From f43e72b74822aab20221a69bc7b70a174586a3c3 Mon Sep 17 00:00:00 2001 From: Danny Willems Date: Tue, 1 Aug 2023 19:06:34 +0200 Subject: [PATCH] run npm run bindings --- compiled/node_bindings/snarky_js_node.bc.cjs | 11 ++++------- compiled/node_bindings/snarky_js_node.bc.map | 2 +- compiled/web_bindings/snarky_js_web.bc.js | 4 ++-- 3 files changed, 7 insertions(+), 10 deletions(-) diff --git a/compiled/node_bindings/snarky_js_node.bc.cjs b/compiled/node_bindings/snarky_js_node.bc.cjs index 6befec0e..f16cf73f 100755 --- a/compiled/node_bindings/snarky_js_node.bc.cjs +++ b/compiled/node_bindings/snarky_js_node.bc.cjs @@ -4824,6 +4824,10 @@ (index,witness_cols,prev_challenges,prev_sgs), proof=caml_pasta_fp_proof_of_rust(res); return proof} + function caml_pasta_fp_plonk_proof_create_and_verify() + {throw new + Error + ("Unimplemented caml_pasta_fp_plonk_proof_create_and_verify")} function caml_pasta_fp_plonk_proof_example_with_ffadd() {throw new Error @@ -7556,13 +7560,6 @@ function(event) {if(event.error)caml_fatal_uncaught_exception(event.error)})} caml_setup_uncaught_exception_handler(); - var - caml_pasta_fp_plonk_proof_create_and_verify= - globalThis.caml_pasta_fp_plonk_proof_create_and_verify !== undefined - ?globalThis.caml_pasta_fp_plonk_proof_create_and_verify - :function() - {caml_failwith - ("caml_pasta_fp_plonk_proof_create_and_verify" + " not implemented")}; function caml_call1(f,a0) {return f.length == 1?f(a0):caml_call_gen(f,[a0])} function caml_call2(f,a0,a1) diff --git a/compiled/node_bindings/snarky_js_node.bc.map b/compiled/node_bindings/snarky_js_node.bc.map index 0c818724..d9d7e51a 100755 --- a/compiled/node_bindings/snarky_js_node.bc.map +++ b/compiled/node_bindings/snarky_js_node.bc.map @@ -1 +1 @@ -{"version":3.0,"file":"snarky_js_node.bc.js","sourceRoot":"","names":["Object","globalThis","this","get","_T_","global","self","DefaultLocale","defaultStrftime","Strftime","isCommonJS","module","namespace","adaptedStrftime","deprecatedStrftime","joo_global_object","eval","_require","_deprecationWarnings","deprecationWarning","name","instead","console","deprecatedStrftimeTZ","deprecatedStrftimeUTC","deprecatedStrftimeLocalized","adaptForwards","fn","fmt","d","locale","undefined","strftime","timezone","null","utcStrftime","Date","customTimezoneOffset","useUtcTimezone","_locale","_customTimezoneOffset","_useUtcBasedDate","_cachedDateTimestamp","_cachedDate","_strftime","format","date","timestamp","currentTimestamp","getTimestampToUtcOffsetFor","_processFormat","resultString","padding","isInScope","length","extendedTZ","i","currentCharCode","padTill2","Math","hours12","padTill3","weekNumber","tzString","y","day","String","ordinal","off","sign","sep","hours","mins","useUtcBasedDate","timezoneType","parseInt","minutes","numberToPad","paddingChar","hour","firstWeekday","weekday","firstDayOfYearUtc","dateUtc","yday","weekNum","number","ii","Base_am_testing","x","caml_mul","a","b","caml_hash_mix_int","h","caml_hash_mix_jsbytes","s","len","w","log2_ok","jsoo_floor_log2","Infinity","caml_int64_offset","caml_raise_constant","tag","caml_global_data","caml_raise_zero_divide","MlInt64","lo","mi","hi","xhi","offset","modulus","divisor","quotient","q","r","caml_int64_create_lo_mi_hi","caml_int64_bits_of_float","isFinite","isNaN","exp","k","r3","r2","r1","caml_int64_lo32","v","caml_int64_hi32","caml_hash_mix_int64","caml_hash_mix_float","v0","caml_str_repeat","n","l","caml_subarray_to_jsbytes","f","caml_convert_string_to_bytes","caml_jsbytes_of_string","caml_hash_mix_string","caml_hash_mix_bytes_arr","jsoo_is_ascii","caml_utf16_of_utf8","t","c","c1","c2","j","MlBytes","contents","content","caml_ml_bytes_content","caml_hash_mix_bytes","caml_int32_bits_of_float","float32a","int32a","caml_int64_to_bytes","caml_ba_serialize","writer","ba","sz","complex","caml_raise_with_string","msg","caml_invalid_argument","caml_ba_get_size_per_element","kind","caml_ba_create_buffer","size","g","view","data","caml_int32_float_of_bits","caml_int64_of_bytes","caml_int64_float_of_bits","NaN","res","caml_ba_get_size","dims","n_dims","caml_int64_create_lo_hi","caml_array_bound_error","caml_ba_custom_name","Ml_Bigarray","layout","buffer","arg","ofs","Array","im","re","total","k1","k2","Ml_Bigarray_c_1_1","caml_ba_create_unsafe","size_per_element","caml_bytes_of_jsbytes","caml_string_of_jsbytes","caml_failwith","caml_ba_deserialize","reader","num_dims","size_dim","size_dim_hi","size_dim_lo","sixty","int64","caml_ba_compare","caml_ba_hash","num_elts","caml_int32_unmarshal","caml_nativeint_unmarshal","caml_int64_unmarshal","caml_int64_marshal","sizes","caml_int64_compare","caml_int64_hash","caml_custom_ops","caml_hash_mix_final","caml_is_ml_bytes","caml_is_ml_string","caml_hash","count","limit","seed","obj","queue","rd","wr","num","hh","Base_hash_double","Base_hash_string","Base_int_math_int32_clz","Base_int_math_int32_ctz","caml_int64_shift_right_unsigned","caml_int64_is_zero","caml_int64_to_int32","Base_int_math_int64_clz","caml_int64_and","caml_int64_of_int32","Base_int_math_int64_ctz","is_zero","land","small_int64","caml_int64_mul","Base_int_math_int64_pow_stub","base","exponent","one","mul","Base_int_math_int_clz","Base_int_math_int_ctz","Base_int_math_int_popcount","Base_int_math_int_pow_stub","Base_int_math_nativeint_clz","Base_int_math_nativeint_ctz","Base_internalhash_fold_float","Base_internalhash_fold_int","Base_internalhash_fold_int64","Base_internalhash_fold_string","Base_internalhash_get_hash_value","incr_nat","nat","carry_in","carry","add_nat","nat1","ofs1","len1","nat2","ofs2","len2","caml_js_from_array","caml_ba_create","dims_ml","bigstring_alloc","_","caml_ml_bytes_length","caml_convert_bytes_to_array","caml_blit_bytes","s1","i1","s2","i2","caml_bytes_of_array","caml_bigstring_blit_ba_to_bytes","ba1","pos1","bytes2","pos2","slice","bigstring_blit_bigstring_bytes_stub","src","src_pos","dst","dst_pos","caml_array_of_bytes","caml_bigstring_blit_bytes_to_ba","str1","ba2","bigstring_blit_bytes_bigstring_stub","caml_ml_string_length","caml_bytes_unsafe_get","caml_string_unsafe_get","caml_array_of_string","caml_bigstring_blit_string_to_ba","bigstring_blit_string_bigstring_stub","caml_bigstring_blit_ba_to_ba","bigstring_blit_stub","caml_bytes_unsafe_set","caml_string_unsafe_set","caml_ba_get_1","i0","bigstringaf_blit_to_bytes","src_off","dst_off","bin_prot_blit_buf_bytes_stub","caml_check_bound","array","index","caml_check_bound_bigstring","bigstring","bin_prot_blit_buf_float_array_stub","bin_prot_blit_float_array_buf_stub","float64","float64_uint8","bin_prot_blit_string_buf_stub","blit_nat","caml_array_append","a1","a2","l1","l2","caml_array_blit","caml_array_concat","caml_array_fill","caml_array_set","newval","caml_array_sub","caml_ba_blit","caml_ba_dim","caml_ba_dim_1","caml_ba_dim_2","caml_ba_get_2","caml_ba_layout","caml_ba_set_1","caml_ba_set_2","caml_ba_sub","changed_dim","new_dims","new_data","caml_ba_uint8_get16","b1","b2","caml_ba_uint8_get32","b3","b4","caml_ba_uint8_get64","b5","b6","b7","b8","caml_ba_uint8_set16","caml_ba_uint8_set32","caml_ba_uint8_set64","caml_backtrace_status","plonk_wasm","require","caml_bigint_256_bytes_per_limb","caml_bigint_256_compare","caml_bigint_256_div","caml_bigint_256_num_limbs","caml_bytes_to_uint8array","ocaml_bytes","bytes","caml_bigint_256_of_bytes","caml_jsstring_of_string","caml_bigint_256_of_decimal_string","caml_bigint_256_of_numeral","caml_bigint_256_print","caml_js_to_bool","caml_bigint_256_test_bit","caml_create_bytes","caml_bytes_of_uint8array","uint8array","caml_bigint_256_to_bytes","caml_utf8_of_utf16","caml_bytes_of_utf16_jsstring","caml_string_of_jsstring","caml_bigint_256_to_string","caml_bytes_of_string","caml_blit_string","e","caml_bswap16","caml_bytes_bound_error","caml_bytes_get","caml_bytes_get16","caml_bytes_set","caml_bytes_set16","i16","caml_bytes_set32","i32","caml_bytes_set64","i64","caml_call_gen","args","argsLen","extra_args","arguments","nargs","caml_classify_float","caml_compare_val_get_custom","caml_compare_val_number_custom","custom","swap","comp","caml_compare_val_tag","Number","caml_int_compare","caml_bytes_compare","caml_string_compare","caml_compare_val","stack","tag_a","tag_b","caml_compare","caml_convert_raw_backtrace","caml_convert_raw_backtrace_slot","caml_div","caml_ephe_key_offset","caml_weak_create","caml_ephe_create","caml_ephe_data_offset","caml_ephe_get_data","caml_ephe_set_data","caml_weak_set","caml_ephe_set_key","caml_equal","caml_fill_bytes","caml_final_register","caml_float_compare","caml_float_of_string","m","m3","mantissa","caml_parse_format","caml_finish_formatting","rawbuffer","caml_format_float","toFixed","dp","prec","p","caml_format_int","rust_affine_to_caml_affine","pt","infinity","js_class_vector_of_rust_vector","klass","pos","caml_array_of_rust_vector","convert","should_free","rust_val","caml_poly_comm_of_rust_poly_comm","poly_comm","rust_shifted","rust_unshifted","caml_shifted","caml_unshifted","caml_vesta_poly_comm_of_rust","caml_u8array_vector_to_rust_flat_vector","inner_len","caml_fp_srs_b_poly_commitment","srs","chals","rust_affine_of_caml_affine","js_class_vector_to_rust_vector","free_finalization_registry","instance_representative","caml_array_to_rust_vector","mk_new","class_val","caml_fp_vector_to_rust","caml_fp_srs_batch_accumulator_check","comms","rust_comms","rust_chals","ok","caml_fp_srs_batch_accumulator_generate","free_on_finalize","caml_fp_srs_create","caml_fp_srs_h","caml_fp_srs_lagrange_commitment","domain_size","caml_fp_srs_read","path","caml_fp_srs_write","append","caml_fp_vector_create","caml_fp_vector_emplace_back","caml_fp_vector_get","value","Error","caml_fp_vector_length","caml_fq_srs_add_lagrange_basis","log2_size","caml_pallas_poly_comm_of_rust","caml_fq_srs_b_poly_commitment","caml_fq_srs_create","caml_fq_srs_h","caml_fq_srs_lagrange_commitment","caml_fq_srs_read","caml_fq_srs_write","caml_fq_vector_create","caml_fq_vector_emplace_back","caml_fq_vector_get","caml_fq_vector_length","caml_oo_last_id","caml_fresh_oo_id","caml_frexp_float","neg","fs_node_supported","make_path_is_absolute","posix","win32","splitDeviceRe","result","device","isUnc","Boolean","root","path_is_absolute","caml_trailing_slash","caml_current_dir","caml_make_path","comp0","ncomp","unix_error","make_unix_err_args","code","syscall","errno","variant","caml_named_values","caml_named_value","nm","caml_raise_with_args","caml_raise_sys_error","caml_raise_no_such_file","MlFile","MlFakeFile","old","buf","clen","new_str","old_data","MlFakeDevice","Symbol","name_slash","mode","raise_unix","parent","RegExp","seen","file","MlNodeFile","fd","err","buf_offset","MlNodeDevice","consts","key","o","js_stats","to_dir","target","link","file_kind","caml_get_root","caml_root","jsoo_mount_point","resolve_fs_device","caml_create_file","jsoo_create_file","caml_fs_init","tmp","caml_gc_quick_stat","caml_get_current_callstack","caml_get_exception_raw_backtrace","caml_method_cache","caml_get_public_method","cacheid","meths","li","caml_greaterequal","caml_greaterthan","caml_hexstring_of_float","style","exp_sign","sign_str","cst","x_str","idx","caml_marshal_data_size","get32","MlStringReader","caml_float_of_bytes","caml_input_value_from_reader","_magic","_block_len","num_objects","_size_32","_size_64","intern_obj_table","obj_counter","intern_rec","header","ops","expected_size","old_pos","caml_string_of_bytes","caml_input_value_from_bytes","caml_ml_channels","caml_input_value","chanid","chan","caml_int32_bswap","caml_int64_add","caml_int64_bswap","caml_int64_div","caml_int64_is_negative","caml_int64_neg","caml_int64_format","wbase","cvtbl","caml_int64_mod","caml_int64_of_float","caml_int64_ult","caml_parse_sign_and_base","caml_parse_digit","caml_int64_of_string","base64","threshold","caml_int64_or","caml_int64_shift_left","caml_int64_shift_right","caml_int64_sub","caml_int64_to_float","caml_int64_xor","caml_int_of_string","caml_js_eval_string","caml_js_wrap_callback","caml_js_wrap_meth_callback","caml_lazy_make_forward","caml_ldexp_float","caml_lessequal","caml_lessthan","caml_lex_array","caml_lex_engine","tbl","start_state","lexbuf","lex_buffer","lex_buffer_len","lex_start_pos","lex_curr_pos","lex_last_pos","lex_last_action","lex_eof_reached","lex_base","lex_backtrk","lex_default","lex_trans","lex_check","state","backtrk","caml_list_of_js_array","caml_log10_float","caml_make_float_vect","caml_make_vect","init","caml_string_of_array","caml_md5_bytes","add","xx","ff","gg","md5","caml_md5_string","caml_ml_channel_size","caml_ml_channel_size_64","caml_sys_close","caml_ml_flush","output","caml_ml_close_channel","caml_ml_debug_info_status","caml_ml_refill_input","str","str_len","caml_ml_input","caml_ml_may_refill_input","caml_raise_end_of_file","caml_ml_input_char","caml_ml_input_int","caml_std_output","slen","js_print_stderr","js_print_stdout","caml_sys_open_internal","flags","info","caml_sys_open","_perms","caml_ml_open_descriptor_in","refill","fs","channel","caml_ml_open_descriptor_out","caml_ml_out_channels_list","caml_ml_output_bytes","string","jsstring","id","caml_ml_output","caml_ml_output_char","caml_ml_output_int","arr","caml_ml_pos_in","caml_ml_pos_in_64","caml_ml_pos_out","caml_ml_pos_out_64","caml_ml_seek_in","caml_ml_seek_in_64","caml_ml_seek_out","caml_ml_seek_out_64","caml_ml_set_binary_mode","caml_ml_set_channel_name","caml_mod","caml_modf_float","caml_lex_run_mem","mem","curr_pos","caml_lex_run_tag","caml_new_lex_engine","lex_mem","lex_base_code","lex_backtrk_code","lex_default_code","lex_trans_code","lex_check_code","lex_code","pc_off","pstate","base_code","caml_notequal","caml_obj_block","caml_obj_make_forward","caml_obj_tag","Function","caml_out_channel_pos_fd","MlObjectTable","NaiveLookup","objs","caml_list_to_js_array","caml_legacy_custom_code","caml_output_val","Writer","no_sharing","closures","memo","existing_offset","extern_rec","sz_32_64","header_pos","type_of_v","caml_output_value_to_buffer","caml_pallas_add","caml_pallas_double","caml_pallas_endo_base","caml_pallas_endo_scalar","caml_pallas_negate","caml_pallas_of_affine_coordinates","caml_pallas_one","caml_pallas_random","caml_pallas_scale","caml_pallas_sub","caml_pallas_to_affine","caml_pasta_fp_add","caml_pasta_fp_copy","caml_pasta_fp_div","caml_pasta_fp_domain_generator","caml_pasta_fp_equal","caml_option_of_maybe_undefined","caml_pasta_fp_inv","caml_pasta_fp_is_square","caml_pasta_fp_mul","caml_pasta_fp_mut_add","caml_pasta_fp_mut_mul","caml_pasta_fp_square","caml_pasta_fp_mut_square","caml_pasta_fp_sub","caml_pasta_fp_mut_sub","caml_pasta_fp_negate","caml_pasta_fp_of_bigint","caml_pasta_fp_of_bytes","caml_pasta_fp_of_int","caml_pasta_fp_of_string","caml_pasta_fp_plonk_circuit_serialize","public_input_size","gate_vector","caml_plonk_wire_to_rust","wire","caml_plonk_wires_to_rust","wires","caml_fp_plonk_gate_to_rust","gate","caml_pasta_fp_plonk_gate_vector_add","caml_pasta_fp_plonk_gate_vector_create","caml_pasta_fp_plonk_gate_vector_digest","caml_plonk_wire_of_rust","caml_plonk_wires_of_rust","caml_u8array_vector_of_rust_flat_vector","output_len","inner_res","caml_plonk_gate_of_rust","caml_pasta_fp_plonk_gate_vector_get","caml_pasta_fp_plonk_gate_vector_len","caml_pasta_fp_plonk_gate_vector_wrap","caml_get_field_of_caml_record","caml_record","caml_fp_runtime_table_cfg_to_rust","caml_runtime_table_cfg","mk_class","caml_runtime_table_cfg_id","caml_runtime_table_cfg_first_column","caml_create_rust_empty_vector","caml_is_empty_caml_array","caml_array","caml_pasta_fp_plonk_index_create","gates","public_inputs","caml_runtime_table_cfgs","prev_challenges","urs","wasm_runtime_table_cfgs","caml_pasta_fp_plonk_index_read","caml_pasta_fp_plonk_index_write","caml_poly_comm_to_rust_poly_comm","poly_comm_class","mk_affine","caml_vesta_poly_comm_to_rust","caml_plonk_domain_to_rust","caml_plonk_verification_evals_to_rust","convertArray","sigma_comm","coefficients_comm","generic_comm","psm_comm","complete_add_comm","mul_comm","emul_comm","endomul_scalar_comm","caml_plonk_verification_shifts_to_rust","caml_plonk_verifier_index_to_rust","domain_class","verification_evals_class","verification_shifts_class","domain","max_poly_size","public_","evals","shifts","caml_pasta_fp_plonk_verifier_index_to_rust","caml_pasta_fp_commitments_to_rust","w_comm","z_comm","t_comm","caml_pasta_fp_opening_proof_to_rust","convert_affines","affines","lr","delta","z1","z2","sg","l_ocaml","r_ocaml","PERMUTS_MINUS_1","COLUMNS","caml_pasta_fp_proof_evaluations_to_rust","caml_pasta_fp_proof_to_rust","commitments","proof","ft_eval1","chals_len","prev_challenges_scalars","prev_challenges_comms","caml_pasta_fp_plonk_proof_batch_verify","indexes","proofs","caml_pasta_fp_commitments_of_rust","caml_pasta_fp_opening_proof_of_rust","tuple","caml_fp_vector_of_rust","caml_pasta_fp_proof_evaluations_of_rust","caml_pasta_fp_proof_of_rust","messages","caml_pasta_fp_plonk_proof_create","witness_cols","prev_sgs","caml_pasta_fp_plonk_proof_example_with_ffadd","caml_pasta_fp_plonk_proof_example_with_lookup","caml_pasta_fp_plonk_proof_example_with_range_check","caml_pasta_fp_plonk_proof_example_with_range_check0","caml_pasta_fp_plonk_proof_example_with_rot","caml_pasta_fp_plonk_proof_example_with_xor","caml_pasta_fp_plonk_proof_verify","column_of_rust","col","gate_type","variable_of_rust","variable","row","polish_token_of_rust","token","wrap","ptr","index_term_of_rust","term","token_class","column","coefficient","linearization_of_rust","linearization","affine_class","F","WasmPolishToken","WasmIndexTerm","constant_term","index_terms","wasmIndexTerm","caml_plonk_domain_of_rust","log_size_of_group","group_gen","caml_plonk_verification_evals_of_rust","affine_klass","caml_plonk_verification_shifts_of_rust","None","caml_plonk_verifier_index_of_rust","lookup_index","caml_pasta_fp_plonk_verifier_index_of_rust","caml_pasta_fp_plonk_verifier_index_create","vk","vk_caml","caml_pasta_fp_plonk_verifier_index_read","caml_pasta_fp_plonk_verifier_index_shifts","caml_pasta_fp_plonk_verifier_index_write","caml_pasta_fp_poseidon_block_cipher","_fake_params","fp_vector","wasm_flat_vector","new_fp_vector","caml_pasta_fp_poseidon_params_create","caml_pasta_fp_print","caml_pasta_fp_random","caml_pasta_fp_rng","caml_pasta_fp_size","caml_pasta_fp_size_in_bits","caml_pasta_fp_sqrt","caml_pasta_fp_to_bigint","caml_pasta_fp_to_bytes","caml_pasta_fp_to_string","caml_pasta_fp_two_adic_root_of_unity","caml_pasta_fq_add","caml_pasta_fq_copy","caml_pasta_fq_div","caml_pasta_fq_domain_generator","caml_pasta_fq_equal","caml_pasta_fq_inv","caml_pasta_fq_is_square","caml_pasta_fq_mul","caml_pasta_fq_mut_add","caml_pasta_fq_mut_mul","caml_pasta_fq_square","caml_pasta_fq_mut_square","caml_pasta_fq_sub","caml_pasta_fq_mut_sub","caml_pasta_fq_negate","caml_pasta_fq_of_bigint","caml_pasta_fq_of_bytes","caml_pasta_fq_of_int","caml_pasta_fq_of_string","caml_pasta_fq_plonk_circuit_serialize","caml_fq_plonk_gate_to_rust","caml_pasta_fq_plonk_gate_vector_add","caml_pasta_fq_plonk_gate_vector_create","caml_pasta_fq_plonk_gate_vector_digest","caml_pasta_fq_plonk_gate_vector_get","caml_pasta_fq_plonk_gate_vector_len","caml_pasta_fq_plonk_gate_vector_wrap","caml_fq_vector_to_rust","caml_fq_runtime_table_cfg_to_rust","caml_pasta_fq_plonk_index_create","caml_pasta_fq_plonk_index_domain_d1_size","caml_pasta_fq_plonk_index_read","caml_pasta_fq_plonk_index_write","caml_pallas_poly_comm_to_rust","caml_pasta_fq_plonk_verifier_index_to_rust","caml_pasta_fq_commitments_to_rust","caml_pasta_fq_opening_proof_to_rust","caml_pasta_fq_proof_evaluations_to_rust","caml_pasta_fq_proof_to_rust","caml_pasta_fq_plonk_proof_batch_verify","caml_pasta_fq_commitments_of_rust","caml_pasta_fq_opening_proof_of_rust","caml_fq_vector_of_rust","caml_pasta_fq_proof_evaluations_of_rust","caml_pasta_fq_proof_of_rust","evals1","caml_pasta_fq_plonk_proof_create","caml_pasta_fq_plonk_proof_verify","caml_pasta_fq_plonk_verifier_index_of_rust","caml_pasta_fq_plonk_verifier_index_create","caml_pasta_fq_plonk_verifier_index_shifts","caml_pasta_fq_print","caml_pasta_fq_random","caml_pasta_fq_rng","caml_pasta_fq_size","caml_pasta_fq_size_in_bits","caml_pasta_fq_sqrt","caml_pasta_fq_to_bigint","caml_pasta_fq_to_bytes","caml_pasta_fq_to_string","caml_pasta_fq_two_adic_root_of_unity","caml_raw_backtrace_slot","caml_record_backtrace","caml_register_global","name_opt","caml_register_named_value","caml_restore_raw_backtrace","exn","bt","caml_set_oo_id","caml_bytes_equal","caml_string_equal","caml_string_bound_error","caml_string_get","caml_string_get16","caml_string_get32","caml_string_get64","caml_bytes_lessequal","caml_string_lessequal","caml_string_greaterequal","caml_bytes_lessthan","caml_string_lessthan","caml_string_greaterthan","caml_string_notequal","caml_argv","main","argv","args2","caml_sys_argv","caml_sys_const_max_wosize","os_type","caml_sys_const_ostype_cygwin","caml_sys_const_ostype_win32","caml_executable_name","caml_sys_executable_name","caml_sys_exit","caml_sys_file_exists","caml_sys_get_config","caml_sys_getcwd","caml_raise_not_found","caml_sys_getenv","caml_sys_isatty","_chan","caml_sys_random_seed","buff","now","caml_sys_remove","caml_sys_system_command","cmd","caml_trampoline","caml_trampoline_return","caml_update_dummy","caml_vesta_add","caml_vesta_double","caml_vesta_endo_base","caml_vesta_endo_scalar","caml_vesta_negate","caml_vesta_of_affine_coordinates","caml_vesta_one","caml_vesta_random","caml_vesta_scale","caml_vesta_sub","caml_vesta_to_affine","caml_return_exn_constant","caml_wrap_exception","num_digits_nat","compare_nat","core_array_unsafe_float_blit","core_array_unsafe_int_blit","core_kernel_gc_minor_words","core_kernel_time_ns_format","time","formatjs","jstring","caml_md5_chan","chan_len","core_md5_fd","ic","MlNat","create_nat","custom_reraise_exn","fallbackMessage","decr_nat","borrow","deferred_bind","deferred","func","newDeferred","anotherDeferred","deferred_map","deferred_return","Promise","deferred_run","deferred_to_promise","deferred_upon_exn","div_helper","z","div_digit_nat","natq","ofsq","natr","ofsr","rem","num_leading_zero_bits_in_digit","shift_left_nat","nbits","shift_right_nat","set_to_zero_nat","nat_of_array","mult_digit_nat","nat3","ofs3","x1","x2","x3","sub_nat","div_nat","quo","expect_test_collector_saved_stderr","expect_test_collector_saved_stdout","expect_test_collector_after_test","vstdout","vstderr","expect_test_collector_before_test","voutput","caml_random_oracles_of_rust","joint_combiner_chal","joint_combiner","joint_combiner_ocaml","caml_oracles_of_rust","fp_oracles_create","lgr_comm","verifier_index","fq_oracles_create","serialize_nat","deserialize_nat","caml_hash_nat","initialize_nat","integers_int32_of_uint32","integers_size_t_size","unit","integers_uint_of_string","max_val","negative","no_digits","ten","max_base_10","UInt32","integers_uint32_of_int64","integers_uint32_of_string","integers_uint16_of_string","integers_uint32_add","integers_uint32_div","integers_uint32_logand","integers_uint32_logor","integers_uint32_logxor","integers_uint32_max","integers_uint32_to_int64","integers_uint32_mul","x_64","y_64","integers_uint32_of_int","integers_uint32_of_int32","integers_uint32_rem","integers_uint32_shift_left","integers_uint32_shift_right","integers_uint32_sub","integers_uint32_to_int","caml_new_string","integers_uint32_to_string","UInt64","integers_uint64_add","integers_uint64_div","integers_uint64_logand","integers_uint64_logor","integers_uint64_logxor","integers_uint64_max","integers_uint64_mul","integers_uint64_of_int","integers_uint64_of_int64","integers_uint64_of_string","integers_uint64_of_uint32","integers_uint64_rem","integers_uint64_shift_left","integers_uint64_shift_right","integers_uint64_sub","integers_uint64_to_int","integers_uint64_to_int64","integers_uint64_to_string","integers_uint8_of_string","integers_uint_size","integers_ulong_size","integers_ulonglong_size","integers_uint8_deserialize","integers_uint16_deserialize","integers_uint32_serialize","integers_uint32_deserialize","integers_uint32_hash","integers_uint32_compare","integers_uint64_compare","integers_uint64_hash","integers_uint64_marshal","integers_uint64_unmarshal","integers_unsigned_init","integers_ushort_size","is_digit_int","is_digit_zero","land_digit_nat","lor_digit_nat","bigInt","BASE","LOG_BASE","MAX_INT","MAX_INT_ARR","smallToArray","DEFAULT_ALPHABET","BigInt","supportsNativeBigInt","Integer","radix","alphabet","caseSensitive","parseValue","parseBase","BigInteger","SmallInteger","NativeBigInt","isPrecise","arrayToSmall","trim","compareAbs","createArray","truncate","l_a","l_b","sum","addAny","addSmall","subtract","a_l","b_l","difference","subtractAny","subtractSmall","small","multiplyLong","product","a_i","b_j","multiplySmall","shiftLeft","multiplyKaratsuba","ac","bd","abcd","useKaratsuba","abs","multiplySmallAndArray","square","a_j","divMod1","divisorMostSignificantDigit","lambda","remainder","quotientDigit","shift","divModSmall","divMod2","part","guess","xlen","highx","highy","check","divModAny","comparison","qSign","mod","mSign","_0","_1","_2","isBasicPrime","millerRabinTest","nPrev","strict","isPrime","bits","logN","iterations","newT","newR","lastT","lastR","powersOfTwo","powers2Length","highestPower2","shift_isSmall","remQuo","bitwise","xSign","ySign","xRem","yRem","xDigit","yDigit","xDivMod","yDivMod","LOBMASK_I","LOBMASK_BI","roughLOB","integerLogarithm","max","min","gcd","lcm","randBetween","low","high","range","digits","toBase","restricted","top","digit","text","absBase","alphabetValues","isNegative","start","parseBaseFromArray","val","pow","stringify","out","left","divmod","toBaseString","zeros","parseStringValue","split","decimalPlace","isValid","parseNumberValue","ml_z_normalize","ml_z_abs","ml_z_add","ml_z_compare","ml_z_div","ml_z_divexact","ml_z_equal","ml_z_fits_int","ml_z_fits_int32","ml_z_format","cas","width","alt","dir","pad","prefix","pre","ml_z_gcd","ml_z_hash","acc","caml_zarith_marshal","block","caml_zarith_unmarshal","negate","ml_z_init","ml_z_logand","ml_z_logor","ml_z_mul","ml_z_neg","ml_z_numbits","upperBound","ml_z_of_bits","base1","ml_z_of_float","f1","ml_z_of_int","ml_z_of_int64","jsoo_z_of_js_string_base","bc","ml_z_of_substring_base","ml_z_pow","ml_z_pred","ml_z_rem","ml_z_shift_left","amt","ml_z_shift_right","ml_z_sign","ml_z_sub","ml_z_succ","ml_z_testbit","ml_z_to_bits","ml_z_to_int","ml_z_fits_int64","ml_z_to_int64","mask","mult_nat","len3","nth_digit_nat","prover_to_json","set_digit_nat","set_digit_nat_native","ms_to_nano","time_now_nanoseconds_since_unix_epoch_or_zero","ms","ms_i63","unix_inet_addr_of_string","caml_fatal_uncaught_exception","throw_errors","collect_strings","caml_setup_uncaught_exception_handler","origin","event","zero$0","y$0","minus_one$0","zero_pos","sub_format","formatting_lit","opt","locfmt","null$0","current_dir_name","parent_dir_name","dir_sep","quotequote","null$1","current_dir_name$0","parent_dir_name$0","dir_sep$0","null$2","current_dir_name$1","parent_dir_name$1","dir_sep$1","module_name","tp_loc","module_name$2","ocaml_lex_tables","m1","m2","m4","h01","the_generic_group$2","mask$0","the_generic_group$3","module_name$13","module_name$14","elided_message","null$3","tp_loc$0","tp_loc$1","tp_loc$2","flags$0","am_recording_environment_varia","name$3","name$4","name$5","name$6","name$7","name$8","name$9","name$10","name$11","name$12","name$13","name$14","name$15","name$16","name$17","name$18","name$19","name$20","name$21","name$22","name$23","ocaml_lex_tables$0","int64$1","golden_gamma","beginning_of_file","err$2","err$1","err$0","tp_loc$3","name$26","tp_loc$4","name$27","loc$2","tp_loc$5","name$28","tp_loc$6","tp_loc$7","name$29","tp_loc$8","tp_loc$9","name$30","tp_loc$10","name$31","name$32","default_seed","default_shrink_attempts","name$55","name$56","name$57","name$58","name$59","name$60","name$61","name$62","name$63","name$64","name$65","name$66","name$67","name$68","name$69","name$70","name$71","name$72","name$73","name$74","name$75","unit_of_time_list","name$77","name$78","name$81","name$80","name$79","module_name$24","tp_loc$13","all$2","name$82","tp_loc$14","name$83","module_name$25","name$84","name$85","suffix$6","suffix","tp_loc$15","module_name$26","module_name$27","suffix$13","module_name$28","name$86","name$87","module_name$29","tp_loc$16","tp_loc$17","atom","record$1","label","ocaml_lex_tables$1","ocaml_lex_tables$2","ocaml_lex_tables$3","name$89","module_name$30","name$90","tp_loc$18","tp_loc$19","tp_loc$20","label$0","pos$0","tp_loc$21","tp_loc$22","tp_loc$23","pos$1","op","tp_loc$24","tp_loc$25","tp_loc$26","tp_loc$27","state$7","state$6","state$5","state$4","state$3","state$2","state$1","state$0","tp_loc$28","feature_flags","actual_feature_flags","tp_loc$29","tp_loc$30","tp_loc$31","tp_loc$32","tp_loc$33","tp_loc$34","tp_loc$35","tp_loc$36","tp_loc$37","tp_loc$38","tp_loc$39","pos$2","tp_loc$40","pos$4","pos$3","slots","slots$0","name$91","n$0","here","tp_loc$41","none$1","arg$0","tp_loc$42","level_bits$0","here$0","here$1","here$2","here$3","here$4","here$5","tp_loc$43","tp_loc$44","tp_loc$45","tp_loc$46","list$1","tp_loc$47","list$2","tp_loc$48","empty$15","v_print_debug_messages_for","environment_variable","job_queue","deferred0","deferred1","monitor","import0","error$0","pos$5","fmt$0","fmt$1","start$0","expected","id$2","pos$10","pos$9","pos$8","pos$7","pos$6","tp_loc$49","state$8","tp_loc$50","tp_loc$51","state$9","tp_loc$52","pos$11","tp_loc$53","tp_loc$54","pos$13","pos$12","tp_loc$55","tp_loc$56","tp_loc$57","tp_loc$58","tp_loc$59","pos$14","pos$17","pos$16","pos$15","name$92","id$3","name$93","id$4","pos$19","pos$18","ast_impl_magic_number","ast_intf_magic_number","right","fmt$4","fmt$5","fmt$6","opt$1","cs","infix_symbols","special_infix_strings","reset_ctxt","ast_impl_magic_number$0","ast_intf_magic_number$0","ast_impl_magic_number$1","ast_intf_magic_number$1","ast_impl_magic_number$2","ast_intf_magic_number$2","ast_impl_magic_number$3","ast_intf_magic_number$3","ast_impl_magic_number$4","ast_intf_magic_number$4","ast_impl_magic_number$5","ast_intf_magic_number$5","ast_impl_magic_number$6","ast_intf_magic_number$6","ast_impl_magic_number$7","ast_intf_magic_number$7","ast_impl_magic_number$8","ast_intf_magic_number$8","ast_impl_magic_number$9","ast_intf_magic_number$9","ast_impl_magic_number$10","ast_intf_magic_number$10","ast_impl_magic_number$11","ast_intf_magic_number$11","pos$20","txt","string_version","string_version$0","string_version$1","string_version$2","string_version$3","string_version$4","string_version$5","string_version$6","string_version$7","string_version$8","string_version$10","string_version$11","flags$2","flags$1","prefix$3","kind$2","vals","prefix$4","warnings","prefix$5","pos$25","pos$24","pos$23","pos$22","pos$21","tp_loc$60","tp_loc$61","tp_loc$62","tp_loc$63","state$11","state$10","tp_loc$64","tp_loc$65","state$12","tp_loc$66","state$17","state$16","state$15","state$14","state$13","tp_loc$67","tp_loc$68","tp_loc$69","tp_loc$70","tp_loc$71","tp_loc$72","tp_loc$73","tp_loc$74","commit_id","commit_date","marlin_commit_id","description$0","pos$32","pos$31","pos$30","pos$29","pos$28","pos$27","pos$26","state$21","initial_prefix","prefix$7","state$20","state$19","state$18","tp_loc$75","tp_loc$76","tp_loc$77","tp_loc$78","tp_loc$79","tp_loc$80","prefix$6","acc$0","state$23","state$22","tp_loc$81","tp_loc$82","tp_loc$83","pos$33","b_010","b_002","pos$35","pos$34","state$24","tp_loc$84","sponge_name","pos$36","description$1","state$26","tp_loc$85","sponge_name$0","pos$40","pos$39","pos$38","pos$37","t2$0","t1$0","t2$1","t1$1","t$7","pos$45","pos$44","pos$43","pos$42","t2$2","t1$2","t2$3","t1$3","pos$41","domains","t$8","pos$61","pos$60","pos$59","pos$58","pos$57","pos$56","pos$55","pos$54","pos$53","pos$52","pos$51","pos$50","pos$49","pos$48","pos$47","pos$46","tp_loc$86","pos$62","tagname","branches","pos$64","pos$63","tp_loc$87","tp_loc$88","pos$65","pos$66","description$2","description$3","tp_loc$89","tp_loc$90","tp_loc$91","tp_loc$92","tp_loc$93","pos$69","message$2","state$29","tp_loc$98","pos$68","message$1","state$28","tp_loc$94","tp_loc$95","tp_loc$96","tp_loc$97","hex_key_odd","hex_key_even","deriver","tp_loc$99","tp_loc$100","tp_loc$101","tp_loc$102","tp_loc$103","tp_loc$104","state$30","tp_loc$105","tp_loc$106","pos$70","cany","v$99","v$100","v$101","v$102","v$103","v$104","ocaml_lex_tables$5","type_kind$0","directive_location","pos$77","pos$76","pos$75","t1$4","t1$5","t1$6","pos$74","pos$73","pos$72","t2$5","t2$6","t2$7","key$1","pos$71","t2$4","introspection_query_raw","pos$81","prefix$8","suffix$14","pos$80","pos$79","pos$78","doc$0","v1","v2","manual","pos$85","pos$84","pos$83","pos$82","state$31","v$105","state$32","tp_loc$107","tp_loc$108","pos$91","pos$90","t2$9","pos$89","pos$88","t2$8","pos$87","pos$86","description$4","compiled","coinbase_amount_string","account_creation_fee_string","genesis_state_timestamp_string","env$1","tp_loc$110","err$3","tp_loc$109","description$5","tp_loc$111","state$33","tp_loc$112","tp_loc$113","description$6","pos$92","tp_loc$114","tp_loc$115","state$35","state$34","tp_loc$116","tp_loc$117","description$7","pos$95","pos$94","state$36","pos$93","tp_loc$118","tp_loc$119","t1$7","empty$35","pos$96","s$2","s$1","s$0","description$8","state$38","state$37","tp_loc$120","tp_loc$121","pos$97","tp_loc$122","tp_loc$123","empty$37","state$41","state$40","state$39","tp_loc$124","tp_loc$125","tp_loc$126","tp_loc$127","tp_loc$128","state$43","state$42","tp_loc$129","tp_loc$130","description$9","description$10","description$11","tp_loc$131","tp_loc$132","tp_loc$133","tp_loc$134","five","state$44","empty_stack_msg","salt_phrase","deriver_name","salt_phrase$0","deriver_name$0","salt_phrase$1","tp_loc$135","state$45","default$9","tp_loc$136","tp_loc$137","description$12","tp_loc$138","pos$102","pos$101","pos$100","pos$99","t2$11","pos$98","t2$10","tp_loc$139","tp_loc$140","tp_loc$141","tp_loc$142","epoch_data$0","dummy_value","tp_loc$143","tp_loc$144","tp_loc$145","tp_loc$146","tp_loc$147","tp_loc$148","tp_loc$149","tp_loc$150","tp_loc$151","tp_loc$152","tp_loc$153","tp_loc$154","tp_loc$155","tp_loc$156","tp_loc$157","tp_loc$158","tp_loc$159","tp_loc$160","tp_loc$161","tp_loc$162","tp_loc$163","tp_loc$164","tp_loc$165","tp_loc$166","tp_loc$167","tp_loc$168","tp_loc$169","tp_loc$170","tp_loc$171","state$50","state$49","state$48","tp_loc$172","description$13","tp_loc$173","tp_loc$174","state$52","state$51","tp_loc$175","description$14","tp_loc$176","state$54","state$53","tp_loc$177","description$15","tp_loc$178","state$59","state$58","state$57","state$56","state$55","tp_loc$179","description$16","description$17","tp_loc$180","tp_loc$181","description$18","tp_loc$182","tp_loc$183","tp_loc$184","tp_loc$185","tp_loc$186","tp_loc$187","tp_loc$188","tp_loc$189","tp_loc$190","tp_loc$191","state$63","state$62","state$61","state$60","description$19","description$20","tp_loc$192","names$1","tp_loc$193","names$2","tp_loc$194","tp_loc$195","state$65","state$64","tp_loc$196","tp_loc$197","pos$104","pos$103","tp_loc$198","tp_loc$199","transaction_id$1","expected_hash$1","transaction_id$0","expected_hash$0","transaction_id","expected_hash","description$21","pos$105","update_failed","kind$3","tp_loc$200","tp_loc$201","tp_loc$202","tp_loc$203","tp_loc$204","tp_loc$205","tp_loc$206","tp_loc$207","tp_loc$208","nsf_tag","min_balance_tag","description$23","description$22","name$99","erase_rel","rest","rest$0","rest$1","rest$2","rest$3","rest$4","rest$5","rest$6","rest$7","ty","rest$8","ty1","rest$9","rest$10","rest$11","rest$12","rest$13","concat_fmtty","fmtty1","fmtty2","ty2","concat_fmt","fmt1","fmt2","pad$0","pad$1","iconv","prec$0","pad$2","iconv$0","prec$1","pad$3","iconv$1","prec$2","pad$4","iconv$2","prec$3","pad$5","fconv","pad$6","chr","fmtty","pad$7","fmtty$0","pad$8","rest$14","rest$15","rest$16","fmting_lit","rest$17","fmting_gen","rest$18","rest$19","char_set","width_opt","rest$20","counter","rest$21","rest$22","ign","rest$23","arity","cur","failwith","invalid_arg","lnot","nan","max_finite_value","max_queue_length","min$0","symbol","char_of_int","bool_of_string","int_to_string","valid_float_lexem","i$0","string_of_float","tl","hd","open_out_gen","perm","open_out","open_out_bin","flush_all","iter","output_string","oc","output_substring","close_out","open_in_gen","open_in_bin","input","unsafe_really_input","ofs$0","len$0","len$1","ofs$1","really_input","really_input_string","prerr_string","symbol$0","str2","exit_function","at_exit","f_yet_to_run","old_exit","new_exit$0","new_exit","success","do_at_exit","exit","retcode","close_in","os_type$0","cygwin","arch_big_endian","num_bits_int","is_block","lazy_tag","object_tag","forward_tag","slot","extension_name","max_ephe_length","raise_undefined","force_lazy_block","blk","closure","empty","append$0","seq1","seq2","next","map","seq","filter_map","seq$0","flat_map","fold_left","acc$1","unfold","u","u$0","some","default$0","map$0","fold","none","iter$0","is_none","map$1","map_error","equal","param$0","nth","l$0","l$1","n$1","rev_append","l1$0","l2$0","l1$1","l2$1","rev","param","accu","accu$0","accu$1","assoc_exn","find_exn","xs","ry","rx","cmp","rev_sort","tl$1","x2$0","x1$0","n1","n2","sort","tl$0","t2","h2","t1","h1","c$0","c$1","c$2","c$3","c$4","c$5","c$6","accu$2","aux","tail","min$1","max$0","to_string$0","is_space","apply1","seplen","is_space$0","i$1","i$2","index_rec","lim","lowercase_ascii$0","capitalize_ascii","uncapitalize_ascii","to_buffer","sx","sy","la","lb","res$0","hd$0","zero","minus_one","succ","pred","abs$0","min$2","max$1","lognot","int32_to_string","succ$0","pred$0","abs$1","bit_not","int64_to_string","y$1","min_nativeint","max_nativeint","nativeint_to_string","engine","sth","with_positions","aux_buffer","read","newlen","newbuf","env","clear_parser","height","create","hl","h$0","hr","bal","lv","ll","lrr","lrv","lrl","rr","rv","rl","rlr","rlv","rll","singleton","add_min_element","add_max_element","join","rh","lh","min_elt","min_elt_opt","max_elt","param$1","max_elt_opt","remove_min_elt","r$0","concat","pres","pres$0","is_empty","remove","union","r2$0","r1$0","inter","split_bis","disjoint","s1$0","s2$0","s2$1","diff","cons_enum","e$0","e$1","compare","e2$2","e1$2","e1","e2","e2$0","e1$0","e2$1","e1$1","subset","for_all","exists","filter","pv","partition","lf","lt","rf","rt","cardinal","elements_aux","elements","find","find_first","v$0","find_first_opt","find_last","find_last_opt","find_opt","try_join","v$1","of_list","sub","l$3","x0","l$4","x0$0","l$5","x0$1","nl","mid","l$2","x4","add_seq","of_seq","seq_of_enum","to_seq","snoc_enum","rev_seq_of_enum","to_rev_seq","to_seq_from","ld","lrd","rld","d$0","min_binding","min_binding_opt","max_binding","max_binding_opt","remove_min_binding","update","data$0","mapi","m$0","add_min_binding","add_max_binding","concat_or_join","merge","d1","d2","d2$0","d1$0","d2$1","d1$1","pvd","fvd","m$1","bindings_aux","bindings","clear","push","pop_opt","top_opt","clear$0","cell","resize","more","old_len","new_len","new_buffer","uchar_utf_8_byte_length_max","new_position","create_char_set","add_in_char_set","str_ind","pad_of_pad_opt","pad_opt","param_format_of_ignored_format","pad_opt$0","pad_opt$1","pad_opt$2","pad_opt$3","pad_opt$4","prec_opt","pad_opt$5","ndec","pad_opt$6","pad_opt$7","pad_opt$8","default_float_precision","buffer_create","init_size","buffer_check_size","overhead","min_len","buffer_add_char","buffer_add_string","buffer_contents","char_of_iconv","string_of_formatting_lit","str$0","bprint_fmtty","sub_fmtty","sub_fmtty$0","symm","trans","rest2","rest2$0","rest2$1","rest2$2","rest2$3","rest2$4","rest2$5","rest2$6","rest2$7","ty2$0","rest2$8","ty22","ty21","fmtty_rel_det","f4","f2","rest2$9","rest2$10","rest2$11","rest2$12","rest2$13","de","ed","af","fa","de$0","ed$0","af$0","fa$0","de$1","ed$1","af$1","fa$1","de$2","ed$2","af$2","fa$2","de$3","ed$3","af$3","fa$3","de$4","ed$4","af$4","fa$4","de$5","ed$5","af$5","fa$5","de$6","ed$6","af$6","fa$6","de$7","ed$7","af$7","fa$7","de$8","ed$8","af$8","fa$8","jd","dj","ga","ag","de$9","ed$9","af$9","fa$9","de$10","ed$10","af$10","fa$10","de$11","ed$11","af$11","fa$11","de$12","ed$12","af$12","fa$12","de$13","ed$13","af$13","fa$13","fmtty_of_precision_fmtty","fmtty_of_padding_fmtty","fmtty_of_custom","arity$0","fmtty_of_fmt","ty_rest","prec_ty","ty_rest$0","prec_ty$0","ty_rest$1","prec_ty$1","ty_rest$2","prec_ty$2","ty_rest$3","prec_ty$3","fmtty$1","fmtty$2","fmtty$3","ty$0","fmtty$4","fmtty$5","type_padding","padty","padty$0","type_padprec","type_ignored_format_substituti","type_format_gen","fmtty_rest","sub_fmtty_rest","sub_fmtty_rest$0","fmtty_rest$0","sub_fmtty_rest$1","sub_fmtty_rest$2","fmtty_rest$1","sub_fmtty_rest$3","fmt$2","sub_fmtty_rest$4","fmtty_rest$2","sub_fmtty_rest$5","fmt$3","sub_fmtty_rest$6","fmtty_rest$3","sub_fmtty_rest$7","sub_fmtty_rest$8","fmtty_rest$4","sub_fmtty_rest$9","sub_fmtty_rest$10","fmtty_rest$5","sub_fmtty_rest$11","sub_fmtty_rest$12","fmtty_rest$6","sub_fmtty_rest$13","fmt$7","sub_fmtty_rest$14","fmtty_rest$7","sub2_fmtty","sub_fmtty_rest$15","sub2_fmtty$0","fmt$8","sub_fmtty_rest$16","fmtty_rest$8","sub2_fmtty$1","sub1_fmtty","sub_fmtty_rest$17","sub2_fmtty$2","sub1_fmtty$0","fmt$9","sub_fmtty_rest$18","fmtty_rest$9","sub_fmtty_rest$19","fmt$10","sub_fmtty_rest$20","fmtty_rest$10","sub_fmtty_rest$21","fmt$11","sub_fmtty_rest$22","fmtty_rest$11","sub_fmtty_rest$23","fmt$12","sub_fmtty_rest$24","fmtty_rest$12","sub_fmtty_rest$25","fmt$13","sub_fmtty_rest$26","fmt_rest","fmt_rest$0","fmt_rest$1","fmt_rest$2","fmt_rest$3","fmt_rest$4","fmt_rest$5","prec$4","fmtty$6","fmt_rest$6","prec$5","prec$6","fmtty$7","fmt_rest$7","prec$7","prec$8","fmtty$8","fmt_rest$8","fmtty$9","fmt_rest$9","fmtty$10","fmt_rest$10","fmtty$11","fmt_rest$11","fmtty$12","fmt_rest$12","fmtty$13","sub_fmtty1","fmt_rest$13","sub_fmtty$1","fmtty$14","fmt$14","fmt_rest$14","fmtty$15","fmt$15","fmt_rest$15","fmtty$16","fmt$16","fmt_rest$16","fmtty$17","fmt$17","fmt_rest$17","formatting_gen","fmtty3","fmt3","str$1","fmt1$0","fmtty2$0","fmt2$0","fmtty3$0","fmt3$0","fmtty_rest$13","fmt_rest$18","fmtty$18","fmt$18","fmtty_rest$14","fmt_rest$19","fmtty$19","fmt$19","fmtty_rest$15","fmt_rest$20","fmtty$20","fmt$20","type_ignored_param_one","fmtty_rest$16","fmtty$21","fmt$21","sub_fmtty$2","sub_fmtty$3","fmtty$22","fmt$22","sub_fmtty$4","type_format","recast","fix_padding","width$0","fix_int_precision","res$1","string_to_caml_string","format_of_fconv","symb","transform_int_alt","put","convert_int","convert_int32","convert_nativeint","convert_int64","convert_float","hex","caml_special_val","string_of_fmtty","make_printf$0","k$0","new_acc","make_printf","make_padding","make_int_padding_precision","p$0","p$1","acc$2","acc$3","acc$4","k$3","kacc","k$1","k$4","k$2","make_ignored_param","make_custom$0","make_invalid_arg","make_from_fmtty$0","make_from_fmtty","make_custom","output_acc","p$2","p$3","p$4","bufput_acc","strput_acc","failwith_message","open_box_of_string","invalid_box","parse_spaces","parse_lword","j$0","j$1","parse_int","wstart","wend","box_name","nstart","nend","indent","exp_end","box_type","make_padding_fmt_ebb","make_padprec_fmt_ebb","fmt_ebb_of_string","legacy_behavior","flag","legacy_behavior$0","invalid_format_message","unexpected_end_of_format","end_ind","invalid_format_without","expected_character","add_literal","lit_start","parse_positive","str_ind$0","str_ind$1","parse_integer","next_ind","incompatible_flag","pct_ind","option","subfmt","compute_int_conv","plus","hash","space","plus$0","hash$0","space$0","search_subformat_end","sub_end","str_ind$2","sub_end$0","str_ind$3","sub_end$1","str_ind$4","str_ind$5","sub_end$2","str_ind$6","str_ind$7","parse_magic_size","str_ind_1","str_ind_2","str_ind_3","parse","parse_good_break","formatting_lit$0","str_ind_4","str_ind_5","parse_tag","is_open_tag","ind","sub_str","sub_fmt","sub_format$0","formatting$0","formatting","parse_flags","minus","set_flag","new_ind","parse_after_padding","parse_literal","parse_after_precision","symb$0","minus$0","parse_conversion","parse_conv","padprec","plus_used","hash_used","space_used","ign_used","pad_used","prec_used","get_plus","get_hash","get_space","get_ign","get_pad","get_prec","get_padprec","get_int_pad","check_no_0","opt_of_pad","width$1","get_pad_opt","get_padprec_opt","fmt_result","ignored$2","counter$0","ignored$6","ignored$7","char_set$1","add_char","add_range","fail_single_percent","parse_char_set_content","parse_char_set_after_char$0","parse_char_set_after_char","reverse","char_set$0","char_set$2","ignored$9","char_format","fmt_rest$21","fmt_rest$22","pad$9","fmt_rest$23","ignored$10","fmt_rest$24","pad$10","fmt_rest$25","sub_fmt$0","fmt_rest$26","ignored$11","ignored$3","ignored$5","ignored$8","space$1","hash$1","plus$2","ignored$4","ignored","ignored$0","ignored$1","plus$1","ign$0","fprintf","bprintf","ksprintf","sprintf","assoc3","y2","y1","split$0","make_symlist","help_action","add_help","speclist","add2","current","bool_of_string_opt","int_of_string_opt","float_of_string_opt","parse_and_expand_argv_dynamic_","allow_expand","anonfun","errmsg","initpos","convert_error","error","progname","doc","spec","follow$0","action","keyword","no_arg$0","follow","no_arg","get_arg$0","get_arg","consume_arg$0","consume_arg","treat_action$0","treat_action","f$0","f$1","r$1","f$2","arg$1","r$2","arg$2","x$0","f$3","arg$3","x$1","r$3","arg$4","x$2","specs","f$4","arg$5","f$5","f$6","f$7","arg$6","newarg","before","after","parse_argv","sth$0","speclist$0","second_word","loop","max_arg_len","kwd","replace_leading_tab","align","completed","ksd","msg$0","cutcol$0","spaces$0","cutcol","kwd_len","spaces","printers","field","other_fields","to_string$1","conv","char$0","line","char$1","line$0","file$0","char$2","line$1","file$1","constructor","convert_raw_backtrace","format_backtrace_slot","is_raise","print_raw_backtrace","outchan","raw_backtrace","backtrace","raw_backtrace_to_string","get_backtrace","register_printer","old_printers","new_printers","errors","default_uncaught_exception_han","status","uncaught_exception_handler","empty_backtrace","handle_uncaught_exception","debugger_in_use","exn$0","raw_backtrace$0","protect","finally$0","work","finally_no_exn","work_exn","work_bt","char_hex","new_state","assign","st1","st2","full_init","seed$0","make$1","make_self_init","copy$1","curval","newval30","init$2","get_state","set_state","ongoing_traversal","flip_ongoing_traversal","params","randomized_default","prng","initial_size","random","clear$2","reset$0","copy_bucketlist","key$0","next$0","copy$2","length$1","resize$0","indexfun","odata","osize","nsize$0","ndata","inplace","indexfun$0","nsize","ndata_tail","cell$0","nidx","match","match$0","iter$4","do_bucket","old_trav","filter_map_inplace_bucket","filter_map_inplace","fold$0","b$0","bucket_length","stats","mbl","histo","to_seq$0","tbl_data","buck","buck$0","buck$1","to_seq_keys","to_seq_values","key_index","bucket","next1","next2","k3","d3","next3","find_all","find_in_bucket","replace","replace_seq","id$0","unknown","pp_enqueue","pp_infinity","pp_output_string","pp_output_newline","format_pp_text","format_string","break_new_line","real_indent","break_line","break_same_line","format_pp_token","size$0","tabs","add_tab","ls","tag_name","marker","breaks","fits","box_type$0","off$0","insertion_point","tabs$0","first","head","tab","off$1","insertion_point$0","width$2","box_type$1","tbox","tag_name$0","marker$0","advance_left","pending_count","enqueue_advance","tok","enqueue_string_as","initialize_scan_stack","queue_elem","set_size","left_total","scan_push","elem","pp_open_box_gen","br_ty","pp_flush_queue","pp_print_as_size","isize","pp","blank_line","display_indent","default_pp_mark_open_tag","default_pp_mark_close_tag","default_pp_print_open_tag","default_pp_print_close_tag","flush","pp_queue","sys_tok","scan_stack","ppf","pp_buffer_size","pp_make_buffer","flush_buffer_formatter","pp_print_list","pp_v","opt$0","pp_sep","vs","compute_tag","tag_acc","output_formatting_lit","output_acc$0","bty","p$5","p$6","strput_acc$0","size$1","flush_standard_formatters","null_char","next_char","ib","peek_char","checked_peek_char","end_of_input","char_count","reset_token","invalidate_current_char","token_string","token_buffer","skip_char","ignore_char","store_char","default_token_buffer_size","create$2","iname","scan_raise_at_end","from_ic","scan_close_ic","eof","bad_input","bad_input_escape","bad_token_length","message","bad_float","bad_hex_float","character_mismatch","ci","check_this_char","check_char","token_char","token_bool","integer_conversion_of_char","token_int_literal","token_float","scan_decimal_digit_star","scan_unsigned_decimal_int","scan_digit_plus","basis","digitp","width$3","is_binary_digit","scan_binary_int","is_octal_digit","scan_octal_int","is_hexa_digit","scan_hexadecimal_int","scan_sign","scan_optionally_signed_decimal","scan_int_conversion","scan_fractional_part","scan_exponent_part","scan_float","precision","precision$0","check_case_insensitive_string","lowercase","scan_hex_float","width$4","width$5","width$6","width$10","width$7","width$8","width$9","scan_caml_float_rest","width_precision","frac_width","scan_caml_float","scan_string","stp","scan_char","hexadecimal_value_of_char","check_next_char","check_next_char_for_char","check_next_char_for_string","scan_backslash_char","c0","get_digit","get_digit$0","c1$0","c2$0","scan_caml_char","find_stop","scan_caml_string","find_stop$0","skip_spaces","scan_chars_in_char_set","scan_indic","scan_chars","ef","get_counter","width_of_pad_opt","stopper_of_formatting_lit","fmting","take_format_readers$0","take_fmtty_format_readers$0","new_k","readers_rest","take_format_readers","fmt$23","fmt$24","fmt$25","take_fmtty_format_readers","make_scanf","readers","scan$0","str_rest","pad_prec_scanf","scan$1","scan$2","scan","scan$3","scan$4","conv$0","scan$5","conv$1","scan$6","conv$2","scan$7","scan$8","fmting_lit$0","str$2","stp$0","str_rest$0","rest$24","rest$25","rest$26","arg_rest","sscanf","apply","args$0","exc","register_exception","initial_object_size","public_method_label","compare$0","compare$1","compare$2","table_count","dummy_met","fit_size","new_table","pub_labels","methods","resize$1","new_size","old_size","new_buck","method_count","inst_var_count","new_method","table","get_method_label","get_method_labels","names","set_method","element","get_method","to_list$0","new_slot","new_variable","to_array","get_variable","create_table","public_methods","tags","met","lab","init_class","inherits","cla","virt_meths$1","concr_meths$0","super$0","vars","virt_meths","concr_meths","virt_meth_labs","concr_meth_labs","tvars","by_name","by_label","hm","vars$0","virt_meths$0","saved_vars","saved_hidden_meths","by_label$0","by_name$0","make_class","pub_meths","class_init","env_init","create_object_opt","obj_0","run_initializers_opt","inits","new_cache","set_methods","clo","clo$0","n$2","n$3","n$4","n$5","n$6","x$3","n$7","x$4","n$8","n$9","x$5","f$8","e$2","n$10","x$6","f$9","n$11","x$7","n$12","x$8","n$13","n$14","e$3","n$15","m$2","x$9","m$3","n$16","m$4","e$4","n$17","m$5","n$18","init_mod_block","loc","comps$0","modu","shape","fn$0","undef","comps","init_mod","update_mod_block","cl","update_mod","generic_basename","is_dir_sep","generic_dirname","is_relative","is_implicit","check_suffix","suff","len_s","len_suf","chop_suffix_opt","filename","len_f","quote","quote_command","stdin","stdout","stderr","basename","dirname","is_dir_sep$0","is_relative$0","is_implicit$0","check_suffix$0","chop_suffix_opt$0","temp_dir_name","quote$0","add_bs","loop$0","loop_bs","quote_cmd_filename","quote_command$0","drive_and_path","dirname$0","drive","basename$0","basename$1","dirname$1","dir_sep$2","is_dir_sep$1","is_relative$1","temp_dir_name$0","quote$1","basename$2","concat$0","prng$0","temp_file_name","temp_dir","rnd","temp_file","try_name","counter$1","create$3","dim","create$4","dim1","dim2","create$5","of_bool","sexp_of_string","sexp_of_ref","sexp_of_a","sexp_of_option","sexp_of_b","sexp_of_list","lst","sexp_of_array","ar","lst_ref","compare$4","exn_id_map","clean_up_handler","old_exn_id_map","new_exn_id_map","add$1","sexp_of_exn","finalise","ephe","find_auto","sexp","exn_to_string","what","of_bool$0","string_of_sexp","int_of_sexp","int32_of_sexp","int64_of_sexp","nativeint_of_sexp","ref_of_sexp","a_of_sexp","option_of_sexp","el","b_of_sexp","b_sexp","a_sexp","list_of_sexp","rev_lst","array_of_sexp","t$0","t_of_sexp$1","get_flc_error","handler","extension_constructor","tuple_of_size_n_expected","stag_no_args","stag_incorrect_n_args","stag_takes_args","nested_list_invalid_sum","empty_list_invalid_sum","unexpected_stag","record_only_pairs_expected","record_superfluous_fields","rev_fld_names","fld_names_str","record_duplicate_fields","record_extra_fields","record_undefined_elements","undefined$0","record_list_instead_atom","no_variant_match","no_matching_variant_found","ptag_incorrect_n_args","cnstr","ptag_takes_args","nested_list_invalid_poly_var","empty_list_invalid_poly_var","empty_type","scale","symbol$1","symbol$2","symbol$3","symbol$4","symbol$5","symbol$6","ascending","descending","equal$1","max$2","min$3","symbol$7","symbol$8","symbol$9","symbol$10","symbol$11","symbol$12","ascending$0","descending$0","compare_int64","equal_int64","max$3","min$4","symbol$13","symbol$14","symbol$15","symbol$16","symbol$17","symbol$18","ascending$1","descending$1","compare_nativeint","equal_nativeint","max$4","min$5","compare_bool","equal_bool","compare$6","compare_float","equal_float","compare_string","equal_string","asr","lor","lsl","lsr","lxor","decr","incr","am_testing","failwithf","getenv","var$0","of_int_exn","of_msb_first","hash_fold_unit","as_int","hash_fold_int32","hash_fold_char","hash_fold_bool","hash_fold_nativeint","hash_fold_option","hash_fold_elem","hash_fold_list","list$0","list","hash_fold_lazy_t","hash_fold_ref_frozen","hash_fold_array_frozen","hash_nativeint","hash_int64","hash_int32","hash_char","hash_int","hash_bool","hash_string","hash_float","hash_unit","compare_state","state_to_string","create$6","run","folder","of_fold","hash_fold_t","hash_fold_t$4","hash_fold_t$7","func$0","t$1","t$2","t$3","t$4","t$5","type_name","compare$11","compare_option","compare_elt","concat$1","ys","num_bits","word_size","formatter","v0$0","v1$0","reraise","to_string$3","protectx","final_exn","protect$0","does_raise","pp$0","raise_without_backtrace","initialize_module","is_alive","return$0","a$0","map_via_bind","ma","symbol_bind","symbol_map","symbol_bind$0","symbol_map$0","symbol_bind$1","symbol_map$1","both","ignore_m","ts","all","all_unit","bind","map$6","bind$0","return$1","map$7","get$0","fst","snd","fst$0","snd$0","fold_result","fold_until","iter$1","return$5","join$1","bits$0","int32","bound","make$3","make_self_init$0","allow_in_tests","assign$0","int$0","bits$1","full_range_int64","bits$2","full_range_int_on_64bits","raise_crossed_bounds","lower_bound","upper_bound","string_of_bound","int$1","bool","init$3","set_state$0","const$0","symbol$43","compare_list","equal_list","derived_map","map2","ta","tb","map3","tc","invariant$1","sexp_of_t","bounds_crossed","lower","upper","lower$0","upper$0","try_with$0","ok_exn","error_s","pass","fail","fail_s","name$0","protect$2","extract_name","alist","first_failure","t_of_sexp$4","sexp_of_t$8","compare$18","hash_fold_t$12","hsv","symbol$45","symbol$46","symbol$47","symbol$48","symbol$49","symbol$50","ascending$6","descending$6","compare$19","equal$4","max$8","min$9","of_string$1","to_string$5","incl","excl","incl$0","excl$0","incl$1","excl$1","incl$2","excl$2","between","clamp_exn","clamp","comparator","validate_lbound","validate_ubound","validate_bound","find_first_satisfying","hi$0","lo$1","lo$0","lo$2","find_last_satisfying","binary_search","how","binary_search_segmented","segment_of","is_left","is_right","unsafe_blit","blit","blito","src_len","sth$1","subo","create_like","length$0","unsafe_blit$0","is_none$0","is_some","equal_option","symbol_bind$2","bind$6","return$9","map$16","join$3","second","other","either","combine","other_loop","return_loop","combine_all","other_loop$0","return_loop$0","combine_all_unit","to_option","with_return$0","ret","combine$1","bind$7","either$0","combine$2","bind$8","iteri","foldi","foldi$0","counti","existsi","for_alli","find_mapi","findi","bind$10","return$11","map$18","create_zero","create$9","get$2","unsafe_set_with_caml_modify","unsafe_set_int_assuming_curren","unsafe_set","old_obj","abs_float","one_ulp","upper_bound_for_int","is_x_minus_one_exact","lower_bound_for_int","min_int_as_float","clamp_unchecked","hash_fold_t$14","t_of_sexp$6","sexp_of_t$11","equal$6","compare$23","comparator$2","compare$25","comparator$4","init$6","convert_failure","to_string","num_bits_nativeint","int_to_int32_trunc","int_to_int32","int_to_int32_exn","int32_to_int_exn","int_to_int64","int64_to_int_trunc","min$11","max$10","int64_is_representable_as_int","int64_to_int","int64_to_int_exn","int_to_nativeint","nativeint_to_int_trunc","nativeint_to_int","nativeint_to_int_exn","int32_to_int64","min$12","max$11","int64_is_representable_as_int3","int64_to_int32_exn","int32_to_nativeint","nativeint_to_int32_exn","nativeint_to_int64","min$28","max$29","to_nativeint_exn","min$13","max$12","int64_is_representable_as_int6","insert_delimiter_every","delimiter","chars_per_delimiter","input_length","has_sign","num_digits","num_delimiters","output_length","input_pos","output_pos","num_chars_until_delimiter","first_digit_pos","insert_delimiter","delimiter$0","make_suffix","to_string_hum","invalid","of_string_with_delimiter","of_string","ocaml_lex_state","ocaml_lex_state$0","body","body$0","int32_positive_overflow_bounds","int_positive_overflow_bounds","int63_on_int64_positive_overfl","int64_positive_overflow_bounds","int64_negative_overflow_bounds","negative_exponent","overflow","pow$0","rval","round_down","round_up","round_towards_zero","to_multiple_of","round_nearest","modulus_minus_remainder","round","int64_popcount","int32_popcount","popcount","popcount$0","t_sexp_grammar","of_float_unchecked","comparator$6","validate_lbound$2","validate_ubound$2","validate_bound$2","validate_positive","validate_non_negative","validate_negative","validate_non_positive","is_positive","is_non_negative","is_negative","is_non_positive","to_string_hum$2","sexp_of_t$13","zero$2","minus_one$2","pp$9","invariant$2","pred$2","succ$2","to_int$2","of_int$0","max_value_30_bits","abs$3","symbol$57","symbol$58","symbol$59","symbol$60","symbol$61","incr$0","decr$0","shift_right","shift_right_logical","shift_left","bit_not$0","bit_or","bit_and","bit_xor","symbol$62","ceil_pow2","floor_pow2","is_pow2","floor_log2","ceil_log2","symbol$63","symbol$64","symbol$65","bswap16","ctz","clz","sexp_of_t$14","symbol$66","symbol$67","symbol$68","symbol$69","symbol$70","symbol$71","equal$7","compare$27","min$14","max$13","ascending$8","descending$8","between$3","clamp_exn$3","clamp$3","comparator$7","validate_lbound$3","validate_ubound$3","validate_bound$3","t_of_sexp_direct","empty$4","to_list$5","mem$4","add$5","remove$2","of_list$3","never_returns","func$4","t_sexp_grammar$0","of_string$11","validate_lbound$6","validate_ubound$6","validate_bound$6","validate_positive$0","validate_non_negative$0","validate_negative$0","validate_non_positive$0","is_positive$0","is_non_negative$0","is_negative$0","is_non_positive$0","sign$0","invariant$3","num_bits$0","shift_right_logical$0","shift_right$0","shift_left$0","bit_xor$0","bit_or$0","bit_and$0","rem$0","symbol$84","to_float","of_float_unchecked$0","of_float","ceil_pow2$0","floor_pow2$0","is_pow2$0","floor_log2$0","ceil_log2$0","between$6","clamp_exn$6","clamp$6","symbol$85","symbol$86","symbol$87","symbol$88","incr$1","decr$1","pow$1","symbol$89","symbol$90","symbol$91","symbol$92","round$0","round_towards_zero$0","round_down$0","round_up$0","round_nearest$0","ctz$0","clz$0","is_empty$5","of_alist_exn$0","set$3","add_exn$1","add$7","change$1","remove$5","nth$5","of_tree$1","of_sorted_array_unchecked$2","of_alist$0","of_iteri$0","of_increasing_iterator_uncheck$2","hash$13","t_sexp_grammar$1","of_string$13","shift_right_logical$1","shift_right$1","shift_left$1","bit_xor$1","bit_or$1","bit_and$1","rem$1","symbol$93","to_float$0","of_float_unchecked$1","num_bits$1","of_float$0","symbol$94","bswap32","bswap48","validate_lbound$7","validate_ubound$7","validate_bound$7","validate_positive$1","validate_non_negative$1","validate_negative$1","validate_non_positive$1","is_positive$1","is_non_negative$1","is_negative$1","is_non_positive$1","sign$1","invariant$4","between$7","clamp_exn$7","clamp$7","symbol$95","symbol$96","symbol$97","symbol$98","incr$2","decr$2","of_int64","to_int64","ceil_pow2$1","floor_pow2$1","is_pow2$1","floor_log2$1","ceil_log2$1","to_string_hum$4","sexp_of_t$21","pp$11","symbol$99","symbol$100","symbol$101","round$1","round_towards_zero$1","round_down$1","round_up$1","round_nearest$1","ctz$1","clz$1","the_group$2","t_sexp_grammar$2","comparator$11","wrap_modulo","invariant$5","symbol$102","symbol$103","neg$2","abs$4","one$0","succ$3","pred$3","min_value$1","max_value$1","lnot$0","land$0","lxor$0","lor$0","lsl$0","asr$0","lsr$0","pow$2","symbol$104","symbol$105","rem$2","popcount$1","to_int64$0","of_int64$0","of_int64_exn","of_int64_trunc","t_of_sexp$10","sexp_of_t$22","compare$33","is_pow2$2","clz$2","ctz$2","floor_pow2$2","ceil_pow2$2","floor_log2$2","ceil_log2$2","the_group$3","t_sexp_grammar$3","func$5","invalid_str","sign_and_signedness","to_string$15","of_string$15","signedness","pos_str","int63","int63$0","bswap16$0","bswap32$0","bswap48$0","float_lower_bound$2","float_upper_bound$2","minus_one$3","one$1","zero$3","num_bits$2","to_float$1","of_float_unchecked$2","of_float$1","validate_lbound$8","validate_ubound$8","validate_bound$8","validate_positive$2","validate_non_negative$2","validate_negative$2","validate_non_positive$2","is_positive$2","is_non_negative$2","is_negative$2","is_non_positive$2","sign$2","between$8","clamp_unchecked$4","clamp_exn$8","clamp$8","symbol$106","incr$3","decr$3","of_int$1","of_int_exn$0","to_int$3","to_int_exn","to_int_trunc","of_int32","of_int32_exn","to_int32","to_int32_exn","to_int32_trunc","of_nativeint$0","of_nativeint_exn","of_nativeint_trunc","to_nativeint$0","to_nativeint_exn$0","to_nativeint_trunc","hash$15","to_string$16","of_string$16","to_string$17","repr","validate_lbound$9","validate_ubound$9","validate_bound$9","func$6","t_sexp_grammar$4","compare_int32","of_string$18","num_bits$3","shift_right_logical$2","shift_right$2","shift_left$2","bit_xor$2","bit_or$2","bit_and$2","rem$3","symbol$110","to_float$2","of_float_unchecked$3","of_float$2","validate_lbound$10","validate_ubound$10","validate_bound$10","validate_positive$3","validate_non_negative$3","validate_negative$3","validate_non_positive$3","is_positive$3","is_non_negative$3","is_negative$3","is_non_positive$3","sign$3","symbol$111","symbol$112","symbol$113","symbol$114","symbol$115","symbol$116","descending$11","min$17","max$16","equal_int32","between$10","clamp_exn$10","clamp$10","invariant$6","symbol$117","symbol$118","symbol$119","symbol$120","incr$4","decr$4","pow$3","symbol$121","ceil_pow2$3","floor_pow2$3","is_pow2$3","floor_log2$3","ceil_log2$3","to_string_hum$6","sexp_of_t$24","pp$14","symbol$122","symbol$123","symbol$124","round$3","round_towards_zero$3","round_down$3","round_up$3","round_nearest$3","ctz$3","clz$3","hash_fold_t$20","hashable","of_key","Key","to_key","max$18","empty$9","height$1","update_height","old_height","new_height","balance","tree","left_node_left","left_node_right","lr_left","lr_right","right_node_left","right_node_right","rl_left","rl_right","set_left","tree$0","set_right","add$8","added","findi_and_call_impl","arg1","arg2","call_if_found","call_if_not_found","if_found","if_not_found","find_and_call","call_if_found$0","call_if_not_found$0","call_if_found$1","call_if_not_found$1","call_if_found$2","call_if_not_found$2","call_if_found$3","call_if_not_found$3","call_if_found$4","call_if_not_found$4","if_not_found$0","remove_min_elt$1","remove$6","removed","fold$11","init$0","rkey","rdata","rkey$0","rdata$0","rkey$1","rdata$1","lkey","ldata","right$0","init$1","data$1","iter$16","mapi_inplace","value$0","clear$4","mem$7","remove$7","length$15","inv$0","inv","left_key","right_key","to_list$7","add$10","iter$18","magnitude","round$5","sexp_of_float","validate$2","validate_positive$5","validate_non_negative$5","validate_negative$5","validate_non_positive$5","create$23","unsafe_blit$4","elide","to_string_list","sexp_of_t$27","initialize_module$0","ocamlrunparam_mentions_backtra","symbol$140","symbol$141","symbol$142","symbol$143","libname_ref","set$5","unset","add_environment_var","libs_to_entries","lookup_rev_lib","libname","force_drop","add_bench","type_conv_path","startpos","endpos","test_spec","entry","empty$10","eval_fail","custom_printf_001","equal_option$0","create$24","eq","xs$1","xs$0","sorted","map$24","uuid","int$2","pair","t_of_sexp$14","of_a","sexp_args$7","v1$5","v0$15","v0$16","v1$6","sexp_args$5","v1$1","v0$11","v0$12","v1$2","sexp_args$1","v0$3","v0$4","sexp_args$2","v0$5","v0$6","sexp_args","sexp_args$4","v0$9","v0$10","field_sexps","sorted_field","duplicates","extra","field_sexp","fvalue","sorted_value","sexp_args$6","v1$3","v0$13","v0$14","v1$4","sexp_args$3","v0$7","v0$8","sexp_args$0","v0$1","v0$2","map$25","to_string$21","v_sorted","bnds","bnds$0","digest_layer","to_digest","to_digest$0","equal$16","opaque","create$25","desc","apply$0","def","recurse","tid","get_poly_variant","annotate","basetype","poly_variant","var$1","apply$1","recurse$0","define","record","create$26","compare$36","a_064","b_065","b_067","a_066","cmp_a","a_068","b_069","b_015","b_013","a_014","b_019","b_017","a_020","b_021","b_023","a_024","b_025","b_027","a_028","b_029","t_031","t_030","t_033","t_032","b_035","a_036","b_037","t_039","t_038","t_041","t_040","a_042","b_043","b_045","a_004","b_005","t_007","t_006","t_009","t_008","a_048","b_049","b_053","b_051","a_054","b_055","b_059","b_057","a_060","b_061","b_063","t_of_sexp$15","equal_t0","var$2","apply$2","recurse$1","get_poly_variant$0","opaque$0","to_digest$1","to_digest$2","annotate$0","basetype$0","tuple$0","poly_variant$0","var$3","recurse$2","apply$3","define$0","record$0","variant$0","create$27","trips","members","lookup","scheme","custom_printf_108","v0$17","v1$7","v0$18","v0$19","v1$8","v1$9","v0$20","v_members","v_loc","v_gid","bnds$1","bnds$2","v1$10","v2$0","is_cyclic_0","via_VR","group","set","visited","trav_tid","trav","ts$0","lookup$0","a_109","b_110","t_112","t_111","t_114","t_113","extend","tenv","depth","look_env","extend_new_tid","def_t","tenv$0","exec","sequence_defining","acc_ys","eval_app","gid","formals","record_or_normal_variant","cyclic","cyclic_no_VR","venv","eval_definition","eval_poly_constr","eval_list","binds","alts","xss","vid","loc$0","custom_printf_115","tid$0","in_group","eval$0","bin_write_unit","bin_write_bool","all_bin_write_small_int","all_bin_write_int16","all_bin_write_int32","bin_write_char","bin_write_int","bin_write_nat0","bin_write_string","new_pos","bin_write_float","bin_write_el","pair$0","bin_write_a","bin_write_b","els_pos$1","els_pos$0","els_pos","els_pos_ref","bin_write_variant_int","bin_write_int_8bit","bin_read_unit","pos_ref","bin_read_bool","safe_bin_read_neg_int8","safe_bin_read_int16","bin_read_nat0","ch","bin_read_bytes","start_pos","bin_read_string","bin_read_char","bin_read_int","bin_read_float","bin_read_int32","bin_read_int64","bin_read_nativeint","bin_read_ref","bin_read_el","bin_read_option","bin_read_pair","bin_read_a","bin_read_b","bin_read_list","dummy_float_buf","max_float_array_length","el$1","maybe_float","el$0","bin_read_variant_int","bin_read_int_8bit","bin_shape_array","pair$1","bin_size_unit","bin_size_bool","bin_size_char","bin_size_int","bin_size_nat0","bin_size_string_or_bytes","size_len","bin_size_string","bin_size_float","bin_size_int32","bin_size_int64","bin_size_el","bin_size_a","bin_size_b","len$2","bin_size_len","total_len","total_len_ref","variant_wrong_type","pair$2","bin_writer_el1","bin_writer_el2","pair$3","bin_reader_el1","bin_reader_el2","pair$4","bin_el1","bin_el2","cnv_writer","cnv","tp_class","cnv_reader","vtag","pre_test_hook","nanoseconds_since_unix_epoch","create$28","binary","may_eof","really_input_exn","input_byte","input_char","already_read","to_read","already_read$0","to_read$0","mach","with_file","binary$0","fail_if_exists$0","perm$0","fail_if_exists","sth$2","value$1","am_recording_value","am_recording","of_string$22","to_string$22","nanos","to_string_with_same_unit","of_string$23","Format","create$29","nested_timer","definition_timer","record_start","record_until","until","gc_stats_after","gc_stats_before","runtime","gc_events","nested$0","nested_timing_events","timing_event","nested","timing_events_to_strings","duration_strings","duration_string","description","compactions","major_collections","minor_collections","to_list","strings","left_column_width","fake_timing_events","print_recorded_timing_events","timing_events","notify_of_overriding","override","timing_events$0","nested_timing_event","uid$0","witness","next$1","cmp$0","same_witness$0","nm1","nm2","uid","typename_of_t","args_labels","ocaml_repr","tyid","traverse","internal_use_only","is_polymorphic","internal_use_only$0","index$0","is_mutable","tyid$0","traverse$0","internal_use_only$1","typename_of_t$0","has_double_array_tag","create$0","internal_use_only$2","typename_of_int","typename_of_int32","typename_of_int64","typename_of_nativeint","typename_of_char","typename_of_float","typename_of_string","typename_of_bytes","typename_of_bool","typename_of_unit","typename_of_option","typename_of_list","typename_of_array","typename_of_lazy_t","typename_of_ref","typename_of_function","typename_of_tuple2","typename_of_tuple3","typename_of_tuple4","typename_of_tuple5","rep","rep$0","rep$1","rep$2","rep$3","rep$4","name$24","b$1","a$1","b$2","a$2","typename_of_t$1","rng","dom","rep$5","rep$6","same_witness$1","r2$1","r2$2","r2$3","r2$4","rng2","dom2","b2$0","a2$0","b1$0","a1$0","b2$1","a2$1","b1$1","a1$1","c2$1","b2$2","a2$2","c1$1","b1$2","a1$2","r2$5","r2$6","r2$7","name2","same$0","same_witness_exn$0","typerep_and_typename_of_int63_","repr_of_poly_variant","hash_variant","double_array_value","double$0","simple","named","of_p1","of_p2","of_p3","typename_of_named","typerep_of_t","v$106","dir_or_error","sexp_of_t$28","v_end_pos","v_start_pos","v_line_start","v_line_number","v_filename","bnds$3","compare$37","of_string$24","expected_length","tests_run","protect$3","current$2","set$7","absolute_filename","unset$0","flushed","upon_unreleasable_issue","get_position","extract_output","ocaml_lex_state$1","ocaml_lex_state$2","relative_filename","with_ic","fname","get_outputs_and_cleanup","last_ofs","next_ofs","outputs","trailing_output","current_test","get_current","save_output","location","save_and_return_output","prev_pos","prev_pos$0","trailing","blocks","final_flush","max_attempts","file_digest","expectations","uncaught_exn_expectation","uncaught_exn","saved_output","run$0","defined_in","inline_test_config","registering_tests_for","return$12","bind$11","to_run","of_int$3","mix_bits","mix64","z$0","z$1","random_int64","create$30","random_state","gamma","odd_gamma","next_int64","bool$0","int64$0","maximum","draw$0","draw","int$3","int32$0","nativeint","unit_float_from_int64","float$0","bits_to_represent","log_uniform","min_bits","max_bits","log_uniform$0","log_uniform$1","log_uniform$2","log_uniform$3","return$13","tf","tx","map$27","map$28","values","weights","value_array","weight","cumulative","choice","lazy_t","of_generator","min_length","max_length","max_length$0","remaining","max_index","let_syntax_267","value_t","list_generic","elt_gen","list_with_length","char_print_uniform","char_uniform","small_int","allow_zero","weighted_low","weighted_high","small_non_negative_int","let_syntax_002","uniform_inclusive","log_uniform_inclusive","non_uniform","inclusive","log_inclusive","uniform_all","quickcheck_generator$0","float_zero_exponent","float_zero_mantissa","float_max_positive_subnormal_v","float_subnormal_exponent","float_min_subnormal_mantissa","float_max_subnormal_mantissa","float_min_normal_exponent","float_max_normal_exponent","float_max_nan_mantissa","float_inf_exponent","float_inf_mantissa","float_nan_exponent","float_min_nan_mantissa","float_num_mantissa_bits","float_normal_mantissa","float_exponent_weighted_low","float_exponent_weighted_high","midpoint","float_exponent","float_zero","let_syntax_004","let_syntax_005","float_subnormal","float_normal","float_infinite","let_syntax_010","let_syntax_011","float_nan","float_matching_classes","quickcheck_generator$1","float_finite_non_zero","lower_inclusive","upper_inclusive","char_gen","let_syntax_033","key_gen","data_gen","keys","keys$0","bigarray1","elts","elts$0","offset$1","offset$0","max_total_size","max_b","b_weighted_low","bigarray2_dim","bigarray2","quickcheck_shrinker","f_inverse","of_shrinker","elt_t","list_t","shrinker","shrink_list","shrink_tree","key_t","data_t","drop_keys","shrink_keys","smaller_key","shrink_data","smaller_data","elt","drop_elts","shrink_elts","smaller_elt","default_config","lazy_nondeterministic_state","with_sample","generator","config","examples","number_of_size_values","remaining_sizes","sequence","run$1","config$0","examples$0","M","error$1","error$2","input$0","shrink_count$1","alternates$2","shrink_count","alternates","shrink_count$0","alternates$0","alternate","alternates$1","with_sample_exn","quickcheck_observer","sizes$0","key_obs","data_obs","elt_obs","length$16","create$31","max_mem_waiting_gc_in_bytes","create$32","unsafe_blit$5","length$17","to_string$23","of_string$25","sexp_of_pos","v_offset","v_col","v_line","sexp_of_range","make_range_incl","last_pos","create$33","initial_pos","reset$2","add_uint16","add_bits","int_buf","add_gen","instr","instr_bits","add_newline","create$34","chunks","chunk","no_more","next_instruction_bits","added_bits","advance","skip","offset_shift","offset_shift_num_bits","skip$0","offset_shift$0","offset_shift_num_bits$0","skip$1","offset_shift$1","offset_shift_num_bits$1","offset_shift$2","skip$2","advance_exn","find$7","sub_sexp_count","loop_list","sexps","loop$1","finalize","find$8","find$9","empty$11","get_many","empty$12","get_single","get_many$0","v_location","v_sub_sexp","v_user_exn","position","initial_state","error_state","rev_chunks","chunk_pos","extra_bits","is_ignoring","is_not_ignoring","raise$0","at_eof","reason","old_parser_exn","current_pos","set_automaton_state","advance$0","advance_eol","newline_offset","add_token_char","add_atom_char","add_quoted_atom_char","check_new_sexp_allowed","is_single","add_pos","add_first_char","eps_add_first_char_hash","start_quoted_string","eps_add_escaped_cr","hex_val","add_dec_escape_char","opening","do_reset_positions","reset_positions","toplevel_sexp_or_comment_added","saved_offset","saved_full_sexps","stack$0","is_top_level","comment_added_assuming_cst","sexp_added","inner_comment_depth","is_comment","make_list","add_comment_to_stack_cst","comment","add_sexp_to_stack_cst","rev_comments","hash_semi_pos","closing","stack$1","end_pos","make_loc","add_non_quoted_atom_pos","eps_push_atom","push_quoted_atom","start_line_comment","end_line_comment","eps_eoi_check","create$35","Stack","tr_00","tr_01","tr_02","tr_03","tr_04","tr_05","tr_06","tr_07","tr_08","tr_09","tr_10","tr_11","tr_12","tr_13","tr_14","tr_15","tr_16","tr_17","tr_18","tr_19","tr_20","tr_21","tr_22","tr_23","tr_24","tr_25","tr_26","tr_27","tr_28","tr_29","tr_30","stack$2","tr_31","tr_32","tr_33","tr_34","tr_35","tr_36","tr_37","tr_38","tr_39","tr_40","tr_41","tr_42","tr_43","tr_44","tr_45","tr_46","tr_47","tr_48","tr_49","tr_50","tr_51","tr_52","tr_53","tr_54","tr_55","tr_56","tr_57","tr_58","tr_59","tr_60","tr_61","tr_62","tr_63","tr_64","tr_65","tr_66","tr_67","tr_68","tr_69","tr_70","tr_71","tr_72","tr_73","tr_74","tr_75","tr_76","tr_77","tr_78","tr_eoi_00","tr_eoi_01","tr_eoi_02","tr_eoi_03","tr_eoi_04","tr_eoi_05","tr_eoi_06","tr_eoi_07","transitions","transitions_eoi","old_parser_approx_cont_states","feed_eoi","feed_substring_unsafe","stop","feed_subbytes_unsafe","match$1","make_value","mode$0","make_value$0","make_value$1","mode$1","make_value$2","mode$2","make_value$3","make_value$4","mode$3","make_value$5","mode$4","make_value$6","make_value$7","mode$5","make_value$8","make_value$9","apply_f","apply_f$0","apply_f$1","to_binable","of_binable","bin_shape_t","of_bigstring","to_bigstring","prefix_with_length","bigstring_length","group$3","bin_shape_t$0","bin_size_t","bin_write_t","bin_writer_t","bin_read_t","vint","bin_read_t$0","bin_reader_t","bin_t","compare$38","a_001","hash_fold_t$21","hash$20","t_of_sexp$16","sexp_of_t$29","group$4","bin_shape_t$1","bin_size_t$0","bin_write_t$0","bin_writer_t$0","bin_read_t$1","bin_read_t$2","bin_reader_t$0","bin_t$0","compare$39","a_003","b_004","hash_fold_t$22","hash$21","t_of_sexp$17","sexp_of_t$30","group$5","bin_shape_t$2","bin_size_t$1","bin_write_t$1","bin_writer_t$1","bin_read_t$3","bin_read_t$4","bin_reader_t$1","bin_t$1","compare$40","a_005","b_006","hash_fold_t$23","hash$22","t_of_sexp$18","atom$0","t_of_sexp$19","sexp_of_t$31","group$6","bin_shape_t$3","bin_size_t$2","size_args","bin_write_t$2","bin_writer_t$2","bin_read_t$5","arg_1","bin_read_t$6","bin_reader_t$2","bin_t$2","compare$41","a_007","b_008","right_010","left_009","hash_fold_t$24","hsv$0","hash$23","t_of_sexp$20","t_of_sexp$21","sexp_of_t$32","group$7","bin_shape_t$4","bin_size_t$3","bin_write_t$3","bin_writer_t$3","bin_read_t$7","bin_read_t$8","bin_reader_t$3","bin_t$3","compare$42","a_011","b_012","right_016","left_015","hash_fold_t$25","hash$24","t_of_sexp$22","sexp_of_t$33","group$8","bin_shape_t$5","bin_size_t$4","bin_write_t$4","bin_writer_t$4","bin_read_t$9","bin_read_t$10","bin_reader_t$4","bin_t$4","compare$43","a_017","b_018","hash_fold_t$26","hash$25","t_of_sexp$23","sexp_of_t$34","group$9","bin_shape_t$6","t_of_sexp","size_of_a","write_a","a_029","b_030","a_031","b_032","group$10","bin_shape_t$7","bin_size_t$8","bin_write_t$8","bin_read_t$17","bin_shape_t$14","failwiths","of_alist","of_alist_report_all_dups","of_alist_or_error","of_alist_exn","of_alist_multi","create_mapped","create_with_key","create_with_key_or_error","create_with_key_exn","variant3","generator_033","generator_034","generator_035","size_040","random_041","size_038","random_039","size_036","random_037","tuple2","generator_166","generator_167","size_168","random_169","tuple3","generator_184","generator_185","generator_186","size_187","random_188","of_hash","list_with_length$0","empty$13","nondeterministic_state","random_state_of_seed","make_seed","make_shrink_count","make_config","trials","shrink_attempts","make_test_m","quickcheck_generator","sexp_of","quickcheck_shrinker$0","random_value","gen","random_sequence","test","testable","test_or_error","test_m","test_distinct_values","distinct_values","actual_count","sexp_of_elt","test_can_generate","sexp_of_value","default_sizes","map_t","set_t","create$39","representative","inner_node","inner","descendants","descendants$0","get$8","union$2","create$40","equal$17","union_find_get_check_no_pendin","check_no_pending_iterations","incr_length","incr_pending_iters","decr_pending_iters","with_iteration_2","with_iteration_3","with_iteration_4","create_aux","is_singleton","value$2","unsafe_split_or_splice","unsafe_split_or_splice_after","unsafe_split_or_splice_before","check_two_nodes_no_pending_ite","split_or_splice_before","insert_before","node","dummy_header","unlink","create$41","iter$20","length$19","fold$13","elt$0","iter$21","length$20","to_list$8","sexp_of_t$35","first$0","insert_empty","new_elt","add$11","remove_one","remove$8","move_to_front","first$1","after_elt","move_to_back","last","sexp_of_key","sexp_of_data","invariant","kv","growth_allowed","ensure_can_modify","lookup_exn","find_map","enqueue","back_or_front","enqueue_back","enqueue_front","enqueue_exn","enqueue_back_exn","enqueue_front_exn","lookup_and_move_to_back_exn","lookup_and_move_to_back","lookup_and_move_to_front_exn","lookup_and_move_to_front","dequeue_with_key","maybe_kv","dequeue_with_key_exn","dequeue_back_with_key","dequeue_back_with_key_exn","dequeue_front_with_key","dequeue_front_with_key_exn","dequeue","dequeue_back","dequeue_front","first_with_key","dequeue_exn","dequeue_back_exn","dequeue_front_exn","count$0","sum$0","min_elt$0","max_elt$0","fold_result$0","fold_until$0","dequeue_all","remove_exn","lookup_and_remove","replace_exn","drop","drop_back","drop_front","sexp_of_t$0","of_data","hash_fold_t$0","bin_size_t$13","bin_write_t$13","bin_read_t$26","bin_read_t$27","t_of_sexp$25","sexp_of_t$36","equal$18","compare$45","hash_fold_t$30","bin_size_t$14","bin_write_t$14","bin_read_t$28","bin_read_t$29","typename_of_t$2","hash_fold_t$31","hash$30","comparator$14","bin_size_t$16","bin_write_t$16","bin_read_t$32","bin_read_t$33","bin_size_t$17","bin_write_t$17","bin_read_t$34","bin_read_t$35","bin_size_t$18","bin_write_t$18","bin_read_t$36","bin_read_t$37","of_string$27","bin_size_t$19","bin_write_t$19","bin_read_t$38","bin_read_t$39","bin_shape_t$38","bin_writer_t$19","bin_reader_t$19","bin_t$19","to_q","group$44","bin_shape_array$1","bin_size_array$0","bin_write_array$0","bin_read_array$1","compare_array","len_a","len_b","equal_array","group$45","bool$1","group$46","bin_shape_char$0","func$7","group$47","bin_shape_float$0","group$48","bin_shape_int","func$8","group$49","bin_shape_list$0","bin_size_list$0","bin_write_list$0","bin_read_list$0","compare_list$0","a_037","b_038","a_039","b_040","equal_list$0","a_041","b_042","a_043","b_044","group$50","bin_shape_option$0","bin_size_option$0","bin_write_option$0","bin_read_option$0","compare_option$0","a_049","b_050","a_051","b_052","equal_option$1","a_053","b_054","a_055","b_056","group$51","bin_shape_string","func$9","group$52","bin_shape_unit$0","group$53","bin_shape_sexp_list","group$54","bin_shape_sexp_option","group$55","bin_shape_t$48","sexp_of_t$37","t_of_sexp$26","compare$46","before_first_transition","to_external","of_external","bin_shape_t$50","group$56","bin_shape_t$51","group$57","bin_shape_t$52","group$58","bin_shape_t$53","compare$47","original_filename","zone","digest","bool_of_int","long$0","int32_of_char","input_long_as_int32","sb1","sb2","sb3","sb4","input_long_as_int","input_long_as_int63","input_long_long_as_int63","int63_of_char","long_long","result$0","result$1","result$2","result$3","result$4","result$5","result$6","input_list","lst$0","input_array","input_regime","utc_offset_in_seconds","is_dst","abbrv_index","abbrv","input_tz_file_gen","input_transition","input_leap_second","utc_local_count","std_wall_count","leap_count","transition_count","type_count","transition_times","transition_indices","regimes","raw_abbrvs","abbrvs","next_index","abbrvs$0","indexed_abbrvs","leap_seconds","regime","new_regime","start_time_in_seconds_since_ep","ltt","default_local_time_type","input_leap_second_gen","time_in_seconds_since_epoch","seconds","read_header","magic","input_tz_file_v1","input_tz_file","zonename","version","x_001","make_zone","of_utc_offset","sexp_of_t$39","likely_machine_zones","utc","name$76","reset_transition_cache","get_regime_exn","effective_start_time","index_lower_bound_contains_sec","index_upper_bound_contains_sec","binary_search_index_of_seconds","transition","index_of_seconds_since_epoch","index$1","index$2","index$3","index$4","index_has_prev_clock_shift","index_has_next_clock_shift","index_prev_clock_shift_time_ex","index_prev_clock_shift_amount_","index_abbreviation_exn","validation_failed","create_exn","raw","to_type_id","sexp_of_t$40","sexp_of_type_id","type_id","type_id1","type_id2","name_of_key","uid_of_key","type_id_name","type_id_uid","sexp_of_t$1","mem_by_id","remove_by_id","add_exn","change_exn","change","orig","to_alist","sexp_of_t$2","invariant$0","empty$0","set$0","mem$0","mem_by_id$0","find$0","find_exn$0","add$0","add_exn$0","change$0","change_exn$0","update$0","remove$0","remove_by_id$0","to_alist$0","find$10","empty$14","race_free_create_loop","make","new_x","create$42","uncurry","group$59","bin_shape_t$54","bin_size_t$23","bin_write_t$24","bin_writer_t$25","bin_read_t$48","bin_read_t$49","bin_reader_t$25","bin_t$25","compare$48","hash_fold_t$33","hash$32","size_018","random_019","size_016","random_017","size_014","random_015","size_012","random_013","size_010","random_011","size_008","random_009","size_006","random_007","to_string$26","of_string_internal","of_int_exn$2","of_string$29","compare$49","comparator$15","hash$33","int63_ten","int63_twenty","int63_billion","digits_of_positive_int63","digits_of_int63_max_value","max_int63_with","billions","digit_of_char","write_1_digit_int","return_tens_and_write_ones","tens","ones","write_2_digit_int","write_3_digit_int","write_4_digit_int","write_5_digit_int","write_6_digit_int","write_7_digit_int","write_8_digit_int","write_9_digit_int","read_1_digit_int","read_2_digit_int","max_scale","check_pos$0","check_write","write_2_digit_int$0","write_3_digit_int$0","write_int63","digits$1","int63$1","custom_printf_003","custom_printf_004","digits$0","check_read","read_1_digit_int$0","read_2_digit_int$0","t_of_sexp$29","sexp_of_t$42","compare$50","hash_fold_t$34","of_int_exn$3","to_int$5","to_binable$1","of_binable$1","bin_size_t$24","bin_write_t$25","bin_read_t$50","bin_read_t$51","bin_shape_t$55","bin_writer_t$26","bin_reader_t$26","bin_t$26","num_months","t_of_sexp$30","all_strings","hash$34","bin_shape_t$56","create0","year","month","all_strings$0","days_in_month","bin_read_t$52","bin_read_t$53","bin_reader_t$27","bin_size_t$25","bin_write_t$26","bin_writer_t$27","bin_t$27","unchecked_value","none$0","to_string$27","parse_year4","parse_day","ensure","month_num","month_abrv","year$0","of_string$30","y_field","m_field","d_field","field_sexp$3","field_sexp$0","field_sexp$1","fvalue$0","field_sexp$2","fvalue$1","d_value","m_value","y_value","t_of_sexp$31","sexp_of_t$43","compare$52","sexp_of_t$44","compare$54","unix_epoch","of_year","of_date","c_10_000","c_14_780","c_3_652_425","to_date","days","ddd","ddd$0","y$2","unix_epoch$0","add_days","gen_incl","quickcheck_generator$3","hash$35","suffixes","am_suffixes","pm_suffixes","find_suffix","suffixes$0","suffixes$1","has_colon","decrement_length_if_ends_in_sp","invalid_string","parse$0","am_or_pm","expect_minutes_and_seconds","hr$1","expect_seconds","subsec_nonzero","subsec_len","subsec_pos","sec","sec$1","nonzero","hr$0","sec$0","subsec_len$0","parse_iso8601_extended","verify","of_binable$2","to_binable$2","t_of_sexp$32","to_string$28","x_abs","of_string$31","float_of_string","group$60","bin_shape_t$57","bin_writer_t$28","bin_reader_t$28","bin_t$28","t_of_sexp$33","format_decimal","tenths","units","compare$55","t_of_sexp$34","sign_field","hr_field","min_field","sec_field","ms_field","us_field","ns_field","field_sexp$7","fvalue$2","field_sexp$4","fvalue$3","field_sexp$5","fvalue$4","field_sexp$6","fvalue$5","ns_value","us_value","ms_value","sec_value","min_value","hr_value","sign_value","sexp_of_t$45","v_ns","v_us","v_ms","v_sec","v_min","v_hr","v_sign","bnds$4","bnds$5","robust_comparison_tolerance","symbol$145","symbol$146","symbol$147","symbol$148","symbol$149","symbol$150","robustly_compare","integral","fractional","nanoseconds","nanoseconds$0","seconds$0","ns","microseconds","us","milliseconds","to_span_since_epoch","divide_by_unit_of_time","unit_of_time","scale_by_unit_of_time","sth$3","sth$4","sth$5","sth$6","span","percent","factor","abs_t","suffix_of_unit_of_time","invalid_string$0","state_is_final","invalid_string$1","magnitude$0","suffix_index","unit_of_time_list$0","unit_of_time$0","float_string","magnitude$1","string_of_float_without_traili","sum$3","sum_t","to_float_string","fixup_unit_of_time","sum_t$0","rem_t","fixup_magnitude","to_int_string_and_sum","unit_span","new_sum_t","new_rem_t","next_magnitude","next_sum_t","next_rem_t","new_sum_t$0","symbol$153","magnitude_string","day_string","hour_string","sum_t$1","minute_string","order_of_magnitude_of_first_di","half_ulp","order_of_magnitude_of_final_di","number_of_digits","decimals","align_decimal","float$1","suffix$7","group$61","bin_shape_t$58","bin_writer_t$29","bin_reader_t$29","bin_t$29","hash$36","t_of_sexp$36","group$62","bin_shape_t$59","bin_writer_t$30","bin_reader_t$30","bin_t$30","t_of_sexp$37","symbol$154","symbol$155","symbol$156","symbol$157","symbol$158","symbol$159","robustly_compare$0","to_span_since_start_of_day","is_valid","of_span_since_start_of_day_unc","span_since_start_of_day_is_val","of_span_since_start_of_day","start_of_next_day","start_of_day","add$12","sub$4","next$3","candidate","prev$0","diff$1","approximate_end_of_day","create$44","ns$0","us$0","ms$0","to_parts$0","to_string_gen","drop_ms","drop_us","drop_us$0","dont_print_us","dont_print_ms","dont_print_s","to_string_trimmed","to_sec_string","to_millisec_string","small_diff","ofday1","ofday2","to_string$30","create_from_parsed","subsec","of_string$33","t_of_sexp$38","sexp_of_t$47","of_string_iso8601_extended","gen_incl$1","gen_uniform_incl$0","quickcheck_generator$4","quickcheck_observer$4","quickcheck_shrinker$3","group$63","bin_shape_t$60","bin_writer_t$31","bin_reader_t$31","bin_t$31","hash$37","t_of_sexp$39","group$64","bin_shape_t$61","bin_writer_t$32","bin_reader_t$32","bin_t$32","t_of_sexp$40","epoch","is_earlier","is_later","of_span_in_seconds","span_in_seconds","of_time_in_seconds","time_in_seconds","time$0","index_of_date_and_ofday","relative","index_offset_from_utc_exn","index_prev_clock_shift_time_ex$0","index_next_clock_shift_time_ex","index_prev_clock_shift_amount_$0","index_next_clock_shift_amount_","abbreviation","index_prev_clock_shift","prev_clock_shift","next_clock_shift","date_and_ofday_of_absolute_tim","offset_from_utc","absolute_time_of_date_and_ofda","abs_diff","of_date_ofday","ofday","of_date_ofday_precise","proposed_time","shift_amount","shift_start","shift_backwards","date_cache","reset_date_cache","set_date_cache","rel","effective_day_start","effective_day_until","cache_start_incl","cache_until_excl","to_ofday","to_date_ofday","to_date_ofday_precise","clock_shift_after","clock_shift_before_or_at","amount","ofday$0","ambiguity","amount$0","from_tz","to_tz","start_time","utc_offset$0","utc_epoch","offset_string","utc_offset","is_utc","to_string_abs_parts","offset_string$0","to_string_abs_trimmed","to_string_abs","to_string_iso8601_basic","to_filename_string","of_filename_string","date$0","ofday$1","of_localized_string","occurrence","before_or_after","first_guess_date","first_guess","increment","ensure_colon_in_offset","offset_length","of_string_gen","default_zone","find_zone","ofday$2","tz","ofday$3","date$1","ofday_to_sec","od","tz$0","utc_offset$1","utc_t","zone_name","gen_uniform_incl","of_synthetic_span_since_epoch","to_synthetic_span_since_epoch","to_absolute","of_absolute","absolute","sec_per_day","to_days_from_epoch","days_from_epoch_approx","ofday_of_days_from_epoch","days_from_epoch","days_from_epoch_in_sec","date_of_days_from_epoch","to_date$0","next_multiple_internal","can_equal_after","interval","base_to_after","can_equal_before","float_ns","group$65","bin_shape_t$62","nanosecond$0","microsecond$0","millisecond$0","second$1","minute$0","hour$0","max_value_for_1us_rounding","min_value_for_1us_rounding","of_int_sec$0","of_sec","to_sec$0","to_int_sec","group$66","bin_shape_t$63","bin_writer_t$33","bin_reader_t$33","bin_t$33","compare$56","number_of_digits_to_write","span_part_magnitude","write_char","write_2_chars","char1","char2","write_digits","write_if_non_empty","nanos_of_millisecond","nanos_of_microsecond","int63_60","int63_24","digits_of_d","digits_of_h","digits_of_m","decimal_unit","decimal_unit_integer","decimal_unit_billionths","decimals_of_decimal_unit","sign_len","d_len","h_len","m_len","digits_len","decimals_len","decimal_unit_len","string_length","int63_10","min_mult10_without_underflow","invalid_string$2","add_without_underflow","min_factor_of","min_days_without_underflow","min_hours_without_underflow","min_minutes_without_underflow","min_seconds_without_underflow","min_milliseconds_without_under","min_microseconds_without_under","min_nanoseconds_without_underf","neg_ns","round_ties_before_negating","has_digit","end_of_digits","digit$0","neg_integer","decimal_pos","end_of_decimals","scale$0","min_without_underflow","neg_integer_ns","neg_nanos_of_part","divisor$0","round_at","numerator","denominator","comparator$17","compare$57","float$2","suffix$0","group$67","bin_shape_t$64","bin_writer_t$34","bin_reader_t$34","bin_t$34","compare$58","hash$38","group$68","bin_shape_t$65","bin_writer_t$35","bin_reader_t$35","bin_t$35","group$69","bin_shape_t$66","create_from_parsed$0","of_string$35","t_of_sexp$42","to_string$32","thousand","sexp_of_t$49","group$70","bin_shape_t$67","bin_writer_t$36","bin_reader_t$36","bin_t$36","group$72","bin_shape_t$69","bin_size_t$26","bin_write_t$27","bin_read_t$54","bin_read_t$55","t_of_sexp$43","sexp_of_t$51","of_format","to_format","create$45","set_exn","get_exn","compare$60","t_of_sexp$44","minor_words_field","promoted_words_field","major_words_field","minor_collections_field","major_collections_field","heap_words_field","heap_chunks_field","live_words_field","live_blocks_field","free_words_field","free_blocks_field","largest_free_field","fragments_field","compactions_field","top_heap_words_field","stack_size_field","forced_major_collections_field","field_sexp$17","fvalue$6","field_sexp$8","fvalue$7","field_sexp$9","fvalue$8","field_sexp$10","fvalue$9","field_sexp$11","fvalue$10","field_sexp$12","fvalue$11","field_sexp$13","fvalue$12","field_sexp$14","fvalue$13","field_sexp$15","fvalue$14","field_sexp$16","fvalue$15","forced_major_collections_value","stack_size_value","top_heap_words_value","compactions_value","fragments_value","largest_free_value","free_blocks_value","free_words_value","live_blocks_value","live_words_value","heap_chunks_value","heap_words_value","major_collections_value","minor_collections_value","major_words_value","promoted_words_value","minor_words_value","sexp_of_t$52","v_forced_major_collections","v_stack_size","v_top_heap_words","v_compactions","v_fragments","v_largest_free","v_free_blocks","v_free_words","v_live_blocks","v_live_words","v_heap_chunks","v_heap_words","v_major_collections","v_minor_collections","v_major_words","v_promoted_words","v_minor_words","bnds$6","arg$7","bnds$7","arg$8","bnds$8","arg$9","bnds$9","arg$10","bnds$10","arg$11","bnds$11","arg$12","bnds$12","arg$13","bnds$13","arg$14","bnds$14","arg$15","bnds$15","compare$61","t_of_sexp$45","minor_heap_size_field","major_heap_increment_field","space_overhead_field","verbose_field","max_overhead_field","stack_limit_field","allocation_policy_field","window_size_field","custom_major_ratio_field","custom_minor_ratio_field","custom_minor_max_size_field","custom_minor_max_size_value","custom_minor_ratio_value","custom_major_ratio_value","window_size_value","allocation_policy_value","stack_limit_value","max_overhead_value","verbose_value","space_overhead_value","major_heap_increment_value","minor_heap_size_value","sexp_of_t$53","v_minor_heap_size","v_major_heap_increment","v_space_overhead","v_verbose","v_max_overhead","v_stack_limit","v_allocation_policy","v_custom_minor_max_size","v_custom_minor_ratio","v_custom_major_ratio","v_window_size","return$14","capture","general","hashable$2","cache_size_bound","hashable$1","cache$0","hashable$0","cache","really_call_f","create$46","initial_length","never_shrink","never_shrink$0","initial_length$0","arr_length","length$21","is_empty$7","assert_not_empty","of_array$3","new_arr","actual_front","actual_back","old_arr","break_pos","get$9","i_from_zero","apparent_front","apparent_back","true_i","max_int","add$15","sub$6","div","rem$5","logand","logor","logxor","shift_left$4","shift_right$4","of_int$4","of_int64$1","to_int64$2","zero$5","one$3","lognot$1","succ$5","pred$5","compare$62","equal$20","max$20","min$20","pp$17","max_int$0","add$16","sub$7","mul$0","div$0","rem$6","logand$0","logor$0","logxor$0","shift_left$5","shift_right$5","of_int$5","of_int64$2","to_int64$3","zero$6","one$4","lognot$2","succ$6","pred$6","compare$63","equal$21","max$21","min$21","pp$18","max_int$1","zero$7","one$5","lognot$3","succ$7","pred$7","compare$64","equal$22","max$22","min$22","pp$19","max_int$2","succ$8","pred$8","compare$65","max$23","min$23","pp$20","of_byte_size","to_binable$3","of_binable$3","to_binable$4","of_binable$4","pp_open_xbox","extra_box","open_tag","close_tag","tag_string","fprint_opt_label","lp","fprint_t","fprint_list_body_stick_left","fprint_list","indent$0","cl$0","sep$0","op$0","base_indent","sep_indent","close_extra$0","open_extra$0","close_extra","open_extra","equal$25","create$47","really_extend","slen0","reqlen","create$48","make_room","shrlen","alloc$0","add_sub","add_substring","write_stringlit","add$17","clear$5","contents$0","json_error","utf8_of_code","maxbits","is_object_or_array","init_lexer","lnum","buf$0","buf$1","write_special","ob","finish_string","json_string_of_string","float_needs_period","tuple$1","variant$1","std","ob$0","s$3","hex$0","write_special$0","finish_string$0","write_string","write_null","write_bool","max_digits","write_digits$0","write_int","float_needs_period$0","iter2$4","f_elt","f_sep","write_t","write_std_json","to_string$34","std$0","read_junk","junk","to_basic","hex$1","write_special$1","finish_string$1","write_string$0","write_null$0","write_bool$0","max_digits$0","write_digits$1","write_int$0","float_needs_period$1","iter2$5","f_sep$0","write_t$0","write_std_json$0","to_string$35","hex$2","custom_error","descr","offs","bol","file_line","read_junk$0","long_error","extra_junk","extract_positive_int","extract_negative_int","newline","read_colon","read_object_sep","read_object_end","read_tuple_sep","read_tuple_end","read_array_sep","read_array_end","finish_string$2","ocaml_lex_state$3","ocaml_lex_state$4","high10","low10","read_ident","finish_comment","read_space","read_json$0","ocaml_lex_read_json_rec","field_name","read_json","field_name$0","cons","finish_variant","read_eof","junk$0","from_lexbuf","stream","from_string$0","typerr","js","assoc","member","to_string$36","read_junk$1","junk$1","symbol_bind$5","symbol$169","map_bind","safe_map","func$10","func$11","var_to_bits","gen$0","equal$26","rhs1","rhs0","lhs1","lhs0","of_interval","canonicalize","a4","a3","disjoint_union_exn","of_intervals_exn","is","is$0","invariant$9","gen_from","min_size","go","gen$1","gen_disjoint_pair","y0","y3","num_bits$5","compare$66","equal$27","symbol$170","symbol$171","of_int$6","symbol$172","symbol$173","symbol$174","symbol$175","to_int_exn$1","to_string$37","of_string$38","shift_left$6","shift_right$6","log_and","log_or","two_to_the_i","compare$67","is_integer_string","char_is_digit","of_string_base","of_string_no_underscores","group$74","bin_shape_t$71","bin_size_t$28","bin_write_t$29","bin_read_t$58","bin_read_t$59","arg_1$0","to_binable$5","of_binable$5","t_of_sexp$46","sexp_of_t$54","bin_size_t$29","bin_write_t$30","bin_read_t$60","bin_read_t$61","bin_shape_t$72","bin_writer_t$37","bin_reader_t$37","bin_t$37","to_string_hum$11","range_at_depth","random_bigint_at_depth","prev_depth","range$0","tolerance_factor","depth$0","int$4","bits$3","extra_bytes","num_bytes","hash$40","to_string$39","char_is_hex_digit","of_hex_string_no_underscores","of_string$40","module_name$31","cvar_of_sexp","of_f","sexp_of_cvar","of_index","var$5","bind$1","return$2","unhandled","fail$0","run$2","label_stack","req","hs","handle","req$1","create_single","request","bind$13","return$15","run$3","map2$4","read_var","value_of_fields","var_to_fields","field_vars","fields","map$30","symbol_bind$6","bind$14","return$16","map$31","join$8","ignore_m$0","all$3","all_unit$0","run$4","rc","rc$0","value$3","cases","add_case","case$0","sexp_of_basic","of_basic","unhandled$0","sexp_of_t$55","t_of_sexp$47","to_basic$0","map$32","v3","Field","get_value","override_label","label_opt","basic","equal$28","boolean$0","r1cs","annotation","unit$0","create$49","get$10","emplace_back","length$22","dummy_vector","get$11","T","make$4","num_inputs","next_auxiliary","system","eval_constraints","log_constraint","with_witness","is_running","eval_constraints$0","as_prover","set_as_prover","set_stack","set_handler","constraint_count","direct","assert_equal","assert_all","assert_square","assert_r1cs","assert","with_label","handle_as_prover","exists_handle","request_witness","mk_lazy","create$50","stack_to_string","eval_constraints_ref","run$5","return$17","map$33","bind$15","symbol_bind$7","symbol_map$2","bind$16","return$18","map$34","join$9","ignore_m$1","all$4","all_unit$1","field_vec_id","pack_field_vec","field_vec","auxiliary_input","t0","handlers","return_typ","auxiliary_output_data","output$0","true_output","auxiliary_input_size","run_and_check_exn","get_one","run_and_check","run_and_check_deferred_exn","run_and_check_deferred","run_unchecked","run_and_check_exn$0","run_and_check$0","check_exn","alloc_var","next_input","store_field_elt","primary_input","collect_input_constraints","input_typ","alloc_input","constraint_system_auxiliary","size_in_field_elements","var_of_fields","retval","circuit","r1cs_h","return_typ$0","checked","checked$0","constraint_system","generate_public_input","value_to_fields","store_field_elt$0","cont0","k0","fields$0","generate_auxiliary_input","primary","generate_witness_conv","auxiliary","read_cvar","output$1","inputs","generate_witness","generate_witness$0","generate_witness_conv$0","constraint_system$0","generate_auxiliary_input$0","generate_public_input$0","generate_witness$1","generate_witness_conv$1","constraint_system$1","run_unchecked$0","run_and_check$1","run_and_check_exn$1","check$0","check_exn$0","snarkless","typ","ref","transport","there","back","transport_var","auxes","num_fields","end_pos$0","fieldss","hlist","spec0","spec0$0","typ1","typ2","typ3","tuple4","typ4","tuple5","typ5","tuple6","typ6","of_hlistable","var_to_hlist","var_of_hlist","value_to_hlist","value_of_hlist","field$0","transport$0","transport_var$0","array$0","hlist$0","tuple2$0","tuple3$0","tuple4$0","tuple5$0","tuple6$0","of_hlistable$0","field_to_int","bs","to_field","of_field","typ$0","to_bits","ith_bit","if$0","then","else$0","t_of_sexp$48","non_empty_tree_of_sexp","tree_of_sexp","implied_root","entry_hash","addr0","path0","addr","let_syntax_001","fetch_and_update_req","prev_path","prev","next_entry_hash","new_root","let_syntax_003","prev_entry_hash","modify_req","get_req","update_req","let_syntax_006","let_syntax_007","let_syntax_008","let_syntax_009","pow2","bigint_num_bits","two_to_the","of_bits","mul_pow_2","multiplied","div_pow_2","divided","divided_of_bits","clamp_to_n_bits","bs$0","bit_length","less","less_or_equal","to_var","constant","tick_n","of_pow_2","ceil_div_pow_2","floor_div","m_divides_n","mod_pow_2","x_div_n","n_x_div_n","set_constraint_logger","clear_constraint_logger","constant$0","all$5","assert$0","exists$1","all$6","join$0","map$2","perform","z_inv","x_inv","y_inv","then$0","true$0","false$0","not","if$1","and_for_square_constraint_syst","x_plus_y","both_false","any","all_zero","to_constant","var_of_value","typ$1","typ_unchecked","num_true","any$0","all$0","any$1","all$1","equal$0","of_cvar","is_true","any$2","exactly_one","not$0","any$3","choose_preimage_unchecked","packing_sum","choose_preimage","lc","choose_preimage_flagged","all_unit$2","all$8","fold_map","any$5","all$9","foldi$1","iteri$0","mapi$0","fold_map$0","existsi$0","exists$0","for_alli$0","for_all$1","two","project","pack","unpack","unpack_flagged","lo_bigint","hi_bigint","gen_uniform","parity","square$0","sqrt","quadratic_nonresidue","sqrt_check","is_square","typf","answer","alpha_packed","alpha","not_all_zeros","lte","gt","gte","non_zero","not_equal","of_binary","eval$1","lt_binary","ys$0","ys$1","lt_bitstring_value","field_size_bits","unpack_full","parity$0","unpack_full$0","unpack_full$1","lt_value","chunk_for_equality","chunk_size","t1_b","t1_a","t2_a","equal$2","equal_expect_true","equal$3","correct_answer","if$2","then_aux","else_aux","else$1","res_aux","res_aux$0","checked_to_unchecked","checked_result","test_equal","unchecked","add_constraint","set_primary_input_size","set_auxiliary_input_size","get_public_input_size","get_rows_len","of_bignum_bigint","to_bignum_bigint","two_to_the_i$0","two_to_the_i$1","negate$0","to_bignum_bigint$0","of_bignum_bigint$0","of_f$0","scratch","context","terms$1","constant$1","to_constant_and_terms","neg_one","linear_combination","terms","var_indices","t_of_sexp$0","basic_field","annotation_field","annotation_value","basic_value","v_annotation","v_basic","fm","constraint_logger","run_as_prover","as_prover$0","old_stack","var2","var1","var2$0","var1$0","var3","var2$1","var1$1","system$0","C","with_handler","store_value","log","at_label_boundary","run_as_prover$0","get_value$0","constraint_count$0","direct$0","next_auxiliary$0","with_handler$0","with_label$0","mk_lazy$0","as_prover$1","add_constraint$0","fake_state","log_constraint$0","sys","constraint_count$1","direct$1","next_auxiliary$1","with_handler$1","with_label$1","mk_lazy$1","as_prover$2","add_constraint$1","ignore_m$2","such_that","such_that$0","compute","request$0","provider","custom_printf_002","symbol_map$3","bind$2","return$3","map$3","join$2","ignore_m$3","all_unit$3","as_prover$3","mk_lazy$2","request_witness$0","exists_handle$0","exists$2","handle$0","handle_as_prover$0","next_auxiliary$2","with_label$2","assert_r1cs$0","assert_square$0","assert_all$0","assert_equal$0","direct$2","constraint_count$2","set_constraint_logger$0","clear_constraint_logger$0","symbol_bind$4","symbol_map$4","bind$3","return$4","map$4","ignore_m$4","all_unit$4","as_prover$4","mk_lazy$3","request_witness$1","request$1","exists_handle$1","exists$3","unhandled$1","handle$1","handle_as_prover$1","next_auxiliary$3","with_label$3","assert$1","assert_r1cs$1","assert_square$1","assert_all$1","assert_equal$1","direct$3","constraint_count$3","functor_counter","active_counters","is_active_functor_id","active","dump","in_prover","in_checked_computation","as_stateful","make_checked","size_in_bits","of_int","print","sub$0","sqrt$0","is_square$0","size_in_bits$0","print$0","random$0","symbol$19","symbol$20","of_string$0","unpack$0","project$0","zero$1","mul$1","square$1","inv$1","is_square$1","sqrt$1","unpack$1","parity$1","choose_preimage_var","symbol$21","symbol$22","equal$5","eval_as_prover","in_prover_block","of_int$2","one$2","sub$1","mul$2","inv$2","square$2","sqrt$2","is_square$2","size_in_bits$1","print$1","random$1","symbol$23","symbol$24","symbol$25","negate$1","symbol$26","symbol$27","symbol$28","symbol$29","unpack$2","project$1","parity$2","run_prover","mark_active","counters","mark_active_deferred","compute$0","lbl","inject_wrapper","finalize_is_running","cached_state","prover_block","this_functor_id","run_checked","shape_tbl","register","path_to_type","ty_decl","shape$0","canonical1","canonical2","create$51","substring","buffer_len","length$23","bytes_for_client_to_commit","offset_in_buffer","apply$5","unsafe_get_char","count_while","lift2","succ1","input1","more1","succ2","input2","more2","symbol$188","symbol$189","more$0","marks","prompt","parser_uncommitted_bytes","parser_committed_bytes","continue$0","demand_input","ensure_suspended","commit","peek_char_fail","satisfy","count_while$0","with_buffer","input_len","count_while1","succ$1","fail$1","string$2","take_while","take_while1","ps","failure_msg","cons$2","many1","steps","max_steps","interpolation","to_int$6","of_int$8","add$18","create$52","N","eq$0","pi","t_plus_n","compare$68","lte_exn","eq_exn","num_commitments_without_degree","to_nat","contr","singleton$0","func$12","length$24","func$13","hhead_off","xss$0","tls","hds","mapn","zip","to_list$9","to_array$4","init$9","map$35","of_list$7","of_list_and_length_exn","of_array_and_length_exn","fold$14","for_all$9","foldi$4","reduce_exn$1","to_yojson","poly_a","of_yojson","for_reader","cnv$0","cnv$1","a_to_b","b_to_a","b_sizer","cnv$2","b_writer","cnv$3","cnv$4","b_reader","cnv$5","sh","to_yojson$0","of_yojson$0","of_list_exn","there$0","back$0","append$5","adds","adds$0","rev$0","split$6","transpose","tails","heads","trim_front","extend_front_exn","dummy","extend_exn","extended","extend_front","bin_shape_t$73","bin_size_t$30","bin_write_t$31","bin_read_t$62","bin_shape_t$74","bin_size_t$31","bin_write_t$32","bin_read_t$63","bin_read_t$64","compare$69","hash_fold_t$37","equal$29","t_of_sexp$49","sexp_of_t$56","bin_shape_t$75","bin_size_t$32","bin_write_t$33","bin_read_t$65","compare$70","hash_fold_t$38","equal$30","to_yojson$1","of_yojson$1","t_of_sexp$50","sexp_of_t$57","compare$71","hash_fold_t$39","equal$31","to_yojson$2","of_yojson$2","t_of_sexp$51","sexp_of_t$58","to_list$10","bin_shape_t$76","bin_size_t$33","bin_write_t$34","bin_read_t$66","compare$72","hash_fold_t$40","equal$32","to_yojson$3","of_yojson$3","t_of_sexp$52","sexp_of_t$59","compare$73","hash_fold_t$41","equal$33","to_yojson$4","of_yojson$4","t_of_sexp$53","sexp_of_t$60","bin_shape_t$77","bin_size_t$34","bin_write_t$35","bin_read_t$67","compare$74","hash_fold_t$42","equal$34","t_of_sexp$54","sexp_of_t$61","compare$75","hash_fold_t$43","equal$35","to_yojson$5","of_yojson$5","t_of_sexp$55","sexp_of_t$62","bin_shape_t$78","bin_size_t$35","bin_write_t$36","bin_read_t$68","compare$76","hash_fold_t$44","equal$36","to_yojson$6","of_yojson$6","t_of_sexp$56","sexp_of_t$63","compare$77","equal$37","t_of_sexp$57","sexp_of_t$64","of_list_exn$0","bin_shape_t$79","bin_size_t$36","bin_write_t$37","bin_read_t$69","compare$78","hash_fold_t$45","equal$38","to_yojson$7","of_yojson$7","t_of_sexp$58","sexp_of_t$65","compare$79","hash_fold_t$46","equal$39","to_yojson$8","of_yojson$8","t_of_sexp$59","sexp_of_t$66","bin_shape_t$80","bin_size_t$37","bin_write_t$38","bin_read_t$70","compare$80","hash_fold_t$47","equal$40","to_yojson$9","of_yojson$9","t_of_sexp$60","sexp_of_t$67","to_yojson$10","poly_f","arg0","symbol$190","group$75","bin_shape_t$81","bin_size_t$38","size_of_f","bin_write_t$39","write_f","bin_writer_t$38","bin_writer_f","bin_read_t$71","bin_read_t$72","bin_reader_t$38","bin_reader_f","bin_t$38","bin_f","versioned","t_of_sexp$61","sexp_of_t$68","compare$81","cmp_f","equal$41","hash_fold_t$48","hash_fold_f","a0","to_yojson$11","symbol$191","t_of_sexp$62","sexp_of_t$69","compare$82","a_009","hash_fold_t$49","map$36","map$37","create$53","equal$42","to_yojson$12","symbol$192","group$76","bin_shape_t$82","bin_size_t$39","bin_write_t$40","bin_writer_t$39","bin_read_t$73","bin_read_t$74","bin_reader_t$39","bin_t$39","versioned$0","t_of_sexp$63","sexp_of_t$70","compare$83","b_020","a_019","equal$43","a_021","b_022","b_024","a_023","hash_fold_t$50","to_yojson$13","symbol$193","t_of_sexp$64","sexp_of_t$71","compare$84","a_025","b_026","b_028","a_027","hash_fold_t$51","typ$2","func$14","map$38","create$54","of_field$0","to_field$0","equal$44","maxes","hash_fold_array","to_option_unsafe","value_exn$1","of_option","symbol$194","map$39","constant_layout_typ","bool_typ","a_typ","dummy_var","bool_typ$0","bool_typ$1","typ$3","group$77","bin_shape_t$83","t_of_sexp$65","range_check0_field","range_check1_field","foreign_field_add_field","foreign_field_mul_field","xor_field","rot_field","lookup_field","runtime_tables_field","runtime_tables_value","lookup_value","rot_value","xor_value","foreign_field_mul_value","foreign_field_add_value","range_check1_value","range_check0_value","to_hlist","runtime_tables","rot","xor","foreign_field_mul","foreign_field_add","range_check1","range_check0","of_hlist","to_data","map$40","group$78","bin_shape_t$84","bin_size_t$40","v25","v24","v23","v22","v21","v20","v19","v18","v17","v16","v15","v14","v13","v12","v11","v10","v9","v8","v7","v6","v5","v4","size$2","size$3","size$4","size$5","size$6","size$7","size$8","size$9","size$10","size$11","size$12","size$13","size$14","size$15","size$16","size$17","size$18","size$19","size$20","size$21","size$22","bin_write_t$41","bin_read_t$75","v_w","v_coefficients","v_z","v_s","v_generic_selector","v_poseidon_selector","v_complete_add_selector","v_mul_selector","v_emul_selector","v_endomul_scalar_selector","v_range_check0_selector","v_range_check1_selector","v_foreign_field_add_selector","v_foreign_field_mul_selector","v_xor_selector","v_rot_selector","v_lookup_aggregation","v_lookup_table","v_lookup_sorted","v_runtime_lookup_table","v_runtime_lookup_table_selecto","v_xor_lookup_selector","v_lookup_gate_lookup_selector","v_range_check_lookup_selector","v_foreign_field_mul_lookup_sel","t_of_sexp$66","w_field","coefficients_field","z_field","s_field","generic_selector_field","poseidon_selector_field","complete_add_selector_field","mul_selector_field","emul_selector_field","endomul_scalar_selector_field","range_check0_selector_field","range_check1_selector_field","foreign_field_add_selector_fie","foreign_field_mul_selector_fie","xor_selector_field","rot_selector_field","lookup_aggregation_field","lookup_table_field","lookup_sorted_field","runtime_lookup_table_field","runtime_lookup_table_selector_","xor_lookup_selector_field","lookup_gate_lookup_selector_fi","range_check_lookup_selector_fi","foreign_field_mul_lookup_selec","field_sexp$25","fvalue$16","field_sexp$18","fvalue$17","field_sexp$19","fvalue$18","field_sexp$20","fvalue$19","field_sexp$21","fvalue$20","field_sexp$22","fvalue$21","field_sexp$23","fvalue$22","field_sexp$24","fvalue$23","foreign_field_mul_lookup_selec$0","range_check_lookup_selector_va","lookup_gate_lookup_selector_va","xor_lookup_selector_value","runtime_lookup_table_selector_$0","runtime_lookup_table_value","lookup_sorted_value","lookup_table_value","lookup_aggregation_value","rot_selector_value","xor_selector_value","foreign_field_mul_selector_val","foreign_field_add_selector_val","range_check1_selector_value","range_check0_selector_value","endomul_scalar_selector_value","emul_selector_value","mul_selector_value","complete_add_selector_value","poseidon_selector_value","generic_selector_value","s_value","z_value","coefficients_value","w_value","t_of_sexp$67","to_hlist$0","range_check_lookup_selector","lookup_gate_lookup_selector","xor_lookup_selector","runtime_lookup_table_selector","runtime_lookup_table","lookup_sorted","lookup_table","lookup_aggregation","rot_selector","xor_selector","foreign_field_mul_selector","foreign_field_add_selector","range_check1_selector","range_check0_selector","endomul_scalar_selector","emul_selector","mul_selector","complete_add_selector","poseidon_selector","generic_selector","coefficients","of_hlist$0","validate_feature_flags","enable_if","range_check_lookup","lookups_per_row_4","lookups_per_row_3","lookups_per_row_2","to_hlist$1","of_hlist$1","map$41","to_list$11","always_present","optional_gates","to_absorption_sequence","to_in_circuit","map$42","to_list$12","group$79","to_hlist$2","public_input","of_hlist$2","to_hlist$3","of_hlist$3","p2","p1","group$80","f_multi","sexp_of_t$72","of_f_multi","v_ft_eval1","v_evals$0","arg$26","bnds$27","of_f_multi$0","v_evals","v_public_input","bnds$24","arg$16","bnds$16","arg$17","bnds$17","arg$18","bnds$18","arg$19","bnds$19","arg$20","bnds$20","arg$21","bnds$21","arg$22","bnds$22","arg$23","bnds$23","arg$24","bnds$25","arg$27","bnds$26","arg$25","bnds$28","to_hlist$4","of_hlist$4","to_hlist$5","of_hlist$5","map$43","f2$0","typ$4","Impl","single","uses_lookup","evals$0","group$81","bin_shape_t$85","fq","bin_size_t$41","size_of_g","size_of_fq","bin_write_t$42","write_g","write_fq","bin_read_t$76","of_g","of_fq","v_lr","v_z_1","v_z_2","v_delta","v_challenge_polynomial_commitm","to_hlist$6","challenge_polynomial_commitmen","z_2","z_1","of_hlist$6","group$82","to_yojson$14","poly_g","symbol$195","group$83","bin_shape_t$86","bin_size_t$42","bin_write_t$43","bin_read_t$77","compare$85","cmp_g","a_357","b_358","a_359","b_360","equal$45","a_361","b_362","a_363","b_364","group$84","bin_shape_t$87","to_hlist$7","aggreg","of_hlist$7","to_hlist$8","of_hlist$8","group$85","sorted_length","bin_shape_t$88","to_hlist$9","of_hlist$9","to_hlist$10","of_hlist$10","typ$6","commitment_lengths","runtime_tables$0","w_lens","wo","fqv","group$86","t_of_sexp$68","of_g$0","of_fqv","sexp$0","field_sexps$2","messages_field","openings_field","duplicates$2","extra$2","tail$2","sexp$1","field_sexps$0","proof_field","evals_field","ft_eval1_field","duplicates$0","extra$0","tail$0","lr_field","z_1_field","z_2_field","delta_field","challenge_polynomial_commitmen$0","delta_value","z_2_value","z_1_value","lr_value","ft_eval1_value","evals_value","proof_value","sexp$2","field_sexps$1","w_comm_field","z_comm_field","t_comm_field","duplicates$1","extra$1","tail$1","aggreg_field","runtime_field","runtime_value","aggreg_value","t_comm_value","z_comm_value","w_comm_value","openings_value","messages_value","group$87","bin_shape_t$89","comm","bin_size_t$43","size_of_comm","bin_write_t$44","write_comm","bin_read_t$78","of_comm","v_sigma_comm","v_coefficients_comm","v_generic_comm","v_psm_comm","v_complete_add_comm","v_mul_comm","v_emul_comm","v_endomul_scalar_comm","t_of_sexp$69","sigma_comm_field","coefficients_comm_field","generic_comm_field","psm_comm_field","complete_add_comm_field","mul_comm_field","emul_comm_field","endomul_scalar_comm_field","endomul_scalar_comm_value","emul_comm_value","mul_comm_value","complete_add_comm_value","psm_comm_value","generic_comm_value","coefficients_comm_value","sigma_comm_value","to_hlist$11","of_hlist$11","map$44","typ$7","num_bits$6","n_lt_2k","pow$6","combine_split_commitments","scale_and_add","xi","without_degree_bound","with_degree_bound","shifted","unshifted","flat","combine_split_evaluations","mul_and_add","evals0","es","fx","to_list$13","to_vector","of_vector","of_list_and_length_exn$0","of_sexpable","of_binable$6","bin_shape_t$90","bin_size_t$44","bin_write_t$45","bin_read_t$79","of_binable$7","map$45","round_constants","mds","pasta_p_legacy","pasta_p_kimchi","pasta_q_kimchi","id$1","make$5","sponge_state","capacity","sponge_state_of_sexp","sexp_of_sponge_state","copy","rate","absorb","squeeze","debug","operation","sponge","fe","to_blocks","field_elems","num_blocks","create_block","global_pos","sexpifier","first_half_rounds_full","block_cipher","sbox","constant_offset","second_half_rounds_full","slots_per_tuple","arch_sixtyfour$0","max_slot","t3","t4","t5","t13","masked_tuple_id_num_bits","max_array_length","tuple_id_mask","init$10","create$55","header_index","tuple_id","header_index_mask","invariant$10","slot_index","first_slot_index","null$4","is_null","is_used","metadata_index","start_of_tuples_index","max_capacity","array_indices_per_tuple","tuple_num_to_header_index","tuple_num","sexp_of_t$73","sexp_of_ty","v_capacity","v_slots_per_tuple","v_length","v_next_id","v_first_free","v_dummy","unsafe_set_header","pointer_is_valid","pointer","header_index$1","header_index$0","is_full","unsafe_add_to_free_list","metadata","set_metadata","create_array","unsafe_init_range","tuple_num$0","create_with_dummy","slots_per_tuple$0","max_capacity$0","grow","capacity$0","old_capacity","next_id","dummy$0","capacity$1","metadata$1","metadata$0","malloc","first_free","get$12","set$9","bin_writer_a","bin_reader_a","bin_a","group$0","t_of_sexp$70","sexp_of_t$74","validate$3","sexp_of_t$76","max_num_bits","invariant$11","of_int$9","symbol$196","symbol$197","pow2$0","num_bits_internal","create_exn$1","ints","extend_to_max_num_bits","ints$0","level_bits_default","to_sexpable$0","alarm_precision","of_sexpable$0","sexp_of_t$78","v_level_bits","v_alarm_precision","bnd","create$56","level_bits","max_num_bits$0","num_keys","add_clamp_to_max","min_key_in_same_slot","min_key_in_same_slot_mask","value$4","next$5","pool","slot$0","min_key_in_same_slot$0","num_levels","min_allowed_key","max_allowed_key","add_elt","pool$1","pool$0","levels","level_index","level","v_elts","v_max_allowed_key$0","v_min_allowed_key$0","v_key","level_index$0","level_index$1","level$0","v_diff_max_min_allowed_key","v_min_key_in_same_slot_mask","v_keys_per_slot","v_bits_per_slot","v_slots_mask","v_bits","v_index","v_min_allowed_key","v_max_allowed_key","v_slots","interval_num_internal","interval_num_unchecked","interval_num_start_unchecked","interval_num","default$1","sexp_of_t$79","v_how_to_dump","v_dump_if_delayed_by","t_of_sexp$73","sexp_of_t$80","equal$46","x_003","x_004","t_of_sexp$74","sexp_of_t$81","t_of_sexp$75","sexp_of_t$82","timing_wheel_config","thread_pool_cpu_affinity","report_thread_pool_stuck_for","record_backtraces","print_debug_messages_for","min_inter_cycle_timeout","max_num_jobs_per_priority_per_","max_num_threads","max_num_open_file_descrs","max_inter_cycle_timeout","file_descr_watcher","epoll_max_ready_events","dump_core_on_job_delay","detect_invalid_access_from_thr","check_invariants","abort_after_thread_pool_stuck_","timing_wheel_config$0","thread_pool_cpu_affinity$0","report_thread_pool_stuck_for$0","record_backtraces$0","print_debug_messages_for$0","min_inter_cycle_timeout$0","max_num_jobs_per_priority_per_$0","max_num_threads$0","max_num_open_file_descrs$0","max_inter_cycle_timeout$0","file_descr_watcher$0","epoll_max_ready_events$0","dump_core_on_job_delay$0","detect_invalid_access_from_thr$0","check_invariants$0","abort_after_thread_pool_stuck_$0","default_timing_wheel_config_fo","level_bits$1","alarm_precision$0","default_timing_wheel_config","default$2","v_timing_wheel_config","v_report_thread_pool_stuck_for","v_record_backtraces","v_min_inter_cycle_timeout","v_max_num_jobs_per_priority_pe","v_max_num_threads","v_max_num_open_file_descrs","v_max_inter_cycle_timeout","v_file_descr_watcher","v_epoll_max_ready_events","v_dump_core_on_job_delay","v_detect_invalid_access_from_t","v_check_invariants","v_abort_after_thread_pool_stuc","usage","to_sexp","name1","bnd$0","bnd$1","v$2","bnd$2","v$3","bnd$3","v$4","bnd$4","v$5","bnd$5","v$6","bnd$6","v$7","bnd$7","v$8","bnd$8","v$9","bnd$9","v$10","bnd$10","v$11","bnd$11","v$12","bnd$12","v$13","bnd$13","v$14","bnd$14","check_invariants_field","dump_core_on_job_delay_field","epoll_max_ready_events_field","file_descr_watcher_field","max_inter_cycle_timeout_field","max_num_open_file_descrs_field","max_num_threads_field","min_inter_cycle_timeout_field","print_debug_messages_for_field","record_backtraces_field","report_thread_pool_stuck_for_f","thread_pool_cpu_affinity_field","timing_wheel_config_field","alarm_precision_field","level_bits_field","capacity_field","num_key_bits","alarm_precision_value","sexp$3","sexp$4","dump_if_delayed_by_field","how_to_dump_field","how_to_dump_value","dump_if_delayed_by_value","timing_wheel_config_value","thread_pool_cpu_affinity_value","report_thread_pool_stuck_for_v","record_backtraces_value","print_debug_messages_for_value","min_inter_cycle_timeout_value","max_num_threads_value","max_num_open_file_descrs_value","max_inter_cycle_timeout_value","file_descr_watcher_value","epoll_max_ready_events_value","dump_core_on_job_delay_value","check_invariants_value","print_debug_messages_for$1","debug$0","symbol$198","check_invariants$1","max_num_jobs_per_priority_per_$1","record_backtraces$1","normal","sexp_of_one","v_is_detached","v_has_seen_error","v_id","v_here","v_name","loop$2","has_seen_error","is_detached","ac$0","sexp_of_t$83","create_with_parent","dummy_e","dummy_f","dummy_a","create_array$0","create$57","none$2","is_none$1","is_some$1","create$59","enqueue$0","execution_context","priority","new_capacity","old_jobs","old_front","new_jobs","create$60","time_source","max_level_min_allowed_key","bits_per_slot","keys_per_slot","diff_max_min_allowed_key","levels$0","tw","prev_level_max_allowed_key","num_levels$0","min_allowed_key_before","desired_min_allowed_key","level_min_allowed_key","level_min_allowed_key$0","slots$1","max_allowed_key$0","alarm","job_pool","from","to","at","current_execution_context","set_prev","set_next","create$61","create2","run1","execution_context1","run2","execution_context2","enqueue$1","scheduler","schedule_jobs","add$19","squash","indir","execution_context$0","bind_result","bind_rhs","bind_result$0","ivar","ivar$0","last1","last2","handler1","execution_context2$0","run2$0","handler1$0","fill_if_empty","to_binable$6","of_binable$8","map$46","bind$18","map$47","bind$19","map$48","both$0","symbol_map$5","choices","unregisters","choices$0","choices$1","handler$0","handler$1","monitor$0","backtrace_history","monitor$1","name$1","backtrace$0","backtrace$1","traces","backtrace$2","list_if_not_empty","return$20","bind$20","map$49","return$21","apply$6","map$50","return$22","equal$47","combine$3","sexp_of_t$85","v_pipe_id","v_values_read","values_sent_downstream","values_sent_downstream_and_flu","when_sent_downstream","fill_with_eof","sexp_of_t$86","v_ready","v_fill_when_num_values_read","fill$2","sexp_of_pipe","of_phantom","v_info","v_buffer","v_size_budget","v_pushback","v_num_values_read","v_read_closed","v_closed","v_blocked_reads","v_blocked_flushes","v_consumers","v_upstream_flusheds","v_consumer","v_wants","is_closed","length$25","is_empty$9","sexp_of_phantom","id_ref","update_pushback","close","close$0","values_were_read","consumer","consumer$0","flush_result","consume_one","consume","ensure_consumer_matches","start_read","gen_read_now","values_available","downstream_flushed","ready","expect","got","create$63","length$26","sub$8","copy$4","init$11","be32_to_cpu","le32_to_cpu","be64_to_cpu","le64_to_cpu","benat_to_cpu","cpu_to_benat","blit_from_bigstring","cpu_to_be32","cpu_to_be64","be32_to_cpu$0","le32_to_cpu$0","be64_to_cpu$0","le64_to_cpu$0","benat_to_cpu$0","cpu_to_benat$0","imin","size_of_long","xor_into","invalid_arg$0","ror64","dup","ctx","param_to_bytes","iv","max_outlen","increment_counter","inc","sigma","compress","a_idx","b_idx","c_idx","d_idx","feed$0","in_off","in_len","fill","unsafe_feed_bytes","unsafe_feed_bigstring","with_outlen_and_key","outlen","param_bytes","with_outlen_and_bytes_key","with_outlen_and_bigstring_key","unsafe_get$0","ror32","dup$0","iv$0","max_outlen$0","increment_counter$0","sigma$0","compress$0","feed$1","unsafe_feed_bytes$0","unsafe_feed_bigstring$0","with_outlen_and_key$0","with_outlen_and_bytes_key$0","with_outlen_and_bigstring_key$0","unsafe_get$1","dup$1","init$12","f3","md5_do_chunk","feed$2","to_fill","unsafe_feed_bytes$1","unsafe_feed_bigstring$1","unsafe_get$2","padlen","rol32","dup$2","init$13","g$0","jj","fff","ggg","hhh","iii","jjj","rmd160_do_chunk","eee","ccc","bbb","aaa","ee","dd","cc","bb","aa","feed$3","unsafe_feed_bytes$2","unsafe_feed_bigstring$2","unsafe_get$3","rol32$0","dup$3","init$14","f1$0","f4$0","f3$0","k4","sha1_do_chunk","feed$4","unsafe_feed_bytes$3","unsafe_feed_bigstring$3","unsafe_get$4","ror32$0","dup$4","init$15","sha256_do_chunk","feed$5","unsafe_feed_bytes$4","unsafe_feed_bigstring$4","unsafe_get$5","init$16","unsafe_get$6","dup$5","unsafe_feed_bytes$5","unsafe_feed_bigstring$5","rol64","dup$6","init$17","mdlen","rsize","keccaft_rndc","keccaft_rotc","keccakf_piln","sha3_keccakf","rotc","bc$0","masks","feed$6","get_uint8","unsafe_feed_bytes$6","unsafe_feed_bigstring$6","unsafe_get$7","ror64$0","dup$7","init$18","sha512_do_chunk","feed$7","unsafe_feed_bytes$7","unsafe_feed_bigstring$7","unsafe_get$8","init$19","unsafe_get$9","dup$8","unsafe_feed_bytes$8","unsafe_feed_bigstring$8","init$20","init$21","init$22","init$23","dup$9","init$24","whirlpool_do_chunk","i$3","wp_op","get_k","m0","feed$8","unsafe_feed_bytes$9","unsafe_feed_bigstring$9","unsafe_get$10","digest_size","block_size","len$3","unsafe_feed_string","unsafe_get","chr$0","chr1","chr2","have_first","ln","bl","feed_bytes","feed_string","feed_bigstring","feedi_bytes","feed","feedi_string","feedi_bigstring","digest_bytes","digest_string","digest_bigstring","digesti_bytes","digesti_string","digesti_bigstring","digestv_bytes","digestv_string","digestv_bigstring","bytes_opad","bytes_ipad","norm_bytes","bigstring_opad","bigstring_ipad","norm_bigstring","hmaci_bytes","outer","hmaci_string","ctx$0","hmaci_bigstring","hmac_bytes","hmac_string","hmac_bigstring","hmacv_bytes","bufs","hmacv_string","hmacv_bigstring","maci_bytes","maci_string","maci_bigstring","mac_bytes","mac_string","mac_bigstring","macv_bytes","macv_string","macv_bigstring","digest_size$0","module_of","b2b","b2s","read$0","ds","of_char_exn","to_int$7","decode","encode","byte$0","to_hex$0","charify","hexified","to_u4","actual","not_implemented","to_binable$7","of_binable$9","empty$16","group$88","bin_shape_t$91","path$0","log$1","internal","empty_quartiles","allocation_times","now$0","get_lifetime_ms","mean","indices","lifetimes","q1","q2","q3_offset","q3","q4","compute_statistics","run_test","time_offsets","expected_quartiles","message$0","comparator$0","comparator$1","message$3","comparator$3","table$0","attach_finalizer","object_id","info_opt","data_opt","statistics","block_on_async_exn","to_deferred","promise","map$51","bind$21","return$23","return$24","map$52","get$13","t_of_sexp$76","accs_field","bits_field","ss_field","base_field","n_prev_field","n_next_field","n_next_value","n_prev_value","base_value","ss_value","bits_value","accs_value","map$53","n_next","n_prev","ss","accs","group$89","bin_shape_t$92","bin_size_t$45","bin_write_t$46","bin_read_t$80","v_inner","to_yojson$15","of_yojson$10","t_of_sexp$77","inner_field","inner_value","sexp_of_t$87","compare$86","equal$48","hash_fold_t$52","typ$8","map$54","y_squared","t_004","t_003","t_005","t_010","t_012","t_011","e0","hsv$1","hash_fold_t$1","to_backend","of_backend","to_affine_or_infinity","to_affine_exn","of_affine","find_y","point_near_x","g_vec","or_infinity_to_backend","or_infinity_of_backend","with_degree_bound_to_backend","commitment","without_degree_bound_to_backen","of_backend_with_degree_bound","shifted$0","of_backend_without_degree_boun","tuple15_to_vec","w14","w13","w12","w11","w10","w9","w8","w7","w6","w5","w4","w3","w2","w1","w0","tuple15_of_vec","group$90","poly_fq","xs$2","xs$3","v_challenges","v_commitment","challenges_field","commitment_field","commitment_value","challenges_value","a_013","b_014","to_latest","hash_fold_array$0","poly_fqv","poly_g$0","fields$11","fields$1","fields$2","fields$3","fields$4","fields$5","fields$6","fields$7","fields$8","fields$9","fields$10","x$10","x$11","fields$12","x$12","fields$13","x$13","fields$14","fields$15","fields$16","fields$17","fields$18","fields$19","fields$20","fields$21","fields$22","fields$23","fields$24","xs$16","xs$17","arg1$2","arg0$2","xs$18","arg24","arg23","arg22","arg21","arg20","arg19","arg18","arg17","arg16","arg15","arg14","arg13","arg12","arg11","arg10","arg9","arg8","arg7","arg6","arg5","arg4","arg3","xs$13","xs$6","xs$5","xs$4","xs$12","xs$11","xs$10","xs$9","xs$8","xs$7","xs$19","x$17","x$16","x$15","x$14","xs$15","xs$14","xs$25","x$23","state$25","xs$24","x$22","xs$23","x$21","xs$22","x$20","xs$21","x$19","xs$20","x$18","arg2$1","arg1$1","arg0$1","arg2$0","arg1$0","arg0$0","size_of_fqv","v2$1","v3$0","write_fqv","v_w_comm","v_z_comm","v_t_comm","v_lookup","v_aggreg","v_runtime","v_messages","v_proof","v_openings","version$0","cmp_g$1","cmp_g$0","a_467","b_468","n$32","n$29","a_403","b_404","a_405","b_406","n$30","a_407","b_408","n$31","a_409","b_410","a_411","b_412","a_413","b_414","a_415","b_416","a_379","b_380","a_381","b_382","cmp_fqv","cmp_fq$0","cmp_fq","a_297","b_298","a_469","b_470","n$27","n$23","a_263","b_264","t_266","t_265","t_268","t_267","n$24","n$25","n$26","a_299","b_300","t_302","t_301","t_304","t_303","n$28","a_033","b_034","a_035","b_036","a_045","b_046","a_047","b_048","a_057","b_058","n$19","a_059","b_060","n$20","a_061","b_062","n$21","a_063","b_064","n$22","a_065","b_066","a_067","b_068","t_of_sexp$2","arg$31","bnds$29","bnds$37","bnds$30","arg$28","arg$29","arg$30","bnds$31","arg$32","bnds$38","bnds$32","arg$33","bnds$33","arg$34","bnds$34","arg$35","bnds$35","arg$36","bnds$36","arg$37","bnds$39","hsv$33","hash_fold_fqv","hsv$29","hsv$30","hsv$31","hsv$32","hash_fold_g","hsv$24","hsv$25","hsv$26","hsv$27","hsv$28","hash_fold_a","hsv$2","hsv$3","hsv$4","hsv$5","hsv$6","hsv$7","hsv$8","hsv$9","hsv$10","hsv$11","hsv$12","hsv$13","hsv$14","hsv$15","hsv$16","hsv$17","hsv$18","hsv$19","hsv$20","hsv$21","hsv$22","hsv$23","a_477","b_478","a_419","b_420","a_421","b_422","a_423","b_424","a_425","b_426","a_427","b_428","a_429","b_430","a_431","b_432","a_385","b_386","a_387","b_388","a_309","b_310","a_479","b_480","a_271","b_272","t_274","t_273","t_276","t_275","a_311","b_312","t_314","t_313","t_316","t_315","a_071","b_072","a_073","b_074","a_075","b_076","a_077","b_078","a_079","b_080","a_081","b_082","a_083","b_084","a_085","b_086","a_087","b_088","a_089","b_090","a_091","b_092","a_093","b_094","a_095","b_096","a_097","b_098","a_099","b_100","a_101","b_102","a_103","b_104","a_105","b_106","a_107","b_108","map_creator","openings","json","to_latest$0","fq_array_to_vec","vec","opening_proof_of_backend_exn","gpair","g2","g1","eval_of_backend","evals_to_tuple","zeta_omega","zeta","gs","eval_to_backend","vec_to_array","V","chal_polys","pcwo","lr$0","evals_of_tuple","challenges","to_backend$0","create$1","pk","create_async","create_and_verify_async","batch_verify","logger","vks_and_v","batch_verify$0","prev_challenge","pi$0","scalar_challenge","beta","digest_before_evaluations","p_eval_1","p_eval_2","opening_prechallenges","columns","permutation_cols","map$55","s3","yr","xr","n_acc","yp","xp","yt","xt","map$56","x7","x6","x5","a8","b0","n8","n0","bin_shape_t_tagged","read_version","all_tag_versions","bin_read_all_tagged_to_latest","saved_pos","pos_ref$0","domain_generator","over","t_of_sexp$78","compare$87","compare$88","cmp_row","to_rust_wire","t_of_sexp$79","of_v","field_sexps$12","l_field","r_field","o_field","c_field","duplicates$12","extra$12","tail$7","field_sexp$52","field_sexp$41","field_sexp$42","fvalue$36","field_sexp$43","fvalue$37","field_sexp$44","fvalue$38","field_sexp$45","fvalue$39","field_sexp$46","fvalue$40","c_value","o_value","r_value","l_value","field_sexps$4","state_field","duplicates$4","extra$4","state_value","field_sexps$11","p1_field","p2_field","p3_field","inf_field","same_x_field","slope_field","inf_z_field","x21_inv_field","duplicates$11","extra$11","tail$6","field_sexp$51","field_sexp$32","field_sexp$33","fvalue$28","field_sexp$34","fvalue$29","field_sexp$35","fvalue$30","field_sexp$36","fvalue$31","field_sexp$37","fvalue$32","field_sexp$38","fvalue$33","field_sexp$39","fvalue$34","field_sexp$40","fvalue$35","x21_inv_value","inf_z_value","slope_value","same_x_value","inf_value","p3_value","p2_value","p1_value","field_sexps$8","state_field$0","duplicates$8","extra$8","tail$3","state_value$0","field_sexps$9","state_field$1","xs_field","ys_field","n_acc_field","duplicates$9","extra$9","tail$4","field_sexp$50","field_sexp$26","field_sexp$27","field_sexp$28","fvalue$24","field_sexp$29","fvalue$25","xt_field","yt_field","xp_field","yp_field","xr_field","yr_field","s1_field","s3_field","b1_field","b2_field","b3_field","b4_field","b4_value","b3_value","b2_value","b1_value","s3_value","s1_value","yr_value","xr_value","n_acc_value","yp_value","xp_value","yt_value","xt_value","field_sexp$30","fvalue$26","ys_value","xs_value","state_value$1","field_sexps$10","state_field$2","duplicates$10","extra$10","tail$5","field_sexp$31","fvalue$27","n0_field","n8_field","a0_field","b0_field","a8_field","b8_field","x0_field","x1_field","x2_field","x3_field","x4_field","x5_field","x6_field","x7_field","x7_value","x6_value","x5_value","x4_value","x3_value","x2_value","x1_value","x0_value","b8_value","a8_value","b0_value","a0_value","n8_value","n0_value","state_value$2","field_sexps$5","w0_field","w1_field","w2_field","w3_field","w4_field","w5_field","w6_field","duplicates$5","extra$5","field_sexp$49","w6_value","w5_value","w4_value","w3_value","w2_value","w1_value","w0_value","field_sexps$3","v0_field","v0p0_field$0","v0p1_field$0","v0p2_field","v0p3_field","v0p4_field","v0p5_field","v0c0_field","v0c1_field","v0c2_field","v0c3_field","v0c4_field","v0c5_field","v0c6_field","v0c7_field","compact_field","duplicates$3","extra$3","iter$2","compact_value","v0c7_value","v0c6_value","v0c5_value","v0c4_value","v0c3_value","v0c2_value","v0c1_value","v0c0_value","v0p5_value","v0p4_value","v0p3_value","v0p2_value","v0p1_value$0","v0p0_value$0","v0_value","v2_field","v12_field","v2c0_field","v2p0_field","v2p1_field","v2p2_field","v2p3_field","v2c1_field","v2c2_field","v2c3_field","v2c4_field","v2c5_field","v2c6_field","v2c7_field","v2c8_field","v2c9_field","v2c10_field","v2c11_field","v0p0_field","v0p1_field","v1p0_field","v1p1_field","v2c12_field","v2c13_field","v2c14_field","v2c15_field","v2c16_field","v2c17_field","v2c18_field","v2c19_field","v2c19_value","v2c18_value","v2c17_value","v2c16_value","v2c15_value","v2c14_value","v2c13_value","v2c12_value","v1p1_value","v1p0_value","v0p1_value","v0p0_value","v2c11_value","v2c10_value","v2c9_value","v2c8_value","v2c7_value","v2c6_value","v2c5_value","v2c4_value","v2c3_value","v2c2_value","v2c1_value","v2p3_value","v2p2_value","v2p1_value","v2p0_value","v2c0_value","v12_value","v2_value","in1_field","in2_field","out_field","in1_0_field","in1_1_field","in1_2_field","in1_3_field","in2_0_field","in2_1_field","in2_2_field","in2_3_field","out_0_field","out_1_field","out_2_field","out_3_field","out_3_value","out_2_value","out_1_value","out_0_value","in2_3_value","in2_2_value","in2_1_value","in2_0_value","in1_3_value","in1_2_value","in1_1_value","in1_0_value","out_value","in2_value","in1_value","field_sexps$7","left_input_lo_field","left_input_mi_field","left_input_hi_field","right_input_lo_field","right_input_mi_field","right_input_hi_field","field_overflow_field","carry_field","foreign_field_modulus0_field","foreign_field_modulus1_field","foreign_field_modulus2_field$0","duplicates$7","extra$7","field_sexp$48","foreign_field_modulus2_value$0","foreign_field_modulus1_value","foreign_field_modulus0_value","carry_value","field_overflow_value","right_input_hi_value","right_input_mi_value","right_input_lo_value","left_input_hi_value","left_input_mi_value","left_input_lo_value","field_sexps$6","left_input0_field","left_input1_field","left_input2_field","right_input0_field","right_input1_field","right_input2_field","remainder01_field","remainder2_field","quotient0_field","quotient1_field","quotient2_field","quotient_hi_bound_field","product1_lo_field","product1_hi_0_field","product1_hi_1_field","carry0_field","carry1_0_field","carry1_12_field","carry1_24_field","carry1_36_field","carry1_48_field","carry1_60_field","carry1_72_field","carry1_84_field","carry1_86_field","carry1_88_field","carry1_90_field","foreign_field_modulus2_field","neg_foreign_field_modulus0_fie","neg_foreign_field_modulus1_fie","neg_foreign_field_modulus2_fie","duplicates$6","extra$6","iter$3","neg_foreign_field_modulus2_val","neg_foreign_field_modulus1_val","neg_foreign_field_modulus0_val","foreign_field_modulus2_value","carry1_90_value","carry1_88_value","carry1_86_value","carry1_84_value","carry1_72_value","carry1_60_value","carry1_48_value","carry1_36_value","carry1_24_value","carry1_12_value","carry1_0_value","carry0_value","product1_hi_1_value","product1_hi_0_value","product1_lo_value","quotient_hi_bound_value","quotient2_value","quotient1_value","quotient0_value","remainder2_value","remainder01_value","right_input2_value","right_input1_value","right_input0_value","left_input2_value","left_input1_value","left_input0_value","word_field","rotated_field","excess_field","bound_limb0_field","bound_limb1_field","bound_limb2_field","bound_limb3_field","bound_crumb0_field","bound_crumb1_field","bound_crumb2_field","bound_crumb3_field","bound_crumb4_field","bound_crumb5_field","bound_crumb6_field","bound_crumb7_field","two_to_rot_field","two_to_rot_value","bound_crumb7_value","bound_crumb6_value","bound_crumb5_value","bound_crumb4_value","bound_crumb3_value","bound_crumb2_value","bound_crumb1_value","bound_crumb0_value","bound_limb3_value","bound_limb2_value","bound_limb1_value","bound_limb0_value","excess_value","rotated_value","word_value","kind_field","values_field","coeffs_field","field_sexp$47","coeffs_value","values_value","kind_value","sexp_of_t$88","v_c","v_m","v_o","v_r","v_l","v_state","v_x21_inv","v_inf_z","v_slope","v_same_x","v_inf","v_p3","v_p2","v_p1","v_state$0","v_n_next","v_n_prev","v_base","v_ss","v_accs","v_n_acc","v_ys","v_xs","v_state$1","v_b4","v_b3","v_b2","v_b1","v_s3","v_s1","v_yr","v_xr","v_yp","v_xp","v_yt","v_xt","v_state$2","v_x7","v_x6","v_x5","v_x4","v_x3","v_x2","v_x1","v_x0","v_b8","v_a8","v_b0","v_a0","v_n8","v_n0","v_w6","v_w5","v_w4","v_w3","v_w2","v_w1","v_w0","v_compact","v_v0c7","v_v0c6","v_v0c5","v_v0c4","v_v0c3","v_v0c2","v_v0c1","v_v0c0","v_v0p5","v_v0p4","v_v0p3","v_v0p2","v_v0p1","v_v0p0","v_v0","bnds$40","arg$38","bnds$41","arg$39","bnds$42","arg$40","bnds$43","arg$41","bnds$44","v_v2c19","v_v2c18","v_v2c17","v_v2c16","v_v2c15","v_v2c14","v_v2c13","v_v2c12","v_v1p1","v_v1p0","v_v0p1$0","v_v0p0$0","v_v2c11","v_v2c10","v_v2c9","v_v2c8","v_v2c7","v_v2c6","v_v2c5","v_v2c4","v_v2c3","v_v2c2","v_v2c1","v_v2p3","v_v2p2","v_v2p1","v_v2p0","v_v2c0","v_v12","v_v2","arg$42","bnds$45","arg$43","bnds$46","arg$44","bnds$47","arg$45","bnds$48","arg$46","bnds$49","arg$47","bnds$50","arg$48","bnds$51","arg$49","bnds$52","arg$50","bnds$53","arg$51","bnds$54","arg$52","bnds$55","arg$53","bnds$56","arg$54","bnds$57","arg$55","bnds$58","arg$56","bnds$59","arg$57","bnds$60","arg$58","bnds$61","arg$59","bnds$62","arg$60","bnds$63","arg$61","bnds$64","arg$62","bnds$65","arg$63","bnds$66","arg$64","bnds$67","arg$65","bnds$68","arg$66","bnds$69","arg$67","bnds$70","arg$68","bnds$71","arg$69","bnds$72","arg$70","bnds$73","arg$71","bnds$74","v_out_3","v_out_2","v_out_1","v_out_0","v_in2_3","v_in2_2","v_in2_1","v_in2_0","v_in1_3","v_in1_2","v_in1_1","v_in1_0","v_out","v_in2","v_in1","arg$72","bnds$75","arg$73","bnds$76","arg$74","bnds$77","arg$75","bnds$78","arg$76","bnds$79","arg$77","bnds$80","arg$78","bnds$81","arg$79","bnds$82","arg$80","bnds$83","arg$81","bnds$84","arg$82","bnds$85","arg$83","bnds$86","arg$84","bnds$87","arg$85","bnds$88","arg$86","bnds$89","v_foreign_field_modulus2","v_foreign_field_modulus1","v_foreign_field_modulus0","v_carry","v_field_overflow","v_right_input_hi","v_right_input_mi","v_right_input_lo","v_left_input_hi","v_left_input_mi","v_left_input_lo","arg$87","bnds$90","arg$88","bnds$91","arg$89","bnds$92","arg$90","bnds$93","arg$91","bnds$94","arg$92","bnds$95","arg$93","bnds$96","arg$94","bnds$97","arg$95","bnds$98","arg$96","bnds$99","arg$97","bnds$100","arg$98","bnds$101","v_neg_foreign_field_modulus2","v_neg_foreign_field_modulus1","v_neg_foreign_field_modulus0","v_foreign_field_modulus2$0","v_carry1_90","v_carry1_88","v_carry1_86","v_carry1_84","v_carry1_72","v_carry1_60","v_carry1_48","v_carry1_36","v_carry1_24","v_carry1_12","v_carry1_0","v_carry0","v_product1_hi_1","v_product1_hi_0","v_product1_lo","v_quotient_hi_bound","v_quotient2","v_quotient1","v_quotient0","v_remainder2","v_remainder01","v_right_input2","v_right_input1","v_right_input0","v_left_input2","v_left_input1","v_left_input0","arg$99","bnds$102","arg$100","bnds$103","arg$101","bnds$104","arg$102","bnds$105","arg$103","bnds$106","arg$104","bnds$107","arg$105","bnds$108","arg$106","bnds$109","arg$107","bnds$110","arg$108","bnds$111","arg$109","bnds$112","arg$110","bnds$113","arg$111","bnds$114","arg$112","bnds$115","arg$113","bnds$116","arg$114","bnds$117","arg$115","bnds$118","arg$116","bnds$119","arg$117","bnds$120","arg$118","bnds$121","arg$119","bnds$122","arg$120","bnds$123","arg$121","bnds$124","arg$122","bnds$125","arg$123","bnds$126","arg$124","bnds$127","arg$125","bnds$128","arg$126","bnds$129","arg$127","bnds$130","arg$128","bnds$131","arg$129","bnds$132","v_two_to_rot","v_bound_crumb7","v_bound_crumb6","v_bound_crumb5","v_bound_crumb4","v_bound_crumb3","v_bound_crumb2","v_bound_crumb1","v_bound_crumb0","v_bound_limb3","v_bound_limb2","v_bound_limb1","v_bound_limb0","v_excess","v_rotated","v_word","arg$130","bnds$133","arg$131","bnds$134","arg$132","bnds$135","arg$133","bnds$136","arg$134","bnds$137","arg$135","bnds$138","arg$136","bnds$139","arg$137","bnds$140","arg$138","bnds$141","arg$139","bnds$142","arg$140","bnds$143","arg$141","bnds$144","arg$142","bnds$145","arg$143","bnds$146","arg$144","bnds$147","arg$145","bnds$148","v_coeffs","v_values","v_kind","arg$146","bnds$149","arg$147","bnds$150","arg$148","bnds$151","map$57","fp","x21_inv","inf_z","slope","same_x","inf","p3","compact","v0c7","v0c6","v0c5","v0c4","v0c3","v0c2","v0c1","v0c0","v0p5","v0p4","v0p3","v0p2","v0p1","v0p0","v2c19","v2c18","v2c17","v2c16","v2c15","v2c14","v2c13","v2c12","v1p1","v1p0","v0p1$0","v0p0$0","v2c11","v2c10","v2c9","v2c8","v2c7","v2c6","v2c5","v2c4","v2c3","v2c2","v2c1","v2p3","v2p2","v2p1","v2p0","v2c0","out_3","out_2","out_1","out_0","in2_3","in2_2","in2_1","in2_0","in1_3","in1_2","in1_1","in1_0","in2","in1","foreign_field_modulus2","foreign_field_modulus1","foreign_field_modulus0","field_overflow","right_input_hi","right_input_mi","right_input_lo","left_input_hi","left_input_mi","left_input_lo","neg_foreign_field_modulus2","neg_foreign_field_modulus1","neg_foreign_field_modulus0","foreign_field_modulus2$0","carry1_90","carry1_88","carry1_86","carry1_84","carry1_72","carry1_60","carry1_48","carry1_36","carry1_24","carry1_12","carry1_0","carry0","product1_hi_1","product1_hi_0","product1_lo","quotient_hi_bound","quotient2","quotient1","quotient0","remainder2","remainder01","right_input2","right_input1","right_input0","left_input2","left_input1","left_input0","two_to_rot","bound_crumb7","bound_crumb6","bound_crumb5","bound_crumb4","bound_crumb3","bound_crumb2","bound_crumb1","bound_crumb0","bound_limb3","bound_limb2","bound_limb1","bound_limb0","excess","rotated","word","coeffs","eval_one","vo","co","vr","cr","vl","vl$0","vr$0","vo$0","custom_printf_009","custom_printf_010","custom_printf_011","custom_printf_012","custom_printf_013","custom_printf_014","custom_printf_015","custom_printf_016","custom_printf_017","custom_printf_018","compare$89","hash_fold_t$53","a0$0","hash$41","t_of_sexp$80","sexp_of_t$89","compute_witness","external_values","internal_values","num_rows","custom_printf_033","i_after_input","cols","row_idx","col_idx","union_find","create_internal","get_auxiliary_input_size","get_primary_input_size","get_prev_challenges","num_pub_inputs","set_prev_challenges","num_prev_challenges","next_row","add_row","vars_for_perm","finalize_and_get_gates","gates_rev","rust_gates","pub_selectors","pub_input_gate_specs_rev","public_var","row_field","col_field","col_value","row_value","v_row","equivalence_classes","pos_map","update_gate_with_permutation_i","public_gates","public_gates$0","absolute_row","gates$0","relative_row","add_gates","wired_to","wired_to$0","md5_digest","gates$1","num_constraints","to_json","add_generic_constraint","coeffs2","o2","coeffs$0","constr","red","terms$0","terms_list","lx","go$0","lx$0","rs","s1x1_plus_s2x2","reduce_to_v","xo","xo$0","x3$0","x3$1","x3$2","ratio","ratio$0","x2$1","red_pr","l_s","r_s","o$0","coeff","add_round_state","s5","s4","reduce_curve_point","x1$1","x2$2","x3$3","curr_row","add_endoscale_round","vars$1","add_endoscale_scalar_round","vars$2","vars$3","coeff$0","v2$2","vars_curr","vars_next","vars$4","vars_curr$0","vars_next$0","vars_curr$1","values$0","urs_info","degree","set_urs_info","load","urs$0","store","urs$1","prev_challenges$0","prev_challenges$1","runtime_table_cfg","array_to_vector","vk_commitments","to_list$14","of_list$8","group3","pt$0","tuples","string_bits","test_bit","to_bytes$0","bit","of_bytes$0","hash$42","hash_fold_t$54","to_yojson$16","of_yojson$11","length_in_bits","order","length_in_bytes","remaining_bytes","extended_euclidean","inv_no_mod","euler","while$0","t_minus_1_over_2","b2m","of_bigint","to_bigint","make_gen","t_of_bignum_bigint","make_gen_full","bignum_bigint_of_t","fold_bits","group$91","bin_shape_t$93","group$92","bin_shape_t$94","bin_size_t$46","bin_write_t$47","bin_read_t$81","to_yojson$17","of_yojson$12","compare$90","equal$49","of_bytes$1","to_bytes$1","of_decimal_string","to_string$42","test_bit$0","div$1","compare$91","num_limbs","bytes_per_limb","to_hex","to_hex_string","of_hex_string","of_numeral","double$1","one$8","symbol$203","double$2","scale$1","one$9","to_affine_exn$0","of_affine$0","symbol$204","make$6","unshifted$0","make$7","params$0","params$1","to_field$1","of_field$1","vks","create_aux$0","prev_chals","prev_comms","computed_witness","create$64","to_binable$8","of_binable$10","create$65","of_data$0","to_field$2","of_field$2","create_aux$1","create_async$0","create_and_verify_async$0","create$66","to_binable$9","of_binable$11","create$67","digest_size_in_bits","digest_size_in_bytes","char_generator","of_hex$0","digest_bigstring$0","digest_string$0","to_raw_string$0","of_raw_string$0","hash_fold_t$2","hash$2","bits_to_string","finished","string_to_bits","pct","pot","mct","mot","loc$3","last$0","last$1","map$62","raise_errorf","fixity_of_string","first_is","last_is","needs_parens","needs_spaces","protect_ident","view_expr","exp$0","is_simple_construct","under_semi","ctxt","list$4","fu","option$0","paren","print_longident$0","longident_loc","delim","mutable_flag","virtual_flag","rec_flag","nonrec_flag","direction_flag","private_flag","constant_string","tyvar","tyvar_loc","f$11","module_type$5","mt2","mt1","module_type$2","module_type1","mt2$0","with_constraint","td","ls$0","type_declaration$2","core_type","li2","li$0","td$0","ls$1","li$1","ls$2","li2$0","li$2","module_type1$0","attributes","signature_item$1","me","module_expr$0","extension","e$6","sugar_expr","label_x_expression_param","simple_expr","s$4","expression2","eo$0","eo$1","l$6","e$7","s$5","l$7","string_x_expression","e$8","e$9","ct","e$10","case_list","label_exp","cd","extension_constructor$4","e$5","ands","let$0","binding_op$1","eo","expression_under_ifthenelse","class_structure$2","expression2$0","simple_expr$0","longident_x_expression","e3","df","expression","pattern$0","ct$0","cto1","lid","pattern$6","pattern1$0","pattern_list_helper","pat2","pat1","simple_pattern","pattern1","simple_pattern$0","po","closed","longident_x_pattern","with_paren","simple_name","pc_rhs","pc_guard","pc_lhs","constructor_declaration","attrs","core_type1","record_declaration","priv","manifest","constructor_declaration$0","pcd","intro","variants","constraints","ct2","ct1","lbls","type_record_field","pld","type_param","structure_item$0","item_attributes","vd","value_description$2","type_def_list","te","type_extension$0","exception_declaration","me$1","me$0","arg_opt","mt","decls","pmb","expr","attrs$0","md","class_constraint","class_type$3","class_declaration","cl$2","cl$1","class_expr$2","class_params_def","class_type_declaration_list","floating_attribute","item_extension","binding$0","binding","pp_print_pexp_function","tyvars_str","tyvars","args_tyvars","gadt_pattern","gadt_exp","tyvars$0","e_ct","e_tyvars","pt_ct","pt_tyvars","check_variable","var_names","core_type$0","lst$1","loop_object_field","lst$2","longident","core_type$1","lbl_lst_option","row_field_list","loop_row_field","core_type$2","string_lst","lst$3","longident$0","prf_desc","pof_desc","ety","tyvars$1","ct$1","payload","me2","me1","mt$0","alias","pms","pmd","s$6","s$7","class_description","exported","type_decl","ce","ce$0","ce$1","so","ovf","ovf$0","ovf$1","class_type_declaration","vf","mf","vf$0","pf","type_with_label","print_indexop","path_prefix","print_index","rem_args","print_path","other_args","i3","i2$0","i1$0","i1$1","left$0","txt$0","core_field_type","field_var","first_is_inherit","type_variant_helper","ctl","cstrs","pp$26","pp$27","migration_error","missing_feature","copy_loc","f0","copy_structure","copy_structure_item","copy_toplevel_phrase","pdir_loc","pdir_arg","pdir_name","copy_directive_argument","pdira_loc","pdira_desc","x0$2","copy_attributes","copy_attribute","copy_constant","copy_rec_flag","copy_arg_label","copy_constructor_arguments","copy_core_type","copy_label_declaration","copy_extension_constructor","pext_attributes","pext_loc","pext_kind","pext_name","copy_Longident_t","copy_extension","copy_payload","copy_signature","copy_signature_item","copy_functor_parameter","copy_module_type","copy_override_flag","copy_open_infos","popen_attributes","popen_loc","popen_override","popen_expr","copy_open_declaration","copy_module_expr","copy_closed_flag","ptyp_attributes","ptyp_loc_stack","ptyp_loc","ptyp_desc","x0$3","copy_object_field","x1$2","x0$4","x1$3","x0$5","x1$4","x0$6","copy_label","copy_row_field","x1$5","x0$7","x0$8","x1$6","x0$10","x0$9","copy_pattern","ppat_attributes","ppat_loc_stack","ppat_loc","ppat_desc","x0$11","x0$12","x0$13","x0$14","x0$15","copy_class_structure","pcstr_fields","pcstr_self","copy_class_field","pmty_attributes","pmty_loc","pmty_desc","copy_with_constraint","pmod_attributes","pmod_loc","pmod_desc","copy_expression","copy_binding_op","pbop_loc","pbop_exp","pbop_pat","pbop_op","copy_expression_desc","copy_value_binding","copy_case","x1$7","x1$8","x1$9","x1$10","x1$11","x0$16","x2$3","x1$12","x0$17","x1$13","x0$18","x2$4","x1$14","x0$19","x1$15","x0$20","x0$21","x1$16","x0$22","x0$23","x2$5","x1$17","x0$24","x1$18","x0$25","x0$26","x0$27","x1$19","x0$28","x0$29","x1$20","x0$30","x0$31","x1$21","x0$32","x0$33","x0$34","pexp_attributes","pexp_loc_stack","pexp_loc","pexp_desc","pvb_loc","pvb_attributes","pvb_expr","pvb_pat","prf_attributes","prf_loc","pof_attributes","pof_loc","attr_loc","attr_payload","attr_name","copy_value_description","pval_loc","pval_attributes","pval_prim","pval_type","pval_name","copy_variance","copy_injectivity","copy_private_flag","copy_type_extension","ptyext_attributes","ptyext_loc","ptyext_private","ptyext_constructors","ptyext_params","ptyext_path","copy_type_exception","ptyexn_attributes","ptyexn_loc","ptyexn_constructor","copy_module_type_declaration","pmtd_loc","pmtd_attributes","pmtd_type","pmtd_name","copy_include_infos","pincl_attributes","pincl_loc","pincl_mod","copy_module_binding","pmb_loc","pmb_attributes","pmb_expr","pmb_name","pstr_loc","pstr_desc","copy_type_declaration","copy_class_declaration","copy_class_type_declaration","copy_virtual_flag","copy_class_infos","pci_attributes","pci_loc","pci_expr","pci_name","pci_params","pci_virt","copy_class_expr","copy_open_description","copy_class_type","pcty_attributes","pcty_loc","pcty_desc","pcsig_fields","pcsig_self","copy_class_type_field","pcl_attributes","pcl_loc","pcl_desc","copy_mutable_flag","copy_class_field_kind","pcf_attributes","pcf_loc","pcf_desc","ptype_loc","ptype_attributes","ptype_manifest","ptype_private","ptype_kind","ptype_cstrs","ptype_params","ptype_name","copy_constructor_declaration","copy_module_declaration","pmd_loc","pmd_attributes","pmd_type","pmd_name","psig_loc","psig_desc","pms_loc","pms_attributes","pms_manifest","pms_name","copy_class_description","pctf_attributes","pctf_loc","pctf_desc","pcd_attributes","pcd_loc","pcd_res","pcd_args","pcd_vars","pcd_name","pld_attributes","pld_loc","pld_type","pld_mutable","pld_name","copy_loc$0","copy_structure$0","copy_structure_item$0","copy_toplevel_phrase$0","copy_directive_argument$0","copy_attributes$0","copy_attribute$0","copy_constant$0","copy_rec_flag$0","copy_arg_label$0","copy_constructor_arguments$0","copy_core_type$0","copy_label_declaration$0","copy_extension_constructor$0","copy_Longident_t$0","copy_extension$0","copy_payload$0","copy_signature$0","copy_signature_item$0","copy_functor_parameter$0","copy_module_type$0","copy_override_flag$0","copy_open_infos$0","copy_open_declaration$0","copy_module_expr$0","copy_closed_flag$0","copy_object_field$0","copy_label$0","copy_row_field$0","copy_pattern$0","copy_class_structure$0","copy_class_field$0","copy_with_constraint$0","copy_expression$0","copy_binding_op$0","copy_expression_desc$0","copy_value_binding$0","copy_case$0","copy_value_description$0","copy_variance$0","copy_injectivity$0","copy_private_flag$0","copy_type_extension$0","copy_type_exception$0","copy_module_type_declaration$0","copy_include_infos$0","copy_module_binding$0","copy_type_declaration$0","copy_class_declaration$0","copy_class_type_declaration$0","copy_virtual_flag$0","copy_class_infos$0","copy_class_expr$0","copy_open_description$0","copy_class_type$0","copy_class_type_field$0","copy_mutable_flag$0","copy_class_field_kind$0","copy_constructor_declaration$0","copy_module_declaration$0","copy_class_description$0","migration_error$0","copy_loc$1","copy_structure$1","copy_structure_item$1","copy_toplevel_phrase$1","copy_directive_argument$1","copy_attributes$1","copy_attribute$1","copy_location_stack","copy_location","copy_constant$1","copy_rec_flag$1","copy_arg_label$1","copy_constructor_arguments$1","copy_core_type$1","copy_label_declaration$1","copy_extension_constructor$1","copy_Longident_t$1","copy_extension$1","copy_payload$1","copy_signature$1","copy_signature_item$1","copy_functor_parameter$1","copy_module_type$1","copy_override_flag$1","copy_open_infos$1","copy_open_declaration$1","copy_module_expr$1","copy_closed_flag$1","copy_object_field$1","copy_label$1","copy_row_field$1","copy_pattern$1","copy_class_structure$1","copy_class_field$1","copy_with_constraint$1","copy_expression$1","copy_binding_op$1","copy_expression_desc$1","copy_value_binding$1","copy_case$1","copy_value_description$1","copy_variance$1","copy_injectivity$1","copy_private_flag$1","copy_type_extension$1","copy_type_exception$1","copy_module_type_declaration$1","copy_include_infos$1","copy_module_binding$1","copy_type_declaration$1","copy_class_declaration$1","copy_class_type_declaration$1","copy_virtual_flag$1","copy_class_infos$1","copy_class_expr$1","copy_open_description$1","copy_class_type$1","copy_class_type_field$1","copy_mutable_flag$1","copy_class_field_kind$1","copy_constructor_declaration$1","copy_module_declaration$1","copy_class_description$1","copy_loc$2","copy_structure$2","copy_structure_item$2","copy_toplevel_phrase$2","copy_directive_argument$2","copy_attributes$2","copy_attribute$2","copy_location_stack$0","copy_location$0","copy_constant$2","copy_rec_flag$2","copy_arg_label$2","copy_constructor_arguments$2","copy_core_type$2","copy_label_declaration$2","copy_extension_constructor$2","copy_Longident_t$2","copy_extension$2","copy_payload$2","copy_signature$2","copy_signature_item$2","copy_functor_parameter$2","copy_module_type$2","copy_override_flag$2","copy_open_infos$2","copy_open_declaration$2","copy_module_expr$2","copy_closed_flag$2","copy_object_field$2","copy_label$2","copy_row_field$2","copy_pattern$2","copy_class_structure$2","copy_class_field$2","copy_with_constraint$2","copy_expression$2","copy_binding_op$2","copy_expression_desc$2","copy_value_binding$2","copy_case$2","copy_value_description$2","copy_variance$2","copy_injectivity$2","copy_private_flag$2","copy_type_extension$2","copy_type_exception$2","copy_module_type_declaration$2","copy_include_infos$2","copy_module_binding$2","copy_type_declaration$2","copy_class_declaration$2","copy_class_type_declaration$2","copy_virtual_flag$2","copy_class_infos$2","copy_class_expr$2","copy_open_description$2","copy_class_type$2","copy_class_type_field$2","copy_mutable_flag$2","copy_class_field_kind$2","copy_constructor_declaration$2","copy_module_declaration$2","copy_class_description$2","copy_loc$3","copy_structure$3","copy_structure_item$3","copy_toplevel_phrase$3","copy_directive_argument$3","copy_attributes$3","copy_attribute$3","copy_constant$3","copy_rec_flag$3","copy_arg_label$3","copy_constructor_arguments$3","copy_core_type$3","copy_label_declaration$3","copy_extension_constructor$3","copy_Longident_t$3","copy_extension$3","copy_payload$3","copy_signature$3","copy_signature_item$3","copy_functor_parameter$3","copy_module_type$3","copy_override_flag$3","copy_open_infos$3","copy_open_declaration$3","copy_module_expr$3","copy_closed_flag$3","copy_object_field$3","copy_label$3","copy_row_field$3","copy_pattern$3","copy_class_structure$3","copy_class_field$3","copy_with_constraint$3","copy_expression$3","copy_binding_op$3","copy_expression_desc$3","copy_value_binding$3","copy_case$3","copy_value_description$3","copy_variance$3","copy_private_flag$3","copy_type_extension$3","copy_type_exception$3","copy_module_type_declaration$3","copy_include_infos$3","copy_module_binding$3","copy_type_declaration$3","copy_class_declaration$3","copy_class_type_declaration$3","copy_virtual_flag$3","copy_class_infos$3","copy_class_expr$3","copy_open_description$3","copy_class_type$3","copy_class_type_field$3","copy_mutable_flag$3","copy_class_field_kind$3","copy_constructor_declaration$3","copy_module_declaration$3","copy_class_description$3","copy_loc$4","copy_structure$4","copy_structure_item$4","copy_toplevel_phrase$4","copy_directive_argument$4","copy_attributes$4","copy_attribute$4","copy_constant$4","copy_rec_flag$4","copy_arg_label$4","copy_constructor_arguments$4","copy_core_type$4","copy_label_declaration$4","copy_extension_constructor$4","copy_Longident_t$4","copy_extension$4","copy_payload$4","copy_signature$4","copy_signature_item$4","copy_functor_parameter$4","copy_module_type$4","copy_override_flag$4","copy_open_infos$4","copy_open_declaration$4","copy_module_expr$4","copy_closed_flag$4","copy_object_field$4","copy_label$4","copy_row_field$4","copy_pattern$4","copy_class_structure$4","copy_class_field$4","copy_with_constraint$4","copy_expression$4","copy_binding_op$4","copy_expression_desc$4","copy_value_binding$4","copy_case$4","copy_value_description$4","copy_variance$4","copy_private_flag$4","copy_type_extension$4","copy_type_exception$4","copy_module_type_declaration$4","copy_include_infos$4","copy_module_binding$4","copy_type_declaration$4","copy_class_declaration$4","copy_class_type_declaration$4","copy_virtual_flag$4","copy_class_infos$4","copy_class_expr$4","copy_open_description$4","copy_class_type$4","copy_class_type_field$4","copy_mutable_flag$4","copy_class_field_kind$4","copy_constructor_declaration$4","copy_module_declaration$4","copy_class_description$4","copy_loc$5","copy_structure$5","copy_structure_item$5","copy_toplevel_phrase$5","copy_directive_argument$5","copy_attributes$5","copy_attribute$5","copy_location_stack$1","copy_location$1","copy_constant$5","copy_rec_flag$5","copy_arg_label$5","copy_constructor_arguments$5","copy_core_type$5","copy_label_declaration$5","copy_extension_constructor$5","copy_Longident_t$5","copy_extension$5","copy_payload$5","copy_signature$5","copy_signature_item$5","copy_functor_parameter$5","copy_module_type$5","copy_override_flag$5","copy_open_infos$5","copy_open_declaration$5","copy_module_expr$5","copy_closed_flag$5","copy_object_field$5","copy_label$5","copy_row_field$5","copy_pattern$5","copy_class_structure$5","copy_class_field$5","copy_with_constraint$5","copy_expression$5","copy_binding_op$5","copy_expression_desc$5","copy_value_binding$5","copy_case$5","copy_value_description$5","copy_variance$5","copy_private_flag$5","copy_type_extension$5","copy_type_exception$5","copy_module_type_declaration$5","copy_include_infos$5","copy_module_binding$5","copy_type_declaration$5","copy_class_declaration$5","copy_class_type_declaration$5","copy_virtual_flag$5","copy_class_infos$5","copy_class_expr$5","copy_open_description$5","copy_class_type$5","copy_class_type_field$5","copy_mutable_flag$5","copy_class_field_kind$5","copy_constructor_declaration$5","copy_module_declaration$5","copy_class_description$5","copy_loc$6","copy_structure$6","copy_structure_item$6","copy_toplevel_phrase$6","copy_directive_argument$6","copy_attributes$6","copy_attribute$6","copy_location_stack$2","copy_location$2","copy_constant$6","copy_rec_flag$6","copy_arg_label$6","copy_constructor_arguments$6","copy_core_type$6","copy_label_declaration$6","copy_extension_constructor$6","copy_Longident_t$6","copy_extension$6","copy_payload$6","copy_signature$6","copy_signature_item$6","copy_functor_parameter$6","copy_module_type$6","copy_override_flag$6","copy_open_infos$6","copy_open_declaration$6","copy_module_expr$6","copy_closed_flag$6","copy_object_field$6","copy_label$6","copy_row_field$6","copy_pattern$6","copy_class_structure$6","copy_class_field$6","copy_with_constraint$6","copy_expression$6","copy_binding_op$6","copy_expression_desc$6","copy_value_binding$6","copy_case$6","copy_value_description$6","copy_variance$6","copy_private_flag$6","copy_type_extension$6","copy_type_exception$6","copy_module_type_declaration$6","copy_include_infos$6","copy_module_binding$6","copy_type_declaration$6","copy_class_declaration$6","copy_class_type_declaration$6","copy_virtual_flag$6","copy_class_infos$6","copy_class_expr$6","copy_open_description$6","copy_class_type$6","copy_class_type_field$6","copy_mutable_flag$6","copy_class_field_kind$6","copy_constructor_declaration$6","copy_module_declaration$6","copy_class_description$6","migration_error$1","map_option","copy_loc$7","copy_structure$7","copy_structure_item$7","copy_toplevel_phrase$7","copy_directive_argument$7","copy_attributes$7","copy_attribute$7","copy_location_stack$3","copy_location$3","copy_constant$7","copy_rec_flag$7","copy_arg_label$7","copy_constructor_arguments$7","copy_core_type$7","copy_label_declaration$7","copy_extension_constructor$7","copy_Longident_t$7","copy_extension$7","copy_payload$7","copy_signature$7","copy_signature_item$7","copy_functor_parameter$7","copy_module_type$7","copy_override_flag$7","copy_open_infos$7","copy_open_declaration$7","copy_module_expr$7","copy_closed_flag$7","copy_object_field$7","copy_label$7","copy_row_field$7","copy_pattern$7","copy_class_structure$7","copy_class_field$7","copy_with_constraint$7","copy_expression$7","copy_binding_op$7","copy_expression_desc$7","copy_value_binding$7","copy_case$7","copy_value_description$7","copy_variance$7","copy_private_flag$7","copy_type_extension$7","copy_type_exception$7","copy_module_type_declaration$7","copy_include_infos$7","copy_module_binding$7","copy_type_declaration$7","copy_class_declaration$7","copy_class_type_declaration$7","copy_virtual_flag$7","copy_class_infos$7","copy_class_expr$7","copy_open_description$7","copy_class_type$7","copy_class_type_field$7","copy_mutable_flag$7","copy_class_field_kind$7","copy_constructor_declaration$7","copy_module_declaration$7","copy_class_description$7","map_option$0","copy_loc$8","copy_structure$8","copy_structure_item$8","copy_toplevel_phrase$8","copy_directive_argument$8","copy_attributes$8","copy_attribute$8","copy_constant$8","copy_rec_flag$8","copy_arg_label$8","copy_constructor_arguments$8","copy_core_type$8","copy_label_declaration$8","copy_extension_constructor$8","copy_Longident_t$8","copy_extension$8","copy_payload$8","copy_signature$8","copy_signature_item$8","copy_override_flag$8","copy_open_infos$8","copy_open_declaration$8","copy_module_expr$8","copy_closed_flag$8","copy_location$4","copy_object_field$8","copy_label$8","copy_row_field$8","copy_pattern$8","copy_class_structure$8","copy_class_field$8","copy_cases","copy_case$8","copy_module_type$8","copy_with_constraint$8","copy_expression$8","copy_binding_op$8","copy_expression_desc$8","copy_value_binding$8","copy_value_description$8","copy_variance$8","copy_private_flag$8","copy_type_extension$8","copy_type_exception$8","copy_module_type_declaration$8","copy_include_infos$8","copy_module_binding$8","copy_type_declaration$8","copy_class_declaration$8","copy_class_type_declaration$8","copy_virtual_flag$8","copy_class_infos$8","copy_class_expr$8","copy_open_description$8","copy_class_type$8","copy_class_type_field$8","copy_mutable_flag$8","copy_class_field_kind$8","copy_constructor_declaration$8","copy_module_declaration$8","copy_class_description$8","copy_loc$9","copy_structure$9","copy_structure_item$9","copy_toplevel_phrase$9","copy_directive_argument$9","copy_attributes$9","copy_attribute$9","copy_constant$9","copy_rec_flag$9","copy_arg_label$9","copy_constructor_arguments$9","copy_core_type$9","copy_label_declaration$9","copy_extension_constructor$9","copy_Longident_t$9","copy_extension$9","copy_payload$9","copy_signature$9","copy_signature_item$9","copy_override_flag$9","copy_open_infos$9","copy_open_declaration$9","copy_module_expr$9","copy_closed_flag$9","copy_location$5","copy_object_field$9","copy_label$9","copy_row_field$9","copy_pattern$9","copy_class_structure$9","copy_class_field$9","copy_cases$0","copy_case$9","copy_module_type$9","copy_with_constraint$9","copy_expression$9","copy_binding_op$9","copy_expression_desc$9","copy_value_binding$9","copy_value_description$9","copy_variance$9","copy_private_flag$9","copy_type_extension$9","copy_type_exception$9","copy_module_type_declaration$9","copy_include_infos$9","copy_module_binding$9","copy_type_declaration$9","copy_class_declaration$9","copy_class_type_declaration$9","copy_virtual_flag$9","copy_class_infos$9","copy_class_expr$9","copy_open_description$9","copy_class_type$9","copy_class_type_field$9","copy_mutable_flag$9","copy_class_field_kind$9","copy_constructor_declaration$9","copy_module_declaration$9","copy_class_description$9","copy_loc$10","copy_structure$10","copy_structure_item$10","copy_toplevel_phrase$10","copy_directive_argument$10","copy_attributes$10","copy_attribute$10","copy_constant$10","copy_rec_flag$10","copy_arg_label$10","copy_constructor_arguments$10","copy_core_type$10","copy_label_declaration$10","copy_extension_constructor$10","copy_Longident_t$10","copy_extension$10","copy_payload$10","copy_signature$10","copy_signature_item$10","copy_override_flag$10","copy_open_infos$10","copy_open_declaration$10","copy_module_expr$10","copy_closed_flag$10","copy_location$6","copy_object_field$10","copy_label$10","copy_row_field$10","copy_pattern$10","copy_class_structure$10","copy_class_field$10","copy_cases$1","copy_case$10","copy_module_type$10","copy_with_constraint$10","copy_expression$10","copy_binding_op$10","copy_expression_desc$10","copy_value_binding$10","copy_value_description$10","copy_variance$10","copy_private_flag$10","copy_type_extension$10","copy_type_exception$10","copy_module_type_declaration$10","copy_include_infos$10","copy_module_binding$10","copy_type_declaration$10","copy_class_declaration$10","copy_class_type_declaration$10","copy_virtual_flag$10","copy_class_infos$10","copy_class_expr$10","copy_open_description$10","copy_class_type$10","copy_class_type_field$10","copy_mutable_flag$10","copy_class_field_kind$10","copy_constructor_declaration$10","copy_module_declaration$10","copy_class_description$10","migration_error$2","copy_bool","copy_option","copy_structure$11","copy_structure_item$11","copy_toplevel_phrase$11","copy_attributes$11","copy_attribute$11","copy_loc$11","copy_constant$11","copy_rec_flag$11","copy_arg_label$11","copy_constructor_arguments$11","copy_core_type$11","copy_label_declaration$11","copy_extension_constructor$11","copy_longident","copy_override_flag$11","copy_extension$11","copy_payload$11","copy_signature$11","copy_signature_item$11","copy_closed_flag$11","copy_object_field$11","copy_label$11","copy_row_field$11","copy_pattern$11","copy_class_structure$11","copy_class_field$11","copy_module_type$11","copy_with_constraint$11","copy_module_expr$11","copy_expression$11","copy_expression_desc$11","copy_value_binding$11","copy_case$11","copy_value_description$11","copy_variance$11","copy_private_flag$11","copy_type_extension$11","copy_module_type_declaration$11","copy_include_infos$11","copy_module_binding$11","copy_type_declaration$11","copy_class_declaration$11","copy_class_type_declaration$11","copy_virtual_flag$11","copy_class_infos$11","copy_class_expr$11","copy_class_type$11","copy_class_type_field$11","copy_mutable_flag$11","copy_class_field_kind$11","copy_constructor_declaration$11","copy_module_declaration$11","x0_loc","copy_class_description$11","copy_toplevel_phrase$12","copy_directive_argument$11","copy_expression$12","copy_expression_desc$12","copy_direction_flag","copy_case$12","copy_value_binding$12","copy_pattern$12","copy_pattern_desc","copy_core_type$12","copy_core_type_desc","copy_package_type","copy_row_field$12","copy_object_field$12","copy_attributes$12","copy_attribute$12","copy_payload$12","copy_structure$12","copy_structure_item$12","copy_structure_item_desc","copy_include_declaration","copy_class_declaration$12","copy_class_expr$12","copy_class_expr_desc","copy_class_structure$12","copy_class_field$12","copy_class_field_desc","copy_class_field_kind$12","copy_module_binding$12","copy_module_expr$12","copy_module_expr_desc","copy_module_type$12","copy_module_type_desc","copy_with_constraint$12","copy_signature$12","copy_signature_item$12","copy_signature_item_desc","copy_class_type_declaration$12","copy_class_description$12","copy_class_type$12","copy_class_type_desc","copy_class_signature","copy_class_type_field$12","copy_class_type_field_desc","copy_extension$12","copy_class_infos$12","copy_virtual_flag$12","copy_include_description","copy_include_infos$12","copy_open_description$11","copy_override_flag$12","copy_module_type_declaration$12","copy_module_declaration$12","copy_type_extension$12","copy_extension_constructor$12","copy_extension_constructor_kin","copy_type_declaration$12","copy_private_flag$12","copy_type_kind","copy_constructor_declaration$12","copy_constructor_arguments$12","copy_label_declaration$12","copy_mutable_flag$12","copy_variance$12","copy_value_description$12","copy_arg_label$12","copy_closed_flag$12","copy_label$12","copy_rec_flag$12","copy_constant$12","copy_option$0","copy_longident$0","copy_loc$12","copy_location$7","copy_bool$0","wrap$2","x2$6","atat","popen_lid","copy_attributes$13","copy_attribute$13","copy_loc$13","copy_option$1","copy_constant$13","copy_rec_flag$13","copy_arg_label$13","copy_constructor_arguments$13","copy_core_type$13","copy_label_declaration$13","copy_extension_constructor$13","copy_longident$1","copy_override_flag$13","copy_extension$13","copy_payload$13","copy_signature$13","copy_signature_item$13","copy_structure$13","copy_structure_item$13","copy_closed_flag$13","copy_object_field$13","copy_label$13","copy_row_field$13","copy_pattern$13","copy_class_structure$13","copy_class_field$13","copy_module_type$13","copy_with_constraint$13","copy_module_expr$13","copy_expression$13","copy_expression_desc$13","copy_value_binding$13","copy_case$13","copy_bool$1","copy_value_description$13","copy_variance$13","copy_private_flag$13","copy_type_extension$13","copy_module_type_declaration$13","copy_open_description$12","copy_include_infos$13","copy_module_binding$13","copy_type_declaration$13","copy_class_declaration$13","copy_class_type_declaration$13","copy_virtual_flag$13","copy_class_infos$13","copy_class_expr$13","copy_class_type$13","copy_class_type_field$13","cty","copy_class_field_kind$13","copy_mutable_flag$13","copy_constructor_declaration$13","copy_module_declaration$13","copy_class_description$13","copy_toplevel_phrase$13","copy_attributes$14","copy_attribute$14","copy_loc$14","copy_option$2","copy_constant$14","copy_rec_flag$14","copy_arg_label$14","copy_constructor_arguments$14","copy_core_type$14","copy_label_declaration$14","copy_extension_constructor$14","copy_longident$2","copy_override_flag$14","copy_extension$14","copy_payload$14","copy_signature$14","copy_signature_item$14","copy_structure$14","copy_structure_item$14","copy_closed_flag$14","copy_object_field$14","copy_label$14","copy_row_field$14","copy_pattern$14","copy_class_structure$14","copy_class_field$14","copy_module_type$14","copy_with_constraint$14","copy_module_expr$14","copy_expression$14","copy_expression_desc$14","copy_value_binding$14","copy_case$14","copy_bool$2","copy_value_description$14","copy_variance$14","copy_private_flag$14","copy_type_extension$14","copy_module_type_declaration$14","copy_open_description$13","copy_include_infos$14","copy_module_binding$14","copy_type_declaration$14","copy_class_declaration$14","copy_class_type_declaration$14","copy_virtual_flag$14","copy_class_infos$14","copy_class_expr$14","copy_class_type$14","copy_class_type_field$14","copy_class_field_kind$14","copy_mutable_flag$14","copy_constructor_declaration$14","copy_module_declaration$14","copy_class_description$14","copy_toplevel_phrase$14","migration_error$3","copy_attributes$15","copy_attribute$15","copy_loc$15","copy_option$3","copy_constant$15","copy_rec_flag$15","copy_arg_label$15","copy_constructor_arguments$15","copy_core_type$15","copy_label_declaration$15","copy_extension_constructor$15","copy_longident$3","copy_override_flag$15","copy_extension$15","copy_payload$15","copy_signature$15","copy_signature_item$15","copy_structure$15","copy_structure_item$15","copy_closed_flag$15","copy_label$15","copy_row_field$15","copy_pattern$15","copy_class_structure$15","copy_class_field$15","copy_module_type$15","copy_with_constraint$15","copy_module_expr$15","copy_expression$15","copy_expression_desc$15","copy_value_binding$15","copy_case$15","copy_bool$3","copy_value_description$15","copy_variance$15","copy_private_flag$15","copy_type_extension$15","copy_module_type_declaration$15","copy_open_description$14","copy_include_infos$15","copy_module_binding$15","copy_type_declaration$15","copy_class_declaration$15","copy_class_type_declaration$15","copy_virtual_flag$15","copy_class_infos$15","copy_class_expr$15","copy_class_type$15","copy_class_type_field$15","copy_class_field_kind$15","copy_mutable_flag$15","copy_constructor_declaration$15","loc$1","copy_module_declaration$15","copy_class_description$15","copy_toplevel_phrase$15","copy_attributes$16","copy_attribute$16","copy_loc$16","copy_option$4","copy_constant$16","copy_rec_flag$16","copy_arg_label$16","copy_constructor_arguments$16","copy_core_type$16","copy_label_declaration$16","copy_extension_constructor$16","copy_longident$4","copy_override_flag$16","copy_extension$16","copy_payload$16","copy_signature$16","copy_signature_item$16","copy_structure$16","copy_structure_item$16","copy_closed_flag$16","copy_label$16","copy_row_field$16","copy_pattern$16","copy_class_structure$16","copy_class_field$16","copy_module_type$16","copy_with_constraint$16","copy_module_expr$16","copy_expression$16","copy_expression_desc$16","copy_value_binding$16","copy_case$16","copy_bool$4","copy_value_description$16","copy_variance$16","copy_private_flag$16","copy_type_extension$16","copy_module_type_declaration$16","copy_open_description$15","copy_include_infos$16","copy_module_binding$16","copy_type_declaration$16","copy_class_declaration$16","copy_class_type_declaration$16","copy_virtual_flag$16","copy_class_infos$16","copy_class_expr$16","copy_class_type$16","copy_class_type_field$16","copy_class_field_kind$16","copy_mutable_flag$16","copy_constructor_declaration$16","copy_module_declaration$16","copy_class_description$16","copy_toplevel_phrase$16","copy_attributes$17","copy_attribute$17","copy_loc$17","copy_option$5","copy_constant$17","copy_rec_flag$17","copy_arg_label$17","copy_constructor_arguments$17","copy_core_type$17","copy_label_declaration$17","copy_extension_constructor$17","copy_longident$5","copy_override_flag$17","copy_extension$17","copy_payload$17","copy_signature$17","copy_signature_item$17","copy_structure$17","copy_structure_item$17","copy_closed_flag$17","copy_label$17","copy_row_field$17","copy_pattern$17","copy_class_structure$17","copy_class_field$17","copy_module_type$17","copy_with_constraint$17","copy_module_expr$17","copy_expression$17","copy_expression_desc$17","copy_value_binding$17","copy_case$17","copy_bool$5","copy_value_description$17","copy_variance$17","copy_private_flag$17","copy_type_extension$17","copy_module_type_declaration$17","copy_open_description$16","copy_include_infos$17","copy_module_binding$17","copy_type_declaration$17","copy_class_declaration$17","copy_class_type_declaration$17","copy_virtual_flag$17","copy_class_infos$17","copy_class_expr$17","copy_class_type$17","copy_class_type_field$17","copy_class_field_kind$17","copy_mutable_flag$17","copy_constructor_declaration$17","copy_module_declaration$17","copy_class_description$17","copy_toplevel_phrase$17","noloc","copy_attributes$18","copy_attribute$18","copy_loc$18","copy_option$6","copy_constant$18","copy_rec_flag$18","copy_arg_label$18","copy_constructor_arguments$18","copy_core_type$18","copy_label_declaration$18","copy_extension_constructor$18","copy_longident$6","copy_override_flag$18","copy_extension$18","copy_payload$18","copy_signature$18","copy_signature_item$18","copy_structure$18","copy_structure_item$18","copy_closed_flag$18","copy_label$18","copy_row_field$18","copy_pattern$18","copy_class_structure$18","copy_class_field$18","copy_module_type$18","copy_with_constraint$18","copy_module_expr$18","copy_expression$18","copy_expression_desc$18","copy_value_binding$18","copy_case$18","copy_bool$6","copy_value_description$18","copy_variance$18","copy_private_flag$18","copy_type_extension$18","copy_module_type_declaration$18","copy_open_description$17","copy_include_infos$18","copy_module_binding$18","copy_type_declaration$18","copy_class_declaration$18","copy_class_type_declaration$18","copy_virtual_flag$18","copy_class_infos$18","copy_class_expr$18","copy_class_type$18","copy_class_type_field$18","copy_class_field_kind$18","copy_mutable_flag$18","copy_constructor_declaration$18","copy_module_declaration$18","copy_class_description$18","copy_toplevel_phrase$18","migration_error$4","copy_attributes$19","copy_attribute$19","copy_loc$19","copy_option$7","copy_constant$19","copy_rec_flag$19","copy_arg_label$19","copy_override_flag$19","copy_extension$19","copy_payload$19","copy_signature$19","copy_signature_item$19","copy_structure$19","copy_structure_item$19","copy_closed_flag$19","copy_core_type$19","copy_longident$7","copy_label$19","copy_row_field$19","copy_pattern$19","copy_class_structure$19","copy_class_field$19","copy_module_type$19","copy_with_constraint$19","copy_module_expr$19","copy_expression$19","copy_expression_desc$19","copy_value_binding$19","copy_case$19","copy_bool$7","copy_value_description$19","copy_constructor_arguments$19","copy_label_declaration$19","copy_extension_constructor$19","copy_variance$19","copy_private_flag$19","copy_type_extension$19","copy_module_type_declaration$19","copy_open_description$18","copy_include_infos$19","copy_module_binding$19","copy_type_declaration$19","copy_class_declaration$19","copy_class_type_declaration$19","copy_virtual_flag$19","copy_class_infos$19","copy_class_expr$19","copy_class_type$19","copy_class_type_field$19","copy_class_field_kind$19","copy_mutable_flag$19","copy_constructor_declaration$19","copy_module_declaration$19","copy_class_description$19","copy_toplevel_phrase$19","copy_attributes$20","copy_attribute$20","copy_loc$20","copy_option$8","copy_constant$20","copy_rec_flag$20","copy_arg_label$20","copy_override_flag$20","copy_extension$20","copy_payload$20","copy_signature$20","copy_signature_item$20","copy_structure$20","copy_structure_item$20","copy_closed_flag$20","copy_core_type$20","copy_longident$8","copy_label$20","copy_row_field$20","copy_pattern$20","copy_class_structure$20","copy_class_field$20","copy_module_type$20","copy_with_constraint$20","copy_module_expr$20","copy_expression$20","copy_expression_desc$20","copy_value_binding$20","copy_case$20","copy_bool$8","copy_value_description$20","copy_constructor_arguments$20","copy_label_declaration$20","copy_extension_constructor$20","copy_variance$20","copy_private_flag$20","copy_type_extension$20","copy_module_type_declaration$20","copy_open_description$19","copy_include_infos$20","copy_module_binding$20","copy_type_declaration$20","copy_class_declaration$20","copy_class_type_declaration$20","copy_virtual_flag$20","copy_class_infos$20","copy_class_expr$20","copy_class_type$20","copy_class_type_field$20","copy_class_field_kind$20","copy_mutable_flag$20","copy_constructor_declaration$20","copy_module_declaration$20","copy_class_description$20","copy_toplevel_phrase$20","inject_predef_option","ident","migration_error$5","copy_attributes$21","copy_attribute$21","copy_loc$21","copy_option$9","copy_constant$21","copy_rec_flag$21","copy_arg_label$21","copy_override_flag$21","copy_extension$21","copy_payload$21","copy_signature$21","copy_signature_item$21","copy_structure$21","copy_structure_item$21","copy_closed_flag$21","copy_core_type$21","copy_longident$9","copy_label$21","copy_row_field$21","copy_pattern$21","copy_class_structure$21","copy_class_field$21","copy_module_type$21","copy_with_constraint$21","copy_module_expr$21","copy_expression$21","copy_expression_desc$21","copy_value_binding$21","copy_case$21","copy_bool$9","type_declarations$3","recflag","types","copy_type_declaration$21","copy_value_description$21","copy_constructor_arguments$21","copy_extension_constructor$21","copy_variance$21","copy_private_flag$21","copy_type_extension$21","copy_module_type_declaration$21","copy_open_description$20","copy_include_infos$21","copy_module_binding$21","copy_class_declaration$21","copy_class_type_declaration$21","copy_virtual_flag$21","copy_class_infos$21","copy_class_expr$21","copy_class_type$21","copy_class_type_field$21","copy_class_field_kind$21","copy_mutable_flag$21","copy_constructor_declaration$21","copy_label_declaration$21","copy_module_declaration$21","copy_class_description$21","copy_toplevel_phrase$21","extract_predef_option","copy_attributes$22","copy_attribute$22","copy_loc$22","copy_option$10","copy_constant$22","copy_rec_flag$22","copy_arg_label$22","copy_override_flag$22","copy_extension$22","copy_payload$22","copy_signature$22","copy_signature_item$22","copy_structure$22","copy_structure_item$22","copy_closed_flag$22","copy_core_type$22","copy_longident$10","copy_label$22","copy_row_field$22","copy_pattern$22","copy_class_structure$22","copy_class_field$22","copy_module_type$22","copy_with_constraint$22","copy_module_expr$22","copy_expression$22","copy_expression_desc$22","copy_value_binding$22","copy_case$22","copy_bool$10","type_declarations$4","is_nonrec","attr","types$0","copy_type_declaration$22","copy_value_description$22","copy_extension_constructor$22","copy_variance$22","copy_private_flag$22","copy_type_extension$22","copy_module_type_declaration$22","copy_open_description$21","copy_include_infos$22","copy_module_binding$22","copy_class_declaration$22","copy_class_type_declaration$22","copy_virtual_flag$22","copy_class_infos$22","copy_class_expr$22","copy_class_type$22","copy_class_type_field$22","copy_class_field_kind$22","copy_mutable_flag$22","copy_constructor_declaration$22","copy_label_declaration$22","copy_module_declaration$22","copy_class_description$22","copy_toplevel_phrase$22","migration_info","id$7","migration_identity","compose$2","migration_functions","is_undefined","immediate_migration","A","direction","funs","B","To","to2","migration_info$0","migration_info$1","migration_info$2","migration_info$3","migration_info$4","migration_info$5","migration_info$6","migration_info$7","migration_info$8","migration_info$10","migration_info$11","version$1","version$2","version$3","version$4","version$5","version$6","version$7","version$9","version$10","of_ocaml","to_ocaml","of_ocaml_mapper","item","to_ocaml_mapper","parse$1","parse$2","self_1","a$3","a$4","a$5","a$6","pdira_desc$0","pdira_loc$0","pdir_name$0","pdir_arg$0","pdir_loc$0","pmb_name$0","pmb_expr$0","pmb_attributes$0","pmb_loc$0","pvb_pat$0","pvb_expr$0","pvb_attributes$0","pvb_loc$0","b$3","b$4","a$7","a$8","a$9","a$10","a$11","a$12","a$13","a$14","a$15","a$16","a$17","a$18","a$19","a$20","a$21","a$22","a$23","a$24","a$25","a$26","b$5","a$27","a$28","b$6","pstr_desc$0","pstr_loc$0","pmod_desc$0","pmod_loc$0","pmod_attributes$0","pincl_mod$0","pincl_loc$0","pincl_attributes$0","popen_expr$0","popen_override$0","popen_loc$0","popen_attributes$0","pmtd_name$0","pmtd_type$0","pmtd_attributes$0","pmtd_loc$0","pms_name$0","pms_manifest$0","pms_attributes$0","pms_loc$0","pmd_name$0","pmd_type$0","pmd_attributes$0","pmd_loc$0","psig_desc$0","psig_loc$0","pmty_desc$0","pmty_loc$0","pmty_attributes$0","pcf_desc$0","pcf_loc$0","pcf_attributes$0","pcstr_self$0","pcstr_fields$0","b$7","b$8","b$9","b$10","pcl_desc$0","pcl_loc$0","pcl_attributes$0","pci_virt$0","pci_params$0","pci_name$0","pci_expr$0","pci_loc$0","pci_attributes$0","d$1","d$2","pctf_desc$0","pctf_loc$0","pctf_attributes$0","pcsig_self$0","pcsig_fields$0","pcty_desc$0","pcty_loc$0","pcty_attributes$0","ptyexn_constructor$0","ptyexn_loc$0","ptyexn_attributes$0","pext_name$0","pext_kind$0","pext_loc$0","pext_attributes$0","ptyext_path$0","ptyext_params$0","ptyext_constructors$0","ptyext_private$0","ptyext_loc$0","ptyext_attributes$0","pcd_name$0","pcd_args$0","pcd_res$0","pcd_loc$0","pcd_attributes$0","pld_name$0","pld_mutable$0","pld_type$0","pld_loc$0","pld_attributes$0","ptype_name$0","ptype_params$0","ptype_cstrs$0","ptype_kind$0","ptype_private$0","ptype_manifest$0","ptype_attributes$0","ptype_loc$0","pval_name$0","pval_type$0","pval_prim$0","pval_attributes$0","pval_loc$0","pbop_op$0","pbop_pat$0","pbop_exp$0","pbop_loc$0","let$1","ands$0","pc_lhs$0","pc_guard$0","pc_rhs$0","b$11","b$12","b$13","b$14","b$15","b$16","b$17","b$18","b$19","a$29","a$30","b$20","b$21","a$31","a$32","b$22","b$23","a$33","a$34","b$24","c$7","b$25","a$35","a$36","b$26","c$8","b$27","a$37","a$38","b$28","c$9","b$29","a$39","a$40","b$30","c$10","b$31","a$41","a$42","b$32","a$43","a$44","b$33","a$45","a$46","b$34","a$47","a$48","c$11","b$35","a$49","a$50","b$36","c$12","b$37","a$51","a$52","b$38","a$53","a$54","a$55","a$56","b$39","a$57","a$58","b$40","a$59","a$60","b$41","a$61","a$62","b$42","a$63","a$64","b$43","a$65","a$66","b$44","a$67","a$68","a$69","a$70","pexp_desc$0","pexp_loc$0","pexp_loc_stack$0","pexp_attributes$0","ppat_desc$0","ppat_loc$0","ppat_loc_stack$0","ppat_attributes$0","pof_desc$0","pof_loc$0","pof_attributes$0","prf_desc$0","prf_loc$0","prf_attributes$0","ptyp_desc$0","ptyp_loc$0","ptyp_loc_stack$0","ptyp_attributes$0","attr_name$0","attr_payload$0","attr_loc$0","loc_ghost","loc_end","loc_start","loc_start$0","loc_end$0","loc_ghost$0","pos_cnum","pos_bol","pos_lnum","pos_fname","pos_fname$0","pos_lnum$0","pos_bol$0","pos_cnum$0","self_2","self_3","acc$5","acc$6","acc$7","acc$8","acc$9","acc$10","acc$11","acc$12","acc$13","acc$14","acc$15","acc$16","acc$17","acc$18","acc$19","acc$20","acc$21","acc$22","acc$23","acc$24","acc$25","acc$26","acc$27","acc$28","acc$29","acc$30","acc$31","acc$32","acc$33","acc$34","acc$35","acc$36","acc$37","acc$38","acc$39","acc$40","acc$41","acc$42","acc$43","acc$44","acc$45","acc$46","acc$47","acc$48","acc$49","acc$50","acc$51","acc$52","acc$53","acc$54","acc$55","self_4","acc$56","acc$57","acc$58","acc$59","acc$60","acc$61","acc$62","acc$63","acc$64","acc$65","acc$66","acc$67","acc$68","self_5","self_6","lookup$1","drv","compare$108","equal$61","protectx$0","add$27","add_exn$3","find_opt$1","of_alist$5","alist$0","f$12","read_all_into","map$65","fold_right$6","symbol$208","concat$4","is_empty$12","filter_map$8","concat_map$2","assoc_opt","iter$32","is_some$2","map$66","is_empty$13","prefix$2","drop_prefix$0","index_opt","rindex_opt","split_on_char$0","find_opt$2","to_string_path","located","in_file$0","loc$5","raise_errorf$0","enter_module","enter_value$0","module_name$32","enter","enter_opt","self_7","mtd","mb","self_8","var_names_of","ec_enter_module_opt","self_9","var_name","var_name$0","in_binding_ctxt","sexp_of$0","self_10","levenshtein_distance","cutoff","line_min","distance","spellcheck$2","registered_name","names_at_best_distance","best_distance","dist","suggestions","rev_rest","ptyp_any","ptyp_constr","pexp_ident","pexp_constant","pexp_let","pexp_fun","pexp_construct","pexp_variant","pexp_record","include_infos$0","ppat_any","ppat_constant","ppat_construct","ppat_variant","ppat_record","pstr_eval","pstr_value","value_binding$0","pat","short_name","name$96","flatten_exn","unflatten","parse$3","map$68","map_lident","lident","vbs","pexp_tuple","ppat_tuple","pexp_apply","unapplied_type_constr_conv_wit","apply_loc","suffix_n","functor","functor_args","functor$0","functor_path","ident$0","gather_args","subpat","param_label","arg_label","ty_opt","attribute","binding_op","lhs","guard","rhs","pcl_constr","pcl_structure","pcl_fun","pcl_apply","pcl_let","pcl_constraint","pcl_extension","pcl_open","pcf_inherit","pcf_val","pcf_method","pcf_constraint","pcf_initializer","pcf_attribute","pcf_extension","class_infos","virt","class_signature","class_structure","pcty_constr","pcty_signature","pcty_arrow","pcty_extension","pcty_open","pctf_inherit","pctf_val","pctf_method","pctf_constraint","pctf_attribute","pctf_extension","ptyp_var","ptyp_arrow","ptyp_object","ptyp_class","ptyp_alias","ptyp_variant","ptyp_package","ptyp_extension","pdir_string","pdir_int","pdir_ident","pdir_bool","pexp_constant$0","pexp_function","pexp_fun$0","pexp_match","pexp_try","pexp_construct$0","pexp_field","pexp_setfield","pexp_array","pexp_ifthenelse","pexp_sequence","pexp_while","pexp_for","pexp_constraint","pexp_coerce","pexp_send","pexp_new","pexp_setinstvar","pexp_override","pexp_letmodule","pexp_letexception","pexp_assert","pexp_lazy","pexp_poly","pexp_object","pexp_newtype","pexp_pack","pexp_open","pexp_letop","pexp_extension","pexp_unreachable","include_infos","label_declaration","mutable","type","letop","end","ghost","module_binding","module_declaration","pmod_ident","pmod_structure","pmod_functor","pmod_apply","pmod_constraint","pmod_unpack","pmod_extension","module_substitution","pmty_ident","pmty_signature","pmty_functor","pmty_with","pmty_typeof","pmty_extension","pmty_alias","module_type_declaration","otag","oinherit","open_infos","ppat_var","ppat_alias","ppat_constant$0","ppat_interval","ppat_construct$0","ppat_array","ppat_or","ppat_constraint","ppat_type","ppat_lazy","ppat_unpack","ppat_exception","ppat_extension","ppat_open","cnum","rtag","rinherit","psig_value","psig_type","psig_typesubst","psig_typext","psig_exception","psig_module","psig_modsubst","psig_recmodule","psig_modtype","psig_open","psig_include","psig_class","psig_class_type","psig_attribute","psig_extension","pstr_primitive","pstr_type","pstr_typext","pstr_exception","pstr_module","pstr_recmodule","pstr_modtype","pstr_open","pstr_class","pstr_class_type","pstr_include","pstr_attribute","pstr_extension","toplevel_directive","type_declaration","private$0","type_exception","type_extension","constructors","value_binding","value_description","prim","nonrec_type_declaration","mk","lident$0","pexp_tuple$0","ppat_tuple$0","ptyp_tuple","pexp_tuple_opt","ppat_tuple_opt","ptyp_poly","pexp_apply$0","eint$0","echar","estring$0","efloat$0","eint32","eint64","enativeint","ebool","evar$0","pint","pchar","pstring","pfloat","pint32","pint64","pnativeint","pbool","pvar$0","eunit$0","punit","eapply$0","eabstract","esequence","elist$0","plist$0","type_constr_conv$0","unapplied_type_constr_conv","make$9","get$15","fold_dot_suffixes","collapse_after_at","parts","parts$1","parts$0","make$10","matches","matched","create_set","fully_qualified_names","attributes$0","list$5","is_whitelisted","reserve","is_in_reserved_namespaces","ignore_checks","create$74","current_file","string_of_context","get_all_for_context","check_collisions_local","caller","all_for_context","declared_at","context$0","check_collisions","register$1","kind$0","raise_errorf$1","white_list","white_list$0","other_contexts","current_context","a_or_an","rev_others","others","meths$0","nmeths","nvals","pstr","pstr_eval$0","restore_context","backup","incr_matched","parse$4","on_error","param$2","nil","symbol$209","symbol$210","map$69","many","single_expr_payload","get_pstr_eval","st","get_pstr_extension","get_psig_extension","get_attributes","get_attribute_if_is_floating_n","dummy_ext","name$97","registrar","declare","pattern","not_seen","mark_as_seen","do_mark_as_seen","get$16","longest_match","longest_match$1","longest_match$0","attr$0","name$98","declare$0","convert$0","check_attribute","item$0","item$1","closed_flag","end_marker","end_marker_str","extract_prefix","remove_loc","remove_loc$0","prev$1","diff_asts","generated","round_trip","with_temp_file","fn1","fn2","ast","cmd$0","parse_string","match_loop","mismatch_handler","source","expected$0","source$0","source$1","expected$1","do_match","get_loc","get_loc$0","to_sexp$0","match_structure","match_signature","class_expr$3","class_field$1","class_type$4","class_type_field$0","expression$0","module_expr$1","module_type$3","pattern$1","signature_item$2","structure_item$1","get_extension","virtual_payload","merge_attributes","registrar$0","with_arg","ext","i$4","convert$1","convert_inline","filter_by_context","expanders","expanders$0","fail$2","split_normal_and_expect","split_normal_and_expect$0","filter$7","extension$0","attr_str_type_decl","expand","attr_sig_type_decl","attr_str_module_type_decl","attr_sig_module_type_decl","attr_str_type_ext","attr_sig_type_ext","attr_str_exception","attr_sig_exception","attr_str_type_decl_expect","attr_sig_type_decl_expect","attr_str_module_type_decl_expe","attr_sig_module_type_decl_expe","attr_str_type_ext_expect","attr_sig_type_ext_expect","attr_str_exception_expect","attr_sig_exception_expect","hook","replace$0","insert_after","map_nodes","super_call","base_ctxt","in_generated_code","extension_point_loc","generated_code","get_group","vals$0","rev_concat","sort_attr_group_inline","sort_attr_inline","context_free_attribute_modific","handle_attr_group_inline","items","expanded_items","expect_items","handle_attr_inline","expanded_item","expect_mismatch_handler","items$0","exp_tds","exp_rf","tds","extra_items","with_extra_items","exp_te","extra_items$0","expect_items$0","exp_ec","ec","extra_items$1","expect_items$1","exp_mtd","extra_items$2","expect_items$2","original_rest","repl","pexp_attributes$1","pexp_attributes$2","expand_constant","rules","special_functions","special_functions$0","extensions","class_expr","class_field","class_type","class_type_field","module_expr","module_type","signature_item","structure_item","ppx_import","attr_sig_exceptions_expect","attr_sig_exceptions","map_node","ctxt$0","ext$0","mk_attr_noloc","hide_attribute","add_arg","loc_fname","perform_checks$0","perform_checks_on_extensions$0","perform_locations_check$0","no_merge","given_through_cli","has_name","all$7","print_caller_id","caller_id","add_ctxt_arg","register_transformation","enclose_impl","enclose_intf","impl","intf","lint_impl","lint_intf","preprocess_impl","preprocess_intf","impl$0","intf$0","preprocess_impl$0","preprocess_intf$0","lint_impl$0","lint_intf$0","enclose_impl$0","enclose_intf$0","instrument","extensions$0","rules$0","aliases","rules$1","new_fn","old_fn","parse_apply_list","mask$1","handle_apply","handle_dont_apply","set_cookie","shared_args","pretty","patt","vars_of","st$2","st$0","vb","st$1","add_dummy_user_for_values","binds_module_names","do_insert_unused_warning_attri","keep_w32_impl","keep_w32_intf","keep_w32_spec","conv_w32_spec","keep_w32_impl$0","keep_w60_impl","keep_w60_intf","keep_w60_spec","names$0","create$75","apply$8","make_noarg","deps$0","deps","arg_names","apply_all","generators","spellcheck_msg","str_type_decl","str_type_ext","str_exception","str_module_type_decl","sig_type_decl","sig_type_ext","sig_exception","sig_module_type_decl","resolve_actual_derivers","collected","resolve_internal","not_supported","spellcheck","resolve","resolve_all","derivers","derivers_and_args","named_generators","actual_deriver_name","dep","dep_name","add$29","extension$1","actual_deriver","invalid_with","generator_name_of_id","f$13","mk_deriving_attr","generator_name","disable_warnings_attribute","warning","inline_doc_attr","wrap_str","hide","warnings$0","warnings$2","warnings$1","wrap_sig","sg$0","sg$1","merge_generators","expand_str_type_decls","expand_sig_type_decls","expand_str_module_type_decl","generators$0","expand_sig_module_type_decl","expand_str_exception","expand_sig_exception","expand_str_type_ext","expand_sig_type_ext","expand_sig","expand_str","rule_str","rule_sig","rule_str_expect","rule_sig_expect","deriving_attr","deriving_attr_expect","rules_type_decl","rules_type_ext","rules_exception","rules_module_type_decl","error$6","unsupported","internal_error","short_string_of_core_type","loc_map$0","lident_loc","prefixed_type_name","observer_name","shrinker_name","pname","ename","gensym","sym","gensyms","loc_list","fn_map_label","f_expr","f_pat","x_expr","x_pat","create_list","salt","location$0","weight_attribute","weight$3","core_type_list","label_decl_list","label_decl","pattern$2","pat_list","expression$1","expr_list","create_list$0","salt$0","location$1","weight_attribute$0","weight$4","core_type_list$0","pattern$3","expression$2","create$76","location$2","pattern$4","expression$3","create$77","location$3","core_type$3","pattern$5","expression$4","compound_sequence","make_compound_expr","field_pats","field_exprs","shrinker_exprs","compound","shrinker_of_core_type","variant$2","variant_type","clauses","Clause","clauses$0","clause","empty$31","lookup$2","of_alist$6","variance_error","create_with_variance","covariant","contravariant","param_list","injectivity","variance","expr$0","pat$0","by_variance_list","covariant_t","tyvar$0","contravariant_t","compound_generator","generator_list","size_expr","size_pat","random_expr","random_pat","compound$0","generator_of_core_type","variant$3","rec_names","make_generator","make_pair","nonrecursive_clauses","nonrec_expr","nonrec_pat","rec_expr","rec_pat","nonrec_exprs","nonrec_pats","rec_exprs","rec_pats","weight_expr","gen_expr","pairs","compound_hash","hash_expr","hash_pat","observer_exprs","body_expr","field_expr","observer_expr","compound$1","observer_of_core_type","variant$4","custom_extension","generator_attribute","obs_env","gen_env","output_type","input_type","generator_of_core_type$0","input_generator","output_observer","unlabelled","observer_of_core_type$0","input_observer","output_generator","generator_impl","observer_impl","shrinker_impl","maybe_mutually_recursive","of_lazy","decls$0","decl","impls","pats","inner_bindings","lazy_expr","covar","contravar","covar$0","contravar$0","type_decl$0","shrinker_intf","generator_intf","observer_intf","sig_type_decl$0","str_type_decl$0","rec_flag$0","generator_extension","observer_extension","shrinker_extension","create$78","fu$0","three_u_squared","sqrt_neg_three_u_squared","potential_xs","alpha_inv","temp","t2_plus_fu","t2_inv","temp$0","try_decode","group$93","bin_shape_t$97","group$94","bin_shape_t$98","group$95","create$79","first_map","three_fourths","curve_eqn","conic_c","conic_d","projection_point","field_to_conic","z0","conic_to_s","s_to_v","s_to_v_truncated","to_group","include","on_conic","on_s","on_v","conic_gen","symbol$211","unsafe_set_uint8","make_alphabet","emap","dmap","default_alphabet","unsafe_set_be_uint16","error_msgf","encode_exn","alphabet$0","emap$0","emit","decode$0","invalid_pad_overflow","get_uint8_or_padding","dmap$0","only_padding","idx$0","wrap$3","non_residue","sqrt_flagged","x2_is_first","x3_is_first","to_group$0","append$6","field_elements","to_input","packeds","packed","xn","pack_to_fields","acc_n","packed_bits","append$7","field_elements$0","bitstring","pack_bits","max_size","bitstrings","field_bits","rev_fields","remaining_length","remaining_bits","packed_field_elements","pack_to_fields$0","return$25","bind$24","map$70","run$6","u8","u32","many$0","exactly","t_036","t_035","t_037","bits_of_byte","string_of_field","field_of_string","gen_field","gen_input","middle","serialized","len_to_string","u8x32","parser","normalized","v_bitstrings","v_field_elements","a_069","b_070","a_015","b_016","bools_equal","bitstring_bits","input_field","packed_fields","final_field_idx","input_bitstrings$3","input_bitstrings","packed_fields$0","packed_fields$1","packed_field","bp","input_bitstrings$0","input_bitstring","bi","packed_fields$2","input_bitstrings$1","packed_fields$3","input_bitstrings$2","of_vector_unsafe","group$96","bin_shape_t$99","bin_write_t$50","bin_read_t$86","t_of_sexp$82","sexp_of_t$91","hash_fold_proofs_verified","path$4","to_int$8","of_int$10","to_input$0","to_input$1","one_hot","typ$10","group$97","bin_shape_t$100","path$5","group$98","bin_shape_t$101","bin_read_t$87","group$99","bin_shape_t$102","bin_size_t$49","bin_write_t$51","bin_read_t$88","group$100","bin_shape_t$103","group$101","bin_shape_t$104","t_of_sexp$83","sexp_of_t$92","compare$109","hash_fold_t$55","hash$49","path$6","equal$62","group$102","bin_shape_t$105","path$7","h$1","to_bits$0","to_yojson$18","symbol$212","of_yojson$13","yojson","to_hex$3","of_hex","sexp_of_t$93","t_of_sexp$84","group$103","bin_shape_t$106","path$8","n_expected","of_tick_field","of_tock_field","to_tick_field","to_tock_field","of_bits_msb","v_proofs_verified","v_domain_log2","domain_log2","proofs_verified","proofs_verified_field","domain_log2_field","domain_log2_value","proofs_verified_value","proofs_verified_mask","four","packed_typ","y7","y6","y5","y4","assert_16_bits","group$104","bin_shape_t$107","challenge","bin_size_t$50","size_of_challenge","bin_write_t$52","write_challenge","bin_read_t$89","of_challenge","v_prechallenge","to_yojson$19","poly_challenge","of_yojson$14","t_of_sexp$85","prechallenge_field","prechallenge_value","sexp_of_t$94","compare$110","cmp_challenge","hash_fold_t$56","hash_fold_challenge","equal$63","prechallenge","typ$11","chal","to_yojson$20","symbol$213","group$105","digest$0","size_of_digest","write_digest","bin_writer_t$42","bin_read_t$90","of_digest","bin_reader_t$42","bin_t$42","version$11","versioned$1","compare$111","of_digest$0","of_digest$1","hash_fold_digest","hash$50","equal$64","path$9","to_bits_unboolean","pack$0","t_constant_opt","spec$0","t_constant_opt$0","spec$1","t_constant_opt$1","spec$2","t_constant_opt$2","spec$3","spec$4","t_const","spec$5","tl_constant_opt","hd_constant_opt","hd$1","dummy2","dummy1","t_constant_opt$3","t_constant_opt$4","b_constant_opt","x_constant_opt","dummy2$0","dummy1$0","inner$0","t_constant_opt$5","t_constant_opt$6","spec$6","t_constant_opt$7","typ$12","flag$0","assert_eq","constant_var","etyp","f_inv","f_inv$0","f_inv$1","f1_inv","f2_inv","f_bool","f_bool$0","f_a","f_a$0","opt_map","f_inv$2","f_inv$3","typ$5","pack$1","typ$13","etyp$0","bp_challenge","group$106","to_hlist$13","of_hlist$13","to_struct","of_struct","to_hlist$14","zeta_to_domain_size","zeta_to_srs_length","of_hlist$14","to_minimal","group$107","to_hlist$15","branch_data","bulletproof_challenges","combined_inner_product","plonk","of_hlist$15","group$108","map_challenges","scalar","typ$14","dummy_scalar","dummy_scalar_challenge","scalar_challenge$0","rot$0","xor$0","foreign_field_mul$0","range_check1$0","range_check0$0","constant_typ","bool_typ_of_flag","group$109","bin_shape_t$108","bin_size_t$51","size_of_g1","size_of_bulletproof_challenges","bin_write_t$53","write_g1","write_bulletproof_challenges","bin_read_t$91","of_g1","of_bulletproof_challenges","v_old_bulletproof_challenges","to_hlist$16","old_bulletproof_challenges","of_hlist$16","to_field_elements","g1_to_field_elements","group$110","to_hlist$17","messages_for_next_wrap_proof","sponge_digest_before_evaluatio","deferred_values","of_hlist$17","bulletproof_challenges$0","bool$2","fp$0","scalar_challenge$1","challenge$0","group$111","to_field_elements_without_inde","app_state_to_field_elements","app_state","bp_chals","digest$1","fp$1","scalar_challenge$2","plonk$0","bp_chals$0","digest$2","messages_for_next_wrap_proof$0","bool$3","fp$2","scalar_challenge$3","challenge$1","group$112","f8","f7","f6","f5","maybe_constant","feature_flags_spec","use","to_data$0","option_map","to_opt","messages_for_next_step_proof","of_data$1","of_opt","feature_flags$0","to_minimal$0","proof_state","to_wrap","opt_none","of_wrap","assert_none","assert_false","map_challenges$0","bp_log2","to_data$1","should_finalize","of_data$2","typ$15","to_hlist$18","unfinalized_proofs","of_hlist$18","to_data$2","of_data$3","per_proof","hash_fold_t$57","hash$51","compare$112","t_of_sexp$86","sexp_of_t$95","hash_fold_t$58","hash$52","compare$113","t_of_sexp$87","sexp_of_t$96","equal$65","rhs0$0","lhs0$0","rhs0$1","lhs0$1","rhs0$2","lhs0$2","rhs0$3","lhs0$3","hash_fold_t$59","a0$1","a0$2","a0$3","hash$53","compare$114","t_of_sexp$88","sexp_of_t$97","if_feature","unnormalized_lagrange_basis","vanishes_on_last_4_rows","endo_coefficient","alpha_pow","x_0","x_1","x_2","x_3","x_4","x_5","x_6","x_7","x_8","x_9","x_10","x_11","x_12","x_13","x_14","x_15","x_15$0","x_16","x_15$1","x_16$0","x_17","x_18","x_18$0","x_19","x_18$1","x_19$0","x_20","x_21","x_21$0","x_22","x_21$1","x_22$0","x_23","x_24","x_24$0","x_25","x_24$1","x_25$0","x_26","x_27","x_27$0","x_28","x_27$1","x_28$0","x_29","x_30","x_31","x_32","x_33","x_34","x_35","x_36","x_37","x_38","x_39","x_40","x_41","x_42","x_43","x_44","x_45","x_46","x_47","x_48","constant_term$0","index_terms$0","pow2pow","shifts$0","zetaw","rounds","expand_feature_flags","features","lookup_pattern_range_check","lookup_pattern_xor","table_width_at_least_2","table_width_at_least_1","all_feature_flags","endo","field_of_hex","srs_length_log2","get_eval","zk_polynomial","zeta_to_n_minus_1","feature","w_to_i","perm_alpha0","ft_eval0","p_eval0","e0_s","zkp","zeta1m1","w_n","ft_eval0$0","ft_eval0$1","nominator","ft_eval0$2","derive_plonk","w0$0","joint_combiner$0","seal","choose","shifted_pow","crs_max_degree","deg","num_shifts","log2s","all_shifts","other_shiftss","all_the_same","which","to_domain","log2_sizes","generator$0","max_log2","mina_alphabet","version_byte","version_byte$0","version_byte$1","version_byte$2","version_byte$3","version_byte$4","version_byte$5","version_byte$6","version_byte$7","version_byte$8","version_byte$9","version_byte$10","version_byte$11","version_byte$12","version_byte$13","version_byte$14","version_byte$15","version_byte$16","version_byte$17","checksum_len","version_string","compute_checksum","ctx0","ctx1","ctx2","first_hash","ctx3","second_hash","checksum","decode_exn","decoded","error_str","test_roundtrip","encoded","payload$0","last_ch","new_last_ch","encoded_bad_checksum","check_encoding","to_base58_check","of_base58_check","of_base58_check_exn","to_base64","of_base64","b64","rev_events","log_func","apply_args","ay","ax","x_squared","x_squared$0","ay$0","lambda$0","ax$0","bx","bx$0","by","cx","cx$0","cy","assert_on_curve","typ_unchecked$0","ey","ex","unshift_nonzero","bs0","S","bs0$0","add_pt","windows","g3","pow2s","group_map","unrelated_base","div_unsafe","add_unsafe","lookup_point","b0_and_b1","lookup_one","pc","bs$1","windows_required","bit_pair","with_shifts","unshift","multiscale_known","scale_known","conditional_negation","p_plus_q_plus_p","lambda_1","lambda_2","scale_fast","scale_constant","bs$2","message$4","message$5","comparator$5","compare$115","to_yojson$21","of_yojson$15","sexp_of_t$98","t_of_sexp$89","compare$116","sexpifier$0","v_identifier","v_type","compare$117","to_int","compare$118","t_of_sexp$90","previous_state_hash_field","previous_length_field","previous_global_slot_field","previous_global_slot_value","previous_length_value","previous_state_hash_value","sexp_of_t$99","v_previous_global_slot","v_previous_length","v_previous_state_hash","compare$119","sexpifier$1","v_fork","v_account_creation_fee","v_supercharged_coinbase_factor","v_coinbase_amount","v_pending_coinbase_depth","v_transaction_capacity","v_block_window_duration_ms","v_work_delay","v_ledger_depth","v_sub_windows_per_window","compare$120","header_version","to_yojson$22","compare$121","prefix_len","parse_lexbuf","yojson_parsebuffer","read_prefix","valid_header","valid_header_string","valid_header_with_prefix","fake_prefix","partial_prefix","from_string","initial_prefix_len","write_with_header","expected_max_size_log2","append_data","header_string","length_offset","length_string","length_data_offset","out_channel","true_length","true_length_string","true_length_padding","read_with_header","read_data","file_length","header_json","sexp_to_yojson","info_internal_repr_to_yojson","info$5","info$0","tag$0","info$1","tag$1","infos","trunc_after$0","acc_len","infos$0","rev_json_infos","infos$2","info$3","json_info$0","acc_infos$0","acc_len$1","infos$1","info$2","json_info","acc_infos","acc_len$0","length$2","trunc_after$1","json_infos","info$4","base_pairs","trunc_after","json$0","tag_to_json","jsons","jsons$0","group$113","bin_shape_t$109","path$10","group$114","bin_shape_t$110","path$11","group$115","bin_shape_t$111","path$12","compare$122","a_285","b_286","t_042","t_044","t_043","t_046","t_045","t_048","t_047","t_052","t_051","t_054","t_053","a_171","b_172","t_174","t_173","t_176","t_175","a_177","b_178","t_180","t_179","t_182","t_181","t_184","t_183","t_186","t_185","a_187","b_188","t_190","t_189","t_192","t_191","t_194","t_193","t_196","t_195","t_198","t_197","t_200","t_199","t_202","t_201","t_204","t_203","t_206","t_205","t_208","t_207","t_210","t_209","t_212","t_211","t_214","t_213","t_216","t_215","a_293","b_294","a_287","b_288","t_290","t_289","t_292","t_291","a_279","b_280","t_282","t_281","t_284","t_283","sexp_of_t$100","v_bulletproof","v_evaluations","v_commitments","v1$11","v1$12","v1$13","v1$14","to_kimchi_proof","bulletproof","evaluations","of_kimchi_proof","debug$1","absorb_field","absorb_scalar","mask_g1_opt","absorb$0","absorb$1","ones_vector","first_zero","lowest_128_bits","constrain_low_bits","assert_128_bits","num_bits$7","to_field_checked","bits_msb","nybbles_per_row","rows","nybbles_by_row","to_field_checked$0","to_field_constant","r_2i1","test$0","seal$0","rounds_rev","n_acc_prev","xq1","yq1","s1_squared","xq2","yq2","s3_squared","random_point","endo_inv","gy","gx","endo_to_field","base$0","scalar$0","endo_to_field$0","forbidden_shifted_values","two_to_n","neg_two_to_n","representatives","generate$0","keypair","other_mod","f$14","forbidden_shifted_values$0","high$0","check$5","x_eq","b_eq","typ$16","wrap_rounds","other_mod$0","f$15","forbidden_shifted_values$1","typ$17","t0$0","check$7","typ_unchecked$1","typ$18","input$1","high_entropy_bits","to_the_alpha","add_assign","apply_affine_map","constants","matrix","dotv","copy$0","underlying","last_squeezed","squeeze_field","params$3","step_log2","step","mk$24","tock_shifts","tick_shifts","wrap_domains","hash_messages_for_next_step_pr","app_state$0","dlog_plonk_index","dlog_pcs_batch","when_profiling","profiling","tock2","tick_zero","zero$10","finite_exn","or_infinite_conv","compute_challenge","compute_challenges","field$2","compute_challenge$0","compute_challenges$0","compute_sg","field$3","compute_challenge$1","compute_challenges$1","tock_unpadded_public_input_of_","prev_statement","tick_public_input_of_statement","max_proofs_verified","ft_comm","sigma_comm_last","f_comm","chunked_t_comm","combined_evaluation","fx$0","fx$1","of_sponge","add_in","i_equals_0","i_equals_j","cond_permute","permute","permuted","add_in_y_after_perm","add_in_y_before_perm","empty_imput","should_permute","n_pre","filtered","pre$0","filtered_res","opt_res","custom_printf_006","custom_printf_007","custom_printf_008","add_fast","check_finite","p1$0","p2$0","same_x_bool","x1_squared","y1$0","add_fast$0","bits_per_chunk","chunks_needed","scale_fast_msb_bits","y_base","x_base","y_acc","x_acc","x_res","y_res","slopes","accs$0","scale_fast_unpack","scale_fast2","s_odd","s_div_2","s_div_2_bits","chunks_needed$0","actual_bits_used","bits_lsb","scale_fast2$0","Scalar_field","s_parts","custom_printf_005","create$80","create$81","hash$54","ro","tock","tick","scalar_chal","evals_combined","dummy_chals","challenges_computed","challenges_computed$0","group$116","bin_shape_t$112","bpcs","bin_size_t$52","size_of_s","size_of_challenge_polynomial_c","size_of_bpcs","bin_write_t$54","write_s","write_challenge_polynomial_com","write_bpcs","bin_read_t$92","of_s","of_challenge_polynomial_commit","of_bpcs","v_app_state","prepare","group$117","bin_shape_t$113","bin_read_t$93","path$13","t_of_sexp$91","sexp_of_t$101","hash_fold_t$60","f$16","sponge_params_constant","read_step_circuit_field_elemen","prover_fe","sponge_params","one$10","group_size_in_bits","constant$4","typ$19","scale$2","inv_exn","symbol$214","symbol$215","symbol$216","negate$2","inv_exn$0","symbol$217","symbol$218","symbol$219","equal$66","t_of_sexp$92","sexp_of_t$102","scale$3","zero$11","symbol$220","negate$3","to_affine_exn$1","of_affine$1","typ$20","typ_unchecked$2","constant$5","symbol$221","double$3","scale$4","to_field_elements$0","scale_inv","negate$4","one$11","if$3","h$2","max$25","hash_fold_vk","group$118","bin_shape_t$114","bin_size_t$53","bin_write_t$55","bin_read_t$94","bin_read_t$95","v_max_proofs_verified","v_actual_wrap_domain_size","v_wrap_index","path$14","versioned$2","func$15","to_repr","wrap_index","actual_wrap_domain_size","of_repr","public$0","wrap_vk","max_proofs_verified_field","actual_wrap_domain_size_field","wrap_index_field","wrap_index_value","actual_wrap_domain_size_value","max_proofs_verified_value","cmp_comm","to_binable$10","of_binable$12","bin_size_t$54","bin_write_t$56","bin_read_t$96","bin_read_t$97","bin_shape_t$115","bin_writer_t$43","bin_reader_t$43","bin_t$43","path$15","g$1","to_hlist$19","of_hlist$19","to_input$2","max_proofs_verified$0","actual_wrap_domain_size$0","bp_chals$1","messages_for_next_wrap_proof$1","fp$3","scalar_challenge$4","challenge$2","group$119","bin_shape_t$116","bin_size_t$55","size_of_messages_for_next_wrap","size_of_messages_for_next_step","v3$6","v2$18","v1$18","size$45","size_of_scalar_challenge","v2$6","v3$2","v2$5","v3$1","v2$4","v6$0","v5$0","v4$0","v2$3","size$46","size_of_f_multi$0","size_of_f_multi","size$47","v4$2","v3$5","v2$17","v1$17","v3$3","v2$7","size$41","v2$8","size$23","size$42","v8$0","v7$0","v6$1","v5$1","v4$1","v3$4","v2$9","size$24","size$25","size$26","v2$10","size$27","size$28","size$29","v2$11","size$30","size$31","v2$12","size$32","size$33","v2$13","size$34","size$35","v2$14","size$36","size$37","v2$15","v1$15","size$38","size$39","v2$16","v1$16","size$40","size$43","size$44","bin_write_t$57","write_messages_for_next_wrap_p","write_messages_for_next_step_p","write_scalar_challenge","write_f_multi$0","write_f_multi","bin_read_t$98","of_messages_for_next_wrap_proo","of_messages_for_next_step_proo","bin_read_t$99","of_scalar_challenge","v_alpha","v_beta","v_gamma","v_zeta","v_joint_combiner","v_range_check0","v_range_check1","v_foreign_field_add","v_foreign_field_mul","v_xor","v_rot","v_runtime_tables","v_feature_flags","v_plonk","v_bulletproof_challenges","v_branch_data","v_deferred_values","v_sponge_digest_before_evaluat","v_messages_for_next_wrap_proof","v_proof_state","v_messages_for_next_step_proof","v_statement","v_prev_evals","v_ft_eval1$0","most_recent_width","g0","tick_arr","lengths","fields$85","fields$76","fields$38","fields$39","fields$40","fields$41","fields$42","fields$77","fields$78","fields$66","fields$67","arg1$3","arg0$3","fields$68","arg1$4","arg0$4","fields$69","arg1$5","arg0$5","fields$70","arg1$6","arg0$6","fields$71","fields$72","arg1$7","arg0$7","fields$73","fields$74","fields$75","fields$79","fields$62","fields$63","fields$64","fields$65","fields$80","fields$86","poly_f_multi$0","fields$36","poly_f_multi","fields$33","fields$25","fields$26","fields$27","fields$28","fields$29","fields$30","fields$31","fields$32","fields$34","fields$35","fields$37","fields$87","poly_bool","poly_scalar_challenge","fields$59","fields$81","fields$82","fields$83","fields$84","fields$60","fields$55","fields$52","fields$53","fields$54","fields$56","fields$57","fields$49","fields$50","fields$43","fields$44","fields$45","fields$46","fields$47","fields$48","fields$51","fields$58","fields$61","fields$88","xs$69","xs$70","state$67","arg2$7","arg1$13","arg0$13","xs$71","x$42","xs$48","xs$49","arg1$8","arg0$8","xs$51","x$31","xs$64","xs$65","arg2$6","arg1$12","arg0$12","xs$68","x$41","state$66","xs$67","x$40","xs$66","x$39","xs$50","x$30","xs$43","xs$44","state$47","arg2$3","xs$47","x$29","xs$34","xs$35","arg2$2","xs$38","x$24","xs$37","xs$36","xs$26","xs$27","arg5$0","arg4$1","arg3$1","xs$33","xs$32","xs$31","xs$30","xs$29","xs$28","xs$46","x$28","xs$39","xs$40","xs$42","x$26","state$46","xs$41","x$25","xs$45","x$27","state$68","xs$72","x$43","xs$58","xs$59","arg3$2","arg2$5","arg1$11","arg0$11","xs$63","x$38","state$27","arg4$0","arg3$0","xs$62","x$37","xs$52","xs$53","arg2$4","arg1$9","arg0$9","xs$56","x$34","xs$55","x$33","xs$54","x$32","arg1$10","arg0$10","xs$61","x$36","xs$57","xs$60","x$35","state$69","xs$73","x$44","poly_f_multi$1","state$70","a_157","b_158","n$43","n$40","n$39","cmp_scalar_challenge","n$38","n$33","n$34","n$35","n$36","n$37","n$41","a_111","b_112","n$42","n$47","n$46","a_173","b_174","n$45","a_179","b_180","a_181","b_182","a_183","b_184","cmp_f_multi","a_117","b_118","a_119","b_120","a_115","b_116","n$44","t_238","t_237","t_240","t_239","a_241","b_242","t_244","t_243","t_246","t_245","a_113","b_114","a_121","b_122","a_123","b_124","a_125","b_126","a_127","b_128","a_129","b_130","a_131","b_132","a_133","b_134","a_135","b_136","a_137","b_138","a_139","b_140","a_141","b_142","a_143","b_144","a_145","b_146","a_147","b_148","statement_field","prev_evals_field","sexp$6","of_bp_chals","of_scalar_challenge$0","proof_state_field","messages_for_next_step_proof_f","deferred_values_field","messages_for_next_wrap_proof_f","old_bulletproof_challenges_fie","old_bulletproof_challenges_val","plonk_field","bulletproof_challenges_field","branch_data_field","alpha_field","beta_field","gamma_field","zeta_field","joint_combiner_field","feature_flags_field","feature_flags_value","joint_combiner_value","zeta_value","gamma_value","beta_value","alpha_value","branch_data_value","bulletproof_challenges_value","plonk_value","messages_for_next_wrap_proof_v","sponge_digest_before_evaluatio$0","deferred_values_value","sexp$5","app_state_field","challenge_polynomial_commitmen$1","old_bulletproof_challenges_fie$0","old_bulletproof_challenges_val$0","challenge_polynomial_commitmen$2","app_state_value","messages_for_next_step_proof_v","proof_state_value","sexp$7","commitments_field","evaluations_field","ft_eval1_field$0","bulletproof_field","bulletproof_value","ft_eval1_value$0","evaluations_value","commitments_value","sexp$8","of_f_multi$2","evals_field$0","of_f_multi$1","public_input_field","public_input_value","evals_value$0","prev_evals_value","statement_value","v_old_bulletproof_challenges$0","v_challenge_polynomial_commitm$0","hsv$71","hash_fold_scalar_challenge","hsv$39","hsv$40","hsv$41","hsv$42","hsv$43","hsv$70","hsv$44","hsv$46","hsv$45","hsv$74","hsv$69","hsv$73","hsv$72","hash_fold_f_multi$0","hash_fold_f_multi","hsv$34","hsv$47","e0$0","hsv$48","hsv$49","hsv$50","hsv$51","hsv$52","e0$1","hsv$53","hsv$54","hsv$55","e0$2","hsv$56","hsv$57","e1$3","e0$3","hsv$58","hsv$59","e1$4","e0$4","hsv$60","hsv$61","e1$5","e0$5","hsv$62","hsv$63","e1$6","e0$6","hsv$64","hsv$65","e1$7","e0$7","hsv$66","hsv$67","hsv$68","hsv$35","hsv$36","hsv$37","hsv$38","a_185","b_186","a_201","b_202","a_205","b_206","a_207","b_208","a_209","b_210","a_211","b_212","a_153","b_154","a_155","b_156","a_151","b_152","t_252","t_251","t_254","t_253","a_255","b_256","t_258","t_257","t_260","t_259","a_159","b_160","a_161","b_162","a_163","b_164","a_165","b_166","a_167","b_168","a_169","b_170","a_175","b_176","t_060","t_059","t_062","t_061","t_064","t_063","t_066","t_065","t_070","t_069","t_072","t_071","a_219","b_220","t_222","t_221","t_224","t_223","a_225","b_226","t_228","t_227","t_230","t_229","t_232","t_231","t_234","t_233","a_235","b_236","t_242","t_241","t_248","t_247","t_250","t_249","t_252$0","t_251$0","t_254$0","t_253$0","t_256","t_255","t_262","t_261","t_264","t_263","a_303","b_304","t_300","t_299","to_yojson_full","group$120","bin_shape_t$117","bin_size_t$56","bin_write_t$58","bin_read_t$100","bin_read_t$101","path$16","of_yojson$16","to_yojson$23","sexp_of_t$104","t_of_sexp$94","hash$56","hash_fold_t$62","equal$68","compare$124","of_repr$0","to_repr$0","versioned$3","path$17","of_yojson$17","to_yojson$24","to_yojson_full$0","sexp_of_t$105","t_of_sexp$95","hash$57","hash_fold_t$63","equal$69","compare$125","group$121","bin_shape_t$118","bin_size_t$57","bin_write_t$59","bin_read_t$102","bin_read_t$103","path$18","of_yojson$18","to_yojson$25","sexp_of_t$106","t_of_sexp$96","hash$58","hash_fold_t$64","equal$70","compare$126","of_repr$1","to_repr$1","versioned$4","path$19","params$4","sponge_params_constant$0","read_wrap_circuit_field_elemen","sponge_params$0","squeeze_field$0","one$12","group_size_in_bits$0","constant$6","typ$22","if$4","scale$5","inv_exn$1","symbol$222","symbol$223","symbol$224","negate$5","negate$6","square$3","inv_exn$2","symbol$225","symbol$226","symbol$227","assert_square$2","assert_r1cs$2","equal$72","t_of_sexp$98","sexp_of_t$108","scale$6","random$2","zero$12","symbol$228","negate$7","to_affine_exn$2","of_affine$2","multiscale_known$0","typ$23","typ_unchecked$3","constant$7","symbol$229","double$4","scale$7","to_field_elements$1","scale_inv$0","negate$8","g$2","if$5","h$3","pad_vector","pad_challenges","chalss","pad_accumulator","hash_messages_for_next_wrap_pr","of_proof","dummy_messages_for_next_wrap_p","full_state","s0","hash_messages_for_next_wrap_pr$0","challenge_polynomial","num_possible_domains","all_possible_domains","to_bits_unsafe","absorb_shifted","absorb_shifted$0","print_g","print_w","print_chal","print_bool","scalar_to_field","assert_n_bits","lowest_128_bits$0","squeeze_challenge","squeeze_scalar","bullet_reduce","gammas","prechallenges","gammas_i","term_and_challenge","left_term","right_term","equal_g","choose_key","lagrange","which_branch","scaled_lagrange","lagrange_with_correction","base_and_correction","pr","h_precomp","finite","batch","without_bound","with_bound","keep","point","check_bulletproof","pcs_batch","advice","combined_polynomial","scale_fast$0","lr_prod","uc","p_prime","cq","b_u","z_1_g_plus_b_u","z2_h","absorb$2","iter2","zeta_1","gamma_1","beta_1","alpha_1","zeta_0","gamma_0","beta_0","alpha_0","assert_eq_plonk","incrementally_verify_proof","Max_proofs_verified","actual_proofs_verified_mask","step_domains","sg_old","openings_proof","sg_old$0","sample","sample_scalar","index_sponge","index_digest","without","absorb_g","public_input$0","non_constant_part","constant_part","corr","correction","x_hat","x_hat$0","sponge$0","sponge_before_evaluations","sigma_comm_init","ft_comm$0","mask_evals","challenge_polynomial$0","actual_evaluation","pt_to_n","pt_n_acc","shift1","shift2","map_plonk_to_field","finalize_other_proof","Proofs_verified","sg_olds","sg_evals","sg_evals2","sg_evals1","challenge_digest","sponge_state_before","state_before","xi_actual","r_actual","xi_actual$0","xi$0","xi_correct","plonk_minimal","zeta_n","zetaw_n","combined_evals","evals2","ft","sg_evals$0","actual_combined_inner_product","combined_inner_product_correct","challenge_poly","b_actual","b_correct","plonk_checks_passed","to_hlist$20","of_hlist$20","to_hlist$21","of_hlist$21","shift$0","typ$24","create$84","find$17","lookup_compiled","other_id","lookup_side_loaded","lookup_basic","wrap_domains$0","wrap_vk$1","wrap_key$0","ephemeral","wrap_key","wrap_vk$0","set_ephemeral","eph","prover","add_exn$4","print_fp","add_opt","constant_part$0","rr$0","xi_acc","p_is_finite","acc_is_finite","xi_acc$0","p_is_finite$0","is_finite","xi_acc$1","assert_eq_deferred_values","lagrange_commitment","public_input_commitment_dynami","lagrange_commitment$0","select_curve_points","points_for_domain","points","sponge_after_index","receive","domain$0","z_comm$0","t_comm$0","vanishing_polynomial","should_square","side_loaded_domain","max_n","vanishing_polynomial$0","d_unchecked","a_002","b_003","pow2_pow","squeeze_challenge$0","domain_for_compiled","unique_domains","which_log2","actual_width_mask","opt_sponge","a_008","b_009","a_010","b_011","a_006","b_007","xi$1","b_used","state_to_field_elements","after_index","hash_messages_for_next_step_pr$0","not_opt","hash_inputs","sponge$1","accumulation_verifier","accumulator_verification_key","prev_accumulators","new_accumulator","is_base_case","lookup_parameters","wrap_domain","wrap_verification_key","statement","unfinalized","bulletproof_challenges_actual","bulletproof_success","to_hlist$22","prev_challenge_polynomial_comm","prev_proof_evals","wrap_proof","of_hlist$22","to_hlist$23","of_hlist$23","shift$1","dummy$1","one_chal","typ$25","dummy$2","create$85","r$4","start$3","clock","is_odd","wrap_main","full_signature","pi_branches","step_keys","step_widths","Req","Max_widths_by_slot","messages_for_next_wrap_proof_d","which_branch$0","prev_proof_state","step_plonk_index","prev_step_accs","old_bp_chals","new_bulletproof_challenges","wrap_domain_indices","old_bulletproof_challenges$0","old_bulletproof_challenges$1","finalized","prev_messages_for_next_wrap_pr","sacc","max_local_max_proofs_verified","rough_domains","domains$0","ret_conv_inv","main$0","group$122","bin_shape_t$119","path$20","group$123","bin_shape_t$120","bin_size_t$58","bin_write_t$60","bin_read_t$104","bin_read_t$105","v_constraints","v_data","path$21","poly_polyComm","versioned$5","of_repr$2","to_binable$11","of_binable$13","path$22","f_debug","num_choices","choices_length","num_choices$0","dummy_step_domains","dummy_step_widths","dummy_step_keys","constant_term$1","index_terms$1","tick_rounds","AB","challenge_polys","which_eval","sgs","step_vk","actual_proofs_verified","tick_plonk_minimal","tick_combined_evals","tick_domain","tick_env","prechals","shift_value","compute_feature_flags","true_opt","false_opt","test_feature_flags_configs","runtest","deferred_values$0","x_hat_evals","deferred_values_typ","deferred_values$1","no_public_input","gate_example","public_input_1","public_input_2","public_input2","public_input1","example","actual_feature_flags$0","expand_deferred","tick_field","sc","plonk0","step_domain","w$0","challenges_digest","lookup_final_terms","xi_chal","r_chal","combined_inner_product_actual","to_shifted","verify_heterogenous","non_chunking","least_wrap_domain","actual_wrap_domain","accumulator_check","batch_verify_inputs","A_value","prepared_statement","dlog_check","comm_chals","verify_promise","a_value","create$86","proofs_verifieds","auxiliary_typ","var_to_field_elements","value_to_field_elements","rule","self_width","extract_lengths","len_ms","len_ns","branches$0","local_branches_length","local_signature_length","heights","widths","requests","output_typ","ld$0","ds$0","ns1","ns2","ln1","ln2","feature_flagss","feature_flagss$0","ln2$0","ln1$0","ns2$0","ns1$0","prev_proof_typs","output_typ$0","input_typ$0","auxiliary_var","ret_var","previous_proof_statements","ret_value","auxiliary_value","previous_proof_statement","tags$0","stmts","proof_must_verify","public_input$1","previous_proof_statements$0","prevs","unfinalized_proofs_unextended","actual_wrap_domains","stmts$0","stmt","proofs$0","prevs$0","datas","messages_for_next_wrap_proofs","unfinalizeds","actual_wrap_domains$0","should_verify","unfinalizeds$0","messages_for_next_wrap_proofs$0","datas$0","actual_wrap_domain$0","actual_wrap_domain$1","sponge_digest","prev_messages_for_next_step_pr","verified","self_data","own_domains","next_state","Maxes","prevs_length","self_dlog_plonk_index","self_dlog_vk","prev_vars_length","prev_values_length","expand_proof","dlog_vk","dlog_index","must_verify","Local_max_proofs_verified","deferred_values_computed","x_hat_1","zeta$0","alpha$0","zetaw$0","tock_domain","tock_combined_evals","tock_plonk_minimal","true$1","false$1","tock_env","b_polys","ft_eval","shifted_value","statements_with_hashes","x_hats","witnesses","prev_proofs","return_value","unfinalized_proofs$0","unfinalized_proofs_extended","extract_from_proofs","Extract","return_value$0","messages_for_next_step_proof_p","messages_for_next_wrap_proof_p","respond","prev_proof_requests","prev_proof_stmts","prev_proof_stmts$0","ws","prev_proofs$0","witnesses$0","x_hats$0","statements_with_hashes$0","unfinalized_proofs$1","domain_index","to_fold_in","next_proof","prev_evals","next_statement","conv_inv","promise_or_error","next_statement_hashed","auxiliary_inputs","to_string$44","to_string$45","s_p","header_read","s_v","read_or_generate","k_p","k_v","dirty","k_v$0","pk$0","vk$0","header_version_field","constraint_constants_field","commits_field","length_field","commit_date_field","constraint_system_hash_field","identifying_hash_field","type_field","identifier_field","identifier_value","type_value","sub_windows_per_window_field","ledger_depth_field","work_delay_field","block_window_duration_ms_field","transaction_capacity_field","pending_coinbase_depth_field","coinbase_amount_field","supercharged_coinbase_factor_f","account_creation_fee_field","fork_field","fork_value","account_creation_fee_value","supercharged_coinbase_factor_v","coinbase_amount_value","pending_coinbase_depth_value","transaction_capacity_value","block_window_duration_ms_value","work_delay_value","ledger_depth_value","sub_windows_per_window_value","mina_field","marlin_field","marlin_value","mina_value","identifying_hash_value","constraint_system_hash_value","commit_date_value","length_value","commits_value","constraint_constants_value","header_version_value","v_identifying_hash","v_constraint_system_hash","v_commit_date","v_commits","v_constraint_constants","v_header_version","v_marlin","v_mina","t_022","t_020","to_string$46","to_string$47","s_p$0","read_or_generate$0","kp","vk$1","symbol$230","generate_or_load","pad_messages_for_next_wrap_pro","messages_len","maxes_len","maxes$0","maxes$1","compile_with_wrap_main_overrid","disk_keys$0","override_wrap_domain","override_wrap_main","Branches","constraint_constants","self$0","self$1","a_value_to_fields","a_var_to_fields","a_value_to_fields$0","a_var_to_fields$0","conv_irs","snark_keys_header","constraint_system_hash","prev_varss_length","prev_varss_n","padded","enabled","step_data","cache_handle","accum_dirty","disk_keys","cs_hash","ks","step_keypairs","step_vks","wrap_main$0","wrap_main$1","wrap_requests","self_id","disk_key_prover","wrap_disk_key","wrap_pk","computed_domain_size","ks$0","step_pk","step_vk$0","proof$0","which_index","tweak_statement","tweak_statement$0","prev_statement_with_hashes","next_statement$0","next_accumulator","provers","cache_handle$0","verify_promise$0","wrap_main_dummy_override","dummy_id","write","of_compiled","in_circuit","permanent","verify$0","srs_precomputation","compile_promise","return_early_digest_exception","compile","proof_module","adjust_provers","dummy_constraints","b0$0","example$0","prev_input","self_correct","s_neg_one","b_neg_one","b0$1","recursion_proof","recursion_input","no_recursion_proof","no_recursion_input","no_recursive_input","no_recursive_proof","prev_proof","s_neg_one$0","b_neg_one$0","b0$2","example2","example1","s_neg_one$1","b_neg_one$1","b0$3","example2$0","example1$0","b0$4","blinding_value","b0$5","dummy_proof","pairing_vk","tick_combined_evals$0","combined_inner_product$0","overwritten_prechals","chals$0","sg_new","proof_with_stmt","assocs","example_proof","example_input","example_proof$0","example_input$0","example_proof$1","example_input$1","side_loaded_tag","maybe_features","params$5","v_u","v_u_over_2","v_y","v_projection_point","v_conic_c","v_a","v_b","v_spec","group_map_params","arg_typ","gen_arg","sexp_of_arg","test1","test2","mul_field","real_part","x_over_y","let_syntax_016","let_syntax_017","let_syntax_018","let_syntax_012","let_syntax_013","let_syntax_014","let_syntax_015","if_value","cond","Shifted","sigma_count","two_to_the_i_plus_1","result_with_shift","let_syntax_021","let_syntax_022","let_syntax_019","let_syntax_020","func$16","length$27","get$17","set$13","length$28","get$18","set$14","bools","v_of_list","pack_value","var_of_bits","var_to_triples","unpack_var","var_of_field_unsafe","unpack_value","compare_var","increment_if_var","increment_var","equal_var","assert_equal_var","pack_int","boolean_assert_lte","assert_decreasing","nth_bit","apply_mask","pack_unsafe","n_ones","total_length","assert_num_bits_upper_bound","masked","size_in_bits_size_in_bits","num_bits_upper_bound_unchecked","leading_zeroes","num_bits_upper_bound_unpacked","x_unpacked","num_bits_upper_bound","decreasing","handle_with$0","handle_with","resp","correct","t_of_sexp$100","sexp_of_t$110","hash_fold_t$66","compare$128","t_of_sexp$101","sexp_of_t$111","bin_size_t$59","bin_write_t$61","bin_read_t$106","bin_read_t$107","empty$32","equal$74","typ$26","t_of_sexp$102","sexp_of_t$112","add$30","typ$27","negate$9","constant$10","if$8","double$5","scale$8","sum$4","make_checked$1","params$6","block_cipher$1","params$7","add_assign$1","copy$10","to_bits$1","update$5","hash$60","pow2$1","to_bits$2","params$8","hash$61","pack_input","pack_input$0","prefix_to_field","salt$1","params$9","rounds_full$0","initial_ark$0","rounds_partial$0","to_the_alpha$1","hash$62","pack_input$1","to_the_alpha$2","seal$1","add_assign$2","apply_affine_map$0","copy$11","params$10","padding_char","create$87","protocol_state","protocol_state_body","account","side_loaded_vk","zkapp_account","zkapp_payload","zkapp_body","merge_snark","base_snark","transition_system_snark","signature_testnet","signature_mainnet","signature_other","chain_name","receipt_chain_user_command","receipt_chain_zkapp","epoch_seed","vrf_message","vrf_output","vrf_evaluation","pending_coinbases","coinbase_stack_data","coinbase_stack_state_hash","coinbase_stack","coinbase","checkpoint_list","zkapp_precondition","zkapp_precondition_account","zkapp_precondition_protocol_st","account_update_account_precond","account_update","account_update_cons","account_update_node","account_update_stack_frame","account_update_stack_frame_con","zkapp_uri","zkapp_event","zkapp_events","zkapp_actions","zkapp_memo","zkapp_test","derive_token_id","salt$2","salt_legacy","cached","cached$0","signature_kind","crypto_hash_prefix","hash_prefix","hash_prefix$0","triple_string","test_to_triples","arbitrary_string","with_randomness","print_digest","check_serialization","known_good_digest","group$124","bin_shape_t$121","group$125","field$4","group$126","create$88","bin_read_t$108","v_x","v_is_odd","bin_size_t$60","bin_write_t$62","to_hlist$24","of_hlist$24","gen$2","group$127","bin_shape_t$122","path$23","version$12","group$128","bin_shape_typ","group$129","bin_shape_t$123","create$89","bin_read_t$109","bin_read_t$110","bin_reader_t$44","bin_size_t$61","bin_write_t$63","bin_writer_t$44","bin_t$44","group$130","size_of_pk","write_pk","bin_writer_t$45","bin_read_t$111","of_pk","bin_reader_t$45","bin_t$45","version$13","equal_key","compare_key$2","hash_fold_t$67","hash$63","to_yojson$28","of_yojson$20","of_pk$0","of_public_key","hash_fold_t$68","uncompressed","path$24","group$131","bin_shape_typ$0","group$132","public_key","create$90","bin_read_t$112","key_to_string","compress$1","empty$33","to_input$3","to_input_legacy","typ$28","var_of_t","equal$75","odd_eq","to_input$4","decompress","y_parity","decompress_exn","compare$129","t_026","t_025","t_028","t_027","hash_fold_t$69","of_yojson$21","compressed","to_yojson$29","sexp_of_t$114","t_of_sexp$104","path$25","group$133","bin_shape_t_tagged$0","create$91","bin_read_t$113","bin_size_t$62","bin_write_t$64","group$134","bin_shape_t$124","bin_size_t$63","bin_write_t$65","bin_writer_t$46","bin_read_t$114","bin_read_t$115","bin_reader_t$46","bin_t$46","compare$130","version$14","t_of_sexp$105","upperbound","path$26","group$135","bin_shape_typ$1","bin_size_typ","bin_write_typ","bin_read_typ","group$136","bin_shape_t_tagged$1","create$92","bin_read_t$116","bin_read_t$117","bin_reader_t$47","bin_size_t$64","bin_write_t$66","bin_writer_t$47","bin_t$47","is_even","derive","k_prime","r_pt","verifier","final_check","e_pk","s_g_e_pk","y_even","r_correct","verifies","assert_verifies","ry_even","network_id_mainnet","network_id_testnet","make_derive","network_id","private_key","network_id_mainnet$0","derive_for_mainnet","derive_for_testnet","make_hash","py","px","hash$64","hash_for_mainnet","hash_for_testnet","hash_checked","make_derive$0","derive$0","derive_for_mainnet$0","derive_for_testnet$0","make_hash$0","hash$65","hash_for_mainnet$0","hash_for_testnet$0","hash_checked$0","gen_legacy","gen_chunked","pubkey","const_typ","group$137","bin_shape_t$125","path$27","t_of_sexp$106","public_key_field","private_key_field","private_key_value","public_key_value","sexp_of_t$115","v_private_key","v_public_key","compare$131","pk2","pk1","of_private_key_exn","gen$3","t_of_sexp$107","sexp_of_t$116","compare$132","group$138","bin_shape_t$126","path$28","t_of_sexp$108","sexp_of_t$117","gen$4","to_field$3","typ$29","one_half","is_pos","constant$11","pos$67","if$9","to_yojson$30","poly_hash","poly_account","group$139","bin_size_t$65","size_of_hash","size_of_account","bin_write_t$67","write_hash","write_account","bin_read_t$118","of_account","arg_1$1","arg_2","arg_3","t_of_sexp$109","sexp_of_t$118","to_yojson$31","of_yojson$22","equal$76","cmp_hash","cmp_account","cmp_hash$0","cmp_account$0","a_021$0","b_022$0","cmp_account$2","cmp_account$1","cmp_hash$2","cmp_hash$1","t_of_sexp$110","sexp_of_t$119","hash$66","group$140","bin_shape_t$127","indexes_field","depth_field","tree_field","tree_value","depth_value","indexes_value","v_tree","v_depth","v_indexes","merkle_root","add_path","account_id","build_tree","h_r","h_l","path$1","find_index_exn","aid","custom_printf_043","custom_printf_044","acct","go_right","expected_kind","custom_printf_045","path_exn","v_favorite_number","name_field","favorite_number_field","favorite_number_value","name_value","data_hash","favorite_number","prune_hash_branches","let_syntax_055","hex_char_to_bits4","bits4_to_hex_char","bits_by_n","bitsn","bits_by_8s","of_unpackable","padding_bit","bytes$0","of_field$3","pack$2","bytes_rev","of_public_key_compressed","to_public_key_compressed","pk_compressed_roundtrip_test","hex_key","field0","transaction_dummy","field_key_attr","make_lident_cmp","dhall_type_of_core_type","Ast_builder","dhall_type_fun","mod_path","dhall_type_fun$0","nm$0","mod_path$0","dhall_variant_from_constructor","ctor_decl","tys_expr","dhall_field_from_label_declara","generate_dhall_type","dhall_type","ctor_decls","label_decls","ty_name","generate_dhall_types","type_decls","attributes$1","str_type_decl$1","group$141","bin_shape_t$128","group$142","bin_shape_typ$2","group$143","bin_shape_t$129","path$29","of_yojson$23","to_yojson$32","t_of_sexp$111","sexp_of_t$120","hash_fold_t$70","func$17","compare$133","equal$77","version$15","bin_size_t$66","bin_write_t$68","bin_read_t$119","bin_read_t$120","path$30","group$144","bin_shape_t_tagged$2","create$93","bin_read_typ$0","bin_read_typ$1","bin_size_typ$0","bin_write_typ$0","to_yojson$33","of_yojson$24","t_of_sexp$112","sexp_of_t$121","hash_fold_t$71","hash$67","hashable$3","add$31","sub$9","div$2","rem$8","max_value$3","logand$1","logor$1","logxor$1","shift_left$7","shift_right$7","of_int$11","to_int$9","of_ms$0","to_ms$0","of_string$45","to_string$48","zero$13","one$13","lognot$6","succ$9","pred$9","compare$134","equal$78","max$26","min$25","pp$28","symbol$231","symbol$232","symbol$233","symbol$234","symbol$235","to_uint64","of_uint64","group$145","bin_shape_t$130","group$146","bin_shape_typ$3","group$147","bin_shape_t$131","path$31","of_yojson$25","to_yojson$34","t_of_sexp$113","sexp_of_t$122","hash_fold_t$72","func$18","compare$135","equal$79","bin_size_t$67","bin_write_t$69","bin_read_t$121","bin_read_t$122","path$32","group$148","bin_shape_t_tagged$3","create$94","to_yojson$35","of_yojson$26","t_of_sexp$114","sexp_of_t$123","length_in_bits$0","hash_fold_t$73","hash$68","hashable$4","add$32","sub$10","div$3","rem$9","max_int$3","logand$2","logor$2","logxor$2","shift_left$8","shift_right$8","of_int$12","to_int$10","of_int64$3","to_int64$4","of_string$46","to_string$49","zero$14","one$14","lognot$7","succ$10","pred$10","compare$136","equal$80","max$27","min$26","pp$29","symbol$236","symbol$237","symbol$238","symbol$239","symbol$240","to_bigint$0","to_uint32","of_uint32","range_check","actual_packed","range_check$0","range_check_flag","field_typ","div_mod","is_succ","xy","yx","x_gte_y","y_gte_x","a_lte_b","succ_if","subtract_unpacking_or_zero","neg_res","underflow","sub_or_zero","group$1","read_version$0","max_value","u32_1","u32_2","zero$15","symbol$241","diff_or_zero","u32_slot","u32_span","u32_sum","diff$0","to_uint32$0","of_uint32$0","zero$16","equal$81","zero$17","succ$11","group$149","bin_shape_t$132","sgn","t_fields_annots","t_toplevel_annots","t_of_sexp$115","of_magnitude","of_sgn","magnitude_field","sgn_field","sgn_value","magnitude_value","sexp_of_t$124","v_sgn","v_magnitude","sgn$0","precision_exp","to_mina_string","whole","num$1","num_stripped_zeros","num$0","num_stripped_zeros$0","of_mina_string_exn","decimal","decimal_length","pack_var","var_to_bits$0","var_to_bits$1","var_to_input","var_to_input_legacy","modulus_as_field","double_modulus_as_field","range_check_flagged","adjustment_factor","out_of_range","t_adjusted","unit_to_nano","to_mina_int","sub_flagged","add_flagged","add_signed_flagged","u64","of_nanomina_int","of_mina_int","of_nanomina_int_exn","of_mina_int_exn","typ_to_hlist","typ_of_hlist","compare_magnitude","sgn_to_bool","to_input_legacy$0","add_flagged$0","of_unsigned","to_fee","of_fee","repr_typ","create_var","mag","to_input_legacy$1","of_unsigned$0","let_syntax_025","let_syntax_026","add_flagged$1","let_syntax_027","let_syntax_028","yv","xv","res_magnitude","res_value","let_syntax_029","let_syntax_030","let_syntax_031","let_syntax_032","let_syntax_034","let_syntax_035","let_syntax_036","let_syntax_037","let_syntax_038","to_fee$0","of_fee$0","sub_flagged$0","y_lt_x","add_flagged$2","add_signed","add_signed_flagged$0","expect_failure","expect_success","qc_test_fast","custom_printf_039","custom_printf_040","custom_printf_041","custom_printf_042","custom_printf_046","after_format","custom_printf_050","custom_printf_047","custom_printf_048","custom_printf_049","formatted","has_decimal","trailing_zero","trailing_zero$0","custom_printf_051","custom_printf_052","currency_length","bin_writer_typ","bin_reader_typ","bin_typ","bin_size_t_tagged","bin_write_t_tagged","bin_writer_t_tagged","bin_read_t_tagged","bin_read_t_tagged$0","v_version","v_t","bin_reader_t_tagged","bin_t_tagged","minimum_user_command_fee","default_transaction_fee","default_snark_worker_fee","fee","add_fee","sexp_of_magnitude","magnitude_of_sexp","to_uint64$0","of_uint64$0","to_nanomina_int","pack_var$0","equal_var$0","var_to_input_legacy$0","var_to_input$0","var_of_t$0","to_nanomina_int$0","to_mina_int$0","of_nanomina_int$0","of_mina_int$0","of_nanomina_int_exn$0","of_mina_int_exn$0","of_uint64$1","to_uint64$1","to_mina_string$0","of_mina_string_exn$0","of_bits$0","gen_incl$0","validate_bound$0","validate_ubound$0","validate_lbound$0","clamp$0","clamp_exn$0","between$0","length_in_bits$1","dhall_type$0","compare_magnitude$0","magnitude_of_sexp$0","sexp_of_magnitude$0","to_amount","add_amount","add_amount_flagged","sub_amount","sub_amount_flagged","add_signed_amount_flagged","to_amount$0","uint64_to_z","uint64_of_z","max_uint64_z","fits_uint64","check_q","den","of_q","of_q_exn","make_exn","to_uint64$2","to_uint64_exn","fr","sub_flagged$1","scale_exn","sexp_of_fee","sexp_of_weight","sub_flagged_checked","u_checked","m_checked","union$6","diff$4","single$0","empty$34","csingle","cseq","cadd","cupper","clower","calpha","cdigit","calnum","eRR","menhir_discard","menhir_env","lexer","menhir_errorcase","menhir_stack","menhir_s","menhir_stack$0","menhir_s$0","menhir_s$1","menhir_stack$1","menhir_s$2","menhir_stack$2","menhir_s$3","menhir_stack$3","menhir_s$4","menhir_stack$4","menhir_s$5","menhir_stack$5","menhir_s$6","menhir_stack$6","menhir_s$7","menhir_stack$7","menhir_s$8","menhir_stack$8","menhir_s$9","menhir_stack$9","menhir_s$10","menhir_stack$10","menhir_s$11","menhir_stack$11","menhir_s$12","menhir_stack$12","menhir_s$13","menhir_stack$13","menhir_s$14","menhir_stack$14","menhir_s$15","menhir_stack$15","menhir_s$16","menhir_stack$16","menhir_s$17","menhir_stack$17","menhir_s$18","menhir_stack$18","menhir_s$19","menhir_stack$19","menhir_s$20","menhir_stack$20","menhir_s$21","menhir_stack$21","menhir_s$22","menhir_stack$22","menhir_s$23","menhir_stack$23","menhir_s$24","menhir_stack$24","menhir_s$25","menhir_stack$25","menhir_s$26","menhir_stack$26","menhir_s$27","menhir_stack$27","menhir_s$28","menhir_stack$28","menhir_s$29","menhir_stack$29","menhir_s$30","menhir_stack$30","menhir_s$31","menhir_stack$31","menhir_s$32","menhir_stack$32","menhir_s$33","menhir_stack$33","menhir_s$34","menhir_stack$34","menhir_s$35","menhir_stack$35","menhir_s$36","menhir_stack$36","menhir_s$37","menhir_stack$37","menhir_s$38","menhir_stack$38","menhir_s$39","menhir_stack$39","menhir_s$40","menhir_stack$40","menhir_s$41","menhir_stack$41","menhir_s$42","menhir_stack$42","menhir_s$43","menhir_stack$43","menhir_fail","menhir_goto_field","menhir_goto_selection","menhir_goto_operation","menhir_goto_definition","tok$0","menhir_run1$0","menhir_run2$0","menhir_run3$0","menhir_run4$0","menhir_run78$0","menhir_goto_loption_selection_","_6","_3","_5","_4","_3$0","_1$0","menhir_reduce40","menhir_env$0","menhir_env$1","menhir_run5","_2$0","_4$0","_2$1","_3$1","_2$2","menhir_run6","menhir_run7","menhir_run8","menhir_run10","menhir_run11","menhir_run12","menhir_run9","menhir_run14","menhir_reduce30","menhir_goto_value_parser_const","menhir_reduce24","menhir_goto_option_default_val","menhir_reduce36","menhir_run87","menhir_run93","menhir_goto_typ","menhir_reduce34","menhir_goto_value_parser_value","menhir_reduce26","menhir_goto_loption_arguments","menhir_run20","menhir_reduce32","tok$1","menhir_reduce28","menhir_run98","menhir_run99","menhir_run100","menhir_run97","menhir_run27","menhir_run103","menhir_run104","menhir_run105","menhir_goto_value","menhir_goto_list_directive","tok$2","tok$3","menhir_goto_loption_variable_d","menhir_env$2","menhir_run26","menhir_run28","menhir_run29","menhir_run34","menhir_run25","menhir_run32","menhir_run33","menhir_run36","menhir_goto_enum_value","menhir_reduce38","menhir_run22","menhir_goto_option_name","menhir_goto_name","menhir_env$3","tok$4","v$23","tok$11","tok$12","v$24","menhir_goto_option_type_condit","tok$7","menhir_env$5","tok$8","v$15","v$16","v$17","tok$9","menhir_env$6","tok$10","v$18","v$19","v$20","v$21","v$22","tok$5","menhir_env$4","tok$6","menhir_run13","menhir_goto_keyword_name","menhir_goto_fragment_name","menhir_goto_optype","menhir_run1","menhir_run2","menhir_run3","menhir_run4","menhir_run78","token$0","lcp","string_of_pos","parse$5","find$18","map$72","map_s","map_p","enum_value","deprecated","coerce","enum$0","string_of_const_value","string_of_arg_typ","eval_arg_error","arg_name","field_type","found_str","guid","non_null","value_to_const_value","variable_map","props","props$0","eval_arg","coerced","eval_arglist","arglist","key_values","arglist$0","arglist$1","const_value","arglist$2","arglist$3","schema","mutations","subscriptions","mutation_name","subscription_name","query_name","obj$0","io_field","abstract_field","subscription_field","enum$1","non_null$0","union$0","interface$0","add_type","abstract_typ","obj_of_subscription_obj","string$0","guid$0","skip_directive","include_directive","unless_visited","arg_list_types","memo$0","memo$1","arg_types","argtyp","argtyp$0","argtyp$1","argtyp$2","visited$0","reducer","opt$2","types_of_schema","args_to_list","no_abstracts","enum_value$0","input_value","interfaces","arg_list","directive","schema$0","subs","mut","add_built_in_fields","schema_field","matches_type_condition","type_condition","abstract$0","should_include_field","directives","arguments$0","eval_directive","arguments$1","alias_or_name","merge_selections","matching","selection_sets","selection_set","collect_fields","include_field","spread","fragment","condition","matches_type_condition$0","field_from_object","field_from_subscription_object","coerce_or_null","src$0","map_fields_with_order","error_to_json","extension_props","error_response","resolve_fields","execution_order","query_field","resolve_field","resolve_info","resolver","unlifted_value","resolved","present","lifted_value","src$1","data_to_json","errors$0","field_error","to_response","msg$1","subscribe","subs_field","source_stream","execute_operation","query","data_errs","collect_fragments","validate_fragment_selection","fragment_map","selection","fragment_spread","validate_fragment","inline_fragment","validate_fragments","fragment_names","cycle","collect_and_validate_fragments","fragments","collect_operations","select_operation","operation_name","operations","execute","variables","default_variables","default_value","variables$0","execution_ctx","find$19","find_string","t_toplevel_annots$0","sexp_of_t$125","v_doc","of_annots","t_fields_annots$0","sexpifier$2","v_deprecated","v_skip","compare$137","of_annots$0","annots","under_to_camel","prefix_us","ws$0","name_under_to_camel","add_field","skip_data","f_input","annotations","ref_as_pipe","inner_acc","graphql_arg_coerce","graphql_arg_fields","creator_input","finish","creator","add_field$0","t_field","finish$0","graphql_fields_accumulator","graphql_fields","nullable_graphql_fields","contramap","arg_to_yojson_rec","arg_to_yojson","acc_obj","graphql_query_accumulator","scalar$1","int$6","string$4","wrapped","option$1","list$6","inner_query","bind$25","map$73","initial_buffer","upstream_flushed","downstream_flushed$0","output_closed","blocked_read","ivar$1","iter$34","message_of_field_error","extensions_of_field_error","parse_query","introspection_query","graphql_arg","nullable_graphql_arg","graphql_arg_accumulator","graphql_creator","graphql_query","raw_server","init_acc","merge_acc","force_breaks1","force_breaks2","force_breaks1$0","force_breaks","children","new_children","param$3","acc0","acc1","new_x1","acc2","new_x2","query_schema","query_for_all","hit_server","hit_server_query","hit_server_args","bar","skipped","foo_hello","bar$0","skipped$0","foo_hello$0","make_creator","foo_hello_fun","skipped_fun","bar_fun","compile_acc","compile_acc$0","foo_hello_gen","compile_acc$1","skipped_gen","compile_acc$2","bar_gen","manual_typ","manual_typ$0","foo","foo$0","make_creator$0","foo_fun","foo_gen","manual_typ$1","derived","manual_typ$2","typ_input","generated_typ","generated_arg_typ","generated_query","to_json_accumulator","int$7","string$5","list$7","add_field$1","finished_obj","finish$1","of_json","int$8","string$6","list$8","of_json_creator","full_derivers","group$150","bin_shape_t$133","t_fields_annots$1","t_toplevel_annots$1","t_of_sexp$116","of_h","data_field","hash_field","hash_value","data_value","sexp_of_t$126","v_hash","hash$69","data$3","hash$70","data$4","sexp_of_t$127","compare$138","cmp_h","hash$71","map$74","to_key$0","to_entry","to_doc_entry","docs","leaf_type","js_layout","js_layout_accumulator","js_type","invalid_scalar_to_string","raise_invalid_scalar","except","iso_string","uint64","uint32","js_only","js_leaf","leaf","js_record","entries","global_slot_since_genesis","global_slot_since_hard_fork","global_slot_span","a_opt","static_length$0","static_length","iso","iso_record","of_record","to_record","record_deriver","add_field$2","new_field","finish$2","accumulator","needs_custom_js","balance_change","sign_to_string","sign_of_string","sgn_fun","magnitude_fun","magnitude_gen","sgn_gen","inner_query$0","json_to_safe","print_schema","full","query_top_level","json_to_string_gql","arg_query","out_query","in_schema","out_schema","run_query","unwrap","verification_key_with_hash","verification_key","hash_fun","data_fun","hash_gen","baz","foo1","baz$0","foo1$0","baz_fun","foo1_fun","foo1_gen","baz_gen","v_nothing","v_field","nothing","nothing$0","nothing_fun","field_fun","compile_acc$3","field_gen","compile_acc$4","nothing_gen","public_key$0","obj$1","compile_acc$5","public_key_gen","group$151","bin_shape_t$134","bin_writer_t$48","bin_reader_t$48","bin_t$48","version$16","func$19","path$33","group$152","bin_shape_typ$4","group$153","bin_shape_t$135","create$95","bin_read_t$123","bin_read_t$124","bin_reader_t$49","bin_size_t$68","bin_write_t$70","bin_writer_t$49","bin_t$49","to_decimal_string","to_bytes","curr","curr$0","var_to_hash_packed","var_of_hash_packed","var_to_field","group$154","state_hash","bin_writer_t$50","bin_reader_t$50","bin_t$50","hash$72","path$34","of_string$47","group$155","bin_shape_t$136","pending_coinbase_depth","init$28","genesis_timestamp_of_string","of_time","compare$139","poly_length","poly_delta","poly_genesis_state_timestamp","group$156","bin_shape_t$137","genesis_state_timestamp","to_hlist$25","slots_per_sub_window","slots_per_epoch","of_hlist$25","compare$140","group$157","bin_shape_t$138","path$35","compare$141","compiled$0","max_epoch_length","hash_typ","time_offset","setting_enabled","disable_setting_offset","enable_setting_offset","set_time_offset","tm","env_offset","get_time_offset","var_of_field","pack_value$0","unpack_value$0","unpack_var$0","compare_var$0","increment_var$0","increment_if_var$0","assert_equal_var$0","var_of_field$0","var_of_field_unsafe$0","of_time_span","to_time_span","to_time_ns_span","of_time_ns_span","int64_ns","to_time_exn","t_int64","now$1","field_var_to_unpacked","diff_checked","unpacked_to_number","to_string_exn","of_time_ns","to_system_time","to_string_system_time_exn","of_string_exn","time_beginning","time_end","time_beginning_int64","time_end_int64","int64_time_span","pack_value$1","unpack_value$1","pack_var$1","unpack_var$1","compare_var$1","increment_var$1","increment_if_var$1","assert_equal_var$1","equal_var$1","var_of_field$1","var_of_field_unsafe$1","of_time$0","to_time_exn$0","now$2","field_var_to_unpacked$0","epoch$0","of_span_since_epoch","diff_checked$0","modulus$0","unpacked_to_number$0","to_string_exn$0","of_time_ns$0","to_system_time$0","to_string_system_time_exn$0","of_string_exn$0","ctrl","cancel_ivar","span$0","timeout","cancel","peek","remaining_time","current_time","time_elapsed","await$0","timeout_duration","time_controller","await_exn","group$158","bin_read_t$125","bin_read_t$126","t_of_sexp$117","to_list$15","to_numbered_list","def2","def1","map$75","fold$19","gen$5","inner_gen","of_array$4","map_gens","gen_division_generic","dirichlet","n_float","uniform","gen_division","symbol$242","zero$19","symbol$243","symbol$244","gen_division_currency","root_gen","node_gen","this$0","next_elem","field_of_bool","of_bigstring_exn","to_bigstring$0","to_field_unsafe","gen_non_default","to_field_unsafe$0","t_014","t_013","t_018","t_017","t_019","of_public_key$0","token_id","owner","token_id$0","derive_token_id$1","tid2","tid1","pk_equal","tid_equal","tid_else","pk_else","tid_then","pk_then","create$96","equal$82","group$159","t_of_sexp$118","of_slot","of_slot_span","of_balance","of_amount","initial_minimum_balance_field","cliff_time_field","cliff_amount_field","vesting_period_field","vesting_increment_field","vesting_increment_value","vesting_period_value","cliff_amount_value","cliff_time_value","initial_minimum_balance_value","group$160","timing","t_of_sexp$119","path$36","vesting_increment","vesting_period","cliff_amount","cliff_time","initial_minimum_balance","is_timed","vesting_increment$0","vesting_period$0","cliff_amount$0","cliff_time$0","initial_minimum_balance$0","is_timed$0","t_fields_annots$2","t_toplevel_annots$2","deriver$1","vesting_increment_fun","vesting_period_fun","cliff_amount_fun","cliff_time_fun","initial_minimum_balance_fun","is_timed_fun","is_timed_gen","initial_minimum_balance_gen","cliff_time_gen","cliff_amount_gen","vesting_period_gen","vesting_increment_gen","slot_span_one","balance_unused","amount_unused","to_input$5","typ$30","deriver$2","group$161","group$162","field$5","version$17","group$163","bin_shape_t_tagged$4","create$97","bin_read_t$127","bin_size_t$69","bin_write_t$71","group$164","bin_shape_t$139","bin_size_t$70","bin_write_t$72","bin_read_t$128","t_of_sexp$120","sexp_of_t$128","compare$142","hash_fold_t$74","group$165","bin_shape_t$140","bin_read_t$129","bin_read_t$130","bin_reader_t$51","bin_size_t$71","bin_write_t$73","bin_writer_t$51","bin_t$51","path$37","group$166","bin_shape_typ$5","group$167","bin_shape_t_tagged$5","create$98","bin_read_t$131","bin_size_t$72","bin_write_t$74","authorization","group$168","bin_shape_t$141","path$38","sexp_of_t$129","gen$6","dummy_signature","let_syntax_297","dummy_of_tag","signature_deriver","t_fields_annots$3","t_toplevel_annots$3","signature$3","signature$4","deriver$3","signature_fun","proof_fun","proof_gen","signature_gen","signature","to_record$0","of_record$0","deriver$4","typ$31","to_input$6","t_fields_annots$4","t_toplevel_annots$4","hash$73","data$5","hash$74","data$6","deriver$5","to_yojson$36","symbol$245","group$169","id$8","bin_size_t$73","bin_write_t$75","bin_read_t$132","t_of_sexp$121","sexp_of_t$130","equal$83","compare$143","hash_fold_t$75","path$39","to_yojson$37","symbol$246","group$170","bin_size_t$74","bin_write_t$76","bin_read_t$133","t_of_sexp$122","sexp_of_t$131","compare$144","hash_fold_t$76","path$40","group$171","bin_shape_typ$6","bin_size_typ$1","bin_write_typ$1","bin_read_typ$2","group$172","create$99","to_yojson$38","symbol$247","default_caller","equal$84","deriver$6","group$173","to_hlist$26","fee_excess_r","fee_token_r","fee_excess_l","fee_token_l","of_hlist$26","typ$32","token_typ","fee_typ","group$174","bin_shape_t$142","path$41","rebalance","fee_token_l$0","fee_token_r$0","fee_excess_l$0","zero$20","of_one_or_two","excesses","unreduced","gen_single","group$175","group$176","group$177","token_id$1","group$178","create$100","group$179","bin_shape_t$143","path$42","group$180","bin_shape_t$144","path$43","group$181","bin_shape_typ$7","group$182","bin_shape_t_tagged$6","create$101","dummy$4","to_yojson$39","of_yojson$27","t_of_sexp$123","sexp_of_t$132","equal$85","compare$145","group$183","ledger","bin_writer_t$52","bin_reader_t$52","bin_t$52","hash$75","path$44","group$184","bin_shape_t$145","write_controller","of_controller","of_controller$0","of_controller$1","hash_fold_controller","path$45","sexp_of_t$133","gen_for_proof_authorization","gen_for_signature_authorizatio","gen_for_none_given_authorizati","to_string$50","of_string$48","to_hlist$27","signature_sufficient","signature_necessary","of_hlist$27","to_input$7","encode$0","decode$1","to_input$8","t$9","typ$33","to_input$9","check$10","group$185","bin_shape_t$146","controller","to_hlist$28","set_timing","set_voting_for","increment_nonce","set_token_symbol","edit_action_state","set_zkapp_uri","set_verification_key","set_permissions","set_delegate","send","access","edit_state","of_hlist$28","set_timing$0","set_voting_for$0","increment_nonce$0","set_token_symbol$0","edit_action_state$0","set_zkapp_uri$0","set_verification_key$0","set_permissions$0","set_delegate$0","receive$0","send$0","access$0","edit_state$0","t_fields_annots$5","t_toplevel_annots$5","set_timing$1","set_voting_for$1","increment_nonce$1","set_token_symbol$1","edit_action_state$1","set_zkapp_uri$1","set_verification_key$1","set_permissions$1","set_delegate$1","receive$1","send$1","access$1","edit_state$1","set_timing$2","set_voting_for$2","increment_nonce$2","set_token_symbol$2","edit_action_state$2","set_zkapp_uri$2","set_verification_key$2","set_permissions$2","set_delegate$2","receive$2","send$2","access$2","edit_state$2","to_input$10","group$186","permissions","size_of_permissions","write_permissions","of_permissions","v_edit_state","v_access","v_send","v_receive","v_set_delegate","v_set_permissions","v_set_verification_key","v_set_zkapp_uri","v_edit_action_state","v_set_token_symbol","v_increment_nonce","v_set_voting_for","v_set_timing","t_of_sexp$124","edit_state_field","access_field","send_field","receive_field","set_delegate_field","set_permissions_field","set_verification_key_field","set_zkapp_uri_field","edit_action_state_field","set_token_symbol_field","increment_nonce_field","set_voting_for_field","set_timing_field","set_timing_value","set_voting_for_value","increment_nonce_value","set_token_symbol_value","edit_action_state_value","set_zkapp_uri_value","set_verification_key_value","set_permissions_value","set_delegate_value","receive_value","send_value","access_value","edit_state_value","of_permissions$0","compare$146","hash_fold_t$77","path$46","to_input$11","typ$34","to_input$12","auth_required","deriver$7","set_timing_fun","set_voting_for_fun","increment_nonce_fun","set_token_symbol_fun","edit_action_state_fun","set_zkapp_uri_fun","set_verification_key_fun","set_permissions_fun","set_delegate_fun","receive_fun","send_fun","access_fun","edit_state_fun","edit_state_gen","access_gen","send_gen","receive_gen","set_delegate_gen","set_permissions_gen","set_verification_key_gen","compile_acc$6","set_zkapp_uri_gen","compile_acc$7","edit_action_state_gen","compile_acc$8","set_token_symbol_gen","compile_acc$9","increment_nonce_gen","compile_acc$10","set_voting_for_gen","compile_acc$11","set_timing_gen","digest_length_byte","memo_length","max_digestible_string_length","digest_tag","bytes_tag","is_digest","create_by_digesting_string_exn","ndx","create_by_digesting_string","create_from_value_exn","create_from_bytes_exn","create_from_bytes","create_from_string_exn","create_from_string","to_raw_exn","to_raw_bytes_exn","of_raw_exn","base58_check","memo_var","aux$0","arr$0","group$187","bin_shape_t$147","path$47","group$188","bin_shape_typ$8","group$189","bin_shape_t$148","path$48","group$190","bin_shape_typ$9","group$191","bin_shape_t_tagged$7","create$102","generator_013","to_yojson$40","group$192","bin_shape_t$149","t_of_sexp$125","sexp_of_t$134","path$49","sexp_of_t$135","compare$147","predicate","source_not_present","receiver_not_present","amount_insufficient_to_create_","cannot_pay_creation_fee_in_tok","source_insufficient_balance","source_minimum_balance_violati","receiver_already_exists","token_owner_not_caller","overflow$0","global_excess_overflow","local_excess_overflow","local_supply_increase_overflow","global_supply_increase_overflo","signed_command_on_zkapp_accoun","zkapp_account_not_present","update_not_permitted_balance","update_not_permitted_access","update_not_permitted_timing","update_not_permitted_delegate","update_not_permitted_app_state","update_not_permitted_verificat","update_not_permitted_action_st","update_not_permitted_zkapp_uri","update_not_permitted_token_sym","update_not_permitted_permissio","update_not_permitted_nonce","update_not_permitted_voting_fo","zkapp_command_replay_check_fai","fee_payer_nonce_must_increase","fee_payer_must_be_signed","account_balance_precondition_u","account_nonce_precondition_uns","account_receipt_chain_hash_pre","account_delegate_precondition_","account_action_state_precondit","account_app_state_precondition","predicate$0","source_not_present$0","receiver_not_present$0","amount_insufficient_to_create_$0","cannot_pay_creation_fee_in_tok$0","source_insufficient_balance$0","source_minimum_balance_violati$0","receiver_already_exists$0","token_owner_not_caller$0","overflow$1","global_excess_overflow$0","local_excess_overflow$0","local_supply_increase_overflow$0","global_supply_increase_overflo$0","signed_command_on_zkapp_accoun$0","zkapp_account_not_present$0","update_not_permitted_balance$0","update_not_permitted_access$0","update_not_permitted_timing$0","update_not_permitted_delegate$0","update_not_permitted_app_state$0","update_not_permitted_verificat$0","update_not_permitted_action_st$0","update_not_permitted_zkapp_uri$0","update_not_permitted_token_sym$0","update_not_permitted_permissio$0","update_not_permitted_nonce$0","update_not_permitted_voting_fo$0","zkapp_command_replay_check_fai$0","fee_payer_nonce_must_increase$0","fee_payer_must_be_signed$0","account_balance_precondition_u$0","account_nonce_precondition_uns$0","account_receipt_chain_hash_pre$0","account_delegate_precondition_$0","account_action_state_precondit$0","account_app_state_precondition$0","account_proved_state_precondit","account_is_new_precondition_un","protocol_state_precondition_un","unexpected_verification_key_ha","valid_while_precondition_unsat","incorrect_nonce","invalid_fee_excess","cancelled","fold$20","predicate_fun","source_not_present_fun","receiver_not_present_fun","source_insufficient_balance_fu","receiver_already_exists_fun","token_owner_not_caller_fun","overflow_fun","global_excess_overflow_fun","local_excess_overflow_fun","zkapp_account_not_present_fun","update_not_permitted_balance_f","update_not_permitted_access_fu","update_not_permitted_timing_fu","update_not_permitted_delegate_","update_not_permitted_nonce_fun","fee_payer_nonce_must_increase_","fee_payer_must_be_signed_fun","account_proved_state_precondit$0","account_is_new_precondition_un$0","protocol_state_precondition_un$0","unexpected_verification_key_ha$0","valid_while_precondition_unsat$0","incorrect_nonce_fun","invalid_fee_excess_fun","cancelled_fun","group$193","bin_shape_t$150","path$50","to_yojson$41","group$194","bin_shape_t$151","path$51","to_display","display","empty$36","of_single_failure","is_empty$14","add$33","failure","describe","group$195","bin_shape_t$152","path$52","min$27","max$28","of_enum","equal$86","gen$7","equal$87","of_t","test_mask","payment","stake_delegation","fee_transfer","coinbase$0","typ$35","to_hlist$29","is_user_command","is_coinbase","is_fee_transfer","is_stake_delegation","is_payment","of_hlist$29","typ$36","equal$88","payment$0","stake_delegation$0","fee_transfer$0","coinbase$1","to_bits_t","to_bits_var","bool_var","bit3","bit2","bit1","acc3","add_if_true","base_typ","typ$37","unpacked_t_of_t","t_of_unpacked_t","unpacked","bits_t_of_t","t_of_bits_t","unpacked_typ","test_predicate","one_of","one$15","default$8","group$196","group$197","group$198","global_slot","nonce","token_id$2","public_key$1","group$199","create$103","to_hlist$30","valid_until","fee_payer_pk","of_hlist$30","symbol$248","group$200","bin_shape_t$153","bin_size_t$75","bin_write_t$77","bin_writer_t$53","bin_read_t$134","bin_read_t$135","v_fee","v_fee_payer_pk","v_nonce","v_valid_until","v_memo","bin_reader_t$53","bin_t$53","t_of_sexp$126","fee_field","fee_payer_pk_field","nonce_field","valid_until_field","memo_field","memo_value","valid_until_value","nonce_value","fee_payer_pk_value","fee_value","sexp_of_t$136","hash_fold_t$78","path$53","group$201","bin_shape_t$154","bin_size_t$76","bin_write_t$78","bin_read_t$136","v_fee_token","t_of_sexp$127","fee_token_field","fee_token_value","sexp_of_t$137","hash_fold_t$79","path$54","group$202","bin_shape_typ$10","group$203","common","create$104","let_syntax_073","gen$8","group$204","bin_shape_t$155","bin_size_t$77","bin_write_t$79","bin_read_t$137","v_receiver_pk","v_amount","v_new_delegate","t_of_sexp$128","new_delegate_field","new_delegate_value","receiver_pk_field","amount_field","amount_value","receiver_pk_value","sexp_of_t$138","hash_fold_t$80","path$55","group$205","bin_shape_t$156","bin_size_t$78","bin_write_t$80","bin_read_t$138","v_source_pk","v_token_id","v_delegator","t_of_sexp$129","delegator_field","delegator_value","source_pk_field","token_id_field","token_id_value","source_pk_value","sexp_of_t$139","hash_fold_t$81","path$56","group$206","bin_shape_typ$11","group$207","bin_shape_t_tagged$8","create$105","to_yojson$42","poly_common","poly_body","symbol$249","group$208","bin_shape_t$157","bin_size_t$79","size_of_common","size_of_body","bin_write_t$81","write_common","write_body","bin_read_t$139","of_common","of_body","v_common","v_body","t_of_sexp$130","common_field","body_field","body_value","common_value","sexp_of_t$140","hash_fold_t$82","hash_fold_common","hash_fold_body","compare$148","cmp_common","cmp_body","group$209","common$0","group$210","create$106","to_hlist$31","of_hlist$31","group$211","bin_shape_t$158","bin_size_t$80","bin_write_t$82","bin_read_t$140","t_of_sexp$131","sexp_of_t$141","hash_fold_t$83","path$57","group$212","bin_shape_t$159","bin_size_t$81","bin_write_t$83","bin_read_t$141","t_of_sexp$132","sexp_of_t$142","hash_fold_t$84","path$58","group$213","bin_shape_typ$12","group$214","bin_shape_t_tagged$9","create$107","bin_read_t$142","read_version$6","read_version$5","read_version$3","read_version$2","read_version$4","read_version$1","bin_size_t$82","bin_write_t$84","create$108","fee$0","fee_payer","nonce$0","receiver","new_delegate","max_amount","receiver_pk","generator_012","t_to_hlist","source_pk","t_of_hlist","typ$38","to_hlist$32","fee_token","of_hlist$32","typ$39","of_user_command_payload","max_amount_without_overflow","poly_payload","poly_pk","poly_signature","size_of_payload","size_of_signature","write_payload","write_signature","bin_writer_payload","bin_writer_pk","bin_writer_signature","of_payload","of_signature","v_payload","v_signer","v_signature","bin_reader_payload","bin_reader_pk","bin_reader_signature","bin_payload","bin_pk","bin_signature","cmp_payload","cmp_pk","cmp_signature","payload_field","signer_field","signature_field","signature_value","signer_value","payload_value","hash_fold_payload","hash_fold_pk","hash_fold_signature","account_access_statuses","acct_id","accounts_referenced","bin_writer_typ$0","bin_reader_typ$0","bin_typ$0","bin_size_t_tagged$0","bin_write_t_tagged$0","bin_writer_t_tagged$0","bin_read_t_tagged$1","bin_read_t_tagged$2","bin_reader_t_tagged$0","bin_t_tagged$0","poly_public_key","bin_read_typ$3","bin_read_typ$4","cmp_public_key","signer","payment_payload","stake_delegation_payload","payload$1","bin_size_typ$2","bin_write_typ$2","bin_writer_typ$1","bin_read_typ$5","bin_read_typ$6","bin_reader_typ$1","bin_typ$1","bin_size_t_tagged$1","bin_write_t_tagged$1","bin_writer_t_tagged$1","bin_read_t_tagged$3","bin_read_t_tagged$4","bin_reader_t_tagged$1","bin_t_tagged$1","bin_writer_typ$2","bin_reader_typ$2","bin_typ$2","bin_size_t_tagged$2","bin_write_t_tagged$2","bin_writer_t_tagged$2","bin_read_t_tagged$5","bin_read_t_tagged$6","bin_reader_t_tagged$2","bin_t_tagged$2","bin_reader_t$5","bin_writer_t$5","bin_t$5","top_tag_versions","bin_read_top_tagged_to_latest","has_insufficient_fee","fee_payer$0","fee_excess","receiver$0","valid_until$0","sign_payload","fake_sign","gen_inner","fee_range","create_body","min_fee","max_fee","with_random_participants","gen_inner$0","min_amount","sign_type","gen_with_random_participants","gen_with_random_participants$0","payment_with_random_participan","stake_delegation_with_random_p","account_info","n_commands","currency_splits","command_senders","account_nonces","sender","rest_splits","this_split","sender_pk","sender_pk$0","splits","command_splits","command_splits$0","spend_all","amount_to_spend","swap_idx","group$11","bin_writer_t$6","bin_reader_t$6","bin_t$6","t_of_sexp$3","sexp_of_t$3","hash_fold_t$3","sexp_of_t$4","to_valid_unsafe","bin_size_typ$3","bin_write_typ$3","bin_writer_typ$3","bin_read_typ$7","bin_read_typ$8","bin_reader_typ$3","bin_typ$3","bin_size_t_tagged$3","bin_write_t_tagged$3","bin_writer_t_tagged$3","bin_read_t_tagged$7","bin_read_t_tagged$8","bin_reader_t_tagged$3","bin_t_tagged$3","bin_read_t$11","bin_read_t$12","bin_reader_t$7","bin_size_t$5","bin_write_t$5","bin_writer_t$7","bin_t$7","check_signature","public_keys","check_valid_keys","create_with_signature_checked","gen_test","check_only_for_signature","forget_check","filter_by_participant","user_commands","user_command","group$215","receipt_chain_hash","bin_writer_t$54","bin_reader_t$54","bin_t$54","hash$76","path$59","empty$38","group$216","bin_shape_t$160","bin_writer_t$55","bin_reader_t$55","bin_t$55","hash$77","path$60","group$217","bin_shape_t$161","path$61","group$218","bin_shape_t$162","to_hlist$33","of_hlist$33","to_input$13","of_option$0","to_option$0","map$76","typ$40","option_typ","group$219","bin_shape_t$163","bin_size_t$83","bin_write_t$85","bin_read_t$143","t_of_sexp$133","sexp_of_t$143","compare$149","hash_fold_t$85","t_of_sexp$134","sexp_of_t$144","map$77","to_option$1","of_option$1","is_set","is_keep","deriver$8","gen$9","gen_a","typ$41","optional_typ","to_input$14","to_input$15","group$220","bin_shape_t$164","bin_size_t$84","bin_write_t$86","bin_read_t$144","t_of_sexp$135","sexp_of_t$145","compare$150","hash_fold_t$86","t_of_sexp$136","sexp_of_t$146","equal$89","compare$151","gen$10","to_option$2","of_option$2","deriver_base","deriver$9","to_input$16","typ$42","ignore","group$221","bin_shape_t$165","path$62","to_hlist$34","of_hlist$34","encode$1","decode$2","invalid_public_key","digest_vk","dummy_vk_hash","t_of_sexp$137","sexp_of_t$147","equal$90","hash_fold_t$87","to_binable$12","of_binable$14","path$63","group$222","bin_shape_t$166","bin_size_t$85","bin_write_t$87","bin_read_t$145","equal$91","typ$43","group$223","t_of_sexp$138","path$64","to_input$17","deriver$10","t_of_sexp$139","sexp_of_t$148","hash$78","empty_hash","push_hash","push_event","push_to_data_as_hash","events","pop_from_data_as_hash","events$0","typ$44","to_input$18","deriver$11","hash$79","typ$45","var_to_input$1","to_input$19","deriver$12","empty$39","max_length$1","check$11","t_of_sexp$140","to_binable$13","of_binable$15","path$65","group$224","t_of_sexp$141","of_app_state","of_vk","of_zkapp_version","of_zkapp_uri","verification_key_field","zkapp_version_field","action_state_field","last_action_slot_field","proved_state_field","zkapp_uri_field","zkapp_uri_value","proved_state_value","last_action_slot_value","action_state_value","zkapp_version_value","verification_key_value","to_hlist$35","proved_state","last_action_slot","action_state","zkapp_version","of_hlist$35","zkapp_uri$1","zkapp_uri$2","proved_state$0","last_action_slot$0","action_state$0","zkapp_version$0","verification_key$0","app_state$1","t_fields_annots$6","t_toplevel_annots$6","group$225","bin_shape_t$167","bin_size_t$86","bin_write_t$88","bin_read_t$146","v_verification_key","v_zkapp_version","v_action_state","v_last_action_slot","v_proved_state","v_zkapp_uri","t_of_sexp$142","sexp_of_t$149","path$66","zkapp_uri_non_preimage","hash_zkapp_uri_opt","zkapp_uri_opt","hash$80","typ$46","zkapp_uri_to_input","digest$6","default_digest","action_state_deriver","list_5","gen_uri","app_state$2","seq_state","last_sequence_slot","group$226","bin_shape_t$168","bin_writer_t$56","bin_reader_t$56","bin_t$56","hash$81","path$67","max_length$2","check$12","t_of_sexp$143","to_binable$14","of_binable$16","path$68","num_bits$8","to_field$4","byte_index","to_input$20","of_field$4","chars","typ$47","typ$48","var_to_input$2","group$227","t_of_sexp$144","of_id","of_token_symbol","of_nonce","of_receipt_chain_hash","of_delegate","of_state_hash","of_timing","of_zkapp_opt","token_symbol_field","balance_field","receipt_chain_hash_field","delegate_field","voting_for_field","timing_field","permissions_field","zkapp_field","zkapp_value","permissions_value","timing_value","voting_for_value","delegate_value","receipt_chain_hash_value","balance_value","token_symbol_value","zkapp","permissions$0","timing$0","voting_for","delegate","receipt_chain_hash$0","nonce$1","balance$1","token_symbol","token$1","public_key$2","zkapp$0","permissions$1","timing$1","voting_for$0","delegate$0","receipt_chain_hash$1","nonce$2","balance$2","token_symbol$0","token_id$3","public_key$3","fold$21","public_key_fun","token_id_fun","token_symbol_fun","balance_fun","nonce_fun","receipt_chain_hash_fun","delegate_fun","voting_for_fun","timing_fun","permissions_fun","zkapp_fun","to_hlist$36","of_hlist$36","t_fields_annots$7","t_toplevel_annots$7","group$228","bin_shape_t$169","path$69","delegate$1","group$229","zkapp_opt","bin_shape_t$170","bin_size_t$87","bin_write_t$89","bin_read_t$147","bin_read_t$148","v_token_symbol","v_balance","v_receipt_chain_hash","v_delegate","v_voting_for","v_timing","v_initial_minimum_balance","v_cliff_time","v_cliff_amount","v_vesting_period","v_vesting_increment","v_permissions","v_zkapp","t_of_sexp$145","sexp_of_t$150","equal$92","cmp_amount","path$70","check$13","path$71","to_yojson$43","poly_field","poly_controller","poly_amount","symbol$250","arg10$0","arg9$0","arg8$0","arg7$0","arg6$1","arg5$1","arg4$2","arg6$0","hash_zkapp_account_opt","delegate_opt","digest$7","typ$49","account$0","zkapp$1","typ$50","hash$82","empty$40","create$109","min_balance_at_slot","min_balance_past_cliff","global_slot_u32","cliff_time_u32","vesting_period_u32","num_periods","vesting_decrement","has_permission","control","has_permission_to_send","has_permission_to_receive","gen_with_constrained_balance","vesting_end","gen_any_vesting_range","let_syntax_102","vesting_slots","vesting_periods_count","max_cliff_amt","to_vest","vi","deriver$13","zkapp_uri_fun","proved_state_fun","last_action_slot_fun","action_state_fun","zkapp_version_fun","verification_key_fun","app_state_fun","app_state_gen","verification_key_gen","zkapp_version_gen","action_state_gen","last_action_slot_gen","proved_state_gen","zkapp_uri_gen","token_id_gen","token_symbol_gen","balance_gen","nonce_gen","receipt_chain_hash_gen","compile_acc$12","delegate_gen","compile_acc$13","voting_for_gen","compile_acc$14","timing_gen","compile_acc$15","permissions_gen","compile_acc$16","zkapp_gen","group$230","bin_shape_t$171","ledger_hash","t_fields_annots$8","t_toplevel_annots$8","to_hlist$37","total_currency","of_hlist$37","hash$83","total_currency$0","hash$84","total_currency_fun","total_currency_gen","group$231","bin_shape_t$172","path$72","group$232","bin_shape_t$173","bin_writer_t$57","bin_reader_t$57","bin_t$57","hash$85","path$73","group$233","bin_shape_t$174","epoch_ledger","start_checkpoint","lock_checkpoint","t_fields_annots$9","t_toplevel_annots$9","to_hlist$38","epoch_length","of_hlist$38","ledger$0","epoch_length$0","lock_checkpoint$0","start_checkpoint$0","ledger$1","ledger_fun","seed_fun","start_checkpoint_fun","lock_checkpoint_fun","epoch_length_fun","ledger_gen","seed_gen","start_checkpoint_gen","lock_checkpoint_gen","epoch_length_gen","group$234","bin_shape_t$175","path$74","merge$10","if$10","merge$11","f$17","of_digest$2","group$235","bin_shape_t$176","t_fields_annots$10","t_toplevel_annots$10","to_hlist$39","of_hlist$39","to_input$21","deriver$14","upper_fun","lower_fun","lower_gen","upper_gen","v_upper","v_lower","run$7","length$29","balance$3","global_slot$0","group$236","bin_shape_t$177","bin_size_t$88","bin_write_t$90","bin_read_t$149","t_of_sexp$146","lower_field","upper_field","upper_value","lower_value","sexp_of_t$151","hash_fold_t$88","compare$152","cmp_a$0","equal$93","compare$153","deriver$15","range_max","range_uint32","range_uint64","nonce$3","balance$4","amount$1","length$30","deriver$16","v_foo","gen$11","compare_a","to_input$22","to_input$23","to_input_checked","typ$51","check$14","run$8","init$29","action_state$1","boolean$1","receipt_chain_hash$2","frozen_ledger_hash","state_hash$0","token_id$4","epoch_seed$0","public_key$4","to_input$24","check$15","typ$52","receipt_chain_hash$3","balance$5","nonce$4","group$237","account$1","t_of_sexp$147","is_new_field","is_new_value","path$75","t_fields_annots$11","t_toplevel_annots$11","to_hlist$40","is_new","of_hlist$40","t_of_sexp$148","sexp_of_t$152","v_is_new","equal$94","compare$154","proved_state$1","action_state$2","delegate$2","receipt_chain_hash$4","nonce$5","balance$6","is_new$0","proved_state$2","action_state$3","delegate$3","receipt_chain_hash$5","nonce$6","balance$7","gen$12","accept","deriver$17","is_new_fun","state_fun","state_gen","is_new_gen","to_input$25","to_hlist$41","of_hlist$41","group$238","bin_shape_t$178","size_of_epoch_data","write_epoch_data","of_epoch_data","v_total_currency","v_ledger","v_seed","v_start_checkpoint","v_lock_checkpoint","v_epoch_length","t_of_sexp$149","ledger_field","seed_field","start_checkpoint_field","lock_checkpoint_field","epoch_length_field","total_currency_field","total_currency_value","epoch_length_value","lock_checkpoint_value","start_checkpoint_value","seed_value","ledger_value","of_epoch_data$0","hash_fold_epoch_data","compare$155","a_189","b_190","a_193","b_194","a_197","b_198","path$76","deriver$18","a_203","b_204","min_epoch_length","gen$13","to_input$26","to_input$27","group$239","bin_shape_t$179","snarked_ledger_hash","epoch_data","to_hlist$42","next_epoch_data","staking_epoch_data","min_window_density","blockchain_length","of_hlist$42","t_of_sexp$150","of_snarked_ledger_hash","of_length","of_global_slot","snarked_ledger_hash_field","blockchain_length_field","min_window_density_field","global_slot_since_genesis_fiel","staking_epoch_data_field","next_epoch_data_field","next_epoch_data_value","staking_epoch_data_value","global_slot_since_genesis_valu","min_window_density_value","blockchain_length_value","snarked_ledger_hash_value","t_fields_annots$12","t_toplevel_annots$12","total_currency$1","next_epoch_data$0","staking_epoch_data$0","global_slot_since_genesis$0","total_currency$2","min_window_density$0","blockchain_length$0","snarked_ledger_hash$0","make_creator$1","snarked_ledger_hash_fun","blockchain_length_fun","min_window_density_fun","global_slot_since_genesis_fun","staking_epoch_data_fun","next_epoch_data_fun","snarked_ledger_hash_gen","blockchain_length_gen","min_window_density_gen","global_slot_since_genesis_gen","staking_epoch_data_gen","next_epoch_data_gen","group$240","protocol_state$1","t_of_sexp$151","sexp_of_t$153","v_next_epoch_data","v_staking_epoch_data","v_global_slot_since_genesis","v_min_window_density","v_blockchain_length","v_snarked_ledger_hash","compare$156","a_233","b_234","cmp_epoch_data","a_251","b_252","cmp_length","a_239","b_240","a_237","b_238","a_249","b_250","a_245","b_246","path$77","deriver$19","snarked_ledger_hash$1","max_min_window_density","gen$14","to_input$28","group$241","bin_shape_t$180","path$78","epoch_data_deriver","deriver$20","frozen_ledger_hash$0","state_hash$1","epoch_seed$1","length$31","amount$2","global_slot$1","typ$53","t1$8","a_313","b_314","group$242","bin_shape_t$181","path$79","gen$15","typ$54","group$243","bin_shape_t$182","path$80","to_hlist$43","user","of_hlist$43","group$244","account_transition","group$245","path$81","group$246","group$247","bin_shape_t$183","path$82","group$248","bin_shape_t$184","path$83","to_hlist$44","verification_key_hash","is_proved","is_signed","of_hlist$44","t_fields_annots$13","t_toplevel_annots$13","verification_key_hash$0","is_proved$0","is_signed$0","to_hlist$45","of_hlist$45","typ$55","deriver$21","verification_key_hash_fun","is_proved_fun","is_signed_fun","is_signed_gen","is_proved_gen","verification_key_hash_gen","to_structured","of_structured_exn","let_syntax_269","vk_hash","deriver$22","typ$56","group$249","bin_shape_t$185","path$84","let_syntax_268","t_fields_annots$14","t_toplevel_annots$14","to_hlist$46","inherit_from_parent","parents_own_token","of_hlist$46","inherit_from_parent$0","parents_own_token$0","typ$57","sum_squared","typ$58","to_input$29","to_variant","of_variant","deriver$23","inherit_from_parent_fun","parents_own_token_fun","parents_own_token_gen","inherit_from_parent_gen","deriver$24","typ$59","group$250","bin_shape_t$186","bin_size_t$89","bin_write_t$91","bin_read_t$150","t_of_sexp$152","sexp_of_t$154","hash_fold_t$89","path$85","t_fields_annots$15","t_toplevel_annots$15","t_of_sexp$153","sexp_of_t$155","to_hlist$47","of_hlist$47","vesting_increment$1","vesting_period$1","cliff_amount$1","cliff_time$1","initial_minimum_balance$1","vesting_increment$2","vesting_period$2","cliff_amount$2","cliff_time$2","initial_minimum_balance$2","to_input$30","dummy$5","to_account_timing","of_account_timing","to_hlist$48","of_hlist$48","to_input$31","typ$60","deriver$25","group$251","bin_shape_t$187","path$86","t_fields_annots$16","t_toplevel_annots$16","voting_for$1","timing$2","token_symbol$1","zkapp_uri$3","permissions$2","verification_key$1","delegate$4","app_state$3","voting_for$2","timing$3","token_symbol$2","zkapp_uri$4","permissions$3","verification_key$2","delegate$5","app_state$4","to_hlist$49","of_hlist$49","gen$16","permissions_auth","token_account","token_gen","uri_gen","auth_tag","auth_required_gen","to_hlist$50","of_hlist$50","noop","to_input$32","deriver$26","group$252","bin_shape_t$188","to_full","path$87","gen$17","of_full","deriver$27","group$253","bin_shape_t$189","path$88","t_fields_annots$17","t_toplevel_annots$17","to_hlist$51","valid_while","network","of_hlist$51","account$2","valid_while$0","account$3","network$0","deriver$28","valid_while_fun","account_fun","network_fun","network_gen","account_gen","valid_while_gen","let_syntax_265","to_hlist$52","of_hlist$52","accept$0","group$254","bin_shape_t$190","bin_size_t$90","bin_write_t$92","bin_read_t$151","t_of_sexp$154","sexp_of_t$156","hash_fold_t$90","compare$157","a_142","b_143","a_144","b_145","a_146","b_147","path$89","group$255","bin_shape_t$191","path$90","t_fields_annots$18","t_toplevel_annots$18","authorization_kind","may_use_token","implicit_account_creation_fee","use_full_commitment","preconditions","call_depth","call_data","actions","increment_nonce$3","update$6","token_id$5","public_key$5","authorization_kind$0","may_use_token$0","implicit_account_creation_fee$0","use_full_commitment$0","preconditions$0","call_depth$0","call_data$0","actions$0","increment_nonce$4","balance_change$0","update$7","token_id$6","public_key$6","deriver$29","authorization_kind_fun","may_use_token_fun","implicit_account_creation_fee_$0","use_full_commitment_fun","preconditions_fun","call_depth_fun","call_data_fun","actions_fun","events_fun","balance_change_fun","update_fun","update_gen","balance_change_gen","events_gen","actions_gen","call_data_gen","call_depth_gen","preconditions_gen","use_full_commitment_gen","implicit_account_creation_fee_","may_use_token_gen","authorization_kind_gen","group$256","bin_shape_t$192","path$91","group$257","bin_shape_t$193","sexp_of_t$157","v_authorization_kind","v_may_use_token","v_implicit_account_creation_fe","v_use_full_commitment","v_preconditions","v_call_data","v_actions","v_events","v_balance_change","v_update","v_valid_while","v_account","v_network","v_delegate$0","compare$158","a_206","b_207","path$92","sexp_of_t$158","to_hlist$53","of_hlist$53","of_graphql_repr","group$258","bin_shape_t$194","path$93","t_fields_annots$19","t_toplevel_annots$19","nonce$7","fee$1","public_key$7","nonce$8","valid_until$1","fee$2","public_key$8","let_syntax_242","gen$18","deriver$30","valid_until_fun","fee_fun","fee_gen","valid_until_gen","of_fee_payer","to_hlist$54","of_hlist$54","typ$61","non_preimage","dummy$6","to_input$33","create_body$0","let_syntax_246","let_syntax_249","let_syntax_250","let_syntax_294","let_syntax_259","let_syntax_262","let_syntax_263","let_syntax_296","group$259","bin_shape_t$195","path$94","t_fields_annots$20","t_toplevel_annots$20","authorization$0","authorization$1","deriver$31","authorization_fun","body_fun","body_gen","authorization_gen","group$260","bin_shape_t$196","path$95","group$261","bin_shape_t$197","size_of_account_update","v8$1","v7$2","v6$2","v5$2","v7$1","size_of_length","write_account_update","write_length","of_account_update","arg_1$3","arg_1$2","v_authorization","t_of_sexp$155","authorization_field","update_field","balance_change_field","events_field","actions_field","call_data_field","preconditions_field","use_full_commitment_field","may_use_token_field","authorization_kind_field","network_field","account_field","valid_while_field","valid_while_value","account_value","network_value","authorization_kind_value","may_use_token_value","use_full_commitment_value","preconditions_value","call_data_value","actions_value","events_value","balance_change_value","update_value","authorization_value","sexp_of_t$159","hash_fold_account_update","hash_fold_length","hash$86","path$96","t_of_sexp$156","sexp_of_t$160","of_graphql_repr$0","quickcheck_generator$5","digest$8","create$110","group$262","bin_shape_t$198","hash_fold_t$91","hash$87","path$97","t_fields_annots$21","t_toplevel_annots$21","authorization$2","body$1","authorization$3","body$2","let_syntax_274","deriver$32","of_fee_payer$0","balance_change$1","public_key$9","token_id$7","increment_nonce$5","group$263","bin_shape_t$199","bin_size_t$91","size_of_field","bin_write_t$93","write_field","bin_read_t$152","v_elt","v_stack_hash","t_of_sexp$157","elt_field","stack_hash_field","stack_hash_value","elt_value","sexp_of_t$161","compare$159","cmp_field","hash_fold_t$92","hash_fold_field","group$264","bin_shape_t$200","t_of_sexp$158","status_field","status_value","sexp_of_t$162","v_status","map$78","group$265","bin_size_t$92","size_of_account_update_digest","bin_write_t$94","write_account_update_digest","bin_read_t$153","of_account_update_digest","v_account_update","v_account_update_digest","v_calls","t_of_sexp$159","account_update_field","account_update_digest_field","calls_field","calls_value","account_update_digest_value","account_update_value","sexp_of_t$163","compare$160","cmp_account_update","cmp_account_update_digest","cmp_digest","hash_fold_t$93","hash_fold_account_update_diges","t_of_sexp$160","fold$22","calls","mapi_forest_with_trees","map$79","func$1","func$2","h_tl","cons$0","func$3","account_update_digest","stack_hash","account_update$0","group$266","bin_shape_t$201","t_of_sexp$161","sexp_of_t$164","quickcheck_shrinker$4","quickcheck_generator$6","size_138","random_139","size_136","random_137","quickcheck_observer$0","x_128","size_129","hash_130","x_135","hash_130$0","hash_130$1","size_133","hash_134","x_132","x_131","hash_134$0","hash_134$1","quickcheck_shrinker$5","x_125","x_127","x_126","of_account_updates_map","account_update_depth","account_updates","siblings","to_account_updates_map","collect","hash$88","cons$5","calls$0","accumulate_hashes","hash_account_update","node_hash","group$267","bin_shape_t$202","group$268","bin_shape_t$203","path$98","empty$41","group$269","bin_shape_t$204","path$99","group$270","bin_shape_t$205","path$100","version$18","t_of_sexp$162","fee_payer_field","account_updates_field","account_updates_value","fee_payer_value","sexp_of_t$165","v_account_updates","v_fee_payer","compare$161","a_224","b_225","a_230","b_231","a_228","b_229","a_226","b_227","hash_fold_t$94","group$271","bin_shape_t$206","bin_size_t$93","bin_write_t$95","bin_read_t$154","bin_read_t$155","path$101","let_syntax_275","let_syntax_273","calls_length","to_wire","forget_hashes","forget_hash","of_binable$17","path$102","group$272","bin_shape_typ$13","t_fields_annots$22","t_toplevel_annots$22","t_of_sexp$163","sexp_of_t$166","memo$2","account_updates$0","fee_payer$1","fee_payer$2","status_sym","if$11","group$273","bin_shape_t$207","path$103","create_complete","memo_hash","fee_payer_hash","group$274","bin_shape_t$208","path$104","group$275","bin_shape_t$209","t_of_sexp$164","zkapp_command_field","zkapp_command_value","sexp_of_t$167","v_zkapp_command","hash_fold_t$95","path$105","account_updates_deriver","of_zkapp_command_with_depth","to_zkapp_command_with_depth","memo_fun","account_updates_fun","fee_payer_fun","fee_payer_gen","account_updates_gen","memo_gen","account_update$1","group$276","bin_shape_t$210","to_hlist$55","of_hlist$55","group$277","bin_shape_t$211","path$106","forest","group$278","bin_shape_t$212","t_of_sexp$165","of_u","sexp_of_t$168","compare$162","cmp_u","cmp_s","hash_fold_t$96","hash_fold_u","hash_fold_s","to_signed_command","gen_signed","group$279","bin_shape_t$213","t_of_sexp$166","sexp_of_t$169","hash_fold_t$97","path$107","group$280","bin_shape_t$214","path$108","group$281","bin_shape_t$215","t_of_sexp$167","sexp_of_t$170","hash_fold_t$98","path$109","with_random_receivers","size_args$0","a_012","right_014","left_013","a_016","a_018","right_006","left_005","right_004","left_003","single_to_yojson","single_of_yojson","single_of_sexp","sexp_of_single","compare_single","hash_fold_single","hash_single","to_singles","of_singles","custom_printf_026","custom_printf_027","two$0","singles","receiver_pks","receivers","ft$0","ft$1","fee_tokens","to_fee_transfer","coinbase_amount","v_receiver","v_fee_transfer","receiver_field","fee_transfer_field","fee_transfer_value","receiver_value","cb","access_status","account_ids","adjusted_fee_transfer","expected_supply_increase","increase","supercharged_coinbase","of_coinbase","incr_by_one","push$0","check_merge","to_latest$1","path$2","poly_stack_hash","size_of_stack_hash","write_stack_hash","bin_writer_stack_hash","of_stack_hash","v_init","v_curr","bin_reader_stack_hash","bin_stack_hash","init_field","curr_field","curr_value","init_value","cmp_stack_hash","hash_fold_stack_hash","to_latest$2","path$3","var_of_t$1","push$1","state_body_hash","empty$1","push$2","check_merge$0","correct_transition","eq_target","eq_src","same_update","bin_shape_t$8","hash$3","to_latest$3","bin_shape_t$9","versioned$6","t_of_sexp$5","sexp_of_t$5","to_latest$4","sexp_of_t$6","var_of_t$2","no_update","update_two_stacks_coinbase_in_","update_two_stacks_coinbase_in_$0","poly_action","poly_coinbase_amount","size_of_action","size_of_coinbase_amount","write_action","write_coinbase_amount","bin_writer_action","bin_writer_coinbase_amount","of_action","of_coinbase_amount","v_action","bin_reader_action","bin_reader_coinbase_amount","bin_action","bin_coinbase_amount","versioned$7","t_of_sexp$7","action_field","action_value","sexp_of_t$7","t_of_sexp$8","bin_shape_t$10","bin_writer_t$8","bin_reader_t$8","bin_t$8","versioned$8","t_of_sexp$9","sexp_of_t$9","to_latest$5","sexp_of_t$10","genesis","var_of_t$3","poly_data_stack","poly_state_stack","data_stack","state_stack","size_of_data_stack","size_of_state_stack","write_data_stack","write_state_stack","bin_writer_t$9","bin_writer_data_stack","bin_writer_state_stack","of_data_stack","of_state_stack","bin_reader_t$9","bin_reader_data_stack","bin_reader_state_stack","bin_t$9","bin_data_stack","bin_state_stack","version$8","versioned$9","hash_fold_data_stack","hash_fold_state_stack","t_of_sexp$11","cmp_data_stack","cmp_state_stack","compare$3","a_044","t_of_sexp$12","sexp_of_t$12","a_046","b_047","bin_shape_t$11","bin_size_t$6","bin_write_t$6","bin_writer_t$10","bin_read_t$13","bin_read_t$14","bin_reader_t$10","bin_t$10","versioned$10","equal$8","a_050","a_052","hash_fold_t$5","hash$4","t_of_sexp$13","a_056","a_058","to_latest$6","equal$9","hash_fold_t$6","hash$5","sexp_of_t$15","compare$7","group$12","bin_shape_t$12","bin_size_t$7","bin_write_t$7","bin_writer_t$11","bin_read_t$15","bin_read_t$16","bin_reader_t$11","bin_t$11","equal$10","compare$8","sexp_of_t$16","versioned$11","hash$6","to_latest$7","equal$11","compare$9","sexp_of_t$17","hash_fold_t$8","hash$7","group$13","bin_shape_t$13","bin_writer_t$12","bin_read_t$18","bin_reader_t$12","bin_t$12","versioned$12","sexp_of_t$18","to_latest$8","sexp_of_t$19","max_coinbase_stack_count","chain","hash_fold_t$9","sexp_of_t$20","compare$10","a_076","b_077","equal$12","hash_fold_t$10","hash$8","hash_var","var_of_t$4","num_pad_bits","pad_bits","empty$2","create_with","equal_state_hash","equal_data","connected","coinbase_stack_connected","state_stack_connected","state_stack_connected$0","push_coinbase","push_state","push_coinbase$0","push_state$0","check_merge$1","valid_coinbase_stacks","valid_state_stacks","create_with$0","equal$13","a_082","b_083","compare$12","a_084","b_085","hash_fold_t$11","hash$9","var_of_t$5","empty_hash$0","merge$0","sexp_of_t$23","hash_var$0","hash$10","merge$1","reraise_merkle_requests","addr$0","addr$1","add_coinbase","coinbase_receiver","supercharge_coinbase","addr2","addr1","equal_to_zero","update_stack1","total_coinbase_amount","rem_amount","no_coinbase_in_this_stack","amount1_equal_to_zero","amount2_equal_to_zero","no_coinbase","stack_with_amount1","stack_with_amount2","previous_state_stack","stack_initialized","stack_with_state_hash","update_state","stack_with_coinbase","stack_with_state","update_second_stack","act","pop_coinbases","proof_emitted","let_syntax_086","let_syntax_087","poly_tree","poly_stack_id","of_tree","of_stack_id","pos_list_field","new_pos_field","new_pos_value","pos_list_value","v_new_pos","v_pos_list","t_of_sexp$24","sexp_of_t$25","init_hash","hash_at_level","cur_hash","root_hash","key$2","key$3","height$0","merkle_root$0","get_stack","find_index","next_stack_id","is_new_stack","incr_index","latest_stack_id","curr_stack_id","current_stack","prev_stack_id","latest_stack","prev_stack","oldest_stack_id","remove_oldest_stack_id","oldest_stack","update_stack","stack_index","stack_before","stack_after","add_coinbase$0","add_state","update_coinbase_stack","remove_coinbase_stack","hash_extra","pos_list","pending_coinbase","coinbase_stack_path_exn","stack_id","stack_id$0","index1","stack_id$1","index2","idx$1","idx$2","prev_state","group$14","bin_size_t$9","size_of_tree","size_of_stack_id","bin_write_t$9","write_tree","write_stack_id","bin_writer_t$13","bin_writer_tree","bin_writer_stack_id","bin_read_t$19","bin_read_t$20","bin_reader_t$13","bin_reader_tree","bin_reader_stack_id","bin_t$13","bin_tree","bin_stack_id","versioned$13","sexp_of_t$26","group$15","bin_size_t$10","bin_write_t$10","bin_writer_t$14","bin_read_t$21","bin_read_t$22","bin_reader_t$14","bin_t$14","versioned$14","t_of_sexp$27","to_latest$9","coinbases_gen","cbs","after_adding","after_del","add_coinbase_with_zero_checks","max_coinbase_amount","t_with_state","interim_tree","coinbase_data","cb_var","f_add_coinbase","amount_var","action_var","coinbase_receiver_var","supercharge_coinbase_var","state_body_hash_var","global_slot_var","checked_merkle_root","f_pop_coinbase","unchecked_after_pop","comp$0","checked_merkle_root_after_pop","add_remove_check","coinbase_lists","coinbase_lists$0","pc$0","coinbase_lists$1","coinbases$0","stacks","coinbases","initial_coinbase","updated","new_stack","new_stack$0","pending_coinbases_updated","added_stacks","expected_stack","updated_pending_coinbases","popped_stack","pc$1","coinbase_lists$2","coinbase_lists_gen","of_bytes","of_sha256","length_in_bytes$0","to_base58_check$0","of_base58_check_exn$0","v_ledger_hash","v_aux_hash","v_pending_coinbase_aux","ledger_hash_field","aux_hash_field","pending_coinbase_aux_field","pending_coinbase_aux_value","aux_hash_value","ledger_hash_value","pending_coinbase_aux","aux_hash","pending_coinbase_aux$0","aux_hash$0","ledger_hash$0","ledger_hash_fun","aux_hash_fun","pending_coinbase_aux_fun","ledger_hash_gen","aux_hash_gen","pending_coinbase_aux_gen","map_poly","for_all$0","set_all_mutable_fields","value_of_sexp","compare_value","hash_fold_value","pending_coinbase_aux$1","aux_hash$1","ledger_hash$1","pending_coinbase_aux$2","aux_hash$2","ledger_hash$2","fold$1","map_poly$0","to_list$1","fold$2","for_all$2","to_list$2","set_all_mutable_fields$0","value_to_yojson","genesis_ledger_hash","fold$3","ledger_hash$3","aux_hash$3","of_ledger_aux_coinbase_hash","warn_improper_transport","poly_non_snark","poly_pending_coinbase_hash","non_snark","pending_coinbase_hash","size_of_non_snark","size_of_pending_coinbase_hash","write_non_snark","write_pending_coinbase_hash","bin_writer_non_snark","bin_writer_pending_coinbase_ha","of_non_snark","of_pending_coinbase_hash","v_non_snark","v_pending_coinbase_hash","bin_reader_non_snark","bin_reader_pending_coinbase_ha","bin_non_snark","bin_pending_coinbase_hash","non_snark_field","pending_coinbase_hash_field","pending_coinbase_hash_value","non_snark_value","cmp_non_snark","cmp_pending_coinbase_hash","hash_fold_non_snark","hash_fold_pending_coinbase_has","hash_value$0","ledger_hash$4","aux_hash$4","pending_coinbase_aux$3","pending_coinbase_hash_var","of_aux_ledger_and_coinbase_has","genesis$0","non_snark$0","pending_coinbase_hash$0","caller_caller","hash_zkapp_command","group$282","bin_shape_t$216","path$110","v_prover","prover_field","prover_value","compare$163","group$283","bin_shape_t$217","sexpifier$3","v_genesis_state_timestamp","v_slots_per_sub_window","v_slots_per_epoch","v_k","path$111","compare$164","end_time","gen$19","value_of_t","typ$62","p_var","group$284","bin_shape_t$218","path$112","group$285","bin_shape_t$219","path$113","group$286","bin_shape_t$220","t_of_sexp$168","sexp_of_t$171","compare$165","path$114","equal_account_state","group$287","bin_shape_t$221","command","t_of_sexp$169","of_command","sexp_of_t$172","compare$166","cmp_command","hash_fold_t$99","hash_fold_command","group$288","bin_shape_t$222","t_of_sexp$170","sexp_of_t$173","compare$167","hash_fold_t$100","func$20","path$115","group$289","bin_shape_t$223","t_of_sexp$171","sexp_of_t$174","compare$168","hash_fold_t$101","func$21","path$116","compare_hash","group$290","bin_shape_t$224","bin_read_t$156","bin_read_t$157","bin_reader_t$58","bin_size_t$94","bin_write_t$96","bin_writer_t$58","bin_t$58","mk_hasher","bin_size_t$95","bin_write_t$97","bin_read_t$158","bin_read_t$159","bin_shape_t$225","bin_writer_t$59","bin_reader_t$59","bin_t$59","signed_cmd_hasher_v1","signed_cmd_hasher","zkapp_cmd_hasher","hash_signed_command_v1","cmd_dummy_signature","hash_signed_command_v2","acct_update","dummy_auth","cmd_dummy_signatures_and_proof","hash_of_transaction_id","cmd_v1","group$291","bin_shape_t$226","t_of_sexp$172","sexp_of_t$175","compare$169","path$117","group$292","bin_shape_t$227","t_of_sexp$173","sexp_of_t$176","compare$170","path$118","group$293","signed_amount","group$294","failure_status_tbl","bin_shape_t$228","path$119","group$295","bin_shape_t$229","path$120","t_of_sexp$174","user_command_field","user_command_value","sexp_of_t$177","v_user_command","group$296","bin_shape_t$230","path$121","t_of_sexp$175","previous_delegate_field","previous_delegate_value","new_accounts_field","new_accounts_value","sexp_of_t$178","v_new_accounts","v_previous_delegate","group$297","bin_shape_t$231","path$122","t_of_sexp$176","sexp_of_t$179","group$298","bin_shape_t$232","path$123","t_of_sexp$177","accounts_field","command_field","command_value","accounts_value","sexp_of_t$180","v_command","v_accounts","group$299","bin_shape_t$233","path$124","t_of_sexp$178","sexp_of_t$181","group$300","bin_shape_t$234","path$125","t_of_sexp$179","burned_tokens_field","burned_tokens_value","sexp_of_t$182","v_burned_tokens","group$301","bin_shape_t$235","path$126","t_of_sexp$180","coinbase_field","coinbase_value","sexp_of_t$183","v_coinbase","group$302","bin_shape_t$236","path$127","t_of_sexp$181","sexp_of_t$184","group$303","bin_shape_t$237","path$128","t_of_sexp$182","previous_hash_field","varying_field","varying_value","previous_hash_value","sexp_of_t$185","v_varying","v_previous_hash","burned_tokens","varying","supply_increase","burned_tokens$0","account_creation_fee_int","new_accounts","zc","num_accounts_created","account_creation_fees","txn","process_decreases","amts","timing_error_to_user_command_s","validate_timing_with_min_balan","txn_amount","txn_global_slot","account_balance","proposed_new_balance","curr_min_balance","curr_min_balance$0","invalid_timing","invalid_balance","possibly_error","validate_timing_with_min_balan$0","min_balance","validate_timing","error_opt","get_with_location","set_with_location","sub_account_creation_fee","transaction","transaction_status","get_new_accounts","has_locked_tokens","apply_user_command_unchecked","signer_pk","fee_payer_account","fee_payer_location","ok_or_reject","compute_updates","receiver_account","receiver_location","receiver_amount","updated_accounts","previous_delegate","applied_body","located_accounts","applied_common","apply_user_command","second_pass_ledger","value_if","is_empty$0","assert_with_failure_status_tbl","ecol","proof_verifies","signature_verifies","get_zkapp","set_zkapp","is_non_neg","of_constant_fee","set_or_keep","or_default","add_check","eff","global_state","local_state","new_account","precondition_account","local_state$0","nonce_matches","global_state$0","or_err","pop_call_stack","next_call_stack","next_frame","update_action_state","s1_updated","is_this_slot","is_empty_or_this_slot","s5$0","s4$0","s3$0","is_start","is_empty_call_forest","is_start$0","will_succeed","start_data$2","start_data$3","first_pass_ledger","call_stack","to_pop","start_data$0","start_data$1","call_stack$1","to_pop$0","next_forest","current_is_empty","call_stack$0","current_forest","remainder_of_current_forest","account_update_forest","may_use_parents_own_token","may_use_token_inherited_from_p","account_update_forest_empty","remainder_of_current_forest_em","popped_call_stack","newly_popped_frame","remainder_of_current_forest_fr","new_call_stack","new_frame","local_state$1","account_update_token_id","default_token_or_token_owner_w","full_transaction_commitment","transaction_commitment","start_data","full_tx_commitment_on_start","tx_commitment","full_tx_commitment","local_state$35","account_is_new","self_delegate","zkapp$2","matching_verification_key_hash","local_state$2","local_state$3","protocol_state_predicate_satis","local_state$4","valid_while_satisfied","local_state$5","local_state$6","local_state$7","precondition_has_constant_nonc","increments_nonce_and_constrain","depends_on_the_fee_payers_nonc","does_not_use_a_signature","local_state$8","account_update_token","account_update_token_is_defaul","account_is_untimed","local_state$9","account_creation_fee","local_state$10","neg_creation_fee","creation_overflow","balance_change_for_creation","pay_creation_fee","creation_overflow$0","local_state$11","pay_creation_fee_from_excess","failed1","local_state$12","account_creation_fee$0","excess_update_failed","excess_minus_creation_fee","local_state$13","supply_increase_update_failed","supply_increase_minus_creation","local_state$14","is_receiver","has_permission$0","local_state$15","invalid_timing$1","invalid_timing$0","local_state$16","has_permission$1","local_state$17","keeping_app_state","changing_entire_app_state","has_permission$2","local_state$18","has_permission$3","local_state$19","has_permission$4","local_state$20","has_permission$5","local_state$21","has_permission$6","local_state$22","base_delegate","has_permission$7","local_state$23","has_permission$8","local_state$24","old_hash","has_permission$9","local_state$25","index_input","has_permission$10","local_state$26","local_delta","new_local_fee_excess","overflowed","new_local_fee_excess$0","local_state$27","local_state$28","is_last_account_update","local_state$29","delta_settled","valid_fee_excess","local_state$30","is_start_or_last","update_global_state_fee_excess","global_excess_update_failed","local_state$31","local_state$32","local_state$33","should_update","local_state$34","update_action_state$0","apply_zkapp_command_first_pass","state_view","previous_hash","original_first_pass_account_st","perform$0","user_acc","apply_zkapp_command_first_pass$0","partial_stmt","apply_zkapp_command_second_pas","account_states","acc_opt","original_account_states","step_all","l_state","g_state","states","reversed_failure_status_tbl","account_ids_originally_not_in_","loc_and_acct","successfully_applied","failure_status_tbl$0","valid_result","loc_opt","other_account_update_accounts_","apply_zkapp_command_unchecked_","apply_zkapp_command_unchecked","state_res","account_update_applied","update_timing_when_no_deductio","has_permission_to_receive$0","receiver_account_id","init_account","single_failure","no_failure","append_entry","apply_fee_transfer","transfer","failures","ft_with_status","modify_timing","modify_balance","ft2","ft1","account_id1","can_receive1","action1","account_id2","new_accounts1","can_receive2","action2","balance1","timing2","balance2","burned_tokens1","burned_tokens2","new_accounts2","can_receive","apply_coinbase","failures1","transferee_timing_prev","transferee_update","receiver_reward","receiver_id","coinbase_receiver_timing","receiver_balance","coinbase_with_status","new_receiver_timing","transferee","transferee_id","transferee_account","transferee_location","apply_transaction_first_pass","txn_state_view","applied","txn$0","partially_applied","apply_transaction_second_pass","applied$0","previous_hash$0","applied$1","previous_hash$1","apply_transactions","txns","min_init_balance","max_init_balance","num_accounts","num_transactions","mk_gen","num_transactions$0","init_ledger","nonces","receiver_is_new","gen_index","receiver_index","nonces$0","let_syntax_041","let_syntax_042","raise$1","array_length","export$0","jsoo_exports","raise_error","raise_exn","json_parse","binary_string_to_base58_check","bin_string","binary_string_of_base58_check","base58","public_key_to_base58","public_key_of_base58","pk_base58","private_key_to_base58","sk","private_key_of_base58","sk_base58","token_id_to_base58","token_id_of_base58","memo_to_base58","memo_hash_base58","memo_base58","derive$1","derive_checked","deriver$33","body_deriver","of_json$0","hash_to_group","sign_field_element","is_mainnet","typ$63","account_update$2","account_update$3","transaction_commitments","tx_json","zkapp_public_input","account_update_index","pack_input$2","timing_input","permissions_input","update_input","account_precondition_input","network_precondition_input","body_input","ok_exn$0","hash_payment","command$0","hash_payment_v1","b58","serialize_common","serialize_payment","serialize_payment_v1","payment$1","example_payment","hashPayment","hashPaymentV1","serializeCommon","serializePayment","serializePaymentV1","examplePayment","accountUpdate","transactionCommitments","zkappPublicInput","signFieldElement","dummySignature","deriveChecked","toBase58","ofBase58","publicKeyToBase58","publicKeyOfBase58","privateKeyToBase58","privateKeyOfBase58","tokenIdToBase58","tokenIdOfBase58","memoToBase58","memoHashBase58","test$1","class$1","get$19","location_of_account","set$16","next_location","get_or_create","create_new_account","remove_accounts_exn","ids","locs","empty$42","with_ledger","create_masked","default_token_id","account_id$0","create$111","deriver$34","transform","get_account","add_account","balance$0","bal_u64","deriver$35","of_json$1","apply_json_transaction","network_json","network_state","who","application_result","static_method","method","prototype","public_input_typ","statement_typ","input_size","output_size","inner_curve_typ","should_verifys_js","js_bool","should_verifys","public_output_size","statements","nat_modules_list","nat_add_modules_list","pickles_compile","max_proofs","to_js_provers","prove","js_prevs","public_output","previous_proofs_should_verify","previous_public_inputs","should_verifys$0","public_inputs$0","prevs$1","proof_to_base64","proof$1","proof_of_base64","dummy_base64_proof","dummy_verification_key","pickles","typ$64","size_in_fields","exists$12","exists_var","run_and_check$3","run_unchecked$3","constraint_system$3","add$34","scale$9","mul$3","read_var$0","assert_mul","assert_square$5","assert_boolean","compare$171","to_bits$3","from_bits","truncate_to_bits16","length_div_16","seal$2","and","or","equals","ec_add","scale$10","scalar_bits","of_js","verify$1","public_input_vec","get_vk","get_cs_json","update$8","hash_to_group$0","sponge_params_checked","sponge_params$1","sponge_create","is_checked","sponge_absorb","sponge_squeeze","existsVar","poseidon","hashToGroup","getVerificationKey","getConstraintSystemJSON","ecadd","assertEqual","readVar","assertMul","assertSquare","assertBoolean","toBits","fromBits","truncateToBits16","toConstantAndTerms","asProver","inProverBlock","runAndCheck","runUnchecked","constraintSystem","snarky","export$1","export_global","snarky_obj"],"sources":["","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/strftime.js","/home/fok/codes/o1-labs/mina/_opam/lib/base/runtime.js","/builtin/+ints.js","/builtin/+hash.js","/builtin/+ieee_754.js","/builtin/+int64.js","/builtin/+fail.js","/builtin/+stdlib.js","/builtin/+mlBytes.js","/builtin/+bigarray.js","/workspace_root/src/lib/snarkyjs/src/bindings/ocaml/overrides.js","/builtin/+marshal.js","/home/fok/codes/o1-labs/mina/_opam/lib/base/base_internalhash_types/runtime.js","/builtin/+nat.js","/builtin/+jslib.js","/home/fok/codes/o1-labs/mina/_opam/lib/base_bigstring/runtime.js","/builtin/+bigstring.js","/home/fok/codes/o1-labs/mina/_opam/lib/bigstringaf/runtime.js","/home/fok/codes/o1-labs/mina/_opam/lib/bin_prot/runtime.js","/builtin/+array.js","/builtin/+backtrace.js","/workspace_root/src/lib/snarkyjs/src/bindings/kimchi/js/node_js/node_backend.js","/workspace_root/src/lib/snarkyjs/src/bindings/kimchi/js/bindings.js","/builtin/+compare.js","/builtin/+weak.js","/builtin/+gc.js","/builtin/+format.js","/builtin/+obj.js","/builtin/+fs_node.js","/builtin/+fs.js","/builtin/+unix.js","/builtin/+sys.js","/builtin/+fs_fake.js","/builtin/+io.js","/builtin/+lexing.js","/builtin/+md5.js","/home/fok/codes/o1-labs/mina/_opam/lib/ppx_expect/collector/runtime.js","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/runtime.js","/workspace_root/src/lib/promise/js/promise.js","/workspace_root/src/lib/integers_stubs_js/runtime.js","/home/fok/codes/o1-labs/mina/_opam/lib/zarith_stubs_js/biginteger.js","/home/fok/codes/o1-labs/mina/_opam/lib/zarith_stubs_js/runtime.js","/home/fok/codes/o1-labs/mina/_opam/lib/time_now/runtime.js","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/obj.ml","/workspace_root/src/lib/pickles/limb_vector/constant.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/int64.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/random.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/lexing.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/camlinternalFormat.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/printexc.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/filename.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/exn.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/sign0.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/hex_lexer.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/popcount.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/int63_emul.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/backtrace.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppx_bench/runtime-lib/benchmark_accumulator.ml","/home/fok/codes/o1-labs/mina/_opam/lib/bin_prot/shape/bin_shape.ml","/home/fok/codes/o1-labs/mina/_opam/lib/stdio/in_channel.ml","/home/fok/codes/o1-labs/mina/_opam/lib/stdio/out_channel.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppx_module_timer/runtime/ppx_module_timer_runtime.ml","/home/fok/codes/o1-labs/mina/_opam/lib/typerep/std_internal.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppx_expect/collector/check_backtraces.ml","/home/fok/codes/o1-labs/mina/_opam/lib/splittable_random/splittable_random.ml","/home/fok/codes/o1-labs/mina/_opam/lib/parsexp/positions.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/perms.ml","/home/fok/codes/o1-labs/mina/_opam/lib/sexplib0/sexp_conv_error.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/quickcheck.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/std_internal.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/span_float.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/tuple.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/digit_string_helpers.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/month.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/date0.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/percent.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/ofday_float.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/span_ns.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/ofday_ns.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/gc.ml","/home/fok/codes/o1-labs/mina/_opam/lib/easy-format/easy_format.ml","/home/fok/codes/o1-labs/mina/_opam/lib/yojson/yojson.ml","/home/fok/codes/o1-labs/mina/_opam/lib/bignum/bigint/bigint.ml","/workspace_root/src/lib/snarky/src/base/cvar.ml","/workspace_root/src/lib/snarky/src/base/constraint.ml","/workspace_root/src/lib/snarky/src/base/backend_extended.ml","/workspace_root/src/lib/snarky/src/base/checked_runner.ml","/workspace_root/src/lib/snarky/src/base/utils.ml","/workspace_root/src/lib/snarky/src/base/merkle_tree.ml","/workspace_root/src/lib/snarky/src/base/snark0.ml","/home/fok/codes/o1-labs/mina/_opam/lib/bigstringaf/bigstringaf.ml","/workspace_root/src/lib/pickles_types/shifted_value.ml","/workspace_root/src/lib/pickles_types/plonk_types.ml","/workspace_root/src/lib/pickles/pickles.ml","/workspace_root/src/lib/pickles_types/plonk_verification_key_evals.ml","/workspace_root/src/lib/pickles_types/pcs_batch.ml","/workspace_root/src/lib/snarky/sponge/sponge.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/tuple_pool/tuple_pool.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/validate.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/thread_pool_cpu_affinity/thread_pool_cpu_affinity.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/uopt/uopt.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/timing_wheel/timing_wheel.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/async_kernel_config.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/monitor.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/async_kernel.ml","/home/fok/codes/o1-labs/mina/_opam/lib/digestif/ocaml/baijiu_blake2b.ml","/home/fok/codes/o1-labs/mina/_opam/lib/digestif/ocaml/baijiu_blake2s.ml","/home/fok/codes/o1-labs/mina/_opam/lib/digestif/ocaml/digestif.ml","/workspace_root/src/lib/hex/hex.ml","/workspace_root/src/lib/logger/fake/logger.ml","/workspace_root/src/lib/allocation_functor/table.ml","/workspace_root/src/lib/crypto/kimchi_backend/common/scale_round.ml","/workspace_root/src/lib/crypto/kimchi_backend/common/scalar_challenge.ml","/workspace_root/src/lib/crypto/kimchi_backend/common/curve.ml","/workspace_root/src/lib/crypto/kimchi_backend/common/plonk_dlog_proof.ml","/workspace_root/src/lib/crypto/kimchi_backend/common/bigint.ml","/workspace_root/src/lib/crypto/kimchi_backend/common/endoscale_round.ml","/workspace_root/src/lib/crypto/kimchi_backend/common/endoscale_scalar_round.ml","/workspace_root/src/lib/crypto/kimchi_backend/common/field.ml","/workspace_root/src/lib/crypto/kimchi_backend/common/plonk_constraint_system.ml","/workspace_root/src/lib/snarky/fold_lib/fold.ml","/workspace_root/src/lib/snarky/snarkette/fields.ml","/workspace_root/src/lib/crypto/kimchi_backend/pasta/vesta_based_plonk.ml","/workspace_root/src/lib/crypto/kimchi_backend/pasta/pallas_based_plonk.ml","/workspace_root/src/lib/blake2/blake2.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/ast_412.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/pprintast.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/ast_413.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/ast_414.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/ast_411.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/ast_410.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/ast_409.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/ast_408.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/ast_407.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/ast_406.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/ast_405.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/ast_404.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/ast_403.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/ast_402.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/migrate_403_402.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/ast/versions.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/stdppx/stdppx.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/name.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/camlinternalOO.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/deriving.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base_quickcheck/ppx_quickcheck/expander/environment.ml","/workspace_root/src/lib/random_oracle_input/random_oracle_input.ml","/workspace_root/src/lib/pickles_base/proofs_verified.ml","/workspace_root/src/lib/pickles_base/side_loaded_verification_key.ml","/workspace_root/src/lib/pickles_base/domain.ml","/workspace_root/src/lib/pickles/composition_types/branch_data.ml","/workspace_root/src/lib/pickles/composition_types/bulletproof_challenge.ml","/workspace_root/src/lib/pickles/composition_types/composition_types.ml","/workspace_root/src/lib/pickles/plonk_checks/scalars.ml","/workspace_root/src/lib/mina_version/normal/mina_version.ml","/workspace_root/src/lib/base58_check/base58_check.ml","/workspace_root/src/lib/snarky/snarky_curve/snarky_curve.ml","/workspace_root/src/lib/snark_keys_header/snark_keys_header.ml","/workspace_root/src/lib/error_json/error_json.ml","/workspace_root/src/lib/pickles/wrap_wire_proof.ml","/workspace_root/src/lib/pickles/scalar_challenge.ml","/workspace_root/src/lib/pickles/impls.ml","/workspace_root/src/lib/pickles/plonk_curve_ops.ml","/workspace_root/src/lib/pickles/reduced_messages_for_next_proof_over_same_field.ml","/workspace_root/src/lib/pickles/step_main_inputs.ml","/workspace_root/src/lib/pickles/side_loaded_verification_key.ml","/workspace_root/src/lib/pickles/proof.ml","/workspace_root/src/lib/pickles/wrap_main_inputs.ml","/workspace_root/src/lib/pickles/wrap_verifier.ml","/workspace_root/src/lib/pickles/step_verifier.ml","/workspace_root/src/lib/pickles/cache.ml","/workspace_root/src/lib/snark_params/snark_params.ml","/workspace_root/src/lib/random_oracle/permutation/external/random_oracle_permutation.ml","/workspace_root/src/lib/random_oracle/random_oracle.ml","/workspace_root/src/lib/non_zero_curve_point/non_zero_curve_point.ml","/workspace_root/src/lib/signature_lib/private_key.ml","/workspace_root/src/lib/signature_lib/schnorr.ml","/workspace_root/src/lib/signature_lib/keypair.ml","/workspace_root/src/lib/sgn/sgn.ml","/workspace_root/src/lib/sparse_ledger_lib/sparse_ledger.ml","/workspace_root/src/lib/rosetta_coding/coding.ml","/workspace_root/src/lib/ppx_dhall_type/deriving.ml","/workspace_root/src/lib/mina_numbers/global_slot_span.ml","/workspace_root/src/lib/mina_numbers/global_slot_since_genesis.ml","/workspace_root/src/lib/mina_numbers/global_slot_since_hard_fork.ml","/workspace_root/src/lib/currency/signed_poly.ml","/workspace_root/src/lib/currency/currency.ml","/home/fok/codes/o1-labs/mina/_opam/lib/re/cset.ml","/home/fok/codes/o1-labs/mina/_opam/lib/graphql_parser/parser.ml","/home/fok/codes/o1-labs/mina/_opam/lib/graphql_parser/lexer.ml","/home/fok/codes/o1-labs/mina/_opam/lib/graphql/graphql_schema.ml","/workspace_root/src/lib/fields_derivers/fields_derivers.ml","/workspace_root/src/lib/fields_derivers_graphql/fields_derivers_graphql.ml","/workspace_root/src/lib/fields_derivers_json/fields_derivers_json.ml","/workspace_root/src/lib/with_hash/with_hash.ml","/workspace_root/src/lib/fields_derivers_zkapps/fields_derivers_zkapps.ml","/workspace_root/src/lib/data_hash_lib/state_hash.ml","/workspace_root/src/lib/genesis_constants/genesis_constants.ml","/workspace_root/src/lib/block_time/block_time.ml","/workspace_root/src/lib/one_or_two/one_or_two.ml","/workspace_root/src/lib/mina_base/account_id.ml","/workspace_root/src/lib/mina_base/account_timing.ml","/workspace_root/src/lib/mina_base/signature.ml","/workspace_root/src/lib/mina_base/control.ml","/workspace_root/src/lib/mina_base/payment_payload.ml","/workspace_root/src/lib/mina_base/ledger_hash0.ml","/workspace_root/src/lib/mina_base/permissions.ml","/workspace_root/src/lib/mina_base/signed_command_memo.ml","/workspace_root/src/lib/mina_base/stake_delegation.ml","/workspace_root/src/lib/mina_base/transaction_status.ml","/workspace_root/src/lib/mina_base/transaction_union_tag.ml","/workspace_root/src/lib/mina_base/signed_command_payload.ml","/workspace_root/src/lib/mina_base/signed_command.ml","/workspace_root/src/lib/mina_base/receipt.ml","/workspace_root/src/lib/mina_base/state_body_hash.ml","/workspace_root/src/lib/mina_base/zkapp_basic.ml","/workspace_root/src/lib/mina_base/zkapp_account.ml","/workspace_root/src/lib/mina_base/account.ml","/workspace_root/src/lib/mina_base/epoch_ledger.ml","/workspace_root/src/lib/mina_base/epoch_seed.ml","/workspace_root/src/lib/mina_base/epoch_data.ml","/workspace_root/src/lib/mina_base/zkapp_precondition.ml","/workspace_root/src/lib/mina_base/data_as_hash.ml","/workspace_root/src/lib/mina_base/account_update.ml","/workspace_root/src/lib/mina_base/with_stack_hash.ml","/workspace_root/src/lib/mina_base/with_status.ml","/workspace_root/src/lib/mina_base/zkapp_command.ml","/workspace_root/src/lib/mina_base/user_command.ml","/workspace_root/src/lib/mina_base/fee_transfer.ml","/workspace_root/src/lib/mina_base/coinbase_fee_transfer.ml","/workspace_root/src/lib/mina_base/coinbase.ml","/workspace_root/src/lib/mina_base/pending_coinbase.ml","/workspace_root/src/lib/mina_base/staged_ledger_hash.ml","/workspace_root/src/lib/mina_base/sok_message.ml","/workspace_root/src/lib/mina_base/protocol_constants_checked.ml","/workspace_root/src/lib/mina_base/fee_with_prover.ml","/workspace_root/src/lib/transaction/transaction.ml","/workspace_root/src/lib/transaction/transaction_hash.ml","/workspace_root/src/lib/transaction_logic/mina_transaction_logic.ml","/workspace_root/src/lib/snarkyjs/src/bindings/ocaml/lib/consistency_test.ml","/workspace_root/src/lib/snarkyjs/src/bindings/ocaml/lib/pickles_bindings.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/camlinternalFormatBasics.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/camlinternalAtomic.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/stdlib.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/base.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/stdlib.mli","/home/fok/codes/o1-labs/mina/_opam/lib/base/int_intf.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/float0.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/pipe.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/int_conversions.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/list.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base_quickcheck/ppx_quickcheck/expander/import.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/sys0.ml","/home/fok/codes/o1-labs/mina/_opam/lib/bin_prot/write.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/camlinternalLazy.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/lazy.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/seq.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/option.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/result.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/char.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/int.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/bytes.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/string.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/marshal.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/array.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/int32.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/nativeint.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/parsing.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/set.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/map.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/stack.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/queue.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/buffer.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/printf.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base_bigstring/base_bigstring.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/arg.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/fun.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/digest.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/random.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/hashtbl.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/attribute.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/format.ml","/home/fok/codes/o1-labs/mina/_opam/lib/re/fmt.ml","/home/fok/codes/o1-labs/mina/_opam/lib/re/pmark.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/scanf.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/callback.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/camlinternalMod.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/bigarray.ml","/home/fok/codes/o1-labs/mina/_opam/lib/sexplib0/lazy_group_id.ml","/home/fok/codes/o1-labs/mina/_opam/lib/sexplib0/sexp.ml","/home/fok/codes/o1-labs/mina/_opam/lib/sexplib0/sexp_conv.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/ephemeron.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/span_helpers.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/import0.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/printf.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/array0.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/char0.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/list0.ml","/workspace_root/src/lib/snarky/bitstring_lib/bitstring.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/hash.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/ppx_compare_lib.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/string0.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/sexp.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/sexpable.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/word_size.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/pretty_printer.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/core_kernel.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/with_return.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/monad.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/comparator.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/field.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/source_code_position0.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/list1.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/result.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/container_intf.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/container.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/lazy.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/monad_intf.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/fn.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/list.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/ordering.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/applicative.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/info.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/error.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/invariant.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/maybe_bound.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/or_error.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/comparable.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/identifiable.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/comparable_intf.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/unit.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/ordered_collection_common.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/binary_search.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/binary_searchable.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/bytes0.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/blit.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/option.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/either.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/indexed_container.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/sequence.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/array.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/obj_array.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/uniform_array.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/char.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/string.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/bytes.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/pow_overflow_bounds.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/int_math.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/int.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/type_equal.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/univ_map.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/option_array.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/stack.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/set.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/set_intf.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/queue.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/nothing.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/never_returns.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/nativeint.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/map.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/map_intf.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/int64.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/bool.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/int32.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/int63.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/hashtbl.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/hashtbl_intf.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/hashable_intf.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/avltree.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/hash_set_intf.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/hash_set.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/float.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/buffer.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppx_assert/runtime-lib/runtime.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/md5/md5_lib.ml","/home/fok/codes/o1-labs/mina/_opam/lib/bin_prot/common.ml","/workspace_root/src/lib/pickles_types/vector.ml","/home/fok/codes/o1-labs/mina/_opam/lib/bin_prot/read.ml","/home/fok/codes/o1-labs/mina/_opam/lib/bin_prot/shape.ml","/home/fok/codes/o1-labs/mina/_opam/lib/bin_prot/size.ml","/home/fok/codes/o1-labs/mina/_opam/lib/bin_prot/type_class.ml","/home/fok/codes/o1-labs/mina/_opam/lib/bin_prot/utils.ml","/home/fok/codes/o1-labs/mina/_opam/lib/bin_prot/std.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppx_inline_test/config/inline_test_config.ml","/home/fok/codes/o1-labs/mina/_opam/lib/time_now/time_now.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppx_inline_test/runtime-lib/runtime.ml","/home/fok/codes/o1-labs/mina/_opam/lib/typerep/typename.ml","/home/fok/codes/o1-labs/mina/_opam/lib/typerep/make_typename.ml","/home/fok/codes/o1-labs/mina/_opam/lib/typerep/variant_and_record_intf.ml","/home/fok/codes/o1-labs/mina/_opam/lib/typerep/typerep_obj.ml","/home/fok/codes/o1-labs/mina/_opam/lib/typerep/type_abstract.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppx_expect/common/file.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppx_expect/collector/expect_test_collector.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppx_expect/config_types/expect_test_config_types_intf.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppx_expect/config_types/expect_test_config_types.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppx_expect/config/expect_test_config.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base_quickcheck/generator.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base_quickcheck/bigarray_helpers.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base_quickcheck/observer0.ml","/workspace_root/src/lib/pickles/opt_sponge.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base_quickcheck/shrinker.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base_quickcheck/test.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base_quickcheck/observer.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/base_for_tests/test_blit.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/base_for_tests/test_binary_searchable.ml","/home/fok/codes/o1-labs/mina/_opam/lib/parsexp/parsexp.ml","/home/fok/codes/o1-labs/mina/_opam/lib/parsexp/automaton_stack.ml","/home/fok/codes/o1-labs/mina/_opam/lib/parsexp/of_sexp_error.ml","/home/fok/codes/o1-labs/mina/_opam/lib/parsexp/parse_error.ml","/home/fok/codes/o1-labs/mina/_opam/lib/parsexp/parser_automaton_internal.ml","/home/fok/codes/o1-labs/mina/_opam/lib/parsexp/parser_automaton.ml","/home/fok/codes/o1-labs/mina/_opam/lib/parsexp/kind.ml","/home/fok/codes/o1-labs/mina/_opam/lib/parsexp/automaton_helpers.ml","/home/fok/codes/o1-labs/mina/_opam/lib/parsexp/parser.ml","/home/fok/codes/o1-labs/mina/_opam/lib/parsexp/conv.ml","/home/fok/codes/o1-labs/mina/_opam/lib/sexplib/pre_sexp.ml","/home/fok/codes/o1-labs/mina/_opam/lib/parsexp/old_parser_cont_state.ml","/home/fok/codes/o1-labs/mina/_opam/lib/sexplib/conv.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/import.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/sexpable.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/binable_intf.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/binable0.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/printf.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/comparator.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/result.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/container.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/deprecate_pipe_bang.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/fn.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/ordered_collection_common.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/sequence.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/array.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/source_code_position0.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/info.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/error.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/t.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/list0.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/hashtbl.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/hash_set.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/or_error.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/map.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/set.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/comparable.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/doubly_linked_intf.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/list.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/option.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/union_find.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/doubly_linked.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/bag.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/sexp.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/hash_queue.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/hashable.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/identifiable.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/bool.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/hexdump_intf.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/hexdump.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/string.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/bytes.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/char.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/core_pervasives.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/sign.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/float.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/int.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/int32.ml","/workspace_root/src/lib/unsigned_extended/unsigned_extended.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/int64.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/int63.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/unit.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/interfaces.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/lazy.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/nativeint.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/nothing.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/ordering.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/ref.ml","/workspace_root/src/lib/transaction_logic/zkapp_command_logic.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/byte_units0.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/bigstring.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/core_bin_prot.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/md5.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/zone_intf.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/binable.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/zone.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/source_code_position.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/validated.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/type_equal.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/univ_map_intf.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/unit_of_time.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/unique_id.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/uniform_array.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/day_of_week.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/ofday_helpers.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/stable_internal.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/float_with_finite_only_serialization.ml","/workspace_root/src/lib/timeout_lib/timeout_lib.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/time_intf.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/time.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/time_float0.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/time_float.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/time_ns.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/time_ns_alternate_sexp.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/set_once.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/heap_block.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/queue.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/option_array.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/memo.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/deque.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/debug.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/bag_intf.ml","/home/fok/codes/o1-labs/mina/_opam/lib/integers/unsigned.ml","/home/fok/codes/o1-labs/mina/_opam/lib/biniou/bi_util.ml","/home/fok/codes/o1-labs/mina/_opam/lib/biniou/bi_outbuf.ml","/home/fok/codes/o1-labs/mina/_opam/lib/biniou/bi_share.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppx_deriving_yojson/runtime/ppx_deriving_yojson_runtime.ml","/workspace_root/src/lib/crypto/kimchi_bindings/stubs/pasta_bindings.ml","/workspace_root/src/lib/snarky/tuple_lib/double.ml","/workspace_root/src/lib/snarky/tuple_lib/intf.ml","/workspace_root/src/lib/snarky/tuple_lib/four.ml","/workspace_root/src/lib/snarky/tuple_lib/quadruple.ml","/workspace_root/src/lib/snarky/tuple_lib/triple.ml","/workspace_root/src/lib/snarky/tuple_lib/tuple_lib.ml","/workspace_root/src/lib/snark_bits/bits.ml","/workspace_root/src/lib/snarky/interval_union/interval_union.ml","/workspace_root/src/lib/snarky/snarkette/nat.ml","/workspace_root/src/lib/snarky/src/base/handle.ml","/workspace_root/src/lib/snarky/src/base/monad_let.ml","/workspace_root/src/lib/snarky/src/base/request.ml","/workspace_root/src/lib/snarky/src/base/checked.ml","/workspace_root/src/lib/snarky/src/base/types.ml","/workspace_root/src/lib/snarky/src/base/as_prover0.ml","/workspace_root/src/lib/snarky/src/base/run_state.ml","/workspace_root/src/lib/snarky/src/base/checked_intf.ml","/workspace_root/src/lib/snarky/src/base/as_prover_ref.ml","/workspace_root/src/lib/snarky/src/base/boolean.ml","/workspace_root/src/lib/snarky/src/base/runners.ml","/workspace_root/src/lib/snarky/src/base/typ.ml","/workspace_root/src/lib/snarky/src/base/monad_sequence.ml","/workspace_root/src/lib/snarky/src/base/enumerable.ml","/workspace_root/src/lib/snarky/src/base/number.ml","/workspace_root/src/lib/snarky/src/base/snark.ml","/workspace_root/src/lib/ppx_version/runtime/shapes.ml","/home/fok/codes/o1-labs/mina/_opam/lib/angstrom/input.ml","/home/fok/codes/o1-labs/mina/_opam/lib/angstrom/parser.ml","/home/fok/codes/o1-labs/mina/_opam/lib/angstrom/angstrom.ml","/workspace_root/src/lib/logproc_lib/interpolator.ml","/workspace_root/src/lib/structured_log_events/structured_log_events.ml","/workspace_root/src/lib/pickles_types/nat.ml","/workspace_root/src/lib/pickles_types/hlist0.ml","/workspace_root/src/lib/mina_base/zkapp_state.ml","/workspace_root/src/lib/crypto/kimchi_backend/pasta/basic/kimchi_pasta_basic.ml","/workspace_root/src/lib/pickles_types/hlist.ml","/workspace_root/src/lib/pickles_types/or_infinity.ml","/workspace_root/src/lib/pickles/plonk_checks/plonk_checks.ml","/workspace_root/src/lib/pickles_types/at_most.ml","/workspace_root/src/lib/crypto/kimchi_bindings/stubs/kimchi_bindings.ml","/workspace_root/src/lib/snarky/sponge/params.ml","/workspace_root/src/lib/snarky/sponge/constants.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/tuple_pool/tuple_type_intf.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/tuple_pool/tuple_type.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/pairing_heap/pairing_heap.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/sexp_hidden_in_test/sexp_hidden_in_test.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/thread_safe_queue/thread_safe_queue.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/time_ns.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/monitor0.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/debug.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/import.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/priority.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/types.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/execution_context.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/job_queue.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/tracing.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/external_job.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/job_pool.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/job_or_event.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/scheduler0.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/synchronous_time_source0.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/scheduler1.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/scheduler.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/ivar0.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/deferred0.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/ivar.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/monad_sequence.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/deferred1.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/deferred_std.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/ivar_filler.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/tail.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/async_stream.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/synchronous_time_source.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/bvar.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/time_source.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/stack_or_counter.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/throttle.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/async_kernel_scheduler.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/clock_ns.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/deferred_list.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/deferred_result.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/deferred_or_error.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/deferred_queue.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/deferred.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/async_gc.ml","/home/fok/codes/o1-labs/mina/_opam/lib/digestif/ocaml/digestif_bi.ml","/home/fok/codes/o1-labs/mina/_opam/lib/digestif/ocaml/digestif_by.ml","/home/fok/codes/o1-labs/mina/_opam/lib/digestif/ocaml/xor.ml","/home/fok/codes/o1-labs/mina/_opam/lib/digestif/ocaml/digestif_conv.ml","/home/fok/codes/o1-labs/mina/_opam/lib/digestif/ocaml/baijiu_md5.ml","/home/fok/codes/o1-labs/mina/_opam/lib/digestif/ocaml/baijiu_rmd160.ml","/home/fok/codes/o1-labs/mina/_opam/lib/digestif/ocaml/baijiu_sha1.ml","/home/fok/codes/o1-labs/mina/_opam/lib/digestif/ocaml/baijiu_sha256.ml","/home/fok/codes/o1-labs/mina/_opam/lib/digestif/ocaml/baijiu_sha224.ml","/home/fok/codes/o1-labs/mina/_opam/lib/digestif/ocaml/baijiu_sha3.ml","/home/fok/codes/o1-labs/mina/_opam/lib/digestif/ocaml/baijiu_sha3_512.ml","/home/fok/codes/o1-labs/mina/_opam/lib/digestif/ocaml/baijiu_sha512.ml","/home/fok/codes/o1-labs/mina/_opam/lib/digestif/ocaml/baijiu_sha384.ml","/home/fok/codes/o1-labs/mina/_opam/lib/digestif/ocaml/baijiu_sha3_224.ml","/home/fok/codes/o1-labs/mina/_opam/lib/digestif/ocaml/baijiu_sha3_256.ml","/home/fok/codes/o1-labs/mina/_opam/lib/digestif/ocaml/baijiu_sha3_384.ml","/home/fok/codes/o1-labs/mina/_opam/lib/digestif/ocaml/baijiu_whirlpool.ml","/home/fok/codes/o1-labs/mina/_opam/lib/digestif/ocaml/digestif_eq.ml","/home/fok/codes/o1-labs/mina/_opam/lib/eqaf/eqaf.ml","/workspace_root/src/lib/key_cache/key_cache.ml","/workspace_root/src/lib/allocation_functor/make.ml","/workspace_root/src/lib/promise/js/promise.ml","/workspace_root/src/lib/internal_tracing/context_logger/internal_tracing_context_logger.ml","/workspace_root/src/lib/crypto/kimchi_backend/common/poly_comm.ml","/workspace_root/src/lib/crypto/kimchi_backend/common/plonk_dlog_oracles.ml","/workspace_root/src/lib/crypto/kimchi_backend/common/constants.ml","/workspace_root/src/lib/crypto/kimchi_backend/common/dlog_plonk_based_keypair.ml","/workspace_root/src/lib/crypto/kimchi_backend/common/kimchi_backend_common.ml","/workspace_root/src/lib/crypto/kimchi_backend/pasta/constraint_system/caml/vesta_constraint_system.ml","/workspace_root/src/lib/crypto/kimchi_backend/pasta/constraint_system/caml/pallas_constraint_system.ml","/workspace_root/src/lib/crypto/kimchi_backend/pasta/kimchi_pasta.ml","/workspace_root/src/lib/mina_wire_types/block_time.ml","/workspace_root/src/lib/mina_wire_types/currency.ml","/workspace_root/src/lib/mina_wire_types/pickles/pickles_composition_types.ml","/workspace_root/src/lib/mina_wire_types/pickles/pickles.ml","/workspace_root/src/lib/mina_wire_types/mina_base/mina_base_account_id.ml","/workspace_root/src/lib/mina_wire_types/mina_numbers.ml","/workspace_root/src/lib/mina_wire_types/mina_base/mina_base_call_stack_digest.ml","/workspace_root/src/lib/mina_wire_types/mina_base/mina_base_coinbase_fee_transfer.ml","/workspace_root/src/lib/mina_wire_types/mina_base/mina_base_coinbase.ml","/workspace_root/src/lib/mina_wire_types/mina_base/mina_base_fee_transfer.ml","/workspace_root/src/lib/mina_wire_types/mina_base/mina_base_pending_coinbase.ml","/workspace_root/src/lib/mina_wire_types/mina_base/mina_base_signed_command_memo.ml","/workspace_root/src/lib/mina_wire_types/mina_base/mina_base_signed_command.ml","/workspace_root/src/lib/mina_wire_types/mina_base/mina_base_sok_message.ml","/workspace_root/src/lib/mina_wire_types/mina_base/mina_base_stack_frame.ml","/workspace_root/src/lib/mina_wire_types/mina_base/mina_base_staged_ledger_hash.ml","/workspace_root/src/lib/mina_wire_types/mina_base/mina_base_zkapp_command.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/ast/ast_helper_lite.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/uchar.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/stdlib0.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/location.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/code_matcher.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/migrate_414_413.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/migrate_413_414.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/migrate_413_412.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/migrate_412_413.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/migrate_412_411.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/migrate_411_412.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/migrate_411_410.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/migrate_410_411.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/migrate_410_409.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/migrate_409_410.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/migrate_409_408.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/migrate_408_409.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/migrate_408_407.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/migrate_407_408.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/migrate_407_406.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/migrate_406_407.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/migrate_406_405.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/migrate_405_406.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/migrate_405_404.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/migrate_404_405.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/migrate_404_403.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/migrate_403_404.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/migrate_402_403.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/ast/import.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/ast/ast.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppx_derivers/ppx_derivers.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/traverse_builtins/ppxlib_traverse_builtins.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/longident.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/code_path.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/location.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/ast/location_error.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/expansion_context.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/ast_traverse.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/spellcheck.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/ast_pattern0.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/ast_builder_generated.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/ast_builder.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/caller_id.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/common.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/ast_pattern_generated.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/ast_pattern.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/extension.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/context_free.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/driver.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/merlin_helpers.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/ignore_unused_warning.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base_quickcheck/ppx_quickcheck/expander/clause_syntax.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base_quickcheck/ppx_quickcheck/expander/field_syntax.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base_quickcheck/ppx_quickcheck/expander/ppx_shrinker_expander.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base_quickcheck/ppx_quickcheck/expander/ppx_generator_expander.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base_quickcheck/ppx_quickcheck/expander/ppx_observer_expander.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base_quickcheck/ppx_quickcheck/expander/ppx_quickcheck_expander.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base_quickcheck/ppx_quickcheck/ppx_quickcheck.ml","/workspace_root/src/lib/crypto/kimchi_backend/kimchi_backend.ml","/workspace_root/src/lib/pickles/backend/backend.ml","/workspace_root/src/lib/snarky/group_map/bw19.ml","/workspace_root/src/lib/cache_dir/fake/cache_dir.ml","/workspace_root/src/lib/snarky/group_map/group_map.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base64/base64.ml","/workspace_root/src/lib/snarky_group_map/checked_map.ml","/workspace_root/src/lib/snarky_group_map/snarky_group_map.ml","/workspace_root/src/lib/pickles/one_hot_vector/one_hot_vector.ml","/workspace_root/src/lib/pickles_base/domains.ml","/workspace_root/src/lib/pickles/limb_vector/make.ml","/workspace_root/src/lib/pickles/limb_vector/challenge.ml","/workspace_root/src/lib/pickles/composition_types/digest.ml","/workspace_root/src/lib/pickles/composition_types/spec.ml","/workspace_root/src/lib/pickles/pseudo/pseudo.ml","/workspace_root/src/lib/base58_check/version_bytes.ml","/workspace_root/src/lib/codable/codable.ml","/workspace_root/src/lib/snarky_log/snarky_log.ml","/workspace_root/src/lib/pickles/import.ml","/workspace_root/src/lib/pickles/util.ml","/workspace_root/src/lib/pickles/endo.ml","/workspace_root/src/lib/pickles/common.ml","/workspace_root/src/lib/snarkyjs/src/bindings/ocaml/lib/snarky_bindings.ml","/workspace_root/src/lib/pickles/make_sponge.ml","/workspace_root/src/lib/pickles/tick_field_sponge.ml","/workspace_root/src/lib/pickles/dummy.ml","/workspace_root/src/lib/pickles/wrap_main.ml","/workspace_root/src/lib/pickles/commitment_lengths.ml","/workspace_root/src/lib/pickles/evaluation_lengths.ml","/workspace_root/src/lib/pickles/ro.ml","/workspace_root/src/lib/pickles/compile.ml","/workspace_root/src/lib/pickles/sponge_inputs.ml","/workspace_root/src/lib/pickles/tock_field_sponge.ml","/workspace_root/src/lib/pickles/wrap_hack.ml","/workspace_root/src/lib/pickles/wrap_proof.ml","/workspace_root/src/lib/pickles/tag.ml","/workspace_root/src/lib/pickles/inductive_rule.ml","/workspace_root/src/lib/pickles/types_map.ml","/workspace_root/src/lib/pickles/per_proof_witness.ml","/workspace_root/src/lib/pickles/unfinalized.ml","/workspace_root/src/lib/pickles/requests.ml","/workspace_root/src/lib/pickles/timer.ml","/workspace_root/src/lib/pickles/fix_domains.ml","/workspace_root/src/lib/pickles/verification_key.ml","/workspace_root/src/lib/pickles/wrap_domains.ml","/workspace_root/src/lib/pickles/wrap.ml","/workspace_root/src/lib/pickles/wrap_deferred_values.ml","/workspace_root/src/lib/pickles/verify.ml","/workspace_root/src/lib/pickles/step_main.ml","/workspace_root/src/lib/pickles/step_branch_data.ml","/workspace_root/src/lib/pickles/step.ml","/workspace_root/src/lib/pickles/dirty.ml","/workspace_root/src/lib/pickles/cache_handle.ml","/workspace_root/src/lib/crypto_params/group_map_params.ml","/workspace_root/src/lib/crypto_params/crypto_params.ml","/workspace_root/src/lib/bignum_bigint/bignum_bigint.ml","/workspace_root/src/lib/snarky_field_extensions/field_extensions.ml","/workspace_root/src/lib/snarky_curves/snarky_curves.ml","/workspace_root/src/lib/mina_stdlib/list.ml","/workspace_root/src/lib/mina_stdlib/result.ml","/workspace_root/src/lib/snark_bits/bits_intf.ml","/workspace_root/src/lib/snark_params/snark_util.ml","/workspace_root/src/lib/snark_params/snark_intf.ml","/workspace_root/src/lib/data_hash_lib/data_hash.ml","/workspace_root/src/lib/crypto/kimchi_bindings/pasta_fp_poseidon/kimchi_pasta_fp_poseidon.ml","/workspace_root/src/lib/hash_prefixes/hash_prefixes.ml","/workspace_root/src/lib/hash_prefix_states/hash_prefix_states.ml","/workspace_root/src/lib/test_util/test_util.ml","/workspace_root/src/lib/non_zero_curve_point/compressed_poly.ml","/workspace_root/src/lib/snarkyjs/src/bindings/ocaml/lib/local_ledger.ml","/workspace_root/src/lib/signature_lib/public_key.ml","/workspace_root/src/lib/sparse_ledger_lib/inputs.ml","/workspace_root/src/lib/dummy_values/dummy_values.ml","/workspace_root/src/lib/mina_base/proof.ml","/workspace_root/src/lib/unsigned_extended/intf.ml","/workspace_root/src/lib/mina_numbers/nat.ml","/workspace_root/src/lib/mina_numbers/intf.ml","/workspace_root/src/lib/mina_numbers/zkapp_version.ml","/workspace_root/src/lib/mina_numbers/account_nonce.ml","/workspace_root/src/lib/mina_numbers/global_slot_intf.ml","/workspace_root/src/lib/mina_numbers/global_slot_legacy.ml","/workspace_root/src/lib/mina_numbers/global_slot.ml","/workspace_root/src/lib/mina_numbers/hd_index.ml","/workspace_root/src/lib/mina_numbers/index.ml","/workspace_root/src/lib/mina_numbers/length.ml","/workspace_root/src/lib/mina_numbers/mina_numbers.ml","/workspace_root/src/lib/currency/intf.ml","/home/fok/codes/o1-labs/mina/_opam/lib/re/core.ml","/home/fok/codes/o1-labs/mina/_opam/lib/graphql_parser/graphql_parser.ml","/workspace_root/src/lib/fields_derivers_zkapps/fields_derivers_js.ml","/workspace_root/src/lib/data_hash_lib/data_hash_intf.ml","/workspace_root/src/lib/block_time/intf.ml","/workspace_root/src/lib/quickcheck_lib/quickcheck_lib.ml","/workspace_root/src/lib/mina_base/util/mina_base_util.ml","/workspace_root/src/lib/mina_base/account_id_intf.ml","/workspace_root/src/lib/mina_base/hash_prefix.ml","/workspace_root/src/lib/mina_base/data_hash.ml","/workspace_root/src/lib/mina_base/token_id.ml","/workspace_root/src/lib/mina_base/fee_excess.ml","/workspace_root/src/lib/mina_base/ledger_hash_intf0.ml","/workspace_root/src/lib/mina_base/frozen_ledger_hash0.ml","/workspace_root/src/lib/mina_base/signed_command_memo_intf.ml","/workspace_root/src/lib/mina_base/transaction_union_payload.ml","/workspace_root/src/lib/mina_base/signed_command_intf.ml","/workspace_root/src/lib/mina_base/side_loaded_verification_key.ml","/workspace_root/src/lib/mina_base/state_hash.ml","/workspace_root/src/lib/mina_base/verification_key_wire.ml","/workspace_root/src/lib/mina_base/ledger_hash.ml","/workspace_root/src/lib/mina_base/ledger_hash_intf.ml","/workspace_root/src/lib/mina_base/frozen_ledger_hash.ml","/workspace_root/src/lib/mina_base/digest_intf.ml","/workspace_root/src/lib/mina_base/zkapp_statement.ml","/workspace_root/src/lib/mina_base/prover_value.ml","/workspace_root/src/lib/mina_base/zkapp_call_forest.ml","/workspace_root/src/lib/mina_base/fee_transfer_intf.ml","/workspace_root/src/lib/mina_base/coinbase_fee_transfer_intf.ml","/workspace_root/src/lib/mina_base/coinbase_intf.ml","/workspace_root/src/lib/mina_base/pending_coinbase_intf.ml","/workspace_root/src/lib/run_in_thread/fake/run_in_thread.ml","/workspace_root/src/lib/mina_base/staged_ledger_hash_intf.ml","/workspace_root/src/lib/mina_base/stack_frame.ml","/workspace_root/src/lib/mina_base/sparse_ledger_base.ml","/workspace_root/src/lib/mina_base/sok_message_intf.ml","/workspace_root/src/lib/mina_base/pending_coinbase_witness.ml","/workspace_root/src/lib/mina_base/call_stack_digest_intf.ml","/workspace_root/src/lib/mina_base/call_stack_digest.ml","/workspace_root/src/lib/mina_base/ledger_intf.ml","/workspace_root/src/lib/mina_base/mina_base.ml","/home/fok/codes/o1-labs/mina/_opam/lib/js_of_ocaml-compiler/runtime/jsoo_runtime.ml","/home/fok/codes/o1-labs/mina/_opam/lib/js_of_ocaml/js.ml","/workspace_root/src/lib/snarkyjs/src/bindings/ocaml/lib/util.ml","/workspace_root/src/lib/snarkyjs/src/bindings/ocaml/lib/snarky_js_bindings_lib.ml","/workspace_root/src/lib/snarkyjs/src/bindings/ocaml/snarky_js_node.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/std_exit.ml"],"mappings":"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KCg4BPC;KACAC;;KC/WgBC;;;;;;;;;;;;;;KA0GVC;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA+HAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAGAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAoUgCC;;;;;;;;;;;;;;;;;;;;;;;;KAtjC5BC;KA9CZC;;KAIAC;;;;;;;;;;;;;KA+HAC;KCsyBEC;KACAC;KCGAC;KACAC;KCfAC;KACAC;KCDAC;KACAC;KCFAC;KACAC;KCUAC;KACAC;KCxFAC;KACAC;KCCAC;KACAC;KCpBAC;KACAC;KCHAC;KACAC;KCJAC;KACAC;KCrCAC;KACAC;KCmIIC;KA39BAC;;;;KCqYJC;KAOAC;KAOAC;KAOAC;KAOAC;KAOAC;KAOAC;KAOAC;KAOAC;KAOAC;;KAcAC;KAOAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KC/NEC;KAhJAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAuKWC;KC1KXC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KC2I8BC;KAAN5oC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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BtL1GEioB;qB4U6LIQ;kBTvXK;mBSmUqB;;;;;;;;uB/T9I1BvoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBbiBJ7H;uB4U+LIqwB;mBAlE0B;;;;uBhWvSbj3B;;;uB6MiDjBxN;uBAaAM;uB7MjCE1O;uBA7Be2b;uBwMyaf3jB;uBEjYI2mB;uB1MxCW9C;uB6MHjBxwD;uB7MGiBqwC;;;;;;uBwM6ZfI;uBADAD;uBxM5ZeG;;;;;;;;uB0MwCX6gB;;;;uBACAG;;;;;;;;;uB1MzCWS;;uB0M8CnBiB;uB1M9CmBtuF;uBCoDHC;uBDpDGC;;;;;;;uB0MqFnBwuF;uBACAD;uB1MtFmBhB;;uB0M2FnBkB;uB1M3FmB5C;;;;;;uB0MiHX6C;;;;;uB1MjHW7zD;;;;;;;;uBUtBjBinD;uBVsBiB4J;;;;uB6MkGjBjN;uBAaAI;uB7M/GiBgP;;uB6MyJjB7O;uB7MzJiBG;;;uBE6LJpzH;uBAAHF;uBF7LO2/H;;;;;;;;;;uBoB0HjBi2B;uB4U6PIe;mBAhF0B;;;;qBtJrQhCr7B;qBAIQ0B;;qBGkCNxK;qBAgBAG;;qBpLeF0I;qB+K0ZIvf;;qBEzdIyf;qBG1CNjsD;qBH0CM6wC;;;;;;qBF6cJI;qBADAD;qBE5cIG;;;;;;;;qBmF+KE+a;;;;qBACAG;;;;;;;;;qBnF9KFS;;;;qBoBAQjtD;;qBpBWhByuD;qBACAD;qBACAD;qBAGAM;qBAKAnB;;qBAsBAqB;qBACAD;qBACAR;qBACAb;qBAGAuB;qBA2CAxB;qBAEAD;qBACAD;;qBAWAD;qBAGAD;qBAtCQ6B;;;;;;;;qBAeRL;qBAMApB;qBAEAD;qBACAD;;qBAIAtG;qBAOAqG;qBAGAD;qBAIAuB;qBACAD;qBGhCE5K;qBAkBAC;qB7M9IiBI;qB6MyJjBH;;;qBHkBF4J;qBAmDAV;qBGpOEhtD;qBADAD;qBHkPFktD;;qBAIAW;qBAIAC;qBAGAG;qBAGAD;qBAGAD;qBAMAuB;qBAMAD;;qBtLpGEy3B;qB4UiOIU;kBTjaK;mBS0aa;mBACA;mBAGxB;;mBAG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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAwBAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAIAC;;;;;;;;;;qBAJAD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAWAE;;;;;;;;;;qBAXAF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAkBAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAIAC;;;;;;;;;;qBAJAD;;;;;;;qBAIAC;;;;;;qBAJAD;;;;;;;;;;;;;;;;;;;;;;;;;;qBAIAC;;;;;;qBAJAD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAWAE;;;;;;;;;;qBAXAF;;;;;;;qBAWAE;;;;;;qBAXAF;;;;;;;;;;;;;;;;;;;;;;;;;;qBAWAE;;;;;;qBAXAF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAkBAG;;;;;;;;;qBAO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C2C1bgF;;wBhFkhE7D;iCqCxlDnBA,WrCwlDmB,+BqCxlDnBA,Y2CzbsE;;wBhFuhEtE;iCqC9lDAA,WrC8lDA,sBqC9lDAA,e2Cxb0E;;wBhF4hE1E;iCqCpmDAA;iCrComDA,uCqCpmDAA,e2CrbwD;;wBhF+hExD;iCqC1mDAA;iCrC0mDA,oCqC1mDAA,e2ClbkF;;wBACjE,kB3CibjBA,iB2Cjb4D;;wBhFm9D9D,qBACE,gBqCniDAA,gBrCmiDyB;wBADhB;0EqCliDTA,kB2Chb8E;;wBhFu9D3D;iCqCviDnBA,WrCuiDmB,8BqCviDnBA,Y2C/aoE;;wBAC3C,sB3C8azBA,mB2C9a4E;;wBhF29D5E;iCqC7iDAA,WrC6iDA,qBqC7iDAA,e2C7awE;;wBhFg+DxE;iCqCnjDAA;iCrCmjDA,sCqCnjDAA,e2C1auD;;wBhFm+DvD;iCqCzjDAA;iCrCyjDA,mCqCzjDAA,e2CvagF;;wBAC9D,kB3CsalBA,iB2Cta8D;;wBhFohE3C;iCqC9mDnBA;iCrC8mDmB,4CqC9mDnBA,Y2CnaoE;qDAG5C,wBAAsC;oD3C+ZtDivC,QAAQC;wBAEpB;;oDADIlvC,WADQivC,QAAQC;;uD,OpCk3DhBp8B,UoCj3DA9S,mB2C7Z2D;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA8J3D;;;;;kBpDzZO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBoDqec,mCAAyB;;wBhFq1CV,0CgFl1C4B;;;0BASnC,oDAAsC;;;;0BhF21CrE,egFt1CE;0BhF0rBF;4BAG6C;qFAA8B;0BADnE;;8C9IlqCJzI,oB8IkqCyB;yCgF5rB8C;;;wBAlD3E;;;;;;;;;;;;;;;iD,6BAA2C;wBAA3C;;;;;qFAA2C;wBAA3C;;;;;iEAA2C;wBAA3C;;;;;;0BAUgB;wDAA8B,iCAAa,EAAC;;0BAG1D,kBAAoC,yBAAO;0BAnFrC;0BACP,qBACE;0BAFK;;4BAKF;yD;0BAAA,sBACO;0BACY,qBA4EgD;;;;;;;;;;;;;;wBhFwrDrE,8CgFr4DkD;6CAErC,WAAI;;wBACL,uB,mBAAuB;;wBhFqlDrC,sDgFplDqE;;wB;uChFwlDvE,2CgFvlDmD;;wBhF0nDnD,8CgFvnDoD;;wBhF6nDlD;yFgF1nDmE;;wBhF8nD/D;;;wBACqB,QgF9nDgB;;wB;;iChFmoD3C;yCgFloD6D;;wBhFqoDrB,kDgFpoDW;;wBhFuoD/C,4CgFtoDmD;;wBhF0oDnD;mCgFzoDmE;;wBhF6oDnE,0DgF5oD2D;;wBhFglDzD;;;wBACqB,QgFhlDU;;wB;uChFqlDrC,mDgFplDuD;;wBACpC,mCAA0B;;wBAxLrC,sCAyL+D;;wBhFwlDnE,yCgFvlD6C;;wBhF2lD7C,0DgF1lD6D;;wBhF8lD7D,uDgF7lDqD;;wBhFimDnD;;;wBAEqB,QgFlmDoB;0CAEjC,QAAC;6ChFwoDf,oCgFvoDyC;2ChF0oD1B,oBgFzoDU;yChF0oDZ,mBgFzoDQ;;wBACA,mCAA4B;;wBAC5B,mCAA4B;;wBACxB,uCAAgC;;wBhF6pDzD,+CgF5pD6D;;wBhFiqD7D,2CgFhqDiD;;wBhFoqDjD,oCgFnqD6C;6CAC3B,iCAAyB;;wBhF0qD3C;;;;gDAA8C,6BAAQ,EgFzqDX;;wBhF6qD3C,kDgF5qDyC;yChForDzC,gCgFnrDiC;2CAClB,+BAAsB;wChFyrDX,+BgFxrDK;4ChF+rD/B,mCgF1rDyC;;wBhFmsDzC,wCgF9rDqD;;wBhFksDjD,wCgFjsD6C;2ChFqsD7C,qCgFpsDmC;;wBhFwsDnC,oCgFvsDqC;;wBhF2sDrC,yCgF1sD2C;;wBhF8sD3C,wCgF7sD6C;;wBhFktD/C;;;;;sCgFjtDqD;;wBhFwtDrD;;;;;sCgFvtDmD;;wBhF8tDnD;;;;;sCgF7tDmD;;wBhFouDnD;;;;;sCgFnuDiD;;wBhF2uDjD;;;yCgF1uD+C;;wBhFivDjD,sCgFhvDyD;4ChFovDzD,oCgFnvDuC;;wBhF6vDvC,qDgFvvD6E;;wBhF2vD7E;qEgFxvDwD;;wBhFkwDpD,sCgF/vDqC;0ChF4wDf,iCgFjwDS;;wBhFowDnC,oDgFnwD6E;;wBhFwwD3E;;;kCgFrwD8C;;wBhF+wDhD,2DgF3wDqD;;wBhFqxDrD,8CgFlxDqE;;wBhFsxDrE,uCgFrxDmD;;wBACzC,uB,O/EopENsb,0B+EppEuB;;wBACb;0BhFuxD+B,8CgFvxDV;2ChF0xDnC,8BgFzxDiC;;;wBhFmyDjC;;;;;mCgFhyDiF;;wBhFwyDhC,uCgFryD4B;;wBhFwyD7E,kDgFryDqD;;wBA1QC,kDA6QM;;wBAxT5D,gDAyToE;wDAlT3C,oBAmT8B;;wBAhTvD,kDAiTmE;;wBhF6wD7B,uCgF7nDuC;;;0BAQ5C,qCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BzF7bnEP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kByF0lBH;;kB9XrqBGuV;kBI4HFwV;kBsUrIS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBtUoITD;kBJ5HExV;kB+XVN;;kBrDEa;mBqDFb;sCtC0F0B,uCsC5DgD;mBA9B1E;;sBxC2NE,gBAAY2lC;wBACO,IAAbvtD,WADMutD;wBAKH,sB,UAJHvtD;wBAEF;yBADEjqH;0BACF;4BACE,4BAHAiqH;;;0CACAjqH,EAFMw3K,MAQI,CwCnMwD;mBAhC1E,0BAkDmD,wBAAe;mBAlDlE;;sBAqD6B;sBtEFL;;;mDsEEwC,4BtEFmB,EsEEC;mBArDpF;;sBAyDI,0BACE,4BAAmB;sBADM;qEACL;mBA1D1B;;sB,I5CgqBMvtD;6C4Clfe,U5CkffA,gB4ClfuC;;wBACL,mC5CiflCA,iB4Cjf6E;;wBAG/E,wC5C8eEA,iB4C9ekD;;wBvF0rCpD,qBAEkB,U2C9sBhBA,gB3C8sBoC;wBADpC,gC2C7sBAA;wB3C6sBA,+CuFxrCyD;;4CvFqqCV,U2C1rB/CA,iB4CteqC;;wBvFmqCnB,U2C7rBlBA,W3C6rBkB,W2C7rBlBA,sB4CreuC;0CAC3B,iB5CoeZA,a4CpeiC;;wBAzDf,U5C6hBlBA,W4C7hBkB,Y5C6hBlBA,c4CneyC;;wBAtDvB,U5CyhBlBA,W4CzhBkB,gB5CyhBlBA,c4CleiD;;wBvFwrC9B,U2CttBnBA,W3CstBmB,a2CttBnBA,e4CjemC;;wBvF2rCrC,4B2C1tBEA,c4CheuD;;wBvF8rCpC,U2C9tBnBA,W3C8tBmB,c2C9tBnBA,e4C/d+B;;wBvFksCxB,U2CnuBPA,W3CmuBO,oB2CnuBPA,e4C9d6C;;wBAGvC,gC5C2dNA,2B4C3dwD;oD5C0dhD6rC;wBAEZ,oCADI7rC,WADQ6rC;;uD,UACR7rC,mB4Cvd+D;;;;;;;;;;;;;;;;;;;mBAzMrE;kBAmUM;kBrDjUO;;;;;;;;;;;;;;;;;;;;;;;8CqDyYS,4BAAoB;4CvFwxBV,gCuFvxB2B;;;0BAQlC,wCAA4B;;;;0BvFsyBjD,euFlyB0B;0BvFsab;;8CxI5yBTzI,oBwI4yB8B;yCuFtaiD;;0BAI/E;+CAAa,iBAAoC;;;wBAlDrD;;;;;;;;;0BAUgB,+BAAoB,wBAAK,EAAG;;0BAG1C,kBAAoC,yBAAO;0BA9ErC;0BACP,qBACE;0BAEH;4BAGQ;qCACE;qCACA,yBAA4B;0BAHpC,gCAAgB,2BAwEuD;;;;;;;;;;;;;4CAxKzD,YAA4B;+CvFggCiB,kCuF//Bf;yCvF8/BjC,kBuF7/Ba;2CvF+/BX,oBuF9/Be;6CvF+/Bf,kBuF9/Be;0CvF+/BhB,mBuF9/Bc;gDvF+/BV,qBuF9/BkB;0CvF+/BtB,mBuF9/Bc;gDvF+/BV,qBuF9/BkB;2CvF+/BvB,gBuF9/Ba;+CvF+/BT,oBuF9/BiB;0CACpB,mBAAc;2CvF+/Bb,oBuF9/Be;yCvF+/BhB,kBuF9/Bc;;wBvFihCiC,+CuFhhCf;2CvF8/B9B,oBuF7/BgB;4CvF8/Bf,qBuF7/BiB;0CvF8/BnB,mBuF7/Be;0CvF8/Bf,mBuF7/Be;yCvF8/BhB,kBuF7/Bc;6CvF8/BV,sBuF7/BkB;6CvF8/BlB,sBuF7/BkB;8CvF8/BhB,uBuF7/BoB;;wBvF8/Bd,uB,oCuF7/B0B;oDvF8/B1B,6BuF7/B0B;;wBACzB,iCAAsC;wCvF6/BZ,gCuF5/Bf;2CvF6/BqB,kCuF5/Bf;;wBvF6/BuB,sCuF5/Bf;;wBvF+/Bf,sCuF9/BmB;wCAC5C,4BAAwB;wCACxB,4BAAwB;2CACrB,+BAA2B;8CvFkgCiB,iCuFjgCf;8CvFkgCe,iCuFjgCf;6CvFkgCa,gCuFjgCf;;wBvFogCF,0CuFngCsB;;wBvFsgCX,sCuFrgCW;4CvFsgCH,mCuFrgCf;;wBvFsgCyB,oCuFrgCf;;wBvFwgChB,wCuFvgCoB;0CAC5C,8BAA0B;gDACtB,gCAA8B;;wBAC1B,oCAAkC;2CvFwgCC,kCuFvgCf;;wBvF0gCK,iDuFzgC6B;;wBvF6gC5E,4CuF1gCyD;;wBvF8gCpB,uCuF3gCmB;;wBvF8gC3B;4D,gBuF7gCiB;;wBvFghCN,0CuF/gCsB;;wBvFmhCzB,sCuFlhCmB;0CvFqhCD,iCuFphCf;wCvFqhC5B,iBuFphCY;;wBvFqhC6C,sCuFphCf;4CACxC,QAAC;0CACD,QAAC;;;wBvFwhCf;yFuFrhC4E;;wBvFwhC3B,uCuFrhCiC;;wBvFwhClF,kDuFrhC0D;;;wBvFyhC1D;;;;;;mCuFrhCqF;6C,iCAIzC;;wBvF6hC3B,oDuF1hC6C;;wBvFkiC7C;;;yBA5QX;wBADA;0EuFpxB8C;;;wBApQpD,gDAuQoE;wDAnQ/C,oBAoQkC;;wBAhQvD,kDAiQmE;gDA4I/C,8BAAoB;8CvF62BZ,6BuF52BkC;;;0BAS1D,2CAAoE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA+IzE;;kB/X9jBGswB;kBI4HFwV;kBsUrIS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBtUoITD;kBJ5HExV;kBgRVN;;kBAkEG;;kBhRvDGC;kBI4HFwV;kBADAD;kBJ5HExV;kBgYVN;;kBtDEa;mBsDFb;oC;mBAAA;;;;;;;;uBhH2MW/uE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBgH3MX;;;;;;;;;uBhH2MWA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBgH3MX;;;;;;;;;;;;;;uBhH2MWA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBgH3MX;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA4MG;;kBhYjMGgvE;kBI4HFwV;kBsUrIS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uB1DmCX7qC;uBAEAC;uBAGAoN;uBAMAC;uBAEAC;uBAEQC;uBACAC;;;;;;;uDADAD;;;;;;;;;;;;;8BAfRxN;8BAEAC;8BAGAoN;8BAMAC;8BAEAC;8BAEQC;8BACAC;;;;;;;;sB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kB5QiFNm9B;kBJ5HExV;kBiYgBN;;kBAsKG;;kBjYrLGC;kBI4HFwV;kBADAD;kBJ5HExV;kBkYVN;;kBxDEa,8BwDFb;kBzJ+HMh5B;;;;sB;wByJxFqB;;;;;;;kBxDrCd;mBwDqDT;;;;8C,gCAA0D;mBAA1D;0C;mBAAA;;sB,uCAA0D;mBAA1D;;sB;mBAAA;;sB,sCAA0D;kBAE3D;;kBlY9CGi5B;kBI4HFwV;kBADAD;kBJ5HExV;kBmYVN;;kBzDEa;mByDCb;;;;8C,gCAAkD;mBAAlD;0C;mBAAA;;sB,0CAAkD;mBAAlD;;sB9DoKE;mB8DpKF;;sB,OnEmYI0Q,iCmEnY8C;kBAAlD;kBAYI;;;kBA4BD;;kBnYhCGzQ;kBI4HFwV;kBADAD;kBJ5HExV;kBoYAN;;kB1DRa;mB0DQb,mBAoDW7yI,GAAI,gBAAJA,MAA2C;mBApDtD;6BAsEmB2iH;sBACjB,UADiBA;sBACjB;wBAEsB;;yBAfP3hH,EAeP4hH;yBAfU+1D;yBAAYC,MAYbj2D;yBAZoBk2D;wBACrC;oCADe73K;0BACf;4BAQE;;8CAT4B43K,MAAOC;6BAAnBF;6BAAYC,MAAf53K;;6BAAsB63K;;0BACrC,IACOx5K;0BAIL,OANmCw5K,qBAML73K,GAAK,OANnB23K,WAMmB,QAAoB;0BAAvD,UANa33K,EAER3B;sBAWP,IACOoxE;sBAAK,UAFKkyC,IAEVlyC,IACoE;mBAzE7E;6BA4ESzvE;sBACP,UADOA;sBACP,kBAIW,sBALJA;sBACP,IACO3B;sBAEL,OAFKA,CAGsB;mBAjF/B,eAqFQ2B,GAAI,YAAJA,KAAkB;mBArF1B;6BAyFUgqE,GAAGF;sBACE;4CADLE;uBACK;;uBACA,uBAFFF;uBAEE;;sBACV,GAFKhrE,OACAD,GAEH;sBAHQ,IAIR,GAJGC,MAIH,GAHGD;sBAMH,GAFC6qE,KACAC,IAEC,aAPH5f,MAOG;sBACA,aATHC;sBAAS;uBAWN,MAND0f,OACAC;uBAKC,aAXC7qE,QAWuB,sBAXvBA;kCAWoC;kBAgB3C;;kBpYpHGgzI;kBI4HFwV;kBADAD;kBJ5HExV;kBqYVN;;kB3DEa;mB2DFb;;6CA4DkB,yBAAwD;mBA5D1E;6BA6Da7nE,GAAQF;sBDoCuB,eCpCvBA,IDoCa,YCpCrBE,iBAAwC;mBA7DrD;6BAgEkDhqE;sBACtC,IAAJhD,EAAI,MADsCgD;sBAE3C,OADChD,KAC6B;sBAAmD,OADhFA,CACiF;mBAlEzF;6BAqEkCgD,GACtB,+BADsBA,GACtB,QAAkD;mBAtE9D;6BAyEsBV,EAAEU;sBACZ,IAAJhD,EAAI,+BADYgD;sBAER,6BADRhD,KADcsC;sBAEN,QAAY;mBA3E5B;6BAiFyBtC,GAA4B,6BAA5BA,QAA4B,QAAwB;mBAjF7E;6BAkFyBA,GAA4B,kBxMuNxCw0I,WwMvNYx0I,QAA4B,QAAwB;mBAlF7E;6BAoFuBgD,EAAErD,EAAEC,EAAE6C;sBACjB,IAAJzC,EAAI,MADWgD;sBAEnB,mBADIhD;sBACJ;wBACM,IAIJqB,EAJI,WAHmBoB,EAAJ9C,EAAEC;4BAIXw7B;;wBACV,mBAJEp7B;wBAIF,MADUo7B;sBAIV,mBAPEp7B;sBAOF,OADAqB,CAEC;mBA7FP;6BAgGuB2B,EAAErD,EAAEC,EAAEqD,EAAER;sBACnB,IAAJzC,EAAI,MADWgD;sBAEnB,mBADIhD;sBACJ;wBACM,IAIJqB,EAJI,WAHqBoB,EAAN9C,EAAEC,EAAEqD;4BAIbm4B;;wBACV,mBAJEp7B;wBAIF,MADUo7B;sBAIV,mBAPEp7B;sBAOF,OADAqB,CAEC;mBAzGP;6BA4GuB2B,EAAErD,EAAEC,EAAEqD,EAAEpH,EAAE4G;sBACrB,IAAJzC,EAAI,MADWgD;sBAEnB,mBADIhD;sBACJ;wBACM,IAIJqB,EAJI,WAHuBoB,EAAR9C,EAAEC,EAAEqD,EAAEpH;4BAIfu/B;;wBACV,mBAJEp7B;wBAIF,MADUo7B;sBAIV,mBAPEp7B;sBAOF,OADAqB,CAEC;mBArHP;6BAmKiBW,EAAE4e;sBACf,IAAQ5d,KACR,kBADQA,KADKhB,EACLgB,IADO4d,SAEf,OADQ5d,CACP;mBArKL,sBAwKmBA,GAAI,OAAJA,cAAkB;mBAxKrC,iBA2KYA,GAAI,OAAJA,IAAW;mBA3KvB;6BAiMoCrD,EAASC,EAASqD,EAASpH;sBAC3D,OAD2DA,EAC3D,OADgC8D,EAChC,OADyCC,EACzC,OADkDqD,EAClD,QAGW;mBArMf;6BAwMmC+pE,GAAGF;sBAClC;+BAD+BE,eAAGF,eAKb;mBA7MzB;6BAgNoCE,GAAGF;sBACnC;+BADgCE,eAAGF,eAKd;mBArNzB;6BAwN4CE,GAAGF;sBAC3C,4BADwCE;sBAEjC,uBAFiCA,MAAGF;sBAEpC,aACF,4BAHsCA,YAGM;mBA3NrD;6BAoO6BE,GAAGF;sBAC5B,+BADyBE,GAAGF;sBAC5B,qCADyBE,GAAGF,GAEO;mBAtOvC;6BAyOoB9pE,EAAEhB;sBAClB,cADgBgB;sBAEL,IAAPo5K,KAAO,WAFOp6K,EAAFgB;sBAGhB,8BAHgBA,EAEZo5K;sBACJ,OADIA,IAEA;mBAUa;;6BAwBRp5K;sBAAI,UAAJA,KAVT;sBACG,kBADCo5K;wBAIF;wBACA,mCALEA;wBAKF,UAnBAC;8BAwB6C;mBAxB9B,0BA+CU,YAAQ;mBA/ClB;6BAgMZr5K,EAAGP;sBACV,UADOO;sBACP;;yBAEOohG;;mCACmDA,MAAM3hG;4B,IAVxCs7J,IAUkC35D;4BAT1D;yCASgE3hG,EAVxCs7J;8BAEb,SAFaA,OAGjB,WADHn0F,SAQsDw6B;8BAPnD,cAHiB25D,IAEpBn0F;2CASuB;wBADD,wBADnBw6B,eAHG3hG;sBAEA,QAGkB;mBArMT;6BAwMVO;sBACT,UADSA;sBACT,UAEgB,IAATohG,eApYQ,aAoYRA;sBADG,QACsC;mBA3M7B;6BAmORphG,EAAG4hB,KAAMniB;sBAAI,SAxFFw2F,IAwF+Bx2F,EAAE+uC,IAAIusH,KAAa,kBAAnBt7J,EAAE+uC,IAAIusH,OAA4B;sBAvFvF,UAuFW/6J;sBAvFX;;yBAEOohG;;mCAEU3hG,EAAE9C,EAAE6xC,IAAI4yD;gCAAJ54C,UAAUuyG,IAAN35D;4BACnB;8BAAU,qBADC3hG,EAAE9C,EAAE6rD,MAAUuyG,KAEd,MAFcA;8BAGtB,GAHsB4e,UAANv4E,MAGW,OAHfj6B;8BACL,IADK3e,YAAUuyG;uCAKF;wBANH,wBADnB35D,SAHenL,IAwFFx2F,EAANmiB,KArFPw/E;sBADG,OAsFIx/E,IAA0E;mBAnOrE,sBJ5MX43J;mBI4MW,wBJ5MXC;mBI4MW,YAmObC,QACAE,QACAC;mBArOa;;;;;;;6BAmST75K;sBAAI,SA1BQP,EA0BsBhD,EAAE4mE,IAAM,UAAR5mE,EAAE4mE,GAAa;sBAzB3D,UAyBUrjE,KAAI;sBAzBd;;yBAEOohG;;mCAEU3hG,EAAE+uC,IADmD4yD;gCACnD54C,UAAIuyG,IAD+C35D;4BAEhE;8BAAW,UADM25D,OAEP,iBAFCt7J,EAAMk6K,SAAJnxH;8BAGV,GAHcmxH,UAD+Cv4E,MAIlC,OAHjBj6B;8BACF,IADE3e,YAAIuyG;uCAKF;wBANK,wBADnB35D,SAHe3hG,EAANmiB,KAGTw/E;sBADG,OAFMx/E,IA0B4C;mBAnSzC;6BAoSPo2F,UAAUh4G;sBAA6B,oBAAvCg4G,UAAuC,UAA7Bh4G,GAAwC;mBApS3C;oCAwZXA,GAA4B,kBjI/SVgsH,OiI+SlBhsH,KApeJ64K,QAoe6C;mBAxZ9B;6BAmeJ74K,EAAEhB;sBAhjBW,IAijBxBk7K,QAjjBwB,WAgjBXl7K,EAhjBW;sBAgjBbgB,UACXk6K;oCAEG;mBAteY;6BA+eJl6K,EAAEhB;sBACjB,UADegB;sBACf;wBAGE,mBAAc,sBADTohG,MAHUpiG;wBAID,UAAVk7K;wBAAU,OAAVA;sBAFI,oBAFKl6K,EAAEhB,EAMR;mBArfU;6BAigBJgB;sBACf,UADeA;sBACf;wBAGE,mBAAa,OADRohG;wBAEL,OAFKA;wBACL,UADKA,UACD8qB;wBAE0C;wBACzC,UAJA9qB;sBADG,QAKc;mBAxgBL;6BA2gBVphG,EAAE+6J;sBACX,UADS/6J;sBACT;wBAGE,IADKohG;wBACF,GAJM25D,QAGJ35D,OAEQ,WALNphG,GAKM;wBACL,YAHHohG,SAHI25D,QAOJ,cAPIA;wBAQJ;sBANG,iCAM8B;mBAnhBrB;;;6BA0rBH/6J,EAAE+6J;sBAClB,UADgB/6J;sBAChB;wBAEgB,qBAAO,WAHL+6J,QAGXwf;wBAAgB;0BA5BpB,GA4BIA,YAHWxf,IAzBW;0BAC1B,YA2BIwf,WAHWxf;4BAvBb,UAuBW/6J;4BAvBX;8BAID,IADKohG;8BACF,YADEA,SAoBS25D;gCAhBI,IAAZyf,UAgBQzf;gCAfZ,uBAeYA,IAhBRyf;gCAAY;iCAEZR;kCAND54E,UAoBS25D,KAAF/6J,UAhBNw6K,sBAJDp5E;gCAcH,uBASCm5E,QAHWxf;gCAhBI;iCAWb,MATCif,YAiBHO;iCARE,aAKOv6K,UAAE+6J;gCAJT;;4BAjBG;0BAkBP;wBAKK;uDACuE;mBA7rB9D;6BAmtBJ/6J,EAAE+6J;sBACjB,UADe/6J;sBACf;wBAGE;;yBAAW,KADNg6K;yBAEE,WALQjf,QAIX2f;wBACG;0BAvBN,GAsBGA,SAJW3f,IAlBY;0BAC1B,YAqBG2f,QAJW3f;4BAhBZ,UAgBU/6J;4BAhBV;8BAID,IADKohG;8BACF,YADEA,SAaQ25D;gCATK,IAAZyf,UASOzf;gCARX,uBAQWA,IATPyf;gCAED,GANAp5E,UAaQ25D,IAPiB,UAFxByf;gCAjuBR,+BA8uBIE,KAJW3f;gCA1uBf,oCA8uBI2f,KAJW3f;8BAJR;4BAVG;0BAWP;wBAKK;uDAGsD;kBAGjB;;kBrYv8B3CjpB;kBI4HFwV;kBADAD;kBJ5HExV;kBuYVN;;kB7DEa;mB6DFb;;;;mBAII;;;;;;;;;;;;;;4D;;;;mBAAA;mBAGkC;oC;mBAAA;;;;;;sB;wBAFhC;;sBACA;;kBACgC;;;sB,QrJ2KhC1wB;;gEqJ3KgC;kB7DLzB;mB6DKyB;;;kBA8BpC;;;;;;sC;;kBAoBA;;;;;;;;kBAkCF;kB7DzFa;mB6DyFb;;;;;;;;;;;;;;;;;;;;;;mC;kBAuBuD;;kBvYvGjD2wB;kBI4HFwV;kBADAD;kBJ5HExV;kBwYVN;;kB9DEa;mB8DFb;;sBAciB,SASP92H,IAAI/a,GAAI,OAAJA,IAAS;sBATN,SAUPyW,MAAMzW,GAAI,OAAJA,IAAW;sBAVV,SANbknH,UAgCcyzD,YAAYC,aAAa56K;wBACrC,UADqCA;+BPCzC+5K;;;oCOdiB36K;;oDAaDu7K,YAbCv7K;oDAaWw7K,aAbXnqH;;uCAc8C;sBA3BhD,SANboqH,UAoCc76K;wBAC2B,+BAD3BA;wBACL,GAAC,UADIA;0BAMyC;sDANzCA;2BAMkB,8BANlBA;2BAMD;;qCACwB86K;8BACjC,QADiCA,MAE3B,2BATI96K,KAQN+a;8BACE;gCAGQ,wBANZq+I,KAEEr+I;;gCAKF,4BAPAq+I,KAEEr+I;8BAEM,6BAGoB;0BAPrB,eANC/a;qDAaqB;sBA3CtB,SANb6tE,OAoDa17B,UAAoC45F;wBAC/C,GADW55F;yBAAiB,QAAjBA,sBAAiBi7B;;6BAAjB2tG;wBACX,SAD2C,mBAAPt5K,KAAOi2F,eAAPj2F;wBAGS;sCAHEsqI;yBAGrC,6BAHCgvC,mBAAyBt5K;wBAE1B,+BAET;sBAlDU,SAqDT8rE,KAAKvtE,EAAEP;wBACQ,6BADVO;wBACU;iCADRP;;mCAE2C,kB3MoO7C+xI,W2MtOAxxI,QAE6C,QAAiB,EAAC;sBAvD3D,SA0DTg7K,kBAAkBh7K;wBACjB,cADiBA,SACjB,aACE,oBAA2E;sBA5DrE,SANb21E,MAqEU31E;wBACR,kBADQA;wBHidA;oDGjdAA,KAGW;sBAlER,SANb1F,OA2EW0F,GAAI,4BAAJA,KAAwB;sBArEtB,SANb6vE,SA4Ea7vE,GAAI,cAAJA,YAAgB;sBAtEhB,SANbm8I,OA8EWn8I,EAAErB;wBACL,+BADGqB,KAAErB;wBACL,UAEQ,IAAPo8J,aAAY,UAAZA;wBADG,QAC8B;sBA3E7B,SANbkgB,WAoFej7K,EAAErB;wBAAI,OAAW,qBAAjBqB,KAAErB,QAAgD;sBA9EpD,SANb6mB,IAqFQxlB,EAAErB,GAAI,4BAANqB,KAAErB,EAAuB;sBA/EpB,SANb4pJ,QAwFYvoJ,GAAa,wBAAbA,MAxENyW,MAwEqE;sBAlF9D,SANbs4F,SAyFa/uG;wBAAc,6BAAdA,MAzEPyW,MAyEwE;sBAnFjE,SANb66D,QA2FYtxE,EAAGP;wBACb;iCADUO;;mCACQ,eAAsC86K,IAAM,kBADjDr7K,EAC2Cq7K,MAAgB;mCAAtD,uBADR96K,WAC+D,EAAC;sBAtF/D,SANbuxE,OA+FWvxE,EAAGP;wBACZ;iCADSO;;mCACS,eAAqC86K,IAAM,kBADjDr7K,EAC2Cq7K,MAAgB;mCAArD,uBADT96K,WAC+D,EAAC;sBA1F9D,SANbk7K,SAmGal7K,EAAGP;wBACd;iCADWO;;mCACO,eAAuC86K,IAAM,kBADjDr7K,EAC2Cq7K,MAAgB;mCAAvD,uBADP96K,WAC+D,EAAC;sBA9FhE,SANbkyE,KAuGSlyE,EAAGP;wBACV;iCADOO;;mCAEL,eACsC86K,IAAM,kBAHpCr7K,EAG8Bq7K,MAAgB;mCAApD,kBpI8OkB9uD,OoI9OlB,gBAHGhsH,YAvFHyW,MA2FkB,EAAC;sBArGZ,SANb0kK,QA8GYn7K,EAAEo7K,cAAcrgK,IAAItE;wBAC9B,kBADUzW;wBAEP,wBAFOA,KAAgB+a,KAGrB;wBACA,IHsmBO/b,KG1mBc+b,IAAItE;wBAIzB,gBAJO2kK;6BAMNrgB,IAGU,OATN/6J,KH0mBEhB;;0BGlmBG,UARLgB,KH2mBd;;2BAEgB,uCAATohG,MAHSpiG;;qCAEN,mBAFMA;0BGlmBG,IAFT+7J;wBAKJ,qBAXQ/6J,KAAgB+a,IAMpBggJ;wBAKJ,YACI;sBApHK,SANbsgB,aA6HiBr7K;wBAAI;;0B,OA7HrBm7K,QA6HiBn7K,qBAAmB;sBAvHvB,SANbs7K,cA8HkBt7K;wBAAI;;0B,OA9HtBm7K,QA8HkBn7K,qBAAoB;sBAxHzB,SANbu7K,YAuIgBv7K,EAAEo7K,cAAcrgK,IAAItE;wBAC5B,kBADQzW,EAAEo7K,cAAcrgK,IAAItE;wBAC5B;;qDAJI,qBAGIzW,KAAgB+a;kCAGnB;sBApIA,SANbygK,iBA6IqBx7K;wBAAI;;0B,OA7IzBu7K,YA6IqBv7K,qBAAuB;sBAvI/B,SANby7K,kBA8IsBz7K;wBAAI;;0B,OA9I1Bu7K,YA8IsBv7K,qBAAwB;sBAxIjC,SANb07K,4BAkJgC17K,EAAE+a;wBAChC,kBAD8B/a;wBAEpB,IAAN+6J,IAAM,qBAFoB/6J,KAAE+a;wBAGhC,aAH8B/a,KAE1B+6J;wBAEY,OAFZA,SAE2B;sBAhJpB,SANb4gB,wBAyJ4B37K,EAAE+a;wBAE5B,kBAF0B/a;wBAE1B,eACQ+6J,KACR,aAJ0B/6J,KAGlB+6J,KAEQ,OAFRA,SAEuB;wBAFjB,+BAHY/6J,KAAE+a;wBAGd,iDAEiB;sBAxJpB,SANb6gK,6BAiKiC57K,EAAE+a;wBACjC,kBAD+B/a;wBAErB,IAAN+6J,IAAM,qBAFqB/6J,KAAE+a;wBAGjC,cAH+B/a,KAE3B+6J;wBAEY,OAFZA,SAE2B;sBA/JpB,SANb8gB,yBAwK6B77K,EAAE+a;wBAE7B,kBAF2B/a;wBAE3B,eACQ+6J;0BACR,cAJ2B/6J,KAGnB+6J,KAEQ,OAFRA,SAEuB;wBAFjB,+BAHa/6J,KAAE+a;wBAGf,iDAEiB;sBAvKpB,SANb+gK,iBAgLqB97K,EAAEo7K;wBACrB,kBADmBp7K;wBACnB,gBADqBo7K;6BAEjBW,SAGU,WALK/7K;;0BAIN,UAJMA,KHwjBvB;;4BAGE,mBAzfA,KAwfKohG;4BAvfF,kBADCg4E;8BAIF,eAofGh4E;8BAnfH,8BAmfGA,MAxfDg4E;8BAKF,UARAC;4BA6fC,GAFEj4E,UAxfDg4E,KA0fyB;4BAD7B,aAzfIA;;;0BG9DW,IAFT2C;wBAE0C,GAF1CA;0BAQF,IADKjB,GAPHiB;0BAQF,qBAViB/7K,KASZ86K;0BACL,aADKA;wBADG,QAGe;sBArLd,SANbkB,qBAkMyBh8K,EAAEo7K;wBACnB,2BADiBp7K,EAAEo7K;wBACnB;+CAEKp8K,aAAHL;sCAAGK;gDAAU;sBA/LV,SANbi9K,sBAwM0Bj8K;wBAAI,wBAAJA,cAA4B;sBAlMzC,SANbk8K,0BAyM8Bl8K;wBAAI,4BAAJA,cAAgC;sBAnMjD,SANbm8K,uBA0M2Bn8K;wBAAI,wBAAJA,YAA6B;sBApM3C,SANbo8K,2BA2M+Bp8K;wBAAI,4BAAJA,YAAiC;sBArMnD,SANbq8K,QA6MYr8K,EAAEo7K;wBACN,2BADIp7K,EAAEo7K;wBACN,+BAEKp8K;wBADD,QACa;sBA1MZ,SANbs9K,aAmNiBt8K,GAAI,eAAJA,cAAmB;sBA7MvB,SANbu8K,cAoNkBv8K,GAAI,eAAJA,YAAoB;sBA9MzB,SANbw8K,eAsNmBx8K;wBACX,kBADWA;wBACX;+CAEG+a,eAAKtE;uCAALsE,IAAKtE;wBADJ,QACgC;sBAnN/B,SANb2qF,MA4NUphG;wBACF,kBADEA;wBACF,UAEO,IAAN86K,YAAM,UAANA;wBADG,QACgB;sBAzNf,SANb2B,YAoOgBz8K,EAAEo7K;wBACV,kBADQp7K,EAAEo7K;wBACV,UAEM,IAALp8K,WAAK,OAALA;gDAAM;sBAjOF,SANb09K,iBA0OqB18K;wBAAI,mBAAJA,cAAuB;sBApO/B,SANb28K,kBA2OsB38K;wBAAI,mBAAJA,YAAwB;sBArOjC,SANbo5J,KA6OSp5J,GAEE,wBAFFA,MA9NH+a,IAgOqD;sBAzO9C,SANbqyG,MAkPUptH,EAAGP;wBACX;iCADQO;;mCAEN,eAAmC86K,IAAM,kBAFhCr7K,EAE0Bq7K,YAAkC;mCAArE,eAFM96K,WAEgE,EAAC;sBA9O9D,SANb4jE,KAuPS5jE,EAAGP;wBAAI;iCAAPO,iBAA+B4B,MAAQ,kBAApCnC,EAA4BmC,KAAc,EAAC;sBAjP1C,SANbyrH,MAyPUrtH,EAAG4hB,KAAMniB;wBACjB;iCADQO;;mCAEN,eAAyCynC,GAAGqzI,IAC1C,kBAHar7K,EAE0BgoC,GAAGqzI,YACX;mCADjC,uBAFM96K,KAAG4hB,WAGyB,EAAC;sBAtP1B,SANb8lD,KA+PS1nE,EAAG4hB,KAAMniB;wBAAI;iCAAbO;iCAAG4hB;0CAAgC6lB,SAAW7lC,MAAQ,kBAA7CnC,EAA0BgoC,GAAW7lC,KAAiB,EAAC;sBAzP5D,SANbg7K,QAgQU58K,EAAGP,GAAI,aAhQjBioE,KAgQU1nE,EAAGP,EAA8B;sBA1P9B,SANbo9K,MAiQQhqK,EAAE7S,EAAGP,GAAI,sBAjQjBioE,KAiQQ70D,GAAE7S,EAAGP,EAA8B;sBA3P9B,SANbq9K,UAkQY98K,EAAG4wE;wBAAU,eAlQzBlJ,KAkQY1nE,EAAG4wE,QAA4C;sBA5P9C,SANbmsG,UAmQY/8K,EAAG4wE;wBAAU,eAnQzBlJ,KAmQY1nE,EAAG4wE,QAA4C;sBA7P9C,SANbosG,cAoQgBh9K,EAAG4hB,KAAMniB;wBAAI,mBApQ7BioE,KAoQmB9lD,KAAMniB,EAATO,EAAmD;sBA9PtD,SANbi9K,aAqQej9K,EAAG4hB,KAAMniB;wBAAI;0B,OvImU9BslH,WuIxkBEr9C,KAqQkB9lD,KAAMniB,QAATO,GAAkD;sBA/PpD,SANbk9K,YAuQgBl9K,EAAGP;wBAEf;0BAAM,wBAFMO;0BAEN,UAGJ,IADKhB,WACL,WALaS,EAIRT;0BADG,SAKL;sBAzQI,SANb8wE,OAkRW9vE,EAAErB;wBACX,kBADSqB;wBAEH,+BAFGA,KAAErB;wBAEL,UAGJ,IADKo8J,aACL,SALO/6J,KAIF+6J,KACL;wBAFQ,iBAGL;sBAlRM,SANboiB,WAkSen9K,EAAErB;wBACf,kBADaqB;wBAEP,iBAFOA,EAAErB;wBAET;;;qDALI,qBAGGqB,KAAErB,QAIJ;sBAhSA,SANby+K,kBAySsBp9K,EAAErB;wBACtB,kBADoBqB;wBAEd,+BAFcA,KAAErB;wBAEhB;0BAGJ,IADKo8J,aACL,SALkB/6J,KAIb+6J,KAEA,UAFAA;wBADG,QAGkB;sBAzSjB,SANbt7D,QAkTYz/F,EAAErB,EAAEK;wBACd,kBADUgB;wBAEJ,+BAFIA,KAAErB;wBAEN,UAGJ,IADKo8J,aACL,YALY/7J,EAKZ;wBAFQ,iBAGL;sBAlTM,SANbq+K,YAkUgBr9K,EAAErB,EAAEK;wBAClB,kBADcgB;wBAER,kBAFQA,EAAErB,EAAEK;wBAEZ;;;qDALI,qBAGIgB,KAAErB,QAIL;sBAhUA,SANb2+K,KAyUWnrI,IAAOnyC,EAAEo7K;wBAClB,GADSjpI,IAAI,QAAJA,SAAIi7B,aAAJ9tE;wBACN,GAAK,OADQU,MAAPV,EAEJ,aAFWU;wBAId;8BAJOV;;0BAKL;4BAAQ,iBALIU,EAAEo7K;4BAKN;+BALH97K;;gCAMH;sBAzUK,SANbi+K,UAkVej+K,EAAEU,GAAI,YAANV,EAAEU,cAAmB;sBA5UvB,SANbw9K,WAmVgBl+K,EAAEU,GAAI,YAANV,EAAEU,YAAoB;sBA7UzB;iCAsVby9K;0B,OA5VAv2D,iBA4VAw2D;wBAEe,IAAX3xC,SAAW;iCACXye,SAAQuwB,eAAgBt5K;0BAAU,cAA1Bs5K,eAAgBt5K,KADxBsqI,SACuE;wBAD5D;gCA9VfzxI;;;;;;;;;;;;;;;;;gCA+VIkwJ;gCA/VJ70E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCA4VA8nG;sBAtVa;8BANbv2D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCAWK;mBAnBT;;kBA6W8B;;kBxYlWxB4qB;kBI4HFwV;kBADAD;kBJ5HExV;kByYRN;;kB/DAa;mB+DAb;;;uBA4CItwB;uBAEQ3wC;;;;;;;uBAONm7D;;8BAPMn7D;8BAFR2wC;8BAEQr0B;8BAON6+C;;;;mBArDN;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBA0EIxqB;uBAEQr0B;uBAON6+C;;8BATFxqB;8BAEQr0B;8BAON6+C;;;;mBAnFN;;;;;;;;;;;;;;;;;;;;;;;;;;kBAgIG;;kBzYvHG+F;kBI4HFwV;kBADAD;kBJ5HExV;kB0YVN;;kBAiHG;;kB1YtGGC;kBI4HFwV;kBsUrIS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uB+D6EJq2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBrYuDLt2B;kBJ5HExV;kB2YVN;;kBjEEa;mBiEAb;;mBAA0C;oC;kBAAA;kBjEA7B;mBiEKP;;mBAAqC;oC;mBAAA,kBzE8EvCyR,c9HPArD;mBuMvEuC,kB3EwGvCsB;mB2ExGuC;;;qBzE8EvC+B;qB9HPArD;qB4HiCAsB;;;;;;mB2ExGuC;;;;qB5SmsBjCloC;qBgE1gBJxB;;;;;;;;;qB4B8CA0G;qBADAD;;;;;;;;;qBqFjBKipB;;;;mB2HrNgC,qB;mBAAA;;;;kBAkBvC;kBAED;;kB3YhBGuK;kBI4HFwV;kBADAD;kBJ5HExV;kB4YKN;;kBAsHG;;kB5Y1HGC;kBI4HFwV;kBADAD;kBJ5HExV;kB6YVN;;kBAW4B,sBAAC,WhN8RhBH;kBgNzIV;;kB7YrJGI;kBI4HFwV;kBADAD;kBJ5HExV;kB8YVN;;kBpEEa;mBoEWP;;mBAAmC;oC;mBAAA,kB5EkHrC+R,gB9HqCApD;mB0MvJqC,kB9E4QrCsB;mB8E5QqC;;;qB5EkHrC8B;qB9HqCApD;qB4HqHAsB;;;;;;qBrI+XEnjC;qBAaArF;qBACAxB;;kBmNzpBmC;;qB5EkHrC8rC;qB9HqCApD;qB4HqHAsB;;;;;;qBrI4YExoC;qBAbAqF;qBAcA7G;;kB+IpqBO;mBoE4BT;;mBAAmC;oC;mBAAA,kB5EiGnC8rC,gB9HqCApD;mB0MtImC,kB9E2PnCsB;mB8E3PmC;;;qB5EiGnC8B;qB9HqCApD;qB4HqHAsB;;;;;;qBrI4YExoC;qBACAxB;qBqFreKsX;kB8HnK4B;;;qB5EiGnCw0B;qB9HqCApD;qB4HqHAsB;;;;;;qBrI4YExoC;qBqFpeK6V;qBrFqeLrX;;kBmNxoBiC;kBpE5B1B;mBoEyCP;;mBAAmC;oC;mBAAA,kB5EoFrC8rC,gB9HqCApD;mB0MzHqC,kB9E8OrCsB;mB8E9OqC;;;qB5EoFrC8B;qB9HqCApD;qB4HqHAsB;;;;;;mB8E9OqC;;;;qBnN0nBnCxoC;qBACAxB;;;;;;;;;qBAbA8G;qBADAD;;;;;;;;;;;;qBsCroBF97F;mB6KwBqC,2B;mBAAA;;;;;;;;;;;;;;;;sBAkBvC,0CAA6D;mBAlBtB;;sBAqCvC,sDAA4E;kBAK3D;;kB9Y1EbivH;kBI4HFwV;kBADAD;kBJ5HExV;kB+YVN;;kBrEEa;mBqEIT;;mBAA2C;oC;kBAAA;kBA4B+B;;kB/YvBxEC;kBI4HFwV;kBADAD;kBJ5HExV;kBgZVN;;;kBtEEa;mBsEKP;;mBAAiC;oC;mBAAA,mB9EoGnC0R,c9HkBAlD;mB4MtHmC,mBhFuRnC0B;mBgFvRmC;;;qB9EoGnCwB;qB9HkBAlD;qB4HiKA0B;;;;;;mBgFvRmC;;qBnTa/BlzB;;;;;;;;;;;;;;;;;;;;;;;;;;mBmTb+B,qB;mBAAA;;;;;mBAgBnC;;mBAAiC;oC;mBAAA,mB9EoFjC00B,c9HkBAlD;mB4MtGiC,mBhFuQjC0B;mBgFvQiC;;;qB9EoFjCwB;qB9HkBAlD;qB4HiKA0B;;;;;;;;qBhD7FO7yB;kBgI1K0B;;;qB9EoFjCq0B;qB9HkBAlD;qB4HiKA0B;;;;;;;qBhD7FO9yB;;;kBgItJiE;;kBhZhCtE6iB;kBI4HFwV;kBADAD;kBJ5HExV;kBiZVN;;kBAauC;;kBjZFjCC;kBI4HFwV;kBADAD;kBJ5HExV;kBkZVN;;kBxEEa;mBwEGT;;mBAI4D;oC;mBAAA,8BAJ5D,QAI4D;;;sBAJ5D;;;qEAI4D;;;;sBAJ5D,gDAI4D;;;sBAJ5D;;;+BACE,gBACA,iBACA,SAC0D;;;;kBxEPnD;mBwEOmD;;;;;;;;;;;;;;;;;;qBvZ2D1DhpB;qBAJAJ;qBAEAE;qBACAC;qBAJAJ;qBAEAE;qBAOAO;qBADAD;qBAGAG;qBADAD;qBAJAJ;qBACAC;;;;;;;;;mBuZ7D0D,2B;mBAAA;;;kBAMlB;;kBlZJxC+oB;kBI4HFwV;kBADAD;kBJ5HExV;kBmZVN;;kBzEEa;mByEuBX;;mBAA2C;oC;mBAAA,mBjF0GzCgS,e9HuDAnD;mB+MjKyC,mBnFkSzCuB;mBmFlSyC;;;;;;;;;uBjF0GzC4B;uB9HuDAnD;uB4HiIAuB;;;;;;;uBrIQExjC;uBAcAkyB;;mBwNxTuC;;;;;uBjF0GzCkT;uB9HuDAnD;uB4HiIAuB;;;;;;uBrIQExjC;;uBAcAkyB;;mBwNxTuC;;;;;;;;;qBxN2SvCjyB;qBADAD;;;mBwN1SuC;;sB;;wBA4BlB,+CAAyC;6CAC9C,kBAAO;;wBACR,oDAAkB;;wBACd,8CAAyC;6CAC7C,oBAAM;6CACD,wBAAQ;;wBAGpB;wBACR;;oEAIM;;;;;;;;;;kBAiBV;kBAmCkE;;kBnZ3G9DqzB;kBI4HFwV;kBADAD;kBJ5HExV;kBoZVN;;kB1EEa;mB0EKP;;mBAA4C;oC;mBAAA,mBlFqG9C2R,a9HwBAlD;mBgN7H8C,mBpF8R9C0B;mBoF9R8C;;;qBlFqG9CwB;qB9HwBAlD;qB4HiKA0B;;;;;;;qBrIkFEzoC;qBb9QEyb;qBenCEb;kB6IpEG;mB0EgBP;;mBAAgC;oC;mBAAA,mBlF0FlCqvB,a9HwBAlD;mBgNlHkC,mBpFmRlC0B;mBoFnRkC;;;qBlF0FlCwB;qB9HwBAlD;qB4HiKA0B;;;;;;mBoFnRkC;;qBpPA9BxgC;;qB2BqWFjI;qBb9QEyb;;qBkBhFJ/xD;qB4CsIEu5C;qBAJAJ;qBAEAE;qBACAC;qBAJAJ;qBAEAE;qBAOAM;;qBAEAE;qBADAD;qBAHAH;qBACAC;;;;qB/C5FIyX;;;;;mBuNpD4B,qB;mBAAA;;;;;;;;;;;;;;;;;;;kBAWpC;kBAS4E;;kBpZ3BxE2d;kBI4HFwV;kBsUrIS;;;qB9F6JP9qC;qBAJAJ;qBAEAE;qBACAC;qBAJAJ;qBAEAE;qBAOAM;;qBAEAE;qBADAD;kBxO9BFyqC;kBJ5HExV;kBqZVN;;kB3EEa;mB2EGP;;mBAAkC;oC;mBAAA,mBnFwIpCiS;mBmFxIoC,mBrFgUpC5B;mBqFhUoC;;;qBnFwIpC4B;;qBFwLA5B;;;;;;mBqFhUoC;;;qBzYoHtCxa;qB+KsSIluB;qBEzVI0xB;;qBG5CNz+D;qBH4CM68D;;;;;;qBF6UJS;qBADAnC;qBE5UIiC;;qBF4UJjC;qBE5UIgC;;;;;;;;;mBwNjE8B,qB;mBAAA;;;;;;;kBAUtC;kBAS8E;;kBrZb1EkI;kBI4HFwV;kBADAD;kBJ5HExV;kBuZVN;;kB7EEa;mB6EGP;;mBAAkC;oC;mBAAA,mBrFgJpCkS;mBqFhJoC,mBvFiVpC5B;mBuFjVoC;;;qBrFgJpC4B;;qBFiMA5B;;;;;;mBuFjVoC;;qBpasDlC1gC;qBA7Be2b;qBwMyaf3jB;qBEjYI2mB;qB1MxCW9C;qB6MHjBxwD;qB7MGiBqwC;;;;;;qBwM6ZfI;qBADAD;qBxM5ZeG;;;;;;;;qB0MwCX6gB;;;;mB0NjE8B,qB;mBAAA;;;;;;kB7EH3B,I7IuEHmhD;kB0NpE8B;kBAUtC;kBAS8E;;kBvZb1E3tC;kBI4HFwV;kBADAD;kBJ5HExV;kBwZVN;;kB9EEa;mB8EFb;;;;qBFuFUwtC;;;;mBEvFV,2B;mBAAA;;;;;;;;;;qB5CUiEK;;;;;;;;mB4CVjE;;sBAkBM;;;gC1OuFEb;;;;;;;yC0OpFsD;mBAGvB;;;;;;;;;;;;;;;;;;;;;;kB9EtB1B;mB8EsB0B;;;;;;;;;;;;qBpY+J/B/yC;;;;;;;;;;;;;;;;;;;;;;;;;;mBoY/J+B,qB;mBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAmDrC;kBAS8E;;kBxZzE1EgG;kBI4HFwV;kBADAD;kBJ5HExV;kByZVN;;kB/EEa;mB+EIP;;mBAAgD;oC;mBAAA;;;sBAOhD;;kFACgD;wB3EqRhDke;;;;;;;;;;;;;;;;;;kBJjSO;mB+EsBP;;mBAAiC;oC;mBAAA,mBvF4DnC1M,c9HbArD;mBqN/CmC,mBzF+EnCqB;mByF/EmC;;;qBvF4DnCgC;qB9HbArD;qB4HgCAqB;;;;;;mByF/EmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;wC;mBAAA;;;;;;kBAapB;;kBzZ1BbvP;kBI4HFwV;kBADAD;kBJ5HExV;kB0ZRN;;kBAwByB;;kB1ZfnBC;kBI4HFwV;kBADAD;kBJ5HExV;kB2ZVN;;kBjFEa;mBiFIT;;8C,gCAAwD;kBAAxD;kBAW2B;;kB3ZNzBC;kBI4HFwV;kBADAD;kBJ5HExV;kB4ZVN;;kBlFEa;mBkFGP;;mBAAsC;oC;mBAAA;sC5FoWxCuQ;mB4FpWwC;;;;;qB5FoWxCA;;;;;;mB4FpWwC;;;qBhZgI1CnpB;qB+K0ZIvf;;qBEzdIyf;qBG1CNjsD;qBH0CM6wC;;;;;;qBF6cJI;qBADAD;qBE5cIG;;;;;;;;qBmF+KE+a;;;;mB4IhPgC;oC;kBAAA;;kBAU1C;kBASkF;;kB5Zb9E0Y;kBI4HFwV;kBADAD;kBJ5HExV;kB6ZVN;;kBnFEa;mBmFKP;;mBAA6B;oC;mBAKlB;;0CAMmB,uBAAkB;mBANrC,mBjHFb7Y;mBiHEa;;sBAUX,qDAAwD;mBAV7C;;sBAcX,iDAA6D;mBAdlD;;;;qBjHFbA;;;;;;;;mBiHEa;;;;;;;;;;;;;;;;;;;;;;;;;;;;mC;kBAmCqC;;kB7ZpChD8Y;kBI4HFwV;kBADAD;kBJ5HExV;kB4SJN;;kBAI4C;;kB5SCtCC;kBI4HFwV;kBADAD;kBJ5HExV;kB8ZVN;;kBAEA;kBAQmC;;kB9ZC7BC;kBI4HFwV;kBADAD;kBJ5HExV;kB+ZVN;;kBrFEa;mBqFKT;;;;8C,gCAA+C;kBAA/C;kBAaF;;;;;;;;kBAOC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P,UAALk2E;;;gDvBvMN3mE,kBuBuMWvP,UAALi2E;;;iDvBvMN1mE,kBuBuMWvP,UAALg2E;;;iDvBvMNzmE,kBuBuMWvP,UAAL+1E;;;iDvBvMNxmE,kBuBuMWvP,UAAL81E;;;iDvBvMNvmE,kBuBuMWvP,UAAL61E;;;iDvBvMNtmE,kBuBuMWvP,UAAL41E;;;iDvBvMNrmE,kBuBuMWvP,UAAL21E;;;;;;gC4R5G4BrO;gD,OnT3FlC/3D,kBuBuMWvP;gCAAL01E;;;iDvBvMNnmE,kBuBuMWvP,UAALy1E;;;iDvBvMNlmE,kBuBuMWvP,UAALw1E;;;iDvBvMNjmE,kBuBuMWvP,UAALu1E;;;iDvBvMNhmE,kBuBuMWvP,UAALs1E;;;iDvBvMN/lE,kBuBuMWvP,UAALq1E;;sDvBvMN9lE,kBuBuMWvP,UAALo1E,KA2B8D;uBA3B9D;iCAAKn1E,QAALr5J;;;;;;;;;;;;;;;;;;;;;;;;;;;;kD4R5G4BglO,e5R4GvB3rE,SAALr5J;;kD4R5G4BglO,e5R4GvB3rE,SAALr5J;4CAAKq5J,QAALr5J;;kD4R5G4B8hO,e5R4GvBzoE,SAALr5J;4CAAKq5J,QAALr5J;4CAAKq5J,QAALr5J;4CAAKq5J,QAALr5J;4CAAKq5J,QAALr5J;4CAAKq5J,QAALr5J;4CAAKq5J,QAALr5J;kCvBvMN4oK,mBuBuMWvP,QAALr5J;kCvBvMN4oK,mBuBuMWvP,QAALr5J;kCvBvMN4oK,mBuBuMWvP,QAALr5J;kCvBvMN4oK,mBuBuMWvP,QAALr5J;kCvBvMN4oK,mBuBuMWvP,QAALr5J;kCvBvMN4oK,mBuBuMWvP,QAALr5J;kCvBvMN4oK,mBuBuMWvP,QAALr5J;kCvBvMN4oK,mBuBuMWvP,QAALr5J;;;;gC4R5G4B2gO;;kC,OnT3FlC/3D,mBuBuMWvP;8BAALr5J;;;kCvBvMN4oK,mBuBuMWvP,QAALr5J;kCvBvMN4oK,mBuBuMWvP,QAALr5J;kCvBvMN4oK,mBuBuMWvP,QAALr5J;kCvBvMN4oK,mBuBuMWvP,QAALr5J;kCvBvMN4oK,mBuBuMWvP,QAALr5J;iCvBvMN4oK,mBuBuMWvP,QAALr5J,eA2B8D;uB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oB,OAEpBA,SAAqB;6BAItB,0BAdCk7Q;6BAgBC,wBA5CyBN;6BA4CzB;;;8BAHHn7Q;;iD6IkUAm5G,a5LjeFk5B,a+C+JEryI;;;;;;uC6IkUAm5G,aXndE8lE,alIiJF7rG;;;4BAtCQ,IAiDW8mC,W6IkInBJ,Y7ItLY1gF;qCAoDO8gF;;;;;0BAGnB,8BAAa;sBAuR6D;;sB9C1c1E44B;sBI4HFwV;sBADAD;sBJ5HExV;sB+gBVN;;sBAwQiB;;sB/gB7PXC;sBI4HFwV;sBADAD;sBJ5HExV;sBghBVN;;sBAGsC;;sBhhBQhCC;sBI4HFwV;sBADAD;sBJ5HExV;sBihBVN;;sBAkDsB;;sBjhBvChBC;sBI4HFwV;sBADAD;sBJ5HExV;sBkhBVN;;sB9E+EoB,I8EqEO76C,aAahB9+E,QAAS,cAATA,SAA4B;sBA4Xf;;sBlhBlhBlB45H;sBI4HFwV;sBADAD;sBJ5HExV;sBmhBVN;;sBAiDQ;;sBnhBtCFC;sBI4HFwV;sBADAD;sBJ5HExV;sBohBVN;;sBA4U8E;;sBphBjUxEC;sBI4HFwV;sBADAD;sBJ5HExV;sBsgBVN;;sBAsB6B;sBlEyDT;;iCkE5BOx3B;0BQnBF,0BCwBf,ETJW1vC;0BACjB,SAxByBlrE;4BAyBrB,eQXK2yE;8BACA,sBAREpzE,KAOFozE,IACPxL;iCAVyB,URkBV+D;;;+BQfsD,ORetDA,QQhBN3rE;8BRgBM2rE,UQRf/D;sCRUsE;4BAApE,OAHmByzC;4BAGnB;oCAAoG;0BAzB3E,aAAJ56G,EAsBF46G;iCSKrBr6G,CTFyG;sBA4Q5G;;sBtgBvTG8xI;sBI4HFwV;sBADAD;sBJ5HExV;sBqhBVN;;sBAmB6B,uBAAuB;sBAmC1B;;sBrhB3CpBC;sBI4HFwV;sBADAD;sBJ5HExV;sBshBVN;;sBA4DG;;sBthBjDGC;sBI4HFwV;sBADAD;sBJ5HExV;sBuhBVN;;sBAoGuD;;sBvhBzFjDC;sBI4HFwV;sBADAD;sBJ5HExV;sBwhBVN;;sBpF+EoB;uBoF/EpB,mBAmBel1I,GAAI,oBAAJA,GAA0B;uBAnBzC;iCAqBaqD,EAAGP;0BACV;mCpR0UsB65Q;mCoR3Uft5Q;4CAGH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;6BA7HEE;;gCwJ/iBF5iL;yCxJgrBa0yK;2CA3CXmQ,YA2CWt6K;oC,O0E9uCf+8H,sB1E8uCe/8H;;mCA3CXA,I0EnsCJ+8H,gB1EmsCIu9C,YA2CWnQ;mCA3CXpiH,sBA2CW3tK;oDwJhrBbq9G,iBxJqoBE6iL,kBA2CWlgS;gCAJbggS;;mCsBvkCEhgS;;;6BtB08BAmgS;8B0E7mCJx9C;yC1E8mCc/8H;;;;;;;gCADVq6K;;;;;6BAsBFM,wBAtBED;;qCAxwBFE,YAgyBa56K;;;;qCAsJbi6K,cAtJaj6K;qCAsJbi6K,cAtJalyH;;;6BAhyBb/nD,euc3UEw2H,evc2UFokD,YA8xBAD;6BA9xBA5yH,iBuc3UEyuE,evc2UFokD;;8C4R0OatnD,e5R1ObsnD;;;;;;;;yCwJyNAnjL,iBxJzNAmjL;;yCwJyNAnjL,iBxJzNAmjL;;yCwJyNAnjL,iBxJzNAmjL;;yCwJyNAnjL,iBxJzNAmjL;;yCwJyNAnjL,iBxJzNAmjL;;yCwJyNAnjL,iBxJzNAmjL;;yCwJyNAnjL,iBxJzNAmjL;;yCwJyNAnjL,iBxJzNAmjL;;;;gC4RqNazoD;yC5RlMOnyH;kC,kBwJsMpBvI,iBxJzNAmjL,YAmBoB56K;gCAnBpB27K;;;yCwJyNAlkL,iBxJzNAmjL;;yCwJyNAnjL,iBxJzNAmjL;;yCwJyNAnjL,iBxJzNAmjL;;yCwJyNAnjL,iBxJzNAmjL;;yCwJyNAnjL,iBxJzNAmjL;6BA8xBAsB;yCwJrkBAzkL,iBxJzNAmjL;oDA8xBAsB;mCsBh+BEv3M;4B,IAAAq7B,IyLUFpH;;qCzLVEw8D,qBAK+C;mCAL/C31G;4BAIE,StBonCJs0N,QsBvnCMppH;+EAAoB;4BtBwnCR,GsBznChB0xE,gBtBynCgB;sCsBznChBD,StBynCgB,MsBznChBC;4BtBynCgB,SAlDlB23C,QAkDemI,wCAAE;4BAjDgC;;;;;;;;kC4R7lBpC1lD;2C5R6lBA4lD;oCAAG;sDAAHE,wCAAE;6CAAFF;mDAAmC;;;;8BAAC;gCACjC;;;;;6CAAHI,wCAAE;;;gCAAC;kCACA;;;;;+CAAHE,wCAAE;;;kCAAC;;;;;sCvB/kCtBniH;iDuBglCmBqiH;0CAAoC,SA3C/C1sC,MA2CW4sC;4CAAG;8DAAHE,wCAAE;qDAAFF;2DAAmC;0CA3CpB,GA2CfF,gBA3Ce;;iDA2CfC;2CA3Ce,MA2CfD;2CA3Ce;;uDAAHM,sCAAE;;;0CAAC;4CAAgB,gBA2C/BN;4CA3C+B;wDA2C/BC;qDvBhlCnBtiH;gEuBqiCgE6iH,sCAAE;;;4CAAhB;;;sDA2CuB;;;;;;;;;;8BqJpuBjE;;;qC/HvWAjhD;;+BtBg+BFq5C;yCsB79BMyB;kCAAe;oDAAfE;2FAAc;2CAAdF;iDtBunCuB;+BA1J7BxB;yCsB99BM7qH;gFtBwnCiB;8BAzJD;;;;+CAAL0yH,yCAAG;+BAAE,eAyJNE,wCAzJD;8BAtBM;;;;;;;;6CAATE;;;;;;;mDADVxtC,MACU0tC,kBAAO;;;;gCAAE;kCACT;;oCACA;;sCACE;;kDAJZ1tC;;;;;;;;;;;;;;iCAxwBF5gH;2CAgyBa0uJ;;;;;;;iDAFbxI,QAEa0I,kBAAW;gCA/xBb;;;;;;;;sC4RwSE1nD;+C5RxSL8nD,sCAAE;;;;kCAAC;oCACW;;;;;wC4RuST9nD;iD5RvSMgoD,sCAAE;;;oCAAC;sCACd;;wCACG;;;;;4C4RsOElrD;qD5RtOLorD,sCAAE;;;wCAAC;0CACY;;4CACC;;8CACI;;gDACT;;kDACC;;oDACU;;sDACC;;;;;mEAAHE,sCAAE;;;sDAAC;wDACA;;;;;qEAAHE,sCAAE;;;wDAAC;0DACK;;;;;uEAAHE,sCAAE;;;0DAAC;4DACA;;;;;yEAAHE,sCAAE;;;4DAAC;8DACd;;;;;2EAAHE,sCAAE;;;8DAAC;gEACA;;;;;6EAAHE,sCAAE;;;gEAAC;kEACM;;;;;+EAAHE,sCAAE;;;kEAAC;oEACN;;;;;iFAAHE,sCAAE;;;oEAAC;sEACQ;;;;;0E4RkMjBvtD;mF5RlMOytD;4EAAG;8FAAHE,sCAAE;qFAAFF;2FAAS;;;sEAAC;wEACA;;;;;qFAAHI,sCAAE;;;wEAAC;0EACS;;;;;uFAAHE,sCAAE;;;0EAAC;4EACV;;;;;yFAAHE,sCAAE;;;4EAAC;8EACQ;;;;;2FAAHE,sCAAE;;;8EAAC;gFACA;;;;;6FAAHE,sCAAE;;;gFAAC;;;;;oFvB/N3CjmH;+FuBgO8CmmH,sCAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gDAqwB1CjL;;;;;wCsB59B+C;0BAGpC,IAAL35Q,GAAK;mCAWL8kR,YAAYnpS,EAAGR,EAAGqwB,SAAUu5Q;4BAAa,kBAA1B5pS,EAA0B,WAA7BQ,EAAM6vB,SAAUu5Q,UAAoC;0BAX3D,SAaL7+I,SAAQ16H,SAAUu5Q;4BACpB,UADUv5Q,SAAUu5Q,SAEE;0BAff;;;6BARXluD;;;6BACO/tE;6BADPC;;;6BACEmB;;;;6BADF6tH;6BACE74C;;;;;;;6BAOIl/N;6BAWA8kR;6BAEA5+I;2BAbK;;;;;;;;;;;;;;;;;;;;;;2Bwf/HF;;;;8C,O5fkJXykI;mCIIQziH,Wwf3LO5yJ,IAAK0nI;4BACU;4DADf1nI,IAAK0nI,SACqC;mCxf0LjDorB,awfxLW9yJ,IAAK0nI,QAAQ9mJ;4BACF;4DADXof,IAAK0nI,QAAQ9mJ,GAC+B;;2BxfuLvDmyK;oCwflMRb,2BxfkMQa;6CwfvKM3sK;4BAAgC,+CAAhCA,GAA+C;mCxfuKrDs3O,UwfhKMgyD;4BACsB,sB,O5f2JpCra;4B4f3JE,yCADYqa,YACmD;mCxfmK3DC,mBAjCE,YAAoB;0BAF1B;0CwfnKFz9H;0BxfmKE;;;;;;;;;;;;;6BA+BMj+F;6BwflMRwgG;;6BxfkMQ7B;;6BwflMRV;;6BxfkMQa;;;6Bwf1KR6e;6BAOA8wD;6BxfmKQhF;6BAIFiyD;2BAnCJ;mCACEltL,gDAK+C;0BANjD;;;;;;;;;;;;;;;;;;;mCAgDA36G,EAAE1B,EAAEP;4BAAwB,qBAAxBA,EAAFO;4BAA0B,oCAAK;0BAhDjC,SAkDAwpS,gBAAgB9kR;4BACR,IAAN+kR,IAAM;4BACV;8BAFkB/kR,aAEKk+O,IAAM,8BADzB6mC,IACmB7mC,GAAmC;4BAA1D,OADI6mC,GAED;0BArDD,SAwDAC,6BAA8B1pS;4BAChC,SAAI0B,EAAG80F;8BACL,iCADKA;8BmblNM,UAEX,IADK/5F,WACL,OADKA;8BAGL,sBnb+M6D;4BAD/D,SAGIktS;8BAEK,IAFOC,YAAJC,YAEH,QAFOD;8BAEb,YAFSC;4BASwB,YAbJ7pS,MAYtB,QAZsBA,MAYtB,MAZsBA,KAYtB,MAZsBA;4BAS5B,gBAT4BA,KAI5B2pS,+BAUH;0BAtEC,SAwEAG;;6BAyBG37C;6BADA4C;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BAHAC;6BAEAn1P;6BADA6gC;6BAFA3gC;2CA8C4B1C;8BACzB;;yCAAgC,wBA7BnC42P,cA4B4B52P,SACwB,EAAC;4BADtD;;6BAlR+B85R,GAuO9Bt3R;6BAvO0Bu3R,GAuO1Bv3R;6BAvOsBw3R,GAuOtBx3R;6BAvOkBy3R,GAuOlBz3R;6BAvOc03R,GAuOd13R;6BAvOU23R,GAuOV33R;6BAyBY,qBA3BZm1P;4BA0BC;mDA3BDj1P;;oCAEA2gC;uCAtOU82P,MAAID,MAAID,MAAID,MAAID,MAAID;oCAwO9BpiC;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;;oCAEAF;oCACAD;oCACAD;oCACAD;oCACAD;oCACA5C;0BAjGH,SAiIA0kC,WAAY7yR;4BACF,IAARgvB,MAAQ,6BADEhvB;4BACF,SAEN+pS;kCACSC,oBAANC;6CAAMD;4BAGb,IALEt8Q,MAKF,OAAwC,gBAP5B1tB,MAGR+pS;4BAIJ,SAEEzvC,GAAG79P;8BACC,kCADDA;;gCAGD,IADoBytS,YACpB,OADoBA;8BAGpB,8BAAY;4BAGhB;0DAjBYlqS,SASVs6P;6BAQF,SAhBEtrO,MACAtB,MAFU1tB;4BAiBZ,eASgBT;8BAGM,qB2M2BAysH,O3M9BNzsH,KAjBd+6P,IAmBmB,SAFL/6P;8BACK,gBADLA,KAjBd+6P,gBAqBS;4BALL;8C2M+BgBtuI,O3MxDVhsH;6BAuBC,SAvBDA;4BAsBC;8CANX8tB,OAMW,GAtBD9tB,4BAgCqC;0BAjKjD,SAmKAmqS;4BA6CgB;6BApBdh8C;6BADA4C;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAl1P;6BADA6gC;6BADAs0N;6BADAj1P;6BA4Cc,iBA1Bdk0P;6BASa,qBA1Bbe;mCAEAn1P;;;;;6BAhUuCs3R;6BAAJC;6BAAJC;6BAAJC;6BAAJC;6BAAJC,GAgUnB33R;4BAuBE;mDA1BFE;oCAEA2gC;uCA/TmB82P,GAAID,GAAID,GAAID,GAAID,GAAID;;oCAiUvCpiC;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;;oCAEAF;oCACAD;oCACAD;oCACAD;oCACAD;oCACA5C;0BA5LF,SAyNAi8C,aACQC;4B,gBACPrrS;8BACwB,qBAFjBqrS,KACPrrS;8BACQ,yBAFDqrS,KACPrrS,SACiC;0BA5NlC,SA8NA4zR,WAAa0X,WAA0Cr0E;;;6BAKhDhnM;6BADAvB;;6BAD+BkqO;6BAAPvpO;6BAALwpO;6BAALC;6BAAJ1pO;;6BAFuB+tH;6BAARnuH;6BAARD;6BAARD;qCAQdpsB,EAAEjF,GAAI,iCAAJA,GAA4D;qCAC9D8tS,KAAKvqS;8BAAI,6CAAJA,GAAkD;4BAClD;6BAALwqS;8BAAK;gCARUp8Q;;kCAQM,0BAAqB,QAAZpzB,GAAO,YAAVyB,SAAoB;4BAA1C,SACLguS;kCAAsBT,oBAANC;6CAAMD;4BAyBtB;;;gCArCWM;;kCAsCN;;;;;4CAA+CI,uBAANjuS,EAAGzB,QAM1C;6BAXD,sBAAgB,OA7BjB0yB,MAQL+8Q;6BAmBO,QA5B6B7yC;6BAyB1B,SAjBV4yC,KAiBU,EAzBmBn8Q,OAAVypO,IAAKD;6BAiBpB;;gC2MzDgB7rI;gC3MsCkBmwB;yCAmBRn8I;kCAGV,qB2M5DAgsH,O3MyDUhsH,KAV9BuqS,MAYmB,WAFWvqS;kCACX,gBADWA,KAV9BuqS,kBAcS;6BANE,WAjBmBv8Q;6BAgBnB,WAhBWD;4BAeX;sDAAe,OAfZD,OASdy8Q;;;oCALKt7Q;oCALgDgnM;;0BA9NvD,SA6QA00E,aAAWL,WAAWr0E,cAAcj2N;4BACf,kBADVsqS,WACU,QADCr0E,eAAcj2N,EACgB;0BA9QpD,SAgRA4qS,SAAQxkM,QAAQykM,GAAIvzE,QAASE;4BAC/B,GADUpxH;6BAEwC,MAFxCA,WACNkkM,WACyCttS;;iCADzCstS;4BAIF;;;;kCAJEA;kDAIqB,IAAOI,oBAAP,OAAOA,UACd;6BAIhB;;gCATEJ;;kCAUG,IAAO/W;kCAAP,iCAAOA,YACiC;6BAErC;;yCAdQsX,GAAIvzE,QAASE,UAI3BkzE,WAKA37Q;4BAKM,kBAAN9sB,IACU;0BA/RZ,SAiSA6oS,aAAc1kM,QAAQykM,GAAIvzE,QAASE;4BACrC,GADgBpxH;6BAEkC,MAFlCA,WACZkkM,WACyCttS;;iCADzCstS;4BAIF;;;;kCAJEA;kDAIqB,IAAOI,oBAAP,OAAOA,UACd;6BAIhB;;gCATEJ;;kCAUG,IAAO/W;kCAAP,iCAAOA,YACiC;4BAF7C,eAIctxR,KAGhB,kBAHgBA,IAGF;4BAFZ;;;yCAfsB4oS,GAAIvzE,QAASE,UAIjCkzE,WAKA37Q;4BAMF,iDAEY;0BAlTZ,SAoTAg8Q;4BAAyB3kM,QAAQykM,GAAIvzE,QAASE;4BAChD,GAD2BpxH;6BAEuB,MAFvBA,WACvBkkM,WACyCttS;;iCADzCstS;4BAIF;;;;kCAJEA;kDAIqB,IAAOI,oBAAP,OAAOA,UACd;6BAIhB;;gCATEJ;;kCAUG,IAAO/W;kCAAP,iCAAOA,YACiC;4BAF7C,eAIctxR,KAIhB,kBAJgBA,IAIF;4BAHZ;;;yCAfiC4oS,GAAIvzE,QAASE,UAI5CkzE,WAKA37Q;4BAMF,iDAGY;0BAtUZ,SAwUAi8Q,aAAelyM,KACdmrB;4BACU,IAATgnL,OAAS;4BACE;8BAAf,oBADIA;4BAAS;6BAETC;8BACF;gCAJCjnL;;kCAIuB;;;;;mCAC6B,iBANtCnrB,KAKsB5vB;mCACzB,aAAY,QADiBr2D,WAAP7S;kCACtB,UADkB4yB,GACtBrf,EACK;4BAEA;8BAAf,oBAPI03R;4BAQW;8BAAf,oBARIA;4BAQW,eACC/yR;8BAKD;gCAAf,oBAdI+yR;8BAcW,OALC/yR,MAMV;4BAHF;yCAVAgzR,0B;6BASA,YATAA,0B;6BAQF;6EAKI;0BAzVJ,eA2VkChiO,IAAM,eAANA,GAAsB;0BAAzC,SAAfiiO;4B,OAnBAH;0BAmBe,SAEfxzG,OAAQpxF,QAAQpmG,EAAE4yB,GAAGs2C;4BAIlB;yEAJkBA;6BAErB,iBACG,QAHKk9B,iBAAQpmG;4BAEhB,2BAFkB4yB,SAKZ;0BAPS;;;;;kCAhWf8iQ;;kCAMEr5K;;;;;;;;;;;;;;;;;kCA+CF36G;kCAEA8nS;kCAMAE;kCAgBAI;kCAyDAjX;kCAkCAsX;kCAsDAC;kCAKAxX;kCA+CA+X;kCAGAC;kCAiBAE;kCAmBAC;kCAoBAC;kCAmBAG;kCAEA3zG;sBAMH;;sBzD/fG1lD;sBI4HFwV;sBADAD;sBJ5HExV;sBqjBVN;;sBjH+EoB;;;mCiH9CdhkE,OAAOj7C,GAAGw4Q,eAAejnO,MAAOoxK;4BACzB,IAAL81D,KAAK,wBADGD,eAAejnO,MAAOoxK;4BACzB,+BADA3iN,GACLy4Q,KACgB;mCAIlBC,iBAAiBtrS,GAAI,UAAJA,EAA6B;mCAE9CojO,MAAOpjO,GAAS,OAATA,OAAuB;mCAE9BurS,KAAMvrS,GAAS,OAATA,OAAiB;mCAEvBozJ,MAAOpzJ,GAAS,OAATA,OAAkB;mCAEzBiqS,KAAMjqS,GAAS,OAATA,OAAsB;mCAE5B2/B,oBAAqB3/B;4BAAS,sB;4BAAA,kBjT+SRgsH,OiT/SDhsH,cAA6C;mCAElE4/B,eAAgB5/B;4BAAS,sB;4BAAA,kBjT6SHgsH,OiT7SNhsH,cAA6C;mCAE7DwrS,0BAA2BxrS,GAAS,OAATA,IAAoC;mCAE/DhB,EAAGgB,GAAS,OAATA,QAAmB;mCAEtBqnE,EAAGrnE,GAAS,OAATA,QAAmB;mCAEtByrS,SAAUzrS,GAAS,OAATA,OAAqB;mCAE/B0rS,SAAU1rS,GAAS,OAATA,OAAqB;mCAE/B2rS,sBAAuB3rS;4BACzB,aADyBA,KAxBvBsrS,iBAyBmD;;kCA/BnDz9N;kCAMAy9N;kCAEAloE;kCAEAmoE;kCAEAn4I;kCAEA62I;kCAEAtqQ;kCAEAC;kCAEA4rQ;kCAEAxsS;kCAEAqoE;kCAEAokO;kCAEAC;kCAEAC;sBAEH;;sBrjBtDG75J;sBI4HFwV;sBADAD;sBJ5HExV;sB0DVN;;sBAwHG;;sB1D7GGC;sBI4HFwV;sBADAD;sBJ5HExV;sBsjBTN;;sBAGwB;;sBtjBOlBC;sBI4HFwV;sBADAD;sBJ5HExV;sB2DVN;;sByY+EoB;;;;;;;;;;;;;sBzYzEhB;;;;;;;;sByYyEgB;uBkH9EpB;;uB3fKI;uCAmB+DpyI;0BAa1D;2BAboD8N;2BAAJD;2BAAJF;2BAAJD;2BAAJ4+R;2BAAJpjS;2BAAJqjS;2BAAJC;2BAAPC;2BAAJC;2BAAJC;2BAAJC;2BAAJC;2BAaD,iBAb0D7sS,EAAN8N;2BAYpD,iBAZ0D9N,EAAV6N;2BAWhD,iBAX0D7N,EAAd2N;2BAU5C,iBAV0D3N,EAAlB0N;2BASxC,iBAT0D1N,EAAtBssS;2BAQpC,iBAR0DtsS,EAA1BkJ;2BAOhC,iBAP0DlJ,EAA9BusS;2BAM5B,iBAN0DvsS,EAAlCwsS;2BAKrB,iBALuDxsS,EAAzCysS;2BAIjB,iBAJ0DzsS,EAA7C0sS;2BAGb,iBAH0D1sS,EAAjD2sS;2BAET,iBAF0D3sS,EAArD4sS;0BACL;6CAD0D5sS,EAAzD6sS;;;;;;;;;;;;;sBA8BP;;sB3D5CGx6J;sBI4HFwV;sBADAD;sBJ5HExV;sB4DVN;;sBwY+EoB;;;;;;;;;;;;;;sBxY1EhB;;;;;;;;sBwY0EgB;uBxYtDhB06J;uCAAgE9sS;0BAc3D;2BAdqD+sS;2BAAJC;2BAAJC;2BAAJp5N;2BAAJv0C;2BAAJD;2BAAJD;2BAAJi0C;2BAAJllE;2BAAJ++R;2BAAJC;2BAAJ3qD;2BAAJ4qD;2BAAJC;2BAcD,iBAd2DrtS,EAAN+sS;2BAarD,iBAb2D/sS,EAAVgtS;2BAYjD,iBAZ2DhtS,EAAditS;2BAW7C,iBAX2DjtS,EAAlB6zE;2BAUzC,iBAV2D7zE,EAAtBs/B;2BASrC,iBAT2Dt/B,EAA1Bq/B;2BAQjC,iBAR2Dr/B,EAA9Bo/B;2BAO7B,iBAP2Dp/B,EAAlCqzE;2BAMzB,iBAN2DrzE,EAAtCmO;2BAKrB,iBAL2DnO,EAA1CktS;2BAIjB,iBAJ2DltS,EAA9CmtS;2BAGb,iBAH2DntS,EAAlDwiP;2BAET,iBAF2DxiP,EAAtDotS;0BACL;6CAD2DptS,EAA1DqtS;;;;;;;;;;;;;;sBAgCP;;sB5D9CGh7J;sBI4HFwV;sBADAD;sBJ5HExV;sB6DVN;;sBuY+EoB;;;0BvYiEP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAEQ;;;;;2B8SjB0Cw6B;;;;;;;;;;;2B9SiB1C;;mCAmED9qD,YAtBEvkH,EAAEP;4BAC8B;gDAD9BA;6BAXLjC;6BAAEyrO;6BAAaz9K;4BACxB;8BAAG,GADMhuD,MAlCbuzO,mCA6CgB/wO,EAXYwrD;8BAIjB;;qDALUlpD,EACR9E;kCAIsC,SAJvBguD,MAAby9K;kCAAaz9K;+BAOI,wBAPjBy9K;+BAOiB,IAPnBzrO;;+BAAEyrO;+BAAaz9K,MAGlB2e;uCASoD;0BAEnD,SAmBG+lB,Y,OqLjCdo0B,QrLiCcC;0BAnBH,SAmBG3wC,QAjBF5G,GAAGF;4BAAmC,2BAAnCA,IAAoB,uBAAvBE;4BAAuB,wCAA6B;0BAFrD,SAmBGotK,UAbAp3O;4BACkB,2BADlBA;4BACJ,iDAAoC;0BAPnC,SAmBGs3O,UAVAl3O;4B,UAAAA;8BAGR,IADMtD,EAFEsD;8BAGL,2BAAW,uBADRtD;4BAGN,YAA2B;0BAvDjC;wC8SxByDgvK;0B9SwBzD;;;;;;;;;;;;;;;+CjDUNsV;;2BiDVM2rH;2DAAsD;mCAAtDv/H;;qDiHhDEuR,cjHgDFnlK;;;;4BAAsD,OAAtD5Z,CAAsD;mCAAtDytK;;;;;;;4BAAsD,OAAtDztK,CAAsD;8BAAtD0tK;;;;;;qEiHhDEmR,cjHgDFpuH;mFAAsD;mCAAtD68G;;;;;4CiHhDEwR,ejHgDFllK;+DAAsD;;2BAAtD2zJ;;2BAJY0/H;;;;oFA6Db;mCA7DaC;;;;;;;;;;wFA6Db;4BA7Da;;+FA6Db;mCAKCG,iBAAkBx2R;4BAAY,wBAAZA,UAAsC;0BAElD,4BAEC;mCAGPs5H,IAAI1zI,GAAiB,gCAAjBA,GAHJwvE,KAG0C;0BAHnC,SAKP42J,KAAKpmO,GAAiB,gCAAjBA,GALLwvE,KAK4C;0BALrC,SAOPqvJ,QAAQt7N;4BAEF,IAAJV,EAAI,gBAFEU;4BAGgB,cAnFxB+tO,aAmFwB,qBADtBzuO,GACyC;0BAVpC,SAYP+9N,QAAQnC;4BACV,eAA2C1sL,IAAI5xC;8BACjC,IAAN4rD,MAAM,iBAD6Bha;8BAC7B,OADiC5xC,EAEjC,iBADN4rD,MAhBN7hD,KAgBM6hD,KAC0B;4BAFxB,gCADA0yK,IAZRjvJ,WAekC;;;;;;;;;;8BAG5B,IAAJjsE,EAAI;8BACD;iDADHA,EACY,iBAAW,iBADvBA;;4DACsC;;;;;;;;;;8BAGlC;;+BAEN;;;mC8SlHyDqsK;;;;;;;;kC9SoHtD;;qC8SpHsDA;;;;;;;;oC9SiHhDriG;+BACT;;+BADSvsB;;2DAAe;;uCAAfkD,iDAGwC;mCAW/C5+B,IAAI/hB,EAAGmsH,OAAQ,wBAAXnsH,EAAGmsH,MAAuB;mCAE9BvlH,IAAI5G,EAAGmsH,OAAQ,wBAAXnsH,EAAGmsH,MAAuB;mCAI9Bv5C,IAAI5yE,EAAGmsH,OAAQ,wBAAXnsH,EAAGmsH,MAAuB;mCAE9Bk2I,KAAMirC,KAAKttS,GAAI,wBAATstS,KAAKttS,EAAe;yCAR1B+hB,IAEAnb,UAIAgsE,IAEAyvL;mCAGF/mN,GAAG77C,EAAEO,EAAEmsH,OAAQ,kBAAZ1sH,EAAEO,EAAEmsH,MAAkB;;0BAEhB,SAATrpD,oB,OAFAxnB;0BAES;0BAEA,SAATspB,sB,OAJAtpB;0BAIS;0BAEA,SAAT6gE,sB,OANA7gE;;;;;;;;;;8BASM,IAAJ7+C,EAAI;8BACA,wBADJA,EACI,QAAS,QADbA,IACyB;;;;;;;;;;8BAG7B,eAIUy+N;gCACiC;4CAAS,QAD1CA;iCACgB,aADhBA;iCACgB;;iCAAXz9K;;kC,O8HqNb06D,a5BlTAN;yClG6FaoS;kCAAK,uCAAL4jD,YAAS;;yCAATntH,qDAAkD;8BAJ/D;;;;;;;;;0DAvIAqtL,qByG2gDEp4E;6CzGh4C+D;;;;oCAxEnDyhF;;oCA5DdqK;;;oC8SxByDp1E;;;;;;;;oC9SoF3Cz7F;;;;;qCA5Ddy8F;;;;;;;;mCAJY6/H;kCAgEE91D;;;;;kC8SpF2C/qE;;;;;;;;kC9SoF3C9qD;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCArEd9/G;kCAuEA4rS;kCAEA1mS;kCAEAslE;kCAGAkkE;kCAEA0yF;kCA9EAkL;kCAgFAzS;kCAKA+B;;;;;;kCAsCAv6J;kCAEA8B;kCAEAu3C;sBAaH;;sB7DnRG21B;sBI4HFwV;sBADAD;sBJ5HExV;sB8DTN;;sBsY8EoB;uBtY9EpB;iCAOE34B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4B0HugBM;qC1HvgBN;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gEAmBiB;uBA1BnB;iCAyDE4zD;;;;;8BAAyB,IAAhBgB,MAAT9kH,SAAyB,uBAAhB8kH;;oCAAThB;4CAAS;0BAA4C,IAAxBgC,MAA7B9lH;0BAAqD,uBAAxB8lH,MACG;uBA1DlC;iCA2EE4+H;0BAAsB,GAAtBz9H,gBAAsB;2CAAtBy9H;0BAAsB,eAAY,UAAlCz9H,mBAAsB3wK,CAAI;uBA3E5B;;8BAsG0BoxB,aAALI,2BAAKJ;uBAtG1B;iCAuJIm9Q;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4B0HuXI;qC1HvXJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kGA8JiB;sDA9JjB54J;;;;;;;;;gDAC4B;6EAD5Bk5J;;kDAC4B;;;;;;wDAAI;;;yEADhCpgF,KACgCx5E;yEADhCs5J,KACgCn6J;yDAAJ+6J,aAAIj6J;;;;oDAAJi6J;qDAAI,yBADhC1tP,YAC4BytP;;;+CAAa;4EADzCL;;iDACyC;;;;;;uDAAI;;;wEAD7CpgF,KAC6Cr4E;wEAD7Cm4J,KAC6CtxJ;wDAAJoyJ,aAAIh5J;;;;mDAAJg5J;oDAAI,yBAD7C5tP,YACyC2tP;;;8CAAa;2EADtDP;;gDACsD;;sEADtDpgF,KACsD6gF;;;6CAAvC;0EADfT;;+CACe;;;;;;qDAAI;;;uEADnBpgF,KACmBp5E;uEADnBk5J,KACmBlxJ;sDAAJoyJ,aAAIn6J;;;;iDAAJm6J;kDAAI,yBADnBhuP,YACe+tP;;;4CAA+C;yEAD9DX;;8CAC8D;;oEAD9DpgF,KAC8DihF;;2CAD9D;;;;;;;;;wCACejB;kCADf,MAC4BC;kCAD5B,MACyCC;kCADzC,MACsDj6G;kCADtD,MAC8Dk6G;;;;oCAARz5G;oCAAb06G;oCAAbC;oCAAbC;qDAAaD,QAAaD,QAAa16G,QAAQy6G;iCAD9D;;;;oDACenB;;qDAAaC;;sDAAaC;;uDAAaj6G;0DAAQk6G;;;gCAD9DoB;gCAGkBC;gCAHlBC;;;;;;;;;;;;;;;;;;4CAGkB;wEAHlBA;;;;+DAGkBt7G,aAHlBz3L;;mDAGkBy3L,aAHlB;;+CAGkBiF;gD6H6ChB/+E;kE,OAAAA,c7HhDFyzL;kDAGkB35G;;2CAHlB;;;;;;;;2CAGkBq7G;iCAHlB,cAGkBG,qBAHlB,UAGkBA;iCAHlB;qEAGkBH;;;gCAHlBI;gCAKQC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCAZRC;;;;;;;;;;;;;;;;;;;;;;;kGA8JiB;sDA9JjBn7J;;;;;;;;;;;;mDAYQ;gFAZRm7J;;qDAYQ;;2EAZRvC,KAYQ4C;;;kDAFA;+EAVRL;;oDAUQ;;0EAVRvC,KAUQ8C;;;iDADA;8EATRP;;mDASQ;;yEATRvC,KASQgD;;;gDAFA;6EAPRT;;kDAOQ;;;;;;wDAAK;;;yEAPbvC,KAOazuS;yEAPbyuS,KAOap9O;yDAALugP,aAAKvuL;;;;oDAALuuL;qDAAK,yBAPbjwP,YAOQgwP;;;+CADA;4EANRX;;iDAMQ;;;;;;uDAAK;;;wEANbvC,KAMah4J;wEANbg4J,KAMa95J;wDAALm9J,aAAKp7J;;;;mDAALo7J;oDAAK,yBANbnwP,YAMQkwP;;;8CADA;2EALRb;;gDAKQ;;;;;;sDAAK;;;uEALbvC,KAKaz5J;uEALby5J,KAKax4J;uDAAL+7J,aAAK/8J;;;;kDAAL+8J;mDAAK,yBALbrwP,YAKQowP;;;6CAMA;0EAXRf;;+CAWQ;;qEAXRvC,KAWQwD;;;4CAHA;yEARRjB;;8CAQQ;;oEARRvC,KAQQ0D;;2CARR;;;;;;;;;wCAKQ3B;kCALR,MAMQC;kCANR,MAOQC;kCAPR,MAQQC;kCARR,MASQC;kCATR,MAUQC;kCAVR,MAWQC;kCAXR,MAYQC;;;;;;;;;;;;;;;;;;;oCADAuB;oCADAC;oCADAC;oCADAC;oCADAC;oCADAC;oCADAC;;;2CACAD;2CACAD;2CACAD;2CACAD;2CACAD;2CACAD;2CACAD;iCAZR;;;;oDAKQ7B;;qDACAC;;sDACAC;;uDACAC;;wDACAC;;yDACAC;;0DACAC;6DACAC;;;gCAZR8B;gCAckBC;gCAdlBC;;;;;;;;;;;;;;;;;;4CAckB;wEAdlBA;;;;iEAckB/jD,cAdlB53J;;;gDAckB43J;iDAdlB;;+CAckBa;gD6HkChB70I;kE,OrInMF21K,aQmJA8d;kDAckBz/C;;2CAdlB;;;;;;;;2CAckB8jD;iCAdlB;uCAckBI,uBAdlB,UAckBA;iCAdlB;qEAckBJ;;;gCAdlBK;gCAgBQC;gCAAoCC;gCAASC;gCAASC;gCAhB9DC;;;;;;;;;;;;;;;;;;;;;;;kGA8JiB;sDA9JjB39J;;;;;;;;+CAgBqD;2EAhBrD29J;;iDAgBqD;;uEAhBrD/E,KAgBqDoF;;;8CAAT;0EAhB5CL;;gDAgB4C;;sEAhB5C/E,KAgB4CqF;;;6CAApC;yEAhBRN;;+CAgBQ;;;iD6HgCNx4L;4DhIlMFlB;;;;;;;;;;;;;;;;;;;;;uD;uDAAA;;;;;;;;;;iE6HygBI;mE7HzgBJ;;;;;;;;;0HAegC;8EAfhC+7B;;;;;;;;;;;;;;2EAEI;qGAFJF;;6EAEI;;gGGgJJ84J,KHhJI15G;;;0EAKA;oGAPJp/C;;4EAOI;;iGG2IJ84J,KH3IIz5G;;;yEAHA;mGAJJr/C;;2EAII;;gGG8IJ84J,KH9IIv5G;;;wEAHA;kGADJv/C;;0EACI;;+FGiJJ84J,KHjJI35G;;;uEAKA;iGANJn/C;;yEAMI;;8FG4IJ84J,KH5IIz0G;;;sEAHA;gGAHJrkD;;wEAGI;;6FG+IJ84J,KH/IIv0G;;;qEAMA;+FATJvkD;;uEASI;;4FGyIJ84J,KHzIIr0G;;;;;;;;;;;0EADA;oGARJzkD;;4EAQI;;iGG0IJ84J,KH1II30G;;;yEAHA;mGALJnkD;;2EAKI;;gGG6IJ84J,KH7II76F;;;wEAQA;kGAbJj+D;;0EAaI;;+FGqIJ84J,KHrII36F;;;uEADA;iGAZJn+D;;yEAYI;;8FGsIJ84J,KHtIIz6F;;;sEADA;gGAXJr+D;;wEAWI;;8FGuIJ84J,KHvIIv6F;;;qEADA;+FAVJv+D;;uEAUI;;6FGwIJ84J,KHxIIr6F;;+EAVJ;;;;kEAegC;qDAfhC;;;;;;4DACI8/F;sDADJ,MAEIC;sDAFJ,MAGIC;sDAHJ,MAIIC;sDAJJ,MAKId;sDALJ,MAMIe;sDANJ,MAOIC;sDAPJ,MAQIC;sDARJ,MASIC;sDATJ,MAUIC;sDAVJ,MAWIC;sDAXJ,MAYIC;sDAZJ,MAaIC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wDADAE;wDADAC;wDADAC;wDADAC;wDADAC;wDADAC;wDADAC;wDADAC;wDADAC;wDADAC;wDADAC;wDADAC;;;+DACAD;+DACAD;+DACAD;+DACAD;+DACAD;+DACAD;+DACAD;+DACAD;+DACAD;+DACAD;+DACAD;+DACAD;qDAbJ;;;;wEACIZ;;yEACAC;;0EACAC;;2EACAC;;4EACAd;;6EACAe;;8EACAC;;+EACAC;;gFACAC;;iFACAC;;kFACAC;;mFACAC;sFACAC;mDGqJIb;;;4CAAsD;wEAhB9DR;;8CAgB8D;;oEAhB9D/E,KAgB8DkH;;2CAhB9D;;;;;;;;;wCAgBQvC;kCAhBR,MAgB4CC;kCAhB5C,MAgBqDC;kCAhBrD,MAgB8DC;;;;oCAATsC;oCAATC;oCAApCC;2DAAoCD,SAASD,SAASP;iCAhB9D;;;;oDAgBQlC;;qDAAoCC;;sDAASC;yDAASC;;;gCAhB9DyC;gCAiBuBC;gCAjBvBC;;;;;;;;;;;;;;;;;;4CAiBuB;yEAjBvBA;;;;iEAiBuBG,cAjBvB9+M;;;gDAiBuB8+M;iDAjBvB;;+CAiBuBC;gD6H+BrBt7L;2D/HnMFlB;;;;;;;;;;;;;;;;;;;;;;sD;sDAAA;;;;;;;;;;gE4H0gBI;kE5H1gBJ;;;;;;;;;yHAgBgC;6EAhBhC+7B;;;;;;;;;;;;;;0EAcI;oGAdJF;;4EAcI;;+FEqIJ84J,KFrII15G;;;yEADA;mGAbJp/C;;2EAaI;;gGEsIJ84J,KFtIIz5G;;;wEADA;kGAZJr/C;;0EAYI;;+FEuIJ84J,KFvIIv5G;;;uEADA;iGAXJv/C;;yEAWI;;8FEwIJ84J,KFxII35G;;;sEADA;gGAVJn/C;;wEAUI;;6FEyIJ84J,KFzIIz0G;;;qEADA;+FATJrkD;;uEASI;;4FE0IJ84J,KF1IIv0G;;;oEADA;8FARJvkD;;sEAQI;;2FE2IJ84J,KF3IIr0G;;;;;;;;;;;;0EADA;oGAPJzkD;;4EAOI;;iGE4IJ84J,KF5II30G;;;yEALA;mGAFJnkD;;2EAEI;;gGEiJJ84J,KFjJI76F;;;wEADA;kGADJj+D;;0EACI;;+FEkJJ84J,KFlJI36F;;;uEAKA;iGANJn+D;;yEAMI;;8FE6IJ84J,KF7IIz6F;;;sEAFA;gGAJJr+D;;wEAII;;8FE+IJ84J,KF/IIv6F;;;qEACA;+FALJv+D;;uEAKI;;6FE8IJ84J,KF9IIr6F;;;oEAFA;8FAHJz+D;;sEAGI;;4FEgJJ84J,KFhJIn6F;;8EAHJ;;;;iEAgBgC;oDAhBhC;;;;;;2DACIiiG;qDADJ,MAEIC;qDAFJ,MAGIC;qDAHJ,MAIIC;qDAJJ,MAKIC;qDALJ,MAMIC;qDANJ,MAOIC;qDAPJ,MAQIC;qDARJ,MASIC;qDATJ,MAUIC;qDAVJ,MAWIC;qDAXJ,MAYIC;qDAZJ,MAaIC;qDAbJ,MAcIC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uDADAE;uDADAC;uDADAC;uDADAC;uDADAC;uDADAC;uDADAC;uDADAC;uDADAC;uDADAC;uDADAC;uDADAC;uDADAC;;;8DACAD;8DACAD;8DACAD;8DACAD;8DACAD;8DACAD;8DACAD;8DACAD;8DACAD;8DACAD;8DACAD;8DACAD;8DACAD;oDAdJ;;;;uEACId;;wEACAC;;yEACAC;;0EACAC;;2EACAC;;4EACAC;;6EACAC;;8EACAC;;+EACAC;;gFACAC;;iFACAC;;kFACAC;;mFACAC;sFACAC;kDEsJmBf;;2CAjBvB;;;;;;;;2CAiBuBJ;iCAjBvB;uCAiBuBkC,uBAjBvB,UAiBuBA;iCAjBvB;qEAiBuBlC;;;gCAjBvBmC;gCAmBQC;gCAASC;gCAASC;gCAASC;gCAASC;gCAASC;gCAASC;gCAnB9DC;;;;;;;;;;;;;;;;;;;;;;;kGA8JiB;sDA9JjB/iK;;;;;;;;;;;kDAmB8D;8EAnB9D+iK;;oDAmB8D;;yEAnB9DnK,KAmB8Dv0G;;;iDAAT;6EAnBrD0+G;;mDAmBqD;;wEAnBrDnK,KAmBqDr0G;;;gDAAT;4EAnB5Cw+G;;kDAmB4C;;uEAnB5CnK,KAmB4C30G;;;+CAAT;2EAnBnC8+G;;iDAmBmC;;sEAnBnCnK,KAmBmC76F;;;8CAAT;0EAnB1BglG;;gDAmB0B;;qEAnB1BnK,KAmB0B36F;;;6CAAT;yEAnBjB8kG;;+CAmBiB;;oEAnBjBnK,KAmBiBz6F;;;4CAAT;wEAnBR4kG;;8CAmBQ;;mEAnBRnK,KAmBQv6F;;2CAnBR;;;;;;;;;wCAmBQmkG;kCAnBR,MAmBiBC;kCAnBjB,MAmB0BC;kCAnB1B,MAmBmCC;kCAnBnC,MAmB4CC;kCAnB5C,MAmBqDC;kCAnBrD,MAmB8DC;;;;;;;;;;;;;;;;;oCAATK;oCAATC;oCAATC;oCAATC;oCAATC;oCAATC;;;2CAASD;2CAASD;2CAASD;2CAASD;2CAASD;2CAASD;iCAnB9D;;;;oDAmBQV;;qDAASC;;sDAASC;;uDAASC;;wDAASC;;yDAASC;4DAASC;;;gCAnB9DW;gCAqBQC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCAEAC;gCArCRC;;;;mC;mCAAA;;;;;;;;;;6C0HuXI;+C1HvXJ;;;;;;;;;sGA8JiB;0DA9JjB1kK;;;;;;;;;;;;;;;wDA2BQ;oFA3BR0kK;;0DA2BQ;;6EA3BR9L,KA2BQ15G;;;uDADA;mFA1BRwlH;;yDA0BQ;;8EA1BR9L,KA0BQz5G;;;sDADA;kFAzBRulH;;wDAyBQ;;6EAzBR9L,KAyBQv5G;;;qDADA;iFAxBRqlH;;uDAwBQ;;4EAxBR9L,KAwBQ35G;;;oDADA;gFAvBRylH;;sDAuBQ;;2EAvBR9L,KAuBQz0G;;;mDADA;+EAtBRugH;;qDAsBQ;;0EAtBR9L,KAsBQv0G;;;kDAaA;8EAnCRqgH;;oDAmCQ;;yEAnCR9L,KAmCQr0G;;;iDADA;6EAlCRmgH;;mDAkCQ;;wEAlCR9L,KAkCQ30G;;;;;;;;;;;;;wDADA;oFAjCRygH;;0DAiCQ;;+EAjCR9L,KAiCQ76F;;;uDADA;mFAhCR2mG;;yDAgCQ;;8EAhCR9L,KAgCQ36F;;;sDADA;kFA/BRymG;;wDA+BQ;;6EA/BR9L,KA+BQz6F;;;qDADA;iFA9BRumG;;uDA8BQ;;6EA9BR9L,KA8BQv6F;;;oDADA;gFA7BRqmG;;sDA6BQ;;4EA7BR9L,KA6BQr6F;;;mDADA;+EA5BRmmG;;qDA4BQ;;2EA5BR9L,KA4BQn6F;;;kDAPA;8EArBRimG;;oDAqBQ;;0EArBR9L,KAqBQj6F;;;iDAgBA;6EArCR+lG;;mDAqCQ;;yEArCR5rF,KAqCQja;;2DArCR;;;;8CA8JiB;+BA9JjB;;;;;;;sCAqBQ6kG;gCArBR,MAsBQC;gCAtBR,MAuBQC;gCAvBR,MAwBQC;gCAxBR,MAyBQC;gCAzBR,MA0BQC;gCA1BR,MA2BQC;gCA3BR,MA4BQC;gCA5BR,MA6BQC;gCA7BR,MA8BQC;gCA9BR,MA+BQC;gCA/BR,MAgCQC;gCAhCR,MAiCQC;gCAjCR,MAkCQC;gCAlCR,MAmCQC;gCAnCR,MAqCQC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAFAK;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;;;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCAEAD;+BArCR;;;;kDAqBQnB;;mDACAC;;oDACAC;;qDACAC;;sDACAC;;uDACAC;;wDACAC;;yDACAC;;0DACAC;;2DACAC;;4DACAC;;6DACAC;;8DACAC;;+DACAC;;gEACAC;mEAEAC;;;gCArCR7+C;gCA0CQigD;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACeC;gCACfC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCAvER3hD;;;;mC;mCAAA;;;;;;;;;;6C0HuXI;+C1HvXJ;;;;;;;;;sGA8JiB;0DA9JjB/lH;;;;;;;;;;;;;;;;;0DAgDQ;sFAhDR+lH;;4DAgDQ;;+EAhDR6yC,KAgDQ15G;;;yDADA;qFA/CR6mE;;2DA+CQ;;gFA/CR6yC,KA+CQz5G;;;wDADA;oFA9CR4mE;;0DA8CQ;;+EA9CR6yC,KA8CQv5G;;;uDADA;mFA7CR0mE;;yDA6CQ;;8EA7CR6yC,KA6CQ35G;;;sDAYe;kFAzDvB8mE;;wDAyDuB;;6EAzDvB6yC,KAyDuBz0G;;;qDADf;iFAxDR4hE;;uDAwDQ;;4EAxDR6yC,KAwDQv0G;;;oDADA;gFAvDR0hE;;sDAuDQ;;2EAvDR6yC,KAuDQr0G;;;;;;;;;;;;0DADA;sFAtDRwhE;;4DAsDQ;;iFAtDR6yC,KAsDQ30G;;;yDADA;qFArDR8hE;;2DAqDQ;;gFArDR6yC,KAqDQ76F;;;wDADA;oFApDRgoD;;0DAoDQ;;+EApDR6yC,KAoDQ36F;;;uDADA;mFAnDR8nD;;yDAmDQ;;8EAnDR6yC,KAmDQz6F;;;sDADA;kFAlDR4nD;;wDAkDQ;;8EAlDR6yC,KAkDQv6F;;;qDAqBA;iFAvER0nD;;uDAuEQ;;6EAvER6yC,KAuEQr6F;;;oDADA;gFAtERwnD;;sDAsEQ;;4EAtER6yC,KAsEQn6F;;;;kDADA;8EArERsnD;;oDAqEQ;;0EArER6yC,KAqEQj6F;;;;;;;;;;;;;;;;0DADA;sFApERonD;;4DAoEQ;;kFApER6yC,KAoEQ/5F;;;yDADA;qFAnERknD;;2DAmEQ;;iFAnER6yC,KAmEQ75F;;;wDADA;oFAlERgnD;;0DAkEQ;;gFAlER6yC,KAkEQ/6F;;;uDADA;mFAjERkoD;;yDAiEQ;;+EAjER6yC,KAiEQv/C;;;sDADA;kFAhER0M;;wDAgEQ;;8EAhER6yC,KAgEQr/C;;;qDALA;iFA3DRwM;;uDA2DQ;;6EA3DR6yC,KA2DQn/C;;;oDADA;gFA1DRsM;;sDA0DQ;;4EA1DR6yC,KA0DQj/C;;;mDATA;+EAjDRoM;;qDAiDQ;;2EAjDR6yC,KAiDQ/+C;;;;;;;;;;;;yDALA;qFA5CRkM;;2DA4CQ;;iFA5CR6yC,KA4CQ7+C;;;wDAFA;oFA1CRgM;;0DA0CQ;;gFA1CR6yC,KA0CQ3+C;;;uDAqBA;mFA/DR8L;;yDA+DQ;;+EA/DR6yC,KA+DQz/C;;;sDADA;kFA9DR4M;;wDA8DQ;;8EA9DR6yC,KA8DQmF;;;qDAnBA;iFA3CRh4C;;uDA2CQ;;6EA3CR6yC,KA2CQoF;;;oDAkBA;gFA7DRj4C;;sDA6DQ;;4EA7DR6yC,KA6DQqF;;;mDADA;+EA5DRl4C;;qDA4DQ;;2EA5DR6yC,KA4DQuF;;;6DA5DR;;;;8CA8JiB;+BA9JjB;;;;;;;sCA0CQ0H;gCA1CR,MA2CQC;gCA3CR,MA4CQC;gCA5CR,MA6CQC;gCA7CR,MA8CQC;gCA9CR,MA+CQC;gCA/CR,MAgDQC;gCAhDR,MAiDQC;gCAjDR,MAkDQC;gCAlDR,MAmDQC;gCAnDR,MAoDQC;gCApDR,MAqDQC;gCArDR,MAsDQC;gCAtDR,MAuDQC;gCAvDR,MAwDQC;gCAxDR,MAyDuBC;gCAzDvB,MA0DQC;gCA1DR,MA2DQC;gCA3DR,MA4DQC;gCA5DR,MA6DQC;gCA7DR,MA8DQC;gCA9DR,MA+DQC;gCA/DR,MAgEQC;gCAhER,MAiEQC;gCAjER,MAkEQC;gCAlER,MAmEQC;gCAnER,MAoEQC;gCApER,MAqEQC;gCArER,MAsEQC;gCAtER,MAuEQC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCADAE;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADeC;kCADfC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;;;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACeD;yCACfD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;+BAvER;;;;kDA0CQ9B;;mDACAC;;oDACAC;;qDACAC;;sDACAC;;uDACAC;;wDACAC;;yDACAC;;0DACAC;;2DACAC;;4DACAC;;6DACAC;;8DACAC;;+DACAC;;gEACAC;;iEACeC;;kEACfC;;mEACAC;;oEACAC;;qEACAC;;sEACAC;;uEACAC;;wEACAC;;yEACAC;;0EACAC;;2EACAC;;4EACAC;;6EACAC;;8EACAC;iFACAC;;;gCAvER9nK;gCA0EQ6pK;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCAxFRzqK;;;;mC;mCAAA;;;;;;;;;;6C0HuXI;+C1HvXJ;;;;;;;;;sGA8JiB;0DA9JjBE;;;;;;;;;;;;;;;wDAwFQ;kFAxFRF;;0DAwFQ;;6EAxFR84J,KAwFQ15G;;;uDADA;iFAvFRp/C;;yDAuFQ;;8EAvFR84J,KAuFQz5G;;;sDADA;gFAtFRr/C;;wDAsFQ;;6EAtFR84J,KAsFQv5G;;;qDADA;+EArFRv/C;;uDAqFQ;;4EArFR84J,KAqFQ35G;;;oDATA;8EA5ERn/C;;sDA4EQ;;2EA5ER84J,KA4EQz0G;;;mDAQA;6EApFRrkD;;qDAoFQ;;0EApFR84J,KAoFQv0G;;;kDADA;4EAnFRvkD;;oDAmFQ;;yEAnFR84J,KAmFQr0G;;;iDADA;2EAlFRzkD;;mDAkFQ;;wEAlFR84J,KAkFQ30G;;;;;;;;;;;;uDADA;iFAjFRnkD;;yDAiFQ;;8EAjFR84J,KAiFQ76F;;;sDANA;gFA3ERj+D;;wDA2EQ;;6EA3ER84J,KA2EQ36F;;;qDAKA;+EAhFRn+D;;uDAgFQ;;4EAhFR84J,KAgFQz6F;;;oDADA;8EA/ERr+D;;sDA+EQ;;4EA/ER84J,KA+EQv6F;;;mDADA;6EA9ERv+D;;qDA8EQ;;2EA9ER84J,KA8EQr6F;;;kDADA;4EA7ERz+D;;oDA6EQ;;0EA7ER84J,KA6EQn6F;;;iDAHA;2EA1ER3+D;;mDA0EQ;;yEA1ER84J,KA0EQj6F;;2DA1ER;;;;8CA8JiB;+BA9JjB;;;;;;sCA0EQ8qG;gCA1ER,MA2EQC;gCA3ER,MA4EQC;gCA5ER,MA6EQC;gCA7ER,MA8EQC;gCA9ER,MA+EQC;gCA/ER,MAgFQC;gCAhFR,MAiFQC;gCAjFR,MAkFQC;gCAlFR,MAmFQC;gCAnFR,MAoFQC;gCApFR,MAqFQC;gCArFR,MAsFQC;gCAtFR,MAuFQC;gCAvFR,MAwFQC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCADAE;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;;;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;+BAxFR;;;;kDA0EQf;;mDACAC;;oDACAC;;qDACAC;;sDACAC;;uDACAC;;wDACAC;;yDACAC;;0DACAC;;2DACAC;;4DACAC;;6DACAC;;8DACAC;;+DACAC;kEACAC;;;gCAxFRgB;gCA2FQC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACmBC;gCACnBC;gCACAC;gCACAxoH;gCAtGRyoH;;;;;;;;;;;;;;;;;;;;;;;kGA8JiB;sDA9JjBnsK;;;;;;;;;;;;;kDAsGQ;8EAtGRmsK;;oDAsGQ;;0EAtGRrzF,KAsGQra;;;iDAPA;6EA/FR0tG;;mDA+FQ;;yEA/FRvT,KA+FQj6F;;;gDADA;4EA9FRwtG;;kDA8FQ;;wEA9FRvT,KA8FQ/5F;;;+CAEA;2EAhGRstG;;iDAgGQ;;uEAhGRvT,KAgGQ75F;;;8CAJA;0EA5FRotG;;gDA4FQ;;sEA5FRvT,KA4FQ/6F;;;6CADA;yEA3FRsuG;;+CA2FQ;;qEA3FRvT,KA2FQv/C;;;;;;;;;;;kDAEA;8EA7FR8yD;;oDA6FQ;;0EA7FRvT,KA6FQr/C;;;iDAQA;6EArGR4yD;;mDAqGQ;;yEArGRrzF,KAqGQ2gC;;;gDADA;4EApGR0yD;;kDAoGQ;;wEApGRrzF,KAoGQ6gC;;;+CADmB;2EAnG3BwyD;;iDAmG2B;;uEAnG3BrzF,KAmG2B+gC;;;8CAFnB;0EAjGRsyD;;gDAiGQ;;sEAjGRvT,KAiGQ7+C;;;6CACA;yEAlGRoyD;;+CAkGQ;;qEAlGRvT,KAkGQ3+C;;wDAlGR;;;;;;;;;;wCA2FQuxD;kCA3FR,MA4FQC;kCA5FR,MA6FQC;kCA7FR,MA8FQC;kCA9FR,MA+FQC;kCA/FR,MAgGQC;kCAhGR,MAiGQC;kCAjGR,MAkGQC;kCAlGR,MAmG2BC;kCAnG3B,MAoGQC;kCApGR,MAqGQC;kCArGR,MAsGQxoH;;;;;;;;;;;;;;;;;;;;;;;;;;;oCADA4oH;oCADAC;oCADmBC;oCADnBC;oCADAC;oCADAC;oCADAC;oCADAC;oCADAC;oCADAC;oCADAC;;;2CACAD;2CACAD;2CACAD;2CACAD;2CACAD;2CACAD;2CACAD;2CACmBD;2CACnBD;2CACAD;2CACAvnH;iCAtGR;;;;oDA2FQymH;;qDACAC;;sDACAC;;uDACAC;;wDACAC;;yDACAC;;0DACAC;;2DACAC;;4DACmBC;;6DACnBC;;8DACAC;iEACAxoH;;;gCAtGRupH;gCAyGQC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACmBC;gCACnBC;gCACAC;gCACAC;gCAvIRC;;;;mC;mCAAA;;;;;;;;;;6C0HuXI;+C1HvXJ;;;;;;;;;sGA8JiB;0DA9JjBjvK;;;;;;;;;;;;;;;;;;2DA8GQ;uFA9GRivK;;6DA8GQ;;gFA9GRrW,KA8GQ15G;;;0DADA;sFA7GR+vH;;4DA6GQ;;iFA7GRrW,KA6GQz5G;;;yDADA;qFA5GR8vH;;2DA4GQ;;gFA5GRrW,KA4GQv5G;;;wDAIA;oFAhHR4vH;;0DAgHQ;;+EAhHRrW,KAgHQ35G;;;uDADA;mFA/GRgwH;;yDA+GQ;;8EA/GRrW,KA+GQz0G;;;sDAKA;kFApHR8qH;;wDAoHQ;;6EApHRrW,KAoHQv0G;;;qDADA;iFAnHR4qH;;uDAmHQ;;4EAnHRrW,KAmHQr0G;;;oDADA;gFAlHR0qH;;sDAkHQ;;2EAlHRrW,KAkHQ30G;;;;;;;;;;;;0DADA;sFAjHRgrH;;4DAiHQ;;iFAjHRrW,KAiHQ76F;;;yDAIA;qFArHRkxG;;2DAqHQ;;gFArHRrW,KAqHQ36F;;;wDAEA;oFAvHRgxG;;0DAuHQ;;+EAvHRrW,KAuHQz6F;;;uDADA;mFAtHR8wG;;yDAsHQ;;+EAtHRrW,KAsHQv6F;;;sDAiBA;kFAvIR4wG;;wDAuIQ;;8EAvIRn2F,KAuIQva;;;qDADA;iFAtIR0wG;;uDAsIQ;;6EAtIRn2F,KAsIQra;;;oDADA;gFArIRwwG;;sDAqIQ;;4EArIRn2F,KAqIQna;;;;kDA1BA;8EA3GRswG;;oDA2GQ;;0EA3GRrW,KA2GQ/5F;;;;;;;;;;;;;;;;0DADA;sFA1GRowG;;4DA0GQ;;kFA1GRrW,KA0GQ75F;;;yDADA;qFAzGRkwG;;2DAyGQ;;iFAzGRrW,KAyGQ/6F;;;wDA2BmB;oFApI3BoxG;;0DAoI2B;;gFApI3Bn2F,KAoI2BugC;;;uDADnB;mFAnIR41D;;yDAmIQ;;+EAnIRrW,KAmIQr/C;;;sDADA;kFAlIR01D;;wDAkIQ;;8EAlIRrW,KAkIQn/C;;;qDADA;iFAjIRw1D;;uDAiIQ;;6EAjIRrW,KAiIQj/C;;;oDADA;gFAhIRs1D;;sDAgIQ;;4EAhIRrW,KAgIQ/+C;;;mDADA;+EA/HRo1D;;qDA+HQ;;2EA/HRrW,KA+HQ7+C;;;;;;;;;;;;yDADA;qFA9HRk1D;;2DA8HQ;;iFA9HRrW,KA8HQ3+C;;;wDADA;oFA7HRg1D;;0DA6HQ;;gFA7HRrW,KA6HQz/C;;;uDADA;mFA5HR81D;;yDA4HQ;;+EA5HRrW,KA4HQmF;;;sDADA;kFA3HRkR;;wDA2HQ;;8EA3HRrW,KA2HQoF;;;qDADA;iFA1HRiR;;uDA0HQ;;6EA1HRrW,KA0HQqF;;;oDADA;gFAzHRgR;;sDAyHQ;;4EAzHRrW,KAyHQuF;;;mDADA;+EAxHR8Q;;qDAwHQ;;2EAxHRrW,KAwHQkH;;;6DAxHR;;;;8CA8JiB;+BA9JjB;;;;;;;sCAyGQoN;gCAzGR,MA0GQC;gCA1GR,MA2GQC;gCA3GR,MA4GQC;gCA5GR,MA6GQC;gCA7GR,MA8GQC;gCA9GR,MA+GQC;gCA/GR,MAgHQC;gCAhHR,MAiHQC;gCAjHR,MAkHQC;gCAlHR,MAmHQC;gCAnHR,MAoHQC;gCApHR,MAqHQC;gCArHR,MAsHQC;gCAtHR,MAuHQC;gCAvHR,MAwHQC;gCAxHR,MAyHQC;gCAzHR,MA0HQC;gCA1HR,MA2HQC;gCA3HR,MA4HQC;gCA5HR,MA6HQC;gCA7HR,MA8HQC;gCA9HR,MA+HQC;gCA/HR,MAgIQC;gCAhIR,MAiIQC;gCAjIR,MAkIQC;gCAlIR,MAmIQC;gCAnIR,MAoI2BC;gCApI3B,MAqIQC;gCArIR,MAsIQC;gCAtIR,MAuIQC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCADAK;kCADAC;kCADmBC;kCADnBC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;;;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACmBD;yCACnBD;yCACAD;yCACAD;+BAvIR;;;;kDAyGQlC;;mDACAC;;oDACAC;;qDACAC;;sDACAC;;uDACAC;;wDACAC;;yDACAC;;0DACAC;;2DACAC;;4DACAC;;6DACAC;;8DACAC;;+DACAC;;gEACAC;;iEACAC;;kEACAC;;mEACAC;;oEACAC;;qEACAC;;sEACAC;;uEACAC;;wEACAC;;yEACAC;;0EACAC;;2EACAC;;4EACAC;;6EACmBC;;8EACnBC;;+EACAC;kFACAC;;;gCAvIR7oD;gCA2IQgrD;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACAC;gCACmBC;gCA1J3B3rD;;;;mC;mCAAA;;;;;;;;;;6C0HuXI;+C1HvXJ;;;;;;;;;sGA8JiB;0DA9JjBvmH;;;;;;;;;;;;;;;wDA2IQ;oFA3IRumH;;0DA2IQ;;6EA3IRqyC,KA2IQ15G;;;uDAemB;mFA1J3BqnE;;yDA0J2B;;8EA1J3BztC,KA0J2B35B;;;sDAdnB;kFA5IRonE;;wDA4IQ;;6EA5IRqyC,KA4IQv5G;;;qDACA;iFA7IRknE;;uDA6IQ;;4EA7IRqyC,KA6IQ35G;;;oDAIA;gFAjJRsnE;;sDAiJQ;;2EAjJRqyC,KAiJQz0G;;;mDADA;+EAhJRoiE;;qDAgJQ;;0EAhJRqyC,KAgJQv0G;;;kDADA;8EA/IRkiE;;oDA+IQ;;yEA/IRqyC,KA+IQr0G;;;iDADA;6EA9IRgiE;;mDA8IQ;;wEA9IRqyC,KA8IQ30G;;;;;;;;;;;;;wDAWA;oFAzJRsiE;;0DAyJQ;;+EAzJRqyC,KAyJQ76F;;;uDADA;mFAxJRwoD;;yDAwJQ;;8EAxJRqyC,KAwJQ36F;;;sDADA;kFAvJRsoD;;wDAuJQ;;6EAvJRqyC,KAuJQz6F;;;qDADA;iFAtJRooD;;uDAsJQ;;6EAtJRqyC,KAsJQv6F;;;oDADA;gFArJRkoD;;sDAqJQ;;4EArJRqyC,KAqJQr6F;;;mDADA;+EApJRgoD;;qDAoJQ;;2EApJRqyC,KAoJQn6F;;;kDADA;8EAnJR8nD;;oDAmJQ;;0EAnJRqyC,KAmJQj6F;;;iDADA;6EAlJR4nD;;mDAkJQ;;yEAlJRqyC,KAkJQ/5F;;2DAlJR;;;;8CA8JiB;+BA9JjB;;;;;;;sCA2IQsyG;gCA3IR,MA4IQC;gCA5IR,MA6IQC;gCA7IR,MA8IQC;gCA9IR,MA+IQC;gCA/IR,MAgJQC;gCAhJR,MAiJQC;gCAjJR,MAkJQC;gCAlJR,MAmJQC;gCAnJR,MAoJQC;gCApJR,MAqJQC;gCArJR,MAsJQC;gCAtJR,MAuJQC;gCAvJR,MAwJQC;gCAxJR,MAyJQC;gCAzJR,MA0J2BC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCADnBE;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;;;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACAD;yCACmBD;+BA1J3B;;;;kDA2IQhB;;mDACAC;;oDACAC;;qDACAC;;sDACAC;;uDACAC;;wDACAC;;yDACAC;;0DACAC;;2DACAC;;4DACAC;;6DACAC;;8DACAC;;+DACAC;;gEACAC;mEACmBC;;;gCA1J3B3qD;gCA6JQ4rD;gCAA2BC;gCAAmBC;gCA7JtD1rD;;;;;;;;;;;;;;;;;;;;;;;kGA8JiB;sDA9JjB3nH;;;;;;;8CA6JmC;0EA7JnC2nH;;gDA6JmC;;wD6H7GjCxiJ,c7HhDFyzL,KA6JmC15G;;;6CAA3B;yEA7JRyoE;;+CA6JQ;;;;;4CAA8C;wEA7JtDA;;8CA6JsD;;wD6H7GpDxiJ,c7HhDF2zG,KA6JsDz5B;;2CA7JtD;;;;;;;;;wCA6JQ8zH;kCA7JR,MA6JmCC;kCA7JnC,MA6JsDC;;;;oCAAnBG;oCAA3BC;yDAA2BD,aAAmBD;iCA7JtD;;;;oDA6JQJ;;qDAA2BC;wDAAmBC;;0BA7JtD,sCA8JiB;uBArTrB;iCAuJIza;;;6BAC8D;;8BAARgb;8BAAbC;8BAAbC;8BAAbC;8BAA+C,eAD9Dj7F,KAC8D66F;;8BAAR,iBADtD76F,KACsD86F;kEAAQ3yK;8BAAR,GAAb4yK;8BAAa,GAAbA;8BAAIrmM,gBAD7CsrG,KAC6C3uN;8CAD7CyuS,KAC6Cp9O;8BAAJ4lC,YAAIosB;8BAAJu6B,oCAAa7G;8BAAtBpC,KAAJg1K;8BAAIlzK,KAAJkzK;8BAAIjzK,gBADhCi4E,KACgCl4E;8CADhCg4J,KACgC95J;8BAAJx9C,YAAIu/C;8BAAJmH,oCAAaD;8BAAtB3H,KAAJ2zK;8BAAI50K,KAAJ40K;8BAAI30K,gBADnB05E,KACmB35E;8CADnBy5J,KACmBx4J;8BAAJ3+C,YAAI29C;8BAAJwb,oCAAa5S;gDAAb4S;;6BAEb;;;8BAAgBh5D;+B6HmDhBwhB;iD,OAAAA,c7HtDFw1L,aAGkBob;kEAAhBxuH;gDAAgBC;;6BASV;;8BADAyuH;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BAOA,iBAZR5b,KAYQqb;;8BADA,iBAXRrb,KAWQsb;kEACA9yG;8BAFA,iBAVRw3F,KAUQub;kEACA7yG;8BAFA,iBATRs3F,KASQwb;kEACA5yG;8BAFA,iBARRo3F,KAQQyb;mEACA3yG;8BADA,KADA4yG;8BACA,KADAA;8BAAK/0K,gBAPbq5J,KAOat5J;8CAPbs5J,KAOan6J;8BAALkjE,aAAKpiE;8BAALuiE,sCACAF;8BAFKt6D,KAALitK;8BAAK9zK,KAAL8zK;8BAAK7zK,gBANbk4J,KAMan4J;8CANbm4J,KAMatxJ;8BAALu6D,aAAKnhE;8BAALshE,sCACAF;8BAFKp6D,KAAL8sK;8BAAK90K,KAAL80K;8BAAK70K,iBALbi5J,KAKal5J;+CALbk5J,KAKalxJ;8BAALq6D,aAAKpiE;8BAALuiE,sCACAF;gDADAE;;6BASN;;;8BAAgBD;+B6HwChB7+F;;mCrIzMF;;;;;;;oCAMI,eQ6IJw1L,KR7II8b;;oCADA,iBQ8IJ9b,KR9II+b;wEACA1zK;oCADA,GADA2zK;oCACA,GADAA;oCAAOpnM,gBQ+IXorL,KR/IWzuS;oDQ+IXyuS,KR/IWp9O;oCAAP4lC,YAAOosB;oCAAPu6B,oCACA7G;oCAFA5/C,MqIsMF8hB,c7HtDFw1L,KRhJIic;wEACA9sK;oCAFAtmD,MqIuMF2hB,c7HtDFw1L,KRjJI3iC;wEACAjuH;oCAFApmD;qCqIwMFwhB;;;0CrIxMU5nD;;0DQkJZo9O,KRlJYzuS;0DQkJZyuS,KRlJYp9O;;uCAARs5P;wEACAl6J;6CADA4qC;iCQgKcivH;oEAAhBryG;gDAAgBE;;6BAE4C;;8BAAT0yG;8BAATC;8BAApCC;8BAAsD,kBAhB9Dtc,KAgB8Dmc;;8BAAT,kBAhBrDnc,KAgBqDoc;oEAASv1D;8BAAlB,kBAhB5Cm5C,KAgB4Cqc;oEAASt1D;8BAA7CD;+B6HsCNt8I;;mChIxMF;;;;;;;;;;;;;;oCAaI,eGqIJw1L,KHrIIuc;;oCADA,iBGsIJvc,KHtIIwc;wEACAn0K;oCAFA,iBGuIJ23J,KHvIIyc;wEACAn0K;oCAFA,iBGwIJ03J,KHxII0c;wEACAvtK;oCAFA,iBGyIJ6wJ,KHzII2c;wEACAvtK;oCAFA,iBG0IJ4wJ,KH1II4c;wEACA56J;oCAFA,iBG2IJg+I,KH3II6c;wEACAjwH;oCAFA,iBG4IJozG,KH5II8c;wEACAjwH;oCAFA,iBG6IJmzG,KH7IImc;wEACA3zG;oCAFA,iBG8IJw3F,KH9II+c;wEACAr0G;oCAFA,iBG+IJs3F,KH/IIgd;wEACAp0G;oCAFA,kBGgJJo3F,KHhJIid;0EACAn0G;oCAFA,kBGiJJk3F,KHjJIkd;0EACAl0G;mCADA;iCGiKIszG;oEAAoCr1D;gDAApCE;;6BACN;;;8BAAqBH;+B6HqCrBx8I;;mC/HzMF;;;;;;;;;;;;;;;oCAcI,eEqIJw1L,KFrIIod;;oCADA,iBEsIJpd,KFtIIqd;wEACAh1K;oCAFA,iBEuIJ23J,KFvIIsd;wEACAh1K;oCAFA,iBEwIJ03J,KFxIIud;wEACApuK;oCAFA,iBEyIJ6wJ,KFzIIwd;wEACApuK;oCAFA,iBE0IJ4wJ,KF1IIyd;wEACAz7J;oCAFA,iBE2IJg+I,KF3II0d;wEACA9wH;oCAFA,iBE4IJozG,KF5II2d;wEACA9wH;oCAFA,iBE6IJmzG,KF7II4d;wEACAp1G;oCAFA,iBE8IJw3F,KF9II6d;wEACAn1G;oCAFA,iBE+IJs3F,KF/II8d;wEACAl1G;oCAFA,kBEgJJo3F,KFhJI+d;0EACAj1G;oCAFA,kBEiJJk3F,KFjJIge;0EACAh1G;oCAFA,kBEkJJg3F,KFlJIie;0EACA/0G;mCADA;iCEmKmBi0G;oEAArB91D;gDAAqBE;;6BAEuC;;8BAAT42D;8BAATC;8BAATC;8BAATC;8BAATC;8BAATC;8BAAsD,kBAnB9Dxe,KAmB8Dke;;8BAAT,kBAnBrDle,KAmBqDme;oEAAS12D;8BAAlB,kBAnB5Cu4C,KAmB4Coe;oEAASz2D;8BAAlB,kBAnBnCq4C,KAmBmCqe;oEAAS13D;8BAAlB,kBAnB1Bq5C,KAmB0Bse;oEAASz2D;8BAAlB,kBAnBjBm4C,KAmBiBue;oEAASx2D;8BAAlB,kBAnBRi4C,KAmBQwe;oEAASj4D;6BAAT;;6BAkBA;;8BAFAm4D;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BAgBA,kBArCRt/F,KAqCQu+F;;8BAFA,kBAnCRze,KAmCQ0e;oEAEAprB;8BAHA,kBAlCR0M,KAkCQ2e;oEACAnrB;8BAFA,kBAjCRwM,KAiCQ4e;oEACAhrB;8BAFA,kBAhCRoM,KAgCQ6e;oEACA9qB;8BAFA,kBA/BRiM,KA+BQ8e;oEACA7qB;8BAFA,kBA9BR+L,KA8BQ+e;oEACA5qB;8BAFA,kBA7BR6L,KA6BQgf;oEACA3qB;8BAFA,kBA5BR2L,KA4BQif;oEACA1qB;8BAFA,kBA3BRyL,KA2BQkf;oEACA3rB;8BAFA,kBA1BRyM,KA0BQmf;oEACArrB;8BAFA,kBAzBRkM,KAyBQof;oEACA3qB;8BAFA,kBAxBRuL,KAwBQqf;oEACAI;8BAFA,kBAvBRzf,KAuBQsf;oEACAK;8BAFA,kBAtBR3f,KAsBQuf;oEACAM;8BAFA,kBArBR7f,KAqBQwf;oEACAO;6BADA;;6BAkDA;;8BADAI;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADeC;8BADfC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BA6BA,kBAvER/hB,KAuEQkgB;;8BADA,kBAtERlgB,KAsEQmgB;oEACA8B;8BAFA,kBArERjiB,KAqEQogB;oEACA+B;8BAFA,kBApERniB,KAoEQqgB;oEACAgC;8BAFA,kBAnERriB,KAmEQsgB;oEACAiC;8BAFA,kBAlERviB,KAkEQugB;oEACAkC;8BAFA,kBAjERziB,KAiEQwgB;oEACAmC;8BAFA,kBAhER3iB,KAgEQygB;oEACAoC;8BAFA,kBA/DR7iB,KA+DQ0gB;oEACAqC;8BAFA,kBA9DR/iB,KA8DQ2gB;oEACAsC;8BAFA,kBA7DRjjB,KA6DQ4gB;oEACAuC;8BAFA,kBA5DRnjB,KA4DQ6gB;oEACAwC;8BAFA,kBA3DRrjB,KA2DQ8gB;oEACAyC;8BAFA,kBA1DRvjB,KA0DQ+gB;oEACA0C;8BAFe,kBAzDvBzjB,KAyDuBghB;oEACf2C;8BAFA,kBAxDR3jB,KAwDQihB;oEACe4C;8BAFf,kBAvDR7jB,KAuDQkhB;oEACA6C;8BAFA,kBAtDR/jB,KAsDQmhB;oEACA8C;8BAFA,kBArDRjkB,KAqDQohB;oEACA+C;8BAFA,kBApDRnkB,KAoDQqhB;oEACAgD;8BAFA,kBAnDRrkB,KAmDQshB;oEACAiD;8BAFA,kBAlDRvkB,KAkDQuhB;oEACAkD;8BAFA,kBAjDRzkB,KAiDQwhB;oEACAmD;8BAFA,kBAhDR3kB,KAgDQyhB;oEACAoD;8BAFA,kBA/CR7kB,KA+CQ0hB;oEACAqD;8BAFA,kBA9CR/kB,KA8CQ2hB;oEACAsD;8BAFA,kBA7CRjlB,KA6CQ4hB;oEACAuD;8BAFA,kBA5CRnlB,KA4CQ6hB;oEACAwD;8BAFA,kBA3CRrlB,KA2CQ8hB;oEACAyD;8BAFA,kBA1CRvlB,KA0CQ+hB;oEACA0D;6BADA;;6BA8CA;;8BADAI;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BAcA,kBAxFR1mB,KAwFQ4lB;;8BADA,kBAvFR5lB,KAuFQ6lB;oEACAe;8BAFA,kBAtFR5mB,KAsFQ8lB;oEACAgB;8BAFA,kBArFR9mB,KAqFQ+lB;oEACAiB;8BAFA,kBApFRhnB,KAoFQgmB;oEACAkB;8BAFA,kBAnFRlnB,KAmFQimB;oEACAmB;8BAFA,kBAlFRpnB,KAkFQkmB;oEACAoB;8BAFA,kBAjFRtnB,KAiFQmmB;oEACAqB;8BAFA,kBAhFRxnB,KAgFQomB;oEACAsB;8BAFA,kBA/ER1nB,KA+EQqmB;oEACAuB;8BAFA,kBA9ER5nB,KA8EQsmB;oEACAwB;8BAFA,kBA7ER9nB,KA6EQumB;oEACAyB;8BAFA,kBA5ERhoB,KA4EQwmB;oEACA0B;8BAFA,kBA3ERloB,KA2EQymB;oEACA2B;8BAFA,kBA1ERpoB,KA0EQ0mB;oEACA4B;6BADA;;6BA4BA;;8BADAG;8BADAC;8BADmBC;8BADnBC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BAWA,kBAtGRjpG,KAsGQvzB;;8BADA,kBArGRuzB,KAqGQuoG;oEACAY;8BAFA,kBApGRnpG,KAoGQwoG;oEACAa;8BAFmB,kBAnG3BrpG,KAmG2ByoG;oEACnBc;8BAFA,kBAlGRzpB,KAkGQ4oB;oEACmBe;8BAFnB,kBAjGR3pB,KAiGQ6oB;oEACAgB;8BAFA,kBAhGR7pB,KAgGQ8oB;oEACAiB;8BAFA,kBA/FR/pB,KA+FQ+oB;oEACAkB;8BAFA,kBA9FRjqB,KA8FQgpB;oEACAmB;8BAFA,kBA7FRnqB,KA6FQipB;oEACAoB;8BAFA,kBA5FRrqB,KA4FQkpB;qEACAqB;8BAFA,kBA3FRvqB,KA2FQmpB;qEACAsB;6BADA;;6BA4CA;;8BADAI;8BADAC;8BADmBC;8BADnBC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BA8BA,kBAvIRxsG,KAuIQ0qG;;8BADA,mBAtIR1qG,KAsIQ2qG;sEACA+B;8BAFA,mBArIR1sG,KAqIQ4qG;sEACAgC;8BAFmB,mBApI3B5sG,KAoI2B6qG;sEACnBiC;8BAFA,mBAnIRhtB,KAmIQgrB;sEACmBkC;8BAFnB,mBAlIRltB,KAkIQirB;sEACAmC;8BAFA,mBAjIRptB,KAiIQkrB;sEACAoC;8BAFA,mBAhIRttB,KAgIQmrB;sEACAqC;8BAFA,mBA/HRxtB,KA+HQorB;sEACAsC;8BAFA,mBA9HR1tB,KA8HQqrB;sEACAuC;8BAFA,mBA7HR5tB,KA6HQsrB;sEACAwC;8BAFA,mBA5HR9tB,KA4HQurB;sEACAyC;8BAFA,mBA3HRhuB,KA2HQwrB;sEACA0C;8BAFA,mBA1HRluB,KA0HQyrB;sEACA2C;8BAFA,mBAzHRpuB,KAyHQ0rB;sEACA4C;8BAFA,mBAxHRtuB,KAwHQ2rB;sEACA6C;8BAFA,mBAvHRxuB,KAuHQ4rB;sEACA8C;8BAFA,mBAtHR1uB,KAsHQ6rB;sEACA+C;8BAFA,mBArHR5uB,KAqHQ8rB;sEACAgD;8BAFA,mBApHR9uB,KAoHQ+rB;sEACAiD;8BAFA,mBAnHRhvB,KAmHQgsB;sEACAkD;8BAFA,mBAlHRlvB,KAkHQisB;sEACAmD;8BAFA,mBAjHRpvB,KAiHQksB;sEACAoD;8BAFA,mBAhHRtvB,KAgHQmsB;sEACAqD;8BAFA,mBA/GRxvB,KA+GQosB;sEACAsD;8BAFA,mBA9GR1vB,KA8GQqsB;sEACAuD;8BAFA,mBA7GR5vB,KA6GQssB;sEACAwD;8BAFA,mBA5GR9vB,KA4GQusB;sEACAyD;8BAFA,mBA3GRhwB,KA2GQwsB;sEACA0D;8BAFA,mBA1GRlwB,KA0GQysB;sEACA2D;8BAFA,mBAzGRpwB,KAyGQ0sB;sEACA4D;6BADA;;6BAiDmB;;8BADnBI;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BADAC;8BAemB,mBA1J3BtxG,KA0J2BuwG;;8BADnB,mBAzJRzwB,KAyJQ0wB;sEACmBgB;8BAFnB,mBAxJR1xB,KAwJQ2wB;sEACAiB;8BAFA,mBAvJR5xB,KAuJQ4wB;sEACAkB;8BAFA,mBAtJR9xB,KAsJQ6wB;sEACAmB;8BAFA,mBArJRhyB,KAqJQ8wB;sEACAoB;8BAFA,mBApJRlyB,KAoJQ+wB;sEACAqB;8BAFA,mBAnJRpyB,KAmJQgxB;sEACAsB;8BAFA,mBAlJRtyB,KAkJQixB;sEACAuB;8BAFA,mBAjJRxyB,KAiJQkxB;sEACAwB;8BAFA,mBAhJR1yB,KAgJQmxB;sEACAyB;8BAFA,mBA/IR5yB,KA+IQoxB;sEACA0B;8BAFA,mBA9IR9yB,KA8IQqxB;sEACA2B;8BAFA,mBA7IRhzB,KA6IQsxB;sEACA4B;8BAFA,mBA5IRlzB,KA4IQuxB;sEACA6B;8BAFA,mBA3IRpzB,KA2IQwxB;sEACA8B;6BADA;;;8BAkB8CG;8BAAnBC;8BAA3BC;8BAA8CC,Q6HvGpDppN,c7HtDF01G,KA6JsDuzG;;8BAAnBK,Q6HvGjCtpN,c7HtDFw1L,KA6JmC0zB;sEAAmBG;6BA7SxD,OA6SUF;;;;;;;;;;;;;;;;;;;yEAA2BI;gDAA3BE,WACS;uBArTrB;iCAwT0B9hU,EAAgBP;0BACpC,SAAIuiU;4BAAkB,IAAXhnU,WAAHyB,WAAc,iBADcgD,EACzBzE;4BAAM,qBADmByE,EAC5BhD;0BAAR,OADoBuD;;6BAKc;8BAFZC,EAHFD;8BAGD6S,EAHC7S;8BAGJgb,EAHIhb;8BAGP3B,EAHO2B;8BAGVT,EAHUS;8BAIZuT;;qCAAMvY,WAAHyB,WAAY,UAAZA,EAAY,WAJagD,EAItBzE;8BACoB,QAFlBggB;8BAES,QAFZ3c;6BAEG,YAFNkB,eAASsT,EAAG5S;;6BAIlB,IADSqhB,MANOthB;6BAOG,gBADVshB,eAC4B7kB,GAAK,aAALA,EAPLgD,EAOwB;;6BAU1C;8BATyCwiU,QARvCjiU;8BAQgCkiU,MARhCliU;8BAQyBmiU,MARzBniU;8BAQiBoiU,OARjBpiU;8BAQYqiU,IARZriU;8BAQQsiU,GARRtiU;8BAQI2zP,GARJ3zP;8BAQA4zP,GARA5zP;8BAiBF,iBAjBkBP,EAQuBwiU;8BAQ3C,iBAhBoBxiU,EAQgByiU;8BAOpC,iBAfoBziU,EAQS0iU;8BAM5B,iBAdmB1iU,EAQC2iU;8BAKvB,iBAbsB3iU,EAQJ4iU;8BAInB,SAJeC;8BAGf,SAHW3uE;6BAEX,aAFOC;;6BAYhB,IADS13M,QAnBOl8C;6BAqBJ,gBAFHk8C,iBAEqBz/C,GAAK,cAALA,EArBEgD,EAqBuB;;6BAM3C;8BALgBysS,MAtBZlsS;8BAsBQqiH,GAtBRriH;8BAsBIkpE,GAtBJlpE;8BAsBHi8C,QAtBGj8C;8BA2BJ,iBA3BoBP,EAsBJysS;8BAInB,iBA1BuBzsS,EAsBR4iH;8BAGf,iBAzBuB5iH,EAsBZypE;6BAER;2CAFCjtB,iBAEiBx/C,GAAK,cAALA,EAxBEgD,EAwB2B;;;;;6BAM3D,IADcu8C,QA7BEh8C;6BAgCV,gBAHQg8C,iBAGUv/C,GAAK,cAALA,EAhCQgD,EAgC4B;;6BAUnD;8BARsB40R,GAlCfr0R;8BAkCWs0R,GAlCXt0R;8BAkCOu0R,GAlCPv0R;8BAkCGw0R,GAlCHx0R;8BAkCDy0R,GAlCCz0R;8BAkCL00R,GAlCK10R;8BAkCT20R,GAlCS30R;8BA0CP,iBA1CuBP,EAkCD40R;8BAOtB,iBAzCuB50R,EAkCL60R;8BAMlB,iBAxCuB70R,EAkCT80R;8BAKd,iBAvCuB90R,EAkCb+0R;8BAIV,iBAtCuB/0R,EAkCjBg1R;8BAGN,iBArCuBh1R,EAkCrBi1R;6BAEF;gDApCuBj1R,EAkCzBk1R;;;;;;;;6BA2CI;8BAjBT4tC,QA5DcviU;8BA2DdwiU,KA3DcxiU;8BA0DdyiU,KA1DcziU;8BAyDd0iU,KAzDc1iU;8BAwDd2iU,KAxDc3iU;8BAuDd4iU,KAvDc5iU;8BAsDd6iU,KAtDc7iU;8BAqDd8iU,KArDc9iU;8BAoDd+iU,KApDc/iU;8BAmDdgjU,KAnDchjU;8BAkDdijU,KAlDcjjU;8BAiDdkjU,KAjDcljU;8BAgDdmjU,KAhDcnjU;8BA+CdojU,KA/CcpjU;8BA8CdqjU,KA9CcrjU;8BA6CdZ,GA7CcY;8BA6EL,iBA7EqBP,EA2D9B+iU;8BAiBS,iBA5EqB/iU,EA0D9BgjU;8BAiBS,iBA3EqBhjU,EAyD9BijU;8BAiBS,iBA1EqBjjU,EAwD9BkjU;8BAiBS,iBAzEqBljU,EAuD9BmjU;8BAiBS,iBAxEqBnjU,EAsD9BojU;8BAiBS,iBAvEqBpjU,EAqD9BqjU;8BAiBS,iBAtEqBrjU,EAoD9BsjU;8BAiBS,iBArEqBtjU,EAmD9BujU;8BAiBS,iBApEqBvjU,EAkD9BwjU;8BAiBS,iBAnEqBxjU,EAiD9ByjU;8BAiBS,iBAlEqBzjU,EAgD9B0jU;8BAiBS,iBAjEqB1jU,EA+C9B2jU;8BAiBS,iBAhEqB3jU,EA8C9B4jU;6BAiBO;gDA/DuB5jU,EA6C9BL;;;;;;;;;;;;;;;qCAeAmjU;;6BAkFU;8BAhCVe,MA9GctjU;8BA6GdujU,MA7GcvjU;8BA4GdwjU,MA5GcxjU;8BA2GdyjU,MA3GczjU;8BA0Gd0jU,MA1Gc1jU;8BAyGd2jU,MAzGc3jU;8BAwGd4jU,MAxGc5jU;8BAuGd6jU,MAvGc7jU;8BAsGd8jU,KAtGc9jU;8BAqGd+jU,KArGc/jU;8BAoGdgkU,OApGchkU;8BAmGdikU,OAnGcjkU;8BAkGdkkU,MAlGclkU;8BAiGdmkU,MAjGcnkU;8BAgGCokU,KAhGDpkU;8BA+FdqkU,KA/FcrkU;8BA8FdskU,KA9FctkU;8BA6FdukU,KA7FcvkU;8BA4FdwkU,KA5FcxkU;8BA2FdykU,KA3FczkU;8BA0Fd0kU,KA1Fc1kU;8BAyFd2kU,KAzFc3kU;8BAwFd4kU,KAxFc5kU;8BAuFd6kU,KAvFc7kU;8BAsFd8kU,KAtFc9kU;8BAqFd+kU,KArFc/kU;8BAoFdglU,KApFchlU;8BAmFdilU,KAnFcjlU;8BAkFdipP,IAlFcjpP;8BAiFI0wD,GAjFJ1wD;8BA8IJ,iBA9IoBP,EA8G9B6jU;8BA+BU,iBA7IoB7jU,EA6G9B8jU;8BA+BU,iBA5IoB9jU,EA4G9B+jU;8BA+BU,iBA3IoB/jU,EA2G9BgkU;8BA+BU,iBA1IoBhkU,EA0G9BikU;8BA+BU,iBAzIoBjkU,EAyG9BkkU;8BA+BU,iBAxIoBlkU,EAwG9BmkU;8BA+BU,iBAvIoBnkU,EAuG9BokU;8BA+BS,iBAtIqBpkU,EAsG9BqkU;8BA+BS,iBArIqBrkU,EAqG9BskU;8BA+BS,iBApIqBtkU,EAoG9BukU;8BA+BS,iBAnIqBvkU,EAmG9BwkU;8BA+BU,iBAlIoBxkU,EAkG9BykU;8BA+BU,iBAjIoBzkU,EAiG9B0kU;8BA+BwB,iBAhIM1kU,EAgGf2kU;8BA+BN,iBA/HqB3kU,EA+F9B4kU;8BA+BS,iBA9HqB5kU,EA8F9B6kU;8BA+BS,iBA7HqB7kU,EA6F9B8kU;8BA+BS,iBA5HqB9kU,EA4F9B+kU;8BA+BS,iBA3HqB/kU,EA2F9BglU;8BA+BS,iBA1HqBhlU,EA0F9BilU;8BA+BS,iBAzHqBjlU,EAyF9BklU;8BA+BS,iBAxHqBllU,EAwF9BmlU;8BA+BS,iBAvHqBnlU,EAuF9BolU;8BA+BS,iBAtHqBplU,EAsF9BqlU;8BA+BS,iBArHqBrlU,EAqF9BslU;8BA+BS,iBApHqBtlU,EAoF9BulU;8BA+BS,iBAnHqBvlU,EAmF9BwlU;8BA+BQ,iBAlHsBxlU,EAkF9BwpP;6BA+ByB;gDAjHKxpP,EAiFZixD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BA+FR;8BAjBVw0Q,MA/JcllU;8BA8JdmlU,MA9JcnlU;8BA6JdolU,MA7JcplU;8BA4JdqlU,MA5JcrlU;8BA2JdslU,MA3JctlU;8BA0JdulU,MA1JcvlU;8BAyJdwlU,MAzJcxlU;8BAwJdylU,MAxJczlU;8BAuJd0lU,MAvJc1lU;8BAsJd2lU,MAtJc3lU;8BAqJd4lU,MArJc5lU;8BAoJd6lU,MApJc7lU;8BAmJd2sC,IAnJc3sC;8BAkJd8lU,IAlJc9lU;8BAiJd+lU,IAjJc/lU;8BAgLJ,iBAhLoBP,EA+J9BylU;8BAgBU,iBA/KoBzlU,EA8J9B0lU;8BAgBU,iBA9KoB1lU,EA6J9B2lU;8BAgBU,iBA7KoB3lU,EA4J9B4lU;8BAgBU,iBA5KoB5lU,EA2J9B6lU;8BAgBU,iBA3KoB7lU,EA0J9B8lU;8BAgBU,iBA1KoB9lU,EAyJ9B+lU;8BAgBU,iBAzKoB/lU,EAwJ9BgmU;8BAgBU,iBAxKoBhmU,EAuJ9BimU;8BAgBU,iBAvKoBjmU,EAsJ9BkmU;8BAgBU,iBAtKoBlmU,EAqJ9BmmU;8BAgBU,iBArKoBnmU,EAoJ9BomU;8BAgBQ,iBApKsBpmU,EAmJ9BktC;8BAgBQ,iBAnKsBltC,EAkJ9BqmU;6BAgBQ;gDAlKsBrmU,EAiJ9BsmU;;;;;;;;;;;;;;;;6BAuDU;8BAVV1qU,KA9Lc2E;8BA6LdgmU,uBA7LchmU;8BA4LdimU,uBA5LcjmU;8BA2LKkmU,uBA3LLlmU;8BA0Ld2H,MA1Lc3H;8BAyLdmmU,eAzLcnmU;8BAwLdomU,eAxLcpmU;8BAuLdqmU,eAvLcrmU;8BAsLdsmU,eAtLctmU;8BAqLdumU,cArLcvmU;8BAoLdwmU,cApLcxmU;8BAmLdymU,cAnLczmU;8BAwMJ,iBAxMoBP,EA0L9BkI;8BAamB,iBAvMWlI,EAyL9B0mU;8BAamB,iBAtMW1mU,EAwL9B2mU;8BAamB,iBArMW3mU,EAuL9B4mU;8BAamB,iBApMW5mU,EAsL9B6mU;8BAakB,iBAnMY7mU,EAqL9B8mU;8BAakB,iBAlMY9mU,EAoL9B+mU;6BAakB;gDAjMY/mU,EAmL9BgnU;;;;;;;;qCAQmBP;qCACnBD;qCACAD;qCACA3qU;;6BA4Ec;8BA7BdqrU,2BA7Oc1mU;8BA4Od2mU,2BA5Oc3mU;8BA2Od4mU,2BA3Oc5mU;8BA0OK6mU,yBA1OL7mU;8BAyOd8mU,UAzOc9mU;8BAwOd+mU,UAxOc/mU;8BAuOdgnU,UAvOchnU;8BAsOdinU,UAtOcjnU;8BAqOdknU,UArOclnU;8BAoOdmnU,UApOcnnU;8BAmOdonU,UAnOcpnU;8BAkOdqnU,UAlOcrnU;8BAiOdsnU,UAjOctnU;8BAgOdunU,UAhOcvnU;8BA+NdwnU,SA/NcxnU;8BA8NdynU,OA9NcznU;8BA6Nd0nU,cA7Nc1nU;8BA4Nd2nU,cA5Nc3nU;8BA2Nd4nU,YA3Nc5nU;8BA0Nd6nU,kBA1Nc7nU;8BAyNd8nU,UAzNc9nU;8BAwNd+nU,UAxNc/nU;8BAuNdgoU,UAvNchoU;8BAsNdioU,WAtNcjoU;8BAqNdkoU,YArNcloU;8BAoNdmoU,aApNcnoU;8BAmNdooU,aAnNcpoU;8BAkNdqoU,aAlNcroU;8BAiNdsoU,YAjNctoU;8BAgNduoU,YAhNcvoU;8BA+MdwoU,YA/McxoU;8BA0QA,iBA1QgBP,EAyO9BqnU;8BAgCc,iBAzQgBrnU,EAwO9BsnU;8BAgCc,iBAxQgBtnU,EAuO9BunU;8BAgCc,iBAvQgBvnU,EAsO9BwnU;8BAgCc,iBAtQgBxnU,EAqO9BynU;8BAgCc,iBArQgBznU,EAoO9B0nU;8BAgCc,iBApQgB1nU,EAmO9B2nU;8BAgCc,iBAnQgB3nU,EAkO9B4nU;8BAgCc,iBAlQgB5nU,EAiO9B6nU;8BAgCc,iBAjQgB7nU,EAgO9B8nU;8BAgCa,iBAhQiB9nU,EA+N9B+nU;8BAgCW,iBA/PmB/nU,EA8N9BgoU;8BAgCkB,iBA9PYhoU,EA6N9BioU;8BAgCkB,iBA7PYjoU,EA4N9BkoU;8BAgCgB,iBA5PcloU,EA2N9BmoU;8BAgCsB,iBA3PQnoU,EA0N9BooU;8BAgCc,iBA1PgBpoU,EAyN9BqoU;8BAgCc,iBAzPgBroU,EAwN9BsoU;8BAgCc,iBAxPgBtoU,EAuN9BuoU;8BAgCe,iBAvPevoU,EAsN9BwoU;8BAgCgB,iBAtPcxoU,EAqN9ByoU;8BAgCiB,iBArPazoU,EAoN9B0oU;8BAgCiB,iBApPa1oU,EAmN9B2oU;8BAgCiB,iBAnPa3oU,EAkN9B4oU;8BAgCgB,iBAlPc5oU,EAiN9B6oU;8BAgCgB,iBAjPc7oU,EAgN9B8oU;6BAgCgB;gDAhPc9oU,EA+M9B+oU;;;;;;;;;;;;;;;;;;;;;;;;;;;qCA2BmB3B;qCACnBD;qCACAD;qCACAD;;6BAoEiB;8BAjBE+B,WAhSLzoU;8BA+Rd0oU,aA/Rc1oU;8BA8Rd2oU,aA9Rc3oU;8BA6Rd4oU,aA7Rc5oU;8BA4Rd6oU,aA5Rc7oU;8BA2Rd8oU,aA3Rc9oU;8BA0Rd+oU,aA1Rc/oU;8BAyRdgpU,aAzRchpU;8BAwRdipU,aAxRcjpU;8BAuRdkpU,YAvRclpU;8BAsRdmpU,YAtRcnpU;8BAqRdopU,YArRcppU;8BAoRdqpU,YApRcrpU;8BAmRdspU,OAnRctpU;8BAkRdupU,QAlRcvpU;8BAiRIwpU,KAjRJxpU;8BAiTG,iBAjTaP,EA+R9BipU;8BAiBiB,iBAhTajpU,EA8R9BkpU;8BAiBiB,iBA/SalpU,EA6R9BmpU;8BAiBiB,iBA9SanpU,EA4R9BopU;8BAiBiB,iBA7SappU,EA2R9BqpU;8BAiBiB,iBA5SarpU,EA0R9BspU;8BAiBiB,iBA3SatpU,EAyR9BupU;8BAiBiB,iBA1SavpU,EAwR9BwpU;8BAiBgB,iBAzScxpU,EAuR9BypU;8BAiBgB,iBAxSczpU,EAsR9B0pU;8BAiBgB,iBAvSc1pU,EAqR9B2pU;8BAiBgB,iBAtSc3pU,EAoR9B4pU;8BAiBW,iBArSmB5pU,EAmR9B6pU;8BAiBY,iBApSkB7pU,EAkR9B8pU;6BAiBS;gDAnSqB9pU,EAiRZ+pU;;;;;;;;;;;;;;;qCAeCf;;iCAoBHgB,OApTFzpU,KAoTN80J,OApTM90J,KAoTZuB,KApTYvB;6BAqTK,WADjBuB,KACiB,MADXuzJ,OApTsBr1J,GAoTdgqU,QACgC;uBA7mB5D;iCAonBgB93S;0B,gBACP+3S,SAAoB1pU;4BACvB,SADuBA;8BAIV;+BADoCC,EAH1BD;+BAGuB6S,EAHvB7S;;+BAGmB2pU;+BAAJC;qCAHf5pU;+BAGO6pU;+BAAJC;qCAHH9pU;+BAGL+pU;+BAAJ71N;+BACD,gBAJVw1N,SAGeK;+BAEL,gBALVL,SAG2BG;+BAGjB,gBANVH,SAGuCC;+BAG7B,MAPHh4S;+BAWuC,iBAXvCA,MAKFq4S,KACAC;+BAKmC,oBAXjCt4S,MAIoC9e,YAAG5S;+BAOjB,oBAXtB0xB,MAI4Bi4S,GAG9BM;+BAIa,oBAXXv4S,MAIgBm4S,GAElBG;+BAIF,kBACI,WAXAt4S,MAIIuiF,GACN81N;8BAQG,cAbDr4S,YASF1vB,KAcC;8BAlBI;+BAgBe,iBArBlB0vB,MAKFq4S,KACAC;+BAeoB;;;;;iDANnBE;sEAfCx4S,KAeDw4S,mBAKe;;+BACI;;;;;iDANnBC;sEAfCz4S,KAeDy4S,mBAKe;;+BACI;;;;;iDANnBC;sEAfC14S,KAeD04S,mBAKe;;+BACI;;;;;iDANnBC;sEAfC34S,KAeD24S,mBAKe;;+BACI;;;;;iDANnBC;sEAfC54S,KAeD44S,mBAKe;;+BACI;;;;;iDANnBC;sEAfC74S,KAeD64S,mBAKe;;+BACI;;;;;iDANnBC;sEAfC94S,KAeD84S,mBAKe;;+BACI;;;;;iDANnBC;sEAfC/4S,KAeD+4S,mBAKe;;+BACI;;;;;iDANnBC;sEAfCh5S,KAeDg5S,mBAKe;;8BANlB;;;;;mDACGC;wEAfCj5S,KAeDi5S,mBAKe;;;gCAhBV12N;gCACN81N;gCADkBF;gCAElBG;gCAF8BL;gCAG9BM;gCAHsCr3T;;gCAAG5S;gCAKzCgC;8BAKF;4BAWF,QAAI;uBA7oBd;oCAuJI2rS,0BAiKIm0B,OA2TAn+F;uBAnnBR;;;iCAmqBIigB;;;;;8BACgB,IAAdG,MADFJ,SACgB,uBAAdI;;oCADFH;4CACE;0BAEc,IAAdI,MAHFL;0BAGgB,yCAAdK,MAI8B;uBA1qBpC;iCAmqBI17H;0B,SAAA5lH;4BACE,OADFA,OACE,iCADF4lH;4BACE,kBkGnpBE/G,clGmpBF8uD;0BAEA,SAHF3tK,OAGE,iCAHF4lH;0BAGE;uBAtqBN;iCAmqBI9rH;0B,IAAA8rH,IoLlfEpH;;mCpLkfF2pN,sBAOgC;uBA1qBpC;iCAmqBI5xN;;;;;;;;;;;;4B0HrJI,c1HqJJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;gEAOgC;uBA1qBpC;;0BAmqBI;4BACE,gCgH5jBE8b,ahH4jBF51H;;0BAEA;yDAI8B;sBA1qBpC,UAmqBIyrU;sBsYrlBgB;uBtY9EpB;;;2BAmqBIC;;;;;uBAnqBJ;;;mCAo1BMK,gBAAiB9hG,IAAU+hG;4BAG3B;;6BAEsB,0BALL/hG;6BAKK,SAApBz/M,oBALey/M;6BAQjB;;gCwf51BFuiE;gDxf61BM,sBAHF0/B,gBAGoC;6BADtC,MAHE1hT;6BAGF;;kCAIFpvB;8BACE;gCAAe,qBAbY4wU,gBAY7B5wU;gCACS,iBAAP,iBANEyH,UAKJzH;;;gCACiB,UADjBA;;;4BAGA,SAAI03E,KAAKlyE,EAAErB;8BACH,8BADCqB,EAAErB;8BACH,UAIF,IADGlC,WACH,OADGA;8BAHD;8BAEF;;;;;;;2DAAW8uU;;wGAA2C;;;uCAHjD5sU;6CAKJ;4BALP,eAoB2C6sU,cAAcC;8BACrD,IAAIC,QADmCF,gBA9BvC5hT;8BA+BA;uCADqD6hT;gDAE5BE,QAAQpsN;yCAC7B,GAD6BA;;;6CAKzB,mBAA2B,iBA1CV6rN,gBAyCJj0L;6CACA;gDAAb,iBAnCRl1I,IA8ByB0pU,sBADrBD;;;;6CAMiB;2CAEb;;4CAAS,WA5CFriG,OA2CMtuF;4CApBP96I,EAqBF2oE;4CArBFw4J,GAqBEx4J;;sDApB+Cp6B;+CAAL;wDAAa/xC;gDAI3D,QAJ2DA,KAC7Dk6F,IAGE,WA5BiBy0O,gBA2BV50O;;gDAGP,QAN2D/5F,KAC7Dk6F,IAKE,KA5BR00O,gBA2Bev0O;+CALuC,UAQ1C,kBARoD95F,EAC1D25F;+CAOM,yBAR+CnoD,UAQrC;4CARL,kBADP4yL,GACO,QADHnhO;2CAuBO;8CAAb,iBAvCRgC,IA8ByB0pU,sBADrBD;;;2CASQj1T;2CACS,2BA5CrB40T,gBAyCqBtwL,MAETtkI;yCALJ,QAOgD,EAAE;4BAZ9D,QAAW,aAnCQ4yN;4BAmCnB,OA5BIpnO,GA0CD;mCAED2pU,WAAWviG,IAAIrqO;4BACjB,sBACI,iBAFaA,EAEM;4BADvB,2BADaqqO,QAAIrqO,QAEQ;mCAGvB6sU,gBAAiB5tG,SAASoL,IAAIjI;4BACxB,IAAJpiO,EAAI;4BACA,WAFoBqqO,OACxBrqO;4BAEJ,oBAH4BqqO,OACxBrqO,KAD4BoiO,GAAbnD;4BAGnB,UAFIj/N,EAGQ;mCAGV6uE;4BAWc;;6BADK;6BARD;6BADE;6BAEJ;4BAIM;;;;;;;;;;;0CAKvB;mCAGCi+P,yBAAyB9rU,GAAI,OAAJA,IAA0B;mCAGnD+rU,uBAAuB/rU;4BAAI,eAAJA,WAAgD;mCAGvEgsU,oBAAoBhsU,GAAI,OAAJA,OAAkC;mCAGtD4lO,yBAAyB5lO,EAAEvD,GAAI,OAAJA,EAAI,QAA2B;mCAG1DkpO,uBAAwB0D,IAAS4iG;4BACnC,eAD0B5iG,aAAS4iG,eAC0B;mCAG3DC,oBAAqB7iG,IAAS8iG;4BAChC,eADuB9iG,aAAS8iG,oBACgC;mCAE9DtmG,sBAAuBwD,KAAW,OAAXA,MAAoC;mCAE3DvD,aAAcuD,KA/MG,cA+MHA,OAA2B;mCAEzC+iG,SAAU/iG,KAAW,OAAXA,MAAuB;mCAMjCt/M,KAAMs/M,IAAItuN,IAAI+V,IAAKJ;4BACb,WADA24M,IAAItuN;4BACJ,8BADAsuN,OAAItuN,OAAI+V,IAAKJ,KAE4C;mCAQ/D27S,QAAQhjG,MAA8B9nO,KAAKkoU;4BAC7C,UADUpgG;4BACV;8BAQI;;+BAAe,qBwf/8BnBwiE;+BjMiBA;8BvTg8BI;gCADIygC;yCAC8B57S,IAAIj0B;kCAClC;2CADkCA,WACZA,GAfL,YAGf4sO,IAYoB5sO,KAZpB4sO,QAW4B34M,IACwB,EAAC;8BAD3D,kBAXoCnvB,SAAKkoU,QAI3B99S;8BAOd,SAXM09M;8BAWN,cAXMA;8BAWN;4BARA,sBAgBoC;mCAMlCkjG,uBAAuBljG;4BAC7B;wCAD6BA;8BAC7B;0CAD6BA;;;;mCAIaogG;mCAAHzuT;mCAAH3c;mCAAHkB;kCAE7B,QANyB8pO,OAII9pO,EAAGlB,EAAG2c,KAAGyuT;kCAEtC;;gCAIA;;iCAAiB;iCAIf,0BAduBpgG;iCAcvB;iCAEkB;uCAt7BTz/M;iCAs7BS;;sCAEpBkH;kCACE;wCAAI87S,cADN97S;oCAEE,KApBuBu4M,IAmBnBujG,cADN97S;oCAEE;;gDAJE47S,eACAC;oCAEF,UADF77S;;;gCARA;iCAtLJ;2CA7vBFsyQ,MA+vBMzgS;oC,UAAAA;;qCA/vBG;;qEAATygS;sCAkBA1Q,MAlBS,WkGxCHlxK,clGwCG+G;;qCAAoB;;uEAA7B66K;sCAkBA1Q,MAlB6B,WkGxCvBlxK,clGwCuB8uD;sDkGxCvB9uD,clG0DNkxK,MA6uBM/vR;iCAFJ;2CAEIlG;oC,IAAA8rH,IoLvoBFpH;4EpLuoBEI,mBAA0D;iCAF9D;2CAEIvhH;oCA7uBN,SA6uBMA,KA7uBN,0CA6uBMA;oCA7uBN;iDA6uBMA;qCA7uBN;;;;;;;;;;;;;;;8C0HmcM;gD1HncN;;;;;;;;;kGA6uBMA,EA7uBkE;2DAAxEi1I;;;;;;kDAAgB;4EAAhBF;;oDAAgB;oDAlBhB;;;;;;;;;;;8DAkBgBG,OAlBhB;wEAkBgBA,OAlBhB;;;;;;;;;;;;;;;;;;yGAkBgBA,UAlBhBzyB;;;;oEAkBgByyB,OAlBhB;;;;;;;;8DAkBgBA,UAlBhBY;;;;iEAkBgBZ,OAlBhB;;6DAkBgBA,OAlBhB;;2DAkBgBA,OAlBhB;oEAkBgBA,OAlBhB;oDAkBgB23L;;iDAAY;2EAA5B93L;;mDAA4B;;;;gDAA5B;;;;8FA6uBM/0I;sCA7uBN;qFA6uBMA;sCA7uBN,UAAgB6sU,aAAhB,MAA4BC;;+DAAZE;4DAAYD;sCAA5B;;+CA6uBM/sU;;yDA7uBU6sU;4DAAYC;iCA2uB1B;2CAEI9tU;oCA7uBN;2CA6uBMA;qCA7uBN,MA6uBMA;qCA7uBsB,egH6BtBg2H,ahH7BsB2oC;;oCAlB5B,SAkBgBsvK;qCAlBP;yCAkBOA;sCAlBP,gBgH+CHj4M,ahH/CG51H;sCAkBOw+C,qBAlBP6kE;;qCAAoB;2CAkBbwqN;sCAlBa,gBgH+CvBj4M,ahH/CuB6gB;sCAkBbj4F,qBAlBak4F;oCAkB7B,IAAgBK,oCAAYD;8CAAZC;iCA2uBd;2CAEIsuG;oCAAe;sDAANG,2CAAK;6CAAdH;mDAAyB;iCAF7B;6CAEIljI;iCAFJ;;iCAQ0B;;2CACqBxmG,IAAKnZ;oCACxC,IAAJylE,EAAI,oBAkKiBgiK,QAnKkBtuN;oCACnC;sCACiD;wCAInD,IADG25N;wCACH,OAN0C9yO,qB,O0PnsB9C2uI,O1PwsBOmkG;wCACH,OADGA;sCADH,kCAJ0C9yO,KAOtC;oCALyB,gBAD/BylE;oCAC+B,2BAHnC6lQ,gCAQU;gCAPd,oBAmK6B7jG;gCAUzB;iCArKM;;2CAC+BqL;oCACrC,eAEuDxhE;sCAAM;wDAANE,2CAAK;+CAALF;qDAAgB;oCAArE,IADEtqG,MACF,eAHmC8rK;oCAGnC,eAEyCvwK,MAAM1hD;sCAC7C,2BAkLA0qT,QAnLuChpQ,MAAM1hD,OACF;oCAL7B,GACdmmD;yCADuCM,GACvCN,SADkCnsE,EAClCmsE,yBADuCM,MAALzsE;;;qDAClCmsE,kBAI6C;gCANrD,oBAVIskQ;gCA8KA;iCAyBIE;2CAAmCt8S,IAClClP;oCACH;2CADGA;qCAGC;;wCwftgCViqR;iDxfsgCwDn7Q;0CAC1C,IATO5c,OAIsBgd,IAIaJ;0CAPrC,mCAFXy8S,QACar5T,SASiB;oCAD5B,UAHD8N,oBAKF;iCAIgB,0BA5Bf+qT;iCA8BF;;oCAFEU;6CAE6BE,aAAapjT;sCACxC;kDAD2BojT,cAAapjT,KAElC;iCAIA,mBA5CYqiT;iCA8CtB;;oCAFE7gT;6CAEsB8hT,aAAatjT;sCACjC;kDADoBsjT,cAAatjT,KAEW;iCAK1B;2CAIVwB;oCACZ;6CADYA;sDACYjqB;+CA36B9B,eAEaoS;iDAAuB,UAAvBA,OAAuB,MAAvBA;;kDA9DT,qBADWtZ;;kDAIX,uBAFiB2oE,MAHNv5C;uEAgEiD;+CAD9D;+DA06B4BloB;gDA16B5B,OA06B4BA;gDA16B5B,KA06B4BA;gDAj6Bf,iBAFQisU,SA5BrBhgC;gDAsCE,uBARAigC;gDAOA,uBAPAA;gDAMA,uBANAA;gDAKA,uBALAA;gDAIA,uBAJAA;gDAGA,uBAHAA;gDAEA;;mEAFAA;;;;;;;0EAw2BInB,cA12BSlrU,KAGb0oB,MAH6Bw/S,QAq6BwB,EAAE;gCAEvD,UAzBI6D;gCA0BJ,UAlBIE;gCA5CJ;iCAiEa,2BAj/BF5jT,kBAg7BP6iT;iCAkEa,iBADb1nJ;gCACa,YAAb8oJ,WAlEApB;gCAkEa,OAlEbA;8BATR,IACyBqB;8BACrB,OADqBA,QAgFX;mCAGZ5tK,SAASlgK,GAAY,uBAAZA,GAAY,QAAmC;mCAExD+tU,gBAAgB1kG;4BAAM,iCAANA;4BAAM,iCAAuC;mCAE7D2kG,QAAS3kG;4BACC;0DADDA;6BAEa,0BAFbA;4BAEa,2BAApBz/M,kBADA+B,MAEiC;mCAG/Bo5J,OAAQskD;4BACd;wCADcA;8BACd,mBAEI,SAHUA;8BACd,IAGYtkD;8BACR,OADQA,OACF;mCA2CRkpJ,uBAAwB1uU,EAAGlB,EAAG2c,EAAEyuT,OAAOpgG;4BACzC,UADyCA;4BACzC;8BAMiB;;+BADG6kG;+BAAJC;+BAAJtvU;+BAAJkN;+BACS,kBAPiB09T,OAMdyE;8BAEhB,QARqC7kG,OAAf9pO,EAAGlB,EAAG2c,EAMxBjP,GAAIlN,GAAIsvU,MACRC;8BACJ;;4BAJA,eAJsB7uU,EAAGlB,EAAG2c,EAAEyuT;4BAI9B,QAKgC;mCA8FlC/jG,qBAAwB2D,IA61BxBglG;4BAx1BQ,SAANC,IpCvsCFtuU;8BoCgpCgB;;+BADgD;;;;8BpC1pCpE,SAAQ8pN;;;;;;;;;oCAEF,IADO7pN;oCACN;wEAAa,yBADPA;;;oCAGP,IADEjB;oCACF,mCADEA;;oCAKe;qCADV8/B;qCAAJD;qCACc,oCADdA;qCACc;;gDAAb6nM;6CAAID;6CADD3nM;;;oCADJ;qCADK9+B;qCAAHhD;qCACF,yBADEA;;6CAAGgD;;8BAOA;wCAbkC2G,IAANslE,OAYtCjsE;+BACU;;+BACD,0BADPC,EAboCgsE,WAapChsE;8BoC2jCJ,eAA4CuuC;gCAAL;;yCAAKA;yCAAQh0C;kDACvBQ;2CACrB,GADqBA;4CACwB,QADxBA,KACjBiH,IAAyC,kBAFJxF,EAEDq1C;;gDAApC7vC,IAFqCxF;2CAGlC,gCADHwF,cAC0C,EAAI;8BAH1D;mDAiFc6kO;+BAQZ;;kCAFEynG;;2CAEqCxzT,IAAKnZ,KAAK4sC,KAC7C,aADwC5sC,KAALmZ,KAAUyzB,IAC3B;+BAEP,mBALb+/R;8BAKa,GAXbtwG;gDAYG/zJ,IAZH+zJ,sBAYG/zJ;;+BAGH;8BACG,GATHskQ;;;kCA7BJ;mCAwDkBnrQ,GA3BdmrQ;mCA2BOC;mCAxDX;;sCAAa;;;0CAQM;2CAHHzuU;2CAAPyuU;2CACCE,QADDF;2CAGU,WAHHzuU;2CAGG;;2CACQ;8DAkEDqpO,gBArEhBslG,YAEAC,GAAIxlQ;2CACa;;0CACrB;+CAJIulQ;+CAEIvlQ;+CACJylQ;qDADAD,GAGa;4CAgEGvlG;0CAjEpB,iBADIwlG;wCALJ,IADIpyU;wCACJ,mBADIA;sCADJ,8BAWwB;mCAb9B,aAwDkB4mE;mCAEF+F;mCAAJwlQ;mCAEF;;sCAtCN3wG,SAqDsBoL,mBAnBfolG,WAECG,GAAIxlQ;kCAEN,GAtCN60J,aA8CmCxhO,EA9CnCwhO,YA8CmCznI;kCApEvC;kCA+DQ;0CAPGi4O;uCAEKrlQ;uCACJnnE;6CADA2sU,GAQK,gCAEsBp4O;oCAOb6yI;kCAZlB,4BAJIpnO;gCAjBU,IAAT0sU;gCAAS,GApBlB1wG;kCA0BQ;uCA1BRA;mCA2BU,yBAHC9zJ,KA6BWk/J,mBAjCbslG;mCAOC;mCAGoB;kCADtB;0CATCA;;uCAMG5iQ;gEAFD5B;oCA6BWk/J;kCAxBd,4BAHIt9J;gCAHJ,8BAHC4iQ;8BADL;4BAuCE,SAENG,YAAaryU;8BACT,cADSA,GACT;;gCAWI,8BAnBc4sO;gCAmBd,UAEF,IADG7yI,aACH,OADGA;gCADD;iCAIM,8BAvBQ6yI;iCAyBwB;gCADxC;qCADI1yI,+CAvBY0yI;gCA2BhB,oBA3BgBA,cAuBZ1yI;gCAIJ,OAJIA;8BAfN,IACIG;8BACH,mCAAuB,OADpBA;8BADJ;+BAIS,qBAZSuyI,gBASdvyI;+BAGK;;+BAGY;8BADrB;mCALIA,UAGAnrB,uCAZc09J;8BAclB,OAFI19J,EAgBC;4BAvBH,GAw1BR0iQ;8BA7zBS;+BADiC39Q,GA8zB1C29Q;+BA9zBsC59Q,GA8zBtC49Q;+BA7zBS,UAD6B59Q;+BACrB,UADyBC;+BACzB;;;;;kCAmBO;kCAAN;;gCAHkC;iCAHrBq+Q;iCAGqB;iCAAV;gCAAlC;gDAHuBA,yCA7CP1lG;8BAgCf;;gCAW2C;;iCAAV;gCAAlC;;;;;yCA3CgBA;8BAgCf;+BACoB2lG;;+BAKkB;+BAAlB;8BAArB;;;0CALqBA;;uCAjCL3lG;+BA61BxBglG;8BAxyBS;+BADmCt9G,GAyyB5Cs9G;+BAzyBwClxL,KAyyBxCkxL;+BAzyBoC3rN,KAyyBpC2rN;+BAxyBS,YAD2B3rN;+BACnB,YADuBy6B;+BACf,UADmB4zE;+BACnB;;;;;;;oCAmCM;oCAAb;;kCAH4B;mCAFEhyL;mCAEF;;kCAAtC;kDAFwCA,yCAnFxBsqM;;;kCAiF4B;;;;mCAA5B;kCAAhB;4FAjFgBA;gCAyEU;iCAFY4lG;;;iCAEZ;iCAAV;gCAAhB;;;4CAFsCA;;yCAvEtB5lG;8BAqDf;;;;kCAwB2C;;;;;kCAA5C;;;;8CAAO;2CA7ESA;gCAqEU;iCAJY6lG;;;iCAIZ;;gCAA1B;;;4CAJsCA;4CAI/B;yCArES7lG;8BAqDf;;gCAU2C;;iCAAV;gCAAlC;;;;;yCA/DgBA;8BAqDf;+BACmC8lG;;+BAKP;;8BAA7B;;;0CALoCA;;uCAtDpB9lG;+BA61BxBglG;8BApwB2C,MAowB3CA,UAnwBa,YADyBrvU,GACzB;wCAAJvC;gCAQiB,4BARpBO;gCAQY,qBARZA;;8BADqC;+BAGlCw5F,IAFA/5F;;;;;8BAKD;0CAHC+5F;;;0CAGM;uCA/FS6yI;+BA61BxBglG;8BAzvBoC;+BADK5yC,KA0vBzC4yC;+BA1vBqCt6L,KA0vBrCs6L;+BAzvBoC,YADK5yC;+BACL;;+BAAR,YADS1nJ;+BACT;;wCAAjBl1G;;kCA2CO,qBA3CXl2B;;gCA6BmB;;iCAIJ,wBAjCfA;iCAkCK,4BAtIY0gO,QAqId+lG;gCACE;kCAEF,oBAAqC,iBAxIvB/lG,IAiIJvqM;kCAOO,0BAxIHuqM,IAuIX5/J;gCANa,UAUoB,kBAvCvC9gE;gCAsCG;uCATUm2B,2CAjIIuqM;gCA0Id,2BA1IcA,QAqId+lG,MAJUtwS;8BA7BgB,UAAzBD;;gCAoBW;iEApBfl2B;iCAqBK,4BAzHY0gO,QAwHdgmG;gCACE;kCAEF,oBAAqC,iBA3HvBhmG,IA0HX7/J;kCACc,0BA3HH6/J;gCAwHF,UAMwB;gCADpC;mDAzBH1gO,+BApGiB0gO;gCA6Hd,2BA7HcA,QAwHdgmG;8BApB0B,IAElBC;8BACT,qBAHF3mU;gCAIQ,gCAJRA;gCAIQ;kCACgC,qBAzGvB0gO,IAsGNimG;kCAGS,0BAzGHjmG;gCA0Gb;8BAEO,qBARX1gO;gCAaC;gCACE;;4CAZQ2mU;;4CAFX3mU,GAcc;yCAlHG0gO;8BAoGY,IAS5B;8BACE;;0CARQimG;;0CAFX3mU,GAUc;uCA9GG0gO;+BA61BxBglG;;;;iCAjqBgB;kCA5CwBpuU;kCAAH4S;kCAAHmI;kCAAH3c;kCAAHkB;kCAqBtB2qE,OArBkCjqE;kCAsBlCsvU;;qCACI;sCADO9yU;sCAAHO;sCACJ,UADOP;sCACP;;;uCAEiB,4BAHbO;uCAGD,2BAJPktE;uCAIO;qCAFH,IAKKssB;qCACQ,wCAPTx5F,SAMCw5F;kCAgBC,eA5CYj3F;kCA4CZ;;kCACA,eA7CelB;kCA6Cf;;kCACH,eA9CqB2c;kCA8CrB;wD;kCAAA,sB,kBsMvjCSgxG;kCtMujCT;wD;kCAAA,sB;;iCAML,GARI7jD,OACAsH;mCAOA;4DARN+/P,IACAC;oCAIA96P,IAGM,wBApDyB9hE;;iC0H11BnC,kB1H24BI8hE,IAME;iCAXQ;kCAWkD,MAlC5DzK;kCAqCmB,YAZhBwlQ;kCAYO,YAbJjgQ;kCAaL,eAdKtH,iBAKNwM;kCAQ4C,YAXzC+6P;kCAW8B,YAZ3BjgQ;iCAYgB;gDAbhBtH,uBA5LYkhK;;iCAkNtB;;kCAEE;;qCAJ2B/nN,sB,mBAzM7BwtT;kCAiNIc;4CAAiBh8M;qCAgBT;sCAhBgCi8M;sCAAJC;sCAAJ/jC;sCAAJljS;sCAAJF;sCAgBhB,0BAhB4BmnU;sCAe5B,0BAf4BA;sCAc5B,0BAd4BA;sCAa5B,0BAbwB/jC;sCAYxB,0BAZwBA;sCAWxB,0BAXwBA;sCAUxB,0BAVoBljS;sCASpB,0BAToBA;sCAQpB,0BARoBA;sCAOpB,0BAPgCgnU;sCAMhC,0BANgCA;sCAKhC,0BALgCA;sCAIhC,0BAJgBlnU;sCAGhB,0BAHgBA;sCAEhB;;4DAFgBA;;;;;;;;;;;;;;;sCAEhB,MAFSirH;sCAkC2B,MAlC3BA;sCAkC2B;;0CAAzC;;sCADyC,MAjC3BA;sCAiC2B;;0CAAzC;;sCADyC,MAhC3BA;sCAgC2B;;0CAAzC;;sCADyC,MA/B3BA;sCA+B2B;;0CAAzC;;sCADyC,MA9B3BA;sCA8B2B;;0CAAzC;;sCADyC,MA7B3BA;sCA6B2B;;0CAAzC;;sCADyC,MA5B3BA;sCA4B2B;;0CAAzC;;sCADyC,MA3B3BA;sCA2B2B;;0CAAzC;;sCADyC,MA1B3BA;sCA0B2B;;0CAAzC;;sCADyC,MAzB3BA;sCAyB2B;;0CAAzC;;sCADyC,MAxB3BA;sCAwB2B;;0CAAzC;;sCADyC;;0CAAzC;;sCADqC;;0CAArC,8BAtBcA;;sCAqBuB;;0CAArC,8BArBcA;;sCAoBuB;;;2CAArC,8BApBcA;;;;;;;;;;;;;;;;qCAoBjB,eA5OkBy1G,IAyNhBz5H,OAkBA65N;kCAqD8B,gBA1EhCvtR;;;;;;;;;;;;;;;;;;;;;+CAkEE,IADoBw+H;+CACpB;;gDApBM,0BAmBcA;gDApBd,0BAoBcA;gDArBd;;sEAqBcA;;;;;;;;;;;;;;;+CArBd,eAlQU2uD,IAiQhBz5H;iDAyB4BvsC;6CAC5B;6FAD4BA;;mCAI5B;;iCAWO;kCAP6C4+P;kCAAPC;kCAAPC;kCAARC;kCAALC;kCAAJC;kCAAJ3uE;kCAAJC;kCACfm8E;;qCAA4C,IAArB/0U,WAAHyB,WAAwB,kBAArBzB;qCAAM,sBAATyB;kCAMX,4BAPMm3P;kCAON;;kCACA,4BARUD;kCAQV;;kCACA,4BATc2uE;kCASd;;kCAYH,qBArBgDL;kCAoBhD,qBApByCC;kCAmBzC,qBAnBkCC;kCAkBlC,qBAlB0BC;kCAiB1B;;uCAVN4N;uCAAIh8O;uCACJi8O;uCAAIl8O;uCACJm8O;uCAAIhmH;uCAQE,YAjBqBm4G;;;;;;;;;iCAiBrB,eAnTYh5F,IA4SlBh5H;;iCAoBJ;;;;4CAiDUujB;qCA1BO;sCAhBwCi9J,OA0C/Cj9J;sCA1CuCk9J,OA0CvCl9J;;sCA1CmCy4K;sCAAJC;sCAAXvb,GA0CpBn9J;sCA1CchqF,KA0CdgqF;sCA1CQo9J,KA0CRp9J;sCA1BO,0BAhBCo9J;sCAeD,0BAfCA;sCAcD,0BAdCA;sCAaD,0BAbCA;sCAYD,0BAZCA;sCAWD,0BAXCA;sCAUD,0BAVCA;sCASD,0BATCA;sCAKD,0BALCA;sCAID;;2CAJwBsb;2CAAID;2CAI5B,iBAJCrb;;2CAA+BF;2CAAQD;;;;;;;;;;sCA+B7C,0BA/BkBE;sCA8BlB,0BA9BkBA;sCA6BlB,0BA7BkBA;sCA4BlB,0BA5BkBA;sCA2BlB,0BA3BkBA;sCA0BlB,0BA1BYnnP;sCAyBZ,0BAzBYA;sCAwBZ,0BAxBYA;sCAuBZ,0BAvBYA;sCAsBZ,0BAtBYA;sCAqBP,0BArBConP;sCAoBD;;4DApBCA;;;;;;;;;;;;;;;qCAqChB,QA5WoB3nD,IAwUhB8mG;qCAoCJ,QA5WoB9mG,IA0VhB+iG;qCA1BF5xU;6CAiD+C;iCADnD;mCAEE;qCAnD2ByhD,wB,ORvgDjC20O,aQ+sCIk+C;;iCAyWA;;iCAMY;kCAFoC5iC;kCAAJ7pL;kCAAJn5C;kCAAPltB;kCAErB;;qCAFqBA,wB,OHpjDrC8vP,aGusCIgjC;kCA+WY;4CAEal7M;qCACvB;sCAAI9iG;;2CADmB8iG;;;;;;;;;;;;;;;qCACvB,eAzXoBy1G,IAyXhBv4M,UAkBqC;iCAE3C,OAvBIirB,QAEAq0R;iCAFQ;kCAgCF,qBAlCsClkC;kCAiCtC,qBAjCkC7pL;kCAgClC;6DAhC8Bn5C;iCAgC9B,eApZYmgK,IA+YlBgnG;;;kCAoBav0R;kCAEbw0R;4CAA4B18M;qCAC9B;sCAAI9iG;;2CAD0B8iG;;;;;;;;;;;;;;;qCAC9B,eAtaoBy1G,IAsahBv4M,UAkB2C;wD,OFxnDrDy7Q,aEusCIuiC;iCAqbI;0CAzBahzR;;4C,OsGr8Cf0qE,UtGu8CE8pN;;iCAiCM;kCARyCj8C;kCAAJC;kCAAJC;kCAAJC;kCAAJC;kCAAJC;kCAAJC;kCAQjB,qBARyCN;kCAOzC,qBAPqCC;kCAMrC,qBANiCC;kCAKjC,qBAL6BC;kCAI7B,qBAJyBC;kCAGzB,qBAHqBC;kCAErB;qDAFiBC;iCAEjB,eAhcYtrD,IA+blBknG;;iCAiDM;kCArBNhO;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAjkU;kCAoCM,qBAtBNojU;kCAqBM,qBAtBNC;kCAqBM,qBAtBNC;kCAqBM,qBAtBNC;kCAqBM,qBAtBNC;kCAqBM,qBAtBNC;kCAqBM,qBAtBNC;kCAqBM,qBAtBNC;kCAqBM,qBAtBNC;kCAqBM,qBAtBNC;kCAqBM,qBAtBNC;kCAqBM,qBAtBNC;kCAqBM,qBAtBNC;kCAqBM,qBAtBNC;kCAqBM;;mDAtBNjkU;;;;;;;;;;;;;;;kCAuCW,0BAxBXmjU;iCAyByB,eApfPl5F,IAielBmnG,aAkBAC;;iCAuDM;kCAtBNnN;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADeC;kCADfC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAh8E;kCADkBynF;kCAmDZ,qBArCNrM;kCAoCM,qBArCNC;kCAoCM,qBArCNC;kCAoCM,qBArCNC;kCAoCM,qBArCNC;kCAoCM,qBArCNC;kCAoCM,qBArCNC;kCAoCM,qBArCNC;kCAoCM,qBArCNC;kCAoCM,qBArCNC;kCAoCM,qBArCNC;kCAoCM,qBArCNC;kCAoCM,qBArCNC;kCAoCM,qBArCNh8E;kCAoCwB;;mDArCNynF;;;;;;;;;;;;;;;kCAqEZ,qBAxCNpN;kCAuCM,qBAxCNC;kCAuCM,qBAxCNC;kCAuCM,qBAxCNC;kCAuCM,qBAxCNC;kCAuCM,qBAxCNC;kCAuCM,qBAxCNC;kCAuCM,qBAxCNC;kCAuCM,qBAxCNC;kCAuCM,qBAxCNC;kCAuCM,qBAxCNC;kCAuCM,qBAxCNC;kCAuCM,qBAxCNC;kCAuCM,qBAxCNC;kCAuCqB;;mDAxCNC;;;;;;;;;;;;;;;iCAyDnB,QA/jBsB/6F,IA2hBlBsnG;iCAoCJ,eA/jBsBtnG,IA6iBlBunG;;iCAuEM;kCAnCN1L;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAl5R;kCADAm5R;kCADAC;kCAiDM,qBAnCNb;kCAkCM,qBAnCNC;kCAkCM,qBAnCNC;kCAkCM,qBAnCNC;kCAkCM,qBAnCNC;kCAkCM,qBAnCNC;kCAkCM,qBAnCNC;kCAkCM,qBAnCNC;kCAkCM,qBAnCNC;kCAkCM,qBAnCNC;kCAkCM,qBAnCNC;kCAkCM,qBAnCNC;kCAkCM,qBAnCNl5R;kCAkCM,qBAnCNm5R;kCAkCM;;mDAnCNC;;;;;;;;;;;;;;;iCAmCM,eAtmBY18F,IAqmBlB8mG;;iCAkEM;kCA/BN90U;kCADA2qU;kCADAC;kCADmBC;kCADnBv+T;kCADAw+T;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCA0CM,qBAnCN9+T;kCAkCM,qBAnCNw+T;kCAkCM,qBAnCNC;kCAkCM,qBAnCNC;kCAkCM,qBAnCNC;kCAkCM,qBAnCNC;kCAkCM,qBAnCNC;kCAkCwB;;mDAnCxBC;;;;;;;;;;;;;;;iCAqDF;0CAlrBoBp9F;0CA+pBlBwnG;;;2CA1BmB3K;2CACnBD;2CACAD;2CACA3qU;;iCAoHM;kCArCNqrU;kCADAC;kCADAC;kCADmBC;kCADnBC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCAmEM,qBAzCN1B;kCAwCM,qBAzCNC;kCAwCM,qBAzCNC;kCAwCM,qBAzCNC;kCAwCM,qBA5CNI;kCA2CM,qBA5CNC;kCA2CM,qBA5CNC;kCA2CM,qBA5CNC;kCA2CM,qBA/CNI;kCA8CM,qBArDNO;kCAoDM,qBArDNC;kCAoDM,qBArDNC;kCAoDM,qBArDNC;kCAoDM,qBArDNC;kCAoDM;;mDArDNC;;;;;;;;;;;;;;;kCAmFM,qBApENf;kCAmEM,qBA5DNP;kCA2DM,qBA5DNC;kCA2DM,qBA5DNC;kCA2DM,qBAjENM;kCAgEM,qBAjENC;kCAgEM,qBAlENE;kCAiEM,qBAlENC;kCAiEM,qBAlENC;kCAiEM,qBAlENC;kCAiEM,qBAlENC;kCAiEM;;mDAlENC;;;;;;;;;;;;;;;iCAmFJ;mCAlxBsB7+F;mCA6uBlBynG;;;oCAzBmBjK;oCACnBD;oCACAD;oCACAD;iCA2DJ,eAlxBsBr9F,IAgwBlB0nG;;iCAgFM;kCAtCatI;kCADnBC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCADAC;kCAqDM,qBAvCNd;kCAsCM,qBAvCNC;kCAsCM,qBAvCNC;kCAsCM,qBAvCNC;kCAsCM,qBAvCNC;kCAsCM,qBAvCNC;kCAsCM,qBAvCNC;kCAsCM,qBAvCNC;kCAsCM,qBAvCNC;kCAsCM,qBAvCNC;kCAsCM,qBAvCNC;kCAsCM,qBAvCNC;kCAsCM,qBAvCNC;kCAsCM,qBAvCNC;kCAsCwB;;mDAvCxBC;;;;;;;;;;;;;;;iCAwDwB,eAn1BNngG,IAi0BlB2nG,kBAvBmBvI;;iCA4CrB;kCAFoCgB;kCAAR30K;kCAANvzJ;kCAEtB;;;8CAAsB/G;uCAIlB;;kDAAuC,oCANfs6J,OAENt6J,UAI+B,EAAC;iCAJtD,eAt1BoB6uO,IAq1BlB4nG,SADoB1vU,KAAckoU;4BAW/B,yBAA2B,OAFpC4E;4BAES,2CACH;;kCArqCNxgQ;kCAkCAg4J;kCAhBAkmG;kCASApmG;kCAZAmmG;kCASAlmG;kCAHAomG;kCAUAE;kCAKApmG;kCAEAsmG;kCA+RA1mG;kCApYAylG;kCAmOAjrK;kCArFIqsK;kCAuFJwB;kCAQIhpJ;kCANJipJ;sBA8/BH;;sB9D/iEGl8L;sBI4HFwV;sBADAD;sBJ5HExV;sBujBVN;;sBnH+EoB;;;0BmHkCe;;;2BAA/B;2BAGe;;2BAEI;mCAHjBu/L,aAIer6O;4BAAQ,eAHrBm6O,mBAGan6O,MAAwD;0BADtD,SAEfs6O;4BACF,UAJEtlT;4BAIF,UAEI,IADGulT,eACH,OADGA;4BADP,UALEJ;4BAUU;6BAIF,eALFn6O,MAIK/2F;;iCAJL+2F,MAGE;4BAAuC,qBAgBlChrE,IAAI5V;8BACT;;uDAA6B,iCADxB4V,IAAI5V,KACkD,EAAC;4BAjBrB,qBAOhCA;8BACP;;;yCACU,oCAFHA;yCAEG,UAEF,IADG4V,aACH,UADGA;yCAGH,oBAEiC,EAAE;4BAV/C;sDACa,OAtBnB3zB,IAsBuB;6BAcX,eAvBJ2+F,MAOAw6O;4BAgBI;oDACAlqQ,aAFJC,IAEID;;8BAGQ,IAANmqQ,MAAM,wBAlClBL;8BAqCY,OA9BNp6O,sBA8B4B,yBAIT;8BAPP,IALZzvB,IAKMkqQ;4BAYV,YAjBIlqQ;4BAiBJ,OAjBIA,GAkBH;0BA/CY,SAmDjBuG,OAAQ/hD,gBAAgBo2B;4BACd;2DADcA;6BAGxB,0CAHwBA;6BAMlB,8BANkBA;4BAMlB;8BAKF,IADGuvR;8BACI,qBAXH3lT,gBAUD2lT;;8BACH,IANFC,kBAKKD;;8BAFH,wBARoBvvR,GAAhBp2B;kCAKN4lT,kBALM5lT;4BACE;6BAcZ;6BAGoB;6BADlB;;;gCAhBEH;gCACA/B;gCAaA+nT;gCAVAD;;4BAYF,UADExmU,MAhBsBg3C,GAoBb;0BAvEM,SAyEjBtvB,GAAG5yB,GAAI,gCAAJA,KAAwC;0BAzE1B,SA2EjB6qS,GAAG7qS,GAAI,OAAJA,CAAK;0BA3ES,SA6EjB4xU,gBAAgBj1U,GAAiC,yBAAjCA,GAAkD;0BA7EjD,SAgFjBk1U,eAAgB7xU;4BAElB,SAAI0B,EAAEzB;8BACE,kCADFA;8BACE,yBAIF;8BAJE,IACkBxD;8BACpB,wBADoBA,OAGR;4BAaM;qCApBNuD;6BAmBJ,QAnBIA;6BAkBL,QAlBKA;6BAiBI,QAjBJA;6BAgBL,QAhBKA;6BAeD,QAfCA;4BAeD,eADHxF;8BAAO,0BAdHwF,QAcJxF,UAAoC;4BAD9C;2CAFUA;8BAAO,0BAXHwF,QAWJxF,UAA6B;4BADvC;;;;;;;;0CAWH;0BArGkB;kCANjBpC;kCAGAg5U;kCAKEC;kCAiDFxjQ;kCAsBAj7C;kCAEAi4Q;kCAEA+mC;kCAGAC;sBAsBH;;sBvjBjNG//L;sBI4HFwV;sBADAD;sBJ5HExV;sBwjBVN;;sBAakB;;sBxjBFZC;sBI4HFwV;sBADAD;sBJ5HExV;sB+DVN;;sBqY+EoB;uBrY/EpB;iCA0Ca7xI;0BACkB,4B;0BAApB,+BADEA,cACsC;uBA3CnD;iCA6CakpE;0BACX,mBAAetnD,KAAMniB,GAAK,mBADfypE,GACItnD,KAAMniB,EAA0B,EAAG;;;;;;;;;;0BAMlD,eACUypE;4BAAsC,IAAflgB,MAAe,WAAS,UAA/CkgB;;8BAA6B;yCAAN2kG,uCAAK,EAA5B3kG,GAAuBlgB;;0DAAsC;0BADvD;;;;;;;;;wD0G4RR8tG;yC1G3RgE;sBqY0BtD;uBrYjBhBk7K;iCAAQxqQ,UAASxnE;0BACnB;2CACU4hB,KAAMniB;oCACV,qBAC2C7C;sCAAd;yCAAUs+N;;;;;4CAGnB;6CADF0xE;6CAAJz/R;6CAAJC,GAF6B8tN;6CAGnB,gBALVz7N,EAEyBiU,MAEjBk5R,GAAJz/R,GAAJC;4CACU,UAAN6kU,QAH6Br1U;sCAMjC,UANyB8W,MAAQ9W,EAAJs+N,IAMd;oCANvB;sDAJWl7N,QAET4hB;qCAEF;;uCADMs5M;;;;;;sDAmBJ;0CARA,kBAZMz7N,EACNiU;wCAaA,kBAdMjU,EACNiU,kBAHA8zD;sCAkBA,kBAhBM/nE,EACNiU,YAHA8zD;oCAoBA,OAjBA9zD,EAmBY,EACrB;;;;;;;;;;0BAGD,eACUw1D;4BAEE;sCAFFA;6BAGO,kBAAQ,SAAiB,UAHhCA;6BAIE,SADJgpQ;6BACI,EAFJ5yU;6BADJ;6BAMW;8CAFPjB;;gCAE0B,WAF1BA,sBAEyD,OANzDmpE,SAMgE;6BAAjE,aAPG0B;6BAUH;;gCAPCgpQ;;kCAOkB;4CAAM/kU,MAAIC,MAAIE,OAAsB;6BAAvD;;6BAESmwC;;8B,O4H6YZ06D,abzYE6c;qC/GJU/K;8BAAI;gDAAJgmD,0CAAG;uCAAHpB;6CAAQ;;8BAAR5tH;4BACL,oBAXH3hD,mBAEAX;0DASoB;0BAdZ;;;;;;;;;wD0GwPRm4J;yC1G1OsB;sBqYvBZ;uBrYyBhBq7K;;0BACF;gDAEgB1yU;oCgOysBhB;oCACoB;iDAAc;sCAA2B;;uChOvsB/C2sL;iDADAnsL;mDACAu0E,OAAOh6E,EAAEg0C;4C;qDAHP/uC,EAGO+uC,IALD,iBAIRvuC,MACOzF,cAA+B;iDAAtCg6E;uDADAv0E;uCAEJ;;;;;;;uCgOssBqC;;;+ChOrsBA,EAC9C;sBAiByD;;sB/DvHtD6xI;sBI4HFwV;sBADAD;sBJ5HExV;sBgdVN;;sBZ+EoB;uBY/EpB;iCAkBa7xI,EAAExF;0BACP;wDAA8B,cADzBwF,EAAExF,iBAC8D;uBAnB7E;iCAqBaiC;0BACH,iBADGA,GACH,WAAJ6C;0BAAI;mCACJiuN;4CAC0Bq/D;qCAC1B,SAAI3sR,EAAEzF;uCACJ,IAAI83U,SAFoB1lD,cACpBpyR;uCAED,gBANEiC,EAKD61U,UADA93U,GAEiC;qCAGoB;;sCAAR;sCAAR;sCAAR;sCAAR;sCAAR;sCAAR;qCAAR;;;;;;;;;;;;;;;oDAA4D,EAAE;uBA9BvE;iCAgCaiC;0BACX;mCADWA;;4CACuCjC,EAAEg0C,IAAIvuC;qCACzC,cADqCuuC,IACrC,aAAY,SAD6BvuC,OAANzF,OACU,EAAE;uBAlChE,cAuDMuwN,aAEAD;uBAzDN;;;;;wCAgES9qN,GAAI,0BAAJA,EAAyB;uBAhElC;iCAkEgBlD,EAAEkD;0BAAoB,kBhThD9BwhH,cgTgDQ1kH,EAAsB,mBAApBkD,GAA4B;uBAlE9C;iCAoEcA,GAAY,sCAAZA,GAAyB;uBApEvC;;0B;4BAwEM,IADMhD,WACH,2BADGA;0BAGN,YAAsC;uBA1E5C,oBAgCIu1U,WAXAF;uBArBJ;;;;;;;;sBAqFI;;sBhd1EEvgM;sBI4HFwV;sBgcxDgB;;;yBY3EhB+iE;yBAgEAqoH;yBAEAC;;;;;;;;;;;yBApBAvoH;yBAgBAqoH;yBAFAD;;;yBAhDAhoH;yBAgCAK;yBAFAP;yBAVAC;yBAIAG;yBAFAD;yBAMAE;yBAFAC;yBAhCAI;yBAFAC;yBAIAC;yBAEAC;yBAIAinH;yBAZAjoH;yBA0BAooH;yBAXAF;sB5ciHAhrL;sBJ5HExV;sBgEVN;;sBoY+EoB;;;0BpY0HL;;2BAED;2BAEyB,iCArEtBr3I;2BAqEQ;;;;4BAQrBwtE,kB,yBAAAvrE,EAAyD;0BARpC,SAQrB26O,UAAS36O,8BAAG;0BARS,SAQrB66O,UAAS76O,8BAAG;0BARS;;;;;;mCAQrBywF,iCAAyD;0BAE9B;4CAVvB0lP;2BAoBA;+BAEK,0BAZLE;0BAUA,SAKEtmK,WAAe5yJ,IAAM0nI,QAAQmrB;4BAC/B,sCADuBnrB,WACiC;0BANxD,SAQE+qB,kBAAe,OAlBjBymK,eAkBgC;0BARhC,SAUExmK,YAAY1yJ,IAAK9F,IAAI9T;4BACd;2CyJpEbw9J,iBzJoEiC,mBADNx9J;6BAEf,gBADJk7N;4BAEJ,kBAFIA,KADUthN,IAAK9F,IAEfxU;4BAEI,GAFJA,IAtBJwzU;8BAyBoB,UAzBpBA;8BAyBoB,cAHhBxzU;oCAGF9E,EAHE8E;gCAIA;gDANUsa,IAAK9F,MAKjBtZ;kCACE,UADFA;;;4BAGF,OARmBsZ,MApBnBg/T,mBA4B2B;0BAlB3B,SAoBEpmK,aAAW9yJ,IAAK0nI;4BAClB;mCADkBA;6BAEI,8BAFT1nI;4BAGV,GADCm5T,kBAhCJD;6BAkCE;gDAlCFA,gBAgCIC;4BADJ;6BAOI;;gCyJnFRx1K,gBzJ2EsBjc,eA9BlBwxL,iBA8Bal5T;6BAOX;4BAGS,aAxCXk5T,kBA8BkBxxL;4BAUP,OAJPthJ,CAKH;0BA/BD;;;;+BADE8rK;+BASAO;+BAEAC;+BAUAI;+BAfAF;2BALF;;;;;;;;mCAkCA5nG,SAAMnoE,EAAEzB;4BAAI,2CAANyB,EAAEzB;4BAAI,sCAAoB;0BAlChC,SAoCAmhH,SAAM1/G,EAAEzB;4BAAI,2CAANyB,EAAEzB;4BAAI,sCAAoB;0BApChC,SAsCAohH,SAAM3/G,EAAEzB;4BAAI,2CAANyB,EAAEzB;4BAAI,sCAAkB;0BAtC9B,SAwCA+sC,OAAOtrC,GAAI,gBAAJA,IAAS;0BAxChB,SA0CIu2U,mBAAmBr2U,EAAEC;4BACxB,cAvDLorE,MAsD6BprE,EAlEzB4rD,OAmEmB,UADI7rD,EAnIdnC,EAiETguD;4BAqEM;sDAHmB5rD,EAGE,mBAHJD,EAAEC;6BAGnB;;;4BAEK;oCADT/D;oCAAMmC;oCACG,SADNyB,EACU,SAAC,mBALOE,EAAEC,GAIjB5B,IACoB;0BA/C5B,SAiDAi4U,WAAWx2U;4BACE,6BADFA,WACE;mCAARE,CACN;0BAnDC,SAqDAwzI,IAAI1zI;4BAAI,mCAAJA;4BAAI,sCAAyB;0BArDjC,SAuDA4/G,SAAM5/G,EAAEzB,GAAQ,gBAAVyB,EAAU,WAARzB,GAAoB;mCA3K9B8nE,OAAOrmE,EAAE6C;4BACH,yBADGA,GASC,IARRX,UACO6vC,IAyBEh0C,EAzBE2oE;4BACb;8BAAQ,GADKA,QACO,OADX30B;8BAGG;4CAHHA;+BAIM,yBANNlvC,EAEI6jE,KAIwB,SAD/B3a,MALC/rD,GAKD+rD;+BAEQ,IALD2a;+BAAJ30B,IAIH24B;+BAJOhE;uCAOG;0BAGqB;;2BAAb;2BAAT,yBAyFb0vQ;2BAzFa;mCADf7vG,UAEEvmO;4BAAW,kBA2FfurE,MA3Fe,OAAXvrE,EADAy2U,OAeS14U,EAdkB;0BADd;2BA8BbwF;;;+BAX6B;;gCAAR,qBAsErB6yU;gCApFS1vQ;+BAAI;iCAAG,sBADJ7jE,EACH6jE;mCAgBH,yBAjBM7jE,EACH6jE,KAUAiI;mCAAI;qCAQuB,gCAR3BA;;uCAA6B;;wCAYI;wCAAb;wCAAL,yBANtBprE;wCAMsB;uCADK,UArBpBmjE,IAqBoB,OAXI1mE,EAM/BuD;qCAEkC,IARiB,aAA5CorE;;iCAV4C,QAA5CjI;;0BALI,SAiCX00B,KAAMs7O,QAAQvxT,KAAKniB;4B,IAALsvI;4BACpB;8BAAG,cADSokM,QAAQpkM;gCACmB,sBADdtvI,EAALsvI;8BACmC,OADnCA,OACuC;0BAlC1C,SAoCXmuF,KAAKtgO,EAAE0C;gCAAF8+F,MAAE5gD;4BAAI;8BAAG,mBAAPA;gCAAuC,QAAvCA,YAAuB,WAAzB4gD,aAAE5gD;;8BAAmD,OAArD4gD,IAAsD;0BApChD,SAsCfykI,KAYElmO;4BACF;gDArBEqD;6BAqBF,oBArBEA,mBqI7HJqmE,iBrI6HIrmE;6BAyBA;;;6BAEM,SAPNrD,EAGIy2U;6BAKE,WARNz2U,EAOEO;6BAEI,WADJT,EADAS;4BAEI;8BAKJ;8BAxBJ;gCAGE;gCAAkB,iBAAZm2U,KAAKxgU,UAA+B;8BAH5C;wCAwBcjW;+BAxBd;;;qCACU,IAAMy2U,aAAe,sBAmDjCrrQ,MAnDkBqrQ,IA1BL74U,EA0BoC;;;;+BAyBjC,OAFHqjC,GAAS7+B;+BAGN,WADJ9B;+BAEgB,eAJTT,EAEPS;8BAEK,UADL61J,IACK,SAJDn2J,EAGJm2J,iBACgC;4BATlC;sCAP2Bl1H,EAO/BjhC,EADAH,EAP4BuC;6BAU9B;;yCACeuU,GAAS,sBA8B5By0D,MA9BmBz0D,KA/CN/Y,EA+C8B;;;6BADvC;mCADIg8F,GAUL;mCA+FD88O,UAAU72U,GAAI,0BAAJA,UAAsB;mCAEhC82U,iBAFc,YAAkB;mCAIhC5wG,OAAO3iO,G,0BAAAA,IAA8B;mCAErCwzU,SAAS98J,IAAI94K,GAAGE;4BAClB,SAAI21U,mBAAmBn0U;8BAAI,uBAAJA,GAAI,gCAAiC;4BACnC,yBAFdo3K,IAAI94K,GAAGE,IACd21U,mBACsD;mCAGxDC,cAAch9J;4BACL,IAAPj1K,KAAO,gCAxFPoxU;4BAyF6B,gBAFjBn8J,IHrHcloI,IGuHG,SAD7B/sC,KHtHa2pN,cGuH2B;0BAEpC,IAAN10C,IAAM;mCAENmf,SAASj4L,GAAGE;4BACd,SAAI61U,mBAAmB3zU;8BAAI,uCAAJA,GAAqC;4BACX,6BAFnClC;4BAEW,8CAFdF,UAE6D;0BAExD,IAAd8kO,YAAc;mCAEdx5B,iBAAiBtrM,GAAGE;4BACtB,SAAI61U,mBAAmB3zU;8BAAI,uCAAJA,GAAqC;4BAE1D,6BAHoBlC;4BAEW;2EAFdF,UAGM;0BALT,SAOd4+F;4BAAY,2BAPZkmI,YAO+C;0BAPjC,SASdkxG,UAAUt0U;4BACZ;6CAEiBkvC,IADD/uC;0CACC+oD,UAAIhuD;sCACb;wCAAQ,GADKA,MAlHjBo4U,eAmHqC,OADxBpqR;wCAE6B;6CAFzBhuD;yCAEL,iBAHAiF,EACC+oD,MAEM,mBALXlpD,EAGS9E;yCAAJguD;yCAAIhuD;iDAIN,EACd;0BAEW,SAAV8gO;4B,OoG/II90G,UrG7INsrN,WCkRE8B;0BAUU,SAEVlsQ,KAAKpoE,GAAwC,0BAAxCA,GAAqD;0BAFhD,SAIV+9N,QAAQzzL;oCAjIN4e,kBAiIM5e;;;oCAIDsxL,YAALt+N;;iCACmC;2DAvM1BpC;kCAuMH2sE,MAAgB;;qCAAhBA;gCACQ,wBADRA,oBADD+zJ;;8BAKN,iDAA0C;0BAbjC;mCAuBVtsL,OAAOnyC,GAAI,kCAAJA,EAAwB;;;;;;;;;;8BAE8B;;+BAAb,UAAC;+BAAZ;+BAAHymQ;+BAAG;;+BAAHzlN;;sEAAC;;uCAAD2D,qDAAoC;;;;;;;;;;8BAItD;;+BAAZ;+BADN;8BACM,4BAjJFyxR;gCAkJgC;qDAAa;iCAAjC,QAAM,iBAFlBj2U;iCAESsmQ;iCAAG;;iCAAHzlN;;;0EAAC;;yCAAD0D;8BACR,QAAE;;;;;;;;;;8BAGP,SAAQ37B,IAAI7oB;gC;;;wCAGHusE,cAALzsE;;;;;;;iDACiB01C;2C,GAAAA;;;mFAAC;;oDAAD+O;4DAJTvkD,EAGRF;sCACkC;6DAD7BysE;kCADH;8BAII,IAANwtG,IAAM,2B6HlDZjhD;8B7HkDY;;;;;;;;;uCAANihD;gDACmCp3K;yCAC3B;kDAD2BA;0CAErB,YADVk+C;0CAE4C,uBAF5CA;0CAE+B;0CAAV,0BAFrBA;yCAEA,gBAAM,iBADNmsB,WACsD,EAAE;;kCA7JhEytK;;;;;;;;;;;;;;;;;kCAHIy7F;kCA1ESr4U;kCAiETguD;kCA0DAoc;kCAIAw3C;kCAFAD;kCAmBAE;kCAfAt0E;kCAoCF2uI;kCAEAmf;kCAIA6sC;kCAEAx5B;kCAKA1sG;kCAmCA5tD;kCAvEEuhG;kCAYFwyF;;;;kCAwCAtF;kCA1CAk2G;kCAFAD;kCA8BAM;kCAYAlsQ;kCAFA4zJ;kCAzHEs3G;kCArFF5vG;kCAuCAH;sBA+mBH;;sBhEnwBG/wF;sBI4HFwV;sBADAD;sBJ5HExV;sB0eVN;;sBtC+EoB;uBsChDZ;;;;;;;uC3K+N0B6sG;;uB2K/N1B;iCAAQ/hP,G,UAARk3U,kBAAQl3U,KACuC;uBAoB/C;;;;;;;uC3K0M0BijP;;uB2K1M1B;iCAAQjjP,G,UAARo3U,kBAAQp3U,KACuC;uBAD/C;iCAAKq2K,UAALh0K;0B,kB3K0M0B6gP,c2K1MrB7sE,UAALh0K;;iCAAKi0K,QAALr5J;0B;8C3K0M0BkmO,e2K1MrB7sE,SAALr5J,UAC+C;uBAD/C;iCAAK45H,KAAL55H;0B;8C3K0M0BmmO,c2K1MrBvsG,MAAL55H,YAC+C;uBAD/C;iCAKJy9N;0CAAY56O;4BAAZ,6B3K8LA0jP,Y2K9LA9I,QAAY56O,EAAqB,CACc;uBAN3C;iCAKJ46O;0CAAY56O;4BAAZ,6B3K8LA2jP,Y2K9LA/I,QAAY56O,EAAqB,CACc;uBAN3C;iCAKJq7I;0BAAe;mC3KwSbkoG;4C2KxSU4E,+BAAZ9sG,MAAY8sG,YAAE;mCAAdH;yCAAiC;uBAL7B;iCAKJ3sG;0BAAe;mC3K4SbooG;4C2K5SU9sE,+BAAZt7B,MAAYs7B,YAAE;mCAAdF;yCAAiC;uBAL7B;;wC;uBAAA;wC;uBAAA;;0B;uBAAA;wC;uBAAA,sB;uBAAA;;0B;uBAAA;;0B;uBAAA;;0B;uBAAA;;2BhbEU;;4BAEK;yCAFjB6hK,UAEAC;2BAAiB,SAIjBC,OAAOj1U;6BACE,IAAP4B,KAAO,yBADF5B;6BAEQ,sCAA0B,SADvC4B,OAC8D;2BAN/C,SAQjBszU,cAAcl1U,GAAW,2BAAXA,GAAmB;2BARhB,SAUjBknH,UAAUlnH,GAAI,kCAAJA,GAAqC;2BAV9B,SAYjBm1U,cAAgBhjS,IAAgBn1C;6BAClC,GADkBm1C,IAAU,QAAVA,eAAUi7B,aAAV0kB;6BACc;+BAAb,gBADe90F;;;;+BACS,gBADTA;;;+BAE1B,IAAJ+2D,IAAI,YAF0B/2D;+BAGlC;;;;;;4DAA2B,iBAHT80F,kBAEd/9B,IAC6D;2DAEtD;;;;;;;;;;+BAIT;;wCAiCI92D,oBAjCqD,6BAAgB;gCAEnE,gBAAO,SAHXwR;gCAIiB,qBAAkB,cAAe,gBAA3Cu7D;gCAAU;;gCAAVvsB;;mDsHjDP0gI,WtHiDOrR,YAAM;;wCAANvsH,OsHjDP09H,atHiDOh0D,oCAA8D;oCAEvE8oD,UAAU/1K;6BAAkB,kCsHnD1BghL,atHmDQhhL,GAAsC;2BAShD;;2CAEK;2BAFL,SAKEwvK,WAAe5yJ,IAAM0nI,QAAQmrB;6BAC/B,sCADuBnrB,WACqC;2BAN5D,SAQE+qB,kBAAe,OAWbpvK,GAX4B;2BARhC,SAUEqvK,YAAY1yJ,IAAK9F,IAAI9T;6BACX,IAARyO,MAAQ,yBADWzO;6BAGvB,yBAFIyO,QADUmL,IAAK9F,IASf7W;6BANJ,OAHmB6W,MASf7W,OAJK;2BAfT,SAiBEyvK,aAAW9yJ,IAAK0nI;6BAClB;oCADkBA;8BACI,8BADT1nI;6BAGV,mBAFCm5T,gBACA91U;+BAEF;iEAHE81U;6BAAJ,IAKItkU,MAAQ,yBANCmL,IAAK0nI,WAEdrkJ;6BAIQ,aAJRA,MAFcqkJ;6BAMN,gCAAR7yI,MAEU;2BAzBd;;;;gCADEq9J;gCASAO;gCAEAC;gCAOAI;gCAZAF;4BALF;;;;;;;;oCA4BA4oK,WAAWp4U,EAAGyJ;6BAAO;sCAAVzJ,EAAU,sBAAVA,GAAGyJ,KAA0C;2BA5BxD;;;;;;;;;mCATAssK;mCAhBA7rD;mCAzDJ4tN;mCAEAD;mCAEAD;mCAEA3mG;mCAEA0mG;mCAIAD;mCAEAD;mCAEAD;mCA6BIO;mCAEAC;mCAsDI/3U;mCAlDJg4U;mCAIAC;mCAIAC;mCAmDAC;;uBgbnEE,sB;uBAAA;;0B;uBAAA;;0B;uBAAA;;yC;;;;uBAAA;;0B;uBAAA,sB;uBAAA,sB;uBAAA;;0B;uBAAA;;0B;uBAAA;wC;uBAAA;;0B;uBAAA;;0B;uBAAA;;0B;uBAAA,sB;uBAAA,sB;uBAAA,sB;uBAAA,sB;uBAAA,sB;uBAAA;;0B;uBAAA,sB;uBAAA,sB;uBAAA,sB;uBAAA,sB;uBAAA,sB;uBAAA;8C;uBAAA;8C;uBAAA;8C;uBAAA;8C;uBAAA,sB;uBAAA,sB;uBAAA,sB;uBAAA;wC;uBAAA;;;;2C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAAA,sB;uBAAA;;0B;uBAAA;;0B;uBAAA;;yC;;;;uBAAA;;0B;uBAAA,sB;uBAAA,sB;uBAAA;;0B;uBAAA;;0B;uBAAA;wC;uBAAA;;0B;uBAAA;;0B;uBAAA;;0B;uBAAA,sB;uBAAA,sB;uBAAA,sB;uBAAA,sB;uBAAA,sB;uBAAA;;0B;uBAAA,sB;uBAAA,sB;uBAAA,sB;uBAAA,sB;uBAAA,sB;uBAAA;8C;uBAAA;8C;uBAAA;8C;uBAAA;8C;uBAAA,sB;uBAAA,sB;uBAAA,sB;uBAAA;wC;uBAAA;;;;2C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAAA;uBA4CI;uCAAJx4U;uBAAI,sB;uBAAA,sB;uBAAA,sB;uBAAA;8C;uBAAA;8C;uBAAA,sB;uBAAA;8C;uBAAA;;0B;uBAAA;;;yC;;;;;;;;;uBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wC;;uBAAA;;;;;;;;;;uBAYA;yCAAJwhG;uBAAI,sB;uBAAA,sB;uBAAA,sB;uBAAA;8C;uBAAA;8C;uBAAA,sB;uBAAA;8C;uBAAA;;0B;uBAAA;;;yC;;;;;;;;;uBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wC;;uBAAA;;;;;;;;;;+C,IAeOkiK;uBAfP;wC,IAiBSC;uBAjBT;iCAqBHA,UAAUD,SAAe,UAAzBC,UAAUD,QAAqC;uBArB5C;;;;;8BAmBJw1E,OAJAx1E,QAEAC;uBAjBI;wC,IAgCOD;uBAhCP;wC,IAkCSC;uBAlCT;iCAsCHA,UAAUD,SAAe,UAAzBC,UAAUD,QAAqC;uBAtC5C;;;;;8BAoCJ01E,OAJAtiD,UAEAqiD;sBAMJ;;sB1ezIEjkM;sBI4HFwV;sBADAD;sBJ5HExV;sByjBVN;;sBrH+EoB;uBqHvEV;;0BlhBgBJgwH;mCkhBhB+BplQ;4BACV,mCADUA;4BACV,wCAA+B;uBADhD,SAFAw5U;uBAEA;;0B;uBAAA;;0B;uBAAA;;0B;uBAAA;;0B;uBAAA;;0B;uBAAA;;;2B;;;;;;uBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wC;uBAAA;;;;;;;;;;;;;;;sBAEF;;sBzjBCFnkM;sBI4HFwV;sBADAD;sBJ5HExV;sB0jBVN;;sBtH+EoB;uBsHvEV;;0BnhBkBJiwH;mCmhBlB+BrlQ;4BACV,mCADUA;4BACV,wCAA+B;uBADhD,SAFAy5U;uBAEA;;0B;uBAAA;;0B;uBAAA;;0B;uBAAA;;0B;uBAAA;;0B;uBAAA;;;2B;;;;;;uBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wC;uBAAA;;;;;;;;;;;;;;sBAEF;;sB1jBCFpkM;sBI4HFwV;sBADAD;sBJ5HExV;sBiEVN;;sBmY+EoB;uBnY/EpB;;;;;;;;;;;;;;;+CASkB,sBAAgB;uBATlC;;;;;;2B;uBAAA;;;;;2B;;uBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6C;uBAAA;;0B;uBAAA;;+C;;;uBAAA;;;2B;;uBAAA;;;2BAqDMxwF;;;;;;;;;;uBArDN;iCAgFqBg1R,IAAIpyN;0BACnB;;qCAAiC,8CADlBoyN,IAAIpyN,GACiC,EAAC;uBAjF3D;iCAmFsBp2C,OAAQg9N,GAAgBvzE,QAAQE,UAAU++G,WACxDC;0BAEF,SAAIpL,gBAAgB5wU;4BAEf;8CAFeA,EAEX,8BAL+B88N;6BAKX,qCALWA,QAGpB98N;4BAGM,UAHNA,IAGM,8BANc88N;4BAMd,qCANsBE,gBAMP;0BAKvC;6DAXsBqzE,MAGpBugC;2BAUW,SAAa,iBAHxBqL;2BAOF;;8BqfnGJ7qC;uCrfmG+Dl7Q;gCACzC;;uCALhB46S;iCAKgB;;sCACdx6S;kCACE;oCAAwD;;;yCAAtB,iBAVtC2lT,iBAOyD/lT,cAEvDI;;oCACE,8BAFEo4H;oCAEsD,UAD1Dp4H;;;gCAGA,OAJIo4H,OAIG;0BALX;mCAjBcr7E,OAAQg9N,MAgBpB76Q,aAhBsDumT,WACxDC,WAuBgD;uBA3GxD;iCA6GsB3rC,GAAgBvzE,QAAQE,UAAU++G,WAAWC;0BAC7D;4CACU3rC,GAAGh2E,gBAAgB/oM,gBAAgBmE;qCACzC;;gDACI;yDAFE46Q,GAAGh2E,gBAAgB/oM,gBAAgBmE,SAEa,EAAE;mCAJ5C46Q;mCAAgBvzE;mCAAQE;mCAAU++G;mCAAWC,WAIC;uBAjHpE;iCAmHiC3rC,GAAgBvzE,QAAQE,UAAU++G,WAC3DC;0BACF;4CACU3rC,GAAGh2E,gBAAgB/oM,gBAAgBmE;qCACzC;;gDACI;yDAFE46Q,GAAGh2E,gBAAgB/oM,gBAAgBmE,SAEwB,EAAE;mCAL5C46Q;mCAAgBvzE;mCAAQE;mCAAU++G;mCAC3DC,WAIuE;uBAxH/E;iCA0HgB3rC,GAAgBvzE,QAAQE,UAAU++G,WAAWC;0BACvD;;qC;;mCADU3rC;mCAAgBvzE;mCAAQE;mCAAU++G;mCAAWC,WACQ;uBA3HrE;;;;yBA0HQE;yBAbA5rC;yBAMAC;;2B;yBAnCAC;uBAhFR;;;;;;;;;2BAmEM1pP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAnEN,6BAsJ2B,QAAE;uBAtJ7B,8BAwJ4B,sBAAe;uBAxJ3C,SAsJYq1R,aAEAC;uBAxJZ;;;;;;;uC;sBmY+EoB;uBnY6FH;iCApIIhkT;0BACnB;iCADmBA;2BAJD,kBAICA;2BAJD;;8BAAd3c;uCAC2Bzb;gCAC3B,6CAFAyb,YAC2Bzb,EAC0C;;4B,+BAEtDo4B;uBAoIJ,WAATikT;uBAAS;sBAEb;;sBjEnKE/kM;sBI4HFwV;sBADAD;sBJ5HExV;sBkEVN;;sBkY+EoB;uBlY/EpB;;;;;;;;;;;;;;;iDASkB,sBAAgB;uBATlC;;;;;;2B;uBAAA;;;;;2B;;uBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6C;uBAAA;;0B;uBAAA;;+C;;;uBAAA;;;2B;;uBAAA;;;2BAsDMtwF;;;;;;;;;;uBAtDN;iCAiFqB80R,IAAIpyN;0BACnB;;qCAAiC,8CADlBoyN,IAAIpyN,GACiC,EAAC;uBAlF3D;iCAoFsBp2C,OAAQg9N,GAAgBvzE,QAAQE,UAAU++G,WACxDC;0BAEF,SAAIpL,gBAAgB5wU;4BAEf;8CAFeA,EAEX,8BAL+B88N;6BAKX,qCALWA,QAGpB98N;4BAGM,UAHNA,IAGM,8BANc88N;4BAMd,qCANsBE,gBAMP;0BAKvC;6DAXsBqzE,MAGpBugC;2BAUW,SAAa,iBAHxBqL;2BAOF;;8BofpGJ7qC;uCpfoG+Dl7Q;gCACzC;;uCALhB46S;iCAKgB;;sCACdx6S;kCACE;oCAAwD;;;yCAAtB,iBAVtC2lT,iBAOyD/lT,cAEvDI;;oCACE,8BAFEo4H;oCAEsD,UAD1Dp4H;;;gCAGA,OAJIo4H,OAIG;0BALX;mCAjBcr7E,OAAQg9N,MAgBpB76Q,aAhBsDumT,WACxDC,WAuBgD;uBA5GxD;iCA8GsB3rC,GAAgBvzE,QAAQE,UAAU++G,WAAWC;0BAC7D;4CACU3rC,GAAGh2E,gBAAgB/oM,gBAAgBmE;qCACzC;;gDACI;yDAFE46Q,GAAGh2E,gBAAgB/oM,gBAAgBmE,SAEa,EAAE;mCAJ5C46Q;mCAAgBvzE;mCAAQE;mCAAU++G;mCAAWC,WAIC;uBAlHpE;iCAoHiC3rC,GAAgBvzE,QAAQE,UAAU++G,WAC3DC;0BACF,sBAA0B;uBAtHhC;iCAyHgB3rC,GAAgBvzE,QAAQE,UAAU++G,WAAWC;0BACvD;;qC;;mCADU3rC;mCAAgBvzE;mCAAQE;mCAAU++G;mCAAWC,WACQ;uBA1HrE;;;;yBAyHQY;yBAXAF;yBAMAC;;2B;yBAnCAhsC;uBAjFR;;;;;;;;;2BAoEM3pP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBApEN,6BAqJ2B,QAAE;uBArJ7B,8BAuJ4B,sBAAe;uBAvJ3C,SAqJY61R,aAEAC;uBAvJZ;;;;;;;uC;sBkY+EoB;uBlY4FH;iCAlII1kT;0BACnB;iCADmBA;2BAJD,kBAICA;2BAJD;;8BAAd3c;uCAC2Bzb;gCAC3B,6CAFAyb,YAC2Bzb,EAC0C;;4B,+BAEtDo4B;uBAkIJ,aAAT2kT;uBAAS;;sBAEb;;sBlElKEzlM;sBI4HFwV;sBADAD;sBJ5HExV;sB2jBVN;;sBA2CG;;sB3jBhCGC;sBI4HFwV;sBADAD;sBJ5HExV;sBmEVN;;sBiY+EoB;uBjY/EpB;;;;;;;;2BAGM2lM;2BAEAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAOS,SAAPvqP,Y,OiG2KEs5B;0BjG3KK,SAEPjF,YAAYjgG,MAAMthB;4BAA2B;qCAAjCshB,MAAiC,iBAA3BthB,GAA4C;0BAU9D;;2BAmBF,gCApBI03U;2BAoBJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BA/BExqP;6BAEAq0B;;;;6BAQAm1D;2BAqBF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BA/BErpF;6BAEAswF;6BAEA/sG;6BAEA4hD;6BAEAjD;6BAEAs5F;;;2BAqBF;;;;mCAYA31H,mCAAqD;0BAZrD;;;;;mCAcIuiM,iBAFJ,YAAqD;0BAZrD,SAgBIr+C,UAAUp3O;4BAA4B,uCAA5BA,GAAyC;0BAhBvD,SAkBIs3O,UAAWt4O;4B,UAAAA;8BAIT,MAJSA,KAIT,eACUvC,GAAK,UAALA,EAAgB;8BACxB,gCAHIO;4BAKN,YAA2B;0BA1BjC;;;kCA+BE8tE;2BA/BF;;;;;;;;;2BAYA;;0BAZA;2BAYA;;;;;;;;;;6BAEI2qN;6BAEAr+C;6BAEAE;;;;;;;;;;2BANJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCA2CA4gG,eAAetuS;4BACT,MADSA,gBACT,KAAJtqC;4BAAI;qCAQJrC;8CACoBkuE;uCAAK,eAALA,QARC38B,MAAKh0C;uCAC5B;yCAAoB;gDADQA;0CACR,mBAFlB8E,MACctB,SAAYxD;yCACgB,GAAxC29U,SACa,kBAFM3pS;yCACH;0CAGlB,MAJcxwC,SAAYxD;0CAIb;4DANAovC,uBAEQ4E,WAAKh0C,EAALg0C;0CAKrB,IAL0Bh0C;0CAALg0C;0CAAKh0C;kDAQoB,EAAC;0BArDjD,SAuDA49U,eAAep7U;4BACjB;+DADiBA;8CAGPxC;uCACc,sBAJPwC,EAGPxC,WAEF4F,EAFE5F;uCAGD,SAFDyF,MACAG,qBACsB,EAAE;0BA7D9B;kCApDAo3U;kCAEAC;;;;kCAkDAn9N;;kCA0BJ89H;;kCAEA2/F;;;;;;;kCsUlCOC;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCtUiDHE;kCAYAE;uBA9GN;;;;;;;;;;;;;;;;0BA4HI;8CAAuB;2BADvB;;;2BADS36R;;8C6G3FL0gI,W7G2FKokE,YAAM;;mCAAN7gM,O6G3FLu8H,a7G2FKh0D,oCAEkC;;;;;;;;;;0BAG7C;;;;;;;;;mCwF8EQgvC;4CxF7EOjvF;qCAAU;0DAAgB,iBAA1BA;sCAAU;;sCAAVvsB;;yD6GjGT0gI,W7GiGS9M,YAAM;;8CAAN5vH,O6GjGTw8H,a7GiGSh0D,oCAA6C,EAAE;;;sBnErH1D6nB;sBI4HFwV;sBgcxDgB;uBwH7EL;;uBCEA;;;;;;;uBCDE;;;;uBCGG;;;;;;;;;uBCFL;;;;uBCDE;;;;;;;;;;;;;;uBCDF;;uBCAA;;uBCAA;;uBCAA;;;;uBCAA;;;;;;;;;;;;;;;;;;;;;;;;;;uBCAA;;uBCCD;;;uBCDC;;;uBCCE;;uBCDF;;;;;;;;;;;uBCAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wB;;;;;;;;;;;;;;;;;;sBxI6EF;yBjQ3DhBtvI,SACA0tD;;uB;;;;;;4CADA1tD,M;;;;;;;;;;sBiQ2DgB;;;;;;;6CjQ7DhBytD;;;;;;;sBiQ6DgB;;;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2CrOsNdynB;2C5BnRFznB;sBiQ6DgB;;;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sCrQ+ed7C;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gDP/CE;gD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BwC4CuC;0B,SAUxB21Q,W;mCADDC,W;;oCAAAA;oCACCD;oCACAD;oCACCD;kC;;;;;;;;;;;;;;;;;;sCxMpkBF1rS;;;;;0B;;;;;;;4BgK4gBd;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB4QhcY;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uC5QgcZ,oB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4E0CvgBFm2D;;uB;;;;;;;sBkOuEc;2C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAAA;;;;;;uB;;;sBAAA;uB;;;;;sBAAA;;;;0B;;;;;;;;;;;;sBAAA;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAAA;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kC5QgcZ;oC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAAA;kC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yCwCqpBAe;+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BxCrpBA,yB;;;;;;sB4QhcY;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4DzQqvBd/gC;;qC;;;;;;gD8BxyBF+wB;;;;;+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gDAAAA;;;;;;;;;;;8B;;;;gDAAAA;;;;;;8B;;;;;gDAAAA;;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BjCmfI,wB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2CO+CFjxB;6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oEAAAA;+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4CAAAA;iC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCP/CE;;iD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2CAAA;;;;;;;;;;;2C;;;;;;;;;;;2DqZ5cG61Q,M;;;;;;6CrjBhEW9rS;4B;;;gEyMgBlB9pB,a;;;;;;;;;;;;;;;;;;;;;;;;0BzC4fI;;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEqZ5cG41T;0B;;;;;;;0BrZ4cH;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAAA;kC;;;;;;;;;kEmB5dJ3tQ,4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6CEwCO;6CD+HT,uBADS9tE;4CACT,SAAIuC;uDADKvC;;8CAGC,wBAFNuC,GAEM,MAFNA,UAEM;;oDACR/E;gDAAsB;;6EAJfwC,EAIPxC;mD,mCAAAA;wEADI6D,EACJ7D;kDAAsB,UAAtBA;;;8CADQ,UAAJ6D;4C;;;;;;;;;;;;;;;;;;;;;;8CX3GDkB,WAAH5C,W,OAAAA,K,OAAAA;0C;;;;;;wEAAG4C;;;;;;kC;;;;;;;;;;;;0B+B0vBuC;;;;;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qE6WxyBnCk5U;mC;;;;;qEAAAA;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAAAA;0B,mDAAAA;0B;;;;;;;;;;;;;;sBzIYS,uB;;;;;sBAAA;;;;;;oC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCyIZTA;uB;;;;;;;;;;;;;;;0BrZ4cH;0B;;;;;;;;;;;;;;;;yCqZ5cGA;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAAAA;0B;;;qEAAAA;0B;;;;;;;;;;qEAAAA;0B;;;;;;;;;;;;qEAAAA;0B;;;;;;;;;;;;;qEAAAA;0B;;;;qEAAAA;0B;;;;;qEAAAA;0B;;;;;;;;;;;;;;;qEAAAA;0B;;;;;;;;;;;;;;;qEAAAA;0B;;;;qEAAAA;0B;;;;qEAAAA;0B;;;;;;;;;;;;;;;;;;;;;qEAAAA;0B;;;;;;;;;;;;;;;;;;;;;qEAAAA;0B;;;;;;;;;qEAAAA;0B;;;;;;;;;;;;;qEAAAA;0B;;;;;;;;;;;;;qEAAAA;0B;;;;;;;;;;;;;qEAAAA;0B;;;;;;;;;;;;qEAAAA;0B;;;;;;;;qEAAAA;0B;;;;;;;;;;;;;qEAAAA;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAAAA;0B;;;;;;;;;;;;;;;;;;;;;qEAAAA;0B;;;;;;;;;;qEAAAA;0B;;;;;;;;;qEAAAA;0B;;;;;;;;;;;;;;;;qEAAAA;0B;;;;;;;;qEAAAA;0B;;;;;;;;;;;;;;;;;;qEAAAA;0B;;;;;;;;;;;;;;;;qEAAAA;0B;;;;;;;qEAAAA;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BrZ4cH;;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;;;yC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAAA;iC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDarfJpyQ;iC;;;;;;kDAAAA;gC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BbqfI;;uC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;;;;;;;;;;;;;;;;;;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;;;;;sE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wE+BpYgBgmF,I;yEAAAA,I;qEAAAA,M;kEAAAA,M;;;2CsXxEbosL;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BvlBoJT;;;8B;;;;;;;8BkMwTM,c;;;8BlMxTN;;;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB8cxIkB;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oC0IrCH,WAAJj+U;oCAAI,YAAJA;;;;;mC;;2CAAAA,E,gDAAAA;iC;;;kCvXkGX;wCAAIsZ,IADkBu4I;oCACtB,GADsBA,UAClBv4I,IACoB,OAFFu4I,IAHpB/1E;oCAIF;qCAC4D,MAFtC+1E;qCXmftB;;wC;qCAAA;sDAGkB;oCACT;qCAGA;sCAMA;wCAOA,mBAQF;wCAPH;8CWvgBAv4I;yCXugBA;0CApBAu3B,MAoBIqvI;;6CAEH,qBWzgBD5mK;6CX0gBC,UW1gBDA;6CX2gBC,UW3gBDA;6CX4gBC,UALG4mK;;;uCAPJ;+CWhgBA5mK;wCXggBA;yCAbAu3B,MAaIqtS;;4CAEH,qBWlgBD5kU;4CXmgBC,UWngBDA;4CXogBC,UAJG4kU;;;sCANJ;8CW1fA5kU;uCX0fA;wCAPAu3B,MAOIstS;;2CAEH,qBW5fD7kU;2CX6fC,UAHG6kU;;;sCAHJ,qBWvfA7kU,eAEAxU;;sCAEE,OALgB+sJ,IAHpB/1E;oCASG,SALDxiE,MAEAxU;;;;iC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iC/BiYE;+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB4QhcY;;0C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAAA;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4B5QgcZ;6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAAA;;;;;;;;;;;;;;uD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA,gB;;;;;;;;;;;;;;;0BAAA,+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA,qB;;;;0DGqTFwjE;mC;;;;;;;;iCAhyBFe,uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BH2eI,mB;;;;;;;;;;;;;sB4QhcY;uB;;;;;;;;;;;0B5QgcZ;;qD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAAA;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAAA;;;;gC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAAA;;;;yC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;;;;;;;;;;;;;;;;;;;;;;;;;;0E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA,gB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAAA;+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2CwCqpBAggC;gC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BxCrpBA;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB4QhcY;;;;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4B5QgcZ,Y;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sCqZ5cG40O;;;2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BrZ4cH;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB4QhcY;uB;;;;;;;;;;;;;;;;;sBAAA;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDyIZTA,Q;;;;;;;;;;;;;;;;;;;;;;;;6BAAAA;;;;6B;;;;;;;;;;;;;;;;;;;;;;;;;;+BAAAA;;;;;4B;;;;;;;;;;;;sCAAAA;yC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBzIYS;;;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6ByIZTA;;;;;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAAAA;;;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCrZ4cH;qC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB4QhcY;;;2C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8B5QgcZ;gC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB4QhcY;;2C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4B5QgcZ;;;+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCAAA;yC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8CqZ5cGA,mC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4CAAAA,M;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BrZ4cH;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAAA,c;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAAA,qB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA,c;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sCAAA,uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAAA;;;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iDAAA;;8C;;;mDgBtfJ7wQ;;uD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BhBsfI;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB4QhcY;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4B5QgcZ,uC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAAA,Y;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gEqZ5cG6wQ;6B;;;;;;;;;;;;;;;;;;;;;;;;;kEAAAA;6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBzIYS;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gEyIZTA;6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8CAAAA;;;6B;;;;;;;;sBzIYS;uB;;;;;;;;;;;;;;;;;0B5QgcZ;4C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAAA,c;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wDejcArxQ,uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB6PCY;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8B5QgcZ;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA,uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEqZ5cGqxQ;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BrZ4cH;6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qDarfJpyQ;;0B;;;;;;;;;;;;;;;;;;;;;;qCbqfI;sC;;;;;;;;;;;;;;;;;;;;;;;;4BAAA,c;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB4QhcY;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAAA;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mC5QgcZ,Y;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAAA;;;;;sC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;;;;;;;wC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAAA,Y;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAAA;;;;;;;;qC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA,Y;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;;;;;gC;;;;;;;;;;;;;;;;;;4BAAA;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;;;;;gC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB4QhcY;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0B5QgcZ;;;;;gC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;;;;;;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qDAAA;8D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA,kB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCAAA;gD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;;;;sC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA,Y;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4CAAA;4C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0CAAA;0C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2CAAA;oD;;;;;;;;;0BAAA;;;;;;;6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;;;;;;;;;;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAAA;wD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAAA;+B;;;;;;;;;;;;;;;;;;;;;sB4QhcY;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAAA;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;sC5QgcZ,mB;;;;;;;;;;;;;;;;;;sB4QhcY;mD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gDyIZToyQ;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mC7WimCH50O;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oDAAAA,oBCjpCJhhF;yC;;;;;;;;;;;;;;;;uDtBsBAgoD,K;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCnBseI;;;qC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB4QhcY;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4B5QgcZ;4B;;;;;;;;;;;;;;;;;;;;;;;;;sB4QhcY;uB;;;;;;;;;;;;gEnQ3ChB3C,oB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCT2eI,uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAAA;yC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAAA,sB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yCAAA;2C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAAA;qD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAAA,sB;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;gD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCSyDN,SAAQ6qJ,OAAO10E,MAAMv3E;oCACnB,SADau3E;sCAGX;;kEAAmB7vG,IAAI/xC,GAAK,UAALA,EAAJ+xC,IAAe,QAHjBs4B;oCAKR,qBALQA;oCAKR;0CAEMF,cAAHnqE;sCAAiB,UAAjBA,EAAiB,OAPlB4hJ,cAOIz3E;oCADF,QACqC;kCAPtD,0BADSI;;oC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BTxDH;;;gC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCwCqpBA68B;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAAAA;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0CxCrpBA,sC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAAA;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAAA;kC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB4QhcY;;;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iC5QgcZ;+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uEqZ5cG40O;;;;6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BrZ4cH,Y;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAAA;gC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB4QhcY;;;0B;;;;;;;;sBAAA;;;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCpOqlCZ50O;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BxCrpBA;qC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCgBpfM;;oC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BhBofN;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAAA;;;mC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAAA;mD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA,Y;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB4QhcY;;;;oC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4B5QgcZ;;+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA,mB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAAA,Y;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAAA;oC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mEqZ5cG40O;;;;;;qC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCpY3CP3wQ,sB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB2PuDgB;;;;wC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0B5QgcZ;mC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;mC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA,8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCwCqpBA+7B;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qD6WjmCG40O;6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BrZ4cH,+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qDAAA;;;0D;;;uEqZ5cGA;0D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BrZ4cH;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAAA;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAAA;wD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAAA;sC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8CAAA;8C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB4QhcY;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0B5QgcZ;mC;;;;;;;;;;;;;;;;;;;;;;;;;8BqZ5cGA;0C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BrZ4cH;wE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8DqZ5cGA,kB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCrZ4cH;0C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAAA;;;;;;;;;;;;;;;;2C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;;6B;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAAA;;2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;;;;;;;;;;;;;;oC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAAA;;;;;;;;;;;;;;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6CAAA,gB;;;;;;;;;;;;;;;;4BAAA;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAAA;kC;;;;;;;;;;;;;;;;;;8BAAA;;kC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gFqZ5cGA,S;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4C7XpBPtsQ;;;;mC;;;;;;;;;4C7NjBiBO;;;;mC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BqMifb;qC;;;;;;;;;;;;;;;;;;;;;;;;yES3dJr2D;qC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAAAA;;;;gC;;;;;;;;;;;;;;;;;uEAAAA;mC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gEAAAA;iC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iEAAAA;;;;mD;;;;;;;;;;;;;;;;;;;;6CMlBIwwD;kC;;;gEAAAA,6B;4DAuBAI;4B,OAlCJT;0B,IAEO/pE,E;iDAAO,UAAPA,EAFP+pE,O;;;;;;;iEN6BAnwD;6B;;;;;;;0CM7BAmwD;kC;;;;;;;;;2CAWIK,+B;;;;;;;;;;+DAXJL;oC;;;;;;;;;6CAWIK;kC;4DAuBAI;4B;;;;;qCAvBAJ;0B,OAXJL,K;;;;;;;wDAWIK,uB;;;;;;;;;;;uENkBJxwD;mC;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAAAA;sC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oDT2dI;;mD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;;;iC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;;;iC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qDezeA0wD;6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BfyeA;qC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sCAAA;;;;;wC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAAA,qB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAAA;;;sC;;;;;;;;;;;;;;;;;;;qCAAA;qC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sCAAA;sC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAAA;kC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAAA;;wC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;;6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAAA;;;;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA,Y;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAAA;gC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;;;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAAA;uC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAAA,Y;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCAAA;;;;yC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA,c;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;wC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;;;;+B;;;;;;;;;;;;;;;;;;;;;;4BAAA;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAAA;;;;2D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yCwCqpBA88B,oD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBoOrlCY;;;0B;;;;;;;;;;;;;;;;;;;;;8B5QgcZ;gC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAAA;;;;wD;;;;;;;;;;;;;;;;0BAAA;;;;;;gC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA,qC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA,Y;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;mC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAAA;wC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qFiB9fJluF;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BjB8fI;;gC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA,mB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAAA;mC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAAA;kC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAAA;;oC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sEqZ5cG8iU;;4C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BrZ4cH;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sCAAA;wC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCuB3UN;;;;iCACaj+U;gCACX;qCADWA,MADT8E;;;oCAGQ,qBAFC9E,G;;;;;;;;8CAEqB,QAFrBA;oCAED;;;;;;;;uC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BvBwUN;qC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAAA;;;wC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAAA;kC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAAA;oC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAAA;+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA,2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gDAAA;kD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAAA;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sCAAA;;;yD;;;;;;;;;;;;;sFqZ5cGi+U,M;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCrZ4cH;2C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAAA;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDqZ5cGA,Q;;;2EAAAA;oC,kCAAAA,wB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kEAAAA;;;;;;;;;;;;;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BrZ4cH;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;;;;;;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oDAAA;oD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yCGqTF31Q;;;;;8BHrTE;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB4QhcY;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qD/PrDhBuD;;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+EwYyCOoyQ,yB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6CrZ4cH;wD;;;;;;;iFqZ5cGA,O;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yCrZ4cH;kD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uEqZ5cGA;mC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2DrZ4cH;;;;;;;2D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yDAAA;;;;;;;yD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yDAAA,yB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA,c;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2EqZ5cGA;oD;;;yEAAAA;gC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBzIYS;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kEpOqlCZ50O,oBCjpCJhhF;uD;;;;;;;;;;kEDipCIghF,oBCjpCJhhF;uD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBmO4DgB;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kC5QgcZ;;;;;;;;oC;;;;;;;;;;;;;;;;0BAAA,wB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uDarfJwjD;qC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0DAAAA;wC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAAAA;gC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kEAAAA;iD;;;;;;;;;;;;;;;;;;;;;;;;;;;gDbqfI,Y;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2DarfJA;yC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yEAAAA;oC;;;;;;;;;2EAAAA;sC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sDAAAA;oC;;;;;;;;;;;;;;;;;;;;sB+PqDgB;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kC5QgcZ;kC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAAA;;iC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0CqZ5cGoyQ;;;;;uC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BrZ4cH;uD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8DgBvfJ/wQ,sB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BhBufI;;;qC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0DqZ5cG+wQ,a;;;;;;;;;;0DAAAA;;;;;iE;;;sBzIYS;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6B5QgcZ;+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0CAAA;oG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wEgBxfJhxQ,+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BhBwfI;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB4QhcY;;;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAAA;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gDyIZTgxQ,uB;;;uEAAAA,K;;;wD9Y2fL71Q,gB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0CAAAA;;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BP/CE;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yEqZ5cG61Q;;;;;;0D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCrZ4cH;;;;sC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;mC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAAA;;kC;;;;;;;;;;;;4BAAA;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCarfJpyQ;;0B;;;;;;;;;;;oEnN6BAL;;;qEAJAF;;6C;;;;;;;;;;;;;;;;;;;;;;;;;sBkd4BgB;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8B5QgcZ;;;;kC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mDQ7dAjD,MD4gBFD,kC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BP/CE;;;;;mC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCAAA;yC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAAA,uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iEQ7dAC,MD4gBFD;;;0C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0DP/CE;0D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6CAAA,qC;;;wDO+CFA;uC;;;;;;;;;;;;;;;uCP/CE;uC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEQ7dAC,MD4gBFD;8C;;;;;;;;;;iEC5gBEC,MD4gBFD;2C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iEAAAA;wC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCP/CE;;yC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA,gB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB4QhcY;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qC5P7DhB2E,K;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BhB6fI;;;0BiBzfO;4BAAqB,IAALvoE;4B,4BAAAA;;;0BAA2B,Y;;;;;;;;;;;;;;;;;;;;;sCR6K/CO,0BAAJ3C,WAAFD;kCAAc,sBAAdA,iBAAM4C;iDAAJ3C;;;4C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BT4UC;;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA,Y;;;;;;;;;;4BAAA,Y;;;;;;;;;;;;;;;;;;;;;;;;;8BAAA,c;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAAA;;;8B;;;;;;;;;;;;;;;;;4BAAA,Y;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA,a;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;;;;;;;mE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA,Y;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA,mB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB4QhcY;;;;;2B;;;;;;;;;;;;;;;;;;;;;;;;uCld1BhBmpE;;;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BsM0dI,mB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oDqZ5cG0yQ;iC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BrZ4cH;uC;;;;;;;;;;;0BAAA;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAAA;qC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sCAAA;sC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6CtMxdJzyQ;6C;;;;;;;;;;;;;;;;;;;+CAAAA,oB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BsMwdI,Y;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4CAAA;qD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAAA;0C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB4QhcY;;;;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+B5QgcZ,wB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0CAAA,wB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAAA;;;4C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAAA,wB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAAA;;;sC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA,Y;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAAA;gC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sCAAA,a;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB4QhcY;;;;;sB;;;;;;sBAAA;;;;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0B5QgcZ;;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAAA,Y;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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GAHH7+B;6CAIG+tc;gCACT,IAAIC,KAFkB5gc,GAATD,GAEkC,6BAFlCA;gCAEgD,oCADpD4gc,KACLC,KACoB;8BAFe;sEADrBlva;+BACF,uCADPD;8BACO;4BAMlB;;;uDAxDE+ua;6BAwDF;;6EAC0D;0BAF5C,qBADLlR,mBARD18b;0BASM,iDAE4C;uBAvB1D,gBADEogO;uBACF;;;0BA0BSs8N;;;;;;0BAdPoR;uBAZF;;sB4VZc;uB5VYd;iCAoCO/rB,gBAAiBmsB,YAAa9xZ;0BAE5B,IAAPg5C,KAAO,OAFF2sV,gBAAiBmsB;0BAEf,sB;0BAAA,eAMGluc;4BAAL,MAAKA,KACc,cADqBvD;4BACtC;mCADGuD,CAEA;0BANZ;;iDAGO,MA5CLogO,4BAuCAhrI;2BAEF;;;2BAUQ,0BAXFujI,ITmxCY22N,UAWAC;0BSnxCV,eACsC9yb,GAAW,kBAZ3Ckrb,MAY2C,UAAXlrb,GAAsB;0BAD5D;kCAAN4+N;2CACmB5+N,GAAa,4BAZvBgD,EAYUhD,GAAkB;wCAA8B;uBAnDrE,OTsxCEgpa;uBStxCF,yBTsxCEA;uBStxCF,STsxCEA;uBStxCF,aTsxCEA;uBStxCF,MTsxCEA;uBStxCF,UTsxCEA;uBStxCF,QTsxCEA;uBStxCF,YTsxCEA;uBStxCF,eTsxCEA;uBStxCF,YTsxCEA;uBStxCF,oBTsxCEA;uBStxCF,STsxCEA;uBStxCF,YTsxCEA;uBStxCF,UTsxCEA;uBStxCF,STsxCEA;uBStxCF,aTsxCEA;uBStxCF,cTsxCEA;uBStxCF,gBTsxCEA;uBStxCF,YTsxCEA;uBStxCF,iBTsxCEA;uBStxCF,kBTsxCEA;uBStxCF,UTsxCEA;uBStxCF,UTsxCEA;uBStxCF,STsxCEA;uBStxCF,gBTsxCEA;uBStxCF,STsxCEA;uBStxCF,mBTsxCEA;uBStxCF,KTsxCEA;uBStxCF,aTsxCEA;uBStxCF,eTsxCEA;uBStxCF,oBTsxCEA;uBStxCF,mBTsxCEA;uBStxCF,wBTsxCEA;uBStxCF,wBTsxCEA;uBStxCF,gBTsxCEA;uBStxCF,gBTsxCEA;uBStxCF,oBTsxCEA;uBStxCF,yBTsxCEA;uBStxCF,YTsxCEA;uBStxCF,QTsxCEA;uBStxCF,mBTsxCEA;uBStxCF,wBTsxCEA;uBStxCF,0BTsxCEA;uBStxCF,YTsxCEA;uBStxCF,yBTsxCEA;uBStxCF,WTsxCEA;uBStxCF,cTsxCEA;uBStxCF,STsxCEA;uBStxCF,aTsxCEA;sBStxCF,QTsxCEA;sBqWlyCY;uB5VYd,eTsxCEA;uBSpsCc;;uBAEH;iDAFT0oC,YACA9/N;uBACS;iCACP5xO;0BACJ,IAAIwB,QTgsCJwna;0BS/rCG,gCADCxna,QADAxB,MAE6B;0BADjC,UAEgC,WT8rChCgpa,YSjsCIhpa;0BAGmB,qBT8rCvBgpa,mBS9rCqD;uBAEvD,wCANIx0F,SACAm9H;;;;;;;;;;0BAcF;2BAEe7rN;4BAFf,OAlBA8rN;;4BAoBsB;uCAAPh9R;kDwEjKf6M,SxEiKe7M,YAAM;8BAANkxE;;;wDAAoC;sB4VjHvC;;;uB5VwHJ,sB,O4DhBN/7H;uB5DgBM;;uBADC,sB,O4DfPA;uB5DcF,kBT4qCAi/S;uBS5qCA,KOtHE6oC;uBPsHF;iCAIQtuc;0BACR;4BAIA;mCTmqCAyla;6BSnqCA,MTmqCAA;6BSnqCA,MTmqCAA;4BSnqC6C,eAFhC3mY;8BAA4B,qBTqqCzC2mY,mBSrqCa3mY;8BAA4B,kBTqqCzC2mY,mBSxqCQzla;4BAKR;;;gCTmqCAyla,oBSrsCA4oC;6BAkCA,iBTmqCA5oC;6BSnqCA,iBTmqCAA;4BSnqCA,kBTmqCAA,4BSlqC0D;0BAF5C,qBATP8oC,QAKCvuc;0BAIM,kBToqCdyla,4BSlqC0D;uBAV1D,gBOtHE6oC;uBPsHF;;;0BAeOG;;;;;;0BAlBQD;uBAGf;;0BAsBJ;;;;;iCTspCI/oC;;2BSznCA,aTynCAA,KStpCAtpR,OpEu5BM//F;0BoE13BN,sBA7BJ,YA+CuD;0BAlBnD,eALUp8C;4BAAL,MAAKA,KACc,cADCvD;4BAClB,WT6nCPgpa;4BS7nCO,OADGzla,CAEA;0BANZ;4CTkoCEyla,QS/nCK,MOnKH6oC;2BPgKJ;;;;4B,OTsoBoBngB,gB3D6PZ/xY,cgOlxBc4vE,OjOrUtBY;0BqEoNA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ER3xJ,0BwQyPsB33C,e5UnMvB6nM;uB4GwpBI8M;;;;wBxC9sBHh9J,0BwQyPsB33C,e5UnMvB6nM;uB4GwpBIs7B,uBgOrdmBnjO,e5UnMvB6nM;uB0HvBH;;;;;;;;;;;wCd+qBOl2a;kC;0CATLqib;;;2CASKmvB;;;;;;8CiUxgBJ77R;;+CjUwgBI07R;;;;;;;uBc/qBP;;0BAAoEzwB;0B;kCAApE6wB;;;mCAAoE7wB;uEA4BrB;uBA5B/C;;0BAAMgxB;0BAA+BC;;0BAArC;;;;;;4CkN0N0BvjO,cuFvKxBn6D;gD,O/VlFN8xG;gD,OuCFA4xJ;;+CiO2P8BvpM,cuFvKxBn6D;mCvTonBO+9R;4B,OxCtsBbjsL;0BwCqsBM;2BAAO6xJ,6BgO5ciBxpM,cuFvKxBn6D;2BvTmnBA,KctqBF69R;2BdsqBE,KctqBFA;2Bd8aE,KAwPArpU;2BAxPA,KAwPAA;2BAxPA,KAwPAA;2BAvbE,KA+LFH;2BA/LE,KA+LFA;2BA/LE,KA+LFA;2BAtaI,KAuOF8B;2BAvOE,KAuOFA;2BAvOE,KAuOFA;2BAvOE,KAuOFA;2BAvOE,KAuOFA;2BAvOE,KAuOFA;2BAvOE;;;;4DA8pBGwtS,kBA9pBH66B;;;4DA8pBG76B,kBA9pBHtnJ;;;;;;;;8BnFuHdn5G,kBmFwiBiB66R,yBA/pBHO;2B5DqJR,G4DrJQD;2B5DqJR,G4DrJQA;2B5DqJR,G4DrJQA;2B5DqJR,G4DrJQA;2B5DqJR,G4DrJQA;2B5DqJR,G4DrJQA;2B5DqJR,G4DrJQA;2B5DqJR,G4DrJQA;2B5DqJR;;;;;;;2B4DkFM;;;;;;gCAvOEpzN;gC5DqJR;2B4DkFM;0D2Y/NJ2pF,oB3Y+NIwpI;2BA+LF;;;;8BA/LE;2BA+LF;2BAwPA;;;;8BAxPA;;;2Cc9aIX,+Bd8aJQ;2Bc9aF;;;;8BdsqBE;;;2CctqBmCP,+BdsqBnCM;2BctqBF;mC1E6hCQU;4B,OvB95BhB19R;0BuB85BM;;gC0E7hCE48R;2B1E6hCF,K0E7hCEA;2B1E6hCF;mCAnCYe;;6BAoCUttZ;;0DADZqtZ,kBACYttZ;8DADZstZ,kBACYrtZ;0BApCpB;gCAmCFqjF;2BAnCE,KA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E,iCADFD;6BAEEE;;;;gCADAD;;;2CACAvvW;8B;uC6X/JN03H;gD7X+JM13H;yC,OfrNNw7T;2DeqNMx7T;oD,OtDnNNwpK,2BsDmNMxpK;;;;;;6BApJNyvW;;qEAoJMD;mCARNp1d;qC1Ei3BEs1d,oB0E7+B8B1vW;8B,OA/EhC+8H,gCA+EgC/8H;;qC1E08B5B2vW,kBAoCoB3vW;;;;qCADtB0vW,oBACsB1vW;qCADtB0vW,oBACsB3nT;;;;6BAATv/F;;qD0E9/BfinZ,O1E8/BevlM;6BAxtBb8P,wBAwtBaK;;6BAxtBba;yCuctUFnkD,evc0/BI44O,kBAprBF31L;;yCuctUFjjD,evc0/BI44O,kBAprBFz0L;mCAorBEy0L,kBAprBFx0L;;yC4RPAtnD,e5R2rBE87O,kBAprBFv0L;oCAorBEu0L,kBAprBFt0L;oCAorBEs0L,kBAprBFr0L;oCAorBEq0L,kBAprBFp0L;oCAorBEo0L,kBAprBFn0L;oCAorBEm0L,kBAprBFl0L;oCAorBEk0L,kBAprBFj0L;;;gCwJyNAjkL,iBxJ2dEk4W,kBAprBFh0L;;;gCwJyNAlkL,iBxJ2dEk4W,kBAprBF/zL;;;gCwJyNAnkL,iBxJ2dEk4W,kBAprBF9zL;;;gCwJyNApkL,iBxJ2dEk4W,kBAprBF7zL;;;gCwJyNArkL,iBxJ2dEk4W,kBAprBF5zL;;;gCwJyNAtkL,iBxJ2dEk4W,kBAprBF3zL;;;gCwJyNAvkL,iBxJ2dEk4W,kBAprBF1zL;;;gCwJyNAxkL,iBxJ2dEk4W,kBAprBFzzL;;;;gC4RPAxpD;yC5R0BoB1yH;kC;2CwJsMpBvI,iBxJ2dEk4W,kBAjqBkB3vW;gCAnBpBu6K;;;;gCwJyNA9iL,iBxJ2dEk4W,kBAprBFn1L;;;gCwJyNA/iL,iBxJ2dEk4W,kBAprBFl1L;;;gCwJyNAhjL,iBxJ2dEk4W,kBAprBFj1L;;;gCwJyNAjjL,iBxJ2dEk4W,kBAprBFh1L;;;gCwJyNAljL,iBxJ2dEk4W,kBAprBFz1L;6BAutBAE;;gCwJ9fA3iL,iBxJ2dEk4W,kBAprBFx1L;6B0EtSFy1L,wB1E6/BEx1L;mC0Ej3BFhgS;;;6BP/LEy1d;;gCo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C,O+HnFI4yE;4C/HmFJ5yE;;4B,OjQzHE20M;;;4CqNgP4Bx8N,epO9LrBxmE;;iCkB5BL8tS;;qC,OdyWE/1B;;mCclEFpxa;;qCAkB+C;;iCAD7CA;0B,qBkN9FwB8/N,cuFvKxBn6D;;4B,O/VlFN8xG;;4B,OuCFA8xJ;;;;8B6QoIA5hL;;gC,O+HnFI4yE;4C/HmFJ5yE;;4B,OjQzHE80M;;4CqNgP4B38N,crNvM1Bm9N;;iCGnBAwK;;qC,OdyWEl2B;;mCcjDAvxa;;;uBAC6C;iCAlB/CA;0B,qBkN7E0B8/N,cuFvKxBn6D;;4B,O/VlFN8xG;;4B,OuCFA8xJ;;;;8B6QoIA5hL;;gC,O+HnFI4yE;4C/HmFJ5yE;;4B,OjQzHE80M;;4CqNgP4B38N,crNvM1Bm9N;;iCGnBA2K;;qC,OdyWEr2B;;mCclEFvxa;2CAkB+C;uBAlB/C;uCAAK6md;sBuV5PO;uBvV4PZ;;;;;;;;;;;;gCAuCWe;uBAvCX;;yBAAKf;yBAALC;;;;mD;uBAAA;;;;;;;;uBAmCF;;sBuV/Rc;uBvV+Rd;;;;;;;;;;;4C;;wBlBzRUnhD;0B+YjCAvrG;4B5YjDI6uG;8BvCER3xJ,0BwQyPsB33C,e5UnMvB6nM;uB0HmTL;6BlBzRU7B;;;2B,OevE0Co2B,gB9FqJ1DnyR;;6B+EnGgB47P,gBeTHw3B;;;wC,OXsViChsB;uBcGtC;;;;;;;4C,OA5WoEgyB;;uBA4WpE;uBAmB+C;wC,UAnB/CwlB;uBAmB+C;iCAnB/Cpje;0B,qBkNlJ0Bw6O,cuFvKxBn6D;gD,O/VlFN8xG;gD,OuCFA4xJ;gD,O4YiDI9uG;gD,O/YiCAurG;;gD,OAAAA;;4B,OevEFq2B;yCfkDE72c;4B,kBoO8L0Bw6O,cpO9LrBxmE,UAALh0K;;iCkB5BA69c;mD,OdyWEhyB;;mCcGF7rb;uBAmB+C;iCAnB/C4a;0B,qBkNlJ0B6/N,euFvKxBn6D;;4B,O/VlFN8xG;;4B,OuCFA6xJ;;4B,O4YiDI/uG;;4B,O/YiCAurG;;;4B,OAAAA;;4B,OevEFw2B;;yCfkDEr8b;4B;gDoO8L0B6/N,epO9LrBxmE,SAALr5J;;iCkB5BAmnc;;qC,OdyWE/1B;;mCcGFpxa;;qCAmB+C;;iCAD7CA;0B,qBkNpKwB8/N,cuFvKxBn6D;;4B,O/VlFN8xG;;4B,OuCFA8xJ;;4B,O4YiDIhvG;;4B,O/YiCAurG;;;4B,OAAAA;;4B,OevEF22B;;4B,OfkDEh3B,ceTAw3B;;iCGnBAwK;;qC,OdyWEl2B;;mCcqBAvxa;;;uBAC6C;iCAnB/CA;0B,qBkNlJ0B8/N,cuFvKxBn6D;;4B,O/VlFN8xG;;4B,OuCFA8xJ;;4B,O4YiDIhvG;;4B,O/YiCAurG;;;4B,OAAAA;;4B,OevEF22B;;4B,OfkDEh3B,ceTAw3B;;iCGnBA2K;;qC,OdyWEr2B;;mCcGFvxa;2CAmB+C;uBAnB/C;uCAAKyod;sBuVjUO;uBvViUZ;;;;;;;;;;;;;gCAwCWe;uBAxCX;;yBAAKf;yBAALC;;;;mD;uBAAA;;;;;;;;uBAoCF;;sBuVrWc;uBvVqWd;;;;;;;;;;sBAoBH;;sB7G7bGxwV;sBI4HFwV;sBgcxDgB;;;;;;;;;;;;;;;;;;;;;;;;;;;sBhcuDhBD;sBJ5HExV;sBuqBVN;;sBnO+EoB;uBmO/EpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAMI;;0BhoBoBEiwH;mCgoBpByB9kQ;4BAGN,IAJTsC,EAIS,aAHMtC;4BAGf,eAJExC;8BAAkB;mDAAC,iBAArB8E,EAAE9E,G1mB+KG4wN;;4B0mB5KX;oEACsC;sBAAG;;sBvqBE7Ct5E;sBI4HFwV;sBADAD;sBJ5HExV;sB8GVN;;sBsV+EoB;uBtVvEhB2xV;wBACa,OvEiBX1hO;sBuERA;;;;;;;;;;;;;;;;sBsV6Dc;uBtV1DR;iCAM+Bc;0BACzB,IAAZy0M,UAAY,sCADyBz0M;0BAGzB;uEAFZy0M,WAEwC;uBATlC;;;;;;;;;;;;;;;;;;uBAgBC;uBAII,uBAjCbmsB,yBfy2CI/9D;uBex0CS;;gCAsBL89D;uBAtBK;wC,afw0CT99D;uBex0CS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BA8BT/7W;2BA5CJ+5a;uBAca;;;;;;;;;;;;;;0B;;sCfw0CTh+D;;;;mCelzCI89D,SAuBqB;sBsVPb;;;uBtVgCJ,kBtDoEVxwM,cAtGAuiD;uBsDkCU;kCfkwCRmwF;uBelwCQ,OfkwCRA;uBelwCQ,KfkwCRA;uBelwCQ,QfkwCRA;uBelwCQ,SfkwCRA;uBelwCQ,UfkwCRA;uBelwCQ,WfkwCRA;uBelwCQ,WfkwCRA;uBelwCQ,WfkwCRA;uBelwCQ;iCAcGhpa;0BAAsB;mCAHSwne,QAG/Bxne,EAAsB,WfovCjCgpa,+BepvC4C;uBAdpC,SfkwCRA;uBelwCQ,SfkwCRA;uBelwCQ,UfkwCRA;uBelwCQ,WfkwCRA;uBelwCQ,WfkwCRA;uBelwCQ,WfkwCRA;uBelwCQ;iCA0BQhpa,EAAEzB,GAAI,kBfwuCtByqa,WexuCgBhpa,EAAEzB,EAA0B;uBA1BpC;iCA4BMyB,EAAEzB,EAAE6iC,GAAI,kBfsuCtB4nY,WetuCchpa,EAAEzB,EAAE6iC,EAA0B;uBA5BpC;;;;iCAmCC79B,EAAQvD;0BACA;mCtDgCnBs2R;mCsDhCmB,WtD1EVtkF,QsD0EiB,WtDuC1BukF,UsDxCWhzR,GAAQvD,GACwB;uBApCjC;;0BAsC2B,kBtD8BrCs2R,csD9BqC,WtD5E5Bv2L,UsD4EwC;uBAtCvC,WfkwCRipU;uBelwCQ;iCA0CAz7V,GAAGF;0BACX,SAAI1jE;4B,IAAS3J;8CfutCbgpa,8BevtCahpa;0BACV,WAFKutE,IAEW,OAFRF;0BAGH,WAHGA,IAGa,OAHhBE;0BAKoB;4CtD4B9BgpN,UsDjCalpN;2BAKE,atDyCfyrQ,WsDzCe,WtD4BfviD,UsDjCUhpN;0BAKK;4BACP,qBtDoBR+oN,csDrBQ10R,GAC4B;8CARhC+me,QAQoC;uBAhD9B;iCAkDC3oe;0BAAyB;mCtDkBpCs2R,csDlBoC,WtDxF3BnkP,OsDwFmC,WtDyB5CokP,UsDzBWv2R,IAAgD;uBAlDjD,gCAkDS,YAAwC;uBAlDjD,4B;uBAAA;;;2BfkwCRgpa;;4BevvCI4+D;4BAAOD;4BAAOD;4BAAOD;4BAGrBI;4BAH8Bt0P;4BAAeg0P;4BAAPC;;6BAWtCW;6BAAOD;6BAAOD;6BAAOD;6BAAiBF;6BAARC;4BAIh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O;kCAEA9jT;;;;;;kCA+OA+zT;kCAQAE;uBAtSN;;2B;;;;;;;uBAAA;;;sBA8lF6C;;sBpCtlFvC35W;sBI4HFwV;sBADAD;sBJ5HExV;sB4rBTN;;sBxP8EoB;uBwP9EhB48W;;;2BAIK;;;;;8CjDkIPt3E;;4BiDlIYrrQ,eAALxuB;+CAC6C1jI;6BjDiIpD,sCiDjIoD0nI;oCAD7CorB;;;8BjDmIH,qBiDnIG9yJ;8BjDoIH,4BiDpIGA;8BjD0GO,qBiD1GPA;8BjD0Ge,qBiD1GfA;8BjD0Ge,sBAARuxO,IAAQyjQ;8BA4BlB,2BiDtIGh1e;8BjD8HO,qBiD9HPA;8BjD8He,qBiD9HfA;8BjD8He,UAARm1e,IAAQC;;qCAKlBN;qCACAC;qCACAE;qCACAC;qCACAG,OiDrIkC;+BAF/BtiV;;6BjDkIP;;iCiDlIO3tK;8BjDkIP,GiDlIOA;8BjDkIP,GiDlIOA;8BjDkIP,KiDlIOA;8BjDkIP,KiDlIOA;8BjDkIP;;8BAxBA,GAwBA+xN;8BAxBA,GAwBAA;8BAxBA;8BAwBA;;;;iCAxBA;8BAwBA;8BAJA,KAIAy4B;8BAJA,KAIAA;8BAJA;;;sCAIAI;sCAJA;oCiD9HOt9E;;;8BjDkIP,GiDlIOttK;8BjDkIP,GiDlIOA;8BjDkIP,GiDlIOA;8BjDkIP,KiDlIOA;8BjDkIP,KiDlIOA;8BjDkIP,uBiDlIO4a,UjDkIPm6H;qDiDlIOn6H,IjDkIPqjC;8BAxBA,GAwBA8zK;8BAxBA,GAwBAA;8BAxBA,qBiD1GOn3M,IjD0GPwjC;qDiD1GOxjC,IjD0GP9F;8BAwBA,uBiDlIO8F,IjDkIPqhC;8BAJA,KAIAuuM;8BAJA,KAIAA;8BAJA,uBiD9HO5vO,IjD8HPujC;qDiD9HOvjC,IjD8HPyhC,WiD5HsC;;4BAF/BkxH;qCAAKT,YAALS;;;;;;;qCAAKT;qCAALS;;;0CAE+B;sBAGi0B;;sB5rBCn2Bz6B;sBI4HFwV;sBADAD;sBJ5HExV;sB6rBVN;;sBAAS,wBnDcLuoE;sBmDZK,sBnDYLA;sBtMiEgB;uByP7EX;;0BAMmB,uBDPxBq0S;0BCOwB;mCDPxBA;iDvfyBApob,iBufzBAoob,kBCO0D;u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e6hB7FFllK;;;;0DAGwC;uBAHxC;;mEAEInd,KAAYo4e,UACwB;uBAHxC;;;oCAEIp4e,EAAYo4e,OACwB;sBAG3C;sBtlBhBH;sB+U6EoB;uB/U7EpB;iCAKW75e;0BAAqB,uCAArBA;0BAAqB,4CAAe;uBAS7C;;;mCAA0DyB;4BACtD,eACQzB,GACR,UAHsDyB,EAE9CzB,EACF;4BADM,qB7DyLZi4R,O6D3LsDx2R;4BAE1C,iDACN;uBAHV;uBAeM;;;;;;;4C,OslBnBsB69f,8B3S+LnBz5U;;uB3S5KH;uBAA8D;wC,UAA9Ds6U;;uCAAKC;sB+UgDO;uB/UhDkD;uBAA9D;;;;;;;;4C,OslBnBFruN;8B3S+LKlsH;;uB3S5KH;uBAA8D;wC,UAA9D06U;;;;;;;;;yCzGoIRn6U,2ByGpIao6U;;uBAAL;uBAA8D;wC,UAA9DC;uBAA8D,mBAA9Dz7f,iBAA8D;;iCAA9D4Z;;mDyD0EAmlK,czD1EAnlK;6BslBnBF+gf,e/iBmBE9G,oBvCAAj6e;;;0BAA8D,OAA9D5Z,CAA8D;;iCAA9D4Z;;;;;;;0BAA8D,OAA9D5Z,CAA8D;0CAA9D47f;uBAA8D;iCAA9D57f;;;;;mEyD0EA6+K,czD1EApuH;;mDslBnBFqqc,c/iBkBAnH,mBvCCEjjc,IAA8D;;iCAA9D92C;;;;;0CyD0EAklK,ezD1EAllK;iCslBnBFmhf,e/iBkBAnH,oBvCCEh6e,WAA8D;0CAA9Dmif;uBAA8D,YAA9DL;uBAA8D;uBAchE;;;;;;;4C,OslBjCwBpB,8B3S+LnBz5U;;uB3S9JL;uBAuBG,mB,UAvBHs7U;uBAuBG;iCAtBDvzb;0BslBlCF;8BtlBkCEA;2BslBlCF,GtlBkCEA;2BslBlCF,wC/iBkBA+qb,c+iBlBAljc;;uBtlBwDG;iCslBxDH72C,UtlBkCEgvD;0BslBlCF;8BtlBkCEA;2BslBlCF,GtlBkCEA;2BslBlCF,e/iBkBAgrb,e+iBlBAh6e;4DtlBmCmC;uBAqBhC,mB2C4IIwif;uB3C5IJ;iCAtB6Cxif,IslBlChD0nI,QtlBkCgDmrB;0BslBlChD;uBtlBwDG;iCslBxDH7yJ;0BAEI;0C/iBiBFi6e,e+iBnBFj6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uBTjNP;uBAE+C;wC,UAF/CwiR;;uCAAKC;sB6SqEW;uB7SrEhB;;;;;;;6DGiDI5vD;;uBHjDJ;uBAE+C;wC,UAF/C8vD;;;;;;;;uC3IyJJpsY,2B2IzJSqsY;;sB6SqEW;uB7S3DhB;;;;;;;;;yDSuMO5iR;;;uBTvMP;uBAK+C;wC,UAL/C6iR;;uCAAKC;sB6S2DW;uB7S3DhB;;;;;;;;;;;;+CGuCIjwD;;;;uBHvCJ;uBAK+C;wC,UAL/CmwD;;;;;;;;;yC3I+IJzsY,2B2I/IS0sY;;uBAAL;uBAK+C;wC,UAL/CC;uBAK+C,oBAL/C/tjB,iBAK+C;uBAcjD,qBSoSEk5J,iBTpSyDv6J,GACvD,UADuDA,EACtB;sBAAE;sBvJ7BnCmzI;sBADAD;sBwJRN;sB4S6EoB;uB5S7EpB;;0BAMM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+EA8CyD;uBA9CzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gG5I2JNuvC;;uB4I3JM;uBA8CyD;wC,UA9CzDgtY;uBA8CyD;iCA9CzDl1c;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BgCugBE;qChCvgBF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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7Y,2B8IzEW07Y;;uBAAL;uBAQ+C;wC,UAR/CC;uBAQ+C,oBAR/C/8jB,iBAQ+C;;;iCAwBtCqsjB;0BACT,GADSA;4BAEP;;;;0BAIA;;;wEAC+B;uBAR/B6Q;sDYoiDAvna;;;;;;;2BZpiDAtuI;2BADA4yiB;2BADAN;2BADAO;2BADIn7C;wCACJm7C,aACAP,MACAM,YACA5yiB;;;2DMkNJ6xI;;uBNxNEika;sBA6BF;;wCrCnCEj/D;wBqCrEE87D;;;;sB0SuCY;uB1S6Gd;;;;;;;;;0CPtJGna;6CI5BAyN;;uBGkLH;uBAGqD;wC,UAHrD8P;uBAGqD;;0BAHrD;;;6BP/KA,GO+KArpb;6BP/KA,GO+KAA;;6BP/KA;;;;;0BO+KA,kBHlLF,KGkLEG;;gDHlLF,0CGqLuD;;iCAHrDt6H;;;;;6BP/KA,GO+KAm6H;6BP/KA,GO+KAA;6BPtJF;6BAzBE,aO+KAn6H,IPtJFqjC,MAzBEwT;oDO+KA72C,IP/KA9F;0BO+KA;;;2BHlLF,KGkLEogI;2BHlLF,yBGkLEt6H,IHlLFwjC;0CGkLExjC,IHlLFqhC,WGqLuD;;iCAHrDrhC;;;4BPtJF;;6BArBM,oBO2KJA;6BP3K+B,0BO2K/BA;6BP3K+B,SAA3B6jjB,cAA2BC;sCO2K/B9tZ;;4BHlLF,4BGkLEh2J;4BHlLF;6BACsB;mDGiLpBA;yCHjLoB+jjB;;iCGiLpB3xW,QHlLF,uBGkLE1qE;;mEAGqD;;iCAHrDpoC;;;;;;;;;;;;4B8BmVE,c9BnVF;;;;;;;;;;;;;;;;;;;;kCHlLF,SGkLE95G;;;;;;;2DHlLF,2BGkLEA;;;;;;;;;;;;;0CHlLF;;;;;;;;;;;;;;;;;;;;;uDACsB;mFADtBo8P;;;;0EACsBlnE,aADtB73L;;8DACsB63L,aADtB,sCGkLEl1L;yDHjLoB;;sDADtB;;;;;8CGkLEqjH;+CHlLF,mDGkLErjH;;6CHlLF;kDGkLEqjH,KHlLF,0CGkLErjH;;+CHlLF,UACsBy+jB;+CADtB;gFGkLEp7c,QHjLoBq7c;;;iDGiLpBr7c;kDHlLF;;oDGkLErjH;gEHjLoBy+jB;;;2CGiLpBp7c,KHlLF,mCGkLErjH;;8CHlLF,kCGkLEA;uDHlLF,2BGkLEA;;;;;;;gCP/KA,SO+KAy2I;0CP/KA,oCO+KAA;;kCP/KA;+CO+KAA;mCP/KA;;;;;;;;;;;;;;;;;;;;;;;;;iGO+KAA,KP1KsD;yDALtDZ;;;;;;gDAII;0EAJJF;;kDAII;;;;;+CAA2B;yEAJ/BA;;iDAI+B;;;;8CAJ/B;;;;;sCO+KAe;uCP/KA,iDO+KAD;;qCP/KA;0CO+KAC,KP/KA,wCO+KAD;;uCP/KA;8CAIIkob;wCAJJ,MAI+BC;;;;;yCAA3BE;yCO2KJpob,QP3KIoob,kBAA2BD;;;;;yCO2K/Bnob;0CP/KA;;4CO+KAD;;sDP3KIkob;yDAA2BC;;0CO2K/Blob;;iEAGqD;;;0BAHrD;4BACE;;6BPhLF,SOgLED;6BPhLF,cOgLEA;6BP5K6B;;6BAA3B;iEAA2BK;6BAA3B;kDO4KF92I;0BACA;;2BHpLJ,eGoLI02I;2BHnLkB;;;gDGmLlBrzB,SACmD;;iCAHrD6tD;0B,SAAA3tK;4BACE;gCADFA;6BACE,iCADF2tK;;6BP/KA/nD,eawOA60Y,eb/MF1qO,MOuJIzwC;oDPhLF15H,IOgLE05H;0BACA,SAFFt/O,OAEE,iCAFF2tK;4CMyDA8sV,eT1OAh6N,MGmLE2nC;uBAFF;uCAAKsyP;sB0S7GS;uB1SwHd;;;;;;;;;0CPvJGrd;6CI5BA2N;;uBGmLH;uBAMqD;wC,UANrD2Q;uBAMqD;;0BANrD;;;6BP/KA,GO+KAvqb;6BP/KA,GO+KAA;6BP/KA,GO+KAA;6BP/KA,GO+KAA;;6BP/KA;;;sEqlBPF6oa,crlBOE7rV;;;;;0BO+KA;;2BHnLF,KGmLE78E;2BHnLF,KGmLEA;2BHnLF;;;;kFGyLuD;;iCANrDt6H;;;;;6BP/KA,GO+KAm6H;6BP/KA,GO+KAA;6BP/KA,GO+KAA;6BP/KA,GO+KAA;6BPvJF;6BAxBE,aO+KAn6H,IPvJF0lC,MAxBEmR;4CO+KA72C,IP/KA9F;8CqlBPF+oiB,e9kBsLEjjiB,IP/KAqhC;oDO+KArhC,IP/KAyhC;0BO+KA;;;2BHnLF,KGmLE64F;2BHnLF,KGmLEA;2BHnLF,yBGmLEt6H,IHnLFomC;0CGmLEpmC,IHnLFqjC;0CGmLErjC,IHnLFwjC,WGyLuD;;iCANrDxjC;;;4BPvJF;;6BAvBM,kBO8KJA;6BP7KI,oBO6KJA;6BP5KI,sBqlBVNkjiB,e9kBsLEljiB;6BP3KI,0BO2KJA;6BP3KI,SAHA+kjB,YACAlB,cACAmB,WACAlB;sCO2KJ9tZ;;4BHnLF,4BGmLEh2J;4BHnLF;6BAEQ;gDGiLNA;8BHhLM,qBGgLNA;yCHjLMiljB,YACAlB;;iCGgLN3xW,QHnLF,uBGmLE1qE;;mEAMqD;;iCANrDpoC;;;;;;;;;;;;4B8BwUE,c9BxUF;;;;;;;;;;;;;;;;;;;;kCHnLF,SGmLE95G;;;;;;;2DHnLF,2BGmLEA;;;;;;;;;;;;;0CHnLF;;;;;;;;;;;;;;;;;;;;;;;;;;;yGGmLEA,GH9K6C;iEAL/C61I;;;;;;wDAGQ;oFAHRumH;;0DAGQ;;;;;uDADA;mFAFRA;;yDAEQ;;;;sDAFR;;;;;8CGmLE/4I;+CHnLF,mDGmLErjH;;6CHnLF;kDGmLEqjH,KHnLF,0CGmLErjH;;+CHnLF;sDAEQ2/jB;gDAFR,MAGQlB;;;;;iDADAmB;iDGiLNv8c,QHjLMu8c,gBACAlB;;;;;iDGgLNr7c;kDHnLF;;oDGmLErjH;;8DHjLM2/jB;iEACAlB;;;2CGgLNp7c,KHnLF,mCGmLErjH;;8CHnLF,kCGmLEA;uDHnLF,2BGmLEA;;;;;;;gCP/KA,SO+KAy2I;0CP/KA,oCO+KAA;;kCP/KA;+CO+KAA;mCP/KA;;;;;;;;;;;;;;;;;;;;;;;;;;;iGO+KAA,KPzKsD;yDANtDZ;;;;;;;;kDAGI;4EAHJF;;oDAGI;;uEqlBVNgoa,crlBUM5oX;;;iDAFA;2EADJp/C;;mDACI;;;;;gDACA;0EAFJA;;kDAEI;;;;;+CAEA;yEAJJA;;iDAII;;;;8CAJJ;;;;;sCO+KAe;uCP/KA,iDO+KAD;;qCP/KA;0CO+KAC,KP/KA,wCO+KAD;;uCP/KA;8CACIopb;wCADJ,MAEIlB;wCAFJ,MAGImB;wCAHJ,MAIIlB;;;;;yCADAmB;yCADAjB;yCADAkB;yCO8KJtpb;;2CP9KIspb;2CACAlB;2CACAiB;2CACAlB;;;;;yCO2KJnob;0CP/KA;;4CO+KAD;;s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C;4BgB2LAsD,OhB3LA,iBAiBF3mC,IAjBEwjC;;+BgB2LAmD,OhB3LA,mBAiBF3mC;0BgB0KE,6BhB1KFA,IgB0KE2mC;iCpJ7CNiiI,mBmJ2DI62Z,efxLAz/jB,IgB0KE+mC,WAqE+C;;iCAD7C/mC;0BApEF,sCAoEE0nI;uBAC6C;iChB/OjD1nI;0BgBsLM;;;8ChBtLNA;2BgBuLM,sBwkBtNNsiiB,exlB+BAtiiB;2BgBwLM,gChBxLNA;2BgByLM,2BhBzLNA;2BgB0LM,yBhB1LNA;2BgB2LM,gCJlMFi6e,eZOJj6e;2BgB4LMsnkB,WpJ/DVz+Z,kBoJ6Ca+5U,MhB1KT5if;2BgB6LM,wBJpMFi6e,eZOJj6e;;;;;2BAjBE,wBAiBFA;0BAjBE;+BgB+MIwnkB;;;4BhB5MI;wEAcVxnkB;6BAbU,8BAaVA;6BAZU,gCAYVA;6BAXU,kCAWVA;6BAVU,qCAUVA;6BgB8LMwnkB;;+BhB5MIC;+BACAC;+BACAC;+BACAC;+BACAC;;gCgBwMJL,ShB/MJ,uBAiBF9/b;0BgBsLM;2BASA,6BhB/LN1nI;2BgBgMM+nkB,QpJnEVl/Z,kBmJ2DI62Z,efxLA1/jB;;kCgBsLMgrf;kCACAg6D;kCACAmiB;kCACAC;kCACAlmB;kCACAmmB;kCACAC;kCACAC;kCACAC;kCACAM;kCACAC,QA+C2C;;iCAd/C3hlB;0BAWI;4B,O2BwTJ65G,e5B5WFgge;0BCgDM;4B,O2B4TJhge,ejC/gBEsjZ;0BMmNE;mCNnNFA;mC8kBpDJg/C;mCxkByHFo/B;;;mCJjGM9nF;;;mCZOJ2hD;mCKsVAwS;;mCWrHE5njB;uBAc+C;iCAd/ChB;0BAvDA;mCAuDAA;2BAvDA,cAuDAA;2BAvDA,SAuDAA;2BAvDA,aAuDAA;2BAvDA,WAuDAA;2BAvDA,qBAuDAA;2BAvDA,QAuDAA;2BAvDA,UAuDAA;2BAvDA,eAuDAA;2BAvDA,WAuDAA;2BAvDA,aAuDAA;;;2BAjCIk4M,O2B0WJj/F,e5BlXF6he,cCQM6H;;2BADA;+DACAlnZ;;;;;0BhBjNJ,GgB+MI2mZ;2BhBxMI;gDgBwMJA;4BhBzMII,iBgByMJJ;4BhB1MIG,egB0MJH;4BhB3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6hhB,cFzMA5+E,cOvBAx2W;;;gDLgOAo1b,cFzMA5+E,cOvBA5iS;;;gDLgOAwhX,cFzMA5+E,cOvBAlqQ;8DC6JA+hW,oBD7JAhiW;uBC4wBiD;iCH3wBjD5vO,QGkwBE5a;0BDnwBF;8BCmwBEA;2BDnwBF,GCmwBEA;2BDnwBF,GCmwBEA;2BDnwBF,KCmwBEA;2BDnwBF,KCmwBEA;2BHlwBF,GEDA0jH;2BFCA,GEDAA;2BCmwBE;;2BHlwBFvlE,MH+NAq1hB,eFzMA5+E,eKtBAh6e;2BEDAwjC,MC6JAquiB,qBH5JA7xkB;2BEDAqjC,MLgOAu1hB,eFzMA5+E,eKtBAh6e,IEDAwjC;iCLgOAo1hB,eFzMA5+E,eKtBAh6e,IEDAqjC;iCLgOAu1hB,eFzMA5+E,eKtBAh6e,IEDAyhC;iCC6JAowiB,qBH5JA7xkB,IEDAqhC,SC4wBiD;;iCH3wBjDrhC;0BGkwBE;;;2BH9vBE4ohB,OH2NJiwC,eFxME5+E,eKvBFj6e;2BAIyBu3kB,iBGwJzBzF,qBH5JA9xkB;2BEWIw3kB,YFPA5uD,OAAqB2uD;2BEQrBE,OLmNJ5e,eFxME5+E,eKvBFj6e;2BEaI03kB;4BLkNJ7e,eFxME5+E,eKvBFj6e;2BEgBI23kB,kBL+MJ9e,eFxME5+E,eKvBFj6e;2BEiBI43kB,eC2IJ9F,qBH5JA9xkB;;kCEWIw3kB;kCACAC;kCACAC;kCAGAC;kCACAC,eC0vB6C;;iCAT/CxxlB;0BAII;0BDvwBN,SCmwBEA,KDnwBF,2CCmwBEA;0BAII;2BDvwBN,cCmwBEA;2BDnwBF;;;;;;;;;;;;;;;;;;oCqBwgBE;sCrBxgBF;;;;;;;;;yFCmwBEA,ED/uBmE;iDApBrEi1I;;;;;;;;;2CAcI;uEAdJumH;;6CAcI;;uDLkNJk3U,cFxMEj/E,cOVEv/T;;;0CADA;sEAbJsnE;;4CAaI;;sDLmNJk3U,cFxMEj/E,cOXEr6T;;;yCAIA;qEAjBJoiE;;2CAiBI;;qDL+MJk3U,cFxMEj/E,cOPEn6T;;;wCALA;oEAZJkiE;;0CAYI,IFXJtiJ,KEWI;0CFXJ;+CEWIg8B,OFXJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gHAKqE;mEALrED;;;;;;0DAIyB;oFAJzBF;;4DAIyB;;sEGwJzB42c,oBHxJyBx3Z;;;yDAArB;mFAJJp/C;;2DAII;;qEH2NJ29b,cFxMEj/E,cKnBEr/T;;wDAJJ;;;;;gDEWIl/C;iDFXJ;;;oDEWIA,OFXJ;;;wDAIIktZ;kDAJJ,MAIyB2vD;;;;;mDAArB1vD;mDEOAntZ,UFPAmtZ,WAAqB2vD;;;;;mDEOrB98c;oDFXJ;;;;gEAIIktZ;mEAAqB2vD;;0CEOrBL;;uCAMA;mEAlBJl2V;;yCAkBI;;mDC2IJmwV,oBD3IInyZ;;sCAlBJ;;;;uFCmwBEx5L;4BDnwBF;8ECmwBEA;4BDnwBF;mCAYI0xlB;6BAZJ,MAaIC;6BAbJ,MAcIC;6BAdJ,MAiBIC;6BAjBJ,MAkBIC;;;;+BADAI;+BAHAC;+BADAC;+BADAC;;;sCACAD;sCACAD;sCAGAD;sCACAD;4BAlBJ;;qCCmwBEjylB;;+CDvvBE0xlB;;gDACAC;;iDACAC;;kDAGAC;qDACAC;uBC0vB6C;iCAT/C9ylB;0BDnwBF;0CCmwBEA;2BDnwBF,kBCmwBEA;2BDnwBF,mBCmwBEA;2BDnwBF,OCmwBEA;2BDnwBF,SCmwBEA;;2BDjvBE4+C,MC2IJouiB,2BD3IIwF;;2BADAn7f,ML+MJs8e,cFxMEj/E,cOPE69F;+DACAv0c;2BAJAzmD,MLkNJo8e,cFxMEj/E,cOVE49F;+DAGAr0c;2BAJAvmD,MLmNJi8e,cFxMEj/E,cOXE29F;+DACAxhc;2BFbJ,iBEWIuhc;2BFXJ,OEWIA;2BFPqBv6f,MGwJzBm1f,oBHxJyBmF;;2BAArBl6f,MH2NJ07e,cFxMEj/E,cKnBE8uC;+DAAqBtsZ;2BEOrBvzI,OFPAwzI;2BEOAukD,kCACAD;oCADAC;uBCgwB6C;iCARzCnyE,IADN5lH;;;2BAEM2gS,MNriBRuvS,qBMoiBQtqd;2BAGF86K,MA1mBN4oT,+BAwmBQ3oT;2BAGFF,MNxiBNyvS,qBMuiBMxvS,MAJJ1gS;2BAMI+vR,MNziBNmgT,qBMwiBMzvS,MALJzgS;2BAOI2tK,MN1iBNuia,qBMyiBMngT,MANJ/vR;iCAtmBFsplB,4BA6mBM37a,MAPJ3tK;uBAS+C;iCAT/C2j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yH,cR/EApzZ,cgB+pBAmhS;;0DRhlBAiyH,oBQglBAlyH;;;iDRhlBAkyH,cQgbEitB,cAgKF4P;2BAgjBA;;;;;2CAhjBAjjX,QRhlBAomV,cFrEAr9E,cUqpBA/0C;2BtC9qBF,GsC8tCEV;2BtC9tCF;2BsC8tCE;0DtC9tCF;2BsC8tCE;;;;;;2BAzLA,KAyLA90N;2BAzLA,KAyLAA;2BAzLA,KAyLAA;2BAzLA;;;;mCF5JS0kX;4B,OA1uBTtiB;0BAyuBE;gCE6JF9uc;2BF7JE,KE6JFA;2BF7JE,KE6JFA;2BF7JE,KE6JFA;2BF7JE,KE6JFA;2BF7JE,KE6JFA;2BF7JE,KE6JFA;2BF7JE;oDNtqBF61b,cFzMA5+E,cQ+2BEt+W;;;;yDAzuBFm2c,oBAyuBE5tI;;0DAzuBF4tI,oBAyuBE7tI;;;2BE6JF;;;;8BF7JE;0BEgDF,UA6GAjtI;;;2BA7GA,SA6GAA;4BA7GA;kCA6GAA;6BF1lBA,GE6eA78L;6BF7eA,GE6eAA;6BF7eA,GE6eAA;6BF7eA,GE6eAA;6BF7eA,GE6eAA;6BF7eA,GE6eAA;6BF7eA,GE6eAA;6BF7eA,KE6eAA;6BF7eA;sDA5SA23c,6BA4SAt3c;;2DA5SAs3c,0BA4SA96hB;;;kDNzOA6hhB,cFzMA5+E,cQkbA5iS;;2DNzOAwhX,cEvBOn2E,WIgQP3yQ;6BE6eA;6BF7eA;;;;;gCqUhcAorV;kD,O3UuNAtC,4BMyOA/oV;;;kDNzOA+oV,mCMyOAhpV;iENzOAgpV,mBMyOAjpV;;;;gCE6eAuB;sDF7eAf,ONzOAyoV,mBMyOAlpV;;4BE6eA;kCA6GAqnF;mCA7GA;0BFhDE;2BE6JF;2BAyLA;;;;;2CAzLAyuI,QFt4BAqsI,0BEs4BAluI;2BAyLA;;;0BAxsCA,UAwsCAt0N;;;2BAxsCA;iCAwsCAA;;6BAxsCA,mCVGA2qQ,cUHAn+W;0BFk3BE;2BE+0BFgrU;;uEAzfAJ;0BpBztCF,UoBktDE3C;;;2BpBltDF,SoBktDEA;4BpBltDF;kCoBktDEA;;8BpBltDF;;;kCoBktDEA;mCpBltDF;uDoBktDE+C,cAE8D;;iC7CttDhE5mc,I6CotDEkqC;;;;2BAzfA,IAyfAo5F;2BAzfA,IAyfAA;2BAzfA,IAyfAA;2BAzfA,IAyfAA;2BAzfA,GAyfAA;2BAzfA,KAyfAA;2BAzfA,KAyfAA;2BAzfA,KAyfAA;2BAzfA,KAyfAA;2BAzfA,KAyfAA;2BAzfA,KAyfAA;2BAzfA,KAyfAA;2BAzfA,KAyfAA;2BAzfA,gB7C3tCFtjI,I6CotDEkqC,OAzfA64F;6CkkB5tCFs/Z,e/mBCAriiB,I6C2tCE2mC;2BAhjBA,KAgjBA+9Z;2BAhjBA,KAgjBAA;2BAhjBA,KAgjBAA;2BAhjBA,KAgjBAA;2BAhjBA,KAgjBAA;2BAhjBA,KAgjBAA;2BAhjBA,KAgjBAA;2BAhjBA,KAgjBAA;2BAhjBA;;4BmUnqBAw2H;;gC,O3UmFA7D;8BrC3FFr3jB;8B6C2qBE+mC;;kCRhlBAswhB,eE6GO50E,SvCxMTzif,I6C2qBEkvC;kCRhlBAmohB,qBrC3FFr3jB,I6C2qBEsvC;kCRhlBA+nhB,eEsHOpqB,kBvCjNTjtiB,I6C2qBEqvC;kCRhlBAgohB,eR/EApzZ,e7BZFjkK,I6C2qBE0vC;kCRhlBA2nhB,qBrC3FFr3jB,I6C2qBEkwC;kCRhlBAmnhB,eQgbEitB,e7C3gBJtklB,I6C2qBEiwC;2BAgjBAF,ORhoCAsnhB,eFrEAr9E,enCtBFh6e,I6C2qBEgwC;2BtC9qBF,GsC8tCEs0Z;2BtC9tCF,GsC8tCEA;2BtC9tCF,8BPGAtkc,I6C2tCE+vC,OtC9tCF8G;2BPGA;4BOHAC;8BPGA;;2B6C2tCE,uB7C3tCF92C,I6C2tCEqhC;iD7C3tCFrhC,I6C2tCE8mC;iD7C3tCF9mC,I6C2tCEqnC;kE7C3tCFrnC,I6C2tCEwnC;2BAzLA,KAyLAgoM;2BAzLA,KAyLAA;2BAzLA,KAyLAA;2BF1SA;;;mCA3CS4kX;4B,OA1uBTviB;0BAyuBE;gCE6JF/uc;2BF7JE,KE6JFA;2BF7JE,KE6JFA;2BF7JE,KE6JFA;2BF7JE,KE6JFA;2BF7JE,KE6JFA;2BF7JE,KE6JFA;2BF7JEr3F,ONtqBFmthB,eFzMA5+E,enCtBFh6e,I6CkiCEunC,OF7JEk0F;8C3Cr4BJz7H,I2Cq4BIyrC;8C3Cr4BJzrC,I2Cq4BIwjC;kCAzuBFquiB,qB3C5JF7xkB,I2Cq4BIujC;kCAzuBFsuiB,qB3C5JF7xkB,I2Cq4BI2rC;kD3Cr4BJ3rC,I2Cq4BI0rC;kD3Cr4BJ1rC,I2Cq4BI0lC;0BEgDF,UA6GAu+Z;sCA7GA,mB7Cr7BFjkc,I6CkiCEomC;;2BA7GA,SA6GA69Z;4BA7GA;kCA6GAA;6BA7GA,yB7Cr7BFjkc,I6CkiCEomC;6BF1lBA,GE6eA6zF;6BF7eA,GE6eAA;6BF7eA,GE6eAA;6BF7eA,GE6eAA;6BF7eA,GE6eAA;6BF7eA,GE6eAA;6BF7eA,KE6eAA;6BF7eA,KE6eAA;6BF7eAzuF,OA5SAqmiB,8B3C5JF7xkB,I2CwcEkmC;oCA5SA2riB,2B3C5JF7xkB,I2CwcEwrC;oCNzOAothB,eFzMA5+E,enCtBFh6e,I2CwcE8tC;oCNzOA8qhB,eEvBOn2E,SvCxMTzif,I2CwcE6tC;;;8BqUhcAqthB;;kC,O3UuNAtC;gCrC/NF54jB;gC2CwcE4tC;;oCNzOAgrhB,oCrC/NF54jB,I2CwcE2tC;oCNzOAirhB,oBrC/NF54jB,I2CwcE0tC;6BE0lBA1H,ORn0BA4yhB,oBrC/NF54jB,I2CwcEytC;;4BE6eA;kCA6GAw2Z;6BA7GA,yB7Cr7BFjkc,I6CkiCEomC;oCA7GA,uB7Cr7BFpmC,I6Cq7BEimC;0BFhDE;2BEsVFuH,OF/jCAqkiB,2B3C5JF7xkB,I6CkiCEgmC;2BAyLA,uB7C3tCFhmC,I6C2tCEwtC;kD7C3tCFxtC,I6C2tCEsnC;0BAnkCA,OAmkCA+nM;8CAnkCA,mB7CxJFrvO,I6CwJE8nC;uCAmkCAD,OAnkCA,mB7CxJF7nC,I6CwJE8nC;wCAmkCAD,OAnkCA,mB7CxJF7nC,I6CwJE8nC;0BArIA,UAwsCAsnM;2BAxsCA;4BAisDAxjM;6BAzfAwjM;+BAxsCA,mB7CnBFpvO,I6C2tCE6nC;+BAxsCA,mB7CnBF7nC,I6C2tCE6nC;;2BAxsCA;iCAwsCAunM;4BAxsCA,yB7CnBFpvO,I6C2tCE6nC;4BAyfA+D,OAjsDA,WVGAouc,enCtBFh6e,I6CmBEmmC;0BpBjBF,UoBktDEw9Z;2BpBltDF,0BzBFA3jc,I6CotDE4rC;;4BpBltDF,SoBktDE+3Z;8BpBltDF,SoBktDEA,QpBltDF,yBzBFA3jc,I6CotDE4rC;8BpBltDF,oCzBFA5rC,IyBEAyhC;qCoBktDEkia,QpBltDF,yBzBFA3jc,I6CotDE4rC;4BpBltDF,sBzBFA5rC,IyBEAqjC,YoBotDgE;;iC7CttDhErjC;0B6C4tCM;8C7C5tCNA;2B6C6tCM,sBkkB9tCNsiiB,e/mBCAtiiB;2B6C2qBE;2BACI68b;4BmUpqBJs+H;;gC,O3UmFA7D;8BrC3FFt3jB;;2B6C8qBM+vlB,aRnlBJz4B,eE6GO10E,MvCxMT5if;2B6C+qBM2/jB,mBRplBJrI,qBrC3FFt3jB;2B6CirBM8nkB,cRtlBJxQ,eEsHOpqB,evCjNTltiB;2B6CkrBMggkB,YRvlBJ1I,eR/EApzZ,c7BZFlkK;2B6CmrBMmnkB,eRxlBJ7P,qBrC3FFt3jB;2B6CqrBMwnkB,SR1lBJlQ,eQgbEitB,e7C3gBJvklB;2B6CsrBMunkB,aR3lBJjQ,eFpEEr9E,enCvBJj6e;2B6C8tCM2vlB;;6BAljBA9yJ;6BAEAkzJ;6BACApwB;6BAEAmI;6BACA9H;6BACAmH;6BAEAK;6BACAD;2BtCvrBF,sCPCJvnkB;;;;;;2B6C+tCM0vlB,oBtChuCFlxF,YAAwBD;2BsCkuCtB,kC7CjuCNv+f;2B6CkuCM,wB7CluCNA;2B6CmuCM,yB7CnuCNA;2B6CouCM,4C7CpuCNA;2B2Ci7BE;;;mCA3CSu6kB;4B,OA1uBTzI;0BA2vBM;2BADAuL;4BNvrBNxkB,eFxME5+E,enCvBJj6e;2B2Cu5BQ,8B3Cv5BRA;2B2Cm6BQ,+B3Cn6BRA;2B2Co6BQu3kB,iBAxwBNzF,qB3C5JF9xkB;2B2Cq6BQk9kB;4BAzwBNpL,qB3C5JF9xkB;2B2Cs6BQ,mC3Ct6BRA;2B2Cu6BQ,gC3Cv6BRA;2B2Cu6BQ;;6BAjBAq9kB;6BACAD;6BAYAD;6BACA5F;6BACA2F;6BACAD;6BACAD;2BEcN,0B7Cr7BFh9kB;0B6Cq7BE;+BA+GI6vlB,UA/GJ,uB7Cr7BFnod;;;;;+B2CycM0/b,UA7SJ0K,8B3C5JF9xkB;+B2C0cMkhjB,QA9SJ4wB,2B3C5JF9xkB;+B2C2cMqnkB;gCN5OJxO,eFxME5+E,enCvBJj6e;+B2C4cMsnkB,WN7OJzO,eEvBOj2E,MvCxMT5if;;+B2C6cMqvS;gCqUrcJ8rR;;oC,O3UuNAtC;kCrC/NF74jB;;+B2C8cM6/jB;gCN/OJhH,oCrC/NF74jB;+B2C+cM+/jB,eNhPJlH,oBrC/NF74jB;+B2CgdMw1kB,SNjPJ3c,oBrC/NF74jB;+B6Cq7BEktf;;iCF5eIk6E;iCACAlmB;iCACAmmB;iCACAC;iCACAj4R;iCACAwwR;iCACAE;iCACAyV;+BEolBAqa,aA/GJ3iG;;;;8D7Cr7BFltf;+B6CoiCM6vlB,aA/GJyE;;yCA+GIzE;0BF7IE;2BE8IFD,cFz4BJ9d,2B3C5JF9xkB;2B6CquCMsvlB,mBAlMAQ,UACAD,UACAD;2BAiMA,sC7CtuCN5vlB;2B6CuuCM,+C7CvuCNA;2B6CwJE,0B7CxJFA;0B6CwJE;+BAglCImvlB,gBAhlCJ,uB7CxJFznd;;;wC6CwuCMynd;;;0BFjVE,YEp4BN,kB7CnBFnvlB;0B6CmBE;+BAstCIkvlB,qBAttCJ,uB7CnBFxnd;;;wC6CyuCMwnd;;8BAttCJ;kDVIEj1G,enCvBJj6e;+B6CyuCMkvlB,wBAttCJqF;;yCAstCIrF;0BFlVE;2BE8zBFjoC;;6BAzfAj8D;6BACAg6D;6BACA2qC;6BACAD;6BAEA7hD;6BACA4hD;6BACAD;6BACAD;6BACAD;6BACAD;6BACAD;6BACAD;6BACAD;2BpBvuCN,0BzBFAlvlB;0ByBEA;+BoBmtD+Bw0lB,gBpBntD/B,uBzBFA9sd;;;;8ByBEA;kEzBFA1nI;+B6CqtD+Bw0lB,mBpBntD/Bx+b;;;;sDzBFAh2J;+B6CqtD+Bw0lB,mBpBntD/BpiZ;;yCoBmtD+BoiZ;oCAAzBvtC,OAAyButC,gBACiC;;iCAF9Dl1f;;;;;;;;;;4B;4BAAA;;;;;;;;;;sCkB7sCE;wClB6sCF;;;;;;;;;gGAE8D;mDAF9D+7B;;;;;;0CACI;oEADJF;;4CACI,IA1fJ6lH,OA0fI;4CA1fJ;iDA0fI1lH,OA1fJ;;;;;;;;;;;;;;;;;;;;;kDACIovX;kDACA46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EACA46D;;kEACAqvC;;mEACAC;;oEAEAjmD;;qEACAkmD;;sEACAC;;uEACAC;;wEACAC;;yEACAC;;0EACAxG;;2EACAyG;8EACAC;4CA4eA/tC;;yCAAyB;mEAD7Bjsb;;2CAC6B;2CpBntD/B;;;;;;;;;;;;;;;;uDoBmtD+Bs/C,SpBntD/B;;;;qDoBmtD+BA,SpBntD/B;;+DoBmtD+BA;;uDpBntD/B8mE;;;;;;;;;;;;;;;;;;;;;;;;0DoBmtD+B9mE,YpBntD/B5xE;;;;;;0DoBmtD+B4xE;2DpBntD/B;;;;;;;;;wDoBmtD+BA,YpBntD/Bv+C;;;;;wDoBmtD+Bu+C;yDpBntD/B;;mEoBmtD+BA,SpBntD/B;;oDoBmtD+BA,SpBntD/B;;kDoBmtD+BA,SpBntD/B;2DoBmtD+BA,SpBntD/B;2CoBmtD+Bi6a;wCAD7B;;;uCAE8D;0BAF9D;;;;;;oCACIttC,cADJ,MAC6BstC;;6DAAzBrtC;iDAAyB8uC;0BAD7B;;;;6CACI/uC;gDAAyBstC,sCACiC;;;0BAF9D;0BpBltDF,UoBmtD+BF;;;2BpBntD/B,SoBmtD+BA;4BpBltD7B;gCoBktD6BA;6BpBltD7B;6BoBktD6BzrmB,mBpBltD7B8/G;;4BACA;kCoBitD6B2rf;6BpBjtD7B;6BoBitD6BzrmB,mBpBjtD7BmzI;0BoBgtDA;2BAC6BK,kCAD7BD;2BACI;+DAAyBC;0BAAzB,iBAC0D;;iCAF9DihV;;;2BAzfA10L,kBN9+BA06N,eMu+CAhmC;2BAziCAz0L,kBkkB5qBF45Q,elkB4tCE75Q;;;2BAhjBA0B;;8BmUnqBArmD;uCnUqqBMx1H;gC,ORllBN+od,qCQklBM/od;8BAFNo6K;;kCRhlBA2uS,eEkJAl0E,eM8bAh5N;kCRhlBAktS,emlB9EAiD,e3kB8pBAlwS;kCRhlBAitS,eTyRF7nB,eiBuTEnlR;kCRhlBAgtS,ekBpEElzZ,eVopBFmmH;kCRhlBA+sS,ekBpEElzZ,eVopBFomH;kCRhlBA8sS,eQgbEgtB,eAgKF75T;2BAgjBA1B,ORhoCAuuS,qBQglBAxuS;;2B7C3qBFv6K,+B6C2tCEw6K;;;8B7C3tCsC,2BAAxCx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22b;uBAS+C;;0BAT/C;;;;2BHymCN,KGzmCMpme;2BHymCN,KGzmCMA;2BHwqBJ,GAicFrxB;2BAjcE,GAicFA;2BAjcE,GAicFA;2BAjcE,GAicFA;2BAjcE;;;;;gD1J1qCR6/D,8B0J0qCQwuC;2BAicF;;;;8BAjcE;2BGxqBI;;;;8BHymCN;;4B,OGpwDE0iZ;qCAqTIjG;0BAsWA;;;;;8B7JlgBZhsb;;kC,O2J9JIuwb;gCEgqBQt2U;;kFAS+C;;iCAT/C7hR;;;;;2BHymCN,KGzmCMm6H;2BHymCN,KGzmCMA;2BHwqBJ,GAicFrxB;2BAjcE,GAicFA;2BAjcE,GAicFA;2BAjcE,GAicFA;2BAjcE,aGxqBI9oG,UHwqBJ62C;2DGxqBI72C,IHwqBJ9F;iC1J1qCR0uK,+B6JkgBY5oK,IHwqBJqhC;2BAicFI,6BGzmCMzhC,IHwqBJujC;2BGxqBIF,MxB/oBRm7f,ewB+oBQx+hB,IHymCNyhC;;4B,OGpwDEs4jB;qCAqTI5F;;;;;;;2BAsWAzujB;4B7JlgBZmiI;;gC,O2J9JIwwb;;8BEgqBQr4lB;;;uEAS+C;;iCAT/CA;2EAS+C;;iCAT/CA;0BHyqBA;8CGzqBAA;2BH0qBA,gCG1qBAA;2BH2qBAmhjB,c1J7qCZt4Y,8B6JkgBY7oK;2BH6qBA,+BG7qBAA;2BH6qBA,UAJAgrf,aACAg2D,MACAG,cAEAD;2BA8bF,+BG3mCElhjB;2BH2mCF,eADAinjB,OACAutC;;4B,OGtwDFyF;qCAqTI5F;0BA6WI;2BALAsL;4B7JpgBhB73b;;gC,O2J9JIywb;8BEgqBQv4lB;;2BAOI,8BAPJA;0BAOI,UANA4/lB,YACAD,kBAKAv+C,OAE2C;uBAT/C;wCAAKo/C;sB2RtlBG;uB3RmpBNM;wBAfF;mCAIWC;2CAHEC;8BACT;oCAEO1F,eADIx8G;8DACJw8G;;;;qDH+hCjB1E,uBG/hCiBmK;qC9JjkBjB/kc;uC8J8jBmBglc,wDAUH;;wD9J1kBhBtkd;;6B8J6kBYg7c,+BACJoJ;sB2RnpBM;uB3RwpBV;iCAqBS16mB;0BACX;;;;4BAAQ86mB;4C,oBACJC;0BAgBJ;4BAhBIA;;8BAAc;8BAYE;yCATV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UwR,K6B8DVxR;+B7B9DiC0xD,GAAvBlgD;+BAAuBigD,GAAvBjgD;+BAAuB/O,6B6BY/B4qK,W7BZ+B57G;+BAAvB++G,gCAAuB/tK,K6BY/B4qK,W7BZ+B37G;2DAAvB8+G;uC6B8DVxwK,K7B9DU+gnB,Y6BYR1zc,W7BZQr/D;;mC6B8DVsgE;4B7B9DF,c6B8DEtuK;;+B7B9DUwR,K6B8DVxR;+B7B9DU8U,IsDyXZqtI,sBzB3TEvnI;+B7B9DiC82C,GAAvBlgD;+BAAuBigD,GAAvBjgD;+BAAuByqC,M6BY/BqxH,YAkDF1yJ,I7B9DU9F,IAAuB28C;qC6BY/B67G,YAkDF1yJ,I7B9DiCqhC;;6BAAvB+xD,O6B8DVhuG;6B7B9DUq8C,MsDyXZ8lG,sBzB3TEvnI;mCAlDE0yJ,YAkDF1yJ,I7B9DUyhC,a6B+DqC;8BAD/CkyH;gDAA4B3zJ;4B,O7B9D9Bi3hB,e6BYInkY,aAkD0B9yJ;mCAA5B6zJ;4B,O7B9DFqjY,e6BYIpkY,aAkDF9yJ,YAC+C;;2BAD/C8zJ;sCAAKtB,cAALmB;;;4B,gB7B9DFr0D;;gE6BYI65D,U7BZJ75D;;;;;oDAC+C;qC6B6D7Cl5G;;4B7B9DF,c6B8DEhB;;+B7B9DUI,G6B8DVJ;+B7B9DiCyxD,GAAvBrxD;+BAAuBqjH,KAAvBrjH;+BAAuBy2I,K6BY/B3uB,U7BZ+BzE;oC6BY/ByE,U7BZ+Bz2D;;gCAAvBqlF,K6B8DV92I;kDAlDEkoH,U7BZQ4uB;mC6B8DVxoC;4BAA4B,S7B9D9BwqC,M6B8DWK,wCAAkB;4B7B9D7B,G6B8DE6ne,gB7B9DF;0C6B8DEA;;gC7B9DiC;iCAAnCzuc,U6B8DEr5B;iC7B9DFs5B,S6B8DEwuc;iC7B9DiChtE,MAAnCxhY;iCAAmCyhY,MAAnCzhY;iCAAmCy1U,MAAnC11U;iCAAmC2hY,MAAnC3hY;iCAAmC;+CAAK,MAALyhY;;uC6B8DjC96Z;mC7B9DF+ne,U6B8DE/ne,S7B9DFgoe,S6B8DEF;sC7B9DFloe;gD6B8DEkoe,YAAkD;mCAAlDrjgB;4BAA4B,S7B9D9Bm7B,M6B8DWsoe,sCAAkB;4B7B9D7B,G6B8DED,gB7B9DF;0C6B8D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6BpD7fF,GoD6fEA;6BpD7fF,GoD6fEA;;;;6BpD7fF;;;;;gC9G8HNwiL;;;qC8G7HqB9wH;;;;wEoDmEbmuH,cpDnEanuH;kCADfD;;sEoDoEEouH,cpDpEFnuH;;uDA7BA41c,0BA6BAv1S;mCoD6fEt9C;4BpD7fF;gCoD6fEz0K;6BpD7fF,GoD6fEA;6BpD7fF,GoD6fEA;;;;6BpD7fFq8C;8B9G8HNomI;yC8G7HoB7nK;;mCAAC82C;;0DAAD92C,QAAC62C;oDoDmEbquH,epDnEYllK,IAACqhC;gCoD4fbrhC;;gCpD7fF62C;4CoDoEEquH,eAybAllK,IpD7fFyhC;mCA7BAord,2BoD0hBE7sf,IpD7fF9F,OoDkgB8B;8BAL5Bu4mB;iDAIEzymB;4BpDjgBJ,sCoDigBI0nI;mCAJFgre;;;;;6BpD5fEzjH;8B9G6HVnnV;yC8G7HU9nK;;mCAAW62C,oBAAX72C;mCAAW82C,coDmEbquH,cpDnEEnlK;4CAAW62C;gCoD4fb72C;;6BpD3fE,mBoDkEFmlK,cAybAnlK;6BpD1fE+uf,OAhCJ/B,2BoD0hBEhtf;sCpD5fEivf,UACAD,QACAD,OoD+f0B;;2BAL5B4jH;uCAAKH,eAALC;;;;;;;;4BpD7fF,SoD6fErsnB,KpD7fF,0CoD6fEA;4BpD7fF;yCoD6fEA;6BpD7fF;;;;;;;;;;;;;;;;sC8D0eE;wC9D1eF;;;;;;;;;0FoD6fEA,EpDxfuB;mDALzBi1I;;;;;;;2CAGI;qEAHJF;;6CAGI;;gEAhCJkyX,0BAgCI9yU;;;0CAFA;oEADJp/C;;4CACI;;;8CiEscJ76B;yDjEtcehB;kDAAD,SAACA;;;;;;;;;;;kFADfzrD,YACeyrD,KAAgB;gDAA3Bk7E;;;yCACA;mEAFJr/C;;2CAEI;;;;wCAFJ;;;;sFoD6fE/0I;8BpD7fF;6EoD6fEA;8BpD7fF;qCACIqogB;+BADJ,MAEIC;+BAFJ,MAGIC;;;;iCADAE;iCADAC;wDACAD,YACAD;8BAHJ;;uCoD6fExogB;;iDpD5fEqogB;;kDACAC;qDACAC;mCoD0fFmkH;4BpD7fF;oCoD6fE1tnB;6BpD7fF,QoD6fEA;6BpD7fF,UoD6fEA;;6BpD1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","sourcesContent":[null,"//\n// strftime\n// github.com/samsonjs/strftime\n// @_sjs\n//\n// Copyright 2010 - 2015 Sami Samhuri \n//\n// MIT License\n// http://sjs.mit-license.org\n//\n\n;(function() {\n\n var DefaultLocale = {\n days: ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'],\n shortDays: ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'],\n months: ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'],\n shortMonths: ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'],\n AM: 'AM',\n PM: 'PM',\n am: 'am',\n pm: 'pm',\n formats: {\n D: '%m/%d/%y',\n F: '%Y-%m-%d',\n R: '%H:%M',\n T: '%H:%M:%S',\n X: '%T',\n c: '%a %b %d %X %Y',\n r: '%I:%M:%S %p',\n v: '%e-%b-%Y',\n x: '%D'\n }\n },\n defaultStrftime = new Strftime(DefaultLocale, 0, false),\n isCommonJS = typeof module !== 'undefined',\n namespace;\n\n // CommonJS / Node module\n if (isCommonJS) {\n namespace = module.exports = adaptedStrftime;\n namespace.strftime = deprecatedStrftime;\n if(joo_global_object) joo_global_object.strftime = adaptedStrftime;\n }\n // Browsers and other environments\n else {\n // Get the global object. Works in ES3, ES5, and ES5 strict mode.\n namespace = joo_global_object || (function() { return this || (1,eval)('this'); }());\n namespace.strftime = adaptedStrftime;\n }\n\n // Deprecated API, to be removed in v1.0\n var _require = isCommonJS ? \"require('strftime')\" : \"strftime\";\n var _deprecationWarnings = {};\n function deprecationWarning(name, instead) {\n if (!_deprecationWarnings[name]) {\n if (typeof console !== 'undefined' && typeof console.warn == 'function') {\n console.warn(\"[WARNING] \" + name + \" is deprecated and will be removed in version 1.0. Instead, use `\" + instead + \"`.\");\n }\n _deprecationWarnings[name] = true;\n }\n }\n\n namespace.strftimeTZ = deprecatedStrftimeTZ;\n namespace.strftimeUTC = deprecatedStrftimeUTC;\n namespace.localizedStrftime = deprecatedStrftimeLocalized;\n\n // Adapt the old API while preserving the new API.\n function adaptForwards(fn) {\n fn.localize = defaultStrftime.localize.bind(defaultStrftime);\n fn.timezone = defaultStrftime.timezone.bind(defaultStrftime);\n fn.utc = defaultStrftime.utc.bind(defaultStrftime);\n }\n\n adaptForwards(adaptedStrftime);\n function adaptedStrftime(fmt, d, locale) {\n // d and locale are optional, check if this is (format, locale)\n if (d && d.days) {\n locale = d;\n d = undefined;\n }\n if (locale) {\n deprecationWarning(\"`\" + _require + \"(format, [date], [locale])`\", \"var s = \" + _require + \".localize(locale); s(format, [date])\");\n }\n var strftime = locale ? defaultStrftime.localize(locale) : defaultStrftime;\n return strftime(fmt, d);\n }\n\n adaptForwards(deprecatedStrftime);\n function deprecatedStrftime(fmt, d, locale) {\n if (locale) {\n deprecationWarning(\"`\" + _require + \".strftime(format, [date], [locale])`\", \"var s = \" + _require + \".localize(locale); s(format, [date])\");\n }\n else {\n deprecationWarning(\"`\" + _require + \".strftime(format, [date])`\", _require + \"(format, [date])\");\n }\n var strftime = locale ? defaultStrftime.localize(locale) : defaultStrftime;\n return strftime(fmt, d);\n }\n\n function deprecatedStrftimeTZ(fmt, d, locale, timezone) {\n // locale is optional, check if this is (format, date, timezone)\n if ((typeof locale == 'number' || typeof locale == 'string') && timezone == null) {\n timezone = locale;\n locale = undefined;\n }\n\n if (locale) {\n deprecationWarning(\"`\" + _require + \".strftimeTZ(format, date, locale, tz)`\", \"var s = \" + _require + \".localize(locale).timezone(tz); s(format, [date])` or `var s = \" + _require + \".localize(locale); s.timezone(tz)(format, [date])\");\n }\n else {\n deprecationWarning(\"`\" + _require + \".strftimeTZ(format, date, tz)`\", \"var s = \" + _require + \".timezone(tz); s(format, [date])` or `\" + _require + \".timezone(tz)(format, [date])\");\n }\n\n var strftime = (locale ? defaultStrftime.localize(locale) : defaultStrftime).timezone(timezone);\n return strftime(fmt, d);\n }\n\n var utcStrftime = defaultStrftime.utc();\n function deprecatedStrftimeUTC(fmt, d, locale) {\n if (locale) {\n deprecationWarning(\"`\" + _require + \".strftimeUTC(format, date, locale)`\", \"var s = \" + _require + \".localize(locale).utc(); s(format, [date])\");\n }\n else {\n deprecationWarning(\"`\" + _require + \".strftimeUTC(format, [date])`\", \"var s = \" + _require + \".utc(); s(format, [date])\");\n }\n var strftime = locale ? utcStrftime.localize(locale) : utcStrftime;\n return strftime(fmt, d);\n }\n\n function deprecatedStrftimeLocalized(locale) {\n deprecationWarning(\"`\" + _require + \".localizedStrftime(locale)`\", _require + \".localize(locale)\");\n return defaultStrftime.localize(locale);\n }\n // End of deprecated API\n\n // Polyfill Date.now for old browsers.\n if (typeof Date.now !== 'function') {\n Date.now = function() {\n return +new Date();\n };\n }\n\n function Strftime(locale, customTimezoneOffset, useUtcTimezone) {\n var _locale = locale || DefaultLocale,\n _customTimezoneOffset = customTimezoneOffset || 0,\n _useUtcBasedDate = useUtcTimezone || false,\n\n // we store unix timestamp value here to not create new Date() each iteration (each millisecond)\n // Date.now() is 2 times faster than new Date()\n // while millisecond precise is enough here\n // this could be very helpful when strftime triggered a lot of times one by one\n _cachedDateTimestamp = 0,\n _cachedDate;\n\n function _strftime(format, date) {\n var timestamp;\n\n if (!date) {\n var currentTimestamp = Date.now();\n if (currentTimestamp > _cachedDateTimestamp) {\n _cachedDateTimestamp = currentTimestamp;\n _cachedDate = new Date(_cachedDateTimestamp);\n\n timestamp = _cachedDateTimestamp;\n\n if (_useUtcBasedDate) {\n // how to avoid duplication of date instantiation for utc here?\n // we tied to getTimezoneOffset of the current date\n _cachedDate = new Date(_cachedDateTimestamp + getTimestampToUtcOffsetFor(_cachedDate) + _customTimezoneOffset);\n }\n }\n date = _cachedDate;\n }\n else {\n timestamp = date.getTime();\n\n if (_useUtcBasedDate) {\n date = new Date(date.getTime() + getTimestampToUtcOffsetFor(date) + _customTimezoneOffset);\n }\n }\n\n return _processFormat(format, date, _locale, timestamp);\n }\n\n function _processFormat(format, date, locale, timestamp) {\n var resultString = '',\n padding = null,\n isInScope = false,\n length = format.length,\n extendedTZ = false;\n\n for (var i = 0; i < length; i++) {\n\n var currentCharCode = format.charCodeAt(i);\n\n if (isInScope === true) {\n // '-'\n if (currentCharCode === 45) {\n padding = '';\n continue;\n }\n // '_'\n else if (currentCharCode === 95) {\n padding = ' ';\n continue;\n }\n // '0'\n else if (currentCharCode === 48) {\n padding = '0';\n continue;\n }\n // ':'\n else if (currentCharCode === 58) {\n if (extendedTZ) {\n if (typeof console !== 'undefined' && typeof console.warn == 'function') {\n console.warn(\"[WARNING] detected use of unsupported %:: or %::: modifiers to strftime\");\n }\n }\n extendedTZ = true;\n continue;\n }\n\n switch (currentCharCode) {\n\n // Examples for new Date(0) in GMT\n\n // 'Thursday'\n // case 'A':\n case 65:\n resultString += locale.days[date.getDay()];\n break;\n\n // 'January'\n // case 'B':\n case 66:\n resultString += locale.months[date.getMonth()];\n break;\n\n // '19'\n // case 'C':\n case 67:\n resultString += padTill2(Math.floor(date.getFullYear() / 100), padding);\n break;\n\n // '01/01/70'\n // case 'D':\n case 68:\n resultString += _processFormat(locale.formats.D, date, locale, timestamp);\n break;\n\n // '1970-01-01'\n // case 'F':\n case 70:\n resultString += _processFormat(locale.formats.F, date, locale, timestamp);\n break;\n\n // '00'\n // case 'H':\n case 72:\n resultString += padTill2(date.getHours(), padding);\n break;\n\n // '12'\n // case 'I':\n case 73:\n resultString += padTill2(hours12(date.getHours()), padding);\n break;\n\n // '000'\n // case 'L':\n case 76:\n resultString += padTill3(Math.floor(timestamp % 1000));\n break;\n\n // '00'\n // case 'M':\n case 77:\n resultString += padTill2(date.getMinutes(), padding);\n break;\n\n // 'am'\n // case 'P':\n case 80:\n resultString += date.getHours() < 12 ? locale.am : locale.pm;\n break;\n\n // '00:00'\n // case 'R':\n case 82:\n resultString += _processFormat(locale.formats.R, date, locale, timestamp);\n break;\n\n // '00'\n // case 'S':\n case 83:\n resultString += padTill2(date.getSeconds(), padding);\n break;\n\n // '00:00:00'\n // case 'T':\n case 84:\n resultString += _processFormat(locale.formats.T, date, locale, timestamp);\n break;\n\n // '00'\n // case 'U':\n case 85:\n resultString += padTill2(weekNumber(date, 'sunday'), padding);\n break;\n\n // '00'\n // case 'W':\n case 87:\n resultString += padTill2(weekNumber(date, 'monday'), padding);\n break;\n\n // '16:00:00'\n // case 'X':\n case 88:\n resultString += _processFormat(locale.formats.X, date, locale, timestamp);\n break;\n\n // '1970'\n // case 'Y':\n case 89:\n resultString += date.getFullYear();\n break;\n\n // 'GMT'\n // case 'Z':\n case 90:\n if (_useUtcBasedDate && _customTimezoneOffset === 0) {\n resultString += \"GMT\";\n }\n else {\n // fixme optimize\n var tzString = date.toString().match(/\\(([\\w\\s]+)\\)/);\n resultString += tzString && tzString[1] || '';\n }\n break;\n\n // 'Thu'\n // case 'a':\n case 97:\n resultString += locale.shortDays[date.getDay()];\n break;\n\n // 'Jan'\n // case 'b':\n case 98:\n resultString += locale.shortMonths[date.getMonth()];\n break;\n\n // ''\n // case 'c':\n case 99:\n resultString += _processFormat(locale.formats.c, date, locale, timestamp);\n break;\n\n // '01'\n // case 'd':\n case 100:\n resultString += padTill2(date.getDate(), padding);\n break;\n\n // ' 1'\n // case 'e':\n case 101:\n resultString += padTill2(date.getDate(), padding == null ? ' ' : padding);\n break;\n\n // 'Jan'\n // case 'h':\n case 104:\n resultString += locale.shortMonths[date.getMonth()];\n break;\n\n // '000'\n // case 'j':\n case 106:\n var y = new Date(date.getFullYear(), 0, 1);\n var day = Math.ceil((date.getTime() - y.getTime()) / (1000 * 60 * 60 * 24));\n resultString += padTill3(day);\n break;\n\n // ' 0'\n // case 'k':\n case 107:\n resultString += padTill2(date.getHours(), padding == null ? ' ' : padding);\n break;\n\n // '12'\n // case 'l':\n case 108:\n resultString += padTill2(hours12(date.getHours()), padding == null ? ' ' : padding);\n break;\n\n // '01'\n // case 'm':\n case 109:\n resultString += padTill2(date.getMonth() + 1, padding);\n break;\n\n // '\\n'\n // case 'n':\n case 110:\n resultString += '\\n';\n break;\n\n // '1st'\n // case 'o':\n case 111:\n resultString += String(date.getDate()) + ordinal(date.getDate());\n break;\n\n // 'AM'\n // case 'p':\n case 112:\n resultString += date.getHours() < 12 ? locale.AM : locale.PM;\n break;\n\n // '12:00:00 AM'\n // case 'r':\n case 114:\n resultString += _processFormat(locale.formats.r, date, locale, timestamp);\n break;\n\n // '0'\n // case 's':\n case 115:\n resultString += Math.floor(timestamp / 1000);\n break;\n\n // '\\t'\n // case 't':\n case 116:\n resultString += '\\t';\n break;\n\n // '4'\n // case 'u':\n case 117:\n var day = date.getDay();\n resultString += day === 0 ? 7 : day;\n break; // 1 - 7, Monday is first day of the week\n\n // ' 1-Jan-1970'\n // case 'v':\n case 118:\n resultString += _processFormat(locale.formats.v, date, locale, timestamp);\n break;\n\n // '4'\n // case 'w':\n case 119:\n resultString += date.getDay();\n break; // 0 - 6, Sunday is first day of the week\n\n // '12/31/69'\n // case 'x':\n case 120:\n resultString += _processFormat(locale.formats.x, date, locale, timestamp);\n break;\n\n // '70'\n // case 'y':\n case 121:\n resultString += ('' + date.getFullYear()).slice(2);\n break;\n\n // '+0000'\n // case 'z':\n case 122:\n if (_useUtcBasedDate && _customTimezoneOffset === 0) {\n resultString += extendedTZ ? \"+00:00\" : \"+0000\";\n }\n else {\n var off;\n if (_customTimezoneOffset !== 0) {\n off = _customTimezoneOffset / (60 * 1000);\n }\n else {\n off = -date.getTimezoneOffset();\n }\n var sign = off < 0 ? '-' : '+';\n var sep = extendedTZ ? ':' : '';\n var hours = Math.floor(Math.abs(off / 60));\n var mins = Math.abs(off % 60);\n resultString += sign + padTill2(hours) + sep + padTill2(mins);\n }\n break;\n\n default:\n resultString += format[i];\n break;\n }\n\n padding = null;\n isInScope = false;\n continue;\n }\n\n // '%'\n if (currentCharCode === 37) {\n isInScope = true;\n continue;\n }\n\n resultString += format[i];\n }\n\n return resultString;\n }\n\n var strftime = _strftime;\n\n strftime.localize = function(locale) {\n return new Strftime(locale || _locale, _customTimezoneOffset, _useUtcBasedDate);\n };\n\n strftime.timezone = function(timezone) {\n var customTimezoneOffset = _customTimezoneOffset;\n var useUtcBasedDate = _useUtcBasedDate;\n\n var timezoneType = typeof timezone;\n if (timezoneType === 'number' || timezoneType === 'string') {\n useUtcBasedDate = true;\n\n // ISO 8601 format timezone string, [-+]HHMM\n if (timezoneType === 'string') {\n var sign = timezone[0] === '-' ? -1 : 1,\n hours = parseInt(timezone.slice(1, 3), 10),\n minutes = parseInt(timezone.slice(3, 5), 10);\n\n customTimezoneOffset = sign * ((60 * hours) + minutes) * 60 * 1000;\n // in minutes: 420\n }\n else if (timezoneType === 'number') {\n customTimezoneOffset = timezone * 60 * 1000;\n }\n }\n\n return new Strftime(_locale, customTimezoneOffset, useUtcBasedDate);\n };\n\n strftime.utc = function() {\n return new Strftime(_locale, _customTimezoneOffset, true);\n };\n\n return strftime;\n }\n\n function padTill2(numberToPad, paddingChar) {\n if (paddingChar === '' || numberToPad > 9) {\n return numberToPad;\n }\n if (paddingChar == null) {\n paddingChar = '0';\n }\n return paddingChar + numberToPad;\n }\n\n function padTill3(numberToPad) {\n if (numberToPad > 99) {\n return numberToPad;\n }\n if (numberToPad > 9) {\n return '0' + numberToPad;\n }\n return '00' + numberToPad;\n }\n\n function hours12(hour) {\n if (hour === 0) {\n return 12;\n }\n else if (hour > 12) {\n return hour - 12;\n }\n return hour;\n }\n\n // firstWeekday: 'sunday' or 'monday', default is 'sunday'\n //\n // Pilfered & ported from Ruby's strftime implementation.\n function weekNumber(date, firstWeekday) {\n firstWeekday = firstWeekday || 'sunday';\n\n // This works by shifting the weekday back by one day if we\n // are treating Monday as the first day of the week.\n var weekday = date.getDay();\n if (firstWeekday === 'monday') {\n if (weekday === 0) // Sunday\n weekday = 6;\n else\n weekday--;\n }\n\n var firstDayOfYearUtc = Date.UTC(date.getFullYear(), 0, 1),\n dateUtc = Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()),\n yday = Math.floor((dateUtc - firstDayOfYearUtc) / 86400000),\n weekNum = (yday + 7 - weekday) / 7;\n\n return Math.floor(weekNum);\n }\n\n // Get the ordinal suffix for a number: st, nd, rd, or th\n function ordinal(number) {\n var i = number % 10;\n var ii = number % 100;\n\n if ((ii >= 11 && ii <= 13) || i === 0 || i >= 4) {\n return 'th';\n }\n switch (i) {\n case 1: return 'st';\n case 2: return 'nd';\n case 3: return 'rd';\n }\n }\n\n function getTimestampToUtcOffsetFor(date) {\n return (date.getTimezoneOffset() || 0) * 60000;\n }\n\n}());\n","//Provides: Base_int_math_int_popcount const\nfunction Base_int_math_int_popcount(v) {\n v = v - ((v >>> 1) & 0x55555555);\n v = (v & 0x33333333) + ((v >>> 2) & 0x33333333);\n return ((v + (v >>> 4) & 0xF0F0F0F) * 0x1010101) >>> 24;\n}\n\n//Provides: Base_clear_caml_backtrace_pos const\nfunction Base_clear_caml_backtrace_pos(x) {\n return 0;\n}\n\n//Provides: Base_int_math_int32_clz const\nfunction Base_int_math_int32_clz(x) {\n var n = 32;\n var y;\n y = x >>16; if (y != 0) { n = n -16; x = y; }\n y = x >> 8; if (y != 0) { n = n - 8; x = y; }\n y = x >> 4; if (y != 0) { n = n - 4; x = y; }\n y = x >> 2; if (y != 0) { n = n - 2; x = y; }\n y = x >> 1; if (y != 0) return n - 2;\n return n - x;\n}\n\n//Provides: Base_int_math_int_clz const\n//Requires: Base_int_math_int32_clz\nfunction Base_int_math_int_clz(x) { return Base_int_math_int32_clz(x); }\n\n//Provides: Base_int_math_nativeint_clz const\n//Requires: Base_int_math_int32_clz\nfunction Base_int_math_nativeint_clz(x) { return Base_int_math_int32_clz(x); }\n\n//Provides: Base_int_math_int64_clz const\n//Requires: caml_int64_shift_right_unsigned, caml_int64_is_zero, caml_int64_to_int32\nfunction Base_int_math_int64_clz(x) {\n var n = 64;\n var y;\n y = caml_int64_shift_right_unsigned(x, 32);\n if (!caml_int64_is_zero(y)) { n = n -32; x = y; }\n y = caml_int64_shift_right_unsigned(x, 16);\n if (!caml_int64_is_zero(y)) { n = n -16; x = y; }\n y = caml_int64_shift_right_unsigned(x, 8);\n if (!caml_int64_is_zero(y)) { n = n - 8; x = y; }\n y = caml_int64_shift_right_unsigned(x, 4);\n if (!caml_int64_is_zero(y)) { n = n - 4; x = y; }\n y = caml_int64_shift_right_unsigned(x, 2);\n if (!caml_int64_is_zero(y)) { n = n - 2; x = y; }\n y = caml_int64_shift_right_unsigned(x, 1);\n if (!caml_int64_is_zero(y)) return n - 2;\n return n - caml_int64_to_int32(x);\n}\n\n//Provides: Base_int_math_int32_ctz const\nfunction Base_int_math_int32_ctz(x) {\n if (x === 0) { return 32; }\n var n = 1;\n if ( (x & 0x0000FFFF) === 0) { n = n + 16; x = x >> 16; }\n if ( (x & 0x000000FF) === 0) { n = n + 8; x = x >> 8; }\n if ( (x & 0x0000000F) === 0) { n = n + 4; x = x >> 4; }\n if ( (x & 0x00000003) === 0) { n = n + 2; x = x >> 2; }\n return n - (x & 1);\n}\n\n//Provides: Base_int_math_int_ctz const\n//Requires: Base_int_math_int32_ctz\nfunction Base_int_math_int_ctz(x) { return Base_int_math_int32_ctz(x); }\n\n//Provides: Base_int_math_nativeint_ctz const\n//Requires: Base_int_math_int32_ctz\nfunction Base_int_math_nativeint_ctz(x) { return Base_int_math_int32_ctz(x); }\n\n//Provides: Base_int_math_int64_ctz const\n//Requires: caml_int64_shift_right_unsigned, caml_int64_is_zero, caml_int64_to_int32\n//Requires: caml_int64_and, caml_int64_of_int32, caml_int64_create_lo_mi_hi\nfunction Base_int_math_int64_ctz(x) {\n if (caml_int64_is_zero(x)) { return 64; }\n var n = 1;\n function is_zero (x) { return caml_int64_is_zero(x); }\n function land (x,y) { return caml_int64_and(x, y); }\n function small_int64(x) { return caml_int64_create_lo_mi_hi(x,0,0); }\n if (is_zero(land(x, caml_int64_create_lo_mi_hi(0xFFFFFF, 0x0000FF, 0x0000)))) {\n n = n + 32; x = caml_int64_shift_right_unsigned(x, 32);\n }\n if (is_zero(land(x, small_int64(0x00FFFF)))) {\n n = n + 16; x = caml_int64_shift_right_unsigned(x, 16);\n }\n if (is_zero(land(x, small_int64(0x0000FF)))) {\n n = n + 8; x = caml_int64_shift_right_unsigned(x, 8);\n }\n if (is_zero(land(x, small_int64(0x00000F)))) {\n n = n + 4; x = caml_int64_shift_right_unsigned(x, 4);\n }\n if (is_zero(land(x, small_int64(0x000003)))) {\n n = n + 2; x = caml_int64_shift_right_unsigned(x, 2);\n }\n return n - (caml_int64_to_int32(caml_int64_and(x, small_int64(0x000001))));\n}\n\n//Provides: Base_int_math_int_pow_stub const\nfunction Base_int_math_int_pow_stub(base, exponent) {\n var one = 1;\n var mul = [one, base, one, one];\n var res = one;\n while (!exponent==0) {\n mul[1] = (mul[1] * mul[3]) | 0;\n mul[2] = (mul[1] * mul[1]) | 0;\n mul[3] = (mul[2] * mul[1]) | 0;\n res = (res * mul[exponent & 3]) | 0;\n exponent = exponent >> 2;\n }\n return res;\n}\n\n//Provides: Base_int_math_int64_pow_stub const\n//Requires: caml_int64_mul, caml_int64_is_zero, caml_int64_shift_right_unsigned\n//Requires: caml_int64_create_lo_hi, caml_int64_lo32\nfunction Base_int_math_int64_pow_stub(base, exponent) {\n var one = caml_int64_create_lo_hi(1,0);\n var mul = [one, base, one, one];\n var res = one;\n while (!caml_int64_is_zero(exponent)) {\n mul[1] = caml_int64_mul(mul[1], mul[3]);\n mul[2] = caml_int64_mul(mul[1], mul[1]);\n mul[3] = caml_int64_mul(mul[2], mul[1]);\n res = caml_int64_mul(res, mul[caml_int64_lo32(exponent) & 3]);\n exponent = caml_int64_shift_right_unsigned(exponent, 2);\n }\n return res;\n}\n\n//Provides: Base_hash_string mutable\n//Requires: caml_hash\nfunction Base_hash_string(s) {\n return caml_hash(1,1,0,s)\n}\n//Provides: Base_hash_double const\n//Requires: caml_hash\nfunction Base_hash_double(d) {\n return caml_hash(1,1,0,d);\n}\n\n//Provides: Base_am_testing const\n//Weakdef\nfunction Base_am_testing(x) {\n return 0;\n}\n","// Js_of_ocaml runtime support\n// http://www.ocsigen.org/js_of_ocaml/\n//\n// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU Lesser General Public License as published by\n// the Free Software Foundation, with linking exception;\n// either version 2.1 of the License, or (at your option) any later version.\n//\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n// GNU Lesser General Public License for more details.\n//\n// You should have received a copy of the GNU Lesser General Public License\n// along with this program; if not, write to the Free Software\n// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n\n//Provides: caml_format_int const (const, const)\n//Requires: caml_parse_format, caml_finish_formatting, caml_str_repeat\n//Requires: caml_string_of_jsbytes, caml_jsbytes_of_string\nfunction caml_format_int(fmt, i) {\n if (caml_jsbytes_of_string(fmt) == \"%d\") return caml_string_of_jsbytes(\"\"+i);\n var f = caml_parse_format(fmt);\n if (i < 0) { if (f.signedconv) { f.sign = -1; i = -i; } else i >>>= 0; }\n var s = i.toString(f.base);\n if (f.prec >= 0) {\n f.filler = ' ';\n var n = f.prec - s.length;\n if (n > 0) s = caml_str_repeat (n, '0') + s;\n }\n return caml_finish_formatting(f, s);\n}\n\n//Provides: caml_parse_sign_and_base\n//Requires: caml_string_unsafe_get, caml_ml_string_length\nfunction caml_parse_sign_and_base (s) {\n var i = 0, len = caml_ml_string_length(s), base = 10, sign = 1;\n if (len > 0) {\n switch (caml_string_unsafe_get(s,i)) {\n case 45: i++; sign = -1; break;\n case 43: i++; sign = 1; break;\n }\n }\n if (i + 1 < len && caml_string_unsafe_get(s, i) == 48)\n switch (caml_string_unsafe_get(s, i + 1)) {\n case 120: case 88: base = 16; i += 2; break;\n case 111: case 79: base = 8; i += 2; break;\n case 98: case 66: base = 2; i += 2; break;\n case 117: case 85: i += 2; break;\n }\n return [i, sign, base];\n}\n\n//Provides: caml_parse_digit\nfunction caml_parse_digit(c) {\n if (c >= 48 && c <= 57) return c - 48;\n if (c >= 65 && c <= 90) return c - 55;\n if (c >= 97 && c <= 122) return c - 87;\n return -1;\n}\n\n//Provides: caml_int_of_string (const)\n//Requires: caml_ml_string_length, caml_string_unsafe_get\n//Requires: caml_parse_sign_and_base, caml_parse_digit, caml_failwith\nfunction caml_int_of_string (s) {\n var r = caml_parse_sign_and_base (s);\n var i = r[0], sign = r[1], base = r[2];\n var len = caml_ml_string_length(s);\n var threshold = -1 >>> 0;\n var c = (i < len)?caml_string_unsafe_get(s, i):0;\n var d = caml_parse_digit(c);\n if (d < 0 || d >= base) caml_failwith(\"int_of_string\");\n var res = d;\n for (i++;i= base) break;\n res = base * res + d;\n if (res > threshold) caml_failwith(\"int_of_string\");\n }\n if (i != len) caml_failwith(\"int_of_string\");\n // For base different from 10, we expect an unsigned representation,\n // hence any value of 'res' (less than 'threshold') is acceptable.\n // But we have to convert the result back to a signed integer.\n res = sign * res;\n if ((base == 10) && ((res | 0) != res))\n /* Signed representation expected, allow -2^(nbits-1) to 2^(nbits-1) - 1 */\n caml_failwith(\"int_of_string\");\n return res | 0;\n}\n\n//Provides: caml_mul const\nfunction caml_mul(a,b){\n return Math.imul(a,b);\n}\n\n//Provides: caml_div\n//Requires: caml_raise_zero_divide\nfunction caml_div(x,y) {\n if (y == 0) caml_raise_zero_divide ();\n return (x/y)|0;\n}\n\n//Provides: caml_mod\n//Requires: caml_raise_zero_divide\nfunction caml_mod(x,y) {\n if (y == 0) caml_raise_zero_divide ();\n return x%y;\n}\n\n//Provides: caml_bswap16\nfunction caml_bswap16(x) {\n return ((((x & 0x00FF) << 8) |\n ((x & 0xFF00) >> 8)));\n}\n//Provides: caml_int32_bswap\nfunction caml_int32_bswap(x) {\n return (((x & 0x000000FF) << 24) |\n ((x & 0x0000FF00) << 8) |\n ((x & 0x00FF0000) >>> 8) |\n ((x & 0xFF000000) >>> 24));\n}\n//Provides: caml_int64_bswap\n//Requires: caml_int64_to_bytes, caml_int64_of_bytes\nfunction caml_int64_bswap(x) {\n var y = caml_int64_to_bytes(x);\n return caml_int64_of_bytes([y[7], y[6], y[5], y[4], y[3], y[2], y[1], y[0]]);\n}\n","// Js_of_ocaml runtime support\n// http://www.ocsigen.org/js_of_ocaml/\n//\n// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU Lesser General Public License as published by\n// the Free Software Foundation, with linking exception;\n// either version 2.1 of the License, or (at your option) any later version.\n//\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n// GNU Lesser General Public License for more details.\n//\n// You should have received a copy of the GNU Lesser General Public License\n// along with this program; if not, write to the Free Software\n// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n\n///////////// Hashtbl\n\n//Provides: caml_hash_univ_param mutable\n//Requires: caml_is_ml_string, caml_is_ml_bytes\n//Requires: caml_ml_bytes_content\n//Requires: caml_int64_to_bytes, caml_int64_bits_of_float, caml_custom_ops\n//Requires: caml_ml_bytes_length, caml_jsbytes_of_string\nfunction caml_hash_univ_param (count, limit, obj) {\n var hash_accu = 0;\n function hash_aux (obj) {\n limit --;\n if (count < 0 || limit < 0) return;\n if (obj instanceof Array && obj[0] === (obj[0]|0)) {\n switch (obj[0]) {\n case 248:\n // Object\n count --;\n hash_accu = (hash_accu * 65599 + obj[2]) | 0;\n break;\n case 250:\n // Forward\n limit++; hash_aux(obj); break;\n default:\n count --;\n hash_accu = (hash_accu * 19 + obj[0]) | 0;\n for (var i = obj.length - 1; i > 0; i--) hash_aux (obj[i]);\n }\n } else if (caml_is_ml_bytes(obj)) {\n count --;\n var content = caml_ml_bytes_content(obj);\n if(typeof content === \"string\") {\n\tfor (var b = content, l = b.length, i = 0; i < l; i++)\n hash_accu = (hash_accu * 19 + b.charCodeAt(i)) | 0;\n } else { /* ARRAY */\n for (var a = content, l = a.length, i = 0; i < l; i++)\n hash_accu = (hash_accu * 19 + a[i]) | 0;\n }\n } else if (caml_is_ml_string(obj)) {\n var jsbytes = caml_jsbytes_of_string(obj);\n for (var b = jsbytes, l = jsbytes.length, i = 0; i < l; i++)\n hash_accu = (hash_accu * 19 + b.charCodeAt(i)) | 0;\n } else if (typeof obj === \"string\") {\n for (var b = obj, l = obj.length, i = 0; i < l; i++)\n hash_accu = (hash_accu * 19 + b.charCodeAt(i)) | 0;\n } else if (obj === (obj|0)) {\n // Integer\n count --;\n hash_accu = (hash_accu * 65599 + obj) | 0;\n } else if (obj === +obj) {\n // Float\n count--;\n var p = caml_int64_to_bytes (caml_int64_bits_of_float (obj));\n for (var i = 7; i >= 0; i--) hash_accu = (hash_accu * 19 + p[i]) | 0;\n } else if(obj && obj.caml_custom) {\n if(caml_custom_ops[obj.caml_custom] && caml_custom_ops[obj.caml_custom].hash) {\n var h = caml_custom_ops[obj.caml_custom].hash(obj) | 0;\n hash_accu = (hash_accu * 65599 + h) | 0;\n }\n }\n }\n hash_aux (obj);\n return hash_accu & 0x3FFFFFFF;\n}\n\n//function ROTL32(x,n) { return ((x << n) | (x >>> (32-n))); }\n//Provides: caml_hash_mix_int\n//Requires: caml_mul\nfunction caml_hash_mix_int(h,d) {\n d = caml_mul(d, 0xcc9e2d51|0);\n d = ((d << 15) | (d >>> (32-15))); // ROTL32(d, 15);\n d = caml_mul(d, 0x1b873593);\n h ^= d;\n h = ((h << 13) | (h >>> (32-13))); //ROTL32(h, 13);\n return (((h + (h << 2))|0) + (0xe6546b64|0))|0;\n}\n\n//Provides: caml_hash_mix_final\n//Requires: caml_mul\nfunction caml_hash_mix_final(h) {\n h ^= h >>> 16;\n h = caml_mul (h, 0x85ebca6b|0);\n h ^= h >>> 13;\n h = caml_mul (h, 0xc2b2ae35|0);\n h ^= h >>> 16;\n return h;\n}\n\n//Provides: caml_hash_mix_float\n//Requires: caml_int64_bits_of_float, caml_hash_mix_int64\nfunction caml_hash_mix_float (h, v0) {\n return caml_hash_mix_int64(h, caml_int64_bits_of_float (v0));\n}\n//Provides: caml_hash_mix_int64\n//Requires: caml_hash_mix_int\n//Requires: caml_int64_lo32, caml_int64_hi32\nfunction caml_hash_mix_int64 (h, v) {\n h = caml_hash_mix_int(h, caml_int64_lo32(v));\n h = caml_hash_mix_int(h, caml_int64_hi32(v));\n return h;\n}\n\n//Provides: caml_hash_mix_jsbytes\n//Requires: caml_hash_mix_int\nfunction caml_hash_mix_jsbytes(h, s) {\n var len = s.length, i, w;\n for (i = 0; i + 4 <= len; i += 4) {\n w = s.charCodeAt(i)\n | (s.charCodeAt(i+1) << 8)\n | (s.charCodeAt(i+2) << 16)\n | (s.charCodeAt(i+3) << 24);\n h = caml_hash_mix_int(h, w);\n }\n w = 0;\n switch (len & 3) {\n case 3: w = s.charCodeAt(i+2) << 16;\n case 2: w |= s.charCodeAt(i+1) << 8;\n case 1:\n w |= s.charCodeAt(i);\n h = caml_hash_mix_int(h, w);\n default:\n }\n h ^= len;\n return h;\n}\n\n//Provides: caml_hash_mix_bytes_arr\n//Requires: caml_hash_mix_int\nfunction caml_hash_mix_bytes_arr(h, s) {\n var len = s.length, i, w;\n for (i = 0; i + 4 <= len; i += 4) {\n w = s[i]\n | (s[i+1] << 8)\n | (s[i+2] << 16)\n | (s[i+3] << 24);\n h = caml_hash_mix_int(h, w);\n }\n w = 0;\n switch (len & 3) {\n case 3: w = s[i+2] << 16;\n case 2: w |= s[i+1] << 8;\n case 1: w |= s[i];\n h = caml_hash_mix_int(h, w);\n default:\n }\n h ^= len;\n return h;\n}\n\n//Provides: caml_hash_mix_bytes\n//Requires: caml_ml_bytes_content\n//Requires: caml_hash_mix_jsbytes\n//Requires: caml_hash_mix_bytes_arr\nfunction caml_hash_mix_bytes(h, v) {\n var content = caml_ml_bytes_content(v);\n if(typeof content === \"string\")\n return caml_hash_mix_jsbytes(h, content)\n else /* ARRAY */\n return caml_hash_mix_bytes_arr(h, content);\n}\n\n//Provides: caml_hash_mix_string\n//Requires: caml_hash_mix_jsbytes, caml_jsbytes_of_string\nfunction caml_hash_mix_string(h, v) {\n return caml_hash_mix_jsbytes(h, caml_jsbytes_of_string(v));\n}\n\n\n//Provides: caml_hash mutable\n//Requires: caml_is_ml_string, caml_is_ml_bytes\n//Requires: caml_hash_mix_int, caml_hash_mix_final\n//Requires: caml_hash_mix_float, caml_hash_mix_string, caml_hash_mix_bytes, caml_custom_ops\n//Requires: caml_hash_mix_jsbytes\nfunction caml_hash (count, limit, seed, obj) {\n var queue, rd, wr, sz, num, h, v, i, len;\n sz = limit;\n if (sz < 0 || sz > 256) sz = 256;\n num = count;\n h = seed;\n queue = [obj]; rd = 0; wr = 1;\n while (rd < wr && num > 0) {\n v = queue[rd++];\n if (v && v.caml_custom){\n if(caml_custom_ops[v.caml_custom] && caml_custom_ops[v.caml_custom].hash) {\n var hh = caml_custom_ops[v.caml_custom].hash(v);\n h = caml_hash_mix_int (h, hh);\n num --;\n }\n }\n else if (v instanceof Array && v[0] === (v[0]|0)) {\n switch (v[0]) {\n case 248:\n // Object\n h = caml_hash_mix_int(h, v[2]);\n num--;\n break;\n case 250:\n // Forward\n queue[--rd] = v[1];\n break;\n default:\n var tag = ((v.length - 1) << 10) | v[0];\n h = caml_hash_mix_int(h, tag);\n for (i = 1, len = v.length; i < len; i++) {\n if (wr >= sz) break;\n queue[wr++] = v[i];\n }\n break;\n }\n } else if (caml_is_ml_bytes(v)) {\n h = caml_hash_mix_bytes(h,v)\n num--;\n } else if (caml_is_ml_string(v)) {\n h = caml_hash_mix_string(h,v)\n num--;\n } else if (typeof v === \"string\") {\n h = caml_hash_mix_jsbytes(h,v)\n num--;\n } else if (v === (v|0)) {\n // Integer\n h = caml_hash_mix_int(h, v+v+1);\n num--;\n } else if (v === +v) {\n // Float\n h = caml_hash_mix_float(h,v);\n num--;\n }\n }\n h = caml_hash_mix_final(h);\n return h & 0x3FFFFFFF;\n}\n","// Js_of_ocaml runtime support\n// http://www.ocsigen.org/js_of_ocaml/\n// Copyright (C) 2010 Jérôme Vouillon\n// Laboratoire PPS - CNRS Université Paris Diderot\n//\n// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU Lesser General Public License as published by\n// the Free Software Foundation, with linking exception;\n// either version 2.1 of the License, or (at your option) any later version.\n//\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n// GNU Lesser General Public License for more details.\n//\n// You should have received a copy of the GNU Lesser General Public License\n// along with this program; if not, write to the Free Software\n// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n\n//Provides: jsoo_floor_log2\nvar log2_ok = Math.log2 && Math.log2(1.1235582092889474E+307) == 1020\nfunction jsoo_floor_log2(x) {\n if(log2_ok) return Math.floor(Math.log2(x))\n var i = 0;\n if (x == 0) return -Infinity;\n if(x>=1) {while (x>=2) {x/=2; i++} }\n else {while (x < 1) {x*=2; i--} };\n return i;\n}\n\n//Provides: caml_int64_bits_of_float const\n//Requires: jsoo_floor_log2, caml_int64_create_lo_mi_hi\nfunction caml_int64_bits_of_float (x) {\n if (!isFinite(x)) {\n if (isNaN(x))\n return caml_int64_create_lo_mi_hi(1, 0, 0x7ff0);\n if (x > 0)\n return caml_int64_create_lo_mi_hi(0, 0, 0x7ff0)\n else\n return caml_int64_create_lo_mi_hi(0, 0, 0xfff0)\n }\n var sign = (x==0 && 1/x == -Infinity)?0x8000:(x>=0)?0:0x8000;\n if (sign) x = -x;\n // Int64.bits_of_float 1.1235582092889474E+307 = 0x7fb0000000000000L\n // using Math.LOG2E*Math.log(x) in place of Math.log2 result in precision lost\n var exp = jsoo_floor_log2(x) + 1023;\n if (exp <= 0) {\n exp = 0;\n x /= Math.pow(2,-1026);\n } else {\n x /= Math.pow(2,exp-1027);\n if (x < 16) {\n x *= 2; exp -=1; }\n if (exp == 0) {\n x /= 2; }\n }\n var k = Math.pow(2,24);\n var r3 = x|0;\n x = (x - r3) * k;\n var r2 = x|0;\n x = (x - r2) * k;\n var r1 = x|0;\n r3 = (r3 &0xf) | sign | exp << 4;\n return caml_int64_create_lo_mi_hi(r1, r2, r3);\n}\n\n//Provides: caml_int32_bits_of_float const\n//Requires: jsoo_floor_log2\nfunction caml_int32_bits_of_float (x) {\n var float32a = new globalThis.Float32Array(1);\n float32a[0] = x;\n var int32a = new globalThis.Int32Array(float32a.buffer);\n return int32a[0] | 0;\n}\n\n//FP literals can be written using the hexadecimal\n//notation 0xp from ISO C99.\n//https://github.com/dankogai/js-hexfloat/blob/master/hexfloat.js\n//Provides: caml_hexstring_of_float const\n//Requires: caml_string_of_jsstring, caml_str_repeat\nfunction caml_hexstring_of_float (x, prec, style) {\n if (!isFinite(x)) {\n if (isNaN(x)) return caml_string_of_jsstring(\"nan\");\n return caml_string_of_jsstring ((x > 0)?\"infinity\":\"-infinity\");\n }\n var sign = (x==0 && 1/x == -Infinity)?1:(x>=0)?0:1;\n if(sign) x = -x;\n var exp = 0;\n if (x == 0) { }\n else if (x < 1) {\n while (x < 1 && exp > -1022) { x *= 2; exp-- }\n } else {\n while (x >= 2) { x /= 2; exp++ }\n }\n var exp_sign = exp < 0 ? '' : '+';\n var sign_str = '';\n if (sign) sign_str = '-'\n else {\n switch(style){\n case 43 /* '+' */: sign_str = '+'; break;\n case 32 /* ' ' */: sign_str = ' '; break;\n default: break;\n }\n }\n if (prec >= 0 && prec < 13) {\n /* If a precision is given, and is small, round mantissa accordingly */\n var cst = Math.pow(2,prec * 4);\n x = Math.round(x * cst) / cst;\n }\n var x_str = x.toString(16);\n if(prec >= 0){\n var idx = x_str.indexOf('.');\n if(idx<0) {\n x_str += '.' + caml_str_repeat(prec, '0');\n }\n else {\n var size = idx+1+prec;\n if(x_str.length < size)\n x_str += caml_str_repeat(size - x_str.length, '0');\n else\n x_str = x_str.substr(0,size);\n }\n }\n return caml_string_of_jsstring (sign_str + '0x' + x_str + 'p' + exp_sign + exp.toString(10));\n}\n\n//Provides: caml_int64_float_of_bits const\nfunction caml_int64_float_of_bits (x) {\n var lo = x.lo;\n var mi = x.mi;\n var hi = x.hi;\n var exp = (hi & 0x7fff) >> 4;\n if (exp == 2047) {\n if ((lo|mi|(hi&0xf)) == 0)\n return (hi & 0x8000)?(-Infinity):Infinity;\n else\n return NaN;\n }\n var k = Math.pow(2,-24);\n var res = (lo*k+mi)*k+(hi&0xf);\n if (exp > 0) {\n res += 16;\n res *= Math.pow(2,exp-1027);\n } else\n res *= Math.pow(2,-1026);\n if (hi & 0x8000) res = - res;\n return res;\n}\n\n//Provides: caml_nextafter_float const\n//Requires: caml_int64_float_of_bits, caml_int64_bits_of_float, caml_int64_add, caml_int64_sub,caml_int64_of_int32\nfunction caml_nextafter_float (x,y) {\n if(isNaN(x) || isNaN(y)) return NaN;\n if(x==y) return y;\n if(x==0){\n if(y < 0)\n return -Math.pow(2, -1074)\n else\n return Math.pow(2, -1074)\n }\n var bits = caml_int64_bits_of_float(x);\n var one = caml_int64_of_int32(1);\n if ((x0))\n bits = caml_int64_add(bits, one)\n else\n bits = caml_int64_sub(bits, one)\n return caml_int64_float_of_bits(bits);\n}\n\n//Provides: caml_trunc_float\nfunction caml_trunc_float(x){\n return Math.trunc(x);\n}\n\n//Provides: caml_int32_float_of_bits const\nfunction caml_int32_float_of_bits (x) {\n var int32a = new globalThis.Int32Array(1);\n int32a[0] = x;\n var float32a = new globalThis.Float32Array(int32a.buffer);\n return float32a[0];\n}\n\n//Provides: caml_classify_float const\nfunction caml_classify_float (x) {\n if (isFinite (x)) {\n if (Math.abs(x) >= 2.2250738585072014e-308) return 0;\n if (x != 0) return 1;\n return 2;\n }\n return isNaN(x)?4:3;\n}\n//Provides: caml_modf_float const\nfunction caml_modf_float (x) {\n if (isFinite (x)) {\n var neg = (1/x) < 0;\n x = Math.abs(x);\n var i = Math.floor (x);\n var f = x - i;\n if (neg) { i = -i; f = -f; }\n return [0, f, i];\n }\n if (isNaN (x)) return [0, NaN, NaN];\n return [0, 1/x, x];\n}\n//Provides: caml_ldexp_float const\nfunction caml_ldexp_float (x,exp) {\n exp |= 0;\n if (exp > 1023) {\n exp -= 1023;\n x *= Math.pow(2, 1023);\n if (exp > 1023) { // in case x is subnormal\n exp -= 1023;\n x *= Math.pow(2, 1023);\n }\n }\n if (exp < -1023) {\n exp += 1023;\n x *= Math.pow(2, -1023);\n }\n x *= Math.pow(2, exp);\n return x;\n}\n//Provides: caml_frexp_float const\n//Requires: jsoo_floor_log2\nfunction caml_frexp_float (x) {\n if ((x == 0) || !isFinite(x)) return [0, x, 0];\n var neg = x < 0;\n if (neg) x = - x;\n var exp = Math.max(-1023, jsoo_floor_log2(x) + 1);\n x *= Math.pow(2,-exp);\n while (x < 0.5) {\n x *= 2;\n exp--;\n }\n while (x >= 1) {\n x *= 0.5;\n exp++;\n }\n if (neg) x = - x;\n return [0, x, exp];\n}\n\n//Provides: caml_float_compare const\nfunction caml_float_compare (x, y) {\n if (x === y) return 0;\n if (x < y) return -1;\n if (x > y) return 1;\n if (x === x) return 1;\n if (y === y) return -1;\n return 0;\n}\n\n//Provides: caml_copysign_float const\nfunction caml_copysign_float (x, y) {\n if (y == 0) y = 1 / y;\n x = Math.abs(x);\n return (y < 0)?(-x):x;\n}\n\n//Provides: caml_signbit_float const\nfunction caml_signbit_float(x) {\n if (x == 0) x = 1 / x;\n return (x < 0)?1:0;\n}\n\n//Provides: caml_expm1_float const\nfunction caml_expm1_float (x) { return Math.expm1(x); }\n//Provides: caml_exp2_float const\nfunction caml_exp2_float(x) { return Math.pow(2, x); }\n//Provides: caml_log1p_float const\nfunction caml_log1p_float(x) { return Math.log1p(x); }\n//Provides: caml_log2_float const\nfunction caml_log2_float(x) { return Math.log2(x); }\n//Provides: caml_hypot_float const\nfunction caml_hypot_float (x, y) { return Math.hypot(x, y); }\n//Provides: caml_log10_float const\nfunction caml_log10_float (x) { return Math.log10(x); }\n//Provides: caml_cosh_float const\nfunction caml_cosh_float (x) { return Math.cosh(x); }\n//Provides: caml_acosh_float const\nfunction caml_acosh_float (x) { return Math.acosh(x); }\n//Provides: caml_sinh_float const\nfunction caml_sinh_float (x) { return Math.sinh(x); }\n//Provides: caml_asinh_float const\nfunction caml_asinh_float (x) { return Math.asinh(x); }\n//Provides: caml_tanh_float const\nfunction caml_tanh_float (x) { return Math.tanh(x); }\n//Provides: caml_atanh_float const\nfunction caml_atanh_float (x) { return Math.atanh(x); }\n//Provides: caml_round_float const\nfunction caml_round_float (x) { return Math.round(x); }\n//Provides: caml_cbrt_float const\nfunction caml_cbrt_float (x) { return Math.cbrt(x); }\n\n//Provides: caml_erf_float const\nfunction caml_erf_float(x) {\n var a1 = 0.254829592;\n var a2 = -0.284496736;\n var a3 = 1.421413741;\n var a4 = -1.453152027;\n var a5 = 1.061405429;\n var p = 0.3275911;\n\n var sign = 1;\n if (x < 0) {\n sign = -1;\n }\n x = Math.abs(x);\n var t = 1.0 / (1.0 + p * x);\n var y = 1.0 - ((((a5 * t + a4) * t + a3) * t + a2) * t + a1) * t * Math.exp(-x * x);\n\n return sign * y;\n}\n\n//Provides: caml_erfc_float const\n//Requires: caml_erf_float\nfunction caml_erfc_float(x) {\n return 1 - caml_erf_float(x);\n}\n\n\n//Provides: caml_fma_float const\nfunction caml_fma_float(x, y, z) {\n var SPLIT = Math.pow(2, 27) + 1;\n var MIN_VALUE = Math.pow(2, -1022);\n var EPSILON = Math.pow(2, -52);\n var C = 416;\n var A = Math.pow(2, +C);\n var B = Math.pow(2, -C);\n\n function multiply (a, b) {\n var at = SPLIT * a;\n var ahi = at - (at - a);\n var alo = a - ahi;\n var bt = SPLIT * b;\n var bhi = bt - (bt - b);\n var blo = b - bhi;\n var p = a * b;\n var e = ((ahi * bhi - p) + ahi * blo + alo * bhi) + alo * blo;\n return {\n p: p,\n e: e\n };\n };\n\n function add (a, b) {\n var s = a + b;\n var v = s - a;\n var e = (a - (s - v)) + (b - v);\n return {\n s: s,\n e: e\n };\n };\n\n function adjust (x, y) {\n return x !== 0 && y !== 0 && SPLIT * x - (SPLIT * x - x) === x ? x * (1 + (x < 0 ? -1 : +1) * (y < 0 ? -1 : +1) * EPSILON) : x;\n };\n\n if (x === 0 || x !== x || x === +1 / 0 || x === -1 / 0 ||\n y === 0 || y !== y || y === +1 / 0 || y === -1 / 0) {\n return x * y + z;\n }\n if (z === 0) {\n return x * y;\n }\n if (z !== z || z === +1 / 0 || z === -1 / 0) {\n return z;\n }\n\n var scale = 1;\n while (Math.abs(x) > A) {\n scale *= A;\n x *= B;\n }\n while (Math.abs(y) > A) {\n scale *= A;\n y *= B;\n }\n if (scale === 1 / 0) {\n return x * y * scale;\n }\n while (Math.abs(x) < B) {\n scale *= B;\n x *= A;\n }\n while (Math.abs(y) < B) {\n scale *= B;\n y *= A;\n }\n if (scale === 0) {\n return z;\n }\n\n var xs = x;\n var ys = y;\n var zs = z / scale;\n\n if (Math.abs(zs) > Math.abs(xs * ys) * 4 / EPSILON) {\n return z;\n }\n if (Math.abs(zs) < Math.abs(xs * ys) * EPSILON / 4 * EPSILON / 4) {\n zs = (z < 0 ? -1 : +1) * MIN_VALUE;\n }\n\n var xy = multiply(xs, ys);\n var s = add(xy.p, zs);\n var u = add(xy.e, s.e);\n var i = add(s.s, u.s);\n\n var f = i.s + adjust(i.e, u.e);\n if (f === 0) {\n return f;\n }\n\n var fs = f * scale;\n if (Math.abs(fs) > MIN_VALUE) {\n return fs;\n }\n\n // It is possible that there was extra rounding for a denormalized value.\n return fs + adjust(f - fs / scale, i.e) * scale;\n}\n\n//Provides: caml_format_float const\n//Requires: caml_parse_format, caml_finish_formatting\nfunction caml_format_float (fmt, x) {\n function toFixed(x,dp) {\n if (Math.abs(x) < 1.0) {\n return x.toFixed(dp);\n } else {\n var e = parseInt(x.toString().split('+')[1]);\n if (e > 20) {\n e -= 20;\n x /= Math.pow(10,e);\n x += (new Array(e+1)).join('0');\n if(dp > 0) {\n x = x + '.' + (new Array(dp+1)).join('0');\n }\n return x;\n }\n else return x.toFixed(dp)\n }\n }\n var s, f = caml_parse_format(fmt);\n var prec = (f.prec < 0)?6:f.prec;\n if (x < 0 || (x == 0 && 1/x == -Infinity)) { f.sign = -1; x = -x; }\n if (isNaN(x)) { s = \"nan\"; f.filler = ' '; }\n else if (!isFinite(x)) { s = \"inf\"; f.filler = ' '; }\n else\n switch (f.conv) {\n case 'e':\n var s = x.toExponential(prec);\n // exponent should be at least two digits\n var i = s.length;\n if (s.charAt(i - 3) == 'e')\n s = s.slice (0, i - 1) + '0' + s.slice (i - 1);\n break;\n case 'f':\n s = toFixed(x, prec); break;\n case 'g':\n prec = prec?prec:1;\n s = x.toExponential(prec - 1);\n var j = s.indexOf('e');\n var exp = +s.slice(j + 1);\n if (exp < -4 || x >= 1e21 || x.toFixed(0).length > prec) {\n // remove trailing zeroes\n var i = j - 1; while (s.charAt(i) == '0') i--;\n if (s.charAt(i) == '.') i--;\n s = s.slice(0, i + 1) + s.slice(j);\n i = s.length;\n if (s.charAt(i - 3) == 'e')\n s = s.slice (0, i - 1) + '0' + s.slice (i - 1);\n break;\n } else {\n var p = prec;\n if (exp < 0) { p -= exp + 1; s = x.toFixed(p); }\n else while (s = x.toFixed(p), s.length > prec + 1) p--;\n if (p) {\n // remove trailing zeroes\n var i = s.length - 1; while (s.charAt(i) == '0') i--;\n if (s.charAt(i) == '.') i--;\n s = s.slice(0, i + 1);\n }\n }\n break;\n }\n return caml_finish_formatting(f, s);\n}\n\n//Provides: caml_float_of_string (const)\n//Requires: caml_failwith, caml_jsbytes_of_string\nfunction caml_float_of_string(s) {\n var res;\n s = caml_jsbytes_of_string(s)\n res = +s;\n if ((s.length > 0) && (res === res)) return res;\n s = s.replace(/_/g,\"\");\n res = +s;\n if (((s.length > 0) && (res === res)) || /^[+-]?nan$/i.test(s)) return res;\n var m = /^ *([+-]?)0x([0-9a-f]+)\\.?([0-9a-f]*)(p([+-]?[0-9]+))?/i.exec(s);\n // 1 2 3 5\n if(m){\n var m3 = m[3].replace(/0+$/,'');\n var mantissa = parseInt(m[1] + m[2] + m3, 16);\n var exponent = (m[5]|0) - 4*m3.length;\n res = mantissa * Math.pow(2, exponent);\n return res;\n }\n if(/^\\+?inf(inity)?$/i.test(s)) return Infinity;\n if(/^-inf(inity)?$/i.test(s)) return -Infinity;\n caml_failwith(\"float_of_string\");\n}\n","// Js_of_ocaml runtime support\n// http://www.ocsigen.org/js_of_ocaml/\n// Copyright (C) 2010 Jérôme Vouillon\n// Laboratoire PPS - CNRS Université Paris Diderot\n//\n// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU Lesser General Public License as published by\n// the Free Software Foundation, with linking exception;\n// either version 2.1 of the License, or (at your option) any later version.\n//\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n// GNU Lesser General Public License for more details.\n//\n// You should have received a copy of the GNU Lesser General Public License\n// along with this program; if not, write to the Free Software\n// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n\n//Provides: caml_int64_offset\nvar caml_int64_offset = Math.pow(2, -24);\n\n//Provides: MlInt64\n//Requires: caml_int64_offset, caml_raise_zero_divide\nfunction MlInt64 (lo,mi,hi) {\n this.lo = lo & 0xffffff;\n this.mi = mi & 0xffffff;\n this.hi = hi & 0xffff;\n}\nMlInt64.prototype.caml_custom = \"_j\"\nMlInt64.prototype.copy = function () {\n return new MlInt64(this.lo,this.mi,this.hi);\n}\n\nMlInt64.prototype.ucompare = function (x) {\n if (this.hi > x.hi) return 1;\n if (this.hi < x.hi) return -1;\n if (this.mi > x.mi) return 1;\n if (this.mi < x.mi) return -1;\n if (this.lo > x.lo) return 1;\n if (this.lo < x.lo) return -1;\n return 0;\n}\nMlInt64.prototype.compare = function (x) {\n var hi = this.hi << 16;\n var xhi = x.hi << 16;\n if (hi > xhi) return 1;\n if (hi < xhi) return -1;\n if (this.mi > x.mi) return 1;\n if (this.mi < x.mi) return -1;\n if (this.lo > x.lo) return 1;\n if (this.lo < x.lo) return -1;\n return 0;\n}\nMlInt64.prototype.neg = function () {\n var lo = - this.lo;\n var mi = - this.mi + (lo >> 24);\n var hi = - this.hi + (mi >> 24);\n return new MlInt64(lo, mi, hi);\n}\nMlInt64.prototype.add = function (x) {\n var lo = this.lo + x.lo;\n var mi = this.mi + x.mi + (lo >> 24);\n var hi = this.hi + x.hi + (mi >> 24);\n return new MlInt64(lo, mi, hi);\n}\nMlInt64.prototype.sub = function (x) {\n var lo = this.lo - x.lo;\n var mi = this.mi - x.mi + (lo >> 24);\n var hi = this.hi - x.hi + (mi >> 24);\n return new MlInt64(lo, mi, hi);\n}\nMlInt64.prototype.mul = function (x) {\n var lo = this.lo * x.lo;\n var mi = ((lo * caml_int64_offset) | 0) + this.mi * x.lo + this.lo * x.mi;\n var hi = ((mi * caml_int64_offset) | 0) + this.hi * x.lo + this.mi * x.mi + this.lo * x.hi;\n return new MlInt64(lo, mi, hi);\n}\nMlInt64.prototype.isZero = function () {\n return (this.lo|this.mi|this.hi) == 0;\n}\nMlInt64.prototype.isNeg = function () {\n return (this.hi << 16) < 0;\n}\nMlInt64.prototype.and = function (x) {\n return new MlInt64(this.lo & x.lo, this.mi & x.mi, this.hi & x.hi);\n}\nMlInt64.prototype.or = function (x) {\n return new MlInt64(this.lo|x.lo, this.mi|x.mi, this.hi|x.hi);\n}\nMlInt64.prototype.xor = function (x) {\n return new MlInt64(this.lo^x.lo, this.mi^x.mi, this.hi^x.hi);\n}\nMlInt64.prototype.shift_left = function (s) {\n s = s & 63;\n if (s == 0) return this;\n if (s < 24) {\n return new MlInt64 (this.lo << s,\n (this.mi << s) | (this.lo >> (24 - s)),\n (this.hi << s) | (this.mi >> (24 - s)));\n }\n if (s < 48)\n return new MlInt64 (0,\n this.lo << (s - 24),\n (this.mi << (s - 24)) | (this.lo >> (48 - s)));\n return new MlInt64(0, 0, this.lo << (s - 48))\n}\nMlInt64.prototype.shift_right_unsigned = function (s) {\n s = s & 63;\n if (s == 0) return this;\n if (s < 24)\n return new MlInt64 (\n (this.lo >> s) | (this.mi << (24 - s)),\n (this.mi >> s) | (this.hi << (24 - s)),\n (this.hi >> s));\n if (s < 48)\n return new MlInt64 (\n (this.mi >> (s - 24)) | (this.hi << (48 - s)),\n (this.hi >> (s - 24)),\n 0);\n return new MlInt64 (this.hi >> (s - 48), 0, 0);\n}\nMlInt64.prototype.shift_right = function (s) {\n s = s & 63;\n if (s == 0) return this;\n var h = (this.hi << 16) >> 16;\n if (s < 24)\n return new MlInt64 (\n (this.lo >> s) | (this.mi << (24 - s)),\n (this.mi >> s) | (h << (24 - s)),\n ((this.hi << 16) >> s) >>> 16);\n var sign = (this.hi << 16) >> 31;\n if (s < 48)\n return new MlInt64 (\n (this.mi >> (s - 24)) | (this.hi << (48 - s)),\n (this.hi << 16) >> (s - 24) >> 16,\n sign & 0xffff);\n return new MlInt64 ((this.hi << 16) >> (s - 32), sign, sign);\n}\nMlInt64.prototype.lsl1 = function () {\n this.hi = (this.hi << 1) | (this.mi >> 23);\n this.mi = ((this.mi << 1) | (this.lo >> 23)) & 0xffffff;\n this.lo = (this.lo << 1) & 0xffffff;\n}\nMlInt64.prototype.lsr1 = function () {\n this.lo = ((this.lo >>> 1) | (this.mi << 23)) & 0xffffff;\n this.mi = ((this.mi >>> 1) | (this.hi << 23)) & 0xffffff;\n this.hi = this.hi >>> 1;\n}\nMlInt64.prototype.udivmod = function (x) {\n var offset = 0;\n var modulus = this.copy();\n var divisor = x.copy();\n var quotient = new MlInt64(0,0,0);\n while (modulus.ucompare(divisor) > 0) {\n offset++;\n divisor.lsl1();\n }\n while (offset >= 0) {\n offset --;\n quotient.lsl1();\n if (modulus.ucompare(divisor) >= 0) {\n quotient.lo ++;\n modulus = modulus.sub(divisor);\n }\n divisor.lsr1();\n }\n return { quotient : quotient, modulus : modulus };\n}\nMlInt64.prototype.div = function (y)\n{\n var x = this;\n if (y.isZero()) caml_raise_zero_divide ();\n var sign = x.hi ^ y.hi;\n if (x.hi & 0x8000) x = x.neg();\n if (y.hi & 0x8000) y = y.neg();\n var q = x.udivmod(y).quotient;\n if (sign & 0x8000) q = q.neg();\n return q;\n}\nMlInt64.prototype.mod = function (y)\n{\n var x = this;\n if (y.isZero()) caml_raise_zero_divide ();\n var sign = x.hi;\n if (x.hi & 0x8000) x = x.neg();\n if (y.hi & 0x8000) y = y.neg();\n var r = x.udivmod(y).modulus;\n if (sign & 0x8000) r = r.neg();\n return r;\n}\nMlInt64.prototype.toInt = function () {\n return this.lo | (this.mi << 24);\n}\nMlInt64.prototype.toFloat = function () {\n return ((this.hi << 16) * Math.pow(2, 32) + this.mi * Math.pow(2, 24)) + this.lo;\n}\nMlInt64.prototype.toArray = function () {\n return [this.hi >> 8,\n this.hi & 0xff,\n this.mi >> 16,\n (this.mi >> 8) & 0xff,\n this.mi & 0xff,\n this.lo >> 16,\n (this.lo >> 8) & 0xff,\n this.lo & 0xff];\n}\nMlInt64.prototype.lo32 = function () {\n return this.lo | ((this.mi & 0xff) << 24);\n}\nMlInt64.prototype.hi32 = function () {\n return ((this.mi >>> 8) & 0xffff) | (this.hi << 16);\n}\n\n//Provides: caml_int64_ult const\nfunction caml_int64_ult(x,y) { return x.ucompare(y) < 0; }\n\n//Provides: caml_int64_compare const\nfunction caml_int64_compare(x,y, total) { return x.compare(y) }\n\n//Provides: caml_int64_neg const\nfunction caml_int64_neg (x) { return x.neg() }\n\n//Provides: caml_int64_add const\nfunction caml_int64_add (x, y) { return x.add(y) }\n\n//Provides: caml_int64_sub const\nfunction caml_int64_sub (x, y) { return x.sub(y) }\n\n//Provides: caml_int64_mul const\n//Requires: caml_int64_offset\nfunction caml_int64_mul(x,y) { return x.mul(y) }\n\n//Provides: caml_int64_is_zero const\nfunction caml_int64_is_zero(x) { return +x.isZero(); }\n\n//Provides: caml_int64_is_negative const\nfunction caml_int64_is_negative(x) { return +x.isNeg(); }\n\n//Provides: caml_int64_and const\nfunction caml_int64_and (x, y) { return x.and(y); }\n\n//Provides: caml_int64_or const\nfunction caml_int64_or (x, y) { return x.or(y); }\n\n//Provides: caml_int64_xor const\nfunction caml_int64_xor (x, y) { return x.xor(y) }\n\n//Provides: caml_int64_shift_left const\nfunction caml_int64_shift_left (x, s) { return x.shift_left(s) }\n\n//Provides: caml_int64_shift_right_unsigned const\nfunction caml_int64_shift_right_unsigned (x, s) { return x.shift_right_unsigned(s) }\n\n//Provides: caml_int64_shift_right const\nfunction caml_int64_shift_right (x, s) { return x.shift_right(s) }\n\n//Provides: caml_int64_div const\nfunction caml_int64_div (x, y) { return x.div(y) }\n\n//Provides: caml_int64_mod const\nfunction caml_int64_mod (x, y) { return x.mod(y) }\n\n//Provides: caml_int64_of_int32 const\n//Requires: MlInt64\nfunction caml_int64_of_int32 (x) {\n return new MlInt64(x & 0xffffff, (x >> 24) & 0xffffff, (x >> 31) & 0xffff)\n}\n\n//Provides: caml_int64_to_int32 const\nfunction caml_int64_to_int32 (x) { return x.toInt() }\n\n//Provides: caml_int64_to_float const\nfunction caml_int64_to_float (x) { return x.toFloat () }\n\n//Provides: caml_int64_of_float const\n//Requires: caml_int64_offset, MlInt64\nfunction caml_int64_of_float (x) {\n if (x < 0) x = Math.ceil(x);\n return new MlInt64(\n x & 0xffffff,\n Math.floor(x * caml_int64_offset) & 0xffffff,\n Math.floor(x * caml_int64_offset * caml_int64_offset) & 0xffff);\n}\n\n//Provides: caml_int64_format const\n//Requires: caml_parse_format, caml_finish_formatting\n//Requires: caml_int64_is_negative, caml_int64_neg\n//Requires: caml_int64_of_int32, caml_int64_to_int32\n//Requires: caml_int64_is_zero, caml_str_repeat\nfunction caml_int64_format (fmt, x) {\n var f = caml_parse_format(fmt);\n if (f.signedconv && caml_int64_is_negative(x)) {\n f.sign = -1; x = caml_int64_neg(x);\n }\n var buffer = \"\";\n var wbase = caml_int64_of_int32(f.base);\n var cvtbl = \"0123456789abcdef\";\n do {\n var p = x.udivmod(wbase);\n x = p.quotient;\n buffer = cvtbl.charAt(caml_int64_to_int32(p.modulus)) + buffer;\n } while (! caml_int64_is_zero(x));\n if (f.prec >= 0) {\n f.filler = ' ';\n var n = f.prec - buffer.length;\n if (n > 0) buffer = caml_str_repeat (n, '0') + buffer;\n }\n return caml_finish_formatting(f, buffer);\n}\n\n//Provides: caml_int64_of_string\n//Requires: caml_parse_sign_and_base, caml_failwith, caml_parse_digit\n//Requires: caml_int64_of_int32, caml_int64_ult\n//Requires: caml_int64_add, caml_int64_mul, caml_int64_neg\n//Requires: caml_ml_string_length,caml_string_unsafe_get, MlInt64\nfunction caml_int64_of_string(s) {\n var r = caml_parse_sign_and_base (s);\n var i = r[0], sign = r[1], base = r[2];\n var base64 = caml_int64_of_int32(base);\n var threshold =\n new MlInt64(0xffffff, 0xfffffff, 0xffff).udivmod(base64).quotient;\n var c = caml_string_unsafe_get(s, i);\n var d = caml_parse_digit(c);\n if (d < 0 || d >= base) caml_failwith(\"int_of_string\");\n var res = caml_int64_of_int32(d);\n for (;;) {\n i++;\n c = caml_string_unsafe_get(s, i);\n if (c == 95) continue;\n d = caml_parse_digit(c);\n if (d < 0 || d >= base) break;\n /* Detect overflow in multiplication base * res */\n if (caml_int64_ult(threshold, res)) caml_failwith(\"int_of_string\");\n d = caml_int64_of_int32(d);\n res = caml_int64_add(caml_int64_mul(base64, res), d);\n /* Detect overflow in addition (base * res) + d */\n if (caml_int64_ult(res, d)) caml_failwith(\"int_of_string\");\n }\n if (i != caml_ml_string_length(s)) caml_failwith(\"int_of_string\");\n if (base == 10 && caml_int64_ult(new MlInt64(0, 0, 0x8000), res))\n caml_failwith(\"int_of_string\");\n if (sign < 0) res = caml_int64_neg(res);\n return res;\n}\n\n//Provides: caml_int64_create_lo_mi_hi const\n//Requires: MlInt64\nfunction caml_int64_create_lo_mi_hi(lo, mi, hi){\n return new MlInt64(lo, mi, hi)\n}\n//Provides: caml_int64_create_lo_hi const\n//Requires: MlInt64\nfunction caml_int64_create_lo_hi(lo, hi){\n return new MlInt64 (\n lo & 0xffffff,\n ((lo >>> 24) & 0xff) | ((hi & 0xffff) << 8),\n (hi >>> 16) & 0xffff);\n}\n//Provides: caml_int64_lo32 const\nfunction caml_int64_lo32(v){ return v.lo32() }\n\n//Provides: caml_int64_hi32 const\nfunction caml_int64_hi32(v){ return v.hi32() }\n\n//Provides: caml_int64_of_bytes const\n//Requires: MlInt64\nfunction caml_int64_of_bytes(a) {\n return new MlInt64(a[7] << 0 | (a[6] << 8) | (a[5] << 16),\n a[4] << 0 | (a[3] << 8) | (a[2] << 16),\n a[1] << 0 | (a[0] << 8));\n}\n//Provides: caml_int64_to_bytes const\nfunction caml_int64_to_bytes(x) { return x.toArray() }\n\n//Provides: caml_int64_hash const\nfunction caml_int64_hash(v){\n return (v.lo32()) ^ (v.hi32())\n}\n","// Js_of_ocaml runtime support\n// http://www.ocsigen.org/js_of_ocaml/\n//\n// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU Lesser General Public License as published by\n// the Free Software Foundation, with linking exception;\n// either version 2.1 of the License, or (at your option) any later version.\n//\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n// GNU Lesser General Public License for more details.\n//\n// You should have received a copy of the GNU Lesser General Public License\n// along with this program; if not, write to the Free Software\n// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n\n//Raise exception\n\n//Provides: caml_raise_constant (const)\nfunction caml_raise_constant (tag) { throw tag; }\n\n//Provides: caml_return_exn_constant (const)\nfunction caml_return_exn_constant (tag) { return tag; }\n\n//Provides: caml_raise_with_arg (const, const)\nfunction caml_raise_with_arg (tag, arg) { throw [0, tag, arg]; }\n\n//Provides: caml_raise_with_args (const, const)\nfunction caml_raise_with_args (tag, args) { throw [0, tag].concat(args); }\n\n//Provides: caml_raise_with_string (const, const)\n//Requires: caml_raise_with_arg, caml_string_of_jsbytes\nfunction caml_raise_with_string (tag, msg) {\n caml_raise_with_arg (tag, caml_string_of_jsbytes(msg));\n}\n\n//Provides: caml_failwith (const)\n//Requires: caml_raise_with_string, caml_global_data, caml_string_of_jsbytes\nfunction caml_failwith (msg) {\n if(!caml_global_data.Failure)\n caml_global_data.Failure=[248,caml_string_of_jsbytes(\"Failure\"),-3];\n caml_raise_with_string(caml_global_data.Failure, msg);\n}\n\n\n//Provides: caml_invalid_argument (const)\n//Requires: caml_raise_with_string, caml_global_data\nfunction caml_invalid_argument (msg) {\n caml_raise_with_string(caml_global_data.Invalid_argument, msg);\n}\n\n//Provides: caml_raise_end_of_file\n//Requires: caml_raise_constant, caml_global_data\nfunction caml_raise_end_of_file () {\n caml_raise_constant(caml_global_data.End_of_file);\n}\n\n//Provides: caml_raise_zero_divide\n//Requires: caml_raise_constant, caml_global_data\nfunction caml_raise_zero_divide () {\n caml_raise_constant(caml_global_data.Division_by_zero);\n}\n\n//Provides: caml_raise_not_found\n//Requires: caml_raise_constant, caml_global_data\nfunction caml_raise_not_found () {\n caml_raise_constant(caml_global_data.Not_found); }\n\n\n//Provides: caml_array_bound_error\n//Requires: caml_invalid_argument\nfunction caml_array_bound_error () {\n caml_invalid_argument(\"index out of bounds\");\n}\n","// Js_of_ocaml runtime support\n// http://www.ocsigen.org/js_of_ocaml/\n// Copyright (C) 2010 Jérôme Vouillon\n// Laboratoire PPS - CNRS Université Paris Diderot\n//\n// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU Lesser General Public License as published by\n// the Free Software Foundation, with linking exception;\n// either version 2.1 of the License, or (at your option) any later version.\n//\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n// GNU Lesser General Public License for more details.\n//\n// You should have received a copy of the GNU Lesser General Public License\n// along with this program; if not, write to the Free Software\n// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n\n//Provides: caml_call_gen (const, shallow)\n//Weakdef\nfunction caml_call_gen(f, args) {\n if(f.fun)\n return caml_call_gen(f.fun, args);\n //FIXME, can happen with too many arguments\n if(typeof f !== \"function\") return f;\n var n = f.length | 0;\n if(n === 0) return f.apply(null,args);\n var argsLen = args.length | 0;\n var d = n - argsLen | 0;\n if (d == 0)\n return f.apply(null, args);\n else if (d < 0) {\n return caml_call_gen(f.apply(null,args.slice(0,n)),args.slice(n));\n }\n else {\n return function (){\n var extra_args = (arguments.length == 0)?1:arguments.length;\n var nargs = new Array(args.length+extra_args);\n for(var i = 0; i < args.length; i++ ) nargs[i] = args[i];\n for(var i = 0; i < arguments.length; i++ ) nargs[args.length+i] = arguments[i];\n return caml_call_gen(f, nargs)\n }\n }\n}\n\n//Provides: caml_named_values\nvar caml_named_values = {};\n\n//Provides: caml_register_named_value (const,const)\n//Requires: caml_named_values, caml_jsbytes_of_string\nfunction caml_register_named_value(nm,v) {\n caml_named_values[caml_jsbytes_of_string(nm)] = v;\n return 0;\n}\n\n//Provides: caml_named_value\n//Requires: caml_named_values\nfunction caml_named_value(nm) {\n return caml_named_values[nm]\n}\n\n//Provides: caml_global_data\nvar caml_global_data = [0];\n\n//Provides: caml_register_global (const, shallow, const)\n//Requires: caml_global_data\nfunction caml_register_global (n, v, name_opt) {\n if(name_opt && globalThis.toplevelReloc)\n n = globalThis.toplevelReloc(name_opt);\n caml_global_data[n + 1] = v;\n if(name_opt) caml_global_data[name_opt] = v;\n}\n\n//Provides: caml_get_global_data mutable\n//Requires: caml_global_data\nfunction caml_get_global_data () { return caml_global_data; }\n\n//Provides: caml_is_printable const (const)\nfunction caml_is_printable(c) { return +(c > 31 && c < 127); }\n","// Js_of_ocaml runtime support\n// http://www.ocsigen.org/js_of_ocaml/\n// Copyright (C) 2010-2014 Jérôme Vouillon\n// Laboratoire PPS - CNRS Université Paris Diderot\n//\n// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU Lesser General Public License as published by\n// the Free Software Foundation, with linking exception;\n// either version 2.1 of the License, or (at your option) any later version.\n//\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n// GNU Lesser General Public License for more details.\n//\n// You should have received a copy of the GNU Lesser General Public License\n// along with this program; if not, write to the Free Software\n// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n\n// An OCaml string is an object with three fields:\n// - tag 't'\n// - length 'l'\n// - contents 'c'\n//\n// The contents of the string can be either a JavaScript array or\n// a JavaScript string. The length of this string can be less than the\n// length of the OCaml string. In this case, remaining bytes are\n// assumed to be zeroes. Arrays are mutable but consumes more memory\n// than strings. A common pattern is to start from an empty string and\n// progressively fill it from the start. Partial strings makes it\n// possible to implement this efficiently.\n//\n// When converting to and from UTF-16, we keep track of whether the\n// string is composed only of ASCII characters (in which case, no\n// conversion needs to be performed) or not.\n//\n// The string tag can thus take the following values:\n// full string BYTE | UNKNOWN: 0\n// BYTE | ASCII: 9\n// BYTE | NOT_ASCII: 8\n// string prefix PARTIAL: 2\n// array ARRAY: 4\n//\n// One can use bit masking to discriminate these different cases:\n// known_encoding(x) = x&8\n// is_ascii(x) = x&1\n// kind(x) = x&6\n\n//Provides: caml_str_repeat\nfunction caml_str_repeat(n, s) {\n if(n == 0) return \"\";\n if (s.repeat) {return s.repeat(n);} // ECMAscript 6 and Firefox 24+\n var r = \"\", l = 0;\n for(;;) {\n if (n & 1) r += s;\n n >>= 1;\n if (n == 0) return r;\n s += s;\n l++;\n if (l == 9) {\n s.slice(0,1); // flatten the string\n // then, the flattening of the whole string will be faster,\n // as it will be composed of larger pieces\n }\n }\n}\n\n//Provides: caml_subarray_to_jsbytes\n//Weakdef\n// Pre ECMAScript 5, [apply] would not support array-like object.\n// In such setup, Typed_array would be implemented as polyfill, and [f.apply] would\n// fail here. Mark the primitive as Weakdef, so that people can override it easily.\nfunction caml_subarray_to_jsbytes (a, i, len) {\n var f = String.fromCharCode;\n if (i == 0 && len <= 4096 && len == a.length) return f.apply (null, a);\n var s = \"\";\n for (; 0 < len; i += 1024,len-=1024)\n s += f.apply (null, a.slice(i,i + Math.min(len, 1024)));\n return s;\n}\n\n//Provides: caml_utf8_of_utf16\nfunction caml_utf8_of_utf16(s) {\n for (var b = \"\", t = b, c, d, i = 0, l = s.length; i < l; i++) {\n c = s.charCodeAt(i);\n if (c < 0x80) {\n for (var j = i + 1; (j < l) && (c = s.charCodeAt(j)) < 0x80; j++);\n if (j - i > 512) { t.substr(0, 1); b += t; t = \"\"; b += s.slice(i, j) }\n else t += s.slice(i, j);\n if (j == l) break;\n i = j;\n }\n if (c < 0x800) {\n t += String.fromCharCode(0xc0 | (c >> 6));\n t += String.fromCharCode(0x80 | (c & 0x3f));\n } else if (c < 0xd800 || c >= 0xdfff) {\n t += String.fromCharCode(0xe0 | (c >> 12),\n 0x80 | ((c >> 6) & 0x3f),\n 0x80 | (c & 0x3f));\n } else if (c >= 0xdbff || i + 1 == l ||\n (d = s.charCodeAt(i + 1)) < 0xdc00 || d > 0xdfff) {\n // Unmatched surrogate pair, replaced by \\ufffd (replacement character)\n t += \"\\xef\\xbf\\xbd\";\n } else {\n i++;\n c = (c << 10) + d - 0x35fdc00;\n t += String.fromCharCode(0xf0 | (c >> 18),\n 0x80 | ((c >> 12) & 0x3f),\n 0x80 | ((c >> 6) & 0x3f),\n 0x80 | (c & 0x3f));\n }\n if (t.length > 1024) {t.substr(0, 1); b += t; t = \"\";}\n }\n return b+t;\n}\n\n//Provides: caml_utf16_of_utf8\nfunction caml_utf16_of_utf8(s) {\n for (var b = \"\", t = \"\", c, c1, c2, v, i = 0, l = s.length; i < l; i++) {\n c1 = s.charCodeAt(i);\n if (c1 < 0x80) {\n for (var j = i + 1; (j < l) && (c1 = s.charCodeAt(j)) < 0x80; j++);\n if (j - i > 512) { t.substr(0, 1); b += t; t = \"\"; b += s.slice(i, j) }\n else t += s.slice(i, j);\n if (j == l) break;\n i = j;\n }\n v = 1;\n if ((++i < l) && (((c2 = s.charCodeAt(i)) & -64) == 128)) {\n c = c2 + (c1 << 6);\n if (c1 < 0xe0) {\n v = c - 0x3080;\n if (v < 0x80) v = 1;\n } else {\n v = 2;\n if ((++i < l) && (((c2 = s.charCodeAt(i)) & -64) == 128)) {\n c = c2 + (c << 6);\n if (c1 < 0xf0) {\n v = c - 0xe2080;\n if ((v < 0x800) || ((v >= 0xd7ff) && (v < 0xe000))) v = 2;\n } else {\n v = 3;\n if ((++i < l) && (((c2 = s.charCodeAt(i)) & -64) == 128) &&\n (c1 < 0xf5)) {\n v = c2 - 0x3c82080 + (c << 6);\n if (v < 0x10000 || v > 0x10ffff) v = 3;\n }\n }\n }\n }\n }\n if (v < 4) { // Invalid sequence\n i -= v;\n t += \"\\ufffd\";\n } else if (v > 0xffff)\n t += String.fromCharCode(0xd7c0 + (v >> 10), 0xdc00 + (v & 0x3FF))\n else\n t += String.fromCharCode(v);\n if (t.length > 1024) {t.substr(0, 1); b += t; t = \"\";}\n }\n return b+t;\n}\n\n//Provides: jsoo_is_ascii\nfunction jsoo_is_ascii (s) {\n // The regular expression gets better at around this point for all browsers\n if (s.length < 24) {\n // Spidermonkey gets much slower when s.length >= 24 (on 64 bit archs)\n for (var i = 0; i < s.length; i++) if (s.charCodeAt(i) > 127) return false;\n return true;\n } else\n return !/[^\\x00-\\x7f]/.test(s);\n}\n\n//Provides: caml_bytes_unsafe_get mutable\nfunction caml_bytes_unsafe_get (s, i) {\n switch (s.t & 6) {\n default: /* PARTIAL */\n if (i >= s.c.length) return 0;\n case 0: /* BYTES */\n return s.c.charCodeAt(i);\n case 4: /* ARRAY */\n return s.c[i]\n }\n}\n\n//Provides: caml_bytes_unsafe_set\n//Requires: caml_convert_bytes_to_array\nfunction caml_bytes_unsafe_set (s, i, c) {\n // The OCaml compiler uses Char.unsafe_chr on integers larger than 255!\n c &= 0xff;\n if (s.t != 4 /* ARRAY */) {\n if (i == s.c.length) {\n s.c += String.fromCharCode (c);\n if (i + 1 == s.l) s.t = 0; /*BYTES | UNKOWN*/\n return 0;\n }\n caml_convert_bytes_to_array (s);\n }\n s.c[i] = c;\n return 0;\n}\n\n//Provides: caml_string_bound_error\n//Requires: caml_invalid_argument\nfunction caml_string_bound_error () {\n caml_invalid_argument (\"index out of bounds\");\n}\n\n//Provides: caml_bytes_bound_error\n//Requires: caml_invalid_argument\nfunction caml_bytes_bound_error () {\n caml_invalid_argument (\"index out of bounds\");\n}\n\n//Provides: caml_string_get\n//Requires: caml_string_bound_error, caml_string_unsafe_get\n//Requires: caml_ml_string_length\nfunction caml_string_get (s, i) {\n if (i >>> 0 >= caml_ml_string_length(s)) caml_string_bound_error();\n return caml_string_unsafe_get (s, i);\n}\n\n//Provides: caml_string_get16\n//Requires: caml_string_unsafe_get, caml_string_bound_error\n//Requires: caml_ml_string_length\nfunction caml_string_get16(s,i) {\n if (i >>> 0 >= caml_ml_string_length(s) - 1) caml_string_bound_error();\n var b1 = caml_string_unsafe_get (s, i),\n b2 = caml_string_unsafe_get (s, i + 1);\n return (b2 << 8 | b1);\n}\n\n//Provides: caml_bytes_get16\n//Requires: caml_bytes_unsafe_get, caml_bytes_bound_error\nfunction caml_bytes_get16(s,i) {\n if (i >>> 0 >= s.l - 1) caml_bytes_bound_error();\n var b1 = caml_bytes_unsafe_get (s, i),\n b2 = caml_bytes_unsafe_get (s, i + 1);\n return (b2 << 8 | b1);\n}\n\n//Provides: caml_string_get32\n//Requires: caml_string_unsafe_get, caml_string_bound_error\n//Requires: caml_ml_string_length\nfunction caml_string_get32(s,i) {\n if (i >>> 0 >= caml_ml_string_length(s) - 3) caml_string_bound_error();\n var b1 = caml_string_unsafe_get (s, i),\n b2 = caml_string_unsafe_get (s, i + 1),\n b3 = caml_string_unsafe_get (s, i + 2),\n b4 = caml_string_unsafe_get (s, i + 3);\n return (b4 << 24 | b3 << 16 | b2 << 8 | b1);\n}\n\n//Provides: caml_bytes_get32\n//Requires: caml_bytes_unsafe_get, caml_bytes_bound_error\nfunction caml_bytes_get32(s,i) {\n if (i >>> 0 >= s.l - 3) caml_bytes_bound_error();\n var b1 = caml_bytes_unsafe_get (s, i),\n b2 = caml_bytes_unsafe_get (s, i + 1),\n b3 = caml_bytes_unsafe_get (s, i + 2),\n b4 = caml_bytes_unsafe_get (s, i + 3);\n return (b4 << 24 | b3 << 16 | b2 << 8 | b1);\n}\n\n//Provides: caml_string_get64\n//Requires: caml_string_unsafe_get, caml_string_bound_error\n//Requires: caml_int64_of_bytes\n//Requires: caml_ml_string_length\nfunction caml_string_get64(s,i) {\n if (i >>> 0 >= caml_ml_string_length(s) - 7) caml_string_bound_error();\n var a = new Array(8);\n for(var j = 0; j < 8; j++){\n a[7 - j] = caml_string_unsafe_get (s, i + j);\n }\n return caml_int64_of_bytes(a);\n}\n\n//Provides: caml_bytes_get64\n//Requires: caml_bytes_unsafe_get, caml_bytes_bound_error\n//Requires: caml_int64_of_bytes\nfunction caml_bytes_get64(s,i) {\n if (i >>> 0 >= s.l - 7) caml_bytes_bound_error();\n var a = new Array(8);\n for(var j = 0; j < 8; j++){\n a[7 - j] = caml_bytes_unsafe_get (s, i + j);\n }\n return caml_int64_of_bytes(a);\n}\n\n//Provides: caml_bytes_get\n//Requires: caml_bytes_bound_error, caml_bytes_unsafe_get\nfunction caml_bytes_get (s, i) {\n if (i >>> 0 >= s.l) caml_bytes_bound_error();\n return caml_bytes_unsafe_get (s, i);\n}\n\n//Provides: caml_string_set\n//Requires: caml_failwith\n//If: js-string\nfunction caml_string_set (s, i, c) {\n caml_failwith(\"caml_string_set\");\n}\n\n//Provides: caml_string_set\n//Requires: caml_string_unsafe_set, caml_string_bound_error\n//If: !js-string\nfunction caml_string_set (s, i, c) {\n if (i >>> 0 >= s.l) caml_string_bound_error();\n return caml_string_unsafe_set (s, i, c);\n}\n\n//Provides: caml_bytes_set16\n//Requires: caml_bytes_bound_error, caml_bytes_unsafe_set\nfunction caml_bytes_set16(s,i,i16){\n if (i >>> 0 >= s.l - 1) caml_bytes_bound_error();\n var b2 = 0xFF & i16 >> 8,\n b1 = 0xFF & i16;\n caml_bytes_unsafe_set (s, i + 0, b1);\n caml_bytes_unsafe_set (s, i + 1, b2);\n return 0\n}\n\n//Provides: caml_string_set16\n//Requires: caml_failwith\n//If: js-string\nfunction caml_string_set16(s,i,i16){\n caml_failwith(\"caml_string_set16\");\n}\n\n//Provides: caml_string_set16\n//Requires: caml_bytes_set16\n//If: !js-string\nfunction caml_string_set16(s,i,i16){\n return caml_bytes_set16(s,i,i16);\n}\n\n//Provides: caml_bytes_set32\n//Requires: caml_bytes_bound_error, caml_bytes_unsafe_set\nfunction caml_bytes_set32(s,i,i32){\n if (i >>> 0 >= s.l - 3) caml_bytes_bound_error();\n var b4 = 0xFF & i32 >> 24,\n b3 = 0xFF & i32 >> 16,\n b2 = 0xFF & i32 >> 8,\n b1 = 0xFF & i32;\n caml_bytes_unsafe_set (s, i + 0, b1);\n caml_bytes_unsafe_set (s, i + 1, b2);\n caml_bytes_unsafe_set (s, i + 2, b3);\n caml_bytes_unsafe_set (s, i + 3, b4);\n return 0\n}\n\n//Provides: caml_string_set32\n//Requires: caml_failwith\n//If: js-string\nfunction caml_string_set32(s,i,i32){\n caml_failwith(\"caml_string_set32\");\n}\n\n//Provides: caml_string_set32\n//Requires: caml_bytes_set32\n//If: !js-string\nfunction caml_string_set32(s,i,i32){\n return caml_bytes_set32(s,i,i32);\n}\n\n//Provides: caml_bytes_set64\n//Requires: caml_bytes_bound_error, caml_bytes_unsafe_set\n//Requires: caml_int64_to_bytes\nfunction caml_bytes_set64(s,i,i64){\n if (i >>> 0 >= s.l - 7) caml_bytes_bound_error();\n var a = caml_int64_to_bytes(i64);\n for(var j = 0; j < 8; j++) {\n caml_bytes_unsafe_set (s, i + 7 - j, a[j]);\n }\n return 0\n}\n\n//Provides: caml_string_set64\n//Requires: caml_failwith\n//If: js-string\nfunction caml_string_set64(s,i,i64){\n caml_failwith(\"caml_string_set64\");\n}\n\n//Provides: caml_string_set64\n//Requires: caml_bytes_set64\n//If: !js-string\nfunction caml_string_set64(s,i,i64){\n return caml_bytes_set64(s,i,i64);\n}\n\n//Provides: caml_bytes_set\n//Requires: caml_bytes_bound_error, caml_bytes_unsafe_set\nfunction caml_bytes_set (s, i, c) {\n if (i >>> 0 >= s.l) caml_bytes_bound_error();\n return caml_bytes_unsafe_set (s, i, c);\n}\n\n//Provides: caml_bytes_of_utf16_jsstring\n//Requires: jsoo_is_ascii, caml_utf8_of_utf16, MlBytes\nfunction caml_bytes_of_utf16_jsstring (s) {\n var tag = 9 /* BYTES | ASCII */;\n if (!jsoo_is_ascii(s))\n tag = 8 /* BYTES | NOT_ASCII */, s = caml_utf8_of_utf16(s);\n return new MlBytes(tag, s, s.length);\n}\n\n\n//Provides: MlBytes\n//Requires: caml_convert_string_to_bytes, jsoo_is_ascii, caml_utf16_of_utf8\nfunction MlBytes (tag, contents, length) {\n this.t=tag; this.c=contents; this.l=length;\n}\nMlBytes.prototype.toString = function(){\n switch (this.t) {\n case 9: /*BYTES | ASCII*/\n return this.c;\n default:\n caml_convert_string_to_bytes(this);\n case 0: /*BYTES | UNKOWN*/\n if (jsoo_is_ascii(this.c)) {\n this.t = 9; /*BYTES | ASCII*/\n return this.c;\n }\n this.t = 8; /*BYTES | NOT_ASCII*/\n case 8: /*BYTES | NOT_ASCII*/\n return this.c;\n }\n};\nMlBytes.prototype.toUtf16 = function (){\n var r = this.toString();\n if(this.t == 9) return r\n return caml_utf16_of_utf8(r);\n}\nMlBytes.prototype.slice = function (){\n var content = this.t == 4 ? this.c.slice() : this.c;\n return new MlBytes(this.t,content,this.l);\n}\n\n//Provides: caml_convert_string_to_bytes\n//Requires: caml_str_repeat, caml_subarray_to_jsbytes\nfunction caml_convert_string_to_bytes (s) {\n /* Assumes not BYTES */\n if (s.t == 2 /* PARTIAL */)\n s.c += caml_str_repeat(s.l - s.c.length, '\\0')\n else\n s.c = caml_subarray_to_jsbytes (s.c, 0, s.c.length);\n s.t = 0; /*BYTES | UNKOWN*/\n}\n\n//Provides: caml_convert_bytes_to_array\nfunction caml_convert_bytes_to_array (s) {\n /* Assumes not ARRAY */\n if(globalThis.Uint8Array) {\n var a = new globalThis.Uint8Array(s.l);\n } else {\n var a = new Array(s.l);\n }\n var b = s.c, l = b.length, i = 0;\n for (; i < l; i++) a[i] = b.charCodeAt(i);\n for (l = s.l; i < l; i++) a[i] = 0;\n s.c = a;\n s.t = 4; /* ARRAY */\n return a;\n}\n\n//Provides: caml_array_of_bytes mutable\n//Requires: caml_convert_bytes_to_array\nfunction caml_array_of_bytes (s) {\n if (s.t != 4 /* ARRAY */) caml_convert_bytes_to_array(s);\n return s.c;\n}\n\n//Provides: caml_array_of_string mutable\n//Requires: caml_convert_bytes_to_array\n//Requires: caml_ml_string_length, caml_string_unsafe_get\nfunction caml_array_of_string (s) {\n var l = caml_ml_string_length(s);\n var a = new Array(l);\n var i = 0;\n for (; i < l; i++) a[i] = caml_string_unsafe_get(s,i);\n return a;\n}\n\n//Provides: caml_create_string const\n//Requires: MlBytes, caml_invalid_argument\n//If: !js-string\nfunction caml_create_string(len) {\n if(len < 0) caml_invalid_argument(\"String.create\");\n return new MlBytes(len?2:9,\"\",len);\n}\n\n//Provides: caml_create_string const\n//Requires: caml_invalid_argument\n//If: js-string\nfunction caml_create_string(len) {\n caml_invalid_argument(\"String.create\");\n}\n\n//Provides: caml_create_bytes const\n//Requires: MlBytes,caml_invalid_argument\nfunction caml_create_bytes(len) {\n if (len < 0) caml_invalid_argument(\"Bytes.create\");\n return new MlBytes(len?2:9,\"\",len);\n}\n\n//Provides: caml_string_of_array\n//Requires: caml_subarray_to_jsbytes, caml_string_of_jsbytes\nfunction caml_string_of_array (a) {\n return caml_string_of_jsbytes(caml_subarray_to_jsbytes(a,0,a.length));\n}\n\n//Provides: caml_bytes_of_array\n//Requires: MlBytes\nfunction caml_bytes_of_array (a) {\n return new MlBytes(4,a,a.length);\n}\n\n//Provides: caml_bytes_compare mutable\n//Requires: caml_convert_string_to_bytes\nfunction caml_bytes_compare(s1, s2) {\n (s1.t & 6) && caml_convert_string_to_bytes(s1);\n (s2.t & 6) && caml_convert_string_to_bytes(s2);\n return (s1.c < s2.c)?-1:(s1.c > s2.c)?1:0;\n}\n\n\n//Provides: caml_bytes_equal mutable (const, const)\n//Requires: caml_convert_string_to_bytes\nfunction caml_bytes_equal(s1, s2) {\n if(s1 === s2) return 1;\n (s1.t & 6) && caml_convert_string_to_bytes(s1);\n (s2.t & 6) && caml_convert_string_to_bytes(s2);\n return (s1.c == s2.c)?1:0;\n}\n\n//Provides: caml_string_notequal mutable (const, const)\n//Requires: caml_string_equal\nfunction caml_string_notequal(s1, s2) { return 1-caml_string_equal(s1, s2); }\n\n//Provides: caml_bytes_notequal mutable (const, const)\n//Requires: caml_bytes_equal\nfunction caml_bytes_notequal(s1, s2) { return 1-caml_bytes_equal(s1, s2); }\n\n//Provides: caml_bytes_lessequal mutable\n//Requires: caml_convert_string_to_bytes\nfunction caml_bytes_lessequal(s1, s2) {\n (s1.t & 6) && caml_convert_string_to_bytes(s1);\n (s2.t & 6) && caml_convert_string_to_bytes(s2);\n return (s1.c <= s2.c)?1:0;\n}\n\n//Provides: caml_bytes_lessthan mutable\n//Requires: caml_convert_string_to_bytes\nfunction caml_bytes_lessthan(s1, s2) {\n (s1.t & 6) && caml_convert_string_to_bytes(s1);\n (s2.t & 6) && caml_convert_string_to_bytes(s2);\n return (s1.c < s2.c)?1:0;\n}\n\n//Provides: caml_string_greaterequal\n//Requires: caml_string_lessequal\nfunction caml_string_greaterequal(s1, s2) {\n return caml_string_lessequal(s2,s1);\n}\n//Provides: caml_bytes_greaterequal\n//Requires: caml_bytes_lessequal\nfunction caml_bytes_greaterequal(s1, s2) {\n return caml_bytes_lessequal(s2,s1);\n}\n\n//Provides: caml_string_greaterthan\n//Requires: caml_string_lessthan\nfunction caml_string_greaterthan(s1, s2) {\n return caml_string_lessthan(s2, s1);\n}\n\n//Provides: caml_bytes_greaterthan\n//Requires: caml_bytes_lessthan\nfunction caml_bytes_greaterthan(s1, s2) {\n return caml_bytes_lessthan(s2, s1);\n}\n\n//Provides: caml_fill_bytes\n//Requires: caml_str_repeat, caml_convert_bytes_to_array\nfunction caml_fill_bytes(s, i, l, c) {\n if (l > 0) {\n if (i == 0 && (l >= s.l || (s.t == 2 /* PARTIAL */ && l >= s.c.length))) {\n if (c == 0) {\n s.c = \"\";\n s.t = 2; /* PARTIAL */\n } else {\n s.c = caml_str_repeat (l, String.fromCharCode(c));\n s.t = (l == s.l)?0 /* BYTES | UNKOWN */ :2; /* PARTIAL */\n }\n } else {\n if (s.t != 4 /* ARRAY */) caml_convert_bytes_to_array(s);\n for (l += i; i < l; i++) s.c[i] = c;\n }\n }\n return 0;\n}\n\n//Provides: caml_fill_string\n//Requires: caml_fill_bytes\nvar caml_fill_string = caml_fill_bytes\n\n//Provides: caml_blit_bytes\n//Requires: caml_subarray_to_jsbytes, caml_convert_bytes_to_array\nfunction caml_blit_bytes(s1, i1, s2, i2, len) {\n if (len == 0) return 0;\n if ((i2 == 0) &&\n (len >= s2.l || (s2.t == 2 /* PARTIAL */ && len >= s2.c.length))) {\n s2.c = (s1.t == 4 /* ARRAY */)?\n caml_subarray_to_jsbytes(s1.c, i1, len):\n (i1 == 0 && s1.c.length == len)?s1.c:s1.c.substr(i1, len);\n s2.t = (s2.c.length == s2.l)?0 /* BYTES | UNKOWN */ :2; /* PARTIAL */\n } else if (s2.t == 2 /* PARTIAL */ && i2 == s2.c.length) {\n s2.c += (s1.t == 4 /* ARRAY */)?\n caml_subarray_to_jsbytes(s1.c, i1, len):\n (i1 == 0 && s1.c.length == len)?s1.c:s1.c.substr(i1, len);\n s2.t = (s2.c.length == s2.l)?0 /* BYTES | UNKOWN */ :2; /* PARTIAL */\n } else {\n if (s2.t != 4 /* ARRAY */) caml_convert_bytes_to_array(s2);\n var c1 = s1.c, c2 = s2.c;\n if (s1.t == 4 /* ARRAY */) {\n if (i2 <= i1) {\n for (var i = 0; i < len; i++) c2 [i2 + i] = c1 [i1 + i];\n } else {\n for (var i = len - 1; i >= 0; i--) c2 [i2 + i] = c1 [i1 + i];\n }\n } else {\n var l = Math.min (len, c1.length - i1);\n for (var i = 0; i < l; i++) c2 [i2 + i] = c1.charCodeAt(i1 + i);\n for (; i < len; i++) c2 [i2 + i] = 0;\n }\n }\n return 0;\n}\n\n//Provides: caml_blit_string\n//Requires: caml_blit_bytes, caml_bytes_of_string\nfunction caml_blit_string(a,b,c,d,e) {\n caml_blit_bytes(caml_bytes_of_string(a),b,c,d,e);\n return 0\n}\n\n//Provides: caml_ml_bytes_length const\nfunction caml_ml_bytes_length(s) { return s.l }\n\n//Provides: caml_string_unsafe_get const\n//If: js-string\nfunction caml_string_unsafe_get (s, i) {\n return s.charCodeAt(i);\n}\n\n//Provides: caml_string_unsafe_set\n//Requires: caml_failwith\n//If: js-string\nfunction caml_string_unsafe_set (s, i, c) {\n caml_failwith(\"caml_string_unsafe_set\");\n}\n\n//Provides: caml_ml_string_length const\n//If: js-string\nfunction caml_ml_string_length(s) {\n return s.length\n}\n\n//Provides: caml_string_compare const\n//If: js-string\nfunction caml_string_compare(s1, s2) {\n return (s1 < s2)?-1:(s1 > s2)?1:0;\n}\n\n//Provides: caml_string_equal const\n//If: js-string\nfunction caml_string_equal(s1, s2) {\n if(s1 === s2) return 1;\n return 0;\n}\n\n//Provides: caml_string_lessequal const\n//If: js-string\nfunction caml_string_lessequal(s1, s2) {\n return (s1 <= s2)?1:0;\n}\n\n//Provides: caml_string_lessthan const\n//If: js-string\nfunction caml_string_lessthan(s1, s2) {\n return (s1 < s2)?1:0;\n}\n\n//Provides: caml_string_of_bytes\n//Requires: caml_convert_string_to_bytes, caml_string_of_jsbytes\n//If: js-string\nfunction caml_string_of_bytes(s) {\n (s.t & 6) && caml_convert_string_to_bytes(s);\n return caml_string_of_jsbytes(s.c);\n}\n\n//Provides: caml_bytes_of_string const\n//Requires: caml_bytes_of_jsbytes, caml_jsbytes_of_string\n//If: js-string\nfunction caml_bytes_of_string(s) {\n return caml_bytes_of_jsbytes(caml_jsbytes_of_string(s));\n}\n\n//Provides: caml_string_of_jsbytes const\n//If: js-string\nfunction caml_string_of_jsbytes(x) { return x }\n\n//Provides: caml_jsbytes_of_string const\n//If: js-string\nfunction caml_jsbytes_of_string(x) { return x }\n\n//Provides: caml_jsstring_of_string const\n//Requires: jsoo_is_ascii, caml_utf16_of_utf8\n//If: js-string\nfunction caml_jsstring_of_string(s) {\n if(jsoo_is_ascii(s))\n return s;\n return caml_utf16_of_utf8(s); }\n\n//Provides: caml_string_of_jsstring const\n//Requires: jsoo_is_ascii, caml_utf8_of_utf16, caml_string_of_jsbytes\n//If: js-string\nfunction caml_string_of_jsstring (s) {\n if (jsoo_is_ascii(s))\n return caml_string_of_jsbytes(s)\n else return caml_string_of_jsbytes(caml_utf8_of_utf16(s));\n}\n\n//Provides: caml_bytes_of_jsbytes const\n//Requires: MlBytes\nfunction caml_bytes_of_jsbytes(s) { return new MlBytes(0,s,s.length); }\n\n\n// The section below should be used when use-js-string=false\n\n//Provides: caml_string_unsafe_get const\n//Requires: caml_bytes_unsafe_get\n//If: !js-string\nfunction caml_string_unsafe_get (s, i) {\n return caml_bytes_unsafe_get(s,i);\n}\n\n//Provides: caml_string_unsafe_set\n//Requires: caml_bytes_unsafe_set\n//If: !js-string\nfunction caml_string_unsafe_set (s, i, c) {\n return caml_bytes_unsafe_set(s,i,c);\n}\n\n//Provides: caml_ml_string_length const\n//Requires: caml_ml_bytes_length\n//If: !js-string\nfunction caml_ml_string_length(s) {\n return caml_ml_bytes_length(s)\n}\n\n//Provides: caml_string_compare\n//Requires: caml_bytes_compare\n//If: !js-string\nfunction caml_string_compare(s1, s2) {\n return caml_bytes_compare(s1,s2)\n}\n\n//Provides: caml_string_equal\n//Requires: caml_bytes_equal\n//If: !js-string\nfunction caml_string_equal(s1, s2) {\n return caml_bytes_equal(s1,s2)\n}\n\n//Provides: caml_string_lessequal\n//Requires: caml_bytes_lessequal\n//If: !js-string\nfunction caml_string_lessequal(s1, s2) {\n return caml_bytes_lessequal(s1,s2)\n}\n\n//Provides: caml_string_lessthan\n//Requires: caml_bytes_lessthan\n//If: !js-string\nfunction caml_string_lessthan(s1, s2) {\n return caml_bytes_lessthan(s1,s2)\n}\n\n//Provides: caml_string_of_bytes\n//If: !js-string\nfunction caml_string_of_bytes(s) { return s }\n\n//Provides: caml_bytes_of_string const\n//If: !js-string\nfunction caml_bytes_of_string(s) { return s }\n\n//Provides: caml_string_of_jsbytes const\n//Requires: caml_bytes_of_jsbytes\n//If: !js-string\nfunction caml_string_of_jsbytes(s) { return caml_bytes_of_jsbytes(s); }\n\n//Provides: caml_jsbytes_of_string const\n//Requires: caml_convert_string_to_bytes\n//If: !js-string\nfunction caml_jsbytes_of_string(s) {\n (s.t & 6) && caml_convert_string_to_bytes(s);\n return s.c }\n\n//Provides: caml_jsstring_of_string mutable (const)\n//If: !js-string\nfunction caml_jsstring_of_string(s){\n return s.toUtf16()\n}\n\n//Provides: caml_string_of_jsstring\n//Requires: caml_bytes_of_utf16_jsstring\n//If: !js-string\nfunction caml_string_of_jsstring (s) {\n return caml_bytes_of_utf16_jsstring(s);\n}\n\n//Provides: caml_is_ml_bytes\n//Requires: MlBytes\nfunction caml_is_ml_bytes(s) {\n return (s instanceof MlBytes);\n}\n\n//Provides: caml_ml_bytes_content\n//Requires: MlBytes, caml_convert_string_to_bytes\nfunction caml_ml_bytes_content(s) {\n switch (s.t & 6) {\n default: /* PARTIAL */\n caml_convert_string_to_bytes(s);\n case 0: /* BYTES */\n return s.c;\n case 4:\n return s.c\n }\n}\n\n//Provides: caml_is_ml_string\n//Requires: jsoo_is_ascii\n//If: js-string\nfunction caml_is_ml_string(s) {\n return (typeof s === \"string\" && !/[^\\x00-\\xff]/.test(s));\n}\n\n//Provides: caml_is_ml_string\n//Requires: caml_is_ml_bytes\n//If: !js-string\nfunction caml_is_ml_string(s) {\n return caml_is_ml_bytes(s);\n}\n\n// The functions below are deprecated\n\n//Provides: caml_js_to_byte_string const\n//Requires: caml_string_of_jsbytes\nfunction caml_js_to_byte_string(s) { return caml_string_of_jsbytes(s) }\n\n//Provides: caml_new_string\n//Requires: caml_string_of_jsbytes\nfunction caml_new_string (s) { return caml_string_of_jsbytes(s) }\n\n//Provides: caml_js_from_string mutable (const)\n//Requires: caml_jsstring_of_string\nfunction caml_js_from_string(s) {\n return caml_jsstring_of_string(s)\n}\n\n//Provides: caml_to_js_string mutable (const)\n//Requires: caml_jsstring_of_string\nfunction caml_to_js_string(s) {\n return caml_jsstring_of_string(s)\n}\n\n//Provides: caml_js_to_string const\n//Requires: caml_string_of_jsstring\nfunction caml_js_to_string (s) {\n return caml_string_of_jsstring(s);\n}\n","// Js_of_ocaml runtime support\n// http://www.ocsigen.org/js_of_ocaml/\n// Copyright (C) 2014 Jérôme Vouillon, Hugo Heuzard, Andy Ray\n// Laboratoire PPS - CNRS Université Paris Diderot\n//\n// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU Lesser General Public License as published by\n// the Free Software Foundation, with linking exception;\n// either version 2.1 of the License, or (at your option) any later version.\n//\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n// GNU Lesser General Public License for more details.\n//\n// You should have received a copy of the GNU Lesser General Public License\n// along with this program; if not, write to the Free Software\n// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n//\n// Bigarray.\n//\n// - all bigarray types including Int64 and Complex.\n// - fortran + c layouts\n// - sub/slice/reshape\n// - retain fast path for 1d array access\n\n//Provides: caml_ba_init const\nfunction caml_ba_init() {\n return 0;\n}\n\n//Provides: caml_ba_get_size\n//Requires: caml_invalid_argument\nfunction caml_ba_get_size(dims) {\n var n_dims = dims.length;\n var size = 1;\n for (var i = 0; i < n_dims; i++) {\n if (dims[i] < 0)\n caml_invalid_argument(\"Bigarray.create: negative dimension\");\n size = size * dims[i];\n }\n return size;\n}\n\n//Provides: caml_ba_get_size_per_element\nfunction caml_ba_get_size_per_element(kind){\n switch(kind){\n case 7: case 10: case 11: return 2;\n default: return 1;\n }\n}\n\n//Provides: caml_ba_create_buffer\n//Requires: caml_ba_get_size_per_element\n//Requires: caml_invalid_argument\nfunction caml_ba_create_buffer(kind, size){\n var g = globalThis;\n var view;\n switch(kind){\n case 0: view = g.Float32Array; break;\n case 1: view = g.Float64Array; break;\n case 2: view = g.Int8Array; break;\n case 3: view = g.Uint8Array; break;\n case 4: view = g.Int16Array; break;\n case 5: view = g.Uint16Array; break;\n case 6: view = g.Int32Array; break;\n case 7: view = g.Int32Array; break;\n case 8: view = g.Int32Array; break;\n case 9: view = g.Int32Array; break;\n case 10: view = g.Float32Array; break;\n case 11: view = g.Float64Array; break;\n case 12: view = g.Uint8Array; break;\n }\n if (!view) caml_invalid_argument(\"Bigarray.create: unsupported kind\");\n var data = new view(size * caml_ba_get_size_per_element(kind));\n return data;\n}\n\n//Provides: caml_ba_custom_name\n//Version: < 4.11\nvar caml_ba_custom_name = \"_bigarray\"\n\n//Provides: caml_ba_custom_name\n//Version: >= 4.11\nvar caml_ba_custom_name = \"_bigarr02\"\n\n//Provides: Ml_Bigarray\n//Requires: caml_array_bound_error, caml_invalid_argument, caml_ba_custom_name\n//Requires: caml_int64_create_lo_hi, caml_int64_hi32, caml_int64_lo32\nfunction Ml_Bigarray (kind, layout, dims, buffer) {\n\n this.kind = kind ;\n this.layout = layout;\n this.dims = dims;\n this.data = buffer;\n}\n\nMl_Bigarray.prototype.caml_custom = caml_ba_custom_name;\n\nMl_Bigarray.prototype.offset = function (arg) {\n var ofs = 0;\n if(typeof arg === \"number\") arg = [arg];\n if (! (arg instanceof Array)) caml_invalid_argument(\"bigarray.js: invalid offset\");\n if (this.dims.length != arg.length)\n caml_invalid_argument(\"Bigarray.get/set: bad number of dimensions\");\n if(this.layout == 0 /* c_layout */) {\n for (var i = 0; i < this.dims.length; i++) {\n if (arg[i] < 0 || arg[i] >= this.dims[i])\n caml_array_bound_error();\n ofs = (ofs * this.dims[i]) + arg[i];\n }\n } else {\n for (var i = this.dims.length - 1; i >= 0; i--) {\n if (arg[i] < 1 || arg[i] > this.dims[i]){\n caml_array_bound_error();\n }\n ofs = (ofs * this.dims[i]) + (arg[i] - 1);\n }\n }\n return ofs;\n}\n\nMl_Bigarray.prototype.get = function (ofs) {\n switch(this.kind){\n case 7:\n // Int64\n var l = this.data[ofs * 2 + 0];\n var h = this.data[ofs * 2 + 1];\n return caml_int64_create_lo_hi(l,h);\n case 10: case 11:\n // Complex32, Complex64\n var r = this.data[ofs * 2 + 0];\n var i = this.data[ofs * 2 + 1];\n return [254, r, i];\n default:\n return this.data[ofs]\n }\n}\n\nMl_Bigarray.prototype.set = function (ofs,v) {\n switch(this.kind){\n case 7:\n // Int64\n this.data[ofs * 2 + 0] = caml_int64_lo32(v);\n this.data[ofs * 2 + 1] = caml_int64_hi32(v);\n break;\n case 10: case 11:\n // Complex32, Complex64\n this.data[ofs * 2 + 0] = v[1];\n this.data[ofs * 2 + 1] = v[2];\n break;\n default:\n this.data[ofs] = v;\n break;\n }\n return 0\n}\n\n\nMl_Bigarray.prototype.fill = function (v) {\n switch(this.kind){\n case 7:\n // Int64\n var a = caml_int64_lo32(v);\n var b = caml_int64_hi32(v);\n if(a == b){\n this.data.fill(a);\n }\n else {\n for(var i = 0; i y)\n return 1;\n if (x != y) {\n if (!total) return NaN;\n if (x == x) return 1;\n if (y == y) return -1;\n }\n }\n break;\n case 7:\n // Int64\n for (var i = 0; i < this.data.length; i+=2) {\n // Check highest bits first\n if (this.data[i+1] < b.data[i+1])\n return -1;\n if (this.data[i+1] > b.data[i+1])\n return 1;\n if ((this.data[i] >>> 0) < (b.data[i] >>> 0))\n return -1;\n if ((this.data[i] >>> 0) > (b.data[i] >>> 0))\n return 1;\n }\n break;\n case 2:\n case 3:\n case 4:\n case 5:\n case 6:\n case 8:\n case 9:\n case 12:\n for (var i = 0; i < this.data.length; i++) {\n if (this.data[i] < b.data[i])\n return -1;\n if (this.data[i] > b.data[i])\n return 1;\n }\n break;\n }\n return 0;\n}\n\n//Provides: Ml_Bigarray_c_1_1\n//Requires: Ml_Bigarray, caml_array_bound_error, caml_invalid_argument\nfunction Ml_Bigarray_c_1_1(kind, layout, dims, buffer) {\n this.kind = kind ;\n this.layout = layout;\n this.dims = dims;\n this.data = buffer;\n}\n\nMl_Bigarray_c_1_1.prototype = new Ml_Bigarray()\nMl_Bigarray_c_1_1.prototype.offset = function (arg) {\n if(typeof arg !== \"number\"){\n if((arg instanceof Array) && arg.length == 1)\n arg = arg[0];\n else caml_invalid_argument(\"Ml_Bigarray_c_1_1.offset\");\n }\n if (arg < 0 || arg >= this.dims[0])\n caml_array_bound_error();\n return arg;\n}\n\nMl_Bigarray_c_1_1.prototype.get = function (ofs) {\n return this.data[ofs];\n}\n\nMl_Bigarray_c_1_1.prototype.set = function (ofs,v) {\n this.data[ofs] = v;\n return 0\n}\n\nMl_Bigarray_c_1_1.prototype.fill = function (v) {\n this.data.fill(v);\n return 0\n}\n\n//Provides: caml_ba_compare\nfunction caml_ba_compare(a,b,total){\n return a.compare(b,total)\n}\n\n//Provides: caml_ba_create_unsafe\n//Requires: Ml_Bigarray, Ml_Bigarray_c_1_1, caml_ba_get_size, caml_ba_get_size_per_element\n//Requires: caml_invalid_argument\nfunction caml_ba_create_unsafe(kind, layout, dims, data){\n var size_per_element = caml_ba_get_size_per_element(kind);\n if(caml_ba_get_size(dims) * size_per_element != data.length) {\n caml_invalid_argument(\"length doesn't match dims\");\n }\n if(layout == 0 && // c_layout\n dims.length == 1 && // Array1\n size_per_element == 1) // 1-to-1 mapping\n return new Ml_Bigarray_c_1_1(kind, layout, dims, data);\n return new Ml_Bigarray(kind, layout, dims, data);\n\n}\n\n\n//Provides: caml_ba_create\n//Requires: caml_js_from_array\n//Requires: caml_ba_get_size, caml_ba_create_unsafe\n//Requires: caml_ba_create_buffer\nfunction caml_ba_create(kind, layout, dims_ml) {\n var dims = caml_js_from_array(dims_ml);\n var data = caml_ba_create_buffer(kind, caml_ba_get_size(dims));\n return caml_ba_create_unsafe(kind, layout, dims, data);\n}\n\n//Provides: caml_ba_change_layout\n//Requires: caml_ba_create_unsafe\nfunction caml_ba_change_layout(ba, layout) {\n if(ba.layout == layout) return ba;\n var new_dims = []\n for(var i = 0; i < ba.dims.length; i++) new_dims[i] = ba.dims[ba.dims.length - i - 1];\n return caml_ba_create_unsafe(ba.kind, layout, new_dims, ba.data);\n}\n\n//Provides: caml_ba_kind\nfunction caml_ba_kind(ba) {\n return ba.kind;\n}\n\n//Provides: caml_ba_layout\nfunction caml_ba_layout(ba) {\n return ba.layout;\n}\n\n//Provides: caml_ba_num_dims\nfunction caml_ba_num_dims(ba) {\n return ba.dims.length;\n}\n\n//Provides: caml_ba_dim\n//Requires: caml_invalid_argument\nfunction caml_ba_dim(ba, i) {\n if (i < 0 || i >= ba.dims.length)\n caml_invalid_argument(\"Bigarray.dim\");\n return ba.dims[i];\n}\n\n//Provides: caml_ba_dim_1\n//Requires: caml_ba_dim\nfunction caml_ba_dim_1(ba) {\n return caml_ba_dim(ba, 0);\n}\n\n//Provides: caml_ba_dim_2\n//Requires: caml_ba_dim\nfunction caml_ba_dim_2(ba) {\n return caml_ba_dim(ba, 1);\n}\n\n//Provides: caml_ba_dim_3\n//Requires: caml_ba_dim\nfunction caml_ba_dim_3(ba) {\n return caml_ba_dim(ba, 2);\n}\n\n//Provides: caml_ba_get_generic\n//Requires: caml_js_from_array\nfunction caml_ba_get_generic(ba, i) {\n var ofs = ba.offset(caml_js_from_array(i));\n return ba.get(ofs);\n}\n\n//Provides: caml_ba_uint8_get16\n//Requires: caml_array_bound_error\nfunction caml_ba_uint8_get16(ba, i0) {\n var ofs = ba.offset(i0);\n if(ofs + 1 >= ba.data.length) caml_array_bound_error();\n var b1 = ba.get(ofs);\n var b2 = ba.get(ofs + 1);\n return (b1 | (b2 << 8));\n}\n\n//Provides: caml_ba_uint8_get32\n//Requires: caml_array_bound_error\nfunction caml_ba_uint8_get32(ba, i0) {\n var ofs = ba.offset(i0);\n if(ofs + 3 >= ba.data.length) caml_array_bound_error();\n var b1 = ba.get(ofs+0);\n var b2 = ba.get(ofs+1);\n var b3 = ba.get(ofs+2);\n var b4 = ba.get(ofs+3);\n return ( (b1 << 0) |\n (b2 << 8) |\n (b3 << 16) |\n (b4 << 24) );\n}\n\n//Provides: caml_ba_uint8_get64\n//Requires: caml_array_bound_error, caml_int64_of_bytes\nfunction caml_ba_uint8_get64(ba, i0) {\n var ofs = ba.offset(i0);\n if(ofs + 7 >= ba.data.length) caml_array_bound_error();\n var b1 = ba.get(ofs+0);\n var b2 = ba.get(ofs+1);\n var b3 = ba.get(ofs+2);\n var b4 = ba.get(ofs+3);\n var b5 = ba.get(ofs+4);\n var b6 = ba.get(ofs+5);\n var b7 = ba.get(ofs+6);\n var b8 = ba.get(ofs+7);\n return caml_int64_of_bytes([b8,b7,b6,b5,b4,b3,b2,b1]);\n}\n\n//Provides: caml_ba_get_1\nfunction caml_ba_get_1(ba, i0) {\n return ba.get(ba.offset(i0));\n}\n\n//Provides: caml_ba_get_2\nfunction caml_ba_get_2(ba, i0, i1) {\n return ba.get(ba.offset([i0,i1]));\n}\n\n//Provides: caml_ba_get_3\nfunction caml_ba_get_3(ba, i0, i1, i2) {\n return ba.get(ba.offset([i0,i1,i2]));\n}\n\n//Provides: caml_ba_set_generic\n//Requires: caml_js_from_array\nfunction caml_ba_set_generic(ba, i, v) {\n ba.set(ba.offset(caml_js_from_array(i)), v);\n return 0\n}\n\n//Provides: caml_ba_uint8_set16\n//Requires: caml_array_bound_error\nfunction caml_ba_uint8_set16(ba, i0, v) {\n var ofs = ba.offset(i0);\n if(ofs + 1 >= ba.data.length) caml_array_bound_error();\n ba.set(ofs+0, v & 0xff);\n ba.set(ofs+1, (v >>> 8) & 0xff);\n return 0;\n}\n\n//Provides: caml_ba_uint8_set32\n//Requires: caml_array_bound_error\nfunction caml_ba_uint8_set32(ba, i0, v) {\n var ofs = ba.offset(i0);\n if(ofs + 3 >= ba.data.length) caml_array_bound_error();\n ba.set(ofs+0, v & 0xff);\n ba.set(ofs+1, (v >>> 8) & 0xff);\n ba.set(ofs+2, (v >>> 16) & 0xff);\n ba.set(ofs+3, (v >>> 24) & 0xff);\n return 0;\n}\n\n//Provides: caml_ba_uint8_set64\n//Requires: caml_array_bound_error, caml_int64_to_bytes\nfunction caml_ba_uint8_set64(ba, i0, v) {\n var ofs = ba.offset(i0);\n if(ofs + 7 >= ba.data.length) caml_array_bound_error();\n var v = caml_int64_to_bytes(v);\n for(var i = 0; i < 8; i++) ba.set(ofs+i, v[7-i])\n return 0;\n}\n\n//Provides: caml_ba_set_1\nfunction caml_ba_set_1(ba, i0, v) {\n ba.set(ba.offset(i0), v);\n return 0\n}\n\n//Provides: caml_ba_set_2\nfunction caml_ba_set_2(ba, i0, i1, v) {\n ba.set(ba.offset([i0,i1]), v);\n return 0;\n}\n\n//Provides: caml_ba_set_3\nfunction caml_ba_set_3(ba, i0, i1, i2, v) {\n ba.set(ba.offset([i0,i1,i2]), v);\n return 0;\n}\n\n//Provides: caml_ba_fill\nfunction caml_ba_fill(ba, v) {\n ba.fill(v);\n return 0;\n}\n\n//Provides: caml_ba_blit\n//Requires: caml_invalid_argument\nfunction caml_ba_blit(src, dst) {\n if (dst.dims.length != src.dims.length)\n caml_invalid_argument(\"Bigarray.blit: dimension mismatch\");\n for (var i = 0; i < dst.dims.length; i++)\n if (dst.dims[i] != src.dims[i])\n caml_invalid_argument(\"Bigarray.blit: dimension mismatch\");\n dst.data.set(src.data);\n return 0;\n}\n\n//Provides: caml_ba_sub\n//Requires: caml_invalid_argument, caml_ba_create_unsafe, caml_ba_get_size\n//Requires: caml_ba_get_size_per_element\nfunction caml_ba_sub(ba, ofs, len) {\n var changed_dim;\n var mul = 1;\n if (ba.layout == 0) {\n for (var i = 1; i < ba.dims.length; i++)\n mul = mul * ba.dims[i];\n changed_dim = 0;\n } else {\n for (var i = 0; i < (ba.dims.length - 1); i++)\n mul = mul * ba.dims[i];\n changed_dim = ba.dims.length - 1;\n ofs = ofs - 1;\n }\n if (ofs < 0 || len < 0 || (ofs + len) > ba.dims[changed_dim]){\n caml_invalid_argument(\"Bigarray.sub: bad sub-array\");\n }\n var new_dims = [];\n for (var i = 0; i < ba.dims.length; i++)\n new_dims[i] = ba.dims[i];\n new_dims[changed_dim] = len;\n mul *= caml_ba_get_size_per_element(ba.kind);\n var new_data = ba.data.subarray(ofs * mul, (ofs + len) * mul);\n return caml_ba_create_unsafe(ba.kind, ba.layout, new_dims, new_data);\n}\n\n//Provides: caml_ba_slice\n//Requires: caml_js_from_array, caml_ba_create_unsafe, caml_invalid_argument, caml_ba_get_size\n//Requires: caml_ba_get_size_per_element\nfunction caml_ba_slice(ba, vind) {\n vind = caml_js_from_array(vind);\n var num_inds = vind.length;\n var index = [];\n var sub_dims = [];\n var ofs;\n\n if (num_inds > ba.dims.length)\n caml_invalid_argument(\"Bigarray.slice: too many indices\");\n\n // Compute offset and check bounds\n if (ba.layout == 0) {\n for (var i = 0; i < num_inds; i++)\n index[i] = vind[i];\n for (; i < ba.dims.length; i++)\n index[i] = 0;\n sub_dims = ba.dims.slice(num_inds);\n } else {\n for (var i = 0; i < num_inds; i++)\n index[ba.dims.length - num_inds + i] = vind[i];\n for (var i = 0; i < ba.dims.length - num_inds; i++)\n index[i] = 1;\n sub_dims = ba.dims.slice(0, ba.dims.length - num_inds);\n }\n ofs = ba.offset(index);\n var size = caml_ba_get_size(sub_dims);\n var size_per_element = caml_ba_get_size_per_element(ba.kind);\n var new_data = ba.data.subarray(ofs * size_per_element, (ofs + size) * size_per_element);\n return caml_ba_create_unsafe(ba.kind, ba.layout, sub_dims, new_data);\n}\n\n//Provides: caml_ba_reshape\n//Requires: caml_js_from_array, caml_invalid_argument, caml_ba_create_unsafe, caml_ba_get_size\nfunction caml_ba_reshape(ba, vind) {\n vind = caml_js_from_array(vind);\n var new_dim = [];\n var num_dims = vind.length;\n\n if (num_dims < 0 || num_dims > 16){\n caml_invalid_argument(\"Bigarray.reshape: bad number of dimensions\");\n }\n var num_elts = 1;\n for (var i = 0; i < num_dims; i++) {\n new_dim[i] = vind[i];\n if (new_dim[i] < 0)\n caml_invalid_argument(\"Bigarray.reshape: negative dimension\");\n num_elts = num_elts * new_dim[i];\n }\n\n var size = caml_ba_get_size(ba.dims);\n // Check that sizes agree\n if (num_elts != size)\n caml_invalid_argument(\"Bigarray.reshape: size mismatch\");\n return caml_ba_create_unsafe(ba.kind, ba.layout, new_dim, ba.data);\n}\n\n//Provides: caml_ba_serialize\n//Requires: caml_int64_bits_of_float, caml_int64_to_bytes\n//Requires: caml_int32_bits_of_float\nfunction caml_ba_serialize(writer, ba, sz) {\n writer.write(32, ba.dims.length);\n writer.write(32, (ba.kind | (ba.layout << 8)));\n if(ba.caml_custom == \"_bigarr02\")\n for(var i = 0; i < ba.dims.length; i++) {\n if(ba.dims[i] < 0xffff)\n writer.write(16, ba.dims[i]);\n else {\n writer.write(16, 0xffff);\n writer.write(32, 0);\n writer.write(32, ba.dims[i]);\n }\n }\n else\n for(var i = 0; i < ba.dims.length; i++) writer.write(32,ba.dims[i])\n switch(ba.kind){\n case 2: //Int8Array\n case 3: //Uint8Array\n case 12: //Uint8Array\n for(var i = 0; i < ba.data.length; i++){\n writer.write(8, ba.data[i]);\n }\n break;\n case 4: // Int16Array\n case 5: // Uint16Array\n for(var i = 0; i < ba.data.length; i++){\n writer.write(16, ba.data[i]);\n }\n break;\n case 6: // Int32Array (int32)\n for(var i = 0; i < ba.data.length; i++){\n writer.write(32, ba.data[i]);\n }\n break;\n case 8: // Int32Array (int)\n case 9: // Int32Array (nativeint)\n writer.write(8,0);\n for(var i = 0; i < ba.data.length; i++){\n writer.write(32, ba.data[i]);\n }\n break;\n case 7: // Int32Array (int64)\n for(var i = 0; i < ba.data.length / 2; i++){\n var b = caml_int64_to_bytes(ba.get(i));\n for (var j = 0; j < 8; j++) writer.write (8, b[j]);\n }\n break;\n case 1: // Float64Array\n for(var i = 0; i < ba.data.length; i++){\n var b = caml_int64_to_bytes(caml_int64_bits_of_float(ba.get(i)));\n for (var j = 0; j < 8; j++) writer.write (8, b[j]);\n }\n break;\n case 0: // Float32Array\n for(var i = 0; i < ba.data.length; i++){\n var b = caml_int32_bits_of_float(ba.get(i));\n writer.write(32, b);\n }\n break;\n case 10: // Float32Array (complex32)\n for(var i = 0; i < ba.data.length / 2; i++){\n var j = ba.get(i);\n writer.write(32, caml_int32_bits_of_float(j[1]));\n writer.write(32, caml_int32_bits_of_float(j[2]));\n }\n break;\n case 11: // Float64Array (complex64)\n for(var i = 0; i < ba.data.length / 2; i++){\n var complex = ba.get(i);\n var b = caml_int64_to_bytes(caml_int64_bits_of_float(complex[1]));\n for (var j = 0; j < 8; j++) writer.write (8, b[j]);\n var b = caml_int64_to_bytes(caml_int64_bits_of_float(complex[2]));\n for (var j = 0; j < 8; j++) writer.write (8, b[j]);\n }\n break;\n }\n sz[0] = (4 + ba.dims.length) * 4;\n sz[1] = (4 + ba.dims.length) * 8;\n}\n\n//Provides: caml_ba_deserialize\n//Requires: caml_ba_create_unsafe, caml_failwith\n//Requires: caml_ba_get_size\n//Requires: caml_int64_of_bytes, caml_int64_float_of_bits\n//Requires: caml_int32_float_of_bits\n//Requires: caml_ba_create_buffer\nfunction caml_ba_deserialize(reader, sz, name){\n var num_dims = reader.read32s();\n if (num_dims < 0 || num_dims > 16)\n caml_failwith(\"input_value: wrong number of bigarray dimensions\");\n var tag = reader.read32s();\n var kind = tag & 0xff\n var layout = (tag >> 8) & 1;\n var dims = []\n if(name == \"_bigarr02\")\n for (var i = 0; i < num_dims; i++) {\n var size_dim = reader.read16u();\n if(size_dim == 0xffff){\n var size_dim_hi = reader.read32u();\n var size_dim_lo = reader.read32u();\n if(size_dim_hi != 0)\n caml_failwith(\"input_value: bigarray dimension overflow in 32bit\");\n size_dim = size_dim_lo;\n }\n dims.push(size_dim);\n }\n else\n for (var i = 0; i < num_dims; i++) dims.push(reader.read32u());\n var size = caml_ba_get_size(dims);\n var data = caml_ba_create_buffer(kind, size);\n var ba = caml_ba_create_unsafe(kind, layout, dims, data);\n switch(kind){\n case 2: //Int8Array\n for(var i = 0; i < size; i++){\n data[i] = reader.read8s();\n }\n break;\n case 3: //Uint8Array\n case 12: //Uint8Array\n for(var i = 0; i < size; i++){\n data[i] = reader.read8u();\n }\n break;\n case 4: // Int16Array\n for(var i = 0; i < size; i++){\n data[i] = reader.read16s();\n }\n break;\n case 5: // Uint16Array\n for(var i = 0; i < size; i++){\n data[i] = reader.read16u();\n }\n break;\n case 6: // Int32Array (int32)\n for(var i = 0; i < size; i++){\n data[i] = reader.read32s();\n }\n break;\n case 8: // Int32Array (int)\n case 9: // Int32Array (nativeint)\n var sixty = reader.read8u();\n if(sixty) caml_failwith(\"input_value: cannot read bigarray with 64-bit OCaml ints\");\n for(var i = 0; i < size; i++){\n data[i] = reader.read32s();\n }\n break;\n case 7: // (int64)\n var t = new Array(8);;\n for(var i = 0; i < size; i++){\n for (var j = 0;j < 8;j++) t[j] = reader.read8u();\n var int64 = caml_int64_of_bytes(t);\n ba.set(i,int64);\n }\n break;\n case 1: // Float64Array\n var t = new Array(8);;\n for(var i = 0; i < size; i++){\n for (var j = 0;j < 8;j++) t[j] = reader.read8u();\n var f = caml_int64_float_of_bits(caml_int64_of_bytes(t));\n ba.set(i,f);\n }\n break;\n case 0: // Float32Array\n for(var i = 0; i < size; i++){\n var f = caml_int32_float_of_bits(reader.read32s());\n ba.set(i,f);\n }\n break;\n case 10: // Float32Array (complex32)\n for(var i = 0; i < size; i++){\n var re = caml_int32_float_of_bits(reader.read32s());\n var im = caml_int32_float_of_bits(reader.read32s());\n ba.set(i,[254,re,im]);\n }\n break;\n case 11: // Float64Array (complex64)\n var t = new Array(8);;\n for(var i = 0; i < size; i++){\n for (var j = 0;j < 8;j++) t[j] = reader.read8u();\n var re = caml_int64_float_of_bits(caml_int64_of_bytes(t));\n for (var j = 0;j < 8;j++) t[j] = reader.read8u();\n var im = caml_int64_float_of_bits(caml_int64_of_bytes(t));\n ba.set(i,[254,re,im]);\n }\n break\n }\n sz[0] = (4 + num_dims) * 4;\n return caml_ba_create_unsafe(kind, layout, dims, data);\n}\n\n//Deprecated\n//Provides: caml_ba_create_from\n//Requires: caml_ba_create_unsafe, caml_invalid_argument, caml_ba_get_size_per_element\nfunction caml_ba_create_from(data1, data2, jstyp, kind, layout, dims){\n if(data2 || caml_ba_get_size_per_element(kind) == 2){\n caml_invalid_argument(\"caml_ba_create_from: use return caml_ba_create_unsafe\");\n }\n return caml_ba_create_unsafe(kind, layout, dims, data1);\n}\n\n//Provides: caml_ba_hash const\n//Requires: caml_ba_get_size, caml_hash_mix_int, caml_hash_mix_float\nfunction caml_ba_hash(ba){\n var num_elts = caml_ba_get_size(ba.dims);\n var h = 0;\n switch(ba.kind){\n case 2: //Int8Array\n case 3: //Uint8Array\n case 12: //Uint8Array\n if(num_elts > 256) num_elts = 256;\n var w = 0, i =0;\n for(i = 0; i + 4 <= ba.data.length; i+=4){\n w = ba.data[i+0] | (ba.data[i+1] << 8) | (ba.data[i+2] << 16) | (ba.data[i+3] << 24);\n h = caml_hash_mix_int(h,w);\n }\n w = 0;\n switch (num_elts & 3) {\n case 3: w = ba.data[i+2] << 16; /* fallthrough */\n case 2: w |= ba.data[i+1] << 8; /* fallthrough */\n case 1: w |= ba.data[i+0];\n h = caml_hash_mix_int(h, w);\n }\n break;\n case 4: // Int16Array\n case 5: // Uint16Array\n if(num_elts > 128) num_elts = 128;\n var w = 0, i =0;\n for(i = 0; i + 2 <= ba.data.length; i+=2){\n w = ba.data[i+0] | (ba.data[i+1] << 16);\n h = caml_hash_mix_int(h,w);\n }\n if ((num_elts & 1) != 0)\n h = caml_hash_mix_int(h, ba.data[i]);\n break;\n case 6: // Int32Array (int32)\n if (num_elts > 64) num_elts = 64;\n for (var i = 0; i < num_elts; i++) h = caml_hash_mix_int(h, ba.data[i]);\n break;\n case 8: // Int32Array (int)\n case 9: // Int32Array (nativeint)\n if (num_elts > 64) num_elts = 64;\n for (var i = 0; i < num_elts; i++) h = caml_hash_mix_int(h, ba.data[i]);\n break;\n case 7: // Int32Array (int64)\n if (num_elts > 32) num_elts = 32;\n num_elts *= 2\n for (var i = 0; i < num_elts; i++) {\n h = caml_hash_mix_int(h, ba.data[i]);\n }\n break;\n case 10: // Float32Array (complex32)\n num_elts *=2; /* fallthrough */\n case 0: // Float32Array\n if (num_elts > 64) num_elts = 64;\n for (var i = 0; i < num_elts; i++) h = caml_hash_mix_float(h, ba.data[i]);\n break;\n case 11: // Float64Array (complex64)\n num_elts *=2; /* fallthrough */\n case 1: // Float64Array\n if (num_elts > 32) num_elts = 32;\n for (var i = 0; i < num_elts; i++) h = caml_hash_mix_float(h, ba.data[i]);\n break;\n }\n return h;\n}\n\n//Provides: caml_ba_to_typed_array mutable\nfunction caml_ba_to_typed_array(ba){\n return ba.data;\n}\n\n//Provides: caml_ba_kind_of_typed_array mutable\n//Requires: caml_invalid_argument\nfunction caml_ba_kind_of_typed_array(ta){\n var g = globalThis;\n var kind;\n if (ta instanceof g.Float32Array) kind = 0;\n else if (ta instanceof g.Float64Array) kind = 1;\n else if (ta instanceof g.Int8Array) kind = 2;\n else if (ta instanceof g.Uint8Array) kind = 3;\n else if (ta instanceof g.Int16Array) kind = 4;\n else if (ta instanceof g.Uint16Array) kind = 5;\n else if (ta instanceof g.Int32Array) kind = 6;\n else if (ta instanceof g.Uint32Array) kind = 6;\n else caml_invalid_argument(\"caml_ba_kind_of_typed_array: unsupported kind\");\n return kind;\n}\n\n//Provides: caml_ba_from_typed_array mutable\n//Requires: caml_ba_kind_of_typed_array\n//Requires: caml_ba_create_unsafe\nfunction caml_ba_from_typed_array(ta){\n var kind = caml_ba_kind_of_typed_array(ta);\n return caml_ba_create_unsafe(kind, 0, [ta.length], ta);\n}\n","/* global joo_global_object\n */\n\n//Provides: caml_raise_with_string (const, const)\nfunction caml_raise_with_string(tag, msg) {\n throw globalThis.Error(msg.c);\n}\n\n//Provides: custom_reraise_exn\nfunction custom_reraise_exn(exn, fallbackMessage) {\n // this handles the common case of a JS Error reraised by OCaml\n // in that case, the error will first be wrapped in OCaml with \"caml_wrap_exception\"\n // (defined in js_of_ocaml-compiler / jslib.js)\n // which results in [0, caml_named_value(\"jsError\"), err]\n var err = exn[2];\n if (err instanceof globalThis.Error) {\n throw err;\n } else {\n throw Error(fallbackMessage);\n }\n}\n\n/**\n * This overrides the handler for uncaught exceptions in js_of_ocaml,\n * fixing the flaw that by default, no actual `Error`s are thrown,\n * but other objects (arrays) which are missing an error trace.\n * This override should make it much easier to find the source of an error.\n */\n//Provides: caml_fatal_uncaught_exception\nfunction caml_fatal_uncaught_exception(err) {\n // first, we search for an actual error inside `err`,\n // since this is the best thing to throw\n function throw_errors(err) {\n if (err instanceof Error) throw err;\n else if (Array.isArray(err)) {\n err.forEach(throw_errors);\n }\n }\n throw_errors(err);\n // if this didn't throw an error, let's log whatever we got\n console.dir(err, { depth: 20 });\n // now, try to collect all strings in the error and throw that\n function collect_strings(err, acc) {\n var str = undefined;\n if (typeof err === 'string') {\n str = err;\n } else if (err && err.constructor && err.constructor.name === 'MlBytes') {\n str = err.c;\n } else if (Array.isArray(err)) {\n err.forEach(function (e) {\n collect_strings(e, acc);\n });\n }\n if (!str) return acc.string;\n if (acc.string === undefined) acc.string = str;\n else acc.string = acc.string + '\\n' + str;\n return acc.string;\n }\n var str = collect_strings(err, {});\n if (str !== undefined) throw joo_global_object.Error(str);\n // otherwise, just throw an unhelpful error\n console.dir(err, { depth: 10 });\n throw joo_global_object.Error('Unknown error thrown from OCaml');\n}\n","// Js_of_ocaml runtime support\n// http://www.ocsigen.org/js_of_ocaml/\n// Copyright (C) 2010 Jérôme Vouillon\n// Laboratoire PPS - CNRS Université Paris Diderot\n//\n// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU Lesser General Public License as published by\n// the Free Software Foundation, with linking exception;\n// either version 2.1 of the License, or (at your option) any later version.\n//\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n// GNU Lesser General Public License for more details.\n//\n// You should have received a copy of the GNU Lesser General Public License\n// along with this program; if not, write to the Free Software\n// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n\n//Provides: caml_marshal_constants\nvar caml_marshal_constants = {\n PREFIX_SMALL_BLOCK: 0x80,\n PREFIX_SMALL_INT: 0x40,\n PREFIX_SMALL_STRING: 0x20,\n CODE_INT8: 0x00,\n CODE_INT16: 0x01,\n CODE_INT32: 0x02,\n CODE_INT64: 0x03,\n CODE_SHARED8: 0x04,\n CODE_SHARED16: 0x05,\n CODE_SHARED32: 0x06,\n CODE_BLOCK32: 0x08,\n CODE_BLOCK64: 0x13,\n CODE_STRING8: 0x09,\n CODE_STRING32: 0x0A,\n CODE_DOUBLE_BIG: 0x0B,\n CODE_DOUBLE_LITTLE: 0x0C,\n CODE_DOUBLE_ARRAY8_BIG: 0x0D,\n CODE_DOUBLE_ARRAY8_LITTLE: 0x0E,\n CODE_DOUBLE_ARRAY32_BIG: 0x0F,\n CODE_DOUBLE_ARRAY32_LITTLE: 0x07,\n CODE_CODEPOINTER: 0x10,\n CODE_INFIXPOINTER: 0x11,\n CODE_CUSTOM: 0x12,\n CODE_CUSTOM_LEN: 0x18,\n CODE_CUSTOM_FIXED: 0x19\n}\n\n\n//Provides: MlStringReader\n//Requires: caml_string_of_jsbytes, caml_jsbytes_of_string\nfunction MlStringReader (s, i) { this.s = caml_jsbytes_of_string(s); this.i = i; }\nMlStringReader.prototype = {\n read8u:function () { return this.s.charCodeAt(this.i++); },\n read8s:function () { return this.s.charCodeAt(this.i++) << 24 >> 24; },\n read16u:function () {\n var s = this.s, i = this.i;\n this.i = i + 2;\n return (s.charCodeAt(i) << 8) | s.charCodeAt(i + 1)\n },\n read16s:function () {\n var s = this.s, i = this.i;\n this.i = i + 2;\n return (s.charCodeAt(i) << 24 >> 16) | s.charCodeAt(i + 1);\n },\n read32u:function () {\n var s = this.s, i = this.i;\n this.i = i + 4;\n return ((s.charCodeAt(i) << 24) | (s.charCodeAt(i+1) << 16) |\n (s.charCodeAt(i+2) << 8) | s.charCodeAt(i+3)) >>> 0;\n },\n read32s:function () {\n var s = this.s, i = this.i;\n this.i = i + 4;\n return (s.charCodeAt(i) << 24) | (s.charCodeAt(i+1) << 16) |\n (s.charCodeAt(i+2) << 8) | s.charCodeAt(i+3);\n },\n readstr:function (len) {\n var i = this.i;\n this.i = i + len;\n return caml_string_of_jsbytes(this.s.substring(i, i + len));\n }\n}\n\n//Provides: BigStringReader\n//Requires: caml_string_of_array, caml_ba_get_1\nfunction BigStringReader (bs, i) { this.s = bs; this.i = i; }\nBigStringReader.prototype = {\n read8u:function () { return caml_ba_get_1(this.s,this.i++); },\n read8s:function () { return caml_ba_get_1(this.s,this.i++) << 24 >> 24; },\n read16u:function () {\n var s = this.s, i = this.i;\n this.i = i + 2;\n return (caml_ba_get_1(s,i) << 8) | caml_ba_get_1(s,i + 1)\n },\n read16s:function () {\n var s = this.s, i = this.i;\n this.i = i + 2;\n return (caml_ba_get_1(s,i) << 24 >> 16) | caml_ba_get_1(s,i + 1);\n },\n read32u:function () {\n var s = this.s, i = this.i;\n this.i = i + 4;\n return ((caml_ba_get_1(s,i) << 24) | (caml_ba_get_1(s,i+1) << 16) |\n (caml_ba_get_1(s,i+2) << 8) | caml_ba_get_1(s,i+3) ) >>> 0;\n },\n read32s:function () {\n var s = this.s, i = this.i;\n this.i = i + 4;\n return (caml_ba_get_1(s,i) << 24) | (caml_ba_get_1(s,i+1) << 16) |\n (caml_ba_get_1(s,i+2) << 8) | caml_ba_get_1(s,i+3);\n },\n readstr:function (len) {\n var i = this.i;\n var arr = new Array(len)\n for(var j = 0; j < len; j++){\n arr[j] = caml_ba_get_1(this.s, i+j);\n }\n this.i = i + len;\n return caml_string_of_array(arr);\n }\n}\n\n\n\n//Provides: caml_float_of_bytes\n//Requires: caml_int64_float_of_bits, caml_int64_of_bytes\nfunction caml_float_of_bytes (a) {\n return caml_int64_float_of_bits (caml_int64_of_bytes (a));\n}\n\n//Provides: caml_input_value_from_string mutable\n//Requires: MlStringReader, caml_input_value_from_reader\nfunction caml_input_value_from_string(s,ofs) {\n var reader = new MlStringReader (s, typeof ofs==\"number\"?ofs:ofs[0]);\n return caml_input_value_from_reader(reader, ofs)\n}\n\n//Provides: caml_input_value_from_bytes mutable\n//Requires: MlStringReader, caml_input_value_from_reader, caml_string_of_bytes\nfunction caml_input_value_from_bytes(s,ofs) {\n var reader = new MlStringReader (caml_string_of_bytes(s), typeof ofs==\"number\"?ofs:ofs[0]);\n return caml_input_value_from_reader(reader, ofs)\n}\n\n//Provides: caml_int64_unmarshal\n//Requires: caml_int64_of_bytes\nfunction caml_int64_unmarshal(reader, size){\n var t = new Array(8);;\n for (var j = 0;j < 8;j++) t[j] = reader.read8u();\n size[0] = 8;\n return caml_int64_of_bytes (t);\n}\n\n//Provides: caml_int64_marshal\n//Requires: caml_int64_to_bytes\nfunction caml_int64_marshal(writer, v, sizes) {\n var b = caml_int64_to_bytes (v);\n for (var i = 0; i < 8; i++) writer.write (8, b[i]);\n sizes[0] = 8; sizes[1] = 8;\n}\n\n//Provides: caml_int32_unmarshal\nfunction caml_int32_unmarshal(reader, size){\n size[0] = 4;\n return reader.read32s ();\n}\n\n//Provides: caml_nativeint_unmarshal\n//Requires: caml_failwith\nfunction caml_nativeint_unmarshal(reader, size){\n switch (reader.read8u ()) {\n case 1:\n size[0] = 4;\n return reader.read32s ();\n case 2:\n caml_failwith(\"input_value: native integer value too large\");\n default: caml_failwith(\"input_value: ill-formed native integer\");\n }\n}\n\n//Provides: caml_custom_ops\n//Requires: caml_int64_unmarshal, caml_int64_marshal, caml_int64_compare, caml_int64_hash\n//Requires: caml_int32_unmarshal, caml_nativeint_unmarshal\n//Requires: caml_ba_serialize, caml_ba_deserialize, caml_ba_compare, caml_ba_hash\nvar caml_custom_ops =\n {\"_j\": {\n deserialize : caml_int64_unmarshal,\n serialize : caml_int64_marshal,\n fixed_length : 8,\n compare : caml_int64_compare,\n hash : caml_int64_hash\n },\n \"_i\": {\n deserialize : caml_int32_unmarshal,\n fixed_length : 4,\n },\n \"_n\": {\n deserialize : caml_nativeint_unmarshal,\n fixed_length : 4,\n },\n \"_bigarray\":{\n deserialize : (function (reader, sz) {return caml_ba_deserialize (reader,sz,\"_bigarray\")}),\n serialize : caml_ba_serialize,\n compare : caml_ba_compare,\n hash: caml_ba_hash,\n },\n \"_bigarr02\":{\n deserialize : (function (reader, sz) {return caml_ba_deserialize (reader,sz,\"_bigarr02\")}),\n serialize : caml_ba_serialize,\n compare : caml_ba_compare,\n hash: caml_ba_hash,\n }\n }\n\n//Provides: caml_input_value_from_reader mutable\n//Requires: caml_failwith\n//Requires: caml_float_of_bytes, caml_custom_ops\n\nfunction caml_input_value_from_reader(reader, ofs) {\n var _magic = reader.read32u ()\n var _block_len = reader.read32u ();\n var num_objects = reader.read32u ();\n var _size_32 = reader.read32u ();\n var _size_64 = reader.read32u ();\n var stack = [];\n var intern_obj_table = (num_objects > 0)?[]:null;\n var obj_counter = 0;\n function intern_rec () {\n var code = reader.read8u ();\n if (code >= 0x40 /*cst.PREFIX_SMALL_INT*/) {\n if (code >= 0x80 /*cst.PREFIX_SMALL_BLOCK*/) {\n var tag = code & 0xF;\n var size = (code >> 4) & 0x7;\n var v = [tag];\n if (size == 0) return v;\n if (intern_obj_table) intern_obj_table[obj_counter++] = v;\n stack.push(v, size);\n return v;\n } else\n return (code & 0x3F);\n } else {\n if (code >= 0x20/*cst.PREFIX_SMALL_STRING */) {\n var len = code & 0x1F;\n var v = reader.readstr (len);\n if (intern_obj_table) intern_obj_table[obj_counter++] = v;\n return v;\n } else {\n switch(code) {\n case 0x00: //cst.CODE_INT8:\n return reader.read8s ();\n case 0x01: //cst.CODE_INT16:\n return reader.read16s ();\n case 0x02: //cst.CODE_INT32:\n return reader.read32s ();\n case 0x03: //cst.CODE_INT64:\n caml_failwith(\"input_value: integer too large\");\n break;\n case 0x04: //cst.CODE_SHARED8:\n var offset = reader.read8u ();\n return intern_obj_table[obj_counter - offset];\n case 0x05: //cst.CODE_SHARED16:\n var offset = reader.read16u ();\n return intern_obj_table[obj_counter - offset];\n case 0x06: //cst.CODE_SHARED32:\n var offset = reader.read32u ();\n return intern_obj_table[obj_counter - offset];\n case 0x08: //cst.CODE_BLOCK32:\n var header = reader.read32u ();\n var tag = header & 0xFF;\n var size = header >> 10;\n var v = [tag];\n if (size == 0) return v;\n if (intern_obj_table) intern_obj_table[obj_counter++] = v;\n stack.push(v, size);\n return v;\n case 0x13: //cst.CODE_BLOCK64:\n caml_failwith (\"input_value: data block too large\");\n break;\n case 0x09: //cst.CODE_STRING8:\n var len = reader.read8u();\n var v = reader.readstr (len);\n if (intern_obj_table) intern_obj_table[obj_counter++] = v;\n return v;\n case 0x0A: //cst.CODE_STRING32:\n var len = reader.read32u();\n var v = reader.readstr (len);\n if (intern_obj_table) intern_obj_table[obj_counter++] = v;\n return v;\n case 0x0C: //cst.CODE_DOUBLE_LITTLE:\n var t = new Array(8);;\n for (var i = 0;i < 8;i++) t[7 - i] = reader.read8u ();\n var v = caml_float_of_bytes (t);\n if (intern_obj_table) intern_obj_table[obj_counter++] = v;\n return v;\n case 0x0B: //cst.CODE_DOUBLE_BIG:\n var t = new Array(8);;\n for (var i = 0;i < 8;i++) t[i] = reader.read8u ();\n var v = caml_float_of_bytes (t);\n if (intern_obj_table) intern_obj_table[obj_counter++] = v;\n return v;\n case 0x0E: //cst.CODE_DOUBLE_ARRAY8_LITTLE:\n var len = reader.read8u();\n var v = new Array(len+1);\n v[0] = 254;\n var t = new Array(8);;\n if (intern_obj_table) intern_obj_table[obj_counter++] = v;\n for (var i = 1;i <= len;i++) {\n for (var j = 0;j < 8;j++) t[7 - j] = reader.read8u();\n v[i] = caml_float_of_bytes (t);\n }\n return v;\n case 0x0D: //cst.CODE_DOUBLE_ARRAY8_BIG:\n var len = reader.read8u();\n var v = new Array(len+1);\n v[0] = 254;\n var t = new Array(8);;\n if (intern_obj_table) intern_obj_table[obj_counter++] = v;\n for (var i = 1;i <= len;i++) {\n for (var j = 0;j < 8;j++) t[j] = reader.read8u();\n v [i] = caml_float_of_bytes (t);\n }\n return v;\n case 0x07: //cst.CODE_DOUBLE_ARRAY32_LITTLE:\n var len = reader.read32u();\n var v = new Array(len+1);\n v[0] = 254;\n if (intern_obj_table) intern_obj_table[obj_counter++] = v;\n var t = new Array(8);;\n for (var i = 1;i <= len;i++) {\n for (var j = 0;j < 8;j++) t[7 - j] = reader.read8u();\n v[i] = caml_float_of_bytes (t);\n }\n return v;\n case 0x0F: //cst.CODE_DOUBLE_ARRAY32_BIG:\n var len = reader.read32u();\n var v = new Array(len+1);\n v[0] = 254;\n var t = new Array(8);;\n for (var i = 1;i <= len;i++) {\n for (var j = 0;j < 8;j++) t[j] = reader.read8u();\n v [i] = caml_float_of_bytes (t);\n }\n return v;\n case 0x10: //cst.CODE_CODEPOINTER:\n case 0x11: //cst.CODE_INFIXPOINTER:\n caml_failwith (\"input_value: code pointer\");\n break;\n case 0x12: //cst.CODE_CUSTOM:\n case 0x18: //cst.CODE_CUSTOM_LEN:\n case 0x19: //cst.CODE_CUSTOM_FIXED:\n var c, s = \"\";\n while ((c = reader.read8u ()) != 0) s += String.fromCharCode (c);\n var ops = caml_custom_ops[s];\n var expected_size;\n if(!ops)\n caml_failwith(\"input_value: unknown custom block identifier\");\n switch(code){\n case 0x12: // cst.CODE_CUSTOM (deprecated)\n break;\n case 0x19: // cst.CODE_CUSTOM_FIXED\n if(!ops.fixed_length)\n caml_failwith(\"input_value: expected a fixed-size custom block\");\n expected_size = ops.fixed_length;\n break;\n case 0x18: // cst.CODE_CUSTOM_LEN\n expected_size = reader.read32u ();\n // Skip size64\n reader.read32s(); reader.read32s();\n break;\n }\n var old_pos = reader.i;\n var size = [0];\n var v = ops.deserialize(reader, size);\n if(expected_size != undefined){\n if(expected_size != size[0])\n caml_failwith(\"input_value: incorrect length of serialized custom block\");\n }\n if (intern_obj_table) intern_obj_table[obj_counter++] = v;\n return v;\n default:\n caml_failwith (\"input_value: ill-formed message\");\n }\n }\n }\n }\n var res = intern_rec ();\n while (stack.length > 0) {\n var size = stack.pop();\n var v = stack.pop();\n var d = v.length;\n if (d < size) stack.push(v, size);\n v[d] = intern_rec ();\n }\n if (typeof ofs!=\"number\") ofs[0] = reader.i;\n return res;\n}\n\n//Provides: caml_marshal_data_size mutable\n//Requires: caml_failwith, caml_bytes_unsafe_get\nfunction caml_marshal_data_size (s, ofs) {\n function get32(s,i) {\n return (caml_bytes_unsafe_get(s, i) << 24) |\n (caml_bytes_unsafe_get(s, i + 1) << 16) |\n (caml_bytes_unsafe_get(s, i + 2) << 8) |\n caml_bytes_unsafe_get(s, i + 3);\n }\n if (get32(s, ofs) != (0x8495A6BE|0))\n caml_failwith(\"Marshal.data_size: bad object\");\n return (get32(s, ofs + 4));\n}\n\n//Provides: MlObjectTable\nvar MlObjectTable;\nif (typeof globalThis.WeakMap === 'undefined') {\n MlObjectTable = function() {\n /* polyfill (using linear search) */\n function NaiveLookup(objs) { this.objs = objs; }\n NaiveLookup.prototype.get = function(v) {\n for (var i = 0; i < this.objs.length; i++) {\n if (this.objs[i] === v) return i;\n }\n };\n NaiveLookup.prototype.set = function() {\n // Do nothing here. [MlObjectTable.store] will push to [this.objs] directly.\n };\n\n return function MlObjectTable() {\n this.objs = []; this.lookup = new NaiveLookup(this.objs);\n };\n }();\n}\nelse {\n MlObjectTable = function MlObjectTable() {\n this.objs = []; this.lookup = new globalThis.WeakMap();\n };\n}\n\nMlObjectTable.prototype.store = function(v) {\n this.lookup.set(v, this.objs.length);\n this.objs.push(v);\n}\n\nMlObjectTable.prototype.recall = function(v) {\n var i = this.lookup.get(v);\n return (i === undefined)\n ? undefined : this.objs.length - i; /* index is relative */\n}\n\n//Provides: caml_legacy_custom_code\n//Version: >= 4.08\nvar caml_legacy_custom_code = false\n\n//Provides: caml_legacy_custom_code\n//Version: < 4.08\nvar caml_legacy_custom_code = true\n\n//Provides: caml_output_val\n//Requires: caml_int64_to_bytes, caml_failwith\n//Requires: caml_int64_bits_of_float\n//Requires: caml_is_ml_bytes, caml_ml_bytes_length, caml_bytes_unsafe_get\n//Requires: caml_is_ml_string, caml_ml_string_length, caml_string_unsafe_get\n//Requires: MlObjectTable, caml_list_to_js_array, caml_legacy_custom_code, caml_custom_ops\n//Requires: caml_invalid_argument,caml_string_of_jsbytes\nvar caml_output_val = function (){\n function Writer () { this.chunk = []; }\n Writer.prototype = {\n chunk_idx:20, block_len:0, obj_counter:0, size_32:0, size_64:0,\n write:function (size, value) {\n for (var i = size - 8;i >= 0;i -= 8)\n this.chunk[this.chunk_idx++] = (value >> i) & 0xFF;\n },\n write_at:function (pos, size, value) {\n var pos = pos;\n for (var i = size - 8;i >= 0;i -= 8)\n this.chunk[pos++] = (value >> i) & 0xFF;\n },\n write_code:function (size, code, value) {\n this.chunk[this.chunk_idx++] = code;\n for (var i = size - 8;i >= 0;i -= 8)\n this.chunk[this.chunk_idx++] = (value >> i) & 0xFF;\n },\n write_shared:function (offset) {\n if (offset < (1 << 8)) this.write_code(8, 0x04 /*cst.CODE_SHARED8*/, offset);\n else if (offset < (1 << 16)) this.write_code(16, 0x05 /*cst.CODE_SHARED16*/, offset);\n else this.write_code(32, 0x06 /*cst.CODE_SHARED32*/, offset);\n },\n pos:function () { return this.chunk_idx },\n finalize:function () {\n this.block_len = this.chunk_idx - 20;\n this.chunk_idx = 0;\n this.write (32, 0x8495A6BE);\n this.write (32, this.block_len);\n this.write (32, this.obj_counter);\n this.write (32, this.size_32);\n this.write (32, this.size_64);\n return this.chunk;\n }\n }\n return function (v, flags) {\n flags = caml_list_to_js_array(flags);\n\n var no_sharing = (flags.indexOf(0 /*Marshal.No_sharing*/) !== -1),\n closures = (flags.indexOf(1 /*Marshal.Closures*/) !== -1);\n /* Marshal.Compat_32 is redundant since integers are 32-bit anyway */\n\n if (closures)\n globalThis.console.warn(\"in caml_output_val: flag Marshal.Closures is not supported.\");\n\n var writer = new Writer ();\n var stack = [];\n var intern_obj_table = no_sharing ? null : new MlObjectTable();\n\n function memo(v) {\n if (no_sharing) return false;\n var existing_offset = intern_obj_table.recall(v);\n if (existing_offset) { writer.write_shared(existing_offset); return true; }\n else { intern_obj_table.store(v); return false; }\n }\n\n function extern_rec (v) {\n if (v.caml_custom) {\n if (memo(v)) return;\n var name = v.caml_custom;\n var ops = caml_custom_ops[name];\n var sz_32_64 = [0,0];\n if(!ops.serialize)\n caml_invalid_argument(\"output_value: abstract value (Custom)\");\n if(caml_legacy_custom_code) {\n writer.write (8, 0x12 /*cst.CODE_CUSTOM*/);\n for (var i = 0; i < name.length; i++)\n writer.write (8, name.charCodeAt(i));\n writer.write(8, 0);\n ops.serialize(writer, v, sz_32_64);\n } else if(ops.fixed_length == undefined){\n writer.write (8, 0x18 /*cst.CODE_CUSTOM_LEN*/);\n for (var i = 0; i < name.length; i++)\n writer.write (8, name.charCodeAt(i));\n writer.write(8, 0);\n var header_pos = writer.pos ();\n for(var i = 0; i < 12; i++) {\n writer.write(8, 0);\n }\n ops.serialize(writer, v, sz_32_64);\n writer.write_at(header_pos, 32, sz_32_64[0]);\n writer.write_at(header_pos + 4, 32, 0); // zero\n writer.write_at(header_pos + 8, 32, sz_32_64[1]);\n } else {\n writer.write (8, 0x19 /*cst.CODE_CUSTOM_FIXED*/);\n for (var i = 0; i < name.length; i++)\n writer.write (8, name.charCodeAt(i));\n writer.write(8, 0);\n var old_pos = writer.pos();\n ops.serialize(writer, v, sz_32_64);\n if (ops.fixed_length != writer.pos() - old_pos)\n caml_failwith(\"output_value: incorrect fixed sizes specified by \" + name);\n }\n writer.size_32 += 2 + ((sz_32_64[0] + 3) >> 2);\n writer.size_64 += 2 + ((sz_32_64[1] + 7) >> 3);\n }\n else if (v instanceof Array && v[0] === (v[0]|0)) {\n if (v[0] == 251) {\n caml_failwith(\"output_value: abstract value (Abstract)\");\n }\n if (v.length > 1 && memo(v)) return;\n if (v[0] < 16 && v.length - 1 < 8)\n writer.write (8, 0x80 /*cst.PREFIX_SMALL_BLOCK*/ + v[0] + ((v.length - 1)<<4));\n else\n writer.write_code(32, 0x08 /*cst.CODE_BLOCK32*/, ((v.length-1) << 10) | v[0]);\n writer.size_32 += v.length;\n writer.size_64 += v.length;\n if (v.length > 1) stack.push (v, 1);\n } else if (caml_is_ml_bytes(v)) {\n if(!(caml_is_ml_bytes(caml_string_of_jsbytes(\"\")))) {\n caml_failwith(\"output_value: [Bytes.t] cannot safely be marshaled with [--enable use-js-string]\");\n }\n if (memo(v)) return;\n var len = caml_ml_bytes_length(v);\n if (len < 0x20)\n writer.write (8, 0x20 /*cst.PREFIX_SMALL_STRING*/ + len);\n else if (len < 0x100)\n writer.write_code (8, 0x09/*cst.CODE_STRING8*/, len);\n else\n writer.write_code (32, 0x0A /*cst.CODE_STRING32*/, len);\n for (var i = 0;i < len;i++)\n writer.write (8, caml_bytes_unsafe_get(v,i));\n writer.size_32 += 1 + (((len + 4) / 4)|0);\n writer.size_64 += 1 + (((len + 8) / 8)|0);\n } else if (caml_is_ml_string(v)) {\n var len = caml_ml_string_length(v);\n if (len < 0x20)\n writer.write (8, 0x20 /*cst.PREFIX_SMALL_STRING*/ + len);\n else if (len < 0x100)\n writer.write_code (8, 0x09/*cst.CODE_STRING8*/, len);\n else\n writer.write_code (32, 0x0A /*cst.CODE_STRING32*/, len);\n for (var i = 0;i < len;i++)\n writer.write (8, caml_string_unsafe_get(v,i));\n writer.size_32 += 1 + (((len + 4) / 4)|0);\n writer.size_64 += 1 + (((len + 8) / 8)|0);\n } else {\n if (v != (v|0)){\n var type_of_v = typeof v;\n //\n // If a float happens to be an integer it is serialized as an integer\n // (Js_of_ocaml cannot tell whether the type of an integer number is\n // float or integer.) This can result in unexpected crashes when\n // unmarshalling using the standard runtime. It seems better to\n // systematically fail on marshalling.\n //\n // if(type_of_v != \"number\")\n caml_failwith(\"output_value: abstract value (\"+type_of_v+\")\");\n // var t = caml_int64_to_bytes(caml_int64_bits_of_float(v));\n // writer.write (8, 0x0B /*cst.CODE_DOUBLE_BIG*/);\n // for(var i = 0; i<8; i++){writer.write(8,t[i])}\n }\n else if (v >= 0 && v < 0x40) {\n writer.write (8, 0X40 /*cst.PREFIX_SMALL_INT*/ + v);\n } else {\n if (v >= -(1 << 7) && v < (1 << 7))\n writer.write_code(8, 0x00 /*cst.CODE_INT8*/, v);\n else if (v >= -(1 << 15) && v < (1 << 15))\n writer.write_code(16, 0x01 /*cst.CODE_INT16*/, v);\n else\n writer.write_code(32, 0x02 /*cst.CODE_INT32*/, v);\n }\n }\n }\n extern_rec (v);\n while (stack.length > 0) {\n var i = stack.pop ();\n var v = stack.pop ();\n if (i + 1 < v.length) stack.push (v, i + 1);\n extern_rec (v[i]);\n }\n if (intern_obj_table) writer.obj_counter = intern_obj_table.objs.length;\n writer.finalize();\n return writer.chunk;\n }\n} ();\n\n//Provides: caml_output_value_to_string mutable\n//Requires: caml_output_val, caml_string_of_array\nfunction caml_output_value_to_string (v, flags) {\n return caml_string_of_array (caml_output_val (v, flags));\n}\n\n//Provides: caml_output_value_to_bytes mutable\n//Requires: caml_output_val, caml_bytes_of_array\nfunction caml_output_value_to_bytes (v, flags) {\n return caml_bytes_of_array (caml_output_val (v, flags));\n}\n\n//Provides: caml_output_value_to_buffer\n//Requires: caml_output_val, caml_failwith, caml_blit_bytes\nfunction caml_output_value_to_buffer (s, ofs, len, v, flags) {\n var t = caml_output_val (v, flags);\n if (t.length > len) caml_failwith (\"Marshal.to_buffer: buffer overflow\");\n caml_blit_bytes(t, 0, s, ofs, t.length);\n return 0;\n}\n","//Provides: Base_internalhash_fold_int64\n//Requires: caml_hash_mix_int64\nvar Base_internalhash_fold_int64 = caml_hash_mix_int64;\n//Provides: Base_internalhash_fold_int\n//Requires: caml_hash_mix_int\nvar Base_internalhash_fold_int = caml_hash_mix_int;\n//Provides: Base_internalhash_fold_float\n//Requires: caml_hash_mix_float\nvar Base_internalhash_fold_float = caml_hash_mix_float;\n//Provides: Base_internalhash_fold_string\n//Requires: caml_hash_mix_string\nvar Base_internalhash_fold_string = caml_hash_mix_string;\n//Provides: Base_internalhash_get_hash_value\n//Requires: caml_hash_mix_final\nfunction Base_internalhash_get_hash_value(seed) {\n var h = caml_hash_mix_final(seed);\n return h & 0x3FFFFFFF;\n}\n","//Provides: initialize_nat\n//Requires: caml_custom_ops\n//Requires: serialize_nat, deserialize_nat, caml_hash_nat\nfunction initialize_nat() {\n caml_custom_ops[\"_nat\"] =\n { deserialize : deserialize_nat,\n serialize : serialize_nat,\n hash : caml_hash_nat\n }\n}\n\n//Provides: MlNat\nfunction MlNat(x){\n this.data = new globalThis.Int32Array(x);\n // length_nat isn't external, so we have to make the Obj.size\n // work out right. The +2 to array length seems to work.\n this.length = this.data.length + 2\n}\n\nMlNat.prototype.caml_custom = \"_nat\";\n\n//Provides: caml_hash_nat\n//Requires: caml_hash_mix_int, num_digits_nat\nfunction caml_hash_nat(x) {\n var len = num_digits_nat(x, 0, x.data.length);\n var h = 0;\n for (var i = 0; i < len; i++) {\n h = caml_hash_mix_int(h, x.data[i]);\n }\n return h;\n}\n\n\n//Provides: nat_of_array\n//Requires: MlNat\nfunction nat_of_array(l){\n return new MlNat(l);\n}\n\n//Provides: create_nat\n//Requires: MlNat\nfunction create_nat(size) {\n var arr = new MlNat(size);\n for(var i = 0; i < size; i++) {\n arr.data[i] = -1;\n }\n return arr;\n}\n\n//Provides: set_to_zero_nat\nfunction set_to_zero_nat(nat, ofs, len) {\n for(var i = 0; i < len; i++) {\n nat.data[ofs+i] = 0;\n }\n return 0;\n}\n\n//Provides: blit_nat\nfunction blit_nat(nat1, ofs1, nat2, ofs2, len) {\n for(var i = 0; i < len; i++) {\n nat1.data[ofs1+i] = nat2.data[ofs2+i];\n }\n return 0;\n}\n\n//Provides: set_digit_nat\nfunction set_digit_nat(nat, ofs, digit) {\n nat.data[ofs] = digit;\n return 0;\n}\n\n//Provides: nth_digit_nat\nfunction nth_digit_nat(nat, ofs) {\n return nat.data[ofs];\n}\n\n//Provides: set_digit_nat_native\nfunction set_digit_nat_native(nat, ofs, digit) {\n nat.data[ofs] = digit;\n return 0;\n}\n\n//Provides: nth_digit_nat_native\nfunction nth_digit_nat_native(nat, ofs) {\n return nat.data[ofs];\n}\n\n//Provides: num_digits_nat\nfunction num_digits_nat(nat, ofs, len) {\n for(var i = len - 1; i >= 0; i--) {\n if(nat.data[ofs+i] != 0) return i+1;\n }\n return 1; // 0 counts as 1 digit\n}\n\n//Provides: num_leading_zero_bits_in_digit\nfunction num_leading_zero_bits_in_digit(nat, ofs) {\n var a = nat.data[ofs];\n var b = 0;\n if(a & 0xFFFF0000) { b +=16; a >>>=16; }\n if(a & 0xFF00) { b += 8; a >>>= 8; }\n if(a & 0xF0) { b += 4; a >>>= 4; }\n if(a & 12) { b += 2; a >>>= 2; }\n if(a & 2) { b += 1; a >>>= 1; }\n if(a & 1) { b += 1; }\n return 32 - b;\n}\n\n//Provides: is_digit_int\nfunction is_digit_int(nat, ofs) {\n if (nat.data[ofs] >= 0) return 1\n return 0;\n}\n\n//Provides: is_digit_zero\nfunction is_digit_zero(nat, ofs) {\n if(nat.data[ofs] == 0) return 1;\n return 0;\n}\n\n//Provides: is_digit_odd\nfunction is_digit_odd(nat, ofs) {\n if(nat.data[ofs] & 1) return 1;\n return 0;\n}\n\n//Provides: incr_nat\nfunction incr_nat(nat, ofs, len, carry_in) {\n var carry = carry_in;\n for(var i = 0; i < len; i++) {\n var x = (nat.data[ofs+i] >>> 0) + carry;\n nat.data[ofs+i] = (x | 0);\n if(x == (x >>> 0)) {\n carry = 0;\n break;\n } else {\n carry = 1;\n }\n }\n return carry;\n}\n\n// len1 >= len2\n//Provides: add_nat\n//Requires: incr_nat\nfunction add_nat(nat1, ofs1, len1, nat2, ofs2, len2, carry_in) {\n var carry = carry_in;\n for(var i = 0; i < len2; i++) {\n var x = (nat1.data[ofs1+i] >>> 0) + (nat2.data[ofs2+i] >>> 0) + carry;\n nat1.data[ofs1+i] = x\n if(x == (x >>> 0)) {\n carry = 0;\n } else {\n carry = 1;\n }\n }\n return incr_nat(nat1, ofs1+len2, len1-len2, carry);\n}\n\n//Provides: complement_nat\nfunction complement_nat(nat, ofs, len) {\n for(var i = 0; i < len; i++) {\n nat.data[ofs+i] = (-1 >>> 0) - (nat.data[ofs+i] >>> 0);\n }\n}\n\n// ocaml flips carry_in\n//Provides: decr_nat\nfunction decr_nat(nat, ofs, len, carry_in) {\n var borrow = (carry_in == 1) ? 0 : 1;\n for(var i = 0; i < len; i++) {\n var x = (nat.data[ofs+i] >>>0) - borrow;\n nat.data[ofs+i] = x;\n if (x >= 0) {\n borrow = 0;\n break;\n } else {\n borrow = 1;\n }\n }\n return (borrow == 1) ? 0 : 1;\n}\n\n// ocaml flips carry_in\n// len1 >= len2\n//Provides: sub_nat\n//Requires: decr_nat\nfunction sub_nat(nat1, ofs1, len1, nat2, ofs2, len2, carry_in) {\n var borrow = (carry_in == 1) ? 0 : 1;\n for(var i = 0; i < len2; i++) {\n var x = (nat1.data[ofs1+i] >>> 0) - (nat2.data[ofs2+i] >>> 0) - borrow;\n nat1.data[ofs1+i] = x;\n if (x >= 0) {\n borrow = 0;\n } else {\n borrow = 1;\n }\n }\n return decr_nat(nat1, ofs1+len2, len1-len2, (borrow==1)?0:1);\n}\n\n// nat1 += nat2 * nat3[ofs3]\n// len1 >= len2\n//Provides: mult_digit_nat\n//Requires: add_nat, nat_of_array\nfunction mult_digit_nat(nat1, ofs1, len1, nat2, ofs2, len2, nat3, ofs3) {\n var carry = 0;\n var a = (nat3.data[ofs3] >>> 0);\n for(var i = 0; i < len2; i++) {\n var x1 = (nat1.data[ofs1+i] >>> 0) + (nat2.data[ofs2+i] >>> 0) * (a & 0x0000FFFF) + carry;\n var x2 = (nat2.data[ofs2+i] >>> 0) * (a >>> 16);\n carry = Math.floor(x2/65536);\n var x3 = x1 + (x2 % 65536) * 65536;\n nat1.data[ofs1+i] = x3;\n carry += Math.floor(x3/4294967296);\n }\n\n if(len2 < len1 && carry) {\n return add_nat(nat1, ofs1+len2, len1-len2, nat_of_array([carry]), 0, 1, 0);\n } else {\n return carry;\n }\n}\n\n// nat1 += nat2 * nat3\n// len1 >= len2 + len3.\n//Provides: mult_nat\n//Requires: mult_digit_nat\nfunction mult_nat(nat1, ofs1, len1, nat2, ofs2, len2, nat3, ofs3, len3) {\n var carry = 0;\n for(var i = 0; i < len3; i++) {\n carry += mult_digit_nat(nat1, ofs1+i, len1-i, nat2, ofs2, len2, nat3, ofs3+i);\n }\n return carry;\n}\n\n// nat1 = 2 * nat1 + nat2 * nat2\n// len1 >= 2 * len2\n//Provides: square_nat\n//Requires: mult_nat, add_nat\nfunction square_nat(nat1, ofs1, len1, nat2, ofs2, len2) {\n var carry = 0;\n carry += add_nat(nat1, ofs1, len1, nat1, ofs1, len1, 0);\n carry += mult_nat(nat1, ofs1, len1, nat2, ofs2, len2, nat2, ofs2, len2);\n return carry;\n}\n\n\n// 0 <= shift < 32\n//Provides: shift_left_nat\nfunction shift_left_nat(nat1, ofs1, len1, nat2, ofs2, nbits) {\n if(nbits == 0) {\n nat2.data[ofs2] = 0;\n return 0;\n }\n var wrap = 0;\n for(var i = 0; i < len1; i++) {\n var a = (nat1.data[ofs1+i] >>> 0);\n nat1.data[ofs1+i] = (a << nbits) | wrap;\n wrap = a >>> (32 - nbits);\n }\n nat2.data[ofs2] = wrap;\n return 0;\n}\n\n// Assuming c > a, returns [quotient, remainder] of (a<<32 + b)/c\n//Provides: div_helper\nfunction div_helper(a, b, c) {\n var x = a * 65536 + (b>>>16);\n var y = Math.floor(x/c) * 65536;\n var z = (x % c) * 65536;\n var w = z + (b & 0x0000FFFF);\n return [y + Math.floor(w/c), w % c];\n}\n\n// nat1[ofs1+len] < nat2[ofs2]\n//Provides: div_digit_nat\n//Requires: div_helper\nfunction div_digit_nat(natq, ofsq, natr, ofsr, nat1, ofs1, len, nat2, ofs2) {\n var rem = (nat1.data[ofs1+len-1] >>>0);\n // natq[ofsq+len-1] is guaranteed to be zero (due to the MSD requirement),\n // and should not be written to.\n for(var i = len-2; i >= 0; i--) {\n var x = div_helper(rem, (nat1.data[ofs1+i] >>> 0), (nat2.data[ofs2] >>> 0));\n natq.data[ofsq+i] = x[0];\n rem = x[1];\n }\n natr.data[ofsr] = rem;\n return 0;\n}\n\n// nat1[nat2:] := nat1 / nat2\n// nat1[:nat2] := nat1 % nat2\n// len1 > len2, nat2[ofs2+len2-1] > nat1[ofs1+len1-1]\n//Provides: div_nat\n//Requires: div_digit_nat, div_helper, num_leading_zero_bits_in_digit, shift_left_nat, shift_right_nat, create_nat, set_to_zero_nat, mult_digit_nat, sub_nat, compare_nat, nat_of_array\nfunction div_nat(nat1, ofs1, len1, nat2, ofs2, len2) {\n if(len2 == 1) {\n div_digit_nat(nat1, ofs1+1, nat1, ofs1, nat1, ofs1, len1, nat2, ofs2);\n return 0;\n }\n\n var s = num_leading_zero_bits_in_digit(nat2, ofs2+len2-1);\n shift_left_nat(nat2, ofs2, len2, nat_of_array([0]), 0, s);\n shift_left_nat(nat1, ofs1, len1, nat_of_array([0]), 0, s);\n\n var d = (nat2.data[ofs2+len2-1] >>> 0) + 1;\n var a = create_nat(len2+1);\n for (var i = len1 - 1; i >= len2; i--) {\n // Decent lower bound on quo\n var quo = d == 4294967296 ? (nat1.data[ofs1+i] >>> 0) : div_helper((nat1.data[ofs1+i] >>> 0), (nat1.data[ofs1+i-1] >>>0), d)[0];\n set_to_zero_nat(a, 0, len2+1);\n mult_digit_nat(a, 0, len2+1, nat2, ofs2, len2, nat_of_array([quo]), 0);\n sub_nat(nat1, ofs1+i-len2, len2+1, a, 0, len2+1, 1);\n\n while (nat1.data[ofs1+i] != 0 || compare_nat(nat1, ofs1+i-len2, len2, nat2, ofs2, len2) >= 0) {\n quo = quo + 1;\n sub_nat(nat1, ofs1+i-len2, len2+1, nat2, ofs2, len2, 1);\n }\n\n nat1.data[ofs1+i] = quo;\n }\n\n shift_right_nat(nat1, ofs1, len2, nat_of_array([0]), 0, s); // shift remainder\n shift_right_nat(nat2, ofs2, len2, nat_of_array([0]), 0, s); // restore\n return 0;\n}\n\n\n// 0 <= shift < 32\n//Provides: shift_right_nat\nfunction shift_right_nat(nat1, ofs1, len1, nat2, ofs2, nbits) {\n if(nbits == 0) {\n nat2.data[ofs2] = 0;\n return 0;\n }\n var wrap = 0;\n for(var i = len1-1; i >= 0; i--) {\n var a = nat1.data[ofs1+i] >>> 0;\n nat1.data[ofs1+i] = (a >>> nbits) | wrap;\n wrap = a << (32 - nbits);\n }\n nat2.data[ofs2] = wrap;\n return 0;\n}\n\n//Provides: compare_digits_nat\nfunction compare_digits_nat(nat1, ofs1, nat2, ofs2) {\n if(nat1.data[ofs1] > nat2.data[ofs2]) return 1;\n if(nat1.data[ofs1] < nat2.data[ofs2]) return -1;\n return 0;\n}\n\n//Provides: compare_nat\n//Requires: num_digits_nat\nfunction compare_nat(nat1, ofs1, len1, nat2, ofs2, len2) {\n var a = num_digits_nat(nat1, ofs1, len1);\n var b = num_digits_nat(nat2, ofs2, len2);\n if(a > b) return 1;\n if(a < b) return -1;\n for(var i = len1 - 1; i >= 0; i--) {\n if ((nat1.data[ofs1+i] >>> 0) > (nat2.data[ofs2+i] >>> 0)) return 1;\n if ((nat1.data[ofs1+i] >>> 0) < (nat2.data[ofs2+i] >>> 0)) return -1;\n }\n return 0;\n}\n\n//Provides: compare_nat_real\n//Requires: compare_nat\nfunction compare_nat_real(nat1,nat2){\n return compare_nat(nat1,0,nat1.data.length,nat2,0,nat2.data.length);\n}\n\n//Provides: land_digit_nat\nfunction land_digit_nat(nat1, ofs1, nat2, ofs2) {\n nat1.data[ofs1] &= nat2.data[ofs2];\n return 0;\n}\n\n//Provides: lor_digit_nat\nfunction lor_digit_nat(nat1, ofs1, nat2, ofs2) {\n nat1.data[ofs1] |= nat2.data[ofs2];\n return 0;\n}\n\n//Provides: lxor_digit_nat\nfunction lxor_digit_nat(nat1, ofs1, nat2, ofs2) {\n nat1.data[ofs1] ^= nat2.data[ofs2];\n return 0;\n}\n\n\n//Provides: serialize_nat\nfunction serialize_nat(writer, nat, sz){\n var len = nat.data.length;\n writer.write(32, len);\n for(var i = 0; i < len; i++){\n writer.write(32, nat.data[i]);\n }\n sz[0] = len * 4;\n sz[1] = len * 8;\n}\n\n//Provides: deserialize_nat\n//Requires: MlNat\nfunction deserialize_nat(reader, sz){\n var len = reader.read32s();\n var nat = new MlNat(len);\n for(var i = 0; i < len; i++){\n nat.data[i] = reader.read32s();\n }\n sz[0] = len * 4;\n return nat;\n}\n","// Js_of_ocaml library\n// http://www.ocsigen.org/js_of_ocaml/\n// Copyright (C) 2010 Jérôme Vouillon\n// Laboratoire PPS - CNRS Université Paris Diderot\n//\n// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU Lesser General Public License as published by\n// the Free Software Foundation, with linking exception;\n// either version 2.1 of the License, or (at your option) any later version.\n//\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n// GNU Lesser General Public License for more details.\n//\n// You should have received a copy of the GNU Lesser General Public License\n// along with this program; if not, write to the Free Software\n// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n\n///////////// Jslib\n\n//Provides: caml_js_pure_expr const\nfunction caml_js_pure_expr (f) { return f(); }\n\n//Provides: caml_js_set (mutable, const, const)\nfunction caml_js_set(o,f,v) { o[f]=v;return 0}\n//Provides: caml_js_get mutable (const, const)\nfunction caml_js_get(o,f) { return o[f]; }\n//Provides: caml_js_delete (mutable, const)\nfunction caml_js_delete(o,f) { delete o[f]; return 0}\n\n//Provides: caml_js_instanceof (const, const)\nfunction caml_js_instanceof(o,c) { return (o instanceof c) ? 1 : 0; }\n\n//Provides: caml_js_typeof (const)\nfunction caml_js_typeof(o) { return typeof o; }\n\n//Provides:caml_trampoline\nfunction caml_trampoline(res) {\n var c = 1;\n while(res && res.joo_tramp){\n res = res.joo_tramp.apply(null, res.joo_args);\n c++;\n }\n return res;\n}\n\n//Provides:caml_trampoline_return\nfunction caml_trampoline_return(f,args) {\n return {joo_tramp:f,joo_args:args};\n}\n\n//Provides: js_print_stdout (const)\n//Requires: caml_utf16_of_utf8\nfunction js_print_stdout(s) {\n var s = caml_utf16_of_utf8(s);\n var g = globalThis;\n if (g.process && g.process.stdout && g.process.stdout.write) {\n g.process.stdout.write(s)\n } else {\n // Do not output the last \\n if present\n // as console logging display a newline at the end\n if(s.charCodeAt(s.length - 1) == 10)\n s = s.substr(0,s.length - 1 );\n var v = g.console;\n v && v.log && v.log(s);\n }\n}\n//Provides: js_print_stderr (const)\n//Requires: caml_utf16_of_utf8\nfunction js_print_stderr(s) {\n var s = caml_utf16_of_utf8(s);\n var g = globalThis;\n if (g.process && g.process.stdout && g.process.stdout.write) {\n g.process.stderr.write(s)\n } else {\n // Do not output the last \\n if present\n // as console logging display a newline at the end\n if(s.charCodeAt(s.length - 1) == 10)\n s = s.substr(0,s.length - 1 );\n var v = g.console;\n v && v.error && v.error(s);\n }\n}\n\n//Provides: caml_is_js\nfunction caml_is_js() {\n return 1;\n}\n\n//Provides: caml_wrap_exception const (const)\n//Requires: caml_global_data,caml_string_of_jsstring,caml_named_value\n//Requires: caml_return_exn_constant\nfunction caml_wrap_exception(e) {\n if(e instanceof Array) return e;\n //Stack_overflow: chrome, safari\n if(globalThis.RangeError\n && e instanceof globalThis.RangeError\n && e.message\n && e.message.match(/maximum call stack/i))\n return caml_return_exn_constant(caml_global_data.Stack_overflow);\n //Stack_overflow: firefox\n if(globalThis.InternalError\n && e instanceof globalThis.InternalError\n && e.message\n && e.message.match(/too much recursion/i))\n return caml_return_exn_constant(caml_global_data.Stack_overflow);\n //Wrap Error in Js.Error exception\n if(e instanceof globalThis.Error && caml_named_value(\"jsError\"))\n return [0,caml_named_value(\"jsError\"),e];\n //fallback: wrapped in Failure\n return [0,caml_global_data.Failure,caml_string_of_jsstring (String(e))];\n}\n\n// Experimental\n//Provides: caml_exn_with_js_backtrace\n//Requires: caml_global_data\nfunction caml_exn_with_js_backtrace(exn, force) {\n //never reraise for constant exn\n if(!exn.js_error || force || exn[0] == 248) exn.js_error = new globalThis.Error(\"Js exception containing backtrace\");\n return exn;\n}\n\n\n//Provides: caml_js_error_option_of_exception\nfunction caml_js_error_option_of_exception(exn) {\n if(exn.js_error) { return [0, exn.js_error]; }\n return 0;\n}\n\n\n\n//Provides: caml_js_from_bool const (const)\nfunction caml_js_from_bool(x) { return !!x; }\n//Provides: caml_js_to_bool const (const)\nfunction caml_js_to_bool(x) { return +x; }\n//Provides: caml_js_from_float const (const)\nfunction caml_js_from_float(x) { return x; }\n//Provides: caml_js_to_float const (const)\nfunction caml_js_to_float(x) { return x; }\n\n//Provides: caml_js_from_array mutable (shallow)\nfunction caml_js_from_array(a) {\n return a.slice(1);\n}\n//Provides: caml_js_to_array mutable (shallow)\nfunction caml_js_to_array(a) {\n var len = a.length;\n var b = new Array(len+1);\n b[0] = 0;\n for(var i=0;i=0; i--){\n var e = a[i];\n l = [0,e,l];\n }\n return l\n}\n\n//Provides: caml_list_to_js_array const (const)\nfunction caml_list_to_js_array(l){\n var a = [];\n for(; l !== 0; l = l[2]) {\n a.push(l[1]);\n }\n return a;\n}\n\n//Provides: caml_js_var mutable (const)\n//Requires: js_print_stderr\n//Requires: caml_jsstring_of_string\nfunction caml_js_var(x) {\n var x = caml_jsstring_of_string(x);\n //Checks that x has the form ident[.ident]*\n if(!x.match(/^[a-zA-Z_$][a-zA-Z_$0-9]*(\\.[a-zA-Z_$][a-zA-Z_$0-9]*)*$/)){\n js_print_stderr(\"caml_js_var: \\\"\" + x + \"\\\" is not a valid JavaScript variable. continuing ..\");\n //globalThis.console.error(\"Js.Unsafe.eval_string\")\n }\n return eval(x);\n}\n//Provides: caml_js_call (const, mutable, shallow)\n//Requires: caml_js_from_array\nfunction caml_js_call(f, o, args) { return f.apply(o, caml_js_from_array(args)); }\n//Provides: caml_js_fun_call (const, shallow)\n//Requires: caml_js_from_array\nfunction caml_js_fun_call(f, a) {\n switch (a.length) {\n case 1: return f();\n case 2: return f (a[1]);\n case 3: return f (a[1],a[2]);\n case 4: return f (a[1],a[2],a[3]);\n case 5: return f (a[1],a[2],a[3],a[4]);\n case 6: return f (a[1],a[2],a[3],a[4],a[5]);\n case 7: return f (a[1],a[2],a[3],a[4],a[5],a[6]);\n case 8: return f (a[1],a[2],a[3],a[4],a[5],a[6],a[7]);\n }\n return f.apply(null, caml_js_from_array(a));\n}\n//Provides: caml_js_meth_call (mutable, const, shallow)\n//Requires: caml_jsstring_of_string\n//Requires: caml_js_from_array\nfunction caml_js_meth_call(o, f, args) {\n return o[caml_jsstring_of_string(f)].apply(o, caml_js_from_array(args));\n}\n//Provides: caml_js_new (const, shallow)\n//Requires: caml_js_from_array\nfunction caml_js_new(c, a) {\n switch (a.length) {\n case 1: return new c;\n case 2: return new c (a[1]);\n case 3: return new c (a[1],a[2]);\n case 4: return new c (a[1],a[2],a[3]);\n case 5: return new c (a[1],a[2],a[3],a[4]);\n case 6: return new c (a[1],a[2],a[3],a[4],a[5]);\n case 7: return new c (a[1],a[2],a[3],a[4],a[5],a[6]);\n case 8: return new c (a[1],a[2],a[3],a[4],a[5],a[6],a[7]);\n }\n function F() { return c.apply(this, caml_js_from_array(a)); }\n F.prototype = c.prototype;\n return new F;\n}\n//Provides: caml_ojs_new_arr (const, shallow)\n//Requires: caml_js_from_array\nfunction caml_ojs_new_arr(c, a) {\n switch (a.length) {\n case 0: return new c;\n case 1: return new c (a[0]);\n case 2: return new c (a[0],a[1]);\n case 3: return new c (a[0],a[1],a[2]);\n case 4: return new c (a[0],a[1],a[2],a[3]);\n case 5: return new c (a[0],a[1],a[2],a[3],a[4]);\n case 6: return new c (a[0],a[1],a[2],a[3],a[4],a[5]);\n case 7: return new c (a[0],a[1],a[2],a[3],a[4],a[5],a[6]);\n }\n function F() { return c.apply(this, a); }\n F.prototype = c.prototype;\n return new F;\n}\n//Provides: caml_js_wrap_callback const (const)\n//Requires: caml_call_gen\nfunction caml_js_wrap_callback(f) {\n return function () {\n var len = arguments.length;\n if(len > 0){\n var args = new Array(len);\n for (var i = 0; i < len; i++) args[i] = arguments[i];\n return caml_call_gen(f, args);\n } else {\n return caml_call_gen(f, [undefined]);\n }\n }\n}\n\n//Provides: caml_js_wrap_callback_arguments\n//Requires: caml_call_gen\nfunction caml_js_wrap_callback_arguments(f) {\n return function() {\n var len = arguments.length;\n var args = new Array(len);\n for (var i = 0; i < len; i++) args[i] = arguments[i];\n return caml_call_gen(f, [args]);\n }\n}\n//Provides: caml_js_wrap_callback_strict const\n//Requires: caml_call_gen\nfunction caml_js_wrap_callback_strict(arity, f) {\n return function () {\n var n = arguments.length;\n if(n == arity && f.length == arity) return f.apply(null, arguments);\n var args = new Array(arity);\n var len = Math.min(arguments.length, arity)\n for (var i = 0; i < len; i++) args[i] = arguments[i];\n return caml_call_gen(f, args);\n };\n}\n//Provides: caml_js_wrap_meth_callback const (const)\n//Requires: caml_call_gen\nfunction caml_js_wrap_meth_callback(f) {\n return function () {\n var len = arguments.length;\n var args = new Array(len + 1);\n args[0] = this;\n for (var i = 0; i < len; i++) args[i+1] = arguments[i];\n return caml_call_gen(f,args);\n }\n}\n//Provides: caml_js_wrap_meth_callback_arguments const (const)\n//Requires: caml_call_gen\nfunction caml_js_wrap_meth_callback_arguments(f) {\n return function () {\n var len = arguments.length;\n var args = new Array(len);\n for (var i = 0; i < len; i++) args[i] = arguments[i];\n return caml_call_gen(f,[this,args]);\n }\n}\n//Provides: caml_js_wrap_meth_callback_strict const\n//Requires: caml_call_gen\nfunction caml_js_wrap_meth_callback_strict(arity, f) {\n return function () {\n var args = new Array(arity + 1);\n var len = Math.min(arguments.length, arity)\n args[0] = this;\n for (var i = 0; i < len; i++) args[i+1] = arguments[i];\n return caml_call_gen(f, args);\n };\n}\n//Provides: caml_js_wrap_meth_callback_unsafe const (const)\n//Requires: caml_call_gen\nfunction caml_js_wrap_meth_callback_unsafe(f) {\n return function () {\n var len = arguments.length;\n var args = new Array(len + 1);\n args[0] = this;\n for (var i = 0; i < len; i++) args[i+1] = arguments[i];\n return f.apply(null, args); }\n}\n//Provides: caml_js_equals mutable (const, const)\nfunction caml_js_equals (x, y) { return +(x == y); }\n\n//Provides: caml_js_eval_string (const)\n//Requires: caml_jsstring_of_string\nfunction caml_js_eval_string (s) {return eval(caml_jsstring_of_string(s));}\n\n//Provides: caml_js_expr (const)\n//Requires: js_print_stderr\n//Requires: caml_jsstring_of_string\nfunction caml_js_expr(s) {\n js_print_stderr(\"caml_js_expr: fallback to runtime evaluation\\n\");\n return eval(caml_jsstring_of_string(s));}\n\n//Provides: caml_pure_js_expr const (const)\n//Requires: js_print_stderr\n//Requires: caml_jsstring_of_string\nfunction caml_pure_js_expr (s){\n js_print_stderr(\"caml_pure_js_expr: fallback to runtime evaluation\\n\");\n return eval(caml_jsstring_of_string(s));}\n\n//Provides: caml_js_object (object_literal)\n//Requires: caml_jsstring_of_string\nfunction caml_js_object (a) {\n var o = {};\n for (var i = 1; i < a.length; i++) {\n var p = a[i];\n o[caml_jsstring_of_string(p[1])] = p[2];\n }\n return o;\n}\n","///////// BIGSTRING\n\n//Provides: bigstring_alloc\n//Requires: caml_ba_create\nfunction bigstring_alloc(_,size){\n return caml_ba_create(12, 0, [0,size]);\n}\n\n//Provides: bigstring_is_mmapped_stub\nfunction bigstring_is_mmapped_stub(x){\n return 0;\n}\n\n//Provides: bigstring_blit_stub\n//Requires: caml_bigstring_blit_ba_to_ba\nfunction bigstring_blit_stub(s1, i1, s2, i2, len){\n return caml_bigstring_blit_ba_to_ba(s1,i1,s2,i2,len);\n}\n\n//Provides: bigstring_blit_bytes_bigstring_stub\n//Requires: caml_bigstring_blit_bytes_to_ba\nfunction bigstring_blit_bytes_bigstring_stub(src, src_pos, dst, dst_pos, len){\n return caml_bigstring_blit_bytes_to_ba(src,src_pos,dst,dst_pos,len);\n}\n\n//Provides: bigstring_blit_bigstring_bytes_stub\n//Requires: caml_bigstring_blit_ba_to_bytes\nfunction bigstring_blit_bigstring_bytes_stub(src, src_pos, dst, dst_pos, len){\n return caml_bigstring_blit_ba_to_bytes(src,src_pos,dst,dst_pos,len);\n}\n\n//Provides: bigstring_blit_string_bigstring_stub\n//Requires: caml_bigstring_blit_string_to_ba\nfunction bigstring_blit_string_bigstring_stub(src, src_pos, dst, dst_pos, len){\n return caml_bigstring_blit_string_to_ba(src,src_pos,dst,dst_pos,len);\n}\n\n//Provides: bigstring_memset_stub\n//Requires: caml_ba_set_1\nfunction bigstring_memset_stub(bigstring, v_pos, v_len, v_char) {\n for (var i = 0; i < v_len; i++) {\n caml_ba_set_1(bigstring, v_pos + i, v_char);\n }\n}\n\n//Provides: bigstring_memcmp_stub\n//Requires: caml_ba_get_1\nfunction bigstring_memcmp_stub(v_s1, v_s1_pos, v_s2, v_s2_pos, v_len){\n for (var i = 0; i < v_len; i++) {\n var a = caml_ba_get_1(v_s1,v_s1_pos + i);\n var b = caml_ba_get_1(v_s2,v_s2_pos + i);\n if (a < b) return -1;\n if (a > b) return 1;\n }\n return 0;\n}\n\n//Provides: internalhash_fold_bigstring\n//Requires: caml_hash_mix_bigstring\nvar internalhash_fold_bigstring = caml_hash_mix_bigstring\n\n//Provides: bigstring_find\n//Requires: caml_ba_get_1\nfunction bigstring_find(bs, chr, pos, len){\n while(len > 0){\n if(caml_ba_get_1(bs,pos) == chr) return pos;\n pos++;\n len--;\n }\n return -1;\n}\n","///////// BIGSTRING\n\n//Provides: caml_hash_mix_bigstring\n//Requires: caml_hash_mix_bytes_arr\nfunction caml_hash_mix_bigstring(h, bs) {\n return caml_hash_mix_bytes_arr(h,bs.data);\n}\n\n//Provides: bigstring_to_array_buffer mutable\nfunction bigstring_to_array_buffer(bs) {\n return bs.data.buffer\n}\n\n//Provides: bigstring_to_typed_array mutable\nfunction bigstring_to_typed_array(bs) {\n return bs.data\n}\n\n//Provides: bigstring_of_array_buffer mutable\n//Requires: caml_ba_create_unsafe\nfunction bigstring_of_array_buffer(ab) {\n var ta = new globalThis.Uint8Array(ab);\n return caml_ba_create_unsafe(12, 0, [ta.length], ta);\n}\n\n//Provides: bigstring_of_typed_array mutable\n//Requires: caml_ba_create_unsafe\nfunction bigstring_of_typed_array(ba) {\n var ta = new globalThis.Uint8Array(ba.buffer, ba.byteOffset, ba.length * ba.BYTES_PER_ELEMENT);\n return caml_ba_create_unsafe(12, 0, [ta.length], ta);\n}\n\n//Provides: caml_bigstring_memcmp\n//Requires: caml_ba_get_1\nfunction caml_bigstring_memcmp(s1, pos1, s2, pos2, len){\n for (var i = 0; i < len; i++) {\n var a = caml_ba_get_1(s1,pos1 + i);\n var b = caml_ba_get_1(s2,pos2 + i);\n if (a < b) return -1;\n if (a > b) return 1;\n }\n return 0;\n}\n\n//Provides: caml_bigstring_blit_ba_to_ba\n//Requires: caml_invalid_argument, caml_array_bound_error\nfunction caml_bigstring_blit_ba_to_ba(ba1, pos1, ba2, pos2, len){\n if(12 != ba1.kind)\n caml_invalid_argument(\"caml_bigstring_blit_ba_to_ba: kind mismatch\");\n if(12 != ba2.kind)\n caml_invalid_argument(\"caml_bigstring_blit_ba_to_ba: kind mismatch\");\n if(len == 0) return 0;\n var ofs1 = ba1.offset(pos1);\n var ofs2 = ba2.offset(pos2);\n if(ofs1 + len > ba1.data.length){\n caml_array_bound_error();\n }\n if(ofs2 + len > ba2.data.length){\n caml_array_bound_error();\n }\n var slice = ba1.data.subarray(ofs1,ofs1+len);\n ba2.data.set(slice,pos2);\n return 0\n}\n\n//Provides: caml_bigstring_blit_string_to_ba\n//Requires: caml_invalid_argument, caml_array_bound_error, caml_array_of_string\n//Requires: caml_ml_string_length\nfunction caml_bigstring_blit_string_to_ba(str1, pos1, ba2, pos2, len){\n if(12 != ba2.kind)\n caml_invalid_argument(\"caml_bigstring_blit_string_to_ba: kind mismatch\");\n if(len == 0) return 0;\n var ofs2 = ba2.offset(pos2);\n if(pos1 + len > caml_ml_string_length(str1)) {\n caml_array_bound_error();\n }\n if(ofs2 + len > ba2.data.length) {\n caml_array_bound_error();\n }\n var slice = caml_array_of_string(str1).slice(pos1,pos1 + len);\n ba2.data.set(slice,ofs2);\n return 0\n}\n\n//Provides: caml_bigstring_blit_bytes_to_ba\n//Requires: caml_invalid_argument, caml_array_bound_error, caml_array_of_bytes\n//Requires: caml_ml_bytes_length\nfunction caml_bigstring_blit_bytes_to_ba(str1, pos1, ba2, pos2, len){\n if(12 != ba2.kind)\n caml_invalid_argument(\"caml_bigstring_blit_string_to_ba: kind mismatch\");\n if(len == 0) return 0;\n var ofs2 = ba2.offset(pos2);\n if(pos1 + len > caml_ml_bytes_length(str1)) {\n caml_array_bound_error();\n }\n if(ofs2 + len > ba2.data.length) {\n caml_array_bound_error();\n }\n var slice = caml_array_of_bytes(str1).slice(pos1,pos1 + len);\n ba2.data.set(slice,ofs2);\n return 0\n}\n\n//Provides: caml_bigstring_blit_ba_to_bytes\n//Requires: caml_invalid_argument, caml_array_bound_error\n//Requires: caml_blit_bytes, caml_bytes_of_array\n//Requires: caml_ml_bytes_length\nfunction caml_bigstring_blit_ba_to_bytes(ba1, pos1, bytes2, pos2, len){\n if(12 != ba1.kind)\n caml_invalid_argument(\"caml_bigstring_blit_string_to_ba: kind mismatch\");\n if(len == 0) return 0;\n var ofs1 = ba1.offset(pos1);\n if(ofs1 + len > ba1.data.length){\n caml_array_bound_error();\n }\n if(pos2 + len > caml_ml_bytes_length(bytes2)){\n caml_array_bound_error();\n }\n var slice = ba1.data.slice(ofs1, ofs1+len);\n caml_blit_bytes(caml_bytes_of_array(slice), 0, bytes2, pos2, len);\n return 0\n}\n","/*----------------------------------------------------------------------------\n Copyright (c) 2017 Inhabited Type LLC.\n\n All rights reserved.\n\n Redistribution and use in source and binary forms, with or without\n modification, are permitted provided that the following conditions\n are met:\n\n 1. Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n\n 2. Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n\n 3. Neither the name of the author nor the names of his contributors\n may be used to endorse or promote products derived from this software\n without specific prior written permission.\n\n THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS ``AS IS'' AND ANY EXPRESS\n OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\n WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR\n ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\n DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS\n OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\n HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,\n STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN\n ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n POSSIBILITY OF SUCH DAMAGE.\n ----------------------------------------------------------------------------*/\n\n//Provides: bigstringaf_blit_to_bytes\n//Requires: caml_string_unsafe_set, caml_ba_get_1\nfunction bigstringaf_blit_to_bytes(src, src_off, dst, dst_off, len) {\n for (var i = 0; i < len; i++) {\n caml_string_unsafe_set(dst, dst_off + i, caml_ba_get_1(src, src_off + i));\n }\n}\n\n//Provides: bigstringaf_blit_to_bigstring\n//Requires: caml_ba_set_1, caml_ba_get_1\nfunction bigstringaf_blit_to_bigstring(src, src_off, dst, dst_off, len) {\n for (var i = 0; i < len; i++) {\n caml_ba_set_1(dst, dst_off + i, caml_ba_get_1(src, src_off + i));\n }\n}\n\n//Provides: bigstringaf_blit_from_bytes\n//Requires: caml_ba_set_1, caml_string_unsafe_get\nfunction bigstringaf_blit_from_bytes(src, src_off, dst, dst_off, len) {\n for (var i = 0; i < len; i++) {\n caml_ba_set_1(dst, dst_off + i, caml_string_unsafe_get(src, src_off + i));\n }\n}\n\n//Provides: bigstringaf_memcmp_bigstring\n//Requires: caml_ba_get_1, caml_int_compare\nfunction bigstringaf_memcmp_bigstring(ba1, ba1_off, ba2, ba2_off, len) {\n for (var i = 0; i < len; i++) {\n var c = caml_int_compare(caml_ba_get_1(ba1, ba1_off + i), caml_ba_get_1(ba2, ba2_off + i));\n if (c != 0) return c\n }\n return 0;\n}\n\n//Provides: bigstringaf_memcmp_string\n//Requires: caml_ba_get_1, caml_int_compare, caml_string_unsafe_get\nfunction bigstringaf_memcmp_string(ba, ba_off, str, str_off, len) {\n for (var i = 0; i < len; i++) {\n var c = caml_int_compare(caml_ba_get_1(ba, ba_off + i), caml_string_unsafe_get(str, str_off + i));\n if (c != 0) return c\n }\n return 0;\n}\n","///////// BIN_PROT\n\n//Provides: caml_check_bound_bigstring\n//Requires: caml_array_bound_error\nfunction caml_check_bound_bigstring(bigstring, i){\n if (i >>> 0 >= bigstring.data.length) caml_array_bound_error();\n}\n\n//Provides: bin_prot_blit_buf_float_array_stub\n//Requires: caml_check_bound, caml_check_bound_bigstring\nfunction bin_prot_blit_buf_float_array_stub(src_pos, src, dst_pos, dst, len){\n if(len == 0) return 0;\n caml_check_bound(dst,dst_pos); // first pos\n caml_check_bound(dst,dst_pos+len-1); // last pos\n caml_check_bound_bigstring(src, src_pos); /* first pos */\n caml_check_bound_bigstring(src, src_pos + len * 8 - 1); /* last pos */\n var view = new joo_global_object.Float64Array(len);\n var buffer = new joo_global_object.Uint8Array(view.buffer);\n buffer.set(src.data.subarray(src_pos, src_pos + (len * 8)));\n for(var i = 0; i < len; i++){\n // [+ 1] because the tag is at pos 0 \n dst[dst_pos+i+1] = view[i];\n }\n return 0\n}\n//Provides: bin_prot_blit_buf_bytes_stub\n//Requires: caml_bigstring_blit_ba_to_bytes\nfunction bin_prot_blit_buf_bytes_stub(src_pos, src, dst_pos, dst, len){\n return caml_bigstring_blit_ba_to_bytes(src, src_pos, dst, dst_pos, len);\n}\n//Provides: bin_prot_blit_float_array_buf_stub\n//Requires: caml_check_bound, caml_check_bound_bigstring\nfunction bin_prot_blit_float_array_buf_stub(src_pos,src, dst_pos, dst, len){\n if(len == 0) return 0 \n caml_check_bound (src, src_pos); // first pos \n caml_check_bound (src, src_pos + len - 1); // last pos\n caml_check_bound_bigstring(dst, dst_pos); /* first pos */\n caml_check_bound_bigstring(dst, dst_pos + len * 8 - 1); /* last pos */\n // [+ 1] because the tag is at pos 0\n src_pos = src_pos + 1\n var float64 = new joo_global_object.Float64Array(src.slice(src_pos,src_pos + len));\n var float64_uint8 = new joo_global_object.Uint8Array(float64.buffer);\n var view = dst.data.subarray(dst_pos, dst_pos + (len * 8));\n view.set(float64_uint8);\n return 0\n}\n//Provides: bin_prot_blit_string_buf_stub\n//Requires: caml_bigstring_blit_string_to_ba\nfunction bin_prot_blit_string_buf_stub (src_pos, src, dst_pos, dst, len){\n return caml_bigstring_blit_string_to_ba(src,src_pos, dst, dst_pos,len);\n}\n//Provides: bin_prot_blit_bytes_buf_stub\n//Requires: caml_bigstring_blit_string_to_ba\nfunction bin_prot_blit_bytes_buf_stub (src_pos, src, dst_pos, dst, len){\n return caml_bigstring_blit_string_to_ba(src,src_pos, dst, dst_pos,len);\n}\n\n//Provides: bin_prot_blit_buf_stub\n//Requires: caml_bigstring_blit_ba_to_ba, bigstring_of_typed_array\nfunction bin_prot_blit_buf_stub (src_pos, src, dst_pos, dst, len){\n // [bin_prot_blit_buf_stub] is used with mixed bigarray kinds.\n // Converter everything to bigarray of char before the blit.\n if(src.kind != 12) // 12 is the char kind\n src = bigstring_of_typed_array(src.data);\n if(dst.kind != 12) // 12 is the char kind\n dst = bigstring_of_typed_array(dst.data);\n return caml_bigstring_blit_ba_to_ba(src,src_pos,dst,dst_pos,len);\n}\n","// Js_of_ocaml runtime support\n// http://www.ocsigen.org/js_of_ocaml/\n//\n// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU Lesser General Public License as published by\n// the Free Software Foundation, with linking exception;\n// either version 2.1 of the License, or (at your option) any later version.\n//\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n// GNU Lesser General Public License for more details.\n//\n// You should have received a copy of the GNU Lesser General Public License\n// along with this program; if not, write to the Free Software\n// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n\n///////////// Array\n\n//Provides: caml_array_sub mutable\nfunction caml_array_sub (a, i, len) {\n var a2 = new Array(len+1);\n a2[0]=0;\n for(var i2 = 1, i1= i+1; i2 <= len; i2++,i1++ ){\n a2[i2]=a[i1];\n }\n return a2;\n}\n\n//Provides: caml_array_append mutable\nfunction caml_array_append(a1, a2) {\n var l1 = a1.length, l2 = a2.length;\n var l = l1+l2-1\n var a = new Array(l);\n a[0] = 0;\n var i = 1,j = 1;\n for(;i= 1; j--) a2[i2 + j] = a1[i1 + j];\n };\n return 0;\n}\n\n//Provides: caml_floatarray_blit\nfunction caml_floatarray_blit(a1, i1, a2, i2, len) {\n if (i2 <= i1) {\n for (var j = 1; j <= len; j++) a2[i2 + j] = a1[i1 + j];\n } else {\n for (var j = len; j >= 1; j--) a2[i2 + j] = a1[i1 + j];\n };\n return 0;\n}\n\n///////////// Pervasive\n//Provides: caml_array_set (mutable, const, const)\n//Requires: caml_array_bound_error\nfunction caml_array_set (array, index, newval) {\n if ((index < 0) || (index >= array.length - 1)) caml_array_bound_error();\n array[index+1]=newval; return 0;\n}\n\n//Provides: caml_array_get mutable (const, const)\n//Requires: caml_array_bound_error\nfunction caml_array_get (array, index) {\n if ((index < 0) || (index >= array.length - 1)) caml_array_bound_error();\n return array[index+1];\n}\n\n//Provides: caml_array_fill\nfunction caml_array_fill(array, ofs, len, v){\n for(var i = 0; i < len; i++){\n array[ofs+i+1] = v;\n }\n return 0;\n}\n\n//Provides: caml_check_bound (const, const)\n//Requires: caml_array_bound_error\nfunction caml_check_bound (array, index) {\n if (index >>> 0 >= array.length - 1) caml_array_bound_error();\n return array;\n}\n\n//Provides: caml_make_vect const (const, const)\n//Requires: caml_array_bound_error\nfunction caml_make_vect (len, init) {\n if (len < 0) caml_array_bound_error();\n var len = len + 1 | 0;\n var b = new Array(len);\n b[0]=0;\n for (var i = 1; i < len; i++) b[i] = init;\n return b;\n}\n\n//Provides: caml_make_float_vect const (const)\n//Requires: caml_array_bound_error\nfunction caml_make_float_vect(len){\n if (len < 0) caml_array_bound_error();\n var len = len + 1 | 0;\n var b = new Array(len);\n b[0]=254;\n for (var i = 1; i < len; i++) b[i] = 0;\n return b\n}\n//Provides: caml_floatarray_create const (const)\n//Requires: caml_array_bound_error\nfunction caml_floatarray_create(len){\n if (len < 0) caml_array_bound_error();\n var len = len + 1 | 0;\n var b = new Array(len);\n b[0]=254;\n for (var i = 1; i < len; i++) b[i] = 0;\n return b\n}\n","// Js_of_ocaml runtime support\n// http://www.ocsigen.org/js_of_ocaml/\n//\n// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU Lesser General Public License as published by\n// the Free Software Foundation, with linking exception;\n// either version 2.1 of the License, or (at your option) any later version.\n//\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n// GNU Lesser General Public License for more details.\n//\n// You should have received a copy of the GNU Lesser General Public License\n// along with this program; if not, write to the Free Software\n// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n\n//Provides: caml_ml_debug_info_status const\nfunction caml_ml_debug_info_status () { return 0; }\n//Provides: caml_backtrace_status const\nfunction caml_backtrace_status () { return 0; }\n//Provides: caml_get_exception_backtrace const\nfunction caml_get_exception_backtrace () { return 0; }\n//Provides: caml_get_exception_raw_backtrace const\nfunction caml_get_exception_raw_backtrace () { return [0]; }\n//Provides: caml_record_backtrace\nfunction caml_record_backtrace () { return 0; }\n//Provides: caml_convert_raw_backtrace const\nfunction caml_convert_raw_backtrace () { return [0]; }\n//Provides: caml_raw_backtrace_length\nfunction caml_raw_backtrace_length() { return 0; }\n//Provides: caml_raw_backtrace_next_slot\nfunction caml_raw_backtrace_next_slot() { return 0 }\n//Provides: caml_raw_backtrace_slot\n//Requires: caml_invalid_argument\nfunction caml_raw_backtrace_slot () {\n caml_invalid_argument(\"Printexc.get_raw_backtrace_slot: index out of bounds\");\n}\n//Provides: caml_restore_raw_backtrace\nfunction caml_restore_raw_backtrace(exn, bt) { return 0 }\n//Provides: caml_get_current_callstack const\nfunction caml_get_current_callstack () { return [0]; }\n\n//Provides: caml_convert_raw_backtrace_slot\n//Requires: caml_failwith\nfunction caml_convert_raw_backtrace_slot(){\n caml_failwith(\"caml_convert_raw_backtrace_slot\");\n}\n","// Provides: plonk_wasm\nvar plonk_wasm = require('./plonk_wasm.js')","/* global joo_global_object, plonk_wasm, caml_js_to_bool, caml_jsstring_of_string,\n caml_string_of_jsstring\n caml_create_bytes, caml_bytes_unsafe_set, caml_bytes_unsafe_get, caml_ml_bytes_length,\n UInt64, caml_int64_of_int32\n*/\n\n// Provides: caml_get_field_of_caml_record\nvar caml_get_field_of_caml_record = function (caml_record, i) {\n // Get the ith field of the record [record]\n // The runtime representation of a record is [0, field1, field2, ...], like\n // arrays and tuples, see https://github.com/ocsigen/js_of_ocaml/blob/4.0.0/README.md#data-representation\n // If js_of_ocaml is updated, this has to be reviewed.\n return caml_record[1 + i];\n};\n\n// Provides: caml_bytes_of_uint8array\n// Requires: caml_create_bytes, caml_bytes_unsafe_set\nvar caml_bytes_of_uint8array = function (uint8array) {\n var length = uint8array.length;\n var ocaml_bytes = caml_create_bytes(length);\n for (var i = 0; i < length; i++) {\n // No need to convert here: OCaml Char.t is just an int under the hood.\n caml_bytes_unsafe_set(ocaml_bytes, i, uint8array[i]);\n }\n return ocaml_bytes;\n};\n\n// Provides: caml_bytes_to_uint8array\n// Requires: caml_ml_bytes_length, caml_bytes_unsafe_get\nvar caml_bytes_to_uint8array = function (ocaml_bytes) {\n var length = caml_ml_bytes_length(ocaml_bytes);\n var bytes = new joo_global_object.Uint8Array(length);\n for (var i = 0; i < length; i++) {\n // No need to convert here: OCaml Char.t is just an int under the hood.\n bytes[i] = caml_bytes_unsafe_get(ocaml_bytes, i);\n }\n return bytes;\n};\n\n// Provides: caml_bigint_256_of_numeral\n// Requires: plonk_wasm, caml_jsstring_of_string\nvar caml_bigint_256_of_numeral = function (s, len, base) {\n return plonk_wasm.caml_bigint_256_of_numeral(\n caml_jsstring_of_string(s),\n len,\n base\n );\n};\n\n// Provides: caml_bigint_256_of_decimal_string\n// Requires: plonk_wasm, caml_jsstring_of_string\nvar caml_bigint_256_of_decimal_string = function (s) {\n return plonk_wasm.caml_bigint_256_of_decimal_string(\n caml_jsstring_of_string(s)\n );\n};\n\n// Provides: caml_create_rust_empty_vector\nvar caml_create_rust_empty_vector = function () {\n return new joo_global_object.Uint32Array(0);\n};\n\n// Provides: caml_is_empty_caml_array\nvar caml_is_empty_caml_array = function(caml_array) {\n // An empty caml array will only be the value [0] as a caml array [v1; v2;,\n // ...] is\n // represented as a JavaScript array [0, v1, v2, ...] where [0] is the runtime\n // tag\n return caml_array.length === 1;\n};\n\n// Provides: caml_bigint_256_num_limbs\n// Requires: plonk_wasm\nvar caml_bigint_256_num_limbs = plonk_wasm.caml_bigint_256_num_limbs;\n\n// Provides: caml_bigint_256_bytes_per_limb\n// Requires: plonk_wasm\nvar caml_bigint_256_bytes_per_limb = plonk_wasm.caml_bigint_256_bytes_per_limb;\n\n// Provides: caml_bigint_256_div\n// Requires: plonk_wasm\nvar caml_bigint_256_div = plonk_wasm.caml_bigint_256_div;\n\n// Provides: caml_bigint_256_compare\n// Requires: plonk_wasm\nvar caml_bigint_256_compare = plonk_wasm.caml_bigint_256_compare;\n\n// Provides: caml_bigint_256_print\n// Requires: plonk_wasm\nvar caml_bigint_256_print = plonk_wasm.caml_bigint_256_print;\n\n// Provides: caml_bigint_256_to_string\n// Requires: plonk_wasm, caml_string_of_jsstring\nvar caml_bigint_256_to_string = function (x) {\n return caml_string_of_jsstring(plonk_wasm.caml_bigint_256_to_string(x));\n};\n\n// Provides: caml_bigint_256_test_bit\n// Requires: plonk_wasm, caml_js_to_bool\nvar caml_bigint_256_test_bit = function (x, i) {\n return caml_js_to_bool(plonk_wasm.caml_bigint_256_test_bit(x, i));\n};\n\n// Provides: caml_bigint_256_to_bytes\n// Requires: plonk_wasm, caml_bytes_of_uint8array\nvar caml_bigint_256_to_bytes = function (x) {\n return caml_bytes_of_uint8array(plonk_wasm.caml_bigint_256_to_bytes(x));\n};\n\n// Provides: caml_bigint_256_of_bytes\n// Requires: plonk_wasm, caml_bytes_to_uint8array\nvar caml_bigint_256_of_bytes = function (ocaml_bytes) {\n return plonk_wasm.caml_bigint_256_of_bytes(\n caml_bytes_to_uint8array(ocaml_bytes)\n );\n};\n\n// Provides: caml_bigint_256_deep_copy\n// Requires: plonk_wasm\nvar caml_bigint_256_deep_copy = plonk_wasm.caml_bigint_256_deep_copy;\n\n// Provides: caml_pasta_fp_copy\nvar caml_pasta_fp_copy = function (x, y) {\n for (var i = 0, l = x.length; i < l; i++) {\n x[i] = y[i];\n }\n};\n\n// Provides: caml_option_of_maybe_undefined\nvar caml_option_of_maybe_undefined = function (x) {\n if (x === undefined) {\n return 0; // None\n } else {\n return [0, x]; // Some(x)\n }\n};\n\n// Provides: caml_option_to_maybe_undefined\nvar caml_option_to_maybe_undefined = function (x) {\n if (x === 0) {\n // None\n return undefined;\n } else {\n return x[1];\n }\n};\n\n// Provides: caml_pasta_fp_size_in_bits\n// Requires: plonk_wasm\nvar caml_pasta_fp_size_in_bits = plonk_wasm.caml_pasta_fp_size_in_bits;\n\n// Provides: caml_pasta_fp_size\n// Requires: plonk_wasm\nvar caml_pasta_fp_size = plonk_wasm.caml_pasta_fp_size;\n\n// Provides: caml_pasta_fp_add\n// Requires: plonk_wasm\nvar caml_pasta_fp_add = plonk_wasm.caml_pasta_fp_add;\n\n// Provides: caml_pasta_fp_sub\n// Requires: plonk_wasm\nvar caml_pasta_fp_sub = plonk_wasm.caml_pasta_fp_sub;\n\n// Provides: caml_pasta_fp_negate\n// Requires: plonk_wasm\nvar caml_pasta_fp_negate = plonk_wasm.caml_pasta_fp_negate;\n\n// Provides: caml_pasta_fp_mul\n// Requires: plonk_wasm\nvar caml_pasta_fp_mul = plonk_wasm.caml_pasta_fp_mul;\n\n// Provides: caml_pasta_fp_div\n// Requires: plonk_wasm\nvar caml_pasta_fp_div = plonk_wasm.caml_pasta_fp_div;\n\n// Provides: caml_pasta_fp_inv\n// Requires: plonk_wasm, caml_option_of_maybe_undefined\nvar caml_pasta_fp_inv = function (x) {\n return caml_option_of_maybe_undefined(plonk_wasm.caml_pasta_fp_inv(x));\n};\n\n// Provides: caml_pasta_fp_square\n// Requires: plonk_wasm\nvar caml_pasta_fp_square = plonk_wasm.caml_pasta_fp_square;\n\n// Provides: caml_pasta_fp_is_square\n// Requires: plonk_wasm, caml_js_to_bool\nvar caml_pasta_fp_is_square = function (x) {\n return caml_js_to_bool(plonk_wasm.caml_pasta_fp_is_square(x));\n};\n\n// Provides: caml_pasta_fp_sqrt\n// Requires: plonk_wasm, caml_option_of_maybe_undefined\nvar caml_pasta_fp_sqrt = function (x) {\n return caml_option_of_maybe_undefined(plonk_wasm.caml_pasta_fp_sqrt(x));\n};\n\n// Provides: caml_pasta_fp_of_int\n// Requires: plonk_wasm\nvar caml_pasta_fp_of_int = plonk_wasm.caml_pasta_fp_of_int;\n\n// Provides: caml_pasta_fp_to_string\n// Requires: plonk_wasm, caml_string_of_jsstring\nvar caml_pasta_fp_to_string = function (x) {\n return caml_string_of_jsstring(plonk_wasm.caml_pasta_fp_to_string(x));\n};\n\n// Provides: caml_pasta_fp_of_string\n// Requires: plonk_wasm, caml_jsstring_of_string\nvar caml_pasta_fp_of_string = function (x) {\n return plonk_wasm.caml_pasta_fp_of_string(caml_jsstring_of_string(x));\n};\n\n// Provides: caml_pasta_fp_print\n// Requires: plonk_wasm\nvar caml_pasta_fp_print = plonk_wasm.caml_pasta_fp_print;\n\n// Provides: caml_pasta_fp_mut_add\n// Requires: caml_pasta_fp_copy, caml_pasta_fp_add\nvar caml_pasta_fp_mut_add = function (x, y) {\n caml_pasta_fp_copy(x, caml_pasta_fp_add(x, y));\n};\n\n// Provides: caml_pasta_fp_mut_sub\n// Requires: caml_pasta_fp_copy, caml_pasta_fp_sub\nvar caml_pasta_fp_mut_sub = function (x, y) {\n caml_pasta_fp_copy(x, caml_pasta_fp_sub(x, y));\n};\n\n// Provides: caml_pasta_fp_mut_mul\n// Requires: caml_pasta_fp_copy, caml_pasta_fp_mul\nvar caml_pasta_fp_mut_mul = function (x, y) {\n caml_pasta_fp_copy(x, caml_pasta_fp_mul(x, y));\n};\n\n// Provides: caml_pasta_fp_mut_square\n// Requires: caml_pasta_fp_copy, caml_pasta_fp_square\nvar caml_pasta_fp_mut_square = function (x) {\n caml_pasta_fp_copy(x, caml_pasta_fp_square(x));\n};\n\n// Provides: caml_pasta_fp_compare\n// Requires: plonk_wasm\nvar caml_pasta_fp_compare = plonk_wasm.caml_pasta_fp_compare;\n\n// Provides: caml_pasta_fp_equal\n// Requires: plonk_wasm\nvar caml_pasta_fp_equal = plonk_wasm.caml_pasta_fp_equal;\n\n// Provides: caml_pasta_fp_random\n// Requires: plonk_wasm\nvar caml_pasta_fp_random = plonk_wasm.caml_pasta_fp_random;\n\n// Provides: caml_pasta_fp_rng\n// Requires: plonk_wasm\nvar caml_pasta_fp_rng = plonk_wasm.caml_pasta_fp_rng;\n\n// Provides: caml_pasta_fp_to_bigint\n// Requires: plonk_wasm\nvar caml_pasta_fp_to_bigint = plonk_wasm.caml_pasta_fp_to_bigint;\n\n// Provides: caml_pasta_fp_of_bigint\n// Requires: plonk_wasm\nvar caml_pasta_fp_of_bigint = plonk_wasm.caml_pasta_fp_of_bigint;\n\n// Provides: caml_pasta_fp_two_adic_root_of_unity\n// Requires: plonk_wasm\nvar caml_pasta_fp_two_adic_root_of_unity =\n plonk_wasm.caml_pasta_fp_two_adic_root_of_unity;\n\n// Provides: caml_pasta_fp_domain_generator\n// Requires: plonk_wasm\nvar caml_pasta_fp_domain_generator = plonk_wasm.caml_pasta_fp_domain_generator;\n\n// Provides: caml_pasta_fp_to_bytes\n// Requires: plonk_wasm, caml_bytes_of_uint8array\nvar caml_pasta_fp_to_bytes = function (x) {\n var res = plonk_wasm.caml_pasta_fp_to_bytes(x);\n return caml_bytes_of_uint8array(plonk_wasm.caml_pasta_fp_to_bytes(x));\n};\n\n// Provides: caml_pasta_fp_of_bytes\n// Requires: plonk_wasm, caml_bytes_to_uint8array\nvar caml_pasta_fp_of_bytes = function (ocaml_bytes) {\n return plonk_wasm.caml_pasta_fp_of_bytes(\n caml_bytes_to_uint8array(ocaml_bytes)\n );\n};\n\n// Provides: caml_pasta_fp_deep_copy\n// Requires: plonk_wasm\nvar caml_pasta_fp_deep_copy = plonk_wasm.caml_pasta_fp_deep_copy;\n\n// Provides: caml_pasta_fq_copy\nvar caml_pasta_fq_copy = function (x, y) {\n for (var i = 0, l = x.length; i < l; i++) {\n x[i] = y[i];\n }\n};\n\n// Provides: caml_pasta_fq_size_in_bits\n// Requires: plonk_wasm\nvar caml_pasta_fq_size_in_bits = plonk_wasm.caml_pasta_fq_size_in_bits;\n\n// Provides: caml_pasta_fq_size\n// Requires: plonk_wasm\nvar caml_pasta_fq_size = plonk_wasm.caml_pasta_fq_size;\n\n// Provides: caml_pasta_fq_add\n// Requires: plonk_wasm\nvar caml_pasta_fq_add = plonk_wasm.caml_pasta_fq_add;\n\n// Provides: caml_pasta_fq_sub\n// Requires: plonk_wasm\nvar caml_pasta_fq_sub = plonk_wasm.caml_pasta_fq_sub;\n\n// Provides: caml_pasta_fq_negate\n// Requires: plonk_wasm\nvar caml_pasta_fq_negate = plonk_wasm.caml_pasta_fq_negate;\n\n// Provides: caml_pasta_fq_mul\n// Requires: plonk_wasm\nvar caml_pasta_fq_mul = plonk_wasm.caml_pasta_fq_mul;\n\n// Provides: caml_pasta_fq_div\n// Requires: plonk_wasm\nvar caml_pasta_fq_div = plonk_wasm.caml_pasta_fq_div;\n\n// Provides: caml_pasta_fq_inv\n// Requires: plonk_wasm, caml_option_of_maybe_undefined\nvar caml_pasta_fq_inv = function (x) {\n return caml_option_of_maybe_undefined(plonk_wasm.caml_pasta_fq_inv(x));\n};\n\n// Provides: caml_pasta_fq_square\n// Requires: plonk_wasm\nvar caml_pasta_fq_square = plonk_wasm.caml_pasta_fq_square;\n\n// Provides: caml_pasta_fq_is_square\n// Requires: plonk_wasm, caml_js_to_bool\nvar caml_pasta_fq_is_square = function (x) {\n return caml_js_to_bool(plonk_wasm.caml_pasta_fq_is_square(x));\n};\n\n// Provides: caml_pasta_fq_sqrt\n// Requires: plonk_wasm, caml_option_of_maybe_undefined\nvar caml_pasta_fq_sqrt = function (x) {\n return caml_option_of_maybe_undefined(plonk_wasm.caml_pasta_fq_sqrt(x));\n};\n\n// Provides: caml_pasta_fq_of_int\n// Requires: plonk_wasm\nvar caml_pasta_fq_of_int = plonk_wasm.caml_pasta_fq_of_int;\n\n// Provides: caml_pasta_fq_to_string\n// Requires: plonk_wasm, caml_string_of_jsstring\nvar caml_pasta_fq_to_string = function (x) {\n return caml_string_of_jsstring(plonk_wasm.caml_pasta_fq_to_string(x));\n};\n\n// Provides: caml_pasta_fq_of_string\n// Requires: plonk_wasm, caml_jsstring_of_string\nvar caml_pasta_fq_of_string = function (x) {\n return plonk_wasm.caml_pasta_fq_of_string(caml_jsstring_of_string(x));\n};\n\n// Provides: caml_pasta_fq_print\n// Requires: plonk_wasm\nvar caml_pasta_fq_print = plonk_wasm.caml_pasta_fq_print;\n\n// Provides: caml_pasta_fq_mut_add\n// Requires: caml_pasta_fq_copy, caml_pasta_fq_add\nvar caml_pasta_fq_mut_add = function (x, y) {\n caml_pasta_fq_copy(x, caml_pasta_fq_add(x, y));\n};\n\n// Provides: caml_pasta_fq_mut_sub\n// Requires: caml_pasta_fq_copy, caml_pasta_fq_sub\nvar caml_pasta_fq_mut_sub = function (x, y) {\n caml_pasta_fq_copy(x, caml_pasta_fq_sub(x, y));\n};\n\n// Provides: caml_pasta_fq_mut_mul\n// Requires: caml_pasta_fq_copy, caml_pasta_fq_mul\nvar caml_pasta_fq_mut_mul = function (x, y) {\n caml_pasta_fq_copy(x, caml_pasta_fq_mul(x, y));\n};\n\n// Provides: caml_pasta_fq_mut_square\n// Requires: caml_pasta_fq_copy, caml_pasta_fq_square\nvar caml_pasta_fq_mut_square = function (x) {\n caml_pasta_fq_copy(x, caml_pasta_fq_square(x));\n};\n\n// Provides: caml_pasta_fq_compare\n// Requires: plonk_wasm\nvar caml_pasta_fq_compare = plonk_wasm.caml_pasta_fq_compare;\n\n// Provides: caml_pasta_fq_equal\n// Requires: plonk_wasm\nvar caml_pasta_fq_equal = plonk_wasm.caml_pasta_fq_equal;\n\n// Provides: caml_pasta_fq_random\n// Requires: plonk_wasm\nvar caml_pasta_fq_random = plonk_wasm.caml_pasta_fq_random;\n\n// Provides: caml_pasta_fq_rng\n// Requires: plonk_wasm\nvar caml_pasta_fq_rng = plonk_wasm.caml_pasta_fq_rng;\n\n// Provides: caml_pasta_fq_to_bigint\n// Requires: plonk_wasm\nvar caml_pasta_fq_to_bigint = plonk_wasm.caml_pasta_fq_to_bigint;\n\n// Provides: caml_pasta_fq_of_bigint\n// Requires: plonk_wasm\nvar caml_pasta_fq_of_bigint = plonk_wasm.caml_pasta_fq_of_bigint;\n\n// Provides: caml_pasta_fq_two_adic_root_of_unity\n// Requires: plonk_wasm\nvar caml_pasta_fq_two_adic_root_of_unity =\n plonk_wasm.caml_pasta_fq_two_adic_root_of_unity;\n\n// Provides: caml_pasta_fq_domain_generator\n// Requires: plonk_wasm\nvar caml_pasta_fq_domain_generator = plonk_wasm.caml_pasta_fq_domain_generator;\n\n// Provides: caml_pasta_fq_to_bytes\n// Requires: plonk_wasm, caml_bytes_of_uint8array\nvar caml_pasta_fq_to_bytes = function (x) {\n var res = plonk_wasm.caml_pasta_fq_to_bytes(x);\n return caml_bytes_of_uint8array(plonk_wasm.caml_pasta_fq_to_bytes(x));\n};\n\n// Provides: caml_pasta_fq_of_bytes\n// Requires: plonk_wasm, caml_bytes_to_uint8array\nvar caml_pasta_fq_of_bytes = function (ocaml_bytes) {\n return plonk_wasm.caml_pasta_fq_of_bytes(\n caml_bytes_to_uint8array(ocaml_bytes)\n );\n};\n\n// Provides: caml_pasta_fq_deep_copy\n// Requires: plonk_wasm\nvar caml_pasta_fq_deep_copy = plonk_wasm.caml_pasta_fq_deep_copy;\n\n// Provides: caml_u8array_vector_to_rust_flat_vector\nvar caml_u8array_vector_to_rust_flat_vector = function (v) {\n var i = 1; // The first entry is the OCaml tag for arrays\n var len = v.length - i;\n if (len === 0) {\n return new joo_global_object.Uint8Array(0);\n }\n var inner_len = v[i].length;\n var res = new joo_global_object.Uint8Array(len * inner_len);\n for (var pos = 0; i <= len; i++) {\n for (var j = 0; j < inner_len; j++, pos++) {\n res[pos] = v[i][j];\n }\n }\n return res;\n};\n\n// Provides: caml_u8array_vector_of_rust_flat_vector\nvar caml_u8array_vector_of_rust_flat_vector = function (v, inner_len) {\n var len = v.length;\n var output_len = len / inner_len;\n var res = new Array(output_len + 1);\n res[0] = 0; // OCaml tag before array contents, so that we can use this with arrays or vectors\n for (var i = 1, pos = 0; i <= output_len; i++) {\n var inner_res = new joo_global_object.Uint8Array(inner_len);\n for (var j = 0; j < inner_len; j++, pos++) {\n inner_res[j] = v[pos];\n }\n res[i] = inner_res;\n }\n return res;\n};\n\n// Provides: js_class_vector_to_rust_vector\nvar js_class_vector_to_rust_vector = function (v) {\n var len = v.length;\n var res = new joo_global_object.Uint32Array(len);\n for (var i = 0; i < len; i++) {\n // Beware: caller may need to do finalizer things to avoid these\n // pointers disappearing out from under us.\n res[i] = v[i].ptr;\n }\n return res;\n};\n\n// Provides: js_class_vector_of_rust_vector\nvar js_class_vector_of_rust_vector = function (v, klass) {\n // return v.map(klass.__wrap)\n var len = v.length;\n var res = new Array(len);\n for (var i = 0, pos = 0; i < len; i++) {\n // Beware: the caller may need to add finalizers to these.\n res[i] = klass.__wrap(v[i]);\n }\n return res;\n};\n\n// Provides: caml_fp_vector_create\nvar caml_fp_vector_create = function () {\n return [0]; // OCaml tag for arrays, so that we can use the same utility fns on both\n};\n\n// Provides: caml_fp_vector_length\nvar caml_fp_vector_length = function (v) {\n return v.length - 1;\n};\n\n// Provides: caml_fp_vector_emplace_back\nvar caml_fp_vector_emplace_back = function (v, x) {\n v.push(x);\n};\n\n// Provides: caml_fp_vector_get\nvar caml_fp_vector_get = function (v, i) {\n var value = v[i + 1];\n if (value === undefined) {\n throw Error(\n 'caml_fp_vector_get: Index out of bounds, got ' + i + '/' + (v.length - 1)\n );\n }\n return new joo_global_object.Uint8Array(value);\n};\n\n// Provides: caml_fp_vector_to_rust\n// Requires: caml_u8array_vector_to_rust_flat_vector\nvar caml_fp_vector_to_rust = function (v) {\n return caml_u8array_vector_to_rust_flat_vector(v);\n};\n\n// Provides: caml_fp_vector_of_rust\n// Requires: caml_u8array_vector_of_rust_flat_vector\nvar caml_fp_vector_of_rust = function (v) {\n // TODO: Hardcoding this is a little brittle\n return caml_u8array_vector_of_rust_flat_vector(v, 32);\n};\n\n// Provides: caml_fq_vector_create\nvar caml_fq_vector_create = function () {\n return [0]; // OCaml tag for arrays, so that we can use the same utility fns on both\n};\n\n// Provides: caml_fq_vector_length\nvar caml_fq_vector_length = function (v) {\n return v.length - 1;\n};\n\n// Provides: caml_fq_vector_emplace_back\nvar caml_fq_vector_emplace_back = function (v, x) {\n v.push(x);\n};\n\n// Provides: caml_fq_vector_get\nvar caml_fq_vector_get = function (v, i) {\n var value = v[i + 1];\n if (value === undefined) {\n throw Error(\n 'caml_fq_vector_get: Index out of bounds, got ' + i + '/' + (v.length - 1)\n );\n }\n return new joo_global_object.Uint8Array(value);\n};\n\n// Provides: caml_fq_vector_to_rust\n// Requires: caml_u8array_vector_to_rust_flat_vector\nvar caml_fq_vector_to_rust = function (v) {\n return caml_u8array_vector_to_rust_flat_vector(v);\n};\n\n// Provides: caml_fq_vector_of_rust\n// Requires: caml_u8array_vector_of_rust_flat_vector\nvar caml_fq_vector_of_rust = function (v) {\n // TODO: Hardcoding this is a little brittle\n return caml_u8array_vector_of_rust_flat_vector(v, 32);\n};\n\n// Provides: free_finalization_registry\n// Requires: plonk_wasm\nvar free_finalization_registry = new joo_global_object.FinalizationRegistry(\n function (instance_representative) {\n instance_representative.free();\n }\n);\n\n// Provides: free_on_finalize\n// Requires: free_finalization_registry\nvar free_on_finalize = function (x) {\n // This is an unfortunate hack: we're creating a second instance of the\n // class to be able to call free on it. We can't pass the value itself,\n // since the registry holds a strong reference to the representative value.\n //\n // However, the class is only really a wrapper around a pointer, with a\n // reference to the class' prototype as its __prototype__.\n //\n // It might seem cleaner to call the destructor here on the pointer\n // directly, but unfortunately the destructor name is some mangled internal\n // string generated by wasm_bindgen. For now, this is the best,\n // least-brittle way to free once the original class instance gets collected.\n var instance_representative = x.constructor.__wrap(x.ptr);\n free_finalization_registry.register(x, instance_representative, x);\n return x;\n};\n\n// Provides: rust_affine_to_caml_affine\nvar rust_affine_to_caml_affine = function (pt) {\n var infinity = pt.infinity;\n if (infinity) {\n pt.free();\n return 0;\n } else {\n var x = pt.x;\n var y = pt.y;\n pt.free();\n return [0, [0, x, y]];\n }\n};\n\n// Provides: rust_affine_of_caml_affine\nvar rust_affine_of_caml_affine = function (pt, klass) {\n var res = new klass();\n if (pt === 0) {\n res.infinity = true;\n } else {\n // Layout is [0, [0, x, y]]\n // First 0 is the tag (it's the 0th constructor that takes arguments)\n // Second 0 is the block marker for the anonymous tuple arguments\n res.x = pt[1][1];\n res.y = pt[1][2];\n }\n return res;\n};\n\n// Provides: caml_pallas_one\n// Requires: plonk_wasm, free_on_finalize\nvar caml_pallas_one = function () {\n var res = plonk_wasm.caml_pallas_one();\n free_on_finalize(res);\n return res;\n};\n\n// Provides: caml_pallas_add\n// Requires: plonk_wasm, free_on_finalize\nvar caml_pallas_add = function (x, y) {\n var res = plonk_wasm.caml_pallas_add(x, y);\n free_on_finalize(res);\n return res;\n};\n\n// Provides: caml_pallas_sub\n// Requires: plonk_wasm, free_on_finalize\nvar caml_pallas_sub = function (x, y) {\n var res = plonk_wasm.caml_pallas_sub(x, y);\n free_on_finalize(res);\n return res;\n};\n\n// Provides: caml_pallas_negate\n// Requires: plonk_wasm, free_on_finalize\nvar caml_pallas_negate = function (x) {\n var res = plonk_wasm.caml_pallas_negate(x);\n free_on_finalize(res);\n return res;\n};\n\n// Provides: caml_pallas_double\n// Requires: plonk_wasm, free_on_finalize\nvar caml_pallas_double = function (x) {\n var res = plonk_wasm.caml_pallas_double(x);\n free_on_finalize(res);\n return res;\n};\n\n// Provides: caml_pallas_scale\n// Requires: plonk_wasm, free_on_finalize\nvar caml_pallas_scale = function (x, y) {\n var res = plonk_wasm.caml_pallas_scale(x, y);\n free_on_finalize(res);\n return res;\n};\n\n// Provides: caml_pallas_random\n// Requires: plonk_wasm, free_on_finalize\nvar caml_pallas_random = function () {\n var res = plonk_wasm.caml_pallas_random();\n free_on_finalize(res);\n return res;\n};\n\n// Provides: caml_pallas_rng\n// Requires: plonk_wasm, free_on_finalize\nvar caml_pallas_rng = function (i) {\n var res = plonk_wasm.caml_pallas_rng(i);\n free_on_finalize(res);\n return res;\n};\n\n// Provides: caml_pallas_to_affine\n// Requires: plonk_wasm, rust_affine_to_caml_affine\nvar caml_pallas_to_affine = function (pt) {\n var res = plonk_wasm.caml_pallas_to_affine(pt);\n return rust_affine_to_caml_affine(res);\n};\n\n// Provides: caml_pallas_of_affine\n// Requires: plonk_wasm, rust_affine_of_caml_affine, free_on_finalize\nvar caml_pallas_of_affine = function (pt) {\n var res = plonk_wasm.caml_pallas_of_affine(\n rust_affine_of_caml_affine(pt, plonk_wasm.caml_pallas_affine_one)\n );\n free_on_finalize(res);\n return res;\n};\n\n// Provides: caml_pallas_of_affine_coordinates\n// Requires: plonk_wasm, free_on_finalize\nvar caml_pallas_of_affine_coordinates = function (x, y) {\n var res = plonk_wasm.caml_pallas_of_affine_coordinates(x, y);\n free_on_finalize(res);\n return res;\n};\n\n// Provides: caml_pallas_endo_base\n// Requires: plonk_wasm\nvar caml_pallas_endo_base = plonk_wasm.caml_pallas_endo_base;\n\n// Provides: caml_pallas_endo_scalar\n// Requires: plonk_wasm\nvar caml_pallas_endo_scalar = plonk_wasm.caml_pallas_endo_scalar;\n\n// Provides: caml_pallas_affine_deep_copy\n// Requires: plonk_wasm, rust_affine_of_caml_affine, rust_affine_to_caml_affine\nvar caml_pallas_affine_deep_copy = function (pt) {\n return rust_affine_to_caml_affine(\n plonk_wasm.caml_pallas_affine_deep_copy(\n rust_affine_of_caml_affine(pt, plonk_wasm.caml_pallas_affine_one)\n )\n );\n};\n\n// Provides: caml_vesta_one\n// Requires: plonk_wasm, free_on_finalize\nvar caml_vesta_one = function () {\n var res = plonk_wasm.caml_vesta_one();\n free_on_finalize(res);\n return res;\n};\n\n// Provides: caml_vesta_add\n// Requires: plonk_wasm, free_on_finalize\nvar caml_vesta_add = function (x, y) {\n var res = plonk_wasm.caml_vesta_add(x, y);\n free_on_finalize(res);\n return res;\n};\n\n// Provides: caml_vesta_sub\n// Requires: plonk_wasm, free_on_finalize\nvar caml_vesta_sub = function (x, y) {\n var res = plonk_wasm.caml_vesta_sub(x, y);\n free_on_finalize(res);\n return res;\n};\n\n// Provides: caml_vesta_negate\n// Requires: plonk_wasm, free_on_finalize\nvar caml_vesta_negate = function (x) {\n var res = plonk_wasm.caml_vesta_negate(x);\n free_on_finalize(res);\n return res;\n};\n\n// Provides: caml_vesta_double\n// Requires: plonk_wasm, free_on_finalize\nvar caml_vesta_double = function (x) {\n var res = plonk_wasm.caml_vesta_double(x);\n free_on_finalize(res);\n return res;\n};\n\n// Provides: caml_vesta_scale\n// Requires: plonk_wasm, free_on_finalize\nvar caml_vesta_scale = function (x, y) {\n var res = plonk_wasm.caml_vesta_scale(x, y);\n free_on_finalize(res);\n return res;\n};\n\n// Provides: caml_vesta_random\n// Requires: plonk_wasm, free_on_finalize\nvar caml_vesta_random = function () {\n var res = plonk_wasm.caml_vesta_random();\n free_on_finalize(res);\n return res;\n};\n\n// Provides: caml_vesta_rng\n// Requires: plonk_wasm, free_on_finalize\nvar caml_vesta_rng = function (i) {\n var res = plonk_wasm.caml_vesta_rng(i);\n free_on_finalize(res);\n return res;\n};\n\n// Provides: caml_vesta_to_affine\n// Requires: plonk_wasm, rust_affine_to_caml_affine\nvar caml_vesta_to_affine = function (pt) {\n var res = plonk_wasm.caml_vesta_to_affine(pt);\n return rust_affine_to_caml_affine(res);\n};\n\n// Provides: caml_vesta_of_affine\n// Requires: plonk_wasm, rust_affine_of_caml_affine, free_on_finalize\nvar caml_vesta_of_affine = function (pt) {\n var res = plonk_wasm.caml_vesta_of_affine(\n rust_affine_of_caml_affine(pt, plonk_wasm.caml_vesta_affine_one)\n );\n free_on_finalize(res);\n return res;\n};\n\n// Provides: caml_vesta_of_affine_coordinates\n// Requires: plonk_wasm, free_on_finalize\nvar caml_vesta_of_affine_coordinates = function (x, y) {\n var res = plonk_wasm.caml_vesta_of_affine_coordinates(x, y);\n free_on_finalize(res);\n return res;\n};\n\n// Provides: caml_vesta_endo_base\n// Requires: plonk_wasm\nvar caml_vesta_endo_base = plonk_wasm.caml_vesta_endo_base;\n\n// Provides: caml_vesta_endo_scalar\n// Requires: plonk_wasm\nvar caml_vesta_endo_scalar = plonk_wasm.caml_vesta_endo_scalar;\n\n// Provides: caml_vesta_affine_deep_copy\n// Requires: plonk_wasm, rust_affine_of_caml_affine, rust_affine_to_caml_affine\nvar caml_vesta_affine_deep_copy = function (pt) {\n return rust_affine_to_caml_affine(\n plonk_wasm.caml_vesta_affine_deep_copy(\n rust_affine_of_caml_affine(pt, plonk_wasm.caml_vesta_affine_one)\n )\n );\n};\n\n// Provides: caml_array_of_rust_vector\n// Requires: js_class_vector_of_rust_vector\nvar caml_array_of_rust_vector = function (v, klass, convert, should_free) {\n v = js_class_vector_of_rust_vector(v, klass);\n var len = v.length;\n var res = new Array(len + 1);\n res[0] = 0; // OCaml tag before array contents\n for (var i = 0; i < len; i++) {\n var rust_val = v[i];\n res[i + 1] = convert(rust_val);\n if (should_free) {\n rust_val.free();\n }\n }\n return res;\n};\n\n// Provides: caml_array_to_rust_vector\n// Requires: js_class_vector_to_rust_vector, free_finalization_registry\nvar caml_array_to_rust_vector = function (v, convert, mk_new) {\n v = v.slice(1); // Copy, dropping OCaml tag\n for (var i = 0, l = v.length; i < l; i++) {\n var class_val = convert(v[i], mk_new);\n v[i] = class_val;\n // Don't free when GC runs; rust will free on its end.\n free_finalization_registry.unregister(class_val);\n }\n return js_class_vector_to_rust_vector(v);\n};\n\n// Provides: caml_poly_comm_of_rust_poly_comm\n// Requires: rust_affine_to_caml_affine, caml_array_of_rust_vector\nvar caml_poly_comm_of_rust_poly_comm = function (\n poly_comm,\n klass,\n should_free\n) {\n var rust_shifted = poly_comm.shifted;\n var rust_unshifted = poly_comm.unshifted;\n var caml_shifted;\n if (rust_shifted === undefined) {\n caml_shifted = 0;\n } else {\n caml_shifted = [0, rust_affine_to_caml_affine(rust_shifted)];\n }\n var caml_unshifted = caml_array_of_rust_vector(\n rust_unshifted,\n klass,\n rust_affine_to_caml_affine,\n should_free\n );\n return [0, caml_unshifted, caml_shifted];\n};\n\n// Provides: caml_poly_comm_to_rust_poly_comm\n// Requires: rust_affine_of_caml_affine, caml_array_to_rust_vector\nvar caml_poly_comm_to_rust_poly_comm = function (\n poly_comm,\n poly_comm_class,\n mk_affine\n) {\n var caml_unshifted = poly_comm[1];\n var caml_shifted = poly_comm[2];\n var rust_shifted = undefined;\n if (caml_shifted !== 0) {\n rust_shifted = rust_affine_of_caml_affine(caml_shifted[1], mk_affine);\n }\n var rust_unshifted = caml_array_to_rust_vector(\n caml_unshifted,\n rust_affine_of_caml_affine,\n mk_affine\n );\n return new poly_comm_class(rust_unshifted, rust_shifted);\n};\n\n// Provides: caml_vesta_poly_comm_of_rust\n// Requires: plonk_wasm, caml_poly_comm_of_rust_poly_comm\nvar caml_vesta_poly_comm_of_rust = function (x) {\n return caml_poly_comm_of_rust_poly_comm(x, plonk_wasm.WasmGVesta, false);\n};\n\n// Provides: caml_vesta_poly_comm_to_rust\n// Requires: plonk_wasm, caml_poly_comm_to_rust_poly_comm\nvar caml_vesta_poly_comm_to_rust = function (x) {\n return caml_poly_comm_to_rust_poly_comm(\n x,\n plonk_wasm.WasmFpPolyComm,\n plonk_wasm.caml_vesta_affine_one\n );\n};\n\n// Provides: caml_pallas_poly_comm_of_rust\n// Requires: plonk_wasm, caml_poly_comm_of_rust_poly_comm\nvar caml_pallas_poly_comm_of_rust = function (x) {\n return caml_poly_comm_of_rust_poly_comm(x, plonk_wasm.WasmGPallas, false);\n};\n\n// Provides: caml_pallas_poly_comm_to_rust\n// Requires: plonk_wasm, caml_poly_comm_to_rust_poly_comm\nvar caml_pallas_poly_comm_to_rust = function (x) {\n return caml_poly_comm_to_rust_poly_comm(\n x,\n plonk_wasm.WasmFqPolyComm,\n plonk_wasm.caml_pallas_affine_one\n );\n};\n\n// Provides: caml_fp_srs_create\n// Requires: plonk_wasm, free_on_finalize\nvar caml_fp_srs_create = function (i) {\n return free_on_finalize(plonk_wasm.caml_fp_srs_create(i));\n};\n\n// Provides: caml_fp_srs_write\n// Requires: plonk_wasm, caml_jsstring_of_string\nvar caml_fp_srs_write = function (append, t, path) {\n if (append === 0) {\n append = undefined;\n } else {\n append = append[1];\n }\n return plonk_wasm.caml_fp_srs_write(append, t, caml_jsstring_of_string(path));\n};\n\n// Provides: caml_fp_srs_read\n// Requires: plonk_wasm, caml_jsstring_of_string\nvar caml_fp_srs_read = function (offset, path) {\n if (offset === 0) {\n offset = undefined;\n } else {\n offset = offset[1];\n }\n var res = plonk_wasm.caml_fp_srs_read(offset, caml_jsstring_of_string(path));\n if (res) {\n return [0, res]; // Some(res)\n } else {\n return 0; // None\n }\n};\n\n// Provides: caml_fp_srs_lagrange_commitment\n// Requires: plonk_wasm, caml_vesta_poly_comm_of_rust\nvar caml_fp_srs_lagrange_commitment = function (t, domain_size, i) {\n var res = plonk_wasm.caml_fp_srs_lagrange_commitment(t, domain_size, i);\n return caml_vesta_poly_comm_of_rust(res);\n};\n\n// Provides: caml_fp_srs_commit_evaluations\n// Requires: plonk_wasm, caml_vesta_poly_comm_of_rust, caml_fp_vector_to_rust\nvar caml_fp_srs_commit_evaluations = function (t, domain_size, fps) {\n var res = plonk_wasm.caml_fp_srs_commit_evaluations(\n t,\n domain_size,\n caml_fp_vector_to_rust(fps)\n );\n return caml_vesta_poly_comm_of_rust(res);\n};\n\n// Provides: caml_fp_srs_b_poly_commitment\n// Requires: plonk_wasm, caml_vesta_poly_comm_of_rust, caml_u8array_vector_to_rust_flat_vector\nvar caml_fp_srs_b_poly_commitment = function (srs, chals) {\n var res = plonk_wasm.caml_fp_srs_b_poly_commitment(\n srs,\n caml_u8array_vector_to_rust_flat_vector(chals)\n );\n return caml_vesta_poly_comm_of_rust(res);\n};\n\n// Provides: caml_fp_srs_batch_accumulator_check\n// Requires: plonk_wasm, rust_affine_of_caml_affine, caml_array_to_rust_vector, caml_fp_vector_to_rust\nvar caml_fp_srs_batch_accumulator_check = function (srs, comms, chals) {\n var rust_comms = caml_array_to_rust_vector(\n comms,\n rust_affine_of_caml_affine,\n plonk_wasm.caml_vesta_affine_one\n );\n var rust_chals = caml_fp_vector_to_rust(chals);\n var ok = plonk_wasm.caml_fp_srs_batch_accumulator_check(\n srs,\n rust_comms,\n rust_chals\n );\n return ok;\n};\n\n// Provides: caml_fp_srs_batch_accumulator_generate\n// Requires: plonk_wasm, rust_affine_to_caml_affine, caml_array_of_rust_vector, caml_fp_vector_to_rust\nvar caml_fp_srs_batch_accumulator_generate = function (srs, comms, chals) {\n var rust_chals = caml_fp_vector_to_rust(chals);\n var rust_comms = plonk_wasm.caml_fp_srs_batch_accumulator_generate(\n srs,\n comms,\n rust_chals\n );\n return caml_array_of_rust_vector(\n rust_comms,\n plonk_wasm.WasmGVesta,\n rust_affine_to_caml_affine,\n false\n );\n};\n\n// Provides: caml_fp_srs_h\n// Requires: plonk_wasm, rust_affine_to_caml_affine\nvar caml_fp_srs_h = function (t) {\n return rust_affine_to_caml_affine(plonk_wasm.caml_fp_srs_h(t));\n};\n\n// Provides: caml_fq_srs_create\n// Requires: plonk_wasm, free_on_finalize\nvar caml_fq_srs_create = function (i) {\n return free_on_finalize(plonk_wasm.caml_fq_srs_create(i));\n};\n\n// Provides: caml_fq_srs_write\n// Requires: plonk_wasm, caml_jsstring_of_string\nvar caml_fq_srs_write = function (append, t, path) {\n if (append === 0) {\n append = undefined;\n } else {\n append = append[1];\n }\n return plonk_wasm.caml_fq_srs_write(append, t, caml_jsstring_of_string(path));\n};\n\n// Provides: caml_fq_srs_read\n// Requires: plonk_wasm, caml_jsstring_of_string\nvar caml_fq_srs_read = function (offset, path) {\n if (offset === 0) {\n offset = undefined;\n } else {\n offset = offset[1];\n }\n var res = plonk_wasm.caml_fq_srs_read(offset, caml_jsstring_of_string(path));\n if (res) {\n return [0, res]; // Some(res)\n } else {\n return 0; // None\n }\n};\n\n// Provides: caml_fq_srs_lagrange_commitment\n// Requires: plonk_wasm, caml_pallas_poly_comm_of_rust\nvar caml_fq_srs_lagrange_commitment = function (t, domain_size, i) {\n var res = plonk_wasm.caml_fq_srs_lagrange_commitment(t, domain_size, i);\n return caml_pallas_poly_comm_of_rust(res);\n};\n\n// Provides: caml_fq_srs_commit_evaluations\n// Requires: plonk_wasm, caml_pallas_poly_comm_of_rust, caml_fq_vector_to_rust\nvar caml_fq_srs_commit_evaluations = function (t, domain_size, fqs) {\n var res = plonk_wasm.caml_fq_srs_commit_evaluations(\n t,\n domain_size,\n caml_fq_vector_to_rust(fqs)\n );\n return caml_pallas_poly_comm_of_rust(res);\n};\n\n// Provides: caml_fq_srs_b_poly_commitment\n// Requires: plonk_wasm, caml_pallas_poly_comm_of_rust, caml_u8array_vector_to_rust_flat_vector\nvar caml_fq_srs_b_poly_commitment = function (srs, chals) {\n var res = plonk_wasm.caml_fq_srs_b_poly_commitment(\n srs,\n caml_u8array_vector_to_rust_flat_vector(chals)\n );\n return caml_pallas_poly_comm_of_rust(res);\n};\n\n// Provides: caml_fq_srs_batch_accumulator_check\n// Requires: plonk_wasm, rust_affine_of_caml_affine, caml_array_to_rust_vector, caml_fq_vector_to_rust\nvar caml_fq_srs_batch_accumulator_check = function (srs, comms, chals) {\n var rust_comms = caml_array_to_rust_vector(\n comms,\n rust_affine_of_caml_affine,\n plonk_wasm.caml_pallas_affine_one\n );\n var rust_chals = caml_fq_vector_to_rust(chals);\n var ok = plonk_wasm.caml_fq_srs_batch_accumulator_check(\n srs,\n rust_comms,\n rust_chals\n );\n return ok;\n};\n\n// Provides: caml_fq_srs_batch_accumulator_generate\n// Requires: plonk_wasm, rust_affine_to_caml_affine, caml_array_of_rust_vector, caml_fq_vector_to_rust\nvar caml_fq_srs_batch_accumulator_generate = function (srs, comms, chals) {\n var rust_chals = caml_fq_vector_to_rust(chals);\n var rust_comms = plonk_wasm.caml_fq_srs_batch_accumulator_generate(\n srs,\n comms,\n rust_chals\n );\n return caml_array_of_rust_vector(\n rust_comms,\n plonk_wasm.WasmGPallas,\n rust_affine_to_caml_affine,\n false\n );\n};\n\n// Provides: caml_fq_srs_h\n// Requires: plonk_wasm, rust_affine_to_caml_affine\nvar caml_fq_srs_h = function (t) {\n return rust_affine_to_caml_affine(plonk_wasm.caml_fq_srs_h(t));\n};\n\n// Provides: caml_fq_srs_add_lagrange_basis\n// Requires: plonk_wasm\nfunction caml_fq_srs_add_lagrange_basis(srs, log2_size) {\n return plonk_wasm.caml_fq_srs_add_lagrange_basis(srs, log2_size);\n}\n\n// Provides: caml_plonk_wire_of_rust\nvar caml_plonk_wire_of_rust = function (wire) {\n var res = [0, wire.row, wire.col];\n wire.free();\n return res;\n};\n\n// Provides: caml_plonk_wire_to_rust\n// Requires: plonk_wasm\nvar caml_plonk_wire_to_rust = function (wire) {\n return plonk_wasm.Wire.create(wire[1], wire[2]);\n};\n\n// Provides: caml_plonk_wires_of_rust\n// Requires: caml_plonk_wire_of_rust\nvar caml_plonk_wires_of_rust = function (wires) {\n var res = [\n 0,\n caml_plonk_wire_of_rust(wires[0]),\n caml_plonk_wire_of_rust(wires[1]),\n caml_plonk_wire_of_rust(wires[2]),\n caml_plonk_wire_of_rust(wires[3]),\n caml_plonk_wire_of_rust(wires[4]),\n caml_plonk_wire_of_rust(wires[5]),\n caml_plonk_wire_of_rust(wires[6]),\n ];\n wires.free();\n return res;\n};\n\n// Provides: caml_plonk_wires_to_rust\n// Requires: plonk_wasm, caml_plonk_wire_to_rust\nvar caml_plonk_wires_to_rust = function (wires) {\n return new plonk_wasm.WasmGateWires(\n caml_plonk_wire_to_rust(wires[1]),\n caml_plonk_wire_to_rust(wires[2]),\n caml_plonk_wire_to_rust(wires[3]),\n caml_plonk_wire_to_rust(wires[4]),\n caml_plonk_wire_to_rust(wires[5]),\n caml_plonk_wire_to_rust(wires[6]),\n caml_plonk_wire_to_rust(wires[7])\n );\n};\n\n// Provides: caml_plonk_gate_of_rust\n// Requires: caml_plonk_wires_of_rust, caml_u8array_vector_of_rust_flat_vector\nvar caml_plonk_gate_of_rust = function (gate) {\n // TODO: Hardcoding 32 here is a little brittle\n var res = [\n 0,\n gate.typ,\n caml_plonk_wires_of_rust(gate.wires),\n caml_u8array_vector_of_rust_flat_vector(gate.c, 32),\n ];\n gate.free();\n return res;\n};\n\n// Provides: caml_fp_plonk_gate_to_rust\n// Requires: plonk_wasm, caml_plonk_wires_to_rust, caml_u8array_vector_to_rust_flat_vector\nvar caml_fp_plonk_gate_to_rust = function (gate) {\n return new plonk_wasm.WasmFpGate(\n gate[1],\n caml_plonk_wires_to_rust(gate[2]),\n caml_u8array_vector_to_rust_flat_vector(gate[3])\n );\n};\n\n// Provides: caml_fq_plonk_gate_to_rust\n// Requires: plonk_wasm, caml_plonk_wires_to_rust, caml_u8array_vector_to_rust_flat_vector\nvar caml_fq_plonk_gate_to_rust = function (gate) {\n // TODO: Hardcoding 32 here is a little brittle\n return new plonk_wasm.WasmFqGate(\n gate[1],\n caml_plonk_wires_to_rust(gate[2]),\n caml_u8array_vector_to_rust_flat_vector(gate[3])\n );\n};\n\n// Provides: caml_fp_lookup_table_to_rust\n// Requires: plonk_wasm, caml_fp_vector_of_rust, caml_get_field_of_caml_record\nvar caml_fp_lookup_table_to_rust = function (caml_lookup_table, mk_class) {\n // A value lookup table is a caml record with an id and a data field.\n // The converter should be changed if CamlLookupTable is modified.\n // id field: int32\n var caml_lookup_table_id = caml_get_field_of_caml_record(\n caml_lookup_table,\n 0\n );\n // data field: caml array of fq vectors\n var caml_lookup_table_data = caml_get_field_of_caml_record(\n caml_lookup_table,\n 1\n );\n // caml_lookup_table_data is a Caml array, starting with 0 for the runtime repr.\n // removing 1 for the 0 used by jsoo to represent values.\n var lt_data_length = caml_lookup_table_data.length - 1;\n var data = new plonk_wasm.WasmVecVecFp(lt_data_length);\n for (var i = 1; i < lt_data_length; i++) {\n data.push(caml_fp_vector_of_rust(caml_lookup_table_data.get(i - 1)));\n }\n var res = new mk_class(caml_lookup_table_id, data);\n return res;\n};\n\n// Provides: caml_fq_lookup_table_to_rust\n// Requires: plonk_wasm, caml_fq_vector_to_rust, caml_get_field_of_caml_record\nvar caml_fq_lookup_table_to_rust = function (caml_lookup_table, mk_class) {\n // A value lookup table is a caml record with an id and a data field.\n // The converter should be changed if CamlLookupTable is modified.\n // id field: int32\n var caml_lookup_table_id = caml_get_field_of_caml_record(\n caml_lookup_table,\n 0\n );\n // data field: caml array of fq vectors\n var caml_lookup_table_data = caml_get_field_of_caml_record(\n caml_lookup_table,\n 1\n );\n // caml_lookup_table_data is a Caml array, starting with 0 for the runtime repr.\n // removing 1 for the 0 used by jsoo to represent values.\n var lt_data_length = caml_lookup_table_data.length - 1;\n var data = new plonk_wasm.WasmVecVecFq(lt_data_length);\n for (var i = 1; i < lt_data_length; i++) {\n data.push(caml_fq_vector_to_rust(caml_lookup_table_data.get(i - 1)));\n }\n var res = new mk_class(caml_lookup_table_id, data);\n return res;\n};\n\n// Provides: caml_pasta_fp_plonk_gate_vector_create\n// Requires: plonk_wasm, free_on_finalize\nvar caml_pasta_fp_plonk_gate_vector_create = function () {\n return free_on_finalize(plonk_wasm.caml_pasta_fp_plonk_gate_vector_create());\n};\n\n// Provides: caml_pasta_fp_plonk_gate_vector_add\n// Requires: plonk_wasm, caml_fp_plonk_gate_to_rust\nvar caml_pasta_fp_plonk_gate_vector_add = function (v, x) {\n return plonk_wasm.caml_pasta_fp_plonk_gate_vector_add(\n v,\n caml_fp_plonk_gate_to_rust(x)\n );\n};\n\n// Provides: caml_pasta_fp_plonk_gate_vector_get\n// Requires: plonk_wasm, caml_plonk_gate_of_rust\nvar caml_pasta_fp_plonk_gate_vector_get = function (v, i) {\n return caml_plonk_gate_of_rust(\n plonk_wasm.caml_pasta_fp_plonk_gate_vector_get(v, i)\n );\n};\n\n// Provides: caml_pasta_fp_plonk_gate_vector_len\n// Requires: plonk_wasm\nvar caml_pasta_fp_plonk_gate_vector_len = function (v) {\n return plonk_wasm.caml_pasta_fp_plonk_gate_vector_len(v);\n};\n\n// Provides: caml_pasta_fp_plonk_gate_vector_wrap\n// Requires: plonk_wasm, caml_plonk_wire_to_rust\nvar caml_pasta_fp_plonk_gate_vector_wrap = function (v, x, y) {\n return plonk_wasm.caml_pasta_fp_plonk_gate_vector_wrap(\n v,\n caml_plonk_wire_to_rust(x),\n caml_plonk_wire_to_rust(y)\n );\n};\n\n// Provides: caml_pasta_fp_plonk_gate_vector_digest\n// Requires: plonk_wasm, caml_bytes_of_uint8array\nvar caml_pasta_fp_plonk_gate_vector_digest = function (\n public_input_size,\n gate_vector\n) {\n var uint8array = plonk_wasm.caml_pasta_fp_plonk_gate_vector_digest(\n public_input_size,\n gate_vector\n );\n return caml_bytes_of_uint8array(uint8array);\n};\n\n// Provides: caml_pasta_fp_plonk_circuit_serialize\n// Requires: plonk_wasm, caml_string_of_jsstring\nvar caml_pasta_fp_plonk_circuit_serialize = function (\n public_input_size,\n gate_vector\n) {\n return caml_string_of_jsstring(\n plonk_wasm.caml_pasta_fp_plonk_circuit_serialize(\n public_input_size,\n gate_vector\n )\n );\n};\n\n// Provides: caml_pasta_fq_plonk_gate_vector_create\n// Requires: plonk_wasm, free_on_finalize\nvar caml_pasta_fq_plonk_gate_vector_create = function () {\n return free_on_finalize(plonk_wasm.caml_pasta_fq_plonk_gate_vector_create());\n};\n\n// Provides: caml_pasta_fq_plonk_gate_vector_add\n// Requires: plonk_wasm, caml_fq_plonk_gate_to_rust\nvar caml_pasta_fq_plonk_gate_vector_add = function (v, x) {\n return plonk_wasm.caml_pasta_fq_plonk_gate_vector_add(\n v,\n caml_fq_plonk_gate_to_rust(x)\n );\n};\n\n// Provides: caml_pasta_fq_plonk_gate_vector_get\n// Requires: plonk_wasm, caml_plonk_gate_of_rust\nvar caml_pasta_fq_plonk_gate_vector_get = function (v, i) {\n return caml_plonk_gate_of_rust(\n plonk_wasm.caml_pasta_fq_plonk_gate_vector_get(v, i)\n );\n};\n\n// Provides: caml_pasta_fq_plonk_gate_vector_len\n// Requires: plonk_wasm\nvar caml_pasta_fq_plonk_gate_vector_len = function (v) {\n return plonk_wasm.caml_pasta_fq_plonk_gate_vector_len(v);\n};\n\n// Provides: caml_pasta_fq_plonk_gate_vector_wrap\n// Requires: plonk_wasm, caml_plonk_wire_to_rust\nvar caml_pasta_fq_plonk_gate_vector_wrap = function (v, x, y) {\n return plonk_wasm.caml_pasta_fq_plonk_gate_vector_wrap(\n v,\n caml_plonk_wire_to_rust(x),\n caml_plonk_wire_to_rust(y)\n );\n};\n\n// Provides: caml_pasta_fq_plonk_gate_vector_digest\n// Requires: plonk_wasm, caml_bytes_of_uint8array\nvar caml_pasta_fq_plonk_gate_vector_digest = function (\n public_input_size,\n gate_vector\n) {\n var uint8array = plonk_wasm.caml_pasta_fq_plonk_gate_vector_digest(\n public_input_size,\n gate_vector\n );\n return caml_bytes_of_uint8array(uint8array);\n};\n\n// Provides: caml_pasta_fq_plonk_circuit_serialize\n// Requires: plonk_wasm, caml_string_of_jsstring\nvar caml_pasta_fq_plonk_circuit_serialize = function (\n public_input_size,\n gate_vector\n) {\n return caml_string_of_jsstring(\n plonk_wasm.caml_pasta_fq_plonk_circuit_serialize(\n public_input_size,\n gate_vector\n )\n );\n};\n\n// Provides: caml_fp_runtime_table_cfg_to_rust\n// Requires: plonk_wasm, caml_fp_vector_to_rust, caml_get_field_of_caml_record\nvar caml_fp_runtime_table_cfg_to_rust = function (\n caml_runtime_table_cfg,\n mk_class\n) {\n // A value caml_runtime_table_cfg is a record on the OCaml side.\n // The converter should be changed if CamlRuntimeTableCfg is modified.\n // id field: int32\n var caml_runtime_table_cfg_id = caml_get_field_of_caml_record(\n caml_runtime_table_cfg,\n 0\n );\n // first_column field: Caml array of fq element\n var caml_runtime_table_cfg_first_column = caml_get_field_of_caml_record(\n caml_runtime_table_cfg,\n 1\n );\n var res = new mk_class(\n caml_runtime_table_cfg_id,\n caml_fp_vector_to_rust(caml_runtime_table_cfg_first_column)\n );\n return res;\n};\n\n// Provides: caml_pasta_fp_plonk_index_create\n// Requires: plonk_wasm, free_on_finalize, caml_array_to_rust_vector, caml_fp_runtime_table_cfg_to_rust, caml_create_rust_empty_vector, caml_is_empty_caml_array\nvar caml_pasta_fp_plonk_index_create = function (\n gates,\n public_inputs,\n caml_runtime_table_cfgs,\n prev_challenges,\n urs\n) {\n var wasm_runtime_table_cfgs;\n\n if (caml_is_empty_caml_array(caml_runtime_table_cfgs)) {\n wasm_runtime_table_cfgs = caml_create_rust_empty_vector();\n }\n else {\n wasm_runtime_table_cfgs = caml_array_to_rust_vector(\n caml_runtime_table_cfgs,\n caml_fp_runtime_table_cfg_to_rust,\n plonk_wasm.WasmPastaFpRuntimeTableCfg\n );\n }\n\n var t = plonk_wasm.caml_pasta_fp_plonk_index_create(\n gates,\n public_inputs,\n wasm_runtime_table_cfgs,\n prev_challenges,\n urs\n );\n return free_on_finalize(t);\n};\n\n// Provides: caml_pasta_fp_plonk_index_max_degree\n// Requires: plonk_wasm\nvar caml_pasta_fp_plonk_index_max_degree =\n plonk_wasm.caml_pasta_fp_plonk_index_max_degree;\n\n// Provides: caml_pasta_fp_plonk_index_public_inputs\n// Requires: plonk_wasm\nvar caml_pasta_fp_plonk_index_public_inputs =\n plonk_wasm.caml_pasta_fp_plonk_index_public_inputs;\n\n// Provides: caml_pasta_fp_plonk_index_domain_d1_size\n// Requires: plonk_wasm\nvar caml_pasta_fp_plonk_index_domain_d1_size =\n plonk_wasm.caml_pasta_fp_plonk_index_domain_d1_size;\n\n// Provides: caml_pasta_fp_plonk_index_domain_d4_size\n// Requires: plonk_wasm\nvar caml_pasta_fp_plonk_index_domain_d4_size =\n plonk_wasm.caml_pasta_fp_plonk_index_domain_d4_size;\n\n// Provides: caml_pasta_fp_plonk_index_domain_d8_size\n// Requires: plonk_wasm\nvar caml_pasta_fp_plonk_index_domain_d8_size =\n plonk_wasm.caml_pasta_fp_plonk_index_domain_d8_size;\n\n// Provides: caml_pasta_fp_plonk_index_read\n// Requires: plonk_wasm, caml_jsstring_of_string\nvar caml_pasta_fp_plonk_index_read = function (offset, urs, path) {\n if (offset === 0) {\n offset = undefined;\n } else {\n offset = offset[1];\n }\n return plonk_wasm.caml_pasta_fp_plonk_index_read(\n offset,\n urs,\n caml_jsstring_of_string(path)\n );\n};\n\n// Provides: caml_pasta_fp_plonk_index_write\n// Requires: plonk_wasm, caml_jsstring_of_string\nvar caml_pasta_fp_plonk_index_write = function (append, t, path) {\n if (append === 0) {\n append = undefined;\n } else {\n append = append[1];\n }\n return plonk_wasm.caml_pasta_fp_plonk_index_write(\n append,\n t,\n caml_jsstring_of_string(path)\n );\n};\n\n// Provides: caml_fq_runtime_table_cfg_to_rust\n// Requires: plonk_wasm, caml_fq_vector_to_rust, caml_get_field_of_caml_record\nvar caml_fq_runtime_table_cfg_to_rust = function (\n caml_runtime_table_cfg,\n mk_class\n) {\n // A value caml_runtime_table_cfg is a record on the OCaml side.\n // The converter should be changed if CamlRuntimeTableCfg is modified.\n // id field: int32\n var caml_runtime_table_cfg_id = caml_get_field_of_caml_record(\n caml_runtime_table_cfg,\n 0\n );\n // first_column field: Caml array of fq element\n var caml_runtime_table_cfg_first_column = caml_get_field_of_caml_record(\n caml_runtime_table_cfg,\n 1\n );\n var res = new mk_class(\n caml_runtime_table_cfg_id,\n caml_fq_vector_to_rust(caml_runtime_table_cfg_first_column)\n );\n return res;\n};\n\n// Provides: caml_pasta_fq_plonk_index_create\n// Requires: plonk_wasm, free_on_finalize, caml_array_to_rust_vector, caml_fq_runtime_table_cfg_to_rust, caml_is_empty_caml_array, caml_create_rust_empty_vector\nvar caml_pasta_fq_plonk_index_create = function (\n gates,\n public_inputs,\n caml_runtime_table_cfgs,\n prev_challenges,\n urs\n) {\n var wasm_runtime_table_cfgs;\n\n if (caml_is_empty_caml_array(caml_runtime_table_cfgs)) {\n wasm_runtime_table_cfgs = caml_create_rust_empty_vector();\n }\n\n else {\n wasm_runtime_table_cfgs = caml_array_to_rust_vector(\n caml_runtime_table_cfgs,\n caml_fq_runtime_table_cfg_to_rust,\n plonk_wasm.WasmPastaFqRuntimeTableCfg\n );\n }\n\n return free_on_finalize(\n plonk_wasm.caml_pasta_fq_plonk_index_create(\n gates,\n public_inputs,\n wasm_runtime_table_cfgs,\n prev_challenges,\n urs\n )\n );\n};\n\n// Provides: caml_pasta_fq_plonk_index_max_degree\n// Requires: plonk_wasm\nvar caml_pasta_fq_plonk_index_max_degree =\n plonk_wasm.caml_pasta_fq_plonk_index_max_degree;\n\n// Provides: caml_pasta_fq_plonk_index_public_inputs\n// Requires: plonk_wasm\nvar caml_pasta_fq_plonk_index_public_inputs =\n plonk_wasm.caml_pasta_fq_plonk_index_public_inputs;\n\n// Provides: caml_pasta_fq_plonk_index_domain_d1_size\n// Requires: plonk_wasm\nvar caml_pasta_fq_plonk_index_domain_d1_size =\n plonk_wasm.caml_pasta_fq_plonk_index_domain_d1_size;\n\n// Provides: caml_pasta_fq_plonk_index_domain_d4_size\n// Requires: plonk_wasm\nvar caml_pasta_fq_plonk_index_domain_d4_size =\n plonk_wasm.caml_pasta_fq_plonk_index_domain_d4_size;\n\n// Provides: caml_pasta_fq_plonk_index_domain_d8_size\n// Requires: plonk_wasm\nvar caml_pasta_fq_plonk_index_domain_d8_size =\n plonk_wasm.caml_pasta_fq_plonk_index_domain_d8_size;\n\n// Provides: caml_pasta_fq_plonk_index_read\n// Requires: plonk_wasm, caml_jsstring_of_string\nvar caml_pasta_fq_plonk_index_read = function (offset, urs, path) {\n if (offset === 0) {\n offset = undefined;\n } else {\n offset = offset[1];\n }\n return plonk_wasm.caml_pasta_fq_plonk_index_read(\n offset,\n urs,\n caml_jsstring_of_string(path)\n );\n};\n\n// Provides: caml_pasta_fq_plonk_index_write\n// Requires: plonk_wasm, caml_jsstring_of_string\nvar caml_pasta_fq_plonk_index_write = function (append, t, path) {\n if (append === 0) {\n append = undefined;\n } else {\n append = append[1];\n }\n return plonk_wasm.caml_pasta_fq_plonk_index_write(\n append,\n t,\n caml_jsstring_of_string(path)\n );\n};\n\n// Provides: caml_plonk_domain_of_rust\nvar caml_plonk_domain_of_rust = function (x) {\n var log_size_of_group = x.log_size_of_group;\n var group_gen = x.group_gen;\n x.free();\n return [0, log_size_of_group, group_gen];\n};\n\n// Provides: caml_plonk_domain_to_rust\n// Requires: free_on_finalize\nvar caml_plonk_domain_to_rust = function (x, klass) {\n // TODO: Check if this gets finalized\n return new klass(x[1], x[2]);\n};\n\n// Provides: caml_plonk_verification_evals_of_rust\n// Requires: caml_poly_comm_of_rust_poly_comm, js_class_vector_of_rust_vector, plonk_wasm\nvar caml_plonk_verification_evals_of_rust = function (x, affine_klass) {\n var convert = function (poly_comm) {\n return caml_poly_comm_of_rust_poly_comm(poly_comm, affine_klass, false);\n };\n\n // var convertArray = function(comms) {\n // var n = comms.length;\n // var res = new Array(n-1);\n // for (var i = 1; i < n; i++) {\n // res[i-1] = convert(comms[i]);\n // }\n // return js_class_vector_to_rust_vector(res);\n // };\n\n // should be inverse of the above ^\n // TODO: make work for both Wasm..PolyComm types\n var convertArray = function (comms) {\n comms = js_class_vector_of_rust_vector(comms, plonk_wasm.WasmFqPolyComm);\n // comms = js_class_vector_of_rust_vector(comms, plonk_wasm.WasmFpPolyComm);\n return [0].concat(comms.map(convert));\n };\n\n var sigma_comm = convertArray(x.sigma_comm);\n var coefficients_comm = convertArray(x.coefficients_comm);\n var generic_comm = convert(x.generic_comm);\n var psm_comm = convert(x.psm_comm);\n var complete_add_comm = convert(x.complete_add_comm);\n var mul_comm = convert(x.mul_comm);\n var emul_comm = convert(x.emul_comm);\n var endomul_scalar_comm = convert(x.endomul_scalar_comm);\n\n x.free();\n return [\n 0,\n sigma_comm,\n coefficients_comm,\n generic_comm,\n psm_comm,\n complete_add_comm,\n mul_comm,\n emul_comm,\n endomul_scalar_comm,\n 0,\n ];\n};\n\n// Provides: caml_plonk_verification_evals_to_rust\n// Requires: caml_poly_comm_to_rust_poly_comm, js_class_vector_to_rust_vector\nvar caml_plonk_verification_evals_to_rust = function (\n x,\n klass,\n poly_comm_class,\n mk_affine\n) {\n var convert = function (poly_comm) {\n return caml_poly_comm_to_rust_poly_comm(\n poly_comm,\n poly_comm_class,\n mk_affine\n );\n };\n\n var convertArray = function (comms) {\n var n = comms.length;\n var res = new Array(n - 1);\n for (var i = 1; i < n; i++) {\n res[i - 1] = convert(comms[i]);\n }\n return js_class_vector_to_rust_vector(res);\n };\n\n var sigma_comm = convertArray(x[1]);\n var coefficients_comm = convertArray(x[2]);\n var generic_comm = convert(x[3]);\n var psm_comm = convert(x[4]);\n var complete_add_comm = convert(x[5]);\n var mul_comm = convert(x[6]);\n var emul_comm = convert(x[7]);\n var endomul_scalar_comm = convert(x[8]);\n\n return new klass(\n sigma_comm,\n coefficients_comm,\n generic_comm,\n psm_comm,\n complete_add_comm,\n mul_comm,\n emul_comm,\n endomul_scalar_comm\n );\n};\n\n// Provides: caml_plonk_verification_shifts_of_rust\nvar caml_plonk_verification_shifts_of_rust = function (x) {\n var res = [0, x.s0, x.s1, x.s2, x.s3, x.s4, x.s5, x.s6];\n x.free();\n return res;\n};\n\n// Provides: caml_plonk_verification_shifts_to_rust\nvar caml_plonk_verification_shifts_to_rust = function (x, klass) {\n return new klass(x[1], x[2], x[3], x[4], x[5], x[6], x[7]);\n};\n\n// Provides: column_of_rust\nfunction column_of_rust(col) {\n // type nonrec column = Witness of int | Z | LookupSorted of int | LookupAggreg | LookupTable | LookupKindIndex of int | Index of gate_type | Coefficient of int\n var tag = col.tag;\n var gate_type = col.gate_type;\n var i = col.i;\n col.free();\n return (\n {\n 0: [tag, i],\n 2: [tag, i],\n 5: [tag, i],\n 6: [tag, gate_type],\n 7: [tag, i],\n }[tag] || tag\n );\n}\n\n// Provides: variable_of_rust\n// Requires: column_of_rust\nfunction variable_of_rust(variable) {\n // col * row\n var col = variable.col;\n var row = variable.row; // 0, 1\n variable.free();\n return [0, column_of_rust(col), row];\n}\n\n// Provides: polish_token_of_rust\n// Requires: variable_of_rust\nfunction polish_token_of_rust(token) {\n var tag = token.tag;\n var i0 = token.i0;\n var i1 = token.i1;\n var f = token.f;\n var v = variable_of_rust(token.v);\n token.free();\n return (\n {\n 5: [5, i0, i1],\n 6: [6, f],\n 7: [7, v],\n 9: [9, i0],\n 14: [14, i0],\n 16: [16, i0],\n }[tag] || tag\n );\n}\n\n// Provides: index_term_of_rust\n// Requires: column_of_rust, js_class_vector_of_rust_vector, polish_token_of_rust\nfunction index_term_of_rust(term, token_class) {\n // pub column: WasmColumn,\n // pub coefficient: WasmVector,\n var column = column_of_rust(term.column);\n var coefficient = js_class_vector_of_rust_vector(\n term.coefficient,\n token_class\n );\n coefficient = coefficient.map(polish_token_of_rust);\n coefficient = [0].concat(coefficient);\n term.free();\n return [0, column, coefficient];\n}\n\n// Provides: wrap\nfunction wrap(ptr, klass) {\n var obj = Object.create(klass.prototype);\n obj.ptr = ptr;\n return obj;\n}\n\n// Provides: linearization_of_rust\n// Requires: plonk_wasm, js_class_vector_of_rust_vector, polish_token_of_rust, wrap, index_term_of_rust\nfunction linearization_of_rust(linearization, affine_class) {\n var F = affine_class === plonk_wasm.WasmGVesta ? 'Fq' : 'Fp';\n var WasmPolishToken = plonk_wasm['Wasm' + F + 'PolishToken'];\n var WasmIndexTerm = plonk_wasm['Wasm' + F + 'IndexTerm'];\n\n var constant_term = js_class_vector_of_rust_vector(\n linearization.constant_term,\n WasmPolishToken\n );\n constant_term = constant_term.map(polish_token_of_rust);\n constant_term = [0].concat(constant_term);\n\n var index_terms = Array.from(linearization.index_terms).map(function (ptr) {\n var wasmIndexTerm = wrap(ptr, WasmIndexTerm);\n return index_term_of_rust(wasmIndexTerm, WasmPolishToken);\n });\n index_terms = [0].concat(index_terms);\n\n linearization.free();\n return [0, constant_term, index_terms];\n}\n\n// Provides: None\nvar None = 0;\n\n// Provides: caml_plonk_verifier_index_of_rust\n// Requires: linearization_of_rust, caml_plonk_domain_of_rust, caml_plonk_verification_evals_of_rust, caml_plonk_verification_shifts_of_rust, free_on_finalize, None\nvar caml_plonk_verifier_index_of_rust = function (x, affine_class) {\n var domain = caml_plonk_domain_of_rust(x.domain);\n var max_poly_size = x.max_poly_size;\n var public_ = x.public_;\n var prev_challenges = x.prev_challenges;\n var srs = free_on_finalize(x.srs);\n var evals = caml_plonk_verification_evals_of_rust(x.evals, affine_class);\n var shifts = caml_plonk_verification_shifts_of_rust(x.shifts);\n // TODO: Handle linearization correctly!\n // var linearization = linearization_of_rust(x.linearization, affine_class);\n var lookup_index = None;\n x.free();\n return [\n 0,\n domain,\n max_poly_size,\n public_,\n prev_challenges,\n srs,\n evals,\n shifts,\n None,\n ];\n};\n// Provides: caml_plonk_verifier_index_to_rust\n// Requires: caml_plonk_domain_to_rust, caml_plonk_verification_evals_to_rust, caml_plonk_verification_shifts_to_rust, free_finalization_registry\nvar caml_plonk_verifier_index_to_rust = function (\n x,\n klass,\n domain_class,\n verification_evals_class,\n poly_comm_class,\n mk_affine,\n verification_shifts_class\n) {\n var domain = caml_plonk_domain_to_rust(x[1], domain_class);\n var max_poly_size = x[2];\n var public_ = x[3];\n var prev_challenges = x[4];\n var srs = x[5];\n var evals = caml_plonk_verification_evals_to_rust(\n x[6],\n verification_evals_class,\n poly_comm_class,\n mk_affine\n );\n var shifts = caml_plonk_verification_shifts_to_rust(\n x[7],\n verification_shifts_class\n );\n return new klass(\n domain,\n max_poly_size,\n public_,\n prev_challenges,\n srs,\n evals,\n shifts\n );\n};\n\n// Provides: caml_pasta_fp_plonk_verifier_index_of_rust\n// Requires: plonk_wasm, caml_plonk_verifier_index_of_rust\nvar caml_pasta_fp_plonk_verifier_index_of_rust = function (x) {\n return caml_plonk_verifier_index_of_rust(x, plonk_wasm.WasmGVesta);\n};\n\n// Provides: caml_pasta_fp_plonk_verifier_index_to_rust\n// Requires: plonk_wasm, caml_plonk_verifier_index_to_rust\nvar caml_pasta_fp_plonk_verifier_index_to_rust = function (x) {\n return caml_plonk_verifier_index_to_rust(\n x,\n plonk_wasm.WasmFpPlonkVerifierIndex,\n plonk_wasm.WasmFpDomain,\n plonk_wasm.WasmFpPlonkVerificationEvals,\n plonk_wasm.WasmFpPolyComm,\n plonk_wasm.caml_vesta_affine_one,\n plonk_wasm.WasmFpShifts\n );\n};\n\n// Provides: caml_pasta_fp_plonk_verifier_index_create\n// Requires: plonk_wasm, caml_pasta_fp_plonk_verifier_index_of_rust\nvar caml_pasta_fp_plonk_verifier_index_create = function (x) {\n var vk = plonk_wasm.caml_pasta_fp_plonk_verifier_index_create(x);\n var vk_caml = caml_pasta_fp_plonk_verifier_index_of_rust(vk);\n return vk_caml;\n};\n\n// Provides: caml_pasta_fp_plonk_verifier_index_read\n// Requires: plonk_wasm, caml_jsstring_of_string, caml_pasta_fp_plonk_verifier_index_of_rust\nvar caml_pasta_fp_plonk_verifier_index_read = function (offset, urs, path) {\n if (offset === 0) {\n offset = undefined;\n } else {\n offset = offset[1];\n }\n return caml_pasta_fp_plonk_verifier_index_of_rust(\n plonk_wasm.caml_pasta_fp_plonk_verifier_index_read(\n offset,\n urs,\n caml_jsstring_of_string(path)\n )\n );\n};\n\n// Provides: caml_pasta_fp_plonk_verifier_index_write\n// Requires: plonk_wasm, caml_jsstring_of_string, caml_pasta_fp_plonk_verifier_index_to_rust\nvar caml_pasta_fp_plonk_verifier_index_write = function (append, t, path) {\n if (append === 0) {\n append = undefined;\n } else {\n append = append[1];\n }\n return plonk_wasm.caml_pasta_fp_plonk_verifier_index_write(\n append,\n caml_pasta_fp_plonk_verifier_index_to_rust(t),\n caml_jsstring_of_string(path)\n );\n};\n\n// Provides: caml_pasta_fp_plonk_verifier_index_shifts\n// Requires: plonk_wasm, caml_plonk_verification_shifts_of_rust\nvar caml_pasta_fp_plonk_verifier_index_shifts = function (log2_size) {\n return caml_plonk_verification_shifts_of_rust(\n plonk_wasm.caml_pasta_fp_plonk_verifier_index_shifts(log2_size)\n );\n};\n\n// Provides: caml_pasta_fp_plonk_verifier_index_dummy\n// Requires: plonk_wasm, caml_pasta_fp_plonk_verifier_index_of_rust\nvar caml_pasta_fp_plonk_verifier_index_dummy = function () {\n var res = plonk_wasm.caml_pasta_fp_plonk_verifier_index_dummy();\n return caml_pasta_fp_plonk_verifier_index_of_rust(res);\n // return caml_pasta_fp_plonk_verifier_index_of_rust(plonk_wasm.caml_pasta_fp_plonk_verifier_index_dummy());\n};\n\n// Provides: caml_pasta_fp_plonk_verifier_index_deep_copy\n// Requires: plonk_wasm, caml_pasta_fp_plonk_verifier_index_of_rust, caml_pasta_fp_plonk_verifier_index_to_rust\nvar caml_pasta_fp_plonk_verifier_index_deep_copy = function (x) {\n return caml_pasta_fp_plonk_verifier_index_of_rust(\n plonk_wasm.caml_pasta_fp_plonk_verifier_index_deep_copy(\n caml_pasta_fp_plonk_verifier_index_to_rust(x)\n )\n );\n};\n\n// Provides: caml_pasta_fq_plonk_verifier_index_of_rust\n// Requires: plonk_wasm, caml_plonk_verifier_index_of_rust\nvar caml_pasta_fq_plonk_verifier_index_of_rust = function (x) {\n return caml_plonk_verifier_index_of_rust(x, plonk_wasm.WasmGPallas);\n};\n\n// Provides: caml_pasta_fq_plonk_verifier_index_to_rust\n// Requires: plonk_wasm, caml_plonk_verifier_index_to_rust\nvar caml_pasta_fq_plonk_verifier_index_to_rust = function (x) {\n return caml_plonk_verifier_index_to_rust(\n x,\n plonk_wasm.WasmFqPlonkVerifierIndex,\n plonk_wasm.WasmFqDomain,\n plonk_wasm.WasmFqPlonkVerificationEvals,\n plonk_wasm.WasmFqPolyComm,\n plonk_wasm.caml_pallas_affine_one,\n plonk_wasm.WasmFqShifts\n );\n};\n\n// Provides: caml_pasta_fq_plonk_verifier_index_create\n// Requires: plonk_wasm, caml_pasta_fq_plonk_verifier_index_of_rust\nvar caml_pasta_fq_plonk_verifier_index_create = function (x) {\n return caml_pasta_fq_plonk_verifier_index_of_rust(\n plonk_wasm.caml_pasta_fq_plonk_verifier_index_create(x)\n );\n};\n\n// Provides: caml_pasta_fq_plonk_verifier_index_read\n// Requires: plonk_wasm, caml_jsstring_of_string, caml_pasta_fq_plonk_verifier_index_of_rust\nvar caml_pasta_fq_plonk_verifier_index_read = function (offset, urs, path) {\n if (offset === 0) {\n offset = undefined;\n } else {\n offset = offset[1];\n }\n return caml_pasta_fq_plonk_verifier_index_of_rust(\n plonk_wasm.caml_pasta_fq_plonk_verifier_index_read(\n offset,\n urs,\n caml_jsstring_of_string(path)\n )\n );\n};\n\n// Provides: caml_pasta_fq_plonk_verifier_index_write\n// Requires: plonk_wasm, caml_jsstring_of_string, caml_pasta_fq_plonk_verifier_index_to_rust\nvar caml_pasta_fq_plonk_verifier_index_write = function (append, t, path) {\n if (append === 0) {\n append = undefined;\n } else {\n append = append[1];\n }\n return plonk_wasm.caml_pasta_fq_plonk_verifier_index_write(\n append,\n caml_pasta_fq_plonk_verifier_index_to_rust(t),\n caml_jsstring_of_string(path)\n );\n};\n\n// Provides: caml_pasta_fq_plonk_verifier_index_shifts\n// Requires: plonk_wasm, caml_plonk_verification_shifts_of_rust\nvar caml_pasta_fq_plonk_verifier_index_shifts = function (log2_size) {\n return caml_plonk_verification_shifts_of_rust(\n plonk_wasm.caml_pasta_fq_plonk_verifier_index_shifts(log2_size)\n );\n};\n\n// Provides: caml_pasta_fq_plonk_verifier_index_dummy\n// Requires: plonk_wasm, caml_pasta_fq_plonk_verifier_index_of_rust\nvar caml_pasta_fq_plonk_verifier_index_dummy = function () {\n return caml_pasta_fq_plonk_verifier_index_of_rust(\n plonk_wasm.caml_pasta_fq_plonk_verifier_index_dummy()\n );\n};\n\n// Provides: caml_pasta_fq_plonk_verifier_index_deep_copy\n// Requires: plonk_wasm, caml_pasta_fq_plonk_verifier_index_of_rust, caml_pasta_fq_plonk_verifier_index_to_rust\nvar caml_pasta_fq_plonk_verifier_index_deep_copy = function (x) {\n return caml_pasta_fq_plonk_verifier_index_of_rust(\n plonk_wasm.caml_pasta_fq_plonk_verifier_index_deep_copy(\n caml_pasta_fq_plonk_verifier_index_to_rust(x)\n )\n );\n};\n\n// Provides: COLUMNS\nvar COLUMNS = 15;\n// Provides: PERMUTS_MINUS_1\nvar PERMUTS_MINUS_1 = 6;\n\n// Provides: caml_pasta_fp_proof_evaluations_to_rust\n// Requires: plonk_wasm, caml_fp_vector_to_rust, PERMUTS_MINUS_1, COLUMNS\nvar caml_pasta_fp_proof_evaluations_to_rust = function (x) {\n return x;\n};\n\n// Provides: caml_pasta_fp_proof_evaluations_of_rust\n// Requires: plonk_wasm, caml_fp_vector_of_rust, COLUMNS, PERMUTS_MINUS_1\nvar caml_pasta_fp_proof_evaluations_of_rust = function (x) {\n return x;\n};\n\n// Provides: caml_pasta_fp_opening_proof_to_rust\n// Requires: plonk_wasm, caml_array_to_rust_vector, rust_affine_of_caml_affine\nvar caml_pasta_fp_opening_proof_to_rust = function (x) {\n var convert_affines = function (affines) {\n return caml_array_to_rust_vector(\n affines,\n rust_affine_of_caml_affine,\n plonk_wasm.caml_vesta_affine_one\n );\n };\n var lr = x[1];\n var delta = rust_affine_of_caml_affine(\n x[2],\n plonk_wasm.caml_vesta_affine_one\n );\n var z1 = x[3];\n var z2 = x[4];\n var sg = rust_affine_of_caml_affine(x[5], plonk_wasm.caml_vesta_affine_one);\n var len = lr.length;\n // We pass l and r as separate vectors over the FFI\n var l_ocaml = new Array(len);\n var r_ocaml = new Array(len);\n for (var i = 1; i < len; i++) {\n l_ocaml[i] = lr[i][1];\n r_ocaml[i] = lr[i][2];\n }\n var l = convert_affines(l_ocaml);\n var r = convert_affines(r_ocaml);\n return new plonk_wasm.WasmFpOpeningProof(l, r, delta, z1, z2, sg);\n};\n\n// Provides: caml_pasta_fp_opening_proof_of_rust\n// Requires: plonk_wasm, caml_array_of_rust_vector, rust_affine_to_caml_affine\nvar caml_pasta_fp_opening_proof_of_rust = function (x) {\n var convert_affines = function (affines) {\n return caml_array_of_rust_vector(\n affines,\n plonk_wasm.WasmGVesta,\n rust_affine_to_caml_affine,\n false\n );\n };\n var l = convert_affines(x.lr_0);\n var r = convert_affines(x.lr_1);\n var delta = rust_affine_to_caml_affine(x.delta);\n var z1 = x.z1;\n var z2 = x.z2;\n var sg = rust_affine_to_caml_affine(x.sg);\n x.free();\n var len = l.length;\n if (len !== r.length) {\n throw new Error(\"l and r lengths don't match\");\n }\n var lr = new Array(len);\n lr[0] = 0;\n for (var i = 1; i < len; i++) {\n var tuple = new Array(3);\n tuple[0] = 0;\n tuple[1] = l[i];\n tuple[2] = r[i];\n lr[i] = tuple;\n }\n return [0, lr, delta, z1, z2, sg];\n};\n\n// Provides: caml_pasta_fp_commitments_to_rust\n// Requires: plonk_wasm, caml_vesta_poly_comm_to_rust, js_class_vector_to_rust_vector\nvar caml_pasta_fp_commitments_to_rust = function (x) {\n var convertArray = function (v) {\n var n = v.length - 1;\n var res = new Array(n);\n for (var i = 0; i < n; ++i) {\n res[i] = caml_vesta_poly_comm_to_rust(v[i + 1]);\n }\n // TODO need to do finalizer things?\n return js_class_vector_to_rust_vector(res);\n };\n\n var w_comm = convertArray(x[1]);\n var z_comm = caml_vesta_poly_comm_to_rust(x[2]);\n var t_comm = caml_vesta_poly_comm_to_rust(x[3]);\n return new plonk_wasm.WasmFpProverCommitments(w_comm, z_comm, t_comm);\n};\n\n// Provides: caml_pasta_fp_commitments_of_rust\n// Requires: caml_vesta_poly_comm_of_rust, js_class_vector_of_rust_vector, plonk_wasm\nvar caml_pasta_fp_commitments_of_rust = function (x) {\n var convertArray = function (v) {\n var a = js_class_vector_of_rust_vector(v, plonk_wasm.WasmFpPolyComm);\n var res = [0];\n for (var i = 0; i < a.length; ++i) {\n // TODO Check this. Could be off by 1\n res.push(caml_vesta_poly_comm_of_rust(a[i]));\n }\n return res;\n };\n\n var w_comm = convertArray(x.w_comm);\n var z_comm = caml_vesta_poly_comm_of_rust(x.z_comm);\n var t_comm = caml_vesta_poly_comm_of_rust(x.t_comm);\n x.free();\n return [0, w_comm, z_comm, t_comm];\n};\n\n// Provides: caml_pasta_fp_proof_to_rust\n// Requires: plonk_wasm, caml_pasta_fp_commitments_to_rust, caml_pasta_fp_opening_proof_to_rust, caml_pasta_fp_proof_evaluations_to_rust, caml_fp_vector_to_rust, caml_vesta_poly_comm_to_rust, js_class_vector_to_rust_vector\nvar caml_pasta_fp_proof_to_rust = function (x) {\n var commitments = caml_pasta_fp_commitments_to_rust(x[1]);\n var proof = caml_pasta_fp_opening_proof_to_rust(x[2]);\n var evals = caml_pasta_fp_proof_evaluations_to_rust(x[3]);\n var ft_eval1 = x[4];\n var public_ = caml_fp_vector_to_rust(x[5]);\n var prev_challenges = x[6];\n var chals_len = prev_challenges.length;\n var prev_challenges_scalars = new plonk_wasm.WasmVecVecFp(chals_len - 1);\n var prev_challenges_comms = new Array(chals_len - 1);\n for (var i = 1; i < chals_len; i++) {\n prev_challenges_scalars.push(caml_fp_vector_to_rust(prev_challenges[i][1]));\n prev_challenges_comms[i - 1] = caml_vesta_poly_comm_to_rust(\n prev_challenges[i][2]\n );\n }\n prev_challenges_comms = js_class_vector_to_rust_vector(prev_challenges_comms);\n return new plonk_wasm.WasmFpProverProof(\n commitments,\n proof,\n evals,\n ft_eval1,\n public_,\n prev_challenges_scalars,\n prev_challenges_comms\n );\n};\n\n// Provides: caml_pasta_fp_proof_of_rust\n// Requires: plonk_wasm, caml_pasta_fp_commitments_of_rust, caml_pasta_fp_opening_proof_of_rust, caml_pasta_fp_proof_evaluations_of_rust, caml_fp_vector_of_rust, js_class_vector_of_rust_vector, caml_vesta_poly_comm_of_rust\nvar caml_pasta_fp_proof_of_rust = function (x) {\n var messages = caml_pasta_fp_commitments_of_rust(x.commitments);\n var proof = caml_pasta_fp_opening_proof_of_rust(x.proof);\n var evals = caml_pasta_fp_proof_evaluations_of_rust(x.evals);\n var ft_eval1 = x.ft_eval1;\n var public_ = caml_fp_vector_of_rust(x.public_);\n var prev_challenges_scalars = x.prev_challenges_scalars;\n var prev_challenges_comms = js_class_vector_of_rust_vector(\n x.prev_challenges_comms,\n plonk_wasm.WasmFpPolyComm\n );\n var chals_len = prev_challenges_comms.length;\n var prev_challenges = new Array(chals_len);\n prev_challenges[0] = 0;\n for (var i = 1; i < chals_len; i++) {\n var res = new Array(3);\n res[0] = 0;\n res[1] = caml_fp_vector_of_rust(prev_challenges_scalars.get(i - 1));\n // TODO Check this. Could be off by 1\n res[2] = caml_vesta_poly_comm_of_rust(prev_challenges_comms[i]);\n prev_challenges[i] = res;\n }\n return [0, messages, proof, evals, ft_eval1, public_, prev_challenges];\n};\n\n// Provides: caml_fp_runtime_table_to_rust\n// Requires: plonk_wasm, caml_fp_vector_to_rust, caml_get_field_of_caml_record\nvar caml_fp_runtime_table_to_rust = function (caml_runtime_table, mk_class) {\n // A value caml_runtime_table is a record on the OCaml side.\n // The converter should be changed if CamlRuntimeTable is modified.\n // id field: int32\n var caml_runtime_table_id = caml_get_field_of_caml_record(\n caml_runtime_table,\n 0\n );\n // data field: Caml array of fq elements\n var caml_runtime_table_data = caml_get_field_of_caml_record(\n caml_runtime_table,\n 1\n );\n var res = new mk_class(\n caml_runtime_table_id,\n caml_fp_vector_to_rust(caml_runtime_table_data)\n );\n return res;\n};\n\n// Provides: caml_pasta_fp_plonk_proof_create\n// Requires: plonk_wasm, caml_fp_vector_to_rust, caml_array_to_rust_vector, rust_affine_of_caml_affine, caml_pasta_fp_proof_of_rust\nvar caml_pasta_fp_plonk_proof_create = function (\n index,\n witness_cols,\n prev_challenges,\n prev_sgs\n) {\n var w = new plonk_wasm.WasmVecVecFp(witness_cols.length - 1);\n for (var i = 1; i < witness_cols.length; i++) {\n w.push(caml_fp_vector_to_rust(witness_cols[i]));\n }\n witness_cols = w;\n prev_challenges = caml_fp_vector_to_rust(prev_challenges);\n prev_sgs = caml_array_to_rust_vector(\n prev_sgs,\n rust_affine_of_caml_affine,\n plonk_wasm.caml_vesta_affine_one\n );\n var res = plonk_wasm.caml_pasta_fp_plonk_proof_create(\n index,\n witness_cols,\n prev_challenges,\n prev_sgs\n );\n var proof = caml_pasta_fp_proof_of_rust(res);\n return proof;\n};\n\n// Provides: caml_pasta_fp_plonk_proof_verify\n// Requires: plonk_wasm, caml_array_to_rust_vector, caml_vesta_poly_comm_to_rust, caml_pasta_fp_plonk_verifier_index_to_rust, caml_pasta_fp_proof_to_rust\nvar caml_pasta_fp_plonk_proof_verify = function (index, proof) {\n index = caml_pasta_fp_plonk_verifier_index_to_rust(index);\n proof = caml_pasta_fp_proof_to_rust(proof);\n return plonk_wasm.caml_pasta_fp_plonk_proof_verify(index, proof);\n};\n\n// Provides: caml_pasta_fp_plonk_proof_batch_verify\n// Requires: plonk_wasm, caml_array_to_rust_vector, caml_vesta_poly_comm_to_rust, caml_pasta_fp_plonk_verifier_index_to_rust, caml_pasta_fp_proof_to_rust\nvar caml_pasta_fp_plonk_proof_batch_verify = function (indexes, proofs) {\n indexes = caml_array_to_rust_vector(\n indexes,\n caml_pasta_fp_plonk_verifier_index_to_rust\n );\n proofs = caml_array_to_rust_vector(proofs, caml_pasta_fp_proof_to_rust);\n return plonk_wasm.caml_pasta_fp_plonk_proof_batch_verify(indexes, proofs);\n};\n\n// Provides: caml_pasta_fp_plonk_proof_dummy\n// Requires: plonk_wasm, caml_pasta_fp_proof_of_rust\nvar caml_pasta_fp_plonk_proof_dummy = function () {\n return caml_pasta_fp_proof_of_rust(\n plonk_wasm.caml_pasta_fp_plonk_proof_dummy()\n );\n};\n\n// Provides: caml_pasta_fp_plonk_proof_deep_copy\n// Requires: plonk_wasm, caml_pasta_fp_proof_to_rust, caml_pasta_fp_proof_of_rust\nvar caml_pasta_fp_plonk_proof_deep_copy = function (proof) {\n return caml_pasta_fp_proof_of_rust(\n plonk_wasm.caml_pasta_fp_plonk_proof_deep_copy(\n caml_pasta_fp_proof_to_rust(proof)\n )\n );\n};\n\n// Provides: caml_pasta_fq_proof_evaluations_to_rust\n// Requires: plonk_wasm, caml_fq_vector_to_rust, PERMUTS_MINUS_1, COLUMNS\nvar caml_pasta_fq_proof_evaluations_to_rust = function (x) {\n return x;\n};\n\n// Provides: caml_pasta_fq_proof_evaluations_of_rust\n// Requires: plonk_wasm, caml_fq_vector_of_rust, COLUMNS, PERMUTS_MINUS_1\nvar caml_pasta_fq_proof_evaluations_of_rust = function (x) {\n return x;\n};\n\n// Provides: caml_pasta_fq_opening_proof_to_rust\n// Requires: plonk_wasm, caml_array_to_rust_vector, rust_affine_of_caml_affine\nvar caml_pasta_fq_opening_proof_to_rust = function (x) {\n var convert_affines = function (affines) {\n return caml_array_to_rust_vector(\n affines,\n rust_affine_of_caml_affine,\n plonk_wasm.caml_pallas_affine_one\n );\n };\n var lr = x[1];\n var delta = rust_affine_of_caml_affine(\n x[2],\n plonk_wasm.caml_pallas_affine_one\n );\n var z1 = x[3];\n var z2 = x[4];\n var sg = rust_affine_of_caml_affine(x[5], plonk_wasm.caml_pallas_affine_one);\n var len = lr.length;\n // We pass l and r as separate vectors over the FFI\n var l_ocaml = new Array(len);\n var r_ocaml = new Array(len);\n for (var i = 1; i < len; i++) {\n l_ocaml[i] = lr[i][1];\n r_ocaml[i] = lr[i][2];\n }\n var l = convert_affines(l_ocaml);\n var r = convert_affines(r_ocaml);\n return new plonk_wasm.WasmFqOpeningProof(l, r, delta, z1, z2, sg);\n};\n\n// Provides: caml_pasta_fq_opening_proof_of_rust\n// Requires: plonk_wasm, caml_array_of_rust_vector, rust_affine_to_caml_affine\nvar caml_pasta_fq_opening_proof_of_rust = function (x) {\n var convert_affines = function (affines) {\n return caml_array_of_rust_vector(\n affines,\n plonk_wasm.WasmGPallas,\n rust_affine_to_caml_affine,\n false\n );\n };\n var l = convert_affines(x.lr_0);\n var r = convert_affines(x.lr_1);\n var delta = rust_affine_to_caml_affine(x.delta);\n var z1 = x.z1;\n var z2 = x.z2;\n var sg = rust_affine_to_caml_affine(x.sg);\n x.free();\n var len = l.length;\n if (len !== r.length) {\n throw new Error(\"l and r lengths don't match\");\n }\n var lr = new Array(len);\n lr[0] = 0;\n for (var i = 1; i < len; i++) {\n var tuple = new Array(3);\n tuple[0] = 0;\n tuple[1] = l[i];\n tuple[2] = r[i];\n lr[i] = tuple;\n }\n return [0, lr, delta, z1, z2, sg];\n};\n\n// Provides: caml_pasta_fq_commitments_to_rust\n// Requires: plonk_wasm, caml_pallas_poly_comm_to_rust, js_class_vector_to_rust_vector\nvar caml_pasta_fq_commitments_to_rust = function (x) {\n var convertArray = function (v) {\n var n = v.length - 1;\n var res = new Array(n);\n for (var i = 0; i < n; ++i) {\n res[i] = caml_pallas_poly_comm_to_rust(v[i + 1]);\n }\n return js_class_vector_to_rust_vector(res);\n };\n\n var w_comm = convertArray(x[1]);\n var z_comm = caml_pallas_poly_comm_to_rust(x[2]);\n var t_comm = caml_pallas_poly_comm_to_rust(x[3]);\n return new plonk_wasm.WasmFqProverCommitments(w_comm, z_comm, t_comm);\n};\n\n// Provides: caml_pasta_fq_commitments_of_rust\n// Requires: caml_pallas_poly_comm_of_rust, js_class_vector_of_rust_vector, plonk_wasm\nvar caml_pasta_fq_commitments_of_rust = function (x) {\n var convertArray = function (v) {\n var a = js_class_vector_of_rust_vector(v, plonk_wasm.WasmFqPolyComm);\n var res = [0];\n for (var i = 0; i < a.length; ++i) {\n // TODO Check this. Could be off by 1\n res.push(caml_pallas_poly_comm_of_rust(a[i]));\n }\n return res;\n };\n\n var w_comm = convertArray(x.w_comm);\n var z_comm = caml_pallas_poly_comm_of_rust(x.z_comm);\n var t_comm = caml_pallas_poly_comm_of_rust(x.t_comm);\n x.free();\n return [0, w_comm, z_comm, t_comm];\n};\n\n// Provides: caml_pasta_fq_proof_to_rust\n// Requires: plonk_wasm, caml_pasta_fq_commitments_to_rust, caml_pasta_fq_opening_proof_to_rust, caml_pasta_fq_proof_evaluations_to_rust, caml_fq_vector_to_rust, caml_pallas_poly_comm_to_rust, js_class_vector_to_rust_vector\nvar caml_pasta_fq_proof_to_rust = function (x) {\n var messages = caml_pasta_fq_commitments_to_rust(x[1]);\n var proof = caml_pasta_fq_opening_proof_to_rust(x[2]);\n var evals = caml_pasta_fq_proof_evaluations_to_rust(x[3]);\n var ft_eval1 = x[4];\n var public_ = caml_fq_vector_to_rust(x[5]);\n var prev_challenges = x[6];\n var chals_len = prev_challenges.length;\n var prev_challenges_scalars = new plonk_wasm.WasmVecVecFq(chals_len - 1);\n var prev_challenges_comms = new Array(chals_len - 1);\n for (var i = 1; i < chals_len; i++) {\n prev_challenges_scalars.push(caml_fq_vector_to_rust(prev_challenges[i][1]));\n prev_challenges_comms[i - 1] = caml_pallas_poly_comm_to_rust(\n prev_challenges[i][2]\n );\n }\n prev_challenges_comms = js_class_vector_to_rust_vector(prev_challenges_comms);\n return new plonk_wasm.WasmFqProverProof(\n messages,\n proof,\n evals,\n ft_eval1,\n public_,\n prev_challenges_scalars,\n prev_challenges_comms\n );\n};\n\n// Provides: caml_pasta_fq_proof_of_rust\n// Requires: plonk_wasm, caml_pasta_fq_commitments_of_rust, caml_pasta_fq_opening_proof_of_rust, caml_pasta_fq_proof_evaluations_of_rust, caml_fq_vector_of_rust, js_class_vector_of_rust_vector, caml_pallas_poly_comm_of_rust\nvar caml_pasta_fq_proof_of_rust = function (x) {\n var messages = caml_pasta_fq_commitments_of_rust(x.commitments);\n var proof = caml_pasta_fq_opening_proof_of_rust(x.proof);\n var evals = caml_pasta_fq_proof_evaluations_of_rust(x.evals);\n var evals1 = caml_pasta_fq_proof_evaluations_of_rust(x.evals1);\n var ft_eval1 = x.ft_eval1;\n var public_ = caml_fq_vector_of_rust(x.public_);\n var prev_challenges_scalars = x.prev_challenges_scalars;\n var prev_challenges_comms = js_class_vector_of_rust_vector(\n x.prev_challenges_comms,\n plonk_wasm.WasmFqPolyComm\n );\n var chals_len = prev_challenges_comms.length;\n var prev_challenges = new Array(chals_len);\n prev_challenges[0] = 0;\n for (var i = 1; i < chals_len; i++) {\n var res = new Array(3);\n res[0] = 0;\n res[1] = caml_fq_vector_of_rust(prev_challenges_scalars.get(i - 1));\n res[2] = caml_pallas_poly_comm_of_rust(prev_challenges_comms[i]);\n prev_challenges[i] = res;\n }\n return [0, messages, proof, evals, ft_eval1, public_, prev_challenges];\n};\n\n// Provides: caml_fq_runtime_table_to_rust\n// Requires: plonk_wasm, caml_fq_vector_to_rust, caml_get_field_of_caml_record\nvar caml_fq_runtime_table_to_rust = function (caml_runtime_table, mk_class) {\n // A value caml_runtime_table is a record on the OCaml side.\n // The converter should be changed if CamlRuntimeTable is modified.\n // id field: int32\n var caml_runtime_table_id = caml_get_field_of_caml_record(\n caml_runtime_table,\n 0\n );\n // data field: Caml array of fq elements\n var caml_runtime_table_data = caml_get_field_of_caml_record(\n caml_runtime_table,\n 1\n );\n var res = new mk_class(\n caml_runtime_table_id,\n caml_fq_vector_to_rust(caml_runtime_table_data)\n );\n return res;\n};\n\n// Provides: caml_pasta_fq_plonk_proof_create\n// Requires: plonk_wasm, caml_fq_vector_to_rust, caml_array_to_rust_vector, rust_affine_of_caml_affine, caml_pasta_fq_proof_of_rust\nvar caml_pasta_fq_plonk_proof_create = function (\n index,\n witness_cols,\n prev_challenges,\n prev_sgs\n) {\n var w = new plonk_wasm.WasmVecVecFq(witness_cols.length - 1);\n for (var i = 1; i < witness_cols.length; i++) {\n w.push(caml_fq_vector_to_rust(witness_cols[i]));\n }\n witness_cols = w;\n prev_challenges = caml_fq_vector_to_rust(prev_challenges);\n prev_sgs = caml_array_to_rust_vector(\n prev_sgs,\n rust_affine_of_caml_affine,\n plonk_wasm.caml_pallas_affine_one\n );\n var res = plonk_wasm.caml_pasta_fq_plonk_proof_create(\n index,\n witness_cols,\n prev_challenges,\n prev_sgs\n );\n var proof = caml_pasta_fq_proof_of_rust(res);\n return proof;\n};\n\n// Provides: caml_pasta_fq_plonk_proof_verify\n// Requires: plonk_wasm, caml_array_to_rust_vector, caml_pallas_poly_comm_to_rust, caml_pasta_fq_plonk_verifier_index_to_rust, caml_pasta_fq_proof_to_rust\nvar caml_pasta_fq_plonk_proof_verify = function (index, proof) {\n index = caml_pasta_fq_plonk_verifier_index_to_rust(index);\n proof = caml_pasta_fq_proof_to_rust(proof);\n return plonk_wasm.caml_pasta_fq_plonk_proof_verify(index, proof);\n};\n\n// Provides: caml_pasta_fq_plonk_proof_batch_verify\n// Requires: plonk_wasm, caml_array_to_rust_vector, caml_pallas_poly_comm_to_rust, caml_pasta_fq_plonk_verifier_index_to_rust, caml_pasta_fq_proof_to_rust\nvar caml_pasta_fq_plonk_proof_batch_verify = function (indexes, proofs) {\n indexes = caml_array_to_rust_vector(\n indexes,\n caml_pasta_fq_plonk_verifier_index_to_rust\n );\n proofs = caml_array_to_rust_vector(proofs, caml_pasta_fq_proof_to_rust);\n return plonk_wasm.caml_pasta_fq_plonk_proof_batch_verify(indexes, proofs);\n};\n\n// Provides: caml_pasta_fq_plonk_proof_dummy\n// Requires: plonk_wasm, caml_pasta_fq_proof_of_rust\nvar caml_pasta_fq_plonk_proof_dummy = function () {\n return caml_pasta_fq_proof_of_rust(\n plonk_wasm.caml_pasta_fq_plonk_proof_dummy()\n );\n};\n\n// Provides: caml_pasta_fq_plonk_proof_deep_copy\n// Requires: plonk_wasm, caml_pasta_fq_proof_to_rust, caml_pasta_fq_proof_of_rust\nvar caml_pasta_fq_plonk_proof_deep_copy = function (proof) {\n return caml_pasta_fq_proof_of_rust(\n plonk_wasm.caml_pasta_fq_plonk_proof_deep_copy(\n caml_pasta_fq_proof_to_rust(proof)\n )\n );\n};\n\n// Provides: caml_random_oracles_of_rust\n// Requires: caml_u8array_vector_of_rust_flat_vector, caml_option_of_maybe_undefined\nvar caml_random_oracles_of_rust = function (x) {\n var joint_combiner_chal = x.joint_combiner_chal;\n var joint_combiner = x.joint_combiner;\n var joint_combiner_ocaml = undefined;\n if (joint_combiner_chal !== undefined && joint_combiner !== undefined) {\n joint_combiner_ocaml = [0, [0, joint_combiner_chal], joint_combiner];\n }\n return [\n 0,\n caml_option_of_maybe_undefined(joint_combiner_ocaml),\n x.beta,\n x.gamma,\n [0, x.alpha_chal],\n x.alpha,\n x.zeta,\n x.v,\n x.u,\n [0, x.zeta_chal],\n [0, x.v_chal],\n [0, x.u_chal],\n ];\n};\n\n// Provides: caml_random_oracles_to_rust\n// Requires: caml_u8array_vector_to_rust_flat_vector, caml_option_to_maybe_undefined\nvar caml_random_oracles_to_rust = function (x, roKlass) {\n // var caml_vector = [0, x[1], x[2], x[3][1], x[4], x[5], x[6], x[7], x[8][1], x[9][1], x[10][1]];\n var joint_combiner_ocaml = caml_option_to_maybe_undefined(x[1]);\n var joint_combiner_chal = undefined;\n var joint_combiner = undefined;\n if (joint_combiner_ocaml !== undefined) {\n joint_combiner_chal = joint_combiner_ocaml[1][1];\n joint_combiner = joint_combiner_ocaml[2];\n }\n return new roKlass(\n joint_combiner_chal,\n joint_combiner,\n x[2],\n x[3],\n x[4][1],\n x[5],\n x[6],\n x[7],\n x[8],\n x[9][1],\n x[10][1],\n x[11][1]\n );\n};\n\n// Provides: caml_oracles_of_rust\n// Requires: caml_u8array_vector_of_rust_flat_vector, caml_random_oracles_of_rust\nvar caml_oracles_of_rust = function (x) {\n return [\n 0,\n caml_random_oracles_of_rust(x.o),\n [0, x.p_eval0, x.p_eval1],\n caml_u8array_vector_of_rust_flat_vector(\n x.opening_prechallenges,\n 32 /* TODO: Don't hardcode */\n ),\n x.digest_before_evaluations,\n ];\n};\n\n// Provides: caml_oracles_to_rust\n// Requires: caml_u8array_vector_to_rust_flat_vector, caml_random_oracles_to_rust\nvar caml_oracles_to_rust = function (x, klass, roKlass) {\n return new klass(\n caml_random_oracles_to_rust(x[1], roKlass),\n x[2][1],\n x[2][2],\n caml_u8array_vector_to_rust_flat_vector(x[3]),\n x[4]\n );\n};\n\n// Provides: fp_oracles_create\n// Requires: plonk_wasm, caml_oracles_of_rust, caml_array_to_rust_vector, caml_vesta_poly_comm_to_rust, caml_pasta_fp_plonk_verifier_index_to_rust, caml_pasta_fp_proof_to_rust\nvar fp_oracles_create = function (lgr_comm, verifier_index, proof) {\n return caml_oracles_of_rust(\n plonk_wasm.fp_oracles_create(\n caml_array_to_rust_vector(lgr_comm, caml_vesta_poly_comm_to_rust),\n caml_pasta_fp_plonk_verifier_index_to_rust(verifier_index),\n caml_pasta_fp_proof_to_rust(proof)\n )\n );\n};\n\n// Provides: fp_oracles_dummy\n// Requires: plonk_wasm, caml_oracles_of_rust\nvar fp_oracles_dummy = function () {\n return caml_oracles_of_rust(plonk_wasm.fp_oracles_dummy());\n};\n\n// Provides: fp_oracles_deep_copy\n// Requires: plonk_wasm, caml_oracles_of_rust, caml_oracles_to_rust\nvar fp_oracles_deep_copy = function (x) {\n return caml_oracles_of_rust(\n plonk_wasm.fp_oracles_deep_copy(\n caml_oracles_to_rust(\n x,\n plonk_wasm.WasmFpOracles,\n plonk_wasm.WasmFpRandomOracles\n )\n )\n );\n};\n\n// Provides: fq_oracles_create\n// Requires: plonk_wasm, caml_oracles_of_rust, caml_array_to_rust_vector, caml_pallas_poly_comm_to_rust, caml_pasta_fq_plonk_verifier_index_to_rust, caml_pasta_fq_proof_to_rust\nvar fq_oracles_create = function (lgr_comm, verifier_index, proof) {\n return caml_oracles_of_rust(\n plonk_wasm.fq_oracles_create(\n caml_array_to_rust_vector(lgr_comm, caml_pallas_poly_comm_to_rust),\n caml_pasta_fq_plonk_verifier_index_to_rust(verifier_index),\n caml_pasta_fq_proof_to_rust(proof)\n )\n );\n};\n\n// Provides: fq_oracles_dummy\n// Requires: plonk_wasm, caml_oracles_of_rust\nvar fq_oracles_dummy = function () {\n return caml_oracles_of_rust(plonk_wasm.fq_oracles_dummy());\n};\n\n// Provides: fq_oracles_deep_copy\n// Requires: plonk_wasm, caml_oracles_of_rust, caml_oracles_to_rust\nvar fq_oracles_deep_copy = function (x) {\n return caml_oracles_of_rust(\n plonk_wasm.fq_oracles_deep_copy(\n caml_oracles_to_rust(\n x,\n plonk_wasm.WasmFqOracles,\n plonk_wasm.WasmFqRandomOracles\n )\n )\n );\n};\n\n// This is fake -- parameters are only needed on the Rust side, so no need to return something meaningful\n// Provides: caml_pasta_fp_poseidon_params_create\nfunction caml_pasta_fp_poseidon_params_create() {\n return [0];\n}\n// Provides: caml_pasta_fq_poseidon_params_create\nfunction caml_pasta_fq_poseidon_params_create() {\n return [0];\n}\n\n// Provides: caml_pasta_fp_poseidon_block_cipher\n// Requires: plonk_wasm, caml_fp_vector_to_rust, caml_fp_vector_of_rust\nfunction caml_pasta_fp_poseidon_block_cipher(_fake_params, fp_vector) {\n // 1. get permuted field vector from rust\n var wasm_flat_vector = plonk_wasm.caml_pasta_fp_poseidon_block_cipher(\n caml_fp_vector_to_rust(fp_vector)\n );\n var new_fp_vector = caml_fp_vector_of_rust(wasm_flat_vector);\n // 2. write back modified field vector to original one\n new_fp_vector.forEach(function (a, i) {\n fp_vector[i] = a;\n });\n}\n\n// Provides: caml_pasta_fq_poseidon_block_cipher\n// Requires: plonk_wasm, caml_fq_vector_to_rust, caml_fq_vector_of_rust\nfunction caml_pasta_fq_poseidon_block_cipher(_fake_params, fq_vector) {\n // 1. get permuted field vector from rust\n var wasm_flat_vector = plonk_wasm.caml_pasta_fq_poseidon_block_cipher(\n caml_fq_vector_to_rust(fq_vector)\n );\n var new_fq_vector = caml_fq_vector_of_rust(wasm_flat_vector);\n // 2. write back modified field vector to original one\n new_fq_vector.forEach(function (a, i) {\n fq_vector[i] = a;\n });\n}\n\n// Provides: caml_pasta_fp_plonk_proof_example_with_lookup\nfunction caml_pasta_fp_plonk_proof_example_with_lookup() {\n // This is only used in the pickles unit tests\n throw new Error(\n 'Unimplemented caml_pasta_fp_plonk_proof_example_with_lookup'\n );\n}\n\n// Provides: prover_to_json\n// Requires: plonk_wasm\nvar prover_to_json = plonk_wasm.prover_to_json;\n\n// Provides: integers_uint64_of_uint32\n// Requires: UInt64, caml_int64_of_int32\nfunction integers_uint64_of_uint32(i) {\n // Same as integers_uint64_of_int\n return new UInt64(caml_int64_of_int32(i));\n}\n\n/////////////////////////////////////////////////////////////////////////////\n// The *_example_* functions below are only used in the pickles unit tests //\n/////////////////////////////////////////////////////////////////////////////\n\n// Provides: caml_pasta_fp_plonk_proof_example_with_ffadd\nfunction caml_pasta_fp_plonk_proof_example_with_ffadd() {\n throw new Error('Unimplemented caml_pasta_fp_plonk_proof_example_with_ffadd');\n}\n\n// Provides: caml_pasta_fp_plonk_proof_example_with_foreign_field_mul\nfunction caml_pasta_fp_plonk_proof_example_with_foreign_field_mul() {\n throw new Error(\n 'Unimplemented caml_pasta_fp_plonk_proof_example_with_foreign_field_mul'\n );\n}\n\n// Provides: caml_pasta_fp_plonk_proof_example_with_range_check\nfunction caml_pasta_fp_plonk_proof_example_with_range_check() {\n throw new Error(\n 'Unimplemented caml_pasta_fp_plonk_proof_example_with_range_check'\n );\n}\n\n// Provides: caml_pasta_fp_plonk_proof_example_with_range_check0\nfunction caml_pasta_fp_plonk_proof_example_with_range_check0() {\n throw new Error(\n 'Unimplemented caml_pasta_fp_plonk_proof_example_with_range_check0'\n );\n}\n\n// Provides: caml_pasta_fp_plonk_proof_example_with_rot\nfunction caml_pasta_fp_plonk_proof_example_with_rot() {\n throw new Error('Unimplemented caml_pasta_fp_plonk_proof_example_with_rot');\n}\n\n// Provides: caml_pasta_fp_plonk_proof_example_with_xor\nfunction caml_pasta_fp_plonk_proof_example_with_xor() {\n throw new Error('Unimplemented caml_pasta_fp_plonk_proof_example_with_xor');\n}\n","// Js_of_ocaml runtime support\n// http://www.ocsigen.org/js_of_ocaml/\n//\n// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU Lesser General Public License as published by\n// the Free Software Foundation, with linking exception;\n// either version 2.1 of the License, or (at your option) any later version.\n//\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n// GNU Lesser General Public License for more details.\n//\n// You should have received a copy of the GNU Lesser General Public License\n// along with this program; if not, write to the Free Software\n// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n\n//Provides: caml_compare_val_tag\n//Requires: caml_is_ml_string, caml_is_ml_bytes\nfunction caml_compare_val_tag(a){\n if (typeof a === \"number\") return 1000; // int_tag (we use it for all numbers)\n else if (caml_is_ml_bytes(a)) return 252; // string_tag\n else if (caml_is_ml_string(a)) return 1252; // ocaml string (if different from bytes)\n else if (a instanceof Array && a[0] === (a[0]>>>0) && a[0] <= 255) {\n // Look like an ocaml block\n var tag = a[0] | 0;\n // ignore double_array_tag because we cannot accurately set\n // this tag when we create an array of float.\n return (tag == 254)?0:tag\n }\n else if (a instanceof String) return 12520; // javascript string, like string_tag (252)\n else if (typeof a == \"string\") return 12520; // javascript string, like string_tag (252)\n else if (a instanceof Number) return 1000; // int_tag (we use it for all numbers)\n else if (a && a.caml_custom) return 1255; // like custom_tag (255)\n else if (a && a.compare) return 1256; // like custom_tag (255)\n else if (typeof a == \"function\") return 1247; // like closure_tag (247)\n else if (typeof a == \"symbol\") return 1251;\n return 1001; //out_of_heap_tag\n}\n\n//Provides: caml_compare_val_get_custom\n//Requires: caml_custom_ops\nfunction caml_compare_val_get_custom(a){\n return caml_custom_ops[a.caml_custom] && caml_custom_ops[a.caml_custom].compare;\n}\n\n//Provides: caml_compare_val_number_custom\n//Requires: caml_compare_val_get_custom\nfunction caml_compare_val_number_custom(num, custom, swap, total) {\n var comp = caml_compare_val_get_custom(custom);\n if(comp) {\n var x = (swap > 0)?comp(custom,num,total):comp(num,custom,total);\n if(total && x != x) return swap; // total && nan\n if(+x != +x) return +x; // nan\n if((x | 0) != 0) return (x | 0); // !nan\n }\n return swap\n}\n\n//Provides: caml_compare_val (const, const, const)\n//Requires: caml_int_compare, caml_string_compare, caml_bytes_compare\n//Requires: caml_invalid_argument, caml_compare_val_get_custom, caml_compare_val_tag\n//Requires: caml_compare_val_number_custom\n//Requires: caml_jsbytes_of_string\nfunction caml_compare_val (a, b, total) {\n var stack = [];\n for(;;) {\n if (!(total && a === b)) {\n var tag_a = caml_compare_val_tag(a);\n // forward_tag ?\n if(tag_a == 250) { a = a[1]; continue }\n\n var tag_b = caml_compare_val_tag(b);\n // forward_tag ?\n if(tag_b == 250) { b = b[1]; continue }\n\n // tags are different\n if(tag_a !== tag_b) {\n if(tag_a == 1000) {\n if(tag_b == 1255) { //immediate can compare against custom\n return caml_compare_val_number_custom(a, b, -1, total);\n }\n return -1\n }\n if(tag_b == 1000) {\n if(tag_a == 1255) { //immediate can compare against custom\n return caml_compare_val_number_custom(b, a, 1, total);\n }\n return 1\n }\n return (tag_a < tag_b)?-1:1;\n }\n switch(tag_a){\n // 246: Lazy_tag handled bellow\n case 247: // Closure_tag\n // Cannot happen\n caml_invalid_argument(\"compare: functional value\");\n break\n case 248: // Object\n var x = caml_int_compare(a[2], b[2]);\n if (x != 0) return (x | 0);\n break;\n case 249: // Infix\n // Cannot happen\n caml_invalid_argument(\"compare: functional value\");\n break\n case 250: // Forward tag\n // Cannot happen, handled above\n caml_invalid_argument(\"equal: got Forward_tag, should not happen\");\n break;\n case 251: //Abstract\n caml_invalid_argument(\"equal: abstract value\");\n break;\n case 252: // OCaml bytes\n if (a !== b) {\n var x = caml_bytes_compare(a, b);\n if (x != 0) return (x | 0);\n };\n break;\n case 253: // Double_tag\n // Cannot happen\n caml_invalid_argument(\"equal: got Double_tag, should not happen\");\n break;\n case 254: // Double_array_tag\n // Cannot happen, handled above\n caml_invalid_argument(\"equal: got Double_array_tag, should not happen\");\n break\n case 255: // Custom_tag\n caml_invalid_argument(\"equal: got Custom_tag, should not happen\");\n break;\n case 1247: // Function\n caml_invalid_argument(\"compare: functional value\");\n break;\n case 1255: // Custom\n var comp = caml_compare_val_get_custom(a);\n if(comp != caml_compare_val_get_custom(b)){\n return (a.caml_custom b) return 1;\n if (a != b) {\n if (!total) return NaN;\n if (a == a) return 1;\n if (b == b) return -1;\n }\n break;\n case 1001: // The rest\n // Here we can be in the following cases:\n // 1. JavaScript primitive types\n // 2. JavaScript object that can be coerced to primitive types\n // 3. JavaScript object than cannot be coerced to primitive types\n //\n // (3) will raise a [TypeError]\n // (2) will coerce to primitive types using [valueOf] or [toString]\n // (2) and (3), after eventual coercion\n // - if a and b are strings, apply lexicographic comparison\n // - if a or b are not strings, convert a and b to number\n // and apply standard comparison\n //\n // Exception: `!=` will not coerce/convert if both a and b are objects\n if (a < b) return -1;\n if (a > b) return 1;\n if (a != b) {\n if (!total) return NaN;\n if (a == a) return 1;\n if (b == b) return -1;\n }\n break;\n case 1251: // JavaScript Symbol, no ordering.\n if(a !== b) {\n if (!total) return NaN;\n return 1;\n }\n break;\n case 1252: // ocaml strings\n var a = caml_jsbytes_of_string(a);\n var b = caml_jsbytes_of_string(b);\n if(a !== b) {\n if(a < b) return -1;\n if(a > b) return 1;\n }\n break;\n case 12520: // javascript strings\n var a = a.toString();\n var b = b.toString();\n if(a !== b) {\n if(a < b) return -1;\n if(a > b) return 1;\n }\n break;\n case 246: // Lazy_tag\n case 254: // Double_array\n default: // Block with other tag\n if (a.length != b.length) return (a.length < b.length)?-1:1;\n if (a.length > 1) stack.push(a, b, 1);\n break;\n }\n }\n if (stack.length == 0) return 0;\n var i = stack.pop();\n b = stack.pop();\n a = stack.pop();\n if (i + 1 < a.length) stack.push(a, b, i + 1);\n a = a[i];\n b = b[i];\n }\n}\n//Provides: caml_compare (const, const)\n//Requires: caml_compare_val\nfunction caml_compare (a, b) { return caml_compare_val (a, b, true); }\n//Provides: caml_int_compare mutable (const, const)\nfunction caml_int_compare (a, b) {\n if (a < b) return (-1); if (a == b) return 0; return 1;\n}\n//Provides: caml_equal mutable (const, const)\n//Requires: caml_compare_val\nfunction caml_equal (x, y) { return +(caml_compare_val(x,y,false) == 0); }\n//Provides: caml_notequal mutable (const, const)\n//Requires: caml_compare_val\nfunction caml_notequal (x, y) { return +(caml_compare_val(x,y,false) != 0); }\n//Provides: caml_greaterequal mutable (const, const)\n//Requires: caml_compare_val\nfunction caml_greaterequal (x, y) { return +(caml_compare_val(x,y,false) >= 0); }\n//Provides: caml_greaterthan mutable (const, const)\n//Requires: caml_compare_val\nfunction caml_greaterthan (x, y) { return +(caml_compare_val(x,y,false) > 0); }\n//Provides: caml_lessequal mutable (const, const)\n//Requires: caml_compare_val\nfunction caml_lessequal (x, y) { return +(caml_compare_val(x,y,false) <= 0); }\n//Provides: caml_lessthan mutable (const, const)\n//Requires: caml_compare_val\nfunction caml_lessthan (x, y) { return +(caml_compare_val(x,y,false) < 0); }\n","// Js_of_ocaml runtime support\n// http://www.ocsigen.org/js_of_ocaml/\n// Copyright (C) 2010 Jérôme Vouillon\n// Laboratoire PPS - CNRS Université Paris Diderot\n//\n// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU Lesser General Public License as published by\n// the Free Software Foundation, with linking exception;\n// either version 2.1 of the License, or (at your option) any later version.\n//\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n// GNU Lesser General Public License for more details.\n//\n// You should have received a copy of the GNU Lesser General Public License\n// along with this program; if not, write to the Free Software\n// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n\n// Weak API, but without the weak semantics\n\n//Provides: caml_ephe_key_offset\nvar caml_ephe_key_offset = 3\n\n//Provides: caml_ephe_data_offset\nvar caml_ephe_data_offset = 2\n\n//Provides: caml_weak_create\n//Requires: caml_ephe_key_offset, caml_invalid_argument\nfunction caml_weak_create (n) {\n if (n < 0) caml_invalid_argument (\"Weak.create\");\n var x = [251,\"caml_ephe_list_head\"];\n x.length = caml_ephe_key_offset + n;\n return x;\n}\n\n//Provides: caml_weak_set\n//Requires: caml_ephe_key_offset, caml_invalid_argument\nfunction caml_weak_set(x, i, v) {\n if(i < 0 || caml_ephe_key_offset + i >= x.length)\n caml_invalid_argument (\"Weak.set\");\n x[caml_ephe_key_offset + i] = v;\n return 0;\n}\n//Provides: caml_weak_get\n//Requires: caml_ephe_key_offset, caml_invalid_argument\nfunction caml_weak_get(x, i) {\n if(i < 0 || caml_ephe_key_offset + i >= x.length)\n caml_invalid_argument (\"Weak.get_key\");\n return (x[caml_ephe_key_offset + i ]===undefined)?0:x[caml_ephe_key_offset + i];\n}\n//Provides: caml_weak_get_copy\n//Requires: caml_weak_get,caml_ephe_key_offset\n//Requires: caml_obj_dup, caml_invalid_argument\nfunction caml_weak_get_copy(x, i) {\n if(i < 0 || caml_ephe_key_offset + i >= x.length)\n caml_invalid_argument (\"Weak.get_copy\");\n var y = caml_weak_get(x, i);\n if (y === 0) return y;\n var z = y[1];\n if (z instanceof Array) return [0, caml_obj_dup(z)];\n return y;\n}\n\n//Provides: caml_weak_check mutable\n//Requires: caml_ephe_key_offset\nfunction caml_weak_check(x, i) {\n if(x[caml_ephe_key_offset + i]!==undefined && x[caml_ephe_key_offset + i] !==0)\n return 1;\n else\n return 0;\n}\n\n//Provides: caml_weak_blit\n//Requires: caml_array_blit\n//Requires: caml_ephe_key_offset\nfunction caml_weak_blit(a1, i1, a2, i2, len) {\n // minus one because caml_array_blit works on ocaml array\n caml_array_blit(a1, caml_ephe_key_offset + i1 - 1,\n a2, caml_ephe_key_offset + i2 - 1,\n len);\n return 0;\n}\n\n//Provides: caml_ephe_create\n//Requires: caml_weak_create\nvar caml_ephe_create = caml_weak_create\n\n//Provides: caml_ephe_blit_key\n//Requires: caml_weak_blit\nvar caml_ephe_blit_key = caml_weak_blit\n\n//Provides: caml_ephe_get_key\n//Requires: caml_weak_get\nvar caml_ephe_get_key = caml_weak_get\n\n//Provides: caml_ephe_get_key_copy\n//Requires: caml_weak_get_copy\nvar caml_ephe_get_key_copy = caml_weak_get_copy\n\n//Provides: caml_ephe_check_key\n//Requires: caml_weak_check\nvar caml_ephe_check_key = caml_weak_check\n\n//Provides: caml_ephe_set_key\n//Requires: caml_weak_set\nfunction caml_ephe_set_key(x, i, v) {\n return caml_weak_set(x, i, [0, v])\n}\n\n//Provides: caml_ephe_unset_key\n//Requires: caml_weak_set\nfunction caml_ephe_unset_key(x, i) {\n return caml_weak_set(x, i, 0)\n}\n\n//Provides: caml_ephe_blit_data\n//Requires: caml_ephe_data_offset\nfunction caml_ephe_blit_data(src, dst){\n dst[caml_ephe_data_offset] = src[caml_ephe_data_offset];\n return 0;\n}\n\n//Provides: caml_ephe_get_data\n//Requires: caml_ephe_data_offset\nfunction caml_ephe_get_data(x){\n if(x[caml_ephe_data_offset] === undefined)\n return 0;\n else\n return [0, x[caml_ephe_data_offset]];\n}\n\n//Provides: caml_ephe_get_data_copy\n//Requires: caml_ephe_data_offset\n//Requires: caml_obj_dup\nfunction caml_ephe_get_data_copy(x){\n if(x[caml_ephe_data_offset] === undefined)\n return 0;\n else\n return [0, caml_obj_dup(x[caml_ephe_data_offset])];\n}\n\n//Provides: caml_ephe_set_data\n//Requires: caml_ephe_data_offset\nfunction caml_ephe_set_data(x, data){\n x[caml_ephe_data_offset] = data;\n return 0;\n}\n\n//Provides: caml_ephe_unset_data\n//Requires: caml_ephe_data_offset\nfunction caml_ephe_unset_data(x, data){\n x[caml_ephe_data_offset] = undefined;\n return 0;\n}\n\n//Provides: caml_ephe_check_data\n//Requires: caml_ephe_data_offset\nfunction caml_ephe_check_data(x){\n if(x[caml_ephe_data_offset] === undefined)\n return 0;\n else\n return 1;\n}\n","\n\n//Provides: caml_gc_minor\nfunction caml_gc_minor(){ return 0}\n//Provides: caml_gc_major\nfunction caml_gc_major(){ return 0}\n//Provides: caml_gc_full_major\nfunction caml_gc_full_major(){ return 0}\n//Provides: caml_gc_compaction\nfunction caml_gc_compaction(){ return 0}\n//Provides: caml_gc_counters\nfunction caml_gc_counters() { return [254,0,0,0] }\n//Provides: caml_gc_quick_stat\nfunction caml_gc_quick_stat(){\n return [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]\n}\n//Provides: caml_gc_stat\nfunction caml_gc_stat() {\n return [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]\n}\n\n//Provides: caml_gc_set\nfunction caml_gc_set(_control) {\n return 0;\n}\n\n//Provides: caml_gc_get\nfunction caml_gc_get(){\n return [0,0,0,0,0,0,0,0,0]\n}\n\n//Provides: caml_memprof_set\nfunction caml_memprof_set(_control) {\n return 0;\n}\n\n//Provides: caml_final_register const\nfunction caml_final_register () { return 0; }\n//Provides: caml_final_register_called_without_value const\nfunction caml_final_register_called_without_value () { return 0; }\n//Provides: caml_final_release const\nfunction caml_final_release () { return 0; }\n\n//Provides: caml_memprof_start\nfunction caml_memprof_start(rate,stack_size,tracker){\n return 0;\n}\n\n//Provides: caml_memprof_stop\nfunction caml_memprof_stop(unit) {\n return 0;\n}\n\n//Provides: caml_eventlog_resume\nfunction caml_eventlog_resume(unit) { return 0; }\n\n//Provides: caml_eventlog_pause\nfunction caml_eventlog_pause(unit) { return 0; }\n\n//Provides: caml_gc_huge_fallback_count\nfunction caml_gc_huge_fallback_count(unit) { return 0; }\n\n//Provides: caml_gc_major_slice\nfunction caml_gc_major_slice(work) { return 0; }\n\n//Provides: caml_gc_minor_words\nfunction caml_gc_minor_words(unit) { return 0; }\n\n//Provides: caml_get_minor_free\nfunction caml_get_minor_free(unit) { return 0; }\n\n//Provides: caml_get_major_bucket\nfunction caml_get_major_bucket(n) { return 0; }\n\n//Provides: caml_get_major_credit\nfunction caml_get_major_credit(n) { return 0; }\n","// Js_of_ocaml runtime support\n// http://www.ocsigen.org/js_of_ocaml/\n//\n// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU Lesser General Public License as published by\n// the Free Software Foundation, with linking exception;\n// either version 2.1 of the License, or (at your option) any later version.\n//\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n// GNU Lesser General Public License for more details.\n//\n// You should have received a copy of the GNU Lesser General Public License\n// along with this program; if not, write to the Free Software\n// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n\n///////////// Format\n\n//Provides: caml_parse_format\n//Requires: caml_jsbytes_of_string, caml_invalid_argument\nfunction caml_parse_format (fmt) {\n fmt = caml_jsbytes_of_string(fmt);\n var len = fmt.length;\n if (len > 31) caml_invalid_argument(\"format_int: format too long\");\n var f =\n { justify:'+', signstyle:'-', filler:' ', alternate:false,\n base:0, signedconv:false, width:0, uppercase:false,\n sign:1, prec:-1, conv:'f' };\n for (var i = 0; i < len; i++) {\n var c = fmt.charAt(i);\n switch (c) {\n case '-':\n f.justify = '-'; break;\n case '+': case ' ':\n f.signstyle = c; break;\n case '0':\n f.filler = '0'; break;\n case '#':\n f.alternate = true; break;\n case '1': case '2': case '3': case '4': case '5':\n case '6': case '7': case '8': case '9':\n f.width = 0;\n while (c=fmt.charCodeAt(i) - 48, c >= 0 && c <= 9) {\n f.width = f.width * 10 + c; i++\n }\n i--;\n break;\n case '.':\n f.prec = 0;\n i++;\n while (c=fmt.charCodeAt(i) - 48, c >= 0 && c <= 9) {\n f.prec = f.prec * 10 + c; i++\n }\n i--;\n case 'd': case 'i':\n f.signedconv = true; /* fallthrough */\n case 'u':\n f.base = 10; break;\n case 'x':\n f.base = 16; break;\n case 'X':\n f.base = 16; f.uppercase = true; break;\n case 'o':\n f.base = 8; break;\n case 'e': case 'f': case 'g':\n f.signedconv = true; f.conv = c; break;\n case 'E': case 'F': case 'G':\n f.signedconv = true; f.uppercase = true;\n f.conv = c.toLowerCase (); break;\n }\n }\n return f;\n}\n\n//Provides: caml_finish_formatting\n//Requires: caml_string_of_jsbytes\nfunction caml_finish_formatting(f, rawbuffer) {\n if (f.uppercase) rawbuffer = rawbuffer.toUpperCase();\n var len = rawbuffer.length;\n /* Adjust len to reflect additional chars (sign, etc) */\n if (f.signedconv && (f.sign < 0 || f.signstyle != '-')) len++;\n if (f.alternate) {\n if (f.base == 8) len += 1;\n if (f.base == 16) len += 2;\n }\n /* Do the formatting */\n var buffer = \"\";\n if (f.justify == '+' && f.filler == ' ')\n for (var i = len; i < f.width; i++) buffer += ' ';\n if (f.signedconv) {\n if (f.sign < 0) buffer += '-';\n else if (f.signstyle != '-') buffer += f.signstyle;\n }\n if (f.alternate && f.base == 8) buffer += '0';\n if (f.alternate && f.base == 16) buffer += \"0x\";\n if (f.justify == '+' && f.filler == '0')\n for (var i = len; i < f.width; i++) buffer += '0';\n buffer += rawbuffer;\n if (f.justify == '-')\n for (var i = len; i < f.width; i++) buffer += ' ';\n return caml_string_of_jsbytes(buffer);\n}\n","// Js_of_ocaml runtime support\n// http://www.ocsigen.org/js_of_ocaml/\n//\n// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU Lesser General Public License as published by\n// the Free Software Foundation, with linking exception;\n// either version 2.1 of the License, or (at your option) any later version.\n//\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n// GNU Lesser General Public License for more details.\n//\n// You should have received a copy of the GNU Lesser General Public License\n// along with this program; if not, write to the Free Software\n// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n\n//Provides: caml_update_dummy\nfunction caml_update_dummy (x, y) {\n if( typeof y===\"function\" ) { x.fun = y; return 0; }\n if( y.fun ) { x.fun = y.fun; return 0; }\n var i = y.length; while (i--) x[i] = y[i]; return 0;\n}\n\n//Provides: caml_obj_is_block const (const)\nfunction caml_obj_is_block (x) { return +(x instanceof Array); }\n\n\n//Provides: caml_obj_tag\n//Requires: caml_is_ml_bytes, caml_is_ml_string\nfunction caml_obj_tag (x) {\n if ((x instanceof Array) && x[0] == (x[0] >>> 0))\n return x[0]\n else if (caml_is_ml_bytes(x))\n return 252\n else if (caml_is_ml_string(x))\n return 252\n else if ((x instanceof Function) || typeof x == \"function\")\n return 247\n else if (x && x.caml_custom)\n return 255\n else\n return 1000\n}\n\n//Provides: caml_obj_set_tag (mutable, const)\nfunction caml_obj_set_tag (x, tag) { x[0] = tag; return 0; }\n//Provides: caml_obj_block const (const,const)\nfunction caml_obj_block (tag, size) {\n var o = new Array(size+1);\n o[0]=tag;\n for (var i = 1; i <= size; i++) o[i] = 0;\n return o;\n}\n\n//Provides: caml_obj_with_tag\nfunction caml_obj_with_tag(tag,x) {\n var l = x.length;\n var a = new Array(l);\n a[0] = tag;\n for(var i = 1; i < l; i++ ) a[i] = x[i];\n return a;\n}\n\n//Provides: caml_obj_dup mutable (const)\nfunction caml_obj_dup (x) {\n var l = x.length;\n var a = new Array(l);\n for(var i = 0; i < l; i++ ) a[i] = x[i];\n return a;\n}\n\n//Provides: caml_obj_truncate (mutable, const)\n//Requires: caml_invalid_argument\nfunction caml_obj_truncate (x, s) {\n if (s<=0 || s + 1 > x.length)\n caml_invalid_argument (\"Obj.truncate\");\n if (x.length != s + 1) x.length = s + 1;\n return 0;\n}\n\n//Provides: caml_obj_make_forward\nfunction caml_obj_make_forward (b,v) {\n b[0]=250;\n b[1]=v;\n return 0\n}\n\n//Provides: caml_lazy_make_forward const (const)\nfunction caml_lazy_make_forward (v) { return [250, v]; }\n\n///////////// CamlinternalOO\n//Provides: caml_get_public_method const\nvar caml_method_cache = [];\nfunction caml_get_public_method (obj, tag, cacheid) {\n var meths = obj[1];\n var ofs = caml_method_cache[cacheid];\n if (ofs === undefined) {\n // Make sure the array is not sparse\n for (var i = caml_method_cache.length; i < cacheid; i++)\n caml_method_cache[i] = 0;\n } else if (meths[ofs] === tag) {\n return meths[ofs - 1];\n }\n var li = 3, hi = meths[1] * 2 + 1, mi;\n while (li < hi) {\n mi = ((li+hi) >> 1) | 1;\n if (tag < meths[mi+1]) hi = mi-2;\n else li = mi;\n }\n caml_method_cache[cacheid] = li + 1;\n /* return 0 if tag is not there */\n return (tag == meths[li+1] ? meths[li] : 0);\n}\n\n//Provides: caml_oo_last_id\nvar caml_oo_last_id = 0;\n\n//Provides: caml_set_oo_id\n//Requires: caml_oo_last_id\nfunction caml_set_oo_id (b) {\n b[2]=caml_oo_last_id++;\n return b;\n}\n\n//Provides: caml_fresh_oo_id const\n//Requires: caml_oo_last_id\nfunction caml_fresh_oo_id() {\n return caml_oo_last_id++;\n}\n\n//Provides: caml_obj_raw_field\nfunction caml_obj_raw_field(o,i) { return o[i+1] }\n\n//Provides: caml_obj_set_raw_field\nfunction caml_obj_set_raw_field(o,i,v) { return o[i+1] = v }\n\n//Provides: caml_obj_reachable_words\nfunction caml_obj_reachable_words(o) { return 0; }\n\n//Provides: caml_obj_add_offset\n//Requires: caml_failwith\nfunction caml_obj_add_offset(v,offset) {\n caml_failwith(\"Obj.add_offset is not supported\");\n}\n","// Js_of_ocaml runtime support\n// http://www.ocsigen.org/js_of_ocaml/\n// Copyright (C) 2014 Jérôme Vouillon, Hugo Heuzard\n// Laboratoire PPS - CNRS Université Paris Diderot\n//\n// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU Lesser General Public License as published by\n// the Free Software Foundation, with linking exception;\n// either version 2.1 of the License, or (at your option) any later version.\n//\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n// GNU Lesser General Public License for more details.\n//\n// You should have received a copy of the GNU Lesser General Public License\n// along with this program; if not, write to the Free Software\n// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n\n//Provides: fs_node_supported\nfunction fs_node_supported () {\n return (\n typeof globalThis.process !== 'undefined'\n && typeof globalThis.process.versions !== 'undefined'\n && typeof globalThis.process.versions.node !== 'undefined')\n}\n//Provides: fs_node_supported\n//If: browser\nfunction fs_node_supported () {\n return false\n}\n\n\n//Provides: MlNodeDevice\n//Requires: MlNodeFile, caml_raise_sys_error, caml_raise_with_args\n//Requires: make_unix_err_args, caml_named_value, caml_string_of_jsstring\nfunction MlNodeDevice(root) {\n this.fs = require('fs');\n this.root = root;\n}\nMlNodeDevice.prototype.nm = function(name) {\n return (this.root + name);\n}\nMlNodeDevice.prototype.exists = function(name) {\n try {\n return this.fs.existsSync(this.nm(name))?1:0;\n } catch (err) {\n return 0;\n }\n}\nMlNodeDevice.prototype.mkdir = function(name, mode, raise_unix) {\n try {\n this.fs.mkdirSync(this.nm(name),{mode:mode});\n return 0\n } catch (err) {\n this.raise_nodejs_error(err, raise_unix);\n }\n}\nMlNodeDevice.prototype.rmdir = function(name, raise_unix) {\n try {\n this.fs.rmdirSync(this.nm(name));\n return 0\n } catch (err) {\n this.raise_nodejs_error(err, raise_unix);\n }\n}\nMlNodeDevice.prototype.readdir = function(name, raise_unix) {\n try {\n return this.fs.readdirSync(this.nm(name));\n } catch (err) {\n this.raise_nodejs_error(err, raise_unix);\n }\n}\nMlNodeDevice.prototype.is_dir = function(name) {\n try {\n return this.fs.statSync(this.nm(name)).isDirectory()?1:0;\n } catch (err) {\n caml_raise_sys_error(err.toString());\n }\n}\nMlNodeDevice.prototype.unlink = function(name, raise_unix) {\n try {\n var b = this.fs.existsSync(this.nm(name))?1:0;\n this.fs.unlinkSync(this.nm(name));\n return b;\n } catch (err) {\n this.raise_nodejs_error(err, raise_unix);\n }\n}\nMlNodeDevice.prototype.open = function(name, f, raise_unix) {\n var consts = require('constants');\n var res = 0;\n for(var key in f){\n switch(key){\n case \"rdonly\" : res |= consts.O_RDONLY; break;\n case \"wronly\" : res |= consts.O_WRONLY; break;\n case \"append\" :\n res |= consts.O_WRONLY | consts.O_APPEND;\n break;\n case \"create\" : res |= consts.O_CREAT; break;\n case \"truncate\" : res |= consts.O_TRUNC; break;\n case \"excl\" : res |= consts.O_EXCL; break;\n case \"binary\" : res |= consts.O_BINARY; break;\n case \"text\" : res |= consts.O_TEXT; break;\n case \"nonblock\" : res |= consts.O_NONBLOCK; break;\n }\n }\n try {\n var fd = this.fs.openSync(this.nm(name), res);\n return new MlNodeFile(fd);\n } catch (err) {\n this.raise_nodejs_error(err, raise_unix);\n }\n}\n\nMlNodeDevice.prototype.rename = function(o, n, raise_unix) {\n try {\n this.fs.renameSync(this.nm(o), this.nm(n));\n } catch (err) {\n this.raise_nodejs_error(err, raise_unix);\n }\n}\nMlNodeDevice.prototype.stat = function(name, raise_unix) {\n try {\n var js_stats = this.fs.statSync(this.nm(name));\n return this.stats_from_js(js_stats);\n } catch (err) {\n this.raise_nodejs_error(err, raise_unix);\n }\n}\nMlNodeDevice.prototype.lstat = function(name, raise_unix) {\n try {\n var js_stats = this.fs.lstatSync(this.nm(name));\n return this.stats_from_js(js_stats);\n } catch (err) {\n this.raise_nodejs_error(err, raise_unix);\n }\n}\nMlNodeDevice.prototype.symlink = function(to_dir, target, path, raise_unix) {\n try {\n this.fs.symlinkSync(this.nm(target), this.nm(path), to_dir ? 'dir' : 'file');\n return 0;\n } catch (err) {\n this.raise_nodejs_error(err, raise_unix);\n }\n}\nMlNodeDevice.prototype.readlink = function(name, raise_unix) {\n try {\n var link = this.fs.readlinkSync(this.nm(name), 'utf8');\n return caml_string_of_jsstring(link);\n } catch (err) {\n this.raise_nodejs_error(err, raise_unix);\n }\n}\nMlNodeDevice.prototype.raise_nodejs_error = function(err, raise_unix) {\n var unix_error = caml_named_value(\"Unix.Unix_error\");\n if (raise_unix && unix_error) {\n var args = make_unix_err_args(err.code, err.syscall, err.path, err.errno);\n caml_raise_with_args(unix_error, args);\n } else {\n caml_raise_sys_error(err.toString());\n }\n}\nMlNodeDevice.prototype.stats_from_js = function(js_stats) {\n /* ===Unix.file_kind===\n * type file_kind =\n * S_REG (** Regular file *)\n * | S_DIR (** Directory *)\n * | S_CHR (** Character device *)\n * | S_BLK (** Block device *)\n * | S_LNK (** Symbolic link *)\n * | S_FIFO (** Named pipe *)\n * | S_SOCK (** Socket *)\n */\n var file_kind;\n if (js_stats.isFile()) {\n file_kind = 0;\n } else if (js_stats.isDirectory()) {\n file_kind = 1;\n } else if (js_stats.isCharacterDevice()) {\n file_kind = 2;\n } else if (js_stats.isBlockDevice()) {\n file_kind = 3;\n } else if (js_stats.isSymbolicLink()) {\n file_kind = 4;\n } else if (js_stats.isFIFO()) {\n file_kind = 5;\n } else if (js_stats.isSocket()) {\n file_kind = 6;\n }\n /* ===Unix.stats===\n * type stats =\n * { st_dev : int; (** Device number *)\n * st_ino : int; (** Inode number *)\n * st_kind : file_kind; (** Kind of the file *)\n * st_perm : file_perm; (** Access rights *)\n * st_nlink : int; (** Number of links *)\n * st_uid : int; (** User id of the owner *)\n * st_gid : int; (** Group ID of the file's group *)\n * st_rdev : int; (** Device ID (if special file) *)\n * st_size : int; (** Size in bytes *)\n * st_atime : float; (** Last access time *)\n * st_mtime : float; (** Last modification time *)\n * st_ctime : float; (** Last status change time *)\n * }\n */\n return BLOCK(\n 0,\n js_stats.dev,\n js_stats.ino,\n file_kind,\n js_stats.mode,\n js_stats.nlink,\n js_stats.uid,\n js_stats.gid,\n js_stats.rdev,\n js_stats.size,\n js_stats.atimeMs,\n js_stats.mtimeMs,\n js_stats.ctimeMs\n );\n}\n\nMlNodeDevice.prototype.constructor = MlNodeDevice\n\n//Provides: MlNodeDevice\n//If: browser\nfunction MlNodeDevice() {\n}\n\n//Provides: MlNodeFile\n//Requires: MlFile, caml_array_of_string, caml_array_of_bytes, caml_bytes_set, caml_raise_sys_error\nfunction MlNodeFile(fd){\n this.fs = require('fs');\n this.fd = fd;\n}\nMlNodeFile.prototype = new MlFile ();\n\nMlNodeFile.prototype.truncate = function(len){\n try {\n this.fs.ftruncateSync(this.fd,len|0)\n } catch (err) {\n caml_raise_sys_error(err.toString());\n }\n}\nMlNodeFile.prototype.length = function () {\n try {\n return this.fs.fstatSync(this.fd).size;\n } catch (err) {\n caml_raise_sys_error(err.toString());\n }\n}\nMlNodeFile.prototype.write = function(offset,buf,buf_offset,len){\n var a = caml_array_of_string(buf);\n if(! (a instanceof globalThis.Uint8Array))\n a = new globalThis.Uint8Array(a);\n var buffer = globalThis.Buffer.from(a);\n try {\n this.fs.writeSync(this.fd, buffer, buf_offset, len, offset);\n } catch (err) {\n caml_raise_sys_error(err.toString());\n }\n return 0;\n}\nMlNodeFile.prototype.read = function(offset,buf,buf_offset,len){\n var a = caml_array_of_bytes(buf);\n if(! (a instanceof globalThis.Uint8Array))\n a = new globalThis.Uint8Array(a);\n var buffer = globalThis.Buffer.from(a);\n try {\n this.fs.readSync(this.fd, buffer, buf_offset, len, offset);\n } catch (err) {\n caml_raise_sys_error(err.toString());\n }\n for(var i = 0; i < len; i++){\n caml_bytes_set(buf,buf_offset + i,buffer[buf_offset+i]);\n }\n return 0\n}\nMlNodeFile.prototype.read_one = function(offset){\n var a = new globalThis.Uint8Array(1);\n var buffer = globalThis.Buffer.from(a);\n try {\n this.fs.readSync(this.fd, buffer, 0, 1, offset);\n } catch (err) {\n caml_raise_sys_error(err.toString());\n }\n return buffer[0];\n}\nMlNodeFile.prototype.close = function(){\n try {\n this.fs.closeSync(this.fd);\n } catch (err) {\n caml_raise_sys_error(err.toString());\n }\n}\n\nMlNodeFile.prototype.constructor = MlNodeFile;\n\n//Provides: MlNodeFile\n//If: browser\nfunction MlNodeFile(){\n}\n","// Js_of_ocaml runtime support\n// http://www.ocsigen.org/js_of_ocaml/\n// Copyright (C) 2014 Jérôme Vouillon, Hugo Heuzard\n// Laboratoire PPS - CNRS Université Paris Diderot\n//\n// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU Lesser General Public License as published by\n// the Free Software Foundation, with linking exception;\n// either version 2.1 of the License, or (at your option) any later version.\n//\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n// GNU Lesser General Public License for more details.\n//\n// You should have received a copy of the GNU Lesser General Public License\n// along with this program; if not, write to the Free Software\n// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n\n///////////// Dummy filesystem\n\n//Provides: caml_trailing_slash\nfunction caml_trailing_slash(name){\n return (name.slice(-1) !== \"/\") ? (name + \"/\") : name;\n}\n\n//Provides: caml_current_dir\n//Requires: caml_trailing_slash, fs_node_supported\nif(fs_node_supported () && globalThis.process && globalThis.process.cwd)\n var caml_current_dir = globalThis.process.cwd().replace(/\\\\/g,'/');\nelse\n var caml_current_dir = \"/static\";\ncaml_current_dir = caml_trailing_slash(caml_current_dir);\n\n//Provides: caml_get_root\n//Requires: path_is_absolute\nfunction caml_get_root(path){\n var x = path_is_absolute(path);\n if (!x) return;\n return x[0] + \"/\"}\n\n//Provides: caml_root\n//Requires: caml_get_root, caml_current_dir, caml_failwith\nvar caml_root = caml_get_root(caml_current_dir) || caml_failwith(\"unable to compute caml_root\");\n\n\n//Provides: MlFile\nfunction MlFile(){ }\n\n//Provides: path_is_absolute\n//Requires: fs_node_supported\nfunction make_path_is_absolute() {\n function posix(path) {\n if (path.charAt(0) === '/') return [\"\", path.substring(1)];\n return;\n }\n\n function win32(path) {\n // https://github.com/nodejs/node/blob/b3fcc245fb25539909ef1d5eaa01dbf92e168633/lib/path.js#L56\n var splitDeviceRe = /^([a-zA-Z]:|[\\\\/]{2}[^\\\\/]+[\\\\/]+[^\\\\/]+)?([\\\\/])?([\\s\\S]*?)$/;\n var result = splitDeviceRe.exec(path);\n var device = result[1] || '';\n var isUnc = Boolean(device && device.charAt(1) !== ':');\n\n // UNC paths are always absolute\n if (Boolean(result[2] || isUnc)) {\n var root = (result[1] || '');\n var sep = (result[2] || '');\n return [root, path.substring(root.length + sep.length)]\n }\n return;\n }\n if(fs_node_supported () && globalThis.process && globalThis.process.platform) {\n return globalThis.process.platform === 'win32' ? win32 : posix;\n }\n else return posix\n}\nvar path_is_absolute = make_path_is_absolute();\n\n//Provides: caml_make_path\n//Requires: caml_current_dir\n//Requires: caml_jsstring_of_string, path_is_absolute\nfunction caml_make_path (name) {\n name=caml_jsstring_of_string(name);\n if( !path_is_absolute(name) )\n name = caml_current_dir + name;\n var comp0 = path_is_absolute(name);\n var comp = comp0[1].split(\"/\");\n var ncomp = []\n for(var i = 0; i1) ncomp.pop(); break;\n case \".\": break;\n default: ncomp.push(comp[i]);break\n }\n }\n ncomp.unshift(comp0[0]);\n ncomp.orig = name;\n return ncomp;\n}\n\n//Provides:jsoo_mount_point\n//Requires: MlFakeDevice, MlNodeDevice, caml_root, fs_node_supported\nvar jsoo_mount_point = []\nif (fs_node_supported()) {\n jsoo_mount_point.push({path:caml_root,device:new MlNodeDevice(caml_root)});\n} else {\n jsoo_mount_point.push({path:caml_root,device:new MlFakeDevice(caml_root)});\n}\njsoo_mount_point.push({path:\"/static/\", device:new MlFakeDevice(\"/static/\")});\n\n//Provides:caml_list_mount_point\n//Requires: jsoo_mount_point, caml_string_of_jsbytes\nfunction caml_list_mount_point(){\n var prev = 0\n for(var i = 0; i < jsoo_mount_point.length; i++){\n var old = prev;\n prev = [0, caml_string_of_jsbytes(jsoo_mount_point[i].path), old]\n }\n return prev;\n}\n\n//Provides: resolve_fs_device\n//Requires: caml_make_path, jsoo_mount_point, caml_raise_sys_error, caml_get_root, MlNodeDevice, caml_trailing_slash, fs_node_supported\nfunction resolve_fs_device(name){\n var path = caml_make_path(name);\n var name = path.join(\"/\");\n var name_slash = caml_trailing_slash(name);\n var res;\n for(var i = 0; i < jsoo_mount_point.length; i++) {\n var m = jsoo_mount_point[i];\n if(name_slash.search(m.path) == 0\n && (!res || res.path.length < m.path.length))\n res = {path:m.path,device:m.device,rest:name.substring(m.path.length,name.length)};\n }\n if( !res && fs_node_supported()) {\n var root = caml_get_root(name);\n if (root && root.match(/^[a-zA-Z]:\\/$/)){\n var m = {path:root,device:new MlNodeDevice(root)};\n jsoo_mount_point.push(m);\n res = {path:m.path,device:m.device,rest:name.substring(m.path.length,name.length)};\n }\n }\n if( res ) return res;\n caml_raise_sys_error(\"no device found for \" + name_slash);\n}\n\n//Provides: caml_mount_autoload\n//Requires: MlFakeDevice, caml_make_path, jsoo_mount_point, caml_trailing_slash\nfunction caml_mount_autoload(name,f){\n var path = caml_make_path(name);\n var name = caml_trailing_slash(path.join(\"/\"));\n jsoo_mount_point.push({path:name,device:new MlFakeDevice(name,f)})\n return 0;\n}\n\n//Provides: caml_unmount\n//Requires: jsoo_mount_point, caml_make_path, caml_trailing_slash\nfunction caml_unmount(name){\n var path = caml_make_path(name);\n var name = caml_trailing_slash(path.join(\"/\"));\n var idx = -1;\n for(var i = 0; i < jsoo_mount_point.length; i++)\n if(jsoo_mount_point[i].path == name) idx = i;\n if(idx > -1) jsoo_mount_point.splice(idx,1);\n return 0\n}\n\n//Provides: caml_sys_getcwd\n//Requires: caml_current_dir, caml_string_of_jsbytes\nfunction caml_sys_getcwd() {\n return caml_string_of_jsbytes(caml_current_dir);\n}\n\n//Provides: caml_sys_chdir\n//Requires: caml_current_dir, caml_raise_no_such_file, resolve_fs_device, caml_trailing_slash, caml_jsbytes_of_string\nfunction caml_sys_chdir(dir) {\n var root = resolve_fs_device(dir);\n if(root.device.exists(root.rest)) {\n if(root.rest) caml_current_dir = caml_trailing_slash(root.path + root.rest);\n else caml_current_dir = root.path;\n return 0;\n }\n else {\n caml_raise_no_such_file(caml_jsbytes_of_string(dir));\n }\n}\n\n//Provides: caml_raise_no_such_file\n//Requires: caml_raise_sys_error\nfunction caml_raise_no_such_file(name){\n caml_raise_sys_error (name + \": No such file or directory\");\n}\n\n//Provides: caml_raise_not_a_dir\n//Requires: caml_raise_sys_error\nfunction caml_raise_not_a_dir(name){\n caml_raise_sys_error (name + \": Not a directory\");\n}\n\n//Provides: caml_sys_file_exists\n//Requires: resolve_fs_device\nfunction caml_sys_file_exists (name) {\n var root = resolve_fs_device(name);\n return root.device.exists(root.rest);\n}\n\n//Provides: caml_sys_read_directory\n//Requires: caml_string_of_jsbytes\n//Requires: caml_raise_not_a_dir, resolve_fs_device\nfunction caml_sys_read_directory(name){\n var root = resolve_fs_device(name);\n var a = root.device.readdir(root.rest);\n var l = new Array(a.length + 1);\n l[0] = 0;\n for(var i=0;i start) r+=\", \";\n var v = bucket[i]\n if(typeof v == \"number\")\n r+= v.toString();\n else if(v instanceof MlBytes){\n r+= '\"' + v.toString() + '\"';\n }\n else if(typeof v == \"string\"){\n r+= '\"' + v.toString() + '\"';\n }\n else r += \"_\";\n }\n r += \")\"\n } else if (exn[0] == 248){\n r += exn[1]\n }\n return r\n}\n\n//Provides: caml_fatal_uncaught_exception\n//Requires: caml_named_value, caml_format_exception\nfunction caml_fatal_uncaught_exception(err){\n if(err instanceof Array && (err[0] == 0 || err[0] == 248)) {\n var handler = caml_named_value(\"Printexc.handle_uncaught_exception\");\n if(handler) handler(err,false);\n else {\n var msg = caml_format_exception(err);\n var at_exit = caml_named_value(\"Pervasives.do_at_exit\");\n if(at_exit) { at_exit(0) }\n globalThis.console.error(\"Fatal error: exception \" + msg + \"\\n\");\n }\n }\n else {\n throw err\n }\n}\n\n\n//Provides: caml_set_static_env\nfunction caml_set_static_env(k,v){\n if(!globalThis.jsoo_static_env)\n globalThis.jsoo_static_env = {}\n globalThis.jsoo_static_env[k] = v;\n return 0;\n}\n//Provides: caml_sys_getenv (const)\n//Requires: caml_raise_not_found\n//Requires: caml_string_of_jsstring\n//Requires: caml_jsstring_of_string\nfunction caml_sys_getenv (name) {\n var g = globalThis;\n var n = caml_jsstring_of_string(name);\n //nodejs env\n if(g.process\n && g.process.env\n && g.process.env[n] != undefined)\n return caml_string_of_jsstring(g.process.env[n]);\n if(globalThis.jsoo_static_env\n && globalThis.jsoo_static_env[n])\n return caml_string_of_jsstring(globalThis.jsoo_static_env[n])\n caml_raise_not_found ();\n}\n\n//Provides: caml_sys_unsafe_getenv\n//Requires: caml_sys_getenv\nfunction caml_sys_unsafe_getenv(name){\n return caml_sys_getenv (name);\n}\n\n//Provides: caml_argv\n//Requires: caml_string_of_jsstring\nvar caml_argv = ((function () {\n var g = globalThis;\n var main = \"a.out\";\n var args = []\n\n if(g.process\n && g.process.argv\n && g.process.argv.length > 1) {\n var argv = g.process.argv\n //nodejs\n main = argv[1];\n args = argv.slice(2);\n }\n\n var p = caml_string_of_jsstring(main);\n var args2 = [0, p];\n for(var i = 0; i < args.length; i++)\n args2.push(caml_string_of_jsstring(args[i]));\n return args2;\n})())\n\n//Provides: caml_executable_name\n//Requires: caml_argv\nvar caml_executable_name = caml_argv[1]\n\n//Provides: caml_sys_get_argv\n//Requires: caml_argv\nfunction caml_sys_get_argv (a) {\n return [0, caml_argv[1], caml_argv];\n}\n\n//Provides: caml_sys_argv\n//Requires: caml_argv\nfunction caml_sys_argv (a) {\n return caml_argv;\n}\n\n//Provides: caml_sys_modify_argv\n//Requires: caml_argv\nfunction caml_sys_modify_argv(arg){\n caml_argv = arg;\n return 0;\n}\n\n//Provides: caml_sys_executable_name const\n//Requires: caml_executable_name\nfunction caml_sys_executable_name(a){\n return caml_executable_name\n}\n\n//Provides: caml_sys_system_command\n//Requires: caml_jsstring_of_string\nfunction caml_sys_system_command(cmd){\n var cmd = caml_jsstring_of_string(cmd);\n if (typeof require != \"undefined\"\n && require('child_process')\n && require('child_process').execSync) {\n try {require('child_process').execSync(cmd,{stdio: 'inherit'}); return 0}\n catch (e) {return 1}\n }\n else return 127;\n}\n\n//Provides: caml_sys_time mutable\nvar caml_initial_time = (new Date()).getTime() * 0.001;\nfunction caml_sys_time () {\n var now = (new Date()).getTime();\n return now * 0.001 - caml_initial_time;\n}\n\n//Provides: caml_sys_time_include_children\n//Requires: caml_sys_time\nfunction caml_sys_time_include_children(b) {\n return caml_sys_time();\n}\n\n//Provides: caml_sys_random_seed mutable\n//The function needs to return an array since OCaml 4.0...\nfunction caml_sys_random_seed () {\n if(globalThis.crypto) {\n if(typeof globalThis.crypto.getRandomValues === 'function'){\n // Webbrowsers\n var a = new globalThis.Uint32Array(1);\n globalThis.crypto.getRandomValues(a);\n return [0,a[0]];\n } else if(globalThis.crypto.randomBytes === 'function'){\n // Nodejs\n var buff = globalThis.crypto.randomBytes(4);\n var a = new globalThis.Uint32Array(buff);\n return [0,a[0]];\n }\n }\n var now = (new Date()).getTime();\n var x = now^0xffffffff*Math.random();\n return [0,x];\n}\n\n//Provides: caml_sys_const_big_endian const\nfunction caml_sys_const_big_endian () { return 0; }\n\n//Provides: caml_sys_const_word_size const\nfunction caml_sys_const_word_size () { return 32; }\n\n//Provides: caml_sys_const_int_size const\nfunction caml_sys_const_int_size () { return 32; }\n\n//Provides: caml_sys_const_max_wosize const\n// max_int / 4 so that the following does not overflow\n//let max_string_length = word_size / 8 * max_array_length - 1;;\nfunction caml_sys_const_max_wosize () { return (0x7FFFFFFF/4) | 0;}\n\n//Provides: caml_sys_const_ostype_unix const\n//Requires: os_type\nfunction caml_sys_const_ostype_unix () { return os_type == \"Unix\" ? 1 : 0; }\n//Provides: caml_sys_const_ostype_win32 const\n//Requires: os_type\nfunction caml_sys_const_ostype_win32 () { return os_type == \"Win32\" ? 1 : 0; }\n//Provides: caml_sys_const_ostype_cygwin const\n//Requires: os_type\nfunction caml_sys_const_ostype_cygwin () { return os_type == \"Cygwin\" ? 1 : 0; }\n\n//Provides: caml_sys_const_backend_type const\n//Requires: caml_string_of_jsbytes\nfunction caml_sys_const_backend_type () {\n return [0, caml_string_of_jsbytes(\"js_of_ocaml\")];\n}\n\n//Provides: os_type\nvar os_type = (globalThis.process &&\n globalThis.process.platform &&\n globalThis.process.platform == \"win32\") ? \"Cygwin\" : \"Unix\";\n\n\n//Provides: caml_sys_get_config const\n//Requires: caml_string_of_jsbytes, os_type\nfunction caml_sys_get_config () {\n return [0, caml_string_of_jsbytes(os_type), 32, 0];\n}\n\n//Provides: caml_sys_isatty\nfunction caml_sys_isatty(_chan) {\n return 0;\n}\n\n//Provides: caml_runtime_variant\n//Requires: caml_string_of_jsbytes\nfunction caml_runtime_variant(_unit) {\n return caml_string_of_jsbytes(\"\");\n}\n//Provides: caml_runtime_parameters\n//Requires: caml_string_of_jsbytes\nfunction caml_runtime_parameters(_unit) {\n return caml_string_of_jsbytes(\"\");\n}\n\n//Provides: caml_install_signal_handler const\nfunction caml_install_signal_handler(){return 0}\n\n//Provides: unix_inet_addr_of_string\nfunction unix_inet_addr_of_string () {return 0;}\n\n\n\n//Provides: caml_runtime_warnings\nvar caml_runtime_warnings = 0;\n\n//Provides: caml_ml_enable_runtime_warnings\n//Requires: caml_runtime_warnings\nfunction caml_ml_enable_runtime_warnings (bool) {\n caml_runtime_warnings = bool;\n return 0;\n}\n\n//Provides: caml_ml_runtime_warnings_enabled\n//Requires: caml_runtime_warnings\nfunction caml_ml_runtime_warnings_enabled (_unit) {\n return caml_runtime_warnings;\n}\n\n\n//Provides: caml_spacetime_enabled const (const)\nfunction caml_spacetime_enabled(_unit) {\n return 0;\n}\n\n//Provides: caml_sys_const_naked_pointers_checked const (const)\nfunction caml_sys_const_naked_pointers_checked(_unit) {\n return 0;\n}\n\n//Provides: caml_register_channel_for_spacetime const (const)\nfunction caml_register_channel_for_spacetime(_channel) {\n return 0;\n}\n\n//Provides: caml_spacetime_only_works_for_native_code\n//Requires: caml_failwith\nfunction caml_spacetime_only_works_for_native_code() {\n caml_failwith(\"Spacetime profiling only works for native code\");\n}\n\n//Always\n//Requires: caml_fatal_uncaught_exception\nfunction caml_setup_uncaught_exception_handler() {\n var g = globalThis;\n if(g.process && g.process.on) {\n g.process.on('uncaughtException', function (err, origin) {\n caml_fatal_uncaught_exception(err);\n g.process.exit (2);\n })\n }\n else if(g.addEventListener){\n g.addEventListener('error', function(event){\n if(event.error){\n caml_fatal_uncaught_exception(event.error);\n }\n });\n }\n}\ncaml_setup_uncaught_exception_handler();\n","// Js_of_ocaml runtime support\n// http://www.ocsigen.org/js_of_ocaml/\n// Copyright (C) 2014 Jérôme Vouillon, Hugo Heuzard\n// Laboratoire PPS - CNRS Université Paris Diderot\n//\n// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU Lesser General Public License as published by\n// the Free Software Foundation, with linking exception;\n// either version 2.1 of the License, or (at your option) any later version.\n//\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n// GNU Lesser General Public License for more details.\n//\n// You should have received a copy of the GNU Lesser General Public License\n// along with this program; if not, write to the Free Software\n// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n\n//Provides: MlFakeDevice\n//Requires: MlFakeFile, caml_create_bytes\n//Requires: caml_raise_sys_error, caml_raise_no_such_file\n//Requires: caml_string_of_jsbytes, caml_string_of_jsstring\n//Requires: caml_bytes_of_array, caml_bytes_of_string, caml_bytes_of_jsbytes\n//Requires: caml_is_ml_bytes, caml_is_ml_string\n//Requires: caml_named_value, caml_raise_with_args, caml_named_values\n//Requires: make_unix_err_args\nfunction MlFakeDevice (root, f) {\n this.content={};\n this.root = root;\n this.lookupFun = f;\n}\nMlFakeDevice.prototype.nm = function(name) {\n return (this.root + name);\n}\nMlFakeDevice.prototype.create_dir_if_needed = function(name) {\n var comp = name.split(\"/\");\n var res = \"\";\n for(var i = 0; i < comp.length - 1; i++){\n res += comp[i] + \"/\";\n if(this.content[res]) continue;\n this.content[res] = Symbol(\"directory\");\n }\n}\nMlFakeDevice.prototype.slash = function(name){\n return /\\/$/.test(name)?name:(name + \"/\");\n}\nMlFakeDevice.prototype.lookup = function(name) {\n if(!this.content[name] && this.lookupFun) {\n var res = this.lookupFun(caml_string_of_jsbytes(this.root), caml_string_of_jsbytes(name));\n if(res !== 0) {\n this.create_dir_if_needed(name);\n this.content[name]=new MlFakeFile(caml_bytes_of_string(res[1]));\n }\n }\n}\nMlFakeDevice.prototype.exists = function(name) {\n // The root of the device exists\n if(name == \"\") return 1;\n // Check if a directory exists\n var name_slash = this.slash(name);\n if(this.content[name_slash]) return 1;\n // Check if a file exists\n this.lookup(name);\n return this.content[name]?1:0;\n}\nMlFakeDevice.prototype.mkdir = function(name,mode, raise_unix) {\n var unix_error = raise_unix && caml_named_value('Unix.Unix_error');\n if(this.exists(name)) {\n if (unix_error) {\n caml_raise_with_args(unix_error, make_unix_err_args(\"EEXIST\", \"mkdir\", this.nm(name)));\n }\n else {\n caml_raise_sys_error(name + \": File exists\");\n }\n }\n var parent = /^(.*)\\/[^/]+/.exec(name);\n parent = (parent && parent[1]) || '';\n if(!this.exists(parent)){\n if (unix_error) {\n caml_raise_with_args(unix_error, make_unix_err_args(\"ENOENT\", \"mkdir\", this.nm(parent)));\n }\n else {\n caml_raise_sys_error(parent + \": No such file or directory\");\n }\n }\n if(!this.is_dir(parent)){\n if (unix_error) {\n caml_raise_with_args(unix_error, make_unix_err_args(\"ENOTDIR\", \"mkdir\", this.nm(parent)));\n }\n else {\n caml_raise_sys_error(parent + \": Not a directory\");\n }\n }\n this.create_dir_if_needed(this.slash(name));\n}\nMlFakeDevice.prototype.rmdir = function(name, raise_unix) {\n var unix_error = raise_unix && caml_named_value('Unix.Unix_error');\n var name_slash = (name == \"\")?\"\":(this.slash(name));\n var r = new RegExp(\"^\" + name_slash + \"([^/]+)\");\n if(!this.exists(name)) {\n if (unix_error) {\n caml_raise_with_args(unix_error, make_unix_err_args(\"ENOENT\", \"rmdir\", this.nm(name)));\n }\n else {\n caml_raise_sys_error(name + \": No such file or directory\");\n }\n }\n if(!this.is_dir(name)) {\n if (unix_error) {\n caml_raise_with_args(unix_error, make_unix_err_args(\"ENOTDIR\", \"rmdir\", this.nm(name)));\n }\n else {\n caml_raise_sys_error(name + \": Not a directory\");\n }\n }\n for(var n in this.content) {\n if(n.match(r)) {\n if (unix_error) {\n caml_raise_with_args(unix_error, make_unix_err_args(\"ENOTEMPTY\", \"rmdir\", this.nm(name)));\n } else {\n caml_raise_sys_error(this.nm(name) + \": Directory not empty\");\n }\n }\n }\n delete this.content[name_slash];\n}\nMlFakeDevice.prototype.readdir = function(name) {\n var name_slash = (name == \"\")?\"\":(this.slash(name));\n if(!this.exists(name)) {\n caml_raise_sys_error(name + \": No such file or directory\");\n }\n if(!this.is_dir(name)) {\n caml_raise_sys_error(name + \": Not a directory\");\n }\n var r = new RegExp(\"^\" + name_slash + \"([^/]+)\");\n var seen = {}\n var a = [];\n for(var n in this.content) {\n var m = n.match(r);\n if(m && !seen[m[1]]) {seen[m[1]] = true; a.push(m[1])}\n }\n return a;\n}\nMlFakeDevice.prototype.is_dir = function(name) {\n if(name == \"\") return true;\n var name_slash = this.slash(name);\n return this.content[name_slash]?1:0;\n}\nMlFakeDevice.prototype.unlink = function(name) {\n var ok = this.content[name]?true:false;\n delete this.content[name];\n return ok;\n}\nMlFakeDevice.prototype.open = function(name, f) {\n if(f.rdonly && f.wronly)\n caml_raise_sys_error(this.nm(name) + \" : flags Open_rdonly and Open_wronly are not compatible\");\n if(f.text && f.binary)\n caml_raise_sys_error(this.nm(name) + \" : flags Open_text and Open_binary are not compatible\");\n this.lookup(name);\n if (this.content[name]) {\n if (this.is_dir(name)) caml_raise_sys_error(this.nm(name) + \" : is a directory\");\n if (f.create && f.excl) caml_raise_sys_error(this.nm(name) + \" : file already exists\");\n var file = this.content[name];\n if(f.truncate) file.truncate();\n return file;\n } else if (f.create) {\n this.create_dir_if_needed(name);\n this.content[name] = new MlFakeFile(caml_create_bytes(0));\n return this.content[name];\n } else {\n caml_raise_no_such_file (this.nm(name));\n }\n}\n\nMlFakeDevice.prototype.register= function (name,content){\n var file;\n if(this.content[name]) caml_raise_sys_error(this.nm(name) + \" : file already exists\");\n if(caml_is_ml_bytes(content))\n file = new MlFakeFile(content);\n if(caml_is_ml_string(content))\n file = new MlFakeFile(caml_bytes_of_string(content));\n else if(content instanceof Array)\n file = new MlFakeFile(caml_bytes_of_array(content));\n else if(typeof content === \"string\")\n file = new MlFakeFile(caml_bytes_of_jsbytes(content));\n else if(content.toString) {\n var bytes = caml_bytes_of_string(caml_string_of_jsstring(content.toString()));\n file = new MlFakeFile(bytes);\n }\n if(file){\n this.create_dir_if_needed(name);\n this.content[name] = file;\n }\n else caml_raise_sys_error(this.nm(name) + \" : registering file with invalid content type\");\n}\n\nMlFakeDevice.prototype.constructor = MlFakeDevice\n\n//Provides: MlFakeFile\n//Requires: MlFile\n//Requires: caml_create_bytes, caml_ml_bytes_length, caml_blit_bytes, caml_blit_string\n//Requires: caml_bytes_get\nfunction MlFakeFile(content){\n this.data = content;\n}\nMlFakeFile.prototype = new MlFile ();\nMlFakeFile.prototype.truncate = function(len){\n var old = this.data;\n this.data = caml_create_bytes(len|0);\n caml_blit_bytes(old, 0, this.data, 0, len);\n}\nMlFakeFile.prototype.length = function () {\n return caml_ml_bytes_length(this.data);\n}\nMlFakeFile.prototype.write = function(offset,buf,pos,len){\n var clen = this.length();\n if(offset + len >= clen) {\n var new_str = caml_create_bytes(offset + len);\n var old_data = this.data;\n this.data = new_str;\n caml_blit_bytes(old_data, 0, this.data, 0, clen);\n }\n caml_blit_string(buf, pos, this.data, offset, len);\n return 0\n}\nMlFakeFile.prototype.read = function(offset,buf,pos,len){\n var clen = this.length();\n caml_blit_bytes(this.data, offset, buf, pos, len);\n return 0\n}\nMlFakeFile.prototype.read_one = function(offset){\n return caml_bytes_get(this.data, offset);\n}\nMlFakeFile.prototype.close = function(){\n\n}\nMlFakeFile.prototype.constructor = MlFakeFile\n","// Js_of_ocaml runtime support\n// http://www.ocsigen.org/js_of_ocaml/\n// Copyright (C) 2014 Jérôme Vouillon, Hugo Heuzard\n// Laboratoire PPS - CNRS Université Paris Diderot\n//\n// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU Lesser General Public License as published by\n// the Free Software Foundation, with linking exception;\n// either version 2.1 of the License, or (at your option) any later version.\n//\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n// GNU Lesser General Public License for more details.\n//\n// You should have received a copy of the GNU Lesser General Public License\n// along with this program; if not, write to the Free Software\n// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n\n///////////// Io\n\n//Provides: caml_sys_close\n//Requires: caml_global_data\nfunction caml_sys_close(fd) {\n delete caml_global_data.fds[fd];\n return 0;\n}\n\n//Provides: caml_std_output\n//Requires: caml_string_of_jsbytes, caml_ml_string_length, caml_ml_channels\nfunction caml_std_output(chanid,s){\n var chan = caml_ml_channels[chanid];\n var str = caml_string_of_jsbytes(s);\n var slen = caml_ml_string_length(str);\n chan.file.write(chan.offset, str, 0, slen);\n chan.offset += slen;\n return 0;\n}\n\n//Provides: caml_sys_open\n//Requires: caml_raise_sys_error, caml_global_data\n//Requires: caml_create_bytes,MlFakeFile\n//Requires: js_print_stderr, js_print_stdout\n//Requires: caml_std_output\n//Requires: resolve_fs_device\n//Requires: caml_jsbytes_of_string\nfunction caml_sys_open_internal(idx,output,file,flags) {\n if(caml_global_data.fds === undefined) caml_global_data.fds = new Array();\n flags=flags?flags:{};\n var info = {};\n info.file = file;\n info.offset = flags.append?file.length():0;\n info.flags = flags;\n info.output = output;\n caml_global_data.fds[idx] = info;\n if(!caml_global_data.fd_last_idx || idx > caml_global_data.fd_last_idx)\n caml_global_data.fd_last_idx = idx;\n return idx;\n}\nfunction caml_sys_open (name, flags, _perms) {\n var f = {};\n while(flags){\n switch(flags[1]){\n case 0: f.rdonly = 1;break;\n case 1: f.wronly = 1;break;\n case 2: f.append = 1;break;\n case 3: f.create = 1;break;\n case 4: f.truncate = 1;break;\n case 5: f.excl = 1; break;\n case 6: f.binary = 1;break;\n case 7: f.text = 1;break;\n case 8: f.nonblock = 1;break;\n }\n flags=flags[2];\n }\n if(f.rdonly && f.wronly)\n caml_raise_sys_error(caml_jsbytes_of_string(name) + \" : flags Open_rdonly and Open_wronly are not compatible\");\n if(f.text && f.binary)\n caml_raise_sys_error(caml_jsbytes_of_string(name) + \" : flags Open_text and Open_binary are not compatible\");\n var root = resolve_fs_device(name);\n var file = root.device.open(root.rest,f);\n var idx = caml_global_data.fd_last_idx?caml_global_data.fd_last_idx:0;\n return caml_sys_open_internal (idx+1,caml_std_output,file,f);\n}\ncaml_sys_open_internal(0,caml_std_output, new MlFakeFile(caml_create_bytes(0))); //stdin\ncaml_sys_open_internal(1,js_print_stdout, new MlFakeFile(caml_create_bytes(0))); //stdout\ncaml_sys_open_internal(2,js_print_stderr, new MlFakeFile(caml_create_bytes(0))); //stderr\n\n\n// ocaml Channels\n\n//Provides: caml_ml_set_channel_name\nfunction caml_ml_set_channel_name() {\n return 0\n}\n\n//Provides: caml_ml_channels\nvar caml_ml_channels = new Array();\n\n//Provides: caml_ml_out_channels_list\n//Requires: caml_ml_channels\nfunction caml_ml_out_channels_list () {\n var l = 0;\n for(var c = 0; c < caml_ml_channels.length; c++){\n if(caml_ml_channels[c] && caml_ml_channels[c].opened && caml_ml_channels[c].out)\n l=[0,caml_ml_channels[c].fd,l];\n }\n return l;\n}\n\n\n//Provides: caml_ml_open_descriptor_out\n//Requires: caml_ml_channels, caml_global_data\n//Requires: caml_raise_sys_error\nfunction caml_ml_open_descriptor_out (fd) {\n var data = caml_global_data.fds[fd];\n if(data.flags.rdonly) caml_raise_sys_error(\"fd \"+ fd + \" is readonly\");\n var channel = {\n file:data.file,\n offset:data.offset,\n fd:fd,\n opened:true,\n out:true,\n buffer:\"\"\n };\n caml_ml_channels[channel.fd]=channel;\n return channel.fd;\n}\n\n//Provides: caml_ml_open_descriptor_in\n//Requires: caml_global_data,caml_sys_open,caml_raise_sys_error, caml_ml_channels\n//Requires: fs_node_supported, caml_string_of_jsstring\nfunction caml_ml_open_descriptor_in (fd) {\n var data = caml_global_data.fds[fd];\n if(data.flags.wronly) caml_raise_sys_error(\"fd \"+ fd + \" is writeonly\");\n var refill = null;\n if(fd == 0 && fs_node_supported()){\n var fs = require('fs');\n refill = function () {\n return caml_string_of_jsstring(fs.readFileSync(0, 'utf8'))};\n }\n var channel = {\n file:data.file,\n offset:data.offset,\n fd:fd,\n opened:true,\n out: false,\n refill:refill\n };\n caml_ml_channels[channel.fd]=channel;\n return channel.fd;\n}\n\n\n//Provides: caml_channel_descriptor\n//Requires: caml_global_data, caml_ml_channels\nfunction caml_channel_descriptor(chanid){\n var chan = caml_ml_channels[chanid];\n return chan.fd;\n}\n\n//Provides: win_filedescr_of_channel\n//Requires: caml_channel_descriptor\nvar win_filedescr_of_channel = caml_channel_descriptor\n\n//Provides: caml_ml_set_binary_mode\n//Requires: caml_global_data, caml_ml_channels\nfunction caml_ml_set_binary_mode(chanid,mode){\n var chan = caml_ml_channels[chanid];\n var data = caml_global_data.fds[chan.fd];\n data.flags.text = !mode\n data.flags.binary = mode\n return 0;\n}\n\n//Input from in_channel\n\n//Provides: caml_ml_close_channel\n//Requires: caml_ml_flush, caml_ml_channels\n//Requires: caml_sys_close\nfunction caml_ml_close_channel (chanid) {\n var chan = caml_ml_channels[chanid];\n caml_ml_flush(chanid);\n chan.opened = false;\n chan.file.close();\n caml_sys_close(chan.fd)\n return 0;\n}\n\n//Provides: caml_ml_channel_size\n//Requires: caml_ml_channels\nfunction caml_ml_channel_size(chanid) {\n var chan = caml_ml_channels[chanid];\n return chan.file.length();\n}\n\n//Provides: caml_ml_channel_size_64\n//Requires: caml_int64_of_float,caml_ml_channels\nfunction caml_ml_channel_size_64(chanid) {\n var chan = caml_ml_channels[chanid];\n return caml_int64_of_float(chan.file.length ());\n}\n\n//Provides: caml_ml_set_channel_output\n//Requires: caml_ml_channels, caml_global_data\nfunction caml_ml_set_channel_output(chanid,f) {\n var chan = caml_ml_channels[chanid];\n caml_global_data.fds[chan.fd].output = f;\n return 0;\n}\n\n//Provides: caml_ml_set_channel_refill\n//Requires: caml_ml_channels, caml_global_data\nfunction caml_ml_set_channel_refill(chanid,f) {\n caml_ml_channels[chanid].refill = f;\n return 0;\n}\n\n//Provides: caml_ml_refill_input\n//Requires: caml_ml_string_length\nfunction caml_ml_refill_input (chan) {\n var str = chan.refill();\n var str_len = caml_ml_string_length(str);\n if (str_len == 0) chan.refill = null;\n chan.file.write(chan.file.length(), str, 0, str_len);\n return str_len;\n}\n\n//Provides: caml_ml_may_refill_input\n//Requires: caml_ml_refill_input, caml_ml_channels\nfunction caml_ml_may_refill_input (chanid) {\n var chan = caml_ml_channels[chanid];\n if (chan.refill == null) return;\n if (chan.file.length() != chan.offset) return;\n caml_ml_refill_input (chan);\n}\n\n//Provides: caml_ml_input\n//Requires: caml_ml_refill_input, caml_ml_channels\nfunction caml_ml_input (chanid, s, i, l) {\n var chan = caml_ml_channels[chanid];\n var l2 = chan.file.length() - chan.offset;\n if (l2 == 0 && chan.refill != null) l2 = caml_ml_refill_input(chan);\n if (l2 < l) l = l2;\n chan.file.read(chan.offset, s, i, l);\n chan.offset += l;\n return l;\n}\n\n//Provides: caml_input_value\n//Requires: caml_marshal_data_size, caml_input_value_from_bytes, caml_create_bytes, caml_ml_channels\nfunction caml_input_value (chanid) {\n var chan = caml_ml_channels[chanid];\n\n var buf = caml_create_bytes(8);\n chan.file.read(chan.offset,buf,0,8);\n\n // Header is 20 bytes\n var len = caml_marshal_data_size (buf, 0) + 20;\n\n var buf = caml_create_bytes(len);\n chan.file.read(chan.offset,buf,0,len);\n\n var offset = [0];\n var res = caml_input_value_from_bytes(buf, offset);\n chan.offset = chan.offset + offset[0];\n return res;\n}\n\n//Provides: caml_ml_input_char\n//Requires: caml_raise_end_of_file, caml_array_bound_error\n//Requires: caml_ml_may_refill_input, caml_ml_channels\nfunction caml_ml_input_char (chanid) {\n var chan = caml_ml_channels[chanid];\n caml_ml_may_refill_input(chanid);\n if (chan.offset >= chan.file.length())\n caml_raise_end_of_file();\n var res = chan.file.read_one(chan.offset);\n chan.offset++;\n return res;\n}\n\n//Provides: caml_ml_input_int\n//Requires: caml_raise_end_of_file\n//Requires: caml_ml_refill_input, caml_ml_channels\nfunction caml_ml_input_int (chanid) {\n var chan = caml_ml_channels[chanid];\n var file = chan.file;\n while ((chan.offset + 3) >= file.length()) {\n var l = caml_ml_refill_input(chan);\n if (l == 0) caml_raise_end_of_file();\n }\n var o = chan.offset;\n var r =(file.read_one(o ) << 24)\n | (file.read_one(o+1) << 16)\n | (file.read_one(o+2) << 8)\n | (file.read_one(o+3));\n chan.offset+=4;\n return r;\n}\n\n//Provides: caml_ml_seek_in\n//Requires: caml_raise_sys_error, caml_ml_channels\nfunction caml_ml_seek_in(chanid,pos){\n var chan = caml_ml_channels[chanid];\n if (chan.refill != null) caml_raise_sys_error(\"Illegal seek\");\n chan.offset = pos;\n return 0;\n}\n\n//Provides: caml_ml_seek_in_64\n//Requires: caml_int64_to_float, caml_raise_sys_error, caml_ml_channels\nfunction caml_ml_seek_in_64(chanid,pos){\n var chan = caml_ml_channels[chanid];\n if (chan.refill != null) caml_raise_sys_error(\"Illegal seek\");\n chan.offset = caml_int64_to_float(pos);\n return 0;\n}\n\n//Provides: caml_ml_pos_in\n//Requires: caml_ml_channels\nfunction caml_ml_pos_in(chanid) {return caml_ml_channels[chanid].offset}\n\n//Provides: caml_ml_pos_in_64\n//Requires: caml_int64_of_float, caml_ml_channels\nfunction caml_ml_pos_in_64(chanid) {return caml_int64_of_float(caml_ml_channels[chanid].offset)}\n\n//Provides: caml_ml_input_scan_line\n//Requires: caml_array_bound_error\n//Requires: caml_ml_may_refill_input, caml_ml_channels\nfunction caml_ml_input_scan_line(chanid){\n var chan = caml_ml_channels[chanid];\n caml_ml_may_refill_input(chanid);\n var p = chan.offset;\n var len = chan.file.length();\n if(p >= len) { return 0;}\n while(true) {\n if(p >= len) return - (p - chan.offset);\n if(chan.file.read_one(p) == 10) return p - chan.offset + 1;\n p++;\n }\n}\n\n//Provides: caml_ml_flush\n//Requires: caml_raise_sys_error, caml_global_data, caml_ml_channels\nfunction caml_ml_flush (chanid) {\n var chan = caml_ml_channels[chanid];\n if(! chan.opened) caml_raise_sys_error(\"Cannot flush a closed channel\");\n if(!chan.buffer || chan.buffer == \"\") return 0;\n if(chan.fd\n && caml_global_data.fds[chan.fd]\n && caml_global_data.fds[chan.fd].output) {\n var output = caml_global_data.fds[chan.fd].output;\n switch(output.length){\n case 2: output(chanid,chan.buffer);break;\n default: output(chan.buffer)\n };\n }\n chan.buffer = \"\";\n return 0;\n}\n\n//output to out_channel\n\n//Provides: caml_ml_output_bytes\n//Requires: caml_ml_flush,caml_ml_bytes_length\n//Requires: caml_create_bytes, caml_blit_bytes, caml_raise_sys_error, caml_ml_channels, caml_string_of_bytes\n//Requires: caml_jsbytes_of_string\nfunction caml_ml_output_bytes(chanid,buffer,offset,len) {\n var chan = caml_ml_channels[chanid];\n if(! chan.opened) caml_raise_sys_error(\"Cannot output to a closed channel\");\n var bytes;\n if(offset == 0 && caml_ml_bytes_length(buffer) == len)\n bytes = buffer;\n else {\n bytes = caml_create_bytes(len);\n caml_blit_bytes(buffer,offset,bytes,0,len);\n }\n var string = caml_string_of_bytes(bytes);\n var jsstring = caml_jsbytes_of_string(string);\n var id = jsstring.lastIndexOf(\"\\n\");\n if(id < 0)\n chan.buffer+=jsstring;\n else {\n chan.buffer+=jsstring.substr(0,id+1);\n caml_ml_flush (chanid);\n chan.buffer += jsstring.substr(id+1);\n }\n return 0;\n}\n\n//Provides: caml_ml_output\n//Requires: caml_ml_output_bytes, caml_bytes_of_string\nfunction caml_ml_output(chanid,buffer,offset,len){\n return caml_ml_output_bytes(chanid,caml_bytes_of_string(buffer),offset,len);\n}\n\n//Provides: caml_ml_output_char\n//Requires: caml_ml_output\n//Requires: caml_string_of_jsbytes\nfunction caml_ml_output_char (chanid,c) {\n var s = caml_string_of_jsbytes(String.fromCharCode(c));\n caml_ml_output(chanid,s,0,1);\n return 0;\n}\n\n//Provides: caml_output_value\n//Requires: caml_output_value_to_string, caml_ml_output,caml_ml_string_length\nfunction caml_output_value (chanid,v,flags) {\n var s = caml_output_value_to_string(v, flags);\n caml_ml_output(chanid,s,0,caml_ml_string_length(s));\n return 0;\n}\n\n\n//Provides: caml_ml_seek_out\n//Requires: caml_ml_channels, caml_ml_flush\nfunction caml_ml_seek_out(chanid,pos){\n caml_ml_flush(chanid);\n caml_ml_channels[chanid].offset = pos;\n return 0;\n}\n\n//Provides: caml_ml_seek_out_64\n//Requires: caml_int64_to_float, caml_ml_channels, caml_ml_flush\nfunction caml_ml_seek_out_64(chanid,pos){\n caml_ml_flush(chanid);\n caml_ml_channels[chanid].offset = caml_int64_to_float(pos);\n return 0;\n}\n\n//Provides: caml_ml_pos_out\n//Requires: caml_ml_channels, caml_ml_flush\nfunction caml_ml_pos_out(chanid) {\n caml_ml_flush(chanid);\n return caml_ml_channels[chanid].offset\n}\n\n//Provides: caml_ml_pos_out_64\n//Requires: caml_int64_of_float, caml_ml_channels, caml_ml_flush\nfunction caml_ml_pos_out_64(chanid) {\n caml_ml_flush(chanid);\n return caml_int64_of_float (caml_ml_channels[chanid].offset);\n}\n\n//Provides: caml_ml_output_int\n//Requires: caml_ml_output\n//Requires: caml_string_of_array\nfunction caml_ml_output_int (chanid,i) {\n var arr = [(i>>24) & 0xFF,(i>>16) & 0xFF,(i>>8) & 0xFF,i & 0xFF ];\n var s = caml_string_of_array(arr);\n caml_ml_output(chanid,s,0,4);\n return 0\n}\n\n//Provides: caml_ml_is_buffered\nfunction caml_ml_is_buffered(c) { return 1 }\n\n//Provides: caml_ml_set_buffered\nfunction caml_ml_set_buffered(c,v) { return 0 }\n","/***********************************************************************/\n/* */\n/* Objective Caml */\n/* */\n/* Xavier Leroy, projet Cristal, INRIA Rocquencourt */\n/* */\n/* Copyright 1996 Institut National de Recherche en Informatique et */\n/* en Automatique. All rights reserved. This file is distributed */\n/* under the terms of the GNU Lesser General Public License, with */\n/* the special exception on linking described in file ../LICENSE. */\n/* */\n/***********************************************************************/\n\n/* $Id: lexing.c 6045 2004-01-01 16:42:43Z doligez $ */\n\n/* The table-driven automaton for lexers generated by camllex. */\n\n//Provides: caml_lex_array\n//Requires: caml_jsbytes_of_string\nfunction caml_lex_array(s) {\n s = caml_jsbytes_of_string(s);\n var l = s.length / 2;\n var a = new Array(l);\n for (var i = 0; i < l; i++)\n a[i] = (s.charCodeAt(2 * i) | (s.charCodeAt(2 * i + 1) << 8)) << 16 >> 16;\n return a;\n}\n\n//Provides: caml_lex_engine\n//Requires: caml_failwith, caml_lex_array, caml_array_of_bytes\nfunction caml_lex_engine(tbl, start_state, lexbuf) {\n var lex_buffer = 2;\n var lex_buffer_len = 3;\n var lex_start_pos = 5;\n var lex_curr_pos = 6;\n var lex_last_pos = 7;\n var lex_last_action = 8;\n var lex_eof_reached = 9;\n var lex_base = 1;\n var lex_backtrk = 2;\n var lex_default = 3;\n var lex_trans = 4;\n var lex_check = 5;\n\n if (!tbl.lex_default) {\n tbl.lex_base = caml_lex_array (tbl[lex_base]);\n tbl.lex_backtrk = caml_lex_array (tbl[lex_backtrk]);\n tbl.lex_check = caml_lex_array (tbl[lex_check]);\n tbl.lex_trans = caml_lex_array (tbl[lex_trans]);\n tbl.lex_default = caml_lex_array (tbl[lex_default]);\n }\n\n var c, state = start_state;\n\n var buffer = caml_array_of_bytes(lexbuf[lex_buffer]);\n\n if (state >= 0) {\n /* First entry */\n lexbuf[lex_last_pos] = lexbuf[lex_start_pos] = lexbuf[lex_curr_pos];\n lexbuf[lex_last_action] = -1;\n } else {\n /* Reentry after refill */\n state = -state - 1;\n }\n for(;;) {\n /* Lookup base address or action number for current state */\n var base = tbl.lex_base[state];\n if (base < 0) return -base-1;\n /* See if it's a backtrack point */\n var backtrk = tbl.lex_backtrk[state];\n if (backtrk >= 0) {\n lexbuf[lex_last_pos] = lexbuf[lex_curr_pos];\n lexbuf[lex_last_action] = backtrk;\n }\n /* See if we need a refill */\n if (lexbuf[lex_curr_pos] >= lexbuf[lex_buffer_len]){\n if (lexbuf[lex_eof_reached] == 0)\n return -state - 1;\n else\n c = 256;\n }else{\n /* Read next input char */\n c = buffer[lexbuf[lex_curr_pos]];\n lexbuf[lex_curr_pos] ++;\n }\n /* Determine next state */\n if (tbl.lex_check[base + c] == state)\n state = tbl.lex_trans[base + c];\n else\n state = tbl.lex_default[state];\n /* If no transition on this char, return to last backtrack point */\n if (state < 0) {\n lexbuf[lex_curr_pos] = lexbuf[lex_last_pos];\n if (lexbuf[lex_last_action] == -1)\n caml_failwith(\"lexing: empty token\");\n else\n return lexbuf[lex_last_action];\n }else{\n /* Erase the EOF condition only if the EOF pseudo-character was\n consumed by the automaton (i.e. there was no backtrack above)\n */\n if (c == 256) lexbuf[lex_eof_reached] = 0;\n }\n }\n}\n\n/***********************************************/\n/* New lexer engine, with memory of positions */\n/***********************************************/\n\n//Provides: caml_new_lex_engine\n//Requires: caml_failwith, caml_lex_array\n//Requires: caml_jsbytes_of_string, caml_array_of_bytes\nfunction caml_lex_run_mem(s, i, mem, curr_pos) {\n for (;;) {\n var dst = s.charCodeAt(i); i++;\n if (dst == 0xff) return;\n var src = s.charCodeAt(i); i++;\n if (src == 0xff)\n mem [dst + 1] = curr_pos;\n else\n mem [dst + 1] = mem [src + 1];\n }\n}\n\nfunction caml_lex_run_tag(s, i, mem) {\n for (;;) {\n var dst = s.charCodeAt(i); i++;\n if (dst == 0xff) return ;\n var src = s.charCodeAt(i); i++;\n if (src == 0xff)\n mem [dst + 1] = -1;\n else\n mem [dst + 1] = mem [src + 1];\n }\n}\n\nfunction caml_new_lex_engine(tbl, start_state, lexbuf) {\n var lex_buffer = 2;\n var lex_buffer_len = 3;\n var lex_start_pos = 5;\n var lex_curr_pos = 6;\n var lex_last_pos = 7;\n var lex_last_action = 8;\n var lex_eof_reached = 9;\n var lex_mem = 10;\n var lex_base = 1;\n var lex_backtrk = 2;\n var lex_default = 3;\n var lex_trans = 4;\n var lex_check = 5;\n var lex_base_code = 6;\n var lex_backtrk_code = 7;\n var lex_default_code = 8;\n var lex_trans_code = 9;\n var lex_check_code = 10;\n var lex_code = 11;\n\n if (!tbl.lex_default) {\n tbl.lex_base = caml_lex_array (tbl[lex_base]);\n tbl.lex_backtrk = caml_lex_array (tbl[lex_backtrk]);\n tbl.lex_check = caml_lex_array (tbl[lex_check]);\n tbl.lex_trans = caml_lex_array (tbl[lex_trans]);\n tbl.lex_default = caml_lex_array (tbl[lex_default]);\n }\n if (!tbl.lex_default_code) {\n tbl.lex_base_code = caml_lex_array (tbl[lex_base_code]);\n tbl.lex_backtrk_code = caml_lex_array (tbl[lex_backtrk_code]);\n tbl.lex_check_code = caml_lex_array (tbl[lex_check_code]);\n tbl.lex_trans_code = caml_lex_array (tbl[lex_trans_code]);\n tbl.lex_default_code = caml_lex_array (tbl[lex_default_code]);\n }\n if (tbl.lex_code == null) tbl.lex_code = caml_jsbytes_of_string(tbl[lex_code]);\n\n var c, state = start_state;\n\n var buffer = caml_array_of_bytes(lexbuf[lex_buffer]);\n\n if (state >= 0) {\n /* First entry */\n lexbuf[lex_last_pos] = lexbuf[lex_start_pos] = lexbuf[lex_curr_pos];\n lexbuf[lex_last_action] = -1;\n } else {\n /* Reentry after refill */\n state = -state - 1;\n }\n for(;;) {\n /* Lookup base address or action number for current state */\n var base = tbl.lex_base[state];\n if (base < 0) {\n var pc_off = tbl.lex_base_code[state];\n caml_lex_run_tag(tbl.lex_code, pc_off, lexbuf[lex_mem]);\n return -base-1;\n }\n /* See if it's a backtrack point */\n var backtrk = tbl.lex_backtrk[state];\n if (backtrk >= 0) {\n var pc_off = tbl.lex_backtrk_code[state];\n caml_lex_run_tag(tbl.lex_code, pc_off, lexbuf[lex_mem]);\n lexbuf[lex_last_pos] = lexbuf[lex_curr_pos];\n lexbuf[lex_last_action] = backtrk;\n }\n /* See if we need a refill */\n if (lexbuf[lex_curr_pos] >= lexbuf[lex_buffer_len]){\n if (lexbuf[lex_eof_reached] == 0)\n return -state - 1;\n else\n c = 256;\n }else{\n /* Read next input char */\n c = buffer[lexbuf[lex_curr_pos]];\n lexbuf[lex_curr_pos] ++;\n }\n /* Determine next state */\n var pstate = state ;\n if (tbl.lex_check[base + c] == state)\n state = tbl.lex_trans[base + c];\n else\n state = tbl.lex_default[state];\n /* If no transition on this char, return to last backtrack point */\n if (state < 0) {\n lexbuf[lex_curr_pos] = lexbuf[lex_last_pos];\n if (lexbuf[lex_last_action] == -1)\n caml_failwith(\"lexing: empty token\");\n else\n return lexbuf[lex_last_action];\n }else{\n /* If some transition, get and perform memory moves */\n var base_code = tbl.lex_base_code[pstate], pc_off;\n if (tbl.lex_check_code[base_code + c] == pstate)\n pc_off = tbl.lex_trans_code[base_code + c];\n else\n pc_off = tbl.lex_default_code[pstate];\n if (pc_off > 0)\n caml_lex_run_mem\n (tbl.lex_code, pc_off, lexbuf[lex_mem], lexbuf[lex_curr_pos]);\n /* Erase the EOF condition only if the EOF pseudo-character was\n consumed by the automaton (i.e. there was no backtrack above)\n */\n if (c == 256) lexbuf[lex_eof_reached] = 0;\n }\n }\n}\n","// Js_of_ocaml runtime support\n// http://www.ocsigen.org/js_of_ocaml/\n// Copyright (C) 2010 Jérôme Vouillon\n// Laboratoire PPS - CNRS Université Paris Diderot\n//\n// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU Lesser General Public License as published by\n// the Free Software Foundation, with linking exception;\n// either version 2.1 of the License, or (at your option) any later version.\n//\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n// GNU Lesser General Public License for more details.\n//\n// You should have received a copy of the GNU Lesser General Public License\n// along with this program; if not, write to the Free Software\n// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n\n\n//Provides: caml_md5_chan\n//Requires: caml_md5_string, caml_string_of_array,caml_ml_channels\n//Requires: caml_raise_end_of_file, caml_create_bytes, caml_string_of_bytes\nfunction caml_md5_chan(chanid,len){\n var chan = caml_ml_channels[chanid];\n var chan_len = chan.file.length();\n if(len<0) len = chan_len - chan.offset;\n if(chan.offset + len > chan_len) caml_raise_end_of_file();\n var buf = caml_create_bytes(len);\n chan.file.read(chan.offset,buf,0,len);\n return caml_md5_string(caml_string_of_bytes(buf),0,len);\n}\n\n//Provides: caml_md5_string\n//Requires: caml_bytes_of_string, caml_md5_bytes\nfunction caml_md5_string(s, ofs, len) {\n return caml_md5_bytes(caml_bytes_of_string(s),ofs,len);\n}\n\n//Provides: caml_md5_bytes\n//Requires: caml_string_of_array, caml_ml_bytes_content\nvar caml_md5_bytes = function () {\n function add (x, y) { return (x + y) | 0; }\n function xx(q,a,b,x,s,t) {\n a = add(add(a, q), add(x, t));\n return add((a << s) | (a >>> (32 - s)), b);\n }\n function ff(a,b,c,d,x,s,t) {\n return xx((b & c) | ((~b) & d), a, b, x, s, t);\n }\n function gg(a,b,c,d,x,s,t) {\n return xx((b & d) | (c & (~d)), a, b, x, s, t);\n }\n function hh(a,b,c,d,x,s,t) { return xx(b ^ c ^ d, a, b, x, s, t); }\n function ii(a,b,c,d,x,s,t) { return xx(c ^ (b | (~d)), a, b, x, s, t); }\n\n function md5(buffer, length) {\n var i = length;\n buffer[i >> 2] |= 0x80 << (8 * (i & 3));\n for (i = (i & ~0x3) + 8;(i & 0x3F) < 60 ;i += 4)\n buffer[(i >> 2) - 1] = 0;\n buffer[(i >> 2) -1] = length << 3;\n buffer[i >> 2] = (length >> 29) & 0x1FFFFFFF;\n\n var w = [0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476];\n\n for(i = 0; i < buffer.length; i += 16) {\n var a = w[0], b = w[1], c = w[2], d = w[3];\n\n a = ff(a, b, c, d, buffer[i+ 0], 7, 0xD76AA478);\n d = ff(d, a, b, c, buffer[i+ 1], 12, 0xE8C7B756);\n c = ff(c, d, a, b, buffer[i+ 2], 17, 0x242070DB);\n b = ff(b, c, d, a, buffer[i+ 3], 22, 0xC1BDCEEE);\n a = ff(a, b, c, d, buffer[i+ 4], 7, 0xF57C0FAF);\n d = ff(d, a, b, c, buffer[i+ 5], 12, 0x4787C62A);\n c = ff(c, d, a, b, buffer[i+ 6], 17, 0xA8304613);\n b = ff(b, c, d, a, buffer[i+ 7], 22, 0xFD469501);\n a = ff(a, b, c, d, buffer[i+ 8], 7, 0x698098D8);\n d = ff(d, a, b, c, buffer[i+ 9], 12, 0x8B44F7AF);\n c = ff(c, d, a, b, buffer[i+10], 17, 0xFFFF5BB1);\n b = ff(b, c, d, a, buffer[i+11], 22, 0x895CD7BE);\n a = ff(a, b, c, d, buffer[i+12], 7, 0x6B901122);\n d = ff(d, a, b, c, buffer[i+13], 12, 0xFD987193);\n c = ff(c, d, a, b, buffer[i+14], 17, 0xA679438E);\n b = ff(b, c, d, a, buffer[i+15], 22, 0x49B40821);\n\n a = gg(a, b, c, d, buffer[i+ 1], 5, 0xF61E2562);\n d = gg(d, a, b, c, buffer[i+ 6], 9, 0xC040B340);\n c = gg(c, d, a, b, buffer[i+11], 14, 0x265E5A51);\n b = gg(b, c, d, a, buffer[i+ 0], 20, 0xE9B6C7AA);\n a = gg(a, b, c, d, buffer[i+ 5], 5, 0xD62F105D);\n d = gg(d, a, b, c, buffer[i+10], 9, 0x02441453);\n c = gg(c, d, a, b, buffer[i+15], 14, 0xD8A1E681);\n b = gg(b, c, d, a, buffer[i+ 4], 20, 0xE7D3FBC8);\n a = gg(a, b, c, d, buffer[i+ 9], 5, 0x21E1CDE6);\n d = gg(d, a, b, c, buffer[i+14], 9, 0xC33707D6);\n c = gg(c, d, a, b, buffer[i+ 3], 14, 0xF4D50D87);\n b = gg(b, c, d, a, buffer[i+ 8], 20, 0x455A14ED);\n a = gg(a, b, c, d, buffer[i+13], 5, 0xA9E3E905);\n d = gg(d, a, b, c, buffer[i+ 2], 9, 0xFCEFA3F8);\n c = gg(c, d, a, b, buffer[i+ 7], 14, 0x676F02D9);\n b = gg(b, c, d, a, buffer[i+12], 20, 0x8D2A4C8A);\n\n a = hh(a, b, c, d, buffer[i+ 5], 4, 0xFFFA3942);\n d = hh(d, a, b, c, buffer[i+ 8], 11, 0x8771F681);\n c = hh(c, d, a, b, buffer[i+11], 16, 0x6D9D6122);\n b = hh(b, c, d, a, buffer[i+14], 23, 0xFDE5380C);\n a = hh(a, b, c, d, buffer[i+ 1], 4, 0xA4BEEA44);\n d = hh(d, a, b, c, buffer[i+ 4], 11, 0x4BDECFA9);\n c = hh(c, d, a, b, buffer[i+ 7], 16, 0xF6BB4B60);\n b = hh(b, c, d, a, buffer[i+10], 23, 0xBEBFBC70);\n a = hh(a, b, c, d, buffer[i+13], 4, 0x289B7EC6);\n d = hh(d, a, b, c, buffer[i+ 0], 11, 0xEAA127FA);\n c = hh(c, d, a, b, buffer[i+ 3], 16, 0xD4EF3085);\n b = hh(b, c, d, a, buffer[i+ 6], 23, 0x04881D05);\n a = hh(a, b, c, d, buffer[i+ 9], 4, 0xD9D4D039);\n d = hh(d, a, b, c, buffer[i+12], 11, 0xE6DB99E5);\n c = hh(c, d, a, b, buffer[i+15], 16, 0x1FA27CF8);\n b = hh(b, c, d, a, buffer[i+ 2], 23, 0xC4AC5665);\n\n a = ii(a, b, c, d, buffer[i+ 0], 6, 0xF4292244);\n d = ii(d, a, b, c, buffer[i+ 7], 10, 0x432AFF97);\n c = ii(c, d, a, b, buffer[i+14], 15, 0xAB9423A7);\n b = ii(b, c, d, a, buffer[i+ 5], 21, 0xFC93A039);\n a = ii(a, b, c, d, buffer[i+12], 6, 0x655B59C3);\n d = ii(d, a, b, c, buffer[i+ 3], 10, 0x8F0CCC92);\n c = ii(c, d, a, b, buffer[i+10], 15, 0xFFEFF47D);\n b = ii(b, c, d, a, buffer[i+ 1], 21, 0x85845DD1);\n a = ii(a, b, c, d, buffer[i+ 8], 6, 0x6FA87E4F);\n d = ii(d, a, b, c, buffer[i+15], 10, 0xFE2CE6E0);\n c = ii(c, d, a, b, buffer[i+ 6], 15, 0xA3014314);\n b = ii(b, c, d, a, buffer[i+13], 21, 0x4E0811A1);\n a = ii(a, b, c, d, buffer[i+ 4], 6, 0xF7537E82);\n d = ii(d, a, b, c, buffer[i+11], 10, 0xBD3AF235);\n c = ii(c, d, a, b, buffer[i+ 2], 15, 0x2AD7D2BB);\n b = ii(b, c, d, a, buffer[i+ 9], 21, 0xEB86D391);\n\n w[0] = add(a, w[0]);\n w[1] = add(b, w[1]);\n w[2] = add(c, w[2]);\n w[3] = add(d, w[3]);\n }\n\n var t = new Array(16);\n for (var i = 0; i < 4; i++)\n for (var j = 0; j < 4; j++)\n t[i * 4 + j] = (w[i] >> (8 * j)) & 0xFF;\n return t;\n }\n\n return function (s, ofs, len) {\n // FIX: maybe we should perform the computation by chunk of 64 bytes\n // as in http://www.myersdaily.org/joseph/javascript/md5.js\n var buf = [];\n var content = caml_ml_bytes_content(s);\n if(typeof content === \"string\"){\n var b = content;\n for (var i = 0; i < len; i+=4) {\n var j = i + ofs;\n buf[i>>2] =\n b.charCodeAt(j) | (b.charCodeAt(j+1) << 8) |\n (b.charCodeAt(j+2) << 16) | (b.charCodeAt(j+3) << 24);\n }\n for (; i < len; i++) buf[i>>2] |= b.charCodeAt(i + ofs) << (8 * (i & 3));\n } else { /* ARRAY */\n var a = content;\n for (var i = 0; i < len; i+=4) {\n var j = i + ofs;\n buf[i>>2] = a[j] | (a[j+1] << 8) | (a[j+2] << 16) | (a[j+3] << 24);\n }\n for (; i < len; i++) buf[i>>2] |= a[i + ofs] << (8 * (i & 3));\n }\n return caml_string_of_array(md5(buf, len));\n }\n} ();\n","//Provides: expect_test_collector_saved_stdout\nvar expect_test_collector_saved_stdout \n//Provides: expect_test_collector_saved_stderr\nvar expect_test_collector_saved_stderr\n\n//Provides: expect_test_collector_before_test\n//Requires: caml_global_data, caml_ml_channels\n//Requires: expect_test_collector_saved_stderr, expect_test_collector_saved_stdout\nfunction expect_test_collector_before_test (voutput, vstdout, vstderr){\n expect_test_collector_saved_stderr = caml_ml_channels[vstderr];\n expect_test_collector_saved_stdout = caml_ml_channels[vstdout];\n var output = caml_ml_channels[voutput];\n caml_ml_channels[vstdout] = output;\n caml_ml_channels[vstderr] = output;\n return 0;\n}\n\n//Provides: expect_test_collector_after_test\n//Requires: caml_global_data, caml_ml_channels\n//Requires: expect_test_collector_saved_stderr, expect_test_collector_saved_stdout\nfunction expect_test_collector_after_test (vstdout, vstderr){\n caml_ml_channels[vstdout] = expect_test_collector_saved_stdout;\n caml_ml_channels[vstderr] = expect_test_collector_saved_stderr;\n return 0;\n}\n\n//Provides:caml_out_channel_pos_fd\n//Requires: caml_global_data, caml_ml_channels\nfunction caml_out_channel_pos_fd(chan){\n var info = caml_ml_channels[chan];\n return info.offset\n}\n","///////// CORE_KERNEL\n\n//Provides: core_array_unsafe_int_blit\n//Requires: caml_array_blit\nvar core_array_unsafe_int_blit = caml_array_blit\n//Provides: core_array_unsafe_float_blit\n//Requires: caml_array_blit\nvar core_array_unsafe_float_blit = caml_array_blit\n\n//Provides: core_kernel_time_ns_format\n//Requires: caml_jsbytes_of_string, caml_string_of_jsbytes\nfunction core_kernel_time_ns_format(time,format){\n var d = new Date(time * 1000);\n var formatjs = caml_jsbytes_of_string(format);\n var jstring = joo_global_object.strftime(formatjs, d);\n return caml_string_of_jsbytes(jstring);\n}\n\n//Provides: core_kernel_gc_compactions\nfunction core_kernel_gc_compactions () { return 0 }\n//Provides: core_kernel_gc_heap_chunks\nfunction core_kernel_gc_heap_chunks () { return 0 }\n//Provides: core_kernel_gc_heap_words\nfunction core_kernel_gc_heap_words () { return 0 }\n//Provides: core_kernel_gc_major_collections\nfunction core_kernel_gc_major_collections () { return 0 }\n//Provides: core_kernel_gc_major_plus_minor_words\nfunction core_kernel_gc_major_plus_minor_words () { return 0 }\n//Provides: core_kernel_gc_major_words\nfunction core_kernel_gc_major_words () { return 0 }\n//Provides: core_kernel_gc_minor_collections\nfunction core_kernel_gc_minor_collections () { return 0 }\n//Provides: core_kernel_gc_minor_words\nfunction core_kernel_gc_minor_words () { return 0 }\n//Provides: core_kernel_gc_promoted_words\nfunction core_kernel_gc_promoted_words () { return 0 }\n//Provides: core_kernel_gc_top_heap_words\nfunction core_kernel_gc_top_heap_words () { return 0 }\n\n//Provides: Core_kernel_heap_block_is_heap_block\nfunction Core_kernel_heap_block_is_heap_block(x){\n return +(x instanceof Array);\n}\n\n//Provides: core_md5_fd\n//Requires: caml_ml_open_descriptor_in, caml_md5_chan, caml_ml_close_channel\nfunction core_md5_fd(fd){\n var ic = caml_ml_open_descriptor_in(fd);\n try {\n return caml_md5_chan(ic, -1);\n } finally {\n caml_ml_close_channel(ic);\n }\n}\n\n//Provides: core_md5_digest_subbigstring\n//Requires: caml_md5_string, caml_blit_string, caml_create_bytes\n//Requires: bigstring_blit_bigstring_bytes_stub, caml_string_of_bytes\nfunction core_md5_digest_subbigstring(buf, ofs, len, res){\n var bytes = caml_create_bytes(len);\n bigstring_blit_bigstring_bytes_stub(buf, ofs, bytes, 0, len);\n var res2 = caml_md5_string(caml_string_of_bytes(bytes), 0, len);\n caml_blit_string(res2, 0, res, 0, 16);\n return 0;\n}\n\n//Bigstring\n\n//Provides: bigstring_destroy_stub\n//Requires: caml_invalid_argument\nfunction bigstring_destroy_stub(v_bstr) {\n if (v_bstr.hasOwnProperty('__is_deallocated')) {\n caml_invalid_argument(\"bigstring_destroy: bigstring is already deallocated\");\n }\n // Mutate the original bigstring in-place, to simulate what the C version does\n v_bstr.__is_deallocated = true;\n v_bstr.data = new v_bstr.data.__proto__.constructor(0);\n v_bstr.dims = [ 0 ];\n return 0;\n}\n\n//Provides: bigstring_realloc\n//Requires: caml_invalid_argument, caml_ba_create_unsafe, bigstring_destroy_stub\nfunction bigstring_realloc(bigstring, size) {\n if (bigstring.hasOwnProperty('__is_deallocated')) {\n caml_invalid_argument(\"bigstring_realloc: bigstring is already deallocated\");\n }\n\n var new_data = new bigstring.data.__proto__.constructor(size);\n new_data.set(bigstring.data.slice(0, size));\n var new_bigstring = caml_ba_create_unsafe(bigstring.kind, bigstring.layout, [size], new_data);\n bigstring_destroy_stub(bigstring);\n\n return new_bigstring;\n}\n","// Provides: deferred_run\nfunction deferred_run(func) {\n var deferred = {\n promise: Promise.resolve()\n .then(func) // the ocaml types don't know this, but func can actually be async or sync\n .then(function (value) {\n deferred.value = value;\n deferred.isDetermined = true;\n return value;\n })\n .catch(function (err) {\n deferred.error = err;\n deferred.isError = true;\n deferred.isDetermined = true;\n throw err;\n }),\n isError: false,\n isDetermined: false,\n };\n return deferred;\n}\n\n// Provides: deferred_map\nfunction deferred_map(deferred, func) {\n var newDeferred = {\n promise: deferred.promise\n .then(func) // the ocaml types don't know this, but func can actually be async or sync\n .then(function (value) {\n newDeferred.value = value;\n newDeferred.isDetermined = true;\n return value;\n })\n .catch(function (err) {\n newDeferred.error = err;\n newDeferred.isError = true;\n newDeferred.isDetermined = true;\n throw err;\n }),\n isError: false,\n isDetermined: false,\n };\n return newDeferred;\n}\n\n// Provides: deferred_bind\nfunction deferred_bind(deferred, func) {\n var newDeferred = {\n promise: deferred.promise\n .then(func)\n .then(function (anotherDeferred) {\n return anotherDeferred.promise;\n })\n .then(function (value) {\n newDeferred.value = value;\n newDeferred.isDetermined = true;\n return value;\n })\n .catch(function (err) {\n newDeferred.error = err;\n newDeferred.isError = true;\n newDeferred.isDetermined = true;\n throw err;\n }),\n isError: false,\n isDetermined: false,\n };\n return newDeferred;\n}\n\n// Provides: deferred_upon\nfunction deferred_upon(deferred, func) {\n deferred.promise\n .then(function () {\n func(deferred.value);\n })\n .catch(function () {});\n}\n\n// Provides: deferred_upon_exn\nfunction deferred_upon_exn(deferred, func) {\n deferred.promise.then(function () {\n func(deferred.value);\n });\n}\n\n// Provides: deferred_is_determined\nfunction deferred_is_determined(deferred) {\n return deferred.isDetermined;\n}\n\n// Provides: deferred_peek\nfunction deferred_peek(deferred) {\n if (!deferred.isDetermined || deferred.isError) {\n return 0;\n }\n return [0, deferred.value];\n}\n\n// Provides: deferred_value_exn\nfunction deferred_value_exn(deferred) {\n if (!deferred.isDetermined) {\n throw Error(\"Deferred has not returned yet.\");\n }\n if (deferred.isError) {\n throw deferred.error;\n }\n return deferred.value;\n}\n\n// Provides: deferred_return\nfunction deferred_return(value) {\n return {\n promise: Promise.resolve(value),\n value: value,\n isError: false,\n isDetermined: true,\n };\n}\n\n// Provides: deferred_create\nfunction deferred_create(promise_creator) {\n var deferred = {\n promise: new Promise(function (resolve) {\n promise_creator(resolve);\n })\n .then(function (value) {\n deferred.value = value;\n deferred.isDetermined = true;\n })\n .catch(function (err) {\n deferred.error = err;\n deferred.isError = true;\n deferred.isDetermined = true;\n throw err;\n }),\n isError: false,\n isDetermined: false,\n };\n return deferred;\n}\n\n// Provides: deferred_to_promise\nfunction deferred_to_promise(deferred) {\n return deferred.promise;\n}\n\n// Provides: deferred_of_promise\nfunction deferred_of_promise(promise) {\n var deferred = {\n promise: promise\n .then(function (value) {\n deferred.value = value;\n deferred.isDetermined = true;\n return value;\n })\n .catch(function (err) {\n deferred.error = err;\n deferred.isError = true;\n deferred.isDetermined = true;\n throw err;\n }),\n isError: false,\n isDetermined: false,\n };\n return deferred;\n}\n","// This code supports both Array and MlInt64 implementations of int64 in\n// js_of_ocaml (pre- vs post-887507db1eb8efd779070cbedab3774098a52939).\n//\n// Compilation is currently broken on the MlInt64 implementation, due to\n// removed internal js_of_ocaml primitives. Removing these (and the Array\n// implementations, signalled by [instanceof Array] checks) will cause\n// compilation to succeed.\n//\n// TODO: build-time magic to stub the unavailable primitives on later versions.\n\n//Provides: UInt32 const\nvar UInt32 = (function() {\n var UInt32 = function(x) {\n this.value = x >>> 0;\n };\n UInt32.prototype.caml_custom = \"integers:uint32\";\n return UInt32;\n})();\n\n//Provides: integers_int32_of_uint32\nfunction integers_int32_of_uint32(i) {\n return (i.value | 0);\n}\n\n//Provides: integers_size_t_size\nfunction integers_size_t_size(unit) {\n return 4; // Set size_t = u32\n}\n\n//Provides: integers_uint16_of_string\n//Requires: integers_uint32_of_string\nfunction integers_uint16_of_string(x) {\n var y = integers_uint32_of_string(x);\n return (y.value & 0xFFFF);\n}\n\n//Provides: integers_uint32_add\n//Requires: UInt32\nfunction integers_uint32_add(x, y) {\n return new UInt32(x.value + y.value);\n}\n\n//Provides: integers_uint32_sub\n//Requires: UInt32\nfunction integers_uint32_sub(x, y) {\n return new UInt32(x.value - y.value);\n}\n\n//Provides: integers_uint32_div\n//Requires: UInt32\nfunction integers_uint32_div(x, y) {\n return new UInt32(x.value / y.value);\n}\n\n//Provides: integers_uint32_logand\n//Requires: UInt32\nfunction integers_uint32_logand(x, y) {\n return new UInt32(x.value & y.value);\n}\n\n//Provides: integers_uint32_logor\n//Requires: UInt32\nfunction integers_uint32_logor(x, y) {\n return new UInt32(x.value | y.value);\n}\n\n//Provides: integers_uint32_logxor\n//Requires: UInt32\nfunction integers_uint32_logxor(x, y) {\n return new UInt32(x.value ^ y.value);\n}\n\n//Provides: integers_uint32_max\n//Requires: UInt32\nfunction integers_uint32_max(unit) {\n return new UInt32(0xFFFFFFFF);\n}\n\n//Provides: integers_uint32_mul\n//Requires: integers_uint32_to_int64, caml_int64_mul, caml_int64_to_int32, UInt32\nfunction integers_uint32_mul(x, y) {\n // Convert to 64-bit and compute there.\n var x_64 = integers_uint32_to_int64(x);\n var y_64 = integers_uint32_to_int64(y);\n return new UInt32 (caml_int64_to_int32(caml_int64_mul(x_64, y_64)));\n}\n\n//Provides: integers_uint32_of_int\n//Requires: UInt32\nfunction integers_uint32_of_int(i) {\n return new UInt32(i);\n}\n\n//Provides: integers_uint32_of_int32\n//Requires: UInt32\nfunction integers_uint32_of_int32(i) {\n return new UInt32(i);\n}\n\n//Provides: integers_uint32_of_int64\n//Requires: caml_int64_to_int32, UInt32\nfunction integers_uint32_of_int64(i) {\n return new UInt32(caml_int64_to_int32(i));\n}\n\n//Provides: integers_uint32_of_string\n//Requires: integers_uint_of_string, integers_uint32_of_int64, caml_int64_create_lo_mi_hi\nfunction integers_uint32_of_string(s) {\n // To match the C implementation, we should parse the string as an uint64\n // and then downcast.\n var max_val = caml_int64_create_lo_mi_hi(0xffffff, 0xffffff, 0xffff);\n return integers_uint32_of_int64(integers_uint_of_string(s, max_val));\n}\n\n//Provides: integers_uint32_rem\n//Requires: caml_raise_zero_divide, UInt32\nfunction integers_uint32_rem(x, y) {\n if (y.value == 0) {\n caml_raise_zero_divide();\n }\n return new UInt32(x.value % y.value);\n}\n\n//Provides: integers_uint32_shift_left\n//Requires: UInt32\nfunction integers_uint32_shift_left(x, y) {\n return new UInt32(x.value << y);\n}\n\n//Provides: integers_uint32_shift_right\n//Requires: UInt32\nfunction integers_uint32_shift_right(x, y) {\n return new UInt32(x.value >>> y);\n}\n\n//Provides: integers_uint32_to_int\nfunction integers_uint32_to_int(i) {\n return (i.value | 0);\n}\n\n//Provides: integers_uint32_to_int64\n//Requires: caml_int64_create_lo_mi_hi\nfunction integers_uint32_to_int64(i) {\n return caml_int64_create_lo_mi_hi(i.value & 0xffffff, (i.value >>> 24) & 0xffffff, 0);\n}\n\n//Provides: integers_uint32_to_string\n//Requires: caml_new_string\nfunction integers_uint32_to_string(i) {\n return caml_new_string(i.value.toString());\n}\n\n//Provides: UInt64 const\nvar UInt64 = (function () {\n var UInt64 = function (x) {\n this.value = x; // x is an MlInt64\n };\n UInt64.prototype.caml_custom = \"integers:uint64\";\n return UInt64;\n})();\n\n//Provides: integers_uint64_add\n//Requires: caml_int64_add, UInt64\nfunction integers_uint64_add(x, y) {\n return new UInt64(caml_int64_add(x.value, y.value));\n}\n\n//Provides: integers_uint64_div\n//Requires: caml_raise_zero_divide, UInt64\nfunction integers_uint64_div(x, y) {\n if (y.value.isZero()) {\n caml_raise_zero_divide();\n }\n // Coerce the high parts to be unsigned before division.\n x.value.hi = x.value.hi >>> 0;\n y.value.hi = y.value.hi >>> 0;\n return new UInt64(x.value.udivmod(y.value).quotient);\n}\n\n//Provides: integers_uint64_logand\n//Requires: caml_int64_and, UInt64\nfunction integers_uint64_logand(x, y) {\n return new UInt64(caml_int64_and(x.value, y.value));\n}\n\n//Provides: integers_uint64_logor\n//Requires: caml_int64_or, UInt64\nfunction integers_uint64_logor(x, y) {\n return new UInt64(caml_int64_or(x.value, y.value));\n}\n\n//Provides: integers_uint64_logxor\n//Requires: caml_int64_xor, UInt64\nfunction integers_uint64_logxor(x, y) {\n return new UInt64(caml_int64_xor(x.value, y.value));\n}\n\n//Provides: integers_uint64_max\n//Requires: caml_int64_create_lo_mi_hi, UInt64\nfunction integers_uint64_max(unit) {\n var x = caml_int64_create_lo_mi_hi(0xffffff, 0xffffff, 0xffff);\n x.hi = x.hi >>> 0;\n return new UInt64(x);\n}\n\n//Provides: integers_uint64_mul\n//Requires: caml_int64_mul, UInt64\nfunction integers_uint64_mul(x, y) {\n return new UInt64(caml_int64_mul(x.value, y.value));\n}\n\n//Provides: integers_uint64_of_int\n//Requires: caml_int64_of_int32, UInt64\nfunction integers_uint64_of_int(i) {\n return new UInt64(caml_int64_of_int32(i));\n}\n\n//Provides: integers_uint64_of_int64\n//Requires: caml_int64_create_lo_mi_hi, UInt64\nfunction integers_uint64_of_int64(i) {\n return new UInt64(caml_int64_create_lo_mi_hi(i.lo, i.mi, i.hi >>> 0));\n}\n\n//Provides: integers_uint_of_string\n//Requires: caml_ml_string_length, caml_failwith, caml_string_unsafe_get, caml_int64_create_lo_mi_hi, caml_int64_of_int32, caml_parse_digit, caml_int64_ult, caml_int64_add, caml_int64_mul, caml_int64_neg\nfunction integers_uint_of_string(s, max_val) {\n // Note: This code matches the behavior of the C function.\n // In particular,\n // - only base-10 numbers are accepted\n // - negative numbers are accepted and coerced to 2's-complement uint64\n // - the longest numeric prefix is accepted, only raising an error when there\n // isn't a numeric prefix\n var i = 0, len = caml_ml_string_length(s), negative = false;\n if (i >= len) {\n caml_failwith(\"int_of_string\");\n }\n var c = caml_string_unsafe_get(s, i);\n if (c === 45) { // Minus sign\n i++;\n negative = true;\n } else if (c === 43) { // Plus sign\n i++;\n }\n var no_digits = true;\n // Ensure that the high byte is unsigned before division.\n max_val.hi = max_val.hi >>> 0;\n var ten = caml_int64_of_int32(10);\n var max_base_10 = max_val.udivmod(ten).quotient;\n var res = caml_int64_of_int32(0);\n for (; i < len; i++) {\n var c = caml_string_unsafe_get(s, i);\n var d = caml_parse_digit(c);\n if (d < 0 || d >= 10) {\n break;\n }\n no_digits = false;\n // Any digit here would overflow. Pin to the maximum value.\n if (caml_int64_ult(max_base_10, res)) {\n return max_val;\n }\n d = caml_int64_of_int32(d);\n res = caml_int64_add(caml_int64_mul(ten, res), d);\n // The given digit was too large. Pin to the maximum value.\n if (caml_int64_ult(res, d)) {\n return max_val;\n }\n }\n if (no_digits) {\n caml_failwith(\"int_of_string\");\n }\n if (negative) {\n res = caml_int64_neg(res);\n }\n // Set the high byte as unsigned.\n res.hi = res.hi >>> 0;\n return res;\n}\n\n//Provides: integers_uint64_of_string\n//Requires: integers_uint_of_string, caml_int64_create_lo_mi_hi, UInt64\nfunction integers_uint64_of_string(s) {\n var max_val = caml_int64_create_lo_mi_hi(0xffffff, 0xffffff, 0xffff);\n return new UInt64(integers_uint_of_string(s, max_val));\n}\n\n//Provides: integers_uint64_rem\n//Requires: caml_raise_zero_divide, caml_int64_is_zero, UInt64\nfunction integers_uint64_rem(x, y) {\n if (y.value.isZero()) {\n caml_raise_zero_divide();\n }\n // Coerce the high parts to be unsigned before division.\n x.value.hi = x.value.hi >>> 0;\n y.value.hi = y.value.hi >>> 0;\n return new UInt64(x.value.udivmod(y.value).modulus);\n}\n\n//Provides: integers_uint64_shift_left\n//Requires: caml_int64_shift_left, UInt64\nfunction integers_uint64_shift_left(x, y) {\n return new UInt64(caml_int64_shift_left(x.value, y));\n}\n\n//Provides: integers_uint64_shift_right\n//Requires: caml_int64_shift_right_unsigned, UInt64\nfunction integers_uint64_shift_right(x, y) {\n return new UInt64(caml_int64_shift_right_unsigned(x.value, y));\n}\n\n//Provides: integers_uint64_sub\n//Requires: caml_int64_sub, UInt64\nfunction integers_uint64_sub(x, y) {\n return new UInt64(caml_int64_sub(x.value, y.value));\n}\n\n//Provides: integers_uint64_to_int\n//Requires: caml_int64_to_int32\nfunction integers_uint64_to_int(i) {\n return caml_int64_to_int32(i.value);\n}\n\n//Provides: integers_uint64_to_int64\n//Requires: caml_int64_create_lo_mi_hi\nfunction integers_uint64_to_int64(i) {\n i = i.value;\n return caml_int64_create_lo_mi_hi(i.lo, i.mi, i.hi | 0);\n}\n\n//Provides: integers_uint64_to_string\n//Requires: caml_int64_format, caml_new_string\nfunction integers_uint64_to_string(i) {\n return caml_int64_format(caml_new_string(\"%u\"), i.value);\n}\n\n//Provides: integers_uint64_unmarshal\n//Requires: caml_int64_unmarshal, UInt64\nfunction integers_uint64_unmarshal(reader, size){\n return new UInt64(caml_int64_unmarshal(reader, size));\n}\n \n//Provides: integers_uint64_marshal\n//Requires: caml_int64_marshal\nfunction integers_uint64_marshal(writer, v, sizes) {\n caml_int64_marshal(writer, v.value, sizes);\n}\n\n//Provides: integers_uint64_hash\n//Requires: caml_int64_hash\nfunction integers_uint64_hash(v) {\n return caml_int64_hash(v.value);\n}\n\n//Provides: integers_uint8_of_string\n//Requires: integers_uint32_of_string\nfunction integers_uint8_of_string(x) {\n var y = integers_uint32_of_string(x);\n return (x.value & 0xFF);\n}\n\n//Provides: integers_uint_size\nfunction integers_uint_size(unit) {\n return 4;\n}\n\n//Provides: integers_ulong_size\nfunction integers_ulong_size(unit) {\n return 4;\n}\n\n//Provides: integers_ulonglong_size\nfunction integers_ulonglong_size(unit) {\n return 8;\n}\n\n//Provides: integers_unsigned_init\n//Requires: caml_custom_ops, integers_uint8_deserialize, integers_uint16_deserialize, integers_uint32_serialize, integers_uint32_deserialize, integers_uint32_hash, integers_uint32_compare, integers_uint64_compare, integers_uint64_hash, integers_uint64_marshal, integers_uint64_unmarshal\nfunction integers_unsigned_init(unit) {\n caml_custom_ops[\"integers:uint8\"] =\n { deserialize: integers_uint8_deserialize\n , fixed_length: 1 };\n caml_custom_ops[\"integers:uint16\"] =\n { deserialize: integers_uint16_deserialize\n , fixed_length: 2 };\n caml_custom_ops[\"integers:uint32\"] =\n { serialize: integers_uint32_serialize\n , deserialize: integers_uint32_deserialize\n , fixed_length: 4\n , hash: integers_uint32_hash\n , compare: integers_uint32_compare };\n caml_custom_ops[\"integers:uint64\"] =\n { serialize: integers_uint64_marshal\n , deserialize: integers_uint64_unmarshal\n , hash: integers_uint64_hash\n , compare: integers_uint64_compare };\n return unit;\n}\n\n//Provides: integers_ushort_size\nfunction integers_ushort_size(unit) {\n return 4;\n}\n\n//Provides: integers_uint32_serialize\nfunction integers_uint32_serialize(writer, v, size) {\n writer.write(32, v.value);\n size[0] = 4;\n size[1] = 4;\n}\n\n//Provides: integers_uint8_deserialize\nfunction integers_uint8_deserialize(reader, size) {\n size[0] = 1;\n return reader.read8u();\n}\n\n//Provides: integers_uint16_deserialize\nfunction integers_uint16_deserialize(reader, size) {\n size[0] = 2;\n return reader.read16u();\n}\n\n//Provides: integers_uint32_deserialize\n//Requires: UInt32\nfunction integers_uint32_deserialize(reader, size) {\n size[0] = 4;\n return new UInt32(reader.read32u());\n}\n\n//Provides: integers_uint32_hash\nfunction integers_uint32_hash(v) {\n return v.value;\n}\n\n//Provides: integers_uint32_compare\nfunction integers_uint32_compare(x, y) {\n if (x.value > y.value) { return 1; }\n if (x.value < y.value) { return -1; }\n return 0;\n}\n\n//Provides: integers_uint64_compare\n//Requires: caml_int64_compare\nfunction integers_uint64_compare(x, y) {\n x.value.hi = x.value.hi >>> 0;\n y.value.hi = y.value.hi >>> 0;\n return x.value.ucompare(y.value);\n}\n","//Imported from https://github.com/peterolson/BigInteger.js#4e99b15b7951338f164728377c906caae5a78202\n\n//Provides: bigInt const\nvar bigInt = (function (undefined) {\n \"use strict\";\n\n var BASE = 1e7,\n LOG_BASE = 7,\n MAX_INT = 9007199254740992,\n MAX_INT_ARR = smallToArray(MAX_INT),\n DEFAULT_ALPHABET = \"0123456789abcdefghijklmnopqrstuvwxyz\";\n\n var BigInt = joo_global_object.BigInt;\n\n var supportsNativeBigInt = typeof BigInt === \"function\";\n\n function Integer(v, radix, alphabet, caseSensitive) {\n if (typeof v === \"undefined\") return Integer[0];\n if (typeof radix !== \"undefined\") return +radix === 10 && !alphabet ? parseValue(v) : parseBase(v, radix, alphabet, caseSensitive);\n return parseValue(v);\n }\n\n function BigInteger(value, sign) {\n this.value = value;\n this.sign = sign;\n this.isSmall = false;\n this.caml_custom = '_z';\n }\n BigInteger.prototype = Object.create(Integer.prototype);\n\n function SmallInteger(value) {\n this.value = value;\n this.sign = value < 0;\n this.isSmall = true;\n this.caml_custom = '_z';\n }\n SmallInteger.prototype = Object.create(Integer.prototype);\n\n function NativeBigInt(value) {\n this.value = value;\n this.caml_custom = '_z';\n }\n NativeBigInt.prototype = Object.create(Integer.prototype);\n\n function isPrecise(n) {\n return -MAX_INT < n && n < MAX_INT;\n }\n\n function smallToArray(n) { // For performance reasons doesn't reference BASE, need to change this function if BASE changes\n if (n < 1e7)\n return [n];\n if (n < 1e14)\n return [n % 1e7, Math.floor(n / 1e7)];\n return [n % 1e7, Math.floor(n / 1e7) % 1e7, Math.floor(n / 1e14)];\n }\n\n function arrayToSmall(arr) { // If BASE changes this function may need to change\n trim(arr);\n var length = arr.length;\n if (length < 4 && compareAbs(arr, MAX_INT_ARR) < 0) {\n switch (length) {\n case 0: return 0;\n case 1: return arr[0];\n case 2: return arr[0] + arr[1] * BASE;\n default: return arr[0] + (arr[1] + arr[2] * BASE) * BASE;\n }\n }\n return arr;\n }\n\n function trim(v) {\n var i = v.length;\n while (v[--i] === 0);\n v.length = i + 1;\n }\n\n function createArray(length) { // function shamelessly stolen from Yaffle's library https://github.com/Yaffle/BigInteger\n var x = new Array(length);\n var i = -1;\n while (++i < length) {\n x[i] = 0;\n }\n return x;\n }\n\n function truncate(n) {\n if (n > 0) return Math.floor(n);\n return Math.ceil(n);\n }\n\n function add(a, b) { // assumes a and b are arrays with a.length >= b.length\n var l_a = a.length,\n l_b = b.length,\n r = new Array(l_a),\n carry = 0,\n base = BASE,\n sum, i;\n for (i = 0; i < l_b; i++) {\n sum = a[i] + b[i] + carry;\n carry = sum >= base ? 1 : 0;\n r[i] = sum - carry * base;\n }\n while (i < l_a) {\n sum = a[i] + carry;\n carry = sum === base ? 1 : 0;\n r[i++] = sum - carry * base;\n }\n if (carry > 0) r.push(carry);\n return r;\n }\n\n function addAny(a, b) {\n if (a.length >= b.length) return add(a, b);\n return add(b, a);\n }\n\n function addSmall(a, carry) { // assumes a is array, carry is number with 0 <= carry < MAX_INT\n var l = a.length,\n r = new Array(l),\n base = BASE,\n sum, i;\n for (i = 0; i < l; i++) {\n sum = a[i] - base + carry;\n carry = Math.floor(sum / base);\n r[i] = sum - carry * base;\n carry += 1;\n }\n while (carry > 0) {\n r[i++] = carry % base;\n carry = Math.floor(carry / base);\n }\n return r;\n }\n\n BigInteger.prototype.add = function (v) {\n var n = parseValue(v);\n if (this.sign !== n.sign) {\n return this.subtract(n.negate());\n }\n var a = this.value, b = n.value;\n if (n.isSmall) {\n return new BigInteger(addSmall(a, Math.abs(b)), this.sign);\n }\n return new BigInteger(addAny(a, b), this.sign);\n };\n BigInteger.prototype.plus = BigInteger.prototype.add;\n\n SmallInteger.prototype.add = function (v) {\n var n = parseValue(v);\n var a = this.value;\n if (a < 0 !== n.sign) {\n return this.subtract(n.negate());\n }\n var b = n.value;\n if (n.isSmall) {\n if (isPrecise(a + b)) return new SmallInteger(a + b);\n b = smallToArray(Math.abs(b));\n }\n return new BigInteger(addSmall(b, Math.abs(a)), a < 0);\n };\n SmallInteger.prototype.plus = SmallInteger.prototype.add;\n\n NativeBigInt.prototype.add = function (v) {\n return new NativeBigInt(this.value + parseValue(v).value);\n }\n NativeBigInt.prototype.plus = NativeBigInt.prototype.add;\n\n function subtract(a, b) { // assumes a and b are arrays with a >= b\n var a_l = a.length,\n b_l = b.length,\n r = new Array(a_l),\n borrow = 0,\n base = BASE,\n i, difference;\n for (i = 0; i < b_l; i++) {\n difference = a[i] - borrow - b[i];\n if (difference < 0) {\n difference += base;\n borrow = 1;\n } else borrow = 0;\n r[i] = difference;\n }\n for (i = b_l; i < a_l; i++) {\n difference = a[i] - borrow;\n if (difference < 0) difference += base;\n else {\n r[i++] = difference;\n break;\n }\n r[i] = difference;\n }\n for (; i < a_l; i++) {\n r[i] = a[i];\n }\n trim(r);\n return r;\n }\n\n function subtractAny(a, b, sign) {\n var value;\n if (compareAbs(a, b) >= 0) {\n value = subtract(a, b);\n } else {\n value = subtract(b, a);\n sign = !sign;\n }\n value = arrayToSmall(value);\n if (typeof value === \"number\") {\n if (sign) value = -value;\n return new SmallInteger(value);\n }\n return new BigInteger(value, sign);\n }\n\n function subtractSmall(a, b, sign) { // assumes a is array, b is number with 0 <= b < MAX_INT\n var l = a.length,\n r = new Array(l),\n carry = -b,\n base = BASE,\n i, difference;\n for (i = 0; i < l; i++) {\n difference = a[i] + carry;\n carry = Math.floor(difference / base);\n difference %= base;\n r[i] = difference < 0 ? difference + base : difference;\n }\n r = arrayToSmall(r);\n if (typeof r === \"number\") {\n if (sign) r = -r;\n return new SmallInteger(r);\n } return new BigInteger(r, sign);\n }\n\n BigInteger.prototype.subtract = function (v) {\n var n = parseValue(v);\n if (this.sign !== n.sign) {\n return this.add(n.negate());\n }\n var a = this.value, b = n.value;\n if (n.isSmall)\n return subtractSmall(a, Math.abs(b), this.sign);\n return subtractAny(a, b, this.sign);\n };\n BigInteger.prototype.minus = BigInteger.prototype.subtract;\n\n SmallInteger.prototype.subtract = function (v) {\n var n = parseValue(v);\n var a = this.value;\n if (a < 0 !== n.sign) {\n return this.add(n.negate());\n }\n var b = n.value;\n if (n.isSmall) {\n return new SmallInteger(a - b);\n }\n return subtractSmall(b, Math.abs(a), a >= 0);\n };\n SmallInteger.prototype.minus = SmallInteger.prototype.subtract;\n\n NativeBigInt.prototype.subtract = function (v) {\n return new NativeBigInt(this.value - parseValue(v).value);\n }\n NativeBigInt.prototype.minus = NativeBigInt.prototype.subtract;\n\n BigInteger.prototype.negate = function () {\n return new BigInteger(this.value, !this.sign);\n };\n SmallInteger.prototype.negate = function () {\n var sign = this.sign;\n var small = new SmallInteger(-this.value);\n small.sign = !sign;\n return small;\n };\n NativeBigInt.prototype.negate = function () {\n return new NativeBigInt(-this.value);\n }\n\n BigInteger.prototype.abs = function () {\n return new BigInteger(this.value, false);\n };\n SmallInteger.prototype.abs = function () {\n return new SmallInteger(Math.abs(this.value));\n };\n NativeBigInt.prototype.abs = function () {\n return new NativeBigInt(this.value >= 0 ? this.value : -this.value);\n }\n\n\n function multiplyLong(a, b) {\n var a_l = a.length,\n b_l = b.length,\n l = a_l + b_l,\n r = createArray(l),\n base = BASE,\n product, carry, i, a_i, b_j;\n for (i = 0; i < a_l; ++i) {\n a_i = a[i];\n for (var j = 0; j < b_l; ++j) {\n b_j = b[j];\n product = a_i * b_j + r[i + j];\n carry = Math.floor(product / base);\n r[i + j] = product - carry * base;\n r[i + j + 1] += carry;\n }\n }\n trim(r);\n return r;\n }\n\n function multiplySmall(a, b) { // assumes a is array, b is number with |b| < BASE\n var l = a.length,\n r = new Array(l),\n base = BASE,\n carry = 0,\n product, i;\n for (i = 0; i < l; i++) {\n product = a[i] * b + carry;\n carry = Math.floor(product / base);\n r[i] = product - carry * base;\n }\n while (carry > 0) {\n r[i++] = carry % base;\n carry = Math.floor(carry / base);\n }\n return r;\n }\n\n function shiftLeft(x, n) {\n var r = [];\n while (n-- > 0) r.push(0);\n return r.concat(x);\n }\n\n function multiplyKaratsuba(x, y) {\n var n = Math.max(x.length, y.length);\n\n if (n <= 30) return multiplyLong(x, y);\n n = Math.ceil(n / 2);\n\n var b = x.slice(n),\n a = x.slice(0, n),\n d = y.slice(n),\n c = y.slice(0, n);\n\n var ac = multiplyKaratsuba(a, c),\n bd = multiplyKaratsuba(b, d),\n abcd = multiplyKaratsuba(addAny(a, b), addAny(c, d));\n\n var product = addAny(addAny(ac, shiftLeft(subtract(subtract(abcd, ac), bd), n)), shiftLeft(bd, 2 * n));\n trim(product);\n return product;\n }\n\n // The following function is derived from a surface fit of a graph plotting the performance difference\n // between long multiplication and karatsuba multiplication versus the lengths of the two arrays.\n function useKaratsuba(l1, l2) {\n return -0.012 * l1 - 0.012 * l2 + 0.000015 * l1 * l2 > 0;\n }\n\n BigInteger.prototype.multiply = function (v) {\n var n = parseValue(v),\n a = this.value, b = n.value,\n sign = this.sign !== n.sign,\n abs;\n if (n.isSmall) {\n if (b === 0) return Integer[0];\n if (b === 1) return this;\n if (b === -1) return this.negate();\n abs = Math.abs(b);\n if (abs < BASE) {\n return new BigInteger(multiplySmall(a, abs), sign);\n }\n b = smallToArray(abs);\n }\n if (useKaratsuba(a.length, b.length)) // Karatsuba is only faster for certain array sizes\n return new BigInteger(multiplyKaratsuba(a, b), sign);\n return new BigInteger(multiplyLong(a, b), sign);\n };\n\n BigInteger.prototype.times = BigInteger.prototype.multiply;\n\n function multiplySmallAndArray(a, b, sign) { // a >= 0\n if (a < BASE) {\n return new BigInteger(multiplySmall(b, a), sign);\n }\n return new BigInteger(multiplyLong(b, smallToArray(a)), sign);\n }\n SmallInteger.prototype._multiplyBySmall = function (a) {\n if (isPrecise(a.value * this.value)) {\n return new SmallInteger(a.value * this.value);\n }\n return multiplySmallAndArray(Math.abs(a.value), smallToArray(Math.abs(this.value)), this.sign !== a.sign);\n };\n BigInteger.prototype._multiplyBySmall = function (a) {\n if (a.value === 0) return Integer[0];\n if (a.value === 1) return this;\n if (a.value === -1) return this.negate();\n return multiplySmallAndArray(Math.abs(a.value), this.value, this.sign !== a.sign);\n };\n SmallInteger.prototype.multiply = function (v) {\n return parseValue(v)._multiplyBySmall(this);\n };\n SmallInteger.prototype.times = SmallInteger.prototype.multiply;\n\n NativeBigInt.prototype.multiply = function (v) {\n return new NativeBigInt(this.value * parseValue(v).value);\n }\n NativeBigInt.prototype.times = NativeBigInt.prototype.multiply;\n\n function square(a) {\n //console.assert(2 * BASE * BASE < MAX_INT);\n var l = a.length,\n r = createArray(l + l),\n base = BASE,\n product, carry, i, a_i, a_j;\n for (i = 0; i < l; i++) {\n a_i = a[i];\n carry = 0 - a_i * a_i;\n for (var j = i; j < l; j++) {\n a_j = a[j];\n product = 2 * (a_i * a_j) + r[i + j] + carry;\n carry = Math.floor(product / base);\n r[i + j] = product - carry * base;\n }\n r[i + l] = carry;\n }\n trim(r);\n return r;\n }\n\n BigInteger.prototype.square = function () {\n return new BigInteger(square(this.value), false);\n };\n\n SmallInteger.prototype.square = function () {\n var value = this.value * this.value;\n if (isPrecise(value)) return new SmallInteger(value);\n return new BigInteger(square(smallToArray(Math.abs(this.value))), false);\n };\n\n NativeBigInt.prototype.square = function (v) {\n return new NativeBigInt(this.value * this.value);\n }\n\n function divMod1(a, b) { // Left over from previous version. Performs faster than divMod2 on smaller input sizes.\n var a_l = a.length,\n b_l = b.length,\n base = BASE,\n result = createArray(b.length),\n divisorMostSignificantDigit = b[b_l - 1],\n // normalization\n lambda = Math.ceil(base / (2 * divisorMostSignificantDigit)),\n remainder = multiplySmall(a, lambda),\n divisor = multiplySmall(b, lambda),\n quotientDigit, shift, carry, borrow, i, l, q;\n if (remainder.length <= a_l) remainder.push(0);\n divisor.push(0);\n divisorMostSignificantDigit = divisor[b_l - 1];\n for (shift = a_l - b_l; shift >= 0; shift--) {\n quotientDigit = base - 1;\n if (remainder[shift + b_l] !== divisorMostSignificantDigit) {\n quotientDigit = Math.floor((remainder[shift + b_l] * base + remainder[shift + b_l - 1]) / divisorMostSignificantDigit);\n }\n // quotientDigit <= base - 1\n carry = 0;\n borrow = 0;\n l = divisor.length;\n for (i = 0; i < l; i++) {\n carry += quotientDigit * divisor[i];\n q = Math.floor(carry / base);\n borrow += remainder[shift + i] - (carry - q * base);\n carry = q;\n if (borrow < 0) {\n remainder[shift + i] = borrow + base;\n borrow = -1;\n } else {\n remainder[shift + i] = borrow;\n borrow = 0;\n }\n }\n while (borrow !== 0) {\n quotientDigit -= 1;\n carry = 0;\n for (i = 0; i < l; i++) {\n carry += remainder[shift + i] - base + divisor[i];\n if (carry < 0) {\n remainder[shift + i] = carry + base;\n carry = 0;\n } else {\n remainder[shift + i] = carry;\n carry = 1;\n }\n }\n borrow += carry;\n }\n result[shift] = quotientDigit;\n }\n // denormalization\n remainder = divModSmall(remainder, lambda)[0];\n return [arrayToSmall(result), arrayToSmall(remainder)];\n }\n\n function divMod2(a, b) { // Implementation idea shamelessly stolen from Silent Matt's library http://silentmatt.com/biginteger/\n // Performs faster than divMod1 on larger input sizes.\n var a_l = a.length,\n b_l = b.length,\n result = [],\n part = [],\n base = BASE,\n guess, xlen, highx, highy, check;\n while (a_l) {\n part.unshift(a[--a_l]);\n trim(part);\n if (compareAbs(part, b) < 0) {\n result.push(0);\n continue;\n }\n xlen = part.length;\n highx = part[xlen - 1] * base + part[xlen - 2];\n highy = b[b_l - 1] * base + b[b_l - 2];\n if (xlen > b_l) {\n highx = (highx + 1) * base;\n }\n guess = Math.ceil(highx / highy);\n do {\n check = multiplySmall(b, guess);\n if (compareAbs(check, part) <= 0) break;\n guess--;\n } while (guess);\n result.push(guess);\n part = subtract(part, check);\n }\n result.reverse();\n return [arrayToSmall(result), arrayToSmall(part)];\n }\n\n function divModSmall(value, lambda) {\n var length = value.length,\n quotient = createArray(length),\n base = BASE,\n i, q, remainder, divisor;\n remainder = 0;\n for (i = length - 1; i >= 0; --i) {\n divisor = remainder * base + value[i];\n q = truncate(divisor / lambda);\n remainder = divisor - q * lambda;\n quotient[i] = q | 0;\n }\n return [quotient, remainder | 0];\n }\n\n function divModAny(self, v) {\n var value, n = parseValue(v);\n if (supportsNativeBigInt) {\n return [new NativeBigInt(self.value / n.value), new NativeBigInt(self.value % n.value)];\n }\n var a = self.value, b = n.value;\n var quotient;\n if (b === 0) throw new Error(\"Cannot divide by zero\");\n if (self.isSmall) {\n if (n.isSmall) {\n return [new SmallInteger(truncate(a / b)), new SmallInteger(a % b)];\n }\n return [Integer[0], self];\n }\n if (n.isSmall) {\n if (b === 1) return [self, Integer[0]];\n if (b == -1) return [self.negate(), Integer[0]];\n var abs = Math.abs(b);\n if (abs < BASE) {\n value = divModSmall(a, abs);\n quotient = arrayToSmall(value[0]);\n var remainder = value[1];\n if (self.sign) remainder = -remainder;\n if (typeof quotient === \"number\") {\n if (self.sign !== n.sign) quotient = -quotient;\n return [new SmallInteger(quotient), new SmallInteger(remainder)];\n }\n return [new BigInteger(quotient, self.sign !== n.sign), new SmallInteger(remainder)];\n }\n b = smallToArray(abs);\n }\n var comparison = compareAbs(a, b);\n if (comparison === -1) return [Integer[0], self];\n if (comparison === 0) return [Integer[self.sign === n.sign ? 1 : -1], Integer[0]];\n\n // divMod1 is faster on smaller input sizes\n if (a.length + b.length <= 200)\n value = divMod1(a, b);\n else value = divMod2(a, b);\n\n quotient = value[0];\n var qSign = self.sign !== n.sign,\n mod = value[1],\n mSign = self.sign;\n if (typeof quotient === \"number\") {\n if (qSign) quotient = -quotient;\n quotient = new SmallInteger(quotient);\n } else quotient = new BigInteger(quotient, qSign);\n if (typeof mod === \"number\") {\n if (mSign) mod = -mod;\n mod = new SmallInteger(mod);\n } else mod = new BigInteger(mod, mSign);\n return [quotient, mod];\n }\n\n BigInteger.prototype.divmod = function (v) {\n var result = divModAny(this, v);\n return {\n quotient: result[0],\n remainder: result[1]\n };\n };\n NativeBigInt.prototype.divmod = SmallInteger.prototype.divmod = BigInteger.prototype.divmod;\n\n\n BigInteger.prototype.divide = function (v) {\n return divModAny(this, v)[0];\n };\n NativeBigInt.prototype.over = NativeBigInt.prototype.divide = function (v) {\n return new NativeBigInt(this.value / parseValue(v).value);\n };\n SmallInteger.prototype.over = SmallInteger.prototype.divide = BigInteger.prototype.over = BigInteger.prototype.divide;\n\n BigInteger.prototype.mod = function (v) {\n return divModAny(this, v)[1];\n };\n NativeBigInt.prototype.mod = NativeBigInt.prototype.remainder = function (v) {\n return new NativeBigInt(this.value % parseValue(v).value);\n };\n SmallInteger.prototype.remainder = SmallInteger.prototype.mod = BigInteger.prototype.remainder = BigInteger.prototype.mod;\n\n BigInteger.prototype.pow = function (v) {\n var n = parseValue(v),\n a = this.value,\n b = n.value,\n value, x, y;\n if (b === 0) return Integer[1];\n if (a === 0) return Integer[0];\n if (a === 1) return Integer[1];\n if (a === -1) return n.isEven() ? Integer[1] : Integer[-1];\n if (n.sign) {\n return Integer[0];\n }\n if (!n.isSmall) throw new Error(\"The exponent \" + n.toString() + \" is too large.\");\n if (this.isSmall) {\n if (isPrecise(value = Math.pow(a, b)))\n return new SmallInteger(truncate(value));\n }\n x = this;\n y = Integer[1];\n while (true) {\n if (b & 1 === 1) {\n y = y.times(x);\n --b;\n }\n if (b === 0) break;\n b /= 2;\n x = x.square();\n }\n return y;\n };\n SmallInteger.prototype.pow = BigInteger.prototype.pow;\n\n NativeBigInt.prototype.pow = function (v) {\n var n = parseValue(v);\n var a = this.value, b = n.value;\n var _0 = BigInt(0), _1 = BigInt(1), _2 = BigInt(2);\n if (b === _0) return Integer[1];\n if (a === _0) return Integer[0];\n if (a === _1) return Integer[1];\n if (a === BigInt(-1)) return n.isEven() ? Integer[1] : Integer[-1];\n if (n.isNegative()) return new NativeBigInt(_0);\n var x = this;\n var y = Integer[1];\n while (true) {\n if ((b & _1) === _1) {\n y = y.times(x);\n --b;\n }\n if (b === _0) break;\n b /= _2;\n x = x.square();\n }\n return y;\n }\n\n BigInteger.prototype.modPow = function (exp, mod) {\n exp = parseValue(exp);\n mod = parseValue(mod);\n if (mod.isZero()) throw new Error(\"Cannot take modPow with modulus 0\");\n var r = Integer[1],\n base = this.mod(mod);\n if (exp.isNegative()) {\n exp = exp.multiply(Integer[-1]);\n base = base.modInv(mod);\n }\n while (exp.isPositive()) {\n if (base.isZero()) return Integer[0];\n if (exp.isOdd()) r = r.multiply(base).mod(mod);\n exp = exp.divide(2);\n base = base.square().mod(mod);\n }\n return r;\n };\n NativeBigInt.prototype.modPow = SmallInteger.prototype.modPow = BigInteger.prototype.modPow;\n\n function compareAbs(a, b) {\n if (a.length !== b.length) {\n return a.length > b.length ? 1 : -1;\n }\n for (var i = a.length - 1; i >= 0; i--) {\n if (a[i] !== b[i]) return a[i] > b[i] ? 1 : -1;\n }\n return 0;\n }\n\n BigInteger.prototype.compareAbs = function (v) {\n var n = parseValue(v),\n a = this.value,\n b = n.value;\n if (n.isSmall) return 1;\n return compareAbs(a, b);\n };\n SmallInteger.prototype.compareAbs = function (v) {\n var n = parseValue(v),\n a = Math.abs(this.value),\n b = n.value;\n if (n.isSmall) {\n b = Math.abs(b);\n return a === b ? 0 : a > b ? 1 : -1;\n }\n return -1;\n };\n NativeBigInt.prototype.compareAbs = function (v) {\n var a = this.value;\n var b = parseValue(v).value;\n a = a >= 0 ? a : -a;\n b = b >= 0 ? b : -b;\n return a === b ? 0 : a > b ? 1 : -1;\n }\n\n BigInteger.prototype.compare = function (v) {\n // See discussion about comparison with Infinity:\n // https://github.com/peterolson/BigInteger.js/issues/61\n if (v === Infinity) {\n return -1;\n }\n if (v === -Infinity) {\n return 1;\n }\n\n var n = parseValue(v),\n a = this.value,\n b = n.value;\n if (this.sign !== n.sign) {\n return n.sign ? 1 : -1;\n }\n if (n.isSmall) {\n return this.sign ? -1 : 1;\n }\n return compareAbs(a, b) * (this.sign ? -1 : 1);\n };\n BigInteger.prototype.compareTo = BigInteger.prototype.compare;\n\n SmallInteger.prototype.compare = function (v) {\n if (v === Infinity) {\n return -1;\n }\n if (v === -Infinity) {\n return 1;\n }\n\n var n = parseValue(v),\n a = this.value,\n b = n.value;\n if (n.isSmall) {\n return a == b ? 0 : a > b ? 1 : -1;\n }\n if (a < 0 !== n.sign) {\n return a < 0 ? -1 : 1;\n }\n return a < 0 ? 1 : -1;\n };\n SmallInteger.prototype.compareTo = SmallInteger.prototype.compare;\n\n NativeBigInt.prototype.compare = function (v) {\n if (v === Infinity) {\n return -1;\n }\n if (v === -Infinity) {\n return 1;\n }\n var a = this.value;\n var b = parseValue(v).value;\n return a === b ? 0 : a > b ? 1 : -1;\n }\n NativeBigInt.prototype.compareTo = NativeBigInt.prototype.compare;\n\n BigInteger.prototype.equals = function (v) {\n return this.compare(v) === 0;\n };\n NativeBigInt.prototype.eq = NativeBigInt.prototype.equals = SmallInteger.prototype.eq = SmallInteger.prototype.equals = BigInteger.prototype.eq = BigInteger.prototype.equals;\n\n BigInteger.prototype.notEquals = function (v) {\n return this.compare(v) !== 0;\n };\n NativeBigInt.prototype.neq = NativeBigInt.prototype.notEquals = SmallInteger.prototype.neq = SmallInteger.prototype.notEquals = BigInteger.prototype.neq = BigInteger.prototype.notEquals;\n\n BigInteger.prototype.greater = function (v) {\n return this.compare(v) > 0;\n };\n NativeBigInt.prototype.gt = NativeBigInt.prototype.greater = SmallInteger.prototype.gt = SmallInteger.prototype.greater = BigInteger.prototype.gt = BigInteger.prototype.greater;\n\n BigInteger.prototype.lesser = function (v) {\n return this.compare(v) < 0;\n };\n NativeBigInt.prototype.lt = NativeBigInt.prototype.lesser = SmallInteger.prototype.lt = SmallInteger.prototype.lesser = BigInteger.prototype.lt = BigInteger.prototype.lesser;\n\n BigInteger.prototype.greaterOrEquals = function (v) {\n return this.compare(v) >= 0;\n };\n NativeBigInt.prototype.geq = NativeBigInt.prototype.greaterOrEquals = SmallInteger.prototype.geq = SmallInteger.prototype.greaterOrEquals = BigInteger.prototype.geq = BigInteger.prototype.greaterOrEquals;\n\n BigInteger.prototype.lesserOrEquals = function (v) {\n return this.compare(v) <= 0;\n };\n NativeBigInt.prototype.leq = NativeBigInt.prototype.lesserOrEquals = SmallInteger.prototype.leq = SmallInteger.prototype.lesserOrEquals = BigInteger.prototype.leq = BigInteger.prototype.lesserOrEquals;\n\n BigInteger.prototype.isEven = function () {\n return (this.value[0] & 1) === 0;\n };\n SmallInteger.prototype.isEven = function () {\n return (this.value & 1) === 0;\n };\n NativeBigInt.prototype.isEven = function () {\n return (this.value & BigInt(1)) === BigInt(0);\n }\n\n BigInteger.prototype.isOdd = function () {\n return (this.value[0] & 1) === 1;\n };\n SmallInteger.prototype.isOdd = function () {\n return (this.value & 1) === 1;\n };\n NativeBigInt.prototype.isOdd = function () {\n return (this.value & BigInt(1)) === BigInt(1);\n }\n\n BigInteger.prototype.isPositive = function () {\n return !this.sign;\n };\n SmallInteger.prototype.isPositive = function () {\n return this.value > 0;\n };\n NativeBigInt.prototype.isPositive = SmallInteger.prototype.isPositive;\n\n BigInteger.prototype.isNegative = function () {\n return this.sign;\n };\n SmallInteger.prototype.isNegative = function () {\n return this.value < 0;\n };\n NativeBigInt.prototype.isNegative = SmallInteger.prototype.isNegative;\n\n BigInteger.prototype.isUnit = function () {\n return false;\n };\n SmallInteger.prototype.isUnit = function () {\n return Math.abs(this.value) === 1;\n };\n NativeBigInt.prototype.isUnit = function () {\n return this.abs().value === BigInt(1);\n }\n\n BigInteger.prototype.isZero = function () {\n return false;\n };\n SmallInteger.prototype.isZero = function () {\n return this.value === 0;\n };\n NativeBigInt.prototype.isZero = function () {\n return this.value === BigInt(0);\n }\n\n BigInteger.prototype.isDivisibleBy = function (v) {\n var n = parseValue(v);\n if (n.isZero()) return false;\n if (n.isUnit()) return true;\n if (n.compareAbs(2) === 0) return this.isEven();\n return this.mod(n).isZero();\n };\n NativeBigInt.prototype.isDivisibleBy = SmallInteger.prototype.isDivisibleBy = BigInteger.prototype.isDivisibleBy;\n\n function isBasicPrime(v) {\n var n = v.abs();\n if (n.isUnit()) return false;\n if (n.equals(2) || n.equals(3) || n.equals(5)) return true;\n if (n.isEven() || n.isDivisibleBy(3) || n.isDivisibleBy(5)) return false;\n if (n.lesser(49)) return true;\n // we don't know if it's prime: let the other functions figure it out\n }\n\n function millerRabinTest(n, a) {\n var nPrev = n.prev(),\n b = nPrev,\n r = 0,\n d, t, i, x;\n while (b.isEven()) b = b.divide(2), r++;\n next: for (i = 0; i < a.length; i++) {\n if (n.lesser(a[i])) continue;\n x = bigInt(a[i]).modPow(b, n);\n if (x.isUnit() || x.equals(nPrev)) continue;\n for (d = r - 1; d != 0; d--) {\n x = x.square().mod(n);\n if (x.isUnit()) return false;\n if (x.equals(nPrev)) continue next;\n }\n return false;\n }\n return true;\n }\n\n // Set \"strict\" to true to force GRH-supported lower bound of 2*log(N)^2\n BigInteger.prototype.isPrime = function (strict) {\n var isPrime = isBasicPrime(this);\n if (isPrime !== undefined) return isPrime;\n var n = this.abs();\n var bits = n.bitLength();\n if (bits <= 64)\n return millerRabinTest(n, [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37]);\n var logN = Math.log(2) * bits.toJSNumber();\n var t = Math.ceil((strict === true) ? (2 * Math.pow(logN, 2)) : logN);\n for (var a = [], i = 0; i < t; i++) {\n a.push(bigInt(i + 2));\n }\n return millerRabinTest(n, a);\n };\n NativeBigInt.prototype.isPrime = SmallInteger.prototype.isPrime = BigInteger.prototype.isPrime;\n\n BigInteger.prototype.isProbablePrime = function (iterations) {\n var isPrime = isBasicPrime(this);\n if (isPrime !== undefined) return isPrime;\n var n = this.abs();\n var t = iterations === undefined ? 5 : iterations;\n for (var a = [], i = 0; i < t; i++) {\n a.push(bigInt.randBetween(2, n.minus(2)));\n }\n return millerRabinTest(n, a);\n };\n NativeBigInt.prototype.isProbablePrime = SmallInteger.prototype.isProbablePrime = BigInteger.prototype.isProbablePrime;\n\n BigInteger.prototype.modInv = function (n) {\n var t = bigInt.zero, newT = bigInt.one, r = parseValue(n), newR = this.abs(), q, lastT, lastR;\n while (!newR.isZero()) {\n q = r.divide(newR);\n lastT = t;\n lastR = r;\n t = newT;\n r = newR;\n newT = lastT.subtract(q.multiply(newT));\n newR = lastR.subtract(q.multiply(newR));\n }\n if (!r.isUnit()) throw new Error(this.toString() + \" and \" + n.toString() + \" are not co-prime\");\n if (t.compare(0) === -1) {\n t = t.add(n);\n }\n if (this.isNegative()) {\n return t.negate();\n }\n return t;\n };\n\n NativeBigInt.prototype.modInv = SmallInteger.prototype.modInv = BigInteger.prototype.modInv;\n\n BigInteger.prototype.next = function () {\n var value = this.value;\n if (this.sign) {\n return subtractSmall(value, 1, this.sign);\n }\n return new BigInteger(addSmall(value, 1), this.sign);\n };\n SmallInteger.prototype.next = function () {\n var value = this.value;\n if (value + 1 < MAX_INT) return new SmallInteger(value + 1);\n return new BigInteger(MAX_INT_ARR, false);\n };\n NativeBigInt.prototype.next = function () {\n return new NativeBigInt(this.value + BigInt(1));\n }\n\n BigInteger.prototype.prev = function () {\n var value = this.value;\n if (this.sign) {\n return new BigInteger(addSmall(value, 1), true);\n }\n return subtractSmall(value, 1, this.sign);\n };\n SmallInteger.prototype.prev = function () {\n var value = this.value;\n if (value - 1 > -MAX_INT) return new SmallInteger(value - 1);\n return new BigInteger(MAX_INT_ARR, true);\n };\n NativeBigInt.prototype.prev = function () {\n return new NativeBigInt(this.value - BigInt(1));\n }\n\n var powersOfTwo = [1];\n while (2 * powersOfTwo[powersOfTwo.length - 1] <= BASE) powersOfTwo.push(2 * powersOfTwo[powersOfTwo.length - 1]);\n var powers2Length = powersOfTwo.length, highestPower2 = powersOfTwo[powers2Length - 1];\n\n function shift_isSmall(n) {\n return Math.abs(n) <= BASE;\n }\n\n BigInteger.prototype.shiftLeft = function (v) {\n var n = parseValue(v).toJSNumber();\n if (!shift_isSmall(n)) {\n throw new Error(String(n) + \" is too large for shifting.\");\n }\n if (n < 0) return this.shiftRight(-n);\n var result = this;\n if (result.isZero()) return result;\n while (n >= powers2Length) {\n result = result.multiply(highestPower2);\n n -= powers2Length - 1;\n }\n return result.multiply(powersOfTwo[n]);\n };\n NativeBigInt.prototype.shiftLeft = SmallInteger.prototype.shiftLeft = BigInteger.prototype.shiftLeft;\n\n BigInteger.prototype.shiftRight = function (v) {\n var remQuo;\n var n = parseValue(v).toJSNumber();\n if (!shift_isSmall(n)) {\n throw new Error(String(n) + \" is too large for shifting.\");\n }\n if (n < 0) return this.shiftLeft(-n);\n var result = this;\n while (n >= powers2Length) {\n if (result.isZero() || (result.isNegative() && result.isUnit())) return result;\n remQuo = divModAny(result, highestPower2);\n result = remQuo[1].isNegative() ? remQuo[0].prev() : remQuo[0];\n n -= powers2Length - 1;\n }\n remQuo = divModAny(result, powersOfTwo[n]);\n return remQuo[1].isNegative() ? remQuo[0].prev() : remQuo[0];\n };\n NativeBigInt.prototype.shiftRight = SmallInteger.prototype.shiftRight = BigInteger.prototype.shiftRight;\n\n function bitwise(x, y, fn) {\n y = parseValue(y);\n var xSign = x.isNegative(), ySign = y.isNegative();\n var xRem = xSign ? x.not() : x,\n yRem = ySign ? y.not() : y;\n var xDigit = 0, yDigit = 0;\n var xDivMod = null, yDivMod = null;\n var result = [];\n while (!xRem.isZero() || !yRem.isZero()) {\n xDivMod = divModAny(xRem, highestPower2);\n xDigit = xDivMod[1].toJSNumber();\n if (xSign) {\n xDigit = highestPower2 - 1 - xDigit; // two's complement for negative numbers\n }\n\n yDivMod = divModAny(yRem, highestPower2);\n yDigit = yDivMod[1].toJSNumber();\n if (ySign) {\n yDigit = highestPower2 - 1 - yDigit; // two's complement for negative numbers\n }\n\n xRem = xDivMod[0];\n yRem = yDivMod[0];\n result.push(fn(xDigit, yDigit));\n }\n var sum = fn(xSign ? 1 : 0, ySign ? 1 : 0) !== 0 ? bigInt(-1) : bigInt(0);\n for (var i = result.length - 1; i >= 0; i -= 1) {\n sum = sum.multiply(highestPower2).add(bigInt(result[i]));\n }\n return sum;\n }\n\n BigInteger.prototype.not = function () {\n return this.negate().prev();\n };\n NativeBigInt.prototype.not = SmallInteger.prototype.not = BigInteger.prototype.not;\n\n BigInteger.prototype.and = function (n) {\n return bitwise(this, n, function (a, b) { return a & b; });\n };\n NativeBigInt.prototype.and = SmallInteger.prototype.and = BigInteger.prototype.and;\n\n BigInteger.prototype.or = function (n) {\n return bitwise(this, n, function (a, b) { return a | b; });\n };\n NativeBigInt.prototype.or = SmallInteger.prototype.or = BigInteger.prototype.or;\n\n BigInteger.prototype.xor = function (n) {\n return bitwise(this, n, function (a, b) { return a ^ b; });\n };\n NativeBigInt.prototype.xor = SmallInteger.prototype.xor = BigInteger.prototype.xor;\n\n var LOBMASK_I = 1 << 30, LOBMASK_BI = (BASE & -BASE) * (BASE & -BASE) | LOBMASK_I;\n function roughLOB(n) { // get lowestOneBit (rough)\n // SmallInteger: return Min(lowestOneBit(n), 1 << 30)\n // BigInteger: return Min(lowestOneBit(n), 1 << 14) [BASE=1e7]\n var v = n.value,\n x = typeof v === \"number\" ? v | LOBMASK_I :\n typeof v === \"bigint\" ? v | BigInt(LOBMASK_I) :\n v[0] + v[1] * BASE | LOBMASK_BI;\n return x & -x;\n }\n\n function integerLogarithm(value, base) {\n if (base.compareTo(value) <= 0) {\n var tmp = integerLogarithm(value, base.square(base));\n var p = tmp.p;\n var e = tmp.e;\n var t = p.multiply(base);\n return t.compareTo(value) <= 0 ? { p: t, e: e * 2 + 1 } : { p: p, e: e * 2 };\n }\n return { p: bigInt(1), e: 0 };\n }\n\n BigInteger.prototype.bitLength = function () {\n var n = this;\n if (n.compareTo(bigInt(0)) < 0) {\n n = n.negate().subtract(bigInt(1));\n }\n if (n.compareTo(bigInt(0)) === 0) {\n return bigInt(0);\n }\n return bigInt(integerLogarithm(n, bigInt(2)).e).add(bigInt(1));\n }\n NativeBigInt.prototype.bitLength = SmallInteger.prototype.bitLength = BigInteger.prototype.bitLength;\n\n function max(a, b) {\n a = parseValue(a);\n b = parseValue(b);\n return a.greater(b) ? a : b;\n }\n function min(a, b) {\n a = parseValue(a);\n b = parseValue(b);\n return a.lesser(b) ? a : b;\n }\n function gcd(a, b) {\n a = parseValue(a).abs();\n b = parseValue(b).abs();\n if (a.equals(b)) return a;\n if (a.isZero()) return b;\n if (b.isZero()) return a;\n var c = Integer[1], d, t;\n while (a.isEven() && b.isEven()) {\n d = min(roughLOB(a), roughLOB(b));\n a = a.divide(d);\n b = b.divide(d);\n c = c.multiply(d);\n }\n while (a.isEven()) {\n a = a.divide(roughLOB(a));\n }\n do {\n while (b.isEven()) {\n b = b.divide(roughLOB(b));\n }\n if (a.greater(b)) {\n t = b; b = a; a = t;\n }\n b = b.subtract(a);\n } while (!b.isZero());\n return c.isUnit() ? a : a.multiply(c);\n }\n function lcm(a, b) {\n a = parseValue(a).abs();\n b = parseValue(b).abs();\n return a.divide(gcd(a, b)).multiply(b);\n }\n function randBetween(a, b) {\n a = parseValue(a);\n b = parseValue(b);\n var low = min(a, b), high = max(a, b);\n var range = high.subtract(low).add(1);\n if (range.isSmall) return low.add(Math.floor(Math.random() * range));\n var digits = toBase(range, BASE).value;\n var result = [], restricted = true;\n for (var i = 0; i < digits.length; i++) {\n var top = restricted ? digits[i] : BASE;\n var digit = truncate(Math.random() * top);\n result.push(digit);\n if (digit < top) restricted = false;\n }\n return low.add(Integer.fromArray(result, BASE, false));\n }\n\n var parseBase = function (text, base, alphabet, caseSensitive) {\n alphabet = alphabet || DEFAULT_ALPHABET;\n text = String(text);\n if (!caseSensitive) {\n text = text.toLowerCase();\n alphabet = alphabet.toLowerCase();\n }\n var length = text.length;\n var i;\n var absBase = Math.abs(base);\n var alphabetValues = {};\n for (i = 0; i < alphabet.length; i++) {\n alphabetValues[alphabet[i]] = i;\n }\n for (i = 0; i < length; i++) {\n var c = text[i];\n if (c === \"-\") continue;\n if (c in alphabetValues) {\n if (alphabetValues[c] >= absBase) {\n if (c === \"1\" && absBase === 1) continue;\n throw new Error(c + \" is not a valid digit in base \" + base + \".\");\n }\n }\n }\n base = parseValue(base);\n var digits = [];\n var isNegative = text[0] === \"-\";\n for (i = isNegative ? 1 : 0; i < text.length; i++) {\n var c = text[i];\n if (c in alphabetValues) digits.push(parseValue(alphabetValues[c]));\n else if (c === \"<\") {\n var start = i;\n do { i++; } while (text[i] !== \">\" && i < text.length);\n digits.push(parseValue(text.slice(start + 1, i)));\n }\n else throw new Error(c + \" is not a valid character\");\n }\n return parseBaseFromArray(digits, base, isNegative);\n };\n\n function parseBaseFromArray(digits, base, isNegative) {\n var val = Integer[0], pow = Integer[1], i;\n for (i = digits.length - 1; i >= 0; i--) {\n val = val.add(digits[i].times(pow));\n pow = pow.times(base);\n }\n return isNegative ? val.negate() : val;\n }\n\n function stringify(digit, alphabet) {\n alphabet = alphabet || DEFAULT_ALPHABET;\n if (digit < alphabet.length) {\n return alphabet[digit];\n }\n return \"<\" + digit + \">\";\n }\n\n function toBase(n, base) {\n base = bigInt(base);\n if (base.isZero()) {\n if (n.isZero()) return { value: [0], isNegative: false };\n throw new Error(\"Cannot convert nonzero numbers to base 0.\");\n }\n if (base.equals(-1)) {\n if (n.isZero()) return { value: [0], isNegative: false };\n if (n.isNegative())\n return {\n value: [].concat.apply([], Array.apply(null, Array(-n.toJSNumber()))\n .map(Array.prototype.valueOf, [1, 0])\n ),\n isNegative: false\n };\n\n var arr = Array.apply(null, Array(n.toJSNumber() - 1))\n .map(Array.prototype.valueOf, [0, 1]);\n arr.unshift([1]);\n return {\n value: [].concat.apply([], arr),\n isNegative: false\n };\n }\n\n var neg = false;\n if (n.isNegative() && base.isPositive()) {\n neg = true;\n n = n.abs();\n }\n if (base.isUnit()) {\n if (n.isZero()) return { value: [0], isNegative: false };\n\n return {\n value: Array.apply(null, Array(n.toJSNumber()))\n .map(Number.prototype.valueOf, 1),\n isNegative: neg\n };\n }\n var out = [];\n var left = n, divmod;\n while (left.isNegative() || left.compareAbs(base) >= 0) {\n divmod = left.divmod(base);\n left = divmod.quotient;\n var digit = divmod.remainder;\n if (digit.isNegative()) {\n digit = base.minus(digit).abs();\n left = left.next();\n }\n out.push(digit.toJSNumber());\n }\n out.push(left.toJSNumber());\n return { value: out.reverse(), isNegative: neg };\n }\n\n function toBaseString(n, base, alphabet) {\n var arr = toBase(n, base);\n return (arr.isNegative ? \"-\" : \"\") + arr.value.map(function (x) {\n return stringify(x, alphabet);\n }).join('');\n }\n\n BigInteger.prototype.toArray = function (radix) {\n return toBase(this, radix);\n };\n\n SmallInteger.prototype.toArray = function (radix) {\n return toBase(this, radix);\n };\n\n NativeBigInt.prototype.toArray = function (radix) {\n return toBase(this, radix);\n };\n\n BigInteger.prototype.toString = function (radix, alphabet) {\n if (radix === undefined) radix = 10;\n if (radix !== 10) return toBaseString(this, radix, alphabet);\n var v = this.value, l = v.length, str = String(v[--l]), zeros = \"0000000\", digit;\n while (--l >= 0) {\n digit = String(v[l]);\n str += zeros.slice(digit.length) + digit;\n }\n var sign = this.sign ? \"-\" : \"\";\n return sign + str;\n };\n\n SmallInteger.prototype.toString = function (radix, alphabet) {\n if (radix === undefined) radix = 10;\n if (radix != 10) return toBaseString(this, radix, alphabet);\n return String(this.value);\n };\n\n NativeBigInt.prototype.toString = SmallInteger.prototype.toString;\n\n NativeBigInt.prototype.toJSON = BigInteger.prototype.toJSON = SmallInteger.prototype.toJSON = function () { return this.toString(); }\n\n BigInteger.prototype.valueOf = function () {\n return parseInt(this.toString(), 10);\n };\n BigInteger.prototype.toJSNumber = BigInteger.prototype.valueOf;\n\n SmallInteger.prototype.valueOf = function () {\n return this.value;\n };\n SmallInteger.prototype.toJSNumber = SmallInteger.prototype.valueOf;\n NativeBigInt.prototype.valueOf = NativeBigInt.prototype.toJSNumber = function () {\n return parseInt(this.toString(), 10);\n }\n\n function parseStringValue(v) {\n if (isPrecise(+v)) {\n var x = +v;\n if (x === truncate(x))\n return supportsNativeBigInt ? new NativeBigInt(BigInt(x)) : new SmallInteger(x);\n throw new Error(\"Invalid integer: \" + v);\n }\n var sign = v[0] === \"-\";\n if (sign) v = v.slice(1);\n var split = v.split(/e/i);\n if (split.length > 2) throw new Error(\"Invalid integer: \" + split.join(\"e\"));\n if (split.length === 2) {\n var exp = split[1];\n if (exp[0] === \"+\") exp = exp.slice(1);\n exp = +exp;\n if (exp !== truncate(exp) || !isPrecise(exp)) throw new Error(\"Invalid integer: \" + exp + \" is not a valid exponent.\");\n var text = split[0];\n var decimalPlace = text.indexOf(\".\");\n if (decimalPlace >= 0) {\n exp -= text.length - decimalPlace - 1;\n text = text.slice(0, decimalPlace) + text.slice(decimalPlace + 1);\n }\n if (exp < 0) throw new Error(\"Cannot include negative exponent part for integers\");\n text += (new Array(exp + 1)).join(\"0\");\n v = text;\n }\n var isValid = /^([0-9][0-9]*)$/.test(v);\n if (!isValid) throw new Error(\"Invalid integer: \" + v);\n if (supportsNativeBigInt) {\n return new NativeBigInt(BigInt(sign ? \"-\" + v : v));\n }\n var r = [], max = v.length, l = LOG_BASE, min = max - l;\n while (max > 0) {\n r.push(+v.slice(min, max));\n min -= l;\n if (min < 0) min = 0;\n max -= l;\n }\n trim(r);\n return new BigInteger(r, sign);\n }\n\n function parseNumberValue(v) {\n if (supportsNativeBigInt) {\n return new NativeBigInt(BigInt(v));\n }\n if (isPrecise(v)) {\n if (v !== truncate(v)) throw new Error(v + \" is not an integer.\");\n return new SmallInteger(v);\n }\n return parseStringValue(v.toString());\n }\n\n function parseValue(v) {\n if (typeof v === \"number\") {\n return parseNumberValue(v);\n }\n if (typeof v === \"string\") {\n return parseStringValue(v);\n }\n if (typeof v === \"bigint\") {\n return new NativeBigInt(v);\n }\n return v;\n }\n // Pre-define numbers in range [-999,999]\n for (var i = 0; i < 1000; i++) {\n Integer[i] = parseValue(i);\n if (i > 0) Integer[-i] = parseValue(-i);\n }\n // Backwards compatibility\n Integer.one = Integer[1];\n Integer.zero = Integer[0];\n Integer.minusOne = Integer[-1];\n Integer.max = max;\n Integer.min = min;\n Integer.gcd = gcd;\n Integer.lcm = lcm;\n Integer.isInstance = function (x) { return x instanceof BigInteger || x instanceof SmallInteger || x instanceof NativeBigInt; };\n Integer.randBetween = randBetween;\n\n Integer.fromArray = function (digits, base, isNegative) {\n return parseBaseFromArray(digits.map(parseValue), parseValue(base || 10), isNegative);\n };\n\n return Integer;\n})();\n","/* global bigInt */\n/* eslint-disable no-unused-vars */\n\n// We represent a [Z.t] as a javascript 32bit integers if it fits or as a bigInt.\n\n//Provides: ml_z_normalize\n//Requires: bigInt\nfunction ml_z_normalize(x){\n var y = x.toJSNumber () | 0;\n if(x.equals(bigInt(y))) return y;\n return x;\n}\n\n//Provides: ml_z_mul_overflows\nfunction ml_z_mul_overflows(x,y){\n var z = x*y;\n return z != (z|0);\n}\n\n//external init: unit -> unit\n//Provides: ml_z_init\n//Requires: caml_zarith_marshal, caml_zarith_unmarshal, caml_custom_ops, ml_z_hash, ml_z_compare\nfunction ml_z_init(unit) {\n caml_custom_ops['_z'] =\n { serialize : caml_zarith_marshal,\n deserialize : caml_zarith_unmarshal,\n hash : ml_z_hash,\n compare : ml_z_compare,\n };\n return 0 }\n\n//external ml_z_install_frametable: unit -> unit\n//Provides: ml_z_install_frametable const\nfunction ml_z_install_frametable(unit) { return 0 }\n\n//external neg: t -> t\n//Provides: ml_z_neg const\n//Requires: bigInt, ml_z_normalize\nfunction ml_z_neg(z1) {\n return ml_z_normalize(bigInt(z1).negate());\n}\n\n//external add: t -> t -> t\n//Provides: ml_z_add const\n//Requires: bigInt, ml_z_normalize\nfunction ml_z_add(z1, z2) {\n return ml_z_normalize(bigInt(z1).add(bigInt(z2)));\n}\n\n//external sub: t -> t -> t\n//Provides: ml_z_sub const\n//Requires: bigInt, ml_z_normalize\nfunction ml_z_sub(z1, z2) {\n return ml_z_normalize(bigInt(z1).subtract(bigInt(z2)));\n}\n\n//external mul: t -> t -> t\n//Provides: ml_z_mul const\n//Requires: bigInt, ml_z_normalize\nfunction ml_z_mul(z1, z2) {\n return ml_z_normalize(bigInt(z1).multiply(bigInt(z2)));\n}\n\n//external div: t -> t -> t\n//Provides: ml_z_div\n//Requires: bigInt, caml_raise_zero_divide, ml_z_normalize\nfunction ml_z_div(z1, z2) {\n z2 = bigInt(z2)\n if(z2.equals(bigInt(0))) caml_raise_zero_divide();\n return ml_z_normalize(bigInt(z1).divide(bigInt(z2)))\n}\n\n//external cdiv: t -> t -> t\n//Provides: ml_z_cdiv\n//Requires: bigInt, ml_z_div, ml_z_sign, ml_z_add\nfunction ml_z_cdiv(z1, z2) {\n var z1_pos = ml_z_sign(z1);\n var z2_pos = ml_z_sign(z2);\n if (z1_pos * z2_pos > 0) /* Multiplication is like a signwise xor */ {\n if (!bigInt(z1).mod(bigInt(z2)).equals(bigInt(0))) {\n return ml_z_add(ml_z_div(z1, z2), bigInt(1)) ;\n }\n }\n return ml_z_div(z1, z2);\n}\n\n//external fdiv: t -> t -> t\n//Provides: ml_z_fdiv\n//Requires: bigInt, ml_z_div, ml_z_sign, ml_z_sub\nfunction ml_z_fdiv(z1, z2) {\n var z1_pos = ml_z_sign(z1);\n var z2_pos = ml_z_sign(z2);\n if (z1_pos * z2_pos < 0) /* Multiplication is like a signwise xor */ {\n if (!bigInt(z1).mod(bigInt(z2)).equals(bigInt(0))) {\n return ml_z_sub(ml_z_div(z1, z2), bigInt(1)) ;\n }\n }\n return ml_z_div(z1, z2);\n}\n\n//external rem: t -> t -> t\n//Provides: ml_z_rem\n//Requires: bigInt, caml_raise_zero_divide, ml_z_normalize\nfunction ml_z_rem(z1, z2) {\n z2 = bigInt(z2);\n if (z2.equals(bigInt(0))) {\n caml_raise_zero_divide();\n }\n return ml_z_normalize(bigInt(z1).mod(z2));\n}\n\n//external div_rem: t -> t -> (t * t)\n//Provides: ml_z_div_rem\n//Requires: ml_z_div, ml_z_rem\nfunction ml_z_div_rem(z1, z2) {\n return [0, ml_z_div(z1,z2), ml_z_rem(z1, z2)]\n}\n//external succ: t -> t\n//Provides: ml_z_succ const\n//Requires: bigInt, ml_z_normalize\nfunction ml_z_succ(z1) {\n return ml_z_normalize(bigInt(z1).next());\n}\n\n//external pred: t -> t\n//Provides: ml_z_pred const\n//Requires: bigInt, ml_z_normalize\nfunction ml_z_pred(z1) {\n return ml_z_normalize(bigInt(z1).prev());\n}\n\n//external abs: t -> t\n//Provides: ml_z_abs const\n//Requires: bigInt, ml_z_normalize\nfunction ml_z_abs(z1) {\n return ml_z_normalize(bigInt(z1).abs());\n}\n\n//external logand: t -> t -> t\n//Provides: ml_z_logand const\n//Requires: bigInt, ml_z_normalize\nfunction ml_z_logand(z1, z2) {\n return ml_z_normalize(bigInt(z1).and(bigInt(z2)));\n}\n\n//external logor: t -> t -> t\n//Provides: ml_z_logor const\n//Requires: bigInt, ml_z_normalize\nfunction ml_z_logor(z1, z2) {\n return ml_z_normalize(bigInt(z1).or(bigInt(z2)));\n}\n\n//external logxor: t -> t -> t\n//Provides: ml_z_logxor const\n//Requires: bigInt, ml_z_normalize\nfunction ml_z_logxor(z1, z2) {\n return ml_z_normalize(bigInt(z1).xor(bigInt(z2)));\n}\n\n//external lognot: t -> t\n//Provides: ml_z_lognot const\n//Requires: bigInt,ml_z_normalize\nfunction ml_z_lognot(z1) {\n return ml_z_normalize(bigInt(z1).not());\n}\n\n//external shift_left: t -> int -> t\n//Provides: ml_z_shift_left const\n//Requires: bigInt, ml_z_normalize\nfunction ml_z_shift_left(z1, amt) {\n return ml_z_normalize(bigInt(z1).shiftLeft(amt));\n}\n\n//external shift_right: t -> int -> t\n//Provides: ml_z_shift_right const\n//Requires: bigInt, ml_z_normalize\nfunction ml_z_shift_right(z1, amt) {\n return ml_z_normalize(bigInt(z1).shiftRight(amt));\n}\n\n//external shift_right_trunc: t -> int -> t\n//Provides: ml_z_shift_right_trunc const\n//Requires: bigInt, ml_z_div\nfunction ml_z_shift_right_trunc(z1, z2) {\n return ml_z_div(bigInt(z1), bigInt(2).pow(z2))\n}\n\n//external of_int: int -> t\n//Provides: ml_z_of_int const\n//Requires: bigInt\nfunction ml_z_of_int(i) {\n return i | 0;\n}\n\n//external of_int32: int32 -> t\n//Provides: ml_z_of_int32 const\n//Requires: ml_z_of_int\nfunction ml_z_of_int32(i32) {\n return ml_z_of_int(i32);\n}\n\n//external of_nativeint: nativeint -> t\n//Provides: ml_z_of_nativeint const\n//Requires: ml_z_of_int\nfunction ml_z_of_nativeint(z) {\n return ml_z_of_int(z)\n}\n\n//external of_int64: int64 -> t\n//Provides: ml_z_of_int64 const\n//Requires: bigInt, caml_int64_compare, caml_int64_neg, ml_z_normalize\n//Requires: caml_int64_create_lo_hi,caml_int64_hi32,caml_int64_lo32\nfunction ml_z_of_int64(i64) {\n var neg = false;\n if(caml_int64_compare(i64, caml_int64_create_lo_hi(0,0)) < 0) {\n neg = true;\n i64 = caml_int64_neg(i64)\n }\n var lo = caml_int64_lo32(i64) >>> 0;\n var hi = caml_int64_hi32(i64) >>> 0;\n var x = bigInt(lo).add(bigInt(hi).shiftLeft(32));\n if(neg) { x = x.negate() };\n return ml_z_normalize(x)\n}\n\n//external of_float: float -> t\n//Provides: ml_z_of_float\n//Requires: bigInt, caml_raise_constant, caml_named_value, ml_z_normalize\nfunction ml_z_of_float(f1) {\n if(f1 == Infinity || f1 == -Infinity || f1 != f1)\n caml_raise_constant(caml_named_value(\"ml_z_overflow\"));\n return ml_z_normalize(bigInt(f1<0?Math.ceil(f1):Math.floor(f1)));\n}\n\n//external to_int: t -> int\n//Provides: ml_z_to_int\n//Requires: bigInt, caml_raise_constant, caml_named_value\nfunction ml_z_to_int(z1) {\n if (z1 == (z1 | 0)) return z1 | 0;\n caml_raise_constant(caml_named_value(\"ml_z_overflow\"));\n}\n\n//external to_int32: t -> int32\n//Provides: ml_z_to_int32\n//Requires: ml_z_to_int\nfunction ml_z_to_int32(z1) { return ml_z_to_int(z1) }\n\n//external to_int64: t -> int64\n//Provides: ml_z_to_int64\n//Requires: bigInt, ml_z_fits_int64, caml_raise_constant, caml_named_value\n//Requires: caml_int64_create_lo_hi\nfunction ml_z_to_int64(z1) {\n z1 = bigInt(z1)\n if(!ml_z_fits_int64(z1)) {\n caml_raise_constant(caml_named_value(\"ml_z_overflow\"));\n }\n var mask = bigInt(0xffffffff)\n var lo = z1.and(mask).toJSNumber();\n var hi = z1.shiftRight(32).and(mask).toJSNumber();\n var x = caml_int64_create_lo_hi(lo, hi);\n return x;\n}\n\n//external testbit: t -> bool\n//Provides: ml_z_testbit\n//Requires: bigInt\nfunction ml_z_testbit(z,pos){\n z = bigInt(z);\n return (z.shiftRight(pos).and(bigInt(1)).toJSNumber())|0;\n}\n\n//external to_nativeint: t -> nativeint\n//Provides: ml_z_to_nativeint\n//Requires: ml_z_to_int\nfunction ml_z_to_nativeint(z1) { return ml_z_to_int(z1) }\n\n//external format: string -> t -> string\n//Provides: ml_z_format \n//Requires: bigInt\n//Requires: caml_jsbytes_of_string, caml_failwith, caml_string_of_jsbytes, ml_z_normalize\nfunction ml_z_format(fmt, z1) {\n z1 = bigInt(z1);\n var fmt = caml_jsbytes_of_string(fmt);\n // https://github.com/ocaml/Zarith/blob/d0555d451ce295c4497f24a8d9993f8dd23097df/z.mlip#L297\n var base = 10;\n var cas = 0;\n var width = 0;\n var alt = 0;\n var dir = 0;\n var sign = '';\n var pad = ' ';\n var idx = 0;\n var prefix=\"\";\n while(fmt[idx] == '%') idx++;\n for(;; idx++) {\n if(fmt[idx] == '#') alt = 1;\n else if (fmt[idx] == '0') pad = '0';\n else if (fmt[idx] == '-') dir = 1;\n else if (fmt[idx] == ' ' || fmt[idx] == '+') sign = fmt[idx];\n else break;\n }\n if(z1.lt(bigInt(0))){sign = '-';z1 = z1.negate()};\n for(;fmt[idx]>='0' && fmt[idx] <='9';idx++)\n width=10*width + (+fmt[idx]);\n switch(fmt[idx]){\n case 'i': case 'd': case 'u': break;\n case 'b': base = 2; if(alt) prefix = \"0b\"; break;\n case 'o': base = 8; if(alt) prefix = \"0o\"; break;\n case 'x': base = 16; if(alt) prefix = \"0x\"; break;\n case 'X': base = 16; if(alt) prefix = \"0X\"; cas = 1; break;\n default:\n caml_failwith(\"Unsupported format '\" + fmt + \"'\");\n }\n if (dir) pad = ' ';\n var res = z1.toString(base);\n if (cas === 1) {\n res = res.toUpperCase();\n }\n var size = res.length;\n if (pad == ' ') {\n if(dir) {\n res = sign + prefix + res;\n for(;res.length= 48 && code <= 57) return code - 48;\n if(code >= 97 && code <= 102) return code - 97 + 10;\n if(code >= 65 && code <= 70) return code - 65 + 10;\n }\n var i = 0;\n if(s[i] == '-') i++;\n for( ; i < s.length ; i++){\n var c = digit(s.charCodeAt(i));\n if(c == undefined || c >= base)\n caml_invalid_argument(\"Z.of_substring_base: invalid digit\");\n }\n return ml_z_normalize(bigInt(s, base));\n \n}\n\n//external of_substring_base: int -> string -> pos:int -> len:int -> t\n//Provides: ml_z_of_substring_base\n//Requires: jsoo_z_of_js_string_base, caml_jsbytes_of_string, caml_invalid_argument, caml_ml_string_length\nfunction ml_z_of_substring_base(base, s, pos, len) {\n s = caml_jsbytes_of_string(s);\n if(pos != 0 || len != s.length) {\n if (s.length - pos < len) {\n caml_invalid_argument(\"Z.of_substring_base: invalid offset or length\");\n }\n s = s.slice(pos,pos+len);\n }\n return jsoo_z_of_js_string_base(base, s);\n}\n\n//external compare: t -> t -> int\n//Provides: ml_z_compare const\n//Requires: bigInt\nfunction ml_z_compare(z1, z2) {\n return bigInt(z1).compare(bigInt(z2));\n}\n\n//external equal: t -> t -> bool\n//Provides: ml_z_equal const\n//Requires: bigInt\nfunction ml_z_equal(z1, z2) {\n return bigInt(z1).equals(bigInt(z2));\n}\n\n//external sign: t -> int\n//Provides: ml_z_sign const\n//Requires: bigInt\nfunction ml_z_sign(z1) {\n return bigInt(z1).compare(bigInt.zero);\n}\n\n//external gcd: t -> t -> t\n//Provides: ml_z_gcd\n//Requires: bigInt, ml_z_normalize\nfunction ml_z_gcd(z1, z2) {\n return ml_z_normalize(bigInt.gcd(bigInt(z1), bigInt(z2)).abs());\n}\n\n//external numbits: t -> int\n//Provides: ml_z_numbits const\n//Requires: bigInt\nfunction ml_z_numbits(z1) {\n z1 = bigInt(z1).abs();\n var n = 0;\n var upperBound = bigInt.one;\n while (upperBound.leq(z1)) {\n n += 1;\n upperBound = upperBound.multiply(2);\n }\n return n; // 2^{n-1} <= |x| < 2^n\n}\n\n//external fits_int: t -> bool\n//Provides: ml_z_fits_int const\n//Requires: bigInt\nfunction ml_z_fits_int(z1) {\n if(z1 == (z1 | 0)) return 1;\n else return 0;\n}\n\n//external fits_int32: t -> bool\n//Provides: ml_z_fits_int32\n//Requires: ml_z_fits_int\nfunction ml_z_fits_int32(z1) {\n return ml_z_fits_int(z1);\n}\n\n//external fits_int64: t -> bool\n//Provides: ml_z_fits_int64\n//Requires: bigInt\nfunction ml_z_fits_int64(z1) {\n z1 = bigInt(z1)\n if (z1.compare(bigInt(\"9223372036854775807\")) <= 0 && z1.compare(bigInt(\"-9223372036854775808\")) >= 0)\n return 1\n else\n return 0\n}\n\n//external fits_nativeint: t -> bool\n//Provides: ml_z_fits_nativeint\n//Requires: ml_z_fits_int\nfunction ml_z_fits_nativeint(z1) {\n return ml_z_fits_int(z1);\n}\n\n//external powm: t -> t -> t -> t\n//Provides: ml_z_powm\n//Requires: bigInt, ml_z_normalize, ml_z_invert, caml_raise_zero_divide\nfunction ml_z_powm(z1, z2, z3) {\n var zero = bigInt(0);\n var one = bigInt(1);\n z1 = bigInt(z1);\n z2 = bigInt(z2);\n z3 = bigInt(z3);\n if(z3.equals(zero)) caml_raise_zero_divide();\n if(z3.abs().equals(one)) return 0;\n if(z2.equals(zero)) return 1;\n if(z2.lt(0)) {\n var inv = bigInt(ml_z_invert(z1, z3));\n var r = inv.modPow(z2.negate(), z3);\n if(r.lt(zero)) r = r.add(z3.abs());\n return ml_z_normalize(r);\n } else {\n var r = bigInt(z1).modPow(z2, z3);\n if(r.lt(zero)) r = r.add(z3.abs());\n return ml_z_normalize(r);\n }\n}\n\n//external pown: t -> t -> t\n//Provides: ml_z_pow\n//Requires: bigInt, caml_failwith, ml_z_normalize, caml_invalid_argument\nfunction ml_z_pow(z1, i1) {\n i1 = bigInt(i1);\n if (i1.lt(bigInt(0))) {\n caml_invalid_argument(\"Z.pow: exponent must be nonnegative\");\n }\n return ml_z_normalize(bigInt(z1).pow(i1));\n}\n\n//external hash: t -> int\n//Provides: ml_z_hash const\n//Requires: bigInt, caml_hash_mix_int\nfunction ml_z_hash(z1) {\n var a = bigInt(z1).toArray(Math.pow(2, 32));\n var acc = 0;\n for (var i = 0; i < a.value.length; i++) {\n acc = caml_hash_mix_int(acc, a.value[i]);\n }\n if(a.value.length % 2 != 0) {\n acc = caml_hash_mix_int(acc, 0);\n }\n if(a.isNegative){\n acc = acc + 1\n }\n return acc | 0\n}\n\n//external to_bits: t -> string\n//Provides: ml_z_to_bits const\n//Requires: caml_string_of_jsbytes, caml_str_repeat, bigInt\nfunction ml_z_to_bits(z1) {\n z1 = bigInt(z1).abs();\n var res = \"\";\n while(!z1.equals(bigInt(0))){\n res += String.fromCharCode(z1.mod(bigInt(256)));\n z1 = z1.divide(bigInt(256));\n }\n while(res.length % 4 != 0){\n res += String.fromCharCode(0);\n }\n return caml_string_of_jsbytes(res);\n}\n\n//external of_bits: string -> t\n//Provides: ml_z_of_bits const\n//Requires: caml_string_unsafe_get, caml_ml_string_length, bigInt, ml_z_normalize\nfunction ml_z_of_bits(z1) {\n var r = bigInt.zero\n var base1 = bigInt(256);\n var base = bigInt.one;\n for(var i = 0; i < caml_ml_string_length(z1); i++){\n var d = caml_string_unsafe_get(z1,i);\n r = bigInt(base).multiply(d).add(r);\n base = bigInt(base).multiply(base1);\n }\n return ml_z_normalize(r);\n}\n\n//external powm_sec: t -> t -> t -> t\n//Provides: ml_z_powm_sec\n//Requires: bigInt, caml_failwith, ml_z_powm, caml_invalid_argument\nfunction ml_z_powm_sec(z1, z2, z3) {\n z3 = bigInt(z3).abs();\n // powm_sec requires that the exponent be positive\n var one = bigInt(1);\n if (bigInt(z2).lt(one)) {\n caml_invalid_argument(\"Z.powm_sec: exponent must be positive\");\n }\n if (!bigInt(z3).and(one).equals(one)) {\n caml_invalid_argument(\"Z.powm_sec: modulus must be odd\");\n }\n return ml_z_powm(z1, z2, z3)\n}\n\n//external root: t -> int -> t\n//Provides: ml_z_root\n//Requires: ml_z_pow, bigInt, ml_z_normalize, caml_invalid_argument\nfunction ml_z_root(z, i) {\n var zero = bigInt(0);\n var one = bigInt(1);\n z = bigInt(z);\n\n if (i % 2 === 0 && z.lt(zero)) {\n caml_invalid_argument(\"Z.root: even root of a negative number\");\n }\n\n if (z.equals(zero) || z.equals(one)) {\n return ml_z_normalize(z);\n }\n\n var start = zero;\n var end = z;\n var ans = null;\n\n var two = bigInt(2);\n\n while (start.leq(end))\n {\n var mid = start.add(end).divide(two);\n var po = mid.pow(i);\n if (po.equals(z)) {\n return ml_z_normalize(mid);\n } else if (po.lt(z)) {\n start = mid.next();\n ans = mid;\n } else {\n end = mid.prev();\n }\n }\n return ml_z_normalize(ans);\n}\n\n//external invert: t -> t -> t\n//Provides: ml_z_invert\n//Requires: bigInt, caml_raise_zero_divide, ml_z_gcdext_intern, ml_z_normalize\nfunction ml_z_invert(a, n) {\n // Because [a.modInv(n)] produces different results for edge cases,\n // we wrote our own implementation based on gcdext_intern.\n a = bigInt(a);\n n = bigInt(n);\n var zero = bigInt(0);\n var one = bigInt(1);\n if(n.abs().equals(one))\n return 0;\n if (n.equals(zero) && a.abs().equals(one)) {\n return a;\n }\n if (n.equals(zero) || a.equals(zero)) {\n caml_raise_zero_divide();\n }\n var x = ml_z_gcdext_intern(a, n);\n var r = bigInt(x[2]);\n var tmp = bigInt(a).multiply(r).mod(n);\n if(tmp.lt(zero)) tmp = tmp.add(n.abs());\n if(r.lt(zero)) r = r.add(n.abs());\n if(tmp.equals(one)) {\n return ml_z_normalize(r);\n }\n caml_raise_zero_divide();\n}\n\n//external perfect_power: t -> bool\n//Provides: ml_z_perfect_power\n//Requires: bigInt, caml_failwith, ml_z_numbits, ml_z_root, ml_z_pow\nfunction ml_z_perfect_power(z) {\n // Return true if op is a perfect power, i.e., if there exist integers a and\n // b, with b > 1, such that op = a^b.\n // Otherwise false.\n z = bigInt(z);\n var zero = bigInt(0);\n var one = bigInt(1);\n\n if (z.equals(zero) || z.equals(one) || z.equals(one.negate())) {\n return 1;\n }\n var log2z = ml_z_numbits(z.abs());\n for (var b = 2; b <= log2z; b++) {\n if(z.lt(zero) && b % 2 == 0) continue;\n var zp = z.abs();\n var p = bigInt(ml_z_root(zp, b));\n if(z.lt(zero)) p = p.negate();\n var r = bigInt(ml_z_pow(p, b));\n if (z.equals(r)) {\n return 1;\n }\n }\n return 0;\n}\n\n//external perfect_square: t -> bool\n//Provides: ml_z_perfect_square\n//Requires: bigInt, ml_z_root\nfunction ml_z_perfect_square(z) {\n z = bigInt(z);\n if (z.lt(bigInt(0))) {\n return 0;\n }\n var root = bigInt(ml_z_root(z, 2));\n if (root.multiply(root).eq(z)) {\n return 1;\n }\n else {\n return 0\n };\n}\n\n//external probab_prime: t -> int -> int\n//Provides: ml_z_probab_prime const\n//Requires: bigInt\nfunction ml_z_probab_prime(z, i) {\n if (bigInt(z).isProbablePrime(i)) {\n return 1;\n } else {\n return 0;\n }\n}\n\n//external nextprime: t -> t\n//Provides: ml_z_nextprime const\n//Requires: bigInt, ml_z_normalize\nfunction ml_z_nextprime(z1) {\n // Interestingly, the zarith next_prime only returns \n // probabalistic primes. We do the same, with the \n // same probablistic parameter of 25.\n // https://fossies.org/dox/gmp-6.1.2/mpz_2nextprime_8c_source.html\n \n z1 = bigInt(z1)\n var one = bigInt(1);\n var two = bigInt(2);\n\n if (z1.lt(one) || z1.equals(one)) {\n return 2;\n }\n\n if (z1.and(one).equals(one)) {\n z1 = z1.add(two);\n } else {\n z1 = z1.add(one);\n }\n\n while (true) {\n if (z1.isProbablePrime(25)) {\n return ml_z_normalize(z1);\n } else {\n z1 = z1.add(two)\n }\n }\n}\n\n//external extract: t -> int -> int -> t\n//Provides: ml_z_extract\n//Requires: caml_failwith, bigInt, ml_z_normalize\nfunction ml_z_extract(z1, pos, len) {\n z1 = bigInt(z1);\n return ml_z_normalize(z1.shiftRight(pos).and(bigInt(2).pow(len).subtract(1)));\n}\n\n//external gcdext_intern: t -> t -> (t * t * bool)\n//Provides: ml_z_gcdext_intern\n//Requires: bigInt, caml_raise_zero_divide, ml_z_normalize\nfunction ml_z_gcdext_intern(z1, z2) {\n z1 = bigInt(z1);\n z2 = bigInt(z2);\n var gcd = bigInt.gcd(z1,z2);\n var a = z1;\n var b = z2;\n var x = bigInt(0);\n var lastx = bigInt(1);\n var y = bigInt(1);\n var lasty = bigInt(1);\n var q, t, r;\n if(z1.equals(bigInt(0))) {\n caml_raise_zero_divide();\n }\n while(!b.equals(bigInt(0))) {\n q = a.divide(b);\n r = a.subtract(q.multiply(b));\n t = x;\n x = lastx.subtract(q.multiply(x));\n lastx = t;\n t = y;\n y = lasty.subtract(q.multiply(y));\n lasty = t;\n a = b;\n b = r;\n }\n if(a.lt(bigInt(0)))\n return [0,ml_z_normalize(a.negate()),ml_z_normalize(lastx.negate()),1]\n else\n return [0,ml_z_normalize(a),ml_z_normalize(lastx),1]\n}\n\n//external sqrt: t -> t\n//Provides: ml_z_sqrt\n//Requires: bigInt, ml_z_root, caml_invalid_argument\nfunction ml_z_sqrt(z1) {\n var z = bigInt(z1);\n var zero = bigInt(0);\n if (z.lt(zero)) {\n caml_invalid_argument(\"Z.sqrt: square root of a negative number\");\n }\n return ml_z_root(z, 2);\n}\n\n//external sqrt_rem: t -> (t * t)\n//Provides: ml_z_sqrt_rem\n//Requires: bigInt, ml_z_root, caml_invalid_argument, ml_z_normalize\nfunction ml_z_sqrt_rem(z) {\n z = bigInt(z);\n var zero = bigInt(0);\n if (z.lt(zero)) {\n caml_invalid_argument(\"Z.sqrt_rem: square root of a negative number\");\n }\n var root = bigInt(ml_z_root(z, 2));\n var mul = root.multiply(root);\n var diff = z.subtract(mul);\n return [0, ml_z_normalize(root), ml_z_normalize(diff)]\n}\n\n//external trailing_zeros: t -> int\n//Provides: ml_z_trailing_zeros const\n//Requires: bigInt\nfunction ml_z_trailing_zeros(z) {\n z = bigInt(z).abs();\n var zero = bigInt(0);\n var one = bigInt(1);\n if (z.equals(zero)) {\n // max_int in 32bit\n return 0x7fffffff;\n }\n var i = 0\n z = z.xor(z.prev()).shiftRight(1);\n for (i = 0; !z.equals(bigInt.zero); i++) {\n z = z.shiftRight(1);\n }\n return i;\n}\n\n//external popcount: t -> int\n//Provides: ml_z_popcount\n//Requires: bigInt, caml_raise_constant, caml_named_value\nfunction ml_z_popcount(z) {\n z = bigInt(z);\n var zero = bigInt(0);\n var one = bigInt(1);\n if (z.lt(zero)) {\n caml_raise_constant(caml_named_value(\"ml_z_overflow\"));\n }\n var i;\n for (i = 0; !z.equals(zero); i++) {\n z = z.and(z.prev());\n }\n if(i != (i|0)) caml_raise_constant(caml_named_value(\"ml_z_overflow\"));\n return i|0;\n}\n\n//external hamdist: t -> t -> int\n//Provides: ml_z_hamdist\n//Requires: bigInt, ml_z_popcount, caml_invalid_argument, caml_raise_constant, caml_named_value\nfunction ml_z_hamdist(z1, z2) {\n if(bigInt(z1).isNegative() != bigInt(z2).isNegative ()){\n caml_raise_constant(caml_named_value(\"ml_z_overflow\"));\n }\n if((z1 != (z1 | 0) || z2 != (z2 | 0)) && (bigInt(z1).isNegative() || bigInt(z2).isNegative ())){\n caml_invalid_argument(\"Z.hamdist: negative arguments\");\n }\n return ml_z_popcount(bigInt(z1).xor(bigInt(z2)));\n}\n\n//external size: t -> int\n//Provides: ml_z_size const\n//Requires: bigInt\nfunction ml_z_size(z1) {\n // Claim to be a 32-bit architecture.\n return bigInt(z1).toArray(Math.pow(2, 32)).value.length;\n}\n\n//external divexact: t -> t -> t\n//Provides: ml_z_divexact\n//Requires: bigInt, ml_z_div\nfunction ml_z_divexact(z1, z2) {\n return ml_z_div(z1, z2);\n}\n\n//Provides: caml_zarith_marshal\n//Requires: bigInt\nfunction caml_zarith_marshal(writer, v, sz) {\n v = bigInt(v);\n var bits = v.toArray(Math.pow(2, 32));\n writer.write(8, bits.isNegative ?1 : 0);\n var block = bits.value.length;\n var len = block * 4;\n writer.write(32, len);\n for(var i = block - 1; i >= 0; i --){\n writer.write(8, (bits.value[i] >>> 0 ) & 0xff);\n writer.write(8, (bits.value[i] >>> 8 ) & 0xff);\n writer.write(8, (bits.value[i] >>> 16) & 0xff);\n writer.write(8, (bits.value[i] >>> 24) & 0xff);\n }\n sz[0] = 4 * (1 + (((len + 3) / 4) | 0));\n sz[1] = 8 * (1 + (((len + 7) / 8) | 0));\n}\n\n//Provides: caml_zarith_unmarshal\n//Requires: bigInt, caml_failwith, ml_z_normalize\nfunction caml_zarith_unmarshal(reader, sz) {\n var negate;\n switch(reader.read8u ()) {\n case 1: negate = true; break;\n case 0: negate = false; break;\n default: caml_failwith(\"input_value: z (malformed input)\");\n }\n var len = reader.read32u();\n var x = bigInt(0);\n for(var i = 0; i < len / 4; i++){\n var y = bigInt(reader.read8u());\n y = y.add((reader.read8u()) << 8);\n y = y.add((reader.read8u()) << 16);\n y = y.add(((reader.read8u()) << 24) >>> 0);\n x = y.shiftLeft(i * 32).add(x);\n }\n if(negate) x = x.negate();\n sz[0] = len + 4;\n return ml_z_normalize(x)\n}\n","///////// TIME_NOW\n\n//Provides: time_now_nanoseconds_since_unix_epoch_or_zero\n//Requires: caml_int64_mul, caml_int64_of_float, caml_int64_of_int32\nvar ms_to_nano = caml_int64_of_int32(1000*1000);\nfunction time_now_nanoseconds_since_unix_epoch_or_zero(){\n var ms = Date.now();\n // multiple by two - int63 integers are shifted to the left\n var ms_i63 = caml_int64_of_float(ms*2);\n return caml_int64_mul(ms_i63,ms_to_nano);\n}\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* Operations on internal representations of values *)\n\ntype t\n\ntype raw_data = nativeint\n\nexternal repr : 'a -> t = \"%identity\"\nexternal obj : t -> 'a = \"%identity\"\nexternal magic : 'a -> 'b = \"%identity\"\nexternal is_int : t -> bool = \"%obj_is_int\"\nlet [@inline always] is_block a = not (is_int a)\nexternal tag : t -> int = \"caml_obj_tag\" [@@noalloc]\nexternal set_tag : t -> int -> unit = \"caml_obj_set_tag\"\nexternal size : t -> int = \"%obj_size\"\nexternal reachable_words : t -> int = \"caml_obj_reachable_words\"\nexternal field : t -> int -> t = \"%obj_field\"\nexternal set_field : t -> int -> t -> unit = \"%obj_set_field\"\nexternal floatarray_get : floatarray -> int -> float = \"caml_floatarray_get\"\nexternal floatarray_set :\n floatarray -> int -> float -> unit = \"caml_floatarray_set\"\nlet [@inline always] double_field x i = floatarray_get (obj x : floatarray) i\nlet [@inline always] set_double_field x i v =\n floatarray_set (obj x : floatarray) i v\nexternal raw_field : t -> int -> raw_data = \"caml_obj_raw_field\"\nexternal set_raw_field : t -> int -> raw_data -> unit\n = \"caml_obj_set_raw_field\"\n\nexternal new_block : int -> int -> t = \"caml_obj_block\"\nexternal dup : t -> t = \"caml_obj_dup\"\nexternal truncate : t -> int -> unit = \"caml_obj_truncate\"\nexternal add_offset : t -> Int32.t -> t = \"caml_obj_add_offset\"\nexternal with_tag : int -> t -> t = \"caml_obj_with_tag\"\n\nlet first_non_constant_constructor_tag = 0\nlet last_non_constant_constructor_tag = 245\n\nlet lazy_tag = 246\nlet closure_tag = 247\nlet object_tag = 248\nlet infix_tag = 249\nlet forward_tag = 250\n\nlet no_scan_tag = 251\n\nlet abstract_tag = 251\nlet string_tag = 252\nlet double_tag = 253\nlet double_array_tag = 254\nlet custom_tag = 255\nlet final_tag = custom_tag\n\n\nlet int_tag = 1000\nlet out_of_heap_tag = 1001\nlet unaligned_tag = 1002\n\nmodule Closure = struct\n type info = {\n arity: int;\n start_env: int;\n }\n\n let info_of_raw (info : nativeint) =\n let open Nativeint in\n let arity =\n (* signed: negative for tupled functions *)\n if Sys.word_size = 64 then\n to_int (shift_right info 56)\n else\n to_int (shift_right info 24)\n in\n let start_env =\n (* start_env is unsigned, but we know it can always fit an OCaml\n integer so we use [to_int] instead of [unsigned_to_int]. *)\n to_int (shift_right_logical (shift_left info 8) 9) in\n { arity; start_env }\n\n (* note: we expect a closure, not an infix pointer *)\n let info (obj : t) =\n assert (tag obj = closure_tag);\n info_of_raw (raw_field obj 1)\nend\n\nmodule Extension_constructor =\nstruct\n type t = extension_constructor\n let of_val x =\n let x = repr x in\n let slot =\n if (is_block x) && (tag x) <> object_tag && (size x) >= 1 then field x 0\n else x\n in\n let name =\n if (is_block slot) && (tag slot) = object_tag then field slot 0\n else invalid_arg \"Obj.extension_constructor\"\n in\n if (tag name) = string_tag then (obj slot : t)\n else invalid_arg \"Obj.extension_constructor\"\n\n let [@inline always] name (slot : t) =\n (obj (field (repr slot) 0) : string)\n\n let [@inline always] id (slot : t) =\n (obj (field (repr slot) 1) : int)\nend\n\nlet extension_constructor = Extension_constructor.of_val\nlet extension_name = Extension_constructor.name\nlet extension_id = Extension_constructor.id\n\nmodule Ephemeron = struct\n type obj_t = t\n\n type t (** ephemeron *)\n\n (** To change in sync with weak.h *)\n let additional_values = 2\n let max_ephe_length = Sys.max_array_length - additional_values\n\n external create : int -> t = \"caml_ephe_create\";;\n let create l =\n if not (0 <= l && l <= max_ephe_length) then\n invalid_arg \"Obj.Ephemeron.create\";\n create l\n\n let length x = size(repr x) - additional_values\n\n let raise_if_invalid_offset e o msg =\n if not (0 <= o && o < length e) then\n invalid_arg msg\n\n external get_key: t -> int -> obj_t option = \"caml_ephe_get_key\"\n let get_key e o =\n raise_if_invalid_offset e o \"Obj.Ephemeron.get_key\";\n get_key e o\n\n external get_key_copy: t -> int -> obj_t option = \"caml_ephe_get_key_copy\"\n let get_key_copy e o =\n raise_if_invalid_offset e o \"Obj.Ephemeron.get_key_copy\";\n get_key_copy e o\n\n external set_key: t -> int -> obj_t -> unit = \"caml_ephe_set_key\"\n let set_key e o x =\n raise_if_invalid_offset e o \"Obj.Ephemeron.set_key\";\n set_key e o x\n\n external unset_key: t -> int -> unit = \"caml_ephe_unset_key\"\n let unset_key e o =\n raise_if_invalid_offset e o \"Obj.Ephemeron.unset_key\";\n unset_key e o\n\n external check_key: t -> int -> bool = \"caml_ephe_check_key\"\n let check_key e o =\n raise_if_invalid_offset e o \"Obj.Ephemeron.check_key\";\n check_key e o\n\n external blit_key : t -> int -> t -> int -> int -> unit\n = \"caml_ephe_blit_key\"\n\n let blit_key e1 o1 e2 o2 l =\n if l < 0 || o1 < 0 || o1 > length e1 - l\n || o2 < 0 || o2 > length e2 - l\n then invalid_arg \"Obj.Ephemeron.blit_key\"\n else if l <> 0 then blit_key e1 o1 e2 o2 l\n\n external get_data: t -> obj_t option = \"caml_ephe_get_data\"\n external get_data_copy: t -> obj_t option = \"caml_ephe_get_data_copy\"\n external set_data: t -> obj_t -> unit = \"caml_ephe_set_data\"\n external unset_data: t -> unit = \"caml_ephe_unset_data\"\n external check_data: t -> bool = \"caml_ephe_check_data\"\n external blit_data : t -> t -> unit = \"caml_ephe_blit_data\"\n\nend\n","open Core_kernel\nopen Pickles_types\n\ntype 'n t = (Int64.t, 'n) Vector.t [@@deriving sexp_of]\n\nlet to_bits t =\n Vector.to_list t\n |> List.concat_map ~f:(fun n ->\n let test_bit i = Int64.(shift_right n i land one = one) in\n List.init 64 ~f:test_bit )\n\nmodule Hex64 = struct\n module T = struct\n type t = Int64.t [@@deriving yojson]\n\n (* Modify the [of_yojson] handler to add a case for [`String].\n This isn't necessary when using Yojson's parser, because it will\n correctly infer [`Intlit] for any possible value that appears here.\n However, if this json was constructed from a GraphQL query then it will\n be encoded as a [`String] and the conversion will fail unless we handle\n it ourselves.\n *)\n let of_yojson yojson =\n match yojson with\n | `String x -> (\n try Result.Ok (Int64.of_string x)\n with _ -> Result.Error \"Constant.Make.Hex64.t\" )\n | _ ->\n of_yojson yojson\n\n include (Int64 : module type of Int64 with type t := t)\n\n let to_hex t =\n let lo = t land of_int 0xffffff in\n let mi = (t lsr 24) land of_int 0xffffff in\n let hi = (t lsr 48) land of_int 0xffff in\n sprintf \"%04x%06x%06x\" (to_int_exn hi) (to_int_exn mi) (to_int_exn lo)\n\n let of_hex h =\n let f s = Hex.of_string (\"0x\" ^ s) in\n let hi, lo = String.(f (sub h ~pos:0 ~len:8), f (sub h ~pos:8 ~len:8)) in\n (hi lsl 32) lor lo\n\n let%test_unit \"int64 hex\" =\n Quickcheck.test (Int64.gen_incl zero max_value) ~f:(fun x ->\n assert (equal x (of_hex (to_hex x))) )\n\n let sexp_of_t = Fn.compose String.sexp_of_t to_hex\n\n let t_of_sexp = Fn.compose of_hex String.t_of_sexp\n end\n\n include T\n\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n type t = (T.t[@version_asserted])\n [@@deriving compare, sexp, yojson, hash, equal]\n\n let to_latest = Fn.id\n end\n end]\nend\n\nmodule Make (N : Vector.Nat_intf) = struct\n module A = Vector.With_length (N)\n\n let length = 64 * Nat.to_int N.n\n\n type t = Hex64.t A.t [@@deriving sexp, compare, yojson, hash, equal]\n\n let to_bits = to_bits\n\n let of_bits bits =\n let pack =\n List.foldi ~init:Int64.zero ~f:(fun i acc b ->\n if b then Int64.(acc lor shift_left one i) else acc )\n in\n let bits =\n List.groupi ~break:(fun i _ _ -> i mod 64 = 0) bits |> List.map ~f:pack\n in\n let n = List.length bits in\n let n_expected = Nat.to_int N.n in\n assert (n <= n_expected) ;\n let bits = bits @ List.init (n_expected - n) ~f:(fun _ -> Int64.zero) in\n Vector.of_list_and_length_exn bits N.n\n\n let of_tick_field x =\n of_bits (List.take (Backend.Tick.Field.to_bits x) length)\n\n let of_tock_field x =\n of_bits (List.take (Backend.Tock.Field.to_bits x) length)\n\n let to_tick_field t = Backend.Tick.Field.of_bits (to_bits t)\n\n let to_tock_field t = Backend.Tock.Field.of_bits (to_bits t)\n\n let dummy : t = Vector.init N.n ~f:(fun _ -> Int64.one)\n\n let zero : t = Vector.init N.n ~f:(fun _ -> Int64.zero)\nend\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* Module [Int64]: 64-bit integers *)\n\nexternal neg : int64 -> int64 = \"%int64_neg\"\nexternal add : int64 -> int64 -> int64 = \"%int64_add\"\nexternal sub : int64 -> int64 -> int64 = \"%int64_sub\"\nexternal mul : int64 -> int64 -> int64 = \"%int64_mul\"\nexternal div : int64 -> int64 -> int64 = \"%int64_div\"\nexternal rem : int64 -> int64 -> int64 = \"%int64_mod\"\nexternal logand : int64 -> int64 -> int64 = \"%int64_and\"\nexternal logor : int64 -> int64 -> int64 = \"%int64_or\"\nexternal logxor : int64 -> int64 -> int64 = \"%int64_xor\"\nexternal shift_left : int64 -> int -> int64 = \"%int64_lsl\"\nexternal shift_right : int64 -> int -> int64 = \"%int64_asr\"\nexternal shift_right_logical : int64 -> int -> int64 = \"%int64_lsr\"\nexternal of_int : int -> int64 = \"%int64_of_int\"\nexternal to_int : int64 -> int = \"%int64_to_int\"\nexternal of_float : float -> int64\n = \"caml_int64_of_float\" \"caml_int64_of_float_unboxed\"\n [@@unboxed] [@@noalloc]\nexternal to_float : int64 -> float\n = \"caml_int64_to_float\" \"caml_int64_to_float_unboxed\"\n [@@unboxed] [@@noalloc]\nexternal of_int32 : int32 -> int64 = \"%int64_of_int32\"\nexternal to_int32 : int64 -> int32 = \"%int64_to_int32\"\nexternal of_nativeint : nativeint -> int64 = \"%int64_of_nativeint\"\nexternal to_nativeint : int64 -> nativeint = \"%int64_to_nativeint\"\n\nlet zero = 0L\nlet one = 1L\nlet minus_one = -1L\nlet succ n = add n 1L\nlet pred n = sub n 1L\nlet abs n = if n >= 0L then n else neg n\nlet min_int = 0x8000000000000000L\nlet max_int = 0x7FFFFFFFFFFFFFFFL\nlet lognot n = logxor n (-1L)\n\nlet unsigned_to_int =\n let max_int = of_int Stdlib.max_int in\n fun n ->\n if compare zero n <= 0 && compare n max_int <= 0 then\n Some (to_int n)\n else\n None\n\nexternal format : string -> int64 -> string = \"caml_int64_format\"\nlet to_string n = format \"%d\" n\n\nexternal of_string : string -> int64 = \"caml_int64_of_string\"\n\nlet of_string_opt s =\n (* TODO: expose a non-raising primitive directly. *)\n try Some (of_string s)\n with Failure _ -> None\n\n\n\nexternal bits_of_float : float -> int64\n = \"caml_int64_bits_of_float\" \"caml_int64_bits_of_float_unboxed\"\n [@@unboxed] [@@noalloc]\nexternal float_of_bits : int64 -> float\n = \"caml_int64_float_of_bits\" \"caml_int64_float_of_bits_unboxed\"\n [@@unboxed] [@@noalloc]\n\ntype t = int64\n\nlet compare (x: t) (y: t) = Stdlib.compare x y\nlet equal (x: t) (y: t) = compare x y = 0\n\nlet unsigned_compare n m =\n compare (sub n min_int) (sub m min_int)\n\nlet min x y : t = if x <= y then x else y\nlet max x y : t = if x >= y then x else y\n\n(* Unsigned division from signed division of the same\n bitness. See Warren Jr., Henry S. (2013). Hacker's Delight (2 ed.), Sec 9-3.\n*)\nlet unsigned_div n d =\n if d < zero then\n if unsigned_compare n d < 0 then zero else one\n else\n let q = shift_left (div (shift_right_logical n 1) d) 1 in\n let r = sub n (mul q d) in\n if unsigned_compare r d >= 0 then succ q else q\n\nlet unsigned_rem n d =\n sub n (mul (unsigned_div n d) d)\n","open! Import\nmodule Array = Array0\nmodule Int = Int0\nmodule Char = Char0\n\n(* Unfortunately, because the standard library does not expose\n [Caml.Random.State.default], we have to construct our own. We then build the\n [Caml.Random.int], [Caml.Random.bool] functions and friends using that default state in\n exactly the same way as the standard library.\n\n One other trickiness is that we need access to the unexposed [Caml.Random.State.assign]\n function, which accesses the unexposed state representation. So, we copy the\n [State.repr] type definition and [assign] function to here from the standard library,\n and use [Obj.magic] to get access to the underlying implementation. *)\n\n(* Regression tests ought to be deterministic because that way anyone who breaks the test\n knows that it's their code that broke the test. If tests are nondeterministic, a test\n failure may instead happen because the test runner got unlucky and uncovered an\n existing bug in the code supposedly being \"protected\" by the test in question. *)\nlet forbid_nondeterminism_in_tests ~allow_in_tests =\n if am_testing\n then (\n match allow_in_tests with\n | Some true -> ()\n | None | Some false ->\n failwith\n \"initializing Random with a nondeterministic seed is forbidden in inline tests\")\n;;\n\nexternal random_seed : unit -> int array = \"caml_sys_random_seed\"\n\nlet random_seed ?allow_in_tests () =\n forbid_nondeterminism_in_tests ~allow_in_tests;\n random_seed ()\n;;\n\nmodule State = struct\n (* We allow laziness only for the definition of [default], below, which may lazily call\n [make_self_init]. For all other purposes, we create and use [t] eagerly. *)\n type t = Caml.Random.State.t Lazy.t\n\n let bits t = Caml.Random.State.bits (Lazy.force t)\n let bool t = Caml.Random.State.bool (Lazy.force t)\n let int t x = Caml.Random.State.int (Lazy.force t) x\n let int32 t x = Caml.Random.State.int32 (Lazy.force t) x\n let int64 t x = Caml.Random.State.int64 (Lazy.force t) x\n let nativeint t x = Caml.Random.State.nativeint (Lazy.force t) x\n let make seed = Lazy.from_val (Caml.Random.State.make seed)\n let copy t = Lazy.from_val (Caml.Random.State.copy (Lazy.force t))\n let char t = int t 256 |> Char.unsafe_of_int\n let ascii t = int t 128 |> Char.unsafe_of_int\n\n let make_self_init ?allow_in_tests () =\n forbid_nondeterminism_in_tests ~allow_in_tests;\n Lazy.from_val (Caml.Random.State.make_self_init ())\n ;;\n\n module Repr = struct\n type t =\n { st : int array\n ; mutable idx : int\n }\n\n let of_state : Caml.Random.State.t -> t = Caml.Obj.magic\n end\n\n let assign t1 t2 =\n let t1 = Repr.of_state (Lazy.force t1) in\n let t2 = Repr.of_state (Lazy.force t2) in\n Array.blit ~src:t2.st ~src_pos:0 ~dst:t1.st ~dst_pos:0 ~len:(Array.length t1.st);\n t1.idx <- t2.idx\n ;;\n\n let full_init t seed = assign t (make seed)\n\n let default =\n if am_testing\n then (\n (* We define Base's default random state as a copy of OCaml's default random state.\n This means that programs that use Base.Random will see the same sequence of\n random bits as if they had used Caml.Random. However, because [get_state] returns\n a copy, Base.Random and OCaml.Random are not using the same state. If a program\n used both, each of them would go through the same sequence of random bits. To\n avoid that, we reset OCaml's random state to a different seed, giving it a\n different sequence. *)\n let t = Caml.Random.get_state () in\n Caml.Random.init 137;\n Lazy.from_val t)\n else\n lazy\n (* Outside of tests, we initialize random state nondeterministically and lazily.\n We force the random initialization to be lazy so that we do not pay any cost\n for it in programs that do not use randomness. *)\n (Lazy.force (make_self_init ()))\n ;;\n\n let int_on_64bits t bound =\n if bound <= 0x3FFFFFFF (* (1 lsl 30) - 1 *)\n then int t bound\n else Caml.Int64.to_int (int64 t (Caml.Int64.of_int bound))\n ;;\n\n let int_on_32bits t bound =\n (* Not always true with the JavaScript backend. *)\n if bound <= 0x3FFFFFFF (* (1 lsl 30) - 1 *)\n then int t bound\n else Caml.Int32.to_int (int32 t (Caml.Int32.of_int bound))\n ;;\n\n let int =\n match Word_size.word_size with\n | W64 -> int_on_64bits\n | W32 -> int_on_32bits\n ;;\n\n let full_range_int64 =\n let open Caml.Int64 in\n let bits state = of_int (bits state) in\n fun state ->\n logxor\n (bits state)\n (logxor (shift_left (bits state) 30) (shift_left (bits state) 60))\n ;;\n\n let full_range_int32 =\n let open Caml.Int32 in\n let bits state = of_int (bits state) in\n fun state -> logxor (bits state) (shift_left (bits state) 30)\n ;;\n\n let full_range_int_on_64bits state = Caml.Int64.to_int (full_range_int64 state)\n let full_range_int_on_32bits state = Caml.Int32.to_int (full_range_int32 state)\n\n let full_range_int =\n match Word_size.word_size with\n | W64 -> full_range_int_on_64bits\n | W32 -> full_range_int_on_32bits\n ;;\n\n let full_range_nativeint_on_64bits state =\n Caml.Int64.to_nativeint (full_range_int64 state)\n ;;\n\n let full_range_nativeint_on_32bits state =\n Caml.Nativeint.of_int32 (full_range_int32 state)\n ;;\n\n let full_range_nativeint =\n match Word_size.word_size with\n | W64 -> full_range_nativeint_on_64bits\n | W32 -> full_range_nativeint_on_32bits\n ;;\n\n let raise_crossed_bounds name lower_bound upper_bound string_of_bound =\n Printf.failwithf\n \"Random.%s: crossed bounds [%s > %s]\"\n name\n (string_of_bound lower_bound)\n (string_of_bound upper_bound)\n ()\n [@@cold] [@@inline never] [@@local never] [@@specialise never]\n ;;\n\n let int_incl =\n let rec in_range state lo hi =\n let int = full_range_int state in\n if int >= lo && int <= hi then int else in_range state lo hi\n in\n fun state lo hi ->\n if lo > hi then raise_crossed_bounds \"int\" lo hi Int.to_string;\n let diff = hi - lo in\n if diff = Int.max_value\n then lo + (full_range_int state land Int.max_value)\n else if diff >= 0\n then lo + int state (Int.succ diff)\n else in_range state lo hi\n ;;\n\n let int32_incl =\n let open Int32_replace_polymorphic_compare in\n let rec in_range state lo hi =\n let int = full_range_int32 state in\n if int >= lo && int <= hi then int else in_range state lo hi\n in\n let open Caml.Int32 in\n fun state lo hi ->\n if lo > hi then raise_crossed_bounds \"int32\" lo hi to_string;\n let diff = sub hi lo in\n if diff = max_int\n then add lo (logand (full_range_int32 state) max_int)\n else if diff >= 0l\n then add lo (int32 state (succ diff))\n else in_range state lo hi\n ;;\n\n let nativeint_incl =\n let open Nativeint_replace_polymorphic_compare in\n let rec in_range state lo hi =\n let int = full_range_nativeint state in\n if int >= lo && int <= hi then int else in_range state lo hi\n in\n let open Caml.Nativeint in\n fun state lo hi ->\n if lo > hi then raise_crossed_bounds \"nativeint\" lo hi to_string;\n let diff = sub hi lo in\n if diff = max_int\n then add lo (logand (full_range_nativeint state) max_int)\n else if diff >= 0n\n then add lo (nativeint state (succ diff))\n else in_range state lo hi\n ;;\n\n let int64_incl =\n let open Int64_replace_polymorphic_compare in\n let rec in_range state lo hi =\n let int = full_range_int64 state in\n if int >= lo && int <= hi then int else in_range state lo hi\n in\n let open Caml.Int64 in\n fun state lo hi ->\n if lo > hi then raise_crossed_bounds \"int64\" lo hi to_string;\n let diff = sub hi lo in\n if diff = max_int\n then add lo (logand (full_range_int64 state) max_int)\n else if diff >= 0L\n then add lo (int64 state (succ diff))\n else in_range state lo hi\n ;;\n\n (* Return a uniformly random float in [0, 1). *)\n let rec rawfloat state =\n let open Float_replace_polymorphic_compare in\n let scale = 0x1p-30 in\n (* 2^-30 *)\n let r1 = Caml.float_of_int (bits state) in\n let r2 = Caml.float_of_int (bits state) in\n let result = ((r1 *. scale) +. r2) *. scale in\n (* With very small probability, result can round up to 1.0, so in that case, we just\n try again. *)\n if result < 1.0 then result else rawfloat state\n ;;\n\n let float state hi = rawfloat state *. hi\n\n let float_range state lo hi =\n let open Float_replace_polymorphic_compare in\n if lo > hi then raise_crossed_bounds \"float\" lo hi Caml.string_of_float;\n lo +. float state (hi -. lo)\n ;;\nend\n\nlet default = State.default\nlet bits () = State.bits default\nlet int x = State.int default x\nlet int32 x = State.int32 default x\nlet nativeint x = State.nativeint default x\nlet int64 x = State.int64 default x\nlet float x = State.float default x\nlet int_incl x y = State.int_incl default x y\nlet int32_incl x y = State.int32_incl default x y\nlet nativeint_incl x y = State.nativeint_incl default x y\nlet int64_incl x y = State.int64_incl default x y\nlet float_range x y = State.float_range default x y\nlet bool () = State.bool default\nlet char () = State.char default\nlet ascii () = State.ascii default\nlet full_init seed = State.full_init default seed\nlet init seed = full_init [| seed |]\nlet self_init ?allow_in_tests () = full_init (random_seed ?allow_in_tests ())\nlet set_state s = State.assign default s\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* The run-time library for lexers generated by camllex *)\n\ntype position = {\n pos_fname : string;\n pos_lnum : int;\n pos_bol : int;\n pos_cnum : int;\n}\n\nlet dummy_pos = {\n pos_fname = \"\";\n pos_lnum = 0;\n pos_bol = 0;\n pos_cnum = -1;\n}\n\ntype lexbuf =\n { refill_buff : lexbuf -> unit;\n mutable lex_buffer : bytes;\n mutable lex_buffer_len : int;\n mutable lex_abs_pos : int;\n mutable lex_start_pos : int;\n mutable lex_curr_pos : int;\n mutable lex_last_pos : int;\n mutable lex_last_action : int;\n mutable lex_eof_reached : bool;\n mutable lex_mem : int array;\n mutable lex_start_p : position;\n mutable lex_curr_p : position;\n }\n\ntype lex_tables =\n { lex_base: string;\n lex_backtrk: string;\n lex_default: string;\n lex_trans: string;\n lex_check: string;\n lex_base_code : string;\n lex_backtrk_code : string;\n lex_default_code : string;\n lex_trans_code : string;\n lex_check_code : string;\n lex_code: string;}\n\nexternal c_engine : lex_tables -> int -> lexbuf -> int = \"caml_lex_engine\"\nexternal c_new_engine : lex_tables -> int -> lexbuf -> int\n = \"caml_new_lex_engine\"\n\nlet engine tbl state buf =\n let result = c_engine tbl state buf in\n if result >= 0 && buf.lex_curr_p != dummy_pos then begin\n buf.lex_start_p <- buf.lex_curr_p;\n buf.lex_curr_p <- {buf.lex_curr_p\n with pos_cnum = buf.lex_abs_pos + buf.lex_curr_pos};\n end;\n result\n\n\nlet new_engine tbl state buf =\n let result = c_new_engine tbl state buf in\n if result >= 0 && buf.lex_curr_p != dummy_pos then begin\n buf.lex_start_p <- buf.lex_curr_p;\n buf.lex_curr_p <- {buf.lex_curr_p\n with pos_cnum = buf.lex_abs_pos + buf.lex_curr_pos};\n end;\n result\n\nlet lex_refill read_fun aux_buffer lexbuf =\n let read =\n read_fun aux_buffer (Bytes.length aux_buffer) in\n let n =\n if read > 0\n then read\n else (lexbuf.lex_eof_reached <- true; 0) in\n (* Current state of the buffer:\n <-------|---------------------|----------->\n | junk | valid data | junk |\n ^ ^ ^ ^\n 0 start_pos buffer_end Bytes.length buffer\n *)\n if lexbuf.lex_buffer_len + n > Bytes.length lexbuf.lex_buffer then begin\n (* There is not enough space at the end of the buffer *)\n if lexbuf.lex_buffer_len - lexbuf.lex_start_pos + n\n <= Bytes.length lexbuf.lex_buffer\n then begin\n (* But there is enough space if we reclaim the junk at the beginning\n of the buffer *)\n Bytes.blit lexbuf.lex_buffer lexbuf.lex_start_pos\n lexbuf.lex_buffer 0\n (lexbuf.lex_buffer_len - lexbuf.lex_start_pos)\n end else begin\n (* We must grow the buffer. Doubling its size will provide enough\n space since n <= String.length aux_buffer <= String.length buffer.\n Watch out for string length overflow, though. *)\n let newlen =\n Int.min (2 * Bytes.length lexbuf.lex_buffer) Sys.max_string_length in\n if lexbuf.lex_buffer_len - lexbuf.lex_start_pos + n > newlen\n then failwith \"Lexing.lex_refill: cannot grow buffer\";\n let newbuf = Bytes.create newlen in\n (* Copy the valid data to the beginning of the new buffer *)\n Bytes.blit lexbuf.lex_buffer lexbuf.lex_start_pos\n newbuf 0\n (lexbuf.lex_buffer_len - lexbuf.lex_start_pos);\n lexbuf.lex_buffer <- newbuf\n end;\n (* Reallocation or not, we have shifted the data left by\n start_pos characters; update the positions *)\n let s = lexbuf.lex_start_pos in\n lexbuf.lex_abs_pos <- lexbuf.lex_abs_pos + s;\n lexbuf.lex_curr_pos <- lexbuf.lex_curr_pos - s;\n lexbuf.lex_start_pos <- 0;\n lexbuf.lex_last_pos <- lexbuf.lex_last_pos - s;\n lexbuf.lex_buffer_len <- lexbuf.lex_buffer_len - s ;\n let t = lexbuf.lex_mem in\n for i = 0 to Array.length t-1 do\n let v = t.(i) in\n if v >= 0 then\n t.(i) <- v-s\n done\n end;\n (* There is now enough space at the end of the buffer *)\n Bytes.blit aux_buffer 0 lexbuf.lex_buffer lexbuf.lex_buffer_len n;\n lexbuf.lex_buffer_len <- lexbuf.lex_buffer_len + n\n\nlet zero_pos = {\n pos_fname = \"\";\n pos_lnum = 1;\n pos_bol = 0;\n pos_cnum = 0;\n}\n\nlet from_function ?(with_positions = true) f =\n { refill_buff = lex_refill f (Bytes.create 512);\n lex_buffer = Bytes.create 1024;\n lex_buffer_len = 0;\n lex_abs_pos = 0;\n lex_start_pos = 0;\n lex_curr_pos = 0;\n lex_last_pos = 0;\n lex_last_action = 0;\n lex_mem = [||];\n lex_eof_reached = false;\n lex_start_p = if with_positions then zero_pos else dummy_pos;\n lex_curr_p = if with_positions then zero_pos else dummy_pos;\n }\n\nlet from_channel ?with_positions ic =\n from_function ?with_positions (fun buf n -> input ic buf 0 n)\n\nlet from_string ?(with_positions = true) s =\n { refill_buff = (fun lexbuf -> lexbuf.lex_eof_reached <- true);\n lex_buffer = Bytes.of_string s; (* have to make a copy for compatibility\n with unsafe-string mode *)\n lex_buffer_len = String.length s;\n lex_abs_pos = 0;\n lex_start_pos = 0;\n lex_curr_pos = 0;\n lex_last_pos = 0;\n lex_last_action = 0;\n lex_mem = [||];\n lex_eof_reached = true;\n lex_start_p = if with_positions then zero_pos else dummy_pos;\n lex_curr_p = if with_positions then zero_pos else dummy_pos;\n }\n\nlet set_position lexbuf position =\n lexbuf.lex_curr_p <- {position with pos_fname = lexbuf.lex_curr_p.pos_fname};\n lexbuf.lex_abs_pos <- position.pos_cnum\n\nlet set_filename lexbuf fname =\n lexbuf.lex_curr_p <- {lexbuf.lex_curr_p with pos_fname = fname}\n\nlet with_positions lexbuf = lexbuf.lex_curr_p != dummy_pos\n\nlet lexeme lexbuf =\n let len = lexbuf.lex_curr_pos - lexbuf.lex_start_pos in\n Bytes.sub_string lexbuf.lex_buffer lexbuf.lex_start_pos len\n\nlet sub_lexeme lexbuf i1 i2 =\n let len = i2-i1 in\n Bytes.sub_string lexbuf.lex_buffer i1 len\n\nlet sub_lexeme_opt lexbuf i1 i2 =\n if i1 >= 0 then begin\n let len = i2-i1 in\n Some (Bytes.sub_string lexbuf.lex_buffer i1 len)\n end else begin\n None\n end\n\nlet sub_lexeme_char lexbuf i = Bytes.get lexbuf.lex_buffer i\n\nlet sub_lexeme_char_opt lexbuf i =\n if i >= 0 then\n Some (Bytes.get lexbuf.lex_buffer i)\n else\n None\n\n\nlet lexeme_char lexbuf i =\n Bytes.get lexbuf.lex_buffer (lexbuf.lex_start_pos + i)\n\nlet lexeme_start lexbuf = lexbuf.lex_start_p.pos_cnum\nlet lexeme_end lexbuf = lexbuf.lex_curr_p.pos_cnum\n\nlet lexeme_start_p lexbuf = lexbuf.lex_start_p\nlet lexeme_end_p lexbuf = lexbuf.lex_curr_p\n\nlet new_line lexbuf =\n let lcp = lexbuf.lex_curr_p in\n if lcp != dummy_pos then\n lexbuf.lex_curr_p <-\n { lcp with\n pos_lnum = lcp.pos_lnum + 1;\n pos_bol = lcp.pos_cnum;\n }\n\n\n\n(* Discard data left in lexer buffer. *)\n\nlet flush_input lb =\n lb.lex_curr_pos <- 0;\n lb.lex_abs_pos <- 0;\n let lcp = lb.lex_curr_p in\n if lcp != dummy_pos then\n lb.lex_curr_p <- {zero_pos with pos_fname = lcp.pos_fname};\n lb.lex_buffer_len <- 0;\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Benoit Vaugon, ENSTA *)\n(* *)\n(* Copyright 2014 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nopen CamlinternalFormatBasics\n\n(******************************************************************************)\n (* Tools to manipulate scanning set of chars (see %[...]) *)\n\ntype mutable_char_set = bytes\n\n(* Create a fresh, empty, mutable char set. *)\nlet create_char_set () = Bytes.make 32 '\\000'\n\n(* Add a char in a mutable char set. *)\nlet add_in_char_set char_set c =\n let ind = int_of_char c in\n let str_ind = ind lsr 3 and mask = 1 lsl (ind land 0b111) in\n Bytes.set char_set str_ind\n (char_of_int (int_of_char (Bytes.get char_set str_ind) lor mask))\n\nlet freeze_char_set char_set =\n Bytes.to_string char_set\n\n(* Compute the complement of a char set. *)\nlet rev_char_set char_set =\n let char_set' = create_char_set () in\n for i = 0 to 31 do\n Bytes.set char_set' i\n (char_of_int (int_of_char (String.get char_set i) lxor 0xFF));\n done;\n Bytes.unsafe_to_string char_set'\n\n(* Return true if a `c' is in `char_set'. *)\nlet is_in_char_set char_set c =\n let ind = int_of_char c in\n let str_ind = ind lsr 3 and mask = 1 lsl (ind land 0b111) in\n (int_of_char (String.get char_set str_ind) land mask) <> 0\n\n\n(******************************************************************************)\n (* Ignored param conversion *)\n\n(* GADT used to abstract an existential type parameter. *)\n(* See param_format_of_ignored_format. *)\ntype ('a, 'b, 'c, 'd, 'e, 'f) param_format_ebb = Param_format_EBB :\n ('x -> 'a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('a, 'b, 'c, 'd, 'e, 'f) param_format_ebb\n\n(* Compute a padding associated to a pad_option (see \"%_42d\"). *)\nlet pad_of_pad_opt pad_opt = match pad_opt with\n | None -> No_padding\n | Some width -> Lit_padding (Right, width)\n\n(* Compute a precision associated to a prec_option (see \"%_.42f\"). *)\nlet prec_of_prec_opt prec_opt = match prec_opt with\n | None -> No_precision\n | Some ndec -> Lit_precision ndec\n\n(* Turn an ignored param into its equivalent not-ignored format node. *)\n(* Used for format pretty-printing and Scanf. *)\nlet param_format_of_ignored_format : type a b c d e f x y .\n (a, b, c, d, y, x) ignored -> (x, b, c, y, e, f) fmt ->\n (a, b, c, d, e, f) param_format_ebb =\nfun ign fmt -> match ign with\n | Ignored_char ->\n Param_format_EBB (Char fmt)\n | Ignored_caml_char ->\n Param_format_EBB (Caml_char fmt)\n | Ignored_string pad_opt ->\n Param_format_EBB (String (pad_of_pad_opt pad_opt, fmt))\n | Ignored_caml_string pad_opt ->\n Param_format_EBB (Caml_string (pad_of_pad_opt pad_opt, fmt))\n | Ignored_int (iconv, pad_opt) ->\n Param_format_EBB (Int (iconv, pad_of_pad_opt pad_opt, No_precision, fmt))\n | Ignored_int32 (iconv, pad_opt) ->\n Param_format_EBB\n (Int32 (iconv, pad_of_pad_opt pad_opt, No_precision, fmt))\n | Ignored_nativeint (iconv, pad_opt) ->\n Param_format_EBB\n (Nativeint (iconv, pad_of_pad_opt pad_opt, No_precision, fmt))\n | Ignored_int64 (iconv, pad_opt) ->\n Param_format_EBB\n (Int64 (iconv, pad_of_pad_opt pad_opt, No_precision, fmt))\n | Ignored_float (pad_opt, prec_opt) ->\n Param_format_EBB\n (Float ((Float_flag_, Float_f),\n pad_of_pad_opt pad_opt, prec_of_prec_opt prec_opt, fmt))\n | Ignored_bool pad_opt ->\n Param_format_EBB (Bool (pad_of_pad_opt pad_opt, fmt))\n | Ignored_format_arg (pad_opt, fmtty) ->\n Param_format_EBB (Format_arg (pad_opt, fmtty, fmt))\n | Ignored_format_subst (pad_opt, fmtty) ->\n Param_format_EBB\n (Format_subst (pad_opt, fmtty, fmt))\n | Ignored_reader ->\n Param_format_EBB (Reader fmt)\n | Ignored_scan_char_set (width_opt, char_set) ->\n Param_format_EBB (Scan_char_set (width_opt, char_set, fmt))\n | Ignored_scan_get_counter counter ->\n Param_format_EBB (Scan_get_counter (counter, fmt))\n | Ignored_scan_next_char ->\n Param_format_EBB (Scan_next_char fmt)\n\n\n(******************************************************************************)\n (* Types *)\n\ntype ('b, 'c) acc_formatting_gen =\n | Acc_open_tag of ('b, 'c) acc\n | Acc_open_box of ('b, 'c) acc\n\n(* Reversed list of printing atoms. *)\n(* Used to accumulate printf arguments. *)\nand ('b, 'c) acc =\n | Acc_formatting_lit of ('b, 'c) acc * formatting_lit\n (* Special fmtting (box) *)\n | Acc_formatting_gen of ('b, 'c) acc * ('b, 'c) acc_formatting_gen\n (* Special fmtting (box) *)\n | Acc_string_literal of ('b, 'c) acc * string (* Literal string *)\n | Acc_char_literal of ('b, 'c) acc * char (* Literal char *)\n | Acc_data_string of ('b, 'c) acc * string (* Generated string *)\n | Acc_data_char of ('b, 'c) acc * char (* Generated char *)\n | Acc_delay of ('b, 'c) acc * ('b -> 'c)\n (* Delayed printing (%a, %t) *)\n | Acc_flush of ('b, 'c) acc (* Flush *)\n | Acc_invalid_arg of ('b, 'c) acc * string\n (* Raise Invalid_argument msg *)\n | End_of_acc\n\n(* List of heterogeneous values. *)\n(* Used to accumulate scanf callback arguments. *)\ntype ('a, 'b) heter_list =\n | Cons : 'c * ('a, 'b) heter_list -> ('c -> 'a, 'b) heter_list\n | Nil : ('b, 'b) heter_list\n\n(* Existential Black Boxes. *)\n(* Used to abstract some existential type parameters. *)\n\n(* GADT type associating a padding and an fmtty. *)\n(* See the type_padding function. *)\ntype ('a, 'b, 'c, 'd, 'e, 'f) padding_fmtty_ebb = Padding_fmtty_EBB :\n ('x, 'y) padding * ('y, 'b, 'c, 'd, 'e, 'f) fmtty ->\n ('x, 'b, 'c, 'd, 'e, 'f) padding_fmtty_ebb\n\n(* GADT type associating a padding, a precision and an fmtty. *)\n(* See the type_padprec function. *)\ntype ('a, 'b, 'c, 'd, 'e, 'f) padprec_fmtty_ebb = Padprec_fmtty_EBB :\n ('x, 'y) padding * ('y, 'z) precision * ('z, 'b, 'c, 'd, 'e, 'f) fmtty ->\n ('x, 'b, 'c, 'd, 'e, 'f) padprec_fmtty_ebb\n\n(* GADT type associating a padding and an fmt. *)\n(* See make_padding_fmt_ebb and parse_format functions. *)\ntype ('a, 'b, 'c, 'e, 'f) padding_fmt_ebb = Padding_fmt_EBB :\n (_, 'x -> 'a) padding *\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('x, 'b, 'c, 'e, 'f) padding_fmt_ebb\n\n(* GADT type associating a precision and an fmt. *)\n(* See make_precision_fmt_ebb and parse_format functions. *)\ntype ('a, 'b, 'c, 'e, 'f) precision_fmt_ebb = Precision_fmt_EBB :\n (_, 'x -> 'a) precision *\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('x, 'b, 'c, 'e, 'f) precision_fmt_ebb\n\n(* GADT type associating a padding, a precision and an fmt. *)\n(* See make_padprec_fmt_ebb and parse_format functions. *)\ntype ('p, 'b, 'c, 'e, 'f) padprec_fmt_ebb = Padprec_fmt_EBB :\n ('x, 'y) padding * ('y, 'p -> 'a) precision *\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('p, 'b, 'c, 'e, 'f) padprec_fmt_ebb\n\n(* Abstract the 'a and 'd parameters of an fmt. *)\n(* Output type of the format parsing function. *)\ntype ('b, 'c, 'e, 'f) fmt_ebb = Fmt_EBB :\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('b, 'c, 'e, 'f) fmt_ebb\n\n(* GADT type associating an fmtty and an fmt. *)\n(* See the type_format_gen function. *)\ntype ('a, 'b, 'c, 'd, 'e, 'f) fmt_fmtty_ebb = Fmt_fmtty_EBB :\n ('a, 'b, 'c, 'd, 'y, 'x) fmt *\n ('x, 'b, 'c, 'y, 'e, 'f) fmtty ->\n ('a, 'b, 'c, 'd, 'e, 'f) fmt_fmtty_ebb\n\n(* GADT type associating an fmtty and an fmt. *)\n(* See the type_ignored_format_substitution function. *)\ntype ('a, 'b, 'c, 'd, 'e, 'f) fmtty_fmt_ebb = Fmtty_fmt_EBB :\n ('a, 'b, 'c, 'd, 'y, 'x) fmtty *\n ('x, 'b, 'c, 'y, 'e, 'f) fmt_fmtty_ebb ->\n ('a, 'b, 'c, 'd, 'e, 'f) fmtty_fmt_ebb\n\n(* Abstract all fmtty type parameters. *)\n(* Used to compare format types. *)\ntype fmtty_ebb = Fmtty_EBB : ('a, 'b, 'c, 'd, 'e, 'f) fmtty -> fmtty_ebb\n\n(* Abstract all padding type parameters. *)\n(* Used to compare paddings. *)\ntype padding_ebb = Padding_EBB : ('a, 'b) padding -> padding_ebb\n\n(* Abstract all precision type parameters. *)\n(* Used to compare precisions. *)\ntype precision_ebb = Precision_EBB : ('a, 'b) precision -> precision_ebb\n\n(******************************************************************************)\n (* Constants *)\n\n(* Default precision for float printing. *)\nlet default_float_precision fconv =\n match snd fconv with\n | Float_f | Float_e | Float_E | Float_g | Float_G | Float_h | Float_H\n | Float_CF -> -6\n (* For %h %H and %#F formats, a negative precision means \"as many digits as\n necessary\". For the other FP formats, we take the absolute value\n of the precision, hence 6 digits by default. *)\n | Float_F -> 12\n (* Default precision for OCaml float printing (%F). *)\n\n(******************************************************************************)\n (* Externals *)\n\nexternal format_float: string -> float -> string\n = \"caml_format_float\"\nexternal format_int: string -> int -> string\n = \"caml_format_int\"\nexternal format_int32: string -> int32 -> string\n = \"caml_int32_format\"\nexternal format_nativeint: string -> nativeint -> string\n = \"caml_nativeint_format\"\nexternal format_int64: string -> int64 -> string\n = \"caml_int64_format\"\nexternal hexstring_of_float: float -> int -> char -> string\n = \"caml_hexstring_of_float\"\n\n(******************************************************************************)\n (* Tools to pretty-print formats *)\n\n(* Type of extensible character buffers. *)\ntype buffer = {\n mutable ind : int;\n mutable bytes : bytes;\n}\n\n(* Create a fresh buffer. *)\nlet buffer_create init_size = { ind = 0; bytes = Bytes.create init_size }\n\n(* Check size of the buffer and grow it if needed. *)\nlet buffer_check_size buf overhead =\n let len = Bytes.length buf.bytes in\n let min_len = buf.ind + overhead in\n if min_len > len then (\n let new_len = Int.max (len * 2) min_len in\n let new_str = Bytes.create new_len in\n Bytes.blit buf.bytes 0 new_str 0 len;\n buf.bytes <- new_str;\n )\n\n(* Add the character `c' to the buffer `buf'. *)\nlet buffer_add_char buf c =\n buffer_check_size buf 1;\n Bytes.set buf.bytes buf.ind c;\n buf.ind <- buf.ind + 1\n\n(* Add the string `s' to the buffer `buf'. *)\nlet buffer_add_string buf s =\n let str_len = String.length s in\n buffer_check_size buf str_len;\n String.blit s 0 buf.bytes buf.ind str_len;\n buf.ind <- buf.ind + str_len\n\n(* Get the content of the buffer. *)\nlet buffer_contents buf =\n Bytes.sub_string buf.bytes 0 buf.ind\n\n(***)\n\n(* Convert an integer conversion to char. *)\nlet char_of_iconv iconv = match iconv with\n | Int_d | Int_pd | Int_sd | Int_Cd -> 'd' | Int_i | Int_pi | Int_si\n | Int_Ci -> 'i' | Int_x | Int_Cx -> 'x' | Int_X | Int_CX -> 'X' | Int_o\n | Int_Co -> 'o' | Int_u | Int_Cu -> 'u'\n\n(* Convert a float conversion to char. *)\n(* `cF' will be 'F' for displaying format and 'g' to call libc printf *)\nlet char_of_fconv ?(cF='F') fconv = match snd fconv with\n | Float_f -> 'f' | Float_e -> 'e'\n | Float_E -> 'E' | Float_g -> 'g'\n | Float_G -> 'G' | Float_F -> cF\n | Float_h -> 'h' | Float_H -> 'H'\n | Float_CF -> 'F'\n\n\n(* Convert a scanning counter to char. *)\nlet char_of_counter counter = match counter with\n | Line_counter -> 'l'\n | Char_counter -> 'n'\n | Token_counter -> 'N'\n\n(***)\n\n(* Print a char_set in a buffer with the OCaml format lexical convention. *)\nlet bprint_char_set buf char_set =\n let rec print_start set =\n let is_alone c =\n let before, after = Char.(chr (code c - 1), chr (code c + 1)) in\n is_in_char_set set c\n && not (is_in_char_set set before && is_in_char_set set after) in\n if is_alone ']' then buffer_add_char buf ']';\n print_out set 1;\n if is_alone '-' then buffer_add_char buf '-';\n and print_out set i =\n if i < 256 then\n if is_in_char_set set (char_of_int i) then print_first set i\n else print_out set (i + 1)\n and print_first set i =\n match char_of_int i with\n | '\\255' -> print_char buf 255;\n | ']' | '-' -> print_out set (i + 1);\n | _ -> print_second set (i + 1);\n and print_second set i =\n if is_in_char_set set (char_of_int i) then\n match char_of_int i with\n | '\\255' ->\n print_char buf 254;\n print_char buf 255;\n | ']' | '-' when not (is_in_char_set set (char_of_int (i + 1))) ->\n print_char buf (i - 1);\n print_out set (i + 1);\n | _ when not (is_in_char_set set (char_of_int (i + 1))) ->\n print_char buf (i - 1);\n print_char buf i;\n print_out set (i + 2);\n | _ ->\n print_in set (i - 1) (i + 2);\n else (\n print_char buf (i - 1);\n print_out set (i + 1);\n )\n and print_in set i j =\n if j = 256 || not (is_in_char_set set (char_of_int j)) then (\n print_char buf i;\n print_char buf (int_of_char '-');\n print_char buf (j - 1);\n if j < 256 then print_out set (j + 1);\n ) else\n print_in set i (j + 1);\n and print_char buf i = match char_of_int i with\n | '%' -> buffer_add_char buf '%'; buffer_add_char buf '%';\n | '@' -> buffer_add_char buf '%'; buffer_add_char buf '@';\n | c -> buffer_add_char buf c;\n in\n buffer_add_char buf '[';\n print_start (\n if is_in_char_set char_set '\\000'\n then ( buffer_add_char buf '^'; rev_char_set char_set )\n else char_set\n );\n buffer_add_char buf ']'\n\n(***)\n\n(* Print a padty in a buffer with the format-like syntax. *)\nlet bprint_padty buf padty = match padty with\n | Left -> buffer_add_char buf '-'\n | Right -> ()\n | Zeros -> buffer_add_char buf '0'\n\n(* Print the '_' of an ignored flag if needed. *)\nlet bprint_ignored_flag buf ign_flag =\n if ign_flag then buffer_add_char buf '_'\n\n(***)\n\nlet bprint_pad_opt buf pad_opt = match pad_opt with\n | None -> ()\n | Some width -> buffer_add_string buf (Int.to_string width)\n\n(***)\n\n(* Print padding in a buffer with the format-like syntax. *)\nlet bprint_padding : type a b . buffer -> (a, b) padding -> unit =\nfun buf pad -> match pad with\n | No_padding -> ()\n | Lit_padding (padty, n) ->\n bprint_padty buf padty;\n buffer_add_string buf (Int.to_string n);\n | Arg_padding padty ->\n bprint_padty buf padty;\n buffer_add_char buf '*'\n\n(* Print precision in a buffer with the format-like syntax. *)\nlet bprint_precision : type a b . buffer -> (a, b) precision -> unit =\n fun buf prec -> match prec with\n | No_precision -> ()\n | Lit_precision n ->\n buffer_add_char buf '.';\n buffer_add_string buf (Int.to_string n);\n | Arg_precision ->\n buffer_add_string buf \".*\"\n\n(***)\n\n(* Print the optional '+', ' ' or '#' associated to an int conversion. *)\nlet bprint_iconv_flag buf iconv = match iconv with\n | Int_pd | Int_pi -> buffer_add_char buf '+'\n | Int_sd | Int_si -> buffer_add_char buf ' '\n | Int_Cx | Int_CX | Int_Co | Int_Cd | Int_Ci | Int_Cu ->\n buffer_add_char buf '#'\n | Int_d | Int_i | Int_x | Int_X | Int_o | Int_u -> ()\n\n(* Print an complete int format in a buffer (ex: \"%3.*d\"). *)\nlet bprint_int_fmt buf ign_flag iconv pad prec =\n buffer_add_char buf '%';\n bprint_ignored_flag buf ign_flag;\n bprint_iconv_flag buf iconv;\n bprint_padding buf pad;\n bprint_precision buf prec;\n buffer_add_char buf (char_of_iconv iconv)\n\n(* Print a complete int32, nativeint or int64 format in a buffer. *)\nlet bprint_altint_fmt buf ign_flag iconv pad prec c =\n buffer_add_char buf '%';\n bprint_ignored_flag buf ign_flag;\n bprint_iconv_flag buf iconv;\n bprint_padding buf pad;\n bprint_precision buf prec;\n buffer_add_char buf c;\n buffer_add_char buf (char_of_iconv iconv)\n\n(***)\n\n(* Print the optional '+', ' ' and/or '#' associated to a float conversion. *)\nlet bprint_fconv_flag buf fconv =\n begin match fst fconv with\n | Float_flag_p -> buffer_add_char buf '+'\n | Float_flag_s -> buffer_add_char buf ' '\n | Float_flag_ -> () end;\n match snd fconv with\n | Float_CF -> buffer_add_char buf '#'\n | Float_f | Float_e | Float_E | Float_g | Float_G\n | Float_F | Float_h | Float_H -> ()\n\n(* Print a complete float format in a buffer (ex: \"%+*.3f\"). *)\nlet bprint_float_fmt buf ign_flag fconv pad prec =\n buffer_add_char buf '%';\n bprint_ignored_flag buf ign_flag;\n bprint_fconv_flag buf fconv;\n bprint_padding buf pad;\n bprint_precision buf prec;\n buffer_add_char buf (char_of_fconv fconv)\n\n(* Compute the literal string representation of a Formatting_lit. *)\n(* Used by Printf and Scanf where formatting is not interpreted. *)\nlet string_of_formatting_lit formatting_lit = match formatting_lit with\n | Close_box -> \"@]\"\n | Close_tag -> \"@}\"\n | Break (str, _, _) -> str\n | FFlush -> \"@?\"\n | Force_newline -> \"@\\n\"\n | Flush_newline -> \"@.\"\n | Magic_size (str, _) -> str\n | Escaped_at -> \"@@\"\n | Escaped_percent -> \"@%\"\n | Scan_indic c -> \"@\" ^ (String.make 1 c)\n\n(***)\n\n(* Print a literal char in a buffer, escape '%' by \"%%\". *)\nlet bprint_char_literal buf chr = match chr with\n | '%' -> buffer_add_string buf \"%%\"\n | _ -> buffer_add_char buf chr\n\n(* Print a literal string in a buffer, escape all '%' by \"%%\". *)\nlet bprint_string_literal buf str =\n for i = 0 to String.length str - 1 do\n bprint_char_literal buf str.[i]\n done\n\n(******************************************************************************)\n (* Format pretty-printing *)\n\n(* Print a complete format type (an fmtty) in a buffer. *)\nlet rec bprint_fmtty : type a b c d e f g h i j k l .\n buffer -> (a, b, c, d, e, f, g, h, i, j, k, l) fmtty_rel -> unit =\nfun buf fmtty -> match fmtty with\n | Char_ty rest -> buffer_add_string buf \"%c\"; bprint_fmtty buf rest;\n | String_ty rest -> buffer_add_string buf \"%s\"; bprint_fmtty buf rest;\n | Int_ty rest -> buffer_add_string buf \"%i\"; bprint_fmtty buf rest;\n | Int32_ty rest -> buffer_add_string buf \"%li\"; bprint_fmtty buf rest;\n | Nativeint_ty rest -> buffer_add_string buf \"%ni\"; bprint_fmtty buf rest;\n | Int64_ty rest -> buffer_add_string buf \"%Li\"; bprint_fmtty buf rest;\n | Float_ty rest -> buffer_add_string buf \"%f\"; bprint_fmtty buf rest;\n | Bool_ty rest -> buffer_add_string buf \"%B\"; bprint_fmtty buf rest;\n | Alpha_ty rest -> buffer_add_string buf \"%a\"; bprint_fmtty buf rest;\n | Theta_ty rest -> buffer_add_string buf \"%t\"; bprint_fmtty buf rest;\n | Any_ty rest -> buffer_add_string buf \"%?\"; bprint_fmtty buf rest;\n | Reader_ty rest -> buffer_add_string buf \"%r\"; bprint_fmtty buf rest;\n\n | Ignored_reader_ty rest ->\n buffer_add_string buf \"%_r\";\n bprint_fmtty buf rest;\n\n | Format_arg_ty (sub_fmtty, rest) ->\n buffer_add_string buf \"%{\"; bprint_fmtty buf sub_fmtty;\n buffer_add_string buf \"%}\"; bprint_fmtty buf rest;\n | Format_subst_ty (sub_fmtty, _, rest) ->\n buffer_add_string buf \"%(\"; bprint_fmtty buf sub_fmtty;\n buffer_add_string buf \"%)\"; bprint_fmtty buf rest;\n\n | End_of_fmtty -> ()\n\n(***)\n\nlet rec int_of_custom_arity : type a b c .\n (a, b, c) custom_arity -> int =\n function\n | Custom_zero -> 0\n | Custom_succ x -> 1 + int_of_custom_arity x\n\n(* Print a complete format in a buffer. *)\nlet bprint_fmt buf fmt =\n let rec fmtiter : type a b c d e f .\n (a, b, c, d, e, f) fmt -> bool -> unit =\n fun fmt ign_flag -> match fmt with\n | String (pad, rest) ->\n buffer_add_char buf '%'; bprint_ignored_flag buf ign_flag;\n bprint_padding buf pad; buffer_add_char buf 's';\n fmtiter rest false;\n | Caml_string (pad, rest) ->\n buffer_add_char buf '%'; bprint_ignored_flag buf ign_flag;\n bprint_padding buf pad; buffer_add_char buf 'S';\n fmtiter rest false;\n\n | Int (iconv, pad, prec, rest) ->\n bprint_int_fmt buf ign_flag iconv pad prec;\n fmtiter rest false;\n | Int32 (iconv, pad, prec, rest) ->\n bprint_altint_fmt buf ign_flag iconv pad prec 'l';\n fmtiter rest false;\n | Nativeint (iconv, pad, prec, rest) ->\n bprint_altint_fmt buf ign_flag iconv pad prec 'n';\n fmtiter rest false;\n | Int64 (iconv, pad, prec, rest) ->\n bprint_altint_fmt buf ign_flag iconv pad prec 'L';\n fmtiter rest false;\n | Float (fconv, pad, prec, rest) ->\n bprint_float_fmt buf ign_flag fconv pad prec;\n fmtiter rest false;\n\n | Char rest ->\n buffer_add_char buf '%'; bprint_ignored_flag buf ign_flag;\n buffer_add_char buf 'c'; fmtiter rest false;\n | Caml_char rest ->\n buffer_add_char buf '%'; bprint_ignored_flag buf ign_flag;\n buffer_add_char buf 'C'; fmtiter rest false;\n | Bool (pad, rest) ->\n buffer_add_char buf '%'; bprint_ignored_flag buf ign_flag;\n bprint_padding buf pad; buffer_add_char buf 'B';\n fmtiter rest false;\n | Alpha rest ->\n buffer_add_char buf '%'; bprint_ignored_flag buf ign_flag;\n buffer_add_char buf 'a'; fmtiter rest false;\n | Theta rest ->\n buffer_add_char buf '%'; bprint_ignored_flag buf ign_flag;\n buffer_add_char buf 't'; fmtiter rest false;\n | Custom (arity, _, rest) ->\n for _i = 1 to int_of_custom_arity arity do\n buffer_add_char buf '%'; bprint_ignored_flag buf ign_flag;\n buffer_add_char buf '?';\n done;\n fmtiter rest false;\n | Reader rest ->\n buffer_add_char buf '%'; bprint_ignored_flag buf ign_flag;\n buffer_add_char buf 'r'; fmtiter rest false;\n | Flush rest ->\n buffer_add_string buf \"%!\";\n fmtiter rest ign_flag;\n\n | String_literal (str, rest) ->\n bprint_string_literal buf str;\n fmtiter rest ign_flag;\n | Char_literal (chr, rest) ->\n bprint_char_literal buf chr;\n fmtiter rest ign_flag;\n\n | Format_arg (pad_opt, fmtty, rest) ->\n buffer_add_char buf '%'; bprint_ignored_flag buf ign_flag;\n bprint_pad_opt buf pad_opt; buffer_add_char buf '{';\n bprint_fmtty buf fmtty; buffer_add_char buf '%'; buffer_add_char buf '}';\n fmtiter rest false;\n | Format_subst (pad_opt, fmtty, rest) ->\n buffer_add_char buf '%'; bprint_ignored_flag buf ign_flag;\n bprint_pad_opt buf pad_opt; buffer_add_char buf '(';\n bprint_fmtty buf fmtty; buffer_add_char buf '%'; buffer_add_char buf ')';\n fmtiter rest false;\n\n | Scan_char_set (width_opt, char_set, rest) ->\n buffer_add_char buf '%'; bprint_ignored_flag buf ign_flag;\n bprint_pad_opt buf width_opt; bprint_char_set buf char_set;\n fmtiter rest false;\n | Scan_get_counter (counter, rest) ->\n buffer_add_char buf '%'; bprint_ignored_flag buf ign_flag;\n buffer_add_char buf (char_of_counter counter);\n fmtiter rest false;\n | Scan_next_char rest ->\n buffer_add_char buf '%'; bprint_ignored_flag buf ign_flag;\n bprint_string_literal buf \"0c\"; fmtiter rest false;\n\n | Ignored_param (ign, rest) ->\n let Param_format_EBB fmt' = param_format_of_ignored_format ign rest in\n fmtiter fmt' true;\n\n | Formatting_lit (fmting_lit, rest) ->\n bprint_string_literal buf (string_of_formatting_lit fmting_lit);\n fmtiter rest ign_flag;\n | Formatting_gen (fmting_gen, rest) ->\n begin match fmting_gen with\n | Open_tag (Format (_, str)) ->\n buffer_add_string buf \"@{\"; buffer_add_string buf str\n | Open_box (Format (_, str)) ->\n buffer_add_string buf \"@[\"; buffer_add_string buf str\n end;\n fmtiter rest ign_flag;\n\n | End_of_format -> ()\n\n in fmtiter fmt false\n\n(***)\n\n(* Convert a format to string. *)\nlet string_of_fmt fmt =\n let buf = buffer_create 16 in\n bprint_fmt buf fmt;\n buffer_contents buf\n\n(******************************************************************************)\n (* Type extraction *)\n\ntype (_, _) eq = Refl : ('a, 'a) eq\n\n(* Invariant: this function is the identity on values.\n\n In particular, if (ty1, ty2) have equal values, then\n (trans (symm ty1) ty2) respects the 'trans' precondition. *)\nlet rec symm : type a1 b1 c1 d1 e1 f1 a2 b2 c2 d2 e2 f2 .\n (a1, b1, c1, d1, e1, f1,\n a2, b2, c2, d2, e2, f2) fmtty_rel\n-> (a2, b2, c2, d2, e2, f2,\n a1, b1, c1, d1, e1, f1) fmtty_rel\n= function\n | Char_ty rest -> Char_ty (symm rest)\n | Int_ty rest -> Int_ty (symm rest)\n | Int32_ty rest -> Int32_ty (symm rest)\n | Int64_ty rest -> Int64_ty (symm rest)\n | Nativeint_ty rest -> Nativeint_ty (symm rest)\n | Float_ty rest -> Float_ty (symm rest)\n | Bool_ty rest -> Bool_ty (symm rest)\n | String_ty rest -> String_ty (symm rest)\n | Theta_ty rest -> Theta_ty (symm rest)\n | Alpha_ty rest -> Alpha_ty (symm rest)\n | Any_ty rest -> Any_ty (symm rest)\n | Reader_ty rest -> Reader_ty (symm rest)\n | Ignored_reader_ty rest -> Ignored_reader_ty (symm rest)\n | Format_arg_ty (ty, rest) ->\n Format_arg_ty (ty, symm rest)\n | Format_subst_ty (ty1, ty2, rest) ->\n Format_subst_ty (ty2, ty1, symm rest)\n | End_of_fmtty -> End_of_fmtty\n\nlet rec fmtty_rel_det : type a1 b c d1 e1 f1 a2 d2 e2 f2 .\n (a1, b, c, d1, e1, f1,\n a2, b, c, d2, e2, f2) fmtty_rel ->\n ((f1, f2) eq -> (a1, a2) eq)\n * ((a1, a2) eq -> (f1, f2) eq)\n * ((e1, e2) eq -> (d1, d2) eq)\n * ((d1, d2) eq -> (e1, e2) eq)\n= function\n | End_of_fmtty ->\n (fun Refl -> Refl),\n (fun Refl -> Refl),\n (fun Refl -> Refl),\n (fun Refl -> Refl)\n | Char_ty rest ->\n let fa, af, ed, de = fmtty_rel_det rest in\n (fun Refl -> let Refl = fa Refl in Refl),\n (fun Refl -> let Refl = af Refl in Refl),\n ed, de\n | String_ty rest ->\n let fa, af, ed, de = fmtty_rel_det rest in\n (fun Refl -> let Refl = fa Refl in Refl),\n (fun Refl -> let Refl = af Refl in Refl),\n ed, de\n | Int_ty rest ->\n let fa, af, ed, de = fmtty_rel_det rest in\n (fun Refl -> let Refl = fa Refl in Refl),\n (fun Refl -> let Refl = af Refl in Refl),\n ed, de\n | Int32_ty rest ->\n let fa, af, ed, de = fmtty_rel_det rest in\n (fun Refl -> let Refl = fa Refl in Refl),\n (fun Refl -> let Refl = af Refl in Refl),\n ed, de\n | Int64_ty rest ->\n let fa, af, ed, de = fmtty_rel_det rest in\n (fun Refl -> let Refl = fa Refl in Refl),\n (fun Refl -> let Refl = af Refl in Refl),\n ed, de\n | Nativeint_ty rest ->\n let fa, af, ed, de = fmtty_rel_det rest in\n (fun Refl -> let Refl = fa Refl in Refl),\n (fun Refl -> let Refl = af Refl in Refl),\n ed, de\n | Float_ty rest ->\n let fa, af, ed, de = fmtty_rel_det rest in\n (fun Refl -> let Refl = fa Refl in Refl),\n (fun Refl -> let Refl = af Refl in Refl),\n ed, de\n | Bool_ty rest ->\n let fa, af, ed, de = fmtty_rel_det rest in\n (fun Refl -> let Refl = fa Refl in Refl),\n (fun Refl -> let Refl = af Refl in Refl),\n ed, de\n\n | Theta_ty rest ->\n let fa, af, ed, de = fmtty_rel_det rest in\n (fun Refl -> let Refl = fa Refl in Refl),\n (fun Refl -> let Refl = af Refl in Refl),\n ed, de\n | Alpha_ty rest ->\n let fa, af, ed, de = fmtty_rel_det rest in\n (fun Refl -> let Refl = fa Refl in Refl),\n (fun Refl -> let Refl = af Refl in Refl),\n ed, de\n | Any_ty rest ->\n let fa, af, ed, de = fmtty_rel_det rest in\n (fun Refl -> let Refl = fa Refl in Refl),\n (fun Refl -> let Refl = af Refl in Refl),\n ed, de\n | Reader_ty rest ->\n let fa, af, ed, de = fmtty_rel_det rest in\n (fun Refl -> let Refl = fa Refl in Refl),\n (fun Refl -> let Refl = af Refl in Refl),\n (fun Refl -> let Refl = ed Refl in Refl),\n (fun Refl -> let Refl = de Refl in Refl)\n | Ignored_reader_ty rest ->\n let fa, af, ed, de = fmtty_rel_det rest in\n (fun Refl -> let Refl = fa Refl in Refl),\n (fun Refl -> let Refl = af Refl in Refl),\n (fun Refl -> let Refl = ed Refl in Refl),\n (fun Refl -> let Refl = de Refl in Refl)\n | Format_arg_ty (_ty, rest) ->\n let fa, af, ed, de = fmtty_rel_det rest in\n (fun Refl -> let Refl = fa Refl in Refl),\n (fun Refl -> let Refl = af Refl in Refl),\n ed, de\n | Format_subst_ty (ty1, ty2, rest) ->\n let fa, af, ed, de = fmtty_rel_det rest in\n let ty = trans (symm ty1) ty2 in\n let ag, ga, dj, jd = fmtty_rel_det ty in\n (fun Refl -> let Refl = fa Refl in let Refl = ag Refl in Refl),\n (fun Refl -> let Refl = ga Refl in let Refl = af Refl in Refl),\n (fun Refl -> let Refl = ed Refl in let Refl = dj Refl in Refl),\n (fun Refl -> let Refl = jd Refl in let Refl = de Refl in Refl)\n\n(* Precondition: we assume that the two fmtty_rel arguments have equal\n values (at possibly distinct types); this invariant comes from the way\n fmtty_rel witnesses are produced by the type-checker\n\n The code below uses (assert false) when this assumption is broken. The\n code pattern is the following:\n\n | Foo x, Foo y ->\n (* case where indeed both values\n start with constructor Foo *)\n | Foo _, _\n | _, Foo _ ->\n (* different head constructors: broken precondition *)\n assert false\n*)\nand trans : type\n a1 b1 c1 d1 e1 f1\n a2 b2 c2 d2 e2 f2\n a3 b3 c3 d3 e3 f3\n.\n (a1, b1, c1, d1, e1, f1,\n a2, b2, c2, d2, e2, f2) fmtty_rel\n-> (a2, b2, c2, d2, e2, f2,\n a3, b3, c3, d3, e3, f3) fmtty_rel\n-> (a1, b1, c1, d1, e1, f1,\n a3, b3, c3, d3, e3, f3) fmtty_rel\n= fun ty1 ty2 -> match ty1, ty2 with\n | Char_ty rest1, Char_ty rest2 -> Char_ty (trans rest1 rest2)\n | String_ty rest1, String_ty rest2 -> String_ty (trans rest1 rest2)\n | Bool_ty rest1, Bool_ty rest2 -> Bool_ty (trans rest1 rest2)\n | Int_ty rest1, Int_ty rest2 -> Int_ty (trans rest1 rest2)\n | Int32_ty rest1, Int32_ty rest2 -> Int32_ty (trans rest1 rest2)\n | Int64_ty rest1, Int64_ty rest2 -> Int64_ty (trans rest1 rest2)\n | Nativeint_ty rest1, Nativeint_ty rest2 -> Nativeint_ty (trans rest1 rest2)\n | Float_ty rest1, Float_ty rest2 -> Float_ty (trans rest1 rest2)\n\n | Alpha_ty rest1, Alpha_ty rest2 -> Alpha_ty (trans rest1 rest2)\n | Alpha_ty _, _ -> assert false\n | _, Alpha_ty _ -> assert false\n\n | Theta_ty rest1, Theta_ty rest2 -> Theta_ty (trans rest1 rest2)\n | Theta_ty _, _ -> assert false\n | _, Theta_ty _ -> assert false\n\n | Any_ty rest1, Any_ty rest2 -> Any_ty (trans rest1 rest2)\n | Any_ty _, _ -> assert false\n | _, Any_ty _ -> assert false\n\n | Reader_ty rest1, Reader_ty rest2 -> Reader_ty (trans rest1 rest2)\n | Reader_ty _, _ -> assert false\n | _, Reader_ty _ -> assert false\n\n | Ignored_reader_ty rest1, Ignored_reader_ty rest2 ->\n Ignored_reader_ty (trans rest1 rest2)\n | Ignored_reader_ty _, _ -> assert false\n | _, Ignored_reader_ty _ -> assert false\n\n | Format_arg_ty (ty1, rest1), Format_arg_ty (ty2, rest2) ->\n Format_arg_ty (trans ty1 ty2, trans rest1 rest2)\n | Format_arg_ty _, _ -> assert false\n | _, Format_arg_ty _ -> assert false\n\n | Format_subst_ty (ty11, ty12, rest1),\n Format_subst_ty (ty21, ty22, rest2) ->\n let ty = trans (symm ty12) ty21 in\n let _, f2, _, f4 = fmtty_rel_det ty in\n let Refl = f2 Refl in\n let Refl = f4 Refl in\n Format_subst_ty (ty11, ty22, trans rest1 rest2)\n | Format_subst_ty _, _ -> assert false\n | _, Format_subst_ty _ -> assert false\n\n | End_of_fmtty, End_of_fmtty -> End_of_fmtty\n | End_of_fmtty, _ -> assert false\n | _, End_of_fmtty -> assert false\n\nlet rec fmtty_of_formatting_gen : type a b c d e f .\n (a, b, c, d, e, f) formatting_gen ->\n (a, b, c, d, e, f) fmtty =\nfun formatting_gen -> match formatting_gen with\n | Open_tag (Format (fmt, _)) -> fmtty_of_fmt fmt\n | Open_box (Format (fmt, _)) -> fmtty_of_fmt fmt\n\n(* Extract the type representation (an fmtty) of a format. *)\nand fmtty_of_fmt : type a b c d e f .\n (a, b, c, d, e, f) fmt -> (a, b, c, d, e, f) fmtty =\nfun fmtty -> match fmtty with\n | String (pad, rest) ->\n fmtty_of_padding_fmtty pad (String_ty (fmtty_of_fmt rest))\n | Caml_string (pad, rest) ->\n fmtty_of_padding_fmtty pad (String_ty (fmtty_of_fmt rest))\n\n | Int (_, pad, prec, rest) ->\n let ty_rest = fmtty_of_fmt rest in\n let prec_ty = fmtty_of_precision_fmtty prec (Int_ty ty_rest) in\n fmtty_of_padding_fmtty pad prec_ty\n | Int32 (_, pad, prec, rest) ->\n let ty_rest = fmtty_of_fmt rest in\n let prec_ty = fmtty_of_precision_fmtty prec (Int32_ty ty_rest) in\n fmtty_of_padding_fmtty pad prec_ty\n | Nativeint (_, pad, prec, rest) ->\n let ty_rest = fmtty_of_fmt rest in\n let prec_ty = fmtty_of_precision_fmtty prec (Nativeint_ty ty_rest) in\n fmtty_of_padding_fmtty pad prec_ty\n | Int64 (_, pad, prec, rest) ->\n let ty_rest = fmtty_of_fmt rest in\n let prec_ty = fmtty_of_precision_fmtty prec (Int64_ty ty_rest) in\n fmtty_of_padding_fmtty pad prec_ty\n | Float (_, pad, prec, rest) ->\n let ty_rest = fmtty_of_fmt rest in\n let prec_ty = fmtty_of_precision_fmtty prec (Float_ty ty_rest) in\n fmtty_of_padding_fmtty pad prec_ty\n\n | Char rest -> Char_ty (fmtty_of_fmt rest)\n | Caml_char rest -> Char_ty (fmtty_of_fmt rest)\n | Bool (pad, rest) ->\n fmtty_of_padding_fmtty pad (Bool_ty (fmtty_of_fmt rest))\n | Alpha rest -> Alpha_ty (fmtty_of_fmt rest)\n | Theta rest -> Theta_ty (fmtty_of_fmt rest)\n | Custom (arity, _, rest) -> fmtty_of_custom arity (fmtty_of_fmt rest)\n | Reader rest -> Reader_ty (fmtty_of_fmt rest)\n\n | Format_arg (_, ty, rest) ->\n Format_arg_ty (ty, fmtty_of_fmt rest)\n | Format_subst (_, ty, rest) ->\n Format_subst_ty (ty, ty, fmtty_of_fmt rest)\n\n | Flush rest -> fmtty_of_fmt rest\n | String_literal (_, rest) -> fmtty_of_fmt rest\n | Char_literal (_, rest) -> fmtty_of_fmt rest\n\n | Scan_char_set (_, _, rest) -> String_ty (fmtty_of_fmt rest)\n | Scan_get_counter (_, rest) -> Int_ty (fmtty_of_fmt rest)\n | Scan_next_char rest -> Char_ty (fmtty_of_fmt rest)\n | Ignored_param (ign, rest) -> fmtty_of_ignored_format ign rest\n | Formatting_lit (_, rest) -> fmtty_of_fmt rest\n | Formatting_gen (fmting_gen, rest) ->\n concat_fmtty (fmtty_of_formatting_gen fmting_gen) (fmtty_of_fmt rest)\n\n | End_of_format -> End_of_fmtty\n\nand fmtty_of_custom : type x y a b c d e f .\n (a, x, y) custom_arity -> (a, b, c, d, e, f) fmtty ->\n (y, b, c, d, e, f) fmtty =\nfun arity fmtty -> match arity with\n | Custom_zero -> fmtty\n | Custom_succ arity -> Any_ty (fmtty_of_custom arity fmtty)\n\n(* Extract the fmtty of an ignored parameter followed by the rest of\n the format. *)\nand fmtty_of_ignored_format : type x y a b c d e f .\n (a, b, c, d, y, x) ignored ->\n (x, b, c, y, e, f) fmt ->\n (a, b, c, d, e, f) fmtty =\nfun ign fmt -> match ign with\n | Ignored_char -> fmtty_of_fmt fmt\n | Ignored_caml_char -> fmtty_of_fmt fmt\n | Ignored_string _ -> fmtty_of_fmt fmt\n | Ignored_caml_string _ -> fmtty_of_fmt fmt\n | Ignored_int (_, _) -> fmtty_of_fmt fmt\n | Ignored_int32 (_, _) -> fmtty_of_fmt fmt\n | Ignored_nativeint (_, _) -> fmtty_of_fmt fmt\n | Ignored_int64 (_, _) -> fmtty_of_fmt fmt\n | Ignored_float (_, _) -> fmtty_of_fmt fmt\n | Ignored_bool _ -> fmtty_of_fmt fmt\n | Ignored_format_arg _ -> fmtty_of_fmt fmt\n | Ignored_format_subst (_, fmtty) -> concat_fmtty fmtty (fmtty_of_fmt fmt)\n | Ignored_reader -> Ignored_reader_ty (fmtty_of_fmt fmt)\n | Ignored_scan_char_set _ -> fmtty_of_fmt fmt\n | Ignored_scan_get_counter _ -> fmtty_of_fmt fmt\n | Ignored_scan_next_char -> fmtty_of_fmt fmt\n\n(* Add an Int_ty node if padding is taken as an extra argument (ex: \"%*s\"). *)\nand fmtty_of_padding_fmtty : type x a b c d e f .\n (x, a) padding -> (a, b, c, d, e, f) fmtty -> (x, b, c, d, e, f) fmtty =\n fun pad fmtty -> match pad with\n | No_padding -> fmtty\n | Lit_padding _ -> fmtty\n | Arg_padding _ -> Int_ty fmtty\n\n(* Add an Int_ty node if precision is taken as an extra argument (ex: \"%.*f\").*)\nand fmtty_of_precision_fmtty : type x a b c d e f .\n (x, a) precision -> (a, b, c, d, e, f) fmtty -> (x, b, c, d, e, f) fmtty =\n fun prec fmtty -> match prec with\n | No_precision -> fmtty\n | Lit_precision _ -> fmtty\n | Arg_precision -> Int_ty fmtty\n\n(******************************************************************************)\n (* Format typing *)\n\n(* Exception raised when a format does not match a given format type. *)\nexception Type_mismatch\n\n(* Type a padding. *)\n(* Take an Int_ty from the fmtty if the integer should be kept as argument. *)\n(* Raise Type_mismatch in case of type mismatch. *)\nlet type_padding : type a b c d e f x y .\n (x, y) padding -> (a, b, c, d, e, f) fmtty ->\n (a, b, c, d, e, f) padding_fmtty_ebb =\nfun pad fmtty -> match pad, fmtty with\n | No_padding, _ -> Padding_fmtty_EBB (No_padding, fmtty)\n | Lit_padding (padty, w), _ -> Padding_fmtty_EBB (Lit_padding (padty,w),fmtty)\n | Arg_padding padty, Int_ty rest -> Padding_fmtty_EBB (Arg_padding padty,rest)\n | _ -> raise Type_mismatch\n\n(* Convert a (upadding, uprecision) to a (padding, precision). *)\n(* Take one or two Int_ty from the fmtty if needed. *)\n(* Raise Type_mismatch in case of type mismatch. *)\nlet type_padprec : type a b c d e f x y z .\n (x, y) padding -> (y, z) precision -> (a, b, c, d, e, f) fmtty ->\n (a, b, c, d, e, f) padprec_fmtty_ebb =\nfun pad prec fmtty -> match prec, type_padding pad fmtty with\n | No_precision, Padding_fmtty_EBB (pad, rest) ->\n Padprec_fmtty_EBB (pad, No_precision, rest)\n | Lit_precision p, Padding_fmtty_EBB (pad, rest) ->\n Padprec_fmtty_EBB (pad, Lit_precision p, rest)\n | Arg_precision, Padding_fmtty_EBB (pad, Int_ty rest) ->\n Padprec_fmtty_EBB (pad, Arg_precision, rest)\n | _, Padding_fmtty_EBB (_, _) -> raise Type_mismatch\n\n(* Type a format according to an fmtty. *)\n(* If typing succeed, generate a copy of the format with the same\n type parameters as the fmtty. *)\n(* Raise [Failure] with an error message in case of type mismatch. *)\nlet rec type_format :\n type a1 b1 c1 d1 e1 f1\n a2 b2 c2 d2 e2 f2 .\n (a1, b1, c1, d1, e1, f1) fmt\n -> (a2, b2, c2, d2, e2, f2) fmtty\n -> (a2, b2, c2, d2, e2, f2) fmt\n= fun fmt fmtty -> match type_format_gen fmt fmtty with\n | Fmt_fmtty_EBB (fmt', End_of_fmtty) -> fmt'\n | _ -> raise Type_mismatch\n\nand type_format_gen :\n type a1 b1 c1 d1 e1 f1\n a2 b2 c2 d2 e2 f2 .\n (a1, b1, c1, d1, e1, f1) fmt\n -> (a2, b2, c2, d2, e2, f2) fmtty\n -> (a2, b2, c2, d2, e2, f2) fmt_fmtty_ebb\n= fun fmt fmtty -> match fmt, fmtty with\n | Char fmt_rest, Char_ty fmtty_rest ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (Char fmt', fmtty')\n | Caml_char fmt_rest, Char_ty fmtty_rest ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (Caml_char fmt', fmtty')\n | String (pad, fmt_rest), _ -> (\n match type_padding pad fmtty with\n | Padding_fmtty_EBB (pad, String_ty fmtty_rest) ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (String (pad, fmt'), fmtty')\n | Padding_fmtty_EBB (_, _) -> raise Type_mismatch\n )\n | Caml_string (pad, fmt_rest), _ -> (\n match type_padding pad fmtty with\n | Padding_fmtty_EBB (pad, String_ty fmtty_rest) ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (Caml_string (pad, fmt'), fmtty')\n | Padding_fmtty_EBB (_, _) -> raise Type_mismatch\n )\n | Int (iconv, pad, prec, fmt_rest), _ -> (\n match type_padprec pad prec fmtty with\n | Padprec_fmtty_EBB (pad, prec, Int_ty fmtty_rest) ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (Int (iconv, pad, prec, fmt'), fmtty')\n | Padprec_fmtty_EBB (_, _, _) -> raise Type_mismatch\n )\n | Int32 (iconv, pad, prec, fmt_rest), _ -> (\n match type_padprec pad prec fmtty with\n | Padprec_fmtty_EBB (pad, prec, Int32_ty fmtty_rest) ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (Int32 (iconv, pad, prec, fmt'), fmtty')\n | Padprec_fmtty_EBB (_, _, _) -> raise Type_mismatch\n )\n | Nativeint (iconv, pad, prec, fmt_rest), _ -> (\n match type_padprec pad prec fmtty with\n | Padprec_fmtty_EBB (pad, prec, Nativeint_ty fmtty_rest) ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (Nativeint (iconv, pad, prec, fmt'), fmtty')\n | Padprec_fmtty_EBB (_, _, _) -> raise Type_mismatch\n )\n | Int64 (iconv, pad, prec, fmt_rest), _ -> (\n match type_padprec pad prec fmtty with\n | Padprec_fmtty_EBB (pad, prec, Int64_ty fmtty_rest) ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (Int64 (iconv, pad, prec, fmt'), fmtty')\n | Padprec_fmtty_EBB (_, _, _) -> raise Type_mismatch\n )\n | Float (fconv, pad, prec, fmt_rest), _ -> (\n match type_padprec pad prec fmtty with\n | Padprec_fmtty_EBB (pad, prec, Float_ty fmtty_rest) ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (Float (fconv, pad, prec, fmt'), fmtty')\n | Padprec_fmtty_EBB (_, _, _) -> raise Type_mismatch\n )\n | Bool (pad, fmt_rest), _ -> (\n match type_padding pad fmtty with\n | Padding_fmtty_EBB (pad, Bool_ty fmtty_rest) ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (Bool (pad, fmt'), fmtty')\n | Padding_fmtty_EBB (_, _) -> raise Type_mismatch\n )\n | Flush fmt_rest, fmtty_rest ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (Flush fmt', fmtty')\n\n | String_literal (str, fmt_rest), fmtty_rest ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (String_literal (str, fmt'), fmtty')\n | Char_literal (chr, fmt_rest), fmtty_rest ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (Char_literal (chr, fmt'), fmtty')\n\n | Format_arg (pad_opt, sub_fmtty, fmt_rest),\n Format_arg_ty (sub_fmtty', fmtty_rest) ->\n if Fmtty_EBB sub_fmtty <> Fmtty_EBB sub_fmtty' then raise Type_mismatch;\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (Format_arg (pad_opt, sub_fmtty', fmt'), fmtty')\n | Format_subst (pad_opt, sub_fmtty, fmt_rest),\n Format_subst_ty (sub_fmtty1, _sub_fmtty2, fmtty_rest) ->\n if Fmtty_EBB (erase_rel sub_fmtty) <> Fmtty_EBB (erase_rel sub_fmtty1) then\n raise Type_mismatch;\n let Fmt_fmtty_EBB (fmt', fmtty') =\n type_format_gen fmt_rest (erase_rel fmtty_rest)\n in\n Fmt_fmtty_EBB (Format_subst (pad_opt, sub_fmtty1, fmt'), fmtty')\n (* Printf and Format specific constructors: *)\n | Alpha fmt_rest, Alpha_ty fmtty_rest ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (Alpha fmt', fmtty')\n | Theta fmt_rest, Theta_ty fmtty_rest ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (Theta fmt', fmtty')\n\n (* Format specific constructors: *)\n | Formatting_lit (formatting_lit, fmt_rest), fmtty_rest ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (Formatting_lit (formatting_lit, fmt'), fmtty')\n | Formatting_gen (formatting_gen, fmt_rest), fmtty_rest ->\n type_formatting_gen formatting_gen fmt_rest fmtty_rest\n\n (* Scanf specific constructors: *)\n | Reader fmt_rest, Reader_ty fmtty_rest ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (Reader fmt', fmtty')\n | Scan_char_set (width_opt, char_set, fmt_rest), String_ty fmtty_rest ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (Scan_char_set (width_opt, char_set, fmt'), fmtty')\n | Scan_get_counter (counter, fmt_rest), Int_ty fmtty_rest ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (Scan_get_counter (counter, fmt'), fmtty')\n | Ignored_param (ign, rest), fmtty_rest ->\n type_ignored_param ign rest fmtty_rest\n\n | End_of_format, fmtty_rest -> Fmt_fmtty_EBB (End_of_format, fmtty_rest)\n\n | _ -> raise Type_mismatch\n\nand type_formatting_gen : type a1 a3 b1 b3 c1 c3 d1 d3 e1 e2 e3 f1 f2 f3 .\n (a1, b1, c1, d1, e1, f1) formatting_gen ->\n (f1, b1, c1, e1, e2, f2) fmt ->\n (a3, b3, c3, d3, e3, f3) fmtty ->\n (a3, b3, c3, d3, e3, f3) fmt_fmtty_ebb =\nfun formatting_gen fmt0 fmtty0 -> match formatting_gen with\n | Open_tag (Format (fmt1, str)) ->\n let Fmt_fmtty_EBB (fmt2, fmtty2) = type_format_gen fmt1 fmtty0 in\n let Fmt_fmtty_EBB (fmt3, fmtty3) = type_format_gen fmt0 fmtty2 in\n Fmt_fmtty_EBB (Formatting_gen (Open_tag (Format (fmt2, str)), fmt3), fmtty3)\n | Open_box (Format (fmt1, str)) ->\n let Fmt_fmtty_EBB (fmt2, fmtty2) = type_format_gen fmt1 fmtty0 in\n let Fmt_fmtty_EBB (fmt3, fmtty3) = type_format_gen fmt0 fmtty2 in\n Fmt_fmtty_EBB (Formatting_gen (Open_box (Format (fmt2, str)), fmt3), fmtty3)\n\n(* Type an Ignored_param node according to an fmtty. *)\nand type_ignored_param : type p q x y z t u v a b c d e f .\n (x, y, z, t, q, p) ignored ->\n (p, y, z, q, u, v) fmt ->\n (a, b, c, d, e, f) fmtty ->\n (a, b, c, d, e, f) fmt_fmtty_ebb =\nfun ign fmt fmtty -> match ign with\n | Ignored_char as ign' -> type_ignored_param_one ign' fmt fmtty\n | Ignored_caml_char as ign' -> type_ignored_param_one ign' fmt fmtty\n | Ignored_string _ as ign' -> type_ignored_param_one ign' fmt fmtty\n | Ignored_caml_string _ as ign' -> type_ignored_param_one ign' fmt fmtty\n | Ignored_int _ as ign' -> type_ignored_param_one ign' fmt fmtty\n | Ignored_int32 _ as ign' -> type_ignored_param_one ign' fmt fmtty\n | Ignored_nativeint _ as ign' -> type_ignored_param_one ign' fmt fmtty\n | Ignored_int64 _ as ign' -> type_ignored_param_one ign' fmt fmtty\n | Ignored_float _ as ign' -> type_ignored_param_one ign' fmt fmtty\n | Ignored_bool _ as ign' -> type_ignored_param_one ign' fmt fmtty\n | Ignored_scan_char_set _ as ign' -> type_ignored_param_one ign' fmt fmtty\n | Ignored_scan_get_counter _ as ign' -> type_ignored_param_one ign' fmt fmtty\n | Ignored_scan_next_char as ign' -> type_ignored_param_one ign' fmt fmtty\n | Ignored_format_arg (pad_opt, sub_fmtty) ->\n type_ignored_param_one (Ignored_format_arg (pad_opt, sub_fmtty)) fmt fmtty\n | Ignored_format_subst (pad_opt, sub_fmtty) ->\n let Fmtty_fmt_EBB (sub_fmtty', Fmt_fmtty_EBB (fmt', fmtty')) =\n type_ignored_format_substitution sub_fmtty fmt fmtty in\n Fmt_fmtty_EBB (Ignored_param (Ignored_format_subst (pad_opt, sub_fmtty'),\n fmt'),\n fmtty')\n | Ignored_reader -> (\n match fmtty with\n | Ignored_reader_ty fmtty_rest ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt fmtty_rest in\n Fmt_fmtty_EBB (Ignored_param (Ignored_reader, fmt'), fmtty')\n | _ -> raise Type_mismatch\n )\n\nand type_ignored_param_one : type a1 a2 b1 b2 c1 c2 d1 d2 e1 e2 f1 f2 .\n (a2, b2, c2, d2, d2, a2) ignored ->\n (a1, b1, c1, d1, e1, f1) fmt ->\n (a2, b2, c2, d2, e2, f2) fmtty ->\n (a2, b2, c2, d2, e2, f2) fmt_fmtty_ebb\n= fun ign fmt fmtty ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt fmtty in\n Fmt_fmtty_EBB (Ignored_param (ign, fmt'), fmtty')\n\n(* Typing of the complex case: \"%_(...%)\". *)\nand type_ignored_format_substitution : type w x y z p s t u a b c d e f .\n (w, x, y, z, s, p) fmtty ->\n (p, x, y, s, t, u) fmt ->\n (a, b, c, d, e, f) fmtty -> (a, b, c, d, e, f) fmtty_fmt_ebb =\nfun sub_fmtty fmt fmtty -> match sub_fmtty, fmtty with\n | Char_ty sub_fmtty_rest, Char_ty fmtty_rest ->\n let Fmtty_fmt_EBB (sub_fmtty_rest', fmt') =\n type_ignored_format_substitution sub_fmtty_rest fmt fmtty_rest in\n Fmtty_fmt_EBB (Char_ty sub_fmtty_rest', fmt')\n | String_ty sub_fmtty_rest, String_ty fmtty_rest ->\n let Fmtty_fmt_EBB (sub_fmtty_rest', fmt') =\n type_ignored_format_substitution sub_fmtty_rest fmt fmtty_rest in\n Fmtty_fmt_EBB (String_ty sub_fmtty_rest', fmt')\n | Int_ty sub_fmtty_rest, Int_ty fmtty_rest ->\n let Fmtty_fmt_EBB (sub_fmtty_rest', fmt') =\n type_ignored_format_substitution sub_fmtty_rest fmt fmtty_rest in\n Fmtty_fmt_EBB (Int_ty sub_fmtty_rest', fmt')\n | Int32_ty sub_fmtty_rest, Int32_ty fmtty_rest ->\n let Fmtty_fmt_EBB (sub_fmtty_rest', fmt') =\n type_ignored_format_substitution sub_fmtty_rest fmt fmtty_rest in\n Fmtty_fmt_EBB (Int32_ty sub_fmtty_rest', fmt')\n | Nativeint_ty sub_fmtty_rest, Nativeint_ty fmtty_rest ->\n let Fmtty_fmt_EBB (sub_fmtty_rest', fmt') =\n type_ignored_format_substitution sub_fmtty_rest fmt fmtty_rest in\n Fmtty_fmt_EBB (Nativeint_ty sub_fmtty_rest', fmt')\n | Int64_ty sub_fmtty_rest, Int64_ty fmtty_rest ->\n let Fmtty_fmt_EBB (sub_fmtty_rest', fmt') =\n type_ignored_format_substitution sub_fmtty_rest fmt fmtty_rest in\n Fmtty_fmt_EBB (Int64_ty sub_fmtty_rest', fmt')\n | Float_ty sub_fmtty_rest, Float_ty fmtty_rest ->\n let Fmtty_fmt_EBB (sub_fmtty_rest', fmt') =\n type_ignored_format_substitution sub_fmtty_rest fmt fmtty_rest in\n Fmtty_fmt_EBB (Float_ty sub_fmtty_rest', fmt')\n | Bool_ty sub_fmtty_rest, Bool_ty fmtty_rest ->\n let Fmtty_fmt_EBB (sub_fmtty_rest', fmt') =\n type_ignored_format_substitution sub_fmtty_rest fmt fmtty_rest in\n Fmtty_fmt_EBB (Bool_ty sub_fmtty_rest', fmt')\n | Alpha_ty sub_fmtty_rest, Alpha_ty fmtty_rest ->\n let Fmtty_fmt_EBB (sub_fmtty_rest', fmt') =\n type_ignored_format_substitution sub_fmtty_rest fmt fmtty_rest in\n Fmtty_fmt_EBB (Alpha_ty sub_fmtty_rest', fmt')\n | Theta_ty sub_fmtty_rest, Theta_ty fmtty_rest ->\n let Fmtty_fmt_EBB (sub_fmtty_rest', fmt') =\n type_ignored_format_substitution sub_fmtty_rest fmt fmtty_rest in\n Fmtty_fmt_EBB (Theta_ty sub_fmtty_rest', fmt')\n | Reader_ty sub_fmtty_rest, Reader_ty fmtty_rest ->\n let Fmtty_fmt_EBB (sub_fmtty_rest', fmt') =\n type_ignored_format_substitution sub_fmtty_rest fmt fmtty_rest in\n Fmtty_fmt_EBB (Reader_ty sub_fmtty_rest', fmt')\n | Ignored_reader_ty sub_fmtty_rest, Ignored_reader_ty fmtty_rest ->\n let Fmtty_fmt_EBB (sub_fmtty_rest', fmt') =\n type_ignored_format_substitution sub_fmtty_rest fmt fmtty_rest in\n Fmtty_fmt_EBB (Ignored_reader_ty sub_fmtty_rest', fmt')\n\n | Format_arg_ty (sub2_fmtty, sub_fmtty_rest),\n Format_arg_ty (sub2_fmtty', fmtty_rest) ->\n if Fmtty_EBB sub2_fmtty <> Fmtty_EBB sub2_fmtty' then raise Type_mismatch;\n let Fmtty_fmt_EBB (sub_fmtty_rest', fmt') =\n type_ignored_format_substitution sub_fmtty_rest fmt fmtty_rest in\n Fmtty_fmt_EBB (Format_arg_ty (sub2_fmtty', sub_fmtty_rest'), fmt')\n | Format_subst_ty (sub1_fmtty, sub2_fmtty, sub_fmtty_rest),\n Format_subst_ty (sub1_fmtty', sub2_fmtty', fmtty_rest) ->\n (* TODO define Fmtty_rel_EBB to remove those erase_rel *)\n if Fmtty_EBB (erase_rel sub1_fmtty) <> Fmtty_EBB (erase_rel sub1_fmtty')\n then raise Type_mismatch;\n if Fmtty_EBB (erase_rel sub2_fmtty) <> Fmtty_EBB (erase_rel sub2_fmtty')\n then raise Type_mismatch;\n let sub_fmtty' = trans (symm sub1_fmtty') sub2_fmtty' in\n let _, f2, _, f4 = fmtty_rel_det sub_fmtty' in\n let Refl = f2 Refl in\n let Refl = f4 Refl in\n let Fmtty_fmt_EBB (sub_fmtty_rest', fmt') =\n type_ignored_format_substitution (erase_rel sub_fmtty_rest) fmt fmtty_rest\n in\n Fmtty_fmt_EBB (Format_subst_ty (sub1_fmtty', sub2_fmtty',\n symm sub_fmtty_rest'),\n fmt')\n | End_of_fmtty, fmtty ->\n Fmtty_fmt_EBB (End_of_fmtty, type_format_gen fmt fmtty)\n | _ -> raise Type_mismatch\n\n(* This implementation of `recast` is a bit disappointing. The\n invariant provided by the type are very strong: the input format's\n type is in relation to the output type's as witnessed by the\n fmtty_rel argument. One would at first expect this function to be\n total, and implementable by exhaustive pattern matching. Instead,\n we reuse the highly partial and much less well-defined function\n `type_format` that has lost all knowledge of the correspondence\n between the argument's types.\n\n Besides the fact that this function reuses a lot of the\n `type_format` logic (eg.: seeing Int_ty in the fmtty parameter does\n not let you match on Int only, as you may in fact have Float\n (Arg_padding, ...) (\"%.*d\") beginning with an Int_ty), it is also\n a partial function, because the typing information in a format is\n not quite enough to reconstruct it unambiguously. For example, the\n format types of \"%d%_r\" and \"%_r%d\" have the same format6\n parameters, but they are not at all exchangeable, and putting one\n in place of the other must result in a dynamic failure.\n\n Given that:\n - we'd have to duplicate a lot of non-trivial typing logic from type_format\n - this wouldn't even eliminate (all) the dynamic failures\n we decided to just reuse type_format directly for now.\n*)\nlet recast :\n type a1 b1 c1 d1 e1 f1\n a2 b2 c2 d2 e2 f2\n .\n (a1, b1, c1, d1, e1, f1) fmt\n -> (a1, b1, c1, d1, e1, f1,\n a2, b2, c2, d2, e2, f2) fmtty_rel\n -> (a2, b2, c2, d2, e2, f2) fmt\n= fun fmt fmtty ->\n type_format fmt (erase_rel (symm fmtty))\n\n(******************************************************************************)\n (* Printing tools *)\n\n(* Add padding spaces around a string. *)\nlet fix_padding padty width str =\n let len = String.length str in\n let width, padty =\n abs width,\n (* while literal padding widths are always non-negative,\n dynamically-set widths (Arg_padding, eg. %*d) may be negative;\n we interpret those as specifying a padding-to-the-left; this\n means that '0' may get dropped even if it was explicitly set,\n but:\n - this is what the legacy implementation does, and\n we preserve compatibility if possible\n - we could only signal this issue by failing at runtime,\n which is not very nice... *)\n if width < 0 then Left else padty in\n if width <= len then str else\n let res = Bytes.make width (if padty = Zeros then '0' else ' ') in\n begin match padty with\n | Left -> String.blit str 0 res 0 len\n | Right -> String.blit str 0 res (width - len) len\n | Zeros when len > 0 && (str.[0] = '+' || str.[0] = '-' || str.[0] = ' ') ->\n Bytes.set res 0 str.[0];\n String.blit str 1 res (width - len + 1) (len - 1)\n | Zeros when len > 1 && str.[0] = '0' && (str.[1] = 'x' || str.[1] = 'X') ->\n Bytes.set res 1 str.[1];\n String.blit str 2 res (width - len + 2) (len - 2)\n | Zeros ->\n String.blit str 0 res (width - len) len\n end;\n Bytes.unsafe_to_string res\n\n(* Add '0' padding to int, int32, nativeint or int64 string representation. *)\nlet fix_int_precision prec str =\n let prec = abs prec in\n let len = String.length str in\n match str.[0] with\n | ('+' | '-' | ' ') as c when prec + 1 > len ->\n let res = Bytes.make (prec + 1) '0' in\n Bytes.set res 0 c;\n String.blit str 1 res (prec - len + 2) (len - 1);\n Bytes.unsafe_to_string res\n | '0' when prec + 2 > len && len > 1 && (str.[1] = 'x' || str.[1] = 'X') ->\n let res = Bytes.make (prec + 2) '0' in\n Bytes.set res 1 str.[1];\n String.blit str 2 res (prec - len + 4) (len - 2);\n Bytes.unsafe_to_string res\n | '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' when prec > len ->\n let res = Bytes.make prec '0' in\n String.blit str 0 res (prec - len) len;\n Bytes.unsafe_to_string res\n | _ ->\n str\n\n(* Escape a string according to the OCaml lexing convention. *)\nlet string_to_caml_string str =\n let str = String.escaped str in\n let l = String.length str in\n let res = Bytes.make (l + 2) '\\\"' in\n String.unsafe_blit str 0 res 1 l;\n Bytes.unsafe_to_string res\n\n(* Generate the format_int/int32/nativeint/int64 first argument\n from an int_conv. *)\nlet format_of_iconv = function\n | Int_d | Int_Cd -> \"%d\" | Int_pd -> \"%+d\" | Int_sd -> \"% d\"\n | Int_i | Int_Ci -> \"%i\" | Int_pi -> \"%+i\" | Int_si -> \"% i\"\n | Int_x -> \"%x\" | Int_Cx -> \"%#x\"\n | Int_X -> \"%X\" | Int_CX -> \"%#X\"\n | Int_o -> \"%o\" | Int_Co -> \"%#o\"\n | Int_u | Int_Cu -> \"%u\"\n\nlet format_of_iconvL = function\n | Int_d | Int_Cd -> \"%Ld\" | Int_pd -> \"%+Ld\" | Int_sd -> \"% Ld\"\n | Int_i | Int_Ci -> \"%Li\" | Int_pi -> \"%+Li\" | Int_si -> \"% Li\"\n | Int_x -> \"%Lx\" | Int_Cx -> \"%#Lx\"\n | Int_X -> \"%LX\" | Int_CX -> \"%#LX\"\n | Int_o -> \"%Lo\" | Int_Co -> \"%#Lo\"\n | Int_u | Int_Cu -> \"%Lu\"\n\nlet format_of_iconvl = function\n | Int_d | Int_Cd -> \"%ld\" | Int_pd -> \"%+ld\" | Int_sd -> \"% ld\"\n | Int_i | Int_Ci -> \"%li\" | Int_pi -> \"%+li\" | Int_si -> \"% li\"\n | Int_x -> \"%lx\" | Int_Cx -> \"%#lx\"\n | Int_X -> \"%lX\" | Int_CX -> \"%#lX\"\n | Int_o -> \"%lo\" | Int_Co -> \"%#lo\"\n | Int_u | Int_Cu -> \"%lu\"\n\nlet format_of_iconvn = function\n | Int_d | Int_Cd -> \"%nd\" | Int_pd -> \"%+nd\" | Int_sd -> \"% nd\"\n | Int_i | Int_Ci -> \"%ni\" | Int_pi -> \"%+ni\" | Int_si -> \"% ni\"\n | Int_x -> \"%nx\" | Int_Cx -> \"%#nx\"\n | Int_X -> \"%nX\" | Int_CX -> \"%#nX\"\n | Int_o -> \"%no\" | Int_Co -> \"%#no\"\n | Int_u | Int_Cu -> \"%nu\"\n\n(* Generate the format_float first argument from a float_conv. *)\nlet format_of_fconv fconv prec =\n let prec = abs prec in\n let symb = char_of_fconv ~cF:'g' fconv in\n let buf = buffer_create 16 in\n buffer_add_char buf '%';\n bprint_fconv_flag buf fconv;\n buffer_add_char buf '.';\n buffer_add_string buf (Int.to_string prec);\n buffer_add_char buf symb;\n buffer_contents buf\n\nlet transform_int_alt iconv s =\n match iconv with\n | Int_Cd | Int_Ci | Int_Cu ->\n let digits =\n let n = ref 0 in\n for i = 0 to String.length s - 1 do\n match String.unsafe_get s i with\n | '0'..'9' -> incr n\n | _ -> ()\n done;\n !n\n in\n let buf = Bytes.create (String.length s + (digits - 1) / 3) in\n let pos = ref 0 in\n let put c = Bytes.set buf !pos c; incr pos in\n let left = ref ((digits - 1) mod 3 + 1) in\n for i = 0 to String.length s - 1 do\n match String.unsafe_get s i with\n | '0'..'9' as c ->\n if !left = 0 then (put '_'; left := 3); decr left; put c\n | c -> put c\n done;\n Bytes.unsafe_to_string buf\n | _ -> s\n\n(* Convert an integer to a string according to a conversion. *)\nlet convert_int iconv n =\n transform_int_alt iconv (format_int (format_of_iconv iconv) n)\nlet convert_int32 iconv n =\n transform_int_alt iconv (format_int32 (format_of_iconvl iconv) n)\nlet convert_nativeint iconv n =\n transform_int_alt iconv (format_nativeint (format_of_iconvn iconv) n)\nlet convert_int64 iconv n =\n transform_int_alt iconv (format_int64 (format_of_iconvL iconv) n)\n\n(* Convert a float to string. *)\n(* Fix special case of \"OCaml float format\". *)\nlet convert_float fconv prec x =\n let hex () =\n let sign =\n match fst fconv with\n | Float_flag_p -> '+'\n | Float_flag_s -> ' '\n | _ -> '-' in\n hexstring_of_float x prec sign in\n let add_dot_if_needed str =\n let len = String.length str in\n let rec is_valid i =\n if i = len then false else\n match str.[i] with\n | '.' | 'e' | 'E' -> true\n | _ -> is_valid (i + 1) in\n if is_valid 0 then str else str ^ \".\" in\n let caml_special_val str = match classify_float x with\n | FP_normal | FP_subnormal | FP_zero -> str\n | FP_infinite -> if x < 0.0 then \"neg_infinity\" else \"infinity\"\n | FP_nan -> \"nan\" in\n match snd fconv with\n | Float_h -> hex ()\n | Float_H -> String.uppercase_ascii (hex ())\n | Float_CF -> caml_special_val (hex ())\n | Float_F ->\n let str = format_float (format_of_fconv fconv prec) x in\n caml_special_val (add_dot_if_needed str)\n | Float_f | Float_e | Float_E | Float_g | Float_G ->\n format_float (format_of_fconv fconv prec) x\n\n(* Convert a char to a string according to the OCaml lexical convention. *)\nlet format_caml_char c =\n let str = Char.escaped c in\n let l = String.length str in\n let res = Bytes.make (l + 2) '\\'' in\n String.unsafe_blit str 0 res 1 l;\n Bytes.unsafe_to_string res\n\n(* Convert a format type to string *)\nlet string_of_fmtty fmtty =\n let buf = buffer_create 16 in\n bprint_fmtty buf fmtty;\n buffer_contents buf\n\n(******************************************************************************)\n (* Generic printing function *)\n\n(* Make a generic printing function. *)\n(* Used to generate Printf and Format printing functions. *)\n(* Parameters:\n k: a continuation finally applied to the output stream and the accumulator.\n o: the output stream (see k, %a and %t).\n acc: rev list of printing entities (string, char, flush, formatting, ...).\n fmt: the format. *)\nlet rec make_printf : type a b c d e f .\n ((b, c) acc -> f) -> (b, c) acc ->\n (a, b, c, d, e, f) fmt -> a =\nfun k acc fmt -> match fmt with\n | Char rest ->\n fun c ->\n let new_acc = Acc_data_char (acc, c) in\n make_printf k new_acc rest\n | Caml_char rest ->\n fun c ->\n let new_acc = Acc_data_string (acc, format_caml_char c) in\n make_printf k new_acc rest\n | String (pad, rest) ->\n make_padding k acc rest pad (fun str -> str)\n | Caml_string (pad, rest) ->\n make_padding k acc rest pad string_to_caml_string\n | Int (iconv, pad, prec, rest) ->\n make_int_padding_precision k acc rest pad prec convert_int iconv\n | Int32 (iconv, pad, prec, rest) ->\n make_int_padding_precision k acc rest pad prec convert_int32 iconv\n | Nativeint (iconv, pad, prec, rest) ->\n make_int_padding_precision k acc rest pad prec convert_nativeint iconv\n | Int64 (iconv, pad, prec, rest) ->\n make_int_padding_precision k acc rest pad prec convert_int64 iconv\n | Float (fconv, pad, prec, rest) ->\n make_float_padding_precision k acc rest pad prec fconv\n | Bool (pad, rest) ->\n make_padding k acc rest pad string_of_bool\n | Alpha rest ->\n fun f x -> make_printf k (Acc_delay (acc, fun o -> f o x)) rest\n | Theta rest ->\n fun f -> make_printf k (Acc_delay (acc, f)) rest\n | Custom (arity, f, rest) ->\n make_custom k acc rest arity (f ())\n | Reader _ ->\n (* This case is impossible, by typing of formats. *)\n (* Indeed, since printf and co. take a format4 as argument, the 'd and 'e\n type parameters of fmt are obviously equals. The Reader is the\n only constructor which touch 'd and 'e type parameters of the format\n type, it adds an (->) to the 'd parameters. Consequently, a format4\n cannot contain a Reader node, except in the sub-format associated to\n an %{...%}. It's not a problem because make_printf do not call\n itself recursively on the sub-format associated to %{...%}. *)\n assert false\n | Flush rest ->\n make_printf k (Acc_flush acc) rest\n\n | String_literal (str, rest) ->\n make_printf k (Acc_string_literal (acc, str)) rest\n | Char_literal (chr, rest) ->\n make_printf k (Acc_char_literal (acc, chr)) rest\n\n | Format_arg (_, sub_fmtty, rest) ->\n let ty = string_of_fmtty sub_fmtty in\n (fun str ->\n ignore str;\n make_printf k (Acc_data_string (acc, ty)) rest)\n | Format_subst (_, fmtty, rest) ->\n fun (Format (fmt, _)) -> make_printf k acc\n (concat_fmt (recast fmt fmtty) rest)\n\n | Scan_char_set (_, _, rest) ->\n let new_acc = Acc_invalid_arg (acc, \"Printf: bad conversion %[\") in\n fun _ -> make_printf k new_acc rest\n | Scan_get_counter (_, rest) ->\n (* This case should be refused for Printf. *)\n (* Accepted for backward compatibility. *)\n (* Interpret %l, %n and %L as %u. *)\n fun n ->\n let new_acc = Acc_data_string (acc, format_int \"%u\" n) in\n make_printf k new_acc rest\n | Scan_next_char rest ->\n fun c ->\n let new_acc = Acc_data_char (acc, c) in\n make_printf k new_acc rest\n | Ignored_param (ign, rest) ->\n make_ignored_param k acc ign rest\n\n | Formatting_lit (fmting_lit, rest) ->\n make_printf k (Acc_formatting_lit (acc, fmting_lit)) rest\n | Formatting_gen (Open_tag (Format (fmt', _)), rest) ->\n let k' kacc =\n make_printf k (Acc_formatting_gen (acc, Acc_open_tag kacc)) rest in\n make_printf k' End_of_acc fmt'\n | Formatting_gen (Open_box (Format (fmt', _)), rest) ->\n let k' kacc =\n make_printf k (Acc_formatting_gen (acc, Acc_open_box kacc)) rest in\n make_printf k' End_of_acc fmt'\n\n | End_of_format ->\n k acc\n\n(* Delay the error (Invalid_argument \"Printf: bad conversion %_\"). *)\n(* Generate functions to take remaining arguments (after the \"%_\"). *)\nand make_ignored_param : type x y a b c d e f .\n ((b, c) acc -> f) -> (b, c) acc ->\n (a, b, c, d, y, x) ignored ->\n (x, b, c, y, e, f) fmt -> a =\nfun k acc ign fmt -> match ign with\n | Ignored_char -> make_invalid_arg k acc fmt\n | Ignored_caml_char -> make_invalid_arg k acc fmt\n | Ignored_string _ -> make_invalid_arg k acc fmt\n | Ignored_caml_string _ -> make_invalid_arg k acc fmt\n | Ignored_int (_, _) -> make_invalid_arg k acc fmt\n | Ignored_int32 (_, _) -> make_invalid_arg k acc fmt\n | Ignored_nativeint (_, _) -> make_invalid_arg k acc fmt\n | Ignored_int64 (_, _) -> make_invalid_arg k acc fmt\n | Ignored_float (_, _) -> make_invalid_arg k acc fmt\n | Ignored_bool _ -> make_invalid_arg k acc fmt\n | Ignored_format_arg _ -> make_invalid_arg k acc fmt\n | Ignored_format_subst (_, fmtty) -> make_from_fmtty k acc fmtty fmt\n | Ignored_reader -> assert false\n | Ignored_scan_char_set _ -> make_invalid_arg k acc fmt\n | Ignored_scan_get_counter _ -> make_invalid_arg k acc fmt\n | Ignored_scan_next_char -> make_invalid_arg k acc fmt\n\n\n(* Special case of printf \"%_(\". *)\nand make_from_fmtty : type x y a b c d e f .\n ((b, c) acc -> f) -> (b, c) acc ->\n (a, b, c, d, y, x) fmtty ->\n (x, b, c, y, e, f) fmt -> a =\nfun k acc fmtty fmt -> match fmtty with\n | Char_ty rest -> fun _ -> make_from_fmtty k acc rest fmt\n | String_ty rest -> fun _ -> make_from_fmtty k acc rest fmt\n | Int_ty rest -> fun _ -> make_from_fmtty k acc rest fmt\n | Int32_ty rest -> fun _ -> make_from_fmtty k acc rest fmt\n | Nativeint_ty rest -> fun _ -> make_from_fmtty k acc rest fmt\n | Int64_ty rest -> fun _ -> make_from_fmtty k acc rest fmt\n | Float_ty rest -> fun _ -> make_from_fmtty k acc rest fmt\n | Bool_ty rest -> fun _ -> make_from_fmtty k acc rest fmt\n | Alpha_ty rest -> fun _ _ -> make_from_fmtty k acc rest fmt\n | Theta_ty rest -> fun _ -> make_from_fmtty k acc rest fmt\n | Any_ty rest -> fun _ -> make_from_fmtty k acc rest fmt\n | Reader_ty _ -> assert false\n | Ignored_reader_ty _ -> assert false\n | Format_arg_ty (_, rest) -> fun _ -> make_from_fmtty k acc rest fmt\n | End_of_fmtty -> make_invalid_arg k acc fmt\n | Format_subst_ty (ty1, ty2, rest) ->\n let ty = trans (symm ty1) ty2 in\n fun _ -> make_from_fmtty k acc (concat_fmtty ty rest) fmt\n\n(* Insert an Acc_invalid_arg in the accumulator and continue to generate\n closures to get the remaining arguments. *)\nand make_invalid_arg : type a b c d e f .\n ((b, c) acc -> f) -> (b, c) acc ->\n (a, b, c, d, e, f) fmt -> a =\nfun k acc fmt ->\n make_printf k (Acc_invalid_arg (acc, \"Printf: bad conversion %_\")) fmt\n\n(* Fix padding, take it as an extra integer argument if needed. *)\nand make_padding : type x z a b c d e f .\n ((b, c) acc -> f) -> (b, c) acc ->\n (a, b, c, d, e, f) fmt ->\n (x, z -> a) padding -> (z -> string) -> x =\n fun k acc fmt pad trans -> match pad with\n | No_padding ->\n fun x ->\n let new_acc = Acc_data_string (acc, trans x) in\n make_printf k new_acc fmt\n | Lit_padding (padty, width) ->\n fun x ->\n let new_acc = Acc_data_string (acc, fix_padding padty width (trans x)) in\n make_printf k new_acc fmt\n | Arg_padding padty ->\n fun w x ->\n let new_acc = Acc_data_string (acc, fix_padding padty w (trans x)) in\n make_printf k new_acc fmt\n\n(* Fix padding and precision for int, int32, nativeint or int64. *)\n(* Take one or two extra integer arguments if needed. *)\nand make_int_padding_precision : type x y z a b c d e f .\n ((b, c) acc -> f) -> (b, c) acc ->\n (a, b, c, d, e, f) fmt ->\n (x, y) padding -> (y, z -> a) precision -> (int_conv -> z -> string) ->\n int_conv -> x =\n fun k acc fmt pad prec trans iconv -> match pad, prec with\n | No_padding, No_precision ->\n fun x ->\n let str = trans iconv x in\n make_printf k (Acc_data_string (acc, str)) fmt\n | No_padding, Lit_precision p ->\n fun x ->\n let str = fix_int_precision p (trans iconv x) in\n make_printf k (Acc_data_string (acc, str)) fmt\n | No_padding, Arg_precision ->\n fun p x ->\n let str = fix_int_precision p (trans iconv x) in\n make_printf k (Acc_data_string (acc, str)) fmt\n | Lit_padding (padty, w), No_precision ->\n fun x ->\n let str = fix_padding padty w (trans iconv x) in\n make_printf k (Acc_data_string (acc, str)) fmt\n | Lit_padding (padty, w), Lit_precision p ->\n fun x ->\n let str = fix_padding padty w (fix_int_precision p (trans iconv x)) in\n make_printf k (Acc_data_string (acc, str)) fmt\n | Lit_padding (padty, w), Arg_precision ->\n fun p x ->\n let str = fix_padding padty w (fix_int_precision p (trans iconv x)) in\n make_printf k (Acc_data_string (acc, str)) fmt\n | Arg_padding padty, No_precision ->\n fun w x ->\n let str = fix_padding padty w (trans iconv x) in\n make_printf k (Acc_data_string (acc, str)) fmt\n | Arg_padding padty, Lit_precision p ->\n fun w x ->\n let str = fix_padding padty w (fix_int_precision p (trans iconv x)) in\n make_printf k (Acc_data_string (acc, str)) fmt\n | Arg_padding padty, Arg_precision ->\n fun w p x ->\n let str = fix_padding padty w (fix_int_precision p (trans iconv x)) in\n make_printf k (Acc_data_string (acc, str)) fmt\n\n(* Convert a float, fix padding and precision if needed. *)\n(* Take the float argument and one or two extra integer arguments if needed. *)\nand make_float_padding_precision : type x y a b c d e f .\n ((b, c) acc -> f) -> (b, c) acc ->\n (a, b, c, d, e, f) fmt ->\n (x, y) padding -> (y, float -> a) precision -> float_conv -> x =\n fun k acc fmt pad prec fconv -> match pad, prec with\n | No_padding, No_precision ->\n fun x ->\n let str = convert_float fconv (default_float_precision fconv) x in\n make_printf k (Acc_data_string (acc, str)) fmt\n | No_padding, Lit_precision p ->\n fun x ->\n let str = convert_float fconv p x in\n make_printf k (Acc_data_string (acc, str)) fmt\n | No_padding, Arg_precision ->\n fun p x ->\n let str = convert_float fconv p x in\n make_printf k (Acc_data_string (acc, str)) fmt\n | Lit_padding (padty, w), No_precision ->\n fun x ->\n let str = convert_float fconv (default_float_precision fconv) x in\n let str' = fix_padding padty w str in\n make_printf k (Acc_data_string (acc, str')) fmt\n | Lit_padding (padty, w), Lit_precision p ->\n fun x ->\n let str = fix_padding padty w (convert_float fconv p x) in\n make_printf k (Acc_data_string (acc, str)) fmt\n | Lit_padding (padty, w), Arg_precision ->\n fun p x ->\n let str = fix_padding padty w (convert_float fconv p x) in\n make_printf k (Acc_data_string (acc, str)) fmt\n | Arg_padding padty, No_precision ->\n fun w x ->\n let str = convert_float fconv (default_float_precision fconv) x in\n let str' = fix_padding padty w str in\n make_printf k (Acc_data_string (acc, str')) fmt\n | Arg_padding padty, Lit_precision p ->\n fun w x ->\n let str = fix_padding padty w (convert_float fconv p x) in\n make_printf k (Acc_data_string (acc, str)) fmt\n | Arg_padding padty, Arg_precision ->\n fun w p x ->\n let str = fix_padding padty w (convert_float fconv p x) in\n make_printf k (Acc_data_string (acc, str)) fmt\nand make_custom : type x y a b c d e f .\n ((b, c) acc -> f) -> (b, c) acc ->\n (a, b, c, d, e, f) fmt ->\n (a, x, y) custom_arity -> x -> y =\n fun k acc rest arity f -> match arity with\n | Custom_zero -> make_printf k (Acc_data_string (acc, f)) rest\n | Custom_succ arity ->\n fun x ->\n make_custom k acc rest arity (f x)\n\nlet const x _ = x\n\nlet rec make_iprintf : type a b c d e f state.\n (state -> f) -> state -> (a, b, c, d, e, f) fmt -> a =\n fun k o fmt -> match fmt with\n | Char rest ->\n const (make_iprintf k o rest)\n | Caml_char rest ->\n const (make_iprintf k o rest)\n | String (No_padding, rest) ->\n const (make_iprintf k o rest)\n | String (Lit_padding _, rest) ->\n const (make_iprintf k o rest)\n | String (Arg_padding _, rest) ->\n const (const (make_iprintf k o rest))\n | Caml_string (No_padding, rest) ->\n const (make_iprintf k o rest)\n | Caml_string (Lit_padding _, rest) ->\n const (make_iprintf k o rest)\n | Caml_string (Arg_padding _, rest) ->\n const (const (make_iprintf k o rest))\n | Int (_, pad, prec, rest) ->\n fn_of_padding_precision k o rest pad prec\n | Int32 (_, pad, prec, rest) ->\n fn_of_padding_precision k o rest pad prec\n | Nativeint (_, pad, prec, rest) ->\n fn_of_padding_precision k o rest pad prec\n | Int64 (_, pad, prec, rest) ->\n fn_of_padding_precision k o rest pad prec\n | Float (_, pad, prec, rest) ->\n fn_of_padding_precision k o rest pad prec\n | Bool (No_padding, rest) ->\n const (make_iprintf k o rest)\n | Bool (Lit_padding _, rest) ->\n const (make_iprintf k o rest)\n | Bool (Arg_padding _, rest) ->\n const (const (make_iprintf k o rest))\n | Alpha rest ->\n const (const (make_iprintf k o rest))\n | Theta rest ->\n const (make_iprintf k o rest)\n | Custom (arity, _, rest) ->\n fn_of_custom_arity k o rest arity\n | Reader _ ->\n (* This case is impossible, by typing of formats. See the\n note in the corresponding case for make_printf. *)\n assert false\n | Flush rest ->\n make_iprintf k o rest\n | String_literal (_, rest) ->\n make_iprintf k o rest\n | Char_literal (_, rest) ->\n make_iprintf k o rest\n | Format_arg (_, _, rest) ->\n const (make_iprintf k o rest)\n | Format_subst (_, fmtty, rest) ->\n fun (Format (fmt, _)) ->\n make_iprintf k o\n (concat_fmt (recast fmt fmtty) rest)\n | Scan_char_set (_, _, rest) ->\n const (make_iprintf k o rest)\n | Scan_get_counter (_, rest) ->\n const (make_iprintf k o rest)\n | Scan_next_char rest ->\n const (make_iprintf k o rest)\n | Ignored_param (ign, rest) ->\n make_ignored_param (fun _ -> k o) (End_of_acc) ign rest\n | Formatting_lit (_, rest) ->\n make_iprintf k o rest\n | Formatting_gen (Open_tag (Format (fmt', _)), rest) ->\n make_iprintf (fun koc -> make_iprintf k koc rest) o fmt'\n | Formatting_gen (Open_box (Format (fmt', _)), rest) ->\n make_iprintf (fun koc -> make_iprintf k koc rest) o fmt'\n | End_of_format ->\n k o\nand fn_of_padding_precision :\n type x y z a b c d e f state.\n (state -> f) -> state -> (a, b, c, d, e, f) fmt ->\n (x, y) padding -> (y, z -> a) precision -> x =\n fun k o fmt pad prec -> match pad, prec with\n | No_padding , No_precision ->\n const (make_iprintf k o fmt)\n | No_padding , Lit_precision _ ->\n const (make_iprintf k o fmt)\n | No_padding , Arg_precision ->\n const (const (make_iprintf k o fmt))\n | Lit_padding _, No_precision ->\n const (make_iprintf k o fmt)\n | Lit_padding _, Lit_precision _ ->\n const (make_iprintf k o fmt)\n | Lit_padding _, Arg_precision ->\n const (const (make_iprintf k o fmt))\n | Arg_padding _, No_precision ->\n const (const (make_iprintf k o fmt))\n | Arg_padding _, Lit_precision _ ->\n const (const (make_iprintf k o fmt))\n | Arg_padding _, Arg_precision ->\n const (const (const (make_iprintf k o fmt)))\nand fn_of_custom_arity : type x y a b c d e f state.\n (state -> f) ->\n state -> (a, b, c, d, e, f) fmt -> (a, x, y) custom_arity -> y =\n fun k o fmt -> function\n | Custom_zero ->\n make_iprintf k o fmt\n | Custom_succ arity ->\n const (fn_of_custom_arity k o fmt arity)\n\n(******************************************************************************)\n (* Continuations for make_printf *)\n\n(* Recursively output an \"accumulator\" containing a reversed list of\n printing entities (string, char, flus, ...) in an output_stream. *)\n(* Used as a continuation of make_printf. *)\nlet rec output_acc o acc = match acc with\n | Acc_formatting_lit (p, fmting_lit) ->\n let s = string_of_formatting_lit fmting_lit in\n output_acc o p; output_string o s;\n | Acc_formatting_gen (p, Acc_open_tag acc') ->\n output_acc o p; output_string o \"@{\"; output_acc o acc';\n | Acc_formatting_gen (p, Acc_open_box acc') ->\n output_acc o p; output_string o \"@[\"; output_acc o acc';\n | Acc_string_literal (p, s)\n | Acc_data_string (p, s) -> output_acc o p; output_string o s\n | Acc_char_literal (p, c)\n | Acc_data_char (p, c) -> output_acc o p; output_char o c\n | Acc_delay (p, f) -> output_acc o p; f o\n | Acc_flush p -> output_acc o p; flush o\n | Acc_invalid_arg (p, msg) -> output_acc o p; invalid_arg msg;\n | End_of_acc -> ()\n\n(* Recursively output an \"accumulator\" containing a reversed list of\n printing entities (string, char, flus, ...) in a buffer. *)\n(* Used as a continuation of make_printf. *)\nlet rec bufput_acc b acc = match acc with\n | Acc_formatting_lit (p, fmting_lit) ->\n let s = string_of_formatting_lit fmting_lit in\n bufput_acc b p; Buffer.add_string b s;\n | Acc_formatting_gen (p, Acc_open_tag acc') ->\n bufput_acc b p; Buffer.add_string b \"@{\"; bufput_acc b acc';\n | Acc_formatting_gen (p, Acc_open_box acc') ->\n bufput_acc b p; Buffer.add_string b \"@[\"; bufput_acc b acc';\n | Acc_string_literal (p, s)\n | Acc_data_string (p, s) -> bufput_acc b p; Buffer.add_string b s\n | Acc_char_literal (p, c)\n | Acc_data_char (p, c) -> bufput_acc b p; Buffer.add_char b c\n | Acc_delay (p, f) -> bufput_acc b p; f b\n | Acc_flush p -> bufput_acc b p;\n | Acc_invalid_arg (p, msg) -> bufput_acc b p; invalid_arg msg;\n | End_of_acc -> ()\n\n(* Recursively output an \"accumulator\" containing a reversed list of\n printing entities (string, char, flus, ...) in a buffer. *)\n(* Differ from bufput_acc by the interpretation of %a and %t. *)\n(* Used as a continuation of make_printf. *)\nlet rec strput_acc b acc = match acc with\n | Acc_formatting_lit (p, fmting_lit) ->\n let s = string_of_formatting_lit fmting_lit in\n strput_acc b p; Buffer.add_string b s;\n | Acc_formatting_gen (p, Acc_open_tag acc') ->\n strput_acc b p; Buffer.add_string b \"@{\"; strput_acc b acc';\n | Acc_formatting_gen (p, Acc_open_box acc') ->\n strput_acc b p; Buffer.add_string b \"@[\"; strput_acc b acc';\n | Acc_string_literal (p, s)\n | Acc_data_string (p, s) -> strput_acc b p; Buffer.add_string b s\n | Acc_char_literal (p, c)\n | Acc_data_char (p, c) -> strput_acc b p; Buffer.add_char b c\n | Acc_delay (p, f) -> strput_acc b p; Buffer.add_string b (f ())\n | Acc_flush p -> strput_acc b p;\n | Acc_invalid_arg (p, msg) -> strput_acc b p; invalid_arg msg;\n | End_of_acc -> ()\n\n(******************************************************************************)\n (* Error management *)\n\n(* Raise [Failure] with a pretty-printed error message. *)\nlet failwith_message (Format (fmt, _)) =\n let buf = Buffer.create 256 in\n let k acc = strput_acc buf acc; failwith (Buffer.contents buf) in\n make_printf k End_of_acc fmt\n\n(******************************************************************************)\n (* Formatting tools *)\n\n(* Convert a string to an open block description (indent, block_type) *)\nlet open_box_of_string str =\n if str = \"\" then (0, Pp_box) else\n let len = String.length str in\n let invalid_box () = failwith_message \"invalid box description %S\" str in\n let rec parse_spaces i =\n if i = len then i else\n match str.[i] with\n | ' ' | '\\t' -> parse_spaces (i + 1)\n | _ -> i\n and parse_lword i j =\n if j = len then j else\n match str.[j] with\n | 'a' .. 'z' -> parse_lword i (j + 1)\n | _ -> j\n and parse_int i j =\n if j = len then j else\n match str.[j] with\n | '0' .. '9' | '-' -> parse_int i (j + 1)\n | _ -> j in\n let wstart = parse_spaces 0 in\n let wend = parse_lword wstart wstart in\n let box_name = String.sub str wstart (wend - wstart) in\n let nstart = parse_spaces wend in\n let nend = parse_int nstart nstart in\n let indent =\n if nstart = nend then 0 else\n try int_of_string (String.sub str nstart (nend - nstart))\n with Failure _ -> invalid_box () in\n let exp_end = parse_spaces nend in\n if exp_end <> len then invalid_box ();\n let box_type = match box_name with\n | \"\" | \"b\" -> Pp_box\n | \"h\" -> Pp_hbox\n | \"v\" -> Pp_vbox\n | \"hv\" -> Pp_hvbox\n | \"hov\" -> Pp_hovbox\n | _ -> invalid_box () in\n (indent, box_type)\n\n(******************************************************************************)\n (* Parsing tools *)\n\n(* Create a padding_fmt_ebb from a padding and a format. *)\n(* Copy the padding to disjoin the type parameters of argument and result. *)\nlet make_padding_fmt_ebb : type x y .\n (x, y) padding -> (_, _, _, _, _, _) fmt ->\n (_, _, _, _, _) padding_fmt_ebb =\nfun pad fmt -> match pad with\n | No_padding -> Padding_fmt_EBB (No_padding, fmt)\n | Lit_padding (s, w) -> Padding_fmt_EBB (Lit_padding (s, w), fmt)\n | Arg_padding s -> Padding_fmt_EBB (Arg_padding s, fmt)\n\n(* Create a precision_fmt_ebb from a precision and a format. *)\n(* Copy the precision to disjoin the type parameters of argument and result. *)\nlet make_precision_fmt_ebb : type x y .\n (x, y) precision -> (_, _, _, _, _, _) fmt ->\n (_, _, _, _, _) precision_fmt_ebb =\nfun prec fmt -> match prec with\n | No_precision -> Precision_fmt_EBB (No_precision, fmt)\n | Lit_precision p -> Precision_fmt_EBB (Lit_precision p, fmt)\n | Arg_precision -> Precision_fmt_EBB (Arg_precision, fmt)\n\n(* Create a padprec_fmt_ebb from a padding, a precision and a format. *)\n(* Copy the padding and the precision to disjoin type parameters of arguments\n and result. *)\nlet make_padprec_fmt_ebb : type x y z t .\n (x, y) padding -> (z, t) precision ->\n (_, _, _, _, _, _) fmt ->\n (_, _, _, _, _) padprec_fmt_ebb =\nfun pad prec fmt ->\n let Precision_fmt_EBB (prec, fmt') = make_precision_fmt_ebb prec fmt in\n match pad with\n | No_padding -> Padprec_fmt_EBB (No_padding, prec, fmt')\n | Lit_padding (s, w) -> Padprec_fmt_EBB (Lit_padding (s, w), prec, fmt')\n | Arg_padding s -> Padprec_fmt_EBB (Arg_padding s, prec, fmt')\n\n(******************************************************************************)\n (* Format parsing *)\n\n(* Parse a string representing a format and create a fmt_ebb. *)\n(* Raise [Failure] in case of invalid format. *)\nlet fmt_ebb_of_string ?legacy_behavior str =\n (* Parameters naming convention: *)\n (* - lit_start: start of the literal sequence. *)\n (* - str_ind: current index in the string. *)\n (* - end_ind: end of the current (sub-)format. *)\n (* - pct_ind: index of the '%' in the current micro-format. *)\n (* - zero: is the '0' flag defined in the current micro-format. *)\n (* - minus: is the '-' flag defined in the current micro-format. *)\n (* - plus: is the '+' flag defined in the current micro-format. *)\n (* - hash: is the '#' flag defined in the current micro-format. *)\n (* - space: is the ' ' flag defined in the current micro-format. *)\n (* - ign: is the '_' flag defined in the current micro-format. *)\n (* - pad: padding of the current micro-format. *)\n (* - prec: precision of the current micro-format. *)\n (* - symb: char representing the conversion ('c', 's', 'd', ...). *)\n (* - char_set: set of characters as bitmap (see scanf %[...]). *)\n\n let legacy_behavior = match legacy_behavior with\n | Some flag -> flag\n | None -> true\n (* When this flag is enabled, the format parser tries to behave as\n the <4.02 implementations, in particular it ignores most benine\n nonsensical format. When the flag is disabled, it will reject any\n format that is not accepted by the specification.\n\n A typical example would be \"%+ d\": specifying both '+' (if the\n number is positive, pad with a '+' to get the same width as\n negative numbers) and ' ' (if the number is positive, pad with\n a space) does not make sense, but the legacy (< 4.02)\n implementation was happy to just ignore the space.\n *)\n in\n\n (* Raise [Failure] with a friendly error message. *)\n let invalid_format_message str_ind msg =\n failwith_message\n \"invalid format %S: at character number %d, %s\"\n str str_ind msg\n in\n\n (* Used when the end of the format (or the current sub-format) was encountered\n unexpectedly. *)\n let unexpected_end_of_format end_ind =\n invalid_format_message end_ind\n \"unexpected end of format\"\n in\n\n (* Used for %0c: no other widths are implemented *)\n let invalid_nonnull_char_width str_ind =\n invalid_format_message str_ind\n \"non-zero widths are unsupported for %c conversions\"\n in\n (* Raise [Failure] with a friendly error message about an option dependency\n problem. *)\n let invalid_format_without str_ind c s =\n failwith_message\n \"invalid format %S: at character number %d, '%c' without %s\"\n str str_ind c s\n in\n\n (* Raise [Failure] with a friendly error message about an unexpected\n character. *)\n let expected_character str_ind expected read =\n failwith_message\n \"invalid format %S: at character number %d, %s expected, read %C\"\n str str_ind expected read\n in\n\n (* Parse the string from beg_ind (included) to end_ind (excluded). *)\n let rec parse : type e f . int -> int -> (_, _, e, f) fmt_ebb =\n fun beg_ind end_ind -> parse_literal beg_ind beg_ind end_ind\n\n (* Read literal characters up to '%' or '@' special characters. *)\n and parse_literal : type e f . int -> int -> int -> (_, _, e, f) fmt_ebb =\n fun lit_start str_ind end_ind ->\n if str_ind = end_ind then add_literal lit_start str_ind End_of_format else\n match str.[str_ind] with\n | '%' ->\n let Fmt_EBB fmt_rest = parse_format str_ind end_ind in\n add_literal lit_start str_ind fmt_rest\n | '@' ->\n let Fmt_EBB fmt_rest = parse_after_at (str_ind + 1) end_ind in\n add_literal lit_start str_ind fmt_rest\n | _ ->\n parse_literal lit_start (str_ind + 1) end_ind\n\n (* Parse a format after '%' *)\n and parse_format : type e f . int -> int -> (_, _, e, f) fmt_ebb =\n fun pct_ind end_ind -> parse_ign pct_ind (pct_ind + 1) end_ind\n\n and parse_ign : type e f . int -> int -> int -> (_, _, e, f) fmt_ebb =\n fun pct_ind str_ind end_ind ->\n if str_ind = end_ind then unexpected_end_of_format end_ind;\n match str.[str_ind] with\n | '_' -> parse_flags pct_ind (str_ind+1) end_ind true\n | _ -> parse_flags pct_ind str_ind end_ind false\n\n and parse_flags : type e f . int -> int -> int -> bool -> (_, _, e, f) fmt_ebb\n =\n fun pct_ind str_ind end_ind ign ->\n let zero = ref false and minus = ref false\n and plus = ref false and space = ref false\n and hash = ref false in\n let set_flag str_ind flag =\n (* in legacy mode, duplicate flags are accepted *)\n if !flag && not legacy_behavior then\n failwith_message\n \"invalid format %S: at character number %d, duplicate flag %C\"\n str str_ind str.[str_ind];\n flag := true;\n in\n let rec read_flags str_ind =\n if str_ind = end_ind then unexpected_end_of_format end_ind;\n begin match str.[str_ind] with\n | '0' -> set_flag str_ind zero; read_flags (str_ind + 1)\n | '-' -> set_flag str_ind minus; read_flags (str_ind + 1)\n | '+' -> set_flag str_ind plus; read_flags (str_ind + 1)\n | '#' -> set_flag str_ind hash; read_flags (str_ind + 1)\n | ' ' -> set_flag str_ind space; read_flags (str_ind + 1)\n | _ ->\n parse_padding pct_ind str_ind end_ind\n !zero !minus !plus !hash !space ign\n end\n in\n read_flags str_ind\n\n (* Try to read a digital or a '*' padding. *)\n and parse_padding : type e f .\n int -> int -> int -> bool -> bool -> bool -> bool -> bool -> bool ->\n (_, _, e, f) fmt_ebb =\n fun pct_ind str_ind end_ind zero minus plus hash space ign ->\n if str_ind = end_ind then unexpected_end_of_format end_ind;\n let padty = match zero, minus with\n | false, false -> Right\n | false, true -> Left\n | true, false -> Zeros\n | true, true ->\n if legacy_behavior then Left\n else incompatible_flag pct_ind str_ind '-' \"0\" in\n match str.[str_ind] with\n | '0' .. '9' ->\n let new_ind, width = parse_positive str_ind end_ind 0 in\n parse_after_padding pct_ind new_ind end_ind minus plus hash space ign\n (Lit_padding (padty, width))\n | '*' ->\n parse_after_padding pct_ind (str_ind + 1) end_ind minus plus hash space\n ign (Arg_padding padty)\n | _ ->\n begin match padty with\n | Left ->\n if not legacy_behavior then\n invalid_format_without (str_ind - 1) '-' \"padding\";\n parse_after_padding pct_ind str_ind end_ind minus plus hash space ign\n No_padding\n | Zeros ->\n (* a '0' padding indication not followed by anything should\n be interpreted as a Right padding of width 0. This is used\n by scanning conversions %0s and %0c *)\n parse_after_padding pct_ind str_ind end_ind minus plus hash space ign\n (Lit_padding (Right, 0))\n | Right ->\n parse_after_padding pct_ind str_ind end_ind minus plus hash space ign\n No_padding\n end\n\n (* Is precision defined? *)\n and parse_after_padding : type x e f .\n int -> int -> int -> bool -> bool -> bool -> bool -> bool ->\n (x, _) padding -> (_, _, e, f) fmt_ebb =\n fun pct_ind str_ind end_ind minus plus hash space ign pad ->\n if str_ind = end_ind then unexpected_end_of_format end_ind;\n match str.[str_ind] with\n | '.' ->\n parse_precision pct_ind (str_ind + 1) end_ind minus plus hash space ign\n pad\n | symb ->\n parse_conversion pct_ind (str_ind + 1) end_ind plus hash space ign pad\n No_precision pad symb\n\n (* Read the digital or '*' precision. *)\n and parse_precision : type x e f .\n int -> int -> int -> bool -> bool -> bool -> bool -> bool ->\n (x, _) padding -> (_, _, e, f) fmt_ebb =\n fun pct_ind str_ind end_ind minus plus hash space ign pad ->\n if str_ind = end_ind then unexpected_end_of_format end_ind;\n let parse_literal minus str_ind =\n let new_ind, prec = parse_positive str_ind end_ind 0 in\n parse_after_precision pct_ind new_ind end_ind minus plus hash space ign\n pad (Lit_precision prec) in\n match str.[str_ind] with\n | '0' .. '9' -> parse_literal minus str_ind\n | ('+' | '-') as symb when legacy_behavior ->\n (* Legacy mode would accept and ignore '+' or '-' before the\n integer describing the desired precision; note that this\n cannot happen for padding width, as '+' and '-' already have\n a semantics there.\n\n That said, the idea (supported by this tweak) that width and\n precision literals are \"integer literals\" in the OCaml sense is\n still blatantly wrong, as 123_456 or 0xFF are rejected. *)\n parse_literal (minus || symb = '-') (str_ind + 1)\n | '*' ->\n parse_after_precision pct_ind (str_ind + 1) end_ind minus plus hash space\n ign pad Arg_precision\n | _ ->\n if legacy_behavior then\n (* note that legacy implementation did not ignore '.' without\n a number (as it does for padding indications), but\n interprets it as '.0' *)\n parse_after_precision pct_ind str_ind end_ind minus plus hash space ign\n pad (Lit_precision 0)\n else\n invalid_format_without (str_ind - 1) '.' \"precision\"\n\n (* Try to read the conversion. *)\n and parse_after_precision : type x y z t e f .\n int -> int -> int -> bool -> bool -> bool -> bool -> bool ->\n (x, y) padding -> (z, t) precision -> (_, _, e, f) fmt_ebb =\n fun pct_ind str_ind end_ind minus plus hash space ign pad prec ->\n if str_ind = end_ind then unexpected_end_of_format end_ind;\n let parse_conv (type u) (type v) (padprec : (u, v) padding) =\n parse_conversion pct_ind (str_ind + 1) end_ind plus hash space ign pad\n prec padprec str.[str_ind] in\n (* in legacy mode, some formats (%s and %S) accept a weird mix of\n padding and precision, which is merged as a single padding\n information. For example, in %.10s the precision is implicitly\n understood as padding %10s, but the left-padding component may\n be specified either as a left padding or a negative precision:\n %-.3s and %.-3s are equivalent to %-3s *)\n match pad with\n | No_padding -> (\n match minus, prec with\n | _, No_precision -> parse_conv No_padding\n | false, Lit_precision n -> parse_conv (Lit_padding (Right, n))\n | true, Lit_precision n -> parse_conv (Lit_padding (Left, n))\n | false, Arg_precision -> parse_conv (Arg_padding Right)\n | true, Arg_precision -> parse_conv (Arg_padding Left)\n )\n | pad -> parse_conv pad\n\n (* Case analysis on conversion. *)\n and parse_conversion : type x y z t u v e f .\n int -> int -> int -> bool -> bool -> bool -> bool -> (x, y) padding ->\n (z, t) precision -> (u, v) padding -> char -> (_, _, e, f) fmt_ebb =\n fun pct_ind str_ind end_ind plus hash space ign pad prec padprec symb ->\n (* Flags used to check option usages/compatibilities. *)\n let plus_used = ref false and hash_used = ref false\n and space_used = ref false and ign_used = ref false\n and pad_used = ref false and prec_used = ref false in\n\n (* Access to options, update flags. *)\n let get_plus () = plus_used := true; plus\n and get_hash () = hash_used := true; hash\n and get_space () = space_used := true; space\n and get_ign () = ign_used := true; ign\n and get_pad () = pad_used := true; pad\n and get_prec () = prec_used := true; prec\n and get_padprec () = pad_used := true; padprec in\n\n let get_int_pad () : (x,y) padding =\n (* %5.3d is accepted and meaningful: pad to length 5 with\n spaces, but first pad with zeros upto length 3 (0-padding\n is the interpretation of \"precision\" for integer formats).\n\n %05.3d is redundant: pad to length 5 *with zeros*, but\n first pad with zeros... To add insult to the injury, the\n legacy implementation ignores the 0-padding indication and\n does the 5 padding with spaces instead. We reuse this\n interpretation for compatibility, but statically reject this\n format when the legacy mode is disabled, to protect strict\n users from this corner case. *)\n match get_pad (), get_prec () with\n | pad, No_precision -> pad\n | No_padding, _ -> No_padding\n | Lit_padding (Zeros, n), _ ->\n if legacy_behavior then Lit_padding (Right, n)\n else incompatible_flag pct_ind str_ind '0' \"precision\"\n | Arg_padding Zeros, _ ->\n if legacy_behavior then Arg_padding Right\n else incompatible_flag pct_ind str_ind '0' \"precision\"\n | Lit_padding _ as pad, _ -> pad\n | Arg_padding _ as pad, _ -> pad in\n\n (* Check that padty <> Zeros. *)\n let check_no_0 symb (type a b) (pad : (a, b) padding) : (a,b) padding =\n match pad with\n | No_padding -> pad\n | Lit_padding ((Left | Right), _) -> pad\n | Arg_padding (Left | Right) -> pad\n | Lit_padding (Zeros, width) ->\n if legacy_behavior then Lit_padding (Right, width)\n else incompatible_flag pct_ind str_ind symb \"0\"\n | Arg_padding Zeros ->\n if legacy_behavior then Arg_padding Right\n else incompatible_flag pct_ind str_ind symb \"0\"\n in\n\n (* Get padding as a pad_option (see \"%_\", \"%{\", \"%(\" and \"%[\").\n (no need for legacy mode tweaking, those were rejected by the\n legacy parser as well) *)\n let opt_of_pad c (type a) (type b) (pad : (a, b) padding) = match pad with\n | No_padding -> None\n | Lit_padding (Right, width) -> Some width\n | Lit_padding (Zeros, width) ->\n if legacy_behavior then Some width\n else incompatible_flag pct_ind str_ind c \"'0'\"\n | Lit_padding (Left, width) ->\n if legacy_behavior then Some width\n else incompatible_flag pct_ind str_ind c \"'-'\"\n | Arg_padding _ -> incompatible_flag pct_ind str_ind c \"'*'\"\n in\n let get_pad_opt c = opt_of_pad c (get_pad ()) in\n let get_padprec_opt c = opt_of_pad c (get_padprec ()) in\n\n (* Get precision as a prec_option (see \"%_f\").\n (no need for legacy mode tweaking, those were rejected by the\n legacy parser as well) *)\n let get_prec_opt () = match get_prec () with\n | No_precision -> None\n | Lit_precision ndec -> Some ndec\n | Arg_precision -> incompatible_flag pct_ind str_ind '_' \"'*'\"\n in\n\n let fmt_result = match symb with\n | ',' ->\n parse str_ind end_ind\n | 'c' ->\n let char_format fmt_rest = (* %c *)\n if get_ign ()\n then Fmt_EBB (Ignored_param (Ignored_char, fmt_rest))\n else Fmt_EBB (Char fmt_rest)\n in\n let scan_format fmt_rest = (* %0c *)\n if get_ign ()\n then Fmt_EBB (Ignored_param (Ignored_scan_next_char, fmt_rest))\n else Fmt_EBB (Scan_next_char fmt_rest)\n in\n let Fmt_EBB fmt_rest = parse str_ind end_ind in\n begin match get_pad_opt 'c' with\n | None -> char_format fmt_rest\n | Some 0 -> scan_format fmt_rest\n | Some _n ->\n if not legacy_behavior\n then invalid_nonnull_char_width str_ind\n else (* legacy ignores %c widths *) char_format fmt_rest\n end\n | 'C' ->\n let Fmt_EBB fmt_rest = parse str_ind end_ind in\n if get_ign () then Fmt_EBB (Ignored_param (Ignored_caml_char,fmt_rest))\n else Fmt_EBB (Caml_char fmt_rest)\n | 's' ->\n let pad = check_no_0 symb (get_padprec ()) in\n let Fmt_EBB fmt_rest = parse str_ind end_ind in\n if get_ign () then\n let ignored = Ignored_string (get_padprec_opt '_') in\n Fmt_EBB (Ignored_param (ignored, fmt_rest))\n else\n let Padding_fmt_EBB (pad', fmt_rest') =\n make_padding_fmt_ebb pad fmt_rest in\n Fmt_EBB (String (pad', fmt_rest'))\n | 'S' ->\n let pad = check_no_0 symb (get_padprec ()) in\n let Fmt_EBB fmt_rest = parse str_ind end_ind in\n if get_ign () then\n let ignored = Ignored_caml_string (get_padprec_opt '_') in\n Fmt_EBB (Ignored_param (ignored, fmt_rest))\n else\n let Padding_fmt_EBB (pad', fmt_rest') =\n make_padding_fmt_ebb pad fmt_rest in\n Fmt_EBB (Caml_string (pad', fmt_rest'))\n | 'd' | 'i' | 'x' | 'X' | 'o' | 'u' ->\n let iconv = compute_int_conv pct_ind str_ind (get_plus ()) (get_hash ())\n (get_space ()) symb in\n let Fmt_EBB fmt_rest = parse str_ind end_ind in\n if get_ign () then\n let ignored = Ignored_int (iconv, get_pad_opt '_') in\n Fmt_EBB (Ignored_param (ignored, fmt_rest))\n else\n let Padprec_fmt_EBB (pad', prec', fmt_rest') =\n make_padprec_fmt_ebb (get_int_pad ()) (get_prec ()) fmt_rest in\n Fmt_EBB (Int (iconv, pad', prec', fmt_rest'))\n | 'N' ->\n let Fmt_EBB fmt_rest = parse str_ind end_ind in\n let counter = Token_counter in\n if get_ign () then\n let ignored = Ignored_scan_get_counter counter in\n Fmt_EBB (Ignored_param (ignored, fmt_rest))\n else\n Fmt_EBB (Scan_get_counter (counter, fmt_rest))\n | 'l' | 'n' | 'L' when str_ind=end_ind || not (is_int_base str.[str_ind]) ->\n let Fmt_EBB fmt_rest = parse str_ind end_ind in\n let counter = counter_of_char symb in\n if get_ign () then\n let ignored = Ignored_scan_get_counter counter in\n Fmt_EBB (Ignored_param (ignored, fmt_rest))\n else\n Fmt_EBB (Scan_get_counter (counter, fmt_rest))\n | 'l' ->\n let iconv =\n compute_int_conv pct_ind (str_ind + 1) (get_plus ()) (get_hash ())\n (get_space ()) str.[str_ind] in\n let Fmt_EBB fmt_rest = parse (str_ind + 1) end_ind in\n if get_ign () then\n let ignored = Ignored_int32 (iconv, get_pad_opt '_') in\n Fmt_EBB (Ignored_param (ignored, fmt_rest))\n else\n let Padprec_fmt_EBB (pad', prec', fmt_rest') =\n make_padprec_fmt_ebb (get_int_pad ()) (get_prec ()) fmt_rest in\n Fmt_EBB (Int32 (iconv, pad', prec', fmt_rest'))\n | 'n' ->\n let iconv =\n compute_int_conv pct_ind (str_ind + 1) (get_plus ())\n (get_hash ()) (get_space ()) str.[str_ind] in\n let Fmt_EBB fmt_rest = parse (str_ind + 1) end_ind in\n if get_ign () then\n let ignored = Ignored_nativeint (iconv, get_pad_opt '_') in\n Fmt_EBB (Ignored_param (ignored, fmt_rest))\n else\n let Padprec_fmt_EBB (pad', prec', fmt_rest') =\n make_padprec_fmt_ebb (get_int_pad ()) (get_prec ()) fmt_rest in\n Fmt_EBB (Nativeint (iconv, pad', prec', fmt_rest'))\n | 'L' ->\n let iconv =\n compute_int_conv pct_ind (str_ind + 1) (get_plus ()) (get_hash ())\n (get_space ()) str.[str_ind] in\n let Fmt_EBB fmt_rest = parse (str_ind + 1) end_ind in\n if get_ign () then\n let ignored = Ignored_int64 (iconv, get_pad_opt '_') in\n Fmt_EBB (Ignored_param (ignored, fmt_rest))\n else\n let Padprec_fmt_EBB (pad', prec', fmt_rest') =\n make_padprec_fmt_ebb (get_int_pad ()) (get_prec ()) fmt_rest in\n Fmt_EBB (Int64 (iconv, pad', prec', fmt_rest'))\n | 'f' | 'e' | 'E' | 'g' | 'G' | 'F' | 'h' | 'H' ->\n let fconv =\n compute_float_conv pct_ind str_ind\n (get_plus ()) (get_hash ()) (get_space ()) symb in\n let Fmt_EBB fmt_rest = parse str_ind end_ind in\n if get_ign () then\n let ignored = Ignored_float (get_pad_opt '_', get_prec_opt ()) in\n Fmt_EBB (Ignored_param (ignored, fmt_rest))\n else\n let Padprec_fmt_EBB (pad', prec', fmt_rest') =\n make_padprec_fmt_ebb (get_pad ()) (get_prec ()) fmt_rest in\n Fmt_EBB (Float (fconv, pad', prec', fmt_rest'))\n | 'b' | 'B' ->\n let pad = check_no_0 symb (get_padprec ()) in\n let Fmt_EBB fmt_rest = parse str_ind end_ind in\n if get_ign () then\n let ignored = Ignored_bool (get_padprec_opt '_') in\n Fmt_EBB (Ignored_param (ignored, fmt_rest))\n else\n let Padding_fmt_EBB (pad', fmt_rest') =\n make_padding_fmt_ebb pad fmt_rest in\n Fmt_EBB (Bool (pad', fmt_rest'))\n | 'a' ->\n let Fmt_EBB fmt_rest = parse str_ind end_ind in\n Fmt_EBB (Alpha fmt_rest)\n | 't' ->\n let Fmt_EBB fmt_rest = parse str_ind end_ind in\n Fmt_EBB (Theta fmt_rest)\n | 'r' ->\n let Fmt_EBB fmt_rest = parse str_ind end_ind in\n if get_ign () then Fmt_EBB (Ignored_param (Ignored_reader, fmt_rest))\n else Fmt_EBB (Reader fmt_rest)\n | '!' ->\n let Fmt_EBB fmt_rest = parse str_ind end_ind in\n Fmt_EBB (Flush fmt_rest)\n | ('%' | '@') as c ->\n let Fmt_EBB fmt_rest = parse str_ind end_ind in\n Fmt_EBB (Char_literal (c, fmt_rest))\n | '{' ->\n let sub_end = search_subformat_end str_ind end_ind '}' in\n let Fmt_EBB sub_fmt = parse str_ind sub_end in\n let Fmt_EBB fmt_rest = parse (sub_end + 2) end_ind in\n let sub_fmtty = fmtty_of_fmt sub_fmt in\n if get_ign () then\n let ignored = Ignored_format_arg (get_pad_opt '_', sub_fmtty) in\n Fmt_EBB (Ignored_param (ignored, fmt_rest))\n else\n Fmt_EBB (Format_arg (get_pad_opt '{', sub_fmtty, fmt_rest))\n | '(' ->\n let sub_end = search_subformat_end str_ind end_ind ')' in\n let Fmt_EBB fmt_rest = parse (sub_end + 2) end_ind in\n let Fmt_EBB sub_fmt = parse str_ind sub_end in\n let sub_fmtty = fmtty_of_fmt sub_fmt in\n if get_ign () then\n let ignored = Ignored_format_subst (get_pad_opt '_', sub_fmtty) in\n Fmt_EBB (Ignored_param (ignored, fmt_rest))\n else\n Fmt_EBB (Format_subst (get_pad_opt '(', sub_fmtty, fmt_rest))\n | '[' ->\n let next_ind, char_set = parse_char_set str_ind end_ind in\n let Fmt_EBB fmt_rest = parse next_ind end_ind in\n if get_ign () then\n let ignored = Ignored_scan_char_set (get_pad_opt '_', char_set) in\n Fmt_EBB (Ignored_param (ignored, fmt_rest))\n else\n Fmt_EBB (Scan_char_set (get_pad_opt '[', char_set, fmt_rest))\n | '-' | '+' | '#' | ' ' | '_' ->\n failwith_message\n \"invalid format %S: at character number %d, \\\n flag %C is only allowed after the '%%', before padding and precision\"\n str pct_ind symb\n | _ ->\n failwith_message\n \"invalid format %S: at character number %d, \\\n invalid conversion \\\"%%%c\\\"\" str (str_ind - 1) symb\n in\n (* Check for unused options, and reject them as incompatible.\n\n Such checks need to be disabled in legacy mode, as the legacy\n parser silently ignored incompatible flags. *)\n if not legacy_behavior then begin\n if not !plus_used && plus then\n incompatible_flag pct_ind str_ind symb \"'+'\";\n if not !hash_used && hash then\n incompatible_flag pct_ind str_ind symb \"'#'\";\n if not !space_used && space then\n incompatible_flag pct_ind str_ind symb \"' '\";\n if not !pad_used && Padding_EBB pad <> Padding_EBB No_padding then\n incompatible_flag pct_ind str_ind symb \"`padding'\";\n if not !prec_used && Precision_EBB prec <> Precision_EBB No_precision then\n incompatible_flag pct_ind str_ind (if ign then '_' else symb)\n \"`precision'\";\n if ign && plus then incompatible_flag pct_ind str_ind '_' \"'+'\";\n end;\n (* this last test must not be disabled in legacy mode,\n as ignoring it would typically result in a different typing\n than what the legacy parser used *)\n if not !ign_used && ign then\n begin match symb with\n (* argument-less formats can safely be ignored in legacy mode *)\n | ('@' | '%' | '!' | ',') when legacy_behavior -> ()\n | _ ->\n incompatible_flag pct_ind str_ind symb \"'_'\"\n end;\n fmt_result\n\n (* Parse formatting information (after '@'). *)\n and parse_after_at : type e f . int -> int -> (_, _, e, f) fmt_ebb =\n fun str_ind end_ind ->\n if str_ind = end_ind then Fmt_EBB (Char_literal ('@', End_of_format))\n else\n match str.[str_ind] with\n | '[' ->\n parse_tag false (str_ind + 1) end_ind\n | ']' ->\n let Fmt_EBB fmt_rest = parse (str_ind + 1) end_ind in\n Fmt_EBB (Formatting_lit (Close_box, fmt_rest))\n | '{' ->\n parse_tag true (str_ind + 1) end_ind\n | '}' ->\n let Fmt_EBB fmt_rest = parse (str_ind + 1) end_ind in\n Fmt_EBB (Formatting_lit (Close_tag, fmt_rest))\n | ',' ->\n let Fmt_EBB fmt_rest = parse (str_ind + 1) end_ind in\n Fmt_EBB (Formatting_lit (Break (\"@,\", 0, 0), fmt_rest))\n | ' ' ->\n let Fmt_EBB fmt_rest = parse (str_ind + 1) end_ind in\n Fmt_EBB (Formatting_lit (Break (\"@ \", 1, 0), fmt_rest))\n | ';' ->\n parse_good_break (str_ind + 1) end_ind\n | '?' ->\n let Fmt_EBB fmt_rest = parse (str_ind + 1) end_ind in\n Fmt_EBB (Formatting_lit (FFlush, fmt_rest))\n | '\\n' ->\n let Fmt_EBB fmt_rest = parse (str_ind + 1) end_ind in\n Fmt_EBB (Formatting_lit (Force_newline, fmt_rest))\n | '.' ->\n let Fmt_EBB fmt_rest = parse (str_ind + 1) end_ind in\n Fmt_EBB (Formatting_lit (Flush_newline, fmt_rest))\n | '<' ->\n parse_magic_size (str_ind + 1) end_ind\n | '@' ->\n let Fmt_EBB fmt_rest = parse (str_ind + 1) end_ind in\n Fmt_EBB (Formatting_lit (Escaped_at, fmt_rest))\n | '%' when str_ind + 1 < end_ind && str.[str_ind + 1] = '%' ->\n let Fmt_EBB fmt_rest = parse (str_ind + 2) end_ind in\n Fmt_EBB (Formatting_lit (Escaped_percent, fmt_rest))\n | '%' ->\n let Fmt_EBB fmt_rest = parse str_ind end_ind in\n Fmt_EBB (Char_literal ('@', fmt_rest))\n | c ->\n let Fmt_EBB fmt_rest = parse (str_ind + 1) end_ind in\n Fmt_EBB (Formatting_lit (Scan_indic c, fmt_rest))\n\n (* Try to read the optional after \"@{\" or \"@[\". *)\n and parse_tag : type e f . bool -> int -> int -> (_, _, e, f) fmt_ebb =\n fun is_open_tag str_ind end_ind ->\n try\n if str_ind = end_ind then raise Not_found;\n match str.[str_ind] with\n | '<' ->\n let ind = String.index_from str (str_ind + 1) '>' in\n if ind >= end_ind then raise Not_found;\n let sub_str = String.sub str str_ind (ind - str_ind + 1) in\n let Fmt_EBB fmt_rest = parse (ind + 1) end_ind in\n let Fmt_EBB sub_fmt = parse str_ind (ind + 1) in\n let sub_format = Format (sub_fmt, sub_str) in\n let formatting =\n if is_open_tag then Open_tag sub_format else Open_box sub_format in\n Fmt_EBB (Formatting_gen (formatting, fmt_rest))\n | _ ->\n raise Not_found\n with Not_found ->\n let Fmt_EBB fmt_rest = parse str_ind end_ind in\n let sub_format = Format (End_of_format, \"\") in\n let formatting =\n if is_open_tag then Open_tag sub_format else Open_box sub_format in\n Fmt_EBB (Formatting_gen (formatting, fmt_rest))\n\n (* Try to read the optional after \"@;\". *)\n and parse_good_break : type e f . int -> int -> (_, _, e, f) fmt_ebb =\n fun str_ind end_ind ->\n let next_ind, formatting_lit =\n try\n if str_ind = end_ind || str.[str_ind] <> '<' then raise Not_found;\n let str_ind_1 = parse_spaces (str_ind + 1) end_ind in\n match str.[str_ind_1] with\n | '0' .. '9' | '-' -> (\n let str_ind_2, width = parse_integer str_ind_1 end_ind in\n let str_ind_3 = parse_spaces str_ind_2 end_ind in\n match str.[str_ind_3] with\n | '>' ->\n let s = String.sub str (str_ind-2) (str_ind_3-str_ind+3) in\n str_ind_3 + 1, Break (s, width, 0)\n | '0' .. '9' | '-' ->\n let str_ind_4, offset = parse_integer str_ind_3 end_ind in\n let str_ind_5 = parse_spaces str_ind_4 end_ind in\n if str.[str_ind_5] <> '>' then raise Not_found;\n let s = String.sub str (str_ind-2) (str_ind_5-str_ind+3) in\n str_ind_5 + 1, Break (s, width, offset)\n | _ -> raise Not_found\n )\n | _ -> raise Not_found\n with Not_found | Failure _ ->\n str_ind, Break (\"@;\", 1, 0)\n in\n let Fmt_EBB fmt_rest = parse next_ind end_ind in\n Fmt_EBB (Formatting_lit (formatting_lit, fmt_rest))\n\n (* Parse the size in a . *)\n and parse_magic_size : type e f . int -> int -> (_, _, e, f) fmt_ebb =\n fun str_ind end_ind ->\n match\n try\n let str_ind_1 = parse_spaces str_ind end_ind in\n match str.[str_ind_1] with\n | '0' .. '9' | '-' ->\n let str_ind_2, size = parse_integer str_ind_1 end_ind in\n let str_ind_3 = parse_spaces str_ind_2 end_ind in\n if str.[str_ind_3] <> '>' then raise Not_found;\n let s = String.sub str (str_ind - 2) (str_ind_3 - str_ind + 3) in\n Some (str_ind_3 + 1, Magic_size (s, size))\n | _ -> None\n with Not_found | Failure _ ->\n None\n with\n | Some (next_ind, formatting_lit) ->\n let Fmt_EBB fmt_rest = parse next_ind end_ind in\n Fmt_EBB (Formatting_lit (formatting_lit, fmt_rest))\n | None ->\n let Fmt_EBB fmt_rest = parse str_ind end_ind in\n Fmt_EBB (Formatting_lit (Scan_indic '<', fmt_rest))\n\n (* Parse and construct a char set. *)\n and parse_char_set str_ind end_ind =\n if str_ind = end_ind then unexpected_end_of_format end_ind;\n\n let char_set = create_char_set () in\n let add_char c =\n add_in_char_set char_set c;\n in\n let add_range c c' =\n for i = int_of_char c to int_of_char c' do\n add_in_char_set char_set (char_of_int i);\n done;\n in\n\n let fail_single_percent str_ind =\n failwith_message\n \"invalid format %S: '%%' alone is not accepted in character sets, \\\n use %%%% instead at position %d.\" str str_ind\n in\n\n (* Parse the first character of a char set. *)\n let rec parse_char_set_start str_ind end_ind =\n if str_ind = end_ind then unexpected_end_of_format end_ind;\n let c = str.[str_ind] in\n parse_char_set_after_char (str_ind + 1) end_ind c\n\n (* Parse the content of a char set until the first ']'. *)\n and parse_char_set_content str_ind end_ind =\n if str_ind = end_ind then unexpected_end_of_format end_ind;\n match str.[str_ind] with\n | ']' ->\n str_ind + 1\n | '-' ->\n add_char '-';\n parse_char_set_content (str_ind + 1) end_ind\n | c ->\n parse_char_set_after_char (str_ind + 1) end_ind c\n\n (* Test for range in char set. *)\n and parse_char_set_after_char str_ind end_ind c =\n if str_ind = end_ind then unexpected_end_of_format end_ind;\n match str.[str_ind] with\n | ']' ->\n add_char c;\n str_ind + 1\n | '-' ->\n parse_char_set_after_minus (str_ind + 1) end_ind c\n | ('%' | '@') as c' when c = '%' ->\n add_char c';\n parse_char_set_content (str_ind + 1) end_ind\n | c' ->\n if c = '%' then fail_single_percent str_ind;\n (* note that '@' alone is accepted, as done by the legacy\n implementation; the documentation specifically requires %@\n so we could warn on that *)\n add_char c;\n parse_char_set_after_char (str_ind + 1) end_ind c'\n\n (* Manage range in char set (except if the '-' the last char before ']') *)\n and parse_char_set_after_minus str_ind end_ind c =\n if str_ind = end_ind then unexpected_end_of_format end_ind;\n match str.[str_ind] with\n | ']' ->\n add_char c;\n add_char '-';\n str_ind + 1\n | '%' ->\n if str_ind + 1 = end_ind then unexpected_end_of_format end_ind;\n begin match str.[str_ind + 1] with\n | ('%' | '@') as c' ->\n add_range c c';\n parse_char_set_content (str_ind + 2) end_ind\n | _ -> fail_single_percent str_ind\n end\n | c' ->\n add_range c c';\n parse_char_set_content (str_ind + 1) end_ind\n in\n let str_ind, reverse =\n if str_ind = end_ind then unexpected_end_of_format end_ind;\n match str.[str_ind] with\n | '^' -> str_ind + 1, true\n | _ -> str_ind, false in\n let next_ind = parse_char_set_start str_ind end_ind in\n let char_set = freeze_char_set char_set in\n next_ind, (if reverse then rev_char_set char_set else char_set)\n\n (* Consume all next spaces, raise an Failure if end_ind is reached. *)\n and parse_spaces str_ind end_ind =\n if str_ind = end_ind then unexpected_end_of_format end_ind;\n if str.[str_ind] = ' ' then parse_spaces (str_ind + 1) end_ind else str_ind\n\n (* Read a positive integer from the string, raise a Failure if end_ind is\n reached. *)\n and parse_positive str_ind end_ind acc =\n if str_ind = end_ind then unexpected_end_of_format end_ind;\n match str.[str_ind] with\n | '0' .. '9' as c ->\n let new_acc = acc * 10 + (int_of_char c - int_of_char '0') in\n if new_acc > Sys.max_string_length then\n failwith_message\n \"invalid format %S: integer %d is greater than the limit %d\"\n str new_acc Sys.max_string_length\n else\n parse_positive (str_ind + 1) end_ind new_acc\n | _ -> str_ind, acc\n\n (* Read a positive or negative integer from the string, raise a Failure\n if end_ind is reached. *)\n and parse_integer str_ind end_ind =\n if str_ind = end_ind then unexpected_end_of_format end_ind;\n match str.[str_ind] with\n | '0' .. '9' -> parse_positive str_ind end_ind 0\n | '-' -> (\n if str_ind + 1 = end_ind then unexpected_end_of_format end_ind;\n match str.[str_ind + 1] with\n | '0' .. '9' ->\n let next_ind, n = parse_positive (str_ind + 1) end_ind 0 in\n next_ind, -n\n | c ->\n expected_character (str_ind + 1) \"digit\" c\n )\n | _ -> assert false\n\n (* Add a literal to a format from a literal character sub-sequence. *)\n and add_literal : type a d e f .\n int -> int -> (a, _, _, d, e, f) fmt ->\n (_, _, e, f) fmt_ebb =\n fun lit_start str_ind fmt -> match str_ind - lit_start with\n | 0 -> Fmt_EBB fmt\n | 1 -> Fmt_EBB (Char_literal (str.[lit_start], fmt))\n | size -> Fmt_EBB (String_literal (String.sub str lit_start size, fmt))\n\n (* Search the end of the current sub-format\n (i.e. the corresponding \"%}\" or \"%)\") *)\n and search_subformat_end str_ind end_ind c =\n if str_ind = end_ind then\n failwith_message\n \"invalid format %S: unclosed sub-format, \\\n expected \\\"%%%c\\\" at character number %d\" str c end_ind;\n match str.[str_ind] with\n | '%' ->\n if str_ind + 1 = end_ind then unexpected_end_of_format end_ind;\n if str.[str_ind + 1] = c then (* End of format found *) str_ind else\n begin match str.[str_ind + 1] with\n | '_' ->\n (* Search for \"%_(\" or \"%_{\". *)\n if str_ind + 2 = end_ind then unexpected_end_of_format end_ind;\n begin match str.[str_ind + 2] with\n | '{' ->\n let sub_end = search_subformat_end (str_ind + 3) end_ind '}' in\n search_subformat_end (sub_end + 2) end_ind c\n | '(' ->\n let sub_end = search_subformat_end (str_ind + 3) end_ind ')' in\n search_subformat_end (sub_end + 2) end_ind c\n | _ -> search_subformat_end (str_ind + 3) end_ind c\n end\n | '{' ->\n (* %{...%} sub-format found. *)\n let sub_end = search_subformat_end (str_ind + 2) end_ind '}' in\n search_subformat_end (sub_end + 2) end_ind c\n | '(' ->\n (* %(...%) sub-format found. *)\n let sub_end = search_subformat_end (str_ind + 2) end_ind ')' in\n search_subformat_end (sub_end + 2) end_ind c\n | '}' ->\n (* Error: %(...%}. *)\n expected_character (str_ind + 1) \"character ')'\" '}'\n | ')' ->\n (* Error: %{...%). *)\n expected_character (str_ind + 1) \"character '}'\" ')'\n | _ ->\n search_subformat_end (str_ind + 2) end_ind c\n end\n | _ -> search_subformat_end (str_ind + 1) end_ind c\n\n (* Check if symb is a valid int conversion after \"%l\", \"%n\" or \"%L\" *)\n and is_int_base symb = match symb with\n | 'd' | 'i' | 'x' | 'X' | 'o' | 'u' -> true\n | _ -> false\n\n (* Convert a char (l, n or L) to its associated counter. *)\n and counter_of_char symb = match symb with\n | 'l' -> Line_counter | 'n' -> Char_counter\n | 'L' -> Token_counter | _ -> assert false\n\n (* Convert (plus, symb) to its associated int_conv. *)\n and compute_int_conv pct_ind str_ind plus hash space symb =\n match plus, hash, space, symb with\n | false, false, false, 'd' -> Int_d | false, false, false, 'i' -> Int_i\n | false, false, true, 'd' -> Int_sd | false, false, true, 'i' -> Int_si\n | true, false, false, 'd' -> Int_pd | true, false, false, 'i' -> Int_pi\n | false, false, false, 'x' -> Int_x | false, false, false, 'X' -> Int_X\n | false, true, false, 'x' -> Int_Cx | false, true, false, 'X' -> Int_CX\n | false, false, false, 'o' -> Int_o\n | false, true, false, 'o' -> Int_Co\n | false, false, false, 'u' -> Int_u\n | false, true, false, 'd' -> Int_Cd\n | false, true, false, 'i' -> Int_Ci\n | false, true, false, 'u' -> Int_Cu\n | _, true, _, 'x' when legacy_behavior -> Int_Cx\n | _, true, _, 'X' when legacy_behavior -> Int_CX\n | _, true, _, 'o' when legacy_behavior -> Int_Co\n | _, true, _, ('d' | 'i' | 'u') ->\n if legacy_behavior then (* ignore *)\n compute_int_conv pct_ind str_ind plus false space symb\n else incompatible_flag pct_ind str_ind symb \"'#'\"\n | true, _, true, _ ->\n if legacy_behavior then\n (* plus and space: legacy implementation prefers plus *)\n compute_int_conv pct_ind str_ind plus hash false symb\n else incompatible_flag pct_ind str_ind ' ' \"'+'\"\n | false, _, true, _ ->\n if legacy_behavior then (* ignore *)\n compute_int_conv pct_ind str_ind plus hash false symb\n else incompatible_flag pct_ind str_ind symb \"' '\"\n | true, _, false, _ ->\n if legacy_behavior then (* ignore *)\n compute_int_conv pct_ind str_ind false hash space symb\n else incompatible_flag pct_ind str_ind symb \"'+'\"\n | false, _, false, _ -> assert false\n\n (* Convert (plus, space, symb) to its associated float_conv. *)\n and compute_float_conv pct_ind str_ind plus hash space symb =\n let flag = match plus, space with\n | false, false -> Float_flag_\n | false, true -> Float_flag_s\n | true, false -> Float_flag_p\n | true, true ->\n (* plus and space: legacy implementation prefers plus *)\n if legacy_behavior then Float_flag_p\n else incompatible_flag pct_ind str_ind ' ' \"'+'\" in\n let kind = match hash, symb with\n | _, 'f' -> Float_f\n | _, 'e' -> Float_e\n | _, 'E' -> Float_E\n | _, 'g' -> Float_g\n | _, 'G' -> Float_G\n | _, 'h' -> Float_h\n | _, 'H' -> Float_H\n | false, 'F' -> Float_F\n | true, 'F' -> Float_CF\n | _ -> assert false in\n flag, kind\n\n (* Raise [Failure] with a friendly error message about incompatible options.*)\n and incompatible_flag : type a . int -> int -> char -> string -> a =\n fun pct_ind str_ind symb option ->\n let subfmt = String.sub str pct_ind (str_ind - pct_ind) in\n failwith_message\n \"invalid format %S: at character number %d, \\\n %s is incompatible with '%c' in sub-format %S\"\n str pct_ind option symb subfmt\n\n in parse 0 (String.length str)\n\n(******************************************************************************)\n (* Guarded string to format conversions *)\n\n(* Convert a string to a format according to an fmtty. *)\n(* Raise [Failure] with an error message in case of type mismatch. *)\nlet format_of_string_fmtty str fmtty =\n let Fmt_EBB fmt = fmt_ebb_of_string str in\n try Format (type_format fmt fmtty, str)\n with Type_mismatch ->\n failwith_message\n \"bad input: format type mismatch between %S and %S\"\n str (string_of_fmtty fmtty)\n\n(* Convert a string to a format compatible with an other format. *)\n(* Raise [Failure] with an error message in case of type mismatch. *)\nlet format_of_string_format str (Format (fmt', str')) =\n let Fmt_EBB fmt = fmt_ebb_of_string str in\n try Format (type_format fmt (fmtty_of_fmt fmt'), str)\n with Type_mismatch ->\n failwith_message\n \"bad input: format type mismatch between %S and %S\" str str'\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nopen Printf\n\ntype t = exn = ..\n\nlet printers = Atomic.make []\n\nlet locfmt = format_of_string \"File \\\"%s\\\", line %d, characters %d-%d: %s\"\n\nlet field x i =\n let f = Obj.field x i in\n if not (Obj.is_block f) then\n sprintf \"%d\" (Obj.magic f : int) (* can also be a char *)\n else if Obj.tag f = Obj.string_tag then\n sprintf \"%S\" (Obj.magic f : string)\n else if Obj.tag f = Obj.double_tag then\n string_of_float (Obj.magic f : float)\n else\n \"_\"\n\nlet rec other_fields x i =\n if i >= Obj.size x then \"\"\n else sprintf \", %s%s\" (field x i) (other_fields x (i+1))\n\nlet fields x =\n match Obj.size x with\n | 0 -> \"\"\n | 1 -> \"\"\n | 2 -> sprintf \"(%s)\" (field x 1)\n | _ -> sprintf \"(%s%s)\" (field x 1) (other_fields x 2)\n\nlet use_printers x =\n let rec conv = function\n | hd :: tl ->\n (match hd x with\n | None | exception _ -> conv tl\n | Some s -> Some s)\n | [] -> None in\n conv (Atomic.get printers)\n\nlet to_string_default = function\n | Out_of_memory -> \"Out of memory\"\n | Stack_overflow -> \"Stack overflow\"\n | Match_failure(file, line, char) ->\n sprintf locfmt file line char (char+5) \"Pattern matching failed\"\n | Assert_failure(file, line, char) ->\n sprintf locfmt file line char (char+6) \"Assertion failed\"\n | Undefined_recursive_module(file, line, char) ->\n sprintf locfmt file line char (char+6) \"Undefined recursive module\"\n | x ->\n let x = Obj.repr x in\n if Obj.tag x <> 0 then\n (Obj.magic (Obj.field x 0) : string)\n else\n let constructor =\n (Obj.magic (Obj.field (Obj.field x 0) 0) : string) in\n constructor ^ (fields x)\n\nlet to_string e =\n match use_printers e with\n | Some s -> s\n | None -> to_string_default e\n\nlet print fct arg =\n try\n fct arg\n with x ->\n eprintf \"Uncaught exception: %s\\n\" (to_string x);\n flush stderr;\n raise x\n\nlet catch fct arg =\n try\n fct arg\n with x ->\n flush stdout;\n eprintf \"Uncaught exception: %s\\n\" (to_string x);\n exit 2\n\ntype raw_backtrace_slot\ntype raw_backtrace_entry = private int\ntype raw_backtrace = raw_backtrace_entry array\n\nlet raw_backtrace_entries bt = bt\n\nexternal get_raw_backtrace:\n unit -> raw_backtrace = \"caml_get_exception_raw_backtrace\"\n\nexternal raise_with_backtrace: exn -> raw_backtrace -> 'a\n = \"%raise_with_backtrace\"\n\ntype backtrace_slot =\n | Known_location of {\n is_raise : bool;\n filename : string;\n line_number : int;\n start_char : int;\n end_char : int;\n is_inline : bool;\n defname : string;\n }\n | Unknown_location of {\n is_raise : bool\n }\n\n(* to avoid warning *)\nlet _ = [Known_location { is_raise = false; filename = \"\";\n line_number = 0; start_char = 0; end_char = 0;\n is_inline = false; defname = \"\" };\n Unknown_location { is_raise = false }]\n\nexternal convert_raw_backtrace_slot:\n raw_backtrace_slot -> backtrace_slot = \"caml_convert_raw_backtrace_slot\"\n\nexternal convert_raw_backtrace:\n raw_backtrace -> backtrace_slot array = \"caml_convert_raw_backtrace\"\n\nlet convert_raw_backtrace bt =\n try Some (convert_raw_backtrace bt)\n with Failure _ -> None\n\nlet format_backtrace_slot pos slot =\n let info is_raise =\n if is_raise then\n if pos = 0 then \"Raised at\" else \"Re-raised at\"\n else\n if pos = 0 then \"Raised by primitive operation at\" else \"Called from\"\n in\n match slot with\n | Unknown_location l ->\n if l.is_raise then\n (* compiler-inserted re-raise, skipped *) None\n else\n Some (sprintf \"%s unknown location\" (info false))\n | Known_location l ->\n Some (sprintf \"%s %s in file \\\"%s\\\"%s, line %d, characters %d-%d\"\n (info l.is_raise) l.defname l.filename\n (if l.is_inline then \" (inlined)\" else \"\")\n l.line_number l.start_char l.end_char)\n\nlet print_exception_backtrace outchan backtrace =\n match backtrace with\n | None ->\n fprintf outchan\n \"(Program not linked with -g, cannot print stack backtrace)\\n\"\n | Some a ->\n for i = 0 to Array.length a - 1 do\n match format_backtrace_slot i a.(i) with\n | None -> ()\n | Some str -> fprintf outchan \"%s\\n\" str\n done\n\nlet print_raw_backtrace outchan raw_backtrace =\n print_exception_backtrace outchan (convert_raw_backtrace raw_backtrace)\n\n(* confusingly named: prints the global current backtrace *)\nlet print_backtrace outchan =\n print_raw_backtrace outchan (get_raw_backtrace ())\n\nlet backtrace_to_string backtrace =\n match backtrace with\n | None ->\n \"(Program not linked with -g, cannot print stack backtrace)\\n\"\n | Some a ->\n let b = Buffer.create 1024 in\n for i = 0 to Array.length a - 1 do\n match format_backtrace_slot i a.(i) with\n | None -> ()\n | Some str -> bprintf b \"%s\\n\" str\n done;\n Buffer.contents b\n\nlet raw_backtrace_to_string raw_backtrace =\n backtrace_to_string (convert_raw_backtrace raw_backtrace)\n\nlet backtrace_slot_is_raise = function\n | Known_location l -> l.is_raise\n | Unknown_location l -> l.is_raise\n\nlet backtrace_slot_is_inline = function\n | Known_location l -> l.is_inline\n | Unknown_location _ -> false\n\ntype location = {\n filename : string;\n line_number : int;\n start_char : int;\n end_char : int;\n}\n\nlet backtrace_slot_location = function\n | Unknown_location _ -> None\n | Known_location l ->\n Some {\n filename = l.filename;\n line_number = l.line_number;\n start_char = l.start_char;\n end_char = l.end_char;\n }\n\nlet backtrace_slot_defname = function\n | Unknown_location _\n | Known_location { defname = \"\" } -> None\n | Known_location l -> Some l.defname\n\nlet backtrace_slots raw_backtrace =\n (* The documentation of this function guarantees that Some is\n returned only if a part of the trace is usable. This gives us\n a bit more work than just convert_raw_backtrace, but it makes the\n API more user-friendly -- otherwise most users would have to\n reimplement the \"Program not linked with -g, sorry\" logic\n themselves. *)\n match convert_raw_backtrace raw_backtrace with\n | None -> None\n | Some backtrace ->\n let usable_slot = function\n | Unknown_location _ -> false\n | Known_location _ -> true in\n let rec exists_usable = function\n | (-1) -> false\n | i -> usable_slot backtrace.(i) || exists_usable (i - 1) in\n if exists_usable (Array.length backtrace - 1)\n then Some backtrace\n else None\n\nlet backtrace_slots_of_raw_entry entry =\n backtrace_slots [| entry |]\n\nmodule Slot = struct\n type t = backtrace_slot\n let format = format_backtrace_slot\n let is_raise = backtrace_slot_is_raise\n let is_inline = backtrace_slot_is_inline\n let location = backtrace_slot_location\n let name = backtrace_slot_defname\nend\n\nlet raw_backtrace_length bt = Array.length bt\n\nexternal get_raw_backtrace_slot :\n raw_backtrace -> int -> raw_backtrace_slot = \"caml_raw_backtrace_slot\"\n\nexternal get_raw_backtrace_next_slot :\n raw_backtrace_slot -> raw_backtrace_slot option\n = \"caml_raw_backtrace_next_slot\"\n\n(* confusingly named:\n returns the *string* corresponding to the global current backtrace *)\nlet get_backtrace () = raw_backtrace_to_string (get_raw_backtrace ())\n\nexternal record_backtrace: bool -> unit = \"caml_record_backtrace\"\nexternal backtrace_status: unit -> bool = \"caml_backtrace_status\"\n\nlet rec register_printer fn =\n let old_printers = Atomic.get printers in\n let new_printers = fn :: old_printers in\n let success = Atomic.compare_and_set printers old_printers new_printers in\n if not success then register_printer fn\n\nexternal get_callstack: int -> raw_backtrace = \"caml_get_current_callstack\"\n\nlet exn_slot x =\n let x = Obj.repr x in\n if Obj.tag x = 0 then Obj.field x 0 else x\n\nlet exn_slot_id x =\n let slot = exn_slot x in\n (Obj.obj (Obj.field slot 1) : int)\n\nlet exn_slot_name x =\n let slot = exn_slot x in\n (Obj.obj (Obj.field slot 0) : string)\n\nexternal get_debug_info_status : unit -> int = \"caml_ml_debug_info_status\"\n\n(* Descriptions for errors in startup.h. See also backtrace.c *)\nlet errors = [| \"\";\n (* FILE_NOT_FOUND *)\n \"(Cannot print locations:\\n \\\n bytecode executable program file not found)\";\n (* BAD_BYTECODE *)\n \"(Cannot print locations:\\n \\\n bytecode executable program file appears to be corrupt)\";\n (* WRONG_MAGIC *)\n \"(Cannot print locations:\\n \\\n bytecode executable program file has wrong magic number)\";\n (* NO_FDS *)\n \"(Cannot print locations:\\n \\\n bytecode executable program file cannot be opened;\\n \\\n -- too many open files. Try running with OCAMLRUNPARAM=b=2)\"\n|]\n\nlet default_uncaught_exception_handler exn raw_backtrace =\n eprintf \"Fatal error: exception %s\\n\" (to_string exn);\n print_raw_backtrace stderr raw_backtrace;\n let status = get_debug_info_status () in\n if status < 0 then\n prerr_endline errors.(abs status);\n flush stderr\n\nlet uncaught_exception_handler = ref default_uncaught_exception_handler\n\nlet set_uncaught_exception_handler fn = uncaught_exception_handler := fn\n\nlet empty_backtrace : raw_backtrace = [| |]\n\nlet try_get_raw_backtrace () =\n try\n get_raw_backtrace ()\n with _ (* Out_of_memory? *) ->\n empty_backtrace\n\nlet handle_uncaught_exception' exn debugger_in_use =\n try\n (* Get the backtrace now, in case one of the [at_exit] function\n destroys it. *)\n let raw_backtrace =\n if debugger_in_use (* Same test as in [runtime/printexc.c] *) then\n empty_backtrace\n else\n try_get_raw_backtrace ()\n in\n (try Stdlib.do_at_exit () with _ -> ());\n try\n !uncaught_exception_handler exn raw_backtrace\n with exn' ->\n let raw_backtrace' = try_get_raw_backtrace () in\n eprintf \"Fatal error: exception %s\\n\" (to_string exn);\n print_raw_backtrace stderr raw_backtrace;\n eprintf \"Fatal error in uncaught exception handler: exception %s\\n\"\n (to_string exn');\n print_raw_backtrace stderr raw_backtrace';\n flush stderr\n with\n | Out_of_memory ->\n prerr_endline\n \"Fatal error: out of memory in uncaught exception handler\"\n\n(* This function is called by [caml_fatal_uncaught_exception] in\n [runtime/printexc.c] which expects no exception is raised. *)\nlet handle_uncaught_exception exn debugger_in_use =\n try\n handle_uncaught_exception' exn debugger_in_use\n with _ ->\n (* There is not much we can do at this point *)\n ()\n\nexternal register_named_value : string -> 'a -> unit\n = \"caml_register_named_value\"\n\nlet () =\n register_named_value \"Printexc.handle_uncaught_exception\"\n handle_uncaught_exception\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy and Damien Doligez, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nlet generic_quote quotequote s =\n let l = String.length s in\n let b = Buffer.create (l + 20) in\n Buffer.add_char b '\\'';\n for i = 0 to l - 1 do\n if s.[i] = '\\''\n then Buffer.add_string b quotequote\n else Buffer.add_char b s.[i]\n done;\n Buffer.add_char b '\\'';\n Buffer.contents b\n\n(* This function implements the Open Group specification found here:\n [[1]] http://pubs.opengroup.org/onlinepubs/9699919799/utilities/basename.html\n In step 1 of [[1]], we choose to return \".\" for empty input.\n (for compatibility with previous versions of OCaml)\n In step 2, we choose to process \"//\" normally.\n Step 6 is not implemented: we consider that the [suffix] operand is\n always absent. Suffixes are handled by [chop_suffix] and [chop_extension].\n*)\nlet generic_basename is_dir_sep current_dir_name name =\n let rec find_end n =\n if n < 0 then String.sub name 0 1\n else if is_dir_sep name n then find_end (n - 1)\n else find_beg n (n + 1)\n and find_beg n p =\n if n < 0 then String.sub name 0 p\n else if is_dir_sep name n then String.sub name (n + 1) (p - n - 1)\n else find_beg (n - 1) p\n in\n if name = \"\"\n then current_dir_name\n else find_end (String.length name - 1)\n\n(* This function implements the Open Group specification found here:\n [[2]] http://pubs.opengroup.org/onlinepubs/9699919799/utilities/dirname.html\n In step 6 of [[2]], we choose to process \"//\" normally.\n*)\nlet generic_dirname is_dir_sep current_dir_name name =\n let rec trailing_sep n =\n if n < 0 then String.sub name 0 1\n else if is_dir_sep name n then trailing_sep (n - 1)\n else base n\n and base n =\n if n < 0 then current_dir_name\n else if is_dir_sep name n then intermediate_sep n\n else base (n - 1)\n and intermediate_sep n =\n if n < 0 then String.sub name 0 1\n else if is_dir_sep name n then intermediate_sep (n - 1)\n else String.sub name 0 (n + 1)\n in\n if name = \"\"\n then current_dir_name\n else trailing_sep (String.length name - 1)\n\nmodule type SYSDEPS = sig\n val null : string\n val current_dir_name : string\n val parent_dir_name : string\n val dir_sep : string\n val is_dir_sep : string -> int -> bool\n val is_relative : string -> bool\n val is_implicit : string -> bool\n val check_suffix : string -> string -> bool\n val chop_suffix_opt : suffix:string -> string -> string option\n val temp_dir_name : string\n val quote : string -> string\n val quote_command :\n string -> ?stdin: string -> ?stdout: string -> ?stderr: string\n -> string list -> string\n val basename : string -> string\n val dirname : string -> string\nend\n\nmodule Unix : SYSDEPS = struct\n let null = \"/dev/null\"\n let current_dir_name = \".\"\n let parent_dir_name = \"..\"\n let dir_sep = \"/\"\n let is_dir_sep s i = s.[i] = '/'\n let is_relative n = String.length n < 1 || n.[0] <> '/'\n let is_implicit n =\n is_relative n\n && (String.length n < 2 || String.sub n 0 2 <> \"./\")\n && (String.length n < 3 || String.sub n 0 3 <> \"../\")\n let check_suffix name suff =\n String.ends_with ~suffix:suff name\n\n let chop_suffix_opt ~suffix filename =\n let len_s = String.length suffix and len_f = String.length filename in\n if len_f >= len_s then\n let r = String.sub filename (len_f - len_s) len_s in\n if r = suffix then\n Some (String.sub filename 0 (len_f - len_s))\n else\n None\n else\n None\n\n let temp_dir_name =\n try Sys.getenv \"TMPDIR\" with Not_found -> \"/tmp\"\n let quote = generic_quote \"'\\\\''\"\n let quote_command cmd ?stdin ?stdout ?stderr args =\n String.concat \" \" (List.map quote (cmd :: args))\n ^ (match stdin with None -> \"\" | Some f -> \" <\" ^ quote f)\n ^ (match stdout with None -> \"\" | Some f -> \" >\" ^ quote f)\n ^ (match stderr with None -> \"\" | Some f -> if stderr = stdout\n then \" 2>&1\"\n else \" 2>\" ^ quote f)\n let basename = generic_basename is_dir_sep current_dir_name\n let dirname = generic_dirname is_dir_sep current_dir_name\nend\n\nmodule Win32 : SYSDEPS = struct\n let null = \"NUL\"\n let current_dir_name = \".\"\n let parent_dir_name = \"..\"\n let dir_sep = \"\\\\\"\n let is_dir_sep s i = let c = s.[i] in c = '/' || c = '\\\\' || c = ':'\n let is_relative n =\n (String.length n < 1 || n.[0] <> '/')\n && (String.length n < 1 || n.[0] <> '\\\\')\n && (String.length n < 2 || n.[1] <> ':')\n let is_implicit n =\n is_relative n\n && (String.length n < 2 || String.sub n 0 2 <> \"./\")\n && (String.length n < 2 || String.sub n 0 2 <> \".\\\\\")\n && (String.length n < 3 || String.sub n 0 3 <> \"../\")\n && (String.length n < 3 || String.sub n 0 3 <> \"..\\\\\")\n let check_suffix name suff =\n String.length name >= String.length suff &&\n (let s = String.sub name (String.length name - String.length suff)\n (String.length suff) in\n String.lowercase_ascii s = String.lowercase_ascii suff)\n\n let chop_suffix_opt ~suffix filename =\n let len_s = String.length suffix and len_f = String.length filename in\n if len_f >= len_s then\n let r = String.sub filename (len_f - len_s) len_s in\n if String.lowercase_ascii r = String.lowercase_ascii suffix then\n Some (String.sub filename 0 (len_f - len_s))\n else\n None\n else\n None\n\n\n let temp_dir_name =\n try Sys.getenv \"TEMP\" with Not_found -> \".\"\n let quote s =\n let l = String.length s in\n let b = Buffer.create (l + 20) in\n Buffer.add_char b '\\\"';\n let rec loop i =\n if i = l then Buffer.add_char b '\\\"' else\n match s.[i] with\n | '\\\"' -> loop_bs 0 i;\n | '\\\\' -> loop_bs 0 i;\n | c -> Buffer.add_char b c; loop (i+1);\n and loop_bs n i =\n if i = l then begin\n Buffer.add_char b '\\\"';\n add_bs n;\n end else begin\n match s.[i] with\n | '\\\"' -> add_bs (2*n+1); Buffer.add_char b '\\\"'; loop (i+1);\n | '\\\\' -> loop_bs (n+1) (i+1);\n | _ -> add_bs n; loop i\n end\n and add_bs n = for _j = 1 to n do Buffer.add_char b '\\\\'; done\n in\n loop 0;\n Buffer.contents b\n(*\nQuoting commands for execution by cmd.exe is difficult.\n1- Each argument is first quoted using the \"quote\" function above, to\n protect it against the processing performed by the C runtime system,\n then cmd.exe's special characters are escaped with '^', using\n the \"quote_cmd\" function below. For more details, see\n https://blogs.msdn.microsoft.com/twistylittlepassagesallalike/2011/04/23\n2- The command and the redirection files, if any, must be double-quoted\n in case they contain spaces. This quoting is interpreted by cmd.exe,\n not by the C runtime system, hence the \"quote\" function above\n cannot be used. The two characters we don't know how to quote\n inside a double-quoted cmd.exe string are double-quote and percent.\n We just fail if the command name or the redirection file names\n contain a double quote (not allowed in Windows file names, anyway)\n or a percent. See function \"quote_cmd_filename\" below.\n3- The whole string passed to Sys.command is then enclosed in double\n quotes, which are immediately stripped by cmd.exe. Otherwise,\n some of the double quotes from step 2 above can be misparsed.\n See e.g. https://stackoverflow.com/a/9965141\n*)\n let quote_cmd s =\n let b = Buffer.create (String.length s + 20) in\n String.iter\n (fun c ->\n match c with\n | '(' | ')' | '!' | '^' | '%' | '\\\"' | '<' | '>' | '&' | '|' ->\n Buffer.add_char b '^'; Buffer.add_char b c\n | _ ->\n Buffer.add_char b c)\n s;\n Buffer.contents b\n let quote_cmd_filename f =\n if String.contains f '\\\"' || String.contains f '%' then\n failwith (\"Filename.quote_command: bad file name \" ^ f)\n else if String.contains f ' ' then\n \"\\\"\" ^ f ^ \"\\\"\"\n else\n f\n (* Redirections in cmd.exe: see https://ss64.com/nt/syntax-redirection.html\n and https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-xp/bb490982(v=technet.10)\n *)\n let quote_command cmd ?stdin ?stdout ?stderr args =\n String.concat \"\" [\n \"\\\"\";\n quote_cmd_filename cmd;\n \" \";\n quote_cmd (String.concat \" \" (List.map quote args));\n (match stdin with None -> \"\" | Some f -> \" <\" ^ quote_cmd_filename f);\n (match stdout with None -> \"\" | Some f -> \" >\" ^ quote_cmd_filename f);\n (match stderr with None -> \"\" | Some f ->\n if stderr = stdout\n then \" 2>&1\"\n else \" 2>\" ^ quote_cmd_filename f);\n \"\\\"\"\n ]\n let has_drive s =\n let is_letter = function\n | 'A' .. 'Z' | 'a' .. 'z' -> true\n | _ -> false\n in\n String.length s >= 2 && is_letter s.[0] && s.[1] = ':'\n let drive_and_path s =\n if has_drive s\n then (String.sub s 0 2, String.sub s 2 (String.length s - 2))\n else (\"\", s)\n let dirname s =\n let (drive, path) = drive_and_path s in\n let dir = generic_dirname is_dir_sep current_dir_name path in\n drive ^ dir\n let basename s =\n let (_drive, path) = drive_and_path s in\n generic_basename is_dir_sep current_dir_name path\nend\n\nmodule Cygwin : SYSDEPS = struct\n let null = \"/dev/null\"\n let current_dir_name = \".\"\n let parent_dir_name = \"..\"\n let dir_sep = \"/\"\n let is_dir_sep = Win32.is_dir_sep\n let is_relative = Win32.is_relative\n let is_implicit = Win32.is_implicit\n let check_suffix = Win32.check_suffix\n let chop_suffix_opt = Win32.chop_suffix_opt\n let temp_dir_name = Unix.temp_dir_name\n let quote = Unix.quote\n let quote_command = Unix.quote_command\n let basename = generic_basename is_dir_sep current_dir_name\n let dirname = generic_dirname is_dir_sep current_dir_name\nend\n\nmodule Sysdeps =\n (val (match Sys.os_type with\n | \"Win32\" -> (module Win32: SYSDEPS)\n | \"Cygwin\" -> (module Cygwin: SYSDEPS)\n | _ -> (module Unix: SYSDEPS)))\n\ninclude Sysdeps\n\nlet concat dirname filename =\n let l = String.length dirname in\n if l = 0 || is_dir_sep dirname (l-1)\n then dirname ^ filename\n else dirname ^ dir_sep ^ filename\n\nlet chop_suffix name suff =\n if check_suffix name suff\n then String.sub name 0 (String.length name - String.length suff)\n else invalid_arg \"Filename.chop_suffix\"\n\nlet extension_len name =\n let rec check i0 i =\n if i < 0 || is_dir_sep name i then 0\n else if name.[i] = '.' then check i0 (i - 1)\n else String.length name - i0\n in\n let rec search_dot i =\n if i < 0 || is_dir_sep name i then 0\n else if name.[i] = '.' then check i (i - 1)\n else search_dot (i - 1)\n in\n search_dot (String.length name - 1)\n\nlet extension name =\n let l = extension_len name in\n if l = 0 then \"\" else String.sub name (String.length name - l) l\n\nlet chop_extension name =\n let l = extension_len name in\n if l = 0 then invalid_arg \"Filename.chop_extension\"\n else String.sub name 0 (String.length name - l)\n\nlet remove_extension name =\n let l = extension_len name in\n if l = 0 then name else String.sub name 0 (String.length name - l)\n\nexternal open_desc: string -> open_flag list -> int -> int = \"caml_sys_open\"\nexternal close_desc: int -> unit = \"caml_sys_close\"\n\nlet prng = lazy(Random.State.make_self_init ())\n\nlet temp_file_name temp_dir prefix suffix =\n let rnd = (Random.State.bits (Lazy.force prng)) land 0xFFFFFF in\n concat temp_dir (Printf.sprintf \"%s%06x%s\" prefix rnd suffix)\n\n\nlet current_temp_dir_name = ref temp_dir_name\n\nlet set_temp_dir_name s = current_temp_dir_name := s\nlet get_temp_dir_name () = !current_temp_dir_name\n\nlet temp_file ?(temp_dir = !current_temp_dir_name) prefix suffix =\n let rec try_name counter =\n let name = temp_file_name temp_dir prefix suffix in\n try\n close_desc(open_desc name [Open_wronly; Open_creat; Open_excl] 0o600);\n name\n with Sys_error _ as e ->\n if counter >= 1000 then raise e else try_name (counter + 1)\n in try_name 0\n\nlet open_temp_file ?(mode = [Open_text]) ?(perms = 0o600)\n ?(temp_dir = !current_temp_dir_name) prefix suffix =\n let rec try_name counter =\n let name = temp_file_name temp_dir prefix suffix in\n try\n (name,\n open_out_gen (Open_wronly::Open_creat::Open_excl::mode) perms name)\n with Sys_error _ as e ->\n if counter >= 1000 then raise e else try_name (counter + 1)\n in try_name 0\n","open! Import\n\ntype t = exn [@@deriving_inline sexp_of]\n\nlet sexp_of_t = (sexp_of_exn : t -> Ppx_sexp_conv_lib.Sexp.t)\n\n[@@@end]\n\nlet exit = Caml.exit\n\nexception Finally of t * t [@@deriving_inline sexp]\n\nlet () =\n Ppx_sexp_conv_lib.Conv.Exn_converter.add [%extension_constructor Finally] (function\n | Finally (v0, v1) ->\n let v0 = sexp_of_t v0\n and v1 = sexp_of_t v1 in\n Ppx_sexp_conv_lib.Sexp.List\n [ Ppx_sexp_conv_lib.Sexp.Atom \"exn.ml.Finally\"; v0; v1 ]\n | _ -> assert false)\n;;\n\n[@@@end]\n\nexception Reraised of string * t [@@deriving_inline sexp]\n\nlet () =\n Ppx_sexp_conv_lib.Conv.Exn_converter.add [%extension_constructor Reraised] (function\n | Reraised (v0, v1) ->\n let v0 = sexp_of_string v0\n and v1 = sexp_of_t v1 in\n Ppx_sexp_conv_lib.Sexp.List\n [ Ppx_sexp_conv_lib.Sexp.Atom \"exn.ml.Reraised\"; v0; v1 ]\n | _ -> assert false)\n;;\n\n[@@@end]\n\nexception Sexp of Sexp.t\n\n(* We install a custom exn-converter rather than use:\n\n {[\n exception Sexp of Sexp.t [@@deriving_inline sexp]\n (* ... *)\n [@@@end]\n ]}\n\n to eliminate the extra wrapping of [(Sexp ...)]. *)\nlet () =\n Sexplib.Conv.Exn_converter.add [%extension_constructor Sexp] (function\n | Sexp t -> t\n | _ ->\n (* Reaching this branch indicates a bug in sexplib. *)\n assert false)\n;;\n\nlet create_s sexp = Sexp sexp\nlet reraise exc str = raise (Reraised (str, exc))\nlet reraisef exc format = Printf.ksprintf (fun str () -> reraise exc str) format\nlet to_string exc = Sexp.to_string_hum ~indent:2 (sexp_of_exn exc)\nlet to_string_mach exc = Sexp.to_string_mach (sexp_of_exn exc)\nlet sexp_of_t = sexp_of_exn\n\nlet protectx ~f x ~(finally : _ -> unit) =\n match f x with\n | res ->\n finally x;\n res\n | exception exn ->\n raise\n (match finally x with\n | () -> exn\n | exception final_exn -> Finally (exn, final_exn))\n;;\n\nlet protect ~f ~finally = protectx ~f () ~finally\n\nlet does_raise (type a) (f : unit -> a) =\n try\n ignore (f () : a);\n false\n with\n | _ -> true\n;;\n\ninclude Pretty_printer.Register_pp (struct\n type t = exn\n\n let pp ppf t =\n match sexp_of_exn_opt t with\n | Some sexp -> Sexp.pp_hum ppf sexp\n | None -> Caml.Format.pp_print_string ppf (Caml.Printexc.to_string t)\n ;;\n\n let module_name = \"Base.Exn\"\n end)\n\nlet print_with_backtrace exc raw_backtrace =\n Caml.Format.eprintf \"@[<2>Uncaught exception:@\\n@\\n@[%a@]@]@\\n@.\" pp exc;\n if Caml.Printexc.backtrace_status ()\n then Caml.Printexc.print_raw_backtrace Caml.stderr raw_backtrace;\n Caml.flush Caml.stderr\n;;\n\nlet set_uncaught_exception_handler () =\n Caml.Printexc.set_uncaught_exception_handler print_with_backtrace\n;;\n\nlet handle_uncaught_aux ~do_at_exit ~exit f =\n try f () with\n | exc ->\n let raw_backtrace = Caml.Printexc.get_raw_backtrace () in\n (* One reason to run [do_at_exit] handlers before printing out the error message is\n that it helps curses applications bring the terminal in a good state, otherwise the\n error message might get corrupted. Also, the OCaml top-level uncaught exception\n handler does the same. *)\n if do_at_exit\n then (\n try Caml.do_at_exit () with\n | _ -> ());\n (try print_with_backtrace exc raw_backtrace with\n | _ ->\n (try\n Caml.Printf.eprintf \"Exn.handle_uncaught could not print; exiting anyway\\n%!\"\n with\n | _ -> ()));\n exit 1\n;;\n\nlet handle_uncaught_and_exit f = handle_uncaught_aux f ~exit ~do_at_exit:true\n\nlet handle_uncaught ~exit:must_exit f =\n handle_uncaught_aux f ~exit:(if must_exit then exit else ignore) ~do_at_exit:must_exit\n;;\n\nlet reraise_uncaught str func =\n try func () with\n | exn -> raise (Reraised (str, exn))\n;;\n\nexternal clear_backtrace : unit -> unit = \"Base_clear_caml_backtrace_pos\" [@@noalloc]\n\nlet raise_without_backtrace e =\n (* We clear the backtrace to reduce confusion, so that people don't think whatever\n is stored corresponds to this raise. *)\n clear_backtrace ();\n Caml.raise_notrace e\n;;\n\nlet initialize_module () = set_uncaught_exception_handler ()\n\nmodule Private = struct\n let clear_backtrace = clear_backtrace\nend\n","(* This is broken off to avoid circular dependency between Sign and Comparable. *)\n\nopen! Import\n\ntype t =\n | Neg\n | Zero\n | Pos\n[@@deriving_inline sexp, compare, hash, enumerate]\n\nlet t_of_sexp =\n (let _tp_loc = \"sign0.ml.t\" in\n function\n | Ppx_sexp_conv_lib.Sexp.Atom (\"neg\" | \"Neg\") -> Neg\n | Ppx_sexp_conv_lib.Sexp.Atom (\"zero\" | \"Zero\") -> Zero\n | Ppx_sexp_conv_lib.Sexp.Atom (\"pos\" | \"Pos\") -> Pos\n | Ppx_sexp_conv_lib.Sexp.List (Ppx_sexp_conv_lib.Sexp.Atom (\"neg\" | \"Neg\") :: _) as\n sexp -> Ppx_sexp_conv_lib.Conv_error.stag_no_args _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.List (Ppx_sexp_conv_lib.Sexp.Atom (\"zero\" | \"Zero\") :: _) as\n sexp -> Ppx_sexp_conv_lib.Conv_error.stag_no_args _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.List (Ppx_sexp_conv_lib.Sexp.Atom (\"pos\" | \"Pos\") :: _) as\n sexp -> Ppx_sexp_conv_lib.Conv_error.stag_no_args _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.List (Ppx_sexp_conv_lib.Sexp.List _ :: _) as sexp ->\n Ppx_sexp_conv_lib.Conv_error.nested_list_invalid_sum _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.List [] as sexp ->\n Ppx_sexp_conv_lib.Conv_error.empty_list_invalid_sum _tp_loc sexp\n | sexp -> Ppx_sexp_conv_lib.Conv_error.unexpected_stag _tp_loc sexp\n : Ppx_sexp_conv_lib.Sexp.t -> t)\n;;\n\nlet sexp_of_t =\n (function\n | Neg -> Ppx_sexp_conv_lib.Sexp.Atom \"Neg\"\n | Zero -> Ppx_sexp_conv_lib.Sexp.Atom \"Zero\"\n | Pos -> Ppx_sexp_conv_lib.Sexp.Atom \"Pos\"\n : t -> Ppx_sexp_conv_lib.Sexp.t)\n;;\n\nlet compare = (Ppx_compare_lib.polymorphic_compare : t -> t -> int)\n\nlet (hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state) =\n (fun hsv arg ->\n match arg with\n | Neg -> Ppx_hash_lib.Std.Hash.fold_int hsv 0\n | Zero -> Ppx_hash_lib.Std.Hash.fold_int hsv 1\n | Pos -> Ppx_hash_lib.Std.Hash.fold_int hsv 2\n : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state)\n;;\n\nlet (hash : t -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func arg =\n Ppx_hash_lib.Std.Hash.get_hash_value\n (let hsv = Ppx_hash_lib.Std.Hash.create () in\n hash_fold_t hsv arg)\n in\n fun x -> func x\n;;\n\nlet all = ([ Neg; Zero; Pos ] : t list)\n\n[@@@end]\n\nmodule Replace_polymorphic_compare = struct\n let ( < ) (x : t) y = Poly.( < ) x y\n let ( <= ) (x : t) y = Poly.( <= ) x y\n let ( <> ) (x : t) y = Poly.( <> ) x y\n let ( = ) (x : t) y = Poly.( = ) x y\n let ( > ) (x : t) y = Poly.( > ) x y\n let ( >= ) (x : t) y = Poly.( >= ) x y\n let ascending (x : t) y = Poly.ascending x y\n let descending (x : t) y = Poly.descending x y\n let compare (x : t) y = Poly.compare x y\n let equal (x : t) y = Poly.equal x y\n let max (x : t) y = if x >= y then x else y\n let min (x : t) y = if x <= y then x else y\nend\n\nlet of_string s = t_of_sexp (sexp_of_string s)\nlet to_string t = string_of_sexp (sexp_of_t t)\n\nlet to_int = function\n | Neg -> -1\n | Zero -> 0\n | Pos -> 1\n;;\n\nlet _ = hash\n\n(* Ignore the hash function produced by [@@deriving_inline hash] *)\nlet hash = to_int\nlet module_name = \"Base.Sign\"\nlet of_int n = if n < 0 then Neg else if n = 0 then Zero else Pos\n","# 1 \"src/hex_lexer.mll\"\n \ntype result =\n| Neg of string\n| Pos of string\n\n# 8 \"src/hex_lexer.ml\"\nlet __ocaml_lex_tables = {\n Lexing.lex_base =\n \"\\000\\000\\000\\000\\001\\000\\001\\000\\002\\000\\027\\000\\082\\000\\105\\000\\\n \";\n Lexing.lex_backtrk =\n \"\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\255\\255\\001\\000\\\n \";\n Lexing.lex_default =\n \"\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \";\n Lexing.lex_trans =\n \"\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\000\\000\\000\\000\\000\\\n \\001\\000\\003\\000\\005\\000\\005\\000\\005\\000\\005\\000\\005\\000\\005\\000\\\n \\005\\000\\005\\000\\005\\000\\005\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\005\\000\\005\\000\\005\\000\\005\\000\\005\\000\\\n \\005\\000\\000\\000\\000\\000\\005\\000\\005\\000\\005\\000\\005\\000\\005\\000\\\n \\005\\000\\005\\000\\005\\000\\005\\000\\005\\000\\000\\000\\000\\000\\000\\000\\\n \\006\\000\\004\\000\\000\\000\\000\\000\\005\\000\\005\\000\\005\\000\\005\\000\\\n \\005\\000\\005\\000\\000\\000\\005\\000\\005\\000\\005\\000\\005\\000\\005\\000\\\n \\005\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\006\\000\\004\\000\\005\\000\\000\\000\\005\\000\\005\\000\\005\\000\\005\\000\\\n \\005\\000\\005\\000\\007\\000\\007\\000\\007\\000\\007\\000\\007\\000\\007\\000\\\n \\007\\000\\007\\000\\007\\000\\007\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\007\\000\\007\\000\\007\\000\\007\\000\\007\\000\\\n \\007\\000\\007\\000\\007\\000\\007\\000\\007\\000\\007\\000\\007\\000\\007\\000\\\n \\007\\000\\007\\000\\007\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\007\\000\\007\\000\\007\\000\\007\\000\\007\\000\\007\\000\\\n \\000\\000\\000\\000\\000\\000\\007\\000\\007\\000\\007\\000\\007\\000\\007\\000\\\n \\007\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\007\\000\\000\\000\\007\\000\\007\\000\\007\\000\\007\\000\\007\\000\\007\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\";\n Lexing.lex_check =\n \"\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\\n \\000\\000\\002\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\\n \\004\\000\\004\\000\\004\\000\\004\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\\n \\004\\000\\255\\255\\255\\255\\005\\000\\005\\000\\005\\000\\005\\000\\005\\000\\\n \\005\\000\\005\\000\\005\\000\\005\\000\\005\\000\\255\\255\\255\\255\\255\\255\\\n \\001\\000\\003\\000\\255\\255\\255\\255\\005\\000\\005\\000\\005\\000\\005\\000\\\n \\005\\000\\005\\000\\255\\255\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\\n \\004\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\001\\000\\003\\000\\005\\000\\255\\255\\005\\000\\005\\000\\005\\000\\005\\000\\\n \\005\\000\\005\\000\\006\\000\\006\\000\\006\\000\\006\\000\\006\\000\\006\\000\\\n \\006\\000\\006\\000\\006\\000\\006\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\006\\000\\006\\000\\006\\000\\006\\000\\006\\000\\\n \\006\\000\\007\\000\\007\\000\\007\\000\\007\\000\\007\\000\\007\\000\\007\\000\\\n \\007\\000\\007\\000\\007\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\007\\000\\007\\000\\007\\000\\007\\000\\007\\000\\007\\000\\\n \\255\\255\\255\\255\\255\\255\\006\\000\\006\\000\\006\\000\\006\\000\\006\\000\\\n \\006\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\007\\000\\255\\255\\007\\000\\007\\000\\007\\000\\007\\000\\007\\000\\007\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\";\n Lexing.lex_base_code =\n \"\";\n Lexing.lex_backtrk_code =\n \"\";\n Lexing.lex_default_code =\n \"\";\n Lexing.lex_trans_code =\n \"\";\n Lexing.lex_check_code =\n \"\";\n Lexing.lex_code =\n \"\";\n}\n\nlet rec parse_hex lexbuf =\n __ocaml_lex_parse_hex_rec lexbuf 0\nand __ocaml_lex_parse_hex_rec lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\nlet\n# 8 \"src/hex_lexer.mll\"\n body\n# 135 \"src/hex_lexer.ml\"\n= Lexing.sub_lexeme lexbuf (lexbuf.Lexing.lex_start_pos + 3) lexbuf.Lexing.lex_curr_pos in\n# 14 \"src/hex_lexer.mll\"\n ( Neg body )\n# 139 \"src/hex_lexer.ml\"\n\n | 1 ->\nlet\n# 8 \"src/hex_lexer.mll\"\n body\n# 145 \"src/hex_lexer.ml\"\n= Lexing.sub_lexeme lexbuf (lexbuf.Lexing.lex_start_pos + 2) lexbuf.Lexing.lex_curr_pos in\n# 15 \"src/hex_lexer.mll\"\n ( Pos body )\n# 149 \"src/hex_lexer.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_parse_hex_rec lexbuf __ocaml_lex_state\n\n;;\n\n","open! Import\n\n(* C stub for int popcount to use the POPCNT instruction where possible *)\nexternal int_popcount : int -> int = \"Base_int_math_int_popcount\" [@@noalloc]\n\n(* To maintain javascript compatibility and enable unboxing, we implement popcount in\n OCaml rather than use C stubs. Implementation adapted from:\n https://en.wikipedia.org/wiki/Hamming_weight#Efficient_implementation *)\nlet int64_popcount =\n let open Caml.Int64 in\n let ( + ) = add in\n let ( - ) = sub in\n let ( * ) = mul in\n let ( lsr ) = shift_right_logical in\n let ( land ) = logand in\n let m1 = 0x5555555555555555L in\n (* 0b01010101... *)\n let m2 = 0x3333333333333333L in\n (* 0b00110011... *)\n let m4 = 0x0f0f0f0f0f0f0f0fL in\n (* 0b00001111... *)\n let h01 = 0x0101010101010101L in\n (* 1 bit set per byte *)\n fun [@inline] x ->\n (* gather the bit count for every pair of bits *)\n let x = x - ((x lsr 1) land m1) in\n (* gather the bit count for every 4 bits *)\n let x = (x land m2) + ((x lsr 2) land m2) in\n (* gather the bit count for every byte *)\n let x = (x + (x lsr 4)) land m4 in\n (* sum the bit counts in the top byte and shift it down *)\n to_int ((x * h01) lsr 56)\n;;\n\nlet int32_popcount =\n (* On 64-bit systems, this is faster than implementing using [int32] arithmetic. *)\n let mask = 0xffff_ffffL in\n fun [@inline] x -> int64_popcount (Caml.Int64.logand (Caml.Int64.of_int32 x) mask)\n;;\n\nlet nativeint_popcount =\n match Caml.Nativeint.size with\n | 32 -> fun [@inline] x -> int32_popcount (Caml.Nativeint.to_int32 x)\n | 64 -> fun [@inline] x -> int64_popcount (Caml.Int64.of_nativeint x)\n | _ -> assert false\n;;\n","(* A 63bit integer is a 64bit integer with its bits shifted to the left\n and its lowest bit set to 0.\n This is the same kind of encoding as OCaml int on 64bit architecture.\n The only difference being the lowest bit (immediate bit) set to 1. *)\n\nopen! Import\ninclude Int64_replace_polymorphic_compare\n\n\nmodule T0 = struct\n module T = struct\n type t = int64 [@@deriving_inline compare, hash, sexp, sexp_grammar]\n\n let compare = (compare_int64 : t -> t -> int)\n\n let (hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state) =\n hash_fold_int64\n\n and (hash : t -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func = hash_int64 in\n fun x -> func x\n ;;\n\n let t_of_sexp = (int64_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t)\n let sexp_of_t = (sexp_of_int64 : t -> Ppx_sexp_conv_lib.Sexp.t)\n\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group)\n =\n { implicit_vars = [ \"int64\" ]\n ; ggid = \"\\146e\\023\\249\\235eE\\139c\\132W\\195\\137\\129\\235\\025\"\n ; types = [ \"t\", Implicit_var 0 ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ int64_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"int63_emul.ml.T0.T\"\n }\n in\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"t\", _the_group)\n in\n t_sexp_grammar\n ;;\n\n [@@@end]\n end\n\n include T\n include Comparator.Make (T)\nend\n\nmodule Conv = Int_conversions\n\nmodule W : sig\n\n type t = int64\n\n include module type of struct\n include T0\n end\n with type t := t\n\n val wrap_exn : Caml.Int64.t -> t\n val wrap_modulo : Caml.Int64.t -> t\n val unwrap : t -> Caml.Int64.t\n\n (** Returns a non-negative int64 that is equal to the input int63 modulo 2^63. *)\n val unwrap_unsigned : t -> Caml.Int64.t\n\n val invariant : t -> unit\n val add : t -> t -> t\n val sub : t -> t -> t\n val neg : t -> t\n val abs : t -> t\n val succ : t -> t\n val pred : t -> t\n val mul : t -> t -> t\n val pow : t -> t -> t\n val div : t -> t -> t\n val rem : t -> t -> t\n val popcount : t -> int\n val bit_not : t -> t\n val bit_xor : t -> t -> t\n val bit_or : t -> t -> t\n val bit_and : t -> t -> t\n val shift_left : t -> int -> t\n val shift_right : t -> int -> t\n val shift_right_logical : t -> int -> t\n val min_value : t\n val max_value : t\n val to_int64 : t -> Caml.Int64.t\n val of_int64 : Caml.Int64.t -> t option\n val of_int64_exn : Caml.Int64.t -> t\n val of_int64_trunc : Caml.Int64.t -> t\n val compare : t -> t -> int\n val ceil_pow2 : t -> t\n val floor_pow2 : t -> t\n val ceil_log2 : t -> int\n val floor_log2 : t -> int\n val is_pow2 : t -> bool\n val clz : t -> int\n val ctz : t -> int\nend = struct\n type t = int64\n\n include (\n T0 :\n module type of struct\n include T0\n end\n with type t := t)\n\n let wrap_exn x =\n (* Raises if the int64 value does not fit on int63. *)\n Conv.int64_fit_on_int63_exn x;\n Caml.Int64.mul x 2L\n ;;\n\n let wrap x =\n if Conv.int64_is_representable_as_int63 x then Some (Caml.Int64.mul x 2L) else None\n ;;\n\n let wrap_modulo x = Caml.Int64.mul x 2L\n let unwrap x = Caml.Int64.shift_right x 1\n let unwrap_unsigned x = Caml.Int64.shift_right_logical x 1\n\n (* This does not use wrap or unwrap to avoid generating exceptions in the case of\n overflows. This is to preserve the semantics of int type on 64 bit architecture. *)\n let f2 f a b =\n Caml.Int64.mul (f (Caml.Int64.shift_right a 1) (Caml.Int64.shift_right b 1)) 2L\n ;;\n\n let mask = 0xffff_ffff_ffff_fffeL\n let m x = Caml.Int64.logand x mask\n let invariant t = assert (m t = t)\n let add x y = Caml.Int64.add x y\n let sub x y = Caml.Int64.sub x y\n let neg x = Caml.Int64.neg x\n let abs x = Caml.Int64.abs x\n let one = wrap_exn 1L\n let succ a = add a one\n let pred a = sub a one\n let min_value = m Caml.Int64.min_int\n let max_value = m Caml.Int64.max_int\n let bit_not x = m (Caml.Int64.lognot x)\n let bit_and = Caml.Int64.logand\n let bit_xor = Caml.Int64.logxor\n let bit_or = Caml.Int64.logor\n let shift_left x i = Caml.Int64.shift_left x i\n let shift_right x i = m (Caml.Int64.shift_right x i)\n let shift_right_logical x i = m (Caml.Int64.shift_right_logical x i)\n let pow = f2 Int_math.Private.int63_pow_on_int64\n let mul a b = Caml.Int64.mul a (Caml.Int64.shift_right b 1)\n let div a b = wrap_modulo (Caml.Int64.div a b)\n let rem a b = Caml.Int64.rem a b\n let popcount x = Popcount.int64_popcount x\n let to_int64 t = unwrap t\n let of_int64 t = wrap t\n let of_int64_exn t = wrap_exn t\n let of_int64_trunc t = wrap_modulo t\n let t_of_sexp x = wrap_exn (int64_of_sexp x)\n let sexp_of_t x = sexp_of_int64 (unwrap x)\n let compare (x : t) y = compare x y\n let is_pow2 x = Int64.is_pow2 (unwrap x)\n\n let clz x =\n (* We run Int64.clz directly on the wrapped int63 value. This is correct because the\n bits of the int63_emul are left-aligned in the Int64. *)\n Int64.clz x\n ;;\n\n let ctz x = Int64.ctz (unwrap x)\n let floor_pow2 x = Int64.floor_pow2 (unwrap x) |> wrap_exn\n let ceil_pow2 x = Int64.floor_pow2 (unwrap x) |> wrap_exn\n let floor_log2 x = Int64.floor_log2 (unwrap x)\n let ceil_log2 x = Int64.ceil_log2 (unwrap x)\nend\n\nopen W\n\nmodule T = struct\n type t = W.t [@@deriving_inline hash, sexp, sexp_grammar]\n\n let (hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state) =\n W.hash_fold_t\n\n and (hash : t -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func = W.hash in\n fun x -> func x\n ;;\n\n let t_of_sexp = (W.t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t)\n let sexp_of_t = (W.sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t)\n\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group) =\n { implicit_vars = [ \"W.t\" ]\n ; ggid = \"\\146e\\023\\249\\235eE\\139c\\132W\\195\\137\\129\\235\\025\"\n ; types = [ \"t\", Implicit_var 0 ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ W.t_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"int63_emul.ml.T\"\n }\n in\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"t\", _the_group)\n in\n t_sexp_grammar\n ;;\n\n [@@@end]\n\n type comparator_witness = W.comparator_witness\n\n let comparator = W.comparator\n let compare = W.compare\n let invariant = W.invariant\n\n (* We don't expect [hash] to follow the behavior of int in 64bit architecture *)\n let _ = hash\n let hash (x : t) = Caml.Hashtbl.hash x\n let invalid_str x = Printf.failwithf \"Int63.of_string: invalid input %S\" x ()\n\n (*\n \"sign\" refers to whether the number starts with a '-'\n \"signedness = false\" means the rest of the number is parsed as unsigned and then cast\n to signed with wrap-around modulo 2^i\n \"signedness = true\" means no such craziness happens\n\n The terminology and the logic is due to the code in byterun/ints.c in ocaml 4.03\n ([parse_sign_and_base] function).\n\n Signedness equals true for plain decimal number (e.g. 1235, -6789)\n\n Signedness equals false in the following cases:\n - [0xffff], [-0xffff] (hexadecimal representation)\n - [0b0101], [-0b0101] (binary representation)\n - [0o1237], [-0o1237] (octal representation)\n - [0u9812], [-0u9812] (unsigned decimal representation - available from OCaml 4.03) *)\n let sign_and_signedness x =\n let len = String.length x in\n let open Int_replace_polymorphic_compare in\n let pos, sign =\n if 0 < len\n then (\n match x.[0] with\n | '-' -> 1, `Neg\n | '+' -> 1, `Pos\n | _ -> 0, `Pos)\n else 0, `Pos\n in\n if pos + 2 < len\n then (\n let c1 = x.[pos] in\n let c2 = x.[pos + 1] in\n match c1, c2 with\n | '0', '0' .. '9' -> sign, true\n | '0', _ -> sign, false\n | _ -> sign, true)\n else sign, true\n ;;\n\n let to_string x = Caml.Int64.to_string (unwrap x)\n\n let of_string str =\n try\n let sign, signedness = sign_and_signedness str in\n if signedness\n then of_int64_exn (Caml.Int64.of_string str)\n else (\n let pos_str =\n match sign with\n | `Neg -> String.sub str ~pos:1 ~len:(String.length str - 1)\n | `Pos -> str\n in\n let int64 = Caml.Int64.of_string pos_str in\n (* unsigned 63-bit int must parse as a positive signed 64-bit int *)\n if Int64_replace_polymorphic_compare.( < ) int64 0L then invalid_str str;\n let int63 = wrap_modulo int64 in\n match sign with\n | `Neg -> neg int63\n | `Pos -> int63)\n with\n | _ -> invalid_str str\n ;;\n\n let bswap16 t = wrap_modulo (Int64.bswap16 (unwrap t))\n let bswap32 t = wrap_modulo (Int64.bswap32 (unwrap t))\n let bswap48 t = wrap_modulo (Int64.bswap48 (unwrap t))\nend\n\ninclude T\n\nlet num_bits = 63\nlet float_lower_bound = Float0.lower_bound_for_int num_bits\nlet float_upper_bound = Float0.upper_bound_for_int num_bits\nlet shift_right_logical = shift_right_logical\nlet shift_right = shift_right\nlet shift_left = shift_left\nlet bit_not = bit_not\nlet bit_xor = bit_xor\nlet bit_or = bit_or\nlet bit_and = bit_and\nlet popcount = popcount\nlet abs = abs\nlet pred = pred\nlet succ = succ\nlet pow = pow\nlet rem = rem\nlet neg = neg\nlet max_value = max_value\nlet min_value = min_value\nlet minus_one = wrap_exn Caml.Int64.minus_one\nlet one = wrap_exn Caml.Int64.one\nlet zero = wrap_exn Caml.Int64.zero\nlet is_pow2 = is_pow2\nlet floor_pow2 = floor_pow2\nlet ceil_pow2 = ceil_pow2\nlet floor_log2 = floor_log2\nlet ceil_log2 = ceil_log2\nlet clz = clz\nlet ctz = ctz\nlet to_float x = Caml.Int64.to_float (unwrap x)\nlet of_float_unchecked x = wrap_modulo (Caml.Int64.of_float x)\n\nlet of_float t =\n let open Float_replace_polymorphic_compare in\n if t >= float_lower_bound && t <= float_upper_bound\n then wrap_modulo (Caml.Int64.of_float t)\n else\n Printf.invalid_argf\n \"Int63.of_float: argument (%f) is out of range or NaN\"\n (Float0.box t)\n ()\n;;\n\nlet of_int64 = of_int64\nlet of_int64_exn = of_int64_exn\nlet of_int64_trunc = of_int64_trunc\nlet to_int64 = to_int64\n\ninclude Comparable.Validate_with_zero (struct\n include T\n\n let zero = zero\n end)\n\nlet between t ~low ~high = low <= t && t <= high\nlet clamp_unchecked t ~min ~max = if t < min then min else if t <= max then t else max\n\nlet clamp_exn t ~min ~max =\n assert (min <= max);\n clamp_unchecked t ~min ~max\n;;\n\nlet clamp t ~min ~max =\n if min > max\n then\n Or_error.error_s\n (Sexp.message\n \"clamp requires [min <= max]\"\n [ \"min\", T.sexp_of_t min; \"max\", T.sexp_of_t max ])\n else Ok (clamp_unchecked t ~min ~max)\n;;\n\nlet ( / ) = div\nlet ( * ) = mul\nlet ( - ) = sub\nlet ( + ) = add\nlet ( ~- ) = neg\nlet ( ** ) b e = pow b e\nlet incr r = r := !r + one\nlet decr r = r := !r - one\n\n(* We can reuse conversion function from/to int64 here. *)\nlet of_int x = wrap_exn (Conv.int_to_int64 x)\nlet of_int_exn x = of_int x\nlet to_int x = Conv.int64_to_int (unwrap x)\nlet to_int_exn x = Conv.int64_to_int_exn (unwrap x)\nlet to_int_trunc x = Conv.int64_to_int_trunc (unwrap x)\nlet of_int32 x = wrap_exn (Conv.int32_to_int64 x)\nlet of_int32_exn x = of_int32 x\nlet to_int32 x = Conv.int64_to_int32 (unwrap x)\nlet to_int32_exn x = Conv.int64_to_int32_exn (unwrap x)\nlet to_int32_trunc x = Conv.int64_to_int32_trunc (unwrap x)\nlet of_nativeint x = of_int64 (Conv.nativeint_to_int64 x)\nlet of_nativeint_exn x = wrap_exn (Conv.nativeint_to_int64 x)\nlet of_nativeint_trunc x = of_int64_trunc (Conv.nativeint_to_int64 x)\nlet to_nativeint x = Conv.int64_to_nativeint (unwrap x)\nlet to_nativeint_exn x = Conv.int64_to_nativeint_exn (unwrap x)\nlet to_nativeint_trunc x = Conv.int64_to_nativeint_trunc (unwrap x)\n\ninclude Conv.Make (T)\n\ninclude Conv.Make_hex (struct\n type t = T.t [@@deriving_inline compare, hash]\n\n let compare = (T.compare : t -> t -> int)\n\n let (hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state) =\n T.hash_fold_t\n\n and (hash : t -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func = T.hash in\n fun x -> func x\n ;;\n\n [@@@end]\n\n let zero = zero\n let neg = ( ~- )\n let ( < ) = ( < )\n\n let to_string i =\n (* the use of [unwrap_unsigned] here is important for the case of [min_value] *)\n Printf.sprintf \"%Lx\" (unwrap_unsigned i)\n ;;\n\n let of_string s = of_string (\"0x\" ^ s)\n let module_name = \"Base.Int63.Hex\"\n end)\n\ninclude Pretty_printer.Register (struct\n type nonrec t = t\n\n let to_string x = to_string x\n let module_name = \"Base.Int63\"\n end)\n\nmodule Pre_O = struct\n let ( + ) = ( + )\n let ( - ) = ( - )\n let ( * ) = ( * )\n let ( / ) = ( / )\n let ( ~- ) = ( ~- )\n let ( ** ) = ( ** )\n\n include (Int64_replace_polymorphic_compare : Comparisons.Infix with type t := t)\n\n let abs = abs\n let neg = neg\n let zero = zero\n let of_int_exn = of_int_exn\nend\n\nmodule O = struct\n include Pre_O\n\n include Int_math.Make (struct\n type nonrec t = t\n\n include Pre_O\n\n let rem = rem\n let to_float = to_float\n let of_float = of_float\n let of_string = T.of_string\n let to_string = T.to_string\n end)\n\n let ( land ) = bit_and\n let ( lor ) = bit_or\n let ( lxor ) = bit_xor\n let lnot = bit_not\n let ( lsl ) = shift_left\n let ( asr ) = shift_right\n let ( lsr ) = shift_right_logical\nend\n\ninclude O\n\n(* [Int63] and [Int63.O] agree value-wise *)\n\nmodule Repr = struct\n type emulated = t\n\n type ('underlying_type, 'intermediate_type) t =\n | Int : (int, int) t\n | Int64 : (int64, emulated) t\nend\n\nlet repr = Repr.Int64\n\n(* Include type-specific [Replace_polymorphic_compare] at the end, after\n including functor application that could shadow its definitions. This is\n here so that efficient versions of the comparison functions are exported by\n this module. *)\ninclude Int64_replace_polymorphic_compare\n","open! Import\nmodule Sys = Sys0\n\ntype t = Caml.Printexc.raw_backtrace\n\nlet elide = ref am_testing\nlet elided_message = \"\"\n\nlet get ?(at_most_num_frames = Int.max_value) () =\n Caml.Printexc.get_callstack at_most_num_frames\n;;\n\nlet to_string t =\n if !elide then elided_message else Caml.Printexc.raw_backtrace_to_string t\n;;\n\nlet to_string_list t = String.split_lines (to_string t)\nlet sexp_of_t t = Sexp.List (List.map (to_string_list t) ~f:(fun x -> Sexp.Atom x))\n\nmodule Exn = struct\n let set_recording = Caml.Printexc.record_backtrace\n let am_recording = Caml.Printexc.backtrace_status\n let most_recent () = Caml.Printexc.get_raw_backtrace ()\n\n (* We turn on backtraces by default if OCAMLRUNPARAM doesn't explicitly mention them. *)\n let maybe_set_recording () =\n let ocamlrunparam_mentions_backtraces =\n match Sys.getenv \"OCAMLRUNPARAM\" with\n | None -> false\n | Some x -> List.exists (String.split x ~on:',') ~f:(String.is_prefix ~prefix:\"b\")\n in\n if not ocamlrunparam_mentions_backtraces then set_recording true\n ;;\n\n (* the caller set something, they are responsible *)\n\n let with_recording b ~f =\n let saved = am_recording () in\n set_recording b;\n Exn.protect ~f ~finally:(fun () -> set_recording saved)\n ;;\nend\n\nlet initialize_module () = Exn.maybe_set_recording ()\n","let unique_id =\n let r = ref 0 in\n fun () -> incr r; !r\n\n(* Used to track the current libname in such a way that for functor applications, it is\n the calling libraries name that gets registered. *)\nmodule Current_libname = struct\n let null = \"\"\n let libname_ref = ref null\n\n let set str = libname_ref := str\n let unset () = libname_ref := null\n let get () = !libname_ref\nend\n\nmodule Current_bench_module_stack = struct\n let t = ref []\n\n let push s = t := s :: !t\n\n let pop_exn () = t := List.tl !t\n\n let to_name () =\n match !t with\n | [] -> None\n | ms -> Some (String.concat \".\" (List.rev ms))\nend\n\n(* This is the main data structure of this module. An [Entry.t] represents a benchmark\n along with some metadata about is position, arguments etc. *)\nmodule Entry = struct\n\n type 'a indexed_spec = {\n arg_name : string;\n arg_values : int list;\n thunk : int -> unit -> 'a;\n }\n\n type test_spec =\n | Regular_thunk : ([`init] -> unit -> 'a) -> test_spec\n | Indexed_thunk : 'a indexed_spec -> test_spec\n\n type t = {\n unique_id : int;\n code : string;\n type_conv_path : string;\n name : string;\n filename : string;\n line : int;\n startpos : int;\n endpos : int;\n test_spec : test_spec;\n bench_module_name : string option;\n }\n\n let compare t1 t2 = compare t1.unique_id t2.unique_id\n\n let get_indexed_arg_name t =\n match t.test_spec with\n | Regular_thunk _ -> None\n | Indexed_thunk {arg_name; _} -> Some arg_name\n\n (* Extracts module name from [\"filename.ml.Module\"], which is the format of [ext_name]\n as set by [typeconv]. *)\n let get_module_name_opt t =\n let str = t.type_conv_path in\n let len = String.length str in\n let rec loop i =\n if i + 4 <= len\n then\n if String.sub str i 4 = \".ml.\"\n then Some (String.sub str (i + 4) (len - i - 4))\n else loop (i + 1)\n else None\n in\n loop 0\nend\n\n(* Inspect system environment variables to decide if benchmarks are being run. This is\n called by the code generated by the [pa_bench] syntax to decide if the global hashtable\n should be populated. *)\nlet add_environment_var =\n let v =\n try Sys.getenv \"BENCHMARKS_RUNNER\" with\n | Not_found -> \"\"\n in\n v = \"TRUE\"\n\n(* This hashtable contains all the benchmarks from all the of libraries that have been\n loaded. At the time the benchmarks are registering themselves with [ppx_bench_lib] we\n don't yet know which libraries will need to be run. *)\nlet libs_to_entries : (string, Entry.t list) Hashtbl.t = Hashtbl.create 10\n\nlet lookup_rev_lib ~libname =\n try Hashtbl.find libs_to_entries libname\n with Not_found -> []\n\nlet lookup_lib ~libname =\n List.rev (lookup_rev_lib ~libname)\n\nlet force_drop =\n (* Useful for js_of_ocaml to perform deadcode elimination.\n see ppx/ppx_inline_test/runtime-lib/runtime.ml [Action.get] for more details *)\n try ignore (Sys.getenv \"FORCE_DROP_BENCH\" : string); true\n with Not_found -> false\n\nlet get_mode () =\n if force_drop\n then `Ignore\n else `Collect\n\nlet[@inline never] add_bench\n ~name\n ~code\n ~filename\n ~type_conv_path\n ~line\n ~startpos\n ~endpos\n test_spec\n =\n match get_mode () with\n | `Ignore -> ()\n | `Collect ->\n let libname = Current_libname.get () in\n let entry = { Entry.\n code; unique_id = unique_id ();\n type_conv_path; bench_module_name = Current_bench_module_stack.to_name ();\n name; filename; line; startpos; endpos; test_spec;\n } in\n Hashtbl.add libs_to_entries libname (entry :: lookup_rev_lib ~libname)\n\nlet[@inline never] add_bench_module\n ~name\n ~code:_\n ~type_conv_path:_\n ~filename:_\n ~line:_\n ~startpos:_\n ~endpos:_\n f =\n match get_mode () with\n | `Ignore -> ()\n | `Collect ->\n (* Running f registers the benchmarks using BENCH *)\n Current_bench_module_stack.push name;\n try\n f ();\n Current_bench_module_stack.pop_exn ();\n with ex ->\n Current_bench_module_stack.pop_exn ();\n raise ex\n","open! Base\n\nmodule Location : sig\n include Identifiable.S\nend = struct\n include String\nend\n\nmodule Uuid : sig\n include Identifiable.S\nend = struct\n include String\nend\n\nlet eval_fail loc fmt =\n Printf.ksprintf (fun s -> failwith (Printf.sprintf !\"%{Location}: %s\" loc s)) fmt\n;;\n\nlet equal_option equal a b =\n match a, b with\n | Some _, None | None, Some _ -> false\n | None, None -> true\n | Some x, Some y -> equal x y\n;;\n\nmodule Sorted_table : sig\n type 'a t [@@deriving compare, sexp]\n\n val create : Location.t -> eq:('a -> 'a -> bool) -> (string * 'a) list -> 'a t\n val expose : 'a t -> (string * 'a) list\n val map : 'a t -> f:('a -> 'b) -> 'b t\nend = struct\n type 'a t = { sorted : (string * 'a) list } [@@deriving compare, sexp]\n\n let merge_check_adjacent_dups\n : eq:('a -> 'a -> bool) -> (string * 'a) list\n -> [ `Ok of (string * 'a) list | `Mismatch of string ]\n =\n fun ~eq ->\n let rec loop acc ~last_key ~last_value = function\n | [] -> `Ok (List.rev acc)\n | (key, value) :: xs ->\n if String.(last_key = key)\n then\n if eq last_value value\n then loop acc ~last_key ~last_value xs\n else `Mismatch key\n else loop ((key, value) :: acc) ~last_key:key ~last_value:value xs\n in\n function\n | [] -> `Ok []\n | (key, value) :: xs -> loop [ key, value ] ~last_key:key ~last_value:value xs\n ;;\n\n let create loc ~eq xs =\n let sorted = List.sort ~compare:(fun (s1, _) (s2, _) -> String.compare s1 s2) xs in\n match merge_check_adjacent_dups ~eq sorted with\n | `Ok sorted -> { sorted }\n | `Mismatch s ->\n eval_fail loc \"Different shapes for duplicated polymorphic constructor: `%s\" s ()\n ;;\n\n let expose t = t.sorted\n let map t ~f = { sorted = List.map t.sorted ~f:(fun (k, v) -> k, f v) }\nend\n\nmodule Digest : sig\n type t = Md5_lib.t [@@deriving compare, sexp]\n\n val to_md5 : t -> Md5_lib.t\n val of_md5 : Md5_lib.t -> t\n val to_hex : t -> string\n val constructor : string -> t list -> t\n val list : t list -> t\n val pair : t -> t -> t\n val string : string -> t\n val uuid : Uuid.t -> t\n val int : int -> t\n val option : t option -> t\nend = struct\n include Md5_lib\n\n let to_md5 t = t\n let of_md5 t = t\n let sexp_of_t t = t |> to_hex |> sexp_of_string\n let t_of_sexp s = s |> string_of_sexp |> of_hex_exn\n let uuid u = string (Uuid.to_string u)\n let int x = string (Int.to_string x)\n let pair x y = string (to_binary x ^ to_binary y)\n let list l = string (String.concat ~sep:\"\" (List.map ~f:to_binary l))\n let constructor s l = string (s ^ to_binary (list l))\n\n let option = function\n | None -> constructor \"none\" []\n | Some x -> constructor \"some\" [ x ]\n ;;\nend\n\nmodule Canonical_exp_constructor = struct\n (* ['a t] is a non-recursive type, used to represent 1-layer of expression. The\n recursive knot is tied below in [Canonical_full.Exp.t]. *)\n type 'a t =\n | Annotate of Uuid.t * 'a\n | Base of Uuid.t * 'a list\n | Tuple of 'a list\n | Record of (string * 'a) list\n | Variant of (string * 'a list) list\n (* Polymorphic variants are insensitive to the order the constructors are listed *)\n | Poly_variant of 'a option Sorted_table.t\n (* Left-hand-side of [Application] is a potentially recursive definition: it\n can refer to itself using [Rec_app (i, _)] where [i] is the depth of this\n application node (how many application nodes are above it).\n It also has its own scope of type variables so it can not refer to type variables\n of the enclosing scope.\n *)\n | Application of 'a * 'a list\n | Rec_app of int * 'a list\n | Var of int\n [@@deriving sexp, compare]\n\n let map x ~f =\n match x with\n | Annotate (u, x) -> Annotate (u, f x)\n | Base (s, xs) -> Base (s, List.map ~f xs)\n | Tuple xs -> Tuple (List.map ~f xs)\n | Record l -> Record (List.map l ~f:(fun (s, x) -> s, f x))\n | Variant l -> Variant (List.map l ~f:(fun (s, xs) -> s, List.map ~f xs))\n | Poly_variant t -> Poly_variant (Sorted_table.map t ~f:(Option.map ~f))\n | Application (x, l) -> Application (f x, List.map ~f l)\n | Rec_app (t, l) -> Rec_app (t, List.map ~f l)\n | Var v -> Var v\n ;;\n\n let to_string t = Sexp.to_string (sexp_of_t (fun _ -> Atom \"...\") t)\nend\n\nmodule Create_digest : sig\n (* Digest various expression forms *)\n\n val digest_layer : Digest.t Canonical_exp_constructor.t -> Digest.t\nend = struct\n let digest_layer = function\n | Canonical_exp_constructor.Annotate (u, x) ->\n Digest.constructor \"annotate\" [ Digest.uuid u; x ]\n | Base (u, l) -> Digest.constructor \"base\" [ Digest.uuid u; Digest.list l ]\n | Tuple l -> Digest.constructor \"tuple\" [ Digest.list l ]\n | Record l ->\n Digest.constructor\n \"record\"\n [ Digest.list (List.map l ~f:(fun (s, t) -> Digest.pair (Digest.string s) t)) ]\n | Variant l ->\n Digest.constructor\n \"variant\"\n [ Digest.list\n (List.map l ~f:(fun (s, l) -> Digest.pair (Digest.string s) (Digest.list l)))\n ]\n | Poly_variant table ->\n Digest.constructor\n \"poly_variant\"\n [ Digest.list\n (List.map (Sorted_table.expose table) ~f:(fun (x, y) ->\n Digest.pair (Digest.string x) (Digest.option y)))\n ]\n | Application (x, l) -> Digest.constructor \"application\" [ x; Digest.list l ]\n | Rec_app (n, l) -> Digest.constructor \"rec_app\" [ Digest.int n; Digest.list l ]\n | Var n -> Digest.constructor \"var\" [ Digest.int n ]\n ;;\nend\n\nmodule Visibility = struct\n type visible = Visible\n type opaque = Opaque\n\n let _ = Visible\n let _ = Opaque\nend\n\nmodule type Canonical = sig\n type t\n\n val to_digest : t -> Digest.t\n\n module Exp1 : sig\n type _ t\n\n val var : int -> _ t\n val recurse : int -> _ t list -> _ t\n val apply : 'a t -> 'a t list -> _ t\n val opaque : _ t -> Visibility.opaque t\n\n val get_poly_variant\n : Visibility.visible t\n -> (Visibility.opaque t option Sorted_table.t, string) Result.t\n end\n\n module Def : sig\n type t = Visibility.visible Exp1.t\n end\n\n module Create : sig\n val annotate : Uuid.t -> _ Exp1.t -> _ Exp1.t\n val basetype : Uuid.t -> _ Exp1.t list -> _ Exp1.t\n val tuple : _ Exp1.t list -> _ Exp1.t\n val poly_variant : Location.t -> (string * _ Exp1.t option) list -> _ Exp1.t\n val var : int -> _ Exp1.t\n val recurse : int -> _ Exp1.t list -> _ Exp1.t\n val apply : 'a Exp1.t -> 'a Exp1.t list -> _ Exp1.t\n val define : Visibility.visible Exp1.t -> Def.t\n val record : (string * _ Exp1.t) list -> _ Exp1.t\n val variant : (string * _ Exp1.t list) list -> _ Exp1.t\n val create : _ Exp1.t -> t\n end\nend\n\nmodule Canonical_digest : Canonical = struct\n type t = Canonical of Digest.t\n\n let to_digest (Canonical x) = x\n\n module CD = Create_digest\n\n module Exp1 = struct\n type opaque = Digest.t\n\n type 'a t =\n | Poly_variant of opaque option Sorted_table.t\n | Non_poly_variant of (string * opaque)\n | Opaque : opaque -> Visibility.opaque t\n\n let to_digest (type a) (x : a t) =\n match x with\n | Opaque x -> x\n | Non_poly_variant (_, x) -> x\n | Poly_variant x -> CD.digest_layer (Poly_variant x)\n ;;\n\n let equal (type a) (x : a t) (y : a t) =\n Digest.compare (to_digest x) (to_digest y) = 0\n ;;\n\n let opaque x = Opaque (to_digest x)\n\n let create x =\n let x = Canonical_exp_constructor.map ~f:to_digest x in\n let desc = Canonical_exp_constructor.to_string x in\n match x with\n | Canonical_exp_constructor.Poly_variant l -> Poly_variant l\n | Base _ -> Non_poly_variant (desc, CD.digest_layer x)\n | Annotate _ ->\n (* It's unsafe to use deriving bin_io when inheriting from a polymorphic variant\n that has a custom bin_io. If we forbid that, we can happily reject here\n anything that's annotated. *)\n Non_poly_variant (desc, CD.digest_layer x)\n | Application _ ->\n (* Application can really be a poly-variant you can inherit from! But it's a\n rare situation that mostly (only?) arises with inheritance from recursive\n polymorpic variants, which we've not seen anywhere yet. So we reject it. *)\n Non_poly_variant (desc, CD.digest_layer x)\n | Rec_app _ ->\n (* You can only get the [Rec_app] constructor for type-references within the\n mutual group being defined. References which\n follow after the current group will always be [Application]s.\n\n And since ocaml rejects references in `inheritance' position to types within\n the current group (see example) with:\n\n Error: The type constructor t\n is not yet completely defined\n\n then its ok to say that a rec-app is something that can't be inherited from and\n return [Non_poly_variant].\n\n And unlike the [Application] case, it should never be possible to see\n an error message with the [desc] = [Rec_app].\n\n Example: [type t = [`a of [ | t] ]]\n Here, [| t] would be an example of inheritance from a Rec_app, which\n is rejected by the compiler.\n *)\n Non_poly_variant (desc, CD.digest_layer x)\n | Var _ | Tuple _ | Record _ | Variant _ ->\n Non_poly_variant (desc, CD.digest_layer x)\n ;;\n\n let var x = create (Var x)\n let apply def l = create (Application (def, l))\n let recurse tid l = create (Rec_app (tid, l))\n\n let get_poly_variant (x : Visibility.visible t) =\n match x with\n | Non_poly_variant (desc, _) -> Error desc\n | Poly_variant l -> Ok (Sorted_table.map ~f:(Option.map ~f:(fun x -> Opaque x)) l)\n ;;\n end\n\n module Def = struct\n type t = Visibility.visible Exp1.t\n end\n\n module Create = struct\n let annotate u x = Exp1.create (Annotate (u, x))\n let basetype u l = Exp1.create (Base (u, l))\n let tuple l = Exp1.create (Tuple l)\n\n let poly_variant loc l =\n Exp1.create\n (Poly_variant (Sorted_table.create loc ~eq:(equal_option Exp1.equal) l))\n ;;\n\n let var x = Exp1.create (Var x)\n let apply x l = Exp1.create (Application (x, l))\n let recurse t l = Exp1.create (Rec_app (t, l))\n let define x = x\n let record l = Exp1.create (Record l)\n let variant l = Exp1.create (Variant l)\n let create e = Canonical (Exp1.to_digest e)\n end\nend\n\nmodule Canonical_full : sig\n type t [@@deriving compare, sexp]\n\n include Canonical with type t := t\n\n val to_string_hum : t -> string\nend = struct\n module CD = Create_digest\n\n module Exp1 = struct\n type t0 = Exp of t0 Canonical_exp_constructor.t [@@deriving compare, sexp]\n\n let equal_t0 x y = compare_t0 x y = 0\n\n type 'a t = t0 [@@deriving compare, sexp]\n\n let var x = Exp (Canonical_exp_constructor.Var x)\n let apply d xs = Exp (Canonical_exp_constructor.Application (d, xs))\n let recurse r xs = Exp (Canonical_exp_constructor.Rec_app (r, xs))\n\n let poly_variant loc xs =\n Exp\n (Canonical_exp_constructor.Poly_variant\n (Sorted_table.create loc ~eq:(equal_option equal_t0) xs))\n ;;\n\n let get_poly_variant = function\n | Exp (Poly_variant tab) -> Ok tab\n | Exp cc -> Error (Canonical_exp_constructor.to_string cc)\n ;;\n\n let opaque t = t\n\n let rec to_digest = function\n | Exp e -> CD.digest_layer (Canonical_exp_constructor.map ~f:to_digest e)\n ;;\n end\n\n module Def = struct\n (* A [Def.t] is an expression which may be applied *)\n type t = Exp1.t0 [@@deriving compare, sexp]\n end\n\n (* A canonical shape [t] is an [Exp1.t]. *)\n type t = Exp1.t0 [@@deriving compare, sexp]\n\n let to_digest e = Exp1.to_digest e\n\n module Create = struct\n let annotate u x = Exp1.Exp (Annotate (u, x))\n let basetype u xs = Exp1.Exp (Base (u, xs))\n let tuple xs = Exp1.Exp (Tuple xs)\n let poly_variant loc xs = Exp1.poly_variant loc xs\n let var n = Exp1.Exp (Var n)\n let recurse r xs = Exp1.recurse r xs\n let apply d xs = Exp1.apply d xs\n let define x = x\n let record xs = Exp1.Exp (Record xs)\n let variant xs = Exp1.Exp (Variant xs)\n let create exp = exp\n end\n\n let to_string_hum t = Sexp.to_string_hum (sexp_of_t t)\nend\n\nmodule Tid : sig\n include Identifiable.S\nend = struct\n include String\nend\n\nmodule Vid : sig\n include Identifiable.S\nend = struct\n include String\nend\n\nmodule Gid : sig\n (* unique group-id, used as key for Tenv below *)\n type t [@@deriving compare, sexp_of]\n\n val create : unit -> t\nend = struct\n type t = int [@@deriving compare, sexp_of]\n\n let r = ref 0\n\n let create () =\n let u = !r in\n r := 1 + u;\n u\n ;;\nend\n\nmodule Expression = struct\n type 't poly_constr =\n [ `Constr of string * 't option\n | `Inherit of Location.t * 't\n ]\n [@@deriving compare, sexp_of]\n\n module Group : sig\n type 'a t [@@deriving compare, sexp_of]\n\n val create : Location.t -> (Tid.t * Vid.t list * 'a) list -> 'a t\n val id : 'a t -> Gid.t\n val lookup : 'a t -> Tid.t -> Vid.t list * 'a\n end = struct\n type 'a t =\n { gid : Gid.t\n ; loc : Location.t\n ; members : (Tid.t * (Vid.t list * 'a)) list\n }\n [@@deriving compare, sexp_of]\n\n let create loc trips =\n let gid = Gid.create () in\n let members = List.map trips ~f:(fun (x, vs, t) -> x, (vs, t)) in\n { gid; loc; members }\n ;;\n\n let id g = g.gid\n\n let lookup g tid =\n match List.Assoc.find g.members ~equal:Tid.( = ) tid with\n | Some scheme -> scheme\n | None ->\n eval_fail\n g.loc\n !\"impossible: lookup_group, unbound type-identifier: %{Tid}\"\n tid\n ()\n ;;\n end\n\n type t =\n | Annotate of Uuid.t * t\n | Base of Uuid.t * t list\n | Record of (string * t) list\n | Variant of (string * t list) list\n | Tuple of t list\n | Poly_variant of (Location.t * t poly_constr list)\n | Var of (Location.t * Vid.t)\n | Rec_app of Tid.t * t list\n | Top_app of t Group.t * Tid.t * t list\n [@@deriving variants, sexp_of]\n\n type group = t Group.t\n\n let group = Group.create\n\n type poly_variant_row = t poly_constr\n\n let constr s t = `Constr (s, t)\n let inherit_ loc t = `Inherit (loc, t)\n let var loc t = Var (loc, t)\n let poly_variant loc xs = Poly_variant (loc, xs)\n let basetype = base\n\n (* \"VR\" stands for \"variant or record\" *)\n\n let is_cyclic_0 ~(via_VR : bool) : group -> Tid.t -> bool =\n fun group tid ->\n let set = ref [] in\n let visited tid = List.mem !set tid ~equal:Tid.equal in\n let add tid = set := tid :: !set in\n let rec trav = function\n (* We look for cycles by traversing the structure of type-expressions *)\n | Annotate (_, t) -> trav t\n | Base (_, ts) | Tuple ts | Top_app (_, _, ts) -> List.iter ts ~f:trav\n (* ..including poly-variants *)\n | Poly_variant (_, cs) ->\n List.iter cs ~f:(function\n | `Constr (_, None) -> ()\n | `Constr (_, Some t) -> trav t\n | `Inherit (_loc, t) -> trav t)\n (* .. and records & (normal) variants *)\n | Record xs -> if via_VR then List.iter xs ~f:(fun (_, t) -> trav t) else ()\n | Variant xs ->\n if via_VR then List.iter xs ~f:(fun (_, ts) -> List.iter ~f:trav ts) else ()\n (* We dont follow type-vars *)\n | Var _ -> ()\n (* traverse (recursive) type-apps when first encountered *)\n | Rec_app (tid, ts) ->\n if visited tid\n then ()\n else (\n add tid;\n trav_tid tid);\n List.iter ts ~f:trav\n and trav_tid tid =\n let _, body = Group.lookup group tid in\n trav body\n in\n trav_tid tid;\n let res = visited tid in\n (*let _ss = String.concat ~sep:\",\" (List.map (!set) ~f:(sprintf !\"%{Tid}\")) in*)\n (*Printf.printf !\"is_cylic: %{Tid} --> (%s) %b -- %s%!\" tid _ss res (Group.loc group);*)\n res\n ;;\n\n let is_cyclic = is_cyclic_0 ~via_VR:true\n let is_cyclic_with_no_intervening_VR = is_cyclic_0 ~via_VR:false\nend\n\ninclude Expression\n\nmodule Evaluation (Canonical : Canonical) = struct\n (* [Venv.t]\n Environment for resolving type-vars *)\n module Venv : sig\n type t\n\n val lookup : t -> Vid.t -> Visibility.visible Canonical.Exp1.t option\n val create : (Vid.t * Visibility.visible Canonical.Exp1.t) list -> t\n end = struct\n type t = Visibility.visible Canonical.Exp1.t Map.M(Vid).t\n\n let create =\n List.fold\n ~init:(Map.empty (module Vid))\n ~f:(fun t (k, v) -> Map.set ~key:k ~data:v t)\n ;;\n\n let lookup t k = Map.find t k\n end\n\n module Applicand = struct\n type t =\n | Recursion_level of int\n | Definition of Canonical.Def.t\n end\n\n (* [Tenv.t]\n Environment for resolving type-definitions *)\n module Tenv : sig\n type key = Gid.t * Tid.t\n type t\n\n val find : t -> key -> [ `Recursion_level of int ] option\n val empty : t\n val extend : t -> key -> [ `Recursion_level of int ] -> t\n end = struct\n module Key = struct\n module T = struct\n type t = Gid.t * Tid.t [@@deriving compare, sexp_of]\n end\n\n include T\n include Comparator.Make (T)\n end\n\n type key = Key.t\n type t = [ `Recursion_level of int ] Map.M(Key).t\n\n let find t k = Map.find t k\n let empty = Map.empty (module Key)\n let extend t k v = Map.set ~key:k ~data:v t\n end\n\n (* [Defining.t]\n Monad for managing un-rolling depth, and maintaing a [Tenv.t] *)\n module Defining : sig\n type 'a t\n\n val return : 'a -> 'a t\n val bind : 'a t -> ('a -> 'b t) -> 'b t\n val look_env : Tenv.key -> Applicand.t option t\n val extend_new_tid : Tenv.key -> Canonical.Def.t t -> Applicand.t t\n val exec : 'a t -> 'a\n end = struct\n type 'a t = depth:int -> Tenv.t -> 'a\n\n let return x ~depth:_ _tenv = x\n\n let bind t f ~depth tenv =\n let x = t ~depth tenv in\n (f x) ~depth tenv\n ;;\n\n let look_env key ~depth:_ tenv =\n let result = Tenv.find tenv key in\n Option.map ~f:(fun (`Recursion_level x) -> Applicand.Recursion_level x) result\n ;;\n\n let extend_new_tid key def_t ~depth tenv =\n Applicand.Definition\n (let value = `Recursion_level depth in\n let tenv = Tenv.extend tenv key value in\n def_t ~depth:(depth + 1) tenv)\n ;;\n\n let exec t = t ~depth:0 Tenv.empty\n end\n\n type 'a defining = 'a Defining.t\n\n let ( >>= ) = Defining.bind\n let return = Defining.return\n\n let sequence_defining : 'a list -> f:('a -> 'b defining) -> 'b list defining =\n fun xs ~f ->\n let rec loop acc_ys = function\n | [] -> return (List.rev acc_ys)\n | x :: xs -> f x >>= fun y -> loop (y :: acc_ys) xs\n in\n loop [] xs\n ;;\n\n (*\n Shape evaluation.\n\n Shapes are evaluated to canonical-shape (expressions), with additional defs collected\n in the [defining] monad, which also manages generation/mapping to [Canonical.Tid.t]\n\n There is downwards context of [group] and [Venv.t]\n The (current) [group] changes when the case for [Top_app] calls [eval_app].\n\n The current [Venv.t] is abandoned when [eval_app] is called, and then re-created after\n the decision has been made to either inline the type-application, or make a reference\n to a type-definition, which is created at most once for each (Gid.t * Tid.t).\n\n We make a type-definition always for Records and Variants, and in addition for any\n other cyclic type-definition.\n *)\n\n let rec eval : group -> Venv.t -> t -> Visibility.visible Canonical.Exp1.t defining =\n fun group venv t ->\n match t with\n | Record binds ->\n sequence_defining binds ~f:(fun (s, x) ->\n eval group venv x >>= fun y -> return (s, y))\n >>= fun binds -> return (Canonical.Create.record binds)\n | Variant alts ->\n sequence_defining alts ~f:(fun (s, xs) ->\n eval_list group venv xs >>= fun ys -> return (s, ys))\n >>= fun alts -> return (Canonical.Create.variant alts)\n | Var (loc, vid) ->\n (match Venv.lookup venv vid with\n | Some x -> return x\n | None -> eval_fail loc !\"Free type variable: '%{Vid}\" vid ())\n | Annotate (s, t) ->\n eval group venv t >>= fun v -> return (Canonical.Create.annotate s v)\n | Base (s, ts) ->\n eval_list group venv ts >>= fun vs -> return (Canonical.Create.basetype s vs)\n | Tuple ts ->\n eval_list group venv ts >>= fun vs -> return (Canonical.Create.tuple vs)\n | Top_app (in_group, tid, args) ->\n eval_list group venv args\n >>= fun args ->\n (* args evaluated in current group *)\n eval_app in_group tid args\n (* group changed here *)\n | Rec_app (tid, args) ->\n eval_list group venv args >>= fun args -> eval_app group tid args\n | Poly_variant (loc, cs) ->\n sequence_defining ~f:(eval_poly_constr group venv) cs\n >>= fun xss -> return (Canonical.Create.poly_variant loc (List.concat xss))\n\n and eval_list : group -> Venv.t -> t list -> _ Canonical.Exp1.t list defining =\n fun group venv ts -> sequence_defining ts ~f:(eval group venv)\n\n and eval_poly_constr\n : group -> Venv.t -> t poly_constr\n -> (string * Visibility.opaque Canonical.Exp1.t option) list defining\n =\n fun group venv c ->\n match c with\n | `Constr (s, None) -> return [ s, None ]\n | `Constr (s, Some t) ->\n eval group venv t >>= fun v -> return [ s, Some (Canonical.Exp1.opaque v) ]\n | `Inherit (loc, t) ->\n eval group venv t\n >>= fun v ->\n (match Canonical.Exp1.get_poly_variant v with\n | Ok tab -> return (Sorted_table.expose tab)\n | Error desc ->\n eval_fail\n loc\n \"The shape for an inherited type is not described as a polymorphic-variant: %s\"\n desc\n ())\n\n and eval_definition : group -> Vid.t list -> t -> Canonical.Def.t defining =\n fun group formals body ->\n let venv = Venv.create (List.mapi formals ~f:(fun i x -> x, Canonical.Exp1.var i)) in\n eval group venv body >>= fun v -> return (Canonical.Create.define v)\n\n and eval_app : group -> Tid.t -> _ Canonical.Exp1.t list -> _ Canonical.Exp1.t defining\n =\n fun group tid args ->\n let gid = Group.id group in\n let formals, body = Group.lookup group tid in\n let record_or_normal_variant =\n match body with\n | Record _ | Variant _ -> true\n | Tuple _ | Annotate _ | Base _ | Poly_variant _ | Var _ | Rec_app _ | Top_app _ ->\n false\n in\n let cyclic = is_cyclic group tid in\n let cyclic_no_VR = is_cyclic_with_no_intervening_VR group tid in\n if (record_or_normal_variant && cyclic) || cyclic_no_VR\n then\n Defining.look_env (gid, tid)\n >>= (function\n | Some recurse -> return recurse\n | None ->\n Defining.extend_new_tid (gid, tid) (eval_definition group formals body))\n >>= function\n | Recursion_level r -> return (Canonical.Exp1.recurse r args)\n | Definition def -> return (Canonical.Exp1.apply def args)\n else (\n let venv =\n match List.zip formals args with\n | Ok x -> Venv.create x\n | Unequal_lengths -> failwith \"apply, incorrect type application arity\"\n in\n eval group venv body)\n ;;\n\n (* top level entry point for evaluation *)\n let eval : t -> Canonical.t =\n fun t ->\n let group = group (Location.of_string \"top-level\") [] in\n let venv = Venv.create [] in\n let v = Defining.exec (eval group venv t) in\n Canonical.Create.create v\n ;;\nend\n\nmodule Canonical = struct\n include Canonical_full\n\n module Exp = struct\n type t = Visibility.visible Exp1.t\n end\nend\n\ninclude Evaluation (Canonical_full)\nmodule Canonical_selected = Canonical_digest\nmodule Evaluation_to_digest = Evaluation (Canonical_selected)\n\nlet eval_to_digest exp = Canonical_selected.to_digest (Evaluation_to_digest.eval exp)\nlet eval_to_digest_string exp = Digest.to_hex (eval_to_digest exp)\n\nmodule For_typerep = struct\n exception Not_a_tuple of t [@@deriving sexp_of]\n\n let deconstruct_tuple_exn t =\n match t with\n | Tuple ts -> ts\n | _ -> raise (Not_a_tuple t)\n ;;\nend\n","open! Base\nopen! Import\n\ntype t = Caml.in_channel\n\nlet equal (t1 : t) t2 = phys_equal t1 t2\n\nlet seek = Caml.LargeFile.seek_in\nlet pos = Caml.LargeFile.pos_in\nlet length = Caml.LargeFile.in_channel_length\n\nlet stdin = Caml.stdin\n\nlet create ?(binary = true) file =\n let flags = [Open_rdonly] in\n let flags = if binary then Open_binary :: flags else flags in\n Caml.open_in_gen flags 0o000 file\n;;\n\nlet close = Caml.close_in\n\nlet with_file ?binary file ~f = Exn.protectx (create ?binary file) ~f ~finally:close\n\nlet may_eof f = try Some (f ()) with End_of_file -> None\n\nlet input t ~buf ~pos ~len = Caml.input t buf pos len\nlet really_input t ~buf ~pos ~len =\n may_eof (fun () -> Caml.really_input t buf pos len)\nlet really_input_exn t ~buf ~pos ~len =\n Caml.really_input t buf pos len\nlet input_byte t = may_eof (fun () -> Caml.input_byte t)\nlet input_char t = may_eof (fun () -> Caml.input_char t)\nlet input_binary_int t = may_eof (fun () -> Caml.input_binary_int t)\nlet unsafe_input_value t = may_eof (fun () -> Caml.input_value t)\nlet input_buffer t buf ~len = may_eof (fun () -> Caml.Buffer.add_channel buf t len)\n\nlet set_binary_mode = Caml.set_binary_mode_in\n\nlet input_all t =\n (* We use 65536 because that is the size of OCaml's IO buffers. *)\n let chunk_size = 65536 in\n let buffer = Buffer.create chunk_size in\n let rec loop () =\n Caml.Buffer.add_channel buffer t chunk_size;\n loop ()\n in\n try loop () with\n | End_of_file -> Buffer.contents buffer\n;;\n\nlet trim ~fix_win_eol line =\n if fix_win_eol then begin\n let len = String.length line in\n if len > 0\n && Char.equal (String.get line (len - 1)) '\\r'\n then String.sub line ~pos:0 ~len:(len - 1)\n else line\n end\n else line\n\nlet input_line ?(fix_win_eol = true) t =\n match may_eof (fun () -> Caml.input_line t) with\n | None -> None\n | Some line -> Some (trim ~fix_win_eol line)\n;;\n\nlet input_line_exn ?(fix_win_eol = true) t =\n let line = Caml.input_line t in\n trim ~fix_win_eol line\n\nlet fold_lines ?fix_win_eol t ~init ~f =\n let rec loop ac =\n match input_line ?fix_win_eol t with\n | None -> ac\n | Some line -> loop (f ac line)\n in\n loop init\n;;\n\nlet input_lines ?fix_win_eol t =\n List.rev\n (fold_lines ?fix_win_eol t ~init:[] ~f:(fun lines line -> line :: lines))\n;;\n\nlet iter_lines ?fix_win_eol t ~f =\n fold_lines ?fix_win_eol t ~init:() ~f:(fun () line -> f line)\n;;\n\nlet read_lines ?fix_win_eol fname = with_file fname ~f:(input_lines ?fix_win_eol)\n\nlet read_all fname = with_file fname ~f:input_all\n","open! Base\nopen! Import\n\ntype t = Caml.out_channel\n\nlet equal (t1 : t) t2 = phys_equal t1 t2\n\nlet seek = Caml.LargeFile.seek_out\nlet pos = Caml.LargeFile.pos_out\nlet length = Caml.LargeFile.out_channel_length\n\nlet stdout = Caml.stdout\nlet stderr = Caml.stderr\n\nlet sexp_of_t t =\n if phys_equal t stderr\n then Sexp.Atom \"\"\n else if phys_equal t stdout\n then Sexp.Atom \"\"\n else Sexp.Atom \"\"\n;;\n\ntype 'a with_create_args =\n ?binary:bool\n -> ?append:bool\n -> ?fail_if_exists:bool\n -> ?perm:int\n -> 'a\n\nlet create ?(binary = true) ?(append = false) ?(fail_if_exists = false) ?(perm = 0o666) file =\n let flags = [Open_wronly; Open_creat] in\n let flags = (if binary then Open_binary else Open_text) :: flags in\n let flags = (if append then Open_append else Open_trunc) :: flags in\n let flags = (if fail_if_exists then Open_excl :: flags else flags) in\n Caml.open_out_gen flags perm file\n;;\n\nlet set_binary_mode = Caml.set_binary_mode_out\n\nlet flush = Caml.flush\n\nlet close = Caml.close_out\nlet close_no_err = Caml.close_out_noerr\n\nlet output t ~buf ~pos ~len = Caml.output t buf pos len\nlet output_substring t ~buf ~pos ~len = Caml.output_substring t buf pos len\nlet output_string = Caml.output_string\nlet output_bytes = Caml.output_bytes\nlet output_char = Caml.output_char\nlet output_byte = Caml.output_byte\nlet output_binary_int = Caml.output_binary_int\nlet output_buffer = Caml.Buffer.output_buffer\nlet output_value = Caml.output_value\n\nlet newline t = output_string t \"\\n\"\n\nlet output_lines t lines =\n List.iter lines ~f:(fun line -> output_string t line; newline t)\n;;\n\nlet printf = Caml.Printf.printf\nlet eprintf = Caml.Printf.eprintf\nlet fprintf = Caml.Printf.fprintf\nlet kfprintf = Caml.Printf.kfprintf\n\nlet print_string = Caml.print_string\nlet print_endline = Caml.print_endline\nlet prerr_endline = Caml.prerr_endline\n\nlet print_s ?mach sexp =\n print_endline\n (match mach with\n | Some () -> Sexp.to_string_mach sexp\n | None -> Sexp.to_string_hum sexp)\n;;\n\nlet eprint_s ?mach sexp =\n prerr_endline\n (match mach with\n | Some () -> Sexp.to_string_mach sexp\n | None -> Sexp.to_string_hum sexp)\n;;\n\n\nlet with_file ?binary ?append ?fail_if_exists ?perm file ~f =\n Exn.protectx (create ?binary ?append ?fail_if_exists ?perm file) ~f ~finally:close\n;;\n\nlet write_lines file lines = with_file file ~f:(fun t -> output_lines t lines)\n\nlet write_all file ~data = with_file file ~f:(fun t -> output_string t data)\n","open! Base\nmodule Gc = Caml.Gc\n\nexternal __MODULE__ : string = \"%loc_MODULE\"\n\nlet am_recording_environment_variable = \"PPX_MODULE_TIMER\"\n\nlet get_am_recording_environment_variable () =\n (* avoid Caml.Sys.getenv_opt to preserve 4.04.x compatibility *)\n match Caml.Sys.getenv am_recording_environment_variable with\n | value -> Some value\n | exception _ -> None\n;;\n\nlet am_recording_value = get_am_recording_environment_variable ()\nlet am_recording = Option.is_some am_recording_value\n\nmodule Duration = struct\n type t = Int63.t\n\n let to_nanoseconds t = t\n let of_nanoseconds t = t\n\n module type Format = sig\n val of_string : string -> t\n val to_string_with_same_unit : t list -> string list\n end\n\n module Default_format = struct\n let of_string string = String.chop_suffix_exn string ~suffix:\"ns\" |> Int63.of_string\n let to_string nanos = Int63.to_string nanos ^ \"ns\"\n let to_string_with_same_unit list = List.map list ~f:to_string\n end\n\n let format = ref (module Default_format : Format)\n\n let of_string string =\n let (module Format) = !format in\n Format.of_string string\n ;;\n\n let to_string_with_same_unit string =\n let (module Format) = !format in\n Format.to_string_with_same_unit string\n ;;\nend\n\nmodule Gc_events = struct\n type t =\n { minor_collections : int\n ; major_collections : int\n ; compactions : int\n }\nend\n\nmodule Timing_event = struct\n type t =\n { description : string\n ; runtime : Duration.t\n ; gc_events : Gc_events.t\n ; nested_timing_events : t list\n }\nend\n\nmodule Timer = struct\n type t =\n { mutable currently_running_description : string\n ; mutable currently_running_start_time : Duration.t\n ; mutable currently_running_gc_stats : Gc.stat\n ; mutable nested_timer : t option\n ; mutable timing_events_in_reverse_chronological_order : Timing_event.t list\n }\n\n let create ?nested_timer () =\n { currently_running_description = \"\"\n ; currently_running_start_time = Int63.zero\n ; currently_running_gc_stats = Gc.quick_stat ()\n ; nested_timer\n ; timing_events_in_reverse_chronological_order = []\n }\n ;;\n\n let reset t =\n t.currently_running_description <- \"\";\n t.currently_running_start_time <- Int63.zero;\n match t.nested_timer with\n | None -> ()\n | Some nested -> nested.timing_events_in_reverse_chronological_order <- []\n ;;\n\n let record_start t description =\n if am_recording\n then (\n assert (String.is_empty t.currently_running_description);\n t.currently_running_description <- description;\n t.currently_running_gc_stats <- Gc.quick_stat ();\n (* call [Time_now] as late as possible before running the module body *)\n t.currently_running_start_time <- Time_now.nanoseconds_since_unix_epoch ())\n ;;\n\n let record_until t description =\n if am_recording\n then (\n (* compute [Time_now] as soon as possible after running the module body *)\n let until = Time_now.nanoseconds_since_unix_epoch () in\n let start = t.currently_running_start_time in\n let gc_stats_after = Gc.quick_stat () in\n let gc_stats_before = t.currently_running_gc_stats in\n let runtime = Int63.( - ) until start in\n assert (String.equal t.currently_running_description description);\n let gc_events : Gc_events.t =\n { minor_collections =\n gc_stats_after.minor_collections - gc_stats_before.minor_collections\n ; major_collections =\n gc_stats_after.major_collections - gc_stats_before.major_collections\n ; compactions = gc_stats_after.compactions - gc_stats_before.compactions\n }\n in\n let nested_timing_events =\n match t.nested_timer with\n | None -> []\n | Some nested -> List.rev nested.timing_events_in_reverse_chronological_order\n in\n let timing_event : Timing_event.t =\n { description; runtime; gc_events; nested_timing_events }\n in\n t.timing_events_in_reverse_chronological_order\n <- timing_event :: t.timing_events_in_reverse_chronological_order;\n reset t)\n ;;\nend\n\nlet definition_timer = Timer.create ()\nlet module_timer = Timer.create ~nested_timer:definition_timer ()\nlet record_start module_name = Timer.record_start module_timer module_name\nlet record_until module_name = Timer.record_until module_timer module_name\nlet record_definition_start loc = Timer.record_start definition_timer loc\nlet record_definition_until loc = Timer.record_until definition_timer loc\n\nlet gc_events_suffix_string\n ({ minor_collections; major_collections; compactions } : Gc_events.t)\n =\n let to_list description count =\n if count = 0 then [] else [ Int.to_string count ^ \" \" ^ description ]\n in\n let strings =\n to_list \"minor collections\" minor_collections\n @ to_list \"major collections\" major_collections\n @ to_list \"compactions\" compactions\n in\n if List.is_empty strings then \"\" else \"; GC: \" ^ String.concat strings ~sep:\", \"\n;;\n\nlet with_left_column_right_justified list =\n let left_column_width =\n List.fold list ~init:0 ~f:(fun width (left, _) -> Int.max width (String.length left))\n in\n List.map list ~f:(fun (left, right) ->\n Printf.sprintf \"%*s %s\" left_column_width left right)\n;;\n\nlet rec timing_events_to_strings list ~indent =\n let duration_strings =\n List.map list ~f:(fun (timing_event : Timing_event.t) -> timing_event.runtime)\n |> Duration.to_string_with_same_unit\n in\n let prefix = String.make indent ' ' in\n List.map2_exn\n duration_strings\n list\n ~f:(fun duration_string\n { runtime = _; description; gc_events; nested_timing_events }\n ->\n ( duration_string\n , description\n ^ gc_events_suffix_string gc_events\n ^ String.concat\n (List.map\n (timing_events_to_strings nested_timing_events ~indent:(indent + 4))\n ~f:(fun line -> \"\\n\" ^ line)) ))\n |> with_left_column_right_justified\n |> List.map ~f:(fun line -> prefix ^ line)\n;;\n\nlet fake_timing_events =\n let gc_events i : Gc_events.t =\n { minor_collections = (if i % 2 = 1 then 1 else 0)\n ; major_collections = (if i % 4 = 3 then 1 else 0)\n ; compactions = (if i % 8 = 7 then 1 else 0)\n }\n in\n lazy\n (List.init 12 ~f:(fun i ->\n ({ description = Printf.sprintf \"Fake__Dependency_%d\" (i + 1)\n ; runtime = Int63.of_int (900 * (i + 1))\n ; gc_events = gc_events i\n ; nested_timing_events =\n (if (i + 1) % 4 = 0\n then\n List.init (i + 1) ~f:(fun j ->\n ({ description = Printf.sprintf \"Line %d\" (j + 1)\n ; runtime = Int63.of_int (900 * (j + 1))\n ; gc_events = gc_events j\n ; nested_timing_events = []\n }\n : Timing_event.t))\n else [])\n }\n : Timing_event.t)))\n;;\n\nlet print_recorded_timing_events timing_events =\n let notify_of_overriding () =\n Stdio.print_endline \"ppx_module_timer: overriding time measurements for testing\"\n in\n let timing_events =\n match Option.value_exn am_recording_value with\n | \"FAKE_MODULES\" ->\n notify_of_overriding ();\n force fake_timing_events\n | string ->\n (match Duration.of_string string with\n | override ->\n notify_of_overriding ();\n List.mapi timing_events ~f:(fun index (timing_event : Timing_event.t) ->\n let runtime = Int63.( * ) override (Int63.of_int (index + 1)) in\n let nested_timing_events =\n List.mapi\n timing_event.nested_timing_events\n ~f:(fun index nested_timing_event ->\n let runtime = Int63.( * ) override (Int63.of_int (index + 1)) in\n { nested_timing_event with runtime })\n in\n { timing_event with runtime; nested_timing_events })\n | exception _ -> timing_events)\n in\n timing_events |> timing_events_to_strings ~indent:0 |> List.iter ~f:Stdio.print_endline\n;;\n\nlet () =\n if am_recording\n then\n Caml.at_exit (fun () ->\n print_recorded_timing_events\n (List.rev module_timer.timing_events_in_reverse_chronological_order))\n;;\n","module Name_of = struct\n let typename_of_int =\n let module M = Typename.Make0(struct type t = int let name = \"int\" end) in\n M.typename_of_t\n\n let typename_of_int32 =\n let module M = Typename.Make0(struct type t = int32 let name = \"int32\" end) in\n M.typename_of_t\n\n let typename_of_int64 =\n let module M = Typename.Make0(struct type t = int64 let name = \"int64\" end) in\n M.typename_of_t\n\n let typename_of_nativeint =\n let module M = Typename.Make0(struct\n type t = nativeint\n let name = \"nativeint\"\n end) in\n M.typename_of_t\n\n let typename_of_char =\n let module M = Typename.Make0(struct type t = char let name = \"char\" end) in\n M.typename_of_t\n\n let typename_of_float =\n let module M = Typename.Make0(struct type t = float let name = \"float\" end) in\n M.typename_of_t\n\n let typename_of_string =\n let module M = Typename.Make0(struct type t = string let name = \"string\" end) in\n M.typename_of_t\n\n let typename_of_bytes =\n let module M = Typename.Make0(struct type t = bytes let name = \"bytes\" end) in\n M.typename_of_t\n\n let typename_of_bool =\n let module M = Typename.Make0(struct type t = bool let name = \"bool\" end) in\n M.typename_of_t\n\n let typename_of_unit =\n let module M = Typename.Make0(struct type t = unit let name = \"unit\" end) in\n M.typename_of_t\n\n module M_option = Typename.Make1(struct type 'a t = 'a option let name = \"option\" end)\n let typename_of_option = M_option.typename_of_t\n\n module M_list = Typename.Make1(struct type 'a t = 'a list let name = \"list\" end)\n let typename_of_list = M_list.typename_of_t\n\n module M_array = Typename.Make1(struct type 'a t = 'a array let name = \"array\" end)\n let typename_of_array = M_array.typename_of_t\n\n module M_lazy_t = Typename.Make1(struct type 'a t = 'a lazy_t let name = \"lazy_t\" end)\n let typename_of_lazy_t = M_lazy_t.typename_of_t\n\n module M_ref = Typename.Make1(struct type 'a t = 'a ref let name = \"ref\" end)\n let typename_of_ref = M_ref.typename_of_t\n\n module M_function = Typename.Make2(struct\n type ('a, 'b) t = 'a -> 'b\n let name = \"function\"\n end)\n let typename_of_function = M_function.typename_of_t\n\n type tuple0 = unit\n module M_tuple0 = Typename.Make0(struct type t = tuple0 let name = \"tuple0\" end)\n let typename_of_tuple0 = M_tuple0.typename_of_t\n\n module M_tuple2 = Typename.Make2(struct\n type ('a, 'b) t = 'a * 'b\n let name = \"tuple2\"\n end)\n let typename_of_tuple2 = M_tuple2.typename_of_t\n\n module M_tuple3 = Typename.Make3(struct\n type ('a, 'b, 'c) t = 'a * 'b * 'c\n let name = \"tuple3\"\n end)\n let typename_of_tuple3 = M_tuple3.typename_of_t\n\n module M_tuple4 = Typename.Make4(struct\n type ('a, 'b, 'c, 'd) t = 'a * 'b * 'c * 'd\n let name = \"tuple4\"\n end)\n let typename_of_tuple4 = M_tuple4.typename_of_t\n\n module M_tuple5 = Typename.Make5(struct\n type ('a, 'b, 'c, 'd, 'e) t = 'a * 'b * 'c *'d * 'e\n let name = \"tuple5\"\n end)\n let typename_of_tuple5 = M_tuple5.typename_of_t\nend\n\nmodule rec Typerep : sig\n\n type _ t =\n | Int : int t\n | Int32 : int32 t\n | Int64 : int64 t\n | Nativeint : nativeint t\n | Char : char t\n | Float : float t\n | String : string t\n | Bytes : bytes t\n | Bool : bool t\n | Unit : unit t\n | Option : 'a t -> 'a option t\n | List : 'a t -> 'a list t\n | Array : 'a t -> 'a array t\n | Lazy : 'a t -> 'a lazy_t t\n | Ref : 'a t -> 'a ref t\n | Function : ('dom t * 'rng t) -> ('dom -> 'rng) t\n | Tuple : 'a Typerep.Tuple.t -> 'a t\n | Record : 'a Typerep.Record.t -> 'a t\n | Variant : 'a Typerep.Variant.t -> 'a t\n | Named : ('a Typerep.Named.t * 'a t lazy_t option) -> 'a t\n\n type packed = T : 'a t -> packed\n\n module Named : sig\n module type T0 = sig\n type named\n type t\n val typename_of_named : named Typename.t\n val typename_of_t : t Typename.t\n val witness : (t, named) Type_equal.t\n end\n module type T1 = sig\n type 'a named\n type a val a : a Typerep.t\n type t\n val typename_of_named : 'a Typename.t -> 'a named Typename.t\n val typename_of_t : t Typename.t\n val witness : (t, a named) Type_equal.t\n end\n module type T2 = sig\n type ('a, 'b) named\n type a val a : a Typerep.t\n type b val b : b Typerep.t\n type t\n val typename_of_named :\n 'a Typename.t\n -> 'b Typename.t\n -> ('a, 'b) named Typename.t\n val typename_of_t : t Typename.t\n val witness : (t, (a, b) named) Type_equal.t\n end\n module type T3 = sig\n type ('a, 'b, 'c) named\n type a val a : a Typerep.t\n type b val b : b Typerep.t\n type c val c : c Typerep.t\n type t\n val typename_of_named :\n 'a Typename.t\n -> 'b Typename.t\n -> 'c Typename.t\n -> ('a, 'b, 'c) named Typename.t\n val typename_of_t : t Typename.t\n val witness : (t, (a, b, c) named) Type_equal.t\n end\n module type T4 = sig\n type ('a, 'b, 'c, 'd) named\n type a val a : a Typerep.t\n type b val b : b Typerep.t\n type c val c : c Typerep.t\n type d val d : d Typerep.t\n type t\n val typename_of_named :\n 'a Typename.t\n -> 'b Typename.t\n -> 'c Typename.t\n -> 'd Typename.t\n -> ('a, 'b, 'c, 'd) named Typename.t\n val typename_of_t : t Typename.t\n val witness : (t, (a, b, c, d) named) Type_equal.t\n end\n module type T5 = sig\n type ('a, 'b, 'c, 'd, 'e) named\n type a val a : a Typerep.t\n type b val b : b Typerep.t\n type c val c : c Typerep.t\n type d val d : d Typerep.t\n type e val e : e Typerep.t\n type t\n val typename_of_named :\n 'a Typename.t\n -> 'b Typename.t\n -> 'c Typename.t\n -> 'd Typename.t\n -> 'e Typename.t\n -> ('a, 'b, 'c, 'd, 'e) named Typename.t\n val typename_of_t : t Typename.t\n val witness : (t, (a, b, c, d, e) named) Type_equal.t\n end\n (* there the module is necessary because we need to deal with a type [t] with\n parameters whose kind is not representable as a type variable: ['a 't], even with\n a gadt. *)\n type 'a t =\n | T0 of (module T0 with type t = 'a)\n | T1 of (module T1 with type t = 'a)\n | T2 of (module T2 with type t = 'a)\n | T3 of (module T3 with type t = 'a)\n | T4 of (module T4 with type t = 'a)\n | T5 of (module T5 with type t = 'a)\n\n val arity : _ t -> int\n val typename_of_t : 'a t -> 'a Typename.t\n val name : _ t -> string\n end\n\n module Tuple : sig\n (* these constructors could be plunged at toplevel of Typerep.t, however it is less\n verbose that way *)\n type _ t =\n | T2 : ('a Typerep.t * 'b Typerep.t)\n -> ('a * 'b) t\n | T3 : ('a Typerep.t * 'b Typerep.t * 'c Typerep.t)\n -> ('a * 'b * 'c) t\n | T4 : ('a Typerep.t * 'b Typerep.t * 'c Typerep.t * 'd Typerep.t)\n -> ('a * 'b * 'c * 'd) t\n | T5 : ('a Typerep.t * 'b Typerep.t * 'c Typerep.t * 'd Typerep.t * 'e Typerep.t)\n -> ('a * 'b * 'c * 'd * 'e) t\n\n val arity : _ t -> int\n val typename_of_t : 'a t -> 'a Typename.t\n end\n\n include Variant_and_record_intf.S with type 'a t := 'a Typerep.t\n\n val same : _ t -> _ t -> bool\n val same_witness : 'a t -> 'b t -> ('a, 'b) Type_equal.t option\n val same_witness_exn : 'a t -> 'b t -> ('a, 'b) Type_equal.t\n val typename_of_t : 'a t -> 'a Typename.t\n val head : 'a t -> 'a t\nend = struct\n\n type _ t =\n | Int : int t\n | Int32 : int32 t\n | Int64 : int64 t\n | Nativeint : nativeint t\n | Char : char t\n | Float : float t\n | String : string t\n | Bytes : bytes t\n | Bool : bool t\n | Unit : unit t\n | Option : 'a t -> 'a option t\n | List : 'a t -> 'a list t\n | Array : 'a t -> 'a array t\n | Lazy : 'a t -> 'a lazy_t t\n | Ref : 'a t -> 'a ref t\n | Function : ('dom t * 'rng t) -> ('dom -> 'rng) t\n | Tuple : 'a Typerep.Tuple.t -> 'a t\n | Record : 'a Typerep.Record.t -> 'a t\n | Variant : 'a Typerep.Variant.t -> 'a t\n | Named : ('a Typerep.Named.t * 'a t lazy_t option) -> 'a t\n\n type packed = T : 'a t -> packed\n\n module Named = struct\n module type T0 = sig\n type named\n type t\n val typename_of_named : named Typename.t\n val typename_of_t : t Typename.t\n val witness : (t, named) Type_equal.t\n end\n module type T1 = sig\n type 'a named\n type a val a : a Typerep.t\n type t\n val typename_of_named : 'a Typename.t -> 'a named Typename.t\n val typename_of_t : t Typename.t\n val witness : (t, a named) Type_equal.t\n end\n module type T2 = sig\n type ('a, 'b) named\n type a val a : a Typerep.t\n type b val b : b Typerep.t\n type t\n val typename_of_named :\n 'a Typename.t\n -> 'b Typename.t\n -> ('a, 'b) named Typename.t\n val typename_of_t : t Typename.t\n val witness : (t, (a, b) named) Type_equal.t\n end\n module type T3 = sig\n type ('a, 'b, 'c) named\n type a val a : a Typerep.t\n type b val b : b Typerep.t\n type c val c : c Typerep.t\n type t\n val typename_of_named :\n 'a Typename.t\n -> 'b Typename.t\n -> 'c Typename.t\n -> ('a, 'b, 'c) named Typename.t\n val typename_of_t : t Typename.t\n val witness : (t, (a, b, c) named) Type_equal.t\n end\n module type T4 = sig\n type ('a, 'b, 'c, 'd) named\n type a val a : a Typerep.t\n type b val b : b Typerep.t\n type c val c : c Typerep.t\n type d val d : d Typerep.t\n type t\n val typename_of_named :\n 'a Typename.t\n -> 'b Typename.t\n -> 'c Typename.t\n -> 'd Typename.t\n -> ('a, 'b, 'c, 'd) named Typename.t\n val typename_of_t : t Typename.t\n val witness : (t, (a, b, c, d) named) Type_equal.t\n end\n module type T5 = sig\n type ('a, 'b, 'c, 'd, 'e) named\n type a val a : a Typerep.t\n type b val b : b Typerep.t\n type c val c : c Typerep.t\n type d val d : d Typerep.t\n type e val e : e Typerep.t\n type t\n val typename_of_named :\n 'a Typename.t\n -> 'b Typename.t\n -> 'c Typename.t\n -> 'd Typename.t\n -> 'e Typename.t\n -> ('a, 'b, 'c, 'd, 'e) named Typename.t\n val typename_of_t : t Typename.t\n val witness : (t, (a, b, c, d, e) named) Type_equal.t\n end\n (* there the module is necessary because we need to deal with a type [t] with\n parameters whose kind is not representable as a type variable: ['a 't], even with\n a gadt. *)\n type 'a t =\n | T0 of (module T0 with type t = 'a)\n | T1 of (module T1 with type t = 'a)\n | T2 of (module T2 with type t = 'a)\n | T3 of (module T3 with type t = 'a)\n | T4 of (module T4 with type t = 'a)\n | T5 of (module T5 with type t = 'a)\n\n let arity = function\n | T0 _ -> 0\n | T1 _ -> 1\n | T2 _ -> 2\n | T3 _ -> 3\n | T4 _ -> 4\n | T5 _ -> 5\n\n let typename_of_t (type a) = function\n | T0 rep ->\n let module T = (val rep : T0 with type t = a) in\n T.typename_of_t\n | T1 rep ->\n let module T = (val rep : T1 with type t = a) in\n T.typename_of_t\n | T2 rep ->\n let module T = (val rep : T2 with type t = a) in\n T.typename_of_t\n | T3 rep ->\n let module T = (val rep : T3 with type t = a) in\n T.typename_of_t\n | T4 rep ->\n let module T = (val rep : T4 with type t = a) in\n T.typename_of_t\n | T5 rep ->\n let module T = (val rep : T5 with type t = a) in\n T.typename_of_t\n\n let name rep =\n Typename.Uid.name (Typename.uid (typename_of_t rep))\n end\n\n module Tuple = struct\n (* these constructors could be plunged at toplevel of Typerep.t, however it is less\n verbose this way *)\n type _ t =\n | T2 : ('a Typerep.t * 'b Typerep.t)\n -> ('a * 'b) t\n | T3 : ('a Typerep.t * 'b Typerep.t * 'c Typerep.t)\n -> ('a * 'b * 'c) t\n | T4 : ('a Typerep.t * 'b Typerep.t * 'c Typerep.t * 'd Typerep.t)\n -> ('a * 'b * 'c * 'd) t\n | T5 : ('a Typerep.t * 'b Typerep.t * 'c Typerep.t * 'd Typerep.t * 'e Typerep.t)\n -> ('a * 'b * 'c * 'd * 'e) t\n\n let arity : type a. a t -> int = function\n | Typerep.Tuple.T2 _ -> 2\n | Typerep.Tuple.T3 _ -> 3\n | Typerep.Tuple.T4 _ -> 4\n | Typerep.Tuple.T5 _ -> 5\n\n let typename_of_t : type a. a t -> a Typename.t = function\n | T2 (a, b) ->\n Name_of.typename_of_tuple2\n (Typerep.typename_of_t a)\n (Typerep.typename_of_t b)\n | T3 (a, b, c) ->\n Name_of.typename_of_tuple3\n (Typerep.typename_of_t a)\n (Typerep.typename_of_t b)\n (Typerep.typename_of_t c)\n | T4 (a, b, c, d) ->\n Name_of.typename_of_tuple4\n (Typerep.typename_of_t a)\n (Typerep.typename_of_t b)\n (Typerep.typename_of_t c)\n (Typerep.typename_of_t d)\n | T5 (a, b, c, d, e) ->\n Name_of.typename_of_tuple5\n (Typerep.typename_of_t a)\n (Typerep.typename_of_t b)\n (Typerep.typename_of_t c)\n (Typerep.typename_of_t d)\n (Typerep.typename_of_t e)\n end\n\n include Variant_and_record_intf.M (struct type 'a rep = 'a t type 'a t = 'a rep end)\n\n let rec typename_of_t : type a. a t -> a Typename.t = function\n | Int -> Name_of.typename_of_int\n | Int32 -> Name_of.typename_of_int32\n | Int64 -> Name_of.typename_of_int64\n | Nativeint -> Name_of.typename_of_nativeint\n | Char -> Name_of.typename_of_char\n | Float -> Name_of.typename_of_float\n | String -> Name_of.typename_of_string\n | Bytes -> Name_of.typename_of_bytes\n | Bool -> Name_of.typename_of_bool\n | Unit -> Name_of.typename_of_unit\n\n | Option rep -> Name_of.typename_of_option (typename_of_t rep)\n | List rep -> Name_of.typename_of_list (typename_of_t rep)\n | Array rep -> Name_of.typename_of_array (typename_of_t rep)\n | Lazy rep -> Name_of.typename_of_lazy_t (typename_of_t rep)\n | Ref rep -> Name_of.typename_of_ref (typename_of_t rep)\n\n | Function (dom, rng) ->\n Name_of.typename_of_function (typename_of_t dom) (typename_of_t rng)\n\n | Tuple rep -> Typerep.Tuple.typename_of_t rep\n\n | Record rep -> Typerep.Record.typename_of_t rep\n | Variant rep -> Typerep.Variant.typename_of_t rep\n\n | Named (name, _) -> Named.typename_of_t name\n ;;\n\n let rec same_witness : type a b. a t -> b t -> (a, b) Type_equal.t option = fun t1 t2 ->\n let module E = Type_equal in\n match t1, t2 with\n | Named (name1, r1), Named (name2, r2) -> begin\n match Typename.same_witness\n (Named.typename_of_t name1)\n (Named.typename_of_t name2) with\n | Some E.T as x -> x\n | None ->\n match r1, r2 with\n | Some (lazy t1), Some (lazy t2) -> same_witness t1 t2\n | Some (lazy t1), None -> same_witness t1 t2\n | None, Some (lazy t2) -> same_witness t1 t2\n | None, None -> None\n end\n | Named (_, r1), t2 -> begin\n match r1 with\n | Some (lazy t1) -> same_witness t1 t2\n | None -> None\n end\n | t1, Named (_, r2) -> begin\n match r2 with\n | Some (lazy t2) -> same_witness t1 t2\n | None -> None\n end\n | Int , Int -> Some E.T\n | Int32 , Int32 -> Some E.T\n | Int64 , Int64 -> Some E.T\n | Nativeint , Nativeint -> Some E.T\n | Char , Char -> Some E.T\n | Float , Float -> Some E.T\n | String , String -> Some E.T\n | Bytes , Bytes -> Some E.T\n | Bool , Bool -> Some E.T\n | Unit , Unit -> Some E.T\n | Option r1, Option r2 -> begin\n match same_witness r1 r2 with\n | None as x -> x\n | Some E.T as x -> x\n end\n | List r1, List r2 -> begin\n match same_witness r1 r2 with\n | None as x -> x\n | Some E.T as x -> x\n end\n | Array r1, Array r2 -> begin\n match same_witness r1 r2 with\n | None as x -> x\n | Some E.T as x -> x\n end\n | Lazy r1, Lazy r2 -> begin\n match same_witness r1 r2 with\n | None as x -> x\n | Some E.T as x -> x\n end\n | Ref r1, Ref r2 -> begin\n match same_witness r1 r2 with\n | None as x -> x\n | Some E.T as x -> x\n end\n | Function (dom1, rng1), Function (dom2, rng2) -> begin\n match same_witness dom1 dom2, same_witness rng1 rng2 with\n | Some E.T, Some E.T -> Some E.T\n | None, _ | _, None -> None\n end\n | Tuple t1, Tuple t2 -> begin\n let module T = Typerep.Tuple in\n match t1, t2 with\n | T.T2 (a1, b1), T.T2 (a2, b2) -> begin\n match same_witness a1 a2, same_witness b1 b2 with\n | Some E.T, Some E.T -> Some E.T\n | None, _ | _, None -> None\n end\n | T.T3 (a1, b1, c1), T.T3 (a2, b2, c2) -> begin\n match\n same_witness a1 a2,\n same_witness b1 b2,\n same_witness c1 c2\n with\n | Some E.T, Some E.T, Some E.T -> Some E.T\n | None, _, _\n | _, None, _\n | _, _, None\n -> None\n end\n | T.T4 (a1, b1, c1, d1), T.T4 (a2, b2, c2, d2) -> begin\n match\n same_witness a1 a2,\n same_witness b1 b2,\n same_witness c1 c2,\n same_witness d1 d2\n with\n | Some E.T, Some E.T, Some E.T, Some E.T -> Some E.T\n | None, _, _, _\n | _, None, _, _\n | _, _, None, _\n | _, _, _, None\n -> None\n end\n | T.T5 (a1, b1, c1, d1, e1), T.T5 (a2, b2, c2, d2, e2) -> begin\n match\n same_witness a1 a2,\n same_witness b1 b2,\n same_witness c1 c2,\n same_witness d1 d2,\n same_witness e1 e2\n with\n | Some E.T, Some E.T, Some E.T, Some E.T, Some E.T -> Some E.T\n | None, _, _, _, _\n | _, None, _, _, _\n | _, _, None, _, _\n | _, _, _, None, _\n | _, _, _, _, None\n -> None\n end\n | T.T2 _, _ -> None\n | T.T3 _, _ -> None\n | T.T4 _, _ -> None\n | T.T5 _, _ -> None\n end\n | Record r1, Record r2 ->\n Typename.same_witness\n (Typerep.Record.typename_of_t r1)\n (Typerep.Record.typename_of_t r2)\n | Variant r1, Variant r2 ->\n Typename.same_witness\n (Typerep.Variant.typename_of_t r1)\n (Typerep.Variant.typename_of_t r2)\n | Int, _ -> None\n | Int32, _ -> None\n | Int64, _ -> None\n | Nativeint, _ -> None\n | Char, _ -> None\n | Float, _ -> None\n | String, _ -> None\n | Bytes, _ -> None\n | Bool, _ -> None\n | Unit, _ -> None\n | Option _, _ -> None\n | List _, _ -> None\n | Array _, _ -> None\n | Lazy _, _ -> None\n | Ref _, _ -> None\n | Function _, _ -> None\n | Tuple _, _ -> None\n | Record _, _ -> None\n | Variant _, _ -> None\n ;;\n\n let same a b = same_witness a b <> None\n let same_witness_exn a b =\n match same_witness a b with\n | Some proof -> proof\n | None -> assert false\n\n let rec head = function\n | Typerep.Named (_, Some (lazy t)) -> head t\n | t -> t\nend\n\nlet typerep_of_int = Typerep.Int\nlet typerep_of_int32 = Typerep.Int32\nlet typerep_of_int64 = Typerep.Int64\nlet typerep_of_nativeint = Typerep.Nativeint\nlet typerep_of_char = Typerep.Char\nlet typerep_of_float = Typerep.Float\nlet typerep_of_string = Typerep.String\nlet typerep_of_bytes = Typerep.Bytes\nlet typerep_of_bool = Typerep.Bool\nlet typerep_of_unit = Typerep.Unit\n\nlet typerep_of_option rep = Typerep.Option rep\nlet typerep_of_list rep = Typerep.List rep\nlet typerep_of_array rep = Typerep.Array rep\nlet typerep_of_lazy_t rep = Typerep.Lazy rep\nlet typerep_of_ref rep = Typerep.Ref rep\n\nlet typerep_of_function dom rng = Typerep.Function (dom, rng)\n\nlet typerep_of_tuple0 = Typerep.Unit\nlet typerep_of_tuple2 a b = Typerep.Tuple (Typerep.Tuple.T2 (a, b))\nlet typerep_of_tuple3 a b c = Typerep.Tuple (Typerep.Tuple.T3 (a, b, c))\nlet typerep_of_tuple4 a b c d = Typerep.Tuple (Typerep.Tuple.T4 (a, b, c, d))\nlet typerep_of_tuple5 a b c d e = Typerep.Tuple (Typerep.Tuple.T5 (a, b, c, d, e))\n\ninclude Name_of\nlet value_tuple0 = ()\n\nlet typerep_of_int63, typename_of_int63 =\n let typerep_and_typename_of_int63_repr\n : type a b . (a, b) Base.Int63.Private.Repr.t -> a Typerep.t * a Typename.t\n = function\n | Base.Int63.Private.Repr.Int -> typerep_of_int, typename_of_int\n | Base.Int63.Private.Repr.Int64 -> typerep_of_int64, typename_of_int64\n in\n typerep_and_typename_of_int63_repr Base.Int63.Private.repr\n","let __ocaml_lex_tables = {\n Lexing.lex_base =\n \"\\000\\000\\000\\000\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\005\\000\\000\\000\\000\\000\\001\\000\\255\\255\\002\\000\\000\\000\\000\\000\\\n \\001\\000\\000\\000\\002\\000\\001\\000\\003\\000\\000\\000\\003\\000\\003\\000\\\n \\000\\000\\001\\000\\009\\000\\005\\000\\002\\000\\004\\000\\017\\000\\012\\000\\\n \\014\\000\\004\\000\\017\\000\\018\\000\\026\\000\\028\\000\\005\\000\\027\\000\\\n \\016\\000\\020\\000\\023\\000\\006\\000\\085\\000\\253\\255\\254\\255\\001\\000\\\n \\046\\000\\047\\000\\040\\000\\031\\000\\046\\000\\048\\000\\007\\000\\079\\000\\\n \\028\\000\\062\\000\\008\\000\\255\\255\\009\\000\\067\\000\\067\\000\\103\\000\\\n \\100\\000\\105\\000\\095\\000\\107\\000\\095\\000\\113\\000\\010\\000\\104\\000\\\n \\104\\000\\116\\000\\104\\000\\122\\000\\104\\000\\116\\000\\111\\000\\113\\000\\\n \\011\\000\\116\\000\\117\\000\\125\\000\\127\\000\\012\\000\\126\\000\\115\\000\\\n \\119\\000\\122\\000\\013\\000\";\n Lexing.lex_backtrk =\n \"\\001\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\";\n Lexing.lex_default =\n \"\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\047\\000\\000\\000\\000\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\";\n Lexing.lex_trans =\n \"\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\008\\000\\012\\000\\014\\000\\024\\000\\012\\000\\039\\000\\012\\000\\055\\000\\\n \\059\\000\\061\\000\\071\\000\\059\\000\\086\\000\\059\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\001\\000\\048\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\002\\000\\049\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\034\\000\\003\\000\\029\\000\\007\\000\\006\\000\\010\\000\\009\\000\\\n \\023\\000\\004\\000\\017\\000\\019\\000\\021\\000\\018\\000\\027\\000\\025\\000\\\n \\015\\000\\026\\000\\016\\000\\005\\000\\011\\000\\020\\000\\022\\000\\028\\000\\\n \\030\\000\\013\\000\\031\\000\\032\\000\\033\\000\\035\\000\\036\\000\\037\\000\\\n \\038\\000\\040\\000\\041\\000\\042\\000\\043\\000\\046\\000\\046\\000\\046\\000\\\n \\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\081\\000\\\n \\050\\000\\051\\000\\052\\000\\053\\000\\054\\000\\060\\000\\046\\000\\046\\000\\\n \\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\\n \\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\\n \\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\\n \\057\\000\\056\\000\\058\\000\\062\\000\\046\\000\\063\\000\\046\\000\\046\\000\\\n \\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\\n \\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\\n \\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\\n \\064\\000\\065\\000\\066\\000\\067\\000\\068\\000\\069\\000\\070\\000\\072\\000\\\n \\073\\000\\074\\000\\075\\000\\076\\000\\077\\000\\078\\000\\079\\000\\080\\000\\\n \\082\\000\\083\\000\\084\\000\\085\\000\\087\\000\\088\\000\\089\\000\\090\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\045\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \";\n Lexing.lex_check =\n \"\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\007\\000\\011\\000\\013\\000\\023\\000\\033\\000\\038\\000\\043\\000\\054\\000\\\n \\058\\000\\060\\000\\070\\000\\080\\000\\085\\000\\090\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\000\\000\\047\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\000\\000\\047\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\001\\000\\002\\000\\028\\000\\006\\000\\005\\000\\008\\000\\008\\000\\\n \\022\\000\\003\\000\\016\\000\\018\\000\\020\\000\\017\\000\\026\\000\\024\\000\\\n \\014\\000\\025\\000\\015\\000\\004\\000\\010\\000\\019\\000\\021\\000\\027\\000\\\n \\029\\000\\009\\000\\030\\000\\031\\000\\032\\000\\034\\000\\035\\000\\036\\000\\\n \\037\\000\\039\\000\\040\\000\\041\\000\\042\\000\\044\\000\\044\\000\\044\\000\\\n \\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\048\\000\\\n \\049\\000\\050\\000\\051\\000\\052\\000\\053\\000\\056\\000\\044\\000\\044\\000\\\n \\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\\n \\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\\n \\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\\n \\055\\000\\055\\000\\057\\000\\061\\000\\044\\000\\062\\000\\044\\000\\044\\000\\\n \\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\\n \\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\\n \\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\\n \\063\\000\\064\\000\\065\\000\\066\\000\\067\\000\\068\\000\\069\\000\\071\\000\\\n \\072\\000\\073\\000\\074\\000\\075\\000\\076\\000\\077\\000\\078\\000\\079\\000\\\n \\081\\000\\082\\000\\083\\000\\084\\000\\086\\000\\087\\000\\088\\000\\089\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\044\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \";\n Lexing.lex_base_code =\n \"\";\n Lexing.lex_backtrk_code =\n \"\";\n Lexing.lex_default_code =\n \"\";\n Lexing.lex_trans_code =\n \"\";\n Lexing.lex_check_code =\n \"\";\n Lexing.lex_code =\n \"\";\n}\n\nlet rec check lexbuf =\n __ocaml_lex_check_rec lexbuf 0\nand __ocaml_lex_check_rec lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 4 \"collector/check_backtraces.mll\"\n ( true )\n# 163 \"collector/check_backtraces.ml\"\n\n | 1 ->\n# 5 \"collector/check_backtraces.mll\"\n ( not_at_bos lexbuf )\n# 168 \"collector/check_backtraces.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_check_rec lexbuf __ocaml_lex_state\n\nand not_at_bos lexbuf =\n __ocaml_lex_not_at_bos_rec lexbuf 44\nand __ocaml_lex_not_at_bos_rec lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 8 \"collector/check_backtraces.mll\"\n ( true )\n# 180 \"collector/check_backtraces.ml\"\n\n | 1 ->\n# 9 \"collector/check_backtraces.mll\"\n ( not_at_bos lexbuf )\n# 185 \"collector/check_backtraces.ml\"\n\n | 2 ->\n# 10 \"collector/check_backtraces.mll\"\n ( false )\n# 190 \"collector/check_backtraces.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_not_at_bos_rec lexbuf __ocaml_lex_state\n\n;;\n\n# 12 \"collector/check_backtraces.mll\"\n \n let contains_backtraces s = check (Lexing.from_string s)\n\n# 201 \"collector/check_backtraces.ml\"\n","(** This module implements \"Fast Splittable Pseudorandom Number Generators\" by Steele et.\n al. (1). The paper's algorithm provides decent randomness for most purposes, but\n sacrifices cryptographic-quality randomness in favor of performance. The original\n implementation was tested with DieHarder and BigCrush; see the paper for details.\n\n Our implementation is a port from Java to OCaml of the paper's algorithm. Other than\n the choice of initial seed for [create], our port should be faithful. We have not\n re-run the DieHarder or BigCrush tests on our implementation. Our port is also not as\n performant as the original; two factors that hurt us are boxed [int64] values and lack\n of a POPCNT primitive.\n\n (1) http://2014.splashcon.org/event/oopsla2014-fast-splittable-pseudorandom-number-generators\n (also mirrored at http://gee.cs.oswego.edu/dl/papers/oopsla14.pdf)\n\n Beware when implementing this interface; it is easy to implement a [split] operation\n whose output is not as \"independent\" as it seems (2). This bug caused problems for\n Haskell's Quickcheck library for a long time.\n\n (2) Schaathun, \"Evaluation of splittable pseudo-random generators\", JFP 2015.\n http://www.hg.schaathun.net/research/Papers/hgs2015jfp.pdf\n*)\n\nopen! Base\nopen Int64.O\n\nlet is_odd x = x lor 1L = x\n\nlet popcount = Int64.popcount\n\nmodule State = struct\n\n type t =\n { mutable seed : int64\n ; odd_gamma : int64\n }\n\n let golden_gamma = 0x9e37_79b9_7f4a_7c15L\n\n let of_int seed =\n { seed = Int64.of_int seed\n ; odd_gamma = golden_gamma\n }\n\n let copy { seed ; odd_gamma } = { seed ; odd_gamma }\n\n let mix_bits z n =\n z lxor (z lsr n)\n\n let mix64 z =\n let z = (mix_bits z 33) * 0xff51_afd7_ed55_8ccdL in\n let z = (mix_bits z 33) * 0xc4ce_b9fe_1a85_ec53L in\n mix_bits z 33\n\n let mix64_variant13 z =\n let z = (mix_bits z 30) * 0xbf58_476d_1ce4_e5b9L in\n let z = (mix_bits z 27) * 0x94d0_49bb_1331_11ebL in\n mix_bits z 31\n\n let mix_odd_gamma z =\n let z = (mix64_variant13 z) lor 1L in\n let n = popcount (z lxor (z lsr 1)) in\n (* The original paper uses [>=] in the conditional immediately below; however this is\n a typo, and we correct it by using [<]. This was fixed in response to [1] and [2].\n\n [1] https://github.com/janestreet/splittable_random/issues/1\n [2] http://www.pcg-random.org/posts/bugs-in-splitmix.html\n *)\n if Int.( < ) n 24\n then z lxor 0xaaaa_aaaa_aaaa_aaaaL\n else z\n\n let%test_unit \"odd gamma\" =\n for input = -1_000_000 to 1_000_000 do\n let output = mix_odd_gamma (Int64.of_int input) in\n if not (is_odd output) then\n Error.raise_s [%message\n \"gamma value is not odd\"\n (input : int)\n (output : int64)]\n done\n\n let next_seed t =\n let next = t.seed + t.odd_gamma in\n t.seed <- next;\n next\n\n let of_seed_and_gamma ~seed ~gamma =\n let seed = mix64 seed in\n let odd_gamma = mix_odd_gamma gamma in\n { seed; odd_gamma }\n\n let random_int64 random_state =\n Random.State.int64_incl random_state Int64.min_value Int64.max_value\n\n let create random_state =\n let seed = random_int64 random_state in\n let gamma = random_int64 random_state in\n of_seed_and_gamma ~seed ~gamma\n\n let split t =\n let seed = next_seed t in\n let gamma = next_seed t in\n of_seed_and_gamma ~seed ~gamma\n\n let next_int64 t = mix64 (next_seed t)\n\n (* [perturb] is not from any external source, but provides a way to mix in external\n entropy with a pseudo-random state. *)\n let perturb t salt =\n let next = t.seed + mix64 (Int64.of_int salt) in\n t.seed <- next\n\nend\n\nlet bool state = is_odd (State.next_int64 state)\n\n(* We abuse terminology and refer to individual values as biased or unbiased. More\n properly, what is unbiased is the sampler that results if we keep only these \"unbiased\"\n values. *)\nlet remainder_is_unbiased\n ~draw\n ~remainder\n ~draw_maximum\n ~remainder_maximum\n =\n let open Int64.O in\n draw - remainder <= draw_maximum - remainder_maximum\n\nlet%test_unit \"remainder_is_unbiased\" =\n (* choosing a range of 10 values based on a range of 105 values *)\n let draw_maximum = 104L in\n let remainder_maximum = 9L in\n let is_unbiased draw =\n let remainder = Int64.rem draw (Int64.succ remainder_maximum) in\n remainder_is_unbiased ~draw ~remainder ~draw_maximum ~remainder_maximum\n in\n for i = 0 to 99 do\n [%test_result: bool]\n (is_unbiased (Int64.of_int i))\n ~expect:true\n ~message:(Int.to_string i)\n done;\n for i = 100 to 104 do\n [%test_result: bool]\n (is_unbiased (Int64.of_int i))\n ~expect:false\n ~message:(Int.to_string i)\n done\n\n(* This implementation of bounded randomness is adapted from [Random.State.int*] in the\n OCaml standard library. The purpose is to use the minimum number of calls to\n [next_int64] to produce a number uniformly chosen within the given range. *)\nlet int64 =\n let open Int64.O in\n let rec between state ~lo ~hi =\n let draw = State.next_int64 state in\n if lo <= draw && draw <= hi\n then draw\n else between state ~lo ~hi\n in\n let rec non_negative_up_to state maximum =\n let draw = State.next_int64 state land Int64.max_value in\n let remainder = Int64.rem draw (Int64.succ maximum) in\n if remainder_is_unbiased\n ~draw\n ~remainder\n ~draw_maximum:Int64.max_value\n ~remainder_maximum:maximum\n then remainder\n else non_negative_up_to state maximum\n in\n fun state ~lo ~hi ->\n if lo > hi then begin\n Error.raise_s [%message \"int64: crossed bounds\" (lo : int64) (hi : int64)]\n end;\n let diff = hi - lo in\n if diff = Int64.max_value\n then ((State.next_int64 state) land Int64.max_value) + lo\n else if diff >= 0L\n then (non_negative_up_to state diff) + lo\n else between state ~lo ~hi\n\nlet int state ~lo ~hi =\n let lo = Int64.of_int lo in\n let hi = Int64.of_int hi in\n (* truncate unneeded bits *)\n Int64.to_int_trunc (int64 state ~lo ~hi)\n\nlet int32 state ~lo ~hi =\n let lo = Int64.of_int32 lo in\n let hi = Int64.of_int32 hi in\n (* truncate unneeded bits *)\n Int64.to_int32_trunc (int64 state ~lo ~hi)\n\nlet nativeint state ~lo ~hi =\n let lo = Int64.of_nativeint lo in\n let hi = Int64.of_nativeint hi in\n (* truncate unneeded bits *)\n Int64.to_nativeint_trunc (int64 state ~lo ~hi)\n\nlet int63 state ~lo ~hi =\n let lo = Int63.to_int64 lo in\n let hi = Int63.to_int64 hi in\n (* truncate unneeded bits *)\n Int63.of_int64_trunc (int64 state ~lo ~hi)\n\nlet double_ulp = 2. **. -53.\n\nlet%test_unit \"double_ulp\" =\n let open Float.O in\n match Word_size.word_size with\n | W64 ->\n assert (1.0 -. double_ulp < 1.0);\n assert (1.0 -. (double_ulp /. 2.0) = 1.0)\n | W32 ->\n (* 32-bit OCaml uses a 64-bit float representation but 80-bit float instructions, so\n rounding works differently due to the conversion back and forth. *)\n assert (1.0 -. double_ulp < 1.0);\n assert (1.0 -. (double_ulp /. 2.0) <= 1.0)\n\nlet unit_float_from_int64 int64 =\n (Int64.to_float (int64 lsr 11)) *. double_ulp\n\nlet%test_unit \"unit_float_from_int64\" = begin\n let open Float.O in\n assert (unit_float_from_int64 0x0000_0000_0000_0000L = 0.);\n assert (unit_float_from_int64 0xffff_ffff_ffff_ffffL < 1.0);\n assert (unit_float_from_int64 0xffff_ffff_ffff_ffffL = (1.0 -. double_ulp));\nend\n\nlet unit_float state =\n unit_float_from_int64 (State.next_int64 state)\n\n(* Note about roundoff error:\n\n Although [float state ~lo ~hi] is nominally inclusive of endpoints, we are relying on\n the fact that [unit_float] never returns 1., because there are pairs [(lo,hi)] for\n which [lo +. 1. *. (hi -. lo) > hi]. There are also pairs [(lo,hi)] and values of [x]\n with [x < 1.] such that [lo +. x *. (hi -. lo) = hi], so it would not be correct to\n document this as being exclusive of [hi].\n*)\nlet float =\n let rec finite_float state ~lo ~hi =\n let range = hi -. lo in\n if Float.is_finite range\n then (lo +. (unit_float state *. range))\n else begin\n (* If [hi - lo] is infinite, then [hi + lo] is finite because [hi] and [lo] have\n opposite signs. *)\n let mid = (hi +. lo) /. 2. in\n if bool state\n (* Depending on rounding, the recursion with [~hi:mid] might be inclusive of [mid],\n which would mean the two cases overlap on [mid]. The alternative is to increment\n or decrement [mid] using [one_ulp] in either of the calls, but then if the first\n case is exclusive we leave a \"gap\" between the two ranges. There's no perfectly\n uniform solution, so we use the simpler code that does not call [one_ulp]. *)\n then finite_float state ~lo ~hi:mid\n else finite_float state ~lo:mid ~hi\n end\n in\n fun state ~lo ~hi ->\n if not (Float.is_finite lo && Float.is_finite hi)\n then begin\n raise_s [%message\n \"float: bounds are not finite numbers\"\n (lo : float)\n (hi : float)]\n end;\n if Float.( > ) lo hi\n then begin\n raise_s [%message\n \"float: bounds are crossed\"\n (lo : float)\n (hi : float)]\n end;\n finite_float state ~lo ~hi\n\nlet%bench_fun \"unit_float_from_int64\" =\n let int64 = 1L in\n fun () -> unit_float_from_int64 int64\n\nmodule Log_uniform = struct\n module Make (M : sig include Int.S val uniform : State.t -> lo:t -> hi:t -> t end) : sig\n val log_uniform : State.t -> lo:M.t -> hi:M.t -> M.t\n end = struct\n open M\n\n let bits_to_represent t =\n assert (t >= zero);\n let t = ref t in\n let n = ref 0 in\n while !t > zero do\n t := shift_right !t 1;\n Int.incr n;\n done;\n !n\n\n let%test_unit \"bits_to_represent\" =\n let test n expect = [%test_result: int] (bits_to_represent n) ~expect in\n test (M.of_int_exn 0) 0;\n test (M.of_int_exn 1) 1;\n test (M.of_int_exn 2) 2;\n test (M.of_int_exn 3) 2;\n test (M.of_int_exn 4) 3;\n test (M.of_int_exn 5) 3;\n test (M.of_int_exn 6) 3;\n test (M.of_int_exn 7) 3;\n test (M.of_int_exn 8) 4;\n test (M.of_int_exn 100) 7;\n test M.max_value (Int.pred M.num_bits);\n ;;\n\n let min_represented_by_n_bits n =\n if Int.equal n 0\n then zero\n else shift_left one (Int.pred n)\n\n let%test_unit \"min_represented_by_n_bits\" =\n let test n expect = [%test_result: M.t] (min_represented_by_n_bits n) ~expect in\n test 0 (M.of_int_exn 0);\n test 1 (M.of_int_exn 1);\n test 2 (M.of_int_exn 2);\n test 3 (M.of_int_exn 4);\n test 4 (M.of_int_exn 8);\n test 7 (M.of_int_exn 64);\n test (Int.pred M.num_bits) (M.shift_right_logical M.min_value 1);\n ;;\n\n let max_represented_by_n_bits n =\n pred (shift_left one n)\n\n let%test_unit \"max_represented_by_n_bits\" =\n let test n expect = [%test_result: M.t] (max_represented_by_n_bits n) ~expect in\n test 0 (M.of_int_exn 0);\n test 1 (M.of_int_exn 1);\n test 2 (M.of_int_exn 3);\n test 3 (M.of_int_exn 7);\n test 4 (M.of_int_exn 15);\n test 7 (M.of_int_exn 127);\n test (Int.pred M.num_bits) M.max_value;\n ;;\n\n let log_uniform state ~lo ~hi =\n let min_bits = bits_to_represent lo in\n let max_bits = bits_to_represent hi in\n let bits = int state ~lo:min_bits ~hi:max_bits in\n uniform state\n ~lo:(min_represented_by_n_bits bits |> max lo)\n ~hi:(max_represented_by_n_bits bits |> min hi)\n end\n\n module For_int = Make (struct include Int let uniform = int end)\n module For_int32 = Make (struct include Int32 let uniform = int32 end)\n module For_int63 = Make (struct include Int63 let uniform = int63 end)\n module For_int64 = Make (struct include Int64 let uniform = int64 end)\n module For_nativeint = Make (struct include Nativeint let uniform = nativeint end)\n\n let int = For_int.log_uniform\n let int32 = For_int32.log_uniform\n let int63 = For_int63.log_uniform\n let int64 = For_int64.log_uniform\n let nativeint = For_nativeint.log_uniform\nend\n\n","(* This module builds a buffer of \"instructions\", in order to represent a compact sequence\n of delimiting positions and newlines. The parser stores the positions of each:\n\n - newline\n - beginning of atom\n - end of atom\n - left parenthesis\n - right parenthesis\n\n Instructions are encoded as a sequence bits. The next instruction is determined by\n looking at the next few bits:\n\n - bit 0 represents a saved position followed by an offset increment\n - bits 10 represent an offset increment\n - bits 110 are followed by 5 bits of payload. The 5-bit payloads of any subsequent 110-\n instructions are squashed to form a number (least significant 5-bit chunk first).\n This number + 5 represents an offset increment\n - bits 1110 marks the beginning of a new line (with offset incremented)\n - bits 1111 represent a position saved twice followed by an offset increment\n\n For instance let's consider the following sexp:\n\n {[\n {|\n(abc\n \"foo\n bar\"\n)\n|}\n ]}\n\n the sequence of instructions to record in order to reconstruct the position of any\n sub-sexp is:\n\n - 0 save position and advance 1: first '('\n - 0 save position and advance 1: start of \"abc\"\n - 10 advance 1\n - 0 save position and advance 1: end of \"abc\"\n - 1110 newline\n - 1100_0001 advance 6\n - 0 save position and advance 1: start of \"foo\\n bar\"\n - 10 advance 1\n - 10 advance 1\n - 10 advance 1\n - 1110 newline\n - 1100_0000 advance 5\n - 0 save position and advance 1: end of \"foo\\n bar\"\n - 1110 newline\n - 0 save position and advance 1: last ')'\n\n (we save the position after the closing parenthesis)\n\n The total sequence is 42 bits, so we need 6 bytes to store it\n\n The sequence of bits is encoded as a sequence of 16-bit values, where the earlier bits\n are most significant.\n\n Note that the parser stores the end positions as inclusive. This way only single\n character atoms require a double positions. If we were storing end positions as\n exclusive, we would need double positions for [)(] and [a(], which are likely to be\n frequent in s-expressions printed with the non [_hum] printer. We expect single\n character atoms to be less frequent so it makes sense to penalize them instead.\n*)\n\nopen! Import\n\ntype pos =\n { line : int\n ; col : int\n ; offset : int\n }\n[@@deriving_inline sexp_of]\n\nlet sexp_of_pos =\n (function\n | { line = v_line; col = v_col; offset = v_offset } ->\n let bnds = [] in\n let bnds =\n let arg = sexp_of_int v_offset in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"offset\"; arg ] :: bnds\n in\n let bnds =\n let arg = sexp_of_int v_col in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"col\"; arg ] :: bnds\n in\n let bnds =\n let arg = sexp_of_int v_line in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"line\"; arg ] :: bnds\n in\n Ppx_sexp_conv_lib.Sexp.List bnds\n : pos -> Ppx_sexp_conv_lib.Sexp.t)\n;;\n\n[@@@end]\n\nlet compare_pos = Caml.compare\nlet beginning_of_file = { line = 1; col = 0; offset = 0 }\nlet shift_pos pos ~cols = { pos with col = pos.col + cols; offset = pos.offset + cols }\n\ntype range =\n { start_pos : pos\n ; end_pos : pos\n }\n[@@deriving_inline sexp_of]\n\nlet sexp_of_range =\n (function\n | { start_pos = v_start_pos; end_pos = v_end_pos } ->\n let bnds = [] in\n let bnds =\n let arg = sexp_of_pos v_end_pos in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"end_pos\"; arg ] :: bnds\n in\n let bnds =\n let arg = sexp_of_pos v_start_pos in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"start_pos\"; arg ]\n :: bnds\n in\n Ppx_sexp_conv_lib.Sexp.List bnds\n : range -> Ppx_sexp_conv_lib.Sexp.t)\n;;\n\n[@@@end]\n\nlet compare_range = Caml.compare\n\nlet make_range_incl ~start_pos ~last_pos =\n { start_pos; end_pos = shift_pos last_pos ~cols:1 }\n;;\n\nmodule Chunk : sig\n (** Represents an array of [length/2] signed 16-bit values *)\n type t\n\n (** Length in bytes. *)\n val length : int\n\n val alloc : unit -> t\n\n (** [get16 ~pos] and [set16 ~pos] manipulate the [pos/2]th stored value.\n [pos] must be even.\n [set16 x] only uses the 16 least significant bits of [x]. *)\n val get16 : t -> pos:int -> int\n\n val set16 : t -> pos:int -> int -> unit\nend = struct\n type t = bytes\n\n (* OCaml strings always waste two bytes at the end, so we take a power of two minus two\n to be sure we don't waste space. *)\n let length = 62\n let alloc () = Bytes.create length\n let get16 = Bytes0.get16\n let set16 = Bytes0.set16\n\n (* If we want to make a [Positions.t] serializable:\n\n {[\n external bswap16 : int -> int = \"%bswap16\";;\n\n let get16 =\n if Caml.Sys.arch_big_endian then\n fun buf ~pos -> get16 buf ~pos |> bswap16\n else\n get16\n\n let set16 =\n if Caml.Sys.arch_big_endian then\n fun buf ~pos x -> set16 buf ~pos (bswap16 x)\n else\n set16\n ]}\n\n *)\nend\n\ntype t_ =\n { chunks : Chunk.t list\n ; (* [num_bytes * 8 + extra_bits] is the number of bits stored in [chunks].\n The last [extra_bits] bits will be stored as the *least* significant bits\n of the appropriate pair of bytes of the last chunk. *)\n num_bytes : int\n ; extra_bits : int\n ; initial_pos : pos\n }\n\ntype t = t_ Lazy.t\n\nlet memory_footprint_in_bytes (lazy t) =\n let num_fields = 4 in\n let header_words = 1 in\n let word_bytes =\n match Sys.word_size with\n | 32 -> 4\n | 64 -> 8\n | _ -> assert false\n in\n let chunk_words =\n let div_ceil a b = (a + b - 1) / b in\n let n =\n div_ceil\n (Chunk.length\n + 1 (* NUL terminating bytes *)\n + 1 (* number of wasted bytes to fill a word *))\n word_bytes\n in\n n + header_words\n in\n let pos_fields = 3 in\n let pos_words = header_words + pos_fields in\n let list_cons_words = header_words + 2 in\n (header_words\n + num_fields\n + pos_words\n + (List.length t.chunks * (chunk_words + list_cons_words)))\n * word_bytes\n;;\n\nmodule Builder = struct\n type t =\n { mutable chunk : Chunk.t\n ; mutable chunk_pos : int\n ; mutable filled_chunks : Chunk.t list (* Filled chunks in reverse order *)\n ; mutable offset : int\n (* Offset of the last saved position or newline plus\n one, or [initial_pos] *)\n ; mutable int_buf : int\n (* the [num_bits] least significant bits of [int_buf]\n are the bits not yet pushed to [chunk]. *)\n ; mutable num_bits : int (* number of bits stored in [int_buf] *)\n ; mutable initial_pos : pos\n }\n\n let invariant t =\n assert (t.chunk_pos >= 0 && t.chunk_pos <= Chunk.length);\n assert (t.offset >= t.initial_pos.offset);\n assert (t.num_bits <= 15)\n ;;\n\n let check_invariant = false\n let invariant t = if check_invariant then invariant t\n\n let create ?(initial_pos = beginning_of_file) () =\n { chunk = Chunk.alloc ()\n ; chunk_pos = 0\n ; filled_chunks = []\n ; offset = initial_pos.offset\n ; int_buf = 0\n ; num_bits = 0\n ; initial_pos\n }\n ;;\n\n let reset t (pos : pos) =\n (* We need a new chunk as [contents] keeps the current chunk in the closure of the\n lazy value. *)\n t.chunk <- Chunk.alloc ();\n t.chunk_pos <- 0;\n t.filled_chunks <- [];\n t.offset <- pos.offset;\n t.int_buf <- 0;\n t.num_bits <- 0;\n t.initial_pos <- pos\n ;;\n\n let[@inlined never] alloc_new_chunk t =\n t.filled_chunks <- t.chunk :: t.filled_chunks;\n t.chunk <- Chunk.alloc ();\n t.chunk_pos <- 0\n ;;\n\n let add_uint16 t n =\n if t.chunk_pos = Chunk.length then alloc_new_chunk t;\n Chunk.set16 t.chunk ~pos:t.chunk_pos n\n ;;\n\n let add_bits t n ~num_bits =\n let int_buf = (t.int_buf lsl num_bits) lor n in\n let num_bits = t.num_bits + num_bits in\n t.int_buf <- int_buf;\n if num_bits < 16\n then t.num_bits <- num_bits\n else (\n let num_bits = num_bits - 16 in\n t.num_bits <- num_bits;\n add_uint16 t (int_buf lsr num_bits);\n t.chunk_pos <- t.chunk_pos + 2\n (* no need to clear the bits of int_buf we just wrote, as further set16 will ignore\n these extra bits. *))\n ;;\n\n let contents t =\n (* Flush the current [t.int_buf] *)\n add_uint16 t t.int_buf;\n let rev_chunks = t.chunk :: t.filled_chunks in\n let chunk_pos = t.chunk_pos in\n let extra_bits = t.num_bits in\n let initial_pos = t.initial_pos in\n lazy\n { chunks = List.rev rev_chunks\n ; num_bytes = ((List.length rev_chunks - 1) * Chunk.length) + chunk_pos\n ; extra_bits\n ; initial_pos\n }\n ;;\n\n let long_shift t n =\n let n = ref (n - 5) in\n while !n > 0 do\n add_bits t (0b1100_0000 lor (!n land 0b0001_1111)) ~num_bits:8;\n n := !n lsr 5\n done\n ;;\n\n (* precondition: n >= 5 *)\n let[@inlined never] add_gen_slow t n ~instr ~instr_bits =\n long_shift t n;\n add_bits t instr ~num_bits:instr_bits\n ;;\n\n let shift4 = 0b10_10_10_10\n\n let[@inline always] add_gen t ~offset ~instr ~instr_bits =\n invariant t;\n let n = offset - t.offset in\n t.offset <- offset + 1;\n match n with\n | 0 | 1 | 2 | 3 | 4 ->\n let num_bits = (n lsl 1) + instr_bits in\n add_bits\n t\n ((shift4 lsl instr_bits) lor instr land ((1 lsl num_bits) - 1))\n ~num_bits\n | 5\n | 6\n | 7\n | 8\n | 9\n | 10\n | 11\n | 12\n | 13\n | 14\n | 15\n | 16\n | 17\n | 18\n | 19\n | 20\n | 21\n | 22\n | 23\n | 24\n | 25\n | 26\n | 27\n | 28\n | 29\n | 30\n | 31\n | 32\n | 33\n | 34\n | 35\n | 36 ->\n add_bits\n t\n (((0b1100_0000 lor (n - 5)) lsl instr_bits) lor instr)\n ~num_bits:(8 + instr_bits)\n | _ ->\n if n < 0 then invalid_arg \"Parsexp.Positions.add_gen\";\n add_gen_slow t n ~instr ~instr_bits\n ;;\n\n let add t ~offset = add_gen t ~offset ~instr:0b0 ~instr_bits:1\n let add_twice t ~offset = add_gen t ~offset ~instr:0b1111 ~instr_bits:4\n let add_newline t ~offset = add_gen t ~offset ~instr:0b1110 ~instr_bits:4\nend\n\ntype positions = t\n\nmodule Iterator : sig\n type t\n\n val create : positions -> t\n\n exception No_more\n\n (* [advance t ~skip] ignores [skip] saved positions and returns the next saved position.\n Raises [No_more] when reaching the end of the position set. *)\n val advance_exn : t -> skip:int -> pos\nend = struct\n type t =\n { mutable chunk : Chunk.t\n ; mutable chunks : Chunk.t list\n ; (* [num_bytes * 8 + extra_bits] is the number of bits available from [instr_pos] in\n [chunk :: chunks]. *)\n mutable num_bytes : int\n ; extra_bits : int\n ; mutable instr_pos : int (* position in [chunk] *)\n ; mutable offset : int\n ; mutable line : int\n ; mutable bol : int\n ; mutable int_buf : int\n ; mutable num_bits : int (* Number of bits not yet consumed in [int_buf] *)\n ; mutable pending : pos option\n }\n\n let create ((lazy p) : positions) =\n match p.chunks with\n | [] -> assert false\n | chunk :: chunks ->\n { chunk\n ; chunks\n ; num_bytes = p.num_bytes\n ; extra_bits = p.extra_bits\n ; instr_pos = 0\n ; offset = p.initial_pos.offset\n ; line = p.initial_pos.line\n ; bol = p.initial_pos.offset - p.initial_pos.col\n ; int_buf = 0\n ; num_bits = 0\n ; pending = None\n }\n ;;\n\n exception No_more\n\n let no_more () = raise_notrace No_more\n\n let[@inlined never] fetch_chunk t =\n match t.chunks with\n | [] -> assert false\n | chunk :: chunks ->\n t.instr_pos <- 0;\n t.num_bytes <- t.num_bytes - Chunk.length;\n t.chunk <- chunk;\n t.chunks <- chunks\n ;;\n\n let fetch t =\n if t.instr_pos > t.num_bytes then no_more ();\n if t.instr_pos = Chunk.length then fetch_chunk t;\n let v = Chunk.get16 t.chunk ~pos:t.instr_pos in\n let added_bits = if t.instr_pos = t.num_bytes then t.extra_bits else 16 in\n t.int_buf <- (t.int_buf lsl added_bits) lor (v land ((1 lsl added_bits) - 1));\n t.num_bits <- t.num_bits + added_bits;\n t.instr_pos <- t.instr_pos + 2\n ;;\n\n let next_instruction_bits t ~num_bits =\n if t.num_bits < num_bits\n then (\n fetch t;\n if t.num_bits < num_bits then no_more ());\n let n = (t.int_buf lsr (t.num_bits - num_bits)) land ((1 lsl num_bits) - 1) in\n t.num_bits <- t.num_bits - num_bits;\n n\n ;;\n\n (* [offset_shift] and [offset_shift_num_bits] encode the offset number\n specified by the immediately preceding [110] instructions. *)\n let rec advance t ~skip ~offset_shift ~offset_shift_num_bits =\n match next_instruction_bits t ~num_bits:1 with\n | 0 ->\n (* bit seq 0 -> new item *)\n let offset = t.offset + offset_shift in\n t.offset <- offset + 1;\n if skip = 0\n then { line = t.line; col = offset - t.bol; offset }\n else advance t ~skip:(skip - 1) ~offset_shift:0 ~offset_shift_num_bits:0\n | _ ->\n (match next_instruction_bits t ~num_bits:1 with\n | 0 ->\n (* bit seq 10 -> shift *)\n t.offset <- t.offset + offset_shift + 1;\n advance t ~skip ~offset_shift:0 ~offset_shift_num_bits:0\n | _ ->\n (match next_instruction_bits t ~num_bits:1 with\n | 0 ->\n (* bit seq 110 -> long shift *)\n let n = next_instruction_bits t ~num_bits:5 in\n let offset_shift = if offset_shift_num_bits = 0 then 5 else offset_shift in\n advance\n t\n ~skip\n ~offset_shift:(offset_shift + (n lsl offset_shift_num_bits))\n ~offset_shift_num_bits:(offset_shift_num_bits + 5)\n | _ ->\n (match next_instruction_bits t ~num_bits:1 with\n | 0 ->\n (* bit seq 1110 -> newline *)\n t.offset <- t.offset + offset_shift + 1;\n t.bol <- t.offset;\n t.line <- t.line + 1;\n advance t ~skip ~offset_shift:0 ~offset_shift_num_bits:0\n | _ ->\n (* bit seq 1111 -> 2 new items *)\n let offset = t.offset + offset_shift in\n t.offset <- offset + 1;\n if skip <= 1\n then (\n let pos = { line = t.line; col = offset - t.bol; offset } in\n if skip = 0 then t.pending <- Some pos;\n pos)\n else advance t ~skip:(skip - 2) ~offset_shift:0 ~offset_shift_num_bits:0)))\n ;;\n\n let advance_exn t ~skip =\n match t.pending with\n | Some pos ->\n t.pending <- None;\n if skip = 0\n then pos\n else advance t ~skip:(skip - 1) ~offset_shift:0 ~offset_shift_num_bits:0\n | None -> advance t ~skip ~offset_shift:0 ~offset_shift_num_bits:0\n ;;\nend\n\nlet find t a b =\n if a < 0 || b <= a then invalid_arg \"Parsexp.Positions.find\";\n let iter = Iterator.create t in\n try\n let start_pos = Iterator.advance_exn iter ~skip:a in\n let last_pos = Iterator.advance_exn iter ~skip:(b - a - 1) in\n make_range_incl ~start_pos ~last_pos\n with\n | Iterator.No_more -> failwith \"Parsexp.Position.find\"\n;;\n\nlet rec sub_sexp_count (sexp : Sexp.t) =\n match sexp with\n | Atom _ -> 1\n | List l -> List.fold_left l ~init:1 ~f:(fun acc x -> acc + sub_sexp_count x)\n;;\n\nmodule Sexp_search = struct\n exception Found of int\n\n let rec loop ~sub index (sexp : Sexp.t) =\n if sexp == sub\n then raise_notrace (Found index)\n else (\n match sexp with\n | Atom _ -> index + 2\n | List l ->\n let index = loop_list ~sub (index + 1) l in\n index + 1)\n\n and loop_list ~sub index (sexps : Sexp.t list) =\n List.fold_left sexps ~init:index ~f:(loop ~sub)\n ;;\n\n let finalize t ~sub a =\n let b = a + (sub_sexp_count sub * 2) - 1 in\n Some (find t a b)\n ;;\n\n let find_sub_sexp_phys t sexp ~sub =\n match loop ~sub 0 sexp with\n | (_ : int) -> None\n | exception Found n -> finalize t ~sub n\n ;;\n\n let find_sub_sexp_in_list_phys t sexps ~sub =\n match loop_list ~sub 0 sexps with\n | (_ : int) -> None\n | exception Found n -> finalize t ~sub n\n ;;\nend\n\nlet find_sub_sexp_phys = Sexp_search.find_sub_sexp_phys\nlet find_sub_sexp_in_list_phys = Sexp_search.find_sub_sexp_in_list_phys\n\nlet to_list t =\n let iter = Iterator.create t in\n let rec loop acc =\n match Iterator.advance_exn iter ~skip:0 with\n | exception Iterator.No_more -> List.rev acc\n | pos -> loop (pos :: acc)\n in\n loop []\n;;\n\nlet to_array t = to_list t |> Array.of_list\nlet compare t1 t2 = Caml.compare (to_array t1) (to_array t2)\nlet sexp_of_t t = sexp_of_array sexp_of_pos (to_array t)\n","open! Import\nmodule Binable = Binable0\n\n(* All the types as exposed in the mli are defined in this [Types] module. The rest of\n this file is simply overriding all the bin_io, compare, and sexp functions to raise\n exceptions. *)\nmodule Types = struct\n module Nobody = struct\n type t [@@deriving bin_io, compare, hash, sexp]\n\n let name = \"Nobody\"\n end\n\n module Me = struct\n type t [@@deriving bin_io, compare, hash, sexp]\n\n let name = \"Me\"\n end\n\n module Read = struct\n type t = [ `Read ] [@@deriving bin_io, compare, hash, sexp]\n\n let name = \"Read\"\n end\n\n module Write = struct\n type t = [ `Who_can_write of Me.t ] [@@deriving bin_io, compare, hash, sexp]\n\n let name = \"Write\"\n end\n\n module Immutable = struct\n type t =\n [ Read.t\n | `Who_can_write of Nobody.t\n ]\n [@@deriving bin_io, compare, hash, sexp]\n\n let name = \"Immutable\"\n end\n\n module Read_write = struct\n type t =\n [ Read.t\n | Write.t\n ]\n [@@deriving bin_io, compare, hash, sexp]\n\n let name = \"Read_write\"\n end\n\n module Upper_bound = struct\n type 'a t =\n [ Read.t\n | `Who_can_write of 'a\n ]\n [@@deriving bin_io, compare, hash, sexp]\n\n let name = \"Upper_bound\"\n end\nend\n\nlet failwithf = Printf.failwithf\n\n(* This is an explicit module type instead of just given inline as the return signature of\n [Only_used_as_phantom_type1] to avoid an unused value warning with bin_io values. *)\nmodule type Sexpable_binable_comparable = sig\n type 'a t = 'a [@@deriving bin_io, compare, hash, sexp]\nend\n\n(* Override all bin_io, sexp, compare functions to raise exceptions *)\nmodule Only_used_as_phantom_type1 (Name : sig\n val name : string\n end) : Sexpable_binable_comparable = struct\n type 'a t = 'a\n\n let sexp_of_t _ _ = failwithf \"Unexpectedly called [%s.sexp_of_t]\" Name.name ()\n let t_of_sexp _ _ = failwithf \"Unexpectedly called [%s.t_of_sexp]\" Name.name ()\n let compare _ _ _ = failwithf \"Unexpectedly called [%s.compare]\" Name.name ()\n let hash_fold_t _ _ _ = failwithf \"Unexpectedly called [%s.hash_fold_t]\" Name.name ()\n\n include Binable.Of_binable1_without_uuid [@alert \"-legacy\"]\n (struct\n type 'a t = 'a [@@deriving bin_io]\n end)\n (struct\n type nonrec 'a t = 'a t\n\n let to_binable _ =\n failwithf \"Unexpectedly used %s bin_io serialization\" Name.name ()\n ;;\n\n let of_binable _ =\n failwithf \"Unexpectedly used %s bin_io deserialization\" Name.name ()\n ;;\n end)\nend\n\nmodule Only_used_as_phantom_type0 (T : sig\n type t [@@deriving bin_io, compare, hash, sexp]\n\n val name : string\n end) : sig\n type t = T.t [@@deriving bin_io, compare, hash, sexp_poly]\nend = struct\n module M = Only_used_as_phantom_type1 (T)\n\n type t = T.t M.t [@@deriving bin_io, compare, hash, sexp]\n\n let __t_of_sexp__ = t_of_sexp\nend\n\nmodule Stable = struct\n module V1 = struct\n module Nobody = Only_used_as_phantom_type0 (Types.Nobody)\n module Me = Only_used_as_phantom_type0 (Types.Me)\n module Read = Only_used_as_phantom_type0 (Types.Read)\n module Write = Only_used_as_phantom_type0 (Types.Write)\n module Read_write = Only_used_as_phantom_type0 (Types.Read_write)\n module Immutable = Only_used_as_phantom_type0 (Types.Immutable)\n\n type nobody = Nobody.t [@@deriving bin_io, compare, hash, sexp]\n type me = Me.t [@@deriving bin_io, compare, hash, sexp]\n\n module Upper_bound = struct\n module M = Only_used_as_phantom_type1 (Types.Upper_bound)\n\n type 'a t = 'a Types.Upper_bound.t M.t [@@deriving bin_io, compare, hash, sexp]\n\n let __t_of_sexp__ = t_of_sexp\n end\n end\n\n module Export = struct\n type read = V1.Read.t [@@deriving bin_io, compare, hash, sexp]\n type write = V1.Write.t [@@deriving compare, hash, sexp]\n type immutable = V1.Immutable.t [@@deriving bin_io, compare, hash, sexp]\n type read_write = V1.Read_write.t [@@deriving bin_io, compare, hash, sexp]\n type 'a perms = 'a V1.Upper_bound.t [@@deriving bin_io, compare, hash, sexp]\n end\nend\n\ninclude Stable.V1\nmodule Export = Stable.Export\n","(* Conv_error: Module for Handling Errors during Automated S-expression\n Conversions *)\n\nopen StdLabels\nopen Printf\nopen Sexp_conv\n\nexception Of_sexp_error = Of_sexp_error\n\n(* Errors concerning tuples *)\n\nlet tuple_of_size_n_expected loc n sexp =\n of_sexp_error (sprintf \"%s_of_sexp: tuple of size %d expected\" loc n) sexp\n\n\n(* Errors concerning sum types *)\n\nlet stag_no_args loc sexp =\n of_sexp_error (loc ^ \"_of_sexp: sum tag does not take arguments\") sexp\n\nlet stag_incorrect_n_args loc tag sexp =\n let msg =\n sprintf \"%s_of_sexp: sum tag %S has incorrect number of arguments\" loc tag\n in\n of_sexp_error msg sexp\n\nlet stag_takes_args loc sexp =\n of_sexp_error (loc ^ \"_of_sexp: sum tag must be a structured value\") sexp\n\nlet nested_list_invalid_sum loc sexp =\n of_sexp_error (loc ^ \"_of_sexp: a nested list is an invalid sum\") sexp\n\nlet empty_list_invalid_sum loc sexp =\n of_sexp_error (loc ^ \"_of_sexp: the empty list is an invalid sum\") sexp\n\nlet unexpected_stag loc sexp =\n of_sexp_error (loc ^ \"_of_sexp: unexpected sum tag\") sexp\n\n\n(* Errors concerning records *)\n\nlet record_sexp_bool_with_payload loc sexp =\n let msg =\n loc ^\n \"_of_sexp: record conversion: a [sexp.bool] field was given a payload.\" in\n of_sexp_error msg sexp\n\nlet record_only_pairs_expected loc sexp =\n let msg =\n loc ^\n \"_of_sexp: record conversion: only pairs expected, \\\n their first element must be an atom\" in\n of_sexp_error msg sexp\n\nlet record_superfluous_fields ~what ~loc rev_fld_names sexp =\n let fld_names_str = String.concat (List.rev rev_fld_names) ~sep:\" \" in\n let msg = sprintf \"%s_of_sexp: %s: %s\" loc what fld_names_str in\n of_sexp_error msg sexp\n\nlet record_duplicate_fields loc rev_fld_names sexp =\n record_superfluous_fields ~what:\"duplicate fields\" ~loc rev_fld_names sexp\n\nlet record_extra_fields loc rev_fld_names sexp =\n record_superfluous_fields ~what:\"extra fields\" ~loc rev_fld_names sexp\n\nlet rec record_get_undefined_loop fields = function\n | [] -> String.concat (List.rev fields) ~sep:\" \"\n | (true, field) :: rest -> record_get_undefined_loop (field :: fields) rest\n | _ :: rest -> record_get_undefined_loop fields rest\n\nlet record_undefined_elements loc sexp lst =\n let undefined = record_get_undefined_loop [] lst in\n let msg =\n sprintf \"%s_of_sexp: the following record elements were undefined: %s\"\n loc undefined\n in\n of_sexp_error msg sexp\n\nlet record_list_instead_atom loc sexp =\n let msg = loc ^ \"_of_sexp: list instead of atom for record expected\" in\n of_sexp_error msg sexp\n\nlet record_poly_field_value loc sexp =\n let msg =\n loc ^\n \"_of_sexp: cannot convert values of types resulting from polymorphic \\\n record fields\"\n in\n of_sexp_error msg sexp\n\n\n(* Errors concerning polymorphic variants *)\n\nexception No_variant_match\n\nlet no_variant_match () =\n raise No_variant_match\n\nlet no_matching_variant_found loc sexp =\n of_sexp_error (loc ^ \"_of_sexp: no matching variant found\") sexp\n\nlet ptag_no_args loc sexp =\n of_sexp_error (\n loc ^ \"_of_sexp: polymorphic variant does not take arguments\") sexp\n\nlet ptag_incorrect_n_args loc cnstr sexp =\n let msg =\n sprintf\n \"%s_of_sexp: polymorphic variant tag %S has incorrect number of arguments\"\n loc cnstr\n in\n of_sexp_error msg sexp\n\nlet ptag_takes_args loc sexp =\n of_sexp_error (loc ^ \"_of_sexp: polymorphic variant tag takes an argument\")\n sexp\n\nlet nested_list_invalid_poly_var loc sexp =\n of_sexp_error (\n loc ^ \"_of_sexp: a nested list is an invalid polymorphic variant\") sexp\n\nlet empty_list_invalid_poly_var loc sexp =\n of_sexp_error (\n loc ^ \"_of_sexp: the empty list is an invalid polymorphic variant\") sexp\n\nlet empty_type loc sexp =\n of_sexp_error (loc ^ \"_of_sexp: trying to convert an empty type\") sexp\n","open! Import\nopen Quickcheck_intf\nopen Base_quickcheck\nmodule Array = Base.Array\nmodule Bool = Base.Bool\nmodule Char = Base.Char\nmodule Float = Base.Float\nmodule Int = Base.Int\nmodule List = Base.List\nmodule Option = Base.Option\nmodule Type_equal = Base.Type_equal\n\nmodule Polymorphic_types = struct\n type ('a, 'b) variant2 =\n [ `A of 'a\n | `B of 'b\n ]\n [@@deriving quickcheck]\n\n type ('a, 'b, 'c) variant3 =\n [ `A of 'a\n | `B of 'b\n | `C of 'c\n ]\n [@@deriving quickcheck]\n\n type ('a, 'b, 'c, 'd) variant4 =\n [ `A of 'a\n | `B of 'b\n | `C of 'c\n | `D of 'd\n ]\n [@@deriving quickcheck]\n\n type ('a, 'b, 'c, 'd, 'e) variant5 =\n [ `A of 'a\n | `B of 'b\n | `C of 'c\n | `D of 'd\n | `E of 'e\n ]\n [@@deriving quickcheck]\n\n type ('a, 'b, 'c, 'd, 'e, 'f) variant6 =\n [ `A of 'a\n | `B of 'b\n | `C of 'c\n | `D of 'd\n | `E of 'e\n | `F of 'f\n ]\n [@@deriving quickcheck]\n\n type ('a, 'b) tuple2 = 'a * 'b [@@deriving quickcheck]\n type ('a, 'b, 'c) tuple3 = 'a * 'b * 'c [@@deriving quickcheck]\n type ('a, 'b, 'c, 'd) tuple4 = 'a * 'b * 'c * 'd [@@deriving quickcheck]\n type ('a, 'b, 'c, 'd, 'e) tuple5 = 'a * 'b * 'c * 'd * 'e [@@deriving quickcheck]\n\n type ('a, 'b, 'c, 'd, 'e, 'f) tuple6 = 'a * 'b * 'c * 'd * 'e * 'f\n [@@deriving quickcheck]\n\n type (-'a, -'b, 'r) fn2 = 'a -> 'b -> 'r [@@deriving quickcheck]\n type (-'a, -'b, -'c, 'r) fn3 = 'a -> 'b -> 'c -> 'r [@@deriving quickcheck]\n type (-'a, -'b, -'c, -'d, 'r) fn4 = 'a -> 'b -> 'c -> 'd -> 'r [@@deriving quickcheck]\n\n type (-'a, -'b, -'c, -'d, -'e, 'r) fn5 = 'a -> 'b -> 'c -> 'd -> 'e -> 'r\n [@@deriving quickcheck]\n\n type (-'a, -'b, -'c, -'d, -'e, -'f, 'r) fn6 = 'a -> 'b -> 'c -> 'd -> 'e -> 'f -> 'r\n [@@deriving quickcheck]\nend\n\nmodule Observer = struct\n include Observer\n\n let of_hash (type a) (module M : Deriving_hash with type t = a) =\n of_hash_fold M.hash_fold_t\n ;;\n\n let variant2 = Polymorphic_types.quickcheck_observer_variant2\n let variant3 = Polymorphic_types.quickcheck_observer_variant3\n let variant4 = Polymorphic_types.quickcheck_observer_variant4\n let variant5 = Polymorphic_types.quickcheck_observer_variant5\n let variant6 = Polymorphic_types.quickcheck_observer_variant6\n let tuple2 = Polymorphic_types.quickcheck_observer_tuple2\n let tuple3 = Polymorphic_types.quickcheck_observer_tuple3\n let tuple4 = Polymorphic_types.quickcheck_observer_tuple4\n let tuple5 = Polymorphic_types.quickcheck_observer_tuple5\n let tuple6 = Polymorphic_types.quickcheck_observer_tuple6\n let of_predicate a b ~f = unmap (variant2 a b) ~f:(fun x -> if f x then `A x else `B x)\n let singleton () = opaque\n let doubleton f = of_predicate (singleton ()) (singleton ()) ~f\n let enum _ ~f = unmap int ~f\n\n let of_list list ~equal =\n let f x =\n match List.findi list ~f:(fun _ y -> equal x y) with\n | None -> failwith \"Quickcheck.Observer.of_list: value not found\"\n | Some (i, _) -> i\n in\n enum (List.length list) ~f\n ;;\n\n let of_fun f = create (fun x ~size ~hash -> observe (f ()) x ~size ~hash)\n\n let comparison ~compare ~eq ~lt ~gt =\n unmap\n (variant3 lt (singleton ()) gt)\n ~f:(fun x ->\n let c = compare x eq in\n if c < 0 then `A x else if c > 0 then `C x else `B x)\n ;;\nend\n\nmodule Generator = struct\n include Generator\n open Let_syntax\n\n let singleton = return\n\n let doubleton x y =\n create (fun ~size:_ ~random -> if Splittable_random.bool random then x else y)\n ;;\n\n let of_fun f = create (fun ~size ~random -> generate (f ()) ~size ~random)\n\n let of_sequence ~p seq =\n if Float.( <= ) p 0. || Float.( > ) p 1.\n then\n failwith (Printf.sprintf \"Generator.of_sequence: probability [%f] out of bounds\" p);\n Sequence.delayed_fold\n seq\n ~init:()\n ~finish:(fun () -> failwith \"Generator.of_sequence: ran out of values\")\n ~f:(fun () x ~k -> weighted_union [ p, singleton x; 1. -. p, of_fun k ])\n ;;\n\n let rec bounded_geometric ~p ~maximum init =\n if init = maximum\n then singleton maximum\n else\n weighted_union\n [ p, singleton init\n ; 1. -. p, of_fun (fun () -> bounded_geometric ~p ~maximum (init + 1))\n ]\n ;;\n\n let geometric ~p init = bounded_geometric ~p ~maximum:Int.max_value init\n let small_non_negative_int = small_positive_or_zero_int\n let small_positive_int = small_strictly_positive_int\n let list_with_length length t = list_with_length t ~length\n let variant2 = Polymorphic_types.quickcheck_generator_variant2\n let variant3 = Polymorphic_types.quickcheck_generator_variant3\n let variant4 = Polymorphic_types.quickcheck_generator_variant4\n let variant5 = Polymorphic_types.quickcheck_generator_variant5\n let variant6 = Polymorphic_types.quickcheck_generator_variant6\n let tuple2 = Polymorphic_types.quickcheck_generator_tuple2\n let tuple3 = Polymorphic_types.quickcheck_generator_tuple3\n let tuple4 = Polymorphic_types.quickcheck_generator_tuple4\n let tuple5 = Polymorphic_types.quickcheck_generator_tuple5\n let tuple6 = Polymorphic_types.quickcheck_generator_tuple6\n let fn2 = Polymorphic_types.quickcheck_generator_fn2\n let fn3 = Polymorphic_types.quickcheck_generator_fn3\n let fn4 = Polymorphic_types.quickcheck_generator_fn4\n let fn5 = Polymorphic_types.quickcheck_generator_fn5\n let fn6 = Polymorphic_types.quickcheck_generator_fn6\n\n let compare_fn dom =\n fn dom int >>| fun get_index x y -> [%compare: int] (get_index x) (get_index y)\n ;;\n\n let equal_fn dom = compare_fn dom >>| fun cmp x y -> Int.( = ) (cmp x y) 0\nend\n\nmodule Shrinker = struct\n include Shrinker\n\n let empty () = atomic\n let variant2 = Polymorphic_types.quickcheck_shrinker_variant2\n let variant3 = Polymorphic_types.quickcheck_shrinker_variant3\n let variant4 = Polymorphic_types.quickcheck_shrinker_variant4\n let variant5 = Polymorphic_types.quickcheck_shrinker_variant5\n let variant6 = Polymorphic_types.quickcheck_shrinker_variant6\n let tuple2 = Polymorphic_types.quickcheck_shrinker_tuple2\n let tuple3 = Polymorphic_types.quickcheck_shrinker_tuple3\n let tuple4 = Polymorphic_types.quickcheck_shrinker_tuple4\n let tuple5 = Polymorphic_types.quickcheck_shrinker_tuple5\n let tuple6 = Polymorphic_types.quickcheck_shrinker_tuple6\nend\n\nmodule Let_syntax = struct\n module Let_syntax = struct\n include Generator\n module Open_on_rhs = Generator\n end\n\n include Generator.Monad_infix\n\n let return = Generator.return\nend\n\nmodule Configure (Config : Quickcheck_config) = struct\n include Config\n\n let nondeterministic_state = lazy (Random.State.make_self_init ())\n\n let random_state_of_seed seed =\n match seed with\n | `Nondeterministic -> Splittable_random.State.create (force nondeterministic_state)\n | `Deterministic str -> Splittable_random.State.of_int ([%hash: string] str)\n ;;\n\n let make_seed seed : Test.Config.Seed.t =\n match seed with\n | `Nondeterministic -> Nondeterministic\n | `Deterministic string -> Deterministic string\n ;;\n\n let make_shrink_count = function\n | `Exhaustive -> Int.max_value\n | `Limit n -> n\n ;;\n\n let make_config ~seed ~sizes ~trials ~shrink_attempts : Test.Config.t =\n { seed = make_seed (Option.value seed ~default:default_seed)\n ; sizes = Option.value sizes ~default:default_sizes\n ; test_count = Option.value trials ~default:default_trial_count\n ; shrink_count =\n make_shrink_count (Option.value shrink_attempts ~default:default_shrink_attempts)\n }\n ;;\n\n let make_test_m (type a) ~gen ~shrinker ~sexp_of : (module Test.S with type t = a) =\n let module M = struct\n type t = a\n\n let quickcheck_generator = gen\n let quickcheck_shrinker = Option.value shrinker ~default:Shrinker.atomic\n let sexp_of_t = Option.value sexp_of ~default:[%sexp_of: _]\n end\n in\n (module M)\n ;;\n\n let random_value ?(seed = default_seed) ?(size = 30) gen =\n let random = random_state_of_seed seed in\n Generator.generate gen ~size ~random\n ;;\n\n let random_sequence ?seed ?sizes gen =\n let config =\n make_config ~seed ~sizes ~trials:(Some Int.max_value) ~shrink_attempts:None\n in\n let return = ref Sequence.empty in\n Test.with_sample_exn ~config gen ~f:(fun sequence -> return := sequence);\n !return\n ;;\n\n let iter ?seed ?sizes ?trials gen ~f =\n let config = make_config ~seed ~sizes ~trials ~shrink_attempts:None in\n Test.with_sample_exn ~config gen ~f:(fun sequence -> Sequence.iter sequence ~f)\n ;;\n\n let test ?seed ?sizes ?trials ?shrinker ?shrink_attempts ?sexp_of ?examples gen ~f =\n let config = make_config ~seed ~sizes ~trials ~shrink_attempts in\n let test_m = make_test_m ~gen ~shrinker ~sexp_of in\n Test.run_exn ~config ?examples ~f test_m\n ;;\n\n let test_or_error\n ?seed\n ?sizes\n ?trials\n ?shrinker\n ?shrink_attempts\n ?sexp_of\n ?examples\n gen\n ~f\n =\n let config = make_config ~seed ~sizes ~trials ~shrink_attempts in\n let test_m = make_test_m ~gen ~shrinker ~sexp_of in\n Test.run ~config ?examples ~f test_m\n ;;\n\n let test_distinct_values\n (type key)\n ?seed\n ?sizes\n ?sexp_of\n gen\n ~trials\n ~distinct_values\n ~compare\n =\n let module S =\n Caml.Set.Make (struct\n type t = key\n\n let compare = compare\n end)\n in\n let fail set =\n let expect_count = distinct_values in\n let actual_count = S.cardinal set in\n let values =\n match sexp_of with\n | None -> None\n | Some sexp_of_elt -> Some [%sexp (S.elements set : elt list)]\n in\n raise_s\n [%message\n \"insufficient distinct values\"\n (trials : int)\n (expect_count : int)\n (actual_count : int)\n (values : (Base.Sexp.t option[@sexp.option]))]\n in\n with_return (fun r ->\n let set = ref S.empty in\n iter ?seed ?sizes ~trials gen ~f:(fun elt ->\n set := S.add elt !set;\n if S.cardinal !set >= distinct_values then r.return ());\n fail !set)\n ;;\n\n let test_can_generate\n ?seed\n ?sizes\n ?(trials = default_can_generate_trial_count)\n ?sexp_of\n gen\n ~f\n =\n let r = ref [] in\n let f_and_enqueue return x = if f x then return `Can_generate else r := x :: !r in\n match\n With_return.with_return (fun return ->\n iter ?seed ?sizes ~trials gen ~f:(f_and_enqueue return.return);\n `Cannot_generate)\n with\n | `Can_generate -> ()\n | `Cannot_generate ->\n (match sexp_of with\n | None -> failwith \"cannot generate\"\n | Some sexp_of_value ->\n Error.raise_s [%message \"cannot generate\" ~attempts:(!r : value list)])\n ;;\nend\n\ninclude Configure (struct\n let default_seed = `Deterministic \"an arbitrary but deterministic string\"\n\n let default_trial_count =\n match Word_size.word_size with\n | W64 -> 10_000\n | W32 -> 1_000\n ;;\n\n let default_can_generate_trial_count = 10_000\n let default_shrink_attempts = `Limit 1000\n\n let default_sizes =\n Sequence.cycle_list_exn (List.range 0 30 ~stop:`inclusive)\n ;;\n end)\n\nmodule type S = S\nmodule type S1 = S1\nmodule type S2 = S2\nmodule type S_int = S_int\nmodule type S_range = S_range\n\ntype nonrec seed = seed\ntype nonrec shrink_attempts = shrink_attempts\n\nmodule type Quickcheck_config = Quickcheck_config\nmodule type Quickcheck_configured = Quickcheck_configured\n","(* We don't just include Sexplib.Std because one can only define Hashtbl once in this\n module. *)\n\nopen! Import\n\n(** [include]d first so that everything else shadows it *)\ninclude Core_pervasives\n\ninclude Int.Replace_polymorphic_compare\ninclude Base_quickcheck.Export\ninclude Deprecate_pipe_bang\ninclude Either.Export\ninclude From_sexplib\ninclude Interfaces\ninclude List.Infix\ninclude Never_returns\ninclude Ordering.Export\ninclude Perms.Export\ninclude Result.Export\n\ntype -'a return = 'a With_return.return = private { return : 'b. 'a -> 'b } [@@unboxed]\n\ninclude struct\n exception Bug of string [@deprecated \"[since 2020-03] Don't use [Bug]\"]\n [@@deriving sexp]\nend [@@alert \"-deprecated\"]\n\n\n(** Raised if malloc in C bindings fail (errno * size). *)\nexception C_malloc_exn of int * int\n\n(* errno, size *)\nlet () = Callback.register_exception \"C_malloc_exn\" (C_malloc_exn (0, 0))\n\nexception Finally = Exn.Finally\n\nlet fst3 (x, _, _) = x\nlet snd3 (_, y, _) = y\nlet trd3 (_, _, z) = z\n\nlet[@deprecated \"[since 2018-12] Use [Option.value_exn]\"] uw = function\n | Some x -> x\n | None ->\n raise Caml.Not_found\n;;\n\n(** [phys_same] is like [phys_equal], but with a more general type. [phys_same] is useful\n when dealing with existential types, when one has a packed value and an unpacked value\n that one wants to check are physically equal. One can't use [phys_equal] in such a\n situation because the types are different. *)\nlet phys_same (type a b) (a : a) (b : b) = phys_equal a (Obj.magic b : a)\n\nlet ( % ) = Int.( % )\nlet ( /% ) = Int.( /% )\nlet ( // ) = Int.( // )\nlet ( ==> ) a b = (not a) || b\nlet bprintf = Printf.bprintf\nlet const = Fn.const\nlet eprintf = Printf.eprintf\nlet error = Or_error.error\nlet error_s = Or_error.error_s\nlet failwithf = Base.Printf.failwithf\n\nlet failwithp =\n (Error.failwithp [@alert \"-deprecated\"])\n[@@deprecated \"[since 2020-03] Use [failwiths] instead.\"]\n;;\n\nlet failwiths = Error.failwiths\nlet force = Base.Lazy.force\nlet fprintf = Printf.fprintf\nlet ident = Fn.id\n\nlet invalid_argf = Base.Printf.invalid_argf\nlet ifprintf = Printf.ifprintf\nlet is_none = Option.is_none\nlet is_some = Option.is_some\nlet ksprintf = Printf.ksprintf\nlet ok_exn = Or_error.ok_exn\nlet phys_equal = Base.phys_equal\nlet phys_same = phys_same\nlet print_s = Stdio.print_s\nlet eprint_s = Stdio.eprint_s\nlet printf = Printf.printf\nlet protect = Exn.protect\nlet protectx = Exn.protectx\nlet raise_s = Error.raise_s\nlet round = Float.round\nlet ( **. ) = Base.( **. )\n\nlet sprintf = Printf.sprintf\nlet stage = Staged.stage\nlet unstage = Staged.unstage\nlet with_return = With_return.with_return\nlet with_return_option = With_return.with_return_option\n\n(* With the following aliases, we are just making extra sure that the toplevel sexp\n converters line up with the ones in our modules. *)\n\n\ninclude Typerep_lib.Std_internal\n\ninclude (\nstruct\n (* [deriving hash] is missing for [array], [bytes], and [ref] since these types are\n mutable. *)\n type 'a array = 'a Array.t\n [@@deriving bin_io, compare, equal, sexp, sexp_grammar, typerep]\n\n type bool = Bool.t\n [@@deriving bin_io, compare, hash, equal, sexp, sexp_grammar, typerep]\n\n type char = Char.t\n [@@deriving bin_io, compare, hash, equal, sexp, sexp_grammar, typerep]\n\n type float = Float.t\n [@@deriving bin_io, compare, hash, equal, sexp, sexp_grammar, typerep]\n\n type int = Int.t\n [@@deriving bin_io, compare, hash, equal, sexp, sexp_grammar, typerep]\n\n type int32 = Int32.t\n [@@deriving bin_io, compare, hash, equal, sexp, sexp_grammar, typerep]\n\n type int64 = Int64.t\n [@@deriving bin_io, compare, hash, equal, sexp, sexp_grammar, typerep]\n\n type 'a lazy_t = 'a Lazy.t\n [@@deriving bin_io, compare, hash, sexp, sexp_grammar, typerep]\n\n type 'a list = 'a List.t\n [@@deriving bin_io, compare, hash, equal, sexp, sexp_grammar, typerep]\n\n type nativeint = Nativeint.t\n [@@deriving bin_io, compare, equal, hash, sexp, sexp_grammar, typerep]\n\n type 'a option = 'a Option.t\n [@@deriving bin_io, compare, equal, hash, sexp, sexp_grammar, typerep]\n\n type string = String.t\n [@@deriving bin_io, compare, equal, hash, sexp, sexp_grammar, typerep]\n\n type bytes = Bytes.t [@@deriving bin_io, compare, equal, sexp, sexp_grammar, typerep]\n\n type 'a ref = 'a Ref.t\n [@@deriving bin_io, compare, equal, sexp, sexp_grammar, typerep]\n\n type unit = Unit.t\n [@@deriving bin_io, compare, equal, hash, sexp, sexp_grammar, typerep]\n\n (* Bin_prot has optimized functions for float arrays *)\n type float_array = Bin_prot.Std.float_array [@@deriving bin_io]\n\n include (\n struct\n type float_array = Float.t array\n [@@deriving compare, sexp, sexp_grammar, typerep]\n end :\n sig\n type float_array [@@deriving compare, sexp, sexp_grammar, typerep]\n end\n with type float_array := float_array)\nend :\nsig\n type 'a array [@@deriving bin_io, compare, equal, sexp, sexp_grammar, typerep]\n type bool [@@deriving bin_io, compare, equal, hash, sexp, sexp_grammar, typerep]\n type char [@@deriving bin_io, compare, equal, hash, sexp, sexp_grammar, typerep]\n type float [@@deriving bin_io, compare, equal, hash, sexp, sexp_grammar, typerep]\n type int [@@deriving bin_io, compare, equal, hash, sexp, sexp_grammar, typerep]\n type int32 [@@deriving bin_io, compare, equal, hash, sexp, sexp_grammar, typerep]\n type int64 [@@deriving bin_io, compare, equal, hash, sexp, sexp_grammar, typerep]\n type 'a lazy_t [@@deriving bin_io, compare, hash, sexp, sexp_grammar, typerep]\n type 'a list [@@deriving bin_io, compare, equal, hash, sexp, sexp_grammar, typerep]\n\n type nativeint\n [@@deriving bin_io, compare, equal, hash, sexp, sexp_grammar, typerep]\n\n type 'a option\n [@@deriving bin_io, compare, equal, hash, sexp, sexp_grammar, typerep]\n\n type string [@@deriving bin_io, compare, equal, hash, sexp, sexp_grammar, typerep]\n type bytes [@@deriving bin_io, compare, equal, sexp, sexp_grammar, typerep]\n type 'a ref [@@deriving bin_io, compare, equal, sexp, sexp_grammar, typerep]\n type unit [@@deriving bin_io, compare, equal, hash, sexp, sexp_grammar, typerep]\n\n type float_array = float array\n [@@deriving bin_io, compare, sexp, sexp_grammar, typerep]\nend\nwith type 'a array := 'a array\nwith type bool := bool\nwith type char := char\nwith type float := float\nwith type int := int\nwith type int32 := int32\nwith type int64 := int64\nwith type 'a list := 'a list\nwith type nativeint := nativeint\nwith type 'a option := 'a option\nwith type string := string\nwith type bytes := bytes\nwith type 'a lazy_t := 'a lazy_t\nwith type 'a ref := 'a ref\nwith type unit := unit)\n\nlet sexp_of_exn = Exn.sexp_of_t\n\n\n(* The below declarations define converters for the special types recognized by pa-sexp.\n E.g. this allows the following to work:\n\n type t = { foo : int sexp_option } [@@deriving bin_io, compare, hash, sexp] *)\ninclude struct\n [@@@ocaml.warning \"-3\"]\n\n type 'a sexp_array = 'a array\n [@@deriving bin_io, compare, typerep]\n [@@deprecated \"[since 2019-03] use [@sexp.array] instead\"]\n\n type sexp_bool = bool\n [@@deriving bin_io, compare, hash, typerep]\n [@@deprecated \"[since 2019-03] use [@sexp.bool] instead\"]\n\n type 'a sexp_list = 'a list\n [@@deriving bin_io, compare, hash, typerep]\n [@@deprecated \"[since 2019-03] use [@sexp.list] instead\"]\n\n type 'a sexp_option = 'a option\n [@@deriving bin_io, compare, hash, typerep]\n [@@deprecated \"[since 2019-03] use [@sexp.option] instead\"]\n\n type 'a sexp_opaque = 'a\n [@@deriving bin_io, compare, hash, typerep]\n [@@deprecated \"[since 2019-03] use [@sexp.opaque] instead\"]\nend\n\n(* The code below checks that the signatures in core_map.mli and core_set.mli are\n consistent with the generic map and set signatures defined in map_intf.ml\n and core_set_intf.ml. *)\n\nlet () =\n let module T = struct\n type 'a elt = 'a\n type 'a cmp = 'a\n end\n in\n let module M : sig\n open Set_intf\n\n module Tree : sig\n type ('a, 'b) t\n\n include\n Creators_and_accessors2_with_comparator\n with type ('a, 'b) set := ('a, 'b) t\n with type ('a, 'b) t := ('a, 'b) t\n with type ('a, 'b) tree := ('a, 'b) t\n with type ('a, 'b) named := ('a, 'b) Tree.Named.t\n end\n\n type ('a, 'b) t\n\n include\n Accessors2\n with type ('a, 'b) t := ('a, 'b) t\n with type ('a, 'b) tree := ('a, 'b) Tree.t\n with type ('a, 'b) named := ('a, 'b) Named.t\n\n include\n Creators_generic\n with type ('a, 'b) set := ('a, 'b) t\n with type ('a, 'b) t := ('a, 'b) t\n with type ('a, 'b) tree := ('a, 'b) Tree.t\n with type 'a elt := 'a T.elt\n with type 'a cmp := 'a T.cmp\n with type ('a, 'cmp, 'z) options :=\n ('a, 'cmp, 'z) Set_intf.With_first_class_module.t\n end =\n Set\n in\n ()\n;;\n\nlet () =\n let module T = struct\n type 'k key = 'k\n type 'c cmp = 'c\n end\n in\n let module M : sig\n open Map_intf\n\n module Tree : sig\n type ('a, 'b, 'c) t\n\n include\n Creators_and_accessors3_with_comparator\n with type ('a, 'b, 'c) t := ('a, 'b, 'c) t\n with type ('a, 'b, 'c) tree := ('a, 'b, 'c) t\n end\n\n type ('a, 'b, 'c) t\n\n include\n Accessors3\n with type ('a, 'b, 'c) t := ('a, 'b, 'c) t\n with type ('a, 'b, 'c) tree := ('a, 'b, 'c) Tree.t\n\n include\n Creators_generic\n with type ('a, 'b, 'c) t := ('a, 'b, 'c) t\n with type ('a, 'b, 'c) tree := ('a, 'b, 'c) Tree.t\n with type ('a, 'cmp, 'z) options :=\n ('a, 'cmp, 'z) Map_intf.With_first_class_module.t\n with type 'k key := 'k T.key\n with type 'c cmp := 'c T.cmp\n end =\n Map\n in\n ()\n;;\n\n","open! Import\nopen Std_internal\nopen! Int.Replace_polymorphic_compare\n\nmodule Stable = struct\n module V1 = struct\n module Parts = struct\n type t =\n { sign : Sign.t\n ; hr : int\n ; min : int\n ; sec : int\n ; ms : int\n ; us : int\n ; ns : int\n }\n [@@deriving compare, sexp]\n end\n\n module type Like_a_float = sig\n type t [@@deriving bin_io, hash, quickcheck, typerep]\n\n include Comparable.S_common with type t := t\n include Comparable.With_zero with type t := t\n include Floatable with type t := t\n\n val ( + ) : t -> t -> t\n val ( - ) : t -> t -> t\n val zero : t\n val robust_comparison_tolerance : t\n val abs : t -> t\n val neg : t -> t\n val scale : t -> float -> t\n end\n\n module T : sig\n type underlying = float [@@deriving hash]\n type t = private underlying [@@deriving bin_io, hash]\n\n include Like_a_float with type t := t\n include Robustly_comparable with type t := t\n\n module Constant : sig\n val nanoseconds_per_second : float\n val microseconds_per_second : float\n val milliseconds_per_second : float\n val nanosecond : t\n val microsecond : t\n val millisecond : t\n val second : t\n val minute : t\n val hour : t\n val day : t\n end\n\n val to_parts : t -> Parts.t\n val next : t -> t\n val prev : t -> t\n end = struct\n type underlying = float [@@deriving hash]\n type t = underlying [@@deriving hash]\n\n let next t = Float.one_ulp `Up t\n let prev t = Float.one_ulp `Down t\n\n (* IF THIS REPRESENTATION EVER CHANGES, ENSURE THAT EITHER\n (1) all values serialize the same way in both representations, or\n (2) you add a new Time.Span version to stable.ml *)\n include (\n struct\n include Float\n\n let sign = sign_exn\n end :\n Like_a_float with type t := t)\n\n (* due to precision limitations in float we can't expect better than microsecond\n precision *)\n include Float.Robust_compare.Make (struct\n let robust_comparison_tolerance = 1E-6\n end)\n\n (* this prevents any worry about having these very common names redefined below and\n makes their usage within this module safer. Constant is included at the very\n bottom to re-export these constants in a more convenient way *)\n module Constant = struct\n let nanoseconds_per_second = 1E9\n let microseconds_per_second = 1E6\n let milliseconds_per_second = 1E3\n\n (* spans are stored as a float in seconds *)\n let nanosecond = of_float (1. /. nanoseconds_per_second)\n let microsecond = of_float (1. /. microseconds_per_second)\n let millisecond = of_float (1. /. milliseconds_per_second)\n let second = of_float 1.\n let minute = of_float 60.\n let hour = of_float (60. *. 60.)\n let day = of_float (24. *. 60. *. 60.)\n end\n\n\n let to_parts t : Parts.t =\n let sign = Float.sign_exn t in\n let t = abs t in\n let integral = Float.round_down t in\n let fractional = t -. integral in\n let seconds = Float.iround_down_exn integral in\n let nanoseconds = Float.iround_nearest_exn (fractional *. 1E9) in\n let seconds, nanoseconds =\n if Int.equal nanoseconds 1_000_000_000\n then Int.succ seconds, 0\n else seconds, nanoseconds\n in\n let sec = seconds mod 60 in\n let minutes = seconds / 60 in\n let min = minutes mod 60 in\n let hr = minutes / 60 in\n let ns = nanoseconds mod 1000 in\n let microseconds = nanoseconds / 1000 in\n let us = microseconds mod 1000 in\n let milliseconds = microseconds / 1000 in\n let ms = milliseconds in\n { sign; hr; min; sec; ms; us; ns }\n ;;\n end\n\n let ( / ) t f = T.of_float ((t : T.t :> float) /. f)\n let ( // ) (f : T.t) (t : T.t) = (f :> float) /. (t :> float)\n\n (* Multiplying by 1E3 is more accurate than division by 1E-3 *)\n let to_ns (x : T.t) = (x :> float) *. T.Constant.nanoseconds_per_second\n let to_us (x : T.t) = (x :> float) *. T.Constant.microseconds_per_second\n let to_ms (x : T.t) = (x :> float) *. T.Constant.milliseconds_per_second\n let to_sec (x : T.t) = (x :> float)\n let to_min x = x // T.Constant.minute\n let to_hr x = x // T.Constant.hour\n let to_day x = x // T.Constant.day\n let to_int63_seconds_round_down_exn x = Float.int63_round_down_exn (to_sec x)\n let ( ** ) f (t : T.t) = T.of_float (f *. (t :> float))\n\n (* Division by 1E3 is more accurate than multiplying by 1E-3 *)\n let of_ns x = T.of_float (x /. T.Constant.nanoseconds_per_second)\n let of_us x = T.of_float (x /. T.Constant.microseconds_per_second)\n let of_ms x = T.of_float (x /. T.Constant.milliseconds_per_second)\n let of_sec x = T.of_float x\n let of_int_sec x = of_sec (Float.of_int x)\n let of_int32_seconds sec = of_sec (Int32.to_float sec)\n\n (* Note that [Int63.to_float] can lose precision, but only on inputs large enough that\n [of_sec] in either the Time_ns or Time_float case would lose precision (or just be\n plain out of bounds) anyway. *)\n let of_int63_seconds sec = of_sec (Int63.to_float sec)\n let of_min x = x ** T.Constant.minute\n let of_hr x = x ** T.Constant.hour\n let of_day x = x ** T.Constant.day\n\n let divide_by_unit_of_time t unit_of_time =\n match (unit_of_time : Unit_of_time.t) with\n | Nanosecond -> to_ns t\n | Microsecond -> to_us t\n | Millisecond -> to_ms t\n | Second -> to_sec t\n | Minute -> to_min t\n | Hour -> to_hr t\n | Day -> to_day t\n ;;\n\n let scale_by_unit_of_time float unit_of_time =\n match (unit_of_time : Unit_of_time.t) with\n | Nanosecond -> of_ns float\n | Microsecond -> of_us float\n | Millisecond -> of_ms float\n | Second -> of_sec float\n | Minute -> of_min float\n | Hour -> of_hr float\n | Day -> of_day float\n ;;\n\n let create\n ?(sign = Sign.Pos)\n ?(day = 0)\n ?(hr = 0)\n ?(min = 0)\n ?(sec = 0)\n ?(ms = 0)\n ?(us = 0)\n ?(ns = 0)\n ()\n =\n let ( + ) = T.( + ) in\n let t =\n of_day (Float.of_int day)\n + of_hr (Float.of_int hr)\n + of_min (Float.of_int min)\n + of_sec (Float.of_int sec)\n + of_ms (Float.of_int ms)\n + of_us (Float.of_int us)\n + of_ns (Float.of_int ns)\n in\n match sign with\n | Neg -> T.( - ) T.zero t\n | Pos | Zero -> t\n ;;\n\n include T\n include Constant\n\n let randomize t ~percent = Span_helpers.randomize t ~percent ~scale\n\n let to_short_string t =\n let ({ sign; hr; min; sec; ms; us; ns } : Parts.t) = to_parts t in\n Span_helpers.short_string ~sign ~hr ~min ~sec ~ms ~us ~ns\n ;;\n\n (* WARNING: if you are going to change this function in any material way, make sure\n you update Stable appropriately. *)\n let of_string_v1_v2 (s : string) ~is_v2 =\n try\n match s with\n | \"\" -> failwith \"empty string\"\n | _ ->\n let float n =\n match String.drop_suffix s n with\n | \"\" -> failwith \"no number given\"\n | s ->\n let v = Float.of_string s in\n Validate.maybe_raise (Float.validate_ordinary v);\n v\n in\n let len = String.length s in\n (match s.[Int.( - ) len 1] with\n | 's' ->\n if Int.( >= ) len 2 && Char.( = ) s.[Int.( - ) len 2] 'm'\n then of_ms (float 2)\n else if is_v2 && Int.( >= ) len 2 && Char.( = ) s.[Int.( - ) len 2] 'u'\n then of_us (float 2)\n else if is_v2 && Int.( >= ) len 2 && Char.( = ) s.[Int.( - ) len 2] 'n'\n then of_ns (float 2)\n else T.of_float (float 1)\n | 'm' -> of_min (float 1)\n | 'h' -> of_hr (float 1)\n | 'd' -> of_day (float 1)\n | _ ->\n if is_v2\n then failwith \"Time spans must end in ns, us, ms, s, m, h, or d.\"\n else failwith \"Time spans must end in ms, s, m, h, or d.\")\n with\n | exn ->\n invalid_argf \"Span.of_string could not parse '%s': %s\" s (Exn.to_string exn) ()\n ;;\n\n let of_sexp_error_exn exn sexp = of_sexp_error (Exn.to_string exn) sexp\n\n exception T_of_sexp of Sexp.t * exn [@@deriving sexp]\n exception T_of_sexp_expected_atom_but_got of Sexp.t [@@deriving sexp]\n\n let t_of_sexp_v1_v2 sexp ~is_v2 =\n match sexp with\n | Sexp.Atom x ->\n (try of_string_v1_v2 x ~is_v2 with\n | exn -> of_sexp_error_exn (T_of_sexp (sexp, exn)) sexp)\n | Sexp.List _ -> of_sexp_error_exn (T_of_sexp_expected_atom_but_got sexp) sexp\n ;;\n\n let string ~is_v2 suffix float =\n if is_v2\n (* This is the same float-to-string conversion used in [Float.sexp_of_t]. It's like\n [Float.to_string], but may leave off trailing period. *)\n then !Sexplib.Conv.default_string_of_float float ^ suffix\n else sprintf \"%g%s\" float suffix\n ;;\n\n (* WARNING: if you are going to change this function in any material way, make sure\n you update Stable appropriately. *)\n (* I'd like it to be the case that you could never construct an infinite span, but I\n can't think of a good way to enforce it. So this to_string function can produce\n strings that will raise an exception when they are fed to of_string *)\n let to_string_v1_v2 (t : T.t) ~is_v2 =\n (* this is a sad broken abstraction... *)\n let module C = Float.Class in\n match Float.classify (t :> float) with\n | C.Subnormal | C.Zero -> \"0s\"\n | C.Infinite -> if T.( > ) t T.zero then \"inf\" else \"-inf\"\n | C.Nan -> \"nan\"\n | C.Normal ->\n let ( < ) = T.( < ) in\n let abs_t = T.of_float (Float.abs (t :> float)) in\n if is_v2 && abs_t < T.Constant.microsecond\n then string ~is_v2 \"ns\" (to_ns t)\n else if is_v2 && abs_t < T.Constant.millisecond\n then string ~is_v2 \"us\" (to_us t)\n else if abs_t < T.Constant.second\n then string ~is_v2 \"ms\" (to_ms t)\n else if abs_t < T.Constant.minute\n then string ~is_v2 \"s\" (to_sec t)\n else if abs_t < T.Constant.hour\n then string ~is_v2 \"m\" (to_min t)\n else if abs_t < T.Constant.day\n then string ~is_v2 \"h\" (to_hr t)\n else string ~is_v2 \"d\" (to_day t)\n ;;\n\n let sexp_of_t_v1_v2 t ~is_v2 = Sexp.Atom (to_string_v1_v2 t ~is_v2)\n let t_of_sexp sexp = t_of_sexp_v1_v2 sexp ~is_v2:false\n let sexp_of_t t = sexp_of_t_v1_v2 t ~is_v2:false\n end\n\n module V2 = struct\n include V1\n\n let t_of_sexp sexp = t_of_sexp_v1_v2 sexp ~is_v2:true\n let sexp_of_t t = sexp_of_t_v1_v2 t ~is_v2:true\n end\n\n module V3 = struct\n include V1\n\n let to_unit_of_time t : Unit_of_time.t =\n let open T in\n let open Constant in\n let abs_t = T.abs t in\n if abs_t >= day\n then Day\n else if abs_t >= hour\n then Hour\n else if abs_t >= minute\n then Minute\n else if abs_t >= second\n then Second\n else if abs_t >= millisecond\n then Millisecond\n else if abs_t >= microsecond\n then Microsecond\n else Nanosecond\n ;;\n\n let of_unit_of_time : Unit_of_time.t -> T.t =\n let open T.Constant in\n function\n | Nanosecond -> nanosecond\n | Microsecond -> microsecond\n | Millisecond -> millisecond\n | Second -> second\n | Minute -> minute\n | Hour -> hour\n | Day -> day\n ;;\n\n let suffix_of_unit_of_time unit_of_time =\n match (unit_of_time : Unit_of_time.t) with\n | Nanosecond -> \"ns\"\n | Microsecond -> \"us\"\n | Millisecond -> \"ms\"\n | Second -> \"s\"\n | Minute -> \"m\"\n | Hour -> \"h\"\n | Day -> \"d\"\n ;;\n\n module Of_string = struct\n let invalid_string string ~reason =\n let message = \"Time.Span.of_string: \" ^ reason in\n raise_s [%message message string]\n ;;\n\n let rec find_unit_of_time_by_suffix string ~index unit_of_time_list =\n match unit_of_time_list with\n | [] -> invalid_string string ~reason:\"invalid span part suffix\"\n | unit_of_time :: rest ->\n let suffix = suffix_of_unit_of_time unit_of_time in\n if String.is_substring_at string ~pos:index ~substring:suffix\n then unit_of_time\n else find_unit_of_time_by_suffix string ~index rest\n ;;\n\n let parse_suffix string ~index =\n (* We rely on the fact that \"ms\" comes before \"m\" in [Unit_of_time.all] to get a\n correct match on millisecond timestamps. This assumption is demonstrated in the\n expect test below. *)\n find_unit_of_time_by_suffix string ~index Unit_of_time.all\n ;;\n\n (* We validate magnitude strings so that we know where the unit-of-time suffix\n begins, and so that only sensible strings are allowed. We do not want to be as\n permissive as [Float.of_string]; for example, hexadecimal span magnitudes are not\n allowed. After validation, we still use [Float.of_string] to produce the actual\n value. *)\n module Float_parser = struct\n (* [In_decimal_have_digit] includes having a digit before the decimal point. *)\n type state =\n | In_integer_need_digit\n | In_integer_have_digit\n | In_decimal_need_digit\n | In_decimal_have_digit\n | In_exponent_need_digit_or_sign\n | In_exponent_need_digit\n | In_exponent_have_digit\n\n type token =\n | Digit\n | Point\n | Under\n | Sign\n | Expt\n\n let state_is_final = function\n | In_integer_have_digit | In_decimal_have_digit | In_exponent_have_digit ->\n true\n | In_integer_need_digit\n | In_decimal_need_digit\n | In_exponent_need_digit_or_sign\n | In_exponent_need_digit -> false\n ;;\n\n let token_of_char = function\n | '0' .. '9' -> Some Digit\n | '.' -> Some Point\n | '_' -> Some Under\n | '-' | '+' -> Some Sign\n | 'E' | 'e' -> Some Expt\n | _ -> None\n ;;\n\n let invalid_string string =\n invalid_string string ~reason:\"invalid span part magnitude\"\n ;;\n\n let rec find_index_after_float_in_state string ~index ~len ~state =\n let open Int.O in\n if index = len\n then if state_is_final state then index else invalid_string string\n else (\n match token_of_char string.[index] with\n | None -> if state_is_final state then index else invalid_string string\n | Some token ->\n let state =\n match state, token with\n | In_integer_need_digit, Digit -> In_integer_have_digit\n | In_integer_need_digit, Point -> In_decimal_need_digit\n | In_integer_need_digit, Under\n | In_integer_need_digit, Sign\n | In_integer_need_digit, Expt -> invalid_string string\n | In_integer_have_digit, Digit | In_integer_have_digit, Under ->\n In_integer_have_digit\n | In_integer_have_digit, Point -> In_decimal_have_digit\n | In_integer_have_digit, Expt -> In_exponent_need_digit_or_sign\n | In_integer_have_digit, Sign -> invalid_string string\n | In_decimal_need_digit, Digit -> In_decimal_have_digit\n | In_decimal_need_digit, Point\n | In_decimal_need_digit, Under\n | In_decimal_need_digit, Expt\n | In_decimal_need_digit, Sign -> invalid_string string\n | In_decimal_have_digit, Digit | In_decimal_have_digit, Under ->\n In_decimal_have_digit\n | In_decimal_have_digit, Expt -> In_exponent_need_digit_or_sign\n | In_decimal_have_digit, Point | In_decimal_have_digit, Sign ->\n invalid_string string\n | In_exponent_need_digit_or_sign, Digit -> In_exponent_have_digit\n | In_exponent_need_digit_or_sign, Sign -> In_exponent_need_digit\n | In_exponent_need_digit_or_sign, Point\n | In_exponent_need_digit_or_sign, Under\n | In_exponent_need_digit_or_sign, Expt -> invalid_string string\n | In_exponent_need_digit, Digit -> In_exponent_have_digit\n | In_exponent_need_digit, Point\n | In_exponent_need_digit, Under\n | In_exponent_need_digit, Expt\n | In_exponent_need_digit, Sign -> invalid_string string\n | In_exponent_have_digit, Digit | In_exponent_have_digit, Under ->\n In_exponent_have_digit\n | In_exponent_have_digit, Point\n | In_exponent_have_digit, Expt\n | In_exponent_have_digit, Sign -> invalid_string string\n in\n find_index_after_float_in_state string ~index:(index + 1) ~len ~state)\n ;;\n\n let find_index_after_float string ~index ~len =\n find_index_after_float_in_state string ~index ~len ~state:In_integer_need_digit\n ;;\n end\n\n let rec accumulate_magnitude string ~magnitude ~index ~len =\n if Int.equal index len\n then magnitude\n else (\n let suffix_index = Float_parser.find_index_after_float string ~index ~len in\n let unit_of_time = parse_suffix string ~index:suffix_index in\n let until_index =\n Int.( + ) suffix_index (String.length (suffix_of_unit_of_time unit_of_time))\n in\n let float_string =\n String.sub string ~pos:index ~len:(Int.( - ) suffix_index index)\n in\n let float = Float.of_string float_string in\n let magnitude = magnitude + scale_by_unit_of_time float unit_of_time in\n accumulate_magnitude string ~magnitude ~index:until_index ~len)\n ;;\n\n let parse_magnitude string ~index ~len =\n accumulate_magnitude string ~magnitude:T.zero ~index ~len\n ;;\n\n let of_string string =\n let open Int.O in\n match string with\n | \"NANs\" -> of_sec Float.nan\n | \"-INFs\" -> of_sec Float.neg_infinity\n | \"INFs\" -> of_sec Float.infinity\n | _ ->\n let len = String.length string in\n if len = 0 then invalid_string string ~reason:\"empty input\";\n let negative, index =\n match string.[0] with\n | '-' -> true, 1\n | '+' -> false, 1\n | _ -> false, 0\n in\n if index >= len then invalid_string string ~reason:\"empty input\";\n let magnitude = parse_magnitude string ~index ~len in\n if negative then T.neg magnitude else magnitude\n ;;\n end\n\n let of_string = Of_string.of_string\n\n module To_string = struct\n let string_of_float_without_trailing_decimal float =\n let string = Float.to_string float in\n let suffix = \".\" in\n if String.is_suffix string ~suffix\n then String.chop_suffix_exn string ~suffix\n else string\n ;;\n\n (* As we build up a string, we keep a running sum of the value that will be read\n back in, so that we can compute the remainder that needs to be generated. *)\n let sum ~sum_t ~unit_of_time ~magnitude =\n sum_t + scale_by_unit_of_time magnitude unit_of_time\n ;;\n\n (* For some units (very large numbers of days, or seconds and smaller) we just\n render a float directly, with a fix for roundoff error. *)\n let to_float_string ~abs_t ~unit_of_time ~fixup_unit_of_time =\n let magnitude = divide_by_unit_of_time abs_t unit_of_time in\n let sum_t = sum ~sum_t:zero ~unit_of_time ~magnitude in\n if sum_t = abs_t\n then\n string_of_float_without_trailing_decimal magnitude\n ^ suffix_of_unit_of_time unit_of_time\n else (\n let magnitude =\n if sum_t < abs_t\n then magnitude\n else divide_by_unit_of_time (prev abs_t) unit_of_time\n in\n let sum_t = sum ~sum_t:zero ~unit_of_time ~magnitude in\n let rem_t = abs_t - sum_t in\n let fixup_magnitude = divide_by_unit_of_time rem_t fixup_unit_of_time in\n string_of_float_without_trailing_decimal magnitude\n ^ suffix_of_unit_of_time unit_of_time\n (* [rem_t] is at ULP size of [abs_t], it needs just one bit of precision *)\n ^ sprintf \"%.1g\" fixup_magnitude\n ^ suffix_of_unit_of_time fixup_unit_of_time)\n ;;\n\n (* For non-decimal units (minutes and greater), we render an integer magnitude, and\n return that with the running sum so the remainder can be rendered at a smaller\n unit. *)\n let to_int_string_and_sum unit_of_time ~abs_t ~sum_t =\n let unit_span = of_unit_of_time unit_of_time in\n let rem_t = abs_t - sum_t in\n (* We calculate the approximate multiple of [unit_of_time] that needs to be\n added to [sum_t]. Due to rounding, this can be off by one (we've never seen a\n case off by two or more), so we re-compute the remainder and correct if\n necessary. *)\n let magnitude = Float.round_down (rem_t // unit_span) in\n let new_sum_t = sum ~sum_t ~unit_of_time ~magnitude in\n let new_rem_t = abs_t - new_sum_t in\n let magnitude =\n if new_rem_t = zero\n then magnitude\n else if new_rem_t < zero\n then magnitude -. 1.\n else (\n let next_magnitude = magnitude +. 1. in\n let next_sum_t = sum ~sum_t ~unit_of_time ~magnitude:next_magnitude in\n let next_rem_t = abs_t - next_sum_t in\n if next_rem_t < zero then magnitude else next_magnitude)\n in\n if Float.( <= ) magnitude 0.\n then \"\", sum_t\n else (\n let new_sum_t = sum ~sum_t ~unit_of_time ~magnitude in\n let string =\n Int63.to_string (Int63.of_float magnitude)\n ^ suffix_of_unit_of_time unit_of_time\n in\n string, new_sum_t)\n ;;\n\n let decimal_order_of_magnitude t = Float.log10 (to_sec t)\n\n (* The final seconds-or-smaller unit needs to be printed with enough digits to\n round-trip the whole span (which is minutes or greater); this can be\n significantly fewer digits than would be needed for the seconds-or-smaller\n remainder itself. *)\n let to_float_string_after_int_strings ~sum_t ~abs_t =\n if sum_t >= abs_t\n then \"\"\n else (\n let rem_t = abs_t - sum_t in\n let unit_of_time = to_unit_of_time rem_t in\n let unit_span = of_unit_of_time unit_of_time in\n let magnitude = rem_t // unit_span in\n let new_sum_t = sum ~sum_t ~unit_of_time ~magnitude in\n let new_rem_t = abs_t - new_sum_t in\n if abs rem_t <= abs new_rem_t\n then \"\"\n else (\n let order_of_magnitude_of_first_digit =\n Float.iround_down_exn (decimal_order_of_magnitude rem_t)\n in\n let half_ulp = (abs_t - prev abs_t) / 2. in\n let order_of_magnitude_of_final_digit =\n (* This works out to rounding down, except in the case of exact integers,\n which are decremented. This makes sure we always stop at a digit with\n strictly more precision than half the ULP. *)\n Int.pred (Float.iround_up_exn (decimal_order_of_magnitude half_ulp))\n in\n let number_of_digits =\n let open Int.O in\n 1 + order_of_magnitude_of_first_digit - order_of_magnitude_of_final_digit\n in\n let suffix = suffix_of_unit_of_time unit_of_time in\n sprintf \"%.*g\" number_of_digits magnitude ^ suffix))\n ;;\n\n (* This helper avoids unnecessary allocation, because for our use below, it is\n common to have either or both arguments be empty. Currently (2018-02), the\n built-in [^] allocates even when appending to an empty string. *)\n let ( ^? ) x y =\n if String.is_empty x then y else if String.is_empty y then x else x ^ y\n ;;\n\n let to_string t =\n let float = to_float t in\n if not (Float.is_finite float)\n then\n if (* We print specific special strings for non-finite floats *)\n Float.is_nan float\n then \"NANs\"\n else if Float.is_negative float\n then \"-INFs\"\n else \"INFs\"\n else if t = zero\n then \"0s\"\n else (\n let unit_of_time = to_unit_of_time t in\n let abs_t = abs t in\n let sign = if t < zero then \"-\" else \"\" in\n let magnitude_string =\n match unit_of_time with\n (* We can use normal float notation for seconds and sub-second units, they are\n readable with a decimal point. *)\n | Nanosecond | Microsecond | Millisecond | Second ->\n to_float_string ~abs_t ~unit_of_time ~fixup_unit_of_time:Nanosecond\n (* For large enough values that the ULP is a day or more, we can use float\n notation because we are expressing a single, very large integer. *)\n | Day when next abs_t - abs_t >= day ->\n to_float_string ~abs_t ~unit_of_time ~fixup_unit_of_time:Day\n (* For everything in between, we need to use integer units of days, hours,\n and/or minutes, because those units are not readable as decimals, and we\n tack on a decimal remainder of a seconds-or-smaller unit if necessary. *)\n | Minute | Hour | Day ->\n let sum_t = zero in\n let day_string, sum_t = to_int_string_and_sum ~abs_t ~sum_t Day in\n let hour_string, sum_t = to_int_string_and_sum ~abs_t ~sum_t Hour in\n let minute_string, sum_t = to_int_string_and_sum ~abs_t ~sum_t Minute in\n let float_string = to_float_string_after_int_strings ~abs_t ~sum_t in\n day_string ^? hour_string ^? minute_string ^? float_string\n in\n sign ^? magnitude_string)\n ;;\n end\n\n let to_string = To_string.to_string\n let sexp_of_t t = Sexp.Atom (to_string t)\n\n let t_of_sexp s =\n match s with\n | Sexp.Atom x ->\n (try of_string x with\n | exn -> of_sexp_error (Exn.to_string exn) s)\n | Sexp.List _ ->\n of_sexp_error \"Time.Span.Stable.V3.t_of_sexp: sexp must be an Atom\" s\n ;;\n end\nend\n\ninclude Stable.V3\n\nlet to_proportional_float = to_float\n\nlet to_string_hum\n ?(delimiter = '_')\n ?(decimals = 3)\n ?(align_decimal = false)\n ?unit_of_time\n t\n =\n let float, suffix =\n match Option.value unit_of_time ~default:(to_unit_of_time t) with\n | Day -> to_day t, \"d\"\n | Hour -> to_hr t, \"h\"\n | Minute -> to_min t, \"m\"\n | Second -> to_sec t, \"s\"\n | Millisecond -> to_ms t, \"ms\"\n | Microsecond -> to_us t, \"us\"\n | Nanosecond -> to_ns t, \"ns\"\n in\n let prefix =\n Float.to_string_hum float ~delimiter ~decimals ~strip_zero:(not align_decimal)\n in\n let suffix =\n if align_decimal && Int.( = ) (String.length suffix) 1 then suffix ^ \" \" else suffix\n in\n prefix ^ suffix\n;;\n\nlet gen_incl lo hi =\n Float.gen_incl (to_sec lo) (to_sec hi) |> Quickcheck.Generator.map ~f:of_sec\n;;\n\nlet gen_uniform_incl lo hi =\n (* Technically exclusive rather than inclusive, but otherwise satisfies the contract to\n within 1ulp of the given bounds. *)\n Float.gen_uniform_excl (to_sec lo) (to_sec hi) |> Quickcheck.Generator.map ~f:of_sec\n;;\n\ninclude Pretty_printer.Register (struct\n type nonrec t = t\n\n let to_string = to_string\n let module_name = \"Core_kernel.Time.Span\"\n end)\n\ninclude Hashable.Make_binable (struct\n type nonrec t = t [@@deriving bin_io, compare, hash, sexp_of]\n\n (* Previous versions rendered hash-based containers using float serialization rather\n than time serialization, so when reading hash-based containers in we accept either\n serialization. *)\n let t_of_sexp sexp =\n match Float.t_of_sexp sexp with\n | float -> of_float float\n | exception _ -> t_of_sexp sexp\n ;;\n end)\n\nmodule C = struct\n type t = T.t [@@deriving bin_io]\n type comparator_witness = T.comparator_witness\n\n let comparator = T.comparator\n\n (* In 108.06a and earlier, spans in sexps of Maps and Sets were raw floats. From 108.07\n through 109.13, the output format remained raw as before, but both the raw and pretty\n format were accepted as input. From 109.14 on, the output format was changed from\n raw to pretty, while continuing to accept both formats. Once we believe most\n programs are beyond 109.14, we will switch the input format to no longer accept\n raw. *)\n let sexp_of_t = sexp_of_t\n\n let t_of_sexp sexp =\n match Option.try_with (fun () -> T.of_float (Float.t_of_sexp sexp)) with\n | Some t -> t\n | None -> t_of_sexp sexp\n ;;\nend\n\nmodule Map = Map.Make_binable_using_comparator (C)\nmodule Set = Set.Make_binable_using_comparator (C)\n\nmodule Private = struct\n let suffix_of_unit_of_time = suffix_of_unit_of_time\n let parse_suffix = Stable.V3.Of_string.parse_suffix\nend\n","open! Import\n\nmodule type T = sig\n type t\nend\n\nmodule Make (T1 : T) (T2 : T) = struct\n type t = T1.t * T2.t\nend\n\nmodule T2 = struct\n type ('a, 'b) t = 'a * 'b [@@deriving sexp, typerep]\n\n let create a b = a, b\n\n let curry f =\n ();\n fun a b -> f (a, b)\n ;;\n\n let uncurry f =\n ();\n fun (a, b) -> f a b\n ;;\n\n external get1 : ('a, _) t -> 'a = \"%field0\"\n external get2 : (_, 'a) t -> 'a = \"%field1\"\n\n let map1 ~f (x, y) = f x, y\n let map2 ~f (x, y) = x, f y\n let map (x, y) ~f = f x, f y\n let map_fst (x, y) ~f = f x, y\n let map_snd (x, y) ~f = x, f y\n\n let compare ~cmp1 ~cmp2 (x, y) (x', y') =\n match cmp1 x x' with\n | 0 -> cmp2 y y'\n | i -> i\n ;;\n\n let equal ~eq1 ~eq2 (x, y) (x', y') = eq1 x x' && eq2 y y'\n let swap (a, b) = b, a\n\n include Comparator.Derived2 (struct\n type nonrec ('a, 'b) t = ('a, 'b) t [@@deriving sexp_of]\n\n let compare cmp1 cmp2 = compare ~cmp1 ~cmp2\n end)\nend\n\nmodule T3 = struct\n type ('a, 'b, 'c) t = 'a * 'b * 'c [@@deriving sexp, typerep]\n\n let create a b c = a, b, c\n\n let curry f =\n ();\n fun a b c -> f (a, b, c)\n ;;\n\n let uncurry f =\n ();\n fun (a, b, c) -> f a b c\n ;;\n\n let map1 ~f (x, y, z) = f x, y, z\n let map2 ~f (x, y, z) = x, f y, z\n let map3 ~f (x, y, z) = x, y, f z\n let map (x, y, z) ~f = f x, f y, f z\n let map_fst (x, y, z) ~f = f x, y, z\n let map_snd (x, y, z) ~f = x, f y, z\n let map_trd (x, y, z) ~f = x, y, f z\n\n external get1 : ('a, _, _) t -> 'a = \"%field0\"\n external get2 : (_, 'a, _) t -> 'a = \"%field1\"\n\n (* There's no %field2....*)\n let get3 (_, _, a) = a\n\n (* lexicographic comparison *)\n let compare ~cmp1 ~cmp2 ~cmp3 (x, y, z) (x', y', z') =\n let c1 = cmp1 x x' in\n if c1 <> 0\n then c1\n else (\n let c2 = cmp2 y y' in\n if c2 <> 0 then c2 else cmp3 z z')\n ;;\n\n let equal ~eq1 ~eq2 ~eq3 (x, y, z) (x', y', z') = eq1 x x' && eq2 y y' && eq3 z z'\nend\n\nmodule type Comparable_sexpable = sig\n type t [@@deriving sexp]\n\n include Comparable.S with type t := t\nend\n\nmodule type Hashable_sexpable = sig\n type t [@@deriving sexp]\n\n include Hashable.S with type t := t\nend\n\nmodule type Hasher_sexpable = sig\n type t [@@deriving compare, hash, sexp]\nend\n\nmodule Sexpable (S1 : Sexpable.S) (S2 : Sexpable.S) = struct\n type t = S1.t * S2.t [@@deriving sexp]\nend\n\nmodule Binable (B1 : Binable.S) (B2 : Binable.S) = struct\n type t = B1.t * B2.t [@@deriving bin_io]\nend\n\nmodule Comparable_plain (S1 : Comparable.S_plain) (S2 : Comparable.S_plain) = struct\n module T = struct\n type t = S1.t * S2.t\n\n type comparator_witness =\n (S1.comparator_witness, S2.comparator_witness) T2.comparator_witness\n\n let comparator = T2.comparator S1.comparator S2.comparator\n let sexp_of_t = comparator.sexp_of_t\n end\n\n include T\n include Comparable.Make_plain_using_comparator (T)\nend\n\nmodule Comparable (S1 : Comparable_sexpable) (S2 : Comparable_sexpable) = struct\n module T = struct\n include Sexpable (S1) (S2)\n\n let compare (s1, s2) (s1', s2') =\n match S1.compare s1 s1' with\n | 0 -> S2.compare s2 s2'\n | x -> x\n ;;\n end\n\n include T\n include Comparable.Make (T)\nend\n\nmodule Hasher (H1 : Hasher_sexpable) (H2 : Hasher_sexpable) = struct\n module T = struct\n type t = H1.t * H2.t [@@deriving compare, hash, sexp]\n end\n\n include T\n include Hashable.Make (T)\nend\n\nmodule Hasher_sexpable_of_hashable_sexpable (S : Hashable_sexpable) :\n Hasher_sexpable with type t = S.t = struct\n include S\n\n let hash_fold_t state t = hash_fold_int state (hash t)\nend\n\nmodule Hashable_t (S1 : Hashable_sexpable) (S2 : Hashable_sexpable) =\n Hasher\n (Hasher_sexpable_of_hashable_sexpable\n (S1))\n (Hasher_sexpable_of_hashable_sexpable (S2))\n\nmodule Hashable = Hashable_t\n","open! Import\nopen Std_internal\nopen Int.Replace_polymorphic_compare\n\nmodule Round = struct\n type t =\n | Toward_positive_infinity\n | Toward_negative_infinity\n [@@deriving compare, sexp_of]\nend\n\nlet module_name = \"Digit_string_helpers\"\nlet int63_two = Int63.of_int 2\nlet int63_ten = Int63.of_int 10\nlet int63_twenty = Int63.of_int 20\nlet int63_billion = Int63.of_int 1_000_000_000\nlet max_billions = Int63.( / ) Int63.max_value int63_billion\n\nlet rec digits_of_positive_int63 n =\n if Int63.( < ) n int63_ten\n then 1\n else Int.succ (digits_of_positive_int63 (Int63.( / ) n int63_ten))\n;;\n\nlet digits_of_int63_max_value = digits_of_positive_int63 Int63.max_value\n\nlet rec max_int63_with ~digits =\n match digits with\n | 1 -> Int63.of_int 9\n | 2 -> Int63.of_int 99\n | 3 -> Int63.of_int 999\n | 4 -> Int63.of_int 9_999\n | 5 -> Int63.of_int 99_999\n | 6 -> Int63.of_int 999_999\n | 7 -> Int63.of_int 9_999_999\n | 8 -> Int63.of_int 99_999_999\n | 9 -> Int63.of_int 999_999_999\n | _ ->\n if digits >= digits_of_int63_max_value\n then Int63.max_value\n else (\n let billions = Int63.succ (max_int63_with ~digits:(digits - 9)) in\n Int63.pred (Int63.( * ) int63_billion billions))\n;;\n\nmodule Unsafe = struct\n let unsafe_char_of_digit n = Char.unsafe_of_int (Char.to_int '0' + n)\n let digit_of_char char = Char.get_digit_exn char\n\n let write_1_digit_int bytes ~pos int =\n Bytes.unsafe_set bytes pos (unsafe_char_of_digit int)\n ;;\n\n let return_tens_and_write_ones bytes ~pos int =\n let tens = int / 10 in\n let ones = int - (tens * 10) in\n write_1_digit_int bytes ~pos ones;\n tens\n ;;\n\n let write_2_digit_int bytes ~pos int =\n let tens = return_tens_and_write_ones bytes ~pos:(pos + 1) int in\n write_1_digit_int bytes ~pos tens\n ;;\n\n let write_3_digit_int bytes ~pos int =\n let tens = return_tens_and_write_ones bytes ~pos:(pos + 2) int in\n write_2_digit_int bytes ~pos tens\n ;;\n\n let write_4_digit_int bytes ~pos int =\n let tens = return_tens_and_write_ones bytes ~pos:(pos + 3) int in\n write_3_digit_int bytes ~pos tens\n ;;\n\n let write_5_digit_int bytes ~pos int =\n let tens = return_tens_and_write_ones bytes ~pos:(pos + 4) int in\n write_4_digit_int bytes ~pos tens\n ;;\n\n let write_6_digit_int bytes ~pos int =\n let tens = return_tens_and_write_ones bytes ~pos:(pos + 5) int in\n write_5_digit_int bytes ~pos tens\n ;;\n\n let write_7_digit_int bytes ~pos int =\n let tens = return_tens_and_write_ones bytes ~pos:(pos + 6) int in\n write_6_digit_int bytes ~pos tens\n ;;\n\n let write_8_digit_int bytes ~pos int =\n let tens = return_tens_and_write_ones bytes ~pos:(pos + 7) int in\n write_7_digit_int bytes ~pos tens\n ;;\n\n let write_9_digit_int bytes ~pos int =\n let tens = return_tens_and_write_ones bytes ~pos:(pos + 8) int in\n write_8_digit_int bytes ~pos tens\n ;;\n\n let return_billions_and_write_remainder bytes ~pos int63 =\n let billions = Int63.( / ) int63 int63_billion in\n let remainder = Int63.( - ) int63 (Int63.( * ) billions int63_billion) in\n write_9_digit_int bytes ~pos (Int63.to_int_exn remainder);\n billions\n ;;\n\n let rec write_int63 bytes ~pos ~digits int63 =\n match digits with\n | 1 -> write_1_digit_int bytes ~pos (Int63.to_int_exn int63)\n | 2 -> write_2_digit_int bytes ~pos (Int63.to_int_exn int63)\n | 3 -> write_3_digit_int bytes ~pos (Int63.to_int_exn int63)\n | 4 -> write_4_digit_int bytes ~pos (Int63.to_int_exn int63)\n | 5 -> write_5_digit_int bytes ~pos (Int63.to_int_exn int63)\n | 6 -> write_6_digit_int bytes ~pos (Int63.to_int_exn int63)\n | 7 -> write_7_digit_int bytes ~pos (Int63.to_int_exn int63)\n | 8 -> write_8_digit_int bytes ~pos (Int63.to_int_exn int63)\n | 9 -> write_9_digit_int bytes ~pos (Int63.to_int_exn int63)\n | _ ->\n let digits_of_billions = digits - 9 in\n let billions =\n return_billions_and_write_remainder bytes ~pos:(pos + digits_of_billions) int63\n in\n write_int63 bytes ~pos ~digits:digits_of_billions billions\n ;;\n\n let read_1_digit_int string ~pos = digit_of_char (String.unsafe_get string pos)\n\n let read_2_digit_int string ~pos =\n (read_1_digit_int string ~pos * 10) + read_1_digit_int string ~pos:(pos + 1)\n ;;\n\n let read_3_digit_int string ~pos =\n (read_2_digit_int string ~pos * 10) + read_1_digit_int string ~pos:(pos + 2)\n ;;\n\n let read_4_digit_int string ~pos =\n (read_3_digit_int string ~pos * 10) + read_1_digit_int string ~pos:(pos + 3)\n ;;\n\n let read_5_digit_int string ~pos =\n (read_4_digit_int string ~pos * 10) + read_1_digit_int string ~pos:(pos + 4)\n ;;\n\n let read_6_digit_int string ~pos =\n (read_5_digit_int string ~pos * 10) + read_1_digit_int string ~pos:(pos + 5)\n ;;\n\n let read_7_digit_int string ~pos =\n (read_6_digit_int string ~pos * 10) + read_1_digit_int string ~pos:(pos + 6)\n ;;\n\n let read_8_digit_int string ~pos =\n (read_7_digit_int string ~pos * 10) + read_1_digit_int string ~pos:(pos + 7)\n ;;\n\n let read_9_digit_int string ~pos =\n (read_8_digit_int string ~pos * 10) + read_1_digit_int string ~pos:(pos + 8)\n ;;\n\n let raise_int63_overflow name =\n invalid_argf \"%s.%s: overflow reading int63\" module_name name ()\n ;;\n\n let rec read_int63 string ~pos ~digits =\n match digits with\n | 1 -> Int63.of_int (read_1_digit_int string ~pos)\n | 2 -> Int63.of_int (read_2_digit_int string ~pos)\n | 3 -> Int63.of_int (read_3_digit_int string ~pos)\n | 4 -> Int63.of_int (read_4_digit_int string ~pos)\n | 5 -> Int63.of_int (read_5_digit_int string ~pos)\n | 6 -> Int63.of_int (read_6_digit_int string ~pos)\n | 7 -> Int63.of_int (read_7_digit_int string ~pos)\n | 8 -> Int63.of_int (read_8_digit_int string ~pos)\n | 9 -> Int63.of_int (read_9_digit_int string ~pos)\n | _ ->\n let digits_of_billions = digits - 9 in\n let billions = read_int63 string ~pos ~digits:digits_of_billions in\n let remainder =\n Int63.of_int (read_9_digit_int string ~pos:(pos + digits_of_billions))\n in\n if Int63.( > ) billions max_billions then raise_int63_overflow \"read_int63\";\n let sum = Int63.( + ) (Int63.( * ) billions int63_billion) remainder in\n if Int63.( < ) sum Int63.zero then raise_int63_overflow \"read_int63\";\n sum\n ;;\n\n let divide_and_round_up ~numerator ~denominator =\n let open Int63.O in\n (numerator + denominator - Int63.one) /% denominator\n ;;\n\n let raise_invalid_decimal name =\n invalid_argf \"%s.%s: invalid decimal character\" module_name name ()\n ;;\n\n (* Reads the portion of string between [pos] and [pos+decimals-1], inclusive, and\n interperets it as a positive decimal part of a number, which we call [x].\n\n Let [i] and [r] be the integer part and remaining fractional part of\n [x * scale / divisor].\n\n If [r < round_at/divisor], returns [i].\n If [r = round_at/divisor], returns [i] or [i+1] based on [round_exact].\n If [r > round_at/divisor], returns [i+1].\n\n Assumes without checking that [scale] and [divisor] are both positive and\n less than [Int63.max_value / 10] (to avoid internal overflow during the algorithm\n when multiplying by 10), and that [round_at >= 0] and [round_at < divisor]. *)\n let read_int63_decimal_rounded\n string\n ~pos:start\n ~decimals\n ~scale\n ~divisor\n ~round_at\n ~round_exact\n ~allow_underscore\n =\n let open Int63.O in\n let until = Int.( + ) start decimals in\n (* The loop invariant is that each iteration, we strip off the next decimal digit and\n update [sum], [round_at], and [divisor] such that the desired result is:\n\n [ sum + round(remaining_digits_of_x_parsed_as_decimal * scale / divisor) ]\n where \"round\" rounds based on the new value of [round_at].\n *)\n let divisor = ref divisor in\n let round_at = ref round_at in\n let sum = ref Int63.zero in\n let pos = ref start in\n (* Stop if we run out of characters, or if further digits cannot increase our sum. *)\n while Int.( <> ) !pos until && !round_at < scale do\n (match String.unsafe_get string !pos with\n | '0' .. '9' as char ->\n let digit = Int63.of_int (digit_of_char char) in\n (* Every new decimal place implicitly scales our numerator by a factor of ten,\n so must also effectively scale our denominator.\n\n 0.abcdef * scale/divisor [round at round_at]\n = a.bcdef * scale/(divisor*10) [round at round_at*10]\n\n Then redefine divisor := divisor*10 and round_at := round_at*10, so we have:\n a.bcdef * scale/divisor [round at round_at] *)\n divisor := !divisor * int63_ten;\n round_at := !round_at * int63_ten;\n (* Next we work out the part of the sum based on our current digit:\n\n a.bcdef * scale/divisor [round at round_at]\n = a.bcdef * scale/divisor - round_at / divisor [round at 0]\n = (a*scale-round_at) / divisor + 0.bcdef * scale/divisor [round at 0]\n\n Decompose the first term into integer and remainder parts.\n Since we have already subtracted [round_at], we decompose based\n on the ceiling rather than the floor of the division,\n e.g. 5/3 would decompose as 2 + (-1)/3, rather than 1 + (2/3).\n\n = increment + remainder/divisor + 0.bcdef * scale/divisor [round at 0]\n = increment + 0.bcdef * scale/divisor [round at -remainder]\n *)\n let numerator = (digit * scale) - !round_at in\n let denominator = !divisor in\n let increment = divide_and_round_up ~numerator ~denominator in\n let remainder = numerator - (increment * denominator) in\n (* Now just accumulate the new increment and iterate on the remaining part:\n 0.bcdef * scale/divisor [round at -remainder].\n\n Since [remainder] is between [-(divisor-1)] and [0] inclusive, the new\n [round_at] will be within [0] and [divisor-1] inclusive. *)\n round_at := -remainder;\n sum := !sum + increment;\n (* This line prevents the divisor from growing without bound and overflowing. If\n this line actually changes the divisor, then the divisor is larger than the\n scale, so the sum will increase if and only if [parsed_remaining_digits *\n scale (> or >=) round_at], which doesn't depend on how much larger the\n divisor is. So this change is safe. *)\n divisor := Int63.min denominator scale\n | '_' when allow_underscore -> ()\n | _ -> raise_invalid_decimal \"read_int63_decimal\");\n pos := Int.succ !pos\n done;\n if !round_at = zero\n then (\n match round_exact with\n | Round.Toward_negative_infinity -> ()\n | Round.Toward_positive_infinity -> sum := !sum + Int63.one);\n !sum\n ;;\n\n let read_int63_decimal string ~pos ~decimals ~scale ~round_ties ~allow_underscore =\n read_int63_decimal_rounded\n string\n ~pos\n ~decimals\n ~scale:(Int63.( * ) scale int63_two)\n ~divisor:int63_two\n ~round_at:Int63.one\n ~round_exact:round_ties\n ~allow_underscore\n ;;\nend\n\nlet min_scale = Int63.one\nlet max_scale = Int63.( / ) Int63.max_value int63_twenty\n\nlet raise_negative_decimals name ~decimals =\n invalid_argf \"%s.%s: decimals=%d is negative\" module_name name decimals ()\n;;\n\nlet raise_non_positive_digits name ~digits =\n invalid_argf \"%s.%s: digits=%d is not a positive number\" module_name name digits ()\n;;\n\nlet raise_scale_out_of_bounds name ~scale =\n invalid_argf\n \"%s.%s: scale=%Ld out of range [%Ld, %Ld]\"\n module_name\n name\n (Int63.to_int64 scale)\n (Int63.to_int64 min_scale)\n (Int63.to_int64 max_scale)\n ()\n;;\n\nlet raise_pos_out_of_bounds name ~len ~pos ~digits =\n if pos < 0 || pos >= len\n then\n invalid_argf\n \"%s.%s: pos=%d out of range for string of length %d\"\n module_name\n name\n pos\n len\n ()\n else\n invalid_argf\n \"%s.%s: %d digits do not fit at pos %d in string of length %d\"\n module_name\n name\n digits\n pos\n len\n ()\n;;\n\nlet raise_int_out_of_bounds name ~max int =\n invalid_argf \"%s.%s: %d out of range [0, %d]\" module_name name int max ()\n;;\n\nlet raise_int63_out_of_bounds name ~max int63 =\n invalid_argf\n !\"%s.%s: %{Int63} out of range [0, %{Int63}]\"\n module_name\n name\n int63\n max\n ()\n;;\n\nlet check_decimals name ~decimals =\n if decimals < 0 then raise_negative_decimals name ~decimals\n;;\n\nlet check_digits name ~digits = if digits < 1 then raise_non_positive_digits name ~digits\n\nlet check_pos name ~len ~pos ~digits =\n if pos < 0 || pos + digits > len then raise_pos_out_of_bounds name ~len ~pos ~digits\n;;\n\nlet check_int name ~max int =\n if int < 0 || int > max then raise_int_out_of_bounds name ~max int\n;;\n\nlet check_int63 name ~max int63 =\n if Int63.( < ) int63 Int63.zero || Int63.( > ) int63 max\n then raise_int63_out_of_bounds name ~max int63\n;;\n\nlet check_scale name ~scale =\n if Int63.( < ) scale min_scale || Int63.( > ) scale max_scale\n then raise_scale_out_of_bounds name ~scale\n;;\n\nlet check_write name ~bytes ~pos ~digits ~max int =\n let len = Bytes.length bytes in\n check_pos name ~digits ~len ~pos;\n check_int name ~max int\n;;\n\nlet check_write63 name ~bytes ~pos ~digits int63 =\n check_digits name ~digits;\n let max = max_int63_with ~digits in\n let len = Bytes.length bytes in\n check_pos name ~digits ~len ~pos;\n check_int63 name ~max int63\n;;\n\nlet write_1_digit_int bytes ~pos int =\n check_write \"write_1_digit_int\" ~bytes ~pos ~digits:1 ~max:9 int;\n Unsafe.write_1_digit_int bytes ~pos int\n;;\n\nlet write_2_digit_int bytes ~pos int =\n check_write \"write_2_digit_int\" ~bytes ~pos ~digits:2 ~max:99 int;\n Unsafe.write_2_digit_int bytes ~pos int\n;;\n\nlet write_3_digit_int bytes ~pos int =\n check_write \"write_3_digit_int\" ~bytes ~pos ~digits:3 ~max:999 int;\n Unsafe.write_3_digit_int bytes ~pos int\n;;\n\nlet write_4_digit_int bytes ~pos int =\n check_write \"write_4_digit_int\" ~bytes ~pos ~digits:4 ~max:9_999 int;\n Unsafe.write_4_digit_int bytes ~pos int\n;;\n\nlet write_5_digit_int bytes ~pos int =\n check_write \"write_5_digit_int\" ~bytes ~pos ~digits:5 ~max:99_999 int;\n Unsafe.write_5_digit_int bytes ~pos int\n;;\n\nlet write_6_digit_int bytes ~pos int =\n check_write \"write_6_digit_int\" ~bytes ~pos ~digits:6 ~max:999_999 int;\n Unsafe.write_6_digit_int bytes ~pos int\n;;\n\nlet write_7_digit_int bytes ~pos int =\n check_write \"write_7_digit_int\" ~bytes ~pos ~digits:7 ~max:9_999_999 int;\n Unsafe.write_7_digit_int bytes ~pos int\n;;\n\nlet write_8_digit_int bytes ~pos int =\n check_write \"write_8_digit_int\" ~bytes ~pos ~digits:8 ~max:99_999_999 int;\n Unsafe.write_8_digit_int bytes ~pos int\n;;\n\nlet write_9_digit_int bytes ~pos int =\n check_write \"write_9_digit_int\" ~bytes ~pos ~digits:9 ~max:999_999_999 int;\n Unsafe.write_9_digit_int bytes ~pos int\n;;\n\nlet write_int63 bytes ~pos ~digits int63 =\n check_write63 \"write_int63\" ~bytes ~pos ~digits int63;\n Unsafe.write_int63 bytes ~pos ~digits int63\n;;\n\nlet check_read name ~string ~pos ~digits =\n let len = String.length string in\n check_pos name ~digits ~len ~pos\n;;\n\nlet check_read63 name ~string ~pos ~digits =\n check_digits name ~digits;\n let len = String.length string in\n check_pos name ~digits ~len ~pos\n;;\n\nlet check_read63_decimal name ~string ~pos ~decimals ~scale =\n let len = String.length string in\n check_decimals name ~decimals;\n check_scale name ~scale;\n check_pos name ~digits:decimals ~len ~pos\n;;\n\nlet read_1_digit_int string ~pos =\n check_read \"read_1_digit_int\" ~string ~pos ~digits:1;\n Unsafe.read_1_digit_int string ~pos\n;;\n\nlet read_2_digit_int string ~pos =\n check_read \"read_2_digit_int\" ~string ~pos ~digits:2;\n Unsafe.read_2_digit_int string ~pos\n;;\n\nlet read_3_digit_int string ~pos =\n check_read \"read_3_digit_int\" ~string ~pos ~digits:3;\n Unsafe.read_3_digit_int string ~pos\n;;\n\nlet read_4_digit_int string ~pos =\n check_read \"read_4_digit_int\" ~string ~pos ~digits:4;\n Unsafe.read_4_digit_int string ~pos\n;;\n\nlet read_5_digit_int string ~pos =\n check_read \"read_5_digit_int\" ~string ~pos ~digits:5;\n Unsafe.read_5_digit_int string ~pos\n;;\n\nlet read_6_digit_int string ~pos =\n check_read \"read_6_digit_int\" ~string ~pos ~digits:6;\n Unsafe.read_6_digit_int string ~pos\n;;\n\nlet read_7_digit_int string ~pos =\n check_read \"read_7_digit_int\" ~string ~pos ~digits:7;\n Unsafe.read_7_digit_int string ~pos\n;;\n\nlet read_8_digit_int string ~pos =\n check_read \"read_8_digit_int\" ~string ~pos ~digits:8;\n Unsafe.read_8_digit_int string ~pos\n;;\n\nlet read_9_digit_int string ~pos =\n check_read \"read_9_digit_int\" ~string ~pos ~digits:9;\n Unsafe.read_9_digit_int string ~pos\n;;\n\nlet read_int63 string ~pos ~digits =\n check_read63 \"read_int63\" ~string ~pos ~digits;\n Unsafe.read_int63 string ~pos ~digits\n;;\n\nlet read_int63_decimal string ~pos ~decimals ~scale ~round_ties ~allow_underscore =\n check_read63_decimal \"read_int63_decimal\" ~string ~pos ~decimals ~scale;\n Unsafe.read_int63_decimal string ~pos ~decimals ~scale ~round_ties ~allow_underscore\n;;\n","open! Import\n\nmodule Stable = struct\n module V1 = struct\n type t =\n | Jan\n | Feb\n | Mar\n | Apr\n | May\n | Jun\n | Jul\n | Aug\n | Sep\n | Oct\n | Nov\n | Dec\n [@@deriving sexp, compare, hash, variants, equal]\n\n let failwithf = Printf.failwithf\n\n let of_int_exn i : t =\n match i with\n | 1 -> Jan\n | 2 -> Feb\n | 3 -> Mar\n | 4 -> Apr\n | 5 -> May\n | 6 -> Jun\n | 7 -> Jul\n | 8 -> Aug\n | 9 -> Sep\n | 10 -> Oct\n | 11 -> Nov\n | 12 -> Dec\n | _ -> failwithf \"Month.of_int_exn %d\" i ()\n ;;\n\n let of_int i =\n try Some (of_int_exn i) with\n | _ -> None\n ;;\n\n let to_int (t : t) =\n match t with\n | Jan -> 1\n | Feb -> 2\n | Mar -> 3\n | Apr -> 4\n | May -> 5\n | Jun -> 6\n | Jul -> 7\n | Aug -> 8\n | Sep -> 9\n | Oct -> 10\n | Nov -> 11\n | Dec -> 12\n ;;\n\n include Binable.Stable.Of_binable.V1 [@alert \"-legacy\"]\n (Int)\n (struct\n type nonrec t = t\n\n let to_binable t = to_int t - 1\n let of_binable i = of_int_exn (i + 1)\n end)\n end\nend\n\nlet num_months = 12\n\nmodule T = struct\n include Stable.V1\n\n let all = [ Jan; Feb; Mar; Apr; May; Jun; Jul; Aug; Sep; Oct; Nov; Dec ]\n let hash = to_int\nend\n\ninclude T\n\ninclude (\n Hashable.Make_binable (struct\n include T\n end) :\n Hashable.S_binable with type t := t)\n\ninclude Comparable.Make_binable (struct\n include T\n\n (* In 108.06a and earlier, months in sexps of Maps and Sets were raw ints. From 108.07\n through 109.13, the output format remained raw as before, but both the raw and\n pretty format were accepted as input. From 109.14 on, the output format was\n changed from raw to pretty, while continuing to accept both formats. Once we believe\n most programs are beyond 109.14, we will switch the input format to no longer accept\n raw. *)\n let t_of_sexp sexp =\n match Option.try_with (fun () -> Int.t_of_sexp sexp) with\n | Some i -> of_int_exn (i + 1)\n | None -> T.t_of_sexp sexp\n ;;\n end)\n\n(* Replace the overriden sexp converters from [Comparable.Make_binable] with the ordinary\n symbolic converters. *)\nlet sexp_of_t = T.sexp_of_t\nlet t_of_sexp = T.t_of_sexp\nlet shift t i = of_int_exn (1 + Int.( % ) (to_int t - 1 + i) num_months)\n\nlet all_strings =\n lazy\n (Array.of_list (List.map all ~f:(fun variant -> Sexp.to_string (sexp_of_t variant))))\n;;\n\nlet to_string (t : t) =\n let all_strings = Lazy.force all_strings in\n all_strings.(to_int t - 1)\n;;\n\nlet of_string =\n let table =\n lazy\n (let module T = String.Table in\n let table = T.create ~size:num_months () in\n Array.iteri (Lazy.force all_strings) ~f:(fun i s ->\n let t = of_int_exn (i + 1) in\n Hashtbl.set table ~key:s ~data:t;\n Hashtbl.set table ~key:(String.lowercase s) ~data:t;\n Hashtbl.set table ~key:(String.uppercase s) ~data:t);\n table)\n in\n fun str ->\n match Hashtbl.find (Lazy.force table) str with\n | Some x -> x\n | None -> failwithf \"Invalid month: %s\" str ()\n;;\n\nmodule Export = struct\n type month = t =\n | Jan\n | Feb\n | Mar\n | Apr\n | May\n | Jun\n | Jul\n | Aug\n | Sep\n | Oct\n | Nov\n | Dec\nend\n","open! Import\nopen Std_internal\nopen Digit_string_helpers\n\nlet is_leap_year ~year = (year mod 4 = 0 && not (year mod 100 = 0)) || year mod 400 = 0\n\n(* Create a local private date type to ensure that all dates are created via\n Date.create_exn.\n*)\nmodule Stable = struct\n module V1 = struct\n module Without_comparable = struct\n module T : sig\n type t [@@immediate] [@@deriving bin_io, hash, typerep]\n\n val create_exn : y:int -> m:Month.Stable.V1.t -> d:int -> t\n val year : t -> int\n val month : t -> Month.Stable.V1.t\n val day : t -> int\n val days_in_month : year:int -> month:Month.t -> int\n val to_int : t -> int\n val of_int_exn : int -> t\n val invalid_value__for_internal_use_only : t\n end = struct\n (* We used to store dates like this:\n type t = { y: int; m: Month.Stable.V1.t; d: int; }\n In the below we make sure that the bin_io representation is\n identical (and the stable unit tests check this)\n\n In memory we use the following much more compact representation:\n 2 bytes year\n 1 byte month\n 1 byte day\n\n all packed into a single immediate int (so from 4 words down to 1).\n *)\n type t = int\n [@@deriving\n hash, typerep, bin_shape ~basetype:\"899ee3e0-490a-11e6-a10a-a3734f733566\"]\n\n let create0 ~year ~month ~day =\n (* create_exn's validation make sure that each value fits *)\n (year lsl 16) lor (Month.to_int month lsl 8) lor day\n ;;\n\n let year t = t lsr 16\n let month t = Month.of_int_exn ((t lsr 8) land 0xff)\n let day t = t land 0xff\n\n let days_in_month ~year ~month =\n match (month : Month.t) with\n | Jan | Mar | May | Jul | Aug | Oct | Dec -> 31\n | Apr | Jun | Sep | Nov -> 30\n | Feb -> if is_leap_year ~year then 29 else 28\n ;;\n\n let create_exn ~y:year ~m:month ~d:day =\n (* year, month, and day need to be passed as parameters to avoid allocating\n a closure (see unit test below) *)\n let invalid ~year ~month ~day msg =\n invalid_argf\n !\"Date.create_exn ~y:%d ~m:%{Month} ~d:%d error: %s\"\n year\n month\n day\n msg\n ()\n in\n if year < 0 || year > 9999\n then invalid ~year ~month ~day \"year outside of [0..9999]\";\n if day <= 0 then invalid ~year ~month ~day \"day <= 0\";\n let days_in_month = days_in_month ~year ~month in\n if day > days_in_month\n then invalid ~year ~month ~day (sprintf \"%d day month violation\" days_in_month);\n create0 ~year ~month ~day\n ;;\n\n (* We don't use Make_binable here, because that would go via an immediate\n tuple or record. That is exactly the 32 bytes we worked so hard above to\n get rid of. We also don't want to just bin_io the integer directly\n because that would mean a new bin_io format. *)\n\n let bin_read_t buf ~pos_ref =\n let year = Int.bin_read_t buf ~pos_ref in\n let month = Month.Stable.V1.bin_read_t buf ~pos_ref in\n let day = Int.bin_read_t buf ~pos_ref in\n create0 ~year ~month ~day\n ;;\n\n let __bin_read_t__ _buf ~pos_ref =\n (* __bin_read_t is only needed for variants *)\n Bin_prot.Common.raise_variant_wrong_type \"Date.t\" !pos_ref\n ;;\n\n let bin_reader_t =\n { Bin_prot.Type_class.read = bin_read_t; vtag_read = __bin_read_t__ }\n ;;\n\n let bin_size_t t =\n Int.bin_size_t (year t) + Month.bin_size_t (month t) + Int.bin_size_t (day t)\n ;;\n\n let bin_write_t buf ~pos t =\n let pos = Int.bin_write_t buf ~pos (year t) in\n let pos = Month.bin_write_t buf ~pos (month t) in\n Int.bin_write_t buf ~pos (day t)\n ;;\n\n let bin_writer_t = { Bin_prot.Type_class.size = bin_size_t; write = bin_write_t }\n\n let bin_t =\n { Bin_prot.Type_class.reader = bin_reader_t\n ; writer = bin_writer_t\n ; shape = bin_shape_t\n }\n ;;\n\n let to_int t = t\n let of_int_exn n = create_exn ~y:(year n) ~m:(month n) ~d:(day n)\n let invalid_value__for_internal_use_only = 0\n\n let%test \"invalid value\" =\n Exn.does_raise (fun () ->\n (of_int_exn invalid_value__for_internal_use_only : t))\n ;;\n end\n\n include T\n\n\n (** YYYY-MM-DD *)\n let to_string_iso8601_extended t =\n let buf = Bytes.create 10 in\n write_4_digit_int buf ~pos:0 (year t);\n Bytes.set buf 4 '-';\n write_2_digit_int buf ~pos:5 (Month.to_int (month t));\n Bytes.set buf 7 '-';\n write_2_digit_int buf ~pos:8 (day t);\n Bytes.unsafe_to_string ~no_mutation_while_string_reachable:buf\n ;;\n\n let to_string = to_string_iso8601_extended\n\n (** YYYYMMDD *)\n let to_string_iso8601_basic t =\n let buf = Bytes.create 8 in\n write_4_digit_int buf ~pos:0 (year t);\n write_2_digit_int buf ~pos:4 (Month.to_int (month t));\n write_2_digit_int buf ~pos:6 (day t);\n Bytes.unsafe_to_string ~no_mutation_while_string_reachable:buf\n ;;\n\n (** MM/DD/YYYY *)\n let to_string_american t =\n let buf = Bytes.create 10 in\n write_2_digit_int buf ~pos:0 (Month.to_int (month t));\n Bytes.set buf 2 '/';\n write_2_digit_int buf ~pos:3 (day t);\n Bytes.set buf 5 '/';\n write_4_digit_int buf ~pos:6 (year t);\n Bytes.unsafe_to_string ~no_mutation_while_string_reachable:buf\n ;;\n\n let parse_year4 str pos = read_4_digit_int str ~pos\n let parse_month str pos = Month.of_int_exn (read_2_digit_int str ~pos)\n let parse_day str pos = read_2_digit_int str ~pos\n\n (** YYYYMMDD *)\n let of_string_iso8601_basic str ~pos =\n if pos + 8 > String.length str\n then invalid_arg \"Date.of_string_iso8601_basic: pos + 8 > string length\";\n create_exn\n ~y:(parse_year4 str pos)\n ~m:(parse_month str (pos + 4))\n ~d:(parse_day str (pos + 6))\n ;;\n\n (* WARNING: if you are going to change this function in a material way, be sure you\n understand the implications of working in Stable *)\n let of_string s =\n let invalid () = failwith (\"invalid date: \" ^ s) in\n let ensure b = if not b then invalid () in\n let month_num ~year ~month ~day =\n create_exn\n ~y:(parse_year4 s year)\n ~m:(parse_month s month)\n ~d:(parse_day s day)\n in\n let month_abrv ~year ~month ~day =\n create_exn\n ~y:(parse_year4 s year)\n ~m:(Month.of_string (String.sub s ~pos:month ~len:3))\n ~d:(parse_day s day)\n in\n if String.contains s '/'\n then (\n let y, m, d =\n match String.split s ~on:'/' with\n | [ a; b; c ] ->\n if String.length a = 4 then a, b, c (* y/m/d *) else c, a, b (* m/d/y *)\n | _ -> invalid ()\n in\n let year = Int.of_string y in\n let year =\n if year >= 100 then year else if year < 75 then 2000 + year else 1900 + year\n in\n let month = Month.of_int_exn (Int.of_string m) in\n let day = Int.of_string d in\n create_exn ~y:year ~m:month ~d:day)\n else if String.contains s '-'\n then (\n (* yyyy-mm-dd *)\n ensure (String.length s = 10 && Char.( = ) s.[4] '-' && Char.( = ) s.[7] '-');\n month_num ~year:0 ~month:5 ~day:8)\n else if String.contains s ' '\n then\n if String.length s = 11 && Char.( = ) s.[2] ' ' && Char.( = ) s.[6] ' '\n then (* DD MMM YYYY *)\n month_abrv ~day:0 ~month:3 ~year:7\n else (\n (* YYYY MMM DD *)\n ensure (String.length s = 11 && Char.( = ) s.[4] ' ' && Char.( = ) s.[8] ' ');\n month_abrv ~day:9 ~month:5 ~year:0)\n else if String.length s = 9\n then (* DDMMMYYYY *)\n month_abrv ~day:0 ~month:2 ~year:5\n else if String.length s = 8\n then (* assume YYYYMMDD *)\n month_num ~year:0 ~month:4 ~day:6\n else invalid ()\n ;;\n\n let of_string s =\n try of_string s with\n | exn -> invalid_argf \"Date.of_string (%s): %s\" s (Exn.to_string exn) ()\n ;;\n\n module Sexpable = struct\n module Old_date = struct\n type t =\n { y : int\n ; m : int\n ; d : int\n }\n [@@deriving sexp]\n\n let to_date t = T.create_exn ~y:t.y ~m:(Month.of_int_exn t.m) ~d:t.d\n end\n\n let t_of_sexp = function\n | Sexp.Atom s -> of_string s\n | Sexp.List _ as sexp -> Old_date.to_date (Old_date.t_of_sexp sexp)\n ;;\n\n let t_of_sexp s =\n try t_of_sexp s with\n | Of_sexp_error _ as exn -> raise exn\n | Invalid_argument a -> of_sexp_error a s\n ;;\n\n let sexp_of_t t = Sexp.Atom (to_string t)\n end\n\n include Sexpable\n\n let compare t1 t2 =\n let n = Int.compare (year t1) (year t2) in\n if n <> 0\n then n\n else (\n let n = Month.compare (month t1) (month t2) in\n if n <> 0 then n else Int.compare (day t1) (day t2))\n ;;\n\n include (val Comparator.Stable.V1.make ~compare ~sexp_of_t)\n end\n\n include Without_comparable\n include Comparable.Stable.V1.Make (Without_comparable)\n end\n\n module Option = struct\n module V1 = struct\n type t = int\n [@@deriving\n bin_io\n , bin_shape ~basetype:\"826a3e79-3321-451a-9707-ed6c03b84e2f\"\n , compare\n , hash\n , typerep]\n\n let none = V1.(to_int invalid_value__for_internal_use_only)\n let is_none t = t = none\n let is_some t = not (is_none t)\n let some_is_representable _ = true\n let some t = V1.to_int t\n let unchecked_value = V1.of_int_exn\n let to_option t = if is_some t then Some (unchecked_value t) else None\n\n let of_option opt =\n match opt with\n | None -> none\n | Some v -> some v\n ;;\n\n let value_exn t =\n if is_some t\n then unchecked_value t\n else raise_s [%message [%here] \"Date.Option.value_exn none\"]\n ;;\n\n let value t ~default = if is_some t then unchecked_value t else default\n let sexp_of_t t = to_option t |> Option.sexp_of_t V1.sexp_of_t\n let t_of_sexp sexp = (Option.t_of_sexp V1.t_of_sexp) sexp |> of_option\n end\n end\nend\n\nmodule Without_comparable = Stable.V1.Without_comparable\ninclude Without_comparable\nmodule C = Comparable.Make_binable_using_comparator (Without_comparable)\ninclude C\n\nmodule O = struct\n include (C : Comparable.Infix with type t := t)\nend\n\ninclude (\n Hashable.Make_binable (struct\n include T\n include Sexpable\n include Binable\n\n let compare (a : t) (b : t) = compare a b\n end) :\n Hashable.S_binable with type t := t)\n\ninclude Pretty_printer.Register (struct\n type nonrec t = t\n\n let module_name = \"Core_kernel.Date\"\n let to_string = to_string\n end)\n\nlet unix_epoch = create_exn ~y:1970 ~m:Jan ~d:1\n\n(* The Days module is used for calculations that involve adding or removing a known number\n of days from a date. Internally the date is translated to a day number, the days are\n added, and the new date is returned. Those interested in the math can read:\n\n http://alcor.concordia.ca/~gpkatch/gdate-method.html\n\n note: unit tests are in lib_test/time_test.ml\n*)\nmodule Days : sig\n type date = t\n type t [@@immediate]\n\n val of_date : date -> t\n val to_date : t -> date\n val diff : t -> t -> int\n val add_days : t -> int -> t\n val unix_epoch : t\nend\nwith type date := t = struct\n open Int\n\n type t = int\n\n let of_year y = (365 * y) + (y / 4) - (y / 100) + (y / 400)\n\n let of_date date =\n let m = (Month.to_int (month date) + 9) % 12 in\n let y = year date - (m / 10) in\n of_year y + (((m * 306) + 5) / 10) + (day date - 1)\n ;;\n\n let c_10_000 = Int63.of_int 10_000\n let c_14_780 = Int63.of_int 14_780\n let c_3_652_425 = Int63.of_int 3_652_425\n\n let to_date days =\n let y =\n let open Int63 in\n to_int_exn (((c_10_000 * of_int days) + c_14_780) / c_3_652_425)\n in\n let ddd = days - of_year y in\n let y, ddd =\n if ddd < 0\n then (\n let y = y - 1 in\n y, days - of_year y)\n else y, ddd\n in\n let mi = ((100 * ddd) + 52) / 3_060 in\n let y = y + ((mi + 2) / 12) in\n let m = ((mi + 2) % 12) + 1 in\n let d = ddd - (((mi * 306) + 5) / 10) + 1 in\n create_exn ~y ~m:(Month.of_int_exn m) ~d\n ;;\n\n let unix_epoch = of_date unix_epoch\n let add_days t days = t + days\n let diff t1 t2 = t1 - t2\nend\n\nlet add_days t days = Days.to_date (Days.add_days (Days.of_date t) days)\nlet diff t1 t2 = Days.diff (Days.of_date t1) (Days.of_date t2)\n\nlet add_months t n =\n let total_months = Month.to_int (month t) + n in\n let y = year t + (total_months /% 12) in\n let m = total_months % 12 in\n (* correct for december *)\n let y, m = if Int.( = ) m 0 then y - 1, m + 12 else y, m in\n let m = Month.of_int_exn m in\n (* handle invalid dates for months with fewer number of days *)\n let rec try_create d =\n try create_exn ~y ~m ~d with\n | _exn ->\n assert (Int.( >= ) d 1);\n try_create (d - 1)\n in\n try_create (day t)\n;;\n\nlet add_years t n = add_months t (n * 12)\n\n(* http://en.wikipedia.org/wiki/Determination_of_the_day_of_the_week#Purely_mathematical_methods\n\n note: unit tests in lib_test/time_test.ml\n*)\nlet day_of_week =\n let table = [| 0; 3; 2; 5; 0; 3; 5; 1; 4; 6; 2; 4 |] in\n fun t ->\n let m = Month.to_int (month t) in\n let y = if Int.( < ) m 3 then year t - 1 else year t in\n Day_of_week.of_int_exn\n ((y + (y / 4) - (y / 100) + (y / 400) + table.(m - 1) + day t) % 7)\n;;\n\n(* http://en.wikipedia.org/wiki/Ordinal_date *)\nlet non_leap_year_table = [| 0; 31; 59; 90; 120; 151; 181; 212; 243; 273; 304; 334 |]\nlet leap_year_table = [| 0; 31; 60; 91; 121; 152; 182; 213; 244; 274; 305; 335 |]\n\nlet ordinal_date t =\n let table =\n if is_leap_year ~year:(year t) then leap_year_table else non_leap_year_table\n in\n let offset = table.(Month.to_int (month t) - 1) in\n day t + offset\n;;\n\nlet last_week_of_year y =\n let first_of_year = create_exn ~y ~m:Jan ~d:1 in\n let is t day = Day_of_week.equal (day_of_week t) day in\n if is first_of_year Thu || (is_leap_year ~year:y && is first_of_year Wed)\n then 53\n else 52\n;;\n\n(* See http://en.wikipedia.org/wiki/ISO_week_date or ISO 8601 for the details of this\n algorithm.\n\n Uses a [~f] argument to avoid allocating a tuple when called by [week_number].\n*)\nlet call_with_week_and_year t ~f =\n let ordinal = ordinal_date t in\n let weekday = Day_of_week.iso_8601_weekday_number (day_of_week t) in\n (* [ordinal - weekday + 4] is the ordinal of this week's Thursday, then (n + 6) / 7 is\n division by 7 rounding up *)\n let week = (ordinal - weekday + 10) / 7 in\n let year = year t in\n if Int.( < ) week 1\n then f ~week:(last_week_of_year (year - 1)) ~year:(year - 1)\n else if Int.( > ) week (last_week_of_year year)\n then f ~week:1 ~year:(year + 1)\n else f ~week ~year\n;;\n\nlet week_number_and_year t = call_with_week_and_year t ~f:(fun ~week ~year -> week, year)\nlet week_number t = call_with_week_and_year t ~f:(fun ~week ~year:_ -> week)\nlet is_weekend t = Day_of_week.is_sun_or_sat (day_of_week t)\nlet is_weekday t = not (is_weekend t)\nlet is_business_day t ~is_holiday = is_weekday t && not (is_holiday t)\n\nlet rec diff_weekend_days t1 t2 =\n if t1 < t2\n then -diff_weekend_days t2 t1\n else (\n (* Basic date diff *)\n let diff = diff t1 t2 in\n (* Compute the number of Saturday -> Sunday crossings *)\n let d1 = day_of_week t1 in\n let d2 = day_of_week t2 in\n let num_satsun_crossings =\n if Int.( < ) (Day_of_week.to_int d1) (Day_of_week.to_int d2)\n then 1 + (diff / 7)\n else diff / 7\n in\n (num_satsun_crossings * 2)\n + (if Day_of_week.( = ) d2 Day_of_week.Sun then 1 else 0)\n + if Day_of_week.( = ) d1 Day_of_week.Sun then -1 else 0)\n;;\n\nlet diff_weekdays t1 t2 = diff t1 t2 - diff_weekend_days t1 t2\n\nlet add_days_skipping t ~skip n =\n let step = if Int.( >= ) n 0 then 1 else -1 in\n let rec loop t k =\n let t_next = add_days t step in\n if skip t then loop t_next k else if Int.( = ) k 0 then t else loop t_next (k - 1)\n in\n loop t (abs n)\n;;\n\nlet rec first_day_satisfying t ~step ~condition =\n if condition t then t else first_day_satisfying (add_days t step) ~step ~condition\n;;\n\nlet next_day_satisfying t ~step ~condition =\n let next_day = add_days t step in\n first_day_satisfying next_day ~step ~condition\n;;\n\nlet following_weekday t = next_day_satisfying t ~step:1 ~condition:is_weekday\nlet previous_weekday t = next_day_satisfying t ~step:(-1) ~condition:is_weekday\nlet round_forward_to_weekday t = first_day_satisfying t ~step:1 ~condition:is_weekday\nlet round_backward_to_weekday t = first_day_satisfying t ~step:(-1) ~condition:is_weekday\n\nlet round_forward_to_business_day t ~is_holiday =\n first_day_satisfying t ~step:1 ~condition:(is_business_day ~is_holiday)\n;;\n\nlet round_backward_to_business_day t ~is_holiday =\n first_day_satisfying t ~step:(-1) ~condition:(is_business_day ~is_holiday)\n;;\n\nlet add_weekdays t n = add_days_skipping t ~skip:is_weekend n\nlet add_weekdays_rounding_in_direction_of_step = add_weekdays\n\nlet add_weekdays_rounding_forward t n =\n add_days_skipping (round_forward_to_weekday t) ~skip:is_weekend n\n;;\n\nlet add_weekdays_rounding_backward t n =\n add_days_skipping (round_backward_to_weekday t) ~skip:is_weekend n\n;;\n\nlet add_business_days t ~is_holiday n =\n add_days_skipping t n ~skip:(fun d -> is_weekend d || is_holiday d)\n;;\n\nlet add_business_days_rounding_in_direction_of_step = add_business_days\n\nlet add_business_days_rounding_forward t ~is_holiday n =\n add_days_skipping (round_forward_to_business_day ~is_holiday t) n ~skip:(fun d ->\n not (is_business_day ~is_holiday d))\n;;\n\nlet add_business_days_rounding_backward t ~is_holiday n =\n add_days_skipping (round_backward_to_business_day ~is_holiday t) n ~skip:(fun d ->\n not (is_business_day ~is_holiday d))\n;;\n\nlet dates_between ~min:t1 ~max:t2 =\n let rec loop t l = if t < t1 then l else loop (add_days t (-1)) (t :: l) in\n loop t2 []\n;;\n\nlet weekdays_between ~min ~max =\n let all_dates = dates_between ~min ~max in\n Option.value_map (List.hd all_dates) ~default:[] ~f:(fun first_date ->\n (* to avoid a system call on every date, we just get the weekday for the first\n date and use it to get all the other weekdays *)\n let first_weekday = day_of_week first_date in\n let date_and_weekdays =\n List.mapi all_dates ~f:(fun i date -> date, Day_of_week.shift first_weekday i)\n in\n List.filter_map date_and_weekdays ~f:(fun (date, weekday) ->\n if Day_of_week.is_sun_or_sat weekday then None else Some date))\n;;\n\nlet business_dates_between ~min ~max ~is_holiday =\n weekdays_between ~min ~max |> List.filter ~f:(fun d -> not (is_holiday d))\n;;\n\nlet first_strictly_after t ~on:dow =\n let dow = Day_of_week.to_int dow in\n let tplus1 = add_days t 1 in\n let cur = Day_of_week.to_int (day_of_week tplus1) in\n let diff = (dow + 7 - cur) mod 7 in\n add_days tplus1 diff\n;;\n\nmodule For_quickcheck = struct\n open Quickcheck\n\n let gen_uniform_incl d1 d2 =\n if d1 > d2\n then\n raise_s\n [%message\n \"Date.gen_uniform_incl: bounds are crossed\"\n ~lower_bound:(d1 : t)\n ~upper_bound:(d2 : t)];\n Generator.map (Int.gen_uniform_incl 0 (diff d2 d1)) ~f:(fun days -> add_days d1 days)\n ;;\n\n let gen_incl d1 d2 =\n Generator.weighted_union\n [ 1., Generator.return d1; 1., Generator.return d2; 18., gen_uniform_incl d1 d2 ]\n ;;\n\n let quickcheck_generator = gen_incl (of_string \"1900-01-01\") (of_string \"2100-01-01\")\n let quickcheck_observer = Observer.create (fun t ~size:_ ~hash -> hash_fold_t hash t)\n let quickcheck_shrinker = Shrinker.empty ()\nend\n\nlet quickcheck_generator = For_quickcheck.quickcheck_generator\nlet gen_incl = For_quickcheck.gen_incl\nlet gen_uniform_incl = For_quickcheck.gen_uniform_incl\nlet quickcheck_observer = For_quickcheck.quickcheck_observer\nlet quickcheck_shrinker = For_quickcheck.quickcheck_shrinker\n\nmodule Private = struct\n let leap_year_table = leap_year_table\n let non_leap_year_table = non_leap_year_table\n let ordinal_date = ordinal_date\nend\n\nmodule Option = struct\n module Stable = Stable.Option\n include Stable.V1\n\n module Optional_syntax = struct\n module Optional_syntax = struct\n let is_none = is_none\n let unsafe_value = unchecked_value\n end\n end\n\n let quickcheck_generator =\n Quickcheck.Generator.map\n (Option.quickcheck_generator quickcheck_generator)\n ~f:of_option\n ;;\n\n let quickcheck_shrinker =\n Quickcheck.Shrinker.map\n (Option.quickcheck_shrinker quickcheck_shrinker)\n ~f:of_option\n ~f_inverse:to_option\n ;;\n\n let quickcheck_observer =\n Quickcheck.Observer.of_hash\n (module struct\n type nonrec t = t [@@deriving hash]\n end)\n ;;\n\n include Comparable.Make_plain (struct\n type nonrec t = t [@@deriving compare, sexp_of]\n end)\nend\n","open! Import\nopen Std_internal\n\nmodule Stable = struct\n module V1 = struct\n type t = (float[@quickcheck.generator Float.gen_finite])\n [@@deriving compare, hash, quickcheck, typerep]\n\n let of_mult f = f\n let to_mult t = t\n let of_percentage f = f /. 100.\n let to_percentage t = t *. 100.\n let of_bp f = f /. 10_000.\n let to_bp t = t *. 10_000.\n let of_bp_int i = of_bp (Float.of_int i)\n let to_bp_int t = Float.to_int (to_bp t)\n\n let round_significant p ~significant_digits =\n Float.round_significant p ~significant_digits\n ;;\n\n let round_decimal_mult p ~decimal_digits = Float.round_decimal p ~decimal_digits\n\n let round_decimal_percentage p ~decimal_digits =\n Float.round_decimal (p *. 100.) ~decimal_digits /. 100.\n ;;\n\n let round_decimal_bp p ~decimal_digits =\n Float.round_decimal (p *. 10000.) ~decimal_digits /. 10000.\n ;;\n\n module Format = struct\n type t =\n | Exponent of int\n | Exponent_E of int\n | Decimal of int\n | Ocaml\n | Compact of int\n | Compact_E of int\n | Hex of int\n | Hex_E of int\n [@@deriving sexp_of]\n\n let exponent ~precision = Exponent precision\n let exponent_E ~precision = Exponent_E precision\n let decimal ~precision = Decimal precision\n let ocaml = Ocaml\n let compact ~precision = Compact precision\n let compact_E ~precision = Compact_E precision\n let hex ~precision = Hex precision\n let hex_E ~precision = Hex_E precision\n\n let format_float t =\n match t with\n | Exponent precision -> sprintf \"%.*e\" precision\n | Exponent_E precision -> sprintf \"%.*E\" precision\n | Decimal precision -> sprintf \"%.*f\" precision\n | Ocaml -> sprintf \"%F\"\n | Compact precision -> sprintf \"%.*g\" precision\n | Compact_E precision -> sprintf \"%.*G\" precision\n | Hex precision -> sprintf \"%.*h\" precision\n | Hex_E precision -> sprintf \"%.*H\" precision\n ;;\n end\n\n let format x format =\n let x_abs = Float.abs x in\n let string float = Format.format_float format float in\n if Float.( = ) x_abs 0.\n then \"0x\"\n else if Float.( >= ) x_abs 1.\n then string (x *. 1.) ^ \"x\"\n else if Float.( >= ) x_abs 0.01\n then string (x *. 100.) ^ \"%\"\n else string (x *. 10_000.) ^ \"bp\"\n ;;\n\n module Stringable = struct\n type t = float\n\n (* WARNING - PLEASE READ BEFORE EDITING THESE FUNCTIONS:\n\n The string converters in Stable.V1 should never change. If you are changing the\n semantics of anything that affects the sexp or bin-io representation of values of\n this type (this includes to_string and of_string) make a Stable.V2 and make your\n changes there. Thanks! *)\n let to_string x =\n let x_abs = Float.abs x in\n let string float = sprintf \"%.6G\" float in\n if Float.( = ) x_abs 0.\n then \"0x\"\n else if Float.( >= ) x_abs 1.\n then string (x *. 1.) ^ \"x\"\n else if Float.( >= ) x_abs 0.01\n then string (x *. 100.) ^ \"%\"\n else string (x *. 10_000.) ^ \"bp\"\n ;;\n\n let really_of_string str float_of_string =\n match String.chop_suffix str ~suffix:\"x\" with\n | Some str -> float_of_string str\n | None ->\n (match String.chop_suffix str ~suffix:\"%\" with\n | Some str -> float_of_string str *. 0.01\n | None ->\n (match String.chop_suffix str ~suffix:\"bp\" with\n | Some str -> of_bp (float_of_string str)\n | None -> failwithf \"Percent.of_string: must end in x, %%, or bp: %s\" str ()))\n ;;\n\n let of_string str =\n let float str = Float_with_finite_only_serialization.t_of_sexp (Sexp.Atom str) in\n really_of_string str float\n ;;\n\n let of_string_allow_nan_and_inf str = really_of_string str Float.of_string\n end\n\n include (\n Stringable :\n sig\n type t\n\n val of_string : string -> t\n val to_string : t -> string\n end\n with type t := t)\n\n include (Sexpable.Stable.Of_stringable.V1 (Stringable) : Sexpable.S with type t := t)\n include (Float : Binable with type t := t)\n\n include Comparable.Make_binable (struct\n type nonrec t = t [@@deriving compare, sexp_of, bin_io]\n\n (* Previous versions rendered comparable-based containers using float\n serialization rather than percent serialization, so when reading\n comparable-based containers in we accept either serialization. *)\n let t_of_sexp sexp =\n match Float.t_of_sexp sexp with\n | float -> float\n | exception _ -> t_of_sexp sexp\n ;;\n end)\n end\n\n module Option = struct\n module V1 = struct\n type t = V1.t [@@deriving bin_io, compare, hash, typerep]\n\n let none = Float.nan\n let is_none t = Float.is_nan t\n let is_some t = not (is_none t)\n let some_is_representable = is_some\n let some = Fn.id\n let unchecked_value = Fn.id\n let to_option t = if is_some t then Some (unchecked_value t) else None\n\n let of_option opt =\n match opt with\n | None -> none\n | Some v -> some v\n ;;\n\n let value_exn t =\n if is_some t\n then unchecked_value t\n else raise_s [%message [%here] \"Percent.Option.value_exn none\"]\n ;;\n\n let value t ~default = if is_some t then unchecked_value t else default\n let sexp_of_t t = to_option t |> Option.sexp_of_t V1.sexp_of_t\n let t_of_sexp sexp = (Option.t_of_sexp V1.t_of_sexp) sexp |> of_option\n end\n end\nend\n\ninclude Stable.V1\n\nmodule Option = struct\n module Stable = Stable.Option\n include Stable.V1\n\n module Optional_syntax = struct\n module Optional_syntax = struct\n let is_none = is_none\n let unsafe_value = unchecked_value\n end\n end\nend\n\nlet is_zero t = t = 0.\nlet apply t f = t *. f\nlet scale t f = t *. f\n\ninclude (\nstruct\n include Float\n\n let sign = sign_exn\nend :\nsig\n val zero : t\n val ( * ) : t -> t -> t\n val ( + ) : t -> t -> t\n val ( - ) : t -> t -> t\n val abs : t -> t\n val neg : t -> t\n val is_nan : t -> bool\n val is_inf : t -> bool\n val sign_exn : t -> Sign.t\n\n include Comparable.With_zero with type t := t\n include Robustly_comparable with type t := t\nend)\n\nlet validate = Float.validate_ordinary\nlet of_string_allow_nan_and_inf s = Stringable.of_string_allow_nan_and_inf s\nlet t_of_sexp_allow_nan_and_inf sexp = of_string_allow_nan_and_inf (Sexp.to_string sexp)\n","open! Import\nopen Std_internal\nopen Digit_string_helpers\nopen! Int.Replace_polymorphic_compare\nmodule Span = Span_float\n\n(* Create an abstract type for Ofday to prevent us from confusing it with\n other floats.\n*)\nmodule Stable = struct\n module V1 = struct\n module T : sig\n type underlying = float\n type t = private underlying [@@deriving bin_io, hash, typerep]\n\n include Comparable.S_common with type t := t\n include Robustly_comparable with type t := t\n include Floatable with type t := t\n\n val add : t -> Span.t -> t option\n val sub : t -> Span.t -> t option\n val next : t -> t option\n val prev : t -> t option\n val diff : t -> t -> Span.t\n val of_span_since_start_of_day_exn : Span.t -> t\n val of_span_since_start_of_day_unchecked : Span.t -> t\n val span_since_start_of_day_is_valid : Span.t -> bool\n val to_span_since_start_of_day : t -> Span.t\n val start_of_day : t\n val start_of_next_day : t\n end = struct\n (* Number of seconds since midnight. *)\n type underlying = Float.t\n\n include (\n struct\n include Float\n\n let sign = sign_exn\n end :\n sig\n type t = underlying [@@deriving bin_io, hash, typerep]\n\n include Comparable.S_common with type t := t\n include Comparable.With_zero with type t := t\n include Robustly_comparable with type t := t\n include Floatable with type t := t\n end)\n\n (* IF THIS REPRESENTATION EVER CHANGES, ENSURE THAT EITHER\n (1) all values serialize the same way in both representations, or\n (2) you add a new Time.Ofday version to stable.ml *)\n\n (* due to precision limitations in float we can't expect better than microsecond\n precision *)\n include Float.Robust_compare.Make (struct\n let robust_comparison_tolerance = 1E-6\n end)\n\n let to_span_since_start_of_day t = Span.of_sec t\n\n (* Another reasonable choice would be only allowing Ofday.t to be < 24hr, but this\n choice was made early on and people became used to being able to easily call 24hr\n the end of the day. It's a bit sad because it shares that moment with the\n beginning of the next day, and round trips oddly if passed through\n Time.to_date_ofday/Time.of_date_ofday.\n\n Note: [Schedule.t] requires that the end of day be representable, as it's the\n only way to write a schedule in terms of [Ofday.t]s that spans two weekdays. *)\n (* ofday must be >= 0 and <= 24h *)\n let is_valid (t : t) =\n let t = to_span_since_start_of_day t in\n Span.( <= ) Span.zero t && Span.( <= ) t Span.day\n ;;\n\n let of_span_since_start_of_day_unchecked span = Span.to_sec span\n\n let span_since_start_of_day_is_valid span =\n is_valid (of_span_since_start_of_day_unchecked span)\n ;;\n\n let of_span_since_start_of_day_exn span =\n let module C = Float.Class in\n let s = Span.to_sec span in\n match Float.classify s with\n | C.Infinite ->\n invalid_arg \"Ofday.of_span_since_start_of_day_exn: infinite value\"\n | C.Nan -> invalid_arg \"Ofday.of_span_since_start_of_day_exn: NaN value\"\n | C.Normal | C.Subnormal | C.Zero ->\n if not (is_valid s)\n then invalid_argf !\"Ofday out of range: %{Span}\" span ()\n else s\n ;;\n\n let start_of_day = 0.\n let start_of_next_day = of_span_since_start_of_day_exn Span.day\n\n let add (t : t) (span : Span.t) =\n let t = t +. Span.to_sec span in\n if is_valid t then Some t else None\n ;;\n\n let sub (t : t) (span : Span.t) =\n let t = t -. Span.to_sec span in\n if is_valid t then Some t else None\n ;;\n\n let next t =\n let candidate = Float.one_ulp `Up t in\n if is_valid candidate then Some candidate else None\n ;;\n\n let prev t =\n let candidate = Float.one_ulp `Down t in\n if is_valid candidate then Some candidate else None\n ;;\n\n let diff t1 t2 =\n Span.( - ) (to_span_since_start_of_day t1) (to_span_since_start_of_day t2)\n ;;\n end\n\n let approximate_end_of_day =\n Option.value_exn (T.sub T.start_of_next_day Span.microsecond)\n ;;\n\n (* [create] chops off any subsecond part when [sec = 60] to handle leap seconds. In\n particular it's trying to be generous about reading in times on things like fix\n messages that might include an extra unlikely second.\n\n Other ways of writing a time, like 1000ms, while mathematically valid, don't match\n ways that people actually write times down, so we didn't see the need to support\n them. That is, a clock might legitimately read 23:59:60 (or, with 60 seconds at\n times of day other than 23:59, depending on the time zone), but it doesn't seem\n reasonable for a clock to read \"23:59:59 and 1000ms\". *)\n let create ?hr ?min ?sec ?ms ?us ?ns () =\n let ms, us, ns =\n match sec with\n | Some 60 -> Some 0, Some 0, Some 0\n | _ -> ms, us, ns\n in\n T.of_span_since_start_of_day_exn (Span.create ?hr ?min ?sec ?ms ?us ?ns ())\n ;;\n\n let to_parts t = Span.to_parts (T.to_span_since_start_of_day t)\n\n let to_string_gen ~drop_ms ~drop_us ~trim t =\n let ( / ) = Int63.( / ) in\n let ( ! ) = Int63.of_int in\n let ( mod ) = Int63.rem in\n let i = Int63.to_int_exn in\n assert (if drop_ms then drop_us else true);\n let float_sec = Span.to_sec (T.to_span_since_start_of_day t) in\n let us = Float.int63_round_nearest_exn (float_sec *. 1e6) in\n let ms, us = us / !1000, us mod !1000 |> i in\n let sec, ms = ms / !1000, ms mod !1000 |> i in\n let min, sec = sec / !60, sec mod !60 |> i in\n let hr, min = min / !60, min mod !60 |> i in\n let hr = i hr in\n let dont_print_us = drop_us || (trim && us = 0) in\n let dont_print_ms = drop_ms || (trim && ms = 0 && dont_print_us) in\n let dont_print_s = trim && sec = 0 && dont_print_ms in\n let len =\n if dont_print_s\n then 5\n else if dont_print_ms\n then 8\n else if dont_print_us\n then 12\n else 15\n in\n let buf = Bytes.create len in\n write_2_digit_int buf ~pos:0 hr;\n Bytes.set buf 2 ':';\n write_2_digit_int buf ~pos:3 min;\n if dont_print_s\n then ()\n else (\n Bytes.set buf 5 ':';\n write_2_digit_int buf ~pos:6 sec;\n if dont_print_ms\n then ()\n else (\n Bytes.set buf 8 '.';\n write_3_digit_int buf ~pos:9 ms;\n if dont_print_us then () else write_3_digit_int buf ~pos:12 us));\n Bytes.unsafe_to_string ~no_mutation_while_string_reachable:buf\n ;;\n\n let to_string_trimmed t = to_string_gen ~drop_ms:false ~drop_us:false ~trim:true t\n let to_sec_string t = to_string_gen ~drop_ms:true ~drop_us:true ~trim:false t\n\n let to_millisecond_string t =\n to_string_gen ~drop_ms:false ~drop_us:true ~trim:false t\n ;;\n\n let small_diff =\n let hour = 3600. in\n fun ofday1 ofday2 ->\n let ofday1 = Span.to_sec (T.to_span_since_start_of_day ofday1) in\n let ofday2 = Span.to_sec (T.to_span_since_start_of_day ofday2) in\n let diff = ofday1 -. ofday2 in\n (* d1 is in (-hour; hour) *)\n let d1 = Float.mod_float diff hour in\n (* d2 is in (0;hour) *)\n let d2 = Float.mod_float (d1 +. hour) hour in\n let d = if Float.( > ) d2 (hour /. 2.) then d2 -. hour else d2 in\n Span.of_sec d\n ;;\n\n include T\n\n let to_string t = to_string_gen ~drop_ms:false ~drop_us:false ~trim:false t\n\n include Pretty_printer.Register (struct\n type nonrec t = t\n\n let to_string = to_string\n let module_name = \"Core_kernel.Time.Ofday\"\n end)\n\n let create_from_parsed string ~hr ~min ~sec ~subsec_pos ~subsec_len =\n let subsec =\n if Int.equal subsec_len 0\n then 0.\n else Float.of_string (String.sub string ~pos:subsec_pos ~len:subsec_len)\n in\n Float.of_int ((hr * 3600) + (min * 60) + sec) +. subsec\n |> Span.of_sec\n |> T.of_span_since_start_of_day_exn\n ;;\n\n let of_string s = Ofday_helpers.parse s ~f:create_from_parsed\n\n let t_of_sexp sexp =\n match sexp with\n | Sexp.Atom s ->\n (try of_string s with\n | Invalid_argument s -> of_sexp_error (\"Ofday.t_of_sexp: \" ^ s) sexp)\n | _ -> of_sexp_error \"Ofday.t_of_sexp\" sexp\n ;;\n\n let sexp_of_t span = Sexp.Atom (to_string span)\n\n let of_string_iso8601_extended ?pos ?len str =\n try Ofday_helpers.parse_iso8601_extended ?pos ?len str ~f:create_from_parsed with\n | exn ->\n invalid_argf\n \"Ofday.of_string_iso8601_extended(%s): %s\"\n (String.subo str ?pos ?len)\n (Exn.to_string exn)\n ()\n ;;\n end\nend\n\ninclude Stable.V1\n\nlet gen_incl lo hi =\n Span.gen_incl (to_span_since_start_of_day lo) (to_span_since_start_of_day hi)\n |> Quickcheck.Generator.map ~f:of_span_since_start_of_day_exn\n;;\n\nlet gen_uniform_incl lo hi =\n Span.gen_uniform_incl (to_span_since_start_of_day lo) (to_span_since_start_of_day hi)\n |> Quickcheck.Generator.map ~f:of_span_since_start_of_day_exn\n;;\n\nlet quickcheck_generator = gen_incl start_of_day start_of_next_day\n\nlet quickcheck_observer =\n Quickcheck.Observer.unmap Span.quickcheck_observer ~f:to_span_since_start_of_day\n;;\n\nlet quickcheck_shrinker = Quickcheck.Shrinker.empty ()\n\ninclude Hashable.Make_binable (struct\n type nonrec t = t [@@deriving bin_io, compare, hash, sexp_of]\n\n (* Previous versions rendered hash-based containers using float serialization rather\n than time serialization, so when reading hash-based containers in we accept either\n serialization. *)\n let t_of_sexp sexp =\n match Float.t_of_sexp sexp with\n | float -> of_float float\n | exception _ -> t_of_sexp sexp\n ;;\n end)\n\nmodule C = struct\n type t = T.t [@@deriving bin_io]\n type comparator_witness = T.comparator_witness\n\n let comparator = T.comparator\n\n (* In 108.06a and earlier, ofdays in sexps of Maps and Sets were raw floats. From\n 108.07 through 109.13, the output format remained raw as before, but both the raw and\n pretty format were accepted as input. From 109.14 on, the output format was changed\n from raw to pretty, while continuing to accept both formats. Once we believe most\n programs are beyond 109.14, we will switch the input format to no longer accept\n raw. *)\n let sexp_of_t = sexp_of_t\n\n let t_of_sexp sexp =\n match Option.try_with (fun () -> T.of_float (Float.t_of_sexp sexp)) with\n | Some t -> t\n | None -> t_of_sexp sexp\n ;;\nend\n\nmodule Map = Map.Make_binable_using_comparator (C)\nmodule Set = Set.Make_binable_using_comparator (C)\n\nlet of_span_since_start_of_day = of_span_since_start_of_day_exn\nlet to_millisec_string = to_millisecond_string\n","open! Import\nopen Std_internal\nopen! Int63.O\n\nlet module_name = \"Core_kernel.Time_ns.Span\"\n\ntype underlying = Int63.t\n\nlet arch_sixtyfour = Int.equal Sys.word_size 64\nlet round_nearest = Float.int63_round_nearest_exn\nlet float x = Int63.to_float x\n\n(* [Span] is basically a [Int63]. It even silently ignores overflow. *)\nmodule T = struct\n type t = Int63.t (* nanoseconds *) [@@deriving hash, bin_io, quickcheck, typerep]\n\n module Replace_polymorphic_compare = Int63.Replace_polymorphic_compare\n\n let zero = Int63.zero\nend\n\ninclude T\nopen Replace_polymorphic_compare\n\nmodule Parts = struct\n type t =\n { sign : Sign.t\n ; hr : int\n ; min : int\n ; sec : int\n ; ms : int\n ; us : int\n ; ns : int\n }\n [@@deriving compare, sexp]\nend\n\nlet next t = Int63.succ t\nlet prev t = Int63.pred t\nlet nanosecond = Int63.of_int 1\nlet microsecond = Int63.(of_int 1000 * nanosecond)\nlet millisecond = Int63.(of_int 1000 * microsecond)\nlet second = Int63.(of_int 1000 * millisecond)\nlet minute = Int63.(of_int 60 * second)\nlet hour = Int63.(of_int 60 * minute)\nlet day = Int63.(of_int 24 * hour)\n\n(* Beyond [min_value_for_1us_rounding..max_value_for_1us_rounding], not every microsecond\n can be represented as a [float] number of seconds. (In fact, it is around 135y, but we\n leave a small margin.)\n\n In the presence of silently ignored overflow, note that [t] is not actually bound to\n stay between these limits. *)\nlet max_value_for_1us_rounding = Int63.(of_int 135 * of_int 365 * day)\nlet min_value_for_1us_rounding = Int63.neg max_value_for_1us_rounding\n\nlet create\n ?sign:(sign_ = Sign.Pos (* rebind so not shadowed by [open Int63] below *))\n ?day:(days = 0)\n ?(hr = 0)\n ?min:(minutes = 0)\n ?(sec = 0)\n ?(ms = 0)\n ?(us = 0)\n ?(ns = 0)\n ()\n =\n let open Int63 in\n let t =\n (of_int days * day)\n + (of_int hr * hour)\n + (of_int minutes * minute)\n + (of_int sec * second)\n + (of_int ms * millisecond)\n + (of_int us * microsecond)\n + (of_int ns * nanosecond)\n in\n match sign_ with\n | Neg -> neg t\n | Pos | Zero -> t\n;;\n\nlet to_parts t =\n let open Int63 in\n let mag = abs t in\n { Parts.sign = (if t < zero then Neg else if t > zero then Pos else Zero)\n ; hr = to_int_exn (mag / hour)\n ; min = to_int_exn (rem mag hour / minute)\n ; sec = to_int_exn (rem mag minute / second)\n ; ms = to_int_exn (rem mag second / millisecond)\n ; us = to_int_exn (rem mag millisecond / microsecond)\n ; ns = to_int_exn (rem mag microsecond / nanosecond)\n }\n;;\n\nlet of_parts { Parts.sign; hr; min; sec; ms; us; ns } =\n create ~sign ~hr ~min ~sec ~ms ~us ~ns ()\n;;\n\nlet of_ns f = round_nearest f\nlet of_int63_ns i = i\nlet of_int_us i = Int63.(of_int i * microsecond)\nlet of_int_ms i = Int63.(of_int i * millisecond)\nlet of_int_sec i = Int63.(of_int i * second)\nlet of_us f = round_nearest (f *. float microsecond)\nlet of_ms f = round_nearest (f *. float millisecond)\nlet of_sec f = round_nearest (f *. float second)\nlet of_min f = round_nearest (f *. float minute)\nlet of_hr f = round_nearest (f *. float hour)\nlet of_day f = round_nearest (f *. float day)\n\nlet of_sec_with_microsecond_precision sec =\n let us = round_nearest (sec *. 1e6) in\n of_int63_ns Int63.(us * of_int 1000)\n;;\n\nlet of_int63_seconds x = x * second\nlet of_int32_seconds x = of_int63_seconds (Int63.of_int32 x)\n\nlet to_ns t = float t\nlet to_int63_ns t = t\nlet to_us t = float t /. float microsecond\nlet to_ms t = float t /. float millisecond\nlet to_sec t = float t /. float second\nlet to_min t = float t /. float minute\nlet to_hr t = float t /. float hour\nlet to_day t = float t /. float day\nlet to_int_us t = Int63.(to_int_exn (t / microsecond))\nlet to_int_ms t = Int63.(to_int_exn (t / millisecond))\nlet to_int_sec t = Int63.(to_int_exn (t / second))\nlet to_int63_seconds_round_down_exn t = t /% second\nlet of_int_ns i = of_int63_ns (Int63.of_int i)\n\nlet to_int_ns =\n if arch_sixtyfour\n then fun t -> Int63.to_int_exn (to_int63_ns t)\n else fun _ -> failwith \"Time_ns.Span.to_int_ns: unsupported on 32bit machines\"\n;;\n\nlet ( + ) t u = Int63.( + ) t u\nlet ( - ) t u = Int63.( - ) t u\nlet abs = Int63.abs\nlet neg = Int63.neg\nlet scale t f = round_nearest (float t *. f)\nlet scale_int63 t i = Int63.( * ) t i\nlet scale_int t i = scale_int63 t (Int63.of_int i)\nlet div = Int63.( /% )\nlet ( / ) t f = round_nearest (float t /. f)\nlet ( // ) = Int63.( // )\nlet to_proportional_float t = Int63.to_float t\n\nlet of_unit_of_time u =\n match (u : Unit_of_time.t) with\n | Nanosecond -> nanosecond\n | Microsecond -> microsecond\n | Millisecond -> millisecond\n | Second -> second\n | Minute -> minute\n | Hour -> hour\n | Day -> day\n;;\n\nlet to_unit_of_time t : Unit_of_time.t =\n let abs_t = abs t in\n if abs_t >= day\n then Day\n else if abs_t >= hour\n then Hour\n else if abs_t >= minute\n then Minute\n else if abs_t >= second\n then Second\n else if abs_t >= millisecond\n then Millisecond\n else if abs_t >= microsecond\n then Microsecond\n else Nanosecond\n;;\n\nmodule Stable = struct\n module V2 = struct\n module T = struct\n module T0 = struct\n type nonrec t = t [@@deriving bin_io, compare, hash]\n\n let of_int63_exn t = of_int63_ns t\n let to_int63 t = to_int63_ns t\n\n module To_string = struct\n let number_of_digits_to_write ~span_part_magnitude =\n let open Int.O in\n if span_part_magnitude = 0\n then 0\n else if span_part_magnitude < 10\n then 1\n else if span_part_magnitude < 100\n then 2\n else if span_part_magnitude < 1_000\n then 3\n else if span_part_magnitude < 10_000\n then 4\n else if span_part_magnitude < 100_000\n then 5\n else assert false\n ;;\n\n (* span part magnitudes are always < 100_000 *)\n\n let number_of_decimal_places_to_write ~billionths =\n let open Int.O in\n assert (billionths >= 0 && billionths <= 999_999_999);\n if billionths = 0\n then 0\n else if billionths % 10 <> 0\n then 9\n else if billionths % 100 <> 0\n then 8\n else if billionths % 1_000 <> 0\n then 7\n else if billionths % 10_000 <> 0\n then 6\n else if billionths % 100_000 <> 0\n then 5\n else if billionths % 1_000_000 <> 0\n then 4\n else if billionths % 10_000_000 <> 0\n then 3\n else if billionths % 100_000_000 <> 0\n then 2\n else 1\n ;;\n\n let write_char buf ~pos char =\n let open Int.O in\n Bytes.unsafe_set buf pos char;\n pos + 1\n ;;\n\n let write_2_chars buf ~pos char1 char2 =\n let open Int.O in\n Bytes.unsafe_set buf pos char1;\n Bytes.unsafe_set buf (pos + 1) char2;\n pos + 2\n ;;\n\n let write_digits buf ~pos ~digits int =\n let open Int.O in\n Digit_string_helpers.write_int63 buf ~pos ~digits (Int63.of_int int);\n pos + digits\n ;;\n\n let write_decimals buf ~pos ~decimals ~billionths =\n let open Int.O in\n Digit_string_helpers.write_int63\n buf\n ~pos\n ~digits:decimals\n (Int63.of_int (billionths / Int.pow 10 (9 - decimals)));\n pos + decimals\n ;;\n\n let write_if_non_empty buf ~pos ~digits int suffix =\n let open Int.O in\n if digits = 0\n then pos\n else (\n let pos = write_digits buf ~pos ~digits int in\n let pos = write_char buf ~pos suffix in\n pos)\n ;;\n\n let nanos_of_millisecond = to_int63_ns millisecond |> Int63.to_int_exn\n let nanos_of_microsecond = to_int63_ns microsecond |> Int63.to_int_exn\n let int63_60 = Int63.of_int 60\n let int63_24 = Int63.of_int 24\n\n (* Units of seconds and smaller can be written in decimal notation without\n worrying about non-power-of-ten factors. *)\n module Decimal_unit = struct\n type t =\n | Second\n | Millisecond\n | Microsecond\n | Nanosecond\n | None\n [@@deriving compare, sexp_of]\n\n let create ~s ~ns =\n let open Int.O in\n if s > 0\n then Second\n else if ns >= nanos_of_millisecond\n then Millisecond\n else if ns >= nanos_of_microsecond\n then Microsecond\n else if ns >= 1\n then Nanosecond\n else None\n ;;\n\n let integer t ~s ~ns =\n let open Int.O in\n match t with\n | Second -> s\n | Millisecond -> ns / nanos_of_millisecond\n | Microsecond -> ns / nanos_of_microsecond\n | Nanosecond -> ns\n | None -> 0\n ;;\n\n let billionths t ~ns =\n let open Int.O in\n match t with\n | Second -> ns\n | Millisecond -> ns % nanos_of_millisecond * 1_000\n | Microsecond -> ns % nanos_of_microsecond * 1_000_000\n | Nanosecond -> 0\n | None -> 0\n ;;\n\n let length t ~digits ~decimals =\n let open Int.O in\n let digits_len =\n match t with\n | Second -> digits + 1\n | Millisecond | Microsecond | Nanosecond -> digits + 2\n | None -> 0\n in\n let decimals_len = if decimals > 0 then decimals + 1 else 0 in\n digits_len + decimals_len\n ;;\n\n let write_suffix t buf ~pos =\n match t with\n | Second -> write_char buf ~pos 's'\n | Millisecond -> write_2_chars buf ~pos 'm' 's'\n | Microsecond -> write_2_chars buf ~pos 'u' 's'\n | Nanosecond -> write_2_chars buf ~pos 'n' 's'\n | None -> pos\n ;;\n\n let write t buf ~pos ~integer ~digits ~billionths ~decimals =\n let open Int.O in\n if digits = 0\n then pos\n else (\n let pos = write_digits buf ~pos integer ~digits in\n let pos =\n if decimals = 0\n then pos\n else (\n let pos = write_char buf ~pos '.' in\n write_decimals buf ~pos ~billionths ~decimals)\n in\n write_suffix t buf ~pos)\n ;;\n end\n\n let to_string t =\n if equal t zero\n then \"0s\"\n else (\n let is_negative = t < zero in\n let seconds = Int63.( / ) (to_int63_ns t) (to_int63_ns second) in\n let ns =\n Int63.rem (to_int63_ns t) (to_int63_ns second) |> Int63.to_int_exn\n in\n let seconds = Int63.abs seconds in\n let ns = Int.abs ns in\n let s = Int63.rem seconds int63_60 |> Int63.to_int_exn in\n let minutes = Int63.( / ) seconds int63_60 in\n let m = Int63.rem minutes int63_60 |> Int63.to_int_exn in\n let hours = Int63.( / ) minutes int63_60 in\n let h = Int63.rem hours int63_24 |> Int63.to_int_exn in\n let d = Int63.( / ) hours int63_24 |> Int63.to_int_exn in\n let open Int.O in\n let digits_of_d = number_of_digits_to_write ~span_part_magnitude:d in\n let digits_of_h = number_of_digits_to_write ~span_part_magnitude:h in\n let digits_of_m = number_of_digits_to_write ~span_part_magnitude:m in\n let decimal_unit = Decimal_unit.create ~s ~ns in\n let decimal_unit_integer = Decimal_unit.integer decimal_unit ~s ~ns in\n let decimal_unit_billionths = Decimal_unit.billionths decimal_unit ~ns in\n let digits_of_decimal_unit =\n number_of_digits_to_write ~span_part_magnitude:decimal_unit_integer\n in\n let decimals_of_decimal_unit =\n number_of_decimal_places_to_write ~billionths:decimal_unit_billionths\n in\n let string_length =\n let sign_len = if is_negative then 1 else 0 in\n let d_len = if digits_of_d > 0 then digits_of_d + 1 else 0 in\n let h_len = if digits_of_h > 0 then digits_of_h + 1 else 0 in\n let m_len = if digits_of_m > 0 then digits_of_m + 1 else 0 in\n let decimal_unit_len =\n Decimal_unit.length\n decimal_unit\n ~digits:digits_of_decimal_unit\n ~decimals:decimals_of_decimal_unit\n in\n sign_len + d_len + h_len + m_len + decimal_unit_len\n in\n assert (string_length > 0);\n let buf = Bytes.create string_length in\n let pos = 0 in\n let pos = if is_negative then write_char buf ~pos '-' else pos in\n let pos = write_if_non_empty buf ~pos ~digits:digits_of_d d 'd' in\n let pos = write_if_non_empty buf ~pos ~digits:digits_of_h h 'h' in\n let pos = write_if_non_empty buf ~pos ~digits:digits_of_m m 'm' in\n let pos =\n Decimal_unit.write\n decimal_unit\n buf\n ~pos\n ~integer:decimal_unit_integer\n ~digits:digits_of_decimal_unit\n ~billionths:decimal_unit_billionths\n ~decimals:decimals_of_decimal_unit\n in\n assert (pos = string_length);\n Bytes.unsafe_to_string ~no_mutation_while_string_reachable:buf)\n ;;\n end\n\n let to_string = To_string.to_string\n\n module Of_string = struct\n (* We do computations using negative numbers everywhere and test against\n things related to [Int63.min_value] rather than using positive numbers\n and testing against things related to [Int63.max_value] because the\n negative integer range is one wider than the positive integer range\n (-2**63 vs 2**63-1), and we need that to be able to handle Int63.min_value\n nicely. *)\n\n let int63_10 = Int63.of_int 10\n let min_mult10_without_underflow = Int63.(min_value / int63_10)\n\n let[@cold] invalid_string string ~reason =\n raise_s\n [%message\n \"Time_ns.Span.of_string: invalid string\"\n (string : string)\n (reason : string)]\n ;;\n\n (* Assumes x and y are both nonpositive *)\n let add_without_underflow ~string x y =\n let open Int63.O in\n let sum = x + y in\n if sum > x\n then invalid_string string ~reason:\"span would be outside of int63 range\";\n sum\n ;;\n\n let add_neg_digit ~string int63 char =\n let open Int63.O in\n let digit = Int63.of_int (Char.get_digit_exn char) in\n if int63 < min_mult10_without_underflow\n then invalid_string string ~reason:\"span would be outside of int63 range\";\n add_without_underflow ~string (int63 * int63_10) (-digit)\n ;;\n\n let min_factor_of span = Int63.( / ) Int63.min_value (to_int63_ns span)\n let min_days_without_underflow = min_factor_of day\n let min_hours_without_underflow = min_factor_of hour\n let min_minutes_without_underflow = min_factor_of minute\n let min_seconds_without_underflow = min_factor_of second\n let min_milliseconds_without_underflow = min_factor_of millisecond\n let min_microseconds_without_underflow = min_factor_of microsecond\n let min_nanoseconds_without_underflow = min_factor_of nanosecond\n\n let min_without_underflow_of_unit_of_time unit_of_time =\n match (unit_of_time : Unit_of_time.t) with\n | Day -> min_days_without_underflow\n | Hour -> min_hours_without_underflow\n | Minute -> min_minutes_without_underflow\n | Second -> min_seconds_without_underflow\n | Millisecond -> min_milliseconds_without_underflow\n | Microsecond -> min_microseconds_without_underflow\n | Nanosecond -> min_nanoseconds_without_underflow\n ;;\n\n let negative_part\n string\n ~neg_integer\n ~decimal_pos\n ~end_pos\n ~unit_of_time\n ~round_ties_before_negating\n =\n let open Int.O in\n let scale = to_int63_ns (of_unit_of_time unit_of_time) in\n let min_without_underflow =\n min_without_underflow_of_unit_of_time unit_of_time\n in\n if Int63.( < ) neg_integer min_without_underflow\n then invalid_string string ~reason:\"span would be outside of int63 range\";\n let neg_integer_ns = Int63.( * ) neg_integer scale in\n let fraction_pos = decimal_pos + 1 in\n if fraction_pos >= end_pos\n then neg_integer_ns\n else (\n let decimal_ns =\n Digit_string_helpers.read_int63_decimal\n string\n ~pos:fraction_pos\n ~scale\n ~decimals:(end_pos - fraction_pos)\n ~allow_underscore:true\n ~round_ties:round_ties_before_negating\n in\n add_without_underflow ~string neg_integer_ns (Int63.( ~- ) decimal_ns))\n ;;\n\n let of_string string =\n let open Int.O in\n let neg_ns = ref Int63.zero in\n let pos = ref 0 in\n let len = String.length string in\n if len = 0 then invalid_string string ~reason:\"empty string\";\n let is_negative =\n match String.unsafe_get string !pos with\n | '-' ->\n incr pos;\n true\n | '+' ->\n incr pos;\n false\n | _ -> false\n in\n let round_ties_before_negating : Digit_string_helpers.Round.t =\n (* Ultimately, we always round parsed spans towards positive infinity when\n the nearest round ns are equidistant. For example, \"1.5ns\" is read as\n 2.0ns, and \"-1.5ns\" is read as -1ns. Since we read absolute values before\n applying the sign, we must choose our rounding direction based on the\n sign. Rounding decimal values happens before negating their magnitude. *)\n match is_negative with\n | false -> Toward_positive_infinity\n | true -> Toward_negative_infinity\n in\n (* Loop over parts, like \"5m\" in \"1h5m30s\" *)\n while !pos < len do\n let has_digit = ref false in\n let neg_integer =\n let i = ref Int63.zero in\n let end_of_digits = ref false in\n while !pos < len && not !end_of_digits do\n let c = String.unsafe_get string !pos in\n match c with\n | '0' .. '9' ->\n i := add_neg_digit ~string !i c;\n has_digit := true;\n incr pos\n | '_' -> incr pos\n | _ -> end_of_digits := true\n done;\n !i\n in\n let decimal_pos = !pos in\n if !pos < len && Char.equal '.' (String.unsafe_get string !pos)\n then (\n incr pos;\n let end_of_decimals = ref false in\n while !pos < len && not !end_of_decimals do\n match String.unsafe_get string !pos with\n | '0' .. '9' ->\n has_digit := true;\n incr pos\n | '_' -> incr pos\n | _ -> end_of_decimals := true\n done);\n let end_pos = !pos in\n if not !has_digit\n then invalid_string string ~reason:\"no digits before unit suffix\";\n let unit_of_time : Unit_of_time.t =\n if !pos + 1 < len && Char.equal 's' (String.unsafe_get string (!pos + 1))\n then (\n match String.unsafe_get string !pos with\n | 'm' ->\n pos := !pos + 2;\n Millisecond\n | 'u' ->\n pos := !pos + 2;\n Microsecond\n | 'n' ->\n pos := !pos + 2;\n Nanosecond\n | _ -> invalid_string string ~reason:\"unparseable unit suffix\")\n else if !pos < len\n then (\n match String.unsafe_get string !pos with\n | 'd' ->\n incr pos;\n Day\n | 'h' ->\n incr pos;\n Hour\n | 'm' ->\n incr pos;\n Minute\n | 's' ->\n incr pos;\n Second\n | _ -> invalid_string string ~reason:\"unparseable unit suffix\")\n else invalid_string string ~reason:\"no unit suffix after digits\"\n in\n let neg_nanos_of_part =\n negative_part\n string\n ~neg_integer\n ~decimal_pos\n ~end_pos\n ~unit_of_time\n ~round_ties_before_negating\n in\n neg_ns := add_without_underflow ~string !neg_ns neg_nanos_of_part\n done;\n let ns =\n if is_negative\n then !neg_ns\n else if Int63.( = ) !neg_ns Int63.min_value\n then invalid_string string ~reason:\"span would be outside of int63 range\"\n else Int63.( ~- ) !neg_ns\n in\n of_int63_ns ns\n ;;\n end\n\n let of_string = Of_string.of_string\n let sexp_of_t t = Sexp.Atom (to_string t)\n\n let t_of_sexp sexp =\n match sexp with\n | Sexp.Atom x ->\n (try of_string x with\n | exn -> of_sexp_error (Exn.to_string exn) sexp)\n | Sexp.List _ ->\n of_sexp_error \"Time_ns.Span.Stable.V2.t_of_sexp: sexp must be an Atom\" sexp\n ;;\n end\n\n include T0\n include Comparator.Stable.V1.Make (T0)\n end\n\n include T\n include Comparable.Stable.V1.Make (T)\n end\nend\n\nlet to_string = Stable.V2.to_string\nlet of_string = Stable.V2.of_string\nlet sexp_of_t = Stable.V2.sexp_of_t\nlet t_of_sexp = Stable.V2.t_of_sexp\n\nmodule Alternate_sexp = struct\n type nonrec t = t [@@deriving sexp]\nend\n\ninclude Comparable.Validate_with_zero (struct\n type nonrec t = t [@@deriving compare, sexp]\n\n let zero = zero\n end)\n\n(* Functions required by [Robustly_comparable]: allows for [robust_comparison_tolerance]\n granularity.\n\n A microsecond is a reasonable granularity because there is very little network\n activity that can be measured to sub-microsecond resolution. *)\nlet robust_comparison_tolerance = microsecond\nlet ( >=. ) t u = t >= Int63.(u - robust_comparison_tolerance)\nlet ( <=. ) t u = t <= Int63.(u + robust_comparison_tolerance)\nlet ( =. ) t u = Int63.(abs (t - u)) <= robust_comparison_tolerance\nlet ( >. ) t u = t > Int63.(u + robust_comparison_tolerance)\nlet ( <. ) t u = t < Int63.(u - robust_comparison_tolerance)\nlet ( <>. ) t u = Int63.(abs (t - u)) > robust_comparison_tolerance\nlet robustly_compare t u = if t <. u then -1 else if t >. u then 1 else 0\n\n(* We don't just convert to [Time.Span.t] and use the conversion there because our\n [to_span] conversion is limited to microsecond precision. *)\nlet to_string_hum\n ?(delimiter = '_')\n ?(decimals = 3)\n ?(align_decimal = false)\n ?unit_of_time\n t\n =\n let float, suffix =\n match Option.value unit_of_time ~default:(to_unit_of_time t) with\n | Day -> to_day t, \"d\"\n | Hour -> to_hr t, \"h\"\n | Minute -> to_min t, \"m\"\n | Second -> to_sec t, \"s\"\n | Millisecond -> to_ms t, \"ms\"\n | Microsecond -> to_us t, \"us\"\n | Nanosecond -> to_ns t, \"ns\"\n in\n let prefix =\n Float.to_string_hum float ~delimiter ~decimals ~strip_zero:(not align_decimal)\n in\n let suffix =\n if align_decimal && Int.( = ) (String.length suffix) 1 then suffix ^ \" \" else suffix\n in\n prefix ^ suffix\n;;\n\nlet since_unix_epoch () = Time_now.nanoseconds_since_unix_epoch () |> of_int63_ns\n\nlet random ?state () =\n Int63.random ?state (max_value_for_1us_rounding + Int63.one)\n - Int63.random ?state (neg min_value_for_1us_rounding + Int63.one)\n;;\n\nlet randomize t ~percent = Span_helpers.randomize t ~percent ~scale\n\nlet to_short_string t =\n let ({ sign; hr; min; sec; ms; us; ns } : Parts.t) = to_parts t in\n Span_helpers.short_string ~sign ~hr ~min ~sec ~ms ~us ~ns\n;;\n\nlet gen_incl = Int63.gen_incl\nlet gen_uniform_incl = Int63.gen_uniform_incl\n\ninclude Pretty_printer.Register (struct\n type nonrec t = t\n\n let to_string = to_string\n let module_name = module_name\n end)\n\ninclude Hashable.Make_binable (struct\n type nonrec t = t [@@deriving bin_io, compare, hash, sexp]\n end)\n\ntype comparator_witness = Stable.V2.comparator_witness\n\ninclude Comparable.Make_binable_using_comparator (struct\n type nonrec t = t [@@deriving bin_io, compare, sexp]\n type nonrec comparator_witness = comparator_witness\n\n let comparator = Stable.V2.comparator\n end)\n\n(* re-include [Replace_polymorphic_compare] and its comparisons to shadow the\n un-inlineable ones from [Comparable] *)\nmodule Replace_polymorphic_compare = T.Replace_polymorphic_compare\ninclude Replace_polymorphic_compare\n\nlet to_span_float_round_nearest t = Span_float.of_sec (to_sec t)\nlet of_span_float_round_nearest s = of_sec (Span_float.to_sec s)\nlet half_microsecond = Int63.of_int 500\nlet nearest_microsecond t = Int63.((to_int63_ns t + half_microsecond) /% of_int 1000)\n\nlet[@cold] invalid_range_for_1us_rounding t =\n raise_s\n [%message\n \"Span.t exceeds limits\"\n (t : t)\n (min_value_for_1us_rounding : t)\n (max_value_for_1us_rounding : t)]\n;;\n\nlet check_range_for_1us_rounding t =\n if t < min_value_for_1us_rounding || t > max_value_for_1us_rounding\n then invalid_range_for_1us_rounding t\n else t\n;;\n\nlet to_span_float_round_nearest_microsecond t =\n Span_float.of_us\n (Int63.to_float (nearest_microsecond (check_range_for_1us_rounding t)))\n;;\n\nlet min_span_float_value_for_1us_rounding =\n to_span_float_round_nearest min_value_for_1us_rounding\n;;\n\nlet max_span_float_value_for_1us_rounding =\n to_span_float_round_nearest max_value_for_1us_rounding\n;;\n\nlet of_span_float_round_nearest_microsecond s =\n if Span_float.( > ) s max_span_float_value_for_1us_rounding\n || Span_float.( < ) s min_span_float_value_for_1us_rounding\n then\n failwiths\n ~here:[%here]\n \"Time_ns.Span does not support this span\"\n s\n [%sexp_of: Span_float.t];\n (* Using [Time.Span.to_sec] (being the identity) so that\n we make don't apply too many conversion\n - Too many : `[Span.t] -> [a] -> [t]`\n - Only One : `[Span.t]==[a] -> [t]`. *)\n of_sec_with_microsecond_precision (Span_float.to_sec s)\n;;\n\nlet min_value_representable = of_int63_ns Int63.min_value\nlet max_value_representable = of_int63_ns Int63.max_value\n\nmodule Private = struct\n module Parts = Parts\n\n let of_parts = of_parts\n let to_parts = to_parts\nend\n\n(* Legacy definitions based on rounding to the nearest microsecond. *)\nlet min_value = min_value_for_1us_rounding\nlet max_value = max_value_for_1us_rounding\nlet of_span = of_span_float_round_nearest_microsecond\nlet to_span = to_span_float_round_nearest_microsecond\n","open! Import\nmodule Span = Span_ns\n\ntype underlying = Int63.t\n\ntype t = Span.t (* since wall-clock midnight *)\n[@@deriving bin_io, compare, hash, typerep]\n\ninclude (Span : Robustly_comparable.S with type t := t)\n\nlet to_parts t = Span.to_parts t\n\n\nlet start_of_day : t = Span.zero\nlet start_of_next_day : t = Span.day\nlet approximate_end_of_day = Span.( - ) start_of_next_day Span.nanosecond\nlet to_span_since_start_of_day t = t\n\nlet[@cold] input_out_of_bounds span =\n raise_s\n [%message\n \"Time_ns.Ofday.of_span_since_start_of_day_exn: input out of bounds\"\n ~_:(span : Span.t)]\n;;\n\nlet[@inline always] is_invalid span =\n (* Why we use [Span.( > )] rather than [( >= )] below:\n\n We allow to represent the end-of-day sentinel value ([24.000000000h]), which is not\n itself a valid clock face time. However, since valid clock face times readily\n round up to it, it's better to allow it to be represented. *)\n Span.( < ) span start_of_day || Span.( > ) span start_of_next_day\n;;\n\nlet span_since_start_of_day_is_valid span = not (is_invalid span)\nlet of_span_since_start_of_day_unchecked span = span\n\nlet of_span_since_start_of_day_exn span =\n if is_invalid span then input_out_of_bounds span else span\n;;\n\nlet of_span_since_start_of_day_opt span = if is_invalid span then None else Some span\nlet add_exn t span = of_span_since_start_of_day_exn (Span.( + ) t span)\nlet sub_exn t span = of_span_since_start_of_day_exn (Span.( - ) t span)\nlet add t span = of_span_since_start_of_day_opt (Span.( + ) t span)\nlet sub t span = of_span_since_start_of_day_opt (Span.( - ) t span)\nlet next t = of_span_since_start_of_day_opt (Span.next t)\nlet prev t = of_span_since_start_of_day_opt (Span.prev t)\nlet diff t u = Span.( - ) t u\n\nlet create ?hr ?min ?sec ?ms ?us ?ns () =\n (* Similar to [Time.Ofday.create], if we detect a leap second we strip off all\n sub-second elements so that HH:MM:60.XXXXXXXXX is all mapped to HH:MM:60. *)\n let ms, us, ns =\n match sec with\n | Some 60 -> Some 0, Some 0, Some 0\n | _ -> ms, us, ns\n in\n of_span_since_start_of_day_exn (Span.create ?hr ?min ?sec ?ms ?us ?ns ())\n;;\n\nmodule Stable = struct\n module V1 = struct\n module T = struct\n type nonrec t = t [@@deriving compare, bin_io]\n\n let to_string_with_unit =\n let ( / ) = Int63.( / ) in\n let ( mod ) = Int63.rem in\n let ( ! ) = Int63.of_int in\n let i = Int63.to_int_exn in\n fun t ~unit ->\n if Span.( < ) t start_of_day || Span.( < ) start_of_next_day t\n then \"Incorrect day\"\n else (\n let sixty = !60 in\n let thousand = !1000 in\n let ns = Span.to_int63_ns t in\n let us = ns / thousand in\n let ns = ns mod thousand |> i in\n let ms = us / thousand in\n let us = us mod thousand |> i in\n let s = ms / thousand in\n let ms = ms mod thousand |> i in\n let m = s / sixty in\n let s = s mod sixty |> i in\n let h = m / sixty |> i in\n let m = m mod sixty |> i in\n let unit =\n match unit with\n | (`Nanosecond | `Millisecond | `Second) as unit -> unit\n | `Minute_or_less ->\n if ns <> 0\n then `Nanosecond\n else if us <> 0\n then `Microsecond\n else if ms <> 0\n then `Millisecond\n else if s <> 0\n then `Second\n else `Minute\n in\n let len =\n match unit with\n | `Minute -> 5\n | `Second -> 8\n | `Millisecond -> 12\n | `Microsecond -> 15\n | `Nanosecond -> 18\n in\n let str = Bytes.create len in\n Digit_string_helpers.write_2_digit_int str ~pos:0 h;\n Bytes.set str 2 ':';\n Digit_string_helpers.write_2_digit_int str ~pos:3 m;\n (match unit with\n | `Minute -> ()\n | (`Second | `Millisecond | `Microsecond | `Nanosecond) as unit ->\n Bytes.set str 5 ':';\n Digit_string_helpers.write_2_digit_int str ~pos:6 s;\n (match unit with\n | `Second -> ()\n | (`Millisecond | `Microsecond | `Nanosecond) as unit ->\n Bytes.set str 8 '.';\n Digit_string_helpers.write_3_digit_int str ~pos:9 ms;\n (match unit with\n | `Millisecond -> ()\n | (`Microsecond | `Nanosecond) as unit ->\n Digit_string_helpers.write_3_digit_int str ~pos:12 us;\n (match unit with\n | `Microsecond -> ()\n | `Nanosecond -> Digit_string_helpers.write_3_digit_int str ~pos:15 ns))));\n Bytes.unsafe_to_string ~no_mutation_while_string_reachable:str)\n ;;\n\n let parse_nanoseconds string ~pos ~until =\n let open Int.O in\n let digits = ref 0 in\n let num_digits = ref 0 in\n let pos = ref pos in\n (* read up to 10 digits; store the first 9, use the 10th to round *)\n while !pos < until && !num_digits < 10 do\n let c = string.[!pos] in\n if Char.is_digit c\n then (\n incr num_digits;\n if !num_digits < 10\n then digits := (!digits * 10) + Char.get_digit_exn c\n else if Char.get_digit_exn c >= 5\n then incr digits\n else ());\n incr pos\n done;\n (* if there are missing digits, add zeroes *)\n if !num_digits < 9 then digits := !digits * Int.pow 10 (9 - !num_digits);\n !digits\n ;;\n\n let create_from_parsed string ~hr ~min ~sec ~subsec_pos ~subsec_len =\n let nanoseconds =\n if Int.equal subsec_len 0\n then 0\n else\n parse_nanoseconds\n string\n ~pos:(subsec_pos + 1)\n ~until:(subsec_pos + subsec_len)\n in\n Span.of_int63_ns (Int63.of_int nanoseconds)\n |> Span.( + ) (Span.scale_int Span.second sec)\n |> Span.( + ) (Span.scale_int Span.minute min)\n |> Span.( + ) (Span.scale_int Span.hour hr)\n |> of_span_since_start_of_day_exn\n ;;\n\n let of_string string = Ofday_helpers.parse string ~f:create_from_parsed\n\n let t_of_sexp sexp : t =\n match sexp with\n | Sexp.List _ -> of_sexp_error \"expected an atom\" sexp\n | Sexp.Atom s ->\n (try of_string s with\n | exn -> of_sexp_error_exn exn sexp)\n ;;\n\n let to_string (t : t) = to_string_with_unit t ~unit:`Nanosecond\n let sexp_of_t (t : t) = Sexp.Atom (to_string t)\n let to_int63 t = Span_ns.Stable.V2.to_int63 t\n\n let of_int63_exn t =\n of_span_since_start_of_day_exn (Span_ns.Stable.V2.of_int63_exn t)\n ;;\n end\n\n include T\n include Comparator.Stable.V1.Make (T)\n end\nend\n\nlet sexp_of_t = Stable.V1.sexp_of_t\nlet t_of_sexp = Stable.V1.t_of_sexp\nlet of_string = Stable.V1.of_string\nlet to_string = Stable.V1.to_string\nlet to_millisecond_string t = Stable.V1.to_string_with_unit t ~unit:`Millisecond\nlet to_sec_string t = Stable.V1.to_string_with_unit t ~unit:`Second\nlet to_string_trimmed t = Stable.V1.to_string_with_unit t ~unit:`Minute_or_less\n\nlet of_string_iso8601_extended ?pos ?len str =\n try\n Ofday_helpers.parse_iso8601_extended ?pos ?len str ~f:Stable.V1.create_from_parsed\n with\n | exn ->\n raise_s\n [%message\n \"Time_ns.Ofday.of_string_iso8601_extended: cannot parse string\"\n ~_:(String.subo str ?pos ?len : string)\n ~_:(exn : exn)]\n;;\n\nlet every =\n let rec every_valid_ofday_span span ~start ~stop ~acc =\n (* Assumes [span], [start], and [stop] are valid ofdays. Assumes [start < stop].\n Assumes [span > 0]. *)\n let acc = start :: acc in\n let start = Span.( + ) start span in\n if Span.( > ) start stop (* cannot overflow *)\n then List.rev acc\n else every_valid_ofday_span span ~start ~stop ~acc\n in\n (* internal [every] named to show up in stack traces *)\n let every span ~start ~stop =\n if Span.( > ) start stop\n then\n Or_error.error_s\n [%message\n \"[Time_ns.Ofday.every] called with [start] > [stop]\" (start : t) (stop : t)]\n else if Span.( <= ) span Span.zero\n then\n Or_error.error_s\n [%message \"[Time_ns.Ofday.every] called with negative span\" ~_:(span : Span.t)]\n else if is_invalid span\n then Ok [ start ]\n else Ok (every_valid_ofday_span span ~start ~stop ~acc:[])\n in\n every\n;;\n\nlet small_diff =\n let hour = Span.to_int63_ns Span.hour in\n fun ofday1 ofday2 ->\n let open Int63.O in\n let ofday1 = Span.to_int63_ns (to_span_since_start_of_day ofday1) in\n let ofday2 = Span.to_int63_ns (to_span_since_start_of_day ofday2) in\n let diff = ofday1 - ofday2 in\n (* d1 is in (-hour; hour) *)\n let d1 = Int63.rem diff hour in\n (* d2 is in (0;hour) *)\n let d2 = Int63.rem (d1 + hour) hour in\n let d = if d2 > hour / Int63.of_int 2 then d2 - hour else d2 in\n Span.of_int63_ns d\n;;\n\nlet%expect_test \"small_diff\" =\n let test x y =\n let diff = small_diff x y in\n printf !\"small_diff %s %s = %s\\n\" (to_string x) (to_string y) (Span.to_string diff)\n in\n let examples =\n List.map\n ~f:(fun (x, y) -> of_string x, of_string y)\n [ \"12:00\", \"12:05\"; \"12:58\", \"13:02\"; \"00:52\", \"23:19\"; \"00:00\", \"24:00\" ]\n in\n List.iter examples ~f:(fun (x, y) ->\n test x y;\n test y x);\n [%expect\n {|\n small_diff 12:00:00.000000000 12:05:00.000000000 = -5m\n small_diff 12:05:00.000000000 12:00:00.000000000 = 5m\n small_diff 12:58:00.000000000 13:02:00.000000000 = -4m\n small_diff 13:02:00.000000000 12:58:00.000000000 = 4m\n small_diff 00:52:00.000000000 23:19:00.000000000 = -27m\n small_diff 23:19:00.000000000 00:52:00.000000000 = 27m\n small_diff 00:00:00.000000000 24:00:00.000000000 = 0s\n small_diff 24:00:00.000000000 00:00:00.000000000 = 0s |}]\n;;\n\nlet gen_incl = Span.gen_incl\nlet gen_uniform_incl = Span.gen_uniform_incl\nlet quickcheck_generator = gen_incl start_of_day start_of_next_day\nlet quickcheck_observer = Span.quickcheck_observer\nlet quickcheck_shrinker = Quickcheck.Shrinker.empty ()\n\ninclude Identifiable.Make (struct\n type nonrec t = t [@@deriving bin_io, compare, hash, sexp]\n\n let module_name = \"Core.Time_ns.Ofday\"\n let hash = Span.hash\n let of_string, to_string = of_string, to_string\n end)\n\ninclude (Span : Comparisons.S with type t := t)\n\n(* deprecated bindings *)\nlet of_span_since_start_of_day = of_span_since_start_of_day_exn\nlet to_millisec_string = to_millisecond_string\n","open! Import\n\nmodule Stable = struct\n module Allocation_policy = struct\n module V1 = struct\n type t =\n | Next_fit\n | First_fit\n | Best_fit\n [@@deriving bin_io, compare, equal, hash, sexp]\n end\n end\nend\n\ninclude Caml.Gc\n\nmodule Stat = struct\n module T = struct\n [%%if ocaml_version >= (4, 12, 0)]\n\n type t = Caml.Gc.stat =\n { minor_words : float\n ; promoted_words : float\n ; major_words : float\n ; minor_collections : int\n ; major_collections : int\n ; heap_words : int\n ; heap_chunks : int\n ; live_words : int\n ; live_blocks : int\n ; free_words : int\n ; free_blocks : int\n ; largest_free : int\n ; fragments : int\n ; compactions : int\n ; top_heap_words : int\n ; stack_size : int\n ; forced_major_collections : int\n }\n [@@deriving compare, hash, bin_io, sexp, fields]\n\n [%%else]\n\n type t = Caml.Gc.stat =\n { minor_words : float\n ; promoted_words : float\n ; major_words : float\n ; minor_collections : int\n ; major_collections : int\n ; heap_words : int\n ; heap_chunks : int\n ; live_words : int\n ; live_blocks : int\n ; free_words : int\n ; free_blocks : int\n ; largest_free : int\n ; fragments : int\n ; compactions : int\n ; top_heap_words : int\n ; stack_size : int\n }\n [@@deriving compare, hash, bin_io, sexp, fields]\n\n [%%endif]\n end\n\n include T\n include Comparable.Make (T)\nend\n\nmodule Control = struct\n module T = struct\n [%%if\n ocaml_version < (4, 08, 0)]\n\n type t = Caml.Gc.control =\n { mutable minor_heap_size : int\n ; mutable major_heap_increment : int\n ; mutable space_overhead : int\n ; mutable verbose : int\n ; mutable max_overhead : int\n ; mutable stack_limit : int\n ; mutable allocation_policy : int\n ; window_size : int\n }\n [@@deriving compare, bin_io, sexp, fields]\n\n [%%else]\n\n [@@@ocaml.warning \"-3\"]\n\n type t = Caml.Gc.control =\n { mutable minor_heap_size : int\n ; mutable major_heap_increment : int\n ; mutable space_overhead : int\n ; mutable verbose : int\n ; mutable max_overhead : int\n ; mutable stack_limit : int\n ; mutable allocation_policy : int\n ; window_size : int\n ; custom_major_ratio : int\n ; custom_minor_ratio : int\n ; custom_minor_max_size : int\n }\n [@@deriving compare, bin_io, sexp, fields]\n\n [%%endif]\n end\n\n include T\n include Comparable.Make (T)\nend\n\nmodule Allocation_policy = struct\n include Stable.Allocation_policy.V1\n\n let to_int = function\n | Next_fit -> 0\n | First_fit -> 1\n | Best_fit -> 2\n ;;\nend\n\n[%%if\n ocaml_version < (4, 08, 0)]\n\nlet tune\n ?logger\n ?minor_heap_size\n ?major_heap_increment\n ?space_overhead\n ?verbose\n ?max_overhead\n ?stack_limit\n ?allocation_policy\n ?window_size\n ()\n =\n let old_control_params = get () in\n let f opt to_string field =\n let old_value = Field.get field old_control_params in\n match opt with\n | None -> old_value\n | Some new_value ->\n Option.iter logger ~f:(fun f ->\n Printf.ksprintf\n f\n \"Gc.Control.%s: %s -> %s\"\n (Field.name field)\n (to_string old_value)\n (to_string new_value));\n new_value\n in\n let allocation_policy = Option.map allocation_policy ~f:Allocation_policy.to_int in\n let new_control_params =\n Control.Fields.map\n ~minor_heap_size:(f minor_heap_size string_of_int)\n ~major_heap_increment:(f major_heap_increment string_of_int)\n ~space_overhead:(f space_overhead string_of_int)\n ~verbose:(f verbose string_of_int)\n ~max_overhead:(f max_overhead string_of_int)\n ~stack_limit:(f stack_limit string_of_int)\n ~allocation_policy:(f allocation_policy string_of_int)\n ~window_size:(f window_size string_of_int)\n in\n set new_control_params\n;;\n\n[%%else]\n\nlet tune\n ?logger\n ?minor_heap_size\n ?major_heap_increment\n ?space_overhead\n ?verbose\n ?max_overhead\n ?stack_limit\n ?allocation_policy\n ?window_size\n ?custom_major_ratio\n ?custom_minor_ratio\n ?custom_minor_max_size\n ()\n =\n let old_control_params = get () in\n let f opt to_string field =\n let old_value = Field.get field old_control_params in\n match opt with\n | None -> old_value\n | Some new_value ->\n Option.iter logger ~f:(fun f ->\n Printf.ksprintf\n f\n \"Gc.Control.%s: %s -> %s\"\n (Field.name field)\n (to_string old_value)\n (to_string new_value));\n new_value\n in\n let allocation_policy = Option.map allocation_policy ~f:Allocation_policy.to_int in\n let new_control_params =\n Control.Fields.map\n ~minor_heap_size:(f minor_heap_size string_of_int)\n ~major_heap_increment:(f major_heap_increment string_of_int)\n ~space_overhead:(f space_overhead string_of_int)\n ~verbose:(f verbose string_of_int)\n ~max_overhead:(f max_overhead string_of_int)\n ~stack_limit:(f stack_limit string_of_int)\n ~allocation_policy:(f allocation_policy string_of_int)\n ~window_size:(f window_size string_of_int)\n ~custom_major_ratio:(f custom_major_ratio string_of_int)\n ~custom_minor_ratio:(f custom_minor_ratio string_of_int)\n ~custom_minor_max_size:(f custom_minor_max_size string_of_int)\n in\n set new_control_params\n;;\n\n[%%endif]\n\nlet disable_compaction ?logger ~allocation_policy () =\n let allocation_policy =\n match allocation_policy with\n | `Don't_change -> None\n | `Set_to policy -> Some policy\n in\n (* The value 1_000_000, according to\n http://caml.inria.fr/pub/docs/manual-ocaml-4.02/libref/Gc.html\n will disable compactions.\n *)\n tune ?logger ?allocation_policy ~max_overhead:1_000_000 ()\n;;\n\nexternal minor_words : unit -> int = \"core_kernel_gc_minor_words\"\nexternal major_words : unit -> int = \"core_kernel_gc_major_words\" [@@noalloc]\nexternal promoted_words : unit -> int = \"core_kernel_gc_promoted_words\" [@@noalloc]\nexternal minor_collections : unit -> int = \"core_kernel_gc_minor_collections\" [@@noalloc]\nexternal major_collections : unit -> int = \"core_kernel_gc_major_collections\" [@@noalloc]\nexternal heap_words : unit -> int = \"core_kernel_gc_heap_words\" [@@noalloc]\nexternal heap_chunks : unit -> int = \"core_kernel_gc_heap_chunks\" [@@noalloc]\nexternal compactions : unit -> int = \"core_kernel_gc_compactions\" [@@noalloc]\nexternal top_heap_words : unit -> int = \"core_kernel_gc_top_heap_words\" [@@noalloc]\nexternal major_plus_minor_words : unit -> int = \"core_kernel_gc_major_plus_minor_words\"\nexternal allocated_words : unit -> int = \"core_kernel_gc_allocated_words\"\n\nlet zero = Sys.opaque_identity (int_of_string \"0\")\n\n(* The compiler won't optimize int_of_string away so it won't\n perform constant folding below. *)\nlet rec keep_alive o = if zero <> 0 then keep_alive (Sys.opaque_identity o)\n\nmodule For_testing = struct\n let prepare_heap_to_count_minor_allocation () =\n (* We call [minor] to empty the minor heap, so that our allocation is unlikely to\n trigger a minor gc. *)\n minor ();\n (* We allocate two words in case the [Gc.minor] finishes a major gc cycle, in which\n case it requests a minor gc to occur at the next minor allocation. We don't want\n the subsequent minor allocation to trigger a minor GC, because there is a bug\n (https://github.com/ocaml/ocaml/issues/7798) in the OCaml runtime that double\n counts [Gc.minor_words] in that case. *)\n ignore (Sys.opaque_identity (ref (Sys.opaque_identity 1)) : int ref)\n ;;\n\n (* We disable inlining for this function so the GC stats and the call to [f] are never\n rearranged. *)\n let[@cold] measure_internal ~on_result f =\n let minor_words_before = minor_words () in\n let major_words_before = major_words () in\n (* We wrap [f ()] with [Sys.opaque_identity] to prevent the return value from being\n optimized away. *)\n let x = Sys.opaque_identity (f ()) in\n let minor_words_after = minor_words () in\n let major_words_after = major_words () in\n let major_words_allocated = major_words_after - major_words_before in\n let minor_words_allocated = minor_words_after - minor_words_before in\n on_result ~major_words_allocated ~minor_words_allocated x\n ;;\n\n let is_zero_alloc (type a) (f : unit -> a) =\n (* Instead of using [Allocation_report.measure], and matching on the result, we use\n this construction, in order to have [is_zero_alloc] not allocate itself. This\n enables [is_zero_alloc] to be used in a nested way.\n\n This also means we cannot call [prepare_heap_to_count_minor_allocation]. This is\n okay, since we do not need a precise count, we only need to check if the count is\n zero or not. *)\n measure_internal\n f\n ~on_result:(fun ~major_words_allocated ~minor_words_allocated value ->\n ignore (Sys.opaque_identity value : a);\n major_words_allocated == 0 && minor_words_allocated == 0)\n ;;\n\n module Allocation_report = struct\n type t =\n { major_words_allocated : int\n ; minor_words_allocated : int\n }\n\n let create ~major_words_allocated ~minor_words_allocated =\n { major_words_allocated; minor_words_allocated }\n ;;\n end\n\n let measure_allocation f =\n prepare_heap_to_count_minor_allocation ();\n measure_internal f ~on_result:(fun ~major_words_allocated ~minor_words_allocated x ->\n x, Allocation_report.create ~major_words_allocated ~minor_words_allocated)\n ;;\nend\n\nmodule Expert = struct\n let add_finalizer x f =\n try Caml.Gc.finalise (fun x -> Exn.handle_uncaught_and_exit (fun () -> f x)) x with\n | Invalid_argument _ ->\n (* The type of add_finalizer ensures that the only possible failure\n is due to [x] being static data. In this case, we simply drop the\n finalizer since static data would never have been collected by the\n GC anyway. *)\n ()\n ;;\n\n (* [add_finalizer_exn] is the same as [add_finalizer]. However, their types in\n core_gc.mli are different, and the type of [add_finalizer] guarantees that it always\n receives a heap block, which ensures that it will not raise, while\n [add_finalizer_exn] accepts any type, and so may raise. *)\n let add_finalizer_exn x f =\n try Caml.Gc.finalise (fun x -> Exn.handle_uncaught_and_exit (fun () -> f x)) x with\n | Invalid_argument _ ->\n ignore (Heap_block.create x : _ Heap_block.t option);\n (* If [Heap_block.create] succeeds then [x] is static data and so\n we can simply drop the finaliser. *)\n ()\n ;;\n\n let add_finalizer_last x f =\n try Caml.Gc.finalise_last (fun () -> Exn.handle_uncaught_and_exit f) x with\n | Invalid_argument _ ->\n (* The type of add_finalizer_last ensures that the only possible failure\n is due to [x] being static data. In this case, we simply drop the\n finalizer since static data would never have been collected by the\n GC anyway. *)\n ()\n ;;\n\n let add_finalizer_last_exn x f =\n try Caml.Gc.finalise_last (fun () -> Exn.handle_uncaught_and_exit f) x with\n | Invalid_argument _ ->\n ignore (Heap_block.create x : _ Heap_block.t option);\n (* If [Heap_block.create] succeeds then [x] is static data and so\n we can simply drop the finaliser. *)\n ()\n ;;\n\n let finalize_release = Caml.Gc.finalise_release\n\n module Alarm = struct\n type t = alarm\n\n let sexp_of_t _ = \"\" |> [%sexp_of: string]\n let create f = create_alarm (fun () -> Exn.handle_uncaught_and_exit f)\n let delete = delete_alarm\n end\nend\n","open Format\n\nlet rev_split l =\n let rec inner xs ys = function\n | (x, y) :: xys ->\n inner (x::xs) (y::ys) xys\n | [] -> (xs, ys)\n in\n inner [] [] l\n\ntype wrap = [\n | `Wrap_atoms\n | `Always_wrap\n | `Never_wrap\n | `Force_breaks\n | `Force_breaks_rec\n | `No_breaks\n]\n\ntype label_break = [\n | `Auto\n | `Always\n | `Always_rec\n | `Never\n]\n\ntype style_name = string\ntype style = {\n tag_open : string;\n tag_close : string\n}\n\ntype atom_param = {\n atom_style : style_name option;\n}\n\nlet atom = {\n atom_style = None\n}\n\ntype list_param = {\n space_after_opening : bool;\n space_after_separator : bool;\n space_before_separator : bool;\n separators_stick_left : bool;\n space_before_closing : bool;\n stick_to_label : bool;\n align_closing : bool;\n wrap_body : wrap;\n indent_body : int;\n list_style : style_name option;\n opening_style : style_name option;\n body_style : style_name option;\n separator_style : style_name option;\n closing_style : style_name option;\n}\n\nlet list = {\n space_after_opening = true;\n space_after_separator = true;\n space_before_separator = false;\n separators_stick_left = true;\n space_before_closing = true;\n stick_to_label = true;\n align_closing = true;\n wrap_body = `Wrap_atoms;\n indent_body = 2;\n list_style = None;\n opening_style = None;\n body_style = None;\n separator_style = None;\n closing_style = None;\n}\n\ntype label_param = {\n label_break: label_break;\n space_after_label : bool;\n indent_after_label : int;\n label_style : style_name option;\n}\n\nlet label = {\n label_break = `Auto;\n space_after_label = true;\n indent_after_label = 2;\n label_style = None;\n}\n\ntype t =\n Atom of string * atom_param\n | List of (string * string * string * list_param) * t list\n | Label of (t * label_param) * t\n | Custom of (formatter -> unit)\n\ntype escape =\n [ `None\n | `Escape of\n ((string -> int -> int -> unit) -> string -> int -> int -> unit)\n | `Escape_string of (string -> string) ]\n\ntype styles = (style_name * style) list\n\n(*\n Transform a tree starting from the leaves, propagating and merging\n accumulators until reaching the root.\n*)\nlet propagate_from_leaf_to_root\n ~init_acc (* create initial accumulator for a leaf *)\n ~merge_acc (* merge two accumulators coming from child nodes *)\n ~map_node (* (node, acc) -> (node, acc) *)\n x =\n\n let rec aux x =\n match x with\n | Atom _ ->\n let acc = init_acc x in\n map_node x acc\n | List (param, children) ->\n let new_children, accs = rev_split (List.rev_map aux children) in\n let acc = List.fold_left merge_acc (init_acc x) accs in\n map_node (List (param, new_children)) acc\n | Label ((x1, param), x2) ->\n let acc0 = init_acc x in\n let new_x1, acc1 = aux x1 in\n let new_x2, acc2 = aux x2 in\n let acc = merge_acc (merge_acc acc0 acc1) acc2 in\n map_node (Label ((new_x1, param), new_x2)) acc\n | Custom _ ->\n let acc = init_acc x in\n map_node x acc\n in\n aux x\n\n(*\n Convert wrappable lists into vertical lists if any of their descendants\n has the attribute wrap_body = `Force_breaks_rec.\n*)\nlet propagate_forced_breaks x =\n (* acc = whether to force breaks in wrappable lists or labels *)\n let init_acc = function\n | List ((_, _, _, { wrap_body = `Force_breaks_rec; _ }), _)\n | Label ((_, { label_break = `Always_rec; _ }), _) -> true\n | Atom _\n | Label _\n | Custom _\n | List _ -> false\n in\n let merge_acc force_breaks1 force_breaks2 =\n force_breaks1 || force_breaks2\n in\n let map_node x force_breaks =\n match x with\n | List ((_, _, _, { wrap_body = `Force_breaks_rec; _ }), _) -> x, true\n | List ((_, _, _, { wrap_body = `Force_breaks; _ }), _) -> x, force_breaks\n\n | List ((op, sep, cl, ({ wrap_body = (`Wrap_atoms\n | `Never_wrap\n | `Always_wrap); _ } as p)),\n children) ->\n if force_breaks then\n let p = { p with wrap_body = `Force_breaks } in\n List ((op, sep, cl, p), children), true\n else\n x, false\n\n | Label ((a, ({ label_break = `Auto; _ } as lp)), b) ->\n if force_breaks then\n let lp = { lp with label_break = `Always } in\n Label ((a, lp), b), true\n else\n x, false\n\n | List ((_, _, _, { wrap_body = `No_breaks; _ }), _)\n | Label ((_, { label_break = (`Always | `Always_rec | `Never); _ }), _)\n | Atom _\n | Custom _ -> x, force_breaks\n in\n let new_x, _forced_breaks =\n propagate_from_leaf_to_root\n ~init_acc\n ~merge_acc\n ~map_node\n x\n in\n new_x\n\nmodule Pretty =\nstruct\n (*\n Rewrite the tree to be printed.\n Currently, this is used only to handle `Force_breaks_rec.\n *)\n let rewrite x = propagate_forced_breaks x\n\n (*\n Relies on the fact that mark_open_tag and mark_close_tag\n are called exactly once before calling pp_output_string once.\n It's a reasonable assumption although not guaranteed by the\n documentation of the Format module.\n *)\n let set_escape fmt escape =\n let print0, flush0 = pp_get_formatter_output_functions fmt () in\n let tagf0 = pp_get_formatter_tag_functions fmt () in\n\n let is_tag = ref false in\n\n let mot tag =\n is_tag := true;\n tagf0.mark_open_tag tag\n in\n\n let mct tag =\n is_tag := true;\n tagf0.mark_close_tag tag\n in\n\n let print s p n =\n if !is_tag then\n (print0 s p n;\n is_tag := false)\n else\n escape print0 s p n\n in\n\n let tagf = {\n tagf0 with\n mark_open_tag = mot;\n mark_close_tag = mct\n }\n in\n pp_set_formatter_output_functions fmt print flush0;\n pp_set_formatter_tag_functions fmt tagf\n\n\n let set_escape_string fmt esc =\n let escape print s p n =\n let s0 = String.sub s p n in\n let s1 = esc s0 in\n print s1 0 (String.length s1)\n in\n set_escape fmt escape\n\n\n let define_styles fmt escape l =\n if l <> [] then (\n pp_set_tags fmt true;\n let tbl1 = Hashtbl.create (2 * List.length l) in\n let tbl2 = Hashtbl.create (2 * List.length l) in\n List.iter (\n fun (style_name, style) ->\n Hashtbl.add tbl1 style_name style.tag_open;\n Hashtbl.add tbl2 style_name style.tag_close\n ) l;\n let mark_open_tag style_name =\n try Hashtbl.find tbl1 style_name\n with Not_found -> \"\"\n in\n let mark_close_tag style_name =\n try Hashtbl.find tbl2 style_name\n with Not_found -> \"\"\n in\n\n let tagf = {\n (pp_get_formatter_tag_functions fmt ()) with\n mark_open_tag = mark_open_tag;\n mark_close_tag = mark_close_tag\n }\n in\n pp_set_formatter_tag_functions fmt tagf\n );\n\n (match escape with\n `None -> ()\n | `Escape esc -> set_escape fmt esc\n | `Escape_string esc -> set_escape_string fmt esc)\n\n\n let pp_open_xbox fmt p indent =\n match p.wrap_body with\n `Always_wrap\n | `Never_wrap\n | `Wrap_atoms -> pp_open_hvbox fmt indent\n | `Force_breaks\n | `Force_breaks_rec -> pp_open_vbox fmt indent\n | `No_breaks -> pp_open_hbox fmt ()\n\n let extra_box p l =\n let wrap =\n match p.wrap_body with\n `Always_wrap -> true\n | `Never_wrap\n | `Force_breaks\n | `Force_breaks_rec\n | `No_breaks -> false\n | `Wrap_atoms ->\n List.for_all (function Atom _ -> true | _ -> false) l\n in\n if wrap then\n ((fun fmt -> pp_open_hovbox fmt 0),\n (fun fmt -> pp_close_box fmt ()))\n else\n ((fun _ -> ()),\n (fun _ -> ()))\n\n\n let pp_open_nonaligned_box fmt p indent l =\n match p.wrap_body with\n `Always_wrap -> pp_open_hovbox fmt indent\n | `Never_wrap -> pp_open_hvbox fmt indent\n | `Wrap_atoms ->\n if List.for_all (function Atom _ -> true | _ -> false) l then\n pp_open_hovbox fmt indent\n else\n pp_open_hvbox fmt indent\n | `Force_breaks\n | `Force_breaks_rec -> pp_open_vbox fmt indent\n | `No_breaks -> pp_open_hbox fmt ()\n\n\n let open_tag fmt = function\n None -> ()\n | Some s -> pp_open_tag fmt s\n\n let close_tag fmt = function\n None -> ()\n | Some _ -> pp_close_tag fmt ()\n\n let tag_string fmt o s =\n match o with\n None -> pp_print_string fmt s\n | Some tag ->\n pp_open_tag fmt tag;\n pp_print_string fmt s;\n pp_close_tag fmt ()\n\n let rec fprint_t fmt = function\n Atom (s, p) ->\n tag_string fmt p.atom_style s;\n\n | List ((_, _, _, p) as param, l) ->\n open_tag fmt p.list_style;\n if p.align_closing then\n fprint_list fmt None param l\n else\n fprint_list2 fmt param l;\n close_tag fmt p.list_style\n\n | Label (label, x) -> fprint_pair fmt label x\n | Custom f -> f fmt\n\n and fprint_list_body_stick_left fmt p sep hd tl =\n open_tag fmt p.body_style;\n fprint_t fmt hd;\n List.iter (\n fun x ->\n if p.space_before_separator then\n pp_print_string fmt \" \";\n tag_string fmt p.separator_style sep;\n if p.space_after_separator then\n pp_print_space fmt ()\n else\n pp_print_cut fmt ();\n fprint_t fmt x\n ) tl;\n close_tag fmt p.body_style\n\n and fprint_list_body_stick_right fmt p sep hd tl =\n open_tag fmt p.body_style;\n fprint_t fmt hd;\n List.iter (\n fun x ->\n if p.space_before_separator then\n pp_print_space fmt ()\n else\n pp_print_cut fmt ();\n tag_string fmt p.separator_style sep;\n if p.space_after_separator then\n pp_print_string fmt \" \";\n fprint_t fmt x\n ) tl;\n close_tag fmt p.body_style\n\n and fprint_opt_label fmt = function\n None -> ()\n | Some (lab, lp) ->\n open_tag fmt lp.label_style;\n fprint_t fmt lab;\n close_tag fmt lp.label_style;\n if lp.space_after_label then\n pp_print_string fmt \" \"\n\n (* Either horizontal or vertical list *)\n and fprint_list fmt label ((op, _sep, cl, p) as param) = function\n [] ->\n fprint_opt_label fmt label;\n tag_string fmt p.opening_style op;\n if p.space_after_opening || p.space_before_closing then\n pp_print_string fmt \" \";\n tag_string fmt p.closing_style cl\n\n | hd :: tl as l ->\n\n if tl = [] || p.separators_stick_left then\n fprint_list_stick_left fmt label param hd tl l\n else\n fprint_list_stick_right fmt label param hd tl l\n\n\n and fprint_list_stick_left fmt label (op, sep, cl, p) hd tl l =\n let indent = p.indent_body in\n pp_open_xbox fmt p indent;\n fprint_opt_label fmt label;\n\n tag_string fmt p.opening_style op;\n\n if p.space_after_opening then\n pp_print_space fmt ()\n else\n pp_print_cut fmt ();\n\n let open_extra, close_extra = extra_box p l in\n open_extra fmt;\n fprint_list_body_stick_left fmt p sep hd tl;\n close_extra fmt;\n\n if p.space_before_closing then\n pp_print_break fmt 1 (-indent)\n else\n pp_print_break fmt 0 (-indent);\n tag_string fmt p.closing_style cl;\n pp_close_box fmt ()\n\n and fprint_list_stick_right fmt label (op, sep, cl, p) hd tl l =\n let base_indent = p.indent_body in\n let sep_indent =\n String.length sep + (if p.space_after_separator then 1 else 0)\n in\n let indent = base_indent + sep_indent in\n\n pp_open_xbox fmt p indent;\n fprint_opt_label fmt label;\n\n tag_string fmt p.opening_style op;\n\n if p.space_after_opening then\n pp_print_space fmt ()\n else\n pp_print_cut fmt ();\n\n let open_extra, close_extra = extra_box p l in\n open_extra fmt;\n\n fprint_t fmt hd;\n List.iter (\n fun x ->\n if p.space_before_separator then\n pp_print_break fmt 1 (-sep_indent)\n else\n pp_print_break fmt 0 (-sep_indent);\n tag_string fmt p.separator_style sep;\n if p.space_after_separator then\n pp_print_string fmt \" \";\n fprint_t fmt x\n ) tl;\n\n close_extra fmt;\n\n if p.space_before_closing then\n pp_print_break fmt 1 (-indent)\n else\n pp_print_break fmt 0 (-indent);\n tag_string fmt p.closing_style cl;\n pp_close_box fmt ()\n\n\n\n (* align_closing = false *)\n and fprint_list2 fmt (op, sep, cl, p) = function\n [] ->\n tag_string fmt p.opening_style op;\n if p.space_after_opening || p.space_before_closing then\n pp_print_string fmt \" \";\n tag_string fmt p.closing_style cl\n\n | hd :: tl as l ->\n tag_string fmt p.opening_style op;\n if p.space_after_opening then\n pp_print_string fmt \" \";\n\n pp_open_nonaligned_box fmt p 0 l ;\n if p.separators_stick_left then\n fprint_list_body_stick_left fmt p sep hd tl\n else\n fprint_list_body_stick_right fmt p sep hd tl;\n pp_close_box fmt ();\n\n if p.space_before_closing then\n pp_print_string fmt \" \";\n tag_string fmt p.closing_style cl\n\n\n (* Printing a label:value pair.\n\n The opening bracket stays on the same line as the key, no matter what,\n and the closing bracket is either on the same line\n or vertically aligned with the beginning of the key.\n *)\n and fprint_pair fmt ((lab, lp) as label) x =\n match x with\n List ((op, sep, cl, p), l) when p.stick_to_label && p.align_closing ->\n fprint_list fmt (Some label) (op, sep, cl, p) l\n\n | _ ->\n let indent = lp.indent_after_label in\n pp_open_hvbox fmt 0;\n\n open_tag fmt lp.label_style;\n fprint_t fmt lab;\n close_tag fmt lp.label_style;\n\n (match lp.label_break with\n | `Auto ->\n if lp.space_after_label then\n pp_print_break fmt 1 indent\n else\n pp_print_break fmt 0 indent\n | `Always\n | `Always_rec ->\n pp_force_newline fmt ();\n pp_print_string fmt (String.make indent ' ')\n | `Never ->\n if lp.space_after_label then\n pp_print_char fmt ' '\n else\n ()\n );\n fprint_t fmt x;\n pp_close_box fmt ()\n\n let to_formatter fmt x =\n let x = rewrite x in\n fprint_t fmt x;\n pp_print_flush fmt ()\n\n let to_buffer ?(escape = `None) ?(styles = []) buf x =\n let fmt = Format.formatter_of_buffer buf in\n define_styles fmt escape styles;\n to_formatter fmt x\n\n let to_string ?escape ?styles x =\n let buf = Buffer.create 500 in\n to_buffer ?escape ?styles buf x;\n Buffer.contents buf\n\n let to_channel ?(escape = `None) ?(styles = []) oc x =\n let fmt = formatter_of_out_channel oc in\n define_styles fmt escape styles;\n to_formatter fmt x\n\n let to_stdout ?escape ?styles x = to_channel ?escape ?styles stdout x\n let to_stderr ?escape ?styles x = to_channel ?escape ?styles stderr x\n\nend\n\n\n\n\nmodule Compact =\nstruct\n open Printf\n\n let rec fprint_t buf = function\n Atom (s, _) -> Buffer.add_string buf s\n | List (param, l) -> fprint_list buf param l\n | Label (label, x) -> fprint_pair buf label x\n | Custom f ->\n (* Will most likely not be compact *)\n let fmt = formatter_of_buffer buf in\n f fmt;\n pp_print_flush fmt ()\n\n and fprint_list buf (op, sep, cl, _) = function\n [] -> bprintf buf \"%s%s\" op cl\n | x :: tl ->\n Buffer.add_string buf op;\n fprint_t buf x;\n List.iter (\n fun x ->\n Buffer.add_string buf sep;\n fprint_t buf x\n ) tl;\n Buffer.add_string buf cl\n\n and fprint_pair buf (label, _) x =\n fprint_t buf label;\n fprint_t buf x\n\n\n let to_buffer buf x = fprint_t buf x\n\n let to_string x =\n let buf = Buffer.create 500 in\n to_buffer buf x;\n Buffer.contents buf\n\n let to_formatter fmt x =\n let s = to_string x in\n Format.fprintf fmt \"%s\" s;\n pp_print_flush fmt ()\n\n let to_channel oc x =\n let buf = Buffer.create 500 in\n to_buffer buf x;\n Buffer.output_buffer oc buf\n\n let to_stdout x = to_channel stdout x\n let to_stderr x = to_channel stderr x\nend\n\n\n\n\n(* Obsolete *)\nmodule Param =\nstruct\n let list_true = {\n space_after_opening = true;\n space_after_separator = true;\n space_before_separator = true;\n separators_stick_left = true;\n space_before_closing = true;\n stick_to_label = true;\n align_closing = true;\n wrap_body = `Wrap_atoms;\n indent_body = 2;\n list_style = None;\n opening_style = None;\n body_style = None;\n separator_style = None;\n closing_style = None;\n }\n\n let list_false = {\n space_after_opening = false;\n space_after_separator = false;\n space_before_separator = false;\n separators_stick_left = false;\n space_before_closing = false;\n stick_to_label = false;\n align_closing = false;\n wrap_body = `Wrap_atoms;\n indent_body = 2;\n list_style = None;\n opening_style = None;\n body_style = None;\n separator_style = None;\n closing_style = None;\n }\n\n let label_true = {\n label_break = `Auto;\n space_after_label = true;\n indent_after_label = 2;\n label_style = None;\n }\n\n let label_false = {\n label_break = `Auto;\n space_after_label = false;\n indent_after_label = 2;\n label_style = None;\n }\nend\n","# 1 \"common.ml\"\nlet version = \"1.7.0\"\n\nexception Json_error of string\n\nlet json_error s = raise (Json_error s)\n\nexception End_of_array\nexception End_of_object\nexception End_of_tuple\nexception End_of_input\n\ntype in_param = {\n string_buf : Buffer.t\n}\n\nlet create_in_param ?(len = 256) () = {\n string_buf = Buffer.create len\n}\n\n\nlet utf8_of_code buf x =\n let add = Bi_outbuf.add_char in\n\n (* Straight <= doesn't work with signed 31-bit ints *)\n let maxbits n x = x lsr n = 0 in\n\n if maxbits 7 x then\n (* 7 *)\n add buf (Char.chr x)\n else if maxbits 11 x then (\n (* 5 + 6 *)\n add buf (Char.chr (0b11000000 lor ((x lsr 6) land 0b00011111)));\n add buf (Char.chr (0b10000000 lor (x land 0b00111111)))\n )\n else if maxbits 16 x then (\n (* 4 + 6 + 6 *)\n add buf (Char.chr (0b11100000 lor ((x lsr 12) land 0b00001111)));\n add buf (Char.chr (0b10000000 lor ((x lsr 6) land 0b00111111)));\n add buf (Char.chr (0b10000000 lor (x land 0b00111111)))\n )\n else if maxbits 21 x then (\n (* 3 + 6 + 6 + 6 *)\n add buf (Char.chr (0b11110000 lor ((x lsr 18) land 0b00000111)));\n add buf (Char.chr (0b10000000 lor ((x lsr 12) land 0b00111111)));\n add buf (Char.chr (0b10000000 lor ((x lsr 6) land 0b00111111)));\n add buf (Char.chr (0b10000000 lor (x land 0b00111111)));\n )\n else if maxbits 26 x then (\n (* 2 + 6 + 6 + 6 + 6 *)\n add buf (Char.chr (0b11111000 lor ((x lsr 24) land 0b00000011)));\n add buf (Char.chr (0b10000000 lor ((x lsr 18) land 0b00111111)));\n add buf (Char.chr (0b10000000 lor ((x lsr 12) land 0b00111111)));\n add buf (Char.chr (0b10000000 lor ((x lsr 6) land 0b00111111)));\n add buf (Char.chr (0b10000000 lor (x land 0b00111111)));\n )\n else (\n assert (maxbits 31 x);\n (* 1 + 6 + 6 + 6 + 6 + 6 *)\n add buf (Char.chr (0b11111100 lor ((x lsr 30) land 0b00000001)));\n add buf (Char.chr (0b10000000 lor ((x lsr 24) land 0b00111111)));\n add buf (Char.chr (0b10000000 lor ((x lsr 18) land 0b00111111)));\n add buf (Char.chr (0b10000000 lor ((x lsr 12) land 0b00111111)));\n add buf (Char.chr (0b10000000 lor ((x lsr 6) land 0b00111111)));\n add buf (Char.chr (0b10000000 lor (x land 0b00111111)));\n )\n\nlet code_of_surrogate_pair i j =\n let high10 = i - 0xD800 in\n let low10 = j - 0xDC00 in\n 0x10000 + ((high10 lsl 10) lor low10)\n\nlet utf8_of_surrogate_pair buf i j =\n utf8_of_code buf (code_of_surrogate_pair i j)\n\nlet is_object_or_array x =\n match x with\n `List _\n | `Assoc _ -> true\n | _ -> false\n\n\ntype lexer_state = {\n buf : Bi_outbuf.t;\n (* Buffer used to accumulate substrings *)\n\n mutable lnum : int;\n (* Current line number (starting from 1) *)\n\n mutable bol : int;\n (* Absolute position of the first character of the current line\n (starting from 0) *)\n\n mutable fname : string option;\n (* Name describing the input file *)\n}\n\nmodule Lexer_state =\nstruct\n type t = lexer_state = {\n buf : Bi_outbuf.t;\n mutable lnum : int;\n mutable bol : int;\n mutable fname : string option;\n }\nend\n\nlet init_lexer ?buf ?fname ?(lnum = 1) () =\n let buf =\n match buf with\n\tNone -> Bi_outbuf.create 256\n | Some buf -> buf\n in\n {\n buf = buf;\n lnum = lnum;\n bol = 0;\n fname = fname\n }\n\n# 1 \"type.ml\"\n(** {3 Type of the JSON tree} *)\n\ntype t =\n [\n | `Null\n | `Bool of bool\n \n# 8 \"type.ml\"\n | `Int of int\n \n# 11 \"type.ml\"\n | `Intlit of string\n \n# 14 \"type.ml\"\n | `Float of float\n \n# 17 \"type.ml\"\n | `Floatlit of string\n \n# 20 \"type.ml\"\n | `String of string\n \n# 23 \"type.ml\"\n | `Stringlit of string\n \n# 25 \"type.ml\"\n | `Assoc of (string * t) list\n | `List of t list\n \n# 28 \"type.ml\"\n | `Tuple of t list\n \n# 31 \"type.ml\"\n | `Variant of (string * t option)\n \n# 33 \"type.ml\"\n ]\n(**\nAll possible cases defined in Yojson:\n- `Null: JSON null\n- `Bool of bool: JSON boolean\n- `Int of int: JSON number without decimal point or exponent.\n- `Intlit of string: JSON number without decimal point or exponent,\n\t preserved as a string.\n- `Float of float: JSON number, Infinity, -Infinity or NaN.\n- `Floatlit of string: JSON number, Infinity, -Infinity or NaN,\n\t preserved as a string.\n- `String of string: JSON string. Bytes in the range 128-255 are preserved\n\t as-is without encoding validation for both reading\n\t and writing.\n- `Stringlit of string: JSON string literal including the double quotes.\n- `Assoc of (string * json) list: JSON object.\n- `List of json list: JSON array.\n- `Tuple of json list: Tuple (non-standard extension of JSON).\n\t Syntax: [(\"abc\", 123)].\n- `Variant of (string * json option): Variant (non-standard extension of JSON).\n\t Syntax: [<\"Foo\">] or [<\"Bar\":123>].\n*)\n\ntype json = t [@@deprecated \"json types are being renamed and will be removed in the next Yojson major version. Use type t instead\"]\n(**\n * Compatibility type alias for type `t`\n *)\n\n(*\n Note to adventurers: ocamldoc does not support inline comments\n on each polymorphic variant, and cppo doesn't allow to concatenate\n comments, so it would be complicated to document only the\n cases that are preserved by cppo in the type definition.\n*)\n# 12 \"yojson.cppo.ml\"\ntype json_max = t\n# 1 \"write.ml\"\n(* included: type.ml *)\n\nlet hex n =\n Char.chr (\n if n < 10 then n + 48\n else n + 87\n )\n\nlet write_special src start stop ob str =\n Bi_outbuf.add_substring ob src !start (stop - !start);\n Bi_outbuf.add_string ob str;\n start := stop + 1\n\nlet write_control_char src start stop ob c =\n Bi_outbuf.add_substring ob src !start (stop - !start);\n let i = Bi_outbuf.alloc ob 6 in\n let dst = ob.o_s in\n Bytes.blit_string \"\\\\u00\" 0 dst i 4;\n Bytes.set dst (i+4) (hex (Char.code c lsr 4));\n Bytes.set dst (i+5) (hex (Char.code c land 0xf));\n start := stop + 1\n\nlet finish_string src start ob =\n try\n Bi_outbuf.add_substring ob src !start (String.length src - !start)\n with exc ->\n Printf.eprintf \"src=%S start=%i len=%i\\n%!\"\n src !start (String.length src - !start);\n raise exc\n\nlet write_string_body ob s =\n let start = ref 0 in\n for i = 0 to String.length s - 1 do\n match s.[i] with\n '\"' -> write_special s start i ob \"\\\\\\\"\"\n | '\\\\' -> write_special s start i ob \"\\\\\\\\\"\n | '\\b' -> write_special s start i ob \"\\\\b\"\n | '\\012' -> write_special s start i ob \"\\\\f\"\n | '\\n' -> write_special s start i ob \"\\\\n\"\n | '\\r' -> write_special s start i ob \"\\\\r\"\n | '\\t' -> write_special s start i ob \"\\\\t\"\n | '\\x00'..'\\x1F'\n | '\\x7F' as c -> write_control_char s start i ob c\n | _ -> ()\n done;\n finish_string s start ob\n\nlet write_string ob s =\n Bi_outbuf.add_char ob '\"';\n write_string_body ob s;\n Bi_outbuf.add_char ob '\"'\n\nlet json_string_of_string s =\n let ob = Bi_outbuf.create 10 in\n write_string ob s;\n Bi_outbuf.contents ob\n\nlet test_string () =\n let s = Bytes.create 256 in\n for i = 0 to 255 do\n Bytes.set s i (Char.chr i)\n done;\n json_string_of_string (Bytes.to_string s)\n\n\nlet write_null ob () =\n Bi_outbuf.add_string ob \"null\"\n\nlet write_bool ob x =\n Bi_outbuf.add_string ob (if x then \"true\" else \"false\")\n\n\nlet max_digits =\n max\n (String.length (string_of_int max_int))\n (String.length (string_of_int min_int))\n\nlet dec n =\n Char.chr (n + 48)\n\nlet rec write_digits s pos x =\n if x = 0 then pos\n else\n let d = x mod 10 in\n let pos = write_digits s pos (x / 10) in\n Bytes.set s pos (dec (abs d));\n pos + 1\n\nlet write_int ob x =\n Bi_outbuf.extend ob max_digits;\n if x > 0 then\n ob.o_len <- write_digits ob.o_s ob.o_len x\n else if x < 0 then (\n let s = ob.o_s in\n let pos = ob.o_len in\n Bytes.set s pos '-';\n ob.o_len <- write_digits s (pos + 1) x\n )\n else\n Bi_outbuf.add_char ob '0'\n\n\nlet json_string_of_int i =\n string_of_int i\n\n\n(*\n Ensure that the float is not printed as an int.\n This is not required by JSON, but useful in order to guarantee\n reversibility.\n*)\nlet float_needs_period s =\n try\n for i = 0 to String.length s - 1 do\n match s.[i] with\n '0'..'9' | '-' -> ()\n | _ -> raise Exit\n done;\n true\n with Exit ->\n false\n\n(*\n Both write_float_fast and write_float guarantee\n that a sufficient number of digits are printed in order to\n allow reversibility.\n\n The _fast version is faster but often produces unnecessarily long numbers.\n*)\nlet write_float_fast ob x =\n match classify_float x with\n FP_nan ->\n Bi_outbuf.add_string ob \"NaN\"\n | FP_infinite ->\n Bi_outbuf.add_string ob (if x > 0. then \"Infinity\" else \"-Infinity\")\n | _ ->\n let s = Printf.sprintf \"%.17g\" x in\n Bi_outbuf.add_string ob s;\n if float_needs_period s then\n Bi_outbuf.add_string ob \".0\"\n\nlet write_float ob x =\n match classify_float x with\n FP_nan ->\n Bi_outbuf.add_string ob \"NaN\"\n | FP_infinite ->\n Bi_outbuf.add_string ob (if x > 0. then \"Infinity\" else \"-Infinity\")\n | _ ->\n let s1 = Printf.sprintf \"%.16g\" x in\n let s =\n if float_of_string s1 = x then s1\n else Printf.sprintf \"%.17g\" x\n in\n Bi_outbuf.add_string ob s;\n if float_needs_period s then\n Bi_outbuf.add_string ob \".0\"\n\nlet write_normal_float_prec significant_figures ob x =\n let open Printf in\n let s =\n match significant_figures with\n 1 -> sprintf \"%.1g\" x\n | 2 -> sprintf \"%.2g\" x\n | 3 -> sprintf \"%.3g\" x\n | 4 -> sprintf \"%.4g\" x\n | 5 -> sprintf \"%.5g\" x\n | 6 -> sprintf \"%.6g\" x\n | 7 -> sprintf \"%.7g\" x\n | 8 -> sprintf \"%.8g\" x\n | 9 -> sprintf \"%.9g\" x\n | 10 -> sprintf \"%.10g\" x\n | 11 -> sprintf \"%.11g\" x\n | 12 -> sprintf \"%.12g\" x\n | 13 -> sprintf \"%.13g\" x\n | 14 -> sprintf \"%.14g\" x\n | 15 -> sprintf \"%.15g\" x\n | 16 -> sprintf \"%.16g\" x\n | _ -> sprintf \"%.17g\" x\n in\n Bi_outbuf.add_string ob s;\n if float_needs_period s then\n Bi_outbuf.add_string ob \".0\"\n\nlet write_float_prec significant_figures ob x =\n match classify_float x with\n FP_nan ->\n Bi_outbuf.add_string ob \"NaN\"\n | FP_infinite ->\n Bi_outbuf.add_string ob (if x > 0. then \"Infinity\" else \"-Infinity\")\n | _ ->\n write_normal_float_prec significant_figures ob x\n\nlet json_string_of_float x =\n let ob = Bi_outbuf.create 20 in\n write_float ob x;\n Bi_outbuf.contents ob\n\n\nlet write_std_float_fast ob x =\n match classify_float x with\n FP_nan ->\n json_error \"NaN value not allowed in standard JSON\"\n | FP_infinite ->\n json_error\n (if x > 0. then\n \"Infinity value not allowed in standard JSON\"\n else\n \"-Infinity value not allowed in standard JSON\")\n | _ ->\n let s = Printf.sprintf \"%.17g\" x in\n Bi_outbuf.add_string ob s;\n if float_needs_period s then\n Bi_outbuf.add_string ob \".0\"\n\nlet write_std_float ob x =\n match classify_float x with\n FP_nan ->\n json_error \"NaN value not allowed in standard JSON\"\n | FP_infinite ->\n json_error\n (if x > 0. then\n \"Infinity value not allowed in standard JSON\"\n else\n \"-Infinity value not allowed in standard JSON\")\n | _ ->\n let s1 = Printf.sprintf \"%.16g\" x in\n let s =\n if float_of_string s1 = x then s1\n else Printf.sprintf \"%.17g\" x\n in\n Bi_outbuf.add_string ob s;\n if float_needs_period s then\n Bi_outbuf.add_string ob \".0\"\n\nlet write_std_float_prec significant_figures ob x =\n match classify_float x with\n FP_nan ->\n json_error \"NaN value not allowed in standard JSON\"\n | FP_infinite ->\n json_error\n (if x > 0. then\n \"Infinity value not allowed in standard JSON\"\n else\n \"-Infinity value not allowed in standard JSON\")\n | _ ->\n write_normal_float_prec significant_figures ob x\n\nlet std_json_string_of_float x =\n let ob = Bi_outbuf.create 20 in\n write_std_float ob x;\n Bi_outbuf.contents ob\n\n\nlet test_float () =\n let l = [ 0.; 1.; -1. ] in\n let l = l @ List.map (fun x -> 2. *. x +. 1.) l in\n let l = l @ List.map (fun x -> x /. sqrt 2.) l in\n let l = l @ List.map (fun x -> x *. sqrt 3.) l in\n let l = l @ List.map cos l in\n let l = l @ List.map (fun x -> x *. 1.23e50) l in\n let l = l @ [ infinity; neg_infinity ] in\n List.iter (\n fun x ->\n let s = Printf.sprintf \"%.17g\" x in\n let y = float_of_string s in\n Printf.printf \"%g %g %S %B\\n\" x y s (x = y)\n )\n l\n\n(*\nlet () = test_float ()\n*)\n\nlet write_intlit = Bi_outbuf.add_string\nlet write_floatlit = Bi_outbuf.add_string\nlet write_stringlit = Bi_outbuf.add_string\n\nlet rec iter2_aux f_elt f_sep x = function\n [] -> ()\n | y :: l ->\n f_sep x;\n f_elt x y;\n iter2_aux f_elt f_sep x l\n\nlet iter2 f_elt f_sep x = function\n [] -> ()\n | y :: l ->\n f_elt x y;\n iter2_aux f_elt f_sep x l\n\nlet f_sep ob =\n Bi_outbuf.add_char ob ','\n\nlet rec write_json ob (x : t) =\n match x with\n `Null -> write_null ob ()\n | `Bool b -> write_bool ob b\n \n# 299 \"write.ml\"\n | `Int i -> write_int ob i\n \n# 302 \"write.ml\"\n | `Intlit s -> Bi_outbuf.add_string ob s\n \n# 305 \"write.ml\"\n | `Float f -> write_float ob f\n \n# 308 \"write.ml\"\n | `Floatlit s -> Bi_outbuf.add_string ob s\n \n# 311 \"write.ml\"\n | `String s -> write_string ob s\n \n# 314 \"write.ml\"\n | `Stringlit s -> Bi_outbuf.add_string ob s\n \n# 316 \"write.ml\"\n | `Assoc l -> write_assoc ob l\n | `List l -> write_list ob l\n \n# 319 \"write.ml\"\n | `Tuple l -> write_tuple ob l\n \n# 322 \"write.ml\"\n | `Variant (s, o) -> write_variant ob s o\n\n# 325 \"write.ml\"\nand write_assoc ob l =\n let f_elt ob (s, x) =\n write_string ob s;\n Bi_outbuf.add_char ob ':';\n write_json ob x\n in\n Bi_outbuf.add_char ob '{';\n iter2 f_elt f_sep ob l;\n Bi_outbuf.add_char ob '}';\n\nand write_list ob l =\n Bi_outbuf.add_char ob '[';\n iter2 write_json f_sep ob l;\n Bi_outbuf.add_char ob ']'\n\n# 341 \"write.ml\"\nand write_tuple ob l =\n Bi_outbuf.add_char ob '(';\n iter2 write_json f_sep ob l;\n Bi_outbuf.add_char ob ')'\n\n# 348 \"write.ml\"\nand write_variant ob s o =\n Bi_outbuf.add_char ob '<';\n write_string ob s;\n (match o with\n None -> ()\n | Some x ->\n Bi_outbuf.add_char ob ':';\n write_json ob x\n );\n Bi_outbuf.add_char ob '>'\n\n# 360 \"write.ml\"\nlet write_t = write_json\n\nlet rec write_std_json ob (x : t) =\n match x with\n `Null -> write_null ob ()\n | `Bool b -> write_bool ob b\n \n# 367 \"write.ml\"\n | `Int i -> write_int ob i\n \n# 370 \"write.ml\"\n | `Intlit s -> Bi_outbuf.add_string ob s\n \n# 373 \"write.ml\"\n | `Float f -> write_std_float ob f\n \n# 376 \"write.ml\"\n | `Floatlit s -> Bi_outbuf.add_string ob s\n \n# 379 \"write.ml\"\n | `String s -> write_string ob s\n \n# 382 \"write.ml\"\n | `Stringlit s -> Bi_outbuf.add_string ob s\n \n# 384 \"write.ml\"\n | `Assoc l -> write_std_assoc ob l\n | `List l -> write_std_list ob l\n \n# 387 \"write.ml\"\n | `Tuple l -> write_std_tuple ob l\n \n# 390 \"write.ml\"\n | `Variant (s, o) -> write_std_variant ob s o\n\n# 393 \"write.ml\"\nand write_std_assoc ob l =\n let f_elt ob (s, x) =\n write_string ob s;\n Bi_outbuf.add_char ob ':';\n write_std_json ob x\n in\n Bi_outbuf.add_char ob '{';\n iter2 f_elt f_sep ob l;\n Bi_outbuf.add_char ob '}';\n\nand write_std_list ob l =\n Bi_outbuf.add_char ob '[';\n iter2 write_std_json f_sep ob l;\n Bi_outbuf.add_char ob ']'\n\nand write_std_tuple ob l =\n Bi_outbuf.add_char ob '[';\n iter2 write_std_json f_sep ob l;\n Bi_outbuf.add_char ob ']'\n\n# 414 \"write.ml\"\nand write_std_variant ob s o =\n match o with\n None -> write_string ob s\n | Some x ->\n Bi_outbuf.add_char ob '[';\n write_string ob s;\n Bi_outbuf.add_char ob ',';\n write_std_json ob x;\n Bi_outbuf.add_char ob ']'\n\n\n# 426 \"write.ml\"\nlet to_outbuf ?(std = false) ob x =\n if std then (\n if not (is_object_or_array x) then\n json_error \"Root is not an object or array\"\n else\n write_std_json ob x\n )\n else\n write_json ob x\n\n\nlet to_string ?buf ?(len = 256) ?std x =\n let ob =\n match buf with\n None -> Bi_outbuf.create len\n | Some ob ->\n Bi_outbuf.clear ob;\n ob\n in\n to_outbuf ?std ob x;\n let s = Bi_outbuf.contents ob in\n Bi_outbuf.clear ob;\n s\n\nlet to_channel ?buf ?len ?std oc x =\n let ob =\n match buf with\n None -> Bi_outbuf.create_channel_writer ?len oc\n | Some ob -> ob\n in\n to_outbuf ?std ob x;\n Bi_outbuf.flush_channel_writer ob\n\nlet to_output ?buf ?len ?std out x =\n let ob =\n match buf with\n None -> Bi_outbuf.create_output_writer ?len out\n | Some ob -> ob\n in\n to_outbuf ?std ob x;\n Bi_outbuf.flush_output_writer ob\n\nlet to_file ?len ?std file x =\n let oc = open_out file in\n try\n to_channel ?len ?std oc x;\n close_out oc\n with e ->\n close_out_noerr oc;\n raise e\n\nlet stream_to_outbuf ?std ob st =\n Stream.iter (to_outbuf ?std ob) st\n\nlet stream_to_string ?buf ?(len = 256) ?std st =\n let ob =\n match buf with\n None -> Bi_outbuf.create len\n | Some ob ->\n Bi_outbuf.clear ob;\n ob\n in\n stream_to_outbuf ?std ob st;\n let s = Bi_outbuf.contents ob in\n Bi_outbuf.clear ob;\n s\n\nlet stream_to_channel ?buf ?len ?std oc st =\n let ob =\n match buf with\n None -> Bi_outbuf.create_channel_writer ?len oc\n | Some ob -> ob\n in\n stream_to_outbuf ?std ob st;\n Bi_outbuf.flush_channel_writer ob\n\nlet stream_to_file ?len ?std file st =\n let oc = open_out file in\n try\n stream_to_channel ?len ?std oc st;\n close_out oc\n with e ->\n close_out_noerr oc;\n raise e\n\n\nlet rec sort = function\n | `Assoc l ->\n let l = List.rev (List.rev_map (fun (k, v) -> (k, sort v)) l) in\n `Assoc (List.stable_sort (fun (a, _) (b, _) -> String.compare a b) l)\n | `List l ->\n `List (List.rev (List.rev_map sort l))\n \n# 519 \"write.ml\"\n | `Tuple l ->\n `Tuple (List.rev (List.rev_map sort l))\n \n# 523 \"write.ml\"\n | `Variant (k, Some v) as x ->\n let v' = sort v in\n if v == v' then x\n else\n `Variant (k, Some v')\n \n# 529 \"write.ml\"\n | x -> x\n# 1 \"monomorphic.ml\"\nlet rec pp fmt =\n function\n | `Null -> Format.pp_print_string fmt \"`Null\"\n | `Bool x ->\n Format.fprintf fmt \"`Bool (@[\";\n Format.fprintf fmt \"%B\" x;\n Format.fprintf fmt \"@])\"\n \n# 9 \"monomorphic.ml\"\n | `Int x ->\n Format.fprintf fmt \"`Int (@[\";\n Format.fprintf fmt \"%d\" x;\n Format.fprintf fmt \"@])\"\n \n# 15 \"monomorphic.ml\"\n | `Intlit x ->\n Format.fprintf fmt \"`Intlit (@[\";\n Format.fprintf fmt \"%S\" x;\n Format.fprintf fmt \"@])\"\n \n# 21 \"monomorphic.ml\"\n | `Float x ->\n Format.fprintf fmt \"`Float (@[\";\n Format.fprintf fmt \"%F\" x;\n Format.fprintf fmt \"@])\"\n \n# 27 \"monomorphic.ml\"\n | `Floatlit x ->\n Format.fprintf fmt \"`Floatlit (@[\";\n Format.fprintf fmt \"%S\" x;\n Format.fprintf fmt \"@])\"\n \n# 33 \"monomorphic.ml\"\n | `String x ->\n Format.fprintf fmt \"`String (@[\";\n Format.fprintf fmt \"%S\" x;\n Format.fprintf fmt \"@])\"\n \n# 39 \"monomorphic.ml\"\n | `Stringlit x ->\n Format.fprintf fmt \"`Stringlit (@[\";\n Format.fprintf fmt \"%S\" x;\n Format.fprintf fmt \"@])\"\n \n# 44 \"monomorphic.ml\"\n | `Assoc xs ->\n Format.fprintf fmt \"`Assoc (@[\";\n Format.fprintf fmt \"@[<2>[\";\n ignore (List.fold_left\n (fun sep (key, value) ->\n if sep then\n Format.fprintf fmt \";@ \";\n Format.fprintf fmt \"(@[\";\n Format.fprintf fmt \"%S\" key;\n Format.fprintf fmt \",@ \";\n pp fmt value;\n Format.fprintf fmt \"@])\";\n true) false xs);\n Format.fprintf fmt \"@,]@]\";\n Format.fprintf fmt \"@])\"\n | `List xs ->\n Format.fprintf fmt \"`List (@[\";\n Format.fprintf fmt \"@[<2>[\";\n ignore (List.fold_left\n (fun sep x ->\n if sep then\n Format.fprintf fmt \";@ \";\n pp fmt x;\n true) false xs);\n Format.fprintf fmt \"@,]@]\";\n Format.fprintf fmt \"@])\"\n \n# 71 \"monomorphic.ml\"\n | `Tuple tup ->\n Format.fprintf fmt \"`Tuple (@[\";\n Format.fprintf fmt \"@[<2>[\";\n ignore (List.fold_left\n (fun sep e ->\n if sep then\n Format.fprintf fmt \";@ \";\n pp fmt e;\n true) false tup);\n Format.fprintf fmt \"@,]@]\";\n Format.fprintf fmt \"@])\"\n \n# 84 \"monomorphic.ml\"\n | `Variant (name, value) ->\n Format.fprintf fmt \"`Variant (@[\";\n Format.fprintf fmt \"(@[\";\n Format.fprintf fmt \"%S\" name;\n Format.fprintf fmt \",@ \";\n (match value with\n | None -> Format.pp_print_string fmt \"None\"\n | Some x ->\n Format.pp_print_string fmt \"(Some \";\n pp fmt x;\n Format.pp_print_string fmt \")\");\n Format.fprintf fmt \"@])\";\n Format.fprintf fmt \"@])\"\n\n# 99 \"monomorphic.ml\"\nlet show x =\n Format.asprintf \"%a\" pp x\n\nlet rec equal a b =\n match a, b with\n | `Null, `Null -> true\n | `Bool a, `Bool b -> a = b\n \n# 107 \"monomorphic.ml\"\n | `Int a, `Int b -> a = b\n \n# 110 \"monomorphic.ml\"\n | `Intlit a, `Intlit b -> a = b\n \n# 113 \"monomorphic.ml\"\n | `Float a, `Float b -> a = b\n \n# 116 \"monomorphic.ml\"\n | `Floatlit a, `Floatlit b -> a = b\n \n# 119 \"monomorphic.ml\"\n | `String a, `String b -> a = b\n \n# 122 \"monomorphic.ml\"\n | `Stringlit a, `Stringlit b -> a = b\n \n# 124 \"monomorphic.ml\"\n | `Assoc xs, `Assoc ys ->\n let compare_keys = fun (key, _) (key', _) -> String.compare key key' in\n let xs = List.stable_sort compare_keys xs in\n let ys = List.stable_sort compare_keys ys in\n (match List.for_all2 (fun (key, value) (key', value') ->\n match key = key' with\n | false -> false\n | true -> equal value value') xs ys with\n | result -> result\n | exception Invalid_argument _ ->\n (* the lists were of different lengths, thus unequal *)\n false)\n \n# 137 \"monomorphic.ml\"\n | `Tuple xs, `Tuple ys\n \n# 139 \"monomorphic.ml\"\n | `List xs, `List ys ->\n (match List.for_all2 equal xs ys with\n | result -> result\n | exception Invalid_argument _ ->\n (* the lists were of different lengths, thus unequal *)\n false)\n \n# 146 \"monomorphic.ml\"\n | `Variant (name, value), `Variant (name', value') ->\n (match name = name' with\n | false -> false\n | true ->\n match value, value' with\n | None, None -> true\n | Some x, Some y -> equal x y\n | _ -> false)\n \n# 155 \"monomorphic.ml\"\n | _ -> false\n# 15 \"yojson.cppo.ml\"\nmodule Pretty =\nstruct\n# 1 \"pretty.ml\"\nopen Printf\n\nlet array = Easy_format.list\nlet record = Easy_format.list\nlet tuple = { Easy_format.list with\n space_after_opening = false;\n space_before_closing = false;\n align_closing = false }\nlet variant = { Easy_format.list with\n space_before_closing = false; }\n\nlet rec format std (x : t) =\n match x with\n `Null -> Easy_format.Atom (\"null\", Easy_format.atom)\n | `Bool x -> Easy_format.Atom ((if x then \"true\" else \"false\"), Easy_format.atom)\n | `Int x -> Easy_format.Atom (json_string_of_int x, Easy_format.atom)\n | `Float x ->\n let s =\n if std then std_json_string_of_float x\n else json_string_of_float x\n in\n Easy_format.Atom (s, Easy_format.atom)\n | `String s -> Easy_format.Atom (json_string_of_string s, Easy_format.atom)\n | `Intlit s\n | `Floatlit s\n | `Stringlit s -> Easy_format.Atom (s, Easy_format.atom)\n | `List [] -> Easy_format.Atom (\"[]\", Easy_format.atom)\n | `List l -> Easy_format.List ((\"[\", \",\", \"]\", array), List.map (format std) l)\n | `Assoc [] -> Easy_format.Atom (\"{}\", Easy_format.atom)\n | `Assoc l -> Easy_format.List ((\"{\", \",\", \"}\", record), List.map (format_field std) l)\n | `Tuple l ->\n if std then\n format std (`List l)\n else\n if l = [] then\n Easy_format.Atom (\"()\", Easy_format.atom)\n else\n Easy_format.List ((\"(\", \",\", \")\", tuple), List.map (format std) l)\n\n | `Variant (s, None) ->\n if std then\n format std (`String s)\n else\n Easy_format.Atom (\"<\" ^ json_string_of_string s ^ \">\", Easy_format.atom)\n\n | `Variant (s, Some x) ->\n if std then\n format std (`List [ `String s; x ])\n else\n let op = \"<\" ^ json_string_of_string s ^ \":\" in\n Easy_format.List ((op, \"\", \">\", variant), [format std x])\n\nand format_field std (name, x) =\n let s = sprintf \"%s:\" (json_string_of_string name) in\n Easy_format.Label ((Easy_format.Atom (s, Easy_format.atom), Easy_format.label), format std x)\n\n\nlet format ?(std = false) x =\n if std && not (is_object_or_array x) then\n json_error\n \"Root is not an object or array as requested by the JSON standard\"\n else\n format std (x :> t)\n\nlet to_string ?std x =\n Easy_format.Pretty.to_string (format ?std x)\n\nlet to_channel ?std oc x =\n Easy_format.Pretty.to_channel oc (format ?std x)\n# 18 \"yojson.cppo.ml\"\nend\n# 1 \"write2.ml\"\nlet pretty_format ?std (x : t) =\n Pretty.format ?std (x :> json_max)\n\nlet pretty_print ?std out (x : t) =\n Easy_format.Pretty.to_formatter out (pretty_format ?std x)\n\nlet pretty_to_string ?std (x : t) =\n Pretty.to_string ?std (x :> json_max)\n\nlet pretty_to_channel ?std oc (x : t) =\n Pretty.to_channel ?std oc (x :> json_max)\n\n# 29 \"yojson.cppo.ml\"\nmodule Basic =\nstruct\n# 1 \"type.ml\"\n(** {3 Type of the JSON tree} *)\n\ntype t =\n [\n | `Null\n | `Bool of bool\n \n# 8 \"type.ml\"\n | `Int of int\n \n# 14 \"type.ml\"\n | `Float of float\n \n# 20 \"type.ml\"\n | `String of string\n \n# 25 \"type.ml\"\n | `Assoc of (string * t) list\n | `List of t list\n \n# 33 \"type.ml\"\n ]\n(**\nAll possible cases defined in Yojson:\n- `Null: JSON null\n- `Bool of bool: JSON boolean\n- `Int of int: JSON number without decimal point or exponent.\n- `Intlit of string: JSON number without decimal point or exponent,\n\t preserved as a string.\n- `Float of float: JSON number, Infinity, -Infinity or NaN.\n- `Floatlit of string: JSON number, Infinity, -Infinity or NaN,\n\t preserved as a string.\n- `String of string: JSON string. Bytes in the range 128-255 are preserved\n\t as-is without encoding validation for both reading\n\t and writing.\n- `Stringlit of string: JSON string literal including the double quotes.\n- `Assoc of (string * json) list: JSON object.\n- `List of json list: JSON array.\n- `Tuple of json list: Tuple (non-standard extension of JSON).\n\t Syntax: [(\"abc\", 123)].\n- `Variant of (string * json option): Variant (non-standard extension of JSON).\n\t Syntax: [<\"Foo\">] or [<\"Bar\":123>].\n*)\n\ntype json = t [@@deprecated \"json types are being renamed and will be removed in the next Yojson major version. Use type t instead\"]\n(**\n * Compatibility type alias for type `t`\n *)\n\n(*\n Note to adventurers: ocamldoc does not support inline comments\n on each polymorphic variant, and cppo doesn't allow to concatenate\n comments, so it would be complicated to document only the\n cases that are preserved by cppo in the type definition.\n*)\n# 1 \"write.ml\"\n(* included: type.ml *)\n\nlet hex n =\n Char.chr (\n if n < 10 then n + 48\n else n + 87\n )\n\nlet write_special src start stop ob str =\n Bi_outbuf.add_substring ob src !start (stop - !start);\n Bi_outbuf.add_string ob str;\n start := stop + 1\n\nlet write_control_char src start stop ob c =\n Bi_outbuf.add_substring ob src !start (stop - !start);\n let i = Bi_outbuf.alloc ob 6 in\n let dst = ob.o_s in\n Bytes.blit_string \"\\\\u00\" 0 dst i 4;\n Bytes.set dst (i+4) (hex (Char.code c lsr 4));\n Bytes.set dst (i+5) (hex (Char.code c land 0xf));\n start := stop + 1\n\nlet finish_string src start ob =\n try\n Bi_outbuf.add_substring ob src !start (String.length src - !start)\n with exc ->\n Printf.eprintf \"src=%S start=%i len=%i\\n%!\"\n src !start (String.length src - !start);\n raise exc\n\nlet write_string_body ob s =\n let start = ref 0 in\n for i = 0 to String.length s - 1 do\n match s.[i] with\n '\"' -> write_special s start i ob \"\\\\\\\"\"\n | '\\\\' -> write_special s start i ob \"\\\\\\\\\"\n | '\\b' -> write_special s start i ob \"\\\\b\"\n | '\\012' -> write_special s start i ob \"\\\\f\"\n | '\\n' -> write_special s start i ob \"\\\\n\"\n | '\\r' -> write_special s start i ob \"\\\\r\"\n | '\\t' -> write_special s start i ob \"\\\\t\"\n | '\\x00'..'\\x1F'\n | '\\x7F' as c -> write_control_char s start i ob c\n | _ -> ()\n done;\n finish_string s start ob\n\nlet write_string ob s =\n Bi_outbuf.add_char ob '\"';\n write_string_body ob s;\n Bi_outbuf.add_char ob '\"'\n\nlet json_string_of_string s =\n let ob = Bi_outbuf.create 10 in\n write_string ob s;\n Bi_outbuf.contents ob\n\nlet test_string () =\n let s = Bytes.create 256 in\n for i = 0 to 255 do\n Bytes.set s i (Char.chr i)\n done;\n json_string_of_string (Bytes.to_string s)\n\n\nlet write_null ob () =\n Bi_outbuf.add_string ob \"null\"\n\nlet write_bool ob x =\n Bi_outbuf.add_string ob (if x then \"true\" else \"false\")\n\n\nlet max_digits =\n max\n (String.length (string_of_int max_int))\n (String.length (string_of_int min_int))\n\nlet dec n =\n Char.chr (n + 48)\n\nlet rec write_digits s pos x =\n if x = 0 then pos\n else\n let d = x mod 10 in\n let pos = write_digits s pos (x / 10) in\n Bytes.set s pos (dec (abs d));\n pos + 1\n\nlet write_int ob x =\n Bi_outbuf.extend ob max_digits;\n if x > 0 then\n ob.o_len <- write_digits ob.o_s ob.o_len x\n else if x < 0 then (\n let s = ob.o_s in\n let pos = ob.o_len in\n Bytes.set s pos '-';\n ob.o_len <- write_digits s (pos + 1) x\n )\n else\n Bi_outbuf.add_char ob '0'\n\n\nlet json_string_of_int i =\n string_of_int i\n\n\n(*\n Ensure that the float is not printed as an int.\n This is not required by JSON, but useful in order to guarantee\n reversibility.\n*)\nlet float_needs_period s =\n try\n for i = 0 to String.length s - 1 do\n match s.[i] with\n '0'..'9' | '-' -> ()\n | _ -> raise Exit\n done;\n true\n with Exit ->\n false\n\n(*\n Both write_float_fast and write_float guarantee\n that a sufficient number of digits are printed in order to\n allow reversibility.\n\n The _fast version is faster but often produces unnecessarily long numbers.\n*)\nlet write_float_fast ob x =\n match classify_float x with\n FP_nan ->\n Bi_outbuf.add_string ob \"NaN\"\n | FP_infinite ->\n Bi_outbuf.add_string ob (if x > 0. then \"Infinity\" else \"-Infinity\")\n | _ ->\n let s = Printf.sprintf \"%.17g\" x in\n Bi_outbuf.add_string ob s;\n if float_needs_period s then\n Bi_outbuf.add_string ob \".0\"\n\nlet write_float ob x =\n match classify_float x with\n FP_nan ->\n Bi_outbuf.add_string ob \"NaN\"\n | FP_infinite ->\n Bi_outbuf.add_string ob (if x > 0. then \"Infinity\" else \"-Infinity\")\n | _ ->\n let s1 = Printf.sprintf \"%.16g\" x in\n let s =\n if float_of_string s1 = x then s1\n else Printf.sprintf \"%.17g\" x\n in\n Bi_outbuf.add_string ob s;\n if float_needs_period s then\n Bi_outbuf.add_string ob \".0\"\n\nlet write_normal_float_prec significant_figures ob x =\n let open Printf in\n let s =\n match significant_figures with\n 1 -> sprintf \"%.1g\" x\n | 2 -> sprintf \"%.2g\" x\n | 3 -> sprintf \"%.3g\" x\n | 4 -> sprintf \"%.4g\" x\n | 5 -> sprintf \"%.5g\" x\n | 6 -> sprintf \"%.6g\" x\n | 7 -> sprintf \"%.7g\" x\n | 8 -> sprintf \"%.8g\" x\n | 9 -> sprintf \"%.9g\" x\n | 10 -> sprintf \"%.10g\" x\n | 11 -> sprintf \"%.11g\" x\n | 12 -> sprintf \"%.12g\" x\n | 13 -> sprintf \"%.13g\" x\n | 14 -> sprintf \"%.14g\" x\n | 15 -> sprintf \"%.15g\" x\n | 16 -> sprintf \"%.16g\" x\n | _ -> sprintf \"%.17g\" x\n in\n Bi_outbuf.add_string ob s;\n if float_needs_period s then\n Bi_outbuf.add_string ob \".0\"\n\nlet write_float_prec significant_figures ob x =\n match classify_float x with\n FP_nan ->\n Bi_outbuf.add_string ob \"NaN\"\n | FP_infinite ->\n Bi_outbuf.add_string ob (if x > 0. then \"Infinity\" else \"-Infinity\")\n | _ ->\n write_normal_float_prec significant_figures ob x\n\nlet json_string_of_float x =\n let ob = Bi_outbuf.create 20 in\n write_float ob x;\n Bi_outbuf.contents ob\n\n\nlet write_std_float_fast ob x =\n match classify_float x with\n FP_nan ->\n json_error \"NaN value not allowed in standard JSON\"\n | FP_infinite ->\n json_error\n (if x > 0. then\n \"Infinity value not allowed in standard JSON\"\n else\n \"-Infinity value not allowed in standard JSON\")\n | _ ->\n let s = Printf.sprintf \"%.17g\" x in\n Bi_outbuf.add_string ob s;\n if float_needs_period s then\n Bi_outbuf.add_string ob \".0\"\n\nlet write_std_float ob x =\n match classify_float x with\n FP_nan ->\n json_error \"NaN value not allowed in standard JSON\"\n | FP_infinite ->\n json_error\n (if x > 0. then\n \"Infinity value not allowed in standard JSON\"\n else\n \"-Infinity value not allowed in standard JSON\")\n | _ ->\n let s1 = Printf.sprintf \"%.16g\" x in\n let s =\n if float_of_string s1 = x then s1\n else Printf.sprintf \"%.17g\" x\n in\n Bi_outbuf.add_string ob s;\n if float_needs_period s then\n Bi_outbuf.add_string ob \".0\"\n\nlet write_std_float_prec significant_figures ob x =\n match classify_float x with\n FP_nan ->\n json_error \"NaN value not allowed in standard JSON\"\n | FP_infinite ->\n json_error\n (if x > 0. then\n \"Infinity value not allowed in standard JSON\"\n else\n \"-Infinity value not allowed in standard JSON\")\n | _ ->\n write_normal_float_prec significant_figures ob x\n\nlet std_json_string_of_float x =\n let ob = Bi_outbuf.create 20 in\n write_std_float ob x;\n Bi_outbuf.contents ob\n\n\nlet test_float () =\n let l = [ 0.; 1.; -1. ] in\n let l = l @ List.map (fun x -> 2. *. x +. 1.) l in\n let l = l @ List.map (fun x -> x /. sqrt 2.) l in\n let l = l @ List.map (fun x -> x *. sqrt 3.) l in\n let l = l @ List.map cos l in\n let l = l @ List.map (fun x -> x *. 1.23e50) l in\n let l = l @ [ infinity; neg_infinity ] in\n List.iter (\n fun x ->\n let s = Printf.sprintf \"%.17g\" x in\n let y = float_of_string s in\n Printf.printf \"%g %g %S %B\\n\" x y s (x = y)\n )\n l\n\n(*\nlet () = test_float ()\n*)\n\nlet write_intlit = Bi_outbuf.add_string\nlet write_floatlit = Bi_outbuf.add_string\nlet write_stringlit = Bi_outbuf.add_string\n\nlet rec iter2_aux f_elt f_sep x = function\n [] -> ()\n | y :: l ->\n f_sep x;\n f_elt x y;\n iter2_aux f_elt f_sep x l\n\nlet iter2 f_elt f_sep x = function\n [] -> ()\n | y :: l ->\n f_elt x y;\n iter2_aux f_elt f_sep x l\n\nlet f_sep ob =\n Bi_outbuf.add_char ob ','\n\nlet rec write_json ob (x : t) =\n match x with\n `Null -> write_null ob ()\n | `Bool b -> write_bool ob b\n \n# 299 \"write.ml\"\n | `Int i -> write_int ob i\n \n# 305 \"write.ml\"\n | `Float f -> write_float ob f\n \n# 311 \"write.ml\"\n | `String s -> write_string ob s\n \n# 316 \"write.ml\"\n | `Assoc l -> write_assoc ob l\n | `List l -> write_list ob l\n\n# 325 \"write.ml\"\nand write_assoc ob l =\n let f_elt ob (s, x) =\n write_string ob s;\n Bi_outbuf.add_char ob ':';\n write_json ob x\n in\n Bi_outbuf.add_char ob '{';\n iter2 f_elt f_sep ob l;\n Bi_outbuf.add_char ob '}';\n\nand write_list ob l =\n Bi_outbuf.add_char ob '[';\n iter2 write_json f_sep ob l;\n Bi_outbuf.add_char ob ']'\n\n\n\n# 360 \"write.ml\"\nlet write_t = write_json\n\nlet rec write_std_json ob (x : t) =\n match x with\n `Null -> write_null ob ()\n | `Bool b -> write_bool ob b\n \n# 367 \"write.ml\"\n | `Int i -> write_int ob i\n \n# 373 \"write.ml\"\n | `Float f -> write_std_float ob f\n \n# 379 \"write.ml\"\n | `String s -> write_string ob s\n \n# 384 \"write.ml\"\n | `Assoc l -> write_std_assoc ob l\n | `List l -> write_std_list ob l\n\n# 393 \"write.ml\"\nand write_std_assoc ob l =\n let f_elt ob (s, x) =\n write_string ob s;\n Bi_outbuf.add_char ob ':';\n write_std_json ob x\n in\n Bi_outbuf.add_char ob '{';\n iter2 f_elt f_sep ob l;\n Bi_outbuf.add_char ob '}';\n\nand write_std_list ob l =\n Bi_outbuf.add_char ob '[';\n iter2 write_std_json f_sep ob l;\n Bi_outbuf.add_char ob ']'\n\nand write_std_tuple ob l =\n Bi_outbuf.add_char ob '[';\n iter2 write_std_json f_sep ob l;\n Bi_outbuf.add_char ob ']'\n\n\n\n# 426 \"write.ml\"\nlet to_outbuf ?(std = false) ob x =\n if std then (\n if not (is_object_or_array x) then\n json_error \"Root is not an object or array\"\n else\n write_std_json ob x\n )\n else\n write_json ob x\n\n\nlet to_string ?buf ?(len = 256) ?std x =\n let ob =\n match buf with\n None -> Bi_outbuf.create len\n | Some ob ->\n Bi_outbuf.clear ob;\n ob\n in\n to_outbuf ?std ob x;\n let s = Bi_outbuf.contents ob in\n Bi_outbuf.clear ob;\n s\n\nlet to_channel ?buf ?len ?std oc x =\n let ob =\n match buf with\n None -> Bi_outbuf.create_channel_writer ?len oc\n | Some ob -> ob\n in\n to_outbuf ?std ob x;\n Bi_outbuf.flush_channel_writer ob\n\nlet to_output ?buf ?len ?std out x =\n let ob =\n match buf with\n None -> Bi_outbuf.create_output_writer ?len out\n | Some ob -> ob\n in\n to_outbuf ?std ob x;\n Bi_outbuf.flush_output_writer ob\n\nlet to_file ?len ?std file x =\n let oc = open_out file in\n try\n to_channel ?len ?std oc x;\n close_out oc\n with e ->\n close_out_noerr oc;\n raise e\n\nlet stream_to_outbuf ?std ob st =\n Stream.iter (to_outbuf ?std ob) st\n\nlet stream_to_string ?buf ?(len = 256) ?std st =\n let ob =\n match buf with\n None -> Bi_outbuf.create len\n | Some ob ->\n Bi_outbuf.clear ob;\n ob\n in\n stream_to_outbuf ?std ob st;\n let s = Bi_outbuf.contents ob in\n Bi_outbuf.clear ob;\n s\n\nlet stream_to_channel ?buf ?len ?std oc st =\n let ob =\n match buf with\n None -> Bi_outbuf.create_channel_writer ?len oc\n | Some ob -> ob\n in\n stream_to_outbuf ?std ob st;\n Bi_outbuf.flush_channel_writer ob\n\nlet stream_to_file ?len ?std file st =\n let oc = open_out file in\n try\n stream_to_channel ?len ?std oc st;\n close_out oc\n with e ->\n close_out_noerr oc;\n raise e\n\n\nlet rec sort = function\n | `Assoc l ->\n let l = List.rev (List.rev_map (fun (k, v) -> (k, sort v)) l) in\n `Assoc (List.stable_sort (fun (a, _) (b, _) -> String.compare a b) l)\n | `List l ->\n `List (List.rev (List.rev_map sort l))\n \n# 529 \"write.ml\"\n | x -> x\n# 1 \"monomorphic.ml\"\nlet rec pp fmt =\n function\n | `Null -> Format.pp_print_string fmt \"`Null\"\n | `Bool x ->\n Format.fprintf fmt \"`Bool (@[\";\n Format.fprintf fmt \"%B\" x;\n Format.fprintf fmt \"@])\"\n \n# 9 \"monomorphic.ml\"\n | `Int x ->\n Format.fprintf fmt \"`Int (@[\";\n Format.fprintf fmt \"%d\" x;\n Format.fprintf fmt \"@])\"\n \n# 21 \"monomorphic.ml\"\n | `Float x ->\n Format.fprintf fmt \"`Float (@[\";\n Format.fprintf fmt \"%F\" x;\n Format.fprintf fmt \"@])\"\n \n# 33 \"monomorphic.ml\"\n | `String x ->\n Format.fprintf fmt \"`String (@[\";\n Format.fprintf fmt \"%S\" x;\n Format.fprintf fmt \"@])\"\n \n# 44 \"monomorphic.ml\"\n | `Assoc xs ->\n Format.fprintf fmt \"`Assoc (@[\";\n Format.fprintf fmt \"@[<2>[\";\n ignore (List.fold_left\n (fun sep (key, value) ->\n if sep then\n Format.fprintf fmt \";@ \";\n Format.fprintf fmt \"(@[\";\n Format.fprintf fmt \"%S\" key;\n Format.fprintf fmt \",@ \";\n pp fmt value;\n Format.fprintf fmt \"@])\";\n true) false xs);\n Format.fprintf fmt \"@,]@]\";\n Format.fprintf fmt \"@])\"\n | `List xs ->\n Format.fprintf fmt \"`List (@[\";\n Format.fprintf fmt \"@[<2>[\";\n ignore (List.fold_left\n (fun sep x ->\n if sep then\n Format.fprintf fmt \";@ \";\n pp fmt x;\n true) false xs);\n Format.fprintf fmt \"@,]@]\";\n Format.fprintf fmt \"@])\"\n\n# 99 \"monomorphic.ml\"\nlet show x =\n Format.asprintf \"%a\" pp x\n\nlet rec equal a b =\n match a, b with\n | `Null, `Null -> true\n | `Bool a, `Bool b -> a = b\n \n# 107 \"monomorphic.ml\"\n | `Int a, `Int b -> a = b\n \n# 113 \"monomorphic.ml\"\n | `Float a, `Float b -> a = b\n \n# 119 \"monomorphic.ml\"\n | `String a, `String b -> a = b\n \n# 124 \"monomorphic.ml\"\n | `Assoc xs, `Assoc ys ->\n let compare_keys = fun (key, _) (key', _) -> String.compare key key' in\n let xs = List.stable_sort compare_keys xs in\n let ys = List.stable_sort compare_keys ys in\n (match List.for_all2 (fun (key, value) (key', value') ->\n match key = key' with\n | false -> false\n | true -> equal value value') xs ys with\n | result -> result\n | exception Invalid_argument _ ->\n (* the lists were of different lengths, thus unequal *)\n false)\n \n# 139 \"monomorphic.ml\"\n | `List xs, `List ys ->\n (match List.for_all2 equal xs ys with\n | result -> result\n | exception Invalid_argument _ ->\n (* the lists were of different lengths, thus unequal *)\n false)\n \n# 155 \"monomorphic.ml\"\n | _ -> false\n# 1 \"write2.ml\"\nlet pretty_format ?std (x : t) =\n Pretty.format ?std (x :> json_max)\n\nlet pretty_print ?std out (x : t) =\n Easy_format.Pretty.to_formatter out (pretty_format ?std x)\n\nlet pretty_to_string ?std (x : t) =\n Pretty.to_string ?std (x :> json_max)\n\nlet pretty_to_channel ?std oc (x : t) =\n Pretty.to_channel ?std oc (x :> json_max)\n\n# 1 \"lib/read.mll\"\n \n \n# 2 \"lib/read.mll\"\n module Lexing =\n (*\n We override Lexing.engine in order to avoid creating a new position\n record each time a rule is matched.\n This reduces total parsing time by about 31%.\n *)\n struct\n include Lexing\n\n external c_engine : lex_tables -> int -> lexbuf -> int = \"caml_lex_engine\"\n\n let engine tbl state buf =\n let result = c_engine tbl state buf in\n (*\n if result >= 0 then begin\n buf.lex_start_p <- buf.lex_curr_p;\n buf.lex_curr_p <- {buf.lex_curr_p\n with pos_cnum = buf.lex_abs_pos + buf.lex_curr_pos};\n end;\n *)\n result\n end\n\n open Printf\n open Lexing\n\n (* see description in common.mli *)\n type lexer_state = Lexer_state.t = {\n buf : Bi_outbuf.t;\n mutable lnum : int;\n mutable bol : int;\n mutable fname : string option;\n }\n\n let dec c =\n Char.code c - 48\n\n let hex c =\n match c with\n '0'..'9' -> int_of_char c - int_of_char '0'\n | 'a'..'f' -> int_of_char c - int_of_char 'a' + 10\n | 'A'..'F' -> int_of_char c - int_of_char 'A' + 10\n | _ -> assert false\n\n let custom_error descr v lexbuf =\n let offs = lexbuf.lex_abs_pos - 1 in\n let bol = v.bol in\n let pos1 = offs + lexbuf.lex_start_pos - bol - 1 in\n let pos2 = max pos1 (offs + lexbuf.lex_curr_pos - bol) in\n let file_line =\n match v.fname with\n None -> \"Line\"\n | Some s ->\n sprintf \"File %s, line\" s\n in\n let bytes =\n if pos1 = pos2 then\n sprintf \"byte %i\" (pos1+1)\n else\n sprintf \"bytes %i-%i\" (pos1+1) (pos2+1)\n in\n let msg = sprintf \"%s %i, %s:\\n%s\" file_line v.lnum bytes descr in\n json_error msg\n\n\n let lexer_error descr v lexbuf =\n custom_error\n (sprintf \"%s '%s'\" descr (Lexing.lexeme lexbuf))\n v lexbuf\n\n let read_junk = ref (fun _ -> assert false)\n\n let long_error descr v lexbuf =\n let junk = Lexing.lexeme lexbuf in\n let extra_junk = !read_junk lexbuf in\n custom_error\n (sprintf \"%s '%s%s'\" descr junk extra_junk)\n v lexbuf\n\n let min10 = min_int / 10 - (if min_int mod 10 = 0 then 0 else 1)\n let max10 = max_int / 10 + (if max_int mod 10 = 0 then 0 else 1)\n\n exception Int_overflow\n\n let extract_positive_int lexbuf =\n let start = lexbuf.lex_start_pos in\n let stop = lexbuf.lex_curr_pos in\n let s = lexbuf.lex_buffer in\n let n = ref 0 in\n for i = start to stop - 1 do\n if !n >= max10 then\n raise Int_overflow\n else\n n := 10 * !n + dec (Bytes.get s i)\n done;\n if !n < 0 then\n raise Int_overflow\n else\n !n\n\n let make_positive_int v lexbuf =\n \n# 104 \"lib/read.mll\"\n try `Int (extract_positive_int lexbuf)\n with Int_overflow ->\n \n# 110 \"lib/read.mll\"\n lexer_error \"Int overflow\" v lexbuf\n\n \n# 113 \"lib/read.mll\"\n let extract_negative_int lexbuf =\n let start = lexbuf.lex_start_pos + 1 in\n let stop = lexbuf.lex_curr_pos in\n let s = lexbuf.lex_buffer in\n let n = ref 0 in\n for i = start to stop - 1 do\n if !n <= min10 then\n raise Int_overflow\n else\n n := 10 * !n - dec (Bytes.get s i)\n done;\n if !n > 0 then\n raise Int_overflow\n else\n !n\n\n let make_negative_int v lexbuf =\n \n# 131 \"lib/read.mll\"\n try `Int (extract_negative_int lexbuf)\n with Int_overflow ->\n \n# 137 \"lib/read.mll\"\n lexer_error \"Int overflow\" v lexbuf\n\n\n \n# 141 \"lib/read.mll\"\n let set_file_name v fname =\n v.fname <- fname\n\n let newline v lexbuf =\n v.lnum <- v.lnum + 1;\n v.bol <- lexbuf.lex_abs_pos + lexbuf.lex_curr_pos\n\n let add_lexeme buf lexbuf =\n let len = lexbuf.lex_curr_pos - lexbuf.lex_start_pos in\n Bi_outbuf.add_subbytes buf lexbuf.lex_buffer lexbuf.lex_start_pos len\n\n let map_lexeme f lexbuf =\n let len = lexbuf.lex_curr_pos - lexbuf.lex_start_pos in\n f (Bytes.to_string lexbuf.lex_buffer) lexbuf.lex_start_pos len\n\n type variant_kind = [ `Edgy_bracket | `Square_bracket | `Double_quote ]\n type tuple_kind = [ `Parenthesis | `Square_bracket ]\n\n\n# 161 \"lib/read.ml\"\n# 161 \"lib/read.ml\"\nlet __ocaml_lex_tables = {\n Lexing.lex_base =\n \"\\000\\000\\236\\255\\237\\255\\003\\000\\239\\255\\016\\000\\242\\255\\243\\255\\\n \\244\\255\\245\\255\\000\\000\\031\\000\\249\\255\\085\\000\\001\\000\\000\\000\\\n \\000\\000\\001\\000\\000\\000\\001\\000\\002\\000\\255\\255\\000\\000\\000\\000\\\n \\003\\000\\254\\255\\001\\000\\004\\000\\253\\255\\011\\000\\252\\255\\003\\000\\\n \\001\\000\\003\\000\\002\\000\\003\\000\\000\\000\\251\\255\\021\\000\\097\\000\\\n \\010\\000\\022\\000\\020\\000\\016\\000\\022\\000\\012\\000\\008\\000\\250\\255\\\n \\119\\000\\129\\000\\139\\000\\161\\000\\171\\000\\181\\000\\193\\000\\209\\000\\\n \\240\\255\\011\\000\\038\\000\\252\\255\\065\\000\\254\\255\\255\\255\\110\\000\\\n \\252\\255\\163\\000\\254\\255\\255\\255\\234\\000\\247\\255\\248\\255\\048\\001\\\n \\250\\255\\251\\255\\252\\255\\253\\255\\254\\255\\255\\255\\071\\001\\126\\001\\\n \\149\\001\\249\\255\\039\\000\\253\\255\\254\\255\\038\\000\\187\\001\\210\\001\\\n \\248\\001\\015\\002\\255\\255\\220\\000\\253\\255\\255\\255\\245\\000\\039\\002\\\n \\109\\002\\014\\001\\088\\002\\164\\002\\187\\002\\225\\002\\013\\000\\252\\255\\\n \\253\\255\\254\\255\\255\\255\\014\\000\\253\\255\\254\\255\\255\\255\\030\\000\\\n \\253\\255\\254\\255\\255\\255\\015\\000\\253\\255\\254\\255\\255\\255\\017\\001\\\n \\251\\255\\252\\255\\253\\255\\254\\255\\255\\255\\019\\000\\252\\255\\253\\255\\\n \\254\\255\\015\\000\\255\\255\\016\\000\\255\\255\\008\\001\\005\\000\\253\\255\\\n \\023\\000\\254\\255\\020\\000\\255\\255\\046\\000\\253\\255\\254\\255\\042\\000\\\n \\052\\000\\053\\000\\255\\255\\053\\000\\048\\000\\091\\000\\092\\000\\255\\255\\\n \\027\\001\\250\\255\\251\\255\\137\\000\\104\\000\\089\\000\\088\\000\\106\\000\\\n \\255\\255\\143\\000\\137\\000\\177\\000\\254\\255\\183\\000\\168\\000\\166\\000\\\n \\183\\000\\002\\000\\253\\255\\177\\000\\172\\000\\187\\000\\004\\000\\252\\255\\\n \\053\\002\\251\\255\\252\\255\\253\\255\\103\\001\\255\\255\\248\\002\\254\\255\\\n \\006\\003\\030\\003\\252\\255\\253\\255\\254\\255\\255\\255\\040\\003\\050\\003\\\n \\074\\003\\252\\255\\253\\255\\254\\255\\255\\255\\061\\003\\084\\003\\108\\003\\\n \\249\\255\\250\\255\\251\\255\\244\\000\\120\\003\\142\\003\\179\\000\\194\\000\\\n \\015\\000\\255\\255\\190\\000\\188\\000\\187\\000\\193\\000\\183\\000\\179\\000\\\n \\254\\255\\191\\000\\201\\000\\200\\000\\196\\000\\203\\000\\193\\000\\189\\000\\\n \\253\\255\\157\\003\\095\\003\\174\\003\\196\\003\\206\\003\\216\\003\\228\\003\\\n \\239\\003\\060\\000\\253\\255\\254\\255\\255\\255\\012\\004\\252\\255\\253\\255\\\n \\087\\004\\255\\255\\145\\004\\252\\255\\253\\255\\221\\004\\255\\255\\229\\000\\\n \\253\\255\\254\\255\\255\\255\\231\\000\\253\\255\\254\\255\\255\\255\\002\\000\\\n \\255\\255\\018\\001\\252\\255\\253\\255\\254\\255\\255\\255\\034\\001\\253\\255\\\n \\254\\255\\255\\255\\000\\000\\255\\255\\003\\000\\254\\255\\255\\255\\038\\001\\\n \\252\\255\\253\\255\\254\\255\\255\\255\\120\\001\\251\\255\\252\\255\\253\\255\\\n \\254\\255\\255\\255\\208\\000\\253\\255\\254\\255\\255\\255\\211\\000\\253\\255\\\n \\254\\255\\255\\255\\189\\000\\255\\255\\143\\001\\252\\255\\253\\255\\254\\255\\\n \\255\\255\\013\\001\\253\\255\\254\\255\\255\\255\\095\\001\\252\\255\\253\\255\\\n \\254\\255\\255\\255\\050\\001\\253\\255\\254\\255\\255\\255\\026\\001\\253\\255\\\n \\254\\255\\255\\255\\233\\000\\253\\255\\254\\255\\255\\255\\222\\000\\253\\255\\\n \\254\\255\\255\\255\\079\\005\\237\\255\\238\\255\\010\\000\\240\\255\\044\\001\\\n \\243\\255\\244\\255\\245\\255\\246\\255\\061\\001\\002\\004\\249\\255\\045\\005\\\n \\209\\000\\228\\000\\211\\000\\232\\000\\225\\000\\223\\000\\240\\000\\255\\255\\\n \\235\\000\\234\\000\\008\\001\\254\\255\\004\\001\\023\\001\\253\\255\\054\\001\\\n \\252\\255\\031\\001\\029\\001\\032\\001\\039\\001\\049\\001\\045\\001\\251\\255\\\n \\057\\001\\082\\001\\080\\001\\078\\001\\084\\001\\074\\001\\086\\001\\250\\255\\\n \\110\\005\\012\\004\\123\\005\\155\\005\\165\\005\\177\\005\\187\\005\\197\\005\\\n \\241\\255\\199\\001\\077\\002\\253\\255\\255\\255\\154\\002\\222\\005\\209\\005\\\n \\155\\002\\239\\005\\053\\006\\076\\006\\114\\006\\016\\002\\252\\255\\253\\255\\\n \\254\\255\\255\\255\\152\\006\\252\\255\\253\\255\\227\\006\\255\\255\\085\\007\\\n \\244\\255\\245\\255\\011\\000\\247\\255\\076\\002\\250\\255\\251\\255\\252\\255\\\n \\253\\255\\254\\255\\031\\002\\243\\005\\051\\007\\100\\001\\115\\001\\104\\001\\\n \\133\\001\\118\\001\\154\\001\\171\\001\\255\\255\\173\\001\\176\\001\\191\\001\\\n \\185\\001\\187\\001\\253\\001\\230\\001\\230\\001\\234\\001\\247\\001\\237\\001\\\n \\234\\001\\009\\002\\019\\002\\019\\002\\015\\002\\021\\002\\011\\002\\007\\002\\\n \\142\\006\\152\\006\\116\\007\\170\\007\\180\\007\\190\\007\\200\\007\\210\\007\\\n \\248\\255\\120\\002\\167\\002\\253\\255\\255\\255\\216\\002\\082\\007\\220\\007\\\n \\236\\002\\244\\007\\058\\008\\081\\008\\119\\008\\076\\002\\252\\255\\253\\255\\\n \\254\\255\\255\\255\\157\\008\\252\\255\\253\\255\\232\\008\\255\\255\\135\\002\\\n \\120\\002\\253\\255\\100\\002\\254\\255\\182\\002\\255\\255\\011\\002\\255\\255\\\n \\204\\002\\252\\255\\253\\255\\254\\255\\255\\255\\046\\002\\255\\255\\178\\002\\\n \\252\\255\\253\\255\\254\\255\\255\\255\\023\\000\\255\\255\\183\\002\\252\\255\\\n \\253\\255\\254\\255\\255\\255\\187\\002\\253\\255\\254\\255\\255\\255\\121\\002\\\n \\253\\255\\254\\255\\255\\255\\184\\002\\252\\255\\253\\255\\254\\255\\019\\000\\\n \\255\\255\\140\\001\\146\\001\\255\\255\\150\\001\\151\\001\\154\\001\\168\\001\\\n \\170\\001\\171\\001\\172\\001\\173\\001\\181\\001\\184\\001\\185\\001\\187\\001\\\n \\191\\001\\193\\001\\195\\001\\196\\001\\197\\001\\200\\001\\203\\001\\223\\001\\\n \\225\\001\\228\\001\\249\\001\\251\\001\\002\\002\\004\\002\\011\\002\\012\\002\\\n \\013\\002\\000\\000\";\n Lexing.lex_backtrk =\n \"\\255\\255\\255\\255\\255\\255\\017\\000\\255\\255\\019\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\007\\000\\007\\000\\255\\255\\019\\000\\019\\000\\019\\000\\\n \\019\\000\\019\\000\\019\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\008\\000\\008\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\009\\000\\255\\255\\009\\000\\255\\255\\009\\000\\255\\255\\\n \\255\\255\\014\\000\\255\\255\\255\\255\\002\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\002\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\007\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\001\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\003\\000\\255\\255\\001\\000\\255\\255\\004\\000\\003\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\\n \\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\004\\000\\004\\000\\004\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\003\\000\\255\\255\\000\\000\\255\\255\\\n \\001\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\002\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\002\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\003\\000\\003\\000\\005\\000\\005\\000\\005\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\003\\000\\255\\255\\003\\000\\255\\255\\003\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\001\\000\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\001\\000\\255\\255\\002\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\001\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\016\\000\\255\\255\\018\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\007\\000\\007\\000\\255\\255\\018\\000\\\n \\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\008\\000\\255\\255\\008\\000\\255\\255\\008\\000\\255\\255\\\n \\255\\255\\013\\000\\255\\255\\255\\255\\255\\255\\001\\000\\001\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\009\\000\\255\\255\\011\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\000\\000\\000\\000\\011\\000\\011\\000\\011\\000\\011\\000\\\n \\011\\000\\011\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\000\\000\\255\\255\\000\\000\\255\\255\\000\\000\\255\\255\\\n \\255\\255\\006\\000\\255\\255\\255\\255\\255\\255\\001\\000\\001\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\004\\000\\\n \\003\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\003\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\";\n Lexing.lex_default =\n \"\\001\\000\\000\\000\\000\\000\\255\\255\\000\\000\\255\\255\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\\n \\255\\255\\000\\000\\255\\255\\255\\255\\000\\000\\255\\255\\000\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\000\\000\\057\\000\\060\\000\\000\\000\\060\\000\\000\\000\\000\\000\\065\\000\\\n \\000\\000\\065\\000\\000\\000\\000\\000\\070\\000\\000\\000\\000\\000\\255\\255\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\255\\255\\\n \\255\\255\\000\\000\\084\\000\\000\\000\\000\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\000\\000\\094\\000\\000\\000\\000\\000\\097\\000\\255\\255\\\n \\255\\255\\097\\000\\255\\255\\255\\255\\255\\255\\255\\255\\104\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\109\\000\\000\\000\\000\\000\\000\\000\\113\\000\\\n \\000\\000\\000\\000\\000\\000\\117\\000\\000\\000\\000\\000\\000\\000\\121\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\126\\000\\000\\000\\000\\000\\\n \\000\\000\\255\\255\\000\\000\\255\\255\\000\\000\\255\\255\\255\\255\\000\\000\\\n \\255\\255\\000\\000\\138\\000\\000\\000\\142\\000\\000\\000\\000\\000\\255\\255\\\n \\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\\n \\154\\000\\000\\000\\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\000\\000\\255\\255\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\\n \\178\\000\\000\\000\\000\\000\\000\\000\\255\\255\\000\\000\\255\\255\\000\\000\\\n \\255\\255\\187\\000\\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\255\\255\\\n \\194\\000\\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\255\\255\\201\\000\\\n \\000\\000\\000\\000\\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\235\\000\\000\\000\\000\\000\\000\\000\\239\\000\\000\\000\\000\\000\\\n \\255\\255\\000\\000\\244\\000\\000\\000\\000\\000\\255\\255\\000\\000\\249\\000\\\n \\000\\000\\000\\000\\000\\000\\253\\000\\000\\000\\000\\000\\000\\000\\255\\255\\\n \\000\\000\\003\\001\\000\\000\\000\\000\\000\\000\\000\\000\\008\\001\\000\\000\\\n \\000\\000\\000\\000\\255\\255\\000\\000\\255\\255\\000\\000\\000\\000\\017\\001\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\022\\001\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\028\\001\\000\\000\\000\\000\\000\\000\\032\\001\\000\\000\\\n \\000\\000\\000\\000\\255\\255\\000\\000\\038\\001\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\043\\001\\000\\000\\000\\000\\000\\000\\047\\001\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\052\\001\\000\\000\\000\\000\\000\\000\\056\\001\\000\\000\\\n \\000\\000\\000\\000\\060\\001\\000\\000\\000\\000\\000\\000\\064\\001\\000\\000\\\n \\000\\000\\000\\000\\067\\001\\000\\000\\000\\000\\255\\255\\000\\000\\255\\255\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\255\\255\\000\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\\n \\255\\255\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\000\\000\\255\\255\\\n \\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\000\\000\\121\\001\\125\\001\\000\\000\\000\\000\\128\\001\\255\\255\\255\\255\\\n \\128\\001\\255\\255\\255\\255\\255\\255\\255\\255\\135\\001\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\140\\001\\000\\000\\000\\000\\255\\255\\000\\000\\144\\001\\\n \\000\\000\\000\\000\\255\\255\\000\\000\\255\\255\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\000\\000\\193\\001\\197\\001\\000\\000\\000\\000\\200\\001\\255\\255\\255\\255\\\n \\200\\001\\255\\255\\255\\255\\255\\255\\255\\255\\207\\001\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\212\\001\\000\\000\\000\\000\\255\\255\\000\\000\\255\\255\\\n \\255\\255\\000\\000\\255\\255\\000\\000\\220\\001\\000\\000\\255\\255\\000\\000\\\n \\226\\001\\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\000\\000\\233\\001\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\000\\000\\240\\001\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\245\\001\\000\\000\\000\\000\\000\\000\\249\\001\\\n \\000\\000\\000\\000\\000\\000\\252\\001\\000\\000\\000\\000\\000\\000\\255\\255\\\n \\000\\000\\002\\002\\004\\002\\000\\000\\005\\002\\006\\002\\007\\002\\008\\002\\\n \\009\\002\\010\\002\\011\\002\\012\\002\\013\\002\\014\\002\\015\\002\\016\\002\\\n \\017\\002\\018\\002\\019\\002\\020\\002\\021\\002\\022\\002\\023\\002\\024\\002\\\n \\025\\002\\026\\002\\027\\002\\028\\002\\029\\002\\030\\002\\031\\002\\032\\002\\\n \\033\\002\\003\\002\";\n Lexing.lex_trans =\n \"\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\003\\000\\004\\000\\000\\000\\003\\000\\003\\000\\134\\000\\000\\000\\\n \\003\\000\\000\\000\\134\\000\\069\\001\\146\\001\\255\\255\\000\\000\\069\\001\\\n \\146\\001\\000\\000\\000\\000\\000\\000\\000\\000\\127\\000\\139\\000\\000\\000\\\n \\003\\000\\000\\000\\012\\000\\003\\000\\170\\000\\134\\000\\175\\000\\000\\000\\\n \\007\\000\\011\\001\\069\\001\\146\\001\\014\\001\\013\\000\\049\\000\\005\\000\\\n \\010\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\\n \\011\\000\\011\\000\\056\\000\\118\\000\\006\\000\\129\\000\\130\\000\\057\\000\\\n \\237\\001\\137\\000\\000\\002\\049\\000\\000\\000\\048\\000\\138\\000\\106\\000\\\n \\062\\000\\014\\000\\110\\000\\105\\000\\000\\000\\049\\000\\015\\000\\011\\000\\\n \\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\\n \\011\\000\\030\\000\\048\\000\\008\\000\\114\\000\\209\\000\\236\\000\\000\\001\\\n \\013\\001\\029\\000\\022\\000\\255\\255\\048\\000\\048\\000\\017\\000\\021\\000\\\n \\025\\000\\032\\000\\033\\000\\035\\000\\023\\000\\027\\000\\016\\000\\031\\000\\\n \\028\\000\\034\\000\\019\\000\\024\\000\\018\\000\\026\\000\\020\\000\\036\\000\\\n \\041\\000\\037\\000\\048\\000\\009\\000\\042\\000\\043\\000\\044\\000\\045\\000\\\n \\046\\000\\047\\000\\061\\000\\085\\000\\048\\000\\038\\000\\039\\000\\039\\000\\\n \\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\049\\000\\\n \\067\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\\n \\039\\000\\039\\000\\039\\000\\086\\000\\143\\000\\255\\255\\040\\000\\144\\000\\\n \\145\\000\\146\\000\\055\\000\\148\\000\\055\\000\\149\\000\\048\\000\\054\\000\\\n \\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\\n \\054\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\\n \\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\\n \\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\255\\255\\048\\000\\150\\000\\\n \\151\\000\\161\\000\\066\\000\\158\\000\\053\\000\\159\\000\\053\\000\\160\\000\\\n \\051\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\\n \\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\\n \\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\\n \\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\165\\000\\\n \\051\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\\n \\054\\000\\054\\000\\054\\000\\162\\000\\163\\000\\166\\000\\093\\000\\255\\255\\\n \\002\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\\n \\054\\000\\054\\000\\054\\000\\255\\255\\077\\000\\103\\000\\108\\000\\116\\000\\\n \\132\\000\\134\\000\\135\\000\\128\\000\\139\\000\\134\\000\\164\\000\\093\\000\\\n \\171\\000\\077\\000\\167\\000\\168\\000\\169\\000\\172\\000\\112\\000\\173\\000\\\n \\174\\000\\210\\000\\226\\000\\208\\000\\211\\000\\212\\000\\059\\000\\083\\000\\\n \\134\\000\\213\\000\\214\\000\\215\\000\\216\\000\\218\\000\\141\\000\\219\\000\\\n \\093\\000\\220\\000\\221\\000\\123\\000\\222\\000\\223\\000\\224\\000\\136\\000\\\n \\095\\000\\225\\000\\035\\001\\065\\001\\234\\000\\155\\000\\005\\001\\097\\001\\\n \\250\\000\\255\\255\\254\\000\\057\\001\\061\\001\\095\\001\\077\\000\\044\\001\\\n \\092\\001\\088\\001\\009\\001\\029\\001\\076\\000\\124\\000\\033\\001\\018\\001\\\n \\075\\000\\098\\000\\019\\001\\085\\001\\086\\001\\087\\001\\120\\001\\089\\001\\\n \\074\\000\\225\\000\\053\\001\\121\\001\\073\\000\\090\\001\\072\\000\\071\\000\\\n \\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\\n \\078\\000\\078\\000\\098\\000\\113\\001\\122\\000\\091\\001\\064\\000\\004\\001\\\n \\093\\001\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\079\\000\\\n \\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\\n \\079\\000\\156\\000\\112\\001\\094\\001\\096\\001\\098\\001\\099\\001\\049\\001\\\n \\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\100\\001\\157\\000\\\n \\101\\001\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\183\\000\\\n \\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\\n \\184\\000\\024\\001\\112\\001\\255\\255\\025\\001\\102\\001\\103\\001\\105\\001\\\n \\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\080\\000\\080\\000\\\n \\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\\n \\106\\001\\107\\001\\048\\001\\040\\001\\108\\001\\109\\001\\110\\001\\080\\000\\\n \\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\081\\000\\081\\000\\081\\000\\\n \\081\\000\\081\\000\\081\\000\\081\\000\\081\\000\\081\\000\\081\\000\\111\\001\\\n \\027\\001\\255\\255\\171\\001\\031\\001\\170\\001\\023\\001\\081\\000\\081\\000\\\n \\081\\000\\081\\000\\081\\000\\081\\000\\092\\000\\168\\001\\063\\001\\080\\000\\\n \\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\248\\000\\165\\001\\252\\000\\\n \\162\\001\\059\\001\\069\\000\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\\n \\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\255\\255\\081\\000\\081\\000\\\n \\081\\000\\081\\000\\081\\000\\081\\000\\087\\000\\087\\000\\087\\000\\087\\000\\\n \\087\\000\\087\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\\n \\088\\000\\088\\000\\088\\000\\088\\000\\039\\001\\042\\001\\255\\255\\163\\001\\\n \\164\\001\\120\\000\\002\\001\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\\n \\088\\000\\166\\001\\055\\001\\153\\000\\087\\000\\087\\000\\087\\000\\087\\000\\\n \\087\\000\\087\\000\\007\\001\\167\\001\\164\\001\\169\\001\\016\\001\\164\\001\\\n \\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\\n \\089\\000\\089\\000\\051\\001\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\\n \\088\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\090\\000\\\n \\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\\n \\090\\000\\097\\000\\137\\001\\164\\001\\172\\001\\185\\001\\136\\001\\173\\001\\\n \\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\097\\000\\179\\000\\\n \\174\\001\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\046\\001\\\n \\175\\001\\176\\001\\180\\000\\164\\001\\184\\001\\181\\000\\182\\000\\182\\000\\\n \\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\124\\001\\\n \\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\192\\001\\178\\001\\\n \\021\\001\\179\\001\\097\\000\\193\\001\\180\\001\\181\\001\\182\\001\\183\\001\\\n \\164\\001\\216\\001\\255\\255\\097\\000\\184\\001\\216\\001\\209\\001\\097\\000\\\n \\223\\001\\097\\000\\208\\001\\230\\001\\003\\002\\097\\000\\219\\001\\037\\001\\\n \\216\\001\\217\\001\\003\\002\\220\\001\\216\\001\\097\\000\\003\\002\\003\\002\\\n \\216\\001\\097\\000\\003\\002\\097\\000\\096\\000\\099\\000\\099\\000\\099\\000\\\n \\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\216\\001\\\n \\003\\002\\126\\001\\003\\002\\003\\002\\003\\002\\003\\002\\099\\000\\099\\000\\\n \\099\\000\\099\\000\\099\\000\\099\\000\\097\\000\\003\\002\\218\\001\\250\\001\\\n \\003\\002\\003\\002\\097\\000\\003\\002\\124\\001\\124\\001\\097\\000\\003\\002\\\n \\221\\001\\003\\002\\253\\001\\003\\002\\003\\002\\003\\002\\097\\000\\255\\255\\\n \\003\\002\\196\\001\\097\\000\\003\\002\\097\\000\\096\\000\\099\\000\\099\\000\\\n \\099\\000\\099\\000\\099\\000\\099\\000\\100\\000\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\235\\001\\003\\002\\\n \\241\\001\\003\\002\\255\\001\\242\\001\\003\\002\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\100\\000\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\\n \\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\246\\001\\129\\001\\129\\001\\\n \\228\\001\\003\\002\\196\\001\\003\\002\\101\\000\\101\\000\\101\\000\\101\\000\\\n \\101\\000\\101\\000\\003\\002\\198\\001\\003\\002\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\100\\000\\003\\002\\003\\002\\003\\002\\196\\001\\234\\001\\\n \\134\\001\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\\n \\097\\000\\097\\000\\097\\000\\000\\000\\101\\000\\101\\000\\101\\000\\101\\000\\\n \\101\\000\\101\\000\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\\n \\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\\n \\182\\000\\182\\000\\000\\000\\000\\000\\201\\001\\177\\000\\184\\000\\184\\000\\\n \\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\\n \\188\\000\\000\\000\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\\n \\201\\001\\227\\001\\000\\000\\191\\000\\206\\001\\123\\001\\189\\000\\190\\000\\\n \\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\\n \\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\\n \\190\\000\\190\\000\\189\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\\n \\190\\000\\190\\000\\190\\000\\190\\000\\195\\000\\197\\000\\197\\000\\197\\000\\\n \\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\198\\000\\\n \\255\\255\\248\\001\\196\\000\\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\\n \\197\\000\\197\\000\\197\\000\\197\\000\\196\\000\\197\\000\\197\\000\\197\\000\\\n \\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\202\\000\\227\\000\\\n \\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\\n \\227\\000\\205\\000\\255\\255\\255\\255\\203\\000\\204\\000\\204\\000\\204\\000\\\n \\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\226\\000\\195\\001\\\n \\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\\n \\204\\000\\204\\000\\232\\001\\000\\000\\000\\000\\206\\000\\221\\001\\239\\001\\\n \\254\\001\\000\\000\\207\\000\\244\\001\\000\\000\\225\\000\\203\\000\\204\\000\\\n \\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\\n \\232\\000\\000\\000\\232\\000\\000\\000\\225\\001\\231\\000\\231\\000\\231\\000\\\n \\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\217\\000\\\n \\255\\255\\000\\000\\000\\000\\000\\000\\000\\000\\225\\000\\227\\000\\227\\000\\\n \\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\000\\000\\000\\000\\230\\000\\\n \\000\\000\\230\\000\\000\\000\\228\\000\\229\\000\\229\\000\\229\\000\\229\\000\\\n \\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\\n \\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\\n \\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\\n \\229\\000\\229\\000\\000\\000\\228\\000\\231\\000\\231\\000\\231\\000\\231\\000\\\n \\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\186\\000\\231\\000\\\n \\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\\n \\231\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\241\\000\\000\\000\\\n \\113\\001\\000\\000\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\\n \\077\\001\\077\\001\\077\\001\\077\\001\\114\\001\\114\\001\\114\\001\\114\\001\\\n \\114\\001\\114\\001\\114\\001\\114\\001\\114\\001\\114\\001\\000\\000\\112\\001\\\n \\000\\000\\000\\000\\193\\000\\000\\000\\000\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\112\\001\\\n \\000\\000\\000\\000\\000\\000\\240\\000\\200\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\000\\000\\246\\000\\000\\000\\000\\000\\240\\000\\000\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\245\\000\\000\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\238\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\245\\000\\000\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\069\\001\\070\\001\\000\\000\\000\\000\\069\\001\\076\\001\\077\\001\\077\\001\\\n \\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\069\\001\\\n \\000\\000\\078\\001\\000\\000\\000\\000\\000\\000\\000\\000\\104\\001\\073\\001\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\079\\001\\000\\000\\071\\001\\076\\001\\\n \\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\\n \\077\\001\\000\\000\\000\\000\\072\\001\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\243\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\080\\001\\119\\001\\000\\000\\119\\001\\000\\000\\081\\001\\118\\001\\118\\001\\\n \\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\\n \\000\\000\\000\\000\\074\\001\\114\\001\\114\\001\\114\\001\\114\\001\\114\\001\\\n \\114\\001\\114\\001\\114\\001\\114\\001\\114\\001\\083\\001\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\082\\001\\000\\000\\000\\000\\\n \\115\\001\\000\\000\\000\\000\\084\\001\\000\\000\\000\\000\\117\\001\\000\\000\\\n \\117\\001\\000\\000\\075\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\\n \\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\\n \\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\000\\000\\\n \\115\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\\n \\116\\001\\116\\001\\116\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\\n \\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\\n \\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\000\\000\\\n \\128\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\\n \\130\\001\\130\\001\\130\\001\\000\\000\\000\\000\\128\\001\\000\\000\\000\\000\\\n \\000\\000\\128\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\001\\000\\000\\\n \\000\\000\\185\\001\\000\\000\\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\\n \\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\\n \\184\\001\\000\\000\\128\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\128\\001\\000\\000\\000\\000\\000\\000\\128\\001\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\128\\001\\128\\001\\000\\000\\000\\000\\068\\001\\\n \\128\\001\\128\\001\\128\\001\\127\\001\\000\\000\\128\\001\\000\\000\\000\\000\\\n \\184\\001\\000\\000\\000\\000\\000\\000\\000\\000\\128\\001\\000\\000\\000\\000\\\n \\000\\000\\128\\001\\000\\000\\128\\001\\127\\001\\131\\001\\131\\001\\131\\001\\\n \\131\\001\\131\\001\\131\\001\\131\\001\\131\\001\\131\\001\\131\\001\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\131\\001\\131\\001\\\n \\131\\001\\131\\001\\131\\001\\131\\001\\132\\001\\132\\001\\132\\001\\132\\001\\\n \\132\\001\\132\\001\\132\\001\\132\\001\\132\\001\\132\\001\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\132\\001\\132\\001\\132\\001\\\n \\132\\001\\132\\001\\132\\001\\000\\000\\000\\000\\000\\000\\131\\001\\131\\001\\\n \\131\\001\\131\\001\\131\\001\\131\\001\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\128\\001\\128\\001\\128\\001\\128\\001\\128\\001\\128\\001\\\n \\128\\001\\128\\001\\128\\001\\128\\001\\000\\000\\132\\001\\132\\001\\132\\001\\\n \\132\\001\\132\\001\\132\\001\\128\\001\\128\\001\\128\\001\\128\\001\\128\\001\\\n \\128\\001\\191\\001\\142\\001\\191\\001\\000\\000\\000\\000\\190\\001\\190\\001\\\n \\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\\n \\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\\n \\186\\001\\186\\001\\000\\000\\128\\001\\128\\001\\128\\001\\128\\001\\128\\001\\\n \\128\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\000\\000\\000\\000\\000\\000\\000\\000\\141\\001\\\n \\000\\000\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\141\\001\\000\\000\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\146\\001\\147\\001\\\n \\000\\000\\000\\000\\146\\001\\154\\001\\155\\001\\155\\001\\155\\001\\155\\001\\\n \\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\200\\001\\146\\001\\000\\000\\153\\001\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\177\\001\\150\\001\\000\\000\\000\\000\\\n \\000\\000\\200\\001\\156\\001\\000\\000\\148\\001\\154\\001\\155\\001\\155\\001\\\n \\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\000\\000\\\n \\000\\000\\149\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\139\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\157\\001\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\158\\001\\186\\001\\186\\001\\186\\001\\186\\001\\\n \\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\200\\001\\000\\000\\\n \\151\\001\\000\\000\\000\\000\\000\\000\\200\\001\\000\\000\\000\\000\\000\\000\\\n \\200\\001\\187\\001\\000\\000\\160\\001\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\200\\001\\000\\000\\000\\000\\159\\001\\200\\001\\000\\000\\200\\001\\199\\001\\\n \\000\\000\\161\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\152\\001\\000\\000\\000\\000\\000\\000\\000\\000\\189\\001\\000\\000\\189\\001\\\n \\000\\000\\187\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\\n \\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\\n \\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\\n \\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\\n \\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\\n \\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\\n \\190\\001\\190\\001\\190\\001\\190\\001\\202\\001\\202\\001\\202\\001\\202\\001\\\n \\202\\001\\202\\001\\202\\001\\202\\001\\202\\001\\202\\001\\200\\001\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\202\\001\\202\\001\\202\\001\\\n \\202\\001\\202\\001\\202\\001\\200\\001\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\202\\001\\202\\001\\202\\001\\\n \\202\\001\\202\\001\\202\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\200\\001\\000\\000\\000\\000\\000\\000\\000\\000\\145\\001\\200\\001\\000\\000\\\n \\000\\000\\000\\000\\200\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\200\\001\\000\\000\\000\\000\\000\\000\\200\\001\\000\\000\\\n \\200\\001\\199\\001\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\\n \\203\\001\\203\\001\\203\\001\\203\\001\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\\n \\203\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\\n \\204\\001\\204\\001\\204\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\\n \\000\\000\\000\\000\\000\\000\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\\n \\203\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\200\\001\\\n \\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\\n \\200\\001\\000\\000\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\\n \\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\000\\000\\214\\001\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\213\\001\\000\\000\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\000\\000\\000\\000\\000\\000\\000\\000\\213\\001\\\n \\000\\000\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\211\\001\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\";\n Lexing.lex_check =\n \"\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\000\\000\\000\\000\\255\\255\\003\\000\\000\\000\\134\\000\\255\\255\\\n \\003\\000\\255\\255\\134\\000\\069\\001\\146\\001\\057\\000\\255\\255\\069\\001\\\n \\146\\001\\255\\255\\255\\255\\255\\255\\255\\255\\125\\000\\138\\000\\255\\255\\\n \\000\\000\\255\\255\\000\\000\\003\\000\\169\\000\\134\\000\\174\\000\\255\\255\\\n \\000\\000\\010\\001\\069\\001\\146\\001\\012\\001\\000\\000\\010\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\005\\000\\115\\000\\000\\000\\125\\000\\129\\000\\005\\000\\\n \\236\\001\\136\\000\\255\\001\\038\\000\\255\\255\\010\\000\\136\\000\\102\\000\\\n \\058\\000\\000\\000\\107\\000\\102\\000\\255\\255\\011\\000\\000\\000\\011\\000\\\n \\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\\n \\011\\000\\029\\000\\038\\000\\000\\000\\111\\000\\208\\000\\233\\000\\255\\000\\\n \\012\\001\\015\\000\\017\\000\\060\\000\\011\\000\\010\\000\\000\\000\\020\\000\\\n \\024\\000\\031\\000\\032\\000\\034\\000\\022\\000\\026\\000\\000\\000\\014\\000\\\n \\027\\000\\033\\000\\018\\000\\023\\000\\000\\000\\016\\000\\019\\000\\035\\000\\\n \\040\\000\\036\\000\\038\\000\\000\\000\\041\\000\\042\\000\\043\\000\\044\\000\\\n \\045\\000\\046\\000\\058\\000\\082\\000\\011\\000\\013\\000\\013\\000\\013\\000\\\n \\013\\000\\013\\000\\013\\000\\013\\000\\013\\000\\013\\000\\013\\000\\039\\000\\\n \\063\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\\n \\039\\000\\039\\000\\039\\000\\085\\000\\140\\000\\060\\000\\013\\000\\143\\000\\\n \\144\\000\\145\\000\\048\\000\\147\\000\\048\\000\\148\\000\\039\\000\\048\\000\\\n \\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\\n \\048\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\\n \\049\\000\\049\\000\\049\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\\n \\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\065\\000\\039\\000\\149\\000\\\n \\150\\000\\156\\000\\063\\000\\157\\000\\051\\000\\158\\000\\051\\000\\159\\000\\\n \\050\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\\n \\051\\000\\051\\000\\051\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\\n \\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\053\\000\\053\\000\\053\\000\\\n \\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\155\\000\\\n \\050\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\\n \\054\\000\\054\\000\\054\\000\\161\\000\\162\\000\\155\\000\\091\\000\\065\\000\\\n \\000\\000\\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\\n \\055\\000\\055\\000\\055\\000\\057\\000\\068\\000\\102\\000\\107\\000\\115\\000\\\n \\131\\000\\133\\000\\133\\000\\125\\000\\138\\000\\133\\000\\163\\000\\094\\000\\\n \\165\\000\\068\\000\\166\\000\\167\\000\\168\\000\\171\\000\\111\\000\\172\\000\\\n \\173\\000\\206\\000\\203\\000\\207\\000\\210\\000\\211\\000\\058\\000\\082\\000\\\n \\133\\000\\212\\000\\213\\000\\214\\000\\215\\000\\217\\000\\140\\000\\218\\000\\\n \\097\\000\\219\\000\\220\\000\\119\\000\\221\\000\\222\\000\\223\\000\\133\\000\\\n \\091\\000\\203\\000\\034\\001\\062\\001\\233\\000\\152\\000\\001\\001\\080\\001\\\n \\247\\000\\060\\000\\251\\000\\054\\001\\058\\001\\081\\001\\068\\000\\041\\001\\\n \\082\\001\\083\\001\\006\\001\\026\\001\\068\\000\\119\\000\\030\\001\\015\\001\\\n \\068\\000\\094\\000\\015\\001\\084\\001\\085\\001\\086\\001\\071\\001\\088\\001\\\n \\068\\000\\203\\000\\050\\001\\071\\001\\068\\000\\089\\001\\068\\000\\068\\000\\\n \\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\\n \\071\\000\\071\\000\\097\\000\\076\\001\\119\\000\\090\\001\\063\\000\\001\\001\\\n \\092\\001\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\078\\000\\\n \\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\\n \\078\\000\\152\\000\\076\\001\\093\\001\\095\\001\\097\\001\\098\\001\\045\\001\\\n \\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\099\\001\\152\\000\\\n \\100\\001\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\180\\000\\\n \\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\\n \\180\\000\\020\\001\\076\\001\\065\\000\\020\\001\\101\\001\\102\\001\\104\\001\\\n \\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\079\\000\\079\\000\\\n \\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\\n \\105\\001\\106\\001\\045\\001\\036\\001\\107\\001\\108\\001\\109\\001\\079\\000\\\n \\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\080\\000\\080\\000\\080\\000\\\n \\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\110\\001\\\n \\026\\001\\121\\001\\157\\001\\030\\001\\158\\001\\020\\001\\080\\000\\080\\000\\\n \\080\\000\\080\\000\\080\\000\\080\\000\\091\\000\\159\\001\\062\\001\\079\\000\\\n \\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\247\\000\\160\\001\\251\\000\\\n \\161\\001\\058\\001\\068\\000\\086\\000\\086\\000\\086\\000\\086\\000\\086\\000\\\n \\086\\000\\086\\000\\086\\000\\086\\000\\086\\000\\094\\000\\080\\000\\080\\000\\\n \\080\\000\\080\\000\\080\\000\\080\\000\\086\\000\\086\\000\\086\\000\\086\\000\\\n \\086\\000\\086\\000\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\\n \\087\\000\\087\\000\\087\\000\\087\\000\\036\\001\\041\\001\\097\\000\\162\\001\\\n \\163\\001\\119\\000\\001\\001\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\\n \\087\\000\\165\\001\\054\\001\\152\\000\\086\\000\\086\\000\\086\\000\\086\\000\\\n \\086\\000\\086\\000\\006\\001\\166\\001\\167\\001\\168\\001\\015\\001\\169\\001\\\n \\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\\n \\088\\000\\088\\000\\050\\001\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\\n \\087\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\089\\000\\\n \\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\\n \\089\\000\\095\\000\\133\\001\\170\\001\\171\\001\\154\\001\\133\\001\\172\\001\\\n \\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\095\\000\\176\\000\\\n \\173\\001\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\045\\001\\\n \\174\\001\\175\\001\\176\\000\\176\\001\\154\\001\\176\\000\\176\\000\\176\\000\\\n \\176\\000\\176\\000\\176\\000\\176\\000\\176\\000\\176\\000\\176\\000\\122\\001\\\n \\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\148\\001\\177\\001\\\n \\020\\001\\178\\001\\098\\000\\148\\001\\179\\001\\180\\001\\181\\001\\182\\001\\\n \\183\\001\\216\\001\\193\\001\\095\\000\\154\\001\\216\\001\\205\\001\\098\\000\\\n \\222\\001\\095\\000\\205\\001\\229\\001\\001\\002\\095\\000\\218\\001\\036\\001\\\n \\215\\001\\215\\001\\002\\002\\218\\001\\215\\001\\095\\000\\004\\002\\005\\002\\\n \\216\\001\\095\\000\\006\\002\\095\\000\\095\\000\\096\\000\\096\\000\\096\\000\\\n \\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\215\\001\\\n \\007\\002\\122\\001\\008\\002\\009\\002\\010\\002\\011\\002\\096\\000\\096\\000\\\n \\096\\000\\096\\000\\096\\000\\096\\000\\098\\000\\012\\002\\215\\001\\247\\001\\\n \\013\\002\\014\\002\\098\\000\\015\\002\\125\\001\\128\\001\\098\\000\\016\\002\\\n \\220\\001\\017\\002\\251\\001\\018\\002\\019\\002\\020\\002\\098\\000\\121\\001\\\n \\021\\002\\194\\001\\098\\000\\022\\002\\098\\000\\098\\000\\096\\000\\096\\000\\\n \\096\\000\\096\\000\\096\\000\\096\\000\\099\\000\\099\\000\\099\\000\\099\\000\\\n \\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\231\\001\\023\\002\\\n \\238\\001\\024\\002\\251\\001\\238\\001\\025\\002\\099\\000\\099\\000\\099\\000\\\n \\099\\000\\099\\000\\099\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\243\\001\\125\\001\\128\\001\\\n \\224\\001\\026\\002\\197\\001\\027\\002\\100\\000\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\028\\002\\194\\001\\029\\002\\099\\000\\099\\000\\099\\000\\\n \\099\\000\\099\\000\\099\\000\\030\\002\\031\\002\\032\\002\\200\\001\\231\\001\\\n \\133\\001\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\\n \\101\\000\\101\\000\\101\\000\\255\\255\\100\\000\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\\n \\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\\n \\182\\000\\182\\000\\255\\255\\255\\255\\197\\001\\176\\000\\184\\000\\184\\000\\\n \\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\\n \\185\\000\\255\\255\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\\n \\200\\001\\224\\001\\255\\255\\185\\000\\205\\001\\122\\001\\185\\000\\185\\000\\\n \\185\\000\\185\\000\\185\\000\\185\\000\\185\\000\\185\\000\\185\\000\\185\\000\\\n \\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\\n \\190\\000\\190\\000\\191\\000\\191\\000\\191\\000\\191\\000\\191\\000\\191\\000\\\n \\191\\000\\191\\000\\191\\000\\191\\000\\192\\000\\197\\000\\197\\000\\197\\000\\\n \\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\192\\000\\\n \\193\\001\\247\\001\\192\\000\\192\\000\\192\\000\\192\\000\\192\\000\\192\\000\\\n \\192\\000\\192\\000\\192\\000\\192\\000\\198\\000\\198\\000\\198\\000\\198\\000\\\n \\198\\000\\198\\000\\198\\000\\198\\000\\198\\000\\198\\000\\199\\000\\226\\000\\\n \\226\\000\\226\\000\\226\\000\\226\\000\\226\\000\\226\\000\\226\\000\\226\\000\\\n \\226\\000\\199\\000\\125\\001\\128\\001\\199\\000\\199\\000\\199\\000\\199\\000\\\n \\199\\000\\199\\000\\199\\000\\199\\000\\199\\000\\199\\000\\204\\000\\194\\001\\\n \\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\\n \\204\\000\\204\\000\\231\\001\\255\\255\\255\\255\\199\\000\\220\\001\\238\\001\\\n \\251\\001\\255\\255\\199\\000\\243\\001\\255\\255\\204\\000\\205\\000\\205\\000\\\n \\205\\000\\205\\000\\205\\000\\205\\000\\205\\000\\205\\000\\205\\000\\205\\000\\\n \\225\\000\\255\\255\\225\\000\\255\\255\\224\\001\\225\\000\\225\\000\\225\\000\\\n \\225\\000\\225\\000\\225\\000\\225\\000\\225\\000\\225\\000\\225\\000\\205\\000\\\n \\197\\001\\255\\255\\255\\255\\255\\255\\255\\255\\204\\000\\227\\000\\227\\000\\\n \\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\200\\001\\255\\255\\255\\255\\228\\000\\\n \\255\\255\\228\\000\\255\\255\\227\\000\\228\\000\\228\\000\\228\\000\\228\\000\\\n \\228\\000\\228\\000\\228\\000\\228\\000\\228\\000\\228\\000\\229\\000\\229\\000\\\n \\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\\n \\230\\000\\230\\000\\230\\000\\230\\000\\230\\000\\230\\000\\230\\000\\230\\000\\\n \\230\\000\\230\\000\\255\\255\\227\\000\\231\\000\\231\\000\\231\\000\\231\\000\\\n \\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\185\\000\\232\\000\\\n \\232\\000\\232\\000\\232\\000\\232\\000\\232\\000\\232\\000\\232\\000\\232\\000\\\n \\232\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\237\\000\\255\\255\\\n \\077\\001\\255\\255\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\\n \\077\\001\\077\\001\\077\\001\\077\\001\\113\\001\\113\\001\\113\\001\\113\\001\\\n \\113\\001\\113\\001\\113\\001\\113\\001\\113\\001\\113\\001\\255\\255\\077\\001\\\n \\255\\255\\255\\255\\192\\000\\255\\255\\255\\255\\237\\000\\237\\000\\237\\000\\\n \\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\\n \\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\\n \\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\077\\001\\\n \\255\\255\\255\\255\\255\\255\\237\\000\\199\\000\\237\\000\\237\\000\\237\\000\\\n \\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\\n \\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\\n \\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\255\\255\\242\\000\\255\\255\\255\\255\\240\\000\\255\\255\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\\n \\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\\n \\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\\n \\242\\000\\242\\000\\242\\000\\242\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\242\\000\\255\\255\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\\n \\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\\n \\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\\n \\242\\000\\242\\000\\242\\000\\242\\000\\237\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\245\\000\\255\\255\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\066\\001\\066\\001\\255\\255\\255\\255\\066\\001\\079\\001\\079\\001\\079\\001\\\n \\079\\001\\079\\001\\079\\001\\079\\001\\079\\001\\079\\001\\079\\001\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\066\\001\\\n \\255\\255\\066\\001\\255\\255\\255\\255\\255\\255\\255\\255\\079\\001\\066\\001\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\066\\001\\255\\255\\066\\001\\066\\001\\\n \\066\\001\\066\\001\\066\\001\\066\\001\\066\\001\\066\\001\\066\\001\\066\\001\\\n \\066\\001\\255\\255\\255\\255\\066\\001\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\242\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\066\\001\\112\\001\\255\\255\\112\\001\\255\\255\\066\\001\\112\\001\\112\\001\\\n \\112\\001\\112\\001\\112\\001\\112\\001\\112\\001\\112\\001\\112\\001\\112\\001\\\n \\255\\255\\255\\255\\066\\001\\114\\001\\114\\001\\114\\001\\114\\001\\114\\001\\\n \\114\\001\\114\\001\\114\\001\\114\\001\\114\\001\\066\\001\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\066\\001\\255\\255\\255\\255\\\n \\114\\001\\255\\255\\255\\255\\066\\001\\255\\255\\255\\255\\115\\001\\255\\255\\\n \\115\\001\\255\\255\\066\\001\\115\\001\\115\\001\\115\\001\\115\\001\\115\\001\\\n \\115\\001\\115\\001\\115\\001\\115\\001\\115\\001\\116\\001\\116\\001\\116\\001\\\n \\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\255\\255\\\n \\114\\001\\117\\001\\117\\001\\117\\001\\117\\001\\117\\001\\117\\001\\117\\001\\\n \\117\\001\\117\\001\\117\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\\n \\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\119\\001\\119\\001\\119\\001\\\n \\119\\001\\119\\001\\119\\001\\119\\001\\119\\001\\119\\001\\119\\001\\255\\255\\\n \\126\\001\\127\\001\\127\\001\\127\\001\\127\\001\\127\\001\\127\\001\\127\\001\\\n \\127\\001\\127\\001\\127\\001\\255\\255\\255\\255\\126\\001\\255\\255\\255\\255\\\n \\255\\255\\129\\001\\127\\001\\127\\001\\127\\001\\127\\001\\127\\001\\127\\001\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\129\\001\\255\\255\\\n \\255\\255\\155\\001\\255\\255\\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\\n \\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\127\\001\\127\\001\\127\\001\\127\\001\\127\\001\\127\\001\\\n \\155\\001\\255\\255\\126\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\126\\001\\255\\255\\255\\255\\255\\255\\126\\001\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\129\\001\\126\\001\\255\\255\\255\\255\\066\\001\\\n \\126\\001\\129\\001\\126\\001\\126\\001\\255\\255\\129\\001\\255\\255\\255\\255\\\n \\155\\001\\255\\255\\255\\255\\255\\255\\255\\255\\129\\001\\255\\255\\255\\255\\\n \\255\\255\\129\\001\\255\\255\\129\\001\\129\\001\\130\\001\\130\\001\\130\\001\\\n \\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\130\\001\\130\\001\\\n \\130\\001\\130\\001\\130\\001\\130\\001\\131\\001\\131\\001\\131\\001\\131\\001\\\n \\131\\001\\131\\001\\131\\001\\131\\001\\131\\001\\131\\001\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\131\\001\\131\\001\\131\\001\\\n \\131\\001\\131\\001\\131\\001\\255\\255\\255\\255\\255\\255\\130\\001\\130\\001\\\n \\130\\001\\130\\001\\130\\001\\130\\001\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\132\\001\\132\\001\\132\\001\\132\\001\\132\\001\\132\\001\\\n \\132\\001\\132\\001\\132\\001\\132\\001\\255\\255\\131\\001\\131\\001\\131\\001\\\n \\131\\001\\131\\001\\131\\001\\132\\001\\132\\001\\132\\001\\132\\001\\132\\001\\\n \\132\\001\\184\\001\\138\\001\\184\\001\\255\\255\\255\\255\\184\\001\\184\\001\\\n \\184\\001\\184\\001\\184\\001\\184\\001\\184\\001\\184\\001\\184\\001\\184\\001\\\n \\185\\001\\185\\001\\185\\001\\185\\001\\185\\001\\185\\001\\185\\001\\185\\001\\\n \\185\\001\\185\\001\\255\\255\\132\\001\\132\\001\\132\\001\\132\\001\\132\\001\\\n \\132\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\\n \\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\\n \\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\\n \\138\\001\\138\\001\\138\\001\\255\\255\\255\\255\\255\\255\\255\\255\\138\\001\\\n \\255\\255\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\\n \\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\\n \\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\\n \\138\\001\\138\\001\\138\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\141\\001\\255\\255\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\143\\001\\143\\001\\\n \\255\\255\\255\\255\\143\\001\\156\\001\\156\\001\\156\\001\\156\\001\\156\\001\\\n \\156\\001\\156\\001\\156\\001\\156\\001\\156\\001\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\198\\001\\143\\001\\255\\255\\143\\001\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\156\\001\\143\\001\\255\\255\\255\\255\\\n \\255\\255\\198\\001\\143\\001\\255\\255\\143\\001\\143\\001\\143\\001\\143\\001\\\n \\143\\001\\143\\001\\143\\001\\143\\001\\143\\001\\143\\001\\143\\001\\255\\255\\\n \\255\\255\\143\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\138\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\143\\001\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\143\\001\\186\\001\\186\\001\\186\\001\\186\\001\\\n \\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\198\\001\\255\\255\\\n \\143\\001\\255\\255\\255\\255\\255\\255\\198\\001\\255\\255\\255\\255\\255\\255\\\n \\198\\001\\186\\001\\255\\255\\143\\001\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\198\\001\\255\\255\\255\\255\\143\\001\\198\\001\\255\\255\\198\\001\\198\\001\\\n \\255\\255\\143\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\143\\001\\255\\255\\255\\255\\255\\255\\255\\255\\187\\001\\255\\255\\187\\001\\\n \\255\\255\\186\\001\\187\\001\\187\\001\\187\\001\\187\\001\\187\\001\\187\\001\\\n \\187\\001\\187\\001\\187\\001\\187\\001\\188\\001\\188\\001\\188\\001\\188\\001\\\n \\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\189\\001\\189\\001\\\n \\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\\n \\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\\n \\190\\001\\190\\001\\191\\001\\191\\001\\191\\001\\191\\001\\191\\001\\191\\001\\\n \\191\\001\\191\\001\\191\\001\\191\\001\\199\\001\\199\\001\\199\\001\\199\\001\\\n \\199\\001\\199\\001\\199\\001\\199\\001\\199\\001\\199\\001\\201\\001\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\199\\001\\199\\001\\199\\001\\\n \\199\\001\\199\\001\\199\\001\\201\\001\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\199\\001\\199\\001\\199\\001\\\n \\199\\001\\199\\001\\199\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\201\\001\\255\\255\\255\\255\\255\\255\\255\\255\\143\\001\\201\\001\\255\\255\\\n \\255\\255\\255\\255\\201\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\201\\001\\255\\255\\255\\255\\255\\255\\201\\001\\255\\255\\\n \\201\\001\\201\\001\\202\\001\\202\\001\\202\\001\\202\\001\\202\\001\\202\\001\\\n \\202\\001\\202\\001\\202\\001\\202\\001\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\202\\001\\202\\001\\202\\001\\202\\001\\202\\001\\\n \\202\\001\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\\n \\203\\001\\203\\001\\203\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\\n \\255\\255\\255\\255\\255\\255\\202\\001\\202\\001\\202\\001\\202\\001\\202\\001\\\n \\202\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\204\\001\\\n \\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\\n \\204\\001\\255\\255\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\\n \\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\255\\255\\210\\001\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\210\\001\\210\\001\\\n \\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\\n \\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\\n \\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\210\\001\\255\\255\\210\\001\\210\\001\\\n \\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\\n \\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\\n \\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\255\\255\\255\\255\\255\\255\\255\\255\\213\\001\\\n \\255\\255\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\210\\001\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\";\n Lexing.lex_base_code =\n \"\";\n Lexing.lex_backtrk_code =\n \"\";\n Lexing.lex_default_code =\n \"\";\n Lexing.lex_trans_code =\n \"\";\n Lexing.lex_check_code =\n \"\";\n Lexing.lex_code =\n \"\";\n}\n\nlet rec read_json v lexbuf =\n __ocaml_lex_read_json_rec v lexbuf 0\nand __ocaml_lex_read_json_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 188 \"lib/read.mll\"\n \n# 188 \"lib/read.mll\"\n ( `Bool true )\n\n# 1032 \"lib/read.ml\"\n\n \n# 1033 \"lib/read.ml\"\n | 1 ->\n\n# 189 \"lib/read.mll\"\n \n# 189 \"lib/read.mll\"\n ( `Bool false )\n\n# 1037 \"lib/read.ml\"\n\n \n# 1038 \"lib/read.ml\"\n | 2 ->\n\n# 190 \"lib/read.mll\"\n \n# 190 \"lib/read.mll\"\n ( `Null )\n\n# 1042 \"lib/read.ml\"\n\n \n# 1043 \"lib/read.ml\"\n | 3 ->\n\n# 191 \"lib/read.mll\"\n \n# 191 \"lib/read.mll\"\n (\n \n# 193 \"lib/read.mll\"\n `Float nan\n \n# 197 \"lib/read.mll\"\n )\n\n# 1053 \"lib/read.ml\"\n\n \n# 1054 \"lib/read.ml\"\n | 4 ->\n\n# 198 \"lib/read.mll\"\n \n# 198 \"lib/read.mll\"\n (\n \n# 200 \"lib/read.mll\"\n `Float infinity\n \n# 204 \"lib/read.mll\"\n )\n\n# 1064 \"lib/read.ml\"\n\n \n# 1065 \"lib/read.ml\"\n | 5 ->\n\n# 205 \"lib/read.mll\"\n \n# 205 \"lib/read.mll\"\n (\n \n# 207 \"lib/read.mll\"\n `Float neg_infinity\n \n# 211 \"lib/read.mll\"\n )\n\n# 1075 \"lib/read.ml\"\n\n \n# 1076 \"lib/read.ml\"\n | 6 ->\n\n# 212 \"lib/read.mll\"\n \n# 212 \"lib/read.mll\"\n (\n \n# 214 \"lib/read.mll\"\n Bi_outbuf.clear v.buf;\n `String (finish_string v lexbuf)\n \n# 219 \"lib/read.mll\"\n )\n\n# 1087 \"lib/read.ml\"\n\n \n# 1088 \"lib/read.ml\"\n | 7 ->\n\n# 220 \"lib/read.mll\"\n \n# 220 \"lib/read.mll\"\n ( make_positive_int v lexbuf )\n\n# 1092 \"lib/read.ml\"\n\n \n# 1093 \"lib/read.ml\"\n | 8 ->\n\n# 221 \"lib/read.mll\"\n \n# 221 \"lib/read.mll\"\n ( make_negative_int v lexbuf )\n\n# 1097 \"lib/read.ml\"\n\n \n# 1098 \"lib/read.ml\"\n | 9 ->\n\n# 222 \"lib/read.mll\"\n \n# 222 \"lib/read.mll\"\n (\n \n# 224 \"lib/read.mll\"\n `Float (float_of_string (lexeme lexbuf))\n \n# 228 \"lib/read.mll\"\n )\n\n# 1108 \"lib/read.ml\"\n\n \n# 1109 \"lib/read.ml\"\n | 10 ->\n\n# 230 \"lib/read.mll\"\n \n# 230 \"lib/read.mll\"\n ( let acc = ref [] in\n try\n read_space v lexbuf;\n read_object_end lexbuf;\n let field_name = read_ident v lexbuf in\n read_space v lexbuf;\n read_colon v lexbuf;\n read_space v lexbuf;\n acc := (field_name, read_json v lexbuf) :: !acc;\n while true do\n read_space v lexbuf;\n read_object_sep v lexbuf;\n read_space v lexbuf;\n let field_name = read_ident v lexbuf in\n read_space v lexbuf;\n read_colon v lexbuf;\n read_space v lexbuf;\n acc := (field_name, read_json v lexbuf) :: !acc;\n done;\n assert false\n with End_of_object ->\n `Assoc (List.rev !acc)\n )\n\n# 1135 \"lib/read.ml\"\n\n \n# 1136 \"lib/read.ml\"\n | 11 ->\n\n# 254 \"lib/read.mll\"\n \n# 254 \"lib/read.mll\"\n ( let acc = ref [] in\n try\n read_space v lexbuf;\n read_array_end lexbuf;\n acc := read_json v lexbuf :: !acc;\n while true do\n read_space v lexbuf;\n read_array_sep v lexbuf;\n read_space v lexbuf;\n acc := read_json v lexbuf :: !acc;\n done;\n assert false\n with End_of_array ->\n `List (List.rev !acc)\n )\n\n# 1154 \"lib/read.ml\"\n\n \n# 1155 \"lib/read.ml\"\n | 12 ->\n\n# 270 \"lib/read.mll\"\n \n# 270 \"lib/read.mll\"\n (\n \n# 287 \"lib/read.mll\"\n long_error \"Invalid token\" v lexbuf\n \n# 289 \"lib/read.mll\"\n )\n\n# 1178 \"lib/read.ml\"\n\n \n# 1179 \"lib/read.ml\"\n | 13 ->\n\n# 291 \"lib/read.mll\"\n \n# 291 \"lib/read.mll\"\n (\n \n# 298 \"lib/read.mll\"\n long_error \"Invalid token\" v lexbuf\n \n# 300 \"lib/read.mll\"\n )\n\n# 1192 \"lib/read.ml\"\n\n \n# 1193 \"lib/read.ml\"\n | 14 ->\n\n# 302 \"lib/read.mll\"\n \n# 302 \"lib/read.mll\"\n ( read_json v lexbuf )\n\n# 1197 \"lib/read.ml\"\n\n \n# 1198 \"lib/read.ml\"\n | 15 ->\n\n# 303 \"lib/read.mll\"\n \n# 303 \"lib/read.mll\"\n ( finish_comment v lexbuf; read_json v lexbuf )\n\n# 1202 \"lib/read.ml\"\n\n \n# 1203 \"lib/read.ml\"\n | 16 ->\n\n# 304 \"lib/read.mll\"\n \n# 304 \"lib/read.mll\"\n ( newline v lexbuf; read_json v lexbuf )\n\n# 1207 \"lib/read.ml\"\n\n \n# 1208 \"lib/read.ml\"\n | 17 ->\n\n# 305 \"lib/read.mll\"\n \n# 305 \"lib/read.mll\"\n ( read_json v lexbuf )\n\n# 1212 \"lib/read.ml\"\n\n \n# 1213 \"lib/read.ml\"\n | 18 ->\n\n# 306 \"lib/read.mll\"\n \n# 306 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1217 \"lib/read.ml\"\n\n \n# 1218 \"lib/read.ml\"\n | 19 ->\n\n# 307 \"lib/read.mll\"\n \n# 307 \"lib/read.mll\"\n ( long_error \"Invalid token\" v lexbuf )\n\n# 1222 \"lib/read.ml\"\n\n \n# 1223 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_json_rec v lexbuf __ocaml_lex_state\n\nand finish_string v lexbuf =\n __ocaml_lex_finish_string_rec v lexbuf 58\nand __ocaml_lex_finish_string_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 311 \"lib/read.mll\"\n \n# 311 \"lib/read.mll\"\n ( Bi_outbuf.contents v.buf )\n\n# 1234 \"lib/read.ml\"\n\n \n# 1235 \"lib/read.ml\"\n | 1 ->\n\n# 312 \"lib/read.mll\"\n \n# 312 \"lib/read.mll\"\n ( finish_escaped_char v lexbuf;\n finish_string v lexbuf )\n\n# 1240 \"lib/read.ml\"\n\n \n# 1241 \"lib/read.ml\"\n | 2 ->\n\n# 314 \"lib/read.mll\"\n \n# 314 \"lib/read.mll\"\n ( add_lexeme v.buf lexbuf;\n finish_string v lexbuf )\n\n# 1246 \"lib/read.ml\"\n\n \n# 1247 \"lib/read.ml\"\n | 3 ->\n\n# 316 \"lib/read.mll\"\n \n# 316 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1251 \"lib/read.ml\"\n\n \n# 1252 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_string_rec v lexbuf __ocaml_lex_state\n\nand map_string v f lexbuf =\n __ocaml_lex_map_string_rec v f lexbuf 63\nand __ocaml_lex_map_string_rec v f lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 319 \"lib/read.mll\"\n \n# 319 \"lib/read.mll\"\n ( let b = v.buf in\n f (Bytes.to_string b.Bi_outbuf.o_s) 0 b.Bi_outbuf.o_len )\n\n# 1264 \"lib/read.ml\"\n\n \n# 1265 \"lib/read.ml\"\n | 1 ->\n\n# 321 \"lib/read.mll\"\n \n# 321 \"lib/read.mll\"\n ( finish_escaped_char v lexbuf;\n map_string v f lexbuf )\n\n# 1270 \"lib/read.ml\"\n\n \n# 1271 \"lib/read.ml\"\n | 2 ->\n\n# 323 \"lib/read.mll\"\n \n# 323 \"lib/read.mll\"\n ( add_lexeme v.buf lexbuf;\n map_string v f lexbuf )\n\n# 1276 \"lib/read.ml\"\n\n \n# 1277 \"lib/read.ml\"\n | 3 ->\n\n# 325 \"lib/read.mll\"\n \n# 325 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1281 \"lib/read.ml\"\n\n \n# 1282 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_map_string_rec v f lexbuf __ocaml_lex_state\n\nand finish_escaped_char v lexbuf =\n __ocaml_lex_finish_escaped_char_rec v lexbuf 68\nand __ocaml_lex_finish_escaped_char_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\nlet\n\n# 330 \"lib/read.mll\"\n \n# 330 \"lib/read.mll\"\n c\n\n# 1294 \"lib/read.ml\"\n# 1294 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf lexbuf.Lexing.lex_start_pos in\n\n# 330 \"lib/read.mll\"\n \n# 330 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf c )\n\n# 1298 \"lib/read.ml\"\n\n \n# 1299 \"lib/read.ml\"\n | 1 ->\n\n# 331 \"lib/read.mll\"\n \n# 331 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\\b' )\n\n# 1303 \"lib/read.ml\"\n\n \n# 1304 \"lib/read.ml\"\n | 2 ->\n\n# 332 \"lib/read.mll\"\n \n# 332 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\\012' )\n\n# 1308 \"lib/read.ml\"\n\n \n# 1309 \"lib/read.ml\"\n | 3 ->\n\n# 333 \"lib/read.mll\"\n \n# 333 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\\n' )\n\n# 1313 \"lib/read.ml\"\n\n \n# 1314 \"lib/read.ml\"\n | 4 ->\n\n# 334 \"lib/read.mll\"\n \n# 334 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\\r' )\n\n# 1318 \"lib/read.ml\"\n\n \n# 1319 \"lib/read.ml\"\n | 5 ->\n\n# 335 \"lib/read.mll\"\n \n# 335 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\\t' )\n\n# 1323 \"lib/read.ml\"\n\n \n# 1324 \"lib/read.ml\"\n | 6 ->\nlet\n\n# 336 \"lib/read.mll\"\n \n# 336 \"lib/read.mll\"\n a\n\n# 1329 \"lib/read.ml\"\n# 1329 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 1)\nand\n\n# 336 \"lib/read.mll\"\n \n# 336 \"lib/read.mll\"\n b\n\n# 1334 \"lib/read.ml\"\n# 1334 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 2)\nand\n\n# 336 \"lib/read.mll\"\n \n# 336 \"lib/read.mll\"\n c\n\n# 1339 \"lib/read.ml\"\n# 1339 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 3)\nand\n\n# 336 \"lib/read.mll\"\n \n# 336 \"lib/read.mll\"\n d\n\n# 1344 \"lib/read.ml\"\n# 1344 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 4) in\n\n# 337 \"lib/read.mll\"\n \n# 337 \"lib/read.mll\"\n ( let x =\n (hex a lsl 12) lor (hex b lsl 8) lor (hex c lsl 4) lor hex d\n in\n if x >= 0xD800 && x <= 0xDBFF then\n finish_surrogate_pair v x lexbuf\n else\n utf8_of_code v.buf x\n )\n\n# 1355 \"lib/read.ml\"\n\n \n# 1356 \"lib/read.ml\"\n | 7 ->\n\n# 345 \"lib/read.mll\"\n \n# 345 \"lib/read.mll\"\n ( long_error \"Invalid escape sequence\" v lexbuf )\n\n# 1360 \"lib/read.ml\"\n\n \n# 1361 \"lib/read.ml\"\n | 8 ->\n\n# 346 \"lib/read.mll\"\n \n# 346 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1365 \"lib/read.ml\"\n\n \n# 1366 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_escaped_char_rec v lexbuf __ocaml_lex_state\n\nand finish_surrogate_pair v x lexbuf =\n __ocaml_lex_finish_surrogate_pair_rec v x lexbuf 82\nand __ocaml_lex_finish_surrogate_pair_rec v x lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\nlet\n\n# 349 \"lib/read.mll\"\n \n# 349 \"lib/read.mll\"\n a\n\n# 1378 \"lib/read.ml\"\n# 1378 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 2)\nand\n\n# 349 \"lib/read.mll\"\n \n# 349 \"lib/read.mll\"\n b\n\n# 1383 \"lib/read.ml\"\n# 1383 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 3)\nand\n\n# 349 \"lib/read.mll\"\n \n# 349 \"lib/read.mll\"\n c\n\n# 1388 \"lib/read.ml\"\n# 1388 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 4)\nand\n\n# 349 \"lib/read.mll\"\n \n# 349 \"lib/read.mll\"\n d\n\n# 1393 \"lib/read.ml\"\n# 1393 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 5) in\n\n# 350 \"lib/read.mll\"\n \n# 350 \"lib/read.mll\"\n ( let y =\n (hex a lsl 12) lor (hex b lsl 8) lor (hex c lsl 4) lor hex d\n in\n if y >= 0xDC00 && y <= 0xDFFF then\n utf8_of_surrogate_pair v.buf x y\n else\n long_error \"Invalid low surrogate for code point beyond U+FFFF\"\n v lexbuf\n )\n\n# 1405 \"lib/read.ml\"\n\n \n# 1406 \"lib/read.ml\"\n | 1 ->\n\n# 359 \"lib/read.mll\"\n \n# 359 \"lib/read.mll\"\n ( long_error \"Missing escape sequence representing low surrogate \\\n for code point beyond U+FFFF\" v lexbuf )\n\n# 1411 \"lib/read.ml\"\n\n \n# 1412 \"lib/read.ml\"\n | 2 ->\n\n# 361 \"lib/read.mll\"\n \n# 361 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1416 \"lib/read.ml\"\n\n \n# 1417 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_surrogate_pair_rec v x lexbuf __ocaml_lex_state\n\nand finish_stringlit v lexbuf =\n __ocaml_lex_finish_stringlit_rec v lexbuf 91\nand __ocaml_lex_finish_stringlit_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 366 \"lib/read.mll\"\n \n# 366 \"lib/read.mll\"\n ( let len = lexbuf.lex_curr_pos - lexbuf.lex_start_pos in\n let s = Bytes.create (len+1) in\n Bytes.set s 0 '\"';\n Bytes.blit lexbuf.lex_buffer lexbuf.lex_start_pos s 1 len;\n Bytes.to_string s\n )\n\n# 1433 \"lib/read.ml\"\n\n \n# 1434 \"lib/read.ml\"\n | 1 ->\n\n# 372 \"lib/read.mll\"\n \n# 372 \"lib/read.mll\"\n ( long_error \"Invalid string literal\" v lexbuf )\n\n# 1438 \"lib/read.ml\"\n\n \n# 1439 \"lib/read.ml\"\n | 2 ->\n\n# 373 \"lib/read.mll\"\n \n# 373 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1443 \"lib/read.ml\"\n\n \n# 1444 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_stringlit_rec v lexbuf __ocaml_lex_state\n\nand finish_variant v lexbuf =\n __ocaml_lex_finish_variant_rec v lexbuf 102\nand __ocaml_lex_finish_variant_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 376 \"lib/read.mll\"\n \n# 376 \"lib/read.mll\"\n ( let x = read_json v lexbuf in\n read_space v lexbuf;\n read_gt v lexbuf;\n Some x )\n\n# 1458 \"lib/read.ml\"\n\n \n# 1459 \"lib/read.ml\"\n | 1 ->\n\n# 380 \"lib/read.mll\"\n \n# 380 \"lib/read.mll\"\n ( None )\n\n# 1463 \"lib/read.ml\"\n\n \n# 1464 \"lib/read.ml\"\n | 2 ->\n\n# 381 \"lib/read.mll\"\n \n# 381 \"lib/read.mll\"\n ( long_error \"Expected ':' or '>' but found\" v lexbuf )\n\n# 1468 \"lib/read.ml\"\n\n \n# 1469 \"lib/read.ml\"\n | 3 ->\n\n# 382 \"lib/read.mll\"\n \n# 382 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1473 \"lib/read.ml\"\n\n \n# 1474 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_variant_rec v lexbuf __ocaml_lex_state\n\nand read_lt v lexbuf =\n __ocaml_lex_read_lt_rec v lexbuf 107\nand __ocaml_lex_read_lt_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 385 \"lib/read.mll\"\n \n# 385 \"lib/read.mll\"\n ( () )\n\n# 1485 \"lib/read.ml\"\n\n \n# 1486 \"lib/read.ml\"\n | 1 ->\n\n# 386 \"lib/read.mll\"\n \n# 386 \"lib/read.mll\"\n ( long_error \"Expected '<' but found\" v lexbuf )\n\n# 1490 \"lib/read.ml\"\n\n \n# 1491 \"lib/read.ml\"\n | 2 ->\n\n# 387 \"lib/read.mll\"\n \n# 387 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1495 \"lib/read.ml\"\n\n \n# 1496 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_lt_rec v lexbuf __ocaml_lex_state\n\nand read_gt v lexbuf =\n __ocaml_lex_read_gt_rec v lexbuf 111\nand __ocaml_lex_read_gt_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 390 \"lib/read.mll\"\n \n# 390 \"lib/read.mll\"\n ( () )\n\n# 1507 \"lib/read.ml\"\n\n \n# 1508 \"lib/read.ml\"\n | 1 ->\n\n# 391 \"lib/read.mll\"\n \n# 391 \"lib/read.mll\"\n ( long_error \"Expected '>' but found\" v lexbuf )\n\n# 1512 \"lib/read.ml\"\n\n \n# 1513 \"lib/read.ml\"\n | 2 ->\n\n# 392 \"lib/read.mll\"\n \n# 392 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1517 \"lib/read.ml\"\n\n \n# 1518 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_gt_rec v lexbuf __ocaml_lex_state\n\nand read_comma v lexbuf =\n __ocaml_lex_read_comma_rec v lexbuf 115\nand __ocaml_lex_read_comma_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 395 \"lib/read.mll\"\n \n# 395 \"lib/read.mll\"\n ( () )\n\n# 1529 \"lib/read.ml\"\n\n \n# 1530 \"lib/read.ml\"\n | 1 ->\n\n# 396 \"lib/read.mll\"\n \n# 396 \"lib/read.mll\"\n ( long_error \"Expected ',' but found\" v lexbuf )\n\n# 1534 \"lib/read.ml\"\n\n \n# 1535 \"lib/read.ml\"\n | 2 ->\n\n# 397 \"lib/read.mll\"\n \n# 397 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1539 \"lib/read.ml\"\n\n \n# 1540 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_comma_rec v lexbuf __ocaml_lex_state\n\nand start_any_variant v lexbuf =\n __ocaml_lex_start_any_variant_rec v lexbuf 119\nand __ocaml_lex_start_any_variant_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 400 \"lib/read.mll\"\n \n# 400 \"lib/read.mll\"\n ( `Edgy_bracket )\n\n# 1551 \"lib/read.ml\"\n\n \n# 1552 \"lib/read.ml\"\n | 1 ->\n\n# 401 \"lib/read.mll\"\n \n# 401 \"lib/read.mll\"\n ( Bi_outbuf.clear v.buf;\n `Double_quote )\n\n# 1557 \"lib/read.ml\"\n\n \n# 1558 \"lib/read.ml\"\n | 2 ->\n\n# 403 \"lib/read.mll\"\n \n# 403 \"lib/read.mll\"\n ( `Square_bracket )\n\n# 1562 \"lib/read.ml\"\n\n \n# 1563 \"lib/read.ml\"\n | 3 ->\n\n# 404 \"lib/read.mll\"\n \n# 404 \"lib/read.mll\"\n ( long_error \"Expected '<', '\\\"' or '[' but found\" v lexbuf )\n\n# 1567 \"lib/read.ml\"\n\n \n# 1568 \"lib/read.ml\"\n | 4 ->\n\n# 405 \"lib/read.mll\"\n \n# 405 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1572 \"lib/read.ml\"\n\n \n# 1573 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_start_any_variant_rec v lexbuf __ocaml_lex_state\n\nand finish_comment v lexbuf =\n __ocaml_lex_finish_comment_rec v lexbuf 125\nand __ocaml_lex_finish_comment_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 408 \"lib/read.mll\"\n \n# 408 \"lib/read.mll\"\n ( () )\n\n# 1584 \"lib/read.ml\"\n\n \n# 1585 \"lib/read.ml\"\n | 1 ->\n\n# 409 \"lib/read.mll\"\n \n# 409 \"lib/read.mll\"\n ( long_error \"Unterminated comment\" v lexbuf )\n\n# 1589 \"lib/read.ml\"\n\n \n# 1590 \"lib/read.ml\"\n | 2 ->\n\n# 410 \"lib/read.mll\"\n \n# 410 \"lib/read.mll\"\n ( newline v lexbuf; finish_comment v lexbuf )\n\n# 1594 \"lib/read.ml\"\n\n \n# 1595 \"lib/read.ml\"\n | 3 ->\n\n# 411 \"lib/read.mll\"\n \n# 411 \"lib/read.mll\"\n ( finish_comment v lexbuf )\n\n# 1599 \"lib/read.ml\"\n\n \n# 1600 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_comment_rec v lexbuf __ocaml_lex_state\n\nand read_eof lexbuf =\n __ocaml_lex_read_eof_rec lexbuf 131\nand __ocaml_lex_read_eof_rec lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 419 \"lib/read.mll\"\n \n# 419 \"lib/read.mll\"\n ( true )\n\n# 1611 \"lib/read.ml\"\n\n \n# 1612 \"lib/read.ml\"\n | 1 ->\n\n# 420 \"lib/read.mll\"\n \n# 420 \"lib/read.mll\"\n ( false )\n\n# 1616 \"lib/read.ml\"\n\n \n# 1617 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_eof_rec lexbuf __ocaml_lex_state\n\nand read_space v lexbuf =\n __ocaml_lex_read_space_rec v lexbuf 133\nand __ocaml_lex_read_space_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 423 \"lib/read.mll\"\n \n# 423 \"lib/read.mll\"\n ( newline v lexbuf; read_space v lexbuf )\n\n# 1628 \"lib/read.ml\"\n\n \n# 1629 \"lib/read.ml\"\n | 1 ->\n\n# 424 \"lib/read.mll\"\n \n# 424 \"lib/read.mll\"\n ( finish_comment v lexbuf; read_space v lexbuf )\n\n# 1633 \"lib/read.ml\"\n\n \n# 1634 \"lib/read.ml\"\n | 2 ->\n\n# 425 \"lib/read.mll\"\n \n# 425 \"lib/read.mll\"\n ( newline v lexbuf; read_space v lexbuf )\n\n# 1638 \"lib/read.ml\"\n\n \n# 1639 \"lib/read.ml\"\n | 3 ->\n\n# 426 \"lib/read.mll\"\n \n# 426 \"lib/read.mll\"\n ( read_space v lexbuf )\n\n# 1643 \"lib/read.ml\"\n\n \n# 1644 \"lib/read.ml\"\n | 4 ->\n\n# 427 \"lib/read.mll\"\n \n# 427 \"lib/read.mll\"\n ( () )\n\n# 1648 \"lib/read.ml\"\n\n \n# 1649 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_space_rec v lexbuf __ocaml_lex_state\n\nand read_null v lexbuf =\n __ocaml_lex_read_null_rec v lexbuf 140\nand __ocaml_lex_read_null_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 430 \"lib/read.mll\"\n \n# 430 \"lib/read.mll\"\n ( () )\n\n# 1660 \"lib/read.ml\"\n\n \n# 1661 \"lib/read.ml\"\n | 1 ->\n\n# 431 \"lib/read.mll\"\n \n# 431 \"lib/read.mll\"\n ( long_error \"Expected 'null' but found\" v lexbuf )\n\n# 1665 \"lib/read.ml\"\n\n \n# 1666 \"lib/read.ml\"\n | 2 ->\n\n# 432 \"lib/read.mll\"\n \n# 432 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1670 \"lib/read.ml\"\n\n \n# 1671 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_null_rec v lexbuf __ocaml_lex_state\n\nand read_null_if_possible v lexbuf =\n __ocaml_lex_read_null_if_possible_rec v lexbuf 147\nand __ocaml_lex_read_null_if_possible_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 435 \"lib/read.mll\"\n \n# 435 \"lib/read.mll\"\n ( true )\n\n# 1682 \"lib/read.ml\"\n\n \n# 1683 \"lib/read.ml\"\n | 1 ->\n\n# 436 \"lib/read.mll\"\n \n# 436 \"lib/read.mll\"\n ( false )\n\n# 1687 \"lib/read.ml\"\n\n \n# 1688 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_null_if_possible_rec v lexbuf __ocaml_lex_state\n\nand read_bool v lexbuf =\n __ocaml_lex_read_bool_rec v lexbuf 152\nand __ocaml_lex_read_bool_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 439 \"lib/read.mll\"\n \n# 439 \"lib/read.mll\"\n ( true )\n\n# 1699 \"lib/read.ml\"\n\n \n# 1700 \"lib/read.ml\"\n | 1 ->\n\n# 440 \"lib/read.mll\"\n \n# 440 \"lib/read.mll\"\n ( false )\n\n# 1704 \"lib/read.ml\"\n\n \n# 1705 \"lib/read.ml\"\n | 2 ->\n\n# 443 \"lib/read.mll\"\n \n# 443 \"lib/read.mll\"\n ( true )\n\n# 1709 \"lib/read.ml\"\n\n \n# 1710 \"lib/read.ml\"\n | 3 ->\n\n# 444 \"lib/read.mll\"\n \n# 444 \"lib/read.mll\"\n ( false )\n\n# 1714 \"lib/read.ml\"\n\n \n# 1715 \"lib/read.ml\"\n | 4 ->\n\n# 446 \"lib/read.mll\"\n \n# 446 \"lib/read.mll\"\n ( long_error \"Expected 'true' or 'false' but found\" v lexbuf )\n\n# 1719 \"lib/read.ml\"\n\n \n# 1720 \"lib/read.ml\"\n | 5 ->\n\n# 447 \"lib/read.mll\"\n \n# 447 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1724 \"lib/read.ml\"\n\n \n# 1725 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_bool_rec v lexbuf __ocaml_lex_state\n\nand read_int v lexbuf =\n __ocaml_lex_read_int_rec v lexbuf 176\nand __ocaml_lex_read_int_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 450 \"lib/read.mll\"\n \n# 450 \"lib/read.mll\"\n ( try extract_positive_int lexbuf\n with Int_overflow ->\n lexer_error \"Int overflow\" v lexbuf )\n\n# 1738 \"lib/read.ml\"\n\n \n# 1739 \"lib/read.ml\"\n | 1 ->\n\n# 453 \"lib/read.mll\"\n \n# 453 \"lib/read.mll\"\n ( try extract_negative_int lexbuf\n with Int_overflow ->\n lexer_error \"Int overflow\" v lexbuf )\n\n# 1745 \"lib/read.ml\"\n\n \n# 1746 \"lib/read.ml\"\n | 2 ->\n\n# 456 \"lib/read.mll\"\n \n# 456 \"lib/read.mll\"\n ( (* Support for double-quoted \"ints\" *)\n Bi_outbuf.clear v.buf;\n let s = finish_string v lexbuf in\n try\n (* Any OCaml-compliant int will pass,\n including hexadecimal and octal notations,\n and embedded underscores *)\n int_of_string s\n with _ ->\n custom_error\n \"Expected an integer but found a string that \\\n doesn't even represent an integer\"\n v lexbuf\n )\n\n# 1763 \"lib/read.ml\"\n\n \n# 1764 \"lib/read.ml\"\n | 3 ->\n\n# 470 \"lib/read.mll\"\n \n# 470 \"lib/read.mll\"\n ( long_error \"Expected integer but found\" v lexbuf )\n\n# 1768 \"lib/read.ml\"\n\n \n# 1769 \"lib/read.ml\"\n | 4 ->\n\n# 471 \"lib/read.mll\"\n \n# 471 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1773 \"lib/read.ml\"\n\n \n# 1774 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_int_rec v lexbuf __ocaml_lex_state\n\nand read_int32 v lexbuf =\n __ocaml_lex_read_int32_rec v lexbuf 185\nand __ocaml_lex_read_int32_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 474 \"lib/read.mll\"\n \n# 474 \"lib/read.mll\"\n ( try Int32.of_string (Lexing.lexeme lexbuf)\n with _ ->\n lexer_error \"Int32 overflow\" v lexbuf )\n\n# 1787 \"lib/read.ml\"\n\n \n# 1788 \"lib/read.ml\"\n | 1 ->\n\n# 477 \"lib/read.mll\"\n \n# 477 \"lib/read.mll\"\n ( (* Support for double-quoted \"ints\" *)\n Bi_outbuf.clear v.buf;\n let s = finish_string v lexbuf in\n try\n (* Any OCaml-compliant int will pass,\n including hexadecimal and octal notations,\n and embedded underscores *)\n Int32.of_string s\n with _ ->\n custom_error\n \"Expected an int32 but found a string that \\\n doesn't even represent an integer\"\n v lexbuf\n )\n\n# 1805 \"lib/read.ml\"\n\n \n# 1806 \"lib/read.ml\"\n | 2 ->\n\n# 491 \"lib/read.mll\"\n \n# 491 \"lib/read.mll\"\n ( long_error \"Expected int32 but found\" v lexbuf )\n\n# 1810 \"lib/read.ml\"\n\n \n# 1811 \"lib/read.ml\"\n | 3 ->\n\n# 492 \"lib/read.mll\"\n \n# 492 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1815 \"lib/read.ml\"\n\n \n# 1816 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_int32_rec v lexbuf __ocaml_lex_state\n\nand read_int64 v lexbuf =\n __ocaml_lex_read_int64_rec v lexbuf 192\nand __ocaml_lex_read_int64_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 495 \"lib/read.mll\"\n \n# 495 \"lib/read.mll\"\n ( try Int64.of_string (Lexing.lexeme lexbuf)\n with _ ->\n lexer_error \"Int32 overflow\" v lexbuf )\n\n# 1829 \"lib/read.ml\"\n\n \n# 1830 \"lib/read.ml\"\n | 1 ->\n\n# 498 \"lib/read.mll\"\n \n# 498 \"lib/read.mll\"\n ( (* Support for double-quoted \"ints\" *)\n Bi_outbuf.clear v.buf;\n let s = finish_string v lexbuf in\n try\n (* Any OCaml-compliant int will pass,\n including hexadecimal and octal notations,\n and embedded underscores *)\n Int64.of_string s\n with _ ->\n custom_error\n \"Expected an int64 but found a string that \\\n doesn't even represent an integer\"\n v lexbuf\n )\n\n# 1847 \"lib/read.ml\"\n\n \n# 1848 \"lib/read.ml\"\n | 2 ->\n\n# 512 \"lib/read.mll\"\n \n# 512 \"lib/read.mll\"\n ( long_error \"Expected int64 but found\" v lexbuf )\n\n# 1852 \"lib/read.ml\"\n\n \n# 1853 \"lib/read.ml\"\n | 3 ->\n\n# 513 \"lib/read.mll\"\n \n# 513 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1857 \"lib/read.ml\"\n\n \n# 1858 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_int64_rec v lexbuf __ocaml_lex_state\n\nand read_number v lexbuf =\n __ocaml_lex_read_number_rec v lexbuf 199\nand __ocaml_lex_read_number_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 516 \"lib/read.mll\"\n \n# 516 \"lib/read.mll\"\n ( nan )\n\n# 1869 \"lib/read.ml\"\n\n \n# 1870 \"lib/read.ml\"\n | 1 ->\n\n# 517 \"lib/read.mll\"\n \n# 517 \"lib/read.mll\"\n ( infinity )\n\n# 1874 \"lib/read.ml\"\n\n \n# 1875 \"lib/read.ml\"\n | 2 ->\n\n# 518 \"lib/read.mll\"\n \n# 518 \"lib/read.mll\"\n ( neg_infinity )\n\n# 1879 \"lib/read.ml\"\n\n \n# 1880 \"lib/read.ml\"\n | 3 ->\n\n# 519 \"lib/read.mll\"\n \n# 519 \"lib/read.mll\"\n ( float_of_string (lexeme lexbuf) )\n\n# 1884 \"lib/read.ml\"\n\n \n# 1885 \"lib/read.ml\"\n | 4 ->\n\n# 520 \"lib/read.mll\"\n \n# 520 \"lib/read.mll\"\n ( Bi_outbuf.clear v.buf;\n let s = finish_string v lexbuf in\n try\n (* Any OCaml-compliant float will pass,\n including hexadecimal and octal notations,\n and embedded underscores. *)\n float_of_string s\n with _ ->\n match s with\n \"NaN\" -> nan\n | \"Infinity\" -> infinity\n | \"-Infinity\" -> neg_infinity\n | _ ->\n custom_error\n \"Expected a number but found a string that \\\n doesn't even represent a number\"\n v lexbuf\n )\n\n# 1906 \"lib/read.ml\"\n\n \n# 1907 \"lib/read.ml\"\n | 5 ->\n\n# 538 \"lib/read.mll\"\n \n# 538 \"lib/read.mll\"\n ( long_error \"Expected number but found\" v lexbuf )\n\n# 1911 \"lib/read.ml\"\n\n \n# 1912 \"lib/read.ml\"\n | 6 ->\n\n# 539 \"lib/read.mll\"\n \n# 539 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1916 \"lib/read.ml\"\n\n \n# 1917 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_number_rec v lexbuf __ocaml_lex_state\n\nand read_string v lexbuf =\n __ocaml_lex_read_string_rec v lexbuf 233\nand __ocaml_lex_read_string_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 542 \"lib/read.mll\"\n \n# 542 \"lib/read.mll\"\n ( Bi_outbuf.clear v.buf;\n finish_string v lexbuf )\n\n# 1929 \"lib/read.ml\"\n\n \n# 1930 \"lib/read.ml\"\n | 1 ->\n\n# 544 \"lib/read.mll\"\n \n# 544 \"lib/read.mll\"\n ( long_error \"Expected '\\\"' but found\" v lexbuf )\n\n# 1934 \"lib/read.ml\"\n\n \n# 1935 \"lib/read.ml\"\n | 2 ->\n\n# 545 \"lib/read.mll\"\n \n# 545 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1939 \"lib/read.ml\"\n\n \n# 1940 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_string_rec v lexbuf __ocaml_lex_state\n\nand read_ident v lexbuf =\n __ocaml_lex_read_ident_rec v lexbuf 237\nand __ocaml_lex_read_ident_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 548 \"lib/read.mll\"\n \n# 548 \"lib/read.mll\"\n ( Bi_outbuf.clear v.buf;\n finish_string v lexbuf )\n\n# 1952 \"lib/read.ml\"\n\n \n# 1953 \"lib/read.ml\"\n | 1 ->\nlet\n\n# 550 \"lib/read.mll\"\n \n# 550 \"lib/read.mll\"\n s\n\n# 1958 \"lib/read.ml\"\n# 1958 \"lib/read.ml\"\n= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos lexbuf.Lexing.lex_curr_pos in\n\n# 551 \"lib/read.mll\"\n \n# 551 \"lib/read.mll\"\n ( s )\n\n# 1962 \"lib/read.ml\"\n\n \n# 1963 \"lib/read.ml\"\n | 2 ->\n\n# 552 \"lib/read.mll\"\n \n# 552 \"lib/read.mll\"\n ( long_error \"Expected string or identifier but found\" v lexbuf )\n\n# 1967 \"lib/read.ml\"\n\n \n# 1968 \"lib/read.ml\"\n | 3 ->\n\n# 553 \"lib/read.mll\"\n \n# 553 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1972 \"lib/read.ml\"\n\n \n# 1973 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_ident_rec v lexbuf __ocaml_lex_state\n\nand map_ident v f lexbuf =\n __ocaml_lex_map_ident_rec v f lexbuf 242\nand __ocaml_lex_map_ident_rec v f lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 556 \"lib/read.mll\"\n \n# 556 \"lib/read.mll\"\n ( Bi_outbuf.clear v.buf;\n map_string v f lexbuf )\n\n# 1985 \"lib/read.ml\"\n\n \n# 1986 \"lib/read.ml\"\n | 1 ->\n\n# 559 \"lib/read.mll\"\n \n# 559 \"lib/read.mll\"\n ( map_lexeme f lexbuf )\n\n# 1990 \"lib/read.ml\"\n\n \n# 1991 \"lib/read.ml\"\n | 2 ->\n\n# 560 \"lib/read.mll\"\n \n# 560 \"lib/read.mll\"\n ( long_error \"Expected string or identifier but found\" v lexbuf )\n\n# 1995 \"lib/read.ml\"\n\n \n# 1996 \"lib/read.ml\"\n | 3 ->\n\n# 561 \"lib/read.mll\"\n \n# 561 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2000 \"lib/read.ml\"\n\n \n# 2001 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_map_ident_rec v f lexbuf __ocaml_lex_state\n\nand read_sequence read_cell init_acc v lexbuf =\n __ocaml_lex_read_sequence_rec read_cell init_acc v lexbuf 247\nand __ocaml_lex_read_sequence_rec read_cell init_acc v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 564 \"lib/read.mll\"\n \n# 564 \"lib/read.mll\"\n ( let acc = ref init_acc in\n try\n read_space v lexbuf;\n read_array_end lexbuf;\n acc := read_cell !acc v lexbuf;\n while true do\n read_space v lexbuf;\n read_array_sep v lexbuf;\n read_space v lexbuf;\n acc := read_cell !acc v lexbuf;\n done;\n assert false\n with End_of_array ->\n !acc\n )\n\n# 2026 \"lib/read.ml\"\n\n \n# 2027 \"lib/read.ml\"\n | 1 ->\n\n# 579 \"lib/read.mll\"\n \n# 579 \"lib/read.mll\"\n ( long_error \"Expected '[' but found\" v lexbuf )\n\n# 2031 \"lib/read.ml\"\n\n \n# 2032 \"lib/read.ml\"\n | 2 ->\n\n# 580 \"lib/read.mll\"\n \n# 580 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2036 \"lib/read.ml\"\n\n \n# 2037 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_sequence_rec read_cell init_acc v lexbuf __ocaml_lex_state\n\nand read_list_rev read_cell v lexbuf =\n __ocaml_lex_read_list_rev_rec read_cell v lexbuf 251\nand __ocaml_lex_read_list_rev_rec read_cell v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 583 \"lib/read.mll\"\n \n# 583 \"lib/read.mll\"\n ( let acc = ref [] in\n try\n read_space v lexbuf;\n read_array_end lexbuf;\n acc := read_cell v lexbuf :: !acc;\n while true do\n read_space v lexbuf;\n read_array_sep v lexbuf;\n read_space v lexbuf;\n acc := read_cell v lexbuf :: !acc;\n done;\n assert false\n with End_of_array ->\n !acc\n )\n\n# 2062 \"lib/read.ml\"\n\n \n# 2063 \"lib/read.ml\"\n | 1 ->\n\n# 598 \"lib/read.mll\"\n \n# 598 \"lib/read.mll\"\n ( long_error \"Expected '[' but found\" v lexbuf )\n\n# 2067 \"lib/read.ml\"\n\n \n# 2068 \"lib/read.ml\"\n | 2 ->\n\n# 599 \"lib/read.mll\"\n \n# 599 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2072 \"lib/read.ml\"\n\n \n# 2073 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_list_rev_rec read_cell v lexbuf __ocaml_lex_state\n\nand read_array_end lexbuf =\n __ocaml_lex_read_array_end_rec lexbuf 255\nand __ocaml_lex_read_array_end_rec lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 602 \"lib/read.mll\"\n \n# 602 \"lib/read.mll\"\n ( raise End_of_array )\n\n# 2084 \"lib/read.ml\"\n\n \n# 2085 \"lib/read.ml\"\n | 1 ->\n\n# 603 \"lib/read.mll\"\n \n# 603 \"lib/read.mll\"\n ( () )\n\n# 2089 \"lib/read.ml\"\n\n \n# 2090 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_array_end_rec lexbuf __ocaml_lex_state\n\nand read_array_sep v lexbuf =\n __ocaml_lex_read_array_sep_rec v lexbuf 257\nand __ocaml_lex_read_array_sep_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 606 \"lib/read.mll\"\n \n# 606 \"lib/read.mll\"\n ( () )\n\n# 2101 \"lib/read.ml\"\n\n \n# 2102 \"lib/read.ml\"\n | 1 ->\n\n# 607 \"lib/read.mll\"\n \n# 607 \"lib/read.mll\"\n ( raise End_of_array )\n\n# 2106 \"lib/read.ml\"\n\n \n# 2107 \"lib/read.ml\"\n | 2 ->\n\n# 608 \"lib/read.mll\"\n \n# 608 \"lib/read.mll\"\n ( long_error \"Expected ',' or ']' but found\" v lexbuf )\n\n# 2111 \"lib/read.ml\"\n\n \n# 2112 \"lib/read.ml\"\n | 3 ->\n\n# 609 \"lib/read.mll\"\n \n# 609 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2116 \"lib/read.ml\"\n\n \n# 2117 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_array_sep_rec v lexbuf __ocaml_lex_state\n\nand read_tuple read_cell init_acc v lexbuf =\n __ocaml_lex_read_tuple_rec read_cell init_acc v lexbuf 262\nand __ocaml_lex_read_tuple_rec read_cell init_acc v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 613 \"lib/read.mll\"\n \n# 613 \"lib/read.mll\"\n (\n \n# 633 \"lib/read.mll\"\n long_error \"Invalid token\" v lexbuf\n \n# 635 \"lib/read.mll\"\n )\n\n# 2150 \"lib/read.ml\"\n\n \n# 2151 \"lib/read.ml\"\n | 1 ->\n\n# 636 \"lib/read.mll\"\n \n# 636 \"lib/read.mll\"\n ( long_error \"Expected ')' but found\" v lexbuf )\n\n# 2155 \"lib/read.ml\"\n\n \n# 2156 \"lib/read.ml\"\n | 2 ->\n\n# 637 \"lib/read.mll\"\n \n# 637 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2160 \"lib/read.ml\"\n\n \n# 2161 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_tuple_rec read_cell init_acc v lexbuf __ocaml_lex_state\n\nand read_tuple_end lexbuf =\n __ocaml_lex_read_tuple_end_rec lexbuf 266\nand __ocaml_lex_read_tuple_end_rec lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 640 \"lib/read.mll\"\n \n# 640 \"lib/read.mll\"\n ( raise End_of_tuple )\n\n# 2172 \"lib/read.ml\"\n\n \n# 2173 \"lib/read.ml\"\n | 1 ->\n\n# 641 \"lib/read.mll\"\n \n# 641 \"lib/read.mll\"\n ( () )\n\n# 2177 \"lib/read.ml\"\n\n \n# 2178 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_tuple_end_rec lexbuf __ocaml_lex_state\n\nand read_tuple_end2 v std lexbuf =\n __ocaml_lex_read_tuple_end2_rec v std lexbuf 268\nand __ocaml_lex_read_tuple_end2_rec v std lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 644 \"lib/read.mll\"\n \n# 644 \"lib/read.mll\"\n ( if std then\n long_error \"Expected ')' or '' but found\" v lexbuf\n else\n raise End_of_tuple )\n\n# 2192 \"lib/read.ml\"\n\n \n# 2193 \"lib/read.ml\"\n | 1 ->\n\n# 648 \"lib/read.mll\"\n \n# 648 \"lib/read.mll\"\n ( if std then\n raise End_of_tuple\n else\n long_error \"Expected ']' or '' but found\" v lexbuf )\n\n# 2200 \"lib/read.ml\"\n\n \n# 2201 \"lib/read.ml\"\n | 2 ->\n\n# 652 \"lib/read.mll\"\n \n# 652 \"lib/read.mll\"\n ( () )\n\n# 2205 \"lib/read.ml\"\n\n \n# 2206 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_tuple_end2_rec v std lexbuf __ocaml_lex_state\n\nand read_tuple_sep v lexbuf =\n __ocaml_lex_read_tuple_sep_rec v lexbuf 271\nand __ocaml_lex_read_tuple_sep_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 655 \"lib/read.mll\"\n \n# 655 \"lib/read.mll\"\n ( () )\n\n# 2217 \"lib/read.ml\"\n\n \n# 2218 \"lib/read.ml\"\n | 1 ->\n\n# 656 \"lib/read.mll\"\n \n# 656 \"lib/read.mll\"\n ( raise End_of_tuple )\n\n# 2222 \"lib/read.ml\"\n\n \n# 2223 \"lib/read.ml\"\n | 2 ->\n\n# 657 \"lib/read.mll\"\n \n# 657 \"lib/read.mll\"\n ( long_error \"Expected ',' or ')' but found\" v lexbuf )\n\n# 2227 \"lib/read.ml\"\n\n \n# 2228 \"lib/read.ml\"\n | 3 ->\n\n# 658 \"lib/read.mll\"\n \n# 658 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2232 \"lib/read.ml\"\n\n \n# 2233 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_tuple_sep_rec v lexbuf __ocaml_lex_state\n\nand read_tuple_sep2 v std lexbuf =\n __ocaml_lex_read_tuple_sep2_rec v std lexbuf 276\nand __ocaml_lex_read_tuple_sep2_rec v std lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 661 \"lib/read.mll\"\n \n# 661 \"lib/read.mll\"\n ( () )\n\n# 2244 \"lib/read.ml\"\n\n \n# 2245 \"lib/read.ml\"\n | 1 ->\n\n# 662 \"lib/read.mll\"\n \n# 662 \"lib/read.mll\"\n ( if std then\n long_error \"Expected ',' or ']' but found\" v lexbuf\n else\n raise End_of_tuple )\n\n# 2252 \"lib/read.ml\"\n\n \n# 2253 \"lib/read.ml\"\n | 2 ->\n\n# 666 \"lib/read.mll\"\n \n# 666 \"lib/read.mll\"\n ( if std then\n raise End_of_tuple\n else\n long_error \"Expected ',' or ')' but found\" v lexbuf )\n\n# 2260 \"lib/read.ml\"\n\n \n# 2261 \"lib/read.ml\"\n | 3 ->\n\n# 670 \"lib/read.mll\"\n \n# 670 \"lib/read.mll\"\n ( long_error \"Expected ',' or ')' but found\" v lexbuf )\n\n# 2265 \"lib/read.ml\"\n\n \n# 2266 \"lib/read.ml\"\n | 4 ->\n\n# 671 \"lib/read.mll\"\n \n# 671 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2270 \"lib/read.ml\"\n\n \n# 2271 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_tuple_sep2_rec v std lexbuf __ocaml_lex_state\n\nand read_abstract_fields read_key read_field init_acc v lexbuf =\n __ocaml_lex_read_abstract_fields_rec read_key read_field init_acc v lexbuf 282\nand __ocaml_lex_read_abstract_fields_rec read_key read_field init_acc v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 675 \"lib/read.mll\"\n \n# 675 \"lib/read.mll\"\n ( let acc = ref init_acc in\n try\n read_space v lexbuf;\n read_object_end lexbuf;\n let field_name = read_key v lexbuf in\n read_space v lexbuf;\n read_colon v lexbuf;\n read_space v lexbuf;\n acc := read_field !acc field_name v lexbuf;\n while true do\n read_space v lexbuf;\n read_object_sep v lexbuf;\n read_space v lexbuf;\n let field_name = read_key v lexbuf in\n read_space v lexbuf;\n read_colon v lexbuf;\n read_space v lexbuf;\n acc := read_field !acc field_name v lexbuf;\n done;\n assert false\n with End_of_object ->\n !acc\n )\n\n# 2304 \"lib/read.ml\"\n\n \n# 2305 \"lib/read.ml\"\n | 1 ->\n\n# 698 \"lib/read.mll\"\n \n# 698 \"lib/read.mll\"\n ( long_error \"Expected '{' but found\" v lexbuf )\n\n# 2309 \"lib/read.ml\"\n\n \n# 2310 \"lib/read.ml\"\n | 2 ->\n\n# 699 \"lib/read.mll\"\n \n# 699 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2314 \"lib/read.ml\"\n\n \n# 2315 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_abstract_fields_rec read_key read_field init_acc v lexbuf __ocaml_lex_state\n\nand read_lcurl v lexbuf =\n __ocaml_lex_read_lcurl_rec v lexbuf 286\nand __ocaml_lex_read_lcurl_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 702 \"lib/read.mll\"\n \n# 702 \"lib/read.mll\"\n ( () )\n\n# 2326 \"lib/read.ml\"\n\n \n# 2327 \"lib/read.ml\"\n | 1 ->\n\n# 703 \"lib/read.mll\"\n \n# 703 \"lib/read.mll\"\n ( long_error \"Expected '{' but found\" v lexbuf )\n\n# 2331 \"lib/read.ml\"\n\n \n# 2332 \"lib/read.ml\"\n | 2 ->\n\n# 704 \"lib/read.mll\"\n \n# 704 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2336 \"lib/read.ml\"\n\n \n# 2337 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_lcurl_rec v lexbuf __ocaml_lex_state\n\nand read_object_end lexbuf =\n __ocaml_lex_read_object_end_rec lexbuf 290\nand __ocaml_lex_read_object_end_rec lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 707 \"lib/read.mll\"\n \n# 707 \"lib/read.mll\"\n ( raise End_of_object )\n\n# 2348 \"lib/read.ml\"\n\n \n# 2349 \"lib/read.ml\"\n | 1 ->\n\n# 708 \"lib/read.mll\"\n \n# 708 \"lib/read.mll\"\n ( () )\n\n# 2353 \"lib/read.ml\"\n\n \n# 2354 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_object_end_rec lexbuf __ocaml_lex_state\n\nand read_object_sep v lexbuf =\n __ocaml_lex_read_object_sep_rec v lexbuf 292\nand __ocaml_lex_read_object_sep_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 711 \"lib/read.mll\"\n \n# 711 \"lib/read.mll\"\n ( () )\n\n# 2365 \"lib/read.ml\"\n\n \n# 2366 \"lib/read.ml\"\n | 1 ->\n\n# 712 \"lib/read.mll\"\n \n# 712 \"lib/read.mll\"\n ( raise End_of_object )\n\n# 2370 \"lib/read.ml\"\n\n \n# 2371 \"lib/read.ml\"\n | 2 ->\n\n# 713 \"lib/read.mll\"\n \n# 713 \"lib/read.mll\"\n ( long_error \"Expected ',' or '}' but found\" v lexbuf )\n\n# 2375 \"lib/read.ml\"\n\n \n# 2376 \"lib/read.ml\"\n | 3 ->\n\n# 714 \"lib/read.mll\"\n \n# 714 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2380 \"lib/read.ml\"\n\n \n# 2381 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_object_sep_rec v lexbuf __ocaml_lex_state\n\nand read_colon v lexbuf =\n __ocaml_lex_read_colon_rec v lexbuf 297\nand __ocaml_lex_read_colon_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 717 \"lib/read.mll\"\n \n# 717 \"lib/read.mll\"\n ( () )\n\n# 2392 \"lib/read.ml\"\n\n \n# 2393 \"lib/read.ml\"\n | 1 ->\n\n# 718 \"lib/read.mll\"\n \n# 718 \"lib/read.mll\"\n ( long_error \"Expected ':' but found\" v lexbuf )\n\n# 2397 \"lib/read.ml\"\n\n \n# 2398 \"lib/read.ml\"\n | 2 ->\n\n# 719 \"lib/read.mll\"\n \n# 719 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2402 \"lib/read.ml\"\n\n \n# 2403 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_colon_rec v lexbuf __ocaml_lex_state\n\nand start_any_tuple v lexbuf =\n __ocaml_lex_start_any_tuple_rec v lexbuf 301\nand __ocaml_lex_start_any_tuple_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 722 \"lib/read.mll\"\n \n# 722 \"lib/read.mll\"\n ( false )\n\n# 2414 \"lib/read.ml\"\n\n \n# 2415 \"lib/read.ml\"\n | 1 ->\n\n# 723 \"lib/read.mll\"\n \n# 723 \"lib/read.mll\"\n ( true )\n\n# 2419 \"lib/read.ml\"\n\n \n# 2420 \"lib/read.ml\"\n | 2 ->\n\n# 724 \"lib/read.mll\"\n \n# 724 \"lib/read.mll\"\n ( long_error \"Expected '(' or '[' but found\" v lexbuf )\n\n# 2424 \"lib/read.ml\"\n\n \n# 2425 \"lib/read.ml\"\n | 3 ->\n\n# 725 \"lib/read.mll\"\n \n# 725 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2429 \"lib/read.ml\"\n\n \n# 2430 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_start_any_tuple_rec v lexbuf __ocaml_lex_state\n\nand read_lpar v lexbuf =\n __ocaml_lex_read_lpar_rec v lexbuf 306\nand __ocaml_lex_read_lpar_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 728 \"lib/read.mll\"\n \n# 728 \"lib/read.mll\"\n ( () )\n\n# 2441 \"lib/read.ml\"\n\n \n# 2442 \"lib/read.ml\"\n | 1 ->\n\n# 729 \"lib/read.mll\"\n \n# 729 \"lib/read.mll\"\n ( long_error \"Expected '(' but found\" v lexbuf )\n\n# 2446 \"lib/read.ml\"\n\n \n# 2447 \"lib/read.ml\"\n | 2 ->\n\n# 730 \"lib/read.mll\"\n \n# 730 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2451 \"lib/read.ml\"\n\n \n# 2452 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_lpar_rec v lexbuf __ocaml_lex_state\n\nand read_rpar v lexbuf =\n __ocaml_lex_read_rpar_rec v lexbuf 310\nand __ocaml_lex_read_rpar_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 733 \"lib/read.mll\"\n \n# 733 \"lib/read.mll\"\n ( () )\n\n# 2463 \"lib/read.ml\"\n\n \n# 2464 \"lib/read.ml\"\n | 1 ->\n\n# 734 \"lib/read.mll\"\n \n# 734 \"lib/read.mll\"\n ( long_error \"Expected ')' but found\" v lexbuf )\n\n# 2468 \"lib/read.ml\"\n\n \n# 2469 \"lib/read.ml\"\n | 2 ->\n\n# 735 \"lib/read.mll\"\n \n# 735 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2473 \"lib/read.ml\"\n\n \n# 2474 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_rpar_rec v lexbuf __ocaml_lex_state\n\nand read_lbr v lexbuf =\n __ocaml_lex_read_lbr_rec v lexbuf 314\nand __ocaml_lex_read_lbr_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 738 \"lib/read.mll\"\n \n# 738 \"lib/read.mll\"\n ( () )\n\n# 2485 \"lib/read.ml\"\n\n \n# 2486 \"lib/read.ml\"\n | 1 ->\n\n# 739 \"lib/read.mll\"\n \n# 739 \"lib/read.mll\"\n ( long_error \"Expected '[' but found\" v lexbuf )\n\n# 2490 \"lib/read.ml\"\n\n \n# 2491 \"lib/read.ml\"\n | 2 ->\n\n# 740 \"lib/read.mll\"\n \n# 740 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2495 \"lib/read.ml\"\n\n \n# 2496 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_lbr_rec v lexbuf __ocaml_lex_state\n\nand read_rbr v lexbuf =\n __ocaml_lex_read_rbr_rec v lexbuf 318\nand __ocaml_lex_read_rbr_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 743 \"lib/read.mll\"\n \n# 743 \"lib/read.mll\"\n ( () )\n\n# 2507 \"lib/read.ml\"\n\n \n# 2508 \"lib/read.ml\"\n | 1 ->\n\n# 744 \"lib/read.mll\"\n \n# 744 \"lib/read.mll\"\n ( long_error \"Expected ']' but found\" v lexbuf )\n\n# 2512 \"lib/read.ml\"\n\n \n# 2513 \"lib/read.ml\"\n | 2 ->\n\n# 745 \"lib/read.mll\"\n \n# 745 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2517 \"lib/read.ml\"\n\n \n# 2518 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_rbr_rec v lexbuf __ocaml_lex_state\n\nand skip_json v lexbuf =\n __ocaml_lex_skip_json_rec v lexbuf 322\nand __ocaml_lex_skip_json_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 751 \"lib/read.mll\"\n \n# 751 \"lib/read.mll\"\n ( () )\n\n# 2529 \"lib/read.ml\"\n\n \n# 2530 \"lib/read.ml\"\n | 1 ->\n\n# 752 \"lib/read.mll\"\n \n# 752 \"lib/read.mll\"\n ( () )\n\n# 2534 \"lib/read.ml\"\n\n \n# 2535 \"lib/read.ml\"\n | 2 ->\n\n# 753 \"lib/read.mll\"\n \n# 753 \"lib/read.mll\"\n ( () )\n\n# 2539 \"lib/read.ml\"\n\n \n# 2540 \"lib/read.ml\"\n | 3 ->\n\n# 754 \"lib/read.mll\"\n \n# 754 \"lib/read.mll\"\n ( () )\n\n# 2544 \"lib/read.ml\"\n\n \n# 2545 \"lib/read.ml\"\n | 4 ->\n\n# 755 \"lib/read.mll\"\n \n# 755 \"lib/read.mll\"\n ( () )\n\n# 2549 \"lib/read.ml\"\n\n \n# 2550 \"lib/read.ml\"\n | 5 ->\n\n# 756 \"lib/read.mll\"\n \n# 756 \"lib/read.mll\"\n ( () )\n\n# 2554 \"lib/read.ml\"\n\n \n# 2555 \"lib/read.ml\"\n | 6 ->\n\n# 757 \"lib/read.mll\"\n \n# 757 \"lib/read.mll\"\n ( finish_skip_stringlit v lexbuf )\n\n# 2559 \"lib/read.ml\"\n\n \n# 2560 \"lib/read.ml\"\n | 7 ->\n\n# 758 \"lib/read.mll\"\n \n# 758 \"lib/read.mll\"\n ( () )\n\n# 2564 \"lib/read.ml\"\n\n \n# 2565 \"lib/read.ml\"\n | 8 ->\n\n# 759 \"lib/read.mll\"\n \n# 759 \"lib/read.mll\"\n ( () )\n\n# 2569 \"lib/read.ml\"\n\n \n# 2570 \"lib/read.ml\"\n | 9 ->\n\n# 761 \"lib/read.mll\"\n \n# 761 \"lib/read.mll\"\n ( try\n read_space v lexbuf;\n read_object_end lexbuf;\n skip_ident v lexbuf;\n read_space v lexbuf;\n read_colon v lexbuf;\n read_space v lexbuf;\n skip_json v lexbuf;\n while true do\n read_space v lexbuf;\n read_object_sep v lexbuf;\n read_space v lexbuf;\n skip_ident v lexbuf;\n read_space v lexbuf;\n read_colon v lexbuf;\n read_space v lexbuf;\n skip_json v lexbuf;\n done;\n assert false\n with End_of_object ->\n ()\n )\n\n# 2595 \"lib/read.ml\"\n\n \n# 2596 \"lib/read.ml\"\n | 10 ->\n\n# 784 \"lib/read.mll\"\n \n# 784 \"lib/read.mll\"\n ( try\n read_space v lexbuf;\n read_array_end lexbuf;\n skip_json v lexbuf;\n while true do\n read_space v lexbuf;\n read_array_sep v lexbuf;\n read_space v lexbuf;\n skip_json v lexbuf;\n done;\n assert false\n with End_of_array ->\n ()\n )\n\n# 2613 \"lib/read.ml\"\n\n \n# 2614 \"lib/read.ml\"\n | 11 ->\n\n# 799 \"lib/read.mll\"\n \n# 799 \"lib/read.mll\"\n (\n \n# 815 \"lib/read.mll\"\n long_error \"Invalid token\" v lexbuf\n \n# 817 \"lib/read.mll\"\n )\n\n# 2636 \"lib/read.ml\"\n\n \n# 2637 \"lib/read.ml\"\n | 12 ->\n\n# 819 \"lib/read.mll\"\n \n# 819 \"lib/read.mll\"\n (\n \n# 826 \"lib/read.mll\"\n long_error \"Invalid token\" v lexbuf\n \n# 828 \"lib/read.mll\"\n )\n\n# 2650 \"lib/read.ml\"\n\n \n# 2651 \"lib/read.ml\"\n | 13 ->\n\n# 830 \"lib/read.mll\"\n \n# 830 \"lib/read.mll\"\n ( skip_json v lexbuf )\n\n# 2655 \"lib/read.ml\"\n\n \n# 2656 \"lib/read.ml\"\n | 14 ->\n\n# 831 \"lib/read.mll\"\n \n# 831 \"lib/read.mll\"\n ( finish_comment v lexbuf; skip_json v lexbuf )\n\n# 2660 \"lib/read.ml\"\n\n \n# 2661 \"lib/read.ml\"\n | 15 ->\n\n# 832 \"lib/read.mll\"\n \n# 832 \"lib/read.mll\"\n ( newline v lexbuf; skip_json v lexbuf )\n\n# 2665 \"lib/read.ml\"\n\n \n# 2666 \"lib/read.ml\"\n | 16 ->\n\n# 833 \"lib/read.mll\"\n \n# 833 \"lib/read.mll\"\n ( skip_json v lexbuf )\n\n# 2670 \"lib/read.ml\"\n\n \n# 2671 \"lib/read.ml\"\n | 17 ->\n\n# 834 \"lib/read.mll\"\n \n# 834 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2675 \"lib/read.ml\"\n\n \n# 2676 \"lib/read.ml\"\n | 18 ->\n\n# 835 \"lib/read.mll\"\n \n# 835 \"lib/read.mll\"\n ( long_error \"Invalid token\" v lexbuf )\n\n# 2680 \"lib/read.ml\"\n\n \n# 2681 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_skip_json_rec v lexbuf __ocaml_lex_state\n\nand finish_skip_stringlit v lexbuf =\n __ocaml_lex_finish_skip_stringlit_rec v lexbuf 378\nand __ocaml_lex_finish_skip_stringlit_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 841 \"lib/read.mll\"\n \n# 841 \"lib/read.mll\"\n ( () )\n\n# 2692 \"lib/read.ml\"\n\n \n# 2693 \"lib/read.ml\"\n | 1 ->\n\n# 842 \"lib/read.mll\"\n \n# 842 \"lib/read.mll\"\n ( long_error \"Invalid string literal\" v lexbuf )\n\n# 2697 \"lib/read.ml\"\n\n \n# 2698 \"lib/read.ml\"\n | 2 ->\n\n# 843 \"lib/read.mll\"\n \n# 843 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2702 \"lib/read.ml\"\n\n \n# 2703 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_skip_stringlit_rec v lexbuf __ocaml_lex_state\n\nand finish_skip_variant v lexbuf =\n __ocaml_lex_finish_skip_variant_rec v lexbuf 389\nand __ocaml_lex_finish_skip_variant_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 846 \"lib/read.mll\"\n \n# 846 \"lib/read.mll\"\n ( skip_json v lexbuf;\n read_space v lexbuf;\n read_gt v lexbuf )\n\n# 2716 \"lib/read.ml\"\n\n \n# 2717 \"lib/read.ml\"\n | 1 ->\n\n# 849 \"lib/read.mll\"\n \n# 849 \"lib/read.mll\"\n ( () )\n\n# 2721 \"lib/read.ml\"\n\n \n# 2722 \"lib/read.ml\"\n | 2 ->\n\n# 850 \"lib/read.mll\"\n \n# 850 \"lib/read.mll\"\n ( long_error \"Expected ':' or '>' but found\" v lexbuf )\n\n# 2726 \"lib/read.ml\"\n\n \n# 2727 \"lib/read.ml\"\n | 3 ->\n\n# 851 \"lib/read.mll\"\n \n# 851 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2731 \"lib/read.ml\"\n\n \n# 2732 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_skip_variant_rec v lexbuf __ocaml_lex_state\n\nand skip_ident v lexbuf =\n __ocaml_lex_skip_ident_rec v lexbuf 394\nand __ocaml_lex_skip_ident_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 854 \"lib/read.mll\"\n \n# 854 \"lib/read.mll\"\n ( finish_skip_stringlit v lexbuf )\n\n# 2743 \"lib/read.ml\"\n\n \n# 2744 \"lib/read.ml\"\n | 1 ->\n\n# 855 \"lib/read.mll\"\n \n# 855 \"lib/read.mll\"\n ( () )\n\n# 2748 \"lib/read.ml\"\n\n \n# 2749 \"lib/read.ml\"\n | 2 ->\n\n# 856 \"lib/read.mll\"\n \n# 856 \"lib/read.mll\"\n ( long_error \"Expected string or identifier but found\" v lexbuf )\n\n# 2753 \"lib/read.ml\"\n\n \n# 2754 \"lib/read.ml\"\n | 3 ->\n\n# 857 \"lib/read.mll\"\n \n# 857 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2758 \"lib/read.ml\"\n\n \n# 2759 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_skip_ident_rec v lexbuf __ocaml_lex_state\n\nand buffer_json v lexbuf =\n __ocaml_lex_buffer_json_rec v lexbuf 399\nand __ocaml_lex_buffer_json_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 870 \"lib/read.mll\"\n \n# 870 \"lib/read.mll\"\n ( add_lexeme v.buf lexbuf )\n\n# 2770 \"lib/read.ml\"\n\n \n# 2771 \"lib/read.ml\"\n | 1 ->\n\n# 872 \"lib/read.mll\"\n \n# 872 \"lib/read.mll\"\n ( finish_buffer_stringlit v lexbuf )\n\n# 2775 \"lib/read.ml\"\n\n \n# 2776 \"lib/read.ml\"\n | 2 ->\n\n# 873 \"lib/read.mll\"\n \n# 873 \"lib/read.mll\"\n ( try\n Bi_outbuf.add_char v.buf '{';\n buffer_space v lexbuf;\n buffer_object_end v lexbuf;\n buffer_ident v lexbuf;\n buffer_space v lexbuf;\n buffer_colon v lexbuf;\n buffer_space v lexbuf;\n buffer_json v lexbuf;\n while true do\n buffer_space v lexbuf;\n buffer_object_sep v lexbuf;\n buffer_space v lexbuf;\n buffer_ident v lexbuf;\n buffer_space v lexbuf;\n buffer_colon v lexbuf;\n buffer_space v lexbuf;\n buffer_json v lexbuf;\n done;\n assert false\n with End_of_object ->\n ()\n )\n\n# 2802 \"lib/read.ml\"\n\n \n# 2803 \"lib/read.ml\"\n | 3 ->\n\n# 897 \"lib/read.mll\"\n \n# 897 \"lib/read.mll\"\n ( try\n Bi_outbuf.add_char v.buf '[';\n buffer_space v lexbuf;\n buffer_array_end v lexbuf;\n buffer_json v lexbuf;\n while true do\n buffer_space v lexbuf;\n buffer_array_sep v lexbuf;\n buffer_space v lexbuf;\n buffer_json v lexbuf;\n done;\n assert false\n with End_of_array ->\n ()\n )\n\n# 2821 \"lib/read.ml\"\n\n \n# 2822 \"lib/read.ml\"\n | 4 ->\n\n# 913 \"lib/read.mll\"\n \n# 913 \"lib/read.mll\"\n (\n \n# 930 \"lib/read.mll\"\n long_error \"Invalid token\" v lexbuf\n \n# 932 \"lib/read.mll\"\n )\n\n# 2845 \"lib/read.ml\"\n\n \n# 2846 \"lib/read.ml\"\n | 5 ->\n\n# 934 \"lib/read.mll\"\n \n# 934 \"lib/read.mll\"\n (\n \n# 942 \"lib/read.mll\"\n long_error \"Invalid token\" v lexbuf\n \n# 944 \"lib/read.mll\"\n )\n\n# 2860 \"lib/read.ml\"\n\n \n# 2861 \"lib/read.ml\"\n | 6 ->\n\n# 946 \"lib/read.mll\"\n \n# 946 \"lib/read.mll\"\n ( add_lexeme v.buf lexbuf; buffer_json v lexbuf )\n\n# 2865 \"lib/read.ml\"\n\n \n# 2866 \"lib/read.ml\"\n | 7 ->\n\n# 947 \"lib/read.mll\"\n \n# 947 \"lib/read.mll\"\n ( Bi_outbuf.add_string v.buf \"/*\";\n finish_buffer_comment v lexbuf;\n buffer_json v lexbuf )\n\n# 2872 \"lib/read.ml\"\n\n \n# 2873 \"lib/read.ml\"\n | 8 ->\n\n# 950 \"lib/read.mll\"\n \n# 950 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\\n';\n newline v lexbuf;\n buffer_json v lexbuf )\n\n# 2879 \"lib/read.ml\"\n\n \n# 2880 \"lib/read.ml\"\n | 9 ->\n\n# 953 \"lib/read.mll\"\n \n# 953 \"lib/read.mll\"\n ( add_lexeme v.buf lexbuf; buffer_json v lexbuf )\n\n# 2884 \"lib/read.ml\"\n\n \n# 2885 \"lib/read.ml\"\n | 10 ->\n\n# 954 \"lib/read.mll\"\n \n# 954 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2889 \"lib/read.ml\"\n\n \n# 2890 \"lib/read.ml\"\n | 11 ->\n\n# 955 \"lib/read.mll\"\n \n# 955 \"lib/read.mll\"\n ( long_error \"Invalid token\" v lexbuf )\n\n# 2894 \"lib/read.ml\"\n\n \n# 2895 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_json_rec v lexbuf __ocaml_lex_state\n\nand finish_buffer_stringlit v lexbuf =\n __ocaml_lex_finish_buffer_stringlit_rec v lexbuf 450\nand __ocaml_lex_finish_buffer_stringlit_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 961 \"lib/read.mll\"\n \n# 961 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\"';\n add_lexeme v.buf lexbuf\n )\n\n# 2908 \"lib/read.ml\"\n\n \n# 2909 \"lib/read.ml\"\n | 1 ->\n\n# 964 \"lib/read.mll\"\n \n# 964 \"lib/read.mll\"\n ( long_error \"Invalid string literal\" v lexbuf )\n\n# 2913 \"lib/read.ml\"\n\n \n# 2914 \"lib/read.ml\"\n | 2 ->\n\n# 965 \"lib/read.mll\"\n \n# 965 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2918 \"lib/read.ml\"\n\n \n# 2919 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_buffer_stringlit_rec v lexbuf __ocaml_lex_state\n\nand finish_buffer_variant v lexbuf =\n __ocaml_lex_finish_buffer_variant_rec v lexbuf 461\nand __ocaml_lex_finish_buffer_variant_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 968 \"lib/read.mll\"\n \n# 968 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf ':';\n buffer_json v lexbuf;\n buffer_space v lexbuf;\n buffer_gt v lexbuf )\n\n# 2933 \"lib/read.ml\"\n\n \n# 2934 \"lib/read.ml\"\n | 1 ->\n\n# 972 \"lib/read.mll\"\n \n# 972 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '>' )\n\n# 2938 \"lib/read.ml\"\n\n \n# 2939 \"lib/read.ml\"\n | 2 ->\n\n# 973 \"lib/read.mll\"\n \n# 973 \"lib/read.mll\"\n ( long_error \"Expected ':' or '>' but found\" v lexbuf )\n\n# 2943 \"lib/read.ml\"\n\n \n# 2944 \"lib/read.ml\"\n | 3 ->\n\n# 974 \"lib/read.mll\"\n \n# 974 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2948 \"lib/read.ml\"\n\n \n# 2949 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_buffer_variant_rec v lexbuf __ocaml_lex_state\n\nand buffer_ident v lexbuf =\n __ocaml_lex_buffer_ident_rec v lexbuf 466\nand __ocaml_lex_buffer_ident_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 977 \"lib/read.mll\"\n \n# 977 \"lib/read.mll\"\n ( finish_buffer_stringlit v lexbuf )\n\n# 2960 \"lib/read.ml\"\n\n \n# 2961 \"lib/read.ml\"\n | 1 ->\n\n# 978 \"lib/read.mll\"\n \n# 978 \"lib/read.mll\"\n ( add_lexeme v.buf lexbuf )\n\n# 2965 \"lib/read.ml\"\n\n \n# 2966 \"lib/read.ml\"\n | 2 ->\n\n# 979 \"lib/read.mll\"\n \n# 979 \"lib/read.mll\"\n ( long_error \"Expected string or identifier but found\" v lexbuf )\n\n# 2970 \"lib/read.ml\"\n\n \n# 2971 \"lib/read.ml\"\n | 3 ->\n\n# 980 \"lib/read.mll\"\n \n# 980 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2975 \"lib/read.ml\"\n\n \n# 2976 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_ident_rec v lexbuf __ocaml_lex_state\n\nand buffer_space v lexbuf =\n __ocaml_lex_buffer_space_rec v lexbuf 471\nand __ocaml_lex_buffer_space_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 983 \"lib/read.mll\"\n \n# 983 \"lib/read.mll\"\n (\n add_lexeme v.buf lexbuf;\n newline v lexbuf;\n buffer_space v lexbuf )\n\n# 2990 \"lib/read.ml\"\n\n \n# 2991 \"lib/read.ml\"\n | 1 ->\n\n# 987 \"lib/read.mll\"\n \n# 987 \"lib/read.mll\"\n (\n Bi_outbuf.add_string v.buf \"/*\";\n finish_buffer_comment v lexbuf;\n buffer_space v lexbuf )\n\n# 2998 \"lib/read.ml\"\n\n \n# 2999 \"lib/read.ml\"\n | 2 ->\n\n# 991 \"lib/read.mll\"\n \n# 991 \"lib/read.mll\"\n (\n Bi_outbuf.add_char v.buf '\\n';\n newline v lexbuf;\n buffer_space v lexbuf )\n\n# 3006 \"lib/read.ml\"\n\n \n# 3007 \"lib/read.ml\"\n | 3 ->\n\n# 995 \"lib/read.mll\"\n \n# 995 \"lib/read.mll\"\n (\n add_lexeme v.buf lexbuf;\n buffer_space v lexbuf )\n\n# 3013 \"lib/read.ml\"\n\n \n# 3014 \"lib/read.ml\"\n | 4 ->\n\n# 998 \"lib/read.mll\"\n \n# 998 \"lib/read.mll\"\n ( () )\n\n# 3018 \"lib/read.ml\"\n\n \n# 3019 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_space_rec v lexbuf __ocaml_lex_state\n\nand buffer_object_end v lexbuf =\n __ocaml_lex_buffer_object_end_rec v lexbuf 478\nand __ocaml_lex_buffer_object_end_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1001 \"lib/read.mll\"\n \n# 1001 \"lib/read.mll\"\n (\n Bi_outbuf.add_char v.buf '}';\n raise End_of_object )\n\n# 3032 \"lib/read.ml\"\n\n \n# 3033 \"lib/read.ml\"\n | 1 ->\n\n# 1004 \"lib/read.mll\"\n \n# 1004 \"lib/read.mll\"\n ( () )\n\n# 3037 \"lib/read.ml\"\n\n \n# 3038 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_object_end_rec v lexbuf __ocaml_lex_state\n\nand buffer_object_sep v lexbuf =\n __ocaml_lex_buffer_object_sep_rec v lexbuf 480\nand __ocaml_lex_buffer_object_sep_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1007 \"lib/read.mll\"\n \n# 1007 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf ',' )\n\n# 3049 \"lib/read.ml\"\n\n \n# 3050 \"lib/read.ml\"\n | 1 ->\n\n# 1008 \"lib/read.mll\"\n \n# 1008 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '}'; raise End_of_object )\n\n# 3054 \"lib/read.ml\"\n\n \n# 3055 \"lib/read.ml\"\n | 2 ->\n\n# 1009 \"lib/read.mll\"\n \n# 1009 \"lib/read.mll\"\n ( long_error \"Expected ',' or '}' but found\" v lexbuf )\n\n# 3059 \"lib/read.ml\"\n\n \n# 3060 \"lib/read.ml\"\n | 3 ->\n\n# 1010 \"lib/read.mll\"\n \n# 1010 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 3064 \"lib/read.ml\"\n\n \n# 3065 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_object_sep_rec v lexbuf __ocaml_lex_state\n\nand buffer_array_end v lexbuf =\n __ocaml_lex_buffer_array_end_rec v lexbuf 485\nand __ocaml_lex_buffer_array_end_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1013 \"lib/read.mll\"\n \n# 1013 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf ']'; raise End_of_array )\n\n# 3076 \"lib/read.ml\"\n\n \n# 3077 \"lib/read.ml\"\n | 1 ->\n\n# 1014 \"lib/read.mll\"\n \n# 1014 \"lib/read.mll\"\n ( () )\n\n# 3081 \"lib/read.ml\"\n\n \n# 3082 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_array_end_rec v lexbuf __ocaml_lex_state\n\nand buffer_array_sep v lexbuf =\n __ocaml_lex_buffer_array_sep_rec v lexbuf 487\nand __ocaml_lex_buffer_array_sep_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1017 \"lib/read.mll\"\n \n# 1017 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf ',' )\n\n# 3093 \"lib/read.ml\"\n\n \n# 3094 \"lib/read.ml\"\n | 1 ->\n\n# 1018 \"lib/read.mll\"\n \n# 1018 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf ']'; raise End_of_array )\n\n# 3098 \"lib/read.ml\"\n\n \n# 3099 \"lib/read.ml\"\n | 2 ->\n\n# 1019 \"lib/read.mll\"\n \n# 1019 \"lib/read.mll\"\n ( long_error \"Expected ',' or ']' but found\" v lexbuf )\n\n# 3103 \"lib/read.ml\"\n\n \n# 3104 \"lib/read.ml\"\n | 3 ->\n\n# 1020 \"lib/read.mll\"\n \n# 1020 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 3108 \"lib/read.ml\"\n\n \n# 3109 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_array_sep_rec v lexbuf __ocaml_lex_state\n\nand buffer_tuple_end v lexbuf =\n __ocaml_lex_buffer_tuple_end_rec v lexbuf 492\nand __ocaml_lex_buffer_tuple_end_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1023 \"lib/read.mll\"\n \n# 1023 \"lib/read.mll\"\n (\n Bi_outbuf.add_char v.buf ')';\n raise End_of_tuple )\n\n# 3122 \"lib/read.ml\"\n\n \n# 3123 \"lib/read.ml\"\n | 1 ->\n\n# 1026 \"lib/read.mll\"\n \n# 1026 \"lib/read.mll\"\n ( () )\n\n# 3127 \"lib/read.ml\"\n\n \n# 3128 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_tuple_end_rec v lexbuf __ocaml_lex_state\n\nand buffer_tuple_sep v lexbuf =\n __ocaml_lex_buffer_tuple_sep_rec v lexbuf 494\nand __ocaml_lex_buffer_tuple_sep_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1029 \"lib/read.mll\"\n \n# 1029 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf ',' )\n\n# 3139 \"lib/read.ml\"\n\n \n# 3140 \"lib/read.ml\"\n | 1 ->\n\n# 1030 \"lib/read.mll\"\n \n# 1030 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf ')'; raise End_of_tuple )\n\n# 3144 \"lib/read.ml\"\n\n \n# 3145 \"lib/read.ml\"\n | 2 ->\n\n# 1031 \"lib/read.mll\"\n \n# 1031 \"lib/read.mll\"\n ( long_error \"Expected ',' or ')' but found\" v lexbuf )\n\n# 3149 \"lib/read.ml\"\n\n \n# 3150 \"lib/read.ml\"\n | 3 ->\n\n# 1032 \"lib/read.mll\"\n \n# 1032 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 3154 \"lib/read.ml\"\n\n \n# 3155 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_tuple_sep_rec v lexbuf __ocaml_lex_state\n\nand buffer_colon v lexbuf =\n __ocaml_lex_buffer_colon_rec v lexbuf 499\nand __ocaml_lex_buffer_colon_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1035 \"lib/read.mll\"\n \n# 1035 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf ':' )\n\n# 3166 \"lib/read.ml\"\n\n \n# 3167 \"lib/read.ml\"\n | 1 ->\n\n# 1036 \"lib/read.mll\"\n \n# 1036 \"lib/read.mll\"\n ( long_error \"Expected ':' but found\" v lexbuf )\n\n# 3171 \"lib/read.ml\"\n\n \n# 3172 \"lib/read.ml\"\n | 2 ->\n\n# 1037 \"lib/read.mll\"\n \n# 1037 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 3176 \"lib/read.ml\"\n\n \n# 3177 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_colon_rec v lexbuf __ocaml_lex_state\n\nand buffer_gt v lexbuf =\n __ocaml_lex_buffer_gt_rec v lexbuf 503\nand __ocaml_lex_buffer_gt_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1040 \"lib/read.mll\"\n \n# 1040 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '>' )\n\n# 3188 \"lib/read.ml\"\n\n \n# 3189 \"lib/read.ml\"\n | 1 ->\n\n# 1041 \"lib/read.mll\"\n \n# 1041 \"lib/read.mll\"\n ( long_error \"Expected '>' but found\" v lexbuf )\n\n# 3193 \"lib/read.ml\"\n\n \n# 3194 \"lib/read.ml\"\n | 2 ->\n\n# 1042 \"lib/read.mll\"\n \n# 1042 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 3198 \"lib/read.ml\"\n\n \n# 3199 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_gt_rec v lexbuf __ocaml_lex_state\n\nand finish_buffer_comment v lexbuf =\n __ocaml_lex_finish_buffer_comment_rec v lexbuf 507\nand __ocaml_lex_finish_buffer_comment_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1045 \"lib/read.mll\"\n \n# 1045 \"lib/read.mll\"\n ( Bi_outbuf.add_string v.buf \"*/\" )\n\n# 3210 \"lib/read.ml\"\n\n \n# 3211 \"lib/read.ml\"\n | 1 ->\n\n# 1046 \"lib/read.mll\"\n \n# 1046 \"lib/read.mll\"\n ( long_error \"Unterminated comment\" v lexbuf )\n\n# 3215 \"lib/read.ml\"\n\n \n# 3216 \"lib/read.ml\"\n | 2 ->\n\n# 1047 \"lib/read.mll\"\n \n# 1047 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\\n';\n newline v lexbuf;\n finish_buffer_comment v lexbuf )\n\n# 3222 \"lib/read.ml\"\n\n \n# 3223 \"lib/read.ml\"\n | 3 ->\n\n# 1050 \"lib/read.mll\"\n \n# 1050 \"lib/read.mll\"\n ( add_lexeme v.buf lexbuf; finish_buffer_comment v lexbuf )\n\n# 3227 \"lib/read.ml\"\n\n \n# 3228 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_buffer_comment_rec v lexbuf __ocaml_lex_state\n\nand junk lexbuf =\n __ocaml_lex_junk_rec lexbuf 513\nand __ocaml_lex_junk_rec lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1053 \"lib/read.mll\"\n \n# 1053 \"lib/read.mll\"\n ( Lexing.lexeme lexbuf )\n\n# 3239 \"lib/read.ml\"\n\n \n# 3240 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_junk_rec lexbuf __ocaml_lex_state\n\n;;\n\n\n# 1055 \"lib/read.mll\"\n \n \n# 1056 \"lib/read.mll\"\n let _ = (read_json : lexer_state -> Lexing.lexbuf -> t)\n\n let read_t = read_json\n\n let () =\n read_junk := junk\n\n let read_int8 v lexbuf =\n let n = read_int v lexbuf in\n if n < 0 || n > 255 then\n lexer_error \"Int8 overflow\" v lexbuf\n else\n char_of_int n\n\n let read_list read_cell v lexbuf =\n List.rev (read_list_rev read_cell v lexbuf)\n\n let array_of_rev_list l =\n match l with\n [] -> [| |]\n | x :: tl ->\n let len = List.length l in\n let a = Array.make len x in\n let r = ref tl in\n for i = len - 2 downto 0 do\n a.(i) <- List.hd !r;\n r := List.tl !r\n done;\n a\n\n let read_array read_cell v lexbuf =\n let l = read_list_rev read_cell v lexbuf in\n array_of_rev_list l\n\n (* Read a JSON object, reading the keys into OCaml strings\n (provided for backward compatibility) *)\n let read_fields read_field init_acc v =\n read_abstract_fields read_ident read_field init_acc v\n\n let finish v lexbuf =\n read_space v lexbuf;\n if not (read_eof lexbuf) then\n long_error \"Junk after end of JSON value:\" v lexbuf\n\n let init_lexer = init_lexer\n\n let from_lexbuf v ?(stream = false) lexbuf =\n read_space v lexbuf;\n\n let x =\n if read_eof lexbuf then\n raise End_of_input\n else\n read_json v lexbuf\n in\n\n if not stream then\n finish v lexbuf;\n\n x\n\n\n let from_string ?buf ?fname ?lnum s =\n try\n let lexbuf = Lexing.from_string s in\n let v = init_lexer ?buf ?fname ?lnum () in\n from_lexbuf v lexbuf\n with End_of_input ->\n json_error \"Blank input data\"\n\n let from_channel ?buf ?fname ?lnum ic =\n try\n let lexbuf = Lexing.from_channel ic in\n let v = init_lexer ?buf ?fname ?lnum () in\n from_lexbuf v lexbuf\n with End_of_input ->\n json_error \"Blank input data\"\n\n let from_file ?buf ?fname ?lnum file =\n let ic = open_in file in\n try\n let x = from_channel ?buf ?fname ?lnum ic in\n close_in ic;\n x\n with e ->\n close_in_noerr ic;\n raise e\n\n exception Finally of exn * exn\n\n let stream_from_lexbuf v ?(fin = fun () -> ()) lexbuf =\n let stream = Some true in\n let f i =\n try Some (from_lexbuf v ?stream lexbuf)\n with\n End_of_input ->\n fin ();\n None\n | e ->\n (try fin () with fin_e -> raise (Finally (e, fin_e)));\n raise e\n in\n Stream.from f\n\n let stream_from_string ?buf ?fname ?lnum s =\n let v = init_lexer ?buf ?fname ?lnum () in\n stream_from_lexbuf v (Lexing.from_string s)\n\n let stream_from_channel ?buf ?fin ?fname ?lnum ic =\n let lexbuf = Lexing.from_channel ic in\n let v = init_lexer ?buf ?fname ?lnum () in\n stream_from_lexbuf v ?fin lexbuf\n\n let stream_from_file ?buf ?fname ?lnum file =\n let ic = open_in file in\n let fin () = close_in ic in\n let fname =\n match fname with\n None -> Some file\n | x -> x\n in\n let lexbuf = Lexing.from_channel ic in\n let v = init_lexer ?buf ?fname ?lnum () in\n stream_from_lexbuf v ~fin lexbuf\n\n type json_line = [ `Json of t | `Exn of exn ]\n\n let linestream_from_channel\n ?buf ?(fin = fun () -> ()) ?fname ?lnum:(lnum0 = 1) ic =\n let buf =\n match buf with\n None -> Some (Bi_outbuf.create 256)\n | Some _ -> buf\n in\n let f i =\n try\n let line = input_line ic in\n let lnum = lnum0 + i in\n Some (`Json (from_string ?buf ?fname ~lnum line))\n with\n End_of_file -> fin (); None\n | e -> Some (`Exn e)\n in\n Stream.from f\n\n let linestream_from_file ?buf ?fname ?lnum file =\n let ic = open_in file in\n let fin () = close_in ic in\n let fname =\n match fname with\n None -> Some file\n | x -> x\n in\n linestream_from_channel ?buf ~fin ?fname ?lnum ic\n\n let prettify ?std s =\n pretty_to_string ?std (from_string s)\n\n let compact ?std s =\n to_string (from_string s)\n\n let validate_json _path _value = None\n\n\n# 3411 \"lib/read.ml\"\n# 39 \"yojson.cppo.ml\"\nmodule Util =\nstruct\n# 1 \"util.ml\"\nexception Type_error of string * t\n\nlet typeof = function\n | `Assoc _ -> \"object\"\n | `Bool _ -> \"bool\"\n | `Float _ -> \"float\"\n | `Int _ -> \"int\"\n | `List _ -> \"array\"\n | `Null -> \"null\"\n | `String _ -> \"string\"\n | `Intlit _ -> \"intlit\"\n | `Tuple _ -> \"tuple\"\n | `Variant _ -> \"variant\"\n\nlet typerr msg js = raise (Type_error (msg ^ typeof js, js))\n\nexception Undefined of string * t\n\nlet ( |> ) = ( |> )\n\nlet assoc name obj =\n try List.assoc name obj\n with Not_found -> `Null\n\nlet member name = function\n | `Assoc obj -> assoc name obj\n | js -> typerr (\"Can't get member '\" ^ name ^ \"' of non-object type \") js\n\nlet index i = function\n | `List l as js ->\n let len = List.length l in\n let wrapped_index = if i < 0 then len + i else i in\n if wrapped_index < 0 || wrapped_index >= len then\n raise (Undefined (\"Index \" ^ string_of_int i ^ \" out of bounds\", js))\n else List.nth l wrapped_index\n | js -> typerr (\"Can't get index \" ^ string_of_int i\n ^ \" of non-array type \") js\n\nlet map f = function\n | `List l -> `List (List.map f l)\n | js -> typerr \"Can't map function over non-array type \" js\n\nlet to_assoc = function\n | `Assoc obj -> obj\n | js -> typerr \"Expected object, got \" js\n\nlet to_option f = function\n | `Null -> None\n | x -> Some (f x)\n\nlet to_bool = function\n | `Bool b -> b\n | js -> typerr \"Expected bool, got \" js\n\nlet to_bool_option = function\n | `Bool b -> Some b\n | `Null -> None\n | js -> typerr \"Expected bool or null, got \" js\n\nlet to_number = function\n | `Int i -> float i\n | `Float f -> f\n | js -> typerr \"Expected number, got \" js\n\nlet to_number_option = function\n | `Int i -> Some (float i)\n | `Float f -> Some f\n | `Null -> None\n | js -> typerr \"Expected number or null, got \" js\n\nlet to_float = function\n | `Float f -> f\n | js -> typerr \"Expected float, got \" js\n\nlet to_float_option = function\n | `Float f -> Some f\n | `Null -> None\n | js -> typerr \"Expected float or null, got \" js\n\nlet to_int = function\n | `Int i -> i\n | js -> typerr \"Expected int, got \" js\n\nlet to_int_option = function\n | `Int i -> Some i\n | `Null -> None\n | js -> typerr \"Expected int or null, got \" js\n\nlet to_list = function\n | `List l -> l\n | js -> typerr \"Expected array, got \" js\n\nlet to_string = function\n | `String s -> s\n | js -> typerr \"Expected string, got \" js\n\nlet to_string_option = function\n | `String s -> Some s\n | `Null -> None\n | js -> typerr \"Expected string or null, got \" js\n\nlet convert_each f = function\n | `List l -> List.map f l\n | js -> typerr \"Can't convert each element of non-array type \" js\n\n\nlet rec rev_filter_map f acc l =\n match l with\n [] -> acc\n | x :: tl ->\n match f x with\n None -> rev_filter_map f acc tl\n | Some y -> rev_filter_map f (y :: acc) tl\n\nlet filter_map f l =\n List.rev (rev_filter_map f [] l)\n\nlet rec rev_flatten acc l =\n match l with\n [] -> acc\n | x :: tl ->\n match x with\n `List l2 -> rev_flatten (List.rev_append l2 acc) tl\n | _ -> rev_flatten acc tl\n\nlet flatten l =\n List.rev (rev_flatten [] l)\n\nlet filter_index i l =\n filter_map (\n function\n `List l ->\n (try Some (List.nth l i)\n with _ -> None)\n | _ -> None\n ) l\n\nlet filter_list l =\n filter_map (\n function\n `List l -> Some l\n | _ -> None\n ) l\n\nlet filter_member k l =\n filter_map (\n function\n `Assoc l ->\n (try Some (List.assoc k l)\n with _ -> None)\n | _ -> None\n ) l\n\nlet filter_assoc l =\n filter_map (\n function\n `Assoc l -> Some l\n | _ -> None\n ) l\n\nlet filter_bool l =\n filter_map (\n function\n `Bool x -> Some x\n | _ -> None\n ) l\n\nlet filter_int l =\n filter_map (\n function\n `Int x -> Some x\n | _ -> None\n ) l\n\nlet filter_float l =\n filter_map (\n function\n `Float x -> Some x\n | _ -> None\n ) l\n\nlet filter_number l =\n filter_map (\n function\n `Int x -> Some (float x)\n | `Float x -> Some x\n | _ -> None\n ) l\n\nlet filter_string l =\n filter_map (\n function\n `String x -> Some x\n | _ -> None\n ) l\n\nlet keys o =\n to_assoc o |> List.map (fun (key, _) -> key)\n\nlet values o =\n to_assoc o |> List.map (fun (_, value) -> value)\n\nlet combine (first : t) (second : t) =\n match (first, second) with\n | (`Assoc a, `Assoc b) -> (`Assoc (a @ b) : t)\n | (a, b) -> raise (Invalid_argument \"Expected two objects, check inputs\")\n# 42 \"yojson.cppo.ml\"\nend\n# 46 \"yojson.cppo.ml\"\nend\n\nmodule Safe =\nstruct\n# 1 \"type.ml\"\n(** {3 Type of the JSON tree} *)\n\ntype t =\n [\n | `Null\n | `Bool of bool\n \n# 8 \"type.ml\"\n | `Int of int\n \n# 11 \"type.ml\"\n | `Intlit of string\n \n# 14 \"type.ml\"\n | `Float of float\n \n# 20 \"type.ml\"\n | `String of string\n \n# 25 \"type.ml\"\n | `Assoc of (string * t) list\n | `List of t list\n \n# 28 \"type.ml\"\n | `Tuple of t list\n \n# 31 \"type.ml\"\n | `Variant of (string * t option)\n \n# 33 \"type.ml\"\n ]\n(**\nAll possible cases defined in Yojson:\n- `Null: JSON null\n- `Bool of bool: JSON boolean\n- `Int of int: JSON number without decimal point or exponent.\n- `Intlit of string: JSON number without decimal point or exponent,\n\t preserved as a string.\n- `Float of float: JSON number, Infinity, -Infinity or NaN.\n- `Floatlit of string: JSON number, Infinity, -Infinity or NaN,\n\t preserved as a string.\n- `String of string: JSON string. Bytes in the range 128-255 are preserved\n\t as-is without encoding validation for both reading\n\t and writing.\n- `Stringlit of string: JSON string literal including the double quotes.\n- `Assoc of (string * json) list: JSON object.\n- `List of json list: JSON array.\n- `Tuple of json list: Tuple (non-standard extension of JSON).\n\t Syntax: [(\"abc\", 123)].\n- `Variant of (string * json option): Variant (non-standard extension of JSON).\n\t Syntax: [<\"Foo\">] or [<\"Bar\":123>].\n*)\n\ntype json = t [@@deprecated \"json types are being renamed and will be removed in the next Yojson major version. Use type t instead\"]\n(**\n * Compatibility type alias for type `t`\n *)\n\n(*\n Note to adventurers: ocamldoc does not support inline comments\n on each polymorphic variant, and cppo doesn't allow to concatenate\n comments, so it would be complicated to document only the\n cases that are preserved by cppo in the type definition.\n*)\n# 1 \"safe.ml\"\nlet rec to_basic : t -> Basic.t = function\n `Null\n | `Bool _\n | `Int _\n | `Float _\n | `String _ as x -> x\n | `Intlit s -> `String s\n | `List l\n | `Tuple l ->\n `List (List.rev (List.rev_map to_basic l))\n | `Assoc l ->\n `Assoc (List.rev (List.rev_map (fun (k, v) -> (k, to_basic v)) l))\n | `Variant (k, None) -> `String k\n | `Variant (k, Some v) -> `List [ `String k; to_basic v ]\n# 1 \"write.ml\"\n(* included: type.ml *)\n\nlet hex n =\n Char.chr (\n if n < 10 then n + 48\n else n + 87\n )\n\nlet write_special src start stop ob str =\n Bi_outbuf.add_substring ob src !start (stop - !start);\n Bi_outbuf.add_string ob str;\n start := stop + 1\n\nlet write_control_char src start stop ob c =\n Bi_outbuf.add_substring ob src !start (stop - !start);\n let i = Bi_outbuf.alloc ob 6 in\n let dst = ob.o_s in\n Bytes.blit_string \"\\\\u00\" 0 dst i 4;\n Bytes.set dst (i+4) (hex (Char.code c lsr 4));\n Bytes.set dst (i+5) (hex (Char.code c land 0xf));\n start := stop + 1\n\nlet finish_string src start ob =\n try\n Bi_outbuf.add_substring ob src !start (String.length src - !start)\n with exc ->\n Printf.eprintf \"src=%S start=%i len=%i\\n%!\"\n src !start (String.length src - !start);\n raise exc\n\nlet write_string_body ob s =\n let start = ref 0 in\n for i = 0 to String.length s - 1 do\n match s.[i] with\n '\"' -> write_special s start i ob \"\\\\\\\"\"\n | '\\\\' -> write_special s start i ob \"\\\\\\\\\"\n | '\\b' -> write_special s start i ob \"\\\\b\"\n | '\\012' -> write_special s start i ob \"\\\\f\"\n | '\\n' -> write_special s start i ob \"\\\\n\"\n | '\\r' -> write_special s start i ob \"\\\\r\"\n | '\\t' -> write_special s start i ob \"\\\\t\"\n | '\\x00'..'\\x1F'\n | '\\x7F' as c -> write_control_char s start i ob c\n | _ -> ()\n done;\n finish_string s start ob\n\nlet write_string ob s =\n Bi_outbuf.add_char ob '\"';\n write_string_body ob s;\n Bi_outbuf.add_char ob '\"'\n\nlet json_string_of_string s =\n let ob = Bi_outbuf.create 10 in\n write_string ob s;\n Bi_outbuf.contents ob\n\nlet test_string () =\n let s = Bytes.create 256 in\n for i = 0 to 255 do\n Bytes.set s i (Char.chr i)\n done;\n json_string_of_string (Bytes.to_string s)\n\n\nlet write_null ob () =\n Bi_outbuf.add_string ob \"null\"\n\nlet write_bool ob x =\n Bi_outbuf.add_string ob (if x then \"true\" else \"false\")\n\n\nlet max_digits =\n max\n (String.length (string_of_int max_int))\n (String.length (string_of_int min_int))\n\nlet dec n =\n Char.chr (n + 48)\n\nlet rec write_digits s pos x =\n if x = 0 then pos\n else\n let d = x mod 10 in\n let pos = write_digits s pos (x / 10) in\n Bytes.set s pos (dec (abs d));\n pos + 1\n\nlet write_int ob x =\n Bi_outbuf.extend ob max_digits;\n if x > 0 then\n ob.o_len <- write_digits ob.o_s ob.o_len x\n else if x < 0 then (\n let s = ob.o_s in\n let pos = ob.o_len in\n Bytes.set s pos '-';\n ob.o_len <- write_digits s (pos + 1) x\n )\n else\n Bi_outbuf.add_char ob '0'\n\n\nlet json_string_of_int i =\n string_of_int i\n\n\n(*\n Ensure that the float is not printed as an int.\n This is not required by JSON, but useful in order to guarantee\n reversibility.\n*)\nlet float_needs_period s =\n try\n for i = 0 to String.length s - 1 do\n match s.[i] with\n '0'..'9' | '-' -> ()\n | _ -> raise Exit\n done;\n true\n with Exit ->\n false\n\n(*\n Both write_float_fast and write_float guarantee\n that a sufficient number of digits are printed in order to\n allow reversibility.\n\n The _fast version is faster but often produces unnecessarily long numbers.\n*)\nlet write_float_fast ob x =\n match classify_float x with\n FP_nan ->\n Bi_outbuf.add_string ob \"NaN\"\n | FP_infinite ->\n Bi_outbuf.add_string ob (if x > 0. then \"Infinity\" else \"-Infinity\")\n | _ ->\n let s = Printf.sprintf \"%.17g\" x in\n Bi_outbuf.add_string ob s;\n if float_needs_period s then\n Bi_outbuf.add_string ob \".0\"\n\nlet write_float ob x =\n match classify_float x with\n FP_nan ->\n Bi_outbuf.add_string ob \"NaN\"\n | FP_infinite ->\n Bi_outbuf.add_string ob (if x > 0. then \"Infinity\" else \"-Infinity\")\n | _ ->\n let s1 = Printf.sprintf \"%.16g\" x in\n let s =\n if float_of_string s1 = x then s1\n else Printf.sprintf \"%.17g\" x\n in\n Bi_outbuf.add_string ob s;\n if float_needs_period s then\n Bi_outbuf.add_string ob \".0\"\n\nlet write_normal_float_prec significant_figures ob x =\n let open Printf in\n let s =\n match significant_figures with\n 1 -> sprintf \"%.1g\" x\n | 2 -> sprintf \"%.2g\" x\n | 3 -> sprintf \"%.3g\" x\n | 4 -> sprintf \"%.4g\" x\n | 5 -> sprintf \"%.5g\" x\n | 6 -> sprintf \"%.6g\" x\n | 7 -> sprintf \"%.7g\" x\n | 8 -> sprintf \"%.8g\" x\n | 9 -> sprintf \"%.9g\" x\n | 10 -> sprintf \"%.10g\" x\n | 11 -> sprintf \"%.11g\" x\n | 12 -> sprintf \"%.12g\" x\n | 13 -> sprintf \"%.13g\" x\n | 14 -> sprintf \"%.14g\" x\n | 15 -> sprintf \"%.15g\" x\n | 16 -> sprintf \"%.16g\" x\n | _ -> sprintf \"%.17g\" x\n in\n Bi_outbuf.add_string ob s;\n if float_needs_period s then\n Bi_outbuf.add_string ob \".0\"\n\nlet write_float_prec significant_figures ob x =\n match classify_float x with\n FP_nan ->\n Bi_outbuf.add_string ob \"NaN\"\n | FP_infinite ->\n Bi_outbuf.add_string ob (if x > 0. then \"Infinity\" else \"-Infinity\")\n | _ ->\n write_normal_float_prec significant_figures ob x\n\nlet json_string_of_float x =\n let ob = Bi_outbuf.create 20 in\n write_float ob x;\n Bi_outbuf.contents ob\n\n\nlet write_std_float_fast ob x =\n match classify_float x with\n FP_nan ->\n json_error \"NaN value not allowed in standard JSON\"\n | FP_infinite ->\n json_error\n (if x > 0. then\n \"Infinity value not allowed in standard JSON\"\n else\n \"-Infinity value not allowed in standard JSON\")\n | _ ->\n let s = Printf.sprintf \"%.17g\" x in\n Bi_outbuf.add_string ob s;\n if float_needs_period s then\n Bi_outbuf.add_string ob \".0\"\n\nlet write_std_float ob x =\n match classify_float x with\n FP_nan ->\n json_error \"NaN value not allowed in standard JSON\"\n | FP_infinite ->\n json_error\n (if x > 0. then\n \"Infinity value not allowed in standard JSON\"\n else\n \"-Infinity value not allowed in standard JSON\")\n | _ ->\n let s1 = Printf.sprintf \"%.16g\" x in\n let s =\n if float_of_string s1 = x then s1\n else Printf.sprintf \"%.17g\" x\n in\n Bi_outbuf.add_string ob s;\n if float_needs_period s then\n Bi_outbuf.add_string ob \".0\"\n\nlet write_std_float_prec significant_figures ob x =\n match classify_float x with\n FP_nan ->\n json_error \"NaN value not allowed in standard JSON\"\n | FP_infinite ->\n json_error\n (if x > 0. then\n \"Infinity value not allowed in standard JSON\"\n else\n \"-Infinity value not allowed in standard JSON\")\n | _ ->\n write_normal_float_prec significant_figures ob x\n\nlet std_json_string_of_float x =\n let ob = Bi_outbuf.create 20 in\n write_std_float ob x;\n Bi_outbuf.contents ob\n\n\nlet test_float () =\n let l = [ 0.; 1.; -1. ] in\n let l = l @ List.map (fun x -> 2. *. x +. 1.) l in\n let l = l @ List.map (fun x -> x /. sqrt 2.) l in\n let l = l @ List.map (fun x -> x *. sqrt 3.) l in\n let l = l @ List.map cos l in\n let l = l @ List.map (fun x -> x *. 1.23e50) l in\n let l = l @ [ infinity; neg_infinity ] in\n List.iter (\n fun x ->\n let s = Printf.sprintf \"%.17g\" x in\n let y = float_of_string s in\n Printf.printf \"%g %g %S %B\\n\" x y s (x = y)\n )\n l\n\n(*\nlet () = test_float ()\n*)\n\nlet write_intlit = Bi_outbuf.add_string\nlet write_floatlit = Bi_outbuf.add_string\nlet write_stringlit = Bi_outbuf.add_string\n\nlet rec iter2_aux f_elt f_sep x = function\n [] -> ()\n | y :: l ->\n f_sep x;\n f_elt x y;\n iter2_aux f_elt f_sep x l\n\nlet iter2 f_elt f_sep x = function\n [] -> ()\n | y :: l ->\n f_elt x y;\n iter2_aux f_elt f_sep x l\n\nlet f_sep ob =\n Bi_outbuf.add_char ob ','\n\nlet rec write_json ob (x : t) =\n match x with\n `Null -> write_null ob ()\n | `Bool b -> write_bool ob b\n \n# 299 \"write.ml\"\n | `Int i -> write_int ob i\n \n# 302 \"write.ml\"\n | `Intlit s -> Bi_outbuf.add_string ob s\n \n# 305 \"write.ml\"\n | `Float f -> write_float ob f\n \n# 311 \"write.ml\"\n | `String s -> write_string ob s\n \n# 316 \"write.ml\"\n | `Assoc l -> write_assoc ob l\n | `List l -> write_list ob l\n \n# 319 \"write.ml\"\n | `Tuple l -> write_tuple ob l\n \n# 322 \"write.ml\"\n | `Variant (s, o) -> write_variant ob s o\n\n# 325 \"write.ml\"\nand write_assoc ob l =\n let f_elt ob (s, x) =\n write_string ob s;\n Bi_outbuf.add_char ob ':';\n write_json ob x\n in\n Bi_outbuf.add_char ob '{';\n iter2 f_elt f_sep ob l;\n Bi_outbuf.add_char ob '}';\n\nand write_list ob l =\n Bi_outbuf.add_char ob '[';\n iter2 write_json f_sep ob l;\n Bi_outbuf.add_char ob ']'\n\n# 341 \"write.ml\"\nand write_tuple ob l =\n Bi_outbuf.add_char ob '(';\n iter2 write_json f_sep ob l;\n Bi_outbuf.add_char ob ')'\n\n# 348 \"write.ml\"\nand write_variant ob s o =\n Bi_outbuf.add_char ob '<';\n write_string ob s;\n (match o with\n None -> ()\n | Some x ->\n Bi_outbuf.add_char ob ':';\n write_json ob x\n );\n Bi_outbuf.add_char ob '>'\n\n# 360 \"write.ml\"\nlet write_t = write_json\n\nlet rec write_std_json ob (x : t) =\n match x with\n `Null -> write_null ob ()\n | `Bool b -> write_bool ob b\n \n# 367 \"write.ml\"\n | `Int i -> write_int ob i\n \n# 370 \"write.ml\"\n | `Intlit s -> Bi_outbuf.add_string ob s\n \n# 373 \"write.ml\"\n | `Float f -> write_std_float ob f\n \n# 379 \"write.ml\"\n | `String s -> write_string ob s\n \n# 384 \"write.ml\"\n | `Assoc l -> write_std_assoc ob l\n | `List l -> write_std_list ob l\n \n# 387 \"write.ml\"\n | `Tuple l -> write_std_tuple ob l\n \n# 390 \"write.ml\"\n | `Variant (s, o) -> write_std_variant ob s o\n\n# 393 \"write.ml\"\nand write_std_assoc ob l =\n let f_elt ob (s, x) =\n write_string ob s;\n Bi_outbuf.add_char ob ':';\n write_std_json ob x\n in\n Bi_outbuf.add_char ob '{';\n iter2 f_elt f_sep ob l;\n Bi_outbuf.add_char ob '}';\n\nand write_std_list ob l =\n Bi_outbuf.add_char ob '[';\n iter2 write_std_json f_sep ob l;\n Bi_outbuf.add_char ob ']'\n\nand write_std_tuple ob l =\n Bi_outbuf.add_char ob '[';\n iter2 write_std_json f_sep ob l;\n Bi_outbuf.add_char ob ']'\n\n# 414 \"write.ml\"\nand write_std_variant ob s o =\n match o with\n None -> write_string ob s\n | Some x ->\n Bi_outbuf.add_char ob '[';\n write_string ob s;\n Bi_outbuf.add_char ob ',';\n write_std_json ob x;\n Bi_outbuf.add_char ob ']'\n\n\n# 426 \"write.ml\"\nlet to_outbuf ?(std = false) ob x =\n if std then (\n if not (is_object_or_array x) then\n json_error \"Root is not an object or array\"\n else\n write_std_json ob x\n )\n else\n write_json ob x\n\n\nlet to_string ?buf ?(len = 256) ?std x =\n let ob =\n match buf with\n None -> Bi_outbuf.create len\n | Some ob ->\n Bi_outbuf.clear ob;\n ob\n in\n to_outbuf ?std ob x;\n let s = Bi_outbuf.contents ob in\n Bi_outbuf.clear ob;\n s\n\nlet to_channel ?buf ?len ?std oc x =\n let ob =\n match buf with\n None -> Bi_outbuf.create_channel_writer ?len oc\n | Some ob -> ob\n in\n to_outbuf ?std ob x;\n Bi_outbuf.flush_channel_writer ob\n\nlet to_output ?buf ?len ?std out x =\n let ob =\n match buf with\n None -> Bi_outbuf.create_output_writer ?len out\n | Some ob -> ob\n in\n to_outbuf ?std ob x;\n Bi_outbuf.flush_output_writer ob\n\nlet to_file ?len ?std file x =\n let oc = open_out file in\n try\n to_channel ?len ?std oc x;\n close_out oc\n with e ->\n close_out_noerr oc;\n raise e\n\nlet stream_to_outbuf ?std ob st =\n Stream.iter (to_outbuf ?std ob) st\n\nlet stream_to_string ?buf ?(len = 256) ?std st =\n let ob =\n match buf with\n None -> Bi_outbuf.create len\n | Some ob ->\n Bi_outbuf.clear ob;\n ob\n in\n stream_to_outbuf ?std ob st;\n let s = Bi_outbuf.contents ob in\n Bi_outbuf.clear ob;\n s\n\nlet stream_to_channel ?buf ?len ?std oc st =\n let ob =\n match buf with\n None -> Bi_outbuf.create_channel_writer ?len oc\n | Some ob -> ob\n in\n stream_to_outbuf ?std ob st;\n Bi_outbuf.flush_channel_writer ob\n\nlet stream_to_file ?len ?std file st =\n let oc = open_out file in\n try\n stream_to_channel ?len ?std oc st;\n close_out oc\n with e ->\n close_out_noerr oc;\n raise e\n\n\nlet rec sort = function\n | `Assoc l ->\n let l = List.rev (List.rev_map (fun (k, v) -> (k, sort v)) l) in\n `Assoc (List.stable_sort (fun (a, _) (b, _) -> String.compare a b) l)\n | `List l ->\n `List (List.rev (List.rev_map sort l))\n \n# 519 \"write.ml\"\n | `Tuple l ->\n `Tuple (List.rev (List.rev_map sort l))\n \n# 523 \"write.ml\"\n | `Variant (k, Some v) as x ->\n let v' = sort v in\n if v == v' then x\n else\n `Variant (k, Some v')\n \n# 529 \"write.ml\"\n | x -> x\n# 1 \"monomorphic.ml\"\nlet rec pp fmt =\n function\n | `Null -> Format.pp_print_string fmt \"`Null\"\n | `Bool x ->\n Format.fprintf fmt \"`Bool (@[\";\n Format.fprintf fmt \"%B\" x;\n Format.fprintf fmt \"@])\"\n \n# 9 \"monomorphic.ml\"\n | `Int x ->\n Format.fprintf fmt \"`Int (@[\";\n Format.fprintf fmt \"%d\" x;\n Format.fprintf fmt \"@])\"\n \n# 15 \"monomorphic.ml\"\n | `Intlit x ->\n Format.fprintf fmt \"`Intlit (@[\";\n Format.fprintf fmt \"%S\" x;\n Format.fprintf fmt \"@])\"\n \n# 21 \"monomorphic.ml\"\n | `Float x ->\n Format.fprintf fmt \"`Float (@[\";\n Format.fprintf fmt \"%F\" x;\n Format.fprintf fmt \"@])\"\n \n# 33 \"monomorphic.ml\"\n | `String x ->\n Format.fprintf fmt \"`String (@[\";\n Format.fprintf fmt \"%S\" x;\n Format.fprintf fmt \"@])\"\n \n# 44 \"monomorphic.ml\"\n | `Assoc xs ->\n Format.fprintf fmt \"`Assoc (@[\";\n Format.fprintf fmt \"@[<2>[\";\n ignore (List.fold_left\n (fun sep (key, value) ->\n if sep then\n Format.fprintf fmt \";@ \";\n Format.fprintf fmt \"(@[\";\n Format.fprintf fmt \"%S\" key;\n Format.fprintf fmt \",@ \";\n pp fmt value;\n Format.fprintf fmt \"@])\";\n true) false xs);\n Format.fprintf fmt \"@,]@]\";\n Format.fprintf fmt \"@])\"\n | `List xs ->\n Format.fprintf fmt \"`List (@[\";\n Format.fprintf fmt \"@[<2>[\";\n ignore (List.fold_left\n (fun sep x ->\n if sep then\n Format.fprintf fmt \";@ \";\n pp fmt x;\n true) false xs);\n Format.fprintf fmt \"@,]@]\";\n Format.fprintf fmt \"@])\"\n \n# 71 \"monomorphic.ml\"\n | `Tuple tup ->\n Format.fprintf fmt \"`Tuple (@[\";\n Format.fprintf fmt \"@[<2>[\";\n ignore (List.fold_left\n (fun sep e ->\n if sep then\n Format.fprintf fmt \";@ \";\n pp fmt e;\n true) false tup);\n Format.fprintf fmt \"@,]@]\";\n Format.fprintf fmt \"@])\"\n \n# 84 \"monomorphic.ml\"\n | `Variant (name, value) ->\n Format.fprintf fmt \"`Variant (@[\";\n Format.fprintf fmt \"(@[\";\n Format.fprintf fmt \"%S\" name;\n Format.fprintf fmt \",@ \";\n (match value with\n | None -> Format.pp_print_string fmt \"None\"\n | Some x ->\n Format.pp_print_string fmt \"(Some \";\n pp fmt x;\n Format.pp_print_string fmt \")\");\n Format.fprintf fmt \"@])\";\n Format.fprintf fmt \"@])\"\n\n# 99 \"monomorphic.ml\"\nlet show x =\n Format.asprintf \"%a\" pp x\n\nlet rec equal a b =\n match a, b with\n | `Null, `Null -> true\n | `Bool a, `Bool b -> a = b\n \n# 107 \"monomorphic.ml\"\n | `Int a, `Int b -> a = b\n \n# 110 \"monomorphic.ml\"\n | `Intlit a, `Intlit b -> a = b\n \n# 113 \"monomorphic.ml\"\n | `Float a, `Float b -> a = b\n \n# 119 \"monomorphic.ml\"\n | `String a, `String b -> a = b\n \n# 124 \"monomorphic.ml\"\n | `Assoc xs, `Assoc ys ->\n let compare_keys = fun (key, _) (key', _) -> String.compare key key' in\n let xs = List.stable_sort compare_keys xs in\n let ys = List.stable_sort compare_keys ys in\n (match List.for_all2 (fun (key, value) (key', value') ->\n match key = key' with\n | false -> false\n | true -> equal value value') xs ys with\n | result -> result\n | exception Invalid_argument _ ->\n (* the lists were of different lengths, thus unequal *)\n false)\n \n# 137 \"monomorphic.ml\"\n | `Tuple xs, `Tuple ys\n \n# 139 \"monomorphic.ml\"\n | `List xs, `List ys ->\n (match List.for_all2 equal xs ys with\n | result -> result\n | exception Invalid_argument _ ->\n (* the lists were of different lengths, thus unequal *)\n false)\n \n# 146 \"monomorphic.ml\"\n | `Variant (name, value), `Variant (name', value') ->\n (match name = name' with\n | false -> false\n | true ->\n match value, value' with\n | None, None -> true\n | Some x, Some y -> equal x y\n | _ -> false)\n \n# 155 \"monomorphic.ml\"\n | _ -> false\n# 1 \"write2.ml\"\nlet pretty_format ?std (x : t) =\n Pretty.format ?std (x :> json_max)\n\nlet pretty_print ?std out (x : t) =\n Easy_format.Pretty.to_formatter out (pretty_format ?std x)\n\nlet pretty_to_string ?std (x : t) =\n Pretty.to_string ?std (x :> json_max)\n\nlet pretty_to_channel ?std oc (x : t) =\n Pretty.to_channel ?std oc (x :> json_max)\n\n# 1 \"lib/read.mll\"\n \n \n# 2 \"lib/read.mll\"\n module Lexing =\n (*\n We override Lexing.engine in order to avoid creating a new position\n record each time a rule is matched.\n This reduces total parsing time by about 31%.\n *)\n struct\n include Lexing\n\n external c_engine : lex_tables -> int -> lexbuf -> int = \"caml_lex_engine\"\n\n let engine tbl state buf =\n let result = c_engine tbl state buf in\n (*\n if result >= 0 then begin\n buf.lex_start_p <- buf.lex_curr_p;\n buf.lex_curr_p <- {buf.lex_curr_p\n with pos_cnum = buf.lex_abs_pos + buf.lex_curr_pos};\n end;\n *)\n result\n end\n\n open Printf\n open Lexing\n\n (* see description in common.mli *)\n type lexer_state = Lexer_state.t = {\n buf : Bi_outbuf.t;\n mutable lnum : int;\n mutable bol : int;\n mutable fname : string option;\n }\n\n let dec c =\n Char.code c - 48\n\n let hex c =\n match c with\n '0'..'9' -> int_of_char c - int_of_char '0'\n | 'a'..'f' -> int_of_char c - int_of_char 'a' + 10\n | 'A'..'F' -> int_of_char c - int_of_char 'A' + 10\n | _ -> assert false\n\n let custom_error descr v lexbuf =\n let offs = lexbuf.lex_abs_pos - 1 in\n let bol = v.bol in\n let pos1 = offs + lexbuf.lex_start_pos - bol - 1 in\n let pos2 = max pos1 (offs + lexbuf.lex_curr_pos - bol) in\n let file_line =\n match v.fname with\n None -> \"Line\"\n | Some s ->\n sprintf \"File %s, line\" s\n in\n let bytes =\n if pos1 = pos2 then\n sprintf \"byte %i\" (pos1+1)\n else\n sprintf \"bytes %i-%i\" (pos1+1) (pos2+1)\n in\n let msg = sprintf \"%s %i, %s:\\n%s\" file_line v.lnum bytes descr in\n json_error msg\n\n\n let lexer_error descr v lexbuf =\n custom_error\n (sprintf \"%s '%s'\" descr (Lexing.lexeme lexbuf))\n v lexbuf\n\n let read_junk = ref (fun _ -> assert false)\n\n let long_error descr v lexbuf =\n let junk = Lexing.lexeme lexbuf in\n let extra_junk = !read_junk lexbuf in\n custom_error\n (sprintf \"%s '%s%s'\" descr junk extra_junk)\n v lexbuf\n\n let min10 = min_int / 10 - (if min_int mod 10 = 0 then 0 else 1)\n let max10 = max_int / 10 + (if max_int mod 10 = 0 then 0 else 1)\n\n exception Int_overflow\n\n let extract_positive_int lexbuf =\n let start = lexbuf.lex_start_pos in\n let stop = lexbuf.lex_curr_pos in\n let s = lexbuf.lex_buffer in\n let n = ref 0 in\n for i = start to stop - 1 do\n if !n >= max10 then\n raise Int_overflow\n else\n n := 10 * !n + dec (Bytes.get s i)\n done;\n if !n < 0 then\n raise Int_overflow\n else\n !n\n\n let make_positive_int v lexbuf =\n \n# 104 \"lib/read.mll\"\n try `Int (extract_positive_int lexbuf)\n with Int_overflow ->\n \n# 108 \"lib/read.mll\"\n `Intlit (lexeme lexbuf)\n\n \n# 113 \"lib/read.mll\"\n let extract_negative_int lexbuf =\n let start = lexbuf.lex_start_pos + 1 in\n let stop = lexbuf.lex_curr_pos in\n let s = lexbuf.lex_buffer in\n let n = ref 0 in\n for i = start to stop - 1 do\n if !n <= min10 then\n raise Int_overflow\n else\n n := 10 * !n - dec (Bytes.get s i)\n done;\n if !n > 0 then\n raise Int_overflow\n else\n !n\n\n let make_negative_int v lexbuf =\n \n# 131 \"lib/read.mll\"\n try `Int (extract_negative_int lexbuf)\n with Int_overflow ->\n \n# 135 \"lib/read.mll\"\n `Intlit (lexeme lexbuf)\n\n\n \n# 141 \"lib/read.mll\"\n let set_file_name v fname =\n v.fname <- fname\n\n let newline v lexbuf =\n v.lnum <- v.lnum + 1;\n v.bol <- lexbuf.lex_abs_pos + lexbuf.lex_curr_pos\n\n let add_lexeme buf lexbuf =\n let len = lexbuf.lex_curr_pos - lexbuf.lex_start_pos in\n Bi_outbuf.add_subbytes buf lexbuf.lex_buffer lexbuf.lex_start_pos len\n\n let map_lexeme f lexbuf =\n let len = lexbuf.lex_curr_pos - lexbuf.lex_start_pos in\n f (Bytes.to_string lexbuf.lex_buffer) lexbuf.lex_start_pos len\n\n type variant_kind = [ `Edgy_bracket | `Square_bracket | `Double_quote ]\n type tuple_kind = [ `Parenthesis | `Square_bracket ]\n\n\n# 161 \"lib/read.ml\"\n# 161 \"lib/read.ml\"\nlet __ocaml_lex_tables = {\n Lexing.lex_base =\n \"\\000\\000\\236\\255\\237\\255\\003\\000\\239\\255\\016\\000\\242\\255\\243\\255\\\n \\244\\255\\245\\255\\000\\000\\031\\000\\249\\255\\085\\000\\001\\000\\000\\000\\\n \\000\\000\\001\\000\\000\\000\\001\\000\\002\\000\\255\\255\\000\\000\\000\\000\\\n \\003\\000\\254\\255\\001\\000\\004\\000\\253\\255\\011\\000\\252\\255\\003\\000\\\n \\001\\000\\003\\000\\002\\000\\003\\000\\000\\000\\251\\255\\021\\000\\097\\000\\\n \\010\\000\\022\\000\\020\\000\\016\\000\\022\\000\\012\\000\\008\\000\\250\\255\\\n \\119\\000\\129\\000\\139\\000\\161\\000\\171\\000\\181\\000\\193\\000\\209\\000\\\n \\240\\255\\011\\000\\038\\000\\252\\255\\065\\000\\254\\255\\255\\255\\110\\000\\\n \\252\\255\\163\\000\\254\\255\\255\\255\\234\\000\\247\\255\\248\\255\\048\\001\\\n \\250\\255\\251\\255\\252\\255\\253\\255\\254\\255\\255\\255\\071\\001\\126\\001\\\n \\149\\001\\249\\255\\039\\000\\253\\255\\254\\255\\038\\000\\187\\001\\210\\001\\\n \\248\\001\\015\\002\\255\\255\\220\\000\\253\\255\\255\\255\\245\\000\\039\\002\\\n \\109\\002\\014\\001\\088\\002\\164\\002\\187\\002\\225\\002\\013\\000\\252\\255\\\n \\253\\255\\254\\255\\255\\255\\014\\000\\253\\255\\254\\255\\255\\255\\030\\000\\\n \\253\\255\\254\\255\\255\\255\\015\\000\\253\\255\\254\\255\\255\\255\\017\\001\\\n \\251\\255\\252\\255\\253\\255\\254\\255\\255\\255\\019\\000\\252\\255\\253\\255\\\n \\254\\255\\015\\000\\255\\255\\016\\000\\255\\255\\008\\001\\005\\000\\253\\255\\\n \\023\\000\\254\\255\\020\\000\\255\\255\\046\\000\\253\\255\\254\\255\\042\\000\\\n \\052\\000\\053\\000\\255\\255\\053\\000\\048\\000\\091\\000\\092\\000\\255\\255\\\n \\027\\001\\250\\255\\251\\255\\137\\000\\104\\000\\089\\000\\088\\000\\106\\000\\\n \\255\\255\\143\\000\\137\\000\\177\\000\\254\\255\\183\\000\\168\\000\\166\\000\\\n \\183\\000\\002\\000\\253\\255\\177\\000\\172\\000\\187\\000\\004\\000\\252\\255\\\n \\053\\002\\251\\255\\252\\255\\253\\255\\103\\001\\255\\255\\248\\002\\254\\255\\\n \\006\\003\\030\\003\\252\\255\\253\\255\\254\\255\\255\\255\\040\\003\\050\\003\\\n \\074\\003\\252\\255\\253\\255\\254\\255\\255\\255\\061\\003\\084\\003\\108\\003\\\n \\249\\255\\250\\255\\251\\255\\244\\000\\120\\003\\142\\003\\179\\000\\194\\000\\\n \\015\\000\\255\\255\\190\\000\\188\\000\\187\\000\\193\\000\\183\\000\\179\\000\\\n \\254\\255\\191\\000\\201\\000\\200\\000\\196\\000\\203\\000\\193\\000\\189\\000\\\n \\253\\255\\157\\003\\095\\003\\174\\003\\196\\003\\206\\003\\216\\003\\228\\003\\\n \\239\\003\\060\\000\\253\\255\\254\\255\\255\\255\\012\\004\\252\\255\\253\\255\\\n \\087\\004\\255\\255\\145\\004\\252\\255\\253\\255\\221\\004\\255\\255\\229\\000\\\n \\253\\255\\254\\255\\255\\255\\231\\000\\253\\255\\254\\255\\255\\255\\002\\000\\\n \\255\\255\\018\\001\\252\\255\\253\\255\\254\\255\\255\\255\\034\\001\\253\\255\\\n \\254\\255\\255\\255\\000\\000\\255\\255\\003\\000\\254\\255\\255\\255\\038\\001\\\n \\252\\255\\253\\255\\254\\255\\255\\255\\120\\001\\251\\255\\252\\255\\253\\255\\\n \\254\\255\\255\\255\\208\\000\\253\\255\\254\\255\\255\\255\\211\\000\\253\\255\\\n \\254\\255\\255\\255\\189\\000\\255\\255\\143\\001\\252\\255\\253\\255\\254\\255\\\n \\255\\255\\013\\001\\253\\255\\254\\255\\255\\255\\095\\001\\252\\255\\253\\255\\\n \\254\\255\\255\\255\\050\\001\\253\\255\\254\\255\\255\\255\\026\\001\\253\\255\\\n \\254\\255\\255\\255\\233\\000\\253\\255\\254\\255\\255\\255\\222\\000\\253\\255\\\n \\254\\255\\255\\255\\079\\005\\237\\255\\238\\255\\010\\000\\240\\255\\044\\001\\\n \\243\\255\\244\\255\\245\\255\\246\\255\\061\\001\\002\\004\\249\\255\\045\\005\\\n \\209\\000\\228\\000\\211\\000\\232\\000\\225\\000\\223\\000\\240\\000\\255\\255\\\n \\235\\000\\234\\000\\008\\001\\254\\255\\004\\001\\023\\001\\253\\255\\054\\001\\\n \\252\\255\\031\\001\\029\\001\\032\\001\\039\\001\\049\\001\\045\\001\\251\\255\\\n \\057\\001\\082\\001\\080\\001\\078\\001\\084\\001\\074\\001\\086\\001\\250\\255\\\n \\110\\005\\012\\004\\123\\005\\155\\005\\165\\005\\177\\005\\187\\005\\197\\005\\\n \\241\\255\\199\\001\\077\\002\\253\\255\\255\\255\\154\\002\\222\\005\\209\\005\\\n \\155\\002\\239\\005\\053\\006\\076\\006\\114\\006\\016\\002\\252\\255\\253\\255\\\n \\254\\255\\255\\255\\152\\006\\252\\255\\253\\255\\227\\006\\255\\255\\085\\007\\\n \\244\\255\\245\\255\\011\\000\\247\\255\\076\\002\\250\\255\\251\\255\\252\\255\\\n \\253\\255\\254\\255\\031\\002\\243\\005\\051\\007\\100\\001\\115\\001\\104\\001\\\n \\133\\001\\118\\001\\154\\001\\171\\001\\255\\255\\173\\001\\176\\001\\191\\001\\\n \\185\\001\\187\\001\\253\\001\\230\\001\\230\\001\\234\\001\\247\\001\\237\\001\\\n \\234\\001\\009\\002\\019\\002\\019\\002\\015\\002\\021\\002\\011\\002\\007\\002\\\n \\142\\006\\152\\006\\116\\007\\170\\007\\180\\007\\190\\007\\200\\007\\210\\007\\\n \\248\\255\\120\\002\\167\\002\\253\\255\\255\\255\\216\\002\\082\\007\\220\\007\\\n \\236\\002\\244\\007\\058\\008\\081\\008\\119\\008\\076\\002\\252\\255\\253\\255\\\n \\254\\255\\255\\255\\157\\008\\252\\255\\253\\255\\232\\008\\255\\255\\135\\002\\\n \\120\\002\\253\\255\\100\\002\\254\\255\\182\\002\\255\\255\\011\\002\\255\\255\\\n \\204\\002\\252\\255\\253\\255\\254\\255\\255\\255\\046\\002\\255\\255\\178\\002\\\n \\252\\255\\253\\255\\254\\255\\255\\255\\023\\000\\255\\255\\183\\002\\252\\255\\\n \\253\\255\\254\\255\\255\\255\\187\\002\\253\\255\\254\\255\\255\\255\\121\\002\\\n \\253\\255\\254\\255\\255\\255\\184\\002\\252\\255\\253\\255\\254\\255\\019\\000\\\n \\255\\255\\140\\001\\146\\001\\255\\255\\150\\001\\151\\001\\154\\001\\168\\001\\\n \\170\\001\\171\\001\\172\\001\\173\\001\\181\\001\\184\\001\\185\\001\\187\\001\\\n \\191\\001\\193\\001\\195\\001\\196\\001\\197\\001\\200\\001\\203\\001\\223\\001\\\n \\225\\001\\228\\001\\249\\001\\251\\001\\002\\002\\004\\002\\011\\002\\012\\002\\\n \\013\\002\\000\\000\";\n Lexing.lex_backtrk =\n \"\\255\\255\\255\\255\\255\\255\\017\\000\\255\\255\\019\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\007\\000\\007\\000\\255\\255\\019\\000\\019\\000\\019\\000\\\n \\019\\000\\019\\000\\019\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\008\\000\\008\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\009\\000\\255\\255\\009\\000\\255\\255\\009\\000\\255\\255\\\n \\255\\255\\014\\000\\255\\255\\255\\255\\002\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\002\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\007\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\001\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\003\\000\\255\\255\\001\\000\\255\\255\\004\\000\\003\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\\n \\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\004\\000\\004\\000\\004\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\003\\000\\255\\255\\000\\000\\255\\255\\\n \\001\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\002\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\002\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\003\\000\\003\\000\\005\\000\\005\\000\\005\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\003\\000\\255\\255\\003\\000\\255\\255\\003\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\001\\000\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\001\\000\\255\\255\\002\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\001\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\016\\000\\255\\255\\018\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\007\\000\\007\\000\\255\\255\\018\\000\\\n \\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\008\\000\\255\\255\\008\\000\\255\\255\\008\\000\\255\\255\\\n \\255\\255\\013\\000\\255\\255\\255\\255\\255\\255\\001\\000\\001\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\009\\000\\255\\255\\011\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\000\\000\\000\\000\\011\\000\\011\\000\\011\\000\\011\\000\\\n \\011\\000\\011\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\000\\000\\255\\255\\000\\000\\255\\255\\000\\000\\255\\255\\\n \\255\\255\\006\\000\\255\\255\\255\\255\\255\\255\\001\\000\\001\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\004\\000\\\n \\003\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\003\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\";\n Lexing.lex_default =\n \"\\001\\000\\000\\000\\000\\000\\255\\255\\000\\000\\255\\255\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\\n \\255\\255\\000\\000\\255\\255\\255\\255\\000\\000\\255\\255\\000\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\000\\000\\057\\000\\060\\000\\000\\000\\060\\000\\000\\000\\000\\000\\065\\000\\\n \\000\\000\\065\\000\\000\\000\\000\\000\\070\\000\\000\\000\\000\\000\\255\\255\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\255\\255\\\n \\255\\255\\000\\000\\084\\000\\000\\000\\000\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\000\\000\\094\\000\\000\\000\\000\\000\\097\\000\\255\\255\\\n \\255\\255\\097\\000\\255\\255\\255\\255\\255\\255\\255\\255\\104\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\109\\000\\000\\000\\000\\000\\000\\000\\113\\000\\\n \\000\\000\\000\\000\\000\\000\\117\\000\\000\\000\\000\\000\\000\\000\\121\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\126\\000\\000\\000\\000\\000\\\n \\000\\000\\255\\255\\000\\000\\255\\255\\000\\000\\255\\255\\255\\255\\000\\000\\\n \\255\\255\\000\\000\\138\\000\\000\\000\\142\\000\\000\\000\\000\\000\\255\\255\\\n \\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\\n \\154\\000\\000\\000\\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\000\\000\\255\\255\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\\n \\178\\000\\000\\000\\000\\000\\000\\000\\255\\255\\000\\000\\255\\255\\000\\000\\\n \\255\\255\\187\\000\\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\255\\255\\\n \\194\\000\\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\255\\255\\201\\000\\\n \\000\\000\\000\\000\\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\235\\000\\000\\000\\000\\000\\000\\000\\239\\000\\000\\000\\000\\000\\\n \\255\\255\\000\\000\\244\\000\\000\\000\\000\\000\\255\\255\\000\\000\\249\\000\\\n \\000\\000\\000\\000\\000\\000\\253\\000\\000\\000\\000\\000\\000\\000\\255\\255\\\n \\000\\000\\003\\001\\000\\000\\000\\000\\000\\000\\000\\000\\008\\001\\000\\000\\\n \\000\\000\\000\\000\\255\\255\\000\\000\\255\\255\\000\\000\\000\\000\\017\\001\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\022\\001\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\028\\001\\000\\000\\000\\000\\000\\000\\032\\001\\000\\000\\\n \\000\\000\\000\\000\\255\\255\\000\\000\\038\\001\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\043\\001\\000\\000\\000\\000\\000\\000\\047\\001\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\052\\001\\000\\000\\000\\000\\000\\000\\056\\001\\000\\000\\\n \\000\\000\\000\\000\\060\\001\\000\\000\\000\\000\\000\\000\\064\\001\\000\\000\\\n \\000\\000\\000\\000\\067\\001\\000\\000\\000\\000\\255\\255\\000\\000\\255\\255\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\255\\255\\000\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\\n \\255\\255\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\000\\000\\255\\255\\\n \\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\000\\000\\121\\001\\125\\001\\000\\000\\000\\000\\128\\001\\255\\255\\255\\255\\\n \\128\\001\\255\\255\\255\\255\\255\\255\\255\\255\\135\\001\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\140\\001\\000\\000\\000\\000\\255\\255\\000\\000\\144\\001\\\n \\000\\000\\000\\000\\255\\255\\000\\000\\255\\255\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\000\\000\\193\\001\\197\\001\\000\\000\\000\\000\\200\\001\\255\\255\\255\\255\\\n \\200\\001\\255\\255\\255\\255\\255\\255\\255\\255\\207\\001\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\212\\001\\000\\000\\000\\000\\255\\255\\000\\000\\255\\255\\\n \\255\\255\\000\\000\\255\\255\\000\\000\\220\\001\\000\\000\\255\\255\\000\\000\\\n \\226\\001\\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\000\\000\\233\\001\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\000\\000\\240\\001\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\245\\001\\000\\000\\000\\000\\000\\000\\249\\001\\\n \\000\\000\\000\\000\\000\\000\\252\\001\\000\\000\\000\\000\\000\\000\\255\\255\\\n \\000\\000\\002\\002\\004\\002\\000\\000\\005\\002\\006\\002\\007\\002\\008\\002\\\n \\009\\002\\010\\002\\011\\002\\012\\002\\013\\002\\014\\002\\015\\002\\016\\002\\\n \\017\\002\\018\\002\\019\\002\\020\\002\\021\\002\\022\\002\\023\\002\\024\\002\\\n \\025\\002\\026\\002\\027\\002\\028\\002\\029\\002\\030\\002\\031\\002\\032\\002\\\n \\033\\002\\003\\002\";\n Lexing.lex_trans =\n \"\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\003\\000\\004\\000\\000\\000\\003\\000\\003\\000\\134\\000\\000\\000\\\n \\003\\000\\000\\000\\134\\000\\069\\001\\146\\001\\255\\255\\000\\000\\069\\001\\\n \\146\\001\\000\\000\\000\\000\\000\\000\\000\\000\\127\\000\\139\\000\\000\\000\\\n \\003\\000\\000\\000\\012\\000\\003\\000\\170\\000\\134\\000\\175\\000\\000\\000\\\n \\007\\000\\011\\001\\069\\001\\146\\001\\014\\001\\013\\000\\049\\000\\005\\000\\\n \\010\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\\n \\011\\000\\011\\000\\056\\000\\118\\000\\006\\000\\129\\000\\130\\000\\057\\000\\\n \\237\\001\\137\\000\\000\\002\\049\\000\\000\\000\\048\\000\\138\\000\\106\\000\\\n \\062\\000\\014\\000\\110\\000\\105\\000\\000\\000\\049\\000\\015\\000\\011\\000\\\n \\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\\n \\011\\000\\030\\000\\048\\000\\008\\000\\114\\000\\209\\000\\236\\000\\000\\001\\\n \\013\\001\\029\\000\\022\\000\\255\\255\\048\\000\\048\\000\\017\\000\\021\\000\\\n \\025\\000\\032\\000\\033\\000\\035\\000\\023\\000\\027\\000\\016\\000\\031\\000\\\n \\028\\000\\034\\000\\019\\000\\024\\000\\018\\000\\026\\000\\020\\000\\036\\000\\\n \\041\\000\\037\\000\\048\\000\\009\\000\\042\\000\\043\\000\\044\\000\\045\\000\\\n \\046\\000\\047\\000\\061\\000\\085\\000\\048\\000\\038\\000\\039\\000\\039\\000\\\n \\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\049\\000\\\n \\067\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\\n \\039\\000\\039\\000\\039\\000\\086\\000\\143\\000\\255\\255\\040\\000\\144\\000\\\n \\145\\000\\146\\000\\055\\000\\148\\000\\055\\000\\149\\000\\048\\000\\054\\000\\\n \\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\\n \\054\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\\n \\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\\n \\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\255\\255\\048\\000\\150\\000\\\n \\151\\000\\161\\000\\066\\000\\158\\000\\053\\000\\159\\000\\053\\000\\160\\000\\\n \\051\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\\n \\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\\n \\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\\n \\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\165\\000\\\n \\051\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\\n \\054\\000\\054\\000\\054\\000\\162\\000\\163\\000\\166\\000\\093\\000\\255\\255\\\n \\002\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\\n \\054\\000\\054\\000\\054\\000\\255\\255\\077\\000\\103\\000\\108\\000\\116\\000\\\n \\132\\000\\134\\000\\135\\000\\128\\000\\139\\000\\134\\000\\164\\000\\093\\000\\\n \\171\\000\\077\\000\\167\\000\\168\\000\\169\\000\\172\\000\\112\\000\\173\\000\\\n \\174\\000\\210\\000\\226\\000\\208\\000\\211\\000\\212\\000\\059\\000\\083\\000\\\n \\134\\000\\213\\000\\214\\000\\215\\000\\216\\000\\218\\000\\141\\000\\219\\000\\\n \\093\\000\\220\\000\\221\\000\\123\\000\\222\\000\\223\\000\\224\\000\\136\\000\\\n \\095\\000\\225\\000\\035\\001\\065\\001\\234\\000\\155\\000\\005\\001\\097\\001\\\n \\250\\000\\255\\255\\254\\000\\057\\001\\061\\001\\095\\001\\077\\000\\044\\001\\\n \\092\\001\\088\\001\\009\\001\\029\\001\\076\\000\\124\\000\\033\\001\\018\\001\\\n \\075\\000\\098\\000\\019\\001\\085\\001\\086\\001\\087\\001\\120\\001\\089\\001\\\n \\074\\000\\225\\000\\053\\001\\121\\001\\073\\000\\090\\001\\072\\000\\071\\000\\\n \\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\\n \\078\\000\\078\\000\\098\\000\\113\\001\\122\\000\\091\\001\\064\\000\\004\\001\\\n \\093\\001\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\079\\000\\\n \\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\\n \\079\\000\\156\\000\\112\\001\\094\\001\\096\\001\\098\\001\\099\\001\\049\\001\\\n \\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\100\\001\\157\\000\\\n \\101\\001\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\183\\000\\\n \\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\\n \\184\\000\\024\\001\\112\\001\\255\\255\\025\\001\\102\\001\\103\\001\\105\\001\\\n \\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\080\\000\\080\\000\\\n \\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\\n \\106\\001\\107\\001\\048\\001\\040\\001\\108\\001\\109\\001\\110\\001\\080\\000\\\n \\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\081\\000\\081\\000\\081\\000\\\n \\081\\000\\081\\000\\081\\000\\081\\000\\081\\000\\081\\000\\081\\000\\111\\001\\\n \\027\\001\\255\\255\\171\\001\\031\\001\\170\\001\\023\\001\\081\\000\\081\\000\\\n \\081\\000\\081\\000\\081\\000\\081\\000\\092\\000\\168\\001\\063\\001\\080\\000\\\n \\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\248\\000\\165\\001\\252\\000\\\n \\162\\001\\059\\001\\069\\000\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\\n \\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\255\\255\\081\\000\\081\\000\\\n \\081\\000\\081\\000\\081\\000\\081\\000\\087\\000\\087\\000\\087\\000\\087\\000\\\n \\087\\000\\087\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\\n \\088\\000\\088\\000\\088\\000\\088\\000\\039\\001\\042\\001\\255\\255\\163\\001\\\n \\164\\001\\120\\000\\002\\001\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\\n \\088\\000\\166\\001\\055\\001\\153\\000\\087\\000\\087\\000\\087\\000\\087\\000\\\n \\087\\000\\087\\000\\007\\001\\167\\001\\164\\001\\169\\001\\016\\001\\164\\001\\\n \\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\\n \\089\\000\\089\\000\\051\\001\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\\n \\088\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\090\\000\\\n \\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\\n \\090\\000\\097\\000\\137\\001\\164\\001\\172\\001\\185\\001\\136\\001\\173\\001\\\n \\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\097\\000\\179\\000\\\n \\174\\001\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\046\\001\\\n \\175\\001\\176\\001\\180\\000\\164\\001\\184\\001\\181\\000\\182\\000\\182\\000\\\n \\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\124\\001\\\n \\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\192\\001\\178\\001\\\n \\021\\001\\179\\001\\097\\000\\193\\001\\180\\001\\181\\001\\182\\001\\183\\001\\\n \\164\\001\\216\\001\\255\\255\\097\\000\\184\\001\\216\\001\\209\\001\\097\\000\\\n \\223\\001\\097\\000\\208\\001\\230\\001\\003\\002\\097\\000\\219\\001\\037\\001\\\n \\216\\001\\217\\001\\003\\002\\220\\001\\216\\001\\097\\000\\003\\002\\003\\002\\\n \\216\\001\\097\\000\\003\\002\\097\\000\\096\\000\\099\\000\\099\\000\\099\\000\\\n \\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\216\\001\\\n \\003\\002\\126\\001\\003\\002\\003\\002\\003\\002\\003\\002\\099\\000\\099\\000\\\n \\099\\000\\099\\000\\099\\000\\099\\000\\097\\000\\003\\002\\218\\001\\250\\001\\\n \\003\\002\\003\\002\\097\\000\\003\\002\\124\\001\\124\\001\\097\\000\\003\\002\\\n \\221\\001\\003\\002\\253\\001\\003\\002\\003\\002\\003\\002\\097\\000\\255\\255\\\n \\003\\002\\196\\001\\097\\000\\003\\002\\097\\000\\096\\000\\099\\000\\099\\000\\\n \\099\\000\\099\\000\\099\\000\\099\\000\\100\\000\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\235\\001\\003\\002\\\n \\241\\001\\003\\002\\255\\001\\242\\001\\003\\002\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\100\\000\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\\n \\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\246\\001\\129\\001\\129\\001\\\n \\228\\001\\003\\002\\196\\001\\003\\002\\101\\000\\101\\000\\101\\000\\101\\000\\\n \\101\\000\\101\\000\\003\\002\\198\\001\\003\\002\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\100\\000\\003\\002\\003\\002\\003\\002\\196\\001\\234\\001\\\n \\134\\001\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\\n \\097\\000\\097\\000\\097\\000\\000\\000\\101\\000\\101\\000\\101\\000\\101\\000\\\n \\101\\000\\101\\000\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\\n \\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\\n \\182\\000\\182\\000\\000\\000\\000\\000\\201\\001\\177\\000\\184\\000\\184\\000\\\n \\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\\n \\188\\000\\000\\000\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\\n \\201\\001\\227\\001\\000\\000\\191\\000\\206\\001\\123\\001\\189\\000\\190\\000\\\n \\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\\n \\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\\n \\190\\000\\190\\000\\189\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\\n \\190\\000\\190\\000\\190\\000\\190\\000\\195\\000\\197\\000\\197\\000\\197\\000\\\n \\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\198\\000\\\n \\255\\255\\248\\001\\196\\000\\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\\n \\197\\000\\197\\000\\197\\000\\197\\000\\196\\000\\197\\000\\197\\000\\197\\000\\\n \\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\202\\000\\227\\000\\\n \\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\\n \\227\\000\\205\\000\\255\\255\\255\\255\\203\\000\\204\\000\\204\\000\\204\\000\\\n \\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\226\\000\\195\\001\\\n \\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\\n \\204\\000\\204\\000\\232\\001\\000\\000\\000\\000\\206\\000\\221\\001\\239\\001\\\n \\254\\001\\000\\000\\207\\000\\244\\001\\000\\000\\225\\000\\203\\000\\204\\000\\\n \\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\\n \\232\\000\\000\\000\\232\\000\\000\\000\\225\\001\\231\\000\\231\\000\\231\\000\\\n \\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\217\\000\\\n \\255\\255\\000\\000\\000\\000\\000\\000\\000\\000\\225\\000\\227\\000\\227\\000\\\n \\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\000\\000\\000\\000\\230\\000\\\n \\000\\000\\230\\000\\000\\000\\228\\000\\229\\000\\229\\000\\229\\000\\229\\000\\\n \\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\\n \\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\\n \\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\\n \\229\\000\\229\\000\\000\\000\\228\\000\\231\\000\\231\\000\\231\\000\\231\\000\\\n \\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\186\\000\\231\\000\\\n \\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\\n \\231\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\241\\000\\000\\000\\\n \\113\\001\\000\\000\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\\n \\077\\001\\077\\001\\077\\001\\077\\001\\114\\001\\114\\001\\114\\001\\114\\001\\\n \\114\\001\\114\\001\\114\\001\\114\\001\\114\\001\\114\\001\\000\\000\\112\\001\\\n \\000\\000\\000\\000\\193\\000\\000\\000\\000\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\112\\001\\\n \\000\\000\\000\\000\\000\\000\\240\\000\\200\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\000\\000\\246\\000\\000\\000\\000\\000\\240\\000\\000\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\245\\000\\000\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\238\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\245\\000\\000\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\069\\001\\070\\001\\000\\000\\000\\000\\069\\001\\076\\001\\077\\001\\077\\001\\\n \\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\069\\001\\\n \\000\\000\\078\\001\\000\\000\\000\\000\\000\\000\\000\\000\\104\\001\\073\\001\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\079\\001\\000\\000\\071\\001\\076\\001\\\n \\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\\n \\077\\001\\000\\000\\000\\000\\072\\001\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\243\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\080\\001\\119\\001\\000\\000\\119\\001\\000\\000\\081\\001\\118\\001\\118\\001\\\n \\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\\n \\000\\000\\000\\000\\074\\001\\114\\001\\114\\001\\114\\001\\114\\001\\114\\001\\\n \\114\\001\\114\\001\\114\\001\\114\\001\\114\\001\\083\\001\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\082\\001\\000\\000\\000\\000\\\n \\115\\001\\000\\000\\000\\000\\084\\001\\000\\000\\000\\000\\117\\001\\000\\000\\\n \\117\\001\\000\\000\\075\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\\n \\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\\n \\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\000\\000\\\n \\115\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\\n \\116\\001\\116\\001\\116\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\\n \\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\\n \\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\000\\000\\\n \\128\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\\n \\130\\001\\130\\001\\130\\001\\000\\000\\000\\000\\128\\001\\000\\000\\000\\000\\\n \\000\\000\\128\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\001\\000\\000\\\n \\000\\000\\185\\001\\000\\000\\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\\n \\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\\n \\184\\001\\000\\000\\128\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\128\\001\\000\\000\\000\\000\\000\\000\\128\\001\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\128\\001\\128\\001\\000\\000\\000\\000\\068\\001\\\n \\128\\001\\128\\001\\128\\001\\127\\001\\000\\000\\128\\001\\000\\000\\000\\000\\\n \\184\\001\\000\\000\\000\\000\\000\\000\\000\\000\\128\\001\\000\\000\\000\\000\\\n \\000\\000\\128\\001\\000\\000\\128\\001\\127\\001\\131\\001\\131\\001\\131\\001\\\n \\131\\001\\131\\001\\131\\001\\131\\001\\131\\001\\131\\001\\131\\001\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\131\\001\\131\\001\\\n \\131\\001\\131\\001\\131\\001\\131\\001\\132\\001\\132\\001\\132\\001\\132\\001\\\n \\132\\001\\132\\001\\132\\001\\132\\001\\132\\001\\132\\001\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\132\\001\\132\\001\\132\\001\\\n \\132\\001\\132\\001\\132\\001\\000\\000\\000\\000\\000\\000\\131\\001\\131\\001\\\n \\131\\001\\131\\001\\131\\001\\131\\001\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\128\\001\\128\\001\\128\\001\\128\\001\\128\\001\\128\\001\\\n \\128\\001\\128\\001\\128\\001\\128\\001\\000\\000\\132\\001\\132\\001\\132\\001\\\n \\132\\001\\132\\001\\132\\001\\128\\001\\128\\001\\128\\001\\128\\001\\128\\001\\\n \\128\\001\\191\\001\\142\\001\\191\\001\\000\\000\\000\\000\\190\\001\\190\\001\\\n \\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\\n \\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\\n \\186\\001\\186\\001\\000\\000\\128\\001\\128\\001\\128\\001\\128\\001\\128\\001\\\n \\128\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\000\\000\\000\\000\\000\\000\\000\\000\\141\\001\\\n \\000\\000\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\141\\001\\000\\000\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\146\\001\\147\\001\\\n \\000\\000\\000\\000\\146\\001\\154\\001\\155\\001\\155\\001\\155\\001\\155\\001\\\n \\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\200\\001\\146\\001\\000\\000\\153\\001\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\177\\001\\150\\001\\000\\000\\000\\000\\\n \\000\\000\\200\\001\\156\\001\\000\\000\\148\\001\\154\\001\\155\\001\\155\\001\\\n \\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\000\\000\\\n \\000\\000\\149\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\139\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\157\\001\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\158\\001\\186\\001\\186\\001\\186\\001\\186\\001\\\n \\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\200\\001\\000\\000\\\n \\151\\001\\000\\000\\000\\000\\000\\000\\200\\001\\000\\000\\000\\000\\000\\000\\\n \\200\\001\\187\\001\\000\\000\\160\\001\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\200\\001\\000\\000\\000\\000\\159\\001\\200\\001\\000\\000\\200\\001\\199\\001\\\n \\000\\000\\161\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\152\\001\\000\\000\\000\\000\\000\\000\\000\\000\\189\\001\\000\\000\\189\\001\\\n \\000\\000\\187\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\\n \\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\\n \\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\\n \\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\\n \\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\\n \\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\\n \\190\\001\\190\\001\\190\\001\\190\\001\\202\\001\\202\\001\\202\\001\\202\\001\\\n \\202\\001\\202\\001\\202\\001\\202\\001\\202\\001\\202\\001\\200\\001\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\202\\001\\202\\001\\202\\001\\\n \\202\\001\\202\\001\\202\\001\\200\\001\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\202\\001\\202\\001\\202\\001\\\n \\202\\001\\202\\001\\202\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\200\\001\\000\\000\\000\\000\\000\\000\\000\\000\\145\\001\\200\\001\\000\\000\\\n \\000\\000\\000\\000\\200\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\200\\001\\000\\000\\000\\000\\000\\000\\200\\001\\000\\000\\\n \\200\\001\\199\\001\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\\n \\203\\001\\203\\001\\203\\001\\203\\001\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\\n \\203\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\\n \\204\\001\\204\\001\\204\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\\n \\000\\000\\000\\000\\000\\000\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\\n \\203\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\200\\001\\\n \\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\\n \\200\\001\\000\\000\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\\n \\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\000\\000\\214\\001\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\213\\001\\000\\000\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\000\\000\\000\\000\\000\\000\\000\\000\\213\\001\\\n \\000\\000\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\211\\001\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\";\n Lexing.lex_check =\n \"\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\000\\000\\000\\000\\255\\255\\003\\000\\000\\000\\134\\000\\255\\255\\\n \\003\\000\\255\\255\\134\\000\\069\\001\\146\\001\\057\\000\\255\\255\\069\\001\\\n \\146\\001\\255\\255\\255\\255\\255\\255\\255\\255\\125\\000\\138\\000\\255\\255\\\n \\000\\000\\255\\255\\000\\000\\003\\000\\169\\000\\134\\000\\174\\000\\255\\255\\\n \\000\\000\\010\\001\\069\\001\\146\\001\\012\\001\\000\\000\\010\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\005\\000\\115\\000\\000\\000\\125\\000\\129\\000\\005\\000\\\n \\236\\001\\136\\000\\255\\001\\038\\000\\255\\255\\010\\000\\136\\000\\102\\000\\\n \\058\\000\\000\\000\\107\\000\\102\\000\\255\\255\\011\\000\\000\\000\\011\\000\\\n \\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\\n \\011\\000\\029\\000\\038\\000\\000\\000\\111\\000\\208\\000\\233\\000\\255\\000\\\n \\012\\001\\015\\000\\017\\000\\060\\000\\011\\000\\010\\000\\000\\000\\020\\000\\\n \\024\\000\\031\\000\\032\\000\\034\\000\\022\\000\\026\\000\\000\\000\\014\\000\\\n \\027\\000\\033\\000\\018\\000\\023\\000\\000\\000\\016\\000\\019\\000\\035\\000\\\n \\040\\000\\036\\000\\038\\000\\000\\000\\041\\000\\042\\000\\043\\000\\044\\000\\\n \\045\\000\\046\\000\\058\\000\\082\\000\\011\\000\\013\\000\\013\\000\\013\\000\\\n \\013\\000\\013\\000\\013\\000\\013\\000\\013\\000\\013\\000\\013\\000\\039\\000\\\n \\063\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\\n \\039\\000\\039\\000\\039\\000\\085\\000\\140\\000\\060\\000\\013\\000\\143\\000\\\n \\144\\000\\145\\000\\048\\000\\147\\000\\048\\000\\148\\000\\039\\000\\048\\000\\\n \\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\\n \\048\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\\n \\049\\000\\049\\000\\049\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\\n \\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\065\\000\\039\\000\\149\\000\\\n \\150\\000\\156\\000\\063\\000\\157\\000\\051\\000\\158\\000\\051\\000\\159\\000\\\n \\050\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\\n \\051\\000\\051\\000\\051\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\\n \\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\053\\000\\053\\000\\053\\000\\\n \\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\155\\000\\\n \\050\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\\n \\054\\000\\054\\000\\054\\000\\161\\000\\162\\000\\155\\000\\091\\000\\065\\000\\\n \\000\\000\\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\\n \\055\\000\\055\\000\\055\\000\\057\\000\\068\\000\\102\\000\\107\\000\\115\\000\\\n \\131\\000\\133\\000\\133\\000\\125\\000\\138\\000\\133\\000\\163\\000\\094\\000\\\n \\165\\000\\068\\000\\166\\000\\167\\000\\168\\000\\171\\000\\111\\000\\172\\000\\\n \\173\\000\\206\\000\\203\\000\\207\\000\\210\\000\\211\\000\\058\\000\\082\\000\\\n \\133\\000\\212\\000\\213\\000\\214\\000\\215\\000\\217\\000\\140\\000\\218\\000\\\n \\097\\000\\219\\000\\220\\000\\119\\000\\221\\000\\222\\000\\223\\000\\133\\000\\\n \\091\\000\\203\\000\\034\\001\\062\\001\\233\\000\\152\\000\\001\\001\\080\\001\\\n \\247\\000\\060\\000\\251\\000\\054\\001\\058\\001\\081\\001\\068\\000\\041\\001\\\n \\082\\001\\083\\001\\006\\001\\026\\001\\068\\000\\119\\000\\030\\001\\015\\001\\\n \\068\\000\\094\\000\\015\\001\\084\\001\\085\\001\\086\\001\\071\\001\\088\\001\\\n \\068\\000\\203\\000\\050\\001\\071\\001\\068\\000\\089\\001\\068\\000\\068\\000\\\n \\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\\n \\071\\000\\071\\000\\097\\000\\076\\001\\119\\000\\090\\001\\063\\000\\001\\001\\\n \\092\\001\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\078\\000\\\n \\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\\n \\078\\000\\152\\000\\076\\001\\093\\001\\095\\001\\097\\001\\098\\001\\045\\001\\\n \\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\099\\001\\152\\000\\\n \\100\\001\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\180\\000\\\n \\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\\n \\180\\000\\020\\001\\076\\001\\065\\000\\020\\001\\101\\001\\102\\001\\104\\001\\\n \\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\079\\000\\079\\000\\\n \\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\\n \\105\\001\\106\\001\\045\\001\\036\\001\\107\\001\\108\\001\\109\\001\\079\\000\\\n \\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\080\\000\\080\\000\\080\\000\\\n \\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\110\\001\\\n \\026\\001\\121\\001\\157\\001\\030\\001\\158\\001\\020\\001\\080\\000\\080\\000\\\n \\080\\000\\080\\000\\080\\000\\080\\000\\091\\000\\159\\001\\062\\001\\079\\000\\\n \\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\247\\000\\160\\001\\251\\000\\\n \\161\\001\\058\\001\\068\\000\\086\\000\\086\\000\\086\\000\\086\\000\\086\\000\\\n \\086\\000\\086\\000\\086\\000\\086\\000\\086\\000\\094\\000\\080\\000\\080\\000\\\n \\080\\000\\080\\000\\080\\000\\080\\000\\086\\000\\086\\000\\086\\000\\086\\000\\\n \\086\\000\\086\\000\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\\n \\087\\000\\087\\000\\087\\000\\087\\000\\036\\001\\041\\001\\097\\000\\162\\001\\\n \\163\\001\\119\\000\\001\\001\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\\n \\087\\000\\165\\001\\054\\001\\152\\000\\086\\000\\086\\000\\086\\000\\086\\000\\\n \\086\\000\\086\\000\\006\\001\\166\\001\\167\\001\\168\\001\\015\\001\\169\\001\\\n \\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\\n \\088\\000\\088\\000\\050\\001\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\\n \\087\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\089\\000\\\n \\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\\n \\089\\000\\095\\000\\133\\001\\170\\001\\171\\001\\154\\001\\133\\001\\172\\001\\\n \\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\095\\000\\176\\000\\\n \\173\\001\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\045\\001\\\n \\174\\001\\175\\001\\176\\000\\176\\001\\154\\001\\176\\000\\176\\000\\176\\000\\\n \\176\\000\\176\\000\\176\\000\\176\\000\\176\\000\\176\\000\\176\\000\\122\\001\\\n \\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\148\\001\\177\\001\\\n \\020\\001\\178\\001\\098\\000\\148\\001\\179\\001\\180\\001\\181\\001\\182\\001\\\n \\183\\001\\216\\001\\193\\001\\095\\000\\154\\001\\216\\001\\205\\001\\098\\000\\\n \\222\\001\\095\\000\\205\\001\\229\\001\\001\\002\\095\\000\\218\\001\\036\\001\\\n \\215\\001\\215\\001\\002\\002\\218\\001\\215\\001\\095\\000\\004\\002\\005\\002\\\n \\216\\001\\095\\000\\006\\002\\095\\000\\095\\000\\096\\000\\096\\000\\096\\000\\\n \\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\215\\001\\\n \\007\\002\\122\\001\\008\\002\\009\\002\\010\\002\\011\\002\\096\\000\\096\\000\\\n \\096\\000\\096\\000\\096\\000\\096\\000\\098\\000\\012\\002\\215\\001\\247\\001\\\n \\013\\002\\014\\002\\098\\000\\015\\002\\125\\001\\128\\001\\098\\000\\016\\002\\\n \\220\\001\\017\\002\\251\\001\\018\\002\\019\\002\\020\\002\\098\\000\\121\\001\\\n \\021\\002\\194\\001\\098\\000\\022\\002\\098\\000\\098\\000\\096\\000\\096\\000\\\n \\096\\000\\096\\000\\096\\000\\096\\000\\099\\000\\099\\000\\099\\000\\099\\000\\\n \\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\231\\001\\023\\002\\\n \\238\\001\\024\\002\\251\\001\\238\\001\\025\\002\\099\\000\\099\\000\\099\\000\\\n \\099\\000\\099\\000\\099\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\243\\001\\125\\001\\128\\001\\\n \\224\\001\\026\\002\\197\\001\\027\\002\\100\\000\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\028\\002\\194\\001\\029\\002\\099\\000\\099\\000\\099\\000\\\n \\099\\000\\099\\000\\099\\000\\030\\002\\031\\002\\032\\002\\200\\001\\231\\001\\\n \\133\\001\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\\n \\101\\000\\101\\000\\101\\000\\255\\255\\100\\000\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\\n \\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\\n \\182\\000\\182\\000\\255\\255\\255\\255\\197\\001\\176\\000\\184\\000\\184\\000\\\n \\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\\n \\185\\000\\255\\255\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\\n \\200\\001\\224\\001\\255\\255\\185\\000\\205\\001\\122\\001\\185\\000\\185\\000\\\n \\185\\000\\185\\000\\185\\000\\185\\000\\185\\000\\185\\000\\185\\000\\185\\000\\\n \\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\\n \\190\\000\\190\\000\\191\\000\\191\\000\\191\\000\\191\\000\\191\\000\\191\\000\\\n \\191\\000\\191\\000\\191\\000\\191\\000\\192\\000\\197\\000\\197\\000\\197\\000\\\n \\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\192\\000\\\n \\193\\001\\247\\001\\192\\000\\192\\000\\192\\000\\192\\000\\192\\000\\192\\000\\\n \\192\\000\\192\\000\\192\\000\\192\\000\\198\\000\\198\\000\\198\\000\\198\\000\\\n \\198\\000\\198\\000\\198\\000\\198\\000\\198\\000\\198\\000\\199\\000\\226\\000\\\n \\226\\000\\226\\000\\226\\000\\226\\000\\226\\000\\226\\000\\226\\000\\226\\000\\\n \\226\\000\\199\\000\\125\\001\\128\\001\\199\\000\\199\\000\\199\\000\\199\\000\\\n \\199\\000\\199\\000\\199\\000\\199\\000\\199\\000\\199\\000\\204\\000\\194\\001\\\n \\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\\n \\204\\000\\204\\000\\231\\001\\255\\255\\255\\255\\199\\000\\220\\001\\238\\001\\\n \\251\\001\\255\\255\\199\\000\\243\\001\\255\\255\\204\\000\\205\\000\\205\\000\\\n \\205\\000\\205\\000\\205\\000\\205\\000\\205\\000\\205\\000\\205\\000\\205\\000\\\n \\225\\000\\255\\255\\225\\000\\255\\255\\224\\001\\225\\000\\225\\000\\225\\000\\\n \\225\\000\\225\\000\\225\\000\\225\\000\\225\\000\\225\\000\\225\\000\\205\\000\\\n \\197\\001\\255\\255\\255\\255\\255\\255\\255\\255\\204\\000\\227\\000\\227\\000\\\n \\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\200\\001\\255\\255\\255\\255\\228\\000\\\n \\255\\255\\228\\000\\255\\255\\227\\000\\228\\000\\228\\000\\228\\000\\228\\000\\\n \\228\\000\\228\\000\\228\\000\\228\\000\\228\\000\\228\\000\\229\\000\\229\\000\\\n \\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\\n \\230\\000\\230\\000\\230\\000\\230\\000\\230\\000\\230\\000\\230\\000\\230\\000\\\n \\230\\000\\230\\000\\255\\255\\227\\000\\231\\000\\231\\000\\231\\000\\231\\000\\\n \\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\185\\000\\232\\000\\\n \\232\\000\\232\\000\\232\\000\\232\\000\\232\\000\\232\\000\\232\\000\\232\\000\\\n \\232\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\237\\000\\255\\255\\\n \\077\\001\\255\\255\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\\n \\077\\001\\077\\001\\077\\001\\077\\001\\113\\001\\113\\001\\113\\001\\113\\001\\\n \\113\\001\\113\\001\\113\\001\\113\\001\\113\\001\\113\\001\\255\\255\\077\\001\\\n \\255\\255\\255\\255\\192\\000\\255\\255\\255\\255\\237\\000\\237\\000\\237\\000\\\n \\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\\n \\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\\n \\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\077\\001\\\n \\255\\255\\255\\255\\255\\255\\237\\000\\199\\000\\237\\000\\237\\000\\237\\000\\\n \\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\\n \\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\\n \\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\255\\255\\242\\000\\255\\255\\255\\255\\240\\000\\255\\255\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\\n \\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\\n \\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\\n \\242\\000\\242\\000\\242\\000\\242\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\242\\000\\255\\255\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\\n \\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\\n \\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\\n \\242\\000\\242\\000\\242\\000\\242\\000\\237\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\245\\000\\255\\255\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\066\\001\\066\\001\\255\\255\\255\\255\\066\\001\\079\\001\\079\\001\\079\\001\\\n \\079\\001\\079\\001\\079\\001\\079\\001\\079\\001\\079\\001\\079\\001\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\066\\001\\\n \\255\\255\\066\\001\\255\\255\\255\\255\\255\\255\\255\\255\\079\\001\\066\\001\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\066\\001\\255\\255\\066\\001\\066\\001\\\n \\066\\001\\066\\001\\066\\001\\066\\001\\066\\001\\066\\001\\066\\001\\066\\001\\\n \\066\\001\\255\\255\\255\\255\\066\\001\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\242\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\066\\001\\112\\001\\255\\255\\112\\001\\255\\255\\066\\001\\112\\001\\112\\001\\\n \\112\\001\\112\\001\\112\\001\\112\\001\\112\\001\\112\\001\\112\\001\\112\\001\\\n \\255\\255\\255\\255\\066\\001\\114\\001\\114\\001\\114\\001\\114\\001\\114\\001\\\n \\114\\001\\114\\001\\114\\001\\114\\001\\114\\001\\066\\001\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\066\\001\\255\\255\\255\\255\\\n \\114\\001\\255\\255\\255\\255\\066\\001\\255\\255\\255\\255\\115\\001\\255\\255\\\n \\115\\001\\255\\255\\066\\001\\115\\001\\115\\001\\115\\001\\115\\001\\115\\001\\\n \\115\\001\\115\\001\\115\\001\\115\\001\\115\\001\\116\\001\\116\\001\\116\\001\\\n \\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\255\\255\\\n \\114\\001\\117\\001\\117\\001\\117\\001\\117\\001\\117\\001\\117\\001\\117\\001\\\n \\117\\001\\117\\001\\117\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\\n \\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\119\\001\\119\\001\\119\\001\\\n \\119\\001\\119\\001\\119\\001\\119\\001\\119\\001\\119\\001\\119\\001\\255\\255\\\n \\126\\001\\127\\001\\127\\001\\127\\001\\127\\001\\127\\001\\127\\001\\127\\001\\\n \\127\\001\\127\\001\\127\\001\\255\\255\\255\\255\\126\\001\\255\\255\\255\\255\\\n \\255\\255\\129\\001\\127\\001\\127\\001\\127\\001\\127\\001\\127\\001\\127\\001\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\129\\001\\255\\255\\\n \\255\\255\\155\\001\\255\\255\\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\\n \\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\127\\001\\127\\001\\127\\001\\127\\001\\127\\001\\127\\001\\\n \\155\\001\\255\\255\\126\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\126\\001\\255\\255\\255\\255\\255\\255\\126\\001\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\129\\001\\126\\001\\255\\255\\255\\255\\066\\001\\\n \\126\\001\\129\\001\\126\\001\\126\\001\\255\\255\\129\\001\\255\\255\\255\\255\\\n \\155\\001\\255\\255\\255\\255\\255\\255\\255\\255\\129\\001\\255\\255\\255\\255\\\n \\255\\255\\129\\001\\255\\255\\129\\001\\129\\001\\130\\001\\130\\001\\130\\001\\\n \\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\130\\001\\130\\001\\\n \\130\\001\\130\\001\\130\\001\\130\\001\\131\\001\\131\\001\\131\\001\\131\\001\\\n \\131\\001\\131\\001\\131\\001\\131\\001\\131\\001\\131\\001\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\131\\001\\131\\001\\131\\001\\\n \\131\\001\\131\\001\\131\\001\\255\\255\\255\\255\\255\\255\\130\\001\\130\\001\\\n \\130\\001\\130\\001\\130\\001\\130\\001\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\132\\001\\132\\001\\132\\001\\132\\001\\132\\001\\132\\001\\\n \\132\\001\\132\\001\\132\\001\\132\\001\\255\\255\\131\\001\\131\\001\\131\\001\\\n \\131\\001\\131\\001\\131\\001\\132\\001\\132\\001\\132\\001\\132\\001\\132\\001\\\n \\132\\001\\184\\001\\138\\001\\184\\001\\255\\255\\255\\255\\184\\001\\184\\001\\\n \\184\\001\\184\\001\\184\\001\\184\\001\\184\\001\\184\\001\\184\\001\\184\\001\\\n \\185\\001\\185\\001\\185\\001\\185\\001\\185\\001\\185\\001\\185\\001\\185\\001\\\n \\185\\001\\185\\001\\255\\255\\132\\001\\132\\001\\132\\001\\132\\001\\132\\001\\\n \\132\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\\n \\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\\n \\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\\n \\138\\001\\138\\001\\138\\001\\255\\255\\255\\255\\255\\255\\255\\255\\138\\001\\\n \\255\\255\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\\n \\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\\n \\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\\n \\138\\001\\138\\001\\138\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\141\\001\\255\\255\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\143\\001\\143\\001\\\n \\255\\255\\255\\255\\143\\001\\156\\001\\156\\001\\156\\001\\156\\001\\156\\001\\\n \\156\\001\\156\\001\\156\\001\\156\\001\\156\\001\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\198\\001\\143\\001\\255\\255\\143\\001\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\156\\001\\143\\001\\255\\255\\255\\255\\\n \\255\\255\\198\\001\\143\\001\\255\\255\\143\\001\\143\\001\\143\\001\\143\\001\\\n \\143\\001\\143\\001\\143\\001\\143\\001\\143\\001\\143\\001\\143\\001\\255\\255\\\n \\255\\255\\143\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\138\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\143\\001\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\143\\001\\186\\001\\186\\001\\186\\001\\186\\001\\\n \\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\198\\001\\255\\255\\\n \\143\\001\\255\\255\\255\\255\\255\\255\\198\\001\\255\\255\\255\\255\\255\\255\\\n \\198\\001\\186\\001\\255\\255\\143\\001\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\198\\001\\255\\255\\255\\255\\143\\001\\198\\001\\255\\255\\198\\001\\198\\001\\\n \\255\\255\\143\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\143\\001\\255\\255\\255\\255\\255\\255\\255\\255\\187\\001\\255\\255\\187\\001\\\n \\255\\255\\186\\001\\187\\001\\187\\001\\187\\001\\187\\001\\187\\001\\187\\001\\\n \\187\\001\\187\\001\\187\\001\\187\\001\\188\\001\\188\\001\\188\\001\\188\\001\\\n \\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\189\\001\\189\\001\\\n \\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\\n \\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\\n \\190\\001\\190\\001\\191\\001\\191\\001\\191\\001\\191\\001\\191\\001\\191\\001\\\n \\191\\001\\191\\001\\191\\001\\191\\001\\199\\001\\199\\001\\199\\001\\199\\001\\\n \\199\\001\\199\\001\\199\\001\\199\\001\\199\\001\\199\\001\\201\\001\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\199\\001\\199\\001\\199\\001\\\n \\199\\001\\199\\001\\199\\001\\201\\001\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\199\\001\\199\\001\\199\\001\\\n \\199\\001\\199\\001\\199\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\201\\001\\255\\255\\255\\255\\255\\255\\255\\255\\143\\001\\201\\001\\255\\255\\\n \\255\\255\\255\\255\\201\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\201\\001\\255\\255\\255\\255\\255\\255\\201\\001\\255\\255\\\n \\201\\001\\201\\001\\202\\001\\202\\001\\202\\001\\202\\001\\202\\001\\202\\001\\\n \\202\\001\\202\\001\\202\\001\\202\\001\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\202\\001\\202\\001\\202\\001\\202\\001\\202\\001\\\n \\202\\001\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\\n \\203\\001\\203\\001\\203\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\\n \\255\\255\\255\\255\\255\\255\\202\\001\\202\\001\\202\\001\\202\\001\\202\\001\\\n \\202\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\204\\001\\\n \\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\\n \\204\\001\\255\\255\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\\n \\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\255\\255\\210\\001\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\210\\001\\210\\001\\\n \\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\\n \\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\\n \\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\210\\001\\255\\255\\210\\001\\210\\001\\\n \\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\\n \\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\\n \\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\255\\255\\255\\255\\255\\255\\255\\255\\213\\001\\\n \\255\\255\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\210\\001\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\";\n Lexing.lex_base_code =\n \"\";\n Lexing.lex_backtrk_code =\n \"\";\n Lexing.lex_default_code =\n \"\";\n Lexing.lex_trans_code =\n \"\";\n Lexing.lex_check_code =\n \"\";\n Lexing.lex_code =\n \"\";\n}\n\nlet rec read_json v lexbuf =\n __ocaml_lex_read_json_rec v lexbuf 0\nand __ocaml_lex_read_json_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 188 \"lib/read.mll\"\n \n# 188 \"lib/read.mll\"\n ( `Bool true )\n\n# 1032 \"lib/read.ml\"\n\n \n# 1033 \"lib/read.ml\"\n | 1 ->\n\n# 189 \"lib/read.mll\"\n \n# 189 \"lib/read.mll\"\n ( `Bool false )\n\n# 1037 \"lib/read.ml\"\n\n \n# 1038 \"lib/read.ml\"\n | 2 ->\n\n# 190 \"lib/read.mll\"\n \n# 190 \"lib/read.mll\"\n ( `Null )\n\n# 1042 \"lib/read.ml\"\n\n \n# 1043 \"lib/read.ml\"\n | 3 ->\n\n# 191 \"lib/read.mll\"\n \n# 191 \"lib/read.mll\"\n (\n \n# 193 \"lib/read.mll\"\n `Float nan\n \n# 197 \"lib/read.mll\"\n )\n\n# 1053 \"lib/read.ml\"\n\n \n# 1054 \"lib/read.ml\"\n | 4 ->\n\n# 198 \"lib/read.mll\"\n \n# 198 \"lib/read.mll\"\n (\n \n# 200 \"lib/read.mll\"\n `Float infinity\n \n# 204 \"lib/read.mll\"\n )\n\n# 1064 \"lib/read.ml\"\n\n \n# 1065 \"lib/read.ml\"\n | 5 ->\n\n# 205 \"lib/read.mll\"\n \n# 205 \"lib/read.mll\"\n (\n \n# 207 \"lib/read.mll\"\n `Float neg_infinity\n \n# 211 \"lib/read.mll\"\n )\n\n# 1075 \"lib/read.ml\"\n\n \n# 1076 \"lib/read.ml\"\n | 6 ->\n\n# 212 \"lib/read.mll\"\n \n# 212 \"lib/read.mll\"\n (\n \n# 214 \"lib/read.mll\"\n Bi_outbuf.clear v.buf;\n `String (finish_string v lexbuf)\n \n# 219 \"lib/read.mll\"\n )\n\n# 1087 \"lib/read.ml\"\n\n \n# 1088 \"lib/read.ml\"\n | 7 ->\n\n# 220 \"lib/read.mll\"\n \n# 220 \"lib/read.mll\"\n ( make_positive_int v lexbuf )\n\n# 1092 \"lib/read.ml\"\n\n \n# 1093 \"lib/read.ml\"\n | 8 ->\n\n# 221 \"lib/read.mll\"\n \n# 221 \"lib/read.mll\"\n ( make_negative_int v lexbuf )\n\n# 1097 \"lib/read.ml\"\n\n \n# 1098 \"lib/read.ml\"\n | 9 ->\n\n# 222 \"lib/read.mll\"\n \n# 222 \"lib/read.mll\"\n (\n \n# 224 \"lib/read.mll\"\n `Float (float_of_string (lexeme lexbuf))\n \n# 228 \"lib/read.mll\"\n )\n\n# 1108 \"lib/read.ml\"\n\n \n# 1109 \"lib/read.ml\"\n | 10 ->\n\n# 230 \"lib/read.mll\"\n \n# 230 \"lib/read.mll\"\n ( let acc = ref [] in\n try\n read_space v lexbuf;\n read_object_end lexbuf;\n let field_name = read_ident v lexbuf in\n read_space v lexbuf;\n read_colon v lexbuf;\n read_space v lexbuf;\n acc := (field_name, read_json v lexbuf) :: !acc;\n while true do\n read_space v lexbuf;\n read_object_sep v lexbuf;\n read_space v lexbuf;\n let field_name = read_ident v lexbuf in\n read_space v lexbuf;\n read_colon v lexbuf;\n read_space v lexbuf;\n acc := (field_name, read_json v lexbuf) :: !acc;\n done;\n assert false\n with End_of_object ->\n `Assoc (List.rev !acc)\n )\n\n# 1135 \"lib/read.ml\"\n\n \n# 1136 \"lib/read.ml\"\n | 11 ->\n\n# 254 \"lib/read.mll\"\n \n# 254 \"lib/read.mll\"\n ( let acc = ref [] in\n try\n read_space v lexbuf;\n read_array_end lexbuf;\n acc := read_json v lexbuf :: !acc;\n while true do\n read_space v lexbuf;\n read_array_sep v lexbuf;\n read_space v lexbuf;\n acc := read_json v lexbuf :: !acc;\n done;\n assert false\n with End_of_array ->\n `List (List.rev !acc)\n )\n\n# 1154 \"lib/read.ml\"\n\n \n# 1155 \"lib/read.ml\"\n | 12 ->\n\n# 270 \"lib/read.mll\"\n \n# 270 \"lib/read.mll\"\n (\n \n# 272 \"lib/read.mll\"\n let acc = ref [] in\n try\n read_space v lexbuf;\n read_tuple_end lexbuf;\n acc := read_json v lexbuf :: !acc;\n while true do\n read_space v lexbuf;\n read_tuple_sep v lexbuf;\n read_space v lexbuf;\n acc := read_json v lexbuf :: !acc;\n done;\n assert false\n with End_of_tuple ->\n `Tuple (List.rev !acc)\n \n# 289 \"lib/read.mll\"\n )\n\n# 1178 \"lib/read.ml\"\n\n \n# 1179 \"lib/read.ml\"\n | 13 ->\n\n# 291 \"lib/read.mll\"\n \n# 291 \"lib/read.mll\"\n (\n \n# 293 \"lib/read.mll\"\n read_space v lexbuf;\n let cons = read_ident v lexbuf in\n read_space v lexbuf;\n `Variant (cons, finish_variant v lexbuf)\n \n# 300 \"lib/read.mll\"\n )\n\n# 1192 \"lib/read.ml\"\n\n \n# 1193 \"lib/read.ml\"\n | 14 ->\n\n# 302 \"lib/read.mll\"\n \n# 302 \"lib/read.mll\"\n ( read_json v lexbuf )\n\n# 1197 \"lib/read.ml\"\n\n \n# 1198 \"lib/read.ml\"\n | 15 ->\n\n# 303 \"lib/read.mll\"\n \n# 303 \"lib/read.mll\"\n ( finish_comment v lexbuf; read_json v lexbuf )\n\n# 1202 \"lib/read.ml\"\n\n \n# 1203 \"lib/read.ml\"\n | 16 ->\n\n# 304 \"lib/read.mll\"\n \n# 304 \"lib/read.mll\"\n ( newline v lexbuf; read_json v lexbuf )\n\n# 1207 \"lib/read.ml\"\n\n \n# 1208 \"lib/read.ml\"\n | 17 ->\n\n# 305 \"lib/read.mll\"\n \n# 305 \"lib/read.mll\"\n ( read_json v lexbuf )\n\n# 1212 \"lib/read.ml\"\n\n \n# 1213 \"lib/read.ml\"\n | 18 ->\n\n# 306 \"lib/read.mll\"\n \n# 306 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1217 \"lib/read.ml\"\n\n \n# 1218 \"lib/read.ml\"\n | 19 ->\n\n# 307 \"lib/read.mll\"\n \n# 307 \"lib/read.mll\"\n ( long_error \"Invalid token\" v lexbuf )\n\n# 1222 \"lib/read.ml\"\n\n \n# 1223 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_json_rec v lexbuf __ocaml_lex_state\n\nand finish_string v lexbuf =\n __ocaml_lex_finish_string_rec v lexbuf 58\nand __ocaml_lex_finish_string_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 311 \"lib/read.mll\"\n \n# 311 \"lib/read.mll\"\n ( Bi_outbuf.contents v.buf )\n\n# 1234 \"lib/read.ml\"\n\n \n# 1235 \"lib/read.ml\"\n | 1 ->\n\n# 312 \"lib/read.mll\"\n \n# 312 \"lib/read.mll\"\n ( finish_escaped_char v lexbuf;\n finish_string v lexbuf )\n\n# 1240 \"lib/read.ml\"\n\n \n# 1241 \"lib/read.ml\"\n | 2 ->\n\n# 314 \"lib/read.mll\"\n \n# 314 \"lib/read.mll\"\n ( add_lexeme v.buf lexbuf;\n finish_string v lexbuf )\n\n# 1246 \"lib/read.ml\"\n\n \n# 1247 \"lib/read.ml\"\n | 3 ->\n\n# 316 \"lib/read.mll\"\n \n# 316 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1251 \"lib/read.ml\"\n\n \n# 1252 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_string_rec v lexbuf __ocaml_lex_state\n\nand map_string v f lexbuf =\n __ocaml_lex_map_string_rec v f lexbuf 63\nand __ocaml_lex_map_string_rec v f lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 319 \"lib/read.mll\"\n \n# 319 \"lib/read.mll\"\n ( let b = v.buf in\n f (Bytes.to_string b.Bi_outbuf.o_s) 0 b.Bi_outbuf.o_len )\n\n# 1264 \"lib/read.ml\"\n\n \n# 1265 \"lib/read.ml\"\n | 1 ->\n\n# 321 \"lib/read.mll\"\n \n# 321 \"lib/read.mll\"\n ( finish_escaped_char v lexbuf;\n map_string v f lexbuf )\n\n# 1270 \"lib/read.ml\"\n\n \n# 1271 \"lib/read.ml\"\n | 2 ->\n\n# 323 \"lib/read.mll\"\n \n# 323 \"lib/read.mll\"\n ( add_lexeme v.buf lexbuf;\n map_string v f lexbuf )\n\n# 1276 \"lib/read.ml\"\n\n \n# 1277 \"lib/read.ml\"\n | 3 ->\n\n# 325 \"lib/read.mll\"\n \n# 325 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1281 \"lib/read.ml\"\n\n \n# 1282 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_map_string_rec v f lexbuf __ocaml_lex_state\n\nand finish_escaped_char v lexbuf =\n __ocaml_lex_finish_escaped_char_rec v lexbuf 68\nand __ocaml_lex_finish_escaped_char_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\nlet\n\n# 330 \"lib/read.mll\"\n \n# 330 \"lib/read.mll\"\n c\n\n# 1294 \"lib/read.ml\"\n# 1294 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf lexbuf.Lexing.lex_start_pos in\n\n# 330 \"lib/read.mll\"\n \n# 330 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf c )\n\n# 1298 \"lib/read.ml\"\n\n \n# 1299 \"lib/read.ml\"\n | 1 ->\n\n# 331 \"lib/read.mll\"\n \n# 331 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\\b' )\n\n# 1303 \"lib/read.ml\"\n\n \n# 1304 \"lib/read.ml\"\n | 2 ->\n\n# 332 \"lib/read.mll\"\n \n# 332 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\\012' )\n\n# 1308 \"lib/read.ml\"\n\n \n# 1309 \"lib/read.ml\"\n | 3 ->\n\n# 333 \"lib/read.mll\"\n \n# 333 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\\n' )\n\n# 1313 \"lib/read.ml\"\n\n \n# 1314 \"lib/read.ml\"\n | 4 ->\n\n# 334 \"lib/read.mll\"\n \n# 334 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\\r' )\n\n# 1318 \"lib/read.ml\"\n\n \n# 1319 \"lib/read.ml\"\n | 5 ->\n\n# 335 \"lib/read.mll\"\n \n# 335 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\\t' )\n\n# 1323 \"lib/read.ml\"\n\n \n# 1324 \"lib/read.ml\"\n | 6 ->\nlet\n\n# 336 \"lib/read.mll\"\n \n# 336 \"lib/read.mll\"\n a\n\n# 1329 \"lib/read.ml\"\n# 1329 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 1)\nand\n\n# 336 \"lib/read.mll\"\n \n# 336 \"lib/read.mll\"\n b\n\n# 1334 \"lib/read.ml\"\n# 1334 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 2)\nand\n\n# 336 \"lib/read.mll\"\n \n# 336 \"lib/read.mll\"\n c\n\n# 1339 \"lib/read.ml\"\n# 1339 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 3)\nand\n\n# 336 \"lib/read.mll\"\n \n# 336 \"lib/read.mll\"\n d\n\n# 1344 \"lib/read.ml\"\n# 1344 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 4) in\n\n# 337 \"lib/read.mll\"\n \n# 337 \"lib/read.mll\"\n ( let x =\n (hex a lsl 12) lor (hex b lsl 8) lor (hex c lsl 4) lor hex d\n in\n if x >= 0xD800 && x <= 0xDBFF then\n finish_surrogate_pair v x lexbuf\n else\n utf8_of_code v.buf x\n )\n\n# 1355 \"lib/read.ml\"\n\n \n# 1356 \"lib/read.ml\"\n | 7 ->\n\n# 345 \"lib/read.mll\"\n \n# 345 \"lib/read.mll\"\n ( long_error \"Invalid escape sequence\" v lexbuf )\n\n# 1360 \"lib/read.ml\"\n\n \n# 1361 \"lib/read.ml\"\n | 8 ->\n\n# 346 \"lib/read.mll\"\n \n# 346 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1365 \"lib/read.ml\"\n\n \n# 1366 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_escaped_char_rec v lexbuf __ocaml_lex_state\n\nand finish_surrogate_pair v x lexbuf =\n __ocaml_lex_finish_surrogate_pair_rec v x lexbuf 82\nand __ocaml_lex_finish_surrogate_pair_rec v x lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\nlet\n\n# 349 \"lib/read.mll\"\n \n# 349 \"lib/read.mll\"\n a\n\n# 1378 \"lib/read.ml\"\n# 1378 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 2)\nand\n\n# 349 \"lib/read.mll\"\n \n# 349 \"lib/read.mll\"\n b\n\n# 1383 \"lib/read.ml\"\n# 1383 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 3)\nand\n\n# 349 \"lib/read.mll\"\n \n# 349 \"lib/read.mll\"\n c\n\n# 1388 \"lib/read.ml\"\n# 1388 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 4)\nand\n\n# 349 \"lib/read.mll\"\n \n# 349 \"lib/read.mll\"\n d\n\n# 1393 \"lib/read.ml\"\n# 1393 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 5) in\n\n# 350 \"lib/read.mll\"\n \n# 350 \"lib/read.mll\"\n ( let y =\n (hex a lsl 12) lor (hex b lsl 8) lor (hex c lsl 4) lor hex d\n in\n if y >= 0xDC00 && y <= 0xDFFF then\n utf8_of_surrogate_pair v.buf x y\n else\n long_error \"Invalid low surrogate for code point beyond U+FFFF\"\n v lexbuf\n )\n\n# 1405 \"lib/read.ml\"\n\n \n# 1406 \"lib/read.ml\"\n | 1 ->\n\n# 359 \"lib/read.mll\"\n \n# 359 \"lib/read.mll\"\n ( long_error \"Missing escape sequence representing low surrogate \\\n for code point beyond U+FFFF\" v lexbuf )\n\n# 1411 \"lib/read.ml\"\n\n \n# 1412 \"lib/read.ml\"\n | 2 ->\n\n# 361 \"lib/read.mll\"\n \n# 361 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1416 \"lib/read.ml\"\n\n \n# 1417 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_surrogate_pair_rec v x lexbuf __ocaml_lex_state\n\nand finish_stringlit v lexbuf =\n __ocaml_lex_finish_stringlit_rec v lexbuf 91\nand __ocaml_lex_finish_stringlit_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 366 \"lib/read.mll\"\n \n# 366 \"lib/read.mll\"\n ( let len = lexbuf.lex_curr_pos - lexbuf.lex_start_pos in\n let s = Bytes.create (len+1) in\n Bytes.set s 0 '\"';\n Bytes.blit lexbuf.lex_buffer lexbuf.lex_start_pos s 1 len;\n Bytes.to_string s\n )\n\n# 1433 \"lib/read.ml\"\n\n \n# 1434 \"lib/read.ml\"\n | 1 ->\n\n# 372 \"lib/read.mll\"\n \n# 372 \"lib/read.mll\"\n ( long_error \"Invalid string literal\" v lexbuf )\n\n# 1438 \"lib/read.ml\"\n\n \n# 1439 \"lib/read.ml\"\n | 2 ->\n\n# 373 \"lib/read.mll\"\n \n# 373 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1443 \"lib/read.ml\"\n\n \n# 1444 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_stringlit_rec v lexbuf __ocaml_lex_state\n\nand finish_variant v lexbuf =\n __ocaml_lex_finish_variant_rec v lexbuf 102\nand __ocaml_lex_finish_variant_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 376 \"lib/read.mll\"\n \n# 376 \"lib/read.mll\"\n ( let x = read_json v lexbuf in\n read_space v lexbuf;\n read_gt v lexbuf;\n Some x )\n\n# 1458 \"lib/read.ml\"\n\n \n# 1459 \"lib/read.ml\"\n | 1 ->\n\n# 380 \"lib/read.mll\"\n \n# 380 \"lib/read.mll\"\n ( None )\n\n# 1463 \"lib/read.ml\"\n\n \n# 1464 \"lib/read.ml\"\n | 2 ->\n\n# 381 \"lib/read.mll\"\n \n# 381 \"lib/read.mll\"\n ( long_error \"Expected ':' or '>' but found\" v lexbuf )\n\n# 1468 \"lib/read.ml\"\n\n \n# 1469 \"lib/read.ml\"\n | 3 ->\n\n# 382 \"lib/read.mll\"\n \n# 382 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1473 \"lib/read.ml\"\n\n \n# 1474 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_variant_rec v lexbuf __ocaml_lex_state\n\nand read_lt v lexbuf =\n __ocaml_lex_read_lt_rec v lexbuf 107\nand __ocaml_lex_read_lt_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 385 \"lib/read.mll\"\n \n# 385 \"lib/read.mll\"\n ( () )\n\n# 1485 \"lib/read.ml\"\n\n \n# 1486 \"lib/read.ml\"\n | 1 ->\n\n# 386 \"lib/read.mll\"\n \n# 386 \"lib/read.mll\"\n ( long_error \"Expected '<' but found\" v lexbuf )\n\n# 1490 \"lib/read.ml\"\n\n \n# 1491 \"lib/read.ml\"\n | 2 ->\n\n# 387 \"lib/read.mll\"\n \n# 387 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1495 \"lib/read.ml\"\n\n \n# 1496 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_lt_rec v lexbuf __ocaml_lex_state\n\nand read_gt v lexbuf =\n __ocaml_lex_read_gt_rec v lexbuf 111\nand __ocaml_lex_read_gt_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 390 \"lib/read.mll\"\n \n# 390 \"lib/read.mll\"\n ( () )\n\n# 1507 \"lib/read.ml\"\n\n \n# 1508 \"lib/read.ml\"\n | 1 ->\n\n# 391 \"lib/read.mll\"\n \n# 391 \"lib/read.mll\"\n ( long_error \"Expected '>' but found\" v lexbuf )\n\n# 1512 \"lib/read.ml\"\n\n \n# 1513 \"lib/read.ml\"\n | 2 ->\n\n# 392 \"lib/read.mll\"\n \n# 392 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1517 \"lib/read.ml\"\n\n \n# 1518 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_gt_rec v lexbuf __ocaml_lex_state\n\nand read_comma v lexbuf =\n __ocaml_lex_read_comma_rec v lexbuf 115\nand __ocaml_lex_read_comma_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 395 \"lib/read.mll\"\n \n# 395 \"lib/read.mll\"\n ( () )\n\n# 1529 \"lib/read.ml\"\n\n \n# 1530 \"lib/read.ml\"\n | 1 ->\n\n# 396 \"lib/read.mll\"\n \n# 396 \"lib/read.mll\"\n ( long_error \"Expected ',' but found\" v lexbuf )\n\n# 1534 \"lib/read.ml\"\n\n \n# 1535 \"lib/read.ml\"\n | 2 ->\n\n# 397 \"lib/read.mll\"\n \n# 397 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1539 \"lib/read.ml\"\n\n \n# 1540 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_comma_rec v lexbuf __ocaml_lex_state\n\nand start_any_variant v lexbuf =\n __ocaml_lex_start_any_variant_rec v lexbuf 119\nand __ocaml_lex_start_any_variant_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 400 \"lib/read.mll\"\n \n# 400 \"lib/read.mll\"\n ( `Edgy_bracket )\n\n# 1551 \"lib/read.ml\"\n\n \n# 1552 \"lib/read.ml\"\n | 1 ->\n\n# 401 \"lib/read.mll\"\n \n# 401 \"lib/read.mll\"\n ( Bi_outbuf.clear v.buf;\n `Double_quote )\n\n# 1557 \"lib/read.ml\"\n\n \n# 1558 \"lib/read.ml\"\n | 2 ->\n\n# 403 \"lib/read.mll\"\n \n# 403 \"lib/read.mll\"\n ( `Square_bracket )\n\n# 1562 \"lib/read.ml\"\n\n \n# 1563 \"lib/read.ml\"\n | 3 ->\n\n# 404 \"lib/read.mll\"\n \n# 404 \"lib/read.mll\"\n ( long_error \"Expected '<', '\\\"' or '[' but found\" v lexbuf )\n\n# 1567 \"lib/read.ml\"\n\n \n# 1568 \"lib/read.ml\"\n | 4 ->\n\n# 405 \"lib/read.mll\"\n \n# 405 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1572 \"lib/read.ml\"\n\n \n# 1573 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_start_any_variant_rec v lexbuf __ocaml_lex_state\n\nand finish_comment v lexbuf =\n __ocaml_lex_finish_comment_rec v lexbuf 125\nand __ocaml_lex_finish_comment_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 408 \"lib/read.mll\"\n \n# 408 \"lib/read.mll\"\n ( () )\n\n# 1584 \"lib/read.ml\"\n\n \n# 1585 \"lib/read.ml\"\n | 1 ->\n\n# 409 \"lib/read.mll\"\n \n# 409 \"lib/read.mll\"\n ( long_error \"Unterminated comment\" v lexbuf )\n\n# 1589 \"lib/read.ml\"\n\n \n# 1590 \"lib/read.ml\"\n | 2 ->\n\n# 410 \"lib/read.mll\"\n \n# 410 \"lib/read.mll\"\n ( newline v lexbuf; finish_comment v lexbuf )\n\n# 1594 \"lib/read.ml\"\n\n \n# 1595 \"lib/read.ml\"\n | 3 ->\n\n# 411 \"lib/read.mll\"\n \n# 411 \"lib/read.mll\"\n ( finish_comment v lexbuf )\n\n# 1599 \"lib/read.ml\"\n\n \n# 1600 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_comment_rec v lexbuf __ocaml_lex_state\n\nand read_eof lexbuf =\n __ocaml_lex_read_eof_rec lexbuf 131\nand __ocaml_lex_read_eof_rec lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 419 \"lib/read.mll\"\n \n# 419 \"lib/read.mll\"\n ( true )\n\n# 1611 \"lib/read.ml\"\n\n \n# 1612 \"lib/read.ml\"\n | 1 ->\n\n# 420 \"lib/read.mll\"\n \n# 420 \"lib/read.mll\"\n ( false )\n\n# 1616 \"lib/read.ml\"\n\n \n# 1617 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_eof_rec lexbuf __ocaml_lex_state\n\nand read_space v lexbuf =\n __ocaml_lex_read_space_rec v lexbuf 133\nand __ocaml_lex_read_space_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 423 \"lib/read.mll\"\n \n# 423 \"lib/read.mll\"\n ( newline v lexbuf; read_space v lexbuf )\n\n# 1628 \"lib/read.ml\"\n\n \n# 1629 \"lib/read.ml\"\n | 1 ->\n\n# 424 \"lib/read.mll\"\n \n# 424 \"lib/read.mll\"\n ( finish_comment v lexbuf; read_space v lexbuf )\n\n# 1633 \"lib/read.ml\"\n\n \n# 1634 \"lib/read.ml\"\n | 2 ->\n\n# 425 \"lib/read.mll\"\n \n# 425 \"lib/read.mll\"\n ( newline v lexbuf; read_space v lexbuf )\n\n# 1638 \"lib/read.ml\"\n\n \n# 1639 \"lib/read.ml\"\n | 3 ->\n\n# 426 \"lib/read.mll\"\n \n# 426 \"lib/read.mll\"\n ( read_space v lexbuf )\n\n# 1643 \"lib/read.ml\"\n\n \n# 1644 \"lib/read.ml\"\n | 4 ->\n\n# 427 \"lib/read.mll\"\n \n# 427 \"lib/read.mll\"\n ( () )\n\n# 1648 \"lib/read.ml\"\n\n \n# 1649 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_space_rec v lexbuf __ocaml_lex_state\n\nand read_null v lexbuf =\n __ocaml_lex_read_null_rec v lexbuf 140\nand __ocaml_lex_read_null_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 430 \"lib/read.mll\"\n \n# 430 \"lib/read.mll\"\n ( () )\n\n# 1660 \"lib/read.ml\"\n\n \n# 1661 \"lib/read.ml\"\n | 1 ->\n\n# 431 \"lib/read.mll\"\n \n# 431 \"lib/read.mll\"\n ( long_error \"Expected 'null' but found\" v lexbuf )\n\n# 1665 \"lib/read.ml\"\n\n \n# 1666 \"lib/read.ml\"\n | 2 ->\n\n# 432 \"lib/read.mll\"\n \n# 432 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1670 \"lib/read.ml\"\n\n \n# 1671 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_null_rec v lexbuf __ocaml_lex_state\n\nand read_null_if_possible v lexbuf =\n __ocaml_lex_read_null_if_possible_rec v lexbuf 147\nand __ocaml_lex_read_null_if_possible_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 435 \"lib/read.mll\"\n \n# 435 \"lib/read.mll\"\n ( true )\n\n# 1682 \"lib/read.ml\"\n\n \n# 1683 \"lib/read.ml\"\n | 1 ->\n\n# 436 \"lib/read.mll\"\n \n# 436 \"lib/read.mll\"\n ( false )\n\n# 1687 \"lib/read.ml\"\n\n \n# 1688 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_null_if_possible_rec v lexbuf __ocaml_lex_state\n\nand read_bool v lexbuf =\n __ocaml_lex_read_bool_rec v lexbuf 152\nand __ocaml_lex_read_bool_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 439 \"lib/read.mll\"\n \n# 439 \"lib/read.mll\"\n ( true )\n\n# 1699 \"lib/read.ml\"\n\n \n# 1700 \"lib/read.ml\"\n | 1 ->\n\n# 440 \"lib/read.mll\"\n \n# 440 \"lib/read.mll\"\n ( false )\n\n# 1704 \"lib/read.ml\"\n\n \n# 1705 \"lib/read.ml\"\n | 2 ->\n\n# 443 \"lib/read.mll\"\n \n# 443 \"lib/read.mll\"\n ( true )\n\n# 1709 \"lib/read.ml\"\n\n \n# 1710 \"lib/read.ml\"\n | 3 ->\n\n# 444 \"lib/read.mll\"\n \n# 444 \"lib/read.mll\"\n ( false )\n\n# 1714 \"lib/read.ml\"\n\n \n# 1715 \"lib/read.ml\"\n | 4 ->\n\n# 446 \"lib/read.mll\"\n \n# 446 \"lib/read.mll\"\n ( long_error \"Expected 'true' or 'false' but found\" v lexbuf )\n\n# 1719 \"lib/read.ml\"\n\n \n# 1720 \"lib/read.ml\"\n | 5 ->\n\n# 447 \"lib/read.mll\"\n \n# 447 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1724 \"lib/read.ml\"\n\n \n# 1725 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_bool_rec v lexbuf __ocaml_lex_state\n\nand read_int v lexbuf =\n __ocaml_lex_read_int_rec v lexbuf 176\nand __ocaml_lex_read_int_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 450 \"lib/read.mll\"\n \n# 450 \"lib/read.mll\"\n ( try extract_positive_int lexbuf\n with Int_overflow ->\n lexer_error \"Int overflow\" v lexbuf )\n\n# 1738 \"lib/read.ml\"\n\n \n# 1739 \"lib/read.ml\"\n | 1 ->\n\n# 453 \"lib/read.mll\"\n \n# 453 \"lib/read.mll\"\n ( try extract_negative_int lexbuf\n with Int_overflow ->\n lexer_error \"Int overflow\" v lexbuf )\n\n# 1745 \"lib/read.ml\"\n\n \n# 1746 \"lib/read.ml\"\n | 2 ->\n\n# 456 \"lib/read.mll\"\n \n# 456 \"lib/read.mll\"\n ( (* Support for double-quoted \"ints\" *)\n Bi_outbuf.clear v.buf;\n let s = finish_string v lexbuf in\n try\n (* Any OCaml-compliant int will pass,\n including hexadecimal and octal notations,\n and embedded underscores *)\n int_of_string s\n with _ ->\n custom_error\n \"Expected an integer but found a string that \\\n doesn't even represent an integer\"\n v lexbuf\n )\n\n# 1763 \"lib/read.ml\"\n\n \n# 1764 \"lib/read.ml\"\n | 3 ->\n\n# 470 \"lib/read.mll\"\n \n# 470 \"lib/read.mll\"\n ( long_error \"Expected integer but found\" v lexbuf )\n\n# 1768 \"lib/read.ml\"\n\n \n# 1769 \"lib/read.ml\"\n | 4 ->\n\n# 471 \"lib/read.mll\"\n \n# 471 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1773 \"lib/read.ml\"\n\n \n# 1774 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_int_rec v lexbuf __ocaml_lex_state\n\nand read_int32 v lexbuf =\n __ocaml_lex_read_int32_rec v lexbuf 185\nand __ocaml_lex_read_int32_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 474 \"lib/read.mll\"\n \n# 474 \"lib/read.mll\"\n ( try Int32.of_string (Lexing.lexeme lexbuf)\n with _ ->\n lexer_error \"Int32 overflow\" v lexbuf )\n\n# 1787 \"lib/read.ml\"\n\n \n# 1788 \"lib/read.ml\"\n | 1 ->\n\n# 477 \"lib/read.mll\"\n \n# 477 \"lib/read.mll\"\n ( (* Support for double-quoted \"ints\" *)\n Bi_outbuf.clear v.buf;\n let s = finish_string v lexbuf in\n try\n (* Any OCaml-compliant int will pass,\n including hexadecimal and octal notations,\n and embedded underscores *)\n Int32.of_string s\n with _ ->\n custom_error\n \"Expected an int32 but found a string that \\\n doesn't even represent an integer\"\n v lexbuf\n )\n\n# 1805 \"lib/read.ml\"\n\n \n# 1806 \"lib/read.ml\"\n | 2 ->\n\n# 491 \"lib/read.mll\"\n \n# 491 \"lib/read.mll\"\n ( long_error \"Expected int32 but found\" v lexbuf )\n\n# 1810 \"lib/read.ml\"\n\n \n# 1811 \"lib/read.ml\"\n | 3 ->\n\n# 492 \"lib/read.mll\"\n \n# 492 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1815 \"lib/read.ml\"\n\n \n# 1816 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_int32_rec v lexbuf __ocaml_lex_state\n\nand read_int64 v lexbuf =\n __ocaml_lex_read_int64_rec v lexbuf 192\nand __ocaml_lex_read_int64_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 495 \"lib/read.mll\"\n \n# 495 \"lib/read.mll\"\n ( try Int64.of_string (Lexing.lexeme lexbuf)\n with _ ->\n lexer_error \"Int32 overflow\" v lexbuf )\n\n# 1829 \"lib/read.ml\"\n\n \n# 1830 \"lib/read.ml\"\n | 1 ->\n\n# 498 \"lib/read.mll\"\n \n# 498 \"lib/read.mll\"\n ( (* Support for double-quoted \"ints\" *)\n Bi_outbuf.clear v.buf;\n let s = finish_string v lexbuf in\n try\n (* Any OCaml-compliant int will pass,\n including hexadecimal and octal notations,\n and embedded underscores *)\n Int64.of_string s\n with _ ->\n custom_error\n \"Expected an int64 but found a string that \\\n doesn't even represent an integer\"\n v lexbuf\n )\n\n# 1847 \"lib/read.ml\"\n\n \n# 1848 \"lib/read.ml\"\n | 2 ->\n\n# 512 \"lib/read.mll\"\n \n# 512 \"lib/read.mll\"\n ( long_error \"Expected int64 but found\" v lexbuf )\n\n# 1852 \"lib/read.ml\"\n\n \n# 1853 \"lib/read.ml\"\n | 3 ->\n\n# 513 \"lib/read.mll\"\n \n# 513 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1857 \"lib/read.ml\"\n\n \n# 1858 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_int64_rec v lexbuf __ocaml_lex_state\n\nand read_number v lexbuf =\n __ocaml_lex_read_number_rec v lexbuf 199\nand __ocaml_lex_read_number_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 516 \"lib/read.mll\"\n \n# 516 \"lib/read.mll\"\n ( nan )\n\n# 1869 \"lib/read.ml\"\n\n \n# 1870 \"lib/read.ml\"\n | 1 ->\n\n# 517 \"lib/read.mll\"\n \n# 517 \"lib/read.mll\"\n ( infinity )\n\n# 1874 \"lib/read.ml\"\n\n \n# 1875 \"lib/read.ml\"\n | 2 ->\n\n# 518 \"lib/read.mll\"\n \n# 518 \"lib/read.mll\"\n ( neg_infinity )\n\n# 1879 \"lib/read.ml\"\n\n \n# 1880 \"lib/read.ml\"\n | 3 ->\n\n# 519 \"lib/read.mll\"\n \n# 519 \"lib/read.mll\"\n ( float_of_string (lexeme lexbuf) )\n\n# 1884 \"lib/read.ml\"\n\n \n# 1885 \"lib/read.ml\"\n | 4 ->\n\n# 520 \"lib/read.mll\"\n \n# 520 \"lib/read.mll\"\n ( Bi_outbuf.clear v.buf;\n let s = finish_string v lexbuf in\n try\n (* Any OCaml-compliant float will pass,\n including hexadecimal and octal notations,\n and embedded underscores. *)\n float_of_string s\n with _ ->\n match s with\n \"NaN\" -> nan\n | \"Infinity\" -> infinity\n | \"-Infinity\" -> neg_infinity\n | _ ->\n custom_error\n \"Expected a number but found a string that \\\n doesn't even represent a number\"\n v lexbuf\n )\n\n# 1906 \"lib/read.ml\"\n\n \n# 1907 \"lib/read.ml\"\n | 5 ->\n\n# 538 \"lib/read.mll\"\n \n# 538 \"lib/read.mll\"\n ( long_error \"Expected number but found\" v lexbuf )\n\n# 1911 \"lib/read.ml\"\n\n \n# 1912 \"lib/read.ml\"\n | 6 ->\n\n# 539 \"lib/read.mll\"\n \n# 539 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1916 \"lib/read.ml\"\n\n \n# 1917 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_number_rec v lexbuf __ocaml_lex_state\n\nand read_string v lexbuf =\n __ocaml_lex_read_string_rec v lexbuf 233\nand __ocaml_lex_read_string_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 542 \"lib/read.mll\"\n \n# 542 \"lib/read.mll\"\n ( Bi_outbuf.clear v.buf;\n finish_string v lexbuf )\n\n# 1929 \"lib/read.ml\"\n\n \n# 1930 \"lib/read.ml\"\n | 1 ->\n\n# 544 \"lib/read.mll\"\n \n# 544 \"lib/read.mll\"\n ( long_error \"Expected '\\\"' but found\" v lexbuf )\n\n# 1934 \"lib/read.ml\"\n\n \n# 1935 \"lib/read.ml\"\n | 2 ->\n\n# 545 \"lib/read.mll\"\n \n# 545 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1939 \"lib/read.ml\"\n\n \n# 1940 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_string_rec v lexbuf __ocaml_lex_state\n\nand read_ident v lexbuf =\n __ocaml_lex_read_ident_rec v lexbuf 237\nand __ocaml_lex_read_ident_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 548 \"lib/read.mll\"\n \n# 548 \"lib/read.mll\"\n ( Bi_outbuf.clear v.buf;\n finish_string v lexbuf )\n\n# 1952 \"lib/read.ml\"\n\n \n# 1953 \"lib/read.ml\"\n | 1 ->\nlet\n\n# 550 \"lib/read.mll\"\n \n# 550 \"lib/read.mll\"\n s\n\n# 1958 \"lib/read.ml\"\n# 1958 \"lib/read.ml\"\n= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos lexbuf.Lexing.lex_curr_pos in\n\n# 551 \"lib/read.mll\"\n \n# 551 \"lib/read.mll\"\n ( s )\n\n# 1962 \"lib/read.ml\"\n\n \n# 1963 \"lib/read.ml\"\n | 2 ->\n\n# 552 \"lib/read.mll\"\n \n# 552 \"lib/read.mll\"\n ( long_error \"Expected string or identifier but found\" v lexbuf )\n\n# 1967 \"lib/read.ml\"\n\n \n# 1968 \"lib/read.ml\"\n | 3 ->\n\n# 553 \"lib/read.mll\"\n \n# 553 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1972 \"lib/read.ml\"\n\n \n# 1973 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_ident_rec v lexbuf __ocaml_lex_state\n\nand map_ident v f lexbuf =\n __ocaml_lex_map_ident_rec v f lexbuf 242\nand __ocaml_lex_map_ident_rec v f lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 556 \"lib/read.mll\"\n \n# 556 \"lib/read.mll\"\n ( Bi_outbuf.clear v.buf;\n map_string v f lexbuf )\n\n# 1985 \"lib/read.ml\"\n\n \n# 1986 \"lib/read.ml\"\n | 1 ->\n\n# 559 \"lib/read.mll\"\n \n# 559 \"lib/read.mll\"\n ( map_lexeme f lexbuf )\n\n# 1990 \"lib/read.ml\"\n\n \n# 1991 \"lib/read.ml\"\n | 2 ->\n\n# 560 \"lib/read.mll\"\n \n# 560 \"lib/read.mll\"\n ( long_error \"Expected string or identifier but found\" v lexbuf )\n\n# 1995 \"lib/read.ml\"\n\n \n# 1996 \"lib/read.ml\"\n | 3 ->\n\n# 561 \"lib/read.mll\"\n \n# 561 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2000 \"lib/read.ml\"\n\n \n# 2001 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_map_ident_rec v f lexbuf __ocaml_lex_state\n\nand read_sequence read_cell init_acc v lexbuf =\n __ocaml_lex_read_sequence_rec read_cell init_acc v lexbuf 247\nand __ocaml_lex_read_sequence_rec read_cell init_acc v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 564 \"lib/read.mll\"\n \n# 564 \"lib/read.mll\"\n ( let acc = ref init_acc in\n try\n read_space v lexbuf;\n read_array_end lexbuf;\n acc := read_cell !acc v lexbuf;\n while true do\n read_space v lexbuf;\n read_array_sep v lexbuf;\n read_space v lexbuf;\n acc := read_cell !acc v lexbuf;\n done;\n assert false\n with End_of_array ->\n !acc\n )\n\n# 2026 \"lib/read.ml\"\n\n \n# 2027 \"lib/read.ml\"\n | 1 ->\n\n# 579 \"lib/read.mll\"\n \n# 579 \"lib/read.mll\"\n ( long_error \"Expected '[' but found\" v lexbuf )\n\n# 2031 \"lib/read.ml\"\n\n \n# 2032 \"lib/read.ml\"\n | 2 ->\n\n# 580 \"lib/read.mll\"\n \n# 580 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2036 \"lib/read.ml\"\n\n \n# 2037 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_sequence_rec read_cell init_acc v lexbuf __ocaml_lex_state\n\nand read_list_rev read_cell v lexbuf =\n __ocaml_lex_read_list_rev_rec read_cell v lexbuf 251\nand __ocaml_lex_read_list_rev_rec read_cell v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 583 \"lib/read.mll\"\n \n# 583 \"lib/read.mll\"\n ( let acc = ref [] in\n try\n read_space v lexbuf;\n read_array_end lexbuf;\n acc := read_cell v lexbuf :: !acc;\n while true do\n read_space v lexbuf;\n read_array_sep v lexbuf;\n read_space v lexbuf;\n acc := read_cell v lexbuf :: !acc;\n done;\n assert false\n with End_of_array ->\n !acc\n )\n\n# 2062 \"lib/read.ml\"\n\n \n# 2063 \"lib/read.ml\"\n | 1 ->\n\n# 598 \"lib/read.mll\"\n \n# 598 \"lib/read.mll\"\n ( long_error \"Expected '[' but found\" v lexbuf )\n\n# 2067 \"lib/read.ml\"\n\n \n# 2068 \"lib/read.ml\"\n | 2 ->\n\n# 599 \"lib/read.mll\"\n \n# 599 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2072 \"lib/read.ml\"\n\n \n# 2073 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_list_rev_rec read_cell v lexbuf __ocaml_lex_state\n\nand read_array_end lexbuf =\n __ocaml_lex_read_array_end_rec lexbuf 255\nand __ocaml_lex_read_array_end_rec lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 602 \"lib/read.mll\"\n \n# 602 \"lib/read.mll\"\n ( raise End_of_array )\n\n# 2084 \"lib/read.ml\"\n\n \n# 2085 \"lib/read.ml\"\n | 1 ->\n\n# 603 \"lib/read.mll\"\n \n# 603 \"lib/read.mll\"\n ( () )\n\n# 2089 \"lib/read.ml\"\n\n \n# 2090 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_array_end_rec lexbuf __ocaml_lex_state\n\nand read_array_sep v lexbuf =\n __ocaml_lex_read_array_sep_rec v lexbuf 257\nand __ocaml_lex_read_array_sep_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 606 \"lib/read.mll\"\n \n# 606 \"lib/read.mll\"\n ( () )\n\n# 2101 \"lib/read.ml\"\n\n \n# 2102 \"lib/read.ml\"\n | 1 ->\n\n# 607 \"lib/read.mll\"\n \n# 607 \"lib/read.mll\"\n ( raise End_of_array )\n\n# 2106 \"lib/read.ml\"\n\n \n# 2107 \"lib/read.ml\"\n | 2 ->\n\n# 608 \"lib/read.mll\"\n \n# 608 \"lib/read.mll\"\n ( long_error \"Expected ',' or ']' but found\" v lexbuf )\n\n# 2111 \"lib/read.ml\"\n\n \n# 2112 \"lib/read.ml\"\n | 3 ->\n\n# 609 \"lib/read.mll\"\n \n# 609 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2116 \"lib/read.ml\"\n\n \n# 2117 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_array_sep_rec v lexbuf __ocaml_lex_state\n\nand read_tuple read_cell init_acc v lexbuf =\n __ocaml_lex_read_tuple_rec read_cell init_acc v lexbuf 262\nand __ocaml_lex_read_tuple_rec read_cell init_acc v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 613 \"lib/read.mll\"\n \n# 613 \"lib/read.mll\"\n (\n \n# 615 \"lib/read.mll\"\n let pos = ref 0 in\n let acc = ref init_acc in\n try\n read_space v lexbuf;\n read_tuple_end lexbuf;\n acc := read_cell !pos !acc v lexbuf;\n incr pos;\n while true do\n read_space v lexbuf;\n read_tuple_sep v lexbuf;\n read_space v lexbuf;\n acc := read_cell !pos !acc v lexbuf;\n incr pos;\n done;\n assert false\n with End_of_tuple ->\n !acc\n \n# 635 \"lib/read.mll\"\n )\n\n# 2150 \"lib/read.ml\"\n\n \n# 2151 \"lib/read.ml\"\n | 1 ->\n\n# 636 \"lib/read.mll\"\n \n# 636 \"lib/read.mll\"\n ( long_error \"Expected ')' but found\" v lexbuf )\n\n# 2155 \"lib/read.ml\"\n\n \n# 2156 \"lib/read.ml\"\n | 2 ->\n\n# 637 \"lib/read.mll\"\n \n# 637 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2160 \"lib/read.ml\"\n\n \n# 2161 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_tuple_rec read_cell init_acc v lexbuf __ocaml_lex_state\n\nand read_tuple_end lexbuf =\n __ocaml_lex_read_tuple_end_rec lexbuf 266\nand __ocaml_lex_read_tuple_end_rec lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 640 \"lib/read.mll\"\n \n# 640 \"lib/read.mll\"\n ( raise End_of_tuple )\n\n# 2172 \"lib/read.ml\"\n\n \n# 2173 \"lib/read.ml\"\n | 1 ->\n\n# 641 \"lib/read.mll\"\n \n# 641 \"lib/read.mll\"\n ( () )\n\n# 2177 \"lib/read.ml\"\n\n \n# 2178 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_tuple_end_rec lexbuf __ocaml_lex_state\n\nand read_tuple_end2 v std lexbuf =\n __ocaml_lex_read_tuple_end2_rec v std lexbuf 268\nand __ocaml_lex_read_tuple_end2_rec v std lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 644 \"lib/read.mll\"\n \n# 644 \"lib/read.mll\"\n ( if std then\n long_error \"Expected ')' or '' but found\" v lexbuf\n else\n raise End_of_tuple )\n\n# 2192 \"lib/read.ml\"\n\n \n# 2193 \"lib/read.ml\"\n | 1 ->\n\n# 648 \"lib/read.mll\"\n \n# 648 \"lib/read.mll\"\n ( if std then\n raise End_of_tuple\n else\n long_error \"Expected ']' or '' but found\" v lexbuf )\n\n# 2200 \"lib/read.ml\"\n\n \n# 2201 \"lib/read.ml\"\n | 2 ->\n\n# 652 \"lib/read.mll\"\n \n# 652 \"lib/read.mll\"\n ( () )\n\n# 2205 \"lib/read.ml\"\n\n \n# 2206 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_tuple_end2_rec v std lexbuf __ocaml_lex_state\n\nand read_tuple_sep v lexbuf =\n __ocaml_lex_read_tuple_sep_rec v lexbuf 271\nand __ocaml_lex_read_tuple_sep_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 655 \"lib/read.mll\"\n \n# 655 \"lib/read.mll\"\n ( () )\n\n# 2217 \"lib/read.ml\"\n\n \n# 2218 \"lib/read.ml\"\n | 1 ->\n\n# 656 \"lib/read.mll\"\n \n# 656 \"lib/read.mll\"\n ( raise End_of_tuple )\n\n# 2222 \"lib/read.ml\"\n\n \n# 2223 \"lib/read.ml\"\n | 2 ->\n\n# 657 \"lib/read.mll\"\n \n# 657 \"lib/read.mll\"\n ( long_error \"Expected ',' or ')' but found\" v lexbuf )\n\n# 2227 \"lib/read.ml\"\n\n \n# 2228 \"lib/read.ml\"\n | 3 ->\n\n# 658 \"lib/read.mll\"\n \n# 658 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2232 \"lib/read.ml\"\n\n \n# 2233 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_tuple_sep_rec v lexbuf __ocaml_lex_state\n\nand read_tuple_sep2 v std lexbuf =\n __ocaml_lex_read_tuple_sep2_rec v std lexbuf 276\nand __ocaml_lex_read_tuple_sep2_rec v std lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 661 \"lib/read.mll\"\n \n# 661 \"lib/read.mll\"\n ( () )\n\n# 2244 \"lib/read.ml\"\n\n \n# 2245 \"lib/read.ml\"\n | 1 ->\n\n# 662 \"lib/read.mll\"\n \n# 662 \"lib/read.mll\"\n ( if std then\n long_error \"Expected ',' or ']' but found\" v lexbuf\n else\n raise End_of_tuple )\n\n# 2252 \"lib/read.ml\"\n\n \n# 2253 \"lib/read.ml\"\n | 2 ->\n\n# 666 \"lib/read.mll\"\n \n# 666 \"lib/read.mll\"\n ( if std then\n raise End_of_tuple\n else\n long_error \"Expected ',' or ')' but found\" v lexbuf )\n\n# 2260 \"lib/read.ml\"\n\n \n# 2261 \"lib/read.ml\"\n | 3 ->\n\n# 670 \"lib/read.mll\"\n \n# 670 \"lib/read.mll\"\n ( long_error \"Expected ',' or ')' but found\" v lexbuf )\n\n# 2265 \"lib/read.ml\"\n\n \n# 2266 \"lib/read.ml\"\n | 4 ->\n\n# 671 \"lib/read.mll\"\n \n# 671 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2270 \"lib/read.ml\"\n\n \n# 2271 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_tuple_sep2_rec v std lexbuf __ocaml_lex_state\n\nand read_abstract_fields read_key read_field init_acc v lexbuf =\n __ocaml_lex_read_abstract_fields_rec read_key read_field init_acc v lexbuf 282\nand __ocaml_lex_read_abstract_fields_rec read_key read_field init_acc v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 675 \"lib/read.mll\"\n \n# 675 \"lib/read.mll\"\n ( let acc = ref init_acc in\n try\n read_space v lexbuf;\n read_object_end lexbuf;\n let field_name = read_key v lexbuf in\n read_space v lexbuf;\n read_colon v lexbuf;\n read_space v lexbuf;\n acc := read_field !acc field_name v lexbuf;\n while true do\n read_space v lexbuf;\n read_object_sep v lexbuf;\n read_space v lexbuf;\n let field_name = read_key v lexbuf in\n read_space v lexbuf;\n read_colon v lexbuf;\n read_space v lexbuf;\n acc := read_field !acc field_name v lexbuf;\n done;\n assert false\n with End_of_object ->\n !acc\n )\n\n# 2304 \"lib/read.ml\"\n\n \n# 2305 \"lib/read.ml\"\n | 1 ->\n\n# 698 \"lib/read.mll\"\n \n# 698 \"lib/read.mll\"\n ( long_error \"Expected '{' but found\" v lexbuf )\n\n# 2309 \"lib/read.ml\"\n\n \n# 2310 \"lib/read.ml\"\n | 2 ->\n\n# 699 \"lib/read.mll\"\n \n# 699 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2314 \"lib/read.ml\"\n\n \n# 2315 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_abstract_fields_rec read_key read_field init_acc v lexbuf __ocaml_lex_state\n\nand read_lcurl v lexbuf =\n __ocaml_lex_read_lcurl_rec v lexbuf 286\nand __ocaml_lex_read_lcurl_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 702 \"lib/read.mll\"\n \n# 702 \"lib/read.mll\"\n ( () )\n\n# 2326 \"lib/read.ml\"\n\n \n# 2327 \"lib/read.ml\"\n | 1 ->\n\n# 703 \"lib/read.mll\"\n \n# 703 \"lib/read.mll\"\n ( long_error \"Expected '{' but found\" v lexbuf )\n\n# 2331 \"lib/read.ml\"\n\n \n# 2332 \"lib/read.ml\"\n | 2 ->\n\n# 704 \"lib/read.mll\"\n \n# 704 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2336 \"lib/read.ml\"\n\n \n# 2337 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_lcurl_rec v lexbuf __ocaml_lex_state\n\nand read_object_end lexbuf =\n __ocaml_lex_read_object_end_rec lexbuf 290\nand __ocaml_lex_read_object_end_rec lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 707 \"lib/read.mll\"\n \n# 707 \"lib/read.mll\"\n ( raise End_of_object )\n\n# 2348 \"lib/read.ml\"\n\n \n# 2349 \"lib/read.ml\"\n | 1 ->\n\n# 708 \"lib/read.mll\"\n \n# 708 \"lib/read.mll\"\n ( () )\n\n# 2353 \"lib/read.ml\"\n\n \n# 2354 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_object_end_rec lexbuf __ocaml_lex_state\n\nand read_object_sep v lexbuf =\n __ocaml_lex_read_object_sep_rec v lexbuf 292\nand __ocaml_lex_read_object_sep_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 711 \"lib/read.mll\"\n \n# 711 \"lib/read.mll\"\n ( () )\n\n# 2365 \"lib/read.ml\"\n\n \n# 2366 \"lib/read.ml\"\n | 1 ->\n\n# 712 \"lib/read.mll\"\n \n# 712 \"lib/read.mll\"\n ( raise End_of_object )\n\n# 2370 \"lib/read.ml\"\n\n \n# 2371 \"lib/read.ml\"\n | 2 ->\n\n# 713 \"lib/read.mll\"\n \n# 713 \"lib/read.mll\"\n ( long_error \"Expected ',' or '}' but found\" v lexbuf )\n\n# 2375 \"lib/read.ml\"\n\n \n# 2376 \"lib/read.ml\"\n | 3 ->\n\n# 714 \"lib/read.mll\"\n \n# 714 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2380 \"lib/read.ml\"\n\n \n# 2381 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_object_sep_rec v lexbuf __ocaml_lex_state\n\nand read_colon v lexbuf =\n __ocaml_lex_read_colon_rec v lexbuf 297\nand __ocaml_lex_read_colon_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 717 \"lib/read.mll\"\n \n# 717 \"lib/read.mll\"\n ( () )\n\n# 2392 \"lib/read.ml\"\n\n \n# 2393 \"lib/read.ml\"\n | 1 ->\n\n# 718 \"lib/read.mll\"\n \n# 718 \"lib/read.mll\"\n ( long_error \"Expected ':' but found\" v lexbuf )\n\n# 2397 \"lib/read.ml\"\n\n \n# 2398 \"lib/read.ml\"\n | 2 ->\n\n# 719 \"lib/read.mll\"\n \n# 719 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2402 \"lib/read.ml\"\n\n \n# 2403 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_colon_rec v lexbuf __ocaml_lex_state\n\nand start_any_tuple v lexbuf =\n __ocaml_lex_start_any_tuple_rec v lexbuf 301\nand __ocaml_lex_start_any_tuple_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 722 \"lib/read.mll\"\n \n# 722 \"lib/read.mll\"\n ( false )\n\n# 2414 \"lib/read.ml\"\n\n \n# 2415 \"lib/read.ml\"\n | 1 ->\n\n# 723 \"lib/read.mll\"\n \n# 723 \"lib/read.mll\"\n ( true )\n\n# 2419 \"lib/read.ml\"\n\n \n# 2420 \"lib/read.ml\"\n | 2 ->\n\n# 724 \"lib/read.mll\"\n \n# 724 \"lib/read.mll\"\n ( long_error \"Expected '(' or '[' but found\" v lexbuf )\n\n# 2424 \"lib/read.ml\"\n\n \n# 2425 \"lib/read.ml\"\n | 3 ->\n\n# 725 \"lib/read.mll\"\n \n# 725 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2429 \"lib/read.ml\"\n\n \n# 2430 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_start_any_tuple_rec v lexbuf __ocaml_lex_state\n\nand read_lpar v lexbuf =\n __ocaml_lex_read_lpar_rec v lexbuf 306\nand __ocaml_lex_read_lpar_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 728 \"lib/read.mll\"\n \n# 728 \"lib/read.mll\"\n ( () )\n\n# 2441 \"lib/read.ml\"\n\n \n# 2442 \"lib/read.ml\"\n | 1 ->\n\n# 729 \"lib/read.mll\"\n \n# 729 \"lib/read.mll\"\n ( long_error \"Expected '(' but found\" v lexbuf )\n\n# 2446 \"lib/read.ml\"\n\n \n# 2447 \"lib/read.ml\"\n | 2 ->\n\n# 730 \"lib/read.mll\"\n \n# 730 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2451 \"lib/read.ml\"\n\n \n# 2452 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_lpar_rec v lexbuf __ocaml_lex_state\n\nand read_rpar v lexbuf =\n __ocaml_lex_read_rpar_rec v lexbuf 310\nand __ocaml_lex_read_rpar_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 733 \"lib/read.mll\"\n \n# 733 \"lib/read.mll\"\n ( () )\n\n# 2463 \"lib/read.ml\"\n\n \n# 2464 \"lib/read.ml\"\n | 1 ->\n\n# 734 \"lib/read.mll\"\n \n# 734 \"lib/read.mll\"\n ( long_error \"Expected ')' but found\" v lexbuf )\n\n# 2468 \"lib/read.ml\"\n\n \n# 2469 \"lib/read.ml\"\n | 2 ->\n\n# 735 \"lib/read.mll\"\n \n# 735 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2473 \"lib/read.ml\"\n\n \n# 2474 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_rpar_rec v lexbuf __ocaml_lex_state\n\nand read_lbr v lexbuf =\n __ocaml_lex_read_lbr_rec v lexbuf 314\nand __ocaml_lex_read_lbr_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 738 \"lib/read.mll\"\n \n# 738 \"lib/read.mll\"\n ( () )\n\n# 2485 \"lib/read.ml\"\n\n \n# 2486 \"lib/read.ml\"\n | 1 ->\n\n# 739 \"lib/read.mll\"\n \n# 739 \"lib/read.mll\"\n ( long_error \"Expected '[' but found\" v lexbuf )\n\n# 2490 \"lib/read.ml\"\n\n \n# 2491 \"lib/read.ml\"\n | 2 ->\n\n# 740 \"lib/read.mll\"\n \n# 740 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2495 \"lib/read.ml\"\n\n \n# 2496 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_lbr_rec v lexbuf __ocaml_lex_state\n\nand read_rbr v lexbuf =\n __ocaml_lex_read_rbr_rec v lexbuf 318\nand __ocaml_lex_read_rbr_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 743 \"lib/read.mll\"\n \n# 743 \"lib/read.mll\"\n ( () )\n\n# 2507 \"lib/read.ml\"\n\n \n# 2508 \"lib/read.ml\"\n | 1 ->\n\n# 744 \"lib/read.mll\"\n \n# 744 \"lib/read.mll\"\n ( long_error \"Expected ']' but found\" v lexbuf )\n\n# 2512 \"lib/read.ml\"\n\n \n# 2513 \"lib/read.ml\"\n | 2 ->\n\n# 745 \"lib/read.mll\"\n \n# 745 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2517 \"lib/read.ml\"\n\n \n# 2518 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_rbr_rec v lexbuf __ocaml_lex_state\n\nand skip_json v lexbuf =\n __ocaml_lex_skip_json_rec v lexbuf 322\nand __ocaml_lex_skip_json_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 751 \"lib/read.mll\"\n \n# 751 \"lib/read.mll\"\n ( () )\n\n# 2529 \"lib/read.ml\"\n\n \n# 2530 \"lib/read.ml\"\n | 1 ->\n\n# 752 \"lib/read.mll\"\n \n# 752 \"lib/read.mll\"\n ( () )\n\n# 2534 \"lib/read.ml\"\n\n \n# 2535 \"lib/read.ml\"\n | 2 ->\n\n# 753 \"lib/read.mll\"\n \n# 753 \"lib/read.mll\"\n ( () )\n\n# 2539 \"lib/read.ml\"\n\n \n# 2540 \"lib/read.ml\"\n | 3 ->\n\n# 754 \"lib/read.mll\"\n \n# 754 \"lib/read.mll\"\n ( () )\n\n# 2544 \"lib/read.ml\"\n\n \n# 2545 \"lib/read.ml\"\n | 4 ->\n\n# 755 \"lib/read.mll\"\n \n# 755 \"lib/read.mll\"\n ( () )\n\n# 2549 \"lib/read.ml\"\n\n \n# 2550 \"lib/read.ml\"\n | 5 ->\n\n# 756 \"lib/read.mll\"\n \n# 756 \"lib/read.mll\"\n ( () )\n\n# 2554 \"lib/read.ml\"\n\n \n# 2555 \"lib/read.ml\"\n | 6 ->\n\n# 757 \"lib/read.mll\"\n \n# 757 \"lib/read.mll\"\n ( finish_skip_stringlit v lexbuf )\n\n# 2559 \"lib/read.ml\"\n\n \n# 2560 \"lib/read.ml\"\n | 7 ->\n\n# 758 \"lib/read.mll\"\n \n# 758 \"lib/read.mll\"\n ( () )\n\n# 2564 \"lib/read.ml\"\n\n \n# 2565 \"lib/read.ml\"\n | 8 ->\n\n# 759 \"lib/read.mll\"\n \n# 759 \"lib/read.mll\"\n ( () )\n\n# 2569 \"lib/read.ml\"\n\n \n# 2570 \"lib/read.ml\"\n | 9 ->\n\n# 761 \"lib/read.mll\"\n \n# 761 \"lib/read.mll\"\n ( try\n read_space v lexbuf;\n read_object_end lexbuf;\n skip_ident v lexbuf;\n read_space v lexbuf;\n read_colon v lexbuf;\n read_space v lexbuf;\n skip_json v lexbuf;\n while true do\n read_space v lexbuf;\n read_object_sep v lexbuf;\n read_space v lexbuf;\n skip_ident v lexbuf;\n read_space v lexbuf;\n read_colon v lexbuf;\n read_space v lexbuf;\n skip_json v lexbuf;\n done;\n assert false\n with End_of_object ->\n ()\n )\n\n# 2595 \"lib/read.ml\"\n\n \n# 2596 \"lib/read.ml\"\n | 10 ->\n\n# 784 \"lib/read.mll\"\n \n# 784 \"lib/read.mll\"\n ( try\n read_space v lexbuf;\n read_array_end lexbuf;\n skip_json v lexbuf;\n while true do\n read_space v lexbuf;\n read_array_sep v lexbuf;\n read_space v lexbuf;\n skip_json v lexbuf;\n done;\n assert false\n with End_of_array ->\n ()\n )\n\n# 2613 \"lib/read.ml\"\n\n \n# 2614 \"lib/read.ml\"\n | 11 ->\n\n# 799 \"lib/read.mll\"\n \n# 799 \"lib/read.mll\"\n (\n \n# 801 \"lib/read.mll\"\n try\n read_space v lexbuf;\n read_tuple_end lexbuf;\n skip_json v lexbuf;\n while true do\n read_space v lexbuf;\n read_tuple_sep v lexbuf;\n read_space v lexbuf;\n skip_json v lexbuf;\n done;\n assert false\n with End_of_tuple ->\n ()\n \n# 817 \"lib/read.mll\"\n )\n\n# 2636 \"lib/read.ml\"\n\n \n# 2637 \"lib/read.ml\"\n | 12 ->\n\n# 819 \"lib/read.mll\"\n \n# 819 \"lib/read.mll\"\n (\n \n# 821 \"lib/read.mll\"\n read_space v lexbuf;\n skip_ident v lexbuf;\n read_space v lexbuf;\n finish_skip_variant v lexbuf\n \n# 828 \"lib/read.mll\"\n )\n\n# 2650 \"lib/read.ml\"\n\n \n# 2651 \"lib/read.ml\"\n | 13 ->\n\n# 830 \"lib/read.mll\"\n \n# 830 \"lib/read.mll\"\n ( skip_json v lexbuf )\n\n# 2655 \"lib/read.ml\"\n\n \n# 2656 \"lib/read.ml\"\n | 14 ->\n\n# 831 \"lib/read.mll\"\n \n# 831 \"lib/read.mll\"\n ( finish_comment v lexbuf; skip_json v lexbuf )\n\n# 2660 \"lib/read.ml\"\n\n \n# 2661 \"lib/read.ml\"\n | 15 ->\n\n# 832 \"lib/read.mll\"\n \n# 832 \"lib/read.mll\"\n ( newline v lexbuf; skip_json v lexbuf )\n\n# 2665 \"lib/read.ml\"\n\n \n# 2666 \"lib/read.ml\"\n | 16 ->\n\n# 833 \"lib/read.mll\"\n \n# 833 \"lib/read.mll\"\n ( skip_json v lexbuf )\n\n# 2670 \"lib/read.ml\"\n\n \n# 2671 \"lib/read.ml\"\n | 17 ->\n\n# 834 \"lib/read.mll\"\n \n# 834 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2675 \"lib/read.ml\"\n\n \n# 2676 \"lib/read.ml\"\n | 18 ->\n\n# 835 \"lib/read.mll\"\n \n# 835 \"lib/read.mll\"\n ( long_error \"Invalid token\" v lexbuf )\n\n# 2680 \"lib/read.ml\"\n\n \n# 2681 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_skip_json_rec v lexbuf __ocaml_lex_state\n\nand finish_skip_stringlit v lexbuf =\n __ocaml_lex_finish_skip_stringlit_rec v lexbuf 378\nand __ocaml_lex_finish_skip_stringlit_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 841 \"lib/read.mll\"\n \n# 841 \"lib/read.mll\"\n ( () )\n\n# 2692 \"lib/read.ml\"\n\n \n# 2693 \"lib/read.ml\"\n | 1 ->\n\n# 842 \"lib/read.mll\"\n \n# 842 \"lib/read.mll\"\n ( long_error \"Invalid string literal\" v lexbuf )\n\n# 2697 \"lib/read.ml\"\n\n \n# 2698 \"lib/read.ml\"\n | 2 ->\n\n# 843 \"lib/read.mll\"\n \n# 843 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2702 \"lib/read.ml\"\n\n \n# 2703 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_skip_stringlit_rec v lexbuf __ocaml_lex_state\n\nand finish_skip_variant v lexbuf =\n __ocaml_lex_finish_skip_variant_rec v lexbuf 389\nand __ocaml_lex_finish_skip_variant_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 846 \"lib/read.mll\"\n \n# 846 \"lib/read.mll\"\n ( skip_json v lexbuf;\n read_space v lexbuf;\n read_gt v lexbuf )\n\n# 2716 \"lib/read.ml\"\n\n \n# 2717 \"lib/read.ml\"\n | 1 ->\n\n# 849 \"lib/read.mll\"\n \n# 849 \"lib/read.mll\"\n ( () )\n\n# 2721 \"lib/read.ml\"\n\n \n# 2722 \"lib/read.ml\"\n | 2 ->\n\n# 850 \"lib/read.mll\"\n \n# 850 \"lib/read.mll\"\n ( long_error \"Expected ':' or '>' but found\" v lexbuf )\n\n# 2726 \"lib/read.ml\"\n\n \n# 2727 \"lib/read.ml\"\n | 3 ->\n\n# 851 \"lib/read.mll\"\n \n# 851 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2731 \"lib/read.ml\"\n\n \n# 2732 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_skip_variant_rec v lexbuf __ocaml_lex_state\n\nand skip_ident v lexbuf =\n __ocaml_lex_skip_ident_rec v lexbuf 394\nand __ocaml_lex_skip_ident_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 854 \"lib/read.mll\"\n \n# 854 \"lib/read.mll\"\n ( finish_skip_stringlit v lexbuf )\n\n# 2743 \"lib/read.ml\"\n\n \n# 2744 \"lib/read.ml\"\n | 1 ->\n\n# 855 \"lib/read.mll\"\n \n# 855 \"lib/read.mll\"\n ( () )\n\n# 2748 \"lib/read.ml\"\n\n \n# 2749 \"lib/read.ml\"\n | 2 ->\n\n# 856 \"lib/read.mll\"\n \n# 856 \"lib/read.mll\"\n ( long_error \"Expected string or identifier but found\" v lexbuf )\n\n# 2753 \"lib/read.ml\"\n\n \n# 2754 \"lib/read.ml\"\n | 3 ->\n\n# 857 \"lib/read.mll\"\n \n# 857 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2758 \"lib/read.ml\"\n\n \n# 2759 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_skip_ident_rec v lexbuf __ocaml_lex_state\n\nand buffer_json v lexbuf =\n __ocaml_lex_buffer_json_rec v lexbuf 399\nand __ocaml_lex_buffer_json_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 870 \"lib/read.mll\"\n \n# 870 \"lib/read.mll\"\n ( add_lexeme v.buf lexbuf )\n\n# 2770 \"lib/read.ml\"\n\n \n# 2771 \"lib/read.ml\"\n | 1 ->\n\n# 872 \"lib/read.mll\"\n \n# 872 \"lib/read.mll\"\n ( finish_buffer_stringlit v lexbuf )\n\n# 2775 \"lib/read.ml\"\n\n \n# 2776 \"lib/read.ml\"\n | 2 ->\n\n# 873 \"lib/read.mll\"\n \n# 873 \"lib/read.mll\"\n ( try\n Bi_outbuf.add_char v.buf '{';\n buffer_space v lexbuf;\n buffer_object_end v lexbuf;\n buffer_ident v lexbuf;\n buffer_space v lexbuf;\n buffer_colon v lexbuf;\n buffer_space v lexbuf;\n buffer_json v lexbuf;\n while true do\n buffer_space v lexbuf;\n buffer_object_sep v lexbuf;\n buffer_space v lexbuf;\n buffer_ident v lexbuf;\n buffer_space v lexbuf;\n buffer_colon v lexbuf;\n buffer_space v lexbuf;\n buffer_json v lexbuf;\n done;\n assert false\n with End_of_object ->\n ()\n )\n\n# 2802 \"lib/read.ml\"\n\n \n# 2803 \"lib/read.ml\"\n | 3 ->\n\n# 897 \"lib/read.mll\"\n \n# 897 \"lib/read.mll\"\n ( try\n Bi_outbuf.add_char v.buf '[';\n buffer_space v lexbuf;\n buffer_array_end v lexbuf;\n buffer_json v lexbuf;\n while true do\n buffer_space v lexbuf;\n buffer_array_sep v lexbuf;\n buffer_space v lexbuf;\n buffer_json v lexbuf;\n done;\n assert false\n with End_of_array ->\n ()\n )\n\n# 2821 \"lib/read.ml\"\n\n \n# 2822 \"lib/read.ml\"\n | 4 ->\n\n# 913 \"lib/read.mll\"\n \n# 913 \"lib/read.mll\"\n (\n \n# 915 \"lib/read.mll\"\n try\n Bi_outbuf.add_char v.buf '(';\n buffer_space v lexbuf;\n buffer_tuple_end v lexbuf;\n buffer_json v lexbuf;\n while true do\n buffer_space v lexbuf;\n buffer_tuple_sep v lexbuf;\n buffer_space v lexbuf;\n buffer_json v lexbuf;\n done;\n assert false\n with End_of_tuple ->\n ()\n \n# 932 \"lib/read.mll\"\n )\n\n# 2845 \"lib/read.ml\"\n\n \n# 2846 \"lib/read.ml\"\n | 5 ->\n\n# 934 \"lib/read.mll\"\n \n# 934 \"lib/read.mll\"\n (\n \n# 936 \"lib/read.mll\"\n Bi_outbuf.add_char v.buf '<';\n buffer_space v lexbuf;\n buffer_ident v lexbuf;\n buffer_space v lexbuf;\n finish_buffer_variant v lexbuf\n \n# 944 \"lib/read.mll\"\n )\n\n# 2860 \"lib/read.ml\"\n\n \n# 2861 \"lib/read.ml\"\n | 6 ->\n\n# 946 \"lib/read.mll\"\n \n# 946 \"lib/read.mll\"\n ( add_lexeme v.buf lexbuf; buffer_json v lexbuf )\n\n# 2865 \"lib/read.ml\"\n\n \n# 2866 \"lib/read.ml\"\n | 7 ->\n\n# 947 \"lib/read.mll\"\n \n# 947 \"lib/read.mll\"\n ( Bi_outbuf.add_string v.buf \"/*\";\n finish_buffer_comment v lexbuf;\n buffer_json v lexbuf )\n\n# 2872 \"lib/read.ml\"\n\n \n# 2873 \"lib/read.ml\"\n | 8 ->\n\n# 950 \"lib/read.mll\"\n \n# 950 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\\n';\n newline v lexbuf;\n buffer_json v lexbuf )\n\n# 2879 \"lib/read.ml\"\n\n \n# 2880 \"lib/read.ml\"\n | 9 ->\n\n# 953 \"lib/read.mll\"\n \n# 953 \"lib/read.mll\"\n ( add_lexeme v.buf lexbuf; buffer_json v lexbuf )\n\n# 2884 \"lib/read.ml\"\n\n \n# 2885 \"lib/read.ml\"\n | 10 ->\n\n# 954 \"lib/read.mll\"\n \n# 954 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2889 \"lib/read.ml\"\n\n \n# 2890 \"lib/read.ml\"\n | 11 ->\n\n# 955 \"lib/read.mll\"\n \n# 955 \"lib/read.mll\"\n ( long_error \"Invalid token\" v lexbuf )\n\n# 2894 \"lib/read.ml\"\n\n \n# 2895 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_json_rec v lexbuf __ocaml_lex_state\n\nand finish_buffer_stringlit v lexbuf =\n __ocaml_lex_finish_buffer_stringlit_rec v lexbuf 450\nand __ocaml_lex_finish_buffer_stringlit_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 961 \"lib/read.mll\"\n \n# 961 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\"';\n add_lexeme v.buf lexbuf\n )\n\n# 2908 \"lib/read.ml\"\n\n \n# 2909 \"lib/read.ml\"\n | 1 ->\n\n# 964 \"lib/read.mll\"\n \n# 964 \"lib/read.mll\"\n ( long_error \"Invalid string literal\" v lexbuf )\n\n# 2913 \"lib/read.ml\"\n\n \n# 2914 \"lib/read.ml\"\n | 2 ->\n\n# 965 \"lib/read.mll\"\n \n# 965 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2918 \"lib/read.ml\"\n\n \n# 2919 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_buffer_stringlit_rec v lexbuf __ocaml_lex_state\n\nand finish_buffer_variant v lexbuf =\n __ocaml_lex_finish_buffer_variant_rec v lexbuf 461\nand __ocaml_lex_finish_buffer_variant_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 968 \"lib/read.mll\"\n \n# 968 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf ':';\n buffer_json v lexbuf;\n buffer_space v lexbuf;\n buffer_gt v lexbuf )\n\n# 2933 \"lib/read.ml\"\n\n \n# 2934 \"lib/read.ml\"\n | 1 ->\n\n# 972 \"lib/read.mll\"\n \n# 972 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '>' )\n\n# 2938 \"lib/read.ml\"\n\n \n# 2939 \"lib/read.ml\"\n | 2 ->\n\n# 973 \"lib/read.mll\"\n \n# 973 \"lib/read.mll\"\n ( long_error \"Expected ':' or '>' but found\" v lexbuf )\n\n# 2943 \"lib/read.ml\"\n\n \n# 2944 \"lib/read.ml\"\n | 3 ->\n\n# 974 \"lib/read.mll\"\n \n# 974 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2948 \"lib/read.ml\"\n\n \n# 2949 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_buffer_variant_rec v lexbuf __ocaml_lex_state\n\nand buffer_ident v lexbuf =\n __ocaml_lex_buffer_ident_rec v lexbuf 466\nand __ocaml_lex_buffer_ident_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 977 \"lib/read.mll\"\n \n# 977 \"lib/read.mll\"\n ( finish_buffer_stringlit v lexbuf )\n\n# 2960 \"lib/read.ml\"\n\n \n# 2961 \"lib/read.ml\"\n | 1 ->\n\n# 978 \"lib/read.mll\"\n \n# 978 \"lib/read.mll\"\n ( add_lexeme v.buf lexbuf )\n\n# 2965 \"lib/read.ml\"\n\n \n# 2966 \"lib/read.ml\"\n | 2 ->\n\n# 979 \"lib/read.mll\"\n \n# 979 \"lib/read.mll\"\n ( long_error \"Expected string or identifier but found\" v lexbuf )\n\n# 2970 \"lib/read.ml\"\n\n \n# 2971 \"lib/read.ml\"\n | 3 ->\n\n# 980 \"lib/read.mll\"\n \n# 980 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2975 \"lib/read.ml\"\n\n \n# 2976 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_ident_rec v lexbuf __ocaml_lex_state\n\nand buffer_space v lexbuf =\n __ocaml_lex_buffer_space_rec v lexbuf 471\nand __ocaml_lex_buffer_space_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 983 \"lib/read.mll\"\n \n# 983 \"lib/read.mll\"\n (\n add_lexeme v.buf lexbuf;\n newline v lexbuf;\n buffer_space v lexbuf )\n\n# 2990 \"lib/read.ml\"\n\n \n# 2991 \"lib/read.ml\"\n | 1 ->\n\n# 987 \"lib/read.mll\"\n \n# 987 \"lib/read.mll\"\n (\n Bi_outbuf.add_string v.buf \"/*\";\n finish_buffer_comment v lexbuf;\n buffer_space v lexbuf )\n\n# 2998 \"lib/read.ml\"\n\n \n# 2999 \"lib/read.ml\"\n | 2 ->\n\n# 991 \"lib/read.mll\"\n \n# 991 \"lib/read.mll\"\n (\n Bi_outbuf.add_char v.buf '\\n';\n newline v lexbuf;\n buffer_space v lexbuf )\n\n# 3006 \"lib/read.ml\"\n\n \n# 3007 \"lib/read.ml\"\n | 3 ->\n\n# 995 \"lib/read.mll\"\n \n# 995 \"lib/read.mll\"\n (\n add_lexeme v.buf lexbuf;\n buffer_space v lexbuf )\n\n# 3013 \"lib/read.ml\"\n\n \n# 3014 \"lib/read.ml\"\n | 4 ->\n\n# 998 \"lib/read.mll\"\n \n# 998 \"lib/read.mll\"\n ( () )\n\n# 3018 \"lib/read.ml\"\n\n \n# 3019 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_space_rec v lexbuf __ocaml_lex_state\n\nand buffer_object_end v lexbuf =\n __ocaml_lex_buffer_object_end_rec v lexbuf 478\nand __ocaml_lex_buffer_object_end_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1001 \"lib/read.mll\"\n \n# 1001 \"lib/read.mll\"\n (\n Bi_outbuf.add_char v.buf '}';\n raise End_of_object )\n\n# 3032 \"lib/read.ml\"\n\n \n# 3033 \"lib/read.ml\"\n | 1 ->\n\n# 1004 \"lib/read.mll\"\n \n# 1004 \"lib/read.mll\"\n ( () )\n\n# 3037 \"lib/read.ml\"\n\n \n# 3038 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_object_end_rec v lexbuf __ocaml_lex_state\n\nand buffer_object_sep v lexbuf =\n __ocaml_lex_buffer_object_sep_rec v lexbuf 480\nand __ocaml_lex_buffer_object_sep_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1007 \"lib/read.mll\"\n \n# 1007 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf ',' )\n\n# 3049 \"lib/read.ml\"\n\n \n# 3050 \"lib/read.ml\"\n | 1 ->\n\n# 1008 \"lib/read.mll\"\n \n# 1008 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '}'; raise End_of_object )\n\n# 3054 \"lib/read.ml\"\n\n \n# 3055 \"lib/read.ml\"\n | 2 ->\n\n# 1009 \"lib/read.mll\"\n \n# 1009 \"lib/read.mll\"\n ( long_error \"Expected ',' or '}' but found\" v lexbuf )\n\n# 3059 \"lib/read.ml\"\n\n \n# 3060 \"lib/read.ml\"\n | 3 ->\n\n# 1010 \"lib/read.mll\"\n \n# 1010 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 3064 \"lib/read.ml\"\n\n \n# 3065 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_object_sep_rec v lexbuf __ocaml_lex_state\n\nand buffer_array_end v lexbuf =\n __ocaml_lex_buffer_array_end_rec v lexbuf 485\nand __ocaml_lex_buffer_array_end_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1013 \"lib/read.mll\"\n \n# 1013 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf ']'; raise End_of_array )\n\n# 3076 \"lib/read.ml\"\n\n \n# 3077 \"lib/read.ml\"\n | 1 ->\n\n# 1014 \"lib/read.mll\"\n \n# 1014 \"lib/read.mll\"\n ( () )\n\n# 3081 \"lib/read.ml\"\n\n \n# 3082 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_array_end_rec v lexbuf __ocaml_lex_state\n\nand buffer_array_sep v lexbuf =\n __ocaml_lex_buffer_array_sep_rec v lexbuf 487\nand __ocaml_lex_buffer_array_sep_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1017 \"lib/read.mll\"\n \n# 1017 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf ',' )\n\n# 3093 \"lib/read.ml\"\n\n \n# 3094 \"lib/read.ml\"\n | 1 ->\n\n# 1018 \"lib/read.mll\"\n \n# 1018 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf ']'; raise End_of_array )\n\n# 3098 \"lib/read.ml\"\n\n \n# 3099 \"lib/read.ml\"\n | 2 ->\n\n# 1019 \"lib/read.mll\"\n \n# 1019 \"lib/read.mll\"\n ( long_error \"Expected ',' or ']' but found\" v lexbuf )\n\n# 3103 \"lib/read.ml\"\n\n \n# 3104 \"lib/read.ml\"\n | 3 ->\n\n# 1020 \"lib/read.mll\"\n \n# 1020 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 3108 \"lib/read.ml\"\n\n \n# 3109 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_array_sep_rec v lexbuf __ocaml_lex_state\n\nand buffer_tuple_end v lexbuf =\n __ocaml_lex_buffer_tuple_end_rec v lexbuf 492\nand __ocaml_lex_buffer_tuple_end_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1023 \"lib/read.mll\"\n \n# 1023 \"lib/read.mll\"\n (\n Bi_outbuf.add_char v.buf ')';\n raise End_of_tuple )\n\n# 3122 \"lib/read.ml\"\n\n \n# 3123 \"lib/read.ml\"\n | 1 ->\n\n# 1026 \"lib/read.mll\"\n \n# 1026 \"lib/read.mll\"\n ( () )\n\n# 3127 \"lib/read.ml\"\n\n \n# 3128 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_tuple_end_rec v lexbuf __ocaml_lex_state\n\nand buffer_tuple_sep v lexbuf =\n __ocaml_lex_buffer_tuple_sep_rec v lexbuf 494\nand __ocaml_lex_buffer_tuple_sep_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1029 \"lib/read.mll\"\n \n# 1029 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf ',' )\n\n# 3139 \"lib/read.ml\"\n\n \n# 3140 \"lib/read.ml\"\n | 1 ->\n\n# 1030 \"lib/read.mll\"\n \n# 1030 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf ')'; raise End_of_tuple )\n\n# 3144 \"lib/read.ml\"\n\n \n# 3145 \"lib/read.ml\"\n | 2 ->\n\n# 1031 \"lib/read.mll\"\n \n# 1031 \"lib/read.mll\"\n ( long_error \"Expected ',' or ')' but found\" v lexbuf )\n\n# 3149 \"lib/read.ml\"\n\n \n# 3150 \"lib/read.ml\"\n | 3 ->\n\n# 1032 \"lib/read.mll\"\n \n# 1032 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 3154 \"lib/read.ml\"\n\n \n# 3155 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_tuple_sep_rec v lexbuf __ocaml_lex_state\n\nand buffer_colon v lexbuf =\n __ocaml_lex_buffer_colon_rec v lexbuf 499\nand __ocaml_lex_buffer_colon_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1035 \"lib/read.mll\"\n \n# 1035 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf ':' )\n\n# 3166 \"lib/read.ml\"\n\n \n# 3167 \"lib/read.ml\"\n | 1 ->\n\n# 1036 \"lib/read.mll\"\n \n# 1036 \"lib/read.mll\"\n ( long_error \"Expected ':' but found\" v lexbuf )\n\n# 3171 \"lib/read.ml\"\n\n \n# 3172 \"lib/read.ml\"\n | 2 ->\n\n# 1037 \"lib/read.mll\"\n \n# 1037 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 3176 \"lib/read.ml\"\n\n \n# 3177 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_colon_rec v lexbuf __ocaml_lex_state\n\nand buffer_gt v lexbuf =\n __ocaml_lex_buffer_gt_rec v lexbuf 503\nand __ocaml_lex_buffer_gt_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1040 \"lib/read.mll\"\n \n# 1040 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '>' )\n\n# 3188 \"lib/read.ml\"\n\n \n# 3189 \"lib/read.ml\"\n | 1 ->\n\n# 1041 \"lib/read.mll\"\n \n# 1041 \"lib/read.mll\"\n ( long_error \"Expected '>' but found\" v lexbuf )\n\n# 3193 \"lib/read.ml\"\n\n \n# 3194 \"lib/read.ml\"\n | 2 ->\n\n# 1042 \"lib/read.mll\"\n \n# 1042 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 3198 \"lib/read.ml\"\n\n \n# 3199 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_gt_rec v lexbuf __ocaml_lex_state\n\nand finish_buffer_comment v lexbuf =\n __ocaml_lex_finish_buffer_comment_rec v lexbuf 507\nand __ocaml_lex_finish_buffer_comment_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1045 \"lib/read.mll\"\n \n# 1045 \"lib/read.mll\"\n ( Bi_outbuf.add_string v.buf \"*/\" )\n\n# 3210 \"lib/read.ml\"\n\n \n# 3211 \"lib/read.ml\"\n | 1 ->\n\n# 1046 \"lib/read.mll\"\n \n# 1046 \"lib/read.mll\"\n ( long_error \"Unterminated comment\" v lexbuf )\n\n# 3215 \"lib/read.ml\"\n\n \n# 3216 \"lib/read.ml\"\n | 2 ->\n\n# 1047 \"lib/read.mll\"\n \n# 1047 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\\n';\n newline v lexbuf;\n finish_buffer_comment v lexbuf )\n\n# 3222 \"lib/read.ml\"\n\n \n# 3223 \"lib/read.ml\"\n | 3 ->\n\n# 1050 \"lib/read.mll\"\n \n# 1050 \"lib/read.mll\"\n ( add_lexeme v.buf lexbuf; finish_buffer_comment v lexbuf )\n\n# 3227 \"lib/read.ml\"\n\n \n# 3228 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_buffer_comment_rec v lexbuf __ocaml_lex_state\n\nand junk lexbuf =\n __ocaml_lex_junk_rec lexbuf 513\nand __ocaml_lex_junk_rec lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1053 \"lib/read.mll\"\n \n# 1053 \"lib/read.mll\"\n ( Lexing.lexeme lexbuf )\n\n# 3239 \"lib/read.ml\"\n\n \n# 3240 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_junk_rec lexbuf __ocaml_lex_state\n\n;;\n\n\n# 1055 \"lib/read.mll\"\n \n \n# 1056 \"lib/read.mll\"\n let _ = (read_json : lexer_state -> Lexing.lexbuf -> t)\n\n let read_t = read_json\n\n let () =\n read_junk := junk\n\n let read_int8 v lexbuf =\n let n = read_int v lexbuf in\n if n < 0 || n > 255 then\n lexer_error \"Int8 overflow\" v lexbuf\n else\n char_of_int n\n\n let read_list read_cell v lexbuf =\n List.rev (read_list_rev read_cell v lexbuf)\n\n let array_of_rev_list l =\n match l with\n [] -> [| |]\n | x :: tl ->\n let len = List.length l in\n let a = Array.make len x in\n let r = ref tl in\n for i = len - 2 downto 0 do\n a.(i) <- List.hd !r;\n r := List.tl !r\n done;\n a\n\n let read_array read_cell v lexbuf =\n let l = read_list_rev read_cell v lexbuf in\n array_of_rev_list l\n\n (* Read a JSON object, reading the keys into OCaml strings\n (provided for backward compatibility) *)\n let read_fields read_field init_acc v =\n read_abstract_fields read_ident read_field init_acc v\n\n let finish v lexbuf =\n read_space v lexbuf;\n if not (read_eof lexbuf) then\n long_error \"Junk after end of JSON value:\" v lexbuf\n\n let init_lexer = init_lexer\n\n let from_lexbuf v ?(stream = false) lexbuf =\n read_space v lexbuf;\n\n let x =\n if read_eof lexbuf then\n raise End_of_input\n else\n read_json v lexbuf\n in\n\n if not stream then\n finish v lexbuf;\n\n x\n\n\n let from_string ?buf ?fname ?lnum s =\n try\n let lexbuf = Lexing.from_string s in\n let v = init_lexer ?buf ?fname ?lnum () in\n from_lexbuf v lexbuf\n with End_of_input ->\n json_error \"Blank input data\"\n\n let from_channel ?buf ?fname ?lnum ic =\n try\n let lexbuf = Lexing.from_channel ic in\n let v = init_lexer ?buf ?fname ?lnum () in\n from_lexbuf v lexbuf\n with End_of_input ->\n json_error \"Blank input data\"\n\n let from_file ?buf ?fname ?lnum file =\n let ic = open_in file in\n try\n let x = from_channel ?buf ?fname ?lnum ic in\n close_in ic;\n x\n with e ->\n close_in_noerr ic;\n raise e\n\n exception Finally of exn * exn\n\n let stream_from_lexbuf v ?(fin = fun () -> ()) lexbuf =\n let stream = Some true in\n let f i =\n try Some (from_lexbuf v ?stream lexbuf)\n with\n End_of_input ->\n fin ();\n None\n | e ->\n (try fin () with fin_e -> raise (Finally (e, fin_e)));\n raise e\n in\n Stream.from f\n\n let stream_from_string ?buf ?fname ?lnum s =\n let v = init_lexer ?buf ?fname ?lnum () in\n stream_from_lexbuf v (Lexing.from_string s)\n\n let stream_from_channel ?buf ?fin ?fname ?lnum ic =\n let lexbuf = Lexing.from_channel ic in\n let v = init_lexer ?buf ?fname ?lnum () in\n stream_from_lexbuf v ?fin lexbuf\n\n let stream_from_file ?buf ?fname ?lnum file =\n let ic = open_in file in\n let fin () = close_in ic in\n let fname =\n match fname with\n None -> Some file\n | x -> x\n in\n let lexbuf = Lexing.from_channel ic in\n let v = init_lexer ?buf ?fname ?lnum () in\n stream_from_lexbuf v ~fin lexbuf\n\n type json_line = [ `Json of t | `Exn of exn ]\n\n let linestream_from_channel\n ?buf ?(fin = fun () -> ()) ?fname ?lnum:(lnum0 = 1) ic =\n let buf =\n match buf with\n None -> Some (Bi_outbuf.create 256)\n | Some _ -> buf\n in\n let f i =\n try\n let line = input_line ic in\n let lnum = lnum0 + i in\n Some (`Json (from_string ?buf ?fname ~lnum line))\n with\n End_of_file -> fin (); None\n | e -> Some (`Exn e)\n in\n Stream.from f\n\n let linestream_from_file ?buf ?fname ?lnum file =\n let ic = open_in file in\n let fin () = close_in ic in\n let fname =\n match fname with\n None -> Some file\n | x -> x\n in\n linestream_from_channel ?buf ~fin ?fname ?lnum ic\n\n let prettify ?std s =\n pretty_to_string ?std (from_string s)\n\n let compact ?std s =\n to_string (from_string s)\n\n let validate_json _path _value = None\n\n\n# 3411 \"lib/read.ml\"\n# 62 \"yojson.cppo.ml\"\nmodule Util =\nstruct\n# 1 \"util.ml\"\nexception Type_error of string * t\n\nlet typeof = function\n | `Assoc _ -> \"object\"\n | `Bool _ -> \"bool\"\n | `Float _ -> \"float\"\n | `Int _ -> \"int\"\n | `List _ -> \"array\"\n | `Null -> \"null\"\n | `String _ -> \"string\"\n | `Intlit _ -> \"intlit\"\n | `Tuple _ -> \"tuple\"\n | `Variant _ -> \"variant\"\n\nlet typerr msg js = raise (Type_error (msg ^ typeof js, js))\n\nexception Undefined of string * t\n\nlet ( |> ) = ( |> )\n\nlet assoc name obj =\n try List.assoc name obj\n with Not_found -> `Null\n\nlet member name = function\n | `Assoc obj -> assoc name obj\n | js -> typerr (\"Can't get member '\" ^ name ^ \"' of non-object type \") js\n\nlet index i = function\n | `List l as js ->\n let len = List.length l in\n let wrapped_index = if i < 0 then len + i else i in\n if wrapped_index < 0 || wrapped_index >= len then\n raise (Undefined (\"Index \" ^ string_of_int i ^ \" out of bounds\", js))\n else List.nth l wrapped_index\n | js -> typerr (\"Can't get index \" ^ string_of_int i\n ^ \" of non-array type \") js\n\nlet map f = function\n | `List l -> `List (List.map f l)\n | js -> typerr \"Can't map function over non-array type \" js\n\nlet to_assoc = function\n | `Assoc obj -> obj\n | js -> typerr \"Expected object, got \" js\n\nlet to_option f = function\n | `Null -> None\n | x -> Some (f x)\n\nlet to_bool = function\n | `Bool b -> b\n | js -> typerr \"Expected bool, got \" js\n\nlet to_bool_option = function\n | `Bool b -> Some b\n | `Null -> None\n | js -> typerr \"Expected bool or null, got \" js\n\nlet to_number = function\n | `Int i -> float i\n | `Float f -> f\n | js -> typerr \"Expected number, got \" js\n\nlet to_number_option = function\n | `Int i -> Some (float i)\n | `Float f -> Some f\n | `Null -> None\n | js -> typerr \"Expected number or null, got \" js\n\nlet to_float = function\n | `Float f -> f\n | js -> typerr \"Expected float, got \" js\n\nlet to_float_option = function\n | `Float f -> Some f\n | `Null -> None\n | js -> typerr \"Expected float or null, got \" js\n\nlet to_int = function\n | `Int i -> i\n | js -> typerr \"Expected int, got \" js\n\nlet to_int_option = function\n | `Int i -> Some i\n | `Null -> None\n | js -> typerr \"Expected int or null, got \" js\n\nlet to_list = function\n | `List l -> l\n | js -> typerr \"Expected array, got \" js\n\nlet to_string = function\n | `String s -> s\n | js -> typerr \"Expected string, got \" js\n\nlet to_string_option = function\n | `String s -> Some s\n | `Null -> None\n | js -> typerr \"Expected string or null, got \" js\n\nlet convert_each f = function\n | `List l -> List.map f l\n | js -> typerr \"Can't convert each element of non-array type \" js\n\n\nlet rec rev_filter_map f acc l =\n match l with\n [] -> acc\n | x :: tl ->\n match f x with\n None -> rev_filter_map f acc tl\n | Some y -> rev_filter_map f (y :: acc) tl\n\nlet filter_map f l =\n List.rev (rev_filter_map f [] l)\n\nlet rec rev_flatten acc l =\n match l with\n [] -> acc\n | x :: tl ->\n match x with\n `List l2 -> rev_flatten (List.rev_append l2 acc) tl\n | _ -> rev_flatten acc tl\n\nlet flatten l =\n List.rev (rev_flatten [] l)\n\nlet filter_index i l =\n filter_map (\n function\n `List l ->\n (try Some (List.nth l i)\n with _ -> None)\n | _ -> None\n ) l\n\nlet filter_list l =\n filter_map (\n function\n `List l -> Some l\n | _ -> None\n ) l\n\nlet filter_member k l =\n filter_map (\n function\n `Assoc l ->\n (try Some (List.assoc k l)\n with _ -> None)\n | _ -> None\n ) l\n\nlet filter_assoc l =\n filter_map (\n function\n `Assoc l -> Some l\n | _ -> None\n ) l\n\nlet filter_bool l =\n filter_map (\n function\n `Bool x -> Some x\n | _ -> None\n ) l\n\nlet filter_int l =\n filter_map (\n function\n `Int x -> Some x\n | _ -> None\n ) l\n\nlet filter_float l =\n filter_map (\n function\n `Float x -> Some x\n | _ -> None\n ) l\n\nlet filter_number l =\n filter_map (\n function\n `Int x -> Some (float x)\n | `Float x -> Some x\n | _ -> None\n ) l\n\nlet filter_string l =\n filter_map (\n function\n `String x -> Some x\n | _ -> None\n ) l\n\nlet keys o =\n to_assoc o |> List.map (fun (key, _) -> key)\n\nlet values o =\n to_assoc o |> List.map (fun (_, value) -> value)\n\nlet combine (first : t) (second : t) =\n match (first, second) with\n | (`Assoc a, `Assoc b) -> (`Assoc (a @ b) : t)\n | (a, b) -> raise (Invalid_argument \"Expected two objects, check inputs\")\n# 65 \"yojson.cppo.ml\"\nend\n# 72 \"yojson.cppo.ml\"\nend\n\nmodule Raw =\nstruct\n# 1 \"type.ml\"\n(** {3 Type of the JSON tree} *)\n\ntype t =\n [\n | `Null\n | `Bool of bool\n \n# 11 \"type.ml\"\n | `Intlit of string\n \n# 17 \"type.ml\"\n | `Floatlit of string\n \n# 23 \"type.ml\"\n | `Stringlit of string\n \n# 25 \"type.ml\"\n | `Assoc of (string * t) list\n | `List of t list\n \n# 28 \"type.ml\"\n | `Tuple of t list\n \n# 31 \"type.ml\"\n | `Variant of (string * t option)\n \n# 33 \"type.ml\"\n ]\n(**\nAll possible cases defined in Yojson:\n- `Null: JSON null\n- `Bool of bool: JSON boolean\n- `Int of int: JSON number without decimal point or exponent.\n- `Intlit of string: JSON number without decimal point or exponent,\n\t preserved as a string.\n- `Float of float: JSON number, Infinity, -Infinity or NaN.\n- `Floatlit of string: JSON number, Infinity, -Infinity or NaN,\n\t preserved as a string.\n- `String of string: JSON string. Bytes in the range 128-255 are preserved\n\t as-is without encoding validation for both reading\n\t and writing.\n- `Stringlit of string: JSON string literal including the double quotes.\n- `Assoc of (string * json) list: JSON object.\n- `List of json list: JSON array.\n- `Tuple of json list: Tuple (non-standard extension of JSON).\n\t Syntax: [(\"abc\", 123)].\n- `Variant of (string * json option): Variant (non-standard extension of JSON).\n\t Syntax: [<\"Foo\">] or [<\"Bar\":123>].\n*)\n\ntype json = t [@@deprecated \"json types are being renamed and will be removed in the next Yojson major version. Use type t instead\"]\n(**\n * Compatibility type alias for type `t`\n *)\n\n(*\n Note to adventurers: ocamldoc does not support inline comments\n on each polymorphic variant, and cppo doesn't allow to concatenate\n comments, so it would be complicated to document only the\n cases that are preserved by cppo in the type definition.\n*)\n# 1 \"write.ml\"\n(* included: type.ml *)\n\nlet hex n =\n Char.chr (\n if n < 10 then n + 48\n else n + 87\n )\n\nlet write_special src start stop ob str =\n Bi_outbuf.add_substring ob src !start (stop - !start);\n Bi_outbuf.add_string ob str;\n start := stop + 1\n\nlet write_control_char src start stop ob c =\n Bi_outbuf.add_substring ob src !start (stop - !start);\n let i = Bi_outbuf.alloc ob 6 in\n let dst = ob.o_s in\n Bytes.blit_string \"\\\\u00\" 0 dst i 4;\n Bytes.set dst (i+4) (hex (Char.code c lsr 4));\n Bytes.set dst (i+5) (hex (Char.code c land 0xf));\n start := stop + 1\n\nlet finish_string src start ob =\n try\n Bi_outbuf.add_substring ob src !start (String.length src - !start)\n with exc ->\n Printf.eprintf \"src=%S start=%i len=%i\\n%!\"\n src !start (String.length src - !start);\n raise exc\n\nlet write_string_body ob s =\n let start = ref 0 in\n for i = 0 to String.length s - 1 do\n match s.[i] with\n '\"' -> write_special s start i ob \"\\\\\\\"\"\n | '\\\\' -> write_special s start i ob \"\\\\\\\\\"\n | '\\b' -> write_special s start i ob \"\\\\b\"\n | '\\012' -> write_special s start i ob \"\\\\f\"\n | '\\n' -> write_special s start i ob \"\\\\n\"\n | '\\r' -> write_special s start i ob \"\\\\r\"\n | '\\t' -> write_special s start i ob \"\\\\t\"\n | '\\x00'..'\\x1F'\n | '\\x7F' as c -> write_control_char s start i ob c\n | _ -> ()\n done;\n finish_string s start ob\n\nlet write_string ob s =\n Bi_outbuf.add_char ob '\"';\n write_string_body ob s;\n Bi_outbuf.add_char ob '\"'\n\nlet json_string_of_string s =\n let ob = Bi_outbuf.create 10 in\n write_string ob s;\n Bi_outbuf.contents ob\n\nlet test_string () =\n let s = Bytes.create 256 in\n for i = 0 to 255 do\n Bytes.set s i (Char.chr i)\n done;\n json_string_of_string (Bytes.to_string s)\n\n\nlet write_null ob () =\n Bi_outbuf.add_string ob \"null\"\n\nlet write_bool ob x =\n Bi_outbuf.add_string ob (if x then \"true\" else \"false\")\n\n\nlet max_digits =\n max\n (String.length (string_of_int max_int))\n (String.length (string_of_int min_int))\n\nlet dec n =\n Char.chr (n + 48)\n\nlet rec write_digits s pos x =\n if x = 0 then pos\n else\n let d = x mod 10 in\n let pos = write_digits s pos (x / 10) in\n Bytes.set s pos (dec (abs d));\n pos + 1\n\nlet write_int ob x =\n Bi_outbuf.extend ob max_digits;\n if x > 0 then\n ob.o_len <- write_digits ob.o_s ob.o_len x\n else if x < 0 then (\n let s = ob.o_s in\n let pos = ob.o_len in\n Bytes.set s pos '-';\n ob.o_len <- write_digits s (pos + 1) x\n )\n else\n Bi_outbuf.add_char ob '0'\n\n\nlet json_string_of_int i =\n string_of_int i\n\n\n(*\n Ensure that the float is not printed as an int.\n This is not required by JSON, but useful in order to guarantee\n reversibility.\n*)\nlet float_needs_period s =\n try\n for i = 0 to String.length s - 1 do\n match s.[i] with\n '0'..'9' | '-' -> ()\n | _ -> raise Exit\n done;\n true\n with Exit ->\n false\n\n(*\n Both write_float_fast and write_float guarantee\n that a sufficient number of digits are printed in order to\n allow reversibility.\n\n The _fast version is faster but often produces unnecessarily long numbers.\n*)\nlet write_float_fast ob x =\n match classify_float x with\n FP_nan ->\n Bi_outbuf.add_string ob \"NaN\"\n | FP_infinite ->\n Bi_outbuf.add_string ob (if x > 0. then \"Infinity\" else \"-Infinity\")\n | _ ->\n let s = Printf.sprintf \"%.17g\" x in\n Bi_outbuf.add_string ob s;\n if float_needs_period s then\n Bi_outbuf.add_string ob \".0\"\n\nlet write_float ob x =\n match classify_float x with\n FP_nan ->\n Bi_outbuf.add_string ob \"NaN\"\n | FP_infinite ->\n Bi_outbuf.add_string ob (if x > 0. then \"Infinity\" else \"-Infinity\")\n | _ ->\n let s1 = Printf.sprintf \"%.16g\" x in\n let s =\n if float_of_string s1 = x then s1\n else Printf.sprintf \"%.17g\" x\n in\n Bi_outbuf.add_string ob s;\n if float_needs_period s then\n Bi_outbuf.add_string ob \".0\"\n\nlet write_normal_float_prec significant_figures ob x =\n let open Printf in\n let s =\n match significant_figures with\n 1 -> sprintf \"%.1g\" x\n | 2 -> sprintf \"%.2g\" x\n | 3 -> sprintf \"%.3g\" x\n | 4 -> sprintf \"%.4g\" x\n | 5 -> sprintf \"%.5g\" x\n | 6 -> sprintf \"%.6g\" x\n | 7 -> sprintf \"%.7g\" x\n | 8 -> sprintf \"%.8g\" x\n | 9 -> sprintf \"%.9g\" x\n | 10 -> sprintf \"%.10g\" x\n | 11 -> sprintf \"%.11g\" x\n | 12 -> sprintf \"%.12g\" x\n | 13 -> sprintf \"%.13g\" x\n | 14 -> sprintf \"%.14g\" x\n | 15 -> sprintf \"%.15g\" x\n | 16 -> sprintf \"%.16g\" x\n | _ -> sprintf \"%.17g\" x\n in\n Bi_outbuf.add_string ob s;\n if float_needs_period s then\n Bi_outbuf.add_string ob \".0\"\n\nlet write_float_prec significant_figures ob x =\n match classify_float x with\n FP_nan ->\n Bi_outbuf.add_string ob \"NaN\"\n | FP_infinite ->\n Bi_outbuf.add_string ob (if x > 0. then \"Infinity\" else \"-Infinity\")\n | _ ->\n write_normal_float_prec significant_figures ob x\n\nlet json_string_of_float x =\n let ob = Bi_outbuf.create 20 in\n write_float ob x;\n Bi_outbuf.contents ob\n\n\nlet write_std_float_fast ob x =\n match classify_float x with\n FP_nan ->\n json_error \"NaN value not allowed in standard JSON\"\n | FP_infinite ->\n json_error\n (if x > 0. then\n \"Infinity value not allowed in standard JSON\"\n else\n \"-Infinity value not allowed in standard JSON\")\n | _ ->\n let s = Printf.sprintf \"%.17g\" x in\n Bi_outbuf.add_string ob s;\n if float_needs_period s then\n Bi_outbuf.add_string ob \".0\"\n\nlet write_std_float ob x =\n match classify_float x with\n FP_nan ->\n json_error \"NaN value not allowed in standard JSON\"\n | FP_infinite ->\n json_error\n (if x > 0. then\n \"Infinity value not allowed in standard JSON\"\n else\n \"-Infinity value not allowed in standard JSON\")\n | _ ->\n let s1 = Printf.sprintf \"%.16g\" x in\n let s =\n if float_of_string s1 = x then s1\n else Printf.sprintf \"%.17g\" x\n in\n Bi_outbuf.add_string ob s;\n if float_needs_period s then\n Bi_outbuf.add_string ob \".0\"\n\nlet write_std_float_prec significant_figures ob x =\n match classify_float x with\n FP_nan ->\n json_error \"NaN value not allowed in standard JSON\"\n | FP_infinite ->\n json_error\n (if x > 0. then\n \"Infinity value not allowed in standard JSON\"\n else\n \"-Infinity value not allowed in standard JSON\")\n | _ ->\n write_normal_float_prec significant_figures ob x\n\nlet std_json_string_of_float x =\n let ob = Bi_outbuf.create 20 in\n write_std_float ob x;\n Bi_outbuf.contents ob\n\n\nlet test_float () =\n let l = [ 0.; 1.; -1. ] in\n let l = l @ List.map (fun x -> 2. *. x +. 1.) l in\n let l = l @ List.map (fun x -> x /. sqrt 2.) l in\n let l = l @ List.map (fun x -> x *. sqrt 3.) l in\n let l = l @ List.map cos l in\n let l = l @ List.map (fun x -> x *. 1.23e50) l in\n let l = l @ [ infinity; neg_infinity ] in\n List.iter (\n fun x ->\n let s = Printf.sprintf \"%.17g\" x in\n let y = float_of_string s in\n Printf.printf \"%g %g %S %B\\n\" x y s (x = y)\n )\n l\n\n(*\nlet () = test_float ()\n*)\n\nlet write_intlit = Bi_outbuf.add_string\nlet write_floatlit = Bi_outbuf.add_string\nlet write_stringlit = Bi_outbuf.add_string\n\nlet rec iter2_aux f_elt f_sep x = function\n [] -> ()\n | y :: l ->\n f_sep x;\n f_elt x y;\n iter2_aux f_elt f_sep x l\n\nlet iter2 f_elt f_sep x = function\n [] -> ()\n | y :: l ->\n f_elt x y;\n iter2_aux f_elt f_sep x l\n\nlet f_sep ob =\n Bi_outbuf.add_char ob ','\n\nlet rec write_json ob (x : t) =\n match x with\n `Null -> write_null ob ()\n | `Bool b -> write_bool ob b\n \n# 302 \"write.ml\"\n | `Intlit s -> Bi_outbuf.add_string ob s\n \n# 308 \"write.ml\"\n | `Floatlit s -> Bi_outbuf.add_string ob s\n \n# 314 \"write.ml\"\n | `Stringlit s -> Bi_outbuf.add_string ob s\n \n# 316 \"write.ml\"\n | `Assoc l -> write_assoc ob l\n | `List l -> write_list ob l\n \n# 319 \"write.ml\"\n | `Tuple l -> write_tuple ob l\n \n# 322 \"write.ml\"\n | `Variant (s, o) -> write_variant ob s o\n\n# 325 \"write.ml\"\nand write_assoc ob l =\n let f_elt ob (s, x) =\n write_string ob s;\n Bi_outbuf.add_char ob ':';\n write_json ob x\n in\n Bi_outbuf.add_char ob '{';\n iter2 f_elt f_sep ob l;\n Bi_outbuf.add_char ob '}';\n\nand write_list ob l =\n Bi_outbuf.add_char ob '[';\n iter2 write_json f_sep ob l;\n Bi_outbuf.add_char ob ']'\n\n# 341 \"write.ml\"\nand write_tuple ob l =\n Bi_outbuf.add_char ob '(';\n iter2 write_json f_sep ob l;\n Bi_outbuf.add_char ob ')'\n\n# 348 \"write.ml\"\nand write_variant ob s o =\n Bi_outbuf.add_char ob '<';\n write_string ob s;\n (match o with\n None -> ()\n | Some x ->\n Bi_outbuf.add_char ob ':';\n write_json ob x\n );\n Bi_outbuf.add_char ob '>'\n\n# 360 \"write.ml\"\nlet write_t = write_json\n\nlet rec write_std_json ob (x : t) =\n match x with\n `Null -> write_null ob ()\n | `Bool b -> write_bool ob b\n \n# 370 \"write.ml\"\n | `Intlit s -> Bi_outbuf.add_string ob s\n \n# 376 \"write.ml\"\n | `Floatlit s -> Bi_outbuf.add_string ob s\n \n# 382 \"write.ml\"\n | `Stringlit s -> Bi_outbuf.add_string ob s\n \n# 384 \"write.ml\"\n | `Assoc l -> write_std_assoc ob l\n | `List l -> write_std_list ob l\n \n# 387 \"write.ml\"\n | `Tuple l -> write_std_tuple ob l\n \n# 390 \"write.ml\"\n | `Variant (s, o) -> write_std_variant ob s o\n\n# 393 \"write.ml\"\nand write_std_assoc ob l =\n let f_elt ob (s, x) =\n write_string ob s;\n Bi_outbuf.add_char ob ':';\n write_std_json ob x\n in\n Bi_outbuf.add_char ob '{';\n iter2 f_elt f_sep ob l;\n Bi_outbuf.add_char ob '}';\n\nand write_std_list ob l =\n Bi_outbuf.add_char ob '[';\n iter2 write_std_json f_sep ob l;\n Bi_outbuf.add_char ob ']'\n\nand write_std_tuple ob l =\n Bi_outbuf.add_char ob '[';\n iter2 write_std_json f_sep ob l;\n Bi_outbuf.add_char ob ']'\n\n# 414 \"write.ml\"\nand write_std_variant ob s o =\n match o with\n None -> write_string ob s\n | Some x ->\n Bi_outbuf.add_char ob '[';\n write_string ob s;\n Bi_outbuf.add_char ob ',';\n write_std_json ob x;\n Bi_outbuf.add_char ob ']'\n\n\n# 426 \"write.ml\"\nlet to_outbuf ?(std = false) ob x =\n if std then (\n if not (is_object_or_array x) then\n json_error \"Root is not an object or array\"\n else\n write_std_json ob x\n )\n else\n write_json ob x\n\n\nlet to_string ?buf ?(len = 256) ?std x =\n let ob =\n match buf with\n None -> Bi_outbuf.create len\n | Some ob ->\n Bi_outbuf.clear ob;\n ob\n in\n to_outbuf ?std ob x;\n let s = Bi_outbuf.contents ob in\n Bi_outbuf.clear ob;\n s\n\nlet to_channel ?buf ?len ?std oc x =\n let ob =\n match buf with\n None -> Bi_outbuf.create_channel_writer ?len oc\n | Some ob -> ob\n in\n to_outbuf ?std ob x;\n Bi_outbuf.flush_channel_writer ob\n\nlet to_output ?buf ?len ?std out x =\n let ob =\n match buf with\n None -> Bi_outbuf.create_output_writer ?len out\n | Some ob -> ob\n in\n to_outbuf ?std ob x;\n Bi_outbuf.flush_output_writer ob\n\nlet to_file ?len ?std file x =\n let oc = open_out file in\n try\n to_channel ?len ?std oc x;\n close_out oc\n with e ->\n close_out_noerr oc;\n raise e\n\nlet stream_to_outbuf ?std ob st =\n Stream.iter (to_outbuf ?std ob) st\n\nlet stream_to_string ?buf ?(len = 256) ?std st =\n let ob =\n match buf with\n None -> Bi_outbuf.create len\n | Some ob ->\n Bi_outbuf.clear ob;\n ob\n in\n stream_to_outbuf ?std ob st;\n let s = Bi_outbuf.contents ob in\n Bi_outbuf.clear ob;\n s\n\nlet stream_to_channel ?buf ?len ?std oc st =\n let ob =\n match buf with\n None -> Bi_outbuf.create_channel_writer ?len oc\n | Some ob -> ob\n in\n stream_to_outbuf ?std ob st;\n Bi_outbuf.flush_channel_writer ob\n\nlet stream_to_file ?len ?std file st =\n let oc = open_out file in\n try\n stream_to_channel ?len ?std oc st;\n close_out oc\n with e ->\n close_out_noerr oc;\n raise e\n\n\nlet rec sort = function\n | `Assoc l ->\n let l = List.rev (List.rev_map (fun (k, v) -> (k, sort v)) l) in\n `Assoc (List.stable_sort (fun (a, _) (b, _) -> String.compare a b) l)\n | `List l ->\n `List (List.rev (List.rev_map sort l))\n \n# 519 \"write.ml\"\n | `Tuple l ->\n `Tuple (List.rev (List.rev_map sort l))\n \n# 523 \"write.ml\"\n | `Variant (k, Some v) as x ->\n let v' = sort v in\n if v == v' then x\n else\n `Variant (k, Some v')\n \n# 529 \"write.ml\"\n | x -> x\n# 1 \"monomorphic.ml\"\nlet rec pp fmt =\n function\n | `Null -> Format.pp_print_string fmt \"`Null\"\n | `Bool x ->\n Format.fprintf fmt \"`Bool (@[\";\n Format.fprintf fmt \"%B\" x;\n Format.fprintf fmt \"@])\"\n \n# 15 \"monomorphic.ml\"\n | `Intlit x ->\n Format.fprintf fmt \"`Intlit (@[\";\n Format.fprintf fmt \"%S\" x;\n Format.fprintf fmt \"@])\"\n \n# 27 \"monomorphic.ml\"\n | `Floatlit x ->\n Format.fprintf fmt \"`Floatlit (@[\";\n Format.fprintf fmt \"%S\" x;\n Format.fprintf fmt \"@])\"\n \n# 39 \"monomorphic.ml\"\n | `Stringlit x ->\n Format.fprintf fmt \"`Stringlit (@[\";\n Format.fprintf fmt \"%S\" x;\n Format.fprintf fmt \"@])\"\n \n# 44 \"monomorphic.ml\"\n | `Assoc xs ->\n Format.fprintf fmt \"`Assoc (@[\";\n Format.fprintf fmt \"@[<2>[\";\n ignore (List.fold_left\n (fun sep (key, value) ->\n if sep then\n Format.fprintf fmt \";@ \";\n Format.fprintf fmt \"(@[\";\n Format.fprintf fmt \"%S\" key;\n Format.fprintf fmt \",@ \";\n pp fmt value;\n Format.fprintf fmt \"@])\";\n true) false xs);\n Format.fprintf fmt \"@,]@]\";\n Format.fprintf fmt \"@])\"\n | `List xs ->\n Format.fprintf fmt \"`List (@[\";\n Format.fprintf fmt \"@[<2>[\";\n ignore (List.fold_left\n (fun sep x ->\n if sep then\n Format.fprintf fmt \";@ \";\n pp fmt x;\n true) false xs);\n Format.fprintf fmt \"@,]@]\";\n Format.fprintf fmt \"@])\"\n \n# 71 \"monomorphic.ml\"\n | `Tuple tup ->\n Format.fprintf fmt \"`Tuple (@[\";\n Format.fprintf fmt \"@[<2>[\";\n ignore (List.fold_left\n (fun sep e ->\n if sep then\n Format.fprintf fmt \";@ \";\n pp fmt e;\n true) false tup);\n Format.fprintf fmt \"@,]@]\";\n Format.fprintf fmt \"@])\"\n \n# 84 \"monomorphic.ml\"\n | `Variant (name, value) ->\n Format.fprintf fmt \"`Variant (@[\";\n Format.fprintf fmt \"(@[\";\n Format.fprintf fmt \"%S\" name;\n Format.fprintf fmt \",@ \";\n (match value with\n | None -> Format.pp_print_string fmt \"None\"\n | Some x ->\n Format.pp_print_string fmt \"(Some \";\n pp fmt x;\n Format.pp_print_string fmt \")\");\n Format.fprintf fmt \"@])\";\n Format.fprintf fmt \"@])\"\n\n# 99 \"monomorphic.ml\"\nlet show x =\n Format.asprintf \"%a\" pp x\n\nlet rec equal a b =\n match a, b with\n | `Null, `Null -> true\n | `Bool a, `Bool b -> a = b\n \n# 110 \"monomorphic.ml\"\n | `Intlit a, `Intlit b -> a = b\n \n# 116 \"monomorphic.ml\"\n | `Floatlit a, `Floatlit b -> a = b\n \n# 122 \"monomorphic.ml\"\n | `Stringlit a, `Stringlit b -> a = b\n \n# 124 \"monomorphic.ml\"\n | `Assoc xs, `Assoc ys ->\n let compare_keys = fun (key, _) (key', _) -> String.compare key key' in\n let xs = List.stable_sort compare_keys xs in\n let ys = List.stable_sort compare_keys ys in\n (match List.for_all2 (fun (key, value) (key', value') ->\n match key = key' with\n | false -> false\n | true -> equal value value') xs ys with\n | result -> result\n | exception Invalid_argument _ ->\n (* the lists were of different lengths, thus unequal *)\n false)\n \n# 137 \"monomorphic.ml\"\n | `Tuple xs, `Tuple ys\n \n# 139 \"monomorphic.ml\"\n | `List xs, `List ys ->\n (match List.for_all2 equal xs ys with\n | result -> result\n | exception Invalid_argument _ ->\n (* the lists were of different lengths, thus unequal *)\n false)\n \n# 146 \"monomorphic.ml\"\n | `Variant (name, value), `Variant (name', value') ->\n (match name = name' with\n | false -> false\n | true ->\n match value, value' with\n | None, None -> true\n | Some x, Some y -> equal x y\n | _ -> false)\n \n# 155 \"monomorphic.ml\"\n | _ -> false\n# 1 \"write2.ml\"\nlet pretty_format ?std (x : t) =\n Pretty.format ?std (x :> json_max)\n\nlet pretty_print ?std out (x : t) =\n Easy_format.Pretty.to_formatter out (pretty_format ?std x)\n\nlet pretty_to_string ?std (x : t) =\n Pretty.to_string ?std (x :> json_max)\n\nlet pretty_to_channel ?std oc (x : t) =\n Pretty.to_channel ?std oc (x :> json_max)\n\n# 1 \"lib/read.mll\"\n \n \n# 2 \"lib/read.mll\"\n module Lexing =\n (*\n We override Lexing.engine in order to avoid creating a new position\n record each time a rule is matched.\n This reduces total parsing time by about 31%.\n *)\n struct\n include Lexing\n\n external c_engine : lex_tables -> int -> lexbuf -> int = \"caml_lex_engine\"\n\n let engine tbl state buf =\n let result = c_engine tbl state buf in\n (*\n if result >= 0 then begin\n buf.lex_start_p <- buf.lex_curr_p;\n buf.lex_curr_p <- {buf.lex_curr_p\n with pos_cnum = buf.lex_abs_pos + buf.lex_curr_pos};\n end;\n *)\n result\n end\n\n open Printf\n open Lexing\n\n (* see description in common.mli *)\n type lexer_state = Lexer_state.t = {\n buf : Bi_outbuf.t;\n mutable lnum : int;\n mutable bol : int;\n mutable fname : string option;\n }\n\n let dec c =\n Char.code c - 48\n\n let hex c =\n match c with\n '0'..'9' -> int_of_char c - int_of_char '0'\n | 'a'..'f' -> int_of_char c - int_of_char 'a' + 10\n | 'A'..'F' -> int_of_char c - int_of_char 'A' + 10\n | _ -> assert false\n\n let custom_error descr v lexbuf =\n let offs = lexbuf.lex_abs_pos - 1 in\n let bol = v.bol in\n let pos1 = offs + lexbuf.lex_start_pos - bol - 1 in\n let pos2 = max pos1 (offs + lexbuf.lex_curr_pos - bol) in\n let file_line =\n match v.fname with\n None -> \"Line\"\n | Some s ->\n sprintf \"File %s, line\" s\n in\n let bytes =\n if pos1 = pos2 then\n sprintf \"byte %i\" (pos1+1)\n else\n sprintf \"bytes %i-%i\" (pos1+1) (pos2+1)\n in\n let msg = sprintf \"%s %i, %s:\\n%s\" file_line v.lnum bytes descr in\n json_error msg\n\n\n let lexer_error descr v lexbuf =\n custom_error\n (sprintf \"%s '%s'\" descr (Lexing.lexeme lexbuf))\n v lexbuf\n\n let read_junk = ref (fun _ -> assert false)\n\n let long_error descr v lexbuf =\n let junk = Lexing.lexeme lexbuf in\n let extra_junk = !read_junk lexbuf in\n custom_error\n (sprintf \"%s '%s%s'\" descr junk extra_junk)\n v lexbuf\n\n let min10 = min_int / 10 - (if min_int mod 10 = 0 then 0 else 1)\n let max10 = max_int / 10 + (if max_int mod 10 = 0 then 0 else 1)\n\n exception Int_overflow\n\n let extract_positive_int lexbuf =\n let start = lexbuf.lex_start_pos in\n let stop = lexbuf.lex_curr_pos in\n let s = lexbuf.lex_buffer in\n let n = ref 0 in\n for i = start to stop - 1 do\n if !n >= max10 then\n raise Int_overflow\n else\n n := 10 * !n + dec (Bytes.get s i)\n done;\n if !n < 0 then\n raise Int_overflow\n else\n !n\n\n let make_positive_int v lexbuf =\n \n# 108 \"lib/read.mll\"\n `Intlit (lexeme lexbuf)\n\n \n# 113 \"lib/read.mll\"\n let extract_negative_int lexbuf =\n let start = lexbuf.lex_start_pos + 1 in\n let stop = lexbuf.lex_curr_pos in\n let s = lexbuf.lex_buffer in\n let n = ref 0 in\n for i = start to stop - 1 do\n if !n <= min10 then\n raise Int_overflow\n else\n n := 10 * !n - dec (Bytes.get s i)\n done;\n if !n > 0 then\n raise Int_overflow\n else\n !n\n\n let make_negative_int v lexbuf =\n \n# 135 \"lib/read.mll\"\n `Intlit (lexeme lexbuf)\n\n\n \n# 141 \"lib/read.mll\"\n let set_file_name v fname =\n v.fname <- fname\n\n let newline v lexbuf =\n v.lnum <- v.lnum + 1;\n v.bol <- lexbuf.lex_abs_pos + lexbuf.lex_curr_pos\n\n let add_lexeme buf lexbuf =\n let len = lexbuf.lex_curr_pos - lexbuf.lex_start_pos in\n Bi_outbuf.add_subbytes buf lexbuf.lex_buffer lexbuf.lex_start_pos len\n\n let map_lexeme f lexbuf =\n let len = lexbuf.lex_curr_pos - lexbuf.lex_start_pos in\n f (Bytes.to_string lexbuf.lex_buffer) lexbuf.lex_start_pos len\n\n type variant_kind = [ `Edgy_bracket | `Square_bracket | `Double_quote ]\n type tuple_kind = [ `Parenthesis | `Square_bracket ]\n\n\n# 161 \"lib/read.ml\"\n# 161 \"lib/read.ml\"\nlet __ocaml_lex_tables = {\n Lexing.lex_base =\n \"\\000\\000\\236\\255\\237\\255\\003\\000\\239\\255\\016\\000\\242\\255\\243\\255\\\n \\244\\255\\245\\255\\000\\000\\031\\000\\249\\255\\085\\000\\001\\000\\000\\000\\\n \\000\\000\\001\\000\\000\\000\\001\\000\\002\\000\\255\\255\\000\\000\\000\\000\\\n \\003\\000\\254\\255\\001\\000\\004\\000\\253\\255\\011\\000\\252\\255\\003\\000\\\n \\001\\000\\003\\000\\002\\000\\003\\000\\000\\000\\251\\255\\021\\000\\097\\000\\\n \\010\\000\\022\\000\\020\\000\\016\\000\\022\\000\\012\\000\\008\\000\\250\\255\\\n \\119\\000\\129\\000\\139\\000\\161\\000\\171\\000\\181\\000\\193\\000\\209\\000\\\n \\240\\255\\011\\000\\038\\000\\252\\255\\065\\000\\254\\255\\255\\255\\110\\000\\\n \\252\\255\\163\\000\\254\\255\\255\\255\\234\\000\\247\\255\\248\\255\\048\\001\\\n \\250\\255\\251\\255\\252\\255\\253\\255\\254\\255\\255\\255\\071\\001\\126\\001\\\n \\149\\001\\249\\255\\039\\000\\253\\255\\254\\255\\038\\000\\187\\001\\210\\001\\\n \\248\\001\\015\\002\\255\\255\\220\\000\\253\\255\\255\\255\\245\\000\\039\\002\\\n \\109\\002\\014\\001\\088\\002\\164\\002\\187\\002\\225\\002\\013\\000\\252\\255\\\n \\253\\255\\254\\255\\255\\255\\014\\000\\253\\255\\254\\255\\255\\255\\030\\000\\\n \\253\\255\\254\\255\\255\\255\\015\\000\\253\\255\\254\\255\\255\\255\\017\\001\\\n \\251\\255\\252\\255\\253\\255\\254\\255\\255\\255\\019\\000\\252\\255\\253\\255\\\n \\254\\255\\015\\000\\255\\255\\016\\000\\255\\255\\008\\001\\005\\000\\253\\255\\\n \\023\\000\\254\\255\\020\\000\\255\\255\\046\\000\\253\\255\\254\\255\\042\\000\\\n \\052\\000\\053\\000\\255\\255\\053\\000\\048\\000\\091\\000\\092\\000\\255\\255\\\n \\027\\001\\250\\255\\251\\255\\137\\000\\104\\000\\089\\000\\088\\000\\106\\000\\\n \\255\\255\\143\\000\\137\\000\\177\\000\\254\\255\\183\\000\\168\\000\\166\\000\\\n \\183\\000\\002\\000\\253\\255\\177\\000\\172\\000\\187\\000\\004\\000\\252\\255\\\n \\053\\002\\251\\255\\252\\255\\253\\255\\103\\001\\255\\255\\248\\002\\254\\255\\\n \\006\\003\\030\\003\\252\\255\\253\\255\\254\\255\\255\\255\\040\\003\\050\\003\\\n \\074\\003\\252\\255\\253\\255\\254\\255\\255\\255\\061\\003\\084\\003\\108\\003\\\n \\249\\255\\250\\255\\251\\255\\244\\000\\120\\003\\142\\003\\179\\000\\194\\000\\\n \\015\\000\\255\\255\\190\\000\\188\\000\\187\\000\\193\\000\\183\\000\\179\\000\\\n \\254\\255\\191\\000\\201\\000\\200\\000\\196\\000\\203\\000\\193\\000\\189\\000\\\n \\253\\255\\157\\003\\095\\003\\174\\003\\196\\003\\206\\003\\216\\003\\228\\003\\\n \\239\\003\\060\\000\\253\\255\\254\\255\\255\\255\\012\\004\\252\\255\\253\\255\\\n \\087\\004\\255\\255\\145\\004\\252\\255\\253\\255\\221\\004\\255\\255\\229\\000\\\n \\253\\255\\254\\255\\255\\255\\231\\000\\253\\255\\254\\255\\255\\255\\002\\000\\\n \\255\\255\\018\\001\\252\\255\\253\\255\\254\\255\\255\\255\\034\\001\\253\\255\\\n \\254\\255\\255\\255\\000\\000\\255\\255\\003\\000\\254\\255\\255\\255\\038\\001\\\n \\252\\255\\253\\255\\254\\255\\255\\255\\120\\001\\251\\255\\252\\255\\253\\255\\\n \\254\\255\\255\\255\\208\\000\\253\\255\\254\\255\\255\\255\\211\\000\\253\\255\\\n \\254\\255\\255\\255\\189\\000\\255\\255\\143\\001\\252\\255\\253\\255\\254\\255\\\n \\255\\255\\013\\001\\253\\255\\254\\255\\255\\255\\095\\001\\252\\255\\253\\255\\\n \\254\\255\\255\\255\\050\\001\\253\\255\\254\\255\\255\\255\\026\\001\\253\\255\\\n \\254\\255\\255\\255\\233\\000\\253\\255\\254\\255\\255\\255\\222\\000\\253\\255\\\n \\254\\255\\255\\255\\079\\005\\237\\255\\238\\255\\010\\000\\240\\255\\044\\001\\\n \\243\\255\\244\\255\\245\\255\\246\\255\\061\\001\\002\\004\\249\\255\\045\\005\\\n \\209\\000\\228\\000\\211\\000\\232\\000\\225\\000\\223\\000\\240\\000\\255\\255\\\n \\235\\000\\234\\000\\008\\001\\254\\255\\004\\001\\023\\001\\253\\255\\054\\001\\\n \\252\\255\\031\\001\\029\\001\\032\\001\\039\\001\\049\\001\\045\\001\\251\\255\\\n \\057\\001\\082\\001\\080\\001\\078\\001\\084\\001\\074\\001\\086\\001\\250\\255\\\n \\110\\005\\012\\004\\123\\005\\155\\005\\165\\005\\177\\005\\187\\005\\197\\005\\\n \\241\\255\\199\\001\\077\\002\\253\\255\\255\\255\\154\\002\\222\\005\\209\\005\\\n \\155\\002\\239\\005\\053\\006\\076\\006\\114\\006\\016\\002\\252\\255\\253\\255\\\n \\254\\255\\255\\255\\152\\006\\252\\255\\253\\255\\227\\006\\255\\255\\085\\007\\\n \\244\\255\\245\\255\\011\\000\\247\\255\\076\\002\\250\\255\\251\\255\\252\\255\\\n \\253\\255\\254\\255\\031\\002\\243\\005\\051\\007\\100\\001\\115\\001\\104\\001\\\n \\133\\001\\118\\001\\154\\001\\171\\001\\255\\255\\173\\001\\176\\001\\191\\001\\\n \\185\\001\\187\\001\\253\\001\\230\\001\\230\\001\\234\\001\\247\\001\\237\\001\\\n \\234\\001\\009\\002\\019\\002\\019\\002\\015\\002\\021\\002\\011\\002\\007\\002\\\n \\142\\006\\152\\006\\116\\007\\170\\007\\180\\007\\190\\007\\200\\007\\210\\007\\\n \\248\\255\\120\\002\\167\\002\\253\\255\\255\\255\\216\\002\\082\\007\\220\\007\\\n \\236\\002\\244\\007\\058\\008\\081\\008\\119\\008\\076\\002\\252\\255\\253\\255\\\n \\254\\255\\255\\255\\157\\008\\252\\255\\253\\255\\232\\008\\255\\255\\135\\002\\\n \\120\\002\\253\\255\\100\\002\\254\\255\\182\\002\\255\\255\\011\\002\\255\\255\\\n \\204\\002\\252\\255\\253\\255\\254\\255\\255\\255\\046\\002\\255\\255\\178\\002\\\n \\252\\255\\253\\255\\254\\255\\255\\255\\023\\000\\255\\255\\183\\002\\252\\255\\\n \\253\\255\\254\\255\\255\\255\\187\\002\\253\\255\\254\\255\\255\\255\\121\\002\\\n \\253\\255\\254\\255\\255\\255\\184\\002\\252\\255\\253\\255\\254\\255\\019\\000\\\n \\255\\255\\140\\001\\146\\001\\255\\255\\150\\001\\151\\001\\154\\001\\168\\001\\\n \\170\\001\\171\\001\\172\\001\\173\\001\\181\\001\\184\\001\\185\\001\\187\\001\\\n \\191\\001\\193\\001\\195\\001\\196\\001\\197\\001\\200\\001\\203\\001\\223\\001\\\n \\225\\001\\228\\001\\249\\001\\251\\001\\002\\002\\004\\002\\011\\002\\012\\002\\\n \\013\\002\\000\\000\";\n Lexing.lex_backtrk =\n \"\\255\\255\\255\\255\\255\\255\\017\\000\\255\\255\\019\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\007\\000\\007\\000\\255\\255\\019\\000\\019\\000\\019\\000\\\n \\019\\000\\019\\000\\019\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\008\\000\\008\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\009\\000\\255\\255\\009\\000\\255\\255\\009\\000\\255\\255\\\n \\255\\255\\014\\000\\255\\255\\255\\255\\002\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\002\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\007\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\001\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\003\\000\\255\\255\\001\\000\\255\\255\\004\\000\\003\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\\n \\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\004\\000\\004\\000\\004\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\003\\000\\255\\255\\000\\000\\255\\255\\\n \\001\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\002\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\002\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\003\\000\\003\\000\\005\\000\\005\\000\\005\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\003\\000\\255\\255\\003\\000\\255\\255\\003\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\001\\000\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\001\\000\\255\\255\\002\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\001\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\016\\000\\255\\255\\018\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\007\\000\\007\\000\\255\\255\\018\\000\\\n \\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\008\\000\\255\\255\\008\\000\\255\\255\\008\\000\\255\\255\\\n \\255\\255\\013\\000\\255\\255\\255\\255\\255\\255\\001\\000\\001\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\009\\000\\255\\255\\011\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\000\\000\\000\\000\\011\\000\\011\\000\\011\\000\\011\\000\\\n \\011\\000\\011\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\000\\000\\255\\255\\000\\000\\255\\255\\000\\000\\255\\255\\\n \\255\\255\\006\\000\\255\\255\\255\\255\\255\\255\\001\\000\\001\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\004\\000\\\n \\003\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\003\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\";\n Lexing.lex_default =\n \"\\001\\000\\000\\000\\000\\000\\255\\255\\000\\000\\255\\255\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\\n \\255\\255\\000\\000\\255\\255\\255\\255\\000\\000\\255\\255\\000\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\000\\000\\057\\000\\060\\000\\000\\000\\060\\000\\000\\000\\000\\000\\065\\000\\\n \\000\\000\\065\\000\\000\\000\\000\\000\\070\\000\\000\\000\\000\\000\\255\\255\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\255\\255\\\n \\255\\255\\000\\000\\084\\000\\000\\000\\000\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\000\\000\\094\\000\\000\\000\\000\\000\\097\\000\\255\\255\\\n \\255\\255\\097\\000\\255\\255\\255\\255\\255\\255\\255\\255\\104\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\109\\000\\000\\000\\000\\000\\000\\000\\113\\000\\\n \\000\\000\\000\\000\\000\\000\\117\\000\\000\\000\\000\\000\\000\\000\\121\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\126\\000\\000\\000\\000\\000\\\n \\000\\000\\255\\255\\000\\000\\255\\255\\000\\000\\255\\255\\255\\255\\000\\000\\\n \\255\\255\\000\\000\\138\\000\\000\\000\\142\\000\\000\\000\\000\\000\\255\\255\\\n \\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\\n \\154\\000\\000\\000\\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\000\\000\\255\\255\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\\n \\178\\000\\000\\000\\000\\000\\000\\000\\255\\255\\000\\000\\255\\255\\000\\000\\\n \\255\\255\\187\\000\\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\255\\255\\\n \\194\\000\\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\255\\255\\201\\000\\\n \\000\\000\\000\\000\\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\235\\000\\000\\000\\000\\000\\000\\000\\239\\000\\000\\000\\000\\000\\\n \\255\\255\\000\\000\\244\\000\\000\\000\\000\\000\\255\\255\\000\\000\\249\\000\\\n \\000\\000\\000\\000\\000\\000\\253\\000\\000\\000\\000\\000\\000\\000\\255\\255\\\n \\000\\000\\003\\001\\000\\000\\000\\000\\000\\000\\000\\000\\008\\001\\000\\000\\\n \\000\\000\\000\\000\\255\\255\\000\\000\\255\\255\\000\\000\\000\\000\\017\\001\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\022\\001\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\028\\001\\000\\000\\000\\000\\000\\000\\032\\001\\000\\000\\\n \\000\\000\\000\\000\\255\\255\\000\\000\\038\\001\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\043\\001\\000\\000\\000\\000\\000\\000\\047\\001\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\052\\001\\000\\000\\000\\000\\000\\000\\056\\001\\000\\000\\\n \\000\\000\\000\\000\\060\\001\\000\\000\\000\\000\\000\\000\\064\\001\\000\\000\\\n \\000\\000\\000\\000\\067\\001\\000\\000\\000\\000\\255\\255\\000\\000\\255\\255\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\255\\255\\000\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\\n \\255\\255\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\000\\000\\255\\255\\\n \\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\000\\000\\121\\001\\125\\001\\000\\000\\000\\000\\128\\001\\255\\255\\255\\255\\\n \\128\\001\\255\\255\\255\\255\\255\\255\\255\\255\\135\\001\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\140\\001\\000\\000\\000\\000\\255\\255\\000\\000\\144\\001\\\n \\000\\000\\000\\000\\255\\255\\000\\000\\255\\255\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\000\\000\\193\\001\\197\\001\\000\\000\\000\\000\\200\\001\\255\\255\\255\\255\\\n \\200\\001\\255\\255\\255\\255\\255\\255\\255\\255\\207\\001\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\212\\001\\000\\000\\000\\000\\255\\255\\000\\000\\255\\255\\\n \\255\\255\\000\\000\\255\\255\\000\\000\\220\\001\\000\\000\\255\\255\\000\\000\\\n \\226\\001\\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\000\\000\\233\\001\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\000\\000\\240\\001\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\245\\001\\000\\000\\000\\000\\000\\000\\249\\001\\\n \\000\\000\\000\\000\\000\\000\\252\\001\\000\\000\\000\\000\\000\\000\\255\\255\\\n \\000\\000\\002\\002\\004\\002\\000\\000\\005\\002\\006\\002\\007\\002\\008\\002\\\n \\009\\002\\010\\002\\011\\002\\012\\002\\013\\002\\014\\002\\015\\002\\016\\002\\\n \\017\\002\\018\\002\\019\\002\\020\\002\\021\\002\\022\\002\\023\\002\\024\\002\\\n \\025\\002\\026\\002\\027\\002\\028\\002\\029\\002\\030\\002\\031\\002\\032\\002\\\n \\033\\002\\003\\002\";\n Lexing.lex_trans =\n \"\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\003\\000\\004\\000\\000\\000\\003\\000\\003\\000\\134\\000\\000\\000\\\n \\003\\000\\000\\000\\134\\000\\069\\001\\146\\001\\255\\255\\000\\000\\069\\001\\\n \\146\\001\\000\\000\\000\\000\\000\\000\\000\\000\\127\\000\\139\\000\\000\\000\\\n \\003\\000\\000\\000\\012\\000\\003\\000\\170\\000\\134\\000\\175\\000\\000\\000\\\n \\007\\000\\011\\001\\069\\001\\146\\001\\014\\001\\013\\000\\049\\000\\005\\000\\\n \\010\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\\n \\011\\000\\011\\000\\056\\000\\118\\000\\006\\000\\129\\000\\130\\000\\057\\000\\\n \\237\\001\\137\\000\\000\\002\\049\\000\\000\\000\\048\\000\\138\\000\\106\\000\\\n \\062\\000\\014\\000\\110\\000\\105\\000\\000\\000\\049\\000\\015\\000\\011\\000\\\n \\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\\n \\011\\000\\030\\000\\048\\000\\008\\000\\114\\000\\209\\000\\236\\000\\000\\001\\\n \\013\\001\\029\\000\\022\\000\\255\\255\\048\\000\\048\\000\\017\\000\\021\\000\\\n \\025\\000\\032\\000\\033\\000\\035\\000\\023\\000\\027\\000\\016\\000\\031\\000\\\n \\028\\000\\034\\000\\019\\000\\024\\000\\018\\000\\026\\000\\020\\000\\036\\000\\\n \\041\\000\\037\\000\\048\\000\\009\\000\\042\\000\\043\\000\\044\\000\\045\\000\\\n \\046\\000\\047\\000\\061\\000\\085\\000\\048\\000\\038\\000\\039\\000\\039\\000\\\n \\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\049\\000\\\n \\067\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\\n \\039\\000\\039\\000\\039\\000\\086\\000\\143\\000\\255\\255\\040\\000\\144\\000\\\n \\145\\000\\146\\000\\055\\000\\148\\000\\055\\000\\149\\000\\048\\000\\054\\000\\\n \\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\\n \\054\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\\n \\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\\n \\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\255\\255\\048\\000\\150\\000\\\n \\151\\000\\161\\000\\066\\000\\158\\000\\053\\000\\159\\000\\053\\000\\160\\000\\\n \\051\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\\n \\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\\n \\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\\n \\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\165\\000\\\n \\051\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\\n \\054\\000\\054\\000\\054\\000\\162\\000\\163\\000\\166\\000\\093\\000\\255\\255\\\n \\002\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\\n \\054\\000\\054\\000\\054\\000\\255\\255\\077\\000\\103\\000\\108\\000\\116\\000\\\n \\132\\000\\134\\000\\135\\000\\128\\000\\139\\000\\134\\000\\164\\000\\093\\000\\\n \\171\\000\\077\\000\\167\\000\\168\\000\\169\\000\\172\\000\\112\\000\\173\\000\\\n \\174\\000\\210\\000\\226\\000\\208\\000\\211\\000\\212\\000\\059\\000\\083\\000\\\n \\134\\000\\213\\000\\214\\000\\215\\000\\216\\000\\218\\000\\141\\000\\219\\000\\\n \\093\\000\\220\\000\\221\\000\\123\\000\\222\\000\\223\\000\\224\\000\\136\\000\\\n \\095\\000\\225\\000\\035\\001\\065\\001\\234\\000\\155\\000\\005\\001\\097\\001\\\n \\250\\000\\255\\255\\254\\000\\057\\001\\061\\001\\095\\001\\077\\000\\044\\001\\\n \\092\\001\\088\\001\\009\\001\\029\\001\\076\\000\\124\\000\\033\\001\\018\\001\\\n \\075\\000\\098\\000\\019\\001\\085\\001\\086\\001\\087\\001\\120\\001\\089\\001\\\n \\074\\000\\225\\000\\053\\001\\121\\001\\073\\000\\090\\001\\072\\000\\071\\000\\\n \\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\\n \\078\\000\\078\\000\\098\\000\\113\\001\\122\\000\\091\\001\\064\\000\\004\\001\\\n \\093\\001\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\079\\000\\\n \\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\\n \\079\\000\\156\\000\\112\\001\\094\\001\\096\\001\\098\\001\\099\\001\\049\\001\\\n \\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\100\\001\\157\\000\\\n \\101\\001\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\183\\000\\\n \\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\\n \\184\\000\\024\\001\\112\\001\\255\\255\\025\\001\\102\\001\\103\\001\\105\\001\\\n \\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\080\\000\\080\\000\\\n \\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\\n \\106\\001\\107\\001\\048\\001\\040\\001\\108\\001\\109\\001\\110\\001\\080\\000\\\n \\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\081\\000\\081\\000\\081\\000\\\n \\081\\000\\081\\000\\081\\000\\081\\000\\081\\000\\081\\000\\081\\000\\111\\001\\\n \\027\\001\\255\\255\\171\\001\\031\\001\\170\\001\\023\\001\\081\\000\\081\\000\\\n \\081\\000\\081\\000\\081\\000\\081\\000\\092\\000\\168\\001\\063\\001\\080\\000\\\n \\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\248\\000\\165\\001\\252\\000\\\n \\162\\001\\059\\001\\069\\000\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\\n \\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\255\\255\\081\\000\\081\\000\\\n \\081\\000\\081\\000\\081\\000\\081\\000\\087\\000\\087\\000\\087\\000\\087\\000\\\n \\087\\000\\087\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\\n \\088\\000\\088\\000\\088\\000\\088\\000\\039\\001\\042\\001\\255\\255\\163\\001\\\n \\164\\001\\120\\000\\002\\001\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\\n \\088\\000\\166\\001\\055\\001\\153\\000\\087\\000\\087\\000\\087\\000\\087\\000\\\n \\087\\000\\087\\000\\007\\001\\167\\001\\164\\001\\169\\001\\016\\001\\164\\001\\\n \\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\\n \\089\\000\\089\\000\\051\\001\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\\n \\088\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\090\\000\\\n \\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\\n \\090\\000\\097\\000\\137\\001\\164\\001\\172\\001\\185\\001\\136\\001\\173\\001\\\n \\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\097\\000\\179\\000\\\n \\174\\001\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\046\\001\\\n \\175\\001\\176\\001\\180\\000\\164\\001\\184\\001\\181\\000\\182\\000\\182\\000\\\n \\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\124\\001\\\n \\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\192\\001\\178\\001\\\n \\021\\001\\179\\001\\097\\000\\193\\001\\180\\001\\181\\001\\182\\001\\183\\001\\\n \\164\\001\\216\\001\\255\\255\\097\\000\\184\\001\\216\\001\\209\\001\\097\\000\\\n \\223\\001\\097\\000\\208\\001\\230\\001\\003\\002\\097\\000\\219\\001\\037\\001\\\n \\216\\001\\217\\001\\003\\002\\220\\001\\216\\001\\097\\000\\003\\002\\003\\002\\\n \\216\\001\\097\\000\\003\\002\\097\\000\\096\\000\\099\\000\\099\\000\\099\\000\\\n \\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\216\\001\\\n \\003\\002\\126\\001\\003\\002\\003\\002\\003\\002\\003\\002\\099\\000\\099\\000\\\n \\099\\000\\099\\000\\099\\000\\099\\000\\097\\000\\003\\002\\218\\001\\250\\001\\\n \\003\\002\\003\\002\\097\\000\\003\\002\\124\\001\\124\\001\\097\\000\\003\\002\\\n \\221\\001\\003\\002\\253\\001\\003\\002\\003\\002\\003\\002\\097\\000\\255\\255\\\n \\003\\002\\196\\001\\097\\000\\003\\002\\097\\000\\096\\000\\099\\000\\099\\000\\\n \\099\\000\\099\\000\\099\\000\\099\\000\\100\\000\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\235\\001\\003\\002\\\n \\241\\001\\003\\002\\255\\001\\242\\001\\003\\002\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\100\\000\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\\n \\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\246\\001\\129\\001\\129\\001\\\n \\228\\001\\003\\002\\196\\001\\003\\002\\101\\000\\101\\000\\101\\000\\101\\000\\\n \\101\\000\\101\\000\\003\\002\\198\\001\\003\\002\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\100\\000\\003\\002\\003\\002\\003\\002\\196\\001\\234\\001\\\n \\134\\001\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\\n \\097\\000\\097\\000\\097\\000\\000\\000\\101\\000\\101\\000\\101\\000\\101\\000\\\n \\101\\000\\101\\000\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\\n \\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\\n \\182\\000\\182\\000\\000\\000\\000\\000\\201\\001\\177\\000\\184\\000\\184\\000\\\n \\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\\n \\188\\000\\000\\000\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\\n \\201\\001\\227\\001\\000\\000\\191\\000\\206\\001\\123\\001\\189\\000\\190\\000\\\n \\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\\n \\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\\n \\190\\000\\190\\000\\189\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\\n \\190\\000\\190\\000\\190\\000\\190\\000\\195\\000\\197\\000\\197\\000\\197\\000\\\n \\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\198\\000\\\n \\255\\255\\248\\001\\196\\000\\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\\n \\197\\000\\197\\000\\197\\000\\197\\000\\196\\000\\197\\000\\197\\000\\197\\000\\\n \\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\202\\000\\227\\000\\\n \\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\\n \\227\\000\\205\\000\\255\\255\\255\\255\\203\\000\\204\\000\\204\\000\\204\\000\\\n \\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\226\\000\\195\\001\\\n \\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\\n \\204\\000\\204\\000\\232\\001\\000\\000\\000\\000\\206\\000\\221\\001\\239\\001\\\n \\254\\001\\000\\000\\207\\000\\244\\001\\000\\000\\225\\000\\203\\000\\204\\000\\\n \\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\\n \\232\\000\\000\\000\\232\\000\\000\\000\\225\\001\\231\\000\\231\\000\\231\\000\\\n \\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\217\\000\\\n \\255\\255\\000\\000\\000\\000\\000\\000\\000\\000\\225\\000\\227\\000\\227\\000\\\n \\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\000\\000\\000\\000\\230\\000\\\n \\000\\000\\230\\000\\000\\000\\228\\000\\229\\000\\229\\000\\229\\000\\229\\000\\\n \\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\\n \\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\\n \\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\\n \\229\\000\\229\\000\\000\\000\\228\\000\\231\\000\\231\\000\\231\\000\\231\\000\\\n \\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\186\\000\\231\\000\\\n \\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\\n \\231\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\241\\000\\000\\000\\\n \\113\\001\\000\\000\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\\n \\077\\001\\077\\001\\077\\001\\077\\001\\114\\001\\114\\001\\114\\001\\114\\001\\\n \\114\\001\\114\\001\\114\\001\\114\\001\\114\\001\\114\\001\\000\\000\\112\\001\\\n \\000\\000\\000\\000\\193\\000\\000\\000\\000\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\112\\001\\\n \\000\\000\\000\\000\\000\\000\\240\\000\\200\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\000\\000\\246\\000\\000\\000\\000\\000\\240\\000\\000\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\245\\000\\000\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\238\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\245\\000\\000\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\069\\001\\070\\001\\000\\000\\000\\000\\069\\001\\076\\001\\077\\001\\077\\001\\\n \\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\069\\001\\\n \\000\\000\\078\\001\\000\\000\\000\\000\\000\\000\\000\\000\\104\\001\\073\\001\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\079\\001\\000\\000\\071\\001\\076\\001\\\n \\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\\n \\077\\001\\000\\000\\000\\000\\072\\001\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\243\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\080\\001\\119\\001\\000\\000\\119\\001\\000\\000\\081\\001\\118\\001\\118\\001\\\n \\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\\n \\000\\000\\000\\000\\074\\001\\114\\001\\114\\001\\114\\001\\114\\001\\114\\001\\\n \\114\\001\\114\\001\\114\\001\\114\\001\\114\\001\\083\\001\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\082\\001\\000\\000\\000\\000\\\n \\115\\001\\000\\000\\000\\000\\084\\001\\000\\000\\000\\000\\117\\001\\000\\000\\\n \\117\\001\\000\\000\\075\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\\n \\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\\n \\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\000\\000\\\n \\115\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\\n \\116\\001\\116\\001\\116\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\\n \\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\\n \\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\000\\000\\\n \\128\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\\n \\130\\001\\130\\001\\130\\001\\000\\000\\000\\000\\128\\001\\000\\000\\000\\000\\\n \\000\\000\\128\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\001\\000\\000\\\n \\000\\000\\185\\001\\000\\000\\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\\n \\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\\n \\184\\001\\000\\000\\128\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\128\\001\\000\\000\\000\\000\\000\\000\\128\\001\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\128\\001\\128\\001\\000\\000\\000\\000\\068\\001\\\n \\128\\001\\128\\001\\128\\001\\127\\001\\000\\000\\128\\001\\000\\000\\000\\000\\\n \\184\\001\\000\\000\\000\\000\\000\\000\\000\\000\\128\\001\\000\\000\\000\\000\\\n \\000\\000\\128\\001\\000\\000\\128\\001\\127\\001\\131\\001\\131\\001\\131\\001\\\n \\131\\001\\131\\001\\131\\001\\131\\001\\131\\001\\131\\001\\131\\001\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\131\\001\\131\\001\\\n \\131\\001\\131\\001\\131\\001\\131\\001\\132\\001\\132\\001\\132\\001\\132\\001\\\n \\132\\001\\132\\001\\132\\001\\132\\001\\132\\001\\132\\001\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\132\\001\\132\\001\\132\\001\\\n \\132\\001\\132\\001\\132\\001\\000\\000\\000\\000\\000\\000\\131\\001\\131\\001\\\n \\131\\001\\131\\001\\131\\001\\131\\001\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\128\\001\\128\\001\\128\\001\\128\\001\\128\\001\\128\\001\\\n \\128\\001\\128\\001\\128\\001\\128\\001\\000\\000\\132\\001\\132\\001\\132\\001\\\n \\132\\001\\132\\001\\132\\001\\128\\001\\128\\001\\128\\001\\128\\001\\128\\001\\\n \\128\\001\\191\\001\\142\\001\\191\\001\\000\\000\\000\\000\\190\\001\\190\\001\\\n \\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\\n \\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\\n \\186\\001\\186\\001\\000\\000\\128\\001\\128\\001\\128\\001\\128\\001\\128\\001\\\n \\128\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\000\\000\\000\\000\\000\\000\\000\\000\\141\\001\\\n \\000\\000\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\141\\001\\000\\000\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\146\\001\\147\\001\\\n \\000\\000\\000\\000\\146\\001\\154\\001\\155\\001\\155\\001\\155\\001\\155\\001\\\n \\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\200\\001\\146\\001\\000\\000\\153\\001\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\177\\001\\150\\001\\000\\000\\000\\000\\\n \\000\\000\\200\\001\\156\\001\\000\\000\\148\\001\\154\\001\\155\\001\\155\\001\\\n \\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\000\\000\\\n \\000\\000\\149\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\139\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\157\\001\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\158\\001\\186\\001\\186\\001\\186\\001\\186\\001\\\n \\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\200\\001\\000\\000\\\n \\151\\001\\000\\000\\000\\000\\000\\000\\200\\001\\000\\000\\000\\000\\000\\000\\\n \\200\\001\\187\\001\\000\\000\\160\\001\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\200\\001\\000\\000\\000\\000\\159\\001\\200\\001\\000\\000\\200\\001\\199\\001\\\n \\000\\000\\161\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\152\\001\\000\\000\\000\\000\\000\\000\\000\\000\\189\\001\\000\\000\\189\\001\\\n \\000\\000\\187\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\\n \\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\\n \\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\\n \\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\\n \\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\\n \\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\\n \\190\\001\\190\\001\\190\\001\\190\\001\\202\\001\\202\\001\\202\\001\\202\\001\\\n \\202\\001\\202\\001\\202\\001\\202\\001\\202\\001\\202\\001\\200\\001\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\202\\001\\202\\001\\202\\001\\\n \\202\\001\\202\\001\\202\\001\\200\\001\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\202\\001\\202\\001\\202\\001\\\n \\202\\001\\202\\001\\202\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\200\\001\\000\\000\\000\\000\\000\\000\\000\\000\\145\\001\\200\\001\\000\\000\\\n \\000\\000\\000\\000\\200\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\200\\001\\000\\000\\000\\000\\000\\000\\200\\001\\000\\000\\\n \\200\\001\\199\\001\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\\n \\203\\001\\203\\001\\203\\001\\203\\001\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\\n \\203\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\\n \\204\\001\\204\\001\\204\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\\n \\000\\000\\000\\000\\000\\000\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\\n \\203\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\200\\001\\\n \\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\\n \\200\\001\\000\\000\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\\n \\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\000\\000\\214\\001\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\213\\001\\000\\000\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\000\\000\\000\\000\\000\\000\\000\\000\\213\\001\\\n \\000\\000\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\211\\001\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\";\n Lexing.lex_check =\n \"\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\000\\000\\000\\000\\255\\255\\003\\000\\000\\000\\134\\000\\255\\255\\\n \\003\\000\\255\\255\\134\\000\\069\\001\\146\\001\\057\\000\\255\\255\\069\\001\\\n \\146\\001\\255\\255\\255\\255\\255\\255\\255\\255\\125\\000\\138\\000\\255\\255\\\n \\000\\000\\255\\255\\000\\000\\003\\000\\169\\000\\134\\000\\174\\000\\255\\255\\\n \\000\\000\\010\\001\\069\\001\\146\\001\\012\\001\\000\\000\\010\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\005\\000\\115\\000\\000\\000\\125\\000\\129\\000\\005\\000\\\n \\236\\001\\136\\000\\255\\001\\038\\000\\255\\255\\010\\000\\136\\000\\102\\000\\\n \\058\\000\\000\\000\\107\\000\\102\\000\\255\\255\\011\\000\\000\\000\\011\\000\\\n \\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\\n \\011\\000\\029\\000\\038\\000\\000\\000\\111\\000\\208\\000\\233\\000\\255\\000\\\n \\012\\001\\015\\000\\017\\000\\060\\000\\011\\000\\010\\000\\000\\000\\020\\000\\\n \\024\\000\\031\\000\\032\\000\\034\\000\\022\\000\\026\\000\\000\\000\\014\\000\\\n \\027\\000\\033\\000\\018\\000\\023\\000\\000\\000\\016\\000\\019\\000\\035\\000\\\n \\040\\000\\036\\000\\038\\000\\000\\000\\041\\000\\042\\000\\043\\000\\044\\000\\\n \\045\\000\\046\\000\\058\\000\\082\\000\\011\\000\\013\\000\\013\\000\\013\\000\\\n \\013\\000\\013\\000\\013\\000\\013\\000\\013\\000\\013\\000\\013\\000\\039\\000\\\n \\063\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\\n \\039\\000\\039\\000\\039\\000\\085\\000\\140\\000\\060\\000\\013\\000\\143\\000\\\n \\144\\000\\145\\000\\048\\000\\147\\000\\048\\000\\148\\000\\039\\000\\048\\000\\\n \\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\\n \\048\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\\n \\049\\000\\049\\000\\049\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\\n \\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\065\\000\\039\\000\\149\\000\\\n \\150\\000\\156\\000\\063\\000\\157\\000\\051\\000\\158\\000\\051\\000\\159\\000\\\n \\050\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\\n \\051\\000\\051\\000\\051\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\\n \\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\053\\000\\053\\000\\053\\000\\\n \\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\155\\000\\\n \\050\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\\n \\054\\000\\054\\000\\054\\000\\161\\000\\162\\000\\155\\000\\091\\000\\065\\000\\\n \\000\\000\\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\\n \\055\\000\\055\\000\\055\\000\\057\\000\\068\\000\\102\\000\\107\\000\\115\\000\\\n \\131\\000\\133\\000\\133\\000\\125\\000\\138\\000\\133\\000\\163\\000\\094\\000\\\n \\165\\000\\068\\000\\166\\000\\167\\000\\168\\000\\171\\000\\111\\000\\172\\000\\\n \\173\\000\\206\\000\\203\\000\\207\\000\\210\\000\\211\\000\\058\\000\\082\\000\\\n \\133\\000\\212\\000\\213\\000\\214\\000\\215\\000\\217\\000\\140\\000\\218\\000\\\n \\097\\000\\219\\000\\220\\000\\119\\000\\221\\000\\222\\000\\223\\000\\133\\000\\\n \\091\\000\\203\\000\\034\\001\\062\\001\\233\\000\\152\\000\\001\\001\\080\\001\\\n \\247\\000\\060\\000\\251\\000\\054\\001\\058\\001\\081\\001\\068\\000\\041\\001\\\n \\082\\001\\083\\001\\006\\001\\026\\001\\068\\000\\119\\000\\030\\001\\015\\001\\\n \\068\\000\\094\\000\\015\\001\\084\\001\\085\\001\\086\\001\\071\\001\\088\\001\\\n \\068\\000\\203\\000\\050\\001\\071\\001\\068\\000\\089\\001\\068\\000\\068\\000\\\n \\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\\n \\071\\000\\071\\000\\097\\000\\076\\001\\119\\000\\090\\001\\063\\000\\001\\001\\\n \\092\\001\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\078\\000\\\n \\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\\n \\078\\000\\152\\000\\076\\001\\093\\001\\095\\001\\097\\001\\098\\001\\045\\001\\\n \\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\099\\001\\152\\000\\\n \\100\\001\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\180\\000\\\n \\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\\n \\180\\000\\020\\001\\076\\001\\065\\000\\020\\001\\101\\001\\102\\001\\104\\001\\\n \\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\079\\000\\079\\000\\\n \\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\\n \\105\\001\\106\\001\\045\\001\\036\\001\\107\\001\\108\\001\\109\\001\\079\\000\\\n \\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\080\\000\\080\\000\\080\\000\\\n \\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\110\\001\\\n \\026\\001\\121\\001\\157\\001\\030\\001\\158\\001\\020\\001\\080\\000\\080\\000\\\n \\080\\000\\080\\000\\080\\000\\080\\000\\091\\000\\159\\001\\062\\001\\079\\000\\\n \\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\247\\000\\160\\001\\251\\000\\\n \\161\\001\\058\\001\\068\\000\\086\\000\\086\\000\\086\\000\\086\\000\\086\\000\\\n \\086\\000\\086\\000\\086\\000\\086\\000\\086\\000\\094\\000\\080\\000\\080\\000\\\n \\080\\000\\080\\000\\080\\000\\080\\000\\086\\000\\086\\000\\086\\000\\086\\000\\\n \\086\\000\\086\\000\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\\n \\087\\000\\087\\000\\087\\000\\087\\000\\036\\001\\041\\001\\097\\000\\162\\001\\\n \\163\\001\\119\\000\\001\\001\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\\n \\087\\000\\165\\001\\054\\001\\152\\000\\086\\000\\086\\000\\086\\000\\086\\000\\\n \\086\\000\\086\\000\\006\\001\\166\\001\\167\\001\\168\\001\\015\\001\\169\\001\\\n \\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\\n \\088\\000\\088\\000\\050\\001\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\\n \\087\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\089\\000\\\n \\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\\n \\089\\000\\095\\000\\133\\001\\170\\001\\171\\001\\154\\001\\133\\001\\172\\001\\\n \\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\095\\000\\176\\000\\\n \\173\\001\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\045\\001\\\n \\174\\001\\175\\001\\176\\000\\176\\001\\154\\001\\176\\000\\176\\000\\176\\000\\\n \\176\\000\\176\\000\\176\\000\\176\\000\\176\\000\\176\\000\\176\\000\\122\\001\\\n \\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\148\\001\\177\\001\\\n \\020\\001\\178\\001\\098\\000\\148\\001\\179\\001\\180\\001\\181\\001\\182\\001\\\n \\183\\001\\216\\001\\193\\001\\095\\000\\154\\001\\216\\001\\205\\001\\098\\000\\\n \\222\\001\\095\\000\\205\\001\\229\\001\\001\\002\\095\\000\\218\\001\\036\\001\\\n \\215\\001\\215\\001\\002\\002\\218\\001\\215\\001\\095\\000\\004\\002\\005\\002\\\n \\216\\001\\095\\000\\006\\002\\095\\000\\095\\000\\096\\000\\096\\000\\096\\000\\\n \\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\215\\001\\\n \\007\\002\\122\\001\\008\\002\\009\\002\\010\\002\\011\\002\\096\\000\\096\\000\\\n \\096\\000\\096\\000\\096\\000\\096\\000\\098\\000\\012\\002\\215\\001\\247\\001\\\n \\013\\002\\014\\002\\098\\000\\015\\002\\125\\001\\128\\001\\098\\000\\016\\002\\\n \\220\\001\\017\\002\\251\\001\\018\\002\\019\\002\\020\\002\\098\\000\\121\\001\\\n \\021\\002\\194\\001\\098\\000\\022\\002\\098\\000\\098\\000\\096\\000\\096\\000\\\n \\096\\000\\096\\000\\096\\000\\096\\000\\099\\000\\099\\000\\099\\000\\099\\000\\\n \\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\231\\001\\023\\002\\\n \\238\\001\\024\\002\\251\\001\\238\\001\\025\\002\\099\\000\\099\\000\\099\\000\\\n \\099\\000\\099\\000\\099\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\243\\001\\125\\001\\128\\001\\\n \\224\\001\\026\\002\\197\\001\\027\\002\\100\\000\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\028\\002\\194\\001\\029\\002\\099\\000\\099\\000\\099\\000\\\n \\099\\000\\099\\000\\099\\000\\030\\002\\031\\002\\032\\002\\200\\001\\231\\001\\\n \\133\\001\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\\n \\101\\000\\101\\000\\101\\000\\255\\255\\100\\000\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\\n \\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\\n \\182\\000\\182\\000\\255\\255\\255\\255\\197\\001\\176\\000\\184\\000\\184\\000\\\n \\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\\n \\185\\000\\255\\255\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\\n \\200\\001\\224\\001\\255\\255\\185\\000\\205\\001\\122\\001\\185\\000\\185\\000\\\n \\185\\000\\185\\000\\185\\000\\185\\000\\185\\000\\185\\000\\185\\000\\185\\000\\\n \\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\\n \\190\\000\\190\\000\\191\\000\\191\\000\\191\\000\\191\\000\\191\\000\\191\\000\\\n \\191\\000\\191\\000\\191\\000\\191\\000\\192\\000\\197\\000\\197\\000\\197\\000\\\n \\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\192\\000\\\n \\193\\001\\247\\001\\192\\000\\192\\000\\192\\000\\192\\000\\192\\000\\192\\000\\\n \\192\\000\\192\\000\\192\\000\\192\\000\\198\\000\\198\\000\\198\\000\\198\\000\\\n \\198\\000\\198\\000\\198\\000\\198\\000\\198\\000\\198\\000\\199\\000\\226\\000\\\n \\226\\000\\226\\000\\226\\000\\226\\000\\226\\000\\226\\000\\226\\000\\226\\000\\\n \\226\\000\\199\\000\\125\\001\\128\\001\\199\\000\\199\\000\\199\\000\\199\\000\\\n \\199\\000\\199\\000\\199\\000\\199\\000\\199\\000\\199\\000\\204\\000\\194\\001\\\n \\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\\n \\204\\000\\204\\000\\231\\001\\255\\255\\255\\255\\199\\000\\220\\001\\238\\001\\\n \\251\\001\\255\\255\\199\\000\\243\\001\\255\\255\\204\\000\\205\\000\\205\\000\\\n \\205\\000\\205\\000\\205\\000\\205\\000\\205\\000\\205\\000\\205\\000\\205\\000\\\n \\225\\000\\255\\255\\225\\000\\255\\255\\224\\001\\225\\000\\225\\000\\225\\000\\\n \\225\\000\\225\\000\\225\\000\\225\\000\\225\\000\\225\\000\\225\\000\\205\\000\\\n \\197\\001\\255\\255\\255\\255\\255\\255\\255\\255\\204\\000\\227\\000\\227\\000\\\n \\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\200\\001\\255\\255\\255\\255\\228\\000\\\n \\255\\255\\228\\000\\255\\255\\227\\000\\228\\000\\228\\000\\228\\000\\228\\000\\\n \\228\\000\\228\\000\\228\\000\\228\\000\\228\\000\\228\\000\\229\\000\\229\\000\\\n \\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\\n \\230\\000\\230\\000\\230\\000\\230\\000\\230\\000\\230\\000\\230\\000\\230\\000\\\n \\230\\000\\230\\000\\255\\255\\227\\000\\231\\000\\231\\000\\231\\000\\231\\000\\\n \\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\185\\000\\232\\000\\\n \\232\\000\\232\\000\\232\\000\\232\\000\\232\\000\\232\\000\\232\\000\\232\\000\\\n \\232\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\237\\000\\255\\255\\\n \\077\\001\\255\\255\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\\n \\077\\001\\077\\001\\077\\001\\077\\001\\113\\001\\113\\001\\113\\001\\113\\001\\\n \\113\\001\\113\\001\\113\\001\\113\\001\\113\\001\\113\\001\\255\\255\\077\\001\\\n \\255\\255\\255\\255\\192\\000\\255\\255\\255\\255\\237\\000\\237\\000\\237\\000\\\n \\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\\n \\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\\n \\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\077\\001\\\n \\255\\255\\255\\255\\255\\255\\237\\000\\199\\000\\237\\000\\237\\000\\237\\000\\\n \\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\\n \\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\\n \\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\255\\255\\242\\000\\255\\255\\255\\255\\240\\000\\255\\255\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\\n \\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\\n \\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\\n \\242\\000\\242\\000\\242\\000\\242\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\242\\000\\255\\255\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\\n \\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\\n \\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\\n \\242\\000\\242\\000\\242\\000\\242\\000\\237\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\245\\000\\255\\255\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\066\\001\\066\\001\\255\\255\\255\\255\\066\\001\\079\\001\\079\\001\\079\\001\\\n \\079\\001\\079\\001\\079\\001\\079\\001\\079\\001\\079\\001\\079\\001\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\066\\001\\\n \\255\\255\\066\\001\\255\\255\\255\\255\\255\\255\\255\\255\\079\\001\\066\\001\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\066\\001\\255\\255\\066\\001\\066\\001\\\n \\066\\001\\066\\001\\066\\001\\066\\001\\066\\001\\066\\001\\066\\001\\066\\001\\\n \\066\\001\\255\\255\\255\\255\\066\\001\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\242\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\066\\001\\112\\001\\255\\255\\112\\001\\255\\255\\066\\001\\112\\001\\112\\001\\\n \\112\\001\\112\\001\\112\\001\\112\\001\\112\\001\\112\\001\\112\\001\\112\\001\\\n \\255\\255\\255\\255\\066\\001\\114\\001\\114\\001\\114\\001\\114\\001\\114\\001\\\n \\114\\001\\114\\001\\114\\001\\114\\001\\114\\001\\066\\001\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\066\\001\\255\\255\\255\\255\\\n \\114\\001\\255\\255\\255\\255\\066\\001\\255\\255\\255\\255\\115\\001\\255\\255\\\n \\115\\001\\255\\255\\066\\001\\115\\001\\115\\001\\115\\001\\115\\001\\115\\001\\\n \\115\\001\\115\\001\\115\\001\\115\\001\\115\\001\\116\\001\\116\\001\\116\\001\\\n \\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\255\\255\\\n \\114\\001\\117\\001\\117\\001\\117\\001\\117\\001\\117\\001\\117\\001\\117\\001\\\n \\117\\001\\117\\001\\117\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\\n \\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\119\\001\\119\\001\\119\\001\\\n \\119\\001\\119\\001\\119\\001\\119\\001\\119\\001\\119\\001\\119\\001\\255\\255\\\n \\126\\001\\127\\001\\127\\001\\127\\001\\127\\001\\127\\001\\127\\001\\127\\001\\\n \\127\\001\\127\\001\\127\\001\\255\\255\\255\\255\\126\\001\\255\\255\\255\\255\\\n \\255\\255\\129\\001\\127\\001\\127\\001\\127\\001\\127\\001\\127\\001\\127\\001\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\129\\001\\255\\255\\\n \\255\\255\\155\\001\\255\\255\\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\\n \\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\127\\001\\127\\001\\127\\001\\127\\001\\127\\001\\127\\001\\\n \\155\\001\\255\\255\\126\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\126\\001\\255\\255\\255\\255\\255\\255\\126\\001\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\129\\001\\126\\001\\255\\255\\255\\255\\066\\001\\\n \\126\\001\\129\\001\\126\\001\\126\\001\\255\\255\\129\\001\\255\\255\\255\\255\\\n \\155\\001\\255\\255\\255\\255\\255\\255\\255\\255\\129\\001\\255\\255\\255\\255\\\n \\255\\255\\129\\001\\255\\255\\129\\001\\129\\001\\130\\001\\130\\001\\130\\001\\\n \\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\130\\001\\130\\001\\\n \\130\\001\\130\\001\\130\\001\\130\\001\\131\\001\\131\\001\\131\\001\\131\\001\\\n \\131\\001\\131\\001\\131\\001\\131\\001\\131\\001\\131\\001\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\131\\001\\131\\001\\131\\001\\\n \\131\\001\\131\\001\\131\\001\\255\\255\\255\\255\\255\\255\\130\\001\\130\\001\\\n \\130\\001\\130\\001\\130\\001\\130\\001\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\132\\001\\132\\001\\132\\001\\132\\001\\132\\001\\132\\001\\\n \\132\\001\\132\\001\\132\\001\\132\\001\\255\\255\\131\\001\\131\\001\\131\\001\\\n \\131\\001\\131\\001\\131\\001\\132\\001\\132\\001\\132\\001\\132\\001\\132\\001\\\n \\132\\001\\184\\001\\138\\001\\184\\001\\255\\255\\255\\255\\184\\001\\184\\001\\\n \\184\\001\\184\\001\\184\\001\\184\\001\\184\\001\\184\\001\\184\\001\\184\\001\\\n \\185\\001\\185\\001\\185\\001\\185\\001\\185\\001\\185\\001\\185\\001\\185\\001\\\n \\185\\001\\185\\001\\255\\255\\132\\001\\132\\001\\132\\001\\132\\001\\132\\001\\\n \\132\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\\n \\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\\n \\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\\n \\138\\001\\138\\001\\138\\001\\255\\255\\255\\255\\255\\255\\255\\255\\138\\001\\\n \\255\\255\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\\n \\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\\n \\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\\n \\138\\001\\138\\001\\138\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\141\\001\\255\\255\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\143\\001\\143\\001\\\n \\255\\255\\255\\255\\143\\001\\156\\001\\156\\001\\156\\001\\156\\001\\156\\001\\\n \\156\\001\\156\\001\\156\\001\\156\\001\\156\\001\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\198\\001\\143\\001\\255\\255\\143\\001\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\156\\001\\143\\001\\255\\255\\255\\255\\\n \\255\\255\\198\\001\\143\\001\\255\\255\\143\\001\\143\\001\\143\\001\\143\\001\\\n \\143\\001\\143\\001\\143\\001\\143\\001\\143\\001\\143\\001\\143\\001\\255\\255\\\n \\255\\255\\143\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\138\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\143\\001\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\143\\001\\186\\001\\186\\001\\186\\001\\186\\001\\\n \\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\198\\001\\255\\255\\\n \\143\\001\\255\\255\\255\\255\\255\\255\\198\\001\\255\\255\\255\\255\\255\\255\\\n \\198\\001\\186\\001\\255\\255\\143\\001\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\198\\001\\255\\255\\255\\255\\143\\001\\198\\001\\255\\255\\198\\001\\198\\001\\\n \\255\\255\\143\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\143\\001\\255\\255\\255\\255\\255\\255\\255\\255\\187\\001\\255\\255\\187\\001\\\n \\255\\255\\186\\001\\187\\001\\187\\001\\187\\001\\187\\001\\187\\001\\187\\001\\\n \\187\\001\\187\\001\\187\\001\\187\\001\\188\\001\\188\\001\\188\\001\\188\\001\\\n \\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\189\\001\\189\\001\\\n \\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\\n \\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\\n \\190\\001\\190\\001\\191\\001\\191\\001\\191\\001\\191\\001\\191\\001\\191\\001\\\n \\191\\001\\191\\001\\191\\001\\191\\001\\199\\001\\199\\001\\199\\001\\199\\001\\\n \\199\\001\\199\\001\\199\\001\\199\\001\\199\\001\\199\\001\\201\\001\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\199\\001\\199\\001\\199\\001\\\n \\199\\001\\199\\001\\199\\001\\201\\001\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\199\\001\\199\\001\\199\\001\\\n \\199\\001\\199\\001\\199\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\201\\001\\255\\255\\255\\255\\255\\255\\255\\255\\143\\001\\201\\001\\255\\255\\\n \\255\\255\\255\\255\\201\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\201\\001\\255\\255\\255\\255\\255\\255\\201\\001\\255\\255\\\n \\201\\001\\201\\001\\202\\001\\202\\001\\202\\001\\202\\001\\202\\001\\202\\001\\\n \\202\\001\\202\\001\\202\\001\\202\\001\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\202\\001\\202\\001\\202\\001\\202\\001\\202\\001\\\n \\202\\001\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\\n \\203\\001\\203\\001\\203\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\\n \\255\\255\\255\\255\\255\\255\\202\\001\\202\\001\\202\\001\\202\\001\\202\\001\\\n \\202\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\204\\001\\\n \\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\\n \\204\\001\\255\\255\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\\n \\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\255\\255\\210\\001\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\210\\001\\210\\001\\\n \\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\\n \\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\\n \\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\210\\001\\255\\255\\210\\001\\210\\001\\\n \\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\\n \\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\\n \\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\255\\255\\255\\255\\255\\255\\255\\255\\213\\001\\\n \\255\\255\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\210\\001\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\";\n Lexing.lex_base_code =\n \"\";\n Lexing.lex_backtrk_code =\n \"\";\n Lexing.lex_default_code =\n \"\";\n Lexing.lex_trans_code =\n \"\";\n Lexing.lex_check_code =\n \"\";\n Lexing.lex_code =\n \"\";\n}\n\nlet rec read_json v lexbuf =\n __ocaml_lex_read_json_rec v lexbuf 0\nand __ocaml_lex_read_json_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 188 \"lib/read.mll\"\n \n# 188 \"lib/read.mll\"\n ( `Bool true )\n\n# 1032 \"lib/read.ml\"\n\n \n# 1033 \"lib/read.ml\"\n | 1 ->\n\n# 189 \"lib/read.mll\"\n \n# 189 \"lib/read.mll\"\n ( `Bool false )\n\n# 1037 \"lib/read.ml\"\n\n \n# 1038 \"lib/read.ml\"\n | 2 ->\n\n# 190 \"lib/read.mll\"\n \n# 190 \"lib/read.mll\"\n ( `Null )\n\n# 1042 \"lib/read.ml\"\n\n \n# 1043 \"lib/read.ml\"\n | 3 ->\n\n# 191 \"lib/read.mll\"\n \n# 191 \"lib/read.mll\"\n (\n \n# 195 \"lib/read.mll\"\n `Floatlit \"NaN\"\n \n# 197 \"lib/read.mll\"\n )\n\n# 1053 \"lib/read.ml\"\n\n \n# 1054 \"lib/read.ml\"\n | 4 ->\n\n# 198 \"lib/read.mll\"\n \n# 198 \"lib/read.mll\"\n (\n \n# 202 \"lib/read.mll\"\n `Floatlit \"Infinity\"\n \n# 204 \"lib/read.mll\"\n )\n\n# 1064 \"lib/read.ml\"\n\n \n# 1065 \"lib/read.ml\"\n | 5 ->\n\n# 205 \"lib/read.mll\"\n \n# 205 \"lib/read.mll\"\n (\n \n# 209 \"lib/read.mll\"\n `Floatlit \"-Infinity\"\n \n# 211 \"lib/read.mll\"\n )\n\n# 1075 \"lib/read.ml\"\n\n \n# 1076 \"lib/read.ml\"\n | 6 ->\n\n# 212 \"lib/read.mll\"\n \n# 212 \"lib/read.mll\"\n (\n \n# 217 \"lib/read.mll\"\n `Stringlit (finish_stringlit v lexbuf)\n \n# 219 \"lib/read.mll\"\n )\n\n# 1087 \"lib/read.ml\"\n\n \n# 1088 \"lib/read.ml\"\n | 7 ->\n\n# 220 \"lib/read.mll\"\n \n# 220 \"lib/read.mll\"\n ( make_positive_int v lexbuf )\n\n# 1092 \"lib/read.ml\"\n\n \n# 1093 \"lib/read.ml\"\n | 8 ->\n\n# 221 \"lib/read.mll\"\n \n# 221 \"lib/read.mll\"\n ( make_negative_int v lexbuf )\n\n# 1097 \"lib/read.ml\"\n\n \n# 1098 \"lib/read.ml\"\n | 9 ->\n\n# 222 \"lib/read.mll\"\n \n# 222 \"lib/read.mll\"\n (\n \n# 226 \"lib/read.mll\"\n `Floatlit (lexeme lexbuf)\n \n# 228 \"lib/read.mll\"\n )\n\n# 1108 \"lib/read.ml\"\n\n \n# 1109 \"lib/read.ml\"\n | 10 ->\n\n# 230 \"lib/read.mll\"\n \n# 230 \"lib/read.mll\"\n ( let acc = ref [] in\n try\n read_space v lexbuf;\n read_object_end lexbuf;\n let field_name = read_ident v lexbuf in\n read_space v lexbuf;\n read_colon v lexbuf;\n read_space v lexbuf;\n acc := (field_name, read_json v lexbuf) :: !acc;\n while true do\n read_space v lexbuf;\n read_object_sep v lexbuf;\n read_space v lexbuf;\n let field_name = read_ident v lexbuf in\n read_space v lexbuf;\n read_colon v lexbuf;\n read_space v lexbuf;\n acc := (field_name, read_json v lexbuf) :: !acc;\n done;\n assert false\n with End_of_object ->\n `Assoc (List.rev !acc)\n )\n\n# 1135 \"lib/read.ml\"\n\n \n# 1136 \"lib/read.ml\"\n | 11 ->\n\n# 254 \"lib/read.mll\"\n \n# 254 \"lib/read.mll\"\n ( let acc = ref [] in\n try\n read_space v lexbuf;\n read_array_end lexbuf;\n acc := read_json v lexbuf :: !acc;\n while true do\n read_space v lexbuf;\n read_array_sep v lexbuf;\n read_space v lexbuf;\n acc := read_json v lexbuf :: !acc;\n done;\n assert false\n with End_of_array ->\n `List (List.rev !acc)\n )\n\n# 1154 \"lib/read.ml\"\n\n \n# 1155 \"lib/read.ml\"\n | 12 ->\n\n# 270 \"lib/read.mll\"\n \n# 270 \"lib/read.mll\"\n (\n \n# 272 \"lib/read.mll\"\n let acc = ref [] in\n try\n read_space v lexbuf;\n read_tuple_end lexbuf;\n acc := read_json v lexbuf :: !acc;\n while true do\n read_space v lexbuf;\n read_tuple_sep v lexbuf;\n read_space v lexbuf;\n acc := read_json v lexbuf :: !acc;\n done;\n assert false\n with End_of_tuple ->\n `Tuple (List.rev !acc)\n \n# 289 \"lib/read.mll\"\n )\n\n# 1178 \"lib/read.ml\"\n\n \n# 1179 \"lib/read.ml\"\n | 13 ->\n\n# 291 \"lib/read.mll\"\n \n# 291 \"lib/read.mll\"\n (\n \n# 293 \"lib/read.mll\"\n read_space v lexbuf;\n let cons = read_ident v lexbuf in\n read_space v lexbuf;\n `Variant (cons, finish_variant v lexbuf)\n \n# 300 \"lib/read.mll\"\n )\n\n# 1192 \"lib/read.ml\"\n\n \n# 1193 \"lib/read.ml\"\n | 14 ->\n\n# 302 \"lib/read.mll\"\n \n# 302 \"lib/read.mll\"\n ( read_json v lexbuf )\n\n# 1197 \"lib/read.ml\"\n\n \n# 1198 \"lib/read.ml\"\n | 15 ->\n\n# 303 \"lib/read.mll\"\n \n# 303 \"lib/read.mll\"\n ( finish_comment v lexbuf; read_json v lexbuf )\n\n# 1202 \"lib/read.ml\"\n\n \n# 1203 \"lib/read.ml\"\n | 16 ->\n\n# 304 \"lib/read.mll\"\n \n# 304 \"lib/read.mll\"\n ( newline v lexbuf; read_json v lexbuf )\n\n# 1207 \"lib/read.ml\"\n\n \n# 1208 \"lib/read.ml\"\n | 17 ->\n\n# 305 \"lib/read.mll\"\n \n# 305 \"lib/read.mll\"\n ( read_json v lexbuf )\n\n# 1212 \"lib/read.ml\"\n\n \n# 1213 \"lib/read.ml\"\n | 18 ->\n\n# 306 \"lib/read.mll\"\n \n# 306 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1217 \"lib/read.ml\"\n\n \n# 1218 \"lib/read.ml\"\n | 19 ->\n\n# 307 \"lib/read.mll\"\n \n# 307 \"lib/read.mll\"\n ( long_error \"Invalid token\" v lexbuf )\n\n# 1222 \"lib/read.ml\"\n\n \n# 1223 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_json_rec v lexbuf __ocaml_lex_state\n\nand finish_string v lexbuf =\n __ocaml_lex_finish_string_rec v lexbuf 58\nand __ocaml_lex_finish_string_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 311 \"lib/read.mll\"\n \n# 311 \"lib/read.mll\"\n ( Bi_outbuf.contents v.buf )\n\n# 1234 \"lib/read.ml\"\n\n \n# 1235 \"lib/read.ml\"\n | 1 ->\n\n# 312 \"lib/read.mll\"\n \n# 312 \"lib/read.mll\"\n ( finish_escaped_char v lexbuf;\n finish_string v lexbuf )\n\n# 1240 \"lib/read.ml\"\n\n \n# 1241 \"lib/read.ml\"\n | 2 ->\n\n# 314 \"lib/read.mll\"\n \n# 314 \"lib/read.mll\"\n ( add_lexeme v.buf lexbuf;\n finish_string v lexbuf )\n\n# 1246 \"lib/read.ml\"\n\n \n# 1247 \"lib/read.ml\"\n | 3 ->\n\n# 316 \"lib/read.mll\"\n \n# 316 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1251 \"lib/read.ml\"\n\n \n# 1252 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_string_rec v lexbuf __ocaml_lex_state\n\nand map_string v f lexbuf =\n __ocaml_lex_map_string_rec v f lexbuf 63\nand __ocaml_lex_map_string_rec v f lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 319 \"lib/read.mll\"\n \n# 319 \"lib/read.mll\"\n ( let b = v.buf in\n f (Bytes.to_string b.Bi_outbuf.o_s) 0 b.Bi_outbuf.o_len )\n\n# 1264 \"lib/read.ml\"\n\n \n# 1265 \"lib/read.ml\"\n | 1 ->\n\n# 321 \"lib/read.mll\"\n \n# 321 \"lib/read.mll\"\n ( finish_escaped_char v lexbuf;\n map_string v f lexbuf )\n\n# 1270 \"lib/read.ml\"\n\n \n# 1271 \"lib/read.ml\"\n | 2 ->\n\n# 323 \"lib/read.mll\"\n \n# 323 \"lib/read.mll\"\n ( add_lexeme v.buf lexbuf;\n map_string v f lexbuf )\n\n# 1276 \"lib/read.ml\"\n\n \n# 1277 \"lib/read.ml\"\n | 3 ->\n\n# 325 \"lib/read.mll\"\n \n# 325 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1281 \"lib/read.ml\"\n\n \n# 1282 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_map_string_rec v f lexbuf __ocaml_lex_state\n\nand finish_escaped_char v lexbuf =\n __ocaml_lex_finish_escaped_char_rec v lexbuf 68\nand __ocaml_lex_finish_escaped_char_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\nlet\n\n# 330 \"lib/read.mll\"\n \n# 330 \"lib/read.mll\"\n c\n\n# 1294 \"lib/read.ml\"\n# 1294 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf lexbuf.Lexing.lex_start_pos in\n\n# 330 \"lib/read.mll\"\n \n# 330 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf c )\n\n# 1298 \"lib/read.ml\"\n\n \n# 1299 \"lib/read.ml\"\n | 1 ->\n\n# 331 \"lib/read.mll\"\n \n# 331 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\\b' )\n\n# 1303 \"lib/read.ml\"\n\n \n# 1304 \"lib/read.ml\"\n | 2 ->\n\n# 332 \"lib/read.mll\"\n \n# 332 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\\012' )\n\n# 1308 \"lib/read.ml\"\n\n \n# 1309 \"lib/read.ml\"\n | 3 ->\n\n# 333 \"lib/read.mll\"\n \n# 333 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\\n' )\n\n# 1313 \"lib/read.ml\"\n\n \n# 1314 \"lib/read.ml\"\n | 4 ->\n\n# 334 \"lib/read.mll\"\n \n# 334 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\\r' )\n\n# 1318 \"lib/read.ml\"\n\n \n# 1319 \"lib/read.ml\"\n | 5 ->\n\n# 335 \"lib/read.mll\"\n \n# 335 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\\t' )\n\n# 1323 \"lib/read.ml\"\n\n \n# 1324 \"lib/read.ml\"\n | 6 ->\nlet\n\n# 336 \"lib/read.mll\"\n \n# 336 \"lib/read.mll\"\n a\n\n# 1329 \"lib/read.ml\"\n# 1329 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 1)\nand\n\n# 336 \"lib/read.mll\"\n \n# 336 \"lib/read.mll\"\n b\n\n# 1334 \"lib/read.ml\"\n# 1334 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 2)\nand\n\n# 336 \"lib/read.mll\"\n \n# 336 \"lib/read.mll\"\n c\n\n# 1339 \"lib/read.ml\"\n# 1339 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 3)\nand\n\n# 336 \"lib/read.mll\"\n \n# 336 \"lib/read.mll\"\n d\n\n# 1344 \"lib/read.ml\"\n# 1344 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 4) in\n\n# 337 \"lib/read.mll\"\n \n# 337 \"lib/read.mll\"\n ( let x =\n (hex a lsl 12) lor (hex b lsl 8) lor (hex c lsl 4) lor hex d\n in\n if x >= 0xD800 && x <= 0xDBFF then\n finish_surrogate_pair v x lexbuf\n else\n utf8_of_code v.buf x\n )\n\n# 1355 \"lib/read.ml\"\n\n \n# 1356 \"lib/read.ml\"\n | 7 ->\n\n# 345 \"lib/read.mll\"\n \n# 345 \"lib/read.mll\"\n ( long_error \"Invalid escape sequence\" v lexbuf )\n\n# 1360 \"lib/read.ml\"\n\n \n# 1361 \"lib/read.ml\"\n | 8 ->\n\n# 346 \"lib/read.mll\"\n \n# 346 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1365 \"lib/read.ml\"\n\n \n# 1366 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_escaped_char_rec v lexbuf __ocaml_lex_state\n\nand finish_surrogate_pair v x lexbuf =\n __ocaml_lex_finish_surrogate_pair_rec v x lexbuf 82\nand __ocaml_lex_finish_surrogate_pair_rec v x lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\nlet\n\n# 349 \"lib/read.mll\"\n \n# 349 \"lib/read.mll\"\n a\n\n# 1378 \"lib/read.ml\"\n# 1378 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 2)\nand\n\n# 349 \"lib/read.mll\"\n \n# 349 \"lib/read.mll\"\n b\n\n# 1383 \"lib/read.ml\"\n# 1383 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 3)\nand\n\n# 349 \"lib/read.mll\"\n \n# 349 \"lib/read.mll\"\n c\n\n# 1388 \"lib/read.ml\"\n# 1388 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 4)\nand\n\n# 349 \"lib/read.mll\"\n \n# 349 \"lib/read.mll\"\n d\n\n# 1393 \"lib/read.ml\"\n# 1393 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 5) in\n\n# 350 \"lib/read.mll\"\n \n# 350 \"lib/read.mll\"\n ( let y =\n (hex a lsl 12) lor (hex b lsl 8) lor (hex c lsl 4) lor hex d\n in\n if y >= 0xDC00 && y <= 0xDFFF then\n utf8_of_surrogate_pair v.buf x y\n else\n long_error \"Invalid low surrogate for code point beyond U+FFFF\"\n v lexbuf\n )\n\n# 1405 \"lib/read.ml\"\n\n \n# 1406 \"lib/read.ml\"\n | 1 ->\n\n# 359 \"lib/read.mll\"\n \n# 359 \"lib/read.mll\"\n ( long_error \"Missing escape sequence representing low surrogate \\\n for code point beyond U+FFFF\" v lexbuf )\n\n# 1411 \"lib/read.ml\"\n\n \n# 1412 \"lib/read.ml\"\n | 2 ->\n\n# 361 \"lib/read.mll\"\n \n# 361 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1416 \"lib/read.ml\"\n\n \n# 1417 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_surrogate_pair_rec v x lexbuf __ocaml_lex_state\n\nand finish_stringlit v lexbuf =\n __ocaml_lex_finish_stringlit_rec v lexbuf 91\nand __ocaml_lex_finish_stringlit_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 366 \"lib/read.mll\"\n \n# 366 \"lib/read.mll\"\n ( let len = lexbuf.lex_curr_pos - lexbuf.lex_start_pos in\n let s = Bytes.create (len+1) in\n Bytes.set s 0 '\"';\n Bytes.blit lexbuf.lex_buffer lexbuf.lex_start_pos s 1 len;\n Bytes.to_string s\n )\n\n# 1433 \"lib/read.ml\"\n\n \n# 1434 \"lib/read.ml\"\n | 1 ->\n\n# 372 \"lib/read.mll\"\n \n# 372 \"lib/read.mll\"\n ( long_error \"Invalid string literal\" v lexbuf )\n\n# 1438 \"lib/read.ml\"\n\n \n# 1439 \"lib/read.ml\"\n | 2 ->\n\n# 373 \"lib/read.mll\"\n \n# 373 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1443 \"lib/read.ml\"\n\n \n# 1444 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_stringlit_rec v lexbuf __ocaml_lex_state\n\nand finish_variant v lexbuf =\n __ocaml_lex_finish_variant_rec v lexbuf 102\nand __ocaml_lex_finish_variant_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 376 \"lib/read.mll\"\n \n# 376 \"lib/read.mll\"\n ( let x = read_json v lexbuf in\n read_space v lexbuf;\n read_gt v lexbuf;\n Some x )\n\n# 1458 \"lib/read.ml\"\n\n \n# 1459 \"lib/read.ml\"\n | 1 ->\n\n# 380 \"lib/read.mll\"\n \n# 380 \"lib/read.mll\"\n ( None )\n\n# 1463 \"lib/read.ml\"\n\n \n# 1464 \"lib/read.ml\"\n | 2 ->\n\n# 381 \"lib/read.mll\"\n \n# 381 \"lib/read.mll\"\n ( long_error \"Expected ':' or '>' but found\" v lexbuf )\n\n# 1468 \"lib/read.ml\"\n\n \n# 1469 \"lib/read.ml\"\n | 3 ->\n\n# 382 \"lib/read.mll\"\n \n# 382 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1473 \"lib/read.ml\"\n\n \n# 1474 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_variant_rec v lexbuf __ocaml_lex_state\n\nand read_lt v lexbuf =\n __ocaml_lex_read_lt_rec v lexbuf 107\nand __ocaml_lex_read_lt_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 385 \"lib/read.mll\"\n \n# 385 \"lib/read.mll\"\n ( () )\n\n# 1485 \"lib/read.ml\"\n\n \n# 1486 \"lib/read.ml\"\n | 1 ->\n\n# 386 \"lib/read.mll\"\n \n# 386 \"lib/read.mll\"\n ( long_error \"Expected '<' but found\" v lexbuf )\n\n# 1490 \"lib/read.ml\"\n\n \n# 1491 \"lib/read.ml\"\n | 2 ->\n\n# 387 \"lib/read.mll\"\n \n# 387 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1495 \"lib/read.ml\"\n\n \n# 1496 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_lt_rec v lexbuf __ocaml_lex_state\n\nand read_gt v lexbuf =\n __ocaml_lex_read_gt_rec v lexbuf 111\nand __ocaml_lex_read_gt_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 390 \"lib/read.mll\"\n \n# 390 \"lib/read.mll\"\n ( () )\n\n# 1507 \"lib/read.ml\"\n\n \n# 1508 \"lib/read.ml\"\n | 1 ->\n\n# 391 \"lib/read.mll\"\n \n# 391 \"lib/read.mll\"\n ( long_error \"Expected '>' but found\" v lexbuf )\n\n# 1512 \"lib/read.ml\"\n\n \n# 1513 \"lib/read.ml\"\n | 2 ->\n\n# 392 \"lib/read.mll\"\n \n# 392 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1517 \"lib/read.ml\"\n\n \n# 1518 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_gt_rec v lexbuf __ocaml_lex_state\n\nand read_comma v lexbuf =\n __ocaml_lex_read_comma_rec v lexbuf 115\nand __ocaml_lex_read_comma_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 395 \"lib/read.mll\"\n \n# 395 \"lib/read.mll\"\n ( () )\n\n# 1529 \"lib/read.ml\"\n\n \n# 1530 \"lib/read.ml\"\n | 1 ->\n\n# 396 \"lib/read.mll\"\n \n# 396 \"lib/read.mll\"\n ( long_error \"Expected ',' but found\" v lexbuf )\n\n# 1534 \"lib/read.ml\"\n\n \n# 1535 \"lib/read.ml\"\n | 2 ->\n\n# 397 \"lib/read.mll\"\n \n# 397 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1539 \"lib/read.ml\"\n\n \n# 1540 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_comma_rec v lexbuf __ocaml_lex_state\n\nand start_any_variant v lexbuf =\n __ocaml_lex_start_any_variant_rec v lexbuf 119\nand __ocaml_lex_start_any_variant_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 400 \"lib/read.mll\"\n \n# 400 \"lib/read.mll\"\n ( `Edgy_bracket )\n\n# 1551 \"lib/read.ml\"\n\n \n# 1552 \"lib/read.ml\"\n | 1 ->\n\n# 401 \"lib/read.mll\"\n \n# 401 \"lib/read.mll\"\n ( Bi_outbuf.clear v.buf;\n `Double_quote )\n\n# 1557 \"lib/read.ml\"\n\n \n# 1558 \"lib/read.ml\"\n | 2 ->\n\n# 403 \"lib/read.mll\"\n \n# 403 \"lib/read.mll\"\n ( `Square_bracket )\n\n# 1562 \"lib/read.ml\"\n\n \n# 1563 \"lib/read.ml\"\n | 3 ->\n\n# 404 \"lib/read.mll\"\n \n# 404 \"lib/read.mll\"\n ( long_error \"Expected '<', '\\\"' or '[' but found\" v lexbuf )\n\n# 1567 \"lib/read.ml\"\n\n \n# 1568 \"lib/read.ml\"\n | 4 ->\n\n# 405 \"lib/read.mll\"\n \n# 405 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1572 \"lib/read.ml\"\n\n \n# 1573 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_start_any_variant_rec v lexbuf __ocaml_lex_state\n\nand finish_comment v lexbuf =\n __ocaml_lex_finish_comment_rec v lexbuf 125\nand __ocaml_lex_finish_comment_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 408 \"lib/read.mll\"\n \n# 408 \"lib/read.mll\"\n ( () )\n\n# 1584 \"lib/read.ml\"\n\n \n# 1585 \"lib/read.ml\"\n | 1 ->\n\n# 409 \"lib/read.mll\"\n \n# 409 \"lib/read.mll\"\n ( long_error \"Unterminated comment\" v lexbuf )\n\n# 1589 \"lib/read.ml\"\n\n \n# 1590 \"lib/read.ml\"\n | 2 ->\n\n# 410 \"lib/read.mll\"\n \n# 410 \"lib/read.mll\"\n ( newline v lexbuf; finish_comment v lexbuf )\n\n# 1594 \"lib/read.ml\"\n\n \n# 1595 \"lib/read.ml\"\n | 3 ->\n\n# 411 \"lib/read.mll\"\n \n# 411 \"lib/read.mll\"\n ( finish_comment v lexbuf )\n\n# 1599 \"lib/read.ml\"\n\n \n# 1600 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_comment_rec v lexbuf __ocaml_lex_state\n\nand read_eof lexbuf =\n __ocaml_lex_read_eof_rec lexbuf 131\nand __ocaml_lex_read_eof_rec lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 419 \"lib/read.mll\"\n \n# 419 \"lib/read.mll\"\n ( true )\n\n# 1611 \"lib/read.ml\"\n\n \n# 1612 \"lib/read.ml\"\n | 1 ->\n\n# 420 \"lib/read.mll\"\n \n# 420 \"lib/read.mll\"\n ( false )\n\n# 1616 \"lib/read.ml\"\n\n \n# 1617 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_eof_rec lexbuf __ocaml_lex_state\n\nand read_space v lexbuf =\n __ocaml_lex_read_space_rec v lexbuf 133\nand __ocaml_lex_read_space_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 423 \"lib/read.mll\"\n \n# 423 \"lib/read.mll\"\n ( newline v lexbuf; read_space v lexbuf )\n\n# 1628 \"lib/read.ml\"\n\n \n# 1629 \"lib/read.ml\"\n | 1 ->\n\n# 424 \"lib/read.mll\"\n \n# 424 \"lib/read.mll\"\n ( finish_comment v lexbuf; read_space v lexbuf )\n\n# 1633 \"lib/read.ml\"\n\n \n# 1634 \"lib/read.ml\"\n | 2 ->\n\n# 425 \"lib/read.mll\"\n \n# 425 \"lib/read.mll\"\n ( newline v lexbuf; read_space v lexbuf )\n\n# 1638 \"lib/read.ml\"\n\n \n# 1639 \"lib/read.ml\"\n | 3 ->\n\n# 426 \"lib/read.mll\"\n \n# 426 \"lib/read.mll\"\n ( read_space v lexbuf )\n\n# 1643 \"lib/read.ml\"\n\n \n# 1644 \"lib/read.ml\"\n | 4 ->\n\n# 427 \"lib/read.mll\"\n \n# 427 \"lib/read.mll\"\n ( () )\n\n# 1648 \"lib/read.ml\"\n\n \n# 1649 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_space_rec v lexbuf __ocaml_lex_state\n\nand read_null v lexbuf =\n __ocaml_lex_read_null_rec v lexbuf 140\nand __ocaml_lex_read_null_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 430 \"lib/read.mll\"\n \n# 430 \"lib/read.mll\"\n ( () )\n\n# 1660 \"lib/read.ml\"\n\n \n# 1661 \"lib/read.ml\"\n | 1 ->\n\n# 431 \"lib/read.mll\"\n \n# 431 \"lib/read.mll\"\n ( long_error \"Expected 'null' but found\" v lexbuf )\n\n# 1665 \"lib/read.ml\"\n\n \n# 1666 \"lib/read.ml\"\n | 2 ->\n\n# 432 \"lib/read.mll\"\n \n# 432 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1670 \"lib/read.ml\"\n\n \n# 1671 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_null_rec v lexbuf __ocaml_lex_state\n\nand read_null_if_possible v lexbuf =\n __ocaml_lex_read_null_if_possible_rec v lexbuf 147\nand __ocaml_lex_read_null_if_possible_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 435 \"lib/read.mll\"\n \n# 435 \"lib/read.mll\"\n ( true )\n\n# 1682 \"lib/read.ml\"\n\n \n# 1683 \"lib/read.ml\"\n | 1 ->\n\n# 436 \"lib/read.mll\"\n \n# 436 \"lib/read.mll\"\n ( false )\n\n# 1687 \"lib/read.ml\"\n\n \n# 1688 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_null_if_possible_rec v lexbuf __ocaml_lex_state\n\nand read_bool v lexbuf =\n __ocaml_lex_read_bool_rec v lexbuf 152\nand __ocaml_lex_read_bool_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 439 \"lib/read.mll\"\n \n# 439 \"lib/read.mll\"\n ( true )\n\n# 1699 \"lib/read.ml\"\n\n \n# 1700 \"lib/read.ml\"\n | 1 ->\n\n# 440 \"lib/read.mll\"\n \n# 440 \"lib/read.mll\"\n ( false )\n\n# 1704 \"lib/read.ml\"\n\n \n# 1705 \"lib/read.ml\"\n | 2 ->\n\n# 443 \"lib/read.mll\"\n \n# 443 \"lib/read.mll\"\n ( true )\n\n# 1709 \"lib/read.ml\"\n\n \n# 1710 \"lib/read.ml\"\n | 3 ->\n\n# 444 \"lib/read.mll\"\n \n# 444 \"lib/read.mll\"\n ( false )\n\n# 1714 \"lib/read.ml\"\n\n \n# 1715 \"lib/read.ml\"\n | 4 ->\n\n# 446 \"lib/read.mll\"\n \n# 446 \"lib/read.mll\"\n ( long_error \"Expected 'true' or 'false' but found\" v lexbuf )\n\n# 1719 \"lib/read.ml\"\n\n \n# 1720 \"lib/read.ml\"\n | 5 ->\n\n# 447 \"lib/read.mll\"\n \n# 447 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1724 \"lib/read.ml\"\n\n \n# 1725 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_bool_rec v lexbuf __ocaml_lex_state\n\nand read_int v lexbuf =\n __ocaml_lex_read_int_rec v lexbuf 176\nand __ocaml_lex_read_int_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 450 \"lib/read.mll\"\n \n# 450 \"lib/read.mll\"\n ( try extract_positive_int lexbuf\n with Int_overflow ->\n lexer_error \"Int overflow\" v lexbuf )\n\n# 1738 \"lib/read.ml\"\n\n \n# 1739 \"lib/read.ml\"\n | 1 ->\n\n# 453 \"lib/read.mll\"\n \n# 453 \"lib/read.mll\"\n ( try extract_negative_int lexbuf\n with Int_overflow ->\n lexer_error \"Int overflow\" v lexbuf )\n\n# 1745 \"lib/read.ml\"\n\n \n# 1746 \"lib/read.ml\"\n | 2 ->\n\n# 456 \"lib/read.mll\"\n \n# 456 \"lib/read.mll\"\n ( (* Support for double-quoted \"ints\" *)\n Bi_outbuf.clear v.buf;\n let s = finish_string v lexbuf in\n try\n (* Any OCaml-compliant int will pass,\n including hexadecimal and octal notations,\n and embedded underscores *)\n int_of_string s\n with _ ->\n custom_error\n \"Expected an integer but found a string that \\\n doesn't even represent an integer\"\n v lexbuf\n )\n\n# 1763 \"lib/read.ml\"\n\n \n# 1764 \"lib/read.ml\"\n | 3 ->\n\n# 470 \"lib/read.mll\"\n \n# 470 \"lib/read.mll\"\n ( long_error \"Expected integer but found\" v lexbuf )\n\n# 1768 \"lib/read.ml\"\n\n \n# 1769 \"lib/read.ml\"\n | 4 ->\n\n# 471 \"lib/read.mll\"\n \n# 471 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1773 \"lib/read.ml\"\n\n \n# 1774 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_int_rec v lexbuf __ocaml_lex_state\n\nand read_int32 v lexbuf =\n __ocaml_lex_read_int32_rec v lexbuf 185\nand __ocaml_lex_read_int32_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 474 \"lib/read.mll\"\n \n# 474 \"lib/read.mll\"\n ( try Int32.of_string (Lexing.lexeme lexbuf)\n with _ ->\n lexer_error \"Int32 overflow\" v lexbuf )\n\n# 1787 \"lib/read.ml\"\n\n \n# 1788 \"lib/read.ml\"\n | 1 ->\n\n# 477 \"lib/read.mll\"\n \n# 477 \"lib/read.mll\"\n ( (* Support for double-quoted \"ints\" *)\n Bi_outbuf.clear v.buf;\n let s = finish_string v lexbuf in\n try\n (* Any OCaml-compliant int will pass,\n including hexadecimal and octal notations,\n and embedded underscores *)\n Int32.of_string s\n with _ ->\n custom_error\n \"Expected an int32 but found a string that \\\n doesn't even represent an integer\"\n v lexbuf\n )\n\n# 1805 \"lib/read.ml\"\n\n \n# 1806 \"lib/read.ml\"\n | 2 ->\n\n# 491 \"lib/read.mll\"\n \n# 491 \"lib/read.mll\"\n ( long_error \"Expected int32 but found\" v lexbuf )\n\n# 1810 \"lib/read.ml\"\n\n \n# 1811 \"lib/read.ml\"\n | 3 ->\n\n# 492 \"lib/read.mll\"\n \n# 492 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1815 \"lib/read.ml\"\n\n \n# 1816 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_int32_rec v lexbuf __ocaml_lex_state\n\nand read_int64 v lexbuf =\n __ocaml_lex_read_int64_rec v lexbuf 192\nand __ocaml_lex_read_int64_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 495 \"lib/read.mll\"\n \n# 495 \"lib/read.mll\"\n ( try Int64.of_string (Lexing.lexeme lexbuf)\n with _ ->\n lexer_error \"Int32 overflow\" v lexbuf )\n\n# 1829 \"lib/read.ml\"\n\n \n# 1830 \"lib/read.ml\"\n | 1 ->\n\n# 498 \"lib/read.mll\"\n \n# 498 \"lib/read.mll\"\n ( (* Support for double-quoted \"ints\" *)\n Bi_outbuf.clear v.buf;\n let s = finish_string v lexbuf in\n try\n (* Any OCaml-compliant int will pass,\n including hexadecimal and octal notations,\n and embedded underscores *)\n Int64.of_string s\n with _ ->\n custom_error\n \"Expected an int64 but found a string that \\\n doesn't even represent an integer\"\n v lexbuf\n )\n\n# 1847 \"lib/read.ml\"\n\n \n# 1848 \"lib/read.ml\"\n | 2 ->\n\n# 512 \"lib/read.mll\"\n \n# 512 \"lib/read.mll\"\n ( long_error \"Expected int64 but found\" v lexbuf )\n\n# 1852 \"lib/read.ml\"\n\n \n# 1853 \"lib/read.ml\"\n | 3 ->\n\n# 513 \"lib/read.mll\"\n \n# 513 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1857 \"lib/read.ml\"\n\n \n# 1858 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_int64_rec v lexbuf __ocaml_lex_state\n\nand read_number v lexbuf =\n __ocaml_lex_read_number_rec v lexbuf 199\nand __ocaml_lex_read_number_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 516 \"lib/read.mll\"\n \n# 516 \"lib/read.mll\"\n ( nan )\n\n# 1869 \"lib/read.ml\"\n\n \n# 1870 \"lib/read.ml\"\n | 1 ->\n\n# 517 \"lib/read.mll\"\n \n# 517 \"lib/read.mll\"\n ( infinity )\n\n# 1874 \"lib/read.ml\"\n\n \n# 1875 \"lib/read.ml\"\n | 2 ->\n\n# 518 \"lib/read.mll\"\n \n# 518 \"lib/read.mll\"\n ( neg_infinity )\n\n# 1879 \"lib/read.ml\"\n\n \n# 1880 \"lib/read.ml\"\n | 3 ->\n\n# 519 \"lib/read.mll\"\n \n# 519 \"lib/read.mll\"\n ( float_of_string (lexeme lexbuf) )\n\n# 1884 \"lib/read.ml\"\n\n \n# 1885 \"lib/read.ml\"\n | 4 ->\n\n# 520 \"lib/read.mll\"\n \n# 520 \"lib/read.mll\"\n ( Bi_outbuf.clear v.buf;\n let s = finish_string v lexbuf in\n try\n (* Any OCaml-compliant float will pass,\n including hexadecimal and octal notations,\n and embedded underscores. *)\n float_of_string s\n with _ ->\n match s with\n \"NaN\" -> nan\n | \"Infinity\" -> infinity\n | \"-Infinity\" -> neg_infinity\n | _ ->\n custom_error\n \"Expected a number but found a string that \\\n doesn't even represent a number\"\n v lexbuf\n )\n\n# 1906 \"lib/read.ml\"\n\n \n# 1907 \"lib/read.ml\"\n | 5 ->\n\n# 538 \"lib/read.mll\"\n \n# 538 \"lib/read.mll\"\n ( long_error \"Expected number but found\" v lexbuf )\n\n# 1911 \"lib/read.ml\"\n\n \n# 1912 \"lib/read.ml\"\n | 6 ->\n\n# 539 \"lib/read.mll\"\n \n# 539 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1916 \"lib/read.ml\"\n\n \n# 1917 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_number_rec v lexbuf __ocaml_lex_state\n\nand read_string v lexbuf =\n __ocaml_lex_read_string_rec v lexbuf 233\nand __ocaml_lex_read_string_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 542 \"lib/read.mll\"\n \n# 542 \"lib/read.mll\"\n ( Bi_outbuf.clear v.buf;\n finish_string v lexbuf )\n\n# 1929 \"lib/read.ml\"\n\n \n# 1930 \"lib/read.ml\"\n | 1 ->\n\n# 544 \"lib/read.mll\"\n \n# 544 \"lib/read.mll\"\n ( long_error \"Expected '\\\"' but found\" v lexbuf )\n\n# 1934 \"lib/read.ml\"\n\n \n# 1935 \"lib/read.ml\"\n | 2 ->\n\n# 545 \"lib/read.mll\"\n \n# 545 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1939 \"lib/read.ml\"\n\n \n# 1940 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_string_rec v lexbuf __ocaml_lex_state\n\nand read_ident v lexbuf =\n __ocaml_lex_read_ident_rec v lexbuf 237\nand __ocaml_lex_read_ident_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 548 \"lib/read.mll\"\n \n# 548 \"lib/read.mll\"\n ( Bi_outbuf.clear v.buf;\n finish_string v lexbuf )\n\n# 1952 \"lib/read.ml\"\n\n \n# 1953 \"lib/read.ml\"\n | 1 ->\nlet\n\n# 550 \"lib/read.mll\"\n \n# 550 \"lib/read.mll\"\n s\n\n# 1958 \"lib/read.ml\"\n# 1958 \"lib/read.ml\"\n= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos lexbuf.Lexing.lex_curr_pos in\n\n# 551 \"lib/read.mll\"\n \n# 551 \"lib/read.mll\"\n ( s )\n\n# 1962 \"lib/read.ml\"\n\n \n# 1963 \"lib/read.ml\"\n | 2 ->\n\n# 552 \"lib/read.mll\"\n \n# 552 \"lib/read.mll\"\n ( long_error \"Expected string or identifier but found\" v lexbuf )\n\n# 1967 \"lib/read.ml\"\n\n \n# 1968 \"lib/read.ml\"\n | 3 ->\n\n# 553 \"lib/read.mll\"\n \n# 553 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1972 \"lib/read.ml\"\n\n \n# 1973 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_ident_rec v lexbuf __ocaml_lex_state\n\nand map_ident v f lexbuf =\n __ocaml_lex_map_ident_rec v f lexbuf 242\nand __ocaml_lex_map_ident_rec v f lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 556 \"lib/read.mll\"\n \n# 556 \"lib/read.mll\"\n ( Bi_outbuf.clear v.buf;\n map_string v f lexbuf )\n\n# 1985 \"lib/read.ml\"\n\n \n# 1986 \"lib/read.ml\"\n | 1 ->\n\n# 559 \"lib/read.mll\"\n \n# 559 \"lib/read.mll\"\n ( map_lexeme f lexbuf )\n\n# 1990 \"lib/read.ml\"\n\n \n# 1991 \"lib/read.ml\"\n | 2 ->\n\n# 560 \"lib/read.mll\"\n \n# 560 \"lib/read.mll\"\n ( long_error \"Expected string or identifier but found\" v lexbuf )\n\n# 1995 \"lib/read.ml\"\n\n \n# 1996 \"lib/read.ml\"\n | 3 ->\n\n# 561 \"lib/read.mll\"\n \n# 561 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2000 \"lib/read.ml\"\n\n \n# 2001 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_map_ident_rec v f lexbuf __ocaml_lex_state\n\nand read_sequence read_cell init_acc v lexbuf =\n __ocaml_lex_read_sequence_rec read_cell init_acc v lexbuf 247\nand __ocaml_lex_read_sequence_rec read_cell init_acc v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 564 \"lib/read.mll\"\n \n# 564 \"lib/read.mll\"\n ( let acc = ref init_acc in\n try\n read_space v lexbuf;\n read_array_end lexbuf;\n acc := read_cell !acc v lexbuf;\n while true do\n read_space v lexbuf;\n read_array_sep v lexbuf;\n read_space v lexbuf;\n acc := read_cell !acc v lexbuf;\n done;\n assert false\n with End_of_array ->\n !acc\n )\n\n# 2026 \"lib/read.ml\"\n\n \n# 2027 \"lib/read.ml\"\n | 1 ->\n\n# 579 \"lib/read.mll\"\n \n# 579 \"lib/read.mll\"\n ( long_error \"Expected '[' but found\" v lexbuf )\n\n# 2031 \"lib/read.ml\"\n\n \n# 2032 \"lib/read.ml\"\n | 2 ->\n\n# 580 \"lib/read.mll\"\n \n# 580 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2036 \"lib/read.ml\"\n\n \n# 2037 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_sequence_rec read_cell init_acc v lexbuf __ocaml_lex_state\n\nand read_list_rev read_cell v lexbuf =\n __ocaml_lex_read_list_rev_rec read_cell v lexbuf 251\nand __ocaml_lex_read_list_rev_rec read_cell v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 583 \"lib/read.mll\"\n \n# 583 \"lib/read.mll\"\n ( let acc = ref [] in\n try\n read_space v lexbuf;\n read_array_end lexbuf;\n acc := read_cell v lexbuf :: !acc;\n while true do\n read_space v lexbuf;\n read_array_sep v lexbuf;\n read_space v lexbuf;\n acc := read_cell v lexbuf :: !acc;\n done;\n assert false\n with End_of_array ->\n !acc\n )\n\n# 2062 \"lib/read.ml\"\n\n \n# 2063 \"lib/read.ml\"\n | 1 ->\n\n# 598 \"lib/read.mll\"\n \n# 598 \"lib/read.mll\"\n ( long_error \"Expected '[' but found\" v lexbuf )\n\n# 2067 \"lib/read.ml\"\n\n \n# 2068 \"lib/read.ml\"\n | 2 ->\n\n# 599 \"lib/read.mll\"\n \n# 599 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2072 \"lib/read.ml\"\n\n \n# 2073 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_list_rev_rec read_cell v lexbuf __ocaml_lex_state\n\nand read_array_end lexbuf =\n __ocaml_lex_read_array_end_rec lexbuf 255\nand __ocaml_lex_read_array_end_rec lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 602 \"lib/read.mll\"\n \n# 602 \"lib/read.mll\"\n ( raise End_of_array )\n\n# 2084 \"lib/read.ml\"\n\n \n# 2085 \"lib/read.ml\"\n | 1 ->\n\n# 603 \"lib/read.mll\"\n \n# 603 \"lib/read.mll\"\n ( () )\n\n# 2089 \"lib/read.ml\"\n\n \n# 2090 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_array_end_rec lexbuf __ocaml_lex_state\n\nand read_array_sep v lexbuf =\n __ocaml_lex_read_array_sep_rec v lexbuf 257\nand __ocaml_lex_read_array_sep_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 606 \"lib/read.mll\"\n \n# 606 \"lib/read.mll\"\n ( () )\n\n# 2101 \"lib/read.ml\"\n\n \n# 2102 \"lib/read.ml\"\n | 1 ->\n\n# 607 \"lib/read.mll\"\n \n# 607 \"lib/read.mll\"\n ( raise End_of_array )\n\n# 2106 \"lib/read.ml\"\n\n \n# 2107 \"lib/read.ml\"\n | 2 ->\n\n# 608 \"lib/read.mll\"\n \n# 608 \"lib/read.mll\"\n ( long_error \"Expected ',' or ']' but found\" v lexbuf )\n\n# 2111 \"lib/read.ml\"\n\n \n# 2112 \"lib/read.ml\"\n | 3 ->\n\n# 609 \"lib/read.mll\"\n \n# 609 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2116 \"lib/read.ml\"\n\n \n# 2117 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_array_sep_rec v lexbuf __ocaml_lex_state\n\nand read_tuple read_cell init_acc v lexbuf =\n __ocaml_lex_read_tuple_rec read_cell init_acc v lexbuf 262\nand __ocaml_lex_read_tuple_rec read_cell init_acc v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 613 \"lib/read.mll\"\n \n# 613 \"lib/read.mll\"\n (\n \n# 615 \"lib/read.mll\"\n let pos = ref 0 in\n let acc = ref init_acc in\n try\n read_space v lexbuf;\n read_tuple_end lexbuf;\n acc := read_cell !pos !acc v lexbuf;\n incr pos;\n while true do\n read_space v lexbuf;\n read_tuple_sep v lexbuf;\n read_space v lexbuf;\n acc := read_cell !pos !acc v lexbuf;\n incr pos;\n done;\n assert false\n with End_of_tuple ->\n !acc\n \n# 635 \"lib/read.mll\"\n )\n\n# 2150 \"lib/read.ml\"\n\n \n# 2151 \"lib/read.ml\"\n | 1 ->\n\n# 636 \"lib/read.mll\"\n \n# 636 \"lib/read.mll\"\n ( long_error \"Expected ')' but found\" v lexbuf )\n\n# 2155 \"lib/read.ml\"\n\n \n# 2156 \"lib/read.ml\"\n | 2 ->\n\n# 637 \"lib/read.mll\"\n \n# 637 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2160 \"lib/read.ml\"\n\n \n# 2161 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_tuple_rec read_cell init_acc v lexbuf __ocaml_lex_state\n\nand read_tuple_end lexbuf =\n __ocaml_lex_read_tuple_end_rec lexbuf 266\nand __ocaml_lex_read_tuple_end_rec lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 640 \"lib/read.mll\"\n \n# 640 \"lib/read.mll\"\n ( raise End_of_tuple )\n\n# 2172 \"lib/read.ml\"\n\n \n# 2173 \"lib/read.ml\"\n | 1 ->\n\n# 641 \"lib/read.mll\"\n \n# 641 \"lib/read.mll\"\n ( () )\n\n# 2177 \"lib/read.ml\"\n\n \n# 2178 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_tuple_end_rec lexbuf __ocaml_lex_state\n\nand read_tuple_end2 v std lexbuf =\n __ocaml_lex_read_tuple_end2_rec v std lexbuf 268\nand __ocaml_lex_read_tuple_end2_rec v std lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 644 \"lib/read.mll\"\n \n# 644 \"lib/read.mll\"\n ( if std then\n long_error \"Expected ')' or '' but found\" v lexbuf\n else\n raise End_of_tuple )\n\n# 2192 \"lib/read.ml\"\n\n \n# 2193 \"lib/read.ml\"\n | 1 ->\n\n# 648 \"lib/read.mll\"\n \n# 648 \"lib/read.mll\"\n ( if std then\n raise End_of_tuple\n else\n long_error \"Expected ']' or '' but found\" v lexbuf )\n\n# 2200 \"lib/read.ml\"\n\n \n# 2201 \"lib/read.ml\"\n | 2 ->\n\n# 652 \"lib/read.mll\"\n \n# 652 \"lib/read.mll\"\n ( () )\n\n# 2205 \"lib/read.ml\"\n\n \n# 2206 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_tuple_end2_rec v std lexbuf __ocaml_lex_state\n\nand read_tuple_sep v lexbuf =\n __ocaml_lex_read_tuple_sep_rec v lexbuf 271\nand __ocaml_lex_read_tuple_sep_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 655 \"lib/read.mll\"\n \n# 655 \"lib/read.mll\"\n ( () )\n\n# 2217 \"lib/read.ml\"\n\n \n# 2218 \"lib/read.ml\"\n | 1 ->\n\n# 656 \"lib/read.mll\"\n \n# 656 \"lib/read.mll\"\n ( raise End_of_tuple )\n\n# 2222 \"lib/read.ml\"\n\n \n# 2223 \"lib/read.ml\"\n | 2 ->\n\n# 657 \"lib/read.mll\"\n \n# 657 \"lib/read.mll\"\n ( long_error \"Expected ',' or ')' but found\" v lexbuf )\n\n# 2227 \"lib/read.ml\"\n\n \n# 2228 \"lib/read.ml\"\n | 3 ->\n\n# 658 \"lib/read.mll\"\n \n# 658 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2232 \"lib/read.ml\"\n\n \n# 2233 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_tuple_sep_rec v lexbuf __ocaml_lex_state\n\nand read_tuple_sep2 v std lexbuf =\n __ocaml_lex_read_tuple_sep2_rec v std lexbuf 276\nand __ocaml_lex_read_tuple_sep2_rec v std lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 661 \"lib/read.mll\"\n \n# 661 \"lib/read.mll\"\n ( () )\n\n# 2244 \"lib/read.ml\"\n\n \n# 2245 \"lib/read.ml\"\n | 1 ->\n\n# 662 \"lib/read.mll\"\n \n# 662 \"lib/read.mll\"\n ( if std then\n long_error \"Expected ',' or ']' but found\" v lexbuf\n else\n raise End_of_tuple )\n\n# 2252 \"lib/read.ml\"\n\n \n# 2253 \"lib/read.ml\"\n | 2 ->\n\n# 666 \"lib/read.mll\"\n \n# 666 \"lib/read.mll\"\n ( if std then\n raise End_of_tuple\n else\n long_error \"Expected ',' or ')' but found\" v lexbuf )\n\n# 2260 \"lib/read.ml\"\n\n \n# 2261 \"lib/read.ml\"\n | 3 ->\n\n# 670 \"lib/read.mll\"\n \n# 670 \"lib/read.mll\"\n ( long_error \"Expected ',' or ')' but found\" v lexbuf )\n\n# 2265 \"lib/read.ml\"\n\n \n# 2266 \"lib/read.ml\"\n | 4 ->\n\n# 671 \"lib/read.mll\"\n \n# 671 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2270 \"lib/read.ml\"\n\n \n# 2271 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_tuple_sep2_rec v std lexbuf __ocaml_lex_state\n\nand read_abstract_fields read_key read_field init_acc v lexbuf =\n __ocaml_lex_read_abstract_fields_rec read_key read_field init_acc v lexbuf 282\nand __ocaml_lex_read_abstract_fields_rec read_key read_field init_acc v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 675 \"lib/read.mll\"\n \n# 675 \"lib/read.mll\"\n ( let acc = ref init_acc in\n try\n read_space v lexbuf;\n read_object_end lexbuf;\n let field_name = read_key v lexbuf in\n read_space v lexbuf;\n read_colon v lexbuf;\n read_space v lexbuf;\n acc := read_field !acc field_name v lexbuf;\n while true do\n read_space v lexbuf;\n read_object_sep v lexbuf;\n read_space v lexbuf;\n let field_name = read_key v lexbuf in\n read_space v lexbuf;\n read_colon v lexbuf;\n read_space v lexbuf;\n acc := read_field !acc field_name v lexbuf;\n done;\n assert false\n with End_of_object ->\n !acc\n )\n\n# 2304 \"lib/read.ml\"\n\n \n# 2305 \"lib/read.ml\"\n | 1 ->\n\n# 698 \"lib/read.mll\"\n \n# 698 \"lib/read.mll\"\n ( long_error \"Expected '{' but found\" v lexbuf )\n\n# 2309 \"lib/read.ml\"\n\n \n# 2310 \"lib/read.ml\"\n | 2 ->\n\n# 699 \"lib/read.mll\"\n \n# 699 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2314 \"lib/read.ml\"\n\n \n# 2315 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_abstract_fields_rec read_key read_field init_acc v lexbuf __ocaml_lex_state\n\nand read_lcurl v lexbuf =\n __ocaml_lex_read_lcurl_rec v lexbuf 286\nand __ocaml_lex_read_lcurl_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 702 \"lib/read.mll\"\n \n# 702 \"lib/read.mll\"\n ( () )\n\n# 2326 \"lib/read.ml\"\n\n \n# 2327 \"lib/read.ml\"\n | 1 ->\n\n# 703 \"lib/read.mll\"\n \n# 703 \"lib/read.mll\"\n ( long_error \"Expected '{' but found\" v lexbuf )\n\n# 2331 \"lib/read.ml\"\n\n \n# 2332 \"lib/read.ml\"\n | 2 ->\n\n# 704 \"lib/read.mll\"\n \n# 704 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2336 \"lib/read.ml\"\n\n \n# 2337 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_lcurl_rec v lexbuf __ocaml_lex_state\n\nand read_object_end lexbuf =\n __ocaml_lex_read_object_end_rec lexbuf 290\nand __ocaml_lex_read_object_end_rec lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 707 \"lib/read.mll\"\n \n# 707 \"lib/read.mll\"\n ( raise End_of_object )\n\n# 2348 \"lib/read.ml\"\n\n \n# 2349 \"lib/read.ml\"\n | 1 ->\n\n# 708 \"lib/read.mll\"\n \n# 708 \"lib/read.mll\"\n ( () )\n\n# 2353 \"lib/read.ml\"\n\n \n# 2354 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_object_end_rec lexbuf __ocaml_lex_state\n\nand read_object_sep v lexbuf =\n __ocaml_lex_read_object_sep_rec v lexbuf 292\nand __ocaml_lex_read_object_sep_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 711 \"lib/read.mll\"\n \n# 711 \"lib/read.mll\"\n ( () )\n\n# 2365 \"lib/read.ml\"\n\n \n# 2366 \"lib/read.ml\"\n | 1 ->\n\n# 712 \"lib/read.mll\"\n \n# 712 \"lib/read.mll\"\n ( raise End_of_object )\n\n# 2370 \"lib/read.ml\"\n\n \n# 2371 \"lib/read.ml\"\n | 2 ->\n\n# 713 \"lib/read.mll\"\n \n# 713 \"lib/read.mll\"\n ( long_error \"Expected ',' or '}' but found\" v lexbuf )\n\n# 2375 \"lib/read.ml\"\n\n \n# 2376 \"lib/read.ml\"\n | 3 ->\n\n# 714 \"lib/read.mll\"\n \n# 714 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2380 \"lib/read.ml\"\n\n \n# 2381 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_object_sep_rec v lexbuf __ocaml_lex_state\n\nand read_colon v lexbuf =\n __ocaml_lex_read_colon_rec v lexbuf 297\nand __ocaml_lex_read_colon_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 717 \"lib/read.mll\"\n \n# 717 \"lib/read.mll\"\n ( () )\n\n# 2392 \"lib/read.ml\"\n\n \n# 2393 \"lib/read.ml\"\n | 1 ->\n\n# 718 \"lib/read.mll\"\n \n# 718 \"lib/read.mll\"\n ( long_error \"Expected ':' but found\" v lexbuf )\n\n# 2397 \"lib/read.ml\"\n\n \n# 2398 \"lib/read.ml\"\n | 2 ->\n\n# 719 \"lib/read.mll\"\n \n# 719 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2402 \"lib/read.ml\"\n\n \n# 2403 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_colon_rec v lexbuf __ocaml_lex_state\n\nand start_any_tuple v lexbuf =\n __ocaml_lex_start_any_tuple_rec v lexbuf 301\nand __ocaml_lex_start_any_tuple_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 722 \"lib/read.mll\"\n \n# 722 \"lib/read.mll\"\n ( false )\n\n# 2414 \"lib/read.ml\"\n\n \n# 2415 \"lib/read.ml\"\n | 1 ->\n\n# 723 \"lib/read.mll\"\n \n# 723 \"lib/read.mll\"\n ( true )\n\n# 2419 \"lib/read.ml\"\n\n \n# 2420 \"lib/read.ml\"\n | 2 ->\n\n# 724 \"lib/read.mll\"\n \n# 724 \"lib/read.mll\"\n ( long_error \"Expected '(' or '[' but found\" v lexbuf )\n\n# 2424 \"lib/read.ml\"\n\n \n# 2425 \"lib/read.ml\"\n | 3 ->\n\n# 725 \"lib/read.mll\"\n \n# 725 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2429 \"lib/read.ml\"\n\n \n# 2430 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_start_any_tuple_rec v lexbuf __ocaml_lex_state\n\nand read_lpar v lexbuf =\n __ocaml_lex_read_lpar_rec v lexbuf 306\nand __ocaml_lex_read_lpar_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 728 \"lib/read.mll\"\n \n# 728 \"lib/read.mll\"\n ( () )\n\n# 2441 \"lib/read.ml\"\n\n \n# 2442 \"lib/read.ml\"\n | 1 ->\n\n# 729 \"lib/read.mll\"\n \n# 729 \"lib/read.mll\"\n ( long_error \"Expected '(' but found\" v lexbuf )\n\n# 2446 \"lib/read.ml\"\n\n \n# 2447 \"lib/read.ml\"\n | 2 ->\n\n# 730 \"lib/read.mll\"\n \n# 730 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2451 \"lib/read.ml\"\n\n \n# 2452 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_lpar_rec v lexbuf __ocaml_lex_state\n\nand read_rpar v lexbuf =\n __ocaml_lex_read_rpar_rec v lexbuf 310\nand __ocaml_lex_read_rpar_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 733 \"lib/read.mll\"\n \n# 733 \"lib/read.mll\"\n ( () )\n\n# 2463 \"lib/read.ml\"\n\n \n# 2464 \"lib/read.ml\"\n | 1 ->\n\n# 734 \"lib/read.mll\"\n \n# 734 \"lib/read.mll\"\n ( long_error \"Expected ')' but found\" v lexbuf )\n\n# 2468 \"lib/read.ml\"\n\n \n# 2469 \"lib/read.ml\"\n | 2 ->\n\n# 735 \"lib/read.mll\"\n \n# 735 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2473 \"lib/read.ml\"\n\n \n# 2474 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_rpar_rec v lexbuf __ocaml_lex_state\n\nand read_lbr v lexbuf =\n __ocaml_lex_read_lbr_rec v lexbuf 314\nand __ocaml_lex_read_lbr_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 738 \"lib/read.mll\"\n \n# 738 \"lib/read.mll\"\n ( () )\n\n# 2485 \"lib/read.ml\"\n\n \n# 2486 \"lib/read.ml\"\n | 1 ->\n\n# 739 \"lib/read.mll\"\n \n# 739 \"lib/read.mll\"\n ( long_error \"Expected '[' but found\" v lexbuf )\n\n# 2490 \"lib/read.ml\"\n\n \n# 2491 \"lib/read.ml\"\n | 2 ->\n\n# 740 \"lib/read.mll\"\n \n# 740 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2495 \"lib/read.ml\"\n\n \n# 2496 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_lbr_rec v lexbuf __ocaml_lex_state\n\nand read_rbr v lexbuf =\n __ocaml_lex_read_rbr_rec v lexbuf 318\nand __ocaml_lex_read_rbr_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 743 \"lib/read.mll\"\n \n# 743 \"lib/read.mll\"\n ( () )\n\n# 2507 \"lib/read.ml\"\n\n \n# 2508 \"lib/read.ml\"\n | 1 ->\n\n# 744 \"lib/read.mll\"\n \n# 744 \"lib/read.mll\"\n ( long_error \"Expected ']' but found\" v lexbuf )\n\n# 2512 \"lib/read.ml\"\n\n \n# 2513 \"lib/read.ml\"\n | 2 ->\n\n# 745 \"lib/read.mll\"\n \n# 745 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2517 \"lib/read.ml\"\n\n \n# 2518 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_rbr_rec v lexbuf __ocaml_lex_state\n\nand skip_json v lexbuf =\n __ocaml_lex_skip_json_rec v lexbuf 322\nand __ocaml_lex_skip_json_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 751 \"lib/read.mll\"\n \n# 751 \"lib/read.mll\"\n ( () )\n\n# 2529 \"lib/read.ml\"\n\n \n# 2530 \"lib/read.ml\"\n | 1 ->\n\n# 752 \"lib/read.mll\"\n \n# 752 \"lib/read.mll\"\n ( () )\n\n# 2534 \"lib/read.ml\"\n\n \n# 2535 \"lib/read.ml\"\n | 2 ->\n\n# 753 \"lib/read.mll\"\n \n# 753 \"lib/read.mll\"\n ( () )\n\n# 2539 \"lib/read.ml\"\n\n \n# 2540 \"lib/read.ml\"\n | 3 ->\n\n# 754 \"lib/read.mll\"\n \n# 754 \"lib/read.mll\"\n ( () )\n\n# 2544 \"lib/read.ml\"\n\n \n# 2545 \"lib/read.ml\"\n | 4 ->\n\n# 755 \"lib/read.mll\"\n \n# 755 \"lib/read.mll\"\n ( () )\n\n# 2549 \"lib/read.ml\"\n\n \n# 2550 \"lib/read.ml\"\n | 5 ->\n\n# 756 \"lib/read.mll\"\n \n# 756 \"lib/read.mll\"\n ( () )\n\n# 2554 \"lib/read.ml\"\n\n \n# 2555 \"lib/read.ml\"\n | 6 ->\n\n# 757 \"lib/read.mll\"\n \n# 757 \"lib/read.mll\"\n ( finish_skip_stringlit v lexbuf )\n\n# 2559 \"lib/read.ml\"\n\n \n# 2560 \"lib/read.ml\"\n | 7 ->\n\n# 758 \"lib/read.mll\"\n \n# 758 \"lib/read.mll\"\n ( () )\n\n# 2564 \"lib/read.ml\"\n\n \n# 2565 \"lib/read.ml\"\n | 8 ->\n\n# 759 \"lib/read.mll\"\n \n# 759 \"lib/read.mll\"\n ( () )\n\n# 2569 \"lib/read.ml\"\n\n \n# 2570 \"lib/read.ml\"\n | 9 ->\n\n# 761 \"lib/read.mll\"\n \n# 761 \"lib/read.mll\"\n ( try\n read_space v lexbuf;\n read_object_end lexbuf;\n skip_ident v lexbuf;\n read_space v lexbuf;\n read_colon v lexbuf;\n read_space v lexbuf;\n skip_json v lexbuf;\n while true do\n read_space v lexbuf;\n read_object_sep v lexbuf;\n read_space v lexbuf;\n skip_ident v lexbuf;\n read_space v lexbuf;\n read_colon v lexbuf;\n read_space v lexbuf;\n skip_json v lexbuf;\n done;\n assert false\n with End_of_object ->\n ()\n )\n\n# 2595 \"lib/read.ml\"\n\n \n# 2596 \"lib/read.ml\"\n | 10 ->\n\n# 784 \"lib/read.mll\"\n \n# 784 \"lib/read.mll\"\n ( try\n read_space v lexbuf;\n read_array_end lexbuf;\n skip_json v lexbuf;\n while true do\n read_space v lexbuf;\n read_array_sep v lexbuf;\n read_space v lexbuf;\n skip_json v lexbuf;\n done;\n assert false\n with End_of_array ->\n ()\n )\n\n# 2613 \"lib/read.ml\"\n\n \n# 2614 \"lib/read.ml\"\n | 11 ->\n\n# 799 \"lib/read.mll\"\n \n# 799 \"lib/read.mll\"\n (\n \n# 801 \"lib/read.mll\"\n try\n read_space v lexbuf;\n read_tuple_end lexbuf;\n skip_json v lexbuf;\n while true do\n read_space v lexbuf;\n read_tuple_sep v lexbuf;\n read_space v lexbuf;\n skip_json v lexbuf;\n done;\n assert false\n with End_of_tuple ->\n ()\n \n# 817 \"lib/read.mll\"\n )\n\n# 2636 \"lib/read.ml\"\n\n \n# 2637 \"lib/read.ml\"\n | 12 ->\n\n# 819 \"lib/read.mll\"\n \n# 819 \"lib/read.mll\"\n (\n \n# 821 \"lib/read.mll\"\n read_space v lexbuf;\n skip_ident v lexbuf;\n read_space v lexbuf;\n finish_skip_variant v lexbuf\n \n# 828 \"lib/read.mll\"\n )\n\n# 2650 \"lib/read.ml\"\n\n \n# 2651 \"lib/read.ml\"\n | 13 ->\n\n# 830 \"lib/read.mll\"\n \n# 830 \"lib/read.mll\"\n ( skip_json v lexbuf )\n\n# 2655 \"lib/read.ml\"\n\n \n# 2656 \"lib/read.ml\"\n | 14 ->\n\n# 831 \"lib/read.mll\"\n \n# 831 \"lib/read.mll\"\n ( finish_comment v lexbuf; skip_json v lexbuf )\n\n# 2660 \"lib/read.ml\"\n\n \n# 2661 \"lib/read.ml\"\n | 15 ->\n\n# 832 \"lib/read.mll\"\n \n# 832 \"lib/read.mll\"\n ( newline v lexbuf; skip_json v lexbuf )\n\n# 2665 \"lib/read.ml\"\n\n \n# 2666 \"lib/read.ml\"\n | 16 ->\n\n# 833 \"lib/read.mll\"\n \n# 833 \"lib/read.mll\"\n ( skip_json v lexbuf )\n\n# 2670 \"lib/read.ml\"\n\n \n# 2671 \"lib/read.ml\"\n | 17 ->\n\n# 834 \"lib/read.mll\"\n \n# 834 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2675 \"lib/read.ml\"\n\n \n# 2676 \"lib/read.ml\"\n | 18 ->\n\n# 835 \"lib/read.mll\"\n \n# 835 \"lib/read.mll\"\n ( long_error \"Invalid token\" v lexbuf )\n\n# 2680 \"lib/read.ml\"\n\n \n# 2681 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_skip_json_rec v lexbuf __ocaml_lex_state\n\nand finish_skip_stringlit v lexbuf =\n __ocaml_lex_finish_skip_stringlit_rec v lexbuf 378\nand __ocaml_lex_finish_skip_stringlit_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 841 \"lib/read.mll\"\n \n# 841 \"lib/read.mll\"\n ( () )\n\n# 2692 \"lib/read.ml\"\n\n \n# 2693 \"lib/read.ml\"\n | 1 ->\n\n# 842 \"lib/read.mll\"\n \n# 842 \"lib/read.mll\"\n ( long_error \"Invalid string literal\" v lexbuf )\n\n# 2697 \"lib/read.ml\"\n\n \n# 2698 \"lib/read.ml\"\n | 2 ->\n\n# 843 \"lib/read.mll\"\n \n# 843 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2702 \"lib/read.ml\"\n\n \n# 2703 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_skip_stringlit_rec v lexbuf __ocaml_lex_state\n\nand finish_skip_variant v lexbuf =\n __ocaml_lex_finish_skip_variant_rec v lexbuf 389\nand __ocaml_lex_finish_skip_variant_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 846 \"lib/read.mll\"\n \n# 846 \"lib/read.mll\"\n ( skip_json v lexbuf;\n read_space v lexbuf;\n read_gt v lexbuf )\n\n# 2716 \"lib/read.ml\"\n\n \n# 2717 \"lib/read.ml\"\n | 1 ->\n\n# 849 \"lib/read.mll\"\n \n# 849 \"lib/read.mll\"\n ( () )\n\n# 2721 \"lib/read.ml\"\n\n \n# 2722 \"lib/read.ml\"\n | 2 ->\n\n# 850 \"lib/read.mll\"\n \n# 850 \"lib/read.mll\"\n ( long_error \"Expected ':' or '>' but found\" v lexbuf )\n\n# 2726 \"lib/read.ml\"\n\n \n# 2727 \"lib/read.ml\"\n | 3 ->\n\n# 851 \"lib/read.mll\"\n \n# 851 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2731 \"lib/read.ml\"\n\n \n# 2732 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_skip_variant_rec v lexbuf __ocaml_lex_state\n\nand skip_ident v lexbuf =\n __ocaml_lex_skip_ident_rec v lexbuf 394\nand __ocaml_lex_skip_ident_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 854 \"lib/read.mll\"\n \n# 854 \"lib/read.mll\"\n ( finish_skip_stringlit v lexbuf )\n\n# 2743 \"lib/read.ml\"\n\n \n# 2744 \"lib/read.ml\"\n | 1 ->\n\n# 855 \"lib/read.mll\"\n \n# 855 \"lib/read.mll\"\n ( () )\n\n# 2748 \"lib/read.ml\"\n\n \n# 2749 \"lib/read.ml\"\n | 2 ->\n\n# 856 \"lib/read.mll\"\n \n# 856 \"lib/read.mll\"\n ( long_error \"Expected string or identifier but found\" v lexbuf )\n\n# 2753 \"lib/read.ml\"\n\n \n# 2754 \"lib/read.ml\"\n | 3 ->\n\n# 857 \"lib/read.mll\"\n \n# 857 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2758 \"lib/read.ml\"\n\n \n# 2759 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_skip_ident_rec v lexbuf __ocaml_lex_state\n\nand buffer_json v lexbuf =\n __ocaml_lex_buffer_json_rec v lexbuf 399\nand __ocaml_lex_buffer_json_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 870 \"lib/read.mll\"\n \n# 870 \"lib/read.mll\"\n ( add_lexeme v.buf lexbuf )\n\n# 2770 \"lib/read.ml\"\n\n \n# 2771 \"lib/read.ml\"\n | 1 ->\n\n# 872 \"lib/read.mll\"\n \n# 872 \"lib/read.mll\"\n ( finish_buffer_stringlit v lexbuf )\n\n# 2775 \"lib/read.ml\"\n\n \n# 2776 \"lib/read.ml\"\n | 2 ->\n\n# 873 \"lib/read.mll\"\n \n# 873 \"lib/read.mll\"\n ( try\n Bi_outbuf.add_char v.buf '{';\n buffer_space v lexbuf;\n buffer_object_end v lexbuf;\n buffer_ident v lexbuf;\n buffer_space v lexbuf;\n buffer_colon v lexbuf;\n buffer_space v lexbuf;\n buffer_json v lexbuf;\n while true do\n buffer_space v lexbuf;\n buffer_object_sep v lexbuf;\n buffer_space v lexbuf;\n buffer_ident v lexbuf;\n buffer_space v lexbuf;\n buffer_colon v lexbuf;\n buffer_space v lexbuf;\n buffer_json v lexbuf;\n done;\n assert false\n with End_of_object ->\n ()\n )\n\n# 2802 \"lib/read.ml\"\n\n \n# 2803 \"lib/read.ml\"\n | 3 ->\n\n# 897 \"lib/read.mll\"\n \n# 897 \"lib/read.mll\"\n ( try\n Bi_outbuf.add_char v.buf '[';\n buffer_space v lexbuf;\n buffer_array_end v lexbuf;\n buffer_json v lexbuf;\n while true do\n buffer_space v lexbuf;\n buffer_array_sep v lexbuf;\n buffer_space v lexbuf;\n buffer_json v lexbuf;\n done;\n assert false\n with End_of_array ->\n ()\n )\n\n# 2821 \"lib/read.ml\"\n\n \n# 2822 \"lib/read.ml\"\n | 4 ->\n\n# 913 \"lib/read.mll\"\n \n# 913 \"lib/read.mll\"\n (\n \n# 915 \"lib/read.mll\"\n try\n Bi_outbuf.add_char v.buf '(';\n buffer_space v lexbuf;\n buffer_tuple_end v lexbuf;\n buffer_json v lexbuf;\n while true do\n buffer_space v lexbuf;\n buffer_tuple_sep v lexbuf;\n buffer_space v lexbuf;\n buffer_json v lexbuf;\n done;\n assert false\n with End_of_tuple ->\n ()\n \n# 932 \"lib/read.mll\"\n )\n\n# 2845 \"lib/read.ml\"\n\n \n# 2846 \"lib/read.ml\"\n | 5 ->\n\n# 934 \"lib/read.mll\"\n \n# 934 \"lib/read.mll\"\n (\n \n# 936 \"lib/read.mll\"\n Bi_outbuf.add_char v.buf '<';\n buffer_space v lexbuf;\n buffer_ident v lexbuf;\n buffer_space v lexbuf;\n finish_buffer_variant v lexbuf\n \n# 944 \"lib/read.mll\"\n )\n\n# 2860 \"lib/read.ml\"\n\n \n# 2861 \"lib/read.ml\"\n | 6 ->\n\n# 946 \"lib/read.mll\"\n \n# 946 \"lib/read.mll\"\n ( add_lexeme v.buf lexbuf; buffer_json v lexbuf )\n\n# 2865 \"lib/read.ml\"\n\n \n# 2866 \"lib/read.ml\"\n | 7 ->\n\n# 947 \"lib/read.mll\"\n \n# 947 \"lib/read.mll\"\n ( Bi_outbuf.add_string v.buf \"/*\";\n finish_buffer_comment v lexbuf;\n buffer_json v lexbuf )\n\n# 2872 \"lib/read.ml\"\n\n \n# 2873 \"lib/read.ml\"\n | 8 ->\n\n# 950 \"lib/read.mll\"\n \n# 950 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\\n';\n newline v lexbuf;\n buffer_json v lexbuf )\n\n# 2879 \"lib/read.ml\"\n\n \n# 2880 \"lib/read.ml\"\n | 9 ->\n\n# 953 \"lib/read.mll\"\n \n# 953 \"lib/read.mll\"\n ( add_lexeme v.buf lexbuf; buffer_json v lexbuf )\n\n# 2884 \"lib/read.ml\"\n\n \n# 2885 \"lib/read.ml\"\n | 10 ->\n\n# 954 \"lib/read.mll\"\n \n# 954 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2889 \"lib/read.ml\"\n\n \n# 2890 \"lib/read.ml\"\n | 11 ->\n\n# 955 \"lib/read.mll\"\n \n# 955 \"lib/read.mll\"\n ( long_error \"Invalid token\" v lexbuf )\n\n# 2894 \"lib/read.ml\"\n\n \n# 2895 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_json_rec v lexbuf __ocaml_lex_state\n\nand finish_buffer_stringlit v lexbuf =\n __ocaml_lex_finish_buffer_stringlit_rec v lexbuf 450\nand __ocaml_lex_finish_buffer_stringlit_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 961 \"lib/read.mll\"\n \n# 961 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\"';\n add_lexeme v.buf lexbuf\n )\n\n# 2908 \"lib/read.ml\"\n\n \n# 2909 \"lib/read.ml\"\n | 1 ->\n\n# 964 \"lib/read.mll\"\n \n# 964 \"lib/read.mll\"\n ( long_error \"Invalid string literal\" v lexbuf )\n\n# 2913 \"lib/read.ml\"\n\n \n# 2914 \"lib/read.ml\"\n | 2 ->\n\n# 965 \"lib/read.mll\"\n \n# 965 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2918 \"lib/read.ml\"\n\n \n# 2919 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_buffer_stringlit_rec v lexbuf __ocaml_lex_state\n\nand finish_buffer_variant v lexbuf =\n __ocaml_lex_finish_buffer_variant_rec v lexbuf 461\nand __ocaml_lex_finish_buffer_variant_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 968 \"lib/read.mll\"\n \n# 968 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf ':';\n buffer_json v lexbuf;\n buffer_space v lexbuf;\n buffer_gt v lexbuf )\n\n# 2933 \"lib/read.ml\"\n\n \n# 2934 \"lib/read.ml\"\n | 1 ->\n\n# 972 \"lib/read.mll\"\n \n# 972 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '>' )\n\n# 2938 \"lib/read.ml\"\n\n \n# 2939 \"lib/read.ml\"\n | 2 ->\n\n# 973 \"lib/read.mll\"\n \n# 973 \"lib/read.mll\"\n ( long_error \"Expected ':' or '>' but found\" v lexbuf )\n\n# 2943 \"lib/read.ml\"\n\n \n# 2944 \"lib/read.ml\"\n | 3 ->\n\n# 974 \"lib/read.mll\"\n \n# 974 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2948 \"lib/read.ml\"\n\n \n# 2949 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_buffer_variant_rec v lexbuf __ocaml_lex_state\n\nand buffer_ident v lexbuf =\n __ocaml_lex_buffer_ident_rec v lexbuf 466\nand __ocaml_lex_buffer_ident_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 977 \"lib/read.mll\"\n \n# 977 \"lib/read.mll\"\n ( finish_buffer_stringlit v lexbuf )\n\n# 2960 \"lib/read.ml\"\n\n \n# 2961 \"lib/read.ml\"\n | 1 ->\n\n# 978 \"lib/read.mll\"\n \n# 978 \"lib/read.mll\"\n ( add_lexeme v.buf lexbuf )\n\n# 2965 \"lib/read.ml\"\n\n \n# 2966 \"lib/read.ml\"\n | 2 ->\n\n# 979 \"lib/read.mll\"\n \n# 979 \"lib/read.mll\"\n ( long_error \"Expected string or identifier but found\" v lexbuf )\n\n# 2970 \"lib/read.ml\"\n\n \n# 2971 \"lib/read.ml\"\n | 3 ->\n\n# 980 \"lib/read.mll\"\n \n# 980 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2975 \"lib/read.ml\"\n\n \n# 2976 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_ident_rec v lexbuf __ocaml_lex_state\n\nand buffer_space v lexbuf =\n __ocaml_lex_buffer_space_rec v lexbuf 471\nand __ocaml_lex_buffer_space_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 983 \"lib/read.mll\"\n \n# 983 \"lib/read.mll\"\n (\n add_lexeme v.buf lexbuf;\n newline v lexbuf;\n buffer_space v lexbuf )\n\n# 2990 \"lib/read.ml\"\n\n \n# 2991 \"lib/read.ml\"\n | 1 ->\n\n# 987 \"lib/read.mll\"\n \n# 987 \"lib/read.mll\"\n (\n Bi_outbuf.add_string v.buf \"/*\";\n finish_buffer_comment v lexbuf;\n buffer_space v lexbuf )\n\n# 2998 \"lib/read.ml\"\n\n \n# 2999 \"lib/read.ml\"\n | 2 ->\n\n# 991 \"lib/read.mll\"\n \n# 991 \"lib/read.mll\"\n (\n Bi_outbuf.add_char v.buf '\\n';\n newline v lexbuf;\n buffer_space v lexbuf )\n\n# 3006 \"lib/read.ml\"\n\n \n# 3007 \"lib/read.ml\"\n | 3 ->\n\n# 995 \"lib/read.mll\"\n \n# 995 \"lib/read.mll\"\n (\n add_lexeme v.buf lexbuf;\n buffer_space v lexbuf )\n\n# 3013 \"lib/read.ml\"\n\n \n# 3014 \"lib/read.ml\"\n | 4 ->\n\n# 998 \"lib/read.mll\"\n \n# 998 \"lib/read.mll\"\n ( () )\n\n# 3018 \"lib/read.ml\"\n\n \n# 3019 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_space_rec v lexbuf __ocaml_lex_state\n\nand buffer_object_end v lexbuf =\n __ocaml_lex_buffer_object_end_rec v lexbuf 478\nand __ocaml_lex_buffer_object_end_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1001 \"lib/read.mll\"\n \n# 1001 \"lib/read.mll\"\n (\n Bi_outbuf.add_char v.buf '}';\n raise End_of_object )\n\n# 3032 \"lib/read.ml\"\n\n \n# 3033 \"lib/read.ml\"\n | 1 ->\n\n# 1004 \"lib/read.mll\"\n \n# 1004 \"lib/read.mll\"\n ( () )\n\n# 3037 \"lib/read.ml\"\n\n \n# 3038 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_object_end_rec v lexbuf __ocaml_lex_state\n\nand buffer_object_sep v lexbuf =\n __ocaml_lex_buffer_object_sep_rec v lexbuf 480\nand __ocaml_lex_buffer_object_sep_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1007 \"lib/read.mll\"\n \n# 1007 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf ',' )\n\n# 3049 \"lib/read.ml\"\n\n \n# 3050 \"lib/read.ml\"\n | 1 ->\n\n# 1008 \"lib/read.mll\"\n \n# 1008 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '}'; raise End_of_object )\n\n# 3054 \"lib/read.ml\"\n\n \n# 3055 \"lib/read.ml\"\n | 2 ->\n\n# 1009 \"lib/read.mll\"\n \n# 1009 \"lib/read.mll\"\n ( long_error \"Expected ',' or '}' but found\" v lexbuf )\n\n# 3059 \"lib/read.ml\"\n\n \n# 3060 \"lib/read.ml\"\n | 3 ->\n\n# 1010 \"lib/read.mll\"\n \n# 1010 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 3064 \"lib/read.ml\"\n\n \n# 3065 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_object_sep_rec v lexbuf __ocaml_lex_state\n\nand buffer_array_end v lexbuf =\n __ocaml_lex_buffer_array_end_rec v lexbuf 485\nand __ocaml_lex_buffer_array_end_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1013 \"lib/read.mll\"\n \n# 1013 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf ']'; raise End_of_array )\n\n# 3076 \"lib/read.ml\"\n\n \n# 3077 \"lib/read.ml\"\n | 1 ->\n\n# 1014 \"lib/read.mll\"\n \n# 1014 \"lib/read.mll\"\n ( () )\n\n# 3081 \"lib/read.ml\"\n\n \n# 3082 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_array_end_rec v lexbuf __ocaml_lex_state\n\nand buffer_array_sep v lexbuf =\n __ocaml_lex_buffer_array_sep_rec v lexbuf 487\nand __ocaml_lex_buffer_array_sep_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1017 \"lib/read.mll\"\n \n# 1017 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf ',' )\n\n# 3093 \"lib/read.ml\"\n\n \n# 3094 \"lib/read.ml\"\n | 1 ->\n\n# 1018 \"lib/read.mll\"\n \n# 1018 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf ']'; raise End_of_array )\n\n# 3098 \"lib/read.ml\"\n\n \n# 3099 \"lib/read.ml\"\n | 2 ->\n\n# 1019 \"lib/read.mll\"\n \n# 1019 \"lib/read.mll\"\n ( long_error \"Expected ',' or ']' but found\" v lexbuf )\n\n# 3103 \"lib/read.ml\"\n\n \n# 3104 \"lib/read.ml\"\n | 3 ->\n\n# 1020 \"lib/read.mll\"\n \n# 1020 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 3108 \"lib/read.ml\"\n\n \n# 3109 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_array_sep_rec v lexbuf __ocaml_lex_state\n\nand buffer_tuple_end v lexbuf =\n __ocaml_lex_buffer_tuple_end_rec v lexbuf 492\nand __ocaml_lex_buffer_tuple_end_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1023 \"lib/read.mll\"\n \n# 1023 \"lib/read.mll\"\n (\n Bi_outbuf.add_char v.buf ')';\n raise End_of_tuple )\n\n# 3122 \"lib/read.ml\"\n\n \n# 3123 \"lib/read.ml\"\n | 1 ->\n\n# 1026 \"lib/read.mll\"\n \n# 1026 \"lib/read.mll\"\n ( () )\n\n# 3127 \"lib/read.ml\"\n\n \n# 3128 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_tuple_end_rec v lexbuf __ocaml_lex_state\n\nand buffer_tuple_sep v lexbuf =\n __ocaml_lex_buffer_tuple_sep_rec v lexbuf 494\nand __ocaml_lex_buffer_tuple_sep_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1029 \"lib/read.mll\"\n \n# 1029 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf ',' )\n\n# 3139 \"lib/read.ml\"\n\n \n# 3140 \"lib/read.ml\"\n | 1 ->\n\n# 1030 \"lib/read.mll\"\n \n# 1030 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf ')'; raise End_of_tuple )\n\n# 3144 \"lib/read.ml\"\n\n \n# 3145 \"lib/read.ml\"\n | 2 ->\n\n# 1031 \"lib/read.mll\"\n \n# 1031 \"lib/read.mll\"\n ( long_error \"Expected ',' or ')' but found\" v lexbuf )\n\n# 3149 \"lib/read.ml\"\n\n \n# 3150 \"lib/read.ml\"\n | 3 ->\n\n# 1032 \"lib/read.mll\"\n \n# 1032 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 3154 \"lib/read.ml\"\n\n \n# 3155 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_tuple_sep_rec v lexbuf __ocaml_lex_state\n\nand buffer_colon v lexbuf =\n __ocaml_lex_buffer_colon_rec v lexbuf 499\nand __ocaml_lex_buffer_colon_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1035 \"lib/read.mll\"\n \n# 1035 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf ':' )\n\n# 3166 \"lib/read.ml\"\n\n \n# 3167 \"lib/read.ml\"\n | 1 ->\n\n# 1036 \"lib/read.mll\"\n \n# 1036 \"lib/read.mll\"\n ( long_error \"Expected ':' but found\" v lexbuf )\n\n# 3171 \"lib/read.ml\"\n\n \n# 3172 \"lib/read.ml\"\n | 2 ->\n\n# 1037 \"lib/read.mll\"\n \n# 1037 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 3176 \"lib/read.ml\"\n\n \n# 3177 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_colon_rec v lexbuf __ocaml_lex_state\n\nand buffer_gt v lexbuf =\n __ocaml_lex_buffer_gt_rec v lexbuf 503\nand __ocaml_lex_buffer_gt_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1040 \"lib/read.mll\"\n \n# 1040 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '>' )\n\n# 3188 \"lib/read.ml\"\n\n \n# 3189 \"lib/read.ml\"\n | 1 ->\n\n# 1041 \"lib/read.mll\"\n \n# 1041 \"lib/read.mll\"\n ( long_error \"Expected '>' but found\" v lexbuf )\n\n# 3193 \"lib/read.ml\"\n\n \n# 3194 \"lib/read.ml\"\n | 2 ->\n\n# 1042 \"lib/read.mll\"\n \n# 1042 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 3198 \"lib/read.ml\"\n\n \n# 3199 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_gt_rec v lexbuf __ocaml_lex_state\n\nand finish_buffer_comment v lexbuf =\n __ocaml_lex_finish_buffer_comment_rec v lexbuf 507\nand __ocaml_lex_finish_buffer_comment_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1045 \"lib/read.mll\"\n \n# 1045 \"lib/read.mll\"\n ( Bi_outbuf.add_string v.buf \"*/\" )\n\n# 3210 \"lib/read.ml\"\n\n \n# 3211 \"lib/read.ml\"\n | 1 ->\n\n# 1046 \"lib/read.mll\"\n \n# 1046 \"lib/read.mll\"\n ( long_error \"Unterminated comment\" v lexbuf )\n\n# 3215 \"lib/read.ml\"\n\n \n# 3216 \"lib/read.ml\"\n | 2 ->\n\n# 1047 \"lib/read.mll\"\n \n# 1047 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\\n';\n newline v lexbuf;\n finish_buffer_comment v lexbuf )\n\n# 3222 \"lib/read.ml\"\n\n \n# 3223 \"lib/read.ml\"\n | 3 ->\n\n# 1050 \"lib/read.mll\"\n \n# 1050 \"lib/read.mll\"\n ( add_lexeme v.buf lexbuf; finish_buffer_comment v lexbuf )\n\n# 3227 \"lib/read.ml\"\n\n \n# 3228 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_buffer_comment_rec v lexbuf __ocaml_lex_state\n\nand junk lexbuf =\n __ocaml_lex_junk_rec lexbuf 513\nand __ocaml_lex_junk_rec lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1053 \"lib/read.mll\"\n \n# 1053 \"lib/read.mll\"\n ( Lexing.lexeme lexbuf )\n\n# 3239 \"lib/read.ml\"\n\n \n# 3240 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_junk_rec lexbuf __ocaml_lex_state\n\n;;\n\n\n# 1055 \"lib/read.mll\"\n \n \n# 1056 \"lib/read.mll\"\n let _ = (read_json : lexer_state -> Lexing.lexbuf -> t)\n\n let read_t = read_json\n\n let () =\n read_junk := junk\n\n let read_int8 v lexbuf =\n let n = read_int v lexbuf in\n if n < 0 || n > 255 then\n lexer_error \"Int8 overflow\" v lexbuf\n else\n char_of_int n\n\n let read_list read_cell v lexbuf =\n List.rev (read_list_rev read_cell v lexbuf)\n\n let array_of_rev_list l =\n match l with\n [] -> [| |]\n | x :: tl ->\n let len = List.length l in\n let a = Array.make len x in\n let r = ref tl in\n for i = len - 2 downto 0 do\n a.(i) <- List.hd !r;\n r := List.tl !r\n done;\n a\n\n let read_array read_cell v lexbuf =\n let l = read_list_rev read_cell v lexbuf in\n array_of_rev_list l\n\n (* Read a JSON object, reading the keys into OCaml strings\n (provided for backward compatibility) *)\n let read_fields read_field init_acc v =\n read_abstract_fields read_ident read_field init_acc v\n\n let finish v lexbuf =\n read_space v lexbuf;\n if not (read_eof lexbuf) then\n long_error \"Junk after end of JSON value:\" v lexbuf\n\n let init_lexer = init_lexer\n\n let from_lexbuf v ?(stream = false) lexbuf =\n read_space v lexbuf;\n\n let x =\n if read_eof lexbuf then\n raise End_of_input\n else\n read_json v lexbuf\n in\n\n if not stream then\n finish v lexbuf;\n\n x\n\n\n let from_string ?buf ?fname ?lnum s =\n try\n let lexbuf = Lexing.from_string s in\n let v = init_lexer ?buf ?fname ?lnum () in\n from_lexbuf v lexbuf\n with End_of_input ->\n json_error \"Blank input data\"\n\n let from_channel ?buf ?fname ?lnum ic =\n try\n let lexbuf = Lexing.from_channel ic in\n let v = init_lexer ?buf ?fname ?lnum () in\n from_lexbuf v lexbuf\n with End_of_input ->\n json_error \"Blank input data\"\n\n let from_file ?buf ?fname ?lnum file =\n let ic = open_in file in\n try\n let x = from_channel ?buf ?fname ?lnum ic in\n close_in ic;\n x\n with e ->\n close_in_noerr ic;\n raise e\n\n exception Finally of exn * exn\n\n let stream_from_lexbuf v ?(fin = fun () -> ()) lexbuf =\n let stream = Some true in\n let f i =\n try Some (from_lexbuf v ?stream lexbuf)\n with\n End_of_input ->\n fin ();\n None\n | e ->\n (try fin () with fin_e -> raise (Finally (e, fin_e)));\n raise e\n in\n Stream.from f\n\n let stream_from_string ?buf ?fname ?lnum s =\n let v = init_lexer ?buf ?fname ?lnum () in\n stream_from_lexbuf v (Lexing.from_string s)\n\n let stream_from_channel ?buf ?fin ?fname ?lnum ic =\n let lexbuf = Lexing.from_channel ic in\n let v = init_lexer ?buf ?fname ?lnum () in\n stream_from_lexbuf v ?fin lexbuf\n\n let stream_from_file ?buf ?fname ?lnum file =\n let ic = open_in file in\n let fin () = close_in ic in\n let fname =\n match fname with\n None -> Some file\n | x -> x\n in\n let lexbuf = Lexing.from_channel ic in\n let v = init_lexer ?buf ?fname ?lnum () in\n stream_from_lexbuf v ~fin lexbuf\n\n type json_line = [ `Json of t | `Exn of exn ]\n\n let linestream_from_channel\n ?buf ?(fin = fun () -> ()) ?fname ?lnum:(lnum0 = 1) ic =\n let buf =\n match buf with\n None -> Some (Bi_outbuf.create 256)\n | Some _ -> buf\n in\n let f i =\n try\n let line = input_line ic in\n let lnum = lnum0 + i in\n Some (`Json (from_string ?buf ?fname ~lnum line))\n with\n End_of_file -> fin (); None\n | e -> Some (`Exn e)\n in\n Stream.from f\n\n let linestream_from_file ?buf ?fname ?lnum file =\n let ic = open_in file in\n let fin () = close_in ic in\n let fname =\n match fname with\n None -> Some file\n | x -> x\n in\n linestream_from_channel ?buf ~fin ?fname ?lnum ic\n\n let prettify ?std s =\n pretty_to_string ?std (from_string s)\n\n let compact ?std s =\n to_string (from_string s)\n\n let validate_json _path _value = None\n\n\n# 3411 \"lib/read.ml\"\n# 91 \"yojson.cppo.ml\"\nend\n","open Core_kernel\nmodule Z = Zarith.Z\n\ntype t = Z.t [@@deriving typerep ~abstract]\n\nlet module_name = \"Bigint\"\nlet invariant (_ : t) = ()\n\nmodule Stringable_t = struct\n type nonrec t = t\n\n let to_string = Z.to_string\n\n let rec is_integer_suffix s i ~len ~char_is_digit =\n if i < len\n then (\n let c = s.[i] in\n if char_is_digit c || Char.equal c '_'\n then is_integer_suffix s (i + 1) ~len ~char_is_digit\n else false)\n else true\n ;;\n\n let is_integer_string s ~char_is_digit =\n let len = String.length s in\n if 0 < len\n then (\n let i = if Char.equal s.[0] '-' then 1 else 0 in\n if i < len\n then\n if char_is_digit s.[i]\n then is_integer_suffix s (i + 1) ~len ~char_is_digit\n else false\n else false)\n else false\n ;;\n\n let of_string_base str ~name ~of_string_no_underscores ~char_is_digit =\n try of_string_no_underscores str with\n | _ ->\n if is_integer_string str ~char_is_digit\n then of_string_no_underscores (String.filter str ~f:(fun c -> Char.( <> ) c '_'))\n else failwithf \"%s.%s: invalid argument %S\" name module_name str ()\n ;;\n\n let of_string str =\n of_string_base\n str\n ~name:\"of_string\"\n ~of_string_no_underscores:Z.of_string\n ~char_is_digit:Char.is_digit\n ;;\nend\n\nmodule Stable = struct\n module V1 = struct\n module Bin_rep = struct\n type t =\n | Zero\n | Pos of string\n | Neg of string\n [@@deriving bin_io]\n end\n\n module Bin_rep_conversion = struct\n type nonrec t = t\n\n let to_binable t =\n let s = Z.sign t in\n if s > 0\n then Bin_rep.Pos (Z.to_bits t)\n else if s < 0\n then Bin_rep.Neg (Z.to_bits t)\n else Bin_rep.Zero\n ;;\n\n let of_binable = function\n | Bin_rep.Zero -> Z.zero\n | Bin_rep.Pos bits -> Z.of_bits bits\n | Bin_rep.Neg bits -> Z.of_bits bits |> Z.neg\n ;;\n end\n\n type nonrec t = t\n\n let compare = Z.compare\n\n include Sexpable.Stable.Of_stringable.V1 (Stringable_t)\n\n include Binable.Stable.Of_binable.V1 [@alert \"-legacy\"]\n (Bin_rep)\n (Bin_rep_conversion)\n end\n\n module V2 = struct\n type nonrec t = t\n\n let compare = Z.compare\n\n include Sexpable.Stable.Of_stringable.V1 (Stringable_t)\n\n let compute_size_in_bytes x =\n let numbits = Z.numbits x in\n Int.round_up ~to_multiple_of:8 numbits / 8\n ;;\n\n let compute_tag ~size_in_bytes ~negative =\n let open Int63 in\n let sign_bit = if negative then one else zero in\n (* Can't overflow:\n size <= String.length bits < 2 * max_string_length < max_int63\n *)\n shift_left (of_int size_in_bytes) 1 + sign_bit\n ;;\n\n let bin_size_t : t Bin_prot.Size.sizer =\n fun x ->\n let size_in_bytes = compute_size_in_bytes x in\n if size_in_bytes = 0\n then Int63.bin_size_t Int63.zero\n else (\n let negative = Z.sign x = -1 in\n let tag = compute_tag ~size_in_bytes ~negative in\n Int63.bin_size_t tag + size_in_bytes)\n ;;\n\n let bin_write_t : t Bin_prot.Write.writer =\n fun buf ~pos x ->\n let size_in_bytes = compute_size_in_bytes x in\n if size_in_bytes = 0\n then Int63.bin_write_t buf ~pos Int63.zero\n else (\n let bits = Z.to_bits x in\n let negative = Z.sign x = -1 in\n let tag = compute_tag ~size_in_bytes ~negative in\n let pos = Int63.bin_write_t buf ~pos tag in\n Bin_prot.Common.blit_string_buf bits ~dst_pos:pos buf ~len:size_in_bytes;\n pos + size_in_bytes)\n ;;\n\n let bin_read_t : t Bin_prot.Read.reader =\n fun buf ~pos_ref ->\n let tag = Core_kernel.Int63.bin_read_t buf ~pos_ref in\n if Int63.equal tag Int63.zero\n then Z.zero\n else (\n let negative = Int63.(tag land one = one) in\n let size_in_bytes = Int63.(to_int_exn (shift_right tag 1)) in\n (* Even though we could cache a buffer for small sizes, the extra logic leads to\n a decrease in performance *)\n let bytes = Bytes.create size_in_bytes in\n Bin_prot.Common.blit_buf_bytes ~src_pos:!pos_ref buf bytes ~len:size_in_bytes;\n let abs =\n Z.of_bits (Bytes.unsafe_to_string ~no_mutation_while_string_reachable:bytes)\n in\n pos_ref := !pos_ref + size_in_bytes;\n if negative then Z.neg abs else abs)\n ;;\n\n let module_name = \"Bigint.Stable.V2.t\"\n\n let bin_writer_t : t Bin_prot.Type_class.writer =\n { size = bin_size_t; write = bin_write_t }\n ;;\n\n let __bin_read_t__ _buf ~pos_ref _vint =\n Bin_prot.Common.raise_variant_wrong_type module_name !pos_ref\n ;;\n\n let bin_reader_t : t Bin_prot.Type_class.reader =\n { read = bin_read_t; vtag_read = __bin_read_t__ }\n ;;\n\n let bin_shape_t : Bin_prot.Shape.t =\n Bin_prot.Shape.basetype\n (Bin_prot.Shape.Uuid.of_string \"7a8cceb2-f3a2-11e9-b7cb-aae95a547ff6\")\n []\n ;;\n\n let bin_t : t Bin_prot.Type_class.t =\n { shape = bin_shape_t; writer = bin_writer_t; reader = bin_reader_t }\n ;;\n end\nend\n\nmodule Unstable = struct\n include Stable.V1\n include Stringable_t\n\n let t_sexp_grammar = [%sexp_grammar: String.t]\n let of_zarith_bigint t = t\n let to_zarith_bigint t = t\n\n let ( /% ) x y =\n if Z.sign y >= 0\n then Z.ediv x y\n else\n failwithf\n \"%s.(%s /%% %s) : divisor must be positive\"\n module_name\n (to_string x)\n (to_string y)\n ()\n ;;\n\n let ( % ) x y =\n if Z.sign y >= 0\n then Z.erem x y\n else\n failwithf\n \"%s.(%s %% %s) : divisor must be positive\"\n module_name\n (to_string x)\n (to_string y)\n ()\n ;;\n\n let hash_fold_t state t = Int.hash_fold_t state (Z.hash t)\n let hash = Z.hash\n let compare = Z.compare\n let ( - ) = Z.( - )\n let ( + ) = Z.( + )\n let ( * ) = Z.( * )\n let ( / ) = Z.( / )\n let rem = Z.rem\n let ( ~- ) = Z.( ~- )\n let neg = Z.neg\n let abs = Z.abs\n let succ = Z.succ\n let pred = Z.pred\n let equal = Z.equal\n let ( = ) = Z.equal\n let ( < ) = Z.lt\n let ( > ) = Z.gt\n let ( <= ) = Z.leq\n let ( >= ) = Z.geq\n let max = Z.max\n let min = Z.min\n let ascending = compare\n let shift_right = Z.shift_right\n let shift_left = Z.shift_left\n let bit_not = Z.lognot\n let bit_xor = Z.logxor\n let bit_or = Z.logor\n let bit_and = Z.logand\n let ( land ) = bit_and\n let ( lor ) = bit_or\n let ( lxor ) = bit_xor\n let lnot = bit_not\n let ( lsl ) = shift_left\n let ( asr ) = shift_right\n let of_int = Z.of_int\n let of_int32 = Z.of_int32\n let of_int64 = Z.of_int64\n let of_nativeint = Z.of_nativeint\n let of_float_unchecked = Z.of_float\n let of_float = Z.of_float\n let of_int_exn = of_int\n let of_int32_exn = of_int32\n let of_int64_exn = of_int64\n let of_nativeint_exn = of_nativeint\n let to_int_exn = Z.to_int\n let to_int32_exn = Z.to_int32\n let to_int64_exn = Z.to_int64\n let to_nativeint_exn = Z.to_nativeint\n let to_float = Z.to_float\n let zero = Z.zero\n let one = Z.one\n let minus_one = Z.minus_one\n let to_int t = if Z.fits_int t then Some (Z.to_int t) else None\n let to_int32 t = if Z.fits_int32 t then Some (Z.to_int32 t) else None\n let to_int64 t = if Z.fits_int64 t then Some (Z.to_int64 t) else None\n let to_nativeint t = if Z.fits_nativeint t then Some (Z.to_nativeint t) else None\n let ( <> ) x y = not (equal x y)\n let incr cell = cell := succ !cell\n let decr cell = cell := pred !cell\n let pow x y = Z.pow x (to_int_exn y)\n let ( ** ) x y = pow x y\n let popcount x = Z.popcount x\nend\n\nmodule T_math = Int_math.Make (Unstable)\nmodule T_conversions = Int_conversions.Make (Unstable)\nmodule T_comparable_with_zero = Comparable.Validate_with_zero (Unstable)\n\nmodule T_identifiable = Identifiable.Make (struct\n let module_name = module_name\n\n include Unstable\n end)\n\n(* Including in opposite order to shadow functorized bindings with direct bindings. *)\nmodule O = struct\n include T_identifiable\n include T_comparable_with_zero\n include T_conversions\n include T_math\n include Unstable\nend\n\ninclude (O : module type of O with type t := t)\n\nmodule Make_random (State : sig\n type t\n\n val bits : t -> int\n val int : t -> int -> int\n end) : sig\n val random : state:State.t -> t -> t\nend = struct\n (* Uniform random generation of Bigint values.\n\n [random ~state range] chooses a [depth] and generates random values using\n [Random.State.bits state], called [1 lsl depth] times and concatenated. The\n preliminary result [n] therefore satisfies [0 <= n < 1 lsl (30 lsl depth)].\n\n In order for the random choice to be uniform between [0] and [range-1], there must\n exist [k > 0] such that [n < k * range <= 1 lsl (30 lsl depth)]. If so, [n % range]\n is returned. Otherwise the random choice process is repeated from scratch.\n\n The [depth] value is chosen so that repeating is uncommon (1 in 1,000 or less). *)\n\n let bits_at_depth ~depth = Int.shift_left 30 depth\n let range_at_depth ~depth = shift_left one (bits_at_depth ~depth)\n\n let rec choose_bit_depth_for_range_from ~range ~depth =\n if range_at_depth ~depth >= range\n then depth\n else choose_bit_depth_for_range_from ~range ~depth:(Int.succ depth)\n ;;\n\n let choose_bit_depth_for_range ~range = choose_bit_depth_for_range_from ~range ~depth:0\n\n let rec random_bigint_at_depth ~state ~depth =\n if Int.equal depth 0\n then of_int (State.bits state)\n else (\n let prev_depth = Int.pred depth in\n let prefix = random_bigint_at_depth ~state ~depth:prev_depth in\n let suffix = random_bigint_at_depth ~state ~depth:prev_depth in\n bit_or (shift_left prefix (bits_at_depth ~depth:prev_depth)) suffix)\n ;;\n\n let random_value_is_uniform_in_range ~range ~depth n =\n let k = range_at_depth ~depth / range in\n n < k * range\n ;;\n\n let rec large_random_at_depth ~state ~range ~depth =\n let result = random_bigint_at_depth ~state ~depth in\n if random_value_is_uniform_in_range ~range ~depth result\n then result % range\n else large_random_at_depth ~state ~range ~depth\n ;;\n\n let large_random ~state ~range =\n let tolerance_factor = of_int 1_000 in\n let depth = choose_bit_depth_for_range ~range:(range * tolerance_factor) in\n large_random_at_depth ~state ~range ~depth\n ;;\n\n let random ~state range =\n if range <= zero\n then\n failwithf \"Bigint.random: argument %s <= 0\" (to_string_hum range) ()\n (* Note that it's not safe to do [1 lsl 30] on a 32-bit machine (with 31-bit signed\n integers) *)\n else if range < shift_left one 30\n then of_int (State.int state (to_int_exn range))\n else large_random ~state ~range\n ;;\nend\n\nmodule Random_internal = Make_random (Random.State)\n\nlet random ?(state = Random.State.default) range = Random_internal.random ~state range\n\nmodule For_quickcheck : sig\n include Quickcheckable.S_int with type t := t\n\n val gen_negative : t Quickcheck.Generator.t\n val gen_positive : t Quickcheck.Generator.t\nend = struct\n module Generator = Quickcheck.Generator\n open Generator.Let_syntax\n\n module Uniform = Make_random (struct\n type t = Splittable_random.State.t\n\n let int t range = Splittable_random.int t ~lo:0 ~hi:(Int.pred range)\n let bits t = int t (Int.shift_left 1 30)\n end)\n\n let random_uniform ~state lo hi = lo + Uniform.random ~state (succ (hi - lo))\n\n let gen_uniform_incl lower_bound upper_bound =\n if lower_bound > upper_bound\n then\n raise_s\n [%message\n \"Bigint.gen_uniform_incl: bounds are crossed\"\n (lower_bound : t)\n (upper_bound : t)];\n Generator.create (fun ~size:_ ~random:state ->\n random_uniform ~state lower_bound upper_bound)\n ;;\n\n let gen_incl lower_bound upper_bound =\n Generator.weighted_union\n [ 0.05, Generator.return lower_bound\n ; 0.05, Generator.return upper_bound\n ; 0.9, gen_uniform_incl lower_bound upper_bound\n ]\n ;;\n\n let min_represented_by_n_bits n =\n if Int.equal n 0 then zero else shift_left one (Int.pred n)\n ;;\n\n let max_represented_by_n_bits n = pred (shift_left one n)\n\n let gen_log_uniform_incl lower_bound upper_bound =\n if lower_bound < zero || lower_bound > upper_bound\n then\n raise_s\n [%message\n \"Bigint.gen_log_incl: invalid bounds\" (lower_bound : t) (upper_bound : t)];\n let min_bits = Z.numbits lower_bound in\n let max_bits = Z.numbits upper_bound in\n let%bind bits = Int.gen_uniform_incl min_bits max_bits in\n gen_uniform_incl\n (max lower_bound (min_represented_by_n_bits bits))\n (min upper_bound (max_represented_by_n_bits bits))\n ;;\n\n let gen_log_incl lower_bound upper_bound =\n Generator.weighted_union\n [ 0.05, Generator.return lower_bound\n ; 0.05, Generator.return upper_bound\n ; 0.9, gen_log_uniform_incl lower_bound upper_bound\n ]\n ;;\n\n let gen_positive =\n let%bind extra_bytes = Generator.size in\n let num_bytes = Int.succ extra_bytes in\n let num_bits = Int.( * ) num_bytes 8 in\n gen_log_uniform_incl one (pred (shift_left one num_bits))\n ;;\n\n let gen_negative = Generator.map gen_positive ~f:neg\n\n let quickcheck_generator =\n Generator.weighted_union\n [ 0.45, gen_positive; 0.1, Generator.return zero; 0.45, gen_negative ]\n ;;\n\n let quickcheck_observer =\n Quickcheck.Observer.create (fun t ~size:_ ~hash -> hash_fold_t hash t)\n ;;\n\n let quickcheck_shrinker = Quickcheck.Shrinker.empty ()\nend\n\ninclude For_quickcheck\n\nmodule Hex = struct\n type nonrec t = t [@@deriving bin_io, typerep]\n\n module M = Base.Int_conversions.Make_hex (struct\n type nonrec t = t [@@deriving hash, compare]\n\n let to_string i = Z.format \"%x\" i\n\n let char_is_hex_digit = function\n | '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' -> true\n | _ -> false\n ;;\n\n let of_hex_string_no_underscores str = Z.of_string_base 16 str\n\n let of_string str =\n of_string_base\n str\n ~name:\"Hex.of_string\"\n ~char_is_digit:char_is_hex_digit\n ~of_string_no_underscores:of_hex_string_no_underscores\n ;;\n\n let ( < ) = ( < )\n let neg = neg\n let zero = zero\n let module_name = module_name ^ \".Hex\"\n end)\n\n include (\n M.Hex :\n module type of struct\n include M.Hex\n end\n with type t := t)\nend\n","open Core_kernel\n\ntype 'f t =\n | Constant of 'f\n | Var of int\n | Add of 'f t * 'f t\n | Scale of 'f * 'f t\n[@@deriving sexp]\n\ntype 'f cvar = 'f t [@@deriving sexp]\n\nlet to_constant_and_terms ~equal ~add ~mul ~zero ~one =\n let rec go scale constant terms = function\n | Constant c ->\n (add constant (mul scale c), terms)\n | Var v ->\n (constant, (scale, v) :: terms)\n | Scale (s, t) ->\n go (mul s scale) constant terms t\n | Add (x1, x2) ->\n let c1, terms1 = go scale constant terms x1 in\n go scale c1 terms1 x2\n in\n fun t ->\n let c, ts = go one zero [] t in\n let c = if equal c zero then None else Some c in\n (c, ts)\n\nmodule Unsafe = struct\n let of_index v = Var v\nend\n\nmodule Make (Field : Snarky_intf.Field.Extended) = struct\n type t = Field.t cvar [@@deriving sexp]\n\n let length _ = failwith \"TODO\"\n\n module Unsafe = Unsafe\n\n let scratch = Field.of_int 0\n\n let eval (`Return_values_will_be_mutated context) t0 =\n let open Field in\n let res = of_int 0 in\n let rec go ~can_mutate_scale scale = function\n | Constant c when can_mutate_scale ->\n scale *= c ; res += scale\n | Constant c ->\n Mutable.copy ~over:scratch c ;\n scratch *= scale ;\n res += scratch\n | Var v ->\n let v = context v in\n v *= scale ; res += v\n | Scale (s, t) when can_mutate_scale ->\n scale *= s ;\n go scale ~can_mutate_scale t\n | Scale (s, t) ->\n go (mul s scale) ~can_mutate_scale:true t\n | Add (t1, t2) ->\n go scale ~can_mutate_scale:false t1 ;\n go scale ~can_mutate_scale t2\n in\n go one ~can_mutate_scale:false t0 ;\n res\n\n let constant c = Constant c\n\n let to_constant_and_terms =\n let rec go scale constant terms = function\n | Constant c ->\n (Field.add constant (Field.mul scale c), terms)\n | Var v ->\n (constant, (scale, v) :: terms)\n | Scale (s, t) ->\n go (Field.mul s scale) constant terms t\n | Add (x1, x2) ->\n let c1, terms1 = go scale constant terms x1 in\n go scale c1 terms1 x2\n in\n fun t ->\n let c, ts = go Field.one Field.zero [] t in\n let c = if Field.equal c Field.zero then None else Some c in\n (c, ts)\n\n let add x y =\n match (x, y) with\n | Constant x, _ when Field.(equal x zero) ->\n y\n | _, Constant y when Field.(equal y zero) ->\n x\n | Constant x, Constant y ->\n Constant (Field.add x y)\n | _, _ ->\n Add (x, y)\n\n let scale x s =\n if Field.(equal s zero) then Constant Field.zero\n else if Field.(equal s one) then x\n else\n match x with\n | Constant x ->\n Constant (Field.mul x s)\n | Scale (sx, x) ->\n Scale (Field.mul sx s, x)\n | _ ->\n Scale (s, x)\n\n let neg_one = Field.(sub zero one)\n\n let sub t1 t2 =\n match (t1, t2) with\n | Constant x, Constant y ->\n Constant (Field.sub x y)\n | _ ->\n add t1 (scale t2 neg_one)\n\n let linear_combination (terms : (Field.t * t) list) : t =\n List.fold terms ~init:(constant Field.zero) ~f:(fun acc (c, t) ->\n add acc (scale t c) )\n\n let sum vs = linear_combination (List.map vs ~f:(fun v -> (Field.one, v)))\n\n let ( + ) = add\n\n let ( - ) = sub\n\n let ( * ) c x = scale x c\n\n let negate x = scale x neg_one\n\n let to_json x =\n let singleton = Map.singleton (module Int) in\n let join = Map.merge_skewed ~combine:(fun ~key:_ -> Field.add) in\n let rec go scale = function\n | Constant f ->\n singleton 0 (Field.mul scale f)\n | Var i ->\n singleton i scale\n | Add (x, y) ->\n join (go scale x) (go scale y)\n | Scale (s, x) ->\n go Field.(scale * s) x\n in\n let map = go Field.one x in\n `Assoc\n (List.filter_map (Map.to_alist map) ~f:(fun (i, f) ->\n if Field.(equal f zero) then None\n else Some (Int.to_string i, `String (Field.to_string f)) ) )\nend\n","open Base\n\ntype ('var, 'field) basic = ..\n\nmodule Conv (F : sig\n type (_, _) t\nend) =\nstruct\n type t =\n { to_basic : 'v 'f. ('v, 'f) F.t -> ('v, 'f) basic\n ; of_basic : 'v 'f. ('v, 'f) basic -> ('v, 'f) F.t\n }\nend\n\nmodule type S = sig\n type (_, _) t [@@deriving sexp]\n\n val map : ('a, 'f) t -> f:('a -> 'b) -> ('b, 'f) t\n\n (* TODO: Try making this a functor and seeing how it affects performance *)\n val eval :\n (module Snarky_intf.Field.S with type t = 'f)\n -> ('v -> 'f)\n -> ('v, 'f) t\n -> bool\nend\n\nmodule Basic = struct\n type ('v, 'f) t = ('v, 'f) basic\n\n module type S_with_conv = sig\n include S\n\n val to_basic : ('v, 'f) t -> ('v, 'f) basic\n\n val of_basic : ('v, 'f) basic -> ('v, 'f) t\n end\n\n module Entry = struct\n type t = (module S_with_conv)\n end\n\n let cases : Entry.t list ref = ref []\n\n let add_case m = cases := m :: !cases\n\n let case f =\n List.find_map_exn !cases ~f:(fun m -> Option.try_with (fun () -> f m))\n\n let sexp_of_t f1 f2 t =\n case (fun (module M) -> M.sexp_of_t f1 f2 (M.of_basic t))\n\n let t_of_sexp f1 f2 s =\n case (fun (module M) -> M.to_basic (M.t_of_sexp f1 f2 s))\n\n let eval (type f) (fm : (module Snarky_intf.Field.S with type t = f))\n (f : 'v -> f) (t : ('v, f) basic) : bool =\n case (fun (module M) -> M.eval fm f (M.of_basic t))\n\n let map t ~f = case (fun (module M) -> M.to_basic (M.map (M.of_basic t) ~f))\nend\n\nmodule Add_kind (C : S) : sig\n type ('v, 'f) basic += T of ('v, 'f) C.t\nend = struct\n type ('v, 'f) basic += T of ('v, 'f) C.t\n\n module M = struct\n include C\n\n let to_basic x = T x\n\n let of_basic = function T x -> x | _ -> failwith \"different constructor\"\n end\n\n let () = Basic.add_case (module M)\nend\n\n(* We special case these for compatibility with existing code. *)\ntype ('var, _) basic +=\n | Boolean of 'var\n | Equal of 'var * 'var\n | Square of 'var * 'var\n | R1CS of 'var * 'var * 'var\n\nlet basic_of_sexp = Basic.t_of_sexp\n\nlet sexp_of_basic = Basic.sexp_of_t\n\nlet () =\n let unhandled s = Core_kernel.failwithf \"%s: non-basic constraint\" s () in\n let module Essential = struct\n type 'var t =\n | Boolean of 'var\n | Equal of 'var * 'var\n | Square of 'var * 'var\n | R1CS of 'var * 'var * 'var\n [@@deriving sexp]\n\n let to_basic : 'v t -> ('v, _) basic = function\n | Boolean x ->\n Boolean x\n | Equal (x, y) ->\n Equal (x, y)\n | Square (x, y) ->\n Square (x, y)\n | R1CS (x, y, z) ->\n R1CS (x, y, z)\n\n let of_basic : ('v, _) basic -> 'v t = function\n | Boolean x ->\n Boolean x\n | Equal (x, y) ->\n Equal (x, y)\n | Square (x, y) ->\n Square (x, y)\n | R1CS (x, y, z) ->\n R1CS (x, y, z)\n | _ ->\n unhandled \"of_basic\"\n end in\n let module M = struct\n type ('v, 'f) t = ('v, 'f) basic\n\n let sexp_of_t f _ t = Essential.(sexp_of_t f (of_basic t))\n\n let t_of_sexp f _ s = Essential.(to_basic (t_of_sexp f s))\n\n let of_basic = Fn.id\n\n let to_basic = Fn.id\n\n let map t ~f =\n match t with\n | Boolean v ->\n Boolean (f v)\n | Equal (v1, v2) ->\n Equal (f v1, f v2)\n | R1CS (v1, v2, v3) ->\n R1CS (f v1, f v2, f v3)\n | Square (a, c) ->\n Square (f a, f c)\n | _ ->\n unhandled \"map\"\n\n let eval (type f v) (module Field : Snarky_intf.Field.S with type t = f)\n (get_value : v -> f) (t : (v, f) basic) : bool =\n match t with\n | Boolean v ->\n let x = get_value v in\n Field.(equal x zero || equal x one)\n | Equal (v1, v2) ->\n Field.equal (get_value v1) (get_value v2)\n | R1CS (v1, v2, v3) ->\n Field.(equal (mul (get_value v1) (get_value v2)) (get_value v3))\n | Square (a, c) ->\n Field.equal (Field.square (get_value a)) (get_value c)\n | _ ->\n unhandled \"eval\"\n end in\n Basic.add_case (module M)\n\ntype ('v, 'f) basic_with_annotation =\n { basic : ('v, 'f) basic; annotation : string option }\n[@@deriving sexp]\n\ntype ('v, 'f) t = ('v, 'f) basic_with_annotation [@@deriving sexp]\n\nmodule T = struct\n let create_basic ?label basic = { basic; annotation = label }\n\n let override_label { basic; annotation = a } label_opt =\n { basic\n ; annotation = (match label_opt with Some x -> Some x | None -> a)\n }\n\n let equal ?label x y = create_basic ?label (Equal (x, y))\n\n let boolean ?label x = create_basic ?label (Boolean x)\n\n let r1cs ?label a b c = create_basic ?label (R1CS (a, b, c))\n\n let square ?label a c = create_basic ?label (Square (a, c))\n\n let annotation (t : _ t) =\n match t.annotation with Some str -> str | None -> \"\"\nend\n\ninclude T\n","open Core_kernel\nmodule Bignum_bigint = Bigint\n\n(** Yojson-compatible JSON type. *)\ntype 'a json =\n [> `String of string\n | `Assoc of (string * 'a json) list\n | `List of 'a json list ]\n as\n 'a\n\nmodule type S = sig\n module Field : Snarky_intf.Field.Full\n\n module Bigint : sig\n include Snarky_intf.Bigint_intf.Extended with type field := Field.t\n\n val of_bignum_bigint : Bignum_bigint.t -> t\n\n val to_bignum_bigint : t -> Bignum_bigint.t\n end\n\n module Cvar : sig\n type t = Field.t Cvar.t [@@deriving sexp]\n\n val length : t -> int\n\n module Unsafe : sig\n val of_index : int -> t\n end\n\n val eval :\n [ `Return_values_will_be_mutated of int -> Field.t ] -> t -> Field.t\n\n val constant : Field.t -> t\n\n val to_constant_and_terms : t -> Field.t option * (Field.t * int) list\n\n val add : t -> t -> t\n\n val negate : t -> t\n\n val scale : t -> Field.t -> t\n\n val sub : t -> t -> t\n\n val linear_combination : (Field.t * t) list -> t\n\n val sum : t list -> t\n\n val ( + ) : t -> t -> t\n\n val ( - ) : t -> t -> t\n\n val ( * ) : Field.t -> t -> t\n\n val var_indices : t -> int list\n\n val to_constant : t -> Field.t option\n end\n\n module R1CS_constraint_system :\n Backend_intf.Constraint_system_intf with module Field := Field\n\n module Constraint : sig\n type t = (Cvar.t, Field.t) Constraint.t [@@deriving sexp]\n\n type 'k with_constraint_args = ?label:string -> 'k\n\n val boolean : (Cvar.t -> t) with_constraint_args\n\n val equal : (Cvar.t -> Cvar.t -> t) with_constraint_args\n\n val r1cs : (Cvar.t -> Cvar.t -> Cvar.t -> t) with_constraint_args\n\n val square : (Cvar.t -> Cvar.t -> t) with_constraint_args\n\n val annotation : t -> string\n\n val eval :\n (Cvar.t, Field.t) Constraint.basic_with_annotation\n -> (Cvar.t -> Field.t)\n -> bool\n end\nend\n\nmodule Make (Backend : Backend_intf.S) :\n S\n with type Field.t = Backend.Field.t\n and type Field.Vector.t = Backend.Field.Vector.t\n and type Bigint.t = Backend.Bigint.t\n and type R1CS_constraint_system.t = Backend.R1CS_constraint_system.t =\nstruct\n open Backend\n\n module Bigint = struct\n include Bigint\n\n let of_bignum_bigint n = of_decimal_string (Bignum_bigint.to_string n)\n\n let to_bignum_bigint n =\n let rec go i two_to_the_i acc =\n if i = Field.size_in_bits then acc\n else\n let acc' =\n if test_bit n i then Bignum_bigint.(acc + two_to_the_i) else acc\n in\n go (i + 1) Bignum_bigint.(two_to_the_i + two_to_the_i) acc'\n in\n go 0 Bignum_bigint.one Bignum_bigint.zero\n end\n\n module Field = struct\n include Field\n\n let size = Bigint.to_bignum_bigint Backend.field_size\n\n let inv x = if equal x zero then failwith \"Field.inv: zero\" else inv x\n\n (* TODO: Optimize *)\n let div x y = mul x (inv y)\n\n let negate x = sub zero x\n\n let unpack x =\n let n = Bigint.of_field x in\n List.init size_in_bits ~f:(fun i -> Bigint.test_bit n i)\n\n let project_reference =\n let rec go x acc = function\n | [] ->\n acc\n | b :: bs ->\n go (Field.add x x) (if b then Field.add acc x else acc) bs\n in\n fun bs -> go Field.one Field.zero bs\n\n let _project bs =\n (* todo: 32-bit and ARM support. basically this code needs to always match the loop in the C++ of_data implementation. *)\n assert (Sys.word_size = 64 && not Sys.big_endian) ;\n let chunks_of n xs =\n List.groupi ~break:(fun i _ _ -> Int.equal (i mod n) 0) xs\n in\n let chunks64 = chunks_of 64 bs in\n let z = Char.of_int_exn 0 in\n let arr =\n Bigstring.init (8 * Backend.Bigint.length_in_bytes) ~f:(fun _ -> z)\n in\n List.(\n iteri ~f:(fun i elt ->\n Bigstring.set_int64_t_le arr ~pos:(i * 8)\n Int64.(\n foldi ~init:zero\n ~f:(fun i acc el ->\n acc + if el then shift_left one i else zero )\n elt) ))\n chunks64 ;\n Backend.Bigint.(of_data arr ~bitcount:(List.length bs) |> to_field)\n\n let project = project_reference\n\n let compare t1 t2 = Bigint.(compare (of_field t1) (of_field t2))\n\n let hash_fold_t s x =\n Bignum_bigint.hash_fold_t s Bigint.(to_bignum_bigint (of_field x))\n\n let hash = Hash.of_fold hash_fold_t\n\n let to_bignum_bigint = Fn.compose Bigint.to_bignum_bigint Bigint.of_field\n\n let of_bignum_bigint = Fn.compose Bigint.to_field Bigint.of_bignum_bigint\n\n let sexp_of_t = Fn.compose Bignum_bigint.sexp_of_t to_bignum_bigint\n\n let t_of_sexp = Fn.compose of_bignum_bigint Bignum_bigint.t_of_sexp\n\n let to_string = Fn.compose Bignum_bigint.to_string to_bignum_bigint\n\n let of_string = Fn.compose of_bignum_bigint Bignum_bigint.of_string\n\n let%test_unit \"project correctness\" =\n Quickcheck.test\n Quickcheck.Generator.(\n small_positive_int >>= fun x -> list_with_length x bool)\n ~f:(fun bs ->\n [%test_eq: string]\n (project bs |> to_string)\n (project_reference bs |> to_string) )\n\n let ( + ) = add\n\n let ( * ) = mul\n\n let ( - ) = sub\n\n let ( / ) = div\n end\n\n module Cvar = struct\n include Cvar.Make (Field)\n\n let var_indices t =\n let _, terms = to_constant_and_terms t in\n List.map ~f:(fun (_, v) -> v) terms\n\n let to_constant : t -> Field.t option = function\n | Constant x ->\n Some x\n | _ ->\n None\n end\n\n module Constraint = struct\n open Constraint\n include Constraint.T\n\n type 'k with_constraint_args = ?label:string -> 'k\n\n type t = (Cvar.t, Field.t) Constraint.t [@@deriving sexp]\n\n let m = (module Field : Snarky_intf.Field.S with type t = Field.t)\n\n let eval { basic; _ } get_value = Constraint.Basic.eval m get_value basic\n end\n\n module R1CS_constraint_system = R1CS_constraint_system\nend\n","open Core_kernel\nmodule Constraint0 = Constraint\n\nlet stack_to_string = String.concat ~sep:\"\\n\"\n\nlet eval_constraints = ref true\n\nlet eval_constraints_ref = eval_constraints\n\nmodule Simple = struct\n module Types = struct\n module Checked = struct\n type ('a, 'f) t =\n | Pure of 'a\n | Function of ('f Run_state.t -> 'f Run_state.t * 'a)\n end\n\n module Typ = struct\n include Types.Typ.T\n\n type ('var, 'value, 'f) t = ('var, 'value, 'f, (unit, 'f) Checked.t) typ\n end\n\n module Provider = struct\n include Types.Provider.T\n\n type ('a, 'f) t =\n (('a Request.t, 'f) As_prover0.t, ('a, 'f) As_prover0.t) provider\n end\n end\n\n type 'f field = 'f\n\n type ('a, 'f) t = ('a, 'f field) Types.Checked.t\n\n let eval (t : ('a, 'f) t) : 'f field Run_state.t -> 'f field Run_state.t * 'a\n =\n match t with Pure a -> fun s -> (s, a) | Function g -> g\n\n include Monad_let.Make2 (struct\n type ('a, 'f) t = ('a, 'f field) Types.Checked.t\n\n let return x : _ t = Pure x\n\n let map =\n `Custom\n (fun (x : _ t) ~f : _ t ->\n match x with\n | Pure a ->\n Pure (f a)\n | Function g ->\n Function\n (fun s ->\n let s, a = g s in\n (s, f a) ) )\n\n let bind (x : _ t) ~f : _ t =\n match x with\n | Pure a ->\n f a\n | Function g ->\n Function\n (fun s ->\n let s, a = g s in\n eval (f a) s )\n end)\nend\n\nmodule Make_checked\n (Backend : Backend_extended.S)\n (As_prover : As_prover_intf.Basic with type 'f field := Backend.Field.t) =\nstruct\n type run_state = Backend.Field.t Run_state.t\n\n module Types = struct\n module Checked = struct\n type ('a, 'f) t = ('a, Backend.Field.t) Simple.Types.Checked.t\n end\n\n module Typ = struct\n include Types.Typ.T\n\n type ('var, 'value, 'f) t = ('var, 'value, 'f, (unit, 'f) Checked.t) typ\n end\n\n module Provider = struct\n include Types.Provider.T\n\n type ('a, 'f) t =\n (('a Request.t, 'f) As_prover.t, ('a, 'f) As_prover.t) provider\n end\n end\n\n type 'f field = Backend.Field.t\n\n include Types.Checked\n\n let eval : ('a, 'f) t -> run_state -> run_state * 'a = Simple.eval\n\n include Monad_let.Make2 (struct\n include Types.Checked\n\n let map = `Custom Simple.map\n\n let bind = Simple.bind\n\n let return = Simple.return\n end)\n\n open Constraint\n open Backend\n\n let get_value (t : Field.t Run_state.t) : Cvar.t -> Field.t =\n let get_one i = Run_state.get_variable_value t i in\n Cvar.eval (`Return_values_will_be_mutated get_one)\n\n let run_as_prover x state =\n match (x, Run_state.has_witness state) with\n | Some x, true ->\n let old = Run_state.as_prover state in\n Run_state.set_as_prover state true ;\n let y = As_prover.run x (get_value state) in\n Run_state.set_as_prover state old ;\n (state, Some y)\n | _, _ ->\n (state, None)\n\n let as_prover x : _ Simple.t =\n Function\n (fun s ->\n let s', (_ : unit option) = run_as_prover (Some x) s in\n (s', ()) )\n\n let mk_lazy x : _ Simple.t =\n Function\n (fun s ->\n let old_stack = Run_state.stack s in\n ( s\n , Lazy.from_fun (fun () ->\n let stack = Run_state.stack s in\n\n (* Add a label to indicate that the new stack is the point at which\n this was forced. When printed for errors, this will split the\n stack into\n\n ...\n stack to lazy\n ...\n\n Lazy value forced at:\n ...\n stack to lazy forcing point\n ...\n *)\n let label = \"\\nLazy value forced at:\" in\n let _s', y =\n Simple.eval (x ())\n (Run_state.set_stack s (old_stack @ (label :: stack)))\n in\n y ) ) )\n\n let with_label lab t : _ Simple.t =\n Function\n (fun s ->\n let stack = Run_state.stack s in\n Option.iter (Run_state.log_constraint s) ~f:(fun f ->\n f ~at_label_boundary:(`Start, lab) None ) ;\n let s', y = Simple.eval (t ()) (Run_state.set_stack s (lab :: stack)) in\n Option.iter (Run_state.log_constraint s) ~f:(fun f ->\n f ~at_label_boundary:(`End, lab) None ) ;\n (Run_state.set_stack s' stack, y) )\n\n let log_constraint { basic; _ } s =\n match basic with\n | Boolean var ->\n Format.(asprintf \"Boolean %s\" (Field.to_string (get_value s var)))\n | Equal (var1, var2) ->\n Format.(\n asprintf \"Equal %s %s\"\n (Field.to_string (get_value s var1))\n (Field.to_string (get_value s var2)))\n | Square (var1, var2) ->\n Format.(\n asprintf \"Square %s %s\"\n (Field.to_string (get_value s var1))\n (Field.to_string (get_value s var2)))\n | R1CS (var1, var2, var3) ->\n Format.(\n asprintf \"R1CS %s %s %s\"\n (Field.to_string (get_value s var1))\n (Field.to_string (get_value s var2))\n (Field.to_string (get_value s var3)))\n | _ ->\n Format.asprintf\n !\"%{sexp:(Field.t, Field.t) Constraint0.basic}\"\n (Constraint0.Basic.map basic ~f:(get_value s))\n\n let add_constraint ~stack ({ basic; annotation } : Constraint.t)\n (Constraint_system.T ((module C), system) : Field.t Constraint_system.t) =\n let label = Option.value annotation ~default:\"\" in\n C.add_constraint system basic ~label:(stack_to_string (label :: stack))\n\n let add_constraint c : _ Simple.t =\n Function\n (fun s ->\n if Run_state.as_prover s then\n (* Don't add constraints as the prover, or the constraint system won't match! *)\n (s, ())\n else (\n Option.iter (Run_state.log_constraint s) ~f:(fun f -> f (Some c)) ;\n if\n Run_state.eval_constraints s\n && !eval_constraints\n && not (Constraint.eval c (get_value s))\n then\n failwithf\n \"Constraint unsatisfied (unreduced):\\n\\\n %s\\n\\\n %s\\n\\n\\\n Constraint:\\n\\\n %s\\n\\\n Data:\\n\\\n %s\"\n (Constraint.annotation c)\n (stack_to_string (Run_state.stack s))\n (Sexp.to_string (Constraint.sexp_of_t c))\n (log_constraint c s) () ;\n if not (Run_state.as_prover s) then\n Option.iter (Run_state.system s) ~f:(fun system ->\n add_constraint ~stack:(Run_state.stack s) c system ) ;\n (s, ()) ) )\n\n let with_handler h t : _ Simple.t =\n Function\n (fun s ->\n let handler = Run_state.handler s in\n let s', y =\n Simple.eval (t ())\n (Run_state.set_handler s (Request.Handler.push handler h))\n in\n (Run_state.set_handler s' handler, y) )\n\n let exists\n (Types.Typ.Typ\n { Types.Typ.var_of_fields\n ; value_to_fields\n ; size_in_field_elements\n ; check\n ; constraint_system_auxiliary\n ; _\n } :\n (_, _, _, _ Simple.t) Types.Typ.typ ) p : _ Simple.t =\n Function\n (fun s ->\n if Run_state.has_witness s then (\n let old = Run_state.as_prover s in\n Run_state.set_as_prover s true ;\n let value =\n As_prover.Provider.run p (Run_state.stack s) (get_value s)\n (Run_state.handler s)\n in\n Run_state.set_as_prover s old ;\n let var =\n let store_value =\n if Run_state.as_prover s then\n (* If we're nested in a prover block, create constants instead of\n storing.\n *)\n Cvar.constant\n else Run_state.store_field_elt s\n in\n let fields, aux = value_to_fields value in\n let field_vars = Array.map ~f:store_value fields in\n var_of_fields (field_vars, aux)\n in\n (* TODO: Push a label onto the stack here *)\n let s, () = Simple.eval (check var) s in\n (s, { Handle.var; value = Some value }) )\n else\n let var =\n var_of_fields\n ( Array.init size_in_field_elements ~f:(fun _ ->\n Run_state.alloc_var s () )\n , constraint_system_auxiliary () )\n in\n (* TODO: Push a label onto the stack here *)\n let s, () = Simple.eval (check var) s in\n (s, { Handle.var; value = None }) )\n\n let next_auxiliary () : _ Simple.t =\n Function (fun s -> (s, Run_state.next_auxiliary s))\n\n let direct f : _ Simple.t = Function f\n\n let constraint_count ?(weight = Fn.const 1)\n ?(log = fun ?start:_ _lab _pos -> ()) (t : unit -> _ Simple.t) =\n (* TODO: Integrate log with log_constraint *)\n let count = ref 0 in\n let log_constraint ?at_label_boundary c =\n ( match at_label_boundary with\n | None ->\n ()\n | Some (pos, lab) ->\n let start = match pos with `Start -> true | _ -> false in\n log ~start lab !count ) ;\n count := !count + Option.value_map ~default:0 ~f:weight c\n in\n let state =\n Run_state.make ~num_inputs:0 ~input:Run_state.Vector.null\n ~next_auxiliary:(ref 1) ~aux:Run_state.Vector.null\n ~eval_constraints:false ~log_constraint ~with_witness:false ()\n in\n let _ = Simple.eval (t ()) state in\n !count\nend\n\nmodule type Run_extras = sig\n type field\n\n type cvar\n\n module Types : Types.Types\n\n val get_value : field Run_state.t -> cvar -> field\n\n val run_as_prover :\n ('a, field) As_prover0.t option\n -> field Run_state.t\n -> field Run_state.t * 'a option\nend\n\nmodule Make (Backend : Backend_extended.S) = struct\n open Backend\n\n type 'f field = 'f\n\n let constraint_logger = ref None\n\n let set_constraint_logger f = constraint_logger := Some f\n\n let clear_constraint_logger () = constraint_logger := None\n\n module Checked_runner = Make_checked (Backend) (As_prover0)\n\n type run_state = Checked_runner.run_state\n\n type state = run_state\n\n type ('a, 't) run = 't -> run_state -> run_state * 'a\n\n include (\n Checked_runner :\n sig\n include\n Checked_intf.Basic\n with module Types := Checked_runner.Types\n with type 'f field := 'f Checked_runner.field\n\n include\n Run_extras\n with module Types := Checked_runner.Types\n with type field := Backend.Field.t\n and type cvar := Backend.Cvar.t\n end )\n\n module Types = Checked_runner.Types\n\n let run = Simple.eval\n\n let dummy_vector = Run_state.Vector.null\n\n let fake_state next_auxiliary stack =\n Run_state.make ~num_inputs:0 ~input:Run_state.Vector.null ~next_auxiliary\n ~aux:Run_state.Vector.null ~eval_constraints:false ~stack\n ~with_witness:false ()\n\n module State = struct\n let make ~num_inputs ~input ~next_auxiliary ~aux ?system\n ?(eval_constraints = !eval_constraints_ref) ?handler ~with_witness\n ?log_constraint () =\n let log_constraint =\n match log_constraint with\n | Some _ ->\n log_constraint\n | None ->\n !constraint_logger\n in\n (* We can't evaluate the constraints if we are not computing over a value. *)\n let eval_constraints = eval_constraints && with_witness in\n Option.iter\n (system : R1CS_constraint_system.t option)\n ~f:(fun system ->\n R1CS_constraint_system.set_primary_input_size system num_inputs ) ;\n let system =\n Option.map system ~f:(fun sys ->\n let module M = struct\n module Field = struct\n type nonrec t = Field.t\n end\n\n include R1CS_constraint_system\n end in\n Constraint_system.T ((module M), sys) )\n in\n Run_state.make ~num_inputs ~input ~next_auxiliary ~aux ?system\n ~eval_constraints ?log_constraint ?handler ~with_witness ()\n end\nend\n\nmodule type S = sig\n include Run_extras\n\n type constr\n\n type r1cs\n\n val set_constraint_logger :\n (?at_label_boundary:[ `Start | `End ] * string -> constr -> unit) -> unit\n\n val clear_constraint_logger : unit -> unit\n\n type run_state = field Run_state.t\n\n type state = run_state\n\n type ('a, 't) run = 't -> run_state -> run_state * 'a\n\n val run : ('a, field) Types.Checked.t -> run_state -> run_state * 'a\n\n module State : sig\n val make :\n num_inputs:int\n -> input:field Run_state.Vector.t\n -> next_auxiliary:int ref\n -> aux:field Run_state.Vector.t\n -> ?system:r1cs\n -> ?eval_constraints:bool\n -> ?handler:Request.Handler.t\n -> with_witness:bool\n -> ?log_constraint:\n ( ?at_label_boundary:[ `End | `Start ] * string\n -> (field Cvar.t, field) Constraint.t option\n -> unit )\n -> unit\n -> field Run_state.t\n end\nend\n","open Core_kernel\nmodule Cvar0 = Cvar\nmodule Runner = Checked_runner\n\nlet set_eval_constraints b = Runner.eval_constraints := b\n\nmodule Make\n (Backend : Backend_extended.S)\n (Checked : Checked_intf.Extended with type field = Backend.Field.t)\n (As_prover : As_prover0.Extended with type field := Backend.Field.t)\n (Runner : Runner.S\n with module Types := Checked.Types\n with type field := Backend.Field.t\n and type cvar := Backend.Cvar.t\n and type constr := Backend.Constraint.t option\n and type r1cs := Backend.R1CS_constraint_system.t) =\nstruct\n open Backend\n\n open Runners.Make (Backend) (Checked) (As_prover) (Runner)\n\n module Typ = struct\n include Types.Typ.T\n module T = Typ.Make (Checked_intf.Unextend (Checked))\n include T.T\n\n type ('var, 'value) t = ('var, 'value, Field.t) T.t\n\n let unit : (unit, unit) t = unit ()\n\n let field : (Cvar.t, Field.t) t = field ()\n end\n\n open (\n Checked :\n Checked_intf.Extended\n with module Types := Checked.Types\n with type field := field )\n\n (* [equal_constraints z z_inv r] asserts that\n if z = 0 then r = 1, or\n if z <> 0 then r = 0 and z * z_inv = 1\n *)\n let equal_constraints (z : Cvar.t) (z_inv : Cvar.t) (r : Cvar.t) =\n Checked.assert_all\n [ Constraint.r1cs ~label:\"equals_1\" z_inv z Cvar.(constant Field.one - r)\n ; Constraint.r1cs ~label:\"equals_2\" r z (Cvar.constant Field.zero)\n ]\n\n (* [equal_vars z] computes [(r, z_inv)] that satisfy the constraints in\n [equal_constraints z z_inv r].\n\n In particular, [r] is [1] if [z = 0] and [0] otherwise.\n *)\n let equal_vars (z : Cvar.t) : (Field.t * Field.t) As_prover.t =\n let open As_prover.Let_syntax in\n let%map z = As_prover.read_var z in\n if Field.equal z Field.zero then (Field.one, Field.zero)\n else (Field.zero, Field.inv z)\n\n let constant (Typ typ : _ Typ.t) x =\n let fields, aux = typ.value_to_fields x in\n let field_vars = Array.map fields ~f:(fun x -> Cvar0.Constant x) in\n typ.var_of_fields (field_vars, aux)\n\n let equal (x : Cvar.t) (y : Cvar.t) : Cvar.t Boolean.t Checked.t =\n match (x, y) with\n | Constant x, Constant y ->\n Checked.return\n (Boolean.Unsafe.create\n (Cvar.constant\n (if Field.equal x y then Field.one else Field.zero) ) )\n | _ ->\n let z = Cvar.(x - y) in\n let%bind r, inv =\n Checked.exists Typ.(tuple2 field field) ~compute:(equal_vars z)\n in\n let%map () = equal_constraints z inv r in\n Boolean.Unsafe.create r\n\n let mul ?(label = \"Checked.mul\") (x : Cvar.t) (y : Cvar.t) =\n match (x, y) with\n | Constant x, Constant y ->\n return (Cvar.constant (Field.mul x y))\n | Constant x, _ ->\n return (Cvar.scale y x)\n | _, Constant y ->\n return (Cvar.scale x y)\n | _, _ ->\n with_label label (fun () ->\n let open Let_syntax in\n let%bind z =\n Checked.exists Typ.field\n ~compute:As_prover.(map2 (read_var x) (read_var y) ~f:Field.mul)\n in\n let%map () = assert_r1cs x y z in\n z )\n\n let square ?(label = \"Checked.square\") (x : Cvar.t) =\n match x with\n | Constant x ->\n return (Cvar.constant (Field.square x))\n | _ ->\n with_label label (fun () ->\n let open Let_syntax in\n let%bind z =\n exists Typ.field\n ~compute:As_prover.(map (read_var x) ~f:Field.square)\n in\n let%map () = assert_square x z in\n z )\n\n (* We get a better stack trace by failing at the call to is_satisfied, so we\n put a bogus value for the inverse to make the constraint system unsat if\n x is zero. *)\n let inv ?(label = \"Checked.inv\") (x : Cvar.t) =\n match x with\n | Constant x ->\n return (Cvar.constant (Field.inv x))\n | _ ->\n with_label label (fun () ->\n let open Let_syntax in\n let%bind x_inv =\n exists Typ.field\n ~compute:\n As_prover.(\n map (read_var x) ~f:(fun x ->\n if Field.(equal zero x) then Field.zero\n else Backend.Field.inv x ))\n in\n let%map () =\n assert_r1cs ~label:\"field_inverse\" x x_inv\n (Cvar.constant Field.one)\n in\n x_inv )\n\n let div ?(label = \"Checked.div\") (x : Cvar.t) (y : Cvar.t) =\n match (x, y) with\n | Constant x, Constant y ->\n return (Cvar.constant (Field.( / ) x y))\n | _ ->\n with_label label (fun () ->\n let open Let_syntax in\n let%bind y_inv = inv y in\n mul x y_inv )\n\n let%snarkydef_ if_ (b : Cvar.t Boolean.t) ~(then_ : Cvar.t) ~(else_ : Cvar.t)\n =\n let open Let_syntax in\n (* r = e + b (t - e)\n r - e = b (t - e)\n *)\n let b = (b :> Cvar.t) in\n match b with\n | Constant b ->\n if Field.(equal b one) then return then_ else return else_\n | _ -> (\n match (then_, else_) with\n | Constant t, Constant e ->\n return Cvar.((t * b) + (e * (constant Field0.one - b)))\n | _, _ ->\n let%bind r =\n exists Typ.field\n ~compute:\n (let open As_prover in\n let open Let_syntax in\n let%bind b = read_var b in\n read Typ.field\n (if Field.equal b Field.one then then_ else else_))\n in\n let%map () = assert_r1cs b Cvar.(then_ - else_) Cvar.(r - else_) in\n r )\n\n let%snarkydef_ assert_non_zero (v : Cvar.t) =\n let open Let_syntax in\n let%map _ = inv v in\n ()\n\n module Boolean = struct\n open Boolean.Unsafe\n\n type var = Cvar.t Boolean.t\n\n type value = bool\n\n let true_ : var = create (Cvar.constant Field.one)\n\n let false_ : var = create (Cvar.constant Field.zero)\n\n let not (x : var) : var = create Cvar.((true_ :> Cvar.t) - (x :> Cvar.t))\n\n let if_ b ~(then_ : var) ~(else_ : var) =\n map ~f:create (if_ b ~then_:(then_ :> Cvar.t) ~else_:(else_ :> Cvar.t))\n\n (* This is unused for now as we are not using any square constraint system based\n backends. *)\n let _and_for_square_constraint_systems (x : var) (y : var) =\n (* (x + y)^2 = 2 z + x + y\n\n x^2 + 2 x*y + y^2 = 2 z + x + y\n x + 2 x*y + y = 2 z + x + y\n 2 x*y = 2 z\n x * y = z\n *)\n let x = (x :> Cvar.t) in\n let y = (y :> Cvar.t) in\n let open Let_syntax in\n let%bind z =\n exists Typ.field\n ~compute:\n (let open As_prover in\n let open Let_syntax in\n let%map x = read_var x and y = read_var y in\n if Field.(equal one x) && Field.(equal one y) then Field.one\n else Field.zero)\n in\n let%map () =\n let x_plus_y = Cvar.add x y in\n assert_square x_plus_y Cvar.((Field.of_int 2 * z) + x_plus_y)\n in\n create z\n\n let ( && ) (x : var) (y : var) : var Checked.t =\n Checked.map ~f:create (mul (x :> Cvar.t) (y :> Cvar.t))\n\n let ( &&& ) = ( && )\n\n let ( || ) x y =\n let open Let_syntax in\n let%map both_false = (not x) && not y in\n not both_false\n\n let ( ||| ) = ( || )\n\n let any = function\n | [] ->\n return false_\n | [ b1 ] ->\n return b1\n | [ b1; b2 ] ->\n b1 || b2\n | bs ->\n let open Let_syntax in\n let%map all_zero =\n equal (Cvar.sum (bs :> Cvar.t list)) (Cvar.constant Field.zero)\n in\n not all_zero\n\n let all = function\n | [] ->\n return true_\n | [ b1 ] ->\n return b1\n | [ b1; b2 ] ->\n b1 && b2\n | bs ->\n equal\n (Cvar.constant (Field.of_int (List.length bs)))\n (Cvar.sum (bs :> Cvar.t list))\n\n let to_constant (b : var) =\n Option.map (Cvar.to_constant (b :> Cvar.t)) ~f:Field.(equal one)\n\n let var_of_value b = if b then true_ else false_\n\n let typ : (var, value) Typ.t =\n let (Typ typ) =\n Typ.field\n |> Typ.transport\n ~there:(function true -> Field.one | false -> Field.zero)\n ~back:(fun x -> if Field.equal x Field.zero then false else true)\n |> Typ.transport_var\n ~there:(fun (b : var) -> (b :> Cvar.t))\n ~back:create\n in\n Typ\n { typ with\n check =\n (fun v ->\n Checked.assert_\n (Constraint.boolean ~label:\"boolean-alloc\" (v :> Cvar.t)) )\n }\n\n let typ_unchecked : (var, value) Typ.t =\n let (Typ typ) = typ in\n Typ { typ with check = (fun _ -> Checked.return ()) }\n\n let%test_unit \"all\" =\n let gen =\n let open Quickcheck.Generator in\n let open Let_syntax in\n let%bind length = small_positive_int in\n list_with_length length bool\n in\n Quickcheck.test gen ~sexp_of:[%sexp_of: bool list] ~f:(fun x ->\n let r =\n run_and_check\n (Checked.map ~f:(As_prover.read typ)\n (all (List.map ~f:(constant typ_unchecked) x)) )\n |> Or_error.ok_exn\n in\n [%test_eq: bool] r (List.for_all x ~f:Fn.id) )\n\n let ( lxor ) b1 b2 =\n match (to_constant b1, to_constant b2) with\n | Some b1, Some b2 ->\n return (constant typ (Caml.not (Bool.equal b1 b2)))\n | Some true, None ->\n return (not b2)\n | None, Some true ->\n return (not b1)\n | Some false, None ->\n return b2\n | None, Some false ->\n return b1\n | None, None ->\n (* (1 - 2 a) (1 - 2 b) = 1 - 2 c\n 1 - 2 (a + b) + 4 a b = 1 - 2 c\n - 2 (a + b) + 4 a b = - 2 c\n (a + b) - 2 a b = c\n 2 a b = a + b - c\n *)\n let open Let_syntax in\n let%bind res =\n exists typ_unchecked\n ~compute:\n As_prover.(\n map2 ~f:Bool.( <> ) (read typ_unchecked b1)\n (read typ_unchecked b2))\n in\n let%map () =\n let a = (b1 :> Cvar.t) in\n let b = (b2 :> Cvar.t) in\n let c = (res :> Cvar.t) in\n let open Cvar in\n assert_r1cs (a + a) b (a + b - c)\n in\n res\n\n module Array = struct\n let num_true (bs : var array) =\n Array.fold bs ~init:(Cvar.constant Field.zero) ~f:(fun x y ->\n Cvar.add x (y :> Cvar.t) )\n\n let any = function\n | [||] ->\n return false_\n | [| b1 |] ->\n return b1\n | [| b1; b2 |] ->\n b1 || b2\n | bs ->\n let open Let_syntax in\n let%map all_zero = equal (num_true bs) (Cvar.constant Field.zero) in\n not all_zero\n\n let all = function\n | [||] ->\n return true_\n | [| b1 |] ->\n return b1\n | [| b1; b2 |] ->\n b1 && b2\n | bs ->\n equal (Cvar.constant (Field.of_int (Array.length bs))) (num_true bs)\n\n module Assert = struct\n let any bs = assert_non_zero (num_true bs)\n\n let all bs =\n assert_equal (num_true bs)\n (Cvar.constant (Field.of_int (Array.length bs)))\n end\n end\n\n let equal (a : var) (b : var) = a lxor b >>| not\n\n let of_field x =\n let open Let_syntax in\n let%map () = assert_ (Constraint.boolean x) in\n create x\n\n module Unsafe = struct\n let of_cvar (t : Cvar.t) : var = create t\n end\n\n module Assert = struct\n let ( = ) (x : var) (y : var) = assert_equal (x :> Cvar.t) (y :> Cvar.t)\n\n let is_true (v : var) = v = true_\n\n let%snarkydef_ any (bs : var list) =\n assert_non_zero (Cvar.sum (bs :> Cvar.t list))\n\n let%snarkydef_ all (bs : var list) =\n assert_equal\n (Cvar.sum (bs :> Cvar.t list))\n (Cvar.constant (Field.of_int (List.length bs)))\n\n let%snarkydef_ exactly_one (bs : var list) =\n assert_equal (Cvar.sum (bs :> Cvar.t list)) (Cvar.constant Field.one)\n end\n\n module Expr = struct\n type t = Var of var | And of t list | Or of t list | Not of t\n\n let rec eval t =\n let open Let_syntax in\n match t with\n | Not t ->\n eval t >>| not\n | Var v ->\n return v\n | And ts ->\n Checked.all (List.map ~f:eval ts) >>= all\n | Or ts ->\n Checked.all (List.map ~f:eval ts) >>= any\n\n let assert_ t = eval t >>= Assert.is_true\n\n let ( ! ) v = Var v\n\n let ( && ) x y = And [ x; y ]\n\n let ( &&& ) = ( && )\n\n let ( || ) x y = Or [ x; y ]\n\n let ( ||| ) = ( || )\n\n let not t = Not t\n\n let any xs = Or xs\n\n let all xs = And xs\n end\n end\n\n module Typ2 = Typ\nend\n","open Core_kernel\n\nmodule Address = struct\n type t = int\nend\n\nmodule Free_hash = struct\n type 'a t = Hash_value of 'a | Hash_empty | Merge of 'a t * 'a t\n [@@deriving sexp]\n\n let diff t1 t2 =\n let module M = struct\n exception Done of bool list\n end in\n let rec go path t1 t2 =\n match (t1, t2) with\n | Hash_empty, Hash_empty ->\n None\n | Hash_value x, Hash_value y ->\n (* poly equality; we don't know type of x and y *)\n if Caml.( = ) x y then None else raise (M.Done path)\n | Merge (l1, r1), Merge (l2, r2) ->\n ignore (go (false :: path) l1 l2) ;\n ignore (go (true :: path) r1 r2) ;\n None\n | Hash_empty, Hash_value _\n | Hash_empty, Merge _\n | Hash_value _, Hash_empty\n | Hash_value _, Merge _\n | Merge _, Hash_empty\n | Merge _, Hash_value _ ->\n raise (M.Done path)\n in\n try go [] t1 t2 with M.Done addr -> Some addr\n\n let rec run t ~hash ~merge =\n match t with\n | Hash_value x ->\n hash (Some x)\n | Hash_empty ->\n hash None\n | Merge (l, r) ->\n merge (run ~hash ~merge l) (run ~hash ~merge r)\nend\n\ntype ('hash, 'a) non_empty_tree =\n | Node of 'hash * ('hash, 'a) tree * ('hash, 'a) tree\n | Leaf of 'hash * 'a\n\nand ('hash, 'a) tree = Non_empty of ('hash, 'a) non_empty_tree | Empty\n[@@deriving sexp]\n\ntype ('hash, 'a) t =\n { tree : ('hash, 'a) non_empty_tree\n ; depth : int\n ; count : int\n ; hash : 'a option -> 'hash\n ; merge : 'hash -> 'hash -> 'hash\n }\n[@@deriving sexp]\n\nlet check_exn { tree; hash; merge; _ } =\n let default = hash None in\n let rec check_hash = function\n | Non_empty t ->\n check_hash_non_empty t\n | Empty ->\n default\n and check_hash_non_empty = function\n | Leaf (h, x) ->\n (* poly equality; don't know the hash type *)\n assert (Caml.( = ) h (hash (Some x))) ;\n h\n | Node (h, l, r) ->\n (* poly equality *)\n assert (Caml.( = ) (merge (check_hash l) (check_hash r)) h) ;\n h\n in\n ignore (check_hash_non_empty tree)\n\nlet non_empty_hash = function Node (h, _, _) -> h | Leaf (h, _) -> h\n\nlet depth { depth; _ } = depth\n\nlet tree_hash ~default = function\n | Empty ->\n default\n | Non_empty t ->\n non_empty_hash t\n\nlet to_list : ('hash, 'a) t -> 'a list =\n let rec go acc = function\n | Empty ->\n acc\n | Non_empty (Leaf (_, x)) ->\n x :: acc\n | Non_empty (Node (_h, l, r)) ->\n let acc' = go acc r in\n go acc' l\n in\n fun t -> go [] (Non_empty t.tree)\n\nlet left_tree hash merge depth x =\n let empty_hash = hash None in\n let rec go i h acc =\n if i = depth then (h, acc)\n else\n let h' = merge h empty_hash in\n go (i + 1) h' (Node (h', Non_empty acc, Empty))\n in\n let h = hash (Some x) in\n go 0 h (Leaf (h, x))\n\nlet insert hash merge t0 mask0 address x =\n let default = hash None in\n let rec go mask t =\n if mask = 0 then\n match t with\n | Empty ->\n Leaf (hash (Some x), x)\n | Non_empty _ ->\n failwith \"Tree should be empty\"\n else\n let go_left = mask land address = 0 in\n let mask' = mask lsr 1 in\n match t with\n | Empty ->\n if go_left then\n let t_l' = go mask' Empty in\n Node (merge (non_empty_hash t_l') default, Non_empty t_l', Empty)\n else\n let t_r' = go mask' Empty in\n Node (merge default (non_empty_hash t_r'), Empty, Non_empty t_r')\n | Non_empty (Node (_h, t_l, t_r)) ->\n if go_left then\n let t_l' = go mask' t_l in\n Node\n ( merge (non_empty_hash t_l') (tree_hash ~default t_r)\n , Non_empty t_l'\n , t_r )\n else\n let t_r' = go mask' t_r in\n Node\n ( merge (tree_hash ~default t_l) (non_empty_hash t_r')\n , t_l\n , Non_empty t_r' )\n | Non_empty (Leaf _) ->\n failwith \"Cannot insert into leaf\"\n in\n go mask0 t0\n\nlet ith_bit n i = (n lsr i) land 1 = 1\n\nlet get { tree; depth; _ } addr0 =\n let rec get t i =\n match t with Empty -> None | Non_empty t -> get_non_empty t i\n and get_non_empty t i =\n match t with\n | Node (_, l, r) ->\n let go_right = ith_bit addr0 i in\n if go_right then get r (i - 1) else get l (i - 1)\n | Leaf (_, x) ->\n Some x\n in\n get_non_empty tree (depth - 1)\n\nlet get_exn t addr = Option.value_exn (get t addr)\n\nlet set_dirty default tree addr x =\n let rec go tree addr =\n match (tree, addr) with\n | Empty, go_right :: bs ->\n let t = Non_empty (go Empty bs) in\n let l, r = if go_right then (Empty, t) else (t, Empty) in\n Node (default, l, r)\n | Empty, [] ->\n Leaf (default, x)\n | Non_empty t, _ ->\n go_non_empty t addr\n and go_non_empty tree addr =\n match (tree, addr) with\n | Leaf _, [] ->\n Leaf (default, x)\n | Node (_, l, r), go_right :: bs ->\n let l', r' =\n if go_right then (l, Non_empty (go r bs)) else (Non_empty (go l bs), r)\n in\n Node (default, l', r')\n | Leaf _, _ :: _ | Node _, [] ->\n failwith \"Merkle_tree.set_dirty (go_non_empty): Mismatch\"\n in\n go_non_empty tree (List.rev addr)\n\nlet recompute_hashes { tree; hash; merge; _ } =\n let h =\n let default = hash None in\n fun t -> tree_hash ~default t\n in\n let rec go = function\n | Non_empty t ->\n Non_empty (go_non_empty t)\n | Empty ->\n Empty\n and go_non_empty = function\n | Leaf (_, x) ->\n Leaf (hash (Some x), x)\n | Node (_, l, r) ->\n let l' = go l in\n let r' = go r in\n Node (merge (h l') (h r'), l', r')\n in\n go_non_empty tree\n\nlet address_of_int ~depth n : bool list =\n List.init depth ~f:(fun i -> n land (1 lsl i) <> 0)\n\nlet add_many t xs =\n let default = t.hash None in\n let left_tree_dirty depth x =\n let rec go i acc =\n if i = depth then acc\n else go (i + 1) (Node (default, Non_empty acc, Empty))\n in\n go 0 (Leaf (default, x))\n in\n let add_one_dirty { tree; depth; count; hash; merge } x =\n if count = 1 lsl depth then\n let t_r = left_tree_dirty depth x in\n { tree = Node (default, Non_empty tree, Non_empty t_r)\n ; count = count + 1\n ; depth = depth + 1\n ; hash\n ; merge\n }\n else\n { tree = set_dirty default tree (address_of_int ~depth count) x\n ; count = count + 1\n ; depth\n ; hash\n ; merge\n }\n in\n let t = List.fold_left xs ~init:t ~f:add_one_dirty in\n { t with tree = recompute_hashes t }\n\nlet add { tree; depth; count; hash; merge } x =\n if count = 1 lsl depth then\n let h_r, t_r = left_tree hash merge depth x in\n let h_l = non_empty_hash tree in\n { tree = Node (merge h_l h_r, Non_empty tree, Non_empty t_r)\n ; count = count + 1\n ; depth = depth + 1\n ; hash\n ; merge\n }\n else\n { tree = insert hash merge (Non_empty tree) (1 lsl (depth - 1)) count x\n ; count = count + 1\n ; depth\n ; hash\n ; merge\n }\n\nlet root { tree; _ } = non_empty_hash tree\n\nlet create ~hash ~merge x =\n { tree = Leaf (hash (Some x), x); count = 1; depth = 0; hash; merge }\n\nlet get_path { tree; hash; depth; _ } addr0 =\n let default = hash None in\n let rec go acc t i =\n if i < 0 then acc\n else\n let go_right = ith_bit addr0 i in\n if go_right then\n match t with\n | Leaf _ ->\n failwith \"get_path\"\n | Node (_h, _t_l, Empty) ->\n failwith \"get_path\"\n | Node (_h, t_l, Non_empty t_r) ->\n go (tree_hash ~default t_l :: acc) t_r (i - 1)\n else\n match t with\n | Leaf _ ->\n failwith \"get_path\"\n | Node (_h, Empty, _t_r) ->\n failwith \"get_path\"\n | Node (_h, Non_empty t_l, t_r) ->\n go (tree_hash ~default t_r :: acc) t_l (i - 1)\n in\n go [] tree (depth - 1)\n\nlet implied_root ~merge addr0 entry_hash path0 =\n let rec go acc i path =\n match path with\n | [] ->\n acc\n | h :: hs ->\n go (if ith_bit addr0 i then merge h acc else merge acc h) (i + 1) hs\n in\n go entry_hash 0 path0\n\nlet rec free_tree_hash = function\n | Empty ->\n Free_hash.Hash_empty\n | Non_empty (Leaf (_, x)) ->\n Hash_value x\n | Non_empty (Node (_, l, r)) ->\n Merge (free_tree_hash l, free_tree_hash r)\n\nlet free_root { tree; _ } = free_tree_hash (Non_empty tree)\n\nlet get_free_path { tree; depth; _ } addr0 =\n let rec go acc t i =\n if i < 0 then acc\n else\n let go_right = ith_bit addr0 i in\n if go_right then\n match t with\n | Leaf _ ->\n failwith \"get_path\"\n | Node (_h, _t_l, Empty) ->\n failwith \"get_path\"\n | Node (_h, t_l, Non_empty t_r) ->\n go (free_tree_hash t_l :: acc) t_r (i - 1)\n else\n match t with\n | Leaf _ ->\n failwith \"get_path\"\n | Node (_h, Empty, _t_r) ->\n failwith \"get_path\"\n | Node (_h, Non_empty t_l, t_r) ->\n go (free_tree_hash t_r :: acc) t_l (i - 1)\n in\n go [] tree (depth - 1)\n\nlet implied_free_root addr0 x path0 =\n implied_root\n ~merge:(fun a b -> Free_hash.Merge (a, b))\n addr0 (Hash_value x) path0\n\ntype ('hash, 'a) merkle_tree = ('hash, 'a) t\n\nmodule Checked\n (Impl : Snark_intf.Basic) (Hash : sig\n type var\n\n type value\n\n val typ : (var, value) Impl.Typ.t\n\n val merge : height:int -> var -> var -> var Impl.Checked.t\n\n val if_ : Impl.Boolean.var -> then_:var -> else_:var -> var Impl.Checked.t\n\n val assert_equal : var -> var -> unit Impl.Checked.t\n end) (Elt : sig\n type var\n\n type value\n\n val typ : (var, value) Impl.Typ.t\n\n val hash : var -> Hash.var Impl.Checked.t\n end) =\nstruct\n open Impl\n\n module Address = struct\n type var = Boolean.var list\n\n type value = int\n\n let typ ~depth : (var, value) Typ.t =\n Typ.transport\n (Typ.list ~length:depth Boolean.typ)\n ~there:(address_of_int ~depth)\n ~back:\n (List.foldi ~init:0 ~f:(fun i acc b ->\n if b then acc lor (1 lsl i) else acc ) )\n end\n\n module Path = struct\n type value = Hash.value list\n\n type var = Hash.var list\n\n let typ ~depth : (var, value) Typ.t = Typ.(list ~length:depth Hash.typ)\n end\n\n let implied_root entry_hash addr0 path0 =\n let rec go height acc addr path =\n let open Let_syntax in\n match (addr, path) with\n | [], [] ->\n return acc\n | b :: bs, h :: hs ->\n let%bind l = Hash.if_ b ~then_:h ~else_:acc\n and r = Hash.if_ b ~then_:acc ~else_:h in\n let%bind acc' = Hash.merge ~height l r in\n go (height + 1) acc' bs hs\n | _, _ ->\n failwith\n \"Merkle_tree.Checked.implied_root: address, path length mismatch\"\n in\n go 0 entry_hash addr0 path0\n\n type _ Request.t +=\n | Get_element : Address.value -> (Elt.value * Path.value) Request.t\n | Get_path : Address.value -> Path.value Request.t\n | Set : Address.value * Elt.value -> unit Request.t\n\n (* addr0 should have least significant bit first *)\n let%snarkydef_ fetch_and_update_req ~(depth : int) root addr0 ~f :\n (Hash.var * [ `Old of Elt.var ] * [ `New of Elt.var ]) Checked.t =\n let open Let_syntax in\n let%bind prev, prev_path =\n request_witness\n Typ.(Elt.typ * Path.typ ~depth)\n As_prover.(\n read (Address.typ ~depth) addr0 >>| fun addr -> Get_element addr)\n in\n let%bind () =\n let%bind prev_entry_hash = Elt.hash prev in\n implied_root prev_entry_hash addr0 prev_path >>= Hash.assert_equal root\n in\n let%bind next = f prev in\n let%bind next_entry_hash = Elt.hash next in\n let%bind () =\n perform\n (let open As_prover in\n let open Let_syntax in\n let%map addr = read (Address.typ ~depth) addr0\n and next = read Elt.typ next in\n Set (addr, next))\n in\n let%map new_root = implied_root next_entry_hash addr0 prev_path in\n (new_root, `Old prev, `New next)\n\n (* addr0 should have least significant bit first *)\n let%snarkydef_ modify_req ~(depth : int) root addr0 ~f : Hash.var Checked.t =\n let%map root, _, _ = fetch_and_update_req ~depth root addr0 ~f in\n root\n\n (* addr0 should have least significant bit first *)\n let%snarkydef_ get_req ~(depth : int) root addr0 : Elt.var Checked.t =\n let open Let_syntax in\n let%bind prev, prev_path =\n request_witness\n Typ.(Elt.typ * Path.typ ~depth)\n As_prover.(\n map (read (Address.typ ~depth) addr0) ~f:(fun a -> Get_element a))\n in\n let%bind () =\n let%bind prev_entry_hash = Elt.hash prev in\n implied_root prev_entry_hash addr0 prev_path >>= Hash.assert_equal root\n in\n return prev\n\n (* addr0 should have least significant bit first *)\n let%snarkydef_ update_req ~(depth : int) ~root ~prev ~next addr0 :\n Hash.var Checked.t =\n let open Let_syntax in\n let%bind prev_entry_hash = Elt.hash prev\n and next_entry_hash = Elt.hash next\n and prev_path =\n request_witness (Path.typ ~depth)\n As_prover.(\n map (read (Address.typ ~depth) addr0) ~f:(fun a -> Get_path a))\n in\n let%bind () =\n implied_root prev_entry_hash addr0 prev_path >>= Hash.assert_equal root\n in\n let%bind () =\n perform\n (let open As_prover in\n let open Let_syntax in\n let%map addr = read (Address.typ ~depth) addr0\n and next = read Elt.typ next in\n Set (addr, next))\n in\n implied_root next_entry_hash addr0 prev_path\nend\n\nmodule Run = struct\n module Make\n (Impl : Snark_intf.Run_basic) (Hash : sig\n type var\n\n type value\n\n val typ : (var, value) Impl.Typ.t\n\n val merge : height:int -> var -> var -> var\n\n val if_ : Impl.Boolean.var -> then_:var -> else_:var -> var\n\n val assert_equal : var -> var -> unit\n end) (Elt : sig\n type var\n\n type value\n\n val typ : (var, value) Impl.Typ.t\n\n val hash : var -> Hash.var\n end) =\n struct\n open Impl\n\n include\n Checked\n (Impl.Internal_Basic)\n (struct\n include Hash\n\n let merge ~height x y = make_checked (fun () -> merge ~height x y)\n\n let if_ x ~then_ ~else_ = make_checked (fun () -> if_ x ~then_ ~else_)\n\n let assert_equal x y = make_checked (fun () -> assert_equal x y)\n end)\n (struct\n include Elt\n\n let hash var = make_checked (fun () -> hash var)\n end)\n\n let implied_root entry_hash addr0 path0 =\n run_checked (implied_root entry_hash addr0 path0)\n\n let modify_req ~depth root addr0 ~f =\n run_checked\n (modify_req ~depth root addr0 ~f:(fun x -> make_checked (fun () -> f x)))\n\n let get_req ~depth root addr0 = run_checked (get_req ~depth root addr0)\n\n let update_req ~depth ~root ~prev ~next addr0 =\n run_checked (update_req ~depth ~root ~prev ~next addr0)\n end\nend\n","open Core_kernel\nmodule Cvar0 = Cvar\nmodule Bignum_bigint = Bigint\n\nexception Runtime_error of string list * exn * string\n\nmodule Runner = Checked_runner\n\nlet set_eval_constraints b = Runner.eval_constraints := b\n\nmodule Make_basic\n (Backend : Backend_extended.S)\n (Checked : Checked_intf.Extended with type field = Backend.Field.t)\n (As_prover : As_prover0.Extended with type field := Backend.Field.t)\n (Ref : As_prover_ref.S\n with module Types := Checked.Types\n and type 'f field := Backend.Field.t\n and type ('a, 'f) checked := 'a Checked.t)\n (Runner : Runner.S\n with module Types := Checked.Types\n with type field := Backend.Field.t\n and type cvar := Backend.Cvar.t\n and type constr := Backend.Constraint.t option\n and type r1cs := Backend.R1CS_constraint_system.t) =\nstruct\n open Backend\n module Checked_S = Checked_intf.Unextend (Checked)\n include Runners.Make (Backend) (Checked) (As_prover) (Runner)\n module Bigint = Bigint\n module Field0 = Field\n module Cvar = Cvar\n module Constraint = Constraint\n\n module Handler = struct\n type t = Request.request -> Request.response\n end\n\n module Typ = struct\n include Types.Typ.T\n module T = Typ.Make (Checked_S)\n include T.T\n\n type ('var, 'value) t = ('var, 'value, Field.t) T.t\n\n let unit : (unit, unit) t = unit ()\n\n let field : (Cvar.t, Field.t) t = field ()\n end\n\n let constant (Typ typ : _ Typ.t) x =\n let fields, aux = typ.value_to_fields x in\n let field_vars = Array.map fields ~f:(fun x -> Cvar0.Constant x) in\n typ.var_of_fields (field_vars, aux)\n\n module As_prover = struct\n include As_prover\n\n type 'a as_prover = 'a t\n\n module Ref = Ref\n end\n\n module Handle = struct\n include Handle\n\n let value = As_prover.Handle.value\n end\n\n module Checked = struct\n include (\n Checked :\n Checked_intf.Extended\n with module Types := Checked.Types\n with type field := field )\n\n let perform req = request_witness Typ.unit req\n\n module Runner = Runner\n\n type run_state = Runner.run_state\n\n include Utils.Make (Backend) (Checked) (As_prover) (Runner)\n\n module Control = struct end\n\n let two_to_the n =\n let rec go acc i =\n if i = 0 then acc else go (Field0.add acc acc) (i - 1)\n in\n go Field0.one n\n\n type _ Request.t += Choose_preimage : Field.t * int -> bool list Request.t\n\n let choose_preimage_unchecked v ~length =\n exists\n (Typ.list Boolean.typ ~length)\n ~request:\n As_prover.(map (read_var v) ~f:(fun x -> Choose_preimage (x, length)))\n ~compute:\n (let open As_prover.Let_syntax in\n let%map x = As_prover.read_var v in\n let x = Bigint.of_field x in\n List.init length ~f:(fun i -> Bigint.test_bit x i))\n\n let packing_sum (bits : Boolean.var list) =\n let ts, _ =\n List.fold_left bits ~init:([], Field.one) ~f:(fun (acc, c) v ->\n ((c, (v :> Cvar.t)) :: acc, Field.add c c) )\n in\n Cvar.linear_combination ts\n\n let choose_preimage (v : Cvar.t) ~length : Boolean.var list t =\n let open Let_syntax in\n let%bind bits = choose_preimage_unchecked v ~length in\n let lc = packing_sum bits in\n let%map () =\n assert_r1cs ~label:\"Choose_preimage\" lc (Cvar.constant Field.one) v\n in\n bits\n\n let choose_preimage_flagged (v : Cvar.t) ~length =\n let open Let_syntax in\n let%bind bits = choose_preimage_unchecked v ~length in\n let lc = packing_sum bits in\n let%map success = equal lc v in\n (bits, `Success success)\n\n module List =\n Monad_sequence.List\n (Checked)\n (struct\n type t = Boolean.var\n\n include Boolean\n end)\n\n module Array =\n Monad_sequence.Array\n (Checked)\n (struct\n type t = Boolean.var\n\n let any = Boolean.Array.any\n\n let all = Boolean.Array.all\n end)\n end\n\n module Cvar1 = struct\n include Cvar\n\n let project =\n let two = Field.of_int 2 in\n fun (vars : Checked.Boolean.var list) ->\n let rec go res = function\n | [] ->\n res\n | v :: vs ->\n go Cvar0.(Add (v, Scale (two, res))) vs\n in\n match List.rev (vars :> Cvar.t list) with\n | [] ->\n Cvar0.Constant Field.zero\n | v :: vs ->\n go v vs\n\n let pack vars =\n assert (List.length vars < Field.size_in_bits) ;\n project vars\n\n let unpack v ~length =\n assert (length < Field.size_in_bits) ;\n Checked.choose_preimage v ~length\n\n let unpack_flagged v ~length =\n assert (length < Field.size_in_bits) ;\n Checked.choose_preimage_flagged v ~length\n end\n\n module Field = struct\n include Field0\n\n let gen =\n Quickcheck.Generator.map\n Bignum_bigint.(gen_incl zero (size - one))\n ~f:(fun x -> Bigint.(to_field (of_bignum_bigint x)))\n\n let gen_incl lo hi =\n let lo_bigint = Bigint.(to_bignum_bigint @@ of_field lo) in\n let hi_bigint = Bigint.(to_bignum_bigint @@ of_field hi) in\n Quickcheck.Generator.map\n Bignum_bigint.(gen_incl lo_bigint hi_bigint)\n ~f:(fun x -> Bigint.(to_field (of_bignum_bigint x)))\n\n let gen_uniform =\n Quickcheck.Generator.map\n Bignum_bigint.(gen_uniform_incl zero (size - one))\n ~f:(fun x -> Bigint.(to_field (of_bignum_bigint x)))\n\n let gen_uniform_incl lo hi =\n let lo_bigint = Bigint.(to_bignum_bigint @@ of_field lo) in\n let hi_bigint = Bigint.(to_bignum_bigint @@ of_field hi) in\n Quickcheck.Generator.map\n Bignum_bigint.(gen_uniform_incl lo_bigint hi_bigint)\n ~f:(fun x -> Bigint.(to_field (of_bignum_bigint x)))\n\n let typ = Typ.field\n\n module Var = Cvar1\n\n let parity x = Bigint.(test_bit (of_field x) 0)\n\n module Checked = struct\n include Cvar1\n\n let equal = Checked.equal\n\n let mul x y = Checked.mul ~label:\"Field.Checked.mul\" x y\n\n let square x = Checked.square ~label:\"Field.Checked.square\" x\n\n let div x y = Checked.div ~label:\"Field.Checked.div\" x y\n\n let inv x = Checked.inv ~label:\"Field.Checked.inv\" x\n\n let sqrt (x : Cvar.t) : Cvar.t Checked.t =\n match x with\n | Constant x ->\n Checked.return (Cvar.constant (Field.sqrt x))\n | _ ->\n let open Checked in\n let open Let_syntax in\n let%bind y =\n exists ~compute:As_prover.(map (read_var x) ~f:Field.sqrt) typ\n in\n let%map () = assert_square y x in\n y\n\n let quadratic_nonresidue =\n lazy\n (let rec go i =\n let x = Field.of_int i in\n if not (Field.is_square x) then x else go Int.(i + 1)\n in\n go 2 )\n\n (* The trick here is the following.\n\n Let beta be a known non-square.\n\n x is not a square iff beta*x is a square\n\n So we guess the result [is_square] and y a sqrt of one of {x, beta*x} and assert\n\n y * y = is_square * x + (1 - is_square) * (beta * x)\n\n which, letting B = beta*x holds iff\n\n y * y\n = is_square * x + B - is_square * B\n = is_square * (x - B) + B\n *)\n let sqrt_check x =\n let open Checked in\n let open Let_syntax in\n let%bind is_square =\n exists\n ~compute:As_prover.(map (read_var x) ~f:Field.is_square)\n Boolean.typ\n in\n let%bind y =\n exists typ\n ~compute:\n As_prover.(\n Let_syntax.(\n let%map is_square = read Boolean.typ is_square\n and x = read_var x in\n if is_square then Field.sqrt x\n else Field.(sqrt (Lazy.force quadratic_nonresidue * x))))\n in\n let b = scale x (Lazy.force quadratic_nonresidue) in\n let%bind t = mul (is_square :> Var.t) (x - b) in\n let%map () = assert_square y (t + b) in\n (y, is_square)\n\n let is_square x =\n let open Checked.Let_syntax in\n let%map _, b = sqrt_check x in\n b\n\n let%test_unit \"is_square\" =\n let x = Field.random () in\n let typf = Typ.field in\n let x2 = Field.square x in\n assert (Field.(equal (x * x) x2)) ;\n let run elt =\n let answer =\n run_and_check\n (Checked.map\n ~f:(As_prover.read Checked.Boolean.typ)\n Checked.(\n Let_syntax.(\n let%bind x = exists typf ~compute:(As_prover.return elt) in\n is_square x)) )\n |> Or_error.ok_exn\n in\n answer\n in\n assert (run x2) ;\n assert (not (run (Field.mul (Lazy.force quadratic_nonresidue) x2)))\n\n let choose_preimage_var = Checked.choose_preimage\n\n type comparison_result =\n { less : Checked.Boolean.var; less_or_equal : Checked.Boolean.var }\n\n let if_ = Checked.if_\n\n let compare ~bit_length a b =\n (* Overview of the logic:\n let n = bit_length\n We have 0 <= a < 2^n, 0 <= b < 2^n, and so\n -2^n < b - a < 2^n\n If (b - a) >= 0, then\n 2^n <= 2^n + b - a < 2^{n+1},\n and so the n-th bit must be set.\n If (b - a) < 0 then\n 0 < 2^n + b - a < 2^n\n and so the n-th bit must not be set.\n Thus, we can use the n-th bit of 2^n + b - a to determine whether\n (b - a) >= 0 <-> a <= b.\n\n We also need that the maximum value\n 2^n + (2^n - 1) - 0 = 2^{n+1} - 1\n fits inside the field, so for the max field element f,\n 2^{n+1} - 1 <= f -> n+1 <= log2(f) = size_in_bits - 1\n *)\n assert (Int.(bit_length <= size_in_bits - 2)) ;\n let open Checked in\n let open Let_syntax in\n [%with_label_ \"compare\"] (fun () ->\n let alpha_packed =\n Cvar.(constant (two_to_the bit_length) + b - a)\n in\n let%bind alpha = unpack alpha_packed ~length:Int.(bit_length + 1) in\n let prefix, less_or_equal =\n match Core_kernel.List.split_n alpha bit_length with\n | p, [ l ] ->\n (p, l)\n | _ ->\n failwith \"compare: Invalid alpha\"\n in\n let%bind not_all_zeros = Boolean.any prefix in\n let%map less = Boolean.(less_or_equal && not_all_zeros) in\n { less; less_or_equal } )\n\n module Assert = struct\n let lt ~bit_length (x : Cvar.t) (y : Cvar.t) =\n match (x, y) with\n | Constant x, Constant y ->\n assert (Field.compare x y < 0) ;\n Checked.return ()\n | _ ->\n let open Checked in\n let open Let_syntax in\n let%bind { less; _ } = compare ~bit_length x y in\n Boolean.Assert.is_true less\n\n let lte ~bit_length (x : Cvar.t) (y : Cvar.t) =\n match (x, y) with\n | Constant x, Constant y ->\n assert (Field.compare x y <= 0) ;\n Checked.return ()\n | _ ->\n let open Checked in\n let open Let_syntax in\n let%bind { less_or_equal; _ } = compare ~bit_length x y in\n Boolean.Assert.is_true less_or_equal\n\n let gt ~bit_length x y = lt ~bit_length y x\n\n let gte ~bit_length x y = lte ~bit_length y x\n\n let non_zero (v : Cvar.t) =\n match v with\n | Constant v ->\n if Field.(equal zero v) then\n failwithf \"assert_non_zero: failed on constant %s\"\n (Field.to_string v) () ;\n Checked.return ()\n | _ ->\n Checked.assert_non_zero v\n\n let equal x y = Checked.assert_equal ~label:\"Checked.Assert.equal\" x y\n\n let not_equal (x : t) (y : t) =\n match (x, y) with\n | Constant x, Constant y ->\n if Field.(equal x y) then\n failwithf \"not_equal: failed on constants %s and %s\"\n (Field.to_string x) (Field.to_string y) () ;\n Checked.return ()\n | _, _ ->\n Checked.with_label \"Checked.Assert.not_equal\" (fun () ->\n non_zero (sub x y) )\n end\n\n let lt_bitstring_value =\n let module Boolean = Checked.Boolean in\n let module Expr = struct\n module Binary = struct\n type 'a t = Lit of 'a | And of 'a * 'a t | Or of 'a * 'a t\n end\n\n module Nary = struct\n type 'a t = Lit of 'a | And of 'a t list | Or of 'a t list\n\n let rec of_binary : 'a Binary.t -> 'a t = function\n | Lit x ->\n Lit x\n | And (x, And (y, t)) ->\n And [ Lit x; Lit y; of_binary t ]\n | Or (x, Or (y, t)) ->\n Or [ Lit x; Lit y; of_binary t ]\n | And (x, t) ->\n And [ Lit x; of_binary t ]\n | Or (x, t) ->\n Or [ Lit x; of_binary t ]\n\n let rec eval =\n let open Checked.Let_syntax in\n function\n | Lit x ->\n return x\n | And xs ->\n Checked.List.map xs ~f:eval >>= Boolean.all\n | Or xs ->\n Checked.List.map xs ~f:eval >>= Boolean.any\n end\n end in\n let rec lt_binary xs ys : Boolean.var Expr.Binary.t =\n match (xs, ys) with\n | [], [] ->\n Lit Boolean.false_\n | [ _x ], [ false ] ->\n Lit Boolean.false_\n | [ x ], [ true ] ->\n Lit (Boolean.not x)\n | [ x1; _x2 ], [ true; false ] ->\n Lit (Boolean.not x1)\n | [ _x1; _x2 ], [ false; false ] ->\n Lit Boolean.false_\n | x :: xs, false :: ys ->\n And (Boolean.not x, lt_binary xs ys)\n | x :: xs, true :: ys ->\n Or (Boolean.not x, lt_binary xs ys)\n | _ :: _, [] | [], _ :: _ ->\n failwith \"lt_bitstring_value: Got unequal length strings\"\n in\n fun (xs : Boolean.var Bitstring_lib.Bitstring.Msb_first.t)\n (ys : bool Bitstring_lib.Bitstring.Msb_first.t) ->\n let open Expr.Nary in\n eval\n (of_binary (lt_binary (xs :> Boolean.var list) (ys :> bool list)))\n\n let field_size_bits =\n List.init Field.size_in_bits ~f:(fun i ->\n Z.testbit\n (Bignum_bigint.to_zarith_bigint Field.size)\n Stdlib.(Field.size_in_bits - 1 - i) )\n |> Bitstring_lib.Bitstring.Msb_first.of_list\n\n let unpack_full x =\n let module Bitstring = Bitstring_lib.Bitstring in\n let open Checked.Let_syntax in\n let%bind res =\n choose_preimage_var x ~length:Field.size_in_bits\n >>| Bitstring.Lsb_first.of_list\n in\n let%map () =\n lt_bitstring_value\n (Bitstring.Msb_first.of_lsb_first res)\n field_size_bits\n >>= Checked.Boolean.Assert.is_true\n in\n res\n\n let parity ?length x =\n let open Checked in\n let unpack =\n let unpack_full x =\n unpack_full x >>| Bitstring_lib.Bitstring.Lsb_first.to_list\n in\n match length with\n | None ->\n unpack_full\n | Some length ->\n let length = Int.min length Field.size_in_bits in\n if Int.equal length Field.size_in_bits then unpack_full\n else choose_preimage_var ~length\n in\n unpack x >>| Base.List.hd_exn\n end\n end\n\n module Bitstring_checked = struct\n type t = Checked.Boolean.var list\n\n let lt_value = Field.Checked.lt_bitstring_value\n\n let chunk_for_equality (t1 : t) (t2 : t) =\n let chunk_size = Field.size_in_bits - 1 in\n let rec go acc t1 t2 =\n match (t1, t2) with\n | [], [] ->\n acc\n | _, _ ->\n let t1_a, t1_b = List.split_n t1 chunk_size in\n let t2_a, t2_b = List.split_n t2 chunk_size in\n go ((t1_a, t2_a) :: acc) t1_b t2_b\n in\n go [] t1 t2\n\n let equal t1 t2 =\n let open Checked in\n all\n (Base.List.map (chunk_for_equality t1 t2) ~f:(fun (x1, x2) ->\n equal (Cvar1.pack x1) (Cvar1.pack x2) ) )\n >>= Boolean.all\n\n let equal_expect_true t1 t2 =\n let open Checked in\n all\n (Core_kernel.List.map (chunk_for_equality t1 t2) ~f:(fun (x1, x2) ->\n (* Inlined [Field.equal], but skip creating the field element for\n this chunk if possible.\n *)\n let z = Cvar1.(pack x1 - pack x2) in\n let%bind r, inv =\n exists\n Typ.(field * field)\n ~compute:\n As_prover.(\n match\n Core_kernel.List.map2 x1 x2 ~f:(fun x1 x2 ->\n let%map x1 = read_var (x1 :> Cvar.t)\n and x2 = read_var (x2 :> Cvar.t) in\n Field.equal x1 x2 )\n with\n | Ok res ->\n let%bind res = all res in\n if Core_kernel.List.for_all ~f:Fn.id res then\n return (Field.one, Field.zero)\n else equal_vars z\n | _ ->\n equal_vars z)\n in\n let%map () = equal_constraints z inv r in\n Boolean.Unsafe.of_cvar r ) )\n >>= Boolean.all\n\n module Assert = struct\n let equal t1 t2 =\n let open Checked in\n Base.List.map (chunk_for_equality t1 t2) ~f:(fun (x1, x2) ->\n Constraint.equal (Cvar1.pack x1) (Cvar1.pack x2) )\n |> assert_all ~label:\"Bitstring.Assert.equal\"\n end\n end\n\n let%test_unit \"lt_bitstring_value\" =\n let gen =\n let open Quickcheck.Generator in\n let open Let_syntax in\n let%bind length = small_positive_int in\n let%map x = list_with_length length bool\n and y = list_with_length length bool in\n (x, y)\n in\n Quickcheck.test gen ~f:(fun (x, y) ->\n let correct_answer = [%compare: bool list] x y < 0 in\n let lt =\n run_and_check\n (Checked.map\n ~f:(As_prover.read Checked.Boolean.typ)\n (Field.Checked.lt_bitstring_value\n (Bitstring_lib.Bitstring.Msb_first.of_list\n (List.map ~f:Checked.(constant Boolean.typ) x) )\n (Bitstring_lib.Bitstring.Msb_first.of_list y) ) )\n |> Or_error.ok_exn\n in\n assert (Bool.equal lt correct_answer) )\n\n include Checked\n\n let%snarkydef_ if_ (b : Boolean.var) ~typ:(Typ typ : ('var, _) Typ.t)\n ~(then_ : 'var) ~(else_ : 'var) =\n let then_, then_aux = typ.var_to_fields then_ in\n let else_, else_aux = typ.var_to_fields else_ in\n let%bind res =\n Array.all\n (Core_kernel.Array.map2_exn then_ else_ ~f:(fun then_ else_ ->\n if_ b ~then_ ~else_ ) )\n in\n let%map res_aux =\n (* Abstraction leak.. *)\n let res_aux = ref None in\n let%map () =\n as_prover\n As_prover.(\n if%map read Boolean.typ b then res_aux := Some then_aux\n else res_aux := Some else_aux)\n in\n match !res_aux with\n | Some res_aux ->\n res_aux\n | None ->\n typ.constraint_system_auxiliary ()\n in\n typ.var_of_fields (res, res_aux)\n\n module Test = struct\n let checked_to_unchecked typ1 typ2 checked input =\n let checked_result =\n run_and_check\n (let open Let_syntax in\n let%bind input = exists typ1 ~compute:(As_prover.return input) in\n let%map result = checked input in\n As_prover.read typ2 result)\n |> Or_error.ok_exn\n in\n checked_result\n\n let test_equal (type a) ?(sexp_of_t = sexp_of_opaque) ?(equal = Caml.( = ))\n typ1 typ2 checked unchecked input =\n let checked_result = checked_to_unchecked typ1 typ2 checked input in\n let sexp_of_a = sexp_of_t in\n let compare_a x y = if equal x y then 0 else 1 in\n [%test_eq: a] checked_result (unchecked input)\n end\n\n module R1CS_constraint_system = struct\n include R1CS_constraint_system\n end\nend\n\n(** The main functor for the monadic interface. \n See [Run.Make] for the same thing but for the imperative interface. *)\nmodule Make (Backend : Backend_intf.S) = struct\n module Backend_extended = Backend_extended.Make (Backend)\n module Runner0 = Runner.Make (Backend_extended)\n module Checked_runner = Runner0.Checked_runner\n module Checked1 = Checked.Make (Backend.Field) (Checked_runner) (As_prover0)\n\n module Field_T = struct\n type field = Backend_extended.Field.t\n end\n\n module As_prover_ext = As_prover0.Make_extended (Field_T) (As_prover0)\n\n module Ref :\n As_prover_ref.S\n with module Types = Checked1.Types\n and type ('a, 'f) checked := ('a, 'f) Checked1.t\n and type 'f field := Backend_extended.Field.t =\n As_prover_ref.Make (Checked1) (As_prover0)\n\n module Checked_for_basic = struct\n include (\n Checked1 :\n Checked_intf.S\n with module Types = Checked1.Types\n with type ('a, 'f) t := ('a, 'f) Checked1.t\n and type 'f field := Backend_extended.Field.t )\n\n type field = Backend_extended.Field.t\n\n type 'a t = ('a, field) Types.Checked.t\n\n let run = Runner0.run\n end\n\n module Basic =\n Make_basic (Backend_extended) (Checked_for_basic) (As_prover_ext) (Ref)\n (Runner0)\n include Basic\n module Number = Number.Make (Basic)\n module Enumerable = Enumerable.Make (Basic)\nend\n\nmodule Typ0 = Typ\n\nmodule Run = struct\n let functor_counter = ref 0\n\n let active_counters = ref []\n\n let is_active_functor_id num =\n match !active_counters with\n | [] ->\n (* Show the usual error, the functor isn't wrong as far as we can tell.\n *)\n true\n | active :: _ ->\n Int.equal active num\n\n let active_functor_id () = List.hd_exn !active_counters\n\n module Make_basic (Backend : Backend_intf.S) = struct\n module Snark = Make (Backend)\n open Run_state\n open Snark\n\n let set_constraint_logger = set_constraint_logger\n\n let clear_constraint_logger = clear_constraint_logger\n\n let this_functor_id = incr functor_counter ; !functor_counter\n\n let state =\n ref\n (Run_state.make ~input:(field_vec ()) ~aux:(field_vec ())\n ~eval_constraints:false ~num_inputs:0 ~next_auxiliary:(ref 0)\n ~with_witness:false ~stack:[] ~is_running:false () )\n\n let dump () = Run_state.dump !state\n\n let in_prover () : bool = Run_state.has_witness !state\n\n let in_checked_computation () : bool =\n is_active_functor_id this_functor_id && Run_state.is_running !state\n\n let run (checked : _ Checked.t) =\n match checked with\n | Pure a ->\n a\n | _ ->\n if not (is_active_functor_id this_functor_id) then\n failwithf\n \"Could not run this function.\\n\\n\\\n Hint: The module used to create this function had internal ID \\\n %i, but the module used to run it had internal ID %i. The same \\\n instance of Snarky.Snark.Run.Make must be used for both.\"\n this_functor_id (active_functor_id ()) ()\n else if not (Run_state.is_running !state) then\n failwith\n \"This function can't be run outside of a checked computation.\" ;\n let state', x = Runner.run checked !state in\n state := state' ;\n x\n\n let as_stateful x state' =\n state := state' ;\n let a = x () in\n (!state, a)\n\n let make_checked (type a) (f : unit -> a) : _ Checked.t =\n let g : run_state -> run_state * a = as_stateful f in\n Function g\n\n module R1CS_constraint_system = Snark.R1CS_constraint_system\n\n type field = Snark.field\n\n module Bigint = Snark.Bigint\n module Constraint = Snark.Constraint\n\n module Typ = struct\n open Snark.Typ\n\n type nonrec ('var, 'value) t = ('var, 'value) t\n\n let unit = unit\n\n let field = field\n\n let tuple2 = tuple2\n\n let ( * ) = ( * )\n\n let tuple3 = tuple3\n\n let list = list\n\n let array = array\n\n let hlist = hlist\n\n let transport = transport\n\n let transport_var = transport_var\n\n let of_hlistable = of_hlistable\n\n module Internal = Internal\n end\n\n let constant (Typ typ : _ Typ.t) x =\n let fields, aux = typ.value_to_fields x in\n let field_vars = Core_kernel.Array.map ~f:Cvar.constant fields in\n typ.var_of_fields (field_vars, aux)\n\n module Boolean = struct\n open Snark.Boolean\n\n type nonrec var = var\n\n type value = bool\n\n let true_ = true_\n\n let false_ = false_\n\n let if_ b ~then_ ~else_ = run (if_ b ~then_ ~else_)\n\n let not = not\n\n let ( && ) x y = run (x && y)\n\n let ( &&& ) = ( && )\n\n let ( || ) x y = run (x || y)\n\n let ( ||| ) = ( || )\n\n let ( lxor ) x y = run (x lxor y)\n\n let any l = run (any l)\n\n let all l = run (all l)\n\n let of_field x = run (of_field x)\n\n let var_of_value = var_of_value\n\n let typ = typ\n\n let typ_unchecked = typ_unchecked\n\n let equal x y = run (equal x y)\n\n module Expr = struct\n open Snark.Boolean.Expr\n\n type nonrec t = t\n\n let ( ! ) = ( ! )\n\n let ( && ) = ( && )\n\n let ( &&& ) = ( && )\n\n let ( || ) = ( || )\n\n let ( ||| ) = ( ||| )\n\n let any = any\n\n let all = all\n\n let not = not\n\n let eval x = run (eval x)\n\n let assert_ x = run (assert_ x)\n end\n\n module Unsafe = Unsafe\n\n module Assert = struct\n open Snark.Boolean.Assert\n\n let ( = ) x y = run (x = y)\n\n let is_true x = run (is_true x)\n\n let any l = run (any l)\n\n let all l = run (all l)\n\n let exactly_one l = run (exactly_one l)\n end\n\n module Array = struct\n open Snark.Boolean.Array\n\n let any x = run (any x)\n\n let all x = run (all x)\n\n module Assert = struct\n let any x = run (Assert.any x)\n\n let all x = run (Assert.all x)\n end\n end\n end\n\n module Field = struct\n open Snark.Field\n\n let size_in_bits = size_in_bits\n\n let size = size\n\n module Constant = struct\n type t = Snark.Field.t [@@deriving bin_io, sexp, hash, compare, eq]\n\n let gen = gen\n\n let gen_uniform = gen_uniform\n\n module T = struct\n let bin_shape_t = bin_shape_t\n\n let bin_writer_t = bin_writer_t\n\n let bin_write_t = bin_write_t\n\n let bin_size_t = bin_size_t\n\n let bin_reader_t = bin_reader_t\n\n let __bin_read_t__ = __bin_read_t__\n\n let bin_read_t = bin_read_t\n\n let bin_t = bin_t\n\n let sexp_of_t = sexp_of_t\n\n let t_of_sexp = t_of_sexp\n\n let of_int = of_int\n\n let one = one\n\n let zero = zero\n\n let add = add\n\n let sub = sub\n\n let mul = mul\n\n let inv = inv\n\n let square = square\n\n let sqrt = sqrt\n\n let is_square = is_square\n\n let equal = equal\n\n let size_in_bits = size_in_bits\n\n let print = print\n\n let to_string = to_string\n\n let random = random\n\n module Mutable = Mutable\n\n let ( += ) = ( += )\n\n let ( -= ) = ( -= )\n\n let ( *= ) = ( *= )\n\n module Vector = Vector\n\n let negate = negate\n\n let ( + ) = ( + )\n\n let ( - ) = ( - )\n\n let ( * ) = ( * )\n\n let ( / ) = ( / )\n\n let of_string = of_string\n\n let to_string = to_string\n\n let unpack = unpack\n\n let project = project\n\n let parity = parity\n end\n\n include T\n end\n\n open Snark.Field.Var\n\n type nonrec t = t\n\n let length = length\n\n let var_indices = var_indices\n\n let to_constant_and_terms = to_constant_and_terms\n\n let constant = constant\n\n let to_constant = to_constant\n\n let linear_combination = linear_combination\n\n let sum = sum\n\n let add = add\n\n let negate = negate\n\n let sub = sub\n\n let scale = scale\n\n let project = project\n\n let pack = pack\n\n (* New definitions *)\n\n let of_int i = constant (Constant.of_int i)\n\n let one = constant Constant.one\n\n let zero = constant Constant.zero\n\n open Snark.Field.Checked\n\n let mul x y = run (mul x y)\n\n let square x = run (square x)\n\n let div x y = run (div x y)\n\n let inv x = run (inv x)\n\n let is_square x = run (is_square x)\n\n let sqrt x = run (sqrt x)\n\n let sqrt_check x = run (sqrt_check x)\n\n let equal x y = run (equal x y)\n\n let unpack x ~length = run (unpack x ~length)\n\n let unpack_flagged x ~length = run (unpack_flagged x ~length)\n\n let unpack_full x = run (unpack_full x)\n\n let parity ?length x = run (parity ?length x)\n\n let choose_preimage_var x ~length = run (choose_preimage_var x ~length)\n\n type nonrec comparison_result = comparison_result =\n { less : Boolean.var; less_or_equal : Boolean.var }\n\n let compare ~bit_length x y = run (compare ~bit_length x y)\n\n let if_ b ~then_ ~else_ = run (if_ b ~then_ ~else_)\n\n let ( + ) = add\n\n let ( - ) = sub\n\n let ( * ) = mul\n\n let ( / ) = div\n\n module Unsafe = Unsafe\n\n module Assert = struct\n open Snark.Field.Checked.Assert\n\n let lte ~bit_length x y = run (lte ~bit_length x y)\n\n let gte ~bit_length x y = run (gte ~bit_length x y)\n\n let lt ~bit_length x y = run (lt ~bit_length x y)\n\n let gt ~bit_length x y = run (gt ~bit_length x y)\n\n let not_equal x y = run (not_equal x y)\n\n let equal x y = run (equal x y)\n\n let non_zero x = run (non_zero x)\n end\n\n let typ = typ\n end\n\n module Proof_inputs = Proof_inputs\n\n module Bitstring_checked = struct\n open Snark.Bitstring_checked\n\n type nonrec t = t\n\n let equal x y = run (equal x y)\n\n let equal_expect_true x y = run (equal_expect_true x y)\n\n let lt_value x y = run (lt_value x y)\n\n module Assert = struct\n open Snark.Bitstring_checked.Assert\n\n let equal x y = run (equal x y)\n end\n end\n\n module As_prover = struct\n type 'a t = 'a\n\n type 'a as_prover = 'a t\n\n let eval_as_prover f =\n if Run_state.as_prover !state && Run_state.has_witness !state then\n let a = f (Runner.get_value !state) in\n a\n else failwith \"Can't evaluate prover code outside an as_prover block\"\n\n let in_prover_block () = Run_state.as_prover !state\n\n let read_var var = eval_as_prover (As_prover.read_var var)\n\n let read typ var = eval_as_prover (As_prover.read typ var)\n\n include Field.Constant.T\n\n module Ref = struct\n type 'a t = 'a As_prover_ref.t\n\n let create f = run As_prover.(Ref.create (map (return ()) ~f))\n\n let get r = eval_as_prover (As_prover.Ref.get r)\n\n let set r x = eval_as_prover (As_prover.Ref.set r x)\n end\n\n let run_prover f _tbl =\n (* Allow for nesting of prover blocks, by caching the current value and\n restoring it once we're done.\n *)\n let old = Run_state.as_prover !state in\n Run_state.set_as_prover !state true ;\n let a = f () in\n Run_state.set_as_prover !state old ;\n a\n end\n\n module Handle = struct\n type ('var, 'value) t = ('var, 'value) Handle.t\n\n let value handle () = As_prover.eval_as_prover (Handle.value handle)\n\n let var = Handle.var\n end\n\n let mark_active ~f =\n let counters = !active_counters in\n active_counters := this_functor_id :: counters ;\n try\n let ret = f () in\n active_counters := counters ;\n ret\n with exn ->\n active_counters := counters ;\n raise exn\n\n let mark_active_deferred (type a ma) ~(map : ma -> f:(a -> a) -> ma) ~f =\n let counters = !active_counters in\n active_counters := this_functor_id :: counters ;\n try\n map (f ()) ~f:(fun (ret : a) ->\n active_counters := counters ;\n ret )\n with exn ->\n active_counters := counters ;\n raise exn\n\n let assert_ ?label c = run (assert_ ?label c)\n\n let assert_all ?label c = run (assert_all ?label c)\n\n let assert_r1cs ?label a b c = run (assert_r1cs ?label a b c)\n\n let assert_square ?label x y = run (assert_square ?label x y)\n\n let as_prover p = run (as_prover (As_prover.run_prover p))\n\n let next_auxiliary () = run (next_auxiliary ())\n\n let request_witness typ p =\n run (request_witness typ (As_prover.run_prover p))\n\n let perform p = run (perform (As_prover.run_prover p))\n\n let request ?such_that typ r =\n match such_that with\n | None ->\n request_witness typ (fun () -> r)\n | Some such_that ->\n let x = request_witness typ (fun () -> r) in\n such_that x ; x\n\n let exists ?request ?compute typ =\n let request = Option.map request ~f:As_prover.run_prover in\n let compute = Option.map compute ~f:As_prover.run_prover in\n run (exists ?request ?compute typ)\n\n let exists_handle ?request ?compute typ =\n let request = Option.map request ~f:As_prover.run_prover in\n let compute = Option.map compute ~f:As_prover.run_prover in\n run (exists_handle ?request ?compute typ)\n\n type nonrec response = response\n\n let unhandled = unhandled\n\n type request = Request.request =\n | With :\n { request : 'a Request.t\n ; respond : 'a Request.Response.t -> response\n }\n -> request\n\n module Handler = Handler\n\n let handle x h =\n let h = Request.Handler.create_single h in\n let handler = Run_state.handler !state in\n state := Run_state.set_handler !state (Request.Handler.push handler h) ;\n let a = x () in\n state := Run_state.set_handler !state handler ;\n a\n\n let handle_as_prover x h =\n let h = h () in\n handle x h\n\n let if_ b ~typ ~then_ ~else_ = run (if_ b ~typ ~then_ ~else_)\n\n let with_label lbl x =\n let stack = Run_state.stack !state in\n let log_constraint = Run_state.log_constraint !state in\n state := Run_state.set_stack !state (lbl :: stack) ;\n Option.iter log_constraint ~f:(fun f ->\n f ~at_label_boundary:(`Start, lbl) None ) ;\n let a = x () in\n Option.iter log_constraint ~f:(fun f ->\n f ~at_label_boundary:(`End, lbl) None ) ;\n state := Run_state.set_stack !state stack ;\n a\n\n let inject_wrapper :\n type r_var input_var.\n f:(r_var -> r_var) -> (input_var -> r_var) -> input_var -> r_var =\n fun ~f x a ->\n let inject_wrapper ~f x = f x in\n inject_wrapper ~f (x a)\n\n (** Caches the global [state] before running [f]. \n It is expected that [f] will reset the global state for its own use only, \n hence why we need to reset it after running [f].*)\n let finalize_is_running f =\n let cached_state = !state in\n let x =\n match f () with\n | exception e ->\n (* Warning: it is important to clean the global state before reraising the exception.\n Imagine if a user of snarky catches exceptions instead of letting the program panic,\n then the next usage of snarky might be messed up. *)\n state := cached_state ;\n raise e\n | x ->\n x\n in\n state := cached_state ;\n x\n\n let constraint_system ~input_typ ~return_typ x : R1CS_constraint_system.t =\n finalize_is_running (fun () ->\n let x = inject_wrapper x ~f:(fun x () -> mark_active ~f:x) in\n Perform.constraint_system ~run:as_stateful ~input_typ ~return_typ x )\n\n let generate_public_input t x : As_prover.Vector.t =\n finalize_is_running (fun () -> generate_public_input t x)\n\n let generate_witness ~input_typ ~return_typ x a : Proof_inputs.t =\n finalize_is_running (fun () ->\n let x = inject_wrapper x ~f:(fun x () -> mark_active ~f:x) in\n Perform.generate_witness ~run:as_stateful ~input_typ ~return_typ x a )\n\n let generate_witness_conv (type out)\n ~(f : Proof_inputs.t -> 'r_value -> out) ~input_typ ~return_typ x input\n : out =\n finalize_is_running (fun () ->\n let x = inject_wrapper x ~f:(fun x () -> mark_active ~f:x) in\n Perform.generate_witness_conv ~run:as_stateful ~f ~input_typ\n ~return_typ x input )\n\n let run_unchecked x =\n finalize_is_running (fun () ->\n Perform.run_unchecked ~run:as_stateful (fun () -> mark_active ~f:x) )\n\n let run_and_check_exn (type a) (x : unit -> (unit -> a) As_prover.t) : a =\n finalize_is_running (fun () ->\n let res =\n Perform.run_and_check_exn ~run:as_stateful (fun () ->\n mark_active ~f:(fun () ->\n let prover_block = x () in\n Run_state.set_as_prover !state true ;\n As_prover.run_prover prover_block ) )\n in\n Run_state.set_as_prover !state true ;\n res )\n\n let run_and_check (type a) (x : unit -> (unit -> a) As_prover.t) :\n a Or_error.t =\n finalize_is_running (fun () ->\n let res =\n Perform.run_and_check ~run:as_stateful (fun () ->\n mark_active ~f:(fun () ->\n let prover_block = x () in\n Run_state.set_as_prover !state true ;\n As_prover.run_prover prover_block ) )\n in\n Run_state.set_as_prover !state true ;\n res )\n\n module Run_and_check_deferred (M : sig\n type _ t\n\n val return : 'a -> 'a t\n\n val map : 'a t -> f:('a -> 'b) -> 'b t\n end) =\n struct\n open M\n\n let run_and_check_exn ~run t =\n map (run_and_check_deferred_exn' ~run t ~map) ~f:(fun (x, get_value) ->\n let x = Basic.As_prover.run x get_value in\n x )\n\n let run_and_check ~run t =\n map\n (run_and_check_deferred' ~run t ~map ~return)\n ~f:\n (Or_error.map ~f:(fun (x, get_value) ->\n let x = Basic.As_prover.run x get_value in\n x ) )\n\n let as_stateful x state' =\n state := state' ;\n map (x ()) ~f:(fun a -> (!state, a))\n\n let run_and_check_exn (type a) (x : unit -> (unit -> a) As_prover.t M.t) :\n a M.t =\n finalize_is_running (fun () ->\n let mark_active = mark_active_deferred ~map in\n let res =\n run_and_check_exn ~run:as_stateful (fun () ->\n mark_active ~f:(fun () ->\n map (x ()) ~f:(fun prover_block ->\n Run_state.set_as_prover !state true ;\n As_prover.run_prover prover_block ) ) )\n in\n Run_state.set_as_prover !state true ;\n res )\n\n let run_and_check (type a) (x : unit -> (unit -> a) As_prover.t M.t) :\n a Or_error.t M.t =\n finalize_is_running (fun () ->\n let mark_active = mark_active_deferred ~map in\n let res =\n run_and_check ~run:as_stateful (fun () ->\n mark_active ~f:(fun () ->\n map (x ()) ~f:(fun prover_block ->\n Run_state.set_as_prover !state true ;\n As_prover.run_prover prover_block ) ) )\n in\n Run_state.set_as_prover !state true ;\n res )\n end\n\n let check_exn x : unit =\n finalize_is_running (fun () -> Perform.check_exn ~run:as_stateful x)\n\n let check x : unit Or_error.t =\n finalize_is_running (fun () -> Perform.check ~run:as_stateful x)\n\n let constraint_count ?(weight = Fn.const 1) ?log x =\n let count = ref 0 in\n let log_constraint ?at_label_boundary c =\n ( match at_label_boundary with\n | None ->\n ()\n | Some (pos, lab) ->\n Option.iter log ~f:(fun f ->\n let start =\n Some (match pos with `Start -> true | _ -> false)\n in\n f ?start lab !count ) ) ;\n count := !count + Option.value_map ~default:0 ~f:weight c\n in\n (* TODO(mrmr1993): Enable label-level logging for the imperative API. *)\n let old = !state in\n state :=\n Runner.State.make ~num_inputs:0 ~input:Vector.null ~aux:Vector.null\n ~next_auxiliary:(ref 0) ~eval_constraints:false ~with_witness:false\n ~log_constraint () ;\n ignore (mark_active ~f:x) ;\n state := old ;\n !count\n\n module Internal_Basic = Snark\n\n let run_checked = run\n end\n\n module Make (Backend : Backend_intf.S) = struct\n module Basic = Make_basic (Backend)\n include Basic\n module Number = Number.Run.Make (Basic)\n module Enumerable = Enumerable.Run.Make (Basic)\n end\nend\n\ntype 'field m = (module Snark_intf.Run with type field = 'field)\n\nlet make (type field) (module Backend : Backend_intf.S with type Field.t = field)\n : field m =\n (module Run.Make (Backend))\n","type bigstring =\n (char, Bigarray.int8_unsigned_elt, Bigarray.c_layout) Bigarray.Array1.t\n\ntype t = bigstring\n\nlet create size = Bigarray.(Array1.create char c_layout size)\nlet empty = create 0\n\nmodule BA1 = Bigarray.Array1\n\nlet length t = BA1.dim t\n\nexternal get : t -> int -> char = \"%caml_ba_ref_1\"\nexternal set : t -> int -> char -> unit = \"%caml_ba_set_1\"\n\nexternal unsafe_get : t -> int -> char = \"%caml_ba_unsafe_ref_1\"\nexternal unsafe_set : t -> int -> char -> unit = \"%caml_ba_unsafe_set_1\"\n\nexternal unsafe_blit : t -> src_off:int -> t -> dst_off:int -> len:int -> unit =\n \"bigstringaf_blit_to_bigstring\" [@@noalloc]\n\nexternal unsafe_blit_to_bytes : t -> src_off:int -> Bytes.t -> dst_off:int -> len:int -> unit =\n \"bigstringaf_blit_to_bytes\" [@@noalloc]\n\nexternal unsafe_blit_from_bytes : Bytes.t -> src_off:int -> t -> dst_off:int -> len:int -> unit =\n \"bigstringaf_blit_from_bytes\" [@@noalloc]\n\nexternal unsafe_blit_from_string : string -> src_off:int -> t -> dst_off:int -> len:int -> unit =\n \"bigstringaf_blit_from_bytes\" [@@noalloc]\n\nexternal unsafe_memcmp : t -> int -> t -> int -> int -> int =\n \"bigstringaf_memcmp_bigstring\" [@@noalloc]\n\nexternal unsafe_memcmp_string : t -> int -> string -> int -> int -> int =\n \"bigstringaf_memcmp_string\" [@@noalloc]\n\nlet sub t ~off ~len =\n BA1.sub t off len\n\nlet[@inline never] invalid_bounds op buffer_len off len =\n let message =\n Printf.sprintf \"Bigstringaf.%s invalid range: { buffer_len: %d, off: %d, len: %d }\"\n op buffer_len off len\n in\n raise (Invalid_argument message)\n;;\n\nlet[@inline never] invalid_bounds_blit op src_len src_off dst_len dst_off len =\n let message =\n Printf.sprintf \"Bigstringaf.%s invalid range: { src_len: %d, src_off: %d, dst_len: %d, dst_off: %d, len: %d }\"\n op src_len src_off dst_len dst_off len\n in\n raise (Invalid_argument message)\n;;\n\nlet[@inline never] invalid_bounds_memcmp op buf1_len buf1_off buf2_len buf2_off len =\n let message =\n Printf.sprintf \"Bigstringaf.%s invalid range: { buf1_len: %d, buf1_off: %d, buf2_len: %d, buf2_off: %d, len: %d }\"\n op buf1_len buf1_off buf2_len buf2_off len\n in\n raise (Invalid_argument message)\n;;\n\n(* A note on bounds checking.\n *\n * The code should perform the following check to ensure that the blit doesn't\n * run off the end of the input buffer:\n *\n * {[off + len <= buffer_len]}\n *\n * However, this may lead to an interger overflow for large values of [off],\n * e.g., [max_int], which will cause the comparison to return [true] when it\n * should really return [false].\n *\n * An equivalent comparison that does not run into this integer overflow\n * problem is:\n *\n * {[buffer_len - off => len]}\n *\n * This is checking that the input buffer, less the offset, is sufficiently\n * long to perform the blit. Since the expression is subtracting [off] rather\n * than adding it, it doesn't suffer from the overflow that the previous\n * inequality did. As long as there is check to ensure that [off] is not\n * negative, it won't underflow either. *)\n\nlet copy t ~off ~len =\n let buffer_len = length t in\n if len < 0 || off < 0 || buffer_len - off < len\n then invalid_bounds \"copy\" buffer_len off len;\n let dst = create len in\n unsafe_blit t ~src_off:off dst ~dst_off:0 ~len;\n dst\n;;\n\nlet substring t ~off ~len =\n let buffer_len = length t in\n if len < 0 || off < 0 || buffer_len - off < len\n then invalid_bounds \"substring\" buffer_len off len;\n let b = Bytes.create len in\n unsafe_blit_to_bytes t ~src_off:off b ~dst_off:0 ~len;\n Bytes.unsafe_to_string b\n;;\n\nlet to_string t =\n let len = length t in\n let b = Bytes.create len in\n unsafe_blit_to_bytes t ~src_off:0 b ~dst_off:0 ~len;\n Bytes.unsafe_to_string b\n;;\n\nlet of_string ~off ~len s =\n let buffer_len = String.length s in\n if len < 0 || off < 0 || buffer_len - off < len\n then invalid_bounds \"of_string\" buffer_len off len;\n let b = create len in\n unsafe_blit_from_string s ~src_off:off b ~dst_off:0 ~len;\n b\n;;\n\nlet blit src ~src_off dst ~dst_off ~len =\n let src_len = length src in\n let dst_len = length dst in\n if len < 0\n then invalid_bounds_blit \"blit\" src_len src_off dst_len dst_off len;\n if src_off < 0 || src_len - src_off < len\n then invalid_bounds_blit \"blit\" src_len src_off dst_len dst_off len;\n if dst_off < 0 || dst_len - dst_off < len\n then invalid_bounds_blit \"blit\" src_len src_off dst_len dst_off len;\n unsafe_blit src ~src_off dst ~dst_off ~len\n;;\n\nlet blit_from_string src ~src_off dst ~dst_off ~len =\n let src_len = String.length src in\n let dst_len = length dst in\n if len < 0\n then invalid_bounds_blit \"blit_from_string\" src_len src_off dst_len dst_off len;\n if src_off < 0 || src_len - src_off < len\n then invalid_bounds_blit \"blit_from_string\" src_len src_off dst_len dst_off len;\n if dst_off < 0 || dst_len - dst_off < len\n then invalid_bounds_blit \"blit_from_string\" src_len src_off dst_len dst_off len;\n unsafe_blit_from_string src ~src_off dst ~dst_off ~len\n;;\n\nlet blit_from_bytes src ~src_off dst ~dst_off ~len =\n let src_len = Bytes.length src in\n let dst_len = length dst in\n if len < 0\n then invalid_bounds_blit \"blit_from_bytes\" src_len src_off dst_len dst_off len;\n if src_off < 0 || src_len - src_off < len\n then invalid_bounds_blit \"blit_from_bytes\" src_len src_off dst_len dst_off len;\n if dst_off < 0 || dst_len - dst_off < len\n then invalid_bounds_blit \"blit_from_bytes\" src_len src_off dst_len dst_off len;\n unsafe_blit_from_bytes src ~src_off dst ~dst_off ~len\n;;\n\nlet blit_to_bytes src ~src_off dst ~dst_off ~len =\n let src_len = length src in\n let dst_len = Bytes.length dst in\n if len < 0\n then invalid_bounds_blit \"blit_to_bytes\" src_len src_off dst_len dst_off len;\n if src_off < 0 || src_len - src_off < len\n then invalid_bounds_blit \"blit_to_bytes\" src_len src_off dst_len dst_off len;\n if dst_off < 0 || dst_len - dst_off < len\n then invalid_bounds_blit \"blit_to_bytes\" src_len src_off dst_len dst_off len;\n unsafe_blit_to_bytes src ~src_off dst ~dst_off ~len\n;;\n\nlet memcmp buf1 buf1_off buf2 buf2_off len =\n let buf1_len = length buf1 in\n let buf2_len = length buf2 in\n if len < 0\n then invalid_bounds_memcmp \"memcmp\" buf1_len buf1_off buf2_len buf2_off len;\n if buf1_off < 0 || buf1_len - buf1_off < len\n then invalid_bounds_memcmp \"memcmp\" buf1_len buf1_off buf2_len buf2_off len;\n if buf2_off < 0 || buf2_len - buf2_off < len\n then invalid_bounds_memcmp \"memcmp\" buf1_len buf1_off buf2_len buf2_off len;\n unsafe_memcmp buf1 buf1_off buf2 buf2_off len\n;;\n\nlet memcmp_string buf1 buf1_off buf2 buf2_off len =\n let buf1_len = length buf1 in\n let buf2_len = String.length buf2 in\n if len < 0\n then invalid_bounds_memcmp \"memcmp_string\" buf1_len buf1_off buf2_len buf2_off len;\n if buf1_off < 0 || buf1_len - buf1_off < len\n then invalid_bounds_memcmp \"memcmp_string\" buf1_len buf1_off buf2_len buf2_off len;\n if buf2_off < 0 || buf2_len - buf2_off < len\n then invalid_bounds_memcmp \"memcmp_string\" buf1_len buf1_off buf2_len buf2_off len;\n unsafe_memcmp_string buf1 buf1_off buf2 buf2_off len\n;;\n\n\n(* Safe operations *)\n\nexternal caml_bigstring_set_16 : bigstring -> int -> int -> unit = \"%caml_bigstring_set16\"\nexternal caml_bigstring_set_32 : bigstring -> int -> int32 -> unit = \"%caml_bigstring_set32\"\nexternal caml_bigstring_set_64 : bigstring -> int -> int64 -> unit = \"%caml_bigstring_set64\"\n\nexternal caml_bigstring_get_16 : bigstring -> int -> int = \"%caml_bigstring_get16\"\nexternal caml_bigstring_get_32 : bigstring -> int -> int32 = \"%caml_bigstring_get32\"\nexternal caml_bigstring_get_64 : bigstring -> int -> int64 = \"%caml_bigstring_get64\"\n\nmodule Swap = struct\n external bswap16 : int -> int = \"%bswap16\"\n external bswap_int32 : int32 -> int32 = \"%bswap_int32\"\n external bswap_int64 : int64 -> int64 = \"%bswap_int64\"\n\n let caml_bigstring_set_16 bs off i =\n caml_bigstring_set_16 bs off (bswap16 i)\n\n let caml_bigstring_set_32 bs off i =\n caml_bigstring_set_32 bs off (bswap_int32 i)\n\n let caml_bigstring_set_64 bs off i =\n caml_bigstring_set_64 bs off (bswap_int64 i)\n\n let caml_bigstring_get_16 bs off =\n bswap16 (caml_bigstring_get_16 bs off)\n\n let caml_bigstring_get_32 bs off =\n bswap_int32 (caml_bigstring_get_32 bs off)\n\n let caml_bigstring_get_64 bs off =\n bswap_int64 (caml_bigstring_get_64 bs off)\n\n let get_int16_sign_extended x off =\n ((caml_bigstring_get_16 x off) lsl (Sys.int_size - 16)) asr (Sys.int_size - 16)\nend\n\nlet set_int16_le, set_int16_be =\n if Sys.big_endian\n then Swap.caml_bigstring_set_16, caml_bigstring_set_16\n else caml_bigstring_set_16 , Swap.caml_bigstring_set_16\n\nlet set_int32_le, set_int32_be =\n if Sys.big_endian\n then Swap.caml_bigstring_set_32, caml_bigstring_set_32\n else caml_bigstring_set_32 , Swap.caml_bigstring_set_32\n\nlet set_int64_le, set_int64_be =\n if Sys.big_endian\n then Swap.caml_bigstring_set_64, caml_bigstring_set_64\n else caml_bigstring_set_64 , Swap.caml_bigstring_set_64\n\nlet get_int16_le, get_int16_be =\n if Sys.big_endian\n then Swap.caml_bigstring_get_16, caml_bigstring_get_16\n else caml_bigstring_get_16 , Swap.caml_bigstring_get_16\n\nlet get_int16_sign_extended_noswap x off =\n ((caml_bigstring_get_16 x off) lsl (Sys.int_size - 16)) asr (Sys.int_size - 16)\n\nlet get_int16_sign_extended_le, get_int16_sign_extended_be =\n if Sys.big_endian\n then Swap.get_int16_sign_extended , get_int16_sign_extended_noswap\n else get_int16_sign_extended_noswap, Swap.get_int16_sign_extended\n\nlet get_int32_le, get_int32_be =\n if Sys.big_endian\n then Swap.caml_bigstring_get_32, caml_bigstring_get_32\n else caml_bigstring_get_32 , Swap.caml_bigstring_get_32\n\nlet get_int64_le, get_int64_be =\n if Sys.big_endian\n then Swap.caml_bigstring_get_64, caml_bigstring_get_64\n else caml_bigstring_get_64 , Swap.caml_bigstring_get_64\n\n(* Unsafe operations *)\n\nexternal caml_bigstring_unsafe_set_16 : bigstring -> int -> int -> unit = \"%caml_bigstring_set16u\"\nexternal caml_bigstring_unsafe_set_32 : bigstring -> int -> int32 -> unit = \"%caml_bigstring_set32u\"\nexternal caml_bigstring_unsafe_set_64 : bigstring -> int -> int64 -> unit = \"%caml_bigstring_set64u\"\n\nexternal caml_bigstring_unsafe_get_16 : bigstring -> int -> int = \"%caml_bigstring_get16u\"\nexternal caml_bigstring_unsafe_get_32 : bigstring -> int -> int32 = \"%caml_bigstring_get32u\"\nexternal caml_bigstring_unsafe_get_64 : bigstring -> int -> int64 = \"%caml_bigstring_get64u\"\n\nmodule USwap = struct\n external bswap16 : int -> int = \"%bswap16\"\n external bswap_int32 : int32 -> int32 = \"%bswap_int32\"\n external bswap_int64 : int64 -> int64 = \"%bswap_int64\"\n\n let caml_bigstring_unsafe_set_16 bs off i =\n caml_bigstring_unsafe_set_16 bs off (bswap16 i)\n\n let caml_bigstring_unsafe_set_32 bs off i =\n caml_bigstring_unsafe_set_32 bs off (bswap_int32 i)\n\n let caml_bigstring_unsafe_set_64 bs off i =\n caml_bigstring_unsafe_set_64 bs off (bswap_int64 i)\n\n let caml_bigstring_unsafe_get_16 bs off =\n bswap16 (caml_bigstring_unsafe_get_16 bs off)\n\n let caml_bigstring_unsafe_get_32 bs off =\n bswap_int32 (caml_bigstring_unsafe_get_32 bs off)\n\n let caml_bigstring_unsafe_get_64 bs off =\n bswap_int64 (caml_bigstring_unsafe_get_64 bs off)\nend\n\nlet unsafe_set_int16_le, unsafe_set_int16_be =\n if Sys.big_endian\n then USwap.caml_bigstring_unsafe_set_16, caml_bigstring_unsafe_set_16\n else caml_bigstring_unsafe_set_16 , USwap.caml_bigstring_unsafe_set_16\n\nlet unsafe_set_int32_le, unsafe_set_int32_be =\n if Sys.big_endian\n then USwap.caml_bigstring_unsafe_set_32, caml_bigstring_unsafe_set_32\n else caml_bigstring_unsafe_set_32 , USwap.caml_bigstring_unsafe_set_32\n\nlet unsafe_set_int64_le, unsafe_set_int64_be =\n if Sys.big_endian\n then USwap.caml_bigstring_unsafe_set_64, caml_bigstring_unsafe_set_64\n else caml_bigstring_unsafe_set_64 , USwap.caml_bigstring_unsafe_set_64\n\nlet unsafe_get_int16_le, unsafe_get_int16_be =\n if Sys.big_endian\n then USwap.caml_bigstring_unsafe_get_16, caml_bigstring_unsafe_get_16\n else caml_bigstring_unsafe_get_16 , USwap.caml_bigstring_unsafe_get_16\n\nlet unsafe_get_int16_sign_extended_le x off =\n ((unsafe_get_int16_le x off) lsl (Sys.int_size - 16)) asr (Sys.int_size - 16)\n\nlet unsafe_get_int16_sign_extended_be x off =\n ((unsafe_get_int16_be x off ) lsl (Sys.int_size - 16)) asr (Sys.int_size - 16)\n\nlet unsafe_get_int32_le, unsafe_get_int32_be =\n if Sys.big_endian\n then USwap.caml_bigstring_unsafe_get_32, caml_bigstring_unsafe_get_32\n else caml_bigstring_unsafe_get_32 , USwap.caml_bigstring_unsafe_get_32\n\nlet unsafe_get_int64_le, unsafe_get_int64_be =\n if Sys.big_endian\n then USwap.caml_bigstring_unsafe_get_64, caml_bigstring_unsafe_get_64\n else caml_bigstring_unsafe_get_64 , USwap.caml_bigstring_unsafe_get_64\n","open Core_kernel\n\nmodule type Field_intf = sig\n type t\n\n val size_in_bits : int\n\n val negate : t -> t\n\n val ( - ) : t -> t -> t\n\n val ( + ) : t -> t -> t\n\n val ( * ) : t -> t -> t\n\n val ( / ) : t -> t -> t\n\n val inv : t -> t\n\n val zero : t\n\n val one : t\n\n val of_int : int -> t\nend\n\nlet two_to_the (type f) (module F : Field_intf with type t = f) =\n let rec two_to_the n =\n if n = 0 then F.one\n else\n let r = two_to_the (n - 1) in\n F.(r + r)\n in\n two_to_the\n\n(* Our custom constraints let us efficiently compute\n\n f = fun (g, t) -> (2 * t + 1 + 2^len(t)) g\n\n We want to compute\n\n f' = fun (g, s) -> s * g\n\n Let n be the field size in bits.\n\n For a scalar s, let t = (s - 2^n - 1)/2.\n t can be represented with an n bit string.\n\n Then\n\n f (g, t)\n = (2 t + 2^n + 1) * g\n = (2 (s - 2^n - 1)/2 + 2^n + 1) * g\n = (s - 2^n - 1 + 2^n + 1) * g\n = s * g\n = f' (g, s)\n\n as desired.\n*)\n\nmodule type S = sig\n [%%versioned:\n module Stable : sig\n module V1 : sig\n type 'f t [@@deriving sexp, compare, equal, yojson, hash]\n end\n end]\n\n val typ :\n ('a, 'b, 'f) Snarky_backendless.Typ.t\n -> ('a t, 'b t, 'f) Snarky_backendless.Typ.t\n\n val map : 'a t -> f:('a -> 'b) -> 'b t\n\n module Shift : sig\n type _ t\n\n val create : (module Field_intf with type t = 'f) -> 'f t\n\n val map : 'a t -> f:('a -> 'b) -> 'b t\n end\n\n val of_field :\n (module Field_intf with type t = 'f) -> shift:'f Shift.t -> 'f -> 'f t\n\n val to_field :\n (module Field_intf with type t = 'f) -> shift:'f Shift.t -> 'f t -> 'f\n\n val equal : ('f, 'res) Sigs.rel2 -> ('f t, 'res) Sigs.rel2\nend\n\n[@@@warning \"-4\"]\n\nmodule Type1 = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type 'f t = Shifted_value of 'f\n [@@deriving sexp, compare, equal, yojson, hash]\n end\n end]\n\n let typ f =\n let there (Shifted_value x) = x in\n let back x = Shifted_value x in\n Snarky_backendless.Typ.(\n transport_var (transport f ~there ~back) ~there ~back)\n\n let map (Shifted_value x) ~f = Shifted_value (f x)\n\n module Shift : sig\n type 'f t = private { c : 'f; scale : 'f }\n\n val create : (module Field_intf with type t = 'f) -> 'f t\n\n val map : 'a t -> f:('a -> 'b) -> 'b t\n end = struct\n type 'f t = { c : 'f; scale : 'f }\n\n let map t ~f = { c = f t.c; scale = f t.scale }\n\n (* 2^{field size in bits} + 1 *)\n let create (type f) (module F : Field_intf with type t = f) : f t =\n { c = F.(two_to_the (module F) size_in_bits + one)\n ; scale = F.(inv (of_int 2))\n }\n end\n\n let of_field (type f) (module F : Field_intf with type t = f)\n ~(shift : f Shift.t) (s : f) : f t =\n Shifted_value F.((s - shift.c) * shift.scale)\n\n let to_field (type f) (module F : Field_intf with type t = f)\n ~(shift : f Shift.t) (Shifted_value t : f t) : f =\n F.(t + t + shift.c)\n\n let equal equal (Shifted_value t1) (Shifted_value t2) = equal t1 t2\nend\n\n(* When the scalar field is larger than the inner field of the circuit,\n we need to encode a scalar [s] as a pair ((s >> 1), s & 1). In other\n words, the high bits, and then the low bit separately.\n\n We can then efficiently compute the function\n\n f = fun (g, s) -> (2 * (s >> 1) + (s & 1) + 2^(5 * ceil(len(s >> 1) / 5))) g\n = fun (g, s) -> (s + 2^field_size_in_bits) g\n\n This is a different notion of shifted value, so we have a separate type for it.\n*)\n\nmodule Type2 = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type 'f t = Shifted_value of 'f\n [@@deriving sexp, compare, equal, yojson, hash]\n end\n end]\n\n let typ f =\n let there (Shifted_value x) = x in\n let back x = Shifted_value x in\n Snarky_backendless.Typ.(\n transport_var (transport f ~there ~back) ~there ~back)\n\n let map (Shifted_value x) ~f = Shifted_value (f x)\n\n module Shift : sig\n type 'f t = private 'f\n\n val create : (module Field_intf with type t = 'f) -> 'f t\n\n val map : 'a t -> f:('a -> 'b) -> 'b t\n end = struct\n type 'f t = 'f\n\n let map t ~f = f t\n\n (* 2^{field size in bits} *)\n let create (type f) (module F : Field_intf with type t = f) : f t =\n two_to_the (module F) F.size_in_bits\n end\n\n let of_field (type f) (module F : Field_intf with type t = f)\n ~(shift : f Shift.t) (s : f) : f t =\n Shifted_value F.(s - (shift :> t))\n\n let to_field (type f) (module F : Field_intf with type t = f)\n ~(shift : f Shift.t) (Shifted_value t : f t) : f =\n F.(t + (shift :> t))\n\n let equal equal (Shifted_value t1) (Shifted_value t2) = equal t1 t2\nend\n","open Core_kernel\n\nlet padded_array_typ ~length ~dummy elt =\n Snarky_backendless.Typ.array ~length elt\n |> Snarky_backendless.Typ.transport\n ~there:(fun a ->\n let n = Array.length a in\n if n > length then failwithf \"Expected %d <= %d\" n length () ;\n Array.append a (Array.create ~len:(length - n) dummy) )\n ~back:Fn.id\n\nlet hash_fold_array f s x = hash_fold_list f s (Array.to_list x)\n\nmodule Columns = Nat.N15\nmodule Columns_vec = Vector.Vector_15\nmodule Permuts_minus_1 = Nat.N6\nmodule Permuts_minus_1_vec = Vector.Vector_6\nmodule Permuts = Nat.N7\nmodule Permuts_vec = Vector.Vector_7\nmodule Lookup_sorted_vec = Vector.Vector_5\n\nmodule Opt = struct\n [@@@warning \"-4\"]\n\n type ('a, 'bool) t = Some of 'a | None | Maybe of 'bool * 'a\n [@@deriving sexp, compare, yojson, hash, equal]\n\n let to_option : ('a, bool) t -> 'a option = function\n | Some x ->\n Some x\n | Maybe (true, x) ->\n Some x\n | Maybe (false, _x) ->\n None\n | None ->\n None\n\n let to_option_unsafe : ('a, 'bool) t -> 'a option = function\n | Some x ->\n Some x\n | Maybe (_, x) ->\n Some x\n | None ->\n None\n\n let value_exn = function\n | Some x ->\n x\n | Maybe (_, x) ->\n x\n | None ->\n invalid_arg \"Opt.value_exn\"\n\n let of_option (t : 'a option) : ('a, 'bool) t =\n match t with None -> None | Some x -> Some x\n\n module Flag = struct\n type t = Yes | No | Maybe [@@deriving sexp, compare, yojson, hash, equal]\n\n let ( ||| ) x y =\n match (x, y) with\n | Yes, _ | _, Yes ->\n Yes\n | Maybe, _ | _, Maybe ->\n Maybe\n | No, No ->\n No\n end\n\n let map t ~f =\n match t with\n | None ->\n None\n | Some x ->\n Some (f x)\n | Maybe (b, x) ->\n Maybe (b, f x)\n\n open Snarky_backendless\n\n let some_typ (type a a_var f bool_var) (t : (a_var, a, f) Typ.t) :\n ((a_var, bool_var) t, a option, f) Typ.t =\n Typ.transport t ~there:(fun x -> Option.value_exn x) ~back:Option.return\n |> Typ.transport_var\n ~there:(function\n | Some x ->\n x\n | Maybe _ | None ->\n failwith \"Opt.some_typ: expected Some\" )\n ~back:(fun x -> Some x)\n\n let none_typ (type a a_var f bool) () : ((a_var, bool) t, a option, f) Typ.t =\n Typ.transport (Typ.unit ())\n ~there:(fun _ -> ())\n ~back:(fun () : _ Option.t -> None)\n |> Typ.transport_var\n ~there:(function\n | None ->\n ()\n | Maybe _ | Some _ ->\n failwith \"Opt.none_typ: expected None\" )\n ~back:(fun () : _ t -> None)\n\n let maybe_typ (type a a_var bool_var f)\n (bool_typ : (bool_var, bool, f) Snarky_backendless.Typ.t) ~(dummy : a)\n (a_typ : (a_var, a, f) Typ.t) : ((a_var, bool_var) t, a option, f) Typ.t =\n Typ.transport\n (Typ.tuple2 bool_typ a_typ)\n ~there:(fun (t : a option) ->\n match t with None -> (false, dummy) | Some x -> (true, x) )\n ~back:(fun (b, x) -> if b then Some x else None)\n |> Typ.transport_var\n ~there:(fun (t : (a_var, _) t) ->\n match t with\n | Maybe (b, x) ->\n (b, x)\n | None | Some _ ->\n failwith \"Opt.maybe_typ: expected Maybe\" )\n ~back:(fun (b, x) -> Maybe (b, x))\n\n let constant_layout_typ (type a a_var f) (bool_typ : _ Typ.t) ~true_ ~false_\n (flag : Flag.t) (a_typ : (a_var, a, f) Typ.t) ~(dummy : a)\n ~(dummy_var : a_var) =\n let (Typ bool_typ) = bool_typ in\n let bool_typ : _ Typ.t =\n let check =\n (* No need to boolean constrain in the No or Yes case *)\n match flag with\n | No | Yes ->\n fun _ -> Checked_runner.Simple.return ()\n | Maybe ->\n bool_typ.check\n in\n Typ { bool_typ with check }\n in\n Typ.transport\n (Typ.tuple2 bool_typ a_typ)\n ~there:(fun (t : a option) ->\n match t with None -> (false, dummy) | Some x -> (true, x) )\n ~back:(fun (b, x) -> if b then Some x else None)\n |> Typ.transport_var\n ~there:(fun (t : (a_var, _) t) ->\n match t with\n | Maybe (b, x) ->\n (b, x)\n | None ->\n (false_, dummy_var)\n | Some x ->\n (true_, x) )\n ~back:(fun (b, x) ->\n match flag with No -> None | Yes -> Some x | Maybe -> Maybe (b, x) )\n\n let typ (type a a_var f) bool_typ (flag : Flag.t)\n (a_typ : (a_var, a, f) Typ.t) ~(dummy : a) =\n match flag with\n | Yes ->\n some_typ a_typ\n | No ->\n none_typ ()\n | Maybe ->\n maybe_typ bool_typ ~dummy a_typ\n\n module Early_stop_sequence = struct\n (* A sequence that should be considered to have stopped at\n the first No flag *)\n (* TODO: The documentation above makes it sound like the type below is too\n generic: we're not guaranteed to have flags in there *)\n type nonrec ('a, 'bool) t = ('a, 'bool) t list\n\n let fold (type a bool acc res)\n (if_res : bool -> then_:res -> else_:res -> res) (t : (a, bool) t)\n ~(init : acc) ~(f : acc -> a -> acc) ~(finish : acc -> res) =\n let rec go acc = function\n | [] ->\n finish acc\n | None :: xs ->\n go acc xs\n | Some x :: xs ->\n go (f acc x) xs\n | Maybe (b, x) :: xs ->\n (* Computing this first makes mutation in f OK. *)\n let stop_res = finish acc in\n let continue_res = go (f acc x) xs in\n if_res b ~then_:continue_res ~else_:stop_res\n in\n go init t\n end\nend\n\nmodule Features = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type 'bool t =\n { range_check0 : 'bool\n ; range_check1 : 'bool\n ; foreign_field_add : 'bool\n ; foreign_field_mul : 'bool\n ; xor : 'bool\n ; rot : 'bool\n ; lookup : 'bool\n ; runtime_tables : 'bool\n }\n [@@deriving sexp, compare, yojson, hash, equal, hlist]\n end\n end]\n\n type options = Opt.Flag.t t\n\n type flags = bool t\n\n let to_data\n { range_check0\n ; range_check1\n ; foreign_field_add\n ; foreign_field_mul\n ; xor\n ; rot\n ; lookup\n ; runtime_tables\n } : _ Hlist.HlistId.t =\n [ range_check0\n ; range_check1\n ; foreign_field_add\n ; foreign_field_mul\n ; xor\n ; rot\n ; lookup\n ; runtime_tables\n ]\n\n let of_data\n ([ range_check0\n ; range_check1\n ; foreign_field_add\n ; foreign_field_mul\n ; xor\n ; rot\n ; lookup\n ; runtime_tables\n ] :\n _ Hlist.HlistId.t ) =\n { range_check0\n ; range_check1\n ; foreign_field_add\n ; foreign_field_mul\n ; xor\n ; rot\n ; lookup\n ; runtime_tables\n }\n\n let typ bool\n ~feature_flags:\n { range_check0\n ; range_check1\n ; foreign_field_add\n ; foreign_field_mul\n ; xor\n ; rot\n ; lookup\n ; runtime_tables\n } =\n (* TODO: This should come from snarky. *)\n let constant (type var value)\n (typ : (var, value, _) Snarky_backendless.Typ.t) (x : value) : var =\n let (Typ typ) = typ in\n let fields, aux = typ.value_to_fields x in\n let fields =\n Array.map ~f:(fun x -> Snarky_backendless.Cvar.Constant x) fields\n in\n typ.var_of_fields (fields, aux)\n in\n let constant_typ ~there value =\n let open Snarky_backendless.Typ in\n unit ()\n |> transport ~there ~back:(fun () -> value)\n |> transport_var ~there:(fun _ -> ()) ~back:(fun () -> constant bool value)\n in\n let bool_typ_of_flag = function\n | Opt.Flag.Yes ->\n constant_typ\n ~there:(function true -> () | false -> assert false)\n true\n | Opt.Flag.No ->\n constant_typ\n ~there:(function false -> () | true -> assert false)\n false\n | Opt.Flag.Maybe ->\n bool\n in\n Snarky_backendless.Typ.of_hlistable\n [ bool_typ_of_flag range_check0\n ; bool_typ_of_flag range_check1\n ; bool_typ_of_flag foreign_field_add\n ; bool_typ_of_flag foreign_field_mul\n ; bool_typ_of_flag xor\n ; bool_typ_of_flag rot\n ; bool_typ_of_flag lookup\n ; bool_typ_of_flag runtime_tables\n ]\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist\n\n let none =\n { range_check0 = Opt.Flag.No\n ; range_check1 = Opt.Flag.No\n ; foreign_field_add = Opt.Flag.No\n ; foreign_field_mul = Opt.Flag.No\n ; xor = Opt.Flag.No\n ; rot = Opt.Flag.No\n ; lookup = Opt.Flag.No\n ; runtime_tables = Opt.Flag.No\n }\n\n let none_bool =\n { range_check0 = false\n ; range_check1 = false\n ; foreign_field_add = false\n ; foreign_field_mul = false\n ; xor = false\n ; rot = false\n ; lookup = false\n ; runtime_tables = false\n }\n\n let map\n { range_check0\n ; range_check1\n ; foreign_field_add\n ; foreign_field_mul\n ; rot\n ; xor\n ; lookup\n ; runtime_tables\n } ~f =\n { range_check0 = f range_check0\n ; range_check1 = f range_check1\n ; foreign_field_add = f foreign_field_add\n ; foreign_field_mul = f foreign_field_mul\n ; xor = f xor\n ; rot = f rot\n ; lookup = f lookup\n ; runtime_tables = f runtime_tables\n }\n\n let map2 x1 x2 ~f =\n { range_check0 = f x1.range_check0 x2.range_check0\n ; range_check1 = f x1.range_check1 x2.range_check1\n ; foreign_field_add = f x1.foreign_field_add x2.foreign_field_add\n ; foreign_field_mul = f x1.foreign_field_mul x2.foreign_field_mul\n ; xor = f x1.xor x2.xor\n ; rot = f x1.rot x2.rot\n ; lookup = f x1.lookup x2.lookup\n ; runtime_tables = f x1.runtime_tables x2.runtime_tables\n }\nend\n\nmodule Evals = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type 'a t =\n { w : 'a Columns_vec.Stable.V1.t\n ; coefficients : 'a Columns_vec.Stable.V1.t\n ; z : 'a\n ; s : 'a Permuts_minus_1_vec.Stable.V1.t\n ; generic_selector : 'a\n ; poseidon_selector : 'a\n ; complete_add_selector : 'a\n ; mul_selector : 'a\n ; emul_selector : 'a\n ; endomul_scalar_selector : 'a\n ; range_check0_selector : 'a option\n ; range_check1_selector : 'a option\n ; foreign_field_add_selector : 'a option\n ; foreign_field_mul_selector : 'a option\n ; xor_selector : 'a option\n ; rot_selector : 'a option\n ; lookup_aggregation : 'a option\n ; lookup_table : 'a option\n ; lookup_sorted : 'a option Lookup_sorted_vec.Stable.V1.t\n ; runtime_lookup_table : 'a option\n ; runtime_lookup_table_selector : 'a option\n ; xor_lookup_selector : 'a option\n ; lookup_gate_lookup_selector : 'a option\n ; range_check_lookup_selector : 'a option\n ; foreign_field_mul_lookup_selector : 'a option\n }\n [@@deriving fields, sexp, compare, yojson, hash, equal, hlist]\n end\n end]\n\n let validate_feature_flags ~feature_flags:(f : bool Features.t)\n { w = _\n ; coefficients = _\n ; z = _\n ; s = _\n ; generic_selector = _\n ; poseidon_selector = _\n ; complete_add_selector = _\n ; mul_selector = _\n ; emul_selector = _\n ; endomul_scalar_selector = _\n ; range_check0_selector\n ; range_check1_selector\n ; foreign_field_add_selector\n ; foreign_field_mul_selector\n ; xor_selector\n ; rot_selector\n ; lookup_aggregation\n ; lookup_table\n ; lookup_sorted\n ; runtime_lookup_table\n ; runtime_lookup_table_selector\n ; xor_lookup_selector\n ; lookup_gate_lookup_selector\n ; range_check_lookup_selector\n ; foreign_field_mul_lookup_selector\n } =\n let enable_if x flag = Bool.(Option.is_some x = flag) in\n let range_check_lookup = f.range_check0 || f.range_check1 || f.rot in\n let lookups_per_row_4 = f.xor || range_check_lookup in\n let lookups_per_row_3 = lookups_per_row_4 || f.lookup in\n let lookups_per_row_2 = lookups_per_row_3 || f.foreign_field_mul in\n Array.reduce_exn ~f:( && )\n [| enable_if range_check0_selector f.range_check0\n ; enable_if range_check1_selector f.range_check1\n ; enable_if foreign_field_add_selector f.foreign_field_add\n ; enable_if foreign_field_mul_selector f.foreign_field_mul\n ; enable_if xor_selector f.xor\n ; enable_if rot_selector f.rot\n ; enable_if lookup_aggregation lookups_per_row_2\n ; enable_if lookup_table lookups_per_row_2\n ; Vector.foldi lookup_sorted ~init:true ~f:(fun i acc x ->\n let flag =\n (* NB: lookups_per_row + 1 in sorted, due to the lookup table. *)\n match i with\n | 0 | 1 | 2 ->\n lookups_per_row_2\n | 3 ->\n lookups_per_row_3\n | 4 ->\n lookups_per_row_4\n | _ ->\n assert false\n in\n acc && enable_if x flag )\n ; enable_if runtime_lookup_table f.runtime_tables\n ; enable_if runtime_lookup_table_selector f.runtime_tables\n ; enable_if xor_lookup_selector f.xor\n ; enable_if lookup_gate_lookup_selector f.lookup\n ; enable_if range_check_lookup_selector range_check_lookup\n ; enable_if foreign_field_mul_lookup_selector f.foreign_field_mul\n |]\n\n let to_absorption_sequence\n { w\n ; coefficients\n ; z\n ; s\n ; generic_selector\n ; poseidon_selector\n ; complete_add_selector\n ; mul_selector\n ; emul_selector\n ; endomul_scalar_selector\n ; range_check0_selector\n ; range_check1_selector\n ; foreign_field_add_selector\n ; foreign_field_mul_selector\n ; xor_selector\n ; rot_selector\n ; lookup_aggregation\n ; lookup_table\n ; lookup_sorted\n ; runtime_lookup_table\n ; runtime_lookup_table_selector\n ; xor_lookup_selector\n ; lookup_gate_lookup_selector\n ; range_check_lookup_selector\n ; foreign_field_mul_lookup_selector\n } : _ list =\n let always_present =\n [ z\n ; generic_selector\n ; poseidon_selector\n ; complete_add_selector\n ; mul_selector\n ; emul_selector\n ; endomul_scalar_selector\n ]\n @ Vector.to_list w\n @ Vector.to_list coefficients\n @ Vector.to_list s\n in\n let optional_gates =\n List.filter_map ~f:Fn.id\n [ range_check0_selector\n ; range_check1_selector\n ; foreign_field_add_selector\n ; foreign_field_mul_selector\n ; xor_selector\n ; rot_selector\n ; lookup_aggregation\n ; lookup_table\n ]\n in\n let lookup_final_terms =\n List.filter_map ~f:Fn.id\n [ runtime_lookup_table\n ; runtime_lookup_table_selector\n ; xor_lookup_selector\n ; lookup_gate_lookup_selector\n ; range_check_lookup_selector\n ; foreign_field_mul_lookup_selector\n ]\n in\n always_present @ optional_gates\n @ List.filter_map ~f:Fn.id (Vector.to_list lookup_sorted)\n @ lookup_final_terms\n\n module In_circuit = struct\n type ('f, 'bool) t =\n { w : 'f Columns_vec.t\n ; coefficients : 'f Columns_vec.t\n ; z : 'f\n ; s : 'f Permuts_minus_1_vec.t\n ; generic_selector : 'f\n ; poseidon_selector : 'f\n ; complete_add_selector : 'f\n ; mul_selector : 'f\n ; emul_selector : 'f\n ; endomul_scalar_selector : 'f\n ; range_check0_selector : ('f, 'bool) Opt.t\n ; range_check1_selector : ('f, 'bool) Opt.t\n ; foreign_field_add_selector : ('f, 'bool) Opt.t\n ; foreign_field_mul_selector : ('f, 'bool) Opt.t\n ; xor_selector : ('f, 'bool) Opt.t\n ; rot_selector : ('f, 'bool) Opt.t\n ; lookup_aggregation : ('f, 'bool) Opt.t\n ; lookup_table : ('f, 'bool) Opt.t\n ; lookup_sorted : ('f, 'bool) Opt.t Lookup_sorted_vec.t\n ; runtime_lookup_table : ('f, 'bool) Opt.t\n ; runtime_lookup_table_selector : ('f, 'bool) Opt.t\n ; xor_lookup_selector : ('f, 'bool) Opt.t\n ; lookup_gate_lookup_selector : ('f, 'bool) Opt.t\n ; range_check_lookup_selector : ('f, 'bool) Opt.t\n ; foreign_field_mul_lookup_selector : ('f, 'bool) Opt.t\n }\n [@@deriving hlist, fields]\n\n let map (type bool a b)\n ({ w\n ; coefficients\n ; z\n ; s\n ; generic_selector\n ; poseidon_selector\n ; complete_add_selector\n ; mul_selector\n ; emul_selector\n ; endomul_scalar_selector\n ; range_check0_selector\n ; range_check1_selector\n ; foreign_field_add_selector\n ; foreign_field_mul_selector\n ; xor_selector\n ; rot_selector\n ; lookup_aggregation\n ; lookup_table\n ; lookup_sorted\n ; runtime_lookup_table\n ; runtime_lookup_table_selector\n ; xor_lookup_selector\n ; lookup_gate_lookup_selector\n ; range_check_lookup_selector\n ; foreign_field_mul_lookup_selector\n } :\n (a, bool) t ) ~(f : a -> b) : (b, bool) t =\n { w = Vector.map w ~f\n ; coefficients = Vector.map coefficients ~f\n ; z = f z\n ; s = Vector.map s ~f\n ; generic_selector = f generic_selector\n ; poseidon_selector = f poseidon_selector\n ; complete_add_selector = f complete_add_selector\n ; mul_selector = f mul_selector\n ; emul_selector = f emul_selector\n ; endomul_scalar_selector = f endomul_scalar_selector\n ; range_check0_selector = Opt.map ~f range_check0_selector\n ; range_check1_selector = Opt.map ~f range_check1_selector\n ; foreign_field_add_selector = Opt.map ~f foreign_field_add_selector\n ; foreign_field_mul_selector = Opt.map ~f foreign_field_mul_selector\n ; xor_selector = Opt.map ~f xor_selector\n ; rot_selector = Opt.map ~f rot_selector\n ; lookup_aggregation = Opt.map ~f lookup_aggregation\n ; lookup_table = Opt.map ~f lookup_table\n ; lookup_sorted = Vector.map ~f:(Opt.map ~f) lookup_sorted\n ; runtime_lookup_table = Opt.map ~f runtime_lookup_table\n ; runtime_lookup_table_selector = Opt.map ~f runtime_lookup_table_selector\n ; xor_lookup_selector = Opt.map ~f xor_lookup_selector\n ; lookup_gate_lookup_selector = Opt.map ~f lookup_gate_lookup_selector\n ; range_check_lookup_selector = Opt.map ~f range_check_lookup_selector\n ; foreign_field_mul_lookup_selector =\n Opt.map ~f foreign_field_mul_lookup_selector\n }\n\n let to_list\n { w\n ; coefficients\n ; z\n ; s\n ; generic_selector\n ; poseidon_selector\n ; complete_add_selector\n ; mul_selector\n ; emul_selector\n ; endomul_scalar_selector\n ; range_check0_selector\n ; range_check1_selector\n ; foreign_field_add_selector\n ; foreign_field_mul_selector\n ; xor_selector\n ; rot_selector\n ; lookup_aggregation\n ; lookup_table\n ; lookup_sorted\n ; runtime_lookup_table\n ; runtime_lookup_table_selector\n ; xor_lookup_selector\n ; lookup_gate_lookup_selector\n ; range_check_lookup_selector\n ; foreign_field_mul_lookup_selector\n } =\n let some x = Opt.Some x in\n let always_present =\n List.map ~f:some\n ( [ z\n ; generic_selector\n ; poseidon_selector\n ; complete_add_selector\n ; mul_selector\n ; emul_selector\n ; endomul_scalar_selector\n ]\n @ Vector.to_list w\n @ Vector.to_list coefficients\n @ Vector.to_list s )\n in\n let optional_gates =\n [ range_check0_selector\n ; range_check1_selector\n ; foreign_field_add_selector\n ; foreign_field_mul_selector\n ; xor_selector\n ; rot_selector\n ]\n in\n always_present @ optional_gates\n @ Vector.to_list lookup_sorted\n @ [ lookup_aggregation\n ; lookup_table\n ; runtime_lookup_table\n ; runtime_lookup_table_selector\n ; xor_lookup_selector\n ; lookup_gate_lookup_selector\n ; range_check_lookup_selector\n ; foreign_field_mul_lookup_selector\n ]\n\n let to_absorption_sequence\n { w\n ; coefficients\n ; z\n ; s\n ; generic_selector\n ; poseidon_selector\n ; complete_add_selector\n ; mul_selector\n ; emul_selector\n ; endomul_scalar_selector\n ; range_check0_selector\n ; range_check1_selector\n ; foreign_field_add_selector\n ; foreign_field_mul_selector\n ; xor_selector\n ; rot_selector\n ; lookup_aggregation\n ; lookup_table\n ; lookup_sorted\n ; runtime_lookup_table\n ; runtime_lookup_table_selector\n ; xor_lookup_selector\n ; lookup_gate_lookup_selector\n ; range_check_lookup_selector\n ; foreign_field_mul_lookup_selector\n } : _ Opt.Early_stop_sequence.t =\n let always_present =\n [ z\n ; generic_selector\n ; poseidon_selector\n ; complete_add_selector\n ; mul_selector\n ; emul_selector\n ; endomul_scalar_selector\n ]\n @ Vector.to_list w\n @ Vector.to_list coefficients\n @ Vector.to_list s\n in\n let optional_gates =\n [ range_check0_selector\n ; range_check1_selector\n ; foreign_field_add_selector\n ; foreign_field_mul_selector\n ; xor_selector\n ; rot_selector\n ; lookup_aggregation\n ; lookup_table\n ]\n in\n let some x = Opt.Some x in\n List.map ~f:some always_present\n @ optional_gates\n @ Vector.to_list lookup_sorted\n @ [ runtime_lookup_table\n ; runtime_lookup_table_selector\n ; xor_lookup_selector\n ; lookup_gate_lookup_selector\n ; range_check_lookup_selector\n ; foreign_field_mul_lookup_selector\n ]\n end\n\n let to_in_circuit (type bool a)\n ({ w\n ; coefficients\n ; z\n ; s\n ; generic_selector\n ; poseidon_selector\n ; complete_add_selector\n ; mul_selector\n ; emul_selector\n ; endomul_scalar_selector\n ; range_check0_selector\n ; range_check1_selector\n ; foreign_field_add_selector\n ; foreign_field_mul_selector\n ; xor_selector\n ; rot_selector\n ; lookup_aggregation\n ; lookup_table\n ; lookup_sorted\n ; runtime_lookup_table\n ; runtime_lookup_table_selector\n ; xor_lookup_selector\n ; lookup_gate_lookup_selector\n ; range_check_lookup_selector\n ; foreign_field_mul_lookup_selector\n } :\n a t ) : (a, bool) In_circuit.t =\n { w\n ; coefficients\n ; z\n ; s\n ; generic_selector\n ; poseidon_selector\n ; complete_add_selector\n ; mul_selector\n ; emul_selector\n ; endomul_scalar_selector\n ; range_check0_selector = Opt.of_option range_check0_selector\n ; range_check1_selector = Opt.of_option range_check1_selector\n ; foreign_field_add_selector = Opt.of_option foreign_field_add_selector\n ; foreign_field_mul_selector = Opt.of_option foreign_field_mul_selector\n ; xor_selector = Opt.of_option xor_selector\n ; rot_selector = Opt.of_option rot_selector\n ; lookup_aggregation = Opt.of_option lookup_aggregation\n ; lookup_table = Opt.of_option lookup_table\n ; lookup_sorted = Vector.map ~f:Opt.of_option lookup_sorted\n ; runtime_lookup_table = Opt.of_option runtime_lookup_table\n ; runtime_lookup_table_selector =\n Opt.of_option runtime_lookup_table_selector\n ; xor_lookup_selector = Opt.of_option xor_lookup_selector\n ; lookup_gate_lookup_selector = Opt.of_option lookup_gate_lookup_selector\n ; range_check_lookup_selector = Opt.of_option range_check_lookup_selector\n ; foreign_field_mul_lookup_selector =\n Opt.of_option foreign_field_mul_lookup_selector\n }\n\n let map (type a b)\n ({ w\n ; coefficients\n ; z\n ; s\n ; generic_selector\n ; poseidon_selector\n ; complete_add_selector\n ; mul_selector\n ; emul_selector\n ; endomul_scalar_selector\n ; range_check0_selector\n ; range_check1_selector\n ; foreign_field_add_selector\n ; foreign_field_mul_selector\n ; xor_selector\n ; rot_selector\n ; lookup_aggregation\n ; lookup_table\n ; lookup_sorted\n ; runtime_lookup_table\n ; runtime_lookup_table_selector\n ; xor_lookup_selector\n ; lookup_gate_lookup_selector\n ; range_check_lookup_selector\n ; foreign_field_mul_lookup_selector\n } :\n a t ) ~(f : a -> b) : b t =\n { w = Vector.map w ~f\n ; coefficients = Vector.map coefficients ~f\n ; z = f z\n ; s = Vector.map s ~f\n ; generic_selector = f generic_selector\n ; poseidon_selector = f poseidon_selector\n ; complete_add_selector = f complete_add_selector\n ; mul_selector = f mul_selector\n ; emul_selector = f emul_selector\n ; endomul_scalar_selector = f endomul_scalar_selector\n ; range_check0_selector = Option.map ~f range_check0_selector\n ; range_check1_selector = Option.map ~f range_check1_selector\n ; foreign_field_add_selector = Option.map ~f foreign_field_add_selector\n ; foreign_field_mul_selector = Option.map ~f foreign_field_mul_selector\n ; xor_selector = Option.map ~f xor_selector\n ; rot_selector = Option.map ~f rot_selector\n ; lookup_aggregation = Option.map ~f lookup_aggregation\n ; lookup_table = Option.map ~f lookup_table\n ; lookup_sorted = Vector.map ~f:(Option.map ~f) lookup_sorted\n ; runtime_lookup_table = Option.map ~f runtime_lookup_table\n ; runtime_lookup_table_selector =\n Option.map ~f runtime_lookup_table_selector\n ; xor_lookup_selector = Option.map ~f xor_lookup_selector\n ; lookup_gate_lookup_selector = Option.map ~f lookup_gate_lookup_selector\n ; range_check_lookup_selector = Option.map ~f range_check_lookup_selector\n ; foreign_field_mul_lookup_selector =\n Option.map ~f foreign_field_mul_lookup_selector\n }\n\n let map2 (type a b c) (t1 : a t) (t2 : b t) ~(f : a -> b -> c) : c t =\n { w = Vector.map2 t1.w t2.w ~f\n ; coefficients = Vector.map2 t1.coefficients t2.coefficients ~f\n ; z = f t1.z t2.z\n ; s = Vector.map2 t1.s t2.s ~f\n ; generic_selector = f t1.generic_selector t2.generic_selector\n ; poseidon_selector = f t1.poseidon_selector t2.poseidon_selector\n ; complete_add_selector =\n f t1.complete_add_selector t2.complete_add_selector\n ; mul_selector = f t1.mul_selector t2.mul_selector\n ; emul_selector = f t1.emul_selector t2.emul_selector\n ; endomul_scalar_selector =\n f t1.endomul_scalar_selector t2.endomul_scalar_selector\n ; range_check0_selector =\n Option.map2 ~f t1.range_check0_selector t2.range_check0_selector\n ; range_check1_selector =\n Option.map2 ~f t1.range_check1_selector t2.range_check1_selector\n ; foreign_field_add_selector =\n Option.map2 ~f t1.foreign_field_add_selector\n t2.foreign_field_add_selector\n ; foreign_field_mul_selector =\n Option.map2 ~f t1.foreign_field_mul_selector\n t2.foreign_field_mul_selector\n ; xor_selector = Option.map2 ~f t1.xor_selector t2.xor_selector\n ; rot_selector = Option.map2 ~f t1.rot_selector t2.rot_selector\n ; lookup_aggregation =\n Option.map2 ~f t1.lookup_aggregation t2.lookup_aggregation\n ; lookup_table = Option.map2 ~f t1.lookup_table t2.lookup_table\n ; lookup_sorted =\n Vector.map2 ~f:(Option.map2 ~f) t1.lookup_sorted t2.lookup_sorted\n ; runtime_lookup_table =\n Option.map2 ~f t1.runtime_lookup_table t2.runtime_lookup_table\n ; runtime_lookup_table_selector =\n Option.map2 ~f t1.runtime_lookup_table_selector\n t2.runtime_lookup_table_selector\n ; xor_lookup_selector =\n Option.map2 ~f t1.xor_lookup_selector t2.xor_lookup_selector\n ; lookup_gate_lookup_selector =\n Option.map2 ~f t1.lookup_gate_lookup_selector\n t2.lookup_gate_lookup_selector\n ; range_check_lookup_selector =\n Option.map2 ~f t1.range_check_lookup_selector\n t2.range_check_lookup_selector\n ; foreign_field_mul_lookup_selector =\n Option.map2 ~f t1.foreign_field_mul_lookup_selector\n t2.foreign_field_mul_lookup_selector\n }\n\n (*\n This is in the same order as the evaluations in the opening proof:\n added later:\n - old sg polynomials\n - public input polynomial\n - ft\n here:\n - z\n - generic selector\n - poseidon selector\n - complete_add_selector\n - mul_selector\n - emul_selector\n - endomul_scalar_selector\n - w (witness columns)\n - coefficients\n - s (sigma columns)\n\n then optionally:\n - lookup sorted\n - lookup aggreg\n - lookup table\n - lookup runtime\n *)\n\n let to_list\n { w\n ; coefficients\n ; z\n ; s\n ; generic_selector\n ; poseidon_selector\n ; complete_add_selector\n ; mul_selector\n ; emul_selector\n ; endomul_scalar_selector\n ; range_check0_selector\n ; range_check1_selector\n ; foreign_field_add_selector\n ; foreign_field_mul_selector\n ; xor_selector\n ; rot_selector\n ; lookup_aggregation\n ; lookup_table\n ; lookup_sorted\n ; runtime_lookup_table\n ; runtime_lookup_table_selector\n ; xor_lookup_selector\n ; lookup_gate_lookup_selector\n ; range_check_lookup_selector\n ; foreign_field_mul_lookup_selector\n } =\n let always_present =\n [ z\n ; generic_selector\n ; poseidon_selector\n ; complete_add_selector\n ; mul_selector\n ; emul_selector\n ; endomul_scalar_selector\n ]\n @ Vector.to_list w\n @ Vector.to_list coefficients\n @ Vector.to_list s\n in\n let optional_gates =\n List.filter_map ~f:Fn.id\n [ range_check0_selector\n ; range_check1_selector\n ; foreign_field_add_selector\n ; foreign_field_mul_selector\n ; xor_selector\n ; rot_selector\n ]\n in\n always_present @ optional_gates\n @ List.filter_map ~f:Fn.id (Vector.to_list lookup_sorted)\n @ List.filter_map ~f:Fn.id\n [ lookup_aggregation\n ; lookup_table\n ; runtime_lookup_table\n ; runtime_lookup_table_selector\n ; xor_lookup_selector\n ; lookup_gate_lookup_selector\n ; range_check_lookup_selector\n ; foreign_field_mul_lookup_selector\n ]\n\n let typ (type f a_var a)\n (module Impl : Snarky_backendless.Snark_intf.Run with type field = f)\n ~dummy e (feature_flags : _ Features.t) :\n ((a_var, Impl.Boolean.var) In_circuit.t, a t, f) Snarky_backendless.Typ.t\n =\n let open Impl in\n let opt flag = Opt.typ Impl.Boolean.typ flag e ~dummy in\n let uses_lookup =\n let { Features.range_check0\n ; range_check1\n ; foreign_field_add = _ (* Doesn't use lookup *)\n ; foreign_field_mul\n ; xor\n ; rot\n ; lookup\n ; runtime_tables = _ (* Fixme *)\n } =\n feature_flags\n in\n Array.reduce_exn ~f:Opt.Flag.( ||| )\n [| range_check0; range_check1; foreign_field_mul; xor; rot; lookup |]\n in\n let lookup_sorted =\n match uses_lookup with\n | Opt.Flag.No ->\n Opt.Flag.No\n | Yes | Maybe ->\n Opt.Flag.Maybe\n in\n Typ.of_hlistable\n [ Vector.typ e Columns.n\n ; Vector.typ e Columns.n\n ; e\n ; Vector.typ e Permuts_minus_1.n\n ; e\n ; e\n ; e\n ; e\n ; e\n ; e\n ; opt feature_flags.range_check0\n ; opt feature_flags.range_check1\n ; opt feature_flags.foreign_field_add\n ; opt feature_flags.foreign_field_mul\n ; opt feature_flags.xor\n ; opt feature_flags.rot\n ; opt uses_lookup\n ; opt uses_lookup\n ; Vector.typ (opt lookup_sorted) Nat.N5.n (* TODO: Fixme *)\n ; opt feature_flags.runtime_tables\n ; opt feature_flags.runtime_tables\n ; opt feature_flags.xor\n ; opt feature_flags.lookup\n ; opt\n Opt.Flag.(\n feature_flags.range_check0 ||| feature_flags.range_check1\n ||| feature_flags.rot)\n (* TODO: This logic does not belong here. *)\n ; opt feature_flags.foreign_field_mul\n ]\n ~var_to_hlist:In_circuit.to_hlist ~var_of_hlist:In_circuit.of_hlist\n ~value_to_hlist:to_hlist ~value_of_hlist:of_hlist\nend\n\nmodule All_evals = struct\n module With_public_input = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type ('f, 'f_multi) t =\n { public_input : 'f; evals : 'f_multi Evals.Stable.V2.t }\n [@@deriving sexp, compare, yojson, hash, equal, hlist]\n end\n end]\n\n module In_circuit = struct\n type ('f, 'f_multi, 'bool) t =\n { public_input : 'f; evals : ('f_multi, 'bool) Evals.In_circuit.t }\n [@@deriving hlist]\n\n let factor (type f f_multi bool)\n ({ public_input = p1, p2; evals } : (f * f, f_multi * f_multi, bool) t)\n : (f, f_multi, bool) t Tuple_lib.Double.t =\n ( { evals = Evals.In_circuit.map ~f:fst evals; public_input = p1 }\n , { evals = Evals.In_circuit.map ~f:snd evals; public_input = p2 } )\n end\n\n let map (type a1 a2 b1 b2) (t : (a1, a2) t) ~(f1 : a1 -> b1) ~(f2 : a2 -> b2)\n : (b1, b2) t =\n { public_input = f1 t.public_input; evals = Evals.map ~f:f2 t.evals }\n\n let typ impl feature_flags f f_multi ~dummy =\n let evals = Evals.typ impl f_multi feature_flags ~dummy in\n let open Snarky_backendless.Typ in\n of_hlistable [ f; evals ] ~var_to_hlist:In_circuit.to_hlist\n ~var_of_hlist:In_circuit.of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist\n end\n\n [@@@warning \"-4\"]\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n type ('f, 'f_multi) t =\n { evals : ('f * 'f, 'f_multi * 'f_multi) With_public_input.Stable.V1.t\n ; ft_eval1 : 'f\n }\n [@@deriving sexp, compare, yojson, hash, equal, hlist]\n end\n end]\n\n module In_circuit = struct\n type ('f, 'f_multi, 'bool) t =\n { evals :\n ('f * 'f, 'f_multi * 'f_multi, 'bool) With_public_input.In_circuit.t\n ; ft_eval1 : 'f\n }\n [@@deriving hlist]\n end\n\n let map (type a1 a2 b1 b2) (t : (a1, a2) t) ~(f1 : a1 -> b1) ~(f2 : a2 -> b2)\n : (b1, b2) t =\n { evals =\n With_public_input.map t.evals\n ~f1:(Tuple_lib.Double.map ~f:f1)\n ~f2:(Tuple_lib.Double.map ~f:f2)\n ; ft_eval1 = f1 t.ft_eval1\n }\n\n let typ (type f)\n (module Impl : Snarky_backendless.Snark_intf.Run with type field = f)\n feature_flags =\n let open Impl.Typ in\n let single = array ~length:1 field in\n let evals =\n With_public_input.typ\n (module Impl)\n feature_flags (tuple2 field field) (tuple2 single single)\n ~dummy:Impl.Field.Constant.([| zero |], [| zero |])\n in\n of_hlistable [ evals; Impl.Field.typ ] ~var_to_hlist:In_circuit.to_hlist\n ~var_of_hlist:In_circuit.of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist\nend\n\nmodule Openings = struct\n [@@@warning \"-4\"] (* Deals with the 2 sexp-deriving types below *)\n\n module Bulletproof = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type ('g, 'fq) t =\n { lr : ('g * 'g) array\n ; z_1 : 'fq\n ; z_2 : 'fq\n ; delta : 'g\n ; challenge_polynomial_commitment : 'g\n }\n [@@deriving sexp, compare, yojson, hash, equal, hlist]\n end\n end]\n\n let typ fq g ~length =\n let open Snarky_backendless.Typ in\n of_hlistable\n [ array ~length (g * g); fq; fq; g; g ]\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist\n end\n\n [%%versioned\n module Stable = struct\n module V2 = struct\n type ('g, 'fq, 'fqv) t =\n { proof : ('g, 'fq) Bulletproof.Stable.V1.t\n ; evals : ('fqv * 'fqv) Evals.Stable.V2.t\n ; ft_eval1 : 'fq\n }\n [@@deriving sexp, compare, yojson, hash, equal, hlist]\n end\n end]\nend\n\nmodule Poly_comm = struct\n module With_degree_bound = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type 'g_opt t = { unshifted : 'g_opt array; shifted : 'g_opt }\n [@@deriving sexp, compare, yojson, hlist, hash, equal]\n end\n end]\n\n let padded_array_typ0 = padded_array_typ\n\n let typ (type f g g_var bool_var)\n (g : (g_var, g, f) Snarky_backendless.Typ.t) ~length\n ~dummy_group_element\n ~(bool : (bool_var, bool, f) Snarky_backendless.Typ.t) :\n ((bool_var * g_var) t, g Or_infinity.t t, f) Snarky_backendless.Typ.t =\n let open Snarky_backendless.Typ in\n let g_inf =\n transport (tuple2 bool g)\n ~there:(function\n | Or_infinity.Infinity ->\n (false, dummy_group_element)\n | Finite x ->\n (true, x) )\n ~back:(fun (b, x) -> if b then Infinity else Finite x)\n in\n let arr = padded_array_typ0 ~length ~dummy:Or_infinity.Infinity g_inf in\n of_hlistable [ arr; g_inf ] ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist\n ~value_to_hlist:to_hlist ~value_of_hlist:of_hlist\n end\n\n module Without_degree_bound = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type 'g t = 'g array [@@deriving sexp, compare, yojson, hash, equal]\n end\n end]\n end\nend\n\nmodule Messages = struct\n open Poly_comm\n\n module Poly = struct\n type ('w, 'z, 't) t = { w : 'w; z : 'z; t : 't }\n [@@deriving sexp, compare, yojson, fields, hash, equal, hlist]\n end\n\n module Lookup = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type 'g t = { sorted : 'g array; aggreg : 'g; runtime : 'g option }\n [@@deriving fields, sexp, compare, yojson, hash, equal, hlist]\n end\n end]\n\n module In_circuit = struct\n type ('g, 'bool) t =\n { sorted : 'g array; aggreg : 'g; runtime : ('g, 'bool) Opt.t }\n [@@deriving hlist]\n end\n\n let sorted_length = 5\n\n let dummy ~runtime_tables z =\n { aggreg = z\n ; sorted = Array.create ~len:sorted_length z\n ; runtime = Option.some_if runtime_tables z\n }\n\n let typ bool_typ e ~runtime_tables ~dummy =\n Snarky_backendless.Typ.of_hlistable\n [ Snarky_backendless.Typ.array ~length:sorted_length e\n ; e\n ; Opt.typ bool_typ runtime_tables e ~dummy\n ]\n ~value_to_hlist:to_hlist ~value_of_hlist:of_hlist\n ~var_to_hlist:In_circuit.to_hlist ~var_of_hlist:In_circuit.of_hlist\n\n let opt_typ bool_typ ~(lookup : Opt.Flag.t) ~(runtime_tables : Opt.Flag.t)\n ~dummy:z elt =\n Opt.typ bool_typ lookup\n ~dummy:\n (dummy z ~runtime_tables:Opt.Flag.(not (equal runtime_tables No)))\n (typ bool_typ ~runtime_tables ~dummy:z elt)\n end\n\n [%%versioned\n module Stable = struct\n module V2 = struct\n type 'g t =\n { w_comm : 'g Without_degree_bound.Stable.V1.t Columns_vec.Stable.V1.t\n ; z_comm : 'g Without_degree_bound.Stable.V1.t\n ; t_comm : 'g Without_degree_bound.Stable.V1.t\n ; lookup : 'g Without_degree_bound.Stable.V1.t Lookup.Stable.V1.t option\n }\n [@@deriving sexp, compare, yojson, fields, hash, equal, hlist]\n end\n end]\n\n module In_circuit = struct\n type ('g, 'bool) t =\n { w_comm : 'g Without_degree_bound.t Columns_vec.t\n ; z_comm : 'g Without_degree_bound.t\n ; t_comm : 'g Without_degree_bound.t\n ; lookup :\n (('g Without_degree_bound.t, 'bool) Lookup.In_circuit.t, 'bool) Opt.t\n }\n [@@deriving hlist, fields]\n end\n\n let typ (type n f)\n (module Impl : Snarky_backendless.Snark_intf.Run with type field = f) g\n ({ lookup; runtime_tables; _ } : Opt.Flag.t Features.t) ~dummy\n ~(commitment_lengths : (((int, n) Vector.t as 'v), int, int) Poly.t) ~bool\n =\n let open Snarky_backendless.Typ in\n let { Poly.w = w_lens; z; t } = commitment_lengths in\n let array ~length elt = padded_array_typ ~dummy ~length elt in\n let wo n = array ~length:(Vector.reduce_exn n ~f:Int.max) g in\n let _w n =\n With_degree_bound.typ g\n ~length:(Vector.reduce_exn n ~f:Int.max)\n ~dummy_group_element:dummy ~bool\n in\n let lookup =\n Lookup.opt_typ Impl.Boolean.typ ~lookup ~runtime_tables ~dummy:[| dummy |]\n (wo [ 1 ])\n in\n of_hlistable\n [ Vector.typ (wo w_lens) Columns.n; wo [ z ]; wo [ t ]; lookup ]\n ~var_to_hlist:In_circuit.to_hlist ~var_of_hlist:In_circuit.of_hlist\n ~value_to_hlist:to_hlist ~value_of_hlist:of_hlist\nend\n\nmodule Proof = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type ('g, 'fq, 'fqv) t =\n { messages : 'g Messages.Stable.V2.t\n ; openings : ('g, 'fq, 'fqv) Openings.Stable.V2.t\n }\n [@@deriving sexp, compare, yojson, hash, equal]\n end\n end]\nend\n\nmodule Shifts = struct\n open Core_kernel\n\n [%%versioned\n module Stable = struct\n module V2 = struct\n type 'field t = 'field array [@@deriving sexp, compare, yojson, equal]\n end\n end]\nend\n","(** Pickles implementation *)\n\n(** See documentation of the {!Mina_wire_types} library *)\nmodule Wire_types = Mina_wire_types.Pickles\n\nmodule Make_sig (A : Wire_types.Types.S) = struct\n module type S =\n Pickles_intf.S\n with type Side_loaded.Verification_key.Stable.V2.t =\n A.Side_loaded.Verification_key.V2.t\n and type ('a, 'b) Proof.t = ('a, 'b) A.Proof.t\nend\n\nmodule Make_str (_ : Wire_types.Concrete) = struct\n module Endo = Endo\n module P = Proof\n\n module type Statement_intf = Intf.Statement\n\n module type Statement_var_intf = Intf.Statement_var\n\n module type Statement_value_intf = Intf.Statement_value\n\n module Common = Common\n module Scalar_challenge = Scalar_challenge\n module SC = Scalar_challenge\n open Core_kernel\n open Async_kernel\n open Import\n open Pickles_types\n open Hlist\n open Common\n open Backend\n module Backend = Backend\n module Sponge_inputs = Sponge_inputs\n module Util = Util\n module Tick_field_sponge = Tick_field_sponge\n module Impls = Impls\n module Inductive_rule = Inductive_rule\n module Tag = Tag\n module Types_map = Types_map\n module Dirty = Dirty\n module Cache_handle = Cache_handle\n module Step_main_inputs = Step_main_inputs\n module Step_verifier = Step_verifier\n\n exception Return_digest = Compile.Return_digest\n\n let verify_promise = Verify.verify\n\n let verify max_proofs_verified statement key proofs =\n verify_promise max_proofs_verified statement key proofs\n |> Promise.to_deferred\n\n (* This file (as you can see from the mli) defines a compiler which turns an inductive\n definition of a set into an inductive SNARK system for proving using those rules.\n\n The two ingredients we use are two SNARKs.\n - A step based SNARK for a field Fp, using the group G1/Fq (whose scalar field is Fp)\n - A DLOG based SNARK for a field Fq, using the group G/Fp (whose scalar field is Fq)\n\n For convenience in this discussion, let's define\n (F_0, G_0) := (Fp, G1)\n (F_1, G_1) := (Fq, G)\n So ScalarField(G_i) = F_i and G_i / F_{1-i}.\n\n An inductive set A is defined by a sequence of inductive rules.\n An inductive rule is intuitively described by something of the form\n\n a1 ∈ A1, ..., an ∈ An\n f [ a0, ... a1 ] a\n ----------------------\n a ∈ A\n\n where f is a snarky function defined over an Impl with Field.t = Fp\n and each Ai is itself an inductive rule (possibly equal to A itself).\n\n We pursue the \"step\" then \"wrap\" approach for proof composition.\n\n The main source of complexity is that we must \"wrap\" proofs whose verifiers are\n slightly different.\n\n The main sources of complexity are twofold:\n 1. Each SNARK verifier includes group operations and scalar field operations.\n This is problematic because the group operations use the base field, which is\n not equal to the scalar field.\n\n Schematically, from the circuit point-of-view, we can say a proof is\n - a sequence of F_0 elements xs_0\n - a sequence of F_1 elelements xs_1\n and a verifier is a pair of \"snarky functions\"\n - check_0 : F_0 list -> F_1 list -> unit which uses the Impl with Field.t = F_0\n - check_1 : F_0 list -> F_1 list -> unit which uses the Impl with Field.t = F_1\n - subset_00 : 'a list -> 'a list\n - subset_01 : 'a list -> 'a list\n - subset_10 : 'a list -> 'a list\n - subset_11 : 'a list -> 'a list\n and a proof verifies if\n ( check_0 (subset_00 xs_0) (subset_01 xs_1) ;\n check_1 (subset_10 xs_0) (subset_11 xs_1) )\n\n When verifying a proof, we perform the parts of the verifier involving group operations\n and expose as public input the scalar-field elements we need to perform the final checks.\n\n In the F_0 circuit, we witness xs_0 and xs_1,\n execute `check_0 (subset_00 xs_0) (subset_01 xs_1)` and\n expose `subset_10 xs_0` and `subset_11 xs_1` as public inputs.\n\n So the \"public inputs\" contain within them an \"unfinalized proof\".\n\n Then, the next time we verify that proof within an F_1 circuit we \"finalize\" those\n unfinalized proofs by running `check_1 xs_0_subset xs_1_subset`.\n\n I didn't implement it exactly this way (although in retrospect probably I should have) but\n that's the basic idea.\n\n **The complexity this causes:**\n When you prove a rule that includes k recursive verifications, you expose k unfinalized\n proofs. So, the shape of a statement depends on how many \"predecessor statements\" it has\n or in other words, how many verifications were performed within it.\n\n Say we have an inductive set given by inductive rules R_1, ... R_n such that\n each rule R_i has k_i predecessor statements.\n\n In the \"wrap\" circuit, we must be able to verify a proof coming from any of the R_i.\n So, we must pad the statement for the proof we're wrapping to have `max_i k_i`\n unfinalized proof components.\n\n 2. The verifier for each R_i looks a little different depending on the complexity of the \"step\"\n circuit corresponding to R_i has. Namely, it is dependent on the \"domains\" H and K for this\n circuit.\n\n So, when the \"wrap\" circuit proves the statement,\n \"there exists some index i in 1,...,n and a proof P such that verifies(P)\"\n \"verifies(P)\" must also take the index \"i\", compute the correct domain sizes correspond to rule \"i\"\n and use *that* in the \"verifies\" computation.\n *)\n open Kimchi_backend\n module Proof = P\n\n module Statement_with_proof = struct\n type ('s, 'max_width, _) t =\n (* TODO: use Max local max proofs verified instead of max_width *)\n ('max_width, 'max_width) Proof.t\n end\n\n module Verification_key = struct\n include Verification_key\n\n module Id = struct\n include Cache.Wrap.Key.Verification\n\n let dummy_id = Type_equal.Id.(uid (create ~name:\"dummy\" sexp_of_opaque))\n\n let dummy : unit -> t =\n let header =\n { Snark_keys_header.header_version = Snark_keys_header.header_version\n ; kind = { type_ = \"verification key\"; identifier = \"dummy\" }\n ; constraint_constants =\n { sub_windows_per_window = 0\n ; ledger_depth = 0\n ; work_delay = 0\n ; block_window_duration_ms = 0\n ; transaction_capacity = Log_2 0\n ; pending_coinbase_depth = 0\n ; coinbase_amount = Unsigned.UInt64.of_int 0\n ; supercharged_coinbase_factor = 0\n ; account_creation_fee = Unsigned.UInt64.of_int 0\n ; fork = None\n }\n ; commits = { mina = \"\"; marlin = \"\" }\n ; length = 0\n ; commit_date = \"\"\n ; constraint_system_hash = \"\"\n ; identifying_hash = \"\"\n }\n in\n let t = lazy (dummy_id, header, Md5.digest_string \"\") in\n fun () -> Lazy.force t\n end\n\n (* TODO: Make async *)\n let load ~cache id =\n Key_cache.Sync.read cache\n (Key_cache.Sync.Disk_storable.of_binable Id.to_string\n (module Verification_key.Stable.Latest) )\n id\n |> Deferred.return\n end\n\n module type Proof_intf = Compile.Proof_intf\n\n module Prover = Compile.Prover\n\n module Side_loaded = struct\n module V = Verification_key\n\n module Verification_key = struct\n include Side_loaded_verification_key\n\n let to_input (t : t) =\n to_input ~field_of_int:Impls.Step.Field.Constant.of_int t\n\n let of_compiled tag : t =\n let d = Types_map.lookup_compiled tag.Tag.id in\n let actual_wrap_domain_size =\n Common.actual_wrap_domain_size\n ~log_2_domain_size:(Lazy.force d.wrap_vk).domain.log_size_of_group\n in\n { wrap_vk = Some (Lazy.force d.wrap_vk)\n ; wrap_index = Lazy.force d.wrap_key\n ; max_proofs_verified =\n Pickles_base.Proofs_verified.of_nat\n (Nat.Add.n d.max_proofs_verified)\n ; actual_wrap_domain_size\n }\n\n module Max_width = Width.Max\n end\n\n let in_circuit tag vk =\n Types_map.set_ephemeral tag { index = `In_circuit vk }\n\n let in_prover tag vk = Types_map.set_ephemeral tag { index = `In_prover vk }\n\n let create ~name ~max_proofs_verified ~feature_flags ~typ =\n Types_map.add_side_loaded ~name\n { max_proofs_verified\n ; public_input = typ\n ; branches = Verification_key.Max_branches.n\n ; feature_flags\n }\n\n module Proof = struct\n include Proof.Proofs_verified_max\n\n let of_proof : _ Proof.t -> t = Wrap_hack.pad_proof\n end\n\n let verify_promise (type t) ~(typ : (_, t) Impls.Step.Typ.t)\n (ts : (Verification_key.t * t * Proof.t) list) =\n let m =\n ( module struct\n type nonrec t = t\n\n let to_field_elements =\n let (Typ typ) = typ in\n fun x -> fst (typ.value_to_fields x)\n end : Intf.Statement_value\n with type t = t )\n in\n (* TODO: This should be the actual max width on a per proof basis *)\n let max_proofs_verified =\n (module Verification_key.Max_width : Nat.Intf\n with type n = Verification_key.Max_width.n )\n in\n with_return (fun { return } ->\n List.map ts ~f:(fun (vk, x, p) ->\n let vk : V.t =\n { commitments = vk.wrap_index\n ; index =\n ( match vk.wrap_vk with\n | None ->\n return\n (Promise.return\n (Or_error.errorf\n \"Pickles.verify: wrap_vk not found\" ) )\n | Some x ->\n x )\n ; data =\n (* This isn't used in verify_heterogeneous, so we can leave this dummy *)\n { constraints = 0 }\n }\n in\n Verify.Instance.T (max_proofs_verified, m, vk, x, p) )\n |> Verify.verify_heterogenous )\n\n let verify ~typ ts = verify_promise ~typ ts |> Promise.to_deferred\n\n let srs_precomputation () : unit =\n let srs = Tock.Keypair.load_urs () in\n List.iter [ 0; 1; 2 ] ~f:(fun i ->\n Kimchi_bindings.Protocol.SRS.Fq.add_lagrange_basis srs\n (Domain.log2_size (Common.wrap_domains ~proofs_verified:i).h) )\n end\n\n let compile_with_wrap_main_override_promise =\n Compile.compile_with_wrap_main_override_promise\n\n let compile_promise ?self ?cache ?disk_keys ?return_early_digest_exception\n ?override_wrap_domain ~public_input ~auxiliary_typ ~branches\n ~max_proofs_verified ~name ~constraint_constants ~choices () =\n compile_with_wrap_main_override_promise ?self ?cache ?disk_keys\n ?return_early_digest_exception ?override_wrap_domain ~public_input\n ~auxiliary_typ ~branches ~max_proofs_verified ~name ~constraint_constants\n ~choices ()\n\n let compile ?self ?cache ?disk_keys ?override_wrap_domain ~public_input\n ~auxiliary_typ ~branches ~max_proofs_verified ~name ~constraint_constants\n ~choices () =\n let self, cache_handle, proof_module, provers =\n compile_promise ?self ?cache ?disk_keys ?override_wrap_domain\n ~public_input ~auxiliary_typ ~branches ~max_proofs_verified ~name\n ~constraint_constants ~choices ()\n in\n let rec adjust_provers :\n type a1 a2 a3 s1 s2_inner.\n (a1, a2, a3, s1, s2_inner Promise.t) H3_2.T(Prover).t\n -> (a1, a2, a3, s1, s2_inner Deferred.t) H3_2.T(Prover).t = function\n | [] ->\n []\n | prover :: tl ->\n (fun ?handler public_input ->\n Promise.to_deferred (prover ?handler public_input) )\n :: adjust_provers tl\n in\n (self, cache_handle, proof_module, adjust_provers provers)\n\n module Provers = H3_2.T (Prover)\n module Proof0 = Proof\n\n let%test_module \"test no side-loaded\" =\n ( module struct\n let () = Tock.Keypair.set_urs_info []\n\n let () = Tick.Keypair.set_urs_info []\n\n let () = Backtrace.elide := false\n\n (*\n let%test_unit \"test deserialization and verification for side-loaded keys\" =\n Side_loaded.srs_precomputation () ;\n let pi =\n match\n \"((statement((proof_state((deferred_values((plonk((alpha((inner(528cdbf16708a53a 1f90a7eea2e06f6a))))(beta(617e5a7fd6be366a de197122a4415175))(gamma(3ca35d4452181c99 10f08540ba61b0ec))(zeta((inner(9b9cb3eb89f99860 fc3f2a556b3da3b8))))))(combined_inner_product(Shifted_value 0x0823E56793B5592614ADBA4D0E5FE7182C36059EFA67B62FF348C298025ED3B1))(b(Shifted_value 0x15E6E583088F3839A0A24BA096058D311F80E63DC7C5F96961EDF0E8431B3A89))(xi((inner(5c78b5106dc9196b dd923608f3a2d7c7))))(bulletproof_challenges(((prechallenge((inner(0277f6aad9d835a5 d7ce644af1e0a623)))))((prechallenge((inner(7155c8ca270890a9 88210ef505d7463a)))))((prechallenge((inner(66dd09cf8c767ca8 49a1f3f0d02c27d1)))))((prechallenge((inner(b3af5b7fff77d3dd 7e3d53b2d699d210)))))((prechallenge((inner(1a7034722f39c680 dac0b920710a3baf)))))((prechallenge((inner(31a391963a1eda22 1768f963fda30dbd)))))((prechallenge((inner(ca6977bc2cd08f02 8cca080a3eea91de)))))((prechallenge((inner(ca1c4459c6db90e0 5dc97444224692b8)))))((prechallenge((inner(5a8691fe938d7766 ffa7b76d50545300)))))((prechallenge((inner(e28a6bd7885e2dce cffc710fd023fcf2)))))((prechallenge((inner(67c9cacdbec10152 dbbbb17446514cdc)))))((prechallenge((inner(b962690d4c6147fe 047ed2b6432ae9a8)))))((prechallenge((inner(247a3c026fd42a1f 30ffd3eb2e92f6e0)))))((prechallenge((inner(fb040a5f7ae1682a 67e88c03b46429fb)))))((prechallenge((inner(da7aaeb99142d490 e6df1ef2a27bd5dd)))))((prechallenge((inner(c9590ba2d65e774c 6513be976dbbd014)))))))(branch_data((proofs_verified N0)(domain_log2"\n")))))(sponge_digest_before_evaluations(345bca89a18be6eb 32b32bea9853ce51 e4b78bd09bbb68a5 0c6791fb08e0ca57))(me_only((challenge_polynomial_commitment(0x0F69B65A5855F3A398D0DFD0C131B9612C9F2061D2F06E676F612C48D827E1E6 0x0CCAF3F03F9D2C3C3D44E09A12106911FA699DF934F706E62131BAD639F30155))(old_bulletproof_challenges((((prechallenge((inner(3382b3c9ace6bf6f 79974358f9761863)))))((prechallenge((inner(dd3a2b06e9888797 dd7ae6402944a1c7)))))((prechallenge((inner(c6e8e530f49c9fcb 07ddbb65cda09cdd)))))((prechallenge((inner(532c59a287691a13 a921bcb02a656f7b)))))((prechallenge((inner(e29c77b18f10078b f85c5f00df6b0cee)))))((prechallenge((inner(1dbda72d07b09c87 4d1b97e2e95f26a0)))))((prechallenge((inner(9c75747c56805f11 a1fe6369facef1e8)))))((prechallenge((inner(5c2b8adfdbe9604d 5a8c718cf210f79b)))))((prechallenge((inner(22c0b35c51e06b48 a6888b7340a96ded)))))((prechallenge((inner(9007d7b55e76646e c1c68b39db4e8e12)))))((prechallenge((inner(4445e35e373f2bc9 9d40c715fc8ccde5)))))((prechallenge((inner(429882844bbcaa4e 97a927d7d0afb7bc)))))((prechallenge((inner(99ca3d5bfffd6e77 efe66a55155c4294)))))((prechallenge((inner(4b7db27121979954 951fa2e06193c840)))))((prechallenge((inner(2cd1ccbeb20747b3 5bd1de3cf264021d))))))(((prechallenge((inner(3382b3c9ace6bf6f 79974358f9761863)))))((prechallenge((inner(dd3a2b06e9888797 dd7ae6402944a1c7)))))((prechallenge((inner(c6e8e530f49c9fcb 07ddbb65cda09cdd)))))((prechallenge((inner(532c59a287691a13 a921bcb02a656f7b)))))((prechallenge((inner(e29c77b18f10078b f85c5f00df6b0cee)))))((prechallenge((inner(1dbda72d07b09c87 4d1b97e2e95f26a0)))))((prechallenge((inner(9c75747c56805f11 a1fe6369facef1e8)))))((prechallenge((inner(5c2b8adfdbe9604d 5a8c718cf210f79b)))))((prechallenge((inner(22c0b35c51e06b48 a6888b7340a96ded)))))((prechallenge((inner(9007d7b55e76646e c1c68b39db4e8e12)))))((prechallenge((inner(4445e35e373f2bc9 9d40c715fc8ccde5)))))((prechallenge((inner(429882844bbcaa4e 97a927d7d0afb7bc)))))((prechallenge((inner(99ca3d5bfffd6e77 efe66a55155c4294)))))((prechallenge((inner(4b7db27121979954 951fa2e06193c840)))))((prechallenge((inner(2cd1ccbeb20747b3 5bd1de3cf264021d))))))))))))(pass_through((app_state())(challenge_polynomial_commitments())(old_bulletproof_challenges())))))(prev_evals((evals(((public_input 0x1D5050ABC193FD8288FE8B09DA9A2AA8C4A95E796C33DFB712E8CCAD7367266A)(evals((w((0x2C33C173BDE9340BE941ECD209AB6E99ECA8BDCA1CA8BDA8DAC3E40C3315F696)(0x02AE92968344D1F59603BA015C29D7801897F6B59E5ED43A3BEE316D6A876C3B)(0x3D4FDD240284F096B0D9CE405C2016E7CAE49931D0571F27DA7A3DDB202FC437)(0x1D8A9A17ABDFF5975832B2EA4AEB94BADE6346A554EB24A51B3ECFF560D33748)(0x36F806F043D8F33F7FD89730FB69E5DAF323E8637D23D95694665AB1B29AD194)(0x21CE677E9416783DBA7310E2813D200104A0328DCA5CF2C0E632BFD719951CBD)(0x0A3464D5ABBDF1C1FA6C3CF5C5328CBED7D1402AD4990AF2D07CF6958700E079)(0x3067923AF93C85BC677715F78EFEE2B765F4712D92A18DD691B2D617245D2837)(0x1D75E1CCE4165FD19BBF1D834F0366E3330A916F252801ACC2A9FCCFE19BB03F)(0x29793C3D311353444C4FCF2BF62299893F69FCEF0ADF7345310DB7E736C21758)(0x3F90E2448CAB2639788EEF0EDBD4F87463082EAE0C52F710E0A57B4238577C09)(0x3E19E9E45C6CFCF0F7036D3A598E26BC4C250AB45049E19A81EF3F9C68E7B09E)(0x31CF2FC45C59E45E5B16A9FA357972AEF1F744388C81C886B28BDBC55815CE45)(0x24B310A418CB5815513DCC5B4DBF4B2C64BD94A2D4764294EEBDF4C7DE1B1B08)(0x3E748B8BF7F3F63235B650DB873BD652BC58DB1C67C94AF03B218DB58CA0EA86)))(z(0x3FA6741D84E11434D7918A459AD1B698B8F3616E2A901B3B17E9E0BA8C229A95))(s((0x2160285A788031C45B0E041C0C3E1322E1330C718B709999E677E4C82C1A8DEC)(0x2CC1EE1154F527B33A011A5F816AFC3C219892D0CC3A25501A90183A2221B847)(0x299366D7BDB50CD278BDB43FFCC1AF66CFD6C821203F980AC22A9E0178612FCC)(0x04204759E7D8E84C1122BCF65008ABAC017DE7DAE44B7E479D30773966EB6B0A)(0x08D5ABDB38CEEA6D50FC378FCCEA65116C298EE0307D827FF67447502C5C5A23)(0x0AB1B1605C07FB055414308FD9D3872D1184AC436BF62BE06BF68A429EB806C8)))(generic_selector(0x2073E57ECA097CDB4349F56A96DD870EF4232F547624BFDD7AFFDF8407826000))(poseidon_selector(0x1412641F378B7B4AA2DF1B29573E3BBA2E092E74D48CC8CA03BFBD88755F5DD5)))))((public_input 0x0EFC0CC4E8604CB4B337B237BB46916110F5604041669E38EB1712C78A86539D)(evals((w((0x30C812455D840F09B1A10D73E607F1CD23F0977E205946DD7252149C3C8EB2EB)(0x0301082FC85A85A5C5E48483CB231F64BE4E42ADB7AB73B973034F92C2008243)(0x1AC263C293B548E7862234481865A6C4255180F33D5FCB1E30360DC5AA4A8164)(0x2679B03901AA2A286DF1E2A90BC72A3AF57C13DD65B9BB11104DB9189ADBB970)(0x39F0CFE5133D4CC3B598F1F6EA16004661DF7BA6D1316C38E124C65EF4F21C95)(0x16457DFD6BF323BE13162779EB0F48CAD3AD8D4970E9E6433F275B2226CF99D9)(0x2AF436FE0FAF0CB905DD8202DDC42C09D1565CE415FD44F33178D94B1BF76127)(0x26A914F7D55AC312918D41FDA516342E929034C06D1970794C1156FF8690B0E6)(0x0BDDDB276B9CDF4B2C9B4C6B43F2F302D46E2A0104724D7779B714CC1C13D10C)(0x057C045F4DA7202317E4A47952BEF19D109475749FC8BF0ED9244FD6BDB20CC3)(0x3AD9805BE86345B3FE98367D2ADAAAF6A3B2A511B7011D354CC074BB0F0B618C)(0x0864BB2DF60F29BEBC8D55DEC2B6F199DF53CB650BD797D8C81AA7D39F7A494C)(0x375F21536B66E816DCFCE829495A7B429CA1EB658123DE8858B765DB26D1DC68)(0x34D1B59A33369350867EE0E538C68D693E19BD5F8F05FBDE52828A6AE39666CA)(0x381AD285334A7884690F3AB8412291FCB0D3357169C0F176D2A6DB8D2B3FC02B)))(z(0x2FB41536E4655C119BE5F0DED90391A8171C191B3A9764F765FBB6EBF2AABAC9))(s((0x3F5522A1D8A0ABFA8876B4185E9CA1F885663F55579C39F7352F981CB304CCEF)(0x2E0700D6F8A02C04B1DFE630896B59615F21C4B3B541E26EE63DBCFDFE59D658)(0x10F7327C833EB35B4499AD4A1EF0BCB66861822381DEB0CC6799E7182892BD26)(0x29AB8F4C7E256D2D7703E368F9101BED0215E08CEC87AA5499CFA7D1E9E11657)(0x16523DDF438ACF2C072DC7F00C41F1E3A5214761C77D2533970A9382B5B48D30)(0x0D684A460B348082F5EFB03F7A635B5358E52235821D36251D67644CE694ABC4)))(generic_selector(0x2B204B8595299D22CC83DE6E2A78D4AF39AAE8527FB4B297A35051F376AE10C6))(poseidon_selector(0x370C7DAC58DB1DAB1147DAA8BBF7EE1F1E2C2EAB64BEED885CA14FC86D786459)))))))(ft_eval1 0x0459DE9EA74B8CB38B54454FA0F59D375307B1210F7403526153D5CC1288DE63)))(proof((messages((w_comm(((0x3E2CF8FDB7F25CC3D523E88735CC8B0068A436A107D926977B4408955AFB5A7D 0x32CEE955EC5BFCF269A050C50C9ED868664F26AEDB4FCC96A2EB22C4E9031ACC))((0x2029F54CE3FE1255005DC6E0D56F45ED46D9294A2021AD7C4D9ECB9A2FC35DDC 0x20098E9EB437414F861C8BB5FDF3111EB3C6707DC156FFEE3F3B712FB67F4A2E))((0x1110AE3F05A3DF2FE4149EB7125B7CF315D01D6BFBDC4E1EBEA05ADD633470FD 0x30BAEF091C165B8FCFAFAA96C0FB9EB59A6FD98176897423043623AFB8DCB084))((0x3395D2993CCBB9C0A22BE321D70F5F01F39B83D78D7D3684DE7EFEF71C9EED94 0x3A99A078DA706F3C43B6C081DE5A09A69D2D308BA50B961CAC6A664E3D4E8E3E))((0x258C56FA32B555BFC3288F6EEAA11344E4430C51F3ED6A59F35F749F9FAF084E 0x1D47AC341EF7AA76F15F0239A494A541E018C113ACD62E87FAA7764E23251944))((0x2C04311B81ED29240DE9DA622C894323236DD623846E83C08309D1C552B06503 0x2438036EE7EF2EAEB9216A843692A2FA45F8B595107D9EA6C05523C8274DCDFE))((0x19C1DE13982583A22FAD04553082499C88055C0D707C09DC77650EBC14718F6C 0x2611B1FC721B8B73B109886E5A2960ABBC5A471472F2DE27F0B70989B0E640BF))((0x136550315A4440E22DB32906E3C7C955B96C735E4058F1AFF8BDCF75BE2324C8 0x34AB87A590CB4B9674F28A75F6CF92757E84E1649F32CABCBE0B76AED1A60E8D))((0x2EE8D5BEA4D460321B9BD1B58BD5F9EF76DF3D0DEBB015190D317C61C73584AC 0x3D330403E54BD189C55448170D59D6F9D3EF48C8095281F45588B92B6107535F))((0x370E23375707B4E74486415A153CB1F0111C2B950C87178FA85891CCAB0D3D8A 0x0E75C598E63688217BEFBB5DCA020433CE158D4F8070C63982275F8261A3CE95))((0x2EFA160350CC4282EE06AF463EC8CA6980AF07983A42B6275E42FC4AA6E685C8 0x0EECA9EDB51265182CBEC10EF3B0AAF81EFB53E9B919940194C2726B9A785D1C))((0x27FE69FF4A716E2DF1389CFCD4C425B050C00931CDD123C0C5BEA7DFFDD3D603 0x122E05931206355AAB60DBAE077D490887DD1CAA599BAC05458BC3F41428CBB6))((0x3663E1C1C27C6F163AB552E83B21FDDC5EBAA3B735EFFFE38BAE99B01D71D037 0x2C46C91336CE381F3900BD2A80C2B36A6BC90C5D53A579E02240BBABB2018E60))((0x26667E23A0085FDDA970D4CDC78D6A4D9C9F003061F40F5AE8F81986C0D6D260 0x2B05A9F120DAAA355F54E8D0B96A78A674898FB1830A4EB71356137C8984BDA5))((0x105D2491EEAE03D1AA4AD8908412F3ED0B988A43C4F33C81581C3A60FEE9721F 0x2DBAAD56BFA1DCDDE5CFE40480C8E8E57E0093FEB153D9D4F983407B3EA91412))))(z_comm((0x029EE7F64D3FFF1F6920D6F009304C2C8F9ABF2B769ACD69F7F78201A09F10BB 0x301449483BF3A688552192934E10391D7BE97E54BEB26F7A3F3B1A2443CA07EC)))(t_comm((0x27ED056E28864693AB1653F62ADF5C6F47DCCD070EF16A2E911283224015921E 0x1077284DD15F99143EFACBA85D3DD63608F222CD6D7CF7A793DFC64390B7DBD8)(0x07A10F95A4F55597F66C3C92BBF9D69A23C6EE86CE2C864FC0A35FB199980B89 0x2BC564EC06B8B7052F469C3EC74ADD32C1C713EFA19F26102E7C73520F90ED2C)(0x3F30E96C3D5A23170F94895565422C6D54B8C8594D154CB495BD808941848C21 0x17F853D3C5869042C600C71720610A21DD057D689A34CF08E6A7054B1BDDD70C)(0x0C27FA8D2829BCBDD90E245677394DF7151F7C4E94D95832962D7187FEB33432 0x0442C73BC7C37791DA9CE0BE6332F69166EF6E6F651E23D859207B1FADF9E1A9)(0x039B920067F59B3458F8CFA660BC585B705826906B88893B88CADE19930604C4 0x33AAA622113A14BB1408538B38CA5157BCC835546BC081BA2D39E5A636F7854B)(0x0E76AEE47485073ADB66E8827B7F11C99B74F5D360AF12C326DEBFF457ABB298 0x15D7F59BD6BD0E49B36BAE1A8E17073FAD3442B8268D50D327E87CD4374C9E2E)(0x24B17C42758CD977DA31A5D619D0B0CC885A074F13DF1B0D9036A5BE962FAA66 0x33ABF75964D4318F21AA7F3C889EA88C495E1322B29C81646C90190626AF93A0)))))(openings((proof((lr(((0x018E82B85F43380E32CEDAD571886DCDB651FD16C54AFACC8A5F0FCA1A35D77A 0x07558C8DE9362826F52ED1FC9F3FAC3E60BE6BF9A693F1A960CB2F54BF9AD308)(0x2DD34ADF732340CE166A3989C2863E00AA20EE8DD3681A6FC47948DDC2291919 0x39EFB3592924CF49F45D5B471ACD66BD6A9D72C7F034EC75703740737E068FF9))((0x05DD7845B0D19212ACDF666DD90F309999BF28719B2A1F70B228AF5D3E59A633 0x207799AB420155C6FFECDB3538B0EF2259EEF776A33A781AC4F3EF6BCEE60700)(0x3AAFC4E24A25D2AFF714F0008F2465496C62EB6C1F7562E605C38EC59DBDBC67 0x378F5BACCE5C4BD6FEF8630F68C439F8FE986F218A562B1EC054E07FC5824B59))((0x38E608E6C866AD1C61BC6F250A0AD7761B71C6E5E0F7A065F01B7B2F4F485D18 0x2F1CFCEE96584F592CDE05B0B3F936A8D1FB603A2984EECB1DB042BA6D81A6D9)(0x07AD6181A8E32C3898B06BF092E28D1C8E928293125609033979AEDDB9116BCE 0x35287F7AA2300ECA1CC58AE8141AB97411E00F61C65F5B1A98A58EF5918C363B))((0x3461FACE1BEB85F605E72FAF9A3C804CC3BF82FC2094583528F0C7EBA74DFB48 0x2212015E8CA2965FE0E8A4A06838CEDDED1EA531A139F5CFD1588DB5736381C3)(0x0DE143977BA8B3FC93D25434EEDA4921E8BDE5AD59E1181E6B456B4309057F08 0x24B094D4AC456EC3F55D46830F4E82BF07312A1FAA97D9138BF41F16F7E23A9A))((0x21E5645330DC73F6F6819176F8E90A0827117664A93B4D96E19DE8B2819689F2 0x1AC631D608FDEB1EEFFB6C18A720E40CF1408B0BE266A62BE8B7D0B46DAF0FD3)(0x00D73BE9C319319E4C12A8F9610C476D16F0878F032DE6D6664E77DAAA446387 0x12814F8638826EA6099E0691770FFE50F817CFB3C45C1F065EB0F85D6EE7BA8B))((0x27D05D5CE92F8375D15C7E28A4F6A02E1C240BBA18978329DCA072436CDB3B7B 0x1C994843BE3797E9A6F2AC6FCCAB1C9B1745E819143F2918A383D3D336C5846C)(0x1D8ABC594EDE311A74A3CEE7DE36E4065851C0ED03A4148F1A13AF8A4E1CE8B2 0x2C3207B67EE005C7FC5B1C072E980ADF9695F015AE26BF16AE32E83C06FCC611))((0x135DC0F98465E36AEFC4AFAF082F4594434B4A4374309CBD334750983A7811A4 0x11057C0DF6BD2CC7A505A6B39969070656CB39E4EC479DCFE42E01E70BA39114)(0x1E254D9B7E6BEDFE142264E1B93B1CA92B943264E48C8E276AABBC063E79C02B 0x2A617229F4D194F3BE3D15D38B777EA4ABBA28F3641B269F7A251FBFC511B25A))((0x1E9E3FA46A50EC7A42F370E9A429C21984FCF730FAAC8913EC6E50B9DBA0390C 0x19A7CD7A84C3E998ABFCAB1D1AB8DF1E9F57D5878ECB12636A8C0D008E466934)(0x3F2C2B737CD73658ACE3CC9242DD9A52E39836B138BCDB71658B1052C7FE9C83 0x218E8EAB1F657EFEF1A281FE61A6B1CDD93033130FC664403EB1610AE20EFB3B))((0x063E8B50A90E7AFAA45B4AE2BB4F48537F14CFE82BEF31A110093999F0AB5333 0x10281C8C0E0174FA2121F435F35D9E8050637AA3F58E2A342DEB9C91798C47AC)(0x0D43AB0853C6C202A2CE3C39E9D1CDA61449A8A16A91012FFE58AFCBF675D3D6 0x3B5DADAAAE57CF6FB972C521FED1AC03B960851C0D44B6122EBB72A2258A4604))((0x18AE3885AC8AF0E6BD9C0E7785D83477ED6F5FE8A239AE2526141931D81EAB56 0x29FBB084D8FBE703D008E9CD70B702B3113B49F859C2A19B4406AD130D3731A2)(0x04AF99E720254B22E8DF368AE6FC273AC75A4639A6F3007369FD405532964CBE 0x124525E37EC615B1F57D54002836E35380548276C61D6B2539EA51C9015EED9C))((0x32A4ECA72864EEFFCF2D83B843B9BE4ADBCD45B972624811C894F916E4C81A30 0x3E6F57AB9CF53618664A7AD9862F65BF164EFFB42B7497B64A8844339318C365)(0x2F7EECC63F3EDF519A83E20D64E88213179264F93A2438A22A16335EB2853E6A 0x1D03C4087516EE01C13982505997CF5E13A8E4C228B4346DEFDCB1101E656494))((0x394C3F476F8DFAE68E5B4610E73239F7ACD8C5AE12E6F094B2D199D39308D87D 0x1A38D41C68C7BD3C6176D24F774641136D6C929811D86AE72E54598BB7DB27F4)(0x160CB44B2FAF93B0375D40E77D560091F066C8616B692FF842F90B6FEBC9BAB2 0x16C4E5ADA6534B5EA0406918AD2D64BC414EAFFBC723F27B359C524FF5FCE39C))((0x3FB19114E947FFDC540FB4284835CB74279DAB1CF3154F0874B0A0A5E63A3EEB 0x3D65D5B172CEF8D31F34A49AB0889F7A10A2238846B6B24569D68AA791F94CB6)(0x0F02699D800DB868A06E3EE4A0C158C90BC48A691E81744FFBCFDA32FF24DCF4 0x2714671243FD8237D339E0AC2C941EE9A642FDF6FCBBE031B42696FD69E831AB))((0x0521F6B05212DC975AF0007CD24D328B2ECED1C82791D2E606059B65BCBE554E 0x36BE6DAC4B773494121F7DD5F8507D36AE6ACC1DC99FA860DED1CA7AE8A3ED01)(0x38B51B590BF50CC6A24AB80474EB147A30C4AF3DD19A5654C1B105559BD14D4D 0x3E11DE8B1B4638FBD8C4D6836A747C0A81578A4D22B84AC58EC061FEB68B3177))((0x2D5328E0BA58995C7066774A463F8A902D7C2B97BD45C10B9D8B4D823DF106AC 0x26933A9C217727C9CDC4A4494D3E332B36BB997396FCA706099FFD3439BB4836)(0x0BB116BA807D12D4DF79557FFB7F60B48858601912530E3F49C890A34AED31CB 0x2462E0396ED302DD10A6EF43AE532333543F4A875599E83FBE4106644DDD3F8E))))(z_1 0x06A616C3A625F92ED65B5CA99D9A1DAAA476481B9C45E4553E7A8E436B13D570)(z_2 0x310AE40CBCE21FA0DC92D1DFE7DF49D939A579FF029F869118036BF8B370438C)(delta(0x366414F4FE9C3DDB27DA5A85452CEDBC65AFD104D1F5C241BE2E594F615ABBBC 0x0B4190D59EEA6EBF8B9316054439E92B5BFDC8CD9BB0C864783D5F1D785DF87E))(challenge_polynomial_commitment(0x1340C10B30AD07F4913C3CDD588C3E8A5A6E6DAC9947378FA97D11F52CCD4AE1 0x0B110AAD2D1957C9C6944439DED80C9CE9A0EAD35C96903AC1EADBC94AEB5D29))))(evals(((w((0x1BF1CE494D243FEF9253CB66CC3D6300A37ED4A230C154451779FA16F6AAEDD7)(0x2A9AB4178F95EAE6A3D608276A4BCD390A88DAF8C35196061ED79DADB747CA62)(0x2F272FD8DF352C035E81FC1A5C8664AABEF4F62962B7E3D03F6BF53C10C2B398)(0x0967B0F7F74E6558AB86D813EAB8490C43C569BAB9E72761C8D4086810A621B2)(0x3BE58E7E3C8DFFE8317E68E50729FFBD6E22E3FE43F3FD0C469F46768068550B)(0x2417CB5380DAD79780D62428CC09175FBE2DBC443E0767157589A7D581458D33)(0x206FA1779C5057CD0639666D2581A170B83CE654C654544C73F7DFD022FF1597)(0x3EC85737838ED8C4CB90D54523231C950FC641DAA8390AC6612995ADBBFC2947)(0x1A24C3397D2F39F1DFEECCCB66C78BE61279D5C22AD692C23DD5268133793F38)(0x1813C59133F4204F15554D891F94D802D26E2F18343D513E164706636CD7D6E4)(0x0534DF67954B7AAA90DBDFA81468B83F4182B927D5B418E531795998B9825BE3)(0x0F7FC2CEA19984972EE5732743ACDA4C6C406F03A852555019F213E43326B61A)(0x367ADA537033A054A65F0E145E6E79B56F054EEB8011F1EEE163E137D6366B89)(0x1B3232DFA316997F453D7A6F2005E6E096B54B3847F6FE8D581165887F85FD71)(0x0EDC1BCD8B78233F2C5E236D6D05265A586587AB0B1C0F5EE3A26E3EC45C8559)))(z(0x2D46727CABD1AD20E476E7ED8D664640D0565D3F01CBBF7C6258E2F436E0FB64))(s((0x16C1D17F88C267C43D4DFD19768583A2E9AB7AEC6975B09F139DF1AB5C41C815)(0x250EA67AD22E2661208B05E72B1054F60798FD58DDFE3333FAA9B5AB547C6745)(0x258A8C918280C265F825EB72C0B8C625665C2FAF60697D588EC6AACAC73D0B86)(0x072EFAAFC967EFE45BFF2EEC1A8CBF8A0B2CC1F44B25296DA33F73B3E48862D2)(0x3A23A8AA2A3D0DC85299DE4975C8485473C9C1D0D0D84A0BECFFD31351A6071D)(0x0DBC51C9DF923ACB44274742095761E599ED1D8F94EF8F414C151DCC5223A13F)))(generic_selector(0x1AB9C88B53C9CFD0A65823311711ABF1E13E5B352DC2D35C6D34A4508EF42C1D))(poseidon_selector(0x0D4DB96949873B90F365BCBC73B2A1AAE695533742F6472E050D024C47EF051F)))((w((0x044E2486D22B5737733C4933944865079C1D24CB1B62D5A5D99FB4A84D1A7806)(0x2B7D6F8FCA7A01770626488AD8540BDBAD1337C627CD8A9E63212A2A05831410)(0x2D92673EBC67FB88DC3053F021AA44F5ECC10FE56E9D8169EB28B63C86AE5766)(0x11BD17917D68A2E68F4E16998A89F15F53BCEE8524042E87316A917BE118B573)(0x1978EF73627746A050DFFFB981ACCAFDE1ED51690921994DBCEE69E44892C07A)(0x20B24CDDD02F9E3E3864B905A0E34C1910914A3990497208B44D9B7D2F9C04D8)(0x074347DE39DBB739163EC16F4AC610BAFE9328C7677A59ADB0E4949BEA72139F)(0x29F334283A097BEF545ED4BD25FE90538565AFB1ECCFBF12BB636F536950AAE5)(0x1D956F27A2C2B32F5108F9261BF08336CABF3F43A34D76549747C589AB268E26)(0x0F67F822B5005129FDDFA19806B63E2F9293651319E024F470A4E3C093C953FA)(0x07FE17373605026D0611EA8C56D5A5E012737A651B9DB4F2B6D3643E66AE8055)(0x050CA2177E768D190DB1B8EF36BFC9295796447C0F00F1C30D4EAD2C4CCF2576)(0x008B132B8DD971E8BD710E2176BA1A1486E982682603D7C99354FFDDD42ED0DF)(0x386E04A8455ACB87D0E73727740ECD7FD21607BBE70CE413AAA2ED5293FA203B)(0x29225BD92F00CC712E9F3FFCA7660592B80987BE8B35DDFF83194F0799DC3B44)))(z(0x2345A1A7FB004FF4B933E47E914BC762D3321AC74A1EB807F22F75F716A29745))(s((0x384F9DCC50FFCCCD17FE53094FDD6C6E3A189937EF2202055A9E84207D1F990F)(0x3E3C73F348C36B61D52D5DDFF36D766357B58A914875549471351BEAB35952CB)(0x193A462B9731E73C8622E658BAD0DB5A932213978DB3925DBB5ACF07F8AB2B4C)(0x2B6E71A35F8A6C161A22D6CA45CA5766378890C30EA61AF0A179CB6B5496E177)(0x03A7BF41CF46215871DC385F1C4AB03A8C3DD67EC3F789E425BAEC8ED2B4A65F)(0x23C3758C52FE243A5E63FD6AEC2218CC2A001A6F655F2E44F1A13E391FFA4BB8)))(generic_selector(0x2CC43F0A9D98CBE8E5B6FC354E9B090B910754181165DBE475E88A0A02F5A786))(poseidon_selector(0x22A81C50CBBE608CB6F8A807471424EB0A5167B392446F32E192E33EFDBFCE75)))))(ft_eval1 0x34AD5FA8AD38D9FB83534F851F0924BA3B9B43E1C45703F151A19BCCE71F4E7D))))))\"\n |> Side_loaded.Proof.of_base64\n with\n | Error e ->\n failwith e\n | Ok pi ->\n pi\n in\n let statement =\n let transaction =\n Backend.Tick.Field.t_of_sexp\n (Atom\n \"0x2340A5795E22C7C923991D225400D0052B3A995C35BCCDC612E6205287419EC1\"\n )\n in\n let at_account_update =\n Backend.Tick.Field.t_of_sexp\n (Atom\n \"0x2340A5795E22C7C923991D225400D0052B3A995C35BCCDC612E6205287419EC1\"\n )\n in\n [| transaction; at_account_update |]\n in\n let vk =\n Side_loaded.Verification_key.of_base58_check_exn\n \"VVA53aPgmCXemUiPjxo1dhgdNUSWbJarTh9Xhaki6b1AjVE31nk6wnSKcPa6JSJ8KDTDMryCozStCeisLTXLoYxBo3fjFhgPJn25EnuJMggPrVocSW3SfQBY7dgpPqQVccsqSPcFGJptarG6dRrLcx65M4SqudGDWbzpKd2oLyeTVifRTREq2BibC3rWMpUDuLwXEnp61FfFaktb4WKu3hfHyYBt5vL3Xndi9kynUWuhznijLG2yP7eX7o5M3nbjfkg7NdWaGReZH1yt4ewtrmHEMF5qTdK2UPgNzpScaK7ix8wZV5qECT483DsuY6Wpx3s2FfdmRDYwdr2YejhW4ZnJLNAxMgUkV3xkid5esqnk5TuQrdHMYvLZXju3RrZrvqhmbTFXpANKskZnuH1BUvkeoPvpQeYdoeYDJ6bgM6NFB3oWsPTU3vSMg3Wjsqx6Ekc8MuZHuaziGax9WNxbM3H6HscZFRs4npttEiwj1gSvZNaVc9FfRdCa3CMMWJNR1CkA1zKtCb8Sie1yiHc89hDA7K5mufV1yaX88xmAQrhZpTLCE8Ch62Zp3P1Vy6QVDACZCKSiz3bhikYEXFKZaJfRYVZVPeEBgjnUDrB4SD61KKnvWWESV8a3uGudeBLnJqoPJuBC8bZTUfskxqzkXmz2XTv4HMARJRTg21tFB8mZmLgVuaSWpc6inGxTZeWmE9ECSFzHuazEPNQ6yn1xo7G72ixrmLZrZqhbhPfnqSL5SWnmFWaWTihNNdHac8FDwb8JKvneC5yUur3WAZ8tTULiiNVvQhjhKVUrym2wTWFwhDAy6GqZcYeWRig9gpgdaxEuA7YnDc8XZZ5JS643PBfAWZZ3mZR4NxXPnVfn1xAUD2VFXmA8pzkqRwQ8DSpSPpKuwzwuJQUW6QSGtBheKFSxrXt6qekFX2azueedJZrhnwPW78dM7v3Qd2zTWo8iD2wfBB1Yot8BfUqAk7FYyi9hajKT1qZWQMg3kUVBywX93KBht2RFDJeVwiuE2hHaAzobxnnwsPJKPHaU8SM1EXQ4cFP2zJ2acPig52MNht3Z34fMeZ65bA3eEbcDbJw3pk2YS1pHtEr818b5TisPu6gshwkRGghbnTsQzHCjZVf61rpT4WphBsv6ob6foLwdc5ZSxq2BFzAWUv5j5nrtU9fqnQCx1DooZxAc8BnjxCXQ5TnE4Rpj82JwUR59QFNza2RwK2vZLvrNPt1LK5eCkZV8fBWuYD9J4AnxGA8icQbWBAfsSk9xXJBynEKymAsw6eTFPWCAMjQgJLhJP8MJR3NyNbqMfT1nR924EyZged7US9ogU8CLV5GcMBTSzAyCSFwFN8LGL1uT9sStzwQNbUvKvXYRwWNMYpb7Mxcjz1NjBaMbiWUryMcJc3D19yXt8VNt5g3L3Ty4GtL3WWV2aXRRXcuzYZai6wV8ESPGd3R6o4NJS5Ct5Z98fx25sNtswb77Q18pU379m4wsk8ck872oMZTPp9bDHTVpLoEBHd1gkC6j7pP8dx3cNTWc1NoewCGLi6zLDNfPZDrRXZESnaDRgVGEDinXS5SeAihMcQxvriHyskPW4SidcZsZtPvLnoQz7HQRpDnXfg4j6b8P5EX6sSJbkU9is3k6e8puQirFzLLgh2uC4oZH8EzLRZcGkonQPP5sLTmfwX4s5DJYdS4NLAVYSXndVZ4fazLfqPLukdWQkxZihUq4NtFkfzpNB8MPUBe6T72zhnvqVPegeEhgVvUokcn2DRJUc93DSYSGEJ3eZNFTruCgbM7xMXq83K6eraFRvxGqAgsQcTcQKwEfF9XvuppFDBbEHjdg84w1XiRkZ7xPKDdF6Hvi5G8V6rr6q1T7qypKiFqNrwM6frbJqgjedLpAY6RkPchip2WsZTpEX3EY1ryyGnJxZvb2fjCooQ9u1R6zNArVCV383KNJQZAaWFgzd58F7ZJ1fGU8zeFzDuhqSwqPyDE299sVYMSfbvp7xjWygxrbjApRE2FkjQtjuxaiXzsuemvrrSedVCGrktCHNqPKkJxbLcpz97rRBvwnKSd26x8LKHn2Zjzp2qeyxsY8HN7WVPATxPE4xXqi9dw41o8LBQ3GDGe1ASjphdp4bxj1guHhSZbMKTJDj7hJKyuvBMdG1YKQo3uv2qu5MiB3Afu5SZbZStNKBnxc2DRoDyF45yrQNeoBJogcSLAqWG624ZAdU4BWrqRJNjoAu6GxxE6E8TvFtvyDW1R9Nv7tXzmWE7RarrAL9YUD6uqe7gAanAv1cdAJRcPcdr2YvUL7zeB5d1daPfwJW4PYDvMwnnqDFSXgNqPreh8nFaiReDYjiHkwCojPcCgdcK5gJwpQTasjkWQBk2RmFQdfaLCpiPZGroZ6hTvRBHq2MwdUtkQHZjjCvY9fUtnniMVdUgkAZ9oLj8evpeoDEwyEHE1upmZZN84CMPP32NpHDtH3PwgGR3\"\n in\n assert (\n Promise.block_on_async_exn (fun () ->\n Side_loaded.verify_promise ~value_to_field_elements:Fn.id\n ~return_typ:Impls.Step.Typ.unit\n [ (vk, (statement, ()), pi) ] ) )*)\n\n open Impls.Step\n\n let () = Snarky_backendless.Snark0.set_eval_constraints true\n\n (* Currently, a circuit must have at least 1 of every type of constraint. *)\n let dummy_constraints () =\n Impl.(\n let x =\n exists Field.typ ~compute:(fun () -> Field.Constant.of_int 3)\n in\n let g =\n exists Step_main_inputs.Inner_curve.typ ~compute:(fun _ ->\n Tick.Inner_curve.(to_affine_exn one) )\n in\n ignore\n ( SC.to_field_checked'\n (module Impl)\n ~num_bits:16\n (Kimchi_backend_common.Scalar_challenge.create x)\n : Field.t * Field.t * Field.t ) ;\n ignore\n ( Step_main_inputs.Ops.scale_fast g ~num_bits:5 (Shifted_value x)\n : Step_main_inputs.Inner_curve.t ) ;\n ignore\n ( Step_main_inputs.Ops.scale_fast g ~num_bits:5 (Shifted_value x)\n : Step_main_inputs.Inner_curve.t ) ;\n ignore\n ( Step_verifier.Scalar_challenge.endo g ~num_bits:4\n (Kimchi_backend_common.Scalar_challenge.create x)\n : Field.t * Field.t ))\n\n module No_recursion = struct\n let[@warning \"-45\"] tag, _, p, Provers.[ step ] =\n Common.time \"compile\" (fun () ->\n compile_promise () ~public_input:(Input Field.typ)\n ~auxiliary_typ:Typ.unit\n ~branches:(module Nat.N1)\n ~max_proofs_verified:(module Nat.N0)\n ~name:\"blockchain-snark\"\n ~constraint_constants:\n (* Dummy values *)\n { sub_windows_per_window = 0\n ; ledger_depth = 0\n ; work_delay = 0\n ; block_window_duration_ms = 0\n ; transaction_capacity = Log_2 0\n ; pending_coinbase_depth = 0\n ; coinbase_amount = Unsigned.UInt64.of_int 0\n ; supercharged_coinbase_factor = 0\n ; account_creation_fee = Unsigned.UInt64.of_int 0\n ; fork = None\n }\n ~choices:(fun ~self:_ ->\n [ { identifier = \"main\"\n ; prevs = []\n ; feature_flags = Plonk_types.Features.none_bool\n ; main =\n (fun { public_input = self } ->\n dummy_constraints () ;\n Field.Assert.equal self Field.zero ;\n { previous_proof_statements = []\n ; public_output = ()\n ; auxiliary_output = ()\n } )\n }\n ] ) )\n\n module Proof = (val p)\n\n let example =\n let (), (), b0 =\n Common.time \"b0\" (fun () ->\n Promise.block_on_async_exn (fun () -> step Field.Constant.zero) )\n in\n Or_error.ok_exn\n (Promise.block_on_async_exn (fun () ->\n Proof.verify_promise [ (Field.Constant.zero, b0) ] ) ) ;\n (Field.Constant.zero, b0)\n\n let _example_input, _example_proof = example\n end\n\n module No_recursion_return = struct\n let[@warning \"-45\"] tag, _, p, Provers.[ step ] =\n Common.time \"compile\" (fun () ->\n compile_promise () ~public_input:(Output Field.typ)\n ~auxiliary_typ:Typ.unit\n ~branches:(module Nat.N1)\n ~max_proofs_verified:(module Nat.N0)\n ~name:\"blockchain-snark\"\n ~constraint_constants:\n (* Dummy values *)\n { sub_windows_per_window = 0\n ; ledger_depth = 0\n ; work_delay = 0\n ; block_window_duration_ms = 0\n ; transaction_capacity = Log_2 0\n ; pending_coinbase_depth = 0\n ; coinbase_amount = Unsigned.UInt64.of_int 0\n ; supercharged_coinbase_factor = 0\n ; account_creation_fee = Unsigned.UInt64.of_int 0\n ; fork = None\n }\n ~choices:(fun ~self:_ ->\n [ { identifier = \"main\"\n ; prevs = []\n ; feature_flags = Plonk_types.Features.none_bool\n ; main =\n (fun _ ->\n dummy_constraints () ;\n { previous_proof_statements = []\n ; public_output = Field.zero\n ; auxiliary_output = ()\n } )\n }\n ] ) )\n\n module Proof = (val p)\n\n let example =\n let res, (), b0 =\n Common.time \"b0\" (fun () ->\n Promise.block_on_async_exn (fun () -> step ()) )\n in\n assert (Field.Constant.(equal zero) res) ;\n Or_error.ok_exn\n (Promise.block_on_async_exn (fun () ->\n Proof.verify_promise [ (res, b0) ] ) ) ;\n (res, b0)\n\n let _example_input, _example_proof = example\n end\n\n [@@@warning \"-60\"]\n\n module Simple_chain = struct\n type _ Snarky_backendless.Request.t +=\n | Prev_input : Field.Constant.t Snarky_backendless.Request.t\n | Proof : (Nat.N1.n, Nat.N1.n) Proof.t Snarky_backendless.Request.t\n\n let handler (prev_input : Field.Constant.t) (proof : _ Proof.t)\n (Snarky_backendless.Request.With { request; respond }) =\n match request with\n | Prev_input ->\n respond (Provide prev_input)\n | Proof ->\n respond (Provide proof)\n | _ ->\n respond Unhandled\n\n let[@warning \"-45\"] _tag, _, p, Provers.[ step ] =\n Common.time \"compile\" (fun () ->\n compile_promise () ~public_input:(Input Field.typ)\n ~auxiliary_typ:Typ.unit\n ~branches:(module Nat.N1)\n ~max_proofs_verified:(module Nat.N1)\n ~name:\"blockchain-snark\"\n ~constraint_constants:\n (* Dummy values *)\n { sub_windows_per_window = 0\n ; ledger_depth = 0\n ; work_delay = 0\n ; block_window_duration_ms = 0\n ; transaction_capacity = Log_2 0\n ; pending_coinbase_depth = 0\n ; coinbase_amount = Unsigned.UInt64.of_int 0\n ; supercharged_coinbase_factor = 0\n ; account_creation_fee = Unsigned.UInt64.of_int 0\n ; fork = None\n }\n ~choices:(fun ~self ->\n [ { identifier = \"main\"\n ; prevs = [ self ]\n ; feature_flags = Plonk_types.Features.none_bool\n ; main =\n (fun { public_input = self } ->\n let prev =\n exists Field.typ ~request:(fun () -> Prev_input)\n in\n let proof =\n exists (Typ.Internal.ref ()) ~request:(fun () ->\n Proof )\n in\n let is_base_case = Field.equal Field.zero self in\n let proof_must_verify = Boolean.not is_base_case in\n let self_correct = Field.(equal (one + prev) self) in\n Boolean.Assert.any [ self_correct; is_base_case ] ;\n { previous_proof_statements =\n [ { public_input = prev\n ; proof\n ; proof_must_verify\n }\n ]\n ; public_output = ()\n ; auxiliary_output = ()\n } )\n }\n ] ) )\n\n module Proof = (val p)\n\n let example =\n let s_neg_one = Field.Constant.(negate one) in\n let b_neg_one : (Nat.N1.n, Nat.N1.n) Proof0.t =\n Proof0.dummy Nat.N1.n Nat.N1.n Nat.N1.n ~domain_log2:14\n in\n let (), (), b0 =\n Common.time \"b0\" (fun () ->\n Promise.block_on_async_exn (fun () ->\n step\n ~handler:(handler s_neg_one b_neg_one)\n Field.Constant.zero ) )\n in\n Or_error.ok_exn\n (Promise.block_on_async_exn (fun () ->\n Proof.verify_promise [ (Field.Constant.zero, b0) ] ) ) ;\n let (), (), b1 =\n Common.time \"b1\" (fun () ->\n Promise.block_on_async_exn (fun () ->\n step\n ~handler:(handler Field.Constant.zero b0)\n Field.Constant.one ) )\n in\n Or_error.ok_exn\n (Promise.block_on_async_exn (fun () ->\n Proof.verify_promise [ (Field.Constant.one, b1) ] ) ) ;\n (Field.Constant.one, b1)\n\n let _example_input, _example_proof = example\n end\n\n module Tree_proof = struct\n type _ Snarky_backendless.Request.t +=\n | No_recursion_input : Field.Constant.t Snarky_backendless.Request.t\n | No_recursion_proof :\n (Nat.N0.n, Nat.N0.n) Proof.t Snarky_backendless.Request.t\n | Recursive_input : Field.Constant.t Snarky_backendless.Request.t\n | Recursive_proof :\n (Nat.N2.n, Nat.N2.n) Proof.t Snarky_backendless.Request.t\n\n let handler\n ((no_recursion_input, no_recursion_proof) :\n Field.Constant.t * _ Proof.t )\n ((recursion_input, recursion_proof) : Field.Constant.t * _ Proof.t)\n (Snarky_backendless.Request.With { request; respond }) =\n match request with\n | No_recursion_input ->\n respond (Provide no_recursion_input)\n | No_recursion_proof ->\n respond (Provide no_recursion_proof)\n | Recursive_input ->\n respond (Provide recursion_input)\n | Recursive_proof ->\n respond (Provide recursion_proof)\n | _ ->\n respond Unhandled\n\n let[@warning \"-45\"] _tag, _, p, Provers.[ step ] =\n Common.time \"compile\" (fun () ->\n compile_promise () ~public_input:(Input Field.typ)\n ~override_wrap_domain:Pickles_base.Proofs_verified.N1\n ~auxiliary_typ:Typ.unit\n ~branches:(module Nat.N1)\n ~max_proofs_verified:(module Nat.N2)\n ~name:\"blockchain-snark\"\n ~constraint_constants:\n (* Dummy values *)\n { sub_windows_per_window = 0\n ; ledger_depth = 0\n ; work_delay = 0\n ; block_window_duration_ms = 0\n ; transaction_capacity = Log_2 0\n ; pending_coinbase_depth = 0\n ; coinbase_amount = Unsigned.UInt64.of_int 0\n ; supercharged_coinbase_factor = 0\n ; account_creation_fee = Unsigned.UInt64.of_int 0\n ; fork = None\n }\n ~choices:(fun ~self ->\n [ { identifier = \"main\"\n ; feature_flags = Plonk_types.Features.none_bool\n ; prevs = [ No_recursion.tag; self ]\n ; main =\n (fun { public_input = self } ->\n let no_recursive_input =\n exists Field.typ ~request:(fun () ->\n No_recursion_input )\n in\n let no_recursive_proof =\n exists (Typ.Internal.ref ()) ~request:(fun () ->\n No_recursion_proof )\n in\n let prev =\n exists Field.typ ~request:(fun () ->\n Recursive_input )\n in\n let prev_proof =\n exists (Typ.Internal.ref ()) ~request:(fun () ->\n Recursive_proof )\n in\n let is_base_case = Field.equal Field.zero self in\n let proof_must_verify = Boolean.not is_base_case in\n let self_correct = Field.(equal (one + prev) self) in\n Boolean.Assert.any [ self_correct; is_base_case ] ;\n { previous_proof_statements =\n [ { public_input = no_recursive_input\n ; proof = no_recursive_proof\n ; proof_must_verify = Boolean.true_\n }\n ; { public_input = prev\n ; proof = prev_proof\n ; proof_must_verify\n }\n ]\n ; public_output = ()\n ; auxiliary_output = ()\n } )\n }\n ] ) )\n\n module Proof = (val p)\n\n let example1, example2 =\n let s_neg_one = Field.Constant.(negate one) in\n let b_neg_one : (Nat.N2.n, Nat.N2.n) Proof0.t =\n Proof0.dummy Nat.N2.n Nat.N2.n Nat.N2.n ~domain_log2:15\n in\n let (), (), b0 =\n Common.time \"tree b0\" (fun () ->\n Promise.block_on_async_exn (fun () ->\n step\n ~handler:\n (handler No_recursion.example (s_neg_one, b_neg_one))\n Field.Constant.zero ) )\n in\n Or_error.ok_exn\n (Promise.block_on_async_exn (fun () ->\n Proof.verify_promise [ (Field.Constant.zero, b0) ] ) ) ;\n let (), (), b1 =\n Common.time \"tree b1\" (fun () ->\n Promise.block_on_async_exn (fun () ->\n step\n ~handler:\n (handler No_recursion.example (Field.Constant.zero, b0))\n Field.Constant.one ) )\n in\n ((Field.Constant.zero, b0), (Field.Constant.one, b1))\n\n let examples = [ example1; example2 ]\n\n let _example1_input, _example_proof = example1\n\n let _example2_input, _example2_proof = example2\n end\n\n let%test_unit \"verify\" =\n Or_error.ok_exn\n (Promise.block_on_async_exn (fun () ->\n Tree_proof.Proof.verify_promise Tree_proof.examples ) )\n\n module Tree_proof_return = struct\n type _ Snarky_backendless.Request.t +=\n | Is_base_case : bool Snarky_backendless.Request.t\n | No_recursion_input : Field.Constant.t Snarky_backendless.Request.t\n | No_recursion_proof :\n (Nat.N0.n, Nat.N0.n) Proof.t Snarky_backendless.Request.t\n | Recursive_input : Field.Constant.t Snarky_backendless.Request.t\n | Recursive_proof :\n (Nat.N2.n, Nat.N2.n) Proof.t Snarky_backendless.Request.t\n\n let handler (is_base_case : bool)\n ((no_recursion_input, no_recursion_proof) :\n Field.Constant.t * _ Proof.t )\n ((recursion_input, recursion_proof) : Field.Constant.t * _ Proof.t)\n (Snarky_backendless.Request.With { request; respond }) =\n match request with\n | Is_base_case ->\n respond (Provide is_base_case)\n | No_recursion_input ->\n respond (Provide no_recursion_input)\n | No_recursion_proof ->\n respond (Provide no_recursion_proof)\n | Recursive_input ->\n respond (Provide recursion_input)\n | Recursive_proof ->\n respond (Provide recursion_proof)\n | _ ->\n respond Unhandled\n\n let[@warning \"-45\"] _tag, _, p, Provers.[ step ] =\n Common.time \"compile\" (fun () ->\n compile_promise () ~public_input:(Output Field.typ)\n ~override_wrap_domain:Pickles_base.Proofs_verified.N1\n ~auxiliary_typ:Typ.unit\n ~branches:(module Nat.N1)\n ~max_proofs_verified:(module Nat.N2)\n ~name:\"blockchain-snark\"\n ~constraint_constants:\n (* Dummy values *)\n { sub_windows_per_window = 0\n ; ledger_depth = 0\n ; work_delay = 0\n ; block_window_duration_ms = 0\n ; transaction_capacity = Log_2 0\n ; pending_coinbase_depth = 0\n ; coinbase_amount = Unsigned.UInt64.of_int 0\n ; supercharged_coinbase_factor = 0\n ; account_creation_fee = Unsigned.UInt64.of_int 0\n ; fork = None\n }\n ~choices:(fun ~self ->\n [ { identifier = \"main\"\n ; feature_flags = Plonk_types.Features.none_bool\n ; prevs = [ No_recursion_return.tag; self ]\n ; main =\n (fun { public_input = () } ->\n let no_recursive_input =\n exists Field.typ ~request:(fun () ->\n No_recursion_input )\n in\n let no_recursive_proof =\n exists (Typ.Internal.ref ()) ~request:(fun () ->\n No_recursion_proof )\n in\n let prev =\n exists Field.typ ~request:(fun () ->\n Recursive_input )\n in\n let prev_proof =\n exists (Typ.Internal.ref ()) ~request:(fun () ->\n Recursive_proof )\n in\n let is_base_case =\n exists Boolean.typ ~request:(fun () -> Is_base_case)\n in\n let proof_must_verify = Boolean.not is_base_case in\n let self =\n Field.(\n if_ is_base_case ~then_:zero ~else_:(one + prev))\n in\n { previous_proof_statements =\n [ { public_input = no_recursive_input\n ; proof = no_recursive_proof\n ; proof_must_verify = Boolean.true_\n }\n ; { public_input = prev\n ; proof = prev_proof\n ; proof_must_verify\n }\n ]\n ; public_output = self\n ; auxiliary_output = ()\n } )\n }\n ] ) )\n\n module Proof = (val p)\n\n let example1, example2 =\n let s_neg_one = Field.Constant.(negate one) in\n let b_neg_one : (Nat.N2.n, Nat.N2.n) Proof0.t =\n Proof0.dummy Nat.N2.n Nat.N2.n Nat.N2.n ~domain_log2:15\n in\n let s0, (), b0 =\n Common.time \"tree b0\" (fun () ->\n Promise.block_on_async_exn (fun () ->\n step\n ~handler:\n (handler true No_recursion_return.example\n (s_neg_one, b_neg_one) )\n () ) )\n in\n assert (Field.Constant.(equal zero) s0) ;\n Or_error.ok_exn\n (Promise.block_on_async_exn (fun () ->\n Proof.verify_promise [ (s0, b0) ] ) ) ;\n let s1, (), b1 =\n Common.time \"tree b1\" (fun () ->\n Promise.block_on_async_exn (fun () ->\n step\n ~handler:\n (handler false No_recursion_return.example (s0, b0))\n () ) )\n in\n assert (Field.Constant.(equal one) s1) ;\n ((s0, b0), (s1, b1))\n\n let examples = [ example1; example2 ]\n\n let _example1_input, _example1_proof = example1\n\n let _example2_input, _example2_proof = example2\n end\n\n let%test_unit \"verify\" =\n Or_error.ok_exn\n (Promise.block_on_async_exn (fun () ->\n Tree_proof_return.Proof.verify_promise Tree_proof_return.examples )\n )\n\n module Add_one_return = struct\n let[@warning \"-45\"] _tag, _, p, Provers.[ step ] =\n Common.time \"compile\" (fun () ->\n compile_promise ()\n ~public_input:(Input_and_output (Field.typ, Field.typ))\n ~auxiliary_typ:Typ.unit\n ~branches:(module Nat.N1)\n ~max_proofs_verified:(module Nat.N0)\n ~name:\"blockchain-snark\"\n ~constraint_constants:\n (* Dummy values *)\n { sub_windows_per_window = 0\n ; ledger_depth = 0\n ; work_delay = 0\n ; block_window_duration_ms = 0\n ; transaction_capacity = Log_2 0\n ; pending_coinbase_depth = 0\n ; coinbase_amount = Unsigned.UInt64.of_int 0\n ; supercharged_coinbase_factor = 0\n ; account_creation_fee = Unsigned.UInt64.of_int 0\n ; fork = None\n }\n ~choices:(fun ~self:_ ->\n [ { identifier = \"main\"\n ; feature_flags = Plonk_types.Features.none_bool\n ; prevs = []\n ; main =\n (fun { public_input = x } ->\n dummy_constraints () ;\n { previous_proof_statements = []\n ; public_output = Field.(add one) x\n ; auxiliary_output = ()\n } )\n }\n ] ) )\n\n module Proof = (val p)\n\n let example =\n let input = Field.Constant.of_int 42 in\n let res, (), b0 =\n Common.time \"b0\" (fun () ->\n Promise.block_on_async_exn (fun () -> step input) )\n in\n assert (Field.Constant.(equal (of_int 43)) res) ;\n Or_error.ok_exn\n (Promise.block_on_async_exn (fun () ->\n Proof.verify_promise [ ((input, res), b0) ] ) ) ;\n ((input, res), b0)\n\n let _example_input, _example_proof = example\n end\n\n module Auxiliary_return = struct\n let[@warning \"-45\"] _tag, _, p, Provers.[ step ] =\n Common.time \"compile\" (fun () ->\n compile_promise ()\n ~public_input:(Input_and_output (Field.typ, Field.typ))\n ~auxiliary_typ:Field.typ\n ~branches:(module Nat.N1)\n ~max_proofs_verified:(module Nat.N0)\n ~name:\"blockchain-snark\"\n ~constraint_constants:\n (* Dummy values *)\n { sub_windows_per_window = 0\n ; ledger_depth = 0\n ; work_delay = 0\n ; block_window_duration_ms = 0\n ; transaction_capacity = Log_2 0\n ; pending_coinbase_depth = 0\n ; coinbase_amount = Unsigned.UInt64.of_int 0\n ; supercharged_coinbase_factor = 0\n ; account_creation_fee = Unsigned.UInt64.of_int 0\n ; fork = None\n }\n ~choices:(fun ~self:_ ->\n [ { identifier = \"main\"\n ; feature_flags = Plonk_types.Features.none_bool\n ; prevs = []\n ; main =\n (fun { public_input = input } ->\n dummy_constraints () ;\n let sponge =\n Step_main_inputs.Sponge.create\n Step_main_inputs.sponge_params\n in\n let blinding_value =\n exists Field.typ ~compute:Field.Constant.random\n in\n Step_main_inputs.Sponge.absorb sponge (`Field input) ;\n Step_main_inputs.Sponge.absorb sponge\n (`Field blinding_value) ;\n let result = Step_main_inputs.Sponge.squeeze sponge in\n { previous_proof_statements = []\n ; public_output = result\n ; auxiliary_output = blinding_value\n } )\n }\n ] ) )\n\n module Proof = (val p)\n\n let example =\n let input = Field.Constant.of_int 42 in\n let result, blinding_value, b0 =\n Common.time \"b0\" (fun () ->\n Promise.block_on_async_exn (fun () -> step input) )\n in\n let sponge =\n Tick_field_sponge.Field.create Tick_field_sponge.params\n in\n Tick_field_sponge.Field.absorb sponge input ;\n Tick_field_sponge.Field.absorb sponge blinding_value ;\n let result' = Tick_field_sponge.Field.squeeze sponge in\n assert (Field.Constant.equal result result') ;\n Or_error.ok_exn\n (Promise.block_on_async_exn (fun () ->\n Proof.verify_promise [ ((input, result), b0) ] ) ) ;\n ((input, result), b0)\n\n let _example_input, _example_proof = example\n end\n end )\n\n let%test_module \"test uncorrelated bulletproof_challenges\" =\n ( module struct\n let () = Backtrace.elide := false\n\n let () = Snarky_backendless.Snark0.set_eval_constraints true\n\n module Statement = struct\n type t = unit\n\n let to_field_elements () = [||]\n end\n\n module A = Statement\n module A_value = Statement\n\n let typ = Impls.Step.Typ.unit\n\n module Branches = Nat.N1\n module Max_proofs_verified = Nat.N2\n\n let constraint_constants : Snark_keys_header.Constraint_constants.t =\n { sub_windows_per_window = 0\n ; ledger_depth = 0\n ; work_delay = 0\n ; block_window_duration_ms = 0\n ; transaction_capacity = Log_2 0\n ; pending_coinbase_depth = 0\n ; coinbase_amount = Unsigned.UInt64.of_int 0\n ; supercharged_coinbase_factor = 0\n ; account_creation_fee = Unsigned.UInt64.of_int 0\n ; fork = None\n }\n\n let tag =\n let tagname = \"\" in\n Tag.create ~kind:Compiled tagname\n\n let rule : _ Inductive_rule.t =\n let open Impls.Step in\n { identifier = \"main\"\n ; prevs = [ tag; tag ]\n ; main =\n (fun { public_input = () } ->\n let dummy_proof =\n As_prover.Ref.create (fun () ->\n Proof0.dummy Nat.N2.n Nat.N2.n Nat.N2.n ~domain_log2:15 )\n in\n { previous_proof_statements =\n [ { public_input = ()\n ; proof = dummy_proof\n ; proof_must_verify = Boolean.false_\n }\n ; { public_input = ()\n ; proof = dummy_proof\n ; proof_must_verify = Boolean.false_\n }\n ]\n ; public_output = ()\n ; auxiliary_output = ()\n } )\n ; feature_flags = Plonk_types.Features.none_bool\n }\n\n module M = struct\n module IR = Inductive_rule.T (A) (A_value) (A) (A_value) (A) (A_value)\n\n let max_local_max_proofs_verifieds ~self (type n)\n (module Max_proofs_verified : Nat.Intf with type n = n) branches\n choices =\n let module Local_max_proofs_verifieds = struct\n type t = (int, Max_proofs_verified.n) Vector.t\n end in\n let module M =\n H4.Map (IR) (E04 (Local_max_proofs_verifieds))\n (struct\n module V = H4.To_vector (Int)\n module HT = H4.T (Tag)\n\n module M =\n H4.Map (Tag) (E04 (Int))\n (struct\n let f (type a b c d) (t : (a, b, c, d) Tag.t) : int =\n if Type_equal.Id.same t.id self then\n Nat.to_int Max_proofs_verified.n\n else\n let (module M) = Types_map.max_proofs_verified t in\n Nat.to_int M.n\n end)\n\n let f :\n type a b c d.\n (a, b, c, d) IR.t -> Local_max_proofs_verifieds.t =\n fun rule ->\n let (T (_, l)) = HT.length rule.prevs in\n Vector.extend_front_exn\n (V.f l (M.f rule.prevs))\n Max_proofs_verified.n 0\n end)\n in\n let module V = H4.To_vector (Local_max_proofs_verifieds) in\n let padded = V.f branches (M.f choices) |> Vector.transpose in\n (padded, Maxes.m padded)\n\n module Lazy_keys = struct\n type t =\n (Impls.Step.Keypair.t * Dirty.t) Lazy.t\n * (Kimchi_bindings.Protocol.VerifierIndex.Fp.t * Dirty.t) Lazy.t\n\n (* TODO Think this is right.. *)\n end\n\n let compile :\n ( unit\n -> (Max_proofs_verified.n, Max_proofs_verified.n) Proof.t Promise.t\n )\n * _\n * _ =\n let self = tag in\n let snark_keys_header kind constraint_system_hash =\n { Snark_keys_header.header_version =\n Snark_keys_header.header_version\n ; kind\n ; constraint_constants\n ; commits =\n { mina = Mina_version.commit_id\n ; marlin = Mina_version.marlin_commit_id\n }\n ; length = (* This is a dummy, it gets filled in on read/write. *) 0\n ; commit_date = Mina_version.commit_date\n ; constraint_system_hash\n ; identifying_hash =\n (* TODO: Proper identifying hash. *)\n constraint_system_hash\n }\n in\n let T = Max_proofs_verified.eq in\n let prev_varss_n = Branches.n in\n let prev_varss_length : _ Length.t = S Z in\n let T = Nat.eq_exn prev_varss_n Branches.n in\n let padded, (module Maxes) =\n max_local_max_proofs_verifieds\n (module Max_proofs_verified)\n prev_varss_length [ rule ] ~self:self.id\n in\n let full_signature =\n { Full_signature.padded; maxes = (module Maxes) }\n in\n let feature_flags = Plonk_types.Features.none in\n let actual_feature_flags = Plonk_types.Features.none_bool in\n let wrap_domains =\n let module M =\n Wrap_domains.Make (A) (A_value) (A) (A_value) (A) (A_value)\n in\n M.f full_signature prev_varss_n prev_varss_length ~feature_flags\n ~max_proofs_verified:(module Max_proofs_verified)\n in\n let module Branch_data = struct\n type ('vars, 'vals, 'n, 'm) t =\n ( A.t\n , A_value.t\n , A.t\n , A_value.t\n , A.t\n , A_value.t\n , Max_proofs_verified.n\n , Branches.n\n , 'vars\n , 'vals\n , 'n\n , 'm )\n Step_branch_data.t\n end in\n let proofs_verifieds = Vector.singleton 2 in\n let (T inner_step_data as step_data) =\n Step_branch_data.create ~index:0 ~feature_flags\n ~actual_feature_flags ~max_proofs_verified:Max_proofs_verified.n\n ~branches:Branches.n ~self ~public_input:(Input typ)\n ~auxiliary_typ:typ A.to_field_elements A_value.to_field_elements\n rule ~wrap_domains ~proofs_verifieds\n in\n let step_domains = Vector.singleton inner_step_data.domains in\n let step_keypair =\n let etyp =\n Impls.Step.input ~feature_flags\n ~proofs_verified:Max_proofs_verified.n\n ~wrap_rounds:Tock.Rounds.n\n in\n let (T (typ, _conv, conv_inv)) = etyp in\n let main () () =\n let res = inner_step_data.main ~step_domains () in\n Impls.Step.with_label \"conv_inv\" (fun () -> conv_inv res)\n in\n let open Impls.Step in\n let k_p =\n lazy\n (let cs =\n constraint_system ~input_typ:Typ.unit ~return_typ:typ main\n in\n let cs_hash = Md5.to_hex (R1CS_constraint_system.digest cs) in\n ( Type_equal.Id.uid self.id\n , snark_keys_header\n { type_ = \"step-proving-key\"\n ; identifier = inner_step_data.rule.identifier\n }\n cs_hash\n , inner_step_data.index\n , cs ) )\n in\n let k_v =\n lazy\n (let id, _header, index, cs = Lazy.force k_p in\n let digest = R1CS_constraint_system.digest cs in\n ( id\n , snark_keys_header\n { type_ = \"step-verification-key\"\n ; identifier = inner_step_data.rule.identifier\n }\n (Md5.to_hex digest)\n , index\n , digest ) )\n in\n Cache.Step.read_or_generate\n ~prev_challenges:\n (Nat.to_int (fst inner_step_data.proofs_verified))\n [] k_p k_v\n (Snarky_backendless.Typ.unit ())\n typ main\n in\n let step_vks =\n lazy\n (Vector.map [ step_keypair ] ~f:(fun (_, vk) ->\n Tick.Keypair.vk_commitments (fst (Lazy.force vk)) ) )\n in\n let wrap_main _ =\n let module SC' = SC in\n let open Impls.Wrap in\n let open Wrap_main_inputs in\n let x =\n exists Field.typ ~compute:(fun () -> Field.Constant.of_int 3)\n in\n let y =\n exists Field.typ ~compute:(fun () -> Field.Constant.of_int 0)\n in\n let z =\n exists Field.typ ~compute:(fun () -> Field.Constant.of_int 0)\n in\n let g = Inner_curve.one in\n let sponge = Sponge.create sponge_params in\n Sponge.absorb sponge x ;\n ignore (Sponge.squeeze_field sponge : Field.t) ;\n ignore\n ( SC'.to_field_checked'\n (module Impl)\n ~num_bits:16\n (Kimchi_backend_common.Scalar_challenge.create x)\n : Field.t * Field.t * Field.t ) ;\n ignore\n (Ops.scale_fast g ~num_bits:5 (Shifted_value x) : Inner_curve.t) ;\n ignore\n ( Wrap_verifier.Scalar_challenge.endo g ~num_bits:4\n (Kimchi_backend_common.Scalar_challenge.create x)\n : Field.t * Field.t ) ;\n for _i = 0 to 64000 do\n assert_r1cs x y z\n done\n in\n let (wrap_pk, wrap_vk), disk_key =\n let open Impls.Wrap in\n let (T (typ, conv, _conv_inv)) = input () in\n let main x () : unit = wrap_main (conv x) in\n let self_id = Type_equal.Id.uid self.id in\n let disk_key_prover =\n lazy\n (let cs =\n constraint_system ~input_typ:typ ~return_typ:Typ.unit main\n in\n let cs_hash = Md5.to_hex (R1CS_constraint_system.digest cs) in\n ( self_id\n , snark_keys_header\n { type_ = \"wrap-proving-key\"; identifier = \"\" }\n cs_hash\n , cs ) )\n in\n let disk_key_verifier =\n lazy\n (let id, _header, cs = Lazy.force disk_key_prover in\n let digest = R1CS_constraint_system.digest cs in\n ( id\n , snark_keys_header\n { type_ = \"wrap-verification-key\"; identifier = \"\" }\n (Md5.to_hex digest)\n , digest ) )\n in\n let r =\n Common.time \"wrap read or generate \" (fun () ->\n Cache.Wrap.read_or_generate ~prev_challenges:2 []\n disk_key_prover disk_key_verifier typ Typ.unit main )\n in\n (r, disk_key_verifier)\n in\n let wrap_vk = Lazy.map wrap_vk ~f:fst in\n let module S = Step.Make (A) (A_value) (Max_proofs_verified) in\n let prover =\n let f :\n ( unit * (unit * unit)\n , unit * (unit * unit)\n , Nat.N2.n * (Nat.N2.n * unit)\n , Nat.N1.n * (Nat.N1.n * unit) )\n Branch_data.t\n -> Lazy_keys.t\n -> unit\n -> (Max_proofs_verified.n, Max_proofs_verified.n) Proof.t\n Promise.t =\n fun (T b as branch_data) (step_pk, step_vk) () ->\n let (_ : (Max_proofs_verified.n, Maxes.ns) Requests.Wrap.t) =\n Requests.Wrap.create ()\n in\n let _, prev_vars_length = b.proofs_verified in\n let step =\n let wrap_vk = Lazy.force wrap_vk in\n S.f branch_data () ~feature_flags ~prevs_length:prev_vars_length\n ~self ~public_input:(Input typ)\n ~auxiliary_typ:Impls.Step.Typ.unit ~step_domains\n ~self_dlog_plonk_index:wrap_vk.commitments\n (Impls.Step.Keypair.pk (fst (Lazy.force step_pk)))\n wrap_vk.index\n in\n let pairing_vk = fst (Lazy.force step_vk) in\n let wrap =\n let wrap_vk = Lazy.force wrap_vk in\n let%bind.Promise proof, (), (), _ =\n step ~maxes:(module Maxes)\n in\n let proof =\n { proof with\n statement =\n { proof.statement with\n messages_for_next_wrap_proof =\n Compile.pad_messages_for_next_wrap_proof\n (module Maxes)\n proof.statement.messages_for_next_wrap_proof\n }\n }\n in\n let%map.Promise proof =\n (* The prover for wrapping a proof *)\n let wrap (type actual_branching)\n ~(max_proofs_verified : Max_proofs_verified.n Nat.t)\n (module Max_local_max_proofs_verifieds : Hlist.Maxes.S\n with type ns = Maxes.ns\n and type length = Max_proofs_verified.n )\n ~dlog_plonk_index wrap_main to_field_elements ~pairing_vk\n ~step_domains:_ ~wrap_domains:_ ~pairing_plonk_indices:_\n pk\n ({ statement = prev_statement\n ; prev_evals = _\n ; proof\n ; index = _which_index\n } :\n ( _\n , _\n , (_, actual_branching) Vector.t\n , (_, actual_branching) Vector.t\n , Maxes.ns\n H1.T\n (P.Base.Messages_for_next_proof_over_same_field.Wrap)\n .t\n , ( ( Tock.Field.t\n , Tock.Field.t array )\n Plonk_types.All_evals.t\n , Max_proofs_verified.n )\n Vector.t )\n P.Base.Step.t ) =\n let prev_messages_for_next_wrap_proof =\n let module M =\n H1.Map\n (P.Base.Messages_for_next_proof_over_same_field.Wrap)\n (P.Base.Messages_for_next_proof_over_same_field.Wrap\n .Prepared)\n (struct\n let f =\n P.Base.Messages_for_next_proof_over_same_field\n .Wrap\n .prepare\n end)\n in\n M.f prev_statement.messages_for_next_wrap_proof\n in\n let prev_statement_with_hashes : _ Types.Step.Statement.t =\n { proof_state =\n { prev_statement.proof_state with\n messages_for_next_step_proof =\n (* TODO: Careful here... the length of\n old_buletproof_challenges inside the messages_for_next_wrap_proof\n might not be correct *)\n Common.hash_messages_for_next_step_proof\n ~app_state:to_field_elements\n (P.Base.Messages_for_next_proof_over_same_field\n .Step\n .prepare ~dlog_plonk_index\n prev_statement.proof_state\n .messages_for_next_step_proof )\n }\n ; messages_for_next_wrap_proof =\n (let module M =\n H1.Map\n (P.Base.Messages_for_next_proof_over_same_field\n .Wrap\n .Prepared)\n (E01 (Digest.Constant))\n (struct\n let f (type n)\n (m :\n n\n P.Base\n .Messages_for_next_proof_over_same_field\n .Wrap\n .Prepared\n .t ) =\n let T =\n Nat.eq_exn max_proofs_verified\n (Vector.length\n m.old_bulletproof_challenges )\n in\n Wrap_hack.hash_messages_for_next_wrap_proof\n max_proofs_verified m\n end)\n in\n let module V = H1.To_vector (Digest.Constant) in\n V.f Max_local_max_proofs_verifieds.length\n (M.f prev_messages_for_next_wrap_proof) )\n }\n in\n let module O = Tick.Oracles in\n let public_input =\n tick_public_input_of_statement ~max_proofs_verified\n ~feature_flags:Plonk_types.Features.none\n prev_statement_with_hashes\n in\n let prev_challenges =\n Vector.map ~f:Ipa.Step.compute_challenges\n prev_statement.proof_state.messages_for_next_step_proof\n .old_bulletproof_challenges\n in\n let actual_proofs_verified =\n Vector.length prev_challenges\n in\n let lte =\n Nat.lte_exn actual_proofs_verified\n (Length.to_nat Max_local_max_proofs_verifieds.length)\n in\n let o =\n let sgs =\n let module M =\n H1.Map\n (P.Base.Messages_for_next_proof_over_same_field.Wrap\n .Prepared)\n (E01 (Tick.Curve.Affine))\n (struct\n let f :\n type n.\n n\n P.Base\n .Messages_for_next_proof_over_same_field\n .Wrap\n .Prepared\n .t\n -> _ =\n fun t -> t.challenge_polynomial_commitment\n end)\n in\n let module V = H1.To_vector (Tick.Curve.Affine) in\n V.f Max_local_max_proofs_verifieds.length\n (M.f prev_messages_for_next_wrap_proof)\n in\n O.create pairing_vk\n Vector.(\n map2 (Vector.trim_front sgs lte) prev_challenges\n ~f:(fun commitment cs ->\n { Tick.Proof.Challenge_polynomial.commitment\n ; challenges = Vector.to_array cs\n } )\n |> to_list)\n public_input proof\n in\n let x_hat = O.(p_eval_1 o, p_eval_2 o) in\n let step_vk, _ = Lazy.force step_vk in\n let next_statement : _ Types.Wrap.Statement.In_circuit.t =\n let scalar_chal f =\n Scalar_challenge.map ~f:Challenge.Constant.of_tick_field\n (f o)\n in\n let sponge_digest_before_evaluations =\n O.digest_before_evaluations o\n in\n let plonk0 =\n { Types.Wrap.Proof_state.Deferred_values.Plonk.Minimal\n .alpha = scalar_chal O.alpha\n ; beta = O.beta o\n ; gamma = O.gamma o\n ; zeta = scalar_chal O.zeta\n ; joint_combiner =\n Option.map (O.joint_combiner_chal o)\n ~f:\n (Scalar_challenge.map\n ~f:Challenge.Constant.of_tick_field )\n ; feature_flags = Plonk_types.Features.none_bool\n }\n in\n let r = scalar_chal O.u in\n let xi = scalar_chal O.v in\n let to_field =\n SC.to_field_constant\n (module Tick.Field)\n ~endo:Endo.Wrap_inner_curve.scalar\n in\n let module As_field = struct\n let r = to_field r\n\n let xi = to_field xi\n\n let zeta = to_field plonk0.zeta\n\n let alpha = to_field plonk0.alpha\n\n let joint_combiner =\n Option.map ~f:to_field plonk0.joint_combiner\n end in\n let domain =\n Domain.Pow_2_roots_of_unity\n step_vk.domain.log_size_of_group\n in\n let w = step_vk.domain.group_gen in\n (* Debug *)\n [%test_eq: Tick.Field.t] w\n (Tick.Field.domain_generator\n ~log2_size:(Domain.log2_size domain) ) ;\n let zetaw = Tick.Field.mul As_field.zeta w in\n let tick_plonk_minimal =\n { plonk0 with\n zeta = As_field.zeta\n ; alpha = As_field.alpha\n ; joint_combiner = As_field.joint_combiner\n }\n in\n let tick_combined_evals =\n Plonk_checks.evals_of_split_evals\n (module Tick.Field)\n proof.openings.evals\n ~rounds:(Nat.to_int Tick.Rounds.n) ~zeta:As_field.zeta\n ~zetaw\n in\n let tick_domain =\n Plonk_checks.domain\n (module Tick.Field)\n domain ~shifts:Common.tick_shifts\n ~domain_generator:Backend.Tick.Field.domain_generator\n in\n let tick_combined_evals =\n Plonk_types.Evals.to_in_circuit tick_combined_evals\n in\n let tick_env =\n let module Env_bool = struct\n type t = bool\n\n let true_ = true\n\n let false_ = false\n\n let ( &&& ) = ( && )\n\n let ( ||| ) = ( || )\n\n let any = List.exists ~f:Fn.id\n end in\n let module Env_field = struct\n include Tick.Field\n\n type bool = Env_bool.t\n\n let if_ (b : bool) ~then_ ~else_ =\n if b then then_ () else else_ ()\n end in\n Plonk_checks.scalars_env\n (module Env_bool)\n (module Env_field)\n ~endo:Endo.Step_inner_curve.base\n ~mds:Tick_field_sponge.params.mds\n ~srs_length_log2:Common.Max_degree.step_log2\n ~field_of_hex:(fun s ->\n Kimchi_pasta.Pasta.Bigint256.of_hex_string s\n |> Kimchi_pasta.Pasta.Fp.of_bigint )\n ~domain:tick_domain tick_plonk_minimal\n tick_combined_evals\n in\n let combined_inner_product =\n let open As_field in\n Wrap.combined_inner_product\n (* Note: We do not pad here. *)\n ~actual_proofs_verified:\n (Nat.Add.create actual_proofs_verified)\n { evals = proof.openings.evals; public_input = x_hat }\n ~r ~xi ~zeta ~zetaw\n ~old_bulletproof_challenges:prev_challenges\n ~env:tick_env ~domain:tick_domain\n ~ft_eval1:proof.openings.ft_eval1\n ~plonk:tick_plonk_minimal\n in\n let chal = Challenge.Constant.of_tick_field in\n let sg_new, new_bulletproof_challenges, b =\n let prechals =\n Array.map (O.opening_prechallenges o) ~f:(fun x ->\n let x =\n Scalar_challenge.map\n ~f:Challenge.Constant.of_tick_field x\n in\n x )\n in\n let chals =\n Array.map prechals ~f:(fun x ->\n Ipa.Step.compute_challenge x )\n in\n let challenge_polynomial =\n unstage (Wrap.challenge_polynomial chals)\n in\n let open As_field in\n let b =\n let open Tick.Field in\n challenge_polynomial zeta\n + (r * challenge_polynomial zetaw)\n in\n let overwritten_prechals =\n Array.map prechals\n ~f:\n (Scalar_challenge.map ~f:(fun _ ->\n Challenge.Constant.of_tick_field\n (Impls.Step.Field.Constant.of_int 100) ) )\n in\n let chals =\n Array.map overwritten_prechals ~f:(fun x ->\n Ipa.Step.compute_challenge x )\n in\n let sg_new =\n let urs = Backend.Tick.Keypair.load_urs () in\n Kimchi_bindings.Protocol.SRS.Fp\n .batch_accumulator_generate urs 1 chals\n in\n let[@warning \"-4\"] sg_new =\n match sg_new with\n | [| Kimchi_types.Finite x |] ->\n x\n | _ ->\n assert false\n in\n let overwritten_prechals =\n Array.map overwritten_prechals\n ~f:Bulletproof_challenge.unpack\n in\n\n (sg_new, overwritten_prechals, b)\n in\n let plonk =\n let module Field = struct\n include Tick.Field\n end in\n Wrap.Type1.derive_plonk\n (module Field)\n ~shift:Shifts.tick1 ~env:tick_env tick_plonk_minimal\n tick_combined_evals\n in\n let shift_value =\n Shifted_value.Type1.of_field\n (module Tick.Field)\n ~shift:Shifts.tick1\n in\n let branch_data : Composition_types.Branch_data.t =\n { proofs_verified =\n ( match actual_proofs_verified with\n | Z ->\n Composition_types.Branch_data.Proofs_verified.N0\n | S Z ->\n N1\n | S (S Z) ->\n N2\n | S _ ->\n assert false )\n ; domain_log2 =\n Composition_types.Branch_data.Domain_log2.of_int_exn\n step_vk.domain.log_size_of_group\n }\n in\n let messages_for_next_wrap_proof :\n _\n P.Base.Messages_for_next_proof_over_same_field.Wrap.t\n =\n { challenge_polynomial_commitment = sg_new\n ; old_bulletproof_challenges =\n Vector.map\n prev_statement.proof_state.unfinalized_proofs\n ~f:(fun t ->\n t.deferred_values.bulletproof_challenges )\n }\n in\n { proof_state =\n { deferred_values =\n { xi\n ; b = shift_value b\n ; bulletproof_challenges =\n Vector.of_array_and_length_exn\n new_bulletproof_challenges Tick.Rounds.n\n ; combined_inner_product =\n shift_value combined_inner_product\n ; branch_data\n ; plonk =\n { plonk with\n zeta = plonk0.zeta\n ; alpha = plonk0.alpha\n ; beta = chal plonk0.beta\n ; gamma = chal plonk0.gamma\n ; lookup = Plonk_types.Opt.None\n }\n }\n ; sponge_digest_before_evaluations =\n Digest.Constant.of_tick_field\n sponge_digest_before_evaluations\n ; messages_for_next_wrap_proof\n }\n ; messages_for_next_step_proof =\n prev_statement.proof_state\n .messages_for_next_step_proof\n }\n in\n let messages_for_next_wrap_proof_prepared =\n P.Base.Messages_for_next_proof_over_same_field.Wrap\n .prepare\n next_statement.proof_state.messages_for_next_wrap_proof\n in\n let%map.Promise next_proof =\n let (T (input, conv, _conv_inv)) = Impls.Wrap.input () in\n Common.time \"wrap proof\" (fun () ->\n Impls.Wrap.generate_witness_conv\n ~f:(fun { Impls.Wrap.Proof_inputs.auxiliary_inputs\n ; public_inputs\n } () ->\n Backend.Tock.Proof.create_async\n ~primary:public_inputs\n ~auxiliary:auxiliary_inputs pk\n ~message:\n ( Vector.map2\n (Vector.extend_front_exn\n prev_statement.proof_state\n .messages_for_next_step_proof\n .challenge_polynomial_commitments\n max_proofs_verified\n (Lazy.force Dummy.Ipa.Wrap.sg) )\n messages_for_next_wrap_proof_prepared\n .old_bulletproof_challenges\n ~f:(fun sg chals ->\n { Tock.Proof.Challenge_polynomial\n .commitment = sg\n ; challenges = Vector.to_array chals\n } )\n |> Wrap_hack.pad_accumulator ) )\n ~input_typ:input\n ~return_typ:(Snarky_backendless.Typ.unit ())\n (fun x () : unit -> wrap_main (conv x))\n { messages_for_next_step_proof =\n prev_statement_with_hashes.proof_state\n .messages_for_next_step_proof\n ; proof_state =\n { next_statement.proof_state with\n messages_for_next_wrap_proof =\n Wrap_hack.hash_messages_for_next_wrap_proof\n max_proofs_verified\n messages_for_next_wrap_proof_prepared\n ; deferred_values =\n { next_statement.proof_state.deferred_values with\n plonk =\n { next_statement.proof_state\n .deferred_values\n .plonk\n with\n lookup = None\n }\n }\n }\n } )\n in\n ( { proof = Wrap_wire_proof.of_kimchi_proof next_proof\n ; statement =\n Types.Wrap.Statement.to_minimal\n ~to_option:Plonk_types.Opt.to_option next_statement\n ; prev_evals =\n { Plonk_types.All_evals.evals =\n { public_input = x_hat\n ; evals = proof.openings.evals\n }\n ; ft_eval1 = proof.openings.ft_eval1\n }\n }\n : _ P.Base.Wrap.t )\n in\n wrap ~max_proofs_verified:Max_proofs_verified.n\n full_signature.maxes ~dlog_plonk_index:wrap_vk.commitments\n wrap_main A_value.to_field_elements ~pairing_vk\n ~step_domains:b.domains\n ~pairing_plonk_indices:(Lazy.force step_vks) ~wrap_domains\n (Impls.Wrap.Keypair.pk (fst (Lazy.force wrap_pk)))\n proof\n in\n Proof.T\n { proof with\n statement =\n { proof.statement with\n messages_for_next_step_proof =\n { proof.statement.messages_for_next_step_proof with\n app_state = ()\n }\n }\n }\n in\n wrap\n in\n f step_data step_keypair\n in\n let data : _ Types_map.Compiled.t =\n { branches = Branches.n\n ; feature_flags\n ; proofs_verifieds\n ; max_proofs_verified = (module Max_proofs_verified)\n ; public_input = typ\n ; wrap_key = Lazy.map wrap_vk ~f:Verification_key.commitments\n ; wrap_vk = Lazy.map wrap_vk ~f:Verification_key.index\n ; wrap_domains\n ; step_domains\n }\n in\n Types_map.add_exn self data ;\n (prover, wrap_vk, disk_key)\n end\n\n let step, wrap_vk, wrap_disk_key = M.compile\n\n module Proof = struct\n module Max_local_max_proofs_verified = Max_proofs_verified\n include Proof.Make (Max_proofs_verified) (Max_local_max_proofs_verified)\n\n let _id = wrap_disk_key\n\n let verification_key = wrap_vk\n\n let verify ts =\n verify_promise\n (module Max_proofs_verified)\n (module A_value)\n (Lazy.force verification_key)\n ts\n\n let _statement (T p : t) =\n p.statement.messages_for_next_step_proof.app_state\n end\n\n let proof_with_stmt =\n let p = Promise.block_on_async_exn (fun () -> step ()) in\n ((), p)\n\n let%test \"should not be able to verify invalid proof\" =\n Or_error.is_error\n @@ Promise.block_on_async_exn (fun () ->\n Proof.verify [ proof_with_stmt ] )\n\n module Recurse_on_bad_proof = struct\n open Impls.Step\n\n let _dummy_proof =\n Proof0.dummy Nat.N2.n Nat.N2.n Nat.N2.n ~domain_log2:15\n\n type _ Snarky_backendless.Request.t +=\n | Proof : (Nat.N2.n, Nat.N2.n) Proof0.t Snarky_backendless.Request.t\n\n let handler (proof : _ Proof0.t)\n (Snarky_backendless.Request.With { request; respond }) =\n match request with\n | Proof ->\n respond (Provide proof)\n | _ ->\n respond Unhandled\n\n let[@warning \"-45\"] _tag, _, p, Provers.[ step ] =\n Common.time \"compile\" (fun () ->\n compile_promise () ~public_input:(Input Typ.unit)\n ~auxiliary_typ:Typ.unit\n ~branches:(module Nat.N1)\n ~max_proofs_verified:(module Nat.N2)\n ~name:\"recurse-on-bad\" ~constraint_constants\n ~choices:(fun ~self:_ ->\n [ { identifier = \"main\"\n ; feature_flags = Plonk_types.Features.none_bool\n ; prevs = [ tag; tag ]\n ; main =\n (fun { public_input = () } ->\n let proof =\n exists (Typ.Internal.ref ()) ~request:(fun () ->\n Proof )\n in\n { previous_proof_statements =\n [ { public_input = ()\n ; proof\n ; proof_must_verify = Boolean.true_\n }\n ; { public_input = ()\n ; proof\n ; proof_must_verify = Boolean.true_\n }\n ]\n ; public_output = ()\n ; auxiliary_output = ()\n } )\n }\n ] ) )\n\n module Proof = (val p)\n end\n\n let%test \"should not be able to create a recursive proof from an invalid \\\n proof\" =\n try\n let (), (), proof =\n Promise.block_on_async_exn (fun () ->\n Recurse_on_bad_proof.step\n ~handler:(Recurse_on_bad_proof.handler (snd proof_with_stmt))\n () )\n in\n Or_error.is_error\n @@ Promise.block_on_async_exn (fun () ->\n Recurse_on_bad_proof.Proof.verify_promise [ ((), proof) ] )\n with _ -> true\n end )\n\n let%test_module \"adversarial_tests\" =\n ( module struct\n [@@@warning \"-60\"]\n\n let () = Backtrace.elide := false\n\n let () = Snarky_backendless.Snark0.set_eval_constraints true\n\n let%test_module \"test domain size too large\" =\n ( module Compile.Make_adversarial_test (struct\n let tweak_statement (stmt : _ Import.Types.Wrap.Statement.In_circuit.t)\n =\n (* Modify the statement to use an invalid domain size. *)\n { stmt with\n proof_state =\n { stmt.proof_state with\n deferred_values =\n { stmt.proof_state.deferred_values with\n branch_data =\n { stmt.proof_state.deferred_values.branch_data with\n Branch_data.domain_log2 =\n Branch_data.Domain_log2.of_int_exn\n (Nat.to_int Kimchi_pasta.Basic.Rounds.Step.n + 1)\n }\n }\n }\n }\n\n let check_verifier_error err =\n (* Convert to JSON to make it easy to parse. *)\n err |> Error_json.error_to_yojson\n |> Yojson.Safe.Util.member \"multiple\"\n |> Yojson.Safe.Util.to_list\n |> List.find_exn ~f:(fun json ->\n let error =\n json\n |> Yojson.Safe.Util.member \"string\"\n |> Yojson.Safe.Util.to_string\n in\n String.equal error \"domain size is small enough\" )\n |> fun _ -> ()\n end) )\n end )\n\n let%test_module \"domain too small\" =\n ( module struct\n open Impls.Step\n\n (* Currently, a circuit must have at least 1 of every type of constraint. *)\n let dummy_constraints () =\n Impl.(\n let x =\n exists Field.typ ~compute:(fun () -> Field.Constant.of_int 3)\n in\n let g =\n exists Step_main_inputs.Inner_curve.typ ~compute:(fun _ ->\n Tick.Inner_curve.(to_affine_exn one) )\n in\n ignore\n ( SC.to_field_checked'\n (module Impl)\n ~num_bits:16\n (Kimchi_backend_common.Scalar_challenge.create x)\n : Field.t * Field.t * Field.t ) ;\n ignore\n ( Step_main_inputs.Ops.scale_fast g ~num_bits:5 (Shifted_value x)\n : Step_main_inputs.Inner_curve.t ) ;\n ignore\n ( Step_main_inputs.Ops.scale_fast g ~num_bits:5 (Shifted_value x)\n : Step_main_inputs.Inner_curve.t ) ;\n ignore\n ( Step_verifier.Scalar_challenge.endo g ~num_bits:4\n (Kimchi_backend_common.Scalar_challenge.create x)\n : Field.t * Field.t ))\n\n module No_recursion = struct\n let[@warning \"-45\"] tag, _, p, Provers.[ step ] =\n Common.time \"compile\" (fun () ->\n compile_promise () ~public_input:(Input Field.typ)\n ~auxiliary_typ:Typ.unit\n ~branches:(module Nat.N1)\n ~max_proofs_verified:(module Nat.N0)\n ~name:\"blockchain-snark\"\n ~constraint_constants:\n (* Dummy values *)\n { sub_windows_per_window = 0\n ; ledger_depth = 0\n ; work_delay = 0\n ; block_window_duration_ms = 0\n ; transaction_capacity = Log_2 0\n ; pending_coinbase_depth = 0\n ; coinbase_amount = Unsigned.UInt64.of_int 0\n ; supercharged_coinbase_factor = 0\n ; account_creation_fee = Unsigned.UInt64.of_int 0\n ; fork = None\n }\n ~choices:(fun ~self:_ ->\n [ { identifier = \"main\"\n ; prevs = []\n ; feature_flags = Plonk_types.Features.none_bool\n ; main =\n (fun { public_input = self } ->\n dummy_constraints () ;\n Field.Assert.equal self Field.zero ;\n { previous_proof_statements = []\n ; public_output = ()\n ; auxiliary_output = ()\n } )\n }\n ] ) )\n\n module Proof = (val p)\n\n let example =\n let (), (), b0 =\n Common.time \"b0\" (fun () ->\n Promise.block_on_async_exn (fun () -> step Field.Constant.zero) )\n in\n Or_error.ok_exn\n (Promise.block_on_async_exn (fun () ->\n Proof.verify_promise [ (Field.Constant.zero, b0) ] ) ) ;\n (Field.Constant.zero, b0)\n\n let example_input, example_proof = example\n end\n\n module Fake_1_recursion = struct\n let[@warning \"-45\"] tag, _, p, Provers.[ step ] =\n Common.time \"compile\" (fun () ->\n compile_promise () ~public_input:(Input Field.typ)\n ~auxiliary_typ:Typ.unit\n ~branches:(module Nat.N1)\n ~max_proofs_verified:(module Nat.N1)\n ~name:\"blockchain-snark\"\n ~constraint_constants:\n (* Dummy values *)\n { sub_windows_per_window = 0\n ; ledger_depth = 0\n ; work_delay = 0\n ; block_window_duration_ms = 0\n ; transaction_capacity = Log_2 0\n ; pending_coinbase_depth = 0\n ; coinbase_amount = Unsigned.UInt64.of_int 0\n ; supercharged_coinbase_factor = 0\n ; account_creation_fee = Unsigned.UInt64.of_int 0\n ; fork = None\n }\n ~choices:(fun ~self:_ ->\n [ { identifier = \"main\"\n ; prevs = []\n ; feature_flags = Plonk_types.Features.none_bool\n ; main =\n (fun { public_input = self } ->\n dummy_constraints () ;\n Field.Assert.equal self Field.zero ;\n { previous_proof_statements = []\n ; public_output = ()\n ; auxiliary_output = ()\n } )\n }\n ] ) )\n\n module Proof = (val p)\n\n let example =\n let (), (), b0 =\n Common.time \"b0\" (fun () ->\n Promise.block_on_async_exn (fun () -> step Field.Constant.zero) )\n in\n Or_error.ok_exn\n (Promise.block_on_async_exn (fun () ->\n Proof.verify_promise [ (Field.Constant.zero, b0) ] ) ) ;\n (Field.Constant.zero, b0)\n\n let example_input, example_proof = example\n end\n\n module Fake_2_recursion = struct\n let[@warning \"-45\"] tag, _, p, Provers.[ step ] =\n Common.time \"compile\" (fun () ->\n compile_promise () ~public_input:(Input Field.typ)\n ~override_wrap_domain:Pickles_base.Proofs_verified.N1\n ~auxiliary_typ:Typ.unit\n ~branches:(module Nat.N1)\n ~max_proofs_verified:(module Nat.N2)\n ~name:\"blockchain-snark\"\n ~constraint_constants:\n (* Dummy values *)\n { sub_windows_per_window = 0\n ; ledger_depth = 0\n ; work_delay = 0\n ; block_window_duration_ms = 0\n ; transaction_capacity = Log_2 0\n ; pending_coinbase_depth = 0\n ; coinbase_amount = Unsigned.UInt64.of_int 0\n ; supercharged_coinbase_factor = 0\n ; account_creation_fee = Unsigned.UInt64.of_int 0\n ; fork = None\n }\n ~choices:(fun ~self:_ ->\n [ { identifier = \"main\"\n ; prevs = []\n ; feature_flags = Plonk_types.Features.none_bool\n ; main =\n (fun { public_input = self } ->\n dummy_constraints () ;\n Field.Assert.equal self Field.zero ;\n { previous_proof_statements = []\n ; public_output = ()\n ; auxiliary_output = ()\n } )\n }\n ] ) )\n\n module Proof = (val p)\n\n let example =\n let (), (), b0 =\n Common.time \"b0\" (fun () ->\n Promise.block_on_async_exn (fun () -> step Field.Constant.zero) )\n in\n Or_error.ok_exn\n (Promise.block_on_async_exn (fun () ->\n Proof.verify_promise [ (Field.Constant.zero, b0) ] ) ) ;\n (Field.Constant.zero, b0)\n\n let example_input, example_proof = example\n end\n\n [@@@warning \"-60\"]\n\n module Simple_chain = struct\n type _ Snarky_backendless.Request.t +=\n | Prev_input : Field.Constant.t Snarky_backendless.Request.t\n | Proof : Side_loaded.Proof.t Snarky_backendless.Request.t\n | Verifier_index :\n Side_loaded.Verification_key.t Snarky_backendless.Request.t\n\n let handler (prev_input : Field.Constant.t) (proof : _ Proof.t)\n (verifier_index : Side_loaded.Verification_key.t)\n (Snarky_backendless.Request.With { request; respond }) =\n match request with\n | Prev_input ->\n respond (Provide prev_input)\n | Proof ->\n respond (Provide proof)\n | Verifier_index ->\n respond (Provide verifier_index)\n | _ ->\n respond Unhandled\n\n let side_loaded_tag =\n Side_loaded.create ~name:\"foo\"\n ~max_proofs_verified:(Nat.Add.create Nat.N2.n)\n ~feature_flags:Plonk_types.Features.none ~typ:Field.typ\n\n let[@warning \"-45\"] _tag, _, p, Provers.[ step ] =\n Common.time \"compile\" (fun () ->\n compile_promise () ~public_input:(Input Field.typ)\n ~auxiliary_typ:Typ.unit\n ~branches:(module Nat.N1)\n ~max_proofs_verified:(module Nat.N1)\n ~name:\"blockchain-snark\"\n ~constraint_constants:\n (* Dummy values *)\n { sub_windows_per_window = 0\n ; ledger_depth = 0\n ; work_delay = 0\n ; block_window_duration_ms = 0\n ; transaction_capacity = Log_2 0\n ; pending_coinbase_depth = 0\n ; coinbase_amount = Unsigned.UInt64.of_int 0\n ; supercharged_coinbase_factor = 0\n ; account_creation_fee = Unsigned.UInt64.of_int 0\n ; fork = None\n }\n ~choices:(fun ~self:_ ->\n [ { identifier = \"main\"\n ; prevs = [ side_loaded_tag ]\n ; feature_flags = Plonk_types.Features.none_bool\n ; main =\n (fun { public_input = self } ->\n let prev =\n exists Field.typ ~request:(fun () -> Prev_input)\n in\n let proof =\n exists (Typ.Internal.ref ()) ~request:(fun () ->\n Proof )\n in\n let vk =\n exists (Typ.Internal.ref ()) ~request:(fun () ->\n Verifier_index )\n in\n as_prover (fun () ->\n let vk = As_prover.Ref.get vk in\n Side_loaded.in_prover side_loaded_tag vk ) ;\n let vk =\n exists Side_loaded_verification_key.typ\n ~compute:(fun () -> As_prover.Ref.get vk)\n in\n Side_loaded.in_circuit side_loaded_tag vk ;\n let is_base_case = Field.equal Field.zero self in\n let self_correct = Field.(equal (one + prev) self) in\n Boolean.Assert.any [ self_correct; is_base_case ] ;\n { previous_proof_statements =\n [ { public_input = prev\n ; proof\n ; proof_must_verify = Boolean.true_\n }\n ]\n ; public_output = ()\n ; auxiliary_output = ()\n } )\n }\n ] ) )\n\n module Proof = (val p)\n\n let _example1 =\n let (), (), b1 =\n Common.time \"b1\" (fun () ->\n Promise.block_on_async_exn (fun () ->\n step\n ~handler:\n (handler No_recursion.example_input\n (Side_loaded.Proof.of_proof\n No_recursion.example_proof )\n (Side_loaded.Verification_key.of_compiled\n No_recursion.tag ) )\n Field.Constant.one ) )\n in\n Or_error.ok_exn\n (Promise.block_on_async_exn (fun () ->\n Proof.verify_promise [ (Field.Constant.one, b1) ] ) ) ;\n (Field.Constant.one, b1)\n\n let _example2 =\n let (), (), b2 =\n Common.time \"b2\" (fun () ->\n Promise.block_on_async_exn (fun () ->\n step\n ~handler:\n (handler Fake_1_recursion.example_input\n (Side_loaded.Proof.of_proof\n Fake_1_recursion.example_proof )\n (Side_loaded.Verification_key.of_compiled\n Fake_1_recursion.tag ) )\n Field.Constant.one ) )\n in\n Or_error.ok_exn\n (Promise.block_on_async_exn (fun () ->\n Proof.verify_promise [ (Field.Constant.one, b2) ] ) ) ;\n (Field.Constant.one, b2)\n\n let _example3 =\n let (), (), b3 =\n Common.time \"b3\" (fun () ->\n Promise.block_on_async_exn (fun () ->\n step\n ~handler:\n (handler Fake_2_recursion.example_input\n (Side_loaded.Proof.of_proof\n Fake_2_recursion.example_proof )\n (Side_loaded.Verification_key.of_compiled\n Fake_2_recursion.tag ) )\n Field.Constant.one ) )\n in\n Or_error.ok_exn\n (Promise.block_on_async_exn (fun () ->\n Proof.verify_promise [ (Field.Constant.one, b3) ] ) ) ;\n (Field.Constant.one, b3)\n end\n end )\n\n let%test_module \"side-loaded with feature flags\" =\n ( module struct\n open Impls.Step\n\n [@@@warning \"-60\"]\n\n module Statement = struct\n [@@@warning \"-32-34\"]\n\n type t = Field.t\n\n let to_field_elements x = [| x |]\n\n module Constant = struct\n type t = Field.Constant.t [@@deriving bin_io]\n\n [@@@warning \"-32\"]\n\n let to_field_elements x = [| x |]\n end\n end\n\n (* Currently, a circuit must have at least 1 of every type of constraint. *)\n let dummy_constraints () =\n Impl.(\n let x =\n exists Field.typ ~compute:(fun () -> Field.Constant.of_int 3)\n in\n let g =\n exists Step_main_inputs.Inner_curve.typ ~compute:(fun _ ->\n Tick.Inner_curve.(to_affine_exn one) )\n in\n ignore\n ( SC.to_field_checked'\n (module Impl)\n ~num_bits:16\n (Kimchi_backend_common.Scalar_challenge.create x)\n : Field.t * Field.t * Field.t ) ;\n ignore\n ( Step_main_inputs.Ops.scale_fast g ~num_bits:5 (Shifted_value x)\n : Step_main_inputs.Inner_curve.t ) ;\n ignore\n ( Step_main_inputs.Ops.scale_fast g ~num_bits:5 (Shifted_value x)\n : Step_main_inputs.Inner_curve.t ) ;\n ignore\n ( Step_verifier.Scalar_challenge.endo g ~num_bits:4\n (Kimchi_backend_common.Scalar_challenge.create x)\n : Field.t * Field.t ))\n\n module No_recursion = struct\n let[@warning \"-45\"] tag, _, p, Provers.[ step ] =\n Common.time \"compile\" (fun () ->\n compile_promise () ~public_input:(Input Field.typ)\n ~auxiliary_typ:Typ.unit\n ~branches:(module Nat.N1)\n ~max_proofs_verified:(module Nat.N0)\n ~name:\"blockchain-snark\"\n ~constraint_constants:\n (* Dummy values *)\n { sub_windows_per_window = 0\n ; ledger_depth = 0\n ; work_delay = 0\n ; block_window_duration_ms = 0\n ; transaction_capacity = Log_2 0\n ; pending_coinbase_depth = 0\n ; coinbase_amount = Unsigned.UInt64.of_int 0\n ; supercharged_coinbase_factor = 0\n ; account_creation_fee = Unsigned.UInt64.of_int 0\n ; fork = None\n }\n ~choices:(fun ~self:_ ->\n [ { identifier = \"main\"\n ; prevs = []\n ; feature_flags = Plonk_types.Features.none_bool\n ; main =\n (fun { public_input = self } ->\n dummy_constraints () ;\n Field.Assert.equal self Field.zero ;\n { previous_proof_statements = []\n ; public_output = ()\n ; auxiliary_output = ()\n } )\n }\n ] ) )\n\n module Proof = (val p)\n\n let example =\n let (), (), b0 =\n Common.time \"b0\" (fun () ->\n Promise.block_on_async_exn (fun () -> step Field.Constant.zero) )\n in\n Or_error.ok_exn\n (Promise.block_on_async_exn (fun () ->\n Proof.verify_promise [ (Field.Constant.zero, b0) ] ) ) ;\n (Field.Constant.zero, b0)\n\n let example_input, example_proof = example\n end\n\n module Fake_1_recursion = struct\n let[@warning \"-45\"] tag, _, p, Provers.[ step ] =\n Common.time \"compile\" (fun () ->\n compile_promise () ~public_input:(Input Field.typ)\n ~auxiliary_typ:Typ.unit\n ~branches:(module Nat.N1)\n ~max_proofs_verified:(module Nat.N1)\n ~name:\"blockchain-snark\"\n ~constraint_constants:\n (* Dummy values *)\n { sub_windows_per_window = 0\n ; ledger_depth = 0\n ; work_delay = 0\n ; block_window_duration_ms = 0\n ; transaction_capacity = Log_2 0\n ; pending_coinbase_depth = 0\n ; coinbase_amount = Unsigned.UInt64.of_int 0\n ; supercharged_coinbase_factor = 0\n ; account_creation_fee = Unsigned.UInt64.of_int 0\n ; fork = None\n }\n ~choices:(fun ~self:_ ->\n [ { identifier = \"main\"\n ; prevs = []\n ; feature_flags = Plonk_types.Features.none_bool\n ; main =\n (fun { public_input = self } ->\n dummy_constraints () ;\n Field.Assert.equal self Field.zero ;\n { previous_proof_statements = []\n ; public_output = ()\n ; auxiliary_output = ()\n } )\n }\n ] ) )\n\n module Proof = (val p)\n\n let example =\n let (), (), b0 =\n Common.time \"b0\" (fun () ->\n Promise.block_on_async_exn (fun () -> step Field.Constant.zero) )\n in\n Or_error.ok_exn\n (Promise.block_on_async_exn (fun () ->\n Proof.verify_promise [ (Field.Constant.zero, b0) ] ) ) ;\n (Field.Constant.zero, b0)\n\n let example_input, example_proof = example\n end\n\n module Fake_2_recursion = struct\n let[@warning \"-45\"] tag, _, p, Provers.[ step ] =\n Common.time \"compile\" (fun () ->\n compile_promise () ~public_input:(Input Field.typ)\n ~override_wrap_domain:Pickles_base.Proofs_verified.N1\n ~auxiliary_typ:Typ.unit\n ~branches:(module Nat.N1)\n ~max_proofs_verified:(module Nat.N2)\n ~name:\"blockchain-snark\"\n ~constraint_constants:\n (* Dummy values *)\n { sub_windows_per_window = 0\n ; ledger_depth = 0\n ; work_delay = 0\n ; block_window_duration_ms = 0\n ; transaction_capacity = Log_2 0\n ; pending_coinbase_depth = 0\n ; coinbase_amount = Unsigned.UInt64.of_int 0\n ; supercharged_coinbase_factor = 0\n ; account_creation_fee = Unsigned.UInt64.of_int 0\n ; fork = None\n }\n ~choices:(fun ~self:_ ->\n [ { identifier = \"main\"\n ; prevs = []\n ; feature_flags = Plonk_types.Features.none_bool\n ; main =\n (fun { public_input = self } ->\n dummy_constraints () ;\n Field.Assert.equal self Field.zero ;\n { previous_proof_statements = []\n ; public_output = ()\n ; auxiliary_output = ()\n } )\n }\n ] ) )\n\n module Proof = (val p)\n\n let example =\n let (), (), b0 =\n Common.time \"b0\" (fun () ->\n Promise.block_on_async_exn (fun () -> step Field.Constant.zero) )\n in\n Or_error.ok_exn\n (Promise.block_on_async_exn (fun () ->\n Proof.verify_promise [ (Field.Constant.zero, b0) ] ) ) ;\n (Field.Constant.zero, b0)\n\n let example_input, example_proof = example\n end\n\n [@@@warning \"-60\"]\n\n module Simple_chain = struct\n type _ Snarky_backendless.Request.t +=\n | Prev_input : Field.Constant.t Snarky_backendless.Request.t\n | Proof : Side_loaded.Proof.t Snarky_backendless.Request.t\n | Verifier_index :\n Side_loaded.Verification_key.t Snarky_backendless.Request.t\n\n let handler (prev_input : Field.Constant.t) (proof : _ Proof.t)\n (verifier_index : Side_loaded.Verification_key.t)\n (Snarky_backendless.Request.With { request; respond }) =\n match request with\n | Prev_input ->\n respond (Provide prev_input)\n | Proof ->\n respond (Provide proof)\n | Verifier_index ->\n respond (Provide verifier_index)\n | _ ->\n respond Unhandled\n\n let maybe_features =\n Plonk_types.Features.(\n map none ~f:(fun _ -> Plonk_types.Opt.Flag.Maybe))\n\n let side_loaded_tag =\n Side_loaded.create ~name:\"foo\"\n ~max_proofs_verified:(Nat.Add.create Nat.N2.n)\n ~feature_flags:maybe_features ~typ:Field.typ\n\n let[@warning \"-45\"] _tag, _, p, Provers.[ step ] =\n Common.time \"compile\" (fun () ->\n compile_promise () ~public_input:(Input Field.typ)\n ~auxiliary_typ:Typ.unit\n ~branches:(module Nat.N1)\n ~max_proofs_verified:(module Nat.N1)\n ~name:\"blockchain-snark\"\n ~constraint_constants:\n (* Dummy values *)\n { sub_windows_per_window = 0\n ; ledger_depth = 0\n ; work_delay = 0\n ; block_window_duration_ms = 0\n ; transaction_capacity = Log_2 0\n ; pending_coinbase_depth = 0\n ; coinbase_amount = Unsigned.UInt64.of_int 0\n ; supercharged_coinbase_factor = 0\n ; account_creation_fee = Unsigned.UInt64.of_int 0\n ; fork = None\n }\n ~choices:(fun ~self:_ ->\n [ { identifier = \"main\"\n ; prevs = [ side_loaded_tag ]\n ; feature_flags = Plonk_types.Features.none_bool\n ; main =\n (fun { public_input = self } ->\n let prev =\n exists Field.typ ~request:(fun () -> Prev_input)\n in\n let proof =\n exists (Typ.Internal.ref ()) ~request:(fun () ->\n Proof )\n in\n let vk =\n exists (Typ.Internal.ref ()) ~request:(fun () ->\n Verifier_index )\n in\n as_prover (fun () ->\n let vk = As_prover.Ref.get vk in\n Side_loaded.in_prover side_loaded_tag vk ) ;\n let vk =\n exists Side_loaded_verification_key.typ\n ~compute:(fun () -> As_prover.Ref.get vk)\n in\n Side_loaded.in_circuit side_loaded_tag vk ;\n let is_base_case = Field.equal Field.zero self in\n let self_correct = Field.(equal (one + prev) self) in\n Boolean.Assert.any [ self_correct; is_base_case ] ;\n { previous_proof_statements =\n [ { public_input = prev\n ; proof\n ; proof_must_verify = Boolean.true_\n }\n ]\n ; public_output = ()\n ; auxiliary_output = ()\n } )\n }\n ] ) )\n\n module Proof = (val p)\n\n let _example1 =\n let (), (), b1 =\n Common.time \"b1\" (fun () ->\n Promise.block_on_async_exn (fun () ->\n step\n ~handler:\n (handler No_recursion.example_input\n (Side_loaded.Proof.of_proof\n No_recursion.example_proof )\n (Side_loaded.Verification_key.of_compiled\n No_recursion.tag ) )\n Field.Constant.one ) )\n in\n Or_error.ok_exn\n (Promise.block_on_async_exn (fun () ->\n Proof.verify_promise [ (Field.Constant.one, b1) ] ) ) ;\n (Field.Constant.one, b1)\n\n let _example2 =\n let (), (), b2 =\n Common.time \"b2\" (fun () ->\n Promise.block_on_async_exn (fun () ->\n step\n ~handler:\n (handler Fake_1_recursion.example_input\n (Side_loaded.Proof.of_proof\n Fake_1_recursion.example_proof )\n (Side_loaded.Verification_key.of_compiled\n Fake_1_recursion.tag ) )\n Field.Constant.one ) )\n in\n Or_error.ok_exn\n (Promise.block_on_async_exn (fun () ->\n Proof.verify_promise [ (Field.Constant.one, b2) ] ) ) ;\n (Field.Constant.one, b2)\n\n let _example3 =\n let (), (), b3 =\n Common.time \"b3\" (fun () ->\n Promise.block_on_async_exn (fun () ->\n step\n ~handler:\n (handler Fake_2_recursion.example_input\n (Side_loaded.Proof.of_proof\n Fake_2_recursion.example_proof )\n (Side_loaded.Verification_key.of_compiled\n Fake_2_recursion.tag ) )\n Field.Constant.one ) )\n in\n Or_error.ok_exn\n (Promise.block_on_async_exn (fun () ->\n Proof.verify_promise [ (Field.Constant.one, b3) ] ) ) ;\n (Field.Constant.one, b3)\n end\n end )\nend\n\ninclude Wire_types.Make (Make_sig) (Make_str)\n","open Core_kernel\nmodule H_list = Snarky_backendless.H_list\n\n[%%versioned\nmodule Stable = struct\n module V2 = struct\n type 'comm t =\n { sigma_comm : 'comm Plonk_types.Permuts_vec.Stable.V1.t\n ; coefficients_comm : 'comm Plonk_types.Columns_vec.Stable.V1.t\n ; generic_comm : 'comm\n ; psm_comm : 'comm\n ; complete_add_comm : 'comm\n ; mul_comm : 'comm\n ; emul_comm : 'comm\n ; endomul_scalar_comm : 'comm\n }\n [@@deriving sexp, equal, compare, hash, yojson, hlist, fields]\n (* TODO: Remove unused annotations *)\n end\nend]\n\n(* TODO: Remove unused functions *)\n\nlet map\n { sigma_comm\n ; coefficients_comm\n ; generic_comm\n ; psm_comm\n ; complete_add_comm\n ; mul_comm\n ; emul_comm\n ; endomul_scalar_comm\n } ~f =\n { sigma_comm = Vector.map ~f sigma_comm\n ; coefficients_comm = Vector.map ~f coefficients_comm\n ; generic_comm = f generic_comm\n ; psm_comm = f psm_comm\n ; complete_add_comm = f complete_add_comm\n ; mul_comm = f mul_comm\n ; emul_comm = f emul_comm\n ; endomul_scalar_comm = f endomul_scalar_comm\n }\n\nlet map2 t1 t2 ~f =\n { sigma_comm = Vector.map2 ~f t1.sigma_comm t2.sigma_comm\n ; coefficients_comm = Vector.map2 ~f t1.coefficients_comm t2.coefficients_comm\n ; generic_comm = f t1.generic_comm t2.generic_comm\n ; psm_comm = f t1.psm_comm t2.psm_comm\n ; complete_add_comm = f t1.complete_add_comm t2.complete_add_comm\n ; mul_comm = f t1.mul_comm t2.mul_comm\n ; emul_comm = f t1.emul_comm t2.emul_comm\n ; endomul_scalar_comm = f t1.endomul_scalar_comm t2.endomul_scalar_comm\n }\n\nlet typ g =\n Snarky_backendless.Typ.of_hlistable\n [ Vector.typ g Plonk_types.Permuts.n\n ; Vector.typ g Plonk_types.Columns.n\n ; g\n ; g\n ; g\n ; g\n ; g\n ; g\n ]\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist\n","open Core_kernel\n\ntype ('a, 'n, 'm) t =\n { without_degree_bound : 'n Nat.t; with_degree_bound : ('a, 'm) Vector.t }\n\nlet map t ~f = { t with with_degree_bound = Vector.map t.with_degree_bound ~f }\n\nlet num_bits n = Int.floor_log2 n + 1\n\nlet%test_unit \"num_bits\" =\n let naive n =\n let rec go k =\n (* [Invalid_argument] represents an overflow, which is certainly bigger\n than any given value.\n *)\n let n_lt_2k = try n < Int.pow 2 k with Invalid_argument _ -> true in\n if n_lt_2k then k else go (k + 1)\n in\n go 0\n in\n Quickcheck.test (Int.gen_uniform_incl 0 Int.max_value) ~f:(fun n ->\n [%test_eq: int] (num_bits n) (naive n) )\n\nlet pow ~one ~mul x n =\n assert (n >= 0) ;\n let k = num_bits n in\n let rec go acc i =\n if i < 0 then acc\n else\n let acc = mul acc acc in\n let b = (n lsr i) land 1 = 1 in\n let acc = if b then mul x acc else acc in\n go acc (i - 1)\n in\n go one (k - 1)\n\nlet create ~without_degree_bound ~with_degree_bound =\n { without_degree_bound; with_degree_bound }\n\nlet combine_commitments _t ~scale ~add ~xi (type n)\n (without_degree_bound : (_, n) Vector.t) with_degree_bound =\n match without_degree_bound with\n | [] ->\n failwith \"combine_commitments: empty list\"\n | init :: without_degree_bound ->\n let polys =\n Vector.to_list without_degree_bound\n @ List.concat_map (Vector.to_list with_degree_bound)\n ~f:(fun (unshifted, shifted) -> [ unshifted; shifted ])\n in\n List.fold_left polys ~init ~f:(fun acc p -> add p (scale acc xi))\n\nlet combine_evaluations' (type a n m)\n ({ without_degree_bound = _; with_degree_bound } : (a, n Nat.s, m) t)\n ~shifted_pow ~mul ~add ~one:_ ~evaluation_point ~xi\n (init :: evals0 : (_, n Nat.s) Vector.t) (evals1 : (_, m) Vector.t) =\n let evals =\n Vector.to_list evals0\n @ List.concat\n (Vector.to_list\n (Vector.map2 with_degree_bound evals1 ~f:(fun deg fx ->\n [ fx; mul (shifted_pow deg evaluation_point) fx ] ) ) )\n in\n List.fold_left evals ~init ~f:(fun acc fx -> add fx (mul acc xi))\n\nlet[@warning \"-45\"] combine_evaluations' (type n) (t : (_, n, _) t) ~shifted_pow\n ~mul ~add ~one ~evaluation_point ~xi (evals0 : (_, n) Vector.t) evals1 =\n match evals0 with\n | Vector.[] ->\n failwith \"Empty evals0\"\n | _ :: _ ->\n combine_evaluations' t ~shifted_pow ~mul ~add ~one ~evaluation_point ~xi\n evals0 evals1\n\nlet combine_evaluations (type f) t ~crs_max_degree ~(mul : f -> f -> f) ~add\n ~one ~evaluation_point ~xi evals0 evals1 =\n let pow = pow ~one ~mul in\n combine_evaluations' t evals0 evals1\n ~shifted_pow:(fun deg x -> pow x (crs_max_degree - deg))\n ~mul ~add ~one ~evaluation_point ~xi\n\nopen Plonk_types.Poly_comm\n\nlet combine_split_commitments _t ~scale_and_add ~init:i ~xi (type n)\n (without_degree_bound : (_, n) Vector.t) with_degree_bound =\n let flat =\n List.concat_map (Vector.to_list without_degree_bound) ~f:Array.to_list\n @ List.concat_map (Vector.to_list with_degree_bound)\n ~f:(fun { With_degree_bound.unshifted; shifted } ->\n Array.to_list unshifted @ [ shifted ] )\n in\n match List.rev flat with\n | [] ->\n failwith \"combine_split_commitments: empty\"\n | init :: comms ->\n List.fold_left comms ~init:(i init) ~f:(fun acc p ->\n scale_and_add ~acc ~xi p )\n\nlet combine_split_evaluations (type f f')\n ~(mul_and_add : acc:f' -> xi:f' -> f -> f') ~init:(i : f -> f') ~(xi : f')\n (evals0 : f array list) : f' =\n let flat = List.concat_map evals0 ~f:Array.to_list in\n match List.rev flat with\n | [] ->\n failwith \"combine_split_evaluations: empty\"\n | init :: es ->\n List.fold_left es ~init:(i init) ~f:(fun acc fx ->\n mul_and_add ~acc ~xi fx )\n","open Core_kernel\nmodule Intf = Intf\n\nmodule Params = struct\n include Params\n\n let bn128 = Constants.params_Bn128\n\n let mnt4_298 = Constants.params_Mnt4_298\n\n let mnt4_753 = Constants.params_Mnt4_753\n\n let bn382_p = Constants.params_Bn382_p\n\n let bn382_q = Constants.params_Bn382_q\n\n let tweedle_p = Constants.params_Tweedle_p\n\n let tweedle_q = Constants.params_Tweedle_q\n\n let pasta_p_legacy = Constants.params_Pasta_p_legacy\n\n let pasta_q_legacy = Constants.params_Pasta_q_legacy\n\n let pasta_p_kimchi = Constants.params_Pasta_p_kimchi\n\n let pasta_q_kimchi = Constants.params_Pasta_q_kimchi\nend\n\nmodule State = Array\n\nlet for_ n ~init ~f =\n let rec go i acc = if Int.(i = n) then acc else go (i + 1) (f i acc) in\n go 0 init\n\nmodule Make_operations (Field : Intf.Field) = struct\n let add_assign ~state i x = state.(i) <- Field.( + ) state.(i) x\n\n let apply_affine_map (matrix, constants) v =\n let dotv row =\n Array.reduce_exn (Array.map2_exn row v ~f:Field.( * )) ~f:Field.( + )\n in\n let res = Array.map matrix ~f:dotv in\n for i = 0 to Array.length res - 1 do\n res.(i) <- Field.( + ) res.(i) constants.(i)\n done ;\n res\n\n let copy = Array.copy\nend\n\nlet m = 3\n\nmodule Bn382_inputs (Field : Intf.Field_mutable) = struct\n let rounds_full = 8\n\n let initial_ark = true\n\n let rounds_partial = 30\n\n module Field = Field\n\n let alpha = 17\n\n (* alpha = 17 *)\n let to_the_alpha x =\n let open Field in\n let res = square x in\n Mutable.square res ;\n (* x^4 *)\n Mutable.square res ;\n (* x^8 *)\n Mutable.square res ;\n (* x^16 *)\n res *= x ;\n res\n\n module Operations = struct\n let add_assign ~state i x = Field.(state.(i) += x)\n\n (* Sparse pseudo-MDS matrix *)\n let apply_affine_map (_rows, c) v =\n let open Field in\n let res = [| v.(0) + v.(2); v.(0) + v.(1); v.(1) + v.(2) |] in\n Array.iteri res ~f:(fun i ri -> ri += c.(i)) ;\n res\n\n let copy a = Array.map a ~f:(fun x -> Field.(x + zero))\n end\nend\n\nmodule Rescue (Inputs : Intf.Inputs.Rescue) = struct\n (*\n We refer below to this paper: https://eprint.iacr.org/2019/426.pdf.\n\nI arrived at this value for the number of rounds in the following way.\nAs mentioned on page 34, the cost of performing the Grobner basis attack is estimated as\n\n( (n + d) choose d ) ^ omega\nwhere\n\n- omega is some number which is known to be >= 2\n- n = 1 + m*N is the number of variables in the system of equations on page 3\n- d is a quantity which they estimate as ((alpha - 1)(m*N + 1) + 1) / 2\n- m is the state size, which we can choose\n- N is the number of rounds which we can choose\n\nFor the MNT curves, `alpha = 11`, and I took `m = 3` which is optimal for binary Merkle trees.\nEvaluating the above formula with these values and `N = 11` and `omega = 2` yields an attack complexity\nof a little over 2^257, which if we take the same factor of 2 security margin as they use in the paper,\ngives us a security level of 257/2 ~= 128.\n\nNB: As you can see from the analysis this is really specialized to alpha = 11 and the number of rounds\nshould be higher for smaller alpha.\n*)\n\n open Inputs\n include Operations\n module Field = Field\n\n let sbox0, sbox1 = (alphath_root, to_the_alpha)\n\n let add_block ~state block = Array.iteri block ~f:(add_assign ~state)\n\n let block_cipher { Params.round_constants; mds } state =\n add_block ~state round_constants.(0) ;\n for_ (2 * rounds) ~init:state ~f:(fun r state ->\n let sbox = if Int.(r mod 2 = 0) then sbox0 else sbox1 in\n Array.map_inplace state ~f:sbox ;\n apply_affine_map (mds, round_constants.(r + 1)) state )\nend\n\nmodule Poseidon (Inputs : Intf.Inputs.Poseidon) = struct\n open Inputs\n include Operations\n module Field = Field\n\n let first_half_rounds_full = rounds_full / 2\n\n let add_block ~state block = Array.iteri block ~f:(add_assign ~state)\n\n (* Poseidon goes\n\n ARK_0 -> SBOX -> MDS\n -> ARK_1 -> SBOX -> MDS\n -> ...\n -> ARK_{half_rounds_full - 1} -> SBOX -> MDS\n -> ARK_{half_rounds_full} -> SBOX0 -> MDS\n -> ...\n -> ARK_{half_rounds_full + rounds_partial - 1} -> SBOX0 -> MDS\n -> ARK_{half_rounds_full + rounds_partial} -> SBOX -> MDS\n -> ...\n -> ARK_{half_rounds_full + rounds_partial + half_rounds_full - 1} -> SBOX -> MDS\n\n It is best to apply the matrix and add the round constants at the same\n time for Marlin constraint efficiency, so that is how this implementation does it.\n Like,\n\n ARK_0\n -> SBOX -> (MDS -> ARK_1)\n -> SBOX -> (MDS -> ARK_2)\n -> ...\n -> SBOX -> (MDS -> ARK_{half_rounds_full - 1})\n -> SBOX -> (MDS -> ARK_{half_rounds_full})\n -> SBOX0 -> (MDS -> ARK_{half_rounds_full + 1})\n -> ...\n -> SBOX0 -> (MDS -> ARK_{half_rounds_full + rounds_partial - 1})\n -> SBOX0 -> (MDS -> ARK_{half_rounds_full + rounds_partial})\n -> SBOX -> (MDS -> ARK_{half_rounds_full + rounds_partial + 1})\n -> ...\n -> SBOX -> (MDS -> ARK_{half_rounds_full + rounds_partial + half_rounds_full - 1})\n -> SBOX -> MDS ->* ARK_{half_rounds_full + rounds_partial + half_rounds_full}\n\n *this last round is a deviation from standard poseidon made for efficiency reasons.\n clearly it does not impact security to add round constants\n *)\n let block_cipher { Params.round_constants; mds } state =\n let sbox = to_the_alpha in\n let state = ref state in\n let constant_offset =\n if initial_ark then (\n add_block ~state:!state round_constants.(0) ;\n 1 )\n else 0\n in\n let range =\n (constant_offset, constant_offset + first_half_rounds_full - 1)\n in\n for i = fst range to snd range do\n (* SBOX -> MDS -> ARK *)\n Array.map_inplace !state ~f:sbox ;\n state := apply_affine_map (mds, round_constants.(i)) !state\n done ;\n let range = (snd range + 1, snd range + rounds_partial) in\n for i = fst range to snd range do\n !state.(0) <- sbox !state.(0) ;\n state := apply_affine_map (mds, round_constants.(i)) !state\n done ;\n let second_half_rounds_full = rounds_full - first_half_rounds_full in\n let range = (snd range + 1, snd range + second_half_rounds_full) in\n for i = fst range to snd range do\n Array.map_inplace !state ~f:sbox ;\n state := apply_affine_map (mds, round_constants.(i)) !state\n done ;\n !state\nend\n\nmodule Make_hash (P : Intf.Permutation) = struct\n open P\n\n let state_size = m\n\n let rate = state_size - 1\n\n let add_block ~state block = Array.iteri block ~f:(add_assign ~state)\n\n let sponge perm blocks ~state =\n Array.fold ~init:state blocks ~f:(fun state block ->\n add_block ~state block ; perm state )\n\n (* takes an array of field elements, and spread them into blocks/arrays that can contain [rate] fied elements *)\n let to_blocks rate field_elems =\n let n = Array.length field_elems in\n let num_blocks = if n = 0 then 1 else (n + rate - 1) / rate in\n let fill_block block_idx pos =\n let global_pos = (rate * block_idx) + pos in\n if global_pos < n then field_elems.(global_pos)\n else (* padding *) Field.zero\n in\n let create_block idx = Array.init rate ~f:(fill_block idx) in\n Array.init num_blocks ~f:create_block\n\n let%test_unit \"empty field_elems to_blocks\" =\n let blocks = to_blocks 2 [||] in\n assert (Array.length blocks = 1) ;\n [%test_eq: unit array array]\n (Array.map blocks ~f:(Array.map ~f:ignore))\n [| [| (); () |] |]\n\n let%test_unit \"block\" =\n let z = Field.zero in\n [%test_eq: unit array array]\n (Array.map (to_blocks 2 [| z; z; z |]) ~f:(Array.map ~f:ignore))\n [| [| (); () |]; [| (); () |] |]\n\n let update params ~state inputs =\n let state = copy state in\n sponge (block_cipher params) (to_blocks rate inputs) ~state\n\n let digest state = state.(0)\n\n let initial_state = Array.init state_size ~f:(fun _ -> Field.zero)\n\n let hash ?(init = initial_state) params inputs =\n update params ~state:init inputs |> digest\nend\n\ntype sponge_state = Absorbed of int | Squeezed of int [@@deriving sexp]\n\ntype 'f t =\n { mutable state : 'f State.t\n ; params : 'f Params.t\n ; mutable sponge_state : sponge_state\n ; id : int\n }\n\nlet id = ref (-1)\n\nlet make ~state ~params ~sponge_state =\n incr id ;\n { state; params; sponge_state; id = !id }\n\nmodule Make_sponge (P : Intf.Permutation) = struct\n open P\n\n let make = make\n\n let capacity = 1\n\n type sponge_state = Absorbed of int | Squeezed of int [@@deriving sexp]\n\n type nonrec t = Field.t t\n\n let state { state; _ } = copy state\n\n let initial_state = Array.init m ~f:(fun _ -> Field.zero)\n\n let create ?(init = initial_state) params =\n make ~state:(copy init) ~sponge_state:(Absorbed 0) ~params\n\n let copy { state; params; sponge_state; id } =\n { state = copy state; params; sponge_state; id }\n\n let rate = m - capacity\n\n let absorb t x =\n match t.sponge_state with\n | Absorbed n ->\n if n = rate then (\n t.state <- block_cipher t.params t.state ;\n add_assign ~state:t.state 0 x ;\n t.sponge_state <- Absorbed 1 )\n else (\n add_assign ~state:t.state n x ;\n t.sponge_state <- Absorbed (n + 1) )\n | Squeezed _ ->\n add_assign ~state:t.state 0 x ;\n t.sponge_state <- Absorbed 1\n\n let squeeze t =\n match t.sponge_state with\n | Squeezed n ->\n if n = rate then (\n t.state <- block_cipher t.params t.state ;\n t.sponge_state <- Squeezed 1 ;\n t.state.(0) )\n else (\n t.sponge_state <- Squeezed (n + 1) ;\n t.state.(n) )\n | Absorbed _ ->\n t.state <- block_cipher t.params t.state ;\n t.sponge_state <- Squeezed 1 ;\n t.state.(0)\nend\n\nmodule Make_debug_sponge (P : sig\n include Intf.Permutation\n\n module Circuit : Snarky_backendless.Snark_intf.Run\n\n val sponge_name : string\n\n val debug_helper_fn : Field.t -> string\nend) =\nstruct\n include Make_sponge (P)\n\n (* In sponge debug mode, prints a standard sponge debug line, otherwise does nothing.\n Note: standard sponge debug line must match the output of Kimchi's sponge debug mode *)\n let debug (operation : string) (sponge : t) (input : P.Field.t option) =\n match Sys.getenv_opt P.sponge_name with\n | Some s -> (\n match String.lowercase s with\n | \"t\" | \"1\" | \"true\" ->\n P.Circuit.as_prover (fun () ->\n (* Convert sponge_state to match Rust style debug string *)\n let sponge_state =\n match sponge.sponge_state with\n | Absorbed n ->\n Printf.sprintf \"Absorbed(%d)\" n\n | Squeezed n ->\n Printf.sprintf \"Squeezed(%d)\" n\n in\n (* Print debug header, operation and sponge_state *)\n Format.eprintf \"debug_sponge: %s%d %s state %s\" P.sponge_name\n sponge.id operation sponge_state ;\n (* Print sponge's state array *)\n Array.iter sponge.state ~f:(fun fe ->\n Format.eprintf \" %s\" (P.debug_helper_fn fe) ) ;\n Format.eprintf \"@.\" ;\n (* Print optional input *)\n match input with\n | Some input ->\n Format.eprintf \"debug_sponge: %s%d %s input %s@.\"\n P.sponge_name sponge.id operation\n (P.debug_helper_fn input)\n | None ->\n () )\n | _ ->\n () )\n | None ->\n ()\n\n let make ~state ~params ~sponge_state =\n let t = make ~state ~params ~sponge_state in\n debug \"make\" t None ; t\n\n let absorb t x = debug \"absorb\" t (Some x) ; absorb t x\n\n let squeeze t = debug \"squeeze\" t None ; squeeze t\nend\n\nmodule Bit_sponge = struct\n type ('s, 'bool) t =\n { underlying : 's\n (* TODO: Have to be careful about these bits. They aren't perfectly uniform. *)\n ; mutable last_squeezed : 'bool list\n }\n\n let map (type a b) t ~(f : a -> b) : (b, _) t =\n { t with underlying = f t.underlying }\n\n let make ?(last_squeezed = []) underlying = { underlying; last_squeezed }\n\n let underlying { underlying; last_squeezed = _ } = underlying\n\n module Make\n (Bool : Intf.T) (Field : sig\n type t\n\n val to_bits : t -> Bool.t list\n\n val finalize_discarded : Bool.t list -> unit\n\n val high_entropy_bits : int\n end)\n (Input : Intf.T)\n (S : Intf.Sponge\n with module State := State\n and module Field := Field\n and type digest := Field.t\n and type input := Input.t) =\n struct\n type nonrec t = (S.t, Bool.t) t\n\n let state t = S.state t.underlying\n\n let high_entropy_bits = Field.high_entropy_bits\n\n let create ?init params =\n { underlying = S.create ?init params; last_squeezed = [] }\n\n let copy { underlying; last_squeezed } =\n { underlying = S.copy underlying; last_squeezed }\n\n let absorb t x =\n S.absorb t.underlying x ;\n t.last_squeezed <- []\n\n let rec squeeze t ~length =\n if List.length t.last_squeezed >= length then (\n let digest, remaining = List.split_n t.last_squeezed length in\n t.last_squeezed <- remaining ;\n digest )\n else\n let x = S.squeeze t.underlying in\n let hi =\n let hi, lo = List.split_n (Field.to_bits x) high_entropy_bits in\n Field.finalize_discarded lo ;\n hi\n in\n t.last_squeezed <- t.last_squeezed @ hi ;\n squeeze ~length t\n\n let squeeze_field t =\n t.last_squeezed <- [] ;\n S.squeeze t.underlying\n end\nend\n","open! Core_kernel\nopen! Import\nopen Tuple_pool_intf\nmodule Tuple_type = Tuple_type\n\nlet failwiths = Error.failwiths\nlet phys_equal = Caml.( == )\nlet arch_sixtyfour = Sys.word_size = 64\n\nmodule Int = struct\n let num_bits = Int.num_bits\n let max_value = Caml.max_int\n let to_string = string_of_int\nend\n\nlet sprintf = Printf.sprintf\nlet concat l = Base.String.concat ~sep:\"\" l\n\nmodule type S = S\n\nmodule Pool = struct\n let grow_capacity ~capacity ~old_capacity =\n match capacity with\n | None -> if old_capacity = 0 then 1 else old_capacity * 2\n | Some capacity ->\n if capacity <= old_capacity\n then\n failwiths\n ~here:[%here]\n \"Pool.grow got too small capacity\"\n (`capacity capacity, `old_capacity old_capacity)\n [%sexp_of: [ `capacity of int ] * [ `old_capacity of int ]];\n capacity\n ;;\n\n module Slots = Tuple_type.Slots\n\n let max_slot = 14\n\n (* The pool is represented as a single [Uniform_array.t], where index zero has the\n metadata about the pool and the remaining indices are the tuples layed out one after\n the other. Each tuple takes [1 + slots_per_tuple] indices in the pool, where the\n first index holds a header and the remaining indices hold the tuple's slots:\n\n {v\n | header | s0 | s1 | ... | s |\n v}\n\n A [Pointer.t] to a tuple contains the integer index where its header is, as well as\n (a mask of) the tuple's unique id.\n\n The free tuples are singly linked via the headers.\n\n When a tuple is in use, its header is marked to indicate so, and also to include the\n tuple's unique id. This allows us to check in constant time whether a pointer is\n valid, by comparing the id in the pointer with the id in the header.\n\n When a tuple is not in use, its header is part of the free list, and its tuple slots\n have dummy values of the appropriate types, from the [dummy] tuple supplied to\n [create]. We must have dummy values of the correct type to prevent a segfault in\n code that (mistakenly) uses a pointer to a free tuple.\n\n For [Pool.Unsafe], a slot in a free object is guaranteed to be an int; it must not be\n pointer to prevent a space leak. However, the int in the slot may not represent a\n valid value of the type.\n *)\n\n module Slot = struct\n type ('slots, 'a) t = int [@@deriving sexp_of]\n\n let equal (t1 : (_, _) t) t2 = t1 = t2\n let t0 = 1\n let t1 = 2\n let t2 = 3\n let t3 = 4\n let t4 = 5\n let t5 = 6\n let t6 = 7\n let t7 = 8\n let t8 = 9\n let t9 = 10\n let t10 = 11\n let t11 = 12\n let t12 = 13\n let t13 = 14\n\n let%test _ = t13 = max_slot\n end\n\n (* We only have [Int.num_bits] bits available for pool pointers. The bits of a pool\n pointer encode two things:\n\n - the tuple's array index in the pool\n - the tuple's identifier (not necessarily unique)\n\n We choose [array_index_num_bits] as large as needed for the maximum pool capacity\n that we want to support, and use the remaining [masked_tuple_id_num_bits] bits for\n the identifier. 64-bit and 32-bit architectures typically have very different\n address-space sizes, so we choose [array_index_num_bits] differently. *)\n\n let array_index_num_bits =\n if arch_sixtyfour\n then (\n assert (Int.num_bits = 63);\n 30)\n else (\n assert (Int.num_bits = 31 || Int.num_bits = 32);\n 22)\n ;;\n\n let masked_tuple_id_num_bits = Int.num_bits - array_index_num_bits\n\n let%test _ = array_index_num_bits > 0\n let%test _ = masked_tuple_id_num_bits > 0\n let%test _ = array_index_num_bits + masked_tuple_id_num_bits <= Int.num_bits\n\n let max_array_length = 1 lsl array_index_num_bits\n\n module Tuple_id : sig\n type t = private int [@@deriving sexp_of]\n\n include Invariant.S with type t := t\n\n val to_string : t -> string\n val equal : t -> t -> bool\n val init : t\n val next : t -> t\n val of_int : int -> t\n val to_int : t -> int\n val examples : t list\n end = struct\n type t = int [@@deriving sexp_of]\n\n (* We guarantee that tuple ids are nonnegative so that they can be encoded in\n headers. *)\n let invariant t = assert (t >= 0)\n let to_string = Int.to_string\n let equal (t1 : t) t2 = t1 = t2\n let init = 0\n let next t = if arch_sixtyfour then t + 1 else if t = Int.max_value then 0 else t + 1\n let to_int t = t\n\n let of_int i =\n if i < 0\n then failwiths ~here:[%here] \"Tuple_id.of_int got negative int\" i [%sexp_of: int];\n i\n ;;\n\n let examples = [ 0; 1; 0x1FFF_FFFF; Int.max_value ]\n end\n\n let tuple_id_mask = (1 lsl masked_tuple_id_num_bits) - 1\n\n module Pointer : sig\n (* [Pointer.t] is an encoding as an [int] of the following sum type:\n\n {[\n | Null\n | Normal of { header_index : int; masked_tuple_id : int }\n ]}\n\n The encoding is chosen to optimize the most common operation, namely tuple-slot\n access, the [slot_index] function. The encoding is designed so that [slot_index]\n produces a negative number for [Null], which will cause the subsequent array bounds\n check to fail. *)\n\n type 'slots t = private int [@@deriving sexp_of, typerep]\n\n include Invariant.S1 with type 'a t := 'a t\n\n val phys_compare : 'a t -> 'a t -> int\n val phys_equal : 'a t -> 'a t -> bool\n\n (* The null pointer. [null] is a function due to issues with the value restriction. *)\n\n val null : unit -> _ t\n val is_null : _ t -> bool\n\n (* Normal pointers. *)\n\n val create : header_index:int -> Tuple_id.t -> _ t\n val header_index : _ t -> int\n val masked_tuple_id : _ t -> int\n val slot_index : _ t -> (_, _) Slot.t -> int\n val first_slot_index : _ t -> int\n\n module Id : sig\n type t [@@deriving bin_io, sexp]\n\n val to_int63 : t -> Int63.t\n val of_int63 : Int63.t -> t\n end\n\n val to_id : _ t -> Id.t\n val of_id_exn : Id.t -> _ t\n end = struct\n (* A pointer is either [null] or the (positive) index in the pool of the next-free\n field preceeding the tuple's slots. *)\n type 'slots t = int [@@deriving typerep]\n\n let sexp_of_t _ t = Sexp.Atom (sprintf \"\" t)\n let phys_equal (t1 : _ t) t2 = phys_equal t1 t2\n let phys_compare = compare\n let null () = -max_slot - 1\n let is_null t = phys_equal t (null ())\n\n (* [null] must be such that [null + slot] is an invalid array index for all slots.\n Otherwise get/set on the null pointer may lead to a segfault. *)\n let%test _ = null () + max_slot < 0\n\n let create ~header_index (tuple_id : Tuple_id.t) =\n header_index\n lor ((Tuple_id.to_int tuple_id land tuple_id_mask) lsl array_index_num_bits)\n ;;\n\n let header_index_mask = (1 lsl array_index_num_bits) - 1\n let masked_tuple_id t = t lsr array_index_num_bits\n let header_index t = t land header_index_mask\n let invariant _ t = if not (is_null t) then assert (header_index t > 0)\n\n let%test_unit _ = invariant ignore (null ())\n\n let%test_unit _ =\n List.iter Tuple_id.examples ~f:(fun tuple_id ->\n invariant ignore (create ~header_index:1 tuple_id))\n ;;\n\n let slot_index t slot = header_index t + slot\n let first_slot_index t = slot_index t Slot.t0\n\n module Id = struct\n include Int63\n\n let to_int63 t = t\n let of_int63 i = i\n end\n\n let to_id t = Id.of_int t\n\n let of_id_exn id =\n try\n let t = Id.to_int_exn id in\n if is_null t\n then t\n else (\n let should_equal =\n create ~header_index:(header_index t) (Tuple_id.of_int (masked_tuple_id t))\n in\n if phys_equal t should_equal\n then t\n else failwiths ~here:[%here] \"should equal\" should_equal [%sexp_of: _ t])\n with\n | exn ->\n failwiths\n ~here:[%here]\n \"Pointer.of_id_exn got strange id\"\n (id, exn)\n [%sexp_of: Id.t * exn]\n ;;\n end\n\n module Header : sig\n (* A [Header.t] is an encoding as an [int] of the following type:\n\n {[\n | Null\n | Free of { next_free_header_index : int }\n | Used of { tuple_id : int }\n ]}\n\n If a tuple is free, its header is set to either [Null] or [Free] with\n [next_free_header_index] indicating the header of the next tuple on the free list.\n If a tuple is in use, it header is set to [Used]. *)\n\n type t = private int [@@deriving sexp_of]\n\n val null : t\n val is_null : t -> bool\n val free : next_free_header_index:int -> t\n val is_free : t -> bool\n val next_free_header_index : t -> int\n\n (* only valid if [is_free t] *)\n\n val used : Tuple_id.t -> t\n val is_used : t -> bool\n val tuple_id : t -> Tuple_id.t\n\n (* only valid if [is_used t] *)\n end = struct\n type t = int\n\n let null = 0\n let is_null t = t = 0\n\n (* We know that header indices are [> 0], because index [0] holds the metadata. *)\n let free ~next_free_header_index = next_free_header_index\n let is_free t = t > 0\n let next_free_header_index t = t\n let used (tuple_id : Tuple_id.t) = -1 - (tuple_id :> int)\n let is_used t = t < 0\n let tuple_id t = Tuple_id.of_int (-(t + 1))\n\n let%test_unit _ =\n List.iter Tuple_id.examples ~f:(fun id ->\n let t = used id in\n assert (is_used t);\n assert (Tuple_id.equal (tuple_id t) id))\n ;;\n\n let sexp_of_t t =\n if is_null t\n then Sexp.Atom \"null\"\n else if is_free t\n then Sexp.(List [ Atom \"Free\"; Atom (Int.to_string (next_free_header_index t)) ])\n else Sexp.(List [ Atom \"Used\"; Atom (Tuple_id.to_string (tuple_id t)) ])\n ;;\n end\n\n let metadata_index = 0\n let start_of_tuples_index = 1\n\n let max_capacity ~slots_per_tuple =\n (max_array_length - start_of_tuples_index) / (1 + slots_per_tuple)\n ;;\n\n let%test_unit _ =\n for slots_per_tuple = 1 to max_slot do\n assert (\n start_of_tuples_index + ((1 + slots_per_tuple) * max_capacity ~slots_per_tuple)\n <= max_array_length)\n done\n ;;\n\n module Metadata = struct\n type 'slots t =\n { (* [slots_per_tuple] is number of slots in a tuple as seen by the user; i.e. not\n counting the next-free pointer. *)\n slots_per_tuple : int\n ; capacity : int\n ; mutable length : int\n ; mutable next_id : Tuple_id.t\n ; mutable first_free : Header.t\n (* [dummy] is [None] in an unsafe pool. In a safe pool, [dummy] is [Some a], with\n [Uniform_array.length a = slots_per_tuple]. [dummy] is actually a tuple value\n with the correct type (corresponding to ['slots]), but we make the type of\n [dummy] be [Obj.t Uniform_array.t] because we can't write that type here. Also,\n the purpose of [dummy] is to initialize a pool element, making [dummy] an [Obj.t\n Uniform_array.t] lets us initialize a pool element using [Uniform_array.blit]\n from [dummy] to the pool, which is an [Obj.t Uniform_array.t]. *)\n ; dummy : (Obj.t Uniform_array.t[@sexp.opaque]) option\n }\n [@@deriving fields, sexp_of]\n\n let array_indices_per_tuple t = 1 + t.slots_per_tuple\n let array_length t = start_of_tuples_index + (t.capacity * array_indices_per_tuple t)\n\n let header_index_to_tuple_num t ~header_index =\n (header_index - start_of_tuples_index) / array_indices_per_tuple t\n ;;\n\n let tuple_num_to_header_index t tuple_num =\n start_of_tuples_index + (tuple_num * array_indices_per_tuple t)\n ;;\n\n let tuple_num_to_first_slot_index t tuple_num =\n tuple_num_to_header_index t tuple_num + 1\n ;;\n\n let is_full t = t.length = t.capacity\n end\n\n open Metadata\n\n (* We use type [Obj.t] because the array holds a mix of integers as well as OCaml values\n of arbitrary type. *)\n type 'slots t = Obj.t Uniform_array.t\n\n let metadata (type slots) (t : slots t) =\n Uniform_array.unsafe_get t metadata_index |> (Obj.obj : _ -> slots Metadata.t)\n ;;\n\n let length t = (metadata t).length\n let sexp_of_t sexp_of_ty t = Metadata.sexp_of_t sexp_of_ty (metadata t)\n\n (* Because [unsafe_header] and [unsafe_set_header] do not do a bounds check, one must be\n sure that one has a valid [header_index] before calling them. *)\n let unsafe_header t ~header_index =\n Uniform_array.unsafe_get t header_index |> (Obj.obj : _ -> Header.t)\n ;;\n\n let unsafe_set_header t ~header_index (header : Header.t) =\n Uniform_array.unsafe_set_int_assuming_currently_int t header_index (header :> int)\n ;;\n\n let header_index_is_in_bounds t ~header_index =\n header_index >= start_of_tuples_index && header_index < Uniform_array.length t\n ;;\n\n let unsafe_pointer_is_live t pointer =\n let header_index = Pointer.header_index pointer in\n let header = unsafe_header t ~header_index in\n Header.is_used header\n && Tuple_id.to_int (Header.tuple_id header) land tuple_id_mask\n = Pointer.masked_tuple_id pointer\n ;;\n\n let pointer_is_valid t pointer =\n header_index_is_in_bounds t ~header_index:(Pointer.header_index pointer)\n (* At this point, we know the pointer isn't [null] and is in bounds, so we know it is\n the index of a header, since we maintain the invariant that all pointers other than\n [null] are. *)\n && unsafe_pointer_is_live t pointer\n ;;\n\n let id_of_pointer _t pointer = Pointer.to_id pointer\n\n let is_valid_header_index t ~header_index =\n let metadata = metadata t in\n header_index_is_in_bounds t ~header_index\n && 0\n = (header_index - start_of_tuples_index)\n mod Metadata.array_indices_per_tuple metadata\n ;;\n\n let pointer_of_id_exn t id =\n try\n let pointer = Pointer.of_id_exn id in\n if not (Pointer.is_null pointer)\n then (\n let header_index = Pointer.header_index pointer in\n if not (is_valid_header_index t ~header_index)\n then failwiths ~here:[%here] \"invalid header index\" header_index [%sexp_of: int];\n if not (unsafe_pointer_is_live t pointer) then failwith \"pointer not live\");\n pointer\n with\n | exn ->\n failwiths\n ~here:[%here]\n \"Pool.pointer_of_id_exn got invalid id\"\n (id, t, exn)\n [%sexp_of: Pointer.Id.t * _ t * exn]\n ;;\n\n let invariant _invariant_a t : unit =\n try\n let metadata = metadata t in\n let check f field = f (Field.get field metadata) in\n Metadata.Fields.iter\n ~slots_per_tuple:(check (fun slots_per_tuple -> assert (slots_per_tuple > 0)))\n ~capacity:\n (check (fun capacity ->\n assert (capacity >= 0);\n assert (Uniform_array.length t = Metadata.array_length metadata)))\n ~length:\n (check (fun length ->\n assert (length >= 0);\n assert (length <= metadata.capacity)))\n ~next_id:(check Tuple_id.invariant)\n ~first_free:\n (check (fun first_free ->\n let free = Array.create ~len:metadata.capacity false in\n let r = ref first_free in\n while not (Header.is_null !r) do\n let header = !r in\n assert (Header.is_free header);\n let header_index = Header.next_free_header_index header in\n assert (is_valid_header_index t ~header_index);\n let tuple_num = header_index_to_tuple_num metadata ~header_index in\n if free.(tuple_num)\n then\n failwiths ~here:[%here] \"cycle in free list\" tuple_num [%sexp_of: int];\n free.(tuple_num) <- true;\n r := unsafe_header t ~header_index\n done))\n ~dummy:\n (check (function\n | Some dummy ->\n assert (Uniform_array.length dummy = metadata.slots_per_tuple)\n | None ->\n for tuple_num = 0 to metadata.capacity - 1 do\n let header_index = tuple_num_to_header_index metadata tuple_num in\n let header = unsafe_header t ~header_index in\n if Header.is_free header\n then (\n let first_slot = tuple_num_to_first_slot_index metadata tuple_num in\n for slot = 0 to metadata.slots_per_tuple - 1 do\n assert (Obj.is_int (Uniform_array.get t (first_slot + slot)))\n done)\n done))\n with\n | exn ->\n failwiths ~here:[%here] \"Pool.invariant failed\" (exn, t) [%sexp_of: exn * _ t]\n ;;\n\n let capacity t = (metadata t).capacity\n let is_full t = Metadata.is_full (metadata t)\n\n let unsafe_add_to_free_list t metadata ~header_index =\n unsafe_set_header t ~header_index metadata.first_free;\n metadata.first_free <- Header.free ~next_free_header_index:header_index\n ;;\n\n let set_metadata (type slots) (t : slots t) metadata =\n Uniform_array.set t metadata_index (Obj.repr (metadata : slots Metadata.t))\n ;;\n\n let create_array (type slots) (metadata : slots Metadata.t) : slots t =\n let t = Uniform_array.create_obj_array ~len:(Metadata.array_length metadata) in\n set_metadata t metadata;\n t\n ;;\n\n (* Initialize tuples numbered from [lo] (inclusive) up to [hi] (exclusive). For each\n tuple, this puts dummy values in the tuple's slots and adds the tuple to the free\n list. *)\n let unsafe_init_range t metadata ~lo ~hi =\n (match metadata.dummy with\n | None -> ()\n | Some dummy ->\n for tuple_num = lo to hi - 1 do\n Uniform_array.blit\n ~src:dummy\n ~src_pos:0\n ~dst:t\n ~dst_pos:(tuple_num_to_first_slot_index metadata tuple_num)\n ~len:metadata.slots_per_tuple\n done);\n for tuple_num = hi - 1 downto lo do\n unsafe_add_to_free_list\n t\n metadata\n ~header_index:(tuple_num_to_header_index metadata tuple_num)\n done\n ;;\n\n let create_with_dummy slots ~capacity ~dummy =\n if capacity < 0\n then\n failwiths ~here:[%here] \"Pool.create got invalid capacity\" capacity [%sexp_of: int];\n let slots_per_tuple = Slots.slots_per_tuple slots in\n let max_capacity = max_capacity ~slots_per_tuple in\n if capacity > max_capacity\n then\n failwiths\n ~here:[%here]\n \"Pool.create got too large capacity\"\n (capacity, `max max_capacity)\n [%sexp_of: int * [ `max of int ]];\n let metadata =\n { Metadata.slots_per_tuple\n ; capacity\n ; length = 0\n ; next_id = Tuple_id.init\n ; first_free = Header.null\n ; dummy\n }\n in\n let t = create_array metadata in\n unsafe_init_range t metadata ~lo:0 ~hi:capacity;\n t\n ;;\n\n let create (type tuple) (slots : (tuple, _) Slots.t) ~capacity ~dummy =\n let dummy =\n if Slots.slots_per_tuple slots = 1\n then Uniform_array.singleton (Obj.repr (dummy : tuple))\n else (Obj.magic (dummy : tuple) : Obj.t Uniform_array.t)\n in\n create_with_dummy slots ~capacity ~dummy:(Some dummy)\n ;;\n\n (* Purge a pool and make it unusable. *)\n let destroy t =\n let metadata = metadata t in\n (* We clear out all the pool's entries, which causes all pointers to be invalid. This\n also prevents the destroyed pool from unnecessarily keeping heap blocks alive.\n This is similar to [free]ing all the entries with the difference that we make the\n free list empty as well. *)\n (match metadata.dummy with\n | None ->\n for i = start_of_tuples_index to Uniform_array.length t - 1 do\n Uniform_array.unsafe_set t i (Obj.repr 0)\n done\n | Some dummy ->\n for tuple_num = 0 to metadata.capacity - 1 do\n let header_index = tuple_num_to_header_index metadata tuple_num in\n unsafe_set_header t ~header_index Header.null;\n Uniform_array.blit\n ~src:dummy\n ~src_pos:0\n ~dst:t\n ~dst_pos:(header_index + 1)\n ~len:metadata.slots_per_tuple\n done);\n let metadata =\n { Metadata.slots_per_tuple = metadata.slots_per_tuple\n ; capacity = 0\n ; length = 0\n ; next_id = metadata.next_id\n ; first_free = Header.null\n ; dummy = metadata.dummy\n }\n in\n set_metadata t metadata\n ;;\n\n let[@cold] grow ?capacity t =\n let { Metadata.slots_per_tuple\n ; capacity = old_capacity\n ; length\n ; next_id\n ; first_free = _\n ; dummy\n }\n =\n metadata t\n in\n let capacity =\n min (max_capacity ~slots_per_tuple) (grow_capacity ~capacity ~old_capacity)\n in\n if capacity = old_capacity\n then\n failwiths\n ~here:[%here]\n \"Pool.grow cannot grow pool; capacity already at maximum\"\n capacity\n [%sexp_of: int];\n let metadata =\n { Metadata.slots_per_tuple\n ; capacity\n ; length\n ; next_id\n ; first_free = Header.null\n ; dummy\n }\n in\n let t' = create_array metadata in\n Uniform_array.blit\n ~src:t\n ~src_pos:start_of_tuples_index\n ~dst:t'\n ~dst_pos:start_of_tuples_index\n ~len:(old_capacity * Metadata.array_indices_per_tuple metadata);\n destroy t;\n unsafe_init_range t' metadata ~lo:old_capacity ~hi:capacity;\n for tuple_num = old_capacity - 1 downto 0 do\n let header_index = tuple_num_to_header_index metadata tuple_num in\n let header = unsafe_header t' ~header_index in\n if not (Header.is_used header)\n then unsafe_add_to_free_list t' metadata ~header_index\n done;\n t'\n ;;\n\n let[@cold] raise_malloc_full t =\n failwiths ~here:[%here] \"Pool.malloc of full pool\" t [%sexp_of: _ t]\n ;;\n\n let malloc (type slots) (t : slots t) : slots Pointer.t =\n let metadata = metadata t in\n let first_free = metadata.first_free in\n if Header.is_null first_free then raise_malloc_full t;\n let header_index = Header.next_free_header_index first_free in\n metadata.first_free <- unsafe_header t ~header_index;\n metadata.length <- metadata.length + 1;\n let tuple_id = metadata.next_id in\n unsafe_set_header t ~header_index (Header.used tuple_id);\n metadata.next_id <- Tuple_id.next tuple_id;\n Pointer.create ~header_index tuple_id\n ;;\n\n let unsafe_free (type slots) (t : slots t) (pointer : slots Pointer.t) =\n let metadata = metadata t in\n metadata.length <- metadata.length - 1;\n unsafe_add_to_free_list t metadata ~header_index:(Pointer.header_index pointer);\n match metadata.dummy with\n | None ->\n let pos = Pointer.first_slot_index pointer in\n for i = 0 to metadata.slots_per_tuple - 1 do\n Uniform_array.unsafe_clear_if_pointer t (pos + i)\n done\n | Some dummy ->\n Uniform_array.unsafe_blit\n ~src:dummy\n ~src_pos:0\n ~len:metadata.slots_per_tuple\n ~dst:t\n ~dst_pos:(Pointer.first_slot_index pointer)\n ;;\n\n let free (type slots) (t : slots t) (pointer : slots Pointer.t) =\n (* Check [pointer_is_valid] to:\n - avoid freeing a null pointer\n - avoid freeing a free pointer (this would lead to a pool inconsistency)\n - be able to use unsafe functions after. *)\n if not (pointer_is_valid t pointer)\n then\n failwiths\n ~here:[%here]\n \"Pool.free of invalid pointer\"\n (pointer, t)\n [%sexp_of: _ Pointer.t * _ t];\n unsafe_free t pointer\n ;;\n\n let new1 t a0 =\n let pointer = malloc t in\n let offset = Pointer.header_index pointer in\n Uniform_array.unsafe_set t (offset + 1) (Obj.repr a0);\n pointer\n ;;\n\n let new2 t a0 a1 =\n let pointer = malloc t in\n let offset = Pointer.header_index pointer in\n Uniform_array.unsafe_set t (offset + 1) (Obj.repr a0);\n Uniform_array.unsafe_set t (offset + 2) (Obj.repr a1);\n pointer\n ;;\n\n let new3 t a0 a1 a2 =\n let pointer = malloc t in\n let offset = Pointer.header_index pointer in\n Uniform_array.unsafe_set t (offset + 1) (Obj.repr a0);\n Uniform_array.unsafe_set t (offset + 2) (Obj.repr a1);\n Uniform_array.unsafe_set t (offset + 3) (Obj.repr a2);\n pointer\n ;;\n\n let new4 t a0 a1 a2 a3 =\n let pointer = malloc t in\n let offset = Pointer.header_index pointer in\n Uniform_array.unsafe_set t (offset + 1) (Obj.repr a0);\n Uniform_array.unsafe_set t (offset + 2) (Obj.repr a1);\n Uniform_array.unsafe_set t (offset + 3) (Obj.repr a2);\n Uniform_array.unsafe_set t (offset + 4) (Obj.repr a3);\n pointer\n ;;\n\n let new5 t a0 a1 a2 a3 a4 =\n let pointer = malloc t in\n let offset = Pointer.header_index pointer in\n Uniform_array.unsafe_set t (offset + 1) (Obj.repr a0);\n Uniform_array.unsafe_set t (offset + 2) (Obj.repr a1);\n Uniform_array.unsafe_set t (offset + 3) (Obj.repr a2);\n Uniform_array.unsafe_set t (offset + 4) (Obj.repr a3);\n Uniform_array.unsafe_set t (offset + 5) (Obj.repr a4);\n pointer\n ;;\n\n let new6 t a0 a1 a2 a3 a4 a5 =\n let pointer = malloc t in\n let offset = Pointer.header_index pointer in\n Uniform_array.unsafe_set t (offset + 1) (Obj.repr a0);\n Uniform_array.unsafe_set t (offset + 2) (Obj.repr a1);\n Uniform_array.unsafe_set t (offset + 3) (Obj.repr a2);\n Uniform_array.unsafe_set t (offset + 4) (Obj.repr a3);\n Uniform_array.unsafe_set t (offset + 5) (Obj.repr a4);\n Uniform_array.unsafe_set t (offset + 6) (Obj.repr a5);\n pointer\n ;;\n\n let new7 t a0 a1 a2 a3 a4 a5 a6 =\n let pointer = malloc t in\n let offset = Pointer.header_index pointer in\n Uniform_array.unsafe_set t (offset + 1) (Obj.repr a0);\n Uniform_array.unsafe_set t (offset + 2) (Obj.repr a1);\n Uniform_array.unsafe_set t (offset + 3) (Obj.repr a2);\n Uniform_array.unsafe_set t (offset + 4) (Obj.repr a3);\n Uniform_array.unsafe_set t (offset + 5) (Obj.repr a4);\n Uniform_array.unsafe_set t (offset + 6) (Obj.repr a5);\n Uniform_array.unsafe_set t (offset + 7) (Obj.repr a6);\n pointer\n ;;\n\n let new8 t a0 a1 a2 a3 a4 a5 a6 a7 =\n let pointer = malloc t in\n let offset = Pointer.header_index pointer in\n Uniform_array.unsafe_set t (offset + 1) (Obj.repr a0);\n Uniform_array.unsafe_set t (offset + 2) (Obj.repr a1);\n Uniform_array.unsafe_set t (offset + 3) (Obj.repr a2);\n Uniform_array.unsafe_set t (offset + 4) (Obj.repr a3);\n Uniform_array.unsafe_set t (offset + 5) (Obj.repr a4);\n Uniform_array.unsafe_set t (offset + 6) (Obj.repr a5);\n Uniform_array.unsafe_set t (offset + 7) (Obj.repr a6);\n Uniform_array.unsafe_set t (offset + 8) (Obj.repr a7);\n pointer\n ;;\n\n let new9 t a0 a1 a2 a3 a4 a5 a6 a7 a8 =\n let pointer = malloc t in\n let offset = Pointer.header_index pointer in\n Uniform_array.unsafe_set t (offset + 1) (Obj.repr a0);\n Uniform_array.unsafe_set t (offset + 2) (Obj.repr a1);\n Uniform_array.unsafe_set t (offset + 3) (Obj.repr a2);\n Uniform_array.unsafe_set t (offset + 4) (Obj.repr a3);\n Uniform_array.unsafe_set t (offset + 5) (Obj.repr a4);\n Uniform_array.unsafe_set t (offset + 6) (Obj.repr a5);\n Uniform_array.unsafe_set t (offset + 7) (Obj.repr a6);\n Uniform_array.unsafe_set t (offset + 8) (Obj.repr a7);\n Uniform_array.unsafe_set t (offset + 9) (Obj.repr a8);\n pointer\n ;;\n\n let new10 t a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 =\n let pointer = malloc t in\n let offset = Pointer.header_index pointer in\n Uniform_array.unsafe_set t (offset + 1) (Obj.repr a0);\n Uniform_array.unsafe_set t (offset + 2) (Obj.repr a1);\n Uniform_array.unsafe_set t (offset + 3) (Obj.repr a2);\n Uniform_array.unsafe_set t (offset + 4) (Obj.repr a3);\n Uniform_array.unsafe_set t (offset + 5) (Obj.repr a4);\n Uniform_array.unsafe_set t (offset + 6) (Obj.repr a5);\n Uniform_array.unsafe_set t (offset + 7) (Obj.repr a6);\n Uniform_array.unsafe_set t (offset + 8) (Obj.repr a7);\n Uniform_array.unsafe_set t (offset + 9) (Obj.repr a8);\n Uniform_array.unsafe_set t (offset + 10) (Obj.repr a9);\n pointer\n ;;\n\n let new11 t a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 =\n let pointer = malloc t in\n let offset = Pointer.header_index pointer in\n Uniform_array.unsafe_set t (offset + 1) (Obj.repr a0);\n Uniform_array.unsafe_set t (offset + 2) (Obj.repr a1);\n Uniform_array.unsafe_set t (offset + 3) (Obj.repr a2);\n Uniform_array.unsafe_set t (offset + 4) (Obj.repr a3);\n Uniform_array.unsafe_set t (offset + 5) (Obj.repr a4);\n Uniform_array.unsafe_set t (offset + 6) (Obj.repr a5);\n Uniform_array.unsafe_set t (offset + 7) (Obj.repr a6);\n Uniform_array.unsafe_set t (offset + 8) (Obj.repr a7);\n Uniform_array.unsafe_set t (offset + 9) (Obj.repr a8);\n Uniform_array.unsafe_set t (offset + 10) (Obj.repr a9);\n Uniform_array.unsafe_set t (offset + 11) (Obj.repr a10);\n pointer\n ;;\n\n let new12 t a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 =\n let pointer = malloc t in\n let offset = Pointer.header_index pointer in\n Uniform_array.unsafe_set t (offset + 1) (Obj.repr a0);\n Uniform_array.unsafe_set t (offset + 2) (Obj.repr a1);\n Uniform_array.unsafe_set t (offset + 3) (Obj.repr a2);\n Uniform_array.unsafe_set t (offset + 4) (Obj.repr a3);\n Uniform_array.unsafe_set t (offset + 5) (Obj.repr a4);\n Uniform_array.unsafe_set t (offset + 6) (Obj.repr a5);\n Uniform_array.unsafe_set t (offset + 7) (Obj.repr a6);\n Uniform_array.unsafe_set t (offset + 8) (Obj.repr a7);\n Uniform_array.unsafe_set t (offset + 9) (Obj.repr a8);\n Uniform_array.unsafe_set t (offset + 10) (Obj.repr a9);\n Uniform_array.unsafe_set t (offset + 11) (Obj.repr a10);\n Uniform_array.unsafe_set t (offset + 12) (Obj.repr a11);\n pointer\n ;;\n\n let new13 t a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 =\n let pointer = malloc t in\n let offset = Pointer.header_index pointer in\n Uniform_array.unsafe_set t (offset + 1) (Obj.repr a0);\n Uniform_array.unsafe_set t (offset + 2) (Obj.repr a1);\n Uniform_array.unsafe_set t (offset + 3) (Obj.repr a2);\n Uniform_array.unsafe_set t (offset + 4) (Obj.repr a3);\n Uniform_array.unsafe_set t (offset + 5) (Obj.repr a4);\n Uniform_array.unsafe_set t (offset + 6) (Obj.repr a5);\n Uniform_array.unsafe_set t (offset + 7) (Obj.repr a6);\n Uniform_array.unsafe_set t (offset + 8) (Obj.repr a7);\n Uniform_array.unsafe_set t (offset + 9) (Obj.repr a8);\n Uniform_array.unsafe_set t (offset + 10) (Obj.repr a9);\n Uniform_array.unsafe_set t (offset + 11) (Obj.repr a10);\n Uniform_array.unsafe_set t (offset + 12) (Obj.repr a11);\n Uniform_array.unsafe_set t (offset + 13) (Obj.repr a12);\n pointer\n ;;\n\n let new14 t a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 a13 =\n let pointer = malloc t in\n let offset = Pointer.header_index pointer in\n Uniform_array.unsafe_set t (offset + 1) (Obj.repr a0);\n Uniform_array.unsafe_set t (offset + 2) (Obj.repr a1);\n Uniform_array.unsafe_set t (offset + 3) (Obj.repr a2);\n Uniform_array.unsafe_set t (offset + 4) (Obj.repr a3);\n Uniform_array.unsafe_set t (offset + 5) (Obj.repr a4);\n Uniform_array.unsafe_set t (offset + 6) (Obj.repr a5);\n Uniform_array.unsafe_set t (offset + 7) (Obj.repr a6);\n Uniform_array.unsafe_set t (offset + 8) (Obj.repr a7);\n Uniform_array.unsafe_set t (offset + 9) (Obj.repr a8);\n Uniform_array.unsafe_set t (offset + 10) (Obj.repr a9);\n Uniform_array.unsafe_set t (offset + 11) (Obj.repr a10);\n Uniform_array.unsafe_set t (offset + 12) (Obj.repr a11);\n Uniform_array.unsafe_set t (offset + 13) (Obj.repr a12);\n Uniform_array.unsafe_set t (offset + 14) (Obj.repr a13);\n pointer\n ;;\n\n let get t p slot = Obj.obj (Uniform_array.get t (Pointer.slot_index p slot))\n\n let unsafe_get t p slot =\n Obj.obj (Uniform_array.unsafe_get t (Pointer.slot_index p slot))\n ;;\n\n let set t p slot x = Uniform_array.set t (Pointer.slot_index p slot) (Obj.repr x)\n\n let unsafe_set t p slot x =\n Uniform_array.unsafe_set t (Pointer.slot_index p slot) (Obj.repr x)\n ;;\n\n let get_tuple (type tuple) (t : (tuple, _) Slots.t t) pointer =\n let metadata = metadata t in\n let len = metadata.slots_per_tuple in\n if len = 1\n then get t pointer Slot.t0\n else\n (Obj.magic\n (Uniform_array.sub t ~pos:(Pointer.first_slot_index pointer) ~len\n : Obj.t Uniform_array.t)\n : tuple)\n ;;\nend\n\ninclude Pool\n\nmodule Unsafe = struct\n include Pool\n\n let create slots ~capacity = create_with_dummy slots ~capacity ~dummy:None\nend\n\nmodule Debug (Pool : S) = struct\n open Pool\n\n let check_invariant = ref true\n let show_messages = ref true\n\n let debug name ts arg sexp_of_arg sexp_of_result f =\n let prefix = \"Pool.\" in\n if !check_invariant then List.iter ts ~f:(invariant ignore);\n if !show_messages then Debug.eprints (concat [ prefix; name ]) arg sexp_of_arg;\n let result_or_exn = Result.try_with f in\n if !show_messages\n then\n Debug.eprints\n (concat [ prefix; name; \" result\" ])\n result_or_exn\n [%sexp_of: (result, exn) Result.t];\n Result.ok_exn result_or_exn\n ;;\n\n module Slots = Slots\n module Slot = Slot\n\n module Pointer = struct\n open Pointer\n\n type nonrec 'slots t = 'slots t [@@deriving sexp_of, typerep]\n\n let phys_compare t1 t2 =\n debug\n \"Pointer.phys_compare\"\n []\n (t1, t2)\n [%sexp_of: _ t * _ t]\n [%sexp_of: int]\n (fun () -> phys_compare t1 t2)\n ;;\n\n let phys_equal t1 t2 =\n debug\n \"Pointer.phys_equal\"\n []\n (t1, t2)\n [%sexp_of: _ t * _ t]\n [%sexp_of: bool]\n (fun () -> phys_equal t1 t2)\n ;;\n\n let is_null t =\n debug \"Pointer.is_null\" [] t [%sexp_of: _ t] [%sexp_of: bool] (fun () -> is_null t)\n ;;\n\n let null = null\n\n module Id = struct\n open Id\n\n type nonrec t = t [@@deriving bin_io, sexp]\n\n let of_int63 i =\n debug \"Pointer.Id.of_int63\" [] i [%sexp_of: Int63.t] [%sexp_of: t] (fun () ->\n of_int63 i)\n ;;\n\n let to_int63 t =\n debug \"Pointer.Id.to_int63\" [] t [%sexp_of: t] [%sexp_of: Int63.t] (fun () ->\n to_int63 t)\n ;;\n end\n end\n\n type nonrec 'slots t = 'slots t [@@deriving sexp_of]\n\n let invariant = invariant\n let length = length\n\n let id_of_pointer t pointer =\n debug\n \"id_of_pointer\"\n [ t ]\n pointer\n [%sexp_of: _ Pointer.t]\n [%sexp_of: Pointer.Id.t]\n (fun () -> id_of_pointer t pointer)\n ;;\n\n let pointer_of_id_exn t id =\n debug\n \"pointer_of_id_exn\"\n [ t ]\n id\n [%sexp_of: Pointer.Id.t]\n [%sexp_of: _ Pointer.t]\n (fun () -> pointer_of_id_exn t id)\n ;;\n\n let pointer_is_valid t pointer =\n debug\n \"pointer_is_valid\"\n [ t ]\n pointer\n [%sexp_of: _ Pointer.t]\n [%sexp_of: bool]\n (fun () -> pointer_is_valid t pointer)\n ;;\n\n let create slots ~capacity ~dummy =\n debug \"create\" [] capacity [%sexp_of: int] [%sexp_of: _ t] (fun () ->\n create slots ~capacity ~dummy)\n ;;\n\n let max_capacity ~slots_per_tuple =\n debug \"max_capacity\" [] slots_per_tuple [%sexp_of: int] [%sexp_of: int] (fun () ->\n max_capacity ~slots_per_tuple)\n ;;\n\n let capacity t =\n debug \"capacity\" [ t ] t [%sexp_of: _ t] [%sexp_of: int] (fun () -> capacity t)\n ;;\n\n let grow ?capacity t =\n debug\n \"grow\"\n [ t ]\n (`capacity capacity)\n [%sexp_of: [ `capacity of int option ]]\n [%sexp_of: _ t]\n (fun () -> grow ?capacity t)\n ;;\n\n let is_full t =\n debug \"is_full\" [ t ] t [%sexp_of: _ t] [%sexp_of: bool] (fun () -> is_full t)\n ;;\n\n let unsafe_free t p =\n debug \"unsafe_free\" [ t ] p [%sexp_of: _ Pointer.t] [%sexp_of: unit] (fun () ->\n unsafe_free t p)\n ;;\n\n let free t p =\n debug \"free\" [ t ] p [%sexp_of: _ Pointer.t] [%sexp_of: unit] (fun () -> free t p)\n ;;\n\n let debug_new t f = debug \"new\" [ t ] () [%sexp_of: unit] [%sexp_of: _ Pointer.t] f\n let new1 t a0 = debug_new t (fun () -> new1 t a0)\n let new2 t a0 a1 = debug_new t (fun () -> new2 t a0 a1)\n let new3 t a0 a1 a2 = debug_new t (fun () -> new3 t a0 a1 a2)\n let new4 t a0 a1 a2 a3 = debug_new t (fun () -> new4 t a0 a1 a2 a3)\n let new5 t a0 a1 a2 a3 a4 = debug_new t (fun () -> new5 t a0 a1 a2 a3 a4)\n let new6 t a0 a1 a2 a3 a4 a5 = debug_new t (fun () -> new6 t a0 a1 a2 a3 a4 a5)\n let new7 t a0 a1 a2 a3 a4 a5 a6 = debug_new t (fun () -> new7 t a0 a1 a2 a3 a4 a5 a6)\n\n let new8 t a0 a1 a2 a3 a4 a5 a6 a7 =\n debug_new t (fun () -> new8 t a0 a1 a2 a3 a4 a5 a6 a7)\n ;;\n\n let new9 t a0 a1 a2 a3 a4 a5 a6 a7 a8 =\n debug_new t (fun () -> new9 t a0 a1 a2 a3 a4 a5 a6 a7 a8)\n ;;\n\n let new10 t a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 =\n debug_new t (fun () -> new10 t a0 a1 a2 a3 a4 a5 a6 a7 a8 a9)\n ;;\n\n let new11 t a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 =\n debug_new t (fun () -> new11 t a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10)\n ;;\n\n let new12 t a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 =\n debug_new t (fun () -> new12 t a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11)\n ;;\n\n let new13 t a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 =\n debug_new t (fun () -> new13 t a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12)\n ;;\n\n let new14 t a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 a13 =\n debug_new t (fun () -> new14 t a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 a13)\n ;;\n\n let get_tuple t pointer =\n debug \"get_tuple\" [ t ] pointer [%sexp_of: _ Pointer.t] [%sexp_of: _] (fun () ->\n get_tuple t pointer)\n ;;\n\n let debug_get name f t pointer =\n debug name [ t ] pointer [%sexp_of: _ Pointer.t] [%sexp_of: _] (fun () ->\n f t pointer)\n ;;\n\n let get t pointer slot = debug_get \"get\" get t pointer slot\n let unsafe_get t pointer slot = debug_get \"unsafe_get\" unsafe_get t pointer slot\n\n let debug_set name f t pointer slot a =\n debug name [ t ] pointer [%sexp_of: _ Pointer.t] [%sexp_of: unit] (fun () ->\n f t pointer slot a)\n ;;\n\n let set t pointer slot a = debug_set \"set\" set t pointer slot a\n let unsafe_set t pointer slot a = debug_set \"unsafe_set\" unsafe_set t pointer slot a\nend\n\nmodule Error_check (Pool : S) = struct\n open Pool\n module Slots = Slots\n module Slot = Slot\n\n module Pointer = struct\n type 'slots t =\n { mutable is_valid : bool\n ; pointer : 'slots Pointer.t\n }\n [@@deriving sexp_of, typerep]\n\n let create pointer = { is_valid = true; pointer }\n let null () = { is_valid = false; pointer = Pointer.null () }\n let phys_compare t1 t2 = Pointer.phys_compare t1.pointer t2.pointer\n let phys_equal t1 t2 = Pointer.phys_equal t1.pointer t2.pointer\n let is_null t = Pointer.is_null t.pointer\n\n let follow t =\n if not t.is_valid\n then failwiths ~here:[%here] \"attempt to use invalid pointer\" t [%sexp_of: _ t];\n t.pointer\n ;;\n\n let invalidate t = t.is_valid <- false\n\n module Id = Pointer.Id\n end\n\n type 'slots t = 'slots Pool.t [@@deriving sexp_of]\n\n let invariant = invariant\n let length = length\n\n let pointer_is_valid t { Pointer.is_valid; pointer } =\n is_valid && pointer_is_valid t pointer\n ;;\n\n (* We don't do [Pointer.follow pointer], because that would disallow [id_of_pointer t\n (Pointer.null ())]. *)\n let id_of_pointer t pointer = id_of_pointer t pointer.Pointer.pointer\n\n let pointer_of_id_exn t id =\n let pointer = pointer_of_id_exn t id in\n let is_valid = Pool.pointer_is_valid t pointer in\n { Pointer.is_valid; pointer }\n ;;\n\n let create = create\n let capacity = capacity\n let max_capacity = max_capacity\n let grow = grow\n let is_full = is_full\n let get_tuple t p = get_tuple t (Pointer.follow p)\n let get t p = get t (Pointer.follow p)\n let unsafe_get t p = unsafe_get t (Pointer.follow p)\n let set t p slot v = set t (Pointer.follow p) slot v\n let unsafe_set t p slot v = unsafe_set t (Pointer.follow p) slot v\n\n let unsafe_free t p =\n unsafe_free t (Pointer.follow p);\n Pointer.invalidate p\n ;;\n\n let free t p =\n free t (Pointer.follow p);\n Pointer.invalidate p\n ;;\n\n let new1 t a0 = Pointer.create (Pool.new1 t a0)\n let new2 t a0 a1 = Pointer.create (Pool.new2 t a0 a1)\n let new3 t a0 a1 a2 = Pointer.create (Pool.new3 t a0 a1 a2)\n let new4 t a0 a1 a2 a3 = Pointer.create (Pool.new4 t a0 a1 a2 a3)\n let new5 t a0 a1 a2 a3 a4 = Pointer.create (Pool.new5 t a0 a1 a2 a3 a4)\n let new6 t a0 a1 a2 a3 a4 a5 = Pointer.create (Pool.new6 t a0 a1 a2 a3 a4 a5)\n let new7 t a0 a1 a2 a3 a4 a5 a6 = Pointer.create (Pool.new7 t a0 a1 a2 a3 a4 a5 a6)\n\n let new8 t a0 a1 a2 a3 a4 a5 a6 a7 =\n Pointer.create (Pool.new8 t a0 a1 a2 a3 a4 a5 a6 a7)\n ;;\n\n let new9 t a0 a1 a2 a3 a4 a5 a6 a7 a8 =\n Pointer.create (Pool.new9 t a0 a1 a2 a3 a4 a5 a6 a7 a8)\n ;;\n\n let new10 t a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 =\n Pointer.create (Pool.new10 t a0 a1 a2 a3 a4 a5 a6 a7 a8 a9)\n ;;\n\n let new11 t a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 =\n Pointer.create (Pool.new11 t a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10)\n ;;\n\n let new12 t a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 =\n Pointer.create (Pool.new12 t a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11)\n ;;\n\n let new13 t a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 =\n Pointer.create (Pool.new13 t a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12)\n ;;\n\n let new14 t a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 a13 =\n Pointer.create (Pool.new14 t a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 a13)\n ;;\nend\n","open! Import\nmodule Int = Int0\nmodule String = String0\n\n(** Each single_error is a path indicating the location within the datastructure in\n question that is being validated, along with an error message. *)\ntype single_error =\n { path : string list\n ; error : Error.t\n }\n\ntype t = single_error list\ntype 'a check = 'a -> t\n\nlet pass : t = []\n\nlet fails message a sexp_of_a =\n [ { path = []; error = Error.create message a sexp_of_a } ]\n;;\n\nlet fail message = [ { path = []; error = Error.of_string message } ]\nlet failf format = Printf.ksprintf fail format\nlet fail_s sexp = [ { path = []; error = Error.create_s sexp } ]\nlet combine t1 t2 = t1 @ t2\nlet of_list = List.concat\n\nlet name name t =\n match t with\n | [] -> [] (* when successful, avoid the allocation of a closure for [~f], below *)\n | _ -> List.map t ~f:(fun { path; error } -> { path = name :: path; error })\n;;\n\nlet name_list n l = name n (of_list l)\nlet fail_fn message _ = fail message\nlet pass_bool (_ : bool) = pass\nlet pass_unit (_ : unit) = pass\n\nlet protect f v =\n try f v with\n | exn ->\n fail_s (Sexp.message \"Exception raised during validation\" [ \"\", sexp_of_exn exn ])\n;;\n\nlet try_with f =\n protect\n (fun () ->\n f ();\n pass)\n ()\n;;\n\nlet path_string path = String.concat ~sep:\".\" path\n\nlet errors t =\n List.map t ~f:(fun { path; error } ->\n Error.to_string_hum (Error.tag error ~tag:(path_string path)))\n;;\n\nlet result_fail t =\n Or_error.error\n \"validation errors\"\n (List.map t ~f:(fun { path; error } -> path_string path, error))\n (sexp_of_list (sexp_of_pair sexp_of_string Error.sexp_of_t))\n[@@cold] [@@inline never] [@@local never] [@@specialise never]\n;;\n\n(** [result] is carefully implemented so that it can be inlined -- calling [result_fail],\n which is not inlineable, is key to this. *)\nlet result t = if List.is_empty t then Ok () else result_fail t\n\nlet maybe_raise t = Or_error.ok_exn (result t)\nlet valid_or_error x check = Or_error.map (result (protect check x)) ~f:(fun () -> x)\n\nlet field record fld f =\n let v = Field.get fld record in\n let result = protect f v in\n name (Field.name fld) result\n;;\n\nlet field_folder record check =\n ();\n fun acc fld -> field record fld check :: acc\n;;\n\nlet field_direct_folder check =\n Staged.stage (fun acc fld _record v ->\n match protect check v with\n | [] -> acc\n | result -> name (Field.name fld) result :: acc)\n;;\n\nlet all checks v =\n let rec loop checks v errs =\n match checks with\n | [] -> errs\n | check :: checks ->\n (match protect check v with\n | [] -> loop checks v errs\n | err -> loop checks v (err :: errs))\n in\n of_list (List.rev (loop checks v []))\n;;\n\nlet of_result f =\n protect (fun v ->\n match f v with\n | Ok () -> pass\n | Error error -> fail error)\n;;\n\nlet of_error f =\n protect (fun v ->\n match f v with\n | Ok () -> pass\n | Error error -> [ { path = []; error } ])\n;;\n\nlet booltest f ~if_false = protect (fun v -> if f v then pass else fail if_false)\n\nlet pair ~fst ~snd (fst_value, snd_value) =\n of_list [ name \"fst\" (protect fst fst_value); name \"snd\" (protect snd snd_value) ]\n;;\n\nlet list_indexed check list =\n List.mapi list ~f:(fun i el -> name (Int.to_string (i + 1)) (protect check el))\n |> of_list\n;;\n\nlet list ~name:extract_name check list =\n List.map list ~f:(fun el ->\n match protect check el with\n | [] -> []\n | t ->\n (* extra level of protection in case extract_name throws an exception *)\n protect (fun t -> name (extract_name el) t) t)\n |> of_list\n;;\n\nlet alist ~name f list' = list (fun (_, x) -> f x) list' ~name:(fun (key, _) -> name key)\nlet first_failure t1 t2 = if List.is_empty t1 then t2 else t1\n\nlet of_error_opt = function\n | None -> pass\n | Some error -> fail error\n;;\n\nlet bounded ~name ~lower ~upper ~compare x =\n match Maybe_bound.compare_to_interval_exn ~lower ~upper ~compare x with\n | In_range -> pass\n | Below_lower_bound ->\n (match lower with\n | Unbounded -> assert false\n | Incl incl -> fail (Printf.sprintf \"value %s < bound %s\" (name x) (name incl))\n | Excl excl -> fail (Printf.sprintf \"value %s <= bound %s\" (name x) (name excl)))\n | Above_upper_bound ->\n (match upper with\n | Unbounded -> assert false\n | Incl incl -> fail (Printf.sprintf \"value %s > bound %s\" (name x) (name incl))\n | Excl excl -> fail (Printf.sprintf \"value %s >= bound %s\" (name x) (name excl)))\n;;\n\nmodule Infix = struct\n let ( ++ ) t1 t2 = combine t1 t2\nend\n","open! Core_kernel\nopen! Import\n\nmodule Cpuset = struct\n include Validated.Make (struct\n type t = Int.Set.t [@@deriving sexp]\n\n let here = [%here]\n\n let validate t =\n Validate.first_failure\n (Int.validate_lbound ~min:(Incl 1) (Int.Set.length t))\n (Int.Set.to_list t\n |> List.map ~f:Int.validate_non_negative\n |> Validate.name_list \"Thread_pool_cpuset\")\n ;;\n end)\n\n let equal t1 t2 = Int.Set.equal (t1 |> raw) (t2 |> raw)\nend\n\ntype t =\n | Inherit\n | Cpuset of Cpuset.t\n[@@deriving sexp]\n","open Core_kernel\n\ntype 'a t = 'a\n\n(* This [Obj.magic] is OK because we never allow user code access to [none] (except via\n [unsafe_value]. We disallow [_ Uopt.t Uopt.t], so there is no chance of confusing\n [none] with [some none]. And [float Uopt.t array] is similarly disallowed. *)\nlet none = \"Uopt.none\" |> (Obj.magic : string -> _ t)\nlet is_none t = phys_equal t none\nlet is_some t = not (is_none t)\nlet invariant invariant_a t = if is_some t then invariant_a t\nlet sexp_of_t sexp_of_a t = if is_none t then [%sexp None] else [%sexp Some (t : a)]\nlet some a = a\nlet value_exn t = if is_none t then failwith \"Uopt.value_exn\" else t\nlet unsafe_value t = t\nlet to_option t = if is_none t then None else Some t\n\nlet of_option = function\n | None -> none\n | Some a -> some a\n;;\n\nmodule Optional_syntax = struct\n module Optional_syntax = struct\n let is_none = is_none\n let unsafe_value = unsafe_value\n end\nend\n","(* Be sure and first read the implementation overview in timing_wheel_intf.ml.\n\n A timing wheel is represented as an array of \"levels\", where each level is an array of\n \"slots\". Each slot represents a range of keys, and holds elements associated with\n those keys. Each level is determined by two parameters: [bits], the number of key bits\n that that level is responsible for distinguishing, and [bits_per_slot], the size of the\n range of keys that correspond to a single slot in the array. Conceptually, each level\n breaks up all possible keys into ranges of size [2^bits_per_slot]. The length of a\n level array is [2^bits], and the array is used like a circular buffer to traverse the\n ranges as the timing wheel's [min_allowed_key] increases. A key [k], if stored in the\n level, is stored at index [(k / 2^bits_per_slot) mod 2^bits].\n\n The settings of the [bits] values are configurable by user code using [Level_bits],\n although there is a reasonable default setting. Given the [bits] values, the\n [bits_per_slot] are chosen so that [bits_per_slot] at level [i] is the sum of the\n [bits] at all lower levels. Thus, a slot's range at level [i] is as large as the\n entire range of the array at level [i - 1].\n\n Each level has a [min_allowed_key] and a [max_allowed_key] that determine the range of\n keys that it currently represents. The crucial invariant of the timing wheel data\n structure is that the [min_allowed_key] at level [i] is no more than the\n [max_allowed_key + 1] of level [i - 1]. This ensures that the levels can represent all\n keys from the [min_allowed_key] of the lowest level to the [max_allowed_key] of the\n highest level. The [increase_min_allowed_key] function is responsible for restoring\n this invariant.\n\n At level 0, [bits_per_slot = 0], and so the size of each slot is [1]. That is, level 0\n precisely distinguishes all the keys between its [min_allowed_key] (which is the same\n as the [min_allowed_key] of the entire timing wheel) and [max_allowed_key]. As the\n levels increase, the [min_allowed_key] increases, the [bits_per_slot] increases, and\n the range of keys stored in the level increases (dramatically).\n\n The idea of the implementation is similar to the hierarchical approach described in:\n\n {v\n Hashed and Hierarchical Timing Wheels:\n Efficient Data Structures for Implementing a Timer Facility\n\n Varghese & Lauck, 1996\n v}\n\n However, the code is completely new. *)\n\nopen! Core_kernel\nopen! Import\nopen! Timing_wheel_intf\nmodule Pool = Tuple_pool\nmodule Time_ns = Core_kernel_private.Time_ns_alternate_sexp\n\nlet sexp_of_t_style : [ `Pretty | `Internal ] ref = ref `Pretty\n\n(* [{max,min}_time] are bounds on the times supported by a timing wheel. *)\n\nlet max_time = Time_ns.max_value_representable\nlet min_time = Time_ns.epoch\n\nmodule Num_key_bits : sig\n type t = private int [@@deriving compare, sexp]\n\n include Comparable with type t := t\n include Invariant.S with type t := t\n\n val zero : t\n\n (* val min_value : t *)\n\n val max_value : t\n val to_int : t -> int\n val of_int : int -> t\n val ( + ) : t -> t -> t\n val ( - ) : t -> t -> t\n val pow2 : t -> Int63.t\nend = struct\n include Int\n\n let min_value = 0\n\n (** We support all non-negative [Time_ns.t] values. *)\n let max_value = Int63.num_bits - 1\n\n let invariant t =\n assert (t >= min_value);\n assert (t <= max_value)\n ;;\n\n let of_int i =\n invariant i;\n i\n ;;\n\n let ( + ) t1 t2 =\n let t = t1 + t2 in\n invariant t;\n t\n ;;\n\n let ( - ) t1 t2 =\n let t = t1 - t2 in\n invariant t;\n t\n ;;\n\n let pow2 t = Int63.shift_left Int63.one t\nend\n\nmodule Level_bits = struct\n type t = Num_key_bits.t list [@@deriving compare, sexp]\n\n let max_num_bits = (Num_key_bits.max_value :> int)\n let num_bits_internal t = List.fold t ~init:Num_key_bits.zero ~f:Num_key_bits.( + )\n let num_bits t = (num_bits_internal t :> int)\n\n let invariant t =\n assert (not (List.is_empty t));\n List.iter t ~f:(fun num_key_bits ->\n Num_key_bits.invariant num_key_bits;\n assert (Num_key_bits.( > ) num_key_bits Num_key_bits.zero));\n Num_key_bits.invariant (num_bits_internal t)\n ;;\n\n let t_of_sexp sexp =\n let t = sexp |> [%of_sexp: t] in\n invariant t;\n t\n ;;\n\n let create_exn ?(extend_to_max_num_bits = false) ints =\n if List.is_empty ints then failwith \"Level_bits.create_exn requires a nonempty list\";\n if List.exists ints ~f:(fun bits -> bits <= 0)\n then\n raise_s\n [%message \"Level_bits.create_exn got nonpositive num bits\" ~_:(ints : int list)];\n let num_bits = List.fold ints ~init:0 ~f:( + ) in\n if num_bits > max_num_bits\n then\n raise_s\n [%message\n \"Level_bits.create_exn got too many bits\"\n ~_:(ints : int list)\n ~got:(num_bits : int)\n (max_num_bits : int)];\n let ints =\n if extend_to_max_num_bits\n then ints @ List.init (max_num_bits - num_bits) ~f:(const 1)\n else ints\n in\n List.map ints ~f:Num_key_bits.of_int\n ;;\n\n let default = create_exn [ 11; 10; 10; 10; 10; 10; 1 ]\n\n let trim t ~max_num_bits =\n if Num_key_bits.( <= ) (num_bits_internal t) max_num_bits\n then t\n else (\n let rec loop t ~remaining =\n match t with\n | [] -> []\n | b :: t ->\n if Num_key_bits.( >= ) b remaining\n then [ remaining ]\n else b :: loop t ~remaining:(Num_key_bits.( - ) remaining b)\n in\n loop t ~remaining:max_num_bits)\n ;;\nend\n\nmodule Alarm_precision : sig\n include Alarm_precision\n\n val num_key_bits : t -> Num_key_bits.t\n val interval_num : t -> Time_ns.t -> Int63.t\n val interval_num_start : t -> Int63.t -> Time_ns.t\nend = struct\n (** [t] is represented as the log2 of a number of nanoseconds. *)\n type t = int [@@deriving compare, hash]\n\n let equal = [%compare.equal: t]\n let num_key_bits t = t |> Num_key_bits.of_int\n\n let to_span t =\n if t < 0\n then\n raise_s\n [%message\n \"[Alarm_precision.to_span] of negative power of two nanoseconds\" ~_:(t : int)];\n Int63.(shift_left one) t |> Time_ns.Span.of_int63_ns\n ;;\n\n let sexp_of_t t = [%sexp (t |> to_span : Time_ns.Span.t)]\n let one_nanosecond = 0\n let about_one_microsecond = 10\n let about_one_millisecond = 20\n let about_one_second = 30\n let about_one_day = 46\n let mul t ~pow2 = t + pow2\n let div t ~pow2 = t - pow2\n let interval_num t time = Int63.shift_right (time |> Time_ns.to_int63_ns_since_epoch) t\n\n let interval_num_start t interval_num =\n Int63.shift_left interval_num t |> Time_ns.of_int63_ns_since_epoch\n ;;\n\n let of_span_floor_pow2_ns span =\n if Time_ns.Span.( <= ) span Time_ns.Span.zero\n then\n raise_s\n [%message\n \"[Alarm_precision.of_span_floor_pow2_ns] got non-positive span\"\n (span : Time_ns.Span.t)];\n span |> Time_ns.Span.to_int63_ns |> Int63.floor_log2\n ;;\n\n let of_span = of_span_floor_pow2_ns\n\n module Unstable = struct\n module T = struct\n type nonrec t = t [@@deriving compare]\n\n let of_binable = of_span_floor_pow2_ns\n let to_binable = to_span\n let of_sexpable = of_span_floor_pow2_ns\n let to_sexpable = to_span\n end\n\n include T\n include Binable.Of_binable_without_uuid [@alert \"-legacy\"] (Time_ns.Span) (T)\n include Sexpable.Of_sexpable (Time_ns.Span) (T)\n end\nend\n\nmodule Config = struct\n let level_bits_default = Level_bits.default\n\n type t =\n { alarm_precision : Alarm_precision.Unstable.t\n ; level_bits : Level_bits.t [@default level_bits_default]\n ; capacity : int option [@sexp.option]\n }\n [@@deriving fields, sexp]\n\n let alarm_precision t = Alarm_precision.to_span t.alarm_precision\n\n (* [max_num_level_bits alarm_precision] returns the number of level bits needed for a\n timing wheel with the specified [alarm_precision] to be able to represent all\n possible times from [Time_ns.epoch] onward. Since non-negative times have 62 bits,\n we require [L <= 62 - A], where [A] is the number of alarm bits and [L] is the\n number of level bits. *)\n let max_num_level_bits alarm_precision =\n Num_key_bits.( - )\n Num_key_bits.max_value\n (Alarm_precision.num_key_bits alarm_precision)\n ;;\n\n let invariant t =\n Invariant.invariant [%here] t [%sexp_of: t] (fun () ->\n assert (\n Num_key_bits.( <= )\n (Level_bits.num_bits_internal t.level_bits)\n (max_num_level_bits t.alarm_precision));\n let check f = Invariant.check_field t f in\n Fields.iter\n ~alarm_precision:ignore\n ~capacity:ignore\n ~level_bits:(check Level_bits.invariant))\n ;;\n\n let create ?capacity ?(level_bits = level_bits_default) ~alarm_precision () =\n let level_bits =\n Level_bits.trim level_bits ~max_num_bits:(max_num_level_bits alarm_precision)\n in\n { alarm_precision; level_bits; capacity }\n ;;\n\n let microsecond_precision () =\n create\n ()\n ~alarm_precision:Alarm_precision.about_one_microsecond\n ~level_bits:(Level_bits.create_exn [ 10; 10; 6; 6; 5 ])\n ;;\n\n let durations t =\n List.folding_map\n t.level_bits\n ~init:(Alarm_precision.num_key_bits t.alarm_precision |> Num_key_bits.to_int)\n ~f:(fun num_bits_accum level_num_bits ->\n let num_bits_accum = num_bits_accum + (level_num_bits |> Num_key_bits.to_int) in\n let duration =\n Time_ns.Span.of_int63_ns\n (if num_bits_accum = Int63.num_bits - 1\n then Int63.max_value\n else Int63.shift_left Int63.one num_bits_accum)\n in\n num_bits_accum, duration)\n ;;\nend\n\n\n(** Timing wheel is implemented as a priority queue in which the keys are\n non-negative integers corresponding to the intervals of time. The priority queue is\n unlike a typical priority queue in that rather than having a \"delete min\" operation,\n it has a nondecreasing minimum allowed key, which corresponds to the current time,\n and an [increase_min_allowed_key] operation, which implements [advance_clock].\n [increase_min_allowed_key] as a side effect removes all elements from the timing\n wheel whose key is smaller than the new minimum, which implements firing the alarms\n whose time has expired.\n\n Adding elements to and removing elements from a timing wheel takes constant time,\n unlike a heap-based priority queue which takes log(N), where N is the number of\n elements in the heap. [increase_min_allowed_key] takes time proportional to the\n amount of increase in the min-allowed key, as compared to log(N) for a heap. It is\n these performance differences that motivate the existence of timing wheels and make\n them a good choice for maintaing a set of alarms. With a timing wheel, one can\n support any number of alarms paying constant overhead per alarm, while paying a\n small constant overhead per unit of time passed.\n\n As the minimum allowed key increases, the timing wheel does a lazy radix sort of the\n element keys, with level 0 handling the least significant [b_0] bits in a key, and\n each subsequent level [i] handling the next most significant [b_i] bits. The levels\n hold increasingly larger ranges of keys, where the union of all the levels can hold\n any key from [min_allowed_key t] to [max_allowed_key t]. When a key is added to the\n timing wheel, it is added at the lowest possible level that can store the key. As\n the minimum allowed key increases, timing-wheel elements move down levels until they\n reach level 0, and then are eventually removed. *)\nmodule Priority_queue : sig\n type 'a t [@@deriving sexp_of]\n type 'a priority_queue = 'a t\n\n module Key : Interval_num\n\n module Elt : sig\n (** An [Elt.t] represents an element that was added to a timing wheel. *)\n type 'a t [@@deriving sexp_of]\n\n val at : 'a priority_queue -> 'a t -> Time_ns.t\n val key : 'a priority_queue -> 'a t -> Key.t\n val value : 'a priority_queue -> 'a t -> 'a\n val null : unit -> 'a t\n end\n\n module Internal_elt : sig\n module Pool : sig\n type 'a t\n end\n\n type 'a t\n\n val key : 'a Pool.t -> 'a t -> Key.t\n val max_alarm_time : 'a Pool.t -> 'a t -> with_key:Key.t -> Time_ns.t\n val is_null : _ t -> bool\n val to_external : 'a t -> 'a Elt.t\n end\n\n val pool : 'a t -> 'a Internal_elt.Pool.t\n\n include Invariant.S1 with type 'a t := 'a t\n\n (** [create ?level_bits ()] creates a new empty timing wheel, [t], with [length t = 0]\n and [min_allowed_key t = 0]. *)\n val create : ?capacity:int -> ?level_bits:Level_bits.t -> unit -> 'a t\n\n (** [length t] returns the number of elements in the timing wheel. *)\n val length : _ t -> int\n\n (** [min_allowed_key t] is the minimum key that can be stored in [t]. This only\n indicates the possibility; there need not be an element [elt] in [t] with [Elt.key\n elt = min_allowed_key t]. This is not the same as the \"min_key\" operation in a\n typical priority queue.\n\n [min_allowed_key t] can increase over time, via calls to\n [increase_min_allowed_key]. *)\n val min_allowed_key : _ t -> Key.t\n\n (** [max_allowed_key t] is the maximum allowed key that can be stored in [t]. As\n [min_allowed_key] increases, so does [max_allowed_key]; however it is not the case\n that [max_allowed_key t - min_allowed_key t] is a constant. It is guaranteed that\n [max_allowed_key t >= min_allowed_key t + 2^B - 1],\n where [B] is the sum of the b_i in [level_bits]. *)\n val max_allowed_key : _ t -> Key.t\n\n val min_elt_ : 'a t -> 'a Internal_elt.t\n val internal_add : 'a t -> key:Key.t -> at:Time_ns.t -> 'a -> 'a Internal_elt.t\n\n (** [remove t elt] removes [elt] from [t]. It is an error if [elt] is not currently\n in [t], and this error may or may not be detected. *)\n val remove : 'a t -> 'a Elt.t -> unit\n\n val change : 'a t -> 'a Elt.t -> key:Key.t -> at:Time_ns.t -> unit\n\n (** [clear t] removes all elts from [t]. *)\n val clear : _ t -> unit\n\n val mem : 'a t -> 'a Elt.t -> bool\n\n (** [increase_min_allowed_key t ~key ~handle_removed] increases the minimum allowed\n key in [t] to [key], and removes all elements with keys less than [key], applying\n [handle_removed] to each element that is removed. If [key <= min_allowed_key t],\n then [increase_min_allowed_key] does nothing. Otherwise, if\n [increase_min_allowed_key] returns successfully, [min_allowed_key t = key].\n\n [increase_min_allowed_key] takes time proportional to [key - min_allowed_key t],\n although possibly less time.\n\n Behavior is unspecified if [handle_removed] accesses [t] in any way other than\n [Elt] functions. *)\n val increase_min_allowed_key\n : 'a t\n -> key:Key.t\n -> handle_removed:('a Elt.t -> unit)\n -> unit\n\n val iter : 'a t -> f:('a Elt.t -> unit) -> unit\n\n val fire_past_alarms\n : 'a t\n -> handle_fired:('a Elt.t -> unit)\n -> key:Key.t\n -> now:Time_ns.t\n -> unit\nend = struct\n (** Each slot in a level is a (possibly null) pointer to a circular doubly-linked list\n of elements. We pool the elements so that we can reuse them after they are removed\n from the timing wheel (either via [remove] or [increase_min_allowed_key]). In\n addition to storing the [key], [at], and [value] in the element, we store the\n [level_index] so that we can quickly get to the level holding an element when we\n [remove] it.\n\n We distinguish between [External_elt] and [Internal_elt], which are the same\n underneath. We maintain the invariant that an [Internal_elt] is either [null] or a\n valid pointer. On the other hand, [External_elt]s are returned to user code, so\n there is no guarantee of validity -- we always validate an [External_elt] before\n doing anything with it.\n\n It is therefore OK to use [Pool.Unsafe], because we will never attempt to access a\n slot of an invalid pointer. *)\n module Pool = Pool.Unsafe\n\n module Pointer = Pool.Pointer\n\n module Key : sig\n (** [Interval_num] is the public API. Everything following in the signature is\n for internal use. *)\n include\n Timing_wheel_intf.Interval_num\n\n (** [add_clamp_to_max] doesn't work at all with negative spans *)\n val add_clamp_to_max : t -> Span.t -> t\n\n val succ_clamp_to_max : t -> t\n\n (** [Slots_mask] is used to quickly determine a key's slot in a given level. *)\n module Slots_mask : sig\n type t = private Int63.t [@@deriving compare, sexp_of]\n\n val create : level_bits:Num_key_bits.t -> t\n val next_slot : t -> int -> int\n end\n\n (** [Min_key_in_same_slot_mask] is used to quickly determine the minimum key in the\n same slot as a given key. *)\n module Min_key_in_same_slot_mask : sig\n type t = private Int63.t [@@deriving compare, sexp_of]\n\n include Equal.S with type t := t\n\n val create : bits_per_slot:Num_key_bits.t -> t\n end\n\n val num_keys : Num_key_bits.t -> Span.t\n val min_key_in_same_slot : t -> Min_key_in_same_slot_mask.t -> t\n val slot : t -> bits_per_slot:Num_key_bits.t -> slots_mask:Slots_mask.t -> int\n end = struct\n module Slots_mask = struct\n type t = Int63.t [@@deriving compare, sexp_of]\n\n let create ~level_bits = Int63.( - ) (Num_key_bits.pow2 level_bits) Int63.one\n let next_slot t slot = (slot + 1) land Int63.to_int_exn t\n end\n\n let num_keys num_bits = Num_key_bits.pow2 num_bits\n\n module Min_key_in_same_slot_mask = struct\n include Int63\n\n let create ~bits_per_slot = bit_not (Num_key_bits.pow2 bits_per_slot - one)\n end\n\n module Span = struct\n include Int63\n\n let to_int63 t = t\n let of_int63 i = i\n let scale_int t i = t * of_int i\n end\n\n include Int63\n\n let of_int63 i = i\n let to_int63 t = t\n let add t i = t + i\n let add_clamp_to_max t i = if t > max_value - i then max_value else t + i\n let succ_clamp_to_max t = if t = max_value then max_value else succ t\n let sub t i = t - i\n let diff t1 t2 = t1 - t2\n\n let slot t ~(bits_per_slot : Num_key_bits.t) ~slots_mask =\n to_int_exn (bit_and (shift_right t (bits_per_slot :> int)) slots_mask)\n ;;\n\n let min_key_in_same_slot t min_key_in_same_slot_mask =\n bit_and t min_key_in_same_slot_mask\n ;;\n end\n\n module Min_key_in_same_slot_mask = Key.Min_key_in_same_slot_mask\n module Slots_mask = Key.Slots_mask\n\n module External_elt = struct\n\n (** The [pool_slots] here has nothing to do with the slots in a level array. This is\n for the slots in the pool tuple representing a level element. *)\n type 'a pool_slots =\n ( Key.t\n , Time_ns.t\n , 'a\n , int\n , 'a pool_slots Pointer.t\n , 'a pool_slots Pointer.t )\n Pool.Slots.t6\n [@@deriving sexp_of]\n\n type 'a t = 'a pool_slots Pointer.t [@@deriving sexp_of]\n\n let null = Pointer.null\n end\n\n module Internal_elt : sig\n module Pool : sig\n type 'a t [@@deriving sexp_of]\n\n include Invariant.S1 with type 'a t := 'a t\n\n val create : ?capacity:int -> unit -> _ t\n val is_full : _ t -> bool\n val grow : ?capacity:int -> 'a t -> 'a t\n end\n\n type 'a t = private 'a External_elt.t [@@deriving sexp_of]\n\n val null : unit -> _ t\n val is_null : _ t -> bool\n val is_valid : 'a Pool.t -> 'a t -> bool\n\n (** Dealing with [External_elt]s. *)\n\n val external_is_valid : 'a Pool.t -> 'a External_elt.t -> bool\n val to_external : 'a t -> 'a External_elt.t\n val of_external_exn : 'a Pool.t -> 'a External_elt.t -> 'a t\n val equal : 'a t -> 'a t -> bool\n val invariant : 'a Pool.t -> ('a -> unit) -> 'a t -> unit\n\n (** [create] returns an element whose [next] and [prev] are [null]. *)\n val create\n : 'a Pool.t\n -> key:Key.t\n (** [at] is used when the priority queue is used to implement a timing wheel. If\n unused, it will be [Time_ns.epoch]. *)\n -> at:Time_ns.t\n -> value:'a\n -> level_index:int\n -> 'a t\n\n val free : 'a Pool.t -> 'a t -> unit\n\n (** accessors *)\n\n val key : 'a Pool.t -> 'a t -> Key.t\n val at : 'a Pool.t -> 'a t -> Time_ns.t\n val level_index : 'a Pool.t -> 'a t -> int\n val next : 'a Pool.t -> 'a t -> 'a t\n val value : 'a Pool.t -> 'a t -> 'a\n\n (** mutators *)\n\n val set_key : 'a Pool.t -> 'a t -> Key.t -> unit\n val set_at : 'a Pool.t -> 'a t -> Time_ns.t -> unit\n val set_level_index : 'a Pool.t -> 'a t -> int -> unit\n\n (** [insert_at_end pool t ~to_add] treats [t] as the head of the list and adds [to_add]\n to the end of it. *)\n val insert_at_end : 'a Pool.t -> 'a t -> to_add:'a t -> unit\n\n (** [link_to_self pool t] makes [t] be a singleton circular doubly-linked list. *)\n val link_to_self : 'a Pool.t -> 'a t -> unit\n\n (** [unlink p t] unlinks [t] from the circularly doubly-linked list that it is in. It\n changes the pointers of [t]'s [prev] and [next] elts, but not [t]'s [prev] and\n [next] pointers. [unlink] is meaningless if [t] is a singleton. *)\n val unlink : 'a Pool.t -> 'a t -> unit\n\n (** Iterators. [iter p t ~init ~f] visits each element in the doubly-linked list\n containing [t], starting at [t], and following [next] pointers. [length] counts\n by visiting each element in the list. *)\n val iter : 'a Pool.t -> 'a t -> f:('a t -> unit) -> unit\n\n val length : 'a Pool.t -> 'a t -> int\n\n (** [max_alarm_time t elt ~with_key] finds the max [at] in [elt]'s list among the elts\n whose key is [with_key], returning [Time_ns.epoch] if the list is empty. *)\n val max_alarm_time : 'a Pool.t -> 'a t -> with_key:Key.t -> Time_ns.t\n end = struct\n type 'a pool_slots = 'a External_elt.pool_slots [@@deriving sexp_of]\n type 'a t = 'a External_elt.t [@@deriving sexp_of]\n\n let null = Pointer.null\n let is_null = Pointer.is_null\n let equal t1 t2 = Pointer.phys_equal t1 t2\n\n let create pool ~key ~at ~value ~level_index =\n Pool.new6 pool key at value level_index (null ()) (null ())\n ;;\n\n let free = Pool.free\n let key p t = Pool.get p t Pool.Slot.t0\n let set_key p t k = Pool.set p t Pool.Slot.t0 k\n let at p t = Pool.get p t Pool.Slot.t1\n let set_at p t x = Pool.set p t Pool.Slot.t1 x\n let value p t = Pool.get p t Pool.Slot.t2\n let level_index p t = Pool.get p t Pool.Slot.t3\n let set_level_index p t i = Pool.set p t Pool.Slot.t3 i\n let prev p t = Pool.get p t Pool.Slot.t4\n let set_prev p t x = Pool.set p t Pool.Slot.t4 x\n let next p t = Pool.get p t Pool.Slot.t5\n let set_next p t x = Pool.set p t Pool.Slot.t5 x\n let is_valid p t = Pool.pointer_is_valid p t\n let external_is_valid = is_valid\n\n let invariant pool invariant_a t =\n Invariant.invariant [%here] t [%sexp_of: _ t] (fun () ->\n assert (is_valid pool t);\n invariant_a (value pool t);\n let n = next pool t in\n assert (is_null n || Pointer.phys_equal t (prev pool n));\n let p = prev pool t in\n assert (is_null p || Pointer.phys_equal t (next pool p)))\n ;;\n\n module Pool = struct\n type 'a t = 'a pool_slots Pool.t [@@deriving sexp_of]\n\n let invariant _invariant_a t = Pool.invariant ignore t\n let create ?(capacity = 1) () = Pool.create Pool.Slots.t6 ~capacity\n let grow = Pool.grow\n let is_full = Pool.is_full\n end\n\n let to_external t = t\n\n let of_external_exn pool t =\n if is_valid pool t then t else raise_s [%message \"Timing_wheel got invalid alarm\"]\n ;;\n\n let unlink pool t =\n set_next pool (prev pool t) (next pool t);\n set_prev pool (next pool t) (prev pool t)\n ;;\n\n let link pool prev next =\n set_next pool prev next;\n set_prev pool next prev\n ;;\n\n let link_to_self pool t = link pool t t\n\n let insert_at_end pool t ~to_add =\n let prev = prev pool t in\n link pool prev to_add;\n link pool to_add t\n ;;\n\n let iter pool first ~f =\n let current = ref first in\n let continue = ref true in\n while !continue do\n (* We get [next] before calling [f] so that [f] can modify or [free] [!current]. *)\n let next = next pool !current in\n f !current;\n if phys_equal next first then continue := false else current := next\n done\n ;;\n\n let length pool first =\n let r = ref 0 in\n let current = ref first in\n let continue = ref true in\n while !continue do\n incr r;\n let next = next pool !current in\n if phys_equal next first then continue := false else current := next\n done;\n !r\n ;;\n\n let max_alarm_time pool first ~with_key =\n let max_alarm_time = ref Time_ns.epoch in\n let current = ref first in\n let continue = ref true in\n while !continue do\n let next = next pool !current in\n if Key.equal (key pool !current) with_key\n then max_alarm_time := Time_ns.max (at pool !current) !max_alarm_time;\n if phys_equal next first then continue := false else current := next\n done;\n !max_alarm_time\n ;;\n end\n\n module Level = struct\n (** For given level, one can break the bits into a key into three regions:\n\n {v\n | higher levels | this level | lower levels |\n v}\n\n \"Lower levels\" is [bits_per_slot] bits wide. \"This level\" is [bits] wide. *)\n type 'a t =\n { (* The [index] in the timing wheel's array of levels where this level is. *)\n index : int\n ; (* How many [bits] this level is responsible for. *)\n bits : Num_key_bits.t\n ; (* [slots_mask = Slots_mask.create ~level_bits:t.bits]. *)\n slots_mask : Slots_mask.t\n ; (* [bits_per_slot] is how many bits each slot distinguishes, and is the sum of of\n the [bits] of all the lower levels. *)\n bits_per_slot : Num_key_bits.t\n ; keys_per_slot : Key.Span.t\n ; min_key_in_same_slot_mask : Min_key_in_same_slot_mask.t\n ; (* [diff_max_min_allowed_key = keys_per_slot * Array.length slots - 1] *)\n diff_max_min_allowed_key : Key.Span.t\n ; (* [length] is the number of elts currently in this level. *)\n mutable length : int\n ; (* All elements at this level have their [key] satisfy [min_allowed_key <= key <=\n max_allowed_key]. Also, [min_allowed_key] is a multiple of [keys_per_slot]. *)\n mutable min_allowed_key : Key.t\n ; mutable max_allowed_key : Key.t\n ; (* [slots] holds the (possibly null) pointers to the circular doubly-linked lists\n of elts. [Array.length slots = 1 lsl bits]. *)\n slots : ('a Internal_elt.t array[@sexp.opaque])\n }\n [@@deriving fields, sexp_of]\n\n let slot t ~key =\n Key.slot key ~bits_per_slot:t.bits_per_slot ~slots_mask:t.slots_mask\n ;;\n\n let next_slot t slot = Slots_mask.next_slot t.slots_mask slot\n\n let min_key_in_same_slot t ~key =\n Key.min_key_in_same_slot key t.min_key_in_same_slot_mask\n ;;\n\n let compute_min_allowed_key t ~prev_level_max_allowed_key =\n (* This computation ensures that [t]'s [min_allowed_key] is as large as possible\n subject to the constraint that there is no inter-level gap. *)\n if Key.equal prev_level_max_allowed_key Key.max_value\n then Key.max_value\n else min_key_in_same_slot t ~key:(Key.succ prev_level_max_allowed_key)\n ;;\n end\n\n type 'a t =\n { mutable length : int\n ; mutable pool : 'a Internal_elt.Pool.t\n ; (* [min_elt] is either null or an element whose key is [elt_key_lower_bound]. *)\n mutable min_elt : 'a Internal_elt.t\n ; (* All elements in the priority queue have their key [>= elt_key_lower_bound]. *)\n mutable elt_key_lower_bound : Key.t\n ; levels : 'a Level.t array\n }\n [@@deriving fields, sexp_of]\n\n type 'a priority_queue = 'a t\n\n module Elt = struct\n type 'a t = 'a External_elt.t [@@deriving sexp_of]\n\n let null = External_elt.null\n let at p t = Internal_elt.at p.pool (Internal_elt.of_external_exn p.pool t)\n let key p t = Internal_elt.key p.pool (Internal_elt.of_external_exn p.pool t)\n let value p t = Internal_elt.value p.pool (Internal_elt.of_external_exn p.pool t)\n end\n\n let sexp_of_t_internal = sexp_of_t\n let is_empty t = length t = 0\n let num_levels t = Array.length t.levels\n let min_allowed_key t = Level.min_allowed_key t.levels.(0)\n let max_allowed_key t = Level.max_allowed_key t.levels.(num_levels t - 1)\n\n let internal_iter t ~f =\n if t.length > 0\n then (\n let pool = t.pool in\n let levels = t.levels in\n for level_index = 0 to Array.length levels - 1 do\n let level = levels.(level_index) in\n if level.length > 0\n then (\n let slots = level.slots in\n for slot_index = 0 to Array.length slots - 1 do\n let elt = slots.(slot_index) in\n if not (Internal_elt.is_null elt) then Internal_elt.iter pool elt ~f\n done)\n done)\n ;;\n\n let iter t ~f = internal_iter t ~f:(f : _ Elt.t -> unit :> _ Internal_elt.t -> unit)\n\n module Pretty = struct\n module Elt = struct\n type 'a t =\n { key : Key.t\n ; value : 'a\n }\n [@@deriving sexp_of]\n end\n\n type 'a t =\n { min_allowed_key : Key.t\n ; max_allowed_key : Key.t\n ; elts : 'a Elt.t list\n }\n [@@deriving sexp_of]\n end\n\n let pretty t =\n let pool = t.pool in\n { Pretty.min_allowed_key = min_allowed_key t\n ; max_allowed_key = max_allowed_key t\n ; elts =\n (let r = ref [] in\n internal_iter t ~f:(fun elt ->\n r\n := { Pretty.Elt.key = Internal_elt.key pool elt\n ; value = Internal_elt.value pool elt\n }\n :: !r);\n List.rev !r)\n }\n ;;\n\n let sexp_of_t sexp_of_a t =\n match !sexp_of_t_style with\n | `Internal -> [%sexp (t : a t_internal)]\n | `Pretty -> [%sexp (pretty t : a Pretty.t)]\n ;;\n\n let compute_diff_max_min_allowed_key ~level_bits ~bits_per_slot =\n let bits = Num_key_bits.( + ) level_bits bits_per_slot in\n if Num_key_bits.equal bits Num_key_bits.max_value\n then Key.Span.max_value\n else Key.Span.pred (Key.num_keys bits)\n ;;\n\n let invariant invariant_a t : unit =\n let pool = t.pool in\n let level_invariant level =\n Invariant.invariant [%here] level [%sexp_of: _ Level.t] (fun () ->\n let check f = Invariant.check_field level f in\n Level.Fields.iter\n ~index:(check (fun index -> assert (index >= 0)))\n ~bits:\n (check (fun bits -> assert (Num_key_bits.( > ) bits Num_key_bits.zero)))\n ~slots_mask:\n (check\n ([%test_result: Slots_mask.t]\n ~expect:(Slots_mask.create ~level_bits:level.bits)))\n ~bits_per_slot:\n (check (fun bits_per_slot ->\n assert (Num_key_bits.( >= ) bits_per_slot Num_key_bits.zero)))\n ~keys_per_slot:\n (check (fun keys_per_slot ->\n [%test_result: Key.Span.t]\n keys_per_slot\n ~expect:(Key.num_keys level.bits_per_slot)))\n ~min_key_in_same_slot_mask:\n (check (fun min_key_in_same_slot_mask ->\n assert (\n Min_key_in_same_slot_mask.equal\n min_key_in_same_slot_mask\n (Min_key_in_same_slot_mask.create\n ~bits_per_slot:level.bits_per_slot))))\n ~diff_max_min_allowed_key:\n (check\n ([%test_result: Key.Span.t]\n ~expect:\n (compute_diff_max_min_allowed_key\n ~level_bits:level.bits\n ~bits_per_slot:level.bits_per_slot)))\n ~length:\n (check (fun length ->\n assert (\n length\n = Array.fold level.slots ~init:0 ~f:(fun n elt ->\n if Internal_elt.is_null elt\n then n\n else n + Internal_elt.length pool elt))))\n ~min_allowed_key:\n (check (fun min_allowed_key ->\n assert (Key.( >= ) min_allowed_key Key.zero);\n if Key.( < ) min_allowed_key Key.max_value\n then\n [%test_result: Key.Span.t]\n (Key.rem min_allowed_key level.keys_per_slot)\n ~expect:Key.Span.zero))\n ~max_allowed_key:\n (check (fun max_allowed_key ->\n [%test_result: Key.t]\n max_allowed_key\n ~expect:\n (Key.add_clamp_to_max\n level.min_allowed_key\n level.diff_max_min_allowed_key)))\n ~slots:\n (check (fun slots ->\n Array.iter slots ~f:(fun elt ->\n if not (Internal_elt.is_null elt)\n then (\n Internal_elt.invariant pool invariant_a elt;\n Internal_elt.iter pool elt ~f:(fun elt ->\n assert (\n Key.( >= )\n (Internal_elt.key pool elt)\n level.min_allowed_key);\n assert (\n Key.( <= )\n (Internal_elt.key pool elt)\n level.max_allowed_key);\n assert (\n Key.( >= )\n (Internal_elt.key pool elt)\n t.elt_key_lower_bound);\n assert (Internal_elt.level_index pool elt = level.index);\n invariant_a (Internal_elt.value pool elt)))))))\n in\n Invariant.invariant [%here] t [%sexp_of: _ t_internal] (fun () ->\n let check f = Invariant.check_field t f in\n assert (Key.( >= ) (min_allowed_key t) Key.zero);\n assert (Key.( >= ) (max_allowed_key t) (min_allowed_key t));\n Fields.iter\n ~length:(check (fun length -> assert (length >= 0)))\n ~pool:(check (Internal_elt.Pool.invariant ignore))\n ~min_elt:\n (check (fun elt_ ->\n if not (Internal_elt.is_null elt_)\n then (\n assert (Internal_elt.is_valid t.pool elt_);\n assert (Key.equal t.elt_key_lower_bound (Internal_elt.key t.pool elt_)))))\n ~elt_key_lower_bound:\n (check (fun elt_key_lower_bound ->\n assert (Key.( >= ) elt_key_lower_bound (min_allowed_key t));\n assert (Key.( <= ) elt_key_lower_bound (max_allowed_key t));\n if not (Internal_elt.is_null t.min_elt)\n then\n assert (\n Key.equal elt_key_lower_bound (Internal_elt.key t.pool t.min_elt))))\n ~levels:\n (check (fun levels ->\n assert (num_levels t > 0);\n Array.iteri levels ~f:(fun level_index level ->\n assert (level_index = Level.index level);\n level_invariant level;\n if level_index > 0\n then (\n let prev_level = levels.(level_index - 1) in\n let module L = Level in\n [%test_result: Key.Span.t]\n (L.keys_per_slot level)\n ~expect:(Key.Span.succ prev_level.diff_max_min_allowed_key);\n [%test_result: Key.t]\n level.min_allowed_key\n ~expect:\n (Level.compute_min_allowed_key\n level\n ~prev_level_max_allowed_key:prev_level.max_allowed_key))))))\n ;;\n\n (** [min_elt_] returns [null] if it can't find the desired element. We wrap it up\n afterwards to return an [option]. *)\n let min_elt_ t =\n if is_empty t\n then Internal_elt.null ()\n else if not (Internal_elt.is_null t.min_elt)\n then t.min_elt\n else (\n let pool = t.pool in\n let min_elt_already_found = ref (Internal_elt.null ()) in\n let min_key_already_found = ref Key.max_value in\n let level_index = ref 0 in\n let num_levels = num_levels t in\n while !level_index < num_levels do\n let level = t.levels.(!level_index) in\n if Key.( > ) (Level.min_allowed_key level) !min_key_already_found\n then\n (* We don't need to consider any more levels. Quit the loop. *)\n level_index := num_levels\n else if level.length = 0\n then incr level_index\n else (\n (* Look in [level]. *)\n let slots = level.slots in\n let slot_min_key =\n ref\n (Level.min_key_in_same_slot\n level\n ~key:(Key.max level.min_allowed_key t.elt_key_lower_bound))\n in\n let slot = ref (Level.slot level ~key:!slot_min_key) in\n (* Find the first nonempty slot with a small enough [slot_min_key]. *)\n while\n Internal_elt.is_null slots.(!slot)\n && Key.( < ) !slot_min_key !min_key_already_found\n do\n slot := Level.next_slot level !slot;\n slot_min_key := Key.add !slot_min_key level.keys_per_slot\n done;\n let first = slots.(!slot) in\n if not (Internal_elt.is_null first)\n then (\n (* Visit all of the elts in this slot and find one with minimum key. *)\n let continue = ref true in\n let current = ref first in\n while !continue do\n let current_key = Internal_elt.key pool !current in\n if Key.( <= ) current_key !min_key_already_found\n then (\n min_elt_already_found := !current;\n min_key_already_found := current_key);\n let next = Internal_elt.next pool !current in\n (* If [!level_index = 0] then all elts in this slot have the same [key],\n i.e. [!slot_min_key]. So, we don't have to check any elements after\n [first]. This is a useful short cut in the common case that there are\n multiple elements in the same min slot in level 0. *)\n if phys_equal next first || !level_index = 0\n then continue := false\n else current := next\n done);\n (* Finished looking in [level]. Move up to the next level. *)\n incr level_index)\n done;\n t.min_elt <- !min_elt_already_found;\n t.elt_key_lower_bound <- !min_key_already_found;\n t.min_elt)\n ;;\n\n let[@cold] raise_add_elt_key_out_of_bounds t key =\n raise_s\n [%message\n \"Priority_queue.add_elt key out of bounds\"\n (key : Key.t)\n (min_allowed_key t : Key.t)\n (max_allowed_key t : Key.t)\n ~priority_queue:(t : _ t)]\n ;;\n\n let[@cold] raise_add_elt_key_out_of_level_bounds key level =\n raise_s\n [%message\n \"Priority_queue.add_elt key out of level bounds\"\n (key : Key.t)\n (level : _ Level.t)]\n ;;\n\n let add_elt t elt =\n let pool = t.pool in\n let key = Internal_elt.key pool elt in\n if not (Key.( >= ) key (min_allowed_key t) && Key.( <= ) key (max_allowed_key t))\n then raise_add_elt_key_out_of_bounds t key;\n (* Find the lowest level that will hold [elt]. *)\n let level_index =\n let level_index = ref 0 in\n while Key.( > ) key (Level.max_allowed_key t.levels.(!level_index)) do\n incr level_index\n done;\n !level_index\n in\n let level = t.levels.(level_index) in\n if not (Key.( >= ) key level.min_allowed_key && Key.( <= ) key level.max_allowed_key)\n then raise_add_elt_key_out_of_level_bounds key level;\n level.length <- level.length + 1;\n Internal_elt.set_level_index pool elt level_index;\n let slot = Level.slot level ~key in\n let slots = level.slots in\n let first = slots.(slot) in\n if not (Internal_elt.is_null first)\n then Internal_elt.insert_at_end pool first ~to_add:elt\n else (\n slots.(slot) <- elt;\n Internal_elt.link_to_self pool elt)\n ;;\n\n let internal_add_elt t elt =\n let key = Internal_elt.key t.pool elt in\n if Key.( < ) key t.elt_key_lower_bound\n then (\n t.min_elt <- elt;\n t.elt_key_lower_bound <- key);\n add_elt t elt;\n t.length <- t.length + 1\n ;;\n\n let[@cold] raise_got_invalid_key t key =\n raise_s\n [%message\n \"Timing_wheel.add_at_interval_num got invalid interval num\"\n ~interval_num:(key : Key.t)\n ~min_allowed_alarm_interval_num:(min_allowed_key t : Key.t)\n ~max_allowed_alarm_interval_num:(max_allowed_key t : Key.t)]\n ;;\n\n let ensure_valid_key t ~key =\n if Key.( < ) key (min_allowed_key t) || Key.( > ) key (max_allowed_key t)\n then raise_got_invalid_key t key\n ;;\n\n let internal_add t ~key ~at value =\n ensure_valid_key t ~key;\n if Internal_elt.Pool.is_full t.pool then t.pool <- Internal_elt.Pool.grow t.pool;\n let elt = Internal_elt.create t.pool ~key ~at ~value ~level_index:(-1) in\n internal_add_elt t elt;\n elt\n ;;\n\n (** [remove_or_re_add_elts] visits each element in the circular doubly-linked list\n [first]. If the element's key is [>= t_min_allowed_key], then it adds the element\n back at a lower level. If not, then it calls [handle_removed] and [free]s the\n element. *)\n let remove_or_re_add_elts\n t\n (level : _ Level.t)\n first\n ~t_min_allowed_key\n ~handle_removed\n =\n let pool = t.pool in\n let current = ref first in\n let continue = ref true in\n while !continue do\n (* We extract [next] from [current] first, because we will modify or [free]\n [current] before continuing the loop. *)\n let next = Internal_elt.next pool !current in\n level.length <- level.length - 1;\n if Key.( >= ) (Internal_elt.key pool !current) t_min_allowed_key\n then add_elt t !current\n else (\n t.length <- t.length - 1;\n handle_removed (Internal_elt.to_external !current);\n Internal_elt.free pool !current);\n if phys_equal next first then continue := false else current := next\n done\n ;;\n\n (** [increase_level_min_allowed_key] increases the [min_allowed_key] of [level] to as\n large a value as possible, but no more than [max_level_min_allowed_key].\n [t_min_allowed_key] is the minimum allowed key for the entire timing wheel. As\n elements are encountered, they are removed from the timing wheel if their key is\n smaller than [t_min_allowed_key], or added at a lower level if not. *)\n let increase_level_min_allowed_key\n t\n (level : _ Level.t)\n ~prev_level_max_allowed_key\n ~t_min_allowed_key\n ~handle_removed\n =\n let desired_min_allowed_key =\n Level.compute_min_allowed_key level ~prev_level_max_allowed_key\n in\n (* We require that [mod level.min_allowed_key level.keys_per_slot = 0]. So,\n we start [level_min_allowed_key] where that is true, and then increase it by\n [keys_per_slot] each iteration of the loop. *)\n let level_min_allowed_key =\n Level.min_key_in_same_slot\n level\n ~key:\n (Key.min\n desired_min_allowed_key\n (Key.max level.min_allowed_key t.elt_key_lower_bound))\n in\n let level_min_allowed_key = ref level_min_allowed_key in\n let slot = ref (Level.slot level ~key:!level_min_allowed_key) in\n let keys_per_slot = level.keys_per_slot in\n let slots = level.slots in\n while Key.( < ) !level_min_allowed_key desired_min_allowed_key do\n if level.length = 0\n then\n (* If no elements remain at this level, we can just set [min_allowed_key] to the\n desired value. *)\n level_min_allowed_key := desired_min_allowed_key\n else (\n let first = slots.(!slot) in\n if not (Internal_elt.is_null first)\n then (\n slots.(!slot) <- Internal_elt.null ();\n remove_or_re_add_elts t level first ~t_min_allowed_key ~handle_removed);\n slot := Level.next_slot level !slot;\n level_min_allowed_key\n := Key.add_clamp_to_max !level_min_allowed_key keys_per_slot)\n done;\n level.min_allowed_key <- desired_min_allowed_key;\n level.max_allowed_key\n <- Key.add_clamp_to_max desired_min_allowed_key level.diff_max_min_allowed_key\n ;;\n\n let increase_min_allowed_key t ~key ~handle_removed =\n if Key.( > ) key (min_allowed_key t)\n then (\n (* We increase the [min_allowed_key] of levels in order to restore the invariant\n that they have as large as possible a [min_allowed_key], while leaving no gaps\n in keys. *)\n let level_index = ref 0 in\n let prev_level_max_allowed_key = ref (Key.pred key) in\n let levels = t.levels in\n let num_levels = num_levels t in\n while !level_index < num_levels do\n let level = levels.(!level_index) in\n let min_allowed_key_before = level.min_allowed_key in\n increase_level_min_allowed_key\n t\n level\n ~prev_level_max_allowed_key:!prev_level_max_allowed_key\n ~t_min_allowed_key:key\n ~handle_removed;\n if Key.equal (Level.min_allowed_key level) min_allowed_key_before\n then\n (* This level did not shift. Don't shift any higher levels. *)\n level_index := num_levels\n else (\n (* Level [level_index] shifted. Consider shifting higher levels. *)\n level_index := !level_index + 1;\n prev_level_max_allowed_key := Level.max_allowed_key level)\n done;\n if Key.( > ) key t.elt_key_lower_bound\n then (\n (* We have removed [t.min_elt] or it was already null, so just set it to\n null. *)\n t.min_elt <- Internal_elt.null ();\n t.elt_key_lower_bound <- min_allowed_key t))\n ;;\n\n let create ?capacity ?level_bits () =\n let level_bits =\n match level_bits with\n | Some l -> l\n | None -> Level_bits.default\n in\n let _, _, levels =\n List.foldi\n level_bits\n ~init:(Num_key_bits.zero, Key.zero, [])\n ~f:(fun index\n (bits_per_slot, max_level_min_allowed_key, levels)\n (level_bits : Num_key_bits.t)\n ->\n let keys_per_slot = Key.num_keys bits_per_slot in\n let diff_max_min_allowed_key =\n compute_diff_max_min_allowed_key ~level_bits ~bits_per_slot\n in\n let min_key_in_same_slot_mask =\n Min_key_in_same_slot_mask.create ~bits_per_slot\n in\n let min_allowed_key =\n Key.min_key_in_same_slot max_level_min_allowed_key min_key_in_same_slot_mask\n in\n let max_allowed_key =\n Key.add_clamp_to_max min_allowed_key diff_max_min_allowed_key\n in\n let level =\n { Level.index\n ; bits = level_bits\n ; slots_mask = Slots_mask.create ~level_bits\n ; bits_per_slot\n ; keys_per_slot\n ; min_key_in_same_slot_mask\n ; diff_max_min_allowed_key\n ; length = 0\n ; min_allowed_key\n ; max_allowed_key\n ; slots =\n Array.create\n ~len:(Int63.to_int_exn (Num_key_bits.pow2 level_bits))\n (Internal_elt.null ())\n }\n in\n ( Num_key_bits.( + ) level_bits bits_per_slot\n , Key.succ_clamp_to_max max_allowed_key\n , level :: levels ))\n in\n { length = 0\n ; pool = Internal_elt.Pool.create ?capacity ()\n ; min_elt = Internal_elt.null ()\n ; elt_key_lower_bound = Key.zero\n ; levels = Array.of_list_rev levels\n }\n ;;\n\n let mem t elt = Internal_elt.external_is_valid t.pool elt\n\n let internal_remove t elt =\n let pool = t.pool in\n if Internal_elt.equal elt t.min_elt\n then\n t.min_elt <- Internal_elt.null ()\n (* We keep [t.elt_lower_bound] since it is valid even though [t.min_elt] is being\n removed. *);\n t.length <- t.length - 1;\n let level = t.levels.(Internal_elt.level_index pool elt) in\n level.length <- level.length - 1;\n let slots = level.slots in\n let slot = Level.slot level ~key:(Internal_elt.key pool elt) in\n let first = slots.(slot) in\n if phys_equal elt (Internal_elt.next pool elt)\n then (* [elt] is the only element in the slot *)\n slots.(slot) <- Internal_elt.null ()\n else (\n if phys_equal elt first then slots.(slot) <- Internal_elt.next pool elt;\n Internal_elt.unlink pool elt)\n ;;\n\n let remove t elt =\n let pool = t.pool in\n let elt = Internal_elt.of_external_exn pool elt in\n internal_remove t elt;\n Internal_elt.free pool elt\n ;;\n\n let fire_past_alarms t ~handle_fired ~key ~now =\n let level = t.levels.(0) in\n if level.length > 0\n then (\n let slot = Level.slot level ~key in\n let slots = level.slots in\n let pool = t.pool in\n let first = ref slots.(slot) in\n if not (Internal_elt.is_null !first)\n then (\n let current = ref !first in\n let continue = ref true in\n while !continue do\n let elt = !current in\n let next = Internal_elt.next pool elt in\n if phys_equal next !first then continue := false else current := next;\n if Time_ns.( <= ) (Internal_elt.at pool elt) now\n then (\n handle_fired (Internal_elt.to_external elt);\n internal_remove t elt;\n Internal_elt.free pool elt;\n (* We recompute [first] because [internal_remove] may have changed it. *)\n first := slots.(slot))\n done))\n ;;\n\n let change t elt ~key ~at =\n ensure_valid_key t ~key;\n let pool = t.pool in\n let elt = Internal_elt.of_external_exn pool elt in\n internal_remove t elt;\n Internal_elt.set_key pool elt key;\n Internal_elt.set_at pool elt at;\n internal_add_elt t elt\n ;;\n\n let clear t =\n if not (is_empty t)\n then (\n t.length <- 0;\n let pool = t.pool in\n let free_elt elt = Internal_elt.free pool elt in\n let levels = t.levels in\n for level_index = 0 to Array.length levels - 1 do\n let level = levels.(level_index) in\n if level.length > 0\n then (\n level.length <- 0;\n let slots = level.slots in\n for slot_index = 0 to Array.length slots - 1 do\n let elt = slots.(slot_index) in\n if not (Internal_elt.is_null elt)\n then (\n Internal_elt.iter pool elt ~f:free_elt;\n slots.(slot_index) <- Internal_elt.null ())\n done)\n done)\n ;;\nend\n\nmodule Internal_elt = Priority_queue.Internal_elt\nmodule Key = Priority_queue.Key\nmodule Interval_num = Key\n\nlet min_interval_num = Interval_num.zero\n\n(* All time from the epoch onwards is broken into half-open intervals of size\n [Config.alarm_precision config]. The intervals are numbered starting at zero, and a\n time's interval number serves as its key in [priority_queue]. *)\ntype 'a t =\n { config : Config.t\n ; start : Time_ns.t\n ; (* [max_interval_num] is the interval number of [max_time]. *)\n max_interval_num : Interval_num.t\n ; mutable now : Time_ns.t\n ; mutable now_interval_num_start : Time_ns.t\n ; mutable max_allowed_alarm_time : Time_ns.t\n ; priority_queue : 'a Priority_queue.t\n }\n[@@deriving fields, sexp_of]\n\ntype 'a timing_wheel = 'a t\ntype 'a t_now = 'a t\n\nlet sexp_of_t_now _ t = [%sexp (t.now : Time_ns.t)]\nlet alarm_precision t = Config.alarm_precision t.config\n\nmodule Alarm = struct\n type 'a t = 'a Priority_queue.Elt.t [@@deriving sexp_of]\n\n let null = Priority_queue.Elt.null\n let at tw t = Priority_queue.Elt.at tw.priority_queue t\n let value tw t = Priority_queue.Elt.value tw.priority_queue t\n let interval_num tw t = Priority_queue.Elt.key tw.priority_queue t\nend\n\nlet sexp_of_t_internal = sexp_of_t\nlet iter t ~f = Priority_queue.iter t.priority_queue ~f\n\nmodule Pretty = struct\n module Alarm = struct\n type 'a t =\n { at : Time_ns.t\n ; value : 'a\n }\n [@@deriving fields, sexp_of]\n\n let create t alarm = { at = Alarm.at t alarm; value = Alarm.value t alarm }\n let compare t1 t2 = Time_ns.compare (at t1) (at t2)\n end\n\n type 'a t =\n { config : Config.t\n ; start : Time_ns.t\n ; max_interval_num : Interval_num.t\n ; now : Time_ns.t\n ; alarms : 'a Alarm.t list\n }\n [@@deriving sexp_of]\nend\n\nlet pretty\n ({ config\n ; start\n ; max_interval_num\n ; now\n ; now_interval_num_start = _\n ; max_allowed_alarm_time = _\n ; priority_queue = _\n } as t)\n =\n let r = ref [] in\n iter t ~f:(fun a -> r := Pretty.Alarm.create t a :: !r);\n let alarms = List.sort !r ~compare:Pretty.Alarm.compare in\n { Pretty.config; start; max_interval_num; now; alarms }\n;;\n\nlet sexp_of_t sexp_of_a t =\n match !sexp_of_t_style with\n | `Internal -> sexp_of_t_internal sexp_of_a t\n | `Pretty -> [%sexp (pretty t : a Pretty.t)]\n;;\n\nlet length t = Priority_queue.length t.priority_queue\nlet is_empty t = length t = 0\n\nlet interval_num_internal ~time ~alarm_precision =\n Interval_num.of_int63 (Alarm_precision.interval_num alarm_precision time)\n;;\n\nlet interval_num_unchecked t time =\n interval_num_internal ~time ~alarm_precision:t.config.alarm_precision\n;;\n\nlet interval_num t time =\n if Time_ns.( < ) time min_time\n then\n raise_s\n [%message\n \"Timing_wheel.interval_num got time too far in the past\" (time : Time_ns.t)];\n interval_num_unchecked t time\n;;\n\nlet interval_num_start_unchecked t interval_num =\n Alarm_precision.interval_num_start\n t.config.alarm_precision\n (interval_num |> Interval_num.to_int63)\n;;\n\nlet[@cold] raise_interval_num_start_got_too_small interval_num =\n raise_s\n [%message\n \"Timing_wheel.interval_num_start got too small interval_num\"\n (interval_num : Interval_num.t)\n (min_interval_num : Interval_num.t)]\n;;\n\nlet[@cold] raise_interval_num_start_got_too_large t interval_num =\n raise_s\n [%message\n \"Timing_wheel.interval_num_start got too large interval_num\"\n (interval_num : Interval_num.t)\n (t.max_interval_num : Interval_num.t)]\n;;\n\nlet interval_num_start t interval_num =\n if Interval_num.( < ) interval_num min_interval_num\n then raise_interval_num_start_got_too_small interval_num;\n if Interval_num.( > ) interval_num t.max_interval_num\n then raise_interval_num_start_got_too_large t interval_num;\n interval_num_start_unchecked t interval_num\n;;\n\nlet compute_max_allowed_alarm_time t =\n let max_allowed_key = Priority_queue.max_allowed_key t.priority_queue in\n if Interval_num.( >= ) max_allowed_key t.max_interval_num\n then max_time\n else\n Time_ns.add\n (interval_num_start_unchecked t max_allowed_key)\n (Time_ns.Span.( - ) (alarm_precision t) Time_ns.Span.nanosecond)\n;;\n\nlet now_interval_num t = Priority_queue.min_allowed_key t.priority_queue\nlet min_allowed_alarm_interval_num = now_interval_num\nlet max_allowed_alarm_interval_num t = interval_num t (max_allowed_alarm_time t)\nlet interval_start t time = interval_num_start_unchecked t (interval_num t time)\n\nlet invariant invariant_a t =\n Invariant.invariant [%here] t [%sexp_of: _ t] (fun () ->\n let check f = Invariant.check_field t f in\n Fields.iter\n ~config:(check Config.invariant)\n ~start:\n (check (fun start ->\n assert (Time_ns.( >= ) start min_time);\n assert (Time_ns.( <= ) start max_time)))\n ~max_interval_num:\n (check (fun max_interval_num ->\n [%test_result: Interval_num.t]\n ~expect:max_interval_num\n (interval_num t max_time);\n [%test_result: Interval_num.t]\n ~expect:max_interval_num\n (interval_num t (interval_num_start t max_interval_num))))\n ~now:\n (check (fun now ->\n assert (Time_ns.( >= ) now t.start);\n assert (Time_ns.( <= ) now max_time);\n assert (\n Interval_num.equal\n (interval_num t t.now)\n (Priority_queue.min_allowed_key t.priority_queue))))\n ~now_interval_num_start:\n (check (fun now_interval_num_start ->\n [%test_result: Time_ns.t]\n now_interval_num_start\n ~expect:(interval_num_start t (now_interval_num t))))\n ~max_allowed_alarm_time:\n (check (fun max_allowed_alarm_time ->\n [%test_result: Time_ns.t]\n max_allowed_alarm_time\n ~expect:(compute_max_allowed_alarm_time t)))\n ~priority_queue:(check (Priority_queue.invariant invariant_a));\n iter t ~f:(fun alarm ->\n assert (\n Interval_num.equal\n (Alarm.interval_num t alarm)\n (interval_num t (Alarm.at t alarm)));\n assert (\n Time_ns.( >= )\n (interval_start t (Alarm.at t alarm))\n (interval_start t (now t)));\n assert (\n Time_ns.( > ) (Alarm.at t alarm) (Time_ns.sub (now t) (alarm_precision t)))))\n;;\n\nlet advance_clock t ~to_ ~handle_fired =\n if Time_ns.( > ) to_ (now t)\n then (\n t.now <- to_;\n let key = interval_num_unchecked t to_ in\n t.now_interval_num_start <- interval_num_start_unchecked t key;\n Priority_queue.increase_min_allowed_key\n t.priority_queue\n ~key\n ~handle_removed:handle_fired;\n t.max_allowed_alarm_time <- compute_max_allowed_alarm_time t)\n;;\n\nlet create ~config ~start =\n if Time_ns.( < ) start Time_ns.epoch\n then\n raise_s\n [%message \"Timing_wheel.create got start before the epoch\" (start : Time_ns.t)];\n let t =\n { config\n ; start\n ; max_interval_num =\n interval_num_internal ~time:max_time ~alarm_precision:config.alarm_precision\n ; now = Time_ns.min_value_for_1us_rounding (* set by [advance_clock] below *)\n ; now_interval_num_start =\n Time_ns.min_value_for_1us_rounding (* set by [advance_clock] below *)\n ; max_allowed_alarm_time = max_time (* set by [advance_clock] below *)\n ; priority_queue =\n Priority_queue.create ?capacity:config.capacity ~level_bits:config.level_bits ()\n }\n in\n advance_clock t ~to_:start ~handle_fired:(fun _ -> assert false);\n t\n;;\n\nlet add_at_interval_num t ~at value =\n Internal_elt.to_external\n (Priority_queue.internal_add\n t.priority_queue\n ~key:at\n ~at:(interval_num_start t at)\n value)\n;;\n\nlet[@cold] raise_that_far_in_the_future t at =\n raise_s\n [%message\n \"Timing_wheel cannot schedule alarm that far in the future\"\n (at : Time_ns.t)\n ~max_allowed_alarm_time:(t.max_allowed_alarm_time : Time_ns.t)]\n;;\n\nlet[@cold] raise_before_start_of_current_interval t at =\n raise_s\n [%message\n \"Timing_wheel cannot schedule alarm before start of current interval\"\n (at : Time_ns.t)\n ~now_interval_num_start:(t.now_interval_num_start : Time_ns.t)]\n;;\n\nlet ensure_can_schedule_alarm t ~at =\n if Time_ns.( > ) at t.max_allowed_alarm_time then raise_that_far_in_the_future t at;\n if Time_ns.( < ) at t.now_interval_num_start\n then raise_before_start_of_current_interval t at\n;;\n\nlet add t ~at value =\n ensure_can_schedule_alarm t ~at;\n Internal_elt.to_external\n (Priority_queue.internal_add\n t.priority_queue\n ~key:(interval_num_unchecked t at)\n ~at\n value)\n;;\n\nlet remove t alarm = Priority_queue.remove t.priority_queue alarm\nlet clear t = Priority_queue.clear t.priority_queue\nlet mem t alarm = Priority_queue.mem t.priority_queue alarm\n\nlet reschedule_gen t alarm ~key ~at =\n if not (mem t alarm)\n then failwith \"Timing_wheel cannot reschedule alarm not in timing wheel\";\n ensure_can_schedule_alarm t ~at;\n Priority_queue.change t.priority_queue alarm ~key ~at\n;;\n\nlet reschedule t alarm ~at =\n reschedule_gen t alarm ~key:(interval_num_unchecked t at) ~at\n;;\n\nlet reschedule_at_interval_num t alarm ~at =\n reschedule_gen t alarm ~key:at ~at:(interval_num_start t at)\n;;\n\nlet pool t = Priority_queue.pool t.priority_queue\n\nlet min_alarm_interval_num t =\n let elt = Priority_queue.min_elt_ t.priority_queue in\n if Internal_elt.is_null elt then None else Some (Internal_elt.key (pool t) elt)\n;;\n\nlet min_alarm_interval_num_exn t =\n let elt = Priority_queue.min_elt_ t.priority_queue in\n if Internal_elt.is_null elt\n then\n raise_s\n [%message\n \"Timing_wheel.min_alarm_interval_num_exn of empty timing_wheel\"\n ~timing_wheel:(t : _ t)]\n else Internal_elt.key (pool t) elt\n;;\n\nlet max_alarm_time_in_list t elt =\n let pool = pool t in\n Internal_elt.max_alarm_time pool elt ~with_key:(Internal_elt.key pool elt)\n;;\n\nlet max_alarm_time_in_min_interval t =\n let elt = Priority_queue.min_elt_ t.priority_queue in\n if Internal_elt.is_null elt then None else Some (max_alarm_time_in_list t elt)\n;;\n\nlet max_alarm_time_in_min_interval_exn t =\n let elt = Priority_queue.min_elt_ t.priority_queue in\n if Internal_elt.is_null elt\n then\n raise_s\n [%message\n \"Timing_wheel.max_alarm_time_in_min_interval_exn of empty timing wheel\"\n ~timing_wheel:(t : _ t)];\n max_alarm_time_in_list t elt\n;;\n\nlet next_alarm_fires_at_internal t key =\n (* [interval_num_start t key] is the key corresponding to the start of the time interval\n holding the first alarm in [t]. Advancing to that would not be enough, since the\n alarms in that interval don't fire until the clock is advanced to the start of the\n next interval. So, we use [succ key] to advance to the start of the next\n interval. *)\n interval_num_start t (Key.succ key)\n;;\n\nlet next_alarm_fires_at t =\n let elt = Priority_queue.min_elt_ t.priority_queue in\n if Internal_elt.is_null elt\n then None\n else (\n let key = Internal_elt.key (pool t) elt in\n if Interval_num.equal key t.max_interval_num\n then None\n else Some (next_alarm_fires_at_internal t key))\n;;\n\nlet[@cold] raise_next_alarm_fires_at_exn_of_empty_timing_wheel t =\n raise_s\n [%message\n \"Timing_wheel.next_alarm_fires_at_exn of empty timing wheel\"\n ~timing_wheel:(t : _ t)]\n;;\n\nlet[@cold] raise_next_alarm_fires_at_with_all_alarms_in_max_interval t =\n raise_s\n [%message\n \"Timing_wheel.next_alarm_fires_at_exn with all alarms in max interval\"\n ~timing_wheel:(t : _ t)]\n;;\n\nlet next_alarm_fires_at_exn t =\n let elt = Priority_queue.min_elt_ t.priority_queue in\n if Internal_elt.is_null elt then raise_next_alarm_fires_at_exn_of_empty_timing_wheel t;\n let key = Internal_elt.key (pool t) elt in\n if Interval_num.equal key t.max_interval_num\n then raise_next_alarm_fires_at_with_all_alarms_in_max_interval t;\n next_alarm_fires_at_internal t key\n;;\n\nlet fire_past_alarms t ~handle_fired =\n Priority_queue.fire_past_alarms\n t.priority_queue\n ~handle_fired\n ~key:(now_interval_num t)\n ~now:t.now\n;;\n\nmodule Private = struct\n module Num_key_bits = Num_key_bits\n\n let interval_num_internal = interval_num_internal\n let max_time = max_time\nend\n","module Inria_sys = Sys\nmodule Time_ns_in_this_directory = Time_ns\nopen Core_kernel\nopen Poly\nmodule Time_ns = Time_ns_in_this_directory\n\nlet sec = Time_ns.Span.of_sec\nlet concat = String.concat\n\nmodule Epoll_max_ready_events = Validated.Make (struct\n include Int\n\n let here = [%here]\n let validate = Int.validate_positive\n end)\n\nmodule Max_inter_cycle_timeout = Validated.Make (struct\n include Time_ns.Span\n\n let here = [%here]\n let validate = Time_ns.Span.validate_non_negative\n end)\n\nmodule Min_inter_cycle_timeout = Validated.Make (struct\n include Time_ns.Span\n\n let here = [%here]\n let validate = Time_ns.Span.validate_non_negative\n end)\n\nmodule Max_num_open_file_descrs = struct\n include Validated.Make (struct\n include Int\n\n let here = [%here]\n let validate = Int.validate_positive\n end)\n\n let default = create_exn (1 lsl 16)\n let equal (t1 : t) t2 = t1 = t2\nend\n\nmodule Max_num_threads = Validated.Make (struct\n include Int\n\n let here = [%here]\n let validate = Int.validate_positive\n end)\n\nmodule Max_num_jobs_per_priority_per_cycle = Validated.Make (struct\n include Int\n\n let here = [%here]\n let validate = Int.validate_positive\n end)\n\nmodule Dump_core_on_job_delay = struct\n module How_to_dump = struct\n type t =\n | Default\n | Call_abort\n | Call_gcore\n [@@deriving sexp]\n end\n\n type watch =\n { dump_if_delayed_by : Time_ns.Span.t\n ; how_to_dump : How_to_dump.t\n }\n [@@deriving sexp]\n\n type t =\n | Watch of watch\n | Do_not_watch\n [@@deriving sexp]\nend\n\nmodule Debug_tag = struct\n module T = struct\n type t =\n | All\n | Clock\n | Fd\n | File_descr_watcher\n | Finalizers\n | Interruptor\n | Monitor\n | Monitor_send_exn\n | Parallel\n | Reader\n | Scheduler\n | Shutdown\n | Thread_pool\n | Thread_safe\n | Writer\n [@@deriving compare, sexp]\n\n let equal = [%compare.equal: t]\n end\n\n include T\n include Sexpable.To_stringable (T)\n\n let list =\n [ All\n ; Clock\n ; Fd\n ; File_descr_watcher\n ; Finalizers\n ; Interruptor\n ; Monitor\n ; Monitor_send_exn\n ; Parallel\n ; Reader\n ; Scheduler\n ; Shutdown\n ; Thread_pool\n ; Thread_safe\n ; Writer\n ]\n ;;\nend\n\nmodule File_descr_watcher = struct\n module T = struct\n type t =\n | Epoll_if_timerfd\n | Epoll\n | Select\n [@@deriving sexp]\n end\n\n include T\n include Sexpable.To_stringable (T)\n\n let list = [ Epoll_if_timerfd; Epoll; Select ]\nend\n\ntype t =\n { abort_after_thread_pool_stuck_for : Time_ns.Span.t option [@sexp.option]\n ; check_invariants : bool option [@sexp.option]\n ; detect_invalid_access_from_thread : bool option [@sexp.option]\n ; dump_core_on_job_delay : Dump_core_on_job_delay.t option [@sexp.option]\n ; epoll_max_ready_events : Epoll_max_ready_events.t option [@sexp.option]\n ; file_descr_watcher : File_descr_watcher.t option [@sexp.option]\n ; max_inter_cycle_timeout : Max_inter_cycle_timeout.t option [@sexp.option]\n ; max_num_open_file_descrs : Max_num_open_file_descrs.t option [@sexp.option]\n ; max_num_threads : Max_num_threads.t option [@sexp.option]\n ; max_num_jobs_per_priority_per_cycle : Max_num_jobs_per_priority_per_cycle.t option\n [@sexp.option]\n ; min_inter_cycle_timeout : Min_inter_cycle_timeout.t option [@sexp.option]\n ; print_debug_messages_for : Debug_tag.t list option [@sexp.option]\n ; record_backtraces : bool option [@sexp.option]\n ; report_thread_pool_stuck_for : Time_ns.Span.t option [@sexp.option]\n ; thread_pool_cpu_affinity : Thread_pool_cpu_affinity.t option [@sexp.option]\n ; timing_wheel_config : Timing_wheel.Config.t option [@sexp.option]\n }\n[@@deriving fields, sexp]\n\nlet empty =\n { abort_after_thread_pool_stuck_for = None\n ; check_invariants = None\n ; detect_invalid_access_from_thread = None\n ; dump_core_on_job_delay = None\n ; epoll_max_ready_events = None\n ; file_descr_watcher = None\n ; max_inter_cycle_timeout = None\n ; max_num_open_file_descrs = None\n ; max_num_threads = None\n ; max_num_jobs_per_priority_per_cycle = None\n ; min_inter_cycle_timeout = None\n ; print_debug_messages_for = None\n ; record_backtraces = None\n ; report_thread_pool_stuck_for = None\n ; thread_pool_cpu_affinity = None\n ; timing_wheel_config = None\n }\n;;\n\nlet default_timing_wheel_config_for_word_size (word_size : Word_size.t) =\n let module Alarm_precision = Timing_wheel.Alarm_precision in\n let alarm_precision, level_bits =\n match word_size with\n | W32 -> Alarm_precision.about_one_millisecond, [ 10; 10; 9 ]\n | W64 -> Alarm_precision.(div about_one_millisecond ~pow2:3), [ 14; 15; 9; 6 ]\n in\n Timing_wheel.Config.create\n ~alarm_precision\n ~level_bits:(Timing_wheel.Level_bits.create_exn level_bits)\n ()\n;;\n\nlet default_timing_wheel_config =\n default_timing_wheel_config_for_word_size Word_size.word_size\n;;\n\nlet default =\n (* For [file_descr_watcher] and [max_num_open_file_descrs] we choose the default for the\n common case that [epoll] is available. There is some additional code in\n [Async_unix.Config] that checks whether [epoll] is actually available, and if not,\n uses [select] and a smaller number of file descriptors. *)\n { abort_after_thread_pool_stuck_for = Some (sec 60.)\n ; check_invariants = Some false\n ; detect_invalid_access_from_thread = Some false\n ; dump_core_on_job_delay = Some Do_not_watch\n ; epoll_max_ready_events = Some (Epoll_max_ready_events.create_exn 256)\n ; file_descr_watcher = Some Epoll_if_timerfd\n ; max_inter_cycle_timeout = Some (Max_inter_cycle_timeout.create_exn (sec 0.05))\n ; max_num_open_file_descrs = Some Max_num_open_file_descrs.default\n ; max_num_threads = Some (Max_num_threads.create_exn 50)\n ; max_num_jobs_per_priority_per_cycle =\n Some (Max_num_jobs_per_priority_per_cycle.create_exn 500)\n ; min_inter_cycle_timeout = Some (Min_inter_cycle_timeout.create_exn (sec 0.))\n ; print_debug_messages_for = Some []\n ; record_backtraces = Some false\n ; report_thread_pool_stuck_for = Some (sec 1.)\n ; thread_pool_cpu_affinity = Some Inherit\n ; timing_wheel_config = Some default_timing_wheel_config\n }\n;;\n\nlet example =\n { default with\n print_debug_messages_for = Some Debug_tag.[ Fd; Scheduler ]\n ; thread_pool_cpu_affinity =\n Some\n (Cpuset\n ([ 0; 1; 2 ] |> Int.Set.of_list |> Thread_pool_cpu_affinity.Cpuset.create_exn))\n }\n;;\n\nlet environment_variable = \"ASYNC_CONFIG\"\n\nlet field_descriptions () : string =\n let field to_sexp description ac field =\n (Field.name field, to_sexp (Option.value_exn (Field.get field default)), description)\n :: ac\n in\n let fields =\n Fields.fold\n ~init:[]\n ~abort_after_thread_pool_stuck_for:\n (field\n [%sexp_of: Time_ns.Span.t]\n [ {|\n By default, Async will send an exception to the toplevel monitor\n if it detects that the thread pool is stuck for longer than this.\n|}\n ])\n ~check_invariants:\n (field\n [%sexp_of: bool]\n [ {|\n If true, causes Async to regularly check invariants of its internal\n data structures. This can substantially slow down your program.\n|}\n ])\n ~detect_invalid_access_from_thread:\n (field\n [%sexp_of: bool]\n [ {|\n If true, causes Async routines to check if they are being accessed\n from some thread other than the thread currently holding the Async\n lock, which is not allowed and can lead to very confusing behavior.\n|}\n ])\n ~dump_core_on_job_delay:\n (field\n [%sexp_of: Dump_core_on_job_delay.t]\n [ {|\n Can be set to [Do_not_watch] or:\n\n (Watch ((dump_if_delayed_by SPAN) (how_to_dump HOW)))\n\n If set to [Watch], then on program start this will start a regular\n Async job that increments a counter, and a C thread that will\n detect if that job is delayed by [dump_if_delayed_by], and if so,\n will core dump the program. If available, [/usr/bin/gcore] is\n used by default to dump the core, which should allow the program\n to continue running. Otherwise, [abort] will be called from C,\n which will kill the program while causing a core dump. One can\n force [abort] or [gcore] via [how_to_dump], which should be one of:\n [Call_abort], [Call_gcore], or [Default].\n|}\n ])\n ~epoll_max_ready_events:\n (field\n [%sexp_of: Epoll_max_ready_events.t]\n [ {|\n The maximum number of ready events that Async's call to [Epoll.wait]\n will handle.\n|}\n ])\n ~file_descr_watcher:\n (field\n [%sexp_of: File_descr_watcher.t]\n [ {|\n This determines what OS subsystem Async uses to watch file descriptors for being ready.\n The default is to use [epoll] if timerfd's are supported and if not, use [select].\n\n Allowed values are:|}\n ; concat\n ~sep:\", \"\n (List.map File_descr_watcher.list ~f:File_descr_watcher.to_string)\n ; {|.\n|}\n ])\n ~max_num_open_file_descrs:\n (field\n (fun default ->\n [%message\n \"\"\n ~_:\n (concat\n [ \"min \"\n ; default |> Max_num_open_file_descrs.raw |> Int.to_string_hum\n ; \" [ulimit -n -H]\"\n ]\n : string)])\n [ {|\n The maximum number of open file descriptors allowed at any one time.|} ])\n ~max_num_threads:\n (field\n [%sexp_of: Max_num_threads.t]\n [ {|\n The maximum number of threads that Async will create to do blocking\n system calls and handle calls to [In_thread.run].\n|}\n ])\n ~max_inter_cycle_timeout:\n (field\n [%sexp_of: Max_inter_cycle_timeout.t]\n [ {|\n The maximum amount of time the scheduler will pause between cycles\n when it has no jobs and is going to wait for I/O. In principle one\n doesn't need this, and we could use an infinite timeout. We instead\n use a small timeout (by default), to be more robust to bugs that\n could prevent Async from waking up and servicing events. For\n example, as of 2013-01, the OCaml runtime has a bug that causes it\n to not necessarily run an OCaml signal handler in a timely manner.\n This in turn can cause a simple Async program that is waiting on a\n signal to hang, when in fact it should handle the signal.\n\n We use 50ms as the default timeout, because it is infrequent enough\n to have a negligible performance impact, and frequent enough that\n the latency would typically be not noticeable. Also, 50ms is what\n the OCaml ticker thread uses.\n|}\n ])\n ~max_num_jobs_per_priority_per_cycle:\n (field\n [%sexp_of: Max_num_jobs_per_priority_per_cycle.t]\n [ {|\n The maximum number of jobs that will be done at each priority within\n each Async cycle. This limits how many jobs the scheduler will run\n before pausing to check for I/O.\n|}\n ])\n ~min_inter_cycle_timeout:\n (field\n [%sexp_of: Min_inter_cycle_timeout.t]\n [ {|\n The minimum timeout the scheduler will pass to the OS when it checks\n for I/O between cycles. This is zero by default. Setting it to a\n nonzero value is used to increase thread fairness between the scheduler\n and other threads. A plausible setting is 1us. This is also\n configurable in OCaml via [Scheduler.set_min_inter_cycle_timeout].\n|}\n ])\n ~print_debug_messages_for:\n (field\n [%sexp_of: Debug_tag.t list]\n [ {|\n A list of tags specifying which Async functions should print debug\n messages to stderr. Each tag identifies a group of related Async\n functions. The tag [all] means to print debug messages for all\n functions. Allowed values are:\n\n|}\n ; concat\n (List.map Debug_tag.list ~f:(fun d ->\n concat [ \" \"; Debug_tag.to_string d; \"\\n\" ]))\n ; {|\n Turning on debug messages will substantially slow down most programs.\n|}\n ])\n ~record_backtraces:\n (field\n [%sexp_of: bool]\n [ {|\n If true, this will cause Async to keep in the execution context the\n history of stack backtraces (obtained via [Backtrace.get]) that led\n to the current job. If an Async job has an unhandled exception,\n this backtrace history will be recorded in the exception. In\n particular the history will appear in an unhandled exception that\n reaches the main monitor. This can have a substantial performance\n impact, both in running time and space usage.\n|}\n ])\n ~report_thread_pool_stuck_for:\n (field\n [%sexp_of: Time_ns.Span.t]\n [ {|\n By default, Async will print a message to stderr every second if\n the thread pool is stuck for longer than this.\n|}\n ])\n ~thread_pool_cpu_affinity:\n (field\n [%sexp_of: Thread_pool_cpu_affinity.t]\n [ {|\n Whether and how threads in the thread pool should be affinitized to CPUs.\n|}\n ])\n ~timing_wheel_config:\n (field\n [%sexp_of: Timing_wheel.Config.t]\n [ {|\n This is used to adjust the time/space tradeoff in the timing wheel\n used to implement Async's clock. Time is split into intervals of\n size [alarm_precision], and alarms with times in the same interval\n fire in the same cycle. Level [i] in the timing wheel has an\n array of size [2^b], where [b] is the [i]'th entry in [level_bits].\n|}\n ])\n in\n concat\n (List.map\n (List.sort fields ~compare:(fun (name1, _, _) (name2, _, _) ->\n String.compare name1 name2))\n ~f:(fun (name, default, description) ->\n concat\n (\"\\n\" :: name :: \" (default \" :: Sexp.to_string default :: \")\" :: description)))\n;;\n\nlet help_message () =\n concat\n [ \"The \"\n ; environment_variable\n ; {| environment variable affects Async\nin various ways. Its value should be a sexp of the following form,\nwhere all fields are optional:\n\n|}\n ; Sexp.to_string_hum (sexp_of_t example)\n ; {|\n\nHere is an explanation of each field.\n|}\n ; field_descriptions ()\n ]\n;;\n\nlet usage () =\n eprintf \"%s%!\" (help_message ());\n exit 1\n;;\n\nlet t =\n match Option.try_with (fun () -> Inria_sys.getenv environment_variable) with\n | None -> empty\n | Some \"\" -> usage ()\n | Some string ->\n (match Result.try_with (fun () -> t_of_sexp (Sexp.of_string string)) with\n | Ok t -> t\n | Error exn ->\n eprintf\n \"%s\\n\\n\"\n (Sexp.to_string_hum\n (Error.sexp_of_t\n (Error.create\n (sprintf\n \"invalid value for %s environment variable\"\n environment_variable)\n exn\n [%sexp_of: exn])));\n usage ())\n;;\n\nmodule Print_debug_messages_for = struct\n let print_debug_messages_for tag =\n match t.print_debug_messages_for with\n | None -> false\n | Some l -> List.mem l tag ~equal:Debug_tag.equal\n ;;\n\n let all = print_debug_messages_for All\n let debug tag = all || print_debug_messages_for tag\n let clock = debug Clock\n let fd = debug Fd\n let file_descr_watcher = debug File_descr_watcher\n let finalizers = debug Finalizers\n let interruptor = debug Interruptor\n let monitor = debug Monitor\n let monitor_send_exn = debug Monitor_send_exn\n let parallel = debug Parallel\n let reader = debug Reader\n let scheduler = debug Scheduler\n let shutdown = debug Shutdown\n let thread_pool = debug Thread_pool\n let thread_safe = debug Thread_safe\n let writer = debug Writer\nend\n\nlet ( !! ) field =\n Option.value (Field.get field t) ~default:(Option.value_exn (Field.get field default))\n;;\n\nlet abort_after_thread_pool_stuck_for = !!Fields.abort_after_thread_pool_stuck_for\nlet check_invariants = !!Fields.check_invariants\nlet detect_invalid_access_from_thread = !!Fields.detect_invalid_access_from_thread\nlet epoll_max_ready_events = !!Fields.epoll_max_ready_events\nlet thread_pool_cpu_affinity = !!Fields.thread_pool_cpu_affinity\nlet file_descr_watcher = !!Fields.file_descr_watcher\nlet max_inter_cycle_timeout = !!Fields.max_inter_cycle_timeout\nlet max_num_open_file_descrs = !!Fields.max_num_open_file_descrs\nlet max_num_threads = !!Fields.max_num_threads\nlet max_num_jobs_per_priority_per_cycle = !!Fields.max_num_jobs_per_priority_per_cycle\nlet min_inter_cycle_timeout = !!Fields.min_inter_cycle_timeout\nlet record_backtraces = !!Fields.record_backtraces\nlet report_thread_pool_stuck_for = !!Fields.report_thread_pool_stuck_for\nlet timing_wheel_config = !!Fields.timing_wheel_config\nlet dump_core_on_job_delay = !!Fields.dump_core_on_job_delay\n\nlet t =\n { abort_after_thread_pool_stuck_for = Some abort_after_thread_pool_stuck_for\n ; check_invariants = Some check_invariants\n ; detect_invalid_access_from_thread = Some detect_invalid_access_from_thread\n ; dump_core_on_job_delay = Some dump_core_on_job_delay\n ; thread_pool_cpu_affinity = Some thread_pool_cpu_affinity\n ; epoll_max_ready_events = Some epoll_max_ready_events\n ; file_descr_watcher = Some file_descr_watcher\n ; max_inter_cycle_timeout = Some max_inter_cycle_timeout\n ; max_num_open_file_descrs = Some max_num_open_file_descrs\n ; max_num_threads = Some max_num_threads\n ; max_num_jobs_per_priority_per_cycle = Some max_num_jobs_per_priority_per_cycle\n ; min_inter_cycle_timeout = Some min_inter_cycle_timeout\n ; print_debug_messages_for = t.print_debug_messages_for\n ; record_backtraces = Some record_backtraces\n ; report_thread_pool_stuck_for = Some report_thread_pool_stuck_for\n ; timing_wheel_config = Some timing_wheel_config\n }\n;;\n\nlet task_id = ref (fun () -> Sexp.Atom \"\")\n","open Core_kernel\nopen Import\nopen Deferred_std\nmodule Deferred = Deferred1\nmodule Scheduler = Scheduler1\nmodule Stream = Tail.Stream\nmodule Monitor = Monitor0\ninclude Monitor\n\ntype monitor = t [@@deriving sexp_of]\n\nlet invariant t =\n Invariant.invariant [%here] t [%sexp_of: t] (fun () ->\n let check f = Invariant.check_field t f in\n Fields.iter\n ~name:ignore\n ~here:ignore\n ~id:ignore\n ~parent:ignore\n ~next_error:(check (fun next_error -> assert (Ivar.is_empty next_error)))\n ~handlers_for_all_errors:ignore\n ~tails_for_all_errors:ignore\n ~has_seen_error:ignore\n ~is_detached:ignore)\n;;\n\nlet current_execution_context () = Scheduler.(current_execution_context (t ()))\nlet current () = Execution_context.monitor (current_execution_context ())\n\nlet depth t =\n let rec loop t n =\n match t.parent with\n | None -> n\n | Some t -> loop t (n + 1)\n in\n loop t 0\n;;\n\ntype 'a with_optional_monitor_name =\n ?here:Source_code_position.t -> ?info:Info.t -> ?name:string -> 'a\n\nlet detach t = t.is_detached <- true\n\ntype handler_state =\n | Uninitialized\n | Running of (Execution_context.t * (exn -> unit)) Bag.Elt.t\n | Terminated\n\nlet detach_and_iter_errors t ~f =\n detach t;\n let scheduler = Scheduler.t () in\n let execution_context = Scheduler.current_execution_context scheduler in\n let handler_state_ref = ref Uninitialized in\n let run_f exn =\n match !handler_state_ref with\n | Uninitialized -> assert false\n | Terminated -> ()\n | Running bag_elt ->\n (try f exn with\n | inner_exn ->\n handler_state_ref := Terminated;\n Bag.remove t.handlers_for_all_errors bag_elt;\n (* [run_f] always runs in [execution_context]. Hence, [raise inner_exn] sends\n [inner_exn] to [execution_context]'s monitor, i.e. the monitor in effect when\n [detach_and_iter_errors] was called. *)\n raise inner_exn)\n in\n handler_state_ref\n := Running (Bag.add t.handlers_for_all_errors (execution_context, run_f))\n;;\n\nlet detach_and_get_error_stream t =\n detach t;\n let tail = Tail.create () in\n t.tails_for_all_errors <- tail :: t.tails_for_all_errors;\n Tail.collect tail\n;;\n\nlet get_next_error t = Ivar.read t.next_error\n\nlet detach_and_get_next_error t =\n detach t;\n get_next_error t\n;;\n\nlet create ?here ?info ?name () =\n let parent = current () in\n create_with_parent ?here ?info ?name (Some parent)\n;;\n\nmodule Exn_for_monitor = struct\n type t =\n { exn : exn\n ; backtrace : Backtrace.t option\n ; backtrace_history : Backtrace.t list\n ; monitor : Monitor.t\n }\n\n let backtrace_truncation_heuristics =\n let job_queue = \"Called from file \\\"job_queue.ml\\\"\" in\n let deferred0 = \"Called from file \\\"deferred0.ml\\\"\" in\n let deferred1 = \"Called from file \\\"deferred1.ml\\\"\" in\n let monitor = \"Called from file \\\"monitor.ml\\\"\" in\n let import0 = \"Raised at file \\\"import0.ml\\\"\" in\n let error = \"Called from file \\\"error.ml\\\"\" in\n fun traces ->\n (* ../test/test_try_with_error_display.ml makes sure this stays up-to-date. *)\n let traces =\n match traces with\n | t1 :: rest when String.is_prefix t1 ~prefix:import0 ->\n (match rest with\n | t2 :: rest when String.is_prefix t2 ~prefix:error ->\n (match rest with\n | t3 :: rest when String.is_prefix t3 ~prefix:error -> rest\n | _ -> rest)\n | _ -> rest)\n | _ -> traces\n in\n match List.rev traces with\n | t1 :: rest when String.is_prefix t1 ~prefix:job_queue ->\n (match rest with\n | t2 :: rest when String.is_prefix t2 ~prefix:job_queue ->\n (match rest with\n | t2 :: rest\n when String.is_prefix t2 ~prefix:deferred0\n (* bind *)\n || String.is_prefix t2 ~prefix:deferred1\n (* map *)\n || String.is_prefix t2 ~prefix:monitor\n (* try_with *) -> List.rev rest\n | _ -> List.rev rest)\n | _ -> List.rev rest)\n | _ -> traces\n ;;\n\n let sexp_of_t { exn; backtrace; backtrace_history; monitor } =\n let monitor =\n let name =\n match Info.to_string_hum monitor.name with\n | \"\" -> None\n | s -> Some s\n in\n let pos =\n match monitor.here with\n | None -> None\n | Some here ->\n (* We display the full filename, whereas backtraces only have basenames, but\n perhaps that's what should change. *)\n let column = here.pos_cnum - here.pos_bol in\n Some\n (sprintf\n \"file %S, line %d, characters %d-%d\"\n here.pos_fname\n here.pos_lnum\n column\n column)\n in\n match pos, name with\n | None, None -> []\n | Some pos, None -> [ sprintf \"Caught by monitor at %s\" pos ]\n | None, Some name -> [ sprintf \"Caught by monitor %s\" name ]\n | Some pos, Some name -> [ sprintf \"Caught by monitor %s at %s\" name pos ]\n in\n let backtrace =\n let backtrace =\n match backtrace with\n | None -> []\n | Some backtrace -> Backtrace.to_string_list backtrace\n in\n backtrace_truncation_heuristics backtrace @ monitor\n in\n let list_if_not_empty = function\n | [] -> None\n | _ :: _ as l -> Some l\n in\n [%sexp\n (exn : exn)\n , (list_if_not_empty backtrace : (string list option[@sexp.option]))\n , `backtrace_history\n (list_if_not_empty backtrace_history : (Backtrace.t list option[@sexp.option]))]\n ;;\nend\n\nexception Error_ of Exn_for_monitor.t\n\nlet () =\n Sexplib.Conv.Exn_converter.add [%extension_constructor Error_] (function\n | Error_ t -> [%sexp \"monitor.ml.Error\" :: (t : Exn_for_monitor.t)]\n | _ ->\n (* Reaching this branch indicates a bug in sexplib. *)\n assert false)\n;;\n\nlet extract_exn exn =\n match exn with\n | Error_ error -> error.exn\n | exn -> exn\n;;\n\nlet send_exn t ?backtrace exn =\n let exn =\n match exn with\n | Error_ _ -> exn\n | _ ->\n let backtrace =\n match backtrace with\n | None -> None\n | Some `Get -> Some (Backtrace.Exn.most_recent ())\n | Some (`This b) -> Some b\n in\n let backtrace_history = (current_execution_context ()).backtrace_history in\n Error_ { Exn_for_monitor.exn; backtrace; backtrace_history; monitor = t }\n in\n if Debug.monitor_send_exn\n then Debug.log \"Monitor.send_exn\" (t, exn) [%sexp_of: t * exn];\n t.has_seen_error <- true;\n let scheduler = Scheduler.t () in\n let rec loop t =\n Ivar.fill t.next_error exn;\n t.next_error <- Ivar.create ();\n if t.is_detached\n then (\n if Debug.monitor_send_exn\n then\n Debug.log \"Monitor.send_exn found listening monitor\" (t, exn) [%sexp_of: t * exn];\n Bag.iter t.handlers_for_all_errors ~f:(fun (execution_context, f) ->\n Scheduler.enqueue scheduler execution_context f exn);\n List.iter t.tails_for_all_errors ~f:(fun tail -> Tail.extend tail exn))\n else (\n match t.parent with\n | Some t' -> loop t'\n | None ->\n (* Do not change this branch to print the exception or to exit. Having the\n scheduler raise an uncaught exception is the necessary behavior for programs\n that call [Scheduler.go] and want to handle it. *)\n Scheduler.(got_uncaught_exn (t ())) exn (!Async_kernel_config.task_id ()))\n in\n loop t\n;;\n\nmodule Exported_for_scheduler = struct\n let within_context context f =\n Scheduler.(with_execution_context (t ())) context ~f:(fun () ->\n match Result.try_with f with\n | Ok x -> Ok x\n | Error exn ->\n send_exn (Execution_context.monitor context) exn ~backtrace:`Get;\n Error ())\n ;;\n\n type 'a with_options = ?monitor:t -> ?priority:Priority.t -> 'a\n\n let within_gen ?monitor ?priority f =\n let tmp_context =\n Execution_context.create_like (current_execution_context ()) ?monitor ?priority\n in\n within_context tmp_context f\n ;;\n\n let within' ?monitor ?priority f =\n match within_gen ?monitor ?priority f with\n | Error () -> Deferred.never ()\n | Ok d -> d\n ;;\n\n let within_v ?monitor ?priority f =\n match within_gen ?monitor ?priority f with\n | Error () -> None\n | Ok x -> Some x\n ;;\n\n let within ?monitor ?priority f =\n match within_gen ?monitor ?priority f with\n | Error () -> ()\n | Ok () -> ()\n ;;\n\n let schedule_with_data ?monitor ?priority work x =\n let scheduler = Scheduler.t () in\n Scheduler.enqueue\n scheduler\n (Execution_context.create_like\n (Scheduler.current_execution_context scheduler)\n ?monitor\n ?priority)\n work\n x\n ;;\n\n let schedule ?monitor ?priority work = schedule_with_data ?monitor ?priority work ()\n\n let schedule' =\n (* For performance, we use [schedule_with_data] with a closed function, and inline\n [Deferred.create]. *)\n let upon_work_fill_i (work, i) = upon (work ()) (fun a -> Ivar.fill i a) in\n fun ?monitor ?priority work ->\n let i = Ivar.create () in\n schedule_with_data ?monitor ?priority upon_work_fill_i (work, i);\n Ivar.read i\n ;;\n\n let preserve_execution_context f =\n let scheduler = Scheduler.t () in\n let execution_context = Scheduler.current_execution_context scheduler in\n stage (fun a -> Scheduler.enqueue scheduler execution_context f a)\n ;;\n\n let preserve_execution_context' f =\n let scheduler = Scheduler.t () in\n let execution_context = Scheduler.current_execution_context scheduler in\n let call_and_fill (f, a, i) = upon (f a) (fun r -> Ivar.fill i r) in\n stage (fun a ->\n Deferred.create (fun i ->\n Scheduler.enqueue scheduler execution_context call_and_fill (f, a, i)))\n ;;\nend\n\nopen Exported_for_scheduler\n\nlet stream_iter stream ~f =\n let rec loop stream =\n Stream.next stream\n >>> function\n | Nil -> ()\n | Cons (v, stream) ->\n loop stream;\n f v\n in\n loop stream\n;;\n\n(* An ['a Ok_and_exns.t] represents the output of a computation running in a detached\n monitor. *)\nmodule Ok_and_exns = struct\n type 'a t =\n { ok : 'a Deferred.t\n ; exns : exn Stream.t\n }\n [@@deriving fields, sexp_of]\n\n let create ?here ?info ?name ~run f =\n (* We call [create_with_parent None] because [monitor] does not need a parent. It\n does not because we call [detach_and_get_error_stream monitor] and deal with the\n errors explicitly, thus [send_exn] would never propagate an exn past [monitor]. *)\n let monitor = create_with_parent ?here ?info ?name None in\n let exns = detach_and_get_error_stream monitor in\n let ok =\n match run with\n | `Now -> within' ~monitor f\n | `Schedule -> schedule' ~monitor f\n in\n { ok; exns }\n ;;\nend\n\nlet fill_result_and_handle_background_errors\n result_filler\n result\n exns\n handle_exns_after_result\n =\n if Ivar_filler.is_empty result_filler\n then (\n Ivar_filler.fill result_filler result;\n handle_exns_after_result exns)\n;;\n\nmodule Expert = struct\n let try_with_log_exn : (exn -> unit) ref =\n ref (fun exn ->\n raise_s\n [%message \"failed to set [Monitor.Expert.try_with_log_exn]\" (exn : Exn.t)])\n ;;\nend\n\nlet make_handle_exn rest =\n match rest with\n | `Log ->\n (* We are careful to not close over current context, which is not needed. *)\n !Expert.try_with_log_exn\n | `Raise ->\n let parent = current () in\n fun exn -> send_exn parent exn ?backtrace:None\n | `Call f ->\n let parent = current () in\n fun exn -> within ~monitor:parent (fun () -> f exn)\n;;\n\nlet try_with\n ?here\n ?info\n ?(name = \"\")\n ?extract_exn:(do_extract_exn = false)\n ?(run = `Schedule)\n ?(rest = `Log)\n f\n =\n let { Ok_and_exns.ok; exns } = Ok_and_exns.create ?here ?info ~name ~run f in\n let handle_exn = make_handle_exn rest in\n let handle_exns_after_result exns = stream_iter exns ~f:handle_exn in\n (* We run [within' ~monitor:main] to avoid holding on to references to the evaluation\n context in which [try_with] was called. This avoids a space leak when a chain of\n [try_with]'s are run each nested within the previous one. Without the [within'], the\n error handling for the innermost [try_with] would keep alive the entire chain. *)\n within' ~monitor:main (fun () ->\n if Deferred.is_determined ok\n then (\n handle_exns_after_result exns;\n return (Ok (Deferred.value_exn ok)))\n else (\n let result_filler, result = Ivar_filler.create () in\n upon ok (fun res ->\n fill_result_and_handle_background_errors\n result_filler\n (Ok res)\n exns\n handle_exns_after_result);\n upon (Stream.next exns) (function\n | Nil -> assert false\n | Cons (exn, exns) ->\n let exn = if do_extract_exn then extract_exn exn else exn in\n fill_result_and_handle_background_errors\n result_filler\n (Error exn)\n exns\n handle_exns_after_result);\n result))\n;;\n\nlet try_with_or_error ?here ?info ?(name = \"try_with_or_error\") ?extract_exn f =\n try_with f ?here ?info ~name ?extract_exn ~run:`Now ~rest:`Log\n >>| Or_error.of_exn_result\n;;\n\nlet try_with_join_or_error ?here ?info ?(name = \"try_with_join_or_error\") ?extract_exn f =\n try_with_or_error f ?here ?info ~name ?extract_exn >>| Or_error.join\n;;\n\nlet protect ?here ?info ?(name = \"Monitor.protect\") ?extract_exn ?run f ~finally =\n let%bind r = try_with ?extract_exn ?here ?info ?run ~name f in\n let%map fr = try_with ~extract_exn:false ?here ?info ~name:\"finally\" finally in\n match r, fr with\n | Error exn, Error finally_exn ->\n raise_s [%message \"Async finally\" (exn : exn) (finally_exn : exn)]\n | Error e, Ok () | Ok _, Error e -> raise e\n | Ok r, Ok () -> r\n;;\n\nlet handle_errors ?here ?info ?name f handler =\n let { Ok_and_exns.ok; exns } = Ok_and_exns.create ?here ?info ?name ~run:`Now f in\n stream_iter exns ~f:handler;\n ok\n;;\n\nlet catch_stream ?here ?info ?name f =\n let { Ok_and_exns.exns; _ } =\n Ok_and_exns.create ?here ?info ?name ~run:`Now (fun () ->\n f ();\n return ())\n in\n exns\n;;\n\nlet catch ?here ?info ?name f =\n match%map Stream.next (catch_stream ?here ?info ?name f) with\n | Cons (x, _) -> x\n | Nil -> raise_s [%message \"Monitor.catch got unexpected empty stream\"]\n;;\n\nlet catch_error ?here ?info ?name f = catch ?here ?info ?name f >>| Error.of_exn\n","(** Contains Async's core data structures, like {{!Async_kernel.Deferred}[Deferred]},\n {{!Async_kernel.Ivar}[Ivar]}, and {{!Async_kernel.Clock_intf.Clock}[Clock]}.\n\n [Async_kernel] is designed to depend only on {{!Core_kernel}[Core_kernel]} (as opposed\n to {{!Core}[Core]}), and so is more platform-independent. *)\n\nopen! Core_kernel\nopen! Import\nmodule Async_kernel_config = Async_kernel_config\nmodule Async_kernel_require_explicit_time_source = Require_explicit_time_source\nmodule Async_kernel_scheduler = Async_kernel_scheduler\nmodule Bvar = Bvar\nmodule Clock_ns = Clock_ns\nmodule Condition = Async_condition\nmodule Deferred = Deferred\nmodule Execution_context = Execution_context\nmodule Gc = Async_gc\nmodule Invariant = Async_invariant\nmodule Ivar = Ivar\nmodule Lazy_deferred = Lazy_deferred\nmodule Monad_sequence = Monad_sequence\nmodule Monitor = Monitor\nmodule Mvar = Mvar\nmodule Pipe = Pipe\nmodule Priority = Priority\nmodule Sequencer = Throttle.Sequencer\nmodule Stream = Async_stream\nmodule Synchronous_time_source = Synchronous_time_source\nmodule Tail = Tail\nmodule Throttle = Throttle\nmodule Time_source = Time_source\nmodule Tracing = Tracing\n\n(** {2 Toplevel functions }\n\n The functions below are broadly useful when writing Async programs, and so are made\n available at the toplevel. *)\n\nlet after = Clock_ns.after\nlet at = Clock_ns.at\nlet catch = Monitor.catch\nlet choice = Deferred.choice\nlet choose = Deferred.choose\nlet don't_wait_for = Deferred.don't_wait_for\nlet every = Clock_ns.every\nlet never = Deferred.never\nlet schedule = Scheduler.schedule\nlet schedule' = Scheduler.schedule'\nlet try_with = Monitor.try_with\nlet upon = Deferred.upon\nlet with_timeout = Clock_ns.with_timeout\nlet within = Scheduler.within\nlet within' = Scheduler.within'\n\n(** {2 Infix operators and [Let_syntax] support} *)\n\ninclude (Deferred : Monad.Infix with type 'a t := 'a Deferred.t)\n\n(** equivalent to {!Deferred.upon}. *)\nlet ( >>> ) = Deferred.Infix.( >>> )\n\n(** equivalent to {!Deferred.Result.bind}. *)\nlet ( >>=? ) = Deferred.Result.( >>= )\n\n(** equivalent to {!Deferred.Result.map}. *)\nlet ( >>|? ) = Deferred.Result.( >>| )\n\ninclude Deferred.Let_syntax\n\n(**/**)\n\n(** The modules in [Async_kernel_private] are used for constructing and testing Async, and\n should not otherwise be used. *)\nmodule Async_kernel_private = struct\n module Debug = Debug\n module Ivar0 = Ivar0\n module Ivar_filler = Ivar_filler\n module Job = Job\n module Stack_or_counter = Stack_or_counter\nend\n\n(**/**)\n\n(* This test must be in this library, because it requires [return] to be inlined. Moving\n it to another library will cause it to break with [X_LIBRARY_INLINING=false]. *)\nlet%test_unit \"[return ()] does not allocate\" =\n let w1 = Gc.minor_words () in\n ignore (Sys.opaque_identity (return ()) : _ Deferred.t);\n ignore (Sys.opaque_identity (Deferred.return ()) : _ Deferred.t);\n ignore (Sys.opaque_identity (Deferred.Let_syntax.return ()) : _ Deferred.t);\n ignore (Sys.opaque_identity (Deferred.Let_syntax.Let_syntax.return ()) : _ Deferred.t);\n let w2 = Gc.minor_words () in\n [%test_result: int] w2 ~expect:w1\n;;\n","module By = Digestif_by\nmodule Bi = Digestif_bi\n\nlet failwith fmt = Format.kasprintf failwith fmt\n\nmodule Int32 = struct\n include Int32\n\n let ( lsl ) = Int32.shift_left\n\n let ( lsr ) = Int32.shift_right_logical\n\n let ( asr ) = Int32.shift_right\n\n let ( lor ) = Int32.logor\n\n let ( lxor ) = Int32.logxor\n\n let ( land ) = Int32.logand\n\n let lnot = Int32.lognot\n\n let ( + ) = Int32.add\n\n let rol32 a n = (a lsl n) lor (a lsr (32 - n))\n\n let ror32 a n = (a lsr n) lor (a lsl (32 - n))\nend\n\nmodule Int64 = struct\n include Int64\n\n let ( land ) = Int64.logand\n\n let ( lsl ) = Int64.shift_left\n\n let ( lsr ) = Int64.shift_right_logical\n\n let ( lor ) = Int64.logor\n\n let ( asr ) = Int64.shift_right\n\n let ( lxor ) = Int64.logxor\n\n let ( + ) = Int64.add\n\n let rol64 a n = (a lsl n) lor (a lsr (64 - n))\n\n let ror64 a n = (a lsr n) lor (a lsl (64 - n))\nend\n\nmodule type S = sig\n type ctx\n\n type kind = [ `BLAKE2B ]\n\n val init : unit -> ctx\n\n val with_outlen_and_bytes_key : int -> By.t -> int -> int -> ctx\n\n val with_outlen_and_bigstring_key : int -> Bi.t -> int -> int -> ctx\n\n val unsafe_feed_bytes : ctx -> By.t -> int -> int -> unit\n\n val unsafe_feed_bigstring : ctx -> Bi.t -> int -> int -> unit\n\n val unsafe_get : ctx -> By.t\n\n val dup : ctx -> ctx\n\n val max_outlen : int\nend\n\nmodule Unsafe : S = struct\n type kind = [ `BLAKE2B ]\n\n type param = {\n digest_length : int;\n key_length : int;\n fanout : int;\n depth : int;\n leaf_length : int32;\n node_offset : int32;\n xof_length : int32;\n node_depth : int;\n inner_length : int;\n reserved : int array;\n salt : int array;\n personal : int array;\n }\n\n type ctx = {\n mutable buflen : int;\n outlen : int;\n mutable last_node : int;\n buf : Bytes.t;\n h : int64 array;\n t : int64 array;\n f : int64 array;\n }\n\n let dup ctx =\n {\n buflen = ctx.buflen;\n outlen = ctx.outlen;\n last_node = ctx.last_node;\n buf = By.copy ctx.buf;\n h = Array.copy ctx.h;\n t = Array.copy ctx.t;\n f = Array.copy ctx.f;\n }\n\n let param_to_bytes param =\n let arr =\n [|\n param.digest_length land 0xFF;\n param.key_length land 0xFF;\n param.fanout land 0xFF;\n param.depth land 0xFF (* store to little-endian *);\n Int32.(to_int ((param.leaf_length lsr 0) land 0xFFl));\n Int32.(to_int ((param.leaf_length lsr 8) land 0xFFl));\n Int32.(to_int ((param.leaf_length lsr 16) land 0xFFl));\n Int32.(to_int ((param.leaf_length lsr 24) land 0xFFl))\n (* store to little-endian *);\n Int32.(to_int ((param.node_offset lsr 0) land 0xFFl));\n Int32.(to_int ((param.node_offset lsr 8) land 0xFFl));\n Int32.(to_int ((param.node_offset lsr 16) land 0xFFl));\n Int32.(to_int ((param.node_offset lsr 24) land 0xFFl))\n (* store to little-endian *);\n Int32.(to_int ((param.xof_length lsr 0) land 0xFFl));\n Int32.(to_int ((param.xof_length lsr 8) land 0xFFl));\n Int32.(to_int ((param.xof_length lsr 16) land 0xFFl));\n Int32.(to_int ((param.xof_length lsr 24) land 0xFFl));\n param.node_depth land 0xFF;\n param.inner_length land 0xFF;\n param.reserved.(0) land 0xFF;\n param.reserved.(1) land 0xFF;\n param.reserved.(2) land 0xFF;\n param.reserved.(3) land 0xFF;\n param.reserved.(4) land 0xFF;\n param.reserved.(5) land 0xFF;\n param.reserved.(6) land 0xFF;\n param.reserved.(7) land 0xFF;\n param.reserved.(8) land 0xFF;\n param.reserved.(9) land 0xFF;\n param.reserved.(10) land 0xFF;\n param.reserved.(11) land 0xFF;\n param.reserved.(12) land 0xFF;\n param.reserved.(13) land 0xFF;\n param.salt.(0) land 0xFF;\n param.salt.(1) land 0xFF;\n param.salt.(2) land 0xFF;\n param.salt.(3) land 0xFF;\n param.salt.(4) land 0xFF;\n param.salt.(5) land 0xFF;\n param.salt.(6) land 0xFF;\n param.salt.(7) land 0xFF;\n param.salt.(8) land 0xFF;\n param.salt.(9) land 0xFF;\n param.salt.(10) land 0xFF;\n param.salt.(11) land 0xFF;\n param.salt.(12) land 0xFF;\n param.salt.(13) land 0xFF;\n param.salt.(14) land 0xFF;\n param.salt.(15) land 0xFF;\n param.personal.(0) land 0xFF;\n param.personal.(1) land 0xFF;\n param.personal.(2) land 0xFF;\n param.personal.(3) land 0xFF;\n param.personal.(4) land 0xFF;\n param.personal.(5) land 0xFF;\n param.personal.(6) land 0xFF;\n param.personal.(7) land 0xFF;\n param.personal.(8) land 0xFF;\n param.personal.(9) land 0xFF;\n param.personal.(10) land 0xFF;\n param.personal.(11) land 0xFF;\n param.personal.(12) land 0xFF;\n param.personal.(13) land 0xFF;\n param.personal.(14) land 0xFF;\n param.personal.(15) land 0xFF;\n |] in\n By.init 64 (fun i -> Char.unsafe_chr arr.(i))\n\n let max_outlen = 64\n\n let default_param =\n {\n digest_length = max_outlen;\n key_length = 0;\n fanout = 1;\n depth = 1;\n leaf_length = 0l;\n node_offset = 0l;\n xof_length = 0l;\n node_depth = 0;\n inner_length = 0;\n reserved = [| 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0 |];\n salt = [| 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0 |];\n personal = [| 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0 |];\n }\n\n let iv =\n [|\n 0x6a09e667f3bcc908L;\n 0xbb67ae8584caa73bL;\n 0x3c6ef372fe94f82bL;\n 0xa54ff53a5f1d36f1L;\n 0x510e527fade682d1L;\n 0x9b05688c2b3e6c1fL;\n 0x1f83d9abfb41bd6bL;\n 0x5be0cd19137e2179L;\n |]\n\n let increment_counter ctx inc =\n let open Int64 in\n ctx.t.(0) <- ctx.t.(0) + inc ;\n ctx.t.(1) <- (ctx.t.(1) + if ctx.t.(0) < inc then 1L else 0L)\n\n let set_lastnode ctx = ctx.f.(1) <- Int64.minus_one\n\n let set_lastblock ctx =\n if ctx.last_node <> 0 then set_lastnode ctx ;\n ctx.f.(0) <- Int64.minus_one\n\n let init () =\n let buf = By.make 128 '\\x00' in\n By.fill buf 0 128 '\\x00' ;\n let ctx =\n {\n buflen = 0;\n outlen = default_param.digest_length;\n last_node = 0;\n buf;\n h = Array.make 8 0L;\n t = Array.make 2 0L;\n f = Array.make 2 0L;\n } in\n let param_bytes = param_to_bytes default_param in\n for i = 0 to 7 do\n ctx.h.(i) <- Int64.(iv.(i) lxor By.le64_to_cpu param_bytes (i * 8))\n done ;\n ctx\n\n let sigma =\n [|\n [| 0; 1; 2; 3; 4; 5; 6; 7; 8; 9; 10; 11; 12; 13; 14; 15 |];\n [| 14; 10; 4; 8; 9; 15; 13; 6; 1; 12; 0; 2; 11; 7; 5; 3 |];\n [| 11; 8; 12; 0; 5; 2; 15; 13; 10; 14; 3; 6; 7; 1; 9; 4 |];\n [| 7; 9; 3; 1; 13; 12; 11; 14; 2; 6; 5; 10; 4; 0; 15; 8 |];\n [| 9; 0; 5; 7; 2; 4; 10; 15; 14; 1; 11; 12; 6; 8; 3; 13 |];\n [| 2; 12; 6; 10; 0; 11; 8; 3; 4; 13; 7; 5; 15; 14; 1; 9 |];\n [| 12; 5; 1; 15; 14; 13; 4; 10; 0; 7; 6; 3; 9; 2; 8; 11 |];\n [| 13; 11; 7; 14; 12; 1; 3; 9; 5; 0; 15; 4; 8; 6; 2; 10 |];\n [| 6; 15; 14; 9; 11; 3; 0; 8; 12; 2; 13; 7; 1; 4; 10; 5 |];\n [| 10; 2; 8; 4; 7; 6; 1; 5; 15; 11; 9; 14; 3; 12; 13; 0 |];\n [| 0; 1; 2; 3; 4; 5; 6; 7; 8; 9; 10; 11; 12; 13; 14; 15 |];\n [| 14; 10; 4; 8; 9; 15; 13; 6; 1; 12; 0; 2; 11; 7; 5; 3 |];\n |]\n\n let compress :\n type a. le64_to_cpu:(a -> int -> int64) -> ctx -> a -> int -> unit =\n fun ~le64_to_cpu ctx block off ->\n let v = Array.make 16 0L in\n let m = Array.make 16 0L in\n let g r i a_idx b_idx c_idx d_idx =\n let ( ++ ) = ( + ) in\n let open Int64 in\n v.(a_idx) <- v.(a_idx) + v.(b_idx) + m.(sigma.(r).((2 * i) ++ 0)) ;\n v.(d_idx) <- ror64 (v.(d_idx) lxor v.(a_idx)) 32 ;\n v.(c_idx) <- v.(c_idx) + v.(d_idx) ;\n v.(b_idx) <- ror64 (v.(b_idx) lxor v.(c_idx)) 24 ;\n v.(a_idx) <- v.(a_idx) + v.(b_idx) + m.(sigma.(r).((2 * i) ++ 1)) ;\n v.(d_idx) <- ror64 (v.(d_idx) lxor v.(a_idx)) 16 ;\n v.(c_idx) <- v.(c_idx) + v.(d_idx) ;\n v.(b_idx) <- ror64 (v.(b_idx) lxor v.(c_idx)) 63 in\n let r r =\n g r 0 0 4 8 12 ;\n g r 1 1 5 9 13 ;\n g r 2 2 6 10 14 ;\n g r 3 3 7 11 15 ;\n g r 4 0 5 10 15 ;\n g r 5 1 6 11 12 ;\n g r 6 2 7 8 13 ;\n g r 7 3 4 9 14 in\n for i = 0 to 15 do\n m.(i) <- le64_to_cpu block (off + (i * 8))\n done ;\n for i = 0 to 7 do\n v.(i) <- ctx.h.(i)\n done ;\n v.(8) <- iv.(0) ;\n v.(9) <- iv.(1) ;\n v.(10) <- iv.(2) ;\n v.(11) <- iv.(3) ;\n v.(12) <- Int64.(iv.(4) lxor ctx.t.(0)) ;\n v.(13) <- Int64.(iv.(5) lxor ctx.t.(1)) ;\n v.(14) <- Int64.(iv.(6) lxor ctx.f.(0)) ;\n v.(15) <- Int64.(iv.(7) lxor ctx.f.(1)) ;\n r 0 ;\n r 1 ;\n r 2 ;\n r 3 ;\n r 4 ;\n r 5 ;\n r 6 ;\n r 7 ;\n r 8 ;\n r 9 ;\n r 10 ;\n r 11 ;\n let ( ++ ) = ( + ) in\n for i = 0 to 7 do\n ctx.h.(i) <- Int64.(ctx.h.(i) lxor v.(i) lxor v.(i ++ 8))\n done ;\n ()\n\n let feed :\n type a.\n blit:(a -> int -> By.t -> int -> int -> unit) ->\n le64_to_cpu:(a -> int -> int64) ->\n ctx ->\n a ->\n int ->\n int ->\n unit =\n fun ~blit ~le64_to_cpu ctx buf off len ->\n let in_off = ref off in\n let in_len = ref len in\n if !in_len > 0\n then (\n let left = ctx.buflen in\n let fill = 128 - left in\n if !in_len > fill\n then (\n ctx.buflen <- 0 ;\n blit buf !in_off ctx.buf left fill ;\n increment_counter ctx 128L ;\n compress ~le64_to_cpu:By.le64_to_cpu ctx ctx.buf 0 ;\n in_off := !in_off + fill ;\n in_len := !in_len - fill ;\n while !in_len > 128 do\n increment_counter ctx 128L ;\n compress ~le64_to_cpu ctx buf !in_off ;\n in_off := !in_off + 128 ;\n in_len := !in_len - 128\n done) ;\n blit buf !in_off ctx.buf ctx.buflen !in_len ;\n ctx.buflen <- ctx.buflen + !in_len) ;\n ()\n\n let unsafe_feed_bytes = feed ~blit:By.blit ~le64_to_cpu:By.le64_to_cpu\n\n let unsafe_feed_bigstring =\n feed ~blit:By.blit_from_bigstring ~le64_to_cpu:Bi.le64_to_cpu\n\n let with_outlen_and_key ~blit outlen key off len =\n if outlen > max_outlen\n then\n failwith \"out length can not be upper than %d (out length: %d)\" max_outlen\n outlen ;\n let buf = By.make 128 '\\x00' in\n let ctx =\n {\n buflen = 0;\n outlen;\n last_node = 0;\n buf;\n h = Array.make 8 0L;\n t = Array.make 2 0L;\n f = Array.make 2 0L;\n } in\n let param_bytes =\n param_to_bytes\n { default_param with digest_length = outlen; key_length = len } in\n for i = 0 to 7 do\n ctx.h.(i) <- Int64.(iv.(i) lxor By.le64_to_cpu param_bytes (i * 8))\n done ;\n if len > 0\n then (\n let block = By.make 128 '\\x00' in\n blit key off block 0 len ;\n unsafe_feed_bytes ctx block 0 128) ;\n ctx\n\n let with_outlen_and_bytes_key outlen key off len =\n with_outlen_and_key ~blit:By.blit outlen key off len\n\n let with_outlen_and_bigstring_key outlen key off len =\n with_outlen_and_key ~blit:By.blit_from_bigstring outlen key off len\n\n let unsafe_get ctx =\n let res = By.make default_param.digest_length '\\x00' in\n increment_counter ctx (Int64.of_int ctx.buflen) ;\n set_lastblock ctx ;\n By.fill ctx.buf ctx.buflen (128 - ctx.buflen) '\\x00' ;\n compress ~le64_to_cpu:By.le64_to_cpu ctx ctx.buf 0 ;\n for i = 0 to 7 do\n By.cpu_to_le64 res (i * 8) ctx.h.(i)\n done ;\n if ctx.outlen < default_param.digest_length\n then By.sub res 0 ctx.outlen\n else if ctx.outlen > default_param.digest_length\n then\n assert false\n (* XXX(dinosaure): [ctx] can not be initialized with [outlen > digest_length = max_outlen]. *)\n else res\nend\n","module By = Digestif_by\nmodule Bi = Digestif_bi\n\nlet failwith fmt = Format.kasprintf failwith fmt\n\nmodule Int32 = struct\n include Int32\n\n let ( lsl ) = Int32.shift_left\n\n let ( lsr ) = Int32.shift_right_logical\n\n let ( asr ) = Int32.shift_right\n\n let ( lor ) = Int32.logor\n\n let ( lxor ) = Int32.logxor\n\n let ( land ) = Int32.logand\n\n let lnot = Int32.lognot\n\n let ( + ) = Int32.add\n\n let rol32 a n = (a lsl n) lor (a lsr (32 - n))\n\n let ror32 a n = (a lsr n) lor (a lsl (32 - n))\nend\n\nmodule Int64 = struct\n include Int64\n\n let ( land ) = Int64.logand\n\n let ( lsl ) = Int64.shift_left\n\n let ( lsr ) = Int64.shift_right_logical\n\n let ( lor ) = Int64.logor\n\n let ( asr ) = Int64.shift_right\n\n let ( lxor ) = Int64.logxor\n\n let ( + ) = Int64.add\n\n let rol64 a n = (a lsl n) lor (a lsr (64 - n))\n\n let ror64 a n = (a lsr n) lor (a lsl (64 - n))\nend\n\nmodule type S = sig\n type ctx\n\n type kind = [ `BLAKE2S ]\n\n val init : unit -> ctx\n\n val with_outlen_and_bytes_key : int -> By.t -> int -> int -> ctx\n\n val with_outlen_and_bigstring_key : int -> Bi.t -> int -> int -> ctx\n\n val unsafe_feed_bytes : ctx -> By.t -> int -> int -> unit\n\n val unsafe_feed_bigstring : ctx -> Bi.t -> int -> int -> unit\n\n val unsafe_get : ctx -> By.t\n\n val dup : ctx -> ctx\n\n val max_outlen : int\nend\n\nmodule Unsafe : S = struct\n type kind = [ `BLAKE2S ]\n\n type param = {\n digest_length : int;\n key_length : int;\n fanout : int;\n depth : int;\n leaf_length : int32;\n node_offset : int32;\n xof_length : int;\n node_depth : int;\n inner_length : int;\n salt : int array;\n personal : int array;\n }\n\n type ctx = {\n mutable buflen : int;\n outlen : int;\n mutable last_node : int;\n buf : Bytes.t;\n h : int32 array;\n t : int32 array;\n f : int32 array;\n }\n\n let dup ctx =\n {\n buflen = ctx.buflen;\n outlen = ctx.outlen;\n last_node = ctx.last_node;\n buf = By.copy ctx.buf;\n h = Array.copy ctx.h;\n t = Array.copy ctx.t;\n f = Array.copy ctx.f;\n }\n\n let param_to_bytes param =\n let arr =\n [|\n param.digest_length land 0xFF;\n param.key_length land 0xFF;\n param.fanout land 0xFF;\n param.depth land 0xFF (* store to little-endian *);\n Int32.(to_int ((param.leaf_length lsr 0) land 0xFFl));\n Int32.(to_int ((param.leaf_length lsr 8) land 0xFFl));\n Int32.(to_int ((param.leaf_length lsr 16) land 0xFFl));\n Int32.(to_int ((param.leaf_length lsr 24) land 0xFFl))\n (* store to little-endian *);\n Int32.(to_int ((param.node_offset lsr 0) land 0xFFl));\n Int32.(to_int ((param.node_offset lsr 8) land 0xFFl));\n Int32.(to_int ((param.node_offset lsr 16) land 0xFFl));\n Int32.(to_int ((param.node_offset lsr 24) land 0xFFl))\n (* store to little-endian *);\n (param.xof_length lsr 0) land 0xFF;\n (param.xof_length lsr 8) land 0xFF;\n param.node_depth land 0xFF;\n param.inner_length land 0xFF;\n param.salt.(0) land 0xFF;\n param.salt.(1) land 0xFF;\n param.salt.(2) land 0xFF;\n param.salt.(3) land 0xFF;\n param.salt.(4) land 0xFF;\n param.salt.(5) land 0xFF;\n param.salt.(6) land 0xFF;\n param.salt.(7) land 0xFF;\n param.personal.(0) land 0xFF;\n param.personal.(1) land 0xFF;\n param.personal.(2) land 0xFF;\n param.personal.(3) land 0xFF;\n param.personal.(4) land 0xFF;\n param.personal.(5) land 0xFF;\n param.personal.(6) land 0xFF;\n param.personal.(7) land 0xFF;\n |] in\n By.init 32 (fun i -> Char.unsafe_chr arr.(i))\n\n let max_outlen = 32\n\n let default_param =\n {\n digest_length = max_outlen;\n key_length = 0;\n fanout = 1;\n depth = 1;\n leaf_length = 0l;\n node_offset = 0l;\n xof_length = 0;\n node_depth = 0;\n inner_length = 0;\n salt = [| 0; 0; 0; 0; 0; 0; 0; 0 |];\n personal = [| 0; 0; 0; 0; 0; 0; 0; 0 |];\n }\n\n let iv =\n [|\n 0x6A09E667l;\n 0xBB67AE85l;\n 0x3C6EF372l;\n 0xA54FF53Al;\n 0x510E527Fl;\n 0x9B05688Cl;\n 0x1F83D9ABl;\n 0x5BE0CD19l;\n |]\n\n let increment_counter ctx inc =\n let open Int32 in\n ctx.t.(0) <- ctx.t.(0) + inc ;\n ctx.t.(1) <- (ctx.t.(1) + if ctx.t.(0) < inc then 1l else 0l)\n\n let set_lastnode ctx = ctx.f.(1) <- Int32.minus_one\n\n let set_lastblock ctx =\n if ctx.last_node <> 0 then set_lastnode ctx ;\n ctx.f.(0) <- Int32.minus_one\n\n let init () =\n let buf = By.make 64 '\\x00' in\n let ctx =\n {\n buflen = 0;\n outlen = default_param.digest_length;\n last_node = 0;\n buf;\n h = Array.make 8 0l;\n t = Array.make 2 0l;\n f = Array.make 2 0l;\n } in\n let param_bytes = param_to_bytes default_param in\n for i = 0 to 7 do\n ctx.h.(i) <- Int32.(iv.(i) lxor By.le32_to_cpu param_bytes (i * 4))\n done ;\n ctx\n\n let sigma =\n [|\n [| 0; 1; 2; 3; 4; 5; 6; 7; 8; 9; 10; 11; 12; 13; 14; 15 |];\n [| 14; 10; 4; 8; 9; 15; 13; 6; 1; 12; 0; 2; 11; 7; 5; 3 |];\n [| 11; 8; 12; 0; 5; 2; 15; 13; 10; 14; 3; 6; 7; 1; 9; 4 |];\n [| 7; 9; 3; 1; 13; 12; 11; 14; 2; 6; 5; 10; 4; 0; 15; 8 |];\n [| 9; 0; 5; 7; 2; 4; 10; 15; 14; 1; 11; 12; 6; 8; 3; 13 |];\n [| 2; 12; 6; 10; 0; 11; 8; 3; 4; 13; 7; 5; 15; 14; 1; 9 |];\n [| 12; 5; 1; 15; 14; 13; 4; 10; 0; 7; 6; 3; 9; 2; 8; 11 |];\n [| 13; 11; 7; 14; 12; 1; 3; 9; 5; 0; 15; 4; 8; 6; 2; 10 |];\n [| 6; 15; 14; 9; 11; 3; 0; 8; 12; 2; 13; 7; 1; 4; 10; 5 |];\n [| 10; 2; 8; 4; 7; 6; 1; 5; 15; 11; 9; 14; 3; 12; 13; 0 |];\n |]\n\n let compress :\n type a. le32_to_cpu:(a -> int -> int32) -> ctx -> a -> int -> unit =\n fun ~le32_to_cpu ctx block off ->\n let v = Array.make 16 0l in\n let m = Array.make 16 0l in\n let g r i a_idx b_idx c_idx d_idx =\n let ( ++ ) = ( + ) in\n let open Int32 in\n v.(a_idx) <- v.(a_idx) + v.(b_idx) + m.(sigma.(r).((2 * i) ++ 0)) ;\n v.(d_idx) <- ror32 (v.(d_idx) lxor v.(a_idx)) 16 ;\n v.(c_idx) <- v.(c_idx) + v.(d_idx) ;\n v.(b_idx) <- ror32 (v.(b_idx) lxor v.(c_idx)) 12 ;\n v.(a_idx) <- v.(a_idx) + v.(b_idx) + m.(sigma.(r).((2 * i) ++ 1)) ;\n v.(d_idx) <- ror32 (v.(d_idx) lxor v.(a_idx)) 8 ;\n v.(c_idx) <- v.(c_idx) + v.(d_idx) ;\n v.(b_idx) <- ror32 (v.(b_idx) lxor v.(c_idx)) 7 in\n let r r =\n g r 0 0 4 8 12 ;\n g r 1 1 5 9 13 ;\n g r 2 2 6 10 14 ;\n g r 3 3 7 11 15 ;\n g r 4 0 5 10 15 ;\n g r 5 1 6 11 12 ;\n g r 6 2 7 8 13 ;\n g r 7 3 4 9 14 in\n for i = 0 to 15 do\n m.(i) <- le32_to_cpu block (off + (i * 4))\n done ;\n for i = 0 to 7 do\n v.(i) <- ctx.h.(i)\n done ;\n v.(8) <- iv.(0) ;\n v.(9) <- iv.(1) ;\n v.(10) <- iv.(2) ;\n v.(11) <- iv.(3) ;\n v.(12) <- Int32.(iv.(4) lxor ctx.t.(0)) ;\n v.(13) <- Int32.(iv.(5) lxor ctx.t.(1)) ;\n v.(14) <- Int32.(iv.(6) lxor ctx.f.(0)) ;\n v.(15) <- Int32.(iv.(7) lxor ctx.f.(1)) ;\n r 0 ;\n r 1 ;\n r 2 ;\n r 3 ;\n r 4 ;\n r 5 ;\n r 6 ;\n r 7 ;\n r 8 ;\n r 9 ;\n let ( ++ ) = ( + ) in\n for i = 0 to 7 do\n ctx.h.(i) <- Int32.(ctx.h.(i) lxor v.(i) lxor v.(i ++ 8))\n done ;\n ()\n\n let feed :\n type a.\n blit:(a -> int -> By.t -> int -> int -> unit) ->\n le32_to_cpu:(a -> int -> int32) ->\n ctx ->\n a ->\n int ->\n int ->\n unit =\n fun ~blit ~le32_to_cpu ctx buf off len ->\n let in_off = ref off in\n let in_len = ref len in\n if !in_len > 0\n then (\n let left = ctx.buflen in\n let fill = 64 - left in\n if !in_len > fill\n then (\n ctx.buflen <- 0 ;\n blit buf !in_off ctx.buf left fill ;\n increment_counter ctx 64l ;\n compress ~le32_to_cpu:By.le32_to_cpu ctx ctx.buf 0 ;\n in_off := !in_off + fill ;\n in_len := !in_len - fill ;\n while !in_len > 64 do\n increment_counter ctx 64l ;\n compress ~le32_to_cpu ctx buf !in_off ;\n in_off := !in_off + 64 ;\n in_len := !in_len - 64\n done) ;\n blit buf !in_off ctx.buf ctx.buflen !in_len ;\n ctx.buflen <- ctx.buflen + !in_len) ;\n ()\n\n let unsafe_feed_bytes = feed ~blit:By.blit ~le32_to_cpu:By.le32_to_cpu\n\n let unsafe_feed_bigstring =\n feed ~blit:By.blit_from_bigstring ~le32_to_cpu:Bi.le32_to_cpu\n\n let with_outlen_and_key ~blit outlen key off len =\n if outlen > max_outlen\n then\n failwith \"out length can not be upper than %d (out length: %d)\" max_outlen\n outlen ;\n let buf = By.make 64 '\\x00' in\n let ctx =\n {\n buflen = 0;\n outlen;\n last_node = 0;\n buf;\n h = Array.make 8 0l;\n t = Array.make 2 0l;\n f = Array.make 2 0l;\n } in\n let param_bytes =\n param_to_bytes\n { default_param with key_length = len; digest_length = outlen } in\n for i = 0 to 7 do\n ctx.h.(i) <- Int32.(iv.(i) lxor By.le32_to_cpu param_bytes (i * 4))\n done ;\n if len > 0\n then (\n let block = By.make 64 '\\x00' in\n blit key off block 0 len ;\n unsafe_feed_bytes ctx block 0 64) ;\n ctx\n\n let with_outlen_and_bytes_key outlen key off len =\n with_outlen_and_key ~blit:By.blit outlen key off len\n\n let with_outlen_and_bigstring_key outlen key off len =\n with_outlen_and_key ~blit:By.blit_from_bigstring outlen key off len\n\n let unsafe_get ctx =\n let res = By.make default_param.digest_length '\\x00' in\n increment_counter ctx (Int32.of_int ctx.buflen) ;\n set_lastblock ctx ;\n By.fill ctx.buf ctx.buflen (64 - ctx.buflen) '\\x00' ;\n compress ~le32_to_cpu:By.le32_to_cpu ctx ctx.buf 0 ;\n for i = 0 to 7 do\n By.cpu_to_le32 res (i * 4) ctx.h.(i)\n done ;\n if ctx.outlen < default_param.digest_length\n then By.sub res 0 ctx.outlen\n else if ctx.outlen > default_param.digest_length\n then\n assert false\n (* XXX(dinosaure): [ctx] can not be initialized with [outlen > digest_length = max_outlen]. *)\n else res\nend\n","type bigstring =\n ( char,\n Bigarray_compat.int8_unsigned_elt,\n Bigarray_compat.c_layout )\n Bigarray_compat.Array1.t\n\ntype 'a iter = ('a -> unit) -> unit\n\ntype 'a compare = 'a -> 'a -> int\n\ntype 'a equal = 'a -> 'a -> bool\n\ntype 'a pp = Format.formatter -> 'a -> unit\n\nmodule By = Digestif_by\nmodule Bi = Digestif_bi\nmodule Eq = Digestif_eq\nmodule Hash = Digestif_hash\nmodule Conv = Digestif_conv\n\nlet failwith fmt = Format.ksprintf failwith fmt\n\nmodule type S = sig\n val digest_size : int\n\n type ctx\n\n type kind\n\n type t\n\n val kind : kind\n\n val empty : ctx\n\n val init : unit -> ctx\n\n val feed_bytes : ctx -> ?off:int -> ?len:int -> Bytes.t -> ctx\n\n val feed_string : ctx -> ?off:int -> ?len:int -> String.t -> ctx\n\n val feed_bigstring : ctx -> ?off:int -> ?len:int -> bigstring -> ctx\n\n val feedi_bytes : ctx -> Bytes.t iter -> ctx\n\n val feedi_string : ctx -> String.t iter -> ctx\n\n val feedi_bigstring : ctx -> bigstring iter -> ctx\n\n val get : ctx -> t\n\n val digest_bytes : ?off:int -> ?len:int -> Bytes.t -> t\n\n val digest_string : ?off:int -> ?len:int -> String.t -> t\n\n val digest_bigstring : ?off:int -> ?len:int -> bigstring -> t\n\n val digesti_bytes : Bytes.t iter -> t\n\n val digesti_string : String.t iter -> t\n\n val digesti_bigstring : bigstring iter -> t\n\n val digestv_bytes : Bytes.t list -> t\n\n val digestv_string : String.t list -> t\n\n val digestv_bigstring : bigstring list -> t\n\n val hmac_bytes : key:Bytes.t -> ?off:int -> ?len:int -> Bytes.t -> t\n\n val hmac_string : key:String.t -> ?off:int -> ?len:int -> String.t -> t\n\n val hmac_bigstring : key:bigstring -> ?off:int -> ?len:int -> bigstring -> t\n\n val hmaci_bytes : key:Bytes.t -> Bytes.t iter -> t\n\n val hmaci_string : key:String.t -> String.t iter -> t\n\n val hmaci_bigstring : key:bigstring -> bigstring iter -> t\n\n val hmacv_bytes : key:Bytes.t -> Bytes.t list -> t\n\n val hmacv_string : key:String.t -> String.t list -> t\n\n val hmacv_bigstring : key:bigstring -> bigstring list -> t\n\n val unsafe_compare : t compare\n\n val equal : t equal\n\n val pp : t pp\n\n val of_hex : string -> t\n\n val of_hex_opt : string -> t option\n\n val consistent_of_hex : string -> t\n\n val consistent_of_hex_opt : string -> t option\n\n val to_hex : t -> string\n\n val of_raw_string : string -> t\n\n val of_raw_string_opt : string -> t option\n\n val to_raw_string : t -> string\nend\n\nmodule type MAC = sig\n type t\n\n val mac_bytes : key:Bytes.t -> ?off:int -> ?len:int -> Bytes.t -> t\n\n val mac_string : key:String.t -> ?off:int -> ?len:int -> String.t -> t\n\n val mac_bigstring : key:bigstring -> ?off:int -> ?len:int -> bigstring -> t\n\n val maci_bytes : key:Bytes.t -> Bytes.t iter -> t\n\n val maci_string : key:String.t -> String.t iter -> t\n\n val maci_bigstring : key:bigstring -> bigstring iter -> t\n\n val macv_bytes : key:Bytes.t -> Bytes.t list -> t\n\n val macv_string : key:String.t -> String.t list -> t\n\n val macv_bigstring : key:bigstring -> bigstring list -> t\nend\n\nmodule type Desc = sig\n type kind\n\n val digest_size : int\n\n val block_size : int\n\n val kind : kind\nend\n\nmodule type Hash = sig\n type ctx\n\n type kind\n\n val init : unit -> ctx\n\n val unsafe_feed_bytes : ctx -> By.t -> int -> int -> unit\n\n val unsafe_feed_bigstring : ctx -> Bi.t -> int -> int -> unit\n\n val unsafe_get : ctx -> By.t\n\n val dup : ctx -> ctx\nend\n\nmodule Unsafe (Hash : Hash) (D : Desc) = struct\n open Hash\n\n let digest_size = D.digest_size\n\n let block_size = D.block_size\n\n let empty = init ()\n\n let init = init\n\n let unsafe_feed_bytes ctx ?off ?len buf =\n let off, len =\n match (off, len) with\n | Some off, Some len -> (off, len)\n | Some off, None -> (off, By.length buf - off)\n | None, Some len -> (0, len)\n | None, None -> (0, By.length buf) in\n if off < 0 || len < 0 || off > By.length buf - len\n then invalid_arg \"offset out of bounds\"\n else unsafe_feed_bytes ctx buf off len\n\n let unsafe_feed_string ctx ?off ?len buf =\n unsafe_feed_bytes ctx ?off ?len (By.unsafe_of_string buf)\n\n let unsafe_feed_bigstring ctx ?off ?len buf =\n let off, len =\n match (off, len) with\n | Some off, Some len -> (off, len)\n | Some off, None -> (off, Bi.length buf - off)\n | None, Some len -> (0, len)\n | None, None -> (0, Bi.length buf) in\n if off < 0 || len < 0 || off > Bi.length buf - len\n then invalid_arg \"offset out of bounds\"\n else unsafe_feed_bigstring ctx buf off len\n\n let unsafe_get = unsafe_get\nend\n\nmodule Core (Hash : Hash) (D : Desc) = struct\n type t = string\n\n type ctx = Hash.ctx\n\n type kind = Hash.kind\n\n include Unsafe (Hash) (D)\n include Conv.Make (D)\n include Eq.Make (D)\n\n let kind = D.kind\n\n let get t =\n let t = Hash.dup t in\n unsafe_get t |> By.unsafe_to_string\n\n let feed_bytes t ?off ?len buf =\n let t = Hash.dup t in\n unsafe_feed_bytes t ?off ?len buf ;\n t\n\n let feed_string t ?off ?len buf =\n let t = Hash.dup t in\n unsafe_feed_string t ?off ?len buf ;\n t\n\n let feed_bigstring t ?off ?len buf =\n let t = Hash.dup t in\n unsafe_feed_bigstring t ?off ?len buf ;\n t\n\n let feedi_bytes t iter =\n let t = Hash.dup t in\n let feed buf = unsafe_feed_bytes t buf in\n iter feed ;\n t\n\n let feedi_string t iter =\n let t = Hash.dup t in\n let feed buf = unsafe_feed_string t buf in\n iter feed ;\n t\n\n let feedi_bigstring t iter =\n let t = Hash.dup t in\n let feed buf = unsafe_feed_bigstring t buf in\n iter feed ;\n t\n\n let digest_bytes ?off ?len buf = feed_bytes empty ?off ?len buf |> get\n\n let digest_string ?off ?len buf = feed_string empty ?off ?len buf |> get\n\n let digest_bigstring ?off ?len buf = feed_bigstring empty ?off ?len buf |> get\n\n let digesti_bytes iter = feedi_bytes empty iter |> get\n\n let digesti_string iter = feedi_string empty iter |> get\n\n let digesti_bigstring iter = feedi_bigstring empty iter |> get\n\n let digestv_bytes lst = digesti_bytes (fun f -> List.iter f lst)\n\n let digestv_string lst = digesti_string (fun f -> List.iter f lst)\n\n let digestv_bigstring lst = digesti_bigstring (fun f -> List.iter f lst)\nend\n\nmodule Make (H : Hash) (D : Desc) = struct\n include Core (H) (D)\n\n let bytes_opad = By.init block_size (fun _ -> '\\x5c')\n\n let bytes_ipad = By.init block_size (fun _ -> '\\x36')\n\n let rec norm_bytes key =\n match Stdlib.compare (By.length key) block_size with\n | 1 -> norm_bytes (By.unsafe_of_string (digest_bytes key))\n | -1 -> By.rpad key block_size '\\000'\n | _ -> key\n\n let bigstring_opad = Bi.init block_size (fun _ -> '\\x5c')\n\n let bigstring_ipad = Bi.init block_size (fun _ -> '\\x36')\n\n let norm_bigstring key =\n let key = Bi.to_string key in\n let res0 = norm_bytes (By.unsafe_of_string key) in\n let res1 = Bi.create (By.length res0) in\n Bi.blit_from_bytes res0 0 res1 0 (By.length res0) ;\n res1\n\n let hmaci_bytes ~key iter =\n let key = norm_bytes key in\n let outer = Xor.Bytes.xor key bytes_opad in\n let inner = Xor.Bytes.xor key bytes_ipad in\n let res =\n digesti_bytes (fun f ->\n f inner ;\n iter f) in\n digesti_bytes (fun f ->\n f outer ;\n f (By.unsafe_of_string res))\n\n let hmaci_string ~key iter =\n let key = norm_bytes (By.unsafe_of_string key) in\n (* XXX(dinosaure): safe, [rpad] and [digest] have a read-only access. *)\n let outer = Xor.Bytes.xor key bytes_opad in\n let inner = Xor.Bytes.xor key bytes_ipad in\n let ctx = feed_bytes empty inner in\n let res = feedi_string ctx iter |> get in\n let ctx = feed_bytes empty outer in\n feed_string ctx (res :> string) |> get\n\n let hmaci_bigstring ~key iter =\n let key = norm_bigstring key in\n let outer = Xor.Bigstring.xor key bigstring_opad in\n let inner = Xor.Bigstring.xor key bigstring_ipad in\n let res =\n digesti_bigstring (fun f ->\n f inner ;\n iter f) in\n let ctx = feed_bigstring empty outer in\n feed_string ctx (res :> string) |> get\n\n let hmac_bytes ~key ?off ?len buf =\n let buf =\n match (off, len) with\n | Some off, Some len -> By.sub buf off len\n | Some off, None -> By.sub buf off (By.length buf - off)\n | None, Some len -> By.sub buf 0 len\n | None, None -> buf in\n hmaci_bytes ~key (fun f -> f buf)\n\n let hmac_string ~key ?off ?len buf =\n let buf =\n match (off, len) with\n | Some off, Some len -> String.sub buf off len\n | Some off, None -> String.sub buf off (String.length buf - off)\n | None, Some len -> String.sub buf 0 len\n | None, None -> buf in\n hmaci_string ~key (fun f -> f buf)\n\n let hmac_bigstring ~key ?off ?len buf =\n let buf =\n match (off, len) with\n | Some off, Some len -> Bi.sub buf off len\n | Some off, None -> Bi.sub buf off (Bi.length buf - off)\n | None, Some len -> Bi.sub buf 0 len\n | None, None -> buf in\n hmaci_bigstring ~key (fun f -> f buf)\n\n let hmacv_bytes ~key bufs = hmaci_bytes ~key (fun f -> List.iter f bufs)\n\n let hmacv_string ~key bufs = hmaci_string ~key (fun f -> List.iter f bufs)\n\n let hmacv_bigstring ~key bufs =\n hmaci_bigstring ~key (fun f -> List.iter f bufs)\nend\n\nmodule type Hash_BLAKE2 = sig\n type ctx\n\n type kind\n\n val with_outlen_and_bytes_key : int -> By.t -> int -> int -> ctx\n\n val with_outlen_and_bigstring_key : int -> Bi.t -> int -> int -> ctx\n\n val unsafe_feed_bytes : ctx -> By.t -> int -> int -> unit\n\n val unsafe_feed_bigstring : ctx -> Bi.t -> int -> int -> unit\n\n val unsafe_get : ctx -> By.t\n\n val dup : ctx -> ctx\n\n val max_outlen : int\nend\n\nmodule Make_BLAKE2 (H : Hash_BLAKE2) (D : Desc) = struct\n let () =\n if D.digest_size > H.max_outlen\n then\n failwith \"Invalid digest_size:%d to make a BLAKE2{S,B} implementation\"\n D.digest_size\n\n include Make\n (struct\n type ctx = H.ctx\n\n type kind = H.kind\n\n let init () =\n H.with_outlen_and_bytes_key D.digest_size By.empty 0 0\n\n let unsafe_feed_bytes = H.unsafe_feed_bytes\n\n let unsafe_feed_bigstring = H.unsafe_feed_bigstring\n\n let unsafe_get = H.unsafe_get\n\n let dup = H.dup\n end)\n (D)\n\n type outer = t\n\n module Keyed = struct\n type t = outer\n\n let maci_bytes ~key iter =\n let ctx = H.with_outlen_and_bytes_key digest_size key 0 (By.length key) in\n feedi_bytes ctx iter |> get\n\n let maci_string ~key iter =\n let ctx =\n H.with_outlen_and_bytes_key digest_size (By.unsafe_of_string key) 0\n (String.length key) in\n feedi_string ctx iter |> get\n\n let maci_bigstring ~key iter =\n let ctx =\n H.with_outlen_and_bigstring_key digest_size key 0 (Bi.length key) in\n feedi_bigstring ctx iter |> get\n\n let mac_bytes ~key ?off ?len buf : t =\n let buf =\n match (off, len) with\n | Some off, Some len -> By.sub buf off len\n | Some off, None -> By.sub buf off (By.length buf - off)\n | None, Some len -> By.sub buf 0 len\n | None, None -> buf in\n maci_bytes ~key (fun f -> f buf)\n\n let mac_string ~key ?off ?len buf =\n let buf =\n match (off, len) with\n | Some off, Some len -> String.sub buf off len\n | Some off, None -> String.sub buf off (String.length buf - off)\n | None, Some len -> String.sub buf 0 len\n | None, None -> buf in\n maci_string ~key (fun f -> f buf)\n\n let mac_bigstring ~key ?off ?len buf =\n let buf =\n match (off, len) with\n | Some off, Some len -> Bi.sub buf off len\n | Some off, None -> Bi.sub buf off (Bi.length buf - off)\n | None, Some len -> Bi.sub buf 0 len\n | None, None -> buf in\n maci_bigstring ~key (fun f -> f buf)\n\n let macv_bytes ~key bufs = maci_bytes ~key (fun f -> List.iter f bufs)\n\n let macv_string ~key bufs = maci_string ~key (fun f -> List.iter f bufs)\n\n let macv_bigstring ~key bufs =\n maci_bigstring ~key (fun f -> List.iter f bufs)\n end\nend\n\nmodule MD5 : S with type kind = [ `MD5 ] =\n Make\n (Baijiu_md5.Unsafe)\n (struct\n let digest_size, block_size = (16, 64)\n\n type kind = [ `MD5 ]\n\n let kind = `MD5\n end)\n\nmodule SHA1 : S with type kind = [ `SHA1 ] =\n Make\n (Baijiu_sha1.Unsafe)\n (struct\n let digest_size, block_size = (20, 64)\n\n type kind = [ `SHA1 ]\n\n let kind = `SHA1\n end)\n\nmodule SHA224 : S with type kind = [ `SHA224 ] =\n Make\n (Baijiu_sha224.Unsafe)\n (struct\n let digest_size, block_size = (28, 64)\n\n type kind = [ `SHA224 ]\n\n let kind = `SHA224\n end)\n\nmodule SHA256 : S with type kind = [ `SHA256 ] =\n Make\n (Baijiu_sha256.Unsafe)\n (struct\n let digest_size, block_size = (32, 64)\n\n type kind = [ `SHA256 ]\n\n let kind = `SHA256\n end)\n\nmodule SHA384 : S with type kind = [ `SHA384 ] =\n Make\n (Baijiu_sha384.Unsafe)\n (struct\n let digest_size, block_size = (48, 128)\n\n type kind = [ `SHA384 ]\n\n let kind = `SHA384\n end)\n\nmodule SHA512 : S with type kind = [ `SHA512 ] =\n Make\n (Baijiu_sha512.Unsafe)\n (struct\n let digest_size, block_size = (64, 128)\n\n type kind = [ `SHA512 ]\n\n let kind = `SHA512\n end)\n\nmodule SHA3_224 : S with type kind = [ `SHA3_224 ] =\n Make\n (Baijiu_sha3_224.Unsafe)\n (struct\n let digest_size, block_size = (28, 144)\n\n type kind = [ `SHA3_224 ]\n\n let kind = `SHA3_224\n end)\n\nmodule SHA3_256 : S with type kind = [ `SHA3_256 ] =\n Make\n (Baijiu_sha3_256.Unsafe)\n (struct\n let digest_size, block_size = (32, 136)\n\n type kind = [ `SHA3_256 ]\n\n let kind = `SHA3_256\n end)\n\nmodule SHA3_384 : S with type kind = [ `SHA3_384 ] =\n Make\n (Baijiu_sha3_384.Unsafe)\n (struct\n let digest_size, block_size = (48, 104)\n\n type kind = [ `SHA3_384 ]\n\n let kind = `SHA3_384\n end)\n\nmodule SHA3_512 : S with type kind = [ `SHA3_512 ] =\n Make\n (Baijiu_sha3_512.Unsafe)\n (struct\n let digest_size, block_size = (64, 72)\n\n type kind = [ `SHA3_512 ]\n\n let kind = `SHA3_512\n end)\n\nmodule WHIRLPOOL : S with type kind = [ `WHIRLPOOL ] =\n Make\n (Baijiu_whirlpool.Unsafe)\n (struct\n let digest_size, block_size = (64, 64)\n\n type kind = [ `WHIRLPOOL ]\n\n let kind = `WHIRLPOOL\n end)\n\nmodule BLAKE2B : sig\n include S with type kind = [ `BLAKE2B ]\n\n module Keyed : MAC with type t = t\nend =\n Make_BLAKE2\n (Baijiu_blake2b.Unsafe)\n (struct\n let digest_size, block_size = (64, 128)\n\n type kind = [ `BLAKE2B ]\n\n let kind = `BLAKE2B\n end)\n\nmodule BLAKE2S : sig\n include S with type kind = [ `BLAKE2S ]\n\n module Keyed : MAC with type t = t\nend =\n Make_BLAKE2\n (Baijiu_blake2s.Unsafe)\n (struct\n let digest_size, block_size = (32, 64)\n\n type kind = [ `BLAKE2S ]\n\n let kind = `BLAKE2S\n end)\n\nmodule RMD160 : S with type kind = [ `RMD160 ] =\n Make\n (Baijiu_rmd160.Unsafe)\n (struct\n let digest_size, block_size = (20, 64)\n\n type kind = [ `RMD160 ]\n\n let kind = `RMD160\n end)\n\nmodule Make_BLAKE2B (D : sig\n val digest_size : int\nend) : S with type kind = [ `BLAKE2B ] = struct\n include Make_BLAKE2\n (Baijiu_blake2b.Unsafe)\n (struct\n let digest_size, block_size = (D.digest_size, 128)\n\n type kind = [ `BLAKE2B ]\n\n let kind = `BLAKE2B\n end)\nend\n\nmodule Make_BLAKE2S (D : sig\n val digest_size : int\nend) : S with type kind = [ `BLAKE2S ] = struct\n include Make_BLAKE2\n (Baijiu_blake2s.Unsafe)\n (struct\n let digest_size, block_size = (D.digest_size, 64)\n\n type kind = [ `BLAKE2S ]\n\n let kind = `BLAKE2S\n end)\nend\n\ninclude Hash\n\ntype blake2b = (module S with type kind = [ `BLAKE2B ])\n\ntype blake2s = (module S with type kind = [ `BLAKE2S ])\n\nlet module_of : type k. k hash -> (module S with type kind = k) =\n fun hash ->\n let b2b : (int, blake2b) Hashtbl.t = Hashtbl.create 13 in\n let b2s : (int, blake2s) Hashtbl.t = Hashtbl.create 13 in\n match hash with\n | MD5 -> (module MD5)\n | SHA1 -> (module SHA1)\n | RMD160 -> (module RMD160)\n | SHA224 -> (module SHA224)\n | SHA256 -> (module SHA256)\n | SHA384 -> (module SHA384)\n | SHA512 -> (module SHA512)\n | SHA3_224 -> (module SHA3_224)\n | SHA3_256 -> (module SHA3_256)\n | SHA3_384 -> (module SHA3_384)\n | SHA3_512 -> (module SHA3_512)\n | WHIRLPOOL -> (module WHIRLPOOL)\n | BLAKE2B digest_size -> (\n match Hashtbl.find b2b digest_size with\n | exception Not_found ->\n let m : (module S with type kind = [ `BLAKE2B ]) =\n (module Make_BLAKE2B (struct\n let digest_size = digest_size\n end) : S\n with type kind = [ `BLAKE2B ]) in\n Hashtbl.replace b2b digest_size m ;\n m\n | m -> m)\n | BLAKE2S digest_size ->\n match Hashtbl.find b2s digest_size with\n | exception Not_found ->\n let m =\n (module Make_BLAKE2S (struct\n let digest_size = digest_size\n end) : S\n with type kind = [ `BLAKE2S ]) in\n Hashtbl.replace b2s digest_size m ;\n m\n | m -> m\n\ntype 'kind t = string\n\nlet digest_bytes : type k. k hash -> Bytes.t -> k t =\n fun hash buf ->\n let module H = (val module_of hash) in\n (H.to_raw_string (H.digest_bytes buf) : H.kind t)\n\nlet digest_string : type k. k hash -> String.t -> k t =\n fun hash buf ->\n let module H = (val module_of hash) in\n (H.to_raw_string (H.digest_string buf) : H.kind t)\n\nlet digest_bigstring : type k. k hash -> bigstring -> k t =\n fun hash buf ->\n let module H = (val module_of hash) in\n (H.to_raw_string (H.digest_bigstring buf) : H.kind t)\n\nlet digesti_bytes : type k. k hash -> Bytes.t iter -> k t =\n fun hash iter ->\n let module H = (val module_of hash) in\n (H.to_raw_string (H.digesti_bytes iter) : H.kind t)\n\nlet digesti_string : type k. k hash -> String.t iter -> k t =\n fun hash iter ->\n let module H = (val module_of hash) in\n (H.to_raw_string (H.digesti_string iter) : H.kind t)\n\nlet digesti_bigstring : type k. k hash -> bigstring iter -> k t =\n fun hash iter ->\n let module H = (val module_of hash) in\n (H.to_raw_string (H.digesti_bigstring iter) : H.kind t)\n\nlet hmaci_bytes : type k. k hash -> key:Bytes.t -> Bytes.t iter -> k t =\n fun hash ~key iter ->\n let module H = (val module_of hash) in\n (H.to_raw_string (H.hmaci_bytes ~key iter) : H.kind t)\n\nlet hmaci_string : type k. k hash -> key:String.t -> String.t iter -> k t =\n fun hash ~key iter ->\n let module H = (val module_of hash) in\n (H.to_raw_string (H.hmaci_string ~key iter) : H.kind t)\n\nlet hmaci_bigstring : type k. k hash -> key:bigstring -> bigstring iter -> k t =\n fun hash ~key iter ->\n let module H = (val module_of hash) in\n (H.to_raw_string (H.hmaci_bigstring ~key iter) : H.kind t)\n\n(* XXX(dinosaure): unsafe part to avoid overhead. *)\n\nlet unsafe_compare : type k. k hash -> k t -> k t -> int =\n fun hash a b ->\n let module H = (val module_of hash) in\n let unsafe : 'k t -> H.t = H.of_raw_string in\n H.unsafe_compare (unsafe a) (unsafe b)\n\nlet equal : type k. k hash -> k t equal =\n fun hash a b ->\n let module H = (val module_of hash) in\n let unsafe : 'k t -> H.t = H.of_raw_string in\n H.equal (unsafe a) (unsafe b)\n\nlet pp : type k. k hash -> k t pp =\n fun hash ppf t ->\n let module H = (val module_of hash) in\n let unsafe : 'k t -> H.t = H.of_raw_string in\n H.pp ppf (unsafe t)\n\nlet of_hex : type k. k hash -> string -> k t =\n fun hash hex ->\n let module H = (val module_of hash) in\n H.to_raw_string (H.of_hex hex)\n\nlet of_hex_opt : type k. k hash -> string -> k t option =\n fun hash hex ->\n let module H = (val module_of hash) in\n match H.of_hex_opt hex with\n | None -> None\n | Some digest -> Some (H.to_raw_string digest)\n\nlet consistent_of_hex : type k. k hash -> string -> k t =\n fun hash hex ->\n let module H = (val module_of hash) in\n H.to_raw_string (H.consistent_of_hex hex)\n\nlet consistent_of_hex_opt : type k. k hash -> string -> k t option =\n fun hash hex ->\n let module H = (val module_of hash) in\n match H.consistent_of_hex_opt hex with\n | None -> None\n | Some digest -> Some (H.to_raw_string digest)\n\nlet to_hex : type k. k hash -> k t -> string =\n fun hash t ->\n let module H = (val module_of hash) in\n let unsafe : 'k t -> H.t = H.of_raw_string in\n H.to_hex (unsafe t)\n\nlet of_raw_string : type k. k hash -> string -> k t =\n fun hash s ->\n let module H = (val module_of hash) in\n let unsafe : H.t -> 'k t = H.to_raw_string in\n unsafe (H.of_raw_string s)\n\nlet of_raw_string_opt : type k. k hash -> string -> k t option =\n fun hash s ->\n let module H = (val module_of hash) in\n let unsafe : H.t -> 'k t = H.to_raw_string in\n match H.of_raw_string_opt s with\n | None -> None\n | Some digest -> Some (unsafe digest)\n\nlet to_raw_string : type k. k hash -> k t -> string = fun _ t -> t\n\nlet of_digest (type hash kind)\n (module H : S with type t = hash and type kind = kind) (hash : H.t) : kind t\n =\n H.to_raw_string hash\n\nlet of_md5 hash = of_raw_string md5 (MD5.to_raw_string hash)\n\nlet of_sha1 hash = of_raw_string sha1 (SHA1.to_raw_string hash)\n\nlet of_rmd160 hash = of_raw_string rmd160 (RMD160.to_raw_string hash)\n\nlet of_sha224 hash = of_raw_string sha224 (SHA224.to_raw_string hash)\n\nlet of_sha256 hash = of_raw_string sha256 (SHA256.to_raw_string hash)\n\nlet of_sha384 hash = of_raw_string sha384 (SHA384.to_raw_string hash)\n\nlet of_sha512 hash = of_raw_string sha512 (SHA512.to_raw_string hash)\n\nlet of_sha3_224 hash = of_raw_string sha3_224 (SHA3_224.to_raw_string hash)\n\nlet of_sha3_256 hash = of_raw_string sha3_256 (SHA3_256.to_raw_string hash)\n\nlet of_sha3_384 hash = of_raw_string sha3_384 (SHA3_384.to_raw_string hash)\n\nlet of_sha3_512 hash = of_raw_string sha3_512 (SHA3_512.to_raw_string hash)\n\nlet of_whirlpool hash = of_raw_string whirlpool (WHIRLPOOL.to_raw_string hash)\n\nlet of_blake2b hash =\n of_raw_string (blake2b BLAKE2B.digest_size) (BLAKE2B.to_raw_string hash)\n\nlet of_blake2s hash =\n of_raw_string (blake2s BLAKE2S.digest_size) (BLAKE2S.to_raw_string hash)\n","open Core_kernel\n\nmodule Digit = struct\n (* A number between 0 and 15 *)\n type t =\n | H0\n | H1\n | H2\n | H3\n | H4\n | H5\n | H6\n | H7\n | H8\n | H9\n | H10\n | H11\n | H12\n | H13\n | H14\n | H15\n\n let of_char_exn c =\n match Char.lowercase c with\n | '0' ->\n H0\n | '1' ->\n H1\n | '2' ->\n H2\n | '3' ->\n H3\n | '4' ->\n H4\n | '5' ->\n H5\n | '6' ->\n H6\n | '7' ->\n H7\n | '8' ->\n H8\n | '9' ->\n H9\n | 'a' ->\n H10\n | 'b' ->\n H11\n | 'c' ->\n H12\n | 'd' ->\n H13\n | 'e' ->\n H14\n | 'f' ->\n H15\n | _ ->\n failwithf \"bad hex digit %c\" c ()\n\n let to_int = function\n | H0 ->\n 0\n | H1 ->\n 1\n | H2 ->\n 2\n | H3 ->\n 3\n | H4 ->\n 4\n | H5 ->\n 5\n | H6 ->\n 6\n | H7 ->\n 7\n | H8 ->\n 8\n | H9 ->\n 9\n | H10 ->\n 10\n | H11 ->\n 11\n | H12 ->\n 12\n | H13 ->\n 13\n | H14 ->\n 14\n | H15 ->\n 15\nend\n\nlet hex_char_of_int_exn = function\n | 0 ->\n '0'\n | 1 ->\n '1'\n | 2 ->\n '2'\n | 3 ->\n '3'\n | 4 ->\n '4'\n | 5 ->\n '5'\n | 6 ->\n '6'\n | 7 ->\n '7'\n | 8 ->\n '8'\n | 9 ->\n '9'\n | 10 ->\n 'a'\n | 11 ->\n 'b'\n | 12 ->\n 'c'\n | 13 ->\n 'd'\n | 14 ->\n 'e'\n | 15 ->\n 'f'\n | d ->\n failwithf \"bad hex digit %d\" d ()\n\nmodule Sequence_be = struct\n type t = Digit.t array\n\n let decode ?(pos = 0) s =\n let n = String.length s - pos in\n Array.init n ~f:(fun i -> Digit.of_char_exn s.[pos + i])\n\n let to_bytes_like ~init (t : t) =\n let n = Array.length t in\n let k = n / 2 in\n assert (n = k + k) ;\n init k ~f:(fun i ->\n Char.of_int_exn\n ((16 * Digit.to_int t.(2 * i)) + Digit.to_int t.((2 * i) + 1)) )\n\n let to_string = to_bytes_like ~init:String.init\n\n let to_bytes = to_bytes_like ~init:Bytes.init\n\n let to_bigstring = to_bytes_like ~init:Bigstring.init\nend\n\nlet decode ?(reverse = false) ?(pos = 0) ~init t =\n let n = String.length t - pos in\n let k = n / 2 in\n assert (n = k + k) ;\n let h j = Digit.(to_int (of_char_exn t.[pos + j])) in\n init k ~f:(fun i ->\n let i = if reverse then k - 1 - i else i in\n Char.of_int_exn ((16 * h (2 * i)) + h ((2 * i) + 1)) )\n\nlet encode ?(reverse = false) t =\n let n = String.length t in\n String.init (2 * n) ~f:(fun i ->\n let c =\n let byte = i / 2 in\n Char.to_int t.[if reverse then n - 1 - byte else byte]\n in\n let c = if i mod 2 = 0 then (* hi *)\n c lsr 4 else (* lo *)\n c in\n hex_char_of_int_exn (c land 15) )\n\nlet%test_unit \"decode\" =\n let t = String.init 100 ~f:(fun _ -> Char.of_int_exn (Random.int 256)) in\n let h = encode t in\n assert (String.equal t (decode ~init:String.init h)) ;\n assert (\n String.equal t\n (decode ~reverse:true ~init:String.init (encode ~reverse:true t)) ) ;\n assert (String.equal t Sequence_be.(to_string (decode h)))\n\n(* TODO: Better deduplicate the hex coding between these two implementations #5711 *)\nmodule Safe = struct\n (** to_hex : {0x0-0xff}* -> [A-F0-9]* *)\n let to_hex (data : string) : string =\n String.to_list data\n |> List.map ~f:(fun c ->\n let charify u4 =\n match u4 with\n | x when x <= 9 && x >= 0 ->\n Char.(of_int_exn @@ (x + to_int '0'))\n | x when x <= 15 && x >= 10 ->\n Char.(of_int_exn @@ (x - 10 + to_int 'A'))\n | _ ->\n failwith \"Unexpected u4 has only 4bits of information\"\n in\n let high = charify @@ ((Char.to_int c land 0xF0) lsr 4) in\n let lo = charify (Char.to_int c land 0x0F) in\n String.of_char_list [ high; lo ] )\n |> String.concat\n\n let%test_unit \"to_hex sane\" =\n let start = \"a\" in\n let hexified = to_hex start in\n let expected = \"61\" in\n if String.equal expected hexified then ()\n else\n failwithf \"start: %s ; hexified : %s ; expected: %s\" start hexified\n expected ()\n\n (** of_hex : [a-fA-F0-9]* -> {0x0-0xff}* option *)\n let of_hex (hex : string) : string option =\n let to_u4 c =\n let open Char in\n assert (is_alphanum c) ;\n match c with\n | _ when is_digit c ->\n to_int c - to_int '0'\n | _ when is_uppercase c ->\n to_int c - to_int 'A' + 10\n | _ (* when is_alpha *) ->\n to_int c - to_int 'a' + 10\n in\n String.to_list hex |> List.chunks_of ~length:2\n |> List.fold_result ~init:[] ~f:(fun acc chunk ->\n match chunk with\n | [ a; b ] when Char.is_alphanum a && Char.is_alphanum b ->\n Or_error.return\n @@ (Char.((to_u4 a lsl 4) lor to_u4 b |> of_int_exn) :: acc)\n | _ ->\n Or_error.error_string \"invalid hex\" )\n |> Or_error.ok\n |> Option.map ~f:(Fn.compose String.of_char_list List.rev)\n\n let%test_unit \"partial isomorphism\" =\n Quickcheck.test ~sexp_of:[%sexp_of: string] ~examples:[ \"\\243\"; \"abc\" ]\n Quickcheck.Generator.(map (list char) ~f:String.of_char_list)\n ~f:(fun s ->\n let hexified = to_hex s in\n let actual = Option.value_exn (of_hex hexified) in\n let expected = s in\n if String.equal actual expected then ()\n else\n failwithf\n !\"expected: %s ; hexified: %s ; actual: %s\"\n expected hexified actual () )\nend\n","(* logger.ml : the fake one *)\n\nopen Core_kernel\n\nlet not_implemented () = failwith \"Not implemented\"\n\nmodule Level = struct\n type t =\n | Internal\n | Spam\n | Trace\n | Debug\n | Info\n | Warn\n | Error\n | Faulty_peer\n | Fatal\n [@@deriving sexp, equal, compare, show { with_path = false }, enumerate]\n\n let of_string _ = not_implemented ()\n\n let to_yojson _ = not_implemented ()\n\n let of_yojson _ = not_implemented ()\nend\n\n(* Core modules extended with Yojson converters *)\nmodule Time = struct\n include Time\n\n let to_yojson _ = not_implemented ()\n\n let of_yojson _ = not_implemented ()\n\n let pp _ _ = not_implemented ()\n\n let set_pretty_to_string _ = not_implemented ()\n\n let pretty_to_string _ = not_implemented ()\nend\n\nmodule Source = struct\n type t = { module_ : string [@key \"module\"]; location : string }\n [@@deriving yojson]\n\n let create ~module_:_ ~location:_ = not_implemented ()\nend\n\nmodule Metadata = struct\n [%%versioned_binable\n module Stable = struct\n module V1 = struct\n type t = Yojson.Safe.t String.Map.t\n\n let to_latest = Fn.id\n\n let to_yojson _ = not_implemented ()\n\n let of_yojson _ = not_implemented ()\n\n include\n Binable.Of_binable_without_uuid\n (Core_kernel.String.Stable.V1)\n (struct\n type nonrec t = t\n\n let to_binable _ = not_implemented ()\n\n let of_binable _ = not_implemented ()\n end)\n end\n end]\n\n [%%define_locally Stable.Latest.(to_yojson, of_yojson)]\n\n let empty = String.Map.empty\nend\n\nlet append_to_global_metadata _ = not_implemented ()\n\nmodule Message = struct\n type t =\n { timestamp : Time.t\n ; level : Level.t\n ; source : Source.t option [@default None]\n ; message : string\n ; metadata : Metadata.t\n ; event_id : Structured_log_events.id option [@default None]\n }\n [@@deriving yojson]\nend\n\nmodule Processor = struct\n module type S = sig\n type t\n\n val process : t -> Message.t -> string option\n end\n\n type t\n\n let create _ _ = not_implemented ()\n\n let raw ?log_level:_ () = not_implemented ()\n\n let raw_structured_log_events _ = not_implemented ()\n\n let pretty ~log_level:_ ~config:_ = not_implemented ()\nend\n\nmodule Transport = struct\n module type S = sig\n type t\n\n val transport : t -> string -> unit\n end\n\n type t\n\n let create _ _ = not_implemented ()\n\n let raw _ = not_implemented ()\n\n let stdout () = not_implemented ()\nend\n\nmodule Consumer_registry = struct\n type id = string\n\n let register ~id:_ ~processor:_ ~transport:_ = not_implemented ()\nend\n\n[%%versioned\nmodule Stable = struct\n module V1 = struct\n type t = { null : bool; metadata : Metadata.Stable.V1.t; id : string }\n\n let to_latest = Fn.id\n end\nend]\n\nlet metadata t = t.metadata\n\nlet create ?metadata:_ ?(id = \"default\") () =\n { null = false; metadata = Metadata.empty; id }\n\nlet null () = { null = true; metadata = Metadata.empty; id = \"default\" }\n\nlet extend t _ = t\n\nlet change_id { null; metadata; id = _ } ~id = { null; metadata; id }\n\nlet raw _ _ = not_implemented ()\n\nlet log _t ~level:_ ~module_:_ ~location:_ ?metadata:_ ?event_id:_ fmt =\n let f _message = () in\n ksprintf f fmt\n\ntype 'a log_function =\n t\n -> module_:string\n -> location:string\n -> ?metadata:(string, Yojson.Safe.t) List.Assoc.t\n -> ?event_id:Structured_log_events.id\n -> ('a, unit, string, unit) format4\n -> 'a\n\nlet trace = log ~level:Level.Trace\n\nlet internal = log ~level:Level.Internal\n\nlet debug = log ~level:Level.Debug\n\nlet info = log ~level:Level.Info\n\nlet warn = log ~level:Level.Warn\n\nlet error = log ~level:Level.Error\n\nlet fatal = log ~level:Level.Fatal\n\nlet faulty_peer_without_punishment = log ~level:Level.Faulty_peer\n\nlet spam = log ~level:Level.Spam ~module_:\"\" ~location:\"\" ?event_id:None\n\n(* deprecated, use Trust_system.record instead *)\nlet faulty_peer = faulty_peer_without_punishment\n\nmodule Structured = struct\n type log_function =\n t\n -> module_:string\n -> location:string\n -> ?metadata:(string, Yojson.Safe.t) List.Assoc.t\n -> Structured_log_events.t\n -> unit\n\n let log _t ~level:_ ~module_:_ ~location:_ ?metadata:_ _event = ()\n\n let trace : log_function = log ~level:Level.Trace\n\n let debug = log ~level:Level.Debug\n\n let info = log ~level:Level.Info\n\n let warn = log ~level:Level.Warn\n\n let error = log ~level:Level.Error\n\n let fatal = log ~level:Level.Fatal\n\n let faulty_peer_without_punishment = log ~level:Level.Faulty_peer\n\n let best_tip_diff = log ~level:Level.Spam ~module_:\"\" ~location:\"\"\nend\n\nmodule Str = Structured\n\nmodule Logger_id = struct\n let invalid = \"fake\"\n\n let mina = invalid\n\n let best_tip_diff = invalid\n\n let rejected_blocks = invalid\n\n let snark_worker = invalid\n\n let oversized_logs = invalid\nend\n","open Core_kernel\n\n(** immutable, serializable statistics derived from allocation data *)\nmodule Allocation_statistics = struct\n (* times represented in ms *)\n type quartiles = { q1 : float; q2 : float; q3 : float; q4 : float }\n [@@deriving yojson]\n\n let make_quartiles n = { q1 = n; q2 = n; q3 = n; q4 = n }\n\n let empty_quartiles = make_quartiles 0.0\n\n type t = { count : int; lifetimes : quartiles } [@@deriving yojson]\n\n let write_metrics { count; lifetimes } object_id =\n let open Mina_metrics in\n let open Mina_metrics.Object_lifetime_statistics in\n let { q1; q2; q3; q4 } = lifetimes in\n let q x = lifetime_quartile_ms ~name:object_id ~quartile:x in\n Gauge.set (live_count ~name:object_id) (Int.to_float count) ;\n Gauge.set (q `Q1) q1 ;\n Gauge.set (q `Q2) q2 ;\n Gauge.set (q `Q3) q3 ;\n Gauge.set (q `Q4) q4\nend\n\n(** mutable data for an object we track allocations of (one exists per object type) *)\nmodule Allocation_data = struct\n (* stops being unique after 2^{30,62} values; perhaps we should use guids instead *)\n type allocation_id = int\n\n let initial_allocation_id = Int.min_value\n\n (* indexed queue data structure would be more effecient here, but keeping this simple for now *)\n type t =\n { allocation_times : (allocation_id * Time.t) Queue.t\n ; mutable next_allocation_id : allocation_id\n }\n\n let create () =\n { allocation_times = Queue.create ()\n ; next_allocation_id = initial_allocation_id\n }\n\n let register_allocation data =\n let id = data.next_allocation_id in\n Queue.enqueue data.allocation_times (id, Time.now ()) ;\n data.next_allocation_id <- data.next_allocation_id + 1 ;\n id\n\n (* currently O(n) wrt queue size *)\n let unregister_allocation data id =\n Queue.filter_inplace data.allocation_times ~f:(fun (id', _) -> id = id')\n\n let compute_statistics { allocation_times; _ } =\n let now = Time.now () in\n let count = Queue.length allocation_times in\n let lifetime_ms_of_time time = Time.Span.to_ms (Time.diff now time) in\n let get_lifetime_ms i =\n lifetime_ms_of_time (snd @@ Queue.get allocation_times i)\n in\n let mean_indices max_len =\n let m = max_len - 1 in\n if m mod 2 = 0 then [ m / 2 ] else [ m / 2; (m / 2) + 1 ]\n in\n let mean offset length =\n let indices =\n mean_indices length |> List.filter ~f:(fun x -> x < count)\n in\n let sum =\n List.fold_left indices ~init:0.0 ~f:(fun acc i ->\n acc +. get_lifetime_ms (count - 1 - (i + offset)) )\n in\n sum /. Int.to_float (List.length indices)\n in\n let lifetimes =\n match count with\n | 0 ->\n Allocation_statistics.empty_quartiles\n | 1 ->\n Allocation_statistics.make_quartiles (get_lifetime_ms 0)\n | _ ->\n let q1 = mean 0 (count / 2) in\n let q2 = mean 0 count in\n let q3_offset = if count mod 2 = 0 then 0 else 1 in\n let q3 = mean ((count / 2) + q3_offset) (count / 2) in\n let q4 = get_lifetime_ms 0 in\n Allocation_statistics.{ q1; q2; q3; q4 }\n in\n Allocation_statistics.{ count; lifetimes }\n\n let compute_statistics t =\n try compute_statistics t\n with _ ->\n Allocation_statistics.\n { count = 0; lifetimes = Allocation_statistics.make_quartiles 0. }\n\n let%test_module \"Allocation_data unit tests\" =\n ( module struct\n open Allocation_statistics\n\n module Float_compare = Float.Robust_compare.Make (struct\n let robust_comparison_tolerance = 0.04\n end)\n\n type robust_float = float [@@deriving sexp]\n\n let compare_robust_float = Float_compare.robustly_compare\n\n (* time_offsets passed in here should be ordered monotonically (to match real world behavior) *)\n let run_test time_offsets expected_quartiles =\n let now = Time.now () in\n (* ids do not need to be unique in this test *)\n let data =\n { allocation_times =\n Queue.of_list\n @@ List.map (List.rev time_offsets) ~f:(fun offset ->\n (0, Time.sub now (Time.Span.of_ms offset)) )\n ; next_allocation_id = 0\n }\n in\n let stats = compute_statistics data in\n [%test_eq: int] stats.count (List.length time_offsets) ;\n [%test_eq: robust_float] stats.lifetimes.q1 expected_quartiles.q1 ;\n [%test_eq: robust_float] stats.lifetimes.q2 expected_quartiles.q2 ;\n [%test_eq: robust_float] stats.lifetimes.q3 expected_quartiles.q3 ;\n [%test_eq: robust_float] stats.lifetimes.q4 expected_quartiles.q4\n\n let%test_unit \"quartiles of empty list\" =\n run_test [] { q1 = 0.0; q2 = 0.0; q3 = 0.0; q4 = 0.0 }\n\n let%test_unit \"quartiles of singleton list\" =\n run_test [ 1.0 ] { q1 = 1.0; q2 = 1.0; q3 = 1.0; q4 = 1.0 }\n\n let%test_unit \"quartiles of 2 element list\" =\n run_test [ 1.0; 2.0 ] { q1 = 1.0; q2 = 1.5; q3 = 2.0; q4 = 2.0 }\n\n let%test_unit \"quartiles of 3 element list\" =\n run_test [ 1.0; 2.0; 3.0 ] { q1 = 1.0; q2 = 2.0; q3 = 3.0; q4 = 3.0 }\n\n let%test_unit \"quartiles of even list (> 3)\" =\n run_test\n [ 1.0; 2.0; 3.0; 4.0; 5.0; 6.0 ]\n { q1 = 2.0; q2 = 3.5; q3 = 5.0; q4 = 6.0 }\n\n let%test_unit \"quartiles of odd list with even split (> 3)\" =\n run_test\n [ 1.0; 2.0; 3.0; 4.0; 5.0; 6.0; 7.0 ]\n { q1 = 2.0; q2 = 4.0; q3 = 6.0; q4 = 7.0 }\n\n let%test_unit \"quartiles of odd list with odd split (> 3)\" =\n run_test\n [ 1.0; 2.0; 3.0; 4.0; 5.0; 6.0; 7.0; 8.0; 9.0 ]\n { q1 = 2.5; q2 = 5.0; q3 = 7.5; q4 = 9.0 }\n end )\nend\n\n(** correlation of allocation data and derived statistics *)\nmodule Allocation_info = struct\n type t = { statistics : Allocation_statistics.t; data : Allocation_data.t }\nend\n\nlet table = String.Table.create ()\n\nlet capture object_id =\n let open Allocation_info in\n let info_opt = String.Table.find table object_id in\n let data_opt = Option.map info_opt ~f:(fun { data; _ } -> data) in\n let data =\n Lazy.(\n force\n @@ Option.value_map data_opt\n ~default:(lazy (Allocation_data.create ()))\n ~f:Lazy.return)\n in\n let allocation_id = Allocation_data.register_allocation data in\n let statistics = Allocation_data.compute_statistics data in\n String.Table.set table ~key:object_id ~data:{ data; statistics } ;\n Allocation_statistics.write_metrics statistics object_id ;\n Mina_metrics.(\n Counter.inc_one (Object_lifetime_statistics.allocated_count ~name:object_id)) ;\n allocation_id\n\n(* release is currently O(n), where n = number of active allocations for this object type; this can be improved by implementing indexed queues (with decent random delete computational complexity) in ocaml *)\nlet release ~object_id ~allocation_id =\n let open Allocation_info in\n let info = String.Table.find_exn table object_id in\n Allocation_data.unregister_allocation info.data allocation_id ;\n let statistics = Allocation_data.compute_statistics info.data in\n String.Table.set table ~key:object_id ~data:{ info with statistics } ;\n Allocation_statistics.write_metrics statistics object_id ;\n Mina_metrics.(\n Counter.inc_one (Object_lifetime_statistics.collected_count ~name:object_id))\n\nlet attach_finalizer object_id obj =\n let allocation_id = capture object_id in\n Gc.Expert.add_finalizer_exn obj (fun _ -> release ~object_id ~allocation_id) ;\n obj\n\nlet dump () =\n let open Allocation_info in\n let entries =\n String.Table.to_alist table\n |> List.Assoc.map ~f:(fun { statistics; _ } ->\n Allocation_statistics.to_yojson statistics )\n in\n `Assoc entries\n","open Core_kernel\n\n[%%versioned\nmodule Stable = struct\n module V2 = struct\n type 'a t =\n { accs : ('a * 'a) array\n ; bits : 'a array\n ; ss : 'a array\n ; base : 'a * 'a\n ; n_prev : 'a\n ; n_next : 'a\n }\n [@@deriving sexp, fields, hlist]\n end\nend]\n\nlet map { accs; bits; ss; base; n_prev; n_next } ~f =\n { accs = Array.map accs ~f:(fun (x, y) -> (f x, f y))\n ; bits = Array.map bits ~f\n ; ss = Array.map ss ~f\n ; base = (f (fst base), f (snd base))\n ; n_prev = f n_prev\n ; n_next = f n_next\n }\n\nlet map2 t1 t2 ~f =\n { accs =\n Array.map (Array.zip_exn t1.accs t2.accs) ~f:(fun ((x1, y1), (x2, y2)) ->\n (f x1 x2, f y1 y2) )\n ; bits =\n Array.map (Array.zip_exn t1.bits t2.bits) ~f:(fun (x1, x2) -> f x1 x2)\n ; ss = Array.map (Array.zip_exn t1.ss t2.ss) ~f:(fun (x1, x2) -> f x1 x2)\n ; base = (f (fst t1.base) (fst t2.base), f (snd t1.base) (snd t2.base))\n ; n_prev = f t1.n_prev t2.n_prev\n ; n_next = f t1.n_next t2.n_next\n }\n\nlet fold { accs; bits; ss; base; n_prev; n_next } ~f ~init =\n let t = Array.fold accs ~init ~f:(fun acc (x, y) -> f [ x; y ] acc) in\n let t = Array.fold bits ~init:t ~f:(fun acc x -> f [ x ] acc) in\n let t = Array.fold ss ~init:t ~f:(fun acc x -> f [ x ] acc) in\n let t = f [ fst base; snd base ] t in\n let t = f [ n_prev ] t in\n let t = f [ n_next ] t in\n t\n","open Core_kernel\n\n[%%versioned\nmodule Stable = struct\n module V2 = struct\n type 'f t = 'f Kimchi_types.scalar_challenge = { inner : 'f }\n [@@deriving sexp, compare, equal, yojson, hash]\n end\nend]\n\nlet create t = { inner = t }\n\nlet typ f =\n let there { inner = x } = x in\n let back x = create x in\n Snarky_backendless.Typ.(transport_var (transport f ~there ~back) ~there ~back)\n\nlet map { inner = x } ~f = create (f x)\n","open Intf\nopen Core_kernel\n\nmodule type Input_intf = sig\n module BaseField : sig\n type t\n end\n\n module ScalarField : sig\n type t\n end\n\n module Affine : sig\n type t = BaseField.t Kimchi_types.or_infinity\n end\n\n type t\n\n val to_affine : t -> Affine.t\n\n val of_affine_coordinates : BaseField.t -> BaseField.t -> t\n\n val add : t -> t -> t\n\n val double : t -> t\n\n val scale : t -> ScalarField.t -> t\n\n val sub : t -> t -> t\n\n val negate : t -> t\n\n val random : unit -> t\n\n val one : unit -> t\nend\n\nmodule type Field_intf = sig\n module Stable : sig\n module Latest : sig\n type t [@@deriving bin_io, equal, sexp, compare, yojson, hash]\n end\n end\n\n type t = Stable.Latest.t\n\n val ( + ) : t -> t -> t\n\n val ( * ) : t -> t -> t\n\n val one : t\n\n val square : t -> t\n\n val is_square : t -> bool\n\n val sqrt : t -> t\n\n val random : unit -> t\nend\n\nmodule Make\n (BaseField : Field_intf) (ScalarField : sig\n type t\n end) (Params : sig\n val a : BaseField.t\n\n val b : BaseField.t\n end)\n (C : Input_intf\n with module BaseField := BaseField\n and module ScalarField := ScalarField) =\nstruct\n include (C : module type of C with type t = C.t with module Affine := C.Affine)\n\n module Base_field = BaseField\n\n let one = one ()\n\n (* TODO: wouldn't be easier if Input_intf exposed a `zero`? *)\n let zero = sub one one\n\n let y_squared x =\n let open BaseField in\n Params.b + (x * (Params.a + square x))\n\n module Affine = struct\n module Backend = struct\n include C.Affine\n\n let zero () = Kimchi_types.Infinity\n\n let create x y = Kimchi_types.Finite (x, y)\n end\n\n module Stable = struct\n module V1 = struct\n module T = struct\n type t = BaseField.Stable.Latest.t * BaseField.Stable.Latest.t\n [@@deriving equal, bin_io, sexp, compare, yojson, hash]\n end\n\n (* asserts the versioned-ness of V1\n to do this properly, we'd move the Stable module outside the functor\n *)\n let __versioned__ = ()\n\n include T\n\n exception Invalid_curve_point of t\n\n include\n Binable.Of_binable\n (T)\n (struct\n let on_curve (x, y) =\n BaseField.Stable.Latest.equal (y_squared x) (BaseField.square y)\n\n type t = T.t\n\n let to_binable = Fn.id\n\n let of_binable t =\n if not (on_curve t) then raise (Invalid_curve_point t) ;\n t\n end)\n end\n\n module Latest = V1\n end\n\n let%test \"cannot deserialize invalid points\" =\n (* y^2 = x^3 + a x + b\n\n pick c at random\n let (x, y) = (c^2, c^3)\n\n Then the above equation becomes\n c^6 = c^6 + (a c^2 + b)\n\n a c^3 + b is almost certainly nonzero (and for our curves, with a = 0, it always is)\n so this point is almost certainly (and for our curves, always) invalid\n *)\n let invalid =\n let open BaseField in\n let c = random () in\n let c2 = square c in\n (c2, c2 * c)\n in\n match\n Binable.to_string (module Stable.Latest) invalid\n |> Binable.of_string (module Stable.Latest)\n with\n | exception Stable.V1.Invalid_curve_point _ ->\n true\n | _ ->\n false\n\n include Stable.Latest\n\n let to_backend :\n (Base_field.t * Base_field.t) Pickles_types.Or_infinity.t -> Backend.t =\n function\n | Infinity ->\n Infinity\n | Finite (x, y) ->\n Finite (x, y)\n\n let of_backend :\n Backend.t -> (Base_field.t * Base_field.t) Pickles_types.Or_infinity.t =\n function\n | Infinity ->\n Infinity\n | Finite (x, y) ->\n Finite (x, y)\n end\n\n let to_affine_or_infinity = C.to_affine\n\n let to_affine_exn t =\n match C.to_affine t with\n | Infinity ->\n failwith \"to_affine_exn: Got identity\"\n | Finite (x, y) ->\n (x, y)\n\n let of_affine (x, y) = C.of_affine_coordinates x y\n\n include\n Binable.Of_binable\n (Affine)\n (struct\n type nonrec t = t\n\n let to_binable = to_affine_exn\n\n let of_binable = of_affine\n end)\n\n let ( + ) = add\n\n let ( * ) s t = scale t s\n\n let find_y x =\n let open BaseField in\n let y2 = y_squared x in\n if is_square y2 then Some (sqrt y2) else None\n\n let point_near_x (x : BaseField.t) =\n let rec go x = function\n | Some y ->\n of_affine (x, y)\n | None ->\n let x' = BaseField.(one + x) in\n go x' (find_y x')\n in\n go x (find_y x)\nend\n","open Core_kernel\nopen Async_kernel\nopen Pickles_types\n\nlet tuple15_to_vec\n (w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, w10, w11, w12, w13, w14) =\n Vector.[ w0; w1; w2; w3; w4; w5; w6; w7; w8; w9; w10; w11; w12; w13; w14 ]\n\nlet tuple15_of_vec\n Vector.[ w0; w1; w2; w3; w4; w5; w6; w7; w8; w9; w10; w11; w12; w13; w14 ] =\n (w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, w10, w11, w12, w13, w14)\n\nlet tuple6_to_vec (w0, w1, w2, w3, w4, w5) = Vector.[ w0; w1; w2; w3; w4; w5 ]\n\nlet tuple6_of_vec Vector.[ w0; w1; w2; w3; w4; w5 ] = (w0, w1, w2, w3, w4, w5)\n\nmodule type Stable_v1 = sig\n module Stable : sig\n module V1 : sig\n type t [@@deriving version, bin_io, sexp, compare, yojson, hash, equal]\n end\n\n module Latest = V1\n end\n\n type t = Stable.V1.t [@@deriving sexp, compare, yojson]\nend\n\nmodule type Inputs_intf = sig\n open Intf\n\n val id : string\n\n module Scalar_field : sig\n include Stable_v1\n\n val one : t\n\n module Vector : Snarky_intf.Vector.S with type elt = t\n end\n\n module Base_field : sig\n type t\n end\n\n module Curve : sig\n module Affine : sig\n include Stable_v1 with type Stable.V1.t = Base_field.t * Base_field.t\n\n module Backend : sig\n type t = Base_field.t Kimchi_types.or_infinity\n end\n\n val of_backend :\n Backend.t -> (Base_field.t * Base_field.t) Pickles_types.Or_infinity.t\n\n val to_backend :\n (Base_field.t * Base_field.t) Pickles_types.Or_infinity.t -> Backend.t\n end\n end\n\n module Poly_comm : sig\n type t = Base_field.t Poly_comm.t\n\n module Backend : sig\n type t = Curve.Affine.Backend.t Kimchi_types.poly_comm\n end\n\n val of_backend_with_degree_bound : Backend.t -> t\n\n val of_backend_without_degree_bound : Backend.t -> t\n\n val to_backend : t -> Backend.t\n end\n\n module Opening_proof_backend : sig\n type t = (Curve.Affine.Backend.t, Scalar_field.t) Kimchi_types.opening_proof\n end\n\n module Evaluations_backend : sig\n type t = Scalar_field.t Kimchi_types.proof_evaluations\n end\n\n module Index : sig\n type t\n end\n\n module Verifier_index : sig\n type t\n end\n\n module Backend : sig\n type t = (Curve.Affine.Backend.t, Scalar_field.t) Kimchi_types.prover_proof\n\n val create :\n Index.t\n -> Scalar_field.Vector.t\n -> Scalar_field.Vector.t\n -> Scalar_field.t array\n -> Curve.Affine.Backend.t array\n -> t\n\n val create_async :\n Index.t\n -> Scalar_field.Vector.t\n -> Scalar_field.Vector.t\n -> Scalar_field.t array\n -> Curve.Affine.Backend.t array\n -> t Promise.t\n\n val create_and_verify_async :\n Index.t\n -> Scalar_field.Vector.t\n -> Scalar_field.Vector.t\n -> Scalar_field.t array\n -> Curve.Affine.Backend.t array\n -> t Promise.t\n\n val verify : Verifier_index.t -> t -> bool\n\n val batch_verify : Verifier_index.t array -> t array -> bool Promise.t\n end\nend\n\nmodule Challenge_polynomial = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type ('g, 'fq) t = { challenges : 'fq array; commitment : 'g }\n [@@deriving version, bin_io, sexp, compare, yojson]\n\n let to_latest = Fn.id\n end\n end]\nend\n\nmodule Make (Inputs : Inputs_intf) = struct\n open Inputs\n module Backend = Backend\n module Fq = Scalar_field\n module G = Curve\n\n module Challenge_polynomial = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t =\n ( G.Affine.Stable.V1.t\n , Fq.Stable.V1.t )\n Challenge_polynomial.Stable.V1.t\n [@@deriving sexp, compare, yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n type ('g, 'fq) t_ = ('g, 'fq) Challenge_polynomial.t =\n { challenges : 'fq array; commitment : 'g }\n end\n\n type message = Challenge_polynomial.t list\n\n let hash_fold_array f s x = hash_fold_list f s (Array.to_list x)\n\n [%%versioned\n module Stable = struct\n module V2 = struct\n module T = struct\n type t =\n ( G.Affine.Stable.V1.t\n , Fq.Stable.V1.t\n , Fq.Stable.V1.t array )\n Pickles_types.Plonk_types.Proof.Stable.V2.t\n [@@deriving compare, sexp, yojson, hash, equal]\n\n let id = \"plong_dlog_proof_\" ^ Inputs.id\n\n type 'a creator =\n messages:G.Affine.t Pickles_types.Plonk_types.Messages.Stable.V2.t\n -> openings:\n ( G.Affine.t\n , Fq.t\n , Fq.t array )\n Pickles_types.Plonk_types.Openings.Stable.V2.t\n -> 'a\n\n let map_creator c ~f ~messages ~openings = f (c ~messages ~openings)\n\n let create ~messages ~openings =\n let open Pickles_types.Plonk_types.Proof in\n { messages; openings }\n end\n\n include T\n\n include (\n Allocation_functor.Make.Full\n (T) :\n Allocation_functor.Intf.Output.Full_intf\n with type t := t\n and type 'a creator := 'a creator )\n\n let to_latest = Fn.id\n end\n end]\n\n include (\n Stable.Latest :\n sig\n type t [@@deriving compare, sexp, yojson, hash, equal, bin_io]\n end\n with type t := t )\n\n [%%define_locally Stable.Latest.(create)]\n\n let g t f = G.Affine.of_backend (f t)\n\n let fq_array_to_vec arr =\n let vec = Fq.Vector.create () in\n Array.iter arr ~f:(fun fe -> Fq.Vector.emplace_back vec fe) ;\n vec\n\n (** Note that this function will panic if any of the points are points at infinity *)\n let opening_proof_of_backend_exn (t : Opening_proof_backend.t) =\n let g (x : G.Affine.Backend.t) : G.Affine.t =\n G.Affine.of_backend x |> Pickles_types.Or_infinity.finite_exn\n in\n let gpair ((g1, g2) : G.Affine.Backend.t * G.Affine.Backend.t) :\n G.Affine.t * G.Affine.t =\n (g g1, g g2)\n in\n { Pickles_types.Plonk_types.Openings.Bulletproof.lr =\n Array.map ~f:gpair t.lr\n ; z_1 = t.z1\n ; z_2 = t.z2\n ; delta = g t.delta\n ; challenge_polynomial_commitment = g t.sg\n }\n\n let eval_of_backend\n ({ w\n ; coefficients\n ; z\n ; s\n ; generic_selector\n ; poseidon_selector\n ; complete_add_selector\n ; mul_selector\n ; emul_selector\n ; endomul_scalar_selector\n ; range_check0_selector\n ; range_check1_selector\n ; foreign_field_add_selector\n ; foreign_field_mul_selector\n ; xor_selector\n ; rot_selector\n ; lookup_aggregation\n ; lookup_table\n ; lookup_sorted\n ; runtime_lookup_table\n ; runtime_lookup_table_selector\n ; xor_lookup_selector\n ; lookup_gate_lookup_selector\n ; range_check_lookup_selector\n ; foreign_field_mul_lookup_selector\n } :\n Evaluations_backend.t ) : _ Pickles_types.Plonk_types.Evals.t =\n { w = tuple15_to_vec w\n ; coefficients = tuple15_to_vec coefficients\n ; z\n ; s = tuple6_to_vec s\n ; generic_selector\n ; poseidon_selector\n ; complete_add_selector\n ; mul_selector\n ; emul_selector\n ; endomul_scalar_selector\n ; range_check0_selector\n ; range_check1_selector\n ; foreign_field_add_selector\n ; foreign_field_mul_selector\n ; xor_selector\n ; rot_selector\n ; lookup_aggregation\n ; lookup_table\n ; lookup_sorted =\n Vector.init Nat.N5.n ~f:(fun i ->\n Option.try_with_join (fun () -> lookup_sorted.(i)) )\n ; runtime_lookup_table\n ; runtime_lookup_table_selector\n ; xor_lookup_selector\n ; lookup_gate_lookup_selector\n ; range_check_lookup_selector\n ; foreign_field_mul_lookup_selector\n }\n\n let of_backend (t : Backend.t) : t =\n let proof = opening_proof_of_backend_exn t.proof in\n let evals =\n let evals_to_tuple\n ({ zeta; zeta_omega } : _ Kimchi_types.point_evaluations) =\n (zeta, zeta_omega)\n in\n Plonk_types.Evals.map ~f:evals_to_tuple (eval_of_backend t.evals)\n in\n let wo x : Inputs.Curve.Affine.t array =\n match Poly_comm.of_backend_without_degree_bound x with\n | `Without_degree_bound gs ->\n gs\n | _ ->\n assert false\n in\n let w_comm =\n tuple15_to_vec t.commitments.w_comm |> Pickles_types.Vector.map ~f:wo\n in\n create\n ~messages:\n { w_comm\n ; z_comm = wo t.commitments.z_comm\n ; t_comm = wo t.commitments.t_comm\n ; lookup =\n Option.map t.commitments.lookup\n ~f:(fun l : _ Pickles_types.Plonk_types.Messages.Lookup.t ->\n { sorted = Array.map ~f:wo l.sorted\n ; aggreg = wo l.aggreg\n ; runtime = Option.map ~f:wo l.runtime\n } )\n }\n ~openings:{ proof; evals; ft_eval1 = t.ft_eval1 }\n\n let eval_to_backend\n { Pickles_types.Plonk_types.Evals.w\n ; coefficients\n ; z\n ; s\n ; generic_selector\n ; poseidon_selector\n ; complete_add_selector\n ; mul_selector\n ; emul_selector\n ; endomul_scalar_selector\n ; range_check0_selector\n ; range_check1_selector\n ; foreign_field_add_selector\n ; foreign_field_mul_selector\n ; xor_selector\n ; rot_selector\n ; lookup_aggregation\n ; lookup_table\n ; lookup_sorted\n ; runtime_lookup_table\n ; runtime_lookup_table_selector\n ; xor_lookup_selector\n ; lookup_gate_lookup_selector\n ; range_check_lookup_selector\n ; foreign_field_mul_lookup_selector\n } : Evaluations_backend.t =\n { w = tuple15_of_vec w\n ; coefficients = tuple15_of_vec coefficients\n ; z\n ; s = tuple6_of_vec s\n ; generic_selector\n ; poseidon_selector\n ; complete_add_selector\n ; mul_selector\n ; emul_selector\n ; endomul_scalar_selector\n ; range_check0_selector\n ; range_check1_selector\n ; foreign_field_add_selector\n ; foreign_field_mul_selector\n ; xor_selector\n ; rot_selector\n ; lookup_aggregation\n ; lookup_table\n ; lookup_sorted = Vector.to_array lookup_sorted\n ; runtime_lookup_table\n ; runtime_lookup_table_selector\n ; xor_lookup_selector\n ; lookup_gate_lookup_selector\n ; range_check_lookup_selector\n ; foreign_field_mul_lookup_selector\n }\n\n let vec_to_array (type t elt)\n (module V : Snarky_intf.Vector.S with type t = t and type elt = elt)\n (v : t) =\n Array.init (V.length v) ~f:(V.get v)\n\n let to_backend' (chal_polys : Challenge_polynomial.t list) primary_input\n ({ messages = { w_comm; z_comm; t_comm; lookup }\n ; openings =\n { proof = { lr; z_1; z_2; delta; challenge_polynomial_commitment }\n ; evals\n ; ft_eval1\n }\n } :\n t ) : Backend.t =\n let g x = G.Affine.to_backend (Pickles_types.Or_infinity.Finite x) in\n let pcwo t = Poly_comm.to_backend (`Without_degree_bound t) in\n let lr = Array.map lr ~f:(fun (x, y) -> (g x, g y)) in\n let evals_of_tuple (zeta, zeta_omega) : _ Kimchi_types.point_evaluations =\n { zeta; zeta_omega }\n in\n { commitments =\n { w_comm = tuple15_of_vec (Pickles_types.Vector.map ~f:pcwo w_comm)\n ; z_comm = pcwo z_comm\n ; t_comm = pcwo t_comm\n ; lookup =\n Option.map lookup ~f:(fun t : _ Kimchi_types.lookup_commitments ->\n { sorted = Array.map ~f:pcwo t.sorted\n ; aggreg = pcwo t.aggreg\n ; runtime = Option.map ~f:pcwo t.runtime\n } )\n }\n ; proof =\n { lr\n ; delta = g delta\n ; z1 = z_1\n ; z2 = z_2\n ; sg = g challenge_polynomial_commitment\n }\n ; evals = eval_to_backend (Plonk_types.Evals.map ~f:evals_of_tuple evals)\n ; ft_eval1\n ; public = primary_input\n ; prev_challenges =\n Array.of_list_map chal_polys\n ~f:(fun { Challenge_polynomial.commitment = x, y; challenges } ->\n { Kimchi_types.chals = challenges\n ; comm =\n { Kimchi_types.shifted = None\n ; unshifted = [| Kimchi_types.Finite (x, y) |]\n }\n } )\n }\n\n let to_backend chal_polys primary_input t =\n to_backend' chal_polys (List.to_array primary_input) t\n\n let create ?message pk ~primary ~auxiliary =\n let chal_polys =\n match (message : message option) with Some s -> s | None -> []\n in\n let challenges =\n List.map chal_polys ~f:(fun { Challenge_polynomial.challenges; _ } ->\n challenges )\n |> Array.concat\n in\n let commitments =\n Array.of_list_map chal_polys\n ~f:(fun { Challenge_polynomial.commitment; _ } ->\n G.Affine.to_backend (Finite commitment) )\n in\n let res = Backend.create pk primary auxiliary challenges commitments in\n of_backend res\n\n let create_async ?message pk ~primary ~auxiliary =\n let chal_polys =\n match (message : message option) with Some s -> s | None -> []\n in\n let challenges =\n List.map chal_polys ~f:(fun { Challenge_polynomial.challenges; _ } ->\n challenges )\n |> Array.concat\n in\n let commitments =\n Array.of_list_map chal_polys\n ~f:(fun { Challenge_polynomial.commitment; _ } ->\n G.Affine.to_backend (Finite commitment) )\n in\n let%map.Promise res =\n Backend.create_async pk primary auxiliary challenges commitments\n in\n of_backend res\n\n let create_and_verify_async ?message pk ~primary ~auxiliary =\n let chal_polys =\n match (message : message option) with Some s -> s | None -> []\n in\n let challenges =\n List.map chal_polys ~f:(fun { Challenge_polynomial.challenges; _ } ->\n challenges )\n |> Array.concat\n in\n let commitments =\n Array.of_list_map chal_polys\n ~f:(fun { Challenge_polynomial.commitment; _ } ->\n G.Affine.to_backend (Finite commitment) )\n in\n let%map.Promise res =\n Backend.create_and_verify_async pk primary auxiliary challenges\n commitments\n in\n of_backend res\n\n let batch_verify' (conv : 'a -> Fq.t array)\n (ts : (Verifier_index.t * t * 'a * message option) list) =\n let logger = Internal_tracing_context_logger.get () in\n [%log internal] \"Batch_verify_backend_convert_inputs\" ;\n let vks_and_v =\n Array.of_list_map ts ~f:(fun (vk, t, xs, m) ->\n let p = to_backend' (Option.value ~default:[] m) (conv xs) t in\n (vk, p) )\n in\n [%log internal] \"Batch_verify_backend_convert_inputs_done\" ;\n [%log internal] \"Batch_verify_backend\" ;\n let%map.Promise result =\n Backend.batch_verify\n (Array.map ~f:fst vks_and_v)\n (Array.map ~f:snd vks_and_v)\n in\n [%log internal] \"Batch_verify_backend_done\" ;\n result\n\n let batch_verify = batch_verify' (fun xs -> List.to_array xs)\n\n let verify ?message t vk xs : bool =\n Backend.verify vk\n (to_backend'\n (Option.value ~default:[] message)\n (vec_to_array (module Scalar_field.Vector) xs)\n t )\nend\n","open Core_kernel\n\nmodule type Bindings = sig\n type t\n\n val num_limbs : unit -> int\n\n val bytes_per_limb : unit -> int\n\n val compare : t -> t -> int\n\n val div : t -> t -> t\n\n val test_bit : t -> int -> bool\n\n val print : t -> unit\n\n val to_string : t -> string\n\n val of_numeral : string -> int -> int -> t\n\n val of_decimal_string : string -> t\n\n val to_bytes : t -> Bytes.t\n\n val of_bytes : Bytes.t -> t\nend\n\nmodule type Intf = sig\n type t [@@deriving bin_io, sexp, compare]\n\n include Bindings with type t := t\n\n val num_limbs : int\n\n val bytes_per_limb : int\n\n val length_in_bytes : int\n\n val to_hex : t -> string\n\n val to_hex_string : t -> string\n\n val of_hex_string : ?reverse:bool -> string -> t\n\n val of_numeral : string -> base:int -> t\nend\n\nmodule Make\n (B : Bindings) (M : sig\n val length_in_bytes : int\n end) : Intf with type t = B.t = struct\n include B\n\n let num_limbs = num_limbs ()\n\n let bytes_per_limb = bytes_per_limb ()\n\n let length_in_bytes = num_limbs * bytes_per_limb\n\n let to_hex t =\n let data = to_bytes t in\n String.uppercase (Hex.encode ~reverse:true (Bytes.to_string data))\n\n let to_hex_string t = \"0x\" ^ to_hex t\n\n let sexp_of_t t = to_hex_string t |> Sexp.of_string\n\n let of_hex_string ?(reverse = true) s =\n assert (Char.equal s.[0] '0' && Char.equal s.[1] 'x') ;\n let s = String.drop_prefix s 2 in\n Option.try_with (fun () -> Hex.decode ~init:Bytes.init ~reverse s)\n |> Option.value_exn ~here:[%here]\n |> of_bytes\n\n let%test_unit \"hex test\" =\n let bytes =\n String.init length_in_bytes ~f:(fun _ -> Char.of_int_exn (Random.int 255))\n in\n let h = \"0x\" ^ Hex.encode bytes in\n [%test_eq: string] h (String.lowercase (to_hex_string (of_hex_string h)))\n\n let t_of_sexp s = of_hex_string (String.t_of_sexp s)\n\n include Bin_prot.Utils.Of_minimal (struct\n type nonrec t = t\n\n (* increment if serialization changes *)\n let version = 1\n\n let bin_shape_t =\n Bin_prot.Shape.basetype\n (Bin_prot.Shape.Uuid.of_string\n (sprintf \"kimchi_backend_bigint_%d_V%d\" M.length_in_bytes version) )\n []\n\n let __bin_read_t__ _buf ~pos_ref _vint =\n Bin_prot.Common.raise_variant_wrong_type \"Bigint.t\" !pos_ref\n\n let bin_size_t _ = length_in_bytes\n\n let bin_write_t buf ~pos t =\n let bytes = to_bytes t in\n let len = length_in_bytes in\n Bigstring.From_bytes.blit ~src:bytes ~src_pos:0 ~len:length_in_bytes\n ~dst:buf ~dst_pos:pos ;\n pos + len\n\n let bin_read_t buf ~pos_ref =\n let remaining_bytes = Bigstring.length buf - !pos_ref in\n let len = length_in_bytes in\n if remaining_bytes < len then\n failwithf \"Bigint.bin_read_t: Expected %d bytes, got %d\"\n M.length_in_bytes remaining_bytes () ;\n let bytes = Bigstring.To_bytes.sub ~pos:!pos_ref ~len buf in\n pos_ref := len + !pos_ref ;\n of_bytes bytes\n end)\n\n let of_numeral s ~base = of_numeral s (String.length s) base\nend\n","open Core_kernel\nmodule H_list = Snarky_backendless.H_list\n\n[%%versioned\nmodule Stable = struct\n module V2 = struct\n type 'a t =\n { xt : 'a\n ; yt : 'a\n ; xp : 'a\n ; yp : 'a\n ; n_acc : 'a\n ; xr : 'a\n ; yr : 'a\n ; s1 : 'a\n ; s3 : 'a\n ; b1 : 'a\n ; b2 : 'a\n ; b3 : 'a\n ; b4 : 'a\n }\n [@@deriving sexp, fields, hlist]\n end\nend]\n\nlet map { xt; yt; xp; yp; n_acc; xr; yr; s1; s3; b1; b2; b3; b4 } ~f =\n { xt = f xt\n ; yt = f yt\n ; xp = f xp\n ; yp = f yp\n ; n_acc = f n_acc\n ; xr = f xr\n ; yr = f yr\n ; s1 = f s1\n ; s3 = f s3\n ; b1 = f b1\n ; b2 = f b2\n ; b3 = f b3\n ; b4 = f b4\n }\n\nlet map2 t1 t2 ~f =\n { xt = f t1.xt t2.xt\n ; yt = f t1.yt t2.yt\n ; xp = f t1.xp t2.xp\n ; yp = f t1.yp t2.yp\n ; n_acc = f t1.n_acc t2.n_acc\n ; xr = f t1.xr t2.xr\n ; yr = f t1.yr t2.yr\n ; s1 = f t1.s1 t2.s1\n ; s3 = f t1.s3 t2.s3\n ; b1 = f t1.b1 t2.b1\n ; b2 = f t1.b2 t2.b2\n ; b3 = f t1.b3 t2.b3\n ; b4 = f t1.b4 t2.b4\n }\n","open Core_kernel\n\n[%%versioned\nmodule Stable = struct\n module V2 = struct\n type 'a t =\n { n0 : 'a\n ; n8 : 'a\n ; a0 : 'a\n ; b0 : 'a\n ; a8 : 'a\n ; b8 : 'a\n ; x0 : 'a\n ; x1 : 'a\n ; x2 : 'a\n ; x3 : 'a\n ; x4 : 'a\n ; x5 : 'a\n ; x6 : 'a\n ; x7 : 'a\n }\n [@@deriving sexp, fields, hlist]\n end\nend]\n\nlet map { n0; n8; a0; b0; a8; b8; x0; x1; x2; x3; x4; x5; x6; x7 } ~f =\n { n0 = f n0\n ; n8 = f n8\n ; a0 = f a0\n ; b0 = f b0\n ; a8 = f a8\n ; b8 = f b8\n ; x0 = f x0\n ; x1 = f x1\n ; x2 = f x2\n ; x3 = f x3\n ; x4 = f x4\n ; x5 = f x5\n ; x6 = f x6\n ; x7 = f x7\n }\n\nlet map2 t1 t2 ~f =\n { n0 = f t1.n0 t2.n0\n ; n8 = f t1.n8 t2.n8\n ; a0 = f t1.a0 t2.a0\n ; b0 = f t1.b0 t2.b0\n ; a8 = f t1.a8 t2.a8\n ; b8 = f t1.b8 t2.b8\n ; x0 = f t1.x0 t2.x0\n ; x1 = f t1.x1 t2.x1\n ; x2 = f t1.x2 t2.x2\n ; x3 = f t1.x3 t2.x3\n ; x4 = f t1.x4 t2.x4\n ; x5 = f t1.x5 t2.x5\n ; x6 = f t1.x6 t2.x6\n ; x7 = f t1.x7 t2.x7\n }\n","open Intf\nopen Core_kernel\nmodule Bignum_bigint = Snarky_backendless.Backend_extended.Bignum_bigint\n\nmodule type Input_intf = sig\n type t\n\n module Bigint : Bigint.Intf\n\n val size : unit -> Bigint.t\n\n val size_in_bits : unit -> int\n\n val to_bigint : t -> Bigint.t\n\n val of_bigint : Bigint.t -> t\n\n val of_int : int -> t\n\n val domain_generator : int -> t\n\n val add : t -> t -> t\n\n val sub : t -> t -> t\n\n val mul : t -> t -> t\n\n val div : t -> t -> t\n\n val inv : t -> t option\n\n val negate : t -> t\n\n val square : t -> t\n\n val sqrt : t -> t option\n\n val is_square : t -> bool\n\n val equal : t -> t -> bool\n\n val print : t -> unit\n\n val to_string : t -> string\n\n val of_string : string -> t\n\n val random : unit -> t\n\n val rng : int -> t\n\n val two_adic_root_of_unity : unit -> t\n\n val mut_add : t -> t -> unit\n\n val mut_mul : t -> t -> unit\n\n val mut_square : t -> unit\n\n val mut_sub : t -> t -> unit\n\n val copy : t -> t -> unit\n\n val to_bytes : t -> bytes\n\n val of_bytes : bytes -> t\n\n val domain_generator : int -> t\n\n module Vector : Snarky_intf.Vector.S with type elt = t\nend\n\nmodule type S = sig\n type t [@@deriving sexp, compare, yojson, bin_io, hash]\n\n include Input_intf with type t := t\n\n val size : Bigint.t\n\n val domain_generator : log2_size:int -> t\n\n val one : t\n\n val zero : t\n\n val inv : t -> t\n\n val sqrt : t -> t\n\n val size_in_bits : int\n\n val to_bits : t -> bool list\n\n val of_bits : bool list -> t\n\n val ( + ) : t -> t -> t\n\n val ( - ) : t -> t -> t\n\n val ( * ) : t -> t -> t\n\n val ( / ) : t -> t -> t\n\n module Mutable : sig\n val add : t -> other:t -> unit\n\n val mul : t -> other:t -> unit\n\n val square : t -> unit\n\n val sub : t -> other:t -> unit\n\n val copy : over:t -> t -> unit\n end\n\n val ( += ) : t -> t -> unit\n\n val ( *= ) : t -> t -> unit\n\n val ( -= ) : t -> t -> unit\nend\n\nmodule type S_with_version = sig\n [%%versioned:\n module Stable : sig\n [@@@no_toplevel_latest_type]\n\n module V1 : sig\n [@@@with_all_version_tags]\n\n type t [@@deriving version, sexp, bin_io, compare, yojson, hash, equal]\n end\n end]\n\n include S with type t = Stable.Latest.t\nend\n\nmodule Make (F : Input_intf) :\n S_with_version\n with type Stable.V1.t = F.t\n and module Bigint = F.Bigint\n and module Vector = F.Vector = struct\n include F\n\n let size = size ()\n\n let size_in_bits = size_in_bits ()\n\n [%%versioned_binable\n module Stable = struct\n module V1 = struct\n [@@@with_all_version_tags]\n\n type t = (F.t[@version_asserted]) [@@deriving version]\n\n let to_latest = Fn.id\n\n include\n Binable.Of_binable\n (Bigint)\n (struct\n type nonrec t = t\n\n let to_binable = to_bigint\n\n let of_binable = of_bigint\n end)\n\n include\n Sexpable.Of_sexpable\n (Bigint)\n (struct\n type nonrec t = t\n\n let to_sexpable = to_bigint\n\n let of_sexpable = of_bigint\n end)\n\n let to_bignum_bigint n =\n let rec go i two_to_the_i acc =\n if Int.equal i size_in_bits then acc\n else\n let acc' =\n if Bigint.test_bit n i then Bignum_bigint.(acc + two_to_the_i)\n else acc\n in\n go (i + 1) Bignum_bigint.(two_to_the_i + two_to_the_i) acc'\n in\n go 0 Bignum_bigint.one Bignum_bigint.zero\n\n let hash_fold_t s x =\n Bignum_bigint.hash_fold_t s (to_bignum_bigint (to_bigint x))\n\n let hash = Hash.of_fold hash_fold_t\n\n let compare t1 t2 = Bigint.compare (to_bigint t1) (to_bigint t2)\n\n let equal = equal\n\n let to_yojson t : Yojson.Safe.t =\n `String (Bigint.to_hex_string (to_bigint t))\n\n let of_yojson j =\n match j with\n | `String h ->\n Ok (of_bigint (Bigint.of_hex_string h))\n | _ ->\n Error \"expected hex string\"\n end\n end]\n\n include (\n Stable.Latest : module type of Stable.Latest with type t := Stable.Latest.t )\n\n let domain_generator ~log2_size = domain_generator log2_size\n\n let one = of_int 1\n\n let zero = of_int 0\n\n (* TODO: Improve snarky interface so these aren't necessary.. *)\n let inv x = Option.value (inv x) ~default:zero\n\n let sqrt x = Option.value (sqrt x) ~default:zero\n\n let to_bits t =\n (* Avoids allocation *)\n let n = F.to_bigint t in\n List.init size_in_bits ~f:(Bigint.test_bit n)\n\n let of_bits bs =\n List.fold (List.rev bs) ~init:zero ~f:(fun acc b ->\n let acc = add acc acc in\n if b then add acc one else acc )\n\n let%test_unit \"sexp round trip\" =\n let t = random () in\n assert (equal t (t_of_sexp (sexp_of_t t)))\n\n let%test_unit \"bin_io round trip\" =\n let t = random () in\n [%test_eq: Stable.Latest.t] t\n (Binable.of_string\n (module Stable.Latest)\n (Binable.to_string (module Stable.Latest) t) )\n\n let ( + ) = add\n\n let ( - ) = sub\n\n let ( * ) = mul\n\n let ( / ) = div\n\n module Mutable = struct\n let add t ~other = mut_add t other\n\n let mul t ~other = mut_mul t other\n\n let square = mut_square\n\n let sub t ~other = mut_sub t other\n\n let copy ~over t = copy over t\n end\n\n let op f t other = f t ~other\n\n let ( += ) = op Mutable.add\n\n let ( *= ) = op Mutable.mul\n\n let ( -= ) = op Mutable.sub\n\n let%test \"of_bits to_bits\" =\n let x = random () in\n equal x (of_bits (to_bits x))\n\n let%test_unit \"to_bits of_bits\" =\n Quickcheck.test\n (Quickcheck.Generator.list_with_length\n Int.(size_in_bits - 1)\n Bool.quickcheck_generator )\n ~f:(fun bs ->\n [%test_eq: bool list] (bs @ [ false ]) (to_bits (of_bits bs)) )\nend\n","(* TODO: remove these openings *)\nopen Sponge\nopen Unsigned.Size_t\n\n(* TODO: open Core here instead of opening it multiple times below *)\n\nmodule Kimchi_gate_type = struct\n (* Alias to allow deriving sexp *)\n type t = Kimchi_types.gate_type =\n | Zero\n | Generic\n | Poseidon\n | CompleteAdd\n | VarBaseMul\n | EndoMul\n | EndoMulScalar\n | Lookup\n | CairoClaim\n | CairoInstruction\n | CairoFlags\n | CairoTransition\n | RangeCheck0\n | RangeCheck1\n | ForeignFieldAdd\n | ForeignFieldMul\n | Xor16\n | Rot64\n [@@deriving sexp]\nend\n\n(** A gate interface, parameterized by a field. *)\nmodule type Gate_vector_intf = sig\n open Unsigned\n\n type field\n\n type t\n\n val create : unit -> t\n\n val add : t -> field Kimchi_types.circuit_gate -> unit\n\n val get : t -> int -> field Kimchi_types.circuit_gate\n\n val len : t -> int\n\n val digest : int -> t -> bytes\n\n val to_json : int -> t -> string\nend\n\n(** A row indexing in a constraint system. *)\nmodule Row = struct\n open Core_kernel\n\n (** Either a public input row,\n or a non-public input row that starts at index 0.\n *)\n type t = Public_input of int | After_public_input of int\n [@@deriving hash, sexp, compare]\n\n let to_absolute ~public_input_size = function\n | Public_input i ->\n i\n | After_public_input i ->\n (* the first i rows are public-input rows *)\n i + public_input_size\nend\n\n(* TODO: rename module Position to Permutation/Wiring? *)\n\n(** A position represents the position of a cell in the constraint system. *)\nmodule Position = struct\n open Core_kernel\n\n (** A position is a row and a column. *)\n type 'row t = { row : 'row; col : int } [@@deriving hash, sexp, compare]\n\n (** Generates a full row of positions that each points to itself. *)\n let create_cols (row : 'row) : _ t array =\n Array.init Constants.permutation_cols ~f:(fun i -> { row; col = i })\n\n (** Given a number of columns,\n append enough column wires to get an entire row.\n The wire appended will simply point to themselves,\n so as to not take part in the permutation argument.\n *)\n let append_cols (row : 'row) (cols : _ t array) : _ t array =\n let padding_offset = Array.length cols in\n assert (padding_offset <= Constants.permutation_cols) ;\n let padding_len = Constants.permutation_cols - padding_offset in\n let padding =\n Array.init padding_len ~f:(fun i -> { row; col = i + padding_offset })\n in\n Array.append cols padding\n\n (** Converts an array of [Constants.columns] to [Constants.permutation_cols].\n This is useful to truncate arrays of cells to the ones that only matter for the permutation argument.\n *)\n let cols_to_perms cols = Array.slice cols 0 Constants.permutation_cols\n\n (** Converts a [Position.t] into the Rust-compatible type [Kimchi_types.wire].\n *)\n let to_rust_wire { row; col } : Kimchi_types.wire = { row; col }\nend\n\n(** A gate. *)\nmodule Gate_spec = struct\n open Core_kernel\n\n (* TODO: split kind/coeffs from row/wired_to *)\n\n (** A gate/row/constraint consists of a type (kind), a row, the other cells its columns/cells are connected to (wired_to), and the selector polynomial associated with the gate. *)\n type ('row, 'f) t =\n { kind : Kimchi_gate_type.t\n ; wired_to : 'row Position.t array\n ; coeffs : 'f array\n }\n [@@deriving sexp_of]\n\n (** Applies a function [f] to the [row] of [t] and all the rows of its [wired_to]. *)\n let map_rows (t : (_, _) t) ~f : (_, _) t =\n (* { wire with row = f row } *)\n let wired_to =\n Array.map\n ~f:(fun (pos : _ Position.t) -> { pos with row = f pos.row })\n t.wired_to\n in\n { t with wired_to }\n\n (* TODO: just send the array to Rust directly *)\n let to_rust_gate { kind; wired_to; coeffs } : _ Kimchi_types.circuit_gate =\n let typ = kind in\n let wired_to = Array.map ~f:Position.to_rust_wire wired_to in\n let wires =\n ( wired_to.(0)\n , wired_to.(1)\n , wired_to.(2)\n , wired_to.(3)\n , wired_to.(4)\n , wired_to.(5)\n , wired_to.(6) )\n in\n { typ; wires; coeffs }\nend\n\n(** The PLONK constraints. *)\nmodule Plonk_constraint = struct\n open Core_kernel\n\n (** A PLONK constraint (or gate) can be [Basic], [Poseidon], [EC_add_complete], [EC_scale], [EC_endoscale], [EC_endoscalar], [RangeCheck0], [RangeCheck1], [Xor] *)\n module T = struct\n type ('v, 'f) t =\n | Basic of { l : 'f * 'v; r : 'f * 'v; o : 'f * 'v; m : 'f; c : 'f }\n (** the Poseidon state is an array of states (and states are arrays of size 3). *)\n | Poseidon of { state : 'v array array }\n | EC_add_complete of\n { p1 : 'v * 'v\n ; p2 : 'v * 'v\n ; p3 : 'v * 'v\n ; inf : 'v\n ; same_x : 'v\n ; slope : 'v\n ; inf_z : 'v\n ; x21_inv : 'v\n }\n | EC_scale of { state : 'v Scale_round.t array }\n | EC_endoscale of\n { state : 'v Endoscale_round.t array; xs : 'v; ys : 'v; n_acc : 'v }\n | EC_endoscalar of { state : 'v Endoscale_scalar_round.t array }\n | Lookup of\n { w0 : 'v; w1 : 'v; w2 : 'v; w3 : 'v; w4 : 'v; w5 : 'v; w6 : 'v }\n | RangeCheck0 of\n { v0 : 'v (* Value to constrain to 88-bits *)\n ; v0p0 : 'v (* MSBs *)\n ; v0p1 : 'v (* vpX are 12-bit plookup chunks *)\n ; v0p2 : 'v\n ; v0p3 : 'v\n ; v0p4 : 'v\n ; v0p5 : 'v\n ; v0c0 : 'v (* vcX are 2-bit crumbs *)\n ; v0c1 : 'v\n ; v0c2 : 'v\n ; v0c3 : 'v\n ; v0c4 : 'v\n ; v0c5 : 'v\n ; v0c6 : 'v\n ; v0c7 : 'v (* LSBs *)\n ; (* Coefficients *)\n compact : 'f\n (* Limbs mode coefficient: 0 (standard 3-limb) or 1 (compact 2-limb) *)\n }\n | RangeCheck1 of\n { (* Current row *)\n v2 : 'v (* Value to constrain to 88-bits *)\n ; v12 : 'v (* Optional value used in compact 2-limb mode *)\n ; v2c0 : 'v (* MSBs, 2-bit crumb *)\n ; v2p0 : 'v (* vpX are 12-bit plookup chunks *)\n ; v2p1 : 'v\n ; v2p2 : 'v\n ; v2p3 : 'v\n ; v2c1 : 'v (* vcX are 2-bit crumbs *)\n ; v2c2 : 'v\n ; v2c3 : 'v\n ; v2c4 : 'v\n ; v2c5 : 'v\n ; v2c6 : 'v\n ; v2c7 : 'v\n ; v2c8 : 'v (* LSBs *)\n ; (* Next row *) v2c9 : 'v\n ; v2c10 : 'v\n ; v2c11 : 'v\n ; v0p0 : 'v\n ; v0p1 : 'v\n ; v1p0 : 'v\n ; v1p1 : 'v\n ; v2c12 : 'v\n ; v2c13 : 'v\n ; v2c14 : 'v\n ; v2c15 : 'v\n ; v2c16 : 'v\n ; v2c17 : 'v\n ; v2c18 : 'v\n ; v2c19 : 'v\n }\n | Xor of\n { in1 : 'v\n ; in2 : 'v\n ; out : 'v\n ; in1_0 : 'v\n ; in1_1 : 'v\n ; in1_2 : 'v\n ; in1_3 : 'v\n ; in2_0 : 'v\n ; in2_1 : 'v\n ; in2_2 : 'v\n ; in2_3 : 'v\n ; out_0 : 'v\n ; out_1 : 'v\n ; out_2 : 'v\n ; out_3 : 'v\n }\n | ForeignFieldAdd of\n { left_input_lo : 'v\n ; left_input_mi : 'v\n ; left_input_hi : 'v\n ; right_input_lo : 'v\n ; right_input_mi : 'v\n ; right_input_hi : 'v\n ; field_overflow : 'v\n ; carry : 'v\n ; (* Coefficients *) foreign_field_modulus0 : 'f\n ; foreign_field_modulus1 : 'f\n ; foreign_field_modulus2 : 'f\n ; sign : 'f\n }\n | ForeignFieldMul of\n { left_input0 : 'v\n ; left_input1 : 'v\n ; left_input2 : 'v\n ; right_input0 : 'v\n ; right_input1 : 'v\n ; right_input2 : 'v\n ; remainder01 : 'v\n ; remainder2 : 'v\n ; quotient0 : 'v\n ; quotient1 : 'v\n ; quotient2 : 'v\n ; quotient_hi_bound : 'v\n ; product1_lo : 'v\n ; product1_hi_0 : 'v\n ; product1_hi_1 : 'v\n ; carry0 : 'v\n ; carry1_0 : 'v\n ; carry1_12 : 'v\n ; carry1_24 : 'v\n ; carry1_36 : 'v\n ; carry1_48 : 'v\n ; carry1_60 : 'v\n ; carry1_72 : 'v\n ; carry1_84 : 'v\n ; carry1_86 : 'v\n ; carry1_88 : 'v\n ; carry1_90 : 'v\n ; (* Coefficients *) foreign_field_modulus2 : 'f\n ; neg_foreign_field_modulus0 : 'f\n ; neg_foreign_field_modulus1 : 'f\n ; neg_foreign_field_modulus2 : 'f\n }\n | Rot64 of\n { (* Current row *)\n word : 'v\n ; rotated : 'v\n ; excess : 'v\n ; bound_limb0 : 'v\n ; bound_limb1 : 'v\n ; bound_limb2 : 'v\n ; bound_limb3 : 'v\n ; bound_crumb0 : 'v\n ; bound_crumb1 : 'v\n ; bound_crumb2 : 'v\n ; bound_crumb3 : 'v\n ; bound_crumb4 : 'v\n ; bound_crumb5 : 'v\n ; bound_crumb6 : 'v\n ; bound_crumb7 : 'v\n ; (* Coefficients *) two_to_rot : 'f (* Rotation scalar 2^rot *)\n }\n | Raw of\n { kind : Kimchi_gate_type.t; values : 'v array; coeffs : 'f array }\n [@@deriving sexp]\n\n (** map t *)\n let map (type a b f) (t : (a, f) t) ~(f : a -> b) =\n let fp (x, y) = (f x, f y) in\n match t with\n | Basic { l; r; o; m; c } ->\n let p (x, y) = (x, f y) in\n Basic { l = p l; r = p r; o = p o; m; c }\n | Poseidon { state } ->\n Poseidon { state = Array.map ~f:(fun x -> Array.map ~f x) state }\n | EC_add_complete { p1; p2; p3; inf; same_x; slope; inf_z; x21_inv } ->\n EC_add_complete\n { p1 = fp p1\n ; p2 = fp p2\n ; p3 = fp p3\n ; inf = f inf\n ; same_x = f same_x\n ; slope = f slope\n ; inf_z = f inf_z\n ; x21_inv = f x21_inv\n }\n | EC_scale { state } ->\n EC_scale\n { state = Array.map ~f:(fun x -> Scale_round.map ~f x) state }\n | EC_endoscale { state; xs; ys; n_acc } ->\n EC_endoscale\n { state = Array.map ~f:(fun x -> Endoscale_round.map ~f x) state\n ; xs = f xs\n ; ys = f ys\n ; n_acc = f n_acc\n }\n | EC_endoscalar { state } ->\n EC_endoscalar\n { state =\n Array.map ~f:(fun x -> Endoscale_scalar_round.map ~f x) state\n }\n | Lookup { w0; w1; w2; w3; w4; w5; w6 } ->\n Lookup\n { w0 = f w0\n ; w1 = f w1\n ; w2 = f w2\n ; w3 = f w3\n ; w4 = f w4\n ; w5 = f w5\n ; w6 = f w6\n }\n | RangeCheck0\n { v0\n ; v0p0\n ; v0p1\n ; v0p2\n ; v0p3\n ; v0p4\n ; v0p5\n ; v0c0\n ; v0c1\n ; v0c2\n ; v0c3\n ; v0c4\n ; v0c5\n ; v0c6\n ; v0c7\n ; compact\n } ->\n RangeCheck0\n { v0 = f v0\n ; v0p0 = f v0p0\n ; v0p1 = f v0p1\n ; v0p2 = f v0p2\n ; v0p3 = f v0p3\n ; v0p4 = f v0p4\n ; v0p5 = f v0p5\n ; v0c0 = f v0c0\n ; v0c1 = f v0c1\n ; v0c2 = f v0c2\n ; v0c3 = f v0c3\n ; v0c4 = f v0c4\n ; v0c5 = f v0c5\n ; v0c6 = f v0c6\n ; v0c7 = f v0c7\n ; compact\n }\n | RangeCheck1\n { (* Current row *) v2\n ; v12\n ; v2c0\n ; v2p0\n ; v2p1\n ; v2p2\n ; v2p3\n ; v2c1\n ; v2c2\n ; v2c3\n ; v2c4\n ; v2c5\n ; v2c6\n ; v2c7\n ; v2c8\n ; (* Next row *) v2c9\n ; v2c10\n ; v2c11\n ; v0p0\n ; v0p1\n ; v1p0\n ; v1p1\n ; v2c12\n ; v2c13\n ; v2c14\n ; v2c15\n ; v2c16\n ; v2c17\n ; v2c18\n ; v2c19\n } ->\n RangeCheck1\n { (* Current row *) v2 = f v2\n ; v12 = f v12\n ; v2c0 = f v2c0\n ; v2p0 = f v2p0\n ; v2p1 = f v2p1\n ; v2p2 = f v2p2\n ; v2p3 = f v2p3\n ; v2c1 = f v2c1\n ; v2c2 = f v2c2\n ; v2c3 = f v2c3\n ; v2c4 = f v2c4\n ; v2c5 = f v2c5\n ; v2c6 = f v2c6\n ; v2c7 = f v2c7\n ; v2c8 = f v2c8\n ; (* Next row *) v2c9 = f v2c9\n ; v2c10 = f v2c10\n ; v2c11 = f v2c11\n ; v0p0 = f v0p0\n ; v0p1 = f v0p1\n ; v1p0 = f v1p0\n ; v1p1 = f v1p1\n ; v2c12 = f v2c12\n ; v2c13 = f v2c13\n ; v2c14 = f v2c14\n ; v2c15 = f v2c15\n ; v2c16 = f v2c16\n ; v2c17 = f v2c17\n ; v2c18 = f v2c18\n ; v2c19 = f v2c19\n }\n | Xor\n { in1\n ; in2\n ; out\n ; in1_0\n ; in1_1\n ; in1_2\n ; in1_3\n ; in2_0\n ; in2_1\n ; in2_2\n ; in2_3\n ; out_0\n ; out_1\n ; out_2\n ; out_3\n } ->\n Xor\n { in1 = f in1\n ; in2 = f in2\n ; out = f out\n ; in1_0 = f in1_0\n ; in1_1 = f in1_1\n ; in1_2 = f in1_2\n ; in1_3 = f in1_3\n ; in2_0 = f in2_0\n ; in2_1 = f in2_1\n ; in2_2 = f in2_2\n ; in2_3 = f in2_3\n ; out_0 = f out_0\n ; out_1 = f out_1\n ; out_2 = f out_2\n ; out_3 = f out_3\n }\n | ForeignFieldAdd\n { left_input_lo\n ; left_input_mi\n ; left_input_hi\n ; right_input_lo\n ; right_input_mi\n ; right_input_hi\n ; field_overflow\n ; carry\n ; (* Coefficients *) foreign_field_modulus0\n ; foreign_field_modulus1\n ; foreign_field_modulus2\n ; sign\n } ->\n ForeignFieldAdd\n { left_input_lo = f left_input_lo\n ; left_input_mi = f left_input_mi\n ; left_input_hi = f left_input_hi\n ; right_input_lo = f right_input_lo\n ; right_input_mi = f right_input_mi\n ; right_input_hi = f right_input_hi\n ; field_overflow = f field_overflow\n ; carry = f carry\n ; (* Coefficients *) foreign_field_modulus0\n ; foreign_field_modulus1\n ; foreign_field_modulus2\n ; sign\n }\n | ForeignFieldMul\n { left_input0\n ; left_input1\n ; left_input2\n ; right_input0\n ; right_input1\n ; right_input2\n ; remainder01\n ; remainder2\n ; quotient0\n ; quotient1\n ; quotient2\n ; quotient_hi_bound\n ; product1_lo\n ; product1_hi_0\n ; product1_hi_1\n ; carry0\n ; carry1_0\n ; carry1_12\n ; carry1_24\n ; carry1_36\n ; carry1_48\n ; carry1_60\n ; carry1_72\n ; carry1_84\n ; carry1_86\n ; carry1_88\n ; carry1_90\n ; (* Coefficients *) foreign_field_modulus2\n ; neg_foreign_field_modulus0\n ; neg_foreign_field_modulus1\n ; neg_foreign_field_modulus2\n } ->\n ForeignFieldMul\n { left_input0 = f left_input0\n ; left_input1 = f left_input1\n ; left_input2 = f left_input2\n ; right_input0 = f right_input0\n ; right_input1 = f right_input1\n ; right_input2 = f right_input2\n ; remainder01 = f remainder01\n ; remainder2 = f remainder2\n ; quotient0 = f quotient0\n ; quotient1 = f quotient1\n ; quotient2 = f quotient2\n ; quotient_hi_bound = f quotient_hi_bound\n ; product1_lo = f product1_lo\n ; product1_hi_0 = f product1_hi_0\n ; product1_hi_1 = f product1_hi_1\n ; carry0 = f carry0\n ; carry1_0 = f carry1_0\n ; carry1_12 = f carry1_12\n ; carry1_24 = f carry1_24\n ; carry1_36 = f carry1_36\n ; carry1_48 = f carry1_48\n ; carry1_60 = f carry1_60\n ; carry1_72 = f carry1_72\n ; carry1_84 = f carry1_84\n ; carry1_86 = f carry1_86\n ; carry1_88 = f carry1_88\n ; carry1_90 = f carry1_90\n ; (* Coefficients *) foreign_field_modulus2\n ; neg_foreign_field_modulus0\n ; neg_foreign_field_modulus1\n ; neg_foreign_field_modulus2\n }\n | Rot64\n { (* Current row *) word\n ; rotated\n ; excess\n ; bound_limb0\n ; bound_limb1\n ; bound_limb2\n ; bound_limb3\n ; bound_crumb0\n ; bound_crumb1\n ; bound_crumb2\n ; bound_crumb3\n ; bound_crumb4\n ; bound_crumb5\n ; bound_crumb6\n ; bound_crumb7\n ; (* Coefficients *) two_to_rot\n } ->\n Rot64\n { word = f word\n ; rotated = f rotated\n ; excess = f excess\n ; bound_limb0 = f bound_limb0\n ; bound_limb1 = f bound_limb1\n ; bound_limb2 = f bound_limb2\n ; bound_limb3 = f bound_limb3\n ; bound_crumb0 = f bound_crumb0\n ; bound_crumb1 = f bound_crumb1\n ; bound_crumb2 = f bound_crumb2\n ; bound_crumb3 = f bound_crumb3\n ; bound_crumb4 = f bound_crumb4\n ; bound_crumb5 = f bound_crumb5\n ; bound_crumb6 = f bound_crumb6\n ; bound_crumb7 = f bound_crumb7\n ; (* Coefficients *) two_to_rot\n }\n | Raw { kind; values; coeffs } ->\n Raw { kind; values = Array.map ~f values; coeffs }\n\n (** [eval (module F) get_variable gate] checks that [gate]'s polynomial is\n satisfied by the assignments given by [get_variable].\n Warning: currently only implemented for the [Basic] gate.\n *)\n let eval (type v f)\n (module F : Snarky_backendless.Field_intf.S with type t = f)\n (eval_one : v -> f) (t : (v, f) t) =\n match t with\n (* cl * vl + cr * vr + co * vo + m * vl*vr + c = 0 *)\n | Basic { l = cl, vl; r = cr, vr; o = co, vo; m; c } ->\n let vl = eval_one vl in\n let vr = eval_one vr in\n let vo = eval_one vo in\n let open F in\n let res =\n List.reduce_exn ~f:add\n [ mul cl vl; mul cr vr; mul co vo; mul m (mul vl vr); c ]\n in\n if not (equal zero res) then (\n eprintf\n !\"%{sexp:t} * %{sexp:t}\\n\\\n + %{sexp:t} * %{sexp:t}\\n\\\n + %{sexp:t} * %{sexp:t}\\n\\\n + %{sexp:t} * %{sexp:t}\\n\\\n + %{sexp:t}\\n\\\n = %{sexp:t}%!\"\n cl vl cr vr co vo m (mul vl vr) c res ;\n false )\n else true\n | _ ->\n true\n end\n\n include T\n\n (* Adds our constraint enum to the list of constraints handled by Snarky. *)\n include Snarky_backendless.Constraint.Add_kind (T)\nend\n\nmodule Internal_var = Core_kernel.Unique_id.Int ()\n\nmodule V = struct\n open Core_kernel\n\n module T = struct\n (** Variables linking uses of the same data between different gates.\n\n Every internal variable is computable from a finite list of external\n variables and internal variables.\n Currently, in fact, every internal variable is a linear combination of\n external variables and previously generated internal variables.\n *)\n type t =\n | External of int\n (** An external variable (generated by snarky, via [exists]). *)\n | Internal of Internal_var.t\n (** An internal variable is generated to hold an intermediate value\n (e.g., in reducing linear combinations to single PLONK positions).\n *)\n [@@deriving compare, hash, sexp]\n end\n\n include T\n include Comparable.Make (T)\n include Hashable.Make (T)\nend\n\n(** Keeps track of a circuit (which is a list of gates)\n while it is being written.\n *)\ntype ('f, 'rust_gates) circuit =\n | Unfinalized_rev of (unit, 'f) Gate_spec.t list\n (** A circuit still being written. *)\n | Compiled of Core_kernel.Md5.t * 'rust_gates\n (** Once finalized, a circuit is represented as a digest\n and a list of gates that corresponds to the circuit.\n *)\n\n(** The constraint system. *)\ntype ('f, 'rust_gates) t =\n { (* Map of cells that share the same value (enforced by to the permutation). *)\n equivalence_classes : Row.t Position.t list V.Table.t\n ; (* How to compute each internal variable (as a linear combination of other variables). *)\n internal_vars : (('f * V.t) list * 'f option) Internal_var.Table.t\n ; (* The variables that hold each witness value for each row, in reverse order. *)\n mutable rows_rev : V.t option array list\n ; (* A circuit is described by a series of gates.\n A gate is finalized once [finalize_and_get_gates] is called.\n The finalized tag contains the digest of the circuit.\n *)\n mutable gates : ('f, 'rust_gates) circuit\n ; (* The row to use the next time we add a constraint. *)\n mutable next_row : int\n ; (* The size of the public input (which fills the first rows of our constraint system. *)\n public_input_size : int Core_kernel.Set_once.t\n ; (* The number of previous recursion challenges. *)\n prev_challenges : int Core_kernel.Set_once.t\n ; (* Whatever is not public input. *)\n mutable auxiliary_input_size : int\n ; (* Queue (of size 1) of generic gate. *)\n mutable pending_generic_gate :\n (V.t option * V.t option * V.t option * 'f array) option\n ; (* V.t's corresponding to constant values. We reuse them so we don't need to\n use a fresh generic constraint each time to create a constant.\n *)\n cached_constants : ('f, V.t) Core_kernel.Hashtbl.t\n (* The [equivalence_classes] field keeps track of the positions which must be\n enforced to be equivalent due to the fact that they correspond to the same V.t value.\n I.e., positions that are different usages of the same [V.t].\n\n We use a union-find data structure to track equalities that a constraint system wants\n enforced *between* [V.t] values. Then, at the end, for all [V.t]s that have been unioned\n together, we combine their equivalence classes in the [equivalence_classes] table into\n a single equivalence class, so that the permutation argument enforces these desired equalities\n as well.\n *)\n ; union_finds : V.t Core_kernel.Union_find.t V.Table.t\n }\n\nlet get_public_input_size sys = sys.public_input_size\n\nlet get_rows_len sys = List.length sys.rows_rev\n\nlet get_prev_challenges sys = sys.prev_challenges\n\nlet set_prev_challenges sys challenges =\n Core_kernel.Set_once.set_exn sys.prev_challenges [%here] challenges\n\n(* TODO: shouldn't that Make create something bounded by a signature? As we know what a back end should be? Check where this is used *)\n\n(* TODO: glossary of terms in this file (terms, reducing, feeding) + module doc *)\n\n(* TODO: rename Fp to F or Field *)\n\n(** ? *)\nmodule Make\n (Fp : Field.S)\n (* We create a type for gate vector, instead of using `Gate.t list`. If we did, we would have to convert it to a `Gate.t array` to pass it across the FFI boundary, where then it gets converted to a `Vec`; it's more efficient to just create the `Vec` directly.\n *)\n (Gates : Gate_vector_intf with type field := Fp.t)\n (Params : sig\n val params : Fp.t Params.t\n end) : sig\n open Core_kernel\n\n type nonrec t = (Fp.t, Gates.t) t\n\n val create : unit -> t\n\n val get_public_input_size : t -> int Set_once.t\n\n val get_primary_input_size : t -> int\n\n val set_primary_input_size : t -> int -> unit\n\n val get_auxiliary_input_size : t -> int\n\n val set_auxiliary_input_size : t -> int -> unit\n\n val get_prev_challenges : t -> int option\n\n val set_prev_challenges : t -> int -> unit\n\n val get_rows_len : t -> int\n\n val next_row : t -> int\n\n val add_constraint :\n ?label:string\n -> t\n -> ( Fp.t Snarky_backendless.Cvar.t\n , Fp.t )\n Snarky_backendless.Constraint.basic\n -> unit\n\n val compute_witness : t -> (int -> Fp.t) -> Fp.t array array\n\n val finalize : t -> unit\n\n val finalize_and_get_gates : t -> Gates.t\n\n val num_constraints : t -> int\n\n val digest : t -> Md5.t\n\n val to_json : t -> string\nend = struct\n open Core_kernel\n open Pickles_types\n\n type nonrec t = (Fp.t, Gates.t) t\n\n (** Converts the set of permutations (equivalence_classes) to\n a hash table that maps each position to the next one.\n For example, if one of the equivalence class is [pos1, pos3, pos7],\n the function will return a hashtable that maps pos1 to pos3,\n pos3 to pos7, and pos7 to pos1.\n *)\n let equivalence_classes_to_hashtbl sys =\n let module Relative_position = struct\n module T = struct\n type t = Row.t Position.t [@@deriving hash, sexp, compare]\n end\n\n include T\n include Core_kernel.Hashable.Make (T)\n end in\n let equivalence_classes = V.Table.create () in\n Hashtbl.iteri sys.equivalence_classes ~f:(fun ~key ~data ->\n let u = Hashtbl.find_exn sys.union_finds key in\n Hashtbl.update equivalence_classes (Union_find.get u) ~f:(function\n | None ->\n Relative_position.Hash_set.of_list data\n | Some ps ->\n List.iter ~f:(Hash_set.add ps) data ;\n ps ) ) ;\n let res = Relative_position.Table.create () in\n Hashtbl.iter equivalence_classes ~f:(fun ps ->\n let rotate_left = function [] -> [] | x :: xs -> xs @ [ x ] in\n let ps =\n Hash_set.to_list ps |> List.sort ~compare:[%compare: Row.t Position.t]\n in\n List.iter2_exn ps (rotate_left ps) ~f:(fun input output ->\n Hashtbl.add_exn res ~key:input ~data:output ) ) ;\n res\n\n (** Compute the witness, given the constraint system `sys`\n and a function that converts the indexed secret inputs to their concrete values.\n *)\n let compute_witness (sys : t) (external_values : int -> Fp.t) :\n Fp.t array array =\n let internal_values : Fp.t Internal_var.Table.t =\n Internal_var.Table.create ()\n in\n let public_input_size = Set_once.get_exn sys.public_input_size [%here] in\n let num_rows = public_input_size + sys.next_row in\n let res =\n Array.init Constants.columns ~f:(fun _ ->\n Array.create ~len:num_rows Fp.zero )\n in\n (* Public input *)\n for i = 0 to public_input_size - 1 do\n res.(0).(i) <- external_values i\n done ;\n let find t k =\n match Hashtbl.find t k with\n | None ->\n failwithf !\"Could not find %{sexp:Internal_var.t}\\n%!\" k ()\n | Some x ->\n x\n in\n (* Compute an internal variable associated value. *)\n let compute ((lc, c) : (Fp.t * V.t) list * Fp.t option) =\n List.fold lc ~init:(Option.value c ~default:Fp.zero) ~f:(fun acc (s, x) ->\n let x =\n match x with\n | External x ->\n external_values x\n | Internal x ->\n find internal_values x\n in\n Fp.(acc + (s * x)) )\n in\n (* Update the witness table with the value of the variables from each row. *)\n List.iteri (List.rev sys.rows_rev) ~f:(fun i_after_input cols ->\n let row_idx = i_after_input + public_input_size in\n Array.iteri cols ~f:(fun col_idx var ->\n match var with\n | None ->\n ()\n | Some (External var) ->\n res.(col_idx).(row_idx) <- external_values var\n | Some (Internal var) ->\n let lc = find sys.internal_vars var in\n let value = compute lc in\n res.(col_idx).(row_idx) <- value ;\n Hashtbl.set internal_values ~key:var ~data:value ) ) ;\n (* Return the witness. *)\n res\n\n let union_find sys v =\n Hashtbl.find_or_add sys.union_finds v ~default:(fun () ->\n Union_find.create v )\n\n (** Creates an internal variable and assigns it the value lc and constant. *)\n let create_internal ?constant sys lc : V.t =\n let v = Internal_var.create () in\n ignore (union_find sys (Internal v) : _ Union_find.t) ;\n Hashtbl.add_exn sys.internal_vars ~key:v ~data:(lc, constant) ;\n V.Internal v\n\n (* Initializes a constraint system. *)\n let create () : t =\n { public_input_size = Set_once.create ()\n ; prev_challenges = Set_once.create ()\n ; internal_vars = Internal_var.Table.create ()\n ; gates = Unfinalized_rev [] (* Gates.create () *)\n ; rows_rev = []\n ; next_row = 0\n ; equivalence_classes = V.Table.create ()\n ; auxiliary_input_size = 0\n ; pending_generic_gate = None\n ; cached_constants = Hashtbl.create (module Fp)\n ; union_finds = V.Table.create ()\n }\n\n (** Returns the number of auxiliary inputs. *)\n let get_auxiliary_input_size t = t.auxiliary_input_size\n\n (** Returns the number of public inputs. *)\n let get_primary_input_size t = Set_once.get_exn t.public_input_size [%here]\n\n (** Returns the number of previous challenges. *)\n let get_prev_challenges t = Set_once.get t.prev_challenges\n\n (* Non-public part of the witness. *)\n let set_auxiliary_input_size t x = t.auxiliary_input_size <- x\n\n (** Sets the number of public-input. It must and can only be called once. *)\n let set_primary_input_size (sys : t) num_pub_inputs =\n Set_once.set_exn sys.public_input_size [%here] num_pub_inputs\n\n (** Sets the number of previous challenges. It must and can only be called once. *)\n let set_prev_challenges (sys : t) num_prev_challenges =\n Set_once.set_exn sys.prev_challenges [%here] num_prev_challenges\n\n let get_public_input_size (sys : t) = get_public_input_size sys\n\n let get_rows_len (sys : t) = get_rows_len sys\n\n let next_row (sys : t) = sys.next_row\n\n (** Adds {row; col} to the system's wiring under a specific key.\n A key is an external or internal variable.\n The row must be given relative to the start of the circuit\n (so at the start of the public-input rows). *)\n let wire' sys key row (col : int) =\n ignore (union_find sys key : V.t Union_find.t) ;\n V.Table.add_multi sys.equivalence_classes ~key ~data:{ row; col }\n\n (* TODO: rename to wire_abs and wire_rel? or wire_public and wire_after_public? or force a single use function that takes a Row.t? *)\n\n (** Same as wire', except that the row must be given relatively to the end of the public-input rows. *)\n let wire sys key row col = wire' sys key (Row.After_public_input row) col\n\n (** Adds a row/gate/constraint to a constraint system `sys`. *)\n let add_row sys (vars : V.t option array) kind coeffs =\n match sys.gates with\n | Compiled _ ->\n failwith \"add_row called on finalized constraint system\"\n | Unfinalized_rev gates ->\n (* As we're adding a row, we're adding new cells.\n If these cells (the first 7) contain variables,\n make sure that they are wired\n *)\n let num_vars = min Constants.permutation_cols (Array.length vars) in\n let vars_for_perm = Array.slice vars 0 num_vars in\n Array.iteri vars_for_perm ~f:(fun col x ->\n Option.iter x ~f:(fun x -> wire sys x sys.next_row col) ) ;\n (* Add to gates. *)\n let open Position in\n sys.gates <- Unfinalized_rev ({ kind; wired_to = [||]; coeffs } :: gates) ;\n (* Increment row. *)\n sys.next_row <- sys.next_row + 1 ;\n (* Add to row. *)\n sys.rows_rev <- vars :: sys.rows_rev\n\n (** Adds zero-knowledgeness to the gates/rows,\n and convert into Rust type [Gates.t].\n This can only be called once.\n *)\n let rec finalize_and_get_gates sys =\n match sys with\n | { gates = Compiled (_, gates); _ } ->\n gates\n | { pending_generic_gate = Some (l, r, o, coeffs); _ } ->\n (* Finalize any pending generic constraint first. *)\n add_row sys [| l; r; o |] Generic coeffs ;\n sys.pending_generic_gate <- None ;\n finalize_and_get_gates sys\n | { gates = Unfinalized_rev gates_rev; _ } ->\n let rust_gates = Gates.create () in\n\n (* Create rows for public input. *)\n let public_input_size =\n Set_once.get_exn sys.public_input_size [%here]\n in\n let pub_selectors = [| Fp.one; Fp.zero; Fp.zero; Fp.zero; Fp.zero |] in\n let pub_input_gate_specs_rev = ref [] in\n for row = 0 to public_input_size - 1 do\n let public_var = V.External row in\n wire' sys public_var (Row.Public_input row) 0 ;\n pub_input_gate_specs_rev :=\n { Gate_spec.kind = Generic\n ; wired_to = [||]\n ; coeffs = pub_selectors\n }\n :: !pub_input_gate_specs_rev\n done ;\n\n (* Construct permutation hashmap. *)\n let pos_map = equivalence_classes_to_hashtbl sys in\n let permutation (pos : Row.t Position.t) : Row.t Position.t =\n Option.value (Hashtbl.find pos_map pos) ~default:pos\n in\n\n let update_gate_with_permutation_info (row : Row.t)\n (gate : (unit, _) Gate_spec.t) : (Row.t, _) Gate_spec.t =\n { gate with\n wired_to =\n Array.init Constants.permutation_cols ~f:(fun col ->\n permutation { row; col } )\n }\n in\n\n (* Process public gates. *)\n let public_gates = List.rev !pub_input_gate_specs_rev in\n let public_gates =\n List.mapi public_gates ~f:(fun absolute_row gate ->\n update_gate_with_permutation_info (Row.Public_input absolute_row)\n gate )\n in\n\n (* construct all the other gates (except zero-knowledge rows) *)\n let gates = List.rev gates_rev in\n let gates =\n List.mapi gates ~f:(fun relative_row gate ->\n update_gate_with_permutation_info\n (Row.After_public_input relative_row) gate )\n in\n\n (* concatenate and convert to absolute rows *)\n let to_absolute_row =\n Gate_spec.map_rows ~f:(Row.to_absolute ~public_input_size)\n in\n\n (* convert all the gates into our Gates.t Rust vector type *)\n let add_gates gates =\n List.iter gates ~f:(fun g ->\n let g = to_absolute_row g in\n Gates.add rust_gates (Gate_spec.to_rust_gate g) )\n in\n add_gates public_gates ;\n add_gates gates ;\n\n (* compute the circuit's digest *)\n let digest = Gates.digest public_input_size rust_gates in\n let md5_digest = Md5.digest_bytes digest in\n\n (* drop the gates, we don't need them anymore *)\n sys.gates <- Compiled (md5_digest, rust_gates) ;\n\n (* return the gates *)\n rust_gates\n\n (** Calls [finalize_and_get_gates] and ignores the result. *)\n let finalize t = ignore (finalize_and_get_gates t : Gates.t)\n\n let num_constraints sys = finalize_and_get_gates sys |> Gates.len\n\n let to_json (sys : t) : string =\n let gates = finalize_and_get_gates sys in\n let public_input_size = Set_once.get_exn sys.public_input_size [%here] in\n Gates.to_json public_input_size gates\n\n (* Returns a hash of the circuit. *)\n let rec digest (sys : t) =\n match sys.gates with\n | Unfinalized_rev _ ->\n finalize sys ; digest sys\n | Compiled (digest, _) ->\n digest\n\n (** Regroup terms that share the same variable.\n For example, (3, i2) ; (2, i2) can be simplified to (5, i2).\n It assumes that the list of given terms is sorted,\n and that i0 is the smallest one.\n For example, `i0 = 1` and `terms = [(_, 2); (_, 2); (_; 4); ...]`\n\n Returns `(last_scalar, last_variable, terms, terms_length)`\n where terms does not contain the last scalar and last variable observed.\n *)\n let accumulate_terms terms =\n List.fold terms ~init:Int.Map.empty ~f:(fun acc (x, i) ->\n Map.change acc i ~f:(fun y ->\n let res = match y with None -> x | Some y -> Fp.add x y in\n if Fp.(equal zero res) then None else Some res ) )\n\n (** Converts a [Cvar.t] to a `(terms, terms_length, has_constant)`.\n if `has_constant` is set, then terms start with a constant term in the form of (c, 0).\n *)\n let canonicalize x =\n let c, terms =\n Fp.(\n Snarky_backendless.Cvar.to_constant_and_terms ~add ~mul ~zero:(of_int 0)\n ~equal ~one:(of_int 1))\n x\n in\n (* Note: [(c, 0)] represents the field element [c] multiplied by the 0th\n variable, which is held constant as [Field.one].\n *)\n let terms = match c with None -> terms | Some c -> (c, 0) :: terms in\n let has_constant_term = Option.is_some c in\n let terms = accumulate_terms terms in\n let terms_list =\n Map.fold_right ~init:[] terms ~f:(fun ~key ~data acc ->\n (data, key) :: acc )\n in\n Some (terms_list, Map.length terms, has_constant_term)\n\n (** Adds a generic constraint to the constraint system.\n As there are two generic gates per row, we queue\n every other generic gate.\n *)\n let add_generic_constraint ?l ?r ?o coeffs sys : unit =\n match sys.pending_generic_gate with\n (* if the queue of generic gate is empty, queue this *)\n | None ->\n sys.pending_generic_gate <- Some (l, r, o, coeffs)\n (* otherwise empty the queue and create the row *)\n | Some (l2, r2, o2, coeffs2) ->\n let coeffs = Array.append coeffs coeffs2 in\n add_row sys [| l; r; o; l2; r2; o2 |] Generic coeffs ;\n sys.pending_generic_gate <- None\n\n (** Converts a number of scaled additions \\sum s_i * x_i\n to as many constraints as needed,\n creating temporary variables for each new row/constraint,\n and returning the output variable.\n\n For example, [(s1, x1), (s2, x2)] is transformed into:\n - internal_var_1 = s1 * x1 + s2 * x2\n - return (1, internal_var_1)\n\n and [(s1, x1), (s2, x2), (s3, x3)] is transformed into:\n - internal_var_1 = s1 * x1 + s2 * x2\n - internal_var_2 = 1 * internal_var_1 + s3 * x3\n - return (1, internal_var_2)\n\n It assumes that the list of terms is not empty. *)\n let completely_reduce sys (terms : (Fp.t * int) list) =\n (* just adding constrained variables without values *)\n let rec go = function\n | [] ->\n assert false\n | [ (s, x) ] ->\n (s, V.External x)\n | (ls, lx) :: t ->\n let lx = V.External lx in\n (* TODO: this should be rewritten to be tail-optimized *)\n let rs, rx = go t in\n let s1x1_plus_s2x2 = create_internal sys [ (ls, lx); (rs, rx) ] in\n add_generic_constraint ~l:lx ~r:rx ~o:s1x1_plus_s2x2\n [| ls; rs; Fp.(negate one); Fp.zero; Fp.zero |]\n sys ;\n (Fp.one, s1x1_plus_s2x2)\n in\n go terms\n\n (** Converts a linear combination of variables into a set of constraints.\n It returns the output variable as (1, `Var res),\n unless the output is a constant, in which case it returns (c, `Constant).\n *)\n let reduce_lincom sys (x : Fp.t Snarky_backendless.Cvar.t) =\n let constant, terms =\n Fp.(\n Snarky_backendless.Cvar.to_constant_and_terms ~add ~mul ~zero:(of_int 0)\n ~equal ~one:(of_int 1))\n x\n in\n let terms = accumulate_terms terms in\n let terms_list =\n Map.fold_right ~init:[] terms ~f:(fun ~key ~data acc ->\n (data, key) :: acc )\n in\n match (constant, Map.is_empty terms) with\n | Some c, true ->\n (c, `Constant)\n | None, true ->\n (Fp.zero, `Constant)\n | _ -> (\n match terms_list with\n | [] ->\n assert false\n | [ (ls, lx) ] -> (\n match constant with\n | None ->\n (ls, `Var (V.External lx))\n | Some c ->\n (* res = ls * lx + c *)\n let res =\n create_internal ~constant:c sys [ (ls, External lx) ]\n in\n add_generic_constraint ~l:(External lx) ~o:res\n [| ls; Fp.zero; Fp.(negate one); Fp.zero; c |]\n (* Could be here *)\n sys ;\n (Fp.one, `Var res) )\n | (ls, lx) :: tl ->\n (* reduce the terms, then add the constant *)\n let rs, rx = completely_reduce sys tl in\n let res =\n create_internal ?constant sys [ (ls, External lx); (rs, rx) ]\n in\n (* res = ls * lx + rs * rx + c *)\n add_generic_constraint ~l:(External lx) ~r:rx ~o:res\n [| ls\n ; rs\n ; Fp.(negate one)\n ; Fp.zero\n ; (match constant with Some x -> x | None -> Fp.zero)\n |]\n (* Could be here *)\n sys ;\n (Fp.one, `Var res) )\n\n (** Adds a constraint to the constraint system. *)\n let add_constraint ?label:_ sys\n (constr :\n ( Fp.t Snarky_backendless.Cvar.t\n , Fp.t )\n Snarky_backendless.Constraint.basic ) =\n let red = reduce_lincom sys in\n (* reduce any [Cvar.t] to a single internal variable *)\n let reduce_to_v (x : Fp.t Snarky_backendless.Cvar.t) : V.t =\n match red x with\n | s, `Var x ->\n if Fp.equal s Fp.one then x\n else\n let sx = create_internal sys [ (s, x) ] in\n (* s * x - sx = 0 *)\n add_generic_constraint ~l:x ~o:sx\n [| s; Fp.zero; Fp.(negate one); Fp.zero; Fp.zero |]\n sys ;\n sx\n | s, `Constant -> (\n match Hashtbl.find sys.cached_constants s with\n | Some x ->\n x\n | None ->\n let x = create_internal sys ~constant:s [] in\n add_generic_constraint ~l:x\n [| Fp.one; Fp.zero; Fp.zero; Fp.zero; Fp.negate s |]\n sys ;\n Hashtbl.set sys.cached_constants ~key:s ~data:x ;\n x )\n in\n match constr with\n | Snarky_backendless.Constraint.Square (v1, v2) -> (\n match (red v1, red v2) with\n | (sl, `Var xl), (so, `Var xo) ->\n (* (sl * xl)^2 = so * xo\n sl^2 * xl * xl - so * xo = 0\n *)\n add_generic_constraint ~l:xl ~r:xl ~o:xo\n [| Fp.zero; Fp.zero; Fp.negate so; Fp.(sl * sl); Fp.zero |]\n sys\n | (sl, `Var xl), (so, `Constant) ->\n (* TODO: it's hard to read the array of selector values, name them! *)\n add_generic_constraint ~l:xl ~r:xl\n [| Fp.zero; Fp.zero; Fp.zero; Fp.(sl * sl); Fp.negate so |]\n sys\n | (sl, `Constant), (so, `Var xo) ->\n (* sl^2 = so * xo *)\n add_generic_constraint ~o:xo\n [| Fp.zero; Fp.zero; so; Fp.zero; Fp.negate (Fp.square sl) |]\n sys\n | (sl, `Constant), (so, `Constant) ->\n assert (Fp.(equal (square sl) so)) )\n | Snarky_backendless.Constraint.R1CS (v1, v2, v3) -> (\n match (red v1, red v2, red v3) with\n | (s1, `Var x1), (s2, `Var x2), (s3, `Var x3) ->\n (* s1 x1 * s2 x2 = s3 x3\n - s1 s2 (x1 x2) + s3 x3 = 0\n *)\n add_generic_constraint ~l:x1 ~r:x2 ~o:x3\n [| Fp.zero; Fp.zero; s3; Fp.(negate s1 * s2); Fp.zero |]\n sys\n | (s1, `Var x1), (s2, `Var x2), (s3, `Constant) ->\n add_generic_constraint ~l:x1 ~r:x2\n [| Fp.zero; Fp.zero; Fp.zero; Fp.(s1 * s2); Fp.negate s3 |]\n sys\n | (s1, `Var x1), (s2, `Constant), (s3, `Var x3) ->\n (* s1 x1 * s2 = s3 x3\n *)\n add_generic_constraint ~l:x1 ~o:x3\n [| Fp.(s1 * s2); Fp.zero; Fp.negate s3; Fp.zero; Fp.zero |]\n sys\n | (s1, `Constant), (s2, `Var x2), (s3, `Var x3) ->\n add_generic_constraint ~r:x2 ~o:x3\n [| Fp.zero; Fp.(s1 * s2); Fp.negate s3; Fp.zero; Fp.zero |]\n sys\n | (s1, `Var x1), (s2, `Constant), (s3, `Constant) ->\n add_generic_constraint ~l:x1\n [| Fp.(s1 * s2); Fp.zero; Fp.zero; Fp.zero; Fp.negate s3 |]\n sys\n | (s1, `Constant), (s2, `Var x2), (s3, `Constant) ->\n add_generic_constraint ~r:x2\n [| Fp.zero; Fp.(s1 * s2); Fp.zero; Fp.zero; Fp.negate s3 |]\n sys\n | (s1, `Constant), (s2, `Constant), (s3, `Var x3) ->\n add_generic_constraint ~o:x3\n [| Fp.zero; Fp.zero; s3; Fp.zero; Fp.(negate s1 * s2) |]\n sys\n | (s1, `Constant), (s2, `Constant), (s3, `Constant) ->\n assert (Fp.(equal s3 Fp.(s1 * s2))) )\n | Snarky_backendless.Constraint.Boolean v -> (\n let s, x = red v in\n match x with\n | `Var x ->\n (* -x + x * x = 0 *)\n add_generic_constraint ~l:x ~r:x\n [| Fp.(negate one); Fp.zero; Fp.zero; Fp.one; Fp.zero |]\n sys\n | `Constant ->\n assert (Fp.(equal s (s * s))) )\n | Snarky_backendless.Constraint.Equal (v1, v2) -> (\n let (s1, x1), (s2, x2) = (red v1, red v2) in\n match (x1, x2) with\n | `Var x1, `Var x2 ->\n if Fp.equal s1 s2 then (\n if not (Fp.equal s1 Fp.zero) then\n Union_find.union (union_find sys x1) (union_find sys x2) )\n else if (* s1 x1 - s2 x2 = 0\n *)\n not (Fp.equal s1 s2) then\n add_generic_constraint ~l:x1 ~r:x2\n [| s1; Fp.(negate s2); Fp.zero; Fp.zero; Fp.zero |]\n sys\n else\n add_generic_constraint ~l:x1 ~r:x2\n [| s1; Fp.(negate s2); Fp.zero; Fp.zero; Fp.zero |]\n sys\n | `Var x1, `Constant -> (\n (* s1 * x1 = s2\n x1 = s2 / s1\n *)\n let ratio = Fp.(s2 / s1) in\n match Hashtbl.find sys.cached_constants ratio with\n | Some x2 ->\n Union_find.union (union_find sys x1) (union_find sys x2)\n | None ->\n add_generic_constraint ~l:x1\n [| s1; Fp.zero; Fp.zero; Fp.zero; Fp.negate s2 |]\n sys ;\n Hashtbl.set sys.cached_constants ~key:ratio ~data:x1 )\n | `Constant, `Var x2 -> (\n (* s1 = s2 * x2\n x2 = s1 / s2\n *)\n let ratio = Fp.(s1 / s2) in\n match Hashtbl.find sys.cached_constants ratio with\n | Some x1 ->\n Union_find.union (union_find sys x1) (union_find sys x2)\n | None ->\n add_generic_constraint ~r:x2\n [| Fp.zero; s2; Fp.zero; Fp.zero; Fp.negate s1 |]\n sys ;\n Hashtbl.set sys.cached_constants ~key:ratio ~data:x2 )\n | `Constant, `Constant ->\n assert (Fp.(equal s1 s2)) )\n | Plonk_constraint.T (Basic { l; r; o; m; c }) ->\n (* 0\n = l.s * l.x\n + r.s * r.x\n + o.s * o.x\n + m * (l.x * r.x)\n + c\n =\n l.s * l.s' * l.x'\n + r.s * r.s' * r.x'\n + o.s * o.s' * o.x'\n + m * (l.s' * l.x' * r.s' * r.x')\n + c\n =\n (l.s * l.s') * l.x'\n + (r.s * r.s') * r.x'\n + (o.s * o.s') * o.x'\n + (m * l.s' * r.s') * l.x' r.x'\n + c\n *)\n (* TODO: This is sub-optimal *)\n let c = ref c in\n let red_pr (s, x) =\n match red x with\n | s', `Constant ->\n c := Fp.add !c Fp.(s * s') ;\n (* No need to have a real term. *)\n (s', None)\n | s', `Var x ->\n (s', Some (Fp.(s * s'), x))\n in\n (* l.s * l.x\n + r.s * r.x\n + o.s * o.x\n + m * (l.x * r.x)\n + c\n =\n l.s * l.s' * l.x'\n + r.s * r.x\n + o.s * o.x\n + m * (l.x * r.x)\n + c\n =\n *)\n let l_s', l = red_pr l in\n let r_s', r = red_pr r in\n let _, o = red_pr o in\n let var = Option.map ~f:snd in\n let coeff = Option.value_map ~default:Fp.zero ~f:fst in\n let m =\n match (l, r) with\n | Some _, Some _ ->\n Fp.(l_s' * r_s' * m)\n | _ ->\n (* TODO: Figure this out later. *)\n failwith \"Must use non-constant cvar in plonk constraints\"\n in\n add_generic_constraint ?l:(var l) ?r:(var r) ?o:(var o)\n [| coeff l; coeff r; coeff o; m; !c |]\n sys\n (* | w0 | w1 | w2 | w3 | w4 | w5\n state = [ x , x , x ], [ y, y, y ], ... ]\n i=0, perm^ i=1, perm^\n *)\n | Plonk_constraint.T (Poseidon { state }) ->\n (* reduce the state *)\n let reduce_state sys (s : Fp.t Snarky_backendless.Cvar.t array array) :\n V.t array array =\n Array.map ~f:(Array.map ~f:reduce_to_v) s\n in\n let state = reduce_state sys state in\n (* add_round_state adds a row that contains 5 rounds of permutation *)\n let add_round_state ~round (s1, s2, s3, s4, s5) =\n let vars =\n [| Some s1.(0)\n ; Some s1.(1)\n ; Some s1.(2)\n ; Some s5.(0) (* the last state is in 2nd position *)\n ; Some s5.(1)\n ; Some s5.(2)\n ; Some s2.(0)\n ; Some s2.(1)\n ; Some s2.(2)\n ; Some s3.(0)\n ; Some s3.(1)\n ; Some s3.(2)\n ; Some s4.(0)\n ; Some s4.(1)\n ; Some s4.(2)\n |]\n in\n let coeffs =\n [| Params.params.round_constants.(round).(0)\n ; Params.params.round_constants.(round).(1)\n ; Params.params.round_constants.(round).(2)\n ; Params.params.round_constants.(round + 1).(0)\n ; Params.params.round_constants.(round + 1).(1)\n ; Params.params.round_constants.(round + 1).(2)\n ; Params.params.round_constants.(round + 2).(0)\n ; Params.params.round_constants.(round + 2).(1)\n ; Params.params.round_constants.(round + 2).(2)\n ; Params.params.round_constants.(round + 3).(0)\n ; Params.params.round_constants.(round + 3).(1)\n ; Params.params.round_constants.(round + 3).(2)\n ; Params.params.round_constants.(round + 4).(0)\n ; Params.params.round_constants.(round + 4).(1)\n ; Params.params.round_constants.(round + 4).(2)\n |]\n in\n add_row sys vars Poseidon coeffs\n in\n (* add_last_row adds the last row containing the output *)\n let add_last_row state =\n let vars =\n [| Some state.(0)\n ; Some state.(1)\n ; Some state.(2)\n ; None\n ; None\n ; None\n ; None\n ; None\n ; None\n ; None\n ; None\n ; None\n ; None\n ; None\n ; None\n |]\n in\n add_row sys vars Zero [||]\n in\n (* go through the states row by row (a row contains 5 states) *)\n let rec process_5_states_at_a_time ~round = function\n | [ s1; s2; s3; s4; s5; last ] ->\n add_round_state ~round (s1, s2, s3, s4, s5) ;\n add_last_row last\n | s1 :: s2 :: s3 :: s4 :: s5 :: tl ->\n add_round_state ~round (s1, s2, s3, s4, s5) ;\n process_5_states_at_a_time ~round:(round + 5) tl\n | _ ->\n failwith \"incorrect number of states given\"\n in\n process_5_states_at_a_time ~round:0 (Array.to_list state)\n | Plonk_constraint.T\n (EC_add_complete { p1; p2; p3; inf; same_x; slope; inf_z; x21_inv }) ->\n let reduce_curve_point (x, y) = (reduce_to_v x, reduce_to_v y) in\n\n (*\n //! 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14\n //! x1 y1 x2 y2 x3 y3 inf same_x s inf_z x21_inv\n *)\n let x1, y1 = reduce_curve_point p1 in\n let x2, y2 = reduce_curve_point p2 in\n let x3, y3 = reduce_curve_point p3 in\n let vars =\n [| Some x1\n ; Some y1\n ; Some x2\n ; Some y2\n ; Some x3\n ; Some y3\n ; Some (reduce_to_v inf)\n ; Some (reduce_to_v same_x)\n ; Some (reduce_to_v slope)\n ; Some (reduce_to_v inf_z)\n ; Some (reduce_to_v x21_inv)\n ; None\n ; None\n ; None\n ; None\n |]\n in\n add_row sys vars CompleteAdd [||]\n | Plonk_constraint.T (EC_scale { state }) ->\n let i = ref 0 in\n (*\n 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14\n xT yT x0 y0 n n' x1 y1 x2 y2 x3 y3 x4 y4\n x5 y5 b0 b1 b2 b3 b4 s0 s1 s2 s3 s4\n *)\n let add_ecscale_round\n Scale_round.{ accs; bits; ss; base = xt, yt; n_prev; n_next } =\n let curr_row =\n [| Some xt\n ; Some yt\n ; Some (fst accs.(0))\n ; Some (snd accs.(0))\n ; Some n_prev\n ; Some n_next\n ; None\n ; Some (fst accs.(1))\n ; Some (snd accs.(1))\n ; Some (fst accs.(2))\n ; Some (snd accs.(2))\n ; Some (fst accs.(3))\n ; Some (snd accs.(3))\n ; Some (fst accs.(4))\n ; Some (snd accs.(4))\n |]\n in\n let next_row =\n [| Some (fst accs.(5))\n ; Some (snd accs.(5))\n ; Some bits.(0)\n ; Some bits.(1)\n ; Some bits.(2)\n ; Some bits.(3)\n ; Some bits.(4)\n ; Some ss.(0)\n ; Some ss.(1)\n ; Some ss.(2)\n ; Some ss.(3)\n ; Some ss.(4)\n ; None\n ; None\n ; None\n |]\n in\n add_row sys curr_row VarBaseMul [||] ;\n add_row sys next_row Zero [||]\n in\n\n Array.iter\n ~f:(fun round -> add_ecscale_round round ; incr i)\n (Array.map state ~f:(Scale_round.map ~f:reduce_to_v)) ;\n ()\n | Plonk_constraint.T (EC_endoscale { state; xs; ys; n_acc }) ->\n (* Reduce state. *)\n let state = Array.map state ~f:(Endoscale_round.map ~f:reduce_to_v) in\n (* Add round function. *)\n let add_endoscale_round (round : V.t Endoscale_round.t) =\n let row =\n [| Some round.xt\n ; Some round.yt\n ; None\n ; None\n ; Some round.xp\n ; Some round.yp\n ; Some round.n_acc\n ; Some round.xr\n ; Some round.yr\n ; Some round.s1\n ; Some round.s3\n ; Some round.b1\n ; Some round.b2\n ; Some round.b3\n ; Some round.b4\n |]\n in\n add_row sys row Kimchi_types.EndoMul [||]\n in\n Array.iter state ~f:add_endoscale_round ;\n (* Last row. *)\n let vars =\n [| None\n ; None\n ; None\n ; None\n ; Some (reduce_to_v xs)\n ; Some (reduce_to_v ys)\n ; Some (reduce_to_v n_acc)\n ; None\n ; None\n ; None\n ; None\n ; None\n ; None\n ; None\n ; None\n |]\n in\n add_row sys vars Zero [||]\n | Plonk_constraint.T\n (EC_endoscalar { state : 'v Endoscale_scalar_round.t array }) ->\n (* Add round function. *)\n let add_endoscale_scalar_round (round : V.t Endoscale_scalar_round.t) =\n let row =\n [| Some round.n0\n ; Some round.n8\n ; Some round.a0\n ; Some round.b0\n ; Some round.a8\n ; Some round.b8\n ; Some round.x0\n ; Some round.x1\n ; Some round.x2\n ; Some round.x3\n ; Some round.x4\n ; Some round.x5\n ; Some round.x6\n ; Some round.x7\n ; None\n |]\n in\n add_row sys row Kimchi_types.EndoMulScalar [||]\n in\n Array.iter state\n ~f:\n (Fn.compose add_endoscale_scalar_round\n (Endoscale_scalar_round.map ~f:reduce_to_v) )\n | Plonk_constraint.T (Lookup { w0; w1; w2; w3; w4; w5; w6 }) ->\n let vars =\n [| Some (reduce_to_v w0)\n ; Some (reduce_to_v w1)\n ; Some (reduce_to_v w2)\n ; Some (reduce_to_v w3)\n ; Some (reduce_to_v w4)\n ; Some (reduce_to_v w5)\n ; Some (reduce_to_v w6)\n |]\n in\n add_row sys vars Lookup [||]\n | Plonk_constraint.T\n (RangeCheck0\n { v0\n ; v0p0\n ; v0p1\n ; v0p2\n ; v0p3\n ; v0p4\n ; v0p5\n ; v0c0\n ; v0c1\n ; v0c2\n ; v0c3\n ; v0c4\n ; v0c5\n ; v0c6\n ; v0c7\n ; compact\n } ) ->\n (*\n //! 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14\n //! v vp0 vp1 vp2 vp3 vp4 vp5 vc0 vc1 vc2 vc3 vc4 vc5 vc6 vc7\n *)\n let vars =\n [| Some (reduce_to_v v0)\n ; Some (reduce_to_v v0p0) (* MSBs *)\n ; Some (reduce_to_v v0p1)\n ; Some (reduce_to_v v0p2)\n ; Some (reduce_to_v v0p3)\n ; Some (reduce_to_v v0p4)\n ; Some (reduce_to_v v0p5)\n ; Some (reduce_to_v v0c0)\n ; Some (reduce_to_v v0c1)\n ; Some (reduce_to_v v0c2)\n ; Some (reduce_to_v v0c3)\n ; Some (reduce_to_v v0c4)\n ; Some (reduce_to_v v0c5)\n ; Some (reduce_to_v v0c6)\n ; Some (reduce_to_v v0c7) (* LSBs *)\n |]\n in\n let coeff = if Fp.equal compact Fp.one then Fp.one else Fp.zero in\n add_row sys vars RangeCheck0 [| coeff |]\n | Plonk_constraint.T\n (RangeCheck1\n { (* Current row *) v2\n ; v12\n ; v2c0\n ; v2p0\n ; v2p1\n ; v2p2\n ; v2p3\n ; v2c1\n ; v2c2\n ; v2c3\n ; v2c4\n ; v2c5\n ; v2c6\n ; v2c7\n ; v2c8\n ; (* Next row *) v2c9\n ; v2c10\n ; v2c11\n ; v0p0\n ; v0p1\n ; v1p0\n ; v1p1\n ; v2c12\n ; v2c13\n ; v2c14\n ; v2c15\n ; v2c16\n ; v2c17\n ; v2c18\n ; v2c19\n } ) ->\n (*\n //! 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14\n //! Curr: v2 v12 v2c0 v2p0 v2p1 v2p2 v2p3 v2c1 v2c2 v2c3 v2c4 v2c5 v2c6 v2c7 v2c8\n //! Next: v2c9 v2c10 v2c11 v0p0 v0p1 v1p0 v1p1 v2c12 v2c13 v2c14 v2c15 v2c16 v2c17 v2c18 v2c19\n *)\n let vars_curr =\n [| (* Current row *) Some (reduce_to_v v2)\n ; Some (reduce_to_v v12)\n ; Some (reduce_to_v v2c0) (* MSBs *)\n ; Some (reduce_to_v v2p0)\n ; Some (reduce_to_v v2p1)\n ; Some (reduce_to_v v2p2)\n ; Some (reduce_to_v v2p3)\n ; Some (reduce_to_v v2c1)\n ; Some (reduce_to_v v2c2)\n ; Some (reduce_to_v v2c3)\n ; Some (reduce_to_v v2c4)\n ; Some (reduce_to_v v2c5)\n ; Some (reduce_to_v v2c6)\n ; Some (reduce_to_v v2c7)\n ; Some (reduce_to_v v2c8) (* LSBs *)\n |]\n in\n let vars_next =\n [| (* Next row *) Some (reduce_to_v v2c9)\n ; Some (reduce_to_v v2c10)\n ; Some (reduce_to_v v2c11)\n ; Some (reduce_to_v v0p0)\n ; Some (reduce_to_v v0p1)\n ; Some (reduce_to_v v1p0)\n ; Some (reduce_to_v v1p1)\n ; Some (reduce_to_v v2c12)\n ; Some (reduce_to_v v2c13)\n ; Some (reduce_to_v v2c14)\n ; Some (reduce_to_v v2c15)\n ; Some (reduce_to_v v2c16)\n ; Some (reduce_to_v v2c17)\n ; Some (reduce_to_v v2c18)\n ; Some (reduce_to_v v2c19)\n |]\n in\n add_row sys vars_curr RangeCheck1 [||] ;\n add_row sys vars_next Zero [||]\n | Plonk_constraint.T\n (Xor\n { in1\n ; in2\n ; out\n ; in1_0\n ; in1_1\n ; in1_2\n ; in1_3\n ; in2_0\n ; in2_1\n ; in2_2\n ; in2_3\n ; out_0\n ; out_1\n ; out_2\n ; out_3\n } ) ->\n (* | Column | Curr | Next (gadget responsibility) |\n | ------ | ---------------- | ---------------------------- |\n | 0 | copy `in1` | copy `in1'` |\n | 1 | copy `in2` | copy `in2'` |\n | 2 | copy `out` | copy `out'` |\n | 3 | plookup0 `in1_0` | |\n | 4 | plookup1 `in1_1` | |\n | 5 | plookup2 `in1_2` | |\n | 6 | plookup3 `in1_3` | |\n | 7 | plookup0 `in2_0` | |\n | 8 | plookup1 `in2_1` | |\n | 9 | plookup2 `in2_2` | |\n | 10 | plookup3 `in2_3` | |\n | 11 | plookup0 `out_0` | |\n | 12 | plookup1 `out_1` | |\n | 13 | plookup2 `out_2` | |\n | 14 | plookup3 `out_3` | |\n *)\n let curr_row =\n [| Some (reduce_to_v in1)\n ; Some (reduce_to_v in2)\n ; Some (reduce_to_v out)\n ; Some (reduce_to_v in1_0)\n ; Some (reduce_to_v in1_1)\n ; Some (reduce_to_v in1_2)\n ; Some (reduce_to_v in1_3)\n ; Some (reduce_to_v in2_0)\n ; Some (reduce_to_v in2_1)\n ; Some (reduce_to_v in2_2)\n ; Some (reduce_to_v in2_3)\n ; Some (reduce_to_v out_0)\n ; Some (reduce_to_v out_1)\n ; Some (reduce_to_v out_2)\n ; Some (reduce_to_v out_3)\n |]\n in\n (* The raw gate after a Xor16 gate is a Const to check that all values are zero.\n For that, the first coefficient is 1 and the rest will be zero.\n This will be included in the gadget for a chain of Xors, not here.*)\n add_row sys curr_row Xor16 [||]\n | Plonk_constraint.T\n (ForeignFieldAdd\n { left_input_lo\n ; left_input_mi\n ; left_input_hi\n ; right_input_lo\n ; right_input_mi\n ; right_input_hi\n ; field_overflow\n ; carry\n ; (* Coefficients *) foreign_field_modulus0\n ; foreign_field_modulus1\n ; foreign_field_modulus2\n ; sign\n } ) ->\n (*\n //! | Gate | `ForeignFieldAdd` | Circuit/gadget responsibility |\n //! | ------ | ------------------------ | ------------------------------ |\n //! | Column | `Curr` | `Next` |\n //! | ------ | ------------------------ | ------------------------------ |\n //! | 0 | `left_input_lo` (copy) | `result_lo` (copy) |\n //! | 1 | `left_input_mi` (copy) | `result_mi` (copy) |\n //! | 2 | `left_input_hi` (copy) | `result_hi` (copy) |\n //! | 3 | `right_input_lo` (copy) | |\n //! | 4 | `right_input_mi` (copy) | |\n //! | 5 | `right_input_hi` (copy) | |\n //! | 6 | `field_overflow` (copy?) | |\n //! | 7 | `carry` | |\n //! | 8 | | |\n //! | 9 | | |\n //! | 10 | | |\n //! | 11 | | |\n //! | 12 | | |\n //! | 13 | | |\n //! | 14 | | |\n *)\n let vars =\n [| (* Current row *) Some (reduce_to_v left_input_lo)\n ; Some (reduce_to_v left_input_mi)\n ; Some (reduce_to_v left_input_hi)\n ; Some (reduce_to_v right_input_lo)\n ; Some (reduce_to_v right_input_mi)\n ; Some (reduce_to_v right_input_hi)\n ; Some (reduce_to_v field_overflow)\n ; Some (reduce_to_v carry)\n ; None\n ; None\n ; None\n ; None\n ; None\n ; None\n ; None\n |]\n in\n add_row sys vars ForeignFieldAdd\n [| foreign_field_modulus0\n ; foreign_field_modulus1\n ; foreign_field_modulus2\n ; sign\n |]\n | Plonk_constraint.T\n (ForeignFieldMul\n { left_input0\n ; left_input1\n ; left_input2\n ; right_input0\n ; right_input1\n ; right_input2\n ; remainder01\n ; remainder2\n ; quotient0\n ; quotient1\n ; quotient2\n ; quotient_hi_bound\n ; product1_lo\n ; product1_hi_0\n ; product1_hi_1\n ; carry0\n ; carry1_0\n ; carry1_12\n ; carry1_24\n ; carry1_36\n ; carry1_48\n ; carry1_60\n ; carry1_72\n ; carry1_84\n ; carry1_86\n ; carry1_88\n ; carry1_90\n ; (* Coefficients *) foreign_field_modulus2\n ; neg_foreign_field_modulus0\n ; neg_foreign_field_modulus1\n ; neg_foreign_field_modulus2\n } ) ->\n (*\n | col | `ForeignFieldMul` | `Zero` |\n | --- | ----------------------- | -------------------------- |\n | 0 | `left_input0` (copy) | `remainder01` (copy) |\n | 1 | `left_input1` (copy) | `remainder2` (copy) |\n | 2 | `left_input2` (copy) | `quotient0` (copy) |\n | 3 | `right_input0` (copy) | `quotient1` (copy) |\n | 4 | `right_input1` (copy) | `quotient2` (copy) |\n | 5 | `right_input2` (copy) | `quotient_hi_bound` (copy) |\n | 6 | `product1_lo` (copy) | `product1_hi_0` (copy) |\n | 7 | `carry1_0` (plookup) | `product1_hi_1` (dummy) |\n | 8 | `carry1_12 (plookup) | `carry1_48` (plookup) |\n | 9 | `carry1_24` (plookup) | `carry1_60` (plookup) |\n | 10 | `carry1_36` (plookup) | `carry1_72` (plookup) |\n | 11 | `carry1_84` | `carry0` |\n | 12 | `carry1_86` | |\n | 13 | `carry1_88` | |\n | 14 | `carry1_90` | |\n *)\n (* Current row *)\n let vars_curr =\n [| Some (reduce_to_v left_input0)\n ; Some (reduce_to_v left_input1)\n ; Some (reduce_to_v left_input2)\n ; Some (reduce_to_v right_input0)\n ; Some (reduce_to_v right_input1)\n ; Some (reduce_to_v right_input2)\n ; Some (reduce_to_v product1_lo)\n ; Some (reduce_to_v carry1_0)\n ; Some (reduce_to_v carry1_12)\n ; Some (reduce_to_v carry1_24)\n ; Some (reduce_to_v carry1_36)\n ; Some (reduce_to_v carry1_84)\n ; Some (reduce_to_v carry1_86)\n ; Some (reduce_to_v carry1_88)\n ; Some (reduce_to_v carry1_90)\n |]\n in\n (* Next row *)\n let vars_next =\n [| Some (reduce_to_v remainder01)\n ; Some (reduce_to_v remainder2)\n ; Some (reduce_to_v quotient0)\n ; Some (reduce_to_v quotient1)\n ; Some (reduce_to_v quotient2)\n ; Some (reduce_to_v quotient_hi_bound)\n ; Some (reduce_to_v product1_hi_0)\n ; Some (reduce_to_v product1_hi_1)\n ; Some (reduce_to_v carry1_48)\n ; Some (reduce_to_v carry1_60)\n ; Some (reduce_to_v carry1_72)\n ; Some (reduce_to_v carry0)\n ; None\n ; None\n ; None\n |]\n in\n add_row sys vars_curr ForeignFieldMul\n [| foreign_field_modulus2\n ; neg_foreign_field_modulus0\n ; neg_foreign_field_modulus1\n ; neg_foreign_field_modulus2\n |] ;\n add_row sys vars_next Zero [||]\n | Plonk_constraint.T\n (Rot64\n { word\n ; rotated\n ; excess\n ; bound_limb0\n ; bound_limb1\n ; bound_limb2\n ; bound_limb3\n ; bound_crumb0\n ; bound_crumb1\n ; bound_crumb2\n ; bound_crumb3\n ; bound_crumb4\n ; bound_crumb5\n ; bound_crumb6\n ; bound_crumb7\n ; (* Coefficients *) two_to_rot\n } ) ->\n (*\n //! | Gate | `Rot64` | `RangeCheck0` gadgets (designer's duty) |\n //! | ------ | ------------------- | --------------------------------------------------------- |\n //! | Column | `Curr` | `Next` | `Next` + 1 | `Next`+ 2, if needed |\n //! | ------ | ------------------- | ---------------- | --------------- | -------------------- |\n //! | 0 | copy `word` |`shifted` | copy `excess` | copy `word` |\n //! | 1 | copy `rotated` | 0 | 0 | 0 |\n //! | 2 | `excess` | 0 | 0 | 0 |\n //! | 3 | `bound_limb0` | `shifted_limb0` | `excess_limb0` | `word_limb0` |\n //! | 4 | `bound_limb1` | `shifted_limb1` | `excess_limb1` | `word_limb1` |\n //! | 5 | `bound_limb2` | `shifted_limb2` | `excess_limb2` | `word_limb2` |\n //! | 6 | `bound_limb3` | `shifted_limb3` | `excess_limb3` | `word_limb3` |\n //! | 7 | `bound_crumb0` | `shifted_crumb0` | `excess_crumb0` | `word_crumb0` |\n //! | 8 | `bound_crumb1` | `shifted_crumb1` | `excess_crumb1` | `word_crumb1` | \n //! | 9 | `bound_crumb2` | `shifted_crumb2` | `excess_crumb2` | `word_crumb2` | \n //! | 10 | `bound_crumb3` | `shifted_crumb3` | `excess_crumb3` | `word_crumb3` | \n //! | 11 | `bound_crumb4` | `shifted_crumb4` | `excess_crumb4` | `word_crumb4` |\n //! | 12 | `bound_crumb5` | `shifted_crumb5` | `excess_crumb5` | `word_crumb5` |\n //! | 13 | `bound_crumb6` | `shifted_crumb6` | `excess_crumb6` | `word_crumb6` |\n //! | 14 | `bound_crumb7` | `shifted_crumb7` | `excess_crumb7` | `word_crumb7` |\n *)\n let vars_curr =\n [| (* Current row *) Some (reduce_to_v word)\n ; Some (reduce_to_v rotated)\n ; Some (reduce_to_v excess)\n ; Some (reduce_to_v bound_limb0)\n ; Some (reduce_to_v bound_limb1)\n ; Some (reduce_to_v bound_limb2)\n ; Some (reduce_to_v bound_limb3)\n ; Some (reduce_to_v bound_crumb0)\n ; Some (reduce_to_v bound_crumb1)\n ; Some (reduce_to_v bound_crumb2)\n ; Some (reduce_to_v bound_crumb3)\n ; Some (reduce_to_v bound_crumb4)\n ; Some (reduce_to_v bound_crumb5)\n ; Some (reduce_to_v bound_crumb6)\n ; Some (reduce_to_v bound_crumb7)\n |]\n in\n add_row sys vars_curr Rot64 [| two_to_rot |]\n | Plonk_constraint.T (Raw { kind; values; coeffs }) ->\n let values =\n Array.init 15 ~f:(fun i ->\n (* Insert [None] if the index is beyond the end of the [values]\n array.\n *)\n Option.try_with (fun () -> reduce_to_v values.(i)) )\n in\n add_row sys values kind coeffs\n | constr ->\n failwithf \"Unhandled constraint %s\"\n Obj.(Extension_constructor.name (Extension_constructor.of_val constr))\n ()\nend\n","open Core_kernel\n\ntype ('a, 's) fold = init:'s -> f:('s -> 'a -> 's) -> 's\n\ntype 'a t = { fold : 's. ('a, 's) fold }\n\nlet map (t : 'a t) ~(f : 'a -> 'b) : 'b t =\n { fold =\n (fun ~init ~f:update -> t.fold ~init ~f:(fun acc x -> update acc (f x)))\n }\n\nlet concat (t : 'a t t) : 'a t =\n { fold =\n (fun ~init ~f ->\n t.fold ~init ~f:(fun acc inner -> inner.fold ~init:acc ~f) )\n }\n\nlet concat_map (t : 'a t) ~(f : 'a -> 'b t) : 'b t =\n { fold =\n (fun ~init ~f:update ->\n t.fold ~init ~f:(fun acc x -> (f x).fold ~init:acc ~f:update) )\n }\n\nlet init n ~f:ith_elt =\n { fold =\n (fun ~init ~f ->\n let rec go i acc =\n if i = n then acc else go (i + 1) (f acc (ith_elt i))\n in\n go 0 init )\n }\n\ninclude Monad.Make (struct\n type nonrec 'a t = 'a t\n\n let map = `Custom map\n\n let return x = { fold = (fun ~init ~f -> f init x) }\n\n let bind = concat_map\nend)\n\nlet to_list (t : 'a t) : 'a list =\n List.rev (t.fold ~init:[] ~f:(Fn.flip List.cons))\n\nlet of_list (xs : 'a list) : 'a t =\n { fold = (fun ~init ~f -> List.fold xs ~init ~f) }\n\nlet of_array (xs : 'a array) : 'a t =\n { fold = (fun ~init ~f -> Array.fold xs ~init ~f) }\n\nlet%test_unit \"fold-to-list\" =\n Quickcheck.test (Quickcheck.Generator.list Int.quickcheck_generator)\n ~f:(fun xs -> assert ([%equal: Int.t list] xs (to_list (of_list xs))))\n\nlet sexp_of_t f t = List.sexp_of_t f (to_list t)\n\nlet compose (t1 : 'a t) (t2 : 'a t) : 'a t =\n { fold = (fun ~init ~f -> t2.fold ~init:(t1.fold ~init ~f) ~f) }\n\nlet ( +> ) = compose\n\nlet group3 ~default (t : 'a t) : ('a * 'a * 'a) t =\n { fold =\n (fun ~init ~f ->\n let pt, bs =\n t.fold ~init:(init, []) ~f:(fun (pt, bs) b ->\n match bs with\n | [ b2; b1; b0 ] ->\n let pt' = f pt (b0, b1, b2) in\n (pt', [ b ])\n | _ ->\n (pt, b :: bs) )\n in\n match bs with\n | [ b2; b1; b0 ] ->\n f pt (b0, b1, b2)\n | [ b1; b0 ] ->\n f pt (b0, b1, default)\n | [ b0 ] ->\n f pt (b0, default, default)\n | [] ->\n pt\n | _x1 :: _x2 :: _x3 :: _x4 :: _ ->\n assert false )\n }\n\nlet%test_unit \"group3\" =\n Quickcheck.test (Quickcheck.Generator.list Int.quickcheck_generator)\n ~f:(fun xs ->\n let default = 0 in\n let n = List.length xs in\n let tuples = to_list (group3 ~default (of_list xs)) in\n let k = List.length tuples in\n let r = n mod 3 in\n (let padded =\n xs @ if r = 0 then [] else List.init (3 - r) ~f:(fun _ -> default)\n in\n let concated =\n List.concat_map ~f:(fun (b1, b2, b3) -> [ b1; b2; b3 ]) tuples\n in\n [%test_eq: int list] padded concated ) ;\n assert ((n + 2) / 3 = k) )\n\nlet string_bits s =\n let ith_bit_int n i = (n lsr i) land 1 = 1 in\n { fold =\n (fun ~init ~f ->\n String.fold s ~init ~f:(fun acc c ->\n let c = Char.to_int c in\n let update i acc = f acc (ith_bit_int c i) in\n update 0 acc |> update 1 |> update 2 |> update 3 |> update 4\n |> update 5 |> update 6 |> update 7 ) )\n }\n\nlet bool_t_to_string =\n let module State = struct\n type t = { curr : int; acc : char list; i : int }\n end in\n let open State in\n fun t ->\n let { curr; i; acc } =\n t.fold ~init:{ curr = 0; acc = []; i = 0 } ~f:(fun { curr; acc; i } b ->\n let curr = if b then curr lor (1 lsl i) else curr in\n if i = 7 then { i = 0; acc = Char.of_int_exn curr :: acc; curr = 0 }\n else { i = i + 1; acc; curr } )\n in\n let cs = if i = 0 then acc else Char.of_int_exn curr :: acc in\n String.of_char_list cs\n\nlet string_triples s = group3 ~default:false (string_bits s)\n","open Core_kernel\nopen Fold_lib\nopen Tuple_lib\n\nlet ( = ) = `Don't_use_polymorphic_equality\n\nmodule type Basic_intf = sig\n module Nat : Nat_intf.S\n\n type t [@@deriving eq]\n\n val order : Nat.t\n\n val one : t\n\n val zero : t\n\n val ( + ) : t -> t -> t\n\n val ( * ) : t -> t -> t\n\n val ( - ) : t -> t -> t\n\n val ( / ) : t -> t -> t\n\n val square : t -> t\nend\n\nmodule type Intf = sig\n type t [@@deriving bin_io, sexp, yojson, compare, hash]\n\n include Basic_intf with type t := t\n\n val gen : t Quickcheck.Generator.t\n\n val gen_incl : t -> t -> t Quickcheck.Generator.t\n\n val gen_uniform : t Quickcheck.Generator.t\n\n val gen_uniform_incl : t -> t -> t Quickcheck.Generator.t\n\n val random : unit -> t\n\n val negate : t -> t\n\n val inv : t -> t\n\n val parity : t -> bool\nend\n\nmodule type Sqrt_field_intf = sig\n include Intf\n\n val is_square : t -> bool\n\n val sqrt : t -> t\nend\n\nmodule type Extended_intf = sig\n include Sqrt_field_intf\n\n val ( ** ) : t -> Nat.t -> t\nend\n\nmodule type Fp_intf = sig\n include Intf\n\n include Stringable.S with type t := t\n\n include Stringable.S with type t := t\n\n val of_int : int -> t\n\n val of_bits : bool list -> t option\n\n val to_bigint : t -> Nat.t\n\n val of_bigint : Nat.t -> t\n\n val fold_bits : t -> bool Fold.t\n\n val fold : t -> bool Triple.t Fold.t\n\n val to_bits : t -> bool list\n\n val length_in_bits : int\n\n val is_square : t -> bool\n\n val sqrt : t -> t\nend\n\nmodule type Extension_intf = sig\n type base\n\n include Extended_intf\n\n val scale : t -> base -> t\n\n val of_base : base -> t\n\n val project_to_base : t -> base\n\n val to_list : t -> base list\nend\n\nmodule Extend (F : Basic_intf) = struct\n open F\n\n let ( ** ) x n =\n let k = Nat.num_bits n in\n let rec go acc i =\n if Int.(i < 0) then acc\n else\n let acc = square acc in\n let acc = if Nat.test_bit n i then acc * x else acc in\n go acc Int.(i - 1)\n in\n go one Int.(k - 1)\n\n let is_square =\n let euler = Nat.((order - of_int 1) // of_int 2) in\n fun x -> equal (x ** euler) one\n\n module Sqrt_params = struct\n let two_adicity n =\n let rec go i = if Nat.test_bit n i then i else go Int.(i + 1) in\n go 0\n\n type nonrec t =\n { two_adicity : int\n ; quadratic_non_residue_to_t : t\n ; t_minus_1_over_2 : Nat.t\n }\n\n let first f =\n let rec go i = match f i with Some x -> x | None -> go (i + one) in\n go one\n\n let create () =\n let p_minus_one = Nat.(order - of_int 1) in\n let s = two_adicity p_minus_one in\n let t = Nat.shift_right p_minus_one s in\n let quadratic_non_residue =\n first (fun i -> Option.some_if (not (is_square i)) i)\n in\n { two_adicity = s\n ; quadratic_non_residue_to_t = quadratic_non_residue ** t\n ; t_minus_1_over_2 = Nat.((t - of_int 1) // of_int 2)\n }\n\n let t = lazy (create ())\n end\n\n let rec loop ~while_ ~init f =\n if while_ init then loop ~while_ ~init:(f init) f else init\n\n let rec pow2 b n = if n > 0 then pow2 (square b) Int.(n - 1) else b\n\n let sqrt =\n let pow2_order b =\n loop\n ~while_:(fun (b2m, _) -> not (equal b2m one))\n ~init:(b, 0)\n (fun (b2m, m) -> (square b2m, Int.succ m))\n |> snd\n in\n let module Loop_params = struct\n type nonrec t = { z : t; b : t; x : t; v : int }\n end in\n let open Loop_params in\n fun a ->\n let { Sqrt_params.two_adicity = v\n ; quadratic_non_residue_to_t = z\n ; t_minus_1_over_2\n } =\n Lazy.force Sqrt_params.t\n in\n let w = a ** t_minus_1_over_2 in\n let x = a * w in\n let b = x * w in\n let { x; _ } =\n loop\n ~while_:(fun p -> not (equal p.b one))\n ~init:{ z; b; x; v }\n (fun { z; b; x; v } ->\n let m = pow2_order b in\n let w = pow2 z Int.(v - m - 1) in\n let z = square w in\n { z; b = b * z; x = x * w; v = m } )\n in\n x\nend\n\nmodule Make_fp\n (N : Nat_intf.S) (Info : sig\n val order : N.t\n end) : Fp_intf with module Nat = N and type t = private N.t = struct\n include Info\n\n module T = struct\n let zero = N.of_int 0\n\n let one = N.of_int 1\n\n let length_in_bits = N.num_bits N.(Info.order - one)\n\n module Nat = N\n open Nat\n\n let order = Info.order\n\n (* TODO version *)\n type t = N.t [@@deriving eq, sexp, yojson, compare, hash]\n\n let length_in_bytes = Int.((length_in_bits + 7) / 8)\n\n (** serialization meant to be identical to field serializations in snarky *)\n include Bin_prot.Utils.Of_minimal (struct\n type nonrec t = t\n\n (* increment if serialization changes *)\n let version = 1\n\n let bin_shape_t =\n Bin_prot.Shape.basetype\n (Bin_prot.Shape.Uuid.of_string\n (sprintf \"snarkette_field_%d_V%d\" length_in_bytes version) )\n []\n\n let __bin_read_t__ _buf ~pos_ref _vint =\n Bin_prot.Common.raise_variant_wrong_type \"Fp.t\" !pos_ref\n\n let bin_size_t _ = length_in_bytes\n\n let bin_write_t buf ~pos t =\n let bs = Bigstring.of_string (N.to_bytes t) in\n let n = Bigstring.length bs in\n Bigstring.blit ~src:bs ~dst:buf ~src_pos:0 ~dst_pos:pos ~len:n ;\n if Int.(n < length_in_bytes) then\n for i = n to Int.(length_in_bytes - 1) do\n Bigstring.set buf Int.(pos + i) '\\000'\n done ;\n Int.(pos + length_in_bytes)\n\n let bin_read_t buf ~pos_ref =\n let open Int in\n let remaining_bytes = Bigstring.length buf - !pos_ref in\n if remaining_bytes < length_in_bytes then\n failwithf \"Field.bin_read_t: Expected %d bytes, got %d\"\n length_in_bytes remaining_bytes () ;\n let t =\n N.of_bytes\n (Bigstring.to_string buf ~pos:!pos_ref ~len:length_in_bytes)\n in\n pos_ref := length_in_bytes + !pos_ref ;\n t\n end)\n\n let ( + ) x y = (x + y) % Info.order\n\n let ( - ) x y = (x - y) % Info.order\n\n let ( * ) x y = x * y % Info.order\n\n let square x = x * x\n\n let rec extended_euclidean a b =\n if equal b zero then (a, one, zero)\n else\n match extended_euclidean b (a % b) with\n | d, x, y ->\n (d, y, x - (a // b * y))\n\n let inv_no_mod x =\n let _, a, _b = extended_euclidean x Info.order in\n a\n\n let inv x = inv_no_mod x % Info.order\n\n let ( / ) x y = x * inv_no_mod y\n end\n\n include Extend (T)\n include T\n\n let of_bigint x = N.(x % Info.order)\n\n let to_bigint = Fn.id\n\n let parity t = N.test_bit (to_bigint t) 0\n\n let make_gen gen lo hi =\n let t_of_bignum_bigint n = Bigint.to_string n |> N.of_string in\n Quickcheck.Generator.map (gen lo hi) ~f:t_of_bignum_bigint\n\n (* fix zero, size - 1 bounds *)\n let make_gen_full gen =\n let size = order |> N.to_string |> Bigint.of_string in\n make_gen gen Bigint.zero Bigint.(size - one)\n\n let gen = make_gen_full Bigint.gen_incl\n\n let gen_incl lo hi =\n let bignum_bigint_of_t t = N.to_string t |> Bigint.of_string in\n make_gen Bigint.gen_incl (bignum_bigint_of_t lo) (bignum_bigint_of_t hi)\n\n let gen_uniform = make_gen_full Bigint.gen_uniform_incl\n\n let gen_uniform_incl lo hi =\n let bignum_bigint_of_t t = N.to_string t |> Bigint.of_string in\n make_gen Bigint.gen_uniform_incl (bignum_bigint_of_t lo)\n (bignum_bigint_of_t hi)\n\n let random () = Quickcheck.random_value gen_uniform\n\n let fold_bits n : bool Fold_lib.Fold.t =\n { fold =\n (fun ~init ~f ->\n let rec go acc i =\n if Int.(i = length_in_bits) then acc\n else go (f acc (N.test_bit n i)) Int.(i + 1)\n in\n go init 0 )\n }\n\n let to_bits = Fn.compose Fold_lib.Fold.to_list fold_bits\n\n let fold n = Fold_lib.Fold.group3 ~default:false (fold_bits n)\n\n let of_bits bits =\n let rec go acc i = function\n | [] ->\n acc\n | b :: bs ->\n let acc = if b then N.log_or acc (N.shift_left one i) else acc in\n go acc Int.(i + 1) bs\n in\n let r = go zero 0 bits in\n if N.( < ) r Info.order then Some r else None\n\n open N\n\n let of_int = N.of_int\n\n let of_string = N.of_string\n\n let to_string = N.to_string\n\n let negate x = N.( - ) Info.order x\n\n let%test_unit \"exp test\" = [%test_eq: t] (of_int 8) (of_int 2 ** of_int 3)\n\n let%test_unit \"pow2\" =\n let b = 7 in\n if N.(of_int Int.(7 ** 8) < order) then\n [%test_eq: t] (pow2 (of_int b) 3) (of_int Int.(7 ** 8))\n else ()\n\n let%test_unit \"sqrt agrees with integer square root on small values\" =\n let rec mem a = function\n | [] ->\n ()\n | x :: xs -> (\n try [%test_eq: t] a x with _ -> mem a xs )\n in\n let gen = Int.gen_incl 1 Int.max_value_30_bits in\n Quickcheck.test ~trials:10 gen ~f:(fun n ->\n let n = abs n in\n let n2 = Int.(n * n) in\n mem (sqrt (of_int n2)) [ of_int n; Info.order - of_int n ] )\nend\n\nmodule type Degree_2_extension_intf = sig\n type base\n\n include Extension_intf with type base := base and type t = base * base\nend\n\nmodule type Degree_3_extension_intf = sig\n type base\n\n include Extension_intf with type base := base and type t = base * base * base\nend\n\nlet ( % ) x n =\n let r = x mod n in\n if r < 0 then r + n else r\n\nlet find_wnaf (type t) (module N : Nat_intf.S with type t = t) window_size\n scalar =\n let one = N.of_int 1 in\n let first_k_bits c k =\n let k_bits = N.(shift_left one k - one) in\n N.to_int_exn (N.log_and k_bits c)\n in\n let length = N.num_bits scalar in\n let res = Array.init (length + 1) ~f:(fun _ -> 0) in\n let zero = N.of_int 0 in\n let rec go c j =\n if N.equal zero c then ()\n else\n let u, c =\n if N.test_bit c 0 then\n let u =\n let u = first_k_bits c (window_size + 1) in\n if u > 1 lsl window_size then u - (1 lsl (window_size + 1)) else u\n in\n let c = N.(c - of_int u) in\n (u, c)\n else (0, c)\n in\n res.(j) <- u ;\n go (N.shift_right c 1) (j + 1)\n in\n go scalar 0 ; res\n\nmodule Make_fp3\n (Fp : Intf) (Info : sig\n val non_residue : Fp.t\n\n val frobenius_coeffs_c1 : Fp.t array\n\n val frobenius_coeffs_c2 : Fp.t array\n end) : sig\n include Degree_3_extension_intf with type base = Fp.t and module Nat = Fp.Nat\n\n val non_residue : Fp.t\n\n val frobenius : t -> int -> t\nend = struct\n include Info\n\n type base = Fp.t\n\n let componentwise f (x1, x2, x3) (y1, y2, y3) = (f x1 y1, f x2 y2, f x3 y3)\n\n let of_base x = (x, Fp.zero, Fp.zero)\n\n module T = struct\n module Nat = Fp.Nat\n\n let order = Nat.(Fp.order * Fp.order * Fp.order)\n\n type t = Fp.t * Fp.t * Fp.t\n [@@deriving eq, bin_io, sexp, yojson, compare, hash]\n\n let ( + ) = componentwise Fp.( + )\n\n let ( - ) = componentwise Fp.( - )\n\n let ( * ) (a1, b1, c1) (a2, b2, c2) =\n let a = Fp.(a1 * a2) in\n let b = Fp.(b1 * b2) in\n let c = Fp.(c1 * c2) in\n let open Fp in\n ( a + (non_residue * (((b1 + c1) * (b2 + c2)) - b - c))\n , ((a1 + b1) * (a2 + b2)) - a - b + (non_residue * c)\n , ((a1 + c1) * (a2 + c2)) - a + b - c )\n\n let square (a, b, c) =\n let s0 = Fp.square a in\n let ab = Fp.(a * b) in\n let s1 = Fp.(ab + ab) in\n let s2 = Fp.(square (a - b + c)) in\n let bc = Fp.(b * c) in\n let s3 = Fp.(bc + bc) in\n let s4 = Fp.square c in\n let open Fp in\n (s0 + (non_residue * s3), s1 + (non_residue * s4), s1 + s2 + s3 - s0 - s4)\n\n let inv (a, b, c) =\n let open Fp in\n let t0 = square a in\n let t1 = square b in\n let t2 = square c in\n let t3 = a * b in\n let t4 = a * c in\n let t5 = b * c in\n let c0 = t0 - (non_residue * t5) in\n let c1 = (non_residue * t2) - t3 in\n let c2 = t1 - t4 in\n let t6 = (a * c0) + (non_residue * ((c * c1) + (b * c2))) |> inv in\n (t6 * c0, t6 * c1, t6 * c2)\n\n let ( / ) x y = x * inv y\n\n let one = of_base Fp.one\n\n let zero = of_base Fp.zero\n end\n\n include T\n include Extend (T)\n\n let gen = Quickcheck.Generator.tuple3 Fp.gen Fp.gen Fp.gen\n\n let gen_incl (lo1, lo2, lo3) (hi1, hi2, hi3) =\n Quickcheck.Generator.tuple3 (Fp.gen_incl lo1 hi1) (Fp.gen_incl lo2 hi2)\n (Fp.gen_incl lo3 hi3)\n\n let gen_uniform =\n Quickcheck.Generator.tuple3 Fp.gen_uniform Fp.gen_uniform Fp.gen_uniform\n\n let gen_uniform_incl (lo1, lo2, lo3) (hi1, hi2, hi3) =\n Quickcheck.Generator.tuple3\n (Fp.gen_uniform_incl lo1 hi1)\n (Fp.gen_uniform_incl lo2 hi2)\n (Fp.gen_uniform_incl lo3 hi3)\n\n let random () = Quickcheck.random_value gen_uniform\n\n let to_list (x, y, z) = [ x; y; z ]\n\n let project_to_base (x, _, _) = x\n\n let parity = Fn.compose Fp.parity project_to_base\n\n let scale (x1, x2, x3) s = Fp.(s * x1, s * x2, s * x3)\n\n let negate (x1, x2, x3) = Fp.(negate x1, negate x2, negate x3)\n\n let frobenius (c0, c1, c2) power =\n let open Fp in\n let open Info in\n let i = power mod 3 in\n (c0, frobenius_coeffs_c1.(i) * c1, frobenius_coeffs_c2.(i) * c2)\nend\n\nmodule Make_fp2\n (Fp : Intf) (Info : sig\n val non_residue : Fp.t\n end) : sig\n include Degree_2_extension_intf with type base = Fp.t and module Nat = Fp.Nat\nend = struct\n type base = Fp.t\n\n let of_base x = (x, Fp.zero)\n\n let componentwise f (x1, x2) (y1, y2) = (f x1 y1, f x2 y2)\n\n module T = struct\n type t = Fp.t * Fp.t [@@deriving eq, yojson, bin_io, sexp, compare, hash]\n\n module Nat = Fp.Nat\n\n let order = Nat.(Fp.order * Fp.order)\n\n let one = of_base Fp.one\n\n let zero = of_base Fp.zero\n\n let ( + ) = componentwise Fp.( + )\n\n let ( - ) = componentwise Fp.( - )\n\n let square (a, b) =\n let open Info in\n let ab = Fp.(a * b) in\n Fp.(((a + b) * (a + (non_residue * b))) - ab - (non_residue * ab), ab + ab)\n\n let ( * ) (a1, b1) (a2, b2) =\n let open Fp in\n let a = a1 * a2 in\n let b = b1 * b2 in\n (a + (Info.non_residue * b), ((a1 + b1) * (a2 + b2)) - a - b)\n\n let inv (a, b) =\n let open Fp in\n let t0 = square a in\n let t1 = square b in\n let t2 = t0 - (Info.non_residue * t1) in\n let t3 = inv t2 in\n let c0 = a * t3 in\n let c1 = negate (b * t3) in\n (c0, c1)\n\n let ( / ) x y = x * inv y\n end\n\n include T\n include Extend (T)\n\n let gen = Quickcheck.Generator.tuple2 Fp.gen Fp.gen\n\n let gen_incl (lo1, lo2) (hi1, hi2) =\n Quickcheck.Generator.tuple2 (Fp.gen_incl lo1 hi1) (Fp.gen_incl lo2 hi2)\n\n let gen_uniform = Quickcheck.Generator.tuple2 Fp.gen_uniform Fp.gen_uniform\n\n let gen_uniform_incl (lo1, lo2) (hi1, hi2) =\n Quickcheck.Generator.tuple2\n (Fp.gen_uniform_incl lo1 hi1)\n (Fp.gen_uniform_incl lo2 hi2)\n\n let random () = Quickcheck.random_value gen_uniform\n\n let to_list (x, y) = [ x; y ]\n\n let project_to_base (x, _) = x\n\n let parity = Fn.compose Fp.parity project_to_base\n\n let scale (x1, x2) s = Fp.(s * x1, s * x2)\n\n let negate (a, b) = Fp.(negate a, negate b)\nend\n\nmodule Make_fp6\n (N : Nat_intf.S)\n (Fp : Intf)\n (Fp2 : Degree_2_extension_intf with type base = Fp.t) (Fp3 : sig\n include Degree_3_extension_intf with type base = Fp.t\n\n val frobenius : t -> int -> t\n\n val non_residue : Fp.t\n end) (Info : sig\n val non_residue : Fp.t\n\n val frobenius_coeffs_c1 : Fp.t array\n end) : sig\n include Degree_2_extension_intf with type base = Fp3.t and module Nat = Fp.Nat\n\n val mul_by_2345 : t -> t -> t\n\n val frobenius : t -> int -> t\n\n val cyclotomic_exp : t -> N.t -> t\n\n val unitary_inverse : t -> t\nend = struct\n module T = struct\n module Nat = Fp.Nat\n\n let of_base x = (x, Fp3.zero)\n\n let componentwise f (x1, x2) (y1, y2) = (f x1 y1, f x2 y2)\n\n type t = Fp3.t * Fp3.t [@@deriving eq, yojson, bin_io, sexp, compare, hash]\n\n let order =\n let open Nat in\n let square x = x * x in\n let p = Fp.order in\n square (p * square p)\n\n let zero = of_base Fp3.zero\n\n let one = of_base Fp3.one\n\n let ( + ) = componentwise Fp3.( + )\n\n let ( - ) = componentwise Fp3.( - )\n\n let mul_by_non_residue ((c0, c1, c2) : Fp3.t) =\n Fp.(Info.non_residue * c2, c0, c1)\n\n let square (a, b) =\n let ab = Fp3.(a * b) in\n let open Fp3 in\n ( ((a + b) * (a + mul_by_non_residue b)) - ab - mul_by_non_residue ab\n , ab + ab )\n\n let ( * ) (a1, b1) (a2, b2) =\n let a = Fp3.(a1 * a2) in\n let b = Fp3.(b1 * b2) in\n let beta_b = mul_by_non_residue b in\n Fp3.(a + beta_b, ((a1 + b1) * (a2 + b2)) - a - b)\n\n let inv (a, b) =\n let t1 = Fp3.square b in\n let t0 = Fp3.(square a - mul_by_non_residue t1) in\n let new_t1 = Fp3.inv t0 in\n Fp3.(a * new_t1, negate (b * new_t1))\n\n let ( / ) x y = x * inv y\n end\n\n include T\n include Extend (T)\n\n type base = Fp3.t\n\n let gen = Quickcheck.Generator.tuple2 Fp3.gen Fp3.gen\n\n let gen_incl (lo1, lo2) (hi1, hi2) =\n Quickcheck.Generator.tuple2 (Fp3.gen_incl lo1 hi1) (Fp3.gen_incl lo2 hi2)\n\n let gen_uniform = Quickcheck.Generator.tuple2 Fp3.gen_uniform Fp3.gen_uniform\n\n let gen_uniform_incl (lo1, lo2) (hi1, hi2) =\n Quickcheck.Generator.tuple2\n (Fp3.gen_uniform_incl lo1 hi1)\n (Fp3.gen_uniform_incl lo2 hi2)\n\n let random () = Quickcheck.random_value gen_uniform\n\n let to_list (x, y) = [ x; y ]\n\n let project_to_base (x, _) = x\n\n let parity = Fn.compose Fp3.parity project_to_base\n\n let scale (x1, x2) s = Fp3.(s * x1, s * x2)\n\n let mul_by_2345 (a1, b1) (a2, b2) =\n let open Info in\n let a1_0, a1_1, a1_2 = a1 in\n let _, _, a2_2 = a2 in\n (let a2_0, a2_1, _ = a2 in\n assert (Fp.(equal a2_0 zero)) ;\n assert (Fp.(equal a2_1 zero)) ) ;\n let a =\n Fp.(a1_1 * a2_2 * non_residue, a1_2 * a2_2 * non_residue, a1_0 * a2_2)\n in\n let b = Fp3.(b1 * b2) in\n let beta_b = mul_by_non_residue b in\n Fp3.(a + beta_b, ((a1 + b2) * (a2 + b2)) - a - b)\n\n let negate (a, b) = Fp3.(negate a, negate b)\n\n let unitary_inverse (x, y) = (x, Fp3.negate y)\n\n let cyclotomic_square ((c00, c01, c02), (c10, c11, c12)) =\n let a : Fp2.t = (c00, c11) in\n let b : Fp2.t = (c10, c02) in\n let c : Fp2.t = (c01, c12) in\n let asq = Fp2.square a in\n let bsq = Fp2.square b in\n let csq = Fp2.square c in\n let a_a =\n let open Fp in\n let a_a = fst asq - fst a in\n a_a + a_a + fst asq\n in\n let a_b =\n let open Fp in\n let a_b = snd asq + snd a in\n a_b + a_b + snd asq\n in\n let b_a =\n let open Fp in\n let b_tmp = Fp3.non_residue * snd csq in\n let b_a = b_tmp + fst b in\n b_a + b_a + b_tmp\n in\n let b_b =\n let open Fp in\n let b_b = fst csq - snd b in\n b_b + b_b + fst csq\n in\n let c_a =\n let open Fp in\n let c_a = fst bsq - fst c in\n c_a + c_a + fst bsq\n in\n let c_b =\n let open Fp in\n let c_b = snd bsq + snd c in\n c_b + c_b + snd bsq\n in\n ((a_a, c_a, b_b), (b_a, a_b, c_b))\n\n let cyclotomic_exp x exponent =\n let x_inv = inv x in\n let naf = find_wnaf (module N) 1 exponent in\n let rec go found_nonzero res i =\n if i < 0 then res\n else\n let res = if found_nonzero then cyclotomic_square res else res in\n if naf.(i) <> 0 then\n let found_nonzero = true in\n let res = if naf.(i) > 0 then res * x else res * x_inv in\n go found_nonzero res Int.(i - 1)\n else go found_nonzero res Int.(i - 1)\n in\n go false one Int.(Array.length naf - 1)\n\n let frobenius (c0, c1) power =\n ( Fp3.frobenius c0 power\n , Fp3.(scale (frobenius c1 power) Info.frobenius_coeffs_c1.(power mod 6)) )\nend\n","open Core_kernel\nopen Kimchi_backend_common\nopen Kimchi_pasta_basic\nmodule Field = Fp\nmodule Curve = Vesta\n\nmodule Bigint = struct\n include Field.Bigint\n\n let of_data _ = failwith __LOC__\n\n let to_field = Field.of_bigint\n\n let of_field = Field.to_bigint\nend\n\nlet field_size : Bigint.t = Field.size\n\nmodule Verification_key = struct\n type t =\n ( Pasta_bindings.Fp.t\n , Kimchi_bindings.Protocol.SRS.Fp.t\n , Pasta_bindings.Fq.t Kimchi_types.or_infinity Kimchi_types.poly_comm )\n Kimchi_types.VerifierIndex.verifier_index\n\n let to_string _ = failwith __LOC__\n\n let of_string _ = failwith __LOC__\n\n let shifts (t : t) = t.shifts\nend\n\nmodule R1CS_constraint_system =\n Kimchi_pasta_constraint_system.Vesta_constraint_system\n\nlet lagrange srs domain_log2 : _ Kimchi_types.poly_comm array =\n let domain_size = Int.pow 2 domain_log2 in\n Array.init domain_size ~f:(fun i ->\n Kimchi_bindings.Protocol.SRS.Fp.lagrange_commitment srs domain_size i )\n\nlet with_lagrange f (vk : Verification_key.t) =\n f (lagrange vk.srs vk.domain.log_size_of_group) vk\n\nlet with_lagranges f (vks : Verification_key.t array) =\n let lgrs =\n Array.map vks ~f:(fun vk -> lagrange vk.srs vk.domain.log_size_of_group)\n in\n f lgrs vks\n\nmodule Rounds_vector = Rounds.Step_vector\nmodule Rounds = Rounds.Step\n\nmodule Keypair = Dlog_plonk_based_keypair.Make (struct\n let name = \"vesta\"\n\n module Rounds = Rounds\n module Urs = Kimchi_bindings.Protocol.SRS.Fp\n module Index = Kimchi_bindings.Protocol.Index.Fp\n module Curve = Curve\n module Poly_comm = Fp_poly_comm\n module Scalar_field = Field\n module Verifier_index = Kimchi_bindings.Protocol.VerifierIndex.Fp\n module Gate_vector = Kimchi_bindings.Protocol.Gates.Vector.Fp\n module Constraint_system = R1CS_constraint_system\nend)\n\nmodule Proof = Plonk_dlog_proof.Make (struct\n let id = \"pasta_vesta\"\n\n module Scalar_field = Field\n module Base_field = Fq\n\n module Backend = struct\n type t =\n ( Pasta_bindings.Fq.t Kimchi_types.or_infinity\n , Pasta_bindings.Fp.t )\n Kimchi_types.prover_proof\n\n include Kimchi_bindings.Protocol.Proof.Fp\n\n let batch_verify vks ts =\n Promise.run_in_thread (fun () -> batch_verify vks ts)\n\n let create_aux ~f:create (pk : Keypair.t) primary auxiliary prev_chals\n prev_comms =\n (* external values contains [1, primary..., auxiliary ] *)\n let external_values i =\n let open Field.Vector in\n if i < length primary then get primary i\n else get auxiliary (i - length primary)\n in\n\n (* compute witness *)\n let computed_witness =\n R1CS_constraint_system.compute_witness pk.cs external_values\n in\n let num_rows = Array.length computed_witness.(0) in\n\n (* convert to Rust vector *)\n let witness_cols =\n Array.init Kimchi_backend_common.Constants.columns ~f:(fun col ->\n let witness = Field.Vector.create () in\n for row = 0 to num_rows - 1 do\n Field.Vector.emplace_back witness computed_witness.(col).(row)\n done ;\n witness )\n in\n create pk.index witness_cols prev_chals prev_comms\n\n let create_async (pk : Keypair.t) primary auxiliary prev_chals prev_comms =\n create_aux pk primary auxiliary prev_chals prev_comms\n ~f:(fun pk auxiliary_input prev_challenges prev_sgs ->\n Promise.run_in_thread (fun () ->\n create pk auxiliary_input prev_challenges prev_sgs ) )\n\n let create_and_verify_async (pk : Keypair.t) primary auxiliary prev_chals\n prev_comms =\n create_aux pk primary auxiliary prev_chals prev_comms\n ~f:(fun pk auxiliary_input prev_challenges prev_sgs ->\n Promise.run_in_thread (fun () ->\n create_and_verify pk auxiliary_input prev_challenges prev_sgs ) )\n\n let create (pk : Keypair.t) primary auxiliary prev_chals prev_comms =\n create_aux pk primary auxiliary prev_chals prev_comms ~f:create\n end\n\n module Verifier_index = Kimchi_bindings.Protocol.VerifierIndex.Fp\n module Index = Keypair\n\n module Evaluations_backend = struct\n type t = Scalar_field.t Kimchi_types.proof_evaluations\n end\n\n module Opening_proof_backend = struct\n type t = (Curve.Affine.Backend.t, Scalar_field.t) Kimchi_types.opening_proof\n end\n\n module Poly_comm = Fp_poly_comm\n module Curve = Curve\nend)\n\nmodule Proving_key = struct\n type t = Keypair.t\n\n include\n Core_kernel.Binable.Of_binable\n (Core_kernel.Unit)\n (struct\n type nonrec t = t\n\n let to_binable _ = ()\n\n let of_binable () = failwith \"TODO\"\n end)\n\n let is_initialized _ = `Yes\n\n let set_constraint_system _ _ = ()\n\n let to_string _ = failwith \"TODO\"\n\n let of_string _ = failwith \"TODO\"\nend\n\nmodule Oracles = Plonk_dlog_oracles.Make (struct\n module Verifier_index = Verification_key\n module Field = Field\n module Proof = Proof\n\n module Backend = struct\n include Kimchi_bindings.Protocol.Oracles.Fp\n\n let create = with_lagrange create\n end\nend)\n","open Core_kernel\nopen Kimchi_backend_common\nopen Kimchi_pasta_basic\nmodule Field = Fq\nmodule Curve = Pallas\n\nmodule Bigint = struct\n include Field.Bigint\n\n let of_data _ = failwith __LOC__\n\n let to_field = Field.of_bigint\n\n let of_field = Field.to_bigint\nend\n\nlet field_size : Bigint.t = Field.size\n\nmodule Verification_key = struct\n type t =\n ( Pasta_bindings.Fq.t\n , Kimchi_bindings.Protocol.SRS.Fq.t\n , Pasta_bindings.Fp.t Kimchi_types.or_infinity Kimchi_types.poly_comm )\n Kimchi_types.VerifierIndex.verifier_index\n\n let to_string _ = failwith __LOC__\n\n let of_string _ = failwith __LOC__\n\n let shifts (t : t) : Field.t array = t.shifts\nend\n\n(* TODO: change name *)\nmodule R1CS_constraint_system =\n Kimchi_pasta_constraint_system.Pallas_constraint_system\n\nlet lagrange srs domain_log2 : _ Kimchi_types.poly_comm array =\n let domain_size = Int.pow 2 domain_log2 in\n Array.init domain_size ~f:(fun i ->\n Kimchi_bindings.Protocol.SRS.Fq.lagrange_commitment srs domain_size i )\n\nlet with_lagrange f (vk : Verification_key.t) =\n f (lagrange vk.srs vk.domain.log_size_of_group) vk\n\nlet with_lagranges f (vks : Verification_key.t array) =\n let lgrs =\n Array.map vks ~f:(fun vk -> lagrange vk.srs vk.domain.log_size_of_group)\n in\n f lgrs vks\n\nmodule Rounds_vector = Rounds.Wrap_vector\nmodule Rounds = Rounds.Wrap\n\nmodule Keypair = Dlog_plonk_based_keypair.Make (struct\n let name = \"pallas\"\n\n module Rounds = Rounds\n module Urs = Kimchi_bindings.Protocol.SRS.Fq\n module Index = Kimchi_bindings.Protocol.Index.Fq\n module Curve = Curve\n module Poly_comm = Fq_poly_comm\n module Scalar_field = Field\n module Verifier_index = Kimchi_bindings.Protocol.VerifierIndex.Fq\n module Gate_vector = Kimchi_bindings.Protocol.Gates.Vector.Fq\n module Constraint_system = R1CS_constraint_system\nend)\n\nmodule Proof = Plonk_dlog_proof.Make (struct\n let id = \"pasta_pallas\"\n\n module Scalar_field = Field\n module Base_field = Fp\n\n module Backend = struct\n type t =\n ( Pasta_bindings.Fp.t Kimchi_types.or_infinity\n , Pasta_bindings.Fq.t )\n Kimchi_types.prover_proof\n\n include Kimchi_bindings.Protocol.Proof.Fq\n\n let batch_verify vks ts =\n Promise.run_in_thread (fun () -> batch_verify vks ts)\n\n let create_aux ~f:create (pk : Keypair.t) primary auxiliary prev_chals\n prev_comms =\n (* external values contains [1, primary..., auxiliary ] *)\n let external_values i =\n let open Field.Vector in\n if i < length primary then get primary i\n else get auxiliary (i - length primary)\n in\n\n (* compute witness *)\n let computed_witness =\n R1CS_constraint_system.compute_witness pk.cs external_values\n in\n let num_rows = Array.length computed_witness.(0) in\n\n (* convert to Rust vector *)\n let witness_cols =\n Array.init Kimchi_backend_common.Constants.columns ~f:(fun col ->\n let witness = Field.Vector.create () in\n for row = 0 to num_rows - 1 do\n Field.Vector.emplace_back witness computed_witness.(col).(row)\n done ;\n witness )\n in\n create pk.index witness_cols prev_chals prev_comms\n\n let create_async (pk : Keypair.t) primary auxiliary prev_chals prev_comms =\n create_aux pk primary auxiliary prev_chals prev_comms\n ~f:(fun pk auxiliary_input prev_challenges prev_sgs ->\n Promise.run_in_thread (fun () ->\n create pk auxiliary_input prev_challenges prev_sgs ) )\n\n let create_and_verify_async (pk : Keypair.t) primary auxiliary prev_chals\n prev_comms =\n failwith \"not implemented\"\n (* TODO: Remove this function when vesta_based_plonk.create_and_verify_async is removed *)\n\n let create (pk : Keypair.t) primary auxiliary prev_chals prev_comms =\n create_aux pk primary auxiliary prev_chals prev_comms ~f:create\n end\n\n module Verifier_index = Kimchi_bindings.Protocol.VerifierIndex.Fq\n module Index = Keypair\n\n module Evaluations_backend = struct\n type t = Scalar_field.t Kimchi_types.proof_evaluations\n end\n\n module Opening_proof_backend = struct\n type t = (Curve.Affine.Backend.t, Scalar_field.t) Kimchi_types.opening_proof\n end\n\n module Poly_comm = Fq_poly_comm\n module Curve = Curve\nend)\n\nmodule Proving_key = struct\n type t = Keypair.t\n\n include\n Core_kernel.Binable.Of_binable\n (Core_kernel.Unit)\n (struct\n type nonrec t = t\n\n let to_binable _ = ()\n\n let of_binable () = failwith \"TODO\"\n end)\n\n let is_initialized _ = `Yes\n\n let set_constraint_system _ _ = ()\n\n let to_string _ = failwith \"TODO\"\n\n let of_string _ = failwith \"TODO\"\nend\n\nmodule Oracles = Plonk_dlog_oracles.Make (struct\n module Verifier_index = Verification_key\n module Field = Field\n module Proof = Proof\n\n module Backend = struct\n include Kimchi_bindings.Protocol.Oracles.Fq\n\n let create = with_lagrange create\n end\nend)\n","open Core_kernel\n\nmodule Make () = struct\n let digest_size_in_bits = 256\n\n let digest_size_in_bytes = digest_size_in_bits / 8\n\n module T0 = struct\n include Digestif.Make_BLAKE2B (struct\n let digest_size = digest_size_in_bytes\n end)\n\n let hash = Fn.compose String.hash to_raw_string\n\n let hash_fold_t state t = Hash.fold_string state (to_raw_string t)\n\n let compare = unsafe_compare\n\n let of_string = of_raw_string\n\n let to_string = to_raw_string\n\n let gen =\n let char_generator =\n Base_quickcheck.Generator.of_list\n [ '0'\n ; '1'\n ; '2'\n ; '3'\n ; '4'\n ; '5'\n ; '6'\n ; '7'\n ; '8'\n ; '9'\n ; 'A'\n ; 'B'\n ; 'C'\n ; 'D'\n ; 'E'\n ; 'F'\n ]\n in\n String.gen_with_length (digest_size_in_bytes * 2) char_generator\n |> Quickcheck.Generator.map ~f:of_hex\n end\n\n module T1 = struct\n include T0\n include Sexpable.Of_stringable (T0)\n end\n\n [%%versioned_binable\n module Stable = struct\n module V1 = struct\n type t = T1.t [@@deriving hash, sexp, compare, equal]\n\n let to_latest = Fn.id\n\n let to_yojson t : Yojson.Safe.t = `String (T1.to_hex t)\n\n let of_yojson (v : Yojson.Safe.t) =\n let open Ppx_deriving_yojson_runtime in\n match v with\n | `String s ->\n Option.value_map ~default:(Result.Error \"not a hex string\")\n ~f:(fun x -> Result.Ok x)\n (T1.of_hex_opt s)\n | _ ->\n Result.Error \"not a string\"\n\n module Arg = struct\n type nonrec t = t\n\n [%%define_locally T1.(to_string, of_string)]\n end\n\n include Binable.Of_stringable_without_uuid (Arg)\n end\n end]\n\n [%%define_locally Stable.Latest.(to_yojson, of_yojson)]\n\n [%%define_locally\n T1.\n ( of_raw_string\n , to_raw_string\n , digest_string\n , digest_bigstring\n , to_hex\n , of_hex\n , gen )]\n\n (* do not create bin_io serialization *)\n include Hashable.Make (T1)\n include Comparable.Make (T1)\n\n (* Little endian *)\n let bits_to_string bits =\n let n = Array.length bits in\n let rec make_byte offset acc (i : int) =\n let finished = Int.(i = 8 || offset + i >= n) in\n if finished then Char.of_int_exn acc\n else\n let acc = if bits.(offset + i) then acc lor (1 lsl i) else acc in\n make_byte offset acc (i + 1)\n in\n let len = (n + 7) / 8 in\n String.init len ~f:(fun i -> make_byte (8 * i) 0 0)\n\n let string_to_bits s =\n Array.init\n (8 * String.length s)\n ~f:(fun i ->\n let c = Char.to_int s.[i / 8] in\n let j = i mod 8 in\n Int.((c lsr j) land 1 = 1) )\nend\n\ninclude Make ()\n\nlet%test_unit \"bits_to_string\" =\n [%test_eq: string]\n (bits_to_string [| true; false |])\n (String.of_char_list [ Char.of_int_exn 1 ])\n\nlet%test_unit \"string to bits\" =\n Quickcheck.test ~trials:5 String.quickcheck_generator ~f:(fun s ->\n [%test_eq: string] s (bits_to_string (string_to_bits s)) )\n","(**************************************************************************)\n(* *)\n(* OCaml Migrate Parsetree *)\n(* *)\n(* Frédéric Bour, Facebook *)\n(* Jérémie Dimino and Leo White, Jane Street Europe *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* Alain Frisch, LexiFi *)\n(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 2018 Institut National de Recherche en Informatique et *)\n(* en Automatique (INRIA). *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nmodule Asttypes = struct\n type constant (*IF_CURRENT = Asttypes.constant *) =\n Const_int of int\n | Const_char of char\n | Const_string of string * Location.t * string option\n | Const_float of string\n | Const_int32 of int32\n | Const_int64 of int64\n | Const_nativeint of nativeint\n\n type rec_flag (*IF_CURRENT = Asttypes.rec_flag *) = Nonrecursive | Recursive\n\n type direction_flag (*IF_CURRENT = Asttypes.direction_flag *) = Upto | Downto\n\n (* Order matters, used in polymorphic comparison *)\n type private_flag (*IF_CURRENT = Asttypes.private_flag *) = Private | Public\n\n type mutable_flag (*IF_CURRENT = Asttypes.mutable_flag *) = Immutable | Mutable\n\n type virtual_flag (*IF_CURRENT = Asttypes.virtual_flag *) = Virtual | Concrete\n\n type override_flag (*IF_CURRENT = Asttypes.override_flag *) = Override | Fresh\n\n type closed_flag (*IF_CURRENT = Asttypes.closed_flag *) = Closed | Open\n\n type label = string\n\n type arg_label (*IF_CURRENT = Asttypes.arg_label *) =\n Nolabel\n | Labelled of string (* label:T -> ... *)\n | Optional of string (* ?label:T -> ... *)\n\n type 'a loc = 'a Location.loc = {\n txt : 'a;\n loc : Location.t;\n }\n\n type variance (*IF_CURRENT = Asttypes.variance *) =\n | Covariant\n | Contravariant\n | NoVariance\n\n type injectivity (*IF_CURRENT = Asttypes.injectivity *) =\n | Injective\n | NoInjectivity\nend\n\nmodule Parsetree = struct\n open Asttypes\n\n type constant (*IF_CURRENT = Parsetree.constant *) =\n Pconst_integer of string * char option\n (* 3 3l 3L 3n\n\n Suffixes [g-z][G-Z] are accepted by the parser.\n Suffixes except 'l', 'L' and 'n' are rejected by the typechecker\n *)\n | Pconst_char of char\n (* 'c' *)\n | Pconst_string of string * Location.t * string option\n (* \"constant\"\n {delim|other constant|delim}\n\n The location span the content of the string, without the delimiters.\n *)\n | Pconst_float of string * char option\n (* 3.4 2e5 1.4e-4\n\n Suffixes [g-z][G-Z] are accepted by the parser.\n Suffixes are rejected by the typechecker.\n *)\n\n type location_stack = Location.t list\n\n (** {1 Extension points} *)\n\n type attribute (*IF_CURRENT = Parsetree.attribute *) = {\n attr_name : string loc;\n attr_payload : payload;\n attr_loc : Location.t;\n }\n (* [@id ARG]\n [@@id ARG]\n\n Metadata containers passed around within the AST.\n The compiler ignores unknown attributes.\n *)\n\n and extension = string loc * payload\n (* [%id ARG]\n [%%id ARG]\n\n Sub-language placeholder -- rejected by the typechecker.\n *)\n\n and attributes = attribute list\n\n and payload (*IF_CURRENT = Parsetree.payload *) =\n | PStr of structure\n | PSig of signature (* : SIG *)\n | PTyp of core_type (* : T *)\n | PPat of pattern * expression option (* ? P or ? P when E *)\n\n (** {1 Core language} *)\n\n (* Type expressions *)\n\n and core_type (*IF_CURRENT = Parsetree.core_type *) =\n {\n ptyp_desc: core_type_desc;\n ptyp_loc: Location.t;\n ptyp_loc_stack: location_stack;\n ptyp_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and core_type_desc (*IF_CURRENT = Parsetree.core_type_desc *) =\n | Ptyp_any\n (* _ *)\n | Ptyp_var of string\n (* 'a *)\n | Ptyp_arrow of arg_label * core_type * core_type\n (* T1 -> T2 Simple\n ~l:T1 -> T2 Labelled\n ?l:T1 -> T2 Optional\n *)\n | Ptyp_tuple of core_type list\n (* T1 * ... * Tn\n\n Invariant: n >= 2\n *)\n | Ptyp_constr of Longident.t loc * core_type list\n (* tconstr\n T tconstr\n (T1, ..., Tn) tconstr\n *)\n | Ptyp_object of object_field list * closed_flag\n (* < l1:T1; ...; ln:Tn > (flag = Closed)\n < l1:T1; ...; ln:Tn; .. > (flag = Open)\n *)\n | Ptyp_class of Longident.t loc * core_type list\n (* #tconstr\n T #tconstr\n (T1, ..., Tn) #tconstr\n *)\n | Ptyp_alias of core_type * string\n (* T as 'a *)\n | Ptyp_variant of row_field list * closed_flag * label list option\n (* [ `A|`B ] (flag = Closed; labels = None)\n [> `A|`B ] (flag = Open; labels = None)\n [< `A|`B ] (flag = Closed; labels = Some [])\n [< `A|`B > `X `Y ](flag = Closed; labels = Some [\"X\";\"Y\"])\n *)\n | Ptyp_poly of string loc list * core_type\n (* 'a1 ... 'an. T\n\n Can only appear in the following context:\n\n - As the core_type of a Ppat_constraint node corresponding\n to a constraint on a let-binding: let x : 'a1 ... 'an. T\n = e ...\n\n - Under Cfk_virtual for methods (not values).\n\n - As the core_type of a Pctf_method node.\n\n - As the core_type of a Pexp_poly node.\n\n - As the pld_type field of a label_declaration.\n\n - As a core_type of a Ptyp_object node.\n *)\n\n | Ptyp_package of package_type\n (* (module S) *)\n | Ptyp_extension of extension\n (* [%id] *)\n\n and package_type = Longident.t loc * (Longident.t loc * core_type) list\n (*\n (module S)\n (module S with type t1 = T1 and ... and tn = Tn)\n *)\n\n and row_field (*IF_CURRENT = Parsetree.row_field *) = {\n prf_desc : row_field_desc;\n prf_loc : Location.t;\n prf_attributes : attributes;\n }\n\n and row_field_desc (*IF_CURRENT = Parsetree.row_field_desc *) =\n | Rtag of label loc * bool * core_type list\n (* [`A] ( true, [] )\n [`A of T] ( false, [T] )\n [`A of T1 & .. & Tn] ( false, [T1;...Tn] )\n [`A of & T1 & .. & Tn] ( true, [T1;...Tn] )\n\n - The 'bool' field is true if the tag contains a\n constant (empty) constructor.\n - '&' occurs when several types are used for the same constructor\n (see 4.2 in the manual)\n *)\n | Rinherit of core_type\n (* [ T ] *)\n\n and object_field (*IF_CURRENT = Parsetree.object_field *) = {\n pof_desc : object_field_desc;\n pof_loc : Location.t;\n pof_attributes : attributes;\n }\n\n and object_field_desc (*IF_CURRENT = Parsetree.object_field_desc *) =\n | Otag of label loc * core_type\n | Oinherit of core_type\n\n (* Patterns *)\n\n and pattern (*IF_CURRENT = Parsetree.pattern *) =\n {\n ppat_desc: pattern_desc;\n ppat_loc: Location.t;\n ppat_loc_stack: location_stack;\n ppat_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and pattern_desc (*IF_CURRENT = Parsetree.pattern_desc *) =\n | Ppat_any\n (* _ *)\n | Ppat_var of string loc\n (* x *)\n | Ppat_alias of pattern * string loc\n (* P as 'a *)\n | Ppat_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Ppat_interval of constant * constant\n (* 'a'..'z'\n\n Other forms of interval are recognized by the parser\n but rejected by the type-checker. *)\n | Ppat_tuple of pattern list\n (* (P1, ..., Pn)\n\n Invariant: n >= 2\n *)\n | Ppat_construct of Longident.t loc * pattern option\n (* C None\n C P Some P\n C (P1, ..., Pn) Some (Ppat_tuple [P1; ...; Pn])\n *)\n | Ppat_variant of label * pattern option\n (* `A (None)\n `A P (Some P)\n *)\n | Ppat_record of (Longident.t loc * pattern) list * closed_flag\n (* { l1=P1; ...; ln=Pn } (flag = Closed)\n { l1=P1; ...; ln=Pn; _} (flag = Open)\n\n Invariant: n > 0\n *)\n | Ppat_array of pattern list\n (* [| P1; ...; Pn |] *)\n | Ppat_or of pattern * pattern\n (* P1 | P2 *)\n | Ppat_constraint of pattern * core_type\n (* (P : T) *)\n | Ppat_type of Longident.t loc\n (* #tconst *)\n | Ppat_lazy of pattern\n (* lazy P *)\n | Ppat_unpack of string option loc\n (* (module P) Some \"P\"\n (module _) None\n\n Note: (module P : S) is represented as\n Ppat_constraint(Ppat_unpack, Ptyp_package)\n *)\n | Ppat_exception of pattern\n (* exception P *)\n | Ppat_extension of extension\n (* [%id] *)\n | Ppat_open of Longident.t loc * pattern\n (* M.(P) *)\n\n (* Value expressions *)\n\n and expression (*IF_CURRENT = Parsetree.expression *) =\n {\n pexp_desc: expression_desc;\n pexp_loc: Location.t;\n pexp_loc_stack: location_stack;\n pexp_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and expression_desc (*IF_CURRENT = Parsetree.expression_desc *) =\n | Pexp_ident of Longident.t loc\n (* x\n M.x\n *)\n | Pexp_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Pexp_let of rec_flag * value_binding list * expression\n (* let P1 = E1 and ... and Pn = EN in E (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in E (flag = Recursive)\n *)\n | Pexp_function of case list\n (* function P1 -> E1 | ... | Pn -> En *)\n | Pexp_fun of arg_label * expression option * pattern * expression\n (* fun P -> E1 (Simple, None)\n fun ~l:P -> E1 (Labelled l, None)\n fun ?l:P -> E1 (Optional l, None)\n fun ?l:(P = E0) -> E1 (Optional l, Some E0)\n\n Notes:\n - If E0 is provided, only Optional is allowed.\n - \"fun P1 P2 .. Pn -> E1\" is represented as nested Pexp_fun.\n - \"let f P = E\" is represented using Pexp_fun.\n *)\n | Pexp_apply of expression * (arg_label * expression) list\n (* E0 ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pexp_match of expression * case list\n (* match E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_try of expression * case list\n (* try E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_tuple of expression list\n (* (E1, ..., En)\n\n Invariant: n >= 2\n *)\n | Pexp_construct of Longident.t loc * expression option\n (* C None\n C E Some E\n C (E1, ..., En) Some (Pexp_tuple[E1;...;En])\n *)\n | Pexp_variant of label * expression option\n (* `A (None)\n `A E (Some E)\n *)\n | Pexp_record of (Longident.t loc * expression) list * expression option\n (* { l1=P1; ...; ln=Pn } (None)\n { E0 with l1=P1; ...; ln=Pn } (Some E0)\n\n Invariant: n > 0\n *)\n | Pexp_field of expression * Longident.t loc\n (* E.l *)\n | Pexp_setfield of expression * Longident.t loc * expression\n (* E1.l <- E2 *)\n | Pexp_array of expression list\n (* [| E1; ...; En |] *)\n | Pexp_ifthenelse of expression * expression * expression option\n (* if E1 then E2 else E3 *)\n | Pexp_sequence of expression * expression\n (* E1; E2 *)\n | Pexp_while of expression * expression\n (* while E1 do E2 done *)\n | Pexp_for of\n pattern * expression * expression * direction_flag * expression\n (* for i = E1 to E2 do E3 done (flag = Upto)\n for i = E1 downto E2 do E3 done (flag = Downto)\n *)\n | Pexp_constraint of expression * core_type\n (* (E : T) *)\n | Pexp_coerce of expression * core_type option * core_type\n (* (E :> T) (None, T)\n (E : T0 :> T) (Some T0, T)\n *)\n | Pexp_send of expression * label loc\n (* E # m *)\n | Pexp_new of Longident.t loc\n (* new M.c *)\n | Pexp_setinstvar of label loc * expression\n (* x <- 2 *)\n | Pexp_override of (label loc * expression) list\n (* {< x1 = E1; ...; Xn = En >} *)\n | Pexp_letmodule of string option loc * module_expr * expression\n (* let module M = ME in E *)\n | Pexp_letexception of extension_constructor * expression\n (* let exception C in E *)\n | Pexp_assert of expression\n (* assert E\n Note: \"assert false\" is treated in a special way by the\n type-checker. *)\n | Pexp_lazy of expression\n (* lazy E *)\n | Pexp_poly of expression * core_type option\n (* Used for method bodies.\n\n Can only be used as the expression under Cfk_concrete\n for methods (not values). *)\n | Pexp_object of class_structure\n (* object ... end *)\n | Pexp_newtype of string loc * expression\n (* fun (type t) -> E *)\n | Pexp_pack of module_expr\n (* (module ME)\n\n (module ME : S) is represented as\n Pexp_constraint(Pexp_pack, Ptyp_package S) *)\n | Pexp_open of open_declaration * expression\n (* M.(E)\n let open M in E\n let! open M in E *)\n | Pexp_letop of letop\n (* let* P = E in E\n let* P = E and* P = E in E *)\n | Pexp_extension of extension\n (* [%id] *)\n | Pexp_unreachable\n (* . *)\n\n and case (*IF_CURRENT = Parsetree.case *) = (* (P -> E) or (P when E0 -> E) *)\n {\n pc_lhs: pattern;\n pc_guard: expression option;\n pc_rhs: expression;\n }\n\n and letop (*IF_CURRENT = Parsetree.letop *) =\n {\n let_ : binding_op;\n ands : binding_op list;\n body : expression;\n }\n\n and binding_op (*IF_CURRENT = Parsetree.binding_op *) =\n {\n pbop_op : string loc;\n pbop_pat : pattern;\n pbop_exp : expression;\n pbop_loc : Location.t;\n }\n\n (* Value descriptions *)\n\n and value_description (*IF_CURRENT = Parsetree.value_description *) =\n {\n pval_name: string loc;\n pval_type: core_type;\n pval_prim: string list;\n pval_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pval_loc: Location.t;\n }\n\n(*\n val x: T (prim = [])\n external x: T = \"s1\" ... \"sn\" (prim = [\"s1\";...\"sn\"])\n*)\n\n (* Type declarations *)\n\n and type_declaration (*IF_CURRENT = Parsetree.type_declaration *) =\n {\n ptype_name: string loc;\n ptype_params: (core_type * (variance * injectivity)) list;\n (* ('a1,...'an) t; None represents _*)\n ptype_cstrs: (core_type * core_type * Location.t) list;\n (* ... constraint T1=T1' ... constraint Tn=Tn' *)\n ptype_kind: type_kind;\n ptype_private: private_flag; (* = private ... *)\n ptype_manifest: core_type option; (* = T *)\n ptype_attributes: attributes; (* ... [@@id1] [@@id2] *)\n ptype_loc: Location.t;\n }\n\n(*\n type t (abstract, no manifest)\n type t = T0 (abstract, manifest=T0)\n type t = C of T | ... (variant, no manifest)\n type t = T0 = C of T | ... (variant, manifest=T0)\n type t = {l: T; ...} (record, no manifest)\n type t = T0 = {l : T; ...} (record, manifest=T0)\n type t = .. (open, no manifest)\n*)\n\n and type_kind (*IF_CURRENT = Parsetree.type_kind *) =\n | Ptype_abstract\n | Ptype_variant of constructor_declaration list\n | Ptype_record of label_declaration list\n (* Invariant: non-empty list *)\n | Ptype_open\n\n and label_declaration (*IF_CURRENT = Parsetree.label_declaration *) =\n {\n pld_name: string loc;\n pld_mutable: mutable_flag;\n pld_type: core_type;\n pld_loc: Location.t;\n pld_attributes: attributes; (* l : T [@id1] [@id2] *)\n }\n\n (* { ...; l: T; ... } (mutable=Immutable)\n { ...; mutable l: T; ... } (mutable=Mutable)\n\n Note: T can be a Ptyp_poly.\n *)\n\n and constructor_declaration (*IF_CURRENT = Parsetree.constructor_declaration *) =\n {\n pcd_name: string loc;\n pcd_args: constructor_arguments;\n pcd_res: core_type option;\n pcd_loc: Location.t;\n pcd_attributes: attributes; (* C of ... [@id1] [@id2] *)\n }\n\n and constructor_arguments (*IF_CURRENT = Parsetree.constructor_arguments *) =\n | Pcstr_tuple of core_type list\n | Pcstr_record of label_declaration list\n\n(*\n | C of T1 * ... * Tn (res = None, args = Pcstr_tuple [])\n | C: T0 (res = Some T0, args = [])\n | C: T1 * ... * Tn -> T0 (res = Some T0, args = Pcstr_tuple)\n | C of {...} (res = None, args = Pcstr_record)\n | C: {...} -> T0 (res = Some T0, args = Pcstr_record)\n | C of {...} as t (res = None, args = Pcstr_record)\n*)\n\n and type_extension (*IF_CURRENT = Parsetree.type_extension *) =\n {\n ptyext_path: Longident.t loc;\n ptyext_params: (core_type * (variance * injectivity)) list;\n ptyext_constructors: extension_constructor list;\n ptyext_private: private_flag;\n ptyext_loc: Location.t;\n ptyext_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n(*\n type t += ...\n*)\n\n and extension_constructor (*IF_CURRENT = Parsetree.extension_constructor *) =\n {\n pext_name: string loc;\n pext_kind : extension_constructor_kind;\n pext_loc : Location.t;\n pext_attributes: attributes; (* C of ... [@id1] [@id2] *)\n }\n\n (* exception E *)\n and type_exception (*IF_CURRENT = Parsetree.type_exception *) =\n {\n ptyexn_constructor: extension_constructor;\n ptyexn_loc: Location.t;\n ptyexn_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and extension_constructor_kind (*IF_CURRENT = Parsetree.extension_constructor_kind *) =\n Pext_decl of constructor_arguments * core_type option\n (*\n | C of T1 * ... * Tn ([T1; ...; Tn], None)\n | C: T0 ([], Some T0)\n | C: T1 * ... * Tn -> T0 ([T1; ...; Tn], Some T0)\n *)\n | Pext_rebind of Longident.t loc\n (*\n | C = D\n *)\n\n (** {1 Class language} *)\n\n (* Type expressions for the class language *)\n\n and class_type (*IF_CURRENT = Parsetree.class_type *) =\n {\n pcty_desc: class_type_desc;\n pcty_loc: Location.t;\n pcty_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and class_type_desc (*IF_CURRENT = Parsetree.class_type_desc *) =\n | Pcty_constr of Longident.t loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcty_signature of class_signature\n (* object ... end *)\n | Pcty_arrow of arg_label * core_type * class_type\n (* T -> CT Simple\n ~l:T -> CT Labelled l\n ?l:T -> CT Optional l\n *)\n | Pcty_extension of extension\n (* [%id] *)\n | Pcty_open of open_description * class_type\n (* let open M in CT *)\n\n and class_signature (*IF_CURRENT = Parsetree.class_signature *) =\n {\n pcsig_self: core_type;\n pcsig_fields: class_type_field list;\n }\n (* object('selfpat) ... end\n object ... end (self = Ptyp_any)\n *)\n\n and class_type_field (*IF_CURRENT = Parsetree.class_type_field *) =\n {\n pctf_desc: class_type_field_desc;\n pctf_loc: Location.t;\n pctf_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and class_type_field_desc (*IF_CURRENT = Parsetree.class_type_field_desc *) =\n | Pctf_inherit of class_type\n (* inherit CT *)\n | Pctf_val of (label loc * mutable_flag * virtual_flag * core_type)\n (* val x: T *)\n | Pctf_method of (label loc * private_flag * virtual_flag * core_type)\n (* method x: T\n\n Note: T can be a Ptyp_poly.\n *)\n | Pctf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pctf_attribute of attribute\n (* [@@@id] *)\n | Pctf_extension of extension\n (* [%%id] *)\n\n and 'a class_infos (*IF_CURRENT = 'a Parsetree.class_infos *) =\n {\n pci_virt: virtual_flag;\n pci_params: (core_type * (variance * injectivity)) list;\n pci_name: string loc;\n pci_expr: 'a;\n pci_loc: Location.t;\n pci_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n (* class c = ...\n class ['a1,...,'an] c = ...\n class virtual c = ...\n\n Also used for \"class type\" declaration.\n *)\n\n and class_description = class_type class_infos\n\n and class_type_declaration = class_type class_infos\n\n (* Value expressions for the class language *)\n\n and class_expr (*IF_CURRENT = Parsetree.class_expr *) =\n {\n pcl_desc: class_expr_desc;\n pcl_loc: Location.t;\n pcl_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and class_expr_desc (*IF_CURRENT = Parsetree.class_expr_desc *) =\n | Pcl_constr of Longident.t loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcl_structure of class_structure\n (* object ... end *)\n | Pcl_fun of arg_label * expression option * pattern * class_expr\n (* fun P -> CE (Simple, None)\n fun ~l:P -> CE (Labelled l, None)\n fun ?l:P -> CE (Optional l, None)\n fun ?l:(P = E0) -> CE (Optional l, Some E0)\n *)\n | Pcl_apply of class_expr * (arg_label * expression) list\n (* CE ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pcl_let of rec_flag * value_binding list * class_expr\n (* let P1 = E1 and ... and Pn = EN in CE (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in CE (flag = Recursive)\n *)\n | Pcl_constraint of class_expr * class_type\n (* (CE : CT) *)\n | Pcl_extension of extension\n (* [%id] *)\n | Pcl_open of open_description * class_expr\n (* let open M in CE *)\n\n\n and class_structure (*IF_CURRENT = Parsetree.class_structure *) =\n {\n pcstr_self: pattern;\n pcstr_fields: class_field list;\n }\n (* object(selfpat) ... end\n object ... end (self = Ppat_any)\n *)\n\n and class_field (*IF_CURRENT = Parsetree.class_field *) =\n {\n pcf_desc: class_field_desc;\n pcf_loc: Location.t;\n pcf_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and class_field_desc (*IF_CURRENT = Parsetree.class_field_desc *) =\n | Pcf_inherit of override_flag * class_expr * string loc option\n (* inherit CE\n inherit CE as x\n inherit! CE\n inherit! CE as x\n *)\n | Pcf_val of (label loc * mutable_flag * class_field_kind)\n (* val x = E\n val virtual x: T\n *)\n | Pcf_method of (label loc * private_flag * class_field_kind)\n (* method x = E (E can be a Pexp_poly)\n method virtual x: T (T can be a Ptyp_poly)\n *)\n | Pcf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pcf_initializer of expression\n (* initializer E *)\n | Pcf_attribute of attribute\n (* [@@@id] *)\n | Pcf_extension of extension\n (* [%%id] *)\n\n and class_field_kind (*IF_CURRENT = Parsetree.class_field_kind *) =\n | Cfk_virtual of core_type\n | Cfk_concrete of override_flag * expression\n\n and class_declaration = class_expr class_infos\n\n (** {1 Module language} *)\n\n (* Type expressions for the module language *)\n\n and module_type (*IF_CURRENT = Parsetree.module_type *) =\n {\n pmty_desc: module_type_desc;\n pmty_loc: Location.t;\n pmty_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and module_type_desc (*IF_CURRENT = Parsetree.module_type_desc *) =\n | Pmty_ident of Longident.t loc\n (* S *)\n | Pmty_signature of signature\n (* sig ... end *)\n | Pmty_functor of functor_parameter * module_type\n (* functor(X : MT1) -> MT2 *)\n | Pmty_with of module_type * with_constraint list\n (* MT with ... *)\n | Pmty_typeof of module_expr\n (* module type of ME *)\n | Pmty_extension of extension\n (* [%id] *)\n | Pmty_alias of Longident.t loc\n (* (module M) *)\n\n and functor_parameter (*IF_CURRENT = Parsetree.functor_parameter *) =\n | Unit\n (* () *)\n | Named of string option loc * module_type\n (* (X : MT) Some X, MT\n (_ : MT) None, MT *)\n\n and signature = signature_item list\n\n and signature_item (*IF_CURRENT = Parsetree.signature_item *) =\n {\n psig_desc: signature_item_desc;\n psig_loc: Location.t;\n }\n\n and signature_item_desc (*IF_CURRENT = Parsetree.signature_item_desc *) =\n | Psig_value of value_description\n (*\n val x: T\n external x: T = \"s1\" ... \"sn\"\n *)\n | Psig_type of rec_flag * type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Psig_typesubst of type_declaration list\n (* type t1 := ... and ... and tn := ... *)\n | Psig_typext of type_extension\n (* type t1 += ... *)\n | Psig_exception of type_exception\n (* exception C of T *)\n | Psig_module of module_declaration\n (* module X = M\n module X : MT *)\n | Psig_modsubst of module_substitution\n (* module X := M *)\n | Psig_recmodule of module_declaration list\n (* module rec X1 : MT1 and ... and Xn : MTn *)\n | Psig_modtype of module_type_declaration\n (* module type S = MT\n module type S *)\n | Psig_open of open_description\n (* open X *)\n | Psig_include of include_description\n (* include MT *)\n | Psig_class of class_description list\n (* class c1 : ... and ... and cn : ... *)\n | Psig_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Psig_attribute of attribute\n (* [@@@id] *)\n | Psig_extension of extension * attributes\n (* [%%id] *)\n\n and module_declaration (*IF_CURRENT = Parsetree.module_declaration *) =\n {\n pmd_name: string option loc;\n pmd_type: module_type;\n pmd_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pmd_loc: Location.t;\n }\n (* S : MT *)\n\n and module_substitution (*IF_CURRENT = Parsetree.module_substitution *) =\n {\n pms_name: string loc;\n pms_manifest: Longident.t loc;\n pms_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pms_loc: Location.t;\n }\n\n and module_type_declaration (*IF_CURRENT = Parsetree.module_type_declaration *) =\n {\n pmtd_name: string loc;\n pmtd_type: module_type option;\n pmtd_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pmtd_loc: Location.t;\n }\n (* S = MT\n S (abstract module type declaration, pmtd_type = None)\n *)\n\n and 'a open_infos (*IF_CURRENT = 'a Parsetree.open_infos *) =\n {\n popen_expr: 'a;\n popen_override: override_flag;\n popen_loc: Location.t;\n popen_attributes: attributes;\n }\n (* open! X - popen_override = Override (silences the 'used identifier\n shadowing' warning)\n open X - popen_override = Fresh\n *)\n\n and open_description = Longident.t loc open_infos\n (* open M.N\n open M(N).O *)\n\n and open_declaration = module_expr open_infos\n (* open M.N\n open M(N).O\n open struct ... end *)\n\n and 'a include_infos (*IF_CURRENT = 'a Parsetree.include_infos *) =\n {\n pincl_mod: 'a;\n pincl_loc: Location.t;\n pincl_attributes: attributes;\n }\n\n and include_description = module_type include_infos\n (* include MT *)\n\n and include_declaration = module_expr include_infos\n (* include ME *)\n\n and with_constraint (*IF_CURRENT = Parsetree.with_constraint *) =\n | Pwith_type of Longident.t loc * type_declaration\n (* with type X.t = ...\n\n Note: the last component of the longident must match\n the name of the type_declaration. *)\n | Pwith_module of Longident.t loc * Longident.t loc\n (* with module X.Y = Z *)\n | Pwith_typesubst of Longident.t loc * type_declaration\n (* with type X.t := ..., same format as [Pwith_type] *)\n | Pwith_modsubst of Longident.t loc * Longident.t loc\n (* with module X.Y := Z *)\n\n (* Value expressions for the module language *)\n\n and module_expr (*IF_CURRENT = Parsetree.module_expr *) =\n {\n pmod_desc: module_expr_desc;\n pmod_loc: Location.t;\n pmod_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and module_expr_desc (*IF_CURRENT = Parsetree.module_expr_desc *) =\n | Pmod_ident of Longident.t loc\n (* X *)\n | Pmod_structure of structure\n (* struct ... end *)\n | Pmod_functor of functor_parameter * module_expr\n (* functor(X : MT1) -> ME *)\n | Pmod_apply of module_expr * module_expr\n (* ME1(ME2) *)\n | Pmod_constraint of module_expr * module_type\n (* (ME : MT) *)\n | Pmod_unpack of expression\n (* (val E) *)\n | Pmod_extension of extension\n (* [%id] *)\n\n and structure = structure_item list\n\n and structure_item (*IF_CURRENT = Parsetree.structure_item *) =\n {\n pstr_desc: structure_item_desc;\n pstr_loc: Location.t;\n }\n\n and structure_item_desc (*IF_CURRENT = Parsetree.structure_item_desc *) =\n | Pstr_eval of expression * attributes\n (* E *)\n | Pstr_value of rec_flag * value_binding list\n (* let P1 = E1 and ... and Pn = EN (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN (flag = Recursive)\n *)\n | Pstr_primitive of value_description\n (* val x: T\n external x: T = \"s1\" ... \"sn\" *)\n | Pstr_type of rec_flag * type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Pstr_typext of type_extension\n (* type t1 += ... *)\n | Pstr_exception of type_exception\n (* exception C of T\n exception C = M.X *)\n | Pstr_module of module_binding\n (* module X = ME *)\n | Pstr_recmodule of module_binding list\n (* module rec X1 = ME1 and ... and Xn = MEn *)\n | Pstr_modtype of module_type_declaration\n (* module type S = MT *)\n | Pstr_open of open_declaration\n (* open X *)\n | Pstr_class of class_declaration list\n (* class c1 = ... and ... and cn = ... *)\n | Pstr_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Pstr_include of include_declaration\n (* include ME *)\n | Pstr_attribute of attribute\n (* [@@@id] *)\n | Pstr_extension of extension * attributes\n (* [%%id] *)\n\n and value_binding (*IF_CURRENT = Parsetree.value_binding *) =\n {\n pvb_pat: pattern;\n pvb_expr: expression;\n pvb_attributes: attributes;\n pvb_loc: Location.t;\n }\n\n and module_binding (*IF_CURRENT = Parsetree.module_binding *) =\n {\n pmb_name: string option loc;\n pmb_expr: module_expr;\n pmb_attributes: attributes;\n pmb_loc: Location.t;\n }\n (* X = ME *)\n\n (** {1 Toplevel} *)\n\n (* Toplevel phrases *)\n\n type toplevel_phrase (*IF_CURRENT = Parsetree.toplevel_phrase *) =\n | Ptop_def of structure\n | Ptop_dir of toplevel_directive\n (* #use, #load ... *)\n\n and toplevel_directive (*IF_CURRENT = Parsetree.toplevel_directive *) =\n {\n pdir_name : string loc;\n pdir_arg : directive_argument option;\n pdir_loc : Location.t;\n }\n\n and directive_argument (*IF_CURRENT = Parsetree.directive_argument *) =\n {\n pdira_desc : directive_argument_desc;\n pdira_loc : Location.t;\n }\n\n and directive_argument_desc (*IF_CURRENT = Parsetree.directive_argument_desc *) =\n | Pdir_string of string\n | Pdir_int of string * char option\n | Pdir_ident of Longident.t\n | Pdir_bool of bool\nend\n\nmodule Config = struct\n let ast_impl_magic_number = \"Caml1999M029\"\n let ast_intf_magic_number = \"Caml1999N029\"\nend\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Thomas Gazagnaire, OCamlPro *)\n(* Fabrice Le Fessant, INRIA Saclay *)\n(* Hongbo Zhang, University of Pennsylvania *)\n(* *)\n(* Copyright 2007 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* Original Code from Ber-metaocaml, modified for 3.12.0 and fixed *)\n(* Printing code expressions *)\n(* Authors: Ed Pizzi, Fabrice Le Fessant *)\n(* Extensive Rewrite: Hongbo Zhang: University of Pennsylvania *)\n(* TODO more fine-grained precedence pretty-printing *)\n\nopen Ast_412\nopen Asttypes\nopen Format\nopen Location\nopen Longident\nopen Parsetree\n\nlet varify_type_constructors var_names t =\n let check_variable vl loc v =\n if List.mem v vl then\n Location.raise_errorf ~loc \"variable in scope syntax error: %s\" v\n in\n let var_names = List.map (fun v -> v.txt) var_names in\n let rec loop t =\n let desc =\n match t.ptyp_desc with\n | Ptyp_any -> Ptyp_any\n | Ptyp_var x ->\n check_variable var_names t.ptyp_loc x;\n Ptyp_var x\n | Ptyp_arrow (label, core_type, core_type') ->\n Ptyp_arrow (label, loop core_type, loop core_type')\n | Ptyp_tuple lst -> Ptyp_tuple (List.map loop lst)\n | Ptyp_constr ({ txt = Longident.Lident s }, []) when List.mem s var_names\n ->\n Ptyp_var s\n | Ptyp_constr (longident, lst) ->\n Ptyp_constr (longident, List.map loop lst)\n | Ptyp_object (lst, o) -> Ptyp_object (List.map loop_object_field lst, o)\n | Ptyp_class (longident, lst) -> Ptyp_class (longident, List.map loop lst)\n | Ptyp_alias (core_type, string) ->\n check_variable var_names t.ptyp_loc string;\n Ptyp_alias (loop core_type, string)\n | Ptyp_variant (row_field_list, flag, lbl_lst_option) ->\n Ptyp_variant\n (List.map loop_row_field row_field_list, flag, lbl_lst_option)\n | Ptyp_poly (string_lst, core_type) ->\n List.iter\n (fun v -> check_variable var_names t.ptyp_loc v.txt)\n string_lst;\n Ptyp_poly (string_lst, loop core_type)\n | Ptyp_package (longident, lst) ->\n Ptyp_package (longident, List.map (fun (n, typ) -> (n, loop typ)) lst)\n | Ptyp_extension (s, arg) -> Ptyp_extension (s, arg)\n in\n { t with ptyp_desc = desc }\n and loop_row_field field =\n let prf_desc =\n match field.prf_desc with\n | Rtag (label, flag, lst) -> Rtag (label, flag, List.map loop lst)\n | Rinherit t -> Rinherit (loop t)\n in\n { field with prf_desc }\n and loop_object_field field =\n let pof_desc =\n match field.pof_desc with\n | Otag (label, t) -> Otag (label, loop t)\n | Oinherit t -> Oinherit (loop t)\n in\n { field with pof_desc }\n in\n loop t\n\nlet prefix_symbols = [ '!'; '?'; '~' ]\n\nlet infix_symbols =\n [ '='; '<'; '>'; '@'; '^'; '|'; '&'; '+'; '-'; '*'; '/'; '$'; '%'; '#' ]\n\n(* type fixity = Infix| Prefix *)\nlet special_infix_strings =\n [ \"asr\"; \"land\"; \"lor\"; \"lsl\"; \"lsr\"; \"lxor\"; \"mod\"; \"or\"; \":=\"; \"!=\"; \"::\" ]\n\nlet letop s =\n String.length s > 3\n && s.[0] = 'l'\n && s.[1] = 'e'\n && s.[2] = 't'\n && List.mem s.[3] infix_symbols\n\nlet andop s =\n String.length s > 3\n && s.[0] = 'a'\n && s.[1] = 'n'\n && s.[2] = 'd'\n && List.mem s.[3] infix_symbols\n\n(* determines if the string is an infix string.\n checks backwards, first allowing a renaming postfix (\"_102\") which\n may have resulted from Pexp -> Texp -> Pexp translation, then checking\n if all the characters in the beginning of the string are valid infix\n characters. *)\nlet fixity_of_string = function\n | \"\" -> `Normal\n | s when List.mem s special_infix_strings -> `Infix s\n | s when List.mem s.[0] infix_symbols -> `Infix s\n | s when List.mem s.[0] prefix_symbols -> `Prefix s\n | s when s.[0] = '.' -> `Mixfix s\n | s when letop s -> `Letop s\n | s when andop s -> `Andop s\n | _ -> `Normal\n\nlet view_fixity_of_exp = function\n | { pexp_desc = Pexp_ident { txt = Lident l; _ }; pexp_attributes = [] } ->\n fixity_of_string l\n | _ -> `Normal\n\nlet is_infix = function `Infix _ -> true | _ -> false\nlet is_mixfix = function `Mixfix _ -> true | _ -> false\nlet is_kwdop = function `Letop _ | `Andop _ -> true | _ -> false\nlet first_is c str = str <> \"\" && str.[0] = c\nlet last_is c str = str <> \"\" && str.[String.length str - 1] = c\nlet first_is_in cs str = str <> \"\" && List.mem str.[0] cs\n\n(* which identifiers are in fact operators needing parentheses *)\nlet needs_parens txt =\n let fix = fixity_of_string txt in\n is_infix fix || is_mixfix fix || is_kwdop fix\n || first_is_in prefix_symbols txt\n\n(* some infixes need spaces around parens to avoid clashes with comment\n syntax *)\nlet needs_spaces txt = first_is '*' txt || last_is '*' txt\n\n(* add parentheses to binders when they are in fact infix or prefix operators *)\nlet protect_ident ppf txt =\n let format : (_, _, _) format =\n if not (needs_parens txt) then \"%s\"\n else if needs_spaces txt then \"(@;%s@;)\"\n else \"(%s)\"\n in\n fprintf ppf format txt\n\nlet protect_longident ppf print_longident longprefix txt =\n let format : (_, _, _) format =\n if not (needs_parens txt) then \"%a.%s\"\n else if needs_spaces txt then \"%a.(@;%s@;)\"\n else \"%a.(%s)\"\n in\n fprintf ppf format print_longident longprefix txt\n\ntype space_formatter = (unit, Format.formatter, unit) format\n\nlet override = function Override -> \"!\" | Fresh -> \"\"\n\n(* variance encoding: need to sync up with the [parser.mly] *)\nlet type_variance = function\n | NoVariance -> \"\"\n | Covariant -> \"+\"\n | Contravariant -> \"-\"\n\nlet type_injectivity = function NoInjectivity -> \"\" | Injective -> \"!\"\n\ntype construct =\n [ `cons of expression list\n | `list of expression list\n | `nil\n | `normal\n | `simple of Longident.t\n | `tuple ]\n\nlet view_expr x =\n match x.pexp_desc with\n | Pexp_construct ({ txt = Lident \"()\"; _ }, _) -> `tuple\n | Pexp_construct ({ txt = Lident \"[]\"; _ }, _) -> `nil\n | Pexp_construct ({ txt = Lident \"::\"; _ }, Some _) ->\n let rec loop exp acc =\n match exp with\n | {\n pexp_desc = Pexp_construct ({ txt = Lident \"[]\"; _ }, _);\n pexp_attributes = [];\n } ->\n (List.rev acc, true)\n | {\n pexp_desc =\n Pexp_construct\n ( { txt = Lident \"::\"; _ },\n Some { pexp_desc = Pexp_tuple [ e1; e2 ]; pexp_attributes = [] }\n );\n pexp_attributes = [];\n } ->\n loop e2 (e1 :: acc)\n | e -> (List.rev (e :: acc), false)\n in\n let ls, b = loop x [] in\n if b then `list ls else `cons ls\n | Pexp_construct (x, None) -> `simple x.txt\n | _ -> `normal\n\nlet is_simple_construct : construct -> bool = function\n | `nil | `tuple | `list _ | `simple _ -> true\n | `cons _ | `normal -> false\n\nlet pp = fprintf\n\ntype ctxt = { pipe : bool; semi : bool; ifthenelse : bool }\n\nlet reset_ctxt = { pipe = false; semi = false; ifthenelse = false }\nlet under_pipe ctxt = { ctxt with pipe = true }\nlet under_semi ctxt = { ctxt with semi = true }\nlet under_ifthenelse ctxt = { ctxt with ifthenelse = true }\n(*\nlet reset_semi ctxt = { ctxt with semi=false }\nlet reset_ifthenelse ctxt = { ctxt with ifthenelse=false }\nlet reset_pipe ctxt = { ctxt with pipe=false }\n*)\n\nlet list :\n 'a.\n ?sep:space_formatter ->\n ?first:space_formatter ->\n ?last:space_formatter ->\n (Format.formatter -> 'a -> unit) ->\n Format.formatter ->\n 'a list ->\n unit =\n fun ?sep ?first ?last fu f xs ->\n let first = match first with Some x -> x | None -> (\"\" : _ format6)\n and last = match last with Some x -> x | None -> (\"\" : _ format6)\n and sep = match sep with Some x -> x | None -> (\"@ \" : _ format6) in\n let aux f = function\n | [] -> ()\n | [ x ] -> fu f x\n | xs ->\n let rec loop f = function\n | [ x ] -> fu f x\n | x :: xs ->\n fu f x;\n pp f sep;\n loop f xs\n | _ -> assert false\n in\n pp f first;\n loop f xs;\n pp f last\n in\n aux f xs\n\nlet option :\n 'a.\n ?first:space_formatter ->\n ?last:space_formatter ->\n (Format.formatter -> 'a -> unit) ->\n Format.formatter ->\n 'a option ->\n unit =\n fun ?first ?last fu f a ->\n let first = match first with Some x -> x | None -> (\"\" : _ format6)\n and last = match last with Some x -> x | None -> (\"\" : _ format6) in\n match a with\n | None -> ()\n | Some x ->\n pp f first;\n fu f x;\n pp f last\n\nlet paren :\n 'a.\n ?first:space_formatter ->\n ?last:space_formatter ->\n bool ->\n (Format.formatter -> 'a -> unit) ->\n Format.formatter ->\n 'a ->\n unit =\n fun ?(first = (\"\" : _ format6)) ?(last = (\"\" : _ format6)) b fu f x ->\n if b then (\n pp f \"(\";\n pp f first;\n fu f x;\n pp f last;\n pp f \")\")\n else fu f x\n\nlet rec longident f = function\n | Lident s -> protect_ident f s\n | Ldot (y, s) -> protect_longident f longident y s\n | Lapply (y, s) -> pp f \"%a(%a)\" longident y longident s\n\nlet longident_loc f x = pp f \"%a\" longident x.txt\n\nlet constant f = function\n | Pconst_char i -> pp f \"%C\" i\n | Pconst_string (i, _, None) -> pp f \"%S\" i\n | Pconst_string (i, _, Some delim) -> pp f \"{%s|%s|%s}\" delim i delim\n | Pconst_integer (i, None) -> paren (first_is '-' i) (fun f -> pp f \"%s\") f i\n | Pconst_integer (i, Some m) ->\n paren (first_is '-' i) (fun f (i, m) -> pp f \"%s%c\" i m) f (i, m)\n | Pconst_float (i, None) -> paren (first_is '-' i) (fun f -> pp f \"%s\") f i\n | Pconst_float (i, Some m) ->\n paren (first_is '-' i) (fun f (i, m) -> pp f \"%s%c\" i m) f (i, m)\n\n(* trailing space*)\nlet mutable_flag f = function Immutable -> () | Mutable -> pp f \"mutable@;\"\nlet virtual_flag f = function Concrete -> () | Virtual -> pp f \"virtual@;\"\n\n(* trailing space added *)\nlet rec_flag f rf =\n match rf with Nonrecursive -> () | Recursive -> pp f \"rec \"\n\nlet nonrec_flag f rf =\n match rf with Nonrecursive -> pp f \"nonrec \" | Recursive -> ()\n\nlet direction_flag f = function\n | Upto -> pp f \"to@ \"\n | Downto -> pp f \"downto@ \"\n\nlet private_flag f = function Public -> () | Private -> pp f \"private@ \"\nlet iter_loc f ctxt { txt; loc = _ } = f ctxt txt\nlet constant_string f s = pp f \"%S\" s\n\nlet tyvar ppf s =\n if String.length s >= 2 && s.[1] = '\\'' then\n (* without the space, this would be parsed as\n a character literal *)\n Format.fprintf ppf \"' %s\" s\n else Format.fprintf ppf \"'%s\" s\n\nlet tyvar_loc f str = tyvar f str.txt\nlet string_quot f x = pp f \"`%s\" x\n\n(* c ['a,'b] *)\nlet rec class_params_def ctxt f = function\n | [] -> ()\n | l -> pp f \"[%a] \" (* space *) (list (type_param ctxt) ~sep:\",\") l\n\nand type_with_label ctxt f (label, c) =\n match label with\n | Nolabel -> core_type1 ctxt f c (* otherwise parenthesize *)\n | Labelled s -> pp f \"%s:%a\" s (core_type1 ctxt) c\n | Optional s -> pp f \"?%s:%a\" s (core_type1 ctxt) c\n\nand core_type ctxt f x =\n if x.ptyp_attributes <> [] then\n pp f \"((%a)%a)\" (core_type ctxt)\n { x with ptyp_attributes = [] }\n (attributes ctxt) x.ptyp_attributes\n else\n match x.ptyp_desc with\n | Ptyp_arrow (l, ct1, ct2) ->\n pp f \"@[<2>%a@;->@;%a@]\" (* FIXME remove parens later *)\n (type_with_label ctxt) (l, ct1) (core_type ctxt) ct2\n | Ptyp_alias (ct, s) ->\n pp f \"@[<2>%a@;as@;%a@]\" (core_type1 ctxt) ct tyvar s\n | Ptyp_poly ([], ct) -> core_type ctxt f ct\n | Ptyp_poly (sl, ct) ->\n pp f \"@[<2>%a%a@]\"\n (fun f l ->\n pp f \"%a\"\n (fun f l ->\n match l with\n | [] -> ()\n | _ -> pp f \"%a@;.@;\" (list tyvar_loc ~sep:\"@;\") l)\n l)\n sl (core_type ctxt) ct\n | _ -> pp f \"@[<2>%a@]\" (core_type1 ctxt) x\n\nand core_type1 ctxt f x =\n if x.ptyp_attributes <> [] then core_type ctxt f x\n else\n match x.ptyp_desc with\n | Ptyp_any -> pp f \"_\"\n | Ptyp_var s -> tyvar f s\n | Ptyp_tuple l -> pp f \"(%a)\" (list (core_type1 ctxt) ~sep:\"@;*@;\") l\n | Ptyp_constr (li, l) ->\n pp f (* \"%a%a@;\" *) \"%a%a\"\n (fun f l ->\n match l with\n | [] -> ()\n | [ x ] -> pp f \"%a@;\" (core_type1 ctxt) x\n | _ -> list ~first:\"(\" ~last:\")@;\" (core_type ctxt) ~sep:\",@;\" f l)\n l longident_loc li\n | Ptyp_variant (l, closed, low) ->\n let first_is_inherit =\n match l with\n | { Parsetree.prf_desc = Rinherit _ } :: _ -> true\n | _ -> false\n in\n let type_variant_helper f x =\n match x.prf_desc with\n | Rtag (l, _, ctl) ->\n pp f \"@[<2>%a%a@;%a@]\" (iter_loc string_quot) l\n (fun f l ->\n match l with\n | [] -> ()\n | _ -> pp f \"@;of@;%a\" (list (core_type ctxt) ~sep:\"&\") ctl)\n ctl (attributes ctxt) x.prf_attributes\n | Rinherit ct -> core_type ctxt f ct\n in\n pp f \"@[<2>[%a%a]@]\"\n (fun f l ->\n match (l, closed) with\n | [], Closed -> ()\n | [], Open -> pp f \">\" (* Cf #7200: print [>] correctly *)\n | _ ->\n pp f \"%s@;%a\"\n (match (closed, low) with\n | Closed, None -> if first_is_inherit then \" |\" else \"\"\n | Closed, Some _ -> \"<\" (* FIXME desugar the syntax sugar*)\n | Open, _ -> \">\")\n (list type_variant_helper ~sep:\"@;<1 -2>| \")\n l)\n l\n (fun f low ->\n match low with\n | Some [] | None -> ()\n | Some xs -> pp f \">@ %a\" (list string_quot) xs)\n low\n | Ptyp_object (l, o) ->\n let core_field_type f x =\n match x.pof_desc with\n | Otag (l, ct) ->\n (* Cf #7200 *)\n pp f \"@[%s: %a@ %a@ @]\" l.txt (core_type ctxt) ct\n (attributes ctxt) x.pof_attributes\n | Oinherit ct -> pp f \"@[%a@ @]\" (core_type ctxt) ct\n in\n let field_var f = function\n | Asttypes.Closed -> ()\n | Asttypes.Open -> (\n match l with [] -> pp f \"..\" | _ -> pp f \" ;..\")\n in\n pp f \"@[<@ %a%a@ > @]\"\n (list core_field_type ~sep:\";\")\n l field_var o\n (* Cf #7200 *)\n | Ptyp_class (li, l) ->\n (*FIXME*)\n pp f \"@[%a#%a@]\"\n (list (core_type ctxt) ~sep:\",\" ~first:\"(\" ~last:\")\")\n l longident_loc li\n | Ptyp_package (lid, cstrs) -> (\n let aux f (s, ct) =\n pp f \"type %a@ =@ %a\" longident_loc s (core_type ctxt) ct\n in\n match cstrs with\n | [] -> pp f \"@[(module@ %a)@]\" longident_loc lid\n | _ ->\n pp f \"@[(module@ %a@ with@ %a)@]\" longident_loc lid\n (list aux ~sep:\"@ and@ \") cstrs)\n | Ptyp_extension e -> extension ctxt f e\n | _ -> paren true (core_type ctxt) f x\n\n(********************pattern********************)\n(* be cautious when use [pattern], [pattern1] is preferred *)\nand pattern ctxt f x =\n let rec list_of_pattern acc = function\n (* only consider ((A|B)|C)*)\n | { ppat_desc = Ppat_or (p1, p2); ppat_attributes = [] } ->\n list_of_pattern (p2 :: acc) p1\n | x -> x :: acc\n in\n if x.ppat_attributes <> [] then\n pp f \"((%a)%a)\" (pattern ctxt)\n { x with ppat_attributes = [] }\n (attributes ctxt) x.ppat_attributes\n else\n match x.ppat_desc with\n | Ppat_alias (p, s) ->\n pp f \"@[<2>%a@;as@;%a@]\" (pattern ctxt) p protect_ident s.txt (* RA*)\n | Ppat_or _ ->\n (* *)\n pp f \"@[%a@]\"\n (list ~sep:\"@,|\" (pattern ctxt))\n (list_of_pattern [] x)\n | _ -> pattern1 ctxt f x\n\nand pattern1 ctxt (f : Format.formatter) (x : pattern) : unit =\n let rec pattern_list_helper f = function\n | {\n ppat_desc =\n Ppat_construct\n ( { txt = Lident \"::\"; _ },\n Some { ppat_desc = Ppat_tuple [ pat1; pat2 ]; _ } );\n ppat_attributes = [];\n } ->\n pp f \"%a::%a\" (simple_pattern ctxt) pat1 pattern_list_helper pat2 (*RA*)\n | p -> pattern1 ctxt f p\n in\n if x.ppat_attributes <> [] then pattern ctxt f x\n else\n match x.ppat_desc with\n | Ppat_variant (l, Some p) ->\n pp f \"@[<2>`%s@;%a@]\" l (simple_pattern ctxt) p\n | Ppat_construct ({ txt = Lident (\"()\" | \"[]\"); _ }, _) ->\n simple_pattern ctxt f x\n | Ppat_construct (({ txt; _ } as li), po) -> (\n if (* FIXME The third field always false *)\n txt = Lident \"::\" then pp f \"%a\" pattern_list_helper x\n else\n match po with\n | Some x -> pp f \"%a@;%a\" longident_loc li (simple_pattern ctxt) x\n | None -> pp f \"%a\" longident_loc li)\n | _ -> simple_pattern ctxt f x\n\nand simple_pattern ctxt (f : Format.formatter) (x : pattern) : unit =\n if x.ppat_attributes <> [] then pattern ctxt f x\n else\n match x.ppat_desc with\n | Ppat_construct ({ txt = Lident ((\"()\" | \"[]\") as x); _ }, _) ->\n pp f \"%s\" x\n | Ppat_any -> pp f \"_\"\n | Ppat_var { txt; _ } -> protect_ident f txt\n | Ppat_array l -> pp f \"@[<2>[|%a|]@]\" (list (pattern1 ctxt) ~sep:\";\") l\n | Ppat_unpack { txt = None } -> pp f \"(module@ _)@ \"\n | Ppat_unpack { txt = Some s } -> pp f \"(module@ %s)@ \" s\n | Ppat_type li -> pp f \"#%a\" longident_loc li\n | Ppat_record (l, closed) -> (\n let longident_x_pattern f (li, p) =\n match (li, p) with\n | ( { txt = Lident s; _ },\n { ppat_desc = Ppat_var { txt; _ }; ppat_attributes = []; _ } )\n when s = txt ->\n pp f \"@[<2>%a@]\" longident_loc li\n | _ -> pp f \"@[<2>%a@;=@;%a@]\" longident_loc li (pattern1 ctxt) p\n in\n match closed with\n | Closed ->\n pp f \"@[<2>{@;%a@;}@]\" (list longident_x_pattern ~sep:\";@;\") l\n | _ -> pp f \"@[<2>{@;%a;_}@]\" (list longident_x_pattern ~sep:\";@;\") l)\n | Ppat_tuple l ->\n pp f \"@[<1>(%a)@]\" (list ~sep:\",@;\" (pattern1 ctxt)) l (* level1*)\n | Ppat_constant c -> pp f \"%a\" constant c\n | Ppat_interval (c1, c2) -> pp f \"%a..%a\" constant c1 constant c2\n | Ppat_variant (l, None) -> pp f \"`%s\" l\n | Ppat_constraint (p, ct) ->\n pp f \"@[<2>(%a@;:@;%a)@]\" (pattern1 ctxt) p (core_type ctxt) ct\n | Ppat_lazy p -> pp f \"@[<2>(lazy@;%a)@]\" (pattern1 ctxt) p\n | Ppat_exception p -> pp f \"@[<2>exception@;%a@]\" (pattern1 ctxt) p\n | Ppat_extension e -> extension ctxt f e\n | Ppat_open (lid, p) ->\n let with_paren =\n match p.ppat_desc with\n | Ppat_array _ | Ppat_record _\n | Ppat_construct ({ txt = Lident (\"()\" | \"[]\"); _ }, _) ->\n false\n | _ -> true\n in\n pp f \"@[<2>%a.%a @]\" longident_loc lid\n (paren with_paren @@ pattern1 ctxt)\n p\n | _ -> paren true (pattern ctxt) f x\n\nand label_exp ctxt f (l, opt, p) =\n match l with\n | Nolabel ->\n (* single case pattern parens needed here *)\n pp f \"%a@ \" (simple_pattern ctxt) p\n | Optional rest -> (\n match p with\n | { ppat_desc = Ppat_var { txt; _ }; ppat_attributes = [] }\n when txt = rest -> (\n match opt with\n | Some o -> pp f \"?(%s=@;%a)@;\" rest (expression ctxt) o\n | None -> pp f \"?%s@ \" rest)\n | _ -> (\n match opt with\n | Some o ->\n pp f \"?%s:(%a=@;%a)@;\" rest (pattern1 ctxt) p (expression ctxt) o\n | None -> pp f \"?%s:%a@;\" rest (simple_pattern ctxt) p))\n | Labelled l -> (\n match p with\n | { ppat_desc = Ppat_var { txt; _ }; ppat_attributes = [] } when txt = l\n ->\n pp f \"~%s@;\" l\n | _ -> pp f \"~%s:%a@;\" l (simple_pattern ctxt) p)\n\nand sugar_expr ctxt f e =\n if e.pexp_attributes <> [] then false\n else\n match e.pexp_desc with\n | Pexp_apply\n ( { pexp_desc = Pexp_ident { txt = id; _ }; pexp_attributes = []; _ },\n args )\n when List.for_all (fun (lab, _) -> lab = Nolabel) args -> (\n let print_indexop a path_prefix assign left right print_index indices\n rem_args =\n let print_path ppf = function\n | None -> ()\n | Some m -> pp ppf \".%a\" longident m\n in\n match (assign, rem_args) with\n | false, [] ->\n pp f \"@[%a%a%s%a%s@]\" (simple_expr ctxt) a print_path path_prefix\n left\n (list ~sep:\",\" print_index)\n indices right;\n true\n | true, [ v ] ->\n pp f \"@[%a%a%s%a%s@ <-@;<1 2>%a@]\" (simple_expr ctxt) a print_path\n path_prefix left\n (list ~sep:\",\" print_index)\n indices right (simple_expr ctxt) v;\n true\n | _ -> false\n in\n match (id, List.map snd args) with\n | Lident \"!\", [ e ] ->\n pp f \"@[!%a@]\" (simple_expr ctxt) e;\n true\n | Ldot (path, ((\"get\" | \"set\") as func)), a :: other_args -> (\n let assign = func = \"set\" in\n let print = print_indexop a None assign in\n match (path, other_args) with\n | Lident \"Array\", i :: rest ->\n print \".(\" \")\" (expression ctxt) [ i ] rest\n | Lident \"String\", i :: rest ->\n print \".[\" \"]\" (expression ctxt) [ i ] rest\n | Ldot (Lident \"Bigarray\", \"Array1\"), i1 :: rest ->\n print \".{\" \"}\" (simple_expr ctxt) [ i1 ] rest\n | Ldot (Lident \"Bigarray\", \"Array2\"), i1 :: i2 :: rest ->\n print \".{\" \"}\" (simple_expr ctxt) [ i1; i2 ] rest\n | Ldot (Lident \"Bigarray\", \"Array3\"), i1 :: i2 :: i3 :: rest ->\n print \".{\" \"}\" (simple_expr ctxt) [ i1; i2; i3 ] rest\n | ( Ldot (Lident \"Bigarray\", \"Genarray\"),\n { pexp_desc = Pexp_array indexes; pexp_attributes = [] } :: rest\n ) ->\n print \".{\" \"}\" (simple_expr ctxt) indexes rest\n | _ -> false)\n | (Lident s | Ldot (_, s)), a :: i :: rest when first_is '.' s ->\n (* extract operator:\n assignment operators end with [right_bracket ^ \"<-\"],\n access operators end with [right_bracket] directly\n *)\n let assign = last_is '-' s in\n let kind =\n (* extract the right end bracket *)\n let n = String.length s in\n if assign then s.[n - 3] else s.[n - 1]\n in\n let left, right =\n match kind with\n | ')' -> ('(', \")\")\n | ']' -> ('[', \"]\")\n | '}' -> ('{', \"}\")\n | _ -> assert false\n in\n let path_prefix =\n match id with Ldot (m, _) -> Some m | _ -> None\n in\n let left = String.sub s 0 (1 + String.index s left) in\n print_indexop a path_prefix assign left right (expression ctxt)\n [ i ] rest\n | _ -> false)\n | _ -> false\n\nand expression ctxt f x =\n if x.pexp_attributes <> [] then\n pp f \"((%a)@,%a)\" (expression ctxt)\n { x with pexp_attributes = [] }\n (attributes ctxt) x.pexp_attributes\n else\n match x.pexp_desc with\n | Pexp_function _ | Pexp_fun _ | Pexp_match _ | Pexp_try _ | Pexp_sequence _\n when ctxt.pipe || ctxt.semi ->\n paren true (expression reset_ctxt) f x\n | (Pexp_ifthenelse _ | Pexp_sequence _) when ctxt.ifthenelse ->\n paren true (expression reset_ctxt) f x\n | Pexp_let _ | Pexp_letmodule _ | Pexp_open _ | Pexp_letexception _\n | Pexp_letop _\n when ctxt.semi ->\n paren true (expression reset_ctxt) f x\n | Pexp_fun (l, e0, p, e) ->\n pp f \"@[<2>fun@;%a->@;%a@]\" (label_exp ctxt) (l, e0, p)\n (expression ctxt) e\n | Pexp_function l -> pp f \"@[function%a@]\" (case_list ctxt) l\n | Pexp_match (e, l) ->\n pp f \"@[@[@[<2>match %a@]@ with@]%a@]\" (expression reset_ctxt)\n e (case_list ctxt) l\n | Pexp_try (e, l) ->\n pp f \"@[<0>@[try@ %a@]@ @[<0>with%a@]@]\"\n (* \"try@;@[<2>%a@]@\\nwith@\\n%a\"*)\n (expression reset_ctxt)\n e (case_list ctxt) l\n | Pexp_let (rf, l, e) ->\n (* pp f \"@[<2>let %a%a in@;<1 -2>%a@]\"\n (*no indentation here, a new line*) *)\n (* rec_flag rf *)\n pp f \"@[<2>%a in@;<1 -2>%a@]\" (bindings reset_ctxt) (rf, l)\n (expression ctxt) e\n | Pexp_apply (e, l) -> (\n if not (sugar_expr ctxt f x) then\n match view_fixity_of_exp e with\n | `Infix s -> (\n match l with\n | [ ((Nolabel, _) as arg1); ((Nolabel, _) as arg2) ] ->\n (* FIXME associativity label_x_expression_param *)\n pp f \"@[<2>%a@;%s@;%a@]\"\n (label_x_expression_param reset_ctxt)\n arg1 s\n (label_x_expression_param ctxt)\n arg2\n | _ ->\n pp f \"@[<2>%a %a@]\" (simple_expr ctxt) e\n (list (label_x_expression_param ctxt))\n l)\n | `Prefix s -> (\n let s =\n if\n List.mem s [ \"~+\"; \"~-\"; \"~+.\"; \"~-.\" ]\n &&\n match l with\n (* See #7200: avoid turning (~- 1) into (- 1) which is\n parsed as an int literal *)\n | [ (_, { pexp_desc = Pexp_constant _ }) ] -> false\n | _ -> true\n then String.sub s 1 (String.length s - 1)\n else s\n in\n match l with\n | [ (Nolabel, x) ] -> pp f \"@[<2>%s@;%a@]\" s (simple_expr ctxt) x\n | _ ->\n pp f \"@[<2>%a %a@]\" (simple_expr ctxt) e\n (list (label_x_expression_param ctxt))\n l)\n | _ ->\n pp f \"@[%a@]\"\n (fun f (e, l) ->\n pp f \"%a@ %a\" (expression2 ctxt) e\n (list (label_x_expression_param reset_ctxt))\n l\n (* reset here only because [function,match,try,sequence]\n are lower priority *))\n (e, l))\n | Pexp_construct (li, Some eo) when not (is_simple_construct (view_expr x))\n -> (\n (* Not efficient FIXME*)\n match view_expr x with\n | `cons ls -> list (simple_expr ctxt) f ls ~sep:\"@;::@;\"\n | `normal -> pp f \"@[<2>%a@;%a@]\" longident_loc li (simple_expr ctxt) eo\n | _ -> assert false)\n | Pexp_setfield (e1, li, e2) ->\n pp f \"@[<2>%a.%a@ <-@ %a@]\" (simple_expr ctxt) e1 longident_loc li\n (simple_expr ctxt) e2\n | Pexp_ifthenelse (e1, e2, eo) ->\n (* @;@[<2>else@ %a@]@] *)\n let fmt : (_, _, _) format =\n \"@[@[<2>if@ %a@]@;@[<2>then@ %a@]%a@]\"\n in\n let expression_under_ifthenelse = expression (under_ifthenelse ctxt) in\n pp f fmt expression_under_ifthenelse e1 expression_under_ifthenelse e2\n (fun f eo ->\n match eo with\n | Some x ->\n pp f \"@;@[<2>else@;%a@]\" (expression (under_semi ctxt)) x\n | None -> ()\n (* pp f \"()\" *))\n eo\n | Pexp_sequence _ ->\n let rec sequence_helper acc = function\n | { pexp_desc = Pexp_sequence (e1, e2); pexp_attributes = [] } ->\n sequence_helper (e1 :: acc) e2\n | v -> List.rev (v :: acc)\n in\n let lst = sequence_helper [] x in\n pp f \"@[%a@]\" (list (expression (under_semi ctxt)) ~sep:\";@;\") lst\n | Pexp_new li -> pp f \"@[new@ %a@]\" longident_loc li\n | Pexp_setinstvar (s, e) ->\n pp f \"@[%s@ <-@ %a@]\" s.txt (expression ctxt) e\n | Pexp_override l ->\n (* FIXME *)\n let string_x_expression f (s, e) =\n pp f \"@[%s@ =@ %a@]\" s.txt (expression ctxt) e\n in\n pp f \"@[{<%a>}@]\" (list string_x_expression ~sep:\";\") l\n | Pexp_letmodule (s, me, e) ->\n pp f \"@[let@ module@ %s@ =@ %a@ in@ %a@]\"\n (match s.txt with None -> \"_\" | Some s -> s)\n (module_expr reset_ctxt) me (expression ctxt) e\n | Pexp_letexception (cd, e) ->\n pp f \"@[let@ exception@ %a@ in@ %a@]\"\n (extension_constructor ctxt)\n cd (expression ctxt) e\n | Pexp_assert e -> pp f \"@[assert@ %a@]\" (simple_expr ctxt) e\n | Pexp_lazy e -> pp f \"@[lazy@ %a@]\" (simple_expr ctxt) e\n (* Pexp_poly: impossible but we should print it anyway, rather than\n assert false *)\n | Pexp_poly (e, None) -> pp f \"@[!poly!@ %a@]\" (simple_expr ctxt) e\n | Pexp_poly (e, Some ct) ->\n pp f \"@[(!poly!@ %a@ : %a)@]\" (simple_expr ctxt) e\n (core_type ctxt) ct\n | Pexp_open (o, e) ->\n pp f \"@[<2>let open%s %a in@;%a@]\"\n (override o.popen_override)\n (module_expr ctxt) o.popen_expr (expression ctxt) e\n | Pexp_variant (l, Some eo) -> pp f \"@[<2>`%s@;%a@]\" l (simple_expr ctxt) eo\n | Pexp_letop { let_; ands; body } ->\n pp f \"@[<2>@[%a@,%a@] in@;<1 -2>%a@]\" (binding_op ctxt) let_\n (list ~sep:\"@,\" (binding_op ctxt))\n ands (expression ctxt) body\n | Pexp_extension e -> extension ctxt f e\n | Pexp_unreachable -> pp f \".\"\n | _ -> expression1 ctxt f x\n\nand expression1 ctxt f x =\n if x.pexp_attributes <> [] then expression ctxt f x\n else\n match x.pexp_desc with\n | Pexp_object cs -> pp f \"%a\" (class_structure ctxt) cs\n | _ -> expression2 ctxt f x\n(* used in [Pexp_apply] *)\n\nand expression2 ctxt f x =\n if x.pexp_attributes <> [] then expression ctxt f x\n else\n match x.pexp_desc with\n | Pexp_field (e, li) ->\n pp f \"@[%a.%a@]\" (simple_expr ctxt) e longident_loc li\n | Pexp_send (e, s) -> pp f \"@[%a#%s@]\" (simple_expr ctxt) e s.txt\n | _ -> simple_expr ctxt f x\n\nand simple_expr ctxt f x =\n if x.pexp_attributes <> [] then expression ctxt f x\n else\n match x.pexp_desc with\n | Pexp_construct _ when is_simple_construct (view_expr x) -> (\n match view_expr x with\n | `nil -> pp f \"[]\"\n | `tuple -> pp f \"()\"\n | `list xs ->\n pp f \"@[[%a]@]\"\n (list (expression (under_semi ctxt)) ~sep:\";@;\")\n xs\n | `simple x -> longident f x\n | _ -> assert false)\n | Pexp_ident li -> longident_loc f li\n (* (match view_fixity_of_exp x with *)\n (* |`Normal -> longident_loc f li *)\n (* | `Prefix _ | `Infix _ -> pp f \"( %a )\" longident_loc li) *)\n | Pexp_constant c -> constant f c\n | Pexp_pack me -> pp f \"(module@;%a)\" (module_expr ctxt) me\n | Pexp_newtype (lid, e) ->\n pp f \"fun@;(type@;%s)@;->@;%a\" lid.txt (expression ctxt) e\n | Pexp_tuple l ->\n pp f \"@[(%a)@]\" (list (simple_expr ctxt) ~sep:\",@;\") l\n | Pexp_constraint (e, ct) ->\n pp f \"(%a : %a)\" (expression ctxt) e (core_type ctxt) ct\n | Pexp_coerce (e, cto1, ct) ->\n pp f \"(%a%a :> %a)\" (expression ctxt) e\n (option (core_type ctxt) ~first:\" : \" ~last:\" \")\n cto1\n (* no sep hint*) (core_type ctxt)\n ct\n | Pexp_variant (l, None) -> pp f \"`%s\" l\n | Pexp_record (l, eo) ->\n let longident_x_expression f (li, e) =\n match e with\n | { pexp_desc = Pexp_ident { txt; _ }; pexp_attributes = []; _ }\n when li.txt = txt ->\n pp f \"@[%a@]\" longident_loc li\n | _ ->\n pp f \"@[%a@;=@;%a@]\" longident_loc li (simple_expr ctxt) e\n in\n pp f \"@[@[{@;%a%a@]@;}@]\" (* \"@[{%a%a}@]\" *)\n (option ~last:\" with@;\" (simple_expr ctxt))\n eo\n (list longident_x_expression ~sep:\";@;\")\n l\n | Pexp_array l ->\n pp f \"@[<0>@[<2>[|%a|]@]@]\"\n (list (simple_expr (under_semi ctxt)) ~sep:\";\")\n l\n | Pexp_while (e1, e2) ->\n let fmt : (_, _, _) format = \"@[<2>while@;%a@;do@;%a@;done@]\" in\n pp f fmt (expression ctxt) e1 (expression ctxt) e2\n | Pexp_for (s, e1, e2, df, e3) ->\n let fmt : (_, _, _) format =\n \"@[@[@[<2>for %a =@;%a@;%a%a@;do@]@;%a@]@;done@]\"\n in\n let expression = expression ctxt in\n pp f fmt (pattern ctxt) s expression e1 direction_flag df expression e2\n expression e3\n | _ -> paren true (expression ctxt) f x\n\nand attributes ctxt f l = List.iter (attribute ctxt f) l\nand item_attributes ctxt f l = List.iter (item_attribute ctxt f) l\n\nand attribute ctxt f a =\n pp f \"@[<2>[@@%s@ %a]@]\" a.attr_name.txt (payload ctxt) a.attr_payload\n\nand item_attribute ctxt f a =\n pp f \"@[<2>[@@@@%s@ %a]@]\" a.attr_name.txt (payload ctxt) a.attr_payload\n\nand floating_attribute ctxt f a =\n pp f \"@[<2>[@@@@@@%s@ %a]@]\" a.attr_name.txt (payload ctxt) a.attr_payload\n\nand value_description ctxt f x =\n (* note: value_description has an attribute field,\n but they're already printed by the callers this method *)\n pp f \"@[%a%a@]\" (core_type ctxt) x.pval_type\n (fun f x ->\n if x.pval_prim <> [] then\n pp f \"@ =@ %a\" (list constant_string) x.pval_prim)\n x\n\nand extension ctxt f (s, e) = pp f \"@[<2>[%%%s@ %a]@]\" s.txt (payload ctxt) e\n\nand item_extension ctxt f (s, e) =\n pp f \"@[<2>[%%%%%s@ %a]@]\" s.txt (payload ctxt) e\n\nand exception_declaration ctxt f x =\n pp f \"@[exception@ %a@]%a\"\n (extension_constructor ctxt)\n x.ptyexn_constructor (item_attributes ctxt) x.ptyexn_attributes\n\nand class_type_field ctxt f x =\n match x.pctf_desc with\n | Pctf_inherit ct ->\n pp f \"@[<2>inherit@ %a@]%a\" (class_type ctxt) ct (item_attributes ctxt)\n x.pctf_attributes\n | Pctf_val (s, mf, vf, ct) ->\n pp f \"@[<2>val @ %a%a%s@ :@ %a@]%a\" mutable_flag mf virtual_flag vf s.txt\n (core_type ctxt) ct (item_attributes ctxt) x.pctf_attributes\n | Pctf_method (s, pf, vf, ct) ->\n pp f \"@[<2>method %a %a%s :@;%a@]%a\" private_flag pf virtual_flag vf s.txt\n (core_type ctxt) ct (item_attributes ctxt) x.pctf_attributes\n | Pctf_constraint (ct1, ct2) ->\n pp f \"@[<2>constraint@ %a@ =@ %a@]%a\" (core_type ctxt) ct1\n (core_type ctxt) ct2 (item_attributes ctxt) x.pctf_attributes\n | Pctf_attribute a -> floating_attribute ctxt f a\n | Pctf_extension e ->\n item_extension ctxt f e;\n item_attributes ctxt f x.pctf_attributes\n\nand class_signature ctxt f { pcsig_self = ct; pcsig_fields = l; _ } =\n pp f \"@[@[object@[<1>%a@]@ %a@]@ end@]\"\n (fun f -> function\n | { ptyp_desc = Ptyp_any; ptyp_attributes = []; _ } -> ()\n | ct -> pp f \" (%a)\" (core_type ctxt) ct)\n ct\n (list (class_type_field ctxt) ~sep:\"@;\")\n l\n\n(* call [class_signature] called by [class_signature] *)\nand class_type ctxt f x =\n match x.pcty_desc with\n | Pcty_signature cs ->\n class_signature ctxt f cs;\n attributes ctxt f x.pcty_attributes\n | Pcty_constr (li, l) ->\n pp f \"%a%a%a\"\n (fun f l ->\n match l with\n | [] -> ()\n | _ -> pp f \"[%a]@ \" (list (core_type ctxt) ~sep:\",\") l)\n l longident_loc li (attributes ctxt) x.pcty_attributes\n | Pcty_arrow (l, co, cl) ->\n pp f \"@[<2>%a@;->@;%a@]\" (* FIXME remove parens later *)\n (type_with_label ctxt) (l, co) (class_type ctxt) cl\n | Pcty_extension e ->\n extension ctxt f e;\n attributes ctxt f x.pcty_attributes\n | Pcty_open (o, e) ->\n pp f \"@[<2>let open%s %a in@;%a@]\"\n (override o.popen_override)\n longident_loc o.popen_expr (class_type ctxt) e\n\n(* [class type a = object end] *)\nand class_type_declaration_list ctxt f l =\n let class_type_declaration kwd f x =\n let { pci_params = ls; pci_name = { txt; _ }; _ } = x in\n pp f \"@[<2>%s %a%a%s@ =@ %a@]%a\" kwd virtual_flag x.pci_virt\n (class_params_def ctxt) ls txt (class_type ctxt) x.pci_expr\n (item_attributes ctxt) x.pci_attributes\n in\n match l with\n | [] -> ()\n | [ x ] -> class_type_declaration \"class type\" f x\n | x :: xs ->\n pp f \"@[%a@,%a@]\"\n (class_type_declaration \"class type\")\n x\n (list ~sep:\"@,\" (class_type_declaration \"and\"))\n xs\n\nand class_field ctxt f x =\n match x.pcf_desc with\n | Pcf_inherit (ovf, ce, so) ->\n pp f \"@[<2>inherit@ %s@ %a%a@]%a\" (override ovf) (class_expr ctxt) ce\n (fun f so ->\n match so with None -> () | Some s -> pp f \"@ as %s\" s.txt)\n so (item_attributes ctxt) x.pcf_attributes\n | Pcf_val (s, mf, Cfk_concrete (ovf, e)) ->\n pp f \"@[<2>val%s %a%s =@;%a@]%a\" (override ovf) mutable_flag mf s.txt\n (expression ctxt) e (item_attributes ctxt) x.pcf_attributes\n | Pcf_method (s, pf, Cfk_virtual ct) ->\n pp f \"@[<2>method virtual %a %s :@;%a@]%a\" private_flag pf s.txt\n (core_type ctxt) ct (item_attributes ctxt) x.pcf_attributes\n | Pcf_val (s, mf, Cfk_virtual ct) ->\n pp f \"@[<2>val virtual %a%s :@ %a@]%a\" mutable_flag mf s.txt\n (core_type ctxt) ct (item_attributes ctxt) x.pcf_attributes\n | Pcf_method (s, pf, Cfk_concrete (ovf, e)) ->\n let bind e =\n binding ctxt f\n {\n pvb_pat =\n {\n ppat_desc = Ppat_var s;\n ppat_loc = Location.none;\n ppat_loc_stack = [];\n ppat_attributes = [];\n };\n pvb_expr = e;\n pvb_attributes = [];\n pvb_loc = Location.none;\n }\n in\n pp f \"@[<2>method%s %a%a@]%a\" (override ovf) private_flag pf\n (fun f -> function\n | { pexp_desc = Pexp_poly (e, Some ct); pexp_attributes = []; _ } ->\n pp f \"%s :@;%a=@;%a\" s.txt (core_type ctxt) ct (expression ctxt) e\n | { pexp_desc = Pexp_poly (e, None); pexp_attributes = []; _ } ->\n bind e\n | _ -> bind e)\n e (item_attributes ctxt) x.pcf_attributes\n | Pcf_constraint (ct1, ct2) ->\n pp f \"@[<2>constraint %a =@;%a@]%a\" (core_type ctxt) ct1 (core_type ctxt)\n ct2 (item_attributes ctxt) x.pcf_attributes\n | Pcf_initializer e ->\n pp f \"@[<2>initializer@ %a@]%a\" (expression ctxt) e (item_attributes ctxt)\n x.pcf_attributes\n | Pcf_attribute a -> floating_attribute ctxt f a\n | Pcf_extension e ->\n item_extension ctxt f e;\n item_attributes ctxt f x.pcf_attributes\n\nand class_structure ctxt f { pcstr_self = p; pcstr_fields = l } =\n pp f \"@[@[object%a@;%a@]@;end@]\"\n (fun f p ->\n match p.ppat_desc with\n | Ppat_any -> ()\n | Ppat_constraint _ -> pp f \" %a\" (pattern ctxt) p\n | _ -> pp f \" (%a)\" (pattern ctxt) p)\n p\n (list (class_field ctxt))\n l\n\nand class_expr ctxt f x =\n if x.pcl_attributes <> [] then\n pp f \"((%a)%a)\" (class_expr ctxt)\n { x with pcl_attributes = [] }\n (attributes ctxt) x.pcl_attributes\n else\n match x.pcl_desc with\n | Pcl_structure cs -> class_structure ctxt f cs\n | Pcl_fun (l, eo, p, e) ->\n pp f \"fun@ %a@ ->@ %a\" (label_exp ctxt) (l, eo, p) (class_expr ctxt) e\n | Pcl_let (rf, l, ce) ->\n pp f \"%a@ in@ %a\" (bindings ctxt) (rf, l) (class_expr ctxt) ce\n | Pcl_apply (ce, l) ->\n pp f \"((%a)@ %a)\"\n (* Cf: #7200 *) (class_expr ctxt)\n ce\n (list (label_x_expression_param ctxt))\n l\n | Pcl_constr (li, l) ->\n pp f \"%a%a\"\n (fun f l ->\n if l <> [] then pp f \"[%a]@ \" (list (core_type ctxt) ~sep:\",\") l)\n l longident_loc li\n | Pcl_constraint (ce, ct) ->\n pp f \"(%a@ :@ %a)\" (class_expr ctxt) ce (class_type ctxt) ct\n | Pcl_extension e -> extension ctxt f e\n | Pcl_open (o, e) ->\n pp f \"@[<2>let open%s %a in@;%a@]\"\n (override o.popen_override)\n longident_loc o.popen_expr (class_expr ctxt) e\n\nand module_type ctxt f x =\n if x.pmty_attributes <> [] then\n pp f \"((%a)%a)\" (module_type ctxt)\n { x with pmty_attributes = [] }\n (attributes ctxt) x.pmty_attributes\n else\n match x.pmty_desc with\n | Pmty_functor (Unit, mt2) ->\n pp f \"@[functor () ->@ %a@]\" (module_type ctxt) mt2\n | Pmty_functor (Named (s, mt1), mt2) -> (\n match s.txt with\n | None ->\n pp f \"@[%a@ ->@ %a@]\" (module_type1 ctxt) mt1\n (module_type ctxt) mt2\n | Some name ->\n pp f \"@[functor@ (%s@ :@ %a)@ ->@ %a@]\" name\n (module_type ctxt) mt1 (module_type ctxt) mt2)\n | Pmty_with (mt, []) -> module_type ctxt f mt\n | Pmty_with (mt, l) ->\n let with_constraint f = function\n | Pwith_type (li, ({ ptype_params = ls; _ } as td)) ->\n let ls = List.map fst ls in\n pp f \"type@ %a %a =@ %a\"\n (list (core_type ctxt) ~sep:\",\" ~first:\"(\" ~last:\")\")\n ls longident_loc li (type_declaration ctxt) td\n | Pwith_module (li, li2) ->\n pp f \"module %a =@ %a\" longident_loc li longident_loc li2\n | Pwith_typesubst (li, ({ ptype_params = ls; _ } as td)) ->\n let ls = List.map fst ls in\n pp f \"type@ %a %a :=@ %a\"\n (list (core_type ctxt) ~sep:\",\" ~first:\"(\" ~last:\")\")\n ls longident_loc li (type_declaration ctxt) td\n | Pwith_modsubst (li, li2) ->\n pp f \"module %a :=@ %a\" longident_loc li longident_loc li2\n in\n pp f \"@[%a@ with@ %a@]\" (module_type1 ctxt) mt\n (list with_constraint ~sep:\"@ and@ \")\n l\n | _ -> module_type1 ctxt f x\n\nand module_type1 ctxt f x =\n if x.pmty_attributes <> [] then module_type ctxt f x\n else\n match x.pmty_desc with\n | Pmty_ident li -> pp f \"%a\" longident_loc li\n | Pmty_alias li -> pp f \"(module %a)\" longident_loc li\n | Pmty_signature s ->\n pp f \"@[@[sig@ %a@]@ end@]\" (* \"@[sig@ %a@ end@]\" *)\n (list (signature_item ctxt))\n s\n (* FIXME wrong indentation*)\n | Pmty_typeof me ->\n pp f \"@[module@ type@ of@ %a@]\" (module_expr ctxt) me\n | Pmty_extension e -> extension ctxt f e\n | _ -> paren true (module_type ctxt) f x\n\nand signature ctxt f x = list ~sep:\"@\\n\" (signature_item ctxt) f x\n\nand signature_item ctxt f x : unit =\n match x.psig_desc with\n | Psig_type (rf, l) -> type_def_list ctxt f (rf, true, l)\n | Psig_typesubst l ->\n (* Psig_typesubst is never recursive, but we specify [Recursive] here to\n avoid printing a [nonrec] flag, which would be rejected by the parser.\n *)\n type_def_list ctxt f (Recursive, false, l)\n | Psig_value vd ->\n let intro = if vd.pval_prim = [] then \"val\" else \"external\" in\n pp f \"@[<2>%s@ %a@ :@ %a@]%a\" intro protect_ident vd.pval_name.txt\n (value_description ctxt) vd (item_attributes ctxt) vd.pval_attributes\n | Psig_typext te -> type_extension ctxt f te\n | Psig_exception ed -> exception_declaration ctxt f ed\n | Psig_class l -> (\n let class_description kwd f\n ({ pci_params = ls; pci_name = { txt; _ }; _ } as x) =\n pp f \"@[<2>%s %a%a%s@;:@;%a@]%a\" kwd virtual_flag x.pci_virt\n (class_params_def ctxt) ls txt (class_type ctxt) x.pci_expr\n (item_attributes ctxt) x.pci_attributes\n in\n match l with\n | [] -> ()\n | [ x ] -> class_description \"class\" f x\n | x :: xs ->\n pp f \"@[%a@,%a@]\"\n (class_description \"class\")\n x\n (list ~sep:\"@,\" (class_description \"and\"))\n xs)\n | Psig_module\n ({\n pmd_type = { pmty_desc = Pmty_alias alias; pmty_attributes = []; _ };\n _;\n } as pmd) ->\n pp f \"@[module@ %s@ =@ %a@]%a\"\n (match pmd.pmd_name.txt with None -> \"_\" | Some s -> s)\n longident_loc alias (item_attributes ctxt) pmd.pmd_attributes\n | Psig_module pmd ->\n pp f \"@[module@ %s@ :@ %a@]%a\"\n (match pmd.pmd_name.txt with None -> \"_\" | Some s -> s)\n (module_type ctxt) pmd.pmd_type (item_attributes ctxt)\n pmd.pmd_attributes\n | Psig_modsubst pms ->\n pp f \"@[module@ %s@ :=@ %a@]%a\" pms.pms_name.txt longident_loc\n pms.pms_manifest (item_attributes ctxt) pms.pms_attributes\n | Psig_open od ->\n pp f \"@[open%s@ %a@]%a\"\n (override od.popen_override)\n longident_loc od.popen_expr (item_attributes ctxt) od.popen_attributes\n | Psig_include incl ->\n pp f \"@[include@ %a@]%a\" (module_type ctxt) incl.pincl_mod\n (item_attributes ctxt) incl.pincl_attributes\n | Psig_modtype { pmtd_name = s; pmtd_type = md; pmtd_attributes = attrs } ->\n pp f \"@[module@ type@ %s%a@]%a\" s.txt\n (fun f md ->\n match md with\n | None -> ()\n | Some mt ->\n pp_print_space f ();\n pp f \"@ =@ %a\" (module_type ctxt) mt)\n md (item_attributes ctxt) attrs\n | Psig_class_type l -> class_type_declaration_list ctxt f l\n | Psig_recmodule decls ->\n let rec string_x_module_type_list f ?(first = true) l =\n match l with\n | [] -> ()\n | pmd :: tl ->\n if not first then\n pp f \"@ @[and@ %s:@ %a@]%a\"\n (match pmd.pmd_name.txt with None -> \"_\" | Some s -> s)\n (module_type1 ctxt) pmd.pmd_type (item_attributes ctxt)\n pmd.pmd_attributes\n else\n pp f \"@[module@ rec@ %s:@ %a@]%a\"\n (match pmd.pmd_name.txt with None -> \"_\" | Some s -> s)\n (module_type1 ctxt) pmd.pmd_type (item_attributes ctxt)\n pmd.pmd_attributes;\n string_x_module_type_list f ~first:false tl\n in\n string_x_module_type_list f decls\n | Psig_attribute a -> floating_attribute ctxt f a\n | Psig_extension (e, a) ->\n item_extension ctxt f e;\n item_attributes ctxt f a\n\nand module_expr ctxt f x =\n if x.pmod_attributes <> [] then\n pp f \"((%a)%a)\" (module_expr ctxt)\n { x with pmod_attributes = [] }\n (attributes ctxt) x.pmod_attributes\n else\n match x.pmod_desc with\n | Pmod_structure s ->\n pp f \"@[struct@;@[<0>%a@]@;<1 -2>end@]\"\n (list (structure_item ctxt) ~sep:\"@\\n\")\n s\n | Pmod_constraint (me, mt) ->\n pp f \"@[(%a@ :@ %a)@]\" (module_expr ctxt) me (module_type ctxt) mt\n | Pmod_ident li -> pp f \"%a\" longident_loc li\n | Pmod_functor (Unit, me) -> pp f \"functor ()@;->@;%a\" (module_expr ctxt) me\n | Pmod_functor (Named (s, mt), me) ->\n pp f \"functor@ (%s@ :@ %a)@;->@;%a\"\n (match s.txt with None -> \"_\" | Some s -> s)\n (module_type ctxt) mt (module_expr ctxt) me\n | Pmod_apply (me1, me2) ->\n pp f \"(%a)(%a)\" (module_expr ctxt) me1 (module_expr ctxt) me2\n (* Cf: #7200 *)\n | Pmod_unpack e -> pp f \"(val@ %a)\" (expression ctxt) e\n | Pmod_extension e -> extension ctxt f e\n\nand structure ctxt f x = list ~sep:\"@\\n\" (structure_item ctxt) f x\n\nand payload ctxt f = function\n | PStr [ { pstr_desc = Pstr_eval (e, attrs) } ] ->\n pp f \"@[<2>%a@]%a\" (expression ctxt) e (item_attributes ctxt) attrs\n | PStr x -> structure ctxt f x\n | PTyp x ->\n pp f \":@ \";\n core_type ctxt f x\n | PSig x ->\n pp f \":@ \";\n signature ctxt f x\n | PPat (x, None) ->\n pp f \"?@ \";\n pattern ctxt f x\n | PPat (x, Some e) ->\n pp f \"?@ \";\n pattern ctxt f x;\n pp f \" when \";\n expression ctxt f e\n\n(* transform [f = fun g h -> ..] to [f g h = ... ] could be improved *)\nand binding ctxt f { pvb_pat = p; pvb_expr = x; _ } =\n (* .pvb_attributes have already been printed by the caller, #bindings *)\n let rec pp_print_pexp_function f x =\n if x.pexp_attributes <> [] then pp f \"=@;%a\" (expression ctxt) x\n else\n match x.pexp_desc with\n | Pexp_fun (label, eo, p, e) ->\n if label = Nolabel then\n pp f \"%a@ %a\" (simple_pattern ctxt) p pp_print_pexp_function e\n else\n pp f \"%a@ %a\" (label_exp ctxt) (label, eo, p) pp_print_pexp_function\n e\n | Pexp_newtype (str, e) ->\n pp f \"(type@ %s)@ %a\" str.txt pp_print_pexp_function e\n | _ -> pp f \"=@;%a\" (expression ctxt) x\n in\n let tyvars_str tyvars = List.map (fun v -> v.txt) tyvars in\n let is_desugared_gadt p e =\n let gadt_pattern =\n match p with\n | {\n ppat_desc =\n Ppat_constraint\n ( ({ ppat_desc = Ppat_var _ } as pat),\n { ptyp_desc = Ptyp_poly (args_tyvars, rt) } );\n ppat_attributes = [];\n } ->\n Some (pat, args_tyvars, rt)\n | _ -> None\n in\n let rec gadt_exp tyvars e =\n match e with\n | { pexp_desc = Pexp_newtype (tyvar, e); pexp_attributes = [] } ->\n gadt_exp (tyvar :: tyvars) e\n | { pexp_desc = Pexp_constraint (e, ct); pexp_attributes = [] } ->\n Some (List.rev tyvars, e, ct)\n | _ -> None\n in\n let gadt_exp = gadt_exp [] e in\n match (gadt_pattern, gadt_exp) with\n | Some (p, pt_tyvars, pt_ct), Some (e_tyvars, e, e_ct)\n when tyvars_str pt_tyvars = tyvars_str e_tyvars ->\n let ety = varify_type_constructors e_tyvars e_ct in\n if ety = pt_ct then Some (p, pt_tyvars, e_ct, e) else None\n | _ -> None\n in\n if x.pexp_attributes <> [] then\n match p with\n | {\n ppat_desc =\n Ppat_constraint\n ( ({ ppat_desc = Ppat_var _; _ } as pat),\n ({ ptyp_desc = Ptyp_poly _; _ } as typ) );\n ppat_attributes = [];\n _;\n } ->\n pp f \"%a@;: %a@;=@;%a\" (simple_pattern ctxt) pat (core_type ctxt) typ\n (expression ctxt) x\n | _ -> pp f \"%a@;=@;%a\" (pattern ctxt) p (expression ctxt) x\n else\n match is_desugared_gadt p x with\n | Some (p, [], ct, e) ->\n pp f \"%a@;: %a@;=@;%a\" (simple_pattern ctxt) p (core_type ctxt) ct\n (expression ctxt) e\n | Some (p, tyvars, ct, e) ->\n pp f \"%a@;: type@;%a.@;%a@;=@;%a\" (simple_pattern ctxt) p\n (list pp_print_string ~sep:\"@;\")\n (tyvars_str tyvars) (core_type ctxt) ct (expression ctxt) e\n | None -> (\n match p with\n | { ppat_desc = Ppat_constraint (p, ty); ppat_attributes = [] } -> (\n (* special case for the first*)\n match ty with\n | { ptyp_desc = Ptyp_poly _; ptyp_attributes = [] } ->\n pp f \"%a@;:@;%a@;=@;%a\" (simple_pattern ctxt) p (core_type ctxt)\n ty (expression ctxt) x\n | _ ->\n pp f \"(%a@;:@;%a)@;=@;%a\" (simple_pattern ctxt) p\n (core_type ctxt) ty (expression ctxt) x)\n | { ppat_desc = Ppat_var _; ppat_attributes = [] } ->\n pp f \"%a@ %a\" (simple_pattern ctxt) p pp_print_pexp_function x\n | _ -> pp f \"%a@;=@;%a\" (pattern ctxt) p (expression ctxt) x)\n\n(* [in] is not printed *)\nand bindings ctxt f (rf, l) =\n let binding kwd rf f x =\n pp f \"@[<2>%s %a%a@]%a\" kwd rec_flag rf (binding ctxt) x\n (item_attributes ctxt) x.pvb_attributes\n in\n match l with\n | [] -> ()\n | [ x ] -> binding \"let\" rf f x\n | x :: xs ->\n pp f \"@[%a@,%a@]\" (binding \"let\" rf) x\n (list ~sep:\"@,\" (binding \"and\" Nonrecursive))\n xs\n\nand binding_op ctxt f x =\n pp f \"@[<2>%s %a@;=@;%a@]\" x.pbop_op.txt (pattern ctxt) x.pbop_pat\n (expression ctxt) x.pbop_exp\n\nand structure_item ctxt f x =\n match x.pstr_desc with\n | Pstr_eval (e, attrs) ->\n pp f \"@[;;%a@]%a\" (expression ctxt) e (item_attributes ctxt) attrs\n | Pstr_type (_, []) -> assert false\n | Pstr_type (rf, l) -> type_def_list ctxt f (rf, true, l)\n | Pstr_value (rf, l) ->\n (* pp f \"@[let %a%a@]\" rec_flag rf bindings l *)\n pp f \"@[<2>%a@]\" (bindings ctxt) (rf, l)\n | Pstr_typext te -> type_extension ctxt f te\n | Pstr_exception ed -> exception_declaration ctxt f ed\n | Pstr_module x ->\n let rec module_helper = function\n | { pmod_desc = Pmod_functor (arg_opt, me'); pmod_attributes = [] } ->\n (match arg_opt with\n | Unit -> pp f \"()\"\n | Named (s, mt) ->\n pp f \"(%s:%a)\"\n (match s.txt with None -> \"_\" | Some s -> s)\n (module_type ctxt) mt);\n module_helper me'\n | me -> me\n in\n pp f \"@[module %s%a@]%a\"\n (match x.pmb_name.txt with None -> \"_\" | Some s -> s)\n (fun f me ->\n let me = module_helper me in\n match me with\n | {\n pmod_desc =\n Pmod_constraint\n (me', ({ pmty_desc = Pmty_ident _ | Pmty_signature _; _ } as mt));\n pmod_attributes = [];\n } ->\n pp f \" :@;%a@;=@;%a@;\" (module_type ctxt) mt (module_expr ctxt)\n me'\n | _ -> pp f \" =@ %a\" (module_expr ctxt) me)\n x.pmb_expr (item_attributes ctxt) x.pmb_attributes\n | Pstr_open od ->\n pp f \"@[<2>open%s@;%a@]%a\"\n (override od.popen_override)\n (module_expr ctxt) od.popen_expr (item_attributes ctxt)\n od.popen_attributes\n | Pstr_modtype { pmtd_name = s; pmtd_type = md; pmtd_attributes = attrs } ->\n pp f \"@[module@ type@ %s%a@]%a\" s.txt\n (fun f md ->\n match md with\n | None -> ()\n | Some mt ->\n pp_print_space f ();\n pp f \"@ =@ %a\" (module_type ctxt) mt)\n md (item_attributes ctxt) attrs\n | Pstr_class l -> (\n let extract_class_args cl =\n let rec loop acc = function\n | { pcl_desc = Pcl_fun (l, eo, p, cl'); pcl_attributes = [] } ->\n loop ((l, eo, p) :: acc) cl'\n | cl -> (List.rev acc, cl)\n in\n let args, cl = loop [] cl in\n let constr, cl =\n match cl with\n | { pcl_desc = Pcl_constraint (cl', ct); pcl_attributes = [] } ->\n (Some ct, cl')\n | _ -> (None, cl)\n in\n (args, constr, cl)\n in\n let class_constraint f ct = pp f \": @[%a@] \" (class_type ctxt) ct in\n let class_declaration kwd f\n ({ pci_params = ls; pci_name = { txt; _ }; _ } as x) =\n let args, constr, cl = extract_class_args x.pci_expr in\n pp f \"@[<2>%s %a%a%s %a%a=@;%a@]%a\" kwd virtual_flag x.pci_virt\n (class_params_def ctxt) ls txt\n (list (label_exp ctxt))\n args (option class_constraint) constr (class_expr ctxt) cl\n (item_attributes ctxt) x.pci_attributes\n in\n match l with\n | [] -> ()\n | [ x ] -> class_declaration \"class\" f x\n | x :: xs ->\n pp f \"@[%a@,%a@]\"\n (class_declaration \"class\")\n x\n (list ~sep:\"@,\" (class_declaration \"and\"))\n xs)\n | Pstr_class_type l -> class_type_declaration_list ctxt f l\n | Pstr_primitive vd ->\n pp f \"@[external@ %a@ :@ %a@]%a\" protect_ident vd.pval_name.txt\n (value_description ctxt) vd (item_attributes ctxt) vd.pval_attributes\n | Pstr_include incl ->\n pp f \"@[include@ %a@]%a\" (module_expr ctxt) incl.pincl_mod\n (item_attributes ctxt) incl.pincl_attributes\n | Pstr_recmodule decls -> (\n (* 3.07 *)\n let aux f = function\n | { pmb_expr = { pmod_desc = Pmod_constraint (expr, typ) } } as pmb ->\n pp f \"@[@ and@ %s:%a@ =@ %a@]%a\"\n (match pmb.pmb_name.txt with None -> \"_\" | Some s -> s)\n (module_type ctxt) typ (module_expr ctxt) expr\n (item_attributes ctxt) pmb.pmb_attributes\n | pmb ->\n pp f \"@[@ and@ %s@ =@ %a@]%a\"\n (match pmb.pmb_name.txt with None -> \"_\" | Some s -> s)\n (module_expr ctxt) pmb.pmb_expr (item_attributes ctxt)\n pmb.pmb_attributes\n in\n match decls with\n | ({ pmb_expr = { pmod_desc = Pmod_constraint (expr, typ) } } as pmb)\n :: l2 ->\n pp f \"@[@[module@ rec@ %s:%a@ =@ %a@]%a@ %a@]\"\n (match pmb.pmb_name.txt with None -> \"_\" | Some s -> s)\n (module_type ctxt) typ (module_expr ctxt) expr\n (item_attributes ctxt) pmb.pmb_attributes\n (fun f l2 -> List.iter (aux f) l2)\n l2\n | pmb :: l2 ->\n pp f \"@[@[module@ rec@ %s@ =@ %a@]%a@ %a@]\"\n (match pmb.pmb_name.txt with None -> \"_\" | Some s -> s)\n (module_expr ctxt) pmb.pmb_expr (item_attributes ctxt)\n pmb.pmb_attributes\n (fun f l2 -> List.iter (aux f) l2)\n l2\n | _ -> assert false)\n | Pstr_attribute a -> floating_attribute ctxt f a\n | Pstr_extension (e, a) ->\n item_extension ctxt f e;\n item_attributes ctxt f a\n\nand type_param ctxt f (ct, (a, b)) =\n pp f \"%s%s%a\" (type_variance a) (type_injectivity b) (core_type ctxt) ct\n\nand type_params ctxt f = function\n | [] -> ()\n | l -> pp f \"%a \" (list (type_param ctxt) ~first:\"(\" ~last:\")\" ~sep:\",@;\") l\n\nand type_def_list ctxt f (rf, exported, l) =\n let type_decl kwd rf f x =\n let eq =\n if x.ptype_kind = Ptype_abstract && x.ptype_manifest = None then \"\"\n else if exported then \" =\"\n else \" :=\"\n in\n pp f \"@[<2>%s %a%a%s%s%a@]%a\" kwd nonrec_flag rf (type_params ctxt)\n x.ptype_params x.ptype_name.txt eq (type_declaration ctxt) x\n (item_attributes ctxt) x.ptype_attributes\n in\n match l with\n | [] -> assert false\n | [ x ] -> type_decl \"type\" rf f x\n | x :: xs ->\n pp f \"@[%a@,%a@]\" (type_decl \"type\" rf) x\n (list ~sep:\"@,\" (type_decl \"and\" Recursive))\n xs\n\nand record_declaration ctxt f lbls =\n let type_record_field f pld =\n pp f \"@[<2>%a%s:@;%a@;%a@]\" mutable_flag pld.pld_mutable pld.pld_name.txt\n (core_type ctxt) pld.pld_type (attributes ctxt) pld.pld_attributes\n in\n pp f \"{@\\n%a}\" (list type_record_field ~sep:\";@\\n\") lbls\n\nand type_declaration ctxt f x =\n (* type_declaration has an attribute field,\n but it's been printed by the caller of this method *)\n let priv f =\n match x.ptype_private with Public -> () | Private -> pp f \"@;private\"\n in\n let manifest f =\n match x.ptype_manifest with\n | None -> ()\n | Some y ->\n if x.ptype_kind = Ptype_abstract then\n pp f \"%t@;%a\" priv (core_type ctxt) y\n else pp f \"@;%a\" (core_type ctxt) y\n in\n let constructor_declaration f pcd =\n pp f \"|@;\";\n constructor_declaration ctxt f\n (pcd.pcd_name.txt, pcd.pcd_args, pcd.pcd_res, pcd.pcd_attributes)\n in\n let repr f =\n let intro f = if x.ptype_manifest = None then () else pp f \"@;=\" in\n match x.ptype_kind with\n | Ptype_variant xs ->\n let variants fmt xs =\n if xs = [] then pp fmt \" |\"\n else pp fmt \"@\\n%a\" (list ~sep:\"@\\n\" constructor_declaration) xs\n in\n pp f \"%t%t%a\" intro priv variants xs\n | Ptype_abstract -> ()\n | Ptype_record l -> pp f \"%t%t@;%a\" intro priv (record_declaration ctxt) l\n | Ptype_open -> pp f \"%t%t@;..\" intro priv\n in\n let constraints f =\n List.iter\n (fun (ct1, ct2, _) ->\n pp f \"@[@ constraint@ %a@ =@ %a@]\" (core_type ctxt) ct1\n (core_type ctxt) ct2)\n x.ptype_cstrs\n in\n pp f \"%t%t%t\" manifest repr constraints\n\nand type_extension ctxt f x =\n let extension_constructor f x =\n pp f \"@\\n|@;%a\" (extension_constructor ctxt) x\n in\n pp f \"@[<2>type %a%a += %a@ %a@]%a\"\n (fun f -> function\n | [] -> ()\n | l ->\n pp f \"%a@;\" (list (type_param ctxt) ~first:\"(\" ~last:\")\" ~sep:\",\") l)\n x.ptyext_params longident_loc x.ptyext_path private_flag\n x.ptyext_private (* Cf: #7200 *)\n (list ~sep:\"\" extension_constructor)\n x.ptyext_constructors (item_attributes ctxt) x.ptyext_attributes\n\nand constructor_declaration ctxt f (name, args, res, attrs) =\n let name = match name with \"::\" -> \"(::)\" | s -> s in\n match res with\n | None ->\n pp f \"%s%a@;%a\" name\n (fun f -> function\n | Pcstr_tuple [] -> ()\n | Pcstr_tuple l ->\n pp f \"@;of@;%a\" (list (core_type1 ctxt) ~sep:\"@;*@;\") l\n | Pcstr_record l -> pp f \"@;of@;%a\" (record_declaration ctxt) l)\n args (attributes ctxt) attrs\n | Some r ->\n pp f \"%s:@;%a@;%a\" name\n (fun f -> function\n | Pcstr_tuple [] -> core_type1 ctxt f r\n | Pcstr_tuple l ->\n pp f \"%a@;->@;%a\"\n (list (core_type1 ctxt) ~sep:\"@;*@;\")\n l (core_type1 ctxt) r\n | Pcstr_record l ->\n pp f \"%a@;->@;%a\" (record_declaration ctxt) l (core_type1 ctxt) r)\n args (attributes ctxt) attrs\n\nand extension_constructor ctxt f x =\n (* Cf: #7200 *)\n match x.pext_kind with\n | Pext_decl (l, r) ->\n constructor_declaration ctxt f (x.pext_name.txt, l, r, x.pext_attributes)\n | Pext_rebind li ->\n pp f \"%s@;=@;%a%a\" x.pext_name.txt longident_loc li (attributes ctxt)\n x.pext_attributes\n\nand case_list ctxt f l : unit =\n let aux f { pc_lhs; pc_guard; pc_rhs } =\n pp f \"@;| @[<2>%a%a@;->@;%a@]\" (pattern ctxt) pc_lhs\n (option (expression ctxt) ~first:\"@;when@;\")\n pc_guard\n (expression (under_pipe ctxt))\n pc_rhs\n in\n list aux f l ~sep:\"\"\n\nand label_x_expression_param ctxt f (l, e) =\n let simple_name =\n match e with\n | { pexp_desc = Pexp_ident { txt = Lident l; _ }; pexp_attributes = [] } ->\n Some l\n | _ -> None\n in\n match l with\n | Nolabel -> expression2 ctxt f e (* level 2*)\n | Optional str ->\n if Some str = simple_name then pp f \"?%s\" str\n else pp f \"?%s:%a\" str (simple_expr ctxt) e\n | Labelled lbl ->\n if Some lbl = simple_name then pp f \"~%s\" lbl\n else pp f \"~%s:%a\" lbl (simple_expr ctxt) e\n\nand directive_argument f x =\n match x.pdira_desc with\n | Pdir_string s -> pp f \"@ %S\" s\n | Pdir_int (n, None) -> pp f \"@ %s\" n\n | Pdir_int (n, Some m) -> pp f \"@ %s%c\" n m\n | Pdir_ident li -> pp f \"@ %a\" longident li\n | Pdir_bool b -> pp f \"@ %s\" (string_of_bool b)\n\nlet toplevel_phrase f x =\n match x with\n | Ptop_def s -> pp f \"@[%a@]\" (list (structure_item reset_ctxt)) s\n (* pp_open_hvbox f 0; *)\n (* pp_print_list structure_item f s ; *)\n (* pp_close_box f (); *)\n | Ptop_dir { pdir_name; pdir_arg = None; _ } ->\n pp f \"@[#%s@]\" pdir_name.txt\n | Ptop_dir { pdir_name; pdir_arg = Some pdir_arg; _ } ->\n pp f \"@[#%s@ %a@]\" pdir_name.txt directive_argument pdir_arg\n\nlet expression f x = pp f \"@[%a@]\" (expression reset_ctxt) x\n\nlet string_of_expression x =\n ignore (flush_str_formatter ());\n let f = str_formatter in\n expression f x;\n flush_str_formatter ()\n\nlet string_of_structure x =\n ignore (flush_str_formatter ());\n let f = str_formatter in\n structure reset_ctxt f x;\n flush_str_formatter ()\n\nlet top_phrase f x =\n pp_print_newline f ();\n toplevel_phrase f x;\n pp f \";;\";\n pp_print_newline f ()\n\nlet core_type = core_type reset_ctxt\nlet pattern = pattern reset_ctxt\nlet signature = signature reset_ctxt\nlet structure = structure reset_ctxt\nlet class_expr = class_expr reset_ctxt\nlet class_field = class_field reset_ctxt\nlet class_type = class_type reset_ctxt\nlet class_signature = class_signature reset_ctxt\nlet class_type_field = class_type_field reset_ctxt\nlet module_expr = module_expr reset_ctxt\nlet module_type = module_type reset_ctxt\nlet signature_item = signature_item reset_ctxt\nlet structure_item = structure_item reset_ctxt\nlet type_declaration = type_declaration reset_ctxt\n","(**************************************************************************)\n(* *)\n(* OCaml Migrate Parsetree *)\n(* *)\n(* Frédéric Bour, Facebook *)\n(* Jérémie Dimino and Leo White, Jane Street Europe *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* Alain Frisch, LexiFi *)\n(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 2018 Institut National de Recherche en Informatique et *)\n(* en Automatique (INRIA). *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nmodule Asttypes = struct\n type constant (*IF_CURRENT = Asttypes.constant *) =\n Const_int of int\n | Const_char of char\n | Const_string of string * Location.t * string option\n | Const_float of string\n | Const_int32 of int32\n | Const_int64 of int64\n | Const_nativeint of nativeint\n\n type rec_flag (*IF_CURRENT = Asttypes.rec_flag *) = Nonrecursive | Recursive\n\n type direction_flag (*IF_CURRENT = Asttypes.direction_flag *) = Upto | Downto\n\n (* Order matters, used in polymorphic comparison *)\n type private_flag (*IF_CURRENT = Asttypes.private_flag *) = Private | Public\n\n type mutable_flag (*IF_CURRENT = Asttypes.mutable_flag *) = Immutable | Mutable\n\n type virtual_flag (*IF_CURRENT = Asttypes.virtual_flag *) = Virtual | Concrete\n\n type override_flag (*IF_CURRENT = Asttypes.override_flag *) = Override | Fresh\n\n type closed_flag (*IF_CURRENT = Asttypes.closed_flag *) = Closed | Open\n\n type label = string\n\n type arg_label (*IF_CURRENT = Asttypes.arg_label *) =\n Nolabel\n | Labelled of string (* label:T -> ... *)\n | Optional of string (* ?label:T -> ... *)\n\n type 'a loc = 'a Location.loc = {\n txt : 'a;\n loc : Location.t;\n }\n\n type variance (*IF_CURRENT = Asttypes.variance *) =\n | Covariant\n | Contravariant\n | NoVariance\n\n type injectivity (*IF_CURRENT = Asttypes.injectivity *) =\n | Injective\n | NoInjectivity\nend\n\nmodule Parsetree = struct\n open Asttypes\n\n type constant (*IF_CURRENT = Parsetree.constant *) =\n Pconst_integer of string * char option\n (* 3 3l 3L 3n\n\n Suffixes [g-z][G-Z] are accepted by the parser.\n Suffixes except 'l', 'L' and 'n' are rejected by the typechecker\n *)\n | Pconst_char of char\n (* 'c' *)\n | Pconst_string of string * Location.t * string option\n (* \"constant\"\n {delim|other constant|delim}\n\n The location span the content of the string, without the delimiters.\n *)\n | Pconst_float of string * char option\n (* 3.4 2e5 1.4e-4\n\n Suffixes [g-z][G-Z] are accepted by the parser.\n Suffixes are rejected by the typechecker.\n *)\n\n type location_stack = Location.t list\n\n (** {1 Extension points} *)\n\n type attribute (*IF_CURRENT = Parsetree.attribute *) = {\n attr_name : string loc;\n attr_payload : payload;\n attr_loc : Location.t;\n }\n (* [@id ARG]\n [@@id ARG]\n\n Metadata containers passed around within the AST.\n The compiler ignores unknown attributes.\n *)\n\n and extension = string loc * payload\n (* [%id ARG]\n [%%id ARG]\n\n Sub-language placeholder -- rejected by the typechecker.\n *)\n\n and attributes = attribute list\n\n and payload (*IF_CURRENT = Parsetree.payload *) =\n | PStr of structure\n | PSig of signature (* : SIG *)\n | PTyp of core_type (* : T *)\n | PPat of pattern * expression option (* ? P or ? P when E *)\n\n (** {1 Core language} *)\n\n (* Type expressions *)\n\n and core_type (*IF_CURRENT = Parsetree.core_type *) =\n {\n ptyp_desc: core_type_desc;\n ptyp_loc: Location.t;\n ptyp_loc_stack: location_stack;\n ptyp_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and core_type_desc (*IF_CURRENT = Parsetree.core_type_desc *) =\n | Ptyp_any\n (* _ *)\n | Ptyp_var of string\n (* 'a *)\n | Ptyp_arrow of arg_label * core_type * core_type\n (* T1 -> T2 Simple\n ~l:T1 -> T2 Labelled\n ?l:T1 -> T2 Optional\n *)\n | Ptyp_tuple of core_type list\n (* T1 * ... * Tn\n\n Invariant: n >= 2\n *)\n | Ptyp_constr of Longident.t loc * core_type list\n (* tconstr\n T tconstr\n (T1, ..., Tn) tconstr\n *)\n | Ptyp_object of object_field list * closed_flag\n (* < l1:T1; ...; ln:Tn > (flag = Closed)\n < l1:T1; ...; ln:Tn; .. > (flag = Open)\n *)\n | Ptyp_class of Longident.t loc * core_type list\n (* #tconstr\n T #tconstr\n (T1, ..., Tn) #tconstr\n *)\n | Ptyp_alias of core_type * string\n (* T as 'a *)\n | Ptyp_variant of row_field list * closed_flag * label list option\n (* [ `A|`B ] (flag = Closed; labels = None)\n [> `A|`B ] (flag = Open; labels = None)\n [< `A|`B ] (flag = Closed; labels = Some [])\n [< `A|`B > `X `Y ](flag = Closed; labels = Some [\"X\";\"Y\"])\n *)\n | Ptyp_poly of string loc list * core_type\n (* 'a1 ... 'an. T\n\n Can only appear in the following context:\n\n - As the core_type of a Ppat_constraint node corresponding\n to a constraint on a let-binding: let x : 'a1 ... 'an. T\n = e ...\n\n - Under Cfk_virtual for methods (not values).\n\n - As the core_type of a Pctf_method node.\n\n - As the core_type of a Pexp_poly node.\n\n - As the pld_type field of a label_declaration.\n\n - As a core_type of a Ptyp_object node.\n *)\n\n | Ptyp_package of package_type\n (* (module S) *)\n | Ptyp_extension of extension\n (* [%id] *)\n\n and package_type = Longident.t loc * (Longident.t loc * core_type) list\n (*\n (module S)\n (module S with type t1 = T1 and ... and tn = Tn)\n *)\n\n and row_field (*IF_CURRENT = Parsetree.row_field *) = {\n prf_desc : row_field_desc;\n prf_loc : Location.t;\n prf_attributes : attributes;\n }\n\n and row_field_desc (*IF_CURRENT = Parsetree.row_field_desc *) =\n | Rtag of label loc * bool * core_type list\n (* [`A] ( true, [] )\n [`A of T] ( false, [T] )\n [`A of T1 & .. & Tn] ( false, [T1;...Tn] )\n [`A of & T1 & .. & Tn] ( true, [T1;...Tn] )\n\n - The 'bool' field is true if the tag contains a\n constant (empty) constructor.\n - '&' occurs when several types are used for the same constructor\n (see 4.2 in the manual)\n *)\n | Rinherit of core_type\n (* [ T ] *)\n\n and object_field (*IF_CURRENT = Parsetree.object_field *) = {\n pof_desc : object_field_desc;\n pof_loc : Location.t;\n pof_attributes : attributes;\n }\n\n and object_field_desc (*IF_CURRENT = Parsetree.object_field_desc *) =\n | Otag of label loc * core_type\n | Oinherit of core_type\n\n (* Patterns *)\n\n and pattern (*IF_CURRENT = Parsetree.pattern *) =\n {\n ppat_desc: pattern_desc;\n ppat_loc: Location.t;\n ppat_loc_stack: location_stack;\n ppat_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and pattern_desc (*IF_CURRENT = Parsetree.pattern_desc *) =\n | Ppat_any\n (* _ *)\n | Ppat_var of string loc\n (* x *)\n | Ppat_alias of pattern * string loc\n (* P as 'a *)\n | Ppat_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Ppat_interval of constant * constant\n (* 'a'..'z'\n\n Other forms of interval are recognized by the parser\n but rejected by the type-checker. *)\n | Ppat_tuple of pattern list\n (* (P1, ..., Pn)\n\n Invariant: n >= 2\n *)\n | Ppat_construct of Longident.t loc * (string loc list * pattern) option\n (* C None\n C P Some ([], P)\n C (P1, ..., Pn) Some ([], Ppat_tuple [P1; ...; Pn])\n C (type a b) P Some ([a; b], P)\n *)\n | Ppat_variant of label * pattern option\n (* `A (None)\n `A P (Some P)\n *)\n | Ppat_record of (Longident.t loc * pattern) list * closed_flag\n (* { l1=P1; ...; ln=Pn } (flag = Closed)\n { l1=P1; ...; ln=Pn; _} (flag = Open)\n\n Invariant: n > 0\n *)\n | Ppat_array of pattern list\n (* [| P1; ...; Pn |] *)\n | Ppat_or of pattern * pattern\n (* P1 | P2 *)\n | Ppat_constraint of pattern * core_type\n (* (P : T) *)\n | Ppat_type of Longident.t loc\n (* #tconst *)\n | Ppat_lazy of pattern\n (* lazy P *)\n | Ppat_unpack of string option loc\n (* (module P) Some \"P\"\n (module _) None\n\n Note: (module P : S) is represented as\n Ppat_constraint(Ppat_unpack, Ptyp_package)\n *)\n | Ppat_exception of pattern\n (* exception P *)\n | Ppat_extension of extension\n (* [%id] *)\n | Ppat_open of Longident.t loc * pattern\n (* M.(P) *)\n\n (* Value expressions *)\n\n and expression (*IF_CURRENT = Parsetree.expression *) =\n {\n pexp_desc: expression_desc;\n pexp_loc: Location.t;\n pexp_loc_stack: location_stack;\n pexp_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and expression_desc (*IF_CURRENT = Parsetree.expression_desc *) =\n | Pexp_ident of Longident.t loc\n (* x\n M.x\n *)\n | Pexp_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Pexp_let of rec_flag * value_binding list * expression\n (* let P1 = E1 and ... and Pn = EN in E (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in E (flag = Recursive)\n *)\n | Pexp_function of case list\n (* function P1 -> E1 | ... | Pn -> En *)\n | Pexp_fun of arg_label * expression option * pattern * expression\n (* fun P -> E1 (Simple, None)\n fun ~l:P -> E1 (Labelled l, None)\n fun ?l:P -> E1 (Optional l, None)\n fun ?l:(P = E0) -> E1 (Optional l, Some E0)\n\n Notes:\n - If E0 is provided, only Optional is allowed.\n - \"fun P1 P2 .. Pn -> E1\" is represented as nested Pexp_fun.\n - \"let f P = E\" is represented using Pexp_fun.\n *)\n | Pexp_apply of expression * (arg_label * expression) list\n (* E0 ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pexp_match of expression * case list\n (* match E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_try of expression * case list\n (* try E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_tuple of expression list\n (* (E1, ..., En)\n\n Invariant: n >= 2\n *)\n | Pexp_construct of Longident.t loc * expression option\n (* C None\n C E Some E\n C (E1, ..., En) Some (Pexp_tuple[E1;...;En])\n *)\n | Pexp_variant of label * expression option\n (* `A (None)\n `A E (Some E)\n *)\n | Pexp_record of (Longident.t loc * expression) list * expression option\n (* { l1=P1; ...; ln=Pn } (None)\n { E0 with l1=P1; ...; ln=Pn } (Some E0)\n\n Invariant: n > 0\n *)\n | Pexp_field of expression * Longident.t loc\n (* E.l *)\n | Pexp_setfield of expression * Longident.t loc * expression\n (* E1.l <- E2 *)\n | Pexp_array of expression list\n (* [| E1; ...; En |] *)\n | Pexp_ifthenelse of expression * expression * expression option\n (* if E1 then E2 else E3 *)\n | Pexp_sequence of expression * expression\n (* E1; E2 *)\n | Pexp_while of expression * expression\n (* while E1 do E2 done *)\n | Pexp_for of\n pattern * expression * expression * direction_flag * expression\n (* for i = E1 to E2 do E3 done (flag = Upto)\n for i = E1 downto E2 do E3 done (flag = Downto)\n *)\n | Pexp_constraint of expression * core_type\n (* (E : T) *)\n | Pexp_coerce of expression * core_type option * core_type\n (* (E :> T) (None, T)\n (E : T0 :> T) (Some T0, T)\n *)\n | Pexp_send of expression * label loc\n (* E # m *)\n | Pexp_new of Longident.t loc\n (* new M.c *)\n | Pexp_setinstvar of label loc * expression\n (* x <- 2 *)\n | Pexp_override of (label loc * expression) list\n (* {< x1 = E1; ...; Xn = En >} *)\n | Pexp_letmodule of string option loc * module_expr * expression\n (* let module M = ME in E *)\n | Pexp_letexception of extension_constructor * expression\n (* let exception C in E *)\n | Pexp_assert of expression\n (* assert E\n Note: \"assert false\" is treated in a special way by the\n type-checker. *)\n | Pexp_lazy of expression\n (* lazy E *)\n | Pexp_poly of expression * core_type option\n (* Used for method bodies.\n\n Can only be used as the expression under Cfk_concrete\n for methods (not values). *)\n | Pexp_object of class_structure\n (* object ... end *)\n | Pexp_newtype of string loc * expression\n (* fun (type t) -> E *)\n | Pexp_pack of module_expr\n (* (module ME)\n\n (module ME : S) is represented as\n Pexp_constraint(Pexp_pack, Ptyp_package S) *)\n | Pexp_open of open_declaration * expression\n (* M.(E)\n let open M in E\n let! open M in E *)\n | Pexp_letop of letop\n (* let* P = E in E\n let* P = E and* P = E in E *)\n | Pexp_extension of extension\n (* [%id] *)\n | Pexp_unreachable\n (* . *)\n\n and case (*IF_CURRENT = Parsetree.case *) = (* (P -> E) or (P when E0 -> E) *)\n {\n pc_lhs: pattern;\n pc_guard: expression option;\n pc_rhs: expression;\n }\n\n and letop (*IF_CURRENT = Parsetree.letop *) =\n {\n let_ : binding_op;\n ands : binding_op list;\n body : expression;\n }\n\n and binding_op (*IF_CURRENT = Parsetree.binding_op *) =\n {\n pbop_op : string loc;\n pbop_pat : pattern;\n pbop_exp : expression;\n pbop_loc : Location.t;\n }\n\n (* Value descriptions *)\n\n and value_description (*IF_CURRENT = Parsetree.value_description *) =\n {\n pval_name: string loc;\n pval_type: core_type;\n pval_prim: string list;\n pval_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pval_loc: Location.t;\n }\n\n(*\n val x: T (prim = [])\n external x: T = \"s1\" ... \"sn\" (prim = [\"s1\";...\"sn\"])\n*)\n\n (* Type declarations *)\n\n and type_declaration (*IF_CURRENT = Parsetree.type_declaration *) =\n {\n ptype_name: string loc;\n ptype_params: (core_type * (variance * injectivity)) list;\n (* ('a1,...'an) t; None represents _*)\n ptype_cstrs: (core_type * core_type * Location.t) list;\n (* ... constraint T1=T1' ... constraint Tn=Tn' *)\n ptype_kind: type_kind;\n ptype_private: private_flag; (* = private ... *)\n ptype_manifest: core_type option; (* = T *)\n ptype_attributes: attributes; (* ... [@@id1] [@@id2] *)\n ptype_loc: Location.t;\n }\n\n(*\n type t (abstract, no manifest)\n type t = T0 (abstract, manifest=T0)\n type t = C of T | ... (variant, no manifest)\n type t = T0 = C of T | ... (variant, manifest=T0)\n type t = {l: T; ...} (record, no manifest)\n type t = T0 = {l : T; ...} (record, manifest=T0)\n type t = .. (open, no manifest)\n*)\n\n and type_kind (*IF_CURRENT = Parsetree.type_kind *) =\n | Ptype_abstract\n | Ptype_variant of constructor_declaration list\n | Ptype_record of label_declaration list\n (* Invariant: non-empty list *)\n | Ptype_open\n\n and label_declaration (*IF_CURRENT = Parsetree.label_declaration *) =\n {\n pld_name: string loc;\n pld_mutable: mutable_flag;\n pld_type: core_type;\n pld_loc: Location.t;\n pld_attributes: attributes; (* l : T [@id1] [@id2] *)\n }\n\n (* { ...; l: T; ... } (mutable=Immutable)\n { ...; mutable l: T; ... } (mutable=Mutable)\n\n Note: T can be a Ptyp_poly.\n *)\n\n and constructor_declaration (*IF_CURRENT = Parsetree.constructor_declaration *) =\n {\n pcd_name: string loc;\n pcd_args: constructor_arguments;\n pcd_res: core_type option;\n pcd_loc: Location.t;\n pcd_attributes: attributes; (* C of ... [@id1] [@id2] *)\n }\n\n and constructor_arguments (*IF_CURRENT = Parsetree.constructor_arguments *) =\n | Pcstr_tuple of core_type list\n | Pcstr_record of label_declaration list\n\n(*\n | C of T1 * ... * Tn (res = None, args = Pcstr_tuple [])\n | C: T0 (res = Some T0, args = [])\n | C: T1 * ... * Tn -> T0 (res = Some T0, args = Pcstr_tuple)\n | C of {...} (res = None, args = Pcstr_record)\n | C: {...} -> T0 (res = Some T0, args = Pcstr_record)\n | C of {...} as t (res = None, args = Pcstr_record)\n*)\n\n and type_extension (*IF_CURRENT = Parsetree.type_extension *) =\n {\n ptyext_path: Longident.t loc;\n ptyext_params: (core_type * (variance * injectivity)) list;\n ptyext_constructors: extension_constructor list;\n ptyext_private: private_flag;\n ptyext_loc: Location.t;\n ptyext_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n(*\n type t += ...\n*)\n\n and extension_constructor (*IF_CURRENT = Parsetree.extension_constructor *) =\n {\n pext_name: string loc;\n pext_kind : extension_constructor_kind;\n pext_loc : Location.t;\n pext_attributes: attributes; (* C of ... [@id1] [@id2] *)\n }\n\n (* exception E *)\n and type_exception (*IF_CURRENT = Parsetree.type_exception *) =\n {\n ptyexn_constructor: extension_constructor;\n ptyexn_loc: Location.t;\n ptyexn_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and extension_constructor_kind (*IF_CURRENT = Parsetree.extension_constructor_kind *) =\n Pext_decl of constructor_arguments * core_type option\n (*\n | C of T1 * ... * Tn ([T1; ...; Tn], None)\n | C: T0 ([], Some T0)\n | C: T1 * ... * Tn -> T0 ([T1; ...; Tn], Some T0)\n *)\n | Pext_rebind of Longident.t loc\n (*\n | C = D\n *)\n\n (** {1 Class language} *)\n\n (* Type expressions for the class language *)\n\n and class_type (*IF_CURRENT = Parsetree.class_type *) =\n {\n pcty_desc: class_type_desc;\n pcty_loc: Location.t;\n pcty_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and class_type_desc (*IF_CURRENT = Parsetree.class_type_desc *) =\n | Pcty_constr of Longident.t loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcty_signature of class_signature\n (* object ... end *)\n | Pcty_arrow of arg_label * core_type * class_type\n (* T -> CT Simple\n ~l:T -> CT Labelled l\n ?l:T -> CT Optional l\n *)\n | Pcty_extension of extension\n (* [%id] *)\n | Pcty_open of open_description * class_type\n (* let open M in CT *)\n\n and class_signature (*IF_CURRENT = Parsetree.class_signature *) =\n {\n pcsig_self: core_type;\n pcsig_fields: class_type_field list;\n }\n (* object('selfpat) ... end\n object ... end (self = Ptyp_any)\n *)\n\n and class_type_field (*IF_CURRENT = Parsetree.class_type_field *) =\n {\n pctf_desc: class_type_field_desc;\n pctf_loc: Location.t;\n pctf_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and class_type_field_desc (*IF_CURRENT = Parsetree.class_type_field_desc *) =\n | Pctf_inherit of class_type\n (* inherit CT *)\n | Pctf_val of (label loc * mutable_flag * virtual_flag * core_type)\n (* val x: T *)\n | Pctf_method of (label loc * private_flag * virtual_flag * core_type)\n (* method x: T\n\n Note: T can be a Ptyp_poly.\n *)\n | Pctf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pctf_attribute of attribute\n (* [@@@id] *)\n | Pctf_extension of extension\n (* [%%id] *)\n\n and 'a class_infos (*IF_CURRENT = 'a Parsetree.class_infos *) =\n {\n pci_virt: virtual_flag;\n pci_params: (core_type * (variance * injectivity)) list;\n pci_name: string loc;\n pci_expr: 'a;\n pci_loc: Location.t;\n pci_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n (* class c = ...\n class ['a1,...,'an] c = ...\n class virtual c = ...\n\n Also used for \"class type\" declaration.\n *)\n\n and class_description = class_type class_infos\n\n and class_type_declaration = class_type class_infos\n\n (* Value expressions for the class language *)\n\n and class_expr (*IF_CURRENT = Parsetree.class_expr *) =\n {\n pcl_desc: class_expr_desc;\n pcl_loc: Location.t;\n pcl_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and class_expr_desc (*IF_CURRENT = Parsetree.class_expr_desc *) =\n | Pcl_constr of Longident.t loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcl_structure of class_structure\n (* object ... end *)\n | Pcl_fun of arg_label * expression option * pattern * class_expr\n (* fun P -> CE (Simple, None)\n fun ~l:P -> CE (Labelled l, None)\n fun ?l:P -> CE (Optional l, None)\n fun ?l:(P = E0) -> CE (Optional l, Some E0)\n *)\n | Pcl_apply of class_expr * (arg_label * expression) list\n (* CE ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pcl_let of rec_flag * value_binding list * class_expr\n (* let P1 = E1 and ... and Pn = EN in CE (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in CE (flag = Recursive)\n *)\n | Pcl_constraint of class_expr * class_type\n (* (CE : CT) *)\n | Pcl_extension of extension\n (* [%id] *)\n | Pcl_open of open_description * class_expr\n (* let open M in CE *)\n\n\n and class_structure (*IF_CURRENT = Parsetree.class_structure *) =\n {\n pcstr_self: pattern;\n pcstr_fields: class_field list;\n }\n (* object(selfpat) ... end\n object ... end (self = Ppat_any)\n *)\n\n and class_field (*IF_CURRENT = Parsetree.class_field *) =\n {\n pcf_desc: class_field_desc;\n pcf_loc: Location.t;\n pcf_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and class_field_desc (*IF_CURRENT = Parsetree.class_field_desc *) =\n | Pcf_inherit of override_flag * class_expr * string loc option\n (* inherit CE\n inherit CE as x\n inherit! CE\n inherit! CE as x\n *)\n | Pcf_val of (label loc * mutable_flag * class_field_kind)\n (* val x = E\n val virtual x: T\n *)\n | Pcf_method of (label loc * private_flag * class_field_kind)\n (* method x = E (E can be a Pexp_poly)\n method virtual x: T (T can be a Ptyp_poly)\n *)\n | Pcf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pcf_initializer of expression\n (* initializer E *)\n | Pcf_attribute of attribute\n (* [@@@id] *)\n | Pcf_extension of extension\n (* [%%id] *)\n\n and class_field_kind (*IF_CURRENT = Parsetree.class_field_kind *) =\n | Cfk_virtual of core_type\n | Cfk_concrete of override_flag * expression\n\n and class_declaration = class_expr class_infos\n\n (** {1 Module language} *)\n\n (* Type expressions for the module language *)\n\n and module_type (*IF_CURRENT = Parsetree.module_type *) =\n {\n pmty_desc: module_type_desc;\n pmty_loc: Location.t;\n pmty_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and module_type_desc (*IF_CURRENT = Parsetree.module_type_desc *) =\n | Pmty_ident of Longident.t loc\n (* S *)\n | Pmty_signature of signature\n (* sig ... end *)\n | Pmty_functor of functor_parameter * module_type\n (* functor(X : MT1) -> MT2 *)\n | Pmty_with of module_type * with_constraint list\n (* MT with ... *)\n | Pmty_typeof of module_expr\n (* module type of ME *)\n | Pmty_extension of extension\n (* [%id] *)\n | Pmty_alias of Longident.t loc\n (* (module M) *)\n\n and functor_parameter (*IF_CURRENT = Parsetree.functor_parameter *) =\n | Unit\n (* () *)\n | Named of string option loc * module_type\n (* (X : MT) Some X, MT\n (_ : MT) None, MT *)\n\n and signature = signature_item list\n\n and signature_item (*IF_CURRENT = Parsetree.signature_item *) =\n {\n psig_desc: signature_item_desc;\n psig_loc: Location.t;\n }\n\n and signature_item_desc (*IF_CURRENT = Parsetree.signature_item_desc *) =\n | Psig_value of value_description\n (*\n val x: T\n external x: T = \"s1\" ... \"sn\"\n *)\n | Psig_type of rec_flag * type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Psig_typesubst of type_declaration list\n (* type t1 := ... and ... and tn := ... *)\n | Psig_typext of type_extension\n (* type t1 += ... *)\n | Psig_exception of type_exception\n (* exception C of T *)\n | Psig_module of module_declaration\n (* module X = M\n module X : MT *)\n | Psig_modsubst of module_substitution\n (* module X := M *)\n | Psig_recmodule of module_declaration list\n (* module rec X1 : MT1 and ... and Xn : MTn *)\n | Psig_modtype of module_type_declaration\n (* module type S = MT\n module type S *)\n | Psig_modtypesubst of module_type_declaration\n (* module type S := ... *)\n | Psig_open of open_description\n (* open X *)\n | Psig_include of include_description\n (* include MT *)\n | Psig_class of class_description list\n (* class c1 : ... and ... and cn : ... *)\n | Psig_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Psig_attribute of attribute\n (* [@@@id] *)\n | Psig_extension of extension * attributes\n (* [%%id] *)\n\n and module_declaration (*IF_CURRENT = Parsetree.module_declaration *) =\n {\n pmd_name: string option loc;\n pmd_type: module_type;\n pmd_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pmd_loc: Location.t;\n }\n (* S : MT *)\n\n and module_substitution (*IF_CURRENT = Parsetree.module_substitution *) =\n {\n pms_name: string loc;\n pms_manifest: Longident.t loc;\n pms_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pms_loc: Location.t;\n }\n\n and module_type_declaration (*IF_CURRENT = Parsetree.module_type_declaration *) =\n {\n pmtd_name: string loc;\n pmtd_type: module_type option;\n pmtd_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pmtd_loc: Location.t;\n }\n (* S = MT\n S (abstract module type declaration, pmtd_type = None)\n *)\n\n and 'a open_infos (*IF_CURRENT = 'a Parsetree.open_infos *) =\n {\n popen_expr: 'a;\n popen_override: override_flag;\n popen_loc: Location.t;\n popen_attributes: attributes;\n }\n (* open! X - popen_override = Override (silences the 'used identifier\n shadowing' warning)\n open X - popen_override = Fresh\n *)\n\n and open_description = Longident.t loc open_infos\n (* open M.N\n open M(N).O *)\n\n and open_declaration = module_expr open_infos\n (* open M.N\n open M(N).O\n open struct ... end *)\n\n and 'a include_infos (*IF_CURRENT = 'a Parsetree.include_infos *) =\n {\n pincl_mod: 'a;\n pincl_loc: Location.t;\n pincl_attributes: attributes;\n }\n\n and include_description = module_type include_infos\n (* include MT *)\n\n and include_declaration = module_expr include_infos\n (* include ME *)\n\n and with_constraint (*IF_CURRENT = Parsetree.with_constraint *) =\n | Pwith_type of Longident.t loc * type_declaration\n (* with type X.t = ...\n\n Note: the last component of the longident must match\n the name of the type_declaration. *)\n | Pwith_module of Longident.t loc * Longident.t loc\n (* with module X.Y = Z *)\n | Pwith_modtype of Longident.t loc * module_type\n (* with module type X.Y = Z *)\n | Pwith_modtypesubst of Longident.t loc * module_type\n (* with module type X.Y := sig end *)\n | Pwith_typesubst of Longident.t loc * type_declaration\n (* with type X.t := ..., same format as [Pwith_type] *)\n | Pwith_modsubst of Longident.t loc * Longident.t loc\n (* with module X.Y := Z *)\n\n (* Value expressions for the module language *)\n\n and module_expr (*IF_CURRENT = Parsetree.module_expr *) =\n {\n pmod_desc: module_expr_desc;\n pmod_loc: Location.t;\n pmod_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and module_expr_desc (*IF_CURRENT = Parsetree.module_expr_desc *) =\n | Pmod_ident of Longident.t loc\n (* X *)\n | Pmod_structure of structure\n (* struct ... end *)\n | Pmod_functor of functor_parameter * module_expr\n (* functor(X : MT1) -> ME *)\n | Pmod_apply of module_expr * module_expr\n (* ME1(ME2) *)\n | Pmod_constraint of module_expr * module_type\n (* (ME : MT) *)\n | Pmod_unpack of expression\n (* (val E) *)\n | Pmod_extension of extension\n (* [%id] *)\n\n and structure = structure_item list\n\n and structure_item (*IF_CURRENT = Parsetree.structure_item *) =\n {\n pstr_desc: structure_item_desc;\n pstr_loc: Location.t;\n }\n\n and structure_item_desc (*IF_CURRENT = Parsetree.structure_item_desc *) =\n | Pstr_eval of expression * attributes\n (* E *)\n | Pstr_value of rec_flag * value_binding list\n (* let P1 = E1 and ... and Pn = EN (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN (flag = Recursive)\n *)\n | Pstr_primitive of value_description\n (* val x: T\n external x: T = \"s1\" ... \"sn\" *)\n | Pstr_type of rec_flag * type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Pstr_typext of type_extension\n (* type t1 += ... *)\n | Pstr_exception of type_exception\n (* exception C of T\n exception C = M.X *)\n | Pstr_module of module_binding\n (* module X = ME *)\n | Pstr_recmodule of module_binding list\n (* module rec X1 = ME1 and ... and Xn = MEn *)\n | Pstr_modtype of module_type_declaration\n (* module type S = MT *)\n | Pstr_open of open_declaration\n (* open X *)\n | Pstr_class of class_declaration list\n (* class c1 = ... and ... and cn = ... *)\n | Pstr_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Pstr_include of include_declaration\n (* include ME *)\n | Pstr_attribute of attribute\n (* [@@@id] *)\n | Pstr_extension of extension * attributes\n (* [%%id] *)\n\n and value_binding (*IF_CURRENT = Parsetree.value_binding *) =\n {\n pvb_pat: pattern;\n pvb_expr: expression;\n pvb_attributes: attributes;\n pvb_loc: Location.t;\n }\n\n and module_binding (*IF_CURRENT = Parsetree.module_binding *) =\n {\n pmb_name: string option loc;\n pmb_expr: module_expr;\n pmb_attributes: attributes;\n pmb_loc: Location.t;\n }\n (* X = ME *)\n\n (** {1 Toplevel} *)\n\n (* Toplevel phrases *)\n\n type toplevel_phrase (*IF_CURRENT = Parsetree.toplevel_phrase *) =\n | Ptop_def of structure\n | Ptop_dir of toplevel_directive\n (* #use, #load ... *)\n\n and toplevel_directive (*IF_CURRENT = Parsetree.toplevel_directive *) =\n {\n pdir_name : string loc;\n pdir_arg : directive_argument option;\n pdir_loc : Location.t;\n }\n\n and directive_argument (*IF_CURRENT = Parsetree.directive_argument *) =\n {\n pdira_desc : directive_argument_desc;\n pdira_loc : Location.t;\n }\n\n and directive_argument_desc (*IF_CURRENT = Parsetree.directive_argument_desc *) =\n | Pdir_string of string\n | Pdir_int of string * char option\n | Pdir_ident of Longident.t\n | Pdir_bool of bool\nend\n\nmodule Config = struct\n let ast_impl_magic_number = \"Caml1999M030\"\n let ast_intf_magic_number = \"Caml1999N030\"\nend\n","(**************************************************************************)\n(* *)\n(* OCaml Migrate Parsetree *)\n(* *)\n(* Frédéric Bour, Facebook *)\n(* Jérémie Dimino and Leo White, Jane Street Europe *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* Alain Frisch, LexiFi *)\n(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 2018 Institut National de Recherche en Informatique et *)\n(* en Automatique (INRIA). *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nmodule Asttypes = struct\n type constant (*IF_CURRENT = Asttypes.constant *) =\n Const_int of int\n | Const_char of char\n | Const_string of string * Location.t * string option\n | Const_float of string\n | Const_int32 of int32\n | Const_int64 of int64\n | Const_nativeint of nativeint\n\n type rec_flag (*IF_CURRENT = Asttypes.rec_flag *) = Nonrecursive | Recursive\n\n type direction_flag (*IF_CURRENT = Asttypes.direction_flag *) = Upto | Downto\n\n (* Order matters, used in polymorphic comparison *)\n type private_flag (*IF_CURRENT = Asttypes.private_flag *) = Private | Public\n\n type mutable_flag (*IF_CURRENT = Asttypes.mutable_flag *) = Immutable | Mutable\n\n type virtual_flag (*IF_CURRENT = Asttypes.virtual_flag *) = Virtual | Concrete\n\n type override_flag (*IF_CURRENT = Asttypes.override_flag *) = Override | Fresh\n\n type closed_flag (*IF_CURRENT = Asttypes.closed_flag *) = Closed | Open\n\n type label = string\n\n type arg_label (*IF_CURRENT = Asttypes.arg_label *) =\n Nolabel\n | Labelled of string (* label:T -> ... *)\n | Optional of string (* ?label:T -> ... *)\n\n type 'a loc = 'a Location.loc = {\n txt : 'a;\n loc : Location.t;\n }\n\n type variance (*IF_CURRENT = Asttypes.variance *) =\n | Covariant\n | Contravariant\n | NoVariance\n\n type injectivity (*IF_CURRENT = Asttypes.injectivity *) =\n | Injective\n | NoInjectivity\nend\n\nmodule Parsetree = struct\n open Asttypes\n\n type constant (*IF_CURRENT = Parsetree.constant *) =\n Pconst_integer of string * char option\n (* 3 3l 3L 3n\n\n Suffixes [g-z][G-Z] are accepted by the parser.\n Suffixes except 'l', 'L' and 'n' are rejected by the typechecker\n *)\n | Pconst_char of char\n (* 'c' *)\n | Pconst_string of string * Location.t * string option\n (* \"constant\"\n {delim|other constant|delim}\n\n The location span the content of the string, without the delimiters.\n *)\n | Pconst_float of string * char option\n (* 3.4 2e5 1.4e-4\n\n Suffixes [g-z][G-Z] are accepted by the parser.\n Suffixes are rejected by the typechecker.\n *)\n\n type location_stack = Location.t list\n\n (** {1 Extension points} *)\n\n type attribute (*IF_CURRENT = Parsetree.attribute *) = {\n attr_name : string loc;\n attr_payload : payload;\n attr_loc : Location.t;\n }\n (* [@id ARG]\n [@@id ARG]\n\n Metadata containers passed around within the AST.\n The compiler ignores unknown attributes.\n *)\n\n and extension = string loc * payload\n (* [%id ARG]\n [%%id ARG]\n\n Sub-language placeholder -- rejected by the typechecker.\n *)\n\n and attributes = attribute list\n\n and payload (*IF_CURRENT = Parsetree.payload *) =\n | PStr of structure\n | PSig of signature (* : SIG *)\n | PTyp of core_type (* : T *)\n | PPat of pattern * expression option (* ? P or ? P when E *)\n\n (** {1 Core language} *)\n\n (* Type expressions *)\n\n and core_type (*IF_CURRENT = Parsetree.core_type *) =\n {\n ptyp_desc: core_type_desc;\n ptyp_loc: Location.t;\n ptyp_loc_stack: location_stack;\n ptyp_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and core_type_desc (*IF_CURRENT = Parsetree.core_type_desc *) =\n | Ptyp_any\n (* _ *)\n | Ptyp_var of string\n (* 'a *)\n | Ptyp_arrow of arg_label * core_type * core_type\n (* T1 -> T2 Simple\n ~l:T1 -> T2 Labelled\n ?l:T1 -> T2 Optional\n *)\n | Ptyp_tuple of core_type list\n (* T1 * ... * Tn\n\n Invariant: n >= 2\n *)\n | Ptyp_constr of Longident.t loc * core_type list\n (* tconstr\n T tconstr\n (T1, ..., Tn) tconstr\n *)\n | Ptyp_object of object_field list * closed_flag\n (* < l1:T1; ...; ln:Tn > (flag = Closed)\n < l1:T1; ...; ln:Tn; .. > (flag = Open)\n *)\n | Ptyp_class of Longident.t loc * core_type list\n (* #tconstr\n T #tconstr\n (T1, ..., Tn) #tconstr\n *)\n | Ptyp_alias of core_type * string\n (* T as 'a *)\n | Ptyp_variant of row_field list * closed_flag * label list option\n (* [ `A|`B ] (flag = Closed; labels = None)\n [> `A|`B ] (flag = Open; labels = None)\n [< `A|`B ] (flag = Closed; labels = Some [])\n [< `A|`B > `X `Y ](flag = Closed; labels = Some [\"X\";\"Y\"])\n *)\n | Ptyp_poly of string loc list * core_type\n (* 'a1 ... 'an. T\n\n Can only appear in the following context:\n\n - As the core_type of a Ppat_constraint node corresponding\n to a constraint on a let-binding: let x : 'a1 ... 'an. T\n = e ...\n\n - Under Cfk_virtual for methods (not values).\n\n - As the core_type of a Pctf_method node.\n\n - As the core_type of a Pexp_poly node.\n\n - As the pld_type field of a label_declaration.\n\n - As a core_type of a Ptyp_object node.\n\n - As the pval_type field of a value_description.\n *)\n\n | Ptyp_package of package_type\n (* (module S) *)\n | Ptyp_extension of extension\n (* [%id] *)\n\n and package_type = Longident.t loc * (Longident.t loc * core_type) list\n (*\n (module S)\n (module S with type t1 = T1 and ... and tn = Tn)\n *)\n\n and row_field (*IF_CURRENT = Parsetree.row_field *) = {\n prf_desc : row_field_desc;\n prf_loc : Location.t;\n prf_attributes : attributes;\n }\n\n and row_field_desc (*IF_CURRENT = Parsetree.row_field_desc *) =\n | Rtag of label loc * bool * core_type list\n (* [`A] ( true, [] )\n [`A of T] ( false, [T] )\n [`A of T1 & .. & Tn] ( false, [T1;...Tn] )\n [`A of & T1 & .. & Tn] ( true, [T1;...Tn] )\n\n - The 'bool' field is true if the tag contains a\n constant (empty) constructor.\n - '&' occurs when several types are used for the same constructor\n (see 4.2 in the manual)\n *)\n | Rinherit of core_type\n (* [ | t ] *)\n\n and object_field (*IF_CURRENT = Parsetree.object_field *) = {\n pof_desc : object_field_desc;\n pof_loc : Location.t;\n pof_attributes : attributes;\n }\n\n and object_field_desc (*IF_CURRENT = Parsetree.object_field_desc *) =\n | Otag of label loc * core_type\n | Oinherit of core_type\n\n (* Patterns *)\n\n and pattern (*IF_CURRENT = Parsetree.pattern *) =\n {\n ppat_desc: pattern_desc;\n ppat_loc: Location.t;\n ppat_loc_stack: location_stack;\n ppat_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and pattern_desc (*IF_CURRENT = Parsetree.pattern_desc *) =\n | Ppat_any\n (* _ *)\n | Ppat_var of string loc\n (* x *)\n | Ppat_alias of pattern * string loc\n (* P as 'a *)\n | Ppat_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Ppat_interval of constant * constant\n (* 'a'..'z'\n\n Other forms of interval are recognized by the parser\n but rejected by the type-checker. *)\n | Ppat_tuple of pattern list\n (* (P1, ..., Pn)\n\n Invariant: n >= 2\n *)\n | Ppat_construct of Longident.t loc * (string loc list * pattern) option\n (* C None\n C P Some ([], P)\n C (P1, ..., Pn) Some ([], Ppat_tuple [P1; ...; Pn])\n C (type a b) P Some ([a; b], P)\n *)\n | Ppat_variant of label * pattern option\n (* `A (None)\n `A P (Some P)\n *)\n | Ppat_record of (Longident.t loc * pattern) list * closed_flag\n (* { l1=P1; ...; ln=Pn } (flag = Closed)\n { l1=P1; ...; ln=Pn; _} (flag = Open)\n\n Invariant: n > 0\n *)\n | Ppat_array of pattern list\n (* [| P1; ...; Pn |] *)\n | Ppat_or of pattern * pattern\n (* P1 | P2 *)\n | Ppat_constraint of pattern * core_type\n (* (P : T) *)\n | Ppat_type of Longident.t loc\n (* #tconst *)\n | Ppat_lazy of pattern\n (* lazy P *)\n | Ppat_unpack of string option loc\n (* (module P) Some \"P\"\n (module _) None\n\n Note: (module P : S) is represented as\n Ppat_constraint(Ppat_unpack, Ptyp_package)\n *)\n | Ppat_exception of pattern\n (* exception P *)\n | Ppat_extension of extension\n (* [%id] *)\n | Ppat_open of Longident.t loc * pattern\n (* M.(P) *)\n\n (* Value expressions *)\n\n and expression (*IF_CURRENT = Parsetree.expression *) =\n {\n pexp_desc: expression_desc;\n pexp_loc: Location.t;\n pexp_loc_stack: location_stack;\n pexp_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and expression_desc (*IF_CURRENT = Parsetree.expression_desc *) =\n | Pexp_ident of Longident.t loc\n (* x\n M.x\n *)\n | Pexp_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Pexp_let of rec_flag * value_binding list * expression\n (* let P1 = E1 and ... and Pn = EN in E (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in E (flag = Recursive)\n *)\n | Pexp_function of case list\n (* function P1 -> E1 | ... | Pn -> En *)\n | Pexp_fun of arg_label * expression option * pattern * expression\n (* fun P -> E1 (Simple, None)\n fun ~l:P -> E1 (Labelled l, None)\n fun ?l:P -> E1 (Optional l, None)\n fun ?l:(P = E0) -> E1 (Optional l, Some E0)\n\n Notes:\n - If E0 is provided, only Optional is allowed.\n - \"fun P1 P2 .. Pn -> E1\" is represented as nested Pexp_fun.\n - \"let f P = E\" is represented using Pexp_fun.\n *)\n | Pexp_apply of expression * (arg_label * expression) list\n (* E0 ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pexp_match of expression * case list\n (* match E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_try of expression * case list\n (* try E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_tuple of expression list\n (* (E1, ..., En)\n\n Invariant: n >= 2\n *)\n | Pexp_construct of Longident.t loc * expression option\n (* C None\n C E Some E\n C (E1, ..., En) Some (Pexp_tuple[E1;...;En])\n *)\n | Pexp_variant of label * expression option\n (* `A (None)\n `A E (Some E)\n *)\n | Pexp_record of (Longident.t loc * expression) list * expression option\n (* { l1=P1; ...; ln=Pn } (None)\n { E0 with l1=P1; ...; ln=Pn } (Some E0)\n\n Invariant: n > 0\n *)\n | Pexp_field of expression * Longident.t loc\n (* E.l *)\n | Pexp_setfield of expression * Longident.t loc * expression\n (* E1.l <- E2 *)\n | Pexp_array of expression list\n (* [| E1; ...; En |] *)\n | Pexp_ifthenelse of expression * expression * expression option\n (* if E1 then E2 else E3 *)\n | Pexp_sequence of expression * expression\n (* E1; E2 *)\n | Pexp_while of expression * expression\n (* while E1 do E2 done *)\n | Pexp_for of\n pattern * expression * expression * direction_flag * expression\n (* for i = E1 to E2 do E3 done (flag = Upto)\n for i = E1 downto E2 do E3 done (flag = Downto)\n *)\n | Pexp_constraint of expression * core_type\n (* (E : T) *)\n | Pexp_coerce of expression * core_type option * core_type\n (* (E :> T) (None, T)\n (E : T0 :> T) (Some T0, T)\n *)\n | Pexp_send of expression * label loc\n (* E # m *)\n | Pexp_new of Longident.t loc\n (* new M.c *)\n | Pexp_setinstvar of label loc * expression\n (* x <- 2 *)\n | Pexp_override of (label loc * expression) list\n (* {< x1 = E1; ...; Xn = En >} *)\n | Pexp_letmodule of string option loc * module_expr * expression\n (* let module M = ME in E *)\n | Pexp_letexception of extension_constructor * expression\n (* let exception C in E *)\n | Pexp_assert of expression\n (* assert E\n Note: \"assert false\" is treated in a special way by the\n type-checker. *)\n | Pexp_lazy of expression\n (* lazy E *)\n | Pexp_poly of expression * core_type option\n (* Used for method bodies.\n\n Can only be used as the expression under Cfk_concrete\n for methods (not values). *)\n | Pexp_object of class_structure\n (* object ... end *)\n | Pexp_newtype of string loc * expression\n (* fun (type t) -> E *)\n | Pexp_pack of module_expr\n (* (module ME)\n\n (module ME : S) is represented as\n Pexp_constraint(Pexp_pack, Ptyp_package S) *)\n | Pexp_open of open_declaration * expression\n (* M.(E)\n let open M in E\n let! open M in E *)\n | Pexp_letop of letop\n (* let* P = E in E\n let* P = E and* P = E in E *)\n | Pexp_extension of extension\n (* [%id] *)\n | Pexp_unreachable\n (* . *)\n\n and case (*IF_CURRENT = Parsetree.case *) = (* (P -> E) or (P when E0 -> E) *)\n {\n pc_lhs: pattern;\n pc_guard: expression option;\n pc_rhs: expression;\n }\n\n and letop (*IF_CURRENT = Parsetree.letop *) =\n {\n let_ : binding_op;\n ands : binding_op list;\n body : expression;\n }\n\n and binding_op (*IF_CURRENT = Parsetree.binding_op *) =\n {\n pbop_op : string loc;\n pbop_pat : pattern;\n pbop_exp : expression;\n pbop_loc : Location.t;\n }\n\n (* Value descriptions *)\n\n and value_description (*IF_CURRENT = Parsetree.value_description *) =\n {\n pval_name: string loc;\n pval_type: core_type;\n pval_prim: string list;\n pval_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pval_loc: Location.t;\n }\n\n(*\n val x: T (prim = [])\n external x: T = \"s1\" ... \"sn\" (prim = [\"s1\";...\"sn\"])\n*)\n\n (* Type declarations *)\n\n and type_declaration (*IF_CURRENT = Parsetree.type_declaration *) =\n {\n ptype_name: string loc;\n ptype_params: (core_type * (variance * injectivity)) list;\n (* ('a1,...'an) t; None represents _*)\n ptype_cstrs: (core_type * core_type * Location.t) list;\n (* ... constraint T1=T1' ... constraint Tn=Tn' *)\n ptype_kind: type_kind;\n ptype_private: private_flag; (* = private ... *)\n ptype_manifest: core_type option; (* = T *)\n ptype_attributes: attributes; (* ... [@@id1] [@@id2] *)\n ptype_loc: Location.t;\n }\n\n(*\n type t (abstract, no manifest)\n type t = T0 (abstract, manifest=T0)\n type t = C of T | ... (variant, no manifest)\n type t = T0 = C of T | ... (variant, manifest=T0)\n type t = {l: T; ...} (record, no manifest)\n type t = T0 = {l : T; ...} (record, manifest=T0)\n type t = .. (open, no manifest)\n*)\n\n and type_kind (*IF_CURRENT = Parsetree.type_kind *) =\n | Ptype_abstract\n | Ptype_variant of constructor_declaration list\n | Ptype_record of label_declaration list\n (* Invariant: non-empty list *)\n | Ptype_open\n\n and label_declaration (*IF_CURRENT = Parsetree.label_declaration *) =\n {\n pld_name: string loc;\n pld_mutable: mutable_flag;\n pld_type: core_type;\n pld_loc: Location.t;\n pld_attributes: attributes; (* l : T [@id1] [@id2] *)\n }\n\n (* { ...; l: T; ... } (mutable=Immutable)\n { ...; mutable l: T; ... } (mutable=Mutable)\n\n Note: T can be a Ptyp_poly.\n *)\n\n and constructor_declaration (*IF_CURRENT = Parsetree.constructor_declaration *) =\n {\n pcd_name: string loc;\n pcd_vars: string loc list;\n pcd_args: constructor_arguments;\n pcd_res: core_type option;\n pcd_loc: Location.t;\n pcd_attributes: attributes; (* C of ... [@id1] [@id2] *)\n }\n\n and constructor_arguments (*IF_CURRENT = Parsetree.constructor_arguments *) =\n | Pcstr_tuple of core_type list\n | Pcstr_record of label_declaration list\n\n(*\n | C of T1 * ... * Tn (res = None, args = Pcstr_tuple [])\n | C: T0 (res = Some T0, args = [])\n | C: T1 * ... * Tn -> T0 (res = Some T0, args = Pcstr_tuple)\n | C of {...} (res = None, args = Pcstr_record)\n | C: {...} -> T0 (res = Some T0, args = Pcstr_record)\n | C of {...} as t (res = None, args = Pcstr_record)\n*)\n\n and type_extension (*IF_CURRENT = Parsetree.type_extension *) =\n {\n ptyext_path: Longident.t loc;\n ptyext_params: (core_type * (variance * injectivity)) list;\n ptyext_constructors: extension_constructor list;\n ptyext_private: private_flag;\n ptyext_loc: Location.t;\n ptyext_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n(*\n type t += ...\n*)\n\n and extension_constructor (*IF_CURRENT = Parsetree.extension_constructor *) =\n {\n pext_name: string loc;\n pext_kind : extension_constructor_kind;\n pext_loc : Location.t;\n pext_attributes: attributes; (* C of ... [@id1] [@id2] *)\n }\n\n (* exception E *)\n and type_exception (*IF_CURRENT = Parsetree.type_exception *) =\n {\n ptyexn_constructor: extension_constructor;\n ptyexn_loc: Location.t;\n ptyexn_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and extension_constructor_kind (*IF_CURRENT = Parsetree.extension_constructor_kind *) =\n Pext_decl of string loc list * constructor_arguments * core_type option\n (*\n | C of T1 * ... * Tn ([], [T1; ...; Tn], None)\n | C: T0 ([], [], Some T0)\n | C: T1 * ... * Tn -> T0 ([], [T1; ...; Tn], Some T0)\n | C: 'a... . T1... -> T0 (['a;...]; [T1;...], Some T0)\n *)\n | Pext_rebind of Longident.t loc\n (*\n | C = D\n *)\n\n (** {1 Class language} *)\n\n (* Type expressions for the class language *)\n\n and class_type (*IF_CURRENT = Parsetree.class_type *) =\n {\n pcty_desc: class_type_desc;\n pcty_loc: Location.t;\n pcty_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and class_type_desc (*IF_CURRENT = Parsetree.class_type_desc *) =\n | Pcty_constr of Longident.t loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcty_signature of class_signature\n (* object ... end *)\n | Pcty_arrow of arg_label * core_type * class_type\n (* T -> CT Simple\n ~l:T -> CT Labelled l\n ?l:T -> CT Optional l\n *)\n | Pcty_extension of extension\n (* [%id] *)\n | Pcty_open of open_description * class_type\n (* let open M in CT *)\n\n and class_signature (*IF_CURRENT = Parsetree.class_signature *) =\n {\n pcsig_self: core_type;\n pcsig_fields: class_type_field list;\n }\n (* object('selfpat) ... end\n object ... end (self = Ptyp_any)\n *)\n\n and class_type_field (*IF_CURRENT = Parsetree.class_type_field *) =\n {\n pctf_desc: class_type_field_desc;\n pctf_loc: Location.t;\n pctf_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and class_type_field_desc (*IF_CURRENT = Parsetree.class_type_field_desc *) =\n | Pctf_inherit of class_type\n (* inherit CT *)\n | Pctf_val of (label loc * mutable_flag * virtual_flag * core_type)\n (* val x: T *)\n | Pctf_method of (label loc * private_flag * virtual_flag * core_type)\n (* method x: T\n\n Note: T can be a Ptyp_poly.\n *)\n | Pctf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pctf_attribute of attribute\n (* [@@@id] *)\n | Pctf_extension of extension\n (* [%%id] *)\n\n and 'a class_infos (*IF_CURRENT = 'a Parsetree.class_infos *) =\n {\n pci_virt: virtual_flag;\n pci_params: (core_type * (variance * injectivity)) list;\n pci_name: string loc;\n pci_expr: 'a;\n pci_loc: Location.t;\n pci_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n (* class c = ...\n class ['a1,...,'an] c = ...\n class virtual c = ...\n\n Also used for \"class type\" declaration.\n *)\n\n and class_description = class_type class_infos\n\n and class_type_declaration = class_type class_infos\n\n (* Value expressions for the class language *)\n\n and class_expr (*IF_CURRENT = Parsetree.class_expr *) =\n {\n pcl_desc: class_expr_desc;\n pcl_loc: Location.t;\n pcl_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and class_expr_desc (*IF_CURRENT = Parsetree.class_expr_desc *) =\n | Pcl_constr of Longident.t loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcl_structure of class_structure\n (* object ... end *)\n | Pcl_fun of arg_label * expression option * pattern * class_expr\n (* fun P -> CE (Simple, None)\n fun ~l:P -> CE (Labelled l, None)\n fun ?l:P -> CE (Optional l, None)\n fun ?l:(P = E0) -> CE (Optional l, Some E0)\n *)\n | Pcl_apply of class_expr * (arg_label * expression) list\n (* CE ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pcl_let of rec_flag * value_binding list * class_expr\n (* let P1 = E1 and ... and Pn = EN in CE (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in CE (flag = Recursive)\n *)\n | Pcl_constraint of class_expr * class_type\n (* (CE : CT) *)\n | Pcl_extension of extension\n (* [%id] *)\n | Pcl_open of open_description * class_expr\n (* let open M in CE *)\n\n\n and class_structure (*IF_CURRENT = Parsetree.class_structure *) =\n {\n pcstr_self: pattern;\n pcstr_fields: class_field list;\n }\n (* object(selfpat) ... end\n object ... end (self = Ppat_any)\n *)\n\n and class_field (*IF_CURRENT = Parsetree.class_field *) =\n {\n pcf_desc: class_field_desc;\n pcf_loc: Location.t;\n pcf_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and class_field_desc (*IF_CURRENT = Parsetree.class_field_desc *) =\n | Pcf_inherit of override_flag * class_expr * string loc option\n (* inherit CE\n inherit CE as x\n inherit! CE\n inherit! CE as x\n *)\n | Pcf_val of (label loc * mutable_flag * class_field_kind)\n (* val x = E\n val virtual x: T\n *)\n | Pcf_method of (label loc * private_flag * class_field_kind)\n (* method x = E (E can be a Pexp_poly)\n method virtual x: T (T can be a Ptyp_poly)\n *)\n | Pcf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pcf_initializer of expression\n (* initializer E *)\n | Pcf_attribute of attribute\n (* [@@@id] *)\n | Pcf_extension of extension\n (* [%%id] *)\n\n and class_field_kind (*IF_CURRENT = Parsetree.class_field_kind *) =\n | Cfk_virtual of core_type\n | Cfk_concrete of override_flag * expression\n\n and class_declaration = class_expr class_infos\n\n (** {1 Module language} *)\n\n (* Type expressions for the module language *)\n\n and module_type (*IF_CURRENT = Parsetree.module_type *) =\n {\n pmty_desc: module_type_desc;\n pmty_loc: Location.t;\n pmty_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and module_type_desc (*IF_CURRENT = Parsetree.module_type_desc *) =\n | Pmty_ident of Longident.t loc\n (* S *)\n | Pmty_signature of signature\n (* sig ... end *)\n | Pmty_functor of functor_parameter * module_type\n (* functor(X : MT1) -> MT2 *)\n | Pmty_with of module_type * with_constraint list\n (* MT with ... *)\n | Pmty_typeof of module_expr\n (* module type of ME *)\n | Pmty_extension of extension\n (* [%id] *)\n | Pmty_alias of Longident.t loc\n (* (module M) *)\n\n and functor_parameter (*IF_CURRENT = Parsetree.functor_parameter *) =\n | Unit\n (* () *)\n | Named of string option loc * module_type\n (* (X : MT) Some X, MT\n (_ : MT) None, MT *)\n\n and signature = signature_item list\n\n and signature_item (*IF_CURRENT = Parsetree.signature_item *) =\n {\n psig_desc: signature_item_desc;\n psig_loc: Location.t;\n }\n\n and signature_item_desc (*IF_CURRENT = Parsetree.signature_item_desc *) =\n | Psig_value of value_description\n (*\n val x: T\n external x: T = \"s1\" ... \"sn\"\n *)\n | Psig_type of rec_flag * type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Psig_typesubst of type_declaration list\n (* type t1 := ... and ... and tn := ... *)\n | Psig_typext of type_extension\n (* type t1 += ... *)\n | Psig_exception of type_exception\n (* exception C of T *)\n | Psig_module of module_declaration\n (* module X = M\n module X : MT *)\n | Psig_modsubst of module_substitution\n (* module X := M *)\n | Psig_recmodule of module_declaration list\n (* module rec X1 : MT1 and ... and Xn : MTn *)\n | Psig_modtype of module_type_declaration\n (* module type S = MT\n module type S *)\n | Psig_modtypesubst of module_type_declaration\n (* module type S := ... *)\n | Psig_open of open_description\n (* open X *)\n | Psig_include of include_description\n (* include MT *)\n | Psig_class of class_description list\n (* class c1 : ... and ... and cn : ... *)\n | Psig_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Psig_attribute of attribute\n (* [@@@id] *)\n | Psig_extension of extension * attributes\n (* [%%id] *)\n\n and module_declaration (*IF_CURRENT = Parsetree.module_declaration *) =\n {\n pmd_name: string option loc;\n pmd_type: module_type;\n pmd_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pmd_loc: Location.t;\n }\n (* S : MT *)\n\n and module_substitution (*IF_CURRENT = Parsetree.module_substitution *) =\n {\n pms_name: string loc;\n pms_manifest: Longident.t loc;\n pms_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pms_loc: Location.t;\n }\n\n and module_type_declaration (*IF_CURRENT = Parsetree.module_type_declaration *) =\n {\n pmtd_name: string loc;\n pmtd_type: module_type option;\n pmtd_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pmtd_loc: Location.t;\n }\n (* S = MT\n S (abstract module type declaration, pmtd_type = None)\n *)\n\n and 'a open_infos (*IF_CURRENT = 'a Parsetree.open_infos *) =\n {\n popen_expr: 'a;\n popen_override: override_flag;\n popen_loc: Location.t;\n popen_attributes: attributes;\n }\n (* open! X - popen_override = Override (silences the 'used identifier\n shadowing' warning)\n open X - popen_override = Fresh\n *)\n\n and open_description = Longident.t loc open_infos\n (* open M.N\n open M(N).O *)\n\n and open_declaration = module_expr open_infos\n (* open M.N\n open M(N).O\n open struct ... end *)\n\n and 'a include_infos (*IF_CURRENT = 'a Parsetree.include_infos *) =\n {\n pincl_mod: 'a;\n pincl_loc: Location.t;\n pincl_attributes: attributes;\n }\n\n and include_description = module_type include_infos\n (* include MT *)\n\n and include_declaration = module_expr include_infos\n (* include ME *)\n\n and with_constraint (*IF_CURRENT = Parsetree.with_constraint *) =\n | Pwith_type of Longident.t loc * type_declaration\n (* with type X.t = ...\n\n Note: the last component of the longident must match\n the name of the type_declaration. *)\n | Pwith_module of Longident.t loc * Longident.t loc\n (* with module X.Y = Z *)\n | Pwith_modtype of Longident.t loc * module_type\n (* with module type X.Y = Z *)\n | Pwith_modtypesubst of Longident.t loc * module_type\n (* with module type X.Y := sig end *)\n | Pwith_typesubst of Longident.t loc * type_declaration\n (* with type X.t := ..., same format as [Pwith_type] *)\n | Pwith_modsubst of Longident.t loc * Longident.t loc\n (* with module X.Y := Z *)\n\n (* Value expressions for the module language *)\n\n and module_expr (*IF_CURRENT = Parsetree.module_expr *) =\n {\n pmod_desc: module_expr_desc;\n pmod_loc: Location.t;\n pmod_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and module_expr_desc (*IF_CURRENT = Parsetree.module_expr_desc *) =\n | Pmod_ident of Longident.t loc\n (* X *)\n | Pmod_structure of structure\n (* struct ... end *)\n | Pmod_functor of functor_parameter * module_expr\n (* functor(X : MT1) -> ME *)\n | Pmod_apply of module_expr * module_expr\n (* ME1(ME2) *)\n | Pmod_constraint of module_expr * module_type\n (* (ME : MT) *)\n | Pmod_unpack of expression\n (* (val E) *)\n | Pmod_extension of extension\n (* [%id] *)\n\n and structure = structure_item list\n\n and structure_item (*IF_CURRENT = Parsetree.structure_item *) =\n {\n pstr_desc: structure_item_desc;\n pstr_loc: Location.t;\n }\n\n and structure_item_desc (*IF_CURRENT = Parsetree.structure_item_desc *) =\n | Pstr_eval of expression * attributes\n (* E *)\n | Pstr_value of rec_flag * value_binding list\n (* let P1 = E1 and ... and Pn = EN (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN (flag = Recursive)\n *)\n | Pstr_primitive of value_description\n (* val x: T\n external x: T = \"s1\" ... \"sn\" *)\n | Pstr_type of rec_flag * type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Pstr_typext of type_extension\n (* type t1 += ... *)\n | Pstr_exception of type_exception\n (* exception C of T\n exception C = M.X *)\n | Pstr_module of module_binding\n (* module X = ME *)\n | Pstr_recmodule of module_binding list\n (* module rec X1 = ME1 and ... and Xn = MEn *)\n | Pstr_modtype of module_type_declaration\n (* module type S = MT *)\n | Pstr_open of open_declaration\n (* open X *)\n | Pstr_class of class_declaration list\n (* class c1 = ... and ... and cn = ... *)\n | Pstr_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Pstr_include of include_declaration\n (* include ME *)\n | Pstr_attribute of attribute\n (* [@@@id] *)\n | Pstr_extension of extension * attributes\n (* [%%id] *)\n\n and value_binding (*IF_CURRENT = Parsetree.value_binding *) =\n {\n pvb_pat: pattern;\n pvb_expr: expression;\n pvb_attributes: attributes;\n pvb_loc: Location.t;\n }\n\n and module_binding (*IF_CURRENT = Parsetree.module_binding *) =\n {\n pmb_name: string option loc;\n pmb_expr: module_expr;\n pmb_attributes: attributes;\n pmb_loc: Location.t;\n }\n (* X = ME *)\n\n (** {1 Toplevel} *)\n\n (* Toplevel phrases *)\n\n type toplevel_phrase (*IF_CURRENT = Parsetree.toplevel_phrase *) =\n | Ptop_def of structure\n | Ptop_dir of toplevel_directive\n (* #use, #load ... *)\n\n and toplevel_directive (*IF_CURRENT = Parsetree.toplevel_directive *) =\n {\n pdir_name : string loc;\n pdir_arg : directive_argument option;\n pdir_loc : Location.t;\n }\n\n and directive_argument (*IF_CURRENT = Parsetree.directive_argument *) =\n {\n pdira_desc : directive_argument_desc;\n pdira_loc : Location.t;\n }\n\n and directive_argument_desc (*IF_CURRENT = Parsetree.directive_argument_desc *) =\n | Pdir_string of string\n | Pdir_int of string * char option\n | Pdir_ident of Longident.t\n | Pdir_bool of bool\nend\n\nmodule Config = struct\n let ast_impl_magic_number = \"Caml1999M031\"\n let ast_intf_magic_number = \"Caml1999N031\"\nend\n","(**************************************************************************)\n(* *)\n(* OCaml Migrate Parsetree *)\n(* *)\n(* Frédéric Bour, Facebook *)\n(* Jérémie Dimino and Leo White, Jane Street Europe *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* Alain Frisch, LexiFi *)\n(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 2018 Institut National de Recherche en Informatique et *)\n(* en Automatique (INRIA). *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nmodule Asttypes = struct\n type constant (*IF_CURRENT = Asttypes.constant *) =\n Const_int of int\n | Const_char of char\n | Const_string of string * Location.t * string option\n | Const_float of string\n | Const_int32 of int32\n | Const_int64 of int64\n | Const_nativeint of nativeint\n\n type rec_flag (*IF_CURRENT = Asttypes.rec_flag *) = Nonrecursive | Recursive\n\n type direction_flag (*IF_CURRENT = Asttypes.direction_flag *) = Upto | Downto\n\n (* Order matters, used in polymorphic comparison *)\n type private_flag (*IF_CURRENT = Asttypes.private_flag *) = Private | Public\n\n type mutable_flag (*IF_CURRENT = Asttypes.mutable_flag *) = Immutable | Mutable\n\n type virtual_flag (*IF_CURRENT = Asttypes.virtual_flag *) = Virtual | Concrete\n\n type override_flag (*IF_CURRENT = Asttypes.override_flag *) = Override | Fresh\n\n type closed_flag (*IF_CURRENT = Asttypes.closed_flag *) = Closed | Open\n\n type label = string\n\n type arg_label (*IF_CURRENT = Asttypes.arg_label *) =\n Nolabel\n | Labelled of string (* label:T -> ... *)\n | Optional of string (* ?label:T -> ... *)\n\n type 'a loc = 'a Location.loc = {\n txt : 'a;\n loc : Location.t;\n }\n\n\n type variance (*IF_CURRENT = Asttypes.variance *) =\n | Covariant\n | Contravariant\n | Invariant\nend\n\nmodule Parsetree = struct\n open Asttypes\n\n type constant (*IF_CURRENT = Parsetree.constant *) =\n Pconst_integer of string * char option\n (* 3 3l 3L 3n\n\n Suffixes [g-z][G-Z] are accepted by the parser.\n Suffixes except 'l', 'L' and 'n' are rejected by the typechecker\n *)\n | Pconst_char of char\n (* 'c' *)\n | Pconst_string of string * Location.t * string option\n (* \"constant\"\n {delim|other constant|delim}\n\n The location span the content of the string, without the delimiters.\n *)\n | Pconst_float of string * char option\n (* 3.4 2e5 1.4e-4\n\n Suffixes [g-z][G-Z] are accepted by the parser.\n Suffixes are rejected by the typechecker.\n *)\n\n type location_stack = Location.t list\n\n (** {1 Extension points} *)\n\n type attribute (*IF_CURRENT = Parsetree.attribute *) = {\n attr_name : string loc;\n attr_payload : payload;\n attr_loc : Location.t;\n }\n (* [@id ARG]\n [@@id ARG]\n\n Metadata containers passed around within the AST.\n The compiler ignores unknown attributes.\n *)\n\n and extension = string loc * payload\n (* [%id ARG]\n [%%id ARG]\n\n Sub-language placeholder -- rejected by the typechecker.\n *)\n\n and attributes = attribute list\n\n and payload (*IF_CURRENT = Parsetree.payload *) =\n | PStr of structure\n | PSig of signature (* : SIG *)\n | PTyp of core_type (* : T *)\n | PPat of pattern * expression option (* ? P or ? P when E *)\n\n (** {1 Core language} *)\n\n (* Type expressions *)\n\n and core_type (*IF_CURRENT = Parsetree.core_type *) =\n {\n ptyp_desc: core_type_desc;\n ptyp_loc: Location.t;\n ptyp_loc_stack: location_stack;\n ptyp_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and core_type_desc (*IF_CURRENT = Parsetree.core_type_desc *) =\n | Ptyp_any\n (* _ *)\n | Ptyp_var of string\n (* 'a *)\n | Ptyp_arrow of arg_label * core_type * core_type\n (* T1 -> T2 Simple\n ~l:T1 -> T2 Labelled\n ?l:T1 -> T2 Optional\n *)\n | Ptyp_tuple of core_type list\n (* T1 * ... * Tn\n\n Invariant: n >= 2\n *)\n | Ptyp_constr of Longident.t loc * core_type list\n (* tconstr\n T tconstr\n (T1, ..., Tn) tconstr\n *)\n | Ptyp_object of object_field list * closed_flag\n (* < l1:T1; ...; ln:Tn > (flag = Closed)\n < l1:T1; ...; ln:Tn; .. > (flag = Open)\n *)\n | Ptyp_class of Longident.t loc * core_type list\n (* #tconstr\n T #tconstr\n (T1, ..., Tn) #tconstr\n *)\n | Ptyp_alias of core_type * string\n (* T as 'a *)\n | Ptyp_variant of row_field list * closed_flag * label list option\n (* [ `A|`B ] (flag = Closed; labels = None)\n [> `A|`B ] (flag = Open; labels = None)\n [< `A|`B ] (flag = Closed; labels = Some [])\n [< `A|`B > `X `Y ](flag = Closed; labels = Some [\"X\";\"Y\"])\n *)\n | Ptyp_poly of string loc list * core_type\n (* 'a1 ... 'an. T\n\n Can only appear in the following context:\n\n - As the core_type of a Ppat_constraint node corresponding\n to a constraint on a let-binding: let x : 'a1 ... 'an. T\n = e ...\n\n - Under Cfk_virtual for methods (not values).\n\n - As the core_type of a Pctf_method node.\n\n - As the core_type of a Pexp_poly node.\n\n - As the pld_type field of a label_declaration.\n\n - As a core_type of a Ptyp_object node.\n *)\n\n | Ptyp_package of package_type\n (* (module S) *)\n | Ptyp_extension of extension\n (* [%id] *)\n\n and package_type = Longident.t loc * (Longident.t loc * core_type) list\n (*\n (module S)\n (module S with type t1 = T1 and ... and tn = Tn)\n *)\n\n and row_field (*IF_CURRENT = Parsetree.row_field *) = {\n prf_desc : row_field_desc;\n prf_loc : Location.t;\n prf_attributes : attributes;\n }\n\n and row_field_desc (*IF_CURRENT = Parsetree.row_field_desc *) =\n | Rtag of label loc * bool * core_type list\n (* [`A] ( true, [] )\n [`A of T] ( false, [T] )\n [`A of T1 & .. & Tn] ( false, [T1;...Tn] )\n [`A of & T1 & .. & Tn] ( true, [T1;...Tn] )\n\n - The 'bool' field is true if the tag contains a\n constant (empty) constructor.\n - '&' occurs when several types are used for the same constructor\n (see 4.2 in the manual)\n *)\n | Rinherit of core_type\n (* [ T ] *)\n\n and object_field (*IF_CURRENT = Parsetree.object_field *) = {\n pof_desc : object_field_desc;\n pof_loc : Location.t;\n pof_attributes : attributes;\n }\n\n and object_field_desc (*IF_CURRENT = Parsetree.object_field_desc *) =\n | Otag of label loc * core_type\n | Oinherit of core_type\n\n (* Patterns *)\n\n and pattern (*IF_CURRENT = Parsetree.pattern *) =\n {\n ppat_desc: pattern_desc;\n ppat_loc: Location.t;\n ppat_loc_stack: location_stack;\n ppat_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and pattern_desc (*IF_CURRENT = Parsetree.pattern_desc *) =\n | Ppat_any\n (* _ *)\n | Ppat_var of string loc\n (* x *)\n | Ppat_alias of pattern * string loc\n (* P as 'a *)\n | Ppat_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Ppat_interval of constant * constant\n (* 'a'..'z'\n\n Other forms of interval are recognized by the parser\n but rejected by the type-checker. *)\n | Ppat_tuple of pattern list\n (* (P1, ..., Pn)\n\n Invariant: n >= 2\n *)\n | Ppat_construct of Longident.t loc * pattern option\n (* C None\n C P Some P\n C (P1, ..., Pn) Some (Ppat_tuple [P1; ...; Pn])\n *)\n | Ppat_variant of label * pattern option\n (* `A (None)\n `A P (Some P)\n *)\n | Ppat_record of (Longident.t loc * pattern) list * closed_flag\n (* { l1=P1; ...; ln=Pn } (flag = Closed)\n { l1=P1; ...; ln=Pn; _} (flag = Open)\n\n Invariant: n > 0\n *)\n | Ppat_array of pattern list\n (* [| P1; ...; Pn |] *)\n | Ppat_or of pattern * pattern\n (* P1 | P2 *)\n | Ppat_constraint of pattern * core_type\n (* (P : T) *)\n | Ppat_type of Longident.t loc\n (* #tconst *)\n | Ppat_lazy of pattern\n (* lazy P *)\n | Ppat_unpack of string option loc\n (* (module P) Some \"P\"\n (module _) None\n\n Note: (module P : S) is represented as\n Ppat_constraint(Ppat_unpack, Ptyp_package)\n *)\n | Ppat_exception of pattern\n (* exception P *)\n | Ppat_extension of extension\n (* [%id] *)\n | Ppat_open of Longident.t loc * pattern\n (* M.(P) *)\n\n (* Value expressions *)\n\n and expression (*IF_CURRENT = Parsetree.expression *) =\n {\n pexp_desc: expression_desc;\n pexp_loc: Location.t;\n pexp_loc_stack: location_stack;\n pexp_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and expression_desc (*IF_CURRENT = Parsetree.expression_desc *) =\n | Pexp_ident of Longident.t loc\n (* x\n M.x\n *)\n | Pexp_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Pexp_let of rec_flag * value_binding list * expression\n (* let P1 = E1 and ... and Pn = EN in E (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in E (flag = Recursive)\n *)\n | Pexp_function of case list\n (* function P1 -> E1 | ... | Pn -> En *)\n | Pexp_fun of arg_label * expression option * pattern * expression\n (* fun P -> E1 (Simple, None)\n fun ~l:P -> E1 (Labelled l, None)\n fun ?l:P -> E1 (Optional l, None)\n fun ?l:(P = E0) -> E1 (Optional l, Some E0)\n\n Notes:\n - If E0 is provided, only Optional is allowed.\n - \"fun P1 P2 .. Pn -> E1\" is represented as nested Pexp_fun.\n - \"let f P = E\" is represented using Pexp_fun.\n *)\n | Pexp_apply of expression * (arg_label * expression) list\n (* E0 ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pexp_match of expression * case list\n (* match E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_try of expression * case list\n (* try E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_tuple of expression list\n (* (E1, ..., En)\n\n Invariant: n >= 2\n *)\n | Pexp_construct of Longident.t loc * expression option\n (* C None\n C E Some E\n C (E1, ..., En) Some (Pexp_tuple[E1;...;En])\n *)\n | Pexp_variant of label * expression option\n (* `A (None)\n `A E (Some E)\n *)\n | Pexp_record of (Longident.t loc * expression) list * expression option\n (* { l1=P1; ...; ln=Pn } (None)\n { E0 with l1=P1; ...; ln=Pn } (Some E0)\n\n Invariant: n > 0\n *)\n | Pexp_field of expression * Longident.t loc\n (* E.l *)\n | Pexp_setfield of expression * Longident.t loc * expression\n (* E1.l <- E2 *)\n | Pexp_array of expression list\n (* [| E1; ...; En |] *)\n | Pexp_ifthenelse of expression * expression * expression option\n (* if E1 then E2 else E3 *)\n | Pexp_sequence of expression * expression\n (* E1; E2 *)\n | Pexp_while of expression * expression\n (* while E1 do E2 done *)\n | Pexp_for of\n pattern * expression * expression * direction_flag * expression\n (* for i = E1 to E2 do E3 done (flag = Upto)\n for i = E1 downto E2 do E3 done (flag = Downto)\n *)\n | Pexp_constraint of expression * core_type\n (* (E : T) *)\n | Pexp_coerce of expression * core_type option * core_type\n (* (E :> T) (None, T)\n (E : T0 :> T) (Some T0, T)\n *)\n | Pexp_send of expression * label loc\n (* E # m *)\n | Pexp_new of Longident.t loc\n (* new M.c *)\n | Pexp_setinstvar of label loc * expression\n (* x <- 2 *)\n | Pexp_override of (label loc * expression) list\n (* {< x1 = E1; ...; Xn = En >} *)\n | Pexp_letmodule of string option loc * module_expr * expression\n (* let module M = ME in E *)\n | Pexp_letexception of extension_constructor * expression\n (* let exception C in E *)\n | Pexp_assert of expression\n (* assert E\n Note: \"assert false\" is treated in a special way by the\n type-checker. *)\n | Pexp_lazy of expression\n (* lazy E *)\n | Pexp_poly of expression * core_type option\n (* Used for method bodies.\n\n Can only be used as the expression under Cfk_concrete\n for methods (not values). *)\n | Pexp_object of class_structure\n (* object ... end *)\n | Pexp_newtype of string loc * expression\n (* fun (type t) -> E *)\n | Pexp_pack of module_expr\n (* (module ME)\n\n (module ME : S) is represented as\n Pexp_constraint(Pexp_pack, Ptyp_package S) *)\n | Pexp_open of open_declaration * expression\n (* M.(E)\n let open M in E\n let! open M in E *)\n | Pexp_letop of letop\n (* let* P = E in E\n let* P = E and* P = E in E *)\n | Pexp_extension of extension\n (* [%id] *)\n | Pexp_unreachable\n (* . *)\n\n and case (*IF_CURRENT = Parsetree.case *) = (* (P -> E) or (P when E0 -> E) *)\n {\n pc_lhs: pattern;\n pc_guard: expression option;\n pc_rhs: expression;\n }\n\n and letop (*IF_CURRENT = Parsetree.letop *) =\n {\n let_ : binding_op;\n ands : binding_op list;\n body : expression;\n }\n\n and binding_op (*IF_CURRENT = Parsetree.binding_op *) =\n {\n pbop_op : string loc;\n pbop_pat : pattern;\n pbop_exp : expression;\n pbop_loc : Location.t;\n }\n\n (* Value descriptions *)\n\n and value_description (*IF_CURRENT = Parsetree.value_description *) =\n {\n pval_name: string loc;\n pval_type: core_type;\n pval_prim: string list;\n pval_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pval_loc: Location.t;\n }\n\n(*\n val x: T (prim = [])\n external x: T = \"s1\" ... \"sn\" (prim = [\"s1\";...\"sn\"])\n*)\n\n (* Type declarations *)\n\n and type_declaration (*IF_CURRENT = Parsetree.type_declaration *) =\n {\n ptype_name: string loc;\n ptype_params: (core_type * variance) list;\n (* ('a1,...'an) t; None represents _*)\n ptype_cstrs: (core_type * core_type * Location.t) list;\n (* ... constraint T1=T1' ... constraint Tn=Tn' *)\n ptype_kind: type_kind;\n ptype_private: private_flag; (* = private ... *)\n ptype_manifest: core_type option; (* = T *)\n ptype_attributes: attributes; (* ... [@@id1] [@@id2] *)\n ptype_loc: Location.t;\n }\n\n(*\n type t (abstract, no manifest)\n type t = T0 (abstract, manifest=T0)\n type t = C of T | ... (variant, no manifest)\n type t = T0 = C of T | ... (variant, manifest=T0)\n type t = {l: T; ...} (record, no manifest)\n type t = T0 = {l : T; ...} (record, manifest=T0)\n type t = .. (open, no manifest)\n*)\n\n and type_kind (*IF_CURRENT = Parsetree.type_kind *) =\n | Ptype_abstract\n | Ptype_variant of constructor_declaration list\n | Ptype_record of label_declaration list\n (* Invariant: non-empty list *)\n | Ptype_open\n\n and label_declaration (*IF_CURRENT = Parsetree.label_declaration *) =\n {\n pld_name: string loc;\n pld_mutable: mutable_flag;\n pld_type: core_type;\n pld_loc: Location.t;\n pld_attributes: attributes; (* l : T [@id1] [@id2] *)\n }\n\n (* { ...; l: T; ... } (mutable=Immutable)\n { ...; mutable l: T; ... } (mutable=Mutable)\n\n Note: T can be a Ptyp_poly.\n *)\n\n and constructor_declaration (*IF_CURRENT = Parsetree.constructor_declaration *) =\n {\n pcd_name: string loc;\n pcd_args: constructor_arguments;\n pcd_res: core_type option;\n pcd_loc: Location.t;\n pcd_attributes: attributes; (* C of ... [@id1] [@id2] *)\n }\n\n and constructor_arguments (*IF_CURRENT = Parsetree.constructor_arguments *) =\n | Pcstr_tuple of core_type list\n | Pcstr_record of label_declaration list\n\n(*\n | C of T1 * ... * Tn (res = None, args = Pcstr_tuple [])\n | C: T0 (res = Some T0, args = [])\n | C: T1 * ... * Tn -> T0 (res = Some T0, args = Pcstr_tuple)\n | C of {...} (res = None, args = Pcstr_record)\n | C: {...} -> T0 (res = Some T0, args = Pcstr_record)\n | C of {...} as t (res = None, args = Pcstr_record)\n*)\n\n and type_extension (*IF_CURRENT = Parsetree.type_extension *) =\n {\n ptyext_path: Longident.t loc;\n ptyext_params: (core_type * variance) list;\n ptyext_constructors: extension_constructor list;\n ptyext_private: private_flag;\n ptyext_loc: Location.t;\n ptyext_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n(*\n type t += ...\n*)\n\n and extension_constructor (*IF_CURRENT = Parsetree.extension_constructor *) =\n {\n pext_name: string loc;\n pext_kind : extension_constructor_kind;\n pext_loc : Location.t;\n pext_attributes: attributes; (* C of ... [@id1] [@id2] *)\n }\n\n (* exception E *)\n and type_exception (*IF_CURRENT = Parsetree.type_exception *) =\n {\n ptyexn_constructor: extension_constructor;\n ptyexn_loc: Location.t;\n ptyexn_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and extension_constructor_kind (*IF_CURRENT = Parsetree.extension_constructor_kind *) =\n Pext_decl of constructor_arguments * core_type option\n (*\n | C of T1 * ... * Tn ([T1; ...; Tn], None)\n | C: T0 ([], Some T0)\n | C: T1 * ... * Tn -> T0 ([T1; ...; Tn], Some T0)\n *)\n | Pext_rebind of Longident.t loc\n (*\n | C = D\n *)\n\n (** {1 Class language} *)\n\n (* Type expressions for the class language *)\n\n and class_type (*IF_CURRENT = Parsetree.class_type *) =\n {\n pcty_desc: class_type_desc;\n pcty_loc: Location.t;\n pcty_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and class_type_desc (*IF_CURRENT = Parsetree.class_type_desc *) =\n | Pcty_constr of Longident.t loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcty_signature of class_signature\n (* object ... end *)\n | Pcty_arrow of arg_label * core_type * class_type\n (* T -> CT Simple\n ~l:T -> CT Labelled l\n ?l:T -> CT Optional l\n *)\n | Pcty_extension of extension\n (* [%id] *)\n | Pcty_open of open_description * class_type\n (* let open M in CT *)\n\n and class_signature (*IF_CURRENT = Parsetree.class_signature *) =\n {\n pcsig_self: core_type;\n pcsig_fields: class_type_field list;\n }\n (* object('selfpat) ... end\n object ... end (self = Ptyp_any)\n *)\n\n and class_type_field (*IF_CURRENT = Parsetree.class_type_field *) =\n {\n pctf_desc: class_type_field_desc;\n pctf_loc: Location.t;\n pctf_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and class_type_field_desc (*IF_CURRENT = Parsetree.class_type_field_desc *) =\n | Pctf_inherit of class_type\n (* inherit CT *)\n | Pctf_val of (label loc * mutable_flag * virtual_flag * core_type)\n (* val x: T *)\n | Pctf_method of (label loc * private_flag * virtual_flag * core_type)\n (* method x: T\n\n Note: T can be a Ptyp_poly.\n *)\n | Pctf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pctf_attribute of attribute\n (* [@@@id] *)\n | Pctf_extension of extension\n (* [%%id] *)\n\n and 'a class_infos (*IF_CURRENT = 'a Parsetree.class_infos *) =\n {\n pci_virt: virtual_flag;\n pci_params: (core_type * variance) list;\n pci_name: string loc;\n pci_expr: 'a;\n pci_loc: Location.t;\n pci_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n (* class c = ...\n class ['a1,...,'an] c = ...\n class virtual c = ...\n\n Also used for \"class type\" declaration.\n *)\n\n and class_description = class_type class_infos\n\n and class_type_declaration = class_type class_infos\n\n (* Value expressions for the class language *)\n\n and class_expr (*IF_CURRENT = Parsetree.class_expr *) =\n {\n pcl_desc: class_expr_desc;\n pcl_loc: Location.t;\n pcl_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and class_expr_desc (*IF_CURRENT = Parsetree.class_expr_desc *) =\n | Pcl_constr of Longident.t loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcl_structure of class_structure\n (* object ... end *)\n | Pcl_fun of arg_label * expression option * pattern * class_expr\n (* fun P -> CE (Simple, None)\n fun ~l:P -> CE (Labelled l, None)\n fun ?l:P -> CE (Optional l, None)\n fun ?l:(P = E0) -> CE (Optional l, Some E0)\n *)\n | Pcl_apply of class_expr * (arg_label * expression) list\n (* CE ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pcl_let of rec_flag * value_binding list * class_expr\n (* let P1 = E1 and ... and Pn = EN in CE (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in CE (flag = Recursive)\n *)\n | Pcl_constraint of class_expr * class_type\n (* (CE : CT) *)\n | Pcl_extension of extension\n (* [%id] *)\n | Pcl_open of open_description * class_expr\n (* let open M in CE *)\n\n\n and class_structure (*IF_CURRENT = Parsetree.class_structure *) =\n {\n pcstr_self: pattern;\n pcstr_fields: class_field list;\n }\n (* object(selfpat) ... end\n object ... end (self = Ppat_any)\n *)\n\n and class_field (*IF_CURRENT = Parsetree.class_field *) =\n {\n pcf_desc: class_field_desc;\n pcf_loc: Location.t;\n pcf_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and class_field_desc (*IF_CURRENT = Parsetree.class_field_desc *) =\n | Pcf_inherit of override_flag * class_expr * string loc option\n (* inherit CE\n inherit CE as x\n inherit! CE\n inherit! CE as x\n *)\n | Pcf_val of (label loc * mutable_flag * class_field_kind)\n (* val x = E\n val virtual x: T\n *)\n | Pcf_method of (label loc * private_flag * class_field_kind)\n (* method x = E (E can be a Pexp_poly)\n method virtual x: T (T can be a Ptyp_poly)\n *)\n | Pcf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pcf_initializer of expression\n (* initializer E *)\n | Pcf_attribute of attribute\n (* [@@@id] *)\n | Pcf_extension of extension\n (* [%%id] *)\n\n and class_field_kind (*IF_CURRENT = Parsetree.class_field_kind *) =\n | Cfk_virtual of core_type\n | Cfk_concrete of override_flag * expression\n\n and class_declaration = class_expr class_infos\n\n (** {1 Module language} *)\n\n (* Type expressions for the module language *)\n\n and module_type (*IF_CURRENT = Parsetree.module_type *) =\n {\n pmty_desc: module_type_desc;\n pmty_loc: Location.t;\n pmty_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and module_type_desc (*IF_CURRENT = Parsetree.module_type_desc *) =\n | Pmty_ident of Longident.t loc\n (* S *)\n | Pmty_signature of signature\n (* sig ... end *)\n | Pmty_functor of functor_parameter * module_type\n (* functor(X : MT1) -> MT2 *)\n | Pmty_with of module_type * with_constraint list\n (* MT with ... *)\n | Pmty_typeof of module_expr\n (* module type of ME *)\n | Pmty_extension of extension\n (* [%id] *)\n | Pmty_alias of Longident.t loc\n (* (module M) *)\n\n and functor_parameter (*IF_CURRENT = Parsetree.functor_parameter *) =\n | Unit\n (* () *)\n | Named of string option loc * module_type\n (* (X : MT) Some X, MT\n (_ : MT) None, MT *)\n\n and signature = signature_item list\n\n and signature_item (*IF_CURRENT = Parsetree.signature_item *) =\n {\n psig_desc: signature_item_desc;\n psig_loc: Location.t;\n }\n\n and signature_item_desc (*IF_CURRENT = Parsetree.signature_item_desc *) =\n | Psig_value of value_description\n (*\n val x: T\n external x: T = \"s1\" ... \"sn\"\n *)\n | Psig_type of rec_flag * type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Psig_typesubst of type_declaration list\n (* type t1 := ... and ... and tn := ... *)\n | Psig_typext of type_extension\n (* type t1 += ... *)\n | Psig_exception of type_exception\n (* exception C of T *)\n | Psig_module of module_declaration\n (* module X = M\n module X : MT *)\n | Psig_modsubst of module_substitution\n (* module X := M *)\n | Psig_recmodule of module_declaration list\n (* module rec X1 : MT1 and ... and Xn : MTn *)\n | Psig_modtype of module_type_declaration\n (* module type S = MT\n module type S *)\n | Psig_open of open_description\n (* open X *)\n | Psig_include of include_description\n (* include MT *)\n | Psig_class of class_description list\n (* class c1 : ... and ... and cn : ... *)\n | Psig_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Psig_attribute of attribute\n (* [@@@id] *)\n | Psig_extension of extension * attributes\n (* [%%id] *)\n\n and module_declaration (*IF_CURRENT = Parsetree.module_declaration *) =\n {\n pmd_name: string option loc;\n pmd_type: module_type;\n pmd_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pmd_loc: Location.t;\n }\n (* S : MT *)\n\n and module_substitution (*IF_CURRENT = Parsetree.module_substitution *) =\n {\n pms_name: string loc;\n pms_manifest: Longident.t loc;\n pms_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pms_loc: Location.t;\n }\n\n and module_type_declaration (*IF_CURRENT = Parsetree.module_type_declaration *) =\n {\n pmtd_name: string loc;\n pmtd_type: module_type option;\n pmtd_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pmtd_loc: Location.t;\n }\n (* S = MT\n S (abstract module type declaration, pmtd_type = None)\n *)\n\n and 'a open_infos (*IF_CURRENT = 'a Parsetree.open_infos *) =\n {\n popen_expr: 'a;\n popen_override: override_flag;\n popen_loc: Location.t;\n popen_attributes: attributes;\n }\n (* open! X - popen_override = Override (silences the 'used identifier\n shadowing' warning)\n open X - popen_override = Fresh\n *)\n\n and open_description = Longident.t loc open_infos\n (* open M.N\n open M(N).O *)\n\n and open_declaration = module_expr open_infos\n (* open M.N\n open M(N).O\n open struct ... end *)\n\n and 'a include_infos (*IF_CURRENT = 'a Parsetree.include_infos *) =\n {\n pincl_mod: 'a;\n pincl_loc: Location.t;\n pincl_attributes: attributes;\n }\n\n and include_description = module_type include_infos\n (* include MT *)\n\n and include_declaration = module_expr include_infos\n (* include ME *)\n\n and with_constraint (*IF_CURRENT = Parsetree.with_constraint *) =\n | Pwith_type of Longident.t loc * type_declaration\n (* with type X.t = ...\n\n Note: the last component of the longident must match\n the name of the type_declaration. *)\n | Pwith_module of Longident.t loc * Longident.t loc\n (* with module X.Y = Z *)\n | Pwith_typesubst of Longident.t loc * type_declaration\n (* with type X.t := ..., same format as [Pwith_type] *)\n | Pwith_modsubst of Longident.t loc * Longident.t loc\n (* with module X.Y := Z *)\n\n (* Value expressions for the module language *)\n\n and module_expr (*IF_CURRENT = Parsetree.module_expr *) =\n {\n pmod_desc: module_expr_desc;\n pmod_loc: Location.t;\n pmod_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and module_expr_desc (*IF_CURRENT = Parsetree.module_expr_desc *) =\n | Pmod_ident of Longident.t loc\n (* X *)\n | Pmod_structure of structure\n (* struct ... end *)\n | Pmod_functor of functor_parameter * module_expr\n (* functor(X : MT1) -> ME *)\n | Pmod_apply of module_expr * module_expr\n (* ME1(ME2) *)\n | Pmod_constraint of module_expr * module_type\n (* (ME : MT) *)\n | Pmod_unpack of expression\n (* (val E) *)\n | Pmod_extension of extension\n (* [%id] *)\n\n and structure = structure_item list\n\n and structure_item (*IF_CURRENT = Parsetree.structure_item *) =\n {\n pstr_desc: structure_item_desc;\n pstr_loc: Location.t;\n }\n\n and structure_item_desc (*IF_CURRENT = Parsetree.structure_item_desc *) =\n | Pstr_eval of expression * attributes\n (* E *)\n | Pstr_value of rec_flag * value_binding list\n (* let P1 = E1 and ... and Pn = EN (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN (flag = Recursive)\n *)\n | Pstr_primitive of value_description\n (* val x: T\n external x: T = \"s1\" ... \"sn\" *)\n | Pstr_type of rec_flag * type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Pstr_typext of type_extension\n (* type t1 += ... *)\n | Pstr_exception of type_exception\n (* exception C of T\n exception C = M.X *)\n | Pstr_module of module_binding\n (* module X = ME *)\n | Pstr_recmodule of module_binding list\n (* module rec X1 = ME1 and ... and Xn = MEn *)\n | Pstr_modtype of module_type_declaration\n (* module type S = MT *)\n | Pstr_open of open_declaration\n (* open X *)\n | Pstr_class of class_declaration list\n (* class c1 = ... and ... and cn = ... *)\n | Pstr_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Pstr_include of include_declaration\n (* include ME *)\n | Pstr_attribute of attribute\n (* [@@@id] *)\n | Pstr_extension of extension * attributes\n (* [%%id] *)\n\n and value_binding (*IF_CURRENT = Parsetree.value_binding *) =\n {\n pvb_pat: pattern;\n pvb_expr: expression;\n pvb_attributes: attributes;\n pvb_loc: Location.t;\n }\n\n and module_binding (*IF_CURRENT = Parsetree.module_binding *) =\n {\n pmb_name: string option loc;\n pmb_expr: module_expr;\n pmb_attributes: attributes;\n pmb_loc: Location.t;\n }\n (* X = ME *)\n\n (** {1 Toplevel} *)\n\n (* Toplevel phrases *)\n\n type toplevel_phrase (*IF_CURRENT = Parsetree.toplevel_phrase *) =\n | Ptop_def of structure\n | Ptop_dir of toplevel_directive\n (* #use, #load ... *)\n\n and toplevel_directive (*IF_CURRENT = Parsetree.toplevel_directive *) =\n {\n pdir_name : string loc;\n pdir_arg : directive_argument option;\n pdir_loc : Location.t;\n }\n\n and directive_argument (*IF_CURRENT = Parsetree.directive_argument *) =\n {\n pdira_desc : directive_argument_desc;\n pdira_loc : Location.t;\n }\n\n and directive_argument_desc (*IF_CURRENT = Parsetree.directive_argument_desc *) =\n | Pdir_string of string\n | Pdir_int of string * char option\n | Pdir_ident of Longident.t\n | Pdir_bool of bool\nend\n\nmodule Config = struct\n let ast_impl_magic_number = \"Caml1999M028\"\n let ast_intf_magic_number = \"Caml1999N028\"\nend\n","(**************************************************************************)\n(* *)\n(* OCaml Migrate Parsetree *)\n(* *)\n(* Frédéric Bour, Facebook *)\n(* Jérémie Dimino and Leo White, Jane Street Europe *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* Alain Frisch, LexiFi *)\n(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 2018 Institut National de Recherche en Informatique et *)\n(* en Automatique (INRIA). *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nmodule Asttypes = struct\n type constant (*IF_CURRENT = Asttypes.constant *) =\n Const_int of int\n | Const_char of char\n | Const_string of string * string option\n | Const_float of string\n | Const_int32 of int32\n | Const_int64 of int64\n | Const_nativeint of nativeint\n\n type rec_flag (*IF_CURRENT = Asttypes.rec_flag *) = Nonrecursive | Recursive\n\n type direction_flag (*IF_CURRENT = Asttypes.direction_flag *) = Upto | Downto\n\n (* Order matters, used in polymorphic comparison *)\n type private_flag (*IF_CURRENT = Asttypes.private_flag *) = Private | Public\n\n type mutable_flag (*IF_CURRENT = Asttypes.mutable_flag *) = Immutable | Mutable\n\n type virtual_flag (*IF_CURRENT = Asttypes.virtual_flag *) = Virtual | Concrete\n\n type override_flag (*IF_CURRENT = Asttypes.override_flag *) = Override | Fresh\n\n type closed_flag (*IF_CURRENT = Asttypes.closed_flag *) = Closed | Open\n\n type label = string\n\n type arg_label (*IF_CURRENT = Asttypes.arg_label *) =\n Nolabel\n | Labelled of string (* label:T -> ... *)\n | Optional of string (* ?label:T -> ... *)\n\n type 'a loc = 'a Location.loc = {\n txt : 'a;\n loc : Location.t;\n }\n\n\n type variance (*IF_CURRENT = Asttypes.variance *) =\n | Covariant\n | Contravariant\n | Invariant\nend\n\nmodule Parsetree = struct\n\n open Asttypes\n\n type constant (*IF_CURRENT = Parsetree.constant *) =\n Pconst_integer of string * char option\n (* 3 3l 3L 3n\n\n Suffixes [g-z][G-Z] are accepted by the parser.\n Suffixes except 'l', 'L' and 'n' are rejected by the typechecker\n *)\n | Pconst_char of char\n (* 'c' *)\n | Pconst_string of string * string option\n (* \"constant\"\n {delim|other constant|delim}\n *)\n | Pconst_float of string * char option\n (* 3.4 2e5 1.4e-4\n\n Suffixes [g-z][G-Z] are accepted by the parser.\n Suffixes are rejected by the typechecker.\n *)\n\n type location_stack = Location.t list\n\n (** {1 Extension points} *)\n\n type attribute (*IF_CURRENT = Parsetree.attribute *) = {\n attr_name : string loc;\n attr_payload : payload;\n attr_loc : Location.t;\n }\n (* [@id ARG]\n [@@id ARG]\n\n Metadata containers passed around within the AST.\n The compiler ignores unknown attributes.\n *)\n\n and extension = string loc * payload\n (* [%id ARG]\n [%%id ARG]\n\n Sub-language placeholder -- rejected by the typechecker.\n *)\n\n and attributes = attribute list\n\n and payload (*IF_CURRENT = Parsetree.payload *) =\n | PStr of structure\n | PSig of signature (* : SIG *)\n | PTyp of core_type (* : T *)\n | PPat of pattern * expression option (* ? P or ? P when E *)\n\n (** {1 Core language} *)\n\n (* Type expressions *)\n\n and core_type (*IF_CURRENT = Parsetree.core_type *) =\n {\n ptyp_desc: core_type_desc;\n ptyp_loc: Location.t;\n ptyp_loc_stack: location_stack;\n ptyp_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and core_type_desc (*IF_CURRENT = Parsetree.core_type_desc *) =\n | Ptyp_any\n (* _ *)\n | Ptyp_var of string\n (* 'a *)\n | Ptyp_arrow of arg_label * core_type * core_type\n (* T1 -> T2 Simple\n ~l:T1 -> T2 Labelled\n ?l:T1 -> T2 Optional\n *)\n | Ptyp_tuple of core_type list\n (* T1 * ... * Tn\n\n Invariant: n >= 2\n *)\n | Ptyp_constr of Longident.t loc * core_type list\n (* tconstr\n T tconstr\n (T1, ..., Tn) tconstr\n *)\n | Ptyp_object of object_field list * closed_flag\n (* < l1:T1; ...; ln:Tn > (flag = Closed)\n < l1:T1; ...; ln:Tn; .. > (flag = Open)\n *)\n | Ptyp_class of Longident.t loc * core_type list\n (* #tconstr\n T #tconstr\n (T1, ..., Tn) #tconstr\n *)\n | Ptyp_alias of core_type * string\n (* T as 'a *)\n | Ptyp_variant of row_field list * closed_flag * label list option\n (* [ `A|`B ] (flag = Closed; labels = None)\n [> `A|`B ] (flag = Open; labels = None)\n [< `A|`B ] (flag = Closed; labels = Some [])\n [< `A|`B > `X `Y ](flag = Closed; labels = Some [\"X\";\"Y\"])\n *)\n | Ptyp_poly of string loc list * core_type\n (* 'a1 ... 'an. T\n\n Can only appear in the following context:\n\n - As the core_type of a Ppat_constraint node corresponding\n to a constraint on a let-binding: let x : 'a1 ... 'an. T\n = e ...\n\n - Under Cfk_virtual for methods (not values).\n\n - As the core_type of a Pctf_method node.\n\n - As the core_type of a Pexp_poly node.\n\n - As the pld_type field of a label_declaration.\n\n - As a core_type of a Ptyp_object node.\n *)\n\n | Ptyp_package of package_type\n (* (module S) *)\n | Ptyp_extension of extension\n (* [%id] *)\n\n and package_type = Longident.t loc * (Longident.t loc * core_type) list\n (*\n (module S)\n (module S with type t1 = T1 and ... and tn = Tn)\n *)\n\n and row_field (*IF_CURRENT = Parsetree.row_field *) = {\n prf_desc : row_field_desc;\n prf_loc : Location.t;\n prf_attributes : attributes;\n }\n\n and row_field_desc (*IF_CURRENT = Parsetree.row_field_desc *) =\n | Rtag of label loc * bool * core_type list\n (* [`A] ( true, [] )\n [`A of T] ( false, [T] )\n [`A of T1 & .. & Tn] ( false, [T1;...Tn] )\n [`A of & T1 & .. & Tn] ( true, [T1;...Tn] )\n\n - The 'bool' field is true if the tag contains a\n constant (empty) constructor.\n - '&' occurs when several types are used for the same constructor\n (see 4.2 in the manual)\n *)\n | Rinherit of core_type\n (* [ T ] *)\n\n and object_field (*IF_CURRENT = Parsetree.object_field *) = {\n pof_desc : object_field_desc;\n pof_loc : Location.t;\n pof_attributes : attributes;\n }\n\n and object_field_desc (*IF_CURRENT = Parsetree.object_field_desc *) =\n | Otag of label loc * core_type\n | Oinherit of core_type\n\n (* Patterns *)\n\n and pattern (*IF_CURRENT = Parsetree.pattern *) =\n {\n ppat_desc: pattern_desc;\n ppat_loc: Location.t;\n ppat_loc_stack: location_stack;\n ppat_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and pattern_desc (*IF_CURRENT = Parsetree.pattern_desc *) =\n | Ppat_any\n (* _ *)\n | Ppat_var of string loc\n (* x *)\n | Ppat_alias of pattern * string loc\n (* P as 'a *)\n | Ppat_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Ppat_interval of constant * constant\n (* 'a'..'z'\n\n Other forms of interval are recognized by the parser\n but rejected by the type-checker. *)\n | Ppat_tuple of pattern list\n (* (P1, ..., Pn)\n\n Invariant: n >= 2\n *)\n | Ppat_construct of Longident.t loc * pattern option\n (* C None\n C P Some P\n C (P1, ..., Pn) Some (Ppat_tuple [P1; ...; Pn])\n *)\n | Ppat_variant of label * pattern option\n (* `A (None)\n `A P (Some P)\n *)\n | Ppat_record of (Longident.t loc * pattern) list * closed_flag\n (* { l1=P1; ...; ln=Pn } (flag = Closed)\n { l1=P1; ...; ln=Pn; _} (flag = Open)\n\n Invariant: n > 0\n *)\n | Ppat_array of pattern list\n (* [| P1; ...; Pn |] *)\n | Ppat_or of pattern * pattern\n (* P1 | P2 *)\n | Ppat_constraint of pattern * core_type\n (* (P : T) *)\n | Ppat_type of Longident.t loc\n (* #tconst *)\n | Ppat_lazy of pattern\n (* lazy P *)\n | Ppat_unpack of string option loc\n (* (module P) Some \"P\"\n (module _) None\n\n Note: (module P : S) is represented as\n Ppat_constraint(Ppat_unpack, Ptyp_package)\n *)\n | Ppat_exception of pattern\n (* exception P *)\n | Ppat_extension of extension\n (* [%id] *)\n | Ppat_open of Longident.t loc * pattern\n (* M.(P) *)\n\n (* Value expressions *)\n\n and expression (*IF_CURRENT = Parsetree.expression *) =\n {\n pexp_desc: expression_desc;\n pexp_loc: Location.t;\n pexp_loc_stack: location_stack;\n pexp_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and expression_desc (*IF_CURRENT = Parsetree.expression_desc *) =\n | Pexp_ident of Longident.t loc\n (* x\n M.x\n *)\n | Pexp_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Pexp_let of rec_flag * value_binding list * expression\n (* let P1 = E1 and ... and Pn = EN in E (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in E (flag = Recursive)\n *)\n | Pexp_function of case list\n (* function P1 -> E1 | ... | Pn -> En *)\n | Pexp_fun of arg_label * expression option * pattern * expression\n (* fun P -> E1 (Simple, None)\n fun ~l:P -> E1 (Labelled l, None)\n fun ?l:P -> E1 (Optional l, None)\n fun ?l:(P = E0) -> E1 (Optional l, Some E0)\n\n Notes:\n - If E0 is provided, only Optional is allowed.\n - \"fun P1 P2 .. Pn -> E1\" is represented as nested Pexp_fun.\n - \"let f P = E\" is represented using Pexp_fun.\n *)\n | Pexp_apply of expression * (arg_label * expression) list\n (* E0 ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pexp_match of expression * case list\n (* match E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_try of expression * case list\n (* try E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_tuple of expression list\n (* (E1, ..., En)\n\n Invariant: n >= 2\n *)\n | Pexp_construct of Longident.t loc * expression option\n (* C None\n C E Some E\n C (E1, ..., En) Some (Pexp_tuple[E1;...;En])\n *)\n | Pexp_variant of label * expression option\n (* `A (None)\n `A E (Some E)\n *)\n | Pexp_record of (Longident.t loc * expression) list * expression option\n (* { l1=P1; ...; ln=Pn } (None)\n { E0 with l1=P1; ...; ln=Pn } (Some E0)\n\n Invariant: n > 0\n *)\n | Pexp_field of expression * Longident.t loc\n (* E.l *)\n | Pexp_setfield of expression * Longident.t loc * expression\n (* E1.l <- E2 *)\n | Pexp_array of expression list\n (* [| E1; ...; En |] *)\n | Pexp_ifthenelse of expression * expression * expression option\n (* if E1 then E2 else E3 *)\n | Pexp_sequence of expression * expression\n (* E1; E2 *)\n | Pexp_while of expression * expression\n (* while E1 do E2 done *)\n | Pexp_for of\n pattern * expression * expression * direction_flag * expression\n (* for i = E1 to E2 do E3 done (flag = Upto)\n for i = E1 downto E2 do E3 done (flag = Downto)\n *)\n | Pexp_constraint of expression * core_type\n (* (E : T) *)\n | Pexp_coerce of expression * core_type option * core_type\n (* (E :> T) (None, T)\n (E : T0 :> T) (Some T0, T)\n *)\n | Pexp_send of expression * label loc\n (* E # m *)\n | Pexp_new of Longident.t loc\n (* new M.c *)\n | Pexp_setinstvar of label loc * expression\n (* x <- 2 *)\n | Pexp_override of (label loc * expression) list\n (* {< x1 = E1; ...; Xn = En >} *)\n | Pexp_letmodule of string option loc * module_expr * expression\n (* let module M = ME in E *)\n | Pexp_letexception of extension_constructor * expression\n (* let exception C in E *)\n | Pexp_assert of expression\n (* assert E\n Note: \"assert false\" is treated in a special way by the\n type-checker. *)\n | Pexp_lazy of expression\n (* lazy E *)\n | Pexp_poly of expression * core_type option\n (* Used for method bodies.\n\n Can only be used as the expression under Cfk_concrete\n for methods (not values). *)\n | Pexp_object of class_structure\n (* object ... end *)\n | Pexp_newtype of string loc * expression\n (* fun (type t) -> E *)\n | Pexp_pack of module_expr\n (* (module ME)\n\n (module ME : S) is represented as\n Pexp_constraint(Pexp_pack, Ptyp_package S) *)\n | Pexp_open of open_declaration * expression\n (* M.(E)\n let open M in E\n let! open M in E *)\n | Pexp_letop of letop\n (* let* P = E in E\n let* P = E and* P = E in E *)\n | Pexp_extension of extension\n (* [%id] *)\n | Pexp_unreachable\n (* . *)\n\n and case (*IF_CURRENT = Parsetree.case *) = (* (P -> E) or (P when E0 -> E) *)\n {\n pc_lhs: pattern;\n pc_guard: expression option;\n pc_rhs: expression;\n }\n\n and letop (*IF_CURRENT = Parsetree.letop *) =\n {\n let_ : binding_op;\n ands : binding_op list;\n body : expression;\n }\n\n and binding_op (*IF_CURRENT = Parsetree.binding_op *) =\n {\n pbop_op : string loc;\n pbop_pat : pattern;\n pbop_exp : expression;\n pbop_loc : Location.t;\n }\n\n (* Value descriptions *)\n\n and value_description (*IF_CURRENT = Parsetree.value_description *) =\n {\n pval_name: string loc;\n pval_type: core_type;\n pval_prim: string list;\n pval_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pval_loc: Location.t;\n }\n\n(*\n val x: T (prim = [])\n external x: T = \"s1\" ... \"sn\" (prim = [\"s1\";...\"sn\"])\n*)\n\n (* Type declarations *)\n\n and type_declaration (*IF_CURRENT = Parsetree.type_declaration *) =\n {\n ptype_name: string loc;\n ptype_params: (core_type * variance) list;\n (* ('a1,...'an) t; None represents _*)\n ptype_cstrs: (core_type * core_type * Location.t) list;\n (* ... constraint T1=T1' ... constraint Tn=Tn' *)\n ptype_kind: type_kind;\n ptype_private: private_flag; (* = private ... *)\n ptype_manifest: core_type option; (* = T *)\n ptype_attributes: attributes; (* ... [@@id1] [@@id2] *)\n ptype_loc: Location.t;\n }\n\n(*\n type t (abstract, no manifest)\n type t = T0 (abstract, manifest=T0)\n type t = C of T | ... (variant, no manifest)\n type t = T0 = C of T | ... (variant, manifest=T0)\n type t = {l: T; ...} (record, no manifest)\n type t = T0 = {l : T; ...} (record, manifest=T0)\n type t = .. (open, no manifest)\n*)\n\n and type_kind (*IF_CURRENT = Parsetree.type_kind *) =\n | Ptype_abstract\n | Ptype_variant of constructor_declaration list\n | Ptype_record of label_declaration list\n (* Invariant: non-empty list *)\n | Ptype_open\n\n and label_declaration (*IF_CURRENT = Parsetree.label_declaration *) =\n {\n pld_name: string loc;\n pld_mutable: mutable_flag;\n pld_type: core_type;\n pld_loc: Location.t;\n pld_attributes: attributes; (* l : T [@id1] [@id2] *)\n }\n\n (* { ...; l: T; ... } (mutable=Immutable)\n { ...; mutable l: T; ... } (mutable=Mutable)\n\n Note: T can be a Ptyp_poly.\n *)\n\n and constructor_declaration (*IF_CURRENT = Parsetree.constructor_declaration *) =\n {\n pcd_name: string loc;\n pcd_args: constructor_arguments;\n pcd_res: core_type option;\n pcd_loc: Location.t;\n pcd_attributes: attributes; (* C of ... [@id1] [@id2] *)\n }\n\n and constructor_arguments (*IF_CURRENT = Parsetree.constructor_arguments *) =\n | Pcstr_tuple of core_type list\n | Pcstr_record of label_declaration list\n\n(*\n | C of T1 * ... * Tn (res = None, args = Pcstr_tuple [])\n | C: T0 (res = Some T0, args = [])\n | C: T1 * ... * Tn -> T0 (res = Some T0, args = Pcstr_tuple)\n | C of {...} (res = None, args = Pcstr_record)\n | C: {...} -> T0 (res = Some T0, args = Pcstr_record)\n | C of {...} as t (res = None, args = Pcstr_record)\n*)\n\n and type_extension (*IF_CURRENT = Parsetree.type_extension *) =\n {\n ptyext_path: Longident.t loc;\n ptyext_params: (core_type * variance) list;\n ptyext_constructors: extension_constructor list;\n ptyext_private: private_flag;\n ptyext_loc: Location.t;\n ptyext_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n(*\n type t += ...\n*)\n\n and extension_constructor (*IF_CURRENT = Parsetree.extension_constructor *) =\n {\n pext_name: string loc;\n pext_kind : extension_constructor_kind;\n pext_loc : Location.t;\n pext_attributes: attributes; (* C of ... [@id1] [@id2] *)\n }\n\n (* exception E *)\n and type_exception (*IF_CURRENT = Parsetree.type_exception *) =\n {\n ptyexn_constructor: extension_constructor;\n ptyexn_loc: Location.t;\n ptyexn_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and extension_constructor_kind (*IF_CURRENT = Parsetree.extension_constructor_kind *) =\n Pext_decl of constructor_arguments * core_type option\n (*\n | C of T1 * ... * Tn ([T1; ...; Tn], None)\n | C: T0 ([], Some T0)\n | C: T1 * ... * Tn -> T0 ([T1; ...; Tn], Some T0)\n *)\n | Pext_rebind of Longident.t loc\n (*\n | C = D\n *)\n\n (** {1 Class language} *)\n\n (* Type expressions for the class language *)\n\n and class_type (*IF_CURRENT = Parsetree.class_type *) =\n {\n pcty_desc: class_type_desc;\n pcty_loc: Location.t;\n pcty_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and class_type_desc (*IF_CURRENT = Parsetree.class_type_desc *) =\n | Pcty_constr of Longident.t loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcty_signature of class_signature\n (* object ... end *)\n | Pcty_arrow of arg_label * core_type * class_type\n (* T -> CT Simple\n ~l:T -> CT Labelled l\n ?l:T -> CT Optional l\n *)\n | Pcty_extension of extension\n (* [%id] *)\n | Pcty_open of open_description * class_type\n (* let open M in CT *)\n\n and class_signature (*IF_CURRENT = Parsetree.class_signature *) =\n {\n pcsig_self: core_type;\n pcsig_fields: class_type_field list;\n }\n (* object('selfpat) ... end\n object ... end (self = Ptyp_any)\n *)\n\n and class_type_field (*IF_CURRENT = Parsetree.class_type_field *) =\n {\n pctf_desc: class_type_field_desc;\n pctf_loc: Location.t;\n pctf_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and class_type_field_desc (*IF_CURRENT = Parsetree.class_type_field_desc *) =\n | Pctf_inherit of class_type\n (* inherit CT *)\n | Pctf_val of (label loc * mutable_flag * virtual_flag * core_type)\n (* val x: T *)\n | Pctf_method of (label loc * private_flag * virtual_flag * core_type)\n (* method x: T\n\n Note: T can be a Ptyp_poly.\n *)\n | Pctf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pctf_attribute of attribute\n (* [@@@id] *)\n | Pctf_extension of extension\n (* [%%id] *)\n\n and 'a class_infos (*IF_CURRENT = 'a Parsetree.class_infos *) =\n {\n pci_virt: virtual_flag;\n pci_params: (core_type * variance) list;\n pci_name: string loc;\n pci_expr: 'a;\n pci_loc: Location.t;\n pci_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n (* class c = ...\n class ['a1,...,'an] c = ...\n class virtual c = ...\n\n Also used for \"class type\" declaration.\n *)\n\n and class_description = class_type class_infos\n\n and class_type_declaration = class_type class_infos\n\n (* Value expressions for the class language *)\n\n and class_expr (*IF_CURRENT = Parsetree.class_expr *) =\n {\n pcl_desc: class_expr_desc;\n pcl_loc: Location.t;\n pcl_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and class_expr_desc (*IF_CURRENT = Parsetree.class_expr_desc *) =\n | Pcl_constr of Longident.t loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcl_structure of class_structure\n (* object ... end *)\n | Pcl_fun of arg_label * expression option * pattern * class_expr\n (* fun P -> CE (Simple, None)\n fun ~l:P -> CE (Labelled l, None)\n fun ?l:P -> CE (Optional l, None)\n fun ?l:(P = E0) -> CE (Optional l, Some E0)\n *)\n | Pcl_apply of class_expr * (arg_label * expression) list\n (* CE ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pcl_let of rec_flag * value_binding list * class_expr\n (* let P1 = E1 and ... and Pn = EN in CE (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in CE (flag = Recursive)\n *)\n | Pcl_constraint of class_expr * class_type\n (* (CE : CT) *)\n | Pcl_extension of extension\n (* [%id] *)\n | Pcl_open of open_description * class_expr\n (* let open M in CE *)\n\n\n and class_structure (*IF_CURRENT = Parsetree.class_structure *) =\n {\n pcstr_self: pattern;\n pcstr_fields: class_field list;\n }\n (* object(selfpat) ... end\n object ... end (self = Ppat_any)\n *)\n\n and class_field (*IF_CURRENT = Parsetree.class_field *) =\n {\n pcf_desc: class_field_desc;\n pcf_loc: Location.t;\n pcf_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and class_field_desc (*IF_CURRENT = Parsetree.class_field_desc *) =\n | Pcf_inherit of override_flag * class_expr * string loc option\n (* inherit CE\n inherit CE as x\n inherit! CE\n inherit! CE as x\n *)\n | Pcf_val of (label loc * mutable_flag * class_field_kind)\n (* val x = E\n val virtual x: T\n *)\n | Pcf_method of (label loc * private_flag * class_field_kind)\n (* method x = E (E can be a Pexp_poly)\n method virtual x: T (T can be a Ptyp_poly)\n *)\n | Pcf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pcf_initializer of expression\n (* initializer E *)\n | Pcf_attribute of attribute\n (* [@@@id] *)\n | Pcf_extension of extension\n (* [%%id] *)\n\n and class_field_kind (*IF_CURRENT = Parsetree.class_field_kind *) =\n | Cfk_virtual of core_type\n | Cfk_concrete of override_flag * expression\n\n and class_declaration = class_expr class_infos\n\n (** {1 Module language} *)\n\n (* Type expressions for the module language *)\n\n and module_type (*IF_CURRENT = Parsetree.module_type *) =\n {\n pmty_desc: module_type_desc;\n pmty_loc: Location.t;\n pmty_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and module_type_desc (*IF_CURRENT = Parsetree.module_type_desc *) =\n | Pmty_ident of Longident.t loc\n (* S *)\n | Pmty_signature of signature\n (* sig ... end *)\n | Pmty_functor of functor_parameter * module_type\n (* functor(X : MT1) -> MT2 *)\n | Pmty_with of module_type * with_constraint list\n (* MT with ... *)\n | Pmty_typeof of module_expr\n (* module type of ME *)\n | Pmty_extension of extension\n (* [%id] *)\n | Pmty_alias of Longident.t loc\n (* (module M) *)\n\n and functor_parameter (*IF_CURRENT = Parsetree.functor_parameter *) =\n | Unit\n (* () *)\n | Named of string option loc * module_type\n (* (X : MT) Some X, MT\n (_ : MT) None, MT *)\n\n and signature = signature_item list\n\n and signature_item (*IF_CURRENT = Parsetree.signature_item *) =\n {\n psig_desc: signature_item_desc;\n psig_loc: Location.t;\n }\n\n and signature_item_desc (*IF_CURRENT = Parsetree.signature_item_desc *) =\n | Psig_value of value_description\n (*\n val x: T\n external x: T = \"s1\" ... \"sn\"\n *)\n | Psig_type of rec_flag * type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Psig_typesubst of type_declaration list\n (* type t1 := ... and ... and tn := ... *)\n | Psig_typext of type_extension\n (* type t1 += ... *)\n | Psig_exception of type_exception\n (* exception C of T *)\n | Psig_module of module_declaration\n (* module X = M\n module X : MT *)\n | Psig_modsubst of module_substitution\n (* module X := M *)\n | Psig_recmodule of module_declaration list\n (* module rec X1 : MT1 and ... and Xn : MTn *)\n | Psig_modtype of module_type_declaration\n (* module type S = MT\n module type S *)\n | Psig_open of open_description\n (* open X *)\n | Psig_include of include_description\n (* include MT *)\n | Psig_class of class_description list\n (* class c1 : ... and ... and cn : ... *)\n | Psig_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Psig_attribute of attribute\n (* [@@@id] *)\n | Psig_extension of extension * attributes\n (* [%%id] *)\n\n and module_declaration (*IF_CURRENT = Parsetree.module_declaration *) =\n {\n pmd_name: string option loc;\n pmd_type: module_type;\n pmd_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pmd_loc: Location.t;\n }\n (* S : MT *)\n\n and module_substitution (*IF_CURRENT = Parsetree.module_substitution *) =\n {\n pms_name: string loc;\n pms_manifest: Longident.t loc;\n pms_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pms_loc: Location.t;\n }\n\n and module_type_declaration (*IF_CURRENT = Parsetree.module_type_declaration *) =\n {\n pmtd_name: string loc;\n pmtd_type: module_type option;\n pmtd_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pmtd_loc: Location.t;\n }\n (* S = MT\n S (abstract module type declaration, pmtd_type = None)\n *)\n\n and 'a open_infos (*IF_CURRENT = 'a Parsetree.open_infos *) =\n {\n popen_expr: 'a;\n popen_override: override_flag;\n popen_loc: Location.t;\n popen_attributes: attributes;\n }\n (* open! X - popen_override = Override (silences the 'used identifier\n shadowing' warning)\n open X - popen_override = Fresh\n *)\n\n and open_description = Longident.t loc open_infos\n (* open M.N\n open M(N).O *)\n\n and open_declaration = module_expr open_infos\n (* open M.N\n open M(N).O\n open struct ... end *)\n\n and 'a include_infos (*IF_CURRENT = 'a Parsetree.include_infos *) =\n {\n pincl_mod: 'a;\n pincl_loc: Location.t;\n pincl_attributes: attributes;\n }\n\n and include_description = module_type include_infos\n (* include MT *)\n\n and include_declaration = module_expr include_infos\n (* include ME *)\n\n and with_constraint (*IF_CURRENT = Parsetree.with_constraint *) =\n | Pwith_type of Longident.t loc * type_declaration\n (* with type X.t = ...\n\n Note: the last component of the longident must match\n the name of the type_declaration. *)\n | Pwith_module of Longident.t loc * Longident.t loc\n (* with module X.Y = Z *)\n | Pwith_typesubst of Longident.t loc * type_declaration\n (* with type X.t := ..., same format as [Pwith_type] *)\n | Pwith_modsubst of Longident.t loc * Longident.t loc\n (* with module X.Y := Z *)\n\n (* Value expressions for the module language *)\n\n and module_expr (*IF_CURRENT = Parsetree.module_expr *) =\n {\n pmod_desc: module_expr_desc;\n pmod_loc: Location.t;\n pmod_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and module_expr_desc (*IF_CURRENT = Parsetree.module_expr_desc *) =\n | Pmod_ident of Longident.t loc\n (* X *)\n | Pmod_structure of structure\n (* struct ... end *)\n | Pmod_functor of functor_parameter * module_expr\n (* functor(X : MT1) -> ME *)\n | Pmod_apply of module_expr * module_expr\n (* ME1(ME2) *)\n | Pmod_constraint of module_expr * module_type\n (* (ME : MT) *)\n | Pmod_unpack of expression\n (* (val E) *)\n | Pmod_extension of extension\n (* [%id] *)\n\n and structure = structure_item list\n\n and structure_item (*IF_CURRENT = Parsetree.structure_item *) =\n {\n pstr_desc: structure_item_desc;\n pstr_loc: Location.t;\n }\n\n and structure_item_desc (*IF_CURRENT = Parsetree.structure_item_desc *) =\n | Pstr_eval of expression * attributes\n (* E *)\n | Pstr_value of rec_flag * value_binding list\n (* let P1 = E1 and ... and Pn = EN (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN (flag = Recursive)\n *)\n | Pstr_primitive of value_description\n (* val x: T\n external x: T = \"s1\" ... \"sn\" *)\n | Pstr_type of rec_flag * type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Pstr_typext of type_extension\n (* type t1 += ... *)\n | Pstr_exception of type_exception\n (* exception C of T\n exception C = M.X *)\n | Pstr_module of module_binding\n (* module X = ME *)\n | Pstr_recmodule of module_binding list\n (* module rec X1 = ME1 and ... and Xn = MEn *)\n | Pstr_modtype of module_type_declaration\n (* module type S = MT *)\n | Pstr_open of open_declaration\n (* open X *)\n | Pstr_class of class_declaration list\n (* class c1 = ... and ... and cn = ... *)\n | Pstr_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Pstr_include of include_declaration\n (* include ME *)\n | Pstr_attribute of attribute\n (* [@@@id] *)\n | Pstr_extension of extension * attributes\n (* [%%id] *)\n\n and value_binding (*IF_CURRENT = Parsetree.value_binding *) =\n {\n pvb_pat: pattern;\n pvb_expr: expression;\n pvb_attributes: attributes;\n pvb_loc: Location.t;\n }\n\n and module_binding (*IF_CURRENT = Parsetree.module_binding *) =\n {\n pmb_name: string option loc;\n pmb_expr: module_expr;\n pmb_attributes: attributes;\n pmb_loc: Location.t;\n }\n (* X = ME *)\n\n (** {1 Toplevel} *)\n\n (* Toplevel phrases *)\n\n type toplevel_phrase (*IF_CURRENT = Parsetree.toplevel_phrase *) =\n | Ptop_def of structure\n | Ptop_dir of toplevel_directive\n (* #use, #load ... *)\n\n and toplevel_directive (*IF_CURRENT = Parsetree.toplevel_directive *) =\n {\n pdir_name : string loc;\n pdir_arg : directive_argument option;\n pdir_loc : Location.t;\n }\n\n and directive_argument (*IF_CURRENT = Parsetree.directive_argument *) =\n {\n pdira_desc : directive_argument_desc;\n pdira_loc : Location.t;\n }\n\n and directive_argument_desc (*IF_CURRENT = Parsetree.directive_argument_desc *) =\n | Pdir_string of string\n | Pdir_int of string * char option\n | Pdir_ident of Longident.t\n | Pdir_bool of bool\n\nend\n\nmodule Config = struct\n let ast_impl_magic_number = \"Caml1999M027\"\n let ast_intf_magic_number = \"Caml1999N027\"\nend\n","(**************************************************************************)\n(* *)\n(* OCaml Migrate Parsetree *)\n(* *)\n(* Frédéric Bour, Facebook *)\n(* Jérémie Dimino and Leo White, Jane Street Europe *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* Alain Frisch, LexiFi *)\n(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 2018 Institut National de Recherche en Informatique et *)\n(* en Automatique (INRIA). *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nmodule Asttypes = struct\n\n type constant (*IF_CURRENT = Asttypes.constant *) =\n Const_int of int\n | Const_char of char\n | Const_string of string * string option\n | Const_float of string\n | Const_int32 of int32\n | Const_int64 of int64\n | Const_nativeint of nativeint\n\n type rec_flag (*IF_CURRENT = Asttypes.rec_flag *) = Nonrecursive | Recursive\n\n type direction_flag (*IF_CURRENT = Asttypes.direction_flag *) = Upto | Downto\n\n (* Order matters, used in polymorphic comparison *)\n type private_flag (*IF_CURRENT = Asttypes.private_flag *) = Private | Public\n\n type mutable_flag (*IF_CURRENT = Asttypes.mutable_flag *) = Immutable | Mutable\n\n type virtual_flag (*IF_CURRENT = Asttypes.virtual_flag *) = Virtual | Concrete\n\n type override_flag (*IF_CURRENT = Asttypes.override_flag *) = Override | Fresh\n\n type closed_flag (*IF_CURRENT = Asttypes.closed_flag *) = Closed | Open\n\n type label = string\n\n type arg_label (*IF_CURRENT = Asttypes.arg_label *) =\n Nolabel\n | Labelled of string (* label:T -> ... *)\n | Optional of string (* ?label:T -> ... *)\n\n type 'a loc = 'a Location.loc = {\n txt : 'a;\n loc : Location.t;\n }\n\n\n type variance (*IF_CURRENT = Asttypes.variance *) =\n | Covariant\n | Contravariant\n | Invariant\n\nend\n\nmodule Parsetree = struct\n\n open Asttypes\n\n type constant (*IF_CURRENT = Parsetree.constant *) =\n Pconst_integer of string * char option\n (* 3 3l 3L 3n\n\n Suffixes [g-z][G-Z] are accepted by the parser.\n Suffixes except 'l', 'L' and 'n' are rejected by the typechecker\n *)\n | Pconst_char of char\n (* 'c' *)\n | Pconst_string of string * string option\n (* \"constant\"\n {delim|other constant|delim}\n *)\n | Pconst_float of string * char option\n (* 3.4 2e5 1.4e-4\n\n Suffixes [g-z][G-Z] are accepted by the parser.\n Suffixes are rejected by the typechecker.\n *)\n\n (** {1 Extension points} *)\n\n type attribute (*IF_CURRENT = Parsetree.attribute *) = {\n attr_name : string loc;\n attr_payload : payload;\n attr_loc : Location.t;\n }\n (* [@id ARG]\n [@@id ARG]\n\n Metadata containers passed around within the AST.\n The compiler ignores unknown attributes.\n *)\n\n and extension = string loc * payload\n (* [%id ARG]\n [%%id ARG]\n\n Sub-language placeholder -- rejected by the typechecker.\n *)\n\n and attributes = attribute list\n\n and payload (*IF_CURRENT = Parsetree.payload *) =\n | PStr of structure\n | PSig of signature (* : SIG *)\n | PTyp of core_type (* : T *)\n | PPat of pattern * expression option (* ? P or ? P when E *)\n\n (** {1 Core language} *)\n\n (* Type expressions *)\n\n and core_type (*IF_CURRENT = Parsetree.core_type *) =\n {\n ptyp_desc: core_type_desc;\n ptyp_loc: Location.t;\n ptyp_loc_stack: Location.t list;\n ptyp_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and typ = core_type\n\n and core_type_desc (*IF_CURRENT = Parsetree.core_type_desc *) =\n | Ptyp_any\n (* _ *)\n | Ptyp_var of string\n (* 'a *)\n | Ptyp_arrow of arg_label * core_type * core_type\n (* T1 -> T2 Simple\n ~l:T1 -> T2 Labelled\n ?l:T1 -> T2 Optional\n *)\n | Ptyp_tuple of core_type list\n (* T1 * ... * Tn\n\n Invariant: n >= 2\n *)\n | Ptyp_constr of Longident.t loc * core_type list\n (* tconstr\n T tconstr\n (T1, ..., Tn) tconstr\n *)\n | Ptyp_object of object_field list * closed_flag\n (* < l1:T1; ...; ln:Tn > (flag = Closed)\n < l1:T1; ...; ln:Tn; .. > (flag = Open)\n *)\n | Ptyp_class of Longident.t loc * core_type list\n (* #tconstr\n T #tconstr\n (T1, ..., Tn) #tconstr\n *)\n | Ptyp_alias of core_type * string\n (* T as 'a *)\n | Ptyp_variant of row_field list * closed_flag * label list option\n (* [ `A|`B ] (flag = Closed; labels = None)\n [> `A|`B ] (flag = Open; labels = None)\n [< `A|`B ] (flag = Closed; labels = Some [])\n [< `A|`B > `X `Y ](flag = Closed; labels = Some [\"X\";\"Y\"])\n *)\n | Ptyp_poly of string loc list * core_type\n (* 'a1 ... 'an. T\n\n Can only appear in the following context:\n\n - As the core_type of a Ppat_constraint node corresponding\n to a constraint on a let-binding: let x : 'a1 ... 'an. T\n = e ...\n\n - Under Cfk_virtual for methods (not values).\n\n - As the core_type of a Pctf_method node.\n\n - As the core_type of a Pexp_poly node.\n\n - As the pld_type field of a label_declaration.\n\n - As a core_type of a Ptyp_object node.\n *)\n\n | Ptyp_package of package_type\n (* (module S) *)\n | Ptyp_extension of extension\n (* [%id] *)\n\n and package_type = Longident.t loc * (Longident.t loc * core_type) list\n (*\n (module S)\n (module S with type t1 = T1 and ... and tn = Tn)\n *)\n\n and row_field (*IF_CURRENT = Parsetree.row_field *) = {\n prf_desc : row_field_desc;\n prf_loc : Location.t;\n prf_attributes : attributes;\n }\n\n and row_field_desc (*IF_CURRENT = Parsetree.row_field_desc *) =\n | Rtag of label loc * bool * core_type list\n (* [`A] ( true, [] )\n [`A of T] ( false, [T] )\n [`A of T1 & .. & Tn] ( false, [T1;...Tn] )\n [`A of & T1 & .. & Tn] ( true, [T1;...Tn] )\n\n - The 'bool' field is true if the tag contains a\n constant (empty) constructor.\n - '&' occurs when several types are used for the same constructor\n (see 4.2 in the manual)\n *)\n | Rinherit of core_type\n (* [ T ] *)\n\n and object_field (*IF_CURRENT = Parsetree.object_field *) = {\n pof_desc : object_field_desc;\n pof_loc : Location.t;\n pof_attributes : attributes;\n }\n\n and object_field_desc (*IF_CURRENT = Parsetree.object_field_desc *) =\n | Otag of label loc * core_type\n | Oinherit of core_type\n\n (* Patterns *)\n\n and pattern (*IF_CURRENT = Parsetree.pattern *) =\n {\n ppat_desc: pattern_desc;\n ppat_loc: Location.t;\n ppat_loc_stack: Location.t list;\n ppat_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and pat = pattern\n\n and pattern_desc (*IF_CURRENT = Parsetree.pattern_desc *) =\n | Ppat_any\n (* _ *)\n | Ppat_var of string loc\n (* x *)\n | Ppat_alias of pattern * string loc\n (* P as 'a *)\n | Ppat_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Ppat_interval of constant * constant\n (* 'a'..'z'\n\n Other forms of interval are recognized by the parser\n but rejected by the type-checker. *)\n | Ppat_tuple of pattern list\n (* (P1, ..., Pn)\n\n Invariant: n >= 2\n *)\n | Ppat_construct of Longident.t loc * pattern option\n (* C None\n C P Some P\n C (P1, ..., Pn) Some (Ppat_tuple [P1; ...; Pn])\n *)\n | Ppat_variant of label * pattern option\n (* `A (None)\n `A P (Some P)\n *)\n | Ppat_record of (Longident.t loc * pattern) list * closed_flag\n (* { l1=P1; ...; ln=Pn } (flag = Closed)\n { l1=P1; ...; ln=Pn; _} (flag = Open)\n\n Invariant: n > 0\n *)\n | Ppat_array of pattern list\n (* [| P1; ...; Pn |] *)\n | Ppat_or of pattern * pattern\n (* P1 | P2 *)\n | Ppat_constraint of pattern * core_type\n (* (P : T) *)\n | Ppat_type of Longident.t loc\n (* #tconst *)\n | Ppat_lazy of pattern\n (* lazy P *)\n | Ppat_unpack of string loc\n (* (module P)\n Note: (module P : S) is represented as\n Ppat_constraint(Ppat_unpack, Ptyp_package)\n *)\n | Ppat_exception of pattern\n (* exception P *)\n | Ppat_extension of extension\n (* [%id] *)\n | Ppat_open of Longident.t loc * pattern\n (* M.(P) *)\n\n (* Value expressions *)\n\n and expression (*IF_CURRENT = Parsetree.expression *) =\n {\n pexp_desc: expression_desc;\n pexp_loc: Location.t;\n pexp_loc_stack: Location.t list;\n pexp_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and expr = expression\n\n and expression_desc (*IF_CURRENT = Parsetree.expression_desc *) =\n | Pexp_ident of Longident.t loc\n (* x\n M.x\n *)\n | Pexp_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Pexp_let of rec_flag * value_binding list * expression\n (* let P1 = E1 and ... and Pn = EN in E (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in E (flag = Recursive)\n *)\n | Pexp_function of cases\n (* function P1 -> E1 | ... | Pn -> En *)\n | Pexp_fun of arg_label * expression option * pattern * expression\n (* fun P -> E1 (Simple, None)\n fun ~l:P -> E1 (Labelled l, None)\n fun ?l:P -> E1 (Optional l, None)\n fun ?l:(P = E0) -> E1 (Optional l, Some E0)\n\n Notes:\n - If E0 is provided, only Optional is allowed.\n - \"fun P1 P2 .. Pn -> E1\" is represented as nested Pexp_fun.\n - \"let f P = E\" is represented using Pexp_fun.\n *)\n | Pexp_apply of expression * (arg_label * expression) list\n (* E0 ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pexp_match of expression * cases\n (* match E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_try of expression * cases\n (* try E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_tuple of expression list\n (* (E1, ..., En)\n\n Invariant: n >= 2\n *)\n | Pexp_construct of Longident.t loc * expression option\n (* C None\n C E Some E\n C (E1, ..., En) Some (Pexp_tuple[E1;...;En])\n *)\n | Pexp_variant of label * expression option\n (* `A (None)\n `A E (Some E)\n *)\n | Pexp_record of (Longident.t loc * expression) list * expression option\n (* { l1=P1; ...; ln=Pn } (None)\n { E0 with l1=P1; ...; ln=Pn } (Some E0)\n\n Invariant: n > 0\n *)\n | Pexp_field of expression * Longident.t loc\n (* E.l *)\n | Pexp_setfield of expression * Longident.t loc * expression\n (* E1.l <- E2 *)\n | Pexp_array of expression list\n (* [| E1; ...; En |] *)\n | Pexp_ifthenelse of expression * expression * expression option\n (* if E1 then E2 else E3 *)\n | Pexp_sequence of expression * expression\n (* E1; E2 *)\n | Pexp_while of expression * expression\n (* while E1 do E2 done *)\n | Pexp_for of\n pattern * expression * expression * direction_flag * expression\n (* for i = E1 to E2 do E3 done (flag = Upto)\n for i = E1 downto E2 do E3 done (flag = Downto)\n *)\n | Pexp_constraint of expression * core_type\n (* (E : T) *)\n | Pexp_coerce of expression * core_type option * core_type\n (* (E :> T) (None, T)\n (E : T0 :> T) (Some T0, T)\n *)\n | Pexp_send of expression * label loc\n (* E # m *)\n | Pexp_new of Longident.t loc\n (* new M.c *)\n | Pexp_setinstvar of label loc * expression\n (* x <- 2 *)\n | Pexp_override of (label loc * expression) list\n (* {< x1 = E1; ...; Xn = En >} *)\n | Pexp_letmodule of string loc * module_expr * expression\n (* let module M = ME in E *)\n | Pexp_letexception of extension_constructor * expression\n (* let exception C in E *)\n | Pexp_assert of expression\n (* assert E\n Note: \"assert false\" is treated in a special way by the\n type-checker. *)\n | Pexp_lazy of expression\n (* lazy E *)\n | Pexp_poly of expression * core_type option\n (* Used for method bodies.\n\n Can only be used as the expression under Cfk_concrete\n for methods (not values). *)\n | Pexp_object of class_structure\n (* object ... end *)\n | Pexp_newtype of string loc * expression\n (* fun (type t) -> E *)\n | Pexp_pack of module_expr\n (* (module ME)\n\n (module ME : S) is represented as\n Pexp_constraint(Pexp_pack, Ptyp_package S) *)\n | Pexp_open of open_declaration * expression\n (* M.(E)\n let open M in E\n let! open M in E *)\n | Pexp_letop of letop\n (* let* P = E in E\n let* P = E and* P = E in E *)\n | Pexp_extension of extension\n (* [%id] *)\n | Pexp_unreachable\n (* . *)\n\n and case (*IF_CURRENT = Parsetree.case *) = (* (P -> E) or (P when E0 -> E) *)\n {\n pc_lhs: pattern;\n pc_guard: expression option;\n pc_rhs: expression;\n }\n\n and cases = case list\n\n and letop (*IF_CURRENT = Parsetree.letop *) =\n {\n let_ : binding_op;\n ands : binding_op list;\n body : expression;\n }\n\n and binding_op (*IF_CURRENT = Parsetree.binding_op *) =\n {\n pbop_op : string loc;\n pbop_pat : pattern;\n pbop_exp : expression;\n pbop_loc : Location.t;\n }\n\n (* Value descriptions *)\n\n and value_description (*IF_CURRENT = Parsetree.value_description *) =\n {\n pval_name: string loc;\n pval_type: core_type;\n pval_prim: string list;\n pval_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pval_loc: Location.t;\n }\n\n(*\n val x: T (prim = [])\n external x: T = \"s1\" ... \"sn\" (prim = [\"s1\";...\"sn\"])\n *)\n\n (* Type declarations *)\n\n and type_declaration (*IF_CURRENT = Parsetree.type_declaration *) =\n {\n ptype_name: string loc;\n ptype_params: (core_type * variance) list;\n (* ('a1,...'an) t; None represents _*)\n ptype_cstrs: (core_type * core_type * Location.t) list;\n (* ... constraint T1=T1' ... constraint Tn=Tn' *)\n ptype_kind: type_kind;\n ptype_private: private_flag; (* = private ... *)\n ptype_manifest: core_type option; (* = T *)\n ptype_attributes: attributes; (* ... [@@id1] [@@id2] *)\n ptype_loc: Location.t;\n }\n\n(*\n type t (abstract, no manifest)\n type t = T0 (abstract, manifest=T0)\n type t = C of T | ... (variant, no manifest)\n type t = T0 = C of T | ... (variant, manifest=T0)\n type t = {l: T; ...} (record, no manifest)\n type t = T0 = {l : T; ...} (record, manifest=T0)\n type t = .. (open, no manifest)\n *)\n\n and type_kind (*IF_CURRENT = Parsetree.type_kind *) =\n | Ptype_abstract\n | Ptype_variant of constructor_declaration list\n | Ptype_record of label_declaration list\n (* Invariant: non-empty list *)\n | Ptype_open\n\n and label_declaration (*IF_CURRENT = Parsetree.label_declaration *) =\n {\n pld_name: string loc;\n pld_mutable: mutable_flag;\n pld_type: core_type;\n pld_loc: Location.t;\n pld_attributes: attributes; (* l : T [@id1] [@id2] *)\n }\n\n (* { ...; l: T; ... } (mutable=Immutable)\n { ...; mutable l: T; ... } (mutable=Mutable)\n\n Note: T can be a Ptyp_poly.\n *)\n\n and constructor_declaration (*IF_CURRENT = Parsetree.constructor_declaration *) =\n {\n pcd_name: string loc;\n pcd_args: constructor_arguments;\n pcd_res: core_type option;\n pcd_loc: Location.t;\n pcd_attributes: attributes; (* C of ... [@id1] [@id2] *)\n }\n\n and constructor_arguments (*IF_CURRENT = Parsetree.constructor_arguments *) =\n | Pcstr_tuple of core_type list\n | Pcstr_record of label_declaration list\n\n(*\n | C of T1 * ... * Tn (res = None, args = Pcstr_tuple [])\n | C: T0 (res = Some T0, args = [])\n | C: T1 * ... * Tn -> T0 (res = Some T0, args = Pcstr_tuple)\n | C of {...} (res = None, args = Pcstr_record)\n | C: {...} -> T0 (res = Some T0, args = Pcstr_record)\n | C of {...} as t (res = None, args = Pcstr_record)\n *)\n\n and type_extension (*IF_CURRENT = Parsetree.type_extension *) =\n {\n ptyext_path: Longident.t loc;\n ptyext_params: (core_type * variance) list;\n ptyext_constructors: extension_constructor list;\n ptyext_private: private_flag;\n ptyext_loc: Location.t;\n ptyext_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n(*\n type t += ...\n *)\n\n and extension_constructor (*IF_CURRENT = Parsetree.extension_constructor *) =\n {\n pext_name: string loc;\n pext_kind : extension_constructor_kind;\n pext_loc : Location.t;\n pext_attributes: attributes; (* C of ... [@id1] [@id2] *)\n }\n\n (* exception E *)\n and type_exception (*IF_CURRENT = Parsetree.type_exception *) =\n {\n ptyexn_constructor: extension_constructor;\n ptyexn_loc: Location.t;\n ptyexn_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and extension_constructor_kind (*IF_CURRENT = Parsetree.extension_constructor_kind *) =\n Pext_decl of constructor_arguments * core_type option\n (*\n | C of T1 * ... * Tn ([T1; ...; Tn], None)\n | C: T0 ([], Some T0)\n | C: T1 * ... * Tn -> T0 ([T1; ...; Tn], Some T0)\n *)\n | Pext_rebind of Longident.t loc\n (*\n | C = D\n *)\n\n (** {1 Class language} *)\n\n (* Type expressions for the class language *)\n\n and class_type (*IF_CURRENT = Parsetree.class_type *) =\n {\n pcty_desc: class_type_desc;\n pcty_loc: Location.t;\n pcty_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and class_type_desc (*IF_CURRENT = Parsetree.class_type_desc *) =\n | Pcty_constr of Longident.t loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcty_signature of class_signature\n (* object ... end *)\n | Pcty_arrow of arg_label * core_type * class_type\n (* T -> CT Simple\n ~l:T -> CT Labelled l\n ?l:T -> CT Optional l\n *)\n | Pcty_extension of extension\n (* [%id] *)\n | Pcty_open of open_description * class_type\n (* let open M in CT *)\n\n and class_signature (*IF_CURRENT = Parsetree.class_signature *) =\n {\n pcsig_self: core_type;\n pcsig_fields: class_type_field list;\n }\n (* object('selfpat) ... end\n object ... end (self = Ptyp_any)\n *)\n\n and class_type_field (*IF_CURRENT = Parsetree.class_type_field *) =\n {\n pctf_desc: class_type_field_desc;\n pctf_loc: Location.t;\n pctf_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and class_type_field_desc (*IF_CURRENT = Parsetree.class_type_field_desc *) =\n | Pctf_inherit of class_type\n (* inherit CT *)\n | Pctf_val of (label loc * mutable_flag * virtual_flag * core_type)\n (* val x: T *)\n | Pctf_method of (label loc * private_flag * virtual_flag * core_type)\n (* method x: T\n\n Note: T can be a Ptyp_poly.\n *)\n | Pctf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pctf_attribute of attribute\n (* [@@@id] *)\n | Pctf_extension of extension\n (* [%%id] *)\n\n and 'a class_infos (*IF_CURRENT = 'a Parsetree.class_infos *) =\n {\n pci_virt: virtual_flag;\n pci_params: (core_type * variance) list;\n pci_name: string loc;\n pci_expr: 'a;\n pci_loc: Location.t;\n pci_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n (* class c = ...\n class ['a1,...,'an] c = ...\n class virtual c = ...\n\n Also used for \"class type\" declaration.\n *)\n\n and class_description = class_type class_infos\n\n and class_type_declaration = class_type class_infos\n\n (* Value expressions for the class language *)\n\n and class_expr (*IF_CURRENT = Parsetree.class_expr *) =\n {\n pcl_desc: class_expr_desc;\n pcl_loc: Location.t;\n pcl_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and class_expr_desc (*IF_CURRENT = Parsetree.class_expr_desc *) =\n | Pcl_constr of Longident.t loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcl_structure of class_structure\n (* object ... end *)\n | Pcl_fun of arg_label * expression option * pattern * class_expr\n (* fun P -> CE (Simple, None)\n fun ~l:P -> CE (Labelled l, None)\n fun ?l:P -> CE (Optional l, None)\n fun ?l:(P = E0) -> CE (Optional l, Some E0)\n *)\n | Pcl_apply of class_expr * (arg_label * expression) list\n (* CE ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pcl_let of rec_flag * value_binding list * class_expr\n (* let P1 = E1 and ... and Pn = EN in CE (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in CE (flag = Recursive)\n *)\n | Pcl_constraint of class_expr * class_type\n (* (CE : CT) *)\n | Pcl_extension of extension\n (* [%id] *)\n | Pcl_open of open_description * class_expr\n (* let open M in CE *)\n\n\n and class_structure (*IF_CURRENT = Parsetree.class_structure *) =\n {\n pcstr_self: pattern;\n pcstr_fields: class_field list;\n }\n (* object(selfpat) ... end\n object ... end (self = Ppat_any)\n *)\n\n and class_field (*IF_CURRENT = Parsetree.class_field *) =\n {\n pcf_desc: class_field_desc;\n pcf_loc: Location.t;\n pcf_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and class_field_desc (*IF_CURRENT = Parsetree.class_field_desc *) =\n | Pcf_inherit of override_flag * class_expr * string loc option\n (* inherit CE\n inherit CE as x\n inherit! CE\n inherit! CE as x\n *)\n | Pcf_val of (label loc * mutable_flag * class_field_kind)\n (* val x = E\n val virtual x: T\n *)\n | Pcf_method of (label loc * private_flag * class_field_kind)\n (* method x = E (E can be a Pexp_poly)\n method virtual x: T (T can be a Ptyp_poly)\n *)\n | Pcf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pcf_initializer of expression\n (* initializer E *)\n | Pcf_attribute of attribute\n (* [@@@id] *)\n | Pcf_extension of extension\n (* [%%id] *)\n\n and class_field_kind (*IF_CURRENT = Parsetree.class_field_kind *) =\n | Cfk_virtual of core_type\n | Cfk_concrete of override_flag * expression\n\n and class_declaration = class_expr class_infos\n\n (** {1 Module language} *)\n\n (* Type expressions for the module language *)\n\n and module_type (*IF_CURRENT = Parsetree.module_type *) =\n {\n pmty_desc: module_type_desc;\n pmty_loc: Location.t;\n pmty_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and module_type_desc (*IF_CURRENT = Parsetree.module_type_desc *) =\n | Pmty_ident of Longident.t loc\n (* S *)\n | Pmty_signature of signature\n (* sig ... end *)\n | Pmty_functor of string loc * module_type option * module_type\n (* functor(X : MT1) -> MT2 *)\n | Pmty_with of module_type * with_constraint list\n (* MT with ... *)\n | Pmty_typeof of module_expr\n (* module type of ME *)\n | Pmty_extension of extension\n (* [%id] *)\n | Pmty_alias of Longident.t loc\n (* (module M) *)\n\n and signature = signature_item list\n\n and signature_item (*IF_CURRENT = Parsetree.signature_item *) =\n {\n psig_desc: signature_item_desc;\n psig_loc: Location.t;\n }\n\n and signature_item_desc (*IF_CURRENT = Parsetree.signature_item_desc *) =\n | Psig_value of value_description\n (*\n val x: T\n external x: T = \"s1\" ... \"sn\"\n *)\n | Psig_type of rec_flag * type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Psig_typesubst of type_declaration list\n (* type t1 := ... and ... and tn := ... *)\n | Psig_typext of type_extension\n (* type t1 += ... *)\n | Psig_exception of type_exception\n (* exception C of T *)\n | Psig_module of module_declaration\n (* module X = M\n module X : MT *)\n | Psig_modsubst of module_substitution\n (* module X := M *)\n | Psig_recmodule of module_declaration list\n (* module rec X1 : MT1 and ... and Xn : MTn *)\n | Psig_modtype of module_type_declaration\n (* module type S = MT\n module type S *)\n | Psig_open of open_description\n (* open X *)\n | Psig_include of include_description\n (* include MT *)\n | Psig_class of class_description list\n (* class c1 : ... and ... and cn : ... *)\n | Psig_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Psig_attribute of attribute\n (* [@@@id] *)\n | Psig_extension of extension * attributes\n (* [%%id] *)\n\n and module_declaration (*IF_CURRENT = Parsetree.module_declaration *) =\n {\n pmd_name: string loc;\n pmd_type: module_type;\n pmd_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pmd_loc: Location.t;\n }\n (* S : MT *)\n\n and module_substitution (*IF_CURRENT = Parsetree.module_substitution *) =\n {\n pms_name: string loc;\n pms_manifest: Longident.t loc;\n pms_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pms_loc: Location.t;\n }\n\n and module_type_declaration (*IF_CURRENT = Parsetree.module_type_declaration *) =\n {\n pmtd_name: string loc;\n pmtd_type: module_type option;\n pmtd_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pmtd_loc: Location.t;\n }\n (* S = MT\n S (abstract module type declaration, pmtd_type = None)\n *)\n\n and 'a open_infos (*IF_CURRENT = 'a Parsetree.open_infos *) =\n {\n popen_expr: 'a;\n popen_override: override_flag;\n popen_loc: Location.t;\n popen_attributes: attributes;\n }\n (* open! X - popen_override = Override (silences the 'used identifier\n shadowing' warning)\n open X - popen_override = Fresh\n *)\n\n and open_description = Longident.t loc open_infos\n (* open M.N\n open M(N).O *)\n\n and open_declaration = module_expr open_infos\n (* open M.N\n open M(N).O\n open struct ... end *)\n\n and 'a include_infos (*IF_CURRENT = 'a Parsetree.include_infos *) =\n {\n pincl_mod: 'a;\n pincl_loc: Location.t;\n pincl_attributes: attributes;\n }\n\n and include_description = module_type include_infos\n (* include MT *)\n\n and include_declaration = module_expr include_infos\n (* include ME *)\n\n and with_constraint (*IF_CURRENT = Parsetree.with_constraint *) =\n | Pwith_type of Longident.t loc * type_declaration\n (* with type X.t = ...\n\n Note: the last component of the longident must match\n the name of the type_declaration. *)\n | Pwith_module of Longident.t loc * Longident.t loc\n (* with module X.Y = Z *)\n | Pwith_typesubst of Longident.t loc * type_declaration\n (* with type X.t := ..., same format as [Pwith_type] *)\n | Pwith_modsubst of Longident.t loc * Longident.t loc\n (* with module X.Y := Z *)\n\n (* Value expressions for the module language *)\n\n and module_expr (*IF_CURRENT = Parsetree.module_expr *) =\n {\n pmod_desc: module_expr_desc;\n pmod_loc: Location.t;\n pmod_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and module_expr_desc (*IF_CURRENT = Parsetree.module_expr_desc *) =\n | Pmod_ident of Longident.t loc\n (* X *)\n | Pmod_structure of structure\n (* struct ... end *)\n | Pmod_functor of string loc * module_type option * module_expr\n (* functor(X : MT1) -> ME *)\n | Pmod_apply of module_expr * module_expr\n (* ME1(ME2) *)\n | Pmod_constraint of module_expr * module_type\n (* (ME : MT) *)\n | Pmod_unpack of expression\n (* (val E) *)\n | Pmod_extension of extension\n (* [%id] *)\n\n and structure = structure_item list\n\n and structure_item (*IF_CURRENT = Parsetree.structure_item *) =\n {\n pstr_desc: structure_item_desc;\n pstr_loc: Location.t;\n }\n\n and structure_item_desc (*IF_CURRENT = Parsetree.structure_item_desc *) =\n | Pstr_eval of expression * attributes\n (* E *)\n | Pstr_value of rec_flag * value_binding list\n (* let P1 = E1 and ... and Pn = EN (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN (flag = Recursive)\n *)\n | Pstr_primitive of value_description\n (* val x: T\n external x: T = \"s1\" ... \"sn\" *)\n | Pstr_type of rec_flag * type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Pstr_typext of type_extension\n (* type t1 += ... *)\n | Pstr_exception of type_exception\n (* exception C of T\n exception C = M.X *)\n | Pstr_module of module_binding\n (* module X = ME *)\n | Pstr_recmodule of module_binding list\n (* module rec X1 = ME1 and ... and Xn = MEn *)\n | Pstr_modtype of module_type_declaration\n (* module type S = MT *)\n | Pstr_open of open_declaration\n (* open X *)\n | Pstr_class of class_declaration list\n (* class c1 = ... and ... and cn = ... *)\n | Pstr_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Pstr_include of include_declaration\n (* include ME *)\n | Pstr_attribute of attribute\n (* [@@@id] *)\n | Pstr_extension of extension * attributes\n (* [%%id] *)\n\n and value_binding (*IF_CURRENT = Parsetree.value_binding *) =\n {\n pvb_pat: pattern;\n pvb_expr: expression;\n pvb_attributes: attributes;\n pvb_loc: Location.t;\n }\n\n and module_binding (*IF_CURRENT = Parsetree.module_binding *) =\n {\n pmb_name: string loc;\n pmb_expr: module_expr;\n pmb_attributes: attributes;\n pmb_loc: Location.t;\n }\n (* X = ME *)\n\n (** {1 Toplevel} *)\n\n (* Toplevel phrases *)\n\n type toplevel_phrase (*IF_CURRENT = Parsetree.toplevel_phrase *) =\n | Ptop_def of structure\n | Ptop_dir of toplevel_directive\n (* #use, #load ... *)\n\n and toplevel_directive (*IF_CURRENT = Parsetree.toplevel_directive *) =\n {\n pdir_name : string loc;\n pdir_arg : directive_argument option;\n pdir_loc : Location.t;\n }\n\n and directive_argument (*IF_CURRENT = Parsetree.directive_argument *) =\n {\n pdira_desc : directive_argument_desc;\n pdira_loc : Location.t;\n }\n\n and directive_argument_desc (*IF_CURRENT = Parsetree.directive_argument_desc *) =\n | Pdir_string of string\n | Pdir_int of string * char option\n | Pdir_ident of Longident.t\n | Pdir_bool of bool\n\nend\n\nmodule Config = struct\n let ast_impl_magic_number = \"Caml1999M026\"\n let ast_intf_magic_number = \"Caml1999N026\"\nend\n","(**************************************************************************)\n(* *)\n(* OCaml Migrate Parsetree *)\n(* *)\n(* Frédéric Bour, Facebook *)\n(* Jérémie Dimino and Leo White, Jane Street Europe *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* Alain Frisch, LexiFi *)\n(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 2018 Institut National de Recherche en Informatique et *)\n(* en Automatique (INRIA). *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* Ast ported on Thu Mar 21 09:50:42 GMT 2019\n OCaml was:\n commit 55c9ba466362f303eb4d5ed511f6fda142879137 (HEAD -> 4.08, origin/4.08)\n Author: Nicolás Ojeda Bär \n Date: Tue Mar 19 08:11:02 2019 +0100\n\n Merge pull request #8521 from nojb/fix_unix_tests_408\n\n Actually run all lib-unix tests [4.08]\n*)\n\nmodule Asttypes = struct\n\n type constant (*IF_CURRENT = Asttypes.constant *) =\n Const_int of int\n | Const_char of char\n | Const_string of string * string option\n | Const_float of string\n | Const_int32 of int32\n | Const_int64 of int64\n | Const_nativeint of nativeint\n\n type rec_flag (*IF_CURRENT = Asttypes.rec_flag *) = Nonrecursive | Recursive\n\n type direction_flag (*IF_CURRENT = Asttypes.direction_flag *) = Upto | Downto\n\n (* Order matters, used in polymorphic comparison *)\n type private_flag (*IF_CURRENT = Asttypes.private_flag *) = Private | Public\n\n type mutable_flag (*IF_CURRENT = Asttypes.mutable_flag *) = Immutable | Mutable\n\n type virtual_flag (*IF_CURRENT = Asttypes.virtual_flag *) = Virtual | Concrete\n\n type override_flag (*IF_CURRENT = Asttypes.override_flag *) = Override | Fresh\n\n type closed_flag (*IF_CURRENT = Asttypes.closed_flag *) = Closed | Open\n\n type label = string\n\n type arg_label (*IF_CURRENT = Asttypes.arg_label *) =\n Nolabel\n | Labelled of string (* label:T -> ... *)\n | Optional of string (* ?label:T -> ... *)\n\n type 'a loc = 'a Location.loc = {\n txt : 'a;\n loc : Location.t;\n }\n\n\n type variance (*IF_CURRENT = Asttypes.variance *) =\n | Covariant\n | Contravariant\n | Invariant\n\nend\n\nmodule Parsetree = struct\n\n open Asttypes\n\n type constant (*IF_CURRENT = Parsetree.constant *) =\n Pconst_integer of string * char option\n (* 3 3l 3L 3n\n\n Suffixes [g-z][G-Z] are accepted by the parser.\n Suffixes except 'l', 'L' and 'n' are rejected by the typechecker\n *)\n | Pconst_char of char\n (* 'c' *)\n | Pconst_string of string * string option\n (* \"constant\"\n {delim|other constant|delim}\n *)\n | Pconst_float of string * char option\n (* 3.4 2e5 1.4e-4\n\n Suffixes [g-z][G-Z] are accepted by the parser.\n Suffixes are rejected by the typechecker.\n *)\n\n (** {1 Extension points} *)\n\n type attribute (*IF_CURRENT = Parsetree.attribute *) = {\n attr_name : string loc;\n attr_payload : payload;\n attr_loc : Location.t;\n }\n (* [@id ARG]\n [@@id ARG]\n\n Metadata containers passed around within the AST.\n The compiler ignores unknown attributes.\n *)\n\n and extension = string loc * payload\n (* [%id ARG]\n [%%id ARG]\n\n Sub-language placeholder -- rejected by the typechecker.\n *)\n\n and attributes = attribute list\n\n and payload (*IF_CURRENT = Parsetree.payload *) =\n | PStr of structure\n | PSig of signature (* : SIG *)\n | PTyp of core_type (* : T *)\n | PPat of pattern * expression option (* ? P or ? P when E *)\n\n (** {1 Core language} *)\n\n (* Type expressions *)\n\n and core_type (*IF_CURRENT = Parsetree.core_type *) =\n {\n ptyp_desc: core_type_desc;\n ptyp_loc: Location.t;\n ptyp_loc_stack: Location.t list;\n ptyp_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and typ = core_type\n\n and core_type_desc (*IF_CURRENT = Parsetree.core_type_desc *) =\n | Ptyp_any\n (* _ *)\n | Ptyp_var of string\n (* 'a *)\n | Ptyp_arrow of arg_label * core_type * core_type\n (* T1 -> T2 Simple\n ~l:T1 -> T2 Labelled\n ?l:T1 -> T2 Optional\n *)\n | Ptyp_tuple of core_type list\n (* T1 * ... * Tn\n\n Invariant: n >= 2\n *)\n | Ptyp_constr of Longident.t loc * core_type list\n (* tconstr\n T tconstr\n (T1, ..., Tn) tconstr\n *)\n | Ptyp_object of object_field list * closed_flag\n (* < l1:T1; ...; ln:Tn > (flag = Closed)\n < l1:T1; ...; ln:Tn; .. > (flag = Open)\n *)\n | Ptyp_class of Longident.t loc * core_type list\n (* #tconstr\n T #tconstr\n (T1, ..., Tn) #tconstr\n *)\n | Ptyp_alias of core_type * string\n (* T as 'a *)\n | Ptyp_variant of row_field list * closed_flag * label list option\n (* [ `A|`B ] (flag = Closed; labels = None)\n [> `A|`B ] (flag = Open; labels = None)\n [< `A|`B ] (flag = Closed; labels = Some [])\n [< `A|`B > `X `Y ](flag = Closed; labels = Some [\"X\";\"Y\"])\n *)\n | Ptyp_poly of string loc list * core_type\n (* 'a1 ... 'an. T\n\n Can only appear in the following context:\n\n - As the core_type of a Ppat_constraint node corresponding\n to a constraint on a let-binding: let x : 'a1 ... 'an. T\n = e ...\n\n - Under Cfk_virtual for methods (not values).\n\n - As the core_type of a Pctf_method node.\n\n - As the core_type of a Pexp_poly node.\n\n - As the pld_type field of a label_declaration.\n\n - As a core_type of a Ptyp_object node.\n *)\n\n | Ptyp_package of package_type\n (* (module S) *)\n | Ptyp_extension of extension\n (* [%id] *)\n\n and package_type = Longident.t loc * (Longident.t loc * core_type) list\n (*\n (module S)\n (module S with type t1 = T1 and ... and tn = Tn)\n *)\n\n and row_field (*IF_CURRENT = Parsetree.row_field *) = {\n prf_desc : row_field_desc;\n prf_loc : Location.t;\n prf_attributes : attributes;\n }\n\n and row_field_desc (*IF_CURRENT = Parsetree.row_field_desc *) =\n | Rtag of label loc * bool * core_type list\n (* [`A] ( true, [] )\n [`A of T] ( false, [T] )\n [`A of T1 & .. & Tn] ( false, [T1;...Tn] )\n [`A of & T1 & .. & Tn] ( true, [T1;...Tn] )\n\n - The 'bool' field is true if the tag contains a\n constant (empty) constructor.\n - '&' occurs when several types are used for the same constructor\n (see 4.2 in the manual)\n *)\n | Rinherit of core_type\n (* [ T ] *)\n\n and object_field (*IF_CURRENT = Parsetree.object_field *) = {\n pof_desc : object_field_desc;\n pof_loc : Location.t;\n pof_attributes : attributes;\n }\n\n and object_field_desc (*IF_CURRENT = Parsetree.object_field_desc *) =\n | Otag of label loc * core_type\n | Oinherit of core_type\n\n (* Patterns *)\n\n and pattern (*IF_CURRENT = Parsetree.pattern *) =\n {\n ppat_desc: pattern_desc;\n ppat_loc: Location.t;\n ppat_loc_stack: Location.t list;\n ppat_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and pat = pattern\n\n and pattern_desc (*IF_CURRENT = Parsetree.pattern_desc *) =\n | Ppat_any\n (* _ *)\n | Ppat_var of string loc\n (* x *)\n | Ppat_alias of pattern * string loc\n (* P as 'a *)\n | Ppat_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Ppat_interval of constant * constant\n (* 'a'..'z'\n\n Other forms of interval are recognized by the parser\n but rejected by the type-checker. *)\n | Ppat_tuple of pattern list\n (* (P1, ..., Pn)\n\n Invariant: n >= 2\n *)\n | Ppat_construct of Longident.t loc * pattern option\n (* C None\n C P Some P\n C (P1, ..., Pn) Some (Ppat_tuple [P1; ...; Pn])\n *)\n | Ppat_variant of label * pattern option\n (* `A (None)\n `A P (Some P)\n *)\n | Ppat_record of (Longident.t loc * pattern) list * closed_flag\n (* { l1=P1; ...; ln=Pn } (flag = Closed)\n { l1=P1; ...; ln=Pn; _} (flag = Open)\n\n Invariant: n > 0\n *)\n | Ppat_array of pattern list\n (* [| P1; ...; Pn |] *)\n | Ppat_or of pattern * pattern\n (* P1 | P2 *)\n | Ppat_constraint of pattern * core_type\n (* (P : T) *)\n | Ppat_type of Longident.t loc\n (* #tconst *)\n | Ppat_lazy of pattern\n (* lazy P *)\n | Ppat_unpack of string loc\n (* (module P)\n Note: (module P : S) is represented as\n Ppat_constraint(Ppat_unpack, Ptyp_package)\n *)\n | Ppat_exception of pattern\n (* exception P *)\n | Ppat_extension of extension\n (* [%id] *)\n | Ppat_open of Longident.t loc * pattern\n (* M.(P) *)\n\n (* Value expressions *)\n\n and expression (*IF_CURRENT = Parsetree.expression *) =\n {\n pexp_desc: expression_desc;\n pexp_loc: Location.t;\n pexp_loc_stack: Location.t list;\n pexp_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and expr = expression\n\n and expression_desc (*IF_CURRENT = Parsetree.expression_desc *) =\n | Pexp_ident of Longident.t loc\n (* x\n M.x\n *)\n | Pexp_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Pexp_let of rec_flag * value_binding list * expression\n (* let P1 = E1 and ... and Pn = EN in E (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in E (flag = Recursive)\n *)\n | Pexp_function of cases\n (* function P1 -> E1 | ... | Pn -> En *)\n | Pexp_fun of arg_label * expression option * pattern * expression\n (* fun P -> E1 (Simple, None)\n fun ~l:P -> E1 (Labelled l, None)\n fun ?l:P -> E1 (Optional l, None)\n fun ?l:(P = E0) -> E1 (Optional l, Some E0)\n\n Notes:\n - If E0 is provided, only Optional is allowed.\n - \"fun P1 P2 .. Pn -> E1\" is represented as nested Pexp_fun.\n - \"let f P = E\" is represented using Pexp_fun.\n *)\n | Pexp_apply of expression * (arg_label * expression) list\n (* E0 ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pexp_match of expression * cases\n (* match E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_try of expression * cases\n (* try E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_tuple of expression list\n (* (E1, ..., En)\n\n Invariant: n >= 2\n *)\n | Pexp_construct of Longident.t loc * expression option\n (* C None\n C E Some E\n C (E1, ..., En) Some (Pexp_tuple[E1;...;En])\n *)\n | Pexp_variant of label * expression option\n (* `A (None)\n `A E (Some E)\n *)\n | Pexp_record of (Longident.t loc * expression) list * expression option\n (* { l1=P1; ...; ln=Pn } (None)\n { E0 with l1=P1; ...; ln=Pn } (Some E0)\n\n Invariant: n > 0\n *)\n | Pexp_field of expression * Longident.t loc\n (* E.l *)\n | Pexp_setfield of expression * Longident.t loc * expression\n (* E1.l <- E2 *)\n | Pexp_array of expression list\n (* [| E1; ...; En |] *)\n | Pexp_ifthenelse of expression * expression * expression option\n (* if E1 then E2 else E3 *)\n | Pexp_sequence of expression * expression\n (* E1; E2 *)\n | Pexp_while of expression * expression\n (* while E1 do E2 done *)\n | Pexp_for of\n pattern * expression * expression * direction_flag * expression\n (* for i = E1 to E2 do E3 done (flag = Upto)\n for i = E1 downto E2 do E3 done (flag = Downto)\n *)\n | Pexp_constraint of expression * core_type\n (* (E : T) *)\n | Pexp_coerce of expression * core_type option * core_type\n (* (E :> T) (None, T)\n (E : T0 :> T) (Some T0, T)\n *)\n | Pexp_send of expression * label loc\n (* E # m *)\n | Pexp_new of Longident.t loc\n (* new M.c *)\n | Pexp_setinstvar of label loc * expression\n (* x <- 2 *)\n | Pexp_override of (label loc * expression) list\n (* {< x1 = E1; ...; Xn = En >} *)\n | Pexp_letmodule of string loc * module_expr * expression\n (* let module M = ME in E *)\n | Pexp_letexception of extension_constructor * expression\n (* let exception C in E *)\n | Pexp_assert of expression\n (* assert E\n Note: \"assert false\" is treated in a special way by the\n type-checker. *)\n | Pexp_lazy of expression\n (* lazy E *)\n | Pexp_poly of expression * core_type option\n (* Used for method bodies.\n\n Can only be used as the expression under Cfk_concrete\n for methods (not values). *)\n | Pexp_object of class_structure\n (* object ... end *)\n | Pexp_newtype of string loc * expression\n (* fun (type t) -> E *)\n | Pexp_pack of module_expr\n (* (module ME)\n\n (module ME : S) is represented as\n Pexp_constraint(Pexp_pack, Ptyp_package S) *)\n | Pexp_open of open_declaration * expression\n (* M.(E)\n let open M in E\n let! open M in E *)\n | Pexp_letop of letop\n (* let* P = E in E\n let* P = E and* P = E in E *)\n | Pexp_extension of extension\n (* [%id] *)\n | Pexp_unreachable\n (* . *)\n\n and case (*IF_CURRENT = Parsetree.case *) = (* (P -> E) or (P when E0 -> E) *)\n {\n pc_lhs: pattern;\n pc_guard: expression option;\n pc_rhs: expression;\n }\n\n and cases = case list\n\n and letop (*IF_CURRENT = Parsetree.letop *) =\n {\n let_ : binding_op;\n ands : binding_op list;\n body : expression;\n }\n\n and binding_op (*IF_CURRENT = Parsetree.binding_op *) =\n {\n pbop_op : string loc;\n pbop_pat : pattern;\n pbop_exp : expression;\n pbop_loc : Location.t;\n }\n\n (* Value descriptions *)\n\n and value_description (*IF_CURRENT = Parsetree.value_description *) =\n {\n pval_name: string loc;\n pval_type: core_type;\n pval_prim: string list;\n pval_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pval_loc: Location.t;\n }\n\n(*\n val x: T (prim = [])\n external x: T = \"s1\" ... \"sn\" (prim = [\"s1\";...\"sn\"])\n *)\n\n (* Type declarations *)\n\n and type_declaration (*IF_CURRENT = Parsetree.type_declaration *) =\n {\n ptype_name: string loc;\n ptype_params: (core_type * variance) list;\n (* ('a1,...'an) t; None represents _*)\n ptype_cstrs: (core_type * core_type * Location.t) list;\n (* ... constraint T1=T1' ... constraint Tn=Tn' *)\n ptype_kind: type_kind;\n ptype_private: private_flag; (* = private ... *)\n ptype_manifest: core_type option; (* = T *)\n ptype_attributes: attributes; (* ... [@@id1] [@@id2] *)\n ptype_loc: Location.t;\n }\n\n(*\n type t (abstract, no manifest)\n type t = T0 (abstract, manifest=T0)\n type t = C of T | ... (variant, no manifest)\n type t = T0 = C of T | ... (variant, manifest=T0)\n type t = {l: T; ...} (record, no manifest)\n type t = T0 = {l : T; ...} (record, manifest=T0)\n type t = .. (open, no manifest)\n *)\n\n and type_kind (*IF_CURRENT = Parsetree.type_kind *) =\n | Ptype_abstract\n | Ptype_variant of constructor_declaration list\n | Ptype_record of label_declaration list\n (* Invariant: non-empty list *)\n | Ptype_open\n\n and label_declaration (*IF_CURRENT = Parsetree.label_declaration *) =\n {\n pld_name: string loc;\n pld_mutable: mutable_flag;\n pld_type: core_type;\n pld_loc: Location.t;\n pld_attributes: attributes; (* l : T [@id1] [@id2] *)\n }\n\n (* { ...; l: T; ... } (mutable=Immutable)\n { ...; mutable l: T; ... } (mutable=Mutable)\n\n Note: T can be a Ptyp_poly.\n *)\n\n and constructor_declaration (*IF_CURRENT = Parsetree.constructor_declaration *) =\n {\n pcd_name: string loc;\n pcd_args: constructor_arguments;\n pcd_res: core_type option;\n pcd_loc: Location.t;\n pcd_attributes: attributes; (* C of ... [@id1] [@id2] *)\n }\n\n and constructor_arguments (*IF_CURRENT = Parsetree.constructor_arguments *) =\n | Pcstr_tuple of core_type list\n | Pcstr_record of label_declaration list\n\n(*\n | C of T1 * ... * Tn (res = None, args = Pcstr_tuple [])\n | C: T0 (res = Some T0, args = [])\n | C: T1 * ... * Tn -> T0 (res = Some T0, args = Pcstr_tuple)\n | C of {...} (res = None, args = Pcstr_record)\n | C: {...} -> T0 (res = Some T0, args = Pcstr_record)\n | C of {...} as t (res = None, args = Pcstr_record)\n *)\n\n and type_extension (*IF_CURRENT = Parsetree.type_extension *) =\n {\n ptyext_path: Longident.t loc;\n ptyext_params: (core_type * variance) list;\n ptyext_constructors: extension_constructor list;\n ptyext_private: private_flag;\n ptyext_loc: Location.t;\n ptyext_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n(*\n type t += ...\n *)\n\n and extension_constructor (*IF_CURRENT = Parsetree.extension_constructor *) =\n {\n pext_name: string loc;\n pext_kind : extension_constructor_kind;\n pext_loc : Location.t;\n pext_attributes: attributes; (* C of ... [@id1] [@id2] *)\n }\n\n (* exception E *)\n and type_exception (*IF_CURRENT = Parsetree.type_exception *) =\n {\n ptyexn_constructor: extension_constructor;\n ptyexn_loc: Location.t;\n ptyexn_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and extension_constructor_kind (*IF_CURRENT = Parsetree.extension_constructor_kind *) =\n Pext_decl of constructor_arguments * core_type option\n (*\n | C of T1 * ... * Tn ([T1; ...; Tn], None)\n | C: T0 ([], Some T0)\n | C: T1 * ... * Tn -> T0 ([T1; ...; Tn], Some T0)\n *)\n | Pext_rebind of Longident.t loc\n (*\n | C = D\n *)\n\n (** {1 Class language} *)\n\n (* Type expressions for the class language *)\n\n and class_type (*IF_CURRENT = Parsetree.class_type *) =\n {\n pcty_desc: class_type_desc;\n pcty_loc: Location.t;\n pcty_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and class_type_desc (*IF_CURRENT = Parsetree.class_type_desc *) =\n | Pcty_constr of Longident.t loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcty_signature of class_signature\n (* object ... end *)\n | Pcty_arrow of arg_label * core_type * class_type\n (* T -> CT Simple\n ~l:T -> CT Labelled l\n ?l:T -> CT Optional l\n *)\n | Pcty_extension of extension\n (* [%id] *)\n | Pcty_open of open_description * class_type\n (* let open M in CT *)\n\n and class_signature (*IF_CURRENT = Parsetree.class_signature *) =\n {\n pcsig_self: core_type;\n pcsig_fields: class_type_field list;\n }\n (* object('selfpat) ... end\n object ... end (self = Ptyp_any)\n *)\n\n and class_type_field (*IF_CURRENT = Parsetree.class_type_field *) =\n {\n pctf_desc: class_type_field_desc;\n pctf_loc: Location.t;\n pctf_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and class_type_field_desc (*IF_CURRENT = Parsetree.class_type_field_desc *) =\n | Pctf_inherit of class_type\n (* inherit CT *)\n | Pctf_val of (label loc * mutable_flag * virtual_flag * core_type)\n (* val x: T *)\n | Pctf_method of (label loc * private_flag * virtual_flag * core_type)\n (* method x: T\n\n Note: T can be a Ptyp_poly.\n *)\n | Pctf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pctf_attribute of attribute\n (* [@@@id] *)\n | Pctf_extension of extension\n (* [%%id] *)\n\n and 'a class_infos (*IF_CURRENT = 'a Parsetree.class_infos *) =\n {\n pci_virt: virtual_flag;\n pci_params: (core_type * variance) list;\n pci_name: string loc;\n pci_expr: 'a;\n pci_loc: Location.t;\n pci_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n (* class c = ...\n class ['a1,...,'an] c = ...\n class virtual c = ...\n\n Also used for \"class type\" declaration.\n *)\n\n and class_description = class_type class_infos\n\n and class_type_declaration = class_type class_infos\n\n (* Value expressions for the class language *)\n\n and class_expr (*IF_CURRENT = Parsetree.class_expr *) =\n {\n pcl_desc: class_expr_desc;\n pcl_loc: Location.t;\n pcl_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and class_expr_desc (*IF_CURRENT = Parsetree.class_expr_desc *) =\n | Pcl_constr of Longident.t loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcl_structure of class_structure\n (* object ... end *)\n | Pcl_fun of arg_label * expression option * pattern * class_expr\n (* fun P -> CE (Simple, None)\n fun ~l:P -> CE (Labelled l, None)\n fun ?l:P -> CE (Optional l, None)\n fun ?l:(P = E0) -> CE (Optional l, Some E0)\n *)\n | Pcl_apply of class_expr * (arg_label * expression) list\n (* CE ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pcl_let of rec_flag * value_binding list * class_expr\n (* let P1 = E1 and ... and Pn = EN in CE (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in CE (flag = Recursive)\n *)\n | Pcl_constraint of class_expr * class_type\n (* (CE : CT) *)\n | Pcl_extension of extension\n (* [%id] *)\n | Pcl_open of open_description * class_expr\n (* let open M in CE *)\n\n\n and class_structure (*IF_CURRENT = Parsetree.class_structure *) =\n {\n pcstr_self: pattern;\n pcstr_fields: class_field list;\n }\n (* object(selfpat) ... end\n object ... end (self = Ppat_any)\n *)\n\n and class_field (*IF_CURRENT = Parsetree.class_field *) =\n {\n pcf_desc: class_field_desc;\n pcf_loc: Location.t;\n pcf_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and class_field_desc (*IF_CURRENT = Parsetree.class_field_desc *) =\n | Pcf_inherit of override_flag * class_expr * string loc option\n (* inherit CE\n inherit CE as x\n inherit! CE\n inherit! CE as x\n *)\n | Pcf_val of (label loc * mutable_flag * class_field_kind)\n (* val x = E\n val virtual x: T\n *)\n | Pcf_method of (label loc * private_flag * class_field_kind)\n (* method x = E (E can be a Pexp_poly)\n method virtual x: T (T can be a Ptyp_poly)\n *)\n | Pcf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pcf_initializer of expression\n (* initializer E *)\n | Pcf_attribute of attribute\n (* [@@@id] *)\n | Pcf_extension of extension\n (* [%%id] *)\n\n and class_field_kind (*IF_CURRENT = Parsetree.class_field_kind *) =\n | Cfk_virtual of core_type\n | Cfk_concrete of override_flag * expression\n\n and class_declaration = class_expr class_infos\n\n (** {1 Module language} *)\n\n (* Type expressions for the module language *)\n\n and module_type (*IF_CURRENT = Parsetree.module_type *) =\n {\n pmty_desc: module_type_desc;\n pmty_loc: Location.t;\n pmty_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and module_type_desc (*IF_CURRENT = Parsetree.module_type_desc *) =\n | Pmty_ident of Longident.t loc\n (* S *)\n | Pmty_signature of signature\n (* sig ... end *)\n | Pmty_functor of string loc * module_type option * module_type\n (* functor(X : MT1) -> MT2 *)\n | Pmty_with of module_type * with_constraint list\n (* MT with ... *)\n | Pmty_typeof of module_expr\n (* module type of ME *)\n | Pmty_extension of extension\n (* [%id] *)\n | Pmty_alias of Longident.t loc\n (* (module M) *)\n\n and signature = signature_item list\n\n and signature_item (*IF_CURRENT = Parsetree.signature_item *) =\n {\n psig_desc: signature_item_desc;\n psig_loc: Location.t;\n }\n\n and signature_item_desc (*IF_CURRENT = Parsetree.signature_item_desc *) =\n | Psig_value of value_description\n (*\n val x: T\n external x: T = \"s1\" ... \"sn\"\n *)\n | Psig_type of rec_flag * type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Psig_typesubst of type_declaration list\n (* type t1 := ... and ... and tn := ... *)\n | Psig_typext of type_extension\n (* type t1 += ... *)\n | Psig_exception of type_exception\n (* exception C of T *)\n | Psig_module of module_declaration\n (* module X = M\n module X : MT *)\n | Psig_modsubst of module_substitution\n (* module X := M *)\n | Psig_recmodule of module_declaration list\n (* module rec X1 : MT1 and ... and Xn : MTn *)\n | Psig_modtype of module_type_declaration\n (* module type S = MT\n module type S *)\n | Psig_open of open_description\n (* open X *)\n | Psig_include of include_description\n (* include MT *)\n | Psig_class of class_description list\n (* class c1 : ... and ... and cn : ... *)\n | Psig_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Psig_attribute of attribute\n (* [@@@id] *)\n | Psig_extension of extension * attributes\n (* [%%id] *)\n\n and module_declaration (*IF_CURRENT = Parsetree.module_declaration *) =\n {\n pmd_name: string loc;\n pmd_type: module_type;\n pmd_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pmd_loc: Location.t;\n }\n (* S : MT *)\n\n and module_substitution (*IF_CURRENT = Parsetree.module_substitution *) =\n {\n pms_name: string loc;\n pms_manifest: Longident.t loc;\n pms_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pms_loc: Location.t;\n }\n\n and module_type_declaration (*IF_CURRENT = Parsetree.module_type_declaration *) =\n {\n pmtd_name: string loc;\n pmtd_type: module_type option;\n pmtd_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pmtd_loc: Location.t;\n }\n (* S = MT\n S (abstract module type declaration, pmtd_type = None)\n *)\n\n and 'a open_infos (*IF_CURRENT = 'a Parsetree.open_infos *) =\n {\n popen_expr: 'a;\n popen_override: override_flag;\n popen_loc: Location.t;\n popen_attributes: attributes;\n }\n (* open! X - popen_override = Override (silences the 'used identifier\n shadowing' warning)\n open X - popen_override = Fresh\n *)\n\n and open_description = Longident.t loc open_infos\n (* open M.N\n open M(N).O *)\n\n and open_declaration = module_expr open_infos\n (* open M.N\n open M(N).O\n open struct ... end *)\n\n and 'a include_infos (*IF_CURRENT = 'a Parsetree.include_infos *) =\n {\n pincl_mod: 'a;\n pincl_loc: Location.t;\n pincl_attributes: attributes;\n }\n\n and include_description = module_type include_infos\n (* include MT *)\n\n and include_declaration = module_expr include_infos\n (* include ME *)\n\n and with_constraint (*IF_CURRENT = Parsetree.with_constraint *) =\n | Pwith_type of Longident.t loc * type_declaration\n (* with type X.t = ...\n\n Note: the last component of the longident must match\n the name of the type_declaration. *)\n | Pwith_module of Longident.t loc * Longident.t loc\n (* with module X.Y = Z *)\n | Pwith_typesubst of Longident.t loc * type_declaration\n (* with type X.t := ..., same format as [Pwith_type] *)\n | Pwith_modsubst of Longident.t loc * Longident.t loc\n (* with module X.Y := Z *)\n\n (* Value expressions for the module language *)\n\n and module_expr (*IF_CURRENT = Parsetree.module_expr *) =\n {\n pmod_desc: module_expr_desc;\n pmod_loc: Location.t;\n pmod_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and module_expr_desc (*IF_CURRENT = Parsetree.module_expr_desc *) =\n | Pmod_ident of Longident.t loc\n (* X *)\n | Pmod_structure of structure\n (* struct ... end *)\n | Pmod_functor of string loc * module_type option * module_expr\n (* functor(X : MT1) -> ME *)\n | Pmod_apply of module_expr * module_expr\n (* ME1(ME2) *)\n | Pmod_constraint of module_expr * module_type\n (* (ME : MT) *)\n | Pmod_unpack of expression\n (* (val E) *)\n | Pmod_extension of extension\n (* [%id] *)\n\n and structure = structure_item list\n\n and structure_item (*IF_CURRENT = Parsetree.structure_item *) =\n {\n pstr_desc: structure_item_desc;\n pstr_loc: Location.t;\n }\n\n and structure_item_desc (*IF_CURRENT = Parsetree.structure_item_desc *) =\n | Pstr_eval of expression * attributes\n (* E *)\n | Pstr_value of rec_flag * value_binding list\n (* let P1 = E1 and ... and Pn = EN (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN (flag = Recursive)\n *)\n | Pstr_primitive of value_description\n (* val x: T\n external x: T = \"s1\" ... \"sn\" *)\n | Pstr_type of rec_flag * type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Pstr_typext of type_extension\n (* type t1 += ... *)\n | Pstr_exception of type_exception\n (* exception C of T\n exception C = M.X *)\n | Pstr_module of module_binding\n (* module X = ME *)\n | Pstr_recmodule of module_binding list\n (* module rec X1 = ME1 and ... and Xn = MEn *)\n | Pstr_modtype of module_type_declaration\n (* module type S = MT *)\n | Pstr_open of open_declaration\n (* open X *)\n | Pstr_class of class_declaration list\n (* class c1 = ... and ... and cn = ... *)\n | Pstr_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Pstr_include of include_declaration\n (* include ME *)\n | Pstr_attribute of attribute\n (* [@@@id] *)\n | Pstr_extension of extension * attributes\n (* [%%id] *)\n\n and value_binding (*IF_CURRENT = Parsetree.value_binding *) =\n {\n pvb_pat: pattern;\n pvb_expr: expression;\n pvb_attributes: attributes;\n pvb_loc: Location.t;\n }\n\n and module_binding (*IF_CURRENT = Parsetree.module_binding *) =\n {\n pmb_name: string loc;\n pmb_expr: module_expr;\n pmb_attributes: attributes;\n pmb_loc: Location.t;\n }\n (* X = ME *)\n\n (** {1 Toplevel} *)\n\n (* Toplevel phrases *)\n\n type toplevel_phrase (*IF_CURRENT = Parsetree.toplevel_phrase *) =\n | Ptop_def of structure\n | Ptop_dir of toplevel_directive\n (* #use, #load ... *)\n\n and toplevel_directive (*IF_CURRENT = Parsetree.toplevel_directive *) =\n {\n pdir_name : string loc;\n pdir_arg : directive_argument option;\n pdir_loc : Location.t;\n }\n\n and directive_argument (*IF_CURRENT = Parsetree.directive_argument *) =\n {\n pdira_desc : directive_argument_desc;\n pdira_loc : Location.t;\n }\n\n and directive_argument_desc (*IF_CURRENT = Parsetree.directive_argument_desc *) =\n | Pdir_string of string\n | Pdir_int of string * char option\n | Pdir_ident of Longident.t\n | Pdir_bool of bool\n\nend\n\nmodule Config = struct\n let ast_impl_magic_number = \"Caml1999M025\"\n let ast_intf_magic_number = \"Caml1999N025\"\nend\n","(**************************************************************************)\n(* *)\n(* OCaml Migrate Parsetree *)\n(* *)\n(* Frédéric Bour, Facebook *)\n(* Jérémie Dimino and Leo White, Jane Street Europe *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* Alain Frisch, LexiFi *)\n(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 2018 Institut National de Recherche en Informatique et *)\n(* en Automatique (INRIA). *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* Ast ported on Wed Apr 18 10:33:29 BST 2018\n OCaml trunk was:\n commit c0bd6a27e138911560f43dc75d5fde2ade4d6cfe (HEAD, tag: 4.07.0+beta2)\n Author: Damien Doligez \n Date: Tue Apr 10 14:50:48 2018 +0200\n\n change VERSION for 4.07.0+beta2\n*)\n\nmodule Asttypes = struct\n (** Auxiliary AST types used by parsetree and typedtree. *)\n\n type constant (*IF_CURRENT = Asttypes.constant *) =\n Const_int of int\n | Const_char of char\n | Const_string of string * string option\n | Const_float of string\n | Const_int32 of int32\n | Const_int64 of int64\n | Const_nativeint of nativeint\n\n type rec_flag (*IF_CURRENT = Asttypes.rec_flag *) = Nonrecursive | Recursive\n\n type direction_flag (*IF_CURRENT = Asttypes.direction_flag *) = Upto | Downto\n\n (* Order matters, used in polymorphic comparison *)\n type private_flag (*IF_CURRENT = Asttypes.private_flag *) = Private | Public\n\n type mutable_flag (*IF_CURRENT = Asttypes.mutable_flag *) = Immutable | Mutable\n\n type virtual_flag (*IF_CURRENT = Asttypes.virtual_flag *) = Virtual | Concrete\n\n type override_flag (*IF_CURRENT = Asttypes.override_flag *) = Override | Fresh\n\n type closed_flag (*IF_CURRENT = Asttypes.closed_flag *) = Closed | Open\n\n type label = string\n\n type arg_label (*IF_CURRENT = Asttypes.arg_label *) =\n Nolabel\n | Labelled of string (* label:T -> ... *)\n | Optional of string (* ?label:T -> ... *)\n\n type 'a loc = 'a Location.loc = {\n txt : 'a;\n loc : Location.t;\n }\n\n\n type variance (*IF_CURRENT = Asttypes.variance *) =\n | Covariant\n | Contravariant\n | Invariant\nend\n\nmodule Parsetree = struct\n (** Abstract syntax tree produced by parsing *)\n\n open Asttypes\n\n type constant (*IF_CURRENT = Parsetree.constant *) =\n Pconst_integer of string * char option\n (* 3 3l 3L 3n\n\n Suffixes [g-z][G-Z] are accepted by the parser.\n Suffixes except 'l', 'L' and 'n' are rejected by the typechecker\n *)\n | Pconst_char of char\n (* 'c' *)\n | Pconst_string of string * string option\n (* \"constant\"\n {delim|other constant|delim}\n *)\n | Pconst_float of string * char option\n (* 3.4 2e5 1.4e-4\n\n Suffixes [g-z][G-Z] are accepted by the parser.\n Suffixes are rejected by the typechecker.\n *)\n\n (** {1 Extension points} *)\n\n type attribute = string loc * payload\n (* [@id ARG]\n [@@id ARG]\n\n Metadata containers passed around within the AST.\n The compiler ignores unknown attributes.\n *)\n\n and extension = string loc * payload\n (* [%id ARG]\n [%%id ARG]\n\n Sub-language placeholder -- rejected by the typechecker.\n *)\n\n and attributes = attribute list\n\n and payload (*IF_CURRENT = Parsetree.payload *) =\n | PStr of structure\n | PSig of signature (* : SIG *)\n | PTyp of core_type (* : T *)\n | PPat of pattern * expression option (* ? P or ? P when E *)\n\n (** {1 Core language} *)\n\n (* Type expressions *)\n\n and core_type (*IF_CURRENT = Parsetree.core_type *) =\n {\n ptyp_desc: core_type_desc;\n ptyp_loc: Location.t;\n ptyp_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and core_type_desc (*IF_CURRENT = Parsetree.core_type_desc *) =\n | Ptyp_any\n (* _ *)\n | Ptyp_var of string\n (* 'a *)\n | Ptyp_arrow of arg_label * core_type * core_type\n (* T1 -> T2 Simple\n ~l:T1 -> T2 Labelled\n ?l:T1 -> T2 Optional\n *)\n | Ptyp_tuple of core_type list\n (* T1 * ... * Tn\n\n Invariant: n >= 2\n *)\n | Ptyp_constr of Longident.t loc * core_type list\n (* tconstr\n T tconstr\n (T1, ..., Tn) tconstr\n *)\n | Ptyp_object of object_field list * closed_flag\n (* < l1:T1; ...; ln:Tn > (flag = Closed)\n < l1:T1; ...; ln:Tn; .. > (flag = Open)\n *)\n | Ptyp_class of Longident.t loc * core_type list\n (* #tconstr\n T #tconstr\n (T1, ..., Tn) #tconstr\n *)\n | Ptyp_alias of core_type * string\n (* T as 'a *)\n | Ptyp_variant of row_field list * closed_flag * label list option\n (* [ `A|`B ] (flag = Closed; labels = None)\n [> `A|`B ] (flag = Open; labels = None)\n [< `A|`B ] (flag = Closed; labels = Some [])\n [< `A|`B > `X `Y ](flag = Closed; labels = Some [\"X\";\"Y\"])\n *)\n | Ptyp_poly of string loc list * core_type\n (* 'a1 ... 'an. T\n\n Can only appear in the following context:\n\n - As the core_type of a Ppat_constraint node corresponding\n to a constraint on a let-binding: let x : 'a1 ... 'an. T\n = e ...\n\n - Under Cfk_virtual for methods (not values).\n\n - As the core_type of a Pctf_method node.\n\n - As the core_type of a Pexp_poly node.\n\n - As the pld_type field of a label_declaration.\n\n - As a core_type of a Ptyp_object node.\n *)\n\n | Ptyp_package of package_type\n (* (module S) *)\n | Ptyp_extension of extension\n (* [%id] *)\n\n and package_type = Longident.t loc * (Longident.t loc * core_type) list\n (*\n (module S)\n (module S with type t1 = T1 and ... and tn = Tn)\n *)\n\n and row_field (*IF_CURRENT = Parsetree.row_field *) =\n | Rtag of label loc * attributes * bool * core_type list\n (* [`A] ( true, [] )\n [`A of T] ( false, [T] )\n [`A of T1 & .. & Tn] ( false, [T1;...Tn] )\n [`A of & T1 & .. & Tn] ( true, [T1;...Tn] )\n\n - The 2nd field is true if the tag contains a\n constant (empty) constructor.\n - '&' occurs when several types are used for the same constructor\n (see 4.2 in the manual)\n\n - TODO: switch to a record representation, and keep location\n *)\n | Rinherit of core_type\n (* [ T ] *)\n\n and object_field (*IF_CURRENT = Parsetree.object_field *) =\n | Otag of label loc * attributes * core_type\n | Oinherit of core_type\n\n (* Patterns *)\n\n and pattern (*IF_CURRENT = Parsetree.pattern *) =\n {\n ppat_desc: pattern_desc;\n ppat_loc: Location.t;\n ppat_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and pattern_desc (*IF_CURRENT = Parsetree.pattern_desc *) =\n | Ppat_any\n (* _ *)\n | Ppat_var of string loc\n (* x *)\n | Ppat_alias of pattern * string loc\n (* P as 'a *)\n | Ppat_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Ppat_interval of constant * constant\n (* 'a'..'z'\n\n Other forms of interval are recognized by the parser\n but rejected by the type-checker. *)\n | Ppat_tuple of pattern list\n (* (P1, ..., Pn)\n\n Invariant: n >= 2\n *)\n | Ppat_construct of Longident.t loc * pattern option\n (* C None\n C P Some P\n C (P1, ..., Pn) Some (Ppat_tuple [P1; ...; Pn])\n *)\n | Ppat_variant of label * pattern option\n (* `A (None)\n `A P (Some P)\n *)\n | Ppat_record of (Longident.t loc * pattern) list * closed_flag\n (* { l1=P1; ...; ln=Pn } (flag = Closed)\n { l1=P1; ...; ln=Pn; _} (flag = Open)\n\n Invariant: n > 0\n *)\n | Ppat_array of pattern list\n (* [| P1; ...; Pn |] *)\n | Ppat_or of pattern * pattern\n (* P1 | P2 *)\n | Ppat_constraint of pattern * core_type\n (* (P : T) *)\n | Ppat_type of Longident.t loc\n (* #tconst *)\n | Ppat_lazy of pattern\n (* lazy P *)\n | Ppat_unpack of string loc\n (* (module P)\n Note: (module P : S) is represented as\n Ppat_constraint(Ppat_unpack, Ptyp_package)\n *)\n | Ppat_exception of pattern\n (* exception P *)\n | Ppat_extension of extension\n (* [%id] *)\n | Ppat_open of Longident.t loc * pattern\n (* M.(P) *)\n\n (* Value expressions *)\n\n and expression (*IF_CURRENT = Parsetree.expression *) =\n {\n pexp_desc: expression_desc;\n pexp_loc: Location.t;\n pexp_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and expression_desc (*IF_CURRENT = Parsetree.expression_desc *) =\n | Pexp_ident of Longident.t loc\n (* x\n M.x\n *)\n | Pexp_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Pexp_let of rec_flag * value_binding list * expression\n (* let P1 = E1 and ... and Pn = EN in E (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in E (flag = Recursive)\n *)\n | Pexp_function of case list\n (* function P1 -> E1 | ... | Pn -> En *)\n | Pexp_fun of arg_label * expression option * pattern * expression\n (* fun P -> E1 (Simple, None)\n fun ~l:P -> E1 (Labelled l, None)\n fun ?l:P -> E1 (Optional l, None)\n fun ?l:(P = E0) -> E1 (Optional l, Some E0)\n\n Notes:\n - If E0 is provided, only Optional is allowed.\n - \"fun P1 P2 .. Pn -> E1\" is represented as nested Pexp_fun.\n - \"let f P = E\" is represented using Pexp_fun.\n *)\n | Pexp_apply of expression * (arg_label * expression) list\n (* E0 ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pexp_match of expression * case list\n (* match E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_try of expression * case list\n (* try E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_tuple of expression list\n (* (E1, ..., En)\n\n Invariant: n >= 2\n *)\n | Pexp_construct of Longident.t loc * expression option\n (* C None\n C E Some E\n C (E1, ..., En) Some (Pexp_tuple[E1;...;En])\n *)\n | Pexp_variant of label * expression option\n (* `A (None)\n `A E (Some E)\n *)\n | Pexp_record of (Longident.t loc * expression) list * expression option\n (* { l1=P1; ...; ln=Pn } (None)\n { E0 with l1=P1; ...; ln=Pn } (Some E0)\n\n Invariant: n > 0\n *)\n | Pexp_field of expression * Longident.t loc\n (* E.l *)\n | Pexp_setfield of expression * Longident.t loc * expression\n (* E1.l <- E2 *)\n | Pexp_array of expression list\n (* [| E1; ...; En |] *)\n | Pexp_ifthenelse of expression * expression * expression option\n (* if E1 then E2 else E3 *)\n | Pexp_sequence of expression * expression\n (* E1; E2 *)\n | Pexp_while of expression * expression\n (* while E1 do E2 done *)\n | Pexp_for of\n pattern * expression * expression * direction_flag * expression\n (* for i = E1 to E2 do E3 done (flag = Upto)\n for i = E1 downto E2 do E3 done (flag = Downto)\n *)\n | Pexp_constraint of expression * core_type\n (* (E : T) *)\n | Pexp_coerce of expression * core_type option * core_type\n (* (E :> T) (None, T)\n (E : T0 :> T) (Some T0, T)\n *)\n | Pexp_send of expression * label loc\n (* E # m *)\n | Pexp_new of Longident.t loc\n (* new M.c *)\n | Pexp_setinstvar of label loc * expression\n (* x <- 2 *)\n | Pexp_override of (label loc * expression) list\n (* {< x1 = E1; ...; Xn = En >} *)\n | Pexp_letmodule of string loc * module_expr * expression\n (* let module M = ME in E *)\n | Pexp_letexception of extension_constructor * expression\n (* let exception C in E *)\n | Pexp_assert of expression\n (* assert E\n Note: \"assert false\" is treated in a special way by the\n type-checker. *)\n | Pexp_lazy of expression\n (* lazy E *)\n | Pexp_poly of expression * core_type option\n (* Used for method bodies.\n\n Can only be used as the expression under Cfk_concrete\n for methods (not values). *)\n | Pexp_object of class_structure\n (* object ... end *)\n | Pexp_newtype of string loc * expression\n (* fun (type t) -> E *)\n | Pexp_pack of module_expr\n (* (module ME)\n\n (module ME : S) is represented as\n Pexp_constraint(Pexp_pack, Ptyp_package S) *)\n | Pexp_open of override_flag * Longident.t loc * expression\n (* M.(E)\n let open M in E\n let! open M in E *)\n | Pexp_extension of extension\n (* [%id] *)\n | Pexp_unreachable\n (* . *)\n\n and case (*IF_CURRENT = Parsetree.case *) = (* (P -> E) or (P when E0 -> E) *)\n {\n pc_lhs: pattern;\n pc_guard: expression option;\n pc_rhs: expression;\n }\n\n (* Value descriptions *)\n\n and value_description (*IF_CURRENT = Parsetree.value_description *) =\n {\n pval_name: string loc;\n pval_type: core_type;\n pval_prim: string list;\n pval_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pval_loc: Location.t;\n }\n\n (*\n val x: T (prim = [])\n external x: T = \"s1\" ... \"sn\" (prim = [\"s1\";...\"sn\"])\n *)\n\n (* Type declarations *)\n\n and type_declaration (*IF_CURRENT = Parsetree.type_declaration *) =\n {\n ptype_name: string loc;\n ptype_params: (core_type * variance) list;\n (* ('a1,...'an) t; None represents _*)\n ptype_cstrs: (core_type * core_type * Location.t) list;\n (* ... constraint T1=T1' ... constraint Tn=Tn' *)\n ptype_kind: type_kind;\n ptype_private: private_flag; (* = private ... *)\n ptype_manifest: core_type option; (* = T *)\n ptype_attributes: attributes; (* ... [@@id1] [@@id2] *)\n ptype_loc: Location.t;\n }\n\n (*\n type t (abstract, no manifest)\n type t = T0 (abstract, manifest=T0)\n type t = C of T | ... (variant, no manifest)\n type t = T0 = C of T | ... (variant, manifest=T0)\n type t = {l: T; ...} (record, no manifest)\n type t = T0 = {l : T; ...} (record, manifest=T0)\n type t = .. (open, no manifest)\n *)\n\n and type_kind (*IF_CURRENT = Parsetree.type_kind *) =\n | Ptype_abstract\n | Ptype_variant of constructor_declaration list\n | Ptype_record of label_declaration list\n (* Invariant: non-empty list *)\n | Ptype_open\n\n and label_declaration (*IF_CURRENT = Parsetree.label_declaration *) =\n {\n pld_name: string loc;\n pld_mutable: mutable_flag;\n pld_type: core_type;\n pld_loc: Location.t;\n pld_attributes: attributes; (* l : T [@id1] [@id2] *)\n }\n\n (* { ...; l: T; ... } (mutable=Immutable)\n { ...; mutable l: T; ... } (mutable=Mutable)\n\n Note: T can be a Ptyp_poly.\n *)\n\n and constructor_declaration (*IF_CURRENT = Parsetree.constructor_declaration *) =\n {\n pcd_name: string loc;\n pcd_args: constructor_arguments;\n pcd_res: core_type option;\n pcd_loc: Location.t;\n pcd_attributes: attributes; (* C of ... [@id1] [@id2] *)\n }\n\n and constructor_arguments (*IF_CURRENT = Parsetree.constructor_arguments *) =\n | Pcstr_tuple of core_type list\n | Pcstr_record of label_declaration list\n\n (*\n | C of T1 * ... * Tn (res = None, args = Pcstr_tuple [])\n | C: T0 (res = Some T0, args = [])\n | C: T1 * ... * Tn -> T0 (res = Some T0, args = Pcstr_tuple)\n | C of {...} (res = None, args = Pcstr_record)\n | C: {...} -> T0 (res = Some T0, args = Pcstr_record)\n | C of {...} as t (res = None, args = Pcstr_record)\n *)\n\n and type_extension (*IF_CURRENT = Parsetree.type_extension *) =\n {\n ptyext_path: Longident.t loc;\n ptyext_params: (core_type * variance) list;\n ptyext_constructors: extension_constructor list;\n ptyext_private: private_flag;\n ptyext_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n (*\n type t += ...\n *)\n\n and extension_constructor (*IF_CURRENT = Parsetree.extension_constructor *) =\n {\n pext_name: string loc;\n pext_kind : extension_constructor_kind;\n pext_loc : Location.t;\n pext_attributes: attributes; (* C of ... [@id1] [@id2] *)\n }\n\n and extension_constructor_kind (*IF_CURRENT = Parsetree.extension_constructor_kind *) =\n Pext_decl of constructor_arguments * core_type option\n (*\n | C of T1 * ... * Tn ([T1; ...; Tn], None)\n | C: T0 ([], Some T0)\n | C: T1 * ... * Tn -> T0 ([T1; ...; Tn], Some T0)\n *)\n | Pext_rebind of Longident.t loc\n (*\n | C = D\n *)\n\n (** {1 Class language} *)\n\n (* Type expressions for the class language *)\n\n and class_type (*IF_CURRENT = Parsetree.class_type *) =\n {\n pcty_desc: class_type_desc;\n pcty_loc: Location.t;\n pcty_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and class_type_desc (*IF_CURRENT = Parsetree.class_type_desc *) =\n | Pcty_constr of Longident.t loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcty_signature of class_signature\n (* object ... end *)\n | Pcty_arrow of arg_label * core_type * class_type\n (* T -> CT Simple\n ~l:T -> CT Labelled l\n ?l:T -> CT Optional l\n *)\n | Pcty_extension of extension\n (* [%id] *)\n | Pcty_open of override_flag * Longident.t loc * class_type\n (* let open M in CT *)\n\n and class_signature (*IF_CURRENT = Parsetree.class_signature *) =\n {\n pcsig_self: core_type;\n pcsig_fields: class_type_field list;\n }\n (* object('selfpat) ... end\n object ... end (self = Ptyp_any)\n *)\n\n and class_type_field (*IF_CURRENT = Parsetree.class_type_field *) =\n {\n pctf_desc: class_type_field_desc;\n pctf_loc: Location.t;\n pctf_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and class_type_field_desc (*IF_CURRENT = Parsetree.class_type_field_desc *) =\n | Pctf_inherit of class_type\n (* inherit CT *)\n | Pctf_val of (label loc * mutable_flag * virtual_flag * core_type)\n (* val x: T *)\n | Pctf_method of (label loc * private_flag * virtual_flag * core_type)\n (* method x: T\n\n Note: T can be a Ptyp_poly.\n *)\n | Pctf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pctf_attribute of attribute\n (* [@@@id] *)\n | Pctf_extension of extension\n (* [%%id] *)\n\n and 'a class_infos (*IF_CURRENT = 'a Parsetree.class_infos *) =\n {\n pci_virt: virtual_flag;\n pci_params: (core_type * variance) list;\n pci_name: string loc;\n pci_expr: 'a;\n pci_loc: Location.t;\n pci_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n (* class c = ...\n class ['a1,...,'an] c = ...\n class virtual c = ...\n\n Also used for \"class type\" declaration.\n *)\n\n and class_description = class_type class_infos\n\n and class_type_declaration = class_type class_infos\n\n (* Value expressions for the class language *)\n\n and class_expr (*IF_CURRENT = Parsetree.class_expr *) =\n {\n pcl_desc: class_expr_desc;\n pcl_loc: Location.t;\n pcl_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and class_expr_desc (*IF_CURRENT = Parsetree.class_expr_desc *) =\n | Pcl_constr of Longident.t loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcl_structure of class_structure\n (* object ... end *)\n | Pcl_fun of arg_label * expression option * pattern * class_expr\n (* fun P -> CE (Simple, None)\n fun ~l:P -> CE (Labelled l, None)\n fun ?l:P -> CE (Optional l, None)\n fun ?l:(P = E0) -> CE (Optional l, Some E0)\n *)\n | Pcl_apply of class_expr * (arg_label * expression) list\n (* CE ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pcl_let of rec_flag * value_binding list * class_expr\n (* let P1 = E1 and ... and Pn = EN in CE (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in CE (flag = Recursive)\n *)\n | Pcl_constraint of class_expr * class_type\n (* (CE : CT) *)\n | Pcl_extension of extension\n (* [%id] *)\n | Pcl_open of override_flag * Longident.t loc * class_expr\n (* let open M in CE *)\n\n\n and class_structure (*IF_CURRENT = Parsetree.class_structure *) =\n {\n pcstr_self: pattern;\n pcstr_fields: class_field list;\n }\n (* object(selfpat) ... end\n object ... end (self = Ppat_any)\n *)\n\n and class_field (*IF_CURRENT = Parsetree.class_field *) =\n {\n pcf_desc: class_field_desc;\n pcf_loc: Location.t;\n pcf_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and class_field_desc (*IF_CURRENT = Parsetree.class_field_desc *) =\n | Pcf_inherit of override_flag * class_expr * string loc option\n (* inherit CE\n inherit CE as x\n inherit! CE\n inherit! CE as x\n *)\n | Pcf_val of (label loc * mutable_flag * class_field_kind)\n (* val x = E\n val virtual x: T\n *)\n | Pcf_method of (label loc * private_flag * class_field_kind)\n (* method x = E (E can be a Pexp_poly)\n method virtual x: T (T can be a Ptyp_poly)\n *)\n | Pcf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pcf_initializer of expression\n (* initializer E *)\n | Pcf_attribute of attribute\n (* [@@@id] *)\n | Pcf_extension of extension\n (* [%%id] *)\n\n and class_field_kind (*IF_CURRENT = Parsetree.class_field_kind *) =\n | Cfk_virtual of core_type\n | Cfk_concrete of override_flag * expression\n\n and class_declaration = class_expr class_infos\n\n (** {1 Module language} *)\n\n (* Type expressions for the module language *)\n\n and module_type (*IF_CURRENT = Parsetree.module_type *) =\n {\n pmty_desc: module_type_desc;\n pmty_loc: Location.t;\n pmty_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and module_type_desc (*IF_CURRENT = Parsetree.module_type_desc *) =\n | Pmty_ident of Longident.t loc\n (* S *)\n | Pmty_signature of signature\n (* sig ... end *)\n | Pmty_functor of string loc * module_type option * module_type\n (* functor(X : MT1) -> MT2 *)\n | Pmty_with of module_type * with_constraint list\n (* MT with ... *)\n | Pmty_typeof of module_expr\n (* module type of ME *)\n | Pmty_extension of extension\n (* [%id] *)\n | Pmty_alias of Longident.t loc\n (* (module M) *)\n\n and signature = signature_item list\n\n and signature_item (*IF_CURRENT = Parsetree.signature_item *) =\n {\n psig_desc: signature_item_desc;\n psig_loc: Location.t;\n }\n\n and signature_item_desc (*IF_CURRENT = Parsetree.signature_item_desc *) =\n | Psig_value of value_description\n (*\n val x: T\n external x: T = \"s1\" ... \"sn\"\n *)\n | Psig_type of rec_flag * type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Psig_typext of type_extension\n (* type t1 += ... *)\n | Psig_exception of extension_constructor\n (* exception C of T *)\n | Psig_module of module_declaration\n (* module X : MT *)\n | Psig_recmodule of module_declaration list\n (* module rec X1 : MT1 and ... and Xn : MTn *)\n | Psig_modtype of module_type_declaration\n (* module type S = MT\n module type S *)\n | Psig_open of open_description\n (* open X *)\n | Psig_include of include_description\n (* include MT *)\n | Psig_class of class_description list\n (* class c1 : ... and ... and cn : ... *)\n | Psig_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Psig_attribute of attribute\n (* [@@@id] *)\n | Psig_extension of extension * attributes\n (* [%%id] *)\n\n and module_declaration (*IF_CURRENT = Parsetree.module_declaration *) =\n {\n pmd_name: string loc;\n pmd_type: module_type;\n pmd_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pmd_loc: Location.t;\n }\n (* S : MT *)\n\n and module_type_declaration (*IF_CURRENT = Parsetree.module_type_declaration *) =\n {\n pmtd_name: string loc;\n pmtd_type: module_type option;\n pmtd_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pmtd_loc: Location.t;\n }\n (* S = MT\n S (abstract module type declaration, pmtd_type = None)\n *)\n\n and open_description (*IF_CURRENT = Parsetree.open_description *) =\n {\n popen_lid: Longident.t loc;\n popen_override: override_flag;\n popen_loc: Location.t;\n popen_attributes: attributes;\n }\n (* open! X - popen_override = Override (silences the 'used identifier\n shadowing' warning)\n open X - popen_override = Fresh\n *)\n\n and 'a include_infos (*IF_CURRENT = 'a Parsetree.include_infos *) =\n {\n pincl_mod: 'a;\n pincl_loc: Location.t;\n pincl_attributes: attributes;\n }\n\n and include_description = module_type include_infos\n (* include MT *)\n\n and include_declaration = module_expr include_infos\n (* include ME *)\n\n and with_constraint (*IF_CURRENT = Parsetree.with_constraint *) =\n | Pwith_type of Longident.t loc * type_declaration\n (* with type X.t = ...\n\n Note: the last component of the longident must match\n the name of the type_declaration. *)\n | Pwith_module of Longident.t loc * Longident.t loc\n (* with module X.Y = Z *)\n | Pwith_typesubst of Longident.t loc * type_declaration\n (* with type X.t := ..., same format as [Pwith_type] *)\n | Pwith_modsubst of Longident.t loc * Longident.t loc\n (* with module X.Y := Z *)\n\n (* Value expressions for the module language *)\n\n and module_expr (*IF_CURRENT = Parsetree.module_expr *) =\n {\n pmod_desc: module_expr_desc;\n pmod_loc: Location.t;\n pmod_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and module_expr_desc (*IF_CURRENT = Parsetree.module_expr_desc *) =\n | Pmod_ident of Longident.t loc\n (* X *)\n | Pmod_structure of structure\n (* struct ... end *)\n | Pmod_functor of string loc * module_type option * module_expr\n (* functor(X : MT1) -> ME *)\n | Pmod_apply of module_expr * module_expr\n (* ME1(ME2) *)\n | Pmod_constraint of module_expr * module_type\n (* (ME : MT) *)\n | Pmod_unpack of expression\n (* (val E) *)\n | Pmod_extension of extension\n (* [%id] *)\n\n and structure = structure_item list\n\n and structure_item (*IF_CURRENT = Parsetree.structure_item *) =\n {\n pstr_desc: structure_item_desc;\n pstr_loc: Location.t;\n }\n\n and structure_item_desc (*IF_CURRENT = Parsetree.structure_item_desc *) =\n | Pstr_eval of expression * attributes\n (* E *)\n | Pstr_value of rec_flag * value_binding list\n (* let P1 = E1 and ... and Pn = EN (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN (flag = Recursive)\n *)\n | Pstr_primitive of value_description\n (* val x: T\n external x: T = \"s1\" ... \"sn\" *)\n | Pstr_type of rec_flag * type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Pstr_typext of type_extension\n (* type t1 += ... *)\n | Pstr_exception of extension_constructor\n (* exception C of T\n exception C = M.X *)\n | Pstr_module of module_binding\n (* module X = ME *)\n | Pstr_recmodule of module_binding list\n (* module rec X1 = ME1 and ... and Xn = MEn *)\n | Pstr_modtype of module_type_declaration\n (* module type S = MT *)\n | Pstr_open of open_description\n (* open X *)\n | Pstr_class of class_declaration list\n (* class c1 = ... and ... and cn = ... *)\n | Pstr_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Pstr_include of include_declaration\n (* include ME *)\n | Pstr_attribute of attribute\n (* [@@@id] *)\n | Pstr_extension of extension * attributes\n (* [%%id] *)\n\n and value_binding (*IF_CURRENT = Parsetree.value_binding *) =\n {\n pvb_pat: pattern;\n pvb_expr: expression;\n pvb_attributes: attributes;\n pvb_loc: Location.t;\n }\n\n and module_binding (*IF_CURRENT = Parsetree.module_binding *) =\n {\n pmb_name: string loc;\n pmb_expr: module_expr;\n pmb_attributes: attributes;\n pmb_loc: Location.t;\n }\n (* X = ME *)\n\n (** {1 Toplevel} *)\n\n (* Toplevel phrases *)\n\n type toplevel_phrase (*IF_CURRENT = Parsetree.toplevel_phrase *) =\n | Ptop_def of structure\n | Ptop_dir of string * directive_argument\n (* #use, #load ... *)\n\n and directive_argument (*IF_CURRENT = Parsetree.directive_argument *) =\n | Pdir_none\n | Pdir_string of string\n | Pdir_int of string * char option\n | Pdir_ident of Longident.t\n | Pdir_bool of bool\n\nend\n\nmodule Config = struct\n let ast_impl_magic_number = \"Caml1999M023\"\n let ast_intf_magic_number = \"Caml1999N023\"\nend\n","(**************************************************************************)\n(* *)\n(* OCaml Migrate Parsetree *)\n(* *)\n(* Frédéric Bour *)\n(* Jérémie Dimino and Leo White, Jane Street Europe *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* Alain Frisch, LexiFi *)\n(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 2017 Institut National de Recherche en Informatique et *)\n(* en Automatique (INRIA). *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* Ast ported on Mon Oct 2 11:25:57 CEST 2017\n OCaml trunk was:\n commit 65940a2c6be43c42f75c6c6b255974f7e6de03ca (HEAD -> 4.06, origin/4.06)\n Author: Christophe Raffalli \n Date: Sun Oct 1 18:27:07 2017 +0200\n\n fixed position of last optional last semicolumn in sequence (#1387)\n*)\n\nmodule Asttypes = struct\n (** Auxiliary AST types used by parsetree and typedtree. *)\n\n type constant (*IF_CURRENT = Asttypes.constant *) =\n Const_int of int\n | Const_char of char\n | Const_string of string * string option\n | Const_float of string\n | Const_int32 of int32\n | Const_int64 of int64\n | Const_nativeint of nativeint\n\n type rec_flag (*IF_CURRENT = Asttypes.rec_flag *) = Nonrecursive | Recursive\n\n type direction_flag (*IF_CURRENT = Asttypes.direction_flag *) = Upto | Downto\n\n (* Order matters, used in polymorphic comparison *)\n type private_flag (*IF_CURRENT = Asttypes.private_flag *) = Private | Public\n\n type mutable_flag (*IF_CURRENT = Asttypes.mutable_flag *) = Immutable | Mutable\n\n type virtual_flag (*IF_CURRENT = Asttypes.virtual_flag *) = Virtual | Concrete\n\n type override_flag (*IF_CURRENT = Asttypes.override_flag *) = Override | Fresh\n\n type closed_flag (*IF_CURRENT = Asttypes.closed_flag *) = Closed | Open\n\n type label = string\n\n type arg_label (*IF_CURRENT = Asttypes.arg_label *) =\n Nolabel\n | Labelled of string (* label:T -> ... *)\n | Optional of string (* ?label:T -> ... *)\n\n type 'a loc = 'a Location.loc = {\n txt : 'a;\n loc : Location.t;\n }\n\n\n type variance (*IF_CURRENT = Asttypes.variance *) =\n | Covariant\n | Contravariant\n | Invariant\nend\n\nmodule Parsetree = struct\n (** Abstract syntax tree produced by parsing *)\n\n open Asttypes\n\n type constant (*IF_CURRENT = Parsetree.constant *) =\n Pconst_integer of string * char option\n (* 3 3l 3L 3n\n\n Suffixes [g-z][G-Z] are accepted by the parser.\n Suffixes except 'l', 'L' and 'n' are rejected by the typechecker\n *)\n | Pconst_char of char\n (* 'c' *)\n | Pconst_string of string * string option\n (* \"constant\"\n {delim|other constant|delim}\n *)\n | Pconst_float of string * char option\n (* 3.4 2e5 1.4e-4\n\n Suffixes [g-z][G-Z] are accepted by the parser.\n Suffixes are rejected by the typechecker.\n *)\n\n (** {2 Extension points} *)\n\n type attribute = string loc * payload\n (* [@id ARG]\n [@@id ARG]\n\n Metadata containers passed around within the AST.\n The compiler ignores unknown attributes.\n *)\n\n and extension = string loc * payload\n (* [%id ARG]\n [%%id ARG]\n\n Sub-language placeholder -- rejected by the typechecker.\n *)\n\n and attributes = attribute list\n\n and payload (*IF_CURRENT = Parsetree.payload *) =\n | PStr of structure\n | PSig of signature (* : SIG *)\n | PTyp of core_type (* : T *)\n | PPat of pattern * expression option (* ? P or ? P when E *)\n\n (** {2 Core language} *)\n\n (* Type expressions *)\n\n and core_type (*IF_CURRENT = Parsetree.core_type *) =\n {\n ptyp_desc: core_type_desc;\n ptyp_loc: Location.t;\n ptyp_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and core_type_desc (*IF_CURRENT = Parsetree.core_type_desc *) =\n | Ptyp_any\n (* _ *)\n | Ptyp_var of string\n (* 'a *)\n | Ptyp_arrow of arg_label * core_type * core_type\n (* T1 -> T2 Simple\n ~l:T1 -> T2 Labelled\n ?l:T1 -> T2 Optional\n *)\n | Ptyp_tuple of core_type list\n (* T1 * ... * Tn\n\n Invariant: n >= 2\n *)\n | Ptyp_constr of Longident.t loc * core_type list\n (* tconstr\n T tconstr\n (T1, ..., Tn) tconstr\n *)\n | Ptyp_object of object_field list * closed_flag\n (* < l1:T1; ...; ln:Tn > (flag = Closed)\n < l1:T1; ...; ln:Tn; .. > (flag = Open)\n *)\n | Ptyp_class of Longident.t loc * core_type list\n (* #tconstr\n T #tconstr\n (T1, ..., Tn) #tconstr\n *)\n | Ptyp_alias of core_type * string\n (* T as 'a *)\n | Ptyp_variant of row_field list * closed_flag * label list option\n (* [ `A|`B ] (flag = Closed; labels = None)\n [> `A|`B ] (flag = Open; labels = None)\n [< `A|`B ] (flag = Closed; labels = Some [])\n [< `A|`B > `X `Y ](flag = Closed; labels = Some [\"X\";\"Y\"])\n *)\n | Ptyp_poly of string loc list * core_type\n (* 'a1 ... 'an. T\n\n Can only appear in the following context:\n\n - As the core_type of a Ppat_constraint node corresponding\n to a constraint on a let-binding: let x : 'a1 ... 'an. T\n = e ...\n\n - Under Cfk_virtual for methods (not values).\n\n - As the core_type of a Pctf_method node.\n\n - As the core_type of a Pexp_poly node.\n\n - As the pld_type field of a label_declaration.\n\n - As a core_type of a Ptyp_object node.\n *)\n\n | Ptyp_package of package_type\n (* (module S) *)\n | Ptyp_extension of extension\n (* [%id] *)\n\n and package_type = Longident.t loc * (Longident.t loc * core_type) list\n (*\n (module S)\n (module S with type t1 = T1 and ... and tn = Tn)\n *)\n\n and row_field (*IF_CURRENT = Parsetree.row_field *) =\n | Rtag of label loc * attributes * bool * core_type list\n (* [`A] ( true, [] )\n [`A of T] ( false, [T] )\n [`A of T1 & .. & Tn] ( false, [T1;...Tn] )\n [`A of & T1 & .. & Tn] ( true, [T1;...Tn] )\n\n - The 2nd field is true if the tag contains a\n constant (empty) constructor.\n - '&' occurs when several types are used for the same constructor\n (see 4.2 in the manual)\n\n - TODO: switch to a record representation, and keep location\n *)\n | Rinherit of core_type\n (* [ T ] *)\n\n and object_field (*IF_CURRENT = Parsetree.object_field *) =\n | Otag of label loc * attributes * core_type\n | Oinherit of core_type\n\n (* Patterns *)\n\n and pattern (*IF_CURRENT = Parsetree.pattern *) =\n {\n ppat_desc: pattern_desc;\n ppat_loc: Location.t;\n ppat_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and pattern_desc (*IF_CURRENT = Parsetree.pattern_desc *) =\n | Ppat_any\n (* _ *)\n | Ppat_var of string loc\n (* x *)\n | Ppat_alias of pattern * string loc\n (* P as 'a *)\n | Ppat_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Ppat_interval of constant * constant\n (* 'a'..'z'\n\n Other forms of interval are recognized by the parser\n but rejected by the type-checker. *)\n | Ppat_tuple of pattern list\n (* (P1, ..., Pn)\n\n Invariant: n >= 2\n *)\n | Ppat_construct of Longident.t loc * pattern option\n (* C None\n C P Some P\n C (P1, ..., Pn) Some (Ppat_tuple [P1; ...; Pn])\n *)\n | Ppat_variant of label * pattern option\n (* `A (None)\n `A P (Some P)\n *)\n | Ppat_record of (Longident.t loc * pattern) list * closed_flag\n (* { l1=P1; ...; ln=Pn } (flag = Closed)\n { l1=P1; ...; ln=Pn; _} (flag = Open)\n\n Invariant: n > 0\n *)\n | Ppat_array of pattern list\n (* [| P1; ...; Pn |] *)\n | Ppat_or of pattern * pattern\n (* P1 | P2 *)\n | Ppat_constraint of pattern * core_type\n (* (P : T) *)\n | Ppat_type of Longident.t loc\n (* #tconst *)\n | Ppat_lazy of pattern\n (* lazy P *)\n | Ppat_unpack of string loc\n (* (module P)\n Note: (module P : S) is represented as\n Ppat_constraint(Ppat_unpack, Ptyp_package)\n *)\n | Ppat_exception of pattern\n (* exception P *)\n | Ppat_extension of extension\n (* [%id] *)\n | Ppat_open of Longident.t loc * pattern\n (* M.(P) *)\n\n (* Value expressions *)\n\n and expression (*IF_CURRENT = Parsetree.expression *) =\n {\n pexp_desc: expression_desc;\n pexp_loc: Location.t;\n pexp_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and expression_desc (*IF_CURRENT = Parsetree.expression_desc *) =\n | Pexp_ident of Longident.t loc\n (* x\n M.x\n *)\n | Pexp_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Pexp_let of rec_flag * value_binding list * expression\n (* let P1 = E1 and ... and Pn = EN in E (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in E (flag = Recursive)\n *)\n | Pexp_function of case list\n (* function P1 -> E1 | ... | Pn -> En *)\n | Pexp_fun of arg_label * expression option * pattern * expression\n (* fun P -> E1 (Simple, None)\n fun ~l:P -> E1 (Labelled l, None)\n fun ?l:P -> E1 (Optional l, None)\n fun ?l:(P = E0) -> E1 (Optional l, Some E0)\n\n Notes:\n - If E0 is provided, only Optional is allowed.\n - \"fun P1 P2 .. Pn -> E1\" is represented as nested Pexp_fun.\n - \"let f P = E\" is represented using Pexp_fun.\n *)\n | Pexp_apply of expression * (arg_label * expression) list\n (* E0 ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pexp_match of expression * case list\n (* match E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_try of expression * case list\n (* try E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_tuple of expression list\n (* (E1, ..., En)\n\n Invariant: n >= 2\n *)\n | Pexp_construct of Longident.t loc * expression option\n (* C None\n C E Some E\n C (E1, ..., En) Some (Pexp_tuple[E1;...;En])\n *)\n | Pexp_variant of label * expression option\n (* `A (None)\n `A E (Some E)\n *)\n | Pexp_record of (Longident.t loc * expression) list * expression option\n (* { l1=P1; ...; ln=Pn } (None)\n { E0 with l1=P1; ...; ln=Pn } (Some E0)\n\n Invariant: n > 0\n *)\n | Pexp_field of expression * Longident.t loc\n (* E.l *)\n | Pexp_setfield of expression * Longident.t loc * expression\n (* E1.l <- E2 *)\n | Pexp_array of expression list\n (* [| E1; ...; En |] *)\n | Pexp_ifthenelse of expression * expression * expression option\n (* if E1 then E2 else E3 *)\n | Pexp_sequence of expression * expression\n (* E1; E2 *)\n | Pexp_while of expression * expression\n (* while E1 do E2 done *)\n | Pexp_for of\n pattern * expression * expression * direction_flag * expression\n (* for i = E1 to E2 do E3 done (flag = Upto)\n for i = E1 downto E2 do E3 done (flag = Downto)\n *)\n | Pexp_constraint of expression * core_type\n (* (E : T) *)\n | Pexp_coerce of expression * core_type option * core_type\n (* (E :> T) (None, T)\n (E : T0 :> T) (Some T0, T)\n *)\n | Pexp_send of expression * label loc\n (* E # m *)\n | Pexp_new of Longident.t loc\n (* new M.c *)\n | Pexp_setinstvar of label loc * expression\n (* x <- 2 *)\n | Pexp_override of (label loc * expression) list\n (* {< x1 = E1; ...; Xn = En >} *)\n | Pexp_letmodule of string loc * module_expr * expression\n (* let module M = ME in E *)\n | Pexp_letexception of extension_constructor * expression\n (* let exception C in E *)\n | Pexp_assert of expression\n (* assert E\n Note: \"assert false\" is treated in a special way by the\n type-checker. *)\n | Pexp_lazy of expression\n (* lazy E *)\n | Pexp_poly of expression * core_type option\n (* Used for method bodies.\n\n Can only be used as the expression under Cfk_concrete\n for methods (not values). *)\n | Pexp_object of class_structure\n (* object ... end *)\n | Pexp_newtype of string loc * expression\n (* fun (type t) -> E *)\n | Pexp_pack of module_expr\n (* (module ME)\n\n (module ME : S) is represented as\n Pexp_constraint(Pexp_pack, Ptyp_package S) *)\n | Pexp_open of override_flag * Longident.t loc * expression\n (* M.(E)\n let open M in E\n let! open M in E *)\n | Pexp_extension of extension\n (* [%id] *)\n | Pexp_unreachable\n (* . *)\n\n and case (*IF_CURRENT = Parsetree.case *) = (* (P -> E) or (P when E0 -> E) *)\n {\n pc_lhs: pattern;\n pc_guard: expression option;\n pc_rhs: expression;\n }\n\n (* Value descriptions *)\n\n and value_description (*IF_CURRENT = Parsetree.value_description *) =\n {\n pval_name: string loc;\n pval_type: core_type;\n pval_prim: string list;\n pval_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pval_loc: Location.t;\n }\n\n (*\n val x: T (prim = [])\n external x: T = \"s1\" ... \"sn\" (prim = [\"s1\";...\"sn\"])\n *)\n\n (* Type declarations *)\n\n and type_declaration (*IF_CURRENT = Parsetree.type_declaration *) =\n {\n ptype_name: string loc;\n ptype_params: (core_type * variance) list;\n (* ('a1,...'an) t; None represents _*)\n ptype_cstrs: (core_type * core_type * Location.t) list;\n (* ... constraint T1=T1' ... constraint Tn=Tn' *)\n ptype_kind: type_kind;\n ptype_private: private_flag; (* = private ... *)\n ptype_manifest: core_type option; (* = T *)\n ptype_attributes: attributes; (* ... [@@id1] [@@id2] *)\n ptype_loc: Location.t;\n }\n\n (*\n type t (abstract, no manifest)\n type t = T0 (abstract, manifest=T0)\n type t = C of T | ... (variant, no manifest)\n type t = T0 = C of T | ... (variant, manifest=T0)\n type t = {l: T; ...} (record, no manifest)\n type t = T0 = {l : T; ...} (record, manifest=T0)\n type t = .. (open, no manifest)\n *)\n\n and type_kind (*IF_CURRENT = Parsetree.type_kind *) =\n | Ptype_abstract\n | Ptype_variant of constructor_declaration list\n (* Invariant: non-empty list *)\n | Ptype_record of label_declaration list\n (* Invariant: non-empty list *)\n | Ptype_open\n\n and label_declaration (*IF_CURRENT = Parsetree.label_declaration *) =\n {\n pld_name: string loc;\n pld_mutable: mutable_flag;\n pld_type: core_type;\n pld_loc: Location.t;\n pld_attributes: attributes; (* l : T [@id1] [@id2] *)\n }\n\n (* { ...; l: T; ... } (mutable=Immutable)\n { ...; mutable l: T; ... } (mutable=Mutable)\n\n Note: T can be a Ptyp_poly.\n *)\n\n and constructor_declaration (*IF_CURRENT = Parsetree.constructor_declaration *) =\n {\n pcd_name: string loc;\n pcd_args: constructor_arguments;\n pcd_res: core_type option;\n pcd_loc: Location.t;\n pcd_attributes: attributes; (* C of ... [@id1] [@id2] *)\n }\n\n and constructor_arguments (*IF_CURRENT = Parsetree.constructor_arguments *) =\n | Pcstr_tuple of core_type list\n | Pcstr_record of label_declaration list\n\n (*\n | C of T1 * ... * Tn (res = None, args = Pcstr_tuple [])\n | C: T0 (res = Some T0, args = [])\n | C: T1 * ... * Tn -> T0 (res = Some T0, args = Pcstr_tuple)\n | C of {...} (res = None, args = Pcstr_record)\n | C: {...} -> T0 (res = Some T0, args = Pcstr_record)\n | C of {...} as t (res = None, args = Pcstr_record)\n *)\n\n and type_extension (*IF_CURRENT = Parsetree.type_extension *) =\n {\n ptyext_path: Longident.t loc;\n ptyext_params: (core_type * variance) list;\n ptyext_constructors: extension_constructor list;\n ptyext_private: private_flag;\n ptyext_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n (*\n type t += ...\n *)\n\n and extension_constructor (*IF_CURRENT = Parsetree.extension_constructor *) =\n {\n pext_name: string loc;\n pext_kind : extension_constructor_kind;\n pext_loc : Location.t;\n pext_attributes: attributes; (* C of ... [@id1] [@id2] *)\n }\n\n and extension_constructor_kind (*IF_CURRENT = Parsetree.extension_constructor_kind *) =\n Pext_decl of constructor_arguments * core_type option\n (*\n | C of T1 * ... * Tn ([T1; ...; Tn], None)\n | C: T0 ([], Some T0)\n | C: T1 * ... * Tn -> T0 ([T1; ...; Tn], Some T0)\n *)\n | Pext_rebind of Longident.t loc\n (*\n | C = D\n *)\n\n (** {2 Class language} *)\n\n (* Type expressions for the class language *)\n\n and class_type (*IF_CURRENT = Parsetree.class_type *) =\n {\n pcty_desc: class_type_desc;\n pcty_loc: Location.t;\n pcty_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and class_type_desc (*IF_CURRENT = Parsetree.class_type_desc *) =\n | Pcty_constr of Longident.t loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcty_signature of class_signature\n (* object ... end *)\n | Pcty_arrow of arg_label * core_type * class_type\n (* T -> CT Simple\n ~l:T -> CT Labelled l\n ?l:T -> CT Optional l\n *)\n | Pcty_extension of extension\n (* [%id] *)\n | Pcty_open of override_flag * Longident.t loc * class_type\n (* let open M in CT *)\n\n\n and class_signature (*IF_CURRENT = Parsetree.class_signature *) =\n {\n pcsig_self: core_type;\n pcsig_fields: class_type_field list;\n }\n (* object('selfpat) ... end\n object ... end (self = Ptyp_any)\n *)\n\n and class_type_field (*IF_CURRENT = Parsetree.class_type_field *) =\n {\n pctf_desc: class_type_field_desc;\n pctf_loc: Location.t;\n pctf_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and class_type_field_desc (*IF_CURRENT = Parsetree.class_type_field_desc *) =\n | Pctf_inherit of class_type\n (* inherit CT *)\n | Pctf_val of (label loc * mutable_flag * virtual_flag * core_type)\n (* val x: T *)\n | Pctf_method of (label loc * private_flag * virtual_flag * core_type)\n (* method x: T\n\n Note: T can be a Ptyp_poly.\n *)\n | Pctf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pctf_attribute of attribute\n (* [@@@id] *)\n | Pctf_extension of extension\n (* [%%id] *)\n\n and 'a class_infos (*IF_CURRENT = 'a Parsetree.class_infos *) =\n {\n pci_virt: virtual_flag;\n pci_params: (core_type * variance) list;\n pci_name: string loc;\n pci_expr: 'a;\n pci_loc: Location.t;\n pci_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n (* class c = ...\n class ['a1,...,'an] c = ...\n class virtual c = ...\n\n Also used for \"class type\" declaration.\n *)\n\n and class_description = class_type class_infos\n\n and class_type_declaration = class_type class_infos\n\n (* Value expressions for the class language *)\n\n and class_expr (*IF_CURRENT = Parsetree.class_expr *) =\n {\n pcl_desc: class_expr_desc;\n pcl_loc: Location.t;\n pcl_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and class_expr_desc (*IF_CURRENT = Parsetree.class_expr_desc *) =\n | Pcl_constr of Longident.t loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcl_structure of class_structure\n (* object ... end *)\n | Pcl_fun of arg_label * expression option * pattern * class_expr\n (* fun P -> CE (Simple, None)\n fun ~l:P -> CE (Labelled l, None)\n fun ?l:P -> CE (Optional l, None)\n fun ?l:(P = E0) -> CE (Optional l, Some E0)\n *)\n | Pcl_apply of class_expr * (arg_label * expression) list\n (* CE ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pcl_let of rec_flag * value_binding list * class_expr\n (* let P1 = E1 and ... and Pn = EN in CE (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in CE (flag = Recursive)\n *)\n | Pcl_constraint of class_expr * class_type\n (* (CE : CT) *)\n | Pcl_extension of extension\n (* [%id] *)\n | Pcl_open of override_flag * Longident.t loc * class_expr\n (* let open M in CE *)\n\n\n and class_structure (*IF_CURRENT = Parsetree.class_structure *) =\n {\n pcstr_self: pattern;\n pcstr_fields: class_field list;\n }\n (* object(selfpat) ... end\n object ... end (self = Ppat_any)\n *)\n\n and class_field (*IF_CURRENT = Parsetree.class_field *) =\n {\n pcf_desc: class_field_desc;\n pcf_loc: Location.t;\n pcf_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and class_field_desc (*IF_CURRENT = Parsetree.class_field_desc *) =\n | Pcf_inherit of override_flag * class_expr * string loc option\n (* inherit CE\n inherit CE as x\n inherit! CE\n inherit! CE as x\n *)\n | Pcf_val of (label loc * mutable_flag * class_field_kind)\n (* val x = E\n val virtual x: T\n *)\n | Pcf_method of (label loc * private_flag * class_field_kind)\n (* method x = E (E can be a Pexp_poly)\n method virtual x: T (T can be a Ptyp_poly)\n *)\n | Pcf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pcf_initializer of expression\n (* initializer E *)\n | Pcf_attribute of attribute\n (* [@@@id] *)\n | Pcf_extension of extension\n (* [%%id] *)\n\n and class_field_kind (*IF_CURRENT = Parsetree.class_field_kind *) =\n | Cfk_virtual of core_type\n | Cfk_concrete of override_flag * expression\n\n and class_declaration = class_expr class_infos\n\n (** {2 Module language} *)\n\n (* Type expressions for the module language *)\n\n and module_type (*IF_CURRENT = Parsetree.module_type *) =\n {\n pmty_desc: module_type_desc;\n pmty_loc: Location.t;\n pmty_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and module_type_desc (*IF_CURRENT = Parsetree.module_type_desc *) =\n | Pmty_ident of Longident.t loc\n (* S *)\n | Pmty_signature of signature\n (* sig ... end *)\n | Pmty_functor of string loc * module_type option * module_type\n (* functor(X : MT1) -> MT2 *)\n | Pmty_with of module_type * with_constraint list\n (* MT with ... *)\n | Pmty_typeof of module_expr\n (* module type of ME *)\n | Pmty_extension of extension\n (* [%id] *)\n | Pmty_alias of Longident.t loc\n (* (module M) *)\n\n and signature = signature_item list\n\n and signature_item (*IF_CURRENT = Parsetree.signature_item *) =\n {\n psig_desc: signature_item_desc;\n psig_loc: Location.t;\n }\n\n and signature_item_desc (*IF_CURRENT = Parsetree.signature_item_desc *) =\n | Psig_value of value_description\n (*\n val x: T\n external x: T = \"s1\" ... \"sn\"\n *)\n | Psig_type of rec_flag * type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Psig_typext of type_extension\n (* type t1 += ... *)\n | Psig_exception of extension_constructor\n (* exception C of T *)\n | Psig_module of module_declaration\n (* module X : MT *)\n | Psig_recmodule of module_declaration list\n (* module rec X1 : MT1 and ... and Xn : MTn *)\n | Psig_modtype of module_type_declaration\n (* module type S = MT\n module type S *)\n | Psig_open of open_description\n (* open X *)\n | Psig_include of include_description\n (* include MT *)\n | Psig_class of class_description list\n (* class c1 : ... and ... and cn : ... *)\n | Psig_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Psig_attribute of attribute\n (* [@@@id] *)\n | Psig_extension of extension * attributes\n (* [%%id] *)\n\n and module_declaration (*IF_CURRENT = Parsetree.module_declaration *) =\n {\n pmd_name: string loc;\n pmd_type: module_type;\n pmd_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pmd_loc: Location.t;\n }\n (* S : MT *)\n\n and module_type_declaration (*IF_CURRENT = Parsetree.module_type_declaration *) =\n {\n pmtd_name: string loc;\n pmtd_type: module_type option;\n pmtd_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pmtd_loc: Location.t;\n }\n (* S = MT\n S (abstract module type declaration, pmtd_type = None)\n *)\n\n and open_description (*IF_CURRENT = Parsetree.open_description *) =\n {\n popen_lid: Longident.t loc;\n popen_override: override_flag;\n popen_loc: Location.t;\n popen_attributes: attributes;\n }\n (* open! X - popen_override = Override (silences the 'used identifier\n shadowing' warning)\n open X - popen_override = Fresh\n *)\n\n and 'a include_infos (*IF_CURRENT = 'a Parsetree.include_infos *) =\n {\n pincl_mod: 'a;\n pincl_loc: Location.t;\n pincl_attributes: attributes;\n }\n\n and include_description = module_type include_infos\n (* include MT *)\n\n and include_declaration = module_expr include_infos\n (* include ME *)\n\n and with_constraint (*IF_CURRENT = Parsetree.with_constraint *) =\n | Pwith_type of Longident.t loc * type_declaration\n (* with type X.t = ...\n\n Note: the last component of the longident must match\n the name of the type_declaration. *)\n | Pwith_module of Longident.t loc * Longident.t loc\n (* with module X.Y = Z *)\n | Pwith_typesubst of Longident.t loc * type_declaration\n (* with type X.t := ..., same format as [Pwith_type] *)\n | Pwith_modsubst of Longident.t loc * Longident.t loc\n (* with module X.Y := Z *)\n\n (* Value expressions for the module language *)\n\n and module_expr (*IF_CURRENT = Parsetree.module_expr *) =\n {\n pmod_desc: module_expr_desc;\n pmod_loc: Location.t;\n pmod_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and module_expr_desc (*IF_CURRENT = Parsetree.module_expr_desc *) =\n | Pmod_ident of Longident.t loc\n (* X *)\n | Pmod_structure of structure\n (* struct ... end *)\n | Pmod_functor of string loc * module_type option * module_expr\n (* functor(X : MT1) -> ME *)\n | Pmod_apply of module_expr * module_expr\n (* ME1(ME2) *)\n | Pmod_constraint of module_expr * module_type\n (* (ME : MT) *)\n | Pmod_unpack of expression\n (* (val E) *)\n | Pmod_extension of extension\n (* [%id] *)\n\n and structure = structure_item list\n\n and structure_item (*IF_CURRENT = Parsetree.structure_item *) =\n {\n pstr_desc: structure_item_desc;\n pstr_loc: Location.t;\n }\n\n and structure_item_desc (*IF_CURRENT = Parsetree.structure_item_desc *) =\n | Pstr_eval of expression * attributes\n (* E *)\n | Pstr_value of rec_flag * value_binding list\n (* let P1 = E1 and ... and Pn = EN (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN (flag = Recursive)\n *)\n | Pstr_primitive of value_description\n (* val x: T\n external x: T = \"s1\" ... \"sn\" *)\n | Pstr_type of rec_flag * type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Pstr_typext of type_extension\n (* type t1 += ... *)\n | Pstr_exception of extension_constructor\n (* exception C of T\n exception C = M.X *)\n | Pstr_module of module_binding\n (* module X = ME *)\n | Pstr_recmodule of module_binding list\n (* module rec X1 = ME1 and ... and Xn = MEn *)\n | Pstr_modtype of module_type_declaration\n (* module type S = MT *)\n | Pstr_open of open_description\n (* open X *)\n | Pstr_class of class_declaration list\n (* class c1 = ... and ... and cn = ... *)\n | Pstr_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Pstr_include of include_declaration\n (* include ME *)\n | Pstr_attribute of attribute\n (* [@@@id] *)\n | Pstr_extension of extension * attributes\n (* [%%id] *)\n\n and value_binding (*IF_CURRENT = Parsetree.value_binding *) =\n {\n pvb_pat: pattern;\n pvb_expr: expression;\n pvb_attributes: attributes;\n pvb_loc: Location.t;\n }\n\n and module_binding (*IF_CURRENT = Parsetree.module_binding *) =\n {\n pmb_name: string loc;\n pmb_expr: module_expr;\n pmb_attributes: attributes;\n pmb_loc: Location.t;\n }\n (* X = ME *)\n\n (** {2 Toplevel} *)\n\n (* Toplevel phrases *)\n\n type toplevel_phrase (*IF_CURRENT = Parsetree.toplevel_phrase *) =\n | Ptop_def of structure\n | Ptop_dir of string * directive_argument\n (* #use, #load ... *)\n\n and directive_argument (*IF_CURRENT = Parsetree.directive_argument *) =\n | Pdir_none\n | Pdir_string of string\n | Pdir_int of string * char option\n | Pdir_ident of Longident.t\n | Pdir_bool of bool\n\nend\n\nmodule Config = struct\n let ast_impl_magic_number = \"Caml1999M022\"\n let ast_intf_magic_number = \"Caml1999N022\"\nend\n","(**************************************************************************)\n(* *)\n(* OCaml Migrate Parsetree *)\n(* *)\n(* Frédéric Bour *)\n(* Jérémie Dimino and Leo White, Jane Street Europe *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* Alain Frisch, LexiFi *)\n(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 2017 Institut National de Recherche en Informatique et *)\n(* en Automatique (INRIA). *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nmodule Asttypes = struct\n (** Auxiliary AST types used by parsetree and typedtree. *)\n\n type constant (*IF_CURRENT = Asttypes.constant *) =\n Const_int of int\n | Const_char of char\n | Const_string of string * string option\n | Const_float of string\n | Const_int32 of int32\n | Const_int64 of int64\n | Const_nativeint of nativeint\n\n type rec_flag (*IF_CURRENT = Asttypes.rec_flag *) = Nonrecursive | Recursive\n\n type direction_flag (*IF_CURRENT = Asttypes.direction_flag *) = Upto | Downto\n\n (* Order matters, used in polymorphic comparison *)\n type private_flag (*IF_CURRENT = Asttypes.private_flag *) = Private | Public\n\n type mutable_flag (*IF_CURRENT = Asttypes.mutable_flag *) = Immutable | Mutable\n\n type virtual_flag (*IF_CURRENT = Asttypes.virtual_flag *) = Virtual | Concrete\n\n type override_flag (*IF_CURRENT = Asttypes.override_flag *) = Override | Fresh\n\n type closed_flag (*IF_CURRENT = Asttypes.closed_flag *) = Closed | Open\n\n type label = string\n\n type arg_label (*IF_CURRENT = Asttypes.arg_label *) =\n Nolabel\n | Labelled of string (* label:T -> ... *)\n | Optional of string (* ?label:T -> ... *)\n\n type 'a loc = 'a Location.loc = {\n txt : 'a;\n loc : Location.t;\n }\n\n\n type variance (*IF_CURRENT = Asttypes.variance *) =\n | Covariant\n | Contravariant\n | Invariant\nend\n\nmodule Parsetree = struct\n (** Abstract syntax tree produced by parsing *)\n\n open Asttypes\n\n type constant (*IF_CURRENT = Parsetree.constant *) =\n Pconst_integer of string * char option\n (* 3 3l 3L 3n\n\n Suffixes [g-z][G-Z] are accepted by the parser.\n Suffixes except 'l', 'L' and 'n' are rejected by the typechecker\n *)\n | Pconst_char of char\n (* 'c' *)\n | Pconst_string of string * string option\n (* \"constant\"\n {delim|other constant|delim}\n *)\n | Pconst_float of string * char option\n (* 3.4 2e5 1.4e-4\n\n Suffixes [g-z][G-Z] are accepted by the parser.\n Suffixes are rejected by the typechecker.\n *)\n\n (** {2 Extension points} *)\n\n type attribute = string loc * payload\n (* [@id ARG]\n [@@id ARG]\n\n Metadata containers passed around within the AST.\n The compiler ignores unknown attributes.\n *)\n\n and extension = string loc * payload\n (* [%id ARG]\n [%%id ARG]\n\n Sub-language placeholder -- rejected by the typechecker.\n *)\n\n and attributes = attribute list\n\n and payload (*IF_CURRENT = Parsetree.payload *) =\n | PStr of structure\n | PSig of signature (* : SIG *)\n | PTyp of core_type (* : T *)\n | PPat of pattern * expression option (* ? P or ? P when E *)\n\n (** {2 Core language} *)\n\n (* Type expressions *)\n\n and core_type (*IF_CURRENT = Parsetree.core_type *) =\n {\n ptyp_desc: core_type_desc;\n ptyp_loc: Location.t;\n ptyp_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and core_type_desc (*IF_CURRENT = Parsetree.core_type_desc *) =\n | Ptyp_any\n (* _ *)\n | Ptyp_var of string\n (* 'a *)\n | Ptyp_arrow of arg_label * core_type * core_type\n (* T1 -> T2 Simple\n ~l:T1 -> T2 Labelled\n ?l:T1 -> T2 Otional\n *)\n | Ptyp_tuple of core_type list\n (* T1 * ... * Tn\n\n Invariant: n >= 2\n *)\n | Ptyp_constr of Longident.t loc * core_type list\n (* tconstr\n T tconstr\n (T1, ..., Tn) tconstr\n *)\n | Ptyp_object of (string loc * attributes * core_type) list * closed_flag\n (* < l1:T1; ...; ln:Tn > (flag = Closed)\n < l1:T1; ...; ln:Tn; .. > (flag = Open)\n *)\n | Ptyp_class of Longident.t loc * core_type list\n (* #tconstr\n T #tconstr\n (T1, ..., Tn) #tconstr\n *)\n | Ptyp_alias of core_type * string\n (* T as 'a *)\n | Ptyp_variant of row_field list * closed_flag * label list option\n (* [ `A|`B ] (flag = Closed; labels = None)\n [> `A|`B ] (flag = Open; labels = None)\n [< `A|`B ] (flag = Closed; labels = Some [])\n [< `A|`B > `X `Y ](flag = Closed; labels = Some [\"X\";\"Y\"])\n *)\n | Ptyp_poly of string loc list * core_type\n (* 'a1 ... 'an. T\n\n Can only appear in the following context:\n\n - As the core_type of a Ppat_constraint node corresponding\n to a constraint on a let-binding: let x : 'a1 ... 'an. T\n = e ...\n\n - Under Cfk_virtual for methods (not values).\n\n - As the core_type of a Pctf_method node.\n\n - As the core_type of a Pexp_poly node.\n\n - As the pld_type field of a label_declaration.\n\n - As a core_type of a Ptyp_object node.\n *)\n\n | Ptyp_package of package_type\n (* (module S) *)\n | Ptyp_extension of extension\n (* [%id] *)\n\n and package_type = Longident.t loc * (Longident.t loc * core_type) list\n (*\n (module S)\n (module S with type t1 = T1 and ... and tn = Tn)\n *)\n\n and row_field (*IF_CURRENT = Parsetree.row_field *) =\n | Rtag of label * attributes * bool * core_type list\n (* [`A] ( true, [] )\n [`A of T] ( false, [T] )\n [`A of T1 & .. & Tn] ( false, [T1;...Tn] )\n [`A of & T1 & .. & Tn] ( true, [T1;...Tn] )\n\n - The 2nd field is true if the tag contains a\n constant (empty) constructor.\n - '&' occurs when several types are used for the same constructor\n (see 4.2 in the manual)\n\n - TODO: switch to a record representation, and keep location\n *)\n | Rinherit of core_type\n (* [ T ] *)\n\n (* Patterns *)\n\n and pattern (*IF_CURRENT = Parsetree.pattern *) =\n {\n ppat_desc: pattern_desc;\n ppat_loc: Location.t;\n ppat_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and pattern_desc (*IF_CURRENT = Parsetree.pattern_desc *) =\n | Ppat_any\n (* _ *)\n | Ppat_var of string loc\n (* x *)\n | Ppat_alias of pattern * string loc\n (* P as 'a *)\n | Ppat_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Ppat_interval of constant * constant\n (* 'a'..'z'\n\n Other forms of interval are recognized by the parser\n but rejected by the type-checker. *)\n | Ppat_tuple of pattern list\n (* (P1, ..., Pn)\n\n Invariant: n >= 2\n *)\n | Ppat_construct of Longident.t loc * pattern option\n (* C None\n C P Some P\n C (P1, ..., Pn) Some (Ppat_tuple [P1; ...; Pn])\n *)\n | Ppat_variant of label * pattern option\n (* `A (None)\n `A P (Some P)\n *)\n | Ppat_record of (Longident.t loc * pattern) list * closed_flag\n (* { l1=P1; ...; ln=Pn } (flag = Closed)\n { l1=P1; ...; ln=Pn; _} (flag = Open)\n\n Invariant: n > 0\n *)\n | Ppat_array of pattern list\n (* [| P1; ...; Pn |] *)\n | Ppat_or of pattern * pattern\n (* P1 | P2 *)\n | Ppat_constraint of pattern * core_type\n (* (P : T) *)\n | Ppat_type of Longident.t loc\n (* #tconst *)\n | Ppat_lazy of pattern\n (* lazy P *)\n | Ppat_unpack of string loc\n (* (module P)\n Note: (module P : S) is represented as\n Ppat_constraint(Ppat_unpack, Ptyp_package)\n *)\n | Ppat_exception of pattern\n (* exception P *)\n | Ppat_extension of extension\n (* [%id] *)\n | Ppat_open of Longident.t loc * pattern\n (* M.(P) *)\n\n (* Value expressions *)\n\n and expression (*IF_CURRENT = Parsetree.expression *) =\n {\n pexp_desc: expression_desc;\n pexp_loc: Location.t;\n pexp_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and expression_desc (*IF_CURRENT = Parsetree.expression_desc *) =\n | Pexp_ident of Longident.t loc\n (* x\n M.x\n *)\n | Pexp_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Pexp_let of rec_flag * value_binding list * expression\n (* let P1 = E1 and ... and Pn = EN in E (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in E (flag = Recursive)\n *)\n | Pexp_function of case list\n (* function P1 -> E1 | ... | Pn -> En *)\n | Pexp_fun of arg_label * expression option * pattern * expression\n (* fun P -> E1 (Simple, None)\n fun ~l:P -> E1 (Labelled l, None)\n fun ?l:P -> E1 (Optional l, None)\n fun ?l:(P = E0) -> E1 (Optional l, Some E0)\n\n Notes:\n - If E0 is provided, only Optional is allowed.\n - \"fun P1 P2 .. Pn -> E1\" is represented as nested Pexp_fun.\n - \"let f P = E\" is represented using Pexp_fun.\n *)\n | Pexp_apply of expression * (arg_label * expression) list\n (* E0 ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pexp_match of expression * case list\n (* match E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_try of expression * case list\n (* try E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_tuple of expression list\n (* (E1, ..., En)\n\n Invariant: n >= 2\n *)\n | Pexp_construct of Longident.t loc * expression option\n (* C None\n C E Some E\n C (E1, ..., En) Some (Pexp_tuple[E1;...;En])\n *)\n | Pexp_variant of label * expression option\n (* `A (None)\n `A E (Some E)\n *)\n | Pexp_record of (Longident.t loc * expression) list * expression option\n (* { l1=P1; ...; ln=Pn } (None)\n { E0 with l1=P1; ...; ln=Pn } (Some E0)\n\n Invariant: n > 0\n *)\n | Pexp_field of expression * Longident.t loc\n (* E.l *)\n | Pexp_setfield of expression * Longident.t loc * expression\n (* E1.l <- E2 *)\n | Pexp_array of expression list\n (* [| E1; ...; En |] *)\n | Pexp_ifthenelse of expression * expression * expression option\n (* if E1 then E2 else E3 *)\n | Pexp_sequence of expression * expression\n (* E1; E2 *)\n | Pexp_while of expression * expression\n (* while E1 do E2 done *)\n | Pexp_for of\n pattern * expression * expression * direction_flag * expression\n (* for i = E1 to E2 do E3 done (flag = Upto)\n for i = E1 downto E2 do E3 done (flag = Downto)\n *)\n | Pexp_constraint of expression * core_type\n (* (E : T) *)\n | Pexp_coerce of expression * core_type option * core_type\n (* (E :> T) (None, T)\n (E : T0 :> T) (Some T0, T)\n *)\n | Pexp_send of expression * string loc\n (* E # m *)\n | Pexp_new of Longident.t loc\n (* new M.c *)\n | Pexp_setinstvar of string loc * expression\n (* x <- 2 *)\n | Pexp_override of (string loc * expression) list\n (* {< x1 = E1; ...; Xn = En >} *)\n | Pexp_letmodule of string loc * module_expr * expression\n (* let module M = ME in E *)\n | Pexp_letexception of extension_constructor * expression\n (* let exception C in E *)\n | Pexp_assert of expression\n (* assert E\n Note: \"assert false\" is treated in a special way by the\n type-checker. *)\n | Pexp_lazy of expression\n (* lazy E *)\n | Pexp_poly of expression * core_type option\n (* Used for method bodies.\n\n Can only be used as the expression under Cfk_concrete\n for methods (not values). *)\n | Pexp_object of class_structure\n (* object ... end *)\n | Pexp_newtype of string loc * expression\n (* fun (type t) -> E *)\n | Pexp_pack of module_expr\n (* (module ME)\n\n (module ME : S) is represented as\n Pexp_constraint(Pexp_pack, Ptyp_package S) *)\n | Pexp_open of override_flag * Longident.t loc * expression\n (* M.(E)\n let open M in E\n let! open M in E *)\n | Pexp_extension of extension\n (* [%id] *)\n | Pexp_unreachable\n (* . *)\n\n and case (*IF_CURRENT = Parsetree.case *) = (* (P -> E) or (P when E0 -> E) *)\n {\n pc_lhs: pattern;\n pc_guard: expression option;\n pc_rhs: expression;\n }\n\n (* Value descriptions *)\n\n and value_description (*IF_CURRENT = Parsetree.value_description *) =\n {\n pval_name: string loc;\n pval_type: core_type;\n pval_prim: string list;\n pval_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pval_loc: Location.t;\n }\n\n (*\n val x: T (prim = [])\n external x: T = \"s1\" ... \"sn\" (prim = [\"s1\";...\"sn\"])\n *)\n\n (* Type declarations *)\n\n and type_declaration (*IF_CURRENT = Parsetree.type_declaration *) =\n {\n ptype_name: string loc;\n ptype_params: (core_type * variance) list;\n (* ('a1,...'an) t; None represents _*)\n ptype_cstrs: (core_type * core_type * Location.t) list;\n (* ... constraint T1=T1' ... constraint Tn=Tn' *)\n ptype_kind: type_kind;\n ptype_private: private_flag; (* = private ... *)\n ptype_manifest: core_type option; (* = T *)\n ptype_attributes: attributes; (* ... [@@id1] [@@id2] *)\n ptype_loc: Location.t;\n }\n\n (*\n type t (abstract, no manifest)\n type t = T0 (abstract, manifest=T0)\n type t = C of T | ... (variant, no manifest)\n type t = T0 = C of T | ... (variant, manifest=T0)\n type t = {l: T; ...} (record, no manifest)\n type t = T0 = {l : T; ...} (record, manifest=T0)\n type t = .. (open, no manifest)\n *)\n\n and type_kind (*IF_CURRENT = Parsetree.type_kind *) =\n | Ptype_abstract\n | Ptype_variant of constructor_declaration list\n (* Invariant: non-empty list *)\n | Ptype_record of label_declaration list\n (* Invariant: non-empty list *)\n | Ptype_open\n\n and label_declaration (*IF_CURRENT = Parsetree.label_declaration *) =\n {\n pld_name: string loc;\n pld_mutable: mutable_flag;\n pld_type: core_type;\n pld_loc: Location.t;\n pld_attributes: attributes; (* l [@id1] [@id2] : T *)\n }\n\n (* { ...; l: T; ... } (mutable=Immutable)\n { ...; mutable l: T; ... } (mutable=Mutable)\n\n Note: T can be a Ptyp_poly.\n *)\n\n and constructor_declaration (*IF_CURRENT = Parsetree.constructor_declaration *) =\n {\n pcd_name: string loc;\n pcd_args: constructor_arguments;\n pcd_res: core_type option;\n pcd_loc: Location.t;\n pcd_attributes: attributes; (* C [@id1] [@id2] of ... *)\n }\n\n and constructor_arguments (*IF_CURRENT = Parsetree.constructor_arguments *) =\n | Pcstr_tuple of core_type list\n | Pcstr_record of label_declaration list\n\n (*\n | C of T1 * ... * Tn (res = None, args = Pcstr_tuple [])\n | C: T0 (res = Some T0, args = [])\n | C: T1 * ... * Tn -> T0 (res = Some T0, args = Pcstr_tuple)\n | C of {...} (res = None, args = Pcstr_record)\n | C: {...} -> T0 (res = Some T0, args = Pcstr_record)\n | C of {...} as t (res = None, args = Pcstr_record)\n *)\n\n and type_extension (*IF_CURRENT = Parsetree.type_extension *) =\n {\n ptyext_path: Longident.t loc;\n ptyext_params: (core_type * variance) list;\n ptyext_constructors: extension_constructor list;\n ptyext_private: private_flag;\n ptyext_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n (*\n type t += ...\n *)\n\n and extension_constructor (*IF_CURRENT = Parsetree.extension_constructor *) =\n {\n pext_name: string loc;\n pext_kind : extension_constructor_kind;\n pext_loc : Location.t;\n pext_attributes: attributes; (* C [@id1] [@id2] of ... *)\n }\n\n and extension_constructor_kind (*IF_CURRENT = Parsetree.extension_constructor_kind *) =\n Pext_decl of constructor_arguments * core_type option\n (*\n | C of T1 * ... * Tn ([T1; ...; Tn], None)\n | C: T0 ([], Some T0)\n | C: T1 * ... * Tn -> T0 ([T1; ...; Tn], Some T0)\n *)\n | Pext_rebind of Longident.t loc\n (*\n | C = D\n *)\n\n (** {2 Class language} *)\n\n (* Type expressions for the class language *)\n\n and class_type (*IF_CURRENT = Parsetree.class_type *) =\n {\n pcty_desc: class_type_desc;\n pcty_loc: Location.t;\n pcty_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and class_type_desc (*IF_CURRENT = Parsetree.class_type_desc *) =\n | Pcty_constr of Longident.t loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcty_signature of class_signature\n (* object ... end *)\n | Pcty_arrow of arg_label * core_type * class_type\n (* T -> CT Simple\n ~l:T -> CT Labelled l\n ?l:T -> CT Optional l\n *)\n | Pcty_extension of extension\n (* [%id] *)\n\n and class_signature (*IF_CURRENT = Parsetree.class_signature *) =\n {\n pcsig_self: core_type;\n pcsig_fields: class_type_field list;\n }\n (* object('selfpat) ... end\n object ... end (self = Ptyp_any)\n *)\n\n and class_type_field (*IF_CURRENT = Parsetree.class_type_field *) =\n {\n pctf_desc: class_type_field_desc;\n pctf_loc: Location.t;\n pctf_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and class_type_field_desc (*IF_CURRENT = Parsetree.class_type_field_desc *) =\n | Pctf_inherit of class_type\n (* inherit CT *)\n | Pctf_val of (string loc * mutable_flag * virtual_flag * core_type)\n (* val x: T *)\n | Pctf_method of (string loc * private_flag * virtual_flag * core_type)\n (* method x: T\n\n Note: T can be a Ptyp_poly.\n *)\n | Pctf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pctf_attribute of attribute\n (* [@@@id] *)\n | Pctf_extension of extension\n (* [%%id] *)\n\n and 'a class_infos (*IF_CURRENT = 'a Parsetree.class_infos *) =\n {\n pci_virt: virtual_flag;\n pci_params: (core_type * variance) list;\n pci_name: string loc;\n pci_expr: 'a;\n pci_loc: Location.t;\n pci_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n (* class c = ...\n class ['a1,...,'an] c = ...\n class virtual c = ...\n\n Also used for \"class type\" declaration.\n *)\n\n and class_description = class_type class_infos\n\n and class_type_declaration = class_type class_infos\n\n (* Value expressions for the class language *)\n\n and class_expr (*IF_CURRENT = Parsetree.class_expr *) =\n {\n pcl_desc: class_expr_desc;\n pcl_loc: Location.t;\n pcl_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and class_expr_desc (*IF_CURRENT = Parsetree.class_expr_desc *) =\n | Pcl_constr of Longident.t loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcl_structure of class_structure\n (* object ... end *)\n | Pcl_fun of arg_label * expression option * pattern * class_expr\n (* fun P -> CE (Simple, None)\n fun ~l:P -> CE (Labelled l, None)\n fun ?l:P -> CE (Optional l, None)\n fun ?l:(P = E0) -> CE (Optional l, Some E0)\n *)\n | Pcl_apply of class_expr * (arg_label * expression) list\n (* CE ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pcl_let of rec_flag * value_binding list * class_expr\n (* let P1 = E1 and ... and Pn = EN in CE (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in CE (flag = Recursive)\n *)\n | Pcl_constraint of class_expr * class_type\n (* (CE : CT) *)\n | Pcl_extension of extension\n (* [%id] *)\n\n and class_structure (*IF_CURRENT = Parsetree.class_structure *) =\n {\n pcstr_self: pattern;\n pcstr_fields: class_field list;\n }\n (* object(selfpat) ... end\n object ... end (self = Ppat_any)\n *)\n\n and class_field (*IF_CURRENT = Parsetree.class_field *) =\n {\n pcf_desc: class_field_desc;\n pcf_loc: Location.t;\n pcf_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and class_field_desc (*IF_CURRENT = Parsetree.class_field_desc *) =\n | Pcf_inherit of override_flag * class_expr * string loc option\n (* inherit CE\n inherit CE as x\n inherit! CE\n inherit! CE as x\n *)\n | Pcf_val of (string loc * mutable_flag * class_field_kind)\n (* val x = E\n val virtual x: T\n *)\n | Pcf_method of (string loc * private_flag * class_field_kind)\n (* method x = E (E can be a Pexp_poly)\n method virtual x: T (T can be a Ptyp_poly)\n *)\n | Pcf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pcf_initializer of expression\n (* initializer E *)\n | Pcf_attribute of attribute\n (* [@@@id] *)\n | Pcf_extension of extension\n (* [%%id] *)\n\n and class_field_kind (*IF_CURRENT = Parsetree.class_field_kind *) =\n | Cfk_virtual of core_type\n | Cfk_concrete of override_flag * expression\n\n and class_declaration = class_expr class_infos\n\n (** {2 Module language} *)\n\n (* Type expressions for the module language *)\n\n and module_type (*IF_CURRENT = Parsetree.module_type *) =\n {\n pmty_desc: module_type_desc;\n pmty_loc: Location.t;\n pmty_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and module_type_desc (*IF_CURRENT = Parsetree.module_type_desc *) =\n | Pmty_ident of Longident.t loc\n (* S *)\n | Pmty_signature of signature\n (* sig ... end *)\n | Pmty_functor of string loc * module_type option * module_type\n (* functor(X : MT1) -> MT2 *)\n | Pmty_with of module_type * with_constraint list\n (* MT with ... *)\n | Pmty_typeof of module_expr\n (* module type of ME *)\n | Pmty_extension of extension\n (* [%id] *)\n | Pmty_alias of Longident.t loc\n (* (module M) *)\n\n and signature = signature_item list\n\n and signature_item (*IF_CURRENT = Parsetree.signature_item *) =\n {\n psig_desc: signature_item_desc;\n psig_loc: Location.t;\n }\n\n and signature_item_desc (*IF_CURRENT = Parsetree.signature_item_desc *) =\n | Psig_value of value_description\n (*\n val x: T\n external x: T = \"s1\" ... \"sn\"\n *)\n | Psig_type of rec_flag * type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Psig_typext of type_extension\n (* type t1 += ... *)\n | Psig_exception of extension_constructor\n (* exception C of T *)\n | Psig_module of module_declaration\n (* module X : MT *)\n | Psig_recmodule of module_declaration list\n (* module rec X1 : MT1 and ... and Xn : MTn *)\n | Psig_modtype of module_type_declaration\n (* module type S = MT\n module type S *)\n | Psig_open of open_description\n (* open X *)\n | Psig_include of include_description\n (* include MT *)\n | Psig_class of class_description list\n (* class c1 : ... and ... and cn : ... *)\n | Psig_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Psig_attribute of attribute\n (* [@@@id] *)\n | Psig_extension of extension * attributes\n (* [%%id] *)\n\n and module_declaration (*IF_CURRENT = Parsetree.module_declaration *) =\n {\n pmd_name: string loc;\n pmd_type: module_type;\n pmd_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pmd_loc: Location.t;\n }\n (* S : MT *)\n\n and module_type_declaration (*IF_CURRENT = Parsetree.module_type_declaration *) =\n {\n pmtd_name: string loc;\n pmtd_type: module_type option;\n pmtd_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pmtd_loc: Location.t;\n }\n (* S = MT\n S (abstract module type declaration, pmtd_type = None)\n *)\n\n and open_description (*IF_CURRENT = Parsetree.open_description *) =\n {\n popen_lid: Longident.t loc;\n popen_override: override_flag;\n popen_loc: Location.t;\n popen_attributes: attributes;\n }\n (* open! X - popen_override = Override (silences the 'used identifier\n shadowing' warning)\n open X - popen_override = Fresh\n *)\n\n and 'a include_infos (*IF_CURRENT = 'a Parsetree.include_infos *) =\n {\n pincl_mod: 'a;\n pincl_loc: Location.t;\n pincl_attributes: attributes;\n }\n\n and include_description = module_type include_infos\n (* include MT *)\n\n and include_declaration = module_expr include_infos\n (* include ME *)\n\n and with_constraint (*IF_CURRENT = Parsetree.with_constraint *) =\n | Pwith_type of Longident.t loc * type_declaration\n (* with type X.t = ...\n\n Note: the last component of the longident must match\n the name of the type_declaration. *)\n | Pwith_module of Longident.t loc * Longident.t loc\n (* with module X.Y = Z *)\n | Pwith_typesubst of type_declaration\n (* with type t := ... *)\n | Pwith_modsubst of string loc * Longident.t loc\n (* with module X := Z *)\n\n (* Value expressions for the module language *)\n\n and module_expr (*IF_CURRENT = Parsetree.module_expr *) =\n {\n pmod_desc: module_expr_desc;\n pmod_loc: Location.t;\n pmod_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and module_expr_desc (*IF_CURRENT = Parsetree.module_expr_desc *) =\n | Pmod_ident of Longident.t loc\n (* X *)\n | Pmod_structure of structure\n (* struct ... end *)\n | Pmod_functor of string loc * module_type option * module_expr\n (* functor(X : MT1) -> ME *)\n | Pmod_apply of module_expr * module_expr\n (* ME1(ME2) *)\n | Pmod_constraint of module_expr * module_type\n (* (ME : MT) *)\n | Pmod_unpack of expression\n (* (val E) *)\n | Pmod_extension of extension\n (* [%id] *)\n\n and structure = structure_item list\n\n and structure_item (*IF_CURRENT = Parsetree.structure_item *) =\n {\n pstr_desc: structure_item_desc;\n pstr_loc: Location.t;\n }\n\n and structure_item_desc (*IF_CURRENT = Parsetree.structure_item_desc *) =\n | Pstr_eval of expression * attributes\n (* E *)\n | Pstr_value of rec_flag * value_binding list\n (* let P1 = E1 and ... and Pn = EN (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN (flag = Recursive)\n *)\n | Pstr_primitive of value_description\n (* val x: T\n external x: T = \"s1\" ... \"sn\" *)\n | Pstr_type of rec_flag * type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Pstr_typext of type_extension\n (* type t1 += ... *)\n | Pstr_exception of extension_constructor\n (* exception C of T\n exception C = M.X *)\n | Pstr_module of module_binding\n (* module X = ME *)\n | Pstr_recmodule of module_binding list\n (* module rec X1 = ME1 and ... and Xn = MEn *)\n | Pstr_modtype of module_type_declaration\n (* module type S = MT *)\n | Pstr_open of open_description\n (* open X *)\n | Pstr_class of class_declaration list\n (* class c1 = ... and ... and cn = ... *)\n | Pstr_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Pstr_include of include_declaration\n (* include ME *)\n | Pstr_attribute of attribute\n (* [@@@id] *)\n | Pstr_extension of extension * attributes\n (* [%%id] *)\n\n and value_binding (*IF_CURRENT = Parsetree.value_binding *) =\n {\n pvb_pat: pattern;\n pvb_expr: expression;\n pvb_attributes: attributes;\n pvb_loc: Location.t;\n }\n\n and module_binding (*IF_CURRENT = Parsetree.module_binding *) =\n {\n pmb_name: string loc;\n pmb_expr: module_expr;\n pmb_attributes: attributes;\n pmb_loc: Location.t;\n }\n (* X = ME *)\n\n (** {2 Toplevel} *)\n\n (* Toplevel phrases *)\n\n type toplevel_phrase (*IF_CURRENT = Parsetree.toplevel_phrase *) =\n | Ptop_def of structure\n | Ptop_dir of string * directive_argument\n (* #use, #load ... *)\n\n and directive_argument (*IF_CURRENT = Parsetree.directive_argument *) =\n | Pdir_none\n | Pdir_string of string\n | Pdir_int of string * char option\n | Pdir_ident of Longident.t\n | Pdir_bool of bool\n\nend\n\nmodule Config = struct\n let ast_impl_magic_number = \"Caml1999M020\"\n let ast_intf_magic_number = \"Caml1999N018\"\nend\n","(**************************************************************************)\n(* *)\n(* OCaml Migrate Parsetree *)\n(* *)\n(* Frédéric Bour *)\n(* Jérémie Dimino and Leo White, Jane Street Europe *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* Alain Frisch, LexiFi *)\n(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 2017 Institut National de Recherche en Informatique et *)\n(* en Automatique (INRIA). *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nmodule Asttypes = struct\n (** Auxiliary AST types used by parsetree and typedtree. *)\n\n type constant (*IF_CURRENT = Asttypes.constant *) =\n Const_int of int\n | Const_char of char\n | Const_string of string * string option\n | Const_float of string\n | Const_int32 of int32\n | Const_int64 of int64\n | Const_nativeint of nativeint\n\n type rec_flag (*IF_CURRENT = Asttypes.rec_flag *) = Nonrecursive | Recursive\n\n type direction_flag (*IF_CURRENT = Asttypes.direction_flag *) = Upto | Downto\n\n (* Order matters, used in polymorphic comparison *)\n type private_flag (*IF_CURRENT = Asttypes.private_flag *) = Private | Public\n\n type mutable_flag (*IF_CURRENT = Asttypes.mutable_flag *) = Immutable | Mutable\n\n type virtual_flag (*IF_CURRENT = Asttypes.virtual_flag *) = Virtual | Concrete\n\n type override_flag (*IF_CURRENT = Asttypes.override_flag *) = Override | Fresh\n\n type closed_flag (*IF_CURRENT = Asttypes.closed_flag *) = Closed | Open\n\n type label = string\n\n type arg_label (*IF_CURRENT = Asttypes.arg_label *) =\n Nolabel\n | Labelled of string (* label:T -> ... *)\n | Optional of string (* ?label:T -> ... *)\n\n type 'a loc = 'a Location.loc = {\n txt : 'a;\n loc : Location.t;\n }\n\n\n type variance (*IF_CURRENT = Asttypes.variance *) =\n | Covariant\n | Contravariant\n | Invariant\nend\n\nmodule Parsetree = struct\n (** Abstract syntax tree produced by parsing *)\n\n open Asttypes\n\n type constant (*IF_CURRENT = Parsetree.constant *) =\n Pconst_integer of string * char option\n (* 3 3l 3L 3n\n\n Suffixes [g-z][G-Z] are accepted by the parser.\n Suffixes except 'l', 'L' and 'n' are rejected by the typechecker\n *)\n | Pconst_char of char\n (* 'c' *)\n | Pconst_string of string * string option\n (* \"constant\"\n {delim|other constant|delim}\n *)\n | Pconst_float of string * char option\n (* 3.4 2e5 1.4e-4\n\n Suffixes [g-z][G-Z] are accepted by the parser.\n Suffixes are rejected by the typechecker.\n *)\n\n (** {2 Extension points} *)\n\n type attribute = string loc * payload\n (* [@id ARG]\n [@@id ARG]\n\n Metadata containers passed around within the AST.\n The compiler ignores unknown attributes.\n *)\n\n and extension = string loc * payload\n (* [%id ARG]\n [%%id ARG]\n\n Sub-language placeholder -- rejected by the typechecker.\n *)\n\n and attributes = attribute list\n\n and payload (*IF_CURRENT = Parsetree.payload *) =\n | PStr of structure\n | PSig of signature (* : SIG *)\n | PTyp of core_type (* : T *)\n | PPat of pattern * expression option (* ? P or ? P when E *)\n\n (** {2 Core language} *)\n\n (* Type expressions *)\n\n and core_type (*IF_CURRENT = Parsetree.core_type *) =\n {\n ptyp_desc: core_type_desc;\n ptyp_loc: Location.t;\n ptyp_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and core_type_desc (*IF_CURRENT = Parsetree.core_type_desc *) =\n | Ptyp_any\n (* _ *)\n | Ptyp_var of string\n (* 'a *)\n | Ptyp_arrow of arg_label * core_type * core_type\n (* T1 -> T2 Simple\n ~l:T1 -> T2 Labelled\n ?l:T1 -> T2 Otional\n *)\n | Ptyp_tuple of core_type list\n (* T1 * ... * Tn\n\n Invariant: n >= 2\n *)\n | Ptyp_constr of Longident.t loc * core_type list\n (* tconstr\n T tconstr\n (T1, ..., Tn) tconstr\n *)\n | Ptyp_object of (string * attributes * core_type) list * closed_flag\n (* < l1:T1; ...; ln:Tn > (flag = Closed)\n < l1:T1; ...; ln:Tn; .. > (flag = Open)\n *)\n | Ptyp_class of Longident.t loc * core_type list\n (* #tconstr\n T #tconstr\n (T1, ..., Tn) #tconstr\n *)\n | Ptyp_alias of core_type * string\n (* T as 'a *)\n | Ptyp_variant of row_field list * closed_flag * label list option\n (* [ `A|`B ] (flag = Closed; labels = None)\n [> `A|`B ] (flag = Open; labels = None)\n [< `A|`B ] (flag = Closed; labels = Some [])\n [< `A|`B > `X `Y ](flag = Closed; labels = Some [\"X\";\"Y\"])\n *)\n | Ptyp_poly of string list * core_type\n (* 'a1 ... 'an. T\n\n Can only appear in the following context:\n\n - As the core_type of a Ppat_constraint node corresponding\n to a constraint on a let-binding: let x : 'a1 ... 'an. T\n = e ...\n\n - Under Cfk_virtual for methods (not values).\n\n - As the core_type of a Pctf_method node.\n\n - As the core_type of a Pexp_poly node.\n\n - As the pld_type field of a label_declaration.\n\n - As a core_type of a Ptyp_object node.\n *)\n\n | Ptyp_package of package_type\n (* (module S) *)\n | Ptyp_extension of extension\n (* [%id] *)\n\n and package_type = Longident.t loc * (Longident.t loc * core_type) list\n (*\n (module S)\n (module S with type t1 = T1 and ... and tn = Tn)\n *)\n\n and row_field (*IF_CURRENT = Parsetree.row_field *) =\n | Rtag of label * attributes * bool * core_type list\n (* [`A] ( true, [] )\n [`A of T] ( false, [T] )\n [`A of T1 & .. & Tn] ( false, [T1;...Tn] )\n [`A of & T1 & .. & Tn] ( true, [T1;...Tn] )\n\n - The 2nd field is true if the tag contains a\n constant (empty) constructor.\n - '&' occurs when several types are used for the same constructor\n (see 4.2 in the manual)\n\n - TODO: switch to a record representation, and keep location\n *)\n | Rinherit of core_type\n (* [ T ] *)\n\n (* Patterns *)\n\n and pattern (*IF_CURRENT = Parsetree.pattern *) =\n {\n ppat_desc: pattern_desc;\n ppat_loc: Location.t;\n ppat_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and pattern_desc (*IF_CURRENT = Parsetree.pattern_desc *) =\n | Ppat_any\n (* _ *)\n | Ppat_var of string loc\n (* x *)\n | Ppat_alias of pattern * string loc\n (* P as 'a *)\n | Ppat_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Ppat_interval of constant * constant\n (* 'a'..'z'\n\n Other forms of interval are recognized by the parser\n but rejected by the type-checker. *)\n | Ppat_tuple of pattern list\n (* (P1, ..., Pn)\n\n Invariant: n >= 2\n *)\n | Ppat_construct of Longident.t loc * pattern option\n (* C None\n C P Some P\n C (P1, ..., Pn) Some (Ppat_tuple [P1; ...; Pn])\n *)\n | Ppat_variant of label * pattern option\n (* `A (None)\n `A P (Some P)\n *)\n | Ppat_record of (Longident.t loc * pattern) list * closed_flag\n (* { l1=P1; ...; ln=Pn } (flag = Closed)\n { l1=P1; ...; ln=Pn; _} (flag = Open)\n\n Invariant: n > 0\n *)\n | Ppat_array of pattern list\n (* [| P1; ...; Pn |] *)\n | Ppat_or of pattern * pattern\n (* P1 | P2 *)\n | Ppat_constraint of pattern * core_type\n (* (P : T) *)\n | Ppat_type of Longident.t loc\n (* #tconst *)\n | Ppat_lazy of pattern\n (* lazy P *)\n | Ppat_unpack of string loc\n (* (module P)\n Note: (module P : S) is represented as\n Ppat_constraint(Ppat_unpack, Ptyp_package)\n *)\n | Ppat_exception of pattern\n (* exception P *)\n | Ppat_extension of extension\n (* [%id] *)\n | Ppat_open of Longident.t loc * pattern\n\n (* Value expressions *)\n\n and expression (*IF_CURRENT = Parsetree.expression *) =\n {\n pexp_desc: expression_desc;\n pexp_loc: Location.t;\n pexp_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and expression_desc (*IF_CURRENT = Parsetree.expression_desc *) =\n | Pexp_ident of Longident.t loc\n (* x\n M.x\n *)\n | Pexp_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Pexp_let of rec_flag * value_binding list * expression\n (* let P1 = E1 and ... and Pn = EN in E (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in E (flag = Recursive)\n *)\n | Pexp_function of case list\n (* function P1 -> E1 | ... | Pn -> En *)\n | Pexp_fun of arg_label * expression option * pattern * expression\n (* fun P -> E1 (Simple, None)\n fun ~l:P -> E1 (Labelled l, None)\n fun ?l:P -> E1 (Optional l, None)\n fun ?l:(P = E0) -> E1 (Optional l, Some E0)\n\n Notes:\n - If E0 is provided, only Optional is allowed.\n - \"fun P1 P2 .. Pn -> E1\" is represented as nested Pexp_fun.\n - \"let f P = E\" is represented using Pexp_fun.\n *)\n | Pexp_apply of expression * (arg_label * expression) list\n (* E0 ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pexp_match of expression * case list\n (* match E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_try of expression * case list\n (* try E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_tuple of expression list\n (* (E1, ..., En)\n\n Invariant: n >= 2\n *)\n | Pexp_construct of Longident.t loc * expression option\n (* C None\n C E Some E\n C (E1, ..., En) Some (Pexp_tuple[E1;...;En])\n *)\n | Pexp_variant of label * expression option\n (* `A (None)\n `A E (Some E)\n *)\n | Pexp_record of (Longident.t loc * expression) list * expression option\n (* { l1=P1; ...; ln=Pn } (None)\n { E0 with l1=P1; ...; ln=Pn } (Some E0)\n\n Invariant: n > 0\n *)\n | Pexp_field of expression * Longident.t loc\n (* E.l *)\n | Pexp_setfield of expression * Longident.t loc * expression\n (* E1.l <- E2 *)\n | Pexp_array of expression list\n (* [| E1; ...; En |] *)\n | Pexp_ifthenelse of expression * expression * expression option\n (* if E1 then E2 else E3 *)\n | Pexp_sequence of expression * expression\n (* E1; E2 *)\n | Pexp_while of expression * expression\n (* while E1 do E2 done *)\n | Pexp_for of\n pattern * expression * expression * direction_flag * expression\n (* for i = E1 to E2 do E3 done (flag = Upto)\n for i = E1 downto E2 do E3 done (flag = Downto)\n *)\n | Pexp_constraint of expression * core_type\n (* (E : T) *)\n | Pexp_coerce of expression * core_type option * core_type\n (* (E :> T) (None, T)\n (E : T0 :> T) (Some T0, T)\n *)\n | Pexp_send of expression * string\n (* E # m *)\n | Pexp_new of Longident.t loc\n (* new M.c *)\n | Pexp_setinstvar of string loc * expression\n (* x <- 2 *)\n | Pexp_override of (string loc * expression) list\n (* {< x1 = E1; ...; Xn = En >} *)\n | Pexp_letmodule of string loc * module_expr * expression\n (* let module M = ME in E *)\n | Pexp_letexception of extension_constructor * expression\n (* let exception C in E *)\n | Pexp_assert of expression\n (* assert E\n Note: \"assert false\" is treated in a special way by the\n type-checker. *)\n | Pexp_lazy of expression\n (* lazy E *)\n | Pexp_poly of expression * core_type option\n (* Used for method bodies.\n\n Can only be used as the expression under Cfk_concrete\n for methods (not values). *)\n | Pexp_object of class_structure\n (* object ... end *)\n | Pexp_newtype of string * expression\n (* fun (type t) -> E *)\n | Pexp_pack of module_expr\n (* (module ME)\n\n (module ME : S) is represented as\n Pexp_constraint(Pexp_pack, Ptyp_package S) *)\n | Pexp_open of override_flag * Longident.t loc * expression\n (* let open M in E\n let! open M in E\n *)\n | Pexp_extension of extension\n (* [%id] *)\n | Pexp_unreachable\n (* . *)\n\n and case (*IF_CURRENT = Parsetree.case *) = (* (P -> E) or (P when E0 -> E) *)\n {\n pc_lhs: pattern;\n pc_guard: expression option;\n pc_rhs: expression;\n }\n\n (* Value descriptions *)\n\n and value_description (*IF_CURRENT = Parsetree.value_description *) =\n {\n pval_name: string loc;\n pval_type: core_type;\n pval_prim: string list;\n pval_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pval_loc: Location.t;\n }\n\n (*\n val x: T (prim = [])\n external x: T = \"s1\" ... \"sn\" (prim = [\"s1\";...\"sn\"])\n *)\n\n (* Type declarations *)\n\n and type_declaration (*IF_CURRENT = Parsetree.type_declaration *) =\n {\n ptype_name: string loc;\n ptype_params: (core_type * variance) list;\n (* ('a1,...'an) t; None represents _*)\n ptype_cstrs: (core_type * core_type * Location.t) list;\n (* ... constraint T1=T1' ... constraint Tn=Tn' *)\n ptype_kind: type_kind;\n ptype_private: private_flag; (* = private ... *)\n ptype_manifest: core_type option; (* = T *)\n ptype_attributes: attributes; (* ... [@@id1] [@@id2] *)\n ptype_loc: Location.t;\n }\n\n (*\n type t (abstract, no manifest)\n type t = T0 (abstract, manifest=T0)\n type t = C of T | ... (variant, no manifest)\n type t = T0 = C of T | ... (variant, manifest=T0)\n type t = {l: T; ...} (record, no manifest)\n type t = T0 = {l : T; ...} (record, manifest=T0)\n type t = .. (open, no manifest)\n *)\n\n and type_kind (*IF_CURRENT = Parsetree.type_kind *) =\n | Ptype_abstract\n | Ptype_variant of constructor_declaration list\n (* Invariant: non-empty list *)\n | Ptype_record of label_declaration list\n (* Invariant: non-empty list *)\n | Ptype_open\n\n and label_declaration (*IF_CURRENT = Parsetree.label_declaration *) =\n {\n pld_name: string loc;\n pld_mutable: mutable_flag;\n pld_type: core_type;\n pld_loc: Location.t;\n pld_attributes: attributes; (* l [@id1] [@id2] : T *)\n }\n\n (* { ...; l: T; ... } (mutable=Immutable)\n { ...; mutable l: T; ... } (mutable=Mutable)\n\n Note: T can be a Ptyp_poly.\n *)\n\n and constructor_declaration (*IF_CURRENT = Parsetree.constructor_declaration *) =\n {\n pcd_name: string loc;\n pcd_args: constructor_arguments;\n pcd_res: core_type option;\n pcd_loc: Location.t;\n pcd_attributes: attributes; (* C [@id1] [@id2] of ... *)\n }\n\n and constructor_arguments (*IF_CURRENT = Parsetree.constructor_arguments *) =\n | Pcstr_tuple of core_type list\n | Pcstr_record of label_declaration list\n\n (*\n | C of T1 * ... * Tn (res = None, args = Pcstr_tuple [])\n | C: T0 (res = Some T0, args = [])\n | C: T1 * ... * Tn -> T0 (res = Some T0, args = Pcstr_tuple)\n | C of {...} (res = None, args = Pcstr_record)\n | C: {...} -> T0 (res = Some T0, args = Pcstr_record)\n | C of {...} as t (res = None, args = Pcstr_record)\n *)\n\n and type_extension (*IF_CURRENT = Parsetree.type_extension *) =\n {\n ptyext_path: Longident.t loc;\n ptyext_params: (core_type * variance) list;\n ptyext_constructors: extension_constructor list;\n ptyext_private: private_flag;\n ptyext_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n (*\n type t += ...\n *)\n\n and extension_constructor (*IF_CURRENT = Parsetree.extension_constructor *) =\n {\n pext_name: string loc;\n pext_kind : extension_constructor_kind;\n pext_loc : Location.t;\n pext_attributes: attributes; (* C [@id1] [@id2] of ... *)\n }\n\n and extension_constructor_kind (*IF_CURRENT = Parsetree.extension_constructor_kind *) =\n Pext_decl of constructor_arguments * core_type option\n (*\n | C of T1 * ... * Tn ([T1; ...; Tn], None)\n | C: T0 ([], Some T0)\n | C: T1 * ... * Tn -> T0 ([T1; ...; Tn], Some T0)\n *)\n | Pext_rebind of Longident.t loc\n (*\n | C = D\n *)\n\n (** {2 Class language} *)\n\n (* Type expressions for the class language *)\n\n and class_type (*IF_CURRENT = Parsetree.class_type *) =\n {\n pcty_desc: class_type_desc;\n pcty_loc: Location.t;\n pcty_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and class_type_desc (*IF_CURRENT = Parsetree.class_type_desc *) =\n | Pcty_constr of Longident.t loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcty_signature of class_signature\n (* object ... end *)\n | Pcty_arrow of arg_label * core_type * class_type\n (* T -> CT Simple\n ~l:T -> CT Labelled l\n ?l:T -> CT Optional l\n *)\n | Pcty_extension of extension\n (* [%id] *)\n\n and class_signature (*IF_CURRENT = Parsetree.class_signature *) =\n {\n pcsig_self: core_type;\n pcsig_fields: class_type_field list;\n }\n (* object('selfpat) ... end\n object ... end (self = Ptyp_any)\n *)\n\n and class_type_field (*IF_CURRENT = Parsetree.class_type_field *) =\n {\n pctf_desc: class_type_field_desc;\n pctf_loc: Location.t;\n pctf_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and class_type_field_desc (*IF_CURRENT = Parsetree.class_type_field_desc *) =\n | Pctf_inherit of class_type\n (* inherit CT *)\n | Pctf_val of (string * mutable_flag * virtual_flag * core_type)\n (* val x: T *)\n | Pctf_method of (string * private_flag * virtual_flag * core_type)\n (* method x: T\n\n Note: T can be a Ptyp_poly.\n *)\n | Pctf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pctf_attribute of attribute\n (* [@@@id] *)\n | Pctf_extension of extension\n (* [%%id] *)\n\n and 'a class_infos (*IF_CURRENT = 'a Parsetree.class_infos *) =\n {\n pci_virt: virtual_flag;\n pci_params: (core_type * variance) list;\n pci_name: string loc;\n pci_expr: 'a;\n pci_loc: Location.t;\n pci_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n (* class c = ...\n class ['a1,...,'an] c = ...\n class virtual c = ...\n\n Also used for \"class type\" declaration.\n *)\n\n and class_description = class_type class_infos\n\n and class_type_declaration = class_type class_infos\n\n (* Value expressions for the class language *)\n\n and class_expr (*IF_CURRENT = Parsetree.class_expr *) =\n {\n pcl_desc: class_expr_desc;\n pcl_loc: Location.t;\n pcl_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and class_expr_desc (*IF_CURRENT = Parsetree.class_expr_desc *) =\n | Pcl_constr of Longident.t loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcl_structure of class_structure\n (* object ... end *)\n | Pcl_fun of arg_label * expression option * pattern * class_expr\n (* fun P -> CE (Simple, None)\n fun ~l:P -> CE (Labelled l, None)\n fun ?l:P -> CE (Optional l, None)\n fun ?l:(P = E0) -> CE (Optional l, Some E0)\n *)\n | Pcl_apply of class_expr * (arg_label * expression) list\n (* CE ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pcl_let of rec_flag * value_binding list * class_expr\n (* let P1 = E1 and ... and Pn = EN in CE (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in CE (flag = Recursive)\n *)\n | Pcl_constraint of class_expr * class_type\n (* (CE : CT) *)\n | Pcl_extension of extension\n (* [%id] *)\n\n and class_structure (*IF_CURRENT = Parsetree.class_structure *) =\n {\n pcstr_self: pattern;\n pcstr_fields: class_field list;\n }\n (* object(selfpat) ... end\n object ... end (self = Ppat_any)\n *)\n\n and class_field (*IF_CURRENT = Parsetree.class_field *) =\n {\n pcf_desc: class_field_desc;\n pcf_loc: Location.t;\n pcf_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and class_field_desc (*IF_CURRENT = Parsetree.class_field_desc *) =\n | Pcf_inherit of override_flag * class_expr * string option\n (* inherit CE\n inherit CE as x\n inherit! CE\n inherit! CE as x\n *)\n | Pcf_val of (string loc * mutable_flag * class_field_kind)\n (* val x = E\n val virtual x: T\n *)\n | Pcf_method of (string loc * private_flag * class_field_kind)\n (* method x = E (E can be a Pexp_poly)\n method virtual x: T (T can be a Ptyp_poly)\n *)\n | Pcf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pcf_initializer of expression\n (* initializer E *)\n | Pcf_attribute of attribute\n (* [@@@id] *)\n | Pcf_extension of extension\n (* [%%id] *)\n\n and class_field_kind (*IF_CURRENT = Parsetree.class_field_kind *) =\n | Cfk_virtual of core_type\n | Cfk_concrete of override_flag * expression\n\n and class_declaration = class_expr class_infos\n\n (** {2 Module language} *)\n\n (* Type expressions for the module language *)\n\n and module_type (*IF_CURRENT = Parsetree.module_type *) =\n {\n pmty_desc: module_type_desc;\n pmty_loc: Location.t;\n pmty_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and module_type_desc (*IF_CURRENT = Parsetree.module_type_desc *) =\n | Pmty_ident of Longident.t loc\n (* S *)\n | Pmty_signature of signature\n (* sig ... end *)\n | Pmty_functor of string loc * module_type option * module_type\n (* functor(X : MT1) -> MT2 *)\n | Pmty_with of module_type * with_constraint list\n (* MT with ... *)\n | Pmty_typeof of module_expr\n (* module type of ME *)\n | Pmty_extension of extension\n (* [%id] *)\n | Pmty_alias of Longident.t loc\n (* (module M) *)\n\n and signature = signature_item list\n\n and signature_item (*IF_CURRENT = Parsetree.signature_item *) =\n {\n psig_desc: signature_item_desc;\n psig_loc: Location.t;\n }\n\n and signature_item_desc (*IF_CURRENT = Parsetree.signature_item_desc *) =\n | Psig_value of value_description\n (*\n val x: T\n external x: T = \"s1\" ... \"sn\"\n *)\n | Psig_type of rec_flag * type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Psig_typext of type_extension\n (* type t1 += ... *)\n | Psig_exception of extension_constructor\n (* exception C of T *)\n | Psig_module of module_declaration\n (* module X : MT *)\n | Psig_recmodule of module_declaration list\n (* module rec X1 : MT1 and ... and Xn : MTn *)\n | Psig_modtype of module_type_declaration\n (* module type S = MT\n module type S *)\n | Psig_open of open_description\n (* open X *)\n | Psig_include of include_description\n (* include MT *)\n | Psig_class of class_description list\n (* class c1 : ... and ... and cn : ... *)\n | Psig_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Psig_attribute of attribute\n (* [@@@id] *)\n | Psig_extension of extension * attributes\n (* [%%id] *)\n\n and module_declaration (*IF_CURRENT = Parsetree.module_declaration *) =\n {\n pmd_name: string loc;\n pmd_type: module_type;\n pmd_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pmd_loc: Location.t;\n }\n (* S : MT *)\n\n and module_type_declaration (*IF_CURRENT = Parsetree.module_type_declaration *) =\n {\n pmtd_name: string loc;\n pmtd_type: module_type option;\n pmtd_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pmtd_loc: Location.t;\n }\n (* S = MT\n S (abstract module type declaration, pmtd_type = None)\n *)\n\n and open_description (*IF_CURRENT = Parsetree.open_description *) =\n {\n popen_lid: Longident.t loc;\n popen_override: override_flag;\n popen_loc: Location.t;\n popen_attributes: attributes;\n }\n (* open! X - popen_override = Override (silences the 'used identifier\n shadowing' warning)\n open X - popen_override = Fresh\n *)\n\n and 'a include_infos (*IF_CURRENT = 'a Parsetree.include_infos *) =\n {\n pincl_mod: 'a;\n pincl_loc: Location.t;\n pincl_attributes: attributes;\n }\n\n and include_description = module_type include_infos\n (* include MT *)\n\n and include_declaration = module_expr include_infos\n (* include ME *)\n\n and with_constraint (*IF_CURRENT = Parsetree.with_constraint *) =\n | Pwith_type of Longident.t loc * type_declaration\n (* with type X.t = ...\n\n Note: the last component of the longident must match\n the name of the type_declaration. *)\n | Pwith_module of Longident.t loc * Longident.t loc\n (* with module X.Y = Z *)\n | Pwith_typesubst of type_declaration\n (* with type t := ... *)\n | Pwith_modsubst of string loc * Longident.t loc\n (* with module X := Z *)\n\n (* Value expressions for the module language *)\n\n and module_expr (*IF_CURRENT = Parsetree.module_expr *) =\n {\n pmod_desc: module_expr_desc;\n pmod_loc: Location.t;\n pmod_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and module_expr_desc (*IF_CURRENT = Parsetree.module_expr_desc *) =\n | Pmod_ident of Longident.t loc\n (* X *)\n | Pmod_structure of structure\n (* struct ... end *)\n | Pmod_functor of string loc * module_type option * module_expr\n (* functor(X : MT1) -> ME *)\n | Pmod_apply of module_expr * module_expr\n (* ME1(ME2) *)\n | Pmod_constraint of module_expr * module_type\n (* (ME : MT) *)\n | Pmod_unpack of expression\n (* (val E) *)\n | Pmod_extension of extension\n (* [%id] *)\n\n and structure = structure_item list\n\n and structure_item (*IF_CURRENT = Parsetree.structure_item *) =\n {\n pstr_desc: structure_item_desc;\n pstr_loc: Location.t;\n }\n\n and structure_item_desc (*IF_CURRENT = Parsetree.structure_item_desc *) =\n | Pstr_eval of expression * attributes\n (* E *)\n | Pstr_value of rec_flag * value_binding list\n (* let P1 = E1 and ... and Pn = EN (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN (flag = Recursive)\n *)\n | Pstr_primitive of value_description\n (* val x: T\n external x: T = \"s1\" ... \"sn\" *)\n | Pstr_type of rec_flag * type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Pstr_typext of type_extension\n (* type t1 += ... *)\n | Pstr_exception of extension_constructor\n (* exception C of T\n exception C = M.X *)\n | Pstr_module of module_binding\n (* module X = ME *)\n | Pstr_recmodule of module_binding list\n (* module rec X1 = ME1 and ... and Xn = MEn *)\n | Pstr_modtype of module_type_declaration\n (* module type S = MT *)\n | Pstr_open of open_description\n (* open X *)\n | Pstr_class of class_declaration list\n (* class c1 = ... and ... and cn = ... *)\n | Pstr_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Pstr_include of include_declaration\n (* include ME *)\n | Pstr_attribute of attribute\n (* [@@@id] *)\n | Pstr_extension of extension * attributes\n (* [%%id] *)\n\n and value_binding (*IF_CURRENT = Parsetree.value_binding *) =\n {\n pvb_pat: pattern;\n pvb_expr: expression;\n pvb_attributes: attributes;\n pvb_loc: Location.t;\n }\n\n and module_binding (*IF_CURRENT = Parsetree.module_binding *) =\n {\n pmb_name: string loc;\n pmb_expr: module_expr;\n pmb_attributes: attributes;\n pmb_loc: Location.t;\n }\n (* X = ME *)\n\n (** {2 Toplevel} *)\n\n (* Toplevel phrases *)\n\n type toplevel_phrase (*IF_CURRENT = Parsetree.toplevel_phrase *) =\n | Ptop_def of structure\n | Ptop_dir of string * directive_argument\n (* #use, #load ... *)\n\n and directive_argument (*IF_CURRENT = Parsetree.directive_argument *) =\n | Pdir_none\n | Pdir_string of string\n | Pdir_int of string * char option\n | Pdir_ident of Longident.t\n | Pdir_bool of bool\nend\n\nmodule Config = struct\n let ast_impl_magic_number = \"Caml1999M020\"\n let ast_intf_magic_number = \"Caml1999N018\"\nend\n","(**************************************************************************)\n(* *)\n(* OCaml Migrate Parsetree *)\n(* *)\n(* Frédéric Bour *)\n(* Jérémie Dimino and Leo White, Jane Street Europe *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* Alain Frisch, LexiFi *)\n(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 2017 Institut National de Recherche en Informatique et *)\n(* en Automatique (INRIA). *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nmodule Asttypes = struct\n (* Auxiliary a.s.t. types used by parsetree and typedtree. *)\n\n type constant (*IF_CURRENT = Asttypes.constant *) =\n Const_int of int\n | Const_char of char\n | Const_string of string * string option\n | Const_float of string\n | Const_int32 of int32\n | Const_int64 of int64\n | Const_nativeint of nativeint\n\n type rec_flag (*IF_CURRENT = Asttypes.rec_flag *) = Nonrecursive | Recursive\n\n type direction_flag (*IF_CURRENT = Asttypes.direction_flag *) = Upto | Downto\n\n (* Order matters, used in polymorphic comparison *)\n type private_flag (*IF_CURRENT = Asttypes.private_flag *) = Private | Public\n\n type mutable_flag (*IF_CURRENT = Asttypes.mutable_flag *) = Immutable | Mutable\n\n type virtual_flag (*IF_CURRENT = Asttypes.virtual_flag *) = Virtual | Concrete\n\n type override_flag (*IF_CURRENT = Asttypes.override_flag *) = Override | Fresh\n\n type closed_flag (*IF_CURRENT = Asttypes.closed_flag *) = Closed | Open\n\n type label = string\n\n type arg_label (*IF_CURRENT = Asttypes.arg_label *) =\n Nolabel\n | Labelled of string (* label:T -> ... *)\n | Optional of string (* ?label:T -> ... *)\n\n type 'a loc = 'a Location.loc = {\n txt : 'a;\n loc : Location.t;\n }\n\n\n type variance (*IF_CURRENT = Asttypes.variance *) =\n | Covariant\n | Contravariant\n | Invariant\nend\n\nmodule Parsetree = struct\n (** Abstract syntax tree produced by parsing *)\n\n open Asttypes\n\n type constant (*IF_CURRENT = Parsetree.constant *) =\n Pconst_integer of string * char option\n (* 3 3l 3L 3n\n\n Suffixes [g-z][G-Z] are accepted by the parser.\n Suffixes except 'l', 'L' and 'n' are rejected by the typechecker\n *)\n | Pconst_char of char\n (* 'c' *)\n | Pconst_string of string * string option\n (* \"constant\"\n {delim|other constant|delim}\n *)\n | Pconst_float of string * char option\n (* 3.4 2e5 1.4e-4\n\n Suffixes [g-z][G-Z] are accepted by the parser.\n Suffixes are rejected by the typechecker.\n *)\n\n (** {2 Extension points} *)\n\n type attribute = string loc * payload\n (* [@id ARG]\n [@@id ARG]\n\n Metadata containers passed around within the AST.\n The compiler ignores unknown attributes.\n *)\n\n and extension = string loc * payload\n (* [%id ARG]\n [%%id ARG]\n\n Sub-language placeholder -- rejected by the typechecker.\n *)\n\n and attributes = attribute list\n\n and payload (*IF_CURRENT = Parsetree.payload *) =\n | PStr of structure\n | PSig of signature (* : SIG *)\n | PTyp of core_type (* : T *)\n | PPat of pattern * expression option (* ? P or ? P when E *)\n\n (** {2 Core language} *)\n\n (* Type expressions *)\n\n and core_type (*IF_CURRENT = Parsetree.core_type *) =\n {\n ptyp_desc: core_type_desc;\n ptyp_loc: Location.t;\n ptyp_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and core_type_desc (*IF_CURRENT = Parsetree.core_type_desc *) =\n | Ptyp_any\n (* _ *)\n | Ptyp_var of string\n (* 'a *)\n | Ptyp_arrow of arg_label * core_type * core_type\n (* T1 -> T2 Simple\n ~l:T1 -> T2 Labelled\n ?l:T1 -> T2 Otional\n *)\n | Ptyp_tuple of core_type list\n (* T1 * ... * Tn\n\n Invariant: n >= 2\n *)\n | Ptyp_constr of Longident.t loc * core_type list\n (* tconstr\n T tconstr\n (T1, ..., Tn) tconstr\n *)\n | Ptyp_object of (string * attributes * core_type) list * closed_flag\n (* < l1:T1; ...; ln:Tn > (flag = Closed)\n < l1:T1; ...; ln:Tn; .. > (flag = Open)\n *)\n | Ptyp_class of Longident.t loc * core_type list\n (* #tconstr\n T #tconstr\n (T1, ..., Tn) #tconstr\n *)\n | Ptyp_alias of core_type * string\n (* T as 'a *)\n | Ptyp_variant of row_field list * closed_flag * label list option\n (* [ `A|`B ] (flag = Closed; labels = None)\n [> `A|`B ] (flag = Open; labels = None)\n [< `A|`B ] (flag = Closed; labels = Some [])\n [< `A|`B > `X `Y ](flag = Closed; labels = Some [\"X\";\"Y\"])\n *)\n | Ptyp_poly of string list * core_type\n (* 'a1 ... 'an. T\n\n Can only appear in the following context:\n\n - As the core_type of a Ppat_constraint node corresponding\n to a constraint on a let-binding: let x : 'a1 ... 'an. T\n = e ...\n\n - Under Cfk_virtual for methods (not values).\n\n - As the core_type of a Pctf_method node.\n\n - As the core_type of a Pexp_poly node.\n\n - As the pld_type field of a label_declaration.\n\n - As a core_type of a Ptyp_object node.\n *)\n\n | Ptyp_package of package_type\n (* (module S) *)\n | Ptyp_extension of extension\n (* [%id] *)\n\n and package_type = Longident.t loc * (Longident.t loc * core_type) list\n (*\n (module S)\n (module S with type t1 = T1 and ... and tn = Tn)\n *)\n\n and row_field (*IF_CURRENT = Parsetree.row_field *) =\n | Rtag of label * attributes * bool * core_type list\n (* [`A] ( true, [] )\n [`A of T] ( false, [T] )\n [`A of T1 & .. & Tn] ( false, [T1;...Tn] )\n [`A of & T1 & .. & Tn] ( true, [T1;...Tn] )\n\n - The 2nd field is true if the tag contains a\n constant (empty) constructor.\n - '&' occurs when several types are used for the same constructor\n (see 4.2 in the manual)\n\n - TODO: switch to a record representation, and keep location\n *)\n | Rinherit of core_type\n (* [ T ] *)\n\n (* Patterns *)\n\n and pattern (*IF_CURRENT = Parsetree.pattern *) =\n {\n ppat_desc: pattern_desc;\n ppat_loc: Location.t;\n ppat_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and pattern_desc (*IF_CURRENT = Parsetree.pattern_desc *) =\n | Ppat_any\n (* _ *)\n | Ppat_var of string loc\n (* x *)\n | Ppat_alias of pattern * string loc\n (* P as 'a *)\n | Ppat_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Ppat_interval of constant * constant\n (* 'a'..'z'\n\n Other forms of interval are recognized by the parser\n but rejected by the type-checker. *)\n | Ppat_tuple of pattern list\n (* (P1, ..., Pn)\n\n Invariant: n >= 2\n *)\n | Ppat_construct of Longident.t loc * pattern option\n (* C None\n C P Some P\n C (P1, ..., Pn) Some (Ppat_tuple [P1; ...; Pn])\n *)\n | Ppat_variant of label * pattern option\n (* `A (None)\n `A P (Some P)\n *)\n | Ppat_record of (Longident.t loc * pattern) list * closed_flag\n (* { l1=P1; ...; ln=Pn } (flag = Closed)\n { l1=P1; ...; ln=Pn; _} (flag = Open)\n\n Invariant: n > 0\n *)\n | Ppat_array of pattern list\n (* [| P1; ...; Pn |] *)\n | Ppat_or of pattern * pattern\n (* P1 | P2 *)\n | Ppat_constraint of pattern * core_type\n (* (P : T) *)\n | Ppat_type of Longident.t loc\n (* #tconst *)\n | Ppat_lazy of pattern\n (* lazy P *)\n | Ppat_unpack of string loc\n (* (module P)\n Note: (module P : S) is represented as\n Ppat_constraint(Ppat_unpack, Ptyp_package)\n *)\n | Ppat_exception of pattern\n (* exception P *)\n | Ppat_extension of extension\n (* [%id] *)\n\n (* Value expressions *)\n\n and expression (*IF_CURRENT = Parsetree.expression *) =\n {\n pexp_desc: expression_desc;\n pexp_loc: Location.t;\n pexp_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and expression_desc (*IF_CURRENT = Parsetree.expression_desc *) =\n | Pexp_ident of Longident.t loc\n (* x\n M.x\n *)\n | Pexp_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Pexp_let of rec_flag * value_binding list * expression\n (* let P1 = E1 and ... and Pn = EN in E (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in E (flag = Recursive)\n *)\n | Pexp_function of case list\n (* function P1 -> E1 | ... | Pn -> En *)\n | Pexp_fun of arg_label * expression option * pattern * expression\n (* fun P -> E1 (Simple, None)\n fun ~l:P -> E1 (Labelled l, None)\n fun ?l:P -> E1 (Optional l, None)\n fun ?l:(P = E0) -> E1 (Optional l, Some E0)\n\n Notes:\n - If E0 is provided, only Optional is allowed.\n - \"fun P1 P2 .. Pn -> E1\" is represented as nested Pexp_fun.\n - \"let f P = E\" is represented using Pexp_fun.\n *)\n | Pexp_apply of expression * (arg_label * expression) list\n (* E0 ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pexp_match of expression * case list\n (* match E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_try of expression * case list\n (* try E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_tuple of expression list\n (* (E1, ..., En)\n\n Invariant: n >= 2\n *)\n | Pexp_construct of Longident.t loc * expression option\n (* C None\n C E Some E\n C (E1, ..., En) Some (Pexp_tuple[E1;...;En])\n *)\n | Pexp_variant of label * expression option\n (* `A (None)\n `A E (Some E)\n *)\n | Pexp_record of (Longident.t loc * expression) list * expression option\n (* { l1=P1; ...; ln=Pn } (None)\n { E0 with l1=P1; ...; ln=Pn } (Some E0)\n\n Invariant: n > 0\n *)\n | Pexp_field of expression * Longident.t loc\n (* E.l *)\n | Pexp_setfield of expression * Longident.t loc * expression\n (* E1.l <- E2 *)\n | Pexp_array of expression list\n (* [| E1; ...; En |] *)\n | Pexp_ifthenelse of expression * expression * expression option\n (* if E1 then E2 else E3 *)\n | Pexp_sequence of expression * expression\n (* E1; E2 *)\n | Pexp_while of expression * expression\n (* while E1 do E2 done *)\n | Pexp_for of\n pattern * expression * expression * direction_flag * expression\n (* for i = E1 to E2 do E3 done (flag = Upto)\n for i = E1 downto E2 do E3 done (flag = Downto)\n *)\n | Pexp_constraint of expression * core_type\n (* (E : T) *)\n | Pexp_coerce of expression * core_type option * core_type\n (* (E :> T) (None, T)\n (E : T0 :> T) (Some T0, T)\n *)\n | Pexp_send of expression * string\n (* E # m *)\n | Pexp_new of Longident.t loc\n (* new M.c *)\n | Pexp_setinstvar of string loc * expression\n (* x <- 2 *)\n | Pexp_override of (string loc * expression) list\n (* {< x1 = E1; ...; Xn = En >} *)\n | Pexp_letmodule of string loc * module_expr * expression\n (* let module M = ME in E *)\n | Pexp_assert of expression\n (* assert E\n Note: \"assert false\" is treated in a special way by the\n type-checker. *)\n | Pexp_lazy of expression\n (* lazy E *)\n | Pexp_poly of expression * core_type option\n (* Used for method bodies.\n\n Can only be used as the expression under Cfk_concrete\n for methods (not values). *)\n | Pexp_object of class_structure\n (* object ... end *)\n | Pexp_newtype of string * expression\n (* fun (type t) -> E *)\n | Pexp_pack of module_expr\n (* (module ME)\n\n (module ME : S) is represented as\n Pexp_constraint(Pexp_pack, Ptyp_package S) *)\n | Pexp_open of override_flag * Longident.t loc * expression\n (* let open M in E\n let! open M in E\n *)\n | Pexp_extension of extension\n (* [%id] *)\n | Pexp_unreachable\n (* . *)\n\n and case (*IF_CURRENT = Parsetree.case *) = (* (P -> E) or (P when E0 -> E) *)\n {\n pc_lhs: pattern;\n pc_guard: expression option;\n pc_rhs: expression;\n }\n\n (* Value descriptions *)\n\n and value_description (*IF_CURRENT = Parsetree.value_description *) =\n {\n pval_name: string loc;\n pval_type: core_type;\n pval_prim: string list;\n pval_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pval_loc: Location.t;\n }\n\n (*\n val x: T (prim = [])\n external x: T = \"s1\" ... \"sn\" (prim = [\"s1\";...\"sn\"])\n *)\n\n (* Type declarations *)\n\n and type_declaration (*IF_CURRENT = Parsetree.type_declaration *) =\n {\n ptype_name: string loc;\n ptype_params: (core_type * variance) list;\n (* ('a1,...'an) t; None represents _*)\n ptype_cstrs: (core_type * core_type * Location.t) list;\n (* ... constraint T1=T1' ... constraint Tn=Tn' *)\n ptype_kind: type_kind;\n ptype_private: private_flag; (* = private ... *)\n ptype_manifest: core_type option; (* = T *)\n ptype_attributes: attributes; (* ... [@@id1] [@@id2] *)\n ptype_loc: Location.t;\n }\n\n (*\n type t (abstract, no manifest)\n type t = T0 (abstract, manifest=T0)\n type t = C of T | ... (variant, no manifest)\n type t = T0 = C of T | ... (variant, manifest=T0)\n type t = {l: T; ...} (record, no manifest)\n type t = T0 = {l : T; ...} (record, manifest=T0)\n type t = .. (open, no manifest)\n *)\n\n and type_kind (*IF_CURRENT = Parsetree.type_kind *) =\n | Ptype_abstract\n | Ptype_variant of constructor_declaration list\n (* Invariant: non-empty list *)\n | Ptype_record of label_declaration list\n (* Invariant: non-empty list *)\n | Ptype_open\n\n and label_declaration (*IF_CURRENT = Parsetree.label_declaration *) =\n {\n pld_name: string loc;\n pld_mutable: mutable_flag;\n pld_type: core_type;\n pld_loc: Location.t;\n pld_attributes: attributes; (* l [@id1] [@id2] : T *)\n }\n\n (* { ...; l: T; ... } (mutable=Immutable)\n { ...; mutable l: T; ... } (mutable=Mutable)\n\n Note: T can be a Ptyp_poly.\n *)\n\n and constructor_declaration (*IF_CURRENT = Parsetree.constructor_declaration *) =\n {\n pcd_name: string loc;\n pcd_args: constructor_arguments;\n pcd_res: core_type option;\n pcd_loc: Location.t;\n pcd_attributes: attributes; (* C [@id1] [@id2] of ... *)\n }\n\n and constructor_arguments (*IF_CURRENT = Parsetree.constructor_arguments *) =\n | Pcstr_tuple of core_type list\n | Pcstr_record of label_declaration list\n\n (*\n | C of T1 * ... * Tn (res = None, args = Pcstr_tuple [])\n | C: T0 (res = Some T0, args = [])\n | C: T1 * ... * Tn -> T0 (res = Some T0, args = Pcstr_tuple)\n | C of {...} (res = None, args = Pcstr_record)\n | C: {...} -> T0 (res = Some T0, args = Pcstr_record)\n | C of {...} as t (res = None, args = Pcstr_record)\n *)\n\n and type_extension (*IF_CURRENT = Parsetree.type_extension *) =\n {\n ptyext_path: Longident.t loc;\n ptyext_params: (core_type * variance) list;\n ptyext_constructors: extension_constructor list;\n ptyext_private: private_flag;\n ptyext_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n (*\n type t += ...\n *)\n\n and extension_constructor (*IF_CURRENT = Parsetree.extension_constructor *) =\n {\n pext_name: string loc;\n pext_kind : extension_constructor_kind;\n pext_loc : Location.t;\n pext_attributes: attributes; (* C [@id1] [@id2] of ... *)\n }\n\n and extension_constructor_kind (*IF_CURRENT = Parsetree.extension_constructor_kind *) =\n Pext_decl of constructor_arguments * core_type option\n (*\n | C of T1 * ... * Tn ([T1; ...; Tn], None)\n | C: T0 ([], Some T0)\n | C: T1 * ... * Tn -> T0 ([T1; ...; Tn], Some T0)\n *)\n | Pext_rebind of Longident.t loc\n (*\n | C = D\n *)\n\n (** {2 Class language} *)\n\n (* Type expressions for the class language *)\n\n and class_type (*IF_CURRENT = Parsetree.class_type *) =\n {\n pcty_desc: class_type_desc;\n pcty_loc: Location.t;\n pcty_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and class_type_desc (*IF_CURRENT = Parsetree.class_type_desc *) =\n | Pcty_constr of Longident.t loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcty_signature of class_signature\n (* object ... end *)\n | Pcty_arrow of arg_label * core_type * class_type\n (* T -> CT Simple\n ~l:T -> CT Labelled l\n ?l:T -> CT Optional l\n *)\n | Pcty_extension of extension\n (* [%id] *)\n\n and class_signature (*IF_CURRENT = Parsetree.class_signature *) =\n {\n pcsig_self: core_type;\n pcsig_fields: class_type_field list;\n }\n (* object('selfpat) ... end\n object ... end (self = Ptyp_any)\n *)\n\n and class_type_field (*IF_CURRENT = Parsetree.class_type_field *) =\n {\n pctf_desc: class_type_field_desc;\n pctf_loc: Location.t;\n pctf_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and class_type_field_desc (*IF_CURRENT = Parsetree.class_type_field_desc *) =\n | Pctf_inherit of class_type\n (* inherit CT *)\n | Pctf_val of (string * mutable_flag * virtual_flag * core_type)\n (* val x: T *)\n | Pctf_method of (string * private_flag * virtual_flag * core_type)\n (* method x: T\n\n Note: T can be a Ptyp_poly.\n *)\n | Pctf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pctf_attribute of attribute\n (* [@@@id] *)\n | Pctf_extension of extension\n (* [%%id] *)\n\n and 'a class_infos (*IF_CURRENT = 'a Parsetree.class_infos *) =\n {\n pci_virt: virtual_flag;\n pci_params: (core_type * variance) list;\n pci_name: string loc;\n pci_expr: 'a;\n pci_loc: Location.t;\n pci_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n (* class c = ...\n class ['a1,...,'an] c = ...\n class virtual c = ...\n\n Also used for \"class type\" declaration.\n *)\n\n and class_description = class_type class_infos\n\n and class_type_declaration = class_type class_infos\n\n (* Value expressions for the class language *)\n\n and class_expr (*IF_CURRENT = Parsetree.class_expr *) =\n {\n pcl_desc: class_expr_desc;\n pcl_loc: Location.t;\n pcl_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and class_expr_desc (*IF_CURRENT = Parsetree.class_expr_desc *) =\n | Pcl_constr of Longident.t loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcl_structure of class_structure\n (* object ... end *)\n | Pcl_fun of arg_label * expression option * pattern * class_expr\n (* fun P -> CE (Simple, None)\n fun ~l:P -> CE (Labelled l, None)\n fun ?l:P -> CE (Optional l, None)\n fun ?l:(P = E0) -> CE (Optional l, Some E0)\n *)\n | Pcl_apply of class_expr * (arg_label * expression) list\n (* CE ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pcl_let of rec_flag * value_binding list * class_expr\n (* let P1 = E1 and ... and Pn = EN in CE (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in CE (flag = Recursive)\n *)\n | Pcl_constraint of class_expr * class_type\n (* (CE : CT) *)\n | Pcl_extension of extension\n (* [%id] *)\n\n and class_structure (*IF_CURRENT = Parsetree.class_structure *) =\n {\n pcstr_self: pattern;\n pcstr_fields: class_field list;\n }\n (* object(selfpat) ... end\n object ... end (self = Ppat_any)\n *)\n\n and class_field (*IF_CURRENT = Parsetree.class_field *) =\n {\n pcf_desc: class_field_desc;\n pcf_loc: Location.t;\n pcf_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and class_field_desc (*IF_CURRENT = Parsetree.class_field_desc *) =\n | Pcf_inherit of override_flag * class_expr * string option\n (* inherit CE\n inherit CE as x\n inherit! CE\n inherit! CE as x\n *)\n | Pcf_val of (string loc * mutable_flag * class_field_kind)\n (* val x = E\n val virtual x: T\n *)\n | Pcf_method of (string loc * private_flag * class_field_kind)\n (* method x = E (E can be a Pexp_poly)\n method virtual x: T (T can be a Ptyp_poly)\n *)\n | Pcf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pcf_initializer of expression\n (* initializer E *)\n | Pcf_attribute of attribute\n (* [@@@id] *)\n | Pcf_extension of extension\n (* [%%id] *)\n\n and class_field_kind (*IF_CURRENT = Parsetree.class_field_kind *) =\n | Cfk_virtual of core_type\n | Cfk_concrete of override_flag * expression\n\n and class_declaration = class_expr class_infos\n\n (** {2 Module language} *)\n\n (* Type expressions for the module language *)\n\n and module_type (*IF_CURRENT = Parsetree.module_type *) =\n {\n pmty_desc: module_type_desc;\n pmty_loc: Location.t;\n pmty_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and module_type_desc (*IF_CURRENT = Parsetree.module_type_desc *) =\n | Pmty_ident of Longident.t loc\n (* S *)\n | Pmty_signature of signature\n (* sig ... end *)\n | Pmty_functor of string loc * module_type option * module_type\n (* functor(X : MT1) -> MT2 *)\n | Pmty_with of module_type * with_constraint list\n (* MT with ... *)\n | Pmty_typeof of module_expr\n (* module type of ME *)\n | Pmty_extension of extension\n (* [%id] *)\n | Pmty_alias of Longident.t loc\n (* (module M) *)\n\n and signature = signature_item list\n\n and signature_item (*IF_CURRENT = Parsetree.signature_item *) =\n {\n psig_desc: signature_item_desc;\n psig_loc: Location.t;\n }\n\n and signature_item_desc (*IF_CURRENT = Parsetree.signature_item_desc *) =\n | Psig_value of value_description\n (*\n val x: T\n external x: T = \"s1\" ... \"sn\"\n *)\n | Psig_type of rec_flag * type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Psig_typext of type_extension\n (* type t1 += ... *)\n | Psig_exception of extension_constructor\n (* exception C of T *)\n | Psig_module of module_declaration\n (* module X : MT *)\n | Psig_recmodule of module_declaration list\n (* module rec X1 : MT1 and ... and Xn : MTn *)\n | Psig_modtype of module_type_declaration\n (* module type S = MT\n module type S *)\n | Psig_open of open_description\n (* open X *)\n | Psig_include of include_description\n (* include MT *)\n | Psig_class of class_description list\n (* class c1 : ... and ... and cn : ... *)\n | Psig_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Psig_attribute of attribute\n (* [@@@id] *)\n | Psig_extension of extension * attributes\n (* [%%id] *)\n\n and module_declaration (*IF_CURRENT = Parsetree.module_declaration *) =\n {\n pmd_name: string loc;\n pmd_type: module_type;\n pmd_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pmd_loc: Location.t;\n }\n (* S : MT *)\n\n and module_type_declaration (*IF_CURRENT = Parsetree.module_type_declaration *) =\n {\n pmtd_name: string loc;\n pmtd_type: module_type option;\n pmtd_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pmtd_loc: Location.t;\n }\n (* S = MT\n S (abstract module type declaration, pmtd_type = None)\n *)\n\n and open_description (*IF_CURRENT = Parsetree.open_description *) =\n {\n popen_lid: Longident.t loc;\n popen_override: override_flag;\n popen_loc: Location.t;\n popen_attributes: attributes;\n }\n (* open! X - popen_override = Override (silences the 'used identifier\n shadowing' warning)\n open X - popen_override = Fresh\n *)\n\n and 'a include_infos (*IF_CURRENT = 'a Parsetree.include_infos *) =\n {\n pincl_mod: 'a;\n pincl_loc: Location.t;\n pincl_attributes: attributes;\n }\n\n and include_description = module_type include_infos\n (* include MT *)\n\n and include_declaration = module_expr include_infos\n (* include ME *)\n\n and with_constraint (*IF_CURRENT = Parsetree.with_constraint *) =\n | Pwith_type of Longident.t loc * type_declaration\n (* with type X.t = ...\n\n Note: the last component of the longident must match\n the name of the type_declaration. *)\n | Pwith_module of Longident.t loc * Longident.t loc\n (* with module X.Y = Z *)\n | Pwith_typesubst of type_declaration\n (* with type t := ... *)\n | Pwith_modsubst of string loc * Longident.t loc\n (* with module X := Z *)\n\n (* Value expressions for the module language *)\n\n and module_expr (*IF_CURRENT = Parsetree.module_expr *) =\n {\n pmod_desc: module_expr_desc;\n pmod_loc: Location.t;\n pmod_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and module_expr_desc (*IF_CURRENT = Parsetree.module_expr_desc *) =\n | Pmod_ident of Longident.t loc\n (* X *)\n | Pmod_structure of structure\n (* struct ... end *)\n | Pmod_functor of string loc * module_type option * module_expr\n (* functor(X : MT1) -> ME *)\n | Pmod_apply of module_expr * module_expr\n (* ME1(ME2) *)\n | Pmod_constraint of module_expr * module_type\n (* (ME : MT) *)\n | Pmod_unpack of expression\n (* (val E) *)\n | Pmod_extension of extension\n (* [%id] *)\n\n and structure = structure_item list\n\n and structure_item (*IF_CURRENT = Parsetree.structure_item *) =\n {\n pstr_desc: structure_item_desc;\n pstr_loc: Location.t;\n }\n\n and structure_item_desc (*IF_CURRENT = Parsetree.structure_item_desc *) =\n | Pstr_eval of expression * attributes\n (* E *)\n | Pstr_value of rec_flag * value_binding list\n (* let P1 = E1 and ... and Pn = EN (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN (flag = Recursive)\n *)\n | Pstr_primitive of value_description\n (* val x: T\n external x: T = \"s1\" ... \"sn\" *)\n | Pstr_type of rec_flag * type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Pstr_typext of type_extension\n (* type t1 += ... *)\n | Pstr_exception of extension_constructor\n (* exception C of T\n exception C = M.X *)\n | Pstr_module of module_binding\n (* module X = ME *)\n | Pstr_recmodule of module_binding list\n (* module rec X1 = ME1 and ... and Xn = MEn *)\n | Pstr_modtype of module_type_declaration\n (* module type S = MT *)\n | Pstr_open of open_description\n (* open X *)\n | Pstr_class of class_declaration list\n (* class c1 = ... and ... and cn = ... *)\n | Pstr_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Pstr_include of include_declaration\n (* include ME *)\n | Pstr_attribute of attribute\n (* [@@@id] *)\n | Pstr_extension of extension * attributes\n (* [%%id] *)\n\n and value_binding (*IF_CURRENT = Parsetree.value_binding *) =\n {\n pvb_pat: pattern;\n pvb_expr: expression;\n pvb_attributes: attributes;\n pvb_loc: Location.t;\n }\n\n and module_binding (*IF_CURRENT = Parsetree.module_binding *) =\n {\n pmb_name: string loc;\n pmb_expr: module_expr;\n pmb_attributes: attributes;\n pmb_loc: Location.t;\n }\n (* X = ME *)\n\n (** {2 Toplevel} *)\n\n (* Toplevel phrases *)\n\n type toplevel_phrase (*IF_CURRENT = Parsetree.toplevel_phrase *) =\n | Ptop_def of structure\n | Ptop_dir of string * directive_argument\n (* #use, #load ... *)\n\n and directive_argument (*IF_CURRENT = Parsetree.directive_argument *) =\n | Pdir_none\n | Pdir_string of string\n | Pdir_int of string * char option\n | Pdir_ident of Longident.t\n | Pdir_bool of bool\nend\n\nmodule Config = struct\n let ast_impl_magic_number = \"Caml1999M019\"\n let ast_intf_magic_number = \"Caml1999N018\"\nend\n","(**************************************************************************)\n(* *)\n(* OCaml Migrate Parsetree *)\n(* *)\n(* Frédéric Bour *)\n(* Jérémie Dimino and Leo White, Jane Street Europe *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* Alain Frisch, LexiFi *)\n(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 2017 Institut National de Recherche en Informatique et *)\n(* en Automatique (INRIA). *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nmodule Asttypes = struct\n (* Auxiliary a.s.t. types used by parsetree and typedtree. *)\n\n type constant (*IF_CURRENT = Asttypes.constant *) =\n Const_int of int\n | Const_char of char\n | Const_string of string * string option\n | Const_float of string\n | Const_int32 of int32\n | Const_int64 of int64\n | Const_nativeint of nativeint\n\n type rec_flag (*IF_CURRENT = Asttypes.rec_flag *) = Nonrecursive | Recursive\n\n type direction_flag (*IF_CURRENT = Asttypes.direction_flag *) = Upto | Downto\n\n type private_flag (*IF_CURRENT = Asttypes.private_flag *) = Private | Public\n\n type mutable_flag (*IF_CURRENT = Asttypes.mutable_flag *) = Immutable | Mutable\n\n type virtual_flag (*IF_CURRENT = Asttypes.virtual_flag *) = Virtual | Concrete\n\n type override_flag (*IF_CURRENT = Asttypes.override_flag *) = Override | Fresh\n\n type closed_flag (*IF_CURRENT = Asttypes.closed_flag *) = Closed | Open\n\n type label = string\n\n type 'a loc = 'a Location.loc = {\n txt : 'a;\n loc : Location.t;\n }\n\n\n type variance (*IF_CURRENT = Asttypes.variance *) =\n | Covariant\n | Contravariant\n | Invariant\nend\n\nmodule Parsetree = struct\n (** Abstract syntax tree produced by parsing *)\n\n open Asttypes\n\n (** {2 Extension points} *)\n\n type attribute = string loc * payload\n (* [@id ARG]\n [@@id ARG]\n\n Metadata containers passed around within the AST.\n The compiler ignores unknown attributes.\n *)\n\n and extension = string loc * payload\n (* [%id ARG]\n [%%id ARG]\n\n Sub-language placeholder -- rejected by the typechecker.\n *)\n\n and attributes = attribute list\n\n and payload (*IF_CURRENT = Parsetree.payload *) =\n | PStr of structure\n | PTyp of core_type (* : T *)\n | PPat of pattern * expression option (* ? P or ? P when E *)\n\n (** {2 Core language} *)\n\n (* Type expressions *)\n\n and core_type (*IF_CURRENT = Parsetree.core_type *) =\n {\n ptyp_desc: core_type_desc;\n ptyp_loc: Location.t;\n ptyp_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and core_type_desc (*IF_CURRENT = Parsetree.core_type_desc *) =\n | Ptyp_any\n (* _ *)\n | Ptyp_var of string\n (* 'a *)\n | Ptyp_arrow of label * core_type * core_type\n (* T1 -> T2 (label = \"\")\n ~l:T1 -> T2 (label = \"l\")\n ?l:T1 -> T2 (label = \"?l\")\n *)\n | Ptyp_tuple of core_type list\n (* T1 * ... * Tn\n\n Invariant: n >= 2\n *)\n | Ptyp_constr of Longident.t loc * core_type list\n (* tconstr\n T tconstr\n (T1, ..., Tn) tconstr\n *)\n | Ptyp_object of (string * attributes * core_type) list * closed_flag\n (* < l1:T1; ...; ln:Tn > (flag = Closed)\n < l1:T1; ...; ln:Tn; .. > (flag = Open)\n *)\n | Ptyp_class of Longident.t loc * core_type list\n (* #tconstr\n T #tconstr\n (T1, ..., Tn) #tconstr\n *)\n | Ptyp_alias of core_type * string\n (* T as 'a *)\n | Ptyp_variant of row_field list * closed_flag * label list option\n (* [ `A|`B ] (flag = Closed; labels = None)\n [> `A|`B ] (flag = Open; labels = None)\n [< `A|`B ] (flag = Closed; labels = Some [])\n [< `A|`B > `X `Y ](flag = Closed; labels = Some [\"X\";\"Y\"])\n *)\n | Ptyp_poly of string list * core_type\n (* 'a1 ... 'an. T\n\n Can only appear in the following context:\n\n - As the core_type of a Ppat_constraint node corresponding\n to a constraint on a let-binding: let x : 'a1 ... 'an. T\n = e ...\n\n - Under Cfk_virtual for methods (not values).\n\n - As the core_type of a Pctf_method node.\n\n - As the core_type of a Pexp_poly node.\n\n - As the pld_type field of a label_declaration.\n\n - As a core_type of a Ptyp_object node.\n *)\n\n | Ptyp_package of package_type\n (* (module S) *)\n | Ptyp_extension of extension\n (* [%id] *)\n\n and package_type = Longident.t loc * (Longident.t loc * core_type) list\n (*\n (module S)\n (module S with type t1 = T1 and ... and tn = Tn)\n *)\n\n and row_field (*IF_CURRENT = Parsetree.row_field *) =\n | Rtag of label * attributes * bool * core_type list\n (* [`A] ( true, [] )\n [`A of T] ( false, [T] )\n [`A of T1 & .. & Tn] ( false, [T1;...Tn] )\n [`A of & T1 & .. & Tn] ( true, [T1;...Tn] )\n\n - The 2nd field is true if the tag contains a\n constant (empty) constructor.\n - '&' occurs when several types are used for the same constructor\n (see 4.2 in the manual)\n\n - TODO: switch to a record representation, and keep location\n *)\n | Rinherit of core_type\n (* [ T ] *)\n\n (* Patterns *)\n\n and pattern (*IF_CURRENT = Parsetree.pattern *) =\n {\n ppat_desc: pattern_desc;\n ppat_loc: Location.t;\n ppat_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and pattern_desc (*IF_CURRENT = Parsetree.pattern_desc *) =\n | Ppat_any\n (* _ *)\n | Ppat_var of string loc\n (* x *)\n | Ppat_alias of pattern * string loc\n (* P as 'a *)\n | Ppat_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Ppat_interval of constant * constant\n (* 'a'..'z'\n\n Other forms of interval are recognized by the parser\n but rejected by the type-checker. *)\n | Ppat_tuple of pattern list\n (* (P1, ..., Pn)\n\n Invariant: n >= 2\n *)\n | Ppat_construct of Longident.t loc * pattern option\n (* C None\n C P Some P\n C (P1, ..., Pn) Some (Ppat_tuple [P1; ...; Pn])\n *)\n | Ppat_variant of label * pattern option\n (* `A (None)\n `A P (Some P)\n *)\n | Ppat_record of (Longident.t loc * pattern) list * closed_flag\n (* { l1=P1; ...; ln=Pn } (flag = Closed)\n { l1=P1; ...; ln=Pn; _} (flag = Open)\n\n Invariant: n > 0\n *)\n | Ppat_array of pattern list\n (* [| P1; ...; Pn |] *)\n | Ppat_or of pattern * pattern\n (* P1 | P2 *)\n | Ppat_constraint of pattern * core_type\n (* (P : T) *)\n | Ppat_type of Longident.t loc\n (* #tconst *)\n | Ppat_lazy of pattern\n (* lazy P *)\n | Ppat_unpack of string loc\n (* (module P)\n Note: (module P : S) is represented as\n Ppat_constraint(Ppat_unpack, Ptyp_package)\n *)\n | Ppat_exception of pattern\n (* exception P *)\n | Ppat_extension of extension\n (* [%id] *)\n\n (* Value expressions *)\n\n and expression (*IF_CURRENT = Parsetree.expression *) =\n {\n pexp_desc: expression_desc;\n pexp_loc: Location.t;\n pexp_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and expression_desc (*IF_CURRENT = Parsetree.expression_desc *) =\n | Pexp_ident of Longident.t loc\n (* x\n M.x\n *)\n | Pexp_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Pexp_let of rec_flag * value_binding list * expression\n (* let P1 = E1 and ... and Pn = EN in E (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in E (flag = Recursive)\n *)\n | Pexp_function of case list\n (* function P1 -> E1 | ... | Pn -> En *)\n | Pexp_fun of label * expression option * pattern * expression\n (* fun P -> E1 (lab = \"\", None)\n fun ~l:P -> E1 (lab = \"l\", None)\n fun ?l:P -> E1 (lab = \"?l\", None)\n fun ?l:(P = E0) -> E1 (lab = \"?l\", Some E0)\n\n Notes:\n - If E0 is provided, lab must start with '?'.\n - \"fun P1 P2 .. Pn -> E1\" is represented as nested Pexp_fun.\n - \"let f P = E\" is represented using Pexp_fun.\n *)\n | Pexp_apply of expression * (label * expression) list\n (* E0 ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pexp_match of expression * case list\n (* match E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_try of expression * case list\n (* try E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_tuple of expression list\n (* (E1, ..., En)\n\n Invariant: n >= 2\n *)\n | Pexp_construct of Longident.t loc * expression option\n (* C None\n C E Some E\n C (E1, ..., En) Some (Pexp_tuple[E1;...;En])\n *)\n | Pexp_variant of label * expression option\n (* `A (None)\n `A E (Some E)\n *)\n | Pexp_record of (Longident.t loc * expression) list * expression option\n (* { l1=P1; ...; ln=Pn } (None)\n { E0 with l1=P1; ...; ln=Pn } (Some E0)\n\n Invariant: n > 0\n *)\n | Pexp_field of expression * Longident.t loc\n (* E.l *)\n | Pexp_setfield of expression * Longident.t loc * expression\n (* E1.l <- E2 *)\n | Pexp_array of expression list\n (* [| E1; ...; En |] *)\n | Pexp_ifthenelse of expression * expression * expression option\n (* if E1 then E2 else E3 *)\n | Pexp_sequence of expression * expression\n (* E1; E2 *)\n | Pexp_while of expression * expression\n (* while E1 do E2 done *)\n | Pexp_for of\n pattern * expression * expression * direction_flag * expression\n (* for i = E1 to E2 do E3 done (flag = Upto)\n for i = E1 downto E2 do E3 done (flag = Downto)\n *)\n | Pexp_constraint of expression * core_type\n (* (E : T) *)\n | Pexp_coerce of expression * core_type option * core_type\n (* (E :> T) (None, T)\n (E : T0 :> T) (Some T0, T)\n *)\n | Pexp_send of expression * string\n (* E # m *)\n | Pexp_new of Longident.t loc\n (* new M.c *)\n | Pexp_setinstvar of string loc * expression\n (* x <- 2 *)\n | Pexp_override of (string loc * expression) list\n (* {< x1 = E1; ...; Xn = En >} *)\n | Pexp_letmodule of string loc * module_expr * expression\n (* let module M = ME in E *)\n | Pexp_assert of expression\n (* assert E\n Note: \"assert false\" is treated in a special way by the\n type-checker. *)\n | Pexp_lazy of expression\n (* lazy E *)\n | Pexp_poly of expression * core_type option\n (* Used for method bodies.\n\n Can only be used as the expression under Cfk_concrete\n for methods (not values). *)\n | Pexp_object of class_structure\n (* object ... end *)\n | Pexp_newtype of string * expression\n (* fun (type t) -> E *)\n | Pexp_pack of module_expr\n (* (module ME)\n\n (module ME : S) is represented as\n Pexp_constraint(Pexp_pack, Ptyp_package S) *)\n | Pexp_open of override_flag * Longident.t loc * expression\n (* let open M in E\n let! open M in E\n *)\n | Pexp_extension of extension\n (* [%id] *)\n\n and case (*IF_CURRENT = Parsetree.case *) = (* (P -> E) or (P when E0 -> E) *)\n {\n pc_lhs: pattern;\n pc_guard: expression option;\n pc_rhs: expression;\n }\n\n (* Value descriptions *)\n\n and value_description (*IF_CURRENT = Parsetree.value_description *) =\n {\n pval_name: string loc;\n pval_type: core_type;\n pval_prim: string list;\n pval_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pval_loc: Location.t;\n }\n\n (*\n val x: T (prim = [])\n external x: T = \"s1\" ... \"sn\" (prim = [\"s1\";...\"sn\"])\n\n Note: when used under Pstr_primitive, prim cannot be empty\n *)\n\n (* Type declarations *)\n\n and type_declaration (*IF_CURRENT = Parsetree.type_declaration *) =\n {\n ptype_name: string loc;\n ptype_params: (core_type * variance) list;\n (* ('a1,...'an) t; None represents _*)\n ptype_cstrs: (core_type * core_type * Location.t) list;\n (* ... constraint T1=T1' ... constraint Tn=Tn' *)\n ptype_kind: type_kind;\n ptype_private: private_flag; (* = private ... *)\n ptype_manifest: core_type option; (* = T *)\n ptype_attributes: attributes; (* ... [@@id1] [@@id2] *)\n ptype_loc: Location.t;\n }\n\n (*\n type t (abstract, no manifest)\n type t = T0 (abstract, manifest=T0)\n type t = C of T | ... (variant, no manifest)\n type t = T0 = C of T | ... (variant, manifest=T0)\n type t = {l: T; ...} (record, no manifest)\n type t = T0 = {l : T; ...} (record, manifest=T0)\n type t = .. (open, no manifest)\n *)\n\n and type_kind (*IF_CURRENT = Parsetree.type_kind *) =\n | Ptype_abstract\n | Ptype_variant of constructor_declaration list\n (* Invariant: non-empty list *)\n | Ptype_record of label_declaration list\n (* Invariant: non-empty list *)\n | Ptype_open\n\n and label_declaration (*IF_CURRENT = Parsetree.label_declaration *) =\n {\n pld_name: string loc;\n pld_mutable: mutable_flag;\n pld_type: core_type;\n pld_loc: Location.t;\n pld_attributes: attributes; (* l [@id1] [@id2] : T *)\n }\n\n (* { ...; l: T; ... } (mutable=Immutable)\n { ...; mutable l: T; ... } (mutable=Mutable)\n\n Note: T can be a Ptyp_poly.\n *)\n\n and constructor_declaration (*IF_CURRENT = Parsetree.constructor_declaration *) =\n {\n pcd_name: string loc;\n pcd_args: core_type list;\n pcd_res: core_type option;\n pcd_loc: Location.t;\n pcd_attributes: attributes; (* C [@id1] [@id2] of ... *)\n }\n (*\n | C of T1 * ... * Tn (res = None)\n | C: T0 (args = [], res = Some T0)\n | C: T1 * ... * Tn -> T0 (res = Some T0)\n *)\n\n and type_extension (*IF_CURRENT = Parsetree.type_extension *) =\n {\n ptyext_path: Longident.t loc;\n ptyext_params: (core_type * variance) list;\n ptyext_constructors: extension_constructor list;\n ptyext_private: private_flag;\n ptyext_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n (*\n type t += ...\n *)\n\n and extension_constructor (*IF_CURRENT = Parsetree.extension_constructor *) =\n {\n pext_name: string loc;\n pext_kind : extension_constructor_kind;\n pext_loc : Location.t;\n pext_attributes: attributes; (* C [@id1] [@id2] of ... *)\n }\n\n and extension_constructor_kind (*IF_CURRENT = Parsetree.extension_constructor_kind *) =\n Pext_decl of core_type list * core_type option\n (*\n | C of T1 * ... * Tn ([T1; ...; Tn], None)\n | C: T0 ([], Some T0)\n | C: T1 * ... * Tn -> T0 ([T1; ...; Tn], Some T0)\n *)\n | Pext_rebind of Longident.t loc\n (*\n | C = D\n *)\n\n (** {2 Class language} *)\n\n (* Type expressions for the class language *)\n\n and class_type (*IF_CURRENT = Parsetree.class_type *) =\n {\n pcty_desc: class_type_desc;\n pcty_loc: Location.t;\n pcty_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and class_type_desc (*IF_CURRENT = Parsetree.class_type_desc *) =\n | Pcty_constr of Longident.t loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcty_signature of class_signature\n (* object ... end *)\n | Pcty_arrow of label * core_type * class_type\n (* T -> CT (label = \"\")\n ~l:T -> CT (label = \"l\")\n ?l:T -> CT (label = \"?l\")\n *)\n | Pcty_extension of extension\n (* [%id] *)\n\n and class_signature (*IF_CURRENT = Parsetree.class_signature *) =\n {\n pcsig_self: core_type;\n pcsig_fields: class_type_field list;\n }\n (* object('selfpat) ... end\n object ... end (self = Ptyp_any)\n *)\n\n and class_type_field (*IF_CURRENT = Parsetree.class_type_field *) =\n {\n pctf_desc: class_type_field_desc;\n pctf_loc: Location.t;\n pctf_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and class_type_field_desc (*IF_CURRENT = Parsetree.class_type_field_desc *) =\n | Pctf_inherit of class_type\n (* inherit CT *)\n | Pctf_val of (string * mutable_flag * virtual_flag * core_type)\n (* val x: T *)\n | Pctf_method of (string * private_flag * virtual_flag * core_type)\n (* method x: T\n\n Note: T can be a Ptyp_poly.\n *)\n | Pctf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pctf_attribute of attribute\n (* [@@@id] *)\n | Pctf_extension of extension\n (* [%%id] *)\n\n and 'a class_infos (*IF_CURRENT = 'a Parsetree.class_infos *) =\n {\n pci_virt: virtual_flag;\n pci_params: (core_type * variance) list;\n pci_name: string loc;\n pci_expr: 'a;\n pci_loc: Location.t;\n pci_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n (* class c = ...\n class ['a1,...,'an] c = ...\n class virtual c = ...\n\n Also used for \"class type\" declaration.\n *)\n\n and class_description = class_type class_infos\n\n and class_type_declaration = class_type class_infos\n\n (* Value expressions for the class language *)\n\n and class_expr (*IF_CURRENT = Parsetree.class_expr *) =\n {\n pcl_desc: class_expr_desc;\n pcl_loc: Location.t;\n pcl_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and class_expr_desc (*IF_CURRENT = Parsetree.class_expr_desc *) =\n | Pcl_constr of Longident.t loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcl_structure of class_structure\n (* object ... end *)\n | Pcl_fun of label * expression option * pattern * class_expr\n (* fun P -> CE (lab = \"\", None)\n fun ~l:P -> CE (lab = \"l\", None)\n fun ?l:P -> CE (lab = \"?l\", None)\n fun ?l:(P = E0) -> CE (lab = \"?l\", Some E0)\n *)\n | Pcl_apply of class_expr * (label * expression) list\n (* CE ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pcl_let of rec_flag * value_binding list * class_expr\n (* let P1 = E1 and ... and Pn = EN in CE (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in CE (flag = Recursive)\n *)\n | Pcl_constraint of class_expr * class_type\n (* (CE : CT) *)\n | Pcl_extension of extension\n (* [%id] *)\n\n and class_structure (*IF_CURRENT = Parsetree.class_structure *) =\n {\n pcstr_self: pattern;\n pcstr_fields: class_field list;\n }\n (* object(selfpat) ... end\n object ... end (self = Ppat_any)\n *)\n\n and class_field (*IF_CURRENT = Parsetree.class_field *) =\n {\n pcf_desc: class_field_desc;\n pcf_loc: Location.t;\n pcf_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and class_field_desc (*IF_CURRENT = Parsetree.class_field_desc *) =\n | Pcf_inherit of override_flag * class_expr * string option\n (* inherit CE\n inherit CE as x\n inherit! CE\n inherit! CE as x\n *)\n | Pcf_val of (string loc * mutable_flag * class_field_kind)\n (* val x = E\n val virtual x: T\n *)\n | Pcf_method of (string loc * private_flag * class_field_kind)\n (* method x = E (E can be a Pexp_poly)\n method virtual x: T (T can be a Ptyp_poly)\n *)\n | Pcf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pcf_initializer of expression\n (* initializer E *)\n | Pcf_attribute of attribute\n (* [@@@id] *)\n | Pcf_extension of extension\n (* [%%id] *)\n\n and class_field_kind (*IF_CURRENT = Parsetree.class_field_kind *) =\n | Cfk_virtual of core_type\n | Cfk_concrete of override_flag * expression\n\n and class_declaration = class_expr class_infos\n\n (** {2 Module language} *)\n\n (* Type expressions for the module language *)\n\n and module_type (*IF_CURRENT = Parsetree.module_type *) =\n {\n pmty_desc: module_type_desc;\n pmty_loc: Location.t;\n pmty_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and module_type_desc (*IF_CURRENT = Parsetree.module_type_desc *) =\n | Pmty_ident of Longident.t loc\n (* S *)\n | Pmty_signature of signature\n (* sig ... end *)\n | Pmty_functor of string loc * module_type option * module_type\n (* functor(X : MT1) -> MT2 *)\n | Pmty_with of module_type * with_constraint list\n (* MT with ... *)\n | Pmty_typeof of module_expr\n (* module type of ME *)\n | Pmty_extension of extension\n (* [%id] *)\n | Pmty_alias of Longident.t loc\n (* (module M) *)\n\n and signature = signature_item list\n\n and signature_item (*IF_CURRENT = Parsetree.signature_item *) =\n {\n psig_desc: signature_item_desc;\n psig_loc: Location.t;\n }\n\n and signature_item_desc (*IF_CURRENT = Parsetree.signature_item_desc *) =\n | Psig_value of value_description\n (*\n val x: T\n external x: T = \"s1\" ... \"sn\"\n *)\n | Psig_type of type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Psig_typext of type_extension\n (* type t1 += ... *)\n | Psig_exception of extension_constructor\n (* exception C of T *)\n | Psig_module of module_declaration\n (* module X : MT *)\n | Psig_recmodule of module_declaration list\n (* module rec X1 : MT1 and ... and Xn : MTn *)\n | Psig_modtype of module_type_declaration\n (* module type S = MT\n module type S *)\n | Psig_open of open_description\n (* open X *)\n | Psig_include of include_description\n (* include MT *)\n | Psig_class of class_description list\n (* class c1 : ... and ... and cn : ... *)\n | Psig_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Psig_attribute of attribute\n (* [@@@id] *)\n | Psig_extension of extension * attributes\n (* [%%id] *)\n\n and module_declaration (*IF_CURRENT = Parsetree.module_declaration *) =\n {\n pmd_name: string loc;\n pmd_type: module_type;\n pmd_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pmd_loc: Location.t;\n }\n (* S : MT *)\n\n and module_type_declaration (*IF_CURRENT = Parsetree.module_type_declaration *) =\n {\n pmtd_name: string loc;\n pmtd_type: module_type option;\n pmtd_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pmtd_loc: Location.t;\n }\n (* S = MT\n S (abstract module type declaration, pmtd_type = None)\n *)\n\n and open_description (*IF_CURRENT = Parsetree.open_description *) =\n {\n popen_lid: Longident.t loc;\n popen_override: override_flag;\n popen_loc: Location.t;\n popen_attributes: attributes;\n }\n (* open! X - popen_override = Override (silences the 'used identifier\n shadowing' warning)\n open X - popen_override = Fresh\n *)\n\n and 'a include_infos (*IF_CURRENT = 'a Parsetree.include_infos *) =\n {\n pincl_mod: 'a;\n pincl_loc: Location.t;\n pincl_attributes: attributes;\n }\n\n and include_description = module_type include_infos\n (* include MT *)\n\n and include_declaration = module_expr include_infos\n (* include ME *)\n\n and with_constraint (*IF_CURRENT = Parsetree.with_constraint *) =\n | Pwith_type of Longident.t loc * type_declaration\n (* with type X.t = ...\n\n Note: the last component of the longident must match\n the name of the type_declaration. *)\n | Pwith_module of Longident.t loc * Longident.t loc\n (* with module X.Y = Z *)\n | Pwith_typesubst of type_declaration\n (* with type t := ... *)\n | Pwith_modsubst of string loc * Longident.t loc\n (* with module X := Z *)\n\n (* Value expressions for the module language *)\n\n and module_expr (*IF_CURRENT = Parsetree.module_expr *) =\n {\n pmod_desc: module_expr_desc;\n pmod_loc: Location.t;\n pmod_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and module_expr_desc (*IF_CURRENT = Parsetree.module_expr_desc *) =\n | Pmod_ident of Longident.t loc\n (* X *)\n | Pmod_structure of structure\n (* struct ... end *)\n | Pmod_functor of string loc * module_type option * module_expr\n (* functor(X : MT1) -> ME *)\n | Pmod_apply of module_expr * module_expr\n (* ME1(ME2) *)\n | Pmod_constraint of module_expr * module_type\n (* (ME : MT) *)\n | Pmod_unpack of expression\n (* (val E) *)\n | Pmod_extension of extension\n (* [%id] *)\n\n and structure = structure_item list\n\n and structure_item (*IF_CURRENT = Parsetree.structure_item *) =\n {\n pstr_desc: structure_item_desc;\n pstr_loc: Location.t;\n }\n\n and structure_item_desc (*IF_CURRENT = Parsetree.structure_item_desc *) =\n | Pstr_eval of expression * attributes\n (* E *)\n | Pstr_value of rec_flag * value_binding list\n (* let P1 = E1 and ... and Pn = EN (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN (flag = Recursive)\n *)\n | Pstr_primitive of value_description\n (* external x: T = \"s1\" ... \"sn\" *)\n | Pstr_type of type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Pstr_typext of type_extension\n (* type t1 += ... *)\n | Pstr_exception of extension_constructor\n (* exception C of T\n exception C = M.X *)\n | Pstr_module of module_binding\n (* module X = ME *)\n | Pstr_recmodule of module_binding list\n (* module rec X1 = ME1 and ... and Xn = MEn *)\n | Pstr_modtype of module_type_declaration\n (* module type S = MT *)\n | Pstr_open of open_description\n (* open X *)\n | Pstr_class of class_declaration list\n (* class c1 = ... and ... and cn = ... *)\n | Pstr_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Pstr_include of include_declaration\n (* include ME *)\n | Pstr_attribute of attribute\n (* [@@@id] *)\n | Pstr_extension of extension * attributes\n (* [%%id] *)\n\n and value_binding (*IF_CURRENT = Parsetree.value_binding *) =\n {\n pvb_pat: pattern;\n pvb_expr: expression;\n pvb_attributes: attributes;\n pvb_loc: Location.t;\n }\n\n and module_binding (*IF_CURRENT = Parsetree.module_binding *) =\n {\n pmb_name: string loc;\n pmb_expr: module_expr;\n pmb_attributes: attributes;\n pmb_loc: Location.t;\n }\n (* X = ME *)\n\n (** {2 Toplevel} *)\n\n (* Toplevel phrases *)\n\n type toplevel_phrase (*IF_CURRENT = Parsetree.toplevel_phrase *) =\n | Ptop_def of structure\n | Ptop_dir of string * directive_argument\n (* #use, #load ... *)\n\n and directive_argument (*IF_CURRENT = Parsetree.directive_argument *) =\n | Pdir_none\n | Pdir_string of string\n | Pdir_int of int\n | Pdir_ident of Longident.t\n | Pdir_bool of bool\nend\n\nmodule Config = struct\n let ast_impl_magic_number = \"Caml1999M016\"\n let ast_intf_magic_number = \"Caml1999N015\"\nend\n","(**************************************************************************)\n(* *)\n(* OCaml Migrate Parsetree *)\n(* *)\n(* Frédéric Bour *)\n(* Alain Frisch, LexiFi *)\n(* *)\n(* Copyright 2017 Institut National de Recherche en Informatique et *)\n(* en Automatique (INRIA). *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nmodule From = Ast_403\nmodule To = Ast_402\n\nlet inject_predef_option label d =\n let open To in\n let open Parsetree in\n match label with\n | From.Asttypes.Optional _ ->\n let loc = { d.ptyp_loc with Location.loc_ghost = true } in\n let txt = Longident.Ldot (Longident.Lident \"*predef*\", \"option\") in\n let ident = { Location.txt; loc } in\n {\n ptyp_desc = Ptyp_constr (ident, [ d ]);\n ptyp_loc = loc;\n ptyp_attributes = [];\n }\n | _ -> d\n\nlet from_loc { Location.txt = _; loc } = loc\n\nlet migration_error loc missing_feature =\n Location.raise_errorf ~loc\n \"migration error: %s is not supported before OCaml 4.03\" missing_feature\n\nlet rec copy_expression : From.Parsetree.expression -> To.Parsetree.expression =\n fun {\n From.Parsetree.pexp_desc;\n From.Parsetree.pexp_loc;\n From.Parsetree.pexp_attributes;\n } ->\n {\n To.Parsetree.pexp_desc = copy_expression_desc pexp_loc pexp_desc;\n To.Parsetree.pexp_loc = copy_location pexp_loc;\n To.Parsetree.pexp_attributes = copy_attributes pexp_attributes;\n }\n\nand copy_expression_desc loc :\n From.Parsetree.expression_desc -> To.Parsetree.expression_desc = function\n | From.Parsetree.Pexp_ident x0 ->\n To.Parsetree.Pexp_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pexp_constant x0 ->\n To.Parsetree.Pexp_constant (copy_constant loc x0)\n | From.Parsetree.Pexp_let (x0, x1, x2) ->\n To.Parsetree.Pexp_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_expression x2)\n | From.Parsetree.Pexp_function x0 ->\n To.Parsetree.Pexp_function (List.map copy_case x0)\n | From.Parsetree.Pexp_fun (x0, x1, x2, x3) ->\n To.Parsetree.Pexp_fun\n ( copy_arg_label x0,\n copy_option copy_expression x1,\n copy_pattern x2,\n copy_expression x3 )\n | From.Parsetree.Pexp_apply (x0, x1) ->\n To.Parsetree.Pexp_apply\n ( copy_expression x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | From.Parsetree.Pexp_match (x0, x1) ->\n To.Parsetree.Pexp_match (copy_expression x0, List.map copy_case x1)\n | From.Parsetree.Pexp_try (x0, x1) ->\n To.Parsetree.Pexp_try (copy_expression x0, List.map copy_case x1)\n | From.Parsetree.Pexp_tuple x0 ->\n To.Parsetree.Pexp_tuple (List.map copy_expression x0)\n | From.Parsetree.Pexp_construct (x0, x1) ->\n To.Parsetree.Pexp_construct\n (copy_loc copy_longident x0, copy_option copy_expression x1)\n | From.Parsetree.Pexp_variant (x0, x1) ->\n To.Parsetree.Pexp_variant (copy_label x0, copy_option copy_expression x1)\n | From.Parsetree.Pexp_record (x0, x1) ->\n To.Parsetree.Pexp_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_expression x1))\n x0,\n copy_option copy_expression x1 )\n | From.Parsetree.Pexp_field (x0, x1) ->\n To.Parsetree.Pexp_field (copy_expression x0, copy_loc copy_longident x1)\n | From.Parsetree.Pexp_setfield (x0, x1, x2) ->\n To.Parsetree.Pexp_setfield\n (copy_expression x0, copy_loc copy_longident x1, copy_expression x2)\n | From.Parsetree.Pexp_array x0 ->\n To.Parsetree.Pexp_array (List.map copy_expression x0)\n | From.Parsetree.Pexp_ifthenelse (x0, x1, x2) ->\n To.Parsetree.Pexp_ifthenelse\n (copy_expression x0, copy_expression x1, copy_option copy_expression x2)\n | From.Parsetree.Pexp_sequence (x0, x1) ->\n To.Parsetree.Pexp_sequence (copy_expression x0, copy_expression x1)\n | From.Parsetree.Pexp_while (x0, x1) ->\n To.Parsetree.Pexp_while (copy_expression x0, copy_expression x1)\n | From.Parsetree.Pexp_for (x0, x1, x2, x3, x4) ->\n To.Parsetree.Pexp_for\n ( copy_pattern x0,\n copy_expression x1,\n copy_expression x2,\n copy_direction_flag x3,\n copy_expression x4 )\n | From.Parsetree.Pexp_constraint (x0, x1) ->\n To.Parsetree.Pexp_constraint (copy_expression x0, copy_core_type x1)\n | From.Parsetree.Pexp_coerce (x0, x1, x2) ->\n To.Parsetree.Pexp_coerce\n (copy_expression x0, copy_option copy_core_type x1, copy_core_type x2)\n | From.Parsetree.Pexp_send (x0, x1) ->\n To.Parsetree.Pexp_send (copy_expression x0, x1)\n | From.Parsetree.Pexp_new x0 ->\n To.Parsetree.Pexp_new (copy_loc copy_longident x0)\n | From.Parsetree.Pexp_setinstvar (x0, x1) ->\n To.Parsetree.Pexp_setinstvar (copy_loc (fun x -> x) x0, copy_expression x1)\n | From.Parsetree.Pexp_override x0 ->\n To.Parsetree.Pexp_override\n (List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_expression x1))\n x0)\n | From.Parsetree.Pexp_letmodule (x0, x1, x2) ->\n To.Parsetree.Pexp_letmodule\n (copy_loc (fun x -> x) x0, copy_module_expr x1, copy_expression x2)\n | From.Parsetree.Pexp_assert x0 ->\n To.Parsetree.Pexp_assert (copy_expression x0)\n | From.Parsetree.Pexp_lazy x0 -> To.Parsetree.Pexp_lazy (copy_expression x0)\n | From.Parsetree.Pexp_poly (x0, x1) ->\n To.Parsetree.Pexp_poly (copy_expression x0, copy_option copy_core_type x1)\n | From.Parsetree.Pexp_object x0 ->\n To.Parsetree.Pexp_object (copy_class_structure x0)\n | From.Parsetree.Pexp_newtype (x0, x1) ->\n To.Parsetree.Pexp_newtype (x0, copy_expression x1)\n | From.Parsetree.Pexp_pack x0 -> To.Parsetree.Pexp_pack (copy_module_expr x0)\n | From.Parsetree.Pexp_open (x0, x1, x2) ->\n To.Parsetree.Pexp_open\n (copy_override_flag x0, copy_loc copy_longident x1, copy_expression x2)\n | From.Parsetree.Pexp_extension x0 ->\n To.Parsetree.Pexp_extension (copy_extension x0)\n | From.Parsetree.Pexp_unreachable ->\n migration_error loc \"unreachable patterns\"\n\nand copy_direction_flag :\n From.Asttypes.direction_flag -> To.Asttypes.direction_flag = function\n | From.Asttypes.Upto -> To.Asttypes.Upto\n | From.Asttypes.Downto -> To.Asttypes.Downto\n\nand copy_case : From.Parsetree.case -> To.Parsetree.case =\n fun { From.Parsetree.pc_lhs; From.Parsetree.pc_guard; From.Parsetree.pc_rhs } ->\n {\n To.Parsetree.pc_lhs = copy_pattern pc_lhs;\n To.Parsetree.pc_guard = copy_option copy_expression pc_guard;\n To.Parsetree.pc_rhs = copy_expression pc_rhs;\n }\n\nand copy_value_binding :\n From.Parsetree.value_binding -> To.Parsetree.value_binding =\n fun {\n From.Parsetree.pvb_pat;\n From.Parsetree.pvb_expr;\n From.Parsetree.pvb_attributes;\n From.Parsetree.pvb_loc;\n } ->\n {\n To.Parsetree.pvb_pat = copy_pattern pvb_pat;\n To.Parsetree.pvb_expr = copy_expression pvb_expr;\n To.Parsetree.pvb_attributes = copy_attributes pvb_attributes;\n To.Parsetree.pvb_loc = copy_location pvb_loc;\n }\n\nand copy_pattern : From.Parsetree.pattern -> To.Parsetree.pattern =\n fun {\n From.Parsetree.ppat_desc;\n From.Parsetree.ppat_loc;\n From.Parsetree.ppat_attributes;\n } ->\n {\n To.Parsetree.ppat_desc = copy_pattern_desc ppat_loc ppat_desc;\n To.Parsetree.ppat_loc = copy_location ppat_loc;\n To.Parsetree.ppat_attributes = copy_attributes ppat_attributes;\n }\n\nand copy_pattern_desc loc :\n From.Parsetree.pattern_desc -> To.Parsetree.pattern_desc = function\n | From.Parsetree.Ppat_any -> To.Parsetree.Ppat_any\n | From.Parsetree.Ppat_var x0 ->\n To.Parsetree.Ppat_var (copy_loc (fun x -> x) x0)\n | From.Parsetree.Ppat_alias (x0, x1) ->\n To.Parsetree.Ppat_alias (copy_pattern x0, copy_loc (fun x -> x) x1)\n | From.Parsetree.Ppat_constant x0 ->\n To.Parsetree.Ppat_constant (copy_constant loc x0)\n | From.Parsetree.Ppat_interval (x0, x1) ->\n To.Parsetree.Ppat_interval (copy_constant loc x0, copy_constant loc x1)\n | From.Parsetree.Ppat_tuple x0 ->\n To.Parsetree.Ppat_tuple (List.map copy_pattern x0)\n | From.Parsetree.Ppat_construct (x0, x1) ->\n To.Parsetree.Ppat_construct\n (copy_loc copy_longident x0, copy_option copy_pattern x1)\n | From.Parsetree.Ppat_variant (x0, x1) ->\n To.Parsetree.Ppat_variant (copy_label x0, copy_option copy_pattern x1)\n | From.Parsetree.Ppat_record (x0, x1) ->\n To.Parsetree.Ppat_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_pattern x1))\n x0,\n copy_closed_flag x1 )\n | From.Parsetree.Ppat_array x0 ->\n To.Parsetree.Ppat_array (List.map copy_pattern x0)\n | From.Parsetree.Ppat_or (x0, x1) ->\n To.Parsetree.Ppat_or (copy_pattern x0, copy_pattern x1)\n | From.Parsetree.Ppat_constraint (x0, x1) ->\n To.Parsetree.Ppat_constraint (copy_pattern x0, copy_core_type x1)\n | From.Parsetree.Ppat_type x0 ->\n To.Parsetree.Ppat_type (copy_loc copy_longident x0)\n | From.Parsetree.Ppat_lazy x0 -> To.Parsetree.Ppat_lazy (copy_pattern x0)\n | From.Parsetree.Ppat_unpack x0 ->\n To.Parsetree.Ppat_unpack (copy_loc (fun x -> x) x0)\n | From.Parsetree.Ppat_exception x0 ->\n To.Parsetree.Ppat_exception (copy_pattern x0)\n | From.Parsetree.Ppat_extension x0 ->\n To.Parsetree.Ppat_extension (copy_extension x0)\n\nand copy_core_type : From.Parsetree.core_type -> To.Parsetree.core_type =\n fun {\n From.Parsetree.ptyp_desc;\n From.Parsetree.ptyp_loc;\n From.Parsetree.ptyp_attributes;\n } ->\n {\n To.Parsetree.ptyp_desc = copy_core_type_desc ptyp_desc;\n To.Parsetree.ptyp_loc = copy_location ptyp_loc;\n To.Parsetree.ptyp_attributes = copy_attributes ptyp_attributes;\n }\n\nand copy_core_type_desc :\n From.Parsetree.core_type_desc -> To.Parsetree.core_type_desc = function\n | From.Parsetree.Ptyp_any -> To.Parsetree.Ptyp_any\n | From.Parsetree.Ptyp_var x0 -> To.Parsetree.Ptyp_var x0\n | From.Parsetree.Ptyp_arrow (x0, x1, x2) ->\n To.Parsetree.Ptyp_arrow\n ( copy_arg_label x0,\n inject_predef_option x0 (copy_core_type x1),\n copy_core_type x2 )\n | From.Parsetree.Ptyp_tuple x0 ->\n To.Parsetree.Ptyp_tuple (List.map copy_core_type x0)\n | From.Parsetree.Ptyp_constr (x0, x1) ->\n To.Parsetree.Ptyp_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Ptyp_object (x0, x1) ->\n To.Parsetree.Ptyp_object\n ( List.map\n (fun x ->\n let x0, x1, x2 = x in\n (x0, copy_attributes x1, copy_core_type x2))\n x0,\n copy_closed_flag x1 )\n | From.Parsetree.Ptyp_class (x0, x1) ->\n To.Parsetree.Ptyp_class\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Ptyp_alias (x0, x1) ->\n To.Parsetree.Ptyp_alias (copy_core_type x0, x1)\n | From.Parsetree.Ptyp_variant (x0, x1, x2) ->\n To.Parsetree.Ptyp_variant\n ( List.map copy_row_field x0,\n copy_closed_flag x1,\n copy_option (fun x -> List.map copy_label x) x2 )\n | From.Parsetree.Ptyp_poly (x0, x1) ->\n To.Parsetree.Ptyp_poly (List.map (fun x -> x) x0, copy_core_type x1)\n | From.Parsetree.Ptyp_package x0 ->\n To.Parsetree.Ptyp_package (copy_package_type x0)\n | From.Parsetree.Ptyp_extension x0 ->\n To.Parsetree.Ptyp_extension (copy_extension x0)\n\nand copy_package_type : From.Parsetree.package_type -> To.Parsetree.package_type\n =\n fun x ->\n let x0, x1 = x in\n ( copy_loc copy_longident x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_core_type x1))\n x1 )\n\nand copy_row_field : From.Parsetree.row_field -> To.Parsetree.row_field =\n function\n | From.Parsetree.Rtag (x0, x1, x2, x3) ->\n To.Parsetree.Rtag\n ( copy_label x0,\n copy_attributes x1,\n copy_bool x2,\n List.map copy_core_type x3 )\n | From.Parsetree.Rinherit x0 -> To.Parsetree.Rinherit (copy_core_type x0)\n\nand copy_attributes : From.Parsetree.attributes -> To.Parsetree.attributes =\n fun x -> List.map copy_attribute x\n\nand copy_attribute : From.Parsetree.attribute -> To.Parsetree.attribute =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload (from_loc x0) x1)\n\nand copy_payload loc : From.Parsetree.payload -> To.Parsetree.payload = function\n | From.Parsetree.PStr x0 -> To.Parsetree.PStr (copy_structure x0)\n | From.Parsetree.PSig _x0 -> migration_error loc \"signatures in attribute\"\n | From.Parsetree.PTyp x0 -> To.Parsetree.PTyp (copy_core_type x0)\n | From.Parsetree.PPat (x0, x1) ->\n To.Parsetree.PPat (copy_pattern x0, copy_option copy_expression x1)\n\nand copy_structure : From.Parsetree.structure -> To.Parsetree.structure =\n fun x -> List.map copy_structure_item x\n\nand copy_structure_item :\n From.Parsetree.structure_item -> To.Parsetree.structure_item =\n fun { From.Parsetree.pstr_desc; From.Parsetree.pstr_loc } ->\n {\n To.Parsetree.pstr_desc = copy_structure_item_desc pstr_desc;\n To.Parsetree.pstr_loc = copy_location pstr_loc;\n }\n\nand copy_structure_item_desc :\n From.Parsetree.structure_item_desc -> To.Parsetree.structure_item_desc =\n function\n | From.Parsetree.Pstr_eval (x0, x1) ->\n To.Parsetree.Pstr_eval (copy_expression x0, copy_attributes x1)\n | From.Parsetree.Pstr_value (x0, x1) ->\n To.Parsetree.Pstr_value (copy_rec_flag x0, List.map copy_value_binding x1)\n | From.Parsetree.Pstr_primitive x0 ->\n To.Parsetree.Pstr_primitive (copy_value_description x0)\n | From.Parsetree.Pstr_type (x0, x1) ->\n To.Parsetree.Pstr_type (type_declarations x0 x1)\n | From.Parsetree.Pstr_typext x0 ->\n To.Parsetree.Pstr_typext (copy_type_extension x0)\n | From.Parsetree.Pstr_exception x0 ->\n To.Parsetree.Pstr_exception (copy_extension_constructor x0)\n | From.Parsetree.Pstr_module x0 ->\n To.Parsetree.Pstr_module (copy_module_binding x0)\n | From.Parsetree.Pstr_recmodule x0 ->\n To.Parsetree.Pstr_recmodule (List.map copy_module_binding x0)\n | From.Parsetree.Pstr_modtype x0 ->\n To.Parsetree.Pstr_modtype (copy_module_type_declaration x0)\n | From.Parsetree.Pstr_open x0 ->\n To.Parsetree.Pstr_open (copy_open_description x0)\n | From.Parsetree.Pstr_class x0 ->\n To.Parsetree.Pstr_class (List.map copy_class_declaration x0)\n | From.Parsetree.Pstr_class_type x0 ->\n To.Parsetree.Pstr_class_type (List.map copy_class_type_declaration x0)\n | From.Parsetree.Pstr_include x0 ->\n To.Parsetree.Pstr_include (copy_include_declaration x0)\n | From.Parsetree.Pstr_attribute x0 ->\n To.Parsetree.Pstr_attribute (copy_attribute x0)\n | From.Parsetree.Pstr_extension (x0, x1) ->\n To.Parsetree.Pstr_extension (copy_extension x0, copy_attributes x1)\n\nand copy_include_declaration :\n From.Parsetree.include_declaration -> To.Parsetree.include_declaration =\n fun x -> copy_include_infos copy_module_expr x\n\nand copy_class_declaration :\n From.Parsetree.class_declaration -> To.Parsetree.class_declaration =\n fun x -> copy_class_infos copy_class_expr x\n\nand copy_class_expr : From.Parsetree.class_expr -> To.Parsetree.class_expr =\n fun {\n From.Parsetree.pcl_desc;\n From.Parsetree.pcl_loc;\n From.Parsetree.pcl_attributes;\n } ->\n {\n To.Parsetree.pcl_desc = copy_class_expr_desc pcl_desc;\n To.Parsetree.pcl_loc = copy_location pcl_loc;\n To.Parsetree.pcl_attributes = copy_attributes pcl_attributes;\n }\n\nand copy_class_expr_desc :\n From.Parsetree.class_expr_desc -> To.Parsetree.class_expr_desc = function\n | From.Parsetree.Pcl_constr (x0, x1) ->\n To.Parsetree.Pcl_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Pcl_structure x0 ->\n To.Parsetree.Pcl_structure (copy_class_structure x0)\n | From.Parsetree.Pcl_fun (x0, x1, x2, x3) ->\n To.Parsetree.Pcl_fun\n ( copy_arg_label x0,\n copy_option copy_expression x1,\n copy_pattern x2,\n copy_class_expr x3 )\n | From.Parsetree.Pcl_apply (x0, x1) ->\n To.Parsetree.Pcl_apply\n ( copy_class_expr x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | From.Parsetree.Pcl_let (x0, x1, x2) ->\n To.Parsetree.Pcl_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_class_expr x2)\n | From.Parsetree.Pcl_constraint (x0, x1) ->\n To.Parsetree.Pcl_constraint (copy_class_expr x0, copy_class_type x1)\n | From.Parsetree.Pcl_extension x0 ->\n To.Parsetree.Pcl_extension (copy_extension x0)\n\nand copy_class_structure :\n From.Parsetree.class_structure -> To.Parsetree.class_structure =\n fun { From.Parsetree.pcstr_self; From.Parsetree.pcstr_fields } ->\n {\n To.Parsetree.pcstr_self = copy_pattern pcstr_self;\n To.Parsetree.pcstr_fields = List.map copy_class_field pcstr_fields;\n }\n\nand copy_class_field : From.Parsetree.class_field -> To.Parsetree.class_field =\n fun {\n From.Parsetree.pcf_desc;\n From.Parsetree.pcf_loc;\n From.Parsetree.pcf_attributes;\n } ->\n {\n To.Parsetree.pcf_desc = copy_class_field_desc pcf_desc;\n To.Parsetree.pcf_loc = copy_location pcf_loc;\n To.Parsetree.pcf_attributes = copy_attributes pcf_attributes;\n }\n\nand copy_class_field_desc :\n From.Parsetree.class_field_desc -> To.Parsetree.class_field_desc = function\n | From.Parsetree.Pcf_inherit (x0, x1, x2) ->\n To.Parsetree.Pcf_inherit\n (copy_override_flag x0, copy_class_expr x1, copy_option (fun x -> x) x2)\n | From.Parsetree.Pcf_val x0 ->\n To.Parsetree.Pcf_val\n (let x0, x1, x2 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_mutable_flag x1,\n copy_class_field_kind x2 ))\n | From.Parsetree.Pcf_method x0 ->\n To.Parsetree.Pcf_method\n (let x0, x1, x2 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_private_flag x1,\n copy_class_field_kind x2 ))\n | From.Parsetree.Pcf_constraint x0 ->\n To.Parsetree.Pcf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | From.Parsetree.Pcf_initializer x0 ->\n To.Parsetree.Pcf_initializer (copy_expression x0)\n | From.Parsetree.Pcf_attribute x0 ->\n To.Parsetree.Pcf_attribute (copy_attribute x0)\n | From.Parsetree.Pcf_extension x0 ->\n To.Parsetree.Pcf_extension (copy_extension x0)\n\nand copy_class_field_kind :\n From.Parsetree.class_field_kind -> To.Parsetree.class_field_kind = function\n | From.Parsetree.Cfk_virtual x0 ->\n To.Parsetree.Cfk_virtual (copy_core_type x0)\n | From.Parsetree.Cfk_concrete (x0, x1) ->\n To.Parsetree.Cfk_concrete (copy_override_flag x0, copy_expression x1)\n\nand copy_module_binding :\n From.Parsetree.module_binding -> To.Parsetree.module_binding =\n fun {\n From.Parsetree.pmb_name;\n From.Parsetree.pmb_expr;\n From.Parsetree.pmb_attributes;\n From.Parsetree.pmb_loc;\n } ->\n {\n To.Parsetree.pmb_name = copy_loc (fun x -> x) pmb_name;\n To.Parsetree.pmb_expr = copy_module_expr pmb_expr;\n To.Parsetree.pmb_attributes = copy_attributes pmb_attributes;\n To.Parsetree.pmb_loc = copy_location pmb_loc;\n }\n\nand copy_module_expr : From.Parsetree.module_expr -> To.Parsetree.module_expr =\n fun {\n From.Parsetree.pmod_desc;\n From.Parsetree.pmod_loc;\n From.Parsetree.pmod_attributes;\n } ->\n {\n To.Parsetree.pmod_desc = copy_module_expr_desc pmod_desc;\n To.Parsetree.pmod_loc = copy_location pmod_loc;\n To.Parsetree.pmod_attributes = copy_attributes pmod_attributes;\n }\n\nand copy_module_expr_desc :\n From.Parsetree.module_expr_desc -> To.Parsetree.module_expr_desc = function\n | From.Parsetree.Pmod_ident x0 ->\n To.Parsetree.Pmod_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pmod_structure x0 ->\n To.Parsetree.Pmod_structure (copy_structure x0)\n | From.Parsetree.Pmod_functor (x0, x1, x2) ->\n To.Parsetree.Pmod_functor\n ( copy_loc (fun x -> x) x0,\n copy_option copy_module_type x1,\n copy_module_expr x2 )\n | From.Parsetree.Pmod_apply (x0, x1) ->\n To.Parsetree.Pmod_apply (copy_module_expr x0, copy_module_expr x1)\n | From.Parsetree.Pmod_constraint (x0, x1) ->\n To.Parsetree.Pmod_constraint (copy_module_expr x0, copy_module_type x1)\n | From.Parsetree.Pmod_unpack x0 ->\n To.Parsetree.Pmod_unpack (copy_expression x0)\n | From.Parsetree.Pmod_extension x0 ->\n To.Parsetree.Pmod_extension (copy_extension x0)\n\nand copy_module_type : From.Parsetree.module_type -> To.Parsetree.module_type =\n fun {\n From.Parsetree.pmty_desc;\n From.Parsetree.pmty_loc;\n From.Parsetree.pmty_attributes;\n } ->\n {\n To.Parsetree.pmty_desc = copy_module_type_desc pmty_desc;\n To.Parsetree.pmty_loc = copy_location pmty_loc;\n To.Parsetree.pmty_attributes = copy_attributes pmty_attributes;\n }\n\nand copy_module_type_desc :\n From.Parsetree.module_type_desc -> To.Parsetree.module_type_desc = function\n | From.Parsetree.Pmty_ident x0 ->\n To.Parsetree.Pmty_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pmty_signature x0 ->\n To.Parsetree.Pmty_signature (copy_signature x0)\n | From.Parsetree.Pmty_functor (x0, x1, x2) ->\n To.Parsetree.Pmty_functor\n ( copy_loc (fun x -> x) x0,\n copy_option copy_module_type x1,\n copy_module_type x2 )\n | From.Parsetree.Pmty_with (x0, x1) ->\n To.Parsetree.Pmty_with\n (copy_module_type x0, List.map copy_with_constraint x1)\n | From.Parsetree.Pmty_typeof x0 ->\n To.Parsetree.Pmty_typeof (copy_module_expr x0)\n | From.Parsetree.Pmty_extension x0 ->\n To.Parsetree.Pmty_extension (copy_extension x0)\n | From.Parsetree.Pmty_alias x0 ->\n To.Parsetree.Pmty_alias (copy_loc copy_longident x0)\n\nand copy_with_constraint :\n From.Parsetree.with_constraint -> To.Parsetree.with_constraint = function\n | From.Parsetree.Pwith_type (x0, x1) ->\n To.Parsetree.Pwith_type\n (copy_loc copy_longident x0, copy_type_declaration x1)\n | From.Parsetree.Pwith_module (x0, x1) ->\n To.Parsetree.Pwith_module\n (copy_loc copy_longident x0, copy_loc copy_longident x1)\n | From.Parsetree.Pwith_typesubst x0 ->\n To.Parsetree.Pwith_typesubst (copy_type_declaration x0)\n | From.Parsetree.Pwith_modsubst (x0, x1) ->\n To.Parsetree.Pwith_modsubst\n (copy_loc (fun x -> x) x0, copy_loc copy_longident x1)\n\nand copy_signature : From.Parsetree.signature -> To.Parsetree.signature =\n fun x -> List.map copy_signature_item x\n\nand copy_signature_item :\n From.Parsetree.signature_item -> To.Parsetree.signature_item =\n fun { From.Parsetree.psig_desc; From.Parsetree.psig_loc } ->\n {\n To.Parsetree.psig_desc = copy_signature_item_desc psig_desc;\n To.Parsetree.psig_loc = copy_location psig_loc;\n }\n\nand copy_signature_item_desc :\n From.Parsetree.signature_item_desc -> To.Parsetree.signature_item_desc =\n function\n | From.Parsetree.Psig_value x0 ->\n To.Parsetree.Psig_value (copy_value_description x0)\n | From.Parsetree.Psig_type (x0, x1) ->\n To.Parsetree.Psig_type (type_declarations x0 x1)\n | From.Parsetree.Psig_typext x0 ->\n To.Parsetree.Psig_typext (copy_type_extension x0)\n | From.Parsetree.Psig_exception x0 ->\n To.Parsetree.Psig_exception (copy_extension_constructor x0)\n | From.Parsetree.Psig_module x0 ->\n To.Parsetree.Psig_module (copy_module_declaration x0)\n | From.Parsetree.Psig_recmodule x0 ->\n To.Parsetree.Psig_recmodule (List.map copy_module_declaration x0)\n | From.Parsetree.Psig_modtype x0 ->\n To.Parsetree.Psig_modtype (copy_module_type_declaration x0)\n | From.Parsetree.Psig_open x0 ->\n To.Parsetree.Psig_open (copy_open_description x0)\n | From.Parsetree.Psig_include x0 ->\n To.Parsetree.Psig_include (copy_include_description x0)\n | From.Parsetree.Psig_class x0 ->\n To.Parsetree.Psig_class (List.map copy_class_description x0)\n | From.Parsetree.Psig_class_type x0 ->\n To.Parsetree.Psig_class_type (List.map copy_class_type_declaration x0)\n | From.Parsetree.Psig_attribute x0 ->\n To.Parsetree.Psig_attribute (copy_attribute x0)\n | From.Parsetree.Psig_extension (x0, x1) ->\n To.Parsetree.Psig_extension (copy_extension x0, copy_attributes x1)\n\nand copy_class_type_declaration :\n From.Parsetree.class_type_declaration -> To.Parsetree.class_type_declaration\n =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_description :\n From.Parsetree.class_description -> To.Parsetree.class_description =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_type : From.Parsetree.class_type -> To.Parsetree.class_type =\n fun {\n From.Parsetree.pcty_desc;\n From.Parsetree.pcty_loc;\n From.Parsetree.pcty_attributes;\n } ->\n {\n To.Parsetree.pcty_desc = copy_class_type_desc pcty_desc;\n To.Parsetree.pcty_loc = copy_location pcty_loc;\n To.Parsetree.pcty_attributes = copy_attributes pcty_attributes;\n }\n\nand copy_class_type_desc :\n From.Parsetree.class_type_desc -> To.Parsetree.class_type_desc = function\n | From.Parsetree.Pcty_constr (x0, x1) ->\n To.Parsetree.Pcty_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Pcty_signature x0 ->\n To.Parsetree.Pcty_signature (copy_class_signature x0)\n | From.Parsetree.Pcty_arrow (x0, x1, x2) ->\n To.Parsetree.Pcty_arrow\n ( copy_arg_label x0,\n inject_predef_option x0 (copy_core_type x1),\n copy_class_type x2 )\n | From.Parsetree.Pcty_extension x0 ->\n To.Parsetree.Pcty_extension (copy_extension x0)\n\nand copy_class_signature :\n From.Parsetree.class_signature -> To.Parsetree.class_signature =\n fun { From.Parsetree.pcsig_self; From.Parsetree.pcsig_fields } ->\n {\n To.Parsetree.pcsig_self = copy_core_type pcsig_self;\n To.Parsetree.pcsig_fields = List.map copy_class_type_field pcsig_fields;\n }\n\nand copy_class_type_field :\n From.Parsetree.class_type_field -> To.Parsetree.class_type_field =\n fun {\n From.Parsetree.pctf_desc;\n From.Parsetree.pctf_loc;\n From.Parsetree.pctf_attributes;\n } ->\n {\n To.Parsetree.pctf_desc = copy_class_type_field_desc pctf_desc;\n To.Parsetree.pctf_loc = copy_location pctf_loc;\n To.Parsetree.pctf_attributes = copy_attributes pctf_attributes;\n }\n\nand copy_class_type_field_desc :\n From.Parsetree.class_type_field_desc -> To.Parsetree.class_type_field_desc =\n function\n | From.Parsetree.Pctf_inherit x0 ->\n To.Parsetree.Pctf_inherit (copy_class_type x0)\n | From.Parsetree.Pctf_val x0 ->\n To.Parsetree.Pctf_val\n (let x0, x1, x2, x3 = x0 in\n (x0, copy_mutable_flag x1, copy_virtual_flag x2, copy_core_type x3))\n | From.Parsetree.Pctf_method x0 ->\n To.Parsetree.Pctf_method\n (let x0, x1, x2, x3 = x0 in\n (x0, copy_private_flag x1, copy_virtual_flag x2, copy_core_type x3))\n | From.Parsetree.Pctf_constraint x0 ->\n To.Parsetree.Pctf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | From.Parsetree.Pctf_attribute x0 ->\n To.Parsetree.Pctf_attribute (copy_attribute x0)\n | From.Parsetree.Pctf_extension x0 ->\n To.Parsetree.Pctf_extension (copy_extension x0)\n\nand copy_extension : From.Parsetree.extension -> To.Parsetree.extension =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload (from_loc x0) x1)\n\nand copy_class_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 From.Parsetree.class_infos ->\n 'g0 To.Parsetree.class_infos =\n fun f0\n {\n From.Parsetree.pci_virt;\n From.Parsetree.pci_params;\n From.Parsetree.pci_name;\n From.Parsetree.pci_expr;\n From.Parsetree.pci_loc;\n From.Parsetree.pci_attributes;\n } ->\n {\n To.Parsetree.pci_virt = copy_virtual_flag pci_virt;\n To.Parsetree.pci_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n pci_params;\n To.Parsetree.pci_name = copy_loc (fun x -> x) pci_name;\n To.Parsetree.pci_expr = f0 pci_expr;\n To.Parsetree.pci_loc = copy_location pci_loc;\n To.Parsetree.pci_attributes = copy_attributes pci_attributes;\n }\n\nand copy_virtual_flag : From.Asttypes.virtual_flag -> To.Asttypes.virtual_flag =\n function\n | From.Asttypes.Virtual -> To.Asttypes.Virtual\n | From.Asttypes.Concrete -> To.Asttypes.Concrete\n\nand copy_include_description :\n From.Parsetree.include_description -> To.Parsetree.include_description =\n fun x -> copy_include_infos copy_module_type x\n\nand copy_include_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 From.Parsetree.include_infos ->\n 'g0 To.Parsetree.include_infos =\n fun f0\n {\n From.Parsetree.pincl_mod;\n From.Parsetree.pincl_loc;\n From.Parsetree.pincl_attributes;\n } ->\n {\n To.Parsetree.pincl_mod = f0 pincl_mod;\n To.Parsetree.pincl_loc = copy_location pincl_loc;\n To.Parsetree.pincl_attributes = copy_attributes pincl_attributes;\n }\n\nand copy_open_description :\n From.Parsetree.open_description -> To.Parsetree.open_description =\n fun {\n From.Parsetree.popen_lid;\n From.Parsetree.popen_override;\n From.Parsetree.popen_loc;\n From.Parsetree.popen_attributes;\n } ->\n {\n To.Parsetree.popen_lid = copy_loc copy_longident popen_lid;\n To.Parsetree.popen_override = copy_override_flag popen_override;\n To.Parsetree.popen_loc = copy_location popen_loc;\n To.Parsetree.popen_attributes = copy_attributes popen_attributes;\n }\n\nand copy_override_flag :\n From.Asttypes.override_flag -> To.Asttypes.override_flag = function\n | From.Asttypes.Override -> To.Asttypes.Override\n | From.Asttypes.Fresh -> To.Asttypes.Fresh\n\nand copy_module_type_declaration :\n From.Parsetree.module_type_declaration ->\n To.Parsetree.module_type_declaration =\n fun {\n From.Parsetree.pmtd_name;\n From.Parsetree.pmtd_type;\n From.Parsetree.pmtd_attributes;\n From.Parsetree.pmtd_loc;\n } ->\n {\n To.Parsetree.pmtd_name = copy_loc (fun x -> x) pmtd_name;\n To.Parsetree.pmtd_type = copy_option copy_module_type pmtd_type;\n To.Parsetree.pmtd_attributes = copy_attributes pmtd_attributes;\n To.Parsetree.pmtd_loc = copy_location pmtd_loc;\n }\n\nand copy_module_declaration :\n From.Parsetree.module_declaration -> To.Parsetree.module_declaration =\n fun {\n From.Parsetree.pmd_name;\n From.Parsetree.pmd_type;\n From.Parsetree.pmd_attributes;\n From.Parsetree.pmd_loc;\n } ->\n {\n To.Parsetree.pmd_name = copy_loc (fun x -> x) pmd_name;\n To.Parsetree.pmd_type = copy_module_type pmd_type;\n To.Parsetree.pmd_attributes = copy_attributes pmd_attributes;\n To.Parsetree.pmd_loc = copy_location pmd_loc;\n }\n\nand copy_type_extension :\n From.Parsetree.type_extension -> To.Parsetree.type_extension =\n fun {\n From.Parsetree.ptyext_path;\n From.Parsetree.ptyext_params;\n From.Parsetree.ptyext_constructors;\n From.Parsetree.ptyext_private;\n From.Parsetree.ptyext_attributes;\n } ->\n {\n To.Parsetree.ptyext_path = copy_loc copy_longident ptyext_path;\n To.Parsetree.ptyext_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptyext_params;\n To.Parsetree.ptyext_constructors =\n List.map copy_extension_constructor ptyext_constructors;\n To.Parsetree.ptyext_private = copy_private_flag ptyext_private;\n To.Parsetree.ptyext_attributes = copy_attributes ptyext_attributes;\n }\n\nand copy_extension_constructor :\n From.Parsetree.extension_constructor -> To.Parsetree.extension_constructor =\n fun {\n From.Parsetree.pext_name;\n From.Parsetree.pext_kind;\n From.Parsetree.pext_loc;\n From.Parsetree.pext_attributes;\n } ->\n {\n To.Parsetree.pext_name = copy_loc (fun x -> x) pext_name;\n To.Parsetree.pext_kind =\n copy_extension_constructor_kind (from_loc pext_name) pext_kind;\n To.Parsetree.pext_loc = copy_location pext_loc;\n To.Parsetree.pext_attributes = copy_attributes pext_attributes;\n }\n\nand copy_extension_constructor_kind loc :\n From.Parsetree.extension_constructor_kind ->\n To.Parsetree.extension_constructor_kind = function\n | From.Parsetree.Pext_decl (x0, x1) ->\n To.Parsetree.Pext_decl\n (copy_constructor_arguments loc x0, copy_option copy_core_type x1)\n | From.Parsetree.Pext_rebind x0 ->\n To.Parsetree.Pext_rebind (copy_loc copy_longident x0)\n\nand copy_type_declaration :\n From.Parsetree.type_declaration -> To.Parsetree.type_declaration =\n fun {\n From.Parsetree.ptype_name;\n From.Parsetree.ptype_params;\n From.Parsetree.ptype_cstrs;\n From.Parsetree.ptype_kind;\n From.Parsetree.ptype_private;\n From.Parsetree.ptype_manifest;\n From.Parsetree.ptype_attributes;\n From.Parsetree.ptype_loc;\n } ->\n {\n To.Parsetree.ptype_name = copy_loc (fun x -> x) ptype_name;\n To.Parsetree.ptype_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptype_params;\n To.Parsetree.ptype_cstrs =\n List.map\n (fun x ->\n let x0, x1, x2 = x in\n (copy_core_type x0, copy_core_type x1, copy_location x2))\n ptype_cstrs;\n To.Parsetree.ptype_kind = copy_type_kind ptype_kind;\n To.Parsetree.ptype_private = copy_private_flag ptype_private;\n To.Parsetree.ptype_manifest = copy_option copy_core_type ptype_manifest;\n To.Parsetree.ptype_attributes = copy_attributes ptype_attributes;\n To.Parsetree.ptype_loc = copy_location ptype_loc;\n }\n\nand copy_private_flag : From.Asttypes.private_flag -> To.Asttypes.private_flag =\n function\n | From.Asttypes.Private -> To.Asttypes.Private\n | From.Asttypes.Public -> To.Asttypes.Public\n\nand copy_type_kind : From.Parsetree.type_kind -> To.Parsetree.type_kind =\n function\n | From.Parsetree.Ptype_abstract -> To.Parsetree.Ptype_abstract\n | From.Parsetree.Ptype_variant x0 ->\n To.Parsetree.Ptype_variant (List.map copy_constructor_declaration x0)\n | From.Parsetree.Ptype_record x0 ->\n To.Parsetree.Ptype_record (List.map copy_label_declaration x0)\n | From.Parsetree.Ptype_open -> To.Parsetree.Ptype_open\n\nand copy_constructor_declaration :\n From.Parsetree.constructor_declaration ->\n To.Parsetree.constructor_declaration =\n fun {\n From.Parsetree.pcd_name;\n From.Parsetree.pcd_args;\n From.Parsetree.pcd_res;\n From.Parsetree.pcd_loc;\n From.Parsetree.pcd_attributes;\n } ->\n {\n To.Parsetree.pcd_name = copy_loc (fun x -> x) pcd_name;\n To.Parsetree.pcd_args =\n copy_constructor_arguments (from_loc pcd_name) pcd_args;\n To.Parsetree.pcd_res = copy_option copy_core_type pcd_res;\n To.Parsetree.pcd_loc = copy_location pcd_loc;\n To.Parsetree.pcd_attributes = copy_attributes pcd_attributes;\n }\n\nand copy_constructor_arguments loc :\n From.Parsetree.constructor_arguments -> To.Parsetree.core_type list =\n function\n | From.Parsetree.Pcstr_tuple x0 -> List.map copy_core_type x0\n | From.Parsetree.Pcstr_record _x0 -> migration_error loc \"inline records\"\n\nand copy_label_declaration :\n From.Parsetree.label_declaration -> To.Parsetree.label_declaration =\n fun {\n From.Parsetree.pld_name;\n From.Parsetree.pld_mutable;\n From.Parsetree.pld_type;\n From.Parsetree.pld_loc;\n From.Parsetree.pld_attributes;\n } ->\n {\n To.Parsetree.pld_name = copy_loc (fun x -> x) pld_name;\n To.Parsetree.pld_mutable = copy_mutable_flag pld_mutable;\n To.Parsetree.pld_type = copy_core_type pld_type;\n To.Parsetree.pld_loc = copy_location pld_loc;\n To.Parsetree.pld_attributes = copy_attributes pld_attributes;\n }\n\nand copy_mutable_flag : From.Asttypes.mutable_flag -> To.Asttypes.mutable_flag =\n function\n | From.Asttypes.Immutable -> To.Asttypes.Immutable\n | From.Asttypes.Mutable -> To.Asttypes.Mutable\n\nand copy_variance : From.Asttypes.variance -> To.Asttypes.variance = function\n | From.Asttypes.Covariant -> To.Asttypes.Covariant\n | From.Asttypes.Contravariant -> To.Asttypes.Contravariant\n | From.Asttypes.Invariant -> To.Asttypes.Invariant\n\nand copy_value_description :\n From.Parsetree.value_description -> To.Parsetree.value_description =\n fun {\n From.Parsetree.pval_name;\n From.Parsetree.pval_type;\n From.Parsetree.pval_prim;\n From.Parsetree.pval_attributes;\n From.Parsetree.pval_loc;\n } ->\n {\n To.Parsetree.pval_name = copy_loc (fun x -> x) pval_name;\n To.Parsetree.pval_type = copy_core_type pval_type;\n To.Parsetree.pval_prim = List.map (fun x -> x) pval_prim;\n To.Parsetree.pval_attributes = copy_attributes pval_attributes;\n To.Parsetree.pval_loc = copy_location pval_loc;\n }\n\nand copy_arg_label : From.Asttypes.arg_label -> string = function\n | From.Asttypes.Nolabel -> \"\"\n | From.Asttypes.Labelled x0 -> x0\n | From.Asttypes.Optional x0 -> \"?\" ^ x0\n\nand copy_closed_flag : From.Asttypes.closed_flag -> To.Asttypes.closed_flag =\n function\n | From.Asttypes.Closed -> To.Asttypes.Closed\n | From.Asttypes.Open -> To.Asttypes.Open\n\nand copy_label : From.Asttypes.label -> To.Asttypes.label = fun x -> x\n\nand copy_rec_flag : From.Asttypes.rec_flag -> To.Asttypes.rec_flag = function\n | From.Asttypes.Nonrecursive -> To.Asttypes.Nonrecursive\n | From.Asttypes.Recursive -> To.Asttypes.Recursive\n\nand copy_constant loc : From.Parsetree.constant -> To.Asttypes.constant =\n function\n | From.Parsetree.Pconst_integer (x0, x1) -> (\n match x1 with\n | None -> To.Asttypes.Const_int (int_of_string x0)\n | Some 'l' -> To.Asttypes.Const_int32 (Int32.of_string x0)\n | Some 'L' -> To.Asttypes.Const_int64 (Int64.of_string x0)\n | Some 'n' -> To.Asttypes.Const_nativeint (Nativeint.of_string x0)\n | Some _ -> migration_error loc \"custom integer literals\")\n | From.Parsetree.Pconst_char x0 -> To.Asttypes.Const_char x0\n | From.Parsetree.Pconst_string (x0, x1) -> To.Asttypes.Const_string (x0, x1)\n | From.Parsetree.Pconst_float (x0, x1) -> (\n match x1 with\n | None -> To.Asttypes.Const_float x0\n | Some _ -> migration_error loc \"custom float literals\")\n\nand copy_option : 'f0 'g0. ('f0 -> 'g0) -> 'f0 option -> 'g0 option =\n fun f0 -> function None -> None | Some x0 -> Some (f0 x0)\n\nand copy_longident : Longident.t -> Longident.t = fun x -> x\n\nand copy_loc :\n 'f0 'g0. ('f0 -> 'g0) -> 'f0 From.Asttypes.loc -> 'g0 To.Asttypes.loc =\n fun f0 { From.Asttypes.txt; From.Asttypes.loc } ->\n { To.Asttypes.txt = f0 txt; To.Asttypes.loc = copy_location loc }\n\nand copy_location : Location.t -> Location.t = fun x -> x\nand copy_bool : bool -> bool = function false -> false | true -> true\n\nand type_declarations recflag types =\n match (recflag, List.map copy_type_declaration types) with\n | From.Asttypes.Recursive, types -> types\n | From.Asttypes.Nonrecursive, [] -> []\n | From.Asttypes.Nonrecursive, x :: xs ->\n let pos =\n {\n Lexing.pos_fname = \"_none_\";\n pos_lnum = 1;\n pos_bol = 0;\n pos_cnum = -1;\n }\n in\n let loc = { Location.loc_start = pos; loc_end = pos; loc_ghost = true } in\n let ptype_attributes =\n ({ To.Asttypes.txt = \"nonrec\"; loc }, To.Parsetree.PStr [])\n :: x.To.Parsetree.ptype_attributes\n in\n { x with To.Parsetree.ptype_attributes } :: xs\n\nlet rec copy_toplevel_phrase :\n From.Parsetree.toplevel_phrase -> To.Parsetree.toplevel_phrase = function\n | From.Parsetree.Ptop_def x0 -> To.Parsetree.Ptop_def (copy_structure x0)\n | From.Parsetree.Ptop_dir (x0, x1) ->\n To.Parsetree.Ptop_dir (x0, copy_directive_argument x1)\n\nand copy_directive_argument :\n From.Parsetree.directive_argument -> To.Parsetree.directive_argument =\n function\n | From.Parsetree.Pdir_none -> To.Parsetree.Pdir_none\n | From.Parsetree.Pdir_string x0 -> To.Parsetree.Pdir_string x0\n | From.Parsetree.Pdir_int (x0, _x1) ->\n To.Parsetree.Pdir_int (int_of_string x0)\n | From.Parsetree.Pdir_ident x0 -> To.Parsetree.Pdir_ident (copy_longident x0)\n | From.Parsetree.Pdir_bool x0 -> To.Parsetree.Pdir_bool (copy_bool x0)\n\nlet copy_cases x = List.map copy_case x\nlet copy_pat = copy_pattern\nlet copy_expr = copy_expression\nlet copy_typ = copy_core_type\n","(**************************************************************************)\n(* *)\n(* OCaml Migrate Parsetree *)\n(* *)\n(* Frédéric Bour *)\n(* Jérémie Dimino, Jane Street Europe *)\n(* *)\n(* Copyright 2017 Institut National de Recherche en Informatique et *)\n(* en Automatique (INRIA). *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* BEGIN of BLACK MAGIC *)\n(*$ open Ast_cinaps_helpers $*)\n\ntype _ witnesses = ..\n\ntype _ migration = ..\ntype _ migration += Undefined : _ migration\n\ntype 'a migration_info = {\n mutable next_version : 'a migration;\n mutable previous_version : 'a migration;\n}\n\n(** Abstract view of a version of an OCaml Ast *)\nmodule type Ast = sig\n (*$ foreach_module (fun m types ->\n printf \" module %s : sig\\n\" m;\n List.iter types ~f:(printf \" type %s\\n\");\n printf \" end\\n\"\n )\n *)\n module Parsetree : sig\n type structure\n type signature\n type toplevel_phrase\n type core_type\n type expression\n type pattern\n type case\n type type_declaration\n type type_extension\n type extension_constructor\n end\n(*$*)\n module Config : sig\n val ast_impl_magic_number : string\n val ast_intf_magic_number : string\n end\nend\n\n(* Shortcuts for talking about ast types outside of the module language *)\n\ntype 'a _types = 'a constraint 'a\n = <\n (*$ foreach_type (fun _ s -> printf \" %-21s : _;\\n\" s) *)\n structure : _;\n signature : _;\n toplevel_phrase : _;\n core_type : _;\n expression : _;\n pattern : _;\n case : _;\n type_declaration : _;\n type_extension : _;\n extension_constructor : _;\n(*$*)\n >\n;;\n\n(*$ foreach_type (fun _ s ->\n printf \"type 'a get_%s =\\n\" s;\n printf \" 'x constraint 'a _types = < %s : 'x; .. >\\n\" s\n ) *)\ntype 'a get_structure =\n 'x constraint 'a _types = < structure : 'x; .. >\ntype 'a get_signature =\n 'x constraint 'a _types = < signature : 'x; .. >\ntype 'a get_toplevel_phrase =\n 'x constraint 'a _types = < toplevel_phrase : 'x; .. >\ntype 'a get_core_type =\n 'x constraint 'a _types = < core_type : 'x; .. >\ntype 'a get_expression =\n 'x constraint 'a _types = < expression : 'x; .. >\ntype 'a get_pattern =\n 'x constraint 'a _types = < pattern : 'x; .. >\ntype 'a get_case =\n 'x constraint 'a _types = < case : 'x; .. >\ntype 'a get_type_declaration =\n 'x constraint 'a _types = < type_declaration : 'x; .. >\ntype 'a get_type_extension =\n 'x constraint 'a _types = < type_extension : 'x; .. >\ntype 'a get_extension_constructor =\n 'x constraint 'a _types = < extension_constructor : 'x; .. >\n(*$*)\n\nmodule type OCaml_version = sig\n module Ast : Ast\n val version : int\n val string_version : string\n type types = <\n (*$ foreach_type (fun m s -> printf \" %-21s : Ast.%s.%s;\\n\" s m s)*)\n structure : Ast.Parsetree.structure;\n signature : Ast.Parsetree.signature;\n toplevel_phrase : Ast.Parsetree.toplevel_phrase;\n core_type : Ast.Parsetree.core_type;\n expression : Ast.Parsetree.expression;\n pattern : Ast.Parsetree.pattern;\n case : Ast.Parsetree.case;\n type_declaration : Ast.Parsetree.type_declaration;\n type_extension : Ast.Parsetree.type_extension;\n extension_constructor : Ast.Parsetree.extension_constructor;\n(*$*)\n > _types\n type _ witnesses += Version : types witnesses\n val migration_info : types migration_info\nend\n\nmodule Make_witness(Ast : Ast) =\nstruct\n type types = <\n (*$ foreach_type (fun m s -> printf \" %-21s : Ast.%s.%s;\\n\" s m s)*)\n structure : Ast.Parsetree.structure;\n signature : Ast.Parsetree.signature;\n toplevel_phrase : Ast.Parsetree.toplevel_phrase;\n core_type : Ast.Parsetree.core_type;\n expression : Ast.Parsetree.expression;\n pattern : Ast.Parsetree.pattern;\n case : Ast.Parsetree.case;\n type_declaration : Ast.Parsetree.type_declaration;\n type_extension : Ast.Parsetree.type_extension;\n extension_constructor : Ast.Parsetree.extension_constructor;\n(*$*)\n > _types\n type _ witnesses += Version : types witnesses\n let migration_info : types migration_info =\n { next_version = Undefined; previous_version = Undefined }\nend\n\ntype 'types ocaml_version =\n (module OCaml_version\n (*$ let sep = with_then_and () in\n foreach_type (fun m s ->\n printf \" %t type Ast.%s.%s = 'types get_%s\\n\" sep m s s) *)\n with type Ast.Parsetree.structure = 'types get_structure\n and type Ast.Parsetree.signature = 'types get_signature\n and type Ast.Parsetree.toplevel_phrase = 'types get_toplevel_phrase\n and type Ast.Parsetree.core_type = 'types get_core_type\n and type Ast.Parsetree.expression = 'types get_expression\n and type Ast.Parsetree.pattern = 'types get_pattern\n and type Ast.Parsetree.case = 'types get_case\n and type Ast.Parsetree.type_declaration = 'types get_type_declaration\n and type Ast.Parsetree.type_extension = 'types get_type_extension\n and type Ast.Parsetree.extension_constructor = 'types get_extension_constructor\n(*$*)\n )\n\ntype ('from, 'to_) migration_functions = {\n (*$ foreach_type (fun _ s ->\n printf \" copy_%s: 'from get_%s -> 'to_ get_%s;\\n\" s s s) *)\n copy_structure: 'from get_structure -> 'to_ get_structure;\n copy_signature: 'from get_signature -> 'to_ get_signature;\n copy_toplevel_phrase: 'from get_toplevel_phrase -> 'to_ get_toplevel_phrase;\n copy_core_type: 'from get_core_type -> 'to_ get_core_type;\n copy_expression: 'from get_expression -> 'to_ get_expression;\n copy_pattern: 'from get_pattern -> 'to_ get_pattern;\n copy_case: 'from get_case -> 'to_ get_case;\n copy_type_declaration: 'from get_type_declaration -> 'to_ get_type_declaration;\n copy_type_extension: 'from get_type_extension -> 'to_ get_type_extension;\n copy_extension_constructor: 'from get_extension_constructor -> 'to_ get_extension_constructor;\n(*$*)\n}\n\nlet id x = x\nlet migration_identity : ('a, 'a) migration_functions = {\n (*$ foreach_type (fun _ s -> printf \" copy_%s = id;\\n\" s) *)\n copy_structure = id;\n copy_signature = id;\n copy_toplevel_phrase = id;\n copy_core_type = id;\n copy_expression = id;\n copy_pattern = id;\n copy_case = id;\n copy_type_declaration = id;\n copy_type_extension = id;\n copy_extension_constructor = id;\n(*$*)\n}\n\nlet compose f g x = f (g x)\nlet migration_compose (ab : ('a, 'b) migration_functions) (bc : ('b, 'c) migration_functions) : ('a, 'c) migration_functions = {\n (*$ foreach_type (fun _ s ->\n printf \" copy_%-21s = compose bc.copy_%-21s ab.copy_%s;\\n\" s s s) *)\n copy_structure = compose bc.copy_structure ab.copy_structure;\n copy_signature = compose bc.copy_signature ab.copy_signature;\n copy_toplevel_phrase = compose bc.copy_toplevel_phrase ab.copy_toplevel_phrase;\n copy_core_type = compose bc.copy_core_type ab.copy_core_type;\n copy_expression = compose bc.copy_expression ab.copy_expression;\n copy_pattern = compose bc.copy_pattern ab.copy_pattern;\n copy_case = compose bc.copy_case ab.copy_case;\n copy_type_declaration = compose bc.copy_type_declaration ab.copy_type_declaration;\n copy_type_extension = compose bc.copy_type_extension ab.copy_type_extension;\n copy_extension_constructor = compose bc.copy_extension_constructor ab.copy_extension_constructor;\n(*$*)\n}\n\ntype _ migration += Migration : 'from ocaml_version * ('from, 'to_) migration_functions * 'to_ ocaml_version -> 'from migration\n\nmodule type Migrate_module = sig\n module From : Ast\n module To : Ast\n (*$ foreach_type (fun m s ->\n printf \" val copy_%-21s: From.%s.%s -> To.%s.%s\\n\" s m s m s) *)\n val copy_structure : From.Parsetree.structure -> To.Parsetree.structure\n val copy_signature : From.Parsetree.signature -> To.Parsetree.signature\n val copy_toplevel_phrase : From.Parsetree.toplevel_phrase -> To.Parsetree.toplevel_phrase\n val copy_core_type : From.Parsetree.core_type -> To.Parsetree.core_type\n val copy_expression : From.Parsetree.expression -> To.Parsetree.expression\n val copy_pattern : From.Parsetree.pattern -> To.Parsetree.pattern\n val copy_case : From.Parsetree.case -> To.Parsetree.case\n val copy_type_declaration : From.Parsetree.type_declaration -> To.Parsetree.type_declaration\n val copy_type_extension : From.Parsetree.type_extension -> To.Parsetree.type_extension\n val copy_extension_constructor: From.Parsetree.extension_constructor -> To.Parsetree.extension_constructor\n(*$*)\nend\n\nmodule Migration_functions\n (A : OCaml_version) (B : OCaml_version)\n (A_to_B : Migrate_module with module From = A.Ast and module To = B.Ast)\n=\nstruct\n let migration_functions : (A.types, B.types) migration_functions =\n let open A_to_B in\n {\n (*$ foreach_type (fun _ s -> printf \" copy_%s;\\n\" s) *)\n copy_structure;\n copy_signature;\n copy_toplevel_phrase;\n copy_core_type;\n copy_expression;\n copy_pattern;\n copy_case;\n copy_type_declaration;\n copy_type_extension;\n copy_extension_constructor;\n(*$*)\n }\nend\n\nmodule Register_migration (A : OCaml_version) (B : OCaml_version)\n (A_to_B : Migrate_module with module From = A.Ast and module To = B.Ast)\n (B_to_A : Migrate_module with module From = B.Ast and module To = A.Ast)\n=\nstruct\n let () = (\n let is_undefined : type a. a migration -> bool = function\n | Undefined -> true\n | _ -> false\n in\n assert (A.version < B.version);\n assert (is_undefined A.migration_info.next_version);\n assert (is_undefined B.migration_info.previous_version);\n let module A_to_B_fun = Migration_functions(A)(B)(A_to_B) in\n let module B_to_A_fun = Migration_functions(B)(A)(B_to_A) in\n A.migration_info.next_version <-\n Migration ((module A), A_to_B_fun.migration_functions, (module B));\n B.migration_info.previous_version <-\n Migration ((module B), B_to_A_fun.migration_functions, (module A));\n )\nend\n\ntype 'from immediate_migration =\n | No_migration : 'from immediate_migration\n | Immediate_migration\n : ('from, 'to_) migration_functions * 'to_ ocaml_version\n -> 'from immediate_migration\n\nlet immediate_migration\n (*$ foreach_type (fun _ s -> printf \" (type %s)\\n\" s) *)\n (type structure)\n (type signature)\n (type toplevel_phrase)\n (type core_type)\n (type expression)\n (type pattern)\n (type case)\n (type type_declaration)\n (type type_extension)\n (type extension_constructor)\n(*$*)\n ((module A) : <\n (*$ foreach_type (fun _ s -> printf \" %-21s : %s;\\n\" s s) *)\n structure : structure;\n signature : signature;\n toplevel_phrase : toplevel_phrase;\n core_type : core_type;\n expression : expression;\n pattern : pattern;\n case : case;\n type_declaration : type_declaration;\n type_extension : type_extension;\n extension_constructor : extension_constructor;\n(*$*)\n > ocaml_version)\n direction\n =\n let version = match direction with\n | `Next -> A.migration_info.next_version\n | `Previous -> A.migration_info.previous_version\n in\n match version with\n | Undefined -> No_migration\n | Migration (_, funs, to_) -> Immediate_migration (funs, to_)\n | _ -> assert false\n\nlet migrate\n (*$ foreach_type (fun _ s -> printf \" (type %s1) (type %s2)\\n\" s s) *)\n (type structure1) (type structure2)\n (type signature1) (type signature2)\n (type toplevel_phrase1) (type toplevel_phrase2)\n (type core_type1) (type core_type2)\n (type expression1) (type expression2)\n (type pattern1) (type pattern2)\n (type case1) (type case2)\n (type type_declaration1) (type type_declaration2)\n (type type_extension1) (type type_extension2)\n (type extension_constructor1) (type extension_constructor2)\n(*$*)\n ((module A) : <\n (*$ foreach_type (fun _ s -> printf \" %-21s : %s1;\\n\" s s) *)\n structure : structure1;\n signature : signature1;\n toplevel_phrase : toplevel_phrase1;\n core_type : core_type1;\n expression : expression1;\n pattern : pattern1;\n case : case1;\n type_declaration : type_declaration1;\n type_extension : type_extension1;\n extension_constructor : extension_constructor1;\n(*$*)\n > ocaml_version)\n ((module B) : <\n (*$ foreach_type (fun _ s -> printf \" %-21s : %s2;\\n\" s s) *)\n structure : structure2;\n signature : signature2;\n toplevel_phrase : toplevel_phrase2;\n core_type : core_type2;\n expression : expression2;\n pattern : pattern2;\n case : case2;\n type_declaration : type_declaration2;\n type_extension : type_extension2;\n extension_constructor : extension_constructor2;\n(*$*)\n > ocaml_version)\n : (A.types, B.types) migration_functions\n =\n match A.Version with\n | B.Version -> migration_identity\n | _ ->\n let direction = if A.version < B.version then `Next else `Previous in\n let rec migrate (m : A.types immediate_migration) : (A.types, B.types) migration_functions =\n match m with\n | No_migration -> assert false\n | Immediate_migration (f, (module To)) ->\n match To.Version with\n | B.Version -> f\n | _ ->\n match immediate_migration (module To) direction with\n | No_migration -> assert false\n | Immediate_migration (g, to2) ->\n migrate (Immediate_migration (migration_compose f g, to2))\n in\n migrate (immediate_migration (module A) direction)\n\nmodule Convert (A : OCaml_version) (B : OCaml_version) = struct\n let {\n (*$ foreach_type (fun _ s -> printf \" copy_%s;\\n\" s) *)\n copy_structure;\n copy_signature;\n copy_toplevel_phrase;\n copy_core_type;\n copy_expression;\n copy_pattern;\n copy_case;\n copy_type_declaration;\n copy_type_extension;\n copy_extension_constructor;\n(*$*)\n } : (A.types, B.types) migration_functions =\n migrate (module A) (module B)\nend\n\n(*$ foreach_version (fun n version ->\n printf \"module OCaml_%d = struct\\n\" n;\n printf \" module Ast = Astlib.Ast_%d\\n\" n;\n printf \" include Make_witness(Astlib.Ast_%d)\\n\" n;\n printf \" let version = %d\\n\" n;\n printf \" let string_version = %S\\n\" version;\n printf \"end\\n\";\n printf \"let ocaml_%d : OCaml_%d.types ocaml_version = (module OCaml_%d)\\n\"\n n n n;\n )\n*)\nmodule OCaml_402 = struct\n module Ast = Astlib.Ast_402\n include Make_witness(Astlib.Ast_402)\n let version = 402\n let string_version = \"4.02\"\nend\nlet ocaml_402 : OCaml_402.types ocaml_version = (module OCaml_402)\nmodule OCaml_403 = struct\n module Ast = Astlib.Ast_403\n include Make_witness(Astlib.Ast_403)\n let version = 403\n let string_version = \"4.03\"\nend\nlet ocaml_403 : OCaml_403.types ocaml_version = (module OCaml_403)\nmodule OCaml_404 = struct\n module Ast = Astlib.Ast_404\n include Make_witness(Astlib.Ast_404)\n let version = 404\n let string_version = \"4.04\"\nend\nlet ocaml_404 : OCaml_404.types ocaml_version = (module OCaml_404)\nmodule OCaml_405 = struct\n module Ast = Astlib.Ast_405\n include Make_witness(Astlib.Ast_405)\n let version = 405\n let string_version = \"4.05\"\nend\nlet ocaml_405 : OCaml_405.types ocaml_version = (module OCaml_405)\nmodule OCaml_406 = struct\n module Ast = Astlib.Ast_406\n include Make_witness(Astlib.Ast_406)\n let version = 406\n let string_version = \"4.06\"\nend\nlet ocaml_406 : OCaml_406.types ocaml_version = (module OCaml_406)\nmodule OCaml_407 = struct\n module Ast = Astlib.Ast_407\n include Make_witness(Astlib.Ast_407)\n let version = 407\n let string_version = \"4.07\"\nend\nlet ocaml_407 : OCaml_407.types ocaml_version = (module OCaml_407)\nmodule OCaml_408 = struct\n module Ast = Astlib.Ast_408\n include Make_witness(Astlib.Ast_408)\n let version = 408\n let string_version = \"4.08\"\nend\nlet ocaml_408 : OCaml_408.types ocaml_version = (module OCaml_408)\nmodule OCaml_409 = struct\n module Ast = Astlib.Ast_409\n include Make_witness(Astlib.Ast_409)\n let version = 409\n let string_version = \"4.09\"\nend\nlet ocaml_409 : OCaml_409.types ocaml_version = (module OCaml_409)\nmodule OCaml_410 = struct\n module Ast = Astlib.Ast_410\n include Make_witness(Astlib.Ast_410)\n let version = 410\n let string_version = \"4.10\"\nend\nlet ocaml_410 : OCaml_410.types ocaml_version = (module OCaml_410)\nmodule OCaml_411 = struct\n module Ast = Astlib.Ast_411\n include Make_witness(Astlib.Ast_411)\n let version = 411\n let string_version = \"4.11\"\nend\nlet ocaml_411 : OCaml_411.types ocaml_version = (module OCaml_411)\nmodule OCaml_412 = struct\n module Ast = Astlib.Ast_412\n include Make_witness(Astlib.Ast_412)\n let version = 412\n let string_version = \"4.12\"\nend\nlet ocaml_412 : OCaml_412.types ocaml_version = (module OCaml_412)\nmodule OCaml_413 = struct\n module Ast = Astlib.Ast_413\n include Make_witness(Astlib.Ast_413)\n let version = 413\n let string_version = \"4.13\"\nend\nlet ocaml_413 : OCaml_413.types ocaml_version = (module OCaml_413)\nmodule OCaml_414 = struct\n module Ast = Astlib.Ast_414\n include Make_witness(Astlib.Ast_414)\n let version = 414\n let string_version = \"4.14\"\nend\nlet ocaml_414 : OCaml_414.types ocaml_version = (module OCaml_414)\n(*$*)\n\nlet all_versions : (module OCaml_version) list = [\n (*$foreach_version (fun n _ ->\n printf \"(module OCaml_%d : OCaml_version);\\n\" n)*)\n(module OCaml_402 : OCaml_version);\n(module OCaml_403 : OCaml_version);\n(module OCaml_404 : OCaml_version);\n(module OCaml_405 : OCaml_version);\n(module OCaml_406 : OCaml_version);\n(module OCaml_407 : OCaml_version);\n(module OCaml_408 : OCaml_version);\n(module OCaml_409 : OCaml_version);\n(module OCaml_410 : OCaml_version);\n(module OCaml_411 : OCaml_version);\n(module OCaml_412 : OCaml_version);\n(module OCaml_413 : OCaml_version);\n(module OCaml_414 : OCaml_version);\n(*$*)\n]\n\n(*$foreach_version_pair (fun a b ->\n printf \"include Register_migration(OCaml_%d)(OCaml_%d)\\n\" a b;\n printf \" (Astlib.Migrate_%d_%d)(Astlib.Migrate_%d_%d)\\n\" a b b a\n )\n*)\ninclude Register_migration(OCaml_402)(OCaml_403)\n (Astlib.Migrate_402_403)(Astlib.Migrate_403_402)\ninclude Register_migration(OCaml_403)(OCaml_404)\n (Astlib.Migrate_403_404)(Astlib.Migrate_404_403)\ninclude Register_migration(OCaml_404)(OCaml_405)\n (Astlib.Migrate_404_405)(Astlib.Migrate_405_404)\ninclude Register_migration(OCaml_405)(OCaml_406)\n (Astlib.Migrate_405_406)(Astlib.Migrate_406_405)\ninclude Register_migration(OCaml_406)(OCaml_407)\n (Astlib.Migrate_406_407)(Astlib.Migrate_407_406)\ninclude Register_migration(OCaml_407)(OCaml_408)\n (Astlib.Migrate_407_408)(Astlib.Migrate_408_407)\ninclude Register_migration(OCaml_408)(OCaml_409)\n (Astlib.Migrate_408_409)(Astlib.Migrate_409_408)\ninclude Register_migration(OCaml_409)(OCaml_410)\n (Astlib.Migrate_409_410)(Astlib.Migrate_410_409)\ninclude Register_migration(OCaml_410)(OCaml_411)\n (Astlib.Migrate_410_411)(Astlib.Migrate_411_410)\ninclude Register_migration(OCaml_411)(OCaml_412)\n (Astlib.Migrate_411_412)(Astlib.Migrate_412_411)\ninclude Register_migration(OCaml_412)(OCaml_413)\n (Astlib.Migrate_412_413)(Astlib.Migrate_413_412)\ninclude Register_migration(OCaml_413)(OCaml_414)\n (Astlib.Migrate_413_414)(Astlib.Migrate_414_413)\n(*$*)\n\nmodule OCaml_current = OCaml_OCAML_VERSION\n\nmodule Find_version = struct\n type t = Impl of (module OCaml_version) | Intf of (module OCaml_version) | Unknown\n\n let from_magic magic =\n let rec loop = function\n | [] -> Unknown\n | (module Version : OCaml_version) :: tail ->\n if Version.Ast.Config.ast_impl_magic_number = magic then\n Impl (module Version)\n else if Version.Ast.Config.ast_intf_magic_number = magic then\n Intf (module Version)\n else\n loop tail\n in\n loop all_versions\nend\n","module Caml = Stdlib\nopen Caml\nopen StdLabels\nmodule Sexp = Sexplib0.Sexp\nmodule Sexpable = Sexplib0.Sexpable\ninclude Sexplib0.Sexp_conv\n\nmodule type Comparisons = sig\n type t\n\n val compare : t -> t -> int\n val equal : t -> t -> bool\n val ( = ) : t -> t -> bool\n val ( < ) : t -> t -> bool\n val ( > ) : t -> t -> bool\n val ( <> ) : t -> t -> bool\n val ( <= ) : t -> t -> bool\n val ( >= ) : t -> t -> bool\n val min : t -> t -> t\n val max : t -> t -> t\nend\n\nmodule Poly = struct\n let compare = compare\n let equal = ( = )\n let ( = ) = ( = )\n let ( < ) = ( < )\n let ( > ) = ( > )\n let ( <> ) = ( <> )\n let ( <= ) = ( <= )\n let ( >= ) = ( >= )\n let min = min\n let max = max\nend\n\ninclude (Poly : Comparisons with type t := int)\nmodule Array = Array\n\nmodule Bool = struct\n let to_string = string_of_bool\n\n include (Poly : Comparisons with type t := bool)\nend\n\nmodule Bytes = struct\n include Bytes\n\n let sub_string t ~pos ~len = Stdlib.Bytes.sub_string t pos len\n\n let blit_string ~src ~src_pos ~dst ~dst_pos ~len =\n Stdlib.Bytes.blit_string src src_pos dst dst_pos len\nend\n\nmodule Char = struct\n include Char\n include (Poly : Comparisons with type t := char)\nend\n\nmodule Exn = struct\n let protectx x ~f ~finally =\n match f x with\n | y ->\n finally x;\n y\n | exception exn ->\n finally x;\n raise exn\nend\n\nmodule Float = struct\n let to_string = string_of_float\n\n include (Poly : Comparisons with type t := float)\nend\n\nmodule Fn = struct\n let id x = x\nend\n\nmodule Hashtbl = struct\n include Hashtbl\n\n let set t ~key ~data =\n while mem t key do\n remove t key\n done;\n add t key data\n\n let add t ~key ~data =\n if mem t key then Error (Invalid_argument \"Hashtbl.add_exn\")\n else (\n add t key data;\n Ok ())\n\n let add_exn t ~key ~data =\n match add t ~key ~data with Ok () -> () | Error exn -> raise exn\n\n let find_opt t key =\n match find t key with data -> Some data | exception Not_found -> None\n\n let find_or_add t key ~default =\n match find_opt t key with\n | Some data -> data\n | None ->\n let data = default () in\n add_exn t ~key ~data;\n data\n\n let rec add_alist t alist =\n match alist with\n | [] -> Ok ()\n | (key, data) :: tail -> (\n match add t ~key ~data with\n | Ok () -> add_alist t tail\n | Error (_ : exn) -> Error key)\n\n let of_alist ?size alist =\n let size =\n match size with Some size -> size | None -> List.length alist\n in\n let t = create size in\n match add_alist t alist with Ok () -> Ok t | Error _ as error -> error\n\n let of_alist_exn ?size alist =\n match of_alist ?size alist with\n | Ok t -> t\n | Error _ -> raise (Invalid_argument \"Hashtbl.of_alist_exn\")\nend\n\nmodule In_channel = struct\n let create ?(binary = true) file =\n let flags = [ Open_rdonly ] in\n let flags = if binary then Open_binary :: flags else flags in\n open_in_gen flags 0o000 file\n\n let with_file ?binary filename ~f =\n let t = create ?binary filename in\n Exn.protectx t ~f ~finally:close_in\n\n let input_all t =\n let rec read_all_into t buf =\n match input_char t with\n | char ->\n Buffer.add_char buf char;\n read_all_into t buf\n | exception End_of_file -> ()\n in\n let buf = Buffer.create 64 in\n read_all_into t buf;\n Buffer.contents buf\n\n let read_all filename = with_file filename ~f:input_all\nend\n\nmodule Int = struct\n let max_int = max_int\n let to_string = string_of_int\n\n include (Poly : Comparisons with type t := int)\nend\n\nmodule List = struct\n include List\n\n include struct\n (* shadow non-tail-recursive functions *)\n let merge = `not_tail_recursive\n let remove_assoc = `not_tail_recursive\n let remove_assq = `not_tail_recursive\n\n let rev_mapi list ~f =\n let rec rev_mapi_at list i ~f ~acc =\n match list with\n | [] -> acc\n | head :: tail -> rev_mapi_at tail (i + 1) ~f ~acc:(f i head :: acc)\n in\n rev_mapi_at list 0 ~f ~acc:[]\n\n let fold_right2 list1 list2 ~init ~f =\n fold_left2 (rev list1) (rev list2) ~init ~f:(fun acc x y -> f x y acc)\n\n let map list ~f = rev (rev_map list ~f)\n let mapi list ~f = rev (rev_mapi list ~f)\n\n let fold_right list ~init ~f =\n fold_left (List.rev list) ~init ~f:(fun acc x -> f x acc)\n\n let append x y = rev_append (rev x) y\n let concat list = fold_right list ~init:[] ~f:append\n\n let rev_combine list1 list2 =\n fold_left2 list1 list2 ~init:[] ~f:(fun acc x y -> (x, y) :: acc)\n\n let combine list1 list2 = rev (rev_combine list1 list2)\n\n let split list =\n fold_right list ~init:([], []) ~f:(fun (x, y) (xs, ys) ->\n (x :: xs, y :: ys))\n\n let map2 list1 list2 ~f =\n rev (fold_left2 list1 list2 ~init:[] ~f:(fun acc x y -> f x y :: acc))\n end\n\n let init ~len ~f =\n let rec loop ~len ~pos ~f ~acc =\n if pos >= len then List.rev acc\n else loop ~len ~pos:(pos + 1) ~f ~acc:(f pos :: acc)\n in\n loop ~len ~pos:0 ~f ~acc:[]\n\n let is_empty = function [] -> true | _ :: _ -> false\n\n let rev_filter_opt list =\n fold_left list ~init:[] ~f:(fun tail option ->\n match option with None -> tail | Some head -> head :: tail)\n\n let filter_opt list = rev (rev_filter_opt list)\n let filter_map list ~f = rev_filter_opt (rev_map list ~f)\n let concat_map list ~f = concat (map list ~f)\n\n let rec find_map list ~f =\n match list with\n | [] -> None\n | head :: tail -> (\n match f head with Some _ as some -> some | None -> find_map tail ~f)\n\n let find_map_exn list ~f =\n match find_map list ~f with Some x -> x | None -> raise Not_found\n\n let rec last = function\n | [] -> None\n | [ x ] -> Some x\n | _ :: (_ :: _ as rest) -> last rest\n\n let split_while list ~f =\n let rec split_while_into list ~f ~acc =\n match list with\n | head :: tail when f head -> split_while_into tail ~f ~acc:(head :: acc)\n | _ :: _ | [] -> (List.rev acc, list)\n in\n split_while_into list ~f ~acc:[]\n\n let find_a_dup (type elt) list ~compare =\n let module Elt = struct\n type t = elt\n\n let compare = compare\n end in\n let module Elt_set = Set.Make (Elt) in\n let rec find_a_dup_in list ~set =\n match list with\n | [] -> None\n | head :: tail ->\n if Elt_set.mem head set then Some head\n else find_a_dup_in tail ~set:(Elt_set.add head set)\n in\n find_a_dup_in list ~set:Elt_set.empty\n\n let assoc_opt key alist =\n match assoc key alist with x -> Some x | exception Not_found -> None\n\n (* reorders arguments to improve type inference *)\n let iter list ~f = iter list ~f\nend\n\nmodule Option = struct\n let is_some = function None -> false | Some _ -> true\n let iter t ~f = match t with None -> () | Some x -> f x\n let map t ~f = match t with None -> None | Some x -> Some (f x)\n let value t ~default = match t with None -> default | Some x -> x\nend\n\nmodule Out_channel = struct\n let create ?(binary = true) ?(append = false) ?(fail_if_exists = false)\n ?(perm = 0o666) file =\n let flags = [ Open_wronly; Open_creat ] in\n let flags = (if binary then Open_binary else Open_text) :: flags in\n let flags = (if append then Open_append else Open_trunc) :: flags in\n let flags = if fail_if_exists then Open_excl :: flags else flags in\n open_out_gen flags perm file\n\n let with_file ?binary ?append ?fail_if_exists ?perm file ~f =\n let t = create ?binary ?append ?fail_if_exists ?perm file in\n Exn.protectx t ~f ~finally:close_out\n\n let write_all filename ~data =\n with_file filename ~f:(fun t -> output_string t data)\nend\n\nmodule String = struct\n include String\n\n let is_empty (t : t) = length t = 0\n let prefix t len = sub t ~pos:0 ~len\n let suffix t len = sub t ~pos:(length t - len) ~len\n let drop_prefix t len = sub t ~pos:len ~len:(length t - len)\n let drop_suffix t len = sub t ~pos:0 ~len:(length t - len)\n\n let is_prefix t ~prefix =\n let rec is_prefix_from t ~prefix ~pos ~len =\n pos >= len\n || Char.equal (get t pos) (get prefix pos)\n && is_prefix_from t ~prefix ~pos:(pos + 1) ~len\n in\n length t >= length prefix\n && is_prefix_from t ~prefix ~pos:0 ~len:(length prefix)\n\n let is_suffix t ~suffix =\n let rec is_suffix_up_to t ~suffix ~pos ~suffix_offset =\n pos < 0\n || Char.equal (get t (suffix_offset + pos)) (get suffix pos)\n && is_suffix_up_to t ~suffix ~pos:(pos - 1) ~suffix_offset\n in\n length t >= length suffix\n && is_suffix_up_to t ~suffix\n ~pos:(length suffix - 1)\n ~suffix_offset:(length t - length suffix)\n\n let exists t ~f =\n let rec exists_at t ~f ~pos ~len =\n pos < len && (f (get t pos) || exists_at t ~f ~pos:(pos + 1) ~len)\n in\n exists_at t ~f ~pos:0 ~len:(length t)\n\n let for_all t ~f =\n let rec for_all_at t ~f ~pos ~len =\n pos >= len || (f (get t pos) && for_all_at t ~f ~pos:(pos + 1) ~len)\n in\n for_all_at t ~f ~pos:0 ~len:(length t)\n\n let index_opt t char =\n match index t char with i -> Some i | exception Not_found -> None\n\n let rindex_opt t char =\n match rindex t char with i -> Some i | exception Not_found -> None\n\n let index_from_opt t char pos =\n match index_from t char pos with i -> Some i | exception Not_found -> None\n\n let rindex_from_opt t char pos =\n match rindex_from t char pos with\n | i -> Some i\n | exception Not_found -> None\n\n let lsplit2 t ~on =\n match index_opt t on with\n | None -> None\n | Some i ->\n Some (sub t ~pos:0 ~len:i, sub t ~pos:(i + 1) ~len:(length t - i - 1))\n\n let capitalize_ascii = Stdlib.String.capitalize_ascii\n let lowercase_ascii = Stdlib.String.lowercase_ascii\n let uncapitalize_ascii = Stdlib.String.uncapitalize_ascii\n let split_on_char t ~sep = Stdlib.String.split_on_char sep t\n\n include (Poly : Comparisons with type t := string)\n\n module Map = struct\n include Map.Make (String)\n\n let find_opt key t =\n match find key t with x -> Some x | exception Not_found -> None\n end\n\n module Set = Set.Make (String)\nend\n\nlet ( @ ) = List.append\nlet output oc bytes ~pos ~len = output oc bytes pos len\nlet output_substring oc string ~pos ~len = output_substring oc string pos len\n","open! Import\nmodule Format = Caml.Format\n\nlet fold_dot_suffixes name ~init:acc ~f =\n let rec collapse_after_at = function\n | [] -> []\n | part :: parts ->\n if (not (String.is_empty part)) && Char.equal part.[0] '@' then\n [ String.concat (String.drop_prefix part 1 :: parts) ~sep:\".\" ]\n else part :: collapse_after_at parts\n in\n let rec loop acc parts =\n match parts with\n | [] -> acc\n | part :: parts ->\n loop (f (String.concat (part :: parts) ~sep:\".\") acc) parts\n in\n String.split_on_char name ~sep:'.' |> collapse_after_at |> loop acc\n\nlet dot_suffixes name =\n fold_dot_suffixes name ~init:[] ~f:(fun x acc -> x :: acc)\n\nlet split_path =\n let rec loop s i =\n if i = String.length s then (s, None)\n else match s.[i] with '.' -> after_dot s (i + 1) | _ -> loop s (i + 1)\n and after_dot s i =\n if i = String.length s then (s, None)\n else\n match s.[i] with\n | 'A' .. 'Z' -> (String.prefix s (i - 1), Some (String.drop_prefix s i))\n | '.' -> after_dot s (i + 1)\n | _ -> loop s (i + 1)\n in\n fun s -> loop s 0\n\nmodule Pattern = struct\n type t = { name : string; dot_suffixes : String.Set.t }\n\n let make name =\n { name; dot_suffixes = String.Set.of_list (dot_suffixes name) }\n\n let name t = t.name\n let matches t matched = String.Set.mem matched t.dot_suffixes\nend\n\nlet get_outer_namespace name =\n match String.index_opt name '.' with\n | None -> None\n | Some i -> Some (String.sub name ~pos:0 ~len:i)\n\nmodule Whitelisted = struct\n (* White list the following attributes, as well as all their dot suffixes.\n\n Since these attributes are interpreted by the compiler itself, we cannot check\n at the level of a ppx rewriter that they have been properly interpreted, so\n we just accept them anywhere.\n\n Sadly, the compiler silently ignores them if they are misplaced...\n *)\n let create_set fully_qualified_names =\n List.fold_left\n ~f:(fun acc name ->\n fold_dot_suffixes name ~init:acc ~f:(fun x acc -> String.Set.add x acc))\n ~init:String.Set.empty fully_qualified_names\n\n let attributes =\n create_set\n [\n \"ocaml.alert\";\n \"ocaml.boxed\";\n \"ocaml.deprecated\";\n \"ocaml.deprecated_mutable\";\n \"ocaml.doc\";\n \"ocaml.extension_constructor\";\n \"ocaml.immediate\";\n \"ocaml.immediate64\";\n \"ocaml.inline\";\n \"ocaml.inlined\";\n \"ocaml.local\";\n \"ocaml.noalloc\";\n \"ocaml.ppwarning\";\n \"ocaml.remove_aliases\";\n \"ocaml.specialise\";\n \"ocaml.specialised\";\n \"ocaml.tailcall\";\n \"ocaml.text\";\n \"ocaml.unboxed\";\n \"ocaml.unroll\";\n \"ocaml.unrolled\";\n \"ocaml.untagged\";\n \"ocaml.warn_on_literal_pattern\";\n \"ocaml.warnerror\";\n \"ocaml.warning\";\n ]\n\n (* White list the following extensions.\n\n Since these extensions are interpreted by the compiler itself, we cannot check\n at the level of a ppx rewriter that they have been properly interpreted, so\n we just accept them anywhere.\n *)\n let extensions = create_set [ \"ocaml.error\"; \"ocaml.extension_constructor\" ]\n\n let is_whitelisted ~kind name =\n match kind with\n | `Attribute -> String.Set.mem name attributes\n | `Extension -> String.Set.mem name extensions\n\n let get_attribute_list () = String.Set.elements attributes\n let get_extension_list () = String.Set.elements extensions\nend\n\nmodule Reserved_namespaces = struct\n let tbl : (string, unit) Hashtbl.t = Hashtbl.create 16\n let reserve ns = Hashtbl.add_exn tbl ~key:ns ~data:()\n let () = reserve \"merlin\"\n let () = reserve \"reason\"\n let () = reserve \"refmt\"\n let () = reserve \"metaocaml\"\n let () = reserve \"ocamlformat\"\n\n let is_in_reserved_namespaces name =\n match get_outer_namespace name with\n | Some ns -> Hashtbl.mem tbl ns\n | None -> Hashtbl.mem tbl name\n\n let check_not_reserved ~kind name =\n let kind, list =\n match kind with\n | `Attribute -> (\"attribute\", Whitelisted.attributes)\n | `Extension -> (\"extension\", Whitelisted.extensions)\n in\n if String.Set.mem name list then\n Printf.ksprintf failwith\n \"Cannot register %s with name '%s' as it matches an %s reserved by the \\\n compiler\"\n kind name kind\n else if is_in_reserved_namespaces name then\n Printf.ksprintf failwith\n \"Cannot register %s with name '%s' as its namespace is marked as \\\n reserved\"\n kind name\nend\n\nlet ignore_checks name =\n Reserved_namespaces.is_in_reserved_namespaces name\n || String.is_prefix name ~prefix:\"_\"\n\nmodule Registrar = struct\n type element = { fully_qualified_name : string; declared_at : Caller_id.t }\n type all_for_context = { mutable all : element String.Map.t }\n\n type 'a t = {\n all_by_context : ('a, all_for_context) Hashtbl.t;\n skip : string list;\n kind : string;\n string_of_context : 'a -> string option;\n }\n\n let create ~kind ~current_file ~string_of_context =\n {\n all_by_context = Hashtbl.create 16;\n skip = [ current_file; __FILE__ ];\n kind;\n string_of_context;\n }\n\n let get_all_for_context t context =\n Hashtbl.find_or_add t.all_by_context context ~default:(fun () ->\n { all = String.Map.empty })\n\n let check_collisions_local ~caller ~all_for_context t context name =\n match String.Map.find_opt name all_for_context.all with\n | None -> ()\n | Some e ->\n let declared_at = function\n | None -> \"\"\n | Some (loc : Caml.Printexc.location) ->\n Printf.sprintf \" declared at %s:%d\" loc.filename loc.line_number\n in\n let context =\n match t.string_of_context context with\n | None -> \"\"\n | Some s -> \" on \" ^ s ^ \"s\"\n in\n Printf.ksprintf failwith\n \"Some ppx-es tried to register conflicting transformations: %s \\\n '%s'%s%s matches %s '%s'%s\"\n (String.capitalize_ascii t.kind)\n name context (declared_at caller) t.kind e.fully_qualified_name\n (declared_at e.declared_at)\n\n let check_collisions t context name =\n let caller = Caller_id.get ~skip:t.skip in\n let all_for_context = get_all_for_context t context in\n check_collisions_local ~caller ~all_for_context t context name\n\n let register ~kind t context name =\n Reserved_namespaces.check_not_reserved ~kind name;\n let caller = Caller_id.get ~skip:t.skip in\n let all = get_all_for_context t context in\n check_collisions_local ~caller ~all_for_context:all t context name;\n let t = { fully_qualified_name = name; declared_at = caller } in\n all.all <-\n fold_dot_suffixes name ~init:all.all ~f:(fun name acc ->\n String.Map.add name t acc)\n\n let spellcheck t context ?(white_list = []) name =\n let all =\n let all = get_all_for_context t context in\n String.Map.fold (fun key _ acc -> key :: acc) all.all []\n in\n match Spellcheck.spellcheck (all @ white_list) name with\n | Some _ as x -> x\n | None -> (\n let other_contexts =\n Hashtbl.fold\n (fun ctx { all } acc ->\n if Poly.( <> ) context ctx && String.Map.mem name all then\n match t.string_of_context ctx with\n | None -> acc\n | Some s -> (s ^ \"s\") :: acc\n else acc)\n t.all_by_context []\n in\n let pp_text = Format.pp_print_text in\n let current_context ppf =\n match t.string_of_context context with\n | None | Some \"\" -> ()\n | Some s ->\n let a_or_an =\n match s.[0] with\n | 'a' | 'e' | 'i' | 'o' | 'u' | 'y' -> \"an\"\n | _ -> \"a\"\n in\n Format.fprintf ppf\n \"@ but@ is@ used@ here@ in@ the@ context@ of@ %s@ %a\" a_or_an\n pp_text s\n in\n match\n List.sort ~cmp:(fun x y -> -String.compare x y) other_contexts\n with\n | [] -> None\n | [ c ] ->\n Some\n (Format.asprintf\n \"@[Hint:@ `%s'@ is@ available@ for@ %a%t.@]@\\n\\\n Did you put it at the wrong level?\" name pp_text c\n current_context)\n | last :: rev_others ->\n let others = List.rev rev_others in\n Some\n (Format.asprintf\n \"@[Hint:@ `%s'@ is@ available@ for@ %a@ and@ %a%t.@]@\\n\\\n Did you put it at the wrong level?\" name\n (Format.pp_print_list pp_text ~pp_sep:(fun ppf () ->\n Format.fprintf ppf \",@ \"))\n others pp_text last current_context))\n\n (* TODO: hint spelling errors regarding reserved namespaces names and white\n listed names instead of taking an optional [white_list] parameter. *)\n let raise_errorf t context ?white_list fmt (name : string Loc.t) =\n Printf.ksprintf\n (fun msg ->\n match spellcheck t context name.txt ?white_list with\n | None -> Location.raise_errorf ~loc:name.loc \"%s\" msg\n | Some s -> Location.raise_errorf ~loc:name.loc \"%s.\\n%s\" msg s)\n fmt name.txt\nend\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Jerome Vouillon, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 2002 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nopen Obj\n\n(**** Object representation ****)\n\nexternal set_id: 'a -> 'a = \"caml_set_oo_id\" [@@noalloc]\n\n(**** Object copy ****)\n\nlet copy o =\n let o = (Obj.obj (Obj.dup (Obj.repr o))) in\n set_id o\n\n(**** Compression options ****)\n(* Parameters *)\ntype params = {\n mutable compact_table : bool;\n mutable copy_parent : bool;\n mutable clean_when_copying : bool;\n mutable retry_count : int;\n mutable bucket_small_size : int\n }\n\nlet params = {\n compact_table = true;\n copy_parent = true;\n clean_when_copying = true;\n retry_count = 3;\n bucket_small_size = 16\n}\n\n(**** Parameters ****)\n\nlet initial_object_size = 2\n\n(**** Items ****)\n\ntype item = DummyA | DummyB | DummyC of int\nlet _ = [DummyA; DummyB; DummyC 0] (* to avoid warnings *)\n\nlet dummy_item = (magic () : item)\n\n(**** Types ****)\n\ntype tag\ntype label = int\ntype closure = item\ntype t = DummyA | DummyB | DummyC of int\nlet _ = [DummyA; DummyB; DummyC 0] (* to avoid warnings *)\n\ntype obj = t array\nexternal ret : (obj -> 'a) -> closure = \"%identity\"\n\n(**** Labels ****)\n\nlet public_method_label s : tag =\n let accu = ref 0 in\n for i = 0 to String.length s - 1 do\n accu := 223 * !accu + Char.code s.[i]\n done;\n (* reduce to 31 bits *)\n accu := !accu land (1 lsl 31 - 1);\n (* make it signed for 64 bits architectures *)\n let tag = if !accu > 0x3FFFFFFF then !accu - (1 lsl 31) else !accu in\n (* Printf.eprintf \"%s = %d\\n\" s tag; flush stderr; *)\n magic tag\n\n(**** Sparse array ****)\n\nmodule Vars =\n Map.Make(struct type t = string let compare (x:t) y = compare x y end)\ntype vars = int Vars.t\n\nmodule Meths =\n Map.Make(struct type t = string let compare (x:t) y = compare x y end)\ntype meths = label Meths.t\nmodule Labs =\n Map.Make(struct type t = label let compare (x:t) y = compare x y end)\ntype labs = bool Labs.t\n\n(* The compiler assumes that the first field of this structure is [size]. *)\ntype table =\n { mutable size: int;\n mutable methods: closure array;\n mutable methods_by_name: meths;\n mutable methods_by_label: labs;\n mutable previous_states:\n (meths * labs * (label * item) list * vars *\n label list * string list) list;\n mutable hidden_meths: (label * item) list;\n mutable vars: vars;\n mutable initializers: (obj -> unit) list }\n\nlet dummy_table =\n { methods = [| dummy_item |];\n methods_by_name = Meths.empty;\n methods_by_label = Labs.empty;\n previous_states = [];\n hidden_meths = [];\n vars = Vars.empty;\n initializers = [];\n size = 0 }\n\nlet table_count = ref 0\n\n(* dummy_met should be a pointer, so use an atom *)\nlet dummy_met : item = obj (Obj.new_block 0 0)\n(* if debugging is needed, this could be a good idea: *)\n(* let dummy_met () = failwith \"Undefined method\" *)\n\nlet rec fit_size n =\n if n <= 2 then n else\n fit_size ((n+1)/2) * 2\n\nlet new_table pub_labels =\n incr table_count;\n let len = Array.length pub_labels in\n let methods = Array.make (len*2+2) dummy_met in\n methods.(0) <- magic len;\n methods.(1) <- magic (fit_size len * Sys.word_size / 8 - 1);\n for i = 0 to len - 1 do methods.(i*2+3) <- magic pub_labels.(i) done;\n { methods = methods;\n methods_by_name = Meths.empty;\n methods_by_label = Labs.empty;\n previous_states = [];\n hidden_meths = [];\n vars = Vars.empty;\n initializers = [];\n size = initial_object_size }\n\nlet resize array new_size =\n let old_size = Array.length array.methods in\n if new_size > old_size then begin\n let new_buck = Array.make new_size dummy_met in\n Array.blit array.methods 0 new_buck 0 old_size;\n array.methods <- new_buck\n end\n\nlet put array label element =\n resize array (label + 1);\n array.methods.(label) <- element\n\n(**** Classes ****)\n\nlet method_count = ref 0\nlet inst_var_count = ref 0\n\n(* type t *)\ntype meth = item\n\nlet new_method table =\n let index = Array.length table.methods in\n resize table (index + 1);\n index\n\nlet get_method_label table name =\n try\n Meths.find name table.methods_by_name\n with Not_found ->\n let label = new_method table in\n table.methods_by_name <- Meths.add name label table.methods_by_name;\n table.methods_by_label <- Labs.add label true table.methods_by_label;\n label\n\nlet get_method_labels table names =\n Array.map (get_method_label table) names\n\nlet set_method table label element =\n incr method_count;\n if Labs.find label table.methods_by_label then\n put table label element\n else\n table.hidden_meths <- (label, element) :: table.hidden_meths\n\nlet get_method table label =\n try List.assoc label table.hidden_meths\n with Not_found -> table.methods.(label)\n\nlet to_list arr =\n if arr == magic 0 then [] else Array.to_list arr\n\nlet narrow table vars virt_meths concr_meths =\n let vars = to_list vars\n and virt_meths = to_list virt_meths\n and concr_meths = to_list concr_meths in\n let virt_meth_labs = List.map (get_method_label table) virt_meths in\n let concr_meth_labs = List.map (get_method_label table) concr_meths in\n table.previous_states <-\n (table.methods_by_name, table.methods_by_label, table.hidden_meths,\n table.vars, virt_meth_labs, vars)\n :: table.previous_states;\n table.vars <-\n Vars.fold\n (fun lab info tvars ->\n if List.mem lab vars then Vars.add lab info tvars else tvars)\n table.vars Vars.empty;\n let by_name = ref Meths.empty in\n let by_label = ref Labs.empty in\n List.iter2\n (fun met label ->\n by_name := Meths.add met label !by_name;\n by_label :=\n Labs.add label\n (try Labs.find label table.methods_by_label with Not_found -> true)\n !by_label)\n concr_meths concr_meth_labs;\n List.iter2\n (fun met label ->\n by_name := Meths.add met label !by_name;\n by_label := Labs.add label false !by_label)\n virt_meths virt_meth_labs;\n table.methods_by_name <- !by_name;\n table.methods_by_label <- !by_label;\n table.hidden_meths <-\n List.fold_right\n (fun ((lab, _) as met) hm ->\n if List.mem lab virt_meth_labs then hm else met::hm)\n table.hidden_meths\n []\n\nlet widen table =\n let (by_name, by_label, saved_hidden_meths, saved_vars, virt_meths, vars) =\n List.hd table.previous_states\n in\n table.previous_states <- List.tl table.previous_states;\n table.vars <-\n List.fold_left\n (fun s v -> Vars.add v (Vars.find v table.vars) s)\n saved_vars vars;\n table.methods_by_name <- by_name;\n table.methods_by_label <- by_label;\n table.hidden_meths <-\n List.fold_right\n (fun ((lab, _) as met) hm ->\n if List.mem lab virt_meths then hm else met::hm)\n table.hidden_meths\n saved_hidden_meths\n\nlet new_slot table =\n let index = table.size in\n table.size <- index + 1;\n index\n\nlet new_variable table name =\n try Vars.find name table.vars\n with Not_found ->\n let index = new_slot table in\n if name <> \"\" then table.vars <- Vars.add name index table.vars;\n index\n\nlet to_array arr =\n if arr = Obj.magic 0 then [||] else arr\n\nlet new_methods_variables table meths vals =\n let meths = to_array meths in\n let nmeths = Array.length meths and nvals = Array.length vals in\n let res = Array.make (nmeths + nvals) 0 in\n for i = 0 to nmeths - 1 do\n res.(i) <- get_method_label table meths.(i)\n done;\n for i = 0 to nvals - 1 do\n res.(i+nmeths) <- new_variable table vals.(i)\n done;\n res\n\nlet get_variable table name =\n try Vars.find name table.vars with Not_found -> assert false\n\nlet get_variables table names =\n Array.map (get_variable table) names\n\nlet add_initializer table f =\n table.initializers <- f::table.initializers\n\n(*\nmodule Keys =\n Map.Make(struct type t = tag array let compare (x:t) y = compare x y end)\nlet key_map = ref Keys.empty\nlet get_key tags : item =\n try magic (Keys.find tags !key_map : tag array)\n with Not_found ->\n key_map := Keys.add tags tags !key_map;\n magic tags\n*)\n\nlet create_table public_methods =\n if public_methods == magic 0 then new_table [||] else\n (* [public_methods] must be in ascending order for bytecode *)\n let tags = Array.map public_method_label public_methods in\n let table = new_table tags in\n Array.iteri\n (fun i met ->\n let lab = i*2+2 in\n table.methods_by_name <- Meths.add met lab table.methods_by_name;\n table.methods_by_label <- Labs.add lab true table.methods_by_label)\n public_methods;\n table\n\nlet init_class table =\n inst_var_count := !inst_var_count + table.size - 1;\n table.initializers <- List.rev table.initializers;\n resize table (3 + magic table.methods.(1) * 16 / Sys.word_size)\n\nlet inherits cla vals virt_meths concr_meths (_, super, _, env) top =\n narrow cla vals virt_meths concr_meths;\n let init =\n if top then super cla env else Obj.repr (super cla) in\n widen cla;\n Array.concat\n [[| repr init |];\n magic (Array.map (get_variable cla) (to_array vals) : int array);\n Array.map\n (fun nm -> repr (get_method cla (get_method_label cla nm) : closure))\n (to_array concr_meths) ]\n\nlet make_class pub_meths class_init =\n let table = create_table pub_meths in\n let env_init = class_init table in\n init_class table;\n (env_init (Obj.repr 0), class_init, env_init, Obj.repr 0)\n\ntype init_table = { mutable env_init: t; mutable class_init: table -> t }\n[@@warning \"-unused-field\"]\n\nlet make_class_store pub_meths class_init init_table =\n let table = create_table pub_meths in\n let env_init = class_init table in\n init_class table;\n init_table.class_init <- class_init;\n init_table.env_init <- env_init\n\nlet dummy_class loc =\n let undef = fun _ -> raise (Undefined_recursive_module loc) in\n (Obj.magic undef, undef, undef, Obj.repr 0)\n\n(**** Objects ****)\n\nlet create_object table =\n (* XXX Appel de [obj_block] | Call to [obj_block] *)\n let obj = Obj.new_block Obj.object_tag table.size in\n (* XXX Appel de [caml_modify] | Call to [caml_modify] *)\n Obj.set_field obj 0 (Obj.repr table.methods);\n Obj.obj (set_id obj)\n\nlet create_object_opt obj_0 table =\n if (Obj.magic obj_0 : bool) then obj_0 else begin\n (* XXX Appel de [obj_block] | Call to [obj_block] *)\n let obj = Obj.new_block Obj.object_tag table.size in\n (* XXX Appel de [caml_modify] | Call to [caml_modify] *)\n Obj.set_field obj 0 (Obj.repr table.methods);\n Obj.obj (set_id obj)\n end\n\nlet rec iter_f obj =\n function\n [] -> ()\n | f::l -> f obj; iter_f obj l\n\nlet run_initializers obj table =\n let inits = table.initializers in\n if inits <> [] then\n iter_f obj inits\n\nlet run_initializers_opt obj_0 obj table =\n if (Obj.magic obj_0 : bool) then obj else begin\n let inits = table.initializers in\n if inits <> [] then iter_f obj inits;\n obj\n end\n\nlet create_object_and_run_initializers obj_0 table =\n if (Obj.magic obj_0 : bool) then obj_0 else begin\n let obj = create_object table in\n run_initializers obj table;\n obj\n end\n\n(* Equivalent primitive below\nlet sendself obj lab =\n (magic obj : (obj -> t) array array).(0).(lab) obj\n*)\nexternal send : obj -> tag -> 'a = \"%send\"\nexternal sendcache : obj -> tag -> t -> int -> 'a = \"%sendcache\"\nexternal sendself : obj -> label -> 'a = \"%sendself\"\nexternal get_public_method : obj -> tag -> closure\n = \"caml_get_public_method\" [@@noalloc]\n\n(**** table collection access ****)\n\ntype tables =\n | Empty\n | Cons of {key : closure; mutable data: tables; mutable next: tables}\n\nlet set_data tables v = match tables with\n | Empty -> assert false\n | Cons tables -> tables.data <- v\nlet set_next tables v = match tables with\n | Empty -> assert false\n | Cons tables -> tables.next <- v\nlet get_key = function\n | Empty -> assert false\n | Cons tables -> tables.key\nlet get_data = function\n | Empty -> assert false\n | Cons tables -> tables.data\nlet get_next = function\n | Empty -> assert false\n | Cons tables -> tables.next\n\nlet build_path n keys tables =\n let res = Cons {key = Obj.magic 0; data = Empty; next = Empty} in\n let r = ref res in\n for i = 0 to n do\n r := Cons {key = keys.(i); data = !r; next = Empty}\n done;\n set_data tables !r;\n res\n\nlet rec lookup_keys i keys tables =\n if i < 0 then tables else\n let key = keys.(i) in\n let rec lookup_key (tables:tables) =\n if get_key tables == key then\n match get_data tables with\n | Empty -> assert false\n | Cons _ as tables_data ->\n lookup_keys (i-1) keys tables_data\n else\n match get_next tables with\n | Cons _ as next -> lookup_key next\n | Empty ->\n let next : tables = Cons {key; data = Empty; next = Empty} in\n set_next tables next;\n build_path (i-1) keys next\n in\n lookup_key tables\n\nlet lookup_tables root keys =\n match get_data root with\n | Cons _ as root_data ->\n lookup_keys (Array.length keys - 1) keys root_data\n | Empty ->\n build_path (Array.length keys - 1) keys root\n\n(**** builtin methods ****)\n\nlet get_const x = ret (fun _obj -> x)\nlet get_var n = ret (fun obj -> Array.unsafe_get obj n)\nlet get_env e n =\n ret (fun obj ->\n Array.unsafe_get (Obj.magic (Array.unsafe_get obj e) : obj) n)\nlet get_meth n = ret (fun obj -> sendself obj n)\nlet set_var n = ret (fun obj x -> Array.unsafe_set obj n x)\nlet app_const f x = ret (fun _obj -> f x)\nlet app_var f n = ret (fun obj -> f (Array.unsafe_get obj n))\nlet app_env f e n =\n ret (fun obj ->\n f (Array.unsafe_get (Obj.magic (Array.unsafe_get obj e) : obj) n))\nlet app_meth f n = ret (fun obj -> f (sendself obj n))\nlet app_const_const f x y = ret (fun _obj -> f x y)\nlet app_const_var f x n = ret (fun obj -> f x (Array.unsafe_get obj n))\nlet app_const_meth f x n = ret (fun obj -> f x (sendself obj n))\nlet app_var_const f n x = ret (fun obj -> f (Array.unsafe_get obj n) x)\nlet app_meth_const f n x = ret (fun obj -> f (sendself obj n) x)\nlet app_const_env f x e n =\n ret (fun obj ->\n f x (Array.unsafe_get (Obj.magic (Array.unsafe_get obj e) : obj) n))\nlet app_env_const f e n x =\n ret (fun obj ->\n f (Array.unsafe_get (Obj.magic (Array.unsafe_get obj e) : obj) n) x)\nlet meth_app_const n x = ret (fun obj -> (sendself obj n : _ -> _) x)\nlet meth_app_var n m =\n ret (fun obj -> (sendself obj n : _ -> _) (Array.unsafe_get obj m))\nlet meth_app_env n e m =\n ret (fun obj -> (sendself obj n : _ -> _)\n (Array.unsafe_get (Obj.magic (Array.unsafe_get obj e) : obj) m))\nlet meth_app_meth n m =\n ret (fun obj -> (sendself obj n : _ -> _) (sendself obj m))\nlet send_const m x c =\n ret (fun obj -> sendcache x m (Array.unsafe_get obj 0) c)\nlet send_var m n c =\n ret (fun obj ->\n sendcache (Obj.magic (Array.unsafe_get obj n) : obj) m\n (Array.unsafe_get obj 0) c)\nlet send_env m e n c =\n ret (fun obj ->\n sendcache\n (Obj.magic (Array.unsafe_get\n (Obj.magic (Array.unsafe_get obj e) : obj) n) : obj)\n m (Array.unsafe_get obj 0) c)\nlet send_meth m n c =\n ret (fun obj ->\n sendcache (sendself obj n) m (Array.unsafe_get obj 0) c)\nlet new_cache table =\n let n = new_method table in\n let n =\n if n mod 2 = 0 || n > 2 + magic table.methods.(1) * 16 / Sys.word_size\n then n else new_method table\n in\n table.methods.(n) <- Obj.magic 0;\n n\n\ntype impl =\n GetConst\n | GetVar\n | GetEnv\n | GetMeth\n | SetVar\n | AppConst\n | AppVar\n | AppEnv\n | AppMeth\n | AppConstConst\n | AppConstVar\n | AppConstEnv\n | AppConstMeth\n | AppVarConst\n | AppEnvConst\n | AppMethConst\n | MethAppConst\n | MethAppVar\n | MethAppEnv\n | MethAppMeth\n | SendConst\n | SendVar\n | SendEnv\n | SendMeth\n | Closure of closure\n\nlet method_impl table i arr =\n let next () = incr i; magic arr.(!i) in\n match next() with\n GetConst -> let x : t = next() in get_const x\n | GetVar -> let n = next() in get_var n\n | GetEnv -> let e = next() in let n = next() in get_env e n\n | GetMeth -> let n = next() in get_meth n\n | SetVar -> let n = next() in set_var n\n | AppConst -> let f = next() in let x = next() in app_const f x\n | AppVar -> let f = next() in let n = next () in app_var f n\n | AppEnv ->\n let f = next() in let e = next() in let n = next() in\n app_env f e n\n | AppMeth -> let f = next() in let n = next () in app_meth f n\n | AppConstConst ->\n let f = next() in let x = next() in let y = next() in\n app_const_const f x y\n | AppConstVar ->\n let f = next() in let x = next() in let n = next() in\n app_const_var f x n\n | AppConstEnv ->\n let f = next() in let x = next() in let e = next () in let n = next() in\n app_const_env f x e n\n | AppConstMeth ->\n let f = next() in let x = next() in let n = next() in\n app_const_meth f x n\n | AppVarConst ->\n let f = next() in let n = next() in let x = next() in\n app_var_const f n x\n | AppEnvConst ->\n let f = next() in let e = next () in let n = next() in let x = next() in\n app_env_const f e n x\n | AppMethConst ->\n let f = next() in let n = next() in let x = next() in\n app_meth_const f n x\n | MethAppConst ->\n let n = next() in let x = next() in meth_app_const n x\n | MethAppVar ->\n let n = next() in let m = next() in meth_app_var n m\n | MethAppEnv ->\n let n = next() in let e = next() in let m = next() in\n meth_app_env n e m\n | MethAppMeth ->\n let n = next() in let m = next() in meth_app_meth n m\n | SendConst ->\n let m = next() in let x = next() in send_const m x (new_cache table)\n | SendVar ->\n let m = next() in let n = next () in send_var m n (new_cache table)\n | SendEnv ->\n let m = next() in let e = next() in let n = next() in\n send_env m e n (new_cache table)\n | SendMeth ->\n let m = next() in let n = next () in send_meth m n (new_cache table)\n | Closure _ as clo -> magic clo\n\nlet set_methods table methods =\n let len = Array.length methods in let i = ref 0 in\n while !i < len do\n let label = methods.(!i) in let clo = method_impl table i methods in\n set_method table label clo;\n incr i\n done\n\n(**** Statistics ****)\n\ntype stats =\n { classes: int; methods: int; inst_vars: int; }\n\nlet stats () =\n { classes = !table_count;\n methods = !method_count; inst_vars = !inst_var_count; }\n","open Import\nopen Ast_builder.Default\n\n(* [do_insert_unused_warning_attribute] -- If true, generated code\n contains compiler attribute to disable unused warnings, instead of\n inserting [let _ = ... ]. *)\nlet do_insert_unused_warning_attribute = ref false\nlet keep_w32_impl = ref false\nlet keep_w32_intf = ref false\n\nlet () =\n let keep_w32_spec =\n Caml.Arg.Symbol\n ( [ \"impl\"; \"intf\"; \"both\" ],\n function\n | \"impl\" -> keep_w32_impl := true\n | \"intf\" -> keep_w32_intf := true\n | \"both\" ->\n keep_w32_impl := true;\n keep_w32_intf := true\n | _ -> assert false )\n in\n let conv_w32_spec =\n Caml.Arg.Symbol\n ( [ \"code\"; \"attribute\" ],\n function\n | \"code\" -> do_insert_unused_warning_attribute := false\n | \"attribute\" -> do_insert_unused_warning_attribute := true\n | _ -> assert false )\n in\n Driver.add_arg \"-deriving-keep-w32\" keep_w32_spec\n ~doc:\" Do not try to disable warning 32 for the generated code\";\n Driver.add_arg \"-deriving-disable-w32-method\" conv_w32_spec\n ~doc:\" How to disable warning 32 for the generated code\";\n Driver.add_arg \"-type-conv-keep-w32\" keep_w32_spec\n ~doc:\" Deprecated, use -deriving-keep-w32\";\n Driver.add_arg \"-type-conv-w32\" conv_w32_spec\n ~doc:\" Deprecated, use -deriving-disable-w32-method\"\n\nlet keep_w32_impl () = !keep_w32_impl || Driver.pretty ()\nlet keep_w32_intf () = !keep_w32_intf || Driver.pretty ()\nlet keep_w60_impl = ref false\nlet keep_w60_intf = ref false\n\nlet () =\n let keep_w60_spec =\n Caml.Arg.Symbol\n ( [ \"impl\"; \"intf\"; \"both\" ],\n function\n | \"impl\" -> keep_w60_impl := true\n | \"intf\" -> keep_w60_intf := true\n | \"both\" ->\n keep_w60_impl := true;\n keep_w60_intf := true\n | _ -> assert false )\n in\n Driver.add_arg \"-deriving-keep-w60\" keep_w60_spec\n ~doc:\" Do not try to disable warning 60 for the generated code\"\n\nlet keep_w60_impl () = !keep_w60_impl || Driver.pretty ()\nlet keep_w60_intf () = !keep_w60_intf || Driver.pretty ()\n\nmodule Args = struct\n include (\n Ast_pattern :\n module type of struct\n include Ast_pattern\n end\n with type ('a, 'b, 'c) t := ('a, 'b, 'c) Ast_pattern.t)\n\n type 'a param = {\n name : string;\n pattern : (expression, 'a) Ast_pattern.Packed.t;\n default : 'a;\n }\n\n let arg name pattern =\n {\n name;\n default = None;\n pattern = Ast_pattern.Packed.create pattern (fun x -> Some x);\n }\n\n let flag name =\n let pattern = pexp_ident (lident (string name)) in\n { name; default = false; pattern = Ast_pattern.Packed.create pattern true }\n\n type (_, _) t =\n | Nil : ('m, 'm) t\n | Cons : ('m1, 'a -> 'm2) t * 'a param -> ('m1, 'm2) t\n\n let empty = Nil\n let ( +> ) a b = Cons (a, b)\n\n let rec names : type a b. (a, b) t -> string list = function\n | Nil -> []\n | Cons (t, p) -> p.name :: names t\n\n module Instance = struct\n type (_, _) instance =\n | I_nil : ('m, 'm) instance\n | I_cons : ('m1, 'a -> 'm2) instance * 'a -> ('m1, 'm2) instance\n\n let rec create :\n type a b. (a, b) t -> (string * expression) list -> (a, b) instance =\n fun spec args ->\n match spec with\n | Nil -> I_nil\n | Cons (t, p) ->\n let value =\n match List.assoc_opt p.name args with\n | None -> p.default\n | Some expr -> Ast_pattern.Packed.parse p.pattern expr.pexp_loc expr\n in\n I_cons (create t args, value)\n\n let rec apply : type a b. (a, b) instance -> a -> b =\n fun t f -> match t with I_nil -> f | I_cons (t, x) -> apply t f x\n end\n\n let apply t args f = Instance.apply (Instance.create t args) f\nend\n\n(* +-----------------------------------------------------------------+\n | Generators |\n +-----------------------------------------------------------------+ *)\n\ntype t = string\n\nlet ignore (_ : t) = ()\n\ntype parsed_args =\n | Args of (string * expression) list\n | Unknown_syntax of Location.t * string\n\nmodule Generator = struct\n type deriver = t\n\n type ('a, 'b) t =\n | T : {\n spec : ('c, 'a) Args.t;\n gen : ctxt:Expansion_context.Deriver.t -> 'b -> 'c;\n arg_names : String.Set.t;\n attributes : Attribute.packed list;\n deps : deriver list;\n }\n -> ('a, 'b) t\n\n let deps (T t) = t.deps\n\n module V2 = struct\n let make ?(attributes = []) ?(deps = []) spec gen =\n let arg_names = String.Set.of_list (Args.names spec) in\n T { spec; gen; arg_names; attributes; deps }\n\n let make_noarg ?attributes ?deps gen = make ?attributes ?deps Args.empty gen\n end\n\n let make ?attributes ?deps spec gen =\n V2.make ?attributes ?deps spec\n (Expansion_context.Deriver.with_loc_and_path gen)\n\n let make_noarg ?attributes ?deps gen = make ?attributes ?deps Args.empty gen\n\n let merge_accepted_args l =\n let rec loop acc = function\n | [] -> acc\n | T t :: rest -> loop (String.Set.union acc t.arg_names) rest\n in\n loop String.Set.empty l\n\n let check_arguments name generators (args : (string * expression) list) =\n List.iter args ~f:(fun (label, e) ->\n if String.is_empty label then\n Location.raise_errorf ~loc:e.pexp_loc\n \"Ppxlib.Deriving: generator arguments must be labelled\");\n Option.iter\n (List.find_a_dup args ~compare:(fun (a, _) (b, _) -> String.compare a b))\n ~f:(fun (label, e) ->\n Location.raise_errorf ~loc:e.pexp_loc\n \"Ppxlib.Deriving: argument labelled '%s' appears more than once\" label);\n let accepted_args = merge_accepted_args generators in\n List.iter args ~f:(fun (label, e) ->\n if not (String.Set.mem label accepted_args) then\n let spellcheck_msg =\n match\n Spellcheck.spellcheck (String.Set.elements accepted_args) label\n with\n | None -> \"\"\n | Some s -> \".\\n\" ^ s\n in\n Location.raise_errorf ~loc:e.pexp_loc\n \"Ppxlib.Deriving: generator '%s' doesn't accept argument '%s'%s\"\n name label spellcheck_msg)\n\n let apply (T t) ~name:_ ~ctxt x args = Args.apply t.spec args (t.gen ~ctxt x)\n\n let apply_all ~ctxt entry (name, generators, args) =\n check_arguments name.txt generators args;\n List.concat_map generators ~f:(fun t ->\n apply t ~name:name.txt ~ctxt entry args)\n\n let apply_all ~ctxt entry generators =\n List.concat_map generators ~f:(apply_all ~ctxt entry)\nend\n\nmodule Deriver = struct\n module Actual_deriver = struct\n type t = {\n name : string;\n str_type_decl :\n (structure, rec_flag * type_declaration list) Generator.t option;\n str_type_ext : (structure, type_extension) Generator.t option;\n str_exception : (structure, type_exception) Generator.t option;\n str_module_type_decl :\n (structure, module_type_declaration) Generator.t option;\n sig_type_decl :\n (signature, rec_flag * type_declaration list) Generator.t option;\n sig_type_ext : (signature, type_extension) Generator.t option;\n sig_exception : (signature, type_exception) Generator.t option;\n sig_module_type_decl :\n (signature, module_type_declaration) Generator.t option;\n extension :\n (loc:Location.t -> path:string -> core_type -> expression) option;\n }\n end\n\n module Alias = struct\n type t = {\n str_type_decl : string list;\n str_type_ext : string list;\n str_exception : string list;\n str_module_type_decl : string list;\n sig_type_decl : string list;\n sig_type_ext : string list;\n sig_exception : string list;\n sig_module_type_decl : string list;\n }\n end\n\n module Field = struct\n type kind = Str | Sig\n\n type ('a, 'b) t = {\n name : string;\n kind : kind;\n get : Actual_deriver.t -> ('a, 'b) Generator.t option;\n get_set : Alias.t -> string list;\n }\n\n let str_type_decl =\n {\n kind = Str;\n name = \"type\";\n get = (fun t -> t.str_type_decl);\n get_set = (fun t -> t.str_type_decl);\n }\n\n let str_type_ext =\n {\n kind = Str;\n name = \"type extension\";\n get = (fun t -> t.str_type_ext);\n get_set = (fun t -> t.str_type_ext);\n }\n\n let str_exception =\n {\n kind = Str;\n name = \"exception\";\n get = (fun t -> t.str_exception);\n get_set = (fun t -> t.str_exception);\n }\n\n let str_module_type_decl =\n {\n kind = Str;\n name = \"module type\";\n get = (fun t -> t.str_module_type_decl);\n get_set = (fun t -> t.str_module_type_decl);\n }\n\n let sig_type_decl =\n {\n kind = Sig;\n name = \"signature type\";\n get = (fun t -> t.sig_type_decl);\n get_set = (fun t -> t.sig_type_decl);\n }\n\n let sig_type_ext =\n {\n kind = Sig;\n name = \"signature type extension\";\n get = (fun t -> t.sig_type_ext);\n get_set = (fun t -> t.sig_type_ext);\n }\n\n let sig_exception =\n {\n kind = Sig;\n name = \"signature exception\";\n get = (fun t -> t.sig_exception);\n get_set = (fun t -> t.sig_exception);\n }\n\n let sig_module_type_decl =\n {\n kind = Sig;\n name = \"signature module type\";\n get = (fun t -> t.sig_module_type_decl);\n get_set = (fun t -> t.sig_module_type_decl);\n }\n end\n\n type t = Actual_deriver of Actual_deriver.t | Alias of Alias.t\n type Ppx_derivers.deriver += T of t\n\n let derivers () =\n List.filter_map (Ppx_derivers.derivers ()) ~f:(function\n | name, T t -> Some (name, t)\n | _ -> None)\n\n exception Not_supported of string\n\n let resolve_actual_derivers (field : (_, _) Field.t) name =\n let rec loop name collected =\n if\n List.exists collected ~f:(fun (d : Actual_deriver.t) ->\n String.equal d.name name)\n then collected\n else\n match Ppx_derivers.lookup name with\n | Some (T (Actual_deriver drv)) -> drv :: collected\n | Some (T (Alias alias)) ->\n let set = field.get_set alias in\n List.fold_right set ~init:collected ~f:loop\n | _ -> raise (Not_supported name)\n in\n List.rev (loop name [])\n\n let resolve_internal (field : (_, _) Field.t) name =\n List.map (resolve_actual_derivers field name) ~f:(fun drv ->\n match field.get drv with\n | None -> raise (Not_supported name)\n | Some g -> (drv.name, g))\n\n let supported_for field =\n List.fold_left (derivers ()) ~init:String.Set.empty ~f:(fun acc (name, _) ->\n match resolve_internal field name with\n | _ -> String.Set.add name acc\n | exception Not_supported _ -> acc)\n |> String.Set.elements\n\n let not_supported (field : (_, _) Field.t) ?(spellcheck = true) name =\n let spellcheck_msg =\n if spellcheck then\n match Spellcheck.spellcheck (supported_for field) name.txt with\n | None -> \"\"\n | Some s -> \".\\n\" ^ s\n else \"\"\n in\n Location.raise_errorf ~loc:name.loc\n \"Ppxlib.Deriving: '%s' is not a supported %s deriving generator%s\"\n name.txt field.name spellcheck_msg\n\n let resolve field name =\n try resolve_internal field name.txt\n with Not_supported name' ->\n not_supported field ~spellcheck:(String.equal name.txt name') name\n\n let resolve_all field derivers =\n let derivers_and_args =\n List.filter_map derivers ~f:(fun (name, args) ->\n match Ppx_derivers.lookup name.txt with\n | None -> not_supported field name\n | Some (T _) ->\n (* It's one of ours, parse the arguments now. We can't do it before since\n ppx_deriving uses a different syntax for arguments. *)\n Some\n ( name,\n match args with\n | Args l -> l\n | Unknown_syntax (loc, msg) ->\n Location.raise_errorf ~loc \"Ppxlib.Deriving: %s\" msg )\n | Some _ ->\n (* It's not one of ours, ignore it. *)\n None)\n in\n (* Set of actual deriver names *)\n let seen = Hashtbl.create 16 in\n List.map derivers_and_args ~f:(fun (name, args) ->\n let named_generators = resolve field name in\n List.iter named_generators ~f:(fun (actual_deriver_name, gen) ->\n if\n Options.fail_on_duplicate_derivers\n && Hashtbl.mem seen actual_deriver_name\n then\n Location.raise_errorf ~loc:name.loc \"Deriver %s appears twice\"\n actual_deriver_name;\n List.iter (Generator.deps gen) ~f:(fun dep ->\n List.iter (resolve_actual_derivers field dep) ~f:(fun drv ->\n let dep_name = drv.name in\n if not (Hashtbl.mem seen dep_name) then\n Location.raise_errorf ~loc:name.loc\n \"Deriver %s is needed for %s, you need to add it \\\n before in the list\"\n dep_name name.txt));\n Hashtbl.set seen ~key:actual_deriver_name ~data:());\n (name, List.map named_generators ~f:snd, args))\n\n let add ?str_type_decl ?str_type_ext ?str_exception ?str_module_type_decl\n ?sig_type_decl ?sig_type_ext ?sig_exception ?sig_module_type_decl\n ?extension name =\n let actual_deriver : Actual_deriver.t =\n {\n name;\n str_type_decl;\n str_type_ext;\n str_exception;\n str_module_type_decl;\n sig_type_decl;\n sig_type_ext;\n sig_exception;\n sig_module_type_decl;\n extension;\n }\n in\n Ppx_derivers.register name (T (Actual_deriver actual_deriver));\n (match extension with\n | None -> ()\n | Some f ->\n let extension =\n Extension.declare name Expression Ast_pattern.(ptyp __) f\n in\n Driver.register_transformation\n (\"Ppxlib.Deriving.\" ^ name)\n ~rules:[ Context_free.Rule.extension extension ]);\n name\n\n let add_alias name ?str_type_decl ?str_type_ext ?str_exception\n ?str_module_type_decl ?sig_type_decl ?sig_type_ext ?sig_exception\n ?sig_module_type_decl set =\n let alias : Alias.t =\n let get = function None -> set | Some set -> set in\n {\n str_type_decl = get str_type_decl;\n str_type_ext = get str_type_ext;\n str_exception = get str_exception;\n str_module_type_decl = get str_module_type_decl;\n sig_type_decl = get sig_type_decl;\n sig_type_ext = get sig_type_ext;\n sig_exception = get sig_exception;\n sig_module_type_decl = get sig_module_type_decl;\n }\n in\n Ppx_derivers.register name (T (Alias alias));\n name\nend\n\nlet add = Deriver.add\nlet add_alias = Deriver.add_alias\n\n(* +-----------------------------------------------------------------+\n | [@@deriving ] parsing |\n +-----------------------------------------------------------------+ *)\n\nlet invalid_with ~loc =\n Location.raise_errorf ~loc \"invalid [@@deriving ] attribute syntax\"\n\nlet generator_name_of_id loc id =\n match Longident.flatten_exn id with\n | l -> { loc; txt = String.concat ~sep:\".\" l }\n | exception _ -> invalid_with ~loc\n\nexception Unknown_syntax of Location.t * string\n\nlet parse_arguments l =\n try\n Args\n (match l with\n | [ (Nolabel, e) ] -> (\n match e.pexp_desc with\n | Pexp_record (fields, None) ->\n List.map fields ~f:(fun (id, expr) ->\n let name =\n match id.txt with\n | Lident s -> s\n | _ ->\n raise_notrace\n (Unknown_syntax (id.loc, \"simple identifier expected\"))\n in\n (name, expr))\n | _ ->\n raise_notrace\n (Unknown_syntax\n ( e.pexp_loc,\n \"non-optional labelled argument or record expected\" )))\n | l ->\n List.map l ~f:(fun (label, expr) ->\n match label with\n | Labelled s -> (s, expr)\n | _ ->\n raise_notrace\n (Unknown_syntax\n (expr.pexp_loc, \"non-optional labelled argument expected\"))))\n with Unknown_syntax (loc, msg) -> Unknown_syntax (loc, msg)\n\nlet mk_deriving_attr context ~prefix ~suffix =\n Attribute.declare\n (prefix ^ \"deriving\" ^ suffix)\n context\n Ast_pattern.(\n let generator_name () =\n map' (pexp_ident __) ~f:(fun loc f id ->\n f (generator_name_of_id loc id))\n in\n let generator () =\n map (generator_name ()) ~f:(fun f x -> f (x, Args []))\n ||| pack2\n (pexp_apply (generator_name ())\n (map1 (many __) ~f:parse_arguments))\n in\n let generators =\n pexp_tuple (many (generator ()))\n ||| map (generator ()) ~f:(fun f x -> f [ x ])\n in\n pstr (pstr_eval generators nil ^:: nil))\n (fun x -> x)\n\n(* +-----------------------------------------------------------------+\n | Unused warning stuff + locations check silencing |\n +-----------------------------------------------------------------+ *)\n\nlet disable_warnings_attribute warnings =\n let loc = Location.none in\n let string =\n List.sort warnings ~cmp:Int.compare\n |> List.map ~f:(fun warning -> \"-\" ^ Int.to_string warning)\n |> String.concat ~sep:\"\"\n in\n {\n attr_name = { txt = \"ocaml.warning\"; loc };\n attr_payload = PStr [ pstr_eval ~loc (estring ~loc string) [] ];\n attr_loc = loc;\n }\n\nlet inline_doc_attr =\n let loc = Location.none in\n {\n attr_name = { txt = \"ocaml.doc\"; loc };\n attr_payload = PStr [ pstr_eval ~loc (estring ~loc \"@inline\") [] ];\n attr_loc = loc;\n }\n\nlet wrap_str ~loc ~hide st =\n let include_infos = include_infos ~loc (pmod_structure ~loc st) in\n let pincl_attributes =\n if hide then [ inline_doc_attr; Merlin_helpers.hide_attribute ]\n else [ inline_doc_attr ]\n in\n [ pstr_include ~loc { include_infos with pincl_attributes } ]\n\nlet wrap_str ~loc ~hide st =\n let loc = { loc with loc_ghost = true } in\n let warnings, st =\n if keep_w32_impl () then ([], st)\n else if not !do_insert_unused_warning_attribute then\n ([], Ignore_unused_warning.add_dummy_user_for_values#structure st)\n else ([ 32 ], st)\n in\n let warnings, st =\n if\n keep_w60_impl ()\n || not (Ignore_unused_warning.binds_module_names#structure st false)\n then (warnings, st)\n else (60 :: warnings, st)\n in\n let wrap, st =\n if List.is_empty warnings then (hide, st)\n else (true, pstr_attribute ~loc (disable_warnings_attribute warnings) :: st)\n in\n if wrap then wrap_str ~loc ~hide st else st\n\nlet wrap_sig ~loc ~hide st =\n let include_infos = include_infos ~loc (pmty_signature ~loc st) in\n let pincl_attributes =\n if hide then [ inline_doc_attr; Merlin_helpers.hide_attribute ]\n else [ inline_doc_attr ]\n in\n [ psig_include ~loc { include_infos with pincl_attributes } ]\n\nlet wrap_sig ~loc ~hide sg =\n let loc = { loc with loc_ghost = true } in\n let warnings = if keep_w32_intf () then [] else [ 32 ] in\n let warnings =\n if\n keep_w60_intf ()\n || not (Ignore_unused_warning.binds_module_names#signature sg false)\n then warnings\n else 60 :: warnings\n in\n let wrap, sg =\n if List.is_empty warnings then (hide, sg)\n else (true, psig_attribute ~loc (disable_warnings_attribute warnings) :: sg)\n in\n if wrap then wrap_sig ~loc ~hide sg else sg\n\n(* +-----------------------------------------------------------------+\n | Remove attributes used by syntax extensions |\n +-----------------------------------------------------------------+ *)\n(*\nlet remove generators =\n let attributes =\n List.concat_map generators ~f:(fun (_, actual_generators, _) ->\n List.concat_map actual_generators ~f:(fun (Generator.T g) -> g.attributes))\n in\n object\n inherit Ast_traverse.map\n\n (* Don't recurse through attributes and extensions *)\n method! attribute x = x\n method! extension x = x\n\n method! label_declaration ld =\n Attribute.remove_seen Attribute.Context.label_declaration attributes ld\n\n method! constructor_declaration cd =\n Attribute.remove_seen Attribute.Context.constructor_declaration attributes cd\n end\n*)\n(* +-----------------------------------------------------------------+\n | Main expansion |\n +-----------------------------------------------------------------+ *)\n\nlet types_used_by_deriving (tds : type_declaration list) : structure_item list =\n if keep_w32_impl () then []\n else\n List.map tds ~f:(fun td ->\n let typ = Common.core_type_of_type_declaration td in\n let loc = td.ptype_loc in\n pstr_value ~loc Nonrecursive\n [\n value_binding ~loc ~pat:(ppat_any ~loc)\n ~expr:\n (pexp_fun ~loc Nolabel None\n (ppat_constraint ~loc (ppat_any ~loc) typ)\n (eunit ~loc));\n ])\n\nlet merge_generators field l =\n List.filter_map l ~f:(fun x -> x) |> List.concat |> Deriver.resolve_all field\n\nlet expand_str_type_decls ~ctxt rec_flag tds values =\n let generators = merge_generators Deriver.Field.str_type_decl values in\n (* TODO: instead of disabling the unused warning for types themselves, we\n should add a tag [@@unused]. *)\n let generated =\n types_used_by_deriving tds\n @ Generator.apply_all ~ctxt (rec_flag, tds) generators\n in\n wrap_str\n ~loc:(Expansion_context.Deriver.derived_item_loc ctxt)\n ~hide:(not @@ Expansion_context.Deriver.inline ctxt)\n generated\n\nlet expand_sig_type_decls ~ctxt rec_flag tds values =\n let generators = merge_generators Deriver.Field.sig_type_decl values in\n let generated = Generator.apply_all ~ctxt (rec_flag, tds) generators in\n wrap_sig\n ~loc:(Expansion_context.Deriver.derived_item_loc ctxt)\n ~hide:(not @@ Expansion_context.Deriver.inline ctxt)\n generated\n\nlet expand_str_module_type_decl ~ctxt mtd generators =\n let generators =\n Deriver.resolve_all Deriver.Field.str_module_type_decl generators\n in\n let generated = Generator.apply_all ~ctxt mtd generators in\n wrap_str\n ~loc:(Expansion_context.Deriver.derived_item_loc ctxt)\n ~hide:(not @@ Expansion_context.Deriver.inline ctxt)\n generated\n\nlet expand_sig_module_type_decl ~ctxt mtd generators =\n let generators =\n Deriver.resolve_all Deriver.Field.sig_module_type_decl generators\n in\n let generated = Generator.apply_all ~ctxt mtd generators in\n wrap_sig\n ~loc:(Expansion_context.Deriver.derived_item_loc ctxt)\n ~hide:(not @@ Expansion_context.Deriver.inline ctxt)\n generated\n\nlet expand_str_exception ~ctxt ec generators =\n let generators = Deriver.resolve_all Deriver.Field.str_exception generators in\n let generated = Generator.apply_all ~ctxt ec generators in\n wrap_str\n ~loc:(Expansion_context.Deriver.derived_item_loc ctxt)\n ~hide:(not @@ Expansion_context.Deriver.inline ctxt)\n generated\n\nlet expand_sig_exception ~ctxt ec generators =\n let generators = Deriver.resolve_all Deriver.Field.sig_exception generators in\n let generated = Generator.apply_all ~ctxt ec generators in\n wrap_sig\n ~loc:(Expansion_context.Deriver.derived_item_loc ctxt)\n ~hide:(not @@ Expansion_context.Deriver.inline ctxt)\n generated\n\nlet expand_str_type_ext ~ctxt te generators =\n let generators = Deriver.resolve_all Deriver.Field.str_type_ext generators in\n let generated = Generator.apply_all ~ctxt te generators in\n wrap_str\n ~loc:(Expansion_context.Deriver.derived_item_loc ctxt)\n ~hide:(not @@ Expansion_context.Deriver.inline ctxt)\n generated\n\nlet expand_sig_type_ext ~ctxt te generators =\n let generators = Deriver.resolve_all Deriver.Field.sig_type_ext generators in\n let generated = Generator.apply_all ~ctxt te generators in\n wrap_sig\n ~loc:(Expansion_context.Deriver.derived_item_loc ctxt)\n ~hide:(not @@ Expansion_context.Deriver.inline ctxt)\n generated\n\nlet rules ~typ ~expand_sig ~expand_str ~rule_str ~rule_sig ~rule_str_expect\n ~rule_sig_expect =\n let prefix = \"ppxlib.\" in\n let deriving_attr = mk_deriving_attr ~suffix:\"\" ~prefix typ in\n let deriving_attr_expect = mk_deriving_attr ~suffix:\"_inline\" ~prefix typ in\n [\n rule_sig deriving_attr expand_sig;\n rule_str deriving_attr expand_str;\n rule_str_expect deriving_attr_expect expand_str;\n rule_sig_expect deriving_attr_expect expand_sig;\n ]\n\nlet rules_type_decl =\n rules ~typ:Type_declaration ~expand_str:expand_str_type_decls\n ~expand_sig:expand_sig_type_decls\n ~rule_str:Context_free.Rule.attr_str_type_decl\n ~rule_sig:Context_free.Rule.attr_sig_type_decl\n ~rule_str_expect:Context_free.Rule.attr_str_type_decl_expect\n ~rule_sig_expect:Context_free.Rule.attr_sig_type_decl_expect\n\nlet rules_type_ext =\n rules ~typ:Type_extension ~expand_str:expand_str_type_ext\n ~expand_sig:expand_sig_type_ext\n ~rule_str:Context_free.Rule.attr_str_type_ext\n ~rule_sig:Context_free.Rule.attr_sig_type_ext\n ~rule_str_expect:Context_free.Rule.attr_str_type_ext_expect\n ~rule_sig_expect:Context_free.Rule.attr_sig_type_ext_expect\n\nlet rules_exception =\n rules ~typ:Type_exception ~expand_str:expand_str_exception\n ~expand_sig:expand_sig_exception\n ~rule_str:Context_free.Rule.attr_str_exception\n ~rule_sig:Context_free.Rule.attr_sig_exception\n ~rule_str_expect:Context_free.Rule.attr_str_exception_expect\n ~rule_sig_expect:Context_free.Rule.attr_sig_exception_expect\n\nlet rules_module_type_decl =\n rules ~typ:Module_type_declaration ~expand_str:expand_str_module_type_decl\n ~expand_sig:expand_sig_module_type_decl\n ~rule_str:Context_free.Rule.attr_str_module_type_decl\n ~rule_sig:Context_free.Rule.attr_sig_module_type_decl\n ~rule_str_expect:Context_free.Rule.attr_str_module_type_decl_expect\n ~rule_sig_expect:Context_free.Rule.attr_sig_module_type_decl_expect\n\nlet () =\n let rules =\n [ rules_type_decl; rules_type_ext; rules_exception; rules_module_type_decl ]\n |> List.concat\n in\n Driver.register_transformation \"deriving\" ~aliases:[ \"type_conv\" ] ~rules\n","open! Import\n\ntype 'a or_raise =\n | Ok of 'a\n | Error of { fail : 'a. loc:location -> 'a }\n\ntype t = (string, expression or_raise, String.comparator_witness) Map.t\n\nlet empty = Map.empty (module String)\n\nlet lookup t ~loc ~tyvar =\n match Map.find t tyvar with\n | Some (Ok expr) -> expr\n | Some (Error { fail }) -> fail ~loc\n | None -> invalid ~loc \"unbound type variable: '%s\" tyvar\n;;\n\nlet of_alist ~loc alist =\n match Map.of_alist (module String) alist with\n | `Ok t -> t\n | `Duplicate_key name -> invalid ~loc \"duplicate type parameter: '%s\" name\n;;\n\nlet create ~loc ~prefix param_list =\n let pat_list, alist =\n List.map param_list ~f:(fun ((core_type, _) as param) ->\n let loc = core_type.ptyp_loc in\n let name = get_type_param_name param in\n let pat, expr = gensym prefix loc in\n pat, (name.txt, Ok expr))\n |> List.unzip\n in\n let t = of_alist ~loc alist in\n pat_list, t\n;;\n\nlet variance_error ~loc ~tyvar ~actual ~expect =\n invalid\n ~loc\n \"misuse of type variable '%s: would confuse %s with %s in generated code; could be \\\n due to a missing or incorrect covariance/contravariance annotation\"\n tyvar\n actual\n expect\n;;\n\nlet create_with_variance ~loc ~covariant ~contravariant param_list =\n let pat_list, by_variance_list =\n List.map param_list ~f:(fun ((core_type, (variance, injectivity)) as param) ->\n let loc = core_type.ptyp_loc in\n let name = get_type_param_name param in\n match (variance, injectivity) with\n | ((NoVariance | Covariant), NoInjectivity) ->\n let pat, expr = gensym covariant loc in\n pat, `Covariant (name.txt, expr)\n | (Contravariant, NoInjectivity) ->\n let pat, expr = gensym contravariant loc in\n pat, `Contravariant (name.txt, expr)\n | (_, Injective) -> Location.raise_errorf ~loc \"Injective type parameters aren't supported.\")\n |> List.unzip\n in\n let covariant_t =\n List.map by_variance_list ~f:(function\n | `Covariant (tyvar, expr) -> tyvar, Ok expr\n | `Contravariant (tyvar, _) ->\n let fail ~loc =\n variance_error ~loc ~tyvar ~expect:covariant ~actual:contravariant\n in\n tyvar, Error { fail })\n |> of_alist ~loc\n in\n let contravariant_t =\n List.map by_variance_list ~f:(function\n | `Contravariant (tyvar, expr) -> tyvar, Ok expr\n | `Covariant (tyvar, _) ->\n let fail ~loc =\n variance_error ~loc ~tyvar ~expect:contravariant ~actual:covariant\n in\n tyvar, Error { fail })\n |> of_alist ~loc\n in\n pat_list, `Covariant covariant_t, `Contravariant contravariant_t\n;;\n","open Core_kernel\n\nmodule Chunked = struct\n (** The input for a random oracle, formed of full field elements and 'chunks'\n of fields that can be combined together into one or more field elements.\n\n The chunks are represented as [(field, length)], where\n [0 <= field < 2^length]. This allows us to efficiently combine values in\n a known range. For example,\n{[\n { field_elements= [||]; packeds= [|(x, 64); (y, 32); (z, 16)|] }\n]}\n results in the chunks being combined as [x * 2^(32+16) + y * 2^(64) + z].\n When the chunks do not fit within a single field element, they are\n greedily concatenated to form field elements, from left to right.\n This packing is performed by the [pack_to_fields] helper function.\n *)\n type 'field t =\n { field_elements : 'field array; packeds : ('field * int) array }\n [@@deriving sexp, compare]\n\n let append (t1 : _ t) (t2 : _ t) =\n { field_elements = Array.append t1.field_elements t2.field_elements\n ; packeds = Array.append t1.packeds t2.packeds\n }\n\n let field_elements (a : 'f array) : 'f t =\n { field_elements = a; packeds = [||] }\n\n let field x : _ t = field_elements [| x |]\n\n (** An input [[|(x_1, l_1); (x_2, l_2); ...|]] includes the values\n [[|x_1; x_2; ...|]] in the input, assuming that `0 <= x_1 < 2^l_1`,\n `0 <= x_2 < 2^l_2`, etc. so that multiple [x_i]s can be combined into a\n single field element when the sum of their [l_i]s are less than the size\n of the field modulus (in bits).\n *)\n let packeds a = { field_elements = [||]; packeds = a }\n\n (** [packed x = packeds [| x |]] *)\n let packed xn : _ t = packeds [| xn |]\n\n module type Field_intf = sig\n type t\n\n val size_in_bits : int\n\n val zero : t\n\n val ( + ) : t -> t -> t\n\n val ( * ) : t -> t -> t\n end\n\n (** Convert the input into a series of field elements, by concatenating\n any chunks of input that fit into a single field element.\n The concatenation is greedy, operating from left to right.\n *)\n let pack_to_fields (type t) (module F : Field_intf with type t = t)\n ~(pow2 : int -> t) { field_elements; packeds } =\n let shift_left acc n = F.( * ) acc (pow2 n) in\n let open F in\n let packed_bits =\n let xs, acc, acc_n =\n Array.fold packeds ~init:([], zero, 0)\n ~f:(fun (xs, acc, acc_n) (x, n) ->\n let n' = Int.(n + acc_n) in\n if Int.(n' < size_in_bits) then (xs, shift_left acc n + x, n')\n else (acc :: xs, x, n) )\n in\n (* if acc_n = 0, packeds was empty (or acc holds 0 bits) and we don't want to append 0 *)\n let xs = if acc_n > 0 then acc :: xs else xs in\n Array.of_list_rev xs\n in\n Array.append field_elements packed_bits\nend\n\nmodule Legacy = struct\n type ('field, 'bool) t =\n { field_elements : 'field array; bitstrings : 'bool list array }\n [@@deriving sexp, compare]\n\n let append t1 t2 =\n { field_elements = Array.append t1.field_elements t2.field_elements\n ; bitstrings = Array.append t1.bitstrings t2.bitstrings\n }\n\n let field_elements x = { field_elements = x; bitstrings = [||] }\n\n let field x = { field_elements = [| x |]; bitstrings = [||] }\n\n let bitstring x = { field_elements = [||]; bitstrings = [| x |] }\n\n let bitstrings x = { field_elements = [||]; bitstrings = x }\n\n let pack_bits ~max_size ~pack { field_elements = _; bitstrings } =\n let rec pack_full_fields rev_fields bits length =\n if length >= max_size then\n let field_bits, bits = List.split_n bits max_size in\n pack_full_fields (pack field_bits :: rev_fields) bits (length - max_size)\n else (rev_fields, bits, length)\n in\n let packed_field_elements, remaining_bits, remaining_length =\n Array.fold bitstrings ~init:([], [], 0)\n ~f:(fun (acc, bits, n) bitstring ->\n let n = n + List.length bitstring in\n let bits = bits @ bitstring in\n let acc, bits, n = pack_full_fields acc bits n in\n (acc, bits, n) )\n in\n if remaining_length = 0 then packed_field_elements\n else pack remaining_bits :: packed_field_elements\n\n let pack_to_fields ~size_in_bits ~pack { field_elements; bitstrings } =\n let max_size = size_in_bits - 1 in\n let packed_bits =\n pack_bits ~max_size ~pack { field_elements; bitstrings }\n in\n Array.append field_elements (Array.of_list_rev packed_bits)\n\n let to_bits ~unpack { field_elements; bitstrings } =\n let field_bits = Array.map ~f:unpack field_elements in\n List.concat @@ Array.to_list @@ Array.append field_bits bitstrings\n\n module Coding = struct\n (** See https://github.com/CodaProtocol/coda/blob/develop/rfcs/0038-rosetta-construction-api.md for details on schema *)\n\n (** Serialize a random oracle input with 32byte fields into bytes according to the RFC0038 specification *)\n let serialize ~string_of_field ~to_bool ~of_bool t =\n let len_to_string x =\n String.of_char_list\n Char.\n [ of_int_exn @@ ((x lsr 24) land 0xff)\n ; of_int_exn @@ ((x lsr 16) land 0xff)\n ; of_int_exn @@ ((x lsr 8) land 0xff)\n ; of_int_exn @@ (x land 0xff)\n ]\n in\n let len1 = len_to_string @@ Array.length t.field_elements in\n let fields =\n (* We only support 32byte fields *)\n let () =\n if Array.length t.field_elements > 0 then\n assert (String.length (string_of_field t.field_elements.(0)) = 32)\n else ()\n in\n Array.map t.field_elements ~f:string_of_field |> String.concat_array\n in\n let len2 =\n len_to_string\n @@ Array.sum (module Int) t.bitstrings ~f:(fun x -> List.length x)\n in\n let packed =\n pack_bits t ~max_size:8 ~pack:(fun bs ->\n let rec go i acc = function\n | [] ->\n acc\n | b :: bs ->\n go (i + 1) ((acc * 2) + if to_bool b then 1 else 0) bs\n in\n let pad =\n List.init (8 - List.length bs) ~f:(Fn.const (of_bool false))\n in\n let combined = bs @ pad in\n assert (List.length combined = 8) ;\n go 0 0 combined )\n |> List.map ~f:Char.of_int_exn\n |> List.rev |> String.of_char_list\n in\n len1 ^ fields ^ len2 ^ packed\n\n module Parser = struct\n (* TODO: Before using this too much; use a solid parser library instead or beef this one up with more debugging info *)\n\n (* The parser is a function over this monad-fail *)\n module M = Result\n\n module T = struct\n type ('a, 'e) t = char list -> ('a * char list, 'e) M.t\n\n let return a cs = M.return (a, cs)\n\n let bind : ('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t =\n fun t ~f cs ->\n let open M.Let_syntax in\n let%bind a, rest = t cs in\n f a rest\n\n let map = `Define_using_bind\n end\n\n include Monad.Make2 (T)\n\n let run p cs =\n p cs\n |> M.bind ~f:(fun (a, cs') ->\n match cs' with [] -> M.return a | _ -> M.fail `Expected_eof )\n\n let fail why _ = M.fail why\n\n let char c = function\n | c' :: cs when Char.equal c c' ->\n M.return (c', cs)\n | c' :: _ ->\n M.fail (`Unexpected_char c')\n | [] ->\n M.fail `Unexpected_eof\n\n let u8 = function\n | c :: cs ->\n M.return (c, cs)\n | [] ->\n M.fail `Unexpected_eof\n\n let u32 =\n let open Let_syntax in\n let open Char in\n let%map a = u8 and b = u8 and c = u8 and d = u8 in\n (to_int a lsl 24)\n lor (to_int b lsl 16)\n lor (to_int c lsl 8)\n lor to_int d\n\n let eof = function [] -> M.return ((), []) | _ -> M.fail `Expected_eof\n\n let take n cs =\n if List.length cs < n then M.fail `Unexpected_eof\n else M.return (List.split_n cs n)\n\n (** p zero or more times, never fails *)\n let many p =\n (fun cs ->\n let rec go xs acc =\n match p xs with\n | Ok (a, xs) ->\n go xs (a :: acc)\n | Error _ ->\n (acc, xs)\n in\n M.return @@ go cs [] )\n |> map ~f:List.rev\n\n let%test_unit \"many\" =\n [%test_eq: (char list, [ `Expected_eof ]) Result.t]\n (run (many u8) [ 'a'; 'b'; 'c' ])\n (Result.return [ 'a'; 'b'; 'c' ])\n\n (** p exactly n times *)\n let exactly n p =\n (fun cs ->\n let rec go xs acc = function\n | 0 ->\n M.return (acc, xs)\n | i ->\n let open M.Let_syntax in\n let%bind a, xs = p xs in\n go xs (a :: acc) (i - 1)\n in\n go cs [] n )\n |> map ~f:List.rev\n\n let%test_unit \"exactly\" =\n [%test_eq:\n (char list * char list, [ `Expected_eof | `Unexpected_eof ]) Result.t]\n ((exactly 3 u8) [ 'a'; 'b'; 'c'; 'd' ])\n (Result.return ([ 'a'; 'b'; 'c' ], [ 'd' ]))\n\n let return_res r cs = r |> Result.map ~f:(fun x -> (x, cs))\n end\n\n let bits_of_byte ~of_bool b =\n let b = Char.to_int b in\n let f x =\n of_bool\n ( match x with\n | 0 ->\n false\n | 1 ->\n true\n | _ ->\n failwith \"Unexpected boolean integer\" )\n in\n [ (b land (0x1 lsl 7)) lsr 7\n ; (b land (0x1 lsl 6)) lsr 6\n ; (b land (0x1 lsl 5)) lsr 5\n ; (b land (0x1 lsl 4)) lsr 4\n ; (b land (0x1 lsl 3)) lsr 3\n ; (b land (0x1 lsl 2)) lsr 2\n ; (b land (0x1 lsl 1)) lsr 1\n ; b land 0x1\n ]\n |> List.map ~f\n\n (** Deserialize bytes into a random oracle input with 32byte fields according to the RFC0038 specification *)\n let deserialize ~field_of_string ~of_bool s =\n let field =\n let open Parser.Let_syntax in\n let%bind u8x32 = Parser.take 32 in\n let s = String.of_char_list u8x32 in\n Parser.return_res (field_of_string s)\n in\n let parser =\n let open Parser.Let_syntax in\n let%bind len1 = Parser.u32 in\n let%bind fields = Parser.exactly len1 field in\n let%bind len2 = Parser.u32 in\n let%map bytes = Parser.(many u8) in\n let bits = List.concat_map ~f:(bits_of_byte ~of_bool) bytes in\n let bitstring = List.take bits len2 in\n { field_elements = Array.of_list fields; bitstrings = [| bitstring |] }\n in\n Parser.run parser s\n\n (** String of field as bits *)\n let string_of_field xs =\n List.chunks_of xs ~length:8\n |> List.map ~f:(fun xs ->\n let rec go i acc = function\n | [] ->\n acc\n | b :: bs ->\n go (i + 1) ((acc * 2) + if b then 1 else 0) bs\n in\n let pad = List.init (8 - List.length xs) ~f:(Fn.const false) in\n let combined = xs @ pad in\n assert (List.length combined = 8) ;\n go 0 0 combined )\n |> List.map ~f:Char.of_int_exn\n |> String.of_char_list\n\n (** Field of string as bits *)\n let field_of_string s ~size_in_bits =\n List.concat_map (String.to_list s) ~f:(bits_of_byte ~of_bool:Fn.id)\n |> Fn.flip List.take size_in_bits\n |> Result.return\n end\n\n (** Coding2 is an alternate binary coding setup where we pass two arrays of\n * field elements instead of a single structure to simplify manipulation\n * outside of the Mina construction API\n *\n * This is described as the second mechanism for coding Random_oracle_input in\n * RFC0038\n *\n*)\n module Coding2 = struct\n module Rendered = struct\n (* as bytes, you must hex this later *)\n type 'field t_ = { prefix : 'field array; suffix : 'field array }\n [@@deriving yojson]\n\n type t = string t_ [@@deriving yojson]\n\n let map ~f { prefix; suffix } =\n { prefix = Array.map ~f prefix; suffix = Array.map ~f suffix }\n end\n\n let string_of_field : bool list -> string = Coding.string_of_field\n\n let field_of_string = Coding.field_of_string\n\n let serialize' t ~pack =\n { Rendered.prefix = t.field_elements\n ; suffix = pack_bits ~max_size:254 ~pack t |> Array.of_list_rev\n }\n\n let serialize t ~string_of_field ~pack =\n let () =\n if Array.length t.field_elements > 0 then\n assert (String.length (string_of_field t.field_elements.(0)) = 32)\n else ()\n in\n serialize' t ~pack |> Rendered.map ~f:string_of_field\n end\n\n let%test_module \"random_oracle input\" =\n ( module struct\n let gen_field ~size_in_bits =\n let open Quickcheck.Generator in\n list_with_length size_in_bits bool\n\n let gen_input ?size_in_bits () =\n let open Quickcheck.Generator in\n let open Let_syntax in\n let%bind size_in_bits =\n size_in_bits |> Option.map ~f:return\n |> Option.value ~default:(Int.gen_incl 2 3000)\n in\n let%bind field_elements =\n (* Treat a field as a list of bools of length [size_in_bits]. *)\n list (gen_field ~size_in_bits)\n in\n let%map bitstrings = list (list bool) in\n ( size_in_bits\n , { field_elements = Array.of_list field_elements\n ; bitstrings = Array.of_list bitstrings\n } )\n\n let%test_unit \"coding2 equiv to hash directly\" =\n let size_in_bits = 255 in\n let field = gen_field ~size_in_bits in\n Quickcheck.test ~trials:300\n Quickcheck.Generator.(\n tuple2 (gen_input ~size_in_bits ()) (tuple2 field field))\n ~f:(fun ((_, input), (x, y)) ->\n let middle = [| x; y |] in\n let expected =\n append input (field_elements middle)\n |> pack_to_fields ~size_in_bits ~pack:Fn.id\n in\n let { Coding2.Rendered.prefix; suffix } =\n Coding2.serialize' input ~pack:Fn.id\n in\n let actual = Array.(concat [ prefix; middle; suffix ]) in\n [%test_eq: bool list array] expected actual )\n\n let%test_unit \"field/string partial isomorphism bitstrings\" =\n Quickcheck.test ~trials:300\n Quickcheck.Generator.(list_with_length 255 bool)\n ~f:(fun input ->\n let serialized = Coding.string_of_field input in\n let deserialized =\n Coding.field_of_string serialized ~size_in_bits:255\n in\n [%test_eq: (bool list, unit) Result.t] (input |> Result.return)\n deserialized )\n\n let%test_unit \"serialize/deserialize partial isomorphism 32byte fields\" =\n let size_in_bits = 255 in\n Quickcheck.test ~trials:3000 (gen_input ~size_in_bits ())\n ~f:(fun (_, input) ->\n let serialized =\n Coding.(\n serialize ~string_of_field ~to_bool:Fn.id ~of_bool:Fn.id input)\n in\n let deserialized =\n Coding.(\n deserialize\n (String.to_list serialized)\n ~field_of_string:(field_of_string ~size_in_bits)\n ~of_bool:Fn.id)\n in\n let normalized t =\n { t with\n bitstrings =\n ( t.bitstrings |> Array.to_list |> List.concat\n |> fun xs -> [| xs |] )\n }\n in\n assert (\n Array.for_all input.field_elements ~f:(fun el ->\n List.length el = size_in_bits ) ) ;\n Result.iter deserialized ~f:(fun x ->\n assert (\n Array.for_all x.field_elements ~f:(fun el ->\n List.length el = size_in_bits ) ) ) ;\n [%test_eq:\n ( (bool list, bool) t\n , [ `Expected_eof | `Unexpected_eof ] )\n Result.t]\n (normalized input |> Result.return)\n (deserialized |> Result.map ~f:normalized) )\n\n let%test_unit \"data is preserved by to_bits\" =\n Quickcheck.test ~trials:300 (gen_input ())\n ~f:(fun (size_in_bits, input) ->\n let bits = to_bits ~unpack:Fn.id input in\n let bools_equal = [%equal: bool list] in\n (* Fields are accumulated at the front, check them first. *)\n let bitstring_bits =\n Array.fold ~init:bits input.field_elements ~f:(fun bits field ->\n (* The next chunk of [size_in_bits] bits is for the field\n element.\n *)\n let field_bits, rest = List.split_n bits size_in_bits in\n assert (bools_equal field_bits field) ;\n rest )\n in\n (* Bits come after. *)\n let remaining_bits =\n Array.fold ~init:bitstring_bits input.bitstrings\n ~f:(fun bits bitstring ->\n (* The next bits match the bitstring. *)\n let bitstring_bits, rest =\n List.split_n bits (List.length bitstring)\n in\n assert (bools_equal bitstring_bits bitstring) ;\n rest )\n in\n (* All bits should have been consumed. *)\n assert (List.is_empty remaining_bits) )\n\n let%test_unit \"data is preserved by pack_to_fields\" =\n Quickcheck.test ~trials:300 (gen_input ())\n ~f:(fun (size_in_bits, input) ->\n let fields = pack_to_fields ~size_in_bits ~pack:Fn.id input in\n (* Fields are accumulated at the front, check them first. *)\n let fields = Array.to_list fields in\n let bitstring_fields =\n Array.fold ~init:fields input.field_elements\n ~f:(fun fields input_field ->\n (* The next field element should be the literal field element\n passed in.\n *)\n match fields with\n | [] ->\n failwith \"Too few field elements\"\n | field :: rest ->\n assert ([%equal: bool list] field input_field) ;\n rest )\n in\n (* Check that the remaining fields have the correct size. *)\n let final_field_idx = List.length bitstring_fields - 1 in\n List.iteri bitstring_fields ~f:(fun i field_bits ->\n if i < final_field_idx then\n (* This field should be densely packed, but should contain\n fewer bits than the maximum field element to ensure that it\n doesn't overflow, so we expect [size_in_bits - 1] bits for\n maximum safe density.\n *)\n assert (List.length field_bits = size_in_bits - 1)\n else (\n (* This field will be comprised of the remaining bits, up to a\n maximum of [size_in_bits - 1]. It should not be empty.\n *)\n assert (not (List.is_empty field_bits)) ;\n assert (List.length field_bits < size_in_bits) ) ) ;\n let rec go input_bitstrings packed_fields =\n match (input_bitstrings, packed_fields) with\n | [], [] ->\n (* We have consumed all bitstrings and fields in parallel, with\n no bits left over. Success.\n *)\n ()\n | [] :: input_bitstrings, packed_fields\n | input_bitstrings, [] :: packed_fields ->\n (* We have consumed the whole of an input bitstring or the whole\n of a packed field, move onto the next one.\n *)\n go input_bitstrings packed_fields\n | ( (bi :: input_bitstring) :: input_bitstrings\n , (bp :: packed_field) :: packed_fields ) ->\n (* Consume the next bit from the next input bitstring, and the\n next bit from the next packed field. They must match.\n *)\n assert (Bool.equal bi bp) ;\n go\n (input_bitstring :: input_bitstrings)\n (packed_field :: packed_fields)\n | [], _ ->\n failwith \"Packed fields contain more bits than were provided\"\n | _, [] ->\n failwith\n \"There are input bits that were not present in the packed \\\n fields\"\n in\n (* Check that the bits match between the input bitstring and the\n remaining fields.\n *)\n go (Array.to_list input.bitstrings) bitstring_fields )\n end )\nend\n","open Core_kernel\n\n[@@@warning \"-4\"] (* sexp-related fragile pattern-matching warning *)\n\n[%%versioned\nmodule Stable = struct\n module V1 = struct\n type t = Mina_wire_types.Pickles_base.Proofs_verified.V1.t = N0 | N1 | N2\n [@@deriving sexp, compare, yojson, hash, equal]\n\n let to_latest = Fn.id\n end\nend]\n\n[@@@warning \"+4\"]\n\nlet to_int : t -> int = function N0 -> 0 | N1 -> 1 | N2 -> 2\n\n(** Inside the circuit, we use two different representations for this type,\n depending on what we need it for.\n\n Sometimes, we use it for masking out a list of 2 points by taking the\n a prefix of length 0, 1, or 2. In this setting, we we will represent a value\n of this type as a sequence of 2 bits like so:\n 00: N0\n 10: N1\n 11: N2\n\n We call this a **prefix mask**.\n\n Sometimes, we use it to select something from a list of 3 values. In this\n case, we will represent a value of this type as a sequence of 3 bits like so:\n\n 100: N0\n 010: N1\n 001: N2\n\n We call this a **one-hot vector** as elsewhere.\n*)\n\ntype proofs_verified = t\n\nlet of_nat (type n) (n : n Pickles_types.Nat.t) : t =\n let open Pickles_types.Nat in\n match n with\n | Z ->\n N0\n | S Z ->\n N1\n | S (S Z) ->\n N2\n | S _ ->\n failwithf \"Proofs_verified.of_nat: got %d\" (to_int n) ()\n\nlet of_int (n : int) : t =\n match n with\n | 0 ->\n N0\n | 1 ->\n N1\n | 2 ->\n N2\n | _ ->\n failwithf \"Proofs_verified.of_int: got %d\" n ()\n\ntype 'f boolean = 'f Snarky_backendless.Cvar.t Snarky_backendless.Boolean.t\n\ntype 'a vec2 = ('a, Pickles_types.Nat.N2.n) Pickles_types.Vector.t\n\nmodule Prefix_mask = struct\n module Checked = struct\n type 'f t = 'f boolean vec2\n end\n\n let[@warning \"-40-42\"] there : proofs_verified -> bool vec2 = function\n | N0 ->\n [ false; false ]\n | N1 ->\n [ false; true ]\n | N2 ->\n [ true; true ]\n\n let[@warning \"-40-42\"] back : bool vec2 -> proofs_verified = function\n | [ false; false ] ->\n N0\n | [ false; true ] ->\n N1\n | [ true; true ] ->\n N2\n | [ true; false ] ->\n invalid_arg \"Prefix_mask.back: invalid mask [false; true]\"\n\n let typ (type f)\n (module Impl : Snarky_backendless.Snark_intf.Run with type field = f) :\n (f Checked.t, proofs_verified) Impl.Typ.t =\n let open Impl in\n Typ.transport\n (Pickles_types.Vector.typ Boolean.typ Pickles_types.Nat.N2.n)\n ~there ~back\nend\n\nmodule One_hot = struct\n module Checked = struct\n type 'f t = ('f, Pickles_types.Nat.N3.n) One_hot_vector.t\n\n let to_input (type f) (t : f t) =\n Random_oracle_input.Chunked.packeds\n (Array.map\n Pickles_types.(Vector.to_array (t :> (f boolean, Nat.N3.n) Vector.t))\n ~f:(fun b -> ((b :> f Snarky_backendless.Cvar.t), 1)) )\n end\n\n let there : proofs_verified -> int = function N0 -> 0 | N1 -> 1 | N2 -> 2\n\n let back : int -> proofs_verified = function\n | 0 ->\n N0\n | 1 ->\n N1\n | 2 ->\n N2\n | _ ->\n failwith \"Invalid mask\"\n\n let to_input ~zero ~one (t : t) =\n let one_hot =\n match t with\n | N0 ->\n [| one; zero; zero |]\n | N1 ->\n [| zero; one; zero |]\n | N2 ->\n [| zero; zero; one |]\n in\n Random_oracle_input.Chunked.packeds (Array.map one_hot ~f:(fun b -> (b, 1)))\n\n let typ (type f)\n (module Impl : Snarky_backendless.Snark_intf.Run with type field = f) :\n (f Checked.t, proofs_verified) Impl.Typ.t =\n let module M = One_hot_vector.Make (Impl) in\n let open Impl in\n Typ.transport (M.typ Pickles_types.Nat.N3.n) ~there ~back\nend\n","open Core_kernel\nopen Pickles_types\n\nlet bits ~len n = List.init len ~f:(fun i -> (n lsr i) land 1 = 1)\n\nlet max_log2_degree = 32\n\nmodule Width : sig\n [%%versioned:\n module Stable : sig\n module V1 : sig\n type t [@@deriving sexp, equal, compare, hash, yojson]\n end\n end]\n\n val of_int_exn : int -> t\n\n val to_int : t -> int\n\n val to_bits : t -> bool list\n\n val zero : t\n\n module Max = Nat.N2\n\n module Max_vector : Vector.With_version(Max).S\n\n module Max_at_most : sig\n [%%versioned:\n module Stable : sig\n module V1 : sig\n type 'a t = ('a, Max.n) At_most.t\n [@@deriving compare, sexp, yojson, hash, equal]\n end\n end]\n end\n\n module Length : Nat.Add.Intf_transparent\nend = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = char [@@deriving sexp, equal, compare, hash, yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n let zero = Char.of_int_exn 0\n\n module Max = Nat.N2\n\n (* Think about versioning here! These vector types *will* change\n serialization if the numbers above change, and so will require a new\n version number. Thus, it's important that these are modules with new\n versioned types, and not just module aliases to the corresponding vector\n implementation.\n *)\n module Max_vector = struct\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n type 'a t = 'a Vector.Vector_2.Stable.V1.t\n [@@deriving compare, yojson, sexp, hash, equal]\n end\n end]\n\n type 'a t = 'a Vector.Vector_2.t\n [@@deriving compare, yojson, sexp, hash, equal]\n\n let map = Vector.map\n\n let of_list_exn = Vector.Vector_2.of_list_exn\n\n let to_list = Vector.to_list\n end\n\n module Max_at_most = struct\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n type 'a t = 'a At_most.At_most_2.Stable.V1.t\n [@@deriving compare, yojson, sexp, hash, equal]\n end\n end]\n\n type 'a t = 'a At_most.At_most_2.t\n [@@deriving compare, yojson, sexp, hash, equal]\n end\n\n module Length = Nat.N4\n\n let to_int = Char.to_int\n\n let to_bits = Fn.compose (bits ~len:(Nat.to_int Length.n)) to_int\n\n let of_int_exn : int -> t =\n let m = Nat.to_int Max.n in\n fun n ->\n assert (n <= m) ;\n Char.of_int_exn n\nend\n\nmodule Max_branches = struct\n include Nat.N8\n module Log2 = Nat.N3\n\n let%test \"check max_branches\" = Nat.to_int n = 1 lsl Nat.to_int Log2.n\nend\n\n(* TODO: remove since it looks very much like the Domains module in the same directory *)\nmodule Domains = struct\n [@@@warning \"-40-42\"]\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n type 'a t = { h : 'a }\n [@@deriving sexp, equal, compare, hash, yojson, hlist, fields]\n end\n end]\nend\n\nmodule Repr = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type 'g t =\n { max_proofs_verified : Proofs_verified.Stable.V1.t\n ; actual_wrap_domain_size : Proofs_verified.Stable.V1.t\n ; wrap_index : 'g Plonk_verification_key_evals.Stable.V2.t\n }\n [@@deriving sexp, equal, compare, yojson]\n end\n end]\nend\n\nmodule Poly = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type ('g, 'proofs_verified, 'vk) t =\n ( 'g\n , 'proofs_verified\n , 'vk )\n Mina_wire_types.Pickles_base.Side_loaded_verification_key.Poly.V2.t =\n { max_proofs_verified : 'proofs_verified\n ; actual_wrap_domain_size : 'proofs_verified\n ; wrap_index : 'g Plonk_verification_key_evals.Stable.V2.t\n ; wrap_vk : 'vk option\n }\n [@@deriving hash]\n end\n end]\nend\n\nlet index_to_field_elements (k : 'a Plonk_verification_key_evals.t) ~g =\n let Plonk_verification_key_evals.\n { sigma_comm\n ; coefficients_comm\n ; generic_comm\n ; psm_comm\n ; complete_add_comm\n ; mul_comm\n ; emul_comm\n ; endomul_scalar_comm\n } =\n k\n in\n List.map\n ( Vector.to_list sigma_comm\n @ Vector.to_list coefficients_comm\n @ [ generic_comm\n ; psm_comm\n ; complete_add_comm\n ; mul_comm\n ; emul_comm\n ; endomul_scalar_comm\n ] )\n ~f:g\n |> Array.concat\n\nlet wrap_index_to_input (type gs f) (g : gs -> f array) t =\n Random_oracle_input.Chunked.field_elements (index_to_field_elements t ~g)\n\nlet to_input (type a) ~(field_of_int : int -> a) :\n (a * a, _, _) Poly.t -> a Random_oracle_input.Chunked.t =\n let open Random_oracle_input.Chunked in\n fun Poly.\n { max_proofs_verified\n ; actual_wrap_domain_size\n ; wrap_index\n ; wrap_vk = _\n } : _ Random_oracle_input.Chunked.t ->\n List.reduce_exn ~f:append\n [ Proofs_verified.One_hot.to_input ~zero:(field_of_int 0)\n ~one:(field_of_int 1) max_proofs_verified\n ; Proofs_verified.One_hot.to_input ~zero:(field_of_int 0)\n ~one:(field_of_int 1) actual_wrap_domain_size\n ; wrap_index_to_input\n (Fn.compose Array.of_list (fun (x, y) -> [ x; y ]))\n wrap_index\n ]\n","open Core_kernel\n\n[@@@warning \"-4\"] (* sexp-related fragile pattern-matching warning *)\n\n[%%versioned\nmodule Stable = struct\n module V1 = struct\n type t = Pow_2_roots_of_unity of int\n [@@unboxed] [@@deriving sexp, equal, compare, hash, yojson]\n\n let to_latest = Fn.id\n end\nend]\n\n[@@@warning \"+4\"]\n\ninclude Hashable.Make (Stable.Latest)\n\nlet log2_size (Pow_2_roots_of_unity k) = k\n\nlet size t = 1 lsl log2_size t\n","(** See documentation of the {!Mina_wire_types} library *)\nmodule Wire_types = Mina_wire_types.Pickles_composition_types.Branch_data\n\nmodule Make_sig (A : Wire_types.Types.S) = struct\n module type S =\n Branch_data_intf.S\n with type Domain_log2.Stable.V1.t = A.Domain_log2.V1.t\n and type Stable.V1.t = A.V1.t\nend\n\nmodule Make_str (A : Wire_types.Concrete) = struct\n (** Data specific to a branch of a proof-system that's necessary for\n finalizing the deferred-values in a wrap proof of that branch. *)\n\n module Proofs_verified = Pickles_base.Proofs_verified\n\n module Domain_log2 = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = char [@@deriving compare, sexp, yojson, hash, equal]\n\n let to_latest = Fn.id\n end\n end]\n\n let of_int_exn : int -> t = Char.of_int_exn\n\n let of_bits_msb (bs : bool list) : t =\n List.fold bs ~init:0 ~f:(fun acc b ->\n let acc = acc lsl 1 in\n if b then acc + 1 else acc )\n |> of_int_exn\n\n let of_field_exn (type f)\n (module Impl : Snarky_backendless.Snark_intf.Run with type field = f)\n (x : f) : t =\n Impl.Field.Constant.unpack x\n |> Fn.flip List.take 8 |> List.rev |> of_bits_msb\n end\n\n (* We pack this into a single field element as follows:\n First 2 bits: proofs_verified\n Next 8 bits: domain_log2 *)\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = A.V1.t =\n { proofs_verified : Proofs_verified.Stable.V1.t\n ; domain_log2 : Domain_log2.Stable.V1.t\n }\n [@@deriving hlist, compare, sexp, yojson, hash, equal]\n\n let to_latest = Fn.id\n end\n end]\n\n let length_in_bits = 10\n\n let pack (type f)\n (module Impl : Snarky_backendless.Snark_intf.Run with type field = f)\n ({ proofs_verified; domain_log2 } : t) : f =\n let open Impl.Field.Constant in\n let double x = x + x in\n let times4 x = double (double x) in\n let domain_log2 = of_int (Char.to_int domain_log2) in\n (* shift domain_log2 over by 2 bits (multiply by 4) *)\n times4 domain_log2\n + project\n (Pickles_types.Vector.to_list\n (Proofs_verified.Prefix_mask.there proofs_verified) )\n\n let unpack (type f)\n (module Impl : Snarky_backendless.Snark_intf.Run with type field = f)\n (x : f) : t =\n match Impl.Field.Constant.unpack x with\n | x0 :: x1 :: y0 :: y1 :: y2 :: y3 :: y4 :: y5 :: y6 :: y7 :: _ ->\n { proofs_verified = Proofs_verified.Prefix_mask.back [ x0; x1 ]\n ; domain_log2 =\n Domain_log2.of_bits_msb [ y7; y6; y5; y4; y3; y2; y1; y0 ]\n }\n | _ ->\n assert false\n\n module Checked = struct\n type 'f t =\n { proofs_verified_mask : 'f Proofs_verified.Prefix_mask.Checked.t\n ; domain_log2 : 'f Snarky_backendless.Cvar.t\n }\n [@@deriving hlist]\n\n let pack (type f)\n (module Impl : Snarky_backendless.Snark_intf.Run with type field = f)\n ({ proofs_verified_mask; domain_log2 } : f t) : Impl.Field.t =\n let open Impl.Field in\n let four = of_int 4 in\n (four * domain_log2)\n + pack (Pickles_types.Vector.to_list proofs_verified_mask)\n end\n\n let packed_typ (type f)\n (module Impl : Snarky_backendless.Snark_intf.Run with type field = f) =\n Impl.Typ.transport Impl.Typ.field\n ~there:(pack (module Impl))\n ~back:(unpack (module Impl))\n\n let typ (type f)\n (module Impl : Snarky_backendless.Snark_intf.Run with type field = f)\n ~(* We actually only need it to be less than 252 bits in order to pack\n the whole branch_data struct safely, but it's cheapest to check that it's\n under 16 bits *)\n (assert_16_bits : Impl.Field.t -> unit) : (f Checked.t, t) Impl.Typ.t =\n let open Impl in\n let proofs_verified_mask :\n (f Proofs_verified.Prefix_mask.Checked.t, Proofs_verified.t) Typ.t =\n Proofs_verified.Prefix_mask.typ (module Impl)\n in\n let domain_log2 : (Field.t, Domain_log2.t) Typ.t =\n let (Typ t) =\n Typ.transport Field.typ\n ~there:(fun (x : char) -> Field.Constant.of_int (Char.to_int x))\n ~back:(Domain_log2.of_field_exn (module Impl))\n in\n let check (x : Field.t) = make_checked (fun () -> assert_16_bits x) in\n Typ { t with check }\n in\n Typ.of_hlistable\n [ proofs_verified_mask; domain_log2 ]\n ~value_of_hlist:of_hlist ~value_to_hlist:to_hlist\n ~var_to_hlist:Checked.to_hlist ~var_of_hlist:Checked.of_hlist\n\n let domain { domain_log2; _ } =\n Pickles_base.Domain.Pow_2_roots_of_unity (Char.to_int domain_log2)\nend\n\ninclude Wire_types.Make (Make_sig) (Make_str)\n","[%%versioned\nmodule Stable = struct\n module V1 = struct\n type 'challenge t =\n 'challenge Mina_wire_types.Pickles_bulletproof_challenge.V1.t =\n { prechallenge : 'challenge }\n [@@deriving sexp, compare, yojson, hash, equal]\n end\nend]\n\nlet pack { prechallenge } = prechallenge\n\nlet unpack prechallenge = { prechallenge }\n\nlet map { prechallenge } ~f = { prechallenge = f prechallenge }\n\nlet typ chal =\n let there = pack in\n let back = unpack in\n let open Snarky_backendless in\n Typ.transport ~there ~back (Kimchi_backend_common.Scalar_challenge.typ chal)\n |> Typ.transport_var ~there ~back\n","open Pickles_types\nmodule Scalar_challenge = Kimchi_backend_common.Scalar_challenge\nmodule Bulletproof_challenge = Bulletproof_challenge\nmodule Branch_data = Branch_data\nmodule Digest = Digest\nmodule Spec = Spec\nmodule Opt = Plonk_types.Opt\nopen Core_kernel\n\ntype 'f impl = 'f Spec.impl\n\nlet index_to_field_elements =\n Pickles_base.Side_loaded_verification_key.index_to_field_elements\n\nmodule Zero_values = struct\n type ('chal, 'fp) single = { challenge : 'chal; scalar : 'fp }\n\n type ('chal, 'chal_var, 'fp, 'fp_var) t =\n { value : ('chal, 'fp) single; var : ('chal_var, 'fp_var) single }\nend\n\nmodule Wrap = struct\n module Proof_state = struct\n (** This module contains structures which contain the scalar-field elements that\n are required to finalize the verification of a proof that is partially verified inside\n a circuit.\n\n Each verifier circuit starts by verifying the parts of a proof involving group operations.\n At the end, there is a sequence of scalar-field computations it must perform. Instead of\n performing them directly, it exposes the values needed for those computations as a part of\n its own public-input, so that the next circuit can do them (since it will use the other curve on the cycle,\n and hence can efficiently perform computations in that scalar field). *)\n module Deferred_values = struct\n module Plonk = struct\n module Minimal = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n (** Challenges from the PLONK IOP. These, plus the evaluations that are already in the proof, are\n all that's needed to derive all the values in the [In_circuit] version below.\n\n See src/lib/pickles/plonk_checks/plonk_checks.ml for the computation of the [In_circuit] value\n from the [Minimal] value.\n *)\n type ('challenge, 'scalar_challenge, 'bool) t =\n ( 'challenge\n , 'scalar_challenge\n , 'bool )\n Mina_wire_types.Pickles_composition_types.Wrap.Proof_state\n .Deferred_values\n .Plonk\n .Minimal\n .V1\n .t =\n { alpha : 'scalar_challenge\n ; beta : 'challenge\n ; gamma : 'challenge\n ; zeta : 'scalar_challenge\n ; joint_combiner : 'scalar_challenge option\n ; feature_flags : 'bool Plonk_types.Features.Stable.V1.t\n }\n [@@deriving sexp, compare, yojson, hlist, hash, equal]\n\n let to_latest = Fn.id\n end\n end]\n\n let map_challenges t ~f ~scalar =\n { t with\n alpha = scalar t.alpha\n ; beta = f t.beta\n ; gamma = f t.gamma\n ; zeta = scalar t.zeta\n ; joint_combiner = Option.map ~f:scalar t.joint_combiner\n }\n end\n\n open Pickles_types\n\n module In_circuit = struct\n module Lookup = struct\n type 'scalar_challenge t = { joint_combiner : 'scalar_challenge }\n [@@deriving sexp, compare, yojson, hlist, hash, equal, fields]\n\n let[@warning \"-45\"] to_struct l = Hlist.HlistId.[ l.joint_combiner ]\n\n let[@warning \"-45\"] of_struct Hlist.HlistId.[ joint_combiner ] =\n { joint_combiner }\n\n let map ~f { joint_combiner } =\n { joint_combiner = f joint_combiner }\n\n let typ scalar_challenge =\n Snarky_backendless.Typ.of_hlistable ~var_to_hlist:to_hlist\n ~var_of_hlist:of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist [ scalar_challenge ]\n end\n\n (** All scalar values deferred by a verifier circuit.\n We expose them so the next guy (who can do scalar arithmetic) can check that they\n were computed correctly from the evaluations in the proof and the challenges.\n *)\n type ( 'challenge\n , 'scalar_challenge\n , 'fp\n , 'fp_opt\n , 'lookup_opt\n , 'bool )\n t =\n { alpha : 'scalar_challenge\n ; beta : 'challenge\n ; gamma : 'challenge\n ; zeta : 'scalar_challenge\n (* TODO: zeta_to_srs_length is kind of unnecessary.\n Try to get rid of it when you can.\n *)\n ; zeta_to_srs_length : 'fp\n ; zeta_to_domain_size : 'fp\n ; perm : 'fp\n (** scalar used on one of the permutation polynomial commitments. *)\n ; feature_flags : 'bool Plonk_types.Features.t\n ; lookup : 'lookup_opt\n }\n [@@deriving sexp, compare, yojson, hlist, hash, equal, fields]\n\n let map_challenges t ~f ~scalar =\n { t with\n alpha = scalar t.alpha\n ; beta = f t.beta\n ; gamma = f t.gamma\n ; zeta = scalar t.zeta\n ; lookup = Opt.map ~f:(Lookup.map ~f:scalar) t.lookup\n }\n\n let map_fields t ~f =\n { t with\n zeta_to_srs_length = f t.zeta_to_srs_length\n ; zeta_to_domain_size = f t.zeta_to_domain_size\n ; perm = f t.perm\n }\n\n let typ (type f fp)\n (module Impl : Snarky_backendless.Snark_intf.Run\n with type field = f ) ~dummy_scalar ~dummy_scalar_challenge\n ~challenge ~scalar_challenge ~bool ~feature_flags\n (fp : (fp, _, f) Snarky_backendless.Typ.t) =\n let uses_lookup =\n let { Plonk_types.Features.range_check0\n ; range_check1\n ; foreign_field_add = _ (* Doesn't use lookup *)\n ; foreign_field_mul\n ; xor\n ; rot\n ; lookup\n ; runtime_tables = _ (* Fixme *)\n } =\n feature_flags\n in\n Array.reduce_exn ~f:Opt.Flag.( ||| )\n [| range_check0\n ; range_check1\n ; foreign_field_mul\n ; xor\n ; rot\n ; lookup\n |]\n in\n Snarky_backendless.Typ.of_hlistable\n [ Scalar_challenge.typ scalar_challenge\n ; challenge\n ; challenge\n ; Scalar_challenge.typ scalar_challenge\n ; fp\n ; fp\n ; fp\n ; Plonk_types.Features.typ ~feature_flags bool\n ; Plonk_types.Opt.typ Impl.Boolean.typ uses_lookup\n ~dummy:{ joint_combiner = dummy_scalar_challenge }\n (Lookup.typ (Scalar_challenge.typ scalar_challenge))\n ]\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist\n ~value_to_hlist:to_hlist ~value_of_hlist:of_hlist\n end\n\n let to_minimal (type challenge scalar_challenge fp fp_opt lookup_opt)\n (t :\n ( challenge\n , scalar_challenge\n , fp\n , fp_opt\n , lookup_opt\n , 'bool )\n In_circuit.t )\n ~(to_option :\n lookup_opt -> scalar_challenge In_circuit.Lookup.t option ) :\n (challenge, scalar_challenge, 'bool) Minimal.t =\n { alpha = t.alpha\n ; beta = t.beta\n ; zeta = t.zeta\n ; gamma = t.gamma\n ; joint_combiner =\n Option.map (to_option t.lookup) ~f:(fun l ->\n l.In_circuit.Lookup.joint_combiner )\n ; feature_flags = t.feature_flags\n }\n end\n\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n (** All the deferred values needed, comprising values from the PLONK IOP verification,\n values from the inner-product argument, and [which_branch] which is needed to know\n the proper domain to use. *)\n type ( 'plonk\n , 'scalar_challenge\n , 'fp\n , 'bulletproof_challenges\n , 'branch_data )\n t =\n ( 'plonk\n , 'scalar_challenge\n , 'fp\n , 'bulletproof_challenges\n , 'branch_data )\n Mina_wire_types.Pickles_composition_types.Wrap.Proof_state\n .Deferred_values\n .V1\n .t =\n { plonk : 'plonk\n ; combined_inner_product : 'fp\n (** combined_inner_product = sum_{i < num_evaluation_points} sum_{j < num_polys} r^i xi^j f_j(pt_i) *)\n ; b : 'fp\n (** b = challenge_poly plonk.zeta + r * challenge_poly (domain_generrator * plonk.zeta)\n where challenge_poly(x) = \\prod_i (1 + bulletproof_challenges.(i) * x^{2^{k - 1 - i}})\n *)\n ; xi : 'scalar_challenge\n (** The challenge used for combining polynomials *)\n ; bulletproof_challenges : 'bulletproof_challenges\n (** The challenges from the inner-product argument that was partially verified. *)\n ; branch_data : 'branch_data\n (** Data specific to which step branch of the proof-system was verified *)\n }\n [@@deriving sexp, compare, yojson, hlist, hash, equal]\n\n let to_latest = Fn.id\n end\n end]\n\n type ( 'plonk\n , 'scalar_challenge\n , 'fp\n , 'bulletproof_challenges\n , 'branch_data )\n t =\n ( 'plonk\n , 'scalar_challenge\n , 'fp\n , 'bulletproof_challenges\n , 'branch_data )\n Stable.Latest.t =\n { plonk : 'plonk\n ; combined_inner_product : 'fp\n ; b : 'fp\n ; xi : 'scalar_challenge\n ; bulletproof_challenges : 'bulletproof_challenges\n ; branch_data : 'branch_data\n }\n [@@deriving sexp, compare, yojson, hlist, hash, equal]\n\n module Minimal = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type ( 'challenge\n , 'scalar_challenge\n , 'fp\n , 'bool\n , 'bulletproof_challenges\n , 'branch_data )\n t =\n ( 'challenge\n , 'scalar_challenge\n , 'fp\n , 'bool\n , 'bulletproof_challenges\n , 'branch_data )\n Mina_wire_types.Pickles_composition_types.Wrap.Proof_state\n .Deferred_values\n .Minimal\n .V1\n .t =\n { plonk :\n ( 'challenge\n , 'scalar_challenge\n , 'bool )\n Plonk.Minimal.Stable.V1.t\n ; bulletproof_challenges : 'bulletproof_challenges\n ; branch_data : 'branch_data\n }\n [@@deriving sexp, compare, yojson, hash, equal]\n end\n end]\n\n let map_challenges { plonk; bulletproof_challenges; branch_data } ~f\n ~scalar =\n { plonk = Plonk.Minimal.map_challenges ~f ~scalar plonk\n ; bulletproof_challenges\n ; branch_data\n }\n end\n\n let map_challenges\n { plonk\n ; combined_inner_product\n ; b : 'fp\n ; xi\n ; bulletproof_challenges\n ; branch_data\n } ~f:_ ~scalar =\n { xi = scalar xi\n ; combined_inner_product\n ; b\n ; plonk\n ; bulletproof_challenges\n ; branch_data\n }\n\n module In_circuit = struct\n type ( 'challenge\n , 'scalar_challenge\n , 'fp\n , 'fp_opt\n , 'lookup_opt\n , 'bulletproof_challenges\n , 'branch_data\n , 'bool )\n t =\n ( ( 'challenge\n , 'scalar_challenge\n , 'fp\n , 'fp_opt\n , 'lookup_opt\n , 'bool )\n Plonk.In_circuit.t\n , 'scalar_challenge\n , 'fp\n , 'bulletproof_challenges\n , 'branch_data )\n Stable.Latest.t\n [@@deriving sexp, compare, yojson, hash, equal]\n\n let to_hlist, of_hlist = (to_hlist, of_hlist)\n\n let typ (type f fp)\n ((module Impl) as impl :\n (module Snarky_backendless.Snark_intf.Run with type field = f) )\n ~dummy_scalar ~dummy_scalar_challenge ~challenge ~scalar_challenge\n ~feature_flags (fp : (fp, _, f) Snarky_backendless.Typ.t) index =\n Snarky_backendless.Typ.of_hlistable\n [ Plonk.In_circuit.typ impl ~dummy_scalar ~dummy_scalar_challenge\n ~challenge ~scalar_challenge ~bool:Impl.Boolean.typ\n ~feature_flags fp\n ; fp\n ; fp\n ; Scalar_challenge.typ scalar_challenge\n ; Vector.typ\n (Bulletproof_challenge.typ scalar_challenge)\n Backend.Tick.Rounds.n\n ; index\n ]\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist\n ~value_to_hlist:to_hlist ~value_of_hlist:of_hlist\n end\n\n let to_minimal\n ({ plonk\n ; combined_inner_product\n ; b\n ; xi\n ; bulletproof_challenges\n ; branch_data\n } :\n _ In_circuit.t ) ~to_option : _ Minimal.t =\n { plonk = Plonk.to_minimal ~to_option plonk\n ; bulletproof_challenges\n ; branch_data\n }\n end\n\n (** The component of the proof accumulation state that is only computed on by the\n \"wrapping\" proof system, and that can be handled opaquely by any \"step\" circuits. *)\n module Messages_for_next_wrap_proof = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type ('g1, 'bulletproof_challenges) t =\n ( 'g1\n , 'bulletproof_challenges )\n Mina_wire_types.Pickles_composition_types.Wrap.Proof_state\n .Messages_for_next_wrap_proof\n .V1\n .t =\n { challenge_polynomial_commitment : 'g1\n ; old_bulletproof_challenges : 'bulletproof_challenges\n }\n [@@deriving sexp, compare, yojson, hlist, hash, equal]\n end\n end]\n\n let to_field_elements (type g f)\n { challenge_polynomial_commitment; old_bulletproof_challenges }\n ~g1:(g1_to_field_elements : g -> f list) =\n Array.concat\n [ Vector.to_array old_bulletproof_challenges\n |> Array.concat_map ~f:Vector.to_array\n ; Array.of_list (g1_to_field_elements challenge_polynomial_commitment)\n ]\n\n let typ g1 chal ~length =\n Snarky_backendless.Typ.of_hlistable\n [ g1; Vector.typ chal length ]\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist\n end\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n type ( 'plonk\n , 'scalar_challenge\n , 'fp\n , 'messages_for_next_wrap_proof\n , 'digest\n , 'bp_chals\n , 'index )\n t =\n ( 'plonk\n , 'scalar_challenge\n , 'fp\n , 'messages_for_next_wrap_proof\n , 'digest\n , 'bp_chals\n , 'index )\n Mina_wire_types.Pickles_composition_types.Wrap.Proof_state.V1.t =\n { deferred_values :\n ( 'plonk\n , 'scalar_challenge\n , 'fp\n , 'bp_chals\n , 'index )\n Deferred_values.Stable.V1.t\n ; sponge_digest_before_evaluations : 'digest\n ; messages_for_next_wrap_proof : 'messages_for_next_wrap_proof\n (** Parts of the statement not needed by the other circuit. Represented as a hash inside the\n circuit which is then \"unhashed\". *)\n }\n [@@deriving sexp, compare, yojson, hlist, hash, equal]\n end\n end]\n\n module Minimal = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type ( 'challenge\n , 'scalar_challenge\n , 'fp\n , 'bool\n , 'messages_for_next_wrap_proof\n , 'digest\n , 'bp_chals\n , 'index )\n t =\n ( 'challenge\n , 'scalar_challenge\n , 'fp\n , 'bool\n , 'messages_for_next_wrap_proof\n , 'digest\n , 'bp_chals\n , 'index )\n Mina_wire_types.Pickles_composition_types.Wrap.Proof_state\n .Minimal\n .V1\n .t =\n { deferred_values :\n ( 'challenge\n , 'scalar_challenge\n , 'fp\n , 'bool\n , 'bp_chals\n , 'index )\n Deferred_values.Minimal.Stable.V1.t\n ; sponge_digest_before_evaluations : 'digest\n ; messages_for_next_wrap_proof : 'messages_for_next_wrap_proof\n (** Parts of the statement not needed by the other circuit. Represented as a hash inside the\n circuit which is then \"unhashed\". *)\n }\n [@@deriving sexp, compare, yojson, hash, equal]\n end\n end]\n end\n\n module In_circuit = struct\n type ( 'challenge\n , 'scalar_challenge\n , 'fp\n , 'fp_opt\n , 'lookup_opt\n , 'bool\n , 'messages_for_next_wrap_proof\n , 'digest\n , 'bp_chals\n , 'index )\n t =\n ( ( 'challenge\n , 'scalar_challenge\n , 'fp\n , 'fp_opt\n , 'lookup_opt\n , 'bool )\n Deferred_values.Plonk.In_circuit.t\n , 'scalar_challenge\n , 'fp\n , 'messages_for_next_wrap_proof\n , 'digest\n , 'bp_chals\n , 'index )\n Stable.Latest.t\n [@@deriving sexp, compare, yojson, hash, equal]\n\n let to_hlist, of_hlist = (to_hlist, of_hlist)\n\n let typ (type f fp)\n (impl : (module Snarky_backendless.Snark_intf.Run with type field = f))\n ~dummy_scalar ~dummy_scalar_challenge ~challenge ~scalar_challenge\n ~feature_flags (fp : (fp, _, f) Snarky_backendless.Typ.t)\n messages_for_next_wrap_proof digest index =\n Snarky_backendless.Typ.of_hlistable\n [ Deferred_values.In_circuit.typ impl ~dummy_scalar\n ~dummy_scalar_challenge ~challenge ~scalar_challenge\n ~feature_flags fp index\n ; digest\n ; messages_for_next_wrap_proof\n ]\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist\n end\n\n let to_minimal\n ({ deferred_values\n ; sponge_digest_before_evaluations\n ; messages_for_next_wrap_proof\n } :\n _ In_circuit.t ) ~to_option : _ Minimal.t =\n { deferred_values = Deferred_values.to_minimal ~to_option deferred_values\n ; sponge_digest_before_evaluations\n ; messages_for_next_wrap_proof\n }\n end\n\n (** The component of the proof accumulation state that is only computed on by the\n \"stepping\" proof system, and that can be handled opaquely by any \"wrap\" circuits. *)\n module Messages_for_next_step_proof = struct\n type ('g, 's, 'challenge_polynomial_commitments, 'bulletproof_challenges) t =\n { app_state : 's\n (** The actual application-level state (e.g., for Mina, this is the protocol state which contains the\n merkle root of the ledger, state related to consensus, etc.) *)\n ; dlog_plonk_index : 'g Plonk_verification_key_evals.t\n (** The verification key corresponding to the wrap-circuit for this recursive proof system.\n It gets threaded through all the circuits so that the step circuits can verify proofs against\n it.\n *)\n ; challenge_polynomial_commitments : 'challenge_polynomial_commitments\n ; old_bulletproof_challenges : 'bulletproof_challenges\n }\n [@@deriving sexp]\n\n let to_field_elements (type g f)\n { app_state\n ; dlog_plonk_index\n ; challenge_polynomial_commitments\n ; old_bulletproof_challenges\n } ~app_state:app_state_to_field_elements ~comm ~(g : g -> f list) =\n Array.concat\n [ index_to_field_elements ~g:comm dlog_plonk_index\n ; app_state_to_field_elements app_state\n ; Vector.map2 challenge_polynomial_commitments\n old_bulletproof_challenges ~f:(fun comm chals ->\n Array.append (Array.of_list (g comm)) (Vector.to_array chals) )\n |> Vector.to_list |> Array.concat\n ]\n\n let to_field_elements_without_index (type g f)\n { app_state\n ; dlog_plonk_index = _\n ; challenge_polynomial_commitments\n ; old_bulletproof_challenges\n } ~app_state:app_state_to_field_elements ~(g : g -> f list) =\n Array.concat\n [ app_state_to_field_elements app_state\n ; Vector.map2 challenge_polynomial_commitments\n old_bulletproof_challenges ~f:(fun comm chals ->\n Array.append (Array.of_list (g comm)) (Vector.to_array chals) )\n |> Vector.to_list |> Array.concat\n ]\n\n open Snarky_backendless.H_list\n\n let[@warning \"-45\"] to_hlist\n { app_state\n ; dlog_plonk_index\n ; challenge_polynomial_commitments\n ; old_bulletproof_challenges\n } =\n [ app_state\n ; dlog_plonk_index\n ; challenge_polynomial_commitments\n ; old_bulletproof_challenges\n ]\n\n let[@warning \"-45\"] of_hlist\n ([ app_state\n ; dlog_plonk_index\n ; challenge_polynomial_commitments\n ; old_bulletproof_challenges\n ] :\n (unit, _) t ) =\n { app_state\n ; dlog_plonk_index\n ; challenge_polynomial_commitments\n ; old_bulletproof_challenges\n }\n\n let typ comm g s chal proofs_verified =\n Snarky_backendless.Typ.of_hlistable\n [ s\n ; Plonk_verification_key_evals.typ comm\n ; Vector.typ g proofs_verified\n ; chal\n ]\n (* TODO: Should this really just be a vector typ of length Rounds.n ?*)\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist\n end\n\n module Lookup_parameters = struct\n (* Values needed for computing lookup parts of the verifier circuit. *)\n type ('chal, 'chal_var, 'fp, 'fp_var) t =\n { zero : ('chal, 'chal_var, 'fp, 'fp_var) Zero_values.t\n ; use : Opt.Flag.t\n }\n\n let opt_spec (type f) ((module Impl) : f impl)\n { zero = { value; var }; use } =\n Spec.T.Opt\n { inner = Struct [ Scalar Challenge ]\n ; flag = use\n ; dummy1 =\n [ Kimchi_backend_common.Scalar_challenge.create value.challenge ]\n ; dummy2 =\n [ Kimchi_backend_common.Scalar_challenge.create var.challenge ]\n ; bool = (module Impl.Boolean)\n }\n end\n\n (** This is the full statement for \"wrap\" proofs which contains\n - the application-level statement (app_state)\n - data needed to perform the final verification of the proof, which correspond\n to parts of incompletely verified proofs.\n *)\n module Statement = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type ( 'plonk\n , 'scalar_challenge\n , 'fp\n , 'messages_for_next_wrap_proof\n , 'digest\n , 'messages_for_next_step_proof\n , 'bp_chals\n , 'index )\n t =\n ( 'plonk\n , 'scalar_challenge\n , 'fp\n , 'messages_for_next_wrap_proof\n , 'digest\n , 'messages_for_next_step_proof\n , 'bp_chals\n , 'index )\n Mina_wire_types.Pickles_composition_types.Wrap.Statement.V1.t =\n { proof_state :\n ( 'plonk\n , 'scalar_challenge\n , 'fp\n , 'messages_for_next_wrap_proof\n , 'digest\n , 'bp_chals\n , 'index )\n Proof_state.Stable.V1.t\n ; messages_for_next_step_proof : 'messages_for_next_step_proof\n }\n [@@deriving compare, yojson, sexp, hash, equal]\n end\n end]\n\n module Minimal = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type ( 'challenge\n , 'scalar_challenge\n , 'fp\n , 'bool\n , 'messages_for_next_wrap_proof\n , 'digest\n , 'messages_for_next_step_proof\n , 'bp_chals\n , 'index )\n t =\n ( 'challenge\n , 'scalar_challenge\n , 'fp\n , 'bool\n , 'messages_for_next_wrap_proof\n , 'digest\n , 'messages_for_next_step_proof\n , 'bp_chals\n , 'index )\n Mina_wire_types.Pickles_composition_types.Wrap.Statement.Minimal\n .V1\n .t =\n { proof_state :\n ( 'challenge\n , 'scalar_challenge\n , 'fp\n , 'bool\n , 'messages_for_next_wrap_proof\n , 'digest\n , 'bp_chals\n , 'index )\n Proof_state.Minimal.Stable.V1.t\n ; messages_for_next_step_proof : 'messages_for_next_step_proof\n }\n [@@deriving compare, yojson, sexp, hash, equal]\n end\n end]\n end\n\n module In_circuit = struct\n type ( 'challenge\n , 'scalar_challenge\n , 'fp\n , 'fp_opt\n , 'lookup_opt\n , 'bool\n , 'messages_for_next_wrap_proof\n , 'digest\n , 'messages_for_next_step_proof\n , 'bp_chals\n , 'index )\n t =\n ( ( 'challenge\n , 'scalar_challenge\n , 'fp\n , 'fp_opt\n , 'lookup_opt\n , 'bool )\n Proof_state.Deferred_values.Plonk.In_circuit.t\n , 'scalar_challenge\n , 'fp\n , 'messages_for_next_wrap_proof\n , 'digest\n , 'messages_for_next_step_proof\n , 'bp_chals\n , 'index )\n Stable.Latest.t\n [@@deriving compare, yojson, sexp, hash, equal]\n\n (** A layout of the raw data in a statement, which is needed for\n representing it inside the circuit. *)\n let spec impl lookup feature_flags =\n let feature_flags_spec =\n let [ f1; f2; f3; f4; f5; f6; f7; f8 ] =\n (* Ensure that layout is the same *)\n Plonk_types.Features.to_data feature_flags\n in\n let constant x =\n Spec.T.Constant (x, (fun x y -> assert (Bool.equal x y)), B Bool)\n in\n let maybe_constant flag =\n match flag with\n | Plonk_types.Opt.Flag.Yes ->\n constant true\n | Plonk_types.Opt.Flag.No ->\n constant false\n | Plonk_types.Opt.Flag.Maybe ->\n Spec.T.B Bool\n in\n Spec.T.Struct\n [ maybe_constant f1\n ; maybe_constant f2\n ; maybe_constant f3\n ; maybe_constant f4\n ; maybe_constant f5\n ; maybe_constant f6\n ; maybe_constant f7\n ; maybe_constant f8\n ]\n in\n Spec.T.Struct\n [ Vector (B Field, Nat.N5.n)\n ; Vector (B Challenge, Nat.N2.n)\n ; Vector (Scalar Challenge, Nat.N3.n)\n ; Vector (B Digest, Nat.N3.n)\n ; Vector (B Bulletproof_challenge, Backend.Tick.Rounds.n)\n ; Vector (B Branch_data, Nat.N1.n)\n ; feature_flags_spec\n ; Lookup_parameters.opt_spec impl lookup\n ]\n\n (** Convert a statement (as structured data) into the flat data-based representation. *)\n let[@warning \"-45\"] to_data\n ({ proof_state =\n { deferred_values =\n { xi\n ; combined_inner_product\n ; b\n ; branch_data\n ; bulletproof_challenges\n ; plonk =\n { alpha\n ; beta\n ; gamma\n ; zeta\n ; zeta_to_srs_length\n ; zeta_to_domain_size\n ; perm\n ; feature_flags\n ; lookup\n }\n }\n ; sponge_digest_before_evaluations\n ; messages_for_next_wrap_proof\n (* messages_for_next_wrap_proof is represented as a digest (and then unhashed) inside the circuit *)\n }\n ; messages_for_next_step_proof\n (* messages_for_next_step_proof is represented as a digest inside the circuit *)\n } :\n _ t ) ~option_map ~to_opt =\n let open Vector in\n let fp =\n [ combined_inner_product\n ; b\n ; zeta_to_srs_length\n ; zeta_to_domain_size\n ; perm\n ]\n in\n let challenge = [ beta; gamma ] in\n let scalar_challenge = [ alpha; zeta; xi ] in\n let digest =\n [ sponge_digest_before_evaluations\n ; messages_for_next_wrap_proof\n ; messages_for_next_step_proof\n ]\n in\n let index = [ branch_data ] in\n Hlist.HlistId.\n [ fp\n ; challenge\n ; scalar_challenge\n ; digest\n ; bulletproof_challenges\n ; index\n ; Plonk_types.Features.to_data feature_flags\n ; option_map lookup\n ~f:Proof_state.Deferred_values.Plonk.In_circuit.Lookup.to_struct\n ]\n\n (** Construct a statement (as structured data) from the flat data-based representation. *)\n let[@warning \"-45\"] of_data\n Hlist.HlistId.\n [ fp\n ; challenge\n ; scalar_challenge\n ; digest\n ; bulletproof_challenges\n ; index\n ; feature_flags\n ; lookup\n ] ~feature_flags:flags ~option_map ~of_opt : _ t =\n let open Vector in\n let [ combined_inner_product\n ; b\n ; zeta_to_srs_length\n ; zeta_to_domain_size\n ; perm\n ] =\n fp\n in\n let [ beta; gamma ] = challenge in\n let [ alpha; zeta; xi ] = scalar_challenge in\n let [ sponge_digest_before_evaluations\n ; messages_for_next_wrap_proof\n ; messages_for_next_step_proof\n ] =\n digest\n in\n let [ branch_data ] = index in\n let feature_flags = Plonk_types.Features.of_data feature_flags in\n { proof_state =\n { deferred_values =\n { xi\n ; combined_inner_product\n ; b\n ; branch_data\n ; bulletproof_challenges\n ; plonk =\n { alpha\n ; beta\n ; gamma\n ; zeta\n ; zeta_to_srs_length\n ; zeta_to_domain_size\n ; perm\n ; feature_flags\n ; lookup =\n option_map lookup\n ~f:\n Proof_state.Deferred_values.Plonk.In_circuit.Lookup\n .of_struct\n }\n }\n ; sponge_digest_before_evaluations\n ; messages_for_next_wrap_proof\n }\n ; messages_for_next_step_proof\n }\n end\n\n let to_minimal\n ({ proof_state; messages_for_next_step_proof } : _ In_circuit.t)\n ~to_option : _ Minimal.t =\n { proof_state = Proof_state.to_minimal ~to_option proof_state\n ; messages_for_next_step_proof\n }\n end\nend\n\nmodule Step = struct\n module Plonk_polys = Nat.N10\n\n module Bulletproof = struct\n include Plonk_types.Openings.Bulletproof\n\n module Advice = struct\n (** This is data that can be computed in linear time from the proof + statement.\n\n It doesn't need to be sent on the wire, but it does need to be provided to the verifier\n *)\n type 'fq t =\n { b : 'fq\n ; combined_inner_product : 'fq (* sum_i r^i sum_j xi^j f_j(pt_i) *)\n }\n [@@deriving hlist]\n end\n end\n\n module Proof_state = struct\n module Deferred_values = struct\n module Plonk = struct\n module Minimal = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n (** Challenges from the PLONK IOP. These, plus the evaluations that are already in the proof, are\n all that's needed to derive all the values in the [In_circuit] version below.\n\n See src/lib/pickles/plonk_checks/plonk_checks.ml for the computation of the [In_circuit] value\n from the [Minimal] value.\n *)\n type ('challenge, 'scalar_challenge) t =\n { alpha : 'scalar_challenge\n ; beta : 'challenge\n ; gamma : 'challenge\n ; zeta : 'scalar_challenge\n }\n [@@deriving sexp, compare, yojson, hlist, hash, equal]\n end\n end]\n\n let to_wrap ~feature_flags { alpha; beta; gamma; zeta } :\n _ Wrap.Proof_state.Deferred_values.Plonk.Minimal.t =\n { alpha; beta; gamma; zeta; joint_combiner = None; feature_flags }\n\n let of_wrap\n ({ alpha\n ; beta\n ; gamma\n ; zeta\n ; joint_combiner = _\n ; feature_flags = _\n } :\n _ Wrap.Proof_state.Deferred_values.Plonk.Minimal.t ) =\n { alpha; beta; gamma; zeta }\n end\n\n open Pickles_types\n\n module In_circuit = struct\n (** All scalar values deferred by a verifier circuit.\n The values in [vbmul], [complete_add], [endomul], [endomul_scalar], and [perm]\n are all scalars which will have been used to scale selector polynomials during the\n computation of the linearized polynomial commitment.\n\n Then, we expose them so the next guy (who can do scalar arithmetic) can check that they\n were computed correctly from the evaluations in the proof and the challenges.\n *)\n type ('challenge, 'scalar_challenge, 'fp) t =\n { alpha : 'scalar_challenge\n ; beta : 'challenge\n ; gamma : 'challenge\n ; zeta : 'scalar_challenge\n (* TODO: zeta_to_srs_length is kind of unnecessary.\n Try to get rid of it when you can.\n *)\n ; zeta_to_srs_length : 'fp\n ; zeta_to_domain_size : 'fp\n ; perm : 'fp\n (** scalar used on one of the permutation polynomial commitments. *)\n }\n [@@deriving sexp, compare, yojson, hlist, hash, equal, fields]\n\n let to_wrap ~opt_none ~false_\n { alpha\n ; beta\n ; gamma\n ; zeta\n ; zeta_to_srs_length\n ; zeta_to_domain_size\n ; perm\n } : _ Wrap.Proof_state.Deferred_values.Plonk.In_circuit.t =\n { alpha\n ; beta\n ; gamma\n ; zeta\n ; zeta_to_srs_length\n ; zeta_to_domain_size\n ; perm\n ; feature_flags =\n { range_check0 = false_\n ; range_check1 = false_\n ; foreign_field_add = false_\n ; foreign_field_mul = false_\n ; xor = false_\n ; rot = false_\n ; lookup = false_\n ; runtime_tables = false_\n }\n ; lookup = opt_none\n }\n\n let of_wrap ~assert_none ~assert_false\n ({ alpha\n ; beta\n ; gamma\n ; zeta\n ; zeta_to_srs_length\n ; zeta_to_domain_size\n ; perm\n ; feature_flags\n ; lookup\n } :\n _ Wrap.Proof_state.Deferred_values.Plonk.In_circuit.t ) =\n let () =\n let { Plonk_types.Features.range_check0\n ; range_check1\n ; foreign_field_add\n ; foreign_field_mul\n ; xor\n ; rot\n ; lookup\n ; runtime_tables\n } =\n feature_flags\n in\n assert_false range_check0 ;\n assert_false range_check1 ;\n assert_false foreign_field_add ;\n assert_false foreign_field_mul ;\n assert_false xor ;\n assert_false rot ;\n assert_false lookup ;\n assert_false runtime_tables\n in\n assert_none lookup ;\n { alpha\n ; beta\n ; gamma\n ; zeta\n ; zeta_to_srs_length\n ; zeta_to_domain_size\n ; perm\n }\n\n let map_challenges t ~f ~scalar =\n { t with\n alpha = scalar t.alpha\n ; beta = f t.beta\n ; gamma = f t.gamma\n ; zeta = scalar t.zeta\n }\n\n let map_fields t ~f =\n { t with\n zeta_to_srs_length = f t.zeta_to_srs_length\n ; zeta_to_domain_size = f t.zeta_to_domain_size\n ; perm = f t.perm\n }\n\n let typ (type f fp) _ ~dummy_scalar ~dummy_scalar_challenge ~challenge\n ~scalar_challenge ~bool ~feature_flags\n (fp : (fp, _, f) Snarky_backendless.Typ.t) =\n Snarky_backendless.Typ.of_hlistable\n [ Scalar_challenge.typ scalar_challenge\n ; challenge\n ; challenge\n ; Scalar_challenge.typ scalar_challenge\n ; fp\n ; fp\n ; fp\n ]\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist\n ~value_to_hlist:to_hlist ~value_of_hlist:of_hlist\n end\n\n let to_minimal (type challenge scalar_challenge fp)\n (t : (challenge, scalar_challenge, fp) In_circuit.t) :\n (challenge, scalar_challenge) Minimal.t =\n { alpha = t.alpha; beta = t.beta; zeta = t.zeta; gamma = t.gamma }\n end\n\n (** All the scalar-field values needed to finalize the verification of a proof\n by checking that the correct values were used in the \"group operations\" part of the\n verifier.\n\n Consists of some evaluations of PLONK polynomials (columns, permutation aggregation, etc.)\n and the remainder are things related to the inner product argument.\n*)\n type ('plonk, 'scalar_challenge, 'fq, 'bulletproof_challenges) t_ =\n { plonk : 'plonk\n ; combined_inner_product : 'fq\n (** combined_inner_product = sum_{i < num_evaluation_points} sum_{j < num_polys} r^i xi^j f_j(pt_i) *)\n ; xi : 'scalar_challenge\n (** The challenge used for combining polynomials *)\n ; bulletproof_challenges : 'bulletproof_challenges\n (** The challenges from the inner-product argument that was partially verified. *)\n ; b : 'fq\n (** b = challenge_poly plonk.zeta + r * challenge_poly (domain_generrator * plonk.zeta)\n where challenge_poly(x) = \\prod_i (1 + bulletproof_challenges.(i) * x^{2^{k - 1 - i}})\n *)\n }\n [@@deriving sexp, compare, yojson]\n\n module Minimal = struct\n type ('challenge, 'scalar_challenge, 'fq, 'bulletproof_challenges) t =\n ( ('challenge, 'scalar_challenge) Plonk.Minimal.t\n , 'scalar_challenge\n , 'fq\n , 'bulletproof_challenges )\n t_\n [@@deriving sexp, compare, yojson]\n end\n\n module In_circuit = struct\n type ('challenge, 'scalar_challenge, 'fq, 'bulletproof_challenges) t =\n ( ('challenge, 'scalar_challenge, 'fq) Plonk.In_circuit.t\n , 'scalar_challenge\n , 'fq\n , 'bulletproof_challenges )\n t_\n [@@deriving sexp, compare, yojson]\n end\n end\n\n module Messages_for_next_wrap_proof =\n Wrap.Proof_state.Messages_for_next_wrap_proof\n module Messages_for_next_step_proof = Wrap.Messages_for_next_step_proof\n\n module Per_proof = struct\n (** For each proof that a step circuit verifies, we do not verify the whole proof.\n Specifically,\n - we defer calculations involving the \"other field\" (i.e., the scalar-field of the group\n elements involved in the proof.\n - we do not fully verify the inner-product argument as that would be O(n) and instead\n do the accumulator trick.\n\n As a result, for each proof that a step circuit verifies, we must expose some data\n related to it as part of the step circuit's statement, in order to allow those proofs\n to be fully verified eventually.\n\n This is that data. *)\n type ( 'plonk\n , 'scalar_challenge\n , 'fq\n , 'bulletproof_challenges\n , 'digest\n , 'bool )\n t_ =\n { deferred_values :\n ( 'plonk\n , 'scalar_challenge\n , 'fq\n , 'bulletproof_challenges )\n Deferred_values.t_\n (** Scalar values related to the proof *)\n ; should_finalize : 'bool\n (** We allow circuits in pickles proof systems to decide if it's OK that a proof did\n not recursively verify. In that case, when we expose the unfinalized bits, we need\n to communicate that it's OK if those bits do not \"finalize\". That's what this boolean\n is for. *)\n ; sponge_digest_before_evaluations : 'digest\n }\n [@@deriving sexp, compare, yojson]\n\n module Minimal = struct\n type ( 'challenge\n , 'scalar_challenge\n , 'fq\n , 'bulletproof_challenges\n , 'digest\n , 'bool )\n t =\n ( ('challenge, 'scalar_challenge) Deferred_values.Plonk.Minimal.t\n , 'scalar_challenge\n , 'fq\n , 'bulletproof_challenges\n , 'digest\n , 'bool )\n t_\n [@@deriving sexp, compare, yojson]\n end\n\n module In_circuit = struct\n type ( 'challenge\n , 'scalar_challenge\n , 'fq\n , 'bulletproof_challenges\n , 'digest\n , 'bool )\n t =\n ( ( 'challenge\n , 'scalar_challenge\n , 'fq )\n Deferred_values.Plonk.In_circuit.t\n , 'scalar_challenge\n , 'fq\n , 'bulletproof_challenges\n , 'digest\n , 'bool )\n t_\n [@@deriving sexp, compare, yojson]\n\n (** A layout of the raw data in this value, which is needed for\n representing it inside the circuit. *)\n let spec bp_log2 =\n Spec.T.Struct\n [ Vector (B Field, Nat.N5.n)\n ; Vector (B Digest, Nat.N1.n)\n ; Vector (B Challenge, Nat.N2.n)\n ; Vector (Scalar Challenge, Nat.N3.n)\n ; Vector (B Bulletproof_challenge, bp_log2)\n ; Vector (B Bool, Nat.N1.n)\n ]\n\n let[@warning \"-45\"] to_data\n ({ deferred_values =\n { xi\n ; bulletproof_challenges\n ; b\n ; combined_inner_product\n ; plonk =\n { alpha\n ; beta\n ; gamma\n ; zeta\n ; zeta_to_srs_length\n ; zeta_to_domain_size\n ; perm\n }\n }\n ; should_finalize\n ; sponge_digest_before_evaluations\n } :\n _ t ) =\n let open Vector in\n let fq =\n [ combined_inner_product\n ; b\n ; zeta_to_srs_length\n ; zeta_to_domain_size\n ; perm\n ]\n in\n let challenge = [ beta; gamma ] in\n let scalar_challenge = [ alpha; zeta; xi ] in\n let digest = [ sponge_digest_before_evaluations ] in\n let bool = [ should_finalize ] in\n let open Hlist.HlistId in\n [ fq\n ; digest\n ; challenge\n ; scalar_challenge\n ; bulletproof_challenges\n ; bool\n ]\n\n let[@warning \"-45\"] of_data\n Hlist.HlistId.\n [ Vector.\n [ combined_inner_product\n ; b\n ; zeta_to_srs_length\n ; zeta_to_domain_size\n ; perm\n ]\n ; Vector.[ sponge_digest_before_evaluations ]\n ; Vector.[ beta; gamma ]\n ; Vector.[ alpha; zeta; xi ]\n ; bulletproof_challenges\n ; Vector.[ should_finalize ]\n ] : _ t =\n { deferred_values =\n { xi\n ; bulletproof_challenges\n ; b\n ; combined_inner_product\n ; plonk =\n { alpha\n ; beta\n ; gamma\n ; zeta\n ; zeta_to_srs_length\n ; zeta_to_domain_size\n ; perm\n }\n }\n ; should_finalize\n ; sponge_digest_before_evaluations\n }\n end\n\n let typ impl fq ~assert_16_bits ~zero =\n let open In_circuit in\n Spec.typ impl fq ~assert_16_bits (spec Backend.Tock.Rounds.n)\n |> Snarky_backendless.Typ.transport ~there:to_data ~back:of_data\n |> Snarky_backendless.Typ.transport_var ~there:to_data ~back:of_data\n end\n\n type ('unfinalized_proofs, 'messages_for_next_step_proof) t =\n { unfinalized_proofs : 'unfinalized_proofs\n (** A vector of the \"per-proof\" structures defined above, one for each proof\n that the step-circuit partially verifies. *)\n ; messages_for_next_step_proof : 'messages_for_next_step_proof\n (** The component of the proof accumulation state that is only computed on by the\n \"stepping\" proof system, and that can be handled opaquely by any \"wrap\" circuits. *)\n }\n [@@deriving sexp, compare, yojson, hlist]\n\n let spec unfinalized_proofs messages_for_next_step_proof =\n Spec.T.Struct [ unfinalized_proofs; messages_for_next_step_proof ]\n\n include struct\n open Hlist.HlistId\n\n let _to_data { unfinalized_proofs; messages_for_next_step_proof } =\n [ Vector.map unfinalized_proofs ~f:Per_proof.In_circuit.to_data\n ; messages_for_next_step_proof\n ]\n\n let _of_data [ unfinalized_proofs; messages_for_next_step_proof ] =\n { unfinalized_proofs =\n Vector.map unfinalized_proofs ~f:Per_proof.In_circuit.of_data\n ; messages_for_next_step_proof\n }\n end [@@warning \"-45\"]\n\n let[@warning \"-60\"] typ (type n f)\n ( (module Impl : Snarky_backendless.Snark_intf.Run with type field = f)\n as impl ) zero ~assert_16_bits\n (proofs_verified :\n (Plonk_types.Opt.Flag.t Plonk_types.Features.t, n) Vector.t ) fq :\n ( ((_, _) Vector.t, _) t\n , ((_, _) Vector.t, _) t\n , _ )\n Snarky_backendless.Typ.t =\n let per_proof feature_flags =\n Per_proof.typ impl fq ~assert_16_bits ~zero\n in\n let unfinalized_proofs =\n Vector.typ' (Vector.map proofs_verified ~f:per_proof)\n in\n let messages_for_next_step_proof =\n Spec.typ impl fq ~assert_16_bits (B Spec.Digest)\n in\n Snarky_backendless.Typ.of_hlistable\n [ unfinalized_proofs; messages_for_next_step_proof ]\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist\n end\n\n module Statement = struct\n type ( 'unfinalized_proofs\n , 'messages_for_next_step_proof\n , 'messages_for_next_wrap_proof )\n t =\n { proof_state :\n ('unfinalized_proofs, 'messages_for_next_step_proof) Proof_state.t\n ; messages_for_next_wrap_proof : 'messages_for_next_wrap_proof\n (** The component of the proof accumulation state that is only computed on by the\n \"wrapping\" proof system, and that can be handled opaquely by any \"step\" circuits. *)\n }\n [@@deriving sexp, compare, yojson]\n\n let[@warning \"-45\"] to_data\n { proof_state = { unfinalized_proofs; messages_for_next_step_proof }\n ; messages_for_next_wrap_proof\n } =\n let open Hlist.HlistId in\n [ Vector.map unfinalized_proofs\n ~f:Proof_state.Per_proof.In_circuit.to_data\n ; messages_for_next_step_proof\n ; messages_for_next_wrap_proof\n ]\n\n let[@warning \"-45\"] of_data\n Hlist.HlistId.\n [ unfinalized_proofs\n ; messages_for_next_step_proof\n ; messages_for_next_wrap_proof\n ] =\n { proof_state =\n { unfinalized_proofs =\n Vector.map unfinalized_proofs\n ~f:Proof_state.Per_proof.In_circuit.of_data\n ; messages_for_next_step_proof\n }\n ; messages_for_next_wrap_proof\n }\n\n let spec proofs_verified bp_log2 =\n let per_proof = Proof_state.Per_proof.In_circuit.spec bp_log2 in\n Spec.T.Struct\n [ Vector (per_proof, proofs_verified)\n ; B Digest\n ; Vector (B Digest, proofs_verified)\n ]\n end\nend\n\nmodule Nvector = Vector.With_length\nmodule Wrap_bp_vec = Backend.Tock.Rounds_vector\nmodule Step_bp_vec = Backend.Tick.Rounds_vector\n\nmodule Challenges_vector = struct\n type 'n t =\n (Backend.Tock.Field.t Snarky_backendless.Cvar.t Wrap_bp_vec.t, 'n) Vector.t\n\n module Constant = struct\n type 'n t = (Backend.Tock.Field.t Wrap_bp_vec.t, 'n) Vector.t\n end\nend\n","(* This file is generated by gen_scalars/gen_scalars.exe. *)\n\n(* turn off fragile pattern-matching warning from sexp ppx *)\n[@@@warning \"-4\"]\n\ntype curr_or_next = Curr | Next [@@deriving hash, eq, compare, sexp]\n\nmodule Gate_type = struct\n module T = struct\n type t = Kimchi_types.gate_type =\n | Zero\n | Generic\n | Poseidon\n | CompleteAdd\n | VarBaseMul\n | EndoMul\n | EndoMulScalar\n | Lookup\n | CairoClaim\n | CairoInstruction\n | CairoFlags\n | CairoTransition\n | RangeCheck0\n | RangeCheck1\n | ForeignFieldAdd\n | ForeignFieldMul\n | Xor16\n | Rot64\n [@@deriving hash, eq, compare, sexp]\n end\n\n include Core_kernel.Hashable.Make (T)\n include T\nend\n\nmodule Lookup_pattern = struct\n module T = struct\n type t = Kimchi_types.lookup_pattern =\n | Xor\n | Lookup\n | RangeCheck\n | ForeignFieldMul\n [@@deriving hash, eq, compare, sexp]\n end\n\n include Core_kernel.Hashable.Make (T)\n include T\nend\n\nmodule Column = struct\n open Core_kernel\n\n module T = struct\n type t =\n | Witness of int\n | Index of Gate_type.t\n | Coefficient of int\n | LookupTable\n | LookupSorted of int\n | LookupAggreg\n | LookupKindIndex of Lookup_pattern.t\n | LookupRuntimeSelector\n | LookupRuntimeTable\n [@@deriving hash, eq, compare, sexp]\n end\n\n include Hashable.Make (T)\n include T\nend\n\nopen Gate_type\nopen Column\n\nmodule Env = struct\n type 'a t =\n { add : 'a -> 'a -> 'a\n ; sub : 'a -> 'a -> 'a\n ; mul : 'a -> 'a -> 'a\n ; pow : 'a * int -> 'a\n ; square : 'a -> 'a\n ; zk_polynomial : 'a\n ; omega_to_minus_3 : 'a\n ; zeta_to_n_minus_1 : 'a\n ; var : Column.t * curr_or_next -> 'a\n ; field : string -> 'a\n ; cell : 'a -> 'a\n ; alpha_pow : int -> 'a\n ; double : 'a -> 'a\n ; endo_coefficient : 'a\n ; mds : int * int -> 'a\n ; srs_length_log2 : int\n ; vanishes_on_last_4_rows : 'a\n ; joint_combiner : 'a\n ; beta : 'a\n ; gamma : 'a\n ; unnormalized_lagrange_basis : int -> 'a\n ; if_feature : Kimchi_types.feature_flag * (unit -> 'a) * (unit -> 'a) -> 'a\n }\nend\n\nmodule type S = sig\n val constant_term : 'a Env.t -> 'a\n\n val index_terms : 'a Env.t -> 'a Lazy.t Column.Table.t\nend\n\n(* The constraints are basically the same, but the literals in them differ. *)\nmodule Tick : S = struct\n let constant_term (type a)\n ({ add = ( + )\n ; sub = ( - )\n ; mul = ( * )\n ; square\n ; mds\n ; endo_coefficient\n ; pow\n ; var\n ; field\n ; cell\n ; alpha_pow\n ; double\n ; zk_polynomial = _\n ; omega_to_minus_3 = _\n ; zeta_to_n_minus_1 = _\n ; srs_length_log2 = _\n ; vanishes_on_last_4_rows\n ; joint_combiner\n ; beta\n ; gamma\n ; unnormalized_lagrange_basis\n ; if_feature\n } :\n a Env.t ) =\n let x_0 = pow (cell (var (Witness 0, Curr)), 7) in\n let x_1 = pow (cell (var (Witness 1, Curr)), 7) in\n let x_2 = pow (cell (var (Witness 2, Curr)), 7) in\n let x_3 = pow (cell (var (Witness 6, Curr)), 7) in\n let x_4 = pow (cell (var (Witness 7, Curr)), 7) in\n let x_5 = pow (cell (var (Witness 8, Curr)), 7) in\n let x_6 = pow (cell (var (Witness 9, Curr)), 7) in\n let x_7 = pow (cell (var (Witness 10, Curr)), 7) in\n let x_8 = pow (cell (var (Witness 11, Curr)), 7) in\n let x_9 = pow (cell (var (Witness 12, Curr)), 7) in\n let x_10 = pow (cell (var (Witness 13, Curr)), 7) in\n let x_11 = pow (cell (var (Witness 14, Curr)), 7) in\n let x_12 = pow (cell (var (Witness 3, Curr)), 7) in\n let x_13 = pow (cell (var (Witness 4, Curr)), 7) in\n let x_14 = pow (cell (var (Witness 5, Curr)), 7) in\n let x_15 = cell (var (Witness 7, Next)) * cell (var (Witness 7, Next)) in\n let x_16 =\n let x_15 = cell (var (Witness 7, Next)) * cell (var (Witness 7, Next)) in\n cell (var (Witness 2, Curr))\n - (x_15 - cell (var (Witness 2, Curr)) - cell (var (Witness 0, Curr)))\n in\n let x_17 =\n let x_16 =\n let x_15 =\n cell (var (Witness 7, Next)) * cell (var (Witness 7, Next))\n in\n cell (var (Witness 2, Curr))\n - (x_15 - cell (var (Witness 2, Curr)) - cell (var (Witness 0, Curr)))\n in\n double (cell (var (Witness 3, Curr)))\n - (x_16 * cell (var (Witness 7, Next)))\n in\n let x_18 = cell (var (Witness 8, Next)) * cell (var (Witness 8, Next)) in\n let x_19 =\n let x_18 = cell (var (Witness 8, Next)) * cell (var (Witness 8, Next)) in\n cell (var (Witness 7, Curr))\n - (x_18 - cell (var (Witness 7, Curr)) - cell (var (Witness 0, Curr)))\n in\n let x_20 =\n let x_19 =\n let x_18 =\n cell (var (Witness 8, Next)) * cell (var (Witness 8, Next))\n in\n cell (var (Witness 7, Curr))\n - (x_18 - cell (var (Witness 7, Curr)) - cell (var (Witness 0, Curr)))\n in\n double (cell (var (Witness 8, Curr)))\n - (x_19 * cell (var (Witness 8, Next)))\n in\n let x_21 = cell (var (Witness 9, Next)) * cell (var (Witness 9, Next)) in\n let x_22 =\n let x_21 = cell (var (Witness 9, Next)) * cell (var (Witness 9, Next)) in\n cell (var (Witness 9, Curr))\n - (x_21 - cell (var (Witness 9, Curr)) - cell (var (Witness 0, Curr)))\n in\n let x_23 =\n let x_22 =\n let x_21 =\n cell (var (Witness 9, Next)) * cell (var (Witness 9, Next))\n in\n cell (var (Witness 9, Curr))\n - (x_21 - cell (var (Witness 9, Curr)) - cell (var (Witness 0, Curr)))\n in\n double (cell (var (Witness 10, Curr)))\n - (x_22 * cell (var (Witness 9, Next)))\n in\n let x_24 = cell (var (Witness 10, Next)) * cell (var (Witness 10, Next)) in\n let x_25 =\n let x_24 =\n cell (var (Witness 10, Next)) * cell (var (Witness 10, Next))\n in\n cell (var (Witness 11, Curr))\n - (x_24 - cell (var (Witness 11, Curr)) - cell (var (Witness 0, Curr)))\n in\n let x_26 =\n let x_25 =\n let x_24 =\n cell (var (Witness 10, Next)) * cell (var (Witness 10, Next))\n in\n cell (var (Witness 11, Curr))\n - (x_24 - cell (var (Witness 11, Curr)) - cell (var (Witness 0, Curr)))\n in\n double (cell (var (Witness 12, Curr)))\n - (x_25 * cell (var (Witness 10, Next)))\n in\n let x_27 = cell (var (Witness 11, Next)) * cell (var (Witness 11, Next)) in\n let x_28 =\n let x_27 =\n cell (var (Witness 11, Next)) * cell (var (Witness 11, Next))\n in\n cell (var (Witness 13, Curr))\n - (x_27 - cell (var (Witness 13, Curr)) - cell (var (Witness 0, Curr)))\n in\n let x_29 =\n let x_28 =\n let x_27 =\n cell (var (Witness 11, Next)) * cell (var (Witness 11, Next))\n in\n cell (var (Witness 13, Curr))\n - (x_27 - cell (var (Witness 13, Curr)) - cell (var (Witness 0, Curr)))\n in\n double (cell (var (Witness 14, Curr)))\n - (x_28 * cell (var (Witness 11, Next)))\n in\n let x_30 = cell (var (Witness 2, Curr)) - cell (var (Witness 0, Curr)) in\n let x_31 = cell (var (Witness 3, Curr)) - cell (var (Witness 1, Curr)) in\n let x_32 = cell (var (Witness 0, Curr)) * cell (var (Witness 0, Curr)) in\n let x_33 =\n ( field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n + cell (var (Witness 11, Curr))\n * ( endo_coefficient\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n ) )\n * cell (var (Witness 0, Curr))\n in\n let x_34 =\n ( field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n + cell (var (Witness 13, Curr))\n * ( endo_coefficient\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n ) )\n * cell (var (Witness 0, Curr))\n in\n let x_35 = square (cell (var (Witness 9, Curr))) in\n let x_36 = square (cell (var (Witness 10, Curr))) in\n let x_37 = cell (var (Witness 4, Curr)) - cell (var (Witness 7, Curr)) in\n let x_38 = cell (var (Witness 7, Curr)) - cell (var (Witness 4, Next)) in\n let x_39 = cell (var (Witness 5, Next)) + cell (var (Witness 8, Curr)) in\n let x_40 = cell (var (Witness 8, Curr)) + cell (var (Witness 5, Curr)) in\n let x_41 =\n ( ( field\n \"0x1555555555555555555555555555555560C232FEADC45309330F104F00000001\"\n * cell (var (Witness 6, Curr))\n + field\n \"0x2000000000000000000000000000000011234C7E04A67C8DCC9698767FFFFFFE\"\n )\n * cell (var (Witness 6, Curr))\n + field\n \"0x0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB061197F56E229849987882780000002\"\n )\n * cell (var (Witness 6, Curr))\n in\n let x_42 =\n ( ( field\n \"0x1555555555555555555555555555555560C232FEADC45309330F104F00000001\"\n * cell (var (Witness 7, Curr))\n + field\n \"0x2000000000000000000000000000000011234C7E04A67C8DCC9698767FFFFFFE\"\n )\n * cell (var (Witness 7, Curr))\n + field\n \"0x0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB061197F56E229849987882780000002\"\n )\n * cell (var (Witness 7, Curr))\n in\n let x_43 =\n ( ( field\n \"0x1555555555555555555555555555555560C232FEADC45309330F104F00000001\"\n * cell (var (Witness 8, Curr))\n + field\n \"0x2000000000000000000000000000000011234C7E04A67C8DCC9698767FFFFFFE\"\n )\n * cell (var (Witness 8, Curr))\n + field\n \"0x0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB061197F56E229849987882780000002\"\n )\n * cell (var (Witness 8, Curr))\n in\n let x_44 =\n ( ( field\n \"0x1555555555555555555555555555555560C232FEADC45309330F104F00000001\"\n * cell (var (Witness 9, Curr))\n + field\n \"0x2000000000000000000000000000000011234C7E04A67C8DCC9698767FFFFFFE\"\n )\n * cell (var (Witness 9, Curr))\n + field\n \"0x0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB061197F56E229849987882780000002\"\n )\n * cell (var (Witness 9, Curr))\n in\n let x_45 =\n ( ( field\n \"0x1555555555555555555555555555555560C232FEADC45309330F104F00000001\"\n * cell (var (Witness 10, Curr))\n + field\n \"0x2000000000000000000000000000000011234C7E04A67C8DCC9698767FFFFFFE\"\n )\n * cell (var (Witness 10, Curr))\n + field\n \"0x0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB061197F56E229849987882780000002\"\n )\n * cell (var (Witness 10, Curr))\n in\n let x_46 =\n ( ( field\n \"0x1555555555555555555555555555555560C232FEADC45309330F104F00000001\"\n * cell (var (Witness 11, Curr))\n + field\n \"0x2000000000000000000000000000000011234C7E04A67C8DCC9698767FFFFFFE\"\n )\n * cell (var (Witness 11, Curr))\n + field\n \"0x0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB061197F56E229849987882780000002\"\n )\n * cell (var (Witness 11, Curr))\n in\n let x_47 =\n ( ( field\n \"0x1555555555555555555555555555555560C232FEADC45309330F104F00000001\"\n * cell (var (Witness 12, Curr))\n + field\n \"0x2000000000000000000000000000000011234C7E04A67C8DCC9698767FFFFFFE\"\n )\n * cell (var (Witness 12, Curr))\n + field\n \"0x0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB061197F56E229849987882780000002\"\n )\n * cell (var (Witness 12, Curr))\n in\n let x_48 =\n ( ( field\n \"0x1555555555555555555555555555555560C232FEADC45309330F104F00000001\"\n * cell (var (Witness 13, Curr))\n + field\n \"0x2000000000000000000000000000000011234C7E04A67C8DCC9698767FFFFFFE\"\n )\n * cell (var (Witness 13, Curr))\n + field\n \"0x0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB061197F56E229849987882780000002\"\n )\n * cell (var (Witness 13, Curr))\n in\n cell (var (Index Poseidon, Curr))\n * ( cell (var (Witness 6, Curr))\n - ( cell (var (Coefficient 0, Curr))\n + (mds (0, 0) * x_0)\n + (mds (0, 1) * x_1)\n + (mds (0, 2) * x_2) )\n + alpha_pow 1\n * ( cell (var (Witness 7, Curr))\n - ( cell (var (Coefficient 1, Curr))\n + (mds (1, 0) * x_0)\n + (mds (1, 1) * x_1)\n + (mds (1, 2) * x_2) ) )\n + alpha_pow 2\n * ( cell (var (Witness 8, Curr))\n - ( cell (var (Coefficient 2, Curr))\n + (mds (2, 0) * x_0)\n + (mds (2, 1) * x_1)\n + (mds (2, 2) * x_2) ) )\n + alpha_pow 3\n * ( cell (var (Witness 9, Curr))\n - ( cell (var (Coefficient 3, Curr))\n + (mds (0, 0) * x_3)\n + (mds (0, 1) * x_4)\n + (mds (0, 2) * x_5) ) )\n + alpha_pow 4\n * ( cell (var (Witness 10, Curr))\n - ( cell (var (Coefficient 4, Curr))\n + (mds (1, 0) * x_3)\n + (mds (1, 1) * x_4)\n + (mds (1, 2) * x_5) ) )\n + alpha_pow 5\n * ( cell (var (Witness 11, Curr))\n - ( cell (var (Coefficient 5, Curr))\n + (mds (2, 0) * x_3)\n + (mds (2, 1) * x_4)\n + (mds (2, 2) * x_5) ) )\n + alpha_pow 6\n * ( cell (var (Witness 12, Curr))\n - ( cell (var (Coefficient 6, Curr))\n + (mds (0, 0) * x_6)\n + (mds (0, 1) * x_7)\n + (mds (0, 2) * x_8) ) )\n + alpha_pow 7\n * ( cell (var (Witness 13, Curr))\n - ( cell (var (Coefficient 7, Curr))\n + (mds (1, 0) * x_6)\n + (mds (1, 1) * x_7)\n + (mds (1, 2) * x_8) ) )\n + alpha_pow 8\n * ( cell (var (Witness 14, Curr))\n - ( cell (var (Coefficient 8, Curr))\n + (mds (2, 0) * x_6)\n + (mds (2, 1) * x_7)\n + (mds (2, 2) * x_8) ) )\n + alpha_pow 9\n * ( cell (var (Witness 3, Curr))\n - ( cell (var (Coefficient 9, Curr))\n + (mds (0, 0) * x_9)\n + (mds (0, 1) * x_10)\n + (mds (0, 2) * x_11) ) )\n + alpha_pow 10\n * ( cell (var (Witness 4, Curr))\n - ( cell (var (Coefficient 10, Curr))\n + (mds (1, 0) * x_9)\n + (mds (1, 1) * x_10)\n + (mds (1, 2) * x_11) ) )\n + alpha_pow 11\n * ( cell (var (Witness 5, Curr))\n - ( cell (var (Coefficient 11, Curr))\n + (mds (2, 0) * x_9)\n + (mds (2, 1) * x_10)\n + (mds (2, 2) * x_11) ) )\n + alpha_pow 12\n * ( cell (var (Witness 0, Next))\n - ( cell (var (Coefficient 12, Curr))\n + (mds (0, 0) * x_12)\n + (mds (0, 1) * x_13)\n + (mds (0, 2) * x_14) ) )\n + alpha_pow 13\n * ( cell (var (Witness 1, Next))\n - ( cell (var (Coefficient 13, Curr))\n + (mds (1, 0) * x_12)\n + (mds (1, 1) * x_13)\n + (mds (1, 2) * x_14) ) )\n + alpha_pow 14\n * ( cell (var (Witness 2, Next))\n - ( cell (var (Coefficient 14, Curr))\n + (mds (2, 0) * x_12)\n + (mds (2, 1) * x_13)\n + (mds (2, 2) * x_14) ) ) )\n + cell (var (Index VarBaseMul, Curr))\n * ( cell (var (Witness 5, Curr))\n - ( cell (var (Witness 6, Next))\n + double\n ( cell (var (Witness 5, Next))\n + double\n ( cell (var (Witness 4, Next))\n + double\n ( cell (var (Witness 3, Next))\n + double\n ( cell (var (Witness 2, Next))\n + double (cell (var (Witness 4, Curr))) ) ) ) ) )\n + alpha_pow 1\n * ( square (cell (var (Witness 2, Next)))\n - cell (var (Witness 2, Next)) )\n + alpha_pow 2\n * ( (cell (var (Witness 2, Curr)) - cell (var (Witness 0, Curr)))\n * cell (var (Witness 7, Next))\n - ( cell (var (Witness 3, Curr))\n - ( double (cell (var (Witness 2, Next)))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * cell (var (Witness 1, Curr)) ) )\n + alpha_pow 3\n * ( (x_17 * x_17)\n - x_16 * x_16\n * ( cell (var (Witness 7, Curr))\n - cell (var (Witness 0, Curr))\n + x_15 ) )\n + alpha_pow 4\n * ( (cell (var (Witness 8, Curr)) + cell (var (Witness 3, Curr)))\n * x_16\n - (cell (var (Witness 2, Curr)) - cell (var (Witness 7, Curr)))\n * x_17 )\n + alpha_pow 5\n * ( square (cell (var (Witness 3, Next)))\n - cell (var (Witness 3, Next)) )\n + alpha_pow 6\n * ( (cell (var (Witness 7, Curr)) - cell (var (Witness 0, Curr)))\n * cell (var (Witness 8, Next))\n - ( cell (var (Witness 8, Curr))\n - ( double (cell (var (Witness 3, Next)))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * cell (var (Witness 1, Curr)) ) )\n + alpha_pow 7\n * ( (x_20 * x_20)\n - x_19 * x_19\n * ( cell (var (Witness 9, Curr))\n - cell (var (Witness 0, Curr))\n + x_18 ) )\n + alpha_pow 8\n * ( (cell (var (Witness 10, Curr)) + cell (var (Witness 8, Curr)))\n * x_19\n - (cell (var (Witness 7, Curr)) - cell (var (Witness 9, Curr)))\n * x_20 )\n + alpha_pow 9\n * ( square (cell (var (Witness 4, Next)))\n - cell (var (Witness 4, Next)) )\n + alpha_pow 10\n * ( (cell (var (Witness 9, Curr)) - cell (var (Witness 0, Curr)))\n * cell (var (Witness 9, Next))\n - ( cell (var (Witness 10, Curr))\n - ( double (cell (var (Witness 4, Next)))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * cell (var (Witness 1, Curr)) ) )\n + alpha_pow 11\n * ( (x_23 * x_23)\n - x_22 * x_22\n * ( cell (var (Witness 11, Curr))\n - cell (var (Witness 0, Curr))\n + x_21 ) )\n + alpha_pow 12\n * ( (cell (var (Witness 12, Curr)) + cell (var (Witness 10, Curr)))\n * x_22\n - (cell (var (Witness 9, Curr)) - cell (var (Witness 11, Curr)))\n * x_23 )\n + alpha_pow 13\n * ( square (cell (var (Witness 5, Next)))\n - cell (var (Witness 5, Next)) )\n + alpha_pow 14\n * ( (cell (var (Witness 11, Curr)) - cell (var (Witness 0, Curr)))\n * cell (var (Witness 10, Next))\n - ( cell (var (Witness 12, Curr))\n - ( double (cell (var (Witness 5, Next)))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * cell (var (Witness 1, Curr)) ) )\n + alpha_pow 15\n * ( (x_26 * x_26)\n - x_25 * x_25\n * ( cell (var (Witness 13, Curr))\n - cell (var (Witness 0, Curr))\n + x_24 ) )\n + alpha_pow 16\n * ( (cell (var (Witness 14, Curr)) + cell (var (Witness 12, Curr)))\n * x_25\n - (cell (var (Witness 11, Curr)) - cell (var (Witness 13, Curr)))\n * x_26 )\n + alpha_pow 17\n * ( square (cell (var (Witness 6, Next)))\n - cell (var (Witness 6, Next)) )\n + alpha_pow 18\n * ( (cell (var (Witness 13, Curr)) - cell (var (Witness 0, Curr)))\n * cell (var (Witness 11, Next))\n - ( cell (var (Witness 14, Curr))\n - ( double (cell (var (Witness 6, Next)))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * cell (var (Witness 1, Curr)) ) )\n + alpha_pow 19\n * ( (x_29 * x_29)\n - x_28 * x_28\n * ( cell (var (Witness 0, Next))\n - cell (var (Witness 0, Curr))\n + x_27 ) )\n + alpha_pow 20\n * ( (cell (var (Witness 1, Next)) + cell (var (Witness 14, Curr)))\n * x_28\n - (cell (var (Witness 13, Curr)) - cell (var (Witness 0, Next)))\n * x_29 ) )\n + cell (var (Index CompleteAdd, Curr))\n * ( (cell (var (Witness 10, Curr)) * x_30)\n - ( field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n - cell (var (Witness 7, Curr)) )\n + (alpha_pow 1 * (cell (var (Witness 7, Curr)) * x_30))\n + alpha_pow 2\n * ( cell (var (Witness 7, Curr))\n * ( double (cell (var (Witness 8, Curr)))\n * cell (var (Witness 1, Curr))\n - double x_32 - x_32 )\n + ( field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n - cell (var (Witness 7, Curr)) )\n * ((x_30 * cell (var (Witness 8, Curr))) - x_31) )\n + alpha_pow 3\n * ( cell (var (Witness 0, Curr))\n + cell (var (Witness 2, Curr))\n + cell (var (Witness 4, Curr))\n - (cell (var (Witness 8, Curr)) * cell (var (Witness 8, Curr))) )\n + alpha_pow 4\n * ( cell (var (Witness 8, Curr))\n * (cell (var (Witness 0, Curr)) - cell (var (Witness 4, Curr)))\n - cell (var (Witness 1, Curr))\n - cell (var (Witness 5, Curr)) )\n + alpha_pow 5\n * ( x_31\n * (cell (var (Witness 7, Curr)) - cell (var (Witness 6, Curr))) )\n + alpha_pow 6\n * ( (x_31 * cell (var (Witness 9, Curr)))\n - cell (var (Witness 6, Curr)) ) )\n + cell (var (Index EndoMul, Curr))\n * ( square (cell (var (Witness 11, Curr)))\n - cell (var (Witness 11, Curr))\n + alpha_pow 1\n * ( square (cell (var (Witness 12, Curr)))\n - cell (var (Witness 12, Curr)) )\n + alpha_pow 2\n * ( square (cell (var (Witness 13, Curr)))\n - cell (var (Witness 13, Curr)) )\n + alpha_pow 3\n * ( square (cell (var (Witness 14, Curr)))\n - cell (var (Witness 14, Curr)) )\n + alpha_pow 4\n * ( (x_33 - cell (var (Witness 4, Curr)))\n * cell (var (Witness 9, Curr))\n - ( ( double (cell (var (Witness 12, Curr)))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * cell (var (Witness 1, Curr))\n - cell (var (Witness 5, Curr)) ) )\n + alpha_pow 5\n * ( (double (cell (var (Witness 4, Curr))) - x_35 + x_33)\n * ((x_37 * cell (var (Witness 9, Curr))) + x_40)\n - (double (cell (var (Witness 5, Curr))) * x_37) )\n + alpha_pow 6\n * ( square x_40\n - (square x_37 * (x_35 - x_33 + cell (var (Witness 7, Curr)))) )\n + alpha_pow 7\n * ( (x_34 - cell (var (Witness 7, Curr)))\n * cell (var (Witness 10, Curr))\n - ( ( double (cell (var (Witness 14, Curr)))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * cell (var (Witness 1, Curr))\n - cell (var (Witness 8, Curr)) ) )\n + alpha_pow 8\n * ( (double (cell (var (Witness 7, Curr))) - x_36 + x_34)\n * ((x_38 * cell (var (Witness 10, Curr))) + x_39)\n - (double (cell (var (Witness 8, Curr))) * x_38) )\n + alpha_pow 9\n * ( square x_39\n - (square x_38 * (x_36 - x_34 + cell (var (Witness 4, Next)))) )\n + alpha_pow 10\n * ( double\n ( double\n ( double\n ( double (cell (var (Witness 6, Curr)))\n + cell (var (Witness 11, Curr)) )\n + cell (var (Witness 12, Curr)) )\n + cell (var (Witness 13, Curr)) )\n + cell (var (Witness 14, Curr))\n - cell (var (Witness 6, Next)) ) )\n + cell (var (Index EndoMulScalar, Curr))\n * ( double\n (double\n ( double\n (double\n ( double\n (double\n ( double\n (double\n ( double\n (double\n ( double\n (double\n ( double\n (double\n ( double\n (double\n (cell\n (var\n ( Witness 0\n , Curr ) ) ) )\n + cell\n (var\n (Witness 6, Curr) )\n ) )\n + cell (var (Witness 7, Curr))\n ) )\n + cell (var (Witness 8, Curr)) ) )\n + cell (var (Witness 9, Curr)) ) )\n + cell (var (Witness 10, Curr)) ) )\n + cell (var (Witness 11, Curr)) ) )\n + cell (var (Witness 12, Curr)) ) )\n + cell (var (Witness 13, Curr))\n - cell (var (Witness 1, Curr))\n + alpha_pow 1\n * ( double\n ( double\n ( double\n ( double\n ( double\n ( double\n ( double\n ( double (cell (var (Witness 2, Curr)))\n + x_41 )\n + x_42 )\n + x_43 )\n + x_44 )\n + x_45 )\n + x_46 )\n + x_47 )\n + x_48\n - cell (var (Witness 4, Curr)) )\n + alpha_pow 2\n * ( double\n ( double\n ( double\n ( double\n ( double\n ( double\n ( double\n ( double (cell (var (Witness 3, Curr)))\n + ( x_41\n + ( ( field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ED00000000\"\n * cell (var (Witness 6, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n )\n * cell (var (Witness 6, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ED00000000\"\n ) ) )\n + ( x_42\n + ( ( field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ED00000000\"\n * cell (var (Witness 7, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n )\n * cell (var (Witness 7, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ED00000000\"\n ) ) )\n + ( x_43\n + ( ( field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ED00000000\"\n * cell (var (Witness 8, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n )\n * cell (var (Witness 8, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ED00000000\"\n ) ) )\n + ( x_44\n + ( ( field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ED00000000\"\n * cell (var (Witness 9, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n )\n * cell (var (Witness 9, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ED00000000\"\n ) ) )\n + ( x_45\n + ( ( field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ED00000000\"\n * cell (var (Witness 10, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n )\n * cell (var (Witness 10, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ED00000000\"\n ) ) )\n + ( x_46\n + ( ( field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ED00000000\"\n * cell (var (Witness 11, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n )\n * cell (var (Witness 11, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ED00000000\"\n ) ) )\n + ( x_47\n + ( ( field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ED00000000\"\n * cell (var (Witness 12, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n )\n * cell (var (Witness 12, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ED00000000\"\n ) ) )\n + ( x_48\n + ( ( field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ED00000000\"\n * cell (var (Witness 13, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n )\n * cell (var (Witness 13, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ED00000000\"\n ) )\n - cell (var (Witness 5, Curr)) )\n + alpha_pow 3\n * ( ( ( ( cell (var (Witness 6, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ECFFFFFFFB\"\n )\n * cell (var (Witness 6, Curr))\n + field\n \"0x000000000000000000000000000000000000000000000000000000000000000B\"\n )\n * cell (var (Witness 6, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ECFFFFFFFB\"\n )\n * cell (var (Witness 6, Curr)) )\n + alpha_pow 4\n * ( ( ( ( cell (var (Witness 7, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ECFFFFFFFB\"\n )\n * cell (var (Witness 7, Curr))\n + field\n \"0x000000000000000000000000000000000000000000000000000000000000000B\"\n )\n * cell (var (Witness 7, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ECFFFFFFFB\"\n )\n * cell (var (Witness 7, Curr)) )\n + alpha_pow 5\n * ( ( ( ( cell (var (Witness 8, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ECFFFFFFFB\"\n )\n * cell (var (Witness 8, Curr))\n + field\n \"0x000000000000000000000000000000000000000000000000000000000000000B\"\n )\n * cell (var (Witness 8, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ECFFFFFFFB\"\n )\n * cell (var (Witness 8, Curr)) )\n + alpha_pow 6\n * ( ( ( ( cell (var (Witness 9, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ECFFFFFFFB\"\n )\n * cell (var (Witness 9, Curr))\n + field\n \"0x000000000000000000000000000000000000000000000000000000000000000B\"\n )\n * cell (var (Witness 9, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ECFFFFFFFB\"\n )\n * cell (var (Witness 9, Curr)) )\n + alpha_pow 7\n * ( ( ( ( cell (var (Witness 10, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ECFFFFFFFB\"\n )\n * cell (var (Witness 10, Curr))\n + field\n \"0x000000000000000000000000000000000000000000000000000000000000000B\"\n )\n * cell (var (Witness 10, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ECFFFFFFFB\"\n )\n * cell (var (Witness 10, Curr)) )\n + alpha_pow 8\n * ( ( ( ( cell (var (Witness 11, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ECFFFFFFFB\"\n )\n * cell (var (Witness 11, Curr))\n + field\n \"0x000000000000000000000000000000000000000000000000000000000000000B\"\n )\n * cell (var (Witness 11, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ECFFFFFFFB\"\n )\n * cell (var (Witness 11, Curr)) )\n + alpha_pow 9\n * ( ( ( ( cell (var (Witness 12, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ECFFFFFFFB\"\n )\n * cell (var (Witness 12, Curr))\n + field\n \"0x000000000000000000000000000000000000000000000000000000000000000B\"\n )\n * cell (var (Witness 12, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ECFFFFFFFB\"\n )\n * cell (var (Witness 12, Curr)) )\n + alpha_pow 10\n * ( ( ( ( cell (var (Witness 13, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ECFFFFFFFB\"\n )\n * cell (var (Witness 13, Curr))\n + field\n \"0x000000000000000000000000000000000000000000000000000000000000000B\"\n )\n * cell (var (Witness 13, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ECFFFFFFFB\"\n )\n * cell (var (Witness 13, Curr)) ) )\n + if_feature\n ( RangeCheck0\n , (fun () ->\n cell (var (Index RangeCheck0, Curr))\n * ( cell (var (Witness 7, Curr))\n * ( cell (var (Witness 7, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 7, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 7, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n )\n + alpha_pow 1\n * ( cell (var (Witness 8, Curr))\n * ( cell (var (Witness 8, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 8, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 8, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 2\n * ( cell (var (Witness 9, Curr))\n * ( cell (var (Witness 9, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 9, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 9, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 3\n * ( cell (var (Witness 10, Curr))\n * ( cell (var (Witness 10, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 10, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 10, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 4\n * ( cell (var (Witness 11, Curr))\n * ( cell (var (Witness 11, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 11, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 11, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 5\n * ( cell (var (Witness 12, Curr))\n * ( cell (var (Witness 12, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 12, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 12, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 6\n * ( cell (var (Witness 13, Curr))\n * ( cell (var (Witness 13, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 13, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 13, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 7\n * ( cell (var (Witness 14, Curr))\n * ( cell (var (Witness 14, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 14, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 14, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 8\n * ( cell (var (Witness 14, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 13, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 12, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 11, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 10, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 9, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 8, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 7, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 6, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * cell (var (Witness 5, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * cell (var (Witness 4, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * cell (var (Witness 3, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * cell (var (Witness 2, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * cell (var (Witness 1, Curr))\n - cell (var (Witness 0, Curr)) )\n + alpha_pow 9\n * ( cell (var (Coefficient 0, Curr))\n * ( cell (var (Witness 1, Next))\n - ( cell (var (Witness 0, Curr))\n + field\n \"0x0000000000000000000000000000000000000000010000000000000000000000\"\n * cell (var (Witness 0, Next)) ) ) ) ) )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000000\"\n )\n + if_feature\n ( RangeCheck1\n , (fun () ->\n cell (var (Index RangeCheck1, Curr))\n * ( cell (var (Witness 2, Curr))\n * ( cell (var (Witness 2, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 2, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 2, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n )\n + alpha_pow 1\n * ( cell (var (Witness 7, Curr))\n * ( cell (var (Witness 7, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 7, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 7, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 2\n * ( cell (var (Witness 8, Curr))\n * ( cell (var (Witness 8, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 8, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 8, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 3\n * ( cell (var (Witness 9, Curr))\n * ( cell (var (Witness 9, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 9, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 9, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 4\n * ( cell (var (Witness 10, Curr))\n * ( cell (var (Witness 10, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 10, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 10, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 5\n * ( cell (var (Witness 11, Curr))\n * ( cell (var (Witness 11, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 11, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 11, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 6\n * ( cell (var (Witness 12, Curr))\n * ( cell (var (Witness 12, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 12, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 12, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 7\n * ( cell (var (Witness 13, Curr))\n * ( cell (var (Witness 13, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 13, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 13, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 8\n * ( cell (var (Witness 14, Curr))\n * ( cell (var (Witness 14, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 14, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 14, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 9\n * ( cell (var (Witness 0, Next))\n * ( cell (var (Witness 0, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 0, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 0, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 10\n * ( cell (var (Witness 1, Next))\n * ( cell (var (Witness 1, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 1, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 1, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 11\n * ( cell (var (Witness 2, Next))\n * ( cell (var (Witness 2, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 2, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 2, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 12\n * ( cell (var (Witness 7, Next))\n * ( cell (var (Witness 7, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 7, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 7, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 13\n * ( cell (var (Witness 8, Next))\n * ( cell (var (Witness 8, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 8, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 8, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 14\n * ( cell (var (Witness 9, Next))\n * ( cell (var (Witness 9, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 9, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 9, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 15\n * ( cell (var (Witness 10, Next))\n * ( cell (var (Witness 10, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 10, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 10, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 16\n * ( cell (var (Witness 11, Next))\n * ( cell (var (Witness 11, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 11, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 11, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 17\n * ( cell (var (Witness 12, Next))\n * ( cell (var (Witness 12, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 12, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 12, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 18\n * ( cell (var (Witness 13, Next))\n * ( cell (var (Witness 13, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 13, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 13, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 19\n * ( cell (var (Witness 14, Next))\n * ( cell (var (Witness 14, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 14, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 14, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 20\n * ( cell (var (Witness 14, Next))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 13, Next))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 12, Next))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 11, Next))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 10, Next))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 9, Next))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 8, Next))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 7, Next))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 2, Next))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 1, Next))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 0, Next))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 14, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 13, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 12, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 11, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 10, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 9, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 8, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 7, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 6, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * cell (var (Witness 5, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * cell (var (Witness 4, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * cell (var (Witness 3, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * cell (var (Witness 2, Curr))\n - cell (var (Witness 0, Curr)) ) ) )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000000\"\n )\n + if_feature\n ( ForeignFieldAdd\n , (fun () ->\n cell (var (Index ForeignFieldAdd, Curr))\n * ( cell (var (Witness 6, Curr))\n * ( cell (var (Witness 6, Curr))\n - cell (var (Coefficient 3, Curr)) )\n + alpha_pow 1\n * ( cell (var (Witness 7, Curr))\n * ( cell (var (Witness 7, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 7, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n ) )\n + alpha_pow 2\n * ( cell (var (Witness 0, Curr))\n + cell (var (Witness 1, Curr))\n * field\n \"0x0000000000000000000000000000000000000000010000000000000000000000\"\n + cell (var (Coefficient 3, Curr))\n * ( cell (var (Witness 3, Curr))\n + cell (var (Witness 4, Curr))\n * field\n \"0x0000000000000000000000000000000000000000010000000000000000000000\"\n )\n - cell (var (Witness 6, Curr))\n * ( cell (var (Coefficient 0, Curr))\n + cell (var (Coefficient 1, Curr))\n * field\n \"0x0000000000000000000000000000000000000000010000000000000000000000\"\n )\n - cell (var (Witness 7, Curr))\n * field\n \"0x0000000000000000000100000000000000000000000000000000000000000000\"\n - ( cell (var (Witness 0, Next))\n + cell (var (Witness 1, Next))\n * field\n \"0x0000000000000000000000000000000000000000010000000000000000000000\"\n ) )\n + alpha_pow 3\n * ( cell (var (Witness 2, Curr))\n + cell (var (Coefficient 3, Curr))\n * cell (var (Witness 5, Curr))\n - cell (var (Witness 6, Curr))\n * cell (var (Coefficient 2, Curr))\n + cell (var (Witness 7, Curr))\n - cell (var (Witness 2, Next)) ) ) )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000000\"\n )\n + if_feature\n ( ForeignFieldMul\n , (fun () ->\n cell (var (Index ForeignFieldMul, Curr))\n * ( cell (var (Witness 7, Next))\n * ( cell (var (Witness 7, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 7, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 7, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n )\n + alpha_pow 1\n * ( cell (var (Witness 11, Next))\n * ( cell (var (Witness 11, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 11, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 11, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 2\n * ( (cell (var (Witness 0, Curr)) * cell (var (Witness 4, Curr)))\n + (cell (var (Witness 1, Curr)) * cell (var (Witness 3, Curr)))\n + cell (var (Witness 2, Next))\n * cell (var (Coefficient 2, Curr))\n + cell (var (Witness 3, Next))\n * cell (var (Coefficient 1, Curr))\n - ( field\n \"0x0000000000000000000000000000000000000000010000000000000000000000\"\n * ( field\n \"0x0000000000000000000000000000000000000000010000000000000000000000\"\n * cell (var (Witness 7, Next))\n + cell (var (Witness 6, Next)) )\n + cell (var (Witness 6, Curr)) ) )\n + alpha_pow 3\n * ( field\n \"0x0000000000000000000100000000000000000000000000000000000000000000\"\n * cell (var (Witness 11, Next))\n - ( cell (var (Witness 0, Curr))\n * cell (var (Witness 3, Curr))\n + cell (var (Witness 2, Next))\n * cell (var (Coefficient 1, Curr))\n + field\n \"0x0000000000000000000000000000000000000000010000000000000000000000\"\n * cell (var (Witness 6, Curr))\n - cell (var (Witness 0, Next)) ) )\n + alpha_pow 4\n * ( ( field\n \"0x0000000000000000000100000000000000000000000000000000000000000000\"\n * cell (var (Witness 2, Curr))\n + field\n \"0x0000000000000000000000000000000000000000010000000000000000000000\"\n * cell (var (Witness 1, Curr))\n + cell (var (Witness 0, Curr)) )\n * ( field\n \"0x0000000000000000000100000000000000000000000000000000000000000000\"\n * cell (var (Witness 5, Curr))\n + field\n \"0x0000000000000000000000000000000000000000010000000000000000000000\"\n * cell (var (Witness 4, Curr))\n + cell (var (Witness 3, Curr)) )\n + ( field\n \"0x0000000000000000000100000000000000000000000000000000000000000000\"\n * cell (var (Witness 4, Next))\n + field\n \"0x0000000000000000000000000000000000000000010000000000000000000000\"\n * cell (var (Witness 3, Next))\n + cell (var (Witness 2, Next)) )\n * ( field\n \"0x0000000000000000000100000000000000000000000000000000000000000000\"\n * cell (var (Coefficient 3, Curr))\n + field\n \"0x0000000000000000000000000000000000000000010000000000000000000000\"\n * cell (var (Coefficient 2, Curr))\n + cell (var (Coefficient 1, Curr)) )\n - ( field\n \"0x0000000000000000000100000000000000000000000000000000000000000000\"\n * cell (var (Witness 1, Next))\n + cell (var (Witness 0, Next)) )\n - ( field\n \"0x0000000000000000000100000000000000000000000000000000000000000000\"\n * cell (var (Witness 4, Next))\n + field\n \"0x0000000000000000000000000000000000000000010000000000000000000000\"\n * cell (var (Witness 3, Next))\n + cell (var (Witness 2, Next)) )\n * field\n \"0x3FFFFFFFFFFFFFFFFFFFFFFFFFFFFF7707E2A8D6D5688AB6E4697CECFFFFFC01\"\n )\n + alpha_pow 5\n * ( cell (var (Witness 11, Curr))\n * ( cell (var (Witness 11, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 11, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 11, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 6\n * ( cell (var (Witness 12, Curr))\n * ( cell (var (Witness 12, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 12, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 12, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 7\n * ( cell (var (Witness 13, Curr))\n * ( cell (var (Witness 13, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 13, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 13, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 8\n * ( square (cell (var (Witness 14, Curr)))\n - cell (var (Witness 14, Curr)) )\n + alpha_pow 9\n * ( field\n \"0x0000000000000000000000000000000000000000010000000000000000000000\"\n * ( cell (var (Witness 7, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * cell (var (Witness 8, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000001000000\"\n * cell (var (Witness 9, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000001000000000\"\n * cell (var (Witness 10, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000001000000000000\"\n * cell (var (Witness 8, Next))\n + field\n \"0x0000000000000000000000000000000000000000000000001000000000000000\"\n * cell (var (Witness 9, Next))\n + field\n \"0x0000000000000000000000000000000000000000000001000000000000000000\"\n * cell (var (Witness 10, Next))\n + field\n \"0x0000000000000000000000000000000000000000001000000000000000000000\"\n * cell (var (Witness 11, Curr))\n + field\n \"0x0000000000000000000000000000000000000000004000000000000000000000\"\n * cell (var (Witness 12, Curr))\n + field\n \"0x0000000000000000000000000000000000000000010000000000000000000000\"\n * cell (var (Witness 13, Curr))\n + field\n \"0x0000000000000000000000000000000000000000040000000000000000000000\"\n * cell (var (Witness 14, Curr)) )\n - ( cell (var (Witness 0, Curr))\n * cell (var (Witness 5, Curr))\n + cell (var (Witness 2, Curr))\n * cell (var (Witness 3, Curr))\n + cell (var (Witness 1, Curr))\n * cell (var (Witness 4, Curr))\n + cell (var (Witness 2, Next))\n * cell (var (Coefficient 3, Curr))\n + cell (var (Witness 4, Next))\n * cell (var (Coefficient 1, Curr))\n + cell (var (Witness 3, Next))\n * cell (var (Coefficient 2, Curr))\n + ( field\n \"0x0000000000000000000000000000000000000000010000000000000000000000\"\n * cell (var (Witness 7, Next))\n + cell (var (Witness 6, Next)) )\n + cell (var (Witness 11, Next))\n - cell (var (Witness 1, Next)) ) )\n + alpha_pow 10\n * ( cell (var (Witness 5, Next))\n - ( cell (var (Witness 4, Next))\n + field\n \"0x0000000000000000000000000000000000000000010000000000000000000000\"\n - cell (var (Coefficient 0, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n ) ) ) )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000000\"\n )\n + if_feature\n ( Xor\n , (fun () ->\n cell (var (Index Xor16, Curr))\n * ( cell (var (Witness 3, Curr))\n + cell (var (Witness 4, Curr))\n * pow\n ( field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n , 4 )\n + cell (var (Witness 5, Curr))\n * pow\n ( field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n , 8 )\n + cell (var (Witness 6, Curr))\n * pow\n ( field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n , 12 )\n + pow\n ( field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n , 16 )\n * cell (var (Witness 0, Next))\n - cell (var (Witness 0, Curr))\n + alpha_pow 1\n * ( cell (var (Witness 7, Curr))\n + cell (var (Witness 8, Curr))\n * pow\n ( field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n , 4 )\n + cell (var (Witness 9, Curr))\n * pow\n ( field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n , 8 )\n + cell (var (Witness 10, Curr))\n * pow\n ( field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n , 12 )\n + pow\n ( field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n , 16 )\n * cell (var (Witness 1, Next))\n - cell (var (Witness 1, Curr)) )\n + alpha_pow 2\n * ( cell (var (Witness 11, Curr))\n + cell (var (Witness 12, Curr))\n * pow\n ( field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n , 4 )\n + cell (var (Witness 13, Curr))\n * pow\n ( field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n , 8 )\n + cell (var (Witness 14, Curr))\n * pow\n ( field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n , 12 )\n + pow\n ( field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n , 16 )\n * cell (var (Witness 2, Next))\n - cell (var (Witness 2, Curr)) ) ) )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000000\"\n )\n + if_feature\n ( Rot\n , (fun () ->\n cell (var (Index Rot64, Curr))\n * ( cell (var (Witness 7, Curr))\n * ( cell (var (Witness 7, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 7, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 7, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n )\n + alpha_pow 1\n * ( cell (var (Witness 8, Curr))\n * ( cell (var (Witness 8, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 8, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 8, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 2\n * ( cell (var (Witness 9, Curr))\n * ( cell (var (Witness 9, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 9, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 9, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 3\n * ( cell (var (Witness 10, Curr))\n * ( cell (var (Witness 10, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 10, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 10, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 4\n * ( cell (var (Witness 11, Curr))\n * ( cell (var (Witness 11, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 11, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 11, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 5\n * ( cell (var (Witness 12, Curr))\n * ( cell (var (Witness 12, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 12, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 12, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 6\n * ( cell (var (Witness 13, Curr))\n * ( cell (var (Witness 13, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 13, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 13, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 7\n * ( cell (var (Witness 14, Curr))\n * ( cell (var (Witness 14, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 14, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 14, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 8\n * ( cell (var (Witness 0, Curr))\n * cell (var (Coefficient 0, Curr))\n - ( cell (var (Witness 2, Curr))\n * field\n \"0x0000000000000000000000000000000000000000000000010000000000000000\"\n + cell (var (Witness 0, Next)) ) )\n + alpha_pow 9\n * ( cell (var (Witness 1, Curr))\n - (cell (var (Witness 0, Next)) + cell (var (Witness 2, Curr)))\n )\n + alpha_pow 10\n * ( cell (var (Witness 14, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 13, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 12, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 11, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 10, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 9, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 8, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 7, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 6, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * cell (var (Witness 5, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * cell (var (Witness 4, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * cell (var (Witness 3, Curr))\n - ( cell (var (Witness 2, Curr))\n - cell (var (Coefficient 0, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000010000000000000000\"\n ) ) ) )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000000\"\n )\n + cell (var (Index Generic, Curr))\n * ( (cell (var (Coefficient 0, Curr)) * cell (var (Witness 0, Curr)))\n + (cell (var (Coefficient 1, Curr)) * cell (var (Witness 1, Curr)))\n + (cell (var (Coefficient 2, Curr)) * cell (var (Witness 2, Curr)))\n + cell (var (Coefficient 3, Curr))\n * cell (var (Witness 0, Curr))\n * cell (var (Witness 1, Curr))\n + cell (var (Coefficient 4, Curr))\n + alpha_pow 1\n * ( (cell (var (Coefficient 5, Curr)) * cell (var (Witness 3, Curr)))\n + (cell (var (Coefficient 6, Curr)) * cell (var (Witness 4, Curr)))\n + (cell (var (Coefficient 7, Curr)) * cell (var (Witness 5, Curr)))\n + cell (var (Coefficient 8, Curr))\n * cell (var (Witness 3, Curr))\n * cell (var (Witness 4, Curr))\n + cell (var (Coefficient 9, Curr)) ) )\n + if_feature\n ( LookupTables\n , (fun () ->\n alpha_pow 24\n * ( vanishes_on_last_4_rows\n * ( cell (var (LookupAggreg, Next))\n * ( if_feature\n ( LookupsPerRow 0\n , (fun () ->\n gamma\n * ( beta\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n + cell (var (LookupSorted 0, Curr))\n + (beta * cell (var (LookupSorted 0, Next))) )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( LookupsPerRow 1\n , (fun () ->\n gamma\n * ( beta\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n + cell (var (LookupSorted 1, Next))\n + (beta * cell (var (LookupSorted 1, Curr))) )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( LookupsPerRow 2\n , (fun () ->\n gamma\n * ( beta\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n + cell (var (LookupSorted 2, Curr))\n + (beta * cell (var (LookupSorted 2, Next))) )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( LookupsPerRow 3\n , (fun () ->\n gamma\n * ( beta\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n + cell (var (LookupSorted 3, Next))\n + (beta * cell (var (LookupSorted 3, Curr))) )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( LookupsPerRow 4\n , (fun () ->\n gamma\n * ( beta\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n + cell (var (LookupSorted 4, Curr))\n + (beta * cell (var (LookupSorted 4, Next))) )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n ) )\n - cell (var (LookupAggreg, Curr))\n * ( ( ( field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n - ( if_feature\n ( LookupPattern Xor\n , (fun () ->\n cell (var (LookupKindIndex Xor, Curr)) )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000000\"\n )\n + if_feature\n ( LookupPattern Lookup\n , (fun () ->\n cell (var (LookupKindIndex Lookup, Curr)) )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000000\"\n )\n + if_feature\n ( LookupPattern RangeCheck\n , (fun () ->\n cell (var (LookupKindIndex RangeCheck, Curr))\n )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000000\"\n )\n + if_feature\n ( LookupPattern ForeignFieldMul\n , (fun () ->\n cell\n (var\n (LookupKindIndex ForeignFieldMul, Curr) )\n )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000000\"\n ) ) )\n * ( if_feature\n ( LookupsPerRow 1\n , (fun () -> gamma)\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( LookupsPerRow 2\n , (fun () -> gamma)\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( LookupsPerRow 3\n , (fun () -> gamma)\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( LookupsPerRow 4\n , (fun () -> gamma)\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( ( field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n + beta )\n * if_feature\n ( LookupsPerRow 2\n , (fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n + beta )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( LookupsPerRow 3\n , (fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n + beta )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( LookupsPerRow 4\n , (fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n + beta )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n ) ) )\n + if_feature\n ( LookupPattern Xor\n , (fun () ->\n cell (var (LookupKindIndex Xor, Curr))\n * ( ( field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n + beta )\n * if_feature\n ( LookupsPerRow 2\n , (fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n + beta )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( LookupsPerRow 3\n , (fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n + beta )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( LookupsPerRow 4\n , (fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n + beta )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( gamma\n + ( joint_combiner\n * ( joint_combiner\n * cell (var (Witness 11, Curr))\n + cell (var (Witness 7, Curr)) )\n + cell (var (Witness 3, Curr)) ) )\n * ( gamma\n + ( joint_combiner\n * ( joint_combiner\n * cell (var (Witness 12, Curr))\n + cell (var (Witness 8, Curr)) )\n + cell (var (Witness 4, Curr)) ) )\n * ( gamma\n + ( joint_combiner\n * ( joint_combiner\n * cell (var (Witness 13, Curr))\n + cell (var (Witness 9, Curr)) )\n + cell (var (Witness 5, Curr)) ) )\n * ( gamma\n + ( joint_combiner\n * ( joint_combiner\n * cell (var (Witness 14, Curr))\n + cell (var (Witness 10, Curr)) )\n + cell (var (Witness 6, Curr)) ) ) ) )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000000\"\n )\n + if_feature\n ( LookupPattern Lookup\n , (fun () ->\n cell (var (LookupKindIndex Lookup, Curr))\n * ( if_feature\n ( LookupsPerRow 4\n , (fun () -> gamma)\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( ( field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n + beta )\n * if_feature\n ( LookupsPerRow 2\n , (fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n + beta )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( LookupsPerRow 3\n , (fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n + beta )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( LookupsPerRow 4\n , (fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n + beta )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n ) )\n * ( gamma\n + ( joint_combiner\n * cell (var (Witness 2, Curr))\n + cell (var (Witness 1, Curr))\n + joint_combiner\n * if_feature\n ( TableWidth 2\n , (fun () -> joint_combiner)\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( TableWidth 3\n , (fun () -> joint_combiner)\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * cell (var (Witness 0, Curr)) ) )\n * ( gamma\n + ( joint_combiner\n * cell (var (Witness 4, Curr))\n + cell (var (Witness 3, Curr))\n + joint_combiner\n * if_feature\n ( TableWidth 2\n , (fun () -> joint_combiner)\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( TableWidth 3\n , (fun () -> joint_combiner)\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * cell (var (Witness 0, Curr)) ) )\n * ( gamma\n + ( joint_combiner\n * cell (var (Witness 6, Curr))\n + cell (var (Witness 5, Curr))\n + joint_combiner\n * if_feature\n ( TableWidth 2\n , (fun () -> joint_combiner)\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( TableWidth 3\n , (fun () -> joint_combiner)\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * cell (var (Witness 0, Curr)) ) ) ) )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000000\"\n )\n + if_feature\n ( LookupPattern RangeCheck\n , (fun () ->\n cell (var (LookupKindIndex RangeCheck, Curr))\n * ( ( field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n + beta )\n * if_feature\n ( LookupsPerRow 2\n , (fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n + beta )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( LookupsPerRow 3\n , (fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n + beta )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( LookupsPerRow 4\n , (fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n + beta )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( gamma\n + ( cell (var (Witness 3, Curr))\n + joint_combiner\n * if_feature\n ( TableWidth 2\n , (fun () -> joint_combiner)\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( TableWidth 3\n , (fun () -> joint_combiner)\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n ) ) )\n * ( gamma\n + ( cell (var (Witness 4, Curr))\n + joint_combiner\n * if_feature\n ( TableWidth 2\n , (fun () -> joint_combiner)\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( TableWidth 3\n , (fun () -> joint_combiner)\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n ) ) )\n * ( gamma\n + ( cell (var (Witness 5, Curr))\n + joint_combiner\n * if_feature\n ( TableWidth 2\n , (fun () -> joint_combiner)\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( TableWidth 3\n , (fun () -> joint_combiner)\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n ) ) )\n * ( gamma\n + ( cell (var (Witness 6, Curr))\n + joint_combiner\n * if_feature\n ( TableWidth 2\n , (fun () -> joint_combiner)\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( TableWidth 3\n , (fun () -> joint_combiner)\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n ) ) ) ) )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000000\"\n )\n + if_feature\n ( LookupPattern ForeignFieldMul\n , (fun () ->\n cell (var (LookupKindIndex ForeignFieldMul, Curr))\n * ( ( field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n + beta )\n * if_feature\n ( LookupsPerRow 2\n , (fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n + beta )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( LookupsPerRow 3\n , (fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n + beta )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( LookupsPerRow 4\n , (fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n + beta )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( gamma\n + ( cell (var (Witness 7, Curr))\n + joint_combiner\n * if_feature\n ( TableWidth 2\n , (fun () -> joint_combiner)\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( TableWidth 3\n , (fun () -> joint_combiner)\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n ) ) )\n * ( gamma\n + ( cell (var (Witness 8, Curr))\n + joint_combiner\n * if_feature\n ( TableWidth 2\n , (fun () -> joint_combiner)\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( TableWidth 3\n , (fun () -> joint_combiner)\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n ) ) )\n * ( gamma\n + ( cell (var (Witness 9, Curr))\n + joint_combiner\n * if_feature\n ( TableWidth 2\n , (fun () -> joint_combiner)\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( TableWidth 3\n , (fun () -> joint_combiner)\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n ) ) )\n * ( gamma\n + ( cell (var (Witness 10, Curr))\n + joint_combiner\n * if_feature\n ( TableWidth 2\n , (fun () -> joint_combiner)\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( TableWidth 3\n , (fun () -> joint_combiner)\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n ) ) ) ) )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000000\"\n ) )\n * ( gamma\n * ( beta\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n + cell (var (LookupTable, Curr))\n + (beta * cell (var (LookupTable, Next))) ) ) ) )\n + alpha_pow 25\n * ( unnormalized_lagrange_basis 0\n * ( cell (var (LookupAggreg, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n ) )\n + alpha_pow 26\n * ( unnormalized_lagrange_basis (-4)\n * ( cell (var (LookupAggreg, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n ) )\n + alpha_pow 27\n * if_feature\n ( LookupsPerRow 1\n , (fun () ->\n unnormalized_lagrange_basis (-4)\n * ( cell (var (LookupSorted 0, Curr))\n - cell (var (LookupSorted 1, Curr)) ) )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000000\"\n )\n + alpha_pow 28\n * if_feature\n ( LookupsPerRow 2\n , (fun () ->\n unnormalized_lagrange_basis 0\n * ( cell (var (LookupSorted 1, Curr))\n - cell (var (LookupSorted 2, Curr)) ) )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000000\"\n )\n + alpha_pow 29\n * if_feature\n ( LookupsPerRow 3\n , (fun () ->\n unnormalized_lagrange_basis (-4)\n * ( cell (var (LookupSorted 2, Curr))\n - cell (var (LookupSorted 3, Curr)) ) )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000000\"\n )\n + alpha_pow 30\n * if_feature\n ( LookupsPerRow 4\n , (fun () ->\n unnormalized_lagrange_basis 0\n * ( cell (var (LookupSorted 3, Curr))\n - cell (var (LookupSorted 4, Curr)) ) )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000000\"\n )\n + alpha_pow 31\n * if_feature\n ( RuntimeLookupTables\n , (fun () ->\n cell (var (LookupRuntimeTable, Curr))\n * cell (var (LookupRuntimeSelector, Curr)) )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000000\"\n ) )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000000\"\n )\n\n let index_terms (type a) (_ : a Env.t) = Column.Table.of_alist_exn []\nend\n\nmodule Tock : S = struct\n let constant_term (type a)\n ({ add = ( + )\n ; sub = ( - )\n ; mul = ( * )\n ; square\n ; mds\n ; endo_coefficient\n ; pow\n ; var\n ; field\n ; cell\n ; alpha_pow\n ; double\n ; zk_polynomial = _\n ; omega_to_minus_3 = _\n ; zeta_to_n_minus_1 = _\n ; srs_length_log2 = _\n ; vanishes_on_last_4_rows = _\n ; joint_combiner = _\n ; beta = _\n ; gamma = _\n ; unnormalized_lagrange_basis = _\n ; if_feature = _\n } :\n a Env.t ) =\n let x_0 = pow (cell (var (Witness 0, Curr)), 7) in\n let x_1 = pow (cell (var (Witness 1, Curr)), 7) in\n let x_2 = pow (cell (var (Witness 2, Curr)), 7) in\n let x_3 = pow (cell (var (Witness 6, Curr)), 7) in\n let x_4 = pow (cell (var (Witness 7, Curr)), 7) in\n let x_5 = pow (cell (var (Witness 8, Curr)), 7) in\n let x_6 = pow (cell (var (Witness 9, Curr)), 7) in\n let x_7 = pow (cell (var (Witness 10, Curr)), 7) in\n let x_8 = pow (cell (var (Witness 11, Curr)), 7) in\n let x_9 = pow (cell (var (Witness 12, Curr)), 7) in\n let x_10 = pow (cell (var (Witness 13, Curr)), 7) in\n let x_11 = pow (cell (var (Witness 14, Curr)), 7) in\n let x_12 = pow (cell (var (Witness 3, Curr)), 7) in\n let x_13 = pow (cell (var (Witness 4, Curr)), 7) in\n let x_14 = pow (cell (var (Witness 5, Curr)), 7) in\n let x_15 = cell (var (Witness 7, Next)) * cell (var (Witness 7, Next)) in\n let x_16 =\n let x_15 = cell (var (Witness 7, Next)) * cell (var (Witness 7, Next)) in\n cell (var (Witness 2, Curr))\n - (x_15 - cell (var (Witness 2, Curr)) - cell (var (Witness 0, Curr)))\n in\n let x_17 =\n let x_16 =\n let x_15 =\n cell (var (Witness 7, Next)) * cell (var (Witness 7, Next))\n in\n cell (var (Witness 2, Curr))\n - (x_15 - cell (var (Witness 2, Curr)) - cell (var (Witness 0, Curr)))\n in\n double (cell (var (Witness 3, Curr)))\n - (x_16 * cell (var (Witness 7, Next)))\n in\n let x_18 = cell (var (Witness 8, Next)) * cell (var (Witness 8, Next)) in\n let x_19 =\n let x_18 = cell (var (Witness 8, Next)) * cell (var (Witness 8, Next)) in\n cell (var (Witness 7, Curr))\n - (x_18 - cell (var (Witness 7, Curr)) - cell (var (Witness 0, Curr)))\n in\n let x_20 =\n let x_19 =\n let x_18 =\n cell (var (Witness 8, Next)) * cell (var (Witness 8, Next))\n in\n cell (var (Witness 7, Curr))\n - (x_18 - cell (var (Witness 7, Curr)) - cell (var (Witness 0, Curr)))\n in\n double (cell (var (Witness 8, Curr)))\n - (x_19 * cell (var (Witness 8, Next)))\n in\n let x_21 = cell (var (Witness 9, Next)) * cell (var (Witness 9, Next)) in\n let x_22 =\n let x_21 = cell (var (Witness 9, Next)) * cell (var (Witness 9, Next)) in\n cell (var (Witness 9, Curr))\n - (x_21 - cell (var (Witness 9, Curr)) - cell (var (Witness 0, Curr)))\n in\n let x_23 =\n let x_22 =\n let x_21 =\n cell (var (Witness 9, Next)) * cell (var (Witness 9, Next))\n in\n cell (var (Witness 9, Curr))\n - (x_21 - cell (var (Witness 9, Curr)) - cell (var (Witness 0, Curr)))\n in\n double (cell (var (Witness 10, Curr)))\n - (x_22 * cell (var (Witness 9, Next)))\n in\n let x_24 = cell (var (Witness 10, Next)) * cell (var (Witness 10, Next)) in\n let x_25 =\n let x_24 =\n cell (var (Witness 10, Next)) * cell (var (Witness 10, Next))\n in\n cell (var (Witness 11, Curr))\n - (x_24 - cell (var (Witness 11, Curr)) - cell (var (Witness 0, Curr)))\n in\n let x_26 =\n let x_25 =\n let x_24 =\n cell (var (Witness 10, Next)) * cell (var (Witness 10, Next))\n in\n cell (var (Witness 11, Curr))\n - (x_24 - cell (var (Witness 11, Curr)) - cell (var (Witness 0, Curr)))\n in\n double (cell (var (Witness 12, Curr)))\n - (x_25 * cell (var (Witness 10, Next)))\n in\n let x_27 = cell (var (Witness 11, Next)) * cell (var (Witness 11, Next)) in\n let x_28 =\n let x_27 =\n cell (var (Witness 11, Next)) * cell (var (Witness 11, Next))\n in\n cell (var (Witness 13, Curr))\n - (x_27 - cell (var (Witness 13, Curr)) - cell (var (Witness 0, Curr)))\n in\n let x_29 =\n let x_28 =\n let x_27 =\n cell (var (Witness 11, Next)) * cell (var (Witness 11, Next))\n in\n cell (var (Witness 13, Curr))\n - (x_27 - cell (var (Witness 13, Curr)) - cell (var (Witness 0, Curr)))\n in\n double (cell (var (Witness 14, Curr)))\n - (x_28 * cell (var (Witness 11, Next)))\n in\n let x_30 = cell (var (Witness 2, Curr)) - cell (var (Witness 0, Curr)) in\n let x_31 = cell (var (Witness 3, Curr)) - cell (var (Witness 1, Curr)) in\n let x_32 = cell (var (Witness 0, Curr)) * cell (var (Witness 0, Curr)) in\n let x_33 =\n ( field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n + cell (var (Witness 11, Curr))\n * ( endo_coefficient\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n ) )\n * cell (var (Witness 0, Curr))\n in\n let x_34 =\n ( field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n + cell (var (Witness 13, Curr))\n * ( endo_coefficient\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n ) )\n * cell (var (Witness 0, Curr))\n in\n let x_35 = square (cell (var (Witness 9, Curr))) in\n let x_36 = square (cell (var (Witness 10, Curr))) in\n let x_37 = cell (var (Witness 4, Curr)) - cell (var (Witness 7, Curr)) in\n let x_38 = cell (var (Witness 7, Curr)) - cell (var (Witness 4, Next)) in\n let x_39 = cell (var (Witness 5, Next)) + cell (var (Witness 8, Curr)) in\n let x_40 = cell (var (Witness 8, Curr)) + cell (var (Witness 5, Curr)) in\n let x_41 =\n ( ( field\n \"0x1555555555555555555555555555555560C232FEADDC3849D96CF90B00000001\"\n * cell (var (Witness 6, Curr))\n + field\n \"0x2000000000000000000000000000000011234C7E04CA546EC62375907FFFFFFE\"\n )\n * cell (var (Witness 6, Curr))\n + field\n \"0x0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB061197F56EE1C24ECB67C8580000002\"\n )\n * cell (var (Witness 6, Curr))\n in\n let x_42 =\n ( ( field\n \"0x1555555555555555555555555555555560C232FEADDC3849D96CF90B00000001\"\n * cell (var (Witness 7, Curr))\n + field\n \"0x2000000000000000000000000000000011234C7E04CA546EC62375907FFFFFFE\"\n )\n * cell (var (Witness 7, Curr))\n + field\n \"0x0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB061197F56EE1C24ECB67C8580000002\"\n )\n * cell (var (Witness 7, Curr))\n in\n let x_43 =\n ( ( field\n \"0x1555555555555555555555555555555560C232FEADDC3849D96CF90B00000001\"\n * cell (var (Witness 8, Curr))\n + field\n \"0x2000000000000000000000000000000011234C7E04CA546EC62375907FFFFFFE\"\n )\n * cell (var (Witness 8, Curr))\n + field\n \"0x0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB061197F56EE1C24ECB67C8580000002\"\n )\n * cell (var (Witness 8, Curr))\n in\n let x_44 =\n ( ( field\n \"0x1555555555555555555555555555555560C232FEADDC3849D96CF90B00000001\"\n * cell (var (Witness 9, Curr))\n + field\n \"0x2000000000000000000000000000000011234C7E04CA546EC62375907FFFFFFE\"\n )\n * cell (var (Witness 9, Curr))\n + field\n \"0x0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB061197F56EE1C24ECB67C8580000002\"\n )\n * cell (var (Witness 9, Curr))\n in\n let x_45 =\n ( ( field\n \"0x1555555555555555555555555555555560C232FEADDC3849D96CF90B00000001\"\n * cell (var (Witness 10, Curr))\n + field\n \"0x2000000000000000000000000000000011234C7E04CA546EC62375907FFFFFFE\"\n )\n * cell (var (Witness 10, Curr))\n + field\n \"0x0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB061197F56EE1C24ECB67C8580000002\"\n )\n * cell (var (Witness 10, Curr))\n in\n let x_46 =\n ( ( field\n \"0x1555555555555555555555555555555560C232FEADDC3849D96CF90B00000001\"\n * cell (var (Witness 11, Curr))\n + field\n \"0x2000000000000000000000000000000011234C7E04CA546EC62375907FFFFFFE\"\n )\n * cell (var (Witness 11, Curr))\n + field\n \"0x0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB061197F56EE1C24ECB67C8580000002\"\n )\n * cell (var (Witness 11, Curr))\n in\n let x_47 =\n ( ( field\n \"0x1555555555555555555555555555555560C232FEADDC3849D96CF90B00000001\"\n * cell (var (Witness 12, Curr))\n + field\n \"0x2000000000000000000000000000000011234C7E04CA546EC62375907FFFFFFE\"\n )\n * cell (var (Witness 12, Curr))\n + field\n \"0x0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB061197F56EE1C24ECB67C8580000002\"\n )\n * cell (var (Witness 12, Curr))\n in\n let x_48 =\n ( ( field\n \"0x1555555555555555555555555555555560C232FEADDC3849D96CF90B00000001\"\n * cell (var (Witness 13, Curr))\n + field\n \"0x2000000000000000000000000000000011234C7E04CA546EC62375907FFFFFFE\"\n )\n * cell (var (Witness 13, Curr))\n + field\n \"0x0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB061197F56EE1C24ECB67C8580000002\"\n )\n * cell (var (Witness 13, Curr))\n in\n cell (var (Index Poseidon, Curr))\n * ( cell (var (Witness 6, Curr))\n - ( cell (var (Coefficient 0, Curr))\n + (mds (0, 0) * x_0)\n + (mds (0, 1) * x_1)\n + (mds (0, 2) * x_2) )\n + alpha_pow 1\n * ( cell (var (Witness 7, Curr))\n - ( cell (var (Coefficient 1, Curr))\n + (mds (1, 0) * x_0)\n + (mds (1, 1) * x_1)\n + (mds (1, 2) * x_2) ) )\n + alpha_pow 2\n * ( cell (var (Witness 8, Curr))\n - ( cell (var (Coefficient 2, Curr))\n + (mds (2, 0) * x_0)\n + (mds (2, 1) * x_1)\n + (mds (2, 2) * x_2) ) )\n + alpha_pow 3\n * ( cell (var (Witness 9, Curr))\n - ( cell (var (Coefficient 3, Curr))\n + (mds (0, 0) * x_3)\n + (mds (0, 1) * x_4)\n + (mds (0, 2) * x_5) ) )\n + alpha_pow 4\n * ( cell (var (Witness 10, Curr))\n - ( cell (var (Coefficient 4, Curr))\n + (mds (1, 0) * x_3)\n + (mds (1, 1) * x_4)\n + (mds (1, 2) * x_5) ) )\n + alpha_pow 5\n * ( cell (var (Witness 11, Curr))\n - ( cell (var (Coefficient 5, Curr))\n + (mds (2, 0) * x_3)\n + (mds (2, 1) * x_4)\n + (mds (2, 2) * x_5) ) )\n + alpha_pow 6\n * ( cell (var (Witness 12, Curr))\n - ( cell (var (Coefficient 6, Curr))\n + (mds (0, 0) * x_6)\n + (mds (0, 1) * x_7)\n + (mds (0, 2) * x_8) ) )\n + alpha_pow 7\n * ( cell (var (Witness 13, Curr))\n - ( cell (var (Coefficient 7, Curr))\n + (mds (1, 0) * x_6)\n + (mds (1, 1) * x_7)\n + (mds (1, 2) * x_8) ) )\n + alpha_pow 8\n * ( cell (var (Witness 14, Curr))\n - ( cell (var (Coefficient 8, Curr))\n + (mds (2, 0) * x_6)\n + (mds (2, 1) * x_7)\n + (mds (2, 2) * x_8) ) )\n + alpha_pow 9\n * ( cell (var (Witness 3, Curr))\n - ( cell (var (Coefficient 9, Curr))\n + (mds (0, 0) * x_9)\n + (mds (0, 1) * x_10)\n + (mds (0, 2) * x_11) ) )\n + alpha_pow 10\n * ( cell (var (Witness 4, Curr))\n - ( cell (var (Coefficient 10, Curr))\n + (mds (1, 0) * x_9)\n + (mds (1, 1) * x_10)\n + (mds (1, 2) * x_11) ) )\n + alpha_pow 11\n * ( cell (var (Witness 5, Curr))\n - ( cell (var (Coefficient 11, Curr))\n + (mds (2, 0) * x_9)\n + (mds (2, 1) * x_10)\n + (mds (2, 2) * x_11) ) )\n + alpha_pow 12\n * ( cell (var (Witness 0, Next))\n - ( cell (var (Coefficient 12, Curr))\n + (mds (0, 0) * x_12)\n + (mds (0, 1) * x_13)\n + (mds (0, 2) * x_14) ) )\n + alpha_pow 13\n * ( cell (var (Witness 1, Next))\n - ( cell (var (Coefficient 13, Curr))\n + (mds (1, 0) * x_12)\n + (mds (1, 1) * x_13)\n + (mds (1, 2) * x_14) ) )\n + alpha_pow 14\n * ( cell (var (Witness 2, Next))\n - ( cell (var (Coefficient 14, Curr))\n + (mds (2, 0) * x_12)\n + (mds (2, 1) * x_13)\n + (mds (2, 2) * x_14) ) ) )\n + cell (var (Index VarBaseMul, Curr))\n * ( cell (var (Witness 5, Curr))\n - ( cell (var (Witness 6, Next))\n + double\n ( cell (var (Witness 5, Next))\n + double\n ( cell (var (Witness 4, Next))\n + double\n ( cell (var (Witness 3, Next))\n + double\n ( cell (var (Witness 2, Next))\n + double (cell (var (Witness 4, Curr))) ) ) ) ) )\n + alpha_pow 1\n * ( square (cell (var (Witness 2, Next)))\n - cell (var (Witness 2, Next)) )\n + alpha_pow 2\n * ( (cell (var (Witness 2, Curr)) - cell (var (Witness 0, Curr)))\n * cell (var (Witness 7, Next))\n - ( cell (var (Witness 3, Curr))\n - ( double (cell (var (Witness 2, Next)))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * cell (var (Witness 1, Curr)) ) )\n + alpha_pow 3\n * ( (x_17 * x_17)\n - x_16 * x_16\n * ( cell (var (Witness 7, Curr))\n - cell (var (Witness 0, Curr))\n + x_15 ) )\n + alpha_pow 4\n * ( (cell (var (Witness 8, Curr)) + cell (var (Witness 3, Curr)))\n * x_16\n - (cell (var (Witness 2, Curr)) - cell (var (Witness 7, Curr)))\n * x_17 )\n + alpha_pow 5\n * ( square (cell (var (Witness 3, Next)))\n - cell (var (Witness 3, Next)) )\n + alpha_pow 6\n * ( (cell (var (Witness 7, Curr)) - cell (var (Witness 0, Curr)))\n * cell (var (Witness 8, Next))\n - ( cell (var (Witness 8, Curr))\n - ( double (cell (var (Witness 3, Next)))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * cell (var (Witness 1, Curr)) ) )\n + alpha_pow 7\n * ( (x_20 * x_20)\n - x_19 * x_19\n * ( cell (var (Witness 9, Curr))\n - cell (var (Witness 0, Curr))\n + x_18 ) )\n + alpha_pow 8\n * ( (cell (var (Witness 10, Curr)) + cell (var (Witness 8, Curr)))\n * x_19\n - (cell (var (Witness 7, Curr)) - cell (var (Witness 9, Curr)))\n * x_20 )\n + alpha_pow 9\n * ( square (cell (var (Witness 4, Next)))\n - cell (var (Witness 4, Next)) )\n + alpha_pow 10\n * ( (cell (var (Witness 9, Curr)) - cell (var (Witness 0, Curr)))\n * cell (var (Witness 9, Next))\n - ( cell (var (Witness 10, Curr))\n - ( double (cell (var (Witness 4, Next)))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * cell (var (Witness 1, Curr)) ) )\n + alpha_pow 11\n * ( (x_23 * x_23)\n - x_22 * x_22\n * ( cell (var (Witness 11, Curr))\n - cell (var (Witness 0, Curr))\n + x_21 ) )\n + alpha_pow 12\n * ( (cell (var (Witness 12, Curr)) + cell (var (Witness 10, Curr)))\n * x_22\n - (cell (var (Witness 9, Curr)) - cell (var (Witness 11, Curr)))\n * x_23 )\n + alpha_pow 13\n * ( square (cell (var (Witness 5, Next)))\n - cell (var (Witness 5, Next)) )\n + alpha_pow 14\n * ( (cell (var (Witness 11, Curr)) - cell (var (Witness 0, Curr)))\n * cell (var (Witness 10, Next))\n - ( cell (var (Witness 12, Curr))\n - ( double (cell (var (Witness 5, Next)))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * cell (var (Witness 1, Curr)) ) )\n + alpha_pow 15\n * ( (x_26 * x_26)\n - x_25 * x_25\n * ( cell (var (Witness 13, Curr))\n - cell (var (Witness 0, Curr))\n + x_24 ) )\n + alpha_pow 16\n * ( (cell (var (Witness 14, Curr)) + cell (var (Witness 12, Curr)))\n * x_25\n - (cell (var (Witness 11, Curr)) - cell (var (Witness 13, Curr)))\n * x_26 )\n + alpha_pow 17\n * ( square (cell (var (Witness 6, Next)))\n - cell (var (Witness 6, Next)) )\n + alpha_pow 18\n * ( (cell (var (Witness 13, Curr)) - cell (var (Witness 0, Curr)))\n * cell (var (Witness 11, Next))\n - ( cell (var (Witness 14, Curr))\n - ( double (cell (var (Witness 6, Next)))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * cell (var (Witness 1, Curr)) ) )\n + alpha_pow 19\n * ( (x_29 * x_29)\n - x_28 * x_28\n * ( cell (var (Witness 0, Next))\n - cell (var (Witness 0, Curr))\n + x_27 ) )\n + alpha_pow 20\n * ( (cell (var (Witness 1, Next)) + cell (var (Witness 14, Curr)))\n * x_28\n - (cell (var (Witness 13, Curr)) - cell (var (Witness 0, Next)))\n * x_29 ) )\n + cell (var (Index CompleteAdd, Curr))\n * ( (cell (var (Witness 10, Curr)) * x_30)\n - ( field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n - cell (var (Witness 7, Curr)) )\n + (alpha_pow 1 * (cell (var (Witness 7, Curr)) * x_30))\n + alpha_pow 2\n * ( cell (var (Witness 7, Curr))\n * ( double (cell (var (Witness 8, Curr)))\n * cell (var (Witness 1, Curr))\n - double x_32 - x_32 )\n + ( field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n - cell (var (Witness 7, Curr)) )\n * ((x_30 * cell (var (Witness 8, Curr))) - x_31) )\n + alpha_pow 3\n * ( cell (var (Witness 0, Curr))\n + cell (var (Witness 2, Curr))\n + cell (var (Witness 4, Curr))\n - (cell (var (Witness 8, Curr)) * cell (var (Witness 8, Curr))) )\n + alpha_pow 4\n * ( cell (var (Witness 8, Curr))\n * (cell (var (Witness 0, Curr)) - cell (var (Witness 4, Curr)))\n - cell (var (Witness 1, Curr))\n - cell (var (Witness 5, Curr)) )\n + alpha_pow 5\n * ( x_31\n * (cell (var (Witness 7, Curr)) - cell (var (Witness 6, Curr))) )\n + alpha_pow 6\n * ( (x_31 * cell (var (Witness 9, Curr)))\n - cell (var (Witness 6, Curr)) ) )\n + cell (var (Index EndoMul, Curr))\n * ( square (cell (var (Witness 11, Curr)))\n - cell (var (Witness 11, Curr))\n + alpha_pow 1\n * ( square (cell (var (Witness 12, Curr)))\n - cell (var (Witness 12, Curr)) )\n + alpha_pow 2\n * ( square (cell (var (Witness 13, Curr)))\n - cell (var (Witness 13, Curr)) )\n + alpha_pow 3\n * ( square (cell (var (Witness 14, Curr)))\n - cell (var (Witness 14, Curr)) )\n + alpha_pow 4\n * ( (x_33 - cell (var (Witness 4, Curr)))\n * cell (var (Witness 9, Curr))\n - ( ( double (cell (var (Witness 12, Curr)))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * cell (var (Witness 1, Curr))\n - cell (var (Witness 5, Curr)) ) )\n + alpha_pow 5\n * ( (double (cell (var (Witness 4, Curr))) - x_35 + x_33)\n * ((x_37 * cell (var (Witness 9, Curr))) + x_40)\n - (double (cell (var (Witness 5, Curr))) * x_37) )\n + alpha_pow 6\n * ( square x_40\n - (square x_37 * (x_35 - x_33 + cell (var (Witness 7, Curr)))) )\n + alpha_pow 7\n * ( (x_34 - cell (var (Witness 7, Curr)))\n * cell (var (Witness 10, Curr))\n - ( ( double (cell (var (Witness 14, Curr)))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * cell (var (Witness 1, Curr))\n - cell (var (Witness 8, Curr)) ) )\n + alpha_pow 8\n * ( (double (cell (var (Witness 7, Curr))) - x_36 + x_34)\n * ((x_38 * cell (var (Witness 10, Curr))) + x_39)\n - (double (cell (var (Witness 8, Curr))) * x_38) )\n + alpha_pow 9\n * ( square x_39\n - (square x_38 * (x_36 - x_34 + cell (var (Witness 4, Next)))) )\n + alpha_pow 10\n * ( double\n ( double\n ( double\n ( double (cell (var (Witness 6, Curr)))\n + cell (var (Witness 11, Curr)) )\n + cell (var (Witness 12, Curr)) )\n + cell (var (Witness 13, Curr)) )\n + cell (var (Witness 14, Curr))\n - cell (var (Witness 6, Next)) ) )\n + cell (var (Index EndoMulScalar, Curr))\n * ( double\n (double\n ( double\n (double\n ( double\n (double\n ( double\n (double\n ( double\n (double\n ( double\n (double\n ( double\n (double\n ( double\n (double\n (cell\n (var\n ( Witness 0\n , Curr ) ) ) )\n + cell\n (var\n (Witness 6, Curr) )\n ) )\n + cell (var (Witness 7, Curr))\n ) )\n + cell (var (Witness 8, Curr)) ) )\n + cell (var (Witness 9, Curr)) ) )\n + cell (var (Witness 10, Curr)) ) )\n + cell (var (Witness 11, Curr)) ) )\n + cell (var (Witness 12, Curr)) ) )\n + cell (var (Witness 13, Curr))\n - cell (var (Witness 1, Curr))\n + alpha_pow 1\n * ( double\n ( double\n ( double\n ( double\n ( double\n ( double\n ( double\n ( double (cell (var (Witness 2, Curr)))\n + x_41 )\n + x_42 )\n + x_43 )\n + x_44 )\n + x_45 )\n + x_46 )\n + x_47 )\n + x_48\n - cell (var (Witness 4, Curr)) )\n + alpha_pow 2\n * ( double\n ( double\n ( double\n ( double\n ( double\n ( double\n ( double\n ( double (cell (var (Witness 3, Curr)))\n + ( x_41\n + ( ( field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB2100000000\"\n * cell (var (Witness 6, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n )\n * cell (var (Witness 6, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB2100000000\"\n ) ) )\n + ( x_42\n + ( ( field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB2100000000\"\n * cell (var (Witness 7, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n )\n * cell (var (Witness 7, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB2100000000\"\n ) ) )\n + ( x_43\n + ( ( field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB2100000000\"\n * cell (var (Witness 8, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n )\n * cell (var (Witness 8, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB2100000000\"\n ) ) )\n + ( x_44\n + ( ( field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB2100000000\"\n * cell (var (Witness 9, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n )\n * cell (var (Witness 9, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB2100000000\"\n ) ) )\n + ( x_45\n + ( ( field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB2100000000\"\n * cell (var (Witness 10, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n )\n * cell (var (Witness 10, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB2100000000\"\n ) ) )\n + ( x_46\n + ( ( field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB2100000000\"\n * cell (var (Witness 11, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n )\n * cell (var (Witness 11, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB2100000000\"\n ) ) )\n + ( x_47\n + ( ( field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB2100000000\"\n * cell (var (Witness 12, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n )\n * cell (var (Witness 12, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB2100000000\"\n ) ) )\n + ( x_48\n + ( ( field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB2100000000\"\n * cell (var (Witness 13, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n )\n * cell (var (Witness 13, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB2100000000\"\n ) )\n - cell (var (Witness 5, Curr)) )\n + alpha_pow 3\n * ( ( ( ( cell (var (Witness 6, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB20FFFFFFFB\"\n )\n * cell (var (Witness 6, Curr))\n + field\n \"0x000000000000000000000000000000000000000000000000000000000000000B\"\n )\n * cell (var (Witness 6, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB20FFFFFFFB\"\n )\n * cell (var (Witness 6, Curr)) )\n + alpha_pow 4\n * ( ( ( ( cell (var (Witness 7, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB20FFFFFFFB\"\n )\n * cell (var (Witness 7, Curr))\n + field\n \"0x000000000000000000000000000000000000000000000000000000000000000B\"\n )\n * cell (var (Witness 7, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB20FFFFFFFB\"\n )\n * cell (var (Witness 7, Curr)) )\n + alpha_pow 5\n * ( ( ( ( cell (var (Witness 8, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB20FFFFFFFB\"\n )\n * cell (var (Witness 8, Curr))\n + field\n \"0x000000000000000000000000000000000000000000000000000000000000000B\"\n )\n * cell (var (Witness 8, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB20FFFFFFFB\"\n )\n * cell (var (Witness 8, Curr)) )\n + alpha_pow 6\n * ( ( ( ( cell (var (Witness 9, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB20FFFFFFFB\"\n )\n * cell (var (Witness 9, Curr))\n + field\n \"0x000000000000000000000000000000000000000000000000000000000000000B\"\n )\n * cell (var (Witness 9, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB20FFFFFFFB\"\n )\n * cell (var (Witness 9, Curr)) )\n + alpha_pow 7\n * ( ( ( ( cell (var (Witness 10, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB20FFFFFFFB\"\n )\n * cell (var (Witness 10, Curr))\n + field\n \"0x000000000000000000000000000000000000000000000000000000000000000B\"\n )\n * cell (var (Witness 10, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB20FFFFFFFB\"\n )\n * cell (var (Witness 10, Curr)) )\n + alpha_pow 8\n * ( ( ( ( cell (var (Witness 11, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB20FFFFFFFB\"\n )\n * cell (var (Witness 11, Curr))\n + field\n \"0x000000000000000000000000000000000000000000000000000000000000000B\"\n )\n * cell (var (Witness 11, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB20FFFFFFFB\"\n )\n * cell (var (Witness 11, Curr)) )\n + alpha_pow 9\n * ( ( ( ( cell (var (Witness 12, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB20FFFFFFFB\"\n )\n * cell (var (Witness 12, Curr))\n + field\n \"0x000000000000000000000000000000000000000000000000000000000000000B\"\n )\n * cell (var (Witness 12, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB20FFFFFFFB\"\n )\n * cell (var (Witness 12, Curr)) )\n + alpha_pow 10\n * ( ( ( ( cell (var (Witness 13, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB20FFFFFFFB\"\n )\n * cell (var (Witness 13, Curr))\n + field\n \"0x000000000000000000000000000000000000000000000000000000000000000B\"\n )\n * cell (var (Witness 13, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB20FFFFFFFB\"\n )\n * cell (var (Witness 13, Curr)) ) )\n + cell (var (Index Generic, Curr))\n * ( (cell (var (Coefficient 0, Curr)) * cell (var (Witness 0, Curr)))\n + (cell (var (Coefficient 1, Curr)) * cell (var (Witness 1, Curr)))\n + (cell (var (Coefficient 2, Curr)) * cell (var (Witness 2, Curr)))\n + cell (var (Coefficient 3, Curr))\n * cell (var (Witness 0, Curr))\n * cell (var (Witness 1, Curr))\n + cell (var (Coefficient 4, Curr))\n + alpha_pow 1\n * ( (cell (var (Coefficient 5, Curr)) * cell (var (Witness 3, Curr)))\n + (cell (var (Coefficient 6, Curr)) * cell (var (Witness 4, Curr)))\n + (cell (var (Coefficient 7, Curr)) * cell (var (Witness 5, Curr)))\n + cell (var (Coefficient 8, Curr))\n * cell (var (Witness 3, Curr))\n * cell (var (Witness 4, Curr))\n + cell (var (Coefficient 9, Curr)) ) )\n\n let index_terms (type a) (_ : a Env.t) = Column.Table.of_alist_exn []\nend\n","let commit_id = \"[DIRTY]1dc5c5bb2611b6cbfec4e231334ab6fb453b4b82\"\nlet commit_id_short = \"1dc5c5bb\"\nlet branch = \"dannywillems/add-runtime-table-cfg-to-prover-index-creation\"\nlet commit_date = \"2023-08-01T15:04:28+02:00\"\nlet marlin_commit_id = \"b0a3cb250b303791652fcab6e4a48db9e539f508\"\nlet marlin_commit_id_short = \"b0a3cb25\"\nlet marlin_commit_date = \"2023-07-26T21:20:12+01:00\"\nlet print_version () = Core_kernel.printf \"Commit %s on branch %s\\n%!\" commit_id branch\n","(* base58_check.ml : implement Base58Check algorithm\n see: https://www.oreilly.com/library/view/mastering-bitcoin-2nd/9781491954379/ch04.html#base58\n also: https://datatracker.ietf.org/doc/html/draft-msporny-base58-03\n\n the algorithm is modified for long strings, to apply encoding on chunks of the input\n*)\n\nopen Core_kernel\n\nexception Invalid_base58_checksum of string\n\nexception Invalid_base58_version_byte of (char * string)\n\nexception Invalid_base58_check_length of string\n\nexception Invalid_base58_character of string\n\n(* same as Bitcoin alphabet *)\nlet mina_alphabet =\n B58.make_alphabet \"123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz\"\n\nlet version_len = 1\n\nlet checksum_len = 4\n\nmodule Make (M : sig\n val description : string\n\n val version_byte : char\nend) =\nstruct\n let version_byte = M.version_byte\n\n let version_string = String.make 1 version_byte\n\n let max_length = 8192\n\n let compute_checksum payload =\n (* double-hash using SHA256 *)\n let open Digestif.SHA256 in\n let ctx0 = init () in\n let ctx1 = feed_string ctx0 version_string in\n let ctx2 = feed_string ctx1 payload in\n let first_hash = get ctx2 |> to_raw_string in\n let ctx3 = feed_string ctx0 first_hash in\n let second_hash = get ctx3 |> to_raw_string in\n second_hash |> String.sub ~pos:0 ~len:checksum_len\n\n (* we don't name this with _exn, we don't expect to raise an exception\n if we do, we're encoding types that shouldn't be encoded\n *)\n let encode payload =\n let len = String.length payload in\n if len > max_length then\n failwithf\n \"String is too long (%d bytes) to Base58Check-encode, max length is %d\"\n len max_length () ;\n let checksum = compute_checksum payload in\n let bytes = version_string ^ payload ^ checksum |> Bytes.of_string in\n B58.encode mina_alphabet bytes |> Bytes.to_string\n\n let decode_exn s =\n let bytes = Bytes.of_string s in\n let decoded =\n try B58.decode mina_alphabet bytes |> Bytes.to_string\n with B58.Invalid_base58_character ->\n raise (Invalid_base58_character M.description)\n in\n let len = String.length decoded in\n (* input must be at least as long as the version byte and checksum *)\n if len < version_len + checksum_len then\n raise (Invalid_base58_check_length M.description) ;\n let checksum =\n String.sub decoded\n ~pos:(String.length decoded - checksum_len)\n ~len:checksum_len\n in\n let payload =\n String.sub decoded ~pos:1 ~len:(len - version_len - checksum_len)\n in\n if not (String.equal checksum (compute_checksum payload)) then\n raise (Invalid_base58_checksum M.description) ;\n if not (Char.equal decoded.[0] version_byte) then\n raise (Invalid_base58_version_byte (decoded.[0], M.description)) ;\n payload\n\n let decode s =\n let error_str e desc =\n sprintf \"Error decoding %s\\nInvalid base58 %s in %s\" s e desc\n in\n try Ok (decode_exn s) with\n | Invalid_base58_character str ->\n Or_error.error_string (error_str \"character\" str)\n | Invalid_base58_check_length str ->\n Or_error.error_string (error_str \"check length\" str)\n | Invalid_base58_checksum str ->\n Or_error.error_string (error_str \"checksum\" str)\n | Invalid_base58_version_byte (ch, str) ->\n Or_error.error_string\n (error_str\n (sprintf \"version byte \\\\x%02X, expected \\\\x%02X\" (Char.to_int ch)\n (Char.to_int version_byte) )\n str )\nend\n\nmodule Version_bytes = Version_bytes\n\nlet%test_module \"base58check tests\" =\n ( module struct\n module Base58_check = Make (struct\n let description = \"Base58check tests\"\n\n let version_byte = '\\x53'\n end)\n\n open Base58_check\n\n let test_roundtrip payload =\n let encoded = encode payload in\n let payload' = decode_exn encoded in\n String.equal payload payload'\n\n let%test \"empty_string\" = test_roundtrip \"\"\n\n let%test \"nonempty_string\" =\n test_roundtrip \"Somewhere, over the rainbow, way up high\"\n\n let%test \"longer_string\" =\n test_roundtrip\n \"Someday, I wish upon a star, wake up where the clouds are far behind \\\n me, where trouble melts like lemon drops, High above the chimney top, \\\n that's where you'll find me\"\n\n let%test \"invalid checksum\" =\n try\n let encoded = encode \"Bluer than velvet were her eyes\" in\n let bytes = Bytes.of_string encoded in\n let len = Bytes.length bytes in\n let last_ch = Bytes.get bytes (len - 1) in\n (* change last byte to invalidate checksum *)\n let new_last_ch =\n if Char.equal last_ch '\\xFF' then '\\x00'\n else Char.of_int_exn (Char.to_int last_ch + 1)\n in\n Bytes.set bytes (len - 1) new_last_ch ;\n let encoded_bad_checksum = Bytes.to_string bytes in\n let _payload = decode_exn encoded_bad_checksum in\n false\n with Invalid_base58_checksum _ -> true\n\n let%test \"invalid length\" =\n try\n let _payload = decode_exn \"abcd\" in\n false\n with Invalid_base58_check_length _ -> true\n end )\n","module Field_intf = struct\n module type Basic = sig\n type t\n\n val ( * ) : t -> t -> t\n\n val ( + ) : t -> t -> t\n\n val ( - ) : t -> t -> t\n\n val inv_exn : t -> t\n\n val negate : t -> t\n\n val square : t -> t\n end\n\n module type Constant = sig\n include Basic\n end\n\n module type Checked = sig\n type field\n\n type bool\n\n include Basic\n\n val if_ : bool -> then_:t -> else_:t -> t\n\n val scale : t -> field -> t\n end\nend\n\nmodule type Constant_intf = sig\n type field\n\n type t\n\n val random : unit -> t\n\n val to_affine_exn : t -> field * field\n\n val of_affine : field * field -> t\n\n val ( + ) : t -> t -> t\n\n val negate : t -> t\nend\n\nmodule type Inputs_intf = sig\n module Impl : Snarky_backendless.Snark_intf.Run\n\n module F : sig\n include\n Field_intf.Checked\n with type bool := Impl.Boolean.var\n and type field := Impl.field\n\n module Constant : Field_intf.Constant\n\n val assert_square : t -> t -> unit\n\n val assert_r1cs : t -> t -> t -> unit\n\n val typ : (t, Constant.t) Impl.Typ.t\n\n val constant : Constant.t -> t\n end\n\n module Constant : Constant_intf with type field := F.Constant.t\n\n module Params : sig\n val one : F.Constant.t * F.Constant.t\n\n val group_size_in_bits : int\n\n val a : F.Constant.t\n\n val b : F.Constant.t\n end\nend\n\nmodule Make_checked (Inputs : Inputs_intf) = struct\n open Inputs\n open Impl\n\n type t = F.t * F.t\n\n let double ((ax, ay) : t) : t =\n let open F in\n (* A: 1\n B: 1\n C: 1 *)\n let x_squared = square ax in\n let lambda =\n exists typ\n ~compute:\n As_prover.(\n fun () ->\n let x_squared = read typ x_squared in\n let ay = read typ ay in\n let open F.Constant in\n (x_squared + x_squared + x_squared + Params.a) * inv_exn (ay + ay))\n in\n let bx =\n exists typ\n ~compute:\n As_prover.(\n fun () ->\n let lambda = read typ lambda in\n let ax = read typ ax in\n let open F.Constant in\n square lambda - (ax + ax))\n in\n let by =\n exists typ\n ~compute:\n As_prover.(\n fun () ->\n let lambda = read typ lambda\n and ax = read typ ax\n and ay = read typ ay\n and bx = read typ bx in\n F.Constant.((lambda * (ax - bx)) - ay))\n in\n let two = Field.Constant.of_int 2 in\n (* A: 1\n B: 1\n C: 2 *)\n assert_r1cs (F.scale lambda two) ay\n (F.scale x_squared (Field.Constant.of_int 3) + F.constant Params.a) ;\n (* A: 1\n B: 1\n C: 2\n *)\n assert_square lambda (bx + F.scale ax two) ;\n (* A: 1\n B: 2\n C: 2\n *)\n assert_r1cs lambda (ax - bx) (by + ay) ;\n (* Overall:\n A: 4\n B: 5\n C: 7 *)\n (bx, by)\n\n let add' ~div (ax, ay) (bx, by) : t =\n let open F in\n (*\n lambda * (bx - ax) = (by - ay)\n\n A: 1\n B: 2\n C: 2\n *)\n let lambda = div (by - ay) (bx - ax) in\n let cx =\n exists typ\n ~compute:\n As_prover.(\n fun () ->\n let ax = read typ ax\n and bx = read typ bx\n and lambda = read typ lambda in\n Constant.(square lambda - (ax + bx)))\n in\n\n (* lambda^2 = cx + ax + bx\n\n A: 1\n B: 1\n C: 3\n *)\n assert_square lambda F.(cx + ax + bx) ;\n let cy =\n exists typ\n ~compute:\n As_prover.(\n fun () ->\n let ax = read typ ax\n and ay = read typ ay\n and cx = read typ cx\n and lambda = read typ lambda in\n Constant.((lambda * (ax - cx)) - ay))\n in\n (* A: 1\n B: 2\n C: 2 *)\n assert_r1cs lambda (ax - cx) (cy + ay) ;\n (* Overall\n A: 2\n B: 5\n C: 7 *)\n (cx, cy)\n\n let add_exn p q = add' ~div:(fun x y -> F.(inv_exn y * x)) p q\n\n let to_affine_exn x = x\n\n let constant t =\n let x, y = Constant.to_affine_exn t in\n (F.constant x, F.constant y)\n\n let negate (x, y) = (x, F.negate y)\n\n let one =\n let x, y = Params.one in\n F.(constant x, constant y)\n\n let assert_on_curve (x, y) =\n let open F in\n let x2 = square x in\n let x3 = x2 * x in\n let ax = constant Params.a * x in\n assert_square y (x3 + ax + constant Params.b)\n\n let typ_unchecked : (t, Constant.t) Typ.t =\n Typ.transport\n Typ.(tuple2 F.typ F.typ)\n ~there:Constant.to_affine_exn ~back:Constant.of_affine\n\n let typ : (t, Constant.t) Typ.t =\n let (Typ typ_unchecked) = typ_unchecked in\n Typ\n { typ_unchecked with\n check = (fun t -> Impl.make_checked (fun () -> assert_on_curve t))\n }\n\n let if_ c ~then_:(tx, ty) ~else_:(ex, ey) =\n (F.if_ c ~then_:tx ~else_:ex, F.if_ c ~then_:ty ~else_:ey)\n\n open Bitstring_lib.Bitstring\n\n module Scalar = struct\n type t = Boolean.var Lsb_first.t\n\n let of_field = Field.unpack_full\n\n let to_field t = Field.project (Lsb_first.to_list t)\n end\n\n module type Shifted_intf = sig\n type t\n\n val zero : t\n\n val unshift_nonzero : t -> F.t * F.t\n\n val add : t -> F.t * F.t -> t\n\n val if_ : Boolean.var -> then_:t -> else_:t -> t\n end\n\n module Shifted (M : sig\n val shift : t\n end)\n () : Shifted_intf = struct\n type t = F.t * F.t\n\n let zero = M.shift\n\n let unshift_nonzero t = add_exn t (negate M.shift)\n\n let add t pt = add_exn t pt\n\n let if_ = if_\n end\n\n let shifted () =\n let shift = exists typ ~compute:(fun () -> Constant.random ()) in\n let module S =\n Shifted\n (struct\n let shift = shift\n end)\n ()\n in\n (module S : Shifted_intf)\n\n (* This doesn't have great performance because it uses add_exn. Should be optimized *)\n let scale ?init t (c : Boolean.var Bitstring_lib.Bitstring.Lsb_first.t) =\n let (module S) = shifted () in\n let c = Bitstring_lib.Bitstring.Lsb_first.to_list c in\n let rec go i bs0 acc pt =\n match bs0 with\n | [] ->\n acc\n | b :: bs ->\n let acc' =\n let add_pt = S.add acc pt in\n let don't_add_pt = acc in\n S.if_ b ~then_:add_pt ~else_:don't_add_pt\n and pt' = double pt in\n go (i + 1) bs acc' pt'\n in\n let init =\n match init with None -> S.zero | Some init -> S.(add zero init)\n in\n S.unshift_nonzero (go 0 c init t)\nend\n\nmodule type Native_base_field_inputs = sig\n (** Snarky instance to use. *)\n module Impl : Snarky_backendless.Snark_intf.Run\n\n include\n Inputs_intf\n with module Impl := Impl\n and type F.t = Impl.Field.t\n and type F.Constant.t = Impl.field\nend\n\nmodule For_native_base_field (Inputs : Native_base_field_inputs) = struct\n open Core_kernel\n open Inputs\n open Impl\n include Make_checked (Inputs)\n\n module Window_table = struct\n open Tuple_lib\n\n type t = Constant.t Quadruple.t array\n\n let window_size = 2\n\n let windows = (Params.group_size_in_bits + window_size - 1) / window_size\n\n let shift_left_by_window_size =\n let rec go i acc =\n if i = 0 then acc else go (i - 1) Constant.(acc + acc)\n in\n go window_size\n\n (* (create g).(i) = ( unrelated_base^i + 2^{window_size*i} 0 g, unrelated_base^i + 2^{window_size*i} g, unrelated_base^i + 2^{window_size*i} (2 g), unrelated_base^i + 2^{window_size*i} (3 g) ) *)\n let create ~shifts g =\n let pure_windows =\n (* pure_windows.(i) = 2^{window_size * i} ( g, 2 g, 3 g) *)\n let w0 =\n let g2 = Constant.(g + g) in\n let g3 = Constant.(g2 + g) in\n (g, g2, g3)\n in\n let a = Array.init windows ~f:(fun _ -> w0) in\n for i = 1 to windows - 1 do\n a.(i) <- Triple.map ~f:shift_left_by_window_size a.(i - 1)\n done ;\n a\n in\n Array.mapi pure_windows ~f:(fun i (a, b, c) ->\n let shift = shifts.(i) in\n Constant.(shift, shift + a, shift + b, shift + c) )\n end\n\n let pow2s g =\n let n = Window_table.windows + 1 in\n assert (n < Params.group_size_in_bits) ;\n let a = Array.init n ~f:(fun _ -> g) in\n for i = 1 to n - 1 do\n let x = a.(i - 1) in\n a.(i) <- Constant.(x + x)\n done ;\n a\n\n module Scaling_precomputation = struct\n type t =\n { base : Constant.t; shifts : Constant.t array; table : Window_table.t }\n\n let group_map =\n lazy\n (let params =\n Group_map.Params.create (module Field.Constant) Params.{ a; b }\n in\n Group_map.to_group (module Field.Constant) ~params )\n\n let string_to_bits s =\n List.concat_map (String.to_list s) ~f:(fun c ->\n let c = Char.to_int c in\n List.init 8 ~f:(fun i -> (c lsr i) land 1 = 1) )\n\n let create base =\n let unrelated_base =\n let x, y = Constant.to_affine_exn base in\n Digestif.BLAKE2S.digest_string\n Field.Constant.(to_string x ^ \",\" ^ to_string y)\n |> Digestif.BLAKE2S.to_raw_string |> string_to_bits\n |> Field.Constant.project |> Lazy.force group_map |> Constant.of_affine\n in\n let shifts = pow2s unrelated_base in\n { base; shifts; table = Window_table.create ~shifts base }\n end\n\n let add_unsafe =\n let div_unsafe x y =\n let z =\n exists Field.typ\n ~compute:\n As_prover.(fun () -> Field.Constant.( / ) (read_var x) (read_var y))\n in\n (* z = x / y <=> z * y = x *)\n assert_r1cs z y x ; z\n in\n add' ~div:div_unsafe\n\n let lookup_point (b0, b1) (t1, t2, t3, t4) =\n let b0_and_b1 = Boolean.( && ) b0 b1 in\n let lookup_one (a1, a2, a3, a4) =\n let open Field.Constant in\n let ( * ) x b = F.scale b x in\n let ( +^ ) = Field.( + ) in\n F.constant a1\n +^ ((a2 - a1) * (b0 :> Field.t))\n +^ ((a3 - a1) * (b1 :> Field.t))\n +^ ((a4 + a1 - a2 - a3) * (b0_and_b1 :> Field.t))\n in\n let x1, y1 = Constant.to_affine_exn t1\n and x2, y2 = Constant.to_affine_exn t2\n and x3, y3 = Constant.to_affine_exn t3\n and x4, y4 = Constant.to_affine_exn t4 in\n (* This is optimized for Marlin-style constraints. *)\n let seal a =\n let a' = exists Field.typ ~compute:(fun () -> As_prover.read_var a) in\n Field.Assert.equal a a' ; a'\n in\n (seal (lookup_one (x1, x2, x3, x4)), seal (lookup_one (y1, y2, y3, y4)))\n\n let rec pairs = function\n | [] ->\n []\n | x :: y :: xs ->\n (x, y) :: pairs xs\n | [ x ] ->\n [ (x, Boolean.false_) ]\n\n type shifted = { value : t; shift : Constant.t }\n\n let scale_known (pc : Scaling_precomputation.t) bs =\n let bs =\n let bs = Array.of_list bs in\n let num_bits = Array.length bs in\n Array.init\n ((Array.length bs + 1) / 2)\n ~f:(fun i ->\n let get j = if j < num_bits then bs.(j) else Boolean.false_ in\n (get (2 * i), get ((2 * i) + 1)) )\n in\n let windows_required = Array.length bs in\n let terms =\n Array.mapi bs ~f:(fun i bit_pair -> lookup_point bit_pair pc.table.(i))\n in\n let with_shifts = Array.reduce_exn terms ~f:add_unsafe in\n let shift =\n let unrelated_base = pc.shifts.(0) in\n\n (*\n 0b1111... * unrelated_base = (2^windows_required - 1) * unrelated_base\n\n is what we added and need to take away for the final result. *)\n Constant.(pc.shifts.(windows_required) + negate unrelated_base)\n in\n { value = with_shifts; shift }\n\n let unshift { value; shift } =\n add_exn value (constant (Constant.negate shift))\n\n let multiscale_known pairs =\n Array.map pairs ~f:(fun (s, g) -> scale_known g s)\n |> Array.reduce_exn ~f:(fun t1 t2 ->\n { value = add_exn t1.value t2.value\n ; shift = Constant.(t1.shift + t2.shift)\n } )\n |> unshift\n\n let scale_known pc bs = unshift (scale_known pc bs)\n\n (* b ? t : -t *)\n let conditional_negation (b : Boolean.var) (x, y) =\n let y' =\n exists Field.typ\n ~compute:\n As_prover.(\n fun () ->\n if read Boolean.typ b then read Field.typ y\n else Field.Constant.negate (read Field.typ y))\n in\n assert_r1cs y Field.((of_int 2 * (b :> Field.t)) - of_int 1) y' ;\n (x, y')\n\n let p_plus_q_plus_p ((x1, y1) : t) ((x2, y2) : t) =\n let open Field in\n let ( ! ) = As_prover.read typ in\n let lambda_1 =\n exists typ ~compute:Constant.(fun () -> (!y2 - !y1) / (!x2 - !x1))\n in\n let x3 =\n exists typ\n ~compute:Constant.(fun () -> (!lambda_1 * !lambda_1) - !x1 - !x2)\n in\n let lambda_2 =\n exists typ\n ~compute:Constant.(fun () -> (of_int 2 * !y1 / (!x1 - !x3)) - !lambda_1)\n in\n let x4 =\n exists typ\n ~compute:Constant.(fun () -> (!lambda_2 * !lambda_2) - !x3 - !x1)\n in\n let y4 =\n exists typ ~compute:Constant.(fun () -> ((!x1 - !x4) * !lambda_2) - !y1)\n in\n (* Determines lambda_1 *)\n assert_r1cs (x2 - x1) lambda_1 (y2 - y1) ;\n (* Determines x_3 *)\n assert_square lambda_1 (x1 + x2 + x3) ;\n (* Determines lambda_2 *)\n assert_r1cs (x1 - x3) (lambda_1 + lambda_2) (of_int 2 * y1) ;\n (* Determines x4 *)\n assert_square lambda_2 (x3 + x1 + x4) ;\n (* Determines y4 *)\n assert_r1cs (x1 - x4) lambda_2 (y4 + y1) ;\n (x4, y4)\n\n (* Input:\n t, r (LSB)\n\n Output:\n (2*r + 1 + 2^len(r)) t\n *)\n let scale_fast (t : Field.t * Field.t) (`Times_two_plus_1_plus_2_to_len r) :\n Field.t * Field.t =\n let n = Array.length r in\n let acc = ref (double t) in\n let () =\n for i = 0 to n - 1 do\n let q = conditional_negation r.(i) t in\n acc := p_plus_q_plus_p !acc q\n done\n in\n !acc\n\n (* Input:\n t, k (LSB)\n\n Output:\n (k + 2^{len(k) - 1}) t\n\n Based on [Daira's algorithm](https://github.com/zcash/zcash/issues/3924)\n *)\n let scale_fast t (`Plus_two_to_len_minus_1 k) =\n let m = Array.length k - 1 in\n let r = Array.init m ~f:(fun i -> k.(i + 1)) in\n let two_r_plus_1_plus_two_to_m =\n scale_fast t (`Times_two_plus_1_plus_2_to_len r)\n in\n if_ k.(0) ~then_:two_r_plus_1_plus_two_to_m\n ~else_:(add_exn two_r_plus_1_plus_two_to_m (negate t))\n\n let%test_unit \"scale_fast\" =\n let scale_constant (t, bs) =\n let rec go acc bs =\n match bs with\n | [] ->\n acc\n | b :: bs ->\n let acc = Constant.(acc + acc) in\n let acc = if b then Constant.(acc + t) else acc in\n go acc bs\n in\n let k = Array.length bs in\n go Constant.(t + negate t) (List.init k ~f:(fun i -> bs.(k - 1 - i)))\n in\n let module A = struct\n type t = Impl.Field.Constant.t * Impl.Field.Constant.t\n [@@deriving sexp, compare]\n end in\n let one = Constant.of_affine Params.one in\n [%test_eq: A.t]\n (Constant.to_affine_exn Constant.(one + negate one + one))\n Constant.(to_affine_exn one) ;\n [%test_eq: A.t]\n (Constant.to_affine_exn (scale_constant (one, [| true |])))\n Constant.(to_affine_exn one) ;\n [%test_eq: A.t]\n (Constant.to_affine_exn (scale_constant (one, [| false; true |])))\n Constant.(to_affine_exn (one + one)) ;\n [%test_eq: A.t]\n (Constant.to_affine_exn (scale_constant (one, [| true; true |])))\n Constant.(to_affine_exn (one + one + one)) ;\n [%test_eq: A.t]\n (Constant.to_affine_exn (scale_constant (one, [| false; false; true |])))\n Constant.(to_affine_exn (one + one + one + one)) ;\n [%test_eq: A.t]\n (Constant.to_affine_exn (scale_constant (one, [| true; false; true |])))\n Constant.(to_affine_exn (one + one + one + one + one)) ;\n let g = Typ.tuple2 Field.typ Field.typ in\n let two_to_the m =\n scale_constant (one, Array.init (m + 1) ~f:(fun i -> i = m))\n in\n [%test_eq: A.t]\n (Constant.to_affine_exn (two_to_the 2))\n Constant.(to_affine_exn (one + one + one + one)) ;\n let n = 4 in\n let bits = Array.init n ~f:(fun _ -> Random.bool ()) in\n Internal_Basic.Test.test_equal\n ~equal:[%eq: Field.Constant.t * Field.Constant.t]\n ~sexp_of_t:[%sexp_of: Field.Constant.t * Field.Constant.t]\n (Typ.tuple2 g (Typ.array ~length:n Boolean.typ))\n g\n (fun (t, bs) ->\n make_checked (fun () -> scale_fast t (`Plus_two_to_len_minus_1 bs)) )\n (fun (t, bs) ->\n let open Constant in\n let t = of_affine t in\n to_affine_exn (scale_constant (t, bs) + two_to_the (n - 1)) )\n (Params.one, bits)\nend\n","open Core_kernel\n\n(** The string that preceeds the JSON header, to identify the file kind before\n attempting to parse it.\n*)\nlet header_string = \"MINA_SNARK_KEYS\\n\"\n\nmodule UInt64 = struct\n (* [Unsigned_extended] depends on pickles, manually include what we need here\n to break a dependency cycle\n\n TODO: Separate [Unsigned_extended] into snark and non-snark parts.\n *)\n type t = Unsigned.UInt64.t [@@deriving ord, equal]\n\n let to_yojson x = `String (Unsigned.UInt64.to_string x)\n\n let of_yojson = function\n | `String x ->\n Or_error.try_with (fun () -> Unsigned.UInt64.of_string x)\n |> Result.map_error ~f:(fun err ->\n sprintf\n \"Snark_keys_header.UInt64.of_yojson: Could not parse string \\\n as UInt64: %s\"\n (Error.to_string_hum err) )\n | _ ->\n Error \"Snark_keys_header.UInt64.of_yojson: Expected a string\"\n\n let sexp_of_t x = Sexp.Atom (Unsigned.UInt64.to_string x)\n\n let t_of_sexp = function\n | Sexp.Atom x ->\n Unsigned.UInt64.of_string x\n | _ ->\n failwith \"Snark_keys_header.UInt64.t_of_sexp: Expected an atom\"\nend\n\nmodule Kind = struct\n (** The 'kind' of data in the file.\n For example, a step proving key for the base transaction snark may have the\n kind:\n{[\n {type_= \"step_proving_key\"; identifier= \"transaction_snark_base\"}\n|}\n *)\n type t =\n { type_ : string [@key \"type\"]\n (** Identifies the type of data that the file contains *)\n ; identifier : string\n (** Identifies the specific purpose of the file's data, in a\n human-readable format\n *)\n }\n [@@deriving yojson, sexp, ord, equal]\nend\n\nmodule Constraint_constants = struct\n module Transaction_capacity = struct\n (** Transaction pool capacity *)\n type t = Log_2 of int | Txns_per_second_x10 of int\n [@@deriving sexp, ord, equal]\n\n let to_yojson t : Yojson.Safe.t =\n match t with\n | Log_2 i ->\n `Assoc [ (\"two_to_the\", `Int i) ]\n | Txns_per_second_x10 i ->\n `Assoc [ (\"txns_per_second_x10\", `Int i) ]\n\n let of_yojson (json : Yojson.Safe.t) =\n match json with\n | `Assoc [ (\"two_to_the\", `Int i) ] ->\n Ok (Log_2 i)\n | `Assoc [ (\"txns_per_second_x10\", `Int i) ] ->\n Ok (Txns_per_second_x10 i)\n | `Assoc _ ->\n Error\n \"Snark_keys_header.Constraint_constants.Transaction_capacity.of_yojson: \\\n Expected a JSON object containing the field 'two_to_the' or \\\n 'txns_per_second_x10'\"\n | _ ->\n Error\n \"Snark_keys_header.Constraint_constants.Transaction_capacity.of_yojson: \\\n Expected a JSON object\"\n end\n\n module Fork_config = struct\n (** Fork data *)\n type t =\n { previous_state_hash : string\n ; previous_length : int\n ; previous_global_slot : int\n }\n [@@deriving yojson, sexp, ord, equal]\n\n let opt_to_yojson t : Yojson.Safe.t =\n match t with Some t -> to_yojson t | None -> `Assoc []\n\n let opt_of_yojson (json : Yojson.Safe.t) =\n match json with\n | `Assoc [] ->\n Ok None\n | _ ->\n Result.map (of_yojson json) ~f:(fun t -> Some t)\n end\n\n (** The constants used in the constraint system. *)\n type t =\n { sub_windows_per_window : int\n ; ledger_depth : int\n ; work_delay : int\n ; block_window_duration_ms : int\n ; transaction_capacity : Transaction_capacity.t\n ; pending_coinbase_depth : int\n ; coinbase_amount : UInt64.t\n ; supercharged_coinbase_factor : int\n ; account_creation_fee : UInt64.t\n ; fork :\n (Fork_config.t option\n [@to_yojson Fork_config.opt_to_yojson]\n [@of_yojson Fork_config.opt_of_yojson] )\n }\n [@@deriving yojson, sexp, ord, equal]\nend\n\nmodule Commits = struct\n (** Commit identifiers *)\n type t = { mina : string; marlin : string }\n [@@deriving yojson, sexp, ord, equal]\nend\n\nlet header_version = 1\n\n(** Header contents *)\ntype t =\n { header_version : int\n ; kind : Kind.t\n ; constraint_constants : Constraint_constants.t\n ; commits : Commits.t\n ; length : int\n ; commit_date : string\n ; constraint_system_hash : string\n ; identifying_hash : string\n }\n[@@deriving yojson, sexp, ord, equal]\n\nlet prefix = \"MINA_SNARK_KEYS\\n\"\n\nlet prefix_len = String.length prefix\n\nlet parse_prefix (lexbuf : Lexing.lexbuf) =\n let open Or_error.Let_syntax in\n Result.map_error ~f:(fun err ->\n Error.tag_arg err \"Could not read prefix\" (\"prefix\", prefix)\n [%sexp_of: string * string] )\n @@ Or_error.try_with_join (fun () ->\n (* This roughly mirrors the behavior of [Yojson.Safe.read_ident],\n except that we have a known fixed length to parse, and that it is a\n failure to read any string except the prefix. We manually update\n the lexbuf to be consistent with the output of this function.\n *)\n (* Manually step the lexbuffer forward to the [lex_curr_pos], so that\n [refill_buf] will know that we're only interested in buffer\n contents from that position onwards.\n *)\n lexbuf.lex_start_pos <- lexbuf.lex_curr_pos ;\n lexbuf.lex_last_pos <- lexbuf.lex_curr_pos ;\n lexbuf.lex_start_p <- lexbuf.lex_curr_p ;\n let%bind () =\n (* Read more if the buffer doesn't contain the whole prefix. *)\n if lexbuf.lex_buffer_len - lexbuf.lex_curr_pos >= prefix_len then\n return ()\n else if lexbuf.lex_eof_reached then\n Or_error.error_string \"Unexpected end-of-file\"\n else (\n lexbuf.refill_buff lexbuf ;\n if lexbuf.lex_buffer_len - lexbuf.lex_curr_pos >= prefix_len then\n return ()\n else if lexbuf.lex_eof_reached then\n Or_error.error_string \"Unexpected end-of-file\"\n else\n Or_error.error_string\n \"Unexpected short read: broken lexbuffer or end-of-file\" )\n in\n let read_prefix =\n Lexing.sub_lexeme lexbuf lexbuf.lex_curr_pos\n (lexbuf.lex_curr_pos + prefix_len)\n in\n let%map () =\n if String.equal prefix read_prefix then return ()\n else\n Or_error.error \"Incorrect prefix\"\n (\"read prefix\", read_prefix)\n [%sexp_of: string * string]\n in\n (* Update the positions to match our end state *)\n lexbuf.lex_curr_pos <- lexbuf.lex_curr_pos + prefix_len ;\n lexbuf.lex_last_pos <- lexbuf.lex_last_pos ;\n lexbuf.lex_curr_p <-\n { lexbuf.lex_curr_p with\n pos_bol = lexbuf.lex_curr_p.pos_bol + prefix_len\n ; pos_cnum = lexbuf.lex_curr_p.pos_cnum + prefix_len\n } ;\n (* This matches the action given by [Yojson.Safe.read_ident]. *)\n lexbuf.lex_last_action <- 1 )\n\nlet parse_lexbuf (lexbuf : Lexing.lexbuf) =\n let open Or_error.Let_syntax in\n Result.map_error ~f:(Error.tag ~tag:\"Failed to read snark key header\")\n @@ let%bind () = parse_prefix lexbuf in\n Or_error.try_with (fun () ->\n let yojson_parsebuffer = Yojson.init_lexer () in\n (* We use [read_t] here rather than one of the alternatives to avoid\n 'greedy' parsing that will attempt to continue and read the file's\n contents beyond the header.\n *)\n Yojson.Safe.read_t yojson_parsebuffer lexbuf )\n\nlet%test_module \"Check parsing of header\" =\n ( module struct\n let valid_header =\n { header_version = 1\n ; kind = { type_ = \"type\"; identifier = \"identifier\" }\n ; constraint_constants =\n { sub_windows_per_window = 4\n ; ledger_depth = 8\n ; work_delay = 1000\n ; block_window_duration_ms = 1000\n ; transaction_capacity = Log_2 3\n ; pending_coinbase_depth = 12\n ; coinbase_amount = Unsigned.UInt64.of_int 1\n ; supercharged_coinbase_factor = 1\n ; account_creation_fee = Unsigned.UInt64.of_int 1\n ; fork = None\n }\n ; commits =\n { mina = \"7e1fb2cd9138af1d0f24e78477efd40a2a0fcd07\"\n ; marlin = \"75836c41fc4947acce9c938da1b2f506843e90ed\"\n }\n ; length = 4096\n ; commit_date = \"2020-01-01 00:00:00.000000Z\"\n ; constraint_system_hash = \"ABCDEF1234567890\"\n ; identifying_hash = \"ABCDEF1234567890\"\n }\n\n let valid_header_string = Yojson.Safe.to_string (to_yojson valid_header)\n\n let valid_header_with_prefix = prefix ^ valid_header_string\n\n module Tests (Lexing : sig\n val from_string : ?with_positions:bool -> string -> Lexing.lexbuf\n end) =\n struct\n let%test \"doesn't parse without prefix\" =\n parse_lexbuf (Lexing.from_string valid_header_string)\n |> Or_error.is_error\n\n let%test \"doesn't parse with incorrect prefix\" =\n parse_lexbuf (Lexing.from_string (\"BLAH\" ^ valid_header_string))\n |> Or_error.is_error\n\n let%test \"doesn't parse with matching-length prefix\" =\n let fake_prefix = String.init prefix_len ~f:(fun _ -> 'a') in\n parse_lexbuf (Lexing.from_string (fake_prefix ^ valid_header_string))\n |> Or_error.is_error\n\n let%test \"doesn't parse with partial matching prefix\" =\n let partial_prefix =\n String.sub prefix ~pos:0 ~len:(prefix_len - 1) ^ \" \"\n in\n parse_lexbuf (Lexing.from_string (partial_prefix ^ valid_header_string))\n |> Or_error.is_error\n\n let%test \"doesn't parse with short file\" =\n parse_lexbuf (Lexing.from_string \"BLAH\") |> Or_error.is_error\n\n let%test \"doesn't parse with prefix only\" =\n parse_lexbuf (Lexing.from_string prefix) |> Or_error.is_error\n\n let%test_unit \"parses valid header with prefix\" =\n parse_lexbuf (Lexing.from_string valid_header_with_prefix)\n |> Or_error.ok_exn |> ignore\n\n let%test_unit \"parses valid header with prefix and data\" =\n parse_lexbuf\n (Lexing.from_string (valid_header_with_prefix ^ \"DATADATADATA\"))\n |> Or_error.ok_exn |> ignore\n end\n\n let%test_module \"Parsing from the start of the lexbuf\" =\n (module Tests (Lexing))\n\n let%test_module \"Parsing from part-way through a lexbuf\" =\n ( module struct\n include Tests (struct\n let from_string ?with_positions:_ str =\n let prefix = \"AAAAAAAAAA\" in\n let prefix_len = String.length prefix in\n let lexbuf = Lexing.from_string (prefix ^ str) in\n lexbuf.lex_start_pos <- 0 ;\n lexbuf.lex_curr_pos <- prefix_len ;\n lexbuf.lex_last_pos <- prefix_len ;\n lexbuf\n end)\n end )\n\n let%test_module \"Parsing with refill\" =\n ( module struct\n include Tests (struct\n let from_string ?with_positions:_ str =\n let init = ref true in\n let initial_prefix = \"AAAAAAAAAA\" in\n let initial_prefix_len = String.length initial_prefix in\n let offset = ref 0 in\n let str_len = String.length str in\n let lexbuf =\n Lexing.from_function (fun buffer length ->\n match !init with\n | true ->\n init := false ;\n (* Initial read: fill with junk up to the first character\n of the actual prefix\n *)\n Bytes.From_string.blit ~src:initial_prefix ~src_pos:0\n ~dst:buffer ~dst_pos:0 ~len:initial_prefix_len ;\n Bytes.set buffer initial_prefix_len str.[0] ;\n offset := 1 ;\n initial_prefix_len + 1\n | false ->\n (* Subsequent read: fill the rest of the buffer. *)\n let len = Int.min length (str_len - !offset) in\n if len = 0 then 0\n else (\n Bytes.From_string.blit ~src:str ~src_pos:!offset\n ~dst:buffer ~dst_pos:0 ~len ;\n offset := !offset + len ;\n len ) )\n in\n (* Load the initial content into the buffer *)\n lexbuf.refill_buff lexbuf ;\n lexbuf.lex_start_pos <- 0 ;\n lexbuf.lex_curr_pos <- initial_prefix_len ;\n lexbuf.lex_last_pos <- initial_prefix_len ;\n lexbuf\n end)\n end )\n end )\n\nlet write_with_header ~expected_max_size_log2 ~append_data header filename =\n (* In order to write the correct length here, we provide the maximum expected\n size and store that in the initial header. Once the data has been written,\n we record the length and then modify the 'length' field to hold the\n correct data.\n Happily, since the header is JSON-encoded, we can pad the calculated\n length with spaces and the header will still form a valid JSON-encoded\n object.\n This intuitively feels hacky, but the only way this can fail are if we are\n not able to write all of our data to the filesystem, or if the file is\n modified during the writing process. In either of these cases, we would\n have the same issue even if we were to pre-compute the length and do the\n write atomically.\n *)\n let length = 1 lsl expected_max_size_log2 in\n if length <= 0 then\n failwith\n \"Snark_keys_header.write_header: expected_max_size_log2 is too large, \\\n the resulting length underflows\" ;\n let header_string =\n Yojson.Safe.to_string (to_yojson { header with length })\n in\n (* We look for the \"length\" field first, to ensure that we find our length\n and not some other data that happens to match it. Due to the\n JSON-encoding, we will only find the first field named \"length\", which is\n the one that we want to modify.\n *)\n let length_offset =\n String.substr_index_exn header_string ~pattern:\"\\\"length\\\":\"\n in\n let length_string = string_of_int length in\n let length_data_offset =\n prefix_len\n + String.substr_index_exn ~pos:length_offset header_string\n ~pattern:length_string\n in\n (* We use [binary=true] to ensure that line endings aren't converted, so that\n files can be used regardless of the operating system that generated them.\n *)\n Out_channel.with_file ~binary:true filename ~f:(fun out_channel ->\n Out_channel.output_string out_channel prefix ;\n Out_channel.output_string out_channel header_string ;\n (* Newline, to allow [head -n 2 path/to/file | tail -n 1] to easily\n extract the header.\n *)\n Out_channel.output_char out_channel '\\n' ) ;\n append_data filename ;\n (* Core doesn't let us open a file without appending or truncating, so we use\n stdlib instead.\n *)\n let out_channel =\n Stdlib.open_out_gen [ Open_wronly; Open_binary ] 0 filename\n in\n let true_length = Out_channel.length out_channel |> Int.of_int64_exn in\n if true_length > length then\n failwith\n \"Snark_keys_header.write_header: 2^expected_max_size_log2 is less than \\\n the true length of the file\" ;\n let true_length_string = string_of_int true_length in\n let true_length_padding =\n String.init\n (String.length length_string - String.length true_length_string)\n ~f:(fun _ -> ' ')\n in\n (* Go to where we wrote the data *)\n Out_channel.seek out_channel (Int64.of_int length_data_offset) ;\n (* Pad with spaces *)\n Out_channel.output_string out_channel true_length_padding ;\n (* Output the true length *)\n Out_channel.output_string out_channel true_length_string ;\n Out_channel.close out_channel\n\nlet read_with_header ~read_data filename =\n let open Or_error.Let_syntax in\n Or_error.try_with_join (fun () ->\n (* We use [binary=true] to ensure that line endings aren't converted. *)\n let in_channel = In_channel.create ~binary:true filename in\n let file_length = In_channel.length in_channel |> Int.of_int64_exn in\n let lexbuf = Lexing.from_channel in_channel in\n let%bind header_json = parse_lexbuf lexbuf in\n let%bind header =\n of_yojson header_json |> Result.map_error ~f:Error.of_string\n in\n let offset = lexbuf.lex_curr_pos in\n let%bind () =\n In_channel.seek in_channel (Int64.of_int offset) ;\n match In_channel.input_char in_channel with\n | Some '\\n' ->\n Ok ()\n | None ->\n Or_error.error_string\n \"Incomplete header: the newline terminator is missing\"\n | Some c ->\n Or_error.error \"Header was not terminated by a newline character\"\n (\"character\", c) [%sexp_of: string * char]\n in\n (* Bump offset for the newline terminator *)\n let offset = offset + 1 in\n In_channel.close in_channel ;\n let%bind () =\n if header.length = file_length then Ok ()\n else\n Or_error.error\n \"Header length didn't match file length. Was the file only \\\n partially downloaded?\"\n ((\"header length\", header.length), (\"file length\", file_length))\n [%sexp_of: (string * int) * (string * int)]\n in\n let%map data = Or_error.try_with (fun () -> read_data ~offset filename) in\n (header, data) )\n","open Base\n\nlet rec sexp_to_yojson (sexp : Sexp.t) : Yojson.Safe.t =\n match sexp with\n | Atom str ->\n `String str\n | List sexps ->\n `List (List.map ~f:sexp_to_yojson sexps)\n\nlet sexp_record_to_yojson (sexp : Sexp.t) : Yojson.Safe.t =\n let fail () =\n failwith\n (Printf.sprintf\n \"sexp_record_to_yojson called on an s-expression with a non-record \\\n structure %s\"\n (Sexp.to_string_hum sexp) )\n in\n match sexp with\n | List fields ->\n `Assoc\n (List.map fields ~f:(function\n | List [ Atom label; value ] ->\n (label, sexp_to_yojson value)\n | _ ->\n fail () ) )\n | _ ->\n fail ()\n\nlet rec sexp_of_yojson (json : Yojson.Safe.t) : (Sexp.t, string) Result.t =\n match json with\n | `String str ->\n Ok (Sexp.Atom str)\n | `List jsons ->\n let rev_sexps =\n List.fold_until ~init:[] jsons ~finish:Result.return\n ~f:(fun sexps json ->\n match sexp_of_yojson json with\n | Ok sexp ->\n Continue (sexp :: sexps)\n | Error str ->\n Stop (Error str) )\n in\n Result.map ~f:(fun l -> Sexp.List (List.rev l)) rev_sexps\n | _ ->\n Error \"Error_json.sexp_of_yojson: Expected a string or a list\"\n\ntype info_data =\n | Sexp of Sexp.t\n | String of string\n | Exn of exn\n | Of_list of int option * int * Yojson.Safe.t\n\n(* Used to encode sub-lists of infos *)\n\ntype info_tag =\n { tag : string; data : Sexp.t option; loc : Source_code_position.t option }\n\ntype 'a info_repr =\n { base : 'a; rev_tags : info_tag list; backtrace : string option }\n\nlet info_repr_to_yojson (info : info_data info_repr) : Yojson.Safe.t =\n let base_pairs =\n match info.base with\n | Sexp sexp ->\n [ (\"sexp\", sexp_to_yojson sexp) ]\n | String str ->\n [ (\"string\", `String str) ]\n | Exn exn ->\n [ ( \"exn_name\"\n , `String Stdlib.Obj.Extension_constructor.(name @@ of_val exn) )\n ; (\"exn\", sexp_to_yojson (Sexplib.Conv.sexp_of_exn exn))\n ]\n | Of_list (Some trunc_after, length, json) ->\n [ (\"multiple\", json)\n ; (\"length\", `Int length)\n ; (\"truncated_after\", `Int trunc_after)\n ]\n | Of_list (None, length, json) ->\n [ (\"multiple\", json); (\"length\", `Int length) ]\n in\n let tags =\n let tag_to_json { tag; data; loc } =\n let jsons =\n match loc with\n | None ->\n []\n | Some loc ->\n [ (\"loc\", `String (Source_code_position.to_string loc)) ]\n in\n let jsons =\n match data with\n | None ->\n jsons\n | Some data ->\n (\"sexp\", sexp_to_yojson data) :: jsons\n in\n `Assoc ((\"tag\", `String tag) :: jsons)\n in\n match info.rev_tags with\n | [] ->\n []\n | _ :: _ ->\n [ (\"tags\", `List (List.rev_map ~f:tag_to_json info.rev_tags)) ]\n in\n let backtrace =\n match info.backtrace with\n | None ->\n []\n | Some backtrace ->\n (* Split backtrace at lines so that it prints nicely in errors *)\n [ ( \"backtrace\"\n , `List\n (List.map ~f:(fun s -> `String s) (String.split_lines backtrace))\n )\n ]\n in\n `Assoc (base_pairs @ tags @ backtrace)\n\n(* NOTE: Could also add a [of_yojson] version for everything except [Exn]\n (which could be converted to [String]), but it's not clear that it would\n ever be useful.\n*)\n\nlet rec info_internal_repr_to_yojson_aux (info : Info.Internal_repr.t)\n (acc : unit info_repr) : info_data info_repr =\n match info with\n | Could_not_construct sexp ->\n { acc with base = Sexp (List [ Atom \"Could_not_construct\"; sexp ]) }\n | Sexp sexp ->\n { acc with base = Sexp sexp }\n | String str ->\n { acc with base = String str }\n | Exn exn ->\n { acc with base = Exn exn }\n | Tag_sexp (tag, sexp, loc) ->\n { acc with\n base = Sexp sexp\n ; rev_tags = { tag; data = None; loc } :: acc.rev_tags\n }\n | Tag_t (tag, info) ->\n info_internal_repr_to_yojson_aux info\n { acc with rev_tags = { tag; data = None; loc = None } :: acc.rev_tags }\n | Tag_arg (tag, data, info) ->\n info_internal_repr_to_yojson_aux info\n { acc with\n rev_tags = { tag; data = Some data; loc = None } :: acc.rev_tags\n }\n | Of_list (trunc_after, infos) ->\n let rec rev_take i acc_len infos acc_infos =\n match (i, infos) with\n | _, [] ->\n (None, acc_len, acc_infos)\n | None, info :: infos ->\n let json_info = info_internal_repr_to_yojson info in\n rev_take i (acc_len + 1) infos (json_info :: acc_infos)\n | Some i, info :: infos ->\n if i > 0 then\n let json_info = info_internal_repr_to_yojson info in\n rev_take\n (Some (i - 1))\n (acc_len + 1) infos (json_info :: acc_infos)\n else (Some acc_len, acc_len + 1 + List.length infos, acc_infos)\n in\n let trunc_after, length, rev_json_infos =\n rev_take trunc_after 0 infos []\n in\n let json_infos = `List (List.rev rev_json_infos) in\n { acc with base = Of_list (trunc_after, length, json_infos) }\n | With_backtrace (info, backtrace) ->\n info_internal_repr_to_yojson_aux info\n { acc with backtrace = Some backtrace }\n\nand info_internal_repr_to_yojson (info : Info.Internal_repr.t) : Yojson.Safe.t =\n info_internal_repr_to_yojson_aux info\n { base = (); rev_tags = []; backtrace = None }\n |> info_repr_to_yojson\n\nlet info_to_yojson (info : Info.t) : Yojson.Safe.t =\n info_internal_repr_to_yojson (Info.Internal_repr.of_info info)\n\nlet error_to_yojson (err : Error.t) : Yojson.Safe.t =\n match info_to_yojson (err :> Info.t) with\n | `Assoc assocs ->\n `Assoc ((\"commit_id\", `String Mina_version.commit_id) :: assocs)\n | json ->\n `Assoc [ (\"commit_id\", `String Mina_version.commit_id); (\"error\", json) ]\n","open Core_kernel\nopen Pickles_types\nmodule Columns = Nat.N15\nmodule Columns_vec = Vector.Vector_15\nmodule Coefficients = Nat.N15\nmodule Coefficients_vec = Vector.Vector_15\nmodule Quotient_polynomial = Nat.N7\nmodule Quotient_polynomial_vec = Vector.Vector_7\nmodule Permuts_minus_1 = Nat.N6\nmodule Permuts_minus_1_vec = Vector.Vector_6\n\n[@@@warning \"-4\"]\n\nmodule Commitments = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t =\n Mina_wire_types.Pickles.Concrete_.Wrap_wire_proof.Commitments.V1.t =\n { w_comm :\n (Backend.Tick.Field.Stable.V1.t * Backend.Tick.Field.Stable.V1.t)\n Columns_vec.Stable.V1.t\n ; z_comm :\n Backend.Tick.Field.Stable.V1.t * Backend.Tick.Field.Stable.V1.t\n ; t_comm :\n (Backend.Tick.Field.Stable.V1.t * Backend.Tick.Field.Stable.V1.t)\n Quotient_polynomial_vec.Stable.V1.t\n }\n [@@deriving compare, sexp, yojson, hash, equal]\n\n [@@@warning \"+4\"]\n\n let to_latest = Fn.id\n end\n end]\n\n let to_kimchi ({ w_comm; z_comm; t_comm } : t) :\n Backend.Tock.Curve.Affine.t Plonk_types.Messages.t =\n { w_comm = Vector.map ~f:(fun x -> [| x |]) w_comm\n ; z_comm = [| z_comm |]\n ; t_comm = Array.map ~f:(fun x -> x) (Vector.to_array t_comm)\n ; lookup = None\n }\n\n let of_kimchi\n ({ w_comm; z_comm; t_comm; lookup = _ } :\n Backend.Tock.Curve.Affine.t Plonk_types.Messages.t ) : t =\n { w_comm = Vector.map ~f:(fun x -> x.(0)) w_comm\n ; z_comm = z_comm.(0)\n ; t_comm = Vector.of_array_and_length_exn t_comm Quotient_polynomial.n\n }\nend\n\n[@@@warning \"-4\"]\n\nmodule Evaluations = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t =\n Mina_wire_types.Pickles.Concrete_.Wrap_wire_proof.Evaluations.V1.t =\n { w :\n (Backend.Tock.Field.Stable.V1.t * Backend.Tock.Field.Stable.V1.t)\n Columns_vec.Stable.V1.t\n ; coefficients :\n (Backend.Tock.Field.Stable.V1.t * Backend.Tock.Field.Stable.V1.t)\n Columns_vec.Stable.V1.t\n ; z : Backend.Tock.Field.Stable.V1.t * Backend.Tock.Field.Stable.V1.t\n ; s :\n (Backend.Tock.Field.Stable.V1.t * Backend.Tock.Field.Stable.V1.t)\n Permuts_minus_1_vec.Stable.V1.t\n ; generic_selector :\n Backend.Tock.Field.Stable.V1.t * Backend.Tock.Field.Stable.V1.t\n ; poseidon_selector :\n Backend.Tock.Field.Stable.V1.t * Backend.Tock.Field.Stable.V1.t\n ; complete_add_selector :\n Backend.Tock.Field.Stable.V1.t * Backend.Tock.Field.Stable.V1.t\n ; mul_selector :\n Backend.Tock.Field.Stable.V1.t * Backend.Tock.Field.Stable.V1.t\n ; emul_selector :\n Backend.Tock.Field.Stable.V1.t * Backend.Tock.Field.Stable.V1.t\n ; endomul_scalar_selector :\n Backend.Tock.Field.Stable.V1.t * Backend.Tock.Field.Stable.V1.t\n }\n [@@deriving compare, sexp, yojson, hash, equal]\n\n [@@@warning \"+4\"]\n\n let to_latest = Fn.id\n end\n end]\n\n let to_kimchi\n ({ w\n ; coefficients\n ; z\n ; s\n ; generic_selector\n ; poseidon_selector\n ; complete_add_selector\n ; mul_selector\n ; emul_selector\n ; endomul_scalar_selector\n } :\n t ) :\n (Backend.Tock.Field.t array * Backend.Tock.Field.t array)\n Plonk_types.Evals.t =\n let conv (x, y) = ([| x |], [| y |]) in\n { w = Vector.map ~f:conv w\n ; coefficients = Vector.map ~f:conv coefficients\n ; z = conv z\n ; s = Vector.map ~f:conv s\n ; generic_selector = conv generic_selector\n ; poseidon_selector = conv poseidon_selector\n ; complete_add_selector = conv complete_add_selector\n ; mul_selector = conv mul_selector\n ; emul_selector = conv emul_selector\n ; endomul_scalar_selector = conv endomul_scalar_selector\n ; range_check0_selector = None\n ; range_check1_selector = None\n ; foreign_field_add_selector = None\n ; foreign_field_mul_selector = None\n ; xor_selector = None\n ; rot_selector = None\n ; lookup_aggregation = None\n ; lookup_table = None\n ; lookup_sorted = [ None; None; None; None; None ]\n ; runtime_lookup_table = None\n ; runtime_lookup_table_selector = None\n ; xor_lookup_selector = None\n ; lookup_gate_lookup_selector = None\n ; range_check_lookup_selector = None\n ; foreign_field_mul_lookup_selector = None\n }\n\n let of_kimchi\n ({ w\n ; coefficients\n ; z\n ; s\n ; generic_selector\n ; poseidon_selector\n ; complete_add_selector\n ; mul_selector\n ; emul_selector\n ; endomul_scalar_selector\n ; range_check0_selector = _\n ; range_check1_selector = _\n ; foreign_field_add_selector = _\n ; foreign_field_mul_selector = _\n ; xor_selector = _\n ; rot_selector = _\n ; lookup_aggregation = _\n ; lookup_table = _\n ; lookup_sorted = _\n ; runtime_lookup_table = _\n ; runtime_lookup_table_selector = _\n ; xor_lookup_selector = _\n ; lookup_gate_lookup_selector = _\n ; range_check_lookup_selector = _\n ; foreign_field_mul_lookup_selector = _\n } :\n (Backend.Tock.Field.t array * Backend.Tock.Field.t array)\n Plonk_types.Evals.t ) : t =\n let conv (x, y) = (x.(0), y.(0)) in\n { w = Vector.map ~f:conv w\n ; coefficients = Vector.map ~f:conv coefficients\n ; z = conv z\n ; s = Vector.map ~f:conv s\n ; generic_selector = conv generic_selector\n ; poseidon_selector = conv poseidon_selector\n ; complete_add_selector = conv complete_add_selector\n ; mul_selector = conv mul_selector\n ; emul_selector = conv emul_selector\n ; endomul_scalar_selector = conv endomul_scalar_selector\n }\nend\n\n[@@@warning \"-4\"]\n\n[%%versioned\nmodule Stable = struct\n module V1 = struct\n type t = Mina_wire_types.Pickles.Concrete_.Wrap_wire_proof.V1.t =\n { commitments : Commitments.Stable.V1.t\n ; evaluations : Evaluations.Stable.V1.t\n ; ft_eval1 : Backend.Tock.Field.Stable.V1.t\n ; bulletproof :\n ( Backend.Tick.Field.Stable.V1.t * Backend.Tick.Field.Stable.V1.t\n , Backend.Tock.Field.Stable.V1.t )\n Plonk_types.Openings.Bulletproof.Stable.V1.t\n (* TODO-URGENT: Validate bulletproof length on the rust side *)\n }\n [@@deriving compare, sexp, yojson, hash, equal]\n\n [@@@warning \"+4\"]\n\n let to_latest = Fn.id\n end\nend]\n\nlet to_kimchi_proof ({ commitments; bulletproof; evaluations; ft_eval1 } : t) :\n Backend.Tock.Proof.t =\n { messages = Commitments.to_kimchi commitments\n ; openings =\n { proof = bulletproof\n ; evals = Evaluations.to_kimchi evaluations\n ; ft_eval1\n }\n }\n\nlet of_kimchi_proof\n ({ messages; openings = { proof; evals; ft_eval1 } } : Backend.Tock.Proof.t)\n : t =\n { commitments = Commitments.of_kimchi messages\n ; bulletproof = proof\n ; evaluations = Evaluations.of_kimchi evals\n ; ft_eval1\n }\n","open Core_kernel\nopen Import\nmodule SC = Scalar_challenge\n\n(* Implementation of the algorithm described on page 29 of the Halo paper\n https://eprint.iacr.org/2019/1021.pdf\n*)\n\nlet num_bits = 128\n\n(* Has the side effect of checking that [scalar] fits in 128 bits. *)\nlet to_field_checked' (type f) ?(num_bits = num_bits)\n (module Impl : Snarky_backendless.Snark_intf.Run with type field = f)\n { SC.inner = (scalar : Impl.Field.t) } =\n let open Impl in\n let neg_one = Field.Constant.(negate one) in\n let a_func = function\n | 0 ->\n Field.Constant.zero\n | 1 ->\n Field.Constant.zero\n | 2 ->\n neg_one\n | 3 ->\n Field.Constant.one\n | _ ->\n raise (Invalid_argument \"a_func\")\n in\n let b_func = function\n | 0 ->\n neg_one\n | 1 ->\n Field.Constant.one\n | 2 ->\n Field.Constant.zero\n | 3 ->\n Field.Constant.zero\n | _ ->\n raise (Invalid_argument \"a_func\")\n in\n let ( !! ) = As_prover.read_var in\n (* MSB bits *)\n let bits_msb =\n lazy\n (let open Field.Constant in\n unpack !!scalar |> Fn.flip List.take num_bits |> Array.of_list_rev\n (*\n |> Array.of_list_rev_map ~f:(fun b -> if b then one else zero) *))\n in\n let nybbles_per_row = 8 in\n let bits_per_row = 2 * nybbles_per_row in\n [%test_eq: int] (num_bits mod bits_per_row) 0 ;\n let rows = num_bits / bits_per_row in\n let nybbles_by_row =\n lazy\n (Array.init rows ~f:(fun i ->\n Array.init nybbles_per_row ~f:(fun j ->\n let bit = (bits_per_row * i) + (2 * j) in\n let b0 = (Lazy.force bits_msb).(bit + 1) in\n let b1 = (Lazy.force bits_msb).(bit) in\n Bool.to_int b0 + (2 * Bool.to_int b1) ) ) )\n in\n let two = Field.of_int 2 in\n let a = ref two in\n let b = ref two in\n let n = ref Field.zero in\n let mk f = exists Field.typ ~compute:f in\n let state = ref [] in\n for i = 0 to rows - 1 do\n let n0 = !n in\n let a0 = !a in\n let b0 = !b in\n let xs =\n Array.init nybbles_per_row ~f:(fun j ->\n mk (fun () ->\n Field.Constant.of_int (Lazy.force nybbles_by_row).(i).(j) ) )\n in\n let open Field.Constant in\n let double x = x + x in\n let n8 =\n mk (fun () ->\n Array.fold xs ~init:!!n0 ~f:(fun acc x ->\n (acc |> double |> double) + !!x ) )\n in\n let a8 =\n mk (fun () ->\n Array.fold\n (Lazy.force nybbles_by_row).(i)\n ~init:!!a0\n ~f:(fun acc x -> (acc |> double) + a_func x) )\n in\n let b8 =\n mk (fun () ->\n Array.fold\n (Lazy.force nybbles_by_row).(i)\n ~init:!!b0\n ~f:(fun acc x -> (acc |> double) + b_func x) )\n in\n state :=\n { Kimchi_backend_common.Endoscale_scalar_round.a0\n ; a8\n ; b0\n ; b8\n ; n0\n ; n8\n ; x0 = xs.(0)\n ; x1 = xs.(1)\n ; x2 = xs.(2)\n ; x3 = xs.(3)\n ; x4 = xs.(4)\n ; x5 = xs.(5)\n ; x6 = xs.(6)\n ; x7 = xs.(7)\n }\n :: !state ;\n n := n8 ;\n a := a8 ;\n b := b8 ;\n ()\n done ;\n with_label __LOC__ (fun () ->\n assert_\n Snarky_backendless.Constraint.\n { annotation = Some __LOC__\n ; basic =\n Kimchi_backend_common.Plonk_constraint_system.Plonk_constraint.(\n T (EC_endoscalar { state = Array.of_list_rev !state }))\n } ) ;\n (!a, !b, !n)\n\nlet to_field_checked (type f) ?num_bits\n (module Impl : Snarky_backendless.Snark_intf.Run with type field = f) ~endo\n ({ SC.inner = (scalar : Impl.Field.t) } as s) =\n let open Impl in\n let a, b, n = to_field_checked' ?num_bits (module Impl) s in\n Field.Assert.equal n scalar ;\n Field.(scale a endo + b)\n\nlet to_field_constant (type f) ~endo\n (module F : Plonk_checks.Field_intf with type t = f) { SC.inner = c } =\n let bits = Array.of_list (Challenge.Constant.to_bits c) in\n let a = ref (F.of_int 2) in\n let b = ref (F.of_int 2) in\n let one = F.of_int 1 in\n let neg_one = F.(of_int 0 - one) in\n for i = (128 / 2) - 1 downto 0 do\n let s = if bits.(2 * i) then one else neg_one in\n (a := F.(!a + !a)) ;\n (b := F.(!b + !b)) ;\n let r_2i1 = bits.((2 * i) + 1) in\n if r_2i1 then a := F.(!a + s) else b := F.(!b + s)\n done ;\n F.((!a * endo) + !b)\n\nlet test (type f)\n (module Impl : Snarky_backendless.Snark_intf.Run with type field = f)\n ~(endo : f) =\n let open Impl in\n let module T = Internal_Basic in\n let n = 128 in\n let module Field_constant = struct\n include Field.Constant\n\n let _if_ b ~then_ ~else_ = if b then then_ () else else_ ()\n end in\n Quickcheck.test ~trials:10\n (Quickcheck.Generator.list_with_length n Bool.quickcheck_generator)\n ~f:(fun xs ->\n try\n T.Test.test_equal ~equal:Field.Constant.equal\n ~sexp_of_t:Field.Constant.sexp_of_t\n (Typ.list ~length:n Boolean.typ)\n Field.typ\n (fun s ->\n make_checked (fun () ->\n to_field_checked\n (module Impl)\n ~endo\n (SC.create (Impl.Field.pack s)) ) )\n (fun s ->\n to_field_constant\n (module Field_constant)\n ~endo\n (SC.create (Challenge.Constant.of_bits s)) )\n xs\n with e ->\n eprintf !\"Input %{sexp: bool list}\\n%!\" xs ;\n raise e )\n\nmodule Make\n (Impl : Snarky_backendless.Snark_intf.Run)\n (G : Intf.Group(Impl).S with type t = Impl.Field.t * Impl.Field.t)\n (Challenge : Challenge.S with module Impl := Impl) (Endo : sig\n val base : Impl.Field.Constant.t\n\n val scalar : G.Constant.Scalar.t\n end) =\nstruct\n open Impl\n module Scalar = G.Constant.Scalar\n\n type t = Challenge.t SC.t\n\n module Constant = struct\n type t = Challenge.Constant.t SC.t\n\n let to_field = to_field_constant ~endo:Endo.scalar (module Scalar)\n end\n\n let typ : (t, Constant.t) Typ.t = SC.typ Challenge.typ\n\n let num_bits = 128\n\n let seal = Util.seal (module Impl)\n\n let endo ?(num_bits = num_bits) t { SC.inner = (scalar : Field.t) } =\n let ( !! ) = As_prover.read_var in\n (* MSB bits *)\n let bits =\n lazy\n (let open Field.Constant in\n unpack !!scalar |> Fn.flip List.take num_bits\n |> Array.of_list_rev_map ~f:(fun b -> if b then one else zero))\n in\n let bits () = Lazy.force bits in\n let xt, yt = Tuple_lib.Double.map t ~f:seal in\n let bits_per_row = 4 in\n let rows = num_bits / bits_per_row in\n let acc =\n with_label __LOC__ (fun () ->\n let p = G.( + ) t (seal (Field.scale xt Endo.base), yt) in\n ref G.(p + p) )\n in\n let n_acc = ref Field.zero in\n let mk f = exists Field.typ ~compute:f in\n let rounds_rev = ref [] in\n for i = 0 to rows - 1 do\n let n_acc_prev = !n_acc in\n let b1 = mk (fun () -> (bits ()).(i * bits_per_row)) in\n let b2 = mk (fun () -> (bits ()).((i * bits_per_row) + 1)) in\n let b3 = mk (fun () -> (bits ()).((i * bits_per_row) + 2)) in\n let b4 = mk (fun () -> (bits ()).((i * bits_per_row) + 3)) in\n let open Field.Constant in\n let double x = x + x in\n let xp, yp = !acc in\n let xq1 = mk (fun () -> (one + ((Endo.base - one) * !!b1)) * !!xt) in\n let yq1 = mk (fun () -> (double !!b2 - one) * !!yt) in\n\n let s1 = mk (fun () -> (!!yq1 - !!yp) / (!!xq1 - !!xp)) in\n let s1_squared = mk (fun () -> square !!s1) in\n let s2 =\n mk (fun () ->\n (double !!yp / (double !!xp + !!xq1 - !!s1_squared)) - !!s1 )\n in\n\n let xr = mk (fun () -> !!xq1 + square !!s2 - !!s1_squared) in\n let yr = mk (fun () -> ((!!xp - !!xr) * !!s2) - !!yp) in\n\n let xq2 = mk (fun () -> (one + ((Endo.base - one) * !!b3)) * !!xt) in\n let yq2 = mk (fun () -> (double !!b4 - one) * !!yt) in\n let s3 = mk (fun () -> (!!yq2 - !!yr) / (!!xq2 - !!xr)) in\n let s3_squared = mk (fun () -> square !!s3) in\n let s4 =\n mk (fun () ->\n (double !!yr / (double !!xr + !!xq2 - !!s3_squared)) - !!s3 )\n in\n\n let xs = mk (fun () -> !!xq2 + square !!s4 - !!s3_squared) in\n let ys = mk (fun () -> ((!!xr - !!xs) * !!s4) - !!yr) in\n acc := (xs, ys) ;\n n_acc :=\n mk (fun () ->\n !!n_acc_prev |> double |> ( + ) !!b1 |> double |> ( + ) !!b2\n |> double |> ( + ) !!b3 |> double |> ( + ) !!b4 ) ;\n rounds_rev :=\n { Kimchi_backend_common.Endoscale_round.xt\n ; yt\n ; xp\n ; yp\n ; n_acc = n_acc_prev\n ; xr\n ; yr\n ; s1\n ; s3\n ; b1\n ; b2\n ; b3\n ; b4\n }\n :: !rounds_rev\n done ;\n let xs, ys = !acc in\n with_label __LOC__ (fun () ->\n assert_\n { annotation = Some __LOC__\n ; basic =\n Kimchi_backend_common.Plonk_constraint_system.Plonk_constraint.(\n T\n (EC_endoscale\n { xs\n ; ys\n ; n_acc = !n_acc\n ; state = Array.of_list_rev !rounds_rev\n } ))\n } ) ;\n with_label __LOC__ (fun () -> Field.Assert.equal !n_acc scalar) ;\n !acc\n\n let endo ?num_bits t s = with_label \"endo\" (fun () -> endo ?num_bits t s)\n\n let%test_unit \"endo\" =\n let module T = Internal_Basic in\n let random_point =\n let rec pt x =\n let y2 = G.Params.(T.Field.(b + (x * (a + (x * x))))) in\n if T.Field.is_square y2 then (x, T.Field.sqrt y2)\n else pt T.Field.(x + one)\n in\n G.Constant.of_affine (pt (T.Field.random ()))\n in\n let n = 128 in\n Quickcheck.test ~trials:10\n (Quickcheck.Generator.list_with_length n Bool.quickcheck_generator)\n ~f:(fun xs ->\n try\n T.Test.test_equal ~equal:G.Constant.equal\n ~sexp_of_t:G.Constant.sexp_of_t\n (Typ.tuple2 G.typ (Typ.list ~length:n Boolean.typ))\n G.typ\n (fun (g, s) ->\n make_checked (fun () -> endo g (SC.create (Field.pack s))) )\n (fun (g, s) ->\n let x =\n Constant.to_field (SC.create (Challenge.Constant.of_bits s))\n in\n G.Constant.scale g x )\n (random_point, xs)\n with e ->\n eprintf !\"Input %{sexp: bool list}\\n%!\" xs ;\n raise e )\n\n let endo_inv ((gx, gy) as g) chal =\n let res =\n exists G.typ\n ~compute:\n As_prover.(\n fun () ->\n let x = Constant.to_field (read typ chal) in\n G.Constant.scale (read G.typ g) Scalar.(one / x))\n in\n let x, y = endo res chal in\n Field.Assert.(equal gx x ; equal gy y) ;\n res\nend\n","open Pickles_types\nopen Core_kernel\nopen Import\nopen Backend\nmodule Wrap_impl = Snarky_backendless.Snark.Run.Make (Tock)\n\n(** returns [true] if the [i]th bit of [x] is set to 1 *)\nlet test_bit x i = B.(shift_right x i land one = one)\n\n(* TODO: I think there are other forbidden values as well. *)\n\n(** returns all the values that can fit in [~size_in_bits] bits and that are\n * either congruent with -2^[~size_in_bits] mod [~modulus] \n * or congruent with -2^[~size_in_bits] - 1 mod [~modulus] \n *)\nlet forbidden_shifted_values ~modulus:r ~size_in_bits =\n let two_to_n = B.(pow (of_int 2) (of_int size_in_bits)) in\n (* this function doesn't make sense if the modulus is smaller *)\n assert (B.(r < two_to_n)) ;\n let neg_two_to_n = B.(neg two_to_n) in\n let representatives x =\n let open Sequence in\n (* All values equivalent to x mod r that fit in [size_in_bits]\n many bits. *)\n let fits_in_n_bits x = B.(x < two_to_n) in\n unfold ~init:B.(x % r) ~f:(fun x -> Some (x, B.(x + r)))\n |> take_while ~f:fits_in_n_bits\n |> to_list\n in\n List.concat_map [ neg_two_to_n; B.(neg_two_to_n - one) ] ~f:representatives\n |> List.dedup_and_sort ~compare:B.compare\n\nmodule Step = struct\n module Impl = Snarky_backendless.Snark.Run.Make (Tick)\n include Impl\n module Verification_key = Tick.Verification_key\n module Proving_key = Tick.Proving_key\n\n module Keypair = struct\n type t = { pk : Proving_key.t; vk : Verification_key.t } [@@deriving fields]\n\n let create = Fields.create\n\n let generate ~prev_challenges cs =\n let open Tick.Keypair in\n let keypair = create ~prev_challenges cs in\n { pk = pk keypair; vk = vk keypair }\n end\n\n module Other_field = struct\n (* Tick.Field.t = p < q = Tock.Field.t *)\n\n module Constant = Tock.Field\n\n type t = (* Low bits, high bit *)\n Field.t * Boolean.var\n\n let forbidden_shifted_values =\n let size_in_bits = Constant.size_in_bits in\n let other_mod = Wrap_impl.Bigint.to_bignum_bigint Constant.size in\n let values = forbidden_shifted_values ~size_in_bits ~modulus:other_mod in\n let f x =\n let open Option.Let_syntax in\n let hi = test_bit x (Field.size_in_bits - 1) in\n let lo = B.shift_right x 1 in\n let%map lo =\n let modulus = Impl.Field.size in\n if B.compare modulus lo <= 0 then None\n else Some Impl.Bigint.(to_field (of_bignum_bigint lo))\n in\n (lo, hi)\n in\n values |> List.filter_map ~f\n\n let%test_unit \"preserve circuit behavior for Step\" =\n let expected_list =\n [ (\"45560315531506369815346746415080538112\", false)\n ; (\"45560315531506369815346746415080538113\", false)\n ; ( \"14474011154664524427946373126085988481727088556502330059655218120611762012161\"\n , true )\n ; ( \"14474011154664524427946373126085988481727088556502330059655218120611762012161\"\n , true )\n ]\n in\n let str_list =\n List.map forbidden_shifted_values ~f:(fun (a, b) ->\n (Tick.Field.to_string a, b) )\n in\n assert ([%equal: (string * bool) list] str_list expected_list)\n\n let typ_unchecked : (t, Constant.t) Typ.t =\n Typ.transport\n (Typ.tuple2 Field.typ Boolean.typ)\n ~there:(fun x ->\n match Tock.Field.to_bits x with\n | [] ->\n assert false\n | low :: high ->\n (Field.Constant.project high, low) )\n ~back:(fun (high, low) ->\n let high = Field.Constant.unpack high in\n Tock.Field.of_bits (low :: high) )\n\n let check t =\n let open Internal_Basic in\n let open Let_syntax in\n let equal (x1, b1) (x2, b2) =\n let%bind x_eq = Field.Checked.equal x1 (Field.Var.constant x2) in\n let b_eq = match b2 with true -> b1 | false -> Boolean.not b1 in\n Boolean.( && ) x_eq b_eq\n in\n let (Typ typ_unchecked) = typ_unchecked in\n let%bind () = typ_unchecked.check t in\n Checked.List.map forbidden_shifted_values ~f:(equal t)\n >>= Boolean.any >>| Boolean.not >>= Boolean.Assert.is_true\n\n let typ : _ Snarky_backendless.Typ.t =\n let (Typ typ_unchecked) = typ_unchecked in\n Typ { typ_unchecked with check }\n\n let _to_bits (x, b) =\n Field.unpack x ~length:(Field.size_in_bits - 1) @ [ b ]\n end\n\n module Digest = Digest.Make (Impl)\n module Challenge = Challenge.Make (Impl)\n\n let input ~proofs_verified ~wrap_rounds ~feature_flags =\n let open Types.Step.Statement in\n let spec = spec proofs_verified wrap_rounds in\n let (T (typ, f, f_inv)) =\n Spec.packed_typ\n (module Impl)\n (T\n ( Shifted_value.Type2.typ Other_field.typ_unchecked\n , (fun (Shifted_value.Type2.Shifted_value x as t) ->\n Impl.run_checked (Other_field.check x) ;\n t )\n , Fn.id ) )\n spec\n in\n let typ = Typ.transport typ ~there:to_data ~back:of_data in\n Spec.ETyp.T (typ, (fun x -> of_data (f x)), fun x -> f_inv (to_data x))\nend\n\nmodule Wrap = struct\n module Impl = Wrap_impl\n include Impl\n module Challenge = Challenge.Make (Impl)\n module Digest = Digest.Make (Impl)\n module Wrap_field = Tock.Field\n module Step_field = Tick.Field\n module Verification_key = Tock.Verification_key\n module Proving_key = Tock.Proving_key\n\n module Keypair = struct\n type t = { pk : Proving_key.t; vk : Verification_key.t } [@@deriving fields]\n\n let create = Fields.create\n\n let generate ~prev_challenges cs =\n let open Tock.Keypair in\n let keypair = create ~prev_challenges cs in\n { pk = pk keypair; vk = vk keypair }\n end\n\n module Other_field = struct\n module Constant = Tick.Field\n open Impl\n\n type t = Field.t\n\n let forbidden_shifted_values =\n let other_mod = Step.Impl.Bigint.to_bignum_bigint Constant.size in\n let size_in_bits = Constant.size_in_bits in\n let values = forbidden_shifted_values ~size_in_bits ~modulus:other_mod in\n let f x =\n let modulus = Impl.Field.size in\n if B.compare modulus x <= 0 then None\n else Some Impl.Bigint.(to_field (of_bignum_bigint x))\n in\n values |> List.filter_map ~f\n\n let%test_unit \"preserve circuit behavior for Wrap\" =\n let expected_list =\n [ \"91120631062839412180561524743370440705\"\n ; \"91120631062839412180561524743370440706\"\n ]\n in\n let str_list =\n List.map forbidden_shifted_values ~f:Wrap_field.to_string\n in\n assert ([%equal: string list] str_list expected_list)\n\n let typ_unchecked, check =\n (* Tick -> Tock *)\n let (Typ t0 as typ_unchecked) =\n Typ.transport Field.typ\n ~there:(Fn.compose Tock.Field.of_bits Tick.Field.to_bits)\n ~back:(Fn.compose Tick.Field.of_bits Tock.Field.to_bits)\n in\n let check t =\n let open Internal_Basic in\n let open Let_syntax in\n let equal x1 x2 = Field.Checked.equal x1 (Field.Var.constant x2) in\n let%bind () = t0.check t in\n Checked.List.map forbidden_shifted_values ~f:(equal t)\n >>= Boolean.any >>| Boolean.not >>= Boolean.Assert.is_true\n in\n (typ_unchecked, check)\n\n let typ : _ Snarky_backendless.Typ.t =\n let (Typ typ_unchecked) = typ_unchecked in\n Typ { typ_unchecked with check }\n\n let _to_bits x = Field.unpack x ~length:Field.size_in_bits\n end\n\n let input () =\n let lookup =\n { Types.Wrap.Lookup_parameters.use = No\n ; zero =\n { value =\n { challenge = Limb_vector.Challenge.Constant.zero\n ; scalar =\n Shifted_value.Type1.Shifted_value Other_field.Constant.zero\n }\n ; var =\n { challenge = Impl.Field.zero\n ; scalar = Shifted_value.Type1.Shifted_value Impl.Field.zero\n }\n }\n }\n in\n let fp : (Impl.Field.t, Other_field.Constant.t) Typ.t =\n Other_field.typ_unchecked\n in\n let open Types.Wrap.Statement in\n let (T (typ, f, f_inv)) =\n Spec.packed_typ\n (module Impl)\n (T\n ( Shifted_value.Type1.typ fp\n , (fun (Shifted_value x as t) ->\n Impl.run_checked (Other_field.check x) ;\n t )\n , Fn.id ) )\n (* Wrap circuit: no features needed. *)\n (In_circuit.spec (module Impl) lookup Plonk_types.Features.none)\n in\n let feature_flags = Plonk_types.Features.none in\n let typ =\n Typ.transport typ\n ~there:(In_circuit.to_data ~option_map:Option.map ~to_opt:Fn.id)\n ~back:\n (In_circuit.of_data ~feature_flags ~option_map:Option.map\n ~of_opt:Plonk_types.Opt.to_option )\n in\n Spec.ETyp.T\n ( typ\n , (fun x ->\n In_circuit.of_data ~feature_flags ~option_map:Plonk_types.Opt.map\n (f x) ~of_opt:Fn.id )\n , fun x ->\n f_inv\n (In_circuit.to_data ~option_map:Plonk_types.Opt.map x\n ~to_opt:Plonk_types.Opt.to_option_unsafe ) )\nend\n","open Core_kernel\n\nopen Kimchi_backend_common.Plonk_constraint_system.Plonk_constraint\n\nlet seal i = Tuple_lib.Double.map ~f:(Util.seal i)\n\nlet add_fast (type f)\n (module Impl : Snarky_backendless.Snark_intf.Run with type field = f)\n ?(check_finite = true) ((x1, y1) as p1) ((x2, y2) as p2) :\n Impl.Field.t * Impl.Field.t =\n let p1 = seal (module Impl) p1 in\n let p2 = seal (module Impl) p2 in\n let open Impl in\n let open Field.Constant in\n let bool b = if b then one else zero in\n let eq a b = As_prover.(equal (read_var a) (read_var b)) in\n let same_x_bool = lazy (eq x1 x2) in\n let ( ! ) = Lazy.force in\n let ( !! ) = As_prover.read_var in\n let mk f = exists Field.typ ~compute:f in\n let same_x = mk (fun () -> bool !same_x_bool) in\n let inf =\n if check_finite then Field.zero\n else mk (fun () -> bool (!same_x_bool && not (eq y1 y2)))\n in\n let inf_z =\n mk (fun () ->\n if eq y1 y2 then zero\n else if !same_x_bool then inv (!!y2 - !!y1)\n else zero )\n in\n let x21_inv =\n mk (fun () -> if !same_x_bool then zero else inv (!!x2 - !!x1))\n in\n let s =\n mk (fun () ->\n if !same_x_bool then\n let x1_squared = square !!x1 in\n let y1 = !!y1 in\n (x1_squared + x1_squared + x1_squared) / (y1 + y1)\n else (!!y2 - !!y1) / (!!x2 - !!x1) )\n in\n let x3 = mk (fun () -> square !!s - (!!x1 + !!x2)) in\n let y3 = mk (fun () -> (!!s * (!!x1 - !!x3)) - !!y1) in\n let p3 = (x3, y3) in\n with_label \"add_fast\" (fun () ->\n assert_\n { Snarky_backendless.Constraint.annotation = Some __LOC__\n ; basic =\n Kimchi_backend_common.Plonk_constraint_system.Plonk_constraint.T\n (EC_add_complete\n { p1; p2; p3; inf; same_x; slope = s; inf_z; x21_inv } )\n } ;\n p3 )\n\nmodule Make\n (Impl : Snarky_backendless.Snark_intf.Run)\n (G : Intf.Group(Impl).S with type t = Impl.Field.t * Impl.Field.t) =\nstruct\n open Impl\n\n let seal = seal (module Impl)\n\n let add_fast = add_fast (module Impl)\n\n let bits_per_chunk = 5\n\n (* Number of chunks needed to cover the given number of bits. *)\n let chunks_needed ~num_bits =\n (num_bits + (bits_per_chunk - 1)) / bits_per_chunk\n\n let scale_fast_msb_bits base\n (Pickles_types.Shifted_value.Type1.Shifted_value\n (bits_msb : Boolean.var array) ) : Field.t * Field.t =\n let ((x_base, y_base) as base) = seal base in\n let ( !! ) = As_prover.read_var in\n let mk f = exists Field.typ ~compute:f in\n (* MSB bits *)\n let num_bits = Array.length bits_msb in\n let chunks = num_bits / bits_per_chunk in\n [%test_eq: int] (num_bits mod bits_per_chunk) 0 ;\n let acc = ref (add_fast base base) in\n let n_acc = ref Field.zero in\n let rounds_rev = ref [] in\n for chunk = 0 to chunks - 1 do\n let open Field.Constant in\n let double x = x + x in\n let bs =\n Array.init bits_per_chunk ~f:(fun i ->\n (bits_msb.(Int.((chunk * bits_per_chunk) + i)) :> Field.t) )\n in\n let n_acc_prev = !n_acc in\n n_acc :=\n mk (fun () ->\n Array.fold bs ~init:!!n_acc_prev ~f:(fun acc b -> double acc + !!b) ) ;\n let accs, slopes =\n Array.fold_map bs ~init:!acc ~f:(fun (x_acc, y_acc) b ->\n let s1 =\n mk (fun () ->\n (!!y_acc - (!!y_base * (double !!b - one)))\n / (!!x_acc - !!x_base) )\n in\n let s1_squared = mk (fun () -> square !!s1) in\n let s2 =\n mk (fun () ->\n (double !!y_acc / (double !!x_acc + !!x_base - !!s1_squared))\n - !!s1 )\n in\n let x_res = mk (fun () -> !!x_base + square !!s2 - !!s1_squared) in\n let y_res = mk (fun () -> ((!!x_acc - !!x_res) * !!s2) - !!y_acc) in\n let acc' = (x_res, y_res) in\n (acc', (acc', s1)) )\n |> snd |> Array.unzip\n in\n let accs = Array.append [| !acc |] accs in\n acc := Array.last accs ;\n rounds_rev :=\n { Kimchi_backend_common.Scale_round.accs\n ; bits = bs\n ; ss = slopes\n ; n_prev = n_acc_prev\n ; n_next = !n_acc\n ; base\n }\n :: !rounds_rev\n done ;\n assert_\n { Snarky_backendless.Constraint.annotation = Some __LOC__\n ; basic =\n Kimchi_backend_common.Plonk_constraint_system.Plonk_constraint.T\n (EC_scale { state = Array.of_list_rev !rounds_rev })\n } ;\n (* TODO: Return n_acc ? *)\n !acc\n\n (*\n Computes\n\n fun (g, t) -> (2 * t + 1 + 2^len(t)) g *)\n let scale_fast_unpack base\n (Pickles_types.Shifted_value.Type1.Shifted_value (scalar : Field.t))\n ~num_bits : (Field.t * Field.t) * Boolean.var array =\n let ((x_base, y_base) as base) = seal base in\n let ( !! ) = As_prover.read_var in\n let mk f = exists Field.typ ~compute:f in\n (* MSB bits *)\n (*\n let num_bits = Field.size_in_bits in *)\n let chunks = num_bits / bits_per_chunk in\n [%test_eq: int] (num_bits mod bits_per_chunk) 0 ;\n let bits_msb =\n exists (Typ.array ~length:num_bits Field.typ) ~compute:(fun () ->\n let open Field.Constant in\n unpack !!scalar |> Fn.flip List.take num_bits\n |> Array.of_list_rev_map ~f:(fun b -> if b then one else zero) )\n in\n let acc = ref (add_fast base base) in\n let n_acc = ref Field.zero in\n let rounds_rev = ref [] in\n for chunk = 0 to chunks - 1 do\n let open Field.Constant in\n let double x = x + x in\n let bs =\n Array.init bits_per_chunk ~f:(fun i ->\n bits_msb.(Int.((chunk * bits_per_chunk) + i)) )\n in\n let n_acc_prev = !n_acc in\n n_acc :=\n mk (fun () ->\n Array.fold bs ~init:!!n_acc_prev ~f:(fun acc b -> double acc + !!b) ) ;\n let accs, slopes =\n Array.fold_map bs ~init:!acc ~f:(fun (x_acc, y_acc) b ->\n let s1 =\n mk (fun () ->\n (!!y_acc - (!!y_base * (double !!b - one)))\n / (!!x_acc - !!x_base) )\n in\n let s1_squared = mk (fun () -> square !!s1) in\n let s2 =\n mk (fun () ->\n (double !!y_acc / (double !!x_acc + !!x_base - !!s1_squared))\n - !!s1 )\n in\n let x_res = mk (fun () -> !!x_base + square !!s2 - !!s1_squared) in\n let y_res = mk (fun () -> ((!!x_acc - !!x_res) * !!s2) - !!y_acc) in\n let acc' = (x_res, y_res) in\n (acc', (acc', s1)) )\n |> snd |> Array.unzip\n in\n let accs = Array.append [| !acc |] accs in\n acc := Array.last accs ;\n rounds_rev :=\n { Kimchi_backend_common.Scale_round.accs\n ; bits = bs\n ; ss = slopes\n ; n_prev = n_acc_prev\n ; n_next = !n_acc\n ; base\n }\n :: !rounds_rev\n done ;\n assert_\n { Snarky_backendless.Constraint.annotation = Some __LOC__\n ; basic =\n Kimchi_backend_common.Plonk_constraint_system.Plonk_constraint.T\n (EC_scale { state = Array.of_list_rev !rounds_rev })\n } ;\n Field.Assert.equal !n_acc scalar ;\n let bits_lsb =\n let bs = Array.map bits_msb ~f:Boolean.Unsafe.of_cvar in\n Array.rev_inplace bs ; bs\n in\n (!acc, bits_lsb)\n\n let scale_fast_unpack base scalar ~num_bits :\n (Field.t * Field.t) * Boolean.var array =\n with_label \"scale_fast_unpack\" (fun () ->\n scale_fast_unpack base scalar ~num_bits )\n\n let scale_fast base s ~num_bits =\n let r, _bits = scale_fast_unpack base s ~num_bits in\n r\n\n module type Scalar_field_intf = sig\n module Constant : sig\n include Plonk_checks.Field_intf\n\n val to_bigint : t -> Impl.Bigint.t\n end\n\n type t = Field.t\n\n val typ : (t, Constant.t) Typ.t\n end\n\n (* Computes\n\n (g, s) -> (s + 2^{len(s) - 1})\n\n as\n\n let h = scale_fast g (s >> 1) in\n if s is odd then h else h - g\n ==\n let h = [ 2 * (s >> 1) + 1 + 2^{len(s) - 1} ] * g in\n if s is odd then h else h - g\n\n since if s is odd, then s = 2 * (s >> 1) + 1, and otherwise,\n s = 2 * (s >> 1) + 1 - 1.\n *)\n let scale_fast2 (g : G.t)\n (Pickles_types.Shifted_value.Type2.Shifted_value\n ((s_div_2 : Field.t), (s_odd : Boolean.var)) ) ~(num_bits : int) : G.t =\n let s_div_2_bits = num_bits - 1 in\n (* The number of chunks need for scaling by s_div_2. *)\n let chunks_needed = chunks_needed ~num_bits:s_div_2_bits in\n let actual_bits_used = chunks_needed * bits_per_chunk in\n let h, bits_lsb =\n scale_fast_unpack g (Shifted_value s_div_2) ~num_bits:actual_bits_used\n in\n (* Constrain the top bits of s_div_2 to be 0. *)\n with_label __LOC__ (fun () ->\n for i = s_div_2_bits to Array.length bits_lsb - 1 do\n Field.Assert.equal Field.zero (bits_lsb.(i) :> Field.t)\n done ) ;\n with_label __LOC__ (fun () ->\n G.if_ s_odd ~then_:h ~else_:(add_fast h (G.negate g)) )\n\n let scale_fast2' (type scalar_field)\n (module Scalar_field : Scalar_field_intf\n with type Constant.t = scalar_field ) g (s : Scalar_field.t) ~num_bits =\n let ((s_div_2, s_odd) as s_parts) =\n with_label __LOC__ (fun () ->\n exists\n Typ.(Scalar_field.typ * Boolean.typ)\n ~compute:\n As_prover.(\n fun () ->\n let s = read Scalar_field.typ s in\n let open Scalar_field.Constant in\n let s_odd = Bigint.test_bit (to_bigint s) 0 in\n ((if s_odd then s - one else s) / of_int 2, s_odd)) )\n in\n\n (* In this case, it's safe to use this field to compute\n\n 2 s_div_2 + b\n\n in the other field. *)\n with_label __LOC__ (fun () ->\n Field.Assert.equal Field.((of_int 2 * s_div_2) + (s_odd :> Field.t)) s ) ;\n scale_fast2 g (Pickles_types.Shifted_value.Type2.Shifted_value s_parts)\n ~num_bits\n\n let scale_fast a b = with_label __LOC__ (fun () -> scale_fast a b)\n\n let%test_module \"curve_ops\" =\n ( module struct\n module T = Internal_Basic\n\n let random_point =\n let rec pt x =\n let y2 = G.Params.(T.Field.(b + (x * (a + (x * x))))) in\n if T.Field.is_square y2 then (x, T.Field.sqrt y2)\n else pt T.Field.(x + one)\n in\n G.Constant.of_affine (pt (T.Field.of_int 0))\n\n let n = Field.size_in_bits\n\n let%test_unit \"scale fast 2\" =\n Quickcheck.test ~trials:5 Field.Constant.gen ~f:(fun s ->\n let input =\n let s_odd = T.Bigint.test_bit (T.Bigint.of_field s) 0 in\n Field.Constant.((if s_odd then s - one else s) / of_int 2, s_odd)\n in\n T.Test.test_equal ~equal:G.Constant.equal\n ~sexp_of_t:G.Constant.sexp_of_t\n (Typ.tuple2 G.typ (Typ.tuple2 Field.typ Boolean.typ))\n G.typ\n (fun (g, s) ->\n make_checked (fun () ->\n scale_fast2 ~num_bits:n g\n (Pickles_types.Shifted_value.Type2.Shifted_value s) ) )\n (fun (g, _) ->\n let x =\n let chunks_needed = chunks_needed ~num_bits:(n - 1) in\n let actual_bits_used = chunks_needed * bits_per_chunk in\n Pickles_types.Pcs_batch.pow ~one:G.Constant.Scalar.one\n ~mul:G.Constant.Scalar.( * )\n G.Constant.Scalar.(of_int 2)\n actual_bits_used\n |> G.Constant.Scalar.( + )\n (G.Constant.Scalar.project (Field.Constant.unpack s))\n in\n G.Constant.scale g x )\n (random_point, input) )\n\n let%test_unit \"scale fast\" =\n let open Pickles_types in\n let shift =\n Shifted_value.Type1.Shift.create (module G.Constant.Scalar)\n in\n Quickcheck.test ~trials:10\n Quickcheck.Generator.(\n map (list_with_length n Bool.quickcheck_generator) ~f:(fun bs ->\n Field.Constant.project bs |> Field.Constant.unpack ))\n ~f:(fun xs ->\n try\n T.Test.test_equal ~equal:G.Constant.equal\n ~sexp_of_t:G.Constant.sexp_of_t\n (Typ.tuple2 G.typ (Typ.list ~length:n Boolean.typ))\n G.typ\n (fun (g, s) ->\n make_checked (fun () ->\n scale_fast ~num_bits:n g\n (Pickles_types.Shifted_value.Type1.Shifted_value\n (Field.project s) ) ) )\n (fun (g, s) ->\n let open G.Constant.Scalar in\n let s = project s in\n let x =\n Shifted_value.Type1.to_field\n (module G.Constant.Scalar)\n ~shift (Pickles_types.Shifted_value.Type1.Shifted_value s)\n in\n G.Constant.scale g x )\n (random_point, xs)\n with e ->\n eprintf !\"Input %{sexp: bool list}\\n%!\" xs ;\n raise e )\n end )\nend\n","open Core_kernel\nopen Import\nopen Pickles_types\nopen Common\nopen Backend\n\n(* The step-proof \"reduced\" me-only contains the data of the standard me-only\n but without the wrap verification key. The purpose of this type is for sending\n step me-onlys on the wire. There is no need to send the wrap-key since everyone\n knows it. *)\nmodule Step = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type ('s, 'challenge_polynomial_commitments, 'bpcs) t =\n ( 's\n , 'challenge_polynomial_commitments\n , 'bpcs )\n Mina_wire_types\n .Pickles_reduced_messages_for_next_proof_over_same_field\n .Step\n .V1\n .t =\n { app_state : 's\n ; challenge_polynomial_commitments : 'challenge_polynomial_commitments\n ; old_bulletproof_challenges : 'bpcs\n }\n [@@deriving sexp, yojson, sexp, compare, hash, equal]\n end\n end]\n\n let prepare ~dlog_plonk_index\n { app_state\n ; challenge_polynomial_commitments\n ; old_bulletproof_challenges\n } =\n { Types.Step.Proof_state.Messages_for_next_step_proof.app_state\n ; challenge_polynomial_commitments\n ; dlog_plonk_index\n ; old_bulletproof_challenges =\n Vector.map ~f:Ipa.Step.compute_challenges old_bulletproof_challenges\n }\nend\n\nmodule Wrap = struct\n module Challenges_vector = struct\n module Vector = Pickles_types.Vector\n module Wrap_bp_vec = Import.Types.Wrap_bp_vec\n open Import\n\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V2 = struct\n type t =\n Limb_vector.Constant.Hex64.Stable.V1.t Vector.Vector_2.Stable.V1.t\n Scalar_challenge.Stable.V2.t\n Bulletproof_challenge.Stable.V1.t\n Wrap_bp_vec.Stable.V1.t\n [@@deriving sexp, compare, yojson, hash, equal]\n\n let to_latest = Fn.id\n end\n end]\n\n type t =\n Challenge.Constant.t Scalar_challenge.t Bulletproof_challenge.t\n Wrap_bp_vec.t\n [@@deriving sexp, compare, yojson, hash, equal]\n\n let (_ : (t, Stable.Latest.t) Type_equal.t) = Type_equal.T\n\n module Prepared = struct\n type t = (Tock.Field.t, Tock.Rounds.n) Vector.t\n end\n end\n\n type 'max_local_max_proofs_verified t =\n ( Tock.Inner_curve.Affine.t\n , (Challenges_vector.t, 'max_local_max_proofs_verified) Vector.t )\n Types.Wrap.Proof_state.Messages_for_next_wrap_proof.t\n\n module Prepared = struct\n type 'max_local_max_proofs_verified t =\n ( Tock.Inner_curve.Affine.t\n , (Challenges_vector.Prepared.t, 'max_local_max_proofs_verified) Vector.t\n )\n Types.Wrap.Proof_state.Messages_for_next_wrap_proof.t\n end\n\n let prepare\n ({ challenge_polynomial_commitment; old_bulletproof_challenges } : _ t) =\n { Types.Wrap.Proof_state.Messages_for_next_wrap_proof\n .challenge_polynomial_commitment\n ; old_bulletproof_challenges =\n Vector.map ~f:Ipa.Wrap.compute_challenges old_bulletproof_challenges\n }\nend\n","open Core_kernel\nopen Common\nopen Backend\nmodule Impl = Impls.Step\n\nlet _high_entropy_bits = 128\n\nlet sponge_params_constant =\n Sponge.Params.(map pasta_p_kimchi ~f:Impl.Field.Constant.of_string)\n\nlet tick_field_random_oracle ?(length = Tick.Field.size_in_bits - 1) s =\n Tick.Field.of_bits (Ro.bits_random_oracle ~length s)\n\nlet _unrelated_g =\n let group_map =\n unstage\n (group_map\n (module Tick.Field)\n ~a:Tick.Inner_curve.Params.a ~b:Tick.Inner_curve.Params.b )\n and str = Fn.compose bits_to_bytes Tick.Field.to_bits in\n fun (x, y) -> group_map (tick_field_random_oracle (str x ^ str y))\n\nopen Impl\n\n(* Debug helper to convert step circuit field element to a hex string *)\nlet read_step_circuit_field_element_as_hex fe =\n let prover_fe = As_prover.read Field.typ fe in\n Kimchi_backend.Pasta.Vesta_based_plonk.(\n Bigint.to_hex (Field.to_bigint prover_fe))\n\nmodule Other_field = struct\n type t = Tock.Field.t [@@deriving sexp]\n\n include (Tock.Field : module type of Tock.Field with type t := t)\n\n let size = Impls.Wrap.Bigint.to_bignum_bigint size\nend\n\nlet sponge_params =\n Sponge.Params.(map sponge_params_constant ~f:Impl.Field.constant)\n\n(* module Unsafe = struct\n let _unpack_unboolean ?(length = Field.size_in_bits) x =\n let res =\n exists\n (Typ.list Boolean.typ_unchecked ~length)\n ~compute:\n As_prover.(\n fun () -> List.take (Field.Constant.unpack (read_var x)) length)\n in\n Field.Assert.equal x (Field.project res) ;\n res\n end *)\n\nmodule Sponge = struct\n module Permutation =\n Sponge_inputs.Make\n (Impl)\n (struct\n include Tick_field_sponge.Inputs\n\n let params = Tick_field_sponge.params\n end)\n\n module S = Sponge.Make_debug_sponge (struct\n include Permutation\n module Circuit = Impls.Step\n\n (* Optional sponge name used in debug mode *)\n let sponge_name = \"step\"\n\n (* To enable debug mode, set environment variable [sponge_name] to \"t\", \"1\" or \"true\". *)\n let debug_helper_fn = read_step_circuit_field_element_as_hex\n end)\n\n include S\n\n let squeeze_field t = squeeze t\n\n let squeeze t = squeeze t\n\n let absorb t input =\n match input with\n | `Field x ->\n absorb t x\n | `Bits bs ->\n absorb t (Field.pack bs)\nend\n\nlet%test_unit \"sponge\" =\n let module T = Make_sponge.Test (Impl) (Tick_field_sponge.Field) (Sponge.S) in\n T.test Tick_field_sponge.params\n\n(* module Input_domain = struct\n let domain = Import.Domain.Pow_2_roots_of_unity 6\n\n let _lagrange_commitments =\n lazy\n (let domain_size = Import.Domain.size domain in\n Common.time \"lagrange\" (fun () ->\n Array.init domain_size ~f:(fun i ->\n let v =\n (Kimchi_bindings.Protocol.SRS.Fq.lagrange_commitment\n (Backend.Tock.Keypair.load_urs ())\n domain_size i )\n .unshifted\n in\n assert (Array.length v = 1) ;\n v.(0) |> Common.finite_exn ) ) )\n end *)\n\nmodule Inner_curve = struct\n module C = Kimchi_pasta.Pasta.Pallas\n\n module Inputs = struct\n module Impl = Impl\n\n module Params = struct\n include C.Params\n\n let one = C.to_affine_exn C.one\n\n let group_size_in_bits = Field.size_in_bits\n end\n\n module F = struct\n include struct\n open Impl.Field\n\n type nonrec t = t\n\n let ( * ), ( + ), ( - ), inv_exn, square, scale, if_, typ, constant =\n (( * ), ( + ), ( - ), inv, square, scale, if_, typ, constant)\n\n let negate x = scale x Constant.(negate one)\n end\n\n module Constant = struct\n open Impl.Field.Constant\n\n type nonrec t = t\n\n let ( * ), ( + ), ( - ), inv_exn, square, negate =\n (( * ), ( + ), ( - ), inv, square, negate)\n end\n\n let assert_square x y = Impl.assert_square x y\n\n let assert_r1cs x y z = Impl.assert_r1cs x y z\n end\n\n module Constant = struct\n include C.Affine\n module Scalar = Impls.Wrap.Field.Constant\n\n let scale (t : t) x : t = C.(to_affine_exn (scale (of_affine t) x))\n\n let random () = C.(to_affine_exn (random ()))\n\n let zero = Impl.Field.Constant.(zero, zero)\n\n let ( + ) t1 t2 =\n let is_zero (x, _) = Impl.Field.Constant.(equal zero x) in\n if is_zero t1 then t2\n else if is_zero t2 then t1\n else\n let r = C.(of_affine t1 + of_affine t2) in\n try C.to_affine_exn r with _ -> zero\n\n let negate x = C.(to_affine_exn (negate (of_affine x)))\n\n let to_affine_exn = Fn.id\n\n let of_affine = Fn.id\n end\n end\n\n module Params = Inputs.Params\n module Constant = Inputs.Constant\n module T = Snarky_curve.For_native_base_field (Inputs)\n\n include (\n T :\n module type of T\n with module Scaling_precomputation := T.Scaling_precomputation )\n\n module Scaling_precomputation = T.Scaling_precomputation\n\n let ( + ) t1 t2 = Plonk_curve_ops.add_fast (module Impl) t1 t2\n\n let double t = t + t\n\n let scale t bs =\n with_label __LOC__ (fun () ->\n T.scale t (Bitstring_lib.Bitstring.Lsb_first.of_list bs) )\n\n let to_field_elements (x, y) = [ x; y ]\n\n let assert_equal (x1, y1) (x2, y2) =\n Field.Assert.equal x1 x2 ; Field.Assert.equal y1 y2\n\n let scale_inv t bs =\n let res =\n exists typ\n ~compute:\n As_prover.(\n fun () ->\n C.scale\n (C.of_affine (read typ t))\n (Tock.Field.inv\n (Tock.Field.of_bits (List.map ~f:(read Boolean.typ) bs)) )\n |> C.to_affine_exn)\n in\n assert_equal t (scale res bs) ;\n res\n\n let negate = T.negate\n\n let one = T.one\n\n let if_ = T.if_\nend\n\nmodule Ops = Plonk_curve_ops.Make (Impl) (Inner_curve)\n\nlet%test_unit \"scale fast 2'\" =\n let open Impl in\n let module T = Internal_Basic in\n let module G = Inner_curve in\n let n = Field.size_in_bits in\n let module F = struct\n type t = Field.t\n\n let typ = Field.typ\n\n module Constant = struct\n include Field.Constant\n\n let to_bigint = Impl.Bigint.of_field\n end\n end in\n Quickcheck.test ~trials:5 Field.Constant.gen ~f:(fun s ->\n T.Test.test_equal ~equal:G.Constant.equal ~sexp_of_t:G.Constant.sexp_of_t\n (Typ.tuple2 G.typ Field.typ)\n G.typ\n (fun (g, s) ->\n make_checked (fun () -> Ops.scale_fast2' ~num_bits:n (module F) g s)\n )\n (fun (g, _) ->\n let x =\n let chunks_needed = Ops.chunks_needed ~num_bits:(n - 1) in\n let actual_bits_used = chunks_needed * Ops.bits_per_chunk in\n Pickles_types.Pcs_batch.pow ~one:G.Constant.Scalar.one\n ~mul:G.Constant.Scalar.( * )\n G.Constant.Scalar.(of_int 2)\n actual_bits_used\n |> G.Constant.Scalar.( + )\n (G.Constant.Scalar.project (Field.Constant.unpack s))\n in\n G.Constant.scale g x )\n (G.Constant.random (), s) )\n\nlet%test_unit \"scale fast 2 small\" =\n let open Impl in\n let module T = Internal_Basic in\n let module G = Inner_curve in\n let n = 8 in\n let module F = struct\n type t = Field.t\n\n let typ = Field.typ\n\n module Constant = struct\n include Field.Constant\n\n let to_bigint = Impl.Bigint.of_field\n end\n end in\n Quickcheck.test ~trials:5 Field.Constant.gen ~f:(fun s ->\n let s =\n Field.Constant.unpack s |> Fn.flip List.take n |> Field.Constant.project\n in\n T.Test.test_equal ~equal:G.Constant.equal ~sexp_of_t:G.Constant.sexp_of_t\n (Typ.tuple2 G.typ Field.typ)\n G.typ\n (fun (g, s) ->\n make_checked (fun () -> Ops.scale_fast2' ~num_bits:n (module F) g s)\n )\n (fun (g, _) ->\n let x =\n let chunks_needed = Ops.chunks_needed ~num_bits:(n - 1) in\n let actual_bits_used = chunks_needed * Ops.bits_per_chunk in\n Pickles_types.Pcs_batch.pow ~one:G.Constant.Scalar.one\n ~mul:G.Constant.Scalar.( * )\n G.Constant.Scalar.(of_int 2)\n actual_bits_used\n |> G.Constant.Scalar.( + )\n (G.Constant.Scalar.project (Field.Constant.unpack s))\n in\n G.Constant.scale g x )\n (G.Constant.random (), s) )\n\nmodule Generators = struct\n let h =\n lazy\n ( Kimchi_bindings.Protocol.SRS.Fq.urs_h (Backend.Tock.Keypair.load_urs ())\n |> Common.finite_exn )\nend\n","(** A verification key for a pickles proof, whose contents are not fixed within\n the verifier circuit.\n This is used to verify a proof where the verification key is determined by\n some other constraint, for example to use a verification key provided as\n input to the circuit, or loaded from an account that was chosen based upon\n the circuit inputs.\n\n Here and elsewhere, we use the terms\n * **width**:\n - the number of proofs that a proof has verified itself;\n - (equivalently) the maximum number of proofs that a proof depends upon\n directly.\n - NB: This does not include recursively-verified proofs, this only refers\n to proofs that were provided directly to pickles when the proof was\n being generated.\n * **branch**:\n - a single 'rule' or 'circuit' for which a proof can be generated, where\n a verification key verifies a proof for any of these branches.\n - It is common to have a 'base' branch and a 'recursion' branch. For\n example, the transaction snark has a 'transaction' proof that evaluates\n a single transaction and a 'merge' proof that combines two transaction\n snark proofs that prove sequential updates, each of which may be either\n a 'transaction' or a 'merge'.\n*)\n\nopen Core_kernel\nopen Pickles_types\nopen Import\nmodule V = Pickles_base.Side_loaded_verification_key\n\ninclude (\n V :\n module type of V\n with module Width := V.Width\n and module Domains := V.Domains )\n\nlet bits = V.bits\n\nlet input_size ~of_int ~add ~mul w =\n (* This should be an affine function in [a]. *)\n let size a =\n let (T (Typ typ, _conv, _conv_inv)) =\n Impls.Step.input ~proofs_verified:a ~wrap_rounds:Backend.Tock.Rounds.n\n ~feature_flags:Plonk_types.Features.none\n in\n typ.size_in_field_elements\n in\n let f0 = size Nat.N0.n in\n let slope = size Nat.N1.n - f0 in\n add (of_int f0) (mul (of_int slope) w)\n\nmodule Width : sig\n [%%versioned:\n module Stable : sig\n module V1 : sig\n type t = V.Width.Stable.V1.t\n [@@deriving sexp, equal, compare, hash, yojson]\n end\n end]\n\n open Impls.Step\n\n module Checked : sig\n type t\n\n val to_field : t -> Field.t\n\n val to_bits : t -> Boolean.var list\n end\n\n val typ : (Checked.t, t) Typ.t\n\n module Max = Nat.N2\n\n module Max_vector : Vector.With_version(Max).S\n\n module Max_at_most : sig\n [%%versioned:\n module Stable : sig\n module V1 : sig\n type 'a t = ('a, Max.n) At_most.t\n [@@deriving compare, sexp, yojson, hash, equal]\n end\n end]\n end\n\n module Length : Nat.Add.Intf_transparent\nend = struct\n include V.Width\n open Impls.Step\n\n module Checked = struct\n (* A \"width\" is represented by a 4 bit integer. *)\n type t = (Boolean.var, Length.n) Vector.t\n\n let to_field : t -> Field.t = Fn.compose Field.project Vector.to_list\n\n let to_bits = Vector.to_list\n end\n\n let typ : (Checked.t, t) Typ.t =\n Typ.transport\n (Vector.typ Boolean.typ Length.n)\n ~there:(fun x ->\n let x = to_int x in\n Vector.init Length.n ~f:(fun i -> (x lsr i) land 1 = 1) )\n ~back:(fun v ->\n Vector.foldi v ~init:0 ~f:(fun i acc b ->\n if b then acc lor (1 lsl i) else acc )\n |> of_int_exn )\nend\n\nmodule Domain = struct\n type 'a t = Pow_2_roots_of_unity of 'a [@@deriving sexp]\n\n let log2_size (Pow_2_roots_of_unity x) = x\nend\n[@@warning \"-4\"]\n\nmodule Domains = struct\n include V.Domains\n\n let _typ =\n let open Impls.Step in\n let dom =\n Typ.transport Typ.field\n ~there:(fun (Plonk_checks.Domain.Pow_2_roots_of_unity n) ->\n Field.Constant.of_int n )\n ~back:(fun _ -> assert false)\n |> Typ.transport_var\n ~there:(fun (Domain.Pow_2_roots_of_unity n) -> n)\n ~back:(fun n -> Domain.Pow_2_roots_of_unity n)\n in\n Typ.of_hlistable [ dom ] ~var_to_hlist:to_hlist ~value_to_hlist:to_hlist\n ~var_of_hlist:of_hlist ~value_of_hlist:of_hlist\nend\n\nlet max_domains =\n { Domains.h = Domain.Pow_2_roots_of_unity (Nat.to_int Backend.Tick.Rounds.n) }\n\nmodule Vk = struct\n type t = (Impls.Wrap.Verification_key.t[@sexp.opaque]) [@@deriving sexp]\n\n let hash_fold_t s _ = Unit.hash_fold_t s ()\nend\n\nmodule R = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t = Backend.Tock.Curve.Affine.Stable.V1.t Repr.Stable.V2.t\n [@@deriving sexp, equal, compare, yojson]\n\n let to_latest = Fn.id\n end\n end]\nend\n\n[%%versioned_binable\nmodule Stable = struct\n module V2 = struct\n module T = struct\n type t =\n ( Backend.Tock.Curve.Affine.t\n , Pickles_base.Proofs_verified.Stable.V1.t\n , Vk.t )\n Poly.Stable.V2.t\n [@@deriving hash]\n\n let to_latest = Fn.id\n\n let description = \"Verification key\"\n\n let version_byte = Base58_check.Version_bytes.verification_key\n\n let to_repr\n { Poly.max_proofs_verified\n ; actual_wrap_domain_size\n ; wrap_index\n ; wrap_vk = _\n } =\n { Repr.Stable.V2.max_proofs_verified\n ; actual_wrap_domain_size\n ; wrap_index\n }\n\n let of_repr\n ({ Repr.Stable.V2.max_proofs_verified\n ; actual_wrap_domain_size\n ; wrap_index = c\n } :\n R.Stable.V2.t ) : t =\n let d =\n (Common.wrap_domains\n ~proofs_verified:\n (Pickles_base.Proofs_verified.to_int actual_wrap_domain_size) )\n .h\n in\n let log2_size = Import.Domain.log2_size d in\n let public =\n let (T (input, _conv, _conv_inv)) = Impls.Wrap.input () in\n let (Typ typ) = input in\n typ.size_in_field_elements\n in\n (* we only compute the wrap_vk if the srs can be loaded *)\n let srs =\n try Some (Backend.Tock.Keypair.load_urs ()) with _ -> None\n in\n let wrap_vk =\n Option.map srs ~f:(fun srs : Impls.Wrap.Verification_key.t ->\n { domain =\n { log_size_of_group = log2_size\n ; group_gen = Backend.Tock.Field.domain_generator ~log2_size\n }\n ; max_poly_size = 1 lsl Nat.to_int Backend.Tock.Rounds.n\n ; public\n ; prev_challenges = 2 (* Due to Wrap_hack *)\n ; srs\n ; evals =\n (let g (x, y) =\n { Kimchi_types.unshifted = [| Kimchi_types.Finite (x, y) |]\n ; shifted = None\n }\n in\n { sigma_comm = Array.map ~f:g (Vector.to_array c.sigma_comm)\n ; coefficients_comm =\n Array.map ~f:g (Vector.to_array c.coefficients_comm)\n ; generic_comm = g c.generic_comm\n ; mul_comm = g c.mul_comm\n ; psm_comm = g c.psm_comm\n ; emul_comm = g c.emul_comm\n ; complete_add_comm = g c.complete_add_comm\n ; endomul_scalar_comm = g c.endomul_scalar_comm\n } )\n ; shifts = Common.tock_shifts ~log2_size\n ; lookup_index = None\n } )\n in\n { Poly.max_proofs_verified\n ; actual_wrap_domain_size\n ; wrap_index = c\n ; wrap_vk\n }\n\n (* Proxy derivers to [R.t]'s, ignoring [wrap_vk] *)\n\n let sexp_of_t t = R.sexp_of_t (to_repr t)\n\n let t_of_sexp sexp = of_repr (R.t_of_sexp sexp)\n\n let _to_yojson t = R.to_yojson (to_repr t)\n\n let _of_yojson json = Result.map ~f:of_repr (R.of_yojson json)\n\n let equal x y = R.equal (to_repr x) (to_repr y)\n\n let compare x y = R.compare (to_repr x) (to_repr y)\n\n include\n Binable.Of_binable\n (R.Stable.V2)\n (struct\n type nonrec t = t\n\n let to_binable r = to_repr r\n\n let of_binable r = of_repr r\n end)\n end\n\n include T\n include Codable.Make_base58_check (T)\n include Codable.Make_base64 (T)\n end\nend]\n\n[%%define_locally\nStable.Latest.\n ( to_base58_check\n , of_base58_check\n , of_base58_check_exn\n , to_base64\n , of_base64\n , sexp_of_t\n , t_of_sexp\n , to_yojson\n , of_yojson\n , equal\n , compare )]\n\nlet dummy : t =\n { max_proofs_verified = N2\n ; actual_wrap_domain_size = N2\n ; wrap_index =\n (let g = Backend.Tock.Curve.(to_affine_exn one) in\n { sigma_comm = Vector.init Plonk_types.Permuts.n ~f:(fun _ -> g)\n ; coefficients_comm = Vector.init Plonk_types.Columns.n ~f:(fun _ -> g)\n ; generic_comm = g\n ; psm_comm = g\n ; complete_add_comm = g\n ; mul_comm = g\n ; emul_comm = g\n ; endomul_scalar_comm = g\n } )\n ; wrap_vk = None\n }\n\nmodule Checked = struct\n open Step_main_inputs\n open Impl\n\n type t =\n { max_proofs_verified :\n Impl.field Pickles_base.Proofs_verified.One_hot.Checked.t\n (** The maximum of all of the [step_widths]. *)\n ; actual_wrap_domain_size :\n Impl.field Pickles_base.Proofs_verified.One_hot.Checked.t\n (** The actual domain size used by the wrap circuit. *)\n ; wrap_index : Inner_curve.t Plonk_verification_key_evals.t\n (** The plonk verification key for the 'wrapping' proof that this key\n is used to verify.\n *)\n }\n [@@deriving hlist, fields]\n\n (** [log_2] of the width. *)\n let _width_size = Nat.to_int Width.Length.n\n\n let to_input =\n let open Random_oracle_input.Chunked in\n fun { max_proofs_verified; actual_wrap_domain_size; wrap_index } :\n _ Random_oracle_input.Chunked.t ->\n let max_proofs_verified =\n Pickles_base.Proofs_verified.One_hot.Checked.to_input\n max_proofs_verified\n in\n let actual_wrap_domain_size =\n Pickles_base.Proofs_verified.One_hot.Checked.to_input\n actual_wrap_domain_size\n in\n List.reduce_exn ~f:append\n [ max_proofs_verified\n ; actual_wrap_domain_size\n ; wrap_index_to_input\n (Fn.compose Array.of_list Inner_curve.to_field_elements)\n wrap_index\n ]\nend\n\nlet%test_unit \"input_size\" =\n List.iter\n (List.range 0 (Nat.to_int Width.Max.n) ~stop:`inclusive ~start:`inclusive)\n ~f:(fun n ->\n [%test_eq: int]\n (input_size ~of_int:Fn.id ~add:( + ) ~mul:( * ) n)\n (let (T a) = Nat.of_int n in\n let (T (Typ typ, _conv, _conv_inv)) =\n Impls.Step.input ~proofs_verified:a\n ~wrap_rounds:Backend.Tock.Rounds.n\n ~feature_flags:Plonk_types.Features.none\n in\n typ.size_in_field_elements ) )\n\nlet typ : (Checked.t, t) Impls.Step.Typ.t =\n let open Step_main_inputs in\n let open Impl in\n Typ.of_hlistable\n [ Pickles_base.Proofs_verified.One_hot.typ (module Impls.Step)\n ; Pickles_base.Proofs_verified.One_hot.typ (module Impls.Step)\n ; Plonk_verification_key_evals.typ Inner_curve.typ\n ]\n ~var_to_hlist:Checked.to_hlist ~var_of_hlist:Checked.of_hlist\n ~value_of_hlist:(fun _ ->\n failwith \"Side_loaded_verification_key: value_of_hlist\" )\n ~value_to_hlist:(fun { Poly.wrap_index\n ; actual_wrap_domain_size\n ; max_proofs_verified\n ; _\n } ->\n [ max_proofs_verified; actual_wrap_domain_size; wrap_index ] )\n","open Core_kernel\nopen Pickles_types\nopen Import\nopen Backend\n\nlet hash_fold_array = Pickles_types.Plonk_types.hash_fold_array\n\nmodule Base = struct\n module Messages_for_next_proof_over_same_field =\n Reduced_messages_for_next_proof_over_same_field\n\n module Step = struct\n type ( 's\n , 'unfinalized_proofs\n , 'sgs\n , 'bp_chals\n , 'messages_for_next_wrap_proof\n , 'prev_evals )\n t =\n { statement :\n ( 'unfinalized_proofs\n , ('s, 'sgs, 'bp_chals) Messages_for_next_proof_over_same_field.Step.t\n , 'messages_for_next_wrap_proof )\n Types.Step.Statement.t\n ; index : int\n ; prev_evals : 'prev_evals\n ; proof : Tick.Proof.t\n }\n end\n\n module Wrap = struct\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V2 = struct\n type ('messages_for_next_wrap_proof, 'messages_for_next_step_proof) t =\n ( 'messages_for_next_wrap_proof\n , 'messages_for_next_step_proof )\n Mina_wire_types.Pickles.Concrete_.Proof.Base.Wrap.V2.t =\n { statement :\n ( Limb_vector.Constant.Hex64.Stable.V1.t\n Vector.Vector_2.Stable.V1.t\n , Limb_vector.Constant.Hex64.Stable.V1.t\n Vector.Vector_2.Stable.V1.t\n Scalar_challenge.Stable.V2.t\n , Tick.Field.Stable.V1.t Shifted_value.Type1.Stable.V1.t\n , bool\n , 'messages_for_next_wrap_proof\n , Digest.Constant.Stable.V1.t\n , 'messages_for_next_step_proof\n , Limb_vector.Constant.Hex64.Stable.V1.t\n Vector.Vector_2.Stable.V1.t\n Scalar_challenge.Stable.V2.t\n Bulletproof_challenge.Stable.V1.t\n Step_bp_vec.Stable.V1.t\n , Branch_data.Stable.V1.t )\n Types.Wrap.Statement.Minimal.Stable.V1.t\n ; prev_evals :\n ( Tick.Field.Stable.V1.t\n , Tick.Field.Stable.V1.t array )\n Plonk_types.All_evals.Stable.V1.t\n ; proof : Wrap_wire_proof.Stable.V1.t\n }\n [@@deriving compare, sexp, yojson, hash, equal]\n end\n end]\n\n type ('messages_for_next_wrap_proof, 'messages_for_next_step_proof) t =\n ( 'messages_for_next_wrap_proof\n , 'messages_for_next_step_proof )\n Stable.Latest.t =\n { statement :\n ( Challenge.Constant.t\n , Challenge.Constant.t Scalar_challenge.t\n , Tick.Field.t Shifted_value.Type1.t\n , bool\n , 'messages_for_next_wrap_proof\n , Digest.Constant.t\n , 'messages_for_next_step_proof\n , Challenge.Constant.t Scalar_challenge.t Bulletproof_challenge.t\n Step_bp_vec.t\n , Branch_data.t )\n Types.Wrap.Statement.Minimal.t\n ; prev_evals : (Tick.Field.t, Tick.Field.t array) Plonk_types.All_evals.t\n ; proof : Wrap_wire_proof.t\n }\n [@@deriving compare, sexp, yojson, hash, equal]\n end\nend\n\ntype ('s, 'mlmb, 'c) with_data =\n ('s, 'mlmb, 'c) Mina_wire_types.Pickles.Concrete_.Proof.with_data =\n | T :\n ( 'mlmb Base.Messages_for_next_proof_over_same_field.Wrap.t\n , ( 's\n , (Tock.Curve.Affine.t, 'most_recent_width) Vector.t\n , ( Challenge.Constant.t Scalar_challenge.Stable.Latest.t\n Bulletproof_challenge.t\n Step_bp_vec.t\n , 'most_recent_width )\n Vector.t )\n Base.Messages_for_next_proof_over_same_field.Step.t )\n Base.Wrap.t\n -> ('s, 'mlmb, _) with_data\n\nmodule With_data = struct\n type ('s, 'mlmb, 'w) t = ('s, 'mlmb, 'w) with_data\nend\n\ntype ('max_width, 'mlmb) t = (unit, 'mlmb, 'max_width) With_data.t\n\nlet dummy (type w h r) (_w : w Nat.t) (h : h Nat.t)\n (most_recent_width : r Nat.t) ~domain_log2 : (w, h) t =\n let open Ro in\n let g0 = Tock.Curve.(to_affine_exn one) in\n let g len = Array.create ~len g0 in\n let tick_arr len = Array.init len ~f:(fun _ -> tick ()) in\n let lengths = Commitment_lengths.create ~of_int:Fn.id in\n T\n { statement =\n { proof_state =\n { deferred_values =\n { branch_data =\n { proofs_verified =\n ( match most_recent_width with\n | Z ->\n N0\n | S Z ->\n N1\n | S (S Z) ->\n N2\n | S _ ->\n assert false )\n ; domain_log2 =\n Branch_data.Domain_log2.of_int_exn domain_log2\n }\n ; bulletproof_challenges = Dummy.Ipa.Step.challenges\n ; plonk =\n { alpha = scalar_chal ()\n ; beta = chal ()\n ; gamma = chal ()\n ; zeta = scalar_chal ()\n ; joint_combiner = None\n ; feature_flags = Plonk_types.Features.none_bool\n }\n }\n ; sponge_digest_before_evaluations =\n Digest.Constant.of_tock_field Tock.Field.zero\n ; messages_for_next_wrap_proof =\n { challenge_polynomial_commitment = Lazy.force Dummy.Ipa.Step.sg\n ; old_bulletproof_challenges =\n Vector.init h ~f:(fun _ -> Dummy.Ipa.Wrap.challenges)\n }\n }\n ; messages_for_next_step_proof =\n { app_state = ()\n ; old_bulletproof_challenges =\n (* Not sure if this should be w or h honestly ...*)\n Vector.init most_recent_width ~f:(fun _ ->\n Dummy.Ipa.Step.challenges )\n (* TODO: Should this be wrap? *)\n ; challenge_polynomial_commitments =\n Vector.init most_recent_width ~f:(fun _ ->\n Lazy.force Dummy.Ipa.Wrap.sg )\n }\n }\n ; proof =\n Wrap_wire_proof.of_kimchi_proof\n { messages =\n { w_comm = Vector.map lengths.w ~f:g\n ; z_comm = g lengths.z\n ; t_comm = g lengths.t\n ; lookup = None\n }\n ; openings =\n { proof =\n { lr =\n Array.init (Nat.to_int Tock.Rounds.n) ~f:(fun _ ->\n (g0, g0) )\n ; z_1 = Ro.tock ()\n ; z_2 = Ro.tock ()\n ; delta = g0\n ; challenge_polynomial_commitment = g0\n }\n ; evals = Dummy.evals.evals.evals\n ; ft_eval1 = Dummy.evals.ft_eval1\n }\n }\n ; prev_evals =\n (let e =\n Plonk_types.Evals.map (Evaluation_lengths.create ~of_int:Fn.id)\n ~f:(fun n -> (tick_arr n, tick_arr n))\n in\n let ex =\n { Plonk_types.All_evals.With_public_input.public_input =\n (tick (), tick ())\n ; evals = e\n }\n in\n { ft_eval1 = tick (); evals = ex } )\n }\n\nmodule Make (W : Nat.Intf) (MLMB : Nat.Intf) = struct\n module Max_proofs_verified_at_most = At_most.With_length (W)\n module MLMB_vec = Nvector (MLMB)\n\n module Repr = struct\n type t =\n ( ( Tock.Inner_curve.Affine.t\n , Reduced_messages_for_next_proof_over_same_field.Wrap.Challenges_vector\n .t\n MLMB_vec.t )\n Types.Wrap.Proof_state.Messages_for_next_wrap_proof.t\n , ( unit\n , Tock.Curve.Affine.t Max_proofs_verified_at_most.t\n , Challenge.Constant.t Scalar_challenge.t Bulletproof_challenge.t\n Step_bp_vec.t\n Max_proofs_verified_at_most.t )\n Base.Messages_for_next_proof_over_same_field.Step.t )\n Base.Wrap.t\n [@@deriving compare, sexp, yojson, hash, equal]\n end\n\n type nonrec t = (W.n, MLMB.n) t\n\n let to_repr (T t) : Repr.t =\n let lte =\n Nat.lte_exn\n (Vector.length\n t.statement.messages_for_next_step_proof\n .challenge_polynomial_commitments )\n W.n\n in\n { t with\n statement =\n { t.statement with\n messages_for_next_step_proof =\n { t.statement.messages_for_next_step_proof with\n challenge_polynomial_commitments =\n At_most.of_vector\n t.statement.messages_for_next_step_proof\n .challenge_polynomial_commitments lte\n ; old_bulletproof_challenges =\n At_most.of_vector\n t.statement.messages_for_next_step_proof\n .old_bulletproof_challenges lte\n }\n }\n }\n\n let of_repr (r : Repr.t) : t =\n let (Vector.T challenge_polynomial_commitments) =\n At_most.to_vector\n r.statement.messages_for_next_step_proof\n .challenge_polynomial_commitments\n in\n let (Vector.T old_bulletproof_challenges) =\n At_most.to_vector\n r.statement.messages_for_next_step_proof.old_bulletproof_challenges\n in\n let T =\n Nat.eq_exn\n (Vector.length challenge_polynomial_commitments)\n (Vector.length old_bulletproof_challenges)\n in\n T\n { r with\n statement =\n { r.statement with\n messages_for_next_step_proof =\n { r.statement.messages_for_next_step_proof with\n challenge_polynomial_commitments\n ; old_bulletproof_challenges\n }\n }\n }\n\n let compare t1 t2 = Repr.compare (to_repr t1) (to_repr t2)\n\n let equal t1 t2 = Repr.equal (to_repr t1) (to_repr t2)\n\n let hash_fold_t s t = Repr.hash_fold_t s (to_repr t)\n\n let hash t = Repr.hash (to_repr t)\n\n include\n Sexpable.Of_sexpable\n (Repr)\n (struct\n type nonrec t = t\n\n let to_sexpable = to_repr\n\n let of_sexpable = of_repr\n end)\n\n let to_base64 t =\n (* assume call to Nat.lte_exn does not raise with a valid instance of t *)\n let sexp = sexp_of_t t in\n (* raises only on invalid optional arguments *)\n Base64.encode_exn (Sexp.to_string sexp)\n\n let of_base64 b64 =\n match Base64.decode b64 with\n | Ok t -> (\n try Ok (t_of_sexp (Sexp.of_string t))\n with exn -> Error (Exn.to_string exn) )\n | Error (`Msg s) ->\n Error s\n\n let to_yojson_full x = Repr.to_yojson (to_repr x)\n\n let to_yojson x = `String (to_base64 x)\n\n let of_yojson = function\n | `String x ->\n of_base64 x\n | _ ->\n Error \"Invalid json for proof. Expecting base64 encoded string\"\nend\n\nmodule Proofs_verified_2 = struct\n module T = Make (Nat.N2) (Nat.N2)\n\n module Repr = struct\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V2 = struct\n type t =\n ( ( Tock.Inner_curve.Affine.Stable.V1.t\n , Reduced_messages_for_next_proof_over_same_field.Wrap\n .Challenges_vector\n .Stable\n .V2\n .t\n Vector.Vector_2.Stable.V1.t )\n Types.Wrap.Proof_state.Messages_for_next_wrap_proof.Stable.V1.t\n , ( unit\n , Tock.Curve.Affine.t At_most.At_most_2.Stable.V1.t\n , Limb_vector.Constant.Hex64.Stable.V1.t Vector.Vector_2.Stable.V1.t\n Scalar_challenge.Stable.V2.t\n Bulletproof_challenge.Stable.V1.t\n Step_bp_vec.Stable.V1.t\n At_most.At_most_2.Stable.V1.t )\n Base.Messages_for_next_proof_over_same_field.Step.Stable.V1.t )\n Base.Wrap.Stable.V2.t\n [@@deriving compare, sexp, yojson, hash, equal]\n\n let to_latest = Fn.id\n end\n end]\n\n include T.Repr\n\n (* Force the typechecker to verify that these types are equal. *)\n let (_ : (t, Stable.Latest.t) Type_equal.t) = Type_equal.T\n end\n\n [%%versioned_binable\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V2 = struct\n type t = T.t\n\n let to_latest = Fn.id\n\n include (T : module type of T with type t := t with module Repr := T.Repr)\n\n include\n Binable.Of_binable\n (Repr.Stable.V2)\n (struct\n type nonrec t = t\n\n let to_binable = to_repr\n\n let of_binable = of_repr\n end)\n end\n end]\n\n include (T : module type of T with module Repr := T.Repr)\nend\n\nmodule Proofs_verified_max = struct\n module T =\n Make\n (Side_loaded_verification_key.Width.Max)\n (Side_loaded_verification_key.Width.Max)\n\n module Repr = struct\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V2 = struct\n type t =\n ( ( Tock.Inner_curve.Affine.Stable.V1.t\n , Reduced_messages_for_next_proof_over_same_field.Wrap\n .Challenges_vector\n .Stable\n .V2\n .t\n Side_loaded_verification_key.Width.Max_vector.Stable.V1.t )\n Types.Wrap.Proof_state.Messages_for_next_wrap_proof.Stable.V1.t\n , ( unit\n , Tock.Curve.Affine.t\n Side_loaded_verification_key.Width.Max_at_most.Stable.V1.t\n , Limb_vector.Constant.Hex64.Stable.V1.t Vector.Vector_2.Stable.V1.t\n Scalar_challenge.Stable.V2.t\n Bulletproof_challenge.Stable.V1.t\n Step_bp_vec.Stable.V1.t\n Side_loaded_verification_key.Width.Max_at_most.Stable.V1.t )\n Base.Messages_for_next_proof_over_same_field.Step.Stable.V1.t )\n Base.Wrap.Stable.V2.t\n [@@deriving compare, sexp, yojson, hash, equal]\n\n let to_latest = Fn.id\n end\n end]\n\n include T.Repr\n\n (* Force the typechecker to verify that these types are equal. *)\n let (_ : (t, Stable.Latest.t) Type_equal.t) = Type_equal.T\n end\n\n [%%versioned_binable\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V2 = struct\n type t = T.t\n\n let to_latest = Fn.id\n\n include (T : module type of T with type t := t with module Repr := T.Repr)\n\n include\n Binable.Of_binable\n (Repr.Stable.V2)\n (struct\n type nonrec t = t\n\n let to_binable = to_repr\n\n let of_binable = of_repr\n end)\n end\n end]\n\n include (T : module type of T with module Repr := T.Repr)\nend\n","open Core_kernel\nopen Backend\nmodule Me = Tock\nmodule Other = Tick\nmodule Impl = Impls.Wrap\n\nlet _high_entropy_bits = 128\n\nlet sponge_params_constant =\n Sponge.Params.(map pasta_q_kimchi ~f:Impl.Field.Constant.of_string)\n\nlet field_random_oracle ?(length = Me.Field.size_in_bits - 1) s =\n Me.Field.of_bits (Ro.bits_random_oracle ~length s)\n\nlet _unrelated_g =\n let open Common in\n let group_map =\n unstage\n (group_map\n (module Me.Field)\n ~a:Me.Inner_curve.Params.a ~b:Me.Inner_curve.Params.b )\n and str = Fn.compose bits_to_bytes Me.Field.to_bits in\n fun (x, y) -> group_map (field_random_oracle (str x ^ str y))\n\nopen Impl\n\n(* Debug helper to convert wrap circuit field element to a hex string *)\nlet read_wrap_circuit_field_element_as_hex fe =\n let prover_fe = As_prover.read Field.typ fe in\n Kimchi_backend.Pasta.Pallas_based_plonk.(\n Bigint.to_hex (Field.to_bigint prover_fe))\n\nmodule Other_field = struct\n type t = Impls.Step.Field.Constant.t [@@deriving sexp]\n\n include (Tick.Field : module type of Tick.Field with type t := t)\n\n let size = Impls.Step.Bigint.to_bignum_bigint size\nend\n\nlet sponge_params =\n Sponge.Params.(map sponge_params_constant ~f:Impl.Field.constant)\n\nmodule Unsafe = struct\n let unpack_unboolean ?(length = Field.size_in_bits) x =\n let res =\n exists\n (Typ.list Boolean.typ_unchecked ~length)\n ~compute:\n As_prover.(\n fun () -> List.take (Field.Constant.unpack (read_var x)) length)\n in\n Field.Assert.equal x (Field.project res) ;\n res\nend\n\nmodule Sponge = struct\n module Permutation =\n Sponge_inputs.Make\n (Impl)\n (struct\n include Tock_field_sponge.Inputs\n\n let params = Tock_field_sponge.params\n end)\n\n module S = Sponge.Make_debug_sponge (struct\n include Permutation\n module Circuit = Impls.Wrap\n\n (* Optional sponge name used in debug mode *)\n let sponge_name = \"wrap\"\n\n (* To enable debug mode, set environment variable [sponge_name] to \"t\", \"1\" or \"true\". *)\n let debug_helper_fn = read_wrap_circuit_field_element_as_hex\n end)\n\n include S\n\n let squeeze_field = squeeze\n\n let squeeze = squeeze\nend\n\nlet%test_unit \"sponge\" =\n let module T = Make_sponge.Test (Impl) (Tock_field_sponge.Field) (Sponge.S) in\n T.test Tock_field_sponge.params\n\n(* module Input_domain = struct\n let _lagrange_commitments domain : Backend.Tock.Inner_curve.Affine.t array =\n let domain_size = Import.Domain.size domain in\n Common.time \"lagrange\" (fun () ->\n Array.init domain_size ~f:(fun i ->\n (Kimchi_bindings.Protocol.SRS.Fp.lagrange_commitment\n (Backend.Tick.Keypair.load_urs ())\n domain_size i )\n .unshifted.(0)\n |> Common.finite_exn ) )\n\n let _domain = Import.Domain.Pow_2_roots_of_unity 7\n end *)\n\nmodule Inner_curve = struct\n module C = Kimchi_pasta.Pasta.Vesta\n\n module Inputs = struct\n module Impl = Impl\n\n module Params = struct\n include C.Params\n\n let one = C.to_affine_exn C.one\n\n let group_size_in_bits = Field.size_in_bits\n end\n\n module F = struct\n include struct\n open Impl.Field\n\n type nonrec t = t\n\n let ( * ), ( + ), ( - ), inv_exn, square, scale, if_, typ, constant =\n (( * ), ( + ), ( - ), inv, square, scale, if_, typ, constant)\n\n let negate x = scale x Constant.(negate one)\n end\n\n module Constant = struct\n open Impl.Field.Constant\n\n type nonrec t = t\n\n let ( * ), ( + ), ( - ), inv_exn, square, negate =\n (( * ), ( + ), ( - ), inv, square, negate)\n end\n\n let assert_square x y = Impl.assert_square x y\n\n let assert_r1cs x y z = Impl.assert_r1cs x y z\n end\n\n module Constant = struct\n include C.Affine\n module Scalar = Impls.Step.Field.Constant\n\n let scale (t : t) (x : Scalar.t) : t =\n C.(to_affine_exn (scale (of_affine t) x))\n\n let random () : t = C.(to_affine_exn (random ()))\n\n let zero = Impl.Field.Constant.(zero, zero)\n\n let ( + ) t1 t2 : t =\n let is_zero (x, _) = Impl.Field.Constant.(equal zero x) in\n if is_zero t1 then t2\n else if is_zero t2 then t1\n else\n let r = C.(of_affine t1 + of_affine t2) in\n try C.to_affine_exn r with _ -> zero\n\n let negate x : t = C.(to_affine_exn (negate (of_affine x)))\n\n let to_affine_exn = Fn.id\n\n let of_affine = Fn.id\n end\n end\n\n module Params = Inputs.Params\n module Constant = Inputs.Constant\n module T = Snarky_curve.For_native_base_field (Inputs)\n\n include (\n T :\n module type of T\n with module Scaling_precomputation := T.Scaling_precomputation )\n\n module Scaling_precomputation = T.Scaling_precomputation\n\n let ( + ) t1 t2 = Plonk_curve_ops.add_fast (module Impl) t1 t2\n\n let double t = t + t\n\n let scale t bs =\n with_label __LOC__ (fun () ->\n T.scale t (Bitstring_lib.Bitstring.Lsb_first.of_list bs) )\n\n let to_field_elements (x, y) = [ x; y ]\n\n let assert_equal (x1, y1) (x2, y2) =\n Field.Assert.equal x1 x2 ; Field.Assert.equal y1 y2\n\n let scale_inv t bs =\n let res =\n exists typ\n ~compute:\n As_prover.(\n fun () ->\n C.scale\n (C.of_affine (read typ t))\n (Other.Field.inv\n (Other.Field.of_bits (List.map ~f:(read Boolean.typ) bs)) )\n |> C.to_affine_exn)\n in\n assert_equal t (scale res bs) ;\n res\n\n let negate = T.negate\n\n let one = T.one\n\n let if_ = T.if_\nend\n\nmodule Ops = Plonk_curve_ops.Make (Impl) (Inner_curve)\n\nmodule Generators = struct\n let h =\n lazy\n ( Kimchi_bindings.Protocol.SRS.Fp.urs_h (Backend.Tick.Keypair.load_urs ())\n |> Common.finite_exn )\nend\n","module S = Sponge\nopen Core_kernel\nopen Util\nmodule SC = Scalar_challenge\nopen Pickles_types\nopen Plonk_types\nopen Tuple_lib\nopen Import\n\n(* G is for Generic. This module is just to protect {!val:challenge_polynomial}\n below from being hidden by the included functor application at the end of\n the module, so that we can re-export it in the end. *)\nmodule G = struct\n let lookup_verification_enabled = false\n\n (* given [chals], compute\n \\prod_i (1 + chals.(i) * x^{2^{k - 1 - i}}) *)\n let challenge_polynomial (type a)\n (module M : Pickles_types.Shifted_value.Field_intf with type t = a) chals\n : (a -> a) Staged.t =\n stage (fun pt ->\n let k = Array.length chals in\n let pow_two_pows =\n let res = Array.init k ~f:(fun _ -> pt) in\n for i = 1 to k - 1 do\n let y = res.(i - 1) in\n res.(i) <- M.(y * y)\n done ;\n res\n in\n let prod f =\n let r = ref (f 0) in\n for i = 1 to k - 1 do\n r := M.(f i * !r)\n done ;\n !r\n in\n prod (fun i ->\n let idx = k - 1 - i in\n M.(one + (chals.(i) * pow_two_pows.(idx))) ) )\n\n let num_possible_domains = Nat.S Wrap_hack.Padded_length.n\n\n let all_possible_domains =\n Memo.unit (fun () ->\n Vector.init num_possible_domains ~f:(fun proofs_verified ->\n (Common.wrap_domains ~proofs_verified).h ) )\nend\n\nmodule Make\n (Inputs : Intf.Wrap_main_inputs.S\n with type Impl.field = Backend.Tock.Field.t\n and type Impl.Bigint.t = Backend.Tock.Bigint.t\n and type Inner_curve.Constant.Scalar.t = Backend.Tick.Field.t) =\nstruct\n open Inputs\n open Impl\n\n module Other_field = struct\n module Packed = struct\n module Constant = Other_field\n\n type t = Impls.Wrap.Other_field.t\n\n let typ = Impls.Wrap.Other_field.typ\n\n let _to_bits_unsafe (x : t) = Wrap_main_inputs.Unsafe.unpack_unboolean x\n\n let absorb_shifted sponge (x : t Shifted_value.Type1.t) =\n match x with Shifted_value x -> Sponge.absorb sponge x\n end\n\n module With_top_bit0 = struct\n (* When the top bit is 0, there is no need to check that this is not\n equal to one of the forbidden values. The scaling is safe. *)\n module Constant = Other_field\n\n type t = Impls.Wrap.Other_field.t\n\n let typ = Impls.Wrap.Other_field.typ_unchecked\n\n let _absorb_shifted sponge (x : t Pickles_types.Shifted_value.Type1.t) =\n match x with Shifted_value x -> Sponge.absorb sponge x\n end\n end\n\n let num_possible_domains = G.num_possible_domains\n\n let all_possible_domains = G.all_possible_domains\n\n let print_g lab (x, y) =\n if debug then\n as_prover\n As_prover.(\n fun () ->\n printf\n !\"%s: %{sexp:Backend.Tock.Field.t}, %{sexp:Backend.Tock.Field.t}\\n\\\n %!\"\n lab (read_var x) (read_var y))\n\n let _print_w lab gs =\n if Import.debug then\n Array.iteri gs ~f:(fun i (fin, g) ->\n as_prover\n As_prover.(fun () -> printf \"fin=%b %!\" (read Boolean.typ fin)) ;\n ksprintf print_g \"%s[%d]\" lab i g )\n\n let _print_chal lab x =\n if Import.debug then\n as_prover\n As_prover.(\n fun () ->\n printf \"in-snark %s:%!\" lab ;\n Field.Constant.print\n (Field.Constant.project (List.map ~f:(read Boolean.typ) x)) ;\n printf \"\\n%!\")\n\n let print_bool lab x =\n if debug then\n as_prover (fun () ->\n printf \"%s: %b\\n%!\" lab (As_prover.read Boolean.typ x) )\n\n module Challenge = Challenge.Make (Impl)\n module Digest = Digest.Make (Impl)\n module Scalar_challenge =\n SC.Make (Impl) (Inner_curve) (Challenge) (Endo.Wrap_inner_curve)\n module Ops = Plonk_curve_ops.Make (Impl) (Inner_curve)\n\n let _product m f =\n Core_kernel.List.reduce_exn (Core_kernel.List.init m ~f) ~f:Field.( * )\n\n let absorb sponge ty t =\n absorb\n ~mask_g1_opt:(fun () -> assert false)\n ~absorb_field:(Sponge.absorb sponge)\n ~g1_to_field_elements:Inner_curve.to_field_elements\n ~absorb_scalar:(Sponge.absorb sponge) ty t\n\n let scalar_to_field s =\n SC.to_field_checked (module Impl) s ~endo:Endo.Step_inner_curve.scalar\n\n let assert_n_bits ~n a =\n (* Scalar_challenge.to_field_checked has the side effect of\n checking that the input fits in n bits. *)\n ignore\n ( SC.to_field_checked\n (module Impl)\n (Import.Scalar_challenge.create a)\n ~endo:Endo.Step_inner_curve.scalar ~num_bits:n\n : Field.t )\n\n let lowest_128_bits ~constrain_low_bits x =\n let assert_128_bits = assert_n_bits ~n:128 in\n Util.lowest_128_bits ~constrain_low_bits ~assert_128_bits (module Impl) x\n\n let squeeze_challenge sponge : Field.t =\n lowest_128_bits (* I think you may not have to constrain these actually *)\n ~constrain_low_bits:true (Sponge.squeeze sponge)\n\n let squeeze_scalar sponge : Field.t Import.Scalar_challenge.t =\n (* No need to boolean constrain scalar challenges. *)\n Import.Scalar_challenge.create\n (lowest_128_bits ~constrain_low_bits:false (Sponge.squeeze sponge))\n\n let bullet_reduce sponge gammas =\n let absorb t = absorb sponge t in\n let prechallenges =\n Array.map gammas ~f:(fun gammas_i ->\n absorb (PC :: PC) gammas_i ;\n squeeze_scalar sponge )\n in\n let term_and_challenge (l, r) pre =\n let left_term = Scalar_challenge.endo_inv l pre in\n let right_term = Scalar_challenge.endo r pre in\n (Ops.add_fast left_term right_term, Bulletproof_challenge.unpack pre)\n in\n let terms, challenges =\n Array.map2_exn gammas prechallenges ~f:term_and_challenge |> Array.unzip\n in\n\n (Array.reduce_exn terms ~f:(Ops.add_fast ?check_finite:None), challenges)\n\n let equal_g g1 g2 =\n List.map2_exn ~f:Field.equal\n (Inner_curve.to_field_elements g1)\n (Inner_curve.to_field_elements g2)\n |> Boolean.all\n\n module One_hot_vector = One_hot_vector.Make (Impl)\n\n type 'a index' = 'a Plonk_verification_key_evals.t\n\n (* Mask out the given vector of indices with the given one-hot vector *)\n let choose_key :\n type n.\n n One_hot_vector.t\n -> (Inner_curve.t index', n) Vector.t\n -> Inner_curve.t index' =\n let open Tuple_lib in\n let map = Plonk_verification_key_evals.map in\n let map2 = Plonk_verification_key_evals.map2 in\n fun bs keys ->\n let open Field in\n Vector.map2\n (bs :> (Boolean.var, n) Vector.t)\n keys\n ~f:(fun b key -> map key ~f:(fun g -> Double.map g ~f:(( * ) (b :> t))))\n |> Vector.reduce_exn ~f:(map2 ~f:(Double.map2 ~f:( + )))\n |> map ~f:(fun g -> Double.map ~f:(Util.seal (module Impl)) g)\n\n (* TODO: Unify with the code in step_verifier *)\n let lagrange (type n)\n ~domain:\n ( (which_branch : n One_hot_vector.t)\n , (domains : (Domains.t, n) Vector.t) ) srs i =\n Vector.map domains ~f:(fun d ->\n let d = Int.pow 2 (Domain.log2_size d.h) in\n match[@warning \"-4\"]\n (Kimchi_bindings.Protocol.SRS.Fp.lagrange_commitment srs d i)\n .unshifted\n with\n | [| Finite g |] ->\n let g = Inner_curve.Constant.of_affine g in\n Inner_curve.constant g\n | _ ->\n assert false )\n |> Vector.map2\n (which_branch :> (Boolean.var, n) Vector.t)\n ~f:(fun b (x, y) -> Field.((b :> t) * x, (b :> t) * y))\n |> Vector.reduce_exn ~f:(Double.map2 ~f:Field.( + ))\n\n let scaled_lagrange (type n) c\n ~domain:\n ( (which_branch : n One_hot_vector.t)\n , (domains : (Domains.t, n) Vector.t) ) srs i =\n Vector.map domains ~f:(fun d ->\n let d = Int.pow 2 (Domain.log2_size d.h) in\n match[@warning \"-4\"]\n (Kimchi_bindings.Protocol.SRS.Fp.lagrange_commitment srs d i)\n .unshifted\n with\n | [| Finite g |] ->\n let g = Inner_curve.Constant.of_affine g in\n Inner_curve.Constant.scale g c |> Inner_curve.constant\n | _ ->\n assert false )\n |> Vector.map2\n (which_branch :> (Boolean.var, n) Vector.t)\n ~f:(fun b (x, y) -> Field.((b :> t) * x, (b :> t) * y))\n |> Vector.reduce_exn ~f:(Double.map2 ~f:Field.( + ))\n\n let lagrange_with_correction (type n) ~input_length\n ~domain:\n ( (which_branch : n One_hot_vector.t)\n , (domains : (Domains.t, n) Vector.t) ) srs i : Inner_curve.t Double.t =\n with_label __LOC__ (fun () ->\n let actual_shift =\n (* TODO: num_bits should maybe be input_length - 1. *)\n Ops.bits_per_chunk * Ops.chunks_needed ~num_bits:input_length\n in\n let rec pow2pow x i =\n if i = 0 then x else pow2pow Inner_curve.Constant.(x + x) (i - 1)\n in\n let base_and_correction (h : Domain.t) =\n let d = Int.pow 2 (Domain.log2_size h) in\n match[@warning \"-4\"]\n (Kimchi_bindings.Protocol.SRS.Fp.lagrange_commitment srs d i)\n .unshifted\n with\n | [| Finite g |] ->\n let open Inner_curve.Constant in\n let g = of_affine g in\n ( Inner_curve.constant g\n , Inner_curve.constant (negate (pow2pow g actual_shift)) )\n | xs ->\n failwithf \"expected commitment to have length 1. got %d\"\n (Array.length xs) ()\n in\n match domains with\n | [] ->\n assert false\n | d :: ds ->\n if Vector.for_all ds ~f:(fun d' -> Domain.equal d.h d'.h) then\n base_and_correction d.h\n else\n Vector.map domains ~f:(fun (ds : Domains.t) ->\n base_and_correction ds.h )\n |> Vector.map2\n (which_branch :> (Boolean.var, n) Vector.t)\n ~f:(fun b pr ->\n Double.map pr ~f:(fun (x, y) ->\n Field.((b :> t) * x, (b :> t) * y) ) )\n |> Vector.reduce_exn\n ~f:(Double.map2 ~f:(Double.map2 ~f:Field.( + )))\n |> Double.map ~f:(Double.map ~f:(Util.seal (module Impl))) )\n\n let _h_precomp =\n Lazy.map ~f:Inner_curve.Scaling_precomputation.create Generators.h\n\n let group_map =\n let f =\n lazy\n (let module M =\n Group_map.Bw19.Make (Field.Constant) (Field)\n (struct\n let params =\n Group_map.Bw19.Params.create\n (module Field.Constant)\n { b = Inner_curve.Params.b }\n end)\n in\n let open M in\n Snarky_group_map.Checked.wrap\n (module Impl)\n ~potential_xs\n ~y_squared:(fun ~x ->\n Field.(\n (x * x * x)\n + (constant Inner_curve.Params.a * x)\n + constant Inner_curve.Params.b) )\n |> unstage )\n in\n fun x -> Lazy.force f x\n\n module Split_commitments = struct\n module Point = struct\n type t =\n [ `Finite of Inner_curve.t\n | `Maybe_finite of Boolean.var * Inner_curve.t ]\n\n let finite : t -> Boolean.var = function\n | `Finite _ ->\n Boolean.true_\n | `Maybe_finite (b, _) ->\n b\n\n let add (p : t) (q : Inner_curve.t) =\n match p with\n | `Finite p ->\n Ops.add_fast p q\n | `Maybe_finite (finite, p) ->\n Inner_curve.if_ finite ~then_:(Ops.add_fast p q) ~else_:q\n\n let underlying = function `Finite p -> p | `Maybe_finite (_, p) -> p\n end\n\n module Curve_opt = struct\n type t = { point : Inner_curve.t; non_zero : Boolean.var }\n end\n\n let combine batch ~xi without_bound with_bound =\n let { Curve_opt.non_zero; point } =\n Pcs_batch.combine_split_commitments batch\n ~scale_and_add:(fun ~(acc : Curve_opt.t) ~xi (keep, (p : Point.t)) ->\n (* match acc.non_zero, keep with\n | false, false -> acc\n | true, false -> acc\n | false, true -> { point= p; non_zero= true }\n | true, true -> { point= p + xi * acc; non_zero= true }\n *)\n let point =\n Inner_curve.(\n if_ keep\n ~then_:\n (if_ acc.non_zero\n ~then_:(Point.add p (Scalar_challenge.endo acc.point xi))\n ~else_:\n ((* In this branch, the accumulator was zero, so there is no harm in\n putting the potentially junk underlying point here. *)\n Point.underlying p ) )\n ~else_:acc.point)\n in\n let non_zero = Boolean.(keep &&& Point.finite p ||| acc.non_zero) in\n { Curve_opt.non_zero; point } )\n ~xi\n ~init:(fun (keep, p) ->\n { non_zero = Boolean.(keep &&& Point.finite p)\n ; point = Point.underlying p\n } )\n without_bound with_bound\n in\n Boolean.Assert.is_true non_zero ;\n point\n end\n\n let scale_fast = Ops.scale_fast\n\n let check_bulletproof ~pcs_batch ~(sponge : Sponge.t)\n ~(xi : Scalar_challenge.t)\n ~(advice :\n Other_field.Packed.t Shifted_value.Type1.t\n Types.Step.Bulletproof.Advice.t )\n ~polynomials:(without_degree_bound, with_degree_bound)\n ~openings_proof:\n ({ lr; delta; z_1; z_2; challenge_polynomial_commitment } :\n ( Inner_curve.t\n , Other_field.Packed.t Shifted_value.Type1.t )\n Openings.Bulletproof.t ) =\n with_label __LOC__ (fun () ->\n Other_field.Packed.absorb_shifted sponge advice.combined_inner_product ;\n (* combined_inner_product should be equal to\n sum_i < t, r^i pows(beta_i) >\n = sum_i r^i < t, pows(beta_i) >\n\n That is checked later.\n *)\n let u =\n let t = Sponge.squeeze_field sponge in\n group_map t\n in\n let open Inner_curve in\n let combined_polynomial (* Corresponds to xi in figure 7 of WTS *) =\n Split_commitments.combine pcs_batch ~xi without_degree_bound\n with_degree_bound\n in\n let scale_fast =\n scale_fast ~num_bits:Other_field.Packed.Constant.size_in_bits\n in\n let lr_prod, challenges = bullet_reduce sponge lr in\n let p_prime =\n let uc = scale_fast u advice.combined_inner_product in\n combined_polynomial + uc\n in\n let q = p_prime + lr_prod in\n absorb sponge PC delta ;\n let c = squeeze_scalar sponge in\n (* c Q + delta = z1 (G + b U) + z2 H *)\n let lhs =\n let cq = Scalar_challenge.endo q c in\n cq + delta\n in\n let rhs =\n let b_u = scale_fast u advice.b in\n let z_1_g_plus_b_u =\n scale_fast (challenge_polynomial_commitment + b_u) z_1\n in\n let z2_h =\n scale_fast (Inner_curve.constant (Lazy.force Generators.h)) z_2\n in\n z_1_g_plus_b_u + z2_h\n in\n (`Success (equal_g lhs rhs), challenges) )\n\n module Opt = struct\n include Opt_sponge.Make (Impl) (Wrap_main_inputs.Sponge.Permutation)\n\n let challenge (s : t) : Field.t =\n lowest_128_bits (squeeze s) ~constrain_low_bits:true\n\n (* No need to boolean constrain scalar challenges. *)\n let scalar_challenge (s : t) : Scalar_challenge.t =\n Import.Scalar_challenge.create\n (lowest_128_bits (squeeze s) ~constrain_low_bits:false)\n end\n\n (* TODO: This doesn't need to be an opt sponge *)\n let absorb sponge ty t =\n Util.absorb ~absorb_field:(Opt.absorb sponge)\n ~g1_to_field_elements:(fun (b, (x, y)) -> [ (b, x); (b, y) ])\n ~absorb_scalar:(fun x -> Opt.absorb sponge (Boolean.true_, x))\n ~mask_g1_opt:(fun ((finite : Boolean.var), (x, y)) ->\n (Boolean.true_, Field.((finite :> t) * x, (finite :> t) * y)) )\n ty t\n\n module Pseudo = Pseudo.Make (Impl)\n\n let mask (type n) (lengths : (int, n) Vector.t) (choice : n One_hot_vector.t)\n : Boolean.var array =\n let max =\n Option.value_exn\n (List.max_elt ~compare:Int.compare (Vector.to_list lengths))\n in\n let length = Pseudo.choose (choice, lengths) ~f:Field.of_int in\n let (T max) = Nat.of_int max in\n Vector.to_array (ones_vector (module Impl) ~first_zero:length max)\n\n module Plonk = Types.Wrap.Proof_state.Deferred_values.Plonk\n\n (* Just for exhaustiveness over fields *)\n let iter2 ~chal ~scalar_chal\n { Plonk.Minimal.alpha = alpha_0\n ; beta = beta_0\n ; gamma = gamma_0\n ; zeta = zeta_0\n ; joint_combiner = _\n ; feature_flags = _\n }\n { Plonk.Minimal.alpha = alpha_1\n ; beta = beta_1\n ; gamma = gamma_1\n ; zeta = zeta_1\n ; joint_combiner = _\n ; feature_flags = _\n } =\n if G.lookup_verification_enabled then failwith \"Wrap_verifier.iter2:TODO\" ;\n with_label __LOC__ (fun () -> chal beta_0 beta_1) ;\n with_label __LOC__ (fun () -> chal gamma_0 gamma_1) ;\n with_label __LOC__ (fun () -> scalar_chal alpha_0 alpha_1) ;\n with_label __LOC__ (fun () -> scalar_chal zeta_0 zeta_1)\n\n let assert_eq_plonk\n (m1 : (_, Field.t Import.Scalar_challenge.t, _) Plonk.Minimal.t)\n (m2 : (_, Scalar_challenge.t, _) Plonk.Minimal.t) =\n iter2 m1 m2\n ~chal:(fun c1 c2 -> Field.Assert.equal c1 c2)\n ~scalar_chal:(fun ({ inner = t1 } : _ Import.Scalar_challenge.t)\n ({ inner = t2 } : Scalar_challenge.t) ->\n Field.Assert.equal t1 t2 )\n\n let incrementally_verify_proof (type b)\n (module Max_proofs_verified : Nat.Add.Intf with type n = b)\n ~actual_proofs_verified_mask ~step_domains ~srs\n ~verification_key:(m : _ Plonk_verification_key_evals.t) ~xi ~sponge\n ~(public_input :\n [ `Field of Field.t * Boolean.var | `Packed_bits of Field.t * int ]\n array ) ~(sg_old : (_, Max_proofs_verified.n) Vector.t) ~advice\n ~(messages : _ Messages.In_circuit.t) ~which_branch ~openings_proof\n ~(plonk : _ Types.Wrap.Proof_state.Deferred_values.Plonk.In_circuit.t) =\n let T = Max_proofs_verified.eq in\n let sg_old =\n with_label __LOC__ (fun () ->\n Vector.map2 actual_proofs_verified_mask sg_old ~f:(fun keep sg ->\n [| (keep, sg) |] ) )\n in\n with_label __LOC__ (fun () ->\n let sample () = Opt.challenge sponge in\n let sample_scalar () : Scalar_challenge.t =\n Opt.scalar_challenge sponge\n in\n let index_digest =\n with_label \"absorb verifier index\" (fun () ->\n let index_sponge = Sponge.create sponge_params in\n Array.iter\n (Types.index_to_field_elements\n ~g:(fun (z : Inputs.Inner_curve.t) ->\n List.to_array (Inner_curve.to_field_elements z) )\n m )\n ~f:(fun x -> Sponge.absorb index_sponge x) ;\n Sponge.squeeze_field index_sponge )\n in\n let without = Type.Without_degree_bound in\n let absorb_g gs =\n absorb sponge without (Array.map gs ~f:(fun g -> (Boolean.true_, g)))\n in\n absorb sponge Field (Boolean.true_, index_digest) ;\n Vector.iter ~f:(Array.iter ~f:(absorb sponge PC)) sg_old ;\n let x_hat =\n let domain = (which_branch, step_domains) in\n let public_input =\n Array.concat_map public_input ~f:(function\n | `Field (x, b) ->\n [| `Field (x, Field.size_in_bits)\n ; `Field ((b :> Field.t), 1)\n |]\n | `Packed_bits (x, n) ->\n [| `Field (x, n) |] )\n in\n let constant_part, non_constant_part =\n List.partition_map\n Array.(to_list (mapi public_input ~f:(fun i t -> (i, t))))\n ~f:(fun (i, t) ->\n match[@warning \"-4\"] t with\n | `Field (Constant c, _) ->\n First\n ( if Field.Constant.(equal zero) c then None\n else if Field.Constant.(equal one) c then\n Some (lagrange ~domain srs i)\n else\n Some\n (scaled_lagrange ~domain\n (Inner_curve.Constant.Scalar.project\n (Field.Constant.unpack c) )\n srs i ) )\n | `Field x ->\n Second (i, x) )\n in\n with_label __LOC__ (fun () ->\n let terms =\n List.map non_constant_part ~f:(fun (i, x) ->\n match x with\n | b, 1 ->\n assert_ (Constraint.boolean (b :> Field.t)) ;\n `Cond_add\n (Boolean.Unsafe.of_cvar b, lagrange ~domain srs i)\n | x, n ->\n `Add_with_correction\n ( (x, n)\n , lagrange_with_correction ~input_length:n ~domain srs\n i ) )\n in\n let correction =\n with_label __LOC__ (fun () ->\n List.reduce_exn\n (List.filter_map terms ~f:(function\n | `Cond_add _ ->\n None\n | `Add_with_correction (_, (_, corr)) ->\n Some corr ) )\n ~f:(Ops.add_fast ?check_finite:None) )\n in\n with_label __LOC__ (fun () ->\n let init =\n List.fold\n (List.filter_map ~f:Fn.id constant_part)\n ~init:correction\n ~f:(Ops.add_fast ?check_finite:None)\n in\n List.fold terms ~init ~f:(fun acc term ->\n match term with\n | `Cond_add (b, g) ->\n with_label __LOC__ (fun () ->\n Inner_curve.if_ b ~then_:(Ops.add_fast g acc)\n ~else_:acc )\n | `Add_with_correction ((x, num_bits), (g, _)) ->\n Ops.add_fast acc\n (Ops.scale_fast2'\n (module Other_field.With_top_bit0)\n g x ~num_bits ) ) ) )\n |> Inner_curve.negate\n in\n let x_hat =\n with_label \"x_hat blinding\" (fun () ->\n Ops.add_fast x_hat\n (Inner_curve.constant (Lazy.force Generators.h)) )\n in\n absorb sponge PC (Boolean.true_, x_hat) ;\n let w_comm = messages.w_comm in\n Vector.iter ~f:absorb_g w_comm ;\n let beta = sample () in\n let gamma = sample () in\n let z_comm = messages.z_comm in\n absorb_g z_comm ;\n let alpha = sample_scalar () in\n let t_comm :\n (Inputs.Impl.Field.t * Inputs.Impl.Field.t)\n Pickles_types__Plonk_types.Poly_comm.Without_degree_bound.t =\n messages.t_comm\n in\n absorb_g t_comm ;\n let zeta = sample_scalar () in\n (* At this point, we should use the previous \"bulletproof_challenges\" to\n compute to compute f(beta_1) outside the snark\n where f is the polynomial corresponding to sg_old\n *)\n let sponge =\n match sponge with\n | { state\n ; sponge_state = Squeezed n\n ; params\n ; needs_final_permute_if_empty = _\n } ->\n S.make ~state ~sponge_state:(Squeezed n) ~params\n | { sponge_state = Absorbing _; _ } ->\n assert false\n in\n let sponge_before_evaluations = Sponge.copy sponge in\n let sponge_digest_before_evaluations = Sponge.squeeze_field sponge in\n\n (* xi, r are sampled here using the other sponge. *)\n (* No need to expose the polynomial evaluations as deferred values as they're\n not needed here for the incremental verification. All we need is a_hat and\n \"combined_inner_product\".\n\n Then, in the other proof, we can witness the evaluations and check their correctness\n against \"combined_inner_product\" *)\n let sigma_comm_init, [ _ ] =\n Vector.split m.sigma_comm (snd (Permuts_minus_1.add Nat.N1.n))\n in\n let scale_fast =\n scale_fast ~num_bits:Other_field.Packed.Constant.size_in_bits\n in\n let ft_comm =\n with_label __LOC__ (fun () ->\n Common.ft_comm\n ~add:(Ops.add_fast ?check_finite:None)\n ~scale:scale_fast ~negate:Inner_curve.negate\n ~endoscale:(Scalar_challenge.endo ?num_bits:None)\n ~verification_key:m ~plonk ~alpha ~t_comm )\n in\n let bulletproof_challenges =\n (* This sponge needs to be initialized with (some derivative of)\n 1. The polynomial commitments\n 2. The combined inner product\n 3. The challenge points.\n\n It should be sufficient to fork the sponge after squeezing beta_3 and then to absorb\n the combined inner product.\n *)\n let num_commitments_without_degree_bound = Nat.N45.n in\n let without_degree_bound =\n (* sg_old\n x_hat\n ft_comm\n z_comm\n generic selector\n poseidon selector\n w_comms\n all but last sigma_comm\n *)\n Vector.append sg_old\n ( [| x_hat |] :: [| ft_comm |] :: z_comm :: [| m.generic_comm |]\n :: [| m.psm_comm |] :: [| m.complete_add_comm |]\n :: [| m.mul_comm |] :: [| m.emul_comm |]\n :: [| m.endomul_scalar_comm |]\n :: Vector.append w_comm\n (Vector.append\n (Vector.map m.coefficients_comm ~f:(fun g -> [| g |]))\n (Vector.map sigma_comm_init ~f:(fun g -> [| g |]))\n (snd Plonk_types.(Columns.add Permuts_minus_1.n)) )\n (snd\n Plonk_types.(\n Columns.add (fst (Columns.add Permuts_minus_1.n))) )\n |> Vector.map ~f:(Array.map ~f:(fun g -> (Boolean.true_, g))) )\n (snd\n (Max_proofs_verified.add num_commitments_without_degree_bound) )\n in\n check_bulletproof\n ~pcs_batch:\n (Common.dlog_pcs_batch\n (Max_proofs_verified.add num_commitments_without_degree_bound) )\n ~sponge:sponge_before_evaluations ~xi ~advice ~openings_proof\n ~polynomials:\n ( Vector.map without_degree_bound\n ~f:(Array.map ~f:(fun (keep, x) -> (keep, `Finite x)))\n , [] )\n in\n let joint_combiner =\n if G.lookup_verification_enabled then failwith \"TODO\" else None\n in\n assert_eq_plonk\n { alpha = plonk.alpha\n ; beta = plonk.beta\n ; gamma = plonk.gamma\n ; zeta = plonk.zeta\n ; joint_combiner\n ; feature_flags = plonk.feature_flags\n }\n { alpha\n ; beta\n ; gamma\n ; zeta\n ; joint_combiner\n ; feature_flags = plonk.feature_flags\n } ;\n (sponge_digest_before_evaluations, bulletproof_challenges) )\n\n let _mask_evals (type n)\n ~(lengths :\n (int, n) Pickles_types.Vector.t Pickles_types.Plonk_types.Evals.t )\n (choice : n One_hot_vector.t)\n (e : Field.t array Pickles_types.Plonk_types.Evals.t) :\n (Boolean.var * Field.t) array Pickles_types.Plonk_types.Evals.t =\n Pickles_types.Plonk_types.Evals.map2 lengths e ~f:(fun lengths e ->\n Array.zip_exn (mask lengths choice) e )\n\n let compute_challenges ~scalar chals =\n Vector.map chals ~f:(fun prechallenge ->\n scalar @@ Bulletproof_challenge.pack prechallenge )\n\n let challenge_polynomial = G.challenge_polynomial (module Field)\n\n let pow2pow (pt : Field.t) (n : int) : Field.t =\n with_label __LOC__ (fun () ->\n let rec go acc i =\n if i = 0 then acc else go (Field.square acc) (i - 1)\n in\n go pt n )\n\n let actual_evaluation (e : Field.t array) ~(pt_to_n : Field.t) : Field.t =\n with_label __LOC__ (fun () ->\n match List.rev (Array.to_list e) with\n | e :: es ->\n List.fold ~init:e es ~f:(fun acc y ->\n let acc' =\n exists Field.typ ~compute:(fun () ->\n As_prover.read_var Field.(y + (pt_to_n * acc)) )\n in\n (* acc' = y + pt_n * acc *)\n let pt_n_acc = Field.(pt_to_n * acc) in\n let open\n Kimchi_backend_common.Plonk_constraint_system.Plonk_constraint in\n (* 0 = - acc' + y + pt_n_acc *)\n let open Field.Constant in\n assert_\n { annotation = None\n ; basic =\n T\n (Basic\n { l = (one, y)\n ; r = (one, pt_n_acc)\n ; o = (negate one, acc')\n ; m = zero\n ; c = zero\n } )\n } ;\n acc' )\n | [] ->\n failwith \"empty list\" )\n\n let _shift1 =\n Pickles_types.Shifted_value.Type1.Shift.(\n map ~f:Field.constant (create (module Field.Constant)))\n\n let shift2 =\n Shifted_value.Type2.Shift.(\n map ~f:Field.constant (create (module Field.Constant)))\n\n let%test_unit \"endo scalar\" =\n SC.test (module Impl) ~endo:Endo.Step_inner_curve.scalar\n\n let map_plonk_to_field plonk =\n Types.Step.Proof_state.Deferred_values.Plonk.In_circuit.map_challenges\n ~f:(Util.seal (module Impl))\n ~scalar:scalar_to_field plonk\n |> Types.Step.Proof_state.Deferred_values.Plonk.In_circuit.map_fields\n ~f:(Shifted_value.Type2.map ~f:(Util.seal (module Impl)))\n\n module Plonk_checks = struct\n include Plonk_checks\n include Plonk_checks.Make (Shifted_value.Type2) (Plonk_checks.Scalars.Tock)\n end\n\n (* This finalizes the \"deferred values\" coming from a previous proof over the same field.\n It\n 1. Checks that [xi] and [r] where sampled correctly. I.e., by absorbing all the\n evaluation openings and then squeezing.\n 2. Checks that the \"combined inner product\" value used in the elliptic curve part of\n the opening proof was computed correctly, in terms of the evaluation openings and the\n evaluation points.\n 3. Check that the \"b\" value was computed correctly.\n 4. Perform the arithmetic checks from marlin. *)\n let finalize_other_proof (type b)\n (module Proofs_verified : Nat.Add.Intf with type n = b) ~domain ~sponge\n ~(old_bulletproof_challenges : (_, b) Vector.t)\n ({ xi; combined_inner_product; bulletproof_challenges; b; plonk } :\n ( _\n , _\n , _ Shifted_value.Type2.t\n , _ )\n Types.Step.Proof_state.Deferred_values.In_circuit.t )\n { Plonk_types.All_evals.In_circuit.ft_eval1; evals } =\n let module Plonk = Types.Step.Proof_state.Deferred_values.Plonk in\n let T = Proofs_verified.eq in\n (* You use the NEW bulletproof challenges to check b. Not the old ones. *)\n let open Field in\n let plonk = map_plonk_to_field plonk in\n let zetaw = Field.mul domain#generator plonk.zeta in\n let sg_evals1, sg_evals2 =\n let sg_olds =\n Vector.map old_bulletproof_challenges ~f:(fun chals ->\n unstage (challenge_polynomial (Vector.to_array chals)) )\n in\n let sg_evals pt = Vector.map sg_olds ~f:(fun f -> f pt) in\n (sg_evals plonk.zeta, sg_evals zetaw)\n in\n let sponge_state =\n (* Absorb bulletproof challenges *)\n let challenge_digest =\n let sponge = Sponge.create sponge_params in\n Vector.iter old_bulletproof_challenges\n ~f:(Vector.iter ~f:(Sponge.absorb sponge)) ;\n Sponge.squeeze sponge\n in\n Sponge.absorb sponge challenge_digest ;\n Sponge.absorb sponge ft_eval1 ;\n Sponge.absorb sponge (fst evals.public_input) ;\n Sponge.absorb sponge (snd evals.public_input) ;\n let xs = Evals.In_circuit.to_absorption_sequence evals.evals in\n (* This is a hacky, but much more efficient, version of the opt sponge.\n This uses the assumption that the sponge 'absorption state' will align\n after each optional absorption, letting us skip the expensive tracking\n that this would otherwise require.\n To future-proof this, we assert that the states are indeed compatible.\n *)\n List.iter xs ~f:(fun opt ->\n let absorb = Array.iter ~f:(fun x -> Sponge.absorb sponge x) in\n match opt with\n | None ->\n ()\n | Some (x1, x2) ->\n absorb x1 ; absorb x2\n | Maybe (b, (x1, x2)) ->\n (* Cache the sponge state before *)\n let sponge_state_before = sponge.sponge_state in\n let state_before = Array.copy sponge.state in\n (* Absorb the points *)\n absorb x1 ;\n absorb x2 ;\n (* Check that the sponge ends in a compatible state. *)\n ( match (sponge_state_before, sponge.sponge_state) with\n | Absorbed x, Absorbed y ->\n [%test_eq: int] x y\n | Squeezed x, Squeezed y ->\n [%test_eq: int] x y\n | Absorbed _, Squeezed _ ->\n [%test_eq: string] \"absorbed\" \"squeezed\"\n | Squeezed _, Absorbed _ ->\n [%test_eq: string] \"squeezed\" \"absorbed\" ) ;\n let state =\n Array.map2_exn sponge.state state_before ~f:(fun then_ else_ ->\n Field.if_ b ~then_ ~else_ )\n in\n sponge.state <- state ) ;\n Array.copy sponge.state\n in\n sponge.state <- sponge_state ;\n let xi_actual = squeeze_scalar sponge in\n let r_actual = squeeze_challenge sponge in\n let xi_correct =\n with_label __LOC__ (fun () ->\n let { Import.Scalar_challenge.inner = xi_actual } = xi_actual in\n let { Import.Scalar_challenge.inner = xi } = xi in\n (* Sample new sg challenge point here *)\n Field.equal xi_actual xi )\n in\n let xi = scalar_to_field xi in\n (* TODO: r actually does not need to be a scalar challenge. *)\n let r = scalar_to_field (Import.Scalar_challenge.create r_actual) in\n let plonk_minimal =\n plonk |> Plonk.to_minimal\n |> Plonk.Minimal.to_wrap\n ~feature_flags:Features.(map ~f:Boolean.var_of_value none_bool)\n in\n let combined_evals =\n let n = Common.Max_degree.wrap_log2 in\n (* TODO: zeta_n is recomputed in [env] below *)\n let zeta_n = pow2pow plonk.zeta n in\n let zetaw_n = pow2pow zetaw n in\n Evals.In_circuit.map evals.evals ~f:(fun (x0, x1) ->\n ( actual_evaluation ~pt_to_n:zeta_n x0\n , actual_evaluation ~pt_to_n:zetaw_n x1 ) )\n in\n let env =\n let module Env_bool = struct\n include Boolean\n\n type t = Boolean.var\n end in\n let module Env_field = struct\n include Field\n\n type bool = Env_bool.t\n\n let if_ (b : bool) ~then_ ~else_ =\n match Impl.Field.to_constant (b :> t) with\n | Some x ->\n (* We have a constant, only compute the branch we care about. *)\n if Impl.Field.Constant.(equal one) x then then_ () else else_ ()\n | None ->\n if_ b ~then_:(then_ ()) ~else_:(else_ ())\n end in\n Plonk_checks.scalars_env\n (module Env_bool)\n (module Env_field)\n ~srs_length_log2:Common.Max_degree.wrap_log2\n ~endo:(Impl.Field.constant Endo.Wrap_inner_curve.base)\n ~mds:sponge_params.mds\n ~field_of_hex:(fun s ->\n Kimchi_pasta.Pasta.Bigint256.of_hex_string s\n |> Kimchi_pasta.Pasta.Fq.of_bigint |> Field.constant )\n ~domain plonk_minimal combined_evals\n in\n let combined_inner_product_correct =\n let evals1, evals2 =\n All_evals.With_public_input.In_circuit.factor evals\n in\n with_label __LOC__ (fun () ->\n let ft_eval0 : Field.t =\n with_label __LOC__ (fun () ->\n Plonk_checks.ft_eval0\n (module Field)\n ~env ~domain plonk_minimal combined_evals evals1.public_input )\n in\n (* sum_i r^i sum_j xi^j f_j(beta_i) *)\n let actual_combined_inner_product =\n let combine ~ft ~sg_evals x_hat\n (e : (Field.t array, _) Evals.In_circuit.t) =\n let a =\n Evals.In_circuit.to_list e\n |> List.map ~f:(function\n | None ->\n [||]\n | Some a ->\n Array.map a ~f:(fun x -> Plonk_types.Opt.Some x)\n | Maybe (b, a) ->\n Array.map a ~f:(fun x -> Plonk_types.Opt.Maybe (b, x)) )\n in\n let sg_evals =\n Vector.map sg_evals ~f:(fun x -> [| Plonk_types.Opt.Some x |])\n |> Vector.to_list\n (* TODO: This was the code before the wrap hack was put in\n match actual_proofs_verified with\n | None ->\n Vector.map sg_olds ~f:(fun f -> [| f pt |])\n | Some proofs_verified ->\n let mask =\n ones_vector\n (module Impl)\n ~first_zero:proofs_verified (Vector.length sg_olds)\n in\n with_label __LOC__ (fun () ->\n Vector.map2 mask sg_olds ~f:(fun b f ->\n [| Field.((b :> t) * f pt) |] ) ) *)\n in\n let v =\n List.append sg_evals ([| Some x_hat |] :: [| Some ft |] :: a)\n in\n Common.combined_evaluation (module Impl) ~xi v\n in\n combine ~ft:ft_eval0 ~sg_evals:sg_evals1 evals1.public_input\n evals1.evals\n + r\n * combine ~ft:ft_eval1 ~sg_evals:sg_evals2 evals2.public_input\n evals2.evals\n in\n with_label __LOC__ (fun () ->\n equal\n (Shifted_value.Type2.to_field\n (module Field)\n ~shift:shift2 combined_inner_product )\n actual_combined_inner_product ) )\n in\n let bulletproof_challenges =\n with_label __LOC__ (fun () ->\n compute_challenges ~scalar:scalar_to_field bulletproof_challenges )\n in\n let b_correct =\n with_label __LOC__ (fun () ->\n let challenge_poly =\n unstage\n (challenge_polynomial (Vector.to_array bulletproof_challenges))\n in\n let b_actual =\n challenge_poly plonk.zeta + (r * challenge_poly zetaw)\n in\n equal\n (Shifted_value.Type2.to_field (module Field) ~shift:shift2 b)\n b_actual )\n in\n let plonk_checks_passed =\n with_label __LOC__ (fun () ->\n (* This proof is a wrap proof; no need to consider features. *)\n Plonk_checks.checked\n (module Impl)\n ~env ~shift:shift2\n (Composition_types.Step.Proof_state.Deferred_values.Plonk.In_circuit\n .to_wrap ~opt_none:Plonk_types.Opt.None ~false_:Boolean.false_\n plonk )\n combined_evals )\n in\n print_bool \"xi_correct\" xi_correct ;\n print_bool \"combined_inner_product_correct\" combined_inner_product_correct ;\n print_bool \"plonk_checks_passed\" plonk_checks_passed ;\n print_bool \"b_correct\" b_correct ;\n ( Boolean.all\n [ xi_correct\n ; b_correct\n ; combined_inner_product_correct\n ; plonk_checks_passed\n ]\n , bulletproof_challenges )\n\n let _map_challenges\n { Import.Types.Step.Proof_state.Deferred_values.plonk\n ; combined_inner_product\n ; xi\n ; bulletproof_challenges\n ; b\n } ~f ~scalar =\n { Types.Step.Proof_state.Deferred_values.plonk =\n Types.Step.Proof_state.Deferred_values.Plonk.In_circuit.map_challenges\n plonk ~f ~scalar\n ; combined_inner_product\n ; bulletproof_challenges =\n Vector.map bulletproof_challenges\n ~f:(fun (r : _ Bulletproof_challenge.t) ->\n Bulletproof_challenge.map ~f:scalar r )\n ; xi = scalar xi\n ; b\n }\nend\n\ninclude Make (Wrap_main_inputs)\n\nlet challenge_polynomial = G.challenge_polynomial\n","(* q > p *)\nopen Core_kernel\nmodule SC = Scalar_challenge\nopen Import\nopen Common\nopen Util\nopen Types.Step\nopen Pickles_types\n\nlet lookup_verification_enabled = false\n\nmodule Make\n (Inputs : Intf.Step_main_inputs.S\n with type Impl.field = Backend.Tick.Field.t\n and type Impl.Bigint.t = Backend.Tick.Bigint.t\n and type Inner_curve.Constant.Scalar.t = Backend.Tock.Field.t) =\nstruct\n open Inputs\n open Impl\n module Challenge = Challenge.Make (Impl)\n module Digest = Digest.Make (Impl)\n\n (* Other_field.size > Field.size *)\n module Other_field = struct\n let size_in_bits = Field.size_in_bits\n\n type t = Impls.Step.Other_field.t\n\n let typ = Impls.Step.Other_field.typ\n end\n\n let print_fp lab x =\n if debug then\n as_prover\n As_prover.(\n fun () ->\n printf !\"%s: %{sexp:Backend.Tick.Field.t}\\n%!\" lab (read_var x))\n\n let print_bool lab x =\n if debug then\n as_prover (fun () ->\n printf \"%s: %b\\n%!\" lab (As_prover.read Boolean.typ x) )\n\n let equal_g g1 g2 =\n List.map2_exn ~f:Field.equal\n (Inner_curve.to_field_elements g1)\n (Inner_curve.to_field_elements g2)\n |> Boolean.all\n\n let absorb sponge ty t =\n absorb\n ~absorb_field:(fun x -> Sponge.absorb sponge (`Field x))\n ~g1_to_field_elements:Inner_curve.to_field_elements\n ~absorb_scalar:(fun (x, (b : Boolean.var)) ->\n Sponge.absorb sponge (`Field x) ;\n Sponge.absorb sponge (`Bits [ b ]) )\n ~mask_g1_opt:(fun ((b : Boolean.var), (x, y)) ->\n Field.((b :> t) * x, (b :> t) * y) )\n ty t\n\n let _scalar_to_field s =\n SC.to_field_checked (module Impl) s ~endo:Endo.Wrap_inner_curve.scalar\n\n let assert_n_bits ~n a =\n (* Scalar_challenge.to_field_checked has the side effect of\n checking that the input fits in n bits. *)\n ignore\n ( SC.to_field_checked\n (module Impl)\n (Import.Scalar_challenge.create a)\n ~endo:Endo.Wrap_inner_curve.scalar ~num_bits:n\n : Field.t )\n\n let lowest_128_bits ~constrain_low_bits x =\n let assert_128_bits = assert_n_bits ~n:128 in\n Util.lowest_128_bits ~constrain_low_bits ~assert_128_bits (module Impl) x\n\n module Scalar_challenge =\n SC.Make (Impl) (Inner_curve) (Challenge) (Endo.Step_inner_curve)\n module Ops = Step_main_inputs.Ops\n\n module Inner_curve = struct\n include Inner_curve\n\n let ( + ) = Ops.add_fast\n end\n\n module Public_input_scalar = struct\n type t = Field.t\n\n let typ = Field.typ\n\n module Constant = struct\n include Field.Constant\n\n let to_bigint = Impl.Bigint.of_field\n end\n end\n\n let multiscale_known\n (ts :\n ( [ `Field of Field.t | `Packed_bits of Field.t * int ]\n * Inner_curve.Constant.t )\n array ) =\n let module F = Public_input_scalar in\n let rec pow2pow x i =\n if i = 0 then x else pow2pow Inner_curve.Constant.(x + x) (i - 1)\n in\n with_label __LOC__ (fun () ->\n let constant_part, non_constant_part =\n List.partition_map (Array.to_list ts) ~f:(fun (t, g) ->\n match[@warning \"-4\"] t with\n | `Field (Constant c) | `Packed_bits (Constant c, _) ->\n First\n ( if Field.Constant.(equal zero) c then None\n else if Field.Constant.(equal one) c then Some g\n else\n Some\n (Inner_curve.Constant.scale g\n (Inner_curve.Constant.Scalar.project\n (Field.Constant.unpack c) ) ) )\n | `Field x ->\n Second (`Field x, g)\n | `Packed_bits (x, n) ->\n Second (`Packed_bits (x, n), g) )\n in\n let add_opt xo y =\n Option.value_map xo ~default:y ~f:(fun x ->\n Inner_curve.Constant.( + ) x y )\n in\n let constant_part =\n List.filter_map constant_part ~f:Fn.id\n |> List.fold ~init:None ~f:(fun acc x -> Some (add_opt acc x))\n in\n let correction, acc =\n List.map non_constant_part ~f:(fun (s, x) ->\n let rr, n =\n match s with\n | `Packed_bits (s, n) ->\n ( Ops.scale_fast2'\n (module F)\n (Inner_curve.constant x) s ~num_bits:n\n , n )\n | `Field s ->\n ( Ops.scale_fast2'\n (module F)\n (Inner_curve.constant x) s ~num_bits:Field.size_in_bits\n , Field.size_in_bits )\n in\n let n =\n Ops.bits_per_chunk * Ops.chunks_needed ~num_bits:(n - 1)\n in\n let cc = pow2pow x n in\n (cc, rr) )\n |> List.reduce_exn ~f:(fun (a1, b1) (a2, b2) ->\n (Inner_curve.Constant.( + ) a1 a2, Inner_curve.( + ) b1 b2) )\n in\n Inner_curve.(\n acc + constant (Constant.negate correction |> add_opt constant_part)) )\n\n let squeeze_challenge sponge : Field.t =\n lowest_128_bits (Sponge.squeeze sponge) ~constrain_low_bits:true\n\n let squeeze_scalar sponge : Field.t Import.Scalar_challenge.t =\n (* No need to boolean constrain scalar challenges. *)\n Import.Scalar_challenge.create\n (lowest_128_bits ~constrain_low_bits:false (Sponge.squeeze sponge))\n\n let bullet_reduce sponge gammas =\n with_label __LOC__ (fun () ->\n let absorb t = absorb sponge t in\n let prechallenges =\n Array.map gammas ~f:(fun gammas_i ->\n absorb (PC :: PC) gammas_i ;\n squeeze_scalar sponge )\n in\n let term_and_challenge (l, r) pre =\n let left_term = Scalar_challenge.endo_inv l pre in\n let right_term = Scalar_challenge.endo r pre in\n ( Inner_curve.(left_term + right_term)\n , Bulletproof_challenge.unpack pre )\n in\n let terms, challenges =\n Array.map2_exn gammas prechallenges ~f:term_and_challenge\n |> Array.unzip\n in\n (Array.reduce_exn terms ~f:(fun x y -> Inner_curve.(x + y)), challenges) )\n\n let group_map =\n let f =\n lazy\n (let module M =\n Group_map.Bw19.Make (Field.Constant) (Field)\n (struct\n let params =\n Group_map.Bw19.Params.create\n (module Field.Constant)\n { b = Inner_curve.Params.b }\n end)\n in\n let open M in\n Snarky_group_map.Checked.wrap\n (module Impl)\n ~potential_xs\n ~y_squared:(fun ~x ->\n Field.(\n (x * x * x)\n + (constant Inner_curve.Params.a * x)\n + constant Inner_curve.Params.b) )\n |> unstage )\n in\n fun x -> Lazy.force f x\n\n let _scale_fast p s =\n with_label __LOC__ (fun () ->\n Ops.scale_fast p s ~num_bits:Field.size_in_bits )\n\n let scale_fast2 p (s : Other_field.t Shifted_value.Type2.t) =\n with_label __LOC__ (fun () ->\n Ops.scale_fast2 p s ~num_bits:Field.size_in_bits )\n\n let check_bulletproof ~pcs_batch ~(sponge : Sponge.t) ~xi\n ~(* Corresponds to y in figure 7 of WTS *)\n (* sum_i r^i sum_j xi^j f_j(beta_i) *)\n (advice : _ Bulletproof.Advice.t)\n ~polynomials:(without_degree_bound, with_degree_bound)\n ~opening:\n ({ lr; delta; z_1; z_2; challenge_polynomial_commitment } :\n (Inner_curve.t, Other_field.t Shifted_value.Type2.t) Bulletproof.t ) =\n with_label \"check_bulletproof\" (fun () ->\n absorb sponge Scalar\n ( match advice.combined_inner_product with\n | Shifted_value.Type2.Shifted_value x ->\n x ) ;\n (* a_hat should be equal to\n sum_i < t, r^i pows(beta_i) >\n = sum_i r^i < t, pows(beta_i) > *)\n let u =\n let t = Sponge.squeeze_field sponge in\n group_map t\n in\n let open Inner_curve in\n let combined_polynomial (* Corresponds to xi in figure 7 of WTS *) =\n with_label \"combined_polynomial\" (fun () ->\n Pcs_batch.combine_split_commitments pcs_batch\n ~scale_and_add:(fun ~(acc :\n [ `Maybe_finite of\n Boolean.var * Inner_curve.t\n | `Finite of Inner_curve.t ] ) ~xi p ->\n match acc with\n | `Maybe_finite (acc_is_finite, (acc : Inner_curve.t)) -> (\n match p with\n | `Maybe_finite (p_is_finite, p) ->\n let is_finite =\n Boolean.(p_is_finite ||| acc_is_finite)\n in\n let xi_acc = Scalar_challenge.endo acc xi in\n `Maybe_finite\n ( is_finite\n , if_ acc_is_finite ~then_:(p + xi_acc) ~else_:p )\n | `Finite p ->\n let xi_acc = Scalar_challenge.endo acc xi in\n `Finite\n (if_ acc_is_finite ~then_:(p + xi_acc) ~else_:p) )\n | `Finite acc ->\n let xi_acc = Scalar_challenge.endo acc xi in\n `Finite\n ( match p with\n | `Finite p ->\n p + xi_acc\n | `Maybe_finite (p_is_finite, p) ->\n if_ p_is_finite ~then_:(p + xi_acc) ~else_:xi_acc )\n )\n ~xi\n ~init:(function\n | `Finite x -> `Finite x | `Maybe_finite x -> `Maybe_finite x\n )\n (Vector.map without_degree_bound\n ~f:(Array.map ~f:(fun x -> `Finite x)) )\n (Vector.map with_degree_bound\n ~f:\n (let open Plonk_types.Poly_comm.With_degree_bound in\n fun { shifted; unshifted } ->\n let f x = `Maybe_finite x in\n { unshifted = Array.map ~f unshifted\n ; shifted = f shifted\n }) ) )\n |> function `Finite x -> x | `Maybe_finite _ -> assert false\n in\n let lr_prod, challenges = bullet_reduce sponge lr in\n let p_prime =\n let uc = scale_fast2 u advice.combined_inner_product in\n combined_polynomial + uc\n in\n let q = p_prime + lr_prod in\n absorb sponge PC delta ;\n let c = squeeze_scalar sponge in\n print_fp \"c\" c.inner ;\n (* c Q + delta = z1 (G + b U) + z2 H *)\n let lhs =\n let cq = Scalar_challenge.endo q c in\n cq + delta\n in\n let rhs =\n with_label __LOC__ (fun () ->\n let b_u = scale_fast2 u advice.b in\n let z_1_g_plus_b_u =\n scale_fast2 (challenge_polynomial_commitment + b_u) z_1\n in\n let z2_h =\n scale_fast2 (Inner_curve.constant (Lazy.force Generators.h)) z_2\n in\n z_1_g_plus_b_u + z2_h )\n in\n (`Success (equal_g lhs rhs), challenges) )\n\n let assert_eq_deferred_values\n (m1 :\n ( 'a\n , Inputs.Impl.Field.t Import.Scalar_challenge.t\n , _ )\n Types.Wrap.Proof_state.Deferred_values.Plonk.Minimal.t )\n (m2 :\n ( Inputs.Impl.Field.t\n , Inputs.Impl.Field.t Import.Scalar_challenge.t\n , _ )\n Types.Wrap.Proof_state.Deferred_values.Plonk.Minimal.t ) =\n let open Types.Wrap.Proof_state.Deferred_values.Plonk.Minimal in\n let chal c1 c2 = Field.Assert.equal c1 c2 in\n let scalar_chal\n ({ Import.Scalar_challenge.inner = t1 } : _ Import.Scalar_challenge.t)\n ({ Import.Scalar_challenge.inner = t2 } : _ Import.Scalar_challenge.t) =\n Field.Assert.equal t1 t2\n in\n with_label __LOC__ (fun () -> chal m1.beta m2.beta) ;\n with_label __LOC__ (fun () -> chal m1.gamma m2.gamma) ;\n with_label __LOC__ (fun () -> scalar_chal m1.alpha m2.alpha) ;\n with_label __LOC__ (fun () -> scalar_chal m1.zeta m2.zeta)\n\n let lagrange_commitment ~domain srs i =\n let d = Int.pow 2 (Domain.log2_size domain) in\n match[@warning \"-4\"]\n (Kimchi_bindings.Protocol.SRS.Fq.lagrange_commitment srs d i).unshifted\n with\n | [| Finite g |] ->\n Inner_curve.Constant.of_affine g\n | _ ->\n assert false\n\n module O = One_hot_vector.Make (Impl)\n open Tuple_lib\n\n let public_input_commitment_dynamic (type n) ~srs (which : n O.t)\n (domains : (Domains.t, n) Vector.t)\n ~(public_input :\n [ `Field of Field.t | `Packed_bits of Field.t * int ] array ) =\n (*\n let domains : (Domains.t, Nat.N3.n) Vector.t =\n Vector.map ~f:(fun proofs_verified -> Common.wrap_domains ~proofs_verified)\n [ 0; 1 ; 2 ]\n in *)\n let lagrange_commitment (d : Domains.t) (i : int) : Inner_curve.Constant.t =\n lagrange_commitment ~domain:d.h srs i\n in\n let select_curve_points (type k)\n ~(points_for_domain : Domains.t -> (Inner_curve.Constant.t, k) Vector.t)\n : (Inner_curve.t, k) Vector.t =\n match domains with\n | [] ->\n assert false\n | d :: ds ->\n if Vector.for_all ds ~f:(fun d' -> Domain.equal d.h d'.h) then\n Vector.map ~f:Inner_curve.constant (points_for_domain d)\n else\n Vector.map2\n (which :> (Boolean.var, n) Vector.t)\n domains\n ~f:(fun b d ->\n let points = points_for_domain d in\n Vector.map points ~f:(fun g ->\n let x, y = Inner_curve.constant g in\n Field.((b :> t) * x, (b :> t) * y) ) )\n |> Vector.reduce_exn\n ~f:(Vector.map2 ~f:(Double.map2 ~f:Field.( + )))\n |> Vector.map ~f:(Double.map ~f:(Util.seal (module Impl)))\n in\n let lagrange i =\n select_curve_points ~points_for_domain:(fun d ->\n [ lagrange_commitment d i ] )\n |> Vector.unsingleton\n in\n let lagrange_with_correction ~input_length i :\n (Inner_curve.t, Nat.N2.n) Vector.t =\n let actual_shift =\n (* TODO: num_bits should maybe be input_length - 1. *)\n Ops.bits_per_chunk * Ops.chunks_needed ~num_bits:input_length\n in\n let rec pow2pow x i =\n if i = 0 then x else pow2pow Inner_curve.Constant.(x + x) (i - 1)\n in\n select_curve_points ~points_for_domain:(fun d ->\n let g = lagrange_commitment d i in\n let open Inner_curve.Constant in\n [ g; negate (pow2pow g actual_shift) ] )\n in\n let x_hat =\n let constant_part, non_constant_part =\n List.partition_map\n (Array.to_list (Array.mapi ~f:(fun i t -> (i, t)) public_input))\n ~f:(fun (i, t) ->\n match[@warning \"-4\"] t with\n | `Field (Constant c) | `Packed_bits (Constant c, _) ->\n First\n ( if Field.Constant.(equal zero) c then None\n else if Field.Constant.(equal one) c then Some (lagrange i)\n else\n Some\n ( select_curve_points ~points_for_domain:(fun d ->\n [ Inner_curve.Constant.scale\n (lagrange_commitment d i)\n (Inner_curve.Constant.Scalar.project\n (Field.Constant.unpack c) )\n ] )\n |> Vector.unsingleton ) )\n | `Field x ->\n Second (i, (x, Public_input_scalar.Constant.size_in_bits))\n | `Packed_bits (x, n) ->\n Second (i, (x, n)) )\n in\n let terms =\n List.map non_constant_part ~f:(fun (i, x) ->\n match x with\n | b, 1 ->\n assert_ (Constraint.boolean (b :> Field.t)) ;\n `Cond_add (Boolean.Unsafe.of_cvar b, lagrange i)\n | x, n ->\n `Add_with_correction\n ((x, n), lagrange_with_correction ~input_length:n i) )\n in\n let f = Ops.add_fast ?check_finite:None in\n let correction =\n List.reduce_exn\n (List.filter_map terms ~f:(function\n | `Cond_add _ ->\n None\n | `Add_with_correction (_, [ _; corr ]) ->\n Some corr ) )\n ~f\n in\n let init =\n List.fold (List.filter_map constant_part ~f:Fn.id) ~init:correction ~f\n in\n List.fold terms ~init ~f:(fun acc term ->\n match term with\n | `Cond_add (b, g) ->\n with_label __LOC__ (fun () ->\n Inner_curve.if_ b ~then_:(Ops.add_fast g acc) ~else_:acc )\n | `Add_with_correction ((x, num_bits), [ g; _ ]) ->\n Ops.add_fast acc\n (Ops.scale_fast2' (module Public_input_scalar) g x ~num_bits) )\n |> Inner_curve.negate\n in\n x_hat\n\n let incrementally_verify_proof (type b)\n (module Proofs_verified : Nat.Add.Intf with type n = b) ~srs:_\n ~(domain :\n [ `Known of Domain.t\n | `Side_loaded of\n _ Composition_types.Branch_data.Proofs_verified.One_hot.Checked.t ]\n ) ~srs ~verification_key:(m : _ Plonk_verification_key_evals.t) ~xi\n ~sponge ~sponge_after_index\n ~(public_input :\n [ `Field of Field.t | `Packed_bits of Field.t * int ] array )\n ~(sg_old : (_, Proofs_verified.n) Vector.t) ~advice\n ~proof:({ messages; opening } : Wrap_proof.Checked.t)\n ~(plonk :\n ( _\n , _\n , _ Shifted_value.Type2.t\n , _\n , _\n , _ )\n Types.Wrap.Proof_state.Deferred_values.Plonk.In_circuit.t ) =\n with_label \"incrementally_verify_proof\" (fun () ->\n let receive ty f =\n with_label \"receive\" (fun () ->\n let x = f messages in\n absorb sponge ty x ; x )\n in\n let sample () = squeeze_challenge sponge in\n let sample_scalar () = squeeze_scalar sponge in\n let open Plonk_types.Messages.In_circuit in\n let without = Type.Without_degree_bound in\n let absorb_g gs = absorb sponge without gs in\n let index_digest =\n with_label \"absorb verifier index\" (fun () ->\n let index_sponge = Sponge.copy sponge_after_index in\n Sponge.squeeze_field index_sponge )\n in\n absorb sponge Field index_digest ;\n let sg_old : (_, Wrap_hack.Padded_length.n) Vector.t =\n Wrap_hack.Checked.pad_commitments sg_old\n in\n Vector.iter ~f:(absorb sponge PC) sg_old ;\n let x_hat =\n with_label \"x_hat\" (fun () ->\n match domain with\n | `Known domain ->\n multiscale_known\n (Array.mapi public_input ~f:(fun i x ->\n (x, lagrange_commitment ~domain srs i) ) )\n |> Inner_curve.negate\n | `Side_loaded which ->\n public_input_commitment_dynamic ~srs which\n (Vector.map\n ~f:(fun proofs_verified ->\n Common.wrap_domains ~proofs_verified )\n [ 0; 1; 2 ] )\n ~public_input )\n in\n let x_hat =\n with_label \"x_hat blinding\" (fun () ->\n Ops.add_fast x_hat\n (Inner_curve.constant (Lazy.force Generators.h)) )\n in\n absorb sponge PC x_hat ;\n let w_comm = messages.w_comm in\n Vector.iter ~f:absorb_g w_comm ;\n let beta = sample () in\n let gamma = sample () in\n let z_comm = receive without z_comm in\n let alpha = sample_scalar () in\n let t_comm = receive without t_comm in\n let zeta = sample_scalar () in\n (* At this point, we should use the previous \"bulletproof_challenges\" to\n compute to compute f(beta_1) outside the snark\n where f is the polynomial corresponding to sg_old\n *)\n let sponge_before_evaluations = Sponge.copy sponge in\n let sponge_digest_before_evaluations = Sponge.squeeze_field sponge in\n\n (* xi, r are sampled here using the other sponge. *)\n (* No need to expose the polynomial evaluations as deferred values as they're\n not needed here for the incremental verification. All we need is a_hat and\n \"combined_inner_product\".\n\n Then, in the other proof, we can witness the evaluations and check their correctness\n against \"combined_inner_product\" *)\n let sigma_comm_init, [ _ ] =\n Vector.split m.sigma_comm\n (snd (Plonk_types.Permuts_minus_1.add Nat.N1.n))\n in\n let ft_comm =\n with_label __LOC__ (fun () ->\n Common.ft_comm\n ~add:(Ops.add_fast ?check_finite:None)\n ~scale:scale_fast2 ~negate:Inner_curve.negate\n ~endoscale:(Scalar_challenge.endo ?num_bits:None)\n ~verification_key:m ~plonk ~alpha ~t_comm )\n in\n let bulletproof_challenges =\n (* This sponge needs to be initialized with (some derivative of)\n 1. The polynomial commitments\n 2. The combined inner product\n 3. The challenge points.\n\n It should be sufficient to fork the sponge after squeezing beta_3 and then to absorb\n the combined inner product.\n *)\n let num_commitments_without_degree_bound = Nat.N45.n in\n let without_degree_bound =\n Vector.append\n (Vector.map sg_old ~f:(fun g -> [| g |]))\n ( [| x_hat |] :: [| ft_comm |] :: z_comm :: [| m.generic_comm |]\n :: [| m.psm_comm |] :: [| m.complete_add_comm |]\n :: [| m.mul_comm |] :: [| m.emul_comm |]\n :: [| m.endomul_scalar_comm |]\n :: Vector.append w_comm\n (Vector.append\n (Vector.map m.coefficients_comm ~f:(fun g -> [| g |]))\n (Vector.map sigma_comm_init ~f:(fun g -> [| g |]))\n (snd Plonk_types.(Columns.add Permuts_minus_1.n)) )\n (snd\n Plonk_types.(\n Columns.add (fst (Columns.add Permuts_minus_1.n))) ) )\n (snd\n (Wrap_hack.Padded_length.add\n num_commitments_without_degree_bound ) )\n in\n with_label \"check_bulletproof\" (fun () ->\n check_bulletproof\n ~pcs_batch:\n (Common.dlog_pcs_batch\n (Wrap_hack.Padded_length.add\n num_commitments_without_degree_bound ) )\n ~sponge:sponge_before_evaluations ~xi ~advice ~opening\n ~polynomials:(without_degree_bound, []) )\n in\n let joint_combiner =\n if lookup_verification_enabled then failwith \"TODO\" else None\n in\n assert_eq_deferred_values\n { alpha = plonk.alpha\n ; beta = plonk.beta\n ; gamma = plonk.gamma\n ; zeta = plonk.zeta\n ; joint_combiner\n ; feature_flags = plonk.feature_flags\n }\n { alpha\n ; beta\n ; gamma\n ; zeta\n ; joint_combiner\n ; feature_flags = plonk.feature_flags\n } ;\n (sponge_digest_before_evaluations, bulletproof_challenges) )\n\n let compute_challenges ~scalar chals =\n with_label \"compute_challenges\" (fun () ->\n Vector.map chals ~f:(fun b -> Bulletproof_challenge.pack b |> scalar) )\n\n let challenge_polynomial = Wrap_verifier.challenge_polynomial (module Field)\n\n module Pseudo = Pseudo.Make (Impl)\n\n (* module Bounded = struct\n type t = { max : int; actual : Field.t }\n\n let _of_pseudo ((_, ns) as p : _ Pseudo.t) =\n { max = Vector.reduce_exn ~f:Int.max ns\n ; actual = Pseudo.choose p ~f:Field.of_int\n }\n end *)\n\n let vanishing_polynomial mask =\n with_label \"vanishing_polynomial\" (fun () ->\n let mask = Vector.to_array mask in\n let max = Array.length mask in\n fun x ->\n let rec go acc i =\n if i >= max then acc\n else\n let should_square = mask.(i) in\n let acc =\n Field.if_ should_square ~then_:(Field.square acc) ~else_:acc\n in\n go acc (i + 1)\n in\n Field.sub (go x 0) Field.one )\n\n let shifts ~log2_size = Common.tick_shifts ~log2_size\n\n let domain_generator ~log2_size =\n Backend.Tick.Field.domain_generator ~log2_size |> Impl.Field.constant\n\n let side_loaded_domain =\n let open Side_loaded_verification_key in\n fun ~(log2_size : Field.t) ->\n let domain ~max =\n let (T max_n) = Nat.of_int max in\n let mask = ones_vector (module Impl) max_n ~first_zero:log2_size in\n let log2_sizes =\n ( O.of_index log2_size ~length:(S max_n)\n , Vector.init (S max_n) ~f:Fn.id )\n in\n let shifts = Pseudo.Domain.shifts log2_sizes ~shifts in\n let generator = Pseudo.Domain.generator log2_sizes ~domain_generator in\n let vanishing_polynomial = vanishing_polynomial mask in\n object\n method log2_size = log2_size\n\n method vanishing_polynomial x = vanishing_polynomial x\n\n method shifts = shifts\n\n method generator = generator\n end\n in\n domain ~max:(Domain.log2_size max_domains.h)\n\n let%test_module \"side loaded domains\" =\n ( module struct\n let run k =\n let y =\n run_and_check (fun () ->\n let y = k () in\n fun () -> As_prover.read_var y )\n |> Or_error.ok_exn\n in\n y\n\n let%test_unit \"side loaded domains\" =\n let open Side_loaded_verification_key in\n let domains = [ { Domains.h = 10 }; { h = 15 } ] in\n let pt = Field.Constant.random () in\n List.iter domains ~f:(fun ds ->\n let d_unchecked =\n Plonk_checks.domain\n (module Field.Constant)\n (Pow_2_roots_of_unity ds.h) ~shifts:Common.tick_shifts\n ~domain_generator:Backend.Tick.Field.domain_generator\n in\n let checked_domain () =\n side_loaded_domain ~log2_size:(Field.of_int ds.h)\n in\n [%test_eq: Field.Constant.t]\n (d_unchecked#vanishing_polynomial pt)\n (run (fun () ->\n (checked_domain ())#vanishing_polynomial (Field.constant pt) )\n ) )\n end )\n\n (* module Split_evaluations = struct\n open Plonk_types\n\n let mask' { Bounded.max; actual } : Boolean.var array =\n let (T max) = Nat.of_int max in\n Vector.to_array (ones_vector (module Impl) ~first_zero:actual max)\n\n let mask (type n) ~(lengths : (int, n) Vector.t)\n (choice : n One_hot_vector.T(Impl).t) : Boolean.var array =\n let max =\n Option.value_exn\n (List.max_elt ~compare:Int.compare (Vector.to_list lengths))\n in\n let actual = Pseudo.choose (choice, lengths) ~f:Field.of_int in\n mask' { max; actual }\n\n let _last =\n Array.reduce_exn ~f:(fun (b_acc, x_acc) (b, x) ->\n (Boolean.(b_acc ||| b), Field.if_ b ~then_:x ~else_:x_acc) )\n\n let pow x bits_lsb =\n with_label \"pow\" (fun () ->\n let rec go acc bs =\n match bs with\n | [] ->\n acc\n | b :: bs ->\n let acc = Field.square acc in\n let acc = Field.if_ b ~then_:Field.(x * acc) ~else_:acc in\n go acc bs\n in\n go Field.one (List.rev bits_lsb) )\n\n let _mod_max_degree =\n let k = Nat.to_int Backend.Tick.Rounds.n in\n fun d ->\n let d =\n Number.of_bits\n (Field.unpack\n ~length:Pickles_base.Side_loaded_verification_key.max_log2_degree\n d )\n in\n Number.mod_pow_2 d (`Two_to_the k)\n\n let _mask_evals (type n) ~(lengths : (int, n) Vector.t Evals.t)\n (choice : n One_hot_vector.T(Impl).t) (e : Field.t array Evals.t) :\n (Boolean.var * Field.t) array Evals.t =\n Evals.map2 lengths e ~f:(fun lengths e ->\n Array.zip_exn (mask ~lengths choice) e )\n end *)\n\n let _absorb_field sponge x = Sponge.absorb sponge (`Field x)\n\n (* pt^{2^n} *)\n let pow2_pow (pt : Field.t) (n : int) : Field.t =\n with_label \"pow2_pow\" (fun () ->\n let rec go acc i =\n if i = 0 then acc else go (Field.square acc) (i - 1)\n in\n go pt n )\n\n let actual_evaluation (e : Field.t array) ~(pt_to_n : Field.t) : Field.t =\n with_label \"actual_evaluation\" (fun () ->\n match List.rev (Array.to_list e) with\n | e :: es ->\n List.fold ~init:e es ~f:(fun acc fx -> Field.(fx + (pt_to_n * acc)))\n | [] ->\n Field.zero )\n\n open Plonk_types\n\n module Opt_sponge = struct\n include Opt_sponge.Make (Impl) (Step_main_inputs.Sponge.Permutation)\n\n let _squeeze_challenge sponge : Field.t =\n lowest_128_bits (squeeze sponge) ~constrain_low_bits:true\n end\n\n let shift1 =\n Shifted_value.Type1.Shift.(\n map ~f:Field.constant (create (module Field.Constant)))\n\n let _shift2 =\n Shifted_value.Type2.Shift.(\n map ~f:Field.constant (create (module Field.Constant)))\n\n let%test_unit \"endo scalar\" =\n SC.test (module Impl) ~endo:Endo.Wrap_inner_curve.scalar\n\n module Plonk = Types.Wrap.Proof_state.Deferred_values.Plonk\n\n module Plonk_checks = struct\n include Plonk_checks\n\n include\n Plonk_checks.Make\n (Shifted_value.Type1)\n (struct\n let constant_term = Plonk_checks.Scalars.Tick.constant_term\n\n let index_terms = Plonk_checks.Scalars.Tick.index_terms\n end)\n end\n\n let domain_for_compiled (type branches)\n (domains : (Domains.t, branches) Vector.t)\n (branch_data : Impl.field Branch_data.Checked.t) :\n Field.t Plonk_checks.plonk_domain =\n let (T unique_domains) =\n List.map (Vector.to_list domains) ~f:Domains.h\n |> List.dedup_and_sort ~compare:(fun d1 d2 ->\n Int.compare (Domain.log2_size d1) (Domain.log2_size d2) )\n |> Vector.of_list\n in\n let which_log2 =\n Vector.map unique_domains ~f:(fun d ->\n Field.equal\n (Field.of_int (Domain.log2_size d))\n branch_data.domain_log2 )\n |> O.of_vector_unsafe\n (* This should be ok... think it through a little more *)\n in\n Pseudo.Domain.to_domain\n (which_log2, unique_domains)\n ~shifts ~domain_generator\n\n (* This finalizes the \"deferred values\" coming from a previous proof over the same field.\n It\n 1. Checks that [xi] and [r] where sampled correctly. I.e., by absorbing all the\n evaluation openings and then squeezing.\n 2. Checks that the \"combined inner product\" value used in the elliptic curve part of\n the opening proof was computed correctly, in terms of the evaluation openings and the\n evaluation points.\n 3. Check that the \"b\" value was computed correctly.\n 4. Perform the arithmetic checks from marlin. *)\n (* TODO: This needs to handle the fact of variable length evaluations.\n Meaning it needs opt sponge. *)\n let finalize_other_proof (type b branches)\n (module Proofs_verified : Nat.Add.Intf with type n = b)\n ~(feature_flags : Plonk_types.Opt.Flag.t Plonk_types.Features.t)\n ~(step_domains :\n [ `Known of (Domains.t, branches) Vector.t | `Side_loaded ] )\n ~(* TODO: Add \"actual proofs verified\" so that proofs don't\n carry around dummy \"old bulletproof challenges\" *)\n sponge ~(prev_challenges : (_, b) Vector.t)\n ({ xi\n ; combined_inner_product\n ; bulletproof_challenges\n ; branch_data\n ; b\n ; plonk\n } :\n ( Field.t\n , _\n , Field.t Shifted_value.Type1.t\n , _\n , _\n , _\n , Field.Constant.t Branch_data.Checked.t\n , _ )\n Types.Wrap.Proof_state.Deferred_values.In_circuit.t )\n { Plonk_types.All_evals.In_circuit.ft_eval1; evals } =\n let actual_width_mask = branch_data.proofs_verified_mask in\n let T = Proofs_verified.eq in\n (* You use the NEW bulletproof challenges to check b. Not the old ones. *)\n let scalar =\n SC.to_field_checked (module Impl) ~endo:Endo.Wrap_inner_curve.scalar\n in\n let plonk =\n Types.Wrap.Proof_state.Deferred_values.Plonk.In_circuit.map_challenges\n ~f:Fn.id ~scalar plonk\n in\n let domain =\n match step_domains with\n | `Known ds ->\n domain_for_compiled ds branch_data\n | `Side_loaded ->\n ( side_loaded_domain ~log2_size:branch_data.domain_log2\n :> _ Plonk_checks.plonk_domain )\n in\n let zetaw = Field.mul domain#generator plonk.zeta in\n let sg_olds =\n with_label \"sg_olds\" (fun () ->\n Vector.map prev_challenges ~f:(fun chals ->\n unstage (challenge_polynomial (Vector.to_array chals)) ) )\n in\n let sg_evals1, sg_evals2 =\n let sg_evals pt =\n Vector.map2\n ~f:(fun keep f -> (keep, f pt))\n (Vector.trim_front actual_width_mask\n (Nat.lte_exn Proofs_verified.n Nat.N2.n) )\n sg_olds\n in\n (sg_evals plonk.zeta, sg_evals zetaw)\n in\n let sponge_state =\n let challenge_digest =\n let opt_sponge = Opt_sponge.create sponge_params in\n Vector.iter2\n (Vector.trim_front actual_width_mask\n (Nat.lte_exn Proofs_verified.n Nat.N2.n) )\n prev_challenges\n ~f:(fun keep chals ->\n Vector.iter chals ~f:(fun chal ->\n Opt_sponge.absorb opt_sponge (keep, chal) ) ) ;\n Opt_sponge.squeeze opt_sponge\n in\n Sponge.absorb sponge (`Field challenge_digest) ;\n Sponge.absorb sponge (`Field ft_eval1) ;\n Sponge.absorb sponge (`Field (fst evals.public_input)) ;\n Sponge.absorb sponge (`Field (snd evals.public_input)) ;\n let xs = Evals.In_circuit.to_absorption_sequence evals.evals in\n (* This is a hacky, but much more efficient, version of the opt sponge.\n This uses the assumption that the sponge 'absorption state' will align\n after each optional absorption, letting us skip the expensive tracking\n that this would otherwise require.\n To future-proof this, we assert that the states are indeed compatible.\n *)\n List.iter xs ~f:(fun opt ->\n let absorb =\n Array.iter ~f:(fun x -> Sponge.absorb sponge (`Field x))\n in\n match opt with\n | None ->\n ()\n | Some (x1, x2) ->\n absorb x1 ; absorb x2\n | Maybe (b, (x1, x2)) ->\n (* Cache the sponge state before *)\n let sponge_state_before = sponge.sponge_state in\n let state_before = Array.copy sponge.state in\n (* Absorb the points *)\n absorb x1 ;\n absorb x2 ;\n (* Check that the sponge ends in a compatible state. *)\n ( match (sponge_state_before, sponge.sponge_state) with\n | Absorbed x, Absorbed y ->\n [%test_eq: int] x y\n | Squeezed x, Squeezed y ->\n [%test_eq: int] x y\n | Absorbed _, Squeezed _ ->\n [%test_eq: string] \"absorbed\" \"squeezed\"\n | Squeezed _, Absorbed _ ->\n [%test_eq: string] \"squeezed\" \"absorbed\" ) ;\n let state =\n Array.map2_exn sponge.state state_before ~f:(fun then_ else_ ->\n Field.if_ b ~then_ ~else_ )\n in\n sponge.state <- state ) ;\n Array.copy sponge.state\n in\n sponge.state <- sponge_state ;\n let squeeze () = squeeze_challenge sponge in\n let xi_actual = squeeze () in\n let r_actual = squeeze () in\n let xi_correct =\n Field.equal xi_actual\n (match xi with { Import.Scalar_challenge.inner = xi } -> xi)\n in\n let xi = scalar xi in\n let r = scalar (Import.Scalar_challenge.create r_actual) in\n let plonk_minimal =\n Plonk.to_minimal plonk ~to_option:Opt.to_option_unsafe\n in\n let combined_evals =\n let n = Int.ceil_log2 Max_degree.step in\n let zeta_n : Field.t = pow2_pow plonk.zeta n in\n let zetaw_n : Field.t = pow2_pow zetaw n in\n Evals.In_circuit.map\n ~f:(fun (x0, x1) ->\n ( actual_evaluation ~pt_to_n:zeta_n x0\n , actual_evaluation ~pt_to_n:zetaw_n x1 ) )\n evals.evals\n in\n let env =\n with_label \"scalars_env\" (fun () ->\n let module Env_bool = struct\n include Boolean\n\n type t = Boolean.var\n end in\n let module Env_field = struct\n include Field\n\n type bool = Env_bool.t\n\n let if_ (b : bool) ~then_ ~else_ =\n match Impl.Field.to_constant (b :> t) with\n | Some x ->\n (* We have a constant, only compute the branch we care about. *)\n if Impl.Field.Constant.(equal one) x then then_ ()\n else else_ ()\n | None ->\n if_ b ~then_:(then_ ()) ~else_:(else_ ())\n end in\n Plonk_checks.scalars_env\n (module Env_bool)\n (module Env_field)\n ~srs_length_log2:Common.Max_degree.step_log2\n ~endo:(Impl.Field.constant Endo.Step_inner_curve.base)\n ~mds:sponge_params.mds\n ~field_of_hex:(fun s ->\n Kimchi_pasta.Pasta.Bigint256.of_hex_string s\n |> Kimchi_pasta.Pasta.Fp.of_bigint |> Field.constant )\n ~domain plonk_minimal combined_evals )\n in\n let open Field in\n let combined_inner_product_correct =\n let evals1, evals2 =\n All_evals.With_public_input.In_circuit.factor evals\n in\n let ft_eval0 : Field.t =\n with_label \"ft_eval0\" (fun () ->\n Plonk_checks.ft_eval0\n (module Field)\n ~env ~domain plonk_minimal combined_evals evals1.public_input )\n in\n print_fp \"ft_eval0\" ft_eval0 ;\n print_fp \"ft_eval1\" ft_eval1 ;\n (* sum_i r^i sum_j xi^j f_j(beta_i) *)\n let actual_combined_inner_product =\n let combine ~ft ~sg_evals x_hat\n (e : (Field.t array, _) Evals.In_circuit.t) =\n let sg_evals =\n sg_evals |> Vector.to_list\n |> List.map ~f:(fun (keep, eval) ->\n [| Plonk_types.Opt.Maybe (keep, eval) |] )\n in\n let a =\n Evals.In_circuit.to_list e\n |> List.map ~f:(function\n | None ->\n [||]\n | Some a ->\n Array.map a ~f:(fun x -> Plonk_types.Opt.Some x)\n | Maybe (b, a) ->\n Array.map a ~f:(fun x -> Plonk_types.Opt.Maybe (b, x)) )\n in\n let v =\n List.append sg_evals ([| Some x_hat |] :: [| Some ft |] :: a)\n in\n Common.combined_evaluation (module Impl) ~xi v\n in\n with_label \"combine\" (fun () ->\n combine ~ft:ft_eval0 ~sg_evals:sg_evals1 evals1.public_input\n evals1.evals\n + r\n * combine ~ft:ft_eval1 ~sg_evals:sg_evals2 evals2.public_input\n evals2.evals )\n in\n let expected =\n Shifted_value.Type1.to_field\n (module Field)\n ~shift:shift1 combined_inner_product\n in\n print_fp \"step_main cip expected\" expected ;\n print_fp \"step_main cip actual\" actual_combined_inner_product ;\n equal expected actual_combined_inner_product\n in\n let bulletproof_challenges =\n compute_challenges ~scalar bulletproof_challenges\n in\n let b_correct =\n with_label \"b_correct\" (fun () ->\n let challenge_poly =\n unstage\n (challenge_polynomial (Vector.to_array bulletproof_challenges))\n in\n let b_actual =\n challenge_poly plonk.zeta + (r * challenge_poly zetaw)\n in\n let b_used =\n Shifted_value.Type1.to_field (module Field) ~shift:shift1 b\n in\n equal b_used b_actual )\n in\n let plonk_checks_passed =\n with_label \"plonk_checks_passed\" (fun () ->\n Plonk_checks.checked\n (module Impl)\n ~env ~shift:shift1 plonk combined_evals )\n in\n print_bool \"xi_correct\" xi_correct ;\n print_bool \"combined_inner_product_correct\" combined_inner_product_correct ;\n print_bool \"plonk_checks_passed\" plonk_checks_passed ;\n print_bool \"b_correct\" b_correct ;\n ( Boolean.all\n [ xi_correct\n ; b_correct\n ; combined_inner_product_correct\n ; plonk_checks_passed\n ]\n , bulletproof_challenges )\n\n let sponge_after_index index =\n let sponge = Sponge.create sponge_params in\n Array.iter\n (Types.index_to_field_elements\n ~g:(fun (z : Inputs.Inner_curve.t) ->\n List.to_array (Inner_curve.to_field_elements z) )\n index )\n ~f:(fun x -> Sponge.absorb sponge (`Field x)) ;\n sponge\n\n let hash_messages_for_next_step_proof (type s) ~index\n (state_to_field_elements : s -> Field.t array) =\n let open Types.Step.Proof_state.Messages_for_next_step_proof in\n let after_index = sponge_after_index index in\n stage (fun (t : _ Types.Step.Proof_state.Messages_for_next_step_proof.t) ->\n let sponge = Sponge.copy after_index in\n Array.iter\n ~f:(fun x -> Sponge.absorb sponge (`Field x))\n (to_field_elements_without_index t ~app_state:state_to_field_elements\n ~g:Inner_curve.to_field_elements ) ;\n Sponge.squeeze_field sponge )\n\n let hash_messages_for_next_step_proof_opt (type s) ~index\n (state_to_field_elements : s -> Field.t array) =\n let open Types.Step.Proof_state.Messages_for_next_step_proof in\n let after_index = sponge_after_index index in\n ( after_index\n , (* TODO: Just get rid of the proofs verified mask and always absorb in full *)\n stage (fun t ~widths:_ ~max_width:_ ~proofs_verified_mask ->\n let sponge = Sponge.copy after_index in\n let t =\n { t with\n old_bulletproof_challenges =\n Vector.map2 proofs_verified_mask t.old_bulletproof_challenges\n ~f:(fun b v -> Vector.map v ~f:(fun x -> `Opt (b, x)))\n ; challenge_polynomial_commitments =\n Vector.map2 proofs_verified_mask\n t.challenge_polynomial_commitments ~f:(fun b g -> (b, g))\n }\n in\n let not_opt x = `Not_opt x in\n let hash_inputs =\n to_field_elements_without_index t\n ~app_state:\n (Fn.compose (Array.map ~f:not_opt) state_to_field_elements)\n ~g:(fun (b, g) ->\n List.map\n ~f:(fun x -> `Opt (b, x))\n (Inner_curve.to_field_elements g) )\n in\n match\n Array.fold hash_inputs ~init:(`Not_opt sponge) ~f:(fun acc t ->\n match (acc, t) with\n | `Not_opt sponge, `Not_opt t ->\n Sponge.absorb sponge (`Field t) ;\n acc\n | `Not_opt sponge, `Opt t ->\n let sponge = Opt_sponge.of_sponge sponge in\n Opt_sponge.absorb sponge t ; `Opt sponge\n | `Opt sponge, `Opt t ->\n Opt_sponge.absorb sponge t ; acc\n | `Opt _, `Not_opt _ ->\n assert false )\n with\n | `Not_opt sponge ->\n (* This means there were no optional inputs. *)\n Sponge.squeeze_field sponge\n | `Opt sponge ->\n Opt_sponge.squeeze sponge ) )\n\n let _accumulation_verifier\n (_accumulator_verification_key : _ Types_map.For_step.t)\n _prev_accumulators _proof _new_accumulator : Boolean.var =\n Boolean.false_\n\n let verify ~proofs_verified ~is_base_case ~sg_old ~sponge_after_index\n ~lookup_parameters ~feature_flags ~(proof : Wrap_proof.Checked.t) ~srs\n ~wrap_domain ~wrap_verification_key statement\n (unfinalized :\n ( _\n , _\n , _ Shifted_value.Type2.t\n , _\n , _\n , _ )\n Types.Step.Proof_state.Per_proof.In_circuit.t ) =\n let public_input :\n [ `Field of Field.t | `Packed_bits of Field.t * int ] array =\n with_label \"pack_statement\" (fun () ->\n Spec.pack\n (module Impl)\n (Types.Wrap.Statement.In_circuit.spec\n (module Impl)\n lookup_parameters feature_flags )\n (Types.Wrap.Statement.In_circuit.to_data\n ~option_map:Plonk_types.Opt.map statement\n ~to_opt:Plonk_types.Opt.to_option_unsafe ) )\n |> Array.map ~f:(function\n | `Field (Shifted_value.Type1.Shifted_value x) ->\n `Field x\n | `Packed_bits (x, n) ->\n `Packed_bits (x, n) )\n in\n let sponge = Sponge.create sponge_params in\n let { Types.Step.Proof_state.Deferred_values.xi\n ; combined_inner_product\n ; b\n ; _\n } =\n unfinalized.deferred_values\n in\n let ( sponge_digest_before_evaluations_actual\n , (`Success bulletproof_success, bulletproof_challenges_actual) ) =\n incrementally_verify_proof ~srs proofs_verified ~srs ~domain:wrap_domain\n ~xi ~verification_key:wrap_verification_key ~sponge ~sponge_after_index\n ~public_input ~sg_old\n ~advice:{ b; combined_inner_product }\n ~proof\n ~plonk:\n (Composition_types.Step.Proof_state.Deferred_values.Plonk.In_circuit\n .to_wrap ~opt_none:Opt.None ~false_:Boolean.false_\n unfinalized.deferred_values.plonk )\n in\n with_label __LOC__ (fun () ->\n with_label __LOC__ (fun () ->\n Field.Assert.equal unfinalized.sponge_digest_before_evaluations\n sponge_digest_before_evaluations_actual ) ;\n Array.iteri\n (Vector.to_array unfinalized.deferred_values.bulletproof_challenges)\n ~f:(fun i c1 ->\n let c2 = bulletproof_challenges_actual.(i) in\n let { Import.Scalar_challenge.inner = c1 } =\n Bulletproof_challenge.pack c1\n in\n let c2 =\n Field.if_ is_base_case ~then_:c1\n ~else_:(match c2.prechallenge with { inner = c2 } -> c2)\n in\n with_label (sprintf \"%s:%d\" __LOC__ i) (fun () ->\n Field.Assert.equal c1 c2 ) ) ) ;\n bulletproof_success\nend\n\ninclude Make (Step_main_inputs)\n","open Core_kernel\n\nmodule Step = struct\n module Key = struct\n module Proving = struct\n type t =\n Type_equal.Id.Uid.t\n * Snark_keys_header.t\n * int\n * Backend.Tick.R1CS_constraint_system.t\n\n let to_string : t -> _ = function\n | _id, header, n, _h ->\n sprintf !\"step-%s-%s-%d-%s\" header.kind.type_ header.kind.identifier\n n header.identifying_hash\n end\n\n module Verification = struct\n type t = Type_equal.Id.Uid.t * Snark_keys_header.t * int * Md5.t\n [@@deriving sexp]\n\n let to_string : t -> _ = function\n | _id, header, n, _h ->\n sprintf !\"vk-step-%s-%s-%d-%s\" header.kind.type_\n header.kind.identifier n header.identifying_hash\n end\n [@@warning \"-4\"]\n end\n\n let storable =\n Key_cache.Sync.Disk_storable.simple Key.Proving.to_string\n (fun (_, header, _, cs) ~path ->\n Or_error.try_with_join (fun () ->\n let open Or_error.Let_syntax in\n let%map header_read, index =\n Snark_keys_header.read_with_header\n ~read_data:(fun ~offset ->\n Kimchi_bindings.Protocol.Index.Fp.read (Some offset)\n (Backend.Tick.Keypair.load_urs ()) )\n path\n in\n [%test_eq: int] header.header_version header_read.header_version ;\n [%test_eq: Snark_keys_header.Kind.t] header.kind header_read.kind ;\n [%test_eq: Snark_keys_header.Constraint_constants.t]\n header.constraint_constants header_read.constraint_constants ;\n [%test_eq: string] header.constraint_system_hash\n header_read.constraint_system_hash ;\n { Backend.Tick.Keypair.index; cs } ) )\n (fun (_, header, _, _) t path ->\n Or_error.try_with (fun () ->\n Snark_keys_header.write_with_header\n ~expected_max_size_log2:33 (* 8 GB should be enough *)\n ~append_data:\n (Kimchi_bindings.Protocol.Index.Fp.write (Some true)\n t.Backend.Tick.Keypair.index )\n header path ) )\n\n let vk_storable =\n Key_cache.Sync.Disk_storable.simple Key.Verification.to_string\n (fun (_, header, _, _) ~path ->\n Or_error.try_with_join (fun () ->\n let open Or_error.Let_syntax in\n let%map header_read, index =\n Snark_keys_header.read_with_header\n ~read_data:(fun ~offset path ->\n Kimchi_bindings.Protocol.VerifierIndex.Fp.read (Some offset)\n (Backend.Tick.Keypair.load_urs ())\n path )\n path\n in\n [%test_eq: int] header.header_version header_read.header_version ;\n [%test_eq: Snark_keys_header.Kind.t] header.kind header_read.kind ;\n [%test_eq: Snark_keys_header.Constraint_constants.t]\n header.constraint_constants header_read.constraint_constants ;\n [%test_eq: string] header.constraint_system_hash\n header_read.constraint_system_hash ;\n index ) )\n (fun (_, header, _, _) x path ->\n Or_error.try_with (fun () ->\n Snark_keys_header.write_with_header\n ~expected_max_size_log2:33 (* 8 GB should be enough *)\n ~append_data:\n (Kimchi_bindings.Protocol.VerifierIndex.Fp.write (Some true) x)\n header path ) )\n\n let read_or_generate ~prev_challenges cache k_p k_v typ return_typ main =\n let s_p = storable in\n let s_v = vk_storable in\n let open Impls.Step in\n let pk =\n lazy\n ( match\n Common.time \"step keypair read\" (fun () ->\n Key_cache.Sync.read cache s_p (Lazy.force k_p) )\n with\n | Ok (pk, dirty) ->\n Common.time \"step keypair create\" (fun () ->\n (Keypair.create ~pk ~vk:(Backend.Tick.Keypair.vk pk), dirty) )\n | Error _e ->\n let r =\n Common.time \"stepkeygen\" (fun () ->\n constraint_system ~input_typ:typ ~return_typ main\n |> Keypair.generate ~prev_challenges )\n in\n Timer.clock __LOC__ ;\n ignore\n ( Key_cache.Sync.write cache s_p (Lazy.force k_p) (Keypair.pk r)\n : unit Or_error.t ) ;\n (r, `Generated_something) )\n in\n let vk =\n lazy\n (let k_v = Lazy.force k_v in\n match\n Common.time \"step vk read\" (fun () ->\n Key_cache.Sync.read cache s_v k_v )\n with\n | Ok (vk, _) ->\n (vk, `Cache_hit)\n | Error _e ->\n let pk, c = Lazy.force pk in\n let vk = Keypair.vk pk in\n ignore (Key_cache.Sync.write cache s_v k_v vk : unit Or_error.t) ;\n (vk, c) )\n in\n (pk, vk)\nend\n\nmodule Wrap = struct\n module Key = struct\n module Verification = struct\n type t = Type_equal.Id.Uid.t * Snark_keys_header.t * Md5.t\n [@@deriving sexp]\n\n let equal ((_, x1, y1) : t) ((_, x2, y2) : t) =\n [%equal: unit * Md5.t] ((* TODO: *) ignore x1, y1) (ignore x2, y2)\n\n let to_string : t -> _ = function\n | _id, header, _h ->\n sprintf !\"vk-wrap-%s-%s-%s\" header.kind.type_ header.kind.identifier\n header.identifying_hash\n end\n [@@warning \"-4\"]\n\n module Proving = struct\n type t =\n Type_equal.Id.Uid.t\n * Snark_keys_header.t\n * Backend.Tock.R1CS_constraint_system.t\n\n let to_string : t -> _ = function\n | _id, header, _h ->\n sprintf !\"wrap-%s-%s-%s\" header.kind.type_ header.kind.identifier\n header.identifying_hash\n end\n end\n\n let storable =\n Key_cache.Sync.Disk_storable.simple Key.Proving.to_string\n (fun (_, header, cs) ~path ->\n Or_error.try_with_join (fun () ->\n let open Or_error.Let_syntax in\n let%map header_read, index =\n Snark_keys_header.read_with_header\n ~read_data:(fun ~offset ->\n Kimchi_bindings.Protocol.Index.Fq.read (Some offset)\n (Backend.Tock.Keypair.load_urs ()) )\n path\n in\n [%test_eq: int] header.header_version header_read.header_version ;\n [%test_eq: Snark_keys_header.Kind.t] header.kind header_read.kind ;\n [%test_eq: Snark_keys_header.Constraint_constants.t]\n header.constraint_constants header_read.constraint_constants ;\n [%test_eq: string] header.constraint_system_hash\n header_read.constraint_system_hash ;\n { Backend.Tock.Keypair.index; cs } ) )\n (fun (_, header, _) t path ->\n Or_error.try_with (fun () ->\n Snark_keys_header.write_with_header\n ~expected_max_size_log2:33 (* 8 GB should be enough *)\n ~append_data:\n (Kimchi_bindings.Protocol.Index.Fq.write (Some true) t.index)\n header path ) )\n\n let read_or_generate ~prev_challenges cache k_p k_v typ return_typ main =\n let module Vk = Verification_key in\n let open Impls.Wrap in\n let s_p = storable in\n let pk =\n lazy\n (let k = Lazy.force k_p in\n match\n Common.time \"wrap key read\" (fun () ->\n Key_cache.Sync.read cache s_p k )\n with\n | Ok (pk, d) ->\n (Keypair.create ~pk ~vk:(Backend.Tock.Keypair.vk pk), d)\n | Error _e ->\n let r =\n Common.time \"wrapkeygen\" (fun () ->\n constraint_system ~input_typ:typ ~return_typ main\n |> Keypair.generate ~prev_challenges )\n in\n ignore\n ( Key_cache.Sync.write cache s_p k (Keypair.pk r)\n : unit Or_error.t ) ;\n (r, `Generated_something) )\n in\n let vk =\n lazy\n (let k_v = Lazy.force k_v in\n let s_v =\n Key_cache.Sync.Disk_storable.simple Key.Verification.to_string\n (fun (_, header, _cs) ~path ->\n Or_error.try_with_join (fun () ->\n let open Or_error.Let_syntax in\n let%map header_read, index =\n Snark_keys_header.read_with_header\n ~read_data:(fun ~offset:_ path ->\n Binable.of_string\n (module Vk.Stable.Latest)\n (In_channel.read_all path) )\n path\n in\n [%test_eq: int] header.header_version\n header_read.header_version ;\n [%test_eq: Snark_keys_header.Kind.t] header.kind\n header_read.kind ;\n [%test_eq: Snark_keys_header.Constraint_constants.t]\n header.constraint_constants\n header_read.constraint_constants ;\n [%test_eq: string] header.constraint_system_hash\n header_read.constraint_system_hash ;\n index ) )\n (fun (_, header, _) t path ->\n Or_error.try_with (fun () ->\n Snark_keys_header.write_with_header\n ~expected_max_size_log2:33 (* 8 GB should be enough *)\n ~append_data:(fun path ->\n Out_channel.with_file ~append:true path ~f:(fun file ->\n Out_channel.output_string file\n (Binable.to_string (module Vk.Stable.Latest) t) )\n )\n header path ) )\n in\n match Key_cache.Sync.read cache s_v k_v with\n | Ok (vk, d) ->\n (vk, d)\n | Error _e ->\n let kp, _dirty = Lazy.force pk in\n let vk = Keypair.vk kp in\n let pk = Keypair.pk kp in\n let vk : Vk.t =\n { index = vk\n ; commitments =\n Kimchi_pasta.Pallas_based_plonk.Keypair.vk_commitments vk\n ; data =\n (let open Kimchi_bindings.Protocol.Index.Fq in\n { constraints = domain_d1_size pk.index })\n }\n in\n ignore (Key_cache.Sync.write cache s_v k_v vk : unit Or_error.t) ;\n let _vk = Key_cache.Sync.read cache s_v k_v in\n (vk, `Generated_something) )\n in\n (pk, vk)\nend\n","open Core_kernel\nopen Bitstring_lib\nopen Snark_bits\n\nmodule Make_snarkable (Impl : Snarky_backendless.Snark_intf.S) = struct\n open Impl\n\n module type S = sig\n type var\n\n type value\n\n val typ : (var, value) Typ.t\n end\n\n module Bits = struct\n module type Lossy =\n Bits_intf.Snarkable.Lossy\n with type ('a, 'b) typ := ('a, 'b) Typ.t\n and type 'a checked := 'a Checked.t\n and type boolean_var := Boolean.var\n\n module type Faithful =\n Bits_intf.Snarkable.Faithful\n with type ('a, 'b) typ := ('a, 'b) Typ.t\n and type 'a checked := 'a Checked.t\n and type boolean_var := Boolean.var\n\n module type Small =\n Bits_intf.Snarkable.Small\n with type ('a, 'b) typ := ('a, 'b) Typ.t\n and type 'a checked := 'a Checked.t\n and type boolean_var := Boolean.var\n and type comparison_result := Field.Checked.comparison_result\n and type field_var := Field.Var.t\n end\nend\n\nmodule Tock0 = struct\n include Crypto_params.Tock\n module Snarkable = Make_snarkable (Crypto_params.Tock)\nend\n\nmodule Tick0 = struct\n include Crypto_params.Tick\n module Snarkable = Make_snarkable (Crypto_params.Tick)\nend\n\nlet%test_unit \"group-map test\" =\n let params = Crypto_params.Tock.group_map_params () in\n let module M = Crypto_params.Tick.Run in\n Quickcheck.test ~trials:3 Tick0.Field.gen ~f:(fun t ->\n let checked_output =\n M.run_and_check (fun () ->\n let x, y =\n Snarky_group_map.Checked.to_group\n (module M)\n ~params (M.Field.constant t)\n in\n fun () -> M.As_prover.(read_var x, read_var y) )\n |> Or_error.ok_exn\n in\n let ((x, y) as actual) =\n Group_map.to_group (module Tick0.Field) ~params t\n in\n [%test_eq: Tick0.Field.t]\n Tick0.Field.(\n (x * x * x)\n + (Tick0.Inner_curve.Params.a * x)\n + Tick0.Inner_curve.Params.b)\n Tick0.Field.(y * y) ;\n [%test_eq: Tick0.Field.t * Tick0.Field.t] checked_output actual )\n\nmodule Make_inner_curve_scalar (Impl : Snark_intf.S) (Other_impl : Snark_intf.S) =\nstruct\n module T = Other_impl.Field\n\n include (\n T :\n module type of T with module Var := T.Var and module Checked := T.Checked )\n\n let of_bits = Other_impl.Field.project\n\n let length_in_bits = size_in_bits\n\n open Impl\n\n type var = Boolean.var Bitstring.Lsb_first.t\n\n let typ : (var, t) Typ.t =\n Typ.transport_var\n (Typ.transport\n (Typ.list ~length:size_in_bits Boolean.typ)\n ~there:unpack ~back:project )\n ~there:Bitstring.Lsb_first.to_list ~back:Bitstring.Lsb_first.of_list\n\n let gen : t Quickcheck.Generator.t =\n Quickcheck.Generator.map\n (Bignum_bigint.gen_incl Bignum_bigint.one\n Bignum_bigint.(Other_impl.Field.size - one) )\n ~f:(fun x -> Other_impl.Bigint.(to_field (of_bignum_bigint x)))\n\n let test_bit x i = Other_impl.Bigint.(test_bit (of_field x) i)\n\n module Checked = struct\n let equal a b =\n Bitstring_checked.equal\n (Bitstring.Lsb_first.to_list a)\n (Bitstring.Lsb_first.to_list b)\n\n let to_bits = Fn.id\n\n module Assert = struct\n let equal : var -> var -> unit Checked.t =\n fun a b ->\n Bitstring_checked.Assert.equal\n (Bitstring.Lsb_first.to_list a)\n (Bitstring.Lsb_first.to_list b)\n end\n end\nend\n\nmodule Make_inner_curve_aux (Impl : Snark_intf.S) (Other_impl : Snark_intf.S) =\nstruct\n open Impl\n\n type var = Field.Var.t * Field.Var.t\n\n module Scalar = Make_inner_curve_scalar (Impl) (Other_impl)\nend\n\nmodule Tock = struct\n include (\n Tock0 : module type of Tock0 with module Inner_curve := Tock0.Inner_curve )\n\n module Fq = Snarky_field_extensions.Field_extensions.F (Tock0)\n\n module Inner_curve = struct\n include Tock0.Inner_curve\n\n include\n Sexpable.Of_sexpable\n (struct\n type t = Field.t * Field.t [@@deriving sexp]\n end)\n (struct\n type nonrec t = t\n\n let to_sexpable = to_affine_exn\n\n let of_sexpable = of_affine\n end)\n\n include Make_inner_curve_aux (Tock0) (Tick0)\n\n module Checked = struct\n include\n Snarky_curves.Make_weierstrass_checked (Fq) (Scalar)\n (struct\n include Tock0.Inner_curve\n end)\n (Params)\n (struct\n let add = None\n end)\n\n let add_known_unsafe t x = add_unsafe t (constant x)\n end\n\n let typ = Checked.typ\n end\nend\n\nmodule Tick = struct\n include (\n Tick0 :\n module type of Tick0\n with module Field := Tick0.Field\n and module Inner_curve := Tick0.Inner_curve )\n\n module Field = struct\n include Hashable.Make (Tick0.Field)\n include Tick0.Field\n module Bits = Bits.Make_field (Tick0.Field) (Tick0.Bigint)\n\n let size_in_triples = Int.((size_in_bits + 2) / 3)\n end\n\n module Fq = Snarky_field_extensions.Field_extensions.F (Tick0)\n\n module Inner_curve = struct\n include Crypto_params.Tick.Inner_curve\n\n include\n Sexpable.Of_sexpable\n (struct\n type t = Field.t * Field.t [@@deriving sexp]\n end)\n (struct\n type nonrec t = t\n\n let to_sexpable = to_affine_exn\n\n let of_sexpable = of_affine\n end)\n\n include Make_inner_curve_aux (Tick0) (Tock0)\n\n module Checked = struct\n include\n Snarky_curves.Make_weierstrass_checked (Fq) (Scalar)\n (Crypto_params.Tick.Inner_curve)\n (Params)\n (struct\n let add =\n Some\n (fun p1 p2 ->\n Run.make_checked (fun () ->\n Pickles.Step_main_inputs.Ops.add_fast p1 p2 ) )\n end)\n\n let add_known_unsafe t x = add_unsafe t (constant x)\n end\n\n let typ = Checked.typ\n end\n\n module Util = Snark_util.Make (Tick0)\n\n let m : Run.field Snarky_backendless.Snark.m = (module Run)\n\n let make_checked c = Run.make_checked c\nend\n\n(* Let n = Tick.Field.size_in_bits.\n Let k = n - 3.\n The reason k = n - 3 is as follows. Inside [meets_target], we compare\n a value against 2^k. 2^k requires k + 1 bits. The comparison then unpacks\n a (k + 1) + 1 bit number. This number cannot overflow so it is important that\n k + 1 + 1 < n. Thus k < n - 2.\n\n However, instead of using `Field.size_in_bits - 3` we choose `Field.size_in_bits - 8`\n to clamp the easiness. To something not-to-quick on a personal laptop from mid 2010s.\n*)\nlet target_bit_length = Tick.Field.size_in_bits - 8\n\nmodule type Snark_intf = Snark_intf.S\n\nmodule Group_map = struct\n let to_group x =\n Group_map.to_group (module Tick.Field) ~params:(Tock.group_map_params ()) x\n\n module Checked = struct\n let to_group x =\n Snarky_group_map.Checked.to_group\n (module Tick.Run)\n ~params:(Tock.group_map_params ()) x\n end\nend\n","open Core_kernel\nmodule Inputs = Pickles.Tick_field_sponge.Inputs\nmodule Ocaml_permutation = Sponge.Poseidon (Inputs)\nmodule Field = Kimchi_backend.Pasta.Basic.Fp\n\nlet add_assign = Ocaml_permutation.add_assign\n\nlet copy = Ocaml_permutation.copy\n\nlet params = Kimchi_pasta_fp_poseidon.create ()\n\nlet block_cipher _params (s : Field.t array) =\n let v = Kimchi_bindings.FieldVectors.Fp.create () in\n Array.iter s ~f:(Kimchi_bindings.FieldVectors.Fp.emplace_back v) ;\n Kimchi_pasta_fp_poseidon.block_cipher params v ;\n Array.init (Array.length s) ~f:(Kimchi_bindings.FieldVectors.Fp.get v)\n\nlet%test_unit \"check rust implementation of block-cipher\" =\n let params' : Field.t Sponge.Params.t =\n Sponge.Params.(map pasta_p_kimchi ~f:Field.of_string)\n in\n let open Pickles.Impls.Step in\n let module T = Internal_Basic in\n Quickcheck.test (Quickcheck.Generator.list_with_length 3 T.Field.gen)\n ~f:(fun s ->\n let s () = Array.of_list s in\n [%test_eq: T.Field.t array]\n (Ocaml_permutation.block_cipher params' (s ()))\n (block_cipher params' (s ())) )\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\n\n[%%ifdef consensus_mechanism]\n\nopen Pickles.Impls.Step.Internal_Basic\n\n[%%else]\n\nopen Snark_params.Tick\n\n[%%endif]\n\nmodule State = struct\n include Array\n\n let map2 = map2_exn\nend\n\nmodule Input = Random_oracle_input\n\nlet params : Field.t Sponge.Params.t =\n Sponge.Params.(map pasta_p_kimchi ~f:Field.of_string)\n\nmodule Operations = struct\n let add_assign ~state i x = Field.(state.(i) <- state.(i) + x)\n\n let apply_affine_map (matrix, constants) v =\n let dotv row =\n Array.reduce_exn (Array.map2_exn row v ~f:Field.( * )) ~f:Field.( + )\n in\n let res = Array.map matrix ~f:dotv in\n Array.map2_exn res constants ~f:Field.( + )\n\n let copy a = Array.map a ~f:Fn.id\nend\n\nmodule Digest = struct\n type t = Field.t\n\n let to_bits ?length x =\n match length with\n | None ->\n Field.unpack x\n | Some length ->\n List.take (Field.unpack x) length\nend\n\ninclude Sponge.Make_hash (Random_oracle_permutation)\n\nlet update ~state = update ~state params\n\nlet hash ?init = hash ?init params\n\nlet pow2 =\n let rec pow2 acc n = if n = 0 then acc else pow2 Field.(acc + acc) (n - 1) in\n Memo.general ~hashable:Int.hashable (fun n -> pow2 Field.one n)\n\n[%%ifdef consensus_mechanism]\n\nmodule Checked = struct\n module Inputs = Pickles.Step_main_inputs.Sponge.Permutation\n\n module Digest = struct\n open Pickles.Impls.Step.Field\n\n type nonrec t = t\n\n let to_bits ?(length = Field.size_in_bits) (x : t) =\n List.take (choose_preimage_var ~length:Field.size_in_bits x) length\n end\n\n include Sponge.Make_hash (Inputs)\n\n let params = Sponge.Params.map ~f:Inputs.Field.constant params\n\n open Inputs.Field\n\n let update ~state xs = update params ~state xs\n\n let hash ?init xs =\n hash ?init:(Option.map init ~f:(State.map ~f:constant)) params xs\n\n let pack_input =\n Input.Chunked.pack_to_fields\n ~pow2:(Fn.compose Field.Var.constant pow2)\n (module Pickles.Impls.Step.Field)\n\n let digest xs = xs.(0)\nend\n\nlet read_typ ({ field_elements; packeds } : _ Input.Chunked.t) =\n let open Pickles.Impls.Step in\n let open As_prover in\n { Input.Chunked.field_elements = Array.map ~f:(read Field.typ) field_elements\n ; packeds = Array.map packeds ~f:(fun (x, i) -> (read Field.typ x, i))\n }\n\nlet read_typ' input : _ Pickles.Impls.Step.Internal_Basic.As_prover.t =\n fun _ -> read_typ input\n\n[%%endif]\n\nlet pack_input = Input.Chunked.pack_to_fields ~pow2 (module Field)\n\nlet prefix_to_field (s : string) =\n let bits_per_character = 8 in\n assert (bits_per_character * String.length s < Field.size_in_bits) ;\n Field.project Fold_lib.Fold.(to_list (string_bits (s :> string)))\n\nlet salt (s : string) = update ~state:initial_state [| prefix_to_field s |]\n\nlet%test_unit \"iterativeness\" =\n let x1 = Field.random () in\n let x2 = Field.random () in\n let x3 = Field.random () in\n let x4 = Field.random () in\n let s_full = update ~state:initial_state [| x1; x2; x3; x4 |] in\n let s_it =\n update ~state:(update ~state:initial_state [| x1; x2 |]) [| x3; x4 |]\n in\n [%test_eq: Field.t array] s_full s_it\n\n[%%ifdef consensus_mechanism]\n\nlet%test_unit \"sponge checked-unchecked\" =\n let open Pickles.Impls.Step in\n let module T = Internal_Basic in\n let x = T.Field.random () in\n let y = T.Field.random () in\n T.Test.test_equal ~equal:T.Field.equal ~sexp_of_t:T.Field.sexp_of_t\n T.Typ.(field * field)\n T.Typ.field\n (fun (x, y) -> make_checked (fun () -> Checked.hash [| x; y |]))\n (fun (x, y) -> hash [| x; y |])\n (x, y)\n\n[%%endif]\n\nmodule Legacy = struct\n module Input = Random_oracle_input.Legacy\n module State = State\n\n let params : Field.t Sponge.Params.t =\n Sponge.Params.(map pasta_p_legacy ~f:Field.of_string)\n\n module Rounds = struct\n let rounds_full = 63\n\n let initial_ark = true\n\n let rounds_partial = 0\n end\n\n module Inputs = struct\n module Field = Field\n include Rounds\n\n let alpha = 5\n\n (* Computes x^5 *)\n let to_the_alpha x =\n let open Field in\n let res = x in\n let res = res * res in\n (* x^2 *)\n let res = res * res in\n (* x^4 *)\n res * x\n\n module Operations = Operations\n end\n\n include Sponge.Make_hash (Sponge.Poseidon (Inputs))\n\n let hash ?init = hash ?init params\n\n let update ~state = update ~state params\n\n let salt (s : string) = update ~state:initial_state [| prefix_to_field s |]\n\n let pack_input =\n Input.pack_to_fields ~size_in_bits:Field.size_in_bits ~pack:Field.project\n\n module Digest = Digest\n\n [%%ifdef consensus_mechanism]\n\n module Checked = struct\n let pack_input =\n Input.pack_to_fields ~size_in_bits:Field.size_in_bits ~pack:Field.Var.pack\n\n module Digest = Checked.Digest\n\n module Inputs = struct\n include Rounds\n module Impl = Pickles.Impls.Step\n open Impl\n module Field = Field\n\n let alpha = 5\n\n (* Computes x^5 *)\n let to_the_alpha x =\n let open Field in\n let res = x in\n let res = res * res in\n (* x^2 *)\n let res = res * res in\n (* x^4 *)\n res * x\n\n module Operations = struct\n open Field\n\n let seal = Pickles.Util.seal (module Impl)\n\n let add_assign ~state i x = state.(i) <- seal (state.(i) + x)\n\n let apply_affine_map (matrix, constants) v =\n let dotv row =\n Array.reduce_exn (Array.map2_exn row v ~f:( * )) ~f:( + )\n in\n let res = Array.map matrix ~f:dotv in\n Array.map2_exn res constants ~f:(fun x c -> seal (x + c))\n\n let copy a = Array.map a ~f:Fn.id\n end\n end\n\n include Sponge.Make_hash (Sponge.Poseidon (Inputs))\n\n let params = Sponge.Params.map ~f:Inputs.Field.constant params\n\n open Inputs.Field\n\n let update ~state xs = update params ~state xs\n\n let hash ?init xs =\n hash ?init:(Option.map init ~f:(State.map ~f:constant)) params xs\n end\n\n [%%endif]\nend\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Snark_params.Tick\n\n[%%ifdef consensus_mechanism]\n\nlet parity y = Bigint.(test_bit (of_field y) 0)\n\n[%%else]\n\nlet parity y = Field.parity y\n\n[%%endif]\n\nlet gen_uncompressed =\n Quickcheck.Generator.filter_map Field.gen_uniform ~f:(fun x ->\n let open Option.Let_syntax in\n let%map y = Inner_curve.find_y x in\n (x, y) )\n\nmodule Compressed = struct\n open Compressed_poly\n\n module Arg = struct\n (* module with same type t as Stable below, to build functor argument *)\n [%%versioned\n module Stable = struct\n module V1 = struct\n [@@@with_all_version_tags]\n\n type t = ((Field.t[@version_asserted]), bool) Poly.Stable.V1.t\n\n let to_latest = Fn.id\n end\n end]\n end\n\n let compress (x, y) = { Poly.x; is_odd = parity y }\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n [@@@with_all_version_tags]\n\n module T = struct\n type t = ((Field.t[@version_asserted]), bool) Poly.Stable.V1.t\n [@@deriving equal, compare, hash]\n\n let to_latest = Fn.id\n\n module M = struct\n (* for compatibility with legacy Base58Check serialization *)\n include Arg.Stable.V1.With_all_version_tags\n\n let description = \"Non zero curve point compressed\"\n\n let version_byte =\n Base58_check.Version_bytes.non_zero_curve_point_compressed\n end\n\n module Base58 = Codable.Make_base58_check (M)\n include Base58\n\n (* sexp representation is a Base58Check string, like the yojson representation *)\n let sexp_of_t t = to_base58_check t |> Sexp.of_string\n\n let t_of_sexp sexp = Sexp.to_string sexp |> of_base58_check_exn\n end\n\n include T\n include Hashable.Make_binable (T)\n\n let gen =\n let open Quickcheck.Generator.Let_syntax in\n let%map uncompressed = gen_uncompressed in\n compress uncompressed\n end\n end]\n\n module Poly = Poly\n include Comparable.Make_binable (Stable.Latest)\n include Hashable.Make_binable (Stable.Latest)\n include Stable.Latest.Base58\n\n let to_string = to_base58_check\n\n [%%define_locally Stable.Latest.(sexp_of_t, t_of_sexp, gen)]\n\n let compress (x, y) = { Poly.x; is_odd = parity y }\n\n let empty = Poly.{ x = Field.zero; is_odd = false }\n\n let to_input { Poly.x; is_odd } =\n { Random_oracle.Input.Chunked.field_elements = [| x |]\n ; packeds = [| (Field.project [ is_odd ], 1) |]\n }\n\n let to_input_legacy { Poly.x; is_odd } =\n { Random_oracle.Input.Legacy.field_elements = [| x |]\n ; bitstrings = [| [ is_odd ] |]\n }\n\n [%%ifdef consensus_mechanism]\n\n (* snarky-dependent *)\n\n type var = (Field.Var.t, Boolean.var) Poly.t\n\n let typ : (var, t) Typ.t =\n Typ.of_hlistable [ Field.typ; Boolean.typ ] ~var_to_hlist:Poly.to_hlist\n ~var_of_hlist:Poly.of_hlist ~value_to_hlist:Poly.to_hlist\n ~value_of_hlist:Poly.of_hlist\n\n let var_of_t ({ x; is_odd } : t) : var =\n { x = Field.Var.constant x; is_odd = Boolean.var_of_value is_odd }\n\n let assert_equal (t1 : var) (t2 : var) =\n let%map () = Field.Checked.Assert.equal t1.x t2.x\n and () = Boolean.Assert.(t1.is_odd = t2.is_odd) in\n ()\n\n module Checked = struct\n let equal t1 t2 =\n let%bind x_eq = Field.Checked.equal t1.Poly.x t2.Poly.x in\n let%bind odd_eq = Boolean.equal t1.is_odd t2.is_odd in\n Boolean.(x_eq && odd_eq)\n\n let to_input ({ x; is_odd } : var) =\n { Random_oracle.Input.Chunked.field_elements = [| x |]\n ; packeds = [| ((is_odd :> Field.Var.t), 1) |]\n }\n\n let to_input_legacy = to_input_legacy\n\n let if_ cond ~then_:t1 ~else_:t2 =\n let%map x = Field.Checked.if_ cond ~then_:t1.Poly.x ~else_:t2.Poly.x\n and is_odd = Boolean.if_ cond ~then_:t1.is_odd ~else_:t2.is_odd in\n Poly.{ x; is_odd }\n\n module Assert = struct\n let equal t1 t2 =\n let%map () = Field.Checked.Assert.equal t1.Poly.x t2.Poly.x\n and () = Boolean.Assert.(t1.is_odd = t2.is_odd) in\n ()\n end\n end\n\n (* end snarky-dependent *)\n [%%endif]\nend\n\nmodule Uncompressed = struct\n let decompress ({ x; is_odd } : Compressed.t) =\n Option.map (Inner_curve.find_y x) ~f:(fun y ->\n let y_parity = parity y in\n let y = if Bool.(is_odd = y_parity) then y else Field.negate y in\n (x, y) )\n\n let decompress_exn t =\n match decompress t with\n | Some d ->\n d\n | None ->\n failwith\n (sprintf \"Compressed public key %s could not be decompressed\"\n (Yojson.Safe.to_string @@ Compressed.to_yojson t) )\n\n let of_base58_check_decompress_exn pk_str =\n let pk = Compressed.of_base58_check_exn pk_str in\n decompress_exn pk |> ignore ;\n pk\n\n let compress = Compressed.compress\n\n [%%versioned_binable\n module Stable = struct\n module V1 = struct\n [@@@with_all_version_tags]\n\n type t = Field.t * Field.t [@@deriving compare, equal, hash]\n\n let to_latest = Fn.id\n\n include\n Binable.Of_binable_without_uuid\n (Compressed.Stable.V1)\n (struct\n type nonrec t = t\n\n let of_binable = decompress_exn\n\n let to_binable = compress\n end)\n\n let gen : t Quickcheck.Generator.t = gen_uncompressed\n\n let of_bigstring bs =\n let open Or_error.Let_syntax in\n let%map elem, _ = Bigstring.read_bin_prot bs bin_reader_t in\n elem\n\n let to_bigstring elem =\n let bs =\n Bigstring.create (bin_size_t elem + Bin_prot.Utils.size_header_length)\n in\n let _ = Bigstring.write_bin_prot bs bin_writer_t elem in\n bs\n\n (* We reuse the Base58check-based yojson (de)serialization from the\n compressed representation. *)\n\n let of_yojson json =\n let open Result in\n Compressed.of_yojson json\n >>= fun compressed ->\n Result.of_option ~error:\"couldn't decompress, curve point invalid\"\n (decompress compressed)\n\n let to_yojson t = Compressed.to_yojson @@ compress t\n\n (* as for yojson, use the Base58check-based sexps from the compressed representation *)\n let sexp_of_t t = Compressed.sexp_of_t @@ compress t\n\n let t_of_sexp sexp =\n Option.value_exn (decompress @@ Compressed.t_of_sexp sexp)\n end\n end]\n\n (* so we can make sets of public keys *)\n include Comparable.Make_binable (Stable.Latest)\n\n [%%define_locally\n Stable.Latest.\n (of_bigstring, to_bigstring, sexp_of_t, t_of_sexp, to_yojson, of_yojson)]\n\n let gen : t Quickcheck.Generator.t = gen_uncompressed\n\n let ( = ) = equal\n\n let of_inner_curve_exn = Inner_curve.to_affine_exn\n\n let to_inner_curve = Inner_curve.of_affine\n\n let%test_unit \"point-compression: decompress . compress = id\" =\n Quickcheck.test gen ~f:(fun pk ->\n assert (equal (decompress_exn (compress pk)) pk) )\n\n [%%ifdef consensus_mechanism]\n\n (* snarky-dependent *)\n\n type var = Field.Var.t * Field.Var.t\n\n let assert_equal var1 var2 =\n let open Field.Checked.Assert in\n let v1_f1, v1_f2 = var1 in\n let v2_f1, v2_f2 = var2 in\n let%bind () = equal v1_f1 v2_f1 in\n let%map () = equal v1_f2 v2_f2 in\n ()\n\n let var_of_t (x, y) = (Field.Var.constant x, Field.Var.constant y)\n\n let typ : (var, t) Typ.t = Typ.(field * field)\n\n let parity_var y =\n let%map bs = Field.Checked.unpack_full y in\n List.hd_exn (Bitstring_lib.Bitstring.Lsb_first.to_list bs)\n\n let decompress_var ({ x; is_odd } as c : Compressed.var) =\n let open Let_syntax in\n let%bind y =\n exists Typ.field\n ~compute:\n As_prover.(\n map (read Compressed.typ c) ~f:(fun c -> snd (decompress_exn c)))\n in\n let%map () = Inner_curve.Checked.Assert.on_curve (x, y)\n and () = parity_var y >>= Boolean.Assert.(( = ) is_odd) in\n (x, y)\n\n let%snarkydef_ compress_var ((x, y) : var) : Compressed.var Checked.t =\n let open Compressed_poly in\n let%map is_odd = parity_var y in\n { Poly.x; is_odd }\n\n (* end snarky-dependent *)\n [%%endif]\nend\n\ninclude Uncompressed\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Snark_params.Tick\n\n[%%versioned\nmodule Stable = struct\n module V1 = struct\n [@@@with_all_version_tags]\n\n type t = (Inner_curve.Scalar.t[@version_asserted])\n [@@deriving compare, sexp]\n\n (* deriver not working, apparently *)\n let sexp_of_t = [%sexp_of: Inner_curve.Scalar.t]\n\n let t_of_sexp = [%of_sexp: Inner_curve.Scalar.t]\n\n let to_latest = Fn.id\n\n [%%ifdef consensus_mechanism]\n\n let gen =\n let open Snark_params.Tick.Inner_curve.Scalar in\n let upperbound = Bignum_bigint.(pred size |> to_string) |> of_string in\n gen_uniform_incl one upperbound\n\n [%%else]\n\n let gen = Inner_curve.Scalar.(gen_uniform_incl one (zero - one))\n\n [%%endif]\n end\nend]\n\n[%%define_locally Stable.Latest.(gen)]\n\n[%%ifdef consensus_mechanism]\n\nlet create () =\n (* This calls into libsnark which uses /dev/urandom *)\n Inner_curve.Scalar.random ()\n\n[%%else]\n\nlet create () : t =\n let open Js_of_ocaml in\n let random_bytes_32 =\n Js.Unsafe.js_expr\n {js|(function() {\n var topLevel = (typeof self === 'object' && self.self === self && self) ||\n (typeof global === 'object' && global.global === global && global) ||\n this;\n var b;\n\n if (topLevel.crypto && topLevel.crypto.getRandomValues) {\n b = new Uint8Array(32);\n topLevel.crypto.getRandomValues(b);\n } else {\n if (typeof require === 'function') {\n var crypto = require('crypto');\n if (!crypto) {\n throw 'random values not available'\n }\n b = crypto.randomBytes(32);\n } else {\n throw 'random values not available'\n }\n }\n var res = [];\n for (var i = 0; i < 32; ++i) {\n res.push(b[i]);\n }\n res[31] &= 0x3f;\n return res;\n })|js}\n in\n let x : int Js.js_array Js.t = Js.Unsafe.fun_call random_bytes_32 [||] in\n let byte_undefined () = failwith \"byte undefined\" in\n Snarkette.Pasta.Fq.of_bigint\n (Snarkette.Nat.of_bytes\n (String.init 32 ~f:(fun i ->\n Char.of_int_exn (Js.Optdef.get (Js.array_get x i) byte_undefined) )\n ) )\n\n[%%endif]\n\ninclude Comparable.Make_binable (Stable.Latest)\n\n(* for compatibility with existing private key serializations *)\nlet of_bigstring_exn =\n Binable.of_bigstring (module Stable.Latest.With_all_version_tags)\n\nlet to_bigstring =\n Binable.to_bigstring (module Stable.Latest.With_all_version_tags)\n\nmodule Base58_check = Base58_check.Make (struct\n let description = \"Private key\"\n\n let version_byte = Base58_check.Version_bytes.private_key\nend)\n\nlet to_base58_check t =\n Base58_check.encode (to_bigstring t |> Bigstring.to_string)\n\nlet of_base58_check_exn s =\n let decoded = Base58_check.decode_exn s in\n decoded |> Bigstring.of_string |> of_bigstring_exn\n\nlet sexp_of_t t = to_base58_check t |> Sexp.of_string\n\nlet t_of_sexp sexp = Sexp.to_string sexp |> of_base58_check_exn\n\nlet to_yojson t = `String (to_base58_check t)\n\nlet of_yojson = function\n | `String x -> (\n try Ok (of_base58_check_exn x) with\n | Failure str ->\n Error str\n | exn ->\n Error (\"Signature_lib.Private_key.of_yojson: \" ^ Exn.to_string exn) )\n | _ ->\n Error \"Signature_lib.Private_key.of_yojson: Expected a string\"\n","[%%import \"/src/config.mlh\"]\n\nmodule Bignum_bigint = Bigint\nopen Core_kernel\n\nmodule type Message_intf = sig\n type field\n\n type t\n\n type curve\n\n type curve_scalar\n\n val derive :\n ?signature_kind:Mina_signature_kind.t\n -> t\n -> private_key:curve_scalar\n -> public_key:curve\n -> curve_scalar\n\n val derive_for_mainnet :\n t -> private_key:curve_scalar -> public_key:curve -> curve_scalar\n\n val derive_for_testnet :\n t -> private_key:curve_scalar -> public_key:curve -> curve_scalar\n\n val hash :\n ?signature_kind:Mina_signature_kind.t\n -> t\n -> public_key:curve\n -> r:field\n -> curve_scalar\n\n val hash_for_mainnet : t -> public_key:curve -> r:field -> curve_scalar\n\n val hash_for_testnet : t -> public_key:curve -> r:field -> curve_scalar\n\n [%%ifdef consensus_mechanism]\n\n type field_var\n\n type boolean_var\n\n type var\n\n type curve_var\n\n type curve_scalar_var\n\n type _ checked\n\n val hash_checked :\n var -> public_key:curve_var -> r:field_var -> curve_scalar_var checked\n\n [%%endif]\nend\n\n[%%ifdef consensus_mechanism]\n\nmodule type S = sig\n module Impl : Snarky_backendless.Snark_intf.S\n\n open Impl\n\n type curve\n\n type curve_var\n\n type curve_scalar\n\n type curve_scalar_var\n\n module Shifted : sig\n module type S =\n Snarky_curves.Shifted_intf\n with type curve_var := curve_var\n and type boolean_var := Boolean.var\n and type 'a checked := 'a Checked.t\n end\n\n module Message :\n Message_intf\n with type boolean_var := Boolean.var\n and type curve_scalar := curve_scalar\n and type curve_scalar_var := curve_scalar_var\n and type 'a checked := 'a Checked.t\n and type curve := curve\n and type curve_var := curve_var\n and type field := Field.t\n and type field_var := Field.Var.t\n\n module Signature : sig\n type t = field * curve_scalar [@@deriving sexp]\n\n type var = Field.Var.t * curve_scalar_var\n\n val typ : (var, t) Typ.t\n end\n\n module Private_key : sig\n type t = curve_scalar [@@deriving sexp]\n end\n\n module Public_key : sig\n type t = curve [@@deriving sexp]\n\n type var = curve_var\n end\n\n module Checked : sig\n val compress : curve_var -> Boolean.var list Checked.t\n\n val verifies :\n (module Shifted.S with type t = 't)\n -> Signature.var\n -> Public_key.var\n -> Message.var\n -> Boolean.var Checked.t\n\n val assert_verifies :\n (module Shifted.S with type t = 't)\n -> Signature.var\n -> Public_key.var\n -> Message.var\n -> unit Checked.t\n end\n\n val compress : curve -> bool list\n\n val sign :\n ?signature_kind:Mina_signature_kind.t\n -> Private_key.t\n -> Message.t\n -> Signature.t\n\n val verify :\n ?signature_kind:Mina_signature_kind.t\n -> Signature.t\n -> Public_key.t\n -> Message.t\n -> bool\nend\n\nmodule Make\n (Impl : Snarky_backendless.Snark_intf.S) (Curve : sig\n open Impl\n\n module Scalar : sig\n type t [@@deriving sexp, equal]\n\n type var\n\n val typ : (var, t) Typ.t\n\n val zero : t\n\n val ( * ) : t -> t -> t\n\n val ( + ) : t -> t -> t\n\n val negate : t -> t\n\n module Checked : sig\n val to_bits : var -> Boolean.var Bitstring_lib.Bitstring.Lsb_first.t\n end\n end\n\n type t [@@deriving sexp]\n\n type var = Field.Var.t * Field.Var.t\n\n module Checked :\n Snarky_curves.Weierstrass_checked_intf\n with module Impl := Impl\n and type t = var\n and type unchecked := t\n\n val one : t\n\n val ( + ) : t -> t -> t\n\n val negate : t -> t\n\n val scale : t -> Scalar.t -> t\n\n val to_affine_exn : t -> Field.t * Field.t\n end)\n (Message : Message_intf\n with type boolean_var := Impl.Boolean.var\n and type curve_scalar_var := Curve.Scalar.var\n and type curve_scalar := Curve.Scalar.t\n and type curve := Curve.t\n and type curve_var := Curve.var\n and type field := Impl.Field.t\n and type field_var := Impl.Field.Var.t\n and type 'a checked := 'a Impl.Checked.t) :\n S\n with module Impl := Impl\n and type curve := Curve.t\n and type curve_var := Curve.var\n and type curve_scalar := Curve.Scalar.t\n and type curve_scalar_var := Curve.Scalar.var\n and module Shifted := Curve.Checked.Shifted\n and module Message := Message = struct\n open Impl\n\n module Signature = struct\n type t = Field.t * Curve.Scalar.t [@@deriving sexp]\n\n type var = Field.Var.t * Curve.Scalar.var\n\n let typ : (var, t) Typ.t = Typ.tuple2 Field.typ Curve.Scalar.typ\n end\n\n module Private_key = struct\n type t = Curve.Scalar.t [@@deriving sexp]\n end\n\n module Public_key : sig\n type t = Curve.t [@@deriving sexp]\n\n type var = Curve.var\n end =\n Curve\n\n let compress (t : Curve.t) =\n let x, _ = Curve.to_affine_exn t in\n Field.unpack x\n\n let is_even (t : Field.t) = not (Bigint.test_bit (Bigint.of_field t) 0)\n\n let sign ?signature_kind (d_prime : Private_key.t) (m : Message.t) =\n let public_key =\n (* TODO: Don't recompute this. *) Curve.scale Curve.one d_prime\n in\n (* TODO: Once we switch to implicit sign-bit we'll have to conditionally negate d_prime. *)\n let d = d_prime in\n let derive = Message.derive ?signature_kind in\n let k_prime = derive m ~public_key ~private_key:d in\n assert (not Curve.Scalar.(equal k_prime zero)) ;\n let r, ry = Curve.(to_affine_exn (scale Curve.one k_prime)) in\n let k = if is_even ry then k_prime else Curve.Scalar.negate k_prime in\n let hash = Message.hash ?signature_kind in\n let e = hash m ~public_key ~r in\n let s = Curve.Scalar.(k + (e * d)) in\n (r, s)\n\n let verify ?signature_kind ((r, s) : Signature.t) (pk : Public_key.t)\n (m : Message.t) =\n let hash = Message.hash ?signature_kind in\n let e = hash ~public_key:pk ~r m in\n let r_pt = Curve.(scale one s + negate (scale pk e)) in\n match Curve.to_affine_exn r_pt with\n | rx, ry ->\n is_even ry && Field.equal rx r\n | exception _ ->\n false\n\n [%%if call_logger]\n\n let verify s pk m =\n Mina_debug.Call_logger.record_call \"Signature_lib.Schnorr.verify\" ;\n if Random.int 1000 = 0 then (\n print_endline \"SCHNORR BACKTRACE:\" ;\n Printexc.print_backtrace stdout ) ;\n verify s pk m\n\n [%%endif]\n\n module Checked = struct\n let to_bits x =\n Field.Checked.choose_preimage_var x ~length:Field.size_in_bits\n\n let compress ((x, _) : Curve.var) = to_bits x\n\n let is_even y =\n let%map bs = Field.Checked.unpack_full y in\n Bitstring_lib.Bitstring.Lsb_first.to_list bs |> List.hd_exn |> Boolean.not\n\n (* returning r_point as a representable point ensures it is nonzero so the nonzero\n * check does not have to explicitly be performed *)\n\n let%snarkydef_ verifier (type s) ~equal ~final_check\n ((module Shifted) as shifted :\n (module Curve.Checked.Shifted.S with type t = s) )\n ((r, s) : Signature.var) (public_key : Public_key.var) (m : Message.var)\n =\n let%bind e = Message.hash_checked m ~public_key ~r in\n (* s * g - e * public_key *)\n let%bind e_pk =\n Curve.Checked.scale shifted\n (Curve.Checked.negate public_key)\n (Curve.Scalar.Checked.to_bits e)\n ~init:Shifted.zero\n in\n let%bind s_g_e_pk =\n Curve.Checked.scale_known shifted Curve.one\n (Curve.Scalar.Checked.to_bits s)\n ~init:e_pk\n in\n let%bind rx, ry = Shifted.unshift_nonzero s_g_e_pk in\n let%bind y_even = is_even ry in\n let%bind r_correct = equal r rx in\n final_check r_correct y_even\n\n let verifies s =\n verifier ~equal:Field.Checked.equal ~final_check:Boolean.( && ) s\n\n let assert_verifies s =\n verifier ~equal:Field.Checked.Assert.equal\n ~final_check:(fun () ry_even -> Boolean.Assert.is_true ry_even)\n s\n end\nend\n\n[%%else]\n\n(* nonconsensus version of the functor; yes, there's some repeated code,\n but seems difficult to abstract over the functors and signatures\n*)\n\nmodule type S = sig\n open Snark_params.Tick\n\n type curve\n\n type curve_scalar\n\n module Message :\n Message_intf\n with type curve_scalar := curve_scalar\n and type curve := curve\n and type field := Field.t\n\n module Signature : sig\n type t = Field.t * curve_scalar [@@deriving sexp]\n end\n\n module Private_key : sig\n type t = curve_scalar [@@deriving sexp]\n end\n\n module Public_key : sig\n type t = curve [@@deriving sexp]\n end\n\n val sign :\n ?signature_kind:Mina_signature_kind.t\n -> Private_key.t\n -> Message.t\n -> Signature.t\n\n val verify :\n ?signature_kind:Mina_signature_kind.t\n -> Signature.t\n -> Public_key.t\n -> Message.t\n -> bool\nend\n\nmodule Make\n (Impl : module type of Snark_params.Tick) (Curve : sig\n open Impl\n\n module Scalar : sig\n type t [@@deriving sexp, equal]\n\n val zero : t\n\n val ( * ) : t -> t -> t\n\n val ( + ) : t -> t -> t\n\n val negate : t -> t\n end\n\n type t [@@deriving sexp]\n\n val one : t\n\n val ( + ) : t -> t -> t\n\n val negate : t -> t\n\n val scale : t -> Scalar.t -> t\n\n val to_affine_exn : t -> Field.t * Field.t\n end)\n (Message : Message_intf\n with type curve := Curve.t\n and type curve_scalar := Curve.Scalar.t\n and type field := Impl.Field.t) :\n S\n with type curve := Curve.t\n and type curve_scalar := Curve.Scalar.t\n and module Message := Message = struct\n module Private_key = struct\n type t = Curve.Scalar.t [@@deriving sexp]\n end\n\n module Signature = struct\n type t = Impl.Field.t * Curve.Scalar.t [@@deriving sexp]\n end\n\n module Public_key : sig\n type t = Curve.t [@@deriving sexp]\n end =\n Curve\n\n let is_even (t : Impl.Field.t) = not @@ Impl.Field.parity t\n\n let sign ?signature_kind (d_prime : Private_key.t) m =\n let public_key =\n (* TODO: Don't recompute this. *)\n Curve.scale Curve.one d_prime\n in\n (* TODO: Once we switch to implicit sign-bit we'll have to conditionally negate d_prime. *)\n let d = d_prime in\n let derive = Message.derive ?signature_kind in\n let k_prime = derive m ~public_key ~private_key:d in\n assert (not Curve.Scalar.(equal k_prime zero)) ;\n let r, (ry : Impl.Field.t) =\n Curve.(to_affine_exn (scale Curve.one k_prime))\n in\n let k = if is_even ry then k_prime else Curve.Scalar.negate k_prime in\n let hash = Message.hash ?signature_kind in\n let e = hash m ~public_key ~r in\n let s = Curve.Scalar.(k + (e * d)) in\n (r, s)\n\n let verify ?signature_kind ((r, s) : Signature.t) (pk : Public_key.t)\n (m : Message.t) =\n let hash = Message.hash ?signature_kind in\n let e = hash ~public_key:pk ~r m in\n let r_pt = Curve.(scale one s + negate (scale pk e)) in\n match Curve.to_affine_exn r_pt with\n | rx, ry ->\n is_even ry && Impl.Field.(equal rx r)\n | exception _ ->\n false\nend\n\n[%%endif]\n\nopen Snark_params\n\nmodule Message = struct\n let network_id_mainnet = String.of_char @@ Char.of_int_exn 1\n\n let network_id_testnet = String.of_char @@ Char.of_int_exn 0\n\n let network_id_other chain_name = chain_name\n\n let network_id =\n match Mina_signature_kind.t with\n | Mainnet ->\n network_id_mainnet\n | Testnet ->\n network_id_testnet\n | Other_network chain_name ->\n network_id_other chain_name\n\n module Legacy = struct\n open Tick\n\n type t = (Field.t, bool) Random_oracle.Input.Legacy.t [@@deriving sexp]\n\n let make_derive ~network_id t ~private_key ~public_key =\n let input =\n let x, y = Tick.Inner_curve.to_affine_exn public_key in\n Random_oracle.Input.Legacy.append t\n { field_elements = [| x; y |]\n ; bitstrings =\n [| Tock.Field.unpack private_key\n ; Fold_lib.Fold.(to_list (string_bits network_id))\n |]\n }\n in\n Random_oracle.Input.Legacy.to_bits ~unpack:Field.unpack input\n |> Array.of_list |> Blake2.bits_to_string |> Blake2.digest_string\n |> Blake2.to_raw_string |> Blake2.string_to_bits |> Array.to_list\n |> Fn.flip List.take (Int.min 256 (Tock.Field.size_in_bits - 1))\n |> Tock.Field.project\n\n let derive ?(signature_kind = Mina_signature_kind.t) =\n make_derive\n ~network_id:\n ( match signature_kind with\n | Mainnet ->\n network_id_mainnet\n | Testnet ->\n network_id_testnet\n | Other_network chain_name ->\n network_id_other chain_name )\n\n let derive_for_mainnet = make_derive ~network_id:network_id_mainnet\n\n let derive_for_testnet = make_derive ~network_id:network_id_testnet\n\n let make_hash ~init t ~public_key ~r =\n let input =\n let px, py = Inner_curve.to_affine_exn public_key in\n Random_oracle.Input.Legacy.append t\n { field_elements = [| px; py; r |]; bitstrings = [||] }\n in\n let open Random_oracle.Legacy in\n hash ~init (pack_input input)\n |> Digest.to_bits ~length:Field.size_in_bits\n |> Inner_curve.Scalar.of_bits\n\n let hash ?signature_kind =\n make_hash ~init:(Hash_prefix_states.signature_legacy ?signature_kind)\n\n let hash_for_mainnet =\n make_hash ~init:Hash_prefix_states.signature_for_mainnet_legacy\n\n let hash_for_testnet =\n make_hash ~init:Hash_prefix_states.signature_for_testnet_legacy\n\n [%%ifdef consensus_mechanism]\n\n type var = (Field.Var.t, Boolean.var) Random_oracle.Input.Legacy.t\n\n let%snarkydef_ hash_checked t ~public_key ~r =\n let input =\n let px, py = public_key in\n Random_oracle.Input.Legacy.append t\n { field_elements = [| px; py; r |]; bitstrings = [||] }\n in\n make_checked (fun () ->\n let open Random_oracle.Legacy.Checked in\n hash\n ~init:(Hash_prefix_states.signature_legacy ?signature_kind:None)\n (pack_input input)\n |> Digest.to_bits ~length:Field.size_in_bits\n |> Bitstring_lib.Bitstring.Lsb_first.of_list )\n\n [%%endif]\n end\n\n module Chunked = struct\n open Tick\n\n type t = Field.t Random_oracle.Input.Chunked.t [@@deriving sexp]\n\n let make_derive ~network_id t ~private_key ~public_key =\n let input =\n let x, y = Tick.Inner_curve.to_affine_exn public_key in\n let id = Fold_lib.Fold.(to_list (string_bits network_id)) in\n Random_oracle.Input.Chunked.append t\n { field_elements =\n [| x; y; Field.project (Tock.Field.unpack private_key) |]\n ; packeds = [| (Field.project id, List.length id) |]\n }\n in\n Array.map (Random_oracle.pack_input input) ~f:Tick.Field.unpack\n |> Array.to_list |> List.concat |> Array.of_list |> Blake2.bits_to_string\n |> Blake2.digest_string |> Blake2.to_raw_string |> Blake2.string_to_bits\n |> Array.to_list\n |> Fn.flip List.take (Int.min 256 (Tock.Field.size_in_bits - 1))\n |> Tock.Field.project\n\n let derive ?(signature_kind = Mina_signature_kind.t) =\n make_derive\n ~network_id:\n ( match signature_kind with\n | Mainnet ->\n network_id_mainnet\n | Testnet ->\n network_id_testnet\n | Other_network chain_name ->\n network_id_other chain_name )\n\n let derive_for_mainnet = make_derive ~network_id:network_id_mainnet\n\n let derive_for_testnet = make_derive ~network_id:network_id_testnet\n\n let make_hash ~init t ~public_key ~r =\n let input =\n let px, py = Inner_curve.to_affine_exn public_key in\n Random_oracle.Input.Chunked.append t\n { field_elements = [| px; py; r |]; packeds = [||] }\n in\n let open Random_oracle in\n hash ~init (pack_input input)\n |> Digest.to_bits ~length:Field.size_in_bits\n |> Inner_curve.Scalar.of_bits\n\n let hash ?signature_kind =\n make_hash ~init:(Hash_prefix_states.signature ?signature_kind)\n\n let hash_for_mainnet =\n make_hash ~init:Hash_prefix_states.signature_for_mainnet\n\n let hash_for_testnet =\n make_hash ~init:Hash_prefix_states.signature_for_testnet\n\n [%%ifdef consensus_mechanism]\n\n type var = Field.Var.t Random_oracle.Input.Chunked.t\n\n let%snarkydef_ hash_checked t ~public_key ~r =\n let input =\n let px, py = public_key in\n Random_oracle.Input.Chunked.append t\n { field_elements = [| px; py; r |]; packeds = [||] }\n in\n make_checked (fun () ->\n let open Random_oracle.Checked in\n hash\n ~init:(Hash_prefix_states.signature ?signature_kind:None)\n (pack_input input)\n |> Digest.to_bits ~length:Field.size_in_bits\n |> Bitstring_lib.Bitstring.Lsb_first.of_list )\n\n [%%endif]\n end\nend\n\nmodule Legacy = Make (Tick) (Tick.Inner_curve) (Message.Legacy)\nmodule Chunked = Make (Tick) (Tick.Inner_curve) (Message.Chunked)\n\n[%%ifdef consensus_mechanism]\n\nlet gen_legacy =\n let open Quickcheck.Let_syntax in\n let%map pk = Private_key.gen and msg = Tick.Field.gen in\n (pk, Random_oracle.Input.Legacy.field_elements [| msg |])\n\nlet gen_chunked =\n let open Quickcheck.Let_syntax in\n let%map pk = Private_key.gen and msg = Tick.Field.gen in\n (pk, Random_oracle.Input.Chunked.field_elements [| msg |])\n\n(* Use for reading only. *)\nlet legacy_message_typ () : (Message.Legacy.var, Message.Legacy.t) Tick.Typ.t =\n let to_hlist { Random_oracle.Input.Legacy.field_elements; bitstrings } =\n H_list.[ field_elements; bitstrings ]\n in\n let of_hlist ([ field_elements; bitstrings ] : (unit, _) H_list.t) =\n { Random_oracle.Input.Legacy.field_elements; bitstrings }\n in\n let open Tick.Typ in\n of_hlistable\n [ array ~length:0 Tick.Field.typ\n ; array ~length:0 (list ~length:0 Tick.Boolean.typ)\n ]\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist\n\n(* Use for reading only. *)\nlet chunked_message_typ () : (Message.Chunked.var, Message.Chunked.t) Tick.Typ.t\n =\n let open Tick.Typ in\n let const_typ =\n Typ\n { check = (fun _ -> Tick.Checked.return ())\n ; var_to_fields = (fun t -> ([||], t))\n ; var_of_fields = (fun (_, t) -> t)\n ; value_to_fields = (fun t -> ([||], t))\n ; value_of_fields = (fun (_, t) -> t)\n ; size_in_field_elements = 0\n ; constraint_system_auxiliary =\n (fun () -> failwith \"Cannot create constant in constraint-system mode\")\n }\n in\n let to_hlist { Random_oracle.Input.Chunked.field_elements; packeds } =\n H_list.[ field_elements; packeds ]\n in\n let of_hlist ([ field_elements; packeds ] : (unit, _) H_list.t) =\n { Random_oracle.Input.Chunked.field_elements; packeds }\n in\n of_hlistable\n [ array ~length:0 Tick.Field.typ\n ; array ~length:0 (Tick.Field.typ * const_typ)\n ]\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist\n\nlet%test_unit \"schnorr checked + unchecked\" =\n Quickcheck.test ~trials:5 gen_legacy ~f:(fun (pk, msg) ->\n let s = Legacy.sign pk msg in\n let pubkey = Tick.Inner_curve.(scale one pk) in\n assert (Legacy.verify s pubkey msg) ;\n (Tick.Test.test_equal ~sexp_of_t:[%sexp_of: bool] ~equal:Bool.equal\n Tick.Typ.(\n tuple3 Tick.Inner_curve.typ (legacy_message_typ ())\n Legacy.Signature.typ)\n Tick.Boolean.typ\n (fun (public_key, msg, s) ->\n let open Tick.Checked in\n let%bind (module Shifted) =\n Tick.Inner_curve.Checked.Shifted.create ()\n in\n Legacy.Checked.verifies (module Shifted) s public_key msg )\n (fun _ -> true) )\n (pubkey, msg, s) )\n\nlet%test_unit \"schnorr checked + unchecked\" =\n Quickcheck.test ~trials:5 gen_chunked ~f:(fun (pk, msg) ->\n let s = Chunked.sign pk msg in\n let pubkey = Tick.Inner_curve.(scale one pk) in\n assert (Chunked.verify s pubkey msg) ;\n (Tick.Test.test_equal ~sexp_of_t:[%sexp_of: bool] ~equal:Bool.equal\n Tick.Typ.(\n tuple3 Tick.Inner_curve.typ (chunked_message_typ ())\n Chunked.Signature.typ)\n Tick.Boolean.typ\n (fun (public_key, msg, s) ->\n let open Tick.Checked in\n let%bind (module Shifted) =\n Tick.Inner_curve.Checked.Shifted.create ()\n in\n Chunked.Checked.verifies (module Shifted) s public_key msg )\n (fun _ -> true) )\n (pubkey, msg, s) )\n\n[%%endif]\n","open Core_kernel\n\n[%%versioned\nmodule Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n type t =\n { public_key : Public_key.Stable.V1.t\n ; private_key : (Private_key.Stable.V1.t[@sexp.opaque])\n }\n [@@deriving sexp]\n\n let to_latest = Fn.id\n\n let to_yojson t = Public_key.Stable.V1.to_yojson t.public_key\n end\nend]\n\nmodule T = struct\n type t = Stable.Latest.t =\n { public_key : Public_key.t; private_key : (Private_key.t[@sexp.opaque]) }\n [@@deriving sexp]\n\n let compare { public_key = pk1; private_key = _ }\n { public_key = pk2; private_key = _ } =\n Public_key.compare pk1 pk2\n\n let to_yojson = Stable.Latest.to_yojson\nend\n\ninclude T\ninclude Comparable.Make (T)\n\nlet of_private_key_exn private_key =\n let public_key = Public_key.of_private_key_exn private_key in\n { public_key; private_key }\n\nlet create () = of_private_key_exn (Private_key.create ())\n\nlet gen = Quickcheck.Generator.(map ~f:of_private_key_exn Private_key.gen)\n\nmodule And_compressed_pk = struct\n module T = struct\n type t = T.t * Public_key.Compressed.t [@@deriving sexp]\n\n let compare ({ public_key = pk1; private_key = _ }, _)\n ({ public_key = pk2; private_key = _ }, _) =\n Public_key.compare pk1 pk2\n end\n\n include T\n include Comparable.Make (T)\nend\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Snark_params.Tick\n\n[%%versioned\nmodule Stable = struct\n module V1 = struct\n type t = Sgn_type.Sgn.Stable.V1.t = Pos | Neg\n [@@deriving sexp, hash, compare, equal, yojson]\n\n let to_latest = Fn.id\n end\nend]\n\nlet gen =\n Quickcheck.Generator.map Bool.quickcheck_generator ~f:(fun b ->\n if b then Pos else Neg )\n\nlet negate = function Pos -> Neg | Neg -> Pos\n\nlet neg_one = Field.(negate one)\n\nlet to_field = function Pos -> Field.one | Neg -> neg_one\n\nlet of_field_exn x =\n if Field.equal x Field.one then Pos\n else if Field.equal x neg_one then Neg\n else failwith \"Sgn.of_field: Expected positive or negative 1\"\n\n[%%ifdef consensus_mechanism]\n\ntype var = Field.Var.t\n\nlet typ : (var, t) Typ.t =\n let open Typ in\n Typ\n { check = (fun x -> assert_r1cs x x (Field.Var.constant Field.one))\n ; var_to_fields = (fun t -> ([| t |], ()))\n ; var_of_fields = (fun (ts, ()) -> ts.(0))\n ; value_to_fields = (fun t -> ([| to_field t |], ()))\n ; value_of_fields = (fun (ts, ()) -> of_field_exn ts.(0))\n ; size_in_field_elements = 1\n ; constraint_system_auxiliary = (fun () -> ())\n }\n\nmodule Checked = struct\n let two = Field.of_int 2\n\n let neg_two = Field.negate two\n\n let one_half = Field.inv two\n\n let neg_one_half = Field.negate one_half\n\n let is_pos (v : var) =\n Boolean.Unsafe.of_cvar\n (let open Field.Checked in\n one_half * (v + Field.Var.constant Field.one))\n\n let is_neg (v : var) =\n Boolean.Unsafe.of_cvar\n (let open Field.Checked in\n neg_one_half * (v - Field.Var.constant Field.one))\n\n let pos_if_true (b : Boolean.var) =\n let open Field.Checked in\n (two * (b :> Field.Var.t)) - Field.Var.constant Field.one\n\n let neg_if_true (b : Boolean.var) =\n let open Field.Checked in\n (neg_two * (b :> Field.Var.t)) + Field.Var.constant Field.one\n\n let negate t = Field.Var.scale t neg_one\n\n let constant = Fn.compose Field.Var.constant to_field\n\n let neg = constant Neg\n\n let pos = constant Pos\n\n let if_ = Field.Checked.if_\nend\n\n[%%endif]\n","open Core_kernel\n\nmodule Tree = struct\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n type ('hash, 'account) t =\n | Account of 'account\n | Hash of 'hash\n | Node of 'hash * ('hash, 'account) t * ('hash, 'account) t\n [@@deriving equal, sexp, yojson]\n\n let rec to_latest acct_to_latest = function\n | Account acct ->\n Account (acct_to_latest acct)\n | Hash hash ->\n Hash hash\n | Node (hash, l, r) ->\n Node (hash, to_latest acct_to_latest l, to_latest acct_to_latest r)\n end\n end]\n\n type ('hash, 'account) t = ('hash, 'account) Stable.Latest.t =\n | Account of 'account\n | Hash of 'hash\n | Node of 'hash * ('hash, 'account) t * ('hash, 'account) t\n [@@deriving equal, sexp, yojson]\nend\n\nmodule T = struct\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V2 = struct\n type ('hash, 'key, 'account) t =\n { indexes : ('key * int) list\n ; depth : int\n ; tree : ('hash, 'account) Tree.Stable.V1.t\n }\n [@@deriving sexp, yojson]\n end\n end]\n\n type ('hash, 'key, 'account) t = ('hash, 'key, 'account) Stable.Latest.t =\n { indexes : ('key * int) list\n ; depth : int\n ; tree : ('hash, 'account) Tree.t\n }\n [@@deriving sexp, yojson]\nend\n\nmodule type S = sig\n type hash\n\n type account_id\n\n type account\n\n type t = (hash, account_id, account) T.t [@@deriving sexp, yojson]\n\n val of_hash : depth:int -> hash -> t\n\n val get_exn : t -> int -> account\n\n val path_exn : t -> int -> [ `Left of hash | `Right of hash ] list\n\n val set_exn : t -> int -> account -> t\n\n val find_index_exn : t -> account_id -> int\n\n val add_path :\n t -> [ `Left of hash | `Right of hash ] list -> account_id -> account -> t\n\n val iteri : t -> f:(int -> account -> unit) -> unit\n\n val merkle_root : t -> hash\n\n val depth : t -> int\nend\n\nlet tree { T.tree; _ } = tree\n\nlet of_hash ~depth h = { T.indexes = []; depth; tree = Hash h }\n\nmodule Make (Hash : sig\n type t [@@deriving equal, sexp, yojson, compare]\n\n val merge : height:int -> t -> t -> t\nend) (Account_id : sig\n type t [@@deriving equal, sexp, yojson]\nend) (Account : sig\n type t [@@deriving equal, sexp, yojson]\n\n val data_hash : t -> Hash.t\nend) : sig\n include\n S\n with type hash := Hash.t\n and type account_id := Account_id.t\n and type account := Account.t\n\n val hash : (Hash.t, Account.t) Tree.t -> Hash.t\nend = struct\n type t = (Hash.t, Account_id.t, Account.t) T.t [@@deriving sexp, yojson]\n\n let of_hash ~depth (hash : Hash.t) = of_hash ~depth hash\n\n let hash : (Hash.t, Account.t) Tree.t -> Hash.t = function\n | Account a ->\n Account.data_hash a\n | Hash h ->\n h\n | Node (h, _, _) ->\n h\n\n type index = int [@@deriving sexp, yojson]\n\n let depth { T.depth; _ } = depth\n\n let merkle_root { T.tree; _ } = hash tree\n\n let add_path depth0 tree0 path0 account =\n let rec build_tree height p =\n match p with\n | `Left h_r :: path ->\n let l = build_tree (height - 1) path in\n Tree.Node (Hash.merge ~height (hash l) h_r, l, Hash h_r)\n | `Right h_l :: path ->\n let r = build_tree (height - 1) path in\n Node (Hash.merge ~height h_l (hash r), Hash h_l, r)\n | [] ->\n assert (height = -1) ;\n Account account\n in\n let rec union height tree path =\n match (tree, path) with\n | Tree.Hash h, path ->\n let t = build_tree height path in\n [%test_result: Hash.t]\n ~message:\n \"Hashes in union are not equal, something is wrong with your \\\n ledger\"\n ~expect:h (hash t) ;\n t\n | Node (h, l, r), `Left h_r :: path ->\n assert (Hash.equal h_r (hash r)) ;\n let l = union (height - 1) l path in\n Node (h, l, r)\n | Node (h, l, r), `Right h_l :: path ->\n assert (Hash.equal h_l (hash l)) ;\n let r = union (height - 1) r path in\n Node (h, l, r)\n | Node _, [] ->\n failwith \"Path too short\"\n | Account _, _ :: _ ->\n failwith \"Path too long\"\n | Account a, [] ->\n assert (Account.equal a account) ;\n tree\n in\n union (depth0 - 1) tree0 (List.rev path0)\n\n let add_path (t : t) path account_id account =\n let index =\n List.foldi path ~init:0 ~f:(fun i acc x ->\n match x with `Right _ -> acc + (1 lsl i) | `Left _ -> acc )\n in\n { t with\n tree = add_path t.depth t.tree path account\n ; indexes = (account_id, index) :: t.indexes\n }\n\n let iteri (t : t) ~f =\n let rec go acc i tree ~f =\n match tree with\n | Tree.Account a ->\n f acc a\n | Hash _ ->\n ()\n | Node (_, l, r) ->\n go acc (i - 1) l ~f ;\n go (acc + (1 lsl i)) (i - 1) r ~f\n in\n go 0 (t.depth - 1) t.tree ~f\n\n let ith_bit idx i = (idx lsr i) land 1 = 1\n\n let find_index_exn (t : t) aid =\n match List.Assoc.find t.indexes ~equal:Account_id.equal aid with\n | Some x ->\n x\n | None ->\n failwithf\n !\"Sparse_ledger.find_index_exn: %{sexp:Account_id.t} not in %{sexp: \\\n Account_id.t list}\"\n aid\n (List.map t.indexes ~f:fst)\n ()\n\n let get_exn ({ T.tree; depth; _ } as t) idx =\n let rec go i tree =\n match (i < 0, tree) with\n | true, Tree.Account acct ->\n acct\n | false, Node (_, l, r) ->\n let go_right = ith_bit idx i in\n if go_right then go (i - 1) r else go (i - 1) l\n | _ ->\n let expected_kind = if i < 0 then \"n account\" else \" node\" in\n let kind =\n match tree with\n | Account _ ->\n \"n account\"\n | Hash _ ->\n \" hash\"\n | Node _ ->\n \" node\"\n in\n failwithf\n !\"Sparse_ledger.get: Bad index %i. Expected a%s, but got a%s at \\\n depth %i. Tree = %{sexp:t}\"\n idx expected_kind kind (depth - i) t ()\n in\n go (depth - 1) tree\n\n let set_exn (t : t) idx acct =\n let rec go i tree =\n match (i < 0, tree) with\n | true, Tree.Account _ ->\n Tree.Account acct\n | false, Node (_, l, r) ->\n let l, r =\n let go_right = ith_bit idx i in\n if go_right then (l, go (i - 1) r) else (go (i - 1) l, r)\n in\n Node (Hash.merge ~height:i (hash l) (hash r), l, r)\n | _ ->\n let expected_kind = if i < 0 then \"n account\" else \" node\" in\n let kind =\n match tree with\n | Account _ ->\n \"n account\"\n | Hash _ ->\n \" hash\"\n | Node _ ->\n \" node\"\n in\n failwithf\n \"Sparse_ledger.set: Bad index %i. Expected a%s, but got a%s at \\\n depth %i.\"\n idx expected_kind kind (t.depth - i) ()\n in\n { t with tree = go (t.depth - 1) t.tree }\n\n let path_exn { T.tree; depth; _ } idx =\n let rec go acc i tree =\n if i < 0 then acc\n else\n match tree with\n | Tree.Account _ ->\n failwithf \"Sparse_ledger.path: Bad depth at index %i.\" idx ()\n | Hash _ ->\n failwithf \"Sparse_ledger.path: Dead end at index %i.\" idx ()\n | Node (_, l, r) ->\n let go_right = ith_bit idx i in\n if go_right then go (`Right (hash l) :: acc) (i - 1) r\n else go (`Left (hash r) :: acc) (i - 1) l\n in\n go [] (depth - 1) tree\nend\n\ntype ('hash, 'key, 'account) t = ('hash, 'key, 'account) T.t [@@deriving yojson]\n\nlet%test_module \"sparse-ledger-test\" =\n ( module struct\n module Hash = struct\n type t = Core_kernel.Md5.t [@@deriving sexp, compare]\n\n let equal h1 h2 = Int.equal (compare h1 h2) 0\n\n let to_yojson md5 = `String (Core_kernel.Md5.to_hex md5)\n\n let of_yojson = function\n | `String x ->\n Or_error.try_with (fun () -> Core_kernel.Md5.of_hex_exn x)\n |> Result.map_error ~f:Error.to_string_hum\n | _ ->\n Error \"Expected a hex-encoded MD5 hash\"\n\n let merge ~height x y =\n let open Md5 in\n digest_string\n (sprintf \"sparse-ledger_%03d\" height ^ to_binary x ^ to_binary y)\n\n let gen =\n Quickcheck.Generator.map String.quickcheck_generator\n ~f:Md5.digest_string\n end\n\n module Account = struct\n module T = struct\n type t = { name : string; favorite_number : int }\n [@@deriving bin_io, equal, sexp, yojson]\n end\n\n include T\n\n let key { name; _ } = name\n\n let data_hash t = Md5.digest_string (Binable.to_string (module T) t)\n\n let gen =\n let open Quickcheck.Generator.Let_syntax in\n let%map name = String.quickcheck_generator\n and favorite_number = Int.quickcheck_generator in\n { name; favorite_number }\n end\n\n module Account_id = struct\n type t = string [@@deriving sexp, equal, yojson]\n end\n\n include Make (Hash) (Account_id) (Account)\n\n let gen =\n let open Quickcheck.Generator in\n let open Let_syntax in\n let indexes max_depth t =\n let rec go addr d = function\n | Tree.Account a ->\n [ (Account.key a, addr) ]\n | Hash _ ->\n []\n | Node (_, l, r) ->\n go addr (d - 1) l @ go (addr lor (1 lsl d)) (d - 1) r\n in\n go 0 (max_depth - 1) t\n in\n let rec prune_hash_branches = function\n | Tree.Hash h ->\n Tree.Hash h\n | Account a ->\n Account a\n | Node (h, l, r) -> (\n match (prune_hash_branches l, prune_hash_branches r) with\n | Hash _, Hash _ ->\n Hash h\n | l, r ->\n Node (h, l, r) )\n in\n let rec gen depth =\n if depth = 0 then Account.gen >>| fun a -> Tree.Account a\n else\n let t =\n let sub = gen (depth - 1) in\n let%map l = sub and r = sub in\n Tree.Node (Hash.merge ~height:(depth - 1) (hash l) (hash r), l, r)\n in\n weighted_union\n [ (1. /. 3., Hash.gen >>| fun h -> Tree.Hash h); (2. /. 3., t) ]\n in\n let%bind depth = Int.gen_incl 0 16 in\n let%map tree = gen depth >>| prune_hash_branches in\n { T.tree; depth; indexes = indexes depth tree }\n\n let%test_unit \"iteri consistent indices with t.indexes\" =\n Quickcheck.test gen ~f:(fun t ->\n let indexes = Int.Set.of_list (t.indexes |> List.map ~f:snd) in\n iteri t ~f:(fun i _ ->\n [%test_result: bool]\n ~message:\n \"Iteri index should be contained in the indexes auxillary \\\n structure\"\n ~expect:true (Int.Set.mem indexes i) ) )\n\n let%test_unit \"path_test\" =\n Quickcheck.test gen ~f:(fun t ->\n let root = { t with indexes = []; tree = Hash (merkle_root t) } in\n let t' =\n List.fold t.indexes ~init:root ~f:(fun acc (_, index) ->\n let account = get_exn t index in\n add_path acc (path_exn t index) (Account.key account) account )\n in\n assert (Tree.equal Hash.equal Account.equal t'.tree t.tree) )\n end )\n","(* coding.ml -- hex encoding/decoding for Rosetta *)\n\n[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nmodule Field = Snark_params.Tick.Field\nmodule Scalar = Snark_params.Tick.Inner_curve.Scalar\nopen Signature_lib\n\n(* see RFC 0038, section \"marshal-keys\" for a specification *)\n\nlet hex_char_to_bits4 = function\n | '0' ->\n [ false; false; false; false ]\n | '1' ->\n [ false; false; false; true ]\n | '2' ->\n [ false; false; true; false ]\n | '3' ->\n [ false; false; true; true ]\n | '4' ->\n [ false; true; false; false ]\n | '5' ->\n [ false; true; false; true ]\n | '6' ->\n [ false; true; true; false ]\n | '7' ->\n [ false; true; true; true ]\n | '8' ->\n [ true; false; false; false ]\n | '9' ->\n [ true; false; false; true ]\n | 'A' | 'a' ->\n [ true; false; true; false ]\n | 'B' | 'b' ->\n [ true; false; true; true ]\n | 'C' | 'c' ->\n [ true; true; false; false ]\n | 'D' | 'd' ->\n [ true; true; false; true ]\n | 'E' | 'e' ->\n [ true; true; true; false ]\n | 'F' | 'f' ->\n [ true; true; true; true ]\n | _ ->\n failwith \"Expected hex character\"\n\nlet bits4_to_hex_char bits =\n List.mapi bits ~f:(fun i bit -> if bit then Int.pow 2 (3 - i) else 0)\n |> List.fold ~init:0 ~f:( + )\n |> fun n ->\n let s = sprintf \"%0X\" n in\n s.[0]\n\nmodule type Packed = sig\n type t\n\n val unpack : t -> bool list\nend\n\n(* break of the bits byte by byte *)\nlet bits_by_n n bits =\n let rec go bits acc =\n if List.is_empty bits then List.rev acc\n else\n let bitsn, rest = List.split_n bits n in\n go rest (bitsn :: acc)\n in\n go bits []\n\nlet bits_by_4s = bits_by_n 4\n\nlet bits_by_8s = bits_by_n 8\n\nlet of_unpackable (type t) (module M : Packed with type t = t)\n ?(padding_bit = false) (packed : t) =\n let bits0 = M.unpack packed |> List.rev in\n assert (Mina_stdlib.List.Length.Compare.(bits0 = 255)) ;\n (* field elements, scalars are 255 bits, left-pad to get 32 bytes *)\n let bits = padding_bit :: bits0 in\n (* break of the bits byte by byte *)\n (* In our encoding, we want highest bytes at the end and lowest at the\n beginning. *)\n let bytes = bits_by_8s bits in\n let bytes' = List.rev bytes in\n let bits' = List.concat bytes' in\n let cs = List.map (bits_by_4s bits') ~f:bits4_to_hex_char in\n String.of_char_list cs\n\nlet of_field = of_unpackable (module Field)\n\nlet of_scalar = of_unpackable (module Scalar)\n\nmodule type Unpacked = sig\n type t\n\n val project : bool list -> t\nend\n\nlet pack (type t) (module M : Unpacked with type t = t) (raw : string) :\n bool * t =\n (* 256 bits = 64 hex chars *)\n assert (Int.equal (String.length raw) 64) ;\n let bits =\n String.to_list raw |> List.map ~f:hex_char_to_bits4 |> List.concat\n in\n (* In our encoding, we have highest bytes at the end and lowest at the\n beginning. *)\n let bytes = bits_by_8s bits in\n let bytes_rev = List.rev bytes in\n let bits' = List.concat bytes_rev in\n\n let padding_bit = List.hd_exn bits' in\n (* remove padding bit *)\n let bits'' = List.tl_exn bits' |> List.rev in\n (padding_bit, M.project bits'')\n\nlet to_field hex = pack (module Field) hex |> snd\n\nlet to_scalar hex = pack (module Scalar) hex |> snd\n\nlet of_public_key_compressed pk =\n let { Public_key.Compressed.Poly.x; is_odd } = pk in\n of_field ~padding_bit:is_odd x\n\nlet of_public_key pk = of_public_key_compressed (Public_key.compress pk)\n\nlet to_public_key_compressed raw =\n let is_odd, x = pack (module Field) raw in\n { Public_key.Compressed.Poly.x; is_odd }\n\nlet to_public_key raw =\n to_public_key_compressed raw |> Public_key.decompress_exn\n\n(* inline tests hard-to-impossible to setup with JS *)\n\nlet field_hex_roundtrip_test () =\n let field0 = Field.of_int 123123 in\n let hex = of_field field0 in\n let field1 = to_field hex in\n Field.equal field0 field1\n\nlet pk_roundtrip_test () =\n let pk =\n { Public_key.Compressed.Poly.x = Field.of_int 123123; is_odd = true }\n in\n let hex = of_public_key_compressed pk in\n let pk' = to_public_key_compressed hex in\n Public_key.Compressed.equal pk pk'\n\nlet hex_key_odd =\n \"fad1d3e31aede102793fb2cce62b4f1e71a214c94ce18ad5756eba67ef398390\"\n\nlet hex_key_even =\n \"7e406ca640115a8c44ece6ef5d0c56af343b1a993d8c871648ab7980ecaf8230\"\n\nlet pk_compressed_roundtrip_test hex_key () =\n let pk = to_public_key hex_key in\n let hex' = of_public_key pk in\n String.equal (String.lowercase hex_key) (String.lowercase hex')\n\nlet%test \"field_hex round-trip\" = field_hex_roundtrip_test ()\n\nlet%test \"public key round-trip\" = pk_roundtrip_test ()\n\nlet%test \"public key compressed roundtrip odd\" =\n pk_compressed_roundtrip_test hex_key_odd ()\n\nlet%test \"public key compressed roundtrip even\" =\n pk_compressed_roundtrip_test hex_key_even ()\n\n(* for running tests from JS *)\n\nlet unit_tests =\n [ (\"field-hex round-trip\", field_hex_roundtrip_test)\n ; (\"public key round-trip\", pk_roundtrip_test)\n ; ( \"public key compressed round-trip odd\"\n , pk_compressed_roundtrip_test hex_key_odd )\n ; ( \"public key compressed round-trip even\"\n , pk_compressed_roundtrip_test hex_key_even )\n ]\n\nlet run_unit_tests () =\n List.iter unit_tests ~f:(fun (name, test) ->\n printf \"Running %s test\\n%!\" name ;\n assert (test ()) )\n","(* deriving.ml -- deriving ppx for Dhall types *)\n\n(* TODO:\n deriver for signatures\n default values in records\n*)\n\nopen Core_kernel\nopen Ppxlib\n\nlet deriver = \"dhall_type\"\n\nlet field_key_attr =\n Attribute.declare (deriver ^ \".key\") Attribute.Context.Label_declaration\n Ast_pattern.(single_expr_payload (estring __))\n Fn.id\n\nlet make_lident_cmp items lident =\n List.mem items (Longident.name lident.txt) ~equal:String.equal\n\nlet is_bool_lident = make_lident_cmp [ \"bool\"; \"Bool.t\" ]\n\nlet is_int_lident = make_lident_cmp [ \"int\"; \"Int.t\" ]\n\nlet is_float_lident = make_lident_cmp [ \"float\"; \"Float.t\" ]\n\nlet is_string_lident = make_lident_cmp [ \"string\"; \"String.t\" ]\n\nlet is_option_lident = make_lident_cmp [ \"option\"; \"Option.t\" ]\n\nlet is_list_lident = make_lident_cmp [ \"list\"; \"List.t\" ]\n\nlet rec dhall_type_of_core_type core_type =\n let (module Ast_builder) = Ast_builder.make core_type.ptyp_loc in\n let open Ast_builder in\n match core_type.ptyp_desc with\n | Ptyp_constr (lident, []) when is_bool_lident lident ->\n [%expr Ppx_dhall_type.Dhall_type.Bool]\n | Ptyp_constr (lident, []) when is_int_lident lident ->\n [%expr Ppx_dhall_type.Dhall_type.Integer]\n | Ptyp_constr (lident, []) when is_float_lident lident ->\n [%expr Ppx_dhall_type.Dhall_type.Double]\n | Ptyp_constr (lident, []) when is_string_lident lident ->\n [%expr Ppx_dhall_type.Dhall_type.Text]\n | Ptyp_constr (lident, [ ty ]) when is_option_lident lident ->\n [%expr Ppx_dhall_type.Dhall_type.Optional [%e dhall_type_of_core_type ty]]\n | Ptyp_constr (lident, [ ty ]) when is_list_lident lident ->\n [%expr Ppx_dhall_type.Dhall_type.List [%e dhall_type_of_core_type ty]]\n | Ptyp_constr ({ txt = Lident id; _ }, []) ->\n evar (id ^ \"_dhall_type\")\n | Ptyp_constr ({ txt = Lident id; _ }, params) ->\n let dhall_type_fun = evar (id ^ \"_dhall_type\") in\n let args = List.map params ~f:dhall_type_of_core_type in\n eapply dhall_type_fun args\n | Ptyp_constr ({ txt = Ldot (prefix, nm); _ }, []) ->\n let mod_path = Longident.name prefix in\n if String.equal nm \"t\" then evar (mod_path ^ \".dhall_type\")\n else evar (mod_path ^ \".\" ^ nm ^ \"_dhall_type\")\n | Ptyp_constr ({ txt = Ldot (prefix, nm); _ }, params) ->\n let mod_path = Longident.name prefix in\n let dhall_type_fun =\n if String.equal nm \"t\" then evar (mod_path ^ \".dhall_type\")\n else evar (mod_path ^ \".\" ^ nm ^ \"_dhall_type\")\n in\n let args = List.map params ~f:dhall_type_of_core_type in\n eapply dhall_type_fun args\n | Ptyp_var a ->\n evar a\n | _ ->\n Location.raise_errorf ~loc:core_type.ptyp_loc \"Unsupported type\"\n\nlet dhall_variant_from_constructor_declaration ctor_decl =\n let (module Ast_builder) = Ast_builder.make ctor_decl.pcd_name.loc in\n let open Ast_builder in\n let name = estring @@ String.lowercase ctor_decl.pcd_name.txt in\n match ctor_decl.pcd_args with\n | Pcstr_tuple [] ->\n [%expr [%e name], None]\n | Pcstr_tuple [ ty ] ->\n [%expr [%e name], Some [%e dhall_type_of_core_type ty]]\n | Pcstr_tuple tys ->\n let tys_expr = elist (List.map tys ~f:dhall_type_of_core_type) in\n [%expr [%e name], Some (List [%e tys_expr])]\n | Pcstr_record _ ->\n Location.raise_errorf ~loc:ctor_decl.pcd_name.loc\n \"Records not yet supported\"\n\nlet dhall_field_from_label_declaration label_decl =\n let (module Ast_builder) = Ast_builder.make label_decl.pld_name.loc in\n let open Ast_builder in\n let name =\n match Attribute.get field_key_attr label_decl with\n | Some name ->\n estring name\n | None ->\n estring label_decl.pld_name.txt\n in\n let ty = dhall_type_of_core_type label_decl.pld_type in\n [%expr [%e name], [%e ty]]\n\nlet generate_dhall_type type_decl =\n let (module Ast_builder) = Ast_builder.make type_decl.ptype_loc in\n let open Ast_builder in\n let dhall_type =\n match type_decl.ptype_kind with\n | Ptype_abstract -> (\n match type_decl.ptype_manifest with\n | None ->\n Location.raise_errorf ~loc:type_decl.ptype_loc\n \"Abstract type declaration has no manifest (right-hand side)\"\n | Some core_type ->\n dhall_type_of_core_type core_type )\n | Ptype_variant ctor_decls ->\n [%expr\n Ppx_dhall_type.Dhall_type.Union\n [%e\n elist\n (List.map ctor_decls\n ~f:dhall_variant_from_constructor_declaration )]]\n | Ptype_record label_decls ->\n [%expr\n Ppx_dhall_type.Dhall_type.Record\n [%e\n elist (List.map label_decls ~f:dhall_field_from_label_declaration)]]\n | Ptype_open ->\n Location.raise_errorf ~loc:type_decl.ptype_loc\n \"Open types not supported\"\n in\n let ty_name =\n match type_decl.ptype_name.txt with\n | \"t\" ->\n pvar \"dhall_type\"\n | nm ->\n pvar (nm ^ \"_dhall_type\")\n in\n match type_decl.ptype_params with\n | [] ->\n [%stri let [%p ty_name] = [%e dhall_type]]\n | params ->\n let args =\n List.map params ~f:(fun (core_type, _variance) ->\n match core_type.ptyp_desc with\n | Ptyp_var a ->\n pvar a\n | _ ->\n Location.raise_errorf ~loc:type_decl.ptype_loc\n \"Type parameter not a type variable\" )\n in\n let abs = eabstract args dhall_type in\n [%stri let [%p ty_name] = [%e abs]]\n\nlet generate_dhall_types ~loc:_ ~path:_ (_rec_flag, type_decls) =\n List.map type_decls ~f:generate_dhall_type\n\nlet attributes = [ Attribute.T field_key_attr ]\n\nlet str_type_decl =\n Deriving.Generator.make_noarg ~attributes generate_dhall_types\n\nlet () = Deriving.add deriver ~str_type_decl |> Ppxlib.Deriving.ignore\n","(** Global slot span implementation *)\n\nopen Core_kernel\n\n(** See documentation of the {!Mina_wire_types} library *)\nmodule Wire_types = Mina_wire_types.Mina_numbers.Global_slot_span\n\ntype uint32 = Unsigned.uint32\n\nmodule Make_sig (A : Wire_types.Types.S) = struct\n module type S = sig\n include Global_slot_intf.S_span with type Stable.V1.t = A.V1.t\n end\nend\n\nmodule T = Nat.Make32 ()\n\nmodule Make_str (_ : Wire_types.Concrete) = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Wire_types.global_slot_span = Global_slot_span of T.Stable.V1.t\n [@@unboxed] [@@deriving hash, sexp, compare, equal, yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n let to_uint32 (Global_slot_span u32) : uint32 = u32\n\n let of_uint32 u32 : t = Global_slot_span u32\n\n module Checked = struct\n include T.Checked\n\n let constant t = constant @@ to_uint32 t\n\n let typ =\n Snark_params.Tick.Typ.transport T.Checked.typ ~there:to_uint32\n ~back:of_uint32\n end\n\n let to_string t = Unsigned.UInt32.to_string @@ to_uint32 t\n\n let of_string s = of_uint32 @@ Unsigned.UInt32.of_string s\n\n let typ = Checked.typ\n\n let gen =\n let%map.Quickcheck u32 = T.gen in\n of_uint32 u32\n\n let gen_incl t1 t2 =\n let u32_1 = to_uint32 t1 in\n let u32_2 = to_uint32 t2 in\n let%map.Quickcheck u32 = T.gen_incl u32_1 u32_2 in\n of_uint32 u32\n\n let dhall_type = Ppx_dhall_type.Dhall_type.Text\n\n let zero = of_uint32 T.zero\n\n let one = of_uint32 T.one\n\n let succ t = of_uint32 (T.succ @@ to_uint32 t)\n\n let max_value = of_uint32 Unsigned.UInt32.max_int\n\n let to_field t = T.to_field (to_uint32 t)\n\n let to_input t = T.to_input (to_uint32 t)\n\n let to_input_legacy t = T.to_input_legacy (to_uint32 t)\n\n include Comparable.Make (Stable.Latest)\n\n let add t1 t2 =\n let u32_1 = to_uint32 t1 in\n let u32_2 = to_uint32 t2 in\n let sum = T.add u32_1 u32_2 in\n of_uint32 sum\n\n let sub t1 t2 =\n let u32_1 = to_uint32 t1 in\n let u32_2 = to_uint32 t2 in\n Option.map (T.sub u32_1 u32_2) ~f:of_uint32\n\n let of_int n = of_uint32 (T.of_int n)\n\n let to_int t = T.to_int (to_uint32 t)\n\n let random () = of_uint32 (T.random ())\nend\n\ninclude Wire_types.Make (Make_sig) (Make_str)\n","(** Global slot (since genesis) implementation *)\n\nopen Core_kernel\n\n(** See documentation of the {!Mina_wire_types} library *)\nmodule Wire_types = Mina_wire_types.Mina_numbers.Global_slot_since_genesis\n\ntype uint32 = Unsigned.uint32\n\nmodule Make_sig (A : Wire_types.Types.S) = struct\n module type S = sig\n include\n Global_slot_intf.S\n with type Stable.V1.t = A.V1.t\n and type global_slot_span = Global_slot_span.t\n and type Checked.global_slot_span_checked = Global_slot_span.Checked.t\n end\nend\n\nmodule T = Nat.Make32 ()\n\nmodule Make_str (_ : Wire_types.Concrete) = struct\n module M = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Wire_types.global_slot = Since_genesis of T.Stable.V1.t\n [@@unboxed] [@@deriving hash, sexp, compare, equal, yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n module T = T\n\n let to_uint32 (Since_genesis u32) : uint32 = u32\n\n let of_uint32 u32 : t = Since_genesis u32\n end\n\n include M\n include Global_slot.Make (M)\nend\n\ninclude Wire_types.Make (Make_sig) (Make_str)\n","(** Global slot (since hard fork) implementation *)\n\nopen Core_kernel\n\n(** See documentation of the {!Mina_wire_types} library *)\nmodule Wire_types = Mina_wire_types.Mina_numbers.Global_slot_since_hard_fork\n\ntype uint32 = Unsigned.uint32\n\nmodule Make_sig (A : Wire_types.Types.S) = struct\n module type S = sig\n include\n Global_slot_intf.S\n with type Stable.V1.t = A.V1.t\n and type global_slot_span = Global_slot_span.t\n and type Checked.global_slot_span_checked = Global_slot_span.Checked.t\n end\nend\n\nmodule T = Nat.Make32 ()\n\nmodule Make_str (_ : Wire_types.Concrete) = struct\n module M = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Wire_types.global_slot = Since_hard_fork of T.Stable.V1.t\n [@@unboxed] [@@deriving hash, sexp, compare, equal, yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n module T = T\n\n let to_uint32 (Since_hard_fork u32) : uint32 = u32\n\n let of_uint32 u32 : t = Since_hard_fork u32\n end\n\n include M\n include Global_slot.Make (M)\nend\n\ninclude Wire_types.Make (Make_sig) (Make_str)\n","open Core_kernel\n\n[%%versioned\nmodule Stable = struct\n module V1 = struct\n type ('magnitude, 'sgn) t =\n ('magnitude, 'sgn) Mina_wire_types.Signed_poly.V1.t =\n { magnitude : 'magnitude; sgn : 'sgn }\n [@@deriving annot, sexp, hash, compare, equal, yojson, fields]\n end\nend]\n\nlet map ~f { magnitude; sgn } = { magnitude = f magnitude; sgn }\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Snark_bits\nopen Snark_params\nopen Tick\n\n[%%ifdef consensus_mechanism]\n\nopen Bitstring_lib\nopen Let_syntax\n\n[%%endif]\n\nopen Intf\n\n(** [Currency_oveflow] is being thrown to signal an overflow\n or underflow during conversions from [int] to currency.\n The exception contains the [int] value that caused the\n misbehaviour. *)\nexception Currency_overflow of int\n\ntype uint64 = Unsigned.uint64\n\n(** See documentation of the {!Mina_wire_types} library *)\nmodule Wire_types = Mina_wire_types.Currency\n\n(** Define the expected full signature of the module, based on the types defined\n in {!Mina_wire_types} *)\nmodule Make_sig (A : Wire_types.Types.S) = struct\n module type S =\n Intf.Full\n (* full interface defined in a separate file, as it would appear\n in the MLI *)\n with type Fee.Stable.V1.t = A.Fee.V1.t\n (* with added type equalities *)\n and type Amount.Stable.V1.t = A.Amount.V1.t\n and type Balance.Stable.V1.t = A.Balance.V1.t\nend\n\n(** Then we make the real module, which has to have a signature of type\n {!Make_sig(A)}. Here, since all types are simple type aliases, we don't need\n to use [A] in the implementation. Otherwise, we would need to add type\n equalities to the corresponding type in [A] in each type definition. *)\nmodule Make_str (A : Wire_types.Concrete) = struct\n module Signed_poly = Signed_poly\n\n [%%ifdef consensus_mechanism]\n\n module Signed_var = struct\n type 'mag repr = ('mag, Sgn.var) Signed_poly.t\n\n (* Invariant: At least one of these is Some *)\n type nonrec 'mag t =\n { repr : 'mag repr; mutable value : Field.Var.t option }\n end\n\n [%%endif]\n\n module Make (Unsigned : sig\n include Unsigned_extended.S\n\n val to_uint64 : t -> uint64\n\n val of_uint64 : uint64 -> t\n end) (M : sig\n val length : int\n end) : sig\n [%%ifdef consensus_mechanism]\n\n include\n S\n with type t = Unsigned.t\n and type var = Field.Var.t\n and type Signed.var = Field.Var.t Signed_var.t\n and type Signed.signed_fee = (Unsigned.t, Sgn.t) Signed_poly.t\n and type Signed.Checked.signed_fee_var = Field.Var.t Signed_var.t\n\n val pack_var : var -> Field.Var.t\n\n [%%else]\n\n include\n S\n with type t = Unsigned.t\n and type Signed.signed_fee := (Unsigned.t, Sgn.t) Signed_poly.t\n\n [%%endif]\n\n val scale : t -> int -> t option\n end = struct\n let max_int = Unsigned.max_int\n\n let length_in_bits = M.length\n\n type t = Unsigned.t [@@deriving sexp, compare, hash]\n\n (* can't be automatically derived *)\n let dhall_type = Ppx_dhall_type.Dhall_type.Text\n\n [%%define_locally\n Unsigned.(to_uint64, of_uint64, of_int, to_int, of_string, to_string)]\n\n let precision = 9\n\n let precision_exp = Unsigned.of_int @@ Int.pow 10 precision\n\n let to_mina_string amount =\n let rec go num_stripped_zeros num =\n let open Int in\n if num mod 10 = 0 && num <> 0 then go (num_stripped_zeros + 1) (num / 10)\n else (num_stripped_zeros, num)\n in\n\n let whole = Unsigned.div amount precision_exp in\n let remainder = Unsigned.to_int (Unsigned.rem amount precision_exp) in\n if Int.(remainder = 0) then to_string whole\n else\n let num_stripped_zeros, num = go 0 remainder in\n Printf.sprintf \"%s.%0*d\" (to_string whole)\n Int.(precision - num_stripped_zeros)\n num\n\n let of_mina_string_exn input =\n let parts = String.split ~on:'.' input in\n match parts with\n | [ whole ] ->\n of_string (whole ^ String.make precision '0')\n | [ whole; decimal ] ->\n let decimal_length = String.length decimal in\n if Int.(decimal_length > precision) then\n of_string (whole ^ String.sub decimal ~pos:0 ~len:precision)\n else\n of_string\n ( whole ^ decimal\n ^ String.make Int.(precision - decimal_length) '0' )\n | _ ->\n failwith \"Currency.of_mina_string_exn: Invalid currency input\"\n\n module Arg = struct\n type typ = t [@@deriving sexp, hash, compare]\n\n type t = typ [@@deriving sexp, hash, compare]\n\n let to_string = to_mina_string\n\n let of_string = of_mina_string_exn\n end\n\n include Codable.Make_of_string (Arg)\n include Hashable.Make (Arg)\n include Comparable.Make (Arg)\n\n let gen_incl a b : t Quickcheck.Generator.t =\n let a = Bignum_bigint.of_string Unsigned.(to_string a) in\n let b = Bignum_bigint.of_string Unsigned.(to_string b) in\n Quickcheck.Generator.map\n Bignum_bigint.(gen_incl a b)\n ~f:(fun n -> of_string (Bignum_bigint.to_string n))\n\n let gen : t Quickcheck.Generator.t =\n let m = Bignum_bigint.of_string Unsigned.(to_string max_int) in\n Quickcheck.Generator.map\n Bignum_bigint.(gen_incl zero m)\n ~f:(fun n -> of_string (Bignum_bigint.to_string n))\n\n module Vector = struct\n include M\n include Unsigned\n\n let empty = zero\n\n let get t i = Infix.((t lsr i) land one = one)\n\n let set v i b =\n if b then Infix.(v lor (one lsl i))\n else Infix.(v land lognot (one lsl i))\n end\n\n module B = Bits.Vector.Make (Vector)\n\n include (B : Bits_intf.Convertible_bits with type t := t)\n\n [%%ifdef consensus_mechanism]\n\n type var = Field.Var.t\n\n let pack_var = Fn.id\n\n let equal_var = Field.Checked.equal\n\n let m = Snark_params.Tick.m\n\n let make_checked = Snark_params.Tick.make_checked\n\n let var_to_bits_ (t : var) = Field.Checked.unpack ~length:length_in_bits t\n\n let var_to_bits t = var_to_bits_ t >>| Bitstring.Lsb_first.of_list\n\n let var_to_input (t : var) =\n Random_oracle.Input.Chunked.packed (t, length_in_bits)\n\n let var_to_input_legacy (t : var) =\n var_to_bits_ t >>| Random_oracle.Input.Legacy.bitstring\n\n let var_of_t (t : t) : var = Field.Var.constant (Field.project (to_bits t))\n\n let if_ cond ~then_ ~else_ : var Checked.t =\n Field.Checked.if_ cond ~then_ ~else_\n\n let () = assert (Int.(length_in_bits mod 16 = 0))\n\n (** UNSAFE. Take the field element formed by the final [length_in_bits] bits\n of the argument.\n\n WARNING: The returned value may be chosen arbitrarily by a malicious\n prover, and this is really only useful for the more-efficient bit\n projection. Users of this function must manually assert the relationship\n between the argument and the return value, or the circuit will be\n underconstrained.\n *)\n let image_from_bits_unsafe (t : var) =\n make_checked (fun () ->\n let _, _, actual_packed =\n Pickles.Scalar_challenge.to_field_checked' ~num_bits:length_in_bits\n m\n (Kimchi_backend_common.Scalar_challenge.create t)\n in\n actual_packed )\n\n (** [range_check t] asserts that [0 <= t < 2^length_in_bits].\n\n Any value consumed or returned by functions in this module must satisfy\n this assertion.\n *)\n let range_check t =\n let%bind actual = image_from_bits_unsafe t in\n with_label \"range_check\" (fun () -> Field.Checked.Assert.equal actual t)\n\n let seal x = make_checked (fun () -> Pickles.Util.seal Tick.m x)\n\n let modulus_as_field =\n lazy (Fn.apply_n_times ~n:length_in_bits Field.(mul (of_int 2)) Field.one)\n\n let double_modulus_as_field =\n lazy (Field.(mul (of_int 2)) (Lazy.force modulus_as_field))\n\n (** [range_check_flagged kind t] returns [t'] that fits in [length_in_bits]\n bits, and satisfies [t' = t + k * 2^length_in_bits] for some [k].\n The [`Overflow b] return value is false iff [t' = t].\n\n This function should be used when [t] was computed via addition or\n subtraction, to calculate the equivalent value that would be returned by\n overflowing or underflowing an integer with [length_in_bits] bits.\n\n The [`Add] and [`Sub] values for [kind] are specializations that use\n fewer constraints and perform fewer calculations. Any inputs that satisfy\n the invariants for [`Add] or [`Sub] will return the same value if\n [`Add_or_sub] is used instead.\n\n Invariants:\n * if [kind] is [`Add], [0 <= t < 2 * 2^length_in_bits - 1];\n * if [kind] is [`Sub], [- 2^length_in_bits < t < 2^length_in_bits];\n * if [kind] is [`Add_or_sub],\n [- 2^length_in_bits < t < 2 * 2^length_in_bits - 1].\n *)\n let range_check_flagged (kind : [ `Add | `Sub | `Add_or_sub ]) t =\n let%bind adjustment_factor =\n exists Field.typ\n ~compute:\n As_prover.(\n let%map t = read Field.typ t in\n match kind with\n | `Add ->\n if Int.(Field.compare t (Lazy.force modulus_as_field) < 0)\n then (* Within range. *)\n Field.zero\n else\n (* Overflowed. We compensate by subtracting [modulus_as_field]. *)\n Field.(negate one)\n | `Sub ->\n if Int.(Field.compare t (Lazy.force modulus_as_field) < 0)\n then (* Within range. *)\n Field.zero\n else\n (* Underflowed, but appears as an overflow because of wrapping in\n the field (that is, -1 is the largest field element, -2 is the\n second largest, etc.). Compensate by adding [modulus_as_field].\n *)\n Field.one\n | `Add_or_sub ->\n (* This case is a little more nuanced: -modulus_as_field < t <\n 2*modulus_as_field, and we need to detect which 'side of 0' we\n are. Thus, we have 3 cases:\n *)\n if Int.(Field.compare t (Lazy.force modulus_as_field) < 0)\n then\n (* 1. we are already in the desired range, no adjustment; *)\n Field.zero\n else if\n Int.(\n Field.compare t (Lazy.force double_modulus_as_field) < 0)\n then\n (* 2. we are in the range\n [modulus_as_field <= t < 2 * modulus_as_field],\n so this was an addition that overflowed, and we should\n compensate by subtracting [modulus_as_field];\n *)\n Field.(negate one)\n else\n (* 3. we are outside of either range, so this must be the\n underflow of a subtraction, and we should compensate by\n adding [modulus_as_field].\n *)\n Field.one)\n in\n let%bind out_of_range =\n match kind with\n | `Add ->\n (* 0 or -1 => 0 or 1 *)\n Boolean.of_field (Field.Var.negate adjustment_factor)\n | `Sub ->\n (* Already 0 or 1 *)\n Boolean.of_field adjustment_factor\n | `Add_or_sub ->\n (* The return flag [out_of_range] is a boolean represented by either 0\n when [t] is in range or 1 when [t] is out-of-range.\n Notice that [out_of_range = adjustment_factor^2] gives us exactly\n the desired values, and moreover we can ensure that\n [adjustment_factor] is exactly one of -1, 0 or 1 by checking that\n [out_of_range] is boolean.\n *)\n Field.Checked.mul adjustment_factor adjustment_factor\n >>= Boolean.of_field\n in\n (* [t_adjusted = t + adjustment_factor * modulus_as_field] *)\n let t_adjusted =\n let open Field.Var in\n add t (scale adjustment_factor (Lazy.force modulus_as_field))\n in\n let%bind t_adjusted = seal t_adjusted in\n let%map () = range_check t_adjusted in\n (t_adjusted, `Overflow out_of_range)\n\n let of_field (x : Field.t) : t =\n of_bits (List.take (Field.unpack x) length_in_bits)\n\n let to_field (x : t) : Field.t = Field.project (to_bits x)\n\n let typ : (var, t) Typ.t =\n let (Typ typ) = Field.typ in\n Typ.transport\n (Typ { typ with check = range_check })\n ~there:to_field ~back:of_field\n\n [%%endif]\n\n let zero = Unsigned.zero\n\n let one = Unsigned.one\n\n (* The number of nanounits in a unit. User for unit transformations. *)\n let unit_to_nano = 1_000_000_000\n\n let to_nanomina_int = to_int\n\n let to_mina_int m = to_int m / unit_to_nano\n\n let sub x y = if x < y then None else Some (Unsigned.sub x y)\n\n let sub_flagged x y =\n let z = Unsigned.sub x y in\n (z, `Underflow (x < y))\n\n let add x y =\n let z = Unsigned.add x y in\n if z < x then None else Some z\n\n let add_flagged x y =\n let z = Unsigned.add x y in\n (z, `Overflow (z < x))\n\n let add_signed_flagged x y =\n match y.Signed_poly.sgn with\n | Sgn.Pos ->\n let z, `Overflow b = add_flagged x y.Signed_poly.magnitude in\n (z, `Overflow b)\n | Sgn.Neg ->\n let z, `Underflow b = sub_flagged x y.Signed_poly.magnitude in\n (z, `Overflow b)\n\n let scale u64 i =\n if Int.(i = 0) then Some zero\n else\n let i = Unsigned.of_int i in\n let max_val = Unsigned.(div max_int i) in\n if max_val >= u64 then Some (Unsigned.mul u64 i) else None\n\n let ( + ) = add\n\n let ( - ) = sub\n\n (* The functions below are unsafe, because they could overflow or\n underflow. They perform appropriate checks to guard against this\n and either raise Currency_overflow exception or return None\n depending on the error-handling strategy.\n\n It is advisable to use nanomina and mina wherever possible and\n limit the use of _exn veriants to places where a fixed value is\n being converted and hence overflow cannot happen. *)\n let of_nanomina_int i = if Int.(i >= 0) then Some (of_int i) else None\n\n let of_mina_int i =\n Option.(of_nanomina_int i >>= Fn.flip scale unit_to_nano)\n\n let of_nanomina_int_exn i =\n match of_nanomina_int i with\n | None ->\n raise (Currency_overflow i)\n | Some m ->\n m\n\n let of_mina_int_exn i =\n match of_mina_int i with\n | None ->\n raise (Currency_overflow i)\n | Some m ->\n m\n\n type magnitude = t [@@deriving sexp, hash, compare, yojson]\n\n let to_input (t : t) =\n Random_oracle.Input.Chunked.packed\n (Field.project (to_bits t), length_in_bits)\n\n let to_input_legacy t = Random_oracle.Input.Legacy.bitstring @@ to_bits t\n\n module Signed = struct\n type ('magnitude, 'sgn) typ = ('magnitude, 'sgn) Signed_poly.t =\n { magnitude : 'magnitude; sgn : 'sgn }\n [@@deriving sexp, hash, compare, yojson, hlist]\n\n type t = (Unsigned.t, Sgn.t) Signed_poly.t [@@deriving sexp, hash, yojson]\n\n let compare : t -> t -> int =\n let cmp = [%compare: (Unsigned.t, Sgn.t) Signed_poly.t] in\n fun t1 t2 ->\n if Unsigned.(equal t1.magnitude zero && equal t2.magnitude zero) then\n 0\n else cmp t1 t2\n\n let equal : t -> t -> bool =\n let eq = [%equal: (Unsigned.t, Sgn.t) Signed_poly.t] in\n fun t1 t2 ->\n if Unsigned.(equal t1.magnitude zero && equal t2.magnitude zero) then\n true\n else eq t1 t2\n\n let is_zero (t : t) : bool = Unsigned.(equal t.magnitude zero)\n\n let is_positive (t : t) : bool =\n match t.sgn with\n | Pos ->\n not Unsigned.(equal zero t.magnitude)\n | Neg ->\n false\n\n let is_negative (t : t) : bool =\n match t.sgn with\n | Neg ->\n not Unsigned.(equal zero t.magnitude)\n | Pos ->\n false\n\n type magnitude = Unsigned.t [@@deriving sexp, compare]\n\n let create ~magnitude ~sgn =\n { magnitude\n ; sgn = (if Unsigned.(equal magnitude zero) then Sgn.Pos else sgn)\n }\n\n let sgn { sgn; _ } = sgn\n\n let magnitude { magnitude; _ } = magnitude\n\n let zero : t = { magnitude = zero; sgn = Sgn.Pos }\n\n let gen =\n Quickcheck.Generator.map2 gen Sgn.gen ~f:(fun magnitude sgn ->\n create ~magnitude ~sgn )\n\n let sgn_to_bool = function Sgn.Pos -> true | Neg -> false\n\n let to_bits ({ sgn; magnitude } : t) =\n sgn_to_bool sgn :: to_bits magnitude\n\n let to_input { sgn; magnitude } =\n Random_oracle.Input.Chunked.(\n append (to_input magnitude)\n (packed (Field.project [ sgn_to_bool sgn ], 1)))\n\n let to_input_legacy t = Random_oracle.Input.Legacy.bitstring (to_bits t)\n\n let add (x : t) (y : t) : t option =\n match (x.sgn, y.sgn) with\n | Neg, (Neg as sgn) | Pos, (Pos as sgn) ->\n let open Option.Let_syntax in\n let%map magnitude = add x.magnitude y.magnitude in\n create ~sgn ~magnitude\n | Pos, Neg | Neg, Pos ->\n let c = compare_magnitude x.magnitude y.magnitude in\n Some\n ( if Int.( < ) c 0 then\n create ~sgn:y.sgn\n ~magnitude:Unsigned.Infix.(y.magnitude - x.magnitude)\n else if Int.( > ) c 0 then\n create ~sgn:x.sgn\n ~magnitude:Unsigned.Infix.(x.magnitude - y.magnitude)\n else zero )\n\n let add_flagged (x : t) (y : t) : t * [ `Overflow of bool ] =\n match (x.sgn, y.sgn) with\n | Neg, (Neg as sgn) | Pos, (Pos as sgn) ->\n let magnitude, `Overflow b = add_flagged x.magnitude y.magnitude in\n (create ~sgn ~magnitude, `Overflow b)\n | Pos, Neg | Neg, Pos ->\n let c = compare_magnitude x.magnitude y.magnitude in\n ( ( if Int.( < ) c 0 then\n create ~sgn:y.sgn\n ~magnitude:Unsigned.Infix.(y.magnitude - x.magnitude)\n else if Int.( > ) c 0 then\n create ~sgn:x.sgn\n ~magnitude:Unsigned.Infix.(x.magnitude - y.magnitude)\n else zero )\n , `Overflow false )\n\n let negate t =\n if Unsigned.(equal zero t.magnitude) then zero\n else { t with sgn = Sgn.negate t.sgn }\n\n let of_unsigned magnitude : t = create ~magnitude ~sgn:Sgn.Pos\n\n let ( + ) = add\n\n let to_fee = Fn.id\n\n let of_fee = Fn.id\n\n [%%ifdef consensus_mechanism]\n\n type signed_fee = t\n\n let magnitude_to_field = to_field\n\n let to_field (t : t) : Field.t =\n Field.mul (Sgn.to_field t.sgn) (magnitude_to_field t.magnitude)\n\n type repr = var Signed_var.repr\n\n type nonrec var = var Signed_var.t\n\n let repr_typ : (repr, t) Typ.t =\n Typ.of_hlistable [ typ; Sgn.typ ] ~var_to_hlist:typ_to_hlist\n ~var_of_hlist:typ_of_hlist ~value_to_hlist:typ_to_hlist\n ~value_of_hlist:typ_of_hlist\n\n let typ : (var, t) Typ.t =\n Typ.transport_var repr_typ\n ~back:(fun repr -> { Signed_var.value = None; repr })\n ~there:(fun { Signed_var.repr; _ } -> repr)\n\n let create_var ~magnitude ~sgn : var =\n { repr = { magnitude; sgn }; value = None }\n\n module Checked = struct\n type t = var\n\n type signed_fee_var = t\n\n let repr (t : var) = Checked.return t.repr\n\n let value (t : var) =\n match t.value with\n | Some x ->\n Checked.return x\n | None ->\n let r = t.repr in\n let%map x =\n Field.Checked.mul (r.sgn :> Field.Var.t) r.magnitude\n in\n t.value <- Some x ;\n x\n\n let to_field_var = value\n\n let to_input t =\n let%map { magnitude; sgn } = repr t in\n let mag = var_to_input magnitude in\n Random_oracle.Input.Chunked.(\n append mag (packed ((Sgn.Checked.is_pos sgn :> Field.Var.t), 1)))\n\n let to_input_legacy t =\n let to_bits { magnitude; sgn } =\n let%map magnitude = var_to_bits_ magnitude in\n Sgn.Checked.is_pos sgn :: magnitude\n in\n repr t >>= to_bits >>| Random_oracle.Input.Legacy.bitstring\n\n let constant ({ magnitude; sgn } as t) =\n { Signed_var.repr =\n { magnitude = var_of_t magnitude; sgn = Sgn.Checked.constant sgn }\n ; value = Some (Field.Var.constant (to_field t))\n }\n\n let of_unsigned magnitude : var =\n { repr = { magnitude; sgn = Sgn.Checked.pos }\n ; value = Some magnitude\n }\n\n let negate (t : var) : var =\n { value = Option.map t.value ~f:Field.Var.negate\n ; repr =\n (let { magnitude; sgn } = t.repr in\n { magnitude; sgn = Sgn.Checked.negate sgn } )\n }\n\n let if_repr cond ~then_ ~else_ =\n let%map sgn = Sgn.Checked.if_ cond ~then_:then_.sgn ~else_:else_.sgn\n and magnitude =\n if_ cond ~then_:then_.magnitude ~else_:else_.magnitude\n in\n { sgn; magnitude }\n\n let if_ cond ~(then_ : var) ~(else_ : var) : var Checked.t =\n let%bind repr = if_repr cond ~then_:then_.repr ~else_:else_.repr in\n let%map value =\n match (then_.value, else_.value) with\n | Some v1, Some v2 ->\n Field.Checked.if_ cond ~then_:v1 ~else_:v2 >>| Option.return\n | _ ->\n return None\n in\n { Signed_var.value; repr }\n\n let sgn (t : var) =\n let%map r = repr t in\n r.sgn\n\n let magnitude (t : var) =\n let%map r = repr t in\n r.magnitude\n\n let add_flagged (x : var) (y : var) =\n let%bind xv = value x and yv = value y in\n let%bind sgn =\n exists Sgn.typ\n ~compute:\n (let open As_prover in\n let%map x = read typ x and y = read typ y in\n match add x y with\n | Some r ->\n r.sgn\n | None -> (\n match (x.sgn, y.sgn) with\n | Sgn.Neg, Sgn.Neg ->\n (* Ensure that we provide a value in the range\n [-modulus_as_field < magnitude < 2*modulus_as_field]\n for [range_check_flagged].\n *)\n Sgn.Neg\n | _ ->\n Sgn.Pos ))\n in\n let value = Field.Var.add xv yv in\n let%bind magnitude =\n Tick.Field.Checked.mul (sgn :> Field.Var.t) value\n in\n let%bind res_magnitude, `Overflow overflow =\n range_check_flagged `Add_or_sub magnitude\n in\n (* Recompute the result from [res_magnitude], since it may have been\n adjusted.\n *)\n let%map res_value =\n Field.Checked.mul (sgn :> Field.Var.t) magnitude\n in\n ( { Signed_var.repr = { magnitude = res_magnitude; sgn }\n ; value = Some res_value\n }\n , `Overflow overflow )\n\n let add (x : var) (y : var) =\n let%bind xv = value x and yv = value y in\n let%bind sgn =\n exists Sgn.typ\n ~compute:\n (let open As_prover in\n let%map x = read typ x and y = read typ y in\n Option.value_map (add x y) ~default:Sgn.Pos ~f:(fun r -> r.sgn))\n in\n let%bind res_value = seal (Field.Var.add xv yv) in\n let%bind magnitude =\n Tick.Field.Checked.mul (sgn :> Field.Var.t) res_value\n in\n let%map () = range_check magnitude in\n { Signed_var.repr = { magnitude; sgn }; value = Some res_value }\n\n let ( + ) = add\n\n let equal (t1 : var) (t2 : var) =\n let%bind t1 = value t1 and t2 = value t2 in\n Field.Checked.equal t1 t2\n\n let assert_equal (t1 : var) (t2 : var) =\n let%bind t1 = value t1 and t2 = value t2 in\n Field.Checked.Assert.equal t1 t2\n\n let to_fee = Fn.id\n\n let of_fee = Fn.id\n end\n\n [%%endif]\n end\n\n [%%ifdef consensus_mechanism]\n\n module Checked = struct\n module N = Mina_numbers.Nat.Make_checked (Unsigned) (B)\n\n type t = var\n\n let if_ = if_\n\n (* Unpacking protects against underflow *)\n let sub (x : var) (y : var) =\n let%bind res = seal (Field.Var.sub x y) in\n let%map () = range_check res in\n res\n\n let sub_flagged x y =\n let%bind z = seal (Field.Var.sub x y) in\n let%map z, `Overflow underflow = range_check_flagged `Sub z in\n (z, `Underflow underflow)\n\n let sub_or_zero x y =\n let%bind res, `Underflow underflow = sub_flagged x y in\n Field.Checked.if_ underflow ~then_:Field.(Var.constant zero) ~else_:res\n\n let assert_equal x y = Field.Checked.Assert.equal x y\n\n let equal x y = Field.Checked.equal x y\n\n let ( = ) = equal\n\n let ( < ) x y =\n let%bind diff = seal (Field.Var.sub x y) in\n (* [lt] is true iff [x - y < 0], ie. [x < y] *)\n let%map _res, `Overflow lt = range_check_flagged `Sub diff in\n lt\n\n (* x <= y iff not (y < x) *)\n let ( <= ) x y =\n let%map y_lt_x = y < x in\n Boolean.not y_lt_x\n\n (* x >= y iff y <= x *)\n let ( >= ) x y = y <= x\n\n let ( > ) x y = y < x\n\n (* Unpacking protects against overflow *)\n let add (x : var) (y : var) =\n let%bind res = seal (Field.Var.add x y) in\n let%map () = range_check res in\n res\n\n let add_flagged x y =\n let%bind z = seal (Field.Var.add x y) in\n let%map z, `Overflow overflow = range_check_flagged `Add z in\n (z, `Overflow overflow)\n\n let ( - ) = sub\n\n let ( + ) = add\n\n let add_signed (t : var) (d : Signed.var) =\n let%bind d = Signed.Checked.to_field_var d in\n let%bind res = seal (Field.Var.add t d) in\n let%map () = range_check res in\n res\n\n let add_signed_flagged (t : var) (d : Signed.var) =\n let%bind d = Signed.Checked.to_field_var d in\n let%bind res = seal (Field.Var.add t d) in\n let%map res, `Overflow overflow = range_check_flagged `Add_or_sub res in\n (res, `Overflow overflow)\n\n let scale (f : Field.Var.t) (t : var) =\n let%bind res = Field.Checked.mul t f in\n let%map () = range_check res in\n res\n\n let%test_module \"currency_test\" =\n ( module struct\n let expect_failure err c =\n if Or_error.is_ok (check c) then failwith err\n\n let expect_success err c =\n match check c with\n | Ok () ->\n ()\n | Error e ->\n Error.(raise (tag ~tag:err e))\n\n let to_bigint x = Bignum_bigint.of_string (Unsigned.to_string x)\n\n let of_bigint x = Unsigned.of_string (Bignum_bigint.to_string x)\n\n let gen_incl x y =\n Quickcheck.Generator.map ~f:of_bigint\n (Bignum_bigint.gen_incl (to_bigint x) (to_bigint y))\n\n let shrinker =\n Quickcheck.Shrinker.create (fun i ->\n Sequence.unfold ~init:i ~f:(fun i ->\n if Unsigned.equal i Unsigned.zero then None\n else\n let n = Unsigned.div i (Unsigned.of_int 10) in\n Some (n, n) ) )\n\n (* TODO: When we do something to make snarks run fast for tests, increase the trials *)\n let qc_test_fast = Quickcheck.test ~trials:100\n\n let%test_unit \"subtraction_completeness\" =\n let generator =\n let open Quickcheck.Generator.Let_syntax in\n let%bind x = gen_incl Unsigned.zero Unsigned.max_int in\n let%map y = gen_incl Unsigned.zero x in\n (x, y)\n in\n qc_test_fast generator ~f:(fun (lo, hi) ->\n expect_success\n (sprintf !\"subtraction: lo=%{Unsigned} hi=%{Unsigned}\" lo hi)\n (var_of_t lo - var_of_t hi) )\n\n let%test_unit \"subtraction_soundness\" =\n let generator =\n let open Quickcheck.Generator.Let_syntax in\n let%bind x = gen_incl Unsigned.zero Unsigned.(sub max_int one) in\n let%map y = gen_incl Unsigned.(add x one) Unsigned.max_int in\n (x, y)\n in\n qc_test_fast generator ~f:(fun (lo, hi) ->\n expect_failure\n (sprintf !\"underflow: lo=%{Unsigned} hi=%{Unsigned}\" lo hi)\n (var_of_t lo - var_of_t hi) )\n\n let%test_unit \"addition_completeness\" =\n let generator =\n let open Quickcheck.Generator.Let_syntax in\n let%bind x = gen_incl Unsigned.zero Unsigned.max_int in\n let%map y = gen_incl Unsigned.zero Unsigned.(sub max_int x) in\n (x, y)\n in\n qc_test_fast generator ~f:(fun (x, y) ->\n expect_success\n (sprintf !\"overflow: x=%{Unsigned} y=%{Unsigned}\" x y)\n (var_of_t x + var_of_t y) )\n\n let%test_unit \"addition_soundness\" =\n let generator =\n let open Quickcheck.Generator.Let_syntax in\n let%bind x = gen_incl Unsigned.one Unsigned.max_int in\n let%map y =\n gen_incl Unsigned.(add (sub max_int x) one) Unsigned.max_int\n in\n (x, y)\n in\n qc_test_fast generator ~f:(fun (x, y) ->\n expect_failure\n (sprintf !\"overflow: x=%{Unsigned} y=%{Unsigned}\" x y)\n (var_of_t x + var_of_t y) )\n\n let%test_unit \"formatting_roundtrip\" =\n let generator = gen_incl Unsigned.zero Unsigned.max_int in\n qc_test_fast generator ~shrinker ~f:(fun num ->\n match of_mina_string_exn (to_mina_string num) with\n | after_format ->\n if Unsigned.equal after_format num then ()\n else\n Error.(\n raise\n (of_string\n (sprintf\n !\"formatting: num=%{Unsigned} middle=%{String} \\\n after=%{Unsigned}\"\n num (to_mina_string num) after_format ) ))\n | exception e ->\n let err = Error.of_exn e in\n Error.(\n raise\n (tag\n ~tag:(sprintf !\"formatting: num=%{Unsigned}\" num)\n err )) )\n\n let%test_unit \"formatting_trailing_zeros\" =\n let generator = gen_incl Unsigned.zero Unsigned.max_int in\n qc_test_fast generator ~shrinker ~f:(fun num ->\n let formatted = to_mina_string num in\n let has_decimal = String.contains formatted '.' in\n let trailing_zero = String.is_suffix formatted ~suffix:\"0\" in\n if has_decimal && trailing_zero then\n Error.(\n raise\n (of_string\n (sprintf\n !\"formatting: num=%{Unsigned} formatted=%{String}\"\n num (to_mina_string num) ) )) )\n end )\n end\n\n [%%endif]\n end\n\n let currency_length = 64\n\n module Fee = struct\n module T =\n Make\n (Unsigned_extended.UInt64)\n (struct\n let length = currency_length\n end)\n\n include T\n\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n [@@@with_all_version_tags]\n\n type t = Unsigned_extended.UInt64.Stable.V1.t\n [@@deriving sexp, compare, hash, equal]\n\n [%%define_from_scope to_yojson, of_yojson, dhall_type]\n\n let to_latest = Fn.id\n end\n end]\n\n let (_ : (Signed.t, (t, Sgn.t) Signed_poly.t) Type_equal.t) = Type_equal.T\n\n let minimum_user_command_fee =\n of_mina_string_exn Mina_compile_config.minimum_user_command_fee_string\n\n let default_transaction_fee =\n of_mina_string_exn Mina_compile_config.default_transaction_fee_string\n\n let default_snark_worker_fee =\n of_mina_string_exn Mina_compile_config.default_snark_worker_fee_string\n end\n\n module Amount = struct\n (* See documentation for {!module:Mina_wire_types} *)\n module Make_sig (A : sig\n type t\n end) =\n struct\n module type S = sig\n [%%versioned:\n module Stable : sig\n module V1 : sig\n [@@@with_all_version_tags]\n\n type t = A.t [@@deriving sexp, compare, hash, equal, yojson]\n\n (* not automatically derived *)\n val dhall_type : Ppx_dhall_type.Dhall_type.t\n end\n end]\n\n [%%ifdef consensus_mechanism]\n\n (* Give a definition to var, it will be hidden at the interface level *)\n include\n Basic\n with type t := Stable.Latest.t\n and type var =\n Pickles.Impls.Step.Impl.Internal_Basic.field\n Snarky_backendless.Cvar.t\n\n [%%else]\n\n include Basic with type t := Stable.Latest.t\n\n [%%endif]\n\n include Arithmetic_intf with type t := t\n\n include Codable.S with type t := t\n\n [%%ifdef consensus_mechanism]\n\n module Signed :\n Signed_intf\n with type magnitude := t\n and type magnitude_var := var\n and type signed_fee := Fee.Signed.t\n and type Checked.signed_fee_var := Fee.Signed.Checked.t\n\n [%%else]\n\n module Signed :\n Signed_intf\n with type magnitude := t\n and type signed_fee := Fee.Signed.t\n\n [%%endif]\n\n (* TODO: Delete these functions *)\n\n val of_fee : Fee.t -> t\n\n val to_fee : t -> Fee.t\n\n val add_fee : t -> Fee.t -> t option\n\n [%%ifdef consensus_mechanism]\n\n module Checked : sig\n include\n Checked_arithmetic_intf\n with type var := var\n and type signed_var := Signed.var\n and type value := t\n\n val add_signed : var -> Signed.var -> var Checked.t\n\n val of_fee : Fee.var -> var\n\n val to_fee : var -> Fee.var\n\n val to_field : var -> Field.Var.t\n\n module Unsafe : sig\n val of_field : Field.Var.t -> t\n end\n end\n\n [%%endif]\n\n val add_signed_flagged : t -> Signed.t -> t * [ `Overflow of bool ]\n end\n end\n [@@warning \"-32\"]\n\n module Make_str (A : sig\n type t = Unsigned_extended.UInt64.Stable.V1.t\n end) : Make_sig(A).S = struct\n module T =\n Make\n (Unsigned_extended.UInt64)\n (struct\n let length = currency_length\n end)\n\n [%%ifdef consensus_mechanism]\n\n include (\n T :\n module type of T\n with type var = T.var\n and module Signed = T.Signed\n and module Checked := T.Checked )\n\n [%%else]\n\n include (T : module type of T with module Signed = T.Signed)\n\n [%%endif]\n\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n [@@@with_all_version_tags]\n\n type t = Unsigned_extended.UInt64.Stable.V1.t\n [@@deriving sexp, compare, hash, equal, yojson]\n\n [%%define_from_scope to_yojson, of_yojson, dhall_type]\n\n let to_latest = Fn.id\n end\n end]\n\n let of_fee (fee : Fee.t) : t = fee\n\n let to_fee (fee : t) : Fee.t = fee\n\n let add_fee (t : t) (fee : Fee.t) = add t (of_fee fee)\n\n [%%ifdef consensus_mechanism]\n\n module Checked = struct\n include T.Checked\n\n let of_fee (fee : Fee.var) : var = fee\n\n let to_fee (t : var) : Fee.var = t\n\n let to_field = Fn.id\n\n module Unsafe = struct\n let of_field : Field.Var.t -> var = Fn.id\n end\n end\n\n [%%endif]\n end\n\n include Make_str (struct\n type t = Unsigned_extended.UInt64.Stable.V1.t\n end)\n (*include Wire_types.Make.Amount (Make_sig) (Make_str)*)\n end\n\n module Balance = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Amount.Stable.V1.t\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n\n (* can't be automatically derived *)\n let dhall_type = Ppx_dhall_type.Dhall_type.Text\n end\n end]\n\n [%%ifdef consensus_mechanism]\n\n include (Amount : Basic with type t := t with type var = Amount.var)\n\n [%%else]\n\n include (Amount : Basic with type t := t)\n\n [%%endif]\n\n let to_amount = Fn.id\n\n let add_amount = Amount.add\n\n let add_amount_flagged = Amount.add_flagged\n\n let sub_amount = Amount.sub\n\n let sub_amount_flagged = Amount.sub_flagged\n\n let add_signed_amount_flagged = Amount.add_signed_flagged\n\n let ( + ) = add_amount\n\n let ( - ) = sub_amount\n\n [%%ifdef consensus_mechanism]\n\n module Checked = struct\n include Amount.Checked\n\n let to_field = Fn.id\n\n module Unsafe = struct\n let of_field (x : Field.Var.t) : var = x\n end\n\n let to_amount = Fn.id\n\n let add_signed_amount = add_signed\n\n let add_amount = add\n\n let sub_amount = sub\n\n let sub_amount_or_zero = sub_or_zero\n\n let add_amount_flagged = add_flagged\n\n let add_signed_amount_flagged = add_signed_flagged\n\n let sub_amount_flagged = sub_flagged\n\n let ( + ) = add_amount\n\n let ( - ) = sub_amount\n end\n\n [%%endif]\n end\n\n module Fee_rate = struct\n type t = Q.t\n\n let uint64_to_z u64 = Z.of_string @@ Unsigned.UInt64.to_string u64\n\n let uint64_of_z z = Unsigned.UInt64.of_string @@ Z.to_string z\n\n let max_uint64_z = uint64_to_z Unsigned.UInt64.max_int\n\n let fits_uint64 z =\n let open Z in\n leq zero z && leq z max_uint64_z\n\n (** check if a Q.t is in range *)\n let check_q Q.{ num; den } : bool =\n let open Z in\n fits_uint64 num && fits_int32 den\n && if equal zero den then equal zero num else true\n\n let of_q q = if check_q q then Some q else None\n\n let of_q_exn q = Option.value_exn (of_q q)\n\n let to_q = ident\n\n let make fee weight = of_q @@ Q.make (uint64_to_z fee) (Z.of_int weight)\n\n let make_exn fee weight = Option.value_exn (make fee weight)\n\n let to_uint64 Q.{ num; den } =\n if Z.(equal den Z.one) then Some (uint64_of_z num) else None\n\n let to_uint64_exn fr = Option.value_exn (to_uint64 fr)\n\n let add x y = of_q @@ Q.add x y\n\n let add_flagged x y =\n let z = Q.add x y in\n (z, `Overflow (check_q z))\n\n let sub x y = of_q @@ Q.sub x y\n\n let sub_flagged x y =\n let z = Q.sub x y in\n (z, `Underflow (check_q z))\n\n let mul x y = of_q @@ Q.mul x y\n\n let div x y = of_q @@ Q.div x y\n\n let ( + ) = add\n\n let ( - ) = sub\n\n let ( * ) = mul\n\n let scale fr s = fr * Q.of_int s\n\n let scale_exn fr s = Option.value_exn (scale fr s)\n\n let compare = Q.compare\n\n let t_of_sexp sexp =\n let open Ppx_sexp_conv_lib.Conv in\n pair_of_sexp Fee.t_of_sexp int_of_sexp sexp\n |> fun (fee, weight) -> make_exn fee weight\n\n let sexp_of_t Q.{ num = fee; den = weight } =\n let sexp_of_fee fee = Fee.sexp_of_t @@ uint64_of_z fee in\n let sexp_of_weight weight = sexp_of_int @@ Z.to_int weight in\n sexp_of_pair sexp_of_fee sexp_of_weight (fee, weight)\n\n include Comparable.Make (struct\n type nonrec t = t\n\n let compare = compare\n\n let t_of_sexp = t_of_sexp\n\n let sexp_of_t = sexp_of_t\n end)\n end\n\n let%test_module \"sub_flagged module\" =\n ( module struct\n [%%ifdef consensus_mechanism]\n\n open Tick\n\n module type Sub_flagged_S = sig\n type t\n\n type magnitude = t [@@deriving sexp, compare]\n\n type var\n\n (* TODO =\n field Snarky_backendless.Cvar.t Snarky_backendless.Boolean.t list *)\n\n val zero : t\n\n val ( - ) : t -> t -> t option\n\n val typ : (var, t) Typ.t\n\n val gen : t Quickcheck.Generator.t\n\n module Checked : sig\n val sub_flagged :\n var -> var -> (var * [ `Underflow of Boolean.var ]) Tick.Checked.t\n end\n end\n\n let run_test (module M : Sub_flagged_S) =\n let open M in\n let sub_flagged_unchecked (x, y) =\n if compare_magnitude x y < 0 then (zero, true)\n else (Option.value_exn (x - y), false)\n in\n let sub_flagged_checked =\n let f (x, y) =\n Tick.Checked.map (M.Checked.sub_flagged x y)\n ~f:(fun (r, `Underflow u) -> (r, u))\n in\n Test_util.checked_to_unchecked (Typ.tuple2 typ typ)\n (Typ.tuple2 typ Boolean.typ)\n f\n in\n Quickcheck.test ~trials:100 (Quickcheck.Generator.tuple2 gen gen)\n ~f:(fun p ->\n let m, u = sub_flagged_unchecked p in\n let m_checked, u_checked = sub_flagged_checked p in\n assert (Bool.equal u u_checked) ;\n if not u then [%test_eq: M.magnitude] m m_checked )\n\n let%test_unit \"fee sub_flagged\" = run_test (module Fee)\n\n let%test_unit \"amount sub_flagged\" = run_test (module Amount)\n\n [%%endif]\n end )\nend\n\n(** Finally, we use [Make] to create the full module where the types defined\n here and in {!Mina_wire_types} are fully unified. *)\ninclude Wire_types.Make (Make_sig) (Make_str)\n","(*\n RE - A regular expression library\n\n Copyright (C) 2001 Jerome Vouillon\n email: Jerome.Vouillon@pps.jussieu.fr\n\n This library is free software; you can redistribute it and/or\n modify it under the terms of the GNU Lesser General Public\n License as published by the Free Software Foundation, with\n linking exception; either version 2.1 of the License, or (at\n your option) any later version.\n\n This library is distributed in the hope that it will be useful,\n but WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n Lesser General Public License for more details.\n\n You should have received a copy of the GNU Lesser General Public\n License along with this library; if not, write to the Free Software\n Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n*)\n\ntype c = int\ntype t = (c * c) list\n\nlet rec union l l' =\n match l, l' with\n _, [] -> l\n | [], _ -> l'\n | (c1, c2)::r, (c1', c2')::r' ->\n if c2 + 1 < c1' then\n (c1, c2)::union r l'\n else if c2' + 1 < c1 then\n (c1', c2')::union l r'\n else if c2 < c2' then\n union r ((min c1 c1', c2')::r')\n else\n union ((min c1 c1', c2)::r) r'\n\nlet rec inter l l' =\n match l, l' with\n _, [] -> []\n | [], _ -> []\n | (c1, c2)::r, (c1', c2')::r' ->\n if c2 < c1' then\n inter r l'\n else if c2' < c1 then\n inter l r'\n else if c2 < c2' then\n (max c1 c1', c2)::inter r l'\n else\n (max c1 c1', c2')::inter l r'\n\nlet rec diff l l' =\n match l, l' with\n _, [] -> l\n | [], _ -> []\n | (c1, c2)::r, (c1', c2')::r' ->\n if c2 < c1' then\n (c1, c2)::diff r l'\n else if c2' < c1 then\n diff l r'\n else\n let r'' = if c2' < c2 then (c2' + 1, c2) :: r else r in\n if c1 < c1' then\n (c1, c1' - 1)::diff r'' r'\n else\n diff r'' r'\n\nlet single c = [c, c]\n\nlet add c l = union (single c) l\n\nlet seq c c' = if c <= c' then [c, c'] else [c', c]\n\nlet rec offset o l =\n match l with\n [] -> []\n | (c1, c2) :: r -> (c1 + o, c2 + o) :: offset o r\n\nlet empty = []\n\nlet rec mem (c : int) s =\n match s with\n [] -> false\n | (c1, c2) :: rem -> if c <= c2 then c >= c1 else mem c rem\n\n(****)\n\ntype hash = int\n\nlet rec hash_rec = function\n | [] -> 0\n | (i, j)::r -> i + 13 * j + 257 * hash_rec r\nlet hash l = (hash_rec l) land 0x3FFFFFFF\n\n(****)\n\nlet print_one ch (c1, c2) =\n if c1 = c2 then\n Format.fprintf ch \"%d\" c1\n else\n Format.fprintf ch \"%d-%d\" c1 c2\n\nlet pp = Fmt.list print_one\n\nlet rec iter t ~f =\n match t with\n | [] -> ()\n | (x, y)::xs ->\n f x y;\n iter xs ~f\n\nlet one_char = function\n | [i, j] when i = j -> Some i\n | _ -> None\n\n\nmodule CSetMap = Map.Make (struct\n type t = int * (int * int) list\n let compare (i, u) (j, v) =\n let c = compare i j in\n if c <> 0\n then c\n else compare u v\n end)\n\nlet fold_right t ~init ~f = List.fold_right f t init\n\nlet csingle c = single (Char.code c)\n\nlet cany = [0, 255]\n\nlet is_empty = function\n | [] -> true\n | _ -> false\n\nlet rec prepend s x l =\n match s, l with\n | [], _ -> l\n | _r, [] -> []\n | (_c, c') :: r, ([d, _d'], _x') :: _r' when c' < d -> prepend r x l\n | (c, c') :: r, ([d, d'], x') :: r' ->\n if c <= d then begin\n if c' < d'\n then ([d, c'], x @ x') :: prepend r x (([c' + 1, d'], x') :: r')\n else ([d, d'], x @ x') :: prepend s x r'\n end else begin\n if c > d'\n then ([d, d'], x') :: prepend s x r'\n else ([d, c - 1], x') :: prepend s x (([c, d'], x') :: r')\n end\n | _ -> assert false\n\nlet pick = function\n | [] -> invalid_arg \"Re_cset.pick\"\n | (x, _)::_ -> x\n","\nmodule MenhirBasics = struct\n \n exception Error\n \n type token = \n | SUBSCRIPTION\n | STRING of (\n# 8 \"graphql_parser/src/parser.mly\"\n (string)\n# 12 \"graphql_parser/src/parser.ml\"\n )\n | RPAREN\n | RBRACK\n | RBRACE\n | QUERY\n | ON\n | NULL\n | NAME of (\n# 5 \"graphql_parser/src/parser.mly\"\n (string)\n# 23 \"graphql_parser/src/parser.ml\"\n )\n | MUTATION\n | LPAREN\n | LBRACK\n | LBRACE\n | INT of (\n# 6 \"graphql_parser/src/parser.mly\"\n (int)\n# 32 \"graphql_parser/src/parser.ml\"\n )\n | FRAGMENT\n | FLOAT of (\n# 7 \"graphql_parser/src/parser.mly\"\n (float)\n# 38 \"graphql_parser/src/parser.ml\"\n )\n | EQUAL\n | EOF\n | ELLIPSIS\n | DOLLAR\n | COLON\n | BOOL of (\n# 9 \"graphql_parser/src/parser.mly\"\n (bool)\n# 48 \"graphql_parser/src/parser.ml\"\n )\n | BANG\n | AT\n \nend\n\ninclude MenhirBasics\n\nlet _eRR =\n MenhirBasics.Error\n\ntype _menhir_env = {\n _menhir_lexer: Lexing.lexbuf -> token;\n _menhir_lexbuf: Lexing.lexbuf;\n _menhir_token: token;\n mutable _menhir_error: bool\n}\n\nand _menhir_state = \n | MenhirState133\n | MenhirState125\n | MenhirState124\n | MenhirState119\n | MenhirState114\n | MenhirState108\n | MenhirState102\n | MenhirState100\n | MenhirState99\n | MenhirState96\n | MenhirState90\n | MenhirState89\n | MenhirState87\n | MenhirState86\n | MenhirState84\n | MenhirState81\n | MenhirState80\n | MenhirState79\n | MenhirState78\n | MenhirState71\n | MenhirState70\n | MenhirState67\n | MenhirState66\n | MenhirState65\n | MenhirState64\n | MenhirState63\n | MenhirState61\n | MenhirState59\n | MenhirState57\n | MenhirState55\n | MenhirState51\n | MenhirState44\n | MenhirState38\n | MenhirState34\n | MenhirState31\n | MenhirState29\n | MenhirState28\n | MenhirState24\n | MenhirState22\n | MenhirState21\n | MenhirState20\n | MenhirState19\n | MenhirState13\n | MenhirState12\n | MenhirState4\n | MenhirState0\n\n# 1 \"graphql_parser/src/parser.mly\"\n \nopen Ast\n\n# 119 \"graphql_parser/src/parser.ml\"\n\nlet rec _menhir_goto_nonempty_list_definition_ : _menhir_env -> 'ttv_tail -> _menhir_state -> (Ast.document) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_stack = (_menhir_stack, _menhir_s, _v) in\n match _menhir_s with\n | MenhirState0 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | EOF ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, (_1 : (Ast.document))) = _menhir_stack in\n let _v : (Ast.document) = \n# 37 \"graphql_parser/src/parser.mly\"\n ( _1 )\n# 137 \"graphql_parser/src/parser.ml\"\n in\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_1 : (Ast.document)) = _v in\n Obj.magic _1\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s)\n | MenhirState133 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let ((_menhir_stack, _menhir_s, (x : (Ast.definition))), _, (xs : (Ast.document))) = _menhir_stack in\n let _v : (Ast.document) = \n# 223 \"\"\n ( x :: xs )\n# 156 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_nonempty_list_definition_ _menhir_env _menhir_stack _menhir_s _v\n | _ ->\n _menhir_fail ()\n\nand _menhir_goto_field : _menhir_env -> 'ttv_tail -> _menhir_state -> (Ast.selection) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_1 : (Ast.selection)) = _v in\n let _v : (Ast.selection) = \n# 87 \"graphql_parser/src/parser.mly\"\n ( _1 )\n# 170 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_selection _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_goto_operation : _menhir_env -> 'ttv_tail -> _menhir_state -> (Ast.definition) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_1 : (Ast.definition)) = _v in\n let _v : (Ast.definition) = \n# 41 \"graphql_parser/src/parser.mly\"\n ( _1 )\n# 182 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_definition _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_goto_definition : _menhir_env -> 'ttv_tail -> _menhir_state -> (Ast.definition) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_stack = (_menhir_stack, _menhir_s, _v) in\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n match _tok with\n | FRAGMENT ->\n _menhir_run78 _menhir_env (Obj.magic _menhir_stack) MenhirState133\n | LBRACE ->\n _menhir_run4 _menhir_env (Obj.magic _menhir_stack) MenhirState133\n | MUTATION ->\n _menhir_run3 _menhir_env (Obj.magic _menhir_stack) MenhirState133\n | QUERY ->\n _menhir_run2 _menhir_env (Obj.magic _menhir_stack) MenhirState133\n | SUBSCRIPTION ->\n _menhir_run1 _menhir_env (Obj.magic _menhir_stack) MenhirState133\n | EOF ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, (x : (Ast.definition))) = _menhir_stack in\n let _v : (Ast.document) = \n# 221 \"\"\n ( [ x ] )\n# 209 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_nonempty_list_definition_ _menhir_env _menhir_stack _menhir_s _v\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState133\n\nand _menhir_goto_loption_selection_set_ : _menhir_env -> 'ttv_tail -> _menhir_state -> (Ast.selection list) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n match _menhir_s with\n | MenhirState67 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_6 : (Ast.selection list)) = _v in\n let (((((_menhir_stack, _menhir_s, (_1 : (string))), _), _, (_3 : (string))), _, (_4 : ((string * Ast.value) list))), _, (_5 : (Ast.directive list))) = _menhir_stack in\n let _v : (Ast.selection) = \n# 91 \"graphql_parser/src/parser.mly\"\n (\n Field {\n alias = Some _1;\n name = _3;\n arguments = _4;\n directives = _5;\n selection_set = _6;\n }\n )\n# 236 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_field _menhir_env _menhir_stack _menhir_s _v\n | MenhirState71 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_4 : (Ast.selection list)) = _v in\n let (((_menhir_stack, _menhir_s, (_1 : (string))), _, (_2 : ((string * Ast.value) list))), _, (_3 : (Ast.directive list))) = _menhir_stack in\n let _v : (Ast.selection) = \n# 101 \"graphql_parser/src/parser.mly\"\n (\n Field {\n alias = None;\n name = _1;\n arguments = _2;\n directives = _3;\n selection_set = _4;\n }\n )\n# 255 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_field _menhir_env _menhir_stack _menhir_s _v\n | _ ->\n _menhir_fail ()\n\nand _menhir_goto_nonempty_list_selection_ : _menhir_env -> 'ttv_tail -> _menhir_state -> (Ast.selection list) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_stack = (_menhir_stack, _menhir_s, _v) in\n match _menhir_s with\n | MenhirState61 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let ((_menhir_stack, _menhir_s, (x : (Ast.selection))), _, (xs : (Ast.selection list))) = _menhir_stack in\n let _v : (Ast.selection list) = \n# 223 \"\"\n ( x :: xs )\n# 272 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_nonempty_list_selection_ _menhir_env _menhir_stack _menhir_s _v\n | MenhirState4 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | RBRACE ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let ((_menhir_stack, _menhir_s), _, (_2 : (Ast.selection list))) = _menhir_stack in\n let _v : (Ast.selection list) = \n# 82 \"graphql_parser/src/parser.mly\"\n ( _2 )\n# 288 \"graphql_parser/src/parser.ml\"\n in\n (match _menhir_s with\n | MenhirState55 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_4 : (Ast.selection list)) = _v in\n let (((_menhir_stack, _menhir_s), _, (_2 : (string option))), _, (_3 : (Ast.directive list))) = _menhir_stack in\n let _v : (Ast.selection) = \n# 125 \"graphql_parser/src/parser.mly\"\n (\n InlineFragment {\n type_condition = _2;\n directives = _3;\n selection_set = _4;\n }\n )\n# 305 \"graphql_parser/src/parser.ml\"\n in\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_1 : (Ast.selection)) = _v in\n let _v : (Ast.selection) = \n# 87 \"graphql_parser/src/parser.mly\"\n ( _1 )\n# 313 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_selection _menhir_env _menhir_stack _menhir_s _v\n | MenhirState71 | MenhirState67 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (x : (Ast.selection list)) = _v in\n let _v : (Ast.selection list) = \n# 144 \"\"\n ( x )\n# 323 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_loption_selection_set_ _menhir_env _menhir_stack _menhir_s _v\n | MenhirState81 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_5 : (Ast.selection list)) = _v in\n let ((((_menhir_stack, _menhir_s), _, (_2 : (string))), _, (_3 : (string))), _, (_4 : (Ast.directive list))) = _menhir_stack in\n let _v : (Ast.definition) = \n# 45 \"graphql_parser/src/parser.mly\"\n (\n Fragment {\n name = _2;\n type_condition = _3;\n directives = _4;\n selection_set = _5;\n }\n )\n# 341 \"graphql_parser/src/parser.ml\"\n in\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_1 : (Ast.definition)) = _v in\n let _v : (Ast.definition) = \n# 41 \"graphql_parser/src/parser.mly\"\n ( _1 )\n# 349 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_definition _menhir_env _menhir_stack _menhir_s _v\n | MenhirState133 | MenhirState0 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_1 : (Ast.selection list)) = _v in\n let _v : (Ast.definition) = \n# 56 \"graphql_parser/src/parser.mly\"\n (\n Operation {\n optype = Query;\n name = None;\n variable_definitions = [];\n directives = [];\n selection_set = _1;\n }\n )\n# 367 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_operation _menhir_env _menhir_stack _menhir_s _v\n | MenhirState125 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_5 : (Ast.selection list)) = _v in\n let ((((_menhir_stack, _menhir_s, (_1 : (Ast.optype))), _, (_2 : (string option))), (_3 : (Ast.variable_definition list))), _, (_4 : (Ast.directive list))) = _menhir_stack in\n let _v : (Ast.definition) = \n# 66 \"graphql_parser/src/parser.mly\"\n (\n Operation {\n optype = _1;\n name = _2;\n variable_definitions = _3;\n directives = _4;\n selection_set = _5;\n }\n )\n# 386 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_operation _menhir_env _menhir_stack _menhir_s _v\n | _ ->\n _menhir_fail ())\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s)\n | _ ->\n _menhir_fail ()\n\nand _menhir_goto_list_const_value_ : _menhir_env -> 'ttv_tail -> _menhir_state -> (Ast.const_value list) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_stack = (_menhir_stack, _menhir_s, _v) in\n match _menhir_s with\n | MenhirState99 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | RBRACK ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let ((_menhir_stack, _menhir_s), _, (_2 : (Ast.const_value list))) = _menhir_stack in\n let _v : (Ast.const_value) = \n# 175 \"graphql_parser/src/parser.mly\"\n ( `List _2 )\n# 417 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_value_parser_const_value_ _menhir_env _menhir_stack _menhir_s _v\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s)\n | MenhirState114 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let ((_menhir_stack, _menhir_s, (x : (Ast.const_value))), _, (xs : (Ast.const_value list))) = _menhir_stack in\n let _v : (Ast.const_value list) = \n# 213 \"\"\n ( x :: xs )\n# 433 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_list_const_value_ _menhir_env _menhir_stack _menhir_s _v\n | _ ->\n _menhir_fail ()\n\nand _menhir_goto_list___anonymous_0_const_value__ : _menhir_env -> 'ttv_tail -> _menhir_state -> ((string * Ast.const_value) list) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_stack = (_menhir_stack, _menhir_s, _v) in\n match _menhir_s with\n | MenhirState108 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (((_menhir_stack, _menhir_s, (_1 : (string))), _, (_3 : (Ast.const_value))), _, (xs : ((string * Ast.const_value) list))) = _menhir_stack in\n let _v : ((string * Ast.const_value) list) = let x = \n# 176 \"graphql_parser/src/parser.mly\"\n ( _1, _3 )\n# 450 \"graphql_parser/src/parser.ml\"\n in\n \n# 213 \"\"\n ( x :: xs )\n# 455 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_list___anonymous_0_const_value__ _menhir_env _menhir_stack _menhir_s _v\n | MenhirState100 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | RBRACE ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let ((_menhir_stack, _menhir_s), _, (_2 : ((string * Ast.const_value) list))) = _menhir_stack in\n let _v : (Ast.const_value) = \n# 176 \"graphql_parser/src/parser.mly\"\n ( `Assoc _2 )\n# 471 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_value_parser_const_value_ _menhir_env _menhir_stack _menhir_s _v\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s)\n | _ ->\n _menhir_fail ()\n\nand _menhir_goto_list_value_ : _menhir_env -> 'ttv_tail -> _menhir_state -> (Ast.value list) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_stack = (_menhir_stack, _menhir_s, _v) in\n match _menhir_s with\n | MenhirState44 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let ((_menhir_stack, _menhir_s, (x : (Ast.value))), _, (xs : (Ast.value list))) = _menhir_stack in\n let _v : (Ast.value list) = \n# 213 \"\"\n ( x :: xs )\n# 494 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_list_value_ _menhir_env _menhir_stack _menhir_s _v\n | MenhirState28 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | RBRACK ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let ((_menhir_stack, _menhir_s), _, (_2 : (Ast.value list))) = _menhir_stack in\n let _v : (Ast.value) = \n# 175 \"graphql_parser/src/parser.mly\"\n ( `List _2 )\n# 510 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_value_parser_value_ _menhir_env _menhir_stack _menhir_s _v\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s)\n | _ ->\n _menhir_fail ()\n\nand _menhir_goto_list___anonymous_0_value__ : _menhir_env -> 'ttv_tail -> _menhir_state -> ((string * Ast.value) list) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_stack = (_menhir_stack, _menhir_s, _v) in\n match _menhir_s with\n | MenhirState38 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (((_menhir_stack, _menhir_s, (_1 : (string))), _, (_3 : (Ast.value))), _, (xs : ((string * Ast.value) list))) = _menhir_stack in\n let _v : ((string * Ast.value) list) = let x = \n# 176 \"graphql_parser/src/parser.mly\"\n ( _1, _3 )\n# 533 \"graphql_parser/src/parser.ml\"\n in\n \n# 213 \"\"\n ( x :: xs )\n# 538 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_list___anonymous_0_value__ _menhir_env _menhir_stack _menhir_s _v\n | MenhirState29 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | RBRACE ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let ((_menhir_stack, _menhir_s), _, (_2 : ((string * Ast.value) list))) = _menhir_stack in\n let _v : (Ast.value) = \n# 176 \"graphql_parser/src/parser.mly\"\n ( `Assoc _2 )\n# 554 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_value_parser_value_ _menhir_env _menhir_stack _menhir_s _v\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s)\n | _ ->\n _menhir_fail ()\n\nand _menhir_goto_list_argument_ : _menhir_env -> 'ttv_tail -> _menhir_state -> ((string * Ast.value) list) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_stack = (_menhir_stack, _menhir_s, _v) in\n match _menhir_s with\n | MenhirState22 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | RPAREN ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let ((_menhir_stack, _menhir_s), _, (_2 : ((string * Ast.value) list))) = _menhir_stack in\n let _v : ((string * Ast.value) list) = \n# 163 \"graphql_parser/src/parser.mly\"\n ( _2 )\n# 583 \"graphql_parser/src/parser.ml\"\n in\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (x : ((string * Ast.value) list)) = _v in\n let _v : ((string * Ast.value) list) = \n# 144 \"\"\n ( x )\n# 591 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_loption_arguments_ _menhir_env _menhir_stack _menhir_s _v\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s)\n | MenhirState51 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let ((_menhir_stack, _menhir_s, (x : (string * Ast.value))), _, (xs : ((string * Ast.value) list))) = _menhir_stack in\n let _v : ((string * Ast.value) list) = \n# 213 \"\"\n ( x :: xs )\n# 607 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_list_argument_ _menhir_env _menhir_stack _menhir_s _v\n | _ ->\n _menhir_fail ()\n\nand _menhir_reduce40 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _v : (Ast.selection list) = \n# 142 \"\"\n ( [] )\n# 618 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_loption_selection_set_ _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_goto_selection : _menhir_env -> 'ttv_tail -> _menhir_state -> (Ast.selection) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_stack = (_menhir_stack, _menhir_s, _v) in\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n match _tok with\n | BOOL _v ->\n _menhir_run14 _menhir_env (Obj.magic _menhir_stack) MenhirState61 _v\n | ELLIPSIS ->\n _menhir_run12 _menhir_env (Obj.magic _menhir_stack) MenhirState61\n | FRAGMENT ->\n _menhir_run11 _menhir_env (Obj.magic _menhir_stack) MenhirState61\n | MUTATION ->\n _menhir_run10 _menhir_env (Obj.magic _menhir_stack) MenhirState61\n | NAME _v ->\n _menhir_run9 _menhir_env (Obj.magic _menhir_stack) MenhirState61 _v\n | NULL ->\n _menhir_run8 _menhir_env (Obj.magic _menhir_stack) MenhirState61\n | ON ->\n _menhir_run7 _menhir_env (Obj.magic _menhir_stack) MenhirState61\n | QUERY ->\n _menhir_run6 _menhir_env (Obj.magic _menhir_stack) MenhirState61\n | SUBSCRIPTION ->\n _menhir_run5 _menhir_env (Obj.magic _menhir_stack) MenhirState61\n | RBRACE ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, (x : (Ast.selection))) = _menhir_stack in\n let _v : (Ast.selection list) = \n# 221 \"\"\n ( [ x ] )\n# 653 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_nonempty_list_selection_ _menhir_env _menhir_stack _menhir_s _v\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState61\n\nand _menhir_goto_list_variable_definition_ : _menhir_env -> 'ttv_tail -> _menhir_state -> (Ast.variable_definition list) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_stack = (_menhir_stack, _menhir_s, _v) in\n match _menhir_s with\n | MenhirState119 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let ((_menhir_stack, _menhir_s, (x : (Ast.variable_definition))), _, (xs : (Ast.variable_definition list))) = _menhir_stack in\n let _v : (Ast.variable_definition list) = \n# 213 \"\"\n ( x :: xs )\n# 672 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_list_variable_definition_ _menhir_env _menhir_stack _menhir_s _v\n | MenhirState86 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | RPAREN ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _, (_2 : (Ast.variable_definition list))) = _menhir_stack in\n let _v : (Ast.variable_definition list) = \n# 134 \"graphql_parser/src/parser.mly\"\n ( _2 )\n# 688 \"graphql_parser/src/parser.ml\"\n in\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (x : (Ast.variable_definition list)) = _v in\n let _v : (Ast.variable_definition list) = \n# 144 \"\"\n ( x )\n# 696 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_loption_variable_definitions_ _menhir_env _menhir_stack _v\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s)\n | _ ->\n _menhir_fail ()\n\nand _menhir_reduce30 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _v : (Ast.const_value list) = \n# 211 \"\"\n ( [] )\n# 713 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_list_const_value_ _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_reduce24 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _v : ((string * Ast.const_value) list) = \n# 211 \"\"\n ( [] )\n# 722 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_list___anonymous_0_const_value__ _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_goto_option_default_value_ : _menhir_env -> 'ttv_tail -> (Ast.const_value option) -> 'ttv_return =\n fun _menhir_env _menhir_stack _v ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_5 : (Ast.const_value option)) = _v in\n let (((_menhir_stack, _menhir_s), _, (_2 : (string))), _, (_4 : (Ast.typ))) = _menhir_stack in\n let _v : (Ast.variable_definition) = \n# 140 \"graphql_parser/src/parser.mly\"\n (\n {\n name = _2;\n typ = _4;\n default_value = _5;\n }\n )\n# 741 \"graphql_parser/src/parser.ml\"\n in\n let _menhir_stack = (_menhir_stack, _menhir_s, _v) in\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n match _tok with\n | DOLLAR ->\n _menhir_run87 _menhir_env (Obj.magic _menhir_stack) MenhirState119\n | RPAREN ->\n _menhir_reduce36 _menhir_env (Obj.magic _menhir_stack) MenhirState119\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState119\n\nand _menhir_run93 : _menhir_env -> 'ttv_tail * _menhir_state * (Ast.typ) -> 'ttv_return =\n fun _menhir_env _menhir_stack ->\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, (_1 : (Ast.typ))) = _menhir_stack in\n let _v : (Ast.typ) = \n# 151 \"graphql_parser/src/parser.mly\"\n ( NonNullType _1 )\n# 765 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_typ _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_reduce34 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _v : (Ast.value list) = \n# 211 \"\"\n ( [] )\n# 774 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_list_value_ _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_reduce26 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _v : ((string * Ast.value) list) = \n# 211 \"\"\n ( [] )\n# 783 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_list___anonymous_0_value__ _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_goto_loption_arguments_ : _menhir_env -> 'ttv_tail -> _menhir_state -> ((string * Ast.value) list) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_stack = (_menhir_stack, _menhir_s, _v) in\n match _menhir_s with\n | MenhirState21 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (((_menhir_stack, _menhir_s), _, (_2 : (string))), _, (_3 : ((string * Ast.value) list))) = _menhir_stack in\n let _v : (Ast.directive) = \n# 155 \"graphql_parser/src/parser.mly\"\n (\n {\n name = _2;\n arguments = _3;\n }\n )\n# 803 \"graphql_parser/src/parser.ml\"\n in\n let _menhir_stack = (_menhir_stack, _menhir_s, _v) in\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | AT ->\n _menhir_run20 _menhir_env (Obj.magic _menhir_stack) MenhirState57\n | BOOL _ | ELLIPSIS | FRAGMENT | LBRACE | MUTATION | NAME _ | NULL | ON | QUERY | RBRACE | SUBSCRIPTION ->\n _menhir_reduce32 _menhir_env (Obj.magic _menhir_stack) MenhirState57\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState57)\n | MenhirState65 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | AT ->\n _menhir_run20 _menhir_env (Obj.magic _menhir_stack) MenhirState66\n | BOOL _ | ELLIPSIS | FRAGMENT | LBRACE | MUTATION | NAME _ | NULL | ON | QUERY | RBRACE | SUBSCRIPTION ->\n _menhir_reduce32 _menhir_env (Obj.magic _menhir_stack) MenhirState66\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState66)\n | MenhirState63 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | AT ->\n _menhir_run20 _menhir_env (Obj.magic _menhir_stack) MenhirState70\n | BOOL _ | ELLIPSIS | FRAGMENT | LBRACE | MUTATION | NAME _ | NULL | ON | QUERY | RBRACE | SUBSCRIPTION ->\n _menhir_reduce32 _menhir_env (Obj.magic _menhir_stack) MenhirState70\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState70)\n | _ ->\n _menhir_fail ()\n\nand _menhir_reduce28 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _v : ((string * Ast.value) list) = \n# 211 \"\"\n ( [] )\n# 852 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_list_argument_ _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_goto_value_parser_const_value_ : _menhir_env -> 'ttv_tail -> _menhir_state -> (Ast.const_value) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_1 : (Ast.const_value)) = _v in\n let _v : (Ast.const_value) = \n# 183 \"graphql_parser/src/parser.mly\"\n ( _1 )\n# 864 \"graphql_parser/src/parser.ml\"\n in\n let _menhir_stack = (_menhir_stack, _menhir_s, _v) in\n match _menhir_s with\n | MenhirState102 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | BOOL _v ->\n _menhir_run14 _menhir_env (Obj.magic _menhir_stack) MenhirState108 _v\n | FRAGMENT ->\n _menhir_run11 _menhir_env (Obj.magic _menhir_stack) MenhirState108\n | MUTATION ->\n _menhir_run10 _menhir_env (Obj.magic _menhir_stack) MenhirState108\n | NAME _v ->\n _menhir_run9 _menhir_env (Obj.magic _menhir_stack) MenhirState108 _v\n | NULL ->\n _menhir_run8 _menhir_env (Obj.magic _menhir_stack) MenhirState108\n | ON ->\n _menhir_run7 _menhir_env (Obj.magic _menhir_stack) MenhirState108\n | QUERY ->\n _menhir_run6 _menhir_env (Obj.magic _menhir_stack) MenhirState108\n | SUBSCRIPTION ->\n _menhir_run5 _menhir_env (Obj.magic _menhir_stack) MenhirState108\n | RBRACE ->\n _menhir_reduce24 _menhir_env (Obj.magic _menhir_stack) MenhirState108\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState108)\n | MenhirState114 | MenhirState99 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | BOOL _v ->\n _menhir_run105 _menhir_env (Obj.magic _menhir_stack) MenhirState114 _v\n | FLOAT _v ->\n _menhir_run104 _menhir_env (Obj.magic _menhir_stack) MenhirState114 _v\n | FRAGMENT ->\n _menhir_run11 _menhir_env (Obj.magic _menhir_stack) MenhirState114\n | INT _v ->\n _menhir_run103 _menhir_env (Obj.magic _menhir_stack) MenhirState114 _v\n | LBRACE ->\n _menhir_run100 _menhir_env (Obj.magic _menhir_stack) MenhirState114\n | LBRACK ->\n _menhir_run99 _menhir_env (Obj.magic _menhir_stack) MenhirState114\n | MUTATION ->\n _menhir_run10 _menhir_env (Obj.magic _menhir_stack) MenhirState114\n | NAME _v ->\n _menhir_run27 _menhir_env (Obj.magic _menhir_stack) MenhirState114 _v\n | NULL ->\n _menhir_run98 _menhir_env (Obj.magic _menhir_stack) MenhirState114\n | QUERY ->\n _menhir_run6 _menhir_env (Obj.magic _menhir_stack) MenhirState114\n | STRING _v ->\n _menhir_run97 _menhir_env (Obj.magic _menhir_stack) MenhirState114 _v\n | SUBSCRIPTION ->\n _menhir_run5 _menhir_env (Obj.magic _menhir_stack) MenhirState114\n | RBRACK ->\n _menhir_reduce30 _menhir_env (Obj.magic _menhir_stack) MenhirState114\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState114)\n | MenhirState96 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _, (_2 : (Ast.const_value))) = _menhir_stack in\n let _v : (Ast.const_value) = \n# 137 \"graphql_parser/src/parser.mly\"\n ( _2 )\n# 937 \"graphql_parser/src/parser.ml\"\n in\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (x : (Ast.const_value)) = _v in\n let _v : (Ast.const_value option) = \n# 116 \"\"\n ( Some x )\n# 945 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_option_default_value_ _menhir_env _menhir_stack _v\n | _ ->\n _menhir_fail ()\n\nand _menhir_goto_value_parser_value_ : _menhir_env -> 'ttv_tail -> _menhir_state -> (Ast.value) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_1 : (Ast.value)) = _v in\n let _v : (Ast.value) = \n# 180 \"graphql_parser/src/parser.mly\"\n ( _1 )\n# 959 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_value _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_goto_list_directive_ : _menhir_env -> 'ttv_tail -> _menhir_state -> (Ast.directive list) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_stack = (_menhir_stack, _menhir_s, _v) in\n match _menhir_s with\n | MenhirState19 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | LBRACE ->\n _menhir_run4 _menhir_env (Obj.magic _menhir_stack) MenhirState55\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState55)\n | MenhirState57 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let ((_menhir_stack, _menhir_s, (x : (Ast.directive))), _, (xs : (Ast.directive list))) = _menhir_stack in\n let _v : (Ast.directive list) = \n# 213 \"\"\n ( x :: xs )\n# 985 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_list_directive_ _menhir_env _menhir_stack _menhir_s _v\n | MenhirState59 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (((_menhir_stack, _menhir_s), _, (_2 : (string))), _, (_3 : (Ast.directive list))) = _menhir_stack in\n let _v : (Ast.selection) = \n# 113 \"graphql_parser/src/parser.mly\"\n (\n FragmentSpread {\n name = _2;\n directives = _3;\n }\n )\n# 1000 \"graphql_parser/src/parser.ml\"\n in\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_1 : (Ast.selection)) = _v in\n let _v : (Ast.selection) = \n# 87 \"graphql_parser/src/parser.mly\"\n ( _1 )\n# 1008 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_selection _menhir_env _menhir_stack _menhir_s _v\n | MenhirState66 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | LBRACE ->\n _menhir_run4 _menhir_env (Obj.magic _menhir_stack) MenhirState67\n | BOOL _ | ELLIPSIS | FRAGMENT | MUTATION | NAME _ | NULL | ON | QUERY | RBRACE | SUBSCRIPTION ->\n _menhir_reduce40 _menhir_env (Obj.magic _menhir_stack) MenhirState67\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState67)\n | MenhirState70 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | LBRACE ->\n _menhir_run4 _menhir_env (Obj.magic _menhir_stack) MenhirState71\n | BOOL _ | ELLIPSIS | FRAGMENT | MUTATION | NAME _ | NULL | ON | QUERY | RBRACE | SUBSCRIPTION ->\n _menhir_reduce40 _menhir_env (Obj.magic _menhir_stack) MenhirState71\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState71)\n | MenhirState80 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | LBRACE ->\n _menhir_run4 _menhir_env (Obj.magic _menhir_stack) MenhirState81\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState81)\n | MenhirState124 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | LBRACE ->\n _menhir_run4 _menhir_env (Obj.magic _menhir_stack) MenhirState125\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState125)\n | _ ->\n _menhir_fail ()\n\nand _menhir_goto_loption_variable_definitions_ : _menhir_env -> 'ttv_tail -> (Ast.variable_definition list) -> 'ttv_return =\n fun _menhir_env _menhir_stack _v ->\n let _menhir_stack = (_menhir_stack, _v) in\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n match _tok with\n | AT ->\n _menhir_run20 _menhir_env (Obj.magic _menhir_stack) MenhirState124\n | LBRACE ->\n _menhir_reduce32 _menhir_env (Obj.magic _menhir_stack) MenhirState124\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState124\n\nand _menhir_reduce36 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _v : (Ast.variable_definition list) = \n# 211 \"\"\n ( [] )\n# 1083 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_list_variable_definition_ _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_run87 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _menhir_stack = (_menhir_stack, _menhir_s) in\n let _menhir_env = _menhir_discard _menhir_env in\n let _tok = _menhir_env._menhir_token in\n match _tok with\n | BOOL _v ->\n _menhir_run14 _menhir_env (Obj.magic _menhir_stack) MenhirState87 _v\n | FRAGMENT ->\n _menhir_run11 _menhir_env (Obj.magic _menhir_stack) MenhirState87\n | MUTATION ->\n _menhir_run10 _menhir_env (Obj.magic _menhir_stack) MenhirState87\n | NAME _v ->\n _menhir_run9 _menhir_env (Obj.magic _menhir_stack) MenhirState87 _v\n | NULL ->\n _menhir_run8 _menhir_env (Obj.magic _menhir_stack) MenhirState87\n | ON ->\n _menhir_run7 _menhir_env (Obj.magic _menhir_stack) MenhirState87\n | QUERY ->\n _menhir_run6 _menhir_env (Obj.magic _menhir_stack) MenhirState87\n | SUBSCRIPTION ->\n _menhir_run5 _menhir_env (Obj.magic _menhir_stack) MenhirState87\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState87\n\nand _menhir_run97 : _menhir_env -> 'ttv_tail -> _menhir_state -> (\n# 8 \"graphql_parser/src/parser.mly\"\n (string)\n# 1117 \"graphql_parser/src/parser.ml\"\n) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_1 : (\n# 8 \"graphql_parser/src/parser.mly\"\n (string)\n# 1125 \"graphql_parser/src/parser.ml\"\n )) = _v in\n let _v : (Ast.const_value) = \n# 172 \"graphql_parser/src/parser.mly\"\n ( `String _1 )\n# 1130 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_value_parser_const_value_ _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_run98 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let _v : (Ast.const_value) = \n# 169 \"graphql_parser/src/parser.mly\"\n ( `Null )\n# 1141 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_value_parser_const_value_ _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_run99 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _menhir_stack = (_menhir_stack, _menhir_s) in\n let _menhir_env = _menhir_discard _menhir_env in\n let _tok = _menhir_env._menhir_token in\n match _tok with\n | BOOL _v ->\n _menhir_run105 _menhir_env (Obj.magic _menhir_stack) MenhirState99 _v\n | FLOAT _v ->\n _menhir_run104 _menhir_env (Obj.magic _menhir_stack) MenhirState99 _v\n | FRAGMENT ->\n _menhir_run11 _menhir_env (Obj.magic _menhir_stack) MenhirState99\n | INT _v ->\n _menhir_run103 _menhir_env (Obj.magic _menhir_stack) MenhirState99 _v\n | LBRACE ->\n _menhir_run100 _menhir_env (Obj.magic _menhir_stack) MenhirState99\n | LBRACK ->\n _menhir_run99 _menhir_env (Obj.magic _menhir_stack) MenhirState99\n | MUTATION ->\n _menhir_run10 _menhir_env (Obj.magic _menhir_stack) MenhirState99\n | NAME _v ->\n _menhir_run27 _menhir_env (Obj.magic _menhir_stack) MenhirState99 _v\n | NULL ->\n _menhir_run98 _menhir_env (Obj.magic _menhir_stack) MenhirState99\n | QUERY ->\n _menhir_run6 _menhir_env (Obj.magic _menhir_stack) MenhirState99\n | STRING _v ->\n _menhir_run97 _menhir_env (Obj.magic _menhir_stack) MenhirState99 _v\n | SUBSCRIPTION ->\n _menhir_run5 _menhir_env (Obj.magic _menhir_stack) MenhirState99\n | RBRACK ->\n _menhir_reduce30 _menhir_env (Obj.magic _menhir_stack) MenhirState99\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState99\n\nand _menhir_run100 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _menhir_stack = (_menhir_stack, _menhir_s) in\n let _menhir_env = _menhir_discard _menhir_env in\n let _tok = _menhir_env._menhir_token in\n match _tok with\n | BOOL _v ->\n _menhir_run14 _menhir_env (Obj.magic _menhir_stack) MenhirState100 _v\n | FRAGMENT ->\n _menhir_run11 _menhir_env (Obj.magic _menhir_stack) MenhirState100\n | MUTATION ->\n _menhir_run10 _menhir_env (Obj.magic _menhir_stack) MenhirState100\n | NAME _v ->\n _menhir_run9 _menhir_env (Obj.magic _menhir_stack) MenhirState100 _v\n | NULL ->\n _menhir_run8 _menhir_env (Obj.magic _menhir_stack) MenhirState100\n | ON ->\n _menhir_run7 _menhir_env (Obj.magic _menhir_stack) MenhirState100\n | QUERY ->\n _menhir_run6 _menhir_env (Obj.magic _menhir_stack) MenhirState100\n | SUBSCRIPTION ->\n _menhir_run5 _menhir_env (Obj.magic _menhir_stack) MenhirState100\n | RBRACE ->\n _menhir_reduce24 _menhir_env (Obj.magic _menhir_stack) MenhirState100\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState100\n\nand _menhir_run103 : _menhir_env -> 'ttv_tail -> _menhir_state -> (\n# 6 \"graphql_parser/src/parser.mly\"\n (int)\n# 1214 \"graphql_parser/src/parser.ml\"\n) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_1 : (\n# 6 \"graphql_parser/src/parser.mly\"\n (int)\n# 1222 \"graphql_parser/src/parser.ml\"\n )) = _v in\n let _v : (Ast.const_value) = \n# 170 \"graphql_parser/src/parser.mly\"\n ( `Int _1 )\n# 1227 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_value_parser_const_value_ _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_run104 : _menhir_env -> 'ttv_tail -> _menhir_state -> (\n# 7 \"graphql_parser/src/parser.mly\"\n (float)\n# 1234 \"graphql_parser/src/parser.ml\"\n) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_1 : (\n# 7 \"graphql_parser/src/parser.mly\"\n (float)\n# 1242 \"graphql_parser/src/parser.ml\"\n )) = _v in\n let _v : (Ast.const_value) = \n# 171 \"graphql_parser/src/parser.mly\"\n ( `Float _1 )\n# 1247 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_value_parser_const_value_ _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_run105 : _menhir_env -> 'ttv_tail -> _menhir_state -> (\n# 9 \"graphql_parser/src/parser.mly\"\n (bool)\n# 1254 \"graphql_parser/src/parser.ml\"\n) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_1 : (\n# 9 \"graphql_parser/src/parser.mly\"\n (bool)\n# 1262 \"graphql_parser/src/parser.ml\"\n )) = _v in\n let _v : (Ast.const_value) = \n# 173 \"graphql_parser/src/parser.mly\"\n ( `Bool _1 )\n# 1267 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_value_parser_const_value_ _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_goto_typ : _menhir_env -> 'ttv_tail -> _menhir_state -> (Ast.typ) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_stack = (_menhir_stack, _menhir_s, _v) in\n match _menhir_s with\n | MenhirState90 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | BANG ->\n _menhir_run93 _menhir_env (Obj.magic _menhir_stack)\n | RBRACK ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let ((_menhir_stack, _menhir_s), _, (_2 : (Ast.typ))) = _menhir_stack in\n let _v : (Ast.typ) = \n# 150 \"graphql_parser/src/parser.mly\"\n ( ListType _2 )\n# 1290 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_typ _menhir_env _menhir_stack _menhir_s _v\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s)\n | MenhirState89 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | BANG ->\n _menhir_run93 _menhir_env (Obj.magic _menhir_stack)\n | EQUAL ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_env = _menhir_discard _menhir_env in\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | BOOL _v ->\n _menhir_run105 _menhir_env (Obj.magic _menhir_stack) MenhirState96 _v\n | FLOAT _v ->\n _menhir_run104 _menhir_env (Obj.magic _menhir_stack) MenhirState96 _v\n | FRAGMENT ->\n _menhir_run11 _menhir_env (Obj.magic _menhir_stack) MenhirState96\n | INT _v ->\n _menhir_run103 _menhir_env (Obj.magic _menhir_stack) MenhirState96 _v\n | LBRACE ->\n _menhir_run100 _menhir_env (Obj.magic _menhir_stack) MenhirState96\n | LBRACK ->\n _menhir_run99 _menhir_env (Obj.magic _menhir_stack) MenhirState96\n | MUTATION ->\n _menhir_run10 _menhir_env (Obj.magic _menhir_stack) MenhirState96\n | NAME _v ->\n _menhir_run27 _menhir_env (Obj.magic _menhir_stack) MenhirState96 _v\n | NULL ->\n _menhir_run98 _menhir_env (Obj.magic _menhir_stack) MenhirState96\n | QUERY ->\n _menhir_run6 _menhir_env (Obj.magic _menhir_stack) MenhirState96\n | STRING _v ->\n _menhir_run97 _menhir_env (Obj.magic _menhir_stack) MenhirState96 _v\n | SUBSCRIPTION ->\n _menhir_run5 _menhir_env (Obj.magic _menhir_stack) MenhirState96\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState96)\n | DOLLAR | RPAREN ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _v : (Ast.const_value option) = \n# 114 \"\"\n ( None )\n# 1344 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_option_default_value_ _menhir_env _menhir_stack _v\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s)\n | _ ->\n _menhir_fail ()\n\nand _menhir_run90 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _menhir_stack = (_menhir_stack, _menhir_s) in\n let _menhir_env = _menhir_discard _menhir_env in\n let _tok = _menhir_env._menhir_token in\n match _tok with\n | BOOL _v ->\n _menhir_run14 _menhir_env (Obj.magic _menhir_stack) MenhirState90 _v\n | FRAGMENT ->\n _menhir_run11 _menhir_env (Obj.magic _menhir_stack) MenhirState90\n | LBRACK ->\n _menhir_run90 _menhir_env (Obj.magic _menhir_stack) MenhirState90\n | MUTATION ->\n _menhir_run10 _menhir_env (Obj.magic _menhir_stack) MenhirState90\n | NAME _v ->\n _menhir_run9 _menhir_env (Obj.magic _menhir_stack) MenhirState90 _v\n | NULL ->\n _menhir_run8 _menhir_env (Obj.magic _menhir_stack) MenhirState90\n | ON ->\n _menhir_run7 _menhir_env (Obj.magic _menhir_stack) MenhirState90\n | QUERY ->\n _menhir_run6 _menhir_env (Obj.magic _menhir_stack) MenhirState90\n | SUBSCRIPTION ->\n _menhir_run5 _menhir_env (Obj.magic _menhir_stack) MenhirState90\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState90\n\nand _menhir_goto_value : _menhir_env -> 'ttv_tail -> _menhir_state -> (Ast.value) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_stack = (_menhir_stack, _menhir_s, _v) in\n match _menhir_s with\n | MenhirState31 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | BOOL _v ->\n _menhir_run14 _menhir_env (Obj.magic _menhir_stack) MenhirState38 _v\n | FRAGMENT ->\n _menhir_run11 _menhir_env (Obj.magic _menhir_stack) MenhirState38\n | MUTATION ->\n _menhir_run10 _menhir_env (Obj.magic _menhir_stack) MenhirState38\n | NAME _v ->\n _menhir_run9 _menhir_env (Obj.magic _menhir_stack) MenhirState38 _v\n | NULL ->\n _menhir_run8 _menhir_env (Obj.magic _menhir_stack) MenhirState38\n | ON ->\n _menhir_run7 _menhir_env (Obj.magic _menhir_stack) MenhirState38\n | QUERY ->\n _menhir_run6 _menhir_env (Obj.magic _menhir_stack) MenhirState38\n | SUBSCRIPTION ->\n _menhir_run5 _menhir_env (Obj.magic _menhir_stack) MenhirState38\n | RBRACE ->\n _menhir_reduce26 _menhir_env (Obj.magic _menhir_stack) MenhirState38\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState38)\n | MenhirState44 | MenhirState28 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | BOOL _v ->\n _menhir_run36 _menhir_env (Obj.magic _menhir_stack) MenhirState44 _v\n | DOLLAR ->\n _menhir_run34 _menhir_env (Obj.magic _menhir_stack) MenhirState44\n | FLOAT _v ->\n _menhir_run33 _menhir_env (Obj.magic _menhir_stack) MenhirState44 _v\n | FRAGMENT ->\n _menhir_run11 _menhir_env (Obj.magic _menhir_stack) MenhirState44\n | INT _v ->\n _menhir_run32 _menhir_env (Obj.magic _menhir_stack) MenhirState44 _v\n | LBRACE ->\n _menhir_run29 _menhir_env (Obj.magic _menhir_stack) MenhirState44\n | LBRACK ->\n _menhir_run28 _menhir_env (Obj.magic _menhir_stack) MenhirState44\n | MUTATION ->\n _menhir_run10 _menhir_env (Obj.magic _menhir_stack) MenhirState44\n | NAME _v ->\n _menhir_run27 _menhir_env (Obj.magic _menhir_stack) MenhirState44 _v\n | NULL ->\n _menhir_run26 _menhir_env (Obj.magic _menhir_stack) MenhirState44\n | QUERY ->\n _menhir_run6 _menhir_env (Obj.magic _menhir_stack) MenhirState44\n | STRING _v ->\n _menhir_run25 _menhir_env (Obj.magic _menhir_stack) MenhirState44 _v\n | SUBSCRIPTION ->\n _menhir_run5 _menhir_env (Obj.magic _menhir_stack) MenhirState44\n | RBRACK ->\n _menhir_reduce34 _menhir_env (Obj.magic _menhir_stack) MenhirState44\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState44)\n | MenhirState24 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let ((_menhir_stack, _menhir_s, (_1 : (string))), _, (_3 : (Ast.value))) = _menhir_stack in\n let _v : (string * Ast.value) = \n# 166 \"graphql_parser/src/parser.mly\"\n ( _1, _3 )\n# 1460 \"graphql_parser/src/parser.ml\"\n in\n let _menhir_stack = (_menhir_stack, _menhir_s, _v) in\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | BOOL _v ->\n _menhir_run14 _menhir_env (Obj.magic _menhir_stack) MenhirState51 _v\n | FRAGMENT ->\n _menhir_run11 _menhir_env (Obj.magic _menhir_stack) MenhirState51\n | MUTATION ->\n _menhir_run10 _menhir_env (Obj.magic _menhir_stack) MenhirState51\n | NAME _v ->\n _menhir_run9 _menhir_env (Obj.magic _menhir_stack) MenhirState51 _v\n | NULL ->\n _menhir_run8 _menhir_env (Obj.magic _menhir_stack) MenhirState51\n | ON ->\n _menhir_run7 _menhir_env (Obj.magic _menhir_stack) MenhirState51\n | QUERY ->\n _menhir_run6 _menhir_env (Obj.magic _menhir_stack) MenhirState51\n | SUBSCRIPTION ->\n _menhir_run5 _menhir_env (Obj.magic _menhir_stack) MenhirState51\n | RPAREN ->\n _menhir_reduce28 _menhir_env (Obj.magic _menhir_stack) MenhirState51\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState51)\n | _ ->\n _menhir_fail ()\n\nand _menhir_run25 : _menhir_env -> 'ttv_tail -> _menhir_state -> (\n# 8 \"graphql_parser/src/parser.mly\"\n (string)\n# 1495 \"graphql_parser/src/parser.ml\"\n) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_1 : (\n# 8 \"graphql_parser/src/parser.mly\"\n (string)\n# 1503 \"graphql_parser/src/parser.ml\"\n )) = _v in\n let _v : (Ast.value) = \n# 172 \"graphql_parser/src/parser.mly\"\n ( `String _1 )\n# 1508 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_value_parser_value_ _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_run26 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let _v : (Ast.value) = \n# 169 \"graphql_parser/src/parser.mly\"\n ( `Null )\n# 1519 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_value_parser_value_ _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_run27 : _menhir_env -> 'ttv_tail -> _menhir_state -> (\n# 5 \"graphql_parser/src/parser.mly\"\n (string)\n# 1526 \"graphql_parser/src/parser.ml\"\n) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_1 : (\n# 5 \"graphql_parser/src/parser.mly\"\n (string)\n# 1534 \"graphql_parser/src/parser.ml\"\n )) = _v in\n let _v : (string) = \n# 193 \"graphql_parser/src/parser.mly\"\n ( _1 )\n# 1539 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_enum_value _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_run28 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _menhir_stack = (_menhir_stack, _menhir_s) in\n let _menhir_env = _menhir_discard _menhir_env in\n let _tok = _menhir_env._menhir_token in\n match _tok with\n | BOOL _v ->\n _menhir_run36 _menhir_env (Obj.magic _menhir_stack) MenhirState28 _v\n | DOLLAR ->\n _menhir_run34 _menhir_env (Obj.magic _menhir_stack) MenhirState28\n | FLOAT _v ->\n _menhir_run33 _menhir_env (Obj.magic _menhir_stack) MenhirState28 _v\n | FRAGMENT ->\n _menhir_run11 _menhir_env (Obj.magic _menhir_stack) MenhirState28\n | INT _v ->\n _menhir_run32 _menhir_env (Obj.magic _menhir_stack) MenhirState28 _v\n | LBRACE ->\n _menhir_run29 _menhir_env (Obj.magic _menhir_stack) MenhirState28\n | LBRACK ->\n _menhir_run28 _menhir_env (Obj.magic _menhir_stack) MenhirState28\n | MUTATION ->\n _menhir_run10 _menhir_env (Obj.magic _menhir_stack) MenhirState28\n | NAME _v ->\n _menhir_run27 _menhir_env (Obj.magic _menhir_stack) MenhirState28 _v\n | NULL ->\n _menhir_run26 _menhir_env (Obj.magic _menhir_stack) MenhirState28\n | QUERY ->\n _menhir_run6 _menhir_env (Obj.magic _menhir_stack) MenhirState28\n | STRING _v ->\n _menhir_run25 _menhir_env (Obj.magic _menhir_stack) MenhirState28 _v\n | SUBSCRIPTION ->\n _menhir_run5 _menhir_env (Obj.magic _menhir_stack) MenhirState28\n | RBRACK ->\n _menhir_reduce34 _menhir_env (Obj.magic _menhir_stack) MenhirState28\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState28\n\nand _menhir_run29 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _menhir_stack = (_menhir_stack, _menhir_s) in\n let _menhir_env = _menhir_discard _menhir_env in\n let _tok = _menhir_env._menhir_token in\n match _tok with\n | BOOL _v ->\n _menhir_run14 _menhir_env (Obj.magic _menhir_stack) MenhirState29 _v\n | FRAGMENT ->\n _menhir_run11 _menhir_env (Obj.magic _menhir_stack) MenhirState29\n | MUTATION ->\n _menhir_run10 _menhir_env (Obj.magic _menhir_stack) MenhirState29\n | NAME _v ->\n _menhir_run9 _menhir_env (Obj.magic _menhir_stack) MenhirState29 _v\n | NULL ->\n _menhir_run8 _menhir_env (Obj.magic _menhir_stack) MenhirState29\n | ON ->\n _menhir_run7 _menhir_env (Obj.magic _menhir_stack) MenhirState29\n | QUERY ->\n _menhir_run6 _menhir_env (Obj.magic _menhir_stack) MenhirState29\n | SUBSCRIPTION ->\n _menhir_run5 _menhir_env (Obj.magic _menhir_stack) MenhirState29\n | RBRACE ->\n _menhir_reduce26 _menhir_env (Obj.magic _menhir_stack) MenhirState29\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState29\n\nand _menhir_run32 : _menhir_env -> 'ttv_tail -> _menhir_state -> (\n# 6 \"graphql_parser/src/parser.mly\"\n (int)\n# 1614 \"graphql_parser/src/parser.ml\"\n) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_1 : (\n# 6 \"graphql_parser/src/parser.mly\"\n (int)\n# 1622 \"graphql_parser/src/parser.ml\"\n )) = _v in\n let _v : (Ast.value) = \n# 170 \"graphql_parser/src/parser.mly\"\n ( `Int _1 )\n# 1627 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_value_parser_value_ _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_run33 : _menhir_env -> 'ttv_tail -> _menhir_state -> (\n# 7 \"graphql_parser/src/parser.mly\"\n (float)\n# 1634 \"graphql_parser/src/parser.ml\"\n) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_1 : (\n# 7 \"graphql_parser/src/parser.mly\"\n (float)\n# 1642 \"graphql_parser/src/parser.ml\"\n )) = _v in\n let _v : (Ast.value) = \n# 171 \"graphql_parser/src/parser.mly\"\n ( `Float _1 )\n# 1647 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_value_parser_value_ _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_run34 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _menhir_stack = (_menhir_stack, _menhir_s) in\n let _menhir_env = _menhir_discard _menhir_env in\n let _tok = _menhir_env._menhir_token in\n match _tok with\n | BOOL _v ->\n _menhir_run14 _menhir_env (Obj.magic _menhir_stack) MenhirState34 _v\n | FRAGMENT ->\n _menhir_run11 _menhir_env (Obj.magic _menhir_stack) MenhirState34\n | MUTATION ->\n _menhir_run10 _menhir_env (Obj.magic _menhir_stack) MenhirState34\n | NAME _v ->\n _menhir_run9 _menhir_env (Obj.magic _menhir_stack) MenhirState34 _v\n | NULL ->\n _menhir_run8 _menhir_env (Obj.magic _menhir_stack) MenhirState34\n | ON ->\n _menhir_run7 _menhir_env (Obj.magic _menhir_stack) MenhirState34\n | QUERY ->\n _menhir_run6 _menhir_env (Obj.magic _menhir_stack) MenhirState34\n | SUBSCRIPTION ->\n _menhir_run5 _menhir_env (Obj.magic _menhir_stack) MenhirState34\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState34\n\nand _menhir_run36 : _menhir_env -> 'ttv_tail -> _menhir_state -> (\n# 9 \"graphql_parser/src/parser.mly\"\n (bool)\n# 1681 \"graphql_parser/src/parser.ml\"\n) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_1 : (\n# 9 \"graphql_parser/src/parser.mly\"\n (bool)\n# 1689 \"graphql_parser/src/parser.ml\"\n )) = _v in\n let _v : (Ast.value) = \n# 173 \"graphql_parser/src/parser.mly\"\n ( `Bool _1 )\n# 1694 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_value_parser_value_ _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_reduce38 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _v : ((string * Ast.value) list) = \n# 142 \"\"\n ( [] )\n# 1703 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_loption_arguments_ _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_run22 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _menhir_stack = (_menhir_stack, _menhir_s) in\n let _menhir_env = _menhir_discard _menhir_env in\n let _tok = _menhir_env._menhir_token in\n match _tok with\n | BOOL _v ->\n _menhir_run14 _menhir_env (Obj.magic _menhir_stack) MenhirState22 _v\n | FRAGMENT ->\n _menhir_run11 _menhir_env (Obj.magic _menhir_stack) MenhirState22\n | MUTATION ->\n _menhir_run10 _menhir_env (Obj.magic _menhir_stack) MenhirState22\n | NAME _v ->\n _menhir_run9 _menhir_env (Obj.magic _menhir_stack) MenhirState22 _v\n | NULL ->\n _menhir_run8 _menhir_env (Obj.magic _menhir_stack) MenhirState22\n | ON ->\n _menhir_run7 _menhir_env (Obj.magic _menhir_stack) MenhirState22\n | QUERY ->\n _menhir_run6 _menhir_env (Obj.magic _menhir_stack) MenhirState22\n | SUBSCRIPTION ->\n _menhir_run5 _menhir_env (Obj.magic _menhir_stack) MenhirState22\n | RPAREN ->\n _menhir_reduce28 _menhir_env (Obj.magic _menhir_stack) MenhirState22\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState22\n\nand _menhir_goto_enum_value : _menhir_env -> 'ttv_tail -> _menhir_state -> (string) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n match _menhir_s with\n | MenhirState24 | MenhirState28 | MenhirState44 | MenhirState31 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_1 : (string)) = _v in\n let _v : (Ast.value) = \n# 174 \"graphql_parser/src/parser.mly\"\n ( `Enum _1 )\n# 1746 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_value_parser_value_ _menhir_env _menhir_stack _menhir_s _v\n | MenhirState96 | MenhirState114 | MenhirState99 | MenhirState102 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_1 : (string)) = _v in\n let _v : (Ast.const_value) = \n# 174 \"graphql_parser/src/parser.mly\"\n ( `Enum _1 )\n# 1756 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_value_parser_const_value_ _menhir_env _menhir_stack _menhir_s _v\n | _ ->\n _menhir_fail ()\n\nand _menhir_fail : unit -> 'a =\n fun () ->\n Printf.fprintf stderr \"Internal failure -- please contact the parser generator's developers.\\n%!\";\n assert false\n\nand _menhir_reduce32 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _v : (Ast.directive list) = \n# 211 \"\"\n ( [] )\n# 1772 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_list_directive_ _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_run20 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _menhir_stack = (_menhir_stack, _menhir_s) in\n let _menhir_env = _menhir_discard _menhir_env in\n let _tok = _menhir_env._menhir_token in\n match _tok with\n | BOOL _v ->\n _menhir_run14 _menhir_env (Obj.magic _menhir_stack) MenhirState20 _v\n | FRAGMENT ->\n _menhir_run11 _menhir_env (Obj.magic _menhir_stack) MenhirState20\n | MUTATION ->\n _menhir_run10 _menhir_env (Obj.magic _menhir_stack) MenhirState20\n | NAME _v ->\n _menhir_run9 _menhir_env (Obj.magic _menhir_stack) MenhirState20 _v\n | NULL ->\n _menhir_run8 _menhir_env (Obj.magic _menhir_stack) MenhirState20\n | ON ->\n _menhir_run7 _menhir_env (Obj.magic _menhir_stack) MenhirState20\n | QUERY ->\n _menhir_run6 _menhir_env (Obj.magic _menhir_stack) MenhirState20\n | SUBSCRIPTION ->\n _menhir_run5 _menhir_env (Obj.magic _menhir_stack) MenhirState20\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState20\n\nand _menhir_goto_option_name_ : _menhir_env -> 'ttv_tail -> _menhir_state -> (string option) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_stack = (_menhir_stack, _menhir_s, _v) in\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n match _tok with\n | LPAREN ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_env = _menhir_discard _menhir_env in\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | DOLLAR ->\n _menhir_run87 _menhir_env (Obj.magic _menhir_stack) MenhirState86\n | RPAREN ->\n _menhir_reduce36 _menhir_env (Obj.magic _menhir_stack) MenhirState86\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState86)\n | AT | LBRACE ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _v : (Ast.variable_definition list) = \n# 142 \"\"\n ( [] )\n# 1828 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_loption_variable_definitions_ _menhir_env _menhir_stack _v\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n\nand _menhir_goto_name : _menhir_env -> 'ttv_tail -> _menhir_state -> (string) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_stack = (_menhir_stack, _menhir_s, _v) in\n match _menhir_s with\n | MenhirState13 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let ((_menhir_stack, _menhir_s), _, (_2 : (string))) = _menhir_stack in\n let _v : (string) = \n# 121 \"graphql_parser/src/parser.mly\"\n ( _2 )\n# 1849 \"graphql_parser/src/parser.ml\"\n in\n let _menhir_stack = (_menhir_stack, _menhir_s, _v) in\n (match _menhir_s with\n | MenhirState12 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, (x : (string))) = _menhir_stack in\n let _v : (string option) = \n# 116 \"\"\n ( Some x )\n# 1860 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_option_type_condition_ _menhir_env _menhir_stack _menhir_s _v\n | MenhirState79 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | AT ->\n _menhir_run20 _menhir_env (Obj.magic _menhir_stack) MenhirState80\n | LBRACE ->\n _menhir_reduce32 _menhir_env (Obj.magic _menhir_stack) MenhirState80\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState80)\n | _ ->\n _menhir_fail ())\n | MenhirState20 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | LPAREN ->\n _menhir_run22 _menhir_env (Obj.magic _menhir_stack) MenhirState21\n | AT | BOOL _ | ELLIPSIS | FRAGMENT | LBRACE | MUTATION | NAME _ | NULL | ON | QUERY | RBRACE | SUBSCRIPTION ->\n _menhir_reduce38 _menhir_env (Obj.magic _menhir_stack) MenhirState21\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState21)\n | MenhirState51 | MenhirState22 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | COLON ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_env = _menhir_discard _menhir_env in\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | BOOL _v ->\n _menhir_run36 _menhir_env (Obj.magic _menhir_stack) MenhirState24 _v\n | DOLLAR ->\n _menhir_run34 _menhir_env (Obj.magic _menhir_stack) MenhirState24\n | FLOAT _v ->\n _menhir_run33 _menhir_env (Obj.magic _menhir_stack) MenhirState24 _v\n | FRAGMENT ->\n _menhir_run11 _menhir_env (Obj.magic _menhir_stack) MenhirState24\n | INT _v ->\n _menhir_run32 _menhir_env (Obj.magic _menhir_stack) MenhirState24 _v\n | LBRACE ->\n _menhir_run29 _menhir_env (Obj.magic _menhir_stack) MenhirState24\n | LBRACK ->\n _menhir_run28 _menhir_env (Obj.magic _menhir_stack) MenhirState24\n | MUTATION ->\n _menhir_run10 _menhir_env (Obj.magic _menhir_stack) MenhirState24\n | NAME _v ->\n _menhir_run27 _menhir_env (Obj.magic _menhir_stack) MenhirState24 _v\n | NULL ->\n _menhir_run26 _menhir_env (Obj.magic _menhir_stack) MenhirState24\n | QUERY ->\n _menhir_run6 _menhir_env (Obj.magic _menhir_stack) MenhirState24\n | STRING _v ->\n _menhir_run25 _menhir_env (Obj.magic _menhir_stack) MenhirState24 _v\n | SUBSCRIPTION ->\n _menhir_run5 _menhir_env (Obj.magic _menhir_stack) MenhirState24\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState24)\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s)\n | MenhirState38 | MenhirState29 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | COLON ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_env = _menhir_discard _menhir_env in\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | BOOL _v ->\n _menhir_run36 _menhir_env (Obj.magic _menhir_stack) MenhirState31 _v\n | DOLLAR ->\n _menhir_run34 _menhir_env (Obj.magic _menhir_stack) MenhirState31\n | FLOAT _v ->\n _menhir_run33 _menhir_env (Obj.magic _menhir_stack) MenhirState31 _v\n | FRAGMENT ->\n _menhir_run11 _menhir_env (Obj.magic _menhir_stack) MenhirState31\n | INT _v ->\n _menhir_run32 _menhir_env (Obj.magic _menhir_stack) MenhirState31 _v\n | LBRACE ->\n _menhir_run29 _menhir_env (Obj.magic _menhir_stack) MenhirState31\n | LBRACK ->\n _menhir_run28 _menhir_env (Obj.magic _menhir_stack) MenhirState31\n | MUTATION ->\n _menhir_run10 _menhir_env (Obj.magic _menhir_stack) MenhirState31\n | NAME _v ->\n _menhir_run27 _menhir_env (Obj.magic _menhir_stack) MenhirState31 _v\n | NULL ->\n _menhir_run26 _menhir_env (Obj.magic _menhir_stack) MenhirState31\n | QUERY ->\n _menhir_run6 _menhir_env (Obj.magic _menhir_stack) MenhirState31\n | STRING _v ->\n _menhir_run25 _menhir_env (Obj.magic _menhir_stack) MenhirState31 _v\n | SUBSCRIPTION ->\n _menhir_run5 _menhir_env (Obj.magic _menhir_stack) MenhirState31\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState31)\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s)\n | MenhirState34 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let ((_menhir_stack, _menhir_s), _, (_2 : (string))) = _menhir_stack in\n let _v : (Ast.value) = \n# 179 \"graphql_parser/src/parser.mly\"\n ( `Variable _2 )\n# 1990 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_value _menhir_env _menhir_stack _menhir_s _v\n | MenhirState4 | MenhirState61 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | COLON ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_s = MenhirState63 in\n let _menhir_stack = (_menhir_stack, _menhir_s) in\n let _menhir_env = _menhir_discard _menhir_env in\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | BOOL _v ->\n _menhir_run14 _menhir_env (Obj.magic _menhir_stack) MenhirState64 _v\n | FRAGMENT ->\n _menhir_run11 _menhir_env (Obj.magic _menhir_stack) MenhirState64\n | MUTATION ->\n _menhir_run10 _menhir_env (Obj.magic _menhir_stack) MenhirState64\n | NAME _v ->\n _menhir_run9 _menhir_env (Obj.magic _menhir_stack) MenhirState64 _v\n | NULL ->\n _menhir_run8 _menhir_env (Obj.magic _menhir_stack) MenhirState64\n | ON ->\n _menhir_run7 _menhir_env (Obj.magic _menhir_stack) MenhirState64\n | QUERY ->\n _menhir_run6 _menhir_env (Obj.magic _menhir_stack) MenhirState64\n | SUBSCRIPTION ->\n _menhir_run5 _menhir_env (Obj.magic _menhir_stack) MenhirState64\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState64)\n | LPAREN ->\n _menhir_run22 _menhir_env (Obj.magic _menhir_stack) MenhirState63\n | AT | BOOL _ | ELLIPSIS | FRAGMENT | LBRACE | MUTATION | NAME _ | NULL | ON | QUERY | RBRACE | SUBSCRIPTION ->\n _menhir_reduce38 _menhir_env (Obj.magic _menhir_stack) MenhirState63\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState63)\n | MenhirState64 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | LPAREN ->\n _menhir_run22 _menhir_env (Obj.magic _menhir_stack) MenhirState65\n | AT | BOOL _ | ELLIPSIS | FRAGMENT | LBRACE | MUTATION | NAME _ | NULL | ON | QUERY | RBRACE | SUBSCRIPTION ->\n _menhir_reduce38 _menhir_env (Obj.magic _menhir_stack) MenhirState65\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState65)\n | MenhirState87 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | COLON ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_env = _menhir_discard _menhir_env in\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | BOOL _v ->\n _menhir_run14 _menhir_env (Obj.magic _menhir_stack) MenhirState89 _v\n | FRAGMENT ->\n _menhir_run11 _menhir_env (Obj.magic _menhir_stack) MenhirState89\n | LBRACK ->\n _menhir_run90 _menhir_env (Obj.magic _menhir_stack) MenhirState89\n | MUTATION ->\n _menhir_run10 _menhir_env (Obj.magic _menhir_stack) MenhirState89\n | NAME _v ->\n _menhir_run9 _menhir_env (Obj.magic _menhir_stack) MenhirState89 _v\n | NULL ->\n _menhir_run8 _menhir_env (Obj.magic _menhir_stack) MenhirState89\n | ON ->\n _menhir_run7 _menhir_env (Obj.magic _menhir_stack) MenhirState89\n | QUERY ->\n _menhir_run6 _menhir_env (Obj.magic _menhir_stack) MenhirState89\n | SUBSCRIPTION ->\n _menhir_run5 _menhir_env (Obj.magic _menhir_stack) MenhirState89\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState89)\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s)\n | MenhirState89 | MenhirState90 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, (_1 : (string))) = _menhir_stack in\n let _v : (Ast.typ) = \n# 149 \"graphql_parser/src/parser.mly\"\n ( NamedType _1 )\n# 2091 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_typ _menhir_env _menhir_stack _menhir_s _v\n | MenhirState108 | MenhirState100 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | COLON ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_env = _menhir_discard _menhir_env in\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | BOOL _v ->\n _menhir_run105 _menhir_env (Obj.magic _menhir_stack) MenhirState102 _v\n | FLOAT _v ->\n _menhir_run104 _menhir_env (Obj.magic _menhir_stack) MenhirState102 _v\n | FRAGMENT ->\n _menhir_run11 _menhir_env (Obj.magic _menhir_stack) MenhirState102\n | INT _v ->\n _menhir_run103 _menhir_env (Obj.magic _menhir_stack) MenhirState102 _v\n | LBRACE ->\n _menhir_run100 _menhir_env (Obj.magic _menhir_stack) MenhirState102\n | LBRACK ->\n _menhir_run99 _menhir_env (Obj.magic _menhir_stack) MenhirState102\n | MUTATION ->\n _menhir_run10 _menhir_env (Obj.magic _menhir_stack) MenhirState102\n | NAME _v ->\n _menhir_run27 _menhir_env (Obj.magic _menhir_stack) MenhirState102 _v\n | NULL ->\n _menhir_run98 _menhir_env (Obj.magic _menhir_stack) MenhirState102\n | QUERY ->\n _menhir_run6 _menhir_env (Obj.magic _menhir_stack) MenhirState102\n | STRING _v ->\n _menhir_run97 _menhir_env (Obj.magic _menhir_stack) MenhirState102 _v\n | SUBSCRIPTION ->\n _menhir_run5 _menhir_env (Obj.magic _menhir_stack) MenhirState102\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState102)\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s)\n | MenhirState84 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, (x : (string))) = _menhir_stack in\n let _v : (string option) = \n# 116 \"\"\n ( Some x )\n# 2145 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_option_name_ _menhir_env _menhir_stack _menhir_s _v\n | _ ->\n _menhir_fail ()\n\nand _menhir_goto_option_type_condition_ : _menhir_env -> 'ttv_tail -> _menhir_state -> (string option) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_stack = (_menhir_stack, _menhir_s, _v) in\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n match _tok with\n | AT ->\n _menhir_run20 _menhir_env (Obj.magic _menhir_stack) MenhirState19\n | LBRACE ->\n _menhir_reduce32 _menhir_env (Obj.magic _menhir_stack) MenhirState19\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState19\n\nand _menhir_run13 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _menhir_stack = (_menhir_stack, _menhir_s) in\n let _menhir_env = _menhir_discard _menhir_env in\n let _tok = _menhir_env._menhir_token in\n match _tok with\n | BOOL _v ->\n _menhir_run14 _menhir_env (Obj.magic _menhir_stack) MenhirState13 _v\n | FRAGMENT ->\n _menhir_run11 _menhir_env (Obj.magic _menhir_stack) MenhirState13\n | MUTATION ->\n _menhir_run10 _menhir_env (Obj.magic _menhir_stack) MenhirState13\n | NAME _v ->\n _menhir_run9 _menhir_env (Obj.magic _menhir_stack) MenhirState13 _v\n | NULL ->\n _menhir_run8 _menhir_env (Obj.magic _menhir_stack) MenhirState13\n | ON ->\n _menhir_run7 _menhir_env (Obj.magic _menhir_stack) MenhirState13\n | QUERY ->\n _menhir_run6 _menhir_env (Obj.magic _menhir_stack) MenhirState13\n | SUBSCRIPTION ->\n _menhir_run5 _menhir_env (Obj.magic _menhir_stack) MenhirState13\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState13\n\nand _menhir_goto_keyword_name : _menhir_env -> 'ttv_tail -> _menhir_state -> (string) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n match _menhir_s with\n | MenhirState84 | MenhirState87 | MenhirState89 | MenhirState100 | MenhirState108 | MenhirState90 | MenhirState78 | MenhirState4 | MenhirState61 | MenhirState64 | MenhirState12 | MenhirState20 | MenhirState51 | MenhirState22 | MenhirState29 | MenhirState38 | MenhirState34 | MenhirState13 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_1 : (string)) = _v in\n let _v : (string) = \n# 199 \"graphql_parser/src/parser.mly\"\n ( _1 )\n# 2204 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_fragment_name _menhir_env _menhir_stack _menhir_s _v\n | MenhirState96 | MenhirState114 | MenhirState99 | MenhirState102 | MenhirState24 | MenhirState28 | MenhirState44 | MenhirState31 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_1 : (string)) = _v in\n let _v : (string) = \n# 193 \"graphql_parser/src/parser.mly\"\n ( _1 )\n# 2214 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_enum_value _menhir_env _menhir_stack _menhir_s _v\n | _ ->\n _menhir_fail ()\n\nand _menhir_goto_fragment_name : _menhir_env -> 'ttv_tail -> _menhir_state -> (string) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_stack = (_menhir_stack, _menhir_s, _v) in\n match _menhir_s with\n | MenhirState84 | MenhirState87 | MenhirState89 | MenhirState100 | MenhirState108 | MenhirState90 | MenhirState4 | MenhirState61 | MenhirState64 | MenhirState20 | MenhirState51 | MenhirState22 | MenhirState29 | MenhirState38 | MenhirState34 | MenhirState13 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, (_1 : (string))) = _menhir_stack in\n let _v : (string) = \n# 202 \"graphql_parser/src/parser.mly\"\n ( _1 )\n# 2231 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_name _menhir_env _menhir_stack _menhir_s _v\n | MenhirState12 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | AT ->\n _menhir_run20 _menhir_env (Obj.magic _menhir_stack) MenhirState59\n | BOOL _ | ELLIPSIS | FRAGMENT | MUTATION | NAME _ | NULL | ON | QUERY | RBRACE | SUBSCRIPTION ->\n _menhir_reduce32 _menhir_env (Obj.magic _menhir_stack) MenhirState59\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState59)\n | MenhirState78 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | ON ->\n _menhir_run13 _menhir_env (Obj.magic _menhir_stack) MenhirState79\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState79)\n | _ ->\n _menhir_fail ()\n\nand _menhir_goto_optype : _menhir_env -> 'ttv_tail -> _menhir_state -> (Ast.optype) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_stack = (_menhir_stack, _menhir_s, _v) in\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n match _tok with\n | BOOL _v ->\n _menhir_run14 _menhir_env (Obj.magic _menhir_stack) MenhirState84 _v\n | FRAGMENT ->\n _menhir_run11 _menhir_env (Obj.magic _menhir_stack) MenhirState84\n | MUTATION ->\n _menhir_run10 _menhir_env (Obj.magic _menhir_stack) MenhirState84\n | NAME _v ->\n _menhir_run9 _menhir_env (Obj.magic _menhir_stack) MenhirState84 _v\n | NULL ->\n _menhir_run8 _menhir_env (Obj.magic _menhir_stack) MenhirState84\n | ON ->\n _menhir_run7 _menhir_env (Obj.magic _menhir_stack) MenhirState84\n | QUERY ->\n _menhir_run6 _menhir_env (Obj.magic _menhir_stack) MenhirState84\n | SUBSCRIPTION ->\n _menhir_run5 _menhir_env (Obj.magic _menhir_stack) MenhirState84\n | AT | LBRACE | LPAREN ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_s = MenhirState84 in\n let _v : (string option) = \n# 114 \"\"\n ( None )\n# 2290 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_option_name_ _menhir_env _menhir_stack _menhir_s _v\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState84\n\nand _menhir_run7 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let _v : (string) = \n# 203 \"graphql_parser/src/parser.mly\"\n ( \"on\" )\n# 2305 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_name _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_run12 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _menhir_stack = (_menhir_stack, _menhir_s) in\n let _menhir_env = _menhir_discard _menhir_env in\n let _tok = _menhir_env._menhir_token in\n match _tok with\n | BOOL _v ->\n _menhir_run14 _menhir_env (Obj.magic _menhir_stack) MenhirState12 _v\n | FRAGMENT ->\n _menhir_run11 _menhir_env (Obj.magic _menhir_stack) MenhirState12\n | MUTATION ->\n _menhir_run10 _menhir_env (Obj.magic _menhir_stack) MenhirState12\n | NAME _v ->\n _menhir_run9 _menhir_env (Obj.magic _menhir_stack) MenhirState12 _v\n | NULL ->\n _menhir_run8 _menhir_env (Obj.magic _menhir_stack) MenhirState12\n | ON ->\n _menhir_run13 _menhir_env (Obj.magic _menhir_stack) MenhirState12\n | QUERY ->\n _menhir_run6 _menhir_env (Obj.magic _menhir_stack) MenhirState12\n | SUBSCRIPTION ->\n _menhir_run5 _menhir_env (Obj.magic _menhir_stack) MenhirState12\n | AT | LBRACE ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_s = MenhirState12 in\n let _v : (string option) = \n# 114 \"\"\n ( None )\n# 2337 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_option_type_condition_ _menhir_env _menhir_stack _menhir_s _v\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState12\n\nand _menhir_run5 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let _v : (string) = \n# 188 \"graphql_parser/src/parser.mly\"\n ( \"subscription\" )\n# 2352 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_keyword_name _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_run6 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let _v : (string) = \n# 186 \"graphql_parser/src/parser.mly\"\n ( \"query\" )\n# 2363 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_keyword_name _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_run8 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let _v : (string) = \n# 196 \"graphql_parser/src/parser.mly\"\n ( \"null\" )\n# 2374 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_fragment_name _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_run9 : _menhir_env -> 'ttv_tail -> _menhir_state -> (\n# 5 \"graphql_parser/src/parser.mly\"\n (string)\n# 2381 \"graphql_parser/src/parser.ml\"\n) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_1 : (\n# 5 \"graphql_parser/src/parser.mly\"\n (string)\n# 2389 \"graphql_parser/src/parser.ml\"\n )) = _v in\n let _v : (string) = \n# 199 \"graphql_parser/src/parser.mly\"\n ( _1 )\n# 2394 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_fragment_name _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_run10 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let _v : (string) = \n# 187 \"graphql_parser/src/parser.mly\"\n ( \"mutation\" )\n# 2405 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_keyword_name _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_run11 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let _v : (string) = \n# 189 \"graphql_parser/src/parser.mly\"\n ( \"fragment\" )\n# 2416 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_keyword_name _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_run14 : _menhir_env -> 'ttv_tail -> _menhir_state -> (\n# 9 \"graphql_parser/src/parser.mly\"\n (bool)\n# 2423 \"graphql_parser/src/parser.ml\"\n) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_1 : (\n# 9 \"graphql_parser/src/parser.mly\"\n (bool)\n# 2431 \"graphql_parser/src/parser.ml\"\n )) = _v in\n let _v : (string) = \n# 197 \"graphql_parser/src/parser.mly\"\n ( string_of_bool _1 )\n# 2436 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_fragment_name _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_errorcase : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n match _menhir_s with\n | MenhirState133 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState125 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState124 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let ((_menhir_stack, _menhir_s, _), _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState119 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState114 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState108 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState102 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState100 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState99 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState96 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n raise _eRR\n | MenhirState90 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState89 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState87 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState86 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n raise _eRR\n | MenhirState84 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState81 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState80 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState79 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState78 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState71 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState70 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState67 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState66 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState65 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState64 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState63 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState61 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState59 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState57 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState55 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState51 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState44 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState38 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState34 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState31 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState29 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState28 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState24 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState22 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState21 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState20 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState19 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState13 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState12 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState4 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState0 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n raise _eRR\n\nand _menhir_run1 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let _v : (Ast.optype) = \n# 79 \"graphql_parser/src/parser.mly\"\n ( Subscription )\n# 2632 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_optype _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_run2 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let _v : (Ast.optype) = \n# 77 \"graphql_parser/src/parser.mly\"\n ( Query )\n# 2643 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_optype _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_run3 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let _v : (Ast.optype) = \n# 78 \"graphql_parser/src/parser.mly\"\n ( Mutation )\n# 2654 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_optype _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_run4 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _menhir_stack = (_menhir_stack, _menhir_s) in\n let _menhir_env = _menhir_discard _menhir_env in\n let _tok = _menhir_env._menhir_token in\n match _tok with\n | BOOL _v ->\n _menhir_run14 _menhir_env (Obj.magic _menhir_stack) MenhirState4 _v\n | ELLIPSIS ->\n _menhir_run12 _menhir_env (Obj.magic _menhir_stack) MenhirState4\n | FRAGMENT ->\n _menhir_run11 _menhir_env (Obj.magic _menhir_stack) MenhirState4\n | MUTATION ->\n _menhir_run10 _menhir_env (Obj.magic _menhir_stack) MenhirState4\n | NAME _v ->\n _menhir_run9 _menhir_env (Obj.magic _menhir_stack) MenhirState4 _v\n | NULL ->\n _menhir_run8 _menhir_env (Obj.magic _menhir_stack) MenhirState4\n | ON ->\n _menhir_run7 _menhir_env (Obj.magic _menhir_stack) MenhirState4\n | QUERY ->\n _menhir_run6 _menhir_env (Obj.magic _menhir_stack) MenhirState4\n | SUBSCRIPTION ->\n _menhir_run5 _menhir_env (Obj.magic _menhir_stack) MenhirState4\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState4\n\nand _menhir_run78 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _menhir_stack = (_menhir_stack, _menhir_s) in\n let _menhir_env = _menhir_discard _menhir_env in\n let _tok = _menhir_env._menhir_token in\n match _tok with\n | BOOL _v ->\n _menhir_run14 _menhir_env (Obj.magic _menhir_stack) MenhirState78 _v\n | FRAGMENT ->\n _menhir_run11 _menhir_env (Obj.magic _menhir_stack) MenhirState78\n | MUTATION ->\n _menhir_run10 _menhir_env (Obj.magic _menhir_stack) MenhirState78\n | NAME _v ->\n _menhir_run9 _menhir_env (Obj.magic _menhir_stack) MenhirState78 _v\n | NULL ->\n _menhir_run8 _menhir_env (Obj.magic _menhir_stack) MenhirState78\n | QUERY ->\n _menhir_run6 _menhir_env (Obj.magic _menhir_stack) MenhirState78\n | SUBSCRIPTION ->\n _menhir_run5 _menhir_env (Obj.magic _menhir_stack) MenhirState78\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState78\n\nand _menhir_discard : _menhir_env -> _menhir_env =\n fun _menhir_env ->\n let lexer = _menhir_env._menhir_lexer in\n let lexbuf = _menhir_env._menhir_lexbuf in\n let _tok = lexer lexbuf in\n {\n _menhir_lexer = lexer;\n _menhir_lexbuf = lexbuf;\n _menhir_token = _tok;\n _menhir_error = false;\n }\n\nand doc : (Lexing.lexbuf -> token) -> Lexing.lexbuf -> (Ast.document) =\n fun lexer lexbuf ->\n let _menhir_env = {\n _menhir_lexer = lexer;\n _menhir_lexbuf = lexbuf;\n _menhir_token = Obj.magic ();\n _menhir_error = false;\n } in\n Obj.magic (let _menhir_stack = ((), _menhir_env._menhir_lexbuf.Lexing.lex_curr_p) in\n let _menhir_env = _menhir_discard _menhir_env in\n let _tok = _menhir_env._menhir_token in\n match _tok with\n | FRAGMENT ->\n _menhir_run78 _menhir_env (Obj.magic _menhir_stack) MenhirState0\n | LBRACE ->\n _menhir_run4 _menhir_env (Obj.magic _menhir_stack) MenhirState0\n | MUTATION ->\n _menhir_run3 _menhir_env (Obj.magic _menhir_stack) MenhirState0\n | QUERY ->\n _menhir_run2 _menhir_env (Obj.magic _menhir_stack) MenhirState0\n | SUBSCRIPTION ->\n _menhir_run1 _menhir_env (Obj.magic _menhir_stack) MenhirState0\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState0)\n\n# 269 \"\"\n \n\n# 2754 \"graphql_parser/src/parser.ml\"\n","# 1 \"graphql_parser/src/lexer.mll\"\n \nopen Lexing\nopen Parser\n\nexception Error of string\n\n# 9 \"graphql_parser/src/lexer.ml\"\nlet __ocaml_lex_tables = {\n Lexing.lex_base =\n \"\\000\\000\\227\\255\\228\\255\\229\\255\\230\\255\\231\\255\\232\\255\\233\\255\\\n \\234\\255\\235\\255\\001\\000\\237\\255\\238\\255\\239\\255\\240\\255\\078\\000\\\n \\160\\000\\235\\000\\054\\001\\129\\001\\204\\001\\023\\002\\098\\002\\250\\255\\\n \\175\\002\\176\\002\\185\\002\\253\\255\\001\\000\\191\\000\\234\\002\\203\\002\\\n \\231\\002\\241\\002\\007\\003\\017\\003\\027\\003\\039\\003\\049\\003\\059\\003\\\n \\134\\003\\209\\003\\028\\004\\103\\004\\178\\004\\253\\004\\072\\005\\147\\005\\\n \\222\\005\\041\\006\\116\\006\\191\\006\\010\\007\\085\\007\\160\\007\\235\\007\\\n \\054\\008\\129\\008\\204\\008\\023\\009\\098\\009\\173\\009\\248\\009\\067\\010\\\n \\142\\010\\217\\010\\036\\011\\111\\011\\186\\011\\005\\012\\080\\012\\155\\012\\\n \\230\\012\\049\\013\\124\\013\\199\\013\\018\\014\\093\\014\\168\\014\\013\\000\\\n \\236\\255\\025\\015\\026\\015\\006\\015\\255\\255\\247\\255\\248\\255\\249\\255\\\n \\250\\255\\251\\255\\252\\255\\253\\255\\254\\255\";\n Lexing.lex_backtrk =\n \"\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\027\\000\\255\\255\\255\\255\\255\\255\\255\\255\\014\\000\\\n \\014\\000\\014\\000\\014\\000\\014\\000\\014\\000\\014\\000\\014\\000\\255\\255\\\n \\003\\000\\003\\000\\027\\000\\255\\255\\002\\000\\001\\000\\000\\000\\255\\255\\\n \\255\\255\\004\\000\\255\\255\\004\\000\\255\\255\\004\\000\\255\\255\\014\\000\\\n \\014\\000\\014\\000\\014\\000\\006\\000\\014\\000\\014\\000\\014\\000\\014\\000\\\n \\014\\000\\007\\000\\014\\000\\014\\000\\014\\000\\014\\000\\014\\000\\014\\000\\\n \\008\\000\\014\\000\\014\\000\\009\\000\\010\\000\\014\\000\\014\\000\\014\\000\\\n \\011\\000\\014\\000\\014\\000\\014\\000\\014\\000\\014\\000\\014\\000\\014\\000\\\n \\014\\000\\014\\000\\014\\000\\012\\000\\014\\000\\014\\000\\013\\000\\255\\255\\\n \\255\\255\\255\\255\\009\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\";\n Lexing.lex_default =\n \"\\002\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\255\\255\\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\\n \\255\\255\\255\\255\\255\\255\\000\\000\\255\\255\\029\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\000\\000\\082\\000\\082\\000\\255\\255\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\";\n Lexing.lex_trans =\n \"\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\030\\000\\027\\000\\027\\000\\000\\000\\028\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\030\\000\\014\\000\\023\\000\\029\\000\\013\\000\\000\\000\\000\\000\\000\\000\\\n \\012\\000\\011\\000\\000\\000\\000\\000\\030\\000\\026\\000\\010\\000\\079\\000\\\n \\025\\000\\024\\000\\024\\000\\024\\000\\024\\000\\024\\000\\024\\000\\024\\000\\\n \\024\\000\\024\\000\\009\\000\\080\\000\\000\\000\\008\\000\\000\\000\\000\\000\\\n \\007\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\006\\000\\000\\000\\005\\000\\000\\000\\015\\000\\\n \\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\022\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\021\\000\\020\\000\\019\\000\\\n \\015\\000\\018\\000\\015\\000\\017\\000\\016\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\004\\000\\000\\000\\003\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\000\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\255\\255\\000\\000\\000\\000\\255\\255\\000\\000\\000\\000\\000\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\\n \\001\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\076\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\015\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\065\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\000\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\061\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\\n \\000\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\015\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\060\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\015\\000\\000\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\057\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\000\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\050\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\015\\000\\000\\000\\040\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\039\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\032\\000\\032\\000\\024\\000\\\n \\024\\000\\024\\000\\024\\000\\024\\000\\024\\000\\024\\000\\024\\000\\024\\000\\\n \\024\\000\\025\\000\\024\\000\\024\\000\\024\\000\\024\\000\\024\\000\\024\\000\\\n \\024\\000\\024\\000\\024\\000\\030\\000\\031\\000\\031\\000\\038\\000\\000\\000\\\n \\038\\000\\000\\000\\000\\000\\037\\000\\037\\000\\037\\000\\037\\000\\037\\000\\\n \\037\\000\\037\\000\\037\\000\\037\\000\\037\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\030\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\031\\000\\031\\000\\030\\000\\033\\000\\\n \\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\\n \\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\\n \\033\\000\\033\\000\\033\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\036\\000\\000\\000\\036\\000\\000\\000\\034\\000\\035\\000\\\n \\035\\000\\035\\000\\035\\000\\035\\000\\035\\000\\035\\000\\035\\000\\035\\000\\\n \\035\\000\\035\\000\\035\\000\\035\\000\\035\\000\\035\\000\\035\\000\\035\\000\\\n \\035\\000\\035\\000\\035\\000\\035\\000\\035\\000\\035\\000\\035\\000\\035\\000\\\n \\035\\000\\035\\000\\035\\000\\035\\000\\035\\000\\000\\000\\034\\000\\037\\000\\\n \\037\\000\\037\\000\\037\\000\\037\\000\\037\\000\\037\\000\\037\\000\\037\\000\\\n \\037\\000\\037\\000\\037\\000\\037\\000\\037\\000\\037\\000\\037\\000\\037\\000\\\n \\037\\000\\037\\000\\037\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\015\\000\\000\\000\\044\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\000\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\041\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\015\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\042\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\015\\000\\000\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\043\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\000\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\015\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\045\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\000\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\046\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\\n \\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\047\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\015\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\048\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\000\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\049\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\015\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\015\\000\\000\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\051\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\000\\000\\\n \\052\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\015\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\053\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\000\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\054\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\\n \\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\055\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\015\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\056\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\000\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\015\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\058\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\015\\000\\000\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\059\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\000\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\015\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\000\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\062\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\\n \\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\063\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\015\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\064\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\000\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\015\\000\\000\\000\\015\\000\\066\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\015\\000\\000\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\067\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\000\\000\\\n \\015\\000\\015\\000\\068\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\015\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\069\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\000\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\070\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\\n \\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\071\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\015\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\072\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\000\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\073\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\015\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\074\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\015\\000\\000\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\075\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\000\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\015\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\077\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\000\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\078\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\\n \\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\\n \\092\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\090\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\084\\000\\255\\255\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\091\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\089\\000\\000\\000\\000\\000\\000\\000\\088\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\087\\000\\083\\000\\255\\255\\000\\000\\\n \\086\\000\\000\\000\\085\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\255\\255\\255\\255\";\n Lexing.lex_check =\n \"\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\000\\000\\000\\000\\028\\000\\255\\255\\000\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\255\\255\\255\\255\\\n \\000\\000\\000\\000\\255\\255\\255\\255\\000\\000\\000\\000\\000\\000\\010\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\079\\000\\255\\255\\000\\000\\255\\255\\255\\255\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\000\\000\\255\\255\\000\\000\\\n \\255\\255\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\000\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\255\\255\\255\\255\\255\\255\\255\\255\\015\\000\\255\\255\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\029\\000\\255\\255\\255\\255\\029\\000\\255\\255\\255\\255\\255\\255\\\n \\016\\000\\016\\000\\016\\000\\016\\000\\016\\000\\016\\000\\016\\000\\016\\000\\\n \\016\\000\\016\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\016\\000\\016\\000\\016\\000\\016\\000\\016\\000\\016\\000\\016\\000\\\n \\016\\000\\016\\000\\016\\000\\016\\000\\016\\000\\016\\000\\016\\000\\016\\000\\\n \\016\\000\\016\\000\\016\\000\\016\\000\\016\\000\\016\\000\\016\\000\\016\\000\\\n \\016\\000\\016\\000\\016\\000\\255\\255\\255\\255\\255\\255\\255\\255\\016\\000\\\n \\000\\000\\016\\000\\016\\000\\016\\000\\016\\000\\016\\000\\016\\000\\016\\000\\\n \\016\\000\\016\\000\\016\\000\\016\\000\\016\\000\\016\\000\\016\\000\\016\\000\\\n \\016\\000\\016\\000\\016\\000\\016\\000\\016\\000\\016\\000\\016\\000\\016\\000\\\n \\016\\000\\016\\000\\016\\000\\017\\000\\017\\000\\017\\000\\017\\000\\017\\000\\\n \\017\\000\\017\\000\\017\\000\\017\\000\\017\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\017\\000\\017\\000\\017\\000\\017\\000\\\n \\017\\000\\017\\000\\017\\000\\017\\000\\017\\000\\017\\000\\017\\000\\017\\000\\\n \\017\\000\\017\\000\\017\\000\\017\\000\\017\\000\\017\\000\\017\\000\\017\\000\\\n \\017\\000\\017\\000\\017\\000\\017\\000\\017\\000\\017\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\017\\000\\255\\255\\017\\000\\017\\000\\017\\000\\017\\000\\\n \\017\\000\\017\\000\\017\\000\\017\\000\\017\\000\\017\\000\\017\\000\\017\\000\\\n \\017\\000\\017\\000\\017\\000\\017\\000\\017\\000\\017\\000\\017\\000\\017\\000\\\n \\017\\000\\017\\000\\017\\000\\017\\000\\017\\000\\017\\000\\018\\000\\018\\000\\\n \\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\018\\000\\\n \\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\\n \\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\\n \\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\\n \\018\\000\\255\\255\\255\\255\\255\\255\\255\\255\\018\\000\\255\\255\\018\\000\\\n \\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\\n \\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\\n \\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\\n \\018\\000\\019\\000\\019\\000\\019\\000\\019\\000\\019\\000\\019\\000\\019\\000\\\n \\019\\000\\019\\000\\019\\000\\255\\255\\255\\255\\255\\255\\255\\255\\029\\000\\\n \\255\\255\\255\\255\\019\\000\\019\\000\\019\\000\\019\\000\\019\\000\\019\\000\\\n \\019\\000\\019\\000\\019\\000\\019\\000\\019\\000\\019\\000\\019\\000\\019\\000\\\n \\019\\000\\019\\000\\019\\000\\019\\000\\019\\000\\019\\000\\019\\000\\019\\000\\\n \\019\\000\\019\\000\\019\\000\\019\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\019\\000\\255\\255\\019\\000\\019\\000\\019\\000\\019\\000\\019\\000\\019\\000\\\n \\019\\000\\019\\000\\019\\000\\019\\000\\019\\000\\019\\000\\019\\000\\019\\000\\\n \\019\\000\\019\\000\\019\\000\\019\\000\\019\\000\\019\\000\\019\\000\\019\\000\\\n \\019\\000\\019\\000\\019\\000\\019\\000\\020\\000\\020\\000\\020\\000\\020\\000\\\n \\020\\000\\020\\000\\020\\000\\020\\000\\020\\000\\020\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\020\\000\\020\\000\\020\\000\\\n \\020\\000\\020\\000\\020\\000\\020\\000\\020\\000\\020\\000\\020\\000\\020\\000\\\n \\020\\000\\020\\000\\020\\000\\020\\000\\020\\000\\020\\000\\020\\000\\020\\000\\\n \\020\\000\\020\\000\\020\\000\\020\\000\\020\\000\\020\\000\\020\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\020\\000\\255\\255\\020\\000\\020\\000\\020\\000\\\n \\020\\000\\020\\000\\020\\000\\020\\000\\020\\000\\020\\000\\020\\000\\020\\000\\\n \\020\\000\\020\\000\\020\\000\\020\\000\\020\\000\\020\\000\\020\\000\\020\\000\\\n \\020\\000\\020\\000\\020\\000\\020\\000\\020\\000\\020\\000\\020\\000\\021\\000\\\n \\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\\n \\021\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\\n \\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\\n \\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\\n \\021\\000\\021\\000\\255\\255\\255\\255\\255\\255\\255\\255\\021\\000\\255\\255\\\n \\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\\n \\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\\n \\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\\n \\021\\000\\021\\000\\022\\000\\022\\000\\022\\000\\022\\000\\022\\000\\022\\000\\\n \\022\\000\\022\\000\\022\\000\\022\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\022\\000\\022\\000\\022\\000\\022\\000\\022\\000\\\n \\022\\000\\022\\000\\022\\000\\022\\000\\022\\000\\022\\000\\022\\000\\022\\000\\\n \\022\\000\\022\\000\\022\\000\\022\\000\\022\\000\\022\\000\\022\\000\\022\\000\\\n \\022\\000\\022\\000\\022\\000\\022\\000\\022\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\022\\000\\255\\255\\022\\000\\022\\000\\022\\000\\022\\000\\022\\000\\\n \\022\\000\\022\\000\\022\\000\\022\\000\\022\\000\\022\\000\\022\\000\\022\\000\\\n \\022\\000\\022\\000\\022\\000\\022\\000\\022\\000\\022\\000\\022\\000\\022\\000\\\n \\022\\000\\022\\000\\022\\000\\022\\000\\022\\000\\024\\000\\025\\000\\024\\000\\\n \\024\\000\\024\\000\\024\\000\\024\\000\\024\\000\\024\\000\\024\\000\\024\\000\\\n \\024\\000\\026\\000\\026\\000\\026\\000\\026\\000\\026\\000\\026\\000\\026\\000\\\n \\026\\000\\026\\000\\026\\000\\030\\000\\024\\000\\025\\000\\031\\000\\255\\255\\\n \\031\\000\\255\\255\\255\\255\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\\n \\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\030\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\024\\000\\025\\000\\030\\000\\032\\000\\\n \\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\\n \\032\\000\\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\\n \\033\\000\\033\\000\\033\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\034\\000\\255\\255\\034\\000\\255\\255\\033\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\035\\000\\035\\000\\035\\000\\035\\000\\035\\000\\035\\000\\035\\000\\\n \\035\\000\\035\\000\\035\\000\\036\\000\\036\\000\\036\\000\\036\\000\\036\\000\\\n \\036\\000\\036\\000\\036\\000\\036\\000\\036\\000\\255\\255\\033\\000\\037\\000\\\n \\037\\000\\037\\000\\037\\000\\037\\000\\037\\000\\037\\000\\037\\000\\037\\000\\\n \\037\\000\\038\\000\\038\\000\\038\\000\\038\\000\\038\\000\\038\\000\\038\\000\\\n \\038\\000\\038\\000\\038\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\\n \\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\039\\000\\039\\000\\039\\000\\039\\000\\\n \\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\\n \\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\\n \\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\039\\000\\255\\255\\039\\000\\039\\000\\039\\000\\039\\000\\\n \\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\\n \\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\\n \\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\040\\000\\040\\000\\\n \\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\040\\000\\\n \\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\\n \\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\\n \\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\\n \\040\\000\\255\\255\\255\\255\\255\\255\\255\\255\\040\\000\\255\\255\\040\\000\\\n \\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\\n \\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\\n \\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\\n \\040\\000\\041\\000\\041\\000\\041\\000\\041\\000\\041\\000\\041\\000\\041\\000\\\n \\041\\000\\041\\000\\041\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\041\\000\\041\\000\\041\\000\\041\\000\\041\\000\\041\\000\\\n \\041\\000\\041\\000\\041\\000\\041\\000\\041\\000\\041\\000\\041\\000\\041\\000\\\n \\041\\000\\041\\000\\041\\000\\041\\000\\041\\000\\041\\000\\041\\000\\041\\000\\\n \\041\\000\\041\\000\\041\\000\\041\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\041\\000\\255\\255\\041\\000\\041\\000\\041\\000\\041\\000\\041\\000\\041\\000\\\n \\041\\000\\041\\000\\041\\000\\041\\000\\041\\000\\041\\000\\041\\000\\041\\000\\\n \\041\\000\\041\\000\\041\\000\\041\\000\\041\\000\\041\\000\\041\\000\\041\\000\\\n \\041\\000\\041\\000\\041\\000\\041\\000\\042\\000\\042\\000\\042\\000\\042\\000\\\n \\042\\000\\042\\000\\042\\000\\042\\000\\042\\000\\042\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\042\\000\\042\\000\\042\\000\\\n \\042\\000\\042\\000\\042\\000\\042\\000\\042\\000\\042\\000\\042\\000\\042\\000\\\n \\042\\000\\042\\000\\042\\000\\042\\000\\042\\000\\042\\000\\042\\000\\042\\000\\\n \\042\\000\\042\\000\\042\\000\\042\\000\\042\\000\\042\\000\\042\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\042\\000\\255\\255\\042\\000\\042\\000\\042\\000\\\n \\042\\000\\042\\000\\042\\000\\042\\000\\042\\000\\042\\000\\042\\000\\042\\000\\\n \\042\\000\\042\\000\\042\\000\\042\\000\\042\\000\\042\\000\\042\\000\\042\\000\\\n \\042\\000\\042\\000\\042\\000\\042\\000\\042\\000\\042\\000\\042\\000\\043\\000\\\n \\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\\n \\043\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\\n \\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\\n \\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\\n \\043\\000\\043\\000\\255\\255\\255\\255\\255\\255\\255\\255\\043\\000\\255\\255\\\n \\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\\n \\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\\n \\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\\n \\043\\000\\043\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\\n \\044\\000\\044\\000\\044\\000\\044\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\\n \\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\\n \\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\\n \\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\044\\000\\255\\255\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\\n \\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\\n \\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\\n \\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\045\\000\\045\\000\\045\\000\\\n \\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\045\\000\\045\\000\\\n \\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\\n \\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\\n \\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\045\\000\\255\\255\\045\\000\\045\\000\\\n \\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\\n \\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\\n \\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\\n \\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\\n \\046\\000\\046\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\\n \\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\\n \\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\\n \\046\\000\\046\\000\\046\\000\\255\\255\\255\\255\\255\\255\\255\\255\\046\\000\\\n \\255\\255\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\\n \\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\\n \\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\\n \\046\\000\\046\\000\\046\\000\\047\\000\\047\\000\\047\\000\\047\\000\\047\\000\\\n \\047\\000\\047\\000\\047\\000\\047\\000\\047\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\047\\000\\047\\000\\047\\000\\047\\000\\\n \\047\\000\\047\\000\\047\\000\\047\\000\\047\\000\\047\\000\\047\\000\\047\\000\\\n \\047\\000\\047\\000\\047\\000\\047\\000\\047\\000\\047\\000\\047\\000\\047\\000\\\n \\047\\000\\047\\000\\047\\000\\047\\000\\047\\000\\047\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\047\\000\\255\\255\\047\\000\\047\\000\\047\\000\\047\\000\\\n \\047\\000\\047\\000\\047\\000\\047\\000\\047\\000\\047\\000\\047\\000\\047\\000\\\n \\047\\000\\047\\000\\047\\000\\047\\000\\047\\000\\047\\000\\047\\000\\047\\000\\\n \\047\\000\\047\\000\\047\\000\\047\\000\\047\\000\\047\\000\\048\\000\\048\\000\\\n \\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\048\\000\\\n \\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\\n \\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\\n \\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\\n \\048\\000\\255\\255\\255\\255\\255\\255\\255\\255\\048\\000\\255\\255\\048\\000\\\n \\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\\n \\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\\n \\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\\n \\048\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\\n \\049\\000\\049\\000\\049\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\\n \\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\\n \\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\\n \\049\\000\\049\\000\\049\\000\\049\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\049\\000\\255\\255\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\\n \\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\\n \\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\\n \\049\\000\\049\\000\\049\\000\\049\\000\\050\\000\\050\\000\\050\\000\\050\\000\\\n \\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\050\\000\\050\\000\\050\\000\\\n \\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\\n \\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\\n \\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\050\\000\\255\\255\\050\\000\\050\\000\\050\\000\\\n \\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\\n \\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\\n \\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\051\\000\\\n \\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\\n \\051\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\\n \\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\\n \\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\\n \\051\\000\\051\\000\\255\\255\\255\\255\\255\\255\\255\\255\\051\\000\\255\\255\\\n \\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\\n \\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\\n \\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\\n \\051\\000\\051\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\\n \\052\\000\\052\\000\\052\\000\\052\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\\n \\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\\n \\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\\n \\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\052\\000\\255\\255\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\\n \\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\\n \\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\\n \\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\053\\000\\053\\000\\053\\000\\\n \\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\053\\000\\053\\000\\\n \\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\\n \\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\\n \\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\053\\000\\255\\255\\053\\000\\053\\000\\\n \\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\\n \\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\\n \\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\\n \\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\\n \\054\\000\\054\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\\n \\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\\n \\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\\n \\054\\000\\054\\000\\054\\000\\255\\255\\255\\255\\255\\255\\255\\255\\054\\000\\\n \\255\\255\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\\n \\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\\n \\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\\n \\054\\000\\054\\000\\054\\000\\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\\n \\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\055\\000\\055\\000\\055\\000\\055\\000\\\n \\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\\n \\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\\n \\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\055\\000\\255\\255\\055\\000\\055\\000\\055\\000\\055\\000\\\n \\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\\n \\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\\n \\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\056\\000\\056\\000\\\n \\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\056\\000\\\n \\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\\n \\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\\n \\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\\n \\056\\000\\255\\255\\255\\255\\255\\255\\255\\255\\056\\000\\255\\255\\056\\000\\\n \\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\\n \\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\\n \\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\\n \\056\\000\\057\\000\\057\\000\\057\\000\\057\\000\\057\\000\\057\\000\\057\\000\\\n \\057\\000\\057\\000\\057\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\057\\000\\057\\000\\057\\000\\057\\000\\057\\000\\057\\000\\\n \\057\\000\\057\\000\\057\\000\\057\\000\\057\\000\\057\\000\\057\\000\\057\\000\\\n \\057\\000\\057\\000\\057\\000\\057\\000\\057\\000\\057\\000\\057\\000\\057\\000\\\n \\057\\000\\057\\000\\057\\000\\057\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\057\\000\\255\\255\\057\\000\\057\\000\\057\\000\\057\\000\\057\\000\\057\\000\\\n \\057\\000\\057\\000\\057\\000\\057\\000\\057\\000\\057\\000\\057\\000\\057\\000\\\n \\057\\000\\057\\000\\057\\000\\057\\000\\057\\000\\057\\000\\057\\000\\057\\000\\\n \\057\\000\\057\\000\\057\\000\\057\\000\\058\\000\\058\\000\\058\\000\\058\\000\\\n \\058\\000\\058\\000\\058\\000\\058\\000\\058\\000\\058\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\058\\000\\058\\000\\058\\000\\\n \\058\\000\\058\\000\\058\\000\\058\\000\\058\\000\\058\\000\\058\\000\\058\\000\\\n \\058\\000\\058\\000\\058\\000\\058\\000\\058\\000\\058\\000\\058\\000\\058\\000\\\n \\058\\000\\058\\000\\058\\000\\058\\000\\058\\000\\058\\000\\058\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\058\\000\\255\\255\\058\\000\\058\\000\\058\\000\\\n \\058\\000\\058\\000\\058\\000\\058\\000\\058\\000\\058\\000\\058\\000\\058\\000\\\n \\058\\000\\058\\000\\058\\000\\058\\000\\058\\000\\058\\000\\058\\000\\058\\000\\\n \\058\\000\\058\\000\\058\\000\\058\\000\\058\\000\\058\\000\\058\\000\\059\\000\\\n \\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\\n \\059\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\\n \\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\\n \\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\\n \\059\\000\\059\\000\\255\\255\\255\\255\\255\\255\\255\\255\\059\\000\\255\\255\\\n \\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\\n \\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\\n \\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\\n \\059\\000\\059\\000\\060\\000\\060\\000\\060\\000\\060\\000\\060\\000\\060\\000\\\n \\060\\000\\060\\000\\060\\000\\060\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\060\\000\\060\\000\\060\\000\\060\\000\\060\\000\\\n \\060\\000\\060\\000\\060\\000\\060\\000\\060\\000\\060\\000\\060\\000\\060\\000\\\n \\060\\000\\060\\000\\060\\000\\060\\000\\060\\000\\060\\000\\060\\000\\060\\000\\\n \\060\\000\\060\\000\\060\\000\\060\\000\\060\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\060\\000\\255\\255\\060\\000\\060\\000\\060\\000\\060\\000\\060\\000\\\n \\060\\000\\060\\000\\060\\000\\060\\000\\060\\000\\060\\000\\060\\000\\060\\000\\\n \\060\\000\\060\\000\\060\\000\\060\\000\\060\\000\\060\\000\\060\\000\\060\\000\\\n \\060\\000\\060\\000\\060\\000\\060\\000\\060\\000\\061\\000\\061\\000\\061\\000\\\n \\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\061\\000\\061\\000\\\n \\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\\n \\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\\n \\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\061\\000\\255\\255\\061\\000\\061\\000\\\n \\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\\n \\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\\n \\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\\n \\062\\000\\062\\000\\062\\000\\062\\000\\062\\000\\062\\000\\062\\000\\062\\000\\\n \\062\\000\\062\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\062\\000\\062\\000\\062\\000\\062\\000\\062\\000\\062\\000\\062\\000\\\n \\062\\000\\062\\000\\062\\000\\062\\000\\062\\000\\062\\000\\062\\000\\062\\000\\\n \\062\\000\\062\\000\\062\\000\\062\\000\\062\\000\\062\\000\\062\\000\\062\\000\\\n \\062\\000\\062\\000\\062\\000\\255\\255\\255\\255\\255\\255\\255\\255\\062\\000\\\n \\255\\255\\062\\000\\062\\000\\062\\000\\062\\000\\062\\000\\062\\000\\062\\000\\\n \\062\\000\\062\\000\\062\\000\\062\\000\\062\\000\\062\\000\\062\\000\\062\\000\\\n \\062\\000\\062\\000\\062\\000\\062\\000\\062\\000\\062\\000\\062\\000\\062\\000\\\n \\062\\000\\062\\000\\062\\000\\063\\000\\063\\000\\063\\000\\063\\000\\063\\000\\\n \\063\\000\\063\\000\\063\\000\\063\\000\\063\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\063\\000\\063\\000\\063\\000\\063\\000\\\n \\063\\000\\063\\000\\063\\000\\063\\000\\063\\000\\063\\000\\063\\000\\063\\000\\\n \\063\\000\\063\\000\\063\\000\\063\\000\\063\\000\\063\\000\\063\\000\\063\\000\\\n \\063\\000\\063\\000\\063\\000\\063\\000\\063\\000\\063\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\063\\000\\255\\255\\063\\000\\063\\000\\063\\000\\063\\000\\\n \\063\\000\\063\\000\\063\\000\\063\\000\\063\\000\\063\\000\\063\\000\\063\\000\\\n \\063\\000\\063\\000\\063\\000\\063\\000\\063\\000\\063\\000\\063\\000\\063\\000\\\n \\063\\000\\063\\000\\063\\000\\063\\000\\063\\000\\063\\000\\064\\000\\064\\000\\\n \\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\064\\000\\\n \\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\\n \\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\\n \\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\\n \\064\\000\\255\\255\\255\\255\\255\\255\\255\\255\\064\\000\\255\\255\\064\\000\\\n \\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\\n \\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\\n \\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\\n \\064\\000\\065\\000\\065\\000\\065\\000\\065\\000\\065\\000\\065\\000\\065\\000\\\n \\065\\000\\065\\000\\065\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\065\\000\\065\\000\\065\\000\\065\\000\\065\\000\\065\\000\\\n \\065\\000\\065\\000\\065\\000\\065\\000\\065\\000\\065\\000\\065\\000\\065\\000\\\n \\065\\000\\065\\000\\065\\000\\065\\000\\065\\000\\065\\000\\065\\000\\065\\000\\\n \\065\\000\\065\\000\\065\\000\\065\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\065\\000\\255\\255\\065\\000\\065\\000\\065\\000\\065\\000\\065\\000\\065\\000\\\n \\065\\000\\065\\000\\065\\000\\065\\000\\065\\000\\065\\000\\065\\000\\065\\000\\\n \\065\\000\\065\\000\\065\\000\\065\\000\\065\\000\\065\\000\\065\\000\\065\\000\\\n \\065\\000\\065\\000\\065\\000\\065\\000\\066\\000\\066\\000\\066\\000\\066\\000\\\n \\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\066\\000\\066\\000\\066\\000\\\n \\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\\n \\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\\n \\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\066\\000\\255\\255\\066\\000\\066\\000\\066\\000\\\n \\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\\n \\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\\n \\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\067\\000\\\n \\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\\n \\067\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\\n \\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\\n \\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\\n \\067\\000\\067\\000\\255\\255\\255\\255\\255\\255\\255\\255\\067\\000\\255\\255\\\n \\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\\n \\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\\n \\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\\n \\067\\000\\067\\000\\068\\000\\068\\000\\068\\000\\068\\000\\068\\000\\068\\000\\\n \\068\\000\\068\\000\\068\\000\\068\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\068\\000\\068\\000\\068\\000\\068\\000\\068\\000\\\n \\068\\000\\068\\000\\068\\000\\068\\000\\068\\000\\068\\000\\068\\000\\068\\000\\\n \\068\\000\\068\\000\\068\\000\\068\\000\\068\\000\\068\\000\\068\\000\\068\\000\\\n \\068\\000\\068\\000\\068\\000\\068\\000\\068\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\068\\000\\255\\255\\068\\000\\068\\000\\068\\000\\068\\000\\068\\000\\\n \\068\\000\\068\\000\\068\\000\\068\\000\\068\\000\\068\\000\\068\\000\\068\\000\\\n \\068\\000\\068\\000\\068\\000\\068\\000\\068\\000\\068\\000\\068\\000\\068\\000\\\n \\068\\000\\068\\000\\068\\000\\068\\000\\068\\000\\069\\000\\069\\000\\069\\000\\\n \\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\069\\000\\069\\000\\\n \\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\\n \\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\\n \\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\069\\000\\255\\255\\069\\000\\069\\000\\\n \\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\\n \\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\\n \\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\\n \\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\\n \\070\\000\\070\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\\n \\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\\n \\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\\n \\070\\000\\070\\000\\070\\000\\255\\255\\255\\255\\255\\255\\255\\255\\070\\000\\\n \\255\\255\\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\\n \\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\\n \\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\\n \\070\\000\\070\\000\\070\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\\n \\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\071\\000\\071\\000\\071\\000\\071\\000\\\n \\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\\n \\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\\n \\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\071\\000\\255\\255\\071\\000\\071\\000\\071\\000\\071\\000\\\n \\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\\n \\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\\n \\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\072\\000\\072\\000\\\n \\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\072\\000\\\n \\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\\n \\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\\n \\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\\n \\072\\000\\255\\255\\255\\255\\255\\255\\255\\255\\072\\000\\255\\255\\072\\000\\\n \\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\\n \\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\\n \\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\\n \\072\\000\\073\\000\\073\\000\\073\\000\\073\\000\\073\\000\\073\\000\\073\\000\\\n \\073\\000\\073\\000\\073\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\073\\000\\073\\000\\073\\000\\073\\000\\073\\000\\073\\000\\\n \\073\\000\\073\\000\\073\\000\\073\\000\\073\\000\\073\\000\\073\\000\\073\\000\\\n \\073\\000\\073\\000\\073\\000\\073\\000\\073\\000\\073\\000\\073\\000\\073\\000\\\n \\073\\000\\073\\000\\073\\000\\073\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\073\\000\\255\\255\\073\\000\\073\\000\\073\\000\\073\\000\\073\\000\\073\\000\\\n \\073\\000\\073\\000\\073\\000\\073\\000\\073\\000\\073\\000\\073\\000\\073\\000\\\n \\073\\000\\073\\000\\073\\000\\073\\000\\073\\000\\073\\000\\073\\000\\073\\000\\\n \\073\\000\\073\\000\\073\\000\\073\\000\\074\\000\\074\\000\\074\\000\\074\\000\\\n \\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\074\\000\\074\\000\\074\\000\\\n \\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\\n \\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\\n \\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\074\\000\\255\\255\\074\\000\\074\\000\\074\\000\\\n \\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\\n \\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\\n \\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\075\\000\\\n \\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\\n \\075\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\\n \\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\\n \\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\\n \\075\\000\\075\\000\\255\\255\\255\\255\\255\\255\\255\\255\\075\\000\\255\\255\\\n \\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\\n \\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\\n \\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\\n \\075\\000\\075\\000\\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\\n \\076\\000\\076\\000\\076\\000\\076\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\\n \\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\\n \\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\\n \\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\076\\000\\255\\255\\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\\n \\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\\n \\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\\n \\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\077\\000\\077\\000\\077\\000\\\n \\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\077\\000\\077\\000\\\n \\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\\n \\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\\n \\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\077\\000\\255\\255\\077\\000\\077\\000\\\n \\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\\n \\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\\n \\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\\n \\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\\n \\078\\000\\078\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\\n \\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\\n \\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\\n \\078\\000\\078\\000\\078\\000\\255\\255\\255\\255\\255\\255\\255\\255\\078\\000\\\n \\255\\255\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\\n \\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\\n \\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\\n \\078\\000\\078\\000\\078\\000\\081\\000\\082\\000\\255\\255\\081\\000\\082\\000\\\n \\083\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\083\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\081\\000\\082\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\083\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\083\\000\\255\\255\\255\\255\\255\\255\\083\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\083\\000\\081\\000\\082\\000\\255\\255\\\n \\083\\000\\255\\255\\083\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\081\\000\\082\\000\";\n Lexing.lex_base_code =\n \"\";\n Lexing.lex_backtrk_code =\n \"\";\n Lexing.lex_default_code =\n \"\";\n Lexing.lex_trans_code =\n \"\";\n Lexing.lex_check_code =\n \"\";\n Lexing.lex_code =\n \"\";\n}\n\nlet rec token lexbuf =\n __ocaml_lex_token_rec lexbuf 0\nand __ocaml_lex_token_rec lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 21 \"graphql_parser/src/lexer.mll\"\n ( token lexbuf )\n# 1105 \"graphql_parser/src/lexer.ml\"\n\n | 1 ->\n# 22 \"graphql_parser/src/lexer.mll\"\n ( token lexbuf )\n# 1110 \"graphql_parser/src/lexer.ml\"\n\n | 2 ->\n# 23 \"graphql_parser/src/lexer.mll\"\n ( new_line lexbuf; token lexbuf )\n# 1115 \"graphql_parser/src/lexer.ml\"\n\n | 3 ->\n# 25 \"graphql_parser/src/lexer.mll\"\n ( INT (int_of_string (lexeme lexbuf)) )\n# 1120 \"graphql_parser/src/lexer.ml\"\n\n | 4 ->\n# 26 \"graphql_parser/src/lexer.mll\"\n ( FLOAT (float_of_string (lexeme lexbuf)) )\n# 1125 \"graphql_parser/src/lexer.ml\"\n\n | 5 ->\n# 27 \"graphql_parser/src/lexer.mll\"\n ( read_string (Buffer.create 17) lexbuf )\n# 1130 \"graphql_parser/src/lexer.ml\"\n\n | 6 ->\n# 29 \"graphql_parser/src/lexer.mll\"\n ( BOOL false )\n# 1135 \"graphql_parser/src/lexer.ml\"\n\n | 7 ->\n# 30 \"graphql_parser/src/lexer.mll\"\n ( FRAGMENT )\n# 1140 \"graphql_parser/src/lexer.ml\"\n\n | 8 ->\n# 31 \"graphql_parser/src/lexer.mll\"\n ( MUTATION )\n# 1145 \"graphql_parser/src/lexer.ml\"\n\n | 9 ->\n# 32 \"graphql_parser/src/lexer.mll\"\n ( NULL )\n# 1150 \"graphql_parser/src/lexer.ml\"\n\n | 10 ->\n# 33 \"graphql_parser/src/lexer.mll\"\n ( ON )\n# 1155 \"graphql_parser/src/lexer.ml\"\n\n | 11 ->\n# 34 \"graphql_parser/src/lexer.mll\"\n ( QUERY )\n# 1160 \"graphql_parser/src/lexer.ml\"\n\n | 12 ->\n# 35 \"graphql_parser/src/lexer.mll\"\n ( SUBSCRIPTION )\n# 1165 \"graphql_parser/src/lexer.ml\"\n\n | 13 ->\n# 36 \"graphql_parser/src/lexer.mll\"\n ( BOOL true )\n# 1170 \"graphql_parser/src/lexer.ml\"\n\n | 14 ->\n# 37 \"graphql_parser/src/lexer.mll\"\n ( NAME (lexeme lexbuf) )\n# 1175 \"graphql_parser/src/lexer.ml\"\n\n | 15 ->\n# 39 \"graphql_parser/src/lexer.mll\"\n ( BANG )\n# 1180 \"graphql_parser/src/lexer.ml\"\n\n | 16 ->\n# 40 \"graphql_parser/src/lexer.mll\"\n ( DOLLAR )\n# 1185 \"graphql_parser/src/lexer.ml\"\n\n | 17 ->\n# 41 \"graphql_parser/src/lexer.mll\"\n ( LPAREN )\n# 1190 \"graphql_parser/src/lexer.ml\"\n\n | 18 ->\n# 42 \"graphql_parser/src/lexer.mll\"\n ( RPAREN )\n# 1195 \"graphql_parser/src/lexer.ml\"\n\n | 19 ->\n# 43 \"graphql_parser/src/lexer.mll\"\n ( ELLIPSIS )\n# 1200 \"graphql_parser/src/lexer.ml\"\n\n | 20 ->\n# 44 \"graphql_parser/src/lexer.mll\"\n ( COLON )\n# 1205 \"graphql_parser/src/lexer.ml\"\n\n | 21 ->\n# 45 \"graphql_parser/src/lexer.mll\"\n ( EQUAL )\n# 1210 \"graphql_parser/src/lexer.ml\"\n\n | 22 ->\n# 46 \"graphql_parser/src/lexer.mll\"\n ( AT )\n# 1215 \"graphql_parser/src/lexer.ml\"\n\n | 23 ->\n# 47 \"graphql_parser/src/lexer.mll\"\n ( LBRACK )\n# 1220 \"graphql_parser/src/lexer.ml\"\n\n | 24 ->\n# 48 \"graphql_parser/src/lexer.mll\"\n ( RBRACK )\n# 1225 \"graphql_parser/src/lexer.ml\"\n\n | 25 ->\n# 49 \"graphql_parser/src/lexer.mll\"\n ( LBRACE )\n# 1230 \"graphql_parser/src/lexer.ml\"\n\n | 26 ->\n# 50 \"graphql_parser/src/lexer.mll\"\n ( RBRACE )\n# 1235 \"graphql_parser/src/lexer.ml\"\n\n | 27 ->\n# 51 \"graphql_parser/src/lexer.mll\"\n ( raise (Error (\"Unexpected char: \" ^ Lexing.lexeme lexbuf)) )\n# 1240 \"graphql_parser/src/lexer.ml\"\n\n | 28 ->\n# 52 \"graphql_parser/src/lexer.mll\"\n ( EOF )\n# 1245 \"graphql_parser/src/lexer.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_token_rec lexbuf __ocaml_lex_state\n\nand read_string buf lexbuf =\n __ocaml_lex_read_string_rec buf lexbuf 81\nand __ocaml_lex_read_string_rec buf lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 55 \"graphql_parser/src/lexer.mll\"\n ( STRING (Buffer.contents buf) )\n# 1257 \"graphql_parser/src/lexer.ml\"\n\n | 1 ->\n# 56 \"graphql_parser/src/lexer.mll\"\n ( Buffer.add_char buf '\"'; read_string buf lexbuf )\n# 1262 \"graphql_parser/src/lexer.ml\"\n\n | 2 ->\n# 57 \"graphql_parser/src/lexer.mll\"\n ( Buffer.add_char buf '\\\\'; read_string buf lexbuf )\n# 1267 \"graphql_parser/src/lexer.ml\"\n\n | 3 ->\n# 58 \"graphql_parser/src/lexer.mll\"\n ( Buffer.add_char buf '/'; read_string buf lexbuf )\n# 1272 \"graphql_parser/src/lexer.ml\"\n\n | 4 ->\n# 59 \"graphql_parser/src/lexer.mll\"\n ( Buffer.add_char buf '\\b'; read_string buf lexbuf )\n# 1277 \"graphql_parser/src/lexer.ml\"\n\n | 5 ->\n# 60 \"graphql_parser/src/lexer.mll\"\n ( Buffer.add_char buf '\\012'; read_string buf lexbuf )\n# 1282 \"graphql_parser/src/lexer.ml\"\n\n | 6 ->\n# 61 \"graphql_parser/src/lexer.mll\"\n ( Buffer.add_char buf '\\n'; read_string buf lexbuf )\n# 1287 \"graphql_parser/src/lexer.ml\"\n\n | 7 ->\n# 62 \"graphql_parser/src/lexer.mll\"\n ( Buffer.add_char buf '\\r'; read_string buf lexbuf )\n# 1292 \"graphql_parser/src/lexer.ml\"\n\n | 8 ->\n# 63 \"graphql_parser/src/lexer.mll\"\n ( Buffer.add_char buf '\\t'; read_string buf lexbuf )\n# 1297 \"graphql_parser/src/lexer.ml\"\n\n | 9 ->\n# 65 \"graphql_parser/src/lexer.mll\"\n (\n Buffer.add_string buf (lexeme lexbuf);\n read_string buf lexbuf\n )\n# 1305 \"graphql_parser/src/lexer.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_string_rec buf lexbuf __ocaml_lex_state\n\n;;\n\n","(* Helper modules *)\nmodule List = struct\n include List\n let assoc_exn = assoc\n let assoc x ys = try Some (assoc_exn x ys) with Not_found -> None\n\n let find_exn = find\n let find cond xs = try Some (find_exn cond xs) with Not_found -> None\n\n module Result = struct\n let rec join ?(memo=[]) = function\n | [] -> Ok (List.rev memo)\n | (Error _ as err)::_ -> err\n | (Ok x)::xs -> join ~memo:(x::memo) xs\n\n let all f xs =\n List.map f xs |> join\n end\nend\n\nmodule Option = struct\n let map x ~f = match x with None -> None | Some y -> Some (f y)\nend\n\n(* IO *)\nmodule type IO = sig\n type +'a t\n\n val return : 'a -> 'a t\n val bind : 'a t -> ('a -> 'b t) -> 'b t\n\n module Stream : sig\n type +'a io\n type 'a t\n\n val map : 'a t -> ('a -> 'b io) -> 'b t\n val iter : 'a t -> ('a -> unit io) -> unit io\n val close : 'a t -> unit\n end with type 'a io := 'a t\nend\n\n(* Field_error *)\nmodule type Field_error = sig\n type t\n val message_of_field_error : t -> string\n val extensions_of_field_error : t -> (string * Yojson.Basic.json [@warning \"-3\"]) list option\nend\n\n(* Schema *)\nmodule Make (Io : IO) (Field_error: Field_error) = struct\n module Io = struct\n include Io\n\n let map x ~f = bind x (fun x' -> return (f x'))\n let ok x = Io.return (Ok x)\n let error x = Io.return (Error x)\n\n let rec all = function\n | [] -> Io.return []\n | x::xs ->\n bind (all xs) (fun xs' ->\n map x ~f:(fun x' -> x'::xs')\n )\n\n module Result = struct\n let bind x f = bind x (function Ok x' -> f x' | Error _ as err -> Io.return err)\n let map_error x ~f = map x ~f:(function Ok _ as ok -> ok | Error err -> Error (f err))\n let map x ~f = map x ~f:(function Ok x' -> Ok (f x') | Error _ as err -> err)\n end\n\n let rec map_s ?(memo=[]) f = function\n | [] -> Io.return (List.rev memo)\n | x::xs ->\n bind (f x) (fun x' -> map_s ~memo:(x'::memo) f xs)\n\n let map_p f xs = List.map f xs |> all\n\n module Infix = struct\n let (>>|) x f = map x ~f\n let (>>=?) = Result.bind\n end\n end\n\n module StringMap = struct\n include Map.Make(String)\n exception Missing_key of string\n let find_exn key t = try find key t with Not_found -> raise (Missing_key key)\n let find k t = try Some (find_exn k t) with Missing_key _ -> None\n end\n\n module StringSet = Set.Make(String)\n\n type field_error = Field_error.t\n\n type variable_map = Graphql_parser.const_value StringMap.t\n\n type deprecated =\n | NotDeprecated\n | Deprecated of string option\n\n type 'a enum_value = {\n name : string;\n doc : string option;\n deprecated : deprecated;\n value : 'a;\n }\n\n type json = Yojson.Basic.json [@warning \"-3\"]\n\n let enum_value ?doc ?(deprecated=NotDeprecated) name ~value =\n { name; doc; deprecated; value; }\n\n let id : 'a. 'a -> 'a = fun x -> x\n\n module Arg = struct\n open Rresult\n\n type _ arg_typ =\n | Scalar : {\n name : string;\n doc : string option;\n coerce : Graphql_parser.const_value -> ('a, string) result;\n } -> 'a option arg_typ\n | Object : {\n name : string;\n doc : string option;\n fields : ('a, 'b) arg_list;\n coerce : 'b;\n } -> 'a option arg_typ\n | Enum : {\n name : string;\n doc : string option;\n values : 'a enum_value list;\n } -> 'a option arg_typ\n | List : 'a arg_typ -> 'a list option arg_typ\n | NonNullable : 'a option arg_typ -> 'a arg_typ\n and _ arg =\n | Arg : {\n name : string;\n doc : string option;\n typ : 'a arg_typ;\n } -> 'a arg\n | DefaultArg : {\n name : string;\n doc : string option;\n typ : 'a option arg_typ;\n default : 'a;\n } -> 'a arg\n and (_, _) arg_list =\n | [] : ('a, 'a) arg_list\n | (::) : 'a arg * ('b, 'c) arg_list -> ('b, 'a -> 'c) arg_list\n\n let arg ?doc name ~typ =\n Arg { name; doc; typ }\n\n let arg' ?doc name ~typ ~default =\n DefaultArg { name; doc; typ; default }\n\n let scalar ?doc name ~coerce =\n Scalar { name; doc; coerce }\n\n let enum ?doc name ~values =\n Enum { name; doc; values }\n\n let obj ?doc name ~fields ~coerce =\n Object { name; doc; fields; coerce }\n\n let rec string_of_const_value : Graphql_parser.const_value -> string = function\n | `Null -> \"null\"\n | `Int i -> string_of_int i\n | `Float f -> string_of_float f\n | `String s -> Printf.sprintf \"\\\"%s\\\"\" s\n | `Bool b -> string_of_bool b\n | `Enum e -> e\n | `List l ->\n let values = List.map (fun i -> string_of_const_value i) l in\n Printf.sprintf \"[%s]\" (String.concat \", \" values)\n | `Assoc a ->\n let values =\n List.map\n (fun (k, v) ->\n Printf.sprintf \"%s: %s\" k (string_of_const_value v) )\n a\n in\n Printf.sprintf \"{%s}\" (String.concat \", \" values)\n\n let rec string_of_arg_typ : type a. a arg_typ -> string = function\n | Scalar a -> a.name\n | Object a -> a.name\n | Enum a -> a.name\n | List a -> Printf.sprintf \"[%s]\" (string_of_arg_typ a)\n | NonNullable a -> Printf.sprintf \"%s!\" (string_of_arg_typ a)\n\n let eval_arg_error ?(field_type=\"field\") ~field_name ~arg_name arg_typ value =\n let found_str =\n match value with\n | Some v -> Printf.sprintf \"found %s\" (string_of_const_value v)\n | None -> \"but not provided\"\n in\n Printf.sprintf \"Argument `%s` of type `%s` expected on %s `%s`, %s.\"\n arg_name\n (string_of_arg_typ arg_typ)\n field_type\n field_name\n found_str\n\n (* Built-in argument types *)\n let int = Scalar {\n name = \"Int\";\n doc = None;\n coerce = function\n | `Int n -> Ok n\n | _ -> Error \"Invalid int\"\n }\n\n let string = Scalar {\n name = \"String\";\n doc = None;\n coerce = function\n | `String s -> Ok s\n | _ -> Error \"Invalid string\"\n }\n\n let float = Scalar {\n name = \"Float\";\n doc = None;\n coerce = function\n | `Float f -> Ok f\n | `Int n -> Ok (float_of_int n)\n | _ -> Error \"Invalid float\"\n }\n\n let bool = Scalar {\n name = \"Boolean\";\n doc = None;\n coerce = function\n | `Bool b -> Ok b\n | _ -> Error \"Invalid boolean\"\n }\n\n let guid = Scalar {\n name = \"ID\";\n doc = None;\n coerce = function\n | `String s -> Ok s\n | `Int n -> Ok (string_of_int n)\n | _ -> Error \"Invalid ID\"\n }\n\n let non_null typ = NonNullable typ\n let list typ = List typ\n\n let rec value_to_const_value variable_map = function\n | `Null -> `Null\n | `Int _ as i -> i\n | `Float _ as f -> f\n | `String _ as s -> s\n | `Bool _ as b -> b\n | `Enum _ as e -> e\n | `Variable v -> StringMap.find_exn v variable_map\n | `List xs -> `List (List.map (value_to_const_value variable_map) xs)\n | `Assoc props ->\n let props' = List.map (fun (name, value) -> name, value_to_const_value variable_map value) props in\n `Assoc props'\n\n let rec eval_arglist\n : type a b. variable_map\n -> ?field_type:string\n -> field_name:string\n -> (a, b) arg_list\n -> (string * Graphql_parser.value) list\n -> b\n -> (a, string) result =\n fun variable_map ?field_type ~field_name arglist key_values f ->\n match arglist with\n | [] -> Ok f\n | (DefaultArg arg)::arglist' ->\n let arglist'' = (Arg { name = arg.name; doc = arg.doc; typ = arg.typ })::arglist' in\n eval_arglist variable_map ?field_type ~field_name arglist'' key_values (function\n | None -> f arg.default\n | Some value -> f value\n )\n | (Arg arg)::arglist' ->\n try\n let value = List.assoc arg.name key_values in\n let const_value = Option.map value ~f:(value_to_const_value variable_map) in\n eval_arg variable_map ?field_type ~field_name ~arg_name:arg.name arg.typ const_value >>= fun coerced ->\n eval_arglist variable_map ?field_type ~field_name arglist' key_values (f coerced)\n with StringMap.Missing_key key -> Error (Format.sprintf \"Missing variable `%s`\" key)\n\n and eval_arg\n : type a. variable_map\n -> ?field_type:string\n -> field_name:string\n -> arg_name:string\n -> a arg_typ\n -> Graphql_parser.const_value option\n -> (a, string) result =\n fun variable_map ?field_type ~field_name ~arg_name typ value ->\n match (typ, value) with\n | NonNullable _, None -> Error (eval_arg_error ?field_type ~field_name ~arg_name typ value)\n | NonNullable _, Some `Null -> Error (eval_arg_error ?field_type ~field_name ~arg_name typ value)\n | Scalar _, None -> Ok None\n | Scalar _, Some `Null -> Ok None\n | Object _, None -> Ok None\n | Object _, Some `Null -> Ok None\n | List _, None -> Ok None\n | List _, Some `Null -> Ok None\n | Enum _, None -> Ok None\n | Enum _, Some `Null -> Ok None\n | Scalar s, Some value ->\n begin match (s.coerce value) with\n | Ok coerced -> Ok (Some coerced)\n | Error _ -> Error (eval_arg_error ?field_type ~field_name ~arg_name typ (Some value))\n end\n | Object o, Some value ->\n begin match value with\n | `Assoc props ->\n let props' = (props :> (string * Graphql_parser.value) list) in\n eval_arglist variable_map ?field_type ~field_name o.fields props' o.coerce >>| fun coerced ->\n Some coerced\n | _ -> Error (eval_arg_error ?field_type ~field_name ~arg_name typ (Some value))\n end\n | List typ, Some value ->\n begin match value with\n | `List values ->\n let option_values = List.map (fun x -> Some x) values in\n List.Result.all (eval_arg variable_map ?field_type ~field_name ~arg_name typ) option_values >>| fun coerced ->\n Some coerced\n | value -> eval_arg variable_map ?field_type ~field_name ~arg_name typ (Some value) >>| fun coerced ->\n (Some [coerced] : a)\n end\n | NonNullable typ, value ->\n eval_arg variable_map ?field_type ~field_name ~arg_name typ value >>= (function\n | Some value -> Ok value\n | None -> Error (eval_arg_error ?field_type ~field_name ~arg_name typ None))\n | Enum e, Some value ->\n begin match value with\n | `Enum v\n | `String v ->\n begin match List.find (fun enum_value -> enum_value.name = v) e.values with\n | Some enum_value -> Ok (Some enum_value.value)\n | None -> Error (Printf.sprintf \"Invalid enum value for argument `%s` on field `%s`\" arg_name field_name)\n end\n | _ -> Error (Printf.sprintf \"Expected enum for argument `%s` on field `%s`\" arg_name field_name)\n end\n end\n\n (* Schema data types *)\n type 'a scalar = {\n name : string;\n doc : string option;\n coerce : 'a -> json;\n }\n\n type 'a enum = {\n name : string;\n doc : string option;\n values : 'a enum_value list;\n }\n\n type fragment_map = Graphql_parser.fragment StringMap.t\n type 'ctx resolve_info = {\n ctx : 'ctx;\n field : Graphql_parser.field;\n fragments : fragment_map;\n variables : variable_map;\n }\n\n type ('ctx, 'src) obj = {\n name : string;\n doc : string option;\n fields : ('ctx, 'src) field list Lazy.t;\n abstracts : abstract list ref;\n }\n and (_, _) field =\n Field : {\n name : string;\n doc : string option;\n deprecated : deprecated;\n typ : ('ctx, 'out) typ;\n args : ('a, 'args) Arg.arg_list;\n resolve : 'ctx resolve_info -> 'src -> 'args;\n lift : 'a -> ('out, field_error) result Io.t;\n } -> ('ctx, 'src) field\n and (_, _) typ =\n | Object : ('ctx, 'src) obj -> ('ctx, 'src option) typ\n | List : ('ctx, 'src) typ -> ('ctx, 'src list option) typ\n | NonNullable : ('ctx, 'src option) typ -> ('ctx, 'src) typ\n | Scalar : 'src scalar -> ('ctx, 'src option) typ\n | Enum : 'src enum -> ('ctx, 'src option) typ\n | Abstract : abstract -> ('ctx, ('ctx, 'a) abstract_value option) typ\n and any_typ =\n | AnyTyp : (_, _) typ -> any_typ\n | AnyArgTyp : _ Arg.arg_typ -> any_typ\n and abstract = {\n name : string;\n doc : string option;\n kind : [`Union | `Interface of abstract_field list Lazy.t];\n mutable types : any_typ list;\n }\n and abstract_field =\n AbstractField : (_, _) field -> abstract_field\n and ('ctx, 'a) abstract_value =\n AbstractValue : ('ctx, 'src option) typ * 'src -> ('ctx, 'a) abstract_value\n\n type 'ctx subscription_field =\n SubscriptionField : {\n name : string;\n doc : string option;\n deprecated : deprecated;\n typ : ('ctx, 'out) typ;\n args : (('out Io.Stream.t, field_error) result Io.t, 'args) Arg.arg_list;\n resolve : 'ctx resolve_info -> 'args;\n } -> 'ctx subscription_field\n\n type 'ctx subscription_obj = {\n name : string;\n doc : string option;\n fields : 'ctx subscription_field list;\n }\n\n type ('ctx, 'a) abstract_typ = ('ctx, ('ctx, 'a) abstract_value option) typ\n\n type directive_location = [\n | `Query\n | `Mutation\n | `Subscription\n | `Field\n | `Fragment_definition\n | `Fragment_spread\n | `Inline_fragment\n | `Variable_definition\n ]\n\n type directive =\n Directive : {\n name : string;\n doc : string option;\n locations : directive_location list;\n args : ([ `Skip | `Include ], 'args) Arg.arg_list;\n resolve : 'args;\n } -> directive\n\n type 'ctx schema = {\n query : ('ctx, unit) obj;\n mutation : ('ctx, unit) obj option;\n subscription : 'ctx subscription_obj option;\n }\n\n let schema ?(mutation_name=\"mutation\")\n ?mutations\n ?(subscription_name=\"subscription\")\n ?subscriptions\n ?(query_name=\"query\")\n fields = {\n query = {\n name = query_name;\n doc = None;\n abstracts = ref [];\n fields = lazy fields;\n };\n mutation = Option.map mutations ~f:(fun fields ->\n {\n name = mutation_name;\n doc = None;\n abstracts = ref [];\n fields = lazy fields;\n }\n );\n subscription = Option.map subscriptions ~f:(fun fields ->\n {\n name = subscription_name;\n doc = None;\n fields;\n }\n )\n }\n\n (* Constructor functions *)\n let obj ?doc name ~fields =\n let rec o = Object { name; doc; fields = lazy (fields o); abstracts = ref []} in\n o\n\n let field ?doc ?(deprecated=NotDeprecated) name ~typ ~args ~resolve =\n Field { name; doc; deprecated; typ; args; resolve; lift = Io.ok }\n\n let io_field ?doc ?(deprecated=NotDeprecated) name ~typ ~args ~resolve =\n Field { name; doc; deprecated; typ; args; resolve; lift = id }\n\n let abstract_field ?doc ?(deprecated=NotDeprecated) name ~typ ~args =\n AbstractField (Field { lift = Io.ok; name; doc; deprecated; typ; args; resolve = Obj.magic () })\n\n let subscription_field ?doc ?(deprecated=NotDeprecated) name ~typ ~args ~resolve =\n SubscriptionField { name; doc; deprecated; typ; args; resolve }\n\n let enum ?doc name ~values =\n Enum { name; doc; values }\n\n let scalar ?doc name ~coerce =\n Scalar { name; doc; coerce }\n\n let list typ =\n List typ\n\n let non_null typ =\n NonNullable typ\n\n let union ?doc name =\n Abstract { name; doc; types = []; kind = `Union }\n\n let interface ?doc name ~fields =\n let rec i = Abstract { name; doc; types = []; kind = `Interface (lazy (fields i)) } in\n i\n\n let add_type abstract_typ typ =\n match (abstract_typ, typ) with\n | Abstract a, Object o ->\n (* TODO add subtype check here *)\n a.types <- (AnyTyp typ)::a.types;\n o.abstracts := a :: !(o.abstracts);\n fun src -> AbstractValue (typ, src)\n | _ ->\n invalid_arg \"Arguments must be Interface/Union and Object\"\n\n let obj_of_subscription_obj {name; doc; fields} =\n let fields = List.map\n (fun (SubscriptionField {name; doc; deprecated; typ; args; resolve}) ->\n Field { lift = Obj.magic (); name; doc; deprecated; typ; args; resolve = (fun ctx () -> resolve ctx) })\n fields\n in\n { name; doc; abstracts = ref []; fields = lazy fields }\n\n (* Built-in scalars *)\n let int : 'ctx. ('ctx, int option) typ = Scalar {\n name = \"Int\";\n doc = None;\n coerce = fun i -> `Int i;\n }\n\n let string : 'ctx. ('ctx, string option) typ = Scalar {\n name = \"String\";\n doc = None;\n coerce = fun s ->`String s;\n }\n\n let bool : 'ctx. ('ctx, bool option) typ = Scalar {\n name = \"Boolean\";\n doc = None;\n coerce = fun b -> `Bool b;\n }\n\n let float : 'ctx. ('ctx, float option) typ = Scalar {\n name = \"Float\";\n doc = None;\n coerce = fun f -> `Float f;\n }\n\n let guid : 'ctx. ('ctx, string option) typ = Scalar {\n name = \"ID\";\n doc = None;\n coerce = fun x -> `String x;\n }\n\n (* Mandatory directives: skip and include *)\n let skip_directive = Directive {\n name = \"skip\";\n doc = Some \"Directs the executor to skip this field or fragment when the `if` argument is true.\";\n locations = [`Field; `Fragment_spread; `Inline_fragment];\n args = Arg.[\n arg \"if\" ~doc:\"Skipped when true.\" ~typ:(non_null bool)\n ];\n resolve = function\n | true -> `Skip\n | false -> `Include\n }\n\n let include_directive = Directive {\n name = \"include\";\n doc = Some \"Directs the executor to include this field or fragment only when the `if` argument is true.\";\n locations = [`Field; `Fragment_spread; `Inline_fragment];\n args = Arg.[\n arg \"if\" ~doc:\"Included when true.\" ~typ:(non_null bool)\n ];\n resolve = function\n | true -> `Include\n | false -> `Skip\n }\n\nmodule Introspection = struct\n (* any_typ, any_field and any_arg hide type parameters to avoid scope escaping errors *)\n type any_field =\n | AnyField : (_, _) field -> any_field\n | AnyArgField : _ Arg.arg -> any_field\n type any_arg = AnyArg : _ Arg.arg -> any_arg\n type any_enum_value = AnyEnumValue : _ enum_value -> any_enum_value\n\n let unless_visited (result, visited) name f =\n if StringSet.mem name visited then\n result, visited\n else\n f (result, visited)\n\n (* Extracts all types contained in a single type *)\n let rec types : type ctx src. ?memo:(any_typ list * StringSet.t) -> (ctx, src) typ -> (any_typ list * StringSet.t) = fun ?(memo=([], StringSet.empty)) typ ->\n match typ with\n | List typ -> types ~memo typ\n | NonNullable typ -> types ~memo typ\n | Scalar s as scalar ->\n unless_visited memo s.name (fun (result, visited) ->\n (AnyTyp scalar)::result, StringSet.add s.name visited\n )\n | Enum e as enum ->\n unless_visited memo e.name (fun (result, visited) ->\n (AnyTyp enum)::result, StringSet.add e.name visited\n )\n | Object o as obj ->\n unless_visited memo o.name (fun (result, visited) ->\n let result' = (AnyTyp obj)::result in\n let visited' = StringSet.add o.name visited in\n let reducer = fun memo (Field f) ->\n let memo' = types ~memo f.typ in\n arg_list_types memo' f.args\n in\n List.fold_left reducer (result', visited') (Lazy.force o.fields)\n )\n | Abstract a as abstract ->\n unless_visited memo a.name (fun (result, visited) ->\n let result' = (AnyTyp abstract)::result in\n let visited' = StringSet.add a.name visited in\n List.fold_left (fun memo typ -> match typ with\n | AnyTyp typ -> types ~memo typ\n | AnyArgTyp _ -> failwith \"Abstracts can't have argument types\")\n (result', visited') a.types\n )\n\n and arg_types : type a. (any_typ list * StringSet.t) -> a Arg.arg_typ -> (any_typ list * StringSet.t) = fun memo argtyp ->\n match argtyp with\n | Arg.List typ -> arg_types memo typ\n | Arg.NonNullable typ -> arg_types memo typ\n | Arg.Scalar s as scalar ->\n unless_visited memo s.name (fun (result, visited) ->\n (AnyArgTyp scalar)::result, StringSet.add s.name visited\n )\n | Arg.Enum e as enum ->\n unless_visited memo e.name (fun (result, visited) ->\n (AnyArgTyp enum)::result, StringSet.add e.name visited\n )\n | Arg.Object o as obj ->\n unless_visited memo o.name (fun (result, visited) ->\n let memo' = (AnyArgTyp obj)::result, StringSet.add o.name visited in\n arg_list_types memo' o.fields\n )\n and arg_list_types : type a b. (any_typ list * StringSet.t) -> (a, b) Arg.arg_list -> (any_typ list * StringSet.t) = fun memo arglist ->\n let open Arg in\n match arglist with\n | [] -> memo\n | arg::args ->\n let memo' = match arg with\n | Arg a -> arg_types memo a.typ\n | DefaultArg a -> arg_types memo a.typ\n in arg_list_types memo' args\n\n let types_of_schema s =\n let types, _ =\n List.fold_left\n (fun memo op ->\n match op with\n | None -> memo\n | Some op -> types ~memo (Object op))\n ([], StringSet.empty)\n [Some s.query; s.mutation; Option.map s.subscription ~f:obj_of_subscription_obj]\n in\n types\n\n let rec args_to_list : type a b. ?memo:any_arg list -> (a, b) Arg.arg_list -> any_arg list = fun ?memo:(memo=[]) arglist ->\n let open Arg in\n match arglist with\n | [] ->\n memo\n | arg::args ->\n let memo' = List.cons (AnyArg arg) memo in\n args_to_list ~memo:memo' args\n\n let no_abstracts = ref []\n\n let __type_kind = Enum {\n name = \"__TypeKind\";\n doc = None;\n values = [\n {\n name=\"SCALAR\";\n doc=None;\n deprecated=NotDeprecated;\n value=`Scalar;\n };\n {\n name=\"OBJECT\";\n doc=None;\n deprecated=NotDeprecated;\n value=`Object;\n };\n {\n name=\"INTERFACE\";\n doc=None;\n deprecated=NotDeprecated;\n value=`Interface;\n };\n {\n name=\"UNION\";\n doc=None;\n deprecated=NotDeprecated;\n value=`Union;\n };\n {\n name=\"ENUM\";\n doc=None;\n deprecated=NotDeprecated;\n value=`Enum;\n };\n {\n name=\"INPUT_OBJECT\";\n doc=None;\n deprecated=NotDeprecated;\n value=`InputObject;\n };\n {\n name=\"LIST\";\n doc=None;\n deprecated=NotDeprecated;\n value=`List;\n };\n {\n name=\"NON_NULL\";\n doc=None;\n deprecated=NotDeprecated;\n value=`NonNull;\n };\n ]\n }\n\n let __enum_value : 'ctx. ('ctx, any_enum_value option) typ = Object {\n name = \"__EnumValue\";\n doc = None;\n abstracts = no_abstracts;\n fields = lazy [\n Field {\n name = \"name\";\n doc = None;\n deprecated = NotDeprecated;\n typ = NonNullable string;\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ (AnyEnumValue enum_value) -> enum_value.name;\n };\n Field {\n name = \"description\";\n doc = None;\n deprecated = NotDeprecated;\n typ = string;\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ (AnyEnumValue enum_value) -> enum_value.doc;\n };\n Field {\n name = \"isDeprecated\";\n doc = None;\n deprecated = NotDeprecated;\n typ = NonNullable bool;\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ (AnyEnumValue enum_value) -> enum_value.deprecated <> NotDeprecated;\n };\n Field {\n name = \"deprecationReason\";\n doc = None;\n deprecated = NotDeprecated;\n typ = string;\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ (AnyEnumValue enum_value) ->\n match enum_value.deprecated with\n | Deprecated reason -> reason\n | NotDeprecated -> None\n }\n ]\n }\n\n let rec __input_value : 'ctx. ('ctx, any_arg option) typ = Object {\n name = \"__InputValue\";\n doc = None;\n abstracts = no_abstracts;\n fields = lazy [\n Field {\n name = \"name\";\n doc = None;\n deprecated = NotDeprecated;\n typ = NonNullable string;\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ (AnyArg arg) -> match arg with\n | Arg.DefaultArg a -> a.name\n | Arg.Arg a -> a.name\n };\n Field {\n name = \"description\";\n doc = None;\n deprecated = NotDeprecated;\n typ = string;\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ (AnyArg arg) -> match arg with\n | Arg.DefaultArg a -> a.doc\n | Arg.Arg a -> a.doc\n };\n Field {\n name = \"type\";\n doc = None;\n deprecated = NotDeprecated;\n typ = NonNullable __type;\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ (AnyArg arg) -> match arg with\n | Arg.DefaultArg a -> AnyArgTyp a.typ\n | Arg.Arg a -> AnyArgTyp a.typ\n };\n Field {\n name = \"defaultValue\";\n doc = None;\n deprecated = NotDeprecated;\n typ = string;\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ (AnyArg _) -> None\n }\n ]\n }\n\n and __type : 'ctx . ('ctx, any_typ option) typ = Object {\n name = \"__Type\";\n doc = None;\n abstracts = no_abstracts;\n fields = lazy [\n Field {\n name = \"kind\";\n doc = None;\n deprecated = NotDeprecated;\n typ = NonNullable __type_kind;\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ t -> match t with\n | AnyTyp (Object _) -> `Object\n | AnyTyp (Abstract { kind = `Union; _ }) -> `Union\n | AnyTyp (Abstract { kind = `Interface _; _ }) -> `Interface\n | AnyTyp (List _) -> `List\n | AnyTyp (Scalar _) -> `Scalar\n | AnyTyp (Enum _) -> `Enum\n | AnyTyp (NonNullable _) -> `NonNull\n | AnyArgTyp (Arg.Object _) -> `InputObject\n | AnyArgTyp (Arg.List _) -> `List\n | AnyArgTyp (Arg.Scalar _) -> `Scalar\n | AnyArgTyp (Arg.Enum _) -> `Enum\n | AnyArgTyp (Arg.NonNullable _) -> `NonNull\n };\n Field {\n name = \"name\";\n doc = None;\n deprecated = NotDeprecated;\n typ = string;\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ t -> match t with\n | AnyTyp (Object o) -> Some o.name\n | AnyTyp (Scalar s) -> Some s.name\n | AnyTyp (Enum e) -> Some e.name\n | AnyTyp (Abstract a) -> Some a.name\n | AnyArgTyp (Arg.Object o) -> Some o.name\n | AnyArgTyp (Arg.Scalar s) -> Some s.name\n | AnyArgTyp (Arg.Enum e) -> Some e.name\n | _ -> None;\n };\n Field {\n name = \"description\";\n doc = None;\n deprecated = NotDeprecated;\n typ = string;\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ t -> match t with\n | AnyTyp (Object o) -> o.doc\n | AnyTyp (Scalar s) -> s.doc\n | AnyTyp (Enum e) -> e.doc\n | AnyTyp (Abstract a) -> a.doc\n | AnyArgTyp (Arg.Object o) -> o.doc\n | AnyArgTyp (Arg.Scalar s) -> s.doc\n | AnyArgTyp (Arg.Enum e) -> e.doc\n | _ -> None\n };\n Field {\n name = \"fields\";\n doc = None;\n deprecated = NotDeprecated;\n typ = List (NonNullable __field);\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ t -> match t with\n | AnyTyp (Object o) ->\n Some (List.map (fun f -> AnyField f) (Lazy.force o.fields))\n | AnyTyp (Abstract { kind = `Interface fields; _ }) ->\n Some (List.map (fun (AbstractField f) -> AnyField f) (Lazy.force fields))\n | AnyArgTyp (Arg.Object o) ->\n let arg_list = args_to_list o.fields in\n Some (List.map (fun (AnyArg f) -> AnyArgField f) arg_list)\n | _ -> None\n };\n Field {\n name = \"interfaces\";\n doc = None;\n deprecated = NotDeprecated;\n typ = List (NonNullable __type);\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ t -> match t with\n | AnyTyp (Object o) ->\n let interfaces = List.filter (function | { kind = `Interface _; _} -> true | _ -> false) !(o.abstracts) in\n Some (List.map (fun i -> AnyTyp (Abstract i)) interfaces)\n | _ -> None\n };\n Field {\n name = \"possibleTypes\";\n doc = None;\n deprecated = NotDeprecated;\n typ = List (NonNullable __type);\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ t -> match t with\n | AnyTyp (Abstract a) ->\n Some a.types\n | _ -> None\n };\n Field {\n name = \"ofType\";\n doc = None;\n deprecated = NotDeprecated;\n typ = __type;\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ t -> match t with\n | AnyTyp (NonNullable typ) -> Some (AnyTyp typ)\n | AnyTyp (List typ) -> Some (AnyTyp typ)\n | AnyArgTyp (Arg.NonNullable typ) -> Some (AnyArgTyp typ)\n | AnyArgTyp (Arg.List typ) -> Some (AnyArgTyp typ)\n | _ -> None\n };\n Field {\n name = \"inputFields\";\n doc = None;\n deprecated = NotDeprecated;\n typ = List (NonNullable __input_value);\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ t -> match t with\n | AnyArgTyp (Arg.Object o) ->\n Some (args_to_list o.fields)\n | _ -> None\n };\n Field {\n name = \"enumValues\";\n doc = None;\n deprecated = NotDeprecated;\n typ = List (NonNullable __enum_value);\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ t -> match t with\n | AnyTyp (Enum e) -> Some (List.map (fun x -> AnyEnumValue x) e.values)\n | AnyArgTyp (Arg.Enum e) -> Some (List.map (fun x -> AnyEnumValue x) e.values)\n | _ -> None\n }\n ]\n }\n\n and __field : 'ctx. ('ctx, any_field option) typ = Object {\n name = \"__Field\";\n doc = None;\n abstracts = no_abstracts;\n fields = lazy [\n Field {\n name = \"name\";\n doc = None;\n deprecated = NotDeprecated;\n typ = NonNullable string;\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ f -> match f with\n | AnyField (Field f) -> f.name\n | AnyArgField (Arg.Arg a) -> a.name\n | AnyArgField (Arg.DefaultArg a) -> a.name\n };\n Field {\n name = \"description\";\n doc = None;\n deprecated = NotDeprecated;\n typ = string;\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ f -> match f with\n | AnyField (Field f) -> f.doc\n | AnyArgField (Arg.Arg a) -> a.doc\n | AnyArgField (Arg.DefaultArg a) -> a.doc\n };\n Field {\n name = \"args\";\n doc = None;\n deprecated = NotDeprecated;\n typ = NonNullable (List (NonNullable __input_value));\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ f -> match f with\n | AnyField (Field f) -> args_to_list f.args\n | AnyArgField _ -> []\n };\n Field {\n name = \"type\";\n doc = None;\n deprecated = NotDeprecated;\n typ = NonNullable __type;\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ f -> match f with\n | AnyField (Field f) -> AnyTyp f.typ\n | AnyArgField (Arg.Arg a) -> AnyArgTyp a.typ\n | AnyArgField (Arg.DefaultArg a) -> AnyArgTyp a.typ\n };\n Field {\n name = \"isDeprecated\";\n doc = None;\n deprecated = NotDeprecated;\n typ = NonNullable bool;\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ f -> match f with\n | AnyField (Field { deprecated = Deprecated _; _ }) -> true\n | _ -> false\n };\n Field {\n name = \"deprecationReason\";\n doc = None;\n deprecated = NotDeprecated;\n typ = string;\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ f -> match f with\n | AnyField (Field { deprecated = Deprecated reason; _ }) -> reason\n | _ -> None\n }\n ]\n }\n\n let __directive_location = Enum {\n name = \"__DirectiveLocation\";\n doc = None;\n values = [\n {\n name=\"QUERY\";\n doc=None;\n deprecated=NotDeprecated;\n value=`Query;\n };\n {\n name=\"MUTATION\";\n doc=None;\n deprecated=NotDeprecated;\n value=`Mutation;\n };\n {\n name=\"SUBSCRIPTION\";\n doc=None;\n deprecated=NotDeprecated;\n value=`Subscription;\n };\n {\n name=\"FIELD\";\n doc=None;\n deprecated=NotDeprecated;\n value=`Field;\n };\n {\n name=\"FRAGMENT_DEFINITION\";\n doc=None;\n deprecated=NotDeprecated;\n value=`Fragment_definition;\n };\n {\n name=\"FRAGMENT_SPREAD\";\n doc=None;\n deprecated=NotDeprecated;\n value=`Fragment_spread;\n };\n {\n name=\"INLINE_FRAGMENT\";\n doc=None;\n deprecated=NotDeprecated;\n value=`Inline_fragment;\n };\n {\n name=\"VARIABLE_DEFINITION\";\n doc=None;\n deprecated=NotDeprecated;\n value=`Variable_definition;\n };\n ]\n }\n\n let __directive = Object {\n name = \"__Directive\";\n doc = None;\n abstracts = no_abstracts;\n fields = lazy [\n Field {\n name = \"name\";\n doc = None;\n deprecated = NotDeprecated;\n typ = NonNullable string;\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ (Directive d) -> d.name\n };\n Field {\n name = \"description\";\n doc = None;\n deprecated = NotDeprecated;\n typ = string;\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ (Directive d) -> d.doc\n };\n Field {\n name = \"locations\";\n doc = None;\n deprecated = NotDeprecated;\n typ = NonNullable (List (NonNullable __directive_location));\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ (Directive d) -> d.locations\n };\n Field {\n name = \"args\";\n doc = None;\n deprecated = NotDeprecated;\n typ = NonNullable (List (NonNullable __input_value));\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ (Directive d) -> args_to_list d.args\n }\n ]\n }\n\n let __schema : 'ctx. ('ctx, ('ctx schema * any_typ list) option) typ = Object {\n name = \"__Schema\";\n doc = None;\n abstracts = no_abstracts;\n fields = lazy [\n Field {\n name = \"types\";\n doc = None;\n deprecated = NotDeprecated;\n typ = NonNullable (List (NonNullable __type));\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ (_schema, types) -> types\n };\n Field {\n name = \"queryType\";\n doc = None;\n deprecated = NotDeprecated;\n typ = NonNullable __type;\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ (schema, _types) -> AnyTyp (Object schema.query)\n };\n Field {\n name = \"mutationType\";\n doc = None;\n deprecated = NotDeprecated;\n typ = __type;\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ (schema, _types) -> Option.map schema.mutation ~f:(fun mut -> AnyTyp (Object mut))\n };\n Field {\n name = \"subscriptionType\";\n doc = None;\n deprecated = NotDeprecated;\n typ = __type;\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ (schema, _types) ->\n Option.map schema.subscription ~f:(fun subs -> AnyTyp (Object (obj_of_subscription_obj subs)))\n };\n Field {\n name = \"directives\";\n doc = None;\n deprecated = NotDeprecated;\n typ = NonNullable (List (NonNullable __directive));\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ _ -> []\n }\n ]\n }\n\n let add_built_in_fields schema =\n let types = types_of_schema schema in\n let schema_field = Field {\n name = \"__schema\";\n doc = None;\n deprecated = NotDeprecated;\n typ = NonNullable __schema;\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ _ -> (schema, types)\n } in\n let type_field = Field {\n name = \"__type\";\n doc = None;\n deprecated = NotDeprecated;\n typ = __type;\n args = Arg.[arg \"name\" ~typ:(non_null string)];\n lift = Io.ok;\n resolve = fun _ _ name ->\n List.find (fun typ ->\n match typ with\n | AnyTyp (Object o) -> o.name = name\n | AnyTyp (Scalar s) -> s.name = name\n | AnyTyp (Enum e) -> e.name = name\n | AnyTyp (Abstract a) -> a.name = name\n | AnyTyp (List _) -> false\n | AnyTyp (NonNullable _) -> false\n | AnyArgTyp (Arg.Object o) -> o.name = name\n | AnyArgTyp (Arg.Scalar s) -> s.name = name\n | AnyArgTyp (Arg.Enum e) -> e.name = name\n | AnyArgTyp (Arg.List _) -> false\n | AnyArgTyp (Arg.NonNullable _) -> false\n ) types\n } in\n let fields = lazy (schema_field::type_field::(Lazy.force schema.query.fields)) in\n { schema with query = { schema.query with fields } }\nend\n\n (* Execution *)\n type variables = (string * Graphql_parser.const_value) list\n type execution_order = Serial | Parallel\n type 'ctx execution_context = {\n variables : variable_map;\n fragments : fragment_map;\n ctx : 'ctx;\n }\n\n type path = [`String of string | `Int of int] list\n type error = field_error * path\n\n type resolve_error = [\n | `Resolve_error of error\n | `Argument_error of string\n | `Validation_error of string\n ]\n\n type execute_error = [\n resolve_error\n | `Mutations_not_configured\n | `Subscriptions_not_configured\n | `No_operation_found\n | `Operation_name_required\n | `Operation_not_found\n ]\n\n type 'a response = ('a, json) result\n\n let matches_type_condition type_condition (obj : ('ctx, 'src) obj) =\n obj.name = type_condition ||\n List.exists (fun (abstract : abstract) -> abstract.name = type_condition) !(obj.abstracts)\n\n let rec should_include_field ctx (directives : Graphql_parser.directive list) =\n match directives with\n | [] -> Ok true\n | { name = \"skip\"; arguments }::rest ->\n eval_directive ctx skip_directive arguments rest\n | { name = \"include\"; arguments }::rest ->\n eval_directive ctx include_directive arguments rest\n | { name; _ }::_ ->\n let err = Format.sprintf \"Unknown directive: %s\" name in\n Error err\n\n and eval_directive ctx (Directive { name; args; resolve; _ }) arguments rest =\n let open Rresult in\n Arg.eval_arglist ctx.variables ~field_type:\"directive\" ~field_name:name args arguments resolve >>= function\n | `Skip -> Ok false\n | `Include -> should_include_field ctx rest\n\n let alias_or_name : Graphql_parser.field -> string = fun field ->\n match field.alias with\n | Some alias -> alias\n | None -> field.name\n\n let rec merge_selections ?(memo=[]) = function\n | [] -> List.rev memo\n | field::fields ->\n let id = alias_or_name field in\n let matching, rest = List.partition (fun field' -> id = (alias_or_name field')) fields in\n let selection_sets = List.map (fun (field : Graphql_parser.field) -> field.selection_set) (field::matching) in\n let selection_set = List.concat selection_sets in\n merge_selections ~memo:({field with selection_set}::memo) rest\n\n let rec collect_fields : 'ctx execution_context -> ('ctx, 'src) obj -> Graphql_parser.selection list -> (Graphql_parser.field list, string) result =\n fun ctx obj fields ->\n let open Rresult in\n List.map (function\n | Graphql_parser.Field field ->\n should_include_field ctx field.directives >>| fun include_field ->\n if include_field then [field] else []\n | Graphql_parser.FragmentSpread spread ->\n begin match StringMap.find spread.name ctx.fragments with\n | Some { directives; type_condition; selection_set; _ }\n when matches_type_condition type_condition obj ->\n should_include_field ctx directives >>= fun include_field ->\n if include_field then\n collect_fields ctx obj selection_set\n else Ok []\n | _ -> Ok []\n end\n | Graphql_parser.InlineFragment fragment ->\n let matches_type_condition = match fragment.type_condition with\n | None -> true\n | Some condition -> matches_type_condition condition obj\n in\n if matches_type_condition then\n should_include_field ctx fragment.directives >>= fun include_field ->\n if include_field then\n collect_fields ctx obj fragment.selection_set\n else Ok []\n else\n Ok []\n ) fields\n |> List.Result.join\n |> Rresult.R.map List.concat\n |> Rresult.R.map merge_selections\n\n let field_from_object : ('ctx, 'src) obj -> string -> ('ctx, 'src) field option = fun obj field_name ->\n List.find (fun (Field field) -> field.name = field_name) (Lazy.force obj.fields)\n\n let field_from_subscription_object = fun obj field_name ->\n List.find (fun (SubscriptionField field) -> field.name = field_name) obj.fields\n\n let coerce_or_null : 'a option -> ('a -> (json * error list, 'b) result Io.t) -> (json * error list, 'b) result Io.t =\n fun src f ->\n match src with\n | None -> Io.ok (`Null, [])\n | Some src' -> f src'\n\n let map_fields_with_order = function\n | Serial -> Io.map_s ~memo:[]\n | Parallel -> Io.map_p\n\n let error_to_json ?path ?extensions msg =\n let props = match path with\n | Some path -> [\"path\", `List (List.rev path :> json list)]\n | None -> []\n in\n let extension_props = match extensions with\n | None\n | Some [] -> []\n | Some extensions -> [\"extensions\", `Assoc extensions]\n in\n (`Assoc ((\"message\", `String msg)::(List.append props extension_props)) : json)\n\n let error_response ?data ?path ?extensions msg =\n let errors = \"errors\", `List [\n error_to_json ?path ?extensions msg\n ]\n in\n let data = match data with\n | None -> []\n | Some data -> [\"data\", data]\n in\n `Assoc (errors :: data)\n\n let rec present : type ctx src. ctx execution_context -> src -> Graphql_parser.field -> (ctx, src) typ -> path -> (json * error list, [> resolve_error]) result Io.t =\n fun ctx src query_field typ path ->\n match typ with\n | Scalar s -> coerce_or_null src (fun x -> Io.ok (s.coerce x, []))\n | List t ->\n coerce_or_null src (fun src' ->\n List.mapi (fun i x -> present ctx x query_field t ((`Int i)::path)) src'\n |> Io.all\n |> Io.map ~f:List.Result.join\n |> Io.Result.map ~f:(fun xs -> (`List (List.map fst xs), List.map snd xs |> List.concat))\n )\n | NonNullable t -> present ctx (Some src) query_field t path\n | Object o ->\n coerce_or_null src (fun src' ->\n match collect_fields ctx o query_field.selection_set with\n | Ok fields -> resolve_fields ctx src' o fields path\n | Error e -> Io.error (`Argument_error e))\n | Enum e ->\n coerce_or_null src (fun src' ->\n match List.find (fun enum_value -> src' == enum_value.value) e.values with\n | Some enum_value -> Io.ok (`String enum_value.name, [])\n | None -> Io.ok (`Null, [])\n )\n | Abstract _ ->\n coerce_or_null src (fun (AbstractValue (typ', src')) ->\n present ctx (Some src') query_field typ' path\n )\n\n and resolve_field : type ctx src. ctx execution_context -> src -> Graphql_parser.field -> (ctx, src) field -> path -> ((string * json) * error list, [> resolve_error]) result Io.t =\n fun ctx src query_field (Field field) path ->\n let open Io.Infix in\n let name = alias_or_name query_field in\n let path' = (`String name)::path in\n let resolve_info = {\n ctx = ctx.ctx;\n field = query_field;\n fragments = ctx.fragments;\n variables = ctx.variables;\n } in\n let resolver = field.resolve resolve_info src in\n match Arg.eval_arglist ctx.variables ~field_name:field.name field.args query_field.arguments resolver with\n | Ok unlifted_value ->\n let lifted_value =\n field.lift unlifted_value\n |> Io.Result.map_error ~f:(fun err -> `Resolve_error (err, path')) >>=? fun resolved ->\n present ctx resolved query_field field.typ path'\n in\n lifted_value >>| (function\n | Ok (value, errors) ->\n Ok ((name, value), errors)\n | Error (`Argument_error _)\n | Error (`Validation_error _) as error ->\n error\n | Error (`Resolve_error err) as error ->\n match field.typ with\n | NonNullable _ ->\n error\n | _ ->\n Ok ((name, `Null), [err])\n )\n | Error err ->\n Io.error (`Argument_error err)\n\n and resolve_fields : type ctx src. ctx execution_context -> ?execution_order:execution_order -> src -> (ctx, src) obj -> Graphql_parser.field list -> path -> (json * error list, [> resolve_error]) result Io.t =\n fun ctx ?execution_order:(execution_order=Parallel) src obj fields path ->\n map_fields_with_order execution_order (fun (query_field : Graphql_parser.field) ->\n let name = alias_or_name query_field in\n if query_field.name = \"__typename\" then\n Io.ok ((name, `String obj.name), [])\n else\n match field_from_object obj query_field.name with\n | Some field ->\n resolve_field ctx src query_field field path\n | None ->\n let err = Printf.sprintf \"Field '%s' is not defined on type '%s'\" query_field.name obj.name in\n Io.error (`Validation_error err)\n ) fields\n |> Io.map ~f:List.Result.join\n |> Io.Result.map ~f:(fun xs -> (`Assoc (List.map fst xs), List.map snd xs |> List.concat))\n\n let data_to_json = function\n | data, [] -> `Assoc [\"data\", data]\n | data, errors ->\n let errors = List.map\n (fun (field_error, path) ->\n let extensions = Field_error.extensions_of_field_error field_error in\n let msg = Field_error.message_of_field_error field_error in\n error_to_json ~path ?extensions msg)\n errors\n in\n `Assoc [\n \"errors\", `List errors;\n \"data\", data;\n ]\n\n let to_response = function\n | Ok _ as res -> res\n | Error `No_operation_found ->\n Error (error_response \"No operation found\")\n | Error `Operation_not_found ->\n Error (error_response \"Operation not found\")\n | Error `Operation_name_required ->\n Error (error_response \"Operation name required\")\n | Error `Subscriptions_not_configured ->\n Error (error_response \"Subscriptions not configured\")\n | Error `Mutations_not_configured ->\n Error (error_response \"Mutations not configured\")\n | Error (`Validation_error msg) ->\n Error (error_response msg)\n | Error (`Argument_error msg) ->\n Error (error_response ~data:`Null msg)\n | Error (`Resolve_error (field_error, path)) ->\n let extensions = Field_error.extensions_of_field_error field_error in\n let msg = Field_error.message_of_field_error field_error in\n Error (error_response ~data:`Null ~path ?extensions msg)\n\n let subscribe : type ctx. ctx execution_context -> ctx subscription_field -> Graphql_parser.field -> (json response Io.Stream.t, [> resolve_error]) result Io.t\n =\n fun ctx (SubscriptionField subs_field) field ->\n let open Io.Infix in\n let name = alias_or_name field in\n let path = [`String name] in\n let resolve_info = {\n ctx = ctx.ctx;\n field;\n fragments = ctx.fragments;\n variables = ctx.variables\n } in\n let resolver = subs_field.resolve resolve_info in\n match Arg.eval_arglist ctx.variables ~field_name:subs_field.name subs_field.args field.arguments resolver with\n | Ok result ->\n result\n |> Io.Result.map ~f:(fun source_stream ->\n Io.Stream.map source_stream (fun value ->\n present ctx value field subs_field.typ path\n |> Io.Result.map ~f:(fun (data, errors) ->\n data_to_json (`Assoc [name, data], errors)\n )\n >>| to_response\n )\n )\n |> Io.Result.map_error ~f:(fun err ->\n `Resolve_error (err, path)\n )\n | Error err -> Io.error (`Argument_error err)\n\n let execute_operation : 'ctx schema -> 'ctx execution_context -> Graphql_parser.operation -> ([ `Response of json | `Stream of json response Io.Stream.t], [> execute_error]) result Io.t =\n fun schema ctx operation ->\n let open Io.Infix in\n match operation.optype with\n | Graphql_parser.Query ->\n let query = schema.query in\n Io.return (collect_fields ctx query operation.selection_set)\n |> Io.Result.map_error ~f:(fun e -> `Argument_error e) >>=? fun fields ->\n (resolve_fields ctx () query fields [] : (json * error list, resolve_error) result Io.t :> (json * error list, [> execute_error]) result Io.t)\n |> Io.Result.map ~f:(fun data_errs -> `Response (data_to_json data_errs))\n | Graphql_parser.Mutation ->\n begin match schema.mutation with\n | None -> Io.error `Mutations_not_configured\n | Some mut ->\n Io.return (collect_fields ctx mut operation.selection_set)\n |> Io.Result.map_error ~f:(fun e -> `Argument_error e) >>=? fun fields ->\n (resolve_fields ~execution_order:Serial ctx () mut fields [] : (json * error list, resolve_error) result Io.t :> (json * error list, [> execute_error]) result Io.t)\n |> Io.Result.map ~f:(fun data_errs -> `Response (data_to_json data_errs))\n end\n | Graphql_parser.Subscription ->\n begin match schema.subscription with\n | None -> Io.error `Subscriptions_not_configured\n | Some subs ->\n Io.return (collect_fields ctx (obj_of_subscription_obj subs) operation.selection_set)\n |> Io.Result.map_error ~f:(fun e -> `Argument_error e) >>=? fun fields ->\n begin match fields with\n | [field] ->\n (match field_from_subscription_object subs field.name with\n | Some subscription_field ->\n (subscribe ctx subscription_field field : ((json, json) result Io.Stream.t, resolve_error) result Io.t :> ((json, json) result Io.Stream.t, [> execute_error]) result Io.t)\n |> Io.Result.map ~f:(fun stream -> `Stream stream)\n | None -> Io.ok (`Response (`Assoc [(alias_or_name field, `Null)])))\n (* see http://facebook.github.io/graphql/June2018/#sec-Response-root-field *)\n | _ -> Io.error (`Validation_error \"Subscriptions only allow exactly one selection for the operation.\")\n end\n end\n\n let collect_fragments doc =\n List.fold_left (fun memo -> function\n | Graphql_parser.Operation _ -> memo\n | Graphql_parser.Fragment f -> StringMap.add f.name f memo\n ) StringMap.empty doc\n\n exception FragmentCycle of string list\n let rec validate_fragments fragment_map =\n try\n StringMap.iter (fun name _ ->\n validate_fragment fragment_map StringSet.empty name\n ) fragment_map;\n Ok fragment_map\n with FragmentCycle fragment_names ->\n let cycle = String.concat \", \" fragment_names in\n let err = Format.sprintf \"Fragment cycle detected: %s\" cycle in\n Error (`Validation_error err)\n\n and validate_fragment (fragment_map : fragment_map) visited name =\n match StringMap.find name fragment_map with\n | None -> ()\n | Some fragment when StringSet.mem fragment.name visited ->\n raise (FragmentCycle (StringSet.elements visited))\n | Some fragment ->\n let visited' = StringSet.add fragment.name visited in\n List.iter (validate_fragment_selection fragment_map visited') fragment.selection_set\n\n and validate_fragment_selection fragment_map visited selection =\n match selection with\n | Graphql_parser.Field field ->\n List.iter (validate_fragment_selection fragment_map visited) field.selection_set\n | InlineFragment inline_fragment ->\n List.iter (validate_fragment_selection fragment_map visited) inline_fragment.selection_set\n | FragmentSpread fragment_spread ->\n validate_fragment fragment_map visited fragment_spread.name\n\n let collect_and_validate_fragments doc =\n let fragments = collect_fragments doc in\n validate_fragments fragments\n\n let collect_operations doc =\n List.fold_left (fun memo -> function\n | Graphql_parser.Operation op -> op::memo\n | Graphql_parser.Fragment _ -> memo\n ) [] doc\n\n let select_operation ?operation_name doc =\n let operations = collect_operations doc in\n match operation_name, operations with\n | _, [] -> Error `No_operation_found\n | None, [op] -> Ok op\n | None, _::_ -> Error `Operation_name_required\n | Some name, ops ->\n try\n Ok (List.find_exn (fun op -> op.Graphql_parser.name = Some name) ops)\n with Not_found ->\n Error `Operation_not_found\n\n let execute schema ctx ?variables:(variables=[]) ?operation_name doc =\n let open Io.Infix in\n let execute' schema ctx doc =\n Io.return (collect_and_validate_fragments doc) >>=? fun fragments ->\n let schema' = Introspection.add_built_in_fields schema in\n Io.return (select_operation ?operation_name doc) >>=? fun op ->\n let default_variables = List.fold_left (fun memo { Graphql_parser.name; default_value; _ } ->\n match default_value with\n | None -> memo\n | Some value -> StringMap.add name value memo\n ) StringMap.empty op.variable_definitions in\n let variables = List.fold_left (fun memo (name, value) -> StringMap.add name value memo) default_variables variables in\n let execution_ctx = { fragments; ctx; variables } in\n execute_operation schema' execution_ctx op\n in\n execute' schema ctx doc >>| to_response\nend\n","open Core_kernel\n\nmodule Annotations = struct\n module Utils = struct\n let find xs key =\n List.find ~f:(fun (k', _) -> String.equal key k') xs |> Option.map ~f:snd\n\n let find_string xs key =\n find xs key |> Option.join |> Option.map ~f:(fun s -> String.strip s)\n\n let find_bool xs key =\n find xs key\n |> Option.map ~f:(fun _ -> true)\n |> Option.value ~default:false\n end\n\n module Top = struct\n (** Top comment *)\n type t = { name : string; doc : string option }\n [@@deriving annot, sexp, compare, equal]\n\n open Utils\n\n let of_annots ~name t_toplevel_annots =\n let xs = t_toplevel_annots () in\n { name; doc = find_string xs \"ocaml.doc\" }\n\n let%test_unit \"top annots parse\" =\n let t = of_annots ~name:\"Top\" t_toplevel_annots in\n [%test_eq: t] t { name = \"Top\"; doc = Some \"Top comment\" }\n end\n\n module Fields = struct\n module T = struct\n type t =\n { name : string option\n ; doc : string option [@name \"document\"]\n ; skip : bool [@skip]\n ; deprecated : string option [@depr \"foo\"] (** this is deprecated *)\n }\n [@@deriving annot, sexp, compare, equal]\n end\n\n type t = string -> T.t\n\n open Utils\n\n let of_annots t_fields_annots field =\n let xs = t_fields_annots field in\n let s = find_string xs in\n let b = find_bool xs in\n { T.name = s \"name\"\n ; doc = s \"ocaml.doc\"\n ; skip = b \"skip\"\n ; deprecated = s \"depr\"\n }\n\n let%test_unit \"field annots parse\" =\n let annots = of_annots T.t_fields_annots in\n [%test_eq: T.t] (annots \"doc\")\n { name = Some \"document\"; doc = None; skip = false; deprecated = None } ;\n [%test_eq: T.t] (annots \"skip\")\n { name = None; doc = None; skip = true; deprecated = None } ;\n [%test_eq: T.t] (annots \"deprecated\")\n { name = None\n ; doc = Some \"this is deprecated\"\n ; skip = false\n ; deprecated = Some \"foo\"\n }\n end\nend\n\n(** Rewrites underscore_case to camelCase. Note: Keeps leading underscores. *)\nlet under_to_camel s =\n (* take all the underscores *)\n let prefix_us =\n String.take_while s ~f:(function '_' -> true | _ -> false)\n in\n (* remove them from the original *)\n let rest = String.substr_replace_first ~pattern:prefix_us ~with_:\"\" s in\n let ws = String.split rest ~on:'_' in\n let result =\n match ws with\n | [] ->\n \"\"\n | w :: ws ->\n (* capitalize each word separated by underscores *)\n w :: (ws |> List.map ~f:String.capitalize) |> String.concat ?sep:None\n in\n (* add the leading underscoes back *)\n String.concat [ prefix_us; result ]\n\nlet%test_unit \"under_to_camel works as expected\" =\n let open Core_kernel in\n [%test_eq: string] \"fooHello\" (under_to_camel \"foo_hello\") ;\n [%test_eq: string] \"fooHello\" (under_to_camel \"foo_hello___\") ;\n [%test_eq: string] \"_fooHello\" (under_to_camel \"_foo_hello__\")\n\n(** Like Field.name but rewrites underscore_case to camelCase. *)\nlet name_under_to_camel f = Fieldslib.Field.name f |> under_to_camel\n\nlet introspection_query_raw =\n {graphql|\n query IntrospectionQuery {\n __schema {\n queryType { name }\n mutationType { name }\n subscriptionType { name }\n types {\n ...FullType\n }\n directives {\n name\n description\n locations\n args {\n ...InputValue\n }\n }\n }\n }\n fragment FullType on __Type {\n kind\n name\n description\n fields(includeDeprecated: true) {\n name\n description\n args {\n ...InputValue\n }\n type {\n ...TypeRef\n }\n isDeprecated\n deprecationReason\n }\n inputFields {\n ...InputValue\n }\n interfaces {\n ...TypeRef\n }\n enumValues(includeDeprecated: true) {\n name\n description\n isDeprecated\n deprecationReason\n }\n possibleTypes {\n ...TypeRef\n }\n }\n fragment InputValue on __InputValue {\n name\n description\n type { ...TypeRef }\n defaultValue\n }\n fragment TypeRef on __Type {\n kind\n name\n ofType {\n kind\n name\n ofType {\n kind\n name\n ofType {\n kind\n name\n ofType {\n kind\n name\n ofType {\n kind\n name\n ofType {\n kind\n name\n ofType {\n kind\n name\n }\n }\n }\n }\n }\n }\n }\n }\n |graphql}\n","open Core_kernel\nopen Fieldslib\n\nmodule Graphql_raw = struct\n module Make (Schema : Graphql_intf.Schema) = struct\n module Args = struct\n module Input = struct\n type ('row, 'result, 'ty, 'nullable) t =\n < graphql_arg : (unit -> 'ty Schema.Arg.arg_typ) ref\n ; nullable_graphql_arg : (unit -> 'nullable Schema.Arg.arg_typ) ref\n ; map : ('ty -> 'result) ref\n ; skip : bool ref\n ; .. >\n as\n 'row\n end\n\n module Acc = struct\n module T = struct\n type ('ty, 'fields) t_inner =\n { graphql_arg_fields : ('ty, 'fields) Schema.Arg.arg_list\n ; graphql_arg_coerce : 'fields\n }\n\n type 'ty t = Init | Acc : ('ty, 'fields) t_inner -> 'ty t\n end\n\n type ('row, 'result, 'ty, 'nullable) t =\n < graphql_arg_accumulator : 'result T.t ref ; .. > as 'row\n constraint\n ('row, 'c, 'ty, 'nullable) t =\n ('row, 'c, 'ty, 'nullable) Input.t\n end\n\n module Creator = struct\n type ('row, 'c, 'ty, 'nullable) t = < .. > as 'row\n constraint\n ('row, 'c, 'ty, 'nullable) t =\n ('row, 'c, 'ty, 'nullable) Input.t\n end\n\n module Output = struct\n type ('row, 'c, 'ty, 'nullable) t = < .. > as 'row\n constraint\n ('row, 'c, 'ty, 'nullable) t =\n ('row, 'c, 'ty, 'nullable) Input.t\n end\n\n let add_field (type f f' ty ty' nullable1 nullable2) ?skip_data\n ~t_fields_annots :\n ('f_row, f', f, nullable1) Input.t\n -> ([< `Read | `Set_and_create ], _, _) Field.t_with_perm\n -> ('row, ty', ty, nullable2) Acc.t\n -> (('row, ty', ty, nullable2) Creator.t -> f')\n * ('row_after, ty', ty, nullable2) Acc.t =\n fun f_input field acc ->\n let annotations =\n Fields_derivers.Annotations.Fields.of_annots t_fields_annots\n (Field.name field)\n in\n let ref_as_pipe = ref None in\n let name =\n Option.value annotations.name\n ~default:(Fields_derivers.name_under_to_camel field)\n in\n let () =\n let inner_acc = acc#graphql_arg_accumulator in\n if annotations.skip || !(f_input#skip) then ()\n else\n let arg =\n Schema.Arg.arg name ?doc:annotations.doc\n ~typ:(!(f_input#graphql_arg) ())\n in\n match !inner_acc with\n | Init ->\n inner_acc :=\n Acc\n { graphql_arg_coerce =\n (fun x ->\n ref_as_pipe := Some x ;\n !(acc#graphql_creator) acc )\n ; graphql_arg_fields = [ arg ]\n }\n | Acc { graphql_arg_fields; graphql_arg_coerce } -> (\n match graphql_arg_fields with\n | [] ->\n inner_acc :=\n Acc\n { graphql_arg_coerce =\n (fun x ->\n ref_as_pipe := Some x ;\n !(acc#graphql_creator) acc )\n ; graphql_arg_fields = [ arg ]\n }\n | _ ->\n inner_acc :=\n Acc\n { graphql_arg_coerce =\n (fun x ->\n ref_as_pipe := Some x ;\n graphql_arg_coerce )\n ; graphql_arg_fields = arg :: graphql_arg_fields\n } )\n in\n ( (fun _creator_input ->\n !(f_input#map)\n @@\n if annotations.skip || !(f_input#skip) then\n match skip_data with\n | Some data ->\n data\n | None ->\n failwith\n \"If you are skipping a field but intend on building this \\\n field, you must provide skip_data to add_field!\"\n else Option.value_exn !ref_as_pipe )\n , acc )\n\n let finish name ~t_toplevel_annots (type ty result nullable) :\n (('row, result, ty, nullable) Input.t -> result)\n * ('row, result, ty, nullable) Acc.t\n -> _ Output.t =\n fun (creator, acc) ->\n let annotations =\n Fields_derivers.Annotations.Top.of_annots ~name t_toplevel_annots\n in\n acc#graphql_creator := creator ;\n (acc#graphql_arg :=\n fun () ->\n match !(acc#graphql_arg_accumulator) with\n | Init ->\n failwith \"Graphql args need at least one field\"\n | Acc { graphql_arg_fields; graphql_arg_coerce } ->\n (* TODO: Figure out why the typechecker doesn't like this\n * expression and remove Obj.magic. *)\n Obj.magic\n @@ Schema.Arg.(\n obj ?doc:annotations.doc\n (annotations.name ^ \"Input\")\n ~fields:graphql_arg_fields ~coerce:graphql_arg_coerce\n |> non_null) ) ;\n (acc#nullable_graphql_arg :=\n fun () ->\n match !(acc#graphql_arg_accumulator) with\n | Init ->\n failwith \"Graphql args need at least one field\"\n | Acc { graphql_arg_fields; graphql_arg_coerce } ->\n (* TODO: See above *)\n Obj.magic\n @@ Schema.Arg.(\n obj ?doc:annotations.doc\n (annotations.name ^ \"Input\")\n ~fields:graphql_arg_fields ~coerce:graphql_arg_coerce)\n ) ;\n acc\n\n let skip obj =\n obj#skip := true ;\n (obj#graphql_arg :=\n fun () ->\n failwith \"Unexpected: This obj#graphql_arg should be skipped\" ) ;\n obj#map := Fn.id ;\n obj#graphql_arg_accumulator := !(obj#graphql_arg_accumulator) ;\n (obj#nullable_graphql_arg :=\n fun () ->\n failwith \"Unexpected: This obj#graphql_arg should be skipped\" ) ;\n obj\n\n let int obj =\n (obj#graphql_arg := fun () -> Schema.Arg.(non_null int)) ;\n obj#map := Fn.id ;\n obj#graphql_arg_accumulator := !(obj#graphql_arg_accumulator) ;\n (obj#nullable_graphql_arg := fun () -> Schema.Arg.int) ;\n obj\n\n let string obj =\n (obj#graphql_arg := fun () -> Schema.Arg.(non_null string)) ;\n obj#map := Fn.id ;\n obj#graphql_arg_accumulator := !(obj#graphql_arg_accumulator) ;\n (obj#nullable_graphql_arg := fun () -> Schema.Arg.string) ;\n obj\n\n let bool obj =\n (obj#graphql_arg := fun () -> Schema.Arg.(non_null bool)) ;\n obj#map := Fn.id ;\n obj#graphql_arg_accumulator := !(obj#graphql_arg_accumulator) ;\n (obj#nullable_graphql_arg := fun () -> Schema.Arg.bool) ;\n obj\n\n let list x obj : (_, 'result list, 'input_type list, _) Input.t =\n (obj#graphql_arg :=\n fun () -> Schema.Arg.(non_null (list (!(x#graphql_arg) ()))) ) ;\n obj#map := List.map ~f:!(x#map) ;\n obj#graphql_arg_accumulator := !(x#graphql_arg_accumulator) ;\n (obj#nullable_graphql_arg :=\n fun () -> Schema.Arg.(list (!(x#graphql_arg) ())) ) ;\n obj\n\n let option (x : (_, 'result, 'input_type, _) Input.t) obj =\n obj#graphql_arg := !(x#nullable_graphql_arg) ;\n obj#nullable_graphql_arg := !(x#nullable_graphql_arg) ;\n obj#map := Option.map ~f:!(x#map) ;\n obj#graphql_arg_accumulator := !(x#graphql_arg_accumulator) ;\n obj\n\n let map ~(f : 'c -> 'd) (x : (_, 'c, 'input_type, _) Input.t) obj :\n (_, 'd, 'input_type, _) Input.t =\n obj#graphql_arg := !(x#graphql_arg) ;\n (obj#map := fun a -> f (!(x#map) a)) ;\n obj#nullable_graphql_arg := !(x#nullable_graphql_arg) ;\n obj#graphql_arg_accumulator := !(x#graphql_arg_accumulator) ;\n obj\n end\n\n module Fields = struct\n module Input = struct\n module T = struct\n type 'input_type t =\n { run : 'ctx. unit -> ('ctx, 'input_type) Schema.typ }\n end\n\n type ('input_type, 'a, 'c, 'nullable) t =\n < graphql_fields : 'input_type T.t ref\n ; contramap : ('c -> 'input_type) ref\n ; nullable_graphql_fields : 'nullable T.t ref\n ; .. >\n as\n 'a\n end\n\n module Accumulator = struct\n module T = struct\n type 'input_type t =\n { run : 'ctx. unit -> ('ctx, 'input_type) Schema.field option }\n end\n\n (** thunks generating the schema in reverse *)\n type ('input_type, 'a, 'c, 'nullable) t =\n < graphql_fields_accumulator : 'c T.t list ref ; .. > as 'a\n constraint\n ('input_type, 'a, 'c, 'nullable) t =\n ('input_type, 'a, 'c, 'nullable) Input.t\n end\n\n let add_field (type f input_type orig nullable c' nullable')\n ~t_fields_annots :\n (orig, 'a, f, nullable) Input.t\n -> ([< `Read | `Set_and_create ], c', f) Fieldslib.Field.t_with_perm\n -> (input_type, 'row2, c', nullable') Accumulator.t\n -> (_ -> f) * (input_type, 'row2, c', nullable') Accumulator.t =\n fun t_field field acc ->\n let annotations =\n Fields_derivers.Annotations.Fields.of_annots t_fields_annots\n (Field.name field)\n in\n let rest = !(acc#graphql_fields_accumulator) in\n acc#graphql_fields_accumulator :=\n { Accumulator.T.run =\n (fun () ->\n if annotations.skip || !(t_field#skip) then None\n else\n Schema.field\n (Option.value annotations.name\n ~default:(Fields_derivers.name_under_to_camel field) )\n ~args:Schema.Arg.[]\n ?doc:annotations.doc\n ~deprecated:\n ( Option.map annotations.deprecated ~f:(fun msg ->\n Schema.Deprecated (Some msg) )\n |> Option.value ~default:Schema.NotDeprecated )\n ~typ:(!(t_field#graphql_fields).Input.T.run ())\n ~resolve:(fun _ x ->\n !(t_field#contramap) (Field.get field x) )\n |> Option.return )\n }\n :: rest ;\n ((fun _ -> failwith \"Unused\"), acc)\n\n let finish name ~t_toplevel_annots ((_creator, obj) : 'u * _ Accumulator.t)\n : _ Input.t =\n let annotations =\n Fields_derivers.Annotations.Top.of_annots ~name t_toplevel_annots\n in\n let graphql_fields_accumulator = !(obj#graphql_fields_accumulator) in\n let graphql_fields =\n { Input.T.run =\n (fun () ->\n Schema.obj annotations.name ?doc:annotations.doc\n ~fields:(fun _ ->\n List.rev\n @@ List.filter_map graphql_fields_accumulator ~f:(fun g ->\n g.Accumulator.T.run () ) )\n |> Schema.non_null )\n }\n in\n let nullable_graphql_fields =\n { Input.T.run =\n (fun () ->\n Schema.obj annotations.name ?doc:annotations.doc\n ~fields:(fun _ ->\n List.rev\n @@ List.filter_map graphql_fields_accumulator ~f:(fun g ->\n g.Accumulator.T.run () ) ) )\n }\n in\n obj#graphql_fields := graphql_fields ;\n obj#nullable_graphql_fields := nullable_graphql_fields ;\n obj#contramap := Fn.id ;\n obj\n\n let skip obj =\n (obj#graphql_fields :=\n Input.T.\n { run =\n (fun () ->\n failwith\n \"Unexpected: This obj#graphql_fields should be skipped\" )\n } ) ;\n obj#contramap := Fn.id ;\n obj#graphql_fields_accumulator := !(obj#graphql_fields_accumulator) ;\n (obj#nullable_graphql_fields :=\n Input.T.\n { run =\n (fun () ->\n failwith\n \"Unexpected: This obj#nullable_graphql_fields should be \\\n skipped\" )\n } ) ;\n obj\n\n let int obj =\n (obj#graphql_fields :=\n Input.T.{ run = (fun () -> Schema.(non_null int)) } ) ;\n obj#contramap := Fn.id ;\n obj#graphql_fields_accumulator := !(obj#graphql_fields_accumulator) ;\n (obj#nullable_graphql_fields := Input.T.{ run = (fun () -> Schema.int) }) ;\n obj\n\n let string obj =\n (obj#graphql_fields :=\n Input.T.{ run = (fun () -> Schema.(non_null string)) } ) ;\n obj#contramap := Fn.id ;\n obj#graphql_fields_accumulator := !(obj#graphql_fields_accumulator) ;\n (obj#nullable_graphql_fields :=\n Input.T.{ run = (fun () -> Schema.string) } ) ;\n obj\n\n let bool obj =\n (obj#graphql_fields :=\n Input.T.{ run = (fun () -> Schema.(non_null bool)) } ) ;\n obj#contramap := Fn.id ;\n obj#graphql_fields_accumulator := !(obj#graphql_fields_accumulator) ;\n (obj#nullable_graphql_fields :=\n Input.T.{ run = (fun () -> Schema.bool) } ) ;\n obj\n\n let list x obj : ('input_type list, _, _, _) Input.t =\n (obj#graphql_fields :=\n Input.T.\n { run =\n (fun () ->\n Schema.(non_null (list (!(x#graphql_fields).run ()))) )\n } ) ;\n obj#contramap := List.map ~f:!(x#contramap) ;\n obj#graphql_fields_accumulator := !(x#graphql_fields_accumulator) ;\n (obj#nullable_graphql_fields :=\n Input.T.\n { run = (fun () -> Schema.(list (!(x#graphql_fields).run ()))) } ) ;\n obj\n\n let option (x : ('input_type, 'b, 'c, 'nullable) Input.t) obj :\n ('input_type option, _, 'c option, _) Input.t =\n obj#graphql_fields := !(x#nullable_graphql_fields) ;\n obj#nullable_graphql_fields := !(x#nullable_graphql_fields) ;\n obj#contramap := Option.map ~f:!(x#contramap) ;\n obj#graphql_fields_accumulator := !(x#graphql_fields_accumulator) ;\n obj\n\n let contramap ~(f : 'd -> 'c)\n (x : ('input_type, 'b, 'c, 'nullable) Input.t) obj :\n ('input_type, _, 'd, _) Input.t =\n obj#graphql_fields := !(x#graphql_fields) ;\n (obj#contramap := fun a -> !(x#contramap) (f a)) ;\n obj#nullable_graphql_fields := !(x#nullable_graphql_fields) ;\n obj#graphql_fields_accumulator := !(x#graphql_fields_accumulator) ;\n obj\n end\n\n let rec arg_to_yojson_rec (arg : Graphql_parser.const_value) : Yojson.Safe.t\n =\n match arg with\n | `Null ->\n `Null\n | `Int x ->\n `Int x\n | `Float x ->\n `Float x\n | `String x ->\n `String x\n | `Bool x ->\n `Bool x\n | `Enum x ->\n `String x\n | `List x ->\n `List (List.map x ~f:arg_to_yojson_rec)\n | `Assoc x ->\n `Assoc\n (List.map x ~f:(fun (key, value) -> (key, arg_to_yojson_rec value)))\n\n let arg_to_yojson arg : (Yojson.Safe.t, string) result =\n Ok (arg_to_yojson_rec arg)\n end\nend\n\nmodule Graphql_query = struct\n module Input = struct\n type 'a t = < graphql_query : string option ref ; .. > as 'a\n end\n\n module Accumulator = struct\n type 'a t =\n < graphql_query_accumulator : (string * string option) option list ref\n ; .. >\n as\n 'a\n constraint 'a t = 'a Input.t\n end\n\n let add_field ~t_fields_annots :\n 'a Input.t -> 'field -> 'obj -> 'creator * 'obj =\n fun t_field field acc_obj ->\n let annotations =\n Fields_derivers.Annotations.Fields.of_annots t_fields_annots\n (Field.name field)\n in\n let rest = !(acc_obj#graphql_query_accumulator) in\n acc_obj#graphql_query_accumulator :=\n ( if annotations.skip || !(t_field#skip) then None\n else\n Some\n ( Option.value annotations.name\n ~default:(Fields_derivers.name_under_to_camel field)\n , !(t_field#graphql_query) ) )\n :: rest ;\n ((fun _ -> failwith \"unused\"), acc_obj)\n\n let finish (_creator, obj) =\n let graphql_query_accumulator = !(obj#graphql_query_accumulator) in\n obj#graphql_query :=\n Some\n (sprintf \"{\\n%s\\n}\"\n ( List.filter_map graphql_query_accumulator\n ~f:\n (Option.map ~f:(fun (k, v) ->\n match v with None -> k | Some v -> sprintf \"%s %s\" k v )\n )\n |> List.rev |> String.concat ~sep:\"\\n\" ) ) ;\n obj\n\n let scalar obj =\n obj#graphql_query := None ;\n obj\n\n let skip obj = scalar obj\n\n let int obj = scalar obj\n\n let string obj = scalar obj\n\n let bool obj = scalar obj\n\n (* nullable and lists of things are projected to the inner thing ONLY IF inner\n * projectable. *)\n let wrapped x obj =\n obj#graphql_query := !(x#graphql_query) ;\n obj\n\n let option x obj = wrapped x obj\n\n let list x obj = wrapped x obj\n\n let inner_query obj = !(obj#graphql_query)\nend\n\nmodule IO = struct\n include Async_kernel.Deferred\n\n let bind x f = bind x ~f\n\n module Stream = struct\n type 'a t = 'a Async_kernel.Pipe.Reader.t\n\n let map t f =\n Async_kernel.Pipe.map' t ~f:(fun q ->\n Async_kernel.Deferred.Queue.map q ~f )\n\n let iter t f = Async_kernel.Pipe.iter t ~f\n\n let close = Async_kernel.Pipe.close_read\n end\nend\n\nmodule Field_error = struct\n type t = string\n\n let message_of_field_error t = t\n\n let extensions_of_field_error _t = None\nend\n\nmodule Schema = Graphql_schema.Make (IO) (Field_error)\nmodule Graphql = Graphql_raw.Make (Schema)\n\nmodule Test = struct\n let parse_query str =\n match Graphql_parser.parse str with\n | Ok res ->\n res\n | Error err ->\n failwith err\n\n let introspection_query () =\n parse_query Fields_derivers.introspection_query_raw\nend\n\nlet%test_module \"Test\" =\n ( module struct\n (* Pure -- just like Graphql libraries functor application *)\n module IO = struct\n type +'a t = 'a\n\n let bind t f = f t\n\n let return t = t\n\n module Stream = struct\n type 'a t = 'a Seq.t\n\n let map t f = Seq.map f t\n\n let iter t f = Seq.iter f t\n\n let close _t = ()\n end\n end\n\n module Schema = Graphql_schema.Make (IO) (Field_error)\n module Graphql = Graphql_raw.Make (Schema)\n module Graphql_fields = Graphql.Fields\n module Graphql_args = Graphql.Args\n\n let deriver (type a b c d) () :\n < contramap : (a -> b) ref\n ; graphql_fields : c Graphql_fields.Input.T.t ref\n ; nullable_graphql_fields : d Graphql_fields.Input.T.t ref\n ; .. >\n as\n 'row =\n (* We have to declare these outside of the object, otherwise the method\n * will create a new ref each time it is called. *)\n let open Graphql_fields in\n let graphql_fields =\n ref Input.T.{ run = (fun () -> failwith \"unimplemented1\") }\n in\n let graphql_arg = ref (fun () -> failwith \"unimplemented2\") in\n let contramap = ref (fun _ -> failwith \"unimplemented3\") in\n let map = ref (fun _ -> failwith \"unimplemented4\") in\n let nullable_graphql_fields =\n ref Input.T.{ run = (fun () -> failwith \"unimplemented5\") }\n in\n let nullable_graphql_arg = ref (fun () -> failwith \"unimplemented6\") in\n let graphql_fields_accumulator = ref [] in\n let graphql_arg_accumulator = ref Graphql_args.Acc.T.Init in\n let graphql_creator = ref (fun _ -> failwith \"unimplemented7\") in\n let graphql_query = ref None in\n let graphql_query_accumulator = ref [] in\n let skip = ref false in\n object\n method skip = skip\n\n method graphql_fields = graphql_fields\n\n method graphql_arg = graphql_arg\n\n method contramap = contramap\n\n method map = map\n\n method nullable_graphql_fields = nullable_graphql_fields\n\n method nullable_graphql_arg = nullable_graphql_arg\n\n method graphql_fields_accumulator = graphql_fields_accumulator\n\n method graphql_arg_accumulator = graphql_arg_accumulator\n\n method graphql_creator = graphql_creator\n\n method graphql_query = graphql_query\n\n method graphql_query_accumulator = graphql_query_accumulator\n end\n\n let o () = deriver ()\n\n let raw_server ?(print = false) q c =\n let schema = Schema.(schema [ q ] ~mutations:[] ~subscriptions:[]) in\n let res = Schema.execute schema () c in\n match res with\n | Ok (`Response data) ->\n if print then Yojson.Basic.pretty_print Format.std_formatter data ;\n data |> Yojson.Basic.to_string\n | Error err ->\n failwithf \"Unexpected error: %s\" (Yojson.Basic.to_string err) ()\n | _ ->\n failwith \"Unexpected response\"\n\n let query_schema typ v =\n Schema.(\n field \"query\" ~typ:(non_null typ)\n ~args:Arg.[]\n ~doc:\"sample query\"\n ~resolve:(fun _ _ -> v))\n\n let query_for_all typ v str =\n raw_server (query_schema typ v) (Test.parse_query str)\n\n let hit_server ?print q = raw_server ?print q (Test.introspection_query ())\n\n let hit_server_query (typ : _ Schema.typ) v =\n hit_server (query_schema typ v)\n\n let hit_server_args (arg_typ : 'a Schema.Arg.arg_typ) =\n hit_server\n Schema.(\n field \"args\" ~typ:(non_null int)\n ~args:Arg.[ arg \"input\" ~typ:arg_typ ]\n ~doc:\"sample args query\"\n ~resolve:(fun _ _ _ -> 0))\n\n module T1 = struct\n (** T1 is foo *)\n type t =\n { foo_hello : int option\n ; skipped : int [@skip]\n ; bar : string list [@name \"bar1\"]\n }\n [@@deriving annot, fields]\n\n let _v = { foo_hello = Some 1; skipped = 0; bar = [ \"baz1\"; \"baz2\" ] }\n\n let doc = \"T1 is foo\"\n\n let manual_typ =\n Schema.(\n obj \"T1\" ~doc ~fields:(fun _ ->\n [ field \"fooHello\"\n ~args:Arg.[]\n ~typ:int\n ~resolve:(fun _ t -> t.foo_hello)\n ; field \"bar1\"\n ~args:Arg.[]\n ~typ:(non_null (list (non_null string)))\n ~resolve:(fun _ t -> t.bar)\n ] ))\n\n let derived init =\n let open Graphql_fields in\n let ( !. ) x fd acc = add_field ~t_fields_annots (x (o ())) fd acc in\n Fields.make_creator init\n ~foo_hello:!.(option @@ int @@ o ())\n ~skipped:!.skip\n ~bar:!.(list @@ string @@ o ())\n |> finish \"T1\" ~t_toplevel_annots\n\n module Args = struct\n let manual_typ =\n Schema.Arg.(\n obj \"T1Input\" ~doc\n ~fields:\n [ arg \"bar1\" ~typ:(non_null (list (non_null string)))\n ; arg \"fooHello\" ~typ:int\n ]\n ~coerce:(fun bar foo_hello -> { bar; skipped = 0; foo_hello }))\n\n let derived init =\n let open Graphql_args in\n let ( !. ) ?skip_data x fd acc =\n add_field ?skip_data ~t_fields_annots (x (o ())) fd acc\n in\n Fields.make_creator init\n ~foo_hello:!.(option @@ int @@ o ())\n ~skipped:(( !. ) ~skip_data:0 skip)\n ~bar:!.(list @@ string @@ o ())\n |> finish \"T1\" ~t_toplevel_annots\n end\n\n module Query = struct\n let derived init =\n let open Graphql_query in\n let ( !. ) x fd acc = add_field ~t_fields_annots (x (o ())) fd acc in\n Fields.make_creator init\n ~foo_hello:!.(option @@ int @@ o ())\n ~skipped:!.skip\n ~bar:!.(list @@ string @@ o ())\n |> finish\n end\n end\n\n module Or_ignore_test = struct\n type 'a t = Check of 'a | Ignore\n\n let of_option = function None -> Ignore | Some x -> Check x\n\n let to_option = function Ignore -> None | Check x -> Some x\n\n let derived (x : ('input_type, 'b, 'c, _) Graphql_fields.Input.t) init :\n (_, _, 'c t, _) Graphql_fields.Input.t =\n let open Graphql_fields in\n let opt = option x (o ()) in\n contramap ~f:to_option opt init\n\n module Args = struct\n let derived (x : ('row1, 'c, 'input_type, _) Graphql_args.Input.t) init\n : ('row2, 'c t, 'input_type option, _) Graphql_args.Input.t =\n let open Graphql_args in\n let opt = option x (o ()) in\n map ~f:of_option opt init\n end\n\n module Query = struct\n let derived x init =\n let open Graphql_query in\n option x init\n end\n end\n\n module T2 = struct\n type t = { foo : T1.t Or_ignore_test.t } [@@deriving annot, fields]\n\n let v1 =\n { foo =\n Check\n { T1.foo_hello = Some 1; skipped = 0; bar = [ \"baz1\"; \"baz2\" ] }\n }\n\n let v2 = { foo = Ignore }\n\n let manual_typ =\n Schema.(\n obj \"T2\" ?doc:None ~fields:(fun _ ->\n [ field \"foo\"\n ~args:Arg.[]\n ~typ:T1.manual_typ\n ~resolve:(fun _ t -> Or_ignore_test.to_option t.foo)\n ] ))\n\n let derived init =\n let open Graphql_fields in\n let ( !. ) x fd acc = add_field ~t_fields_annots (x (o ())) fd acc in\n Fields.make_creator init\n ~foo:!.(Or_ignore_test.derived @@ T1.derived @@ o ())\n |> finish \"T2\" ~t_toplevel_annots\n\n module Args = struct\n let manual_typ =\n Schema.Arg.(\n obj \"T2Input\" ?doc:None\n ~fields:[ arg \"foo\" ~typ:T1.Args.manual_typ ]\n ~coerce:(fun foo -> Or_ignore_test.of_option foo))\n\n let derived init =\n let open Graphql_args in\n let ( !. ) x fd acc = add_field ~t_fields_annots (x (o ())) fd acc in\n Fields.make_creator init\n ~foo:!.(Or_ignore_test.Args.derived @@ T1.Args.derived @@ o ())\n |> finish \"T2\" ~t_toplevel_annots\n end\n\n module Query = struct\n let manual =\n {|\n {\n foo {\n fooHello\n bar1\n }\n }\n |}\n\n let derived init =\n let open Graphql_query in\n let ( !. ) x fd acc = add_field ~t_fields_annots (x (o ())) fd acc in\n Fields.make_creator init\n ~foo:!.(Or_ignore_test.Query.derived @@ T1.Query.derived @@ o ())\n |> finish\n end\n end\n\n let%test_unit \"T2 fold\" =\n let open Graphql_fields in\n let generated_typ =\n let typ_input = T2.(option @@ derived @@ o ()) (o ()) in\n !(typ_input#graphql_fields).run ()\n in\n [%test_eq: string]\n (hit_server_query generated_typ T2.v1)\n (hit_server_query T2.manual_typ T2.v1) ;\n [%test_eq: string]\n (hit_server_query generated_typ T2.v2)\n (hit_server_query T2.manual_typ T2.v2)\n\n let%test_unit \"T2 unfold\" =\n let open Graphql_args in\n let generated_arg_typ =\n let obj = T2.(option @@ Args.derived @@ o ()) (o ()) in\n !(obj#graphql_arg) ()\n in\n [%test_eq: string]\n (hit_server_args generated_arg_typ)\n (hit_server_args T2.Args.manual_typ)\n\n let%test_unit \"T2 query expected & parses\" =\n let open Graphql_fields in\n let generated_typ =\n let typ_input = T2.(option @@ derived @@ o ()) (o ()) in\n !(typ_input#graphql_fields).run ()\n in\n let open Graphql_query in\n let generated_query =\n T2.Query.(option @@ derived @@ o ()) (o ())\n |> inner_query |> Option.value_exn\n in\n let prefix = \"query TestQuery { query\" in\n let suffix = \"}\" in\n [%test_eq: string]\n (query_for_all generated_typ T2.v1 (prefix ^ generated_query ^ suffix))\n (query_for_all generated_typ T2.v1 (prefix ^ T2.Query.manual ^ suffix))\n end )\n","open Core_kernel\nopen Fieldslib\n\nmodule To_yojson = struct\n module Input = struct\n type ('input_type, 'a, 'c) t =\n < to_json : ('input_type -> Yojson.Safe.t) ref\n ; contramap : ('c -> 'input_type) ref\n ; skip : bool ref\n ; .. >\n as\n 'a\n end\n\n module Accumulator = struct\n type ('input_type, 'a, 'c) t =\n < to_json_accumulator :\n (string * ('input_type -> Yojson.Safe.t)) option list ref\n ; .. >\n as\n 'a\n constraint ('input_type, 'a, 'c) t = ('input_type, 'a, 'c) Input.t\n end\n\n let add_field ~t_fields_annots t_field field acc =\n let annotations =\n Fields_derivers.Annotations.Fields.of_annots t_fields_annots\n (Field.name field)\n in\n let rest = !(acc#to_json_accumulator) in\n acc#to_json_accumulator :=\n ( if annotations.skip || !(t_field#skip) then None\n else\n ( Option.value annotations.name\n ~default:(Fields_derivers.name_under_to_camel field)\n , fun x -> !(t_field#to_json) (!(t_field#contramap) (Field.get field x))\n )\n |> Option.return )\n :: rest ;\n ((fun _ -> failwith \"Unused\"), acc)\n\n let finish (_creator, obj) =\n let to_json_accumulator = !(obj#to_json_accumulator) in\n obj#contramap := Fn.id ;\n (obj#to_json :=\n fun t ->\n `Assoc\n ( List.filter_map to_json_accumulator\n ~f:(Option.map ~f:(fun (name, f) -> (name, f t)))\n |> List.rev ) ) ;\n obj\n\n let skip obj =\n obj#skip := true ;\n obj#contramap := Fn.id ;\n (obj#to_json :=\n fun _ -> failwith \"Unexpected: This obj#to_json should be skipped\" ) ;\n obj\n\n let int obj =\n obj#contramap := Fn.id ;\n (obj#to_json := fun x -> `Int x) ;\n obj\n\n let string obj =\n obj#contramap := Fn.id ;\n (obj#to_json := fun x -> `String x) ;\n obj\n\n let bool obj =\n obj#contramap := Fn.id ;\n (obj#to_json := fun x -> `Bool x) ;\n obj\n\n let list x obj =\n obj#contramap := List.map ~f:!(x#contramap) ;\n (obj#to_json := fun a -> `List (List.map ~f:!(x#to_json) a)) ;\n obj\n\n let option x obj =\n obj#contramap := Option.map ~f:!(x#contramap) ;\n (obj#to_json :=\n fun a_opt -> match a_opt with Some a -> !(x#to_json) a | None -> `Null ) ;\n obj\n\n let contramap ~f x obj =\n (obj#contramap := fun a -> !(x#contramap) (f a)) ;\n obj#to_json := !(x#to_json) ;\n obj\nend\n\nmodule Of_yojson = struct\n module Input = struct\n type ('input_type, 'a, 'c) t =\n < of_json : (Yojson.Safe.t -> 'input_type) ref\n ; map : ('input_type -> 'c) ref\n ; skip : bool ref\n ; .. >\n as\n 'a\n end\n\n module Creator = struct\n type ('input_type, 'a, 'c) t =\n < of_json_creator : Yojson.Safe.t String.Map.t ref ; .. > as 'a\n constraint ('input_type, 'a, 'c) t = ('input_type, 'a, 'c) Input.t\n end\n\n exception Field_not_found of string\n\n let add_field ?skip_data ~t_fields_annots :\n ('t, 'a, 'c) Input.t -> 'field -> 'obj -> 'creator * 'obj =\n fun t_field field acc_obj ->\n let annotations =\n Fields_derivers.Annotations.Fields.of_annots t_fields_annots\n (Field.name field)\n in\n let creator finished_obj =\n let map = !(finished_obj#of_json_creator) in\n !(t_field#map)\n ( if annotations.skip || !(t_field#skip) then\n match skip_data with\n | Some x ->\n x\n | None ->\n failwith\n \"If you are skipping a field in of_json but intend on building \\\n this field, you must provide skip_data to add_field!\"\n else\n !(t_field#of_json)\n (let name =\n Option.value annotations.name\n ~default:(Fields_derivers.name_under_to_camel field)\n in\n match Map.find map name with\n | None ->\n raise (Field_not_found name)\n | Some x ->\n x ) )\n in\n (creator, acc_obj)\n\n exception Json_not_object\n\n let finish (creator, obj) =\n let of_json json =\n match json with\n | `Assoc pairs ->\n obj#of_json_creator := String.Map.of_alist_exn pairs ;\n creator obj\n | _ ->\n raise Json_not_object\n in\n obj#map := Fn.id ;\n obj#of_json := of_json ;\n obj\n\n exception Invalid_json_scalar of [ `Int | `String | `Bool | `List ]\n\n let skip obj =\n obj#contramap := Fn.id ;\n (obj#of_json :=\n fun _ -> failwith \"Unexpected: This obj#of_json should be skipped\" ) ;\n obj\n\n let int obj =\n (obj#of_json :=\n function `Int x -> x | _ -> raise (Invalid_json_scalar `Int) ) ;\n obj#map := Fn.id ;\n obj\n\n let string obj =\n (obj#of_json :=\n function `String x -> x | _ -> raise (Invalid_json_scalar `String) ) ;\n obj#map := Fn.id ;\n obj\n\n let bool obj =\n (obj#of_json :=\n function `Bool x -> x | _ -> raise (Invalid_json_scalar `Bool) ) ;\n obj#map := Fn.id ;\n obj\n\n let list x obj =\n (obj#of_json :=\n function\n | `List xs ->\n List.map xs ~f:!(x#of_json)\n | _ ->\n raise (Invalid_json_scalar `List) ) ;\n obj#map := List.map ~f:!(x#map) ;\n obj\n\n let option x obj =\n (obj#of_json :=\n function `Null -> None | other -> Some (!(x#of_json) other) ) ;\n obj#map := Option.map ~f:!(x#map) ;\n obj\n\n let map ~f x obj =\n (obj#map := fun a -> f (!(x#map) a)) ;\n obj#of_json := !(x#of_json) ;\n obj\nend\n\nlet%test_module \"Test\" =\n ( module struct\n type t = { foo_hello : int; skipped : int [@skip]; bar : string list }\n [@@deriving annot, fields]\n\n let v = { foo_hello = 1; skipped = 0; bar = [ \"baz1\"; \"baz2\" ] }\n\n let m =\n {json|{ fooHello: 1, bar: [\"baz1\", \"baz2\"] }|json}\n |> Yojson.Safe.from_string\n\n module Yojson_version = struct\n type t = { foo_hello : int [@key \"fooHello\"]; bar : string list }\n [@@deriving yojson]\n\n let v = { foo_hello = 1; bar = [ \"baz1\"; \"baz2\" ] }\n end\n\n let deriver () =\n let to_json = ref (fun _ -> failwith \"unimplemented\") in\n let of_json = ref (fun _ -> failwith \"unimplemented\") in\n let to_json_accumulator = ref [] in\n let of_json_creator = ref String.Map.empty in\n let map = ref Fn.id in\n let contramap = ref Fn.id in\n let skip = ref false in\n object\n method skip = skip\n\n method to_json = to_json\n\n method map = map\n\n method contramap = contramap\n\n method of_json = of_json\n\n method to_json_accumulator = to_json_accumulator\n\n method of_json_creator = of_json_creator\n end\n\n let o () = deriver ()\n\n (* Explanation: Fields.make_creator roughly executes the following code:\n\n let make_creator ~foo_hello ~bar obj =\n (* Fieldslib.Field is actually a little more complicated *)\n let field_foo = Field { name = \"foo_hello\" ; getter = (fun o -> o.foo_hello) } in\n let field_bar = Field { name = \"bar\"; getter = (fun o -> o.bar) } in\n let creator_foo, obj = foo_hello field_foo obj in\n let creator_bar, obj = bar field_bar obj in\n let creator finished_obj =\n { foo_hello = creator_foo finished_obj ; bar = creator_bar finished_obj }\n in\n (creator, obj)\n *)\n\n let to_json obj =\n let open To_yojson in\n let ( !. ) x fd acc = add_field ~t_fields_annots (x @@ o ()) fd acc in\n Fields.make_creator obj ~foo_hello:!.int ~skipped:!.skip\n ~bar:!.(list @@ string @@ o ())\n |> finish\n\n let of_json obj =\n let open Of_yojson in\n let ( !. ) ?skip_data x fd acc =\n add_field ?skip_data ~t_fields_annots (x @@ o ()) fd acc\n in\n Fields.make_creator obj ~foo_hello:!.int\n ~skipped:(( !. ) ~skip_data:0 skip)\n ~bar:!.(list @@ string @@ o ())\n |> finish\n\n let both_json obj =\n let _a = to_json obj in\n let _b = of_json obj in\n obj\n\n let full_derivers = both_json @@ o ()\n\n let%test_unit \"folding creates a yojson object we expect (modulo camel \\\n casing)\" =\n [%test_eq: string]\n (Yojson_version.to_yojson Yojson_version.v |> Yojson.Safe.to_string)\n (!(full_derivers#to_json) v |> Yojson.Safe.to_string)\n\n let%test_unit \"unfolding creates a yojson object we expect\" =\n let expected =\n Yojson_version.of_yojson m |> Result.ok |> Option.value_exn\n in\n let actual = !(full_derivers#of_json) m in\n [%test_eq: string list] expected.bar actual.bar ;\n [%test_eq: int] expected.foo_hello actual.foo_hello\n\n let%test_unit \"round trip\" =\n [%test_eq: string]\n ( !(full_derivers#to_json) (!(full_derivers#of_json) m)\n |> Yojson.Safe.to_string )\n (m |> Yojson.Safe.to_string)\n end )\n","open Core_kernel\n\n[%%versioned\nmodule Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n type ('a, 'h) t = ('a, 'h) Mina_wire_types.With_hash.V1.t =\n { data : 'a; hash : 'h }\n [@@deriving annot, sexp, equal, compare, hash, yojson, fields]\n\n let to_latest data_latest hash_latest { data; hash } =\n { data = data_latest data; hash = hash_latest hash }\n end\nend]\n\ntype ('a, 'h) t = ('a, 'h) Stable.Latest.t = { data : 'a; hash : 'h }\n[@@deriving annot, sexp, equal, compare, hash, yojson]\n\nlet data { data; _ } = data\n\nlet hash { hash; _ } = hash\n\nlet map t ~f = { t with data = f t.data }\n\nlet map_hash t ~f = { t with hash = f t.hash }\n\nlet of_data data ~hash_data = { data; hash = hash_data data }\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nmodule Field = Snark_params.Tick.Field\n\nmodule Make (Schema : Graphql_intf.Schema) = struct\n module Graphql = Fields_derivers_graphql.Graphql_raw.Make (Schema)\n\n let derivers () =\n let graphql_fields =\n ref Graphql.Fields.Input.T.{ run = (fun () -> failwith \"unimplemented\") }\n in\n let nullable_graphql_fields =\n ref Graphql.Fields.Input.T.{ run = (fun () -> failwith \"unimplemented\") }\n in\n let graphql_fields_accumulator = ref [] in\n let graphql_arg = ref (fun () -> failwith \"unimplemented\") in\n let nullable_graphql_arg = ref (fun () -> failwith \"unimplemented\") in\n let graphql_arg_accumulator = ref Graphql.Args.Acc.T.Init in\n let graphql_creator = ref (fun _ -> failwith \"unimplemented\") in\n let graphql_query = ref None in\n let graphql_query_accumulator = ref [] in\n\n let to_json = ref (fun _ -> failwith \"unimplemented\") in\n let of_json = ref (fun _ -> failwith \"unimplemented\") in\n let to_json_accumulator = ref [] in\n let of_json_creator = ref String.Map.empty in\n\n let js_layout = ref (`Assoc []) in\n let js_layout_accumulator = ref [] in\n\n let contramap = ref (fun _ -> failwith \"unimplemented\") in\n let map = ref (fun _ -> failwith \"unimplemented\") in\n\n let skip = ref false in\n\n object\n method skip = skip\n\n method graphql_fields = graphql_fields\n\n method nullable_graphql_fields = nullable_graphql_fields\n\n method graphql_fields_accumulator = graphql_fields_accumulator\n\n method graphql_arg = graphql_arg\n\n method nullable_graphql_arg = nullable_graphql_arg\n\n method graphql_arg_accumulator = graphql_arg_accumulator\n\n method graphql_creator = graphql_creator\n\n method graphql_query = graphql_query\n\n method graphql_query_accumulator = graphql_query_accumulator\n\n method to_json = to_json\n\n method of_json = of_json\n\n method to_json_accumulator = to_json_accumulator\n\n method of_json_creator = of_json_creator\n\n method js_layout = js_layout\n\n method js_layout_accumulator = js_layout_accumulator\n\n method contramap = contramap\n\n method map = map\n end\n\n let o () = derivers ()\n\n module Unified_input = struct\n type 'a t = < .. > as 'a\n constraint 'a = _ Fields_derivers_json.To_yojson.Input.t\n constraint 'a = _ Fields_derivers_json.Of_yojson.Input.t\n constraint 'a = _ Graphql.Fields.Input.t\n constraint 'a = _ Graphql.Args.Input.t\n constraint 'a = _ Fields_derivers_graphql.Graphql_query.Input.t\n constraint 'a = _ Fields_derivers_js.Js_layout.Input.t\n end\n\n let yojson obj ?doc ~name ~js_type ~map ~contramap : _ Unified_input.t =\n (obj#graphql_fields :=\n let open Schema in\n Graphql.Fields.Input.T.\n { run =\n (fun () ->\n scalar name ?doc ~coerce:Yojson.Safe.to_basic |> non_null )\n } ) ;\n\n (obj#nullable_graphql_fields :=\n let open Schema in\n Graphql.Fields.Input.T.\n { run = (fun () -> scalar name ?doc ~coerce:Yojson.Safe.to_basic) } ) ;\n\n (obj#graphql_arg :=\n fun () ->\n Schema.Arg.scalar name ?doc ~coerce:Graphql.arg_to_yojson\n |> Schema.Arg.non_null ) ;\n\n (obj#nullable_graphql_arg :=\n fun () -> Schema.Arg.scalar name ?doc ~coerce:Graphql.arg_to_yojson ) ;\n\n obj#to_json := Fn.id ;\n\n obj#of_json := Fn.id ;\n\n obj#contramap := contramap ;\n\n obj#map := map ;\n\n obj#js_layout := Fields_derivers_js.Js_layout.leaf_type js_type ;\n\n Fields_derivers_graphql.Graphql_query.scalar obj\n\n let invalid_scalar_to_string = function\n | `Uint ->\n \"Uint\"\n | `Field ->\n \"Field\"\n | `Token_id ->\n \"Token_id\"\n | `Public_key ->\n \"Public_key\"\n | `Amount ->\n \"Amount\"\n | `Balance ->\n \"Balance\"\n | `Unit ->\n \"Unit\"\n | `Proof ->\n \"Proof\"\n | `Verification_key ->\n \"Verification_key\"\n | `Signature ->\n \"Signature\"\n\n let raise_invalid_scalar t s =\n failwith (\"Invalid rich scalar: \" ^ invalid_scalar_to_string t ^ \" \" ^ s)\n\n let except ~f v (x : string) = try f x with _ -> raise_invalid_scalar v x\n\n let iso_string ?doc ~name ~js_type obj ~(to_string : 'a -> string)\n ~(of_string : string -> 'a) =\n yojson obj ?doc ~name ~js_type\n ~map:(function\n | `String x ->\n of_string x\n | _ ->\n raise (Fields_derivers_json.Of_yojson.Invalid_json_scalar `String)\n )\n ~contramap:(fun x -> `String (to_string x))\n\n let uint64 obj : _ Unified_input.t =\n iso_string obj\n ~doc:\"Unsigned 64-bit integer represented as a string in base10\"\n ~name:\"UInt64\" ~js_type:UInt64 ~to_string:Unsigned.UInt64.to_string\n ~of_string:(except ~f:Unsigned.UInt64.of_string `Uint)\n\n let uint32 obj : _ Unified_input.t =\n iso_string obj\n ~doc:\"Unsigned 32-bit integer represented as a string in base10\"\n ~name:\"UInt32\" ~js_type:UInt32 ~to_string:Unsigned.UInt32.to_string\n ~of_string:(except ~f:Unsigned.UInt32.of_string `Uint)\n\n let field obj : _ Unified_input.t =\n iso_string obj ~name:\"Field\" ~js_type:Field\n ~doc:\"String representing an Fp Field element\" ~to_string:Field.to_string\n ~of_string:(except ~f:Field.of_string `Field)\n\n let public_key obj : _ Unified_input.t =\n iso_string obj ~name:\"PublicKey\" ~js_type:PublicKey\n ~doc:\"String representing a public key in base58\"\n ~to_string:Signature_lib.Public_key.Compressed.to_string\n ~of_string:\n (except ~f:Signature_lib.Public_key.Compressed.of_base58_check_exn\n `Public_key )\n\n let skip obj : _ Unified_input.t =\n let _a = Graphql.Fields.skip obj in\n let _b = Graphql.Args.skip obj in\n let _c = Fields_derivers_json.To_yojson.skip obj in\n let _d = Fields_derivers_graphql.Graphql_query.skip obj in\n let _e = Fields_derivers_js.Js_layout.skip obj in\n Fields_derivers_json.Of_yojson.skip obj\n\n let js_only (js_layout : _ Fields_derivers_js.Js_layout.Input.t -> 'a) obj :\n _ Unified_input.t =\n let _a = Graphql.Fields.skip obj in\n let _b = Graphql.Args.skip obj in\n let _c = Fields_derivers_json.To_yojson.skip obj in\n let _d = Fields_derivers_graphql.Graphql_query.skip obj in\n let _e = js_layout obj in\n Fields_derivers_json.Of_yojson.skip obj\n\n let js_leaf leaf obj =\n js_only Fields_derivers_js.Js_layout.(of_layout @@ leaf_type leaf) obj\n\n let js_record entries obj =\n js_only (Fields_derivers_js.Js_layout.record entries) obj\n\n let int obj : _ Unified_input.t =\n let _a = Graphql.Fields.int obj in\n let _b = Graphql.Args.int obj in\n let _c = Fields_derivers_json.To_yojson.int obj in\n let _d = Fields_derivers_graphql.Graphql_query.int obj in\n let _e = Fields_derivers_js.Js_layout.int obj in\n Fields_derivers_json.Of_yojson.int obj\n\n let string obj : _ Unified_input.t =\n let _a = Graphql.Fields.string obj in\n let _b = Graphql.Args.string obj in\n let _c = Fields_derivers_json.To_yojson.string obj in\n let _d = Fields_derivers_graphql.Graphql_query.string obj in\n let _e = Fields_derivers_js.Js_layout.string obj in\n Fields_derivers_json.Of_yojson.string obj\n\n let bool obj : _ Unified_input.t =\n let _a = Graphql.Fields.bool obj in\n let _b = Graphql.Args.bool obj in\n let _c = Fields_derivers_json.To_yojson.bool obj in\n let _d = Fields_derivers_graphql.Graphql_query.bool obj in\n let _e = Fields_derivers_js.Js_layout.bool obj in\n Fields_derivers_json.Of_yojson.bool obj\n\n let global_slot_since_genesis obj =\n iso_string obj ~name:\"GlobalSlotSinceGenesis\" ~js_type:UInt32\n ~to_string:Mina_numbers.Global_slot_since_genesis.to_string\n ~of_string:\n (except ~f:Mina_numbers.Global_slot_since_genesis.of_string `Uint)\n\n let global_slot_since_hard_fork obj =\n iso_string obj ~name:\"GlobalSlotSinceHardFork\" ~js_type:UInt32\n ~to_string:Mina_numbers.Global_slot_since_hard_fork.to_string\n ~of_string:\n (except ~f:Mina_numbers.Global_slot_since_hard_fork.of_string `Uint)\n\n let global_slot_span obj =\n iso_string obj ~name:\"GlobalSlotSpan\" ~js_type:UInt32\n ~to_string:Mina_numbers.Global_slot_span.to_string\n ~of_string:(except ~f:Mina_numbers.Global_slot_span.of_string `Uint)\n\n let amount obj =\n iso_string obj ~name:\"CurrencyAmount\" ~js_type:UInt64\n ~to_string:Currency.Amount.to_string\n ~of_string:(except ~f:Currency.Amount.of_string `Amount)\n\n let balance obj =\n iso_string obj ~name:\"Balance\" ~js_type:UInt64\n ~to_string:Currency.Balance.to_string\n ~of_string:(except ~f:Currency.Balance.of_string `Balance)\n\n let option (x : _ Unified_input.t) ~js_type obj : _ Unified_input.t =\n let _a = Graphql.Fields.option x obj in\n let _b = Graphql.Args.option x obj in\n let _c = Fields_derivers_json.To_yojson.option x obj in\n let _d = Fields_derivers_graphql.Graphql_query.option x obj in\n let _e = Fields_derivers_js.Js_layout.option ~js_type x obj in\n Fields_derivers_json.Of_yojson.option x obj\n\n let list ?(static_length : int option) (x : _ Unified_input.t) obj :\n _ Unified_input.t =\n let _a = Graphql.Fields.list x obj in\n let _b = Graphql.Args.list x obj in\n let _c = Fields_derivers_json.To_yojson.list x obj in\n let _d = Fields_derivers_graphql.Graphql_query.list x obj in\n let _e = Fields_derivers_js.Js_layout.list ?static_length x obj in\n Fields_derivers_json.Of_yojson.list x obj\n\n let iso ~map ~contramap (x : _ Unified_input.t) obj : _ Unified_input.t =\n let _a = Graphql.Fields.contramap ~f:contramap x obj in\n let _b = Graphql.Args.map ~f:map x obj in\n let _c = Fields_derivers_json.To_yojson.contramap ~f:contramap x obj in\n let _d = Fields_derivers_graphql.Graphql_query.wrapped x obj in\n let _e = Fields_derivers_js.Js_layout.wrapped x obj in\n Fields_derivers_json.Of_yojson.map ~f:map x obj\n\n let iso_record ~of_record ~to_record record_deriver obj =\n iso ~map:of_record ~contramap:to_record (record_deriver @@ o ()) obj\n\n let array inner obj : _ Unified_input.t =\n iso ~map:Array.of_list ~contramap:Array.to_list\n ((list @@ inner @@ o ()) (o ()))\n obj\n\n let add_field ?skip_data ~t_fields_annots (x : _ Unified_input.t) fd acc =\n let _, acc' = Graphql.Fields.add_field ~t_fields_annots x fd acc in\n let c1, acc'' =\n Graphql.Args.add_field ?skip_data ~t_fields_annots x fd acc'\n in\n let _, acc''' =\n Fields_derivers_json.To_yojson.add_field ~t_fields_annots x fd acc''\n in\n let c2, acc'''' =\n Fields_derivers_json.Of_yojson.add_field ?skip_data ~t_fields_annots x fd\n acc'''\n in\n let _, acc''''' =\n Fields_derivers_graphql.Graphql_query.add_field ~t_fields_annots x fd\n acc''''\n in\n let _, acc'''''' =\n Fields_derivers_js.Js_layout.add_field ~t_fields_annots x fd acc'''''\n in\n ((function `Left x -> c1 x | `Right x -> c2 x), acc'''''')\n\n let ( !. ) ?skip_data x fd acc = add_field ?skip_data (x @@ o ()) fd acc\n\n let finish name ~t_toplevel_annots (f, acc) =\n let _a =\n Graphql.Fields.finish name ~t_toplevel_annots ((fun x -> f (`Left x)), acc)\n in\n let _b =\n Graphql.Args.finish name ~t_toplevel_annots ((fun x -> f (`Left x)), acc)\n in\n let _c =\n Fields_derivers_json.To_yojson.finish ((fun x -> f (`Right x)), acc)\n in\n let _d =\n Fields_derivers_graphql.Graphql_query.finish ((fun x -> f (`Left x)), acc)\n in\n let _e =\n Fields_derivers_js.Js_layout.finish name ~t_toplevel_annots\n ((fun x -> f (`Left x)), acc)\n in\n Fields_derivers_json.Of_yojson.finish ((fun x -> f (`Right x)), acc)\n\n let needs_custom_js ~js_type ~name deriver obj =\n Fields_derivers_js.Js_layout.needs_custom_js ~name\n (js_type @@ o ())\n (deriver obj)\n\n let balance_change obj =\n let sign_to_string = function\n | Sgn.Pos ->\n \"Positive\"\n | Sgn.Neg ->\n \"Negative\"\n in\n let sign_of_string = function\n | \"Positive\" ->\n Sgn.Pos\n | \"Negative\" ->\n Sgn.Neg\n | _ ->\n failwith \"impossible\"\n in\n let sign_deriver =\n iso_string ~name:\"Sign\" ~js_type:Sign ~to_string:sign_to_string\n ~of_string:sign_of_string\n in\n let ( !. ) = ( !. ) ~t_fields_annots:Currency.Signed_poly.t_fields_annots in\n Currency.Signed_poly.Fields.make_creator obj ~magnitude:!.amount\n ~sgn:!.sign_deriver\n |> finish \"BalanceChange\"\n ~t_toplevel_annots:Currency.Signed_poly.t_toplevel_annots\n\n let to_json obj x = !(obj#to_json) @@ !(obj#contramap) x\n\n let of_json obj x = !(obj#map) @@ !(obj#of_json) x\n\n let js_layout deriver = !((deriver @@ o ())#js_layout)\n\n let typ obj = !(obj#graphql_fields).Graphql.Fields.Input.T.run ()\n\n let arg_typ obj = !(obj#graphql_arg) ()\n\n let inner_query obj = Fields_derivers_graphql.Graphql_query.inner_query obj\n\n let rec json_to_safe : Yojson.Basic.t -> Yojson.Safe.t = function\n | `Assoc kv ->\n `Assoc (List.map kv ~f:(fun (k, v) -> (k, json_to_safe v)))\n | `Bool b ->\n `Bool b\n | `Float f ->\n `Float f\n | `Int i ->\n `Int i\n | `List xs ->\n `List (List.map xs ~f:json_to_safe)\n | `Null ->\n `Null\n | `String s ->\n `String s\n\n (* TODO: remove this or move to a %test_module once the deriver code is stable *)\n (* Can be used to print the graphql schema, like this:\n Fields_derivers_zkapps.Test.print_schema full ;\n *)\n module Test = struct\n module M = struct\n let ( let* ) = Schema.Io.bind\n\n let return = Schema.Io.return\n end\n\n let print_schema (full : _ Unified_input.t) =\n let typ = !(full#graphql_fields).run () in\n let query_top_level =\n Schema.(\n field \"query\" ~typ:(non_null typ)\n ~args:Arg.[]\n ~doc:\"sample query\"\n ~resolve:(fun _ _ -> ()))\n in\n let schema =\n Schema.(schema [ query_top_level ] ~mutations:[] ~subscriptions:[])\n in\n let res : 'a Schema.Io.t =\n Schema.execute schema ()\n (Fields_derivers_graphql.Test.introspection_query ())\n in\n let open Schema.Io in\n bind res (function\n | Ok (`Response data) ->\n data |> Yojson.Basic.to_string |> printf \"%s\" |> return\n | _ ->\n failwith \"Unexpected response\" )\n\n module Loop = struct\n let rec json_to_string_gql : Yojson.Safe.t -> string = function\n | `Assoc kv ->\n sprintf \"{\\n%s\\n}\"\n ( List.map kv ~f:(fun (k, v) ->\n sprintf \"%s: %s\"\n (Fields_derivers.under_to_camel k)\n (json_to_string_gql v) )\n |> String.concat ~sep:\",\\n\" )\n | `List xs ->\n sprintf \"[\\n%s\\n]\"\n (List.map xs ~f:json_to_string_gql |> String.concat ~sep:\",\\n\")\n | x ->\n Yojson.Safe.to_string x\n\n let arg_query json =\n Printf.sprintf\n {graphql|query LoopIn {\n arg(\n input : %s\n )\n }|graphql}\n (json_to_string_gql json)\n\n let out_query keys =\n Printf.sprintf\n {graphql|\n query LoopOut {\n out %s\n }\n |graphql}\n keys\n\n let run deriver (a : 'a) =\n let schema =\n let in_schema : ('a option ref, unit) Schema.field =\n Schema.(\n field \"arg\" ~typ:(non_null int)\n ~args:Arg.[ arg \"input\" ~typ:(arg_typ deriver) ]\n ~doc:\"sample args query\"\n ~resolve:(fun { ctx; _ } () (input : 'a) ->\n ctx := Some input ;\n 0 ))\n in\n let out_schema : ('a option ref, unit) Schema.field =\n Schema.(\n field \"out\" ~typ:(typ deriver)\n ~args:Arg.[]\n ~doc:\"sample query\"\n ~resolve:(fun { ctx; _ } () -> Option.value_exn !ctx))\n in\n Schema.(\n schema [ in_schema; out_schema ] ~mutations:[] ~subscriptions:[])\n in\n let ctx = ref None in\n let open M in\n let run_query q =\n let x = Graphql_parser.parse q in\n match x with\n | Ok res ->\n Schema.execute schema ctx res\n | Error err ->\n failwithf \"Failed to parse query: %s %s\" q err ()\n in\n (* send json in *)\n let* () =\n let json = to_json deriver a in\n let q = arg_query json in\n let* res = run_query q in\n match res with\n | Ok (`Response _) ->\n return @@ ()\n | Error e ->\n failwithf \"Unexpected response in: %s\"\n (e |> Yojson.Basic.to_string)\n ()\n | _ ->\n failwith \"Unexpected stream in\"\n in\n (* get query *)\n let inner_query =\n Option.value_exn\n (Fields_derivers_graphql.Graphql_query.inner_query deriver)\n in\n (* read json out *)\n let* a' =\n let* res = run_query (out_query inner_query) in\n match res with\n | Ok (`Response json) ->\n let unwrap k json =\n match json with\n | `Assoc kv ->\n List.Assoc.find_exn kv ~equal:String.equal k\n | _ ->\n failwithf \"Expected wrapping %s\" k ()\n in\n let inner = json |> unwrap \"data\" |> unwrap \"out\" in\n of_json deriver (json_to_safe inner) |> return\n | Error e ->\n failwithf \"Unexpected response out: %s\"\n (e |> Yojson.Basic.to_string)\n ()\n | _ ->\n failwith \"Unexpected stream out\"\n in\n [%test_eq: string]\n (Yojson.Safe.to_string (to_json deriver a))\n (Yojson.Safe.to_string (to_json deriver a')) ;\n return ()\n end\n end\nend\n\nmodule Derivers = Make (Fields_derivers_graphql.Schema)\ninclude Derivers\nmodule Js_layout = Fields_derivers_js.Js_layout\n\n[%%ifdef consensus_mechanism]\n\nlet proof obj : _ Unified_input.t =\n let of_string s =\n match Pickles.Side_loaded.Proof.of_base64 s with\n | Ok proof ->\n proof\n | Error _err ->\n raise_invalid_scalar `Proof s\n in\n iso_string obj ~name:\"ZkappProof\" ~js_type:String\n ~to_string:Pickles.Side_loaded.Proof.to_base64 ~of_string\n\nlet verification_key_with_hash obj =\n let verification_key obj =\n let of_string s =\n match Pickles.Side_loaded.Verification_key.of_base64 s with\n | Ok vk ->\n vk\n | Error _err ->\n raise_invalid_scalar `Verification_key s\n in\n Pickles.Side_loaded.Verification_key.(\n iso_string obj ~name:\"VerificationKey\" ~js_type:String\n ~to_string:to_base64 ~of_string ~doc:\"Verification key in Base64 format\")\n in\n let ( !. ) =\n ( !. ) ~t_fields_annots:With_hash.Stable.Latest.t_fields_annots\n in\n With_hash.Stable.Latest.Fields.make_creator ~data:!.verification_key\n ~hash:!.field obj\n |> finish \"VerificationKeyWithHash\"\n ~t_toplevel_annots:With_hash.Stable.Latest.t_toplevel_annots\n\nlet%test_unit \"verification key with hash, roundtrip json\" =\n let open Pickles.Side_loaded.Verification_key in\n (* we do this because the dummy doesn't have a wrap_vk on it *)\n let data = dummy |> to_base58_check |> of_base58_check_exn in\n let v = { With_hash.data; hash = Field.one } in\n let o = verification_key_with_hash @@ o () in\n [%test_eq: (t, Field.t) With_hash.t] v (of_json o (to_json o v))\n\n[%%endif]\n\nlet%test_module \"Test\" =\n ( module struct\n module IO = struct\n type +'a t = 'a\n\n let bind t f = f t\n\n let return t = t\n\n module Stream = struct\n type 'a t = 'a Seq.t\n\n let map t f = Seq.map f t\n\n let iter t f = Seq.iter f t\n\n let close _t = ()\n end\n end\n\n module Field_error = struct\n type t = string\n\n let message_of_field_error t = t\n\n let extensions_of_field_error _t = None\n end\n\n module Schema = Graphql_schema.Make (IO) (Field_error)\n module Derivers = Make (Schema)\n include Derivers\n module Public_key = Signature_lib.Public_key.Compressed\n\n module Or_ignore_test = struct\n type 'a t = Check of 'a | Ignore [@@deriving compare, sexp, equal]\n\n let of_option = function None -> Ignore | Some x -> Check x\n\n let to_option = function Ignore -> None | Check x -> Some x\n\n let to_yojson a x = [%to_yojson: 'a option] a (to_option x)\n\n let of_yojson a x = Result.map ~f:of_option ([%of_yojson: 'a option] a x)\n\n let derived inner init =\n iso ~map:of_option ~contramap:to_option\n ((option ~js_type:Flagged_option @@ inner @@ o ()) (o ()))\n init\n end\n\n module V = struct\n type t =\n { foo : int\n ; foo1 : Unsigned_extended.UInt64.t\n ; bar : Unsigned_extended.UInt64.t Or_ignore_test.t\n ; baz : Unsigned_extended.UInt32.t list\n }\n [@@deriving annot, compare, sexp, equal, fields, yojson]\n\n let v =\n { foo = 1\n ; foo1 = Unsigned.UInt64.of_int 10\n ; bar = Or_ignore_test.Check (Unsigned.UInt64.of_int 10)\n ; baz = Unsigned.UInt32.[ of_int 11; of_int 12 ]\n }\n\n let ( !. ) = ( !. ) ~t_fields_annots\n\n let derivers obj =\n Fields.make_creator obj ~foo:!.int ~foo1:!.uint64\n ~bar:!.(Or_ignore_test.derived uint64)\n ~baz:!.(list @@ uint32 @@ o ())\n |> finish \"V\" ~t_toplevel_annots\n end\n\n let v1 = V.derivers @@ o ()\n\n let%test_unit \"full roundtrips\" = Test.Loop.run v1 V.v\n\n module V2 = struct\n type t = { field : Field.t; nothing : unit [@skip] }\n [@@deriving annot, compare, sexp, equal, fields]\n\n let v = { field = Field.of_int 10; nothing = () }\n\n let derivers obj =\n let open Derivers in\n let ( !. ) ?skip_data = ( !. ) ?skip_data ~t_fields_annots in\n Fields.make_creator obj ~field:!.field\n ~nothing:(( !. ) ~skip_data:() skip)\n |> finish \"V2\" ~t_toplevel_annots\n end\n\n let v2 = V2.derivers @@ Derivers.o ()\n\n let%test_unit \"to_json'\" =\n let open Derivers in\n [%test_eq: string]\n (Yojson.Safe.to_string (to_json v2 V2.v))\n {|{\"field\":\"10\"}|}\n\n let%test_unit \"roundtrip json'\" =\n let open Derivers in\n [%test_eq: V2.t] (of_json v2 (to_json v2 V2.v)) V2.v\n\n module V3 = struct\n type t = { public_key : Public_key.t }\n [@@deriving annot, compare, sexp, equal, fields]\n\n let v =\n { public_key =\n Public_key.of_base58_check_exn\n \"B62qoTqMG41DFgkyQmY2Pos1x671Gfzs9k8NKqUdSg7wQasEV6qnXQP\"\n }\n\n let derivers obj =\n let open Derivers in\n let ( !. ) = ( !. ) ~t_fields_annots in\n Fields.make_creator obj ~public_key:!.public_key\n |> finish \"V3\" ~t_toplevel_annots\n end\n\n let v3 = V3.derivers @@ Derivers.o ()\n\n let%test_unit \"to_json'\" =\n let open Derivers in\n [%test_eq: string]\n (Yojson.Safe.to_string (to_json v3 V3.v))\n {|{\"publicKey\":\"B62qoTqMG41DFgkyQmY2Pos1x671Gfzs9k8NKqUdSg7wQasEV6qnXQP\"}|}\n\n let%test_unit \"roundtrip json'\" =\n let open Derivers in\n [%test_eq: V3.t] (of_json v3 (to_json v3 V3.v)) V3.v\n end )\n","(* state_hash.ml -- defines the type for the protocol state hash *)\n\n[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Snark_params.Tick\n\ninclude Data_hash.Make_full_size (struct\n let version_byte = Base58_check.Version_bytes.state_hash\n\n let description = \"State hash\"\nend)\n\nlet dummy = of_hash Outside_hash_image.t\n\n[%%ifdef consensus_mechanism]\n\nlet zero = dummy\n\n[%%else]\n\n(* in the nonconsensus world, we don't have the Pedersen machinery available,\n so just inline the value for zero\n*)\nlet zero = Field.of_string \"0\"\n\n[%%endif]\n\nlet raw_hash_bytes = to_bytes\n\nlet to_bytes = `Use_to_base58_check_or_raw_hash_bytes\n\nlet to_decimal_string = to_decimal_string\n\nlet of_decimal_string = of_decimal_string\n\n(* Data hash versioned boilerplate below *)\n\n[%%versioned\nmodule Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n module T = struct\n type t = (Field.t[@version_asserted]) [@@deriving sexp, compare, hash]\n end\n\n include T\n\n let to_latest = Fn.id\n\n [%%define_from_scope to_yojson, of_yojson]\n\n include Comparable.Make (T)\n include Hashable.Make_binable (T)\n end\nend]\n\nlet (_ : (t, Stable.Latest.t) Type_equal.t) = Type_equal.T\n\nlet deriver obj =\n Fields_derivers_zkapps.(\n iso_string ~name:\"StateHash\" ~js_type:Field ~to_string:to_base58_check\n ~of_string:of_base58_check_exn\n |> needs_custom_js ~name:\"StateHash\" ~js_type:field)\n obj\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\n\nmodule Proof_level = struct\n type t = Full | Check | None [@@deriving bin_io_unversioned, equal]\n\n let to_string = function Full -> \"full\" | Check -> \"check\" | None -> \"none\"\n\n let of_string = function\n | \"full\" ->\n Full\n | \"check\" ->\n Check\n | \"none\" ->\n None\n | s ->\n failwithf \"unrecognised proof level %s\" s ()\n\n [%%inject \"compiled\", proof_level]\n\n let compiled = of_string compiled\n\n let for_unit_tests = Check\nend\n\nmodule Fork_constants = struct\n type t =\n { previous_state_hash : Pickles.Backend.Tick.Field.Stable.Latest.t\n ; previous_length : Mina_numbers.Length.Stable.Latest.t\n ; previous_global_slot :\n Mina_numbers.Global_slot_since_genesis.Stable.Latest.t\n }\n [@@deriving bin_io_unversioned, sexp, equal, compare, yojson]\nend\n\n(** Constants that affect the constraint systems for proofs (and thus also key\n generation).\n\n Care must be taken to ensure that these match against the proving/\n verification keys when [proof_level=Full], otherwise generated proofs will\n be invalid.\n*)\nmodule Constraint_constants = struct\n type t =\n { sub_windows_per_window : int\n ; ledger_depth : int\n ; work_delay : int\n ; block_window_duration_ms : int\n ; transaction_capacity_log_2 : int\n ; pending_coinbase_depth : int\n ; coinbase_amount : Currency.Amount.Stable.Latest.t\n ; supercharged_coinbase_factor : int\n ; account_creation_fee : Currency.Fee.Stable.Latest.t\n ; fork : Fork_constants.t option\n }\n [@@deriving bin_io_unversioned, sexp, equal, compare, yojson]\n\n let to_snark_keys_header (t : t) : Snark_keys_header.Constraint_constants.t =\n { sub_windows_per_window = t.sub_windows_per_window\n ; ledger_depth = t.ledger_depth\n ; work_delay = t.work_delay\n ; block_window_duration_ms = t.block_window_duration_ms\n ; transaction_capacity = Log_2 t.transaction_capacity_log_2\n ; pending_coinbase_depth = t.pending_coinbase_depth\n ; coinbase_amount = Currency.Amount.to_uint64 t.coinbase_amount\n ; supercharged_coinbase_factor = t.supercharged_coinbase_factor\n ; account_creation_fee = Currency.Fee.to_uint64 t.account_creation_fee\n ; fork =\n ( match t.fork with\n | Some { previous_length; previous_state_hash; previous_global_slot } ->\n Some\n { previous_length = Unsigned.UInt32.to_int previous_length\n ; previous_state_hash =\n Pickles.Backend.Tick.Field.to_string previous_state_hash\n ; previous_global_slot =\n Unsigned.UInt32.to_int\n (Mina_numbers.Global_slot_since_genesis.to_uint32\n previous_global_slot )\n }\n | None ->\n None )\n }\n\n (* Generate the compile-time constraint constants, using a signature to hide\n the optcomp constants that we import.\n *)\n include (\n struct\n [%%ifdef consensus_mechanism]\n\n [%%inject \"sub_windows_per_window\", sub_windows_per_window]\n\n [%%else]\n\n (* Invalid value, this should not be used by nonconsensus nodes. *)\n let sub_windows_per_window = -1\n\n [%%endif]\n\n [%%inject \"ledger_depth\", ledger_depth]\n\n [%%inject \"coinbase_amount_string\", coinbase]\n\n [%%inject \"account_creation_fee_string\", account_creation_fee_int]\n\n (** All the proofs before the last [work_delay] blocks must be\n completed to add transactions. [work_delay] is the minimum number\n of blocks and will increase if the throughput is less.\n - If [work_delay = 0], all the work that was added to the scan\n state in the previous block is expected to be completed and\n included in the current block if any transactions/coinbase are to\n be included.\n - [work_delay >= 1] means that there's at least two block times for\n completing the proofs.\n *)\n\n [%%inject \"work_delay\", scan_state_work_delay]\n\n [%%inject \"block_window_duration_ms\", block_window_duration]\n\n [%%if scan_state_with_tps_goal]\n\n [%%inject \"tps_goal_x10\", scan_state_tps_goal_x10]\n\n let max_coinbases = 2\n\n (* block_window_duration is in milliseconds, so divide by 1000 divide\n by 10 again because we have tps * 10\n *)\n let max_user_commands_per_block =\n tps_goal_x10 * block_window_duration_ms / (1000 * 10)\n\n (** Log of the capacity of transactions per transition.\n - 1 will only work if we don't have prover fees.\n - 2 will work with prover fees, but not if we want a transaction\n included in every block.\n - At least 3 ensures a transaction per block and the staged-ledger\n unit tests pass.\n *)\n let transaction_capacity_log_2 =\n 1\n + Core_kernel.Int.ceil_log2 (max_user_commands_per_block + max_coinbases)\n\n [%%else]\n\n [%%inject\n \"transaction_capacity_log_2\", scan_state_transaction_capacity_log_2]\n\n [%%endif]\n\n [%%inject \"supercharged_coinbase_factor\", supercharged_coinbase_factor]\n\n let pending_coinbase_depth =\n Core_kernel.Int.ceil_log2\n (((transaction_capacity_log_2 + 1) * (work_delay + 1)) + 1)\n\n [%%ifndef fork_previous_length]\n\n let fork = None\n\n [%%else]\n\n [%%inject \"fork_previous_length\", fork_previous_length]\n\n [%%inject \"fork_previous_state_hash\", fork_previous_state_hash]\n\n [%%inject \"fork_previous_global_slot\", fork_previous_global_slot]\n\n let fork =\n Some\n { Fork_constants.previous_length =\n Mina_numbers.Length.of_int fork_previous_length\n ; previous_state_hash =\n Data_hash_lib.State_hash.of_base58_check_exn\n fork_previous_state_hash\n ; previous_global_slot =\n Mina_numbers.Global_slot_since_genesis.of_int\n fork_previous_global_slot\n }\n\n [%%endif]\n\n let compiled =\n { sub_windows_per_window\n ; ledger_depth\n ; work_delay\n ; block_window_duration_ms\n ; transaction_capacity_log_2\n ; pending_coinbase_depth\n ; coinbase_amount =\n Currency.Amount.of_mina_string_exn coinbase_amount_string\n ; supercharged_coinbase_factor\n ; account_creation_fee =\n Currency.Fee.of_mina_string_exn account_creation_fee_string\n ; fork\n }\n end :\n sig\n val compiled : t\n end )\n\n let for_unit_tests = compiled\nend\n\n(*Constants that can be specified for generating the base proof (that are not required for key-generation) in runtime_genesis_ledger.exe and that can be configured at runtime.\n The types are defined such that this module doesn't depend on any of the coda libraries (except blake2 and module_version) to avoid dependency cycles.\n TODO: #4659 move key generation to runtime_genesis_ledger.exe to include scan_state constants, consensus constants (c and block_window_duration) and ledger depth here*)\n\nlet genesis_timestamp_of_string str =\n let default_zone = Time.Zone.of_utc_offset ~hours:(-8) in\n Time.of_string_gen\n ~find_zone:(fun _ -> assert false)\n ~default_zone:(fun () -> default_zone)\n str\n\nlet of_time t = Time.to_span_since_epoch t |> Time.Span.to_ms |> Int64.of_float\n\nlet validate_time time_str =\n match\n Result.try_with (fun () ->\n Option.value_map ~default:(Time.now ()) ~f:genesis_timestamp_of_string\n time_str )\n with\n | Ok time ->\n Ok (of_time time)\n | Error _ ->\n Error\n \"Invalid timestamp. Please specify timestamp in \\\"%Y-%m-%d \\\n %H:%M:%S%z\\\". For example, \\\"2019-01-30 12:00:00-0800\\\" for UTC-08:00 \\\n timezone\"\n\nlet genesis_timestamp_to_string time =\n Int64.to_float time |> Time.Span.of_ms |> Time.of_span_since_epoch\n |> Time.to_string_iso8601_basic ~zone:(Time.Zone.of_utc_offset ~hours:(-8))\n\n(*Protocol constants required for consensus and snarks. Consensus constants is generated using these*)\nmodule Protocol = struct\n module Poly = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type ('length, 'delta, 'genesis_state_timestamp) t =\n ( 'length\n , 'delta\n , 'genesis_state_timestamp )\n Mina_wire_types.Genesis_constants.Protocol.Poly.V1.t =\n { k : 'length\n ; slots_per_epoch : 'length\n ; slots_per_sub_window : 'length\n ; delta : 'delta\n ; genesis_state_timestamp : 'genesis_state_timestamp\n }\n [@@deriving equal, ord, hash, sexp, yojson, hlist, fields]\n end\n end]\n end\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = (int, int, (Int64.t[@version_asserted])) Poly.Stable.V1.t\n [@@deriving equal, ord, hash]\n\n let to_latest = Fn.id\n\n let to_yojson (t : t) =\n `Assoc\n [ (\"k\", `Int t.k)\n ; (\"slots_per_epoch\", `Int t.slots_per_epoch)\n ; (\"slots_per_sub_window\", `Int t.slots_per_sub_window)\n ; (\"delta\", `Int t.delta)\n ; ( \"genesis_state_timestamp\"\n , `String\n (Time.to_string_abs\n (Time.of_span_since_epoch\n (Time.Span.of_ms\n (Int64.to_float t.genesis_state_timestamp) ) )\n ~zone:Time.Zone.utc ) )\n ]\n\n let of_yojson = function\n | `Assoc\n [ (\"k\", `Int k)\n ; (\"slots_per_epoch\", `Int slots_per_epoch)\n ; (\"slots_per_sub_window\", `Int slots_per_sub_window)\n ; (\"delta\", `Int delta)\n ; (\"genesis_state_timestamp\", `String time_str)\n ] -> (\n match validate_time time_str with\n | Ok genesis_state_timestamp ->\n Ok\n { Poly.k\n ; slots_per_epoch\n ; slots_per_sub_window\n ; delta\n ; genesis_state_timestamp\n }\n | Error e ->\n Error (sprintf !\"Genesis_constants.Protocol.of_yojson: %s\" e) )\n | _ ->\n Error \"Genesis_constants.Protocol.of_yojson: unexpected JSON\"\n\n let t_of_sexp _ = failwith \"t_of_sexp: not implemented\"\n\n let sexp_of_t (t : t) =\n let module T = struct\n type t = (int, int, string) Poly.Stable.V1.t [@@deriving sexp]\n end in\n let t' : T.t =\n { k = t.k\n ; delta = t.delta\n ; slots_per_epoch = t.slots_per_epoch\n ; slots_per_sub_window = t.slots_per_sub_window\n ; genesis_state_timestamp =\n Time.to_string_abs\n (Time.of_span_since_epoch\n (Time.Span.of_ms (Int64.to_float t.genesis_state_timestamp)) )\n ~zone:Time.Zone.utc\n }\n in\n T.sexp_of_t t'\n end\n end]\n\n [%%define_locally Stable.Latest.(to_yojson)]\nend\n\nmodule T = struct\n (* bin_io is for printing chain id inputs *)\n type t =\n { protocol : Protocol.Stable.Latest.t\n ; txpool_max_size : int\n ; num_accounts : int option\n ; zkapp_proof_update_cost : float\n ; zkapp_signed_single_update_cost : float\n ; zkapp_signed_pair_update_cost : float\n ; zkapp_transaction_cost_limit : float\n ; max_event_elements : int\n ; max_action_elements : int\n }\n [@@deriving to_yojson, sexp_of, bin_io_unversioned]\n\n let hash (t : t) =\n let str =\n ( List.map\n (* TODO: *)\n [ t.protocol.k\n ; t.protocol.slots_per_epoch\n ; t.protocol.slots_per_sub_window\n ; t.protocol.delta\n ; t.txpool_max_size\n ]\n ~f:Int.to_string\n |> String.concat ~sep:\"\" )\n ^ Time.to_string_abs ~zone:Time.Zone.utc\n (Time.of_span_since_epoch\n (Time.Span.of_ms\n (Int64.to_float t.protocol.genesis_state_timestamp) ) )\n in\n Blake2.digest_string str |> Blake2.to_hex\nend\n\ninclude T\n\n[%%inject \"genesis_state_timestamp_string\", genesis_state_timestamp]\n\n[%%inject \"k\", k]\n\n[%%inject \"slots_per_epoch\", slots_per_epoch]\n\n[%%inject \"slots_per_sub_window\", slots_per_sub_window]\n\n[%%inject \"delta\", delta]\n\n[%%inject \"pool_max_size\", pool_max_size]\n\nlet compiled : t =\n { protocol =\n { k\n ; slots_per_epoch\n ; slots_per_sub_window\n ; delta\n ; genesis_state_timestamp =\n genesis_timestamp_of_string genesis_state_timestamp_string |> of_time\n }\n ; txpool_max_size = pool_max_size\n ; num_accounts = None\n ; zkapp_proof_update_cost = Mina_compile_config.zkapp_proof_update_cost\n ; zkapp_signed_single_update_cost =\n Mina_compile_config.zkapp_signed_single_update_cost\n ; zkapp_signed_pair_update_cost =\n Mina_compile_config.zkapp_signed_pair_update_cost\n ; zkapp_transaction_cost_limit =\n Mina_compile_config.zkapp_transaction_cost_limit\n ; max_event_elements = Mina_compile_config.max_event_elements\n ; max_action_elements = Mina_compile_config.max_action_elements\n }\n\nlet for_unit_tests = compiled\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Snark_params\nopen Tick\nopen Unsigned_extended\nopen Snark_bits\n\n(** See documentation of the {!Mina_wire_types} library *)\nmodule Wire_types = Mina_wire_types.Block_time\n\nmodule Make_sig (A : Wire_types.Types.S) = struct\n module type S = Intf.S with type Time.t = A.V1.t\nend\n\nmodule Make_str (_ : Wire_types.Concrete) = struct\n module Time = struct\n (* Milliseconds since epoch *)\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = UInt64.Stable.V1.t\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n\n module T = struct\n type typ = t [@@deriving sexp, compare, hash]\n\n type t = typ [@@deriving sexp, compare, hash]\n end\n\n include Hashable.Make (T)\n end\n end]\n\n let max_value = UInt64.max_int\n\n let zero = UInt64.zero\n\n module Controller = struct\n [%%if time_offsets]\n\n type t = unit -> Time.Span.t [@@deriving sexp]\n\n (* NB: All instances are identical by construction (see basic below). *)\n let equal _ _ = true\n\n (* NB: All instances are identical by construction (see basic below). *)\n let compare _ _ = 0\n\n let time_offset = ref None\n\n let setting_enabled = ref None\n\n let disable_setting_offset () = setting_enabled := Some false\n\n let enable_setting_offset () =\n match !setting_enabled with\n | None ->\n setting_enabled := Some true\n | Some true ->\n ()\n | Some false ->\n failwith\n \"Cannot enable time offset mutations; it has been explicitly \\\n disabled\"\n\n let set_time_offset offset =\n match !setting_enabled with\n | Some true ->\n time_offset := Some offset\n | None | Some false ->\n failwith \"Cannot mutate the time offset\"\n\n let create offset = offset\n\n let basic ~logger:_ () =\n match !time_offset with\n | Some offset ->\n offset\n | None ->\n let offset =\n let env = \"MINA_TIME_OFFSET\" in\n let env_offset =\n match Core_kernel.Sys.getenv_opt env with\n | Some tm ->\n Int.of_string tm\n | None ->\n let default = 0 in\n eprintf\n \"Environment variable %s not found, using default of %d\\n\\\n %!\"\n env default ;\n default\n in\n Core_kernel.Time.Span.of_int_sec env_offset\n in\n time_offset := Some offset ;\n offset\n\n let get_time_offset ~logger = basic ~logger ()\n\n [%%else]\n\n type t = unit [@@deriving sexp, equal, compare]\n\n let create () = ()\n\n let basic ~logger:_ = ()\n\n let disable_setting_offset () = ()\n\n let enable_setting_offset () = ()\n\n let set_time_offset _ = failwith \"Cannot mutate the time offset\"\n\n let get_time_offset _ = Core_kernel.Time.Span.of_int_sec 0\n\n [%%endif]\n end\n\n module B = Bits\n module Bits = Bits.UInt64\n include B.Snarkable.UInt64 (Tick)\n module N = Mina_numbers.Nat.Make_checked (UInt64) (Bits)\n\n let to_input (t : t) =\n Random_oracle_input.Chunked.packed\n (Tick.Field.project (Bits.to_bits t), 64)\n\n module Checked = struct\n type t = N.var\n\n module Unsafe = N.Unsafe\n\n let to_input (t : t) = N.to_input t\n\n let to_field = N.to_field\n\n [%%define_locally N.(typ, ( = ), ( <= ), ( >= ), ( < ), ( > ))]\n end\n\n module Span = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = UInt64.Stable.V1.t\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n module Bits = B.UInt64\n include B.Snarkable.UInt64 (Tick)\n\n let of_time_span s = UInt64.of_int64 (Int64.of_float (Time.Span.to_ms s))\n\n let to_time_span s = Time.Span.of_ms (Int64.to_float (UInt64.to_int64 s))\n\n let to_time_ns_span s =\n Time_ns.Span.of_ms (Int64.to_float (UInt64.to_int64 s))\n\n let of_time_ns_span ns : t =\n let int64_ns = ns |> Time_ns.Span.to_int63_ns |> Int63.to_int64 in\n (* convert to milliseconds *)\n Int64.(int64_ns / 1_000_000L) |> UInt64.of_int64\n\n let to_string_hum s = to_time_ns_span s |> Time_ns.Span.to_string_hum\n\n let to_ms = UInt64.to_int64\n\n let of_ms = UInt64.of_int64\n\n [%%define_locally UInt64.Infix.(( + ), ( - ), ( * ))]\n\n [%%define_locally UInt64.(( < ), ( > ), ( = ), ( <= ), ( >= ), min, zero)]\n\n let to_input = to_input\n\n module Checked = Checked\n end\n\n include Comparable.Make (Stable.Latest)\n include Hashable.Make (Stable.Latest)\n\n let of_time t =\n UInt64.of_int64\n (Int64.of_float (Time.Span.to_ms (Time.to_span_since_epoch t)))\n\n (* TODO: Time.t can't hold the full uint64 range, so this can fail for large t *)\n let to_time_exn t =\n let t_int64 = UInt64.to_int64 t in\n if Int64.(t_int64 < zero) then failwith \"converting to negative timestamp\" ;\n Time.of_span_since_epoch (Time.Span.of_ms (Int64.to_float t_int64))\n\n [%%if time_offsets]\n\n let now offset = of_time (Time.sub (Time.now ()) (offset ()))\n\n [%%else]\n\n let now _ = of_time (Time.now ())\n\n [%%endif]\n\n let field_var_to_unpacked (x : Tick.Field.Var.t) =\n Tick.Field.Checked.unpack ~length:64 x\n\n let epoch = of_time Time.epoch\n\n let add x y = UInt64.add x y\n\n let diff x y = UInt64.sub x y\n\n let sub x y = UInt64.sub x y\n\n let to_span_since_epoch t = diff t epoch\n\n let of_span_since_epoch s = UInt64.add s epoch\n\n let diff_checked x y =\n let pack = Tick.Field.Var.project in\n Span.unpack_var Tick.Field.Checked.(pack x - pack y)\n\n let modulus t span = UInt64.rem t span\n\n let unpacked_to_number var =\n let bits = Span.Unpacked.var_to_bits var in\n Number.of_bits (bits :> Boolean.var list)\n\n let to_int64 = Fn.compose Span.to_ms to_span_since_epoch\n\n let of_int64 = Fn.compose of_span_since_epoch Span.of_ms\n\n let of_uint64 : UInt64.t -> t = of_span_since_epoch\n\n let to_uint64 : t -> UInt64.t = to_span_since_epoch\n\n (* TODO: this can fail if the input has more than 63 bits, because it would be serialized to a negative number string *)\n let to_string_exn t =\n let t_int64 = UInt64.to_int64 t in\n if Int64.(t_int64 < zero) then failwith \"converting to negative timestamp\" ;\n Int64.to_string t_int64\n\n let of_time_ns ns : t =\n let int64_ns = ns |> Time_ns.to_int63_ns_since_epoch |> Int63.to_int64 in\n (* convert to milliseconds *)\n Int64.(int64_ns / 1_000_000L) |> UInt64.of_int64\n\n [%%if time_offsets]\n\n let to_system_time (offset : Controller.t) (t : t) =\n of_span_since_epoch\n Span.(to_span_since_epoch t + of_time_span (offset ()))\n\n [%%else]\n\n let to_system_time (_offset : Controller.t) (t : t) = t\n\n [%%endif]\n\n let to_string_system_time_exn (offset : Controller.t) (t : t) : string =\n to_system_time offset t |> to_string_exn\n\n let of_string_exn string =\n Int64.of_string string |> Span.of_ms |> of_span_since_epoch\n\n let gen_incl time_beginning time_end =\n let open Quickcheck.Let_syntax in\n let time_beginning_int64 = to_int64 time_beginning in\n let time_end_int64 = to_int64 time_end in\n let%map int64_time_span =\n Int64.(gen_incl time_beginning_int64 time_end_int64)\n in\n of_span_since_epoch @@ Span.of_ms int64_time_span\n\n let gen =\n let open Quickcheck.Let_syntax in\n let%map int64_time_span = Int64.(gen_incl zero max_value) in\n of_span_since_epoch @@ Span.of_ms int64_time_span\n end\n\n include Time\n module Timeout = Timeout_lib.Make (Time)\nend\n\ninclude Wire_types.Make (Make_sig) (Make_str)\n","open Core_kernel\nopen Async_kernel\n\n[%%versioned\nmodule Stable = struct\n module V1 = struct\n type 'a t = [ `One of 'a | `Two of 'a * 'a ]\n [@@deriving equal, compare, hash, sexp, yojson]\n\n let to_latest a_latest = function\n | `One x ->\n `One (a_latest x)\n | `Two (x, y) ->\n `Two (a_latest x, a_latest y)\n\n let of_latest a_latest = function\n | `One x ->\n let open Result.Let_syntax in\n let%map x = a_latest x in\n `One x\n | `Two (x, y) ->\n let open Result.Let_syntax in\n let%map x = a_latest x and y = a_latest y in\n `Two (x, y)\n end\nend]\n\nlet length = function `One _ -> 1 | `Two _ -> 2\n\nlet to_list = function `One a -> [ a ] | `Two (a, b) -> [ a; b ]\n\nlet to_numbered_list = function\n | `One a ->\n [ (0, a) ]\n | `Two (a, b) ->\n [ (0, a); (1, b) ]\n\nlet group_sequence : 'a Sequence.t -> 'a t Sequence.t =\n fun to_group ->\n Sequence.unfold ~init:to_group ~f:(fun acc ->\n match Sequence.next acc with\n | None ->\n None\n | Some (a, rest_1) -> (\n match Sequence.next rest_1 with\n | None ->\n Some (`One a, Sequence.empty)\n | Some (b, rest_2) ->\n Some (`Two (a, b), rest_2) ) )\n\nlet group_list : 'a list -> 'a t list =\n fun xs -> xs |> Sequence.of_list |> group_sequence |> Sequence.to_list\n\nlet zip : 'a t -> 'b t -> ('a * 'b) t Or_error.t =\n fun a b ->\n match (a, b) with\n | `One a1, `One b1 ->\n Ok (`One (a1, b1))\n | `Two (a1, a2), `Two (b1, b2) ->\n Ok (`Two ((a1, b1), (a2, b2)))\n | _ ->\n Or_error.error_string \"One_or_two.zip mismatched\"\n\nlet zip_exn : 'a t -> 'b t -> ('a * 'b) t =\n fun a b -> Or_error.ok_exn @@ zip a b\n\nmodule Monadic2 (M : Monad.S2) :\n Intfs.Monadic2 with type ('a, 'e) m := ('a, 'e) M.t = struct\n let sequence : ('a, 'e) M.t t -> ('a t, 'e) M.t = function\n | `One def ->\n M.map def ~f:(fun x -> `One x)\n | `Two (def1, def2) ->\n let open M.Let_syntax in\n let%bind a = def1 in\n let%map b = def2 in\n `Two (a, b)\n\n let map : 'a t -> f:('a -> ('b, 'e) M.t) -> ('b t, 'e) M.t =\n fun t ~f ->\n (* We could use sequence here, but this approach saves us computation in the\n Result and option monads when the first component of a `Two fails. *)\n match t with\n | `One a ->\n M.map ~f:(fun x -> `One x) (f a)\n | `Two (a, b) ->\n let open M.Let_syntax in\n let%bind a' = f a in\n let%map b' = f b in\n `Two (a', b')\n\n let fold :\n 'a t\n -> init:'accum\n -> f:('accum -> 'a -> ('accum, 'e) M.t)\n -> ('accum, 'e) M.t =\n fun t ~init ~f ->\n match t with\n | `One a ->\n f init a\n | `Two (a, b) ->\n M.bind (f init a) ~f:(fun x -> f x b)\nend\n\nmodule Monadic (M : Monad.S) : Intfs.Monadic with type 'a m := 'a M.t =\n Monadic2 (Base__.Monad_intf.S_to_S2 (M))\n\nmodule Deferred_result = Monadic2 (Deferred.Result)\nmodule Ident = Monadic (Monad.Ident)\nmodule Deferred = Monadic (Deferred)\nmodule Option = Monadic (Option)\nmodule Or_error = Monadic (Or_error)\n\nlet map = Ident.map\n\nlet fold = Ident.fold\n\nlet iter t ~f = match t with `One a -> f a | `Two (a, b) -> f a ; f b\n\nlet fold_until ~init ~f ~finish t =\n Container.fold_until ~fold ~init ~f ~finish t\n\nlet gen inner_gen =\n Quickcheck.Generator.(\n union\n [ map inner_gen ~f:(fun x -> `One x)\n ; map (tuple2 inner_gen inner_gen) ~f:(fun pair -> `Two pair)\n ])\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Mina_base_import\n\n(** See documentation of the {!Mina_wire_types} library *)\nmodule Wire_types = Mina_wire_types.Mina_base.Account_id\n\nmodule Make_sig (A : Wire_types.Types.S) = struct\n module type S =\n Account_id_intf.S\n with type Digest.Stable.V1.t = A.Digest.V1.t\n and type Stable.V2.t = A.V2.t\nend\n\nmodule Make_str (_ : Wire_types.Concrete) = struct\n let invalid = (Public_key.Compressed.empty, Pickles.Backend.Tick.Field.zero)\n\n module Digest = struct\n [%%ifdef consensus_mechanism]\n\n let of_bigstring_exn =\n Binable.of_bigstring (module Pickles.Backend.Tick.Field.Stable.Latest)\n\n let to_bigstring =\n Binable.to_bigstring (module Pickles.Backend.Tick.Field.Stable.Latest)\n\n [%%else]\n\n let of_bigstring_exn =\n Binable.of_bigstring (module Snark_params.Tick.Field.Stable.Latest)\n\n let to_bigstring =\n Binable.to_bigstring (module Snark_params.Tick.Field.Stable.Latest)\n\n [%%endif]\n\n module Base58_check = Base58_check.Make (struct\n let description = \"Token ID\"\n\n let version_byte = Base58_check.Version_bytes.token_id_key\n end)\n\n let to_base58_check t : string =\n Base58_check.encode (to_bigstring t |> Bigstring.to_string)\n\n let of_base58_check_exn (s : string) =\n let decoded = Base58_check.decode_exn s in\n decoded |> Bigstring.of_string |> of_bigstring_exn\n\n let to_string = to_base58_check\n\n let of_string = of_base58_check_exn\n\n let of_field = Fn.id\n\n let to_field_unsafe = Fn.id\n\n [%%ifdef consensus_mechanism]\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Pickles.Backend.Tick.Field.Stable.V1.t\n [@@deriving sexp, equal, compare, hash]\n\n let to_yojson (t : t) : Yojson.Safe.t = `String (to_string t)\n\n let of_yojson (j : Yojson.Safe.t) : (t, string) result =\n try Ok (of_string (Yojson.Safe.Util.to_string j))\n with e -> Error (Exn.to_string e)\n\n let to_latest = Fn.id\n end\n end]\n\n [%%else]\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Snark_params.Tick.Field.Stable.V1.t\n [@@deriving sexp, equal, compare, hash]\n\n let to_yojson (t : t) : Yojson.Safe.t = `String (to_string t)\n\n let of_yojson (j : Yojson.Safe.t) : (t, string) result =\n try Ok (of_string (Yojson.Safe.Util.to_string j))\n with e -> Error (Exn.to_string e)\n\n let to_latest = Fn.id\n end\n end]\n\n [%%endif]\n\n [%%define_locally Stable.Latest.(of_yojson, to_yojson)]\n\n module Binables = struct\n include Comparable.Make_binable (Stable.Latest)\n include Hashable.Make_binable (Stable.Latest)\n end\n\n include Binables\n\n let to_input : t -> _ Random_oracle_input.Chunked.t =\n Random_oracle_input.Chunked.field\n\n (* Just matters that this no one can find a preimage to this with poseidon.\n Chose 1 for consistency for the old uint64 based token IDs *)\n let default : t = Snark_params.Tick.Field.one\n\n let gen : t Quickcheck.Generator.t = Snark_params.Tick.Field.gen\n\n let gen_non_default =\n Quickcheck.Generator.filter gen ~f:(fun x -> not (equal x default))\n\n [%%ifdef consensus_mechanism]\n\n module Checked = struct\n open Pickles.Impls.Step\n\n type t = Field.t\n\n let to_input : t -> _ Random_oracle_input.Chunked.t =\n Random_oracle_input.Chunked.field\n\n let constant : Stable.Latest.t -> t = Field.constant\n\n let equal : t -> t -> Boolean.var = Field.equal\n\n let if_ = Field.if_\n\n let of_field = Fn.id\n\n let to_field_unsafe = Fn.id\n\n module Assert = struct\n let equal : t -> t -> unit = Field.Assert.equal\n end\n end\n\n let typ = Snark_params.Tick.Field.typ\n\n [%%endif]\n end\n\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t = Public_key.Compressed.Stable.V1.t * Digest.Stable.V1.t\n [@@deriving sexp, equal, compare, hash, yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n let create key tid = (key, tid)\n\n let empty : t = (Public_key.Compressed.empty, Digest.default)\n\n let public_key (key, _tid) = key\n\n let of_public_key (pk : Public_key.t) =\n create (Public_key.compress pk) Digest.default\n\n let token_id (_key, id) = id\n\n let to_input ((key, tid) : t) =\n Random_oracle_input.Chunked.(\n append (Public_key.Compressed.to_input key) (field tid))\n\n let derive_token_id ~(owner : t) : Digest.t =\n Random_oracle.hash ~init:Hash_prefix.derive_token_id\n (Random_oracle.pack_input (to_input owner))\n\n let gen =\n let open Quickcheck.Let_syntax in\n let%map key = Public_key.Compressed.gen and tid = Digest.gen in\n (key, tid)\n\n include Comparable.Make_binable (Stable.Latest)\n include Hashable.Make_binable (Stable.Latest)\n\n let to_input ((key, tid) : t) =\n Random_oracle.Input.Chunked.append\n (Public_key.Compressed.to_input key)\n (Digest.to_input tid)\n\n [%%ifdef consensus_mechanism]\n\n type var = Public_key.Compressed.var * Digest.Checked.t\n\n let typ = Snarky_backendless.Typ.(Public_key.Compressed.typ * Digest.typ)\n\n let var_of_t ((key, tid) : t) =\n ( Public_key.Compressed.var_of_t key\n , Snark_params.Tick.Field.Var.constant tid )\n\n module Checked = struct\n open Snark_params\n open Tick\n\n let create key tid = (key, tid)\n\n let public_key (key, _tid) = key\n\n let token_id (_key, tid) = tid\n\n let to_input ((key, tid) : var) =\n let tid = Digest.Checked.to_input tid in\n Random_oracle.Input.Chunked.append\n (Public_key.Compressed.Checked.to_input key)\n tid\n\n let derive_token_id ~(owner : var) : Digest.Checked.t =\n Random_oracle.Checked.hash ~init:Hash_prefix.derive_token_id\n (Random_oracle.Checked.pack_input (to_input owner))\n\n let equal (pk1, tid1) (pk2, tid2) =\n let%bind pk_equal = Public_key.Compressed.Checked.equal pk1 pk2 in\n let%bind tid_equal = Snark_params.Tick.Field.Checked.equal tid1 tid2 in\n Tick.Boolean.(pk_equal && tid_equal)\n\n let if_ b ~then_:(pk_then, tid_then) ~else_:(pk_else, tid_else) =\n let%bind pk =\n Public_key.Compressed.Checked.if_ b ~then_:pk_then ~else_:pk_else\n in\n let%map tid =\n Snark_params.Tick.Field.Checked.if_ b ~then_:tid_then ~else_:tid_else\n in\n (pk, tid)\n end\n\n [%%endif]\nend\n\ninclude Wire_types.Make (Make_sig) (Make_str)\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Snark_params\nopen Tick\nopen Currency\nopen Mina_numbers\n\n(* A timed account is an account, which releases its balance to be spent\n gradually. The process of releasing frozen funds is defined as follows.\n Until the cliff_time global slot is reached, the initial_minimum_balance\n of mina is frozen and cannot be spent. At the cliff slot, cliff_amount\n is released and initial_minimum_balance is effectively lowered by that\n amount. Next, every vesting_period number of slots, vesting_increment\n is released, further decreasing the current minimum balance. At some\n point minimum balance drops to 0, and after that the account behaves\n like an untimed one. *)\nmodule Poly = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type ('slot, 'slot_span, 'balance, 'amount) t =\n | Untimed\n | Timed of\n { initial_minimum_balance : 'balance\n ; cliff_time : 'slot\n ; cliff_amount : 'amount\n ; vesting_period : 'slot_span\n ; vesting_increment : 'amount\n }\n [@@deriving sexp, equal, hash, compare, yojson]\n end\n end]\nend\n\n[%%versioned\nmodule Stable = struct\n module V2 = struct\n type t =\n ( Global_slot_since_genesis.Stable.V1.t\n , Global_slot_span.Stable.V1.t\n , Balance.Stable.V1.t\n , Amount.Stable.V1.t )\n Poly.Stable.V2.t\n [@@deriving sexp, equal, hash, compare, yojson]\n\n let to_latest = Fn.id\n end\nend]\n\ntype ('slot, 'slot_span, 'balance, 'amount) tt =\n ('slot, 'slot_span, 'balance, 'amount) Poly.t =\n | Untimed\n | Timed of\n { initial_minimum_balance : 'balance\n ; cliff_time : 'slot\n ; cliff_amount : 'amount\n ; vesting_period : 'slot_span\n ; vesting_increment : 'amount\n }\n[@@deriving sexp, equal, hash, compare, yojson]\n\nmodule As_record = struct\n type ('bool, 'slot, 'slot_span, 'balance, 'amount) t =\n { is_timed : 'bool\n ; initial_minimum_balance : 'balance\n ; cliff_time : 'slot\n ; cliff_amount : 'amount\n ; vesting_period : 'slot_span\n ; vesting_increment : 'amount\n }\n [@@deriving equal, hlist, fields, annot]\n\n let deriver obj =\n let open Fields_derivers_zkapps.Derivers in\n let ( !. ) = ( !. ) ~t_fields_annots in\n Fields.make_creator obj ~is_timed:!.bool ~initial_minimum_balance:!.balance\n ~cliff_time:!.global_slot_since_genesis\n ~cliff_amount:!.amount ~vesting_period:!.global_slot_span\n ~vesting_increment:!.amount\n |> finish \"AccountTiming\" ~t_toplevel_annots\nend\n\ntype as_record =\n ( bool\n , Global_slot_since_genesis.Stable.V1.t\n , Global_slot_span.Stable.V1.t\n , Balance.Stable.V1.t\n , Amount.Stable.V1.t )\n As_record.t\n\n(* convert sum type to record format, useful for to_bits and typ *)\nlet to_record t =\n match t with\n | Untimed ->\n let slot_unused = Global_slot_since_genesis.zero in\n let slot_span_one = Global_slot_span.(succ zero) in\n let balance_unused = Balance.zero in\n let amount_unused = Amount.zero in\n { As_record.is_timed = false\n ; initial_minimum_balance = balance_unused\n ; cliff_time = slot_unused\n ; cliff_amount = amount_unused\n ; vesting_period = slot_span_one (* avoid division by zero *)\n ; vesting_increment = amount_unused\n }\n | Timed\n { initial_minimum_balance\n ; cliff_time\n ; cliff_amount\n ; vesting_period\n ; vesting_increment\n } ->\n { is_timed = true\n ; initial_minimum_balance\n ; cliff_time\n ; cliff_amount\n ; vesting_period\n ; vesting_increment\n }\n\nlet of_record\n { As_record.is_timed\n ; initial_minimum_balance\n ; cliff_time\n ; cliff_amount\n ; vesting_period\n ; vesting_increment\n } : t =\n if is_timed then\n Timed\n { initial_minimum_balance\n ; cliff_time\n ; cliff_amount\n ; vesting_period\n ; vesting_increment\n }\n else Untimed\n\nlet of_record (r : as_record) : t =\n if r.is_timed then\n Timed\n { initial_minimum_balance = r.initial_minimum_balance\n ; cliff_time = r.cliff_time\n ; cliff_amount = r.cliff_amount\n ; vesting_period = r.vesting_period\n ; vesting_increment = r.vesting_increment\n }\n else Untimed\n\nlet to_input t =\n let As_record.\n { is_timed\n ; initial_minimum_balance\n ; cliff_time\n ; cliff_amount\n ; vesting_period\n ; vesting_increment\n } =\n to_record t\n in\n let open Random_oracle_input.Chunked in\n Array.reduce_exn ~f:append\n [| packed ((if is_timed then Field.one else Field.zero), 1)\n ; Balance.to_input initial_minimum_balance\n ; Global_slot_since_genesis.to_input cliff_time\n ; Amount.to_input cliff_amount\n ; Global_slot_span.to_input vesting_period\n ; Amount.to_input vesting_increment\n |]\n\n[%%ifdef consensus_mechanism]\n\ntype var =\n ( Boolean.var\n , Global_slot_since_genesis.Checked.var\n , Global_slot_span.Checked.var\n , Balance.var\n , Amount.var )\n As_record.t\n\nlet var_to_input\n As_record.\n { is_timed : Boolean.var\n ; initial_minimum_balance\n ; cliff_time\n ; cliff_amount\n ; vesting_period\n ; vesting_increment\n } =\n let open Random_oracle_input.Chunked in\n Array.reduce_exn ~f:append\n [| packed ((is_timed :> Field.Var.t), 1)\n ; Balance.var_to_input initial_minimum_balance\n ; Global_slot_since_genesis.Checked.to_input cliff_time\n ; Amount.var_to_input cliff_amount\n ; Global_slot_span.Checked.to_input vesting_period\n ; Amount.var_to_input vesting_increment\n |]\n\nlet var_of_t (t : t) : var =\n let { As_record.is_timed\n ; initial_minimum_balance\n ; cliff_time\n ; cliff_amount\n ; vesting_period\n ; vesting_increment\n } =\n to_record t\n in\n { is_timed = Boolean.var_of_value is_timed\n ; initial_minimum_balance = Balance.var_of_t initial_minimum_balance\n ; cliff_time = Global_slot_since_genesis.Checked.constant cliff_time\n ; cliff_amount = Amount.var_of_t cliff_amount\n ; vesting_period = Global_slot_span.Checked.constant vesting_period\n ; vesting_increment = Amount.var_of_t vesting_increment\n }\n\nlet untimed_var = var_of_t Untimed\n\nlet typ : (var, t) Typ.t =\n (* because we represent the types t (a sum type) and var (a record) differently,\n we can't use the trick, used elsewhere, of polymorphic to_hlist and of_hlist\n functions to handle both types\n *)\n let value_of_hlist :\n ( unit\n , Boolean.value\n -> Balance.t\n -> Global_slot_since_genesis.t\n -> Amount.t\n -> Global_slot_span.t\n -> Amount.t\n -> unit )\n H_list.t\n -> t =\n let open H_list in\n fun [ is_timed\n ; initial_minimum_balance\n ; cliff_time\n ; cliff_amount\n ; vesting_period\n ; vesting_increment\n ] ->\n if is_timed then\n Timed\n { initial_minimum_balance\n ; cliff_time\n ; cliff_amount\n ; vesting_period\n ; vesting_increment\n }\n else Untimed\n in\n let value_to_hlist (t : t) =\n let As_record.\n { is_timed\n ; initial_minimum_balance\n ; cliff_time\n ; cliff_amount\n ; vesting_period\n ; vesting_increment\n } =\n to_record t\n in\n H_list.\n [ is_timed\n ; initial_minimum_balance\n ; cliff_time\n ; cliff_amount\n ; vesting_period\n ; vesting_increment\n ]\n in\n let var_of_hlist = As_record.of_hlist in\n let var_to_hlist = As_record.to_hlist in\n Typ.of_hlistable\n [ Boolean.typ\n ; Balance.typ\n ; Global_slot_since_genesis.typ\n ; Amount.typ\n ; Global_slot_span.typ\n ; Amount.typ\n ]\n ~var_to_hlist ~var_of_hlist ~value_to_hlist ~value_of_hlist\n\n(* we can't use the generic if_ with the above typ, because Global_slot_since_genesis.typ doesn't work correctly with it\n so we define a custom if_\n*)\nlet if_ b ~(then_ : var) ~(else_ : var) =\n let%bind is_timed =\n Boolean.if_ b ~then_:then_.is_timed ~else_:else_.is_timed\n in\n let%bind initial_minimum_balance =\n Balance.Checked.if_ b ~then_:then_.initial_minimum_balance\n ~else_:else_.initial_minimum_balance\n in\n let%bind cliff_time =\n Global_slot_since_genesis.Checked.if_ b ~then_:then_.cliff_time\n ~else_:else_.cliff_time\n in\n let%bind cliff_amount =\n Amount.Checked.if_ b ~then_:then_.cliff_amount ~else_:else_.cliff_amount\n in\n let%bind vesting_period =\n Global_slot_span.Checked.if_ b ~then_:then_.vesting_period\n ~else_:else_.vesting_period\n in\n let%map vesting_increment =\n Amount.Checked.if_ b ~then_:then_.vesting_increment\n ~else_:else_.vesting_increment\n in\n { As_record.is_timed\n ; initial_minimum_balance\n ; cliff_time\n ; cliff_amount\n ; vesting_period\n ; vesting_increment\n }\n\nlet deriver obj =\n let open Fields_derivers_zkapps in\n iso_record ~to_record ~of_record As_record.deriver obj\n\n[%%endif]\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Snark_params.Tick\n\nmodule Poly = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n [@@@with_all_version_tags]\n\n type ('field, 'scalar) t = 'field * 'scalar\n [@@deriving sexp, compare, equal, hash]\n end\n end]\nend\n\n[%%versioned\nmodule Stable = struct\n module V1 = struct\n [@@@with_all_version_tags]\n\n type t =\n ( (Field.t[@version_asserted])\n , (Inner_curve.Scalar.t[@version_asserted]) )\n Poly.Stable.V1.t\n [@@deriving sexp, compare, equal, hash]\n\n module Codable_arg = struct\n (* version tag for compatibility with pre-Berkeley hard fork\n Base58Check-serialized signatures\n *)\n type t =\n (Field.t, Inner_curve.Scalar.t) Poly.Stable.V1.With_all_version_tags.t\n [@@deriving bin_io_unversioned]\n\n let description = \"Signature\"\n\n let version_byte = Base58_check.Version_bytes.signature\n end\n\n (* Base58Check encodes t *)\n let (_ : (t, Codable_arg.t) Type_equal.t) = Type_equal.T\n\n include Codable.Make_base58_check (Codable_arg)\n\n let to_latest = Fn.id\n\n let gen = Quickcheck.Generator.tuple2 Field.gen Inner_curve.Scalar.gen\n end\nend]\n\nlet dummy = (Field.one, Inner_curve.Scalar.one)\n\nlet gen = Stable.Latest.gen\n\nmodule Raw = struct\n open Rosetta_coding.Coding\n\n let encode (field, scalar) = of_field field ^ of_scalar scalar\n\n let decode raw =\n let len = String.length raw in\n let field_len = len / 2 in\n let field_enc = String.sub raw ~pos:0 ~len:field_len in\n let scalar_enc = String.sub raw ~pos:field_len ~len:field_len in\n try Some (to_field field_enc, to_scalar scalar_enc) with _ -> None\nend\n\n[%%ifdef consensus_mechanism]\n\ntype var = Field.Var.t * Inner_curve.Scalar.var\n\n[%%endif]\n\n[%%define_locally\nStable.Latest.\n (of_base58_check_exn, of_base58_check, of_yojson, to_yojson, to_base58_check)]\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\n\n(* TODO: temporary hack *)\n[%%ifdef consensus_mechanism]\n\n[%%versioned\nmodule Stable = struct\n module V2 = struct\n type t = Mina_wire_types.Mina_base.Control.V2.t =\n | Proof of Pickles.Side_loaded.Proof.Stable.V2.t\n | Signature of Signature.Stable.V1.t\n | None_given\n [@@deriving sexp, equal, yojson, hash, compare]\n\n let to_latest = Fn.id\n end\nend]\n\n(* lazy, to prevent spawning Rust threads at startup, which prevents daemonization *)\nlet gen_with_dummies : t Quickcheck.Generator.t =\n let gen =\n lazy\n (Quickcheck.Generator.of_list\n (let dummy_proof =\n let n2 = Pickles_types.Nat.N2.n in\n let proof = Pickles.Proof.dummy n2 n2 n2 ~domain_log2:15 in\n Proof proof\n in\n let dummy_signature = Signature Signature.dummy in\n [ dummy_proof; dummy_signature; None_given ] ) )\n in\n Quickcheck.Generator.create (fun ~size ~random ->\n Quickcheck.Generator.generate (Lazy.force gen) ~size ~random )\n\n[%%else]\n\n[%%versioned\nmodule Stable = struct\n module V2 = struct\n type t = Proof of unit | Signature of Signature.Stable.V1.t | None_given\n [@@deriving sexp, equal, yojson, hash, compare]\n\n let to_latest = Fn.id\n end\n\n module V1 = struct\n type t =\n | Proof of unit\n | Signature of Signature.Stable.V1.t\n | Both of { signature : Signature.Stable.V1.t; proof : unit }\n | None_given\n [@@deriving sexp, equal, yojson, hash, compare]\n\n let to_latest : t -> V2.t = function\n | Proof proof ->\n Proof proof\n | Signature signature ->\n Signature signature\n | None_given ->\n None_given\n | Both _ ->\n failwith\n \"Control.Stable.V1.to_latest: Both variant is no longer supported\"\n end\nend]\n\n[%%endif]\n\nmodule Tag = struct\n type t = Signature | Proof | None_given [@@deriving equal, compare, sexp]\n\n let gen = Quickcheck.Generator.of_list [ Proof; Signature; None_given ]\n\n let to_string = function\n | Signature ->\n \"Signature\"\n | Proof ->\n \"Proof\"\n | None_given ->\n \"None_given\"\n\n let of_string_exn = function\n | \"Signature\" ->\n Signature\n | \"Proof\" ->\n Proof\n | \"None_given\" ->\n None_given\n | s ->\n failwithf \"String %s does not denote a control tag\" s ()\nend\n\nlet tag : t -> Tag.t = function\n | Proof _ ->\n Proof\n | Signature _ ->\n Signature\n | None_given ->\n None_given\n\n[%%ifdef consensus_mechanism]\n\nlet dummy_of_tag : Tag.t -> t = function\n | Proof ->\n let n2 = Pickles_types.Nat.N2.n in\n let proof = Pickles.Proof.dummy n2 n2 n2 ~domain_log2:15 in\n Proof proof\n | Signature ->\n Signature Signature.dummy\n | None_given ->\n None_given\n\nlet signature_deriver obj =\n Fields_derivers_zkapps.Derivers.iso_string obj ~name:\"Signature\"\n ~js_type:String ~to_string:Signature.to_base58_check\n ~of_string:\n (Fields_derivers_zkapps.except ~f:Signature.of_base58_check_exn `Signature)\n\nmodule As_record = struct\n type t =\n { proof : Pickles.Side_loaded.Proof.t option\n ; signature : Signature.t option\n }\n [@@deriving annot, fields]\n\n let deriver obj =\n let open Fields_derivers_zkapps in\n let ( !. ) = ( !. ) ~t_fields_annots in\n Fields.make_creator obj\n ~proof:!.(option ~js_type:Or_undefined @@ proof @@ o ())\n ~signature:!.(option ~js_type:Or_undefined @@ signature_deriver @@ o ())\n |> finish \"Control\" ~t_toplevel_annots\nend\n\nlet to_record = function\n | Proof p ->\n { As_record.proof = Some p; signature = None }\n | Signature s ->\n { proof = None; signature = Some s }\n | None_given ->\n { proof = None; signature = None }\n\nlet of_record = function\n | { As_record.proof = Some p; _ } ->\n Proof p\n | { signature = Some s; _ } ->\n Signature s\n | _ ->\n None_given\n\nlet deriver obj =\n Fields_derivers_zkapps.Derivers.iso_record ~of_record ~to_record\n As_record.deriver obj\n\nlet%test_unit \"json rountrip\" =\n let module Fd = Fields_derivers_zkapps.Derivers in\n let full = deriver (Fd.o ()) in\n let control = dummy_of_tag Proof in\n [%test_eq: t] control (control |> Fd.to_json full |> Fd.of_json full)\n\n[%%endif]\n","(* payment_payload.ml *)\n\n[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Signature_lib\nmodule Amount = Currency.Amount\nmodule Fee = Currency.Fee\n\nmodule Poly = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type ('public_key, 'amount) t =\n ( 'public_key\n , 'amount )\n Mina_wire_types.Mina_base.Payment_payload.Poly.V2.t =\n { receiver_pk : 'public_key; amount : 'amount }\n [@@deriving equal, sexp, hash, yojson, compare, hlist]\n end\n\n module V1 = struct\n [@@@with_all_version_tags]\n\n type ('public_key, 'token_id, 'amount) t =\n { source_pk : 'public_key\n ; receiver_pk : 'public_key\n ; token_id : 'token_id\n ; amount : 'amount\n }\n [@@deriving equal, sexp, hash, yojson, compare, hlist]\n end\n end]\nend\n\n[%%versioned\nmodule Stable = struct\n module V2 = struct\n type t =\n (Public_key.Compressed.Stable.V1.t, Amount.Stable.V1.t) Poly.Stable.V2.t\n [@@deriving equal, sexp, hash, compare, yojson]\n\n let to_latest = Fn.id\n end\n\n module V1 = struct\n [@@@with_all_version_tags]\n\n type t =\n ( Public_key.Compressed.Stable.V1.t\n , Token_id.Stable.V1.t\n , Amount.Stable.V1.t )\n Poly.Stable.V1.t\n [@@deriving equal, sexp, hash, compare, yojson]\n\n (* don't need to coerce old payments to new ones *)\n let to_latest _ = failwith \"Not implemented\"\n end\nend]\n\nlet dummy =\n Poly.{ receiver_pk = Public_key.Compressed.empty; amount = Amount.zero }\n\n[%%ifdef consensus_mechanism]\n\ntype var = (Public_key.Compressed.var, Amount.var) Poly.t\n\nlet var_of_t ({ receiver_pk; amount } : t) : var =\n { receiver_pk = Public_key.Compressed.var_of_t receiver_pk\n ; amount = Amount.var_of_t amount\n }\n\n[%%endif]\n\nlet gen_aux max_amount =\n let open Quickcheck.Generator.Let_syntax in\n let%bind receiver_pk = Public_key.Compressed.gen in\n let%map amount = Amount.gen_incl Amount.zero max_amount in\n Poly.{ receiver_pk; amount }\n\nlet gen max_amount = gen_aux max_amount\n\nlet gen_default_token max_amount = gen_aux max_amount\n","open Core_kernel\nopen Snark_params.Tick\n\ninclude Data_hash.Make_full_size (struct\n let description = \"Ledger hash\"\n\n let version_byte = Base58_check.Version_bytes.ledger_hash\nend)\n\n(* Data hash versioned boilerplate below *)\n\n[%%versioned\nmodule Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n module T = struct\n type t = (Field.t[@version_asserted]) [@@deriving sexp, compare, hash]\n end\n\n include T\n\n let to_latest = Fn.id\n\n [%%define_from_scope to_yojson, of_yojson]\n\n include Comparable.Make (T)\n include Hashable.Make_binable (T)\n end\nend]\n\nlet (_ : (t, Stable.Latest.t) Type_equal.t) = Type_equal.T\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Mina_base_util\n\n[%%ifdef consensus_mechanism]\n\nopen Snark_params.Tick\n\n[%%endif]\n\nmodule Frozen_ledger_hash = Frozen_ledger_hash0\nmodule Ledger_hash = Ledger_hash0\n\n(* Semantically this type represents a function\n { has_valid_signature: bool; has_valid_proof: bool } -> bool\n\n These are all of them:\n 00 01 10 11 | intuitive definition | Make sense\n 0 0 0 0 | Impossible | yes\n 0 0 0 1 | Both | yes\n 0 0 1 0 | Proof and not signature | no\n 0 0 1 1 | Proof | yes\n 0 1 0 0 | Signature and not proof | no\n 0 1 0 1 | Signature | yes\n 0 1 1 0 | Exactly one | no\n 0 1 1 1 | Either | yes\n 1 0 0 0 | Neither | no\n 1 0 0 1 | Neither or both | no\n 1 0 1 0 | Neither or proof, not both | no\n ...\n 1 1 1 1 | None | yes\n\n The ones marked as \"not making sense\" don't make sense because it is pointless\n to demand a signature failed to verify since you can always make a failing signature\n or proof.\n\n The ones that make sense are\n 0 0 0 0 | Impossible | yes\n 0 0 0 1 | Both | yes\n 0 0 1 1 | Proof | yes\n 0 1 0 1 | Signature | yes\n 0 1 1 1 | Either | yes\n 1 1 1 1 | None | yes\n\n \"Making sense\" can be captured by the idea that these are the *increasing*\n boolean functions on the type { has_valid_signature: bool; has_valid_proof: bool }.\n*)\nmodule Auth_required = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t = Mina_wire_types.Mina_base.Permissions.Auth_required.V2.t =\n | None\n | Either\n | Proof\n | Signature\n | Impossible (* Both and either can both be subsumed in verification key.\n It is good to have \"Either\" as a separate thing to spare the owner from\n having to make a proof instead of a signature. Both, I'm not sure if there's\n a good justification for. *)\n [@@deriving sexp, equal, compare, hash, yojson, enum]\n\n let to_latest = Fn.id\n end\n end]\n\n let from ~auth_tag : t =\n match auth_tag with\n | Control.Tag.Proof ->\n Proof\n | Signature ->\n Signature\n | None_given ->\n None\n\n (* permissions such that [check permission (Proof _)] is true *)\n let gen_for_proof_authorization : t Quickcheck.Generator.t =\n Quickcheck.Generator.of_list [ None; Either; Proof ]\n\n (* permissions such that [check permission (Signature _)] is true *)\n let gen_for_signature_authorization : t Quickcheck.Generator.t =\n Quickcheck.Generator.of_list [ None; Either; Signature ]\n\n (* permissions such that [check permission None_given] is true *)\n let gen_for_none_given_authorization : t Quickcheck.Generator.t =\n Quickcheck.Generator.return None\n\n let to_string = function\n | None ->\n \"None\"\n | Either ->\n \"Either\"\n | Proof ->\n \"Proof\"\n | Signature ->\n \"Signature\"\n | Impossible ->\n \"Impossible\"\n\n let of_string = function\n | \"None\" ->\n Stable.Latest.None\n | \"Either\" ->\n Either\n | \"Proof\" ->\n Proof\n | \"Signature\" ->\n Signature\n | \"Impossible\" ->\n Impossible\n | _ ->\n failwith \"auth_required_of_string: unknown variant\"\n\n (* The encoding is chosen so that it is easy to write this function\n\n let spec_eval t ~signature_verifies =\n let impossible = (constant t && not (signature_sufficient t)) in\n let result =\n not impossible &&\n ( (signature_verifies && signature_sufficient t)\n || not (signature_necessary t) )\n in\n { result; proof_must_verify= not (signature_sufficient t) } *)\n\n (* Here is the mapping between our type and the bits\n { constant: bool\n ; signature_necessary: bool\n ; signature_sufficient: bool\n }\n\n Not constant\n Signature not necessary\n Signature not sufficient\n Proof\n Signature sufficient\n Either\n Signature necessary\n Signature not sufficient\n Both\n Signature sufficient\n Signature\n\n Constant\n Signature not sufficient\n Impossible\n Signature sufficient\n None\n *)\n module Encoding = struct\n type 'bool t =\n { constant : 'bool\n ; signature_necessary : 'bool\n ; signature_sufficient : 'bool\n }\n [@@deriving hlist, fields]\n\n let to_input ~field_of_bool t =\n let [ x; y; z ] = to_hlist t in\n let bs = [| x; y; z |] in\n Random_oracle.Input.Chunked.packeds\n (Array.map bs ~f:(fun b -> (field_of_bool b, 1)))\n\n let map t ~f =\n { constant = f t.constant\n ; signature_necessary = f t.signature_necessary\n ; signature_sufficient = f t.signature_sufficient\n }\n\n let _ = map\n\n [%%ifdef consensus_mechanism]\n\n let if_ b ~then_:t ~else_:e =\n let open Pickles.Impls.Step in\n { constant = Boolean.if_ b ~then_:t.constant ~else_:e.constant\n ; signature_necessary =\n Boolean.if_ b ~then_:t.signature_necessary\n ~else_:e.signature_necessary\n ; signature_sufficient =\n Boolean.if_ b ~then_:t.signature_sufficient\n ~else_:e.signature_sufficient\n }\n\n [%%endif]\n end\n\n let encode : t -> bool Encoding.t = function\n | Impossible ->\n { constant = true\n ; signature_necessary = true\n ; signature_sufficient = false\n }\n | None ->\n { constant = true\n ; signature_necessary = false\n ; signature_sufficient = true\n }\n | Proof ->\n { constant = false\n ; signature_necessary = false\n ; signature_sufficient = false\n }\n | Signature ->\n { constant = false\n ; signature_necessary = true\n ; signature_sufficient = true\n }\n | Either ->\n { constant = false\n ; signature_necessary = false\n ; signature_sufficient = true\n }\n\n let decode : bool Encoding.t -> t = function\n | { constant = true; signature_necessary = _; signature_sufficient = false }\n ->\n Impossible\n | { constant = true; signature_necessary = _; signature_sufficient = true }\n ->\n None\n | { constant = false\n ; signature_necessary = false\n ; signature_sufficient = false\n } ->\n Proof\n | { constant = false\n ; signature_necessary = true\n ; signature_sufficient = true\n } ->\n Signature\n | { constant = false\n ; signature_necessary = false\n ; signature_sufficient = true\n } ->\n Either\n | { constant = false\n ; signature_necessary = true\n ; signature_sufficient = false\n } ->\n failwith\n \"Permissions.decode: Found encoding of Both, but Both is not an \\\n exposed option\"\n\n let%test_unit \"decode encode\" =\n List.iter [ Impossible; Proof; Signature; Either ] ~f:(fun t ->\n [%test_eq: t] t (decode (encode t)) )\n\n [%%ifdef consensus_mechanism]\n\n module Checked = struct\n type t = Boolean.var Encoding.t\n\n let if_ = Encoding.if_\n\n let to_input : t -> _ =\n Encoding.to_input ~field_of_bool:(fun (b : Boolean.var) ->\n (b :> Field.Var.t) )\n\n let constant t = Encoding.map (encode t) ~f:Boolean.var_of_value\n\n let eval_no_proof\n ({ constant; signature_necessary = _; signature_sufficient } : t)\n ~signature_verifies =\n (* ways authorization can succeed when no proof is present:\n - None\n {constant= true; signature_necessary= _; signature_sufficient= true}\n - Either && signature_verifies\n {constant= false; signature_necessary= false; signature_sufficient= true}\n - Signature && signature_verifies\n {constant= false; signature_necessary= true; signature_sufficient= true}\n *)\n let open Pickles.Impls.Step.Boolean in\n signature_sufficient\n &&& (constant ||| ((not constant) &&& signature_verifies))\n\n let eval_proof ({ constant; signature_necessary; signature_sufficient } : t)\n =\n (* ways authorization can succeed if a proof is present:\n - None\n {constant= true; signature_necessary= _; signature_sufficient= true}\n - Either\n {constant= false; signature_necessary= false; signature_sufficient= true}\n - Proof\n {constant= false; signature_necessary= false; signature_sufficient= false}\n *)\n let open Pickles.Impls.Step.Boolean in\n let impossible = constant &&& not signature_sufficient in\n (not signature_necessary) &&& not impossible\n\n let spec_eval ({ constant; signature_necessary; signature_sufficient } : t)\n ~signature_verifies =\n let open Pickles.Impls.Step.Boolean in\n let impossible = constant &&& not signature_sufficient in\n let result =\n (not impossible)\n &&& ( signature_verifies &&& signature_sufficient\n ||| not signature_necessary )\n in\n let didn't_fail_yet = result in\n (* If the transaction already failed to verify, we don't need to assert\n that the proof should verify. *)\n (result, `proof_must_verify (didn't_fail_yet &&& not signature_sufficient))\n end\n\n let typ =\n let t =\n let open Encoding in\n Typ.of_hlistable\n [ Boolean.typ; Boolean.typ; Boolean.typ ]\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist\n in\n Typ.transport t ~there:encode ~back:decode\n\n [%%endif]\n\n let to_input x = Encoding.to_input (encode x) ~field_of_bool\n\n let check (t : t) (c : Control.Tag.t) =\n match (t, c) with\n | Impossible, _ ->\n false\n | None, _ ->\n true\n | Proof, Proof ->\n true\n | Signature, Signature ->\n true\n (* The signatures and proofs have already been checked by this point. *)\n | Either, (Proof | Signature) ->\n true\n | Signature, Proof ->\n false\n | Proof, Signature ->\n false\n | (Proof | Signature | Either), None_given ->\n false\nend\n\nmodule Poly = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type 'controller t =\n 'controller Mina_wire_types.Mina_base.Permissions.Poly.V2.t =\n { edit_state : 'controller\n ; access : 'controller\n ; send : 'controller\n ; receive : 'controller\n ; set_delegate : 'controller\n ; set_permissions : 'controller\n ; set_verification_key : 'controller\n ; set_zkapp_uri : 'controller\n ; edit_action_state : 'controller\n ; set_token_symbol : 'controller\n ; increment_nonce : 'controller\n ; set_voting_for : 'controller\n ; set_timing : 'controller\n }\n [@@deriving annot, sexp, equal, compare, hash, yojson, hlist, fields]\n end\n end]\n\n let to_input controller t =\n let f mk acc field = mk (Core_kernel.Field.get field t) :: acc in\n Stable.Latest.Fields.fold ~init:[] ~edit_state:(f controller)\n ~send:(f controller) ~set_delegate:(f controller)\n ~set_permissions:(f controller) ~set_verification_key:(f controller)\n ~receive:(f controller) ~set_zkapp_uri:(f controller)\n ~edit_action_state:(f controller) ~set_token_symbol:(f controller)\n ~increment_nonce:(f controller) ~set_voting_for:(f controller)\n ~set_timing:(f controller) ~access:(f controller)\n |> List.rev\n |> List.reduce_exn ~f:Random_oracle.Input.Chunked.append\nend\n\n[%%versioned\nmodule Stable = struct\n module V2 = struct\n type t = Auth_required.Stable.V2.t Poly.Stable.V2.t\n [@@deriving sexp, equal, compare, hash, yojson]\n\n let to_latest = Fn.id\n end\nend]\n\nlet gen ~auth_tag : t Quickcheck.Generator.t =\n let auth_required_gen =\n (* for Auth_required permissions p, choose such that [check p authorization] is true *)\n match auth_tag with\n | Control.Tag.Proof ->\n Auth_required.gen_for_proof_authorization\n | Signature ->\n Auth_required.gen_for_signature_authorization\n | None_given ->\n Auth_required.gen_for_none_given_authorization\n in\n let open Quickcheck.Generator.Let_syntax in\n let%bind edit_state = auth_required_gen in\n let%bind send = auth_required_gen in\n let%bind receive = auth_required_gen in\n let%bind set_delegate = auth_required_gen in\n let%bind set_permissions = auth_required_gen in\n let%bind set_verification_key = auth_required_gen in\n let%bind set_zkapp_uri = auth_required_gen in\n let%bind edit_action_state = auth_required_gen in\n let%bind set_token_symbol = auth_required_gen in\n let%bind increment_nonce = auth_required_gen in\n let%bind set_voting_for = auth_required_gen in\n let%bind set_timing = auth_required_gen in\n let%bind access =\n (* Access permission is significantly more restrictive, do not arbitrarily\n set it when tests may not be intending to exercise it.\n *)\n Auth_required.gen_for_none_given_authorization\n in\n return\n { Poly.edit_state\n ; send\n ; receive\n ; set_delegate\n ; set_permissions\n ; set_verification_key\n ; set_zkapp_uri\n ; edit_action_state\n ; set_token_symbol\n ; increment_nonce\n ; set_voting_for\n ; set_timing\n ; access\n }\n\n[%%ifdef consensus_mechanism]\n\nmodule Checked = struct\n type t = Auth_required.Checked.t Poly.Stable.Latest.t\n\n let to_input (x : t) = Poly.to_input Auth_required.Checked.to_input x\n\n let if_ b ~then_ ~else_ =\n let g cond f =\n cond b\n ~then_:(Core_kernel.Field.get f then_)\n ~else_:(Core_kernel.Field.get f else_)\n in\n let c = g Auth_required.Checked.if_ in\n Poly.Fields.map ~edit_state:c ~send:c ~receive:c ~set_delegate:c\n ~set_permissions:c ~set_verification_key:c ~set_zkapp_uri:c\n ~edit_action_state:c ~set_token_symbol:c ~increment_nonce:c\n ~set_voting_for:c ~set_timing:c ~access:c\n\n let constant (t : Stable.Latest.t) : t =\n let open Core_kernel.Field in\n let a f = Auth_required.Checked.constant (get f t) in\n Poly.Fields.map ~edit_state:a ~send:a ~receive:a ~set_delegate:a\n ~set_permissions:a ~set_verification_key:a ~set_zkapp_uri:a\n ~edit_action_state:a ~set_token_symbol:a ~increment_nonce:a\n ~set_voting_for:a ~set_timing:a ~access:a\nend\n\nlet typ =\n let open Poly.Stable.Latest in\n Typ.of_hlistable\n [ Auth_required.typ\n ; Auth_required.typ\n ; Auth_required.typ\n ; Auth_required.typ\n ; Auth_required.typ\n ; Auth_required.typ\n ; Auth_required.typ\n ; Auth_required.typ\n ; Auth_required.typ\n ; Auth_required.typ\n ; Auth_required.typ\n ; Auth_required.typ\n ; Auth_required.typ\n ]\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist\n\n[%%endif]\n\nlet to_input (x : t) = Poly.to_input Auth_required.to_input x\n\nlet user_default : t =\n { edit_state = Signature\n ; send = Signature\n ; receive = None\n ; set_delegate = Signature\n ; set_permissions = Signature\n ; set_verification_key = Signature\n ; set_zkapp_uri = Signature\n ; edit_action_state = Signature\n ; set_token_symbol = Signature\n ; increment_nonce = Signature\n ; set_voting_for = Signature\n ; set_timing = Signature\n ; access = None\n }\n\nlet empty : t =\n { edit_state = None\n ; send = None\n ; receive = None\n ; access = None\n ; set_delegate = None\n ; set_permissions = None\n ; set_verification_key = None\n ; set_zkapp_uri = None\n ; edit_action_state = None\n ; set_token_symbol = None\n ; increment_nonce = None\n ; set_voting_for = None\n ; set_timing = None\n }\n\n(* deriving-fields-related stuff *)\n\nlet auth_required =\n Fields_derivers_zkapps.Derivers.iso_string ~name:\"AuthRequired\"\n ~js_type:(Custom \"AuthRequired\") ~doc:\"Kind of authorization required\"\n ~to_string:Auth_required.to_string ~of_string:Auth_required.of_string\n\nlet deriver obj =\n let open Fields_derivers_zkapps.Derivers in\n let ( !. ) = ( !. ) ~t_fields_annots:Poly.t_fields_annots in\n Poly.Fields.make_creator obj ~edit_state:!.auth_required ~send:!.auth_required\n ~receive:!.auth_required ~set_delegate:!.auth_required\n ~set_permissions:!.auth_required ~set_verification_key:!.auth_required\n ~set_zkapp_uri:!.auth_required ~edit_action_state:!.auth_required\n ~set_token_symbol:!.auth_required ~increment_nonce:!.auth_required\n ~set_voting_for:!.auth_required ~set_timing:!.auth_required\n ~access:!.auth_required\n |> finish \"Permissions\" ~t_toplevel_annots:Poly.t_toplevel_annots\n\nlet%test_unit \"json roundtrip\" =\n let open Fields_derivers_zkapps.Derivers in\n let full = o () in\n let _a = deriver full in\n [%test_eq: t] user_default (user_default |> to_json full |> of_json full)\n\nlet%test_unit \"json value\" =\n let open Fields_derivers_zkapps.Derivers in\n let full = o () in\n let _a = deriver full in\n [%test_eq: string]\n (user_default |> to_json full |> Yojson.Safe.to_string)\n ( {json|{\n editState: \"Signature\",\n access: \"None\",\n send: \"Signature\",\n receive: \"None\",\n setDelegate: \"Signature\",\n setPermissions: \"Signature\",\n setVerificationKey: \"Signature\",\n setZkappUri: \"Signature\",\n editActionState: \"Signature\",\n setTokenSymbol: \"Signature\",\n incrementNonce: \"Signature\",\n setVotingFor: \"Signature\",\n setTiming: \"Signature\"\n }|json}\n |> Yojson.Safe.from_string |> Yojson.Safe.to_string )\n","(* signed_command_memo.ml *)\n\n[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Snark_params\n\n(** See documentation of the {!Mina_wire_types} library *)\nmodule Wire_types = Mina_wire_types.Mina_base.Signed_command_memo\n\nmodule Make_sig (A : Wire_types.Types.S) = struct\n module type S = Signed_command_memo_intf.S with type t = A.V1.t\nend\n\nmodule Make_str (_ : Wire_types.Concrete) = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n [@@@with_all_version_tags]\n\n type t = string [@@deriving sexp, equal, compare, hash]\n\n let to_latest = Fn.id\n\n module Base58_check = Base58_check.Make (struct\n let description = \"User command memo\"\n\n let version_byte = Base58_check.Version_bytes.user_command_memo\n end)\n\n let to_base58_check (memo : t) : string = Base58_check.encode memo\n\n let of_base58_check (s : string) : t Or_error.t = Base58_check.decode s\n\n let of_base58_check_exn (s : string) : t = Base58_check.decode_exn s\n\n module T = struct\n type nonrec t = t\n\n let to_string = to_base58_check\n\n let of_string = of_base58_check_exn\n end\n\n include Codable.Make_of_string (T)\n end\n end]\n\n [%%define_locally\n Stable.Latest.\n (to_yojson, of_yojson, to_base58_check, of_base58_check, of_base58_check_exn)]\n\n exception Too_long_user_memo_input\n\n exception Too_long_digestible_string\n\n let max_digestible_string_length = 1000\n\n (* 0th byte is a tag to distinguish digests from other data\n 1st byte is length, always 32 for digests\n bytes 2 to 33 are data, 0-right-padded if length is less than 32\n *)\n\n let digest_tag = '\\x00'\n\n let bytes_tag = '\\x01'\n\n let tag_index = 0\n\n let length_index = 1\n\n let digest_length = Blake2.digest_size_in_bytes\n\n let digest_length_byte = Char.of_int_exn digest_length\n\n (* +2 for tag and length bytes *)\n let memo_length = digest_length + 2\n\n let max_input_length = digest_length\n\n let tag (memo : t) = memo.[tag_index]\n\n let length memo = Char.to_int memo.[length_index]\n\n let is_bytes memo = Char.equal (tag memo) bytes_tag\n\n let is_digest memo = Char.equal (tag memo) digest_tag\n\n let is_valid memo =\n Int.(String.length memo = memo_length)\n &&\n let length = length memo in\n if is_digest memo then Int.(length = digest_length)\n else\n Char.equal (tag memo) bytes_tag\n && Int.(length <= digest_length)\n &&\n let padded =\n String.sub memo ~pos:(length + 2) ~len:(digest_length - length)\n in\n String.for_all padded ~f:(Char.equal '\\x00')\n\n let create_by_digesting_string_exn s =\n if Int.(String.length s > max_digestible_string_length) then\n raise Too_long_digestible_string ;\n let digest = Blake2.(to_raw_string (digest_string s)) in\n String.init memo_length ~f:(fun ndx ->\n if Int.(ndx = tag_index) then digest_tag\n else if Int.(ndx = length_index) then digest_length_byte\n else digest.[ndx - 2] )\n\n let create_by_digesting_string (s : string) =\n try Ok (create_by_digesting_string_exn s)\n with Too_long_digestible_string ->\n Or_error.error_string \"create_by_digesting_string: string too long\"\n\n module type Memoable = sig\n type t\n\n val length : t -> int\n\n val get : t -> int -> char\n end\n\n let create_from_value_exn (type t) (module M : Memoable with type t = t)\n (value : t) =\n let len = M.length value in\n if Int.(len > max_input_length) then raise Too_long_user_memo_input ;\n String.init memo_length ~f:(fun ndx ->\n if Int.(ndx = tag_index) then bytes_tag\n else if Int.(ndx = length_index) then Char.of_int_exn len\n else if Int.(ndx < len + 2) then M.get value (ndx - 2)\n else '\\x00' )\n\n let create_from_bytes_exn bytes = create_from_value_exn (module Bytes) bytes\n\n let create_from_bytes bytes =\n try Ok (create_from_bytes_exn bytes)\n with Too_long_user_memo_input ->\n Or_error.error_string\n (sprintf \"create_from_bytes: length exceeds %d\" max_input_length)\n\n let create_from_string_exn s = create_from_value_exn (module String) s\n\n let create_from_string s =\n try Ok (create_from_string_exn s)\n with Too_long_user_memo_input ->\n Or_error.error_string\n (sprintf \"create_from_string: length exceeds %d\" max_input_length)\n\n let dummy = (create_by_digesting_string_exn \"\" :> t)\n\n let empty = create_from_string_exn \"\"\n\n type raw = Digest of string | Bytes of string\n\n let to_raw_exn memo =\n let tag = tag memo in\n if Char.equal tag digest_tag then Digest (to_base58_check memo)\n else if Char.equal tag bytes_tag then\n let len = length memo in\n Bytes (String.init len ~f:(fun idx -> memo.[idx - 2]))\n else failwithf \"Unknown memo tag %c\" tag ()\n\n let to_raw_bytes_exn memo =\n match to_raw_exn memo with\n | Digest _ ->\n failwith \"Cannot convert a digest to raw bytes\"\n | Bytes str ->\n str\n\n let of_raw_exn = function\n | Digest base58_check ->\n of_base58_check_exn base58_check\n | Bytes str ->\n of_base58_check_exn str\n\n let fold_bits t =\n { Fold_lib.Fold.fold =\n (fun ~init ~f ->\n let n = 8 * String.length t in\n let rec go acc i =\n if i = n then acc\n else\n let b = (Char.to_int t.[i / 8] lsr (i mod 8)) land 1 = 1 in\n go (f acc b) (i + 1)\n in\n go init 0 )\n }\n\n let to_bits t = Fold_lib.Fold.to_list (fold_bits t)\n\n let gen =\n Quickcheck.Generator.map String.quickcheck_generator\n ~f:create_by_digesting_string_exn\n\n let hash memo =\n Random_oracle.hash ~init:Hash_prefix.zkapp_memo\n (Random_oracle.Legacy.pack_input\n (Random_oracle_input.Legacy.bitstring (to_bits memo)) )\n\n let to_plaintext (memo : t) : string Or_error.t =\n if is_bytes memo then Ok (String.sub memo ~pos:2 ~len:(length memo))\n else Error (Error.of_string \"Memo does not contain text bytes\")\n\n let to_digest (memo : t) : string Or_error.t =\n if is_digest memo then Ok (String.sub memo ~pos:2 ~len:digest_length)\n else Error (Error.of_string \"Memo does not contain a digest\")\n\n let to_string_hum (memo : t) =\n match to_plaintext memo with\n | Ok text ->\n text\n | Error _ -> (\n match to_digest memo with\n | Ok digest ->\n sprintf \"0x%s\" (Hex.encode digest)\n | Error _ ->\n \"(Invalid memo, neither text nor a digest)\" )\n\n [%%ifdef consensus_mechanism]\n\n module Boolean = Tick.Boolean\n module Typ = Tick.Typ\n\n (* the code below is much the same as in Random_oracle.Digest; tag and length bytes\n make it a little different\n *)\n\n module Checked = struct\n type unchecked = t\n\n type t = Boolean.var array\n\n let constant unchecked =\n assert (Int.(String.length (unchecked :> string) = memo_length)) ;\n Array.map\n (Blake2.string_to_bits (unchecked :> string))\n ~f:Boolean.var_of_value\n end\n\n let length_in_bits = 8 * memo_length\n\n let typ : (Checked.t, t) Typ.t =\n Typ.transport\n (Typ.array ~length:length_in_bits Boolean.typ)\n ~there:(fun (t : t) -> Blake2.string_to_bits (t :> string))\n ~back:(fun bs -> (Blake2.bits_to_string bs :> t))\n\n [%%endif]\n\n let deriver obj =\n Fields_derivers_zkapps.iso_string obj ~name:\"Memo\" ~js_type:String\n ~to_string:to_base58_check ~of_string:of_base58_check_exn\n\n let%test_module \"user_command_memo\" =\n ( module struct\n let data memo = String.sub memo ~pos:(length_index + 1) ~len:(length memo)\n\n let%test \"digest string\" =\n let s = \"this is a string\" in\n let memo = create_by_digesting_string_exn s in\n is_valid memo\n\n let%test \"digest too-long string\" =\n let s =\n String.init (max_digestible_string_length + 1) ~f:(fun _ -> '\\xFF')\n in\n try\n let (_ : t) = create_by_digesting_string_exn s in\n false\n with Too_long_digestible_string -> true\n\n let%test \"memo from string\" =\n let s = \"time and tide wait for no one\" in\n let memo = create_from_string_exn s in\n is_valid memo && String.equal s (data memo)\n\n let%test \"memo from too-long string\" =\n let s = String.init (max_input_length + 1) ~f:(fun _ -> '\\xFF') in\n try\n let (_ : t) = create_from_string_exn s in\n false\n with Too_long_user_memo_input -> true\n\n [%%ifdef consensus_mechanism]\n\n let%test_unit \"typ is identity\" =\n let s = \"this is a string\" in\n let memo = create_by_digesting_string_exn s in\n let read_constant = function\n | Snarky_backendless.Cvar.Constant x ->\n x\n | _ ->\n assert false\n in\n let (Typ typ) = typ in\n let memo_var =\n memo |> typ.value_to_fields\n |> (fun (arr, aux) ->\n ( Array.map arr ~f:(fun x -> Snarky_backendless.Cvar.Constant x)\n , aux ) )\n |> typ.var_of_fields\n in\n let memo_read =\n memo_var |> typ.var_to_fields\n |> (fun (arr, aux) ->\n (Array.map arr ~f:(fun x -> read_constant x), aux) )\n |> typ.value_of_fields\n in\n [%test_eq: string] memo memo_read\n\n [%%endif]\n end )\nend\n\ninclude Wire_types.Make (Make_sig) (Make_str)\n","(* stake_delegation.ml *)\n\nopen Core_kernel\nopen Signature_lib\n\n[%%versioned\nmodule Stable = struct\n module V2 = struct\n [@@@with_all_version_tags]\n\n type t = Mina_wire_types.Mina_base.Stake_delegation.V2.t =\n | Set_delegate of { new_delegate : Public_key.Compressed.Stable.V1.t }\n [@@deriving compare, equal, sexp, hash, yojson]\n\n let to_latest = Fn.id\n end\n\n module V1 = struct\n [@@@with_all_version_tags]\n\n type t = Mina_wire_types.Mina_base.Stake_delegation.V1.t =\n | Set_delegate of\n { delegator : Public_key.Compressed.Stable.V1.t\n ; new_delegate : Public_key.Compressed.Stable.V1.t\n }\n [@@deriving compare, equal, sexp, hash, yojson]\n\n let to_latest (Set_delegate { delegator = _; new_delegate }) =\n V2.Set_delegate { new_delegate }\n end\nend]\n\nlet receiver_pk = function Set_delegate { new_delegate } -> new_delegate\n\nlet receiver = function\n | Set_delegate { new_delegate } ->\n Account_id.create new_delegate Token_id.default\n\nlet gen =\n Quickcheck.Generator.map Public_key.Compressed.gen ~f:(fun k ->\n Set_delegate { new_delegate = k } )\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\n\nmodule Failure = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t = Mina_wire_types.Mina_base.Transaction_status.Failure.V2.t =\n | Predicate [@value 1]\n | Source_not_present\n | Receiver_not_present\n | Amount_insufficient_to_create_account\n | Cannot_pay_creation_fee_in_token\n | Source_insufficient_balance\n | Source_minimum_balance_violation\n | Receiver_already_exists\n | Token_owner_not_caller\n | Overflow\n | Global_excess_overflow\n | Local_excess_overflow\n | Local_supply_increase_overflow\n | Global_supply_increase_overflow\n | Signed_command_on_zkapp_account\n | Zkapp_account_not_present\n | Update_not_permitted_balance\n | Update_not_permitted_access\n | Update_not_permitted_timing\n | Update_not_permitted_delegate\n | Update_not_permitted_app_state\n | Update_not_permitted_verification_key\n | Update_not_permitted_action_state\n | Update_not_permitted_zkapp_uri\n | Update_not_permitted_token_symbol\n | Update_not_permitted_permissions\n | Update_not_permitted_nonce\n | Update_not_permitted_voting_for\n | Zkapp_command_replay_check_failed\n | Fee_payer_nonce_must_increase\n | Fee_payer_must_be_signed\n | Account_balance_precondition_unsatisfied\n | Account_nonce_precondition_unsatisfied\n | Account_receipt_chain_hash_precondition_unsatisfied\n | Account_delegate_precondition_unsatisfied\n | Account_action_state_precondition_unsatisfied\n | Account_app_state_precondition_unsatisfied of int\n | Account_proved_state_precondition_unsatisfied\n | Account_is_new_precondition_unsatisfied\n | Protocol_state_precondition_unsatisfied\n | Unexpected_verification_key_hash\n | Valid_while_precondition_unsatisfied\n | Incorrect_nonce\n | Invalid_fee_excess\n | Cancelled\n [@@deriving sexp, yojson, equal, compare, variants, hash]\n\n let to_latest = Fn.id\n end\n end]\n\n module Collection = struct\n module Display = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = (int * Stable.V2.t list) list\n [@@deriving equal, compare, yojson, sexp, hash]\n\n let to_latest = Fn.id\n end\n end]\n end\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Stable.V2.t list list\n [@@deriving equal, compare, yojson, sexp, hash]\n\n let to_latest = Fn.id\n end\n end]\n\n let to_display t : Display.t =\n let _, display =\n List.fold_left t ~init:(0, []) ~f:(fun (index, acc) bucket ->\n if List.is_empty bucket then (index + 1, acc)\n else (index + 1, (index, bucket) :: acc) )\n in\n display\n\n let empty = []\n\n let of_single_failure f : t = [ [ f ] ]\n\n let is_empty : t -> bool = Fn.compose List.is_empty List.concat\n end\n\n type failure = t\n\n let failure_min = min\n\n let failure_max = max\n\n let all =\n let add acc var = var.Variantslib.Variant.constructor :: acc in\n Variants.fold ~init:[] ~predicate:add ~source_not_present:add\n ~receiver_not_present:add ~amount_insufficient_to_create_account:add\n ~cannot_pay_creation_fee_in_token:add ~source_insufficient_balance:add\n ~source_minimum_balance_violation:add ~receiver_already_exists:add\n ~token_owner_not_caller:add ~overflow:add ~global_excess_overflow:add\n ~local_excess_overflow:add ~local_supply_increase_overflow:add\n ~global_supply_increase_overflow:add ~signed_command_on_zkapp_account:add\n ~zkapp_account_not_present:add ~update_not_permitted_balance:add\n ~update_not_permitted_timing:add ~update_not_permitted_access:add\n ~update_not_permitted_delegate:add ~update_not_permitted_app_state:add\n ~update_not_permitted_verification_key:add\n ~update_not_permitted_action_state:add ~update_not_permitted_zkapp_uri:add\n ~update_not_permitted_token_symbol:add\n ~update_not_permitted_permissions:add ~update_not_permitted_nonce:add\n ~update_not_permitted_voting_for:add\n ~zkapp_command_replay_check_failed:add ~fee_payer_nonce_must_increase:add\n ~fee_payer_must_be_signed:add\n ~account_balance_precondition_unsatisfied:add\n ~account_nonce_precondition_unsatisfied:add\n ~account_receipt_chain_hash_precondition_unsatisfied:add\n ~account_delegate_precondition_unsatisfied:add\n ~account_action_state_precondition_unsatisfied:add\n ~account_app_state_precondition_unsatisfied:(fun acc var ->\n List.init 8 ~f:var.constructor @ acc )\n ~account_proved_state_precondition_unsatisfied:add\n ~account_is_new_precondition_unsatisfied:add\n ~protocol_state_precondition_unsatisfied:add\n ~valid_while_precondition_unsatisfied:add\n ~unexpected_verification_key_hash:add ~incorrect_nonce:add\n ~invalid_fee_excess:add ~cancelled:add\n\n let gen = Quickcheck.Generator.of_list all\n\n let to_string = function\n | Predicate ->\n \"Predicate\"\n | Source_not_present ->\n \"Source_not_present\"\n | Receiver_not_present ->\n \"Receiver_not_present\"\n | Amount_insufficient_to_create_account ->\n \"Amount_insufficient_to_create_account\"\n | Cannot_pay_creation_fee_in_token ->\n \"Cannot_pay_creation_fee_in_token\"\n | Source_insufficient_balance ->\n \"Source_insufficient_balance\"\n | Source_minimum_balance_violation ->\n \"Source_minimum_balance_violation\"\n | Receiver_already_exists ->\n \"Receiver_already_exists\"\n | Token_owner_not_caller ->\n \"Token_owner_not_caller\"\n | Overflow ->\n \"Overflow\"\n | Global_excess_overflow ->\n \"Global_excess_overflow\"\n | Local_excess_overflow ->\n \"Local_excess_overflow\"\n | Local_supply_increase_overflow ->\n \"Local_supply_increase_overflow\"\n | Global_supply_increase_overflow ->\n \"Global_supply_increase_overflow\"\n | Signed_command_on_zkapp_account ->\n \"Signed_command_on_zkapp_account\"\n | Zkapp_account_not_present ->\n \"Zkapp_account_not_present\"\n | Update_not_permitted_balance ->\n \"Update_not_permitted_balance\"\n | Update_not_permitted_access ->\n \"Update_not_permitted_access\"\n | Update_not_permitted_timing ->\n \"Update_not_permitted_timing\"\n | Update_not_permitted_delegate ->\n \"update_not_permitted_delegate\"\n | Update_not_permitted_app_state ->\n \"Update_not_permitted_app_state\"\n | Update_not_permitted_verification_key ->\n \"Update_not_permitted_verification_key\"\n | Update_not_permitted_action_state ->\n \"Update_not_permitted_action_state\"\n | Update_not_permitted_zkapp_uri ->\n \"Update_not_permitted_zkapp_uri\"\n | Update_not_permitted_token_symbol ->\n \"Update_not_permitted_token_symbol\"\n | Update_not_permitted_permissions ->\n \"Update_not_permitted_permissions\"\n | Update_not_permitted_nonce ->\n \"Update_not_permitted_nonce\"\n | Update_not_permitted_voting_for ->\n \"Update_not_permitted_voting_for\"\n | Zkapp_command_replay_check_failed ->\n \"Zkapp_command_replay_check_failed\"\n | Fee_payer_nonce_must_increase ->\n \"Fee_payer_nonce_must_increase\"\n | Fee_payer_must_be_signed ->\n \"Fee_payer_must_be_signed\"\n | Account_balance_precondition_unsatisfied ->\n \"Account_balance_precondition_unsatisfied\"\n | Account_nonce_precondition_unsatisfied ->\n \"Account_nonce_precondition_unsatisfied\"\n | Account_receipt_chain_hash_precondition_unsatisfied ->\n \"Account_receipt_chain_hash_precondition_unsatisfied\"\n | Account_delegate_precondition_unsatisfied ->\n \"Account_delegate_precondition_unsatisfied\"\n | Account_action_state_precondition_unsatisfied ->\n \"Account_action_state_precondition_unsatisfied\"\n | Account_app_state_precondition_unsatisfied i ->\n sprintf \"Account_app_state_%i_precondition_unsatisfied\" i\n | Account_proved_state_precondition_unsatisfied ->\n \"Account_proved_state_precondition_unsatisfied\"\n | Account_is_new_precondition_unsatisfied ->\n \"Account_is_new_precondition_unsatisfied\"\n | Protocol_state_precondition_unsatisfied ->\n \"Protocol_state_precondition_unsatisfied\"\n | Valid_while_precondition_unsatisfied ->\n \"Valid_while_precondition_unsatisfied\"\n | Unexpected_verification_key_hash ->\n \"Unexpected_verification_key_hash\"\n | Incorrect_nonce ->\n \"Incorrect_nonce\"\n | Invalid_fee_excess ->\n \"Invalid_fee_excess\"\n | Cancelled ->\n \"Cancelled\"\n\n let of_string = function\n | \"Predicate\" ->\n Ok Predicate\n | \"Source_not_present\" ->\n Ok Source_not_present\n | \"Receiver_not_present\" ->\n Ok Receiver_not_present\n | \"Amount_insufficient_to_create_account\" ->\n Ok Amount_insufficient_to_create_account\n | \"Cannot_pay_creation_fee_in_token\" ->\n Ok Cannot_pay_creation_fee_in_token\n | \"Source_insufficient_balance\" ->\n Ok Source_insufficient_balance\n | \"Source_minimum_balance_violation\" ->\n Ok Source_minimum_balance_violation\n | \"Receiver_already_exists\" ->\n Ok Receiver_already_exists\n | \"Token_owner_not_caller\" ->\n Ok Token_owner_not_caller\n | \"Overflow\" ->\n Ok Overflow\n | \"Global_excess_overflow\" ->\n Ok Global_excess_overflow\n | \"Local_excess_overflow\" ->\n Ok Local_excess_overflow\n | \"Local_supply_increase_overflow\" ->\n Ok Local_supply_increase_overflow\n | \"Global_supply_increase_overflow\" ->\n Ok Global_supply_increase_overflow\n | \"Signed_command_on_zkapp_account\" ->\n Ok Signed_command_on_zkapp_account\n | \"Zkapp_account_not_present\" ->\n Ok Zkapp_account_not_present\n | \"Update_not_permitted_balance\" ->\n Ok Update_not_permitted_balance\n | \"Update_not_permitted_access\" ->\n Ok Update_not_permitted_access\n | \"Update_not_permitted_timing\" ->\n Ok Update_not_permitted_timing\n | \"update_not_permitted_delegate\" ->\n Ok Update_not_permitted_delegate\n | \"Update_not_permitted_app_state\" ->\n Ok Update_not_permitted_app_state\n | \"Update_not_permitted_verification_key\" ->\n Ok Update_not_permitted_verification_key\n | \"Update_not_permitted_action_state\" ->\n Ok Update_not_permitted_action_state\n | \"Update_not_permitted_zkapp_uri\" ->\n Ok Update_not_permitted_zkapp_uri\n | \"Update_not_permitted_token_symbol\" ->\n Ok Update_not_permitted_token_symbol\n | \"Update_not_permitted_permissions\" ->\n Ok Update_not_permitted_permissions\n | \"Update_not_permitted_nonce\" ->\n Ok Update_not_permitted_nonce\n | \"Update_not_permitted_voting_for\" ->\n Ok Update_not_permitted_voting_for\n | \"Zkapp_command_replay_check_failed\" ->\n Ok Zkapp_command_replay_check_failed\n | \"Fee_payer_nonce_must_increase\" ->\n Ok Fee_payer_nonce_must_increase\n | \"Fee_payer_must_be_signed\" ->\n Ok Fee_payer_must_be_signed\n | \"Account_balance_precondition_unsatisfied\" ->\n Ok Account_balance_precondition_unsatisfied\n | \"Account_nonce_precondition_unsatisfied\" ->\n Ok Account_nonce_precondition_unsatisfied\n | \"Account_receipt_chain_hash_precondition_unsatisfied\" ->\n Ok Account_receipt_chain_hash_precondition_unsatisfied\n | \"Account_delegate_precondition_unsatisfied\" ->\n Ok Account_delegate_precondition_unsatisfied\n | \"Account_action_state_precondition_unsatisfied\" ->\n Ok Account_action_state_precondition_unsatisfied\n | \"Account_proved_state_precondition_unsatisfied\" ->\n Ok Account_proved_state_precondition_unsatisfied\n | \"Account_is_new_precondition_unsatisfied\" ->\n Ok Account_is_new_precondition_unsatisfied\n | \"Protocol_state_precondition_unsatisfied\" ->\n Ok Protocol_state_precondition_unsatisfied\n | \"Valid_while_precondition_unsatisfied\" ->\n Ok Valid_while_precondition_unsatisfied\n | \"Unexpected_verification_key_hash\" ->\n Ok Unexpected_verification_key_hash\n | \"Incorrect_nonce\" ->\n Ok Incorrect_nonce\n | \"Invalid_fee_excess\" ->\n Ok Invalid_fee_excess\n | \"Cancelled\" ->\n Ok Cancelled\n | str -> (\n let res =\n List.find_map\n ~f:(fun (prefix, suffix, parse) ->\n Option.try_with (fun () ->\n assert (\n String.length str\n >= String.length prefix + String.length suffix ) ;\n for i = 0 to String.length prefix - 1 do\n assert (Char.equal prefix.[i] str.[i])\n done ;\n let offset = String.length str - String.length suffix in\n for i = 0 to String.length suffix - 1 do\n assert (Char.equal suffix.[i] str.[offset + i])\n done ;\n parse\n (String.sub str ~pos:(String.length prefix)\n ~len:(offset - String.length prefix) ) ) )\n [ ( \"Account_app_state_\"\n , \"_precondition_unsatisfied\"\n , fun str ->\n Account_app_state_precondition_unsatisfied (int_of_string str)\n )\n ]\n in\n match res with\n | Some res ->\n Ok res\n | None ->\n Error \"Transaction_status.Failure.of_string: Unknown value\" )\n\n let%test_unit \"of_string(to_string) roundtrip\" =\n List.iter all ~f:(fun failure ->\n [%test_eq: (t, string) Result.t]\n (of_string (to_string failure))\n (Ok failure) )\n\n let describe = function\n | Predicate ->\n \"A predicate failed\"\n | Source_not_present ->\n \"The source account does not exist\"\n | Receiver_not_present ->\n \"The receiver account does not exist\"\n | Amount_insufficient_to_create_account ->\n \"Cannot create account: transaction amount is smaller than the account \\\n creation fee\"\n | Cannot_pay_creation_fee_in_token ->\n \"Cannot create account: account creation fees cannot be paid in \\\n non-default tokens\"\n | Source_insufficient_balance ->\n \"The source account has an insufficient balance\"\n | Source_minimum_balance_violation ->\n \"The source account requires a minimum balance\"\n | Receiver_already_exists ->\n \"Attempted to create an account that already exists\"\n | Token_owner_not_caller ->\n \"An account update used a non-default token but its caller was not the \\\n token owner\"\n | Overflow ->\n \"The resulting balance is too large to store\"\n | Global_excess_overflow ->\n \"The resulting global fee excess is too large to store\"\n | Local_excess_overflow ->\n \"The resulting local fee excess is too large to store\"\n | Local_supply_increase_overflow ->\n \"The resulting local supply increase is too large to store\"\n | Global_supply_increase_overflow ->\n \"The resulting global supply increase is too large to store\"\n | Signed_command_on_zkapp_account ->\n \"The source of a signed command cannot be a snapp account\"\n | Zkapp_account_not_present ->\n \"A zkApp account does not exist\"\n | Update_not_permitted_balance ->\n \"The authentication for an account didn't allow the requested update \\\n to its balance\"\n | Update_not_permitted_access ->\n \"The authentication for an account didn't allow it to be accessed\"\n | Update_not_permitted_timing ->\n \"The authentication for an account didn't allow the requested update \\\n to its timing\"\n | Update_not_permitted_delegate ->\n \"The authentication for an account didn't allow the requested update \\\n to its delegate\"\n | Update_not_permitted_app_state ->\n \"The authentication for an account didn't allow the requested update \\\n to its app state\"\n | Update_not_permitted_verification_key ->\n \"The authentication for an account didn't allow the requested update \\\n to its verification key\"\n | Update_not_permitted_action_state ->\n \"The authentication for an account didn't allow the requested update \\\n to its action state\"\n | Update_not_permitted_zkapp_uri ->\n \"The authentication for an account didn't allow the requested update \\\n to its snapp URI\"\n | Update_not_permitted_token_symbol ->\n \"The authentication for an account didn't allow the requested update \\\n to its token symbol\"\n | Update_not_permitted_permissions ->\n \"The authentication for an account didn't allow the requested update \\\n to its permissions\"\n | Update_not_permitted_nonce ->\n \"The authentication for an account didn't allow the requested update \\\n to its nonce\"\n | Update_not_permitted_voting_for ->\n \"The authentication for an account didn't allow the requested update \\\n to its voted-for state hash\"\n | Zkapp_command_replay_check_failed ->\n \"Check to avoid replays failed. The account update must increment \\\n nonce or use full commitment if the authorization is a signature\"\n | Fee_payer_nonce_must_increase ->\n \"Fee payer account update must increment its nonce\"\n | Fee_payer_must_be_signed ->\n \"Fee payer account update must have a valid signature\"\n | Account_balance_precondition_unsatisfied ->\n \"The account update's account balance precondition was unsatisfied\"\n | Account_nonce_precondition_unsatisfied ->\n \"The account update's account nonce precondition was unsatisfied\"\n | Account_receipt_chain_hash_precondition_unsatisfied ->\n \"The account update's account receipt-chain hash precondition was \\\n unsatisfied\"\n | Account_delegate_precondition_unsatisfied ->\n \"The account update's account delegate precondition was unsatisfied\"\n | Account_action_state_precondition_unsatisfied ->\n \"The account update's account action state precondition was unsatisfied\"\n | Account_app_state_precondition_unsatisfied i ->\n sprintf\n \"The account update's account app state (%i) precondition was \\\n unsatisfied\"\n i\n | Account_proved_state_precondition_unsatisfied ->\n \"The account update's account proved state precondition was unsatisfied\"\n | Account_is_new_precondition_unsatisfied ->\n \"The account update's account is-new state precondition was unsatisfied\"\n | Protocol_state_precondition_unsatisfied ->\n \"The account update's protocol state precondition unsatisfied\"\n | Valid_while_precondition_unsatisfied ->\n \"The account update's valid-until precondition was unsatisfied\"\n | Unexpected_verification_key_hash ->\n \"The account update's verification key hash does not match the \\\n verification key in the ledger account\"\n | Incorrect_nonce ->\n \"Incorrect nonce\"\n | Invalid_fee_excess ->\n \"Fee excess from zkapp_command transaction more than the transaction \\\n fees\"\n | Cancelled ->\n \"The account update is cancelled because there's a failure in the \\\n zkApp transaction\"\nend\n\n[%%versioned\nmodule Stable = struct\n module V2 = struct\n type t = Mina_wire_types.Mina_base.Transaction_status.V2.t =\n | Applied\n | Failed of Failure.Collection.Stable.V1.t\n [@@deriving sexp, yojson, equal, compare]\n\n let to_latest = Fn.id\n end\nend]\n","(* transaction_union_tag.ml *)\n\n[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\n\n[%%ifdef consensus_mechanism]\n\nopen Snark_params.Tick\n\n[%%else]\n\nopen Mina_base_import\n\n[%%endif]\n\ntype t = Payment | Stake_delegation | Fee_transfer | Coinbase\n[@@deriving enum, equal, sexp]\n\nlet to_string = function\n | Payment ->\n \"payment\"\n | Stake_delegation ->\n \"delegation\"\n | Fee_transfer ->\n \"fee-transfer\"\n | Coinbase ->\n \"coinbase\"\n\nlet gen =\n Quickcheck.Generator.map (Int.gen_incl min max) ~f:(fun i ->\n Option.value_exn (of_enum i) )\n\nmodule Bits = struct\n type t = bool * bool * bool [@@deriving equal]\n\n let of_int i : t =\n let test_mask mask = i land mask = mask in\n (test_mask 0b100, test_mask 0b10, test_mask 0b1)\n\n let of_t x = of_int (to_enum x)\n\n let payment = of_t Payment\n\n let stake_delegation = of_t Stake_delegation\n\n let fee_transfer = of_t Fee_transfer\n\n let coinbase = of_t Coinbase\n\n let to_bits (b1, b2, b3) = [ b1; b2; b3 ]\n\n let to_input_legacy t = Random_oracle.Input.Legacy.bitstring (to_bits t)\n\n [%%ifdef consensus_mechanism]\n\n type var = Boolean.var * Boolean.var * Boolean.var\n\n let typ = Typ.tuple3 Boolean.typ Boolean.typ Boolean.typ\n\n let constant (b1, b2, b3) =\n Boolean.(var_of_value b1, var_of_value b2, var_of_value b3)\n\n [%%endif]\nend\n\nmodule Unpacked = struct\n (* Invariant: exactly one of the tag identifiers must be true. *)\n module Poly = struct\n type 'bool t =\n { is_payment : 'bool\n ; is_stake_delegation : 'bool\n ; is_fee_transfer : 'bool\n ; is_coinbase : 'bool\n ; is_user_command : 'bool\n }\n [@@deriving equal, hlist]\n\n [%%ifdef consensus_mechanism]\n\n let typ (bool : ('bool_var, 'bool) Typ.t) : ('bool_var t, 'bool t) Typ.t =\n Typ.of_hlistable\n [ bool; bool; bool; bool; bool ]\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist\n\n [%%endif]\n end\n\n type t = bool Poly.t [@@deriving equal]\n\n (* An invalid value with all types empty. Do not use directly. *)\n let empty : t =\n { is_payment = false\n ; is_stake_delegation = false\n ; is_fee_transfer = false\n ; is_coinbase = false\n ; is_user_command = false\n }\n\n let payment = { empty with is_payment = true; is_user_command = true }\n\n let stake_delegation =\n { empty with is_stake_delegation = true; is_user_command = true }\n\n let fee_transfer =\n { empty with is_fee_transfer = true; is_user_command = false }\n\n let coinbase = { empty with is_coinbase = true; is_user_command = false }\n\n let of_bits_t (bits : Bits.t) : t =\n match\n List.Assoc.find ~equal:Bits.equal\n [ (Bits.payment, payment)\n ; (Bits.stake_delegation, stake_delegation)\n ; (Bits.fee_transfer, fee_transfer)\n ; (Bits.coinbase, coinbase)\n ]\n bits\n with\n | Some t ->\n t\n | None ->\n raise (Invalid_argument \"Transaction_union_tag.Unpacked.of_bits_t\")\n\n let to_bits_t (t : t) : Bits.t =\n match\n List.Assoc.find ~equal\n [ (payment, Bits.payment)\n ; (stake_delegation, Bits.stake_delegation)\n ; (fee_transfer, Bits.fee_transfer)\n ; (coinbase, Bits.coinbase)\n ]\n t\n with\n | Some bits ->\n bits\n | None ->\n raise (Invalid_argument \"Transaction_union_tag.Unpacked.to_bits_t\")\n\n [%%ifdef consensus_mechanism]\n\n type var = Boolean.var Poly.t\n\n let to_bits_var\n ({ is_payment\n ; is_stake_delegation\n ; is_fee_transfer\n ; is_coinbase\n ; is_user_command = _\n } :\n var ) =\n (* For each bit, compute the sum of all the tags for which that bit is true\n in its bit representation.\n\n Since we have the invariant that exactly one tag identifier is true,\n exactly the bits in that tag's bit representation will be true in the\n resulting bits.\n *)\n let b1, b2, b3 =\n List.fold\n ~init:Field.(Var.(constant zero, constant zero, constant zero))\n [ (Bits.payment, is_payment)\n ; (Bits.stake_delegation, is_stake_delegation)\n ; (Bits.fee_transfer, is_fee_transfer)\n ; (Bits.coinbase, is_coinbase)\n ]\n ~f:(fun (acc1, acc2, acc3) ((bit1, bit2, bit3), bool_var) ->\n let add_if_true bit acc =\n if bit then Field.Var.add acc (bool_var :> Field.Var.t) else acc\n in\n (add_if_true bit1 acc1, add_if_true bit2 acc2, add_if_true bit3 acc3)\n )\n in\n Boolean.Unsafe.(of_cvar b1, of_cvar b2, of_cvar b3)\n\n let typ : (var, t) Typ.t =\n let (Typ base_typ) = Poly.typ Boolean.typ in\n Typ\n { base_typ with\n check =\n (fun ( { is_payment\n ; is_stake_delegation\n ; is_fee_transfer\n ; is_coinbase\n ; is_user_command\n } as t ) ->\n let open Checked.Let_syntax in\n let%bind () = base_typ.check t in\n let%bind () =\n [%with_label_ \"Only one tag is set\"] (fun () ->\n Boolean.Assert.exactly_one\n [ is_payment\n ; is_stake_delegation\n ; is_fee_transfer\n ; is_coinbase\n ] )\n in\n [%with_label_ \"User command flag is correctly set\"] (fun () ->\n Boolean.Assert.exactly_one\n [ is_user_command; is_fee_transfer; is_coinbase ] ) )\n }\n\n let constant\n ({ is_payment\n ; is_stake_delegation\n ; is_fee_transfer\n ; is_coinbase\n ; is_user_command\n } :\n t ) : var =\n { is_payment = Boolean.var_of_value is_payment\n ; is_stake_delegation = Boolean.var_of_value is_stake_delegation\n ; is_fee_transfer = Boolean.var_of_value is_fee_transfer\n ; is_coinbase = Boolean.var_of_value is_coinbase\n ; is_user_command = Boolean.var_of_value is_user_command\n }\n\n let is_payment ({ is_payment; _ } : var) = is_payment\n\n let is_stake_delegation ({ is_stake_delegation; _ } : var) =\n is_stake_delegation\n\n let is_fee_transfer ({ is_fee_transfer; _ } : var) = is_fee_transfer\n\n let is_coinbase ({ is_coinbase; _ } : var) = is_coinbase\n\n let is_user_command ({ is_user_command; _ } : var) = is_user_command\n\n let to_bits t = Bits.to_bits (to_bits_var t)\n\n let to_input_legacy t = Random_oracle.Input.Legacy.bitstring (to_bits t)\n\n [%%endif]\nend\n\nlet unpacked_t_of_t = function\n | Payment ->\n Unpacked.payment\n | Stake_delegation ->\n Unpacked.stake_delegation\n | Fee_transfer ->\n Unpacked.fee_transfer\n | Coinbase ->\n Unpacked.coinbase\n\nlet to_bits tag = Bits.to_bits (Unpacked.to_bits_t (unpacked_t_of_t tag))\n\nlet to_input_legacy tag = Random_oracle.Input.Legacy.bitstring (to_bits tag)\n\n[%%ifdef consensus_mechanism]\n\nlet t_of_unpacked_t (unpacked : Unpacked.t) : t =\n match\n List.Assoc.find ~equal:Unpacked.equal\n [ (Unpacked.payment, Payment)\n ; (Unpacked.stake_delegation, Stake_delegation)\n ; (Unpacked.fee_transfer, Fee_transfer)\n ; (Unpacked.coinbase, Coinbase)\n ]\n unpacked\n with\n | Some t ->\n t\n | None ->\n raise (Invalid_argument \"Transaction_union_tag.t_of_unpacked_t\")\n\nlet bits_t_of_t tag = Unpacked.to_bits_t (unpacked_t_of_t tag)\n\nlet t_of_bits_t tag = t_of_unpacked_t (Unpacked.of_bits_t tag)\n\nlet unpacked_of_t tag = Unpacked.constant (unpacked_t_of_t tag)\n\nlet bits_of_t tag = Bits.constant (bits_t_of_t tag)\n\nlet unpacked_typ =\n Typ.transport Unpacked.typ ~there:unpacked_t_of_t ~back:t_of_unpacked_t\n\nlet bits_typ = Typ.transport Bits.typ ~there:bits_t_of_t ~back:t_of_bits_t\n\nlet%test_module \"predicates\" =\n ( module struct\n let test_predicate checked unchecked =\n let checked x = Checked.return (checked x) in\n for i = min to max do\n Test_util.test_equal unpacked_typ Boolean.typ checked unchecked\n (Option.value_exn (of_enum i))\n done\n\n let one_of xs t = List.mem xs ~equal t\n\n let%test_unit \"is_payment\" =\n test_predicate Unpacked.is_payment (equal Payment)\n\n let%test_unit \"is_stake_delegation\" =\n test_predicate Unpacked.is_stake_delegation (equal Stake_delegation)\n\n let%test_unit \"is_fee_transfer\" =\n test_predicate Unpacked.is_fee_transfer (equal Fee_transfer)\n\n let%test_unit \"is_coinbase\" =\n test_predicate Unpacked.is_coinbase (equal Coinbase)\n\n let%test_unit \"is_user_command\" =\n test_predicate Unpacked.is_user_command\n (one_of [ Payment; Stake_delegation ])\n\n let%test_unit \"not_user_command\" =\n test_predicate\n (fun x -> Boolean.not (Unpacked.is_user_command x))\n (one_of [ Fee_transfer; Coinbase ])\n\n let%test_unit \"bit_representation\" =\n for i = min to max do\n Test_util.test_equal unpacked_typ Bits.typ\n (Fn.compose Checked.return Unpacked.to_bits_var)\n bits_t_of_t\n (Option.value_exn (of_enum i))\n done\n end )\n\n[%%endif]\n","(* user_command_payload.ml *)\n\n[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Snark_params.Tick\nopen Signature_lib\nmodule Memo = Signed_command_memo\nmodule Account_nonce = Mina_numbers.Account_nonce\nmodule Global_slot_since_genesis = Mina_numbers.Global_slot_since_genesis\nmodule Global_slot_legacy = Mina_numbers.Global_slot_legacy\n\n(* This represents the random oracle input corresponding to the old form of the token\n ID, which was a 64-bit integer. The default token id was the number 1.\n\n The corresponding random oracle input is still needed for signing non-snapp\n transactions to maintain compatibility with the old transaction format.\n*)\nmodule Legacy_token_id = struct\n let default : (Field.t, bool) Random_oracle_input.Legacy.t =\n let one = true :: List.init 63 ~f:(fun _ -> false) in\n Random_oracle_input.Legacy.bitstring one\n\n [%%ifdef consensus_mechanism]\n\n let default_checked : (Field.Var.t, Boolean.var) Random_oracle_input.Legacy.t\n =\n { field_elements = Array.map default.field_elements ~f:Field.Var.constant\n ; bitstrings =\n Array.map default.bitstrings ~f:(List.map ~f:Boolean.var_of_value)\n }\n\n [%%endif]\nend\n\nmodule Common = struct\n module Poly = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type ('fee, 'public_key, 'nonce, 'global_slot, 'memo) t =\n ( 'fee\n , 'public_key\n , 'nonce\n , 'global_slot\n , 'memo )\n Mina_wire_types.Mina_base.Signed_command_payload.Common.Poly.V2.t =\n { fee : 'fee\n ; fee_payer_pk : 'public_key\n ; nonce : 'nonce\n ; valid_until : 'global_slot\n ; memo : 'memo\n }\n [@@deriving compare, equal, sexp, hash, yojson, hlist]\n end\n\n module V1 = struct\n [@@@with_all_version_tags]\n\n type ('fee, 'public_key, 'token_id, 'nonce, 'global_slot, 'memo) t =\n { fee : 'fee\n ; fee_token : 'token_id\n ; fee_payer_pk : 'public_key\n ; nonce : 'nonce\n ; valid_until : 'global_slot\n ; memo : 'memo\n }\n [@@deriving compare, equal, sexp, hash, yojson, hlist]\n end\n end]\n end\n\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t =\n ( Currency.Fee.Stable.V1.t\n , Public_key.Compressed.Stable.V1.t\n , Account_nonce.Stable.V1.t\n , Global_slot_since_genesis.Stable.V1.t\n , Memo.Stable.V1.t )\n Poly.Stable.V2.t\n [@@deriving compare, equal, sexp, hash, yojson]\n\n let to_latest = Fn.id\n end\n\n module V1 = struct\n [@@@with_all_version_tags]\n\n type t =\n ( Currency.Fee.Stable.V1.t\n , Public_key.Compressed.Stable.V1.t\n , Token_id.Stable.V1.t\n , Account_nonce.Stable.V1.t\n , Global_slot_legacy.Stable.V1.t\n , Memo.Stable.V1.t )\n Poly.Stable.V1.t\n [@@deriving compare, equal, sexp, hash, yojson]\n\n let to_latest _ = failwith \"Not implemented\"\n end\n end]\n\n let to_input_legacy ({ fee; fee_payer_pk; nonce; valid_until; memo } : t) =\n let bitstring = Random_oracle.Input.Legacy.bitstring in\n Array.reduce_exn ~f:Random_oracle.Input.Legacy.append\n [| Currency.Fee.to_input_legacy fee\n ; Legacy_token_id.default\n ; Public_key.Compressed.to_input_legacy fee_payer_pk\n ; Account_nonce.to_input_legacy nonce\n ; Global_slot_since_genesis.to_input_legacy valid_until\n ; bitstring (Memo.to_bits memo)\n |]\n\n let gen : t Quickcheck.Generator.t =\n let open Quickcheck.Generator.Let_syntax in\n let%map fee = Currency.Fee.gen\n and fee_payer_pk = Public_key.Compressed.gen\n and nonce = Account_nonce.gen\n and valid_until = Global_slot_since_genesis.gen\n and memo =\n let%bind is_digest = Bool.quickcheck_generator in\n if is_digest then\n String.gen_with_length Memo.max_digestible_string_length\n Char.quickcheck_generator\n >>| Memo.create_by_digesting_string_exn\n else\n String.gen_with_length Memo.max_input_length Char.quickcheck_generator\n >>| Memo.create_from_string_exn\n in\n Poly.{ fee; fee_payer_pk; nonce; valid_until; memo }\n\n [%%ifdef consensus_mechanism]\n\n type var =\n ( Currency.Fee.var\n , Public_key.Compressed.var\n , Account_nonce.Checked.t\n , Global_slot_since_genesis.Checked.t\n , Memo.Checked.t )\n Poly.t\n\n let typ =\n Typ.of_hlistable\n [ Currency.Fee.typ\n ; Public_key.Compressed.typ\n ; Account_nonce.typ\n ; Global_slot_since_genesis.typ\n ; Memo.typ\n ]\n ~var_to_hlist:Poly.to_hlist ~var_of_hlist:Poly.of_hlist\n ~value_to_hlist:Poly.to_hlist ~value_of_hlist:Poly.of_hlist\n\n module Checked = struct\n let constant ({ fee; fee_payer_pk; nonce; valid_until; memo } : t) : var =\n { fee = Currency.Fee.var_of_t fee\n ; fee_payer_pk = Public_key.Compressed.var_of_t fee_payer_pk\n ; nonce = Account_nonce.Checked.constant nonce\n ; memo = Memo.Checked.constant memo\n ; valid_until = Global_slot_since_genesis.Checked.constant valid_until\n }\n\n let to_input_legacy ({ fee; fee_payer_pk; nonce; valid_until; memo } : var)\n =\n let%map nonce = Account_nonce.Checked.to_input_legacy nonce\n and valid_until =\n Global_slot_since_genesis.Checked.to_input_legacy valid_until\n and fee = Currency.Fee.var_to_input_legacy fee in\n let fee_token = Legacy_token_id.default_checked in\n Array.reduce_exn ~f:Random_oracle.Input.Legacy.append\n [| fee\n ; fee_token\n ; Public_key.Compressed.Checked.to_input_legacy fee_payer_pk\n ; nonce\n ; valid_until\n ; Random_oracle.Input.Legacy.bitstring\n (Array.to_list (memo :> Boolean.var array))\n |]\n end\n\n [%%endif]\nend\n\nmodule Body = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t = Mina_wire_types.Mina_base.Signed_command_payload.Body.V2.t =\n | Payment of Payment_payload.Stable.V2.t\n | Stake_delegation of Stake_delegation.Stable.V2.t\n [@@deriving sexp, compare, equal, sexp, hash, yojson]\n\n let to_latest = Fn.id\n end\n\n module V1 = struct\n [@@@with_all_version_tags]\n\n type t =\n | Payment of Payment_payload.Stable.V1.t\n | Stake_delegation of Stake_delegation.Stable.V1.t\n (* omitting token commands, none were ever created\n such omission doesn't affect serialization/Base58Check of payments, delegations\n *)\n [@@deriving sexp, compare, equal, sexp, hash, yojson]\n\n let to_latest _ = failwith \"Not implemented\"\n end\n end]\n\n module Tag = Transaction_union_tag\n\n let gen max_amount =\n let open Quickcheck.Generator in\n map\n (variant2 (Payment_payload.gen max_amount) Stake_delegation.gen)\n ~f:(function `A p -> Payment p | `B d -> Stake_delegation d)\n\n let receiver_pk (t : t) =\n match t with\n | Payment payload ->\n payload.receiver_pk\n | Stake_delegation payload ->\n Stake_delegation.receiver_pk payload\n\n let token (_ : t) = Token_id.default\n\n let receiver t =\n match t with\n | Payment payload ->\n Account_id.create payload.receiver_pk Token_id.default\n | Stake_delegation payload ->\n Stake_delegation.receiver payload\n\n let tag = function\n | Payment _ ->\n Transaction_union_tag.Payment\n | Stake_delegation _ ->\n Transaction_union_tag.Stake_delegation\nend\n\nmodule Poly = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n [@@@with_all_version_tags]\n\n type ('common, 'body) t =\n ( 'common\n , 'body )\n Mina_wire_types.Mina_base.Signed_command_payload.Poly.V1.t =\n { common : 'common; body : 'body }\n [@@deriving equal, sexp, hash, yojson, compare, hlist]\n\n let of_latest common_latest body_latest { common; body } =\n let open Result.Let_syntax in\n let%map common = common_latest common and body = body_latest body in\n { common; body }\n end\n end]\nend\n\n[%%versioned\nmodule Stable = struct\n module V2 = struct\n type t = (Common.Stable.V2.t, Body.Stable.V2.t) Poly.Stable.V1.t\n [@@deriving compare, equal, sexp, hash, yojson]\n\n let to_latest = Fn.id\n end\n\n module V1 = struct\n [@@@with_all_version_tags]\n\n type t = (Common.Stable.V1.t, Body.Stable.V1.t) Poly.Stable.V1.t\n [@@deriving compare, equal, sexp, hash, yojson]\n\n (* don't need to coerce old transactions to newer version *)\n let to_latest _ = failwith \"Not implemented\"\n end\nend]\n\nlet create ~fee ~fee_payer_pk ~nonce ~valid_until ~memo ~body : t =\n { common =\n { fee\n ; fee_payer_pk\n ; nonce\n ; valid_until =\n Option.value valid_until ~default:Global_slot_since_genesis.max_value\n ; memo\n }\n ; body\n }\n\nlet fee (t : t) = t.common.fee\n\nlet fee_token (_ : t) = Token_id.default\n\nlet fee_payer_pk (t : t) = t.common.fee_payer_pk\n\nlet fee_payer (t : t) = Account_id.create t.common.fee_payer_pk Token_id.default\n\nlet nonce (t : t) = t.common.nonce\n\nlet valid_until (t : t) = t.common.valid_until\n\nlet memo (t : t) = t.common.memo\n\nlet body (t : t) = t.body\n\nlet receiver_pk (t : t) = Body.receiver_pk t.body\n\nlet receiver (t : t) = Body.receiver t.body\n\nlet token (t : t) = Body.token t.body\n\nlet tag (t : t) = Body.tag t.body\n\nlet amount (t : t) =\n match t.body with\n | Payment payload ->\n Some payload.Payment_payload.Poly.amount\n | Stake_delegation _ ->\n None\n\nlet fee_excess (t : t) =\n Fee_excess.of_single (fee_token t, Currency.Fee.Signed.of_unsigned (fee t))\n\nlet account_access_statuses (t : t) (status : Transaction_status.t) =\n match status with\n | Applied ->\n List.map\n [ fee_payer t; receiver t ]\n ~f:(fun acct_id -> (acct_id, `Accessed))\n | Failed _ ->\n (fee_payer t, `Accessed)\n :: List.map [ receiver t ] ~f:(fun acct_id -> (acct_id, `Not_accessed))\n\nlet dummy : t =\n { common =\n { fee = Currency.Fee.zero\n ; fee_payer_pk = Public_key.Compressed.empty\n ; nonce = Account_nonce.zero\n ; valid_until = Global_slot_since_genesis.max_value\n ; memo = Memo.dummy\n }\n ; body = Payment Payment_payload.dummy\n }\n\nlet gen =\n let open Quickcheck.Generator.Let_syntax in\n let%bind common = Common.gen in\n let max_amount =\n Currency.Amount.(sub max_int (of_fee common.fee))\n |> Option.value_exn ?here:None ?error:None ?message:None\n in\n let%map body = Body.gen max_amount in\n Poly.{ common; body }\n\n(** This module defines a weight for each payload component *)\nmodule Weight = struct\n let payment (_payment_payload : Payment_payload.t) : int = 1\n\n let stake_delegation (_stake_delegation : Stake_delegation.t) : int = 1\n\n let of_body : Body.t -> int = function\n | Payment payment_payload ->\n payment payment_payload\n | Stake_delegation stake_delegation_payload ->\n stake_delegation stake_delegation_payload\nend\n\nlet weight (signed_command_payload : t) : int =\n body signed_command_payload |> Weight.of_body\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Mina_base_import\nopen Mina_numbers\n\n(** See documentation of the {!Mina_wire_types} library *)\nmodule Wire_types = Mina_wire_types.Mina_base.Signed_command\n\nmodule Make_sig (A : Wire_types.Types.S) = struct\n module type S =\n Signed_command_intf.Full\n with type With_valid_signature.Stable.Latest.t =\n A.With_valid_signature.V2.t\nend\n\nmodule Make_str (_ : Wire_types.Concrete) = struct\n module Fee = Currency.Fee\n module Payload = Signed_command_payload\n\n module Poly = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n [@@@with_all_version_tags]\n\n type ('payload, 'pk, 'signature) t =\n ( 'payload\n , 'pk\n , 'signature )\n Mina_wire_types.Mina_base.Signed_command.Poly.V1.t =\n { payload : 'payload; signer : 'pk; signature : 'signature }\n [@@deriving compare, sexp, hash, yojson, equal]\n end\n end]\n end\n\n [%%versioned\n module Stable = struct\n [@@@with_top_version_tag]\n\n (* DO NOT DELETE VERSIONS!\n so we can always get transaction hashes from old transaction ids\n the version linter should be checking this\n\n IF YOU CREATE A NEW VERSION:\n update Transaction_hash.hash_of_transaction_id to handle it\n add hash_signed_command_vn for that version\n *)\n\n module V2 = struct\n type t =\n ( Payload.Stable.V2.t\n , Public_key.Stable.V1.t\n , Signature.Stable.V1.t )\n Poly.Stable.V1.t\n [@@deriving compare, sexp, hash, yojson]\n\n let to_latest = Fn.id\n\n module T = struct\n (* can't use nonrec + deriving *)\n type typ = t [@@deriving compare, sexp, hash]\n\n type t = typ [@@deriving compare, sexp, hash]\n end\n\n include Comparable.Make (T)\n include Hashable.Make (T)\n\n let account_access_statuses ({ payload; _ } : t) status =\n Payload.account_access_statuses payload status\n\n let accounts_referenced (t : t) =\n List.map (account_access_statuses t Applied)\n ~f:(fun (acct_id, _status) -> acct_id)\n end\n\n module V1 = struct\n [@@@with_all_version_tags]\n\n type t =\n ( Payload.Stable.V1.t\n , Public_key.Stable.V1.t\n , Signature.Stable.V1.t )\n Poly.Stable.V1.t\n [@@deriving compare, sexp, hash, yojson]\n\n let to_latest ({ payload; signer; signature } : t) : Latest.t =\n let payload : Signed_command_payload.t =\n let valid_until =\n Global_slot_legacy.to_uint32 payload.common.valid_until\n |> Global_slot_since_genesis.of_uint32\n in\n let common : Signed_command_payload.Common.t =\n { fee = payload.common.fee\n ; fee_payer_pk = payload.common.fee_payer_pk\n ; nonce = payload.common.nonce\n ; valid_until\n ; memo = payload.common.memo\n }\n in\n let body : Signed_command_payload.Body.t =\n match payload.body with\n | Payment payment_payload ->\n let payload' : Payment_payload.t =\n { receiver_pk = payment_payload.receiver_pk\n ; amount = payment_payload.amount\n }\n in\n Payment payload'\n | Stake_delegation stake_delegation_payload ->\n Stake_delegation\n (Stake_delegation.Stable.V1.to_latest stake_delegation_payload)\n in\n { common; body }\n in\n { payload; signer; signature }\n end\n end]\n\n (* type of signed commands, pre-Berkeley hard fork *)\n type t_v1 = Stable.V1.t\n\n let (_ : (t, (Payload.t, Public_key.t, Signature.t) Poly.t) Type_equal.t) =\n Type_equal.T\n\n include (Stable.Latest : module type of Stable.Latest with type t := t)\n\n let payload Poly.{ payload; _ } = payload\n\n let fee = Fn.compose Payload.fee payload\n\n let nonce = Fn.compose Payload.nonce payload\n\n (* for filtering *)\n let minimum_fee = Currency.Fee.minimum_user_command_fee\n\n let has_insufficient_fee t = Currency.Fee.(fee t < minimum_fee)\n\n let signer { Poly.signer; _ } = signer\n\n let fee_token (_ : t) = Token_id.default\n\n let fee_payer_pk ({ payload; _ } : t) = Payload.fee_payer_pk payload\n\n let fee_payer ({ payload; _ } : t) = Payload.fee_payer payload\n\n let fee_excess ({ payload; _ } : t) = Payload.fee_excess payload\n\n let token ({ payload; _ } : t) = Payload.token payload\n\n let receiver_pk ({ payload; _ } : t) = Payload.receiver_pk payload\n\n let receiver ({ payload; _ } : t) = Payload.receiver payload\n\n let amount = Fn.compose Payload.amount payload\n\n let memo = Fn.compose Payload.memo payload\n\n let valid_until = Fn.compose Payload.valid_until payload\n\n let tag ({ payload; _ } : t) = Payload.tag payload\n\n let tag_string (t : t) =\n match t.payload.body with\n | Payment _ ->\n \"payment\"\n | Stake_delegation _ ->\n \"delegation\"\n\n let to_input_legacy (payload : Payload.t) =\n Transaction_union_payload.(\n to_input_legacy (of_user_command_payload payload))\n\n let sign_payload ?signature_kind (private_key : Signature_lib.Private_key.t)\n (payload : Payload.t) : Signature.t =\n Signature_lib.Schnorr.Legacy.sign ?signature_kind private_key\n (to_input_legacy payload)\n\n let sign ?signature_kind (kp : Signature_keypair.t) (payload : Payload.t) : t\n =\n { payload\n ; signer = kp.public_key\n ; signature = sign_payload ?signature_kind kp.private_key payload\n }\n\n module For_tests = struct\n (* Pretend to sign a command. Much faster than actually signing. *)\n let fake_sign ?signature_kind:_ (kp : Signature_keypair.t)\n (payload : Payload.t) : t =\n { payload; signer = kp.public_key; signature = Signature.dummy }\n end\n\n module Gen = struct\n let gen_inner (sign' : Signature_lib.Keypair.t -> Payload.t -> t) ~key_gen\n ?(nonce = Account_nonce.zero) ~fee_range create_body =\n let open Quickcheck.Generator.Let_syntax in\n let min_fee = Fee.to_nanomina_int Currency.Fee.minimum_user_command_fee in\n let max_fee = min_fee + fee_range in\n let%bind (signer : Signature_keypair.t), (receiver : Signature_keypair.t)\n =\n key_gen\n and fee =\n Int.gen_incl min_fee max_fee >>| Currency.Fee.of_nanomina_int_exn\n and memo = String.quickcheck_generator in\n let%map body = create_body signer receiver in\n let payload : Payload.t =\n Payload.create ~fee\n ~fee_payer_pk:(Public_key.compress signer.public_key)\n ~nonce ~valid_until:None\n ~memo:(Signed_command_memo.create_by_digesting_string_exn memo)\n ~body\n in\n sign' signer payload\n\n let with_random_participants ~keys ~gen =\n let key_gen = Quickcheck_lib.gen_pair @@ Quickcheck_lib.of_array keys in\n gen ~key_gen\n\n module Payment = struct\n let gen_inner (sign' : Signature_lib.Keypair.t -> Payload.t -> t) ~key_gen\n ?nonce ?(min_amount = 1) ~max_amount ~fee_range () =\n gen_inner sign' ~key_gen ?nonce ~fee_range\n @@ fun { public_key = signer; _ } { public_key = receiver; _ } ->\n let open Quickcheck.Generator.Let_syntax in\n let%map amount =\n Int.gen_incl min_amount max_amount\n >>| Currency.Amount.of_nanomina_int_exn\n in\n Signed_command_payload.Body.Payment\n { receiver_pk = Public_key.compress receiver; amount }\n\n let gen ?(sign_type = `Fake) =\n match sign_type with\n | `Fake ->\n gen_inner For_tests.fake_sign\n | `Real ->\n gen_inner sign\n\n let gen_with_random_participants ?sign_type ~keys ?nonce ?min_amount\n ~max_amount ~fee_range =\n with_random_participants ~keys ~gen:(fun ~key_gen ->\n gen ?sign_type ~key_gen ?nonce ?min_amount ~max_amount ~fee_range )\n end\n\n module Stake_delegation = struct\n let gen ~key_gen ?nonce ~fee_range () =\n gen_inner For_tests.fake_sign ~key_gen ?nonce ~fee_range\n (fun { public_key = signer; _ } { public_key = new_delegate; _ } ->\n Quickcheck.Generator.return\n @@ Signed_command_payload.Body.Stake_delegation\n (Set_delegate\n { new_delegate = Public_key.compress new_delegate } ) )\n\n let gen_with_random_participants ~keys ?nonce ~fee_range =\n with_random_participants ~keys ~gen:(gen ?nonce ~fee_range)\n end\n\n let payment = Payment.gen\n\n let payment_with_random_participants = Payment.gen_with_random_participants\n\n let stake_delegation = Stake_delegation.gen\n\n let stake_delegation_with_random_participants =\n Stake_delegation.gen_with_random_participants\n\n let sequence :\n ?length:int\n -> ?sign_type:[ `Fake | `Real ]\n -> ( Signature_lib.Keypair.t\n * Currency.Amount.t\n * Mina_numbers.Account_nonce.t\n * Account_timing.t )\n array\n -> t list Quickcheck.Generator.t =\n fun ?length ?(sign_type = `Fake) account_info ->\n let open Quickcheck.Generator in\n let open Quickcheck.Generator.Let_syntax in\n let%bind n_commands =\n Option.value_map length ~default:small_non_negative_int ~f:return\n in\n if Int.(n_commands = 0) then return []\n else\n let n_accounts = Array.length account_info in\n let%bind command_senders, currency_splits =\n (* How many commands will be issued from each account? *)\n (let%bind command_splits =\n Quickcheck_lib.gen_division n_commands n_accounts\n in\n let command_splits' = Array.of_list command_splits in\n (* List of payment senders in the final order. *)\n let%bind command_senders =\n Quickcheck_lib.shuffle\n @@ List.concat_mapi command_splits ~f:(fun idx cmds ->\n List.init cmds ~f:(Fn.const idx) )\n in\n (* within the accounts, how will the currency be split into separate\n payments? *)\n let%bind currency_splits =\n Quickcheck_lib.init_gen_array\n ~f:(fun i ->\n let%bind spend_all = bool in\n let _, balance, _, _ = account_info.(i) in\n let amount_to_spend =\n if spend_all then balance\n else\n Currency.Amount.of_nanomina_int_exn\n (Currency.Amount.to_nanomina_int balance / 2)\n in\n Quickcheck_lib.gen_division_currency amount_to_spend\n command_splits'.(i) )\n n_accounts\n in\n return (command_senders, currency_splits) )\n |> (* We need to ensure each command has enough currency for a fee of 2\n or more, so it'll be enough to buy the requisite transaction\n snarks. It's important that the backtracking from filter goes and\n redraws command_splits as well as currency_splits, so we don't get\n stuck in a situation where it's very unlikely for the predicate to\n pass. *)\n Quickcheck.Generator.filter ~f:(fun (_, splits) ->\n Array.for_all splits ~f:(fun split ->\n List.for_all split ~f:(fun amt ->\n Currency.Amount.(amt >= of_mina_int_exn 2) ) ) )\n in\n let account_nonces =\n Array.map ~f:(fun (_, _, nonce, _) -> nonce) account_info\n in\n let uncons_exn = function\n | [] ->\n failwith \"uncons_exn\"\n | x :: xs ->\n (x, xs)\n in\n Quickcheck_lib.map_gens command_senders ~f:(fun sender ->\n let this_split, rest_splits = uncons_exn currency_splits.(sender) in\n let sender_pk, _, _, _ = account_info.(sender) in\n currency_splits.(sender) <- rest_splits ;\n let nonce = account_nonces.(sender) in\n account_nonces.(sender) <- Account_nonce.succ nonce ;\n let%bind fee =\n (* use of_string here because json_of_ocaml won't handle\n equivalent integer constants\n *)\n Currency.Fee.(\n gen_incl (of_string \"6000000000\")\n (min (of_string \"10000000000\")\n (Currency.Amount.to_fee this_split) ))\n in\n let amount =\n Option.value_exn Currency.Amount.(this_split - of_fee fee)\n in\n let%bind receiver =\n map ~f:(fun idx ->\n let kp, _, _, _ = account_info.(idx) in\n Public_key.compress kp.public_key )\n @@ Int.gen_uniform_incl 0 (n_accounts - 1)\n in\n let memo = Signed_command_memo.dummy in\n let payload =\n let sender_pk = Public_key.compress sender_pk.public_key in\n Payload.create ~fee ~fee_payer_pk:sender_pk ~valid_until:None\n ~nonce ~memo\n ~body:(Payment { receiver_pk = receiver; amount })\n in\n let sign' =\n match sign_type with\n | `Fake ->\n For_tests.fake_sign\n | `Real ->\n sign\n in\n return @@ sign' sender_pk payload )\n end\n\n module With_valid_signature = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t = Stable.V2.t [@@deriving sexp, equal, yojson, hash]\n\n let to_latest = Stable.V2.to_latest\n\n let compare = Stable.V2.compare\n\n let equal = Stable.V2.equal\n\n module Gen = Gen\n end\n end]\n\n module Gen = Stable.Latest.Gen\n include Comparable.Make (Stable.Latest)\n end\n\n let to_valid_unsafe t =\n `If_this_is_used_it_should_have_a_comment_justifying_it t\n\n (* so we can deserialize Base58Check transaction ids created before Berkeley hard fork *)\n module V1_all_tagged = struct\n include Stable.V1.With_all_version_tags\n\n let description = \"Signed command\"\n\n let version_byte = Base58_check.Version_bytes.signed_command_v1\n end\n\n let of_base58_check_exn_v1, to_base58_check_v1 =\n let module Base58_check_v1 = Codable.Make_base58_check (V1_all_tagged) in\n Base58_check_v1.(of_base58_check, to_base58_check)\n\n (* give transaction ids have version tag *)\n include Codable.Make_base64 (Stable.Latest.With_top_version_tag)\n\n let check_signature ?signature_kind ({ payload; signer; signature } : t) =\n Signature_lib.Schnorr.Legacy.verify ?signature_kind signature\n (Snark_params.Tick.Inner_curve.of_affine signer)\n (to_input_legacy payload)\n\n let public_keys t =\n let fee_payer = fee_payer_pk t in\n let receiver = receiver_pk t in\n [ fee_payer; receiver ]\n\n let check_valid_keys t =\n List.for_all (public_keys t) ~f:(fun pk ->\n Option.is_some (Public_key.decompress pk) )\n\n let create_with_signature_checked ?signature_kind signature signer payload =\n let open Option.Let_syntax in\n let%bind signer = Public_key.decompress signer in\n let t = Poly.{ payload; signature; signer } in\n Option.some_if (check_signature ?signature_kind t && check_valid_keys t) t\n\n let gen_test =\n let open Quickcheck.Let_syntax in\n let%bind keys =\n Quickcheck.Generator.list_with_length 2 Signature_keypair.gen\n in\n Gen.payment_with_random_participants ~sign_type:`Real\n ~keys:(Array.of_list keys) ~max_amount:10000 ~fee_range:1000 ()\n\n let%test_unit \"completeness\" =\n Quickcheck.test ~trials:20 gen_test ~f:(fun t -> assert (check_signature t))\n\n let%test_unit \"json\" =\n Quickcheck.test ~trials:20 ~sexp_of:sexp_of_t gen_test ~f:(fun t ->\n assert (Codable.For_tests.check_encoding (module Stable.Latest) ~equal t) )\n\n (* return type is `t option` here, interface coerces that to `With_valid_signature.t option` *)\n let check t = Option.some_if (check_signature t && check_valid_keys t) t\n\n (* return type is `t option` here, interface coerces that to `With_valid_signature.t option` *)\n let check_only_for_signature t = Option.some_if (check_signature t) t\n\n let forget_check t = t\n\n let filter_by_participant user_commands public_key =\n List.filter user_commands ~f:(fun user_command ->\n Core_kernel.List.exists\n (accounts_referenced user_command)\n ~f:\n (Fn.compose\n (Public_key.Compressed.equal public_key)\n Account_id.public_key ) )\n\n let%test \"latest signed command version\" =\n (* if this test fails, update `Transaction_hash.hash_of_transaction_id`\n for latest version, then update this test\n *)\n Int.equal Stable.Latest.version 2\nend\n\ninclude Wire_types.Make (Make_sig) (Make_str)\n","(* receipt.ml *)\n\n[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nmodule B58_lib = Base58_check\nopen Snark_params.Tick\n\nmodule Signed_command_elt = struct\n type t = Signed_command_payload of Signed_command.Payload.t\nend\n\nmodule Zkapp_command_elt = struct\n type t = Zkapp_command_commitment of Random_oracle.Digest.t\nend\n\nmodule Chain_hash = struct\n include Data_hash.Make_full_size (struct\n let description = \"Receipt chain hash\"\n\n let version_byte = Base58_check.Version_bytes.receipt_chain_hash\n end)\n\n (* Data hash versioned boilerplate below *)\n\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n module T = struct\n type t = (Field.t[@version_asserted]) [@@deriving sexp, compare, hash]\n end\n\n include T\n\n let to_latest = Fn.id\n\n [%%define_from_scope to_yojson, of_yojson]\n\n include Comparable.Make (T)\n include Hashable.Make_binable (T)\n end\n end]\n\n let (_ : (t, Stable.Latest.t) Type_equal.t) = Type_equal.T\n\n let equal = Stable.Latest.equal\n\n let empty = of_hash Random_oracle.(salt \"CodaReceiptEmpty\" |> digest)\n\n let cons_signed_command_payload (e : Signed_command_elt.t) (t : t) =\n let open Random_oracle.Legacy in\n let x =\n match e with\n | Signed_command_payload payload ->\n Transaction_union_payload.(\n to_input_legacy (of_user_command_payload payload))\n in\n Input.(append x (field (t :> Field.t)))\n |> pack_input\n |> hash ~init:Hash_prefix.receipt_chain_signed_command\n |> of_hash\n\n (* prepend account_update index computed by Zkapp_command_logic.apply *)\n let cons_zkapp_command_commitment (index : Mina_numbers.Index.t)\n (e : Zkapp_command_elt.t) (t : t) =\n let open Random_oracle in\n let x =\n match e with Zkapp_command_commitment s -> Input.Chunked.field s\n in\n let index_input = Mina_numbers.Index.to_input index in\n Input.Chunked.(append index_input (append x (field (t :> Field.t))))\n |> pack_input\n |> hash ~init:Hash_prefix.receipt_chain_zkapp_command\n |> of_hash\n\n [%%if defined consensus_mechanism]\n\n module Checked = struct\n module Signed_command_elt = struct\n type t = Signed_command_payload of Transaction_union_payload.var\n end\n\n module Zkapp_command_elt = struct\n type t = Zkapp_command_commitment of Random_oracle.Checked.Digest.t\n end\n\n let constant (t : t) =\n var_of_hash_packed (Field.Var.constant (t :> Field.t))\n\n type t = var\n\n let equal t1 t2 = equal_var t1 t2\n\n let if_ = if_\n\n let cons_signed_command_payload (e : Signed_command_elt.t) t =\n let open Random_oracle.Legacy in\n let%bind x =\n match e with\n | Signed_command_payload payload ->\n let%map payload =\n Transaction_union_payload.Checked.to_input_legacy payload\n in\n payload\n in\n make_checked (fun () ->\n Checked.hash ~init:Hash_prefix.receipt_chain_signed_command\n (Checked.pack_input Input.(append x (field (var_to_hash_packed t))))\n |> var_of_hash_packed )\n\n (* prepend account_update index *)\n let cons_zkapp_command_commitment (index : Mina_numbers.Index.Checked.t)\n (e : Zkapp_command_elt.t) (t : t) =\n let open Random_oracle in\n let%bind x =\n match e with\n | Zkapp_command_commitment s ->\n Let_syntax.return (Input.Chunked.field s)\n in\n let index_input = Mina_numbers.Index.Checked.to_input index in\n make_checked (fun () ->\n Checked.hash ~init:Hash_prefix.receipt_chain_zkapp_command\n (Checked.pack_input\n Input.Chunked.(\n append index_input (append x (field (var_to_hash_packed t)))) )\n |> var_of_hash_packed )\n end\n\n [%%endif]\nend\n","open Core_kernel\nopen Snark_params.Tick\n\ninclude Data_hash.Make_full_size (struct\n let description = \"State body hash\"\n\n let version_byte = Base58_check.Version_bytes.state_body_hash\nend)\n\nlet dummy = of_hash Outside_hash_image.t\n\n(* Data hash versioned boilerplate below *)\n\n[%%versioned\nmodule Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n module T = struct\n type t = (Field.t[@version_asserted]) [@@deriving sexp, compare, hash]\n end\n\n include T\n\n let to_latest = Fn.id\n\n [%%define_from_scope to_yojson, of_yojson]\n\n include Comparable.Make (T)\n include Hashable.Make_binable (T)\n end\nend]\n\nlet (_ : (t, Stable.Latest.t) Type_equal.t) = Type_equal.T\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\n\nlet field_of_bool = Mina_base_util.field_of_bool\n\n[%%ifdef consensus_mechanism]\n\nopen Snark_params.Tick\nopen Signature_lib\n\n[%%endif]\n\nlet int_to_bits ~length x = List.init length ~f:(fun i -> (x lsr i) land 1 = 1)\n\nlet int_of_bits =\n List.foldi ~init:0 ~f:(fun i acc b -> if b then acc lor (1 lsl i) else acc)\n\nmodule Transition = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type 'a t = { prev : 'a; next : 'a }\n [@@deriving hlist, sexp, equal, yojson, hash, compare]\n end\n end]\n\n let to_input { prev; next } ~f =\n Random_oracle_input.Chunked.append (f prev) (f next)\n\n [%%ifdef consensus_mechanism]\n\n let typ t =\n Typ.of_hlistable [ t; t ] ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist\n ~value_to_hlist:to_hlist ~value_of_hlist:of_hlist\n\n [%%endif]\nend\n\nmodule Flagged_data = struct\n type ('flag, 'a) t = { flag : 'flag; data : 'a } [@@deriving hlist, fields]\n\n [%%ifdef consensus_mechanism]\n\n let typ flag t =\n Typ.of_hlistable [ flag; t ] ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist\n ~value_to_hlist:to_hlist ~value_of_hlist:of_hlist\n\n [%%endif]\n\n let to_input' { flag; data } ~flag:f ~data:d =\n Random_oracle_input.Chunked.(append (f flag) (d data))\nend\n\nmodule Flagged_option = struct\n type ('bool, 'a) t = { is_some : 'bool; data : 'a } [@@deriving hlist, fields]\n\n let to_input' ~field_of_bool { is_some; data } ~f =\n Random_oracle_input.Chunked.(\n append (packed (field_of_bool is_some, 1)) (f data))\n\n let to_input { is_some; data } ~default ~f =\n let data = if is_some then data else default in\n to_input' { is_some; data } ~f\n\n let of_option t ~default =\n match t with\n | None ->\n { is_some = false; data = default }\n | Some data ->\n { is_some = true; data }\n\n let to_option { is_some; data } = Option.some_if is_some data\n\n let map ~f { is_some; data } = { is_some; data = f data }\n\n [%%ifdef consensus_mechanism]\n\n let if_ ~(if_ : 'b -> then_:'var -> else_:'var -> 'var) b ~then_ ~else_ =\n { is_some =\n Run.run_checked\n (Boolean.if_ b ~then_:then_.is_some ~else_:else_.is_some)\n ; data = if_ b ~then_:then_.data ~else_:else_.data\n }\n\n let typ t =\n Typ.of_hlistable [ Boolean.typ; t ] ~var_to_hlist:to_hlist\n ~var_of_hlist:of_hlist ~value_to_hlist:to_hlist ~value_of_hlist:of_hlist\n\n let option_typ ~default t =\n Typ.transport (typ t) ~there:(of_option ~default) ~back:to_option\n\n [%%endif]\nend\n\nmodule Set_or_keep = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type 'a t = 'a Mina_wire_types.Mina_base.Zkapp_basic.Set_or_keep.V1.t =\n | Set of 'a\n | Keep\n [@@deriving sexp, equal, compare, hash, yojson]\n end\n end]\n\n let map t ~f = match t with Keep -> Keep | Set x -> Set (f x)\n\n let to_option = function Set x -> Some x | Keep -> None\n\n let of_option = function Some x -> Set x | None -> Keep\n\n let set_or_keep t x = match t with Keep -> x | Set y -> y\n\n let is_set = function Set _ -> true | _ -> false\n\n let is_keep = function Keep -> true | _ -> false\n\n let deriver inner obj =\n let open Fields_derivers_zkapps.Derivers in\n iso ~map:of_option ~contramap:to_option\n ((option ~js_type:Flagged_option @@ inner @@ o ()) (o ()))\n obj\n\n let gen gen_a =\n let open Quickcheck.Let_syntax in\n (* with equal probability, return a Set or a Keep *)\n let%bind b = Quickcheck.Generator.bool in\n if b then\n let%bind a = gen_a in\n return (Set a)\n else return Keep\n\n [%%ifdef consensus_mechanism]\n\n module Checked : sig\n type 'a t\n\n val is_keep : _ t -> Boolean.var\n\n val is_set : _ t -> Boolean.var\n\n val set_or_keep :\n if_:(Boolean.var -> then_:'a -> else_:'a -> 'a) -> 'a t -> 'a -> 'a\n\n val data : 'a t -> 'a\n\n val typ :\n dummy:'a -> ('a_var, 'a) Typ.t -> ('a_var t, 'a Stable.Latest.t) Typ.t\n\n val optional_typ :\n to_option:('new_value -> 'value option)\n -> of_option:('value option -> 'new_value)\n -> ('var, 'new_value) Typ.t\n -> ('var t, 'value Stable.Latest.t) Typ.t\n\n val map : f:('a -> 'b) -> 'a t -> 'b t\n\n val to_input :\n 'a t\n -> f:('a -> Field.Var.t Random_oracle_input.Chunked.t)\n -> Field.Var.t Random_oracle_input.Chunked.t\n\n val set : 'a -> 'a t\n\n val keep : dummy:'a -> 'a t\n\n val make_unsafe : Boolean.var -> 'a -> 'a t\n end = struct\n type 'a t = (Boolean.var, 'a) Flagged_option.t\n\n let set_or_keep ~if_ ({ is_some; data } : _ t) x =\n if_ is_some ~then_:data ~else_:x\n\n let data = Flagged_option.data\n\n let is_set = Flagged_option.is_some\n\n let is_keep x = Boolean.not (Flagged_option.is_some x)\n\n let map = Flagged_option.map\n\n let typ ~dummy t =\n Typ.transport\n (Flagged_option.option_typ ~default:dummy t)\n ~there:to_option ~back:of_option\n\n let optional_typ (type new_value value var) :\n to_option:(new_value -> value option)\n -> of_option:(value option -> new_value)\n -> (var, new_value) Typ.t\n -> (var t, value Stable.Latest.t) Typ.t =\n fun ~to_option ~of_option t ->\n Typ.transport (Flagged_option.typ t)\n ~there:(function\n | Set x ->\n { Flagged_option.is_some = true; data = of_option (Some x) }\n | Keep ->\n { Flagged_option.is_some = false; data = of_option None } )\n ~back:(function\n | { Flagged_option.is_some = true; data = x } ->\n Set (Option.value_exn (to_option x))\n | { Flagged_option.is_some = false; data = _ } ->\n Keep )\n\n let to_input (t : _ t) ~f =\n Flagged_option.to_input' t ~f ~field_of_bool:(fun (b : Boolean.var) ->\n (b :> Field.Var.t) )\n\n let make_unsafe is_keep data = { Flagged_option.is_some = is_keep; data }\n\n let set data = { Flagged_option.is_some = Boolean.true_; data }\n\n let keep ~dummy = { Flagged_option.is_some = Boolean.false_; data = dummy }\n end\n\n let typ = Checked.typ\n\n let optional_typ = Checked.optional_typ\n\n [%%endif]\n\n let to_input t ~dummy:default ~f =\n Flagged_option.to_input ~default ~f ~field_of_bool\n (Flagged_option.of_option ~default (to_option t))\nend\n\nmodule Or_ignore = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type 'a t = 'a Mina_wire_types.Mina_base.Zkapp_basic.Or_ignore.V1.t =\n | Check of 'a\n | Ignore\n [@@deriving sexp, equal, compare, hash, yojson]\n end\n end]\n\n let gen gen_a =\n let open Quickcheck.Let_syntax in\n (* choose constructor *)\n let%bind b = Quickcheck.Generator.bool in\n if b then\n let%map a = gen_a in\n Check a\n else return Ignore\n\n let to_option = function Ignore -> None | Check x -> Some x\n\n let of_option = function None -> Ignore | Some x -> Check x\n\n let deriver_base ~js_type inner obj =\n let open Fields_derivers_zkapps.Derivers in\n iso ~map:of_option ~contramap:to_option\n ((option ~js_type @@ inner @@ o ()) (o ()))\n obj\n\n let deriver inner obj = deriver_base ~js_type:Flagged_option inner obj\n\n let deriver_interval inner obj ~range_max =\n deriver_base ~js_type:(Closed_interval range_max) inner obj\n\n [%%ifdef consensus_mechanism]\n\n module Checked : sig\n type 'a t\n\n val typ :\n ignore:'a -> ('a_var, 'a) Typ.t -> ('a_var t, 'a Stable.Latest.t) Typ.t\n\n val to_input :\n 'a t\n -> f:('a -> Field.Var.t Random_oracle_input.Chunked.t)\n -> Field.Var.t Random_oracle_input.Chunked.t\n\n val check : 'a t -> f:('a -> Boolean.var) -> Boolean.var\n\n val map : f:('a -> 'b) -> 'a t -> 'b t\n\n val data : 'a t -> 'a\n\n val is_check : 'a t -> Boolean.var\n\n val make_unsafe : Boolean.var -> 'a -> 'a t\n end = struct\n type 'a t = (Boolean.var, 'a) Flagged_option.t\n\n let to_input t ~f =\n Flagged_option.to_input' t ~f ~field_of_bool:(fun (b : Boolean.var) ->\n (b :> Field.Var.t) )\n\n let check { Flagged_option.is_some; data } ~f =\n Pickles.Impls.Step.Boolean.(any [ not is_some; f data ])\n\n let map = Flagged_option.map\n\n let data = Flagged_option.data\n\n let is_check = Flagged_option.is_some\n\n let typ (type a_var a) ~ignore (t : (a_var, a) Typ.t) =\n Typ.transport\n (Flagged_option.option_typ ~default:ignore t)\n ~there:to_option ~back:of_option\n\n let make_unsafe is_ignore data =\n { Flagged_option.is_some = is_ignore; data }\n end\n\n let typ = Checked.typ\n\n [%%endif]\nend\n\nmodule Account_state = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Empty | Non_empty | Any\n [@@deriving sexp, equal, yojson, hash, compare, enum]\n\n let to_latest = Fn.id\n end\n end]\n\n module Encoding = struct\n type 'b t = { any : 'b; empty : 'b } [@@deriving hlist]\n\n let to_input ~field_of_bool { any; empty } =\n Random_oracle_input.Chunked.packeds\n [| (field_of_bool any, 1); (field_of_bool empty, 1) |]\n end\n\n let encode : t -> bool Encoding.t = function\n | Empty ->\n { any = false; empty = true }\n | Non_empty ->\n { any = false; empty = false }\n | Any ->\n { any = true; empty = false }\n\n let decode : bool Encoding.t -> t = function\n | { any = false; empty = true } ->\n Empty\n | { any = false; empty = false } ->\n Non_empty\n | { any = true; empty = false } | { any = true; empty = true } ->\n Any\n\n let to_input (x : t) = Encoding.to_input ~field_of_bool (encode x)\n\n let check (t : t) (x : [ `Empty | `Non_empty ]) =\n match (t, x) with\n | Any, _ | Non_empty, `Non_empty | Empty, `Empty ->\n Ok ()\n | _ ->\n Or_error.error_string \"Bad account_type\"\n\n [%%ifdef consensus_mechanism]\n\n module Checked = struct\n open Pickles.Impls.Step\n\n type t = Boolean.var Encoding.t\n\n let to_input (t : t) =\n Encoding.to_input t ~field_of_bool:(fun (b : Boolean.var) ->\n (b :> Field.t) )\n\n let check (t : t) ~is_empty =\n Boolean.(\n any [ t.any; t.empty && is_empty; (not t.empty) && not is_empty ])\n end\n\n let typ : (Checked.t, t) Typ.t =\n let open Encoding in\n Typ.of_hlistable\n [ Boolean.typ; Boolean.typ ]\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist\n |> Typ.transport ~there:encode ~back:decode\n\n [%%endif]\nend\n\n[%%ifdef consensus_mechanism]\n\nmodule F = Pickles.Backend.Tick.Field\n\n[%%else]\n\nmodule F = Snark_params.Tick.Field\n\n[%%endif]\n\nmodule F_map = struct\n include Hashable.Make (F)\n include Comparable.Make (F)\nend\n\nlet invalid_public_key : Public_key.Compressed.t =\n { x = F.zero; is_odd = false }\n\nlet%test \"invalid_public_key is invalid\" =\n Option.is_none (Public_key.decompress invalid_public_key)\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Snark_params.Tick\nopen Zkapp_basic\n\nmodule Event = struct\n (* Arbitrary hash input, encoding determined by the zkApp's developer. *)\n type t = Field.t array [@@deriving compare, sexp]\n\n let hash (x : t) = Random_oracle.hash ~init:Hash_prefix_states.zkapp_event x\n\n [%%ifdef consensus_mechanism]\n\n type var = Field.Var.t array\n\n let hash_var (x : Field.Var.t array) =\n Random_oracle.Checked.hash ~init:Hash_prefix_states.zkapp_event x\n\n [%%endif]\n\n let gen : t Quickcheck.Generator.t =\n let open Quickcheck in\n Generator.map ~f:Array.of_list @@ Generator.list Field.gen\nend\n\nmodule Make_events (Inputs : sig\n val salt_phrase : string\n\n val hash_prefix : field Random_oracle.State.t\n\n val deriver_name : string\nend) =\nstruct\n type t = Event.t list [@@deriving compare, sexp]\n\n let empty_hash = Random_oracle.(salt Inputs.salt_phrase |> digest)\n\n let push_hash acc hash =\n Random_oracle.hash ~init:Inputs.hash_prefix [| acc; hash |]\n\n let push_event acc event = push_hash acc (Event.hash event)\n\n let hash (x : t) =\n (* fold_right so the empty hash is used at the end of the events *)\n List.fold_right ~init:empty_hash ~f:(Fn.flip push_event) x\n\n [%%ifdef consensus_mechanism]\n\n type var = t Data_as_hash.t\n\n let typ = Data_as_hash.typ ~hash\n\n let var_to_input (x : var) = Data_as_hash.to_input x\n\n let to_input (x : t) = Random_oracle_input.Chunked.field (hash x)\n\n let push_to_data_as_hash (events : var) (e : Event.var) : var =\n let open Run in\n let res =\n exists typ ~compute:(fun () ->\n let tl = As_prover.read typ events in\n let hd =\n As_prover.read (Typ.array ~length:(Array.length e) Field.typ) e\n in\n hd :: tl )\n in\n Field.Assert.equal\n (Random_oracle.Checked.hash ~init:Inputs.hash_prefix\n [| Data_as_hash.hash events; Event.hash_var e |] )\n (Data_as_hash.hash res) ;\n res\n\n let empty_stack_msg = \"Attempted to pop an empty stack\"\n\n let pop_from_data_as_hash (events : var) : Event.t Data_as_hash.t * var =\n let open Run in\n let hd, tl =\n exists\n Typ.(Data_as_hash.typ ~hash:Event.hash * typ)\n ~compute:(fun () ->\n match As_prover.read typ events with\n | [] ->\n failwith empty_stack_msg\n | event :: events ->\n (event, events) )\n in\n Field.Assert.equal\n (Random_oracle.Checked.hash ~init:Inputs.hash_prefix\n [| Data_as_hash.hash tl; Data_as_hash.hash hd |] )\n (Data_as_hash.hash events) ;\n (hd, tl)\n\n [%%endif]\n\n let deriver obj =\n let open Fields_derivers_zkapps in\n let events = list @@ array field (o ()) in\n needs_custom_js\n ~js_type:(Data_as_hash.deriver events)\n ~name:Inputs.deriver_name events obj\nend\n\nmodule Events = struct\n include Make_events (struct\n let salt_phrase = \"MinaZkappEventsEmpty\"\n\n let hash_prefix = Hash_prefix_states.zkapp_events\n\n let deriver_name = \"Events\"\n end)\nend\n\nmodule Actions = struct\n include Make_events (struct\n let salt_phrase = \"MinaZkappActionsEmpty\"\n\n let hash_prefix = Hash_prefix_states.zkapp_actions\n\n let deriver_name = \"Actions\"\n end)\n\n let is_empty_var (e : var) =\n Snark_params.Tick.Field.(\n Checked.equal (Data_as_hash.hash e) (Var.constant empty_hash))\n\n let empty_state_element =\n let salt_phrase = \"MinaZkappActionStateEmptyElt\" in\n Random_oracle.(salt salt_phrase |> digest)\n\n let push_events (acc : Field.t) (events : t) : Field.t =\n push_hash acc (hash events)\n\n [%%ifdef consensus_mechanism]\n\n let push_events_checked (x : Field.Var.t) (e : var) : Field.Var.t =\n Random_oracle.Checked.hash ~init:Hash_prefix_states.zkapp_actions\n [| x; Data_as_hash.hash e |]\n\n [%%endif]\nend\n\nmodule Zkapp_uri = struct\n [%%versioned_binable\n module Stable = struct\n module V1 = struct\n module T = struct\n type t = string [@@deriving sexp, equal, compare, hash, yojson]\n\n let to_latest = Fn.id\n\n let max_length = 255\n\n let check (x : t) = assert (String.length x <= max_length)\n\n let t_of_sexp sexp =\n let res = t_of_sexp sexp in\n check res ; res\n\n let of_yojson json =\n let res = of_yojson json in\n Result.bind res ~f:(fun res ->\n Result.try_with (fun () -> check res)\n |> Result.map ~f:(Fn.const res)\n |> Result.map_error\n ~f:(Fn.const \"Zkapp_uri.of_yojson: symbol is too long\") )\n end\n\n include T\n\n include\n Binable.Of_binable_without_uuid\n (Core_kernel.String.Stable.V1)\n (struct\n type t = string\n\n let to_binable = Fn.id\n\n let of_binable x = check x ; x\n end)\n end\n end]\n\n [%%define_locally\n Stable.Latest.\n (sexp_of_t, t_of_sexp, equal, to_yojson, of_yojson, max_length, check)]\nend\n\nmodule Poly = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type ('app_state, 'vk, 'zkapp_version, 'field, 'slot, 'bool, 'zkapp_uri) t =\n { app_state : 'app_state\n ; verification_key : 'vk\n ; zkapp_version : 'zkapp_version\n ; action_state : 'field Pickles_types.Vector.Vector_5.Stable.V1.t\n ; last_action_slot : 'slot\n ; proved_state : 'bool\n ; zkapp_uri : 'zkapp_uri\n }\n [@@deriving sexp, equal, compare, hash, yojson, hlist, fields, annot]\n end\n end]\nend\n\ntype ('app_state, 'vk, 'zkapp_version, 'field, 'slot, 'bool, 'zkapp_uri) t_ =\n ('app_state, 'vk, 'zkapp_version, 'field, 'slot, 'bool, 'zkapp_uri) Poly.t =\n { app_state : 'app_state\n ; verification_key : 'vk\n ; zkapp_version : 'zkapp_version\n ; action_state : 'field Pickles_types.Vector.Vector_5.t\n ; last_action_slot : 'slot\n ; proved_state : 'bool\n ; zkapp_uri : 'zkapp_uri\n }\n\n[%%versioned\nmodule Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V2 = struct\n type t =\n ( Zkapp_state.Value.Stable.V1.t\n , Verification_key_wire.Stable.V1.t option\n , Mina_numbers.Zkapp_version.Stable.V1.t\n , F.Stable.V1.t\n , Mina_numbers.Global_slot_since_genesis.Stable.V1.t\n , bool\n , Zkapp_uri.Stable.V1.t )\n Poly.Stable.V2.t\n [@@deriving sexp, equal, compare, hash, yojson]\n\n let to_latest = Fn.id\n end\nend]\n\ntype t =\n ( Zkapp_state.Value.t\n , Verification_key_wire.t option\n , Mina_numbers.Zkapp_version.t\n , F.t\n , Mina_numbers.Global_slot_since_genesis.t\n , bool\n , Zkapp_uri.t )\n Poly.t\n[@@deriving sexp, equal, compare, hash, yojson]\n\nlet (_ : (t, Stable.Latest.t) Type_equal.t) = Type_equal.T\n\n[%%ifdef consensus_mechanism]\n\nmodule Checked = struct\n type t =\n ( Pickles.Impls.Step.Field.t Zkapp_state.V.t\n , ( Boolean.var\n , (Side_loaded_verification_key.t option, Field.t) With_hash.t\n Data_as_hash.t )\n Flagged_option.t\n , Mina_numbers.Zkapp_version.Checked.t\n , Pickles.Impls.Step.Field.t\n , Mina_numbers.Global_slot_since_genesis.Checked.t\n , Boolean.var\n , string Data_as_hash.t )\n Poly.t\n\n open Pickles_types\n\n let to_input' (t : _ Poly.t) :\n Snark_params.Tick.Field.Var.t Random_oracle.Input.Chunked.t =\n let open Random_oracle.Input.Chunked in\n let f mk acc field = mk (Core_kernel.Field.get field t) :: acc in\n let app_state v =\n Random_oracle.Input.Chunked.field_elements (Vector.to_array v)\n in\n Poly.Fields.fold ~init:[] ~app_state:(f app_state)\n ~verification_key:(f field)\n ~zkapp_version:(f Mina_numbers.Zkapp_version.Checked.to_input)\n ~action_state:(f app_state)\n ~last_action_slot:\n (f Mina_numbers.Global_slot_since_genesis.Checked.to_input)\n ~proved_state:\n (f (fun (b : Boolean.var) ->\n Random_oracle.Input.Chunked.packed ((b :> Field.Var.t), 1) ) )\n ~zkapp_uri:(f field)\n |> List.reduce_exn ~f:append\n\n let to_input (t : t) =\n to_input'\n { t with\n verification_key = Data_as_hash.hash t.verification_key.data\n ; zkapp_uri = Data_as_hash.hash t.zkapp_uri\n }\n\n let digest_vk t =\n Random_oracle.Checked.(\n hash ~init:Hash_prefix_states.side_loaded_vk\n (pack_input (Pickles.Side_loaded.Verification_key.Checked.to_input t)))\n\n let digest t =\n Random_oracle.Checked.(\n hash ~init:Hash_prefix_states.zkapp_account (pack_input (to_input t)))\n\n let digest' t =\n Random_oracle.Checked.(\n hash ~init:Hash_prefix_states.zkapp_account (pack_input (to_input' t)))\nend\n\n[%%define_locally Verification_key_wire.(digest_vk, dummy_vk_hash)]\n\n(* This preimage cannot be attained by any string, due to the trailing [true]\n added below.\n*)\nlet zkapp_uri_non_preimage =\n lazy (Random_oracle_input.Chunked.field_elements [| Field.zero; Field.zero |])\n\nlet hash_zkapp_uri_opt (zkapp_uri_opt : string option) =\n let input =\n match zkapp_uri_opt with\n | Some zkapp_uri ->\n (* We use [length*8 + 1] to pass a final [true] after the end of the\n string, to ensure that trailing null bytes don't alias in the hash\n preimage.\n *)\n let bits = Array.create ~len:((String.length zkapp_uri * 8) + 1) true in\n String.foldi zkapp_uri ~init:() ~f:(fun i () c ->\n let c = Char.to_int c in\n (* Insert the bits into [bits], LSB order. *)\n for j = 0 to 7 do\n (* [Int.test_bit c j] *)\n bits.((i * 8) + j) <- Int.bit_and c (1 lsl j) <> 0\n done ) ;\n Random_oracle_input.Chunked.packeds\n (Array.map ~f:(fun b -> (field_of_bool b, 1)) bits)\n | None ->\n Lazy.force zkapp_uri_non_preimage\n in\n Random_oracle.pack_input input\n |> Random_oracle.hash ~init:Hash_prefix_states.zkapp_uri\n\nlet hash_zkapp_uri (zkapp_uri : string) = hash_zkapp_uri_opt (Some zkapp_uri)\n\nlet typ : (Checked.t, t) Typ.t =\n let open Poly in\n Typ.of_hlistable\n [ Zkapp_state.typ Field.typ\n ; Flagged_option.option_typ\n ~default:{ With_hash.data = None; hash = dummy_vk_hash () }\n (Data_as_hash.typ ~hash:With_hash.hash)\n |> Typ.transport\n ~there:(Option.map ~f:(With_hash.map ~f:Option.some))\n ~back:\n (Option.map ~f:(With_hash.map ~f:(fun x -> Option.value_exn x)))\n ; Mina_numbers.Zkapp_version.typ\n ; Pickles_types.Vector.typ Field.typ Pickles_types.Nat.N5.n\n ; Mina_numbers.Global_slot_since_genesis.typ\n ; Boolean.typ\n ; Data_as_hash.typ ~hash:hash_zkapp_uri\n ]\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist\n\n[%%endif]\n\nlet zkapp_uri_to_input zkapp_uri =\n Random_oracle.Input.Chunked.field @@ hash_zkapp_uri zkapp_uri\n\nlet to_input (t : t) : _ Random_oracle.Input.Chunked.t =\n let open Random_oracle.Input.Chunked in\n let f mk acc field = mk (Core_kernel.Field.get field t) :: acc in\n let app_state v =\n Random_oracle.Input.Chunked.field_elements (Pickles_types.Vector.to_array v)\n in\n Poly.Fields.fold ~init:[] ~app_state:(f app_state)\n ~verification_key:\n (f\n (Fn.compose field\n (Option.value_map ~default:(dummy_vk_hash ()) ~f:With_hash.hash) ) )\n ~zkapp_version:(f Mina_numbers.Zkapp_version.to_input)\n ~action_state:(f app_state)\n ~last_action_slot:(f Mina_numbers.Global_slot_since_genesis.to_input)\n ~proved_state:\n (f (fun b -> Random_oracle.Input.Chunked.packed (field_of_bool b, 1)))\n ~zkapp_uri:(f zkapp_uri_to_input)\n |> List.reduce_exn ~f:append\n\nlet default : _ Poly.t =\n (* These are the permissions of a \"user\"/\"non zkapp\" account. *)\n { app_state =\n Pickles_types.Vector.init Zkapp_state.Max_state_size.n ~f:(fun _ ->\n F.zero )\n ; verification_key = None\n ; zkapp_version = Mina_numbers.Zkapp_version.zero\n ; action_state =\n (let empty = Actions.empty_state_element in\n [ empty; empty; empty; empty; empty ] )\n ; last_action_slot = Mina_numbers.Global_slot_since_genesis.zero\n ; proved_state = false\n ; zkapp_uri = \"\"\n }\n\nlet digest (t : t) =\n Random_oracle.(\n hash ~init:Hash_prefix_states.zkapp_account (pack_input (to_input t)))\n\nlet default_digest = lazy (digest default)\n\nlet hash_zkapp_account_opt' = function\n | None ->\n Lazy.force default_digest\n | Some (a : t) ->\n digest a\n\nlet action_state_deriver obj =\n let open Fields_derivers_zkapps.Derivers in\n let list_5 = list ~static_length:5 (field @@ o ()) in\n let open Pickles_types.Vector.Vector_5 in\n iso ~map:of_list_exn ~contramap:to_list (list_5 (o ())) obj\n\nlet deriver obj =\n let open Fields_derivers_zkapps in\n let ( !. ) = ( !. ) ~t_fields_annots:Poly.t_fields_annots in\n finish \"ZkappAccount\" ~t_toplevel_annots:Poly.t_toplevel_annots\n @@ Poly.Fields.make_creator\n ~app_state:!.(Zkapp_state.deriver field)\n ~verification_key:\n !.(option ~js_type:Or_undefined (verification_key_with_hash @@ o ()))\n ~zkapp_version:!.uint32 ~action_state:!.action_state_deriver\n ~last_action_slot:!.global_slot_since_genesis\n ~proved_state:!.bool ~zkapp_uri:!.string obj\n\nlet gen_uri =\n let open Quickcheck in\n let open Generator.Let_syntax in\n let%bind parts =\n String.gen_with_length 8 Char.gen_alphanum |> Generator.list_with_length 3\n in\n let%map domain = Generator.of_list [ \"com\"; \"org\"; \"net\"; \"info\" ] in\n Printf.sprintf \"https://%s.%s\" (String.concat ~sep:\".\" parts) domain\n\nlet gen : t Quickcheck.Generator.t =\n let open Quickcheck in\n let open Generator.Let_syntax in\n let app_state =\n Pickles_types.Vector.init Zkapp_state.Max_state_size.n ~f:(fun _ ->\n F.random () )\n in\n let%bind zkapp_version = Mina_numbers.Zkapp_version.gen in\n let%bind seq_state = Generator.list_with_length 5 Field.gen in\n let%bind last_sequence_slot = Mina_numbers.Global_slot_since_genesis.gen in\n let%map zkapp_uri = gen_uri in\n let five = Pickles_types.Nat.(S (S (S (S (S Z))))) in\n { app_state\n ; verification_key = None\n ; zkapp_version\n ; action_state = Pickles_types.(Vector.of_list_and_length_exn seq_state five)\n ; last_action_slot = Mina_numbers.Global_slot_since_genesis.zero\n ; proved_state = false\n ; zkapp_uri\n }\n","(* account.ml *)\n\n[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Mina_base_util\nopen Snark_params\nopen Tick\nopen Currency\nopen Mina_numbers\nopen Fold_lib\nopen Mina_base_import\n\nmodule Index = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n module T = struct\n type t = int [@@deriving to_yojson, sexp, hash, compare]\n end\n\n include T\n\n let to_latest = Fn.id\n\n include Hashable.Make_binable (T)\n end\n end]\n\n include Hashable.Make_binable (Stable.Latest)\n\n let to_int = Int.to_int\n\n let gen ~ledger_depth = Int.gen_incl 0 ((1 lsl ledger_depth) - 1)\n\n module Vector = struct\n include Int\n\n let empty = zero\n\n let get t i = (t lsr i) land 1 = 1\n\n let set v i b = if b then v lor (one lsl i) else v land lnot (one lsl i)\n end\n\n let to_bits ~ledger_depth t = List.init ledger_depth ~f:(Vector.get t)\n\n let of_bits = List.foldi ~init:Vector.empty ~f:(fun i t b -> Vector.set t i b)\n\n let to_input ~ledger_depth x =\n List.map (to_bits ~ledger_depth x) ~f:(fun b -> (field_of_bool b, 1))\n |> List.to_array |> Random_oracle.Input.Chunked.packeds\n\n let fold_bits ~ledger_depth t =\n { Fold.fold =\n (fun ~init ~f ->\n let rec go acc i =\n if i = ledger_depth then acc else go (f acc (Vector.get t i)) (i + 1)\n in\n go init 0 )\n }\n\n let fold ~ledger_depth t =\n Fold.group3 ~default:false (fold_bits ~ledger_depth t)\n\n [%%ifdef consensus_mechanism]\n\n module Unpacked = struct\n type var = Tick.Boolean.var list\n\n type value = Vector.t\n\n let to_input x =\n List.map x ~f:(fun (b : Boolean.var) -> ((b :> Field.Var.t), 1))\n |> List.to_array |> Random_oracle.Input.Chunked.packeds\n\n let typ ~ledger_depth : (var, value) Tick.Typ.t =\n Typ.transport\n (Typ.list ~length:ledger_depth Boolean.typ)\n ~there:(to_bits ~ledger_depth) ~back:of_bits\n end\n\n [%%endif]\nend\n\nmodule Nonce = Account_nonce\n\nmodule Token_symbol = struct\n [%%versioned_binable\n module Stable = struct\n module V1 = struct\n module T = struct\n type t = string [@@deriving sexp, equal, compare, hash, yojson]\n\n let to_latest = Fn.id\n\n let max_length = 6\n\n let check (x : t) = assert (String.length x <= max_length)\n\n let t_of_sexp sexp =\n let res = t_of_sexp sexp in\n check res ; res\n\n let of_yojson json =\n let res = of_yojson json in\n Result.bind res ~f:(fun res ->\n Result.try_with (fun () -> check res)\n |> Result.map ~f:(Fn.const res)\n |> Result.map_error\n ~f:(Fn.const \"Token_symbol.of_yojson: symbol is too long\") )\n end\n\n include T\n\n include\n Binable.Of_binable_without_uuid\n (Core_kernel.String.Stable.V1)\n (struct\n type t = string\n\n let to_binable = Fn.id\n\n let of_binable x = check x ; x\n end)\n end\n end]\n\n [%%define_locally\n Stable.Latest.\n (sexp_of_t, t_of_sexp, equal, to_yojson, of_yojson, max_length, check)]\n\n let default = \"\"\n\n (* 48 = max_length * 8 *)\n module Num_bits = Pickles_types.Nat.N48\n\n let num_bits = Pickles_types.Nat.to_int Num_bits.n\n\n let to_bits (x : t) =\n Pickles_types.Vector.init Num_bits.n ~f:(fun i ->\n let byte_index = i / 8 in\n if byte_index < String.length x then\n let c = x.[byte_index] |> Char.to_int in\n c land (1 lsl (i mod 8)) <> 0\n else false )\n\n let of_bits x : t =\n let c, j, chars =\n Pickles_types.Vector.fold x ~init:(0, 0, []) ~f:(fun (c, j, chars) x ->\n let c = c lor ((if x then 1 else 0) lsl j) in\n if j = 7 then (0, 0, Char.of_int_exn c :: chars) else (c, j + 1, chars) )\n in\n assert (c = 0) ;\n assert (j = 0) ;\n let chars = List.drop_while ~f:(fun c -> Char.to_int c = 0) chars in\n String.of_char_list (List.rev chars)\n\n let to_field (x : t) : Field.t =\n Field.project (Pickles_types.Vector.to_list (to_bits x))\n\n let to_input (x : t) =\n Random_oracle_input.Chunked.packed (to_field x, num_bits)\n\n [%%ifdef consensus_mechanism]\n\n type var = Field.Var.t\n\n let range_check (t : var) =\n let%bind actual =\n make_checked (fun () ->\n let _, _, actual_packed =\n Pickles.Scalar_challenge.to_field_checked' ~num_bits m\n (Kimchi_backend_common.Scalar_challenge.create t)\n in\n actual_packed )\n in\n Field.Checked.Assert.equal t actual\n\n let var_of_value x =\n Pickles_types.Vector.map ~f:Boolean.var_of_value (to_bits x)\n\n let of_field (x : Field.t) : t =\n of_bits\n (Pickles_types.Vector.of_list_and_length_exn\n (List.take (Field.unpack x) num_bits)\n Num_bits.n )\n\n let typ : (var, t) Typ.t =\n let (Typ typ) = Field.typ in\n Typ.transport\n (Typ { typ with check = range_check })\n ~there:to_field ~back:of_field\n\n let var_to_input (x : var) = Random_oracle_input.Chunked.packed (x, num_bits)\n\n let if_ = Tick.Run.Field.if_\n\n [%%endif]\nend\n\n(* the `token_symbol` describes a token id owned by the account id\n from this account, not the token id used by this account\n*)\nmodule Poly = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type ( 'pk\n , 'id\n , 'token_symbol\n , 'amount\n , 'nonce\n , 'receipt_chain_hash\n , 'delegate\n , 'state_hash\n , 'timing\n , 'permissions\n , 'zkapp_opt )\n t =\n { public_key : 'pk\n ; token_id : 'id\n ; token_symbol : 'token_symbol\n ; balance : 'amount\n ; nonce : 'nonce\n ; receipt_chain_hash : 'receipt_chain_hash\n ; delegate : 'delegate\n ; voting_for : 'state_hash\n ; timing : 'timing\n ; permissions : 'permissions\n ; zkapp : 'zkapp_opt\n }\n [@@deriving sexp, equal, compare, hash, yojson, fields, hlist, annot]\n\n let to_latest = Fn.id\n end\n end]\nend\n\nlet token = Poly.token_id\n\nmodule Key = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Public_key.Compressed.Stable.V1.t\n [@@deriving sexp, equal, hash, compare, yojson]\n\n let to_latest = Fn.id\n end\n end]\nend\n\nmodule Identifier = Account_id\n\ntype key = Key.t [@@deriving sexp, equal, hash, compare, yojson]\n\nmodule Timing = Account_timing\n\nmodule Binable_arg = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t =\n ( Public_key.Compressed.Stable.V1.t\n , Token_id.Stable.V2.t\n , Token_symbol.Stable.V1.t\n , Balance.Stable.V1.t\n , Nonce.Stable.V1.t\n , Receipt.Chain_hash.Stable.V1.t\n , Public_key.Compressed.Stable.V1.t option\n , State_hash.Stable.V1.t\n , Timing.Stable.V2.t\n , Permissions.Stable.V2.t\n , Zkapp_account.Stable.V2.t option )\n (* TODO: Cache the digest of this? *)\n Poly.Stable.V2.t\n [@@deriving sexp, equal, hash, compare, yojson]\n\n let to_latest = Fn.id\n\n let public_key (t : t) : key = t.public_key\n end\n end]\nend\n\nlet check = Fn.id\n\n[%%versioned_binable\nmodule Stable = struct\n module V2 = struct\n type t = Binable_arg.Stable.V2.t\n [@@deriving sexp, equal, hash, compare, yojson]\n\n include\n Binable.Of_binable_without_uuid\n (Binable_arg.Stable.V2)\n (struct\n type nonrec t = t\n\n let to_binable = check\n\n let of_binable = check\n end)\n\n let to_latest = Fn.id\n\n let public_key (t : t) : key = t.public_key\n end\nend]\n\n[%%define_locally Stable.Latest.(public_key)]\n\nlet identifier ({ public_key; token_id; _ } : t) =\n Account_id.create public_key token_id\n\ntype value =\n ( Public_key.Compressed.t\n , Token_id.t\n , Token_symbol.t\n , Balance.t\n , Nonce.t\n , Receipt.Chain_hash.t\n , Public_key.Compressed.t option\n , State_hash.t\n , Timing.t\n , Permissions.t\n , Zkapp_account.t option )\n Poly.t\n[@@deriving sexp]\n\nlet key_gen = Public_key.Compressed.gen\n\nlet initialize account_id : t =\n let public_key = Account_id.public_key account_id in\n let token_id = Account_id.token_id account_id in\n let delegate =\n (* Only allow delegation if this account is for the default token. *)\n if Token_id.(equal default token_id) then Some public_key else None\n in\n { public_key\n ; token_id\n ; token_symbol = \"\"\n ; balance = Balance.zero\n ; nonce = Nonce.zero\n ; receipt_chain_hash = Receipt.Chain_hash.empty\n ; delegate\n ; voting_for = State_hash.dummy\n ; timing = Timing.Untimed\n ; permissions = Permissions.user_default\n ; zkapp = None\n }\n\nlet hash_zkapp_account_opt = function\n | None ->\n Lazy.force Zkapp_account.default_digest\n | Some (a : Zkapp_account.t) ->\n Zkapp_account.digest a\n\nlet delegate_opt = Option.value ~default:Public_key.Compressed.empty\n\nlet to_input (t : t) =\n let open Random_oracle.Input.Chunked in\n let f mk acc field = mk (Core_kernel.Field.get field t) :: acc in\n Poly.Fields.fold ~init:[]\n ~public_key:(f Public_key.Compressed.to_input)\n ~token_id:(f Token_id.to_input) ~balance:(f Balance.to_input)\n ~token_symbol:(f Token_symbol.to_input) ~nonce:(f Nonce.to_input)\n ~receipt_chain_hash:(f Receipt.Chain_hash.to_input)\n ~delegate:(f (Fn.compose Public_key.Compressed.to_input delegate_opt))\n ~voting_for:(f State_hash.to_input) ~timing:(f Timing.to_input)\n ~zkapp:(f (Fn.compose field hash_zkapp_account_opt))\n ~permissions:(f Permissions.to_input)\n |> List.reduce_exn ~f:append\n\nlet crypto_hash_prefix = Hash_prefix.account\n\nlet crypto_hash t =\n Random_oracle.hash ~init:crypto_hash_prefix\n (Random_oracle.pack_input (to_input t))\n\n[%%ifdef consensus_mechanism]\n\ntype var =\n ( Public_key.Compressed.var\n , Token_id.Checked.t\n , Token_symbol.var\n , Balance.var\n , Nonce.Checked.t\n , Receipt.Chain_hash.var\n , Public_key.Compressed.var\n , State_hash.var\n , Timing.var\n , Permissions.Checked.t\n (* TODO: This is a hack that lets us avoid unhashing zkApp accounts when we don't need to *)\n , Field.Var.t * Zkapp_account.t option As_prover.Ref.t )\n Poly.t\n\nlet identifier_of_var ({ public_key; token_id; _ } : var) =\n Account_id.Checked.create public_key token_id\n\nlet typ' zkapp =\n Typ.of_hlistable\n [ Public_key.Compressed.typ\n ; Token_id.typ\n ; Token_symbol.typ\n ; Balance.typ\n ; Nonce.typ\n ; Receipt.Chain_hash.typ\n ; Typ.transport Public_key.Compressed.typ ~there:delegate_opt\n ~back:(fun delegate ->\n if Public_key.Compressed.(equal empty) delegate then None\n else Some delegate )\n ; State_hash.typ\n ; Timing.typ\n ; Permissions.typ\n ; zkapp\n ]\n ~var_to_hlist:Poly.to_hlist ~var_of_hlist:Poly.of_hlist\n ~value_to_hlist:Poly.to_hlist ~value_of_hlist:Poly.of_hlist\n\nlet typ : (var, value) Typ.t =\n let zkapp :\n ( Field.Var.t * Zkapp_account.t option As_prover.Ref.t\n , Zkapp_account.t option )\n Typ.t =\n let account :\n (Zkapp_account.t option As_prover.Ref.t, Zkapp_account.t option) Typ.t =\n Typ.Internal.ref ()\n in\n Typ.(Field.typ * account)\n |> Typ.transport ~there:(fun x -> (hash_zkapp_account_opt x, x)) ~back:snd\n in\n typ' zkapp\n\nlet var_of_t\n ({ public_key\n ; token_id\n ; token_symbol\n ; balance\n ; nonce\n ; receipt_chain_hash\n ; delegate\n ; voting_for\n ; timing\n ; permissions\n ; zkapp\n } :\n value ) =\n { Poly.public_key = Public_key.Compressed.var_of_t public_key\n ; token_id = Token_id.Checked.constant token_id\n ; token_symbol = Token_symbol.var_of_value token_symbol\n ; balance = Balance.var_of_t balance\n ; nonce = Nonce.Checked.constant nonce\n ; receipt_chain_hash = Receipt.Chain_hash.var_of_t receipt_chain_hash\n ; delegate = Public_key.Compressed.var_of_t (delegate_opt delegate)\n ; voting_for = State_hash.var_of_t voting_for\n ; timing = Timing.var_of_t timing\n ; permissions = Permissions.Checked.constant permissions\n ; zkapp = Field.Var.constant (hash_zkapp_account_opt zkapp)\n }\n\nmodule Checked = struct\n module Unhashed = struct\n type t =\n ( Public_key.Compressed.var\n , Token_id.Checked.t\n , Token_symbol.var\n , Balance.var\n , Nonce.Checked.t\n , Receipt.Chain_hash.var\n , Public_key.Compressed.var\n , State_hash.var\n , Timing.var\n , Permissions.Checked.t\n , Zkapp_account.Checked.t )\n Poly.t\n\n let typ : (t, Stable.Latest.t) Typ.t =\n typ'\n (Typ.transport Zkapp_account.typ\n ~there:(fun t -> Option.value t ~default:Zkapp_account.default)\n ~back:(fun t -> Some t) )\n end\n\n let to_input (t : var) =\n let f mk acc field = mk (Core_kernel.Field.get field t) :: acc in\n let open Random_oracle.Input.Chunked in\n List.reduce_exn ~f:append\n (Poly.Fields.fold ~init:[]\n ~zkapp:(f (fun (x, _) -> field x))\n ~permissions:(f Permissions.Checked.to_input)\n ~public_key:(f Public_key.Compressed.Checked.to_input)\n ~token_id:(f Token_id.Checked.to_input)\n ~token_symbol:(f Token_symbol.var_to_input)\n ~balance:(f Balance.var_to_input) ~nonce:(f Nonce.Checked.to_input)\n ~receipt_chain_hash:(f Receipt.Chain_hash.var_to_input)\n ~delegate:(f Public_key.Compressed.Checked.to_input)\n ~voting_for:(f State_hash.var_to_input)\n ~timing:(f Timing.var_to_input) )\n\n let digest t =\n make_checked (fun () ->\n Random_oracle.Checked.(\n hash ~init:crypto_hash_prefix (pack_input (to_input t))) )\n\n let balance_upper_bound = Bignum_bigint.(one lsl Balance.length_in_bits)\n\n let amount_upper_bound = Bignum_bigint.(one lsl Amount.length_in_bits)\n\n let min_balance_at_slot ~global_slot ~cliff_time ~cliff_amount\n ~(vesting_period : Mina_numbers.Global_slot_span.Checked.var)\n ~vesting_increment ~initial_minimum_balance =\n let%bind before_cliff =\n Global_slot_since_genesis.Checked.(global_slot < cliff_time)\n in\n let%bind else_branch =\n make_checked (fun () ->\n let _, (slot_diff : Mina_numbers.Global_slot_span.Checked.var) =\n Tick.Run.run_checked\n (Global_slot_since_genesis.Checked.diff_or_zero global_slot\n cliff_time )\n in\n let cliff_decrement = cliff_amount in\n let min_balance_less_cliff_decrement =\n Tick.Run.run_checked\n (Balance.Checked.sub_amount_or_zero initial_minimum_balance\n cliff_decrement )\n in\n let (num_periods : Mina_numbers.Global_slot_span.Checked.var), _ =\n Tick.Run.run_checked\n (Global_slot_span.Checked.div_mod slot_diff vesting_period)\n in\n let vesting_decrement =\n Tick.Run.Field.mul\n (Global_slot_span.Checked.to_field num_periods)\n (Amount.pack_var vesting_increment)\n in\n let min_balance_less_cliff_and_vesting_decrements =\n Tick.Run.run_checked\n (Balance.Checked.sub_amount_or_zero\n min_balance_less_cliff_decrement\n Amount.(Checked.Unsafe.of_field vesting_decrement) )\n in\n min_balance_less_cliff_and_vesting_decrements )\n in\n Balance.Checked.if_ before_cliff ~then_:initial_minimum_balance\n ~else_:else_branch\n\n let has_locked_tokens ~global_slot (t : var) =\n let open Timing.As_record in\n let { is_timed = _\n ; initial_minimum_balance\n ; cliff_time\n ; cliff_amount\n ; vesting_period\n ; vesting_increment\n } =\n t.timing\n in\n let%bind cur_min_balance =\n min_balance_at_slot ~global_slot ~initial_minimum_balance ~cliff_time\n ~cliff_amount ~vesting_period ~vesting_increment\n in\n let%map zero_min_balance =\n Balance.equal_var Balance.(var_of_t zero) cur_min_balance\n in\n (*Note: Untimed accounts will always have zero min balance*)\n Boolean.not zero_min_balance\n\n let has_permission ?signature_verifies ~to_ (account : var) =\n let signature_verifies =\n match signature_verifies with\n | Some signature_verifies ->\n signature_verifies\n | None -> (\n match to_ with\n | `Send ->\n Boolean.true_\n | `Receive ->\n Boolean.false_\n | `Set_delegate ->\n Boolean.true_\n | `Increment_nonce ->\n Boolean.true_\n | `Access ->\n failwith\n \"Account.Checked.has_permission: signature_verifies argument \\\n must be given for access permission\" )\n in\n match to_ with\n | `Send ->\n Permissions.Auth_required.Checked.eval_no_proof account.permissions.send\n ~signature_verifies\n | `Receive ->\n Permissions.Auth_required.Checked.eval_no_proof\n account.permissions.receive ~signature_verifies\n | `Set_delegate ->\n Permissions.Auth_required.Checked.eval_no_proof\n account.permissions.set_delegate ~signature_verifies\n | `Increment_nonce ->\n Permissions.Auth_required.Checked.eval_no_proof\n account.permissions.increment_nonce ~signature_verifies\n | `Access ->\n Permissions.Auth_required.Checked.eval_no_proof\n account.permissions.access ~signature_verifies\nend\n\n[%%endif]\n\nlet digest = crypto_hash\n\nlet empty =\n { Poly.public_key = Public_key.Compressed.empty\n ; token_id = Token_id.default\n ; token_symbol = Token_symbol.default\n ; balance = Balance.zero\n ; nonce = Nonce.zero\n ; receipt_chain_hash = Receipt.Chain_hash.empty\n ; delegate = None\n ; voting_for = State_hash.dummy\n ; timing = Timing.Untimed\n ; permissions =\n Permissions.user_default\n (* TODO: This should maybe be Permissions.empty *)\n ; zkapp = None\n }\n\nlet empty_digest = digest empty\n\nlet create account_id balance =\n let public_key = Account_id.public_key account_id in\n let token_id = Account_id.token_id account_id in\n let delegate =\n (* Only allow delegation if this account is for the default token. *)\n if Token_id.(equal default) token_id then Some public_key else None\n in\n { Poly.public_key\n ; token_id\n ; token_symbol = Token_symbol.default\n ; balance\n ; nonce = Nonce.zero\n ; receipt_chain_hash = Receipt.Chain_hash.empty\n ; delegate\n ; voting_for = State_hash.dummy\n ; timing = Timing.Untimed\n ; permissions = Permissions.user_default\n ; zkapp = None\n }\n\nlet create_timed account_id balance ~initial_minimum_balance ~cliff_time\n ~cliff_amount ~vesting_period ~vesting_increment =\n if Global_slot_span.(equal vesting_period zero) then\n Or_error.errorf\n !\"Error creating timed account for account id %{sexp: Account_id.t}: \\\n vesting period must be greater than zero\"\n account_id\n else\n let public_key = Account_id.public_key account_id in\n let token_id = Account_id.token_id account_id in\n let delegate =\n (* Only allow delegation if this account is for the default token. *)\n if Token_id.(equal default) token_id then Some public_key else None\n in\n Or_error.return\n { Poly.public_key\n ; token_id\n ; token_symbol = Token_symbol.default\n ; balance\n ; nonce = Nonce.zero\n ; receipt_chain_hash = Receipt.Chain_hash.empty\n ; delegate\n ; voting_for = State_hash.dummy\n ; zkapp = None\n ; permissions = Permissions.user_default\n ; timing =\n Timing.Timed\n { initial_minimum_balance\n ; cliff_time\n ; cliff_amount\n ; vesting_period\n ; vesting_increment\n }\n }\n\n(* no vesting after cliff time + 1 slot *)\nlet create_time_locked public_key balance ~initial_minimum_balance ~cliff_time =\n create_timed public_key balance ~initial_minimum_balance ~cliff_time\n ~vesting_period:Global_slot_span.(succ zero)\n ~vesting_increment:initial_minimum_balance\n\nlet initial_minimum_balance Poly.{ timing; _ } =\n match timing with\n | Timing.Untimed ->\n None\n | Timed t ->\n Some t.initial_minimum_balance\n\nlet cliff_time Poly.{ timing; _ } =\n match timing with Timing.Untimed -> None | Timed t -> Some t.cliff_time\n\nlet cliff_amount Poly.{ timing; _ } =\n match timing with Timing.Untimed -> None | Timed t -> Some t.cliff_amount\n\nlet vesting_increment Poly.{ timing } =\n match timing with\n | Timing.Untimed ->\n None\n | Timed t ->\n Some t.vesting_increment\n\nlet vesting_period Poly.{ timing; _ } =\n match timing with Timing.Untimed -> None | Timed t -> Some t.vesting_period\n\nlet min_balance_at_slot ~global_slot ~cliff_time ~cliff_amount ~vesting_period\n ~vesting_increment ~initial_minimum_balance =\n let open Unsigned in\n if Global_slot_since_genesis.(global_slot < cliff_time) then\n initial_minimum_balance\n (* If vesting period is zero then everything vests immediately at the cliff *)\n else if Global_slot_span.(equal vesting_period zero) then Balance.zero\n else\n match Balance.(initial_minimum_balance - cliff_amount) with\n | None ->\n Balance.zero\n | Some min_balance_past_cliff -> (\n (* take advantage of fact that global slots are uint32's *)\n let num_periods =\n UInt32.(\n let global_slot_u32 =\n Global_slot_since_genesis.to_uint32 global_slot\n in\n let cliff_time_u32 =\n Global_slot_since_genesis.to_uint32 cliff_time\n in\n let vesting_period_u32 =\n Global_slot_span.to_uint32 vesting_period\n in\n Infix.((global_slot_u32 - cliff_time_u32) / vesting_period_u32)\n |> to_int64 |> UInt64.of_int64)\n in\n let vesting_decrement =\n let vesting_increment = Amount.to_uint64 vesting_increment in\n if\n try\n UInt64.(compare Infix.(max_int / num_periods) vesting_increment)\n < 0\n with Division_by_zero -> false\n then\n (* The vesting decrement will overflow, use [max_int] instead. *)\n UInt64.max_int |> Amount.of_uint64\n else\n UInt64.Infix.(num_periods * vesting_increment) |> Amount.of_uint64\n in\n match Balance.(min_balance_past_cliff - vesting_decrement) with\n | None ->\n Balance.zero\n | Some amt ->\n amt )\n\nlet incremental_balance_between_slots ~start_slot ~end_slot ~cliff_time\n ~cliff_amount ~vesting_period ~vesting_increment ~initial_minimum_balance :\n Unsigned.UInt64.t =\n let open Unsigned in\n if Global_slot_since_genesis.(end_slot <= start_slot) then UInt64.zero\n else\n let min_balance_at_start_slot =\n min_balance_at_slot ~global_slot:start_slot ~cliff_time ~cliff_amount\n ~vesting_period ~vesting_increment ~initial_minimum_balance\n |> Balance.to_amount |> Amount.to_uint64\n in\n let min_balance_at_end_slot =\n min_balance_at_slot ~global_slot:end_slot ~cliff_time ~cliff_amount\n ~vesting_period ~vesting_increment ~initial_minimum_balance\n |> Balance.to_amount |> Amount.to_uint64\n in\n UInt64.Infix.(min_balance_at_start_slot - min_balance_at_end_slot)\n\nlet has_locked_tokens ~global_slot (account : t) =\n match account.timing with\n | Untimed ->\n false\n | Timed\n { initial_minimum_balance\n ; cliff_time\n ; cliff_amount\n ; vesting_period\n ; vesting_increment\n } ->\n let curr_min_balance =\n min_balance_at_slot ~global_slot ~cliff_time ~cliff_amount\n ~vesting_period ~vesting_increment ~initial_minimum_balance\n in\n Balance.(curr_min_balance > zero)\n\nlet final_vesting_slot ~initial_minimum_balance ~cliff_time ~cliff_amount\n ~vesting_period ~vesting_increment =\n let open Unsigned in\n let to_vest =\n Balance.(initial_minimum_balance - cliff_amount)\n |> Option.value_map ~default:UInt64.zero ~f:Balance.to_uint64\n in\n let vest_incr = Amount.to_uint64 vesting_increment in\n let periods =\n let open UInt64 in\n let open Infix in\n (to_vest / vest_incr)\n + if equal (rem to_vest vest_incr) zero then zero else one\n in\n let open UInt32 in\n let open Infix in\n Global_slot_since_genesis.of_uint32\n @@ Global_slot_since_genesis.to_uint32 cliff_time\n + (UInt64.to_uint32 periods * Global_slot_span.to_uint32 vesting_period)\n\nlet timing_final_vesting_slot = function\n | Timing.Untimed ->\n Global_slot_since_genesis.zero\n | Timed\n { initial_minimum_balance\n ; cliff_time\n ; cliff_amount\n ; vesting_period\n ; vesting_increment\n } ->\n final_vesting_slot ~initial_minimum_balance ~cliff_time ~cliff_amount\n ~vesting_period ~vesting_increment\n\nlet has_permission ~control ~to_ (account : t) =\n match to_ with\n | `Access ->\n Permissions.Auth_required.check account.permissions.access control\n | `Send ->\n Permissions.Auth_required.check account.permissions.send control\n | `Receive ->\n Permissions.Auth_required.check account.permissions.receive control\n | `Set_delegate ->\n Permissions.Auth_required.check account.permissions.set_delegate control\n | `Increment_nonce ->\n Permissions.Auth_required.check account.permissions.increment_nonce\n control\n\n(** [true] iff account has permissions set that enable them to transfer Mina (assuming the command is signed) *)\nlet has_permission_to_send account =\n has_permission ~control:Control.Tag.Signature ~to_:`Access account\n && has_permission ~control:Control.Tag.Signature ~to_:`Send account\n\n(** [true] iff account has permissions set that enable them to receive Mina *)\nlet has_permission_to_receive account =\n has_permission ~control:Control.Tag.None_given ~to_:`Access account\n && has_permission ~control:Control.Tag.None_given ~to_:`Receive account\n\n(** [true] iff account has permissions set that enable them to set their delegate (assuming the command is signed) *)\nlet has_permission_to_set_delegate account =\n has_permission ~control:Control.Tag.Signature ~to_:`Access account\n && has_permission ~control:Control.Tag.Signature ~to_:`Set_delegate account\n\n(** [true] iff account has permissions set that enable them to increment their nonce (assuming the command is signed) *)\nlet has_permission_to_increment_nonce account =\n has_permission ~control:Control.Tag.Signature ~to_:`Access account\n && has_permission ~control:Control.Tag.Signature ~to_:`Increment_nonce account\n\nlet liquid_balance_at_slot ~global_slot (account : t) =\n match account.timing with\n | Untimed ->\n account.balance\n | Timed\n { initial_minimum_balance\n ; cliff_time\n ; cliff_amount\n ; vesting_period\n ; vesting_increment\n } ->\n Balance.sub_amount account.balance\n (Balance.to_amount\n (min_balance_at_slot ~global_slot ~cliff_time ~cliff_amount\n ~vesting_period ~vesting_increment ~initial_minimum_balance ) )\n |> Option.value_exn\n\nlet gen : t Quickcheck.Generator.t =\n let open Quickcheck.Let_syntax in\n let%bind public_key = Public_key.Compressed.gen in\n let%bind token_id = Token_id.gen in\n let%map balance = Currency.Balance.gen in\n create (Account_id.create public_key token_id) balance\n\nlet gen_with_constrained_balance ~low ~high : t Quickcheck.Generator.t =\n let open Quickcheck.Let_syntax in\n let%bind public_key = Public_key.Compressed.gen in\n let%bind token_id = Token_id.gen in\n let%map balance = Currency.Balance.gen_incl low high in\n create (Account_id.create public_key token_id) balance\n\nlet gen_any_vesting_range =\n let open Quickcheck.Generator.Let_syntax in\n let open Global_slot_since_genesis in\n (* vesting period must be at least one to avoid division by zero *)\n let%bind vesting_period = Int.gen_incl 1 1000 >>| Global_slot_span.of_int in\n let%bind vesting_end = gen_incl (of_int 1) max_value in\n let%map cliff_time = gen_incl (of_int 1) vesting_end in\n (cliff_time, vesting_end, vesting_period)\n\nlet gen_with_vesting_period vesting_period =\n let open Quickcheck.Generator.Let_syntax in\n let open Global_slot_since_genesis in\n let min_vesting_end =\n Global_slot_span.(succ vesting_period |> to_uint32)\n |> Global_slot_since_genesis.of_uint32\n in\n let%bind vesting_end = gen_incl min_vesting_end max_value in\n let max_cliff_time = Option.value_exn @@ sub vesting_end vesting_period in\n let%map cliff_time = gen_incl (of_int 1) max_cliff_time in\n (cliff_time, vesting_end, vesting_period)\n\nlet gen_vesting_details ~(cliff_time : Global_slot_since_genesis.t)\n ~(vesting_end : Global_slot_since_genesis.t)\n ~(vesting_period : Global_slot_span.t) (initial_minimum_balance : Balance.t)\n : Timing.as_record Quickcheck.Generator.t =\n let open Unsigned in\n let open Quickcheck in\n let open Generator.Let_syntax in\n let vesting_slots =\n let open Global_slot_since_genesis in\n let open UInt32.Infix in\n to_uint32 vesting_end - to_uint32 cliff_time\n in\n (* We need to arrange vesting schedule so that all funds are vested before the\n maximum global slot, which is 2 ^ 32. *)\n let vesting_periods_count =\n Unsigned.UInt32.div vesting_slots\n (Global_slot_span.to_uint32 vesting_period)\n |> UInt64.of_uint32\n in\n let max_cliff_amt =\n Balance.(initial_minimum_balance - Amount.of_uint64 vesting_periods_count)\n |> Option.value_map ~f:Balance.to_amount ~default:Amount.zero\n in\n let%map cliff_amount =\n if UInt64.(compare vesting_periods_count zero) > 0 then\n Amount.(gen_incl zero max_cliff_amt)\n else return @@ Balance.to_amount initial_minimum_balance\n in\n let to_vest =\n Balance.(initial_minimum_balance - cliff_amount)\n |> Option.value_map ~default:Unsigned.UInt64.zero ~f:Balance.to_uint64\n in\n let vesting_increment =\n if Unsigned.UInt64.(equal vesting_periods_count zero) then Amount.one\n (* This value does not matter anyway. *)\n else\n let vi = UInt64.Infix.(to_vest / vesting_periods_count) in\n let rnd = UInt64.Infix.(to_vest mod vesting_periods_count) in\n (if UInt64.(compare rnd zero) > 0 then UInt64.succ vi else vi)\n |> Amount.of_uint64\n in\n { Timing.As_record.is_timed = true\n ; initial_minimum_balance\n ; cliff_time\n ; cliff_amount\n ; vesting_period\n ; vesting_increment\n }\n\nlet gen_timing (account_balance : Balance.t) =\n let open Quickcheck.Generator.Let_syntax in\n let%bind initial_minimum_balance = Balance.(gen_incl one account_balance)\n and cliff_time, vesting_end, vesting_period = gen_any_vesting_range in\n gen_vesting_details ~vesting_period ~cliff_time ~vesting_end\n initial_minimum_balance\n\nlet gen_timing_at_least_one_vesting_period (account_balance : Balance.t) =\n let open Quickcheck.Generator.Let_syntax in\n let%bind initial_minimum_balance = Balance.(gen_incl one account_balance)\n (* vesting period must be at least one to avoid division by zero *)\n and cliff_time, vesting_end, vesting_period =\n gen_with_vesting_period @@ Global_slot_span.of_int 2\n in\n gen_vesting_details ~vesting_period ~cliff_time ~vesting_end\n initial_minimum_balance\n\nlet gen_timed : t Quickcheck.Generator.t =\n let open Quickcheck in\n let open Generator.Let_syntax in\n let%bind account =\n gen_with_constrained_balance ~low:Balance.one ~high:Balance.max_int\n in\n let%map timing = gen_timing account.balance in\n { account with timing = Timing.of_record timing }\n\nlet deriver obj =\n let open Fields_derivers_zkapps in\n let ( !. ) = ( !. ) ~t_fields_annots:Poly.t_fields_annots in\n let receipt_chain_hash =\n needs_custom_js ~js_type:field ~name:\"ReceiptChainHash\" field\n in\n finish \"Account\" ~t_toplevel_annots:Poly.t_toplevel_annots\n @@ Poly.Fields.make_creator ~public_key:!.public_key\n ~token_id:!.Token_id.deriver ~token_symbol:!.string ~balance:!.balance\n ~nonce:!.uint32 ~receipt_chain_hash:!.receipt_chain_hash\n ~delegate:!.(option ~js_type:Or_undefined (public_key @@ o ()))\n ~voting_for:!.field ~timing:!.Timing.deriver\n ~permissions:!.Permissions.deriver\n ~zkapp:!.(option ~js_type:Or_undefined (Zkapp_account.deriver @@ o ()))\n obj\n","open Core_kernel\nopen Currency\nopen Snark_params.Tick\n\nmodule Poly = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type ('ledger_hash, 'amount) t =\n ( 'ledger_hash\n , 'amount )\n Mina_wire_types.Mina_base.Epoch_ledger.Poly.V1.t =\n { hash : 'ledger_hash; total_currency : 'amount }\n [@@deriving annot, sexp, equal, compare, hash, yojson, hlist, fields]\n end\n end]\nend\n\nmodule Value = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t =\n (Frozen_ledger_hash0.Stable.V1.t, Amount.Stable.V1.t) Poly.Stable.V1.t\n [@@deriving sexp, equal, compare, hash, yojson]\n\n let to_latest = Fn.id\n end\n end]\nend\n\nlet to_input ({ hash; total_currency } : Value.t) =\n Random_oracle_input.Chunked.(\n append (field (hash :> Field.t)) (Amount.to_input total_currency))\n\ntype var = (Frozen_ledger_hash0.var, Amount.var) Poly.t\n\nlet typ : (var, Value.t) Typ.t =\n Typ.of_hlistable\n [ Frozen_ledger_hash0.typ; Amount.typ ]\n ~var_to_hlist:Poly.to_hlist ~var_of_hlist:Poly.of_hlist\n ~value_to_hlist:Poly.to_hlist ~value_of_hlist:Poly.of_hlist\n\nlet var_to_input ({ Poly.hash; total_currency } : var) =\n let total_currency = Amount.var_to_input total_currency in\n Random_oracle_input.Chunked.(\n append (field (Frozen_ledger_hash0.var_to_hash_packed hash)) total_currency)\n\nlet if_ cond ~(then_ : (Frozen_ledger_hash0.var, Amount.var) Poly.t)\n ~(else_ : (Frozen_ledger_hash0.var, Amount.var) Poly.t) =\n let open Checked.Let_syntax in\n let%map hash =\n Frozen_ledger_hash0.if_ cond ~then_:then_.hash ~else_:else_.hash\n and total_currency =\n Amount.Checked.if_ cond ~then_:then_.total_currency\n ~else_:else_.total_currency\n in\n { Poly.hash; total_currency }\n","open Core_kernel\n\ninclude Data_hash.Make_full_size (struct\n let version_byte = Base58_check.Version_bytes.epoch_seed\n\n let description = \"Epoch Seed\"\nend)\n\n[%%versioned\nmodule Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n module T = struct\n type t = (Snark_params.Tick.Field.t[@version_asserted])\n [@@deriving sexp, compare, hash]\n end\n\n include T\n\n let to_latest = Fn.id\n\n [%%define_from_scope to_yojson, of_yojson]\n\n include Comparable.Make (T)\n include Hashable.Make_binable (T)\n end\nend]\n\nlet _f () : (Stable.Latest.t, t) Type_equal.t = Type_equal.T\n","open Core_kernel\nopen Mina_numbers\n\nmodule Poly = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type ( 'epoch_ledger\n , 'epoch_seed\n , 'start_checkpoint\n , 'lock_checkpoint\n , 'length )\n t =\n ( 'epoch_ledger\n , 'epoch_seed\n , 'start_checkpoint\n , 'lock_checkpoint\n , 'length )\n Mina_wire_types.Mina_base.Epoch_data.Poly.V1.t =\n { ledger : 'epoch_ledger\n ; seed : 'epoch_seed\n ; start_checkpoint : 'start_checkpoint\n (* The lock checkpoint is the hash of the latest state in the seed update range, not including\n the current state. *)\n ; lock_checkpoint : 'lock_checkpoint\n ; epoch_length : 'length\n }\n [@@deriving annot, hlist, sexp, equal, compare, hash, yojson, fields]\n end\n end]\nend\n\ntype var =\n ( Epoch_ledger.var\n , Epoch_seed.var\n , State_hash.var\n , State_hash.var\n , Length.Checked.t )\n Poly.t\n\nlet if_ cond ~(then_ : var) ~(else_ : var) =\n let open Snark_params.Tick.Checked.Let_syntax in\n let%map ledger = Epoch_ledger.if_ cond ~then_:then_.ledger ~else_:else_.ledger\n and seed = Epoch_seed.if_ cond ~then_:then_.seed ~else_:else_.seed\n and start_checkpoint =\n State_hash.if_ cond ~then_:then_.start_checkpoint\n ~else_:else_.start_checkpoint\n and lock_checkpoint =\n State_hash.if_ cond ~then_:then_.lock_checkpoint\n ~else_:else_.lock_checkpoint\n and epoch_length =\n Length.Checked.if_ cond ~then_:then_.epoch_length ~else_:else_.epoch_length\n in\n { Poly.ledger; seed; start_checkpoint; lock_checkpoint; epoch_length }\n\nmodule Value = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t =\n ( Epoch_ledger.Value.Stable.V1.t\n , Epoch_seed.Stable.V1.t\n , State_hash.Stable.V1.t\n , State_hash.Stable.V1.t\n , Length.Stable.V1.t )\n Poly.Stable.V1.t\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n end\n end]\nend\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\n\n[%%ifdef consensus_mechanism]\n\nopen Snark_params.Tick\n\n[%%endif]\n\nopen Signature_lib\nmodule A = Account\nopen Mina_numbers\nopen Currency\nopen Zkapp_basic\nopen Pickles_types\nmodule Impl = Pickles.Impls.Step\n\nmodule Closed_interval = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type 'a t =\n 'a Mina_wire_types.Mina_base.Zkapp_precondition.Closed_interval.V1.t =\n { lower : 'a; upper : 'a }\n [@@deriving annot, sexp, equal, compare, hash, yojson, hlist, fields]\n end\n end]\n\n let gen gen_a compare_a =\n let open Quickcheck.Let_syntax in\n let%bind a1 = gen_a in\n let%map a2 = gen_a in\n if compare_a a1 a2 <= 0 then { lower = a1; upper = a2 }\n else { lower = a2; upper = a1 }\n\n let to_input { lower; upper } ~f =\n Random_oracle_input.Chunked.append (f lower) (f upper)\n\n let typ x =\n Typ.of_hlistable [ x; x ] ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist\n ~value_to_hlist:to_hlist ~value_of_hlist:of_hlist\n\n let deriver ~name inner obj =\n let open Fields_derivers_zkapps.Derivers in\n let ( !. ) = ( !. ) ~t_fields_annots in\n Fields.make_creator obj ~lower:!.inner ~upper:!.inner\n |> finish (name ^ \"Interval\") ~t_toplevel_annots\n\n let%test_module \"ClosedInterval\" =\n ( module struct\n module IntClosedInterval = struct\n type t_ = int t [@@deriving sexp, equal, compare]\n\n (* Note: nonrec doesn't work with ppx-deriving *)\n type t = t_ [@@deriving sexp, equal, compare]\n\n let v = { lower = 10; upper = 100 }\n end\n\n let%test_unit \"roundtrip json\" =\n let open Fields_derivers_zkapps.Derivers in\n let full = o () in\n let _a : _ Unified_input.t = deriver ~name:\"Int\" int full in\n [%test_eq: IntClosedInterval.t]\n (!(full#of_json) (!(full#to_json) IntClosedInterval.v))\n IntClosedInterval.v\n end )\nend\n\nlet assert_ b e = if b then Ok () else Or_error.error_string e\n\n(* Proofs are produced against a predicate on the protocol state. For the\n transaction to go through, the predicate must be satisfied of the protocol\n state at the time of transaction application. *)\nmodule Numeric = struct\n module Tc = struct\n type ('var, 'a) t =\n { zero : 'a\n ; max_value : 'a\n ; compare : 'a -> 'a -> int\n ; equal : 'a -> 'a -> bool\n ; typ : ('var, 'a) Typ.t\n ; to_input : 'a -> F.t Random_oracle_input.Chunked.t\n ; to_input_checked : 'var -> Field.Var.t Random_oracle_input.Chunked.t\n ; lte_checked : 'var -> 'var -> Boolean.var\n ; eq_checked : 'var -> 'var -> Boolean.var\n }\n\n let run f x y = Impl.run_checked (f x y)\n\n let ( !! ) f = Fn.compose Impl.run_checked f\n\n let length =\n Length.\n { zero\n ; max_value\n ; compare\n ; lte_checked = run Checked.( <= )\n ; eq_checked = run Checked.( = )\n ; equal\n ; typ\n ; to_input\n ; to_input_checked = Checked.to_input\n }\n\n let amount =\n Currency.Amount.\n { zero\n ; max_value = max_int\n ; compare\n ; lte_checked = run Checked.( <= )\n ; eq_checked = run Checked.( = )\n ; equal\n ; typ\n ; to_input\n ; to_input_checked = var_to_input\n }\n\n let balance =\n Currency.Balance.\n { zero\n ; max_value = max_int\n ; compare\n ; lte_checked = run Checked.( <= )\n ; eq_checked = run Checked.( = )\n ; equal\n ; typ\n ; to_input\n ; to_input_checked = var_to_input\n }\n\n let nonce =\n Account_nonce.\n { zero\n ; max_value\n ; compare\n ; lte_checked = run Checked.( <= )\n ; eq_checked = run Checked.( = )\n ; equal\n ; typ\n ; to_input\n ; to_input_checked = Checked.to_input\n }\n\n let global_slot =\n Global_slot_since_genesis.\n { zero\n ; max_value\n ; compare\n ; lte_checked = run Checked.( <= )\n ; eq_checked = run Checked.( = )\n ; equal\n ; typ\n ; to_input\n ; to_input_checked = Checked.to_input\n }\n end\n\n open Tc\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n type 'a t = 'a Closed_interval.Stable.V1.t Or_ignore.Stable.V1.t\n [@@deriving sexp, equal, yojson, hash, compare]\n end\n end]\n\n let deriver name inner range_max obj =\n let closed_interval obj' = Closed_interval.deriver ~name inner obj' in\n Or_ignore.deriver_interval ~range_max closed_interval obj\n\n module Derivers = struct\n open Fields_derivers_zkapps.Derivers\n\n let range_uint32 =\n Unsigned_extended.UInt32.(to_string zero, to_string max_int)\n\n let range_uint64 =\n Unsigned_extended.UInt64.(to_string zero, to_string max_int)\n\n let block_time_inner obj =\n let ( ^^ ) = Fn.compose in\n iso_string ~name:\"BlockTime\" ~js_type:UInt64\n ~of_string:(Block_time.of_uint64 ^^ Unsigned_extended.UInt64.of_string)\n ~to_string:(Unsigned_extended.UInt64.to_string ^^ Block_time.to_uint64)\n obj\n\n let nonce obj = deriver \"Nonce\" uint32 range_uint32 obj\n\n let balance obj = deriver \"Balance\" balance range_uint64 obj\n\n let amount obj = deriver \"CurrencyAmount\" amount range_uint64 obj\n\n let length obj = deriver \"Length\" uint32 range_uint32 obj\n\n let global_slot_since_genesis obj =\n deriver \"GlobalSlotSinceGenesis\" global_slot_since_genesis range_uint32\n obj\n\n let block_time obj = deriver \"BlockTime\" block_time_inner range_uint64 obj\n end\n\n let%test_module \"Numeric\" =\n ( module struct\n module Int_numeric = struct\n type t_ = int t [@@deriving sexp, equal, compare]\n\n (* Note: nonrec doesn't work with ppx-deriving *)\n type t = t_ [@@deriving sexp, equal, compare]\n end\n\n module T = struct\n type t = { foo : Int_numeric.t }\n [@@deriving annot, sexp, equal, compare, fields]\n\n let v : t =\n { foo = Or_ignore.Check { Closed_interval.lower = 10; upper = 100 } }\n\n let deriver obj =\n let open Fields_derivers_zkapps.Derivers in\n let ( !. ) = ( !. ) ~t_fields_annots in\n Fields.make_creator obj ~foo:!.(deriver \"Int\" int (\"0\", \"1000\"))\n |> finish \"T\" ~t_toplevel_annots\n end\n\n let%test_unit \"roundtrip json\" =\n let open Fields_derivers_zkapps.Derivers in\n let full = o () in\n let _a : _ Unified_input.t = T.deriver full in\n [%test_eq: T.t] (of_json full (to_json full T.v)) T.v\n end )\n\n let gen gen_a compare_a = Or_ignore.gen (Closed_interval.gen gen_a compare_a)\n\n let to_input { zero; max_value; to_input; _ } (t : 'a t) =\n Flagged_option.to_input'\n ~f:(Closed_interval.to_input ~f:to_input)\n ~field_of_bool\n ( match t with\n | Ignore ->\n { is_some = false\n ; data = { Closed_interval.lower = zero; upper = max_value }\n }\n | Check x ->\n { is_some = true; data = x } )\n\n module Checked = struct\n type 'a t = 'a Closed_interval.t Or_ignore.Checked.t\n\n let to_input { to_input_checked; _ } (t : 'a t) =\n Or_ignore.Checked.to_input t\n ~f:(Closed_interval.to_input ~f:to_input_checked)\n\n open Impl\n\n let check { lte_checked = ( <= ); _ } (t : 'a t) (x : 'a) =\n Or_ignore.Checked.check t ~f:(fun { lower; upper } ->\n Boolean.all [ lower <= x; x <= upper ] )\n\n let is_constant { eq_checked = ( = ); _ } (t : 'a t) =\n let is_constant ({ lower; upper } : _ Closed_interval.t) =\n lower = upper\n in\n Boolean.( &&& )\n (Or_ignore.Checked.is_check t)\n (is_constant (Or_ignore.Checked.data t))\n end\n\n let typ { zero; max_value; typ; _ } =\n Or_ignore.typ (Closed_interval.typ typ)\n ~ignore:{ Closed_interval.lower = zero; upper = max_value }\n\n let check ~label { compare; _ } (t : 'a t) (x : 'a) =\n match t with\n | Ignore ->\n Ok ()\n | Check { lower; upper } ->\n if compare lower x <= 0 && compare x upper <= 0 then Ok ()\n else Or_error.errorf \"Bounds check failed: %s\" label\n\n let is_constant { equal = ( = ); _ } (t : 'a t) =\n match t with Ignore -> false | Check { lower; upper } -> lower = upper\nend\n\nmodule Eq_data = struct\n include Or_ignore\n\n module Tc = struct\n type ('var, 'a) t =\n { equal : 'a -> 'a -> bool\n ; equal_checked : 'var -> 'var -> Boolean.var\n ; default : 'a\n ; typ : ('var, 'a) Typ.t\n ; to_input : 'a -> F.t Random_oracle_input.Chunked.t\n ; to_input_checked : 'var -> Field.Var.t Random_oracle_input.Chunked.t\n }\n\n let run f x y = Impl.run_checked (f x y)\n\n let field =\n let open Random_oracle_input.Chunked in\n Field.\n { typ\n ; equal\n ; equal_checked = run Checked.equal\n ; default = zero\n ; to_input = field\n ; to_input_checked = field\n }\n\n let action_state =\n let open Random_oracle_input.Chunked in\n lazy\n Field.\n { typ\n ; equal\n ; equal_checked = run Checked.equal\n ; default = Zkapp_account.Actions.empty_state_element\n ; to_input = field\n ; to_input_checked = field\n }\n\n let boolean =\n let open Random_oracle_input.Chunked in\n Boolean.\n { typ\n ; equal = Bool.equal\n ; equal_checked = run equal\n ; default = false\n ; to_input = (fun b -> packed (field_of_bool b, 1))\n ; to_input_checked =\n (fun (b : Boolean.var) -> packed ((b :> Field.Var.t), 1))\n }\n\n let receipt_chain_hash =\n Receipt.Chain_hash.\n { field with\n to_input_checked = var_to_input\n ; typ\n ; equal\n ; equal_checked = run equal_var\n }\n\n let ledger_hash =\n Ledger_hash.\n { field with\n to_input_checked = var_to_input\n ; typ\n ; equal\n ; equal_checked = run equal_var\n }\n\n let frozen_ledger_hash =\n Frozen_ledger_hash.\n { field with\n to_input_checked = var_to_input\n ; typ\n ; equal\n ; equal_checked = run equal_var\n }\n\n let state_hash =\n State_hash.\n { field with\n to_input_checked = var_to_input\n ; typ\n ; equal\n ; equal_checked = run equal_var\n }\n\n let token_id =\n Token_id.\n { default\n ; to_input_checked = Checked.to_input\n ; to_input\n ; typ\n ; equal\n ; equal_checked = Checked.equal\n }\n\n let epoch_seed =\n Epoch_seed.\n { field with\n to_input_checked = var_to_input\n ; typ\n ; equal\n ; equal_checked = run equal_var\n }\n\n let public_key () =\n Public_key.Compressed.\n { default = invalid_public_key\n ; to_input\n ; to_input_checked = Checked.to_input\n ; equal_checked = run Checked.equal\n ; typ\n ; equal\n }\n end\n\n let to_input { Tc.default; to_input; _ } (t : _ t) =\n Flagged_option.to_input' ~f:to_input ~field_of_bool\n ( match t with\n | Ignore ->\n { is_some = false; data = default }\n | Check data ->\n { is_some = true; data } )\n\n let to_input_checked { Tc.to_input_checked; _ } (t : _ Checked.t) =\n Checked.to_input t ~f:to_input_checked\n\n let check_checked { Tc.equal_checked; _ } (t : 'a Checked.t) (x : 'a) =\n Checked.check t ~f:(equal_checked x)\n\n let check ?(label = \"\") { Tc.equal; _ } (t : 'a t) (x : 'a) =\n match t with\n | Ignore ->\n Ok ()\n | Check y ->\n if equal x y then Ok ()\n else Or_error.errorf \"Equality check failed: %s\" label\n\n let typ { Tc.default = ignore; typ = t; _ } = typ ~ignore t\nend\n\nmodule Hash = Eq_data\n\nmodule Leaf_typs = struct\n let public_key () =\n Public_key.Compressed.(Or_ignore.typ ~ignore:invalid_public_key typ)\n\n open Eq_data.Tc\n\n let field = Eq_data.typ field\n\n let receipt_chain_hash = Hash.typ receipt_chain_hash\n\n let ledger_hash = Hash.typ ledger_hash\n\n let frozen_ledger_hash = Hash.typ frozen_ledger_hash\n\n let state_hash = Hash.typ state_hash\n\n open Numeric.Tc\n\n let length = Numeric.typ length\n\n let amount = Numeric.typ amount\n\n let balance = Numeric.typ balance\n\n let nonce = Numeric.typ nonce\n\n let global_slot = Numeric.typ global_slot\n\n let token_id = Hash.typ token_id\nend\n\nmodule Account = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t = Mina_wire_types.Mina_base.Zkapp_precondition.Account.V2.t =\n { balance : Balance.Stable.V1.t Numeric.Stable.V1.t\n ; nonce : Account_nonce.Stable.V1.t Numeric.Stable.V1.t\n ; receipt_chain_hash : Receipt.Chain_hash.Stable.V1.t Hash.Stable.V1.t\n ; delegate : Public_key.Compressed.Stable.V1.t Eq_data.Stable.V1.t\n ; state : F.Stable.V1.t Eq_data.Stable.V1.t Zkapp_state.V.Stable.V1.t\n ; action_state : F.Stable.V1.t Eq_data.Stable.V1.t\n ; proved_state : bool Eq_data.Stable.V1.t\n ; is_new : bool Eq_data.Stable.V1.t\n }\n [@@deriving annot, hlist, sexp, equal, yojson, hash, compare, fields]\n\n let to_latest = Fn.id\n end\n end]\n\n let gen : t Quickcheck.Generator.t =\n let open Quickcheck.Let_syntax in\n let%bind balance = Numeric.gen Balance.gen Balance.compare in\n let%bind nonce = Numeric.gen Account_nonce.gen Account_nonce.compare in\n let%bind receipt_chain_hash = Or_ignore.gen Receipt.Chain_hash.gen in\n let%bind delegate = Eq_data.gen Public_key.Compressed.gen in\n let%bind state =\n let%bind fields =\n let field_gen = Snark_params.Tick.Field.gen in\n Quickcheck.Generator.list_with_length 8 (Or_ignore.gen field_gen)\n in\n (* won't raise because length is correct *)\n Quickcheck.Generator.return (Zkapp_state.V.of_list_exn fields)\n in\n let%bind action_state =\n let%bind n = Int.gen_uniform_incl Int.min_value Int.max_value in\n let field_gen = Quickcheck.Generator.return (F.of_int n) in\n Or_ignore.gen field_gen\n in\n let%bind proved_state = Or_ignore.gen Quickcheck.Generator.bool in\n let%map is_new = Or_ignore.gen Quickcheck.Generator.bool in\n { balance\n ; nonce\n ; receipt_chain_hash\n ; delegate\n ; state\n ; action_state\n ; proved_state\n ; is_new\n }\n\n let accept : t =\n { balance = Ignore\n ; nonce = Ignore\n ; receipt_chain_hash = Ignore\n ; delegate = Ignore\n ; state =\n Vector.init Zkapp_state.Max_state_size.n ~f:(fun _ -> Or_ignore.Ignore)\n ; action_state = Ignore\n ; proved_state = Ignore\n ; is_new = Ignore\n }\n\n let is_accept : t -> bool = equal accept\n\n let deriver obj =\n let open Fields_derivers_zkapps in\n let ( !. ) = ( !. ) ~t_fields_annots in\n let action_state =\n needs_custom_js ~js_type:field ~name:\"ActionState\" field\n in\n Fields.make_creator obj ~balance:!.Numeric.Derivers.balance\n ~nonce:!.Numeric.Derivers.nonce\n ~receipt_chain_hash:!.(Or_ignore.deriver field)\n ~delegate:!.(Or_ignore.deriver public_key)\n ~state:!.(Zkapp_state.deriver @@ Or_ignore.deriver field)\n ~action_state:!.(Or_ignore.deriver action_state)\n ~proved_state:!.(Or_ignore.deriver bool)\n ~is_new:!.(Or_ignore.deriver bool)\n |> finish \"AccountPrecondition\" ~t_toplevel_annots\n\n let%test_unit \"json roundtrip\" =\n let b = Balance.of_nanomina_int_exn 1000 in\n let predicate : t =\n { accept with\n balance = Or_ignore.Check { Closed_interval.lower = b; upper = b }\n ; action_state = Or_ignore.Check (Field.of_int 99)\n ; proved_state = Or_ignore.Check true\n }\n in\n let module Fd = Fields_derivers_zkapps.Derivers in\n let full = deriver (Fd.o ()) in\n [%test_eq: t] predicate (predicate |> Fd.to_json full |> Fd.of_json full)\n\n let to_input\n ({ balance\n ; nonce\n ; receipt_chain_hash\n ; delegate\n ; state\n ; action_state\n ; proved_state\n ; is_new\n } :\n t ) =\n let open Random_oracle_input.Chunked in\n List.reduce_exn ~f:append\n [ Numeric.(to_input Tc.balance balance)\n ; Numeric.(to_input Tc.nonce nonce)\n ; Hash.(to_input Tc.receipt_chain_hash receipt_chain_hash)\n ; Eq_data.(to_input (Tc.public_key ()) delegate)\n ; Vector.reduce_exn ~f:append\n (Vector.map state ~f:Eq_data.(to_input Tc.field))\n ; Eq_data.(to_input (Lazy.force Tc.action_state)) action_state\n ; Eq_data.(to_input Tc.boolean) proved_state\n ; Eq_data.(to_input Tc.boolean) is_new\n ]\n\n let digest t =\n Random_oracle.(\n hash ~init:Hash_prefix.zkapp_precondition_account\n (pack_input (to_input t)))\n\n module Checked = struct\n type t =\n { balance : Balance.var Numeric.Checked.t\n ; nonce : Account_nonce.Checked.t Numeric.Checked.t\n ; receipt_chain_hash : Receipt.Chain_hash.var Hash.Checked.t\n ; delegate : Public_key.Compressed.var Eq_data.Checked.t\n ; state : Field.Var.t Eq_data.Checked.t Zkapp_state.V.t\n ; action_state : Field.Var.t Eq_data.Checked.t\n ; proved_state : Boolean.var Eq_data.Checked.t\n ; is_new : Boolean.var Eq_data.Checked.t\n }\n [@@deriving hlist]\n\n let to_input\n ({ balance\n ; nonce\n ; receipt_chain_hash\n ; delegate\n ; state\n ; action_state\n ; proved_state\n ; is_new\n } :\n t ) =\n let open Random_oracle_input.Chunked in\n List.reduce_exn ~f:append\n [ Numeric.(Checked.to_input Tc.balance balance)\n ; Numeric.(Checked.to_input Tc.nonce nonce)\n ; Hash.(to_input_checked Tc.receipt_chain_hash receipt_chain_hash)\n ; Eq_data.(to_input_checked (Tc.public_key ()) delegate)\n ; Vector.reduce_exn ~f:append\n (Vector.map state ~f:Eq_data.(to_input_checked Tc.field))\n ; Eq_data.(to_input_checked (Lazy.force Tc.action_state)) action_state\n ; Eq_data.(to_input_checked Tc.boolean) proved_state\n ; Eq_data.(to_input_checked Tc.boolean) is_new\n ]\n\n open Impl\n\n let checks ~new_account\n { balance\n ; nonce\n ; receipt_chain_hash\n ; delegate\n ; state\n ; action_state\n ; proved_state\n ; is_new\n } (a : Account.Checked.Unhashed.t) =\n [ ( Transaction_status.Failure.Account_balance_precondition_unsatisfied\n , Numeric.(Checked.check Tc.balance balance a.balance) )\n ; ( Transaction_status.Failure.Account_nonce_precondition_unsatisfied\n , Numeric.(Checked.check Tc.nonce nonce a.nonce) )\n ; ( Transaction_status.Failure\n .Account_receipt_chain_hash_precondition_unsatisfied\n , Eq_data.(\n check_checked Tc.receipt_chain_hash receipt_chain_hash\n a.receipt_chain_hash) )\n ; ( Transaction_status.Failure.Account_delegate_precondition_unsatisfied\n , Eq_data.(check_checked (Tc.public_key ()) delegate a.delegate) )\n ]\n @ [ ( Transaction_status.Failure\n .Account_action_state_precondition_unsatisfied\n , Boolean.any\n Vector.(\n to_list\n (map a.zkapp.action_state\n ~f:\n Eq_data.(\n check_checked (Lazy.force Tc.action_state) action_state) ))\n )\n ]\n @ ( Vector.(\n to_list\n (map2 state a.zkapp.app_state ~f:Eq_data.(check_checked Tc.field)))\n |> List.mapi ~f:(fun i check ->\n let failure =\n Transaction_status.Failure\n .Account_app_state_precondition_unsatisfied\n i\n in\n (failure, check) ) )\n @ [ ( Transaction_status.Failure\n .Account_proved_state_precondition_unsatisfied\n , Eq_data.(check_checked Tc.boolean proved_state a.zkapp.proved_state)\n )\n ]\n @ [ ( Transaction_status.Failure.Account_is_new_precondition_unsatisfied\n , Eq_data.(check_checked Tc.boolean is_new new_account) )\n ]\n\n let check ~new_account ~check t a =\n List.iter\n ~f:(fun (failure, passed) -> check failure passed)\n (checks ~new_account t a)\n\n let digest (t : t) =\n Random_oracle.Checked.(\n hash ~init:Hash_prefix.zkapp_precondition_account\n (pack_input (to_input t)))\n end\n\n let typ () : (Checked.t, t) Typ.t =\n let open Leaf_typs in\n Typ.of_hlistable\n [ balance\n ; nonce\n ; receipt_chain_hash\n ; public_key ()\n ; Zkapp_state.typ (Or_ignore.typ Field.typ ~ignore:Field.zero)\n ; Or_ignore.typ Field.typ\n ~ignore:Zkapp_account.Actions.empty_state_element\n ; Or_ignore.typ Boolean.typ ~ignore:false\n ; Or_ignore.typ Boolean.typ ~ignore:false\n ]\n ~var_to_hlist:Checked.to_hlist ~var_of_hlist:Checked.of_hlist\n ~value_to_hlist:to_hlist ~value_of_hlist:of_hlist\n\n let checks ~new_account\n { balance\n ; nonce\n ; receipt_chain_hash\n ; delegate\n ; state\n ; action_state\n ; proved_state\n ; is_new\n } (a : Account.t) =\n [ ( Transaction_status.Failure.Account_balance_precondition_unsatisfied\n , Numeric.(check ~label:\"balance\" Tc.balance balance a.balance) )\n ; ( Transaction_status.Failure.Account_nonce_precondition_unsatisfied\n , Numeric.(check ~label:\"nonce\" Tc.nonce nonce a.nonce) )\n ; ( Transaction_status.Failure\n .Account_receipt_chain_hash_precondition_unsatisfied\n , Eq_data.(\n check ~label:\"receipt_chain_hash\" Tc.receipt_chain_hash\n receipt_chain_hash a.receipt_chain_hash) )\n ; ( Transaction_status.Failure.Account_delegate_precondition_unsatisfied\n , let tc = Eq_data.Tc.public_key () in\n Eq_data.(\n check ~label:\"delegate\" tc delegate\n (Option.value ~default:tc.default a.delegate)) )\n ]\n @\n let zkapp = Option.value ~default:Zkapp_account.default a.zkapp in\n [ ( Transaction_status.Failure.Account_action_state_precondition_unsatisfied\n , match\n List.find (Vector.to_list zkapp.action_state) ~f:(fun state ->\n Eq_data.(\n check (Lazy.force Tc.action_state) ~label:\"\" action_state state)\n |> Or_error.is_ok )\n with\n | None ->\n Error (Error.createf \"Action state mismatch\")\n | Some _ ->\n Ok () )\n ]\n @ List.mapi\n Vector.(to_list (zip state zkapp.app_state))\n ~f:(fun i (c, v) ->\n let failure =\n Transaction_status.Failure\n .Account_app_state_precondition_unsatisfied\n i\n in\n (failure, Eq_data.(check Tc.field ~label:(sprintf \"state[%d]\" i) c v))\n )\n @ [ ( Transaction_status.Failure\n .Account_proved_state_precondition_unsatisfied\n , Eq_data.(\n check ~label:\"proved_state\" Tc.boolean proved_state\n zkapp.proved_state) )\n ]\n @ [ ( Transaction_status.Failure.Account_is_new_precondition_unsatisfied\n , Eq_data.(check ~label:\"is_new\" Tc.boolean is_new new_account) )\n ]\n\n let check ~new_account ~check t a =\n List.iter\n ~f:(fun (failure, res) -> check failure (Result.is_ok res))\n (checks ~new_account t a)\nend\n\nmodule Protocol_state = struct\n (* On each numeric field, you may assert a range\n On each hash field, you may assert an equality\n *)\n\n module Epoch_data = struct\n module Poly = Epoch_data.Poly\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n (* TODO: Not sure if this should be frozen ledger hash or not *)\n type t =\n ( ( Frozen_ledger_hash.Stable.V1.t Hash.Stable.V1.t\n , Currency.Amount.Stable.V1.t Numeric.Stable.V1.t )\n Epoch_ledger.Poly.Stable.V1.t\n , Epoch_seed.Stable.V1.t Hash.Stable.V1.t\n , State_hash.Stable.V1.t Hash.Stable.V1.t\n , State_hash.Stable.V1.t Hash.Stable.V1.t\n , Length.Stable.V1.t Numeric.Stable.V1.t )\n Poly.Stable.V1.t\n [@@deriving sexp, equal, yojson, hash, compare]\n\n let to_latest = Fn.id\n end\n end]\n\n let deriver obj =\n let open Fields_derivers_zkapps.Derivers in\n let ledger obj' =\n let ( !. ) =\n ( !. ) ~t_fields_annots:Epoch_ledger.Poly.t_fields_annots\n in\n Epoch_ledger.Poly.Fields.make_creator obj'\n ~hash:!.(Or_ignore.deriver field)\n ~total_currency:!.Numeric.Derivers.amount\n |> finish \"EpochLedgerPrecondition\"\n ~t_toplevel_annots:Epoch_ledger.Poly.t_toplevel_annots\n in\n let ( !. ) = ( !. ) ~t_fields_annots:Poly.t_fields_annots in\n Poly.Fields.make_creator obj ~ledger:!.ledger\n ~seed:!.(Or_ignore.deriver field)\n ~start_checkpoint:!.(Or_ignore.deriver field)\n ~lock_checkpoint:!.(Or_ignore.deriver field)\n ~epoch_length:!.Numeric.Derivers.length\n |> finish \"EpochDataPrecondition\"\n ~t_toplevel_annots:Poly.t_toplevel_annots\n\n let%test_unit \"json roundtrip\" =\n let f = Or_ignore.Check Field.one in\n let u = Length.zero in\n let a = Amount.zero in\n let predicate : t =\n { Poly.ledger =\n { Epoch_ledger.Poly.hash = f\n ; total_currency =\n Or_ignore.Check { Closed_interval.lower = a; upper = a }\n }\n ; seed = f\n ; start_checkpoint = f\n ; lock_checkpoint = f\n ; epoch_length =\n Or_ignore.Check { Closed_interval.lower = u; upper = u }\n }\n in\n let module Fd = Fields_derivers_zkapps.Derivers in\n let full = deriver (Fd.o ()) in\n [%test_eq: t] predicate (predicate |> Fd.to_json full |> Fd.of_json full)\n\n let gen : t Quickcheck.Generator.t =\n let open Quickcheck.Let_syntax in\n let%bind ledger =\n let%bind hash = Hash.gen Frozen_ledger_hash0.gen in\n let%map total_currency = Numeric.gen Amount.gen Amount.compare in\n { Epoch_ledger.Poly.hash; total_currency }\n in\n let%bind seed = Hash.gen Epoch_seed.gen in\n let%bind start_checkpoint = Hash.gen State_hash.gen in\n let%bind lock_checkpoint = Hash.gen State_hash.gen in\n let min_epoch_length = 8 in\n let max_epoch_length = Genesis_constants.slots_per_epoch in\n let%map epoch_length =\n Numeric.gen\n (Length.gen_incl\n (Length.of_int min_epoch_length)\n (Length.of_int max_epoch_length) )\n Length.compare\n in\n { Poly.ledger; seed; start_checkpoint; lock_checkpoint; epoch_length }\n\n let to_input\n ({ ledger = { hash; total_currency }\n ; seed\n ; start_checkpoint\n ; lock_checkpoint\n ; epoch_length\n } :\n t ) =\n let open Random_oracle.Input.Chunked in\n List.reduce_exn ~f:append\n [ Hash.(to_input Tc.frozen_ledger_hash hash)\n ; Numeric.(to_input Tc.amount total_currency)\n ; Hash.(to_input Tc.epoch_seed seed)\n ; Hash.(to_input Tc.state_hash start_checkpoint)\n ; Hash.(to_input Tc.state_hash lock_checkpoint)\n ; Numeric.(to_input Tc.length epoch_length)\n ]\n\n module Checked = struct\n type t =\n ( ( Frozen_ledger_hash.var Hash.Checked.t\n , Currency.Amount.var Numeric.Checked.t )\n Epoch_ledger.Poly.t\n , Epoch_seed.var Hash.Checked.t\n , State_hash.var Hash.Checked.t\n , State_hash.var Hash.Checked.t\n , Length.Checked.t Numeric.Checked.t )\n Poly.t\n\n let to_input\n ({ ledger = { hash; total_currency }\n ; seed\n ; start_checkpoint\n ; lock_checkpoint\n ; epoch_length\n } :\n t ) =\n let open Random_oracle.Input.Chunked in\n List.reduce_exn ~f:append\n [ Hash.(to_input_checked Tc.frozen_ledger_hash hash)\n ; Numeric.(Checked.to_input Tc.amount total_currency)\n ; Hash.(to_input_checked Tc.epoch_seed seed)\n ; Hash.(to_input_checked Tc.state_hash start_checkpoint)\n ; Hash.(to_input_checked Tc.state_hash lock_checkpoint)\n ; Numeric.(Checked.to_input Tc.length epoch_length)\n ]\n end\n end\n\n module Poly = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type ( 'snarked_ledger_hash\n , 'length\n , 'global_slot\n , 'amount\n , 'epoch_data )\n t =\n ( 'snarked_ledger_hash\n , 'length\n , 'global_slot\n , 'amount\n , 'epoch_data )\n Mina_wire_types.Mina_base.Zkapp_precondition.Protocol_state.Poly\n .V1\n .t =\n { (* TODO:\n We should include staged ledger hash again! It only changes once per\n block. *)\n snarked_ledger_hash : 'snarked_ledger_hash\n ; blockchain_length : 'length\n (* TODO: This previously had epoch_count but I removed it as I believe it is redundant\n with global_slot_since_hard_fork.\n\n epoch_count in [a, b]\n\n should be equivalent to\n\n global_slot_since_hard_fork in [slots_per_epoch * a, slots_per_epoch * b]\n\n TODO: Now that we removed global_slot_since_hard_fork, maybe we want to add epoch_count back\n *)\n ; min_window_density : 'length\n ; total_currency : 'amount\n ; global_slot_since_genesis : 'global_slot\n ; staking_epoch_data : 'epoch_data\n ; next_epoch_data : 'epoch_data\n }\n [@@deriving annot, hlist, sexp, equal, yojson, hash, compare, fields]\n end\n end]\n end\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t =\n ( Frozen_ledger_hash.Stable.V1.t Hash.Stable.V1.t\n , Length.Stable.V1.t Numeric.Stable.V1.t\n , Global_slot_since_genesis.Stable.V1.t Numeric.Stable.V1.t\n , Currency.Amount.Stable.V1.t Numeric.Stable.V1.t\n , Epoch_data.Stable.V1.t )\n Poly.Stable.V1.t\n [@@deriving sexp, equal, yojson, hash, compare]\n\n let to_latest = Fn.id\n end\n end]\n\n let deriver obj =\n let open Fields_derivers_zkapps.Derivers in\n let ( !. ) ?skip_data =\n ( !. ) ?skip_data ~t_fields_annots:Poly.t_fields_annots\n in\n Poly.Fields.make_creator obj\n ~snarked_ledger_hash:!.(Or_ignore.deriver field)\n ~blockchain_length:!.Numeric.Derivers.length\n ~min_window_density:!.Numeric.Derivers.length\n ~total_currency:!.Numeric.Derivers.amount\n ~global_slot_since_genesis:!.Numeric.Derivers.global_slot_since_genesis\n ~staking_epoch_data:!.Epoch_data.deriver\n ~next_epoch_data:!.Epoch_data.deriver\n |> finish \"NetworkPrecondition\" ~t_toplevel_annots:Poly.t_toplevel_annots\n\n let gen : t Quickcheck.Generator.t =\n let open Quickcheck.Let_syntax in\n (* TODO: pass in ledger hash, next available token *)\n let snarked_ledger_hash = Zkapp_basic.Or_ignore.Ignore in\n let%bind blockchain_length = Numeric.gen Length.gen Length.compare in\n let max_min_window_density =\n Genesis_constants.for_unit_tests.protocol.slots_per_sub_window\n * Genesis_constants.Constraint_constants.compiled.sub_windows_per_window\n - 1\n |> Length.of_int\n in\n let%bind min_window_density =\n Numeric.gen\n (Length.gen_incl Length.zero max_min_window_density)\n Length.compare\n in\n let%bind total_currency =\n Numeric.gen Currency.Amount.gen Currency.Amount.compare\n in\n let%bind global_slot_since_genesis =\n Numeric.gen Global_slot_since_genesis.gen\n Global_slot_since_genesis.compare\n in\n let%bind staking_epoch_data = Epoch_data.gen in\n let%map next_epoch_data = Epoch_data.gen in\n { Poly.snarked_ledger_hash\n ; blockchain_length\n ; min_window_density\n ; total_currency\n ; global_slot_since_genesis\n ; staking_epoch_data\n ; next_epoch_data\n }\n\n let to_input\n ({ snarked_ledger_hash\n ; blockchain_length\n ; min_window_density\n ; total_currency\n ; global_slot_since_genesis\n ; staking_epoch_data\n ; next_epoch_data\n } :\n t ) =\n let open Random_oracle.Input.Chunked in\n let length = Numeric.(to_input Tc.length) in\n List.reduce_exn ~f:append\n [ Hash.(to_input Tc.field snarked_ledger_hash)\n ; length blockchain_length\n ; length min_window_density\n ; Numeric.(to_input Tc.amount total_currency)\n ; Numeric.(to_input Tc.global_slot global_slot_since_genesis)\n ; Epoch_data.to_input staking_epoch_data\n ; Epoch_data.to_input next_epoch_data\n ]\n\n let digest t =\n Random_oracle.(\n hash ~init:Hash_prefix.zkapp_precondition_protocol_state\n (pack_input (to_input t)))\n\n module View = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t =\n ( Frozen_ledger_hash.Stable.V1.t\n , Length.Stable.V1.t\n , Global_slot_since_genesis.Stable.V1.t\n , Currency.Amount.Stable.V1.t\n , ( ( Frozen_ledger_hash.Stable.V1.t\n , Currency.Amount.Stable.V1.t )\n Epoch_ledger.Poly.Stable.V1.t\n , Epoch_seed.Stable.V1.t\n , State_hash.Stable.V1.t\n , State_hash.Stable.V1.t\n , Length.Stable.V1.t )\n Epoch_data.Poly.Stable.V1.t )\n Poly.Stable.V1.t\n [@@deriving sexp, equal, yojson, hash, compare]\n\n let to_latest = Fn.id\n end\n end]\n\n module Checked = struct\n type t =\n ( Frozen_ledger_hash.var\n , Length.Checked.t\n , Global_slot_since_genesis.Checked.t\n , Currency.Amount.var\n , ( (Frozen_ledger_hash.var, Currency.Amount.var) Epoch_ledger.Poly.t\n , Epoch_seed.var\n , State_hash.var\n , State_hash.var\n , Length.Checked.t )\n Epoch_data.Poly.t )\n Poly.t\n end\n\n let epoch_data_deriver obj =\n let open Fields_derivers_zkapps.Derivers in\n let ledger obj' =\n let ( !. ) =\n ( !. ) ~t_fields_annots:Epoch_ledger.Poly.t_fields_annots\n in\n Epoch_ledger.Poly.Fields.make_creator obj' ~hash:!.field\n ~total_currency:!.amount\n |> finish \"EpochLedger\"\n ~t_toplevel_annots:Epoch_ledger.Poly.t_toplevel_annots\n in\n let ( !. ) = ( !. ) ~t_fields_annots:Epoch_data.Poly.t_fields_annots in\n Epoch_data.Poly.Fields.make_creator obj ~ledger:!.ledger ~seed:!.field\n ~start_checkpoint:!.field ~lock_checkpoint:!.field\n ~epoch_length:!.uint32\n |> finish \"EpochData\" ~t_toplevel_annots:Epoch_data.Poly.t_toplevel_annots\n\n let deriver obj =\n let open Fields_derivers_zkapps.Derivers in\n let ( !. ) ?skip_data =\n ( !. ) ?skip_data ~t_fields_annots:Poly.t_fields_annots\n in\n Poly.Fields.make_creator obj ~snarked_ledger_hash:!.field\n ~blockchain_length:!.uint32 ~min_window_density:!.uint32\n ~total_currency:!.amount\n ~global_slot_since_genesis:!.global_slot_since_genesis\n ~staking_epoch_data:!.epoch_data_deriver\n ~next_epoch_data:!.epoch_data_deriver\n |> finish \"NetworkView\" ~t_toplevel_annots:Poly.t_toplevel_annots\n end\n\n module Checked = struct\n type t =\n ( Frozen_ledger_hash.var Hash.Checked.t\n , Length.Checked.t Numeric.Checked.t\n , Global_slot_since_genesis.Checked.t Numeric.Checked.t\n , Currency.Amount.var Numeric.Checked.t\n , Epoch_data.Checked.t )\n Poly.Stable.Latest.t\n\n let to_input\n ({ snarked_ledger_hash\n ; blockchain_length\n ; min_window_density\n ; total_currency\n ; global_slot_since_genesis\n ; staking_epoch_data\n ; next_epoch_data\n } :\n t ) =\n let open Random_oracle.Input.Chunked in\n let length = Numeric.(Checked.to_input Tc.length) in\n List.reduce_exn ~f:append\n [ Hash.(to_input_checked Tc.frozen_ledger_hash snarked_ledger_hash)\n ; length blockchain_length\n ; length min_window_density\n ; Numeric.(Checked.to_input Tc.amount total_currency)\n ; Numeric.(Checked.to_input Tc.global_slot global_slot_since_genesis)\n ; Epoch_data.Checked.to_input staking_epoch_data\n ; Epoch_data.Checked.to_input next_epoch_data\n ]\n\n let digest t =\n Random_oracle.Checked.(\n hash ~init:Hash_prefix.zkapp_precondition_protocol_state\n (pack_input (to_input t)))\n\n let check\n (* Bind all the fields explicity so we make sure they are all used. *)\n ({ snarked_ledger_hash\n ; blockchain_length\n ; min_window_density\n ; total_currency\n ; global_slot_since_genesis\n ; staking_epoch_data\n ; next_epoch_data\n } :\n t ) (s : View.Checked.t) =\n let open Impl in\n let epoch_ledger ({ hash; total_currency } : _ Epoch_ledger.Poly.t)\n (t : Epoch_ledger.var) =\n [ Hash.(check_checked Tc.frozen_ledger_hash) hash t.hash\n ; Numeric.(Checked.check Tc.amount) total_currency t.total_currency\n ]\n in\n let epoch_data\n ({ ledger; seed; start_checkpoint; lock_checkpoint; epoch_length } :\n _ Epoch_data.Poly.t ) (t : _ Epoch_data.Poly.t) =\n ignore seed ;\n epoch_ledger ledger t.ledger\n @ [ Hash.(check_checked Tc.state_hash)\n start_checkpoint t.start_checkpoint\n ; Hash.(check_checked Tc.state_hash) lock_checkpoint t.lock_checkpoint\n ; Numeric.(Checked.check Tc.length) epoch_length t.epoch_length\n ]\n in\n Boolean.all\n ( [ Hash.(check_checked Tc.ledger_hash)\n snarked_ledger_hash s.snarked_ledger_hash\n ; Numeric.(Checked.check Tc.length)\n blockchain_length s.blockchain_length\n ; Numeric.(Checked.check Tc.length)\n min_window_density s.min_window_density\n ; Numeric.(Checked.check Tc.amount) total_currency s.total_currency\n ; Numeric.(Checked.check Tc.global_slot)\n global_slot_since_genesis s.global_slot_since_genesis\n ]\n @ epoch_data staking_epoch_data s.staking_epoch_data\n @ epoch_data next_epoch_data s.next_epoch_data )\n end\n\n let typ : (Checked.t, Stable.Latest.t) Typ.t =\n let open Poly.Stable.Latest in\n let frozen_ledger_hash = Hash.(typ Tc.frozen_ledger_hash) in\n let state_hash = Hash.(typ Tc.state_hash) in\n let epoch_seed = Hash.(typ Tc.epoch_seed) in\n let length = Numeric.(typ Tc.length) in\n let amount = Numeric.(typ Tc.amount) in\n let global_slot = Numeric.(typ Tc.global_slot) in\n let epoch_data =\n let epoch_ledger =\n let open Epoch_ledger.Poly in\n Typ.of_hlistable\n [ frozen_ledger_hash; amount ]\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist\n in\n let open Epoch_data.Poly in\n Typ.of_hlistable\n [ epoch_ledger; epoch_seed; state_hash; state_hash; length ]\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist\n in\n Typ.of_hlistable\n [ frozen_ledger_hash\n ; length\n ; length\n ; amount\n ; global_slot\n ; epoch_data\n ; epoch_data\n ]\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist\n\n let epoch_data : Epoch_data.t =\n { ledger = { hash = Ignore; total_currency = Ignore }\n ; seed = Ignore\n ; start_checkpoint = Ignore\n ; lock_checkpoint = Ignore\n ; epoch_length = Ignore\n }\n\n let accept : t =\n { snarked_ledger_hash = Ignore\n ; blockchain_length = Ignore\n ; min_window_density = Ignore\n ; total_currency = Ignore\n ; global_slot_since_genesis = Ignore\n ; staking_epoch_data = epoch_data\n ; next_epoch_data = epoch_data\n }\n\n let valid_until time : t =\n { snarked_ledger_hash = Ignore\n ; blockchain_length = Ignore\n ; min_window_density = Ignore\n ; total_currency = Ignore\n ; global_slot_since_genesis = Check time\n ; staking_epoch_data = epoch_data\n ; next_epoch_data = epoch_data\n }\n\n let%test_unit \"json roundtrip\" =\n let predicate : t = accept in\n let module Fd = Fields_derivers_zkapps.Derivers in\n let full = deriver (Fd.o ()) in\n [%test_eq: t] predicate (predicate |> Fd.to_json full |> Fd.of_json full)\n\n let check\n (* Bind all the fields explicity so we make sure they are all used. *)\n ({ snarked_ledger_hash\n ; blockchain_length\n ; min_window_density\n ; total_currency\n ; global_slot_since_genesis\n ; staking_epoch_data\n ; next_epoch_data\n } :\n t ) (s : View.t) =\n let open Or_error.Let_syntax in\n let epoch_ledger ({ hash; total_currency } : _ Epoch_ledger.Poly.t)\n (t : Epoch_ledger.Value.t) =\n let%bind () =\n Hash.(check ~label:\"epoch_ledger_hash\" Tc.frozen_ledger_hash)\n hash t.hash\n in\n let%map () =\n Numeric.(check ~label:\"epoch_ledger_total_currency\" Tc.amount)\n total_currency t.total_currency\n in\n ()\n in\n let epoch_data label\n ({ ledger; seed; start_checkpoint; lock_checkpoint; epoch_length } :\n _ Epoch_data.Poly.t ) (t : _ Epoch_data.Poly.t) =\n let l s = sprintf \"%s_%s\" label s in\n let%bind () = epoch_ledger ledger t.ledger in\n ignore seed ;\n let%bind () =\n Hash.(check ~label:(l \"start_check_point\") Tc.state_hash)\n start_checkpoint t.start_checkpoint\n in\n let%bind () =\n Hash.(check ~label:(l \"lock_check_point\") Tc.state_hash)\n lock_checkpoint t.lock_checkpoint\n in\n let%map () =\n Numeric.(check ~label:\"epoch_length\" Tc.length)\n epoch_length t.epoch_length\n in\n ()\n in\n let%bind () =\n Hash.(check ~label:\"snarked_ledger_hash\" Tc.ledger_hash)\n snarked_ledger_hash s.snarked_ledger_hash\n in\n let%bind () =\n Numeric.(check ~label:\"blockchain_length\" Tc.length)\n blockchain_length s.blockchain_length\n in\n let%bind () =\n Numeric.(check ~label:\"min_window_density\" Tc.length)\n min_window_density s.min_window_density\n in\n (* TODO: Decide whether to expose this *)\n let%bind () =\n Numeric.(check ~label:\"total_currency\" Tc.amount)\n total_currency s.total_currency\n in\n let%bind () =\n Numeric.(check ~label:\"global_slot_since_genesis\" Tc.global_slot)\n global_slot_since_genesis s.global_slot_since_genesis\n in\n let%bind () =\n epoch_data \"staking_epoch_data\" staking_epoch_data s.staking_epoch_data\n in\n let%map () =\n epoch_data \"next_epoch_data\" next_epoch_data s.next_epoch_data\n in\n ()\nend\n\nmodule Valid_while = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Global_slot_since_genesis.Stable.V1.t Numeric.Stable.V1.t\n [@@deriving sexp, equal, yojson, hash, compare]\n\n let to_latest = Fn.id\n end\n end]\n\n let deriver = Numeric.Derivers.global_slot_since_genesis\n\n let gen =\n Numeric.gen Global_slot_since_genesis.gen Global_slot_since_genesis.compare\n\n let typ = Numeric.(typ Tc.global_slot)\n\n let to_input valid_while = Numeric.(to_input Tc.global_slot valid_while)\n\n let check (valid_while : t) global_slot =\n Numeric.(check ~label:\"valid_while_precondition\" Tc.global_slot)\n valid_while global_slot\n\n module Checked = struct\n type t = Global_slot_since_genesis.Checked.t Numeric.Checked.t\n\n let check (valid_while : t) global_slot =\n Numeric.(Checked.check Tc.global_slot) valid_while global_slot\n\n let to_input valid_while =\n Numeric.(Checked.to_input Tc.global_slot valid_while)\n end\nend\n\nmodule Account_type = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = User | Zkapp | None | Any\n [@@deriving sexp, equal, yojson, hash, compare]\n\n let to_latest = Fn.id\n end\n end]\n\n let check (t : t) (a : A.t option) =\n match (a, t) with\n | _, Any ->\n Ok ()\n | None, None ->\n Ok ()\n | None, _ ->\n Or_error.error_string \"expected account_type = None\"\n | Some a, User ->\n assert_ (Option.is_none a.zkapp) \"expected account_type = User\"\n | Some a, Zkapp ->\n assert_ (Option.is_some a.zkapp) \"expected account_type = Zkapp\"\n | Some _, None ->\n Or_error.error_string \"no second account allowed\"\n\n let to_bits = function\n | User ->\n [ true; false ]\n | Zkapp ->\n [ false; true ]\n | None ->\n [ false; false ]\n | Any ->\n [ true; true ]\n\n let of_bits = function\n | [ user; zkapp ] -> (\n match (user, zkapp) with\n | true, false ->\n User\n | false, true ->\n Zkapp\n | false, false ->\n None\n | true, true ->\n Any )\n | _ ->\n assert false\n\n let to_input x =\n let open Random_oracle_input.Chunked in\n Array.reduce_exn ~f:append\n (Array.of_list_map (to_bits x) ~f:(fun b -> packed (field_of_bool b, 1)))\n\n module Checked = struct\n type t = { user : Boolean.var; zkapp : Boolean.var } [@@deriving hlist]\n\n let to_input { user; zkapp } =\n let open Random_oracle_input.Chunked in\n Array.reduce_exn ~f:append\n (Array.map [| user; zkapp |] ~f:(fun b ->\n packed ((b :> Field.Var.t), 1) ) )\n\n let constant =\n let open Boolean in\n function\n | User ->\n { user = true_; zkapp = false_ }\n | Zkapp ->\n { user = false_; zkapp = true_ }\n | None ->\n { user = false_; zkapp = false_ }\n | Any ->\n { user = true_; zkapp = true_ }\n\n (* TODO: Write a unit test for these. *)\n let snapp_allowed t = t.zkapp\n\n let user_allowed t = t.user\n end\n\n let typ =\n let open Checked in\n Typ.of_hlistable\n [ Boolean.typ; Boolean.typ ]\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist\n ~value_to_hlist:(function\n | User ->\n [ true; false ]\n | Zkapp ->\n [ false; true ]\n | None ->\n [ false; false ]\n | Any ->\n [ true; true ] )\n ~value_of_hlist:(fun [ user; zkapp ] ->\n match (user, zkapp) with\n | true, false ->\n User\n | false, true ->\n Zkapp\n | false, false ->\n None\n | true, true ->\n Any )\nend\n\nmodule Other = struct\n module Poly = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type ('account, 'account_transition, 'vk) t =\n { predicate : 'account\n ; account_transition : 'account_transition\n ; account_vk : 'vk\n }\n [@@deriving hlist, sexp, equal, yojson, hash, compare]\n end\n end]\n end\n\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t =\n ( Account.Stable.V2.t\n , Account_state.Stable.V1.t Transition.Stable.V1.t\n , F.Stable.V1.t Hash.Stable.V1.t )\n Poly.Stable.V1.t\n [@@deriving sexp, equal, yojson, hash, compare]\n\n let to_latest = Fn.id\n end\n end]\n\n module Checked = struct\n type t =\n ( Account.Checked.t\n , Account_state.Checked.t Transition.t\n , Field.Var.t Or_ignore.Checked.t )\n Poly.Stable.Latest.t\n\n let to_input ({ predicate; account_transition; account_vk } : t) =\n let open Random_oracle_input.Chunked in\n List.reduce_exn ~f:append\n [ Account.Checked.to_input predicate\n ; Transition.to_input ~f:Account_state.Checked.to_input\n account_transition\n ; Hash.(to_input_checked Tc.field) account_vk\n ]\n end\n\n let to_input ({ predicate; account_transition; account_vk } : t) =\n let open Random_oracle_input.Chunked in\n List.reduce_exn ~f:append\n [ Account.to_input predicate\n ; Transition.to_input ~f:Account_state.to_input account_transition\n ; Hash.(to_input Tc.field) account_vk\n ]\n\n let typ () =\n let open Poly in\n Typ.of_hlistable\n [ Account.typ (); Transition.typ Account_state.typ; Hash.(typ Tc.field) ]\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist\n\n let accept : t =\n { predicate = Account.accept\n ; account_transition = { prev = Any; next = Any }\n ; account_vk = Ignore\n }\nend\n\nmodule Poly = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type ('account, 'protocol_state, 'other, 'pk) t =\n { self_predicate : 'account\n ; other : 'other\n ; fee_payer : 'pk\n ; protocol_state_predicate : 'protocol_state\n }\n [@@deriving hlist, sexp, equal, yojson, hash, compare]\n\n let to_latest = Fn.id\n end\n end]\n\n let typ spec =\n let open Stable.Latest in\n Typ.of_hlistable spec ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist\n ~value_to_hlist:to_hlist ~value_of_hlist:of_hlist\nend\n\n[%%versioned\nmodule Stable = struct\n module V2 = struct\n type t =\n ( Account.Stable.V2.t\n , Protocol_state.Stable.V1.t\n , Other.Stable.V2.t\n , Public_key.Compressed.Stable.V1.t Eq_data.Stable.V1.t )\n Poly.Stable.V1.t\n [@@deriving sexp, equal, yojson, hash, compare]\n\n let to_latest = Fn.id\n end\nend]\n\nmodule Digested = F\n\nlet to_input ({ self_predicate; other; fee_payer; protocol_state_predicate } : t)\n =\n let open Random_oracle_input.Chunked in\n List.reduce_exn ~f:append\n [ Account.to_input self_predicate\n ; Other.to_input other\n ; Eq_data.(to_input (Tc.public_key ())) fee_payer\n ; Protocol_state.to_input protocol_state_predicate\n ]\n\nlet digest t =\n Random_oracle.(\n hash ~init:Hash_prefix.zkapp_precondition (pack_input (to_input t)))\n\nlet accept : t =\n { self_predicate = Account.accept\n ; other = Other.accept\n ; fee_payer = Ignore\n ; protocol_state_predicate = Protocol_state.accept\n }\n\nmodule Checked = struct\n type t =\n ( Account.Checked.t\n , Protocol_state.Checked.t\n , Other.Checked.t\n , Public_key.Compressed.var Or_ignore.Checked.t )\n Poly.Stable.Latest.t\n\n let to_input\n ({ self_predicate; other; fee_payer; protocol_state_predicate } : t) =\n let open Random_oracle_input.Chunked in\n List.reduce_exn ~f:append\n [ Account.Checked.to_input self_predicate\n ; Other.Checked.to_input other\n ; Eq_data.(to_input_checked (Tc.public_key ())) fee_payer\n ; Protocol_state.Checked.to_input protocol_state_predicate\n ]\n\n let digest t =\n Random_oracle.Checked.(\n hash ~init:Hash_prefix.zkapp_precondition (pack_input (to_input t)))\nend\n\nlet typ () : (Checked.t, Stable.Latest.t) Typ.t =\n Poly.typ\n [ Account.typ ()\n ; Other.typ ()\n ; Eq_data.(typ (Tc.public_key ()))\n ; Protocol_state.typ\n ]\n","open Snark_params\nopen Tick\n\ntype 'a t = Field.Var.t * 'a As_prover.Ref.t\n\nlet hash (x, _) = x\n\nlet ref (_, x) = x\n\nlet typ ~hash =\n Typ.transport\n Typ.(Field.typ * Internal.ref ())\n ~there:(fun s -> (hash s, s))\n ~back:(fun (_, s) -> s)\n\nlet optional_typ ~hash ~non_preimage ~dummy_value =\n Typ.transport\n Typ.(Field.typ * Internal.ref ())\n ~there:(function\n | None -> (non_preimage, dummy_value) | Some s -> (hash s, s) )\n ~back:(fun (_, s) -> Some s)\n\nlet to_input (x, _) = Random_oracle_input.Chunked.field x\n\nlet if_ b ~then_ ~else_ =\n let open Run in\n let hash = Field.if_ b ~then_:(fst then_) ~else_:(fst else_) in\n let ref =\n As_prover.Ref.create\n As_prover.(\n fun () ->\n let ref = if read Boolean.typ b then snd then_ else snd else_ in\n As_prover.Ref.get ref)\n in\n (hash, ref)\n\nlet make_unsafe hash ref : 'a t = (hash, ref)\n\nmodule As_record = struct\n (* it's OK that hash is a Field.t (not a var), bc this is just annotation for the deriver *)\n type 'a t = { data : 'a; hash : Field.t } [@@deriving annot, fields]\nend\n\nlet deriver inner obj =\n let open Fields_derivers_zkapps in\n let ( !. ) = ( !. ) ~t_fields_annots:As_record.t_fields_annots in\n As_record.Fields.make_creator obj ~data:!.inner ~hash:!.field\n |> finish \"Events\" ~t_toplevel_annots:As_record.t_toplevel_annots\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Mina_base_util\n\n[%%ifdef consensus_mechanism]\n\nopen Snark_params.Tick\n\n[%%endif]\n\nopen Signature_lib\nmodule Impl = Pickles.Impls.Step\nopen Mina_numbers\nopen Currency\nopen Pickles_types\nmodule Digest = Random_oracle.Digest\n\nmodule type Type = sig\n type t\nend\n\nmodule Authorization_kind = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n (* TODO: yojson for Field.t in snarky (#12591) *)\n type t =\n Mina_wire_types.Mina_base.Account_update.Authorization_kind.V1.t =\n | Signature\n | Proof of\n (Field.t\n [@version_asserted]\n [@to_yojson fun t -> `String (Snark_params.Tick.Field.to_string t)]\n [@of_yojson\n function\n | `String s ->\n let field = Snark_params.Tick.Field.of_string s in\n let s' = Snark_params.Tick.Field.to_string field in\n if String.equal s s' then Ok field\n else Error \"Invalid JSON for field\"\n | _ ->\n Error \"expected JSON string\"] )\n | None_given\n [@@deriving sexp, equal, yojson, hash, compare]\n\n let to_latest = Fn.id\n end\n end]\n\n module Structured = struct\n type t =\n { is_signed : bool\n ; is_proved : bool\n ; verification_key_hash : Snark_params.Tick.Field.t\n }\n [@@deriving hlist, annot, fields]\n\n let to_input ({ is_signed; is_proved; verification_key_hash } : t) =\n let f x = if x then Field.one else Field.zero in\n Random_oracle_input.Chunked.append\n (Random_oracle_input.Chunked.packeds\n [| (f is_signed, 1); (f is_proved, 1) |] )\n (Random_oracle_input.Chunked.field verification_key_hash)\n\n [%%ifdef consensus_mechanism]\n\n module Checked = struct\n type t =\n { is_signed : Boolean.var\n ; is_proved : Boolean.var\n ; verification_key_hash : Snark_params.Tick.Field.Var.t\n }\n [@@deriving hlist]\n\n let to_input { is_signed; is_proved; verification_key_hash } =\n let f (x : Boolean.var) = (x :> Field.Var.t) in\n Random_oracle_input.Chunked.append\n (Random_oracle_input.Chunked.packeds\n [| (f is_signed, 1); (f is_proved, 1) |] )\n (Random_oracle_input.Chunked.field verification_key_hash)\n end\n\n let typ =\n Typ.of_hlistable ~var_to_hlist:Checked.to_hlist\n ~var_of_hlist:Checked.of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist\n [ Boolean.typ; Boolean.typ; Field.typ ]\n\n let deriver obj =\n let open Fields_derivers_zkapps in\n let open Fields in\n let ( !. ) = ( !. ) ~t_fields_annots in\n let verification_key_hash =\n needs_custom_js ~js_type:field ~name:\"VerificationKeyHash\" field\n in\n Fields.make_creator obj ~is_signed:!.bool ~is_proved:!.bool\n ~verification_key_hash:!.verification_key_hash\n |> finish \"AuthorizationKindStructured\" ~t_toplevel_annots\n\n [%%endif]\n end\n\n let to_control_tag : t -> Control.Tag.t = function\n | None_given ->\n None_given\n | Signature ->\n Signature\n | Proof _ ->\n Proof\n\n let to_structured : t -> Structured.t = function\n | None_given ->\n { is_signed = false\n ; is_proved = false\n ; verification_key_hash = Zkapp_account.dummy_vk_hash ()\n }\n | Signature ->\n { is_signed = true\n ; is_proved = false\n ; verification_key_hash = Zkapp_account.dummy_vk_hash ()\n }\n | Proof verification_key_hash ->\n { is_signed = false; is_proved = true; verification_key_hash }\n\n let of_structured_exn : Structured.t -> t = function\n | { is_signed = false; is_proved = false; _ } ->\n None_given\n | { is_signed = true; is_proved = false; _ } ->\n Signature\n | { is_signed = false; is_proved = true; verification_key_hash } ->\n Proof verification_key_hash\n | { is_signed = true; is_proved = true; _ } ->\n failwith \"Invalid authorization kind\"\n\n let gen =\n let%bind.Quickcheck vk_hash = Field.gen in\n Quickcheck.Generator.of_list [ None_given; Signature; Proof vk_hash ]\n\n let deriver obj =\n let open Fields_derivers_zkapps in\n iso_record ~to_record:to_structured ~of_record:of_structured_exn\n Structured.deriver obj\n\n let to_input x = Structured.to_input (to_structured x)\n\n [%%ifdef consensus_mechanism]\n\n module Checked = Structured.Checked\n\n let typ =\n Structured.typ |> Typ.transport ~there:to_structured ~back:of_structured_exn\n\n [%%endif]\nend\n\nmodule May_use_token = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Mina_wire_types.Mina_base.Account_update.May_use_token.V1.t =\n | No\n (** No permission to use any token other than the default Mina\n token.\n *)\n | Parents_own_token\n (** Has permission to use the token owned by the direct parent of\n this account update, which may be inherited by child account\n updates.\n *)\n | Inherit_from_parent\n (** Inherit the token permission available to the parent. *)\n [@@deriving sexp, equal, yojson, hash, compare]\n\n let to_latest = Fn.id\n end\n end]\n\n let gen =\n Quickcheck.Generator.of_list [ No; Parents_own_token; Inherit_from_parent ]\n\n let to_string = function\n | No ->\n \"No\"\n | Parents_own_token ->\n \"ParentsOwnToken\"\n | Inherit_from_parent ->\n \"InheritFromParent\"\n\n let of_string = function\n | \"No\" ->\n No\n | \"ParentsOwnToken\" ->\n Parents_own_token\n | \"InheritFromParent\" ->\n Inherit_from_parent\n | s ->\n failwithf \"Invalid call type: %s\" s ()\n\n let parents_own_token = function Parents_own_token -> true | _ -> false\n\n let inherit_from_parent = function Inherit_from_parent -> true | _ -> false\n\n module As_record : sig\n type variant = t\n\n type 'bool t\n\n val parents_own_token : 'bool t -> 'bool\n\n val inherit_from_parent : 'bool t -> 'bool\n\n val map : f:('a -> 'b) -> 'a t -> 'b t\n\n val to_hlist : 'bool t -> (unit, 'bool -> 'bool -> unit) H_list.t\n\n val of_hlist : (unit, 'bool -> 'bool -> unit) H_list.t -> 'bool t\n\n val to_input :\n field_of_bool:('a -> 'b) -> 'a t -> 'b Random_oracle_input.Chunked.t\n\n val typ : (Snark_params.Tick.Boolean.var t, bool t) Snark_params.Tick.Typ.t\n\n val equal :\n and_:('bool -> 'bool -> 'bool)\n -> equal:('a -> 'a -> 'bool)\n -> 'a t\n -> 'a t\n -> 'bool\n\n val to_variant : bool t -> variant\n\n val of_variant : variant -> bool t\n\n (* TODO: Create an alias for this type *)\n val deriver :\n ( bool t\n , ( ( ( bool t\n , ( bool t\n , ( bool t\n , ( ( bool t\n , ( bool t\n , ( bool t\n , ( (< contramap : (bool t -> bool t) Core_kernel.ref\n ; graphql_arg :\n ( unit\n -> bool t\n Fields_derivers_graphql.Schema.Arg\n .arg_typ )\n Core_kernel.ref\n ; graphql_arg_accumulator :\n bool t\n Fields_derivers_zkapps.Derivers.Graphql.Args\n .Acc\n .T\n .t\n Core_kernel.ref\n ; graphql_creator :\n ( ( ( 'a\n , bool t\n , bool t\n , 'b )\n Fields_derivers_zkapps.Derivers\n .Graphql\n .Args\n .Output\n .t\n , bool t\n , bool t\n , 'b )\n Fields_derivers_zkapps.Derivers.Graphql\n .Args\n .Input\n .t\n -> bool t )\n Core_kernel.ref\n ; graphql_fields :\n bool t\n Fields_derivers_zkapps.Derivers.Graphql\n .Fields\n .Input\n .T\n .t\n Core_kernel.ref\n ; graphql_fields_accumulator :\n bool t\n Fields_derivers_zkapps.Derivers.Graphql\n .Fields\n .Accumulator\n .T\n .t\n list\n Core_kernel.ref\n ; graphql_query : string option Core_kernel.ref\n ; graphql_query_accumulator :\n (Core_kernel.String.t * string option)\n option\n list\n Core_kernel.ref\n ; js_layout :\n [> `Assoc of (string * Yojson.Safe.t) list ]\n Core_kernel.ref\n ; js_layout_accumulator :\n Fields_derivers_zkapps__.Fields_derivers_js\n .Js_layout\n .Accumulator\n .field\n option\n list\n Core_kernel.ref\n ; map : (bool t -> bool t) Core_kernel.ref\n ; nullable_graphql_arg :\n ( unit\n -> 'b\n Fields_derivers_graphql.Schema.Arg\n .arg_typ )\n Core_kernel.ref\n ; nullable_graphql_fields :\n bool t option\n Fields_derivers_zkapps.Derivers.Graphql\n .Fields\n .Input\n .T\n .t\n Core_kernel.ref\n ; of_json :\n (Yojson.Safe.t -> bool t) Core_kernel.ref\n ; of_json_creator :\n Yojson.Safe.t Core_kernel.String.Map.t\n Core_kernel.ref\n ; skip : bool Core_kernel.ref\n ; to_json :\n (bool t -> Yojson.Safe.t) Core_kernel.ref\n ; to_json_accumulator :\n ( Core_kernel.String.t\n * (bool t -> Yojson.Safe.t) )\n option\n list\n Core_kernel.ref\n ; .. >\n as\n 'a )\n Fields_derivers_zkapps__.Fields_derivers_js\n .Js_layout\n .Input\n .t\n Fields_derivers_graphql.Graphql_query.Input.t\n , bool t\n , bool t\n , 'b )\n Fields_derivers_zkapps.Derivers.Graphql.Args.Input\n .t\n , bool t\n , bool t option )\n Fields_derivers_zkapps.Derivers.Graphql.Fields.Input\n .t\n , bool t )\n Fields_derivers_json.Of_yojson.Input.t\n , bool t )\n Fields_derivers_json.To_yojson.Input.t\n Fields_derivers_zkapps.Unified_input.t\n Fields_derivers_zkapps__.Fields_derivers_js.Js_layout\n .Input\n .t\n Fields_derivers_graphql.Graphql_query.Input.t\n , bool t\n , bool t\n , 'b )\n Fields_derivers_zkapps.Derivers.Graphql.Args.Input.t\n , bool t\n , bool t option )\n Fields_derivers_zkapps.Derivers.Graphql.Fields.Input.t\n , bool t )\n Fields_derivers_json.Of_yojson.Input.t\n , bool t )\n Fields_derivers_json.To_yojson.Input.t\n Fields_derivers_zkapps.Unified_input.t\n , bool t\n , bool t\n , 'b )\n Fields_derivers_zkapps.Derivers.Graphql.Args.Input.t\n , bool t\n , bool t\n , 'b )\n Fields_derivers_zkapps.Derivers.Graphql.Args.Acc.t\n , bool t\n , bool t option )\n Fields_derivers_zkapps.Derivers.Graphql.Fields.Accumulator.t\n -> ( bool t\n , ( bool t\n , ( bool t\n , ( 'a Fields_derivers_zkapps__.Fields_derivers_js.Js_layout.Input.t\n Fields_derivers_graphql.Graphql_query.Input.t\n , bool t\n , bool t\n , 'b )\n Fields_derivers_zkapps.Derivers.Graphql.Args.Input.t\n , bool t\n , bool t option )\n Fields_derivers_zkapps.Derivers.Graphql.Fields.Input.t\n , bool t )\n Fields_derivers_json.Of_yojson.Input.t\n , bool t )\n Fields_derivers_json.To_yojson.Input.t\n Fields_derivers_zkapps.Unified_input.t\n end = struct\n type variant = t\n\n type 'bool t =\n { (* NB: call is implicit. *)\n parents_own_token : 'bool\n ; inherit_from_parent : 'bool\n }\n [@@deriving annot, hlist, fields]\n\n let map ~f { parents_own_token; inherit_from_parent } =\n { parents_own_token = f parents_own_token\n ; inherit_from_parent = f inherit_from_parent\n }\n\n let typ : _ Typ.t =\n let open Snark_params.Tick in\n let (Typ typ) =\n Typ.of_hlistable\n [ Boolean.typ; Boolean.typ ]\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist\n in\n Typ\n { typ with\n check =\n (fun ({ parents_own_token; inherit_from_parent } as x) ->\n let open Checked in\n let%bind () = typ.check x in\n let sum =\n Field.Var.(\n add (parents_own_token :> t) (inherit_from_parent :> t))\n in\n (* Assert boolean; we should really have a helper for this\n somewhere.\n *)\n let%bind sum_squared = Field.Checked.mul sum sum in\n Field.Checked.Assert.equal sum sum_squared )\n }\n\n let to_input ~field_of_bool { parents_own_token; inherit_from_parent } =\n Array.reduce_exn ~f:Random_oracle_input.Chunked.append\n [| Random_oracle_input.Chunked.packed\n (field_of_bool parents_own_token, 1)\n ; Random_oracle_input.Chunked.packed\n (field_of_bool inherit_from_parent, 1)\n |]\n\n let equal ~and_ ~equal\n { parents_own_token = parents_own_token1\n ; inherit_from_parent = inherit_from_parent1\n }\n { parents_own_token = parents_own_token2\n ; inherit_from_parent = inherit_from_parent2\n } =\n and_\n (equal parents_own_token1 parents_own_token2)\n (equal inherit_from_parent1 inherit_from_parent2)\n\n let to_variant = function\n | { parents_own_token = false; inherit_from_parent = false } ->\n No\n | { parents_own_token = true; inherit_from_parent = false } ->\n Parents_own_token\n | { parents_own_token = false; inherit_from_parent = true } ->\n Inherit_from_parent\n | _ ->\n failwith \"May_use_token.to_variant: More than one boolean flag is set\"\n\n let of_variant = function\n | No ->\n { parents_own_token = false; inherit_from_parent = false }\n | Parents_own_token ->\n { parents_own_token = true; inherit_from_parent = false }\n | Inherit_from_parent ->\n { parents_own_token = false; inherit_from_parent = true }\n\n let deriver obj : _ Fields_derivers_zkapps.Unified_input.t =\n let open Fields_derivers_zkapps.Derivers in\n let ( !. ) = ( !. ) ~t_fields_annots in\n Fields.make_creator obj ~parents_own_token:!.bool\n ~inherit_from_parent:!.bool\n |> finish \"MayUseToken\" ~t_toplevel_annots\n end\n\n let quickcheck_generator = gen\n\n let deriver obj =\n let open Fields_derivers_zkapps in\n iso_record ~of_record:As_record.to_variant ~to_record:As_record.of_variant\n As_record.deriver obj\n\n module Checked = struct\n type t = Boolean.var As_record.t\n\n let parents_own_token = As_record.parents_own_token\n\n let inherit_from_parent = As_record.inherit_from_parent\n\n let constant x =\n As_record.map ~f:Boolean.var_of_value @@ As_record.of_variant x\n\n let to_input (x : t) =\n As_record.to_input\n ~field_of_bool:(fun (x : Boolean.var) -> (x :> Field.Var.t))\n x\n\n let equal x y =\n As_record.equal ~equal:Run.Boolean.equal ~and_:Run.Boolean.( &&& ) x y\n\n let assert_equal x y =\n As_record.equal ~equal:Run.Boolean.Assert.( = ) ~and_:(fun _ _ -> ()) x y\n end\n\n let to_input x = As_record.to_input ~field_of_bool (As_record.of_variant x)\n\n let typ : (Checked.t, t) Typ.t =\n As_record.typ\n |> Typ.transport ~there:As_record.of_variant ~back:As_record.to_variant\nend\n\nmodule Update = struct\n module Timing_info = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t =\n Mina_wire_types.Mina_base.Account_update.Update.Timing_info.V1.t =\n { initial_minimum_balance : Balance.Stable.V1.t\n ; cliff_time : Global_slot_since_genesis.Stable.V1.t\n ; cliff_amount : Amount.Stable.V1.t\n ; vesting_period : Global_slot_span.Stable.V1.t\n ; vesting_increment : Amount.Stable.V1.t\n }\n [@@deriving annot, compare, equal, sexp, hash, yojson, hlist, fields]\n\n let to_latest = Fn.id\n end\n end]\n\n type value = t\n\n let gen =\n let open Quickcheck.Let_syntax in\n let%bind initial_minimum_balance = Balance.gen in\n let%bind cliff_time = Global_slot_since_genesis.gen in\n let%bind cliff_amount =\n Amount.gen_incl Amount.zero (Balance.to_amount initial_minimum_balance)\n in\n let%bind vesting_period =\n Global_slot_span.gen_incl\n Global_slot_span.(succ zero)\n (Global_slot_span.of_int 10)\n in\n let%map vesting_increment =\n Amount.gen_incl Amount.one (Amount.of_nanomina_int_exn 100)\n in\n { initial_minimum_balance\n ; cliff_time\n ; cliff_amount\n ; vesting_period\n ; vesting_increment\n }\n\n let to_input (t : t) =\n List.reduce_exn ~f:Random_oracle_input.Chunked.append\n [ Balance.to_input t.initial_minimum_balance\n ; Global_slot_since_genesis.to_input t.cliff_time\n ; Amount.to_input t.cliff_amount\n ; Global_slot_span.to_input t.vesting_period\n ; Amount.to_input t.vesting_increment\n ]\n\n let dummy =\n let slot_unused = Global_slot_since_genesis.zero in\n let slot_span_unused = Global_slot_span.zero in\n let balance_unused = Balance.zero in\n let amount_unused = Amount.zero in\n { initial_minimum_balance = balance_unused\n ; cliff_time = slot_unused\n ; cliff_amount = amount_unused\n ; vesting_period = slot_span_unused\n ; vesting_increment = amount_unused\n }\n\n let to_account_timing (t : t) : Account_timing.t =\n Timed\n { initial_minimum_balance = t.initial_minimum_balance\n ; cliff_time = t.cliff_time\n ; cliff_amount = t.cliff_amount\n ; vesting_period = t.vesting_period\n ; vesting_increment = t.vesting_increment\n }\n\n let of_account_timing (t : Account_timing.t) : t option =\n match t with\n | Untimed ->\n None\n | Timed t ->\n Some\n { initial_minimum_balance = t.initial_minimum_balance\n ; cliff_time = t.cliff_time\n ; cliff_amount = t.cliff_amount\n ; vesting_period = t.vesting_period\n ; vesting_increment = t.vesting_increment\n }\n\n module Checked = struct\n type t =\n { initial_minimum_balance : Balance.Checked.t\n ; cliff_time : Global_slot_since_genesis.Checked.t\n ; cliff_amount : Amount.Checked.t\n ; vesting_period : Global_slot_span.Checked.t\n ; vesting_increment : Amount.Checked.t\n }\n [@@deriving hlist]\n\n let constant (t : value) : t =\n { initial_minimum_balance = Balance.var_of_t t.initial_minimum_balance\n ; cliff_time = Global_slot_since_genesis.Checked.constant t.cliff_time\n ; cliff_amount = Amount.var_of_t t.cliff_amount\n ; vesting_period = Global_slot_span.Checked.constant t.vesting_period\n ; vesting_increment = Amount.var_of_t t.vesting_increment\n }\n\n let to_input\n ({ initial_minimum_balance\n ; cliff_time\n ; cliff_amount\n ; vesting_period\n ; vesting_increment\n } :\n t ) =\n List.reduce_exn ~f:Random_oracle_input.Chunked.append\n [ Balance.var_to_input initial_minimum_balance\n ; Global_slot_since_genesis.Checked.to_input cliff_time\n ; Amount.var_to_input cliff_amount\n ; Global_slot_span.Checked.to_input vesting_period\n ; Amount.var_to_input vesting_increment\n ]\n\n let to_account_timing (t : t) : Account_timing.var =\n { is_timed = Boolean.true_\n ; initial_minimum_balance = t.initial_minimum_balance\n ; cliff_time = t.cliff_time\n ; cliff_amount = t.cliff_amount\n ; vesting_period = t.vesting_period\n ; vesting_increment = t.vesting_increment\n }\n\n let of_account_timing (t : Account_timing.var) : t =\n { initial_minimum_balance = t.initial_minimum_balance\n ; cliff_time = t.cliff_time\n ; cliff_amount = t.cliff_amount\n ; vesting_period = t.vesting_period\n ; vesting_increment = t.vesting_increment\n }\n end\n\n let typ : (Checked.t, t) Typ.t =\n Typ.of_hlistable\n [ Balance.typ\n ; Global_slot_since_genesis.typ\n ; Amount.typ\n ; Global_slot_span.typ\n ; Amount.typ\n ]\n ~var_to_hlist:Checked.to_hlist ~var_of_hlist:Checked.of_hlist\n ~value_to_hlist:to_hlist ~value_of_hlist:of_hlist\n\n let deriver obj =\n let open Fields_derivers_zkapps.Derivers in\n let ( !. ) = ( !. ) ~t_fields_annots in\n Fields.make_creator obj ~initial_minimum_balance:!.balance\n ~cliff_time:!.global_slot_since_genesis\n ~cliff_amount:!.amount ~vesting_period:!.global_slot_span\n ~vesting_increment:!.amount\n |> finish \"Timing\" ~t_toplevel_annots\n end\n\n open Zkapp_basic\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n (* TODO: Have to check that the public key is not = Public_key.Compressed.empty here. *)\n type t = Mina_wire_types.Mina_base.Account_update.Update.V1.t =\n { app_state :\n F.Stable.V1.t Set_or_keep.Stable.V1.t Zkapp_state.V.Stable.V1.t\n ; delegate : Public_key.Compressed.Stable.V1.t Set_or_keep.Stable.V1.t\n ; verification_key :\n Verification_key_wire.Stable.V1.t Set_or_keep.Stable.V1.t\n ; permissions : Permissions.Stable.V2.t Set_or_keep.Stable.V1.t\n ; zkapp_uri : string Set_or_keep.Stable.V1.t\n ; token_symbol :\n Account.Token_symbol.Stable.V1.t Set_or_keep.Stable.V1.t\n ; timing : Timing_info.Stable.V1.t Set_or_keep.Stable.V1.t\n ; voting_for : State_hash.Stable.V1.t Set_or_keep.Stable.V1.t\n }\n [@@deriving annot, compare, equal, sexp, hash, yojson, fields, hlist]\n\n let to_latest = Fn.id\n end\n end]\n\n let gen ?(token_account = false) ?(zkapp_account = false) ?vk\n ?permissions_auth () : t Quickcheck.Generator.t =\n let open Quickcheck.Let_syntax in\n let%bind app_state =\n let%bind fields =\n let field_gen = Snark_params.Tick.Field.gen in\n Quickcheck.Generator.list_with_length 8 (Set_or_keep.gen field_gen)\n in\n (* won't raise because length is correct *)\n Quickcheck.Generator.return (Zkapp_state.V.of_list_exn fields)\n in\n let%bind delegate =\n if not token_account then Set_or_keep.gen Public_key.Compressed.gen\n else return Set_or_keep.Keep\n in\n let%bind verification_key =\n if zkapp_account then\n Set_or_keep.gen\n (Quickcheck.Generator.return\n ( match vk with\n | None ->\n let data = Pickles.Side_loaded.Verification_key.dummy in\n let hash = Zkapp_account.digest_vk data in\n { With_hash.data; hash }\n | Some vk ->\n vk ) )\n else return Set_or_keep.Keep\n in\n let%bind permissions =\n match permissions_auth with\n | None ->\n return Set_or_keep.Keep\n | Some auth_tag ->\n let%map permissions = Permissions.gen ~auth_tag in\n Set_or_keep.Set permissions\n in\n let%bind zkapp_uri =\n let uri_gen =\n Quickcheck.Generator.of_list\n [ \"https://www.example.com\"\n ; \"https://www.minaprotocol.com\"\n ; \"https://www.gurgle.com\"\n ; \"https://faceplant.com\"\n ]\n in\n Set_or_keep.gen uri_gen\n in\n let%bind token_symbol =\n let token_gen =\n Quickcheck.Generator.of_list\n [ \"MINA\"; \"TOKEN1\"; \"TOKEN2\"; \"TOKEN3\"; \"TOKEN4\"; \"TOKEN5\" ]\n in\n Set_or_keep.gen token_gen\n in\n let%bind voting_for = Set_or_keep.gen Field.gen in\n (* a new account for the Account_update.t is in the ledger when we use\n this generated update in tests, so the timing must be Keep\n *)\n let timing = Set_or_keep.Keep in\n return\n ( { app_state\n ; delegate\n ; verification_key\n ; permissions\n ; zkapp_uri\n ; token_symbol\n ; timing\n ; voting_for\n }\n : t )\n\n module Checked = struct\n open Pickles.Impls.Step\n\n type t =\n { app_state : Field.t Set_or_keep.Checked.t Zkapp_state.V.t\n ; delegate : Public_key.Compressed.var Set_or_keep.Checked.t\n ; verification_key :\n ( Boolean.var\n , ( Side_loaded_verification_key.t option\n , Field.Constant.t )\n With_hash.t\n Data_as_hash.t )\n Zkapp_basic.Flagged_option.t\n Set_or_keep.Checked.t\n ; permissions : Permissions.Checked.t Set_or_keep.Checked.t\n ; zkapp_uri : string Data_as_hash.t Set_or_keep.Checked.t\n ; token_symbol : Account.Token_symbol.var Set_or_keep.Checked.t\n ; timing : Timing_info.Checked.t Set_or_keep.Checked.t\n ; voting_for : State_hash.var Set_or_keep.Checked.t\n }\n [@@deriving hlist]\n\n let to_input\n ({ app_state\n ; delegate\n ; verification_key\n ; permissions\n ; zkapp_uri\n ; token_symbol\n ; timing\n ; voting_for\n } :\n t ) =\n let open Random_oracle_input.Chunked in\n List.reduce_exn ~f:append\n [ Zkapp_state.to_input app_state\n ~f:(Set_or_keep.Checked.to_input ~f:field)\n ; Set_or_keep.Checked.to_input delegate\n ~f:Public_key.Compressed.Checked.to_input\n ; Set_or_keep.Checked.to_input verification_key ~f:(fun x ->\n field (Data_as_hash.hash x.data) )\n ; Set_or_keep.Checked.to_input permissions\n ~f:Permissions.Checked.to_input\n ; Set_or_keep.Checked.to_input zkapp_uri ~f:Data_as_hash.to_input\n ; Set_or_keep.Checked.to_input token_symbol\n ~f:Account.Token_symbol.var_to_input\n ; Set_or_keep.Checked.to_input timing ~f:Timing_info.Checked.to_input\n ; Set_or_keep.Checked.to_input voting_for ~f:State_hash.var_to_input\n ]\n end\n\n let noop : t =\n { app_state =\n Vector.init Zkapp_state.Max_state_size.n ~f:(fun _ -> Set_or_keep.Keep)\n ; delegate = Keep\n ; verification_key = Keep\n ; permissions = Keep\n ; zkapp_uri = Keep\n ; token_symbol = Keep\n ; timing = Keep\n ; voting_for = Keep\n }\n\n let dummy = noop\n\n let to_input\n ({ app_state\n ; delegate\n ; verification_key\n ; permissions\n ; zkapp_uri\n ; token_symbol\n ; timing\n ; voting_for\n } :\n t ) =\n let open Random_oracle_input.Chunked in\n List.reduce_exn ~f:append\n [ Zkapp_state.to_input app_state\n ~f:(Set_or_keep.to_input ~dummy:Field.zero ~f:field)\n ; Set_or_keep.to_input delegate\n ~dummy:(Zkapp_precondition.Eq_data.Tc.public_key ()).default\n ~f:Public_key.Compressed.to_input\n ; Set_or_keep.to_input\n (Set_or_keep.map verification_key ~f:With_hash.hash)\n ~dummy:Field.zero ~f:field\n ; Set_or_keep.to_input permissions ~dummy:Permissions.empty\n ~f:Permissions.to_input\n ; Set_or_keep.to_input\n (Set_or_keep.map ~f:Zkapp_account.hash_zkapp_uri zkapp_uri)\n ~dummy:(Zkapp_account.hash_zkapp_uri_opt None)\n ~f:field\n ; Set_or_keep.to_input token_symbol ~dummy:Account.Token_symbol.default\n ~f:Account.Token_symbol.to_input\n ; Set_or_keep.to_input timing ~dummy:Timing_info.dummy\n ~f:Timing_info.to_input\n ; Set_or_keep.to_input voting_for ~dummy:State_hash.dummy\n ~f:State_hash.to_input\n ]\n\n let typ () : (Checked.t, t) Typ.t =\n let open Pickles.Impls.Step in\n Typ.of_hlistable\n [ Zkapp_state.typ (Set_or_keep.typ ~dummy:Field.Constant.zero Field.typ)\n ; Set_or_keep.typ ~dummy:Public_key.Compressed.empty\n Public_key.Compressed.typ\n ; Set_or_keep.optional_typ\n (Data_as_hash.typ ~hash:With_hash.hash)\n ~to_option:(function\n | { With_hash.data = Some data; hash } ->\n Some { With_hash.data; hash }\n | { With_hash.data = None; _ } ->\n None )\n ~of_option:(function\n | Some { With_hash.data; hash } ->\n { With_hash.data = Some data; hash }\n | None ->\n { With_hash.data = None; hash = Field.Constant.zero } )\n |> Typ.transport_var\n ~there:\n (Set_or_keep.Checked.map\n ~f:(fun { Zkapp_basic.Flagged_option.data; _ } -> data) )\n ~back:(fun x ->\n Set_or_keep.Checked.map x ~f:(fun data ->\n { Zkapp_basic.Flagged_option.data\n ; is_some = Set_or_keep.Checked.is_set x\n } ) )\n ; Set_or_keep.typ ~dummy:Permissions.empty Permissions.typ\n ; Set_or_keep.optional_typ\n (Data_as_hash.optional_typ ~hash:Zkapp_account.hash_zkapp_uri\n ~non_preimage:(Zkapp_account.hash_zkapp_uri_opt None)\n ~dummy_value:\"\" )\n ~to_option:Fn.id ~of_option:Fn.id\n ; Set_or_keep.typ ~dummy:Account.Token_symbol.default\n Account.Token_symbol.typ\n ; Set_or_keep.typ ~dummy:Timing_info.dummy Timing_info.typ\n ; Set_or_keep.typ ~dummy:State_hash.dummy State_hash.typ\n ]\n ~var_to_hlist:Checked.to_hlist ~var_of_hlist:Checked.of_hlist\n ~value_to_hlist:to_hlist ~value_of_hlist:of_hlist\n\n let deriver obj =\n let open Fields_derivers_zkapps in\n let ( !. ) = ( !. ) ~t_fields_annots in\n let zkapp_uri =\n needs_custom_js\n ~js_type:(Data_as_hash.deriver string)\n ~name:\"ZkappUri\" string\n in\n let token_symbol =\n needs_custom_js\n ~js_type:\n (js_record\n [ (\"symbol\", js_layout string); (\"field\", js_layout field) ] )\n ~name:\"TokenSymbol\" string\n in\n finish \"AccountUpdateModification\" ~t_toplevel_annots\n @@ Fields.make_creator\n ~app_state:!.(Zkapp_state.deriver @@ Set_or_keep.deriver field)\n ~delegate:!.(Set_or_keep.deriver public_key)\n ~verification_key:!.(Set_or_keep.deriver verification_key_with_hash)\n ~permissions:!.(Set_or_keep.deriver Permissions.deriver)\n ~zkapp_uri:!.(Set_or_keep.deriver zkapp_uri)\n ~token_symbol:!.(Set_or_keep.deriver token_symbol)\n ~timing:!.(Set_or_keep.deriver Timing_info.deriver)\n ~voting_for:!.(Set_or_keep.deriver State_hash.deriver)\n obj\nend\n\nmodule Events = Zkapp_account.Events\nmodule Actions = Zkapp_account.Actions\n\nmodule Account_precondition = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t =\n Mina_wire_types.Mina_base.Account_update.Account_precondition.V1.t =\n | Full of Zkapp_precondition.Account.Stable.V2.t\n | Nonce of Account.Nonce.Stable.V1.t\n | Accept\n [@@deriving sexp, yojson, hash]\n\n let to_latest = Fn.id\n\n let to_full = function\n | Full s ->\n s\n | Nonce n ->\n { Zkapp_precondition.Account.accept with\n nonce = Check { lower = n; upper = n }\n }\n | Accept ->\n Zkapp_precondition.Account.accept\n\n let equal p q = Zkapp_precondition.Account.equal (to_full p) (to_full q)\n\n let compare p q =\n Zkapp_precondition.Account.compare (to_full p) (to_full q)\n end\n end]\n\n [%%define_locally Stable.Latest.(to_full, equal, compare)]\n\n let gen : t Quickcheck.Generator.t =\n Quickcheck.Generator.variant3 Zkapp_precondition.Account.gen\n Account.Nonce.gen Unit.quickcheck_generator\n |> Quickcheck.Generator.map ~f:(function\n | `A x ->\n Full x\n | `B x ->\n Nonce x\n | `C () ->\n Accept )\n\n let of_full (p : Zkapp_precondition.Account.t) =\n let module A = Zkapp_precondition.Account in\n if A.equal p A.accept then Accept\n else\n match p.nonce with\n | Ignore ->\n Full p\n | Check { lower; upper } as n ->\n if\n A.equal p { A.accept with nonce = n }\n && Account.Nonce.equal lower upper\n then Nonce lower\n else Full p\n\n module Tag = struct\n type t = Full | Nonce | Accept [@@deriving equal, compare, sexp, yojson]\n end\n\n let tag : t -> Tag.t = function\n | Full _ ->\n Full\n | Nonce _ ->\n Nonce\n | Accept ->\n Accept\n\n let deriver obj =\n let open Fields_derivers_zkapps.Derivers in\n iso_record ~of_record:of_full ~to_record:to_full\n Zkapp_precondition.Account.deriver obj\n\n let digest (t : t) =\n let digest x =\n Random_oracle.(\n hash ~init:Hash_prefix_states.account_update_account_precondition\n (pack_input x))\n in\n to_full t |> Zkapp_precondition.Account.to_input |> digest\n\n module Checked = struct\n type t = Zkapp_precondition.Account.Checked.t\n\n let digest (t : t) =\n let digest x =\n Random_oracle.Checked.(\n hash ~init:Hash_prefix_states.account_update_account_precondition\n (pack_input x))\n in\n Zkapp_precondition.Account.Checked.to_input t |> digest\n\n let nonce (t : t) = t.nonce\n end\n\n let typ () : (Zkapp_precondition.Account.Checked.t, t) Typ.t =\n Typ.transport (Zkapp_precondition.Account.typ ()) ~there:to_full\n ~back:(fun s -> Full s)\n\n let nonce = function\n | Full { nonce; _ } ->\n nonce\n | Nonce nonce ->\n Check { lower = nonce; upper = nonce }\n | Accept ->\n Ignore\nend\n\nmodule Preconditions = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Mina_wire_types.Mina_base.Account_update.Preconditions.V1.t =\n { network : Zkapp_precondition.Protocol_state.Stable.V1.t\n ; account : Account_precondition.Stable.V1.t\n ; valid_while :\n Mina_numbers.Global_slot_since_genesis.Stable.V1.t\n Zkapp_precondition.Numeric.Stable.V1.t\n }\n [@@deriving annot, sexp, equal, yojson, hash, hlist, compare, fields]\n\n let to_latest = Fn.id\n end\n end]\n\n let deriver obj =\n let open Fields_derivers_zkapps.Derivers in\n let ( !. ) = ( !. ) ~t_fields_annots in\n Fields.make_creator obj\n ~network:!.Zkapp_precondition.Protocol_state.deriver\n ~account:!.Account_precondition.deriver\n ~valid_while:!.Zkapp_precondition.Valid_while.deriver\n |> finish \"Preconditions\" ~t_toplevel_annots\n\n let to_input ({ network; account; valid_while } : t) =\n List.reduce_exn ~f:Random_oracle_input.Chunked.append\n [ Zkapp_precondition.Protocol_state.to_input network\n ; Zkapp_precondition.Account.to_input\n (Account_precondition.to_full account)\n ; Zkapp_precondition.Valid_while.to_input valid_while\n ]\n\n let gen =\n let open Quickcheck.Generator.Let_syntax in\n let%map network = Zkapp_precondition.Protocol_state.gen\n and account = Account_precondition.gen\n and valid_while = Zkapp_precondition.Valid_while.gen in\n { network; account; valid_while }\n\n module Checked = struct\n module Type_of_var (V : sig\n type var\n end) =\n struct\n type t = V.var\n end\n\n module Int_as_prover_ref = struct\n type t = int As_prover.Ref.t\n end\n\n type t =\n { network : Zkapp_precondition.Protocol_state.Checked.t\n ; account : Account_precondition.Checked.t\n ; valid_while : Zkapp_precondition.Valid_while.Checked.t\n }\n [@@deriving annot, hlist, fields]\n\n let to_input ({ network; account; valid_while } : t) =\n List.reduce_exn ~f:Random_oracle_input.Chunked.append\n [ Zkapp_precondition.Protocol_state.Checked.to_input network\n ; Zkapp_precondition.Account.Checked.to_input account\n ; Zkapp_precondition.Valid_while.Checked.to_input valid_while\n ]\n end\n\n let typ () : (Checked.t, t) Typ.t =\n Typ.of_hlistable\n [ Zkapp_precondition.Protocol_state.typ\n ; Account_precondition.typ ()\n ; Zkapp_precondition.Valid_while.typ\n ]\n ~var_to_hlist:Checked.to_hlist ~var_of_hlist:Checked.of_hlist\n ~value_to_hlist:to_hlist ~value_of_hlist:of_hlist\n\n let accept =\n { network = Zkapp_precondition.Protocol_state.accept\n ; account = Account_precondition.Accept\n ; valid_while = Ignore\n }\nend\n\nmodule Body = struct\n (* Why isn't this derived automatically? *)\n let hash_fold_array f init x = Array.fold ~init ~f x\n\n module Events' = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Pickles.Backend.Tick.Field.Stable.V1.t array list\n [@@deriving sexp, equal, hash, compare, yojson]\n\n let to_latest = Fn.id\n end\n end]\n end\n\n module Graphql_repr = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t =\n { public_key : Public_key.Compressed.Stable.V1.t\n ; token_id : Token_id.Stable.V2.t\n ; update : Update.Stable.V1.t\n ; balance_change :\n (Amount.Stable.V1.t, Sgn.Stable.V1.t) Signed_poly.Stable.V1.t\n ; increment_nonce : bool\n ; events : Events'.Stable.V1.t\n ; actions : Events'.Stable.V1.t\n ; call_data : Pickles.Backend.Tick.Field.Stable.V1.t\n ; call_depth : int\n ; preconditions : Preconditions.Stable.V1.t\n ; use_full_commitment : bool\n ; implicit_account_creation_fee : bool\n ; may_use_token : May_use_token.Stable.V1.t\n ; authorization_kind : Authorization_kind.Stable.V1.t\n }\n [@@deriving annot, sexp, equal, yojson, hash, compare, fields]\n\n let to_latest = Fn.id\n end\n end]\n\n let deriver obj =\n let open Fields_derivers_zkapps in\n let ( !. ) = ( !. ) ~t_fields_annots in\n Fields.make_creator obj ~public_key:!.public_key ~update:!.Update.deriver\n ~token_id:!.Token_id.deriver ~balance_change:!.balance_change\n ~increment_nonce:!.bool ~events:!.Events.deriver\n ~actions:!.Actions.deriver ~call_data:!.field\n ~preconditions:!.Preconditions.deriver ~use_full_commitment:!.bool\n ~implicit_account_creation_fee:!.bool\n ~may_use_token:!.May_use_token.deriver ~call_depth:!.int\n ~authorization_kind:!.Authorization_kind.deriver\n |> finish \"AccountUpdateBody\" ~t_toplevel_annots\n\n let dummy : t =\n { public_key = Public_key.Compressed.empty\n ; update = Update.dummy\n ; token_id = Token_id.default\n ; balance_change = Amount.Signed.zero\n ; increment_nonce = false\n ; events = []\n ; actions = []\n ; call_data = Field.zero\n ; call_depth = 0\n ; preconditions = Preconditions.accept\n ; use_full_commitment = false\n ; implicit_account_creation_fee = false\n ; may_use_token = No\n ; authorization_kind = None_given\n }\n end\n\n module Simple = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t =\n { public_key : Public_key.Compressed.Stable.V1.t\n ; token_id : Token_id.Stable.V2.t\n ; update : Update.Stable.V1.t\n ; balance_change :\n (Amount.Stable.V1.t, Sgn.Stable.V1.t) Signed_poly.Stable.V1.t\n ; increment_nonce : bool\n ; events : Events'.Stable.V1.t\n ; actions : Events'.Stable.V1.t\n ; call_data : Pickles.Backend.Tick.Field.Stable.V1.t\n ; call_depth : int\n ; preconditions : Preconditions.Stable.V1.t\n ; use_full_commitment : bool\n ; implicit_account_creation_fee : bool\n ; may_use_token : May_use_token.Stable.V1.t\n ; authorization_kind : Authorization_kind.Stable.V1.t\n }\n [@@deriving annot, sexp, equal, yojson, hash, compare, fields]\n\n let to_latest = Fn.id\n end\n end]\n end\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Mina_wire_types.Mina_base.Account_update.Body.V1.t =\n { public_key : Public_key.Compressed.Stable.V1.t\n ; token_id : Token_id.Stable.V2.t\n ; update : Update.Stable.V1.t\n ; balance_change :\n (Amount.Stable.V1.t, Sgn.Stable.V1.t) Signed_poly.Stable.V1.t\n ; increment_nonce : bool\n ; events : Events'.Stable.V1.t\n ; actions : Events'.Stable.V1.t\n ; call_data : Pickles.Backend.Tick.Field.Stable.V1.t\n ; preconditions : Preconditions.Stable.V1.t\n ; use_full_commitment : bool\n ; implicit_account_creation_fee : bool\n ; may_use_token : May_use_token.Stable.V1.t\n ; authorization_kind : Authorization_kind.Stable.V1.t\n }\n [@@deriving annot, sexp, equal, yojson, hash, hlist, compare, fields]\n\n let to_latest = Fn.id\n end\n end]\n\n let of_simple (p : Simple.t) : t =\n { public_key = p.public_key\n ; token_id = p.token_id\n ; update = p.update\n ; balance_change = p.balance_change\n ; increment_nonce = p.increment_nonce\n ; events = p.events\n ; actions = p.actions\n ; call_data = p.call_data\n ; preconditions = p.preconditions\n ; use_full_commitment = p.use_full_commitment\n ; implicit_account_creation_fee = p.implicit_account_creation_fee\n ; may_use_token = p.may_use_token\n ; authorization_kind = p.authorization_kind\n }\n\n let of_graphql_repr\n ({ public_key\n ; token_id\n ; update\n ; balance_change\n ; increment_nonce\n ; events\n ; actions\n ; call_data\n ; preconditions\n ; use_full_commitment\n ; implicit_account_creation_fee\n ; may_use_token\n ; call_depth = _\n ; authorization_kind\n } :\n Graphql_repr.t ) : t =\n { public_key\n ; token_id\n ; update\n ; balance_change\n ; increment_nonce\n ; events\n ; actions\n ; call_data\n ; preconditions\n ; use_full_commitment\n ; implicit_account_creation_fee\n ; may_use_token\n ; authorization_kind\n }\n\n let to_graphql_repr\n ({ public_key\n ; token_id\n ; update\n ; balance_change\n ; increment_nonce\n ; events\n ; actions\n ; call_data\n ; preconditions\n ; use_full_commitment\n ; implicit_account_creation_fee\n ; may_use_token\n ; authorization_kind\n } :\n t ) ~call_depth : Graphql_repr.t =\n { Graphql_repr.public_key\n ; token_id\n ; update\n ; balance_change\n ; increment_nonce\n ; events\n ; actions\n ; call_data\n ; preconditions\n ; use_full_commitment\n ; implicit_account_creation_fee\n ; may_use_token\n ; call_depth\n ; authorization_kind\n }\n\n module Fee_payer = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Mina_wire_types.Mina_base.Account_update.Body.Fee_payer.V1.t =\n { public_key : Public_key.Compressed.Stable.V1.t\n ; fee : Fee.Stable.V1.t\n ; valid_until : Global_slot_since_genesis.Stable.V1.t option\n [@name \"validUntil\"]\n ; nonce : Account_nonce.Stable.V1.t\n }\n [@@deriving annot, sexp, equal, yojson, hash, compare, hlist, fields]\n\n let to_latest = Fn.id\n end\n end]\n\n let gen : t Quickcheck.Generator.t =\n let open Quickcheck.Generator.Let_syntax in\n let%map public_key = Public_key.Compressed.gen\n and fee = Currency.Fee.gen\n and valid_until =\n Option.quickcheck_generator Global_slot_since_genesis.gen\n and nonce = Account.Nonce.gen in\n { public_key; fee; valid_until; nonce }\n\n let dummy : t =\n { public_key = Public_key.Compressed.empty\n ; fee = Fee.zero\n ; valid_until = None\n ; nonce = Account_nonce.zero\n }\n\n let deriver obj =\n let open Fields_derivers_zkapps in\n let fee obj =\n iso_string obj ~name:\"Fee\" ~js_type:UInt64 ~to_string:Fee.to_string\n ~of_string:Fee.of_string\n in\n let ( !. ) ?skip_data = ( !. ) ?skip_data ~t_fields_annots in\n Fields.make_creator obj ~public_key:!.public_key ~fee:!.fee\n ~valid_until:\n !.Fields_derivers_zkapps.Derivers.(\n option ~js_type:Or_undefined @@ global_slot_since_genesis @@ o ())\n ~nonce:!.uint32\n |> finish \"FeePayerBody\" ~t_toplevel_annots\n end\n\n let of_fee_payer (t : Fee_payer.t) : t =\n { public_key = t.public_key\n ; token_id = Token_id.default\n ; update = Update.noop\n ; balance_change =\n { Signed_poly.sgn = Sgn.Neg; magnitude = Amount.of_fee t.fee }\n ; increment_nonce = true\n ; events = []\n ; actions = []\n ; call_data = Field.zero\n ; preconditions =\n { Preconditions.network =\n (let valid_until =\n Option.value ~default:Global_slot_since_genesis.max_value\n t.valid_until\n in\n { Zkapp_precondition.Protocol_state.accept with\n global_slot_since_genesis =\n Check\n { lower = Global_slot_since_genesis.zero\n ; upper = valid_until\n }\n } )\n ; account = Account_precondition.Nonce t.nonce\n ; valid_while = Ignore\n }\n ; use_full_commitment = true\n ; implicit_account_creation_fee = true\n ; may_use_token = No\n ; authorization_kind = Signature\n }\n\n let to_simple_fee_payer (t : Fee_payer.t) : Simple.t =\n { public_key = t.public_key\n ; token_id = Token_id.default\n ; update = Update.noop\n ; balance_change =\n { Signed_poly.sgn = Sgn.Neg; magnitude = Amount.of_fee t.fee }\n ; increment_nonce = true\n ; events = []\n ; actions = []\n ; call_data = Field.zero\n ; preconditions =\n { Preconditions.network =\n (let valid_until =\n Option.value ~default:Global_slot_since_genesis.max_value\n t.valid_until\n in\n { Zkapp_precondition.Protocol_state.accept with\n global_slot_since_genesis =\n Check\n { lower = Global_slot_since_genesis.zero\n ; upper = valid_until\n }\n } )\n ; account = Account_precondition.Nonce t.nonce\n ; valid_while = Ignore\n }\n ; use_full_commitment = true\n ; implicit_account_creation_fee = true\n ; may_use_token = No\n ; call_depth = 0\n ; authorization_kind = Signature\n }\n\n let to_fee_payer_exn (t : t) : Fee_payer.t =\n let { public_key\n ; token_id = _\n ; update = _\n ; balance_change\n ; increment_nonce = _\n ; events = _\n ; actions = _\n ; call_data = _\n ; preconditions\n ; use_full_commitment = _\n ; may_use_token = _\n ; authorization_kind = _\n } =\n t\n in\n let fee =\n Currency.Fee.of_uint64\n (balance_change.magnitude |> Currency.Amount.to_uint64)\n in\n let nonce =\n match preconditions.account with\n | Nonce nonce ->\n Mina_numbers.Account_nonce.of_uint32 nonce\n | Full _ | Accept ->\n failwith \"Expected a nonce for fee payer account precondition\"\n in\n let valid_until =\n match preconditions.network.global_slot_since_genesis with\n | Ignore ->\n None\n | Check { upper; _ } ->\n Some upper\n in\n { public_key; fee; valid_until; nonce }\n\n module Checked = struct\n module Type_of_var (V : sig\n type var\n end) =\n struct\n type t = V.var\n end\n\n module Int_as_prover_ref = struct\n type t = int As_prover.Ref.t\n end\n\n type t =\n { public_key : Public_key.Compressed.var\n ; token_id : Token_id.Checked.t\n ; update : Update.Checked.t\n ; balance_change : Amount.Signed.var\n ; increment_nonce : Boolean.var\n ; events : Events.var\n ; actions : Actions.var\n ; call_data : Field.Var.t\n ; preconditions : Preconditions.Checked.t\n ; use_full_commitment : Boolean.var\n ; implicit_account_creation_fee : Boolean.var\n ; may_use_token : May_use_token.Checked.t\n ; authorization_kind : Authorization_kind.Checked.t\n }\n [@@deriving annot, hlist, fields]\n\n let to_input\n ({ public_key\n ; token_id\n ; update\n ; balance_change\n ; increment_nonce\n ; events\n ; actions\n ; call_data\n ; preconditions\n ; use_full_commitment\n ; implicit_account_creation_fee\n ; may_use_token\n ; authorization_kind\n } :\n t ) =\n List.reduce_exn ~f:Random_oracle_input.Chunked.append\n [ Public_key.Compressed.Checked.to_input public_key\n ; Token_id.Checked.to_input token_id\n ; Update.Checked.to_input update\n ; Snark_params.Tick.Run.run_checked\n (Amount.Signed.Checked.to_input balance_change)\n ; Random_oracle_input.Chunked.packed\n ((increment_nonce :> Field.Var.t), 1)\n ; Events.var_to_input events\n ; Actions.var_to_input actions\n ; Random_oracle_input.Chunked.field call_data\n ; Preconditions.Checked.to_input preconditions\n ; Random_oracle_input.Chunked.packed\n ((use_full_commitment :> Field.Var.t), 1)\n ; Random_oracle_input.Chunked.packed\n ((implicit_account_creation_fee :> Field.Var.t), 1)\n ; May_use_token.Checked.to_input may_use_token\n ; Authorization_kind.Checked.to_input authorization_kind\n ]\n\n let digest (t : t) =\n Random_oracle.Checked.(\n hash ~init:Hash_prefix.zkapp_body (pack_input (to_input t)))\n end\n\n let typ () : (Checked.t, t) Typ.t =\n Typ.of_hlistable\n [ Public_key.Compressed.typ\n ; Token_id.typ\n ; Update.typ ()\n ; Amount.Signed.typ\n ; Boolean.typ\n ; Events.typ\n ; Actions.typ\n ; Field.typ\n ; Preconditions.typ ()\n ; Impl.Boolean.typ\n ; Impl.Boolean.typ\n ; May_use_token.typ\n ; Authorization_kind.typ\n ]\n ~var_to_hlist:Checked.to_hlist ~var_of_hlist:Checked.of_hlist\n ~value_to_hlist:to_hlist ~value_of_hlist:of_hlist\n\n let dummy : t =\n { public_key = Public_key.Compressed.empty\n ; update = Update.dummy\n ; token_id = Token_id.default\n ; balance_change = Amount.Signed.zero\n ; increment_nonce = false\n ; events = []\n ; actions = []\n ; call_data = Field.zero\n ; preconditions = Preconditions.accept\n ; use_full_commitment = false\n ; implicit_account_creation_fee = true\n ; may_use_token = No\n ; authorization_kind = None_given\n }\n\n let to_input\n ({ public_key\n ; update\n ; token_id\n ; balance_change\n ; increment_nonce\n ; events\n ; actions\n ; call_data\n ; preconditions\n ; use_full_commitment\n ; implicit_account_creation_fee\n ; may_use_token\n ; authorization_kind\n } :\n t ) =\n List.reduce_exn ~f:Random_oracle_input.Chunked.append\n [ Public_key.Compressed.to_input public_key\n ; Token_id.to_input token_id\n ; Update.to_input update\n ; Amount.Signed.to_input balance_change\n ; Random_oracle_input.Chunked.packed (field_of_bool increment_nonce, 1)\n ; Events.to_input events\n ; Actions.to_input actions\n ; Random_oracle_input.Chunked.field call_data\n ; Preconditions.to_input preconditions\n ; Random_oracle_input.Chunked.packed (field_of_bool use_full_commitment, 1)\n ; Random_oracle_input.Chunked.packed\n (field_of_bool implicit_account_creation_fee, 1)\n ; May_use_token.to_input may_use_token\n ; Authorization_kind.to_input authorization_kind\n ]\n\n let digest (t : t) =\n Random_oracle.(hash ~init:Hash_prefix.zkapp_body (pack_input (to_input t)))\n\n module Digested = struct\n type t = Random_oracle.Digest.t\n\n module Checked = struct\n type t = Random_oracle.Checked.Digest.t\n end\n end\n\n let gen =\n let open Quickcheck.Generator.Let_syntax in\n let%map public_key = Public_key.Compressed.gen\n and token_id = Token_id.gen\n and update = Update.gen ()\n and balance_change = Currency.Amount.Signed.gen\n and increment_nonce = Quickcheck.Generator.bool\n and events = return []\n and actions = return []\n and call_data = Field.gen\n and preconditions = Preconditions.gen\n and use_full_commitment = Quickcheck.Generator.bool\n and implicit_account_creation_fee = Quickcheck.Generator.bool\n and may_use_token = May_use_token.gen\n and authorization_kind = Authorization_kind.gen in\n { public_key\n ; token_id\n ; update\n ; balance_change\n ; increment_nonce\n ; events\n ; actions\n ; call_data\n ; preconditions\n ; use_full_commitment\n ; implicit_account_creation_fee\n ; may_use_token\n ; authorization_kind\n }\n\n let gen_with_events_and_actions =\n let open Quickcheck.Generator.Let_syntax in\n let%map public_key = Public_key.Compressed.gen\n and token_id = Token_id.gen\n and update = Update.gen ()\n and balance_change = Currency.Amount.Signed.gen\n and increment_nonce = Quickcheck.Generator.bool\n and events = return [ [| Field.zero |]; [| Field.zero |] ]\n and actions = return [ [| Field.zero |]; [| Field.zero |] ]\n and call_data = Field.gen\n and preconditions = Preconditions.gen\n and use_full_commitment = Quickcheck.Generator.bool\n and implicit_account_creation_fee = Quickcheck.Generator.bool\n and may_use_token = May_use_token.gen\n and authorization_kind = Authorization_kind.gen in\n { public_key\n ; token_id\n ; update\n ; balance_change\n ; increment_nonce\n ; events\n ; actions\n ; call_data\n ; preconditions\n ; use_full_commitment\n ; implicit_account_creation_fee\n ; may_use_token\n ; authorization_kind\n }\nend\n\nmodule T = struct\n module Graphql_repr = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n (** An account update in a zkApp transaction *)\n type t =\n { body : Body.Graphql_repr.Stable.V1.t\n ; authorization : Control.Stable.V2.t\n }\n [@@deriving annot, sexp, equal, yojson, hash, compare, fields]\n\n let to_latest = Fn.id\n end\n end]\n\n let deriver obj =\n let open Fields_derivers_zkapps.Derivers in\n let ( !. ) = ( !. ) ~t_fields_annots in\n Fields.make_creator obj\n ~body:!.Body.Graphql_repr.deriver\n ~authorization:!.Control.deriver\n |> finish \"ZkappAccountUpdate\" ~t_toplevel_annots\n end\n\n module Simple = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t =\n { body : Body.Simple.Stable.V1.t\n ; authorization : Control.Stable.V2.t\n }\n [@@deriving annot, sexp, equal, yojson, hash, compare, fields]\n\n let to_latest = Fn.id\n end\n end]\n end\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n (** A account_update to a zkApp transaction *)\n type t = Mina_wire_types.Mina_base.Account_update.V1.t =\n { body : Body.Stable.V1.t; authorization : Control.Stable.V2.t }\n [@@deriving annot, sexp, equal, yojson, hash, compare, fields]\n\n let to_latest = Fn.id\n end\n end]\n\n let of_graphql_repr ({ body; authorization } : Graphql_repr.t) : t =\n { authorization; body = Body.of_graphql_repr body }\n\n let to_graphql_repr ({ body; authorization } : t) ~call_depth : Graphql_repr.t\n =\n { authorization; body = Body.to_graphql_repr ~call_depth body }\n\n let gen : t Quickcheck.Generator.t =\n let open Quickcheck.Generator.Let_syntax in\n let%map body = Body.gen and authorization = Control.gen_with_dummies in\n { body; authorization }\n\n let gen_with_events_and_actions : t Quickcheck.Generator.t =\n let open Quickcheck.Generator.Let_syntax in\n let%map body = Body.gen_with_events_and_actions\n and authorization = Control.gen_with_dummies in\n { body; authorization }\n\n let quickcheck_generator : t Quickcheck.Generator.t = gen\n\n let quickcheck_observer : t Quickcheck.Observer.t =\n Quickcheck.Observer.of_hash (module Stable.Latest)\n\n let quickcheck_shrinker : t Quickcheck.Shrinker.t =\n Quickcheck.Shrinker.empty ()\n\n let of_simple (p : Simple.t) : t =\n { body = Body.of_simple p.body; authorization = p.authorization }\n\n let digest (t : t) = Body.digest t.body\n\n module Checked = struct\n type t = Body.Checked.t\n\n let digest (t : t) = Body.Checked.digest t\n end\nend\n\nmodule Fee_payer = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Mina_wire_types.Mina_base.Account_update.Fee_payer.V1.t =\n { body : Body.Fee_payer.Stable.V1.t\n ; authorization : Signature.Stable.V1.t\n }\n [@@deriving annot, sexp, equal, yojson, hash, compare, fields]\n\n let to_latest = Fn.id\n end\n end]\n\n let gen : t Quickcheck.Generator.t =\n let open Quickcheck.Let_syntax in\n let%map body = Body.Fee_payer.gen in\n let authorization = Signature.dummy in\n { body; authorization }\n\n let quickcheck_generator : t Quickcheck.Generator.t = gen\n\n let quickcheck_observer : t Quickcheck.Observer.t =\n Quickcheck.Observer.of_hash (module Stable.Latest)\n\n let quickcheck_shrinker : t Quickcheck.Shrinker.t =\n Quickcheck.Shrinker.empty ()\n\n let account_id (t : t) : Account_id.t =\n Account_id.create t.body.public_key Token_id.default\n\n let to_account_update (t : t) : T.t =\n { authorization = Control.Signature t.authorization\n ; body = Body.of_fee_payer t.body\n }\n\n let deriver obj =\n let open Fields_derivers_zkapps.Derivers in\n let ( !. ) = ( !. ) ~t_fields_annots in\n Fields.make_creator obj ~body:!.Body.Fee_payer.deriver\n ~authorization:!.Control.signature_deriver\n |> finish \"ZkappFeePayer\" ~t_toplevel_annots\nend\n\ninclude T\n\nlet account_id (t : t) : Account_id.t =\n Account_id.create t.body.public_key t.body.token_id\n\nlet verification_key_update_to_option (t : t) :\n Verification_key_wire.t option Zkapp_basic.Set_or_keep.t =\n Zkapp_basic.Set_or_keep.map ~f:Option.some t.body.update.verification_key\n\nlet of_fee_payer ({ body; authorization } : Fee_payer.t) : t =\n { authorization = Signature authorization; body = Body.of_fee_payer body }\n\n(** The change in balance to apply to the target account of this account_update.\n When this is negative, the amount will be withdrawn from the account and\n made available to later zkapp_command in the same transaction.\n When this is positive, the amount will be deposited into the account from\n the funds made available by previous zkapp_command in the same transaction.\n*)\nlet balance_change (t : t) : Amount.Signed.t = t.body.balance_change\n\nlet protocol_state_precondition (t : t) : Zkapp_precondition.Protocol_state.t =\n t.body.preconditions.network\n\nlet valid_while_precondition (t : t) :\n Mina_numbers.Global_slot_since_genesis.t Zkapp_precondition.Numeric.t =\n t.body.preconditions.valid_while\n\nlet public_key (t : t) : Public_key.Compressed.t = t.body.public_key\n\nlet token_id (t : t) : Token_id.t = t.body.token_id\n\nlet use_full_commitment (t : t) : bool = t.body.use_full_commitment\n\nlet implicit_account_creation_fee (t : t) : bool =\n t.body.implicit_account_creation_fee\n\nlet increment_nonce (t : t) : bool = t.body.increment_nonce\n","open Core_kernel\n\n[%%versioned\nmodule Stable = struct\n module V1 = struct\n type ('a, 'field) t =\n ('a, 'field) Mina_wire_types.Mina_base.With_stack_hash.V1.t =\n { elt : 'a; stack_hash : 'field }\n [@@deriving sexp, compare, equal, hash, yojson, fields, quickcheck]\n end\nend]\n\nlet map t ~f = { t with elt = f t.elt }\n","open Core_kernel\n\n[%%versioned\nmodule Stable = struct\n module V2 = struct\n type 'a t = 'a Mina_wire_types.Mina_base.With_status.V2.t =\n { data : 'a; status : Transaction_status.Stable.V2.t }\n [@@deriving sexp, yojson, equal, compare, fields]\n\n let to_latest data_latest (t : _ t) =\n { data = data_latest t.data; status = t.status }\n end\nend]\n\nlet map ~f { data; status } = { data = f data; status }\n\nlet map_opt ~f { data; status } =\n Option.map (f data) ~f:(fun data -> { data; status })\n\nlet map_result ~f { data; status } =\n Result.map (f data) ~f:(fun data -> { data; status })\n","open Core_kernel\nopen Signature_lib\n\nmodule Call_forest = struct\n let empty = Outside_hash_image.t\n\n module Tree = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type ('account_update, 'account_update_digest, 'digest) t =\n ( 'account_update\n , 'account_update_digest\n , 'digest )\n Mina_wire_types.Mina_base.Zkapp_command.Call_forest.Tree.V1.t =\n { account_update : 'account_update\n ; account_update_digest : 'account_update_digest\n ; calls :\n ( ('account_update, 'account_update_digest, 'digest) t\n , 'digest )\n With_stack_hash.Stable.V1.t\n list\n }\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n let rec fold_forest (ts : (_ t, _) With_stack_hash.t list) ~f ~init =\n List.fold ts ~init ~f:(fun acc { elt; stack_hash = _ } ->\n fold elt ~init:acc ~f )\n\n and fold { account_update; calls; account_update_digest = _ } ~f ~init =\n fold_forest calls ~f ~init:(f init account_update)\n\n let rec fold_forest2_exn (ts1 : (_ t, _) With_stack_hash.t list)\n (ts2 : (_ t, _) With_stack_hash.t list) ~f ~init =\n List.fold2_exn ts1 ts2 ~init\n ~f:(fun\n acc\n { elt = elt1; stack_hash = _ }\n { elt = elt2; stack_hash = _ }\n -> fold2_exn elt1 elt2 ~init:acc ~f )\n\n and fold2_exn\n { account_update = account_update1\n ; calls = calls1\n ; account_update_digest = _\n }\n { account_update = account_update2\n ; calls = calls2\n ; account_update_digest = _\n } ~f ~init =\n fold_forest2_exn calls1 calls2 ~f\n ~init:(f init account_update1 account_update2)\n\n let iter_forest2_exn ts1 ts2 ~f =\n fold_forest2_exn ts1 ts2 ~init:() ~f:(fun () p1 p2 -> f p1 p2)\n\n let iter2_exn ts1 ts2 ~f =\n fold2_exn ts1 ts2 ~init:() ~f:(fun () p1 p2 -> f p1 p2)\n\n let rec mapi_with_trees' ~i (t : _ t) ~f =\n let account_update = f i t.account_update t in\n let l, calls = mapi_forest_with_trees' ~i:(i + 1) t.calls ~f in\n ( l\n , { calls\n ; account_update\n ; account_update_digest = t.account_update_digest\n } )\n\n and mapi_forest_with_trees' ~i x ~f =\n let rec go i acc = function\n | [] ->\n (i, List.rev acc)\n | t :: ts ->\n let l, elt' = mapi_with_trees' ~i ~f (With_stack_hash.elt t) in\n go l (With_stack_hash.map t ~f:(fun _ -> elt') :: acc) ts\n in\n go i [] x\n\n let mapi_with_trees t ~f = mapi_with_trees' ~i:0 t ~f |> snd\n\n let mapi_forest_with_trees t ~f = mapi_forest_with_trees' ~i:0 t ~f |> snd\n\n let mapi' ~i t ~f =\n mapi_with_trees' ~i t ~f:(fun i account_update _ -> f i account_update)\n\n let mapi_forest' ~i t ~f =\n mapi_forest_with_trees' ~i t ~f:(fun i account_update _ ->\n f i account_update )\n\n let rec deferred_mapi_with_trees' ~i (t : _ t) ~f =\n let open Async_kernel.Deferred.Let_syntax in\n let%bind l, calls =\n deferred_mapi_forest_with_trees' ~i:(i + 1) t.calls ~f\n in\n let%map account_update = f i t.account_update t in\n ( l\n , { calls\n ; account_update\n ; account_update_digest = t.account_update_digest\n } )\n\n and deferred_mapi_forest_with_trees' ~i x ~f =\n let open Async_kernel.Deferred.Let_syntax in\n let rec go i acc = function\n | [] ->\n return (i, List.rev acc)\n | t :: ts ->\n let%bind l, elt' =\n deferred_mapi_with_trees' ~i ~f (With_stack_hash.elt t)\n in\n go l (With_stack_hash.map t ~f:(fun _ -> elt') :: acc) ts\n in\n go i [] x\n\n let map_forest ~f t = mapi_forest' ~i:0 ~f:(fun _ x -> f x) t |> snd\n\n let mapi_forest ~f t = mapi_forest' ~i:0 ~f t |> snd\n\n let deferred_map_forest ~f t =\n let open Async_kernel.Deferred in\n deferred_mapi_forest_with_trees' ~i:0 ~f:(fun _ x -> f x) t >>| snd\n\n let deferred_mapi_forest ~f t =\n let open Async_kernel.Deferred in\n deferred_mapi_forest_with_trees' ~i:0 ~f t >>| snd\n\n let hash { account_update = _; calls; account_update_digest } =\n let stack_hash =\n match calls with [] -> empty | e :: _ -> e.stack_hash\n in\n Random_oracle.hash ~init:Hash_prefix_states.account_update_node\n [| account_update_digest; stack_hash |]\n end\n\n type ('a, 'b, 'c) tree = ('a, 'b, 'c) Tree.t\n\n module type Digest_intf = sig\n module Account_update : sig\n include Digest_intf.S\n\n module Checked : sig\n include Digest_intf.S_checked\n\n val create : Account_update.Checked.t -> t\n\n val create_body : Account_update.Body.Checked.t -> t\n end\n\n include Digest_intf.S_aux with type t := t and type checked := Checked.t\n\n val create : Account_update.t -> t\n\n val create_body : Account_update.Body.t -> t\n end\n\n module rec Forest : sig\n include Digest_intf.S\n\n module Checked : sig\n include Digest_intf.S_checked\n\n val empty : t\n\n val cons : Tree.Checked.t -> t -> t\n end\n\n include Digest_intf.S_aux with type t := t and type checked := Checked.t\n\n val empty : t\n\n val cons : Tree.t -> Forest.t -> Forest.t\n end\n\n and Tree : sig\n include Digest_intf.S\n\n module Checked : sig\n include Digest_intf.S_checked\n\n val create :\n account_update:Account_update.Checked.t\n -> calls:Forest.Checked.t\n -> Tree.Checked.t\n end\n\n include Digest_intf.S_aux with type t := t and type checked := Checked.t\n\n val create : (_, Account_update.t, Forest.t) tree -> Tree.t\n end\n end\n\n module Make_digest_sig\n (T : Mina_wire_types.Mina_base.Zkapp_command.Digest_types.S) =\n struct\n module type S =\n Digest_intf\n with type Account_update.Stable.V1.t = T.Account_update.V1.t\n and type Forest.Stable.V1.t = T.Forest.V1.t\n end\n\n module Make_digest_str\n (T : Mina_wire_types.Mina_base.Zkapp_command.Digest_concrete) :\n Make_digest_sig(T).S = struct\n module M = struct\n open Pickles.Impls.Step.Field\n module Checked = Pickles.Impls.Step.Field\n\n let typ = typ\n\n let constant = constant\n end\n\n module Account_update = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Kimchi_backend.Pasta.Basic.Fp.Stable.V1.t\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n include M\n\n module Checked = struct\n include Checked\n\n let create = Account_update.Checked.digest\n\n let create_body = Account_update.Body.Checked.digest\n end\n\n let create : Account_update.t -> t = Account_update.digest\n\n let create_body : Account_update.Body.t -> t = Account_update.Body.digest\n end\n\n module Forest = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Kimchi_backend.Pasta.Basic.Fp.Stable.V1.t\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n include M\n\n module Checked = struct\n include Checked\n\n let empty = constant empty\n\n let cons hash h_tl =\n Random_oracle.Checked.hash\n ~init:Hash_prefix_states.account_update_cons [| hash; h_tl |]\n end\n\n let empty = empty\n\n let cons hash h_tl =\n Random_oracle.hash ~init:Hash_prefix_states.account_update_cons\n [| hash; h_tl |]\n end\n\n module Tree = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Kimchi_backend.Pasta.Basic.Fp.Stable.V1.t\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n include M\n\n module Checked = struct\n include Checked\n\n let create ~(account_update : Account_update.Checked.t)\n ~(calls : Forest.Checked.t) =\n Random_oracle.Checked.hash\n ~init:Hash_prefix_states.account_update_node\n [| (account_update :> t); (calls :> t) |]\n end\n\n let create ({ account_update = _; calls; account_update_digest } : _ tree)\n =\n let stack_hash =\n match calls with [] -> empty | e :: _ -> e.stack_hash\n in\n Random_oracle.hash ~init:Hash_prefix_states.account_update_node\n [| account_update_digest; stack_hash |]\n end\n end\n\n module Digest =\n Mina_wire_types.Mina_base.Zkapp_command.Digest_make\n (Make_digest_sig)\n (Make_digest_str)\n\n let fold = Tree.fold_forest\n\n let iteri t ~(f : int -> 'a -> unit) : unit =\n let (_ : int) = fold t ~init:0 ~f:(fun acc x -> f acc x ; acc + 1) in\n ()\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n type ('account_update, 'account_update_digest, 'digest) t =\n ( ('account_update, 'account_update_digest, 'digest) Tree.Stable.V1.t\n , 'digest )\n With_stack_hash.Stable.V1.t\n list\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n module Shape = struct\n module I = struct\n type t = int\n\n let quickcheck_shrinker = Quickcheck.Shrinker.empty ()\n\n let quickcheck_generator = [%quickcheck.generator: int]\n\n let quickcheck_observer = [%quickcheck.observer: int]\n end\n\n type t = Node of (I.t * t) list [@@deriving quickcheck]\n end\n\n let rec shape (t : _ t) : Shape.t =\n Node (List.mapi t ~f:(fun i { elt; stack_hash = _ } -> (i, shape elt.calls)))\n\n let match_up (type a b) (xs : a list) (ys : (int * b) list) : (a * b) list =\n let rec go i_curr xs ys =\n match (xs, ys) with\n | [], [] ->\n []\n | x :: xs', (i, y) :: ys' ->\n if i_curr = i then (x, y) :: go (i_curr + 1) xs' ys'\n else if i_curr < i then go (i_curr + 1) xs' ys'\n else assert false\n | [], _ :: _ ->\n assert false\n | _ :: _, [] ->\n []\n in\n go 0 xs ys\n\n let rec mask (t : ('p, 'h1, unit) t) (Node shape : Shape.t) :\n ('p, 'h1, unit) t =\n List.map (match_up t shape)\n ~f:(fun ({ With_stack_hash.elt = t_sub; stack_hash = () }, shape_sub) ->\n { With_stack_hash.elt =\n { t_sub with calls = mask t_sub.calls shape_sub }\n ; stack_hash = ()\n } )\n\n let rec of_account_updates_map ~(f : 'p1 -> 'p2)\n ~(account_update_depth : 'p1 -> int) (account_updates : 'p1 list) :\n ('p2, unit, unit) t =\n match account_updates with\n | [] ->\n []\n | p :: ps ->\n let depth = account_update_depth p in\n let children, siblings =\n List.split_while ps ~f:(fun p' -> account_update_depth p' > depth)\n in\n { With_stack_hash.elt =\n { Tree.account_update = f p\n ; account_update_digest = ()\n ; calls = of_account_updates_map ~f ~account_update_depth children\n }\n ; stack_hash = ()\n }\n :: of_account_updates_map ~f ~account_update_depth siblings\n\n let of_account_updates ~account_update_depth account_updates =\n of_account_updates_map ~f:Fn.id ~account_update_depth account_updates\n\n let to_account_updates_map ~f (xs : _ t) =\n let rec collect depth (xs : _ t) acc =\n match xs with\n | [] ->\n acc\n | { elt = { account_update; calls; account_update_digest = _ }\n ; stack_hash = _\n }\n :: xs ->\n f ~depth account_update :: acc\n |> collect (depth + 1) calls\n |> collect depth xs\n in\n List.rev (collect 0 xs [])\n\n let to_account_updates xs =\n to_account_updates_map ~f:(fun ~depth:_ account_update -> account_update) xs\n\n let hd_account_update (xs : _ t) =\n match xs with\n | [] ->\n None\n | { elt = { account_update; calls = _; account_update_digest = _ }\n ; stack_hash = _\n }\n :: _ ->\n Some account_update\n\n let map = Tree.map_forest\n\n let mapi = Tree.mapi_forest\n\n let mapi_with_trees = Tree.mapi_forest_with_trees\n\n let deferred_mapi = Tree.deferred_mapi_forest\n\n let to_zkapp_command_with_hashes_list (xs : _ t) =\n let rec collect (xs : _ t) acc =\n match xs with\n | [] ->\n acc\n | { elt = { account_update; calls; account_update_digest = _ }\n ; stack_hash\n }\n :: xs ->\n (account_update, stack_hash) :: acc |> collect calls |> collect xs\n in\n List.rev (collect xs [])\n\n let hash_cons hash h_tl =\n Random_oracle.hash ~init:Hash_prefix_states.account_update_cons\n [| hash; h_tl |]\n\n let hash = function\n | [] ->\n Digest.Forest.empty\n | x :: _ ->\n With_stack_hash.stack_hash x\n\n let cons_tree tree (forest : _ t) : _ t =\n { elt = tree\n ; stack_hash = Digest.Forest.cons (Digest.Tree.create tree) (hash forest)\n }\n :: forest\n\n let cons_aux (type p) ~(digest_account_update : p -> _) ?(calls = [])\n (account_update : p) (xs : _ t) : _ t =\n let account_update_digest = digest_account_update account_update in\n let tree : _ Tree.t = { account_update; account_update_digest; calls } in\n cons_tree tree xs\n\n let cons ?calls (account_update : Account_update.t) xs =\n cons_aux ~digest_account_update:Digest.Account_update.create ?calls\n account_update xs\n\n let rec accumulate_hashes ~hash_account_update (xs : _ t) =\n let go = accumulate_hashes ~hash_account_update in\n match xs with\n | [] ->\n []\n | { elt = { account_update; calls; account_update_digest = _ }\n ; stack_hash = _\n }\n :: xs ->\n let calls = go calls in\n let xs = go xs in\n let node =\n { Tree.account_update\n ; calls\n ; account_update_digest = hash_account_update account_update\n }\n in\n let node_hash = Digest.Tree.create node in\n { elt = node; stack_hash = Digest.Forest.cons node_hash (hash xs) }\n :: xs\n\n let accumulate_hashes' (type a b) (xs : (Account_update.t, a, b) t) :\n (Account_update.t, Digest.Account_update.t, Digest.Forest.t) t =\n let hash_account_update (p : Account_update.t) =\n Digest.Account_update.create p\n in\n accumulate_hashes ~hash_account_update xs\n\n let accumulate_hashes_predicated xs =\n accumulate_hashes ~hash_account_update:Digest.Account_update.create xs\n\n module With_hashes_and_data = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type 'data t =\n ( Account_update.Stable.V1.t * 'data\n , Digest.Account_update.Stable.V1.t\n , Digest.Forest.Stable.V1.t )\n Stable.V1.t\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n let empty = Digest.Forest.empty\n\n let hash_account_update ((p : Account_update.t), _) =\n Digest.Account_update.create p\n\n let accumulate_hashes xs : _ t = accumulate_hashes ~hash_account_update xs\n\n let of_zkapp_command_simple_list (xs : (Account_update.Simple.t * 'a) list)\n : _ t =\n of_account_updates xs\n ~account_update_depth:(fun ((p : Account_update.Simple.t), _) ->\n p.body.call_depth )\n |> map ~f:(fun (p, x) -> (Account_update.of_simple p, x))\n |> accumulate_hashes\n\n let of_account_updates (xs : (Account_update.Graphql_repr.t * 'a) list) :\n _ t =\n of_account_updates_map\n ~account_update_depth:(fun ((p : Account_update.Graphql_repr.t), _) ->\n p.body.call_depth )\n ~f:(fun (p, x) -> (Account_update.of_graphql_repr p, x))\n xs\n |> accumulate_hashes\n\n let to_account_updates (x : _ t) = to_account_updates x\n\n let to_zkapp_command_with_hashes_list (x : _ t) =\n to_zkapp_command_with_hashes_list x\n\n let account_updates_hash' xs = of_account_updates xs |> hash\n\n let account_updates_hash xs =\n List.map ~f:(fun x -> (x, ())) xs |> account_updates_hash'\n end\n\n module With_hashes = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t =\n ( Account_update.Stable.V1.t\n , Digest.Account_update.Stable.V1.t\n , Digest.Forest.Stable.V1.t )\n Stable.V1.t\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n let empty = Digest.Forest.empty\n\n let hash_account_update (p : Account_update.t) =\n Digest.Account_update.create p\n\n let accumulate_hashes xs : t = accumulate_hashes ~hash_account_update xs\n\n let of_zkapp_command_simple_list (xs : Account_update.Simple.t list) : t =\n of_account_updates xs\n ~account_update_depth:(fun (p : Account_update.Simple.t) ->\n p.body.call_depth )\n |> map ~f:Account_update.of_simple\n |> accumulate_hashes\n\n let of_account_updates (xs : Account_update.Graphql_repr.t list) : t =\n of_account_updates_map\n ~account_update_depth:(fun (p : Account_update.Graphql_repr.t) ->\n p.body.call_depth )\n ~f:(fun p -> Account_update.of_graphql_repr p)\n xs\n |> accumulate_hashes\n\n let to_account_updates (x : t) = to_account_updates x\n\n let to_zkapp_command_with_hashes_list (x : t) =\n to_zkapp_command_with_hashes_list x\n\n let account_updates_hash' xs = of_account_updates xs |> hash\n\n let account_updates_hash xs =\n List.map ~f:(fun x -> x) xs |> account_updates_hash'\n end\n\n let is_empty : _ t -> bool = List.is_empty\n\n let to_list (type p) (t : (p, _, _) t) : p list =\n List.rev @@ fold t ~init:[] ~f:(fun acc p -> p :: acc)\n\n let exists (type p) (t : (p, _, _) t) ~(f : p -> bool) : bool =\n with_return (fun { return } ->\n fold t ~init:() ~f:(fun () p -> if f p then return true else ()) ;\n false )\nend\n\nmodule Graphql_repr = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t =\n { fee_payer : Account_update.Fee_payer.Stable.V1.t\n ; account_updates : Account_update.Graphql_repr.Stable.V1.t list\n ; memo : Signed_command_memo.Stable.V1.t\n }\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n end\n end]\nend\n\nmodule Simple = struct\n (* For easily constructing values *)\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t =\n { fee_payer : Account_update.Fee_payer.Stable.V1.t\n ; account_updates : Account_update.Simple.Stable.V1.t list\n ; memo : Signed_command_memo.Stable.V1.t\n }\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n end\n end]\nend\n\nmodule Digest = Call_forest.Digest\n\nmodule T = struct\n [%%versioned_binable\n module Stable = struct\n [@@@with_top_version_tag]\n\n (* DO NOT DELETE VERSIONS!\n so we can always get transaction hashes from old transaction ids\n the version linter should be checking this\n\n IF YOU CREATE A NEW VERSION:\n update Transaction_hash.hash_of_transaction_id to handle it\n add hash_zkapp_command_vn for that version\n *)\n\n module V1 = struct\n type t = Mina_wire_types.Mina_base.Zkapp_command.V1.t =\n { fee_payer : Account_update.Fee_payer.Stable.V1.t\n ; account_updates :\n ( Account_update.Stable.V1.t\n , Digest.Account_update.Stable.V1.t\n , Digest.Forest.Stable.V1.t )\n Call_forest.Stable.V1.t\n ; memo : Signed_command_memo.Stable.V1.t\n }\n [@@deriving annot, sexp, compare, equal, hash, yojson, fields]\n\n let to_latest = Fn.id\n\n module Wire = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t =\n { fee_payer : Account_update.Fee_payer.Stable.V1.t\n ; account_updates :\n ( Account_update.Stable.V1.t\n , unit\n , unit )\n Call_forest.Stable.V1.t\n ; memo : Signed_command_memo.Stable.V1.t\n }\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n let check (t : t) : unit =\n List.iter t.account_updates ~f:(fun p ->\n assert (\n Account_update.May_use_token.equal\n p.elt.account_update.body.may_use_token No ) )\n\n let of_graphql_repr (t : Graphql_repr.t) : t =\n { fee_payer = t.fee_payer\n ; memo = t.memo\n ; account_updates =\n Call_forest.of_account_updates_map t.account_updates\n ~f:Account_update.of_graphql_repr\n ~account_update_depth:(fun (p : Account_update.Graphql_repr.t)\n -> p.body.call_depth )\n }\n\n let to_graphql_repr (t : t) : Graphql_repr.t =\n { fee_payer = t.fee_payer\n ; memo = t.memo\n ; account_updates =\n t.account_updates\n |> Call_forest.to_account_updates_map\n ~f:(fun ~depth account_update ->\n Account_update.to_graphql_repr account_update\n ~call_depth:depth )\n }\n\n let gen =\n let open Quickcheck.Generator in\n let open Let_syntax in\n let gen_call_forest =\n fixed_point (fun self ->\n let%bind calls_length = small_non_negative_int in\n list_with_length calls_length\n (let%map account_update = Account_update.gen\n and calls = self in\n { With_stack_hash.stack_hash = ()\n ; elt =\n { Call_forest.Tree.account_update\n ; account_update_digest = ()\n ; calls\n }\n } ) )\n in\n let open Quickcheck.Let_syntax in\n let%map fee_payer = Account_update.Fee_payer.gen\n and account_updates = gen_call_forest\n and memo = Signed_command_memo.gen in\n { fee_payer; account_updates; memo }\n\n let shrinker : t Quickcheck.Shrinker.t =\n Quickcheck.Shrinker.create (fun t ->\n let shape = Call_forest.shape t.account_updates in\n Sequence.map\n (Quickcheck.Shrinker.shrink\n Call_forest.Shape.quickcheck_shrinker shape )\n ~f:(fun shape' ->\n { t with\n account_updates = Call_forest.mask t.account_updates shape'\n } ) )\n end\n\n let of_wire (w : Wire.t) : t =\n { fee_payer = w.fee_payer\n ; memo = w.memo\n ; account_updates =\n w.account_updates\n |> Call_forest.accumulate_hashes\n ~hash_account_update:(fun (p : Account_update.t) ->\n Digest.Account_update.create p )\n }\n\n let to_wire (t : t) : Wire.t =\n let rec forget_hashes = List.map ~f:forget_hash\n and forget_hash = function\n | { With_stack_hash.stack_hash = _\n ; elt =\n { Call_forest.Tree.account_update\n ; account_update_digest = _\n ; calls\n }\n } ->\n { With_stack_hash.stack_hash = ()\n ; elt =\n { Call_forest.Tree.account_update\n ; account_update_digest = ()\n ; calls = forget_hashes calls\n }\n }\n in\n { fee_payer = t.fee_payer\n ; memo = t.memo\n ; account_updates = forget_hashes t.account_updates\n }\n\n include\n Binable.Of_binable_without_uuid\n (Wire.Stable.V1)\n (struct\n type nonrec t = t\n\n let of_binable t = Wire.check t ; of_wire t\n\n let to_binable = to_wire\n end)\n end\n end]\nend\n\ninclude T\n\n[%%define_locally Stable.Latest.(of_wire, to_wire)]\n\n[%%define_locally Stable.Latest.Wire.(gen)]\n\nlet of_simple (w : Simple.t) : t =\n { fee_payer = w.fee_payer\n ; memo = w.memo\n ; account_updates =\n Call_forest.of_account_updates w.account_updates\n ~account_update_depth:(fun (p : Account_update.Simple.t) ->\n p.body.call_depth )\n |> Call_forest.map ~f:Account_update.of_simple\n |> Call_forest.accumulate_hashes\n ~hash_account_update:(fun (p : Account_update.t) ->\n Digest.Account_update.create p )\n }\n\nlet to_simple (t : t) : Simple.t =\n { fee_payer = t.fee_payer\n ; memo = t.memo\n ; account_updates =\n t.account_updates\n |> Call_forest.to_account_updates_map\n ~f:(fun ~depth { Account_update.body = b; authorization } ->\n { Account_update.Simple.authorization\n ; body =\n { public_key = b.public_key\n ; token_id = b.token_id\n ; update = b.update\n ; balance_change = b.balance_change\n ; increment_nonce = b.increment_nonce\n ; events = b.events\n ; actions = b.actions\n ; call_data = b.call_data\n ; preconditions = b.preconditions\n ; use_full_commitment = b.use_full_commitment\n ; implicit_account_creation_fee =\n b.implicit_account_creation_fee\n ; may_use_token = b.may_use_token\n ; call_depth = depth\n ; authorization_kind = b.authorization_kind\n }\n } )\n }\n\nlet all_account_updates (t : t) : _ Call_forest.t =\n let p = t.fee_payer in\n let body = Account_update.Body.of_fee_payer p.body in\n let fee_payer : Account_update.t =\n let p = t.fee_payer in\n { authorization = Control.Signature p.authorization; body }\n in\n Call_forest.cons fee_payer t.account_updates\n\nlet fee (t : t) : Currency.Fee.t = t.fee_payer.body.fee\n\nlet fee_payer_account_update ({ fee_payer; _ } : t) = fee_payer\n\nlet applicable_at_nonce (t : t) : Account.Nonce.t =\n (fee_payer_account_update t).body.nonce\n\nlet target_nonce_on_success (t : t) : Account.Nonce.t =\n let base_nonce = Account.Nonce.succ (applicable_at_nonce t) in\n let fee_payer_pubkey = t.fee_payer.body.public_key in\n let fee_payer_account_update_increments =\n List.count (Call_forest.to_list t.account_updates) ~f:(fun p ->\n Public_key.Compressed.equal p.body.public_key fee_payer_pubkey\n && p.body.increment_nonce )\n in\n Account.Nonce.add base_nonce\n (Account.Nonce.of_int fee_payer_account_update_increments)\n\nlet nonce_increments (t : t) : int Public_key.Compressed.Map.t =\n let base_increments =\n Public_key.Compressed.Map.of_alist_exn [ (t.fee_payer.body.public_key, 1) ]\n in\n List.fold_left (Call_forest.to_list t.account_updates) ~init:base_increments\n ~f:(fun incr_map account_update ->\n if account_update.body.increment_nonce then\n Map.update incr_map account_update.body.public_key\n ~f:(Option.value_map ~default:1 ~f:(( + ) 1))\n else incr_map )\n\nlet fee_token (_t : t) = Token_id.default\n\nlet fee_payer (t : t) =\n Account_id.create t.fee_payer.body.public_key (fee_token t)\n\nlet extract_vks (t : t) : Verification_key_wire.t List.t =\n account_updates t\n |> Call_forest.fold ~init:[] ~f:(fun acc (p : Account_update.t) ->\n match Account_update.verification_key_update_to_option p with\n | Zkapp_basic.Set_or_keep.Set (Some vk) ->\n vk :: acc\n | _ ->\n acc )\n\nlet account_updates_list (t : t) : Account_update.t list =\n Call_forest.fold t.account_updates ~init:[] ~f:(Fn.flip List.cons) |> List.rev\n\nlet all_account_updates_list (t : t) : Account_update.t list =\n Call_forest.fold t.account_updates\n ~init:[ Account_update.of_fee_payer (fee_payer_account_update t) ]\n ~f:(Fn.flip List.cons)\n |> List.rev\n\nlet fee_excess (t : t) =\n Fee_excess.of_single (fee_token t, Currency.Fee.Signed.of_unsigned (fee t))\n\n(* always `Accessed` for fee payer *)\nlet account_access_statuses (t : t) (status : Transaction_status.t) =\n let init = [ (fee_payer t, `Accessed) ] in\n let status_sym =\n match status with Applied -> `Accessed | Failed _ -> `Not_accessed\n in\n Call_forest.fold t.account_updates ~init ~f:(fun acc p ->\n (Account_update.account_id p, status_sym) :: acc )\n |> List.rev |> List.stable_dedup\n\nlet accounts_referenced (t : t) =\n List.map (account_access_statuses t Applied) ~f:(fun (acct_id, _status) ->\n acct_id )\n\nlet fee_payer_pk (t : t) = t.fee_payer.body.public_key\n\nlet value_if b ~then_ ~else_ = if b then then_ else else_\n\nmodule Virtual = struct\n module Bool = struct\n type t = bool\n\n let true_ = true\n\n let assert_ _ = ()\n\n let equal = Bool.equal\n\n let not = not\n\n let ( || ) = ( || )\n\n let ( && ) = ( && )\n end\n\n module Unit = struct\n type t = unit\n\n let if_ = value_if\n end\n\n module Ledger = Unit\n module Account = Unit\n\n module Amount = struct\n open Currency.Amount\n\n type nonrec t = t\n\n let if_ = value_if\n\n module Signed = Signed\n\n let zero = zero\n\n let ( - ) (x1 : t) (x2 : t) : Signed.t =\n Option.value_exn Signed.(of_unsigned x1 + negate (of_unsigned x2))\n\n let ( + ) (x1 : t) (x2 : t) : t = Option.value_exn (add x1 x2)\n\n let add_signed (x1 : t) (x2 : Signed.t) : t =\n let y = Option.value_exn Signed.(of_unsigned x1 + x2) in\n match y.sgn with Pos -> y.magnitude | Neg -> failwith \"add_signed\"\n end\n\n module Token_id = struct\n include Token_id\n\n let if_ = value_if\n end\n\n module Zkapp_command = struct\n type t = Account_update.t list\n\n let if_ = value_if\n\n type account_update = Account_update.t\n\n let empty = []\n\n let is_empty = List.is_empty\n\n let pop (t : t) = match t with [] -> failwith \"pop\" | p :: t -> (p, t)\n end\nend\n\nlet check_authorization (p : Account_update.t) : unit Or_error.t =\n match (p.authorization, p.body.authorization_kind) with\n | None_given, None_given | Proof _, Proof _ | Signature _, Signature ->\n Ok ()\n | _ ->\n let err =\n let expected =\n Account_update.Authorization_kind.to_control_tag\n p.body.authorization_kind\n in\n let got = Control.tag p.authorization in\n Error.create \"Authorization kind does not match the authorization\"\n [ (\"expected\", expected); (\"got\", got) ]\n [%sexp_of: (string * Control.Tag.t) list]\n in\n Error err\n\nmodule Verifiable : sig\n [%%versioned:\n module Stable : sig\n module V1 : sig\n type t = private\n { fee_payer : Account_update.Fee_payer.Stable.V1.t\n ; account_updates :\n ( Side_loaded_verification_key.Stable.V2.t\n , Zkapp_basic.F.Stable.V1.t )\n With_hash.Stable.V1.t\n option\n Call_forest.With_hashes_and_data.Stable.V1.t\n ; memo : Signed_command_memo.Stable.V1.t\n }\n [@@deriving sexp, compare, equal, hash, yojson]\n\n val to_latest : t -> t\n end\n end]\n\n val find_vk_via_ledger :\n ledger:'a\n -> get:('a -> 'b -> Account.t option)\n -> location_of_account:('a -> Account_id.t -> 'b option)\n -> Zkapp_basic.F.t\n -> Account_id.t\n -> (Verification_key_wire.t, Error.t) Result.t\n\n val create :\n T.t\n -> status:Transaction_status.t\n -> find_vk:\n ( Zkapp_basic.F.t\n -> Account_id.t\n -> (Verification_key_wire.t, Error.t) Result.t )\n -> t Or_error.t\n\n module Any : sig\n (** creates verifiables from a list of commands that caches verification\n keys and permits _any_ vks that have been seen earlier in the list. *)\n val create_all :\n T.t With_status.t list\n -> find_vk:\n ( Zkapp_basic.F.t\n -> Account_id.t\n -> (Verification_key_wire.t, Error.t) Result.t )\n -> t With_status.t list Or_error.t\n end\n\n module Last : sig\n (** creates verifiables from a list of commands that caches verification\n keys and permits only the _last_ vk that has been seen earlier in the\n list. *)\n val create_all :\n T.t With_status.t list\n -> find_vk:\n ( Zkapp_basic.F.t\n -> Account_id.t\n -> (Verification_key_wire.t, Error.t) Result.t )\n -> t With_status.t list Or_error.t\n end\nend = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t =\n { fee_payer : Account_update.Fee_payer.Stable.V1.t\n ; account_updates :\n ( Side_loaded_verification_key.Stable.V2.t\n , Zkapp_basic.F.Stable.V1.t )\n With_hash.Stable.V1.t\n option\n Call_forest.With_hashes_and_data.Stable.V1.t\n ; memo : Signed_command_memo.Stable.V1.t\n }\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n let ok_if_vk_hash_expected ~got ~expected =\n if not @@ Zkapp_basic.F.equal (With_hash.hash got) expected then\n Error\n (Error.create \"Expected vk hash doesn't match hash in vk we received\"\n [ (\"expected_vk_hash\", expected)\n ; (\"got_vk_hash\", With_hash.hash got)\n ]\n [%sexp_of: (string * Zkapp_basic.F.t) list] )\n else Ok got\n\n let find_vk_via_ledger ~ledger ~get ~location_of_account expected_vk_hash\n account_id =\n match\n let open Option.Let_syntax in\n let%bind location = location_of_account ledger account_id in\n let%bind (account : Account.t) = get ledger location in\n let%bind zkapp = account.zkapp in\n zkapp.verification_key\n with\n | Some vk ->\n ok_if_vk_hash_expected ~got:vk ~expected:expected_vk_hash\n | None ->\n let err =\n Error.create \"No verification key found for proved account update\"\n (\"account_id\", account_id) [%sexp_of: string * Account_id.t]\n in\n Error err\n\n (* Ensures that there's a verification_key available for all account_updates\n * and creates a valid command associating the correct keys with each\n * account_id.\n *\n * If an account_update replaces the verification_key (or deletes it),\n * subsequent account_updates use the replaced key instead of looking in the\n * ledger for the key (ie set by a previous transaction).\n *)\n let create ({ fee_payer; account_updates; memo } : T.t)\n ~(status : Transaction_status.t) ~find_vk : t Or_error.t =\n With_return.with_return (fun { return } ->\n let tbl = Account_id.Table.create () in\n let vks_overridden =\n (* Keep track of the verification keys that have been set so far\n during this transaction.\n *)\n ref Account_id.Map.empty\n in\n let account_updates =\n Call_forest.map account_updates ~f:(fun p ->\n let account_id = Account_update.account_id p in\n let vks_overriden' =\n match Account_update.verification_key_update_to_option p with\n | Zkapp_basic.Set_or_keep.Set vk_next ->\n Account_id.Map.set !vks_overridden ~key:account_id\n ~data:vk_next\n | Zkapp_basic.Set_or_keep.Keep ->\n !vks_overridden\n in\n let () =\n match check_authorization p with\n | Ok () ->\n ()\n | Error _ as err ->\n return err\n in\n match\n ( p.body.authorization_kind\n , phys_equal status Transaction_status.Applied )\n with\n | Proof vk_hash, true -> (\n let prioritized_vk =\n (* only lookup _past_ vk setting, ie exclude the new one we\n * potentially set in this account_update (use the non-'\n * vks_overrided) . *)\n match Account_id.Map.find !vks_overridden account_id with\n | Some (Some vk) -> (\n match\n ok_if_vk_hash_expected ~got:vk ~expected:vk_hash\n with\n | Ok vk ->\n Some vk\n | Error err ->\n return (Error err) )\n | Some None ->\n (* we explicitly have erased the key *)\n let err =\n Error.create\n \"No verification key found for proved account \\\n update: the verification key was removed by a \\\n previous account update\"\n (\"account_id\", account_id)\n [%sexp_of: string * Account_id.t]\n in\n return (Error err)\n | None -> (\n (* we haven't set anything; lookup the vk in the fallback *)\n match find_vk vk_hash account_id with\n | Error e ->\n return (Error e)\n | Ok vk ->\n Some vk )\n in\n match prioritized_vk with\n | Some prioritized_vk ->\n Account_id.Table.update tbl account_id ~f:(fun _ ->\n With_hash.hash prioritized_vk ) ;\n (* return the updated overrides *)\n vks_overridden := vks_overriden' ;\n (p, Some prioritized_vk)\n | None ->\n (* The transaction failed, so we allow the vk to be missing. *)\n (p, None) )\n | _ ->\n vks_overridden := vks_overriden' ;\n (p, None) )\n in\n Ok { fee_payer; account_updates; memo } )\n\n module Map_cache = struct\n type 'a t = 'a Zkapp_basic.F_map.Map.t\n\n let empty = Zkapp_basic.F_map.Map.empty\n\n let find = Zkapp_basic.F_map.Map.find\n\n let set = Zkapp_basic.F_map.Map.set\n end\n\n module Singleton_cache = struct\n type 'a t = (Zkapp_basic.F.t * 'a) option\n\n let empty = None\n\n let find t key =\n match t with\n | None ->\n None\n | Some (k, v) ->\n if Zkapp_basic.F.equal key k then Some v else None\n\n let set _ ~key ~data = Some (key, data)\n end\n\n module Make_create_all (Cache : sig\n type 'a t\n\n val empty : 'a t\n\n val find : 'a t -> Zkapp_basic.F.t -> 'a option\n\n val set : 'a t -> key:Zkapp_basic.F.t -> data:'a -> 'a t\n end) =\n struct\n let create_all (cmds : T.t With_status.t list)\n ~(find_vk :\n Zkapp_basic.F.t\n -> Account_id.t\n -> (Verification_key_wire.t, Error.t) Result.t ) :\n t With_status.t list Or_error.t =\n Or_error.try_with (fun () ->\n snd (* remove the helper cache we folded with *)\n (List.fold_map cmds ~init:Cache.empty\n ~f:(fun\n (running_cache : Verification_key_wire.t Cache.t)\n { data = cmd; status }\n ->\n let verified_cmd : t =\n create cmd ~status ~find_vk:(fun vk_hash account_id ->\n (* first we check if there's anything in the running\n cache within this chunk so far *)\n match Cache.find running_cache vk_hash with\n | None ->\n (* before falling back to the find_vk *)\n find_vk vk_hash account_id\n | Some vk ->\n Ok vk )\n |> Or_error.ok_exn\n in\n let running_cache' =\n List.fold (extract_vks cmd) ~init:running_cache\n ~f:(fun acc vk ->\n Cache.set acc ~key:(With_hash.hash vk) ~data:vk )\n in\n (running_cache', { With_status.data = verified_cmd; status }) )\n ) )\n end\n\n module Any = struct\n include Make_create_all (Map_cache)\n end\n\n module Last = struct\n include Make_create_all (Singleton_cache)\n end\nend\n\nlet of_verifiable (t : Verifiable.t) : t =\n { fee_payer = t.fee_payer\n ; account_updates = Call_forest.map t.account_updates ~f:fst\n ; memo = t.memo\n }\n\nmodule Transaction_commitment = struct\n module Stable = Kimchi_backend.Pasta.Basic.Fp.Stable\n\n type t = (Stable.Latest.t[@deriving sexp])\n\n let sexp_of_t = Stable.Latest.sexp_of_t\n\n let t_of_sexp = Stable.Latest.t_of_sexp\n\n let empty = Outside_hash_image.t\n\n let typ = Snark_params.Tick.Field.typ\n\n let create ~(account_updates_hash : Digest.Forest.t) : t =\n (account_updates_hash :> t)\n\n let create_complete (t : t) ~memo_hash\n ~(fee_payer_hash : Digest.Account_update.t) =\n Random_oracle.hash ~init:Hash_prefix.account_update_cons\n [| memo_hash; (fee_payer_hash :> t); t |]\n\n module Checked = struct\n type t = Pickles.Impls.Step.Field.t\n\n let create ~(account_updates_hash : Digest.Forest.Checked.t) =\n (account_updates_hash :> t)\n\n let create_complete (t : t) ~memo_hash\n ~(fee_payer_hash : Digest.Account_update.Checked.t) =\n Random_oracle.Checked.hash ~init:Hash_prefix.account_update_cons\n [| memo_hash; (fee_payer_hash :> t); t |]\n end\nend\n\nlet account_updates_hash (t : t) = Call_forest.hash t.account_updates\n\nlet commitment (t : t) : Transaction_commitment.t =\n Transaction_commitment.create ~account_updates_hash:(account_updates_hash t)\n\n(** This module defines weights for each component of a `Zkapp_command.t` element. *)\nmodule Weight = struct\n let account_update : Account_update.t -> int = fun _ -> 1\n\n let fee_payer (_fp : Account_update.Fee_payer.t) : int = 1\n\n let account_updates : (Account_update.t, _, _) Call_forest.t -> int =\n Call_forest.fold ~init:0 ~f:(fun acc p -> acc + account_update p)\n\n let memo : Signed_command_memo.t -> int = fun _ -> 0\nend\n\nlet weight (zkapp_command : t) : int =\n let { fee_payer; account_updates; memo } = zkapp_command in\n List.sum\n (module Int)\n ~f:Fn.id\n [ Weight.fee_payer fee_payer\n ; Weight.account_updates account_updates\n ; Weight.memo memo\n ]\n\nmodule type Valid_intf = sig\n [%%versioned:\n module Stable : sig\n module V1 : sig\n type t = private { zkapp_command : T.Stable.V1.t }\n [@@deriving sexp, compare, equal, hash, yojson]\n end\n end]\n\n val to_valid_unsafe :\n T.t -> [> `If_this_is_used_it_should_have_a_comment_justifying_it of t ]\n\n val to_valid :\n T.t\n -> status:Transaction_status.t\n -> find_vk:\n ( Zkapp_basic.F.t\n -> Account_id.t\n -> (Verification_key_wire.t, Error.t) Result.t )\n -> t Or_error.t\n\n val of_verifiable : Verifiable.t -> t\n\n val forget : t -> T.t\nend\n\nmodule Valid :\n Valid_intf\n with type Stable.V1.t = Mina_wire_types.Mina_base.Zkapp_command.Valid.V1.t =\nstruct\n module S = Stable\n\n module Verification_key_hash = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Zkapp_basic.F.Stable.V1.t\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n end\n end]\n end\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Mina_wire_types.Mina_base.Zkapp_command.Valid.V1.t =\n { zkapp_command : S.V1.t }\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n let create zkapp_command : t = { zkapp_command }\n\n let of_verifiable (t : Verifiable.t) : t = { zkapp_command = of_verifiable t }\n\n let to_valid_unsafe (t : T.t) :\n [> `If_this_is_used_it_should_have_a_comment_justifying_it of t ] =\n `If_this_is_used_it_should_have_a_comment_justifying_it (create t)\n\n let forget (t : t) : T.t = t.zkapp_command\n\n let to_valid (t : T.t) ~status ~find_vk : t Or_error.t =\n Verifiable.create t ~status ~find_vk |> Or_error.map ~f:of_verifiable\nend\n\n[%%define_locally Stable.Latest.(of_yojson, to_yojson)]\n\n(* so transaction ids have a version tag *)\ninclude Codable.Make_base64 (Stable.Latest.With_top_version_tag)\n\ntype account_updates =\n (Account_update.t, Digest.Account_update.t, Digest.Forest.t) Call_forest.t\n\nlet account_updates_deriver obj =\n let of_zkapp_command_with_depth (ps : Account_update.Graphql_repr.t list) :\n account_updates =\n Call_forest.of_account_updates ps\n ~account_update_depth:(fun (p : Account_update.Graphql_repr.t) ->\n p.body.call_depth )\n |> Call_forest.map ~f:Account_update.of_graphql_repr\n |> Call_forest.accumulate_hashes'\n and to_zkapp_command_with_depth (ps : account_updates) :\n Account_update.Graphql_repr.t list =\n ps\n |> Call_forest.to_account_updates_map ~f:(fun ~depth p ->\n Account_update.to_graphql_repr ~call_depth:depth p )\n in\n let open Fields_derivers_zkapps.Derivers in\n let inner = (list @@ Account_update.Graphql_repr.deriver @@ o ()) @@ o () in\n iso ~map:of_zkapp_command_with_depth ~contramap:to_zkapp_command_with_depth\n inner obj\n\nlet deriver obj =\n let open Fields_derivers_zkapps.Derivers in\n let ( !. ) = ( !. ) ~t_fields_annots in\n Fields.make_creator obj\n ~fee_payer:!.Account_update.Fee_payer.deriver\n ~account_updates:!.account_updates_deriver\n ~memo:!.Signed_command_memo.deriver\n |> finish \"ZkappCommand\" ~t_toplevel_annots\n\nlet arg_typ () = Fields_derivers_zkapps.(arg_typ (deriver @@ Derivers.o ()))\n\nlet typ () = Fields_derivers_zkapps.(typ (deriver @@ Derivers.o ()))\n\nlet to_json x = Fields_derivers_zkapps.(to_json (deriver @@ Derivers.o ())) x\n\nlet of_json x = Fields_derivers_zkapps.(of_json (deriver @@ Derivers.o ())) x\n\nlet account_updates_of_json x =\n Fields_derivers_zkapps.(\n of_json\n ((list @@ Account_update.Graphql_repr.deriver @@ o ()) @@ derivers ()))\n x\n\nlet zkapp_command_to_json x =\n Fields_derivers_zkapps.(to_json (deriver @@ derivers ())) x\n\nlet arg_query_string x =\n Fields_derivers_zkapps.Test.Loop.json_to_string_gql @@ to_json x\n\nlet dummy =\n let account_update : Account_update.t =\n { body = Account_update.Body.dummy\n ; authorization = Control.dummy_of_tag Signature\n }\n in\n let fee_payer : Account_update.Fee_payer.t =\n { body = Account_update.Body.Fee_payer.dummy\n ; authorization = Signature.dummy\n }\n in\n { fee_payer\n ; account_updates = Call_forest.cons account_update []\n ; memo = Signed_command_memo.empty\n }\n\nmodule Make_update_group (Input : sig\n type global_state\n\n type local_state\n\n type spec\n\n type connecting_ledger_hash\n\n val zkapp_segment_of_controls : Control.t list -> spec\nend) : sig\n module Zkapp_command_intermediate_state : sig\n type state = { global : Input.global_state; local : Input.local_state }\n\n type t =\n { kind : [ `Same | `New | `Two_new ]\n ; spec : Input.spec\n ; state_before : state\n ; state_after : state\n ; connecting_ledger : Input.connecting_ledger_hash\n }\n end\n\n val group_by_zkapp_command_rev :\n t list\n -> (Input.global_state * Input.local_state * Input.connecting_ledger_hash)\n list\n list\n -> Zkapp_command_intermediate_state.t list\nend = struct\n open Input\n\n module Zkapp_command_intermediate_state = struct\n type state = { global : global_state; local : local_state }\n\n type t =\n { kind : [ `Same | `New | `Two_new ]\n ; spec : spec\n ; state_before : state\n ; state_after : state\n ; connecting_ledger : connecting_ledger_hash\n }\n end\n\n (** [group_by_zkapp_command_rev zkapp_commands stmtss] identifies before/after pairs of\n statements, corresponding to account updates for each zkapp_command in [zkapp_commands] which minimize the\n number of snark proofs needed to prove all of the zkapp_command.\n\n This function is intended to take multiple zkapp transactions as\n its input, which is then converted to a [Account_update.t list list] using\n [List.map ~f:Zkapp_command.zkapp_command]. The [stmtss] argument should\n be a list of the same length, with 1 more state than the number of\n zkapp_command for each transaction.\n\n For example, two transactions made up of zkapp_command [[p1; p2; p3]] and\n [[p4; p5]] should have the statements [[[s0; s1; s2; s3]; [s3; s4; s5]]],\n where each [s_n] is the state after applying [p_n] on top of [s_{n-1}], and\n where [s0] is the initial state before any of the transactions have been\n applied.\n\n Each pair is also identified with one of [`Same], [`New], or [`Two_new],\n indicating that the next one ([`New]) or next two ([`Two_new]) [Zkapp_command.t]s\n will need to be passed as part of the snark witness while applying that\n pair.\n *)\n let group_by_zkapp_command_rev (zkapp_commands : t list)\n (stmtss : (global_state * local_state * connecting_ledger_hash) list list)\n : Zkapp_command_intermediate_state.t list =\n let intermediate_state ~kind ~spec ~before ~after =\n let global_before, local_before, _ = before in\n let global_after, local_after, connecting_ledger = after in\n { Zkapp_command_intermediate_state.kind\n ; spec\n ; state_before = { global = global_before; local = local_before }\n ; state_after = { global = global_after; local = local_after }\n ; connecting_ledger\n }\n in\n let zkapp_account_updatess =\n []\n :: List.map zkapp_commands ~f:(fun (zkapp_command : t) ->\n all_account_updates_list zkapp_command )\n in\n let rec group_by_zkapp_command_rev\n (zkapp_commands : Account_update.t list list) stmtss acc =\n match (zkapp_commands, stmtss) with\n | ([] | [ [] ]), [ _ ] ->\n (* We've associated statements with all given zkapp_command. *)\n acc\n | [ [ { authorization = a1; _ } ] ], [ [ before; after ] ] ->\n (* There are no later zkapp_command to pair this one with. Prove it on its\n own.\n *)\n intermediate_state ~kind:`Same\n ~spec:(zkapp_segment_of_controls [ a1 ])\n ~before ~after\n :: acc\n | [ []; [ { authorization = a1; _ } ] ], [ [ _ ]; [ before; after ] ] ->\n (* This account_update is part of a new transaction, and there are no later\n zkapp_command to pair it with. Prove it on its own.\n *)\n intermediate_state ~kind:`New\n ~spec:(zkapp_segment_of_controls [ a1 ])\n ~before ~after\n :: acc\n | ( ({ authorization = Proof _ as a1; _ } :: zkapp_command)\n :: zkapp_commands\n , (before :: (after :: _ as stmts)) :: stmtss ) ->\n (* This account_update contains a proof, don't pair it with other account updates. *)\n group_by_zkapp_command_rev\n (zkapp_command :: zkapp_commands)\n (stmts :: stmtss)\n ( intermediate_state ~kind:`Same\n ~spec:(zkapp_segment_of_controls [ a1 ])\n ~before ~after\n :: acc )\n | ( []\n :: ({ authorization = Proof _ as a1; _ } :: zkapp_command)\n :: zkapp_commands\n , [ _ ] :: (before :: (after :: _ as stmts)) :: stmtss ) ->\n (* This account_update is part of a new transaction, and contains a proof, don't\n pair it with other account updates.\n *)\n group_by_zkapp_command_rev\n (zkapp_command :: zkapp_commands)\n (stmts :: stmtss)\n ( intermediate_state ~kind:`New\n ~spec:(zkapp_segment_of_controls [ a1 ])\n ~before ~after\n :: acc )\n | ( ({ authorization = a1; _ }\n :: ({ authorization = Proof _; _ } :: _ as zkapp_command) )\n :: zkapp_commands\n , (before :: (after :: _ as stmts)) :: stmtss ) ->\n (* The next account_update contains a proof, don't pair it with this account_update. *)\n group_by_zkapp_command_rev\n (zkapp_command :: zkapp_commands)\n (stmts :: stmtss)\n ( intermediate_state ~kind:`Same\n ~spec:(zkapp_segment_of_controls [ a1 ])\n ~before ~after\n :: acc )\n | ( ({ authorization = a1; _ } :: ([] as zkapp_command))\n :: (({ authorization = Proof _; _ } :: _) :: _ as zkapp_commands)\n , (before :: (after :: _ as stmts)) :: stmtss ) ->\n (* The next account_update is in the next transaction and contains a proof,\n don't pair it with this account_update.\n *)\n group_by_zkapp_command_rev\n (zkapp_command :: zkapp_commands)\n (stmts :: stmtss)\n ( intermediate_state ~kind:`Same\n ~spec:(zkapp_segment_of_controls [ a1 ])\n ~before ~after\n :: acc )\n | ( ({ authorization = (Signature _ | None_given) as a1; _ }\n :: { authorization = (Signature _ | None_given) as a2; _ }\n :: zkapp_command )\n :: zkapp_commands\n , (before :: _ :: (after :: _ as stmts)) :: stmtss ) ->\n (* The next two zkapp_command do not contain proofs, and are within the same\n transaction. Pair them.\n Ok to get \"use_full_commitment\" of [a1] because neither of them\n contain a proof.\n *)\n group_by_zkapp_command_rev\n (zkapp_command :: zkapp_commands)\n (stmts :: stmtss)\n ( intermediate_state ~kind:`Same\n ~spec:(zkapp_segment_of_controls [ a1; a2 ])\n ~before ~after\n :: acc )\n | ( []\n :: ({ authorization = a1; _ }\n :: ({ authorization = Proof _; _ } :: _ as zkapp_command) )\n :: zkapp_commands\n , [ _ ] :: (before :: (after :: _ as stmts)) :: stmtss ) ->\n (* This account_update is in the next transaction, and the next account_update contains a\n proof, don't pair it with this account_update.\n *)\n group_by_zkapp_command_rev\n (zkapp_command :: zkapp_commands)\n (stmts :: stmtss)\n ( intermediate_state ~kind:`New\n ~spec:(zkapp_segment_of_controls [ a1 ])\n ~before ~after\n :: acc )\n | ( []\n :: ({ authorization = (Signature _ | None_given) as a1; _ }\n :: { authorization = (Signature _ | None_given) as a2; _ }\n :: zkapp_command )\n :: zkapp_commands\n , [ _ ] :: (before :: _ :: (after :: _ as stmts)) :: stmtss ) ->\n (* The next two zkapp_command do not contain proofs, and are within the same\n new transaction. Pair them.\n Ok to get \"use_full_commitment\" of [a1] because neither of them\n contain a proof.\n *)\n group_by_zkapp_command_rev\n (zkapp_command :: zkapp_commands)\n (stmts :: stmtss)\n ( intermediate_state ~kind:`New\n ~spec:(zkapp_segment_of_controls [ a1; a2 ])\n ~before ~after\n :: acc )\n | ( [ { authorization = (Signature _ | None_given) as a1; _ } ]\n :: ({ authorization = (Signature _ | None_given) as a2; _ }\n :: zkapp_command )\n :: zkapp_commands\n , (before :: _after1) :: (_before2 :: (after :: _ as stmts)) :: stmtss )\n ->\n (* The next two zkapp_command do not contain proofs, and the second is within\n a new transaction. Pair them.\n Ok to get \"use_full_commitment\" of [a1] because neither of them\n contain a proof.\n *)\n group_by_zkapp_command_rev\n (zkapp_command :: zkapp_commands)\n (stmts :: stmtss)\n ( intermediate_state ~kind:`New\n ~spec:(zkapp_segment_of_controls [ a1; a2 ])\n ~before ~after\n :: acc )\n | ( []\n :: ({ authorization = a1; _ } :: zkapp_command)\n :: (({ authorization = Proof _; _ } :: _) :: _ as zkapp_commands)\n , [ _ ] :: (before :: ([ after ] as stmts)) :: (_ :: _ as stmtss) ) ->\n (* The next transaction contains a proof, and this account_update is in a new\n transaction, don't pair it with the next account_update.\n *)\n group_by_zkapp_command_rev\n (zkapp_command :: zkapp_commands)\n (stmts :: stmtss)\n ( intermediate_state ~kind:`New\n ~spec:(zkapp_segment_of_controls [ a1 ])\n ~before ~after\n :: acc )\n | ( []\n :: [ { authorization = (Signature _ | None_given) as a1; _ } ]\n :: ({ authorization = (Signature _ | None_given) as a2; _ }\n :: zkapp_command )\n :: zkapp_commands\n , [ _ ]\n :: [ before; _after1 ]\n :: (_before2 :: (after :: _ as stmts)) :: stmtss ) ->\n (* The next two zkapp_command do not contain proofs, the first is within a\n new transaction, and the second is within another new transaction.\n Pair them.\n Ok to get \"use_full_commitment\" of [a1] because neither of them\n contain a proof.\n *)\n group_by_zkapp_command_rev\n (zkapp_command :: zkapp_commands)\n (stmts :: stmtss)\n ( intermediate_state ~kind:`Two_new\n ~spec:(zkapp_segment_of_controls [ a1; a2 ])\n ~before ~after\n :: acc )\n | [ [ { authorization = a1; _ } ] ], (before :: after :: _) :: _ ->\n (* This account_update is the final account_update given. Prove it on its own. *)\n intermediate_state ~kind:`Same\n ~spec:(zkapp_segment_of_controls [ a1 ])\n ~before ~after\n :: acc\n | ( [] :: [ { authorization = a1; _ } ] :: [] :: _\n , [ _ ] :: (before :: after :: _) :: _ ) ->\n (* This account_update is the final account_update given, in a new transaction. Prove it\n on its own.\n *)\n intermediate_state ~kind:`New\n ~spec:(zkapp_segment_of_controls [ a1 ])\n ~before ~after\n :: acc\n | _, [] ->\n failwith \"group_by_zkapp_command_rev: No statements remaining\"\n | ([] | [ [] ]), _ ->\n failwith \"group_by_zkapp_command_rev: Unmatched statements remaining\"\n | [] :: _, [] :: _ ->\n failwith\n \"group_by_zkapp_command_rev: No final statement for current \\\n transaction\"\n | [] :: _, (_ :: _ :: _) :: _ ->\n failwith\n \"group_by_zkapp_command_rev: Unmatched statements for current \\\n transaction\"\n | [] :: [ _ ] :: _, [ _ ] :: (_ :: _ :: _ :: _) :: _ ->\n failwith\n \"group_by_zkapp_command_rev: Unmatched statements for next \\\n transaction\"\n | [ []; [ _ ] ], [ _ ] :: [ _; _ ] :: _ :: _ ->\n failwith\n \"group_by_zkapp_command_rev: Unmatched statements after next \\\n transaction\"\n | (_ :: _) :: _, ([] | [ _ ]) :: _ | (_ :: _ :: _) :: _, [ _; _ ] :: _ ->\n failwith\n \"group_by_zkapp_command_rev: Too few statements remaining for the \\\n current transaction\"\n | ([] | [ _ ]) :: [] :: _, _ ->\n failwith\n \"group_by_zkapp_command_rev: The next transaction has no \\\n zkapp_command\"\n | [] :: (_ :: _) :: _, _ :: ([] | [ _ ]) :: _\n | [] :: (_ :: _ :: _) :: _, _ :: [ _; _ ] :: _ ->\n failwith\n \"group_by_zkapp_command_rev: Too few statements remaining for the \\\n next transaction\"\n | [ _ ] :: (_ :: _) :: _, _ :: ([] | [ _ ]) :: _ ->\n failwith\n \"group_by_zkapp_command_rev: Too few statements remaining for the \\\n next transaction\"\n | [] :: [ _ ] :: (_ :: _) :: _, _ :: _ :: ([] | [ _ ]) :: _ ->\n failwith\n \"group_by_zkapp_command_rev: Too few statements remaining for the \\\n transaction after next\"\n | ([] | [ _ ]) :: (_ :: _) :: _, [ _ ] ->\n failwith\n \"group_by_zkapp_command_rev: No statements given for the next \\\n transaction\"\n | [] :: [ _ ] :: (_ :: _) :: _, [ _; _ :: _ :: _ ] ->\n failwith\n \"group_by_zkapp_command_rev: No statements given for transaction \\\n after next\"\n in\n group_by_zkapp_command_rev zkapp_account_updatess stmtss []\nend\n\n(*Transaction_snark.Zkapp_command_segment.Basic.t*)\ntype possible_segments = Proved | Signed_single | Signed_pair\n\nmodule Update_group = Make_update_group (struct\n type local_state = unit\n\n type global_state = unit\n\n type connecting_ledger_hash = unit\n\n type spec = possible_segments\n\n let zkapp_segment_of_controls controls : spec =\n match controls with\n | [ Control.Proof _ ] ->\n Proved\n | [ (Control.Signature _ | Control.None_given) ] ->\n Signed_single\n | [ Control.(Signature _ | None_given); Control.(Signature _ | None_given) ]\n ->\n Signed_pair\n | _ ->\n failwith \"zkapp_segment_of_controls: Unsupported combination\"\nend)\n\nlet zkapp_cost ~proof_segments ~signed_single_segments ~signed_pair_segments\n ~(genesis_constants : Genesis_constants.t) () =\n (*10.26*np + 10.08*n2 + 9.14*n1 < 69.45*)\n let proof_cost = genesis_constants.zkapp_proof_update_cost in\n let signed_pair_cost = genesis_constants.zkapp_signed_pair_update_cost in\n let signed_single_cost = genesis_constants.zkapp_signed_single_update_cost in\n Float.(\n (proof_cost * of_int proof_segments)\n + (signed_pair_cost * of_int signed_pair_segments)\n + (signed_single_cost * of_int signed_single_segments))\n\n(* Zkapp_command transactions are filtered using this predicate\n - when adding to the transaction pool\n - in incoming blocks\n*)\nlet valid_size ~(genesis_constants : Genesis_constants.t) (t : t) :\n unit Or_error.t =\n let events_elements events =\n List.fold events ~init:0 ~f:(fun acc event -> acc + Array.length event)\n in\n let all_updates, num_event_elements, num_action_elements =\n Call_forest.fold t.account_updates\n ~init:([ Account_update.of_fee_payer (fee_payer_account_update t) ], 0, 0)\n ~f:(fun (acc, num_event_elements, num_action_elements)\n (account_update : Account_update.t) ->\n let account_update_evs_elements =\n events_elements account_update.body.events\n in\n let account_update_seq_evs_elements =\n events_elements account_update.body.actions\n in\n ( account_update :: acc\n , num_event_elements + account_update_evs_elements\n , num_action_elements + account_update_seq_evs_elements ) )\n |> fun (updates, ev, sev) -> (List.rev updates, ev, sev)\n in\n let groups =\n Update_group.group_by_zkapp_command_rev [ t ]\n ( [ ((), (), ()) ]\n :: [ ((), (), ()) :: List.map all_updates ~f:(fun _ -> ((), (), ())) ] )\n in\n let proof_segments, signed_single_segments, signed_pair_segments =\n List.fold ~init:(0, 0, 0) groups\n ~f:(fun (proof_segments, signed_singles, signed_pairs) { spec; _ } ->\n match spec with\n | Proved ->\n (proof_segments + 1, signed_singles, signed_pairs)\n | Signed_single ->\n (proof_segments, signed_singles + 1, signed_pairs)\n | Signed_pair ->\n (proof_segments, signed_singles, signed_pairs + 1) )\n in\n let cost_limit = genesis_constants.zkapp_transaction_cost_limit in\n let max_event_elements = genesis_constants.max_event_elements in\n let max_action_elements = genesis_constants.max_action_elements in\n let zkapp_cost_within_limit =\n Float.(\n zkapp_cost ~proof_segments ~signed_single_segments ~signed_pair_segments\n ~genesis_constants ()\n < cost_limit)\n in\n let valid_event_elements = num_event_elements <= max_event_elements in\n let valid_action_elements = num_action_elements <= max_action_elements in\n if zkapp_cost_within_limit && valid_event_elements && valid_action_elements\n then Ok ()\n else\n let proof_zkapp_command_err =\n if zkapp_cost_within_limit then None\n else Some (sprintf \"zkapp transaction too expensive\")\n in\n let events_err =\n if valid_event_elements then None\n else\n Some\n (sprintf \"too many event elements (%d, max allowed is %d)\"\n num_event_elements max_event_elements )\n in\n let actions_err =\n if valid_action_elements then None\n else\n Some\n (sprintf \"too many sequence event elements (%d, max allowed is %d)\"\n num_action_elements max_action_elements )\n in\n let err_msg =\n List.filter\n [ proof_zkapp_command_err; events_err; actions_err ]\n ~f:Option.is_some\n |> List.map ~f:(fun opt -> Option.value_exn opt)\n |> String.concat ~sep:\"; \"\n in\n Error (Error.of_string err_msg)\n\nlet has_zero_vesting_period t =\n Call_forest.exists t.account_updates ~f:(fun p ->\n match p.body.update.timing with\n | Keep ->\n false\n | Set { vesting_period; _ } ->\n Mina_numbers.Global_slot_span.(equal zero) vesting_period )\n\nlet get_transaction_commitments (zkapp_command : t) =\n let memo_hash = Signed_command_memo.hash zkapp_command.memo in\n let fee_payer_hash =\n Account_update.of_fee_payer zkapp_command.fee_payer\n |> Digest.Account_update.create\n in\n let account_updates_hash = account_updates_hash zkapp_command in\n let txn_commitment = Transaction_commitment.create ~account_updates_hash in\n let full_txn_commitment =\n Transaction_commitment.create_complete txn_commitment ~memo_hash\n ~fee_payer_hash\n in\n (txn_commitment, full_txn_commitment)\n\nlet inner_query =\n lazy\n (Option.value_exn ~message:\"Invariant: All projectable derivers are Some\"\n Fields_derivers_zkapps.(inner_query (deriver @@ Derivers.o ())) )\n\nmodule For_tests = struct\n let replace_vks t vk =\n { t with\n account_updates =\n Call_forest.map t.account_updates ~f:(fun (p : Account_update.t) ->\n { p with\n body =\n { p.body with\n update =\n { p.body.update with\n verification_key =\n (* replace dummy vks in vk Setting *)\n ( match p.body.update.verification_key with\n | Set _vk ->\n Set vk\n | Keep ->\n Keep )\n }\n ; authorization_kind =\n (* replace dummy vk hashes in authorization kind *)\n ( match p.body.authorization_kind with\n | Proof _vk_hash ->\n Proof (With_hash.hash vk)\n | ak ->\n ak )\n }\n } )\n }\nend\n\nlet%test \"latest zkApp version\" =\n (* if this test fails, update `Transaction_hash.hash_of_transaction_id`\n for latest version, then update this test\n *)\n Stable.Latest.version = 1\n","open Core_kernel\n\nmodule Poly = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type ('u, 's) t =\n ('u, 's) Mina_wire_types.Mina_base.User_command.Poly.V2.t =\n | Signed_command of 'u\n | Zkapp_command of 's\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n end\n\n module V1 = struct\n type ('u, 's) t = Signed_command of 'u | Snapp_command of 's\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest : _ t -> _ V2.t = function\n | Signed_command x ->\n Signed_command x\n | Snapp_command _ ->\n failwith \"Snapp_command\"\n end\n end]\nend\n\ntype ('u, 's) t_ = ('u, 's) Poly.Stable.Latest.t =\n | Signed_command of 'u\n | Zkapp_command of 's\n\nmodule Gen_make (C : Signed_command_intf.Gen_intf) = struct\n let to_signed_command f =\n Quickcheck.Generator.map f ~f:(fun c -> Signed_command c)\n\n open C.Gen\n\n let payment ?sign_type ~key_gen ?nonce ~max_amount ~fee_range () =\n to_signed_command\n (payment ?sign_type ~key_gen ?nonce ~max_amount ~fee_range ())\n\n let payment_with_random_participants ?sign_type ~keys ?nonce ~max_amount\n ~fee_range () =\n to_signed_command\n (payment_with_random_participants ?sign_type ~keys ?nonce ~max_amount\n ~fee_range () )\n\n let stake_delegation ~key_gen ?nonce ~fee_range () =\n to_signed_command (stake_delegation ~key_gen ?nonce ~fee_range ())\n\n let stake_delegation_with_random_participants ~keys ?nonce ~fee_range () =\n to_signed_command\n (stake_delegation_with_random_participants ~keys ?nonce ~fee_range ())\n\n let sequence ?length ?sign_type a =\n Quickcheck.Generator.map\n (sequence ?length ?sign_type a)\n ~f:(List.map ~f:(fun c -> Signed_command c))\nend\n\nmodule Gen = Gen_make (Signed_command)\n\nlet gen_signed =\n let module G = Signed_command.Gen in\n let open Quickcheck.Let_syntax in\n let%bind keys =\n Quickcheck.Generator.list_with_length 2\n Mina_base_import.Signature_keypair.gen\n in\n G.payment_with_random_participants ~sign_type:`Real ~keys:(Array.of_list keys)\n ~max_amount:10000 ~fee_range:1000 ()\n\nlet gen = Gen.to_signed_command gen_signed\n\n[%%versioned\nmodule Stable = struct\n module V2 = struct\n type t =\n (Signed_command.Stable.V2.t, Zkapp_command.Stable.V1.t) Poly.Stable.V2.t\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n end\nend]\n\nlet to_base64 : t -> string = function\n | Signed_command sc ->\n Signed_command.to_base64 sc\n | Zkapp_command zc ->\n Zkapp_command.to_base64 zc\n\nlet of_base64 s : t Or_error.t =\n match Signed_command.of_base64 s with\n | Ok sc ->\n Ok (Signed_command sc)\n | Error err1 -> (\n match Zkapp_command.of_base64 s with\n | Ok zc ->\n Ok (Zkapp_command zc)\n | Error err2 ->\n Error\n (Error.of_string\n (sprintf\n \"Could decode Base64 neither to signed command (%s), nor to \\\n zkApp (%s)\"\n (Error.to_string_hum err1) (Error.to_string_hum err2) ) ) )\n\n(*\ninclude Allocation_functor.Make.Versioned_v1.Full_compare_eq_hash (struct\n let id = \"user_command\"\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t =\n (Signed_command.Stable.V1.t, Snapp_command.Stable.V1.t) Poly.Stable.V1.t\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n\n type 'a creator : Signed_command.t -> Snapp_command.t -> 'a\n\n let create cmd1 cmd2 = (cmd1, cmd2)\n end\n end]\nend)\n*)\n\nmodule Zero_one_or_two = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type 'a t = [ `Zero | `One of 'a | `Two of 'a * 'a ]\n [@@deriving sexp, compare, equal, hash, yojson]\n end\n end]\nend\n\nmodule Verifiable = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t =\n ( Signed_command.Stable.V2.t\n , Zkapp_command.Verifiable.Stable.V1.t )\n Poly.Stable.V2.t\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n let fee_payer (t : t) =\n match t with\n | Signed_command x ->\n Signed_command.fee_payer x\n | Zkapp_command p ->\n Account_update.Fee_payer.account_id p.fee_payer\nend\n\nlet to_verifiable (t : t) ~status ~find_vk : Verifiable.t Or_error.t =\n match t with\n | Signed_command c ->\n Ok (Signed_command c)\n | Zkapp_command cmd ->\n Zkapp_command.Verifiable.create ~status ~find_vk cmd\n |> Or_error.map ~f:(fun cmd -> Zkapp_command cmd)\n\nmodule Make_to_all_verifiable (Strategy : sig\n val create_all :\n Zkapp_command.t With_status.t list\n -> find_vk:\n ( Zkapp_basic.F.t\n -> Account_id.t\n -> (Verification_key_wire.t, Error.t) Result.t )\n -> Zkapp_command.Verifiable.t With_status.t list Or_error.t\nend) =\nstruct\n let to_all_verifiable (ts : t With_status.t list) ~find_vk :\n Verifiable.t With_status.t list Or_error.t =\n let open Or_error.Let_syntax in\n (* First we tag everything with its index *)\n let its = List.mapi ts ~f:(fun i x -> (i, x)) in\n (* then we partition out the zkapp commands *)\n let izk_cmds, is_cmds =\n List.partition_map its ~f:(fun (i, cmd) ->\n match cmd.data with\n | Zkapp_command c ->\n First (i, { cmd with data = c })\n | Signed_command c ->\n Second (i, { cmd with data = c }) )\n in\n (* then unzip the indices *)\n let ixs, zk_cmds = List.unzip izk_cmds in\n (* then we verify the zkapp commands *)\n let%map vzk_cmds = Strategy.create_all ~find_vk zk_cmds in\n (* rezip indices *)\n let ivzk_cmds = List.zip_exn ixs vzk_cmds in\n (* Put them back in with a sort by index (un-partition) *)\n let ivs =\n List.map is_cmds ~f:(fun (i, cmd) ->\n (i, { cmd with data = Signed_command cmd.data }) )\n @ List.map ivzk_cmds ~f:(fun (i, cmd) ->\n (i, { cmd with data = Zkapp_command cmd.data }) )\n |> List.sort ~compare:(fun (i, _) (j, _) -> i - j)\n in\n (* Drop the indices *)\n List.unzip ivs |> snd\nend\n\nmodule Any = struct\n include Make_to_all_verifiable (Zkapp_command.Verifiable.Any)\nend\n\nmodule Last = struct\n include Make_to_all_verifiable (Zkapp_command.Verifiable.Last)\nend\n\nlet of_verifiable (t : Verifiable.t) : t =\n match t with\n | Signed_command x ->\n Signed_command x\n | Zkapp_command p ->\n Zkapp_command (Zkapp_command.of_verifiable p)\n\nlet fee : t -> Currency.Fee.t = function\n | Signed_command x ->\n Signed_command.fee x\n | Zkapp_command p ->\n Zkapp_command.fee p\n\n(* for filtering *)\nlet minimum_fee = Currency.Fee.minimum_user_command_fee\n\nlet has_insufficient_fee t = Currency.Fee.(fee t < minimum_fee)\n\n(* always `Accessed` for fee payer *)\nlet accounts_accessed (t : t) (status : Transaction_status.t) :\n (Account_id.t * [ `Accessed | `Not_accessed ]) list =\n match t with\n | Signed_command x ->\n Signed_command.account_access_statuses x status\n | Zkapp_command ps ->\n Zkapp_command.account_access_statuses ps status\n\nlet accounts_referenced (t : t) =\n List.map (accounts_accessed t Applied) ~f:(fun (acct_id, _status) -> acct_id)\n\nlet fee_payer (t : t) =\n match t with\n | Signed_command x ->\n Signed_command.fee_payer x\n | Zkapp_command p ->\n Zkapp_command.fee_payer p\n\n(** The application nonce is the nonce of the fee payer at which a user command can be applied. *)\nlet applicable_at_nonce (t : t) =\n match t with\n | Signed_command x ->\n Signed_command.nonce x\n | Zkapp_command p ->\n Zkapp_command.applicable_at_nonce p\n\nlet expected_target_nonce t = Account.Nonce.succ (applicable_at_nonce t)\n\nlet extract_vks : t -> Verification_key_wire.t List.t = function\n | Signed_command _ ->\n []\n | Zkapp_command cmd ->\n Zkapp_command.extract_vks cmd\n\n(** The target nonce is what the nonce of the fee payer will be after a user command is successfully applied. *)\nlet target_nonce_on_success (t : t) =\n match t with\n | Signed_command x ->\n Account.Nonce.succ (Signed_command.nonce x)\n | Zkapp_command p ->\n Zkapp_command.target_nonce_on_success p\n\nlet fee_token (t : t) =\n match t with\n | Signed_command x ->\n Signed_command.fee_token x\n | Zkapp_command x ->\n Zkapp_command.fee_token x\n\nlet valid_until (t : t) =\n match t with\n | Signed_command x ->\n Signed_command.valid_until x\n | Zkapp_command { fee_payer; _ } -> (\n match fee_payer.Account_update.Fee_payer.body.valid_until with\n | Some valid_until ->\n valid_until\n | None ->\n Mina_numbers.Global_slot_since_genesis.max_value )\n\nmodule Valid = struct\n type t_ = t\n\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t =\n ( Signed_command.With_valid_signature.Stable.V2.t\n , Zkapp_command.Valid.Stable.V1.t )\n Poly.Stable.V2.t\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n module Gen = Gen_make (Signed_command.With_valid_signature)\nend\n\nlet check_verifiable (t : Verifiable.t) : Valid.t Or_error.t =\n match t with\n | Signed_command x -> (\n match Signed_command.check x with\n | Some c ->\n Ok (Signed_command c)\n | None ->\n Or_error.error_string \"Invalid signature\" )\n | Zkapp_command p ->\n Ok (Zkapp_command (Zkapp_command.Valid.of_verifiable p))\n\nlet check ~status ~find_vk (t : t) : Valid.t Or_error.t =\n to_verifiable ~status ~find_vk t |> Or_error.bind ~f:check_verifiable\n\nlet forget_check (t : Valid.t) : t =\n match t with\n | Zkapp_command x ->\n Zkapp_command (Zkapp_command.Valid.forget x)\n | Signed_command c ->\n Signed_command (c :> Signed_command.t)\n\nlet to_valid_unsafe (t : t) =\n `If_this_is_used_it_should_have_a_comment_justifying_it\n ( match t with\n | Zkapp_command x ->\n let (`If_this_is_used_it_should_have_a_comment_justifying_it x) =\n Zkapp_command.Valid.to_valid_unsafe x\n in\n Zkapp_command x\n | Signed_command x ->\n (* This is safe due to being immediately wrapped again. *)\n let (`If_this_is_used_it_should_have_a_comment_justifying_it x) =\n Signed_command.to_valid_unsafe x\n in\n Signed_command x )\n\nlet filter_by_participant (commands : t list) public_key =\n List.filter commands ~f:(fun user_command ->\n Core_kernel.List.exists\n (accounts_referenced user_command)\n ~f:\n (Fn.compose\n (Signature_lib.Public_key.Compressed.equal public_key)\n Account_id.public_key ) )\n\n(* A metric on user commands that should correspond roughly to resource costs\n for validation/application *)\nlet weight : t -> int = function\n | Signed_command signed_command ->\n Signed_command.payload signed_command |> Signed_command_payload.weight\n | Zkapp_command zkapp_command ->\n Zkapp_command.weight zkapp_command\n\n(* Fee per weight unit *)\nlet fee_per_wu (user_command : Stable.Latest.t) : Currency.Fee_rate.t =\n (*TODO: return Or_error*)\n Currency.Fee_rate.make_exn (fee user_command) (weight user_command)\n\nlet valid_size ~genesis_constants = function\n | Signed_command _ ->\n Ok ()\n | Zkapp_command zkapp_command ->\n Zkapp_command.valid_size ~genesis_constants zkapp_command\n\nlet has_zero_vesting_period = function\n | Signed_command _ ->\n false\n | Zkapp_command p ->\n Zkapp_command.has_zero_vesting_period p\n\nmodule Well_formedness_error = struct\n (* syntactically-evident errors such that a user command can never succeed *)\n type t =\n | Insufficient_fee\n | Zero_vesting_period\n | Zkapp_too_big of (Error.t[@to_yojson Error_json.error_to_yojson])\n [@@deriving compare, to_yojson]\n\n let to_string = function\n | Insufficient_fee ->\n \"Insufficient fee\"\n | Zero_vesting_period ->\n \"Zero vesting period\"\n | Zkapp_too_big err ->\n sprintf \"Zkapp too big (%s)\" (Error.to_string_hum err)\nend\n\nlet check_well_formedness ~genesis_constants t :\n (unit, Well_formedness_error.t list) result =\n let preds =\n let open Well_formedness_error in\n [ (has_insufficient_fee, Insufficient_fee)\n ; (has_zero_vesting_period, Zero_vesting_period)\n ]\n in\n let errs0 =\n List.fold preds ~init:[] ~f:(fun acc (f, err) ->\n if f t then err :: acc else acc )\n in\n let errs =\n match valid_size ~genesis_constants t with\n | Ok () ->\n errs0\n | Error err ->\n Zkapp_too_big err :: errs0\n in\n if List.is_empty errs then Ok () else Error errs\n","open Core_kernel\nopen Mina_base_import\n\n(** See documentation of the {!Mina_wire_types} library *)\nmodule Wire_types = Mina_wire_types.Mina_base.Fee_transfer\n\nmodule Make_sig (A : Wire_types.Types.S) = struct\n module type S =\n Fee_transfer_intf.Full\n with type Single.Stable.V2.t = A.Single.V2.t\n and type Stable.V2.t = A.V2.t\nend\n\nmodule Make_str (A : Wire_types.Concrete) = struct\n module Single = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t = A.Single.V2.t =\n { receiver_pk : Public_key.Compressed.Stable.V1.t\n ; fee : Currency.Fee.Stable.V1.t\n ; fee_token : Token_id.Stable.V2.t\n }\n [@@deriving sexp, compare, equal, yojson, hash]\n\n let to_latest = Fn.id\n\n let description = \"Fee transfer Single\"\n\n let version_byte = Base58_check.Version_bytes.fee_transfer_single\n end\n end]\n\n include Comparable.Make (Stable.Latest)\n module Base58_check = Codable.Make_base58_check (Stable.Latest)\n\n [%%define_locally\n Base58_check.(to_base58_check, of_base58_check, of_base58_check_exn)]\n\n let create ~receiver_pk ~fee ~fee_token = { receiver_pk; fee; fee_token }\n\n let receiver_pk { receiver_pk; _ } = receiver_pk\n\n let receiver { receiver_pk; fee_token; _ } =\n Account_id.create receiver_pk fee_token\n\n let fee { fee; _ } = fee\n\n let fee_token { fee_token; _ } = fee_token\n\n module Gen = struct\n let with_random_receivers ?(min_fee = 0) ~max_fee ~token keys :\n t Quickcheck.Generator.t =\n let open Quickcheck.Generator.Let_syntax in\n let%map receiver_pk =\n let open Signature_lib in\n Quickcheck_lib.of_array keys\n >>| fun keypair -> Public_key.compress keypair.Keypair.public_key\n and fee =\n Int.gen_incl min_fee max_fee >>| Currency.Fee.of_nanomina_int_exn\n and fee_token = token in\n { receiver_pk; fee; fee_token }\n end\n end\n\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t = Single.Stable.V2.t One_or_two.Stable.V1.t\n [@@deriving sexp, compare, equal, yojson, hash]\n\n let to_latest = Fn.id\n end\n end]\n\n type single = Single.t =\n { receiver_pk : Public_key.Compressed.t\n ; fee : Currency.Fee.t\n ; fee_token : Token_id.t\n }\n [@@deriving sexp, compare, yojson, hash]\n\n let to_singles = Fn.id\n\n let of_singles = function\n | `One _ as t ->\n Or_error.return t\n | `Two (one, two) as t ->\n if Token_id.equal one.fee_token two.fee_token then Or_error.return t\n else\n (* Necessary invariant for the transaction snark: we should never have\n fee excesses in multiple tokens simultaneously.\n *)\n Or_error.errorf\n !\"Cannot combine single fee transfers with incompatible tokens: \\\n %{sexp: Token_id.t} <> %{sexp: Token_id.t}\"\n one.fee_token two.fee_token\n\n let create one two =\n let singles =\n match two with None -> `One one | Some two -> `Two (one, two)\n in\n of_singles singles\n\n let create_single ~receiver_pk ~fee ~fee_token =\n `One (Single.create ~receiver_pk ~fee ~fee_token)\n\n include Comparable.Make (Stable.Latest)\n\n let fee_excess ft =\n ft\n |> One_or_two.map ~f:(fun { fee_token; fee; _ } ->\n (fee_token, Currency.Fee.Signed.(negate (of_unsigned fee))) )\n |> Fee_excess.of_one_or_two\n\n let receiver_pks t =\n One_or_two.to_list (One_or_two.map ~f:Single.receiver_pk t)\n\n let receivers t = One_or_two.to_list (One_or_two.map ~f:Single.receiver t)\n\n (* This must match [Transaction_union].\n TODO: enforce this.\n *)\n let fee_payer_pk ft =\n match ft with\n | `One ft ->\n Single.receiver_pk ft\n | `Two (_, ft) ->\n Single.receiver_pk ft\n\n let fee_token = Single.fee_token\n\n let fee_tokens = One_or_two.map ~f:Single.fee_token\n\n let map = One_or_two.map\n\n let fold = One_or_two.fold\n\n let to_list = One_or_two.to_list\n\n let to_numbered_list = One_or_two.to_numbered_list\nend\n\ninclude Wire_types.Make (Make_sig) (Make_str)\n","open Core_kernel\nopen Mina_base_import\n\n(** See documentation of the {!Mina_wire_types} library *)\nmodule Wire_types = Mina_wire_types.Mina_base.Coinbase_fee_transfer\n\nmodule Make_sig (A : Wire_types.Types.S) = struct\n module type S = Coinbase_fee_transfer_intf.Full with type Stable.V1.t = A.V1.t\nend\n\nmodule Make_str (A : Wire_types.Concrete) = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = A.V1.t =\n { receiver_pk : Public_key.Compressed.Stable.V1.t\n ; fee : Currency.Fee.Stable.V1.t\n }\n [@@deriving sexp, compare, equal, yojson, hash]\n\n let to_latest = Fn.id\n\n let description = \"Coinbase fee transfer\"\n\n let version_byte = Base58_check.Version_bytes.fee_transfer_single\n end\n end]\n\n let create ~receiver_pk ~fee = { receiver_pk; fee }\n\n include Comparable.Make (Stable.Latest)\n module Base58_check = Codable.Make_base58_check (Stable.Latest)\n\n [%%define_locally\n Base58_check.(to_base58_check, of_base58_check, of_base58_check_exn)]\n\n let receiver_pk { receiver_pk; _ } = receiver_pk\n\n let receiver { receiver_pk; _ } =\n Account_id.create receiver_pk Token_id.default\n\n let fee { fee; _ } = fee\n\n let to_fee_transfer { receiver_pk; fee } =\n Fee_transfer.Single.create ~receiver_pk ~fee ~fee_token:Token_id.default\n\n module Gen = struct\n let gen ?(min_fee = Currency.Fee.zero) max_fee : t Quickcheck.Generator.t =\n let open Quickcheck.Generator.Let_syntax in\n let%bind receiver_pk = Public_key.Compressed.gen in\n let%map fee = Currency.Fee.gen_incl min_fee max_fee in\n { receiver_pk; fee }\n\n let with_random_receivers ~keys ?(min_fee = Currency.Fee.zero)\n coinbase_amount : t Quickcheck.Generator.t =\n let open Quickcheck.Generator.Let_syntax in\n let max_fee = Currency.Amount.to_fee coinbase_amount in\n let%map receiver_pk =\n let open Signature_lib in\n Quickcheck_lib.of_array keys\n >>| fun keypair -> Public_key.compress keypair.Keypair.public_key\n and fee = Currency.Fee.gen_incl min_fee max_fee in\n { receiver_pk; fee }\n end\nend\n\ninclude Wire_types.Make (Make_sig) (Make_str)\n","open Core_kernel\nopen Mina_base_import\n\n(** See documentation of the {!Mina_wire_types} library *)\nmodule Wire_types = Mina_wire_types.Mina_base.Coinbase\n\nmodule Make_sig (A : Wire_types.Types.S) = struct\n module type S = Coinbase_intf.Full with type Stable.V1.t = A.V1.t\nend\n\nmodule Make_str (A : Wire_types.Concrete) = struct\n module Fee_transfer = Coinbase_fee_transfer\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = A.V1.t =\n { receiver : Public_key.Compressed.Stable.V1.t\n ; amount : Currency.Amount.Stable.V1.t\n ; fee_transfer : Fee_transfer.Stable.V1.t option\n }\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n\n let description = \"Coinbase\"\n\n let version_byte = Base58_check.Version_bytes.coinbase\n end\n end]\n\n module Base58_check = Codable.Make_base58_check (Stable.Latest)\n\n [%%define_locally\n Base58_check.(to_base58_check, of_base58_check, of_base58_check_exn)]\n\n let receiver_pk t = t.receiver\n\n let receiver t = Account_id.create t.receiver Token_id.default\n\n (* This must match [Transaction_union].\n TODO: enforce this.\n *)\n let fee_payer_pk cb =\n match cb.fee_transfer with None -> cb.receiver | Some ft -> ft.receiver_pk\n\n let amount t = t.amount\n\n let fee_transfer t = t.fee_transfer\n\n let account_access_statuses t (status : Transaction_status.t) =\n let access_status =\n match status with Applied -> `Accessed | Failed _ -> `Not_accessed\n in\n let account_ids =\n receiver t\n :: List.map ~f:Fee_transfer.receiver (Option.to_list t.fee_transfer)\n in\n List.map account_ids ~f:(fun acct_id -> (acct_id, access_status))\n\n let accounts_referenced t =\n List.map (account_access_statuses t Transaction_status.Applied)\n ~f:(fun (acct_id, _status) -> acct_id)\n\n let is_valid { amount; fee_transfer; _ } =\n match fee_transfer with\n | None ->\n true\n | Some { fee; _ } ->\n Currency.Amount.(of_fee fee <= amount)\n\n let create ~amount ~receiver ~fee_transfer =\n let t = { receiver; amount; fee_transfer } in\n if is_valid t then\n let adjusted_fee_transfer =\n Option.bind fee_transfer ~f:(fun fee_transfer ->\n Option.some_if\n (not\n (Public_key.Compressed.equal receiver\n (Fee_transfer.receiver_pk fee_transfer) ) )\n fee_transfer )\n in\n Ok { t with fee_transfer = adjusted_fee_transfer }\n else Or_error.error_string \"Coinbase.create: invalid coinbase\"\n\n let expected_supply_increase { receiver = _; amount; fee_transfer } =\n match fee_transfer with\n | None ->\n Ok amount\n | Some { fee; _ } ->\n Currency.Amount.sub amount (Currency.Amount.of_fee fee)\n |> Option.value_map\n ~f:(fun _ -> Ok amount)\n ~default:(Or_error.error_string \"Coinbase underflow\")\n\n let fee_excess t =\n Or_error.map (expected_supply_increase t) ~f:(fun _increase ->\n Fee_excess.empty )\n\n module Gen = struct\n let gen ~(constraint_constants : Genesis_constants.Constraint_constants.t) =\n let open Quickcheck.Let_syntax in\n let%bind receiver = Public_key.Compressed.gen in\n let%bind supercharged_coinbase = Quickcheck.Generator.bool in\n let%bind amount =\n let max_amount = constraint_constants.coinbase_amount in\n (* amount should be at least the account creation fee to pay for the creation of coinbase receiver and the fee transfer receiver below *)\n let min_amount =\n Option.value_exn\n (Currency.Fee.scale constraint_constants.account_creation_fee 2)\n |> Currency.Amount.of_fee\n in\n let%map amount = Currency.Amount.(gen_incl min_amount max_amount) in\n if supercharged_coinbase then\n Option.value_exn\n (Currency.Amount.scale amount\n constraint_constants.supercharged_coinbase_factor )\n else amount\n in\n (* keep account-creation fee for the coinbase-receiver *)\n let max_fee =\n Option.value_exn\n (Currency.Fee.sub\n (Currency.Amount.to_fee amount)\n constraint_constants.account_creation_fee )\n in\n let min_fee = constraint_constants.account_creation_fee in\n let%map fee_transfer =\n Option.quickcheck_generator (Fee_transfer.Gen.gen ~min_fee max_fee)\n in\n let fee_transfer =\n match fee_transfer with\n | Some { Fee_transfer.receiver_pk; _ }\n when Public_key.Compressed.equal receiver receiver_pk ->\n (* Erase fee transfer, to mirror [create]. *)\n None\n | _ ->\n fee_transfer\n in\n ( { receiver; amount; fee_transfer }\n , `Supercharged_coinbase supercharged_coinbase )\n\n let with_random_receivers ~keys ~min_amount ~max_amount ~fee_transfer =\n let open Quickcheck.Let_syntax in\n let%bind receiver =\n let open Signature_lib in\n Quickcheck_lib.of_array keys\n >>| fun keypair -> Public_key.compress keypair.Keypair.public_key\n and amount =\n Int.gen_incl min_amount max_amount\n >>| Currency.Amount.of_nanomina_int_exn\n in\n let%map fee_transfer =\n Option.quickcheck_generator (fee_transfer ~coinbase_amount:amount)\n in\n let fee_transfer =\n match fee_transfer with\n | Some { Fee_transfer.receiver_pk; _ }\n when Public_key.Compressed.equal receiver receiver_pk ->\n (* Erase fee transfer, to mirror [create]. *)\n None\n | _ ->\n fee_transfer\n in\n { receiver; amount; fee_transfer }\n end\nend\n\ninclude Wire_types.Make (Make_sig) (Make_str)\n","open Core_kernel\nopen Mina_base_import\nopen Snarky_backendless\nopen Snark_params\nopen Snark_params.Tick\nopen Let_syntax\nopen Currency\n\n(* A pending coinbase is basically a Merkle tree of \"stacks\", each of which contains two hashes. The first hash\n is computed from the components in the coinbase via a \"push\" operation. The second hash, a protocol\n state hash, is computed from the state *body* hash in the coinbase.\n The \"add_coinbase\" operation takes a coinbase, retrieves the latest stack, or creates a new one, and does\n a push.\n\n A pending coinbase also contains a stack id, used to determine the chronology of stacks, so we can know\n which is the oldest, and which is the newest stack.\n\n The name \"stack\" here is a misnomer: see issue #3226\n*)\nmodule Wire_types = Mina_wire_types.Mina_base.Pending_coinbase\n\nmodule Make_sig (A : Wire_types.Types.S) = struct\n module type S =\n Pending_coinbase_intf.S\n with type State_stack.Stable.V1.t = A.State_stack.V1.t\n and type Stack_versioned.Stable.V1.t = A.Stack_versioned.V1.t\n and type Hash.t = A.Hash_builder.V1.t\n and type Hash_versioned.Stable.V1.t = A.Hash_versioned.V1.t\nend\n\nmodule Make_str (A : Wire_types.Concrete) = struct\n module Coinbase_data = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Public_key.Compressed.Stable.V1.t * Amount.Stable.V1.t\n [@@deriving sexp, to_yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n let of_coinbase (cb : Coinbase.t) : t = (cb.receiver, cb.amount)\n\n type var = Public_key.Compressed.var * Amount.var\n\n let var_of_t ((public_key, amount) : t) =\n (Public_key.Compressed.var_of_t public_key, Amount.var_of_t amount)\n\n let to_input (pk, amount) =\n let open Random_oracle.Input.Chunked in\n List.reduce_exn ~f:append\n [ Public_key.Compressed.to_input pk; Amount.to_input amount ]\n\n module Checked = struct\n let to_input (public_key, amount) =\n let open Random_oracle.Input.Chunked in\n List.reduce_exn ~f:append\n [ Public_key.Compressed.Checked.to_input public_key\n ; Amount.var_to_input amount\n ]\n end\n\n let typ : (var, t) Typ.t =\n let of_hlist\n : 'public_key 'amount.\n (unit, 'public_key -> 'amount -> unit) H_list.t\n -> 'public_key * 'amount =\n let open H_list in\n fun [ public_key; amount ] -> (public_key, amount)\n in\n let to_hlist (public_key, amount) = H_list.[ public_key; amount ] in\n Typ.of_hlistable\n [ Public_key.Compressed.typ; Amount.typ ]\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist\n\n let empty = (Public_key.Compressed.empty, Amount.zero)\n\n let genesis = empty\n end\n\n module Stack_id : sig\n [%%versioned:\n module Stable : sig\n module V1 : sig\n type t [@@deriving sexp, yojson, compare, equal]\n end\n end]\n\n val of_int : int -> t\n\n val to_int : t -> int\n\n val zero : t\n\n val incr_by_one : t -> t Or_error.t\n\n val to_string : t -> string\n\n val ( > ) : t -> t -> bool\n end = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = int [@@deriving sexp, yojson, compare, equal]\n\n let to_latest = Fn.id\n end\n end]\n\n [%%define_locally Int.(( > ), to_string, zero, to_int, of_int, equal)]\n\n let incr_by_one t1 =\n let t2 = t1 + 1 in\n if t2 < t1 then Or_error.error_string \"Stack_id overflow\" else Ok t2\n end\n\n module type Data_hash_intf = sig\n type t = private Field.t [@@deriving sexp, compare, equal, yojson, hash]\n\n type var\n\n val var_of_t : t -> var\n\n val typ : (var, t) Typ.t\n\n val var_to_hash_packed : var -> Field.Var.t\n\n val equal_var : var -> var -> Boolean.var Tick.Checked.t\n\n val to_bytes : t -> string\n\n val to_bits : t -> bool list\n\n val to_base58_check : t -> string\n\n val of_base58_check_exn : string -> t\n\n val gen : t Quickcheck.Generator.t\n end\n\n (* a coinbase stack has two components, data and a state_hash\n we create modules for each component\n *)\n\n module Coinbase_stack = struct\n include Data_hash.Make_full_size (struct\n let description = \"Coinbase stack data\"\n\n let version_byte = Base58_check.Version_bytes.coinbase_stack_data\n end)\n\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n module T = struct\n type t = (Field.t[@version_asserted]) [@@deriving sexp, compare, hash]\n end\n\n include T\n\n let to_latest = Fn.id\n\n [%%define_from_scope to_yojson, of_yojson]\n\n include Comparable.Make (T)\n include Hashable.Make_binable (T)\n end\n end]\n\n let (_ : (t, Stable.Latest.t) Type_equal.t) = Type_equal.T\n\n let push (h : t) cb =\n let coinbase = Coinbase_data.of_coinbase cb in\n let open Random_oracle in\n hash ~init:Hash_prefix.coinbase_stack\n (pack_input\n (Input.Chunked.append (Coinbase_data.to_input coinbase) (to_input h)) )\n |> of_hash\n\n let empty = Random_oracle.salt \"CoinbaseStack\" |> Random_oracle.digest\n\n module Checked = struct\n type t = var\n\n let push (h : t) (cb : Coinbase_data.var) =\n let open Random_oracle.Checked in\n make_checked (fun () ->\n hash ~init:Hash_prefix.coinbase_stack\n (pack_input\n (Random_oracle.Input.Chunked.append\n (Coinbase_data.Checked.to_input cb)\n (var_to_input h) ) )\n |> var_of_hash_packed )\n\n let check_merge (_, t1) (s2, _) = equal_var t1 s2\n\n let if_ = if_\n end\n end\n\n module Stack_hash = struct\n include Data_hash.Make_full_size (struct\n let description = \"Coinbase stack hash\"\n\n let version_byte = Base58_check.Version_bytes.coinbase_stack_hash\n end)\n\n (* Data hash versioned boilerplate below *)\n\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n module T = struct\n type t = (Field.t[@version_asserted]) [@@deriving sexp, compare, hash]\n end\n\n include T\n\n let to_latest = Fn.id\n\n [%%define_from_scope to_yojson, of_yojson]\n\n include Comparable.Make (T)\n include Hashable.Make_binable (T)\n end\n end]\n\n let (_ : (t, Stable.Latest.t) Type_equal.t) = Type_equal.T\n\n let dummy = of_hash Outside_hash_image.t\n end\n\n (*Stack of protocol state body hashes*)\n module State_stack = struct\n module Poly = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type 'stack_hash t = 'stack_hash A.State_stack.Poly.V1.t =\n { init : 'stack_hash; curr : 'stack_hash }\n [@@deriving sexp, compare, hash, yojson, equal, hlist]\n end\n end]\n end\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Stack_hash.Stable.V1.t Poly.Stable.V1.t\n [@@deriving sexp, compare, hash, equal, yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n type var = Stack_hash.var Poly.t\n\n let gen : t Quickcheck.Generator.t =\n let open Quickcheck.Generator.Let_syntax in\n let%map init, curr =\n Quickcheck.Generator.tuple2 Stack_hash.gen Stack_hash.gen\n in\n { Poly.init; curr }\n\n let to_input (t : t) =\n Random_oracle.Input.Chunked.append\n (Stack_hash.to_input t.init)\n (Stack_hash.to_input t.curr)\n\n let var_to_input (t : var) =\n Random_oracle.Input.Chunked.append\n (Stack_hash.var_to_input t.init)\n (Stack_hash.var_to_input t.curr)\n\n let var_of_t (t : t) =\n { Poly.init = Stack_hash.var_of_t t.init\n ; curr = Stack_hash.var_of_t t.curr\n }\n\n let typ : (var, t) Typ.t =\n Snark_params.Tick.Typ.of_hlistable\n [ Stack_hash.typ; Stack_hash.typ ]\n ~var_to_hlist:Poly.to_hlist ~var_of_hlist:Poly.of_hlist\n ~value_to_hlist:Poly.to_hlist ~value_of_hlist:Poly.of_hlist\n\n let to_bits (t : t) = Stack_hash.to_bits t.init @ Stack_hash.to_bits t.curr\n\n let to_bytes (t : t) =\n Stack_hash.to_bytes t.init ^ Stack_hash.to_bytes t.curr\n\n let equal_var (v1 : var) (v2 : var) =\n let open Tick.Checked.Let_syntax in\n let%bind b1 = Stack_hash.equal_var v1.init v2.init in\n let%bind b2 = Stack_hash.equal_var v1.curr v2.curr in\n Boolean.(b1 && b2)\n\n let if_ (cond : Tick0.Boolean.var) ~(then_ : var) ~(else_ : var) :\n var Tick0.Checked.t =\n let%bind init = Stack_hash.if_ cond ~then_:then_.init ~else_:else_.init in\n let%map curr = Stack_hash.if_ cond ~then_:then_.curr ~else_:else_.curr in\n { Poly.init; curr }\n\n let push (t : t) (state_body_hash : State_body_hash.t)\n (global_slot : Mina_numbers.Global_slot_since_genesis.t) : t =\n (* this is the same computation for combining state hashes and state body hashes as\n `Protocol_state.hash_abstract', not available here because it would create\n a module dependency cycle\n *)\n { t with\n curr =\n Random_oracle.hash ~init:Hash_prefix.protocol_state\n [| (t.curr :> Field.t)\n ; (state_body_hash :> Field.t)\n ; Mina_numbers.Global_slot_since_genesis.to_field global_slot\n |]\n |> Stack_hash.of_hash\n }\n\n let empty : t = { Poly.init = Stack_hash.dummy; curr = Stack_hash.dummy }\n\n let create ~init = { Poly.init; curr = init }\n\n module Checked = struct\n type t = var\n\n let push (t : t) (state_body_hash : State_body_hash.var)\n (global_slot : Mina_numbers.Global_slot_since_genesis.Checked.var) =\n make_checked (fun () ->\n let curr =\n Random_oracle.Checked.hash ~init:Hash_prefix.protocol_state\n [| Stack_hash.var_to_hash_packed t.curr\n ; State_body_hash.var_to_hash_packed state_body_hash\n ; Mina_numbers.Global_slot_since_genesis.Checked.to_field\n global_slot\n |]\n |> Stack_hash.var_of_hash_packed\n in\n { t with curr } )\n\n let check_merge (s1, t1) (s2, t2) =\n (*state stacks are updated for every transaction in transaction snark but\n only once for every blockchain snark. Therefore, source stacks (and\n target stacks) will be equal for transactions in the same block*)\n let%bind eq_src = equal_var s1 s2\n and eq_target = equal_var t1 t2\n and correct_transition = equal_var t1 s2 in\n let%bind same_update = Boolean.(eq_src &&& eq_target) in\n Boolean.any [ same_update; correct_transition ]\n end\n end\n\n (* Pending coinbase hash *)\n module Hash_builder = struct\n include Data_hash.Make_full_size (struct\n let description = \"Pending coinbase hash builder\"\n\n let version_byte = Base58_check.Version_bytes.receipt_chain_hash\n end)\n\n (* Data hash versioned boilerplate below *)\n\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n module T = struct\n type t = (Field.t[@version_asserted]) [@@deriving sexp, compare, hash]\n end\n\n include T\n\n let to_latest = Fn.id\n\n [%%define_from_scope to_yojson, of_yojson]\n\n include Comparable.Make (T)\n include Hashable.Make_binable (T)\n end\n end]\n\n let (_ : (t, Stable.Latest.t) Type_equal.t) = Type_equal.T\n\n let merge ~height (h1 : t) (h2 : t) =\n Random_oracle.hash\n ~init:(Hash_prefix.coinbase_merkle_tree height)\n [| (h1 :> field); (h2 :> field) |]\n |> of_hash\n\n let empty_hash =\n Random_oracle.(digest (salt \"PendingCoinbaseMerkleTree\")) |> of_hash\n\n let of_digest = Fn.compose Fn.id of_hash\n end\n\n module Update = struct\n module Action = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t =\n | Update_none\n | Update_one\n | Update_two_coinbase_in_first\n | Update_two_coinbase_in_second\n [@@deriving equal, sexp, to_yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n type var = Boolean.var * Boolean.var\n\n let to_bits = function\n | Update_none ->\n (false, false)\n | Update_one ->\n (true, false)\n | Update_two_coinbase_in_first ->\n (false, true)\n | Update_two_coinbase_in_second ->\n (true, true)\n\n let of_bits = function\n | false, false ->\n Update_none\n | true, false ->\n Update_one\n | false, true ->\n Update_two_coinbase_in_first\n | true, true ->\n Update_two_coinbase_in_second\n\n let var_of_t t =\n let x, y = to_bits t in\n Boolean.(var_of_value x, var_of_value y)\n\n let typ =\n Typ.transport\n Typ.(Boolean.typ * Boolean.typ)\n ~there:to_bits ~back:of_bits\n\n module Checked = struct\n let no_update (b0, b1) = Boolean.((not b0) &&& not b1)\n\n let update_two_stacks_coinbase_in_first (b0, b1) =\n Boolean.((not b0) &&& b1)\n\n let update_two_stacks_coinbase_in_second (b0, b1) = Boolean.(b0 &&& b1)\n end\n end\n\n module Poly = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type ('action, 'coinbase_amount) t =\n { action : 'action; coinbase_amount : 'coinbase_amount }\n [@@deriving sexp, to_yojson, hlist]\n end\n end]\n end\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = (Action.Stable.V1.t, Amount.Stable.V1.t) Poly.Stable.V1.t\n [@@deriving sexp, to_yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n [%%define_locally Poly.(to_hlist, of_hlist)]\n\n type var = (Action.var, Amount.var) Poly.t\n\n let typ =\n let open Snark_params.Tick.Typ in\n of_hlistable ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist\n ~value_to_hlist:to_hlist ~value_of_hlist:of_hlist\n [ Action.typ; Amount.typ ]\n\n let genesis : t =\n { coinbase_amount = Currency.Amount.zero; action = Action.Update_none }\n\n let var_of_t (t : t) : var =\n { action = Action.var_of_t t.action\n ; coinbase_amount = Amount.var_of_t t.coinbase_amount\n }\n end\n\n (* Sparse_ledger.Make is applied more than once in the code, so\n it can't make assumptions about the internal structure of its module\n arguments. Therefore, for modules with a bin_io type passed to the functor,\n that type cannot be in a version module hierarchy. We build the required\n modules for Hash and Stack.\n *)\n\n module Stack_versioned = struct\n module Poly = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type ('data_stack, 'state_stack) t =\n ('data_stack, 'state_stack) A.Stack_versioned.Poly.V1.t =\n { data : 'data_stack; state : 'state_stack }\n [@@deriving yojson, hash, sexp, equal, compare]\n end\n end]\n end\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t =\n (Coinbase_stack.Stable.V1.t, State_stack.Stable.V1.t) Poly.Stable.V1.t\n [@@deriving equal, yojson, hash, sexp, compare]\n\n let to_latest = Fn.id\n end\n end]\n end\n\n module Hash_versioned = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Hash_builder.Stable.V1.t\n [@@deriving equal, compare, sexp, yojson, hash]\n\n let to_latest = Fn.id\n end\n end]\n end\n\n module Merkle_tree_versioned = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t =\n ( Hash_versioned.Stable.V1.t\n , Stack_id.Stable.V1.t\n , Stack_versioned.Stable.V1.t )\n Sparse_ledger_lib.Sparse_ledger.T.Stable.V2.t\n [@@deriving sexp, to_yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n let (_ :\n ( t\n , ( Hash_versioned.t\n , Stack_id.t\n , Stack_versioned.t )\n Sparse_ledger_lib.Sparse_ledger.T.t )\n Type_equal.t ) =\n Type_equal.T\n end\n\n module T = struct\n (* Total number of stacks *)\n let max_coinbase_stack_count ~depth = Int.pow 2 depth\n\n let chain if_ b ~then_ ~else_ =\n let%bind then_ = then_ and else_ = else_ in\n if_ b ~then_ ~else_\n\n (*pair of coinbase and state stacks*)\n module Stack = struct\n module Poly = struct\n type ('data_stack, 'state_stack) t =\n ('data_stack, 'state_stack) Stack_versioned.Poly.t =\n { data : 'data_stack; state : 'state_stack }\n [@@deriving yojson, hash, sexp, compare, hlist]\n end\n\n type t = Stack_versioned.t [@@deriving yojson, equal, compare, sexp, hash]\n\n let (_ : (t, (Coinbase_stack.t, State_stack.t) Poly.t) Type_equal.t) =\n Type_equal.T\n\n type var = (Coinbase_stack.var, State_stack.var) Poly.t\n\n let to_input ({ data; state } : t) =\n Random_oracle.Input.Chunked.append\n (Coinbase_stack.to_input data)\n (State_stack.to_input state)\n\n let data_hash t =\n Random_oracle.(\n hash ~init:Hash_prefix_states.coinbase_stack (pack_input (to_input t)))\n |> Hash_builder.of_digest\n\n let var_to_input ({ data; state } : var) =\n Random_oracle.Input.Chunked.append\n (Coinbase_stack.var_to_input data)\n (State_stack.var_to_input state)\n\n let hash_var (t : var) =\n make_checked (fun () ->\n Random_oracle.Checked.(\n hash ~init:Hash_prefix_states.coinbase_stack\n (pack_input (var_to_input t))) )\n\n let var_of_t t =\n { Poly.data = Coinbase_stack.var_of_t t.Poly.data\n ; state = State_stack.var_of_t t.state\n }\n\n let gen =\n let open Base_quickcheck.Generator.Let_syntax in\n let%bind data = Coinbase_stack.gen in\n let%map state = State_stack.gen in\n { Poly.data; state }\n\n let typ : (var, t) Typ.t =\n Snark_params.Tick.Typ.of_hlistable\n [ Coinbase_stack.typ; State_stack.typ ]\n ~var_to_hlist:Poly.to_hlist ~var_of_hlist:Poly.of_hlist\n ~value_to_hlist:Poly.to_hlist ~value_of_hlist:Poly.of_hlist\n\n let num_pad_bits =\n let len = List.length Coinbase_stack.(to_bits empty) in\n (3 - (len mod 3)) mod 3\n\n (* pad to match the triple representation *)\n let pad_bits = List.init num_pad_bits ~f:(fun _ -> false)\n\n let to_bits t =\n Coinbase_stack.to_bits t.Poly.data\n @ pad_bits\n @ State_stack.to_bits t.Poly.state\n\n let to_bytes t =\n Coinbase_stack.to_bytes t.Poly.data ^ State_stack.to_bytes t.Poly.state\n\n let equal_var var1 var2 =\n let open Tick.Checked.Let_syntax in\n let%bind b1 = Coinbase_stack.equal_var var1.Poly.data var2.Poly.data in\n let%bind b2 = State_stack.equal_var var1.Poly.state var2.Poly.state in\n let open Tick0.Boolean in\n b1 &&& b2\n\n let empty =\n { Poly.data = Coinbase_stack.empty; state = State_stack.empty }\n\n let create_with (t : t) =\n { empty with state = State_stack.create ~init:t.state.curr }\n\n let equal_state_hash t1 t2 = State_stack.equal t1.Poly.state t2.Poly.state\n\n let equal_data t1 t2 = Coinbase_stack.equal t1.Poly.data t2.Poly.data\n\n let connected ?(prev : t option = None) ~first ~second () =\n let coinbase_stack_connected =\n (*same as old stack or second could be a new stack with empty data*)\n equal_data first second\n || Coinbase_stack.(equal empty second.Poly.data)\n in\n let state_stack_connected =\n (*1. same as old stack or\n 2. new stack initialized with the stack state of last block. Not possible to know this unless we track all the stack states because they are updated once per block (init=curr)\n 3. [second] could be a new stack initialized with the latest state of [first] or\n 4. [second] starts from the previous state of [first]. This is not available in either [first] or [second] *)\n equal_state_hash first second\n || Stack_hash.equal second.state.init second.state.curr\n || Stack_hash.equal first.state.curr second.state.curr\n || Option.value_map prev ~default:true ~f:(fun prev ->\n Stack_hash.equal prev.state.curr second.state.curr )\n in\n coinbase_stack_connected && state_stack_connected\n\n let push_coinbase (cb : Coinbase.t) t =\n let data = Coinbase_stack.push t.Poly.data cb in\n { t with data }\n\n let push_state (state_body_hash : State_body_hash.t)\n (global_slot : Mina_numbers.Global_slot_since_genesis.t) (t : t) =\n { t with state = State_stack.push t.state state_body_hash global_slot }\n\n let if_ (cond : Tick0.Boolean.var) ~(then_ : var) ~(else_ : var) :\n var Tick0.Checked.t =\n let%bind data =\n Coinbase_stack.Checked.if_ cond ~then_:then_.data ~else_:else_.data\n in\n let%map state =\n State_stack.if_ cond ~then_:then_.state ~else_:else_.state\n in\n { Poly.data; state }\n\n module Checked = struct\n type t = var\n\n let push_coinbase (coinbase : Coinbase_data.var) (t : t) :\n t Tick0.Checked.t =\n let%map data = Coinbase_stack.Checked.push t.data coinbase in\n { t with data }\n\n let push_state (state_body_hash : State_body_hash.var)\n (global_slot : Mina_numbers.Global_slot_since_genesis.Checked.var)\n (t : t) =\n let%map state =\n State_stack.Checked.push t.state state_body_hash global_slot\n in\n { t with state }\n\n let check_merge ~transition1:((s, t) : t * t)\n ~transition2:((s', t') : t * t) : Boolean.var Tick0.Checked.t =\n let%bind valid_coinbase_stacks =\n Coinbase_stack.Checked.check_merge (s.data, t.data)\n (s'.data, t'.data)\n in\n let%bind valid_state_stacks =\n State_stack.Checked.check_merge (s.state, t.state)\n (s'.state, t'.state)\n in\n Boolean.(valid_coinbase_stacks && valid_state_stacks)\n\n let empty = var_of_t empty\n\n let create_with (t : var) =\n { empty with state = State_stack.create ~init:t.state.init }\n\n let if_ = if_\n end\n end\n\n module Hash = struct\n type t = Hash_builder.t constraint t = Hash_versioned.t\n [@@deriving equal, compare, sexp, yojson, hash]\n\n type var = Hash_builder.var\n\n [%%define_locally\n Hash_builder.\n ( of_digest\n , merge\n , empty_hash\n , gen\n , to_bits\n , to_bytes\n , equal_var\n , var_of_t\n , var_of_hash_packed\n , var_to_hash_packed\n , to_base58_check\n , of_base58_check_exn\n , typ )]\n end\n\n module Merkle_tree = struct\n type t = Merkle_tree_versioned.t [@@deriving sexp, to_yojson]\n\n let (_ :\n ( t\n , (Hash.t, Stack_id.t, Stack.t) Sparse_ledger_lib.Sparse_ledger.T.t\n )\n Type_equal.t ) =\n Type_equal.T\n\n module M = Sparse_ledger_lib.Sparse_ledger.Make (Hash) (Stack_id) (Stack)\n\n [%%define_locally\n M.\n ( of_hash\n , get_exn\n , path_exn\n , set_exn\n , find_index_exn\n , add_path\n , merkle_root )]\n end\n\n module Checked = struct\n type var = Hash.var\n\n module Merkle_tree =\n Snarky_backendless.Merkle_tree.Checked\n (Tick)\n (struct\n type value = Field.t\n\n type var = Field.Var.t\n\n let typ = Field.typ\n\n let merge ~height h1 h2 =\n Tick.make_checked (fun () ->\n Random_oracle.Checked.hash\n ~init:(Hash_prefix.coinbase_merkle_tree height)\n [| h1; h2 |] )\n\n let assert_equal h1 h2 = Field.Checked.Assert.equal h1 h2\n\n let if_ = Field.Checked.if_\n end)\n (struct\n include Stack\n\n type value = t [@@deriving sexp]\n\n let hash var = hash_var var\n end)\n\n module Path = Merkle_tree.Path\n\n type path = Path.value\n\n module Address = struct\n include Merkle_tree.Address\n end\n\n type _ Request.t +=\n | Coinbase_stack_path : Address.value -> path Request.t\n | Get_coinbase_stack : Address.value -> (Stack.t * path) Request.t\n | Set_coinbase_stack : Address.value * Stack.t -> unit Request.t\n | Set_oldest_coinbase_stack : Address.value * Stack.t -> unit Request.t\n | Find_index_of_newest_stacks :\n Update.Action.t\n -> (Address.value * Address.value) Request.t\n | Find_index_of_oldest_stack : Address.value Request.t\n | Get_previous_stack : State_stack.t Request.t\n\n let reraise_merkle_requests (With { request; respond }) =\n match request with\n | Merkle_tree.Get_path addr ->\n respond (Delegate (Coinbase_stack_path addr))\n | Merkle_tree.Set (addr, stack) ->\n respond (Delegate (Set_coinbase_stack (addr, stack)))\n | Merkle_tree.Get_element addr ->\n respond (Delegate (Get_coinbase_stack addr))\n | _ ->\n unhandled\n\n let get ~depth t addr =\n handle\n (fun () -> Merkle_tree.get_req ~depth (Hash.var_to_hash_packed t) addr)\n reraise_merkle_requests\n\n let%snarkydef_ add_coinbase\n ~(constraint_constants : Genesis_constants.Constraint_constants.t) t\n ({ action; coinbase_amount = amount } : Update.var) ~coinbase_receiver\n ~supercharge_coinbase state_body_hash global_slot =\n let depth = constraint_constants.pending_coinbase_depth in\n let%bind addr1, addr2 =\n request_witness\n Typ.(Address.typ ~depth * Address.typ ~depth)\n As_prover.(\n map (read Update.Action.typ action) ~f:(fun act ->\n Find_index_of_newest_stacks act ))\n in\n let equal_to_zero x = Amount.(equal_var x (var_of_t zero)) in\n let%bind no_update = Update.Action.Checked.no_update action in\n let update_state_stack (stack : Stack.var) =\n (*get previous stack to carry-forward the stack of state body hashes*)\n let%bind previous_state_stack =\n request_witness State_stack.typ\n As_prover.(map (return ()) ~f:(fun () -> Get_previous_stack))\n in\n let stack_initialized = { stack with state = previous_state_stack } in\n let%bind stack_with_state_hash =\n Stack.Checked.push_state state_body_hash global_slot\n stack_initialized\n in\n (*Always update the state body hash unless there are no transactions in this block*)\n Stack.Checked.if_ no_update ~then_:stack ~else_:stack_with_state_hash\n in\n let update_stack1 stack =\n let%bind stack = update_state_stack stack in\n let%bind total_coinbase_amount =\n let coinbase_amount =\n Currency.Amount.var_of_t constraint_constants.coinbase_amount\n in\n let supercharged_coinbase =\n let amt =\n Option.value_exn\n (Currency.Amount.scale constraint_constants.coinbase_amount\n constraint_constants.supercharged_coinbase_factor )\n in\n Currency.Amount.var_of_t amt\n in\n Currency.Amount.Checked.if_ supercharge_coinbase\n ~then_:supercharged_coinbase ~else_:coinbase_amount\n in\n let%bind rem_amount =\n Currency.Amount.Checked.sub total_coinbase_amount amount\n in\n let%bind no_coinbase_in_this_stack =\n Update.Action.Checked.update_two_stacks_coinbase_in_second action\n in\n let%bind amount1_equal_to_zero = equal_to_zero amount in\n let%bind amount2_equal_to_zero = equal_to_zero rem_amount in\n (*if no update then coinbase amount has to be zero*)\n let%bind () =\n with_label __LOC__ (fun () ->\n let%bind check =\n Boolean.equal no_update amount1_equal_to_zero\n in\n Boolean.Assert.is_true check )\n in\n let%bind no_coinbase =\n Boolean.(no_update ||| no_coinbase_in_this_stack)\n in\n (* TODO: Optimize here since we are pushing twice to the same stack *)\n let%bind stack_with_amount1 =\n Stack.Checked.push_coinbase (coinbase_receiver, amount) stack\n in\n let%bind stack_with_amount2 =\n Stack.Checked.push_coinbase\n (coinbase_receiver, rem_amount)\n stack_with_amount1\n in\n chain Stack.if_ no_coinbase ~then_:(return stack)\n ~else_:\n (Stack.if_ amount2_equal_to_zero ~then_:stack_with_amount1\n ~else_:stack_with_amount2 )\n in\n (*This is for the second stack for when transactions in a block occupy\n two trees of the scan state; the second tree will carry-forward the state\n stack from the previous block, push the new state, and may or may not have a coinbase*)\n let update_stack2 (init_stack : Stack.var) (stack0 : Stack.var) =\n let%bind add_coinbase =\n Update.Action.Checked.update_two_stacks_coinbase_in_second action\n in\n let%bind update_state =\n let%bind update_second_stack =\n Update.Action.Checked.update_two_stacks_coinbase_in_first action\n in\n Boolean.(update_second_stack ||| add_coinbase)\n in\n let%bind stack =\n let%bind stack_with_state =\n Stack.Checked.push_state state_body_hash global_slot\n { stack0 with\n state =\n State_stack.create ~init:init_stack.Stack.Poly.state.curr\n }\n in\n Stack.if_ update_state ~then_:stack_with_state ~else_:stack0\n in\n let%bind stack_with_coinbase =\n Stack.Checked.push_coinbase (coinbase_receiver, amount) stack\n in\n Stack.if_ add_coinbase ~then_:stack_with_coinbase ~else_:stack\n in\n (*update the first stack*)\n let%bind root', `Old prev, `New _updated_stack1 =\n handle\n (fun () ->\n Merkle_tree.fetch_and_update_req ~depth\n (Hash.var_to_hash_packed t)\n addr1 ~f:update_stack1 )\n reraise_merkle_requests\n in\n (*update the second stack*)\n let%map root, _, _ =\n handle\n (fun () ->\n Merkle_tree.fetch_and_update_req ~depth root' addr2\n ~f:(update_stack2 prev) )\n reraise_merkle_requests\n in\n Hash.var_of_hash_packed root\n\n let%snarkydef_ pop_coinbases\n ~(constraint_constants : Genesis_constants.Constraint_constants.t) t\n ~proof_emitted =\n let depth = constraint_constants.pending_coinbase_depth in\n let%bind addr =\n request_witness (Address.typ ~depth)\n As_prover.(map (return ()) ~f:(fun _ -> Find_index_of_oldest_stack))\n in\n let%bind prev, prev_path =\n request_witness\n Typ.(Stack.typ * Path.typ ~depth)\n As_prover.(\n map\n (read (Address.typ ~depth) addr)\n ~f:(fun a -> Get_coinbase_stack a))\n in\n let stack_hash = Stack.hash_var in\n let%bind prev_entry_hash = stack_hash prev in\n let%bind () =\n Merkle_tree.implied_root prev_entry_hash addr prev_path\n >>= Field.Checked.Assert.equal (Hash.var_to_hash_packed t)\n in\n let%bind next =\n Stack.if_ proof_emitted ~then_:Stack.Checked.empty ~else_:prev\n in\n let%bind next_entry_hash = stack_hash next in\n let%bind () =\n perform\n (let open As_prover in\n let open Let_syntax in\n let%map addr = read (Address.typ ~depth) addr\n and next = read Stack.typ next in\n Set_oldest_coinbase_stack (addr, next))\n in\n let%map new_root =\n Merkle_tree.implied_root next_entry_hash addr prev_path\n in\n (Hash.var_of_hash_packed new_root, prev)\n end\n\n module Poly = struct\n type ('tree, 'stack_id) t = ('tree, 'stack_id) A.Poly.t =\n { tree : 'tree; pos_list : 'stack_id list; new_pos : 'stack_id }\n [@@deriving sexp, to_yojson]\n end\n\n type t = (Merkle_tree.t, Stack_id.t) Poly.t [@@deriving sexp, to_yojson]\n\n let init_hash = Stack.data_hash Stack.empty\n\n let hash_at_level =\n let cached = ref [| init_hash |] in\n fun i ->\n let len = Array.length !cached in\n ( if i >= len then\n let cur_hash = ref (Array.last !cached) in\n cached :=\n Array.append !cached\n (Array.init\n (i + 1 - len)\n ~f:(fun i ->\n cur_hash :=\n Hash.merge ~height:(i + len - 1) !cur_hash !cur_hash ;\n !cur_hash ) ) ) ;\n !cached.(i)\n\n let create_exn' ~depth () =\n let rec create_path height path key =\n if height < 0 then path\n else\n let hash = hash_at_level height in\n create_path (height - 1)\n ((if key mod 2 = 0 then `Left hash else `Right hash) :: path)\n (key / 2)\n in\n let rec make_tree t key =\n if Stack_id.( > ) key (Stack_id.of_int @@ (Int.pow 2 depth - 1)) then t\n else\n let path = create_path (depth - 1) [] (Stack_id.to_int key) in\n make_tree\n (Merkle_tree.add_path t path key Stack.empty)\n (Or_error.ok_exn (Stack_id.incr_by_one key))\n in\n let root_hash = hash_at_level depth in\n { Poly.tree =\n make_tree (Merkle_tree.of_hash ~depth root_hash) Stack_id.zero\n ; pos_list = []\n ; new_pos = Stack_id.zero\n }\n\n [%%define_locally Or_error.(try_with)]\n\n let create ~depth () = try_with (fun () -> create_exn' ~depth ())\n\n let merkle_root (t : t) = Merkle_tree.merkle_root t.tree\n\n let get_stack (t : t) index =\n try_with (fun () -> Merkle_tree.get_exn t.tree index)\n\n let path (t : t) index =\n try_with (fun () -> Merkle_tree.path_exn t.tree index)\n\n let find_index (t : t) key =\n try_with (fun () -> Merkle_tree.find_index_exn t.tree key)\n\n let next_index ~depth (t : t) =\n if\n Stack_id.equal t.new_pos\n (Stack_id.of_int (max_coinbase_stack_count ~depth - 1))\n then Ok Stack_id.zero\n else Stack_id.incr_by_one t.new_pos\n\n let next_stack_id ~depth t ~is_new_stack =\n if is_new_stack then next_index ~depth t else Ok t.new_pos\n\n let incr_index ~depth (t : t) ~is_new_stack =\n let open Or_error.Let_syntax in\n if is_new_stack then\n let%map new_pos = next_index ~depth t in\n { t with pos_list = t.new_pos :: t.pos_list; new_pos }\n else Ok t\n\n let set_stack ~depth (t : t) index stack ~is_new_stack =\n let open Or_error.Let_syntax in\n let%bind tree =\n try_with (fun () -> Merkle_tree.set_exn t.tree index stack)\n in\n incr_index ~depth { t with tree } ~is_new_stack\n\n let latest_stack_id (t : t) ~is_new_stack =\n if is_new_stack then t.new_pos\n else match List.hd t.pos_list with Some x -> x | None -> Stack_id.zero\n\n let curr_stack_id (t : t) = List.hd t.pos_list\n\n let current_stack t =\n let prev_stack_id =\n Option.value ~default:Stack_id.zero (curr_stack_id t)\n in\n Or_error.try_with (fun () ->\n let index = Merkle_tree.find_index_exn t.tree prev_stack_id in\n Merkle_tree.get_exn t.tree index )\n\n let latest_stack (t : t) ~is_new_stack =\n let open Or_error.Let_syntax in\n let key = latest_stack_id t ~is_new_stack in\n let%bind res =\n Or_error.try_with (fun () ->\n let index = Merkle_tree.find_index_exn t.tree key in\n Merkle_tree.get_exn t.tree index )\n in\n if is_new_stack then\n let%map prev_stack = current_stack t in\n { res with state = State_stack.create ~init:prev_stack.state.curr }\n else Ok res\n\n let oldest_stack_id (t : t) = List.last t.pos_list\n\n let remove_oldest_stack_id t =\n match List.rev t with\n | [] ->\n Or_error.error_string \"No coinbase stack-with-state-hash to pop\"\n | x :: xs ->\n Ok (x, List.rev xs)\n\n let oldest_stack t =\n let open Or_error.Let_syntax in\n let key = Option.value ~default:Stack_id.zero (oldest_stack_id t) in\n let%bind index = find_index t key in\n get_stack t index\n\n let update_stack' ~depth t ~(f : Stack.t -> Stack.t) ~is_new_stack =\n let open Or_error.Let_syntax in\n let key = latest_stack_id t ~is_new_stack in\n let%bind stack_index = find_index t key in\n let%bind stack_before = get_stack t stack_index in\n let stack_after = f stack_before in\n (* state hash in \"after\" stack becomes previous state hash at top level *)\n set_stack ~depth t stack_index stack_after ~is_new_stack\n\n let add_coinbase ~depth t ~coinbase ~is_new_stack =\n update_stack' ~depth t ~f:(Stack.push_coinbase coinbase) ~is_new_stack\n\n let add_state ~depth t state_body_hash global_slot ~is_new_stack =\n update_stack' ~depth t\n ~f:(Stack.push_state state_body_hash global_slot)\n ~is_new_stack\n\n let update_coinbase_stack ~depth (t : t) stack ~is_new_stack =\n update_stack' ~depth t ~f:(fun _ -> stack) ~is_new_stack\n\n let remove_coinbase_stack ~depth (t : t) =\n let open Or_error.Let_syntax in\n let%bind oldest_stack, remaining = remove_oldest_stack_id t.pos_list in\n let%bind stack_index = find_index t oldest_stack in\n let%bind stack = get_stack t stack_index in\n let%map t' =\n set_stack ~depth t stack_index Stack.empty ~is_new_stack:false\n in\n (stack, { t' with pos_list = remaining })\n\n let hash_extra ({ pos_list; new_pos; _ } : t) =\n let h = Digestif.SHA256.init () in\n let h =\n Digestif.SHA256.feed_string h\n (List.fold pos_list ~init:\"\" ~f:(fun s a -> s ^ Stack_id.to_string a))\n in\n let h = Digestif.SHA256.feed_string h (Stack_id.to_string new_pos) in\n Digestif.SHA256.(get h |> to_raw_string)\n\n let handler ~depth (t : t) ~is_new_stack =\n let pending_coinbase = ref t in\n let coinbase_stack_path_exn idx =\n List.map\n (path !pending_coinbase idx |> Or_error.ok_exn)\n ~f:(function `Left h -> h | `Right h -> h)\n in\n stage (fun (With { request; respond }) ->\n match request with\n | Checked.Coinbase_stack_path idx ->\n let path =\n (coinbase_stack_path_exn idx :> Random_oracle.Digest.t list)\n in\n respond (Provide path)\n | Checked.Find_index_of_oldest_stack ->\n let stack_id =\n Option.value ~default:Stack_id.zero\n (oldest_stack_id !pending_coinbase)\n in\n let index =\n find_index !pending_coinbase stack_id |> Or_error.ok_exn\n in\n respond (Provide index)\n | Checked.Find_index_of_newest_stacks _action ->\n let index1 =\n let stack_id =\n latest_stack_id !pending_coinbase ~is_new_stack\n in\n find_index !pending_coinbase stack_id |> Or_error.ok_exn\n in\n let index2 =\n let stack_id =\n match\n next_stack_id ~depth !pending_coinbase ~is_new_stack\n with\n | Ok id ->\n id\n | _ ->\n Stack_id.zero\n in\n find_index !pending_coinbase stack_id |> Or_error.ok_exn\n in\n respond @@ Provide (index1, index2)\n | Checked.Get_coinbase_stack idx ->\n let elt = get_stack !pending_coinbase idx |> Or_error.ok_exn in\n let path =\n (coinbase_stack_path_exn idx :> Random_oracle.Digest.t list)\n in\n respond (Provide (elt, path))\n | Checked.Set_coinbase_stack (idx, stack) ->\n pending_coinbase :=\n set_stack ~depth !pending_coinbase idx stack ~is_new_stack\n |> Or_error.ok_exn ;\n respond (Provide ())\n | Checked.Set_oldest_coinbase_stack (idx, stack) ->\n pending_coinbase :=\n set_stack ~depth !pending_coinbase idx stack ~is_new_stack:false\n |> Or_error.ok_exn ;\n respond (Provide ())\n | Checked.Get_previous_stack ->\n let prev_state =\n if is_new_stack then\n let stack =\n current_stack !pending_coinbase |> Or_error.ok_exn\n in\n { State_stack.Poly.init = stack.state.curr\n ; curr = stack.state.curr\n }\n else\n let stack =\n latest_stack !pending_coinbase ~is_new_stack\n |> Or_error.ok_exn\n in\n stack.state\n in\n respond (Provide prev_state)\n | _ ->\n unhandled )\n end\n\n include T\n\n module Poly_versioned = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type ('tree, 'stack_id) t = ('tree, 'stack_id) T.Poly.t =\n { tree : 'tree; pos_list : 'stack_id list; new_pos : 'stack_id }\n [@@deriving sexp, to_yojson]\n end\n end]\n end\n\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V2 = struct\n type t =\n ( Merkle_tree_versioned.Stable.V2.t\n , Stack_id.Stable.V1.t )\n Poly_versioned.Stable.V1.t\n [@@deriving sexp, to_yojson]\n\n let (_ : (t, T.t) Type_equal.t) = Type_equal.T\n\n let to_latest = Fn.id\n end\n end]\n\n let (_ : (t, Stable.Latest.t) Type_equal.t) = Type_equal.T\n\n let%test_unit \"add stack + remove stack = initial tree \" =\n let constraint_constants =\n Genesis_constants.Constraint_constants.for_unit_tests\n in\n let depth = constraint_constants.pending_coinbase_depth in\n let coinbases_gen =\n Quickcheck.Generator.list_non_empty\n (Coinbase.Gen.gen ~constraint_constants)\n in\n let pending_coinbases = ref (create ~depth () |> Or_error.ok_exn) in\n Quickcheck.test coinbases_gen ~trials:50 ~f:(fun cbs ->\n Run_in_thread.block_on_async_exn (fun () ->\n let is_new_stack = ref true in\n let init = merkle_root !pending_coinbases in\n let after_adding =\n List.fold cbs ~init:!pending_coinbases\n ~f:(fun acc (coinbase, _) ->\n let t =\n add_coinbase ~depth acc ~coinbase\n ~is_new_stack:!is_new_stack\n |> Or_error.ok_exn\n in\n is_new_stack := false ;\n t )\n in\n let _, after_del =\n remove_coinbase_stack ~depth after_adding |> Or_error.ok_exn\n in\n pending_coinbases := after_del ;\n assert (Hash.equal (merkle_root after_del) init) ;\n Async_kernel.Deferred.return () ) )\n\n module type Pending_coinbase_intf = sig\n type t [@@deriving sexp]\n\n val add_coinbase :\n depth:int -> t -> coinbase:Coinbase.t -> is_new_stack:bool -> t Or_error.t\n\n val add_state :\n depth:int\n -> t\n -> State_body_hash.t\n -> Mina_numbers.Global_slot_since_genesis.t\n -> is_new_stack:bool\n -> t Or_error.t\n end\n\n let add_coinbase_with_zero_checks (type t)\n (module T : Pending_coinbase_intf with type t = t) (t : t)\n ~(constraint_constants : Genesis_constants.Constraint_constants.t)\n ~coinbase ~supercharged_coinbase ~state_body_hash ~global_slot\n ~is_new_stack =\n let depth = constraint_constants.pending_coinbase_depth in\n if Amount.equal coinbase.Coinbase.amount Amount.zero then t\n else\n let max_coinbase_amount =\n if supercharged_coinbase then\n Option.value_exn\n (Currency.Amount.scale constraint_constants.coinbase_amount\n constraint_constants.supercharged_coinbase_factor )\n else constraint_constants.coinbase_amount\n in\n let coinbase' =\n Coinbase.create\n ~amount:\n (Option.value_exn (Amount.sub max_coinbase_amount coinbase.amount))\n ~receiver:coinbase.receiver ~fee_transfer:None\n |> Or_error.ok_exn\n in\n let t_with_state =\n T.add_state ~depth t state_body_hash global_slot ~is_new_stack\n |> Or_error.ok_exn\n in\n (*add coinbase to the same stack*)\n let interim_tree =\n T.add_coinbase ~depth t_with_state ~coinbase ~is_new_stack:false\n |> Or_error.ok_exn\n in\n if Amount.equal coinbase'.amount Amount.zero then interim_tree\n else\n T.add_coinbase ~depth interim_tree ~coinbase:coinbase'\n ~is_new_stack:false\n |> Or_error.ok_exn\n\n let%test_unit \"Checked_stack = Unchecked_stack\" =\n let open Quickcheck in\n let constraint_constants =\n Genesis_constants.Constraint_constants.for_unit_tests\n in\n test ~trials:20\n (Generator.tuple2 Stack.gen (Coinbase.Gen.gen ~constraint_constants))\n ~f:(fun (base, (cb, _supercharged_coinbase)) ->\n let coinbase_data = Coinbase_data.of_coinbase cb in\n let unchecked = Stack.push_coinbase cb base in\n let checked =\n let comp =\n let open Snark_params.Tick in\n let cb_var = Coinbase_data.(var_of_t coinbase_data) in\n let%map res =\n Stack.Checked.push_coinbase cb_var (Stack.var_of_t base)\n in\n As_prover.read Stack.typ res\n in\n Or_error.ok_exn (run_and_check comp)\n in\n assert (Stack.equal unchecked checked) )\n\n let%test_unit \"Checked_tree = Unchecked_tree\" =\n let open Quickcheck in\n let constraint_constants =\n Genesis_constants.Constraint_constants.for_unit_tests\n in\n let depth = constraint_constants.pending_coinbase_depth in\n let pending_coinbases = create ~depth () |> Or_error.ok_exn in\n test ~trials:20\n (Generator.tuple3\n (Coinbase.Gen.gen ~constraint_constants)\n State_body_hash.gen Mina_numbers.Global_slot_since_genesis.gen )\n ~f:(fun ( (coinbase, `Supercharged_coinbase supercharged_coinbase)\n , state_body_hash\n , global_slot ) ->\n let amount = coinbase.amount in\n let is_new_stack, action =\n Currency.Amount.(\n if equal coinbase.amount zero then (true, Update.Action.Update_none)\n else (true, Update_one))\n in\n let unchecked =\n add_coinbase_with_zero_checks ~constraint_constants\n (module T)\n pending_coinbases ~coinbase ~is_new_stack ~state_body_hash\n ~global_slot ~supercharged_coinbase\n in\n (* inside the `open' below, Checked means something else, so define this function *)\n let f_add_coinbase = Checked.add_coinbase ~constraint_constants in\n let checked_merkle_root =\n let comp =\n let open Snark_params.Tick in\n let amount_var = Amount.var_of_t amount in\n let action_var = Update.Action.var_of_t action in\n let coinbase_receiver_var =\n Public_key.Compressed.var_of_t coinbase.receiver\n in\n let supercharge_coinbase_var =\n Boolean.var_of_value supercharged_coinbase\n in\n let state_body_hash_var =\n State_body_hash.var_of_t state_body_hash\n in\n let global_slot_var =\n Mina_numbers.Global_slot_since_genesis.Checked.constant\n global_slot\n in\n let%map result =\n handle\n (fun () ->\n f_add_coinbase\n (Hash.var_of_t (merkle_root pending_coinbases))\n { Update.Poly.action = action_var\n ; coinbase_amount = amount_var\n }\n ~coinbase_receiver:coinbase_receiver_var\n ~supercharge_coinbase:supercharge_coinbase_var\n state_body_hash_var global_slot_var )\n (unstage (handler ~depth pending_coinbases ~is_new_stack))\n in\n As_prover.read Hash.typ result\n in\n Or_error.ok_exn (run_and_check comp)\n in\n assert (Hash.equal (merkle_root unchecked) checked_merkle_root) )\n\n let%test_unit \"Checked_tree = Unchecked_tree after pop\" =\n let open Quickcheck in\n let constraint_constants =\n Genesis_constants.Constraint_constants.for_unit_tests\n in\n let depth = constraint_constants.pending_coinbase_depth in\n test ~trials:20\n (Generator.tuple3\n (Coinbase.Gen.gen ~constraint_constants)\n State_body_hash.gen Mina_numbers.Global_slot_since_genesis.gen )\n ~f:(fun ( (coinbase, `Supercharged_coinbase supercharged_coinbase)\n , state_body_hash\n , global_slot ) ->\n let pending_coinbases = create ~depth () |> Or_error.ok_exn in\n let amount = coinbase.amount in\n let action =\n Currency.Amount.(\n if equal coinbase.amount zero then Update.Action.Update_none\n else Update_one)\n in\n let unchecked =\n add_coinbase_with_zero_checks ~constraint_constants\n (module T)\n pending_coinbases ~coinbase ~is_new_stack:true ~state_body_hash\n ~global_slot ~supercharged_coinbase\n in\n (* inside the `open' below, Checked means something else, so define these functions *)\n let f_add_coinbase = Checked.add_coinbase ~constraint_constants in\n let f_pop_coinbase = Checked.pop_coinbases ~constraint_constants in\n let checked_merkle_root =\n let comp =\n let open Snark_params.Tick in\n let amount_var = Amount.var_of_t amount in\n let action_var = Update.Action.(var_of_t action) in\n let coinbase_receiver_var =\n Public_key.Compressed.var_of_t coinbase.receiver\n in\n let supercharge_coinbase_var =\n Boolean.var_of_value supercharged_coinbase\n in\n let state_body_hash_var =\n State_body_hash.var_of_t state_body_hash\n in\n let global_slot_var =\n Mina_numbers.Global_slot_since_genesis.Checked.constant\n global_slot\n in\n let%map result =\n handle\n (fun () ->\n f_add_coinbase\n (Hash.var_of_t (merkle_root pending_coinbases))\n { Update.Poly.action = action_var\n ; coinbase_amount = amount_var\n }\n ~coinbase_receiver:coinbase_receiver_var\n ~supercharge_coinbase:supercharge_coinbase_var\n state_body_hash_var global_slot_var )\n (unstage (handler ~depth pending_coinbases ~is_new_stack:true))\n in\n As_prover.read Hash.typ result\n in\n Or_error.ok_exn (run_and_check comp)\n in\n assert (Hash.equal (merkle_root unchecked) checked_merkle_root) ;\n (*deleting the coinbase stack we just created. therefore if there was no update then don't try to delete*)\n let proof_emitted = not Update.Action.(equal action Update_none) in\n let unchecked_after_pop =\n if proof_emitted then\n remove_coinbase_stack ~depth unchecked |> Or_error.ok_exn |> snd\n else unchecked\n in\n let checked_merkle_root_after_pop =\n let comp =\n let open Snark_params.Tick in\n let%map current, _previous =\n handle\n (fun () ->\n f_pop_coinbase ~proof_emitted:Boolean.true_\n (Hash.var_of_t checked_merkle_root) )\n (unstage (handler ~depth unchecked ~is_new_stack:false))\n in\n As_prover.read Hash.typ current\n in\n Or_error.ok_exn (run_and_check comp)\n in\n assert (\n Hash.equal\n (merkle_root unchecked_after_pop)\n checked_merkle_root_after_pop ) )\n\n let%test_unit \"push and pop multiple stacks\" =\n let open Quickcheck in\n let module Pending_coinbase = T in\n let constraint_constants =\n { Genesis_constants.Constraint_constants.for_unit_tests with\n pending_coinbase_depth = 3\n }\n in\n let depth = constraint_constants.pending_coinbase_depth in\n let t_of_coinbases t = function\n | [] ->\n let t' =\n Pending_coinbase.incr_index ~depth t ~is_new_stack:true\n |> Or_error.ok_exn\n in\n (Pending_coinbase.Stack.empty, t')\n | ( (initial_coinbase, _supercharged_coinbase)\n , state_body_hash\n , global_slot )\n :: coinbases ->\n let t' =\n Pending_coinbase.add_state ~depth t state_body_hash global_slot\n ~is_new_stack:true\n |> Or_error.ok_exn\n |> Pending_coinbase.add_coinbase ~depth ~coinbase:initial_coinbase\n ~is_new_stack:false\n |> Or_error.ok_exn\n in\n let updated =\n List.fold coinbases ~init:t'\n ~f:(fun\n pending_coinbases\n ( (coinbase, `Supercharged_coinbase supercharged_coinbase)\n , state_body_hash\n , global_slot )\n ->\n add_coinbase_with_zero_checks ~constraint_constants\n (module Pending_coinbase)\n pending_coinbases ~coinbase ~is_new_stack:false\n ~state_body_hash ~global_slot ~supercharged_coinbase )\n in\n let new_stack =\n Or_error.ok_exn\n @@ Pending_coinbase.latest_stack updated ~is_new_stack:false\n in\n (new_stack, updated)\n in\n (* Create pending coinbase stacks from coinbase lists and add it to the pending coinbase merkle tree *)\n let add coinbase_lists pending_coinbases =\n List.fold ~init:([], pending_coinbases) coinbase_lists\n ~f:(fun (stacks, pc) coinbases ->\n let new_stack, pc = t_of_coinbases pc coinbases in\n (new_stack :: stacks, pc) )\n in\n (* remove the oldest stack and check if that's the expected one *)\n let remove_check t expected_stack =\n let popped_stack, updated_pending_coinbases =\n Pending_coinbase.remove_coinbase_stack ~depth t |> Or_error.ok_exn\n in\n assert (Pending_coinbase.Stack.equal_data popped_stack expected_stack) ;\n updated_pending_coinbases\n in\n let add_remove_check coinbase_lists =\n let max_coinbase_stack_count =\n Pending_coinbase.max_coinbase_stack_count ~depth\n in\n let pending_coinbases = Pending_coinbase.create_exn' ~depth () in\n let rec go coinbase_lists pc =\n if List.is_empty coinbase_lists then ()\n else\n let coinbase_lists' =\n List.take coinbase_lists max_coinbase_stack_count\n in\n let added_stacks, pending_coinbases_updated =\n add coinbase_lists' pc\n in\n let pending_coinbases' =\n List.fold ~init:pending_coinbases_updated (List.rev added_stacks)\n ~f:(fun pc expected_stack -> remove_check pc expected_stack)\n in\n let remaining_lists =\n List.drop coinbase_lists max_coinbase_stack_count\n in\n go remaining_lists pending_coinbases'\n in\n go coinbase_lists pending_coinbases\n in\n let coinbase_lists_gen =\n Quickcheck.Generator.(\n list\n (list\n (Generator.tuple3\n (Coinbase.Gen.gen ~constraint_constants)\n State_body_hash.gen Mina_numbers.Global_slot_since_genesis.gen ) ))\n in\n test ~trials:100 coinbase_lists_gen ~f:add_remove_check\nend\n\ninclude Wire_types.Make (Make_sig) (Make_str)\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Mina_base_util\nopen Fold_lib\nopen Snark_params.Tick\nmodule Wire_types = Mina_wire_types.Mina_base.Staged_ledger_hash\n\nmodule Make_sig (A : Wire_types.Types.S) = struct\n module type S =\n Staged_ledger_hash_intf.Full\n with type Aux_hash.t = A.Aux_hash.t\n and type Pending_coinbase_aux.t = A.Pending_coinbase_aux.V1.t\n and type t = A.V1.t\n and type Stable.V1.t = A.V1.t\nend\n\nmodule Make_str (A : Wire_types.Concrete) = struct\n module Aux_hash = struct\n let length_in_bits = 256\n\n let length_in_bytes = length_in_bits / 8\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = string [@@deriving sexp, equal, compare, hash]\n\n let to_latest = Fn.id\n\n module Base58_check = Base58_check.Make (struct\n let description = \"Aux hash\"\n\n let version_byte =\n Base58_check.Version_bytes.staged_ledger_hash_aux_hash\n end)\n\n let to_base58_check s = Base58_check.encode s\n\n let of_base58_check_exn s = Base58_check.decode_exn s\n\n let to_yojson s = `String (to_base58_check s)\n\n let of_yojson = function\n | `String s -> (\n match Base58_check.decode s with\n | Error e ->\n Error\n (sprintf \"Aux_hash.of_yojson, bad Base58Check:%s\"\n (Error.to_string_hum e) )\n | Ok x ->\n Ok x )\n | _ ->\n Error \"Aux_hash.of_yojson expected `String\"\n end\n end]\n\n [%%define_locally\n Stable.Latest.\n ( to_yojson\n , of_yojson\n , to_base58_check\n , of_base58_check_exn\n , compare\n , sexp_of_t )]\n\n let of_bytes = Fn.id\n\n let to_bytes = Fn.id\n\n let dummy : t = String.init length_in_bytes ~f:(fun _ -> '\\000')\n\n let of_sha256 : Digestif.SHA256.t -> t =\n Fn.compose of_bytes Digestif.SHA256.to_raw_string\n\n let gen : t Quickcheck.Generator.t =\n let char_generator =\n Base_quickcheck.Generator.of_list\n [ '0'\n ; '1'\n ; '2'\n ; '3'\n ; '4'\n ; '5'\n ; '6'\n ; '7'\n ; '8'\n ; '9'\n ; 'A'\n ; 'B'\n ; 'C'\n ; 'D'\n ; 'E'\n ; 'F'\n ]\n in\n String.gen_with_length (length_in_bytes * 2) char_generator\n |> Quickcheck.Generator.map\n ~f:(Fn.compose of_sha256 Digestif.SHA256.of_hex)\n end\n\n module Pending_coinbase_aux = struct\n let length_in_bits = 256\n\n let length_in_bytes = length_in_bits / 8\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = string [@@deriving sexp, equal, compare, hash]\n\n let to_latest = Fn.id\n\n module Base58_check = Base58_check.Make (struct\n let description = \"Pending coinbase aux\"\n\n let version_byte =\n Base58_check.Version_bytes.staged_ledger_hash_pending_coinbase_aux\n end)\n\n let to_base58_check s = Base58_check.encode s\n\n let of_base58_check_exn s = Base58_check.decode_exn s\n\n let to_yojson s = `String (to_base58_check s)\n\n let of_yojson = function\n | `String s -> (\n match Base58_check.decode s with\n | Ok x ->\n Ok x\n | Error e ->\n Error\n (sprintf\n \"Pending_coinbase_aux.of_yojson, bad Base58Check:%s\"\n (Error.to_string_hum e) ) )\n | _ ->\n Error \"Pending_coinbase_aux.of_yojson expected `String\"\n end\n end]\n\n [%%define_locally\n Stable.Latest.(to_yojson, of_yojson, to_base58_check, of_base58_check_exn)]\n\n let dummy : t = String.init length_in_bytes ~f:(fun _ -> '\\000')\n end\n\n module Non_snark = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = A.Non_snark.V1.t =\n { ledger_hash : Ledger_hash.Stable.V1.t\n ; aux_hash : Aux_hash.Stable.V1.t\n ; pending_coinbase_aux : Pending_coinbase_aux.Stable.V1.t\n }\n [@@deriving sexp, equal, compare, hash, yojson, fields]\n\n let to_latest = Fn.id\n end\n end]\n\n type value = t [@@deriving sexp, compare, hash, yojson]\n\n let dummy : t Lazy.t =\n lazy\n { ledger_hash = Ledger_hash.empty_hash\n ; aux_hash = Aux_hash.dummy\n ; pending_coinbase_aux = Pending_coinbase_aux.dummy\n }\n\n let genesis ~genesis_ledger_hash : t =\n { ledger_hash = genesis_ledger_hash\n ; aux_hash = Aux_hash.dummy\n ; pending_coinbase_aux = Pending_coinbase_aux.dummy\n }\n\n type var = Boolean.var list\n\n let length_in_bits = 256\n\n let digest ({ ledger_hash; aux_hash; pending_coinbase_aux } : t) =\n let h = Digestif.SHA256.init () in\n let h =\n Digestif.SHA256.feed_string h (Ledger_hash.to_bytes ledger_hash)\n in\n let h = Digestif.SHA256.feed_string h aux_hash in\n let h = Digestif.SHA256.feed_string h pending_coinbase_aux in\n Digestif.SHA256.(get h |> to_raw_string)\n\n let fold t = Fold.string_bits (digest t)\n\n let to_input t =\n let open Random_oracle.Input.Chunked in\n Array.reduce_exn ~f:append\n (Array.of_list_map\n (Fold.to_list (fold t))\n ~f:(fun b -> packed (field_of_bool b, 1)) )\n\n let ledger_hash ({ ledger_hash; _ } : t) = ledger_hash\n\n let aux_hash ({ aux_hash; _ } : t) = aux_hash\n\n let of_ledger_aux_coinbase_hash aux_hash ledger_hash pending_coinbase_aux :\n t =\n { aux_hash; ledger_hash; pending_coinbase_aux }\n\n let var_to_input (t : var) =\n let open Random_oracle.Input.Chunked in\n Array.reduce_exn ~f:append\n (Array.of_list_map t ~f:(fun b -> packed ((b :> Field.Var.t), 1)))\n\n let var_of_t t : var =\n List.map (Fold.to_list @@ fold t) ~f:Boolean.var_of_value\n\n [%%if proof_level = \"check\"]\n\n let warn_improper_transport () = ()\n\n [%%else]\n\n let warn_improper_transport () =\n printf \"WARNING: improperly transporting staged-ledger-hash\\n\"\n\n [%%endif]\n\n let typ : (var, value) Typ.t =\n Typ.transport (Typ.list ~length:length_in_bits Boolean.typ)\n ~there:(Fn.compose Fold.to_list fold) ~back:(fun _ ->\n (* If we put a failwith here, we lose the ability to printf-inspect\n * anything that uses staged-ledger-hashes from within Checked\n * computations. It's useful when debugging to dump the protocol state\n * and so we can just lie here instead. *)\n warn_improper_transport () ; Lazy.force dummy )\n end\n\n module Poly = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type ('non_snark, 'pending_coinbase_hash) t =\n ('non_snark, 'pending_coinbase_hash) A.Poly.V1.t =\n { non_snark : 'non_snark\n ; pending_coinbase_hash : 'pending_coinbase_hash\n }\n [@@deriving sexp, equal, compare, hash, yojson, hlist]\n end\n end]\n end\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n (** Staged ledger hash has two parts\n 1) merkle root of the pending coinbases\n 2) ledger hash, aux hash, and the FIFO order of the coinbase stacks(Non snark).\n Only part 1 is required for blockchain snark computation and therefore the remaining fields of the staged ledger are grouped together as \"Non_snark\"\n *)\n type t =\n ( Non_snark.Stable.V1.t\n , Pending_coinbase.Hash_versioned.Stable.V1.t )\n Poly.Stable.V1.t\n [@@deriving sexp, equal, compare, hash, yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n type ('a, 'b) t_ = ('a, 'b) Poly.t\n\n type value = t [@@deriving sexp, equal, compare, hash]\n\n type var = (Non_snark.var, Pending_coinbase.Hash.var) t_\n\n include Hashable.Make (Stable.Latest)\n\n let ledger_hash ({ non_snark; _ } : t) = Non_snark.ledger_hash non_snark\n\n let aux_hash ({ non_snark; _ } : t) = Non_snark.aux_hash non_snark\n\n let pending_coinbase_aux ({ non_snark; _ } : t) =\n Non_snark.pending_coinbase_aux non_snark\n\n let pending_coinbase_hash ({ pending_coinbase_hash; _ } : t) =\n pending_coinbase_hash\n\n let pending_coinbase_hash_var ({ pending_coinbase_hash; _ } : var) =\n pending_coinbase_hash\n\n let of_aux_ledger_and_coinbase_hash aux_hash ledger_hash pending_coinbase : t\n =\n { non_snark =\n Non_snark.of_ledger_aux_coinbase_hash aux_hash ledger_hash\n (Pending_coinbase.hash_extra pending_coinbase)\n ; pending_coinbase_hash = Pending_coinbase.merkle_root pending_coinbase\n }\n\n let genesis ~(constraint_constants : Genesis_constants.Constraint_constants.t)\n ~genesis_ledger_hash : t =\n let pending_coinbase =\n Pending_coinbase.create ~depth:constraint_constants.pending_coinbase_depth\n ()\n |> Or_error.ok_exn\n in\n { non_snark = Non_snark.genesis ~genesis_ledger_hash\n ; pending_coinbase_hash = Pending_coinbase.merkle_root pending_coinbase\n }\n\n let var_of_t ({ pending_coinbase_hash; non_snark } : t) : var =\n let non_snark = Non_snark.var_of_t non_snark in\n let pending_coinbase_hash =\n Pending_coinbase.Hash.var_of_t pending_coinbase_hash\n in\n { non_snark; pending_coinbase_hash }\n\n let to_input ({ non_snark; pending_coinbase_hash } : t) =\n Random_oracle.Input.Chunked.(\n append\n (Non_snark.to_input non_snark)\n (field (pending_coinbase_hash :> Field.t)))\n\n let var_to_input ({ non_snark; pending_coinbase_hash } : var) =\n Random_oracle.Input.Chunked.(\n append\n (Non_snark.var_to_input non_snark)\n (field (Pending_coinbase.Hash.var_to_hash_packed pending_coinbase_hash)))\n\n let typ : (var, t) Typ.t =\n Typ.of_hlistable\n [ Non_snark.typ; Pending_coinbase.Hash.typ ]\n ~var_to_hlist:Poly.to_hlist ~var_of_hlist:Poly.of_hlist\n ~value_to_hlist:Poly.to_hlist ~value_of_hlist:Poly.of_hlist\nend\n\ninclude Wire_types.Make (Make_sig) (Make_str)\n","open Core_kernel\nopen Mina_base_util\nopen Mina_base_import\nmodule Wire_types = Mina_wire_types.Mina_base.Sok_message\n\nmodule Make_sig (A : Wire_types.Types.S) = struct\n module type S = Sok_message_intf.Full with type Digest.t = A.Digest.V1.t\nend\n\nmodule Make_str (A : Wire_types.Concrete) = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t =\n { fee : Currency.Fee.Stable.V1.t\n ; prover : Public_key.Compressed.Stable.V1.t\n }\n [@@deriving sexp, yojson, equal, compare]\n\n let to_latest = Fn.id\n end\n end]\n\n let create ~fee ~prover = Stable.Latest.{ fee; prover }\n\n module Digest = struct\n let length_in_bytes = Blake2.digest_size_in_bytes\n\n [%%versioned_binable\n module Stable = struct\n module V1 = struct\n type t = string [@@deriving sexp, hash, compare, equal, yojson]\n\n let to_latest = Fn.id\n\n include\n Binable.Of_binable_without_uuid\n (Core_kernel.String.Stable.V1)\n (struct\n type nonrec t = t\n\n let to_binable = Fn.id\n\n let of_binable s =\n assert (String.length s = length_in_bytes) ;\n s\n end)\n\n open Snark_params.Tick\n\n let to_input t =\n Random_oracle.Input.Chunked.packeds\n (Array.of_list_map\n Fold_lib.Fold.(to_list (string_bits t))\n ~f:(fun b -> (field_of_bool b, 1)) )\n\n let typ =\n Typ.array ~length:Blake2.digest_size_in_bits Boolean.typ\n |> Typ.transport ~there:Blake2.string_to_bits\n ~back:Blake2.bits_to_string\n end\n end]\n\n module Checked = struct\n open Snark_params.Tick\n\n type t = Boolean.var array\n\n let to_input (t : t) =\n Random_oracle.Input.Chunked.packeds\n (Array.map t ~f:(fun b -> ((b :> Field.Var.t), 1)))\n end\n\n [%%define_locally Stable.Latest.(to_input, typ)]\n\n let default = String.init length_in_bytes ~f:(fun _ -> '\\000')\n end\n\n let digest t =\n Blake2.to_raw_string\n (Blake2.digest_string (Binable.to_string (module Stable.Latest) t))\nend\n\ninclude Wire_types.Make (Make_sig) (Make_str)\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Snark_params.Tick\nmodule T = Mina_numbers.Length\n\n(*constants actually required for blockchain snark*)\n(* k\n ,c\n ,slots_per_epoch\n ,slots_per_sub_window\n ,sub_windows_per_window\n ,checkpoint_window_size_in_slots\n ,block_window_duration_ms*)\n\nmodule Poly = Genesis_constants.Protocol.Poly\n\nmodule Value = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t =\n (T.Stable.V1.t, T.Stable.V1.t, Block_time.Stable.V1.t) Poly.Stable.V1.t\n [@@deriving equal, ord, hash, sexp, yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n let gen : t Quickcheck.Generator.t =\n let open Quickcheck.Let_syntax in\n let%bind k = Int.gen_incl 1 5000 in\n let%bind delta = Int.gen_incl 0 5000 in\n let%bind slots_per_epoch = Int.gen_incl k (8 * k) >>| ( * ) 3 >>| T.of_int\n and slots_per_sub_window = Int.gen_incl 1 ((k + 9) / 9) in\n (*TODO: Bug -> Block_time.(to_time x |> of_time) != x for certain values.\n Eg: 34702788243129 <--> 34702788243128, 8094 <--> 8093*)\n let%bind ms = Int64.(gen_log_uniform_incl 0L 9999999999999L) in\n let end_time = Block_time.of_int64 999999999999999L in\n let%map genesis_state_timestamp =\n Block_time.(gen_incl (of_int64 ms) end_time)\n in\n { Poly.k = T.of_int k\n ; delta = T.of_int delta\n ; slots_per_epoch\n ; slots_per_sub_window = T.of_int slots_per_sub_window\n ; genesis_state_timestamp\n }\nend\n\ntype value = Value.t\n\nlet value_of_t (t : Genesis_constants.Protocol.t) : value =\n { k = T.of_int t.k\n ; delta = T.of_int t.delta\n ; slots_per_epoch = T.of_int t.slots_per_epoch\n ; slots_per_sub_window = T.of_int t.slots_per_sub_window\n ; genesis_state_timestamp = Block_time.of_int64 t.genesis_state_timestamp\n }\n\nlet t_of_value (v : value) : Genesis_constants.Protocol.t =\n { k = T.to_int v.k\n ; delta = T.to_int v.delta\n ; slots_per_epoch = T.to_int v.slots_per_epoch\n ; slots_per_sub_window = T.to_int v.slots_per_sub_window\n ; genesis_state_timestamp = Block_time.to_int64 v.genesis_state_timestamp\n }\n\nlet to_input (t : value) =\n Array.reduce_exn ~f:Random_oracle.Input.Chunked.append\n [| T.to_input t.k\n ; T.to_input t.delta\n ; T.to_input t.slots_per_epoch\n ; T.to_input t.slots_per_sub_window\n ; Block_time.to_input t.genesis_state_timestamp\n |]\n\n[%%if defined consensus_mechanism]\n\ntype var = (T.Checked.t, T.Checked.t, Block_time.Checked.t) Poly.t\n\nlet typ =\n Typ.of_hlistable\n [ T.Checked.typ\n ; T.Checked.typ\n ; T.Checked.typ\n ; T.Checked.typ\n ; Block_time.Checked.typ\n ]\n ~var_to_hlist:Poly.to_hlist ~var_of_hlist:Poly.of_hlist\n ~value_to_hlist:Poly.to_hlist ~value_of_hlist:Poly.of_hlist\n\nlet var_to_input (var : var) =\n let k = T.Checked.to_input var.k\n and delta = T.Checked.to_input var.delta\n and slots_per_epoch = T.Checked.to_input var.slots_per_epoch\n and slots_per_sub_window = T.Checked.to_input var.slots_per_sub_window in\n let genesis_state_timestamp =\n Block_time.Checked.to_input var.genesis_state_timestamp\n in\n Array.reduce_exn ~f:Random_oracle.Input.Chunked.append\n [| k\n ; delta\n ; slots_per_epoch\n ; slots_per_sub_window\n ; genesis_state_timestamp\n |]\n\nlet%test_unit \"value = var\" =\n let compiled = Genesis_constants.for_unit_tests.protocol in\n let test protocol_constants =\n let open Snarky_backendless in\n let p_var =\n let%map p = exists typ ~compute:(As_prover0.return protocol_constants) in\n As_prover0.read typ p\n in\n let res = Or_error.ok_exn (run_and_check p_var) in\n [%test_eq: Value.t] res protocol_constants ;\n [%test_eq: Value.t] protocol_constants\n (t_of_value protocol_constants |> value_of_t)\n in\n Quickcheck.test ~trials:100 Value.gen\n ~examples:[ value_of_t compiled ]\n ~f:test\n\n[%%endif]\n","open Core_kernel\nopen Signature_lib\n\n[%%versioned\nmodule Stable = struct\n module V1 = struct\n type t = Mina_wire_types.Mina_base.Fee_with_prover.V1.t =\n { fee : Currency.Fee.Stable.V1.t\n ; prover : Public_key.Compressed.Stable.V1.t\n }\n [@@deriving sexp, yojson, hash]\n\n let to_latest = Fn.id\n\n module T = struct\n type typ = t [@@deriving sexp]\n\n type t = typ [@@deriving sexp]\n\n (* TODO: Compare in a better way than with public key, like in transaction pool *)\n let compare t1 t2 =\n let r = Currency.Fee.compare t1.fee t2.fee in\n if Int.( <> ) r 0 then r\n else Public_key.Compressed.compare t1.prover t2.prover\n end\n\n include Comparable.Make (T)\n end\nend]\n\ninclude Comparable.Make (Stable.V1.T)\n\nlet gen =\n Quickcheck.Generator.map2 Currency.Fee.gen Public_key.Compressed.gen\n ~f:(fun fee prover -> { fee; prover })\n","open Core_kernel\nopen Mina_base\n\nmodule Poly = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type 'command t = 'command Mina_wire_types.Mina_transaction.Poly.V2.t =\n | Command of 'command\n | Fee_transfer of Fee_transfer.Stable.V2.t\n | Coinbase of Coinbase.Stable.V1.t\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n\n let map t ~f =\n match t with\n | Command x ->\n Command (f x)\n | Fee_transfer x ->\n Fee_transfer x\n | Coinbase x ->\n Coinbase x\n end\n end]\nend\n\nmodule Valid = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t = User_command.Valid.Stable.V2.t Poly.Stable.V2.t\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n include Hashable.Make (Stable.Latest)\n include Comparable.Make (Stable.Latest)\nend\n\n[%%versioned\nmodule Stable = struct\n module V2 = struct\n type t = User_command.Stable.V2.t Poly.Stable.V2.t\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n end\nend]\n\ninclude Hashable.Make (Stable.Latest)\ninclude Comparable.Make (Stable.Latest)\n\ntype 'command t_ = 'command Poly.t =\n | Command of 'command\n | Fee_transfer of Fee_transfer.t\n | Coinbase of Coinbase.t\n\nlet to_valid_unsafe :\n t -> [ `If_this_is_used_it_should_have_a_comment_justifying_it of Valid.t ]\n = function\n | Command t ->\n let (`If_this_is_used_it_should_have_a_comment_justifying_it t') =\n User_command.to_valid_unsafe t\n in\n `If_this_is_used_it_should_have_a_comment_justifying_it (Command t')\n | Fee_transfer t ->\n `If_this_is_used_it_should_have_a_comment_justifying_it (Fee_transfer t)\n | Coinbase t ->\n `If_this_is_used_it_should_have_a_comment_justifying_it (Coinbase t)\n\nlet forget : Valid.t -> t = function\n | Command t ->\n Command (User_command.forget_check t)\n | Fee_transfer t ->\n Fee_transfer t\n | Coinbase t ->\n Coinbase t\n\nlet fee_excess : t -> Fee_excess.t Or_error.t = function\n | Command (Signed_command t) ->\n Ok (Signed_command.fee_excess t)\n | Command (Zkapp_command ps) ->\n Ok (Zkapp_command.fee_excess ps)\n | Fee_transfer t ->\n Fee_transfer.fee_excess t\n | Coinbase t ->\n Coinbase.fee_excess t\n\nlet expected_supply_increase = function\n | Command _ | Fee_transfer _ ->\n Ok Currency.Amount.zero\n | Coinbase t ->\n Coinbase.expected_supply_increase t\n\nlet public_keys (t : t) =\n let account_ids =\n match t with\n | Command (Signed_command cmd) ->\n Signed_command.accounts_referenced cmd\n | Command (Zkapp_command t) ->\n Zkapp_command.accounts_referenced t\n | Fee_transfer ft ->\n Fee_transfer.receivers ft\n | Coinbase cb ->\n Coinbase.accounts_referenced cb\n in\n List.map account_ids ~f:Account_id.public_key\n\nlet account_access_statuses (t : t) (status : Transaction_status.t) =\n match t with\n | Command (Signed_command cmd) ->\n Signed_command.account_access_statuses cmd status\n | Command (Zkapp_command t) ->\n Zkapp_command.account_access_statuses t status\n | Fee_transfer ft ->\n assert (Transaction_status.equal Applied status) ;\n List.map (Fee_transfer.receivers ft) ~f:(fun acct_id ->\n (acct_id, `Accessed) )\n | Coinbase cb ->\n Coinbase.account_access_statuses cb status\n\nlet accounts_referenced (t : t) =\n List.map (account_access_statuses t Applied) ~f:(fun (acct_id, _status) ->\n acct_id )\n\nlet fee_payer_pk (t : t) =\n match t with\n | Command (Signed_command cmd) ->\n Signed_command.fee_payer_pk cmd\n | Command (Zkapp_command t) ->\n Zkapp_command.fee_payer_pk t\n | Fee_transfer ft ->\n Fee_transfer.fee_payer_pk ft\n | Coinbase cb ->\n Coinbase.fee_payer_pk cb\n\nlet valid_size ~genesis_constants (t : t) =\n match t with\n | Command cmd ->\n User_command.valid_size ~genesis_constants cmd\n | Fee_transfer _ | Coinbase _ ->\n Ok ()\n\nlet check_well_formedness ~genesis_constants (t : t) =\n match t with\n | Command cmd ->\n User_command.check_well_formedness ~genesis_constants cmd\n | Fee_transfer _ | Coinbase _ ->\n Ok ()\n","open Core_kernel\nopen Mina_base\n\n[%%import \"/src/config.mlh\"]\n\nmodule T = struct\n include Blake2.Make ()\nend\n\ninclude T\n\nmodule Base58_check = Codable.Make_base58_check (struct\n type t = Stable.Latest.t [@@deriving bin_io_unversioned]\n\n let version_byte = Base58_check.Version_bytes.transaction_hash\n\n let description = \"Transaction hash\"\nend)\n\n[%%define_locally\nBase58_check.(of_base58_check, of_base58_check_exn, to_base58_check)]\n\nlet to_yojson t = `String (to_base58_check t)\n\nlet of_yojson = function\n | `String str ->\n Result.map_error (of_base58_check str) ~f:(fun _ ->\n \"Transaction_hash.of_yojson: Error decoding string from base58_check \\\n format\" )\n | _ ->\n Error \"Transaction_hash.of_yojson: Expected a string\"\n\nlet ( hash_signed_command_v1\n , hash_signed_command\n , hash_zkapp_command\n , hash_coinbase\n , hash_fee_transfer ) =\n let mk_hasher (type a) (module M : Bin_prot.Binable.S with type t = a)\n (cmd : a) =\n cmd |> Binable.to_string (module M) |> digest_string\n in\n let signed_cmd_hasher_v1 =\n mk_hasher\n ( module struct\n include Signed_command.Stable.V1\n end )\n in\n let signed_cmd_hasher = mk_hasher (module Signed_command.Stable.Latest) in\n let zkapp_cmd_hasher = mk_hasher (module Zkapp_command.Stable.Latest) in\n (* replace actual signatures, proofs with dummies for hashing, so we can\n reproduce the transaction hashes if signatures, proofs omitted in\n archive db\n *)\n let hash_signed_command_v1 (cmd : Signed_command.Stable.V1.t) =\n let cmd_dummy_signature = { cmd with signature = Signature.dummy } in\n signed_cmd_hasher_v1 cmd_dummy_signature\n in\n let hash_signed_command (cmd : Signed_command.t) =\n let cmd_dummy_signature = { cmd with signature = Signature.dummy } in\n signed_cmd_hasher cmd_dummy_signature\n in\n let hash_zkapp_command (cmd : Zkapp_command.t) =\n let cmd_dummy_signatures_and_proofs =\n { cmd with\n fee_payer = { cmd.fee_payer with authorization = Signature.dummy }\n ; account_updates =\n Zkapp_command.Call_forest.map cmd.account_updates\n ~f:(fun (acct_update : Account_update.t) ->\n let dummy_auth =\n match acct_update.authorization with\n | Control.Proof _ ->\n Control.Proof Proof.transaction_dummy\n | Control.Signature _ ->\n Control.Signature Signature.dummy\n | Control.None_given ->\n Control.None_given\n in\n { acct_update with authorization = dummy_auth } )\n }\n in\n zkapp_cmd_hasher cmd_dummy_signatures_and_proofs\n in\n (* no signatures to replace for internal commands *)\n let hash_coinbase = mk_hasher (module Mina_base.Coinbase.Stable.Latest) in\n let hash_fee_transfer =\n mk_hasher (module Fee_transfer.Single.Stable.Latest)\n in\n ( hash_signed_command_v1\n , hash_signed_command\n , hash_zkapp_command\n , hash_coinbase\n , hash_fee_transfer )\n\n[%%ifdef consensus_mechanism]\n\nlet hash_command cmd =\n match cmd with\n | User_command.Signed_command s ->\n hash_signed_command s\n | User_command.Zkapp_command p ->\n hash_zkapp_command p\n\nlet hash_signed_command_v2 = hash_signed_command\n\nlet hash_of_transaction_id (transaction_id : string) : t Or_error.t =\n (* A transaction id might be:\n - original Base58Check transaction ids of signed commands (Signed_command.V1.t), or\n - a Base64 encoding of signed commands and zkApps (Signed_command.Vn.t, for n >= 2,\n or Zkapp_command.Vm.t, for m >= 1)\n\n For the Base64 case, the Bin_prot serialization leads with a version tag\n *)\n match Signed_command.of_base58_check_exn_v1 transaction_id with\n | Ok cmd_v1 ->\n Ok (hash_signed_command_v1 cmd_v1)\n | Error _ -> (\n match Base64.decode transaction_id with\n | Ok s -> (\n let len = String.length s in\n let buf = Bin_prot.Common.create_buf len in\n Bin_prot.Common.blit_string_buf s buf ~len ;\n let pos_ref = ref 0 in\n let version = Bin_prot.Std.bin_read_int ~pos_ref buf in\n match version with\n | 1 -> (\n (* must be a zkApp command *)\n try\n let cmd = Zkapp_command.Stable.Latest.bin_read_t ~pos_ref buf in\n Ok (hash_zkapp_command cmd)\n with _ ->\n Or_error.error_string\n \"Could not decode serialized zkApp command (version 1)\" )\n | 2 -> (\n (* must be a signed command, until there's a V2 for zkApp commands *)\n try\n let cmd = Signed_command.Stable.V2.bin_read_t ~pos_ref buf in\n Ok (hash_signed_command_v2 cmd)\n with _ ->\n Or_error.error_string\n \"Could not decode serialized signed command (version 2)\" )\n | _ ->\n Or_error.error_string\n (sprintf\n \"Transaction hashing not implemented for command with \\\n version %d\"\n version ) )\n | Error _ ->\n Or_error.error_string\n \"Could not decode transaction id as either Base58Check or Base64\" )\n\nmodule User_command_with_valid_signature = struct\n type hash = T.t [@@deriving sexp, compare, hash]\n\n let hash_to_yojson = to_yojson\n\n let hash_of_yojson = of_yojson\n\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t =\n ( (User_command.Valid.Stable.V2.t[@hash.ignore])\n , (T.Stable.V1.t[@to_yojson hash_to_yojson]) )\n With_hash.Stable.V1.t\n [@@deriving sexp, hash, to_yojson]\n\n let to_latest = Fn.id\n\n (* Compare only on hashes, comparing on the data too would be slower and\n add no value.\n *)\n let compare (x : t) (y : t) = T.compare x.hash y.hash\n end\n end]\n\n let create (c : User_command.Valid.t) : t =\n { data = c; hash = hash_command (User_command.forget_check c) }\n\n let data ({ data; _ } : t) = data\n\n let command ({ data; _ } : t) = User_command.forget_check data\n\n let hash ({ hash; _ } : t) = hash\n\n let forget_check ({ data; hash } : t) =\n { With_hash.data = User_command.forget_check data; hash }\n\n include Comparable.Make (Stable.Latest)\n\n let make data hash : t = { data; hash }\nend\n\nmodule User_command = struct\n type hash = T.t [@@deriving sexp, compare, hash]\n\n let hash_to_yojson = to_yojson\n\n let hash_of_yojson = of_yojson\n\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t =\n ( (User_command.Stable.V2.t[@hash.ignore])\n , (T.Stable.V1.t[@to_yojson hash_to_yojson]) )\n With_hash.Stable.V1.t\n [@@deriving sexp, hash, to_yojson]\n\n let to_latest = Fn.id\n\n (* Compare only on hashes, comparing on the data too would be slower and\n add no value.\n *)\n let compare (x : t) (y : t) = T.compare x.hash y.hash\n end\n end]\n\n let create (c : User_command.t) : t = { data = c; hash = hash_command c }\n\n let data ({ data; _ } : t) = data\n\n let command ({ data; _ } : t) = data\n\n let hash ({ hash; _ } : t) = hash\n\n let of_checked ({ data; hash } : User_command_with_valid_signature.t) : t =\n { With_hash.data = User_command.forget_check data; hash }\n\n include Comparable.Make (Stable.Latest)\nend\n\nlet%test_module \"Transaction hashes\" =\n ( module struct\n let run_test ~transaction_id ~expected_hash =\n let hash =\n match hash_of_transaction_id transaction_id with\n | Ok hash ->\n to_base58_check hash\n | Error err ->\n failwithf \"Error getting hash: %s\" (Error.to_string_hum err) ()\n in\n String.equal hash expected_hash\n\n let%test \"signed command v1 hash from transaction id\" =\n let transaction_id =\n \"BD421DxjdoLimeUh4RA4FEvHdDn6bfxyMVWiWUwbYzQkqhNUv8B5M4gCSREpu9mVueBYoHYWkwB8BMf6iS2jjV8FffvPGkuNeczBfY7YRwLuUGBRCQJ3ktFBrNuu4abqgkYhXmcS2xyzoSGxHbXkJRAokTwjQ9HP6TLSeXz9qa92nJaTeccMnkoZBmEitsZWWnTCMqDc6rhN4Z9UMpg4wzdPMwNJvLRuJBD14Dd5pR84KBoY9rrnv66rHPc4m2hH9QSEt4aEJC76BQ446pHN9ZLmyhrk28f5xZdBmYxp3hV13fJEJ3Gv1XqJMBqFxRhzCVGoKDbLAaNRb5F1u1WxTzJu5n4cMMDEYydGEpNirY2PKQqHkR8gEqjXRTkpZzP8G19qT\"\n in\n let expected_hash =\n \"5JuV53FPXad1QLC46z7wsou9JjjYP87qaUeryscZqLUMmLSg8j2n\"\n in\n run_test ~transaction_id ~expected_hash\n\n let%test \"signed command v2 hash from transaction id\" =\n let transaction_id =\n \"Av0IlDV3VklWpVXVRQr7cidImXn8E9nqCAxPjuyUNZ2pu3pJJxkBAAD//yIAIKTVOZ2q1qG1KT11p6844pWJ3fQug1XGnzv2S3N73azIABXhN3d+nO04Y7YqBul1CY5CEq9o34KWvfcB8IWep3kkAf60JFZJVqVV1UUK+3InSJl5/BPZ6ggMT47slDWdqbt6SScZAQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=\"\n in\n let expected_hash =\n \"5JvBt4173K3t7gQSpFoMGtbtZuYWPSg29cWad5pnnRd9BnAowoqY\"\n in\n run_test ~transaction_id ~expected_hash\n\n (* To regenerate:\n * Run dune in this library's directory\n dune utop src/lib/transaction\n * Generate a zkapp transaction:\n let txn = let txn = Mina_base.Zkapp_command.dummy in {txn with account_updates = Mina_base.Zkapp_command.Call_forest.map txn.account_updates ~f:(fun x -> {x with Mina_base.Account_update.authorization= Proof Mina_base.Proof.blockchain_dummy})};;\n * Print the transaction:\n Core_kernel.Out_channel.with_file \"txn_id\" ~f:(fun file -> Out_channel.output_string file (Core_kernel.Binable.to_string (module Mina_base.User_command.Stable.V2) (Zkapp_command txn) |> Base64.encode |> (function Ok x -> x | Error _ -> \"\")));;\n * Get the hash:\n Mina_transaction.Transaction_hash.(hash_command (Zkapp_command txn) |> to_base58_check);;\n *)\n\n let%test \"zkApp v1 hash from transaction id\" =\n let transaction_id =\n \"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\"\n in\n let expected_hash =\n \"5Jv9H3FWr4Uepj8FWhpMQErTaxuXUuk6zGeVziMSCZM5rdaTvY3B\"\n in\n run_test ~transaction_id ~expected_hash\n end )\n\n[%%endif]\n","open Core_kernel\nopen Mina_base\nopen Currency\nopen Signature_lib\nopen Mina_transaction\nmodule Zkapp_command_logic = Zkapp_command_logic\nmodule Global_slot_since_genesis = Mina_numbers.Global_slot_since_genesis\n\nmodule Transaction_applied = struct\n module UC = Signed_command\n\n module Signed_command_applied = struct\n module Common = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t =\n { user_command : Signed_command.Stable.V2.t With_status.Stable.V2.t\n }\n [@@deriving sexp, to_yojson]\n\n let to_latest = Fn.id\n end\n end]\n end\n\n module Body = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t =\n | Payment of { new_accounts : Account_id.Stable.V2.t list }\n | Stake_delegation of\n { previous_delegate : Public_key.Compressed.Stable.V1.t option }\n | Failed\n [@@deriving sexp, to_yojson]\n\n let to_latest = Fn.id\n end\n end]\n end\n\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t = { common : Common.Stable.V2.t; body : Body.Stable.V2.t }\n [@@deriving sexp, to_yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n let new_accounts (t : t) =\n match t.body with\n | Payment { new_accounts; _ } ->\n new_accounts\n | Stake_delegation _ | Failed ->\n []\n end\n\n module Zkapp_command_applied = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t =\n { accounts :\n (Account_id.Stable.V2.t * Account.Stable.V2.t option) list\n ; command : Zkapp_command.Stable.V1.t With_status.Stable.V2.t\n ; new_accounts : Account_id.Stable.V2.t list\n }\n [@@deriving sexp, to_yojson]\n\n let to_latest = Fn.id\n end\n end]\n end\n\n module Command_applied = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t =\n | Signed_command of Signed_command_applied.Stable.V2.t\n | Zkapp_command of Zkapp_command_applied.Stable.V1.t\n [@@deriving sexp, to_yojson]\n\n let to_latest = Fn.id\n end\n end]\n end\n\n module Fee_transfer_applied = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t =\n { fee_transfer : Fee_transfer.Stable.V2.t With_status.Stable.V2.t\n ; new_accounts : Account_id.Stable.V2.t list\n ; burned_tokens : Currency.Amount.Stable.V1.t\n }\n [@@deriving sexp, to_yojson]\n\n let to_latest = Fn.id\n end\n end]\n end\n\n module Coinbase_applied = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t =\n { coinbase : Coinbase.Stable.V1.t With_status.Stable.V2.t\n ; new_accounts : Account_id.Stable.V2.t list\n ; burned_tokens : Currency.Amount.Stable.V1.t\n }\n [@@deriving sexp, to_yojson]\n\n let to_latest = Fn.id\n end\n end]\n end\n\n module Varying = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t =\n | Command of Command_applied.Stable.V2.t\n | Fee_transfer of Fee_transfer_applied.Stable.V2.t\n | Coinbase of Coinbase_applied.Stable.V2.t\n [@@deriving sexp, to_yojson]\n\n let to_latest = Fn.id\n end\n end]\n end\n\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t =\n { previous_hash : Ledger_hash.Stable.V1.t\n ; varying : Varying.Stable.V2.t\n }\n [@@deriving sexp, to_yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n let burned_tokens : t -> Currency.Amount.t =\n fun { varying; _ } ->\n match varying with\n | Command _ ->\n Currency.Amount.zero\n | Fee_transfer f ->\n f.burned_tokens\n | Coinbase c ->\n c.burned_tokens\n\n let new_accounts : t -> Account_id.t list =\n fun { varying; _ } ->\n match varying with\n | Command c -> (\n match c with\n | Signed_command sc ->\n Signed_command_applied.new_accounts sc\n | Zkapp_command zc ->\n zc.new_accounts )\n | Fee_transfer f ->\n f.new_accounts\n | Coinbase c ->\n c.new_accounts\n\n let supply_increase : t -> Currency.Amount.Signed.t Or_error.t =\n fun t ->\n let open Or_error.Let_syntax in\n let burned_tokens = Currency.Amount.Signed.of_unsigned (burned_tokens t) in\n let account_creation_fees =\n let account_creation_fee_int =\n Genesis_constants.Constraint_constants.compiled.account_creation_fee\n |> Currency.Fee.to_nanomina_int\n in\n let num_accounts_created = List.length @@ new_accounts t in\n (* int type is OK, no danger of overflow *)\n Currency.Amount.(\n Signed.of_unsigned\n @@ of_nanomina_int_exn (account_creation_fee_int * num_accounts_created))\n in\n let txn : Transaction.t =\n match t.varying with\n | Command\n (Signed_command { common = { user_command = { data; _ }; _ }; _ }) ->\n Command (Signed_command data)\n | Command (Zkapp_command c) ->\n Command (Zkapp_command c.command.data)\n | Fee_transfer f ->\n Fee_transfer f.fee_transfer.data\n | Coinbase c ->\n Coinbase c.coinbase.data\n in\n let%bind expected_supply_increase =\n Transaction.expected_supply_increase txn\n in\n let rec process_decreases total = function\n | [] ->\n Some total\n | amt :: amts ->\n let%bind.Option sum =\n Currency.Amount.Signed.(add @@ negate amt) total\n in\n process_decreases sum amts\n in\n let total =\n process_decreases\n (Currency.Amount.Signed.of_unsigned expected_supply_increase)\n [ burned_tokens; account_creation_fees ]\n in\n Option.value_map total ~default:(Or_error.error_string \"overflow\")\n ~f:(fun v -> Ok v)\n\n let transaction_with_status : t -> Transaction.t With_status.t =\n fun { varying; _ } ->\n match varying with\n | Command (Signed_command uc) ->\n With_status.map uc.common.user_command ~f:(fun cmd ->\n Transaction.Command (User_command.Signed_command cmd) )\n | Command (Zkapp_command s) ->\n With_status.map s.command ~f:(fun c ->\n Transaction.Command (User_command.Zkapp_command c) )\n | Fee_transfer f ->\n With_status.map f.fee_transfer ~f:(fun f -> Transaction.Fee_transfer f)\n | Coinbase c ->\n With_status.map c.coinbase ~f:(fun c -> Transaction.Coinbase c)\n\n let transaction_status : t -> Transaction_status.t =\n fun { varying; _ } ->\n match varying with\n | Command\n (Signed_command { common = { user_command = { status; _ }; _ }; _ }) ->\n status\n | Command (Zkapp_command c) ->\n c.command.status\n | Fee_transfer f ->\n f.fee_transfer.status\n | Coinbase c ->\n c.coinbase.status\nend\n\nmodule type S = sig\n type ledger\n\n type location\n\n module Transaction_applied : sig\n module Signed_command_applied : sig\n module Common : sig\n type t = Transaction_applied.Signed_command_applied.Common.t =\n { user_command : Signed_command.t With_status.t }\n [@@deriving sexp]\n end\n\n module Body : sig\n type t = Transaction_applied.Signed_command_applied.Body.t =\n | Payment of { new_accounts : Account_id.t list }\n | Stake_delegation of\n { previous_delegate : Public_key.Compressed.t option }\n | Failed\n [@@deriving sexp]\n end\n\n type t = Transaction_applied.Signed_command_applied.t =\n { common : Common.t; body : Body.t }\n [@@deriving sexp]\n end\n\n module Zkapp_command_applied : sig\n type t = Transaction_applied.Zkapp_command_applied.t =\n { accounts : (Account_id.t * Account.t option) list\n ; command : Zkapp_command.t With_status.t\n ; new_accounts : Account_id.t list\n }\n [@@deriving sexp]\n end\n\n module Command_applied : sig\n type t = Transaction_applied.Command_applied.t =\n | Signed_command of Signed_command_applied.t\n | Zkapp_command of Zkapp_command_applied.t\n [@@deriving sexp]\n end\n\n module Fee_transfer_applied : sig\n type t = Transaction_applied.Fee_transfer_applied.t =\n { fee_transfer : Fee_transfer.t With_status.t\n ; new_accounts : Account_id.t list\n ; burned_tokens : Currency.Amount.t\n }\n [@@deriving sexp]\n end\n\n module Coinbase_applied : sig\n type t = Transaction_applied.Coinbase_applied.t =\n { coinbase : Coinbase.t With_status.t\n ; new_accounts : Account_id.t list\n ; burned_tokens : Currency.Amount.t\n }\n [@@deriving sexp]\n end\n\n module Varying : sig\n type t = Transaction_applied.Varying.t =\n | Command of Command_applied.t\n | Fee_transfer of Fee_transfer_applied.t\n | Coinbase of Coinbase_applied.t\n [@@deriving sexp]\n end\n\n type t = Transaction_applied.t =\n { previous_hash : Ledger_hash.t; varying : Varying.t }\n [@@deriving sexp]\n\n val burned_tokens : t -> Currency.Amount.t\n\n val supply_increase : t -> Currency.Amount.Signed.t Or_error.t\n\n val transaction : t -> Transaction.t With_status.t\n\n val transaction_status : t -> Transaction_status.t\n end\n\n module Global_state : sig\n type t =\n { first_pass_ledger : ledger\n ; second_pass_ledger : ledger\n ; fee_excess : Amount.Signed.t\n ; supply_increase : Amount.Signed.t\n ; protocol_state : Zkapp_precondition.Protocol_state.View.t\n ; block_global_slot : Mina_numbers.Global_slot_since_genesis.t\n (* Slot of block when the transaction is applied. NOTE: This is at least 1 slot after the protocol_state's view, which is for the *previous* slot. *)\n }\n end\n\n module Transaction_partially_applied : sig\n module Zkapp_command_partially_applied : sig\n type t =\n { command : Zkapp_command.t\n ; previous_hash : Ledger_hash.t\n ; original_first_pass_account_states :\n (Account_id.t * (location * Account.t) option) list\n ; constraint_constants : Genesis_constants.Constraint_constants.t\n ; state_view : Zkapp_precondition.Protocol_state.View.t\n ; global_state : Global_state.t\n ; local_state :\n ( Stack_frame.value\n , Stack_frame.value list\n , Amount.Signed.t\n , ledger\n , bool\n , Zkapp_command.Transaction_commitment.t\n , Mina_numbers.Index.t\n , Transaction_status.Failure.Collection.t )\n Zkapp_command_logic.Local_state.t\n }\n end\n\n type 'applied fully_applied =\n { previous_hash : Ledger_hash.t; applied : 'applied }\n\n type t =\n | Signed_command of\n Transaction_applied.Signed_command_applied.t fully_applied\n | Zkapp_command of Zkapp_command_partially_applied.t\n | Fee_transfer of Transaction_applied.Fee_transfer_applied.t fully_applied\n | Coinbase of Transaction_applied.Coinbase_applied.t fully_applied\n\n val command : t -> Transaction.t\n end\n\n val apply_user_command :\n constraint_constants:Genesis_constants.Constraint_constants.t\n -> txn_global_slot:Global_slot_since_genesis.t\n -> ledger\n -> Signed_command.With_valid_signature.t\n -> Transaction_applied.Signed_command_applied.t Or_error.t\n\n val apply_user_command_unchecked :\n constraint_constants:Genesis_constants.Constraint_constants.t\n -> txn_global_slot:Global_slot_since_genesis.t\n -> ledger\n -> Signed_command.t\n -> Transaction_applied.Signed_command_applied.t Or_error.t\n\n val update_action_state :\n Snark_params.Tick.Field.t Pickles_types.Vector.Vector_5.t\n -> Zkapp_account.Actions.t\n -> txn_global_slot:Global_slot_since_genesis.t\n -> last_action_slot:Global_slot_since_genesis.t\n -> Snark_params.Tick.Field.t Pickles_types.Vector.Vector_5.t\n * Global_slot_since_genesis.t\n\n val apply_zkapp_command_unchecked :\n constraint_constants:Genesis_constants.Constraint_constants.t\n -> global_slot:Mina_numbers.Global_slot_since_genesis.t\n -> state_view:Zkapp_precondition.Protocol_state.View.t\n -> ledger\n -> Zkapp_command.t\n -> ( Transaction_applied.Zkapp_command_applied.t\n * ( ( Stack_frame.value\n , Stack_frame.value list\n , Amount.Signed.t\n , ledger\n , bool\n , Zkapp_command.Transaction_commitment.t\n , Mina_numbers.Index.t\n , Transaction_status.Failure.Collection.t )\n Zkapp_command_logic.Local_state.t\n * Amount.Signed.t ) )\n Or_error.t\n\n (** Apply all zkapp_command within a zkapp_command transaction. This behaves as\n [apply_zkapp_command_unchecked], except that the [~init] and [~f] arguments\n are provided to allow for the accumulation of the intermediate states.\n\n Invariant: [f] is always applied at least once, so it is valid to use an\n [_ option] as the initial state and call [Option.value_exn] on the\n accumulated result.\n\n This can be used to collect the intermediate states to make them\n available for snark work. In particular, since the transaction snark has\n a cap on the number of zkapp_command of each kind that may be included, we can\n use this to retrieve the (source, target) pairs for each batch of\n zkapp_command to include in the snark work spec / transaction snark witness.\n *)\n val apply_zkapp_command_unchecked_aux :\n constraint_constants:Genesis_constants.Constraint_constants.t\n -> global_slot:Mina_numbers.Global_slot_since_genesis.t\n -> state_view:Zkapp_precondition.Protocol_state.View.t\n -> init:'acc\n -> f:\n ( 'acc\n -> Global_state.t\n * ( Stack_frame.value\n , Stack_frame.value list\n , Amount.Signed.t\n , ledger\n , bool\n , Zkapp_command.Transaction_commitment.t\n , Mina_numbers.Index.t\n , Transaction_status.Failure.Collection.t )\n Zkapp_command_logic.Local_state.t\n -> 'acc )\n -> ?fee_excess:Amount.Signed.t\n -> ?supply_increase:Amount.Signed.t\n -> ledger\n -> Zkapp_command.t\n -> (Transaction_applied.Zkapp_command_applied.t * 'acc) Or_error.t\n\n val apply_zkapp_command_first_pass_aux :\n constraint_constants:Genesis_constants.Constraint_constants.t\n -> global_slot:Mina_numbers.Global_slot_since_genesis.t\n -> state_view:Zkapp_precondition.Protocol_state.View.t\n -> init:'acc\n -> f:\n ( 'acc\n -> Global_state.t\n * ( Stack_frame.value\n , Stack_frame.value list\n , Amount.Signed.t\n , ledger\n , bool\n , Zkapp_command.Transaction_commitment.t\n , Mina_numbers.Index.t\n , Transaction_status.Failure.Collection.t )\n Zkapp_command_logic.Local_state.t\n -> 'acc )\n -> ?fee_excess:Amount.Signed.t\n -> ?supply_increase:Amount.Signed.t\n -> ledger\n -> Zkapp_command.t\n -> (Transaction_partially_applied.Zkapp_command_partially_applied.t * 'acc)\n Or_error.t\n\n val apply_zkapp_command_second_pass_aux :\n init:'acc\n -> f:\n ( 'acc\n -> Global_state.t\n * ( Stack_frame.value\n , Stack_frame.value list\n , Amount.Signed.t\n , ledger\n , bool\n , Zkapp_command.Transaction_commitment.t\n , Mina_numbers.Index.t\n , Transaction_status.Failure.Collection.t )\n Zkapp_command_logic.Local_state.t\n -> 'acc )\n -> ledger\n -> Transaction_partially_applied.Zkapp_command_partially_applied.t\n -> (Transaction_applied.Zkapp_command_applied.t * 'acc) Or_error.t\n\n val apply_fee_transfer :\n constraint_constants:Genesis_constants.Constraint_constants.t\n -> txn_global_slot:Global_slot_since_genesis.t\n -> ledger\n -> Fee_transfer.t\n -> Transaction_applied.Fee_transfer_applied.t Or_error.t\n\n val apply_coinbase :\n constraint_constants:Genesis_constants.Constraint_constants.t\n -> txn_global_slot:Global_slot_since_genesis.t\n -> ledger\n -> Coinbase.t\n -> Transaction_applied.Coinbase_applied.t Or_error.t\n\n val apply_transaction_first_pass :\n constraint_constants:Genesis_constants.Constraint_constants.t\n -> global_slot:Global_slot_since_genesis.t\n -> txn_state_view:Zkapp_precondition.Protocol_state.View.t\n -> ledger\n -> Transaction.t\n -> Transaction_partially_applied.t Or_error.t\n\n val apply_transaction_second_pass :\n ledger\n -> Transaction_partially_applied.t\n -> Transaction_applied.t Or_error.t\n\n val apply_transactions :\n constraint_constants:Genesis_constants.Constraint_constants.t\n -> global_slot:Mina_numbers.Global_slot_since_genesis.t\n -> txn_state_view:Zkapp_precondition.Protocol_state.View.t\n -> ledger\n -> Transaction.t list\n -> Transaction_applied.t list Or_error.t\n\n val has_locked_tokens :\n global_slot:Global_slot_since_genesis.t\n -> account_id:Account_id.t\n -> ledger\n -> bool Or_error.t\n\n module For_tests : sig\n val validate_timing_with_min_balance :\n account:Account.t\n -> txn_amount:Amount.t\n -> txn_global_slot:Global_slot_since_genesis.t\n -> (Account.Timing.t * [> `Min_balance of Balance.t ]) Or_error.t\n\n val validate_timing :\n account:Account.t\n -> txn_amount:Amount.t\n -> txn_global_slot:Global_slot_since_genesis.t\n -> Account.Timing.t Or_error.t\n end\nend\n\n(* tags for timing validation errors *)\nlet nsf_tag = \"nsf\"\n\nlet min_balance_tag = \"minbal\"\n\nlet timing_error_to_user_command_status err =\n match Error.Internal_repr.of_info err with\n | Tag_t (tag, _) when String.equal tag nsf_tag ->\n Transaction_status.Failure.Source_insufficient_balance\n | Tag_t (tag, _) when String.equal tag min_balance_tag ->\n Transaction_status.Failure.Source_minimum_balance_violation\n | _ ->\n failwith \"Unexpected timed account validation error\"\n\n(** [validate_timing_with_min_balance' ~account ~txn_amount ~txn_global_slot]\n returns a tuple of 3 values:\n * [[`Insufficient_balance of bool | `Invalid_timing of bool]] encodes\n possible errors, with the invariant that the return value is always\n [`Invalid_timing false] if there was no error.\n - [`Insufficient_balance true] results if [txn_amount] is larger than the\n balance held in [account].\n - [`Invalid_timing true] results if [txn_amount] is larger than the\n balance available in [account] at global slot [txn_global_slot].\n * [Timing.t], the new timing for [account] calculated at [txn_global_slot].\n * [[`Min_balance of Balance.t]] returns the computed available balance at\n [txn_global_slot].\n - NOTE: We skip this calculation if the error is\n [`Insufficient_balance true]. In this scenario, this value MUST NOT be\n used, as it contains an incorrect placeholder value.\n*)\nlet validate_timing_with_min_balance' ~account ~txn_amount ~txn_global_slot =\n let open Account.Poly in\n let open Account.Timing.Poly in\n match account.timing with\n | Untimed -> (\n (* no time restrictions *)\n match Balance.(account.balance - txn_amount) with\n | None ->\n (`Insufficient_balance true, Untimed, `Min_balance Balance.zero)\n | _ ->\n (`Invalid_timing false, Untimed, `Min_balance Balance.zero) )\n | Timed\n { initial_minimum_balance\n ; cliff_time\n ; cliff_amount\n ; vesting_period\n ; vesting_increment\n } ->\n let invalid_balance, invalid_timing, curr_min_balance =\n let account_balance = account.balance in\n match Balance.(account_balance - txn_amount) with\n | None ->\n (* NB: The [initial_minimum_balance] here is the incorrect value,\n but:\n * we don't use it anywhere in this error case; and\n * we don't want to waste time computing it if it will be unused.\n *)\n (true, false, initial_minimum_balance)\n | Some proposed_new_balance ->\n let curr_min_balance =\n Account.min_balance_at_slot ~global_slot:txn_global_slot\n ~cliff_time ~cliff_amount ~vesting_period ~vesting_increment\n ~initial_minimum_balance\n in\n if Balance.(proposed_new_balance < curr_min_balance) then\n (false, true, curr_min_balance)\n else (false, false, curr_min_balance)\n in\n (* once the calculated minimum balance becomes zero, the account becomes untimed *)\n let possibly_error =\n if invalid_balance then `Insufficient_balance invalid_balance\n else `Invalid_timing invalid_timing\n in\n if Balance.(curr_min_balance > zero) then\n (possibly_error, account.timing, `Min_balance curr_min_balance)\n else (possibly_error, Untimed, `Min_balance Balance.zero)\n\nlet validate_timing_with_min_balance ~account ~txn_amount ~txn_global_slot =\n let open Or_error.Let_syntax in\n let nsf_error kind =\n Or_error.errorf\n !\"For %s account, the requested transaction for amount %{sexp: Amount.t} \\\n at global slot %{sexp: Global_slot_since_genesis.t}, the balance \\\n %{sexp: Balance.t} is insufficient\"\n kind txn_amount txn_global_slot account.Account.Poly.balance\n |> Or_error.tag ~tag:nsf_tag\n in\n let min_balance_error min_balance =\n Or_error.errorf\n !\"For timed account, the requested transaction for amount %{sexp: \\\n Amount.t} at global slot %{sexp: Global_slot_since_genesis.t}, \\\n applying the transaction would put the balance below the calculated \\\n minimum balance of %{sexp: Balance.t}\"\n txn_amount txn_global_slot min_balance\n |> Or_error.tag ~tag:min_balance_tag\n in\n let possibly_error, timing, (`Min_balance curr_min_balance as min_balance) =\n validate_timing_with_min_balance' ~account ~txn_amount ~txn_global_slot\n in\n match possibly_error with\n | `Insufficient_balance true ->\n nsf_error \"timed\"\n | `Invalid_timing true ->\n min_balance_error curr_min_balance\n | `Insufficient_balance false ->\n failwith \"Broken invariant in validate_timing_with_min_balance'\"\n | `Invalid_timing false ->\n return (timing, min_balance)\n\nlet validate_timing ~account ~txn_amount ~txn_global_slot =\n let open Result.Let_syntax in\n let%map timing, `Min_balance _ =\n validate_timing_with_min_balance ~account ~txn_amount ~txn_global_slot\n in\n timing\n\nmodule Make (L : Ledger_intf.S) :\n S with type ledger := L.t and type location := L.location = struct\n open L\n\n let error s = Or_error.errorf \"Ledger.apply_transaction: %s\" s\n\n let error_opt e = Option.value_map ~default:(error e) ~f:Or_error.return\n\n let get_with_location ledger account_id =\n match location_of_account ledger account_id with\n | Some location -> (\n match get ledger location with\n | Some account ->\n Ok (`Existing location, account)\n | None ->\n failwith \"Ledger location with no account\" )\n | None ->\n Ok (`New, Account.create account_id Balance.zero)\n\n let set_with_location ledger location account =\n match location with\n | `Existing location ->\n Ok (set ledger location account)\n | `New ->\n create_new_account ledger (Account.identifier account) account\n\n let add_amount balance amount =\n error_opt \"overflow\" (Balance.add_amount balance amount)\n\n let sub_amount balance amount =\n error_opt \"insufficient funds\" (Balance.sub_amount balance amount)\n\n let sub_account_creation_fee\n ~(constraint_constants : Genesis_constants.Constraint_constants.t) action\n amount =\n let fee = constraint_constants.account_creation_fee in\n if Ledger_intf.equal_account_state action `Added then\n error_opt\n (sprintf\n !\"Error subtracting account creation fee %{sexp: Currency.Fee.t}; \\\n transaction amount %{sexp: Currency.Amount.t} insufficient\"\n fee amount )\n Amount.(sub amount (of_fee fee))\n else Ok amount\n\n let check b = ksprintf (fun s -> if b then Ok () else Or_error.error_string s)\n\n let validate_nonces txn_nonce account_nonce =\n check\n (Account.Nonce.equal account_nonce txn_nonce)\n !\"Nonce in account %{sexp: Account.Nonce.t} different from nonce in \\\n transaction %{sexp: Account.Nonce.t}\"\n account_nonce txn_nonce\n\n let validate_time ~valid_until ~current_global_slot =\n check\n Global_slot_since_genesis.(current_global_slot <= valid_until)\n !\"Current global slot %{sexp: Global_slot_since_genesis.t} greater than \\\n transaction expiry slot %{sexp: Global_slot_since_genesis.t}\"\n current_global_slot valid_until\n\n module Transaction_applied = struct\n include Transaction_applied\n\n let transaction : t -> Transaction.t With_status.t =\n fun { varying; _ } ->\n match varying with\n | Command (Signed_command uc) ->\n With_status.map uc.common.user_command ~f:(fun cmd ->\n Transaction.Command (User_command.Signed_command cmd) )\n | Command (Zkapp_command s) ->\n With_status.map s.command ~f:(fun c ->\n Transaction.Command (User_command.Zkapp_command c) )\n | Fee_transfer f ->\n With_status.map f.fee_transfer ~f:(fun f ->\n Transaction.Fee_transfer f )\n | Coinbase c ->\n With_status.map c.coinbase ~f:(fun c -> Transaction.Coinbase c)\n\n let transaction_status : t -> Transaction_status.t =\n fun { varying; _ } ->\n match varying with\n | Command\n (Signed_command { common = { user_command = { status; _ }; _ }; _ })\n ->\n status\n | Command (Zkapp_command c) ->\n c.command.status\n | Fee_transfer f ->\n f.fee_transfer.status\n | Coinbase c ->\n c.coinbase.status\n end\n\n let get_new_accounts action pk =\n if Ledger_intf.equal_account_state action `Added then [ pk ] else []\n\n let has_locked_tokens ~global_slot ~account_id ledger =\n let open Or_error.Let_syntax in\n let%map _, account = get_with_location ledger account_id in\n Account.has_locked_tokens ~global_slot account\n\n let failure (e : Transaction_status.Failure.t) = e\n\n let incr_balance (acct : Account.t) amt =\n match add_amount acct.balance amt with\n | Ok balance ->\n Ok { acct with balance }\n | Error _ ->\n Result.fail (failure Overflow)\n\n (* Helper function for [apply_user_command_unchecked] *)\n let pay_fee' ~command ~nonce ~fee_payer ~fee ~ledger ~current_global_slot =\n let open Or_error.Let_syntax in\n (* Fee-payer information *)\n let%bind location, account = get_with_location ledger fee_payer in\n let%bind () =\n match location with\n | `Existing _ ->\n return ()\n | `New ->\n Or_error.errorf \"The fee-payer account does not exist\"\n in\n let fee = Amount.of_fee fee in\n let%bind balance = sub_amount account.balance fee in\n let%bind () = validate_nonces nonce account.nonce in\n let%map timing =\n validate_timing ~txn_amount:fee ~txn_global_slot:current_global_slot\n ~account\n in\n ( location\n , { account with\n balance\n ; nonce = Account.Nonce.succ account.nonce\n ; receipt_chain_hash =\n Receipt.Chain_hash.cons_signed_command_payload command\n account.receipt_chain_hash\n ; timing\n } )\n\n (* Helper function for [apply_user_command_unchecked] *)\n let pay_fee ~user_command ~signer_pk ~ledger ~current_global_slot =\n let open Or_error.Let_syntax in\n (* Fee-payer information *)\n let nonce = Signed_command.nonce user_command in\n let fee_payer = Signed_command.fee_payer user_command in\n let%bind () =\n let fee_token = Signed_command.fee_token user_command in\n let%bind () =\n (* TODO: Enable multi-sig. *)\n if\n Public_key.Compressed.equal\n (Account_id.public_key fee_payer)\n signer_pk\n then return ()\n else\n Or_error.errorf\n \"Cannot pay fees from a public key that did not sign the \\\n transaction\"\n in\n let%map () =\n (* TODO: Remove this check and update the transaction snark once we have\n an exchange rate mechanism. See issue #4447.\n *)\n if Token_id.equal fee_token Token_id.default then return ()\n else\n Or_error.errorf\n \"Cannot create transactions with fee_token different from the \\\n default\"\n in\n ()\n in\n let%map loc, account' =\n pay_fee' ~command:(Signed_command_payload user_command.payload) ~nonce\n ~fee_payer\n ~fee:(Signed_command.fee user_command)\n ~ledger ~current_global_slot\n in\n (loc, account')\n\n (* someday: It would probably be better if we didn't modify the receipt chain hash\n in the case that the sender is equal to the receiver, but it complicates the SNARK, so\n we don't for now. *)\n let apply_user_command_unchecked\n ~(constraint_constants : Genesis_constants.Constraint_constants.t)\n ~txn_global_slot ledger\n ({ payload; signer; signature = _ } as user_command : Signed_command.t) =\n let open Or_error.Let_syntax in\n let signer_pk = Public_key.compress signer in\n let current_global_slot = txn_global_slot in\n let%bind () =\n validate_time\n ~valid_until:(Signed_command.valid_until user_command)\n ~current_global_slot\n in\n (* Fee-payer information *)\n let fee_payer = Signed_command.fee_payer user_command in\n let%bind fee_payer_location, fee_payer_account =\n pay_fee ~user_command ~signer_pk ~ledger ~current_global_slot\n in\n let%bind () =\n if Account.has_permission_to_send fee_payer_account then Ok ()\n else\n Or_error.error_string\n Transaction_status.Failure.(describe Update_not_permitted_balance)\n in\n let%bind () =\n if Account.has_permission_to_increment_nonce fee_payer_account then Ok ()\n else\n Or_error.error_string\n Transaction_status.Failure.(describe Update_not_permitted_nonce)\n in\n (* Charge the fee. This must happen, whether or not the command itself\n succeeds, to ensure that the network is compensated for processing this\n command.\n *)\n let%bind () =\n set_with_location ledger fee_payer_location fee_payer_account\n in\n let receiver = Signed_command.receiver user_command in\n let exception Reject of Error.t in\n let ok_or_reject = function Ok x -> x | Error err -> raise (Reject err) in\n let compute_updates () =\n let open Result.Let_syntax in\n (* Compute the necessary changes to apply the command, failing if any of\n the conditions are not met.\n *)\n match payload.body with\n | Stake_delegation _ ->\n let receiver_location, _receiver_account =\n (* Check that receiver account exists. *)\n get_with_location ledger receiver |> ok_or_reject\n in\n let%bind () =\n match receiver_location with\n | `Existing _ ->\n return ()\n | `New ->\n Result.fail Transaction_status.Failure.Receiver_not_present\n in\n let%bind () =\n Result.ok_if_true\n (Account.has_permission_to_set_delegate fee_payer_account)\n ~error:Transaction_status.Failure.Update_not_permitted_delegate\n in\n let previous_delegate = fee_payer_account.delegate in\n (* Timing is always valid, but we need to record any switch from\n timed to untimed here to stay in sync with the snark.\n *)\n let%map fee_payer_account =\n let%map timing =\n validate_timing ~txn_amount:Amount.zero\n ~txn_global_slot:current_global_slot ~account:fee_payer_account\n |> Result.map_error ~f:timing_error_to_user_command_status\n in\n { fee_payer_account with\n delegate = Some (Account_id.public_key receiver)\n ; timing\n }\n in\n ( [ (fee_payer_location, fee_payer_account) ]\n , Transaction_applied.Signed_command_applied.Body.Stake_delegation\n { previous_delegate } )\n | Payment { amount; _ } ->\n let%bind fee_payer_account =\n let ret =\n let%bind balance =\n Result.map_error (sub_amount fee_payer_account.balance amount)\n ~f:(fun _ ->\n Transaction_status.Failure.Source_insufficient_balance )\n in\n let%map timing =\n validate_timing ~txn_amount:amount\n ~txn_global_slot:current_global_slot\n ~account:fee_payer_account\n |> Result.map_error ~f:timing_error_to_user_command_status\n in\n { fee_payer_account with balance; timing }\n in\n (* Don't accept transactions with insufficient balance from the fee-payer.\n TODO: eliminate this condition and accept transaction with failed status\n *)\n match ret with\n | Ok x ->\n Ok x\n | Error failure ->\n raise\n (Reject\n (Error.createf \"%s\"\n (Transaction_status.Failure.describe failure) ) )\n in\n let receiver_location, receiver_account =\n if Account_id.equal fee_payer receiver then\n (fee_payer_location, fee_payer_account)\n else get_with_location ledger receiver |> ok_or_reject\n in\n let%bind () =\n Result.ok_if_true\n (Account.has_permission_to_send fee_payer_account)\n ~error:Transaction_status.Failure.Update_not_permitted_balance\n in\n let%bind () =\n Result.ok_if_true\n (Account.has_permission_to_receive receiver_account)\n ~error:Transaction_status.Failure.Update_not_permitted_balance\n in\n (* Charge the account creation fee. *)\n let%bind receiver_amount =\n match receiver_location with\n | `Existing _ ->\n return amount\n | `New ->\n (* Subtract the creation fee from the transaction amount. *)\n sub_account_creation_fee ~constraint_constants `Added amount\n |> Result.map_error ~f:(fun _ ->\n Transaction_status.Failure\n .Amount_insufficient_to_create_account )\n in\n let%map receiver_account =\n incr_balance receiver_account receiver_amount\n in\n let new_accounts =\n match receiver_location with\n | `Existing _ ->\n []\n | `New ->\n [ receiver ]\n in\n let updated_accounts =\n if Account_id.equal fee_payer receiver then\n (* [receiver_account] at this point has all the updates*)\n [ (receiver_location, receiver_account) ]\n else\n [ (receiver_location, receiver_account)\n ; (fee_payer_location, fee_payer_account)\n ]\n in\n ( updated_accounts\n , Transaction_applied.Signed_command_applied.Body.Payment\n { new_accounts } )\n in\n match compute_updates () with\n | Ok (located_accounts, applied_body) ->\n (* Update the ledger. *)\n let%bind () =\n List.fold located_accounts ~init:(Ok ())\n ~f:(fun acc (location, account) ->\n let%bind () = acc in\n set_with_location ledger location account )\n in\n let applied_common : Transaction_applied.Signed_command_applied.Common.t\n =\n { user_command = { data = user_command; status = Applied } }\n in\n return\n ( { common = applied_common; body = applied_body }\n : Transaction_applied.Signed_command_applied.t )\n | Error failure ->\n (* Do not update the ledger. Except for the fee payer which is already updated *)\n let applied_common : Transaction_applied.Signed_command_applied.Common.t\n =\n { user_command =\n { data = user_command\n ; status =\n Failed\n (Transaction_status.Failure.Collection.of_single_failure\n failure )\n }\n }\n in\n return\n ( { common = applied_common; body = Failed }\n : Transaction_applied.Signed_command_applied.t )\n | exception Reject err ->\n (* TODO: These transactions should never reach this stage, this error\n should be fatal.\n *)\n Error err\n\n let apply_user_command ~constraint_constants ~txn_global_slot ledger\n (user_command : Signed_command.With_valid_signature.t) =\n apply_user_command_unchecked ~constraint_constants ~txn_global_slot ledger\n (Signed_command.forget_check user_command)\n\n module Global_state = struct\n type t =\n { first_pass_ledger : L.t\n ; second_pass_ledger : L.t\n ; fee_excess : Amount.Signed.t\n ; supply_increase : Amount.Signed.t\n ; protocol_state : Zkapp_precondition.Protocol_state.View.t\n ; block_global_slot : Global_slot_since_genesis.t\n }\n\n let first_pass_ledger { first_pass_ledger; _ } =\n L.create_masked first_pass_ledger\n\n let set_first_pass_ledger ~should_update t ledger =\n if should_update then L.apply_mask t.first_pass_ledger ~masked:ledger ;\n t\n\n let second_pass_ledger { second_pass_ledger; _ } =\n L.create_masked second_pass_ledger\n\n let set_second_pass_ledger ~should_update t ledger =\n if should_update then L.apply_mask t.second_pass_ledger ~masked:ledger ;\n t\n\n let fee_excess { fee_excess; _ } = fee_excess\n\n let set_fee_excess t fee_excess = { t with fee_excess }\n\n let supply_increase { supply_increase; _ } = supply_increase\n\n let set_supply_increase t supply_increase = { t with supply_increase }\n\n let block_global_slot { block_global_slot; _ } = block_global_slot\n end\n\n module Transaction_partially_applied = struct\n module Zkapp_command_partially_applied = struct\n type t =\n { command : Zkapp_command.t\n ; previous_hash : Ledger_hash.t\n ; original_first_pass_account_states :\n (Account_id.t * (location * Account.t) option) list\n ; constraint_constants : Genesis_constants.Constraint_constants.t\n ; state_view : Zkapp_precondition.Protocol_state.View.t\n ; global_state : Global_state.t\n ; local_state :\n ( Stack_frame.value\n , Stack_frame.value list\n , Amount.Signed.t\n , L.t\n , bool\n , Zkapp_command.Transaction_commitment.t\n , Mina_numbers.Index.t\n , Transaction_status.Failure.Collection.t )\n Zkapp_command_logic.Local_state.t\n }\n end\n\n type 'applied fully_applied =\n { previous_hash : Ledger_hash.t; applied : 'applied }\n\n (* TODO: lift previous_hash up in the types *)\n type t =\n | Signed_command of\n Transaction_applied.Signed_command_applied.t fully_applied\n | Zkapp_command of Zkapp_command_partially_applied.t\n | Fee_transfer of Transaction_applied.Fee_transfer_applied.t fully_applied\n | Coinbase of Transaction_applied.Coinbase_applied.t fully_applied\n\n let command (t : t) : Transaction.t =\n match t with\n | Signed_command s ->\n Transaction.Command\n (User_command.Signed_command s.applied.common.user_command.data)\n | Zkapp_command z ->\n Command (User_command.Zkapp_command z.command)\n | Fee_transfer f ->\n Fee_transfer f.applied.fee_transfer.data\n | Coinbase c ->\n Coinbase c.applied.coinbase.data\n end\n\n module Inputs = struct\n let with_label ~label:_ f = f ()\n\n let value_if b ~then_ ~else_ = if b then then_ else else_\n\n module Global_state = Global_state\n\n module Field = struct\n type t = Snark_params.Tick.Field.t\n\n let if_ = value_if\n\n let equal = Snark_params.Tick.Field.equal\n end\n\n module Bool = struct\n type t = bool\n\n module Assert = struct\n let is_true ~pos b =\n try assert b\n with Assert_failure _ ->\n let file, line, col, _ecol = pos in\n raise (Assert_failure (file, line, col))\n\n let any ~pos bs = List.exists ~f:Fn.id bs |> is_true ~pos\n end\n\n let if_ = value_if\n\n let true_ = true\n\n let false_ = false\n\n let equal = Bool.equal\n\n let not = not\n\n let ( ||| ) = ( || )\n\n let ( &&& ) = ( && )\n\n let display b ~label = sprintf \"%s: %b\" label b\n\n let all = List.for_all ~f:Fn.id\n\n type failure_status = Transaction_status.Failure.t option\n\n type failure_status_tbl = Transaction_status.Failure.Collection.t\n\n let is_empty t = List.join t |> List.is_empty\n\n let assert_with_failure_status_tbl ~pos b failure_status_tbl =\n let file, line, col, ecol = pos in\n if (not b) && not (is_empty failure_status_tbl) then\n (* Raise a more useful error message if we have a failure\n description. *)\n let failure_msg =\n Yojson.Safe.to_string\n @@ Transaction_status.Failure.Collection.Display.to_yojson\n @@ Transaction_status.Failure.Collection.to_display\n failure_status_tbl\n in\n Error.raise @@ Error.of_string\n @@ sprintf \"File %S, line %d, characters %d-%d: %s\" file line col ecol\n failure_msg\n else\n try assert b\n with Assert_failure _ -> raise (Assert_failure (file, line, col))\n end\n\n module Account_id = struct\n include Account_id\n\n let if_ = value_if\n end\n\n module Ledger = struct\n type t = L.t\n\n let if_ = value_if\n\n let empty = L.empty\n\n type inclusion_proof = [ `Existing of location | `New ]\n\n let get_account p l =\n let loc, acct =\n Or_error.ok_exn (get_with_location l (Account_update.account_id p))\n in\n (acct, loc)\n\n let set_account l (a, loc) =\n Or_error.ok_exn (set_with_location l loc a) ;\n l\n\n let check_inclusion _ledger (_account, _loc) = ()\n\n let check_account public_key token_id\n ((account, loc) : Account.t * inclusion_proof) =\n assert (Public_key.Compressed.equal public_key account.public_key) ;\n assert (Token_id.equal token_id account.token_id) ;\n match loc with `Existing _ -> `Is_new false | `New -> `Is_new true\n end\n\n module Transaction_commitment = struct\n type t = Field.t\n\n let empty = Zkapp_command.Transaction_commitment.empty\n\n let commitment ~account_updates =\n let account_updates_hash =\n Mina_base.Zkapp_command.Call_forest.hash account_updates\n in\n Zkapp_command.Transaction_commitment.create ~account_updates_hash\n\n let full_commitment ~account_update ~memo_hash ~commitment =\n (* when called from Zkapp_command_logic.apply, the account_update is the fee payer *)\n let fee_payer_hash =\n Zkapp_command.Digest.Account_update.create account_update\n in\n Zkapp_command.Transaction_commitment.create_complete commitment\n ~memo_hash ~fee_payer_hash\n\n let if_ = value_if\n end\n\n module Index = struct\n type t = Mina_numbers.Index.t\n\n let zero, succ = Mina_numbers.Index.(zero, succ)\n\n let if_ = value_if\n end\n\n module Public_key = struct\n type t = Public_key.Compressed.t\n\n let if_ = value_if\n end\n\n module Controller = struct\n type t = Permissions.Auth_required.t\n\n let if_ = value_if\n\n let check ~proof_verifies ~signature_verifies perm =\n (* Invariant: We either have a proof, a signature, or neither. *)\n assert (not (proof_verifies && signature_verifies)) ;\n let tag =\n if proof_verifies then Control.Tag.Proof\n else if signature_verifies then Control.Tag.Signature\n else Control.Tag.None_given\n in\n Permissions.Auth_required.check perm tag\n end\n\n module Global_slot_since_genesis = struct\n include Mina_numbers.Global_slot_since_genesis\n\n let if_ = value_if\n end\n\n module Global_slot_span = struct\n include Mina_numbers.Global_slot_span\n\n let if_ = value_if\n end\n\n module Nonce = struct\n type t = Account.Nonce.t\n\n let if_ = value_if\n\n let succ = Account.Nonce.succ\n end\n\n module Receipt_chain_hash = struct\n type t = Receipt.Chain_hash.t\n\n module Elt = struct\n type t = Receipt.Zkapp_command_elt.t\n\n let of_transaction_commitment tc =\n Receipt.Zkapp_command_elt.Zkapp_command_commitment tc\n end\n\n let cons_zkapp_command_commitment =\n Receipt.Chain_hash.cons_zkapp_command_commitment\n\n let if_ = value_if\n end\n\n module State_hash = struct\n include State_hash\n\n let if_ = value_if\n end\n\n module Timing = struct\n type t = Account_update.Update.Timing_info.t option\n\n let if_ = value_if\n\n let vesting_period (t : t) =\n match t with\n | Some t ->\n t.vesting_period\n | None ->\n (Account_timing.to_record Untimed).vesting_period\n end\n\n module Balance = struct\n include Balance\n\n let if_ = value_if\n end\n\n module Verification_key = struct\n type t = (Side_loaded_verification_key.t, Field.t) With_hash.t option\n\n let if_ = value_if\n end\n\n module Verification_key_hash = struct\n type t = Field.t option\n\n let equal vk1 vk2 = Option.equal Field.equal vk1 vk2\n end\n\n module Actions = struct\n type t = Zkapp_account.Actions.t\n\n let is_empty = List.is_empty\n\n let push_events = Account_update.Actions.push_events\n end\n\n module Zkapp_uri = struct\n type t = string\n\n let if_ = value_if\n end\n\n module Token_symbol = struct\n type t = Account.Token_symbol.t\n\n let if_ = value_if\n end\n\n module Account = struct\n include Account\n\n module Permissions = struct\n let access : t -> Controller.t = fun a -> a.permissions.access\n\n let edit_state : t -> Controller.t = fun a -> a.permissions.edit_state\n\n let send : t -> Controller.t = fun a -> a.permissions.send\n\n let receive : t -> Controller.t = fun a -> a.permissions.receive\n\n let set_delegate : t -> Controller.t =\n fun a -> a.permissions.set_delegate\n\n let set_permissions : t -> Controller.t =\n fun a -> a.permissions.set_permissions\n\n let set_verification_key : t -> Controller.t =\n fun a -> a.permissions.set_verification_key\n\n let set_zkapp_uri : t -> Controller.t =\n fun a -> a.permissions.set_zkapp_uri\n\n let edit_action_state : t -> Controller.t =\n fun a -> a.permissions.edit_action_state\n\n let set_token_symbol : t -> Controller.t =\n fun a -> a.permissions.set_token_symbol\n\n let increment_nonce : t -> Controller.t =\n fun a -> a.permissions.increment_nonce\n\n let set_voting_for : t -> Controller.t =\n fun a -> a.permissions.set_voting_for\n\n let set_timing : t -> Controller.t = fun a -> a.permissions.set_timing\n\n type t = Permissions.t\n\n let if_ = value_if\n end\n\n type timing = Account_update.Update.Timing_info.t option\n\n let timing (a : t) : timing =\n Account_update.Update.Timing_info.of_account_timing a.timing\n\n let set_timing (a : t) (timing : timing) : t =\n { a with\n timing =\n Option.value_map ~default:Account_timing.Untimed\n ~f:Account_update.Update.Timing_info.to_account_timing timing\n }\n\n let is_timed (a : t) =\n match a.timing with Account_timing.Untimed -> false | _ -> true\n\n let set_token_id (a : t) (id : Token_id.t) : t = { a with token_id = id }\n\n let balance (a : t) : Balance.t = a.balance\n\n let set_balance (balance : Balance.t) (a : t) : t = { a with balance }\n\n let check_timing ~txn_global_slot account =\n let invalid_timing, timing, _ =\n validate_timing_with_min_balance' ~txn_amount:Amount.zero\n ~txn_global_slot ~account\n in\n ( invalid_timing\n , Account_update.Update.Timing_info.of_account_timing timing )\n\n let receipt_chain_hash (a : t) : Receipt.Chain_hash.t =\n a.receipt_chain_hash\n\n let set_receipt_chain_hash (a : t) hash =\n { a with receipt_chain_hash = hash }\n\n let make_zkapp (a : t) =\n let zkapp =\n match a.zkapp with\n | None ->\n Some Zkapp_account.default\n | Some _ as zkapp ->\n zkapp\n in\n { a with zkapp }\n\n let unmake_zkapp (a : t) : t =\n let zkapp =\n match a.zkapp with\n | None ->\n None\n | Some zkapp ->\n if Zkapp_account.(equal default zkapp) then None else Some zkapp\n in\n { a with zkapp }\n\n let get_zkapp (a : t) = Option.value_exn a.zkapp\n\n let set_zkapp (a : t) ~f : t = { a with zkapp = Option.map a.zkapp ~f }\n\n let proved_state (a : t) = (get_zkapp a).proved_state\n\n let set_proved_state proved_state (a : t) =\n set_zkapp a ~f:(fun zkapp -> { zkapp with proved_state })\n\n let app_state (a : t) = (get_zkapp a).app_state\n\n let set_app_state app_state (a : t) =\n set_zkapp a ~f:(fun zkapp -> { zkapp with app_state })\n\n let register_verification_key (_ : t) = ()\n\n let verification_key (a : t) = (get_zkapp a).verification_key\n\n let set_verification_key verification_key (a : t) =\n set_zkapp a ~f:(fun zkapp -> { zkapp with verification_key })\n\n let verification_key_hash (a : t) =\n match a.zkapp with\n | None ->\n None\n | Some zkapp ->\n Option.map zkapp.verification_key ~f:With_hash.hash\n\n let last_action_slot (a : t) = (get_zkapp a).last_action_slot\n\n let set_last_action_slot last_action_slot (a : t) =\n set_zkapp a ~f:(fun zkapp -> { zkapp with last_action_slot })\n\n let action_state (a : t) = (get_zkapp a).action_state\n\n let set_action_state action_state (a : t) =\n set_zkapp a ~f:(fun zkapp -> { zkapp with action_state })\n\n let zkapp_uri (a : t) =\n Option.value_map a.zkapp ~default:\"\" ~f:(fun zkapp -> zkapp.zkapp_uri)\n\n let set_zkapp_uri zkapp_uri (a : t) : t =\n { a with\n zkapp = Option.map a.zkapp ~f:(fun zkapp -> { zkapp with zkapp_uri })\n }\n\n let token_symbol (a : t) = a.token_symbol\n\n let set_token_symbol token_symbol (a : t) = { a with token_symbol }\n\n let public_key (a : t) = a.public_key\n\n let set_public_key public_key (a : t) = { a with public_key }\n\n let delegate (a : t) = Account.delegate_opt a.delegate\n\n let set_delegate delegate (a : t) =\n let delegate =\n if Signature_lib.Public_key.Compressed.(equal empty) delegate then\n None\n else Some delegate\n in\n { a with delegate }\n\n let nonce (a : t) = a.nonce\n\n let set_nonce nonce (a : t) = { a with nonce }\n\n let voting_for (a : t) = a.voting_for\n\n let set_voting_for voting_for (a : t) = { a with voting_for }\n\n let permissions (a : t) = a.permissions\n\n let set_permissions permissions (a : t) = { a with permissions }\n end\n\n module Amount = struct\n open Currency.Amount\n\n type unsigned = t\n\n type t = unsigned\n\n let if_ = value_if\n\n module Signed = struct\n include Signed\n\n let if_ = value_if\n\n (* Correctness of these functions hinges on the fact that zero is\n only ever expressed as {sgn = Pos; magnitude = zero}. Sadly, this\n is not guaranteed by the module's signature, as it's internal\n structure is exposed. Create function never produces this unwanted\n value, but the type's internal structure is still exposed, so it's\n possible theoretically to obtain it.\n\n For the moment, however, there is some consolation in the fact that\n addition never produces negative zero, even if it was one of its\n arguments. For that reason the risk of this function misbehaving is\n minimal and can probably be safely ignored. *)\n let is_non_neg (t : t) = Sgn.equal t.sgn Pos\n\n let is_neg (t : t) = Sgn.equal t.sgn Neg\n end\n\n let zero = zero\n\n let equal = equal\n\n let add_flagged = add_flagged\n\n let add_signed_flagged (x1 : t) (x2 : Signed.t) : t * [ `Overflow of bool ]\n =\n let y, `Overflow b = Signed.(add_flagged (of_unsigned x1) x2) in\n match y.sgn with\n | Pos ->\n (y.magnitude, `Overflow b)\n | Neg ->\n (* We want to capture the accurate value so that this will match\n with the values in the snarked logic.\n *)\n let magnitude =\n Amount.to_uint64 y.magnitude\n |> Unsigned.UInt64.(mul (sub zero one))\n |> Amount.of_uint64\n in\n (magnitude, `Overflow true)\n\n let of_constant_fee = of_fee\n end\n\n module Token_id = struct\n include Token_id\n\n let if_ = value_if\n end\n\n module Protocol_state_precondition = struct\n include Zkapp_precondition.Protocol_state\n end\n\n module Valid_while_precondition = struct\n include Zkapp_precondition.Valid_while\n end\n\n module Account_update = struct\n include Account_update\n\n module Account_precondition = struct\n include Account_update.Account_precondition\n\n let nonce (t : Account_update.t) = nonce t.body.preconditions.account\n end\n\n type 'a or_ignore = 'a Zkapp_basic.Or_ignore.t\n\n type call_forest = Zkapp_call_forest.t\n\n type transaction_commitment = Transaction_commitment.t\n\n let may_use_parents_own_token (p : t) =\n May_use_token.parents_own_token p.body.may_use_token\n\n let may_use_token_inherited_from_parent (p : t) =\n May_use_token.inherit_from_parent p.body.may_use_token\n\n let check_authorization ~will_succeed:_ ~commitment:_ ~calls:_\n (account_update : t) =\n (* The transaction's validity should already have been checked before\n this point.\n *)\n match account_update.authorization with\n | Signature _ ->\n (`Proof_verifies false, `Signature_verifies true)\n | Proof _ ->\n (`Proof_verifies true, `Signature_verifies false)\n | None_given ->\n (`Proof_verifies false, `Signature_verifies false)\n\n let is_proved (account_update : t) =\n match account_update.body.authorization_kind with\n | Proof _ ->\n true\n | Signature | None_given ->\n false\n\n let is_signed (account_update : t) =\n match account_update.body.authorization_kind with\n | Signature ->\n true\n | Proof _ | None_given ->\n false\n\n let verification_key_hash (p : t) =\n match p.body.authorization_kind with\n | Proof vk_hash ->\n Some vk_hash\n | _ ->\n None\n\n module Update = struct\n open Zkapp_basic\n\n type 'a set_or_keep = 'a Zkapp_basic.Set_or_keep.t\n\n let timing (account_update : t) : Account.timing set_or_keep =\n Set_or_keep.map ~f:Option.some account_update.body.update.timing\n\n let app_state (account_update : t) =\n account_update.body.update.app_state\n\n let verification_key (account_update : t) =\n Zkapp_basic.Set_or_keep.map ~f:Option.some\n account_update.body.update.verification_key\n\n let actions (account_update : t) = account_update.body.actions\n\n let zkapp_uri (account_update : t) =\n account_update.body.update.zkapp_uri\n\n let token_symbol (account_update : t) =\n account_update.body.update.token_symbol\n\n let delegate (account_update : t) = account_update.body.update.delegate\n\n let voting_for (account_update : t) =\n account_update.body.update.voting_for\n\n let permissions (account_update : t) =\n account_update.body.update.permissions\n end\n end\n\n module Set_or_keep = struct\n include Zkapp_basic.Set_or_keep\n\n let set_or_keep ~if_:_ t x = set_or_keep t x\n end\n\n module Opt = struct\n type 'a t = 'a option\n\n let is_some = Option.is_some\n\n let map = Option.map\n\n let or_default ~if_ x ~default =\n if_ (is_some x) ~then_:(Option.value ~default x) ~else_:default\n\n let or_exn x = Option.value_exn x\n end\n\n module Stack (Elt : sig\n type t\n end) =\n struct\n type t = Elt.t list\n\n let if_ = value_if\n\n let empty () = []\n\n let is_empty = List.is_empty\n\n let pop_exn : t -> Elt.t * t = function\n | [] ->\n failwith \"pop_exn\"\n | x :: xs ->\n (x, xs)\n\n let pop : t -> (Elt.t * t) option = function\n | x :: xs ->\n Some (x, xs)\n | _ ->\n None\n\n let push x ~onto : t = x :: onto\n end\n\n module Call_forest = Zkapp_call_forest\n\n module Stack_frame = struct\n include Stack_frame\n\n type t = value\n\n let if_ = Zkapp_command.value_if\n\n let make = Stack_frame.make\n end\n\n module Call_stack = Stack (Stack_frame)\n\n module Local_state = struct\n type t =\n ( Stack_frame.t\n , Call_stack.t\n , Amount.Signed.t\n , Ledger.t\n , Bool.t\n , Transaction_commitment.t\n , Index.t\n , Bool.failure_status_tbl )\n Zkapp_command_logic.Local_state.t\n\n let add_check (t : t) failure b =\n let failure_status_tbl =\n match t.failure_status_tbl with\n | hd :: tl when not b ->\n (failure :: hd) :: tl\n | old_failure_status_tbl ->\n old_failure_status_tbl\n in\n { t with failure_status_tbl; success = t.success && b }\n\n let update_failure_status_tbl (t : t) failure_status b =\n match failure_status with\n | None ->\n { t with success = t.success && b }\n | Some failure ->\n add_check t failure b\n\n let add_new_failure_status_bucket (t : t) =\n { t with failure_status_tbl = [] :: t.failure_status_tbl }\n end\n\n module Nonce_precondition = struct\n let is_constant =\n Zkapp_precondition.Numeric.is_constant\n Zkapp_precondition.Numeric.Tc.nonce\n end\n end\n\n module Env = struct\n open Inputs\n\n type t =\n < account_update : Account_update.t\n ; zkapp_command : Zkapp_command.t\n ; account : Account.t\n ; ledger : Ledger.t\n ; amount : Amount.t\n ; signed_amount : Amount.Signed.t\n ; bool : Bool.t\n ; token_id : Token_id.t\n ; global_state : Global_state.t\n ; inclusion_proof : [ `Existing of location | `New ]\n ; local_state :\n ( Stack_frame.t\n , Call_stack.t\n , Amount.Signed.t\n , L.t\n , bool\n , Transaction_commitment.t\n , Index.t\n , Transaction_status.Failure.Collection.t )\n Zkapp_command_logic.Local_state.t\n ; protocol_state_precondition : Zkapp_precondition.Protocol_state.t\n ; valid_while_precondition : Zkapp_precondition.Valid_while.t\n ; transaction_commitment : Transaction_commitment.t\n ; full_transaction_commitment : Transaction_commitment.t\n ; field : Snark_params.Tick.Field.t\n ; failure : Transaction_status.Failure.t option >\n\n let perform ~constraint_constants:_ (type r)\n (eff : (r, t) Zkapp_command_logic.Eff.t) : r =\n match eff with\n | Check_valid_while_precondition (valid_while, global_state) ->\n Zkapp_precondition.Valid_while.check valid_while\n global_state.block_global_slot\n |> Or_error.is_ok\n | Check_protocol_state_precondition (pred, global_state) -> (\n Zkapp_precondition.Protocol_state.check pred\n global_state.protocol_state\n |> fun or_err -> match or_err with Ok () -> true | Error _ -> false )\n | Check_account_precondition\n (account_update, account, new_account, local_state) -> (\n match account_update.body.preconditions.account with\n | Accept ->\n local_state\n | Nonce n ->\n let nonce_matches = Account.Nonce.equal account.nonce n in\n Inputs.Local_state.add_check local_state\n Account_nonce_precondition_unsatisfied nonce_matches\n | Full precondition_account ->\n let local_state = ref local_state in\n let check failure b =\n local_state :=\n Inputs.Local_state.add_check !local_state failure b\n in\n Zkapp_precondition.Account.check ~new_account ~check\n precondition_account account ;\n !local_state )\n | Init_account { account_update = _; account = a } ->\n a\n end\n\n module M = Zkapp_command_logic.Make (Inputs)\n\n let update_action_state action_state actions ~txn_global_slot\n ~last_action_slot =\n let action_state', last_action_slot' =\n M.update_action_state action_state actions ~txn_global_slot\n ~last_action_slot\n in\n (action_state', last_action_slot')\n\n (* apply zkapp command fee payer's while stubbing out the second pass ledger\n CAUTION: If you use the intermediate local states, you MUST update the\n [will_succeed] field to [false] if the [status] is [Failed].*)\n let apply_zkapp_command_first_pass_aux (type user_acc) ~constraint_constants\n ~global_slot ~(state_view : Zkapp_precondition.Protocol_state.View.t)\n ~(init : user_acc) ~f\n ?((* TODO: can this be ripped out from here? *)\n fee_excess = Amount.Signed.zero)\n ?((* TODO: is the right? is it never used for zkapps? *)\n supply_increase = Amount.Signed.zero) (ledger : L.t)\n (command : Zkapp_command.t) :\n ( Transaction_partially_applied.Zkapp_command_partially_applied.t\n * user_acc )\n Or_error.t =\n let open Or_error.Let_syntax in\n let previous_hash = merkle_root ledger in\n let original_first_pass_account_states =\n let id = Zkapp_command.fee_payer command in\n [ ( id\n , Option.Let_syntax.(\n let%bind loc = L.location_of_account ledger id in\n let%map a = L.get ledger loc in\n (loc, a)) )\n ]\n in\n let perform eff = Env.perform ~constraint_constants eff in\n let initial_state :\n Inputs.Global_state.t * _ Zkapp_command_logic.Local_state.t =\n ( { protocol_state = state_view\n ; first_pass_ledger = ledger\n ; second_pass_ledger =\n (* We stub out the second_pass_ledger initially, and then poke the\n correct value in place after the first pass is finished.\n *)\n L.empty ~depth:0 ()\n ; fee_excess\n ; supply_increase\n ; block_global_slot = global_slot\n }\n , { stack_frame =\n ({ calls = []\n ; caller = Token_id.default\n ; caller_caller = Token_id.default\n } : Inputs.Stack_frame.t)\n ; call_stack = []\n ; transaction_commitment = Inputs.Transaction_commitment.empty\n ; full_transaction_commitment = Inputs.Transaction_commitment.empty\n ; excess = Currency.Amount.(Signed.of_unsigned zero)\n ; supply_increase = Currency.Amount.(Signed.of_unsigned zero)\n ; ledger = L.empty ~depth:0 ()\n ; success = true\n ; account_update_index = Inputs.Index.zero\n ; failure_status_tbl = []\n ; will_succeed = true\n } )\n in\n let user_acc = f init initial_state in\n let account_updates = Zkapp_command.all_account_updates command in\n let%map global_state, local_state =\n Or_error.try_with (fun () ->\n M.start ~constraint_constants\n { account_updates\n ; memo_hash = Signed_command_memo.hash command.memo\n ; will_succeed =\n (* It's always valid to set this value to true, and it will\n have no effect outside of the snark.\n *)\n true\n }\n { perform } initial_state )\n in\n ( { Transaction_partially_applied.Zkapp_command_partially_applied.command\n ; previous_hash\n ; original_first_pass_account_states\n ; constraint_constants\n ; state_view\n ; global_state\n ; local_state\n }\n , user_acc )\n\n let apply_zkapp_command_first_pass ~constraint_constants ~global_slot\n ~(state_view : Zkapp_precondition.Protocol_state.View.t)\n ?((* TODO: can this be ripped out from here? *)\n fee_excess = Amount.Signed.zero)\n ?((* TODO: is the right? is it never used for zkapps? *)\n supply_increase = Amount.Signed.zero) (ledger : L.t)\n (command : Zkapp_command.t) :\n Transaction_partially_applied.Zkapp_command_partially_applied.t Or_error.t\n =\n let open Or_error.Let_syntax in\n let%map partial_stmt, _user_acc =\n apply_zkapp_command_first_pass_aux ~constraint_constants ~global_slot\n ~state_view ~fee_excess ~supply_increase ledger command ~init:None\n ~f:(fun _acc state -> Some state)\n in\n partial_stmt\n\n let apply_zkapp_command_second_pass_aux (type user_acc) ~(init : user_acc) ~f\n ledger\n (c : Transaction_partially_applied.Zkapp_command_partially_applied.t) :\n (Transaction_applied.Zkapp_command_applied.t * user_acc) Or_error.t =\n let open Or_error.Let_syntax in\n let perform eff =\n Env.perform ~constraint_constants:c.constraint_constants eff\n in\n let original_account_states =\n (*get the original states of all the accounts in each pass.\n If an account updated in the first pass is referenced in account\n updates, then retain the value before first pass application*)\n (* IMPORTANT: this account list must be sorted by Account_id in increasing order,\n if this ordering changes the scan state hash will be affected and made\n incompatible. *)\n Account_id.Map.to_alist ~key_order:`Increasing\n @@ List.fold ~init:Account_id.Map.empty\n ~f:(fun account_states (id, acc_opt) ->\n Account_id.Map.update account_states id\n ~f:(Option.value ~default:acc_opt) )\n ( c.original_first_pass_account_states\n @ List.map (Zkapp_command.accounts_referenced c.command)\n ~f:(fun id ->\n ( id\n , Option.Let_syntax.(\n let%bind loc = L.location_of_account ledger id in\n let%map a = L.get ledger loc in\n (loc, a)) ) ) )\n in\n let rec step_all (user_acc : user_acc)\n ( (g_state : Inputs.Global_state.t)\n , (l_state : _ Zkapp_command_logic.Local_state.t) ) :\n (user_acc * Transaction_status.Failure.Collection.t) Or_error.t =\n if List.is_empty l_state.stack_frame.Stack_frame.calls then\n Ok (user_acc, l_state.failure_status_tbl)\n else\n let%bind states =\n Or_error.try_with (fun () ->\n M.step ~constraint_constants:c.constraint_constants { perform }\n (g_state, l_state) )\n in\n step_all (f user_acc states) states\n in\n let account_states_after_fee_payer =\n (*To check if the accounts remain unchanged in the event the transaction\n fails. First pass updates will remain even if the transaction fails to\n apply zkapp account updates*)\n List.map (Zkapp_command.accounts_referenced c.command) ~f:(fun id ->\n ( id\n , Option.Let_syntax.(\n let%bind loc = L.location_of_account ledger id in\n let%map a = L.get ledger loc in\n (loc, a)) ) )\n in\n let accounts () =\n List.map original_account_states\n ~f:(Tuple2.map_snd ~f:(Option.map ~f:snd))\n in\n (* Warning: This is an abstraction leak / hack.\n Here, we update global second pass ledger to be the input ledger, and\n then update the local ledger to be the input ledger *IF AND ONLY IF*\n there are more transaction segments to be processed in this pass.\n\n TODO: Remove this, and uplift the logic into the call in staged ledger.\n *)\n let global_state = { c.global_state with second_pass_ledger = ledger } in\n let local_state =\n if List.is_empty c.local_state.stack_frame.Stack_frame.calls then\n (* Don't mess with the local state; we've already finished the\n transaction after the fee payer.\n *)\n c.local_state\n else\n (* Install the ledger that should already be in the local state, but\n may not be in some situations depending on who the caller is.\n *)\n { c.local_state with\n ledger = Global_state.second_pass_ledger global_state\n }\n in\n let start = (global_state, local_state) in\n match step_all (f init start) start with\n | Error e ->\n Error e\n | Ok (user_acc, reversed_failure_status_tbl) ->\n let failure_status_tbl = List.rev reversed_failure_status_tbl in\n let account_ids_originally_not_in_ledger =\n List.filter_map original_account_states\n ~f:(fun (acct_id, loc_and_acct) ->\n if Option.is_none loc_and_acct then Some acct_id else None )\n in\n let successfully_applied =\n Transaction_status.Failure.Collection.is_empty failure_status_tbl\n in\n (* if the zkapp command fails in at least 1 account update,\n then all the account updates would be cancelled except\n the fee payer one\n *)\n let failure_status_tbl =\n if successfully_applied then failure_status_tbl\n else\n List.mapi failure_status_tbl ~f:(fun idx fs ->\n if idx > 0 && List.is_empty fs then\n [ Transaction_status.Failure.Cancelled ]\n else fs )\n in\n (* accounts not originally in ledger, now present in ledger *)\n let new_accounts =\n List.filter account_ids_originally_not_in_ledger ~f:(fun acct_id ->\n Option.is_some @@ L.location_of_account ledger acct_id )\n in\n let valid_result =\n Ok\n ( { Transaction_applied.Zkapp_command_applied.accounts = accounts ()\n ; command =\n { With_status.data = c.command\n ; status =\n ( if successfully_applied then Applied\n else Failed failure_status_tbl )\n }\n ; new_accounts\n }\n , user_acc )\n in\n if successfully_applied then valid_result\n else\n let other_account_update_accounts_unchanged =\n List.fold_until account_states_after_fee_payer ~init:true\n ~f:(fun acc (_, loc_opt) ->\n match\n let open Option.Let_syntax in\n let%bind loc, a = loc_opt in\n let%bind a' = L.get ledger loc in\n Option.some_if (not (Account.equal a a')) ()\n with\n | None ->\n Continue acc\n | Some _ ->\n Stop false )\n ~finish:Fn.id\n in\n (* Other zkapp_command failed, therefore, updates in those should not get applied *)\n if\n List.is_empty new_accounts\n && other_account_update_accounts_unchanged\n then valid_result\n else\n Or_error.error_string\n \"Zkapp_command application failed but new accounts created or \\\n some of the other account_update updates applied\"\n\n let apply_zkapp_command_second_pass ledger c :\n Transaction_applied.Zkapp_command_applied.t Or_error.t =\n let open Or_error.Let_syntax in\n let%map x, () =\n apply_zkapp_command_second_pass_aux ~init:() ~f:Fn.const ledger c\n in\n x\n\n let apply_zkapp_command_unchecked_aux ~constraint_constants ~global_slot\n ~state_view ~init ~f ?fee_excess ?supply_increase ledger command =\n let open Or_error.Let_syntax in\n apply_zkapp_command_first_pass_aux ~constraint_constants ~global_slot\n ~state_view ?fee_excess ?supply_increase ledger command ~init ~f\n >>= fun (partial_stmt, user_acc) ->\n apply_zkapp_command_second_pass_aux ~init:user_acc ~f ledger partial_stmt\n\n let apply_zkapp_command_unchecked ~constraint_constants ~global_slot\n ~state_view ledger command =\n let open Or_error.Let_syntax in\n apply_zkapp_command_first_pass ~constraint_constants ~global_slot\n ~state_view ledger command\n >>= apply_zkapp_command_second_pass_aux ledger ~init:None\n ~f:(fun _acc (global_state, local_state) ->\n Some (local_state, global_state.fee_excess) )\n |> Result.map ~f:(fun (account_update_applied, state_res) ->\n (account_update_applied, Option.value_exn state_res) )\n\n let update_timing_when_no_deduction ~txn_global_slot account =\n validate_timing ~txn_amount:Amount.zero ~txn_global_slot ~account\n\n let has_permission_to_receive ~ledger receiver_account_id :\n Account.t\n * Ledger_intf.account_state\n * [> `Has_permission_to_receive of bool ] =\n let init_account = Account.initialize receiver_account_id in\n match location_of_account ledger receiver_account_id with\n | None ->\n (* new account, check that default permissions allow receiving *)\n ( init_account\n , `Added\n , `Has_permission_to_receive\n (Account.has_permission_to_receive init_account) )\n | Some loc -> (\n match get ledger loc with\n | None ->\n failwith \"Ledger location with no account\"\n | Some receiver_account ->\n ( receiver_account\n , `Existed\n , `Has_permission_to_receive\n (Account.has_permission_to_receive receiver_account) ) )\n\n let no_failure = []\n\n let update_failed =\n [ Transaction_status.Failure.Update_not_permitted_balance ]\n\n let empty = Transaction_status.Failure.Collection.empty\n\n let single_failure =\n Transaction_status.Failure.Collection.of_single_failure\n Update_not_permitted_balance\n\n let append_entry f (s : Transaction_status.Failure.Collection.t) :\n Transaction_status.Failure.Collection.t =\n match s with [] -> [ f ] | h :: t -> h :: f :: t\n\n (*Structure of the failure status:\n I. Only one fee transfer in the transaction (`One) and it fails:\n [[failure]]\n II. Two fee transfers in the transaction (`Two)-\n Both fee transfers fail:\n [[failure-of-first-fee-transfer]; [failure-of-second-fee-transfer]]\n First succeeds and second one fails:\n [[];[failure-of-second-fee-transfer]]\n First fails and second succeeds:\n [[failure-of-first-fee-transfer];[]]\n *)\n let process_fee_transfer t (transfer : Fee_transfer.t) ~modify_balance\n ~modify_timing =\n let open Or_error.Let_syntax in\n (* TODO(#4555): Allow token_id to vary from default. *)\n let%bind () =\n if\n List.for_all\n ~f:Token_id.(equal default)\n (One_or_two.to_list (Fee_transfer.fee_tokens transfer))\n then return ()\n else Or_error.errorf \"Cannot pay fees in non-default tokens.\"\n in\n match Fee_transfer.to_singles transfer with\n | `One ft ->\n let account_id = Fee_transfer.Single.receiver ft in\n let a, action, `Has_permission_to_receive can_receive =\n has_permission_to_receive ~ledger:t account_id\n in\n let%bind timing = modify_timing a in\n let%bind balance = modify_balance action account_id a.balance ft.fee in\n if can_receive then (\n let%map _action, a, loc = get_or_create t account_id in\n let new_accounts = get_new_accounts action account_id in\n set t loc { a with balance; timing } ;\n (new_accounts, empty, Currency.Amount.zero) )\n else Ok ([], single_failure, Currency.Amount.of_fee ft.fee)\n | `Two (ft1, ft2) ->\n let account_id1 = Fee_transfer.Single.receiver ft1 in\n let a1, action1, `Has_permission_to_receive can_receive1 =\n has_permission_to_receive ~ledger:t account_id1\n in\n let account_id2 = Fee_transfer.Single.receiver ft2 in\n if Account_id.equal account_id1 account_id2 then\n let%bind fee = error_opt \"overflow\" (Fee.add ft1.fee ft2.fee) in\n let%bind timing = modify_timing a1 in\n let%bind balance =\n modify_balance action1 account_id1 a1.balance fee\n in\n if can_receive1 then (\n let%map _action1, a1, l1 = get_or_create t account_id1 in\n let new_accounts1 = get_new_accounts action1 account_id1 in\n set t l1 { a1 with balance; timing } ;\n (new_accounts1, empty, Currency.Amount.zero) )\n else\n (*failure for each fee transfer single*)\n Ok\n ( []\n , append_entry update_failed single_failure\n , Currency.Amount.of_fee fee )\n else\n let a2, action2, `Has_permission_to_receive can_receive2 =\n has_permission_to_receive ~ledger:t account_id2\n in\n let%bind balance1 =\n modify_balance action1 account_id1 a1.balance ft1.fee\n in\n (*Note: Not updating the timing field of a1 to avoid additional check in transactions snark (check_timing for \"receiver\"). This is OK because timing rules will not be violated when balance increases and will be checked whenever an amount is deducted from the account. (#5973)*)\n let%bind timing2 = modify_timing a2 in\n let%bind balance2 =\n modify_balance action2 account_id2 a2.balance ft2.fee\n in\n let%bind new_accounts1, failures, burned_tokens1 =\n if can_receive1 then (\n let%map _action1, a1, l1 = get_or_create t account_id1 in\n let new_accounts1 = get_new_accounts action1 account_id1 in\n set t l1 { a1 with balance = balance1 } ;\n ( new_accounts1\n , append_entry no_failure empty\n , Currency.Amount.zero ) )\n else Ok ([], single_failure, Currency.Amount.of_fee ft1.fee)\n in\n let%bind new_accounts2, failures', burned_tokens2 =\n if can_receive2 then (\n let%map _action2, a2, l2 = get_or_create t account_id2 in\n let new_accounts2 = get_new_accounts action2 account_id2 in\n set t l2 { a2 with balance = balance2; timing = timing2 } ;\n ( new_accounts2\n , append_entry no_failure failures\n , Currency.Amount.zero ) )\n else\n Ok\n ( []\n , append_entry update_failed failures\n , Currency.Amount.of_fee ft2.fee )\n in\n let%map burned_tokens =\n error_opt \"burned tokens overflow\"\n (Currency.Amount.add burned_tokens1 burned_tokens2)\n in\n (new_accounts1 @ new_accounts2, failures', burned_tokens)\n\n let apply_fee_transfer ~constraint_constants ~txn_global_slot t transfer =\n let open Or_error.Let_syntax in\n let%map new_accounts, failures, burned_tokens =\n process_fee_transfer t transfer\n ~modify_balance:(fun action _ b f ->\n let%bind amount =\n let amount = Amount.of_fee f in\n sub_account_creation_fee ~constraint_constants action amount\n in\n add_amount b amount )\n ~modify_timing:(fun acc ->\n update_timing_when_no_deduction ~txn_global_slot acc )\n in\n let ft_with_status =\n if Transaction_status.Failure.Collection.is_empty failures then\n { With_status.data = transfer; status = Applied }\n else { data = transfer; status = Failed failures }\n in\n Transaction_applied.Fee_transfer_applied.\n { fee_transfer = ft_with_status; new_accounts; burned_tokens }\n\n (*Structure of the failure status:\n I. No fee transfer and coinbase transfer fails: [[failure]]\n II. With fee transfer-\n Both fee transfer and coinbase fails:\n [[failure-of-fee-transfer]; [failure-of-coinbase]]\n Fee transfer succeeds and coinbase fails:\n [[];[failure-of-coinbase]]\n Fee transfer fails and coinbase succeeds:\n [[failure-of-fee-transfer];[]]\n *)\n let apply_coinbase ~constraint_constants ~txn_global_slot t\n (* TODO: Better system needed for making atomic changes. Could use a monad. *)\n ({ receiver; fee_transfer; amount = coinbase_amount } as cb : Coinbase.t)\n =\n let open Or_error.Let_syntax in\n let%bind ( receiver_reward\n , new_accounts1\n , transferee_update\n , transferee_timing_prev\n , failures1\n , burned_tokens1 ) =\n match fee_transfer with\n | None ->\n return (coinbase_amount, [], None, None, empty, Currency.Amount.zero)\n | Some ({ receiver_pk = transferee; fee } as ft) ->\n assert (not @@ Public_key.Compressed.equal transferee receiver) ;\n let transferee_id = Coinbase.Fee_transfer.receiver ft in\n let fee = Amount.of_fee fee in\n let%bind receiver_reward =\n error_opt \"Coinbase fee transfer too large\"\n (Amount.sub coinbase_amount fee)\n in\n let transferee_account, action, `Has_permission_to_receive can_receive\n =\n has_permission_to_receive ~ledger:t transferee_id\n in\n let new_accounts = get_new_accounts action transferee_id in\n let%bind timing =\n update_timing_when_no_deduction ~txn_global_slot transferee_account\n in\n let%bind balance =\n let%bind amount =\n sub_account_creation_fee ~constraint_constants action fee\n in\n add_amount transferee_account.balance amount\n in\n if can_receive then\n let%map _action, transferee_account, transferee_location =\n get_or_create t transferee_id\n in\n ( receiver_reward\n , new_accounts\n , Some\n ( transferee_location\n , { transferee_account with balance; timing } )\n , Some transferee_account.timing\n , append_entry no_failure empty\n , Currency.Amount.zero )\n else return (receiver_reward, [], None, None, single_failure, fee)\n in\n let receiver_id = Account_id.create receiver Token_id.default in\n let receiver_account, action2, `Has_permission_to_receive can_receive =\n has_permission_to_receive ~ledger:t receiver_id\n in\n let new_accounts2 = get_new_accounts action2 receiver_id in\n (* Note: Updating coinbase receiver timing only if there is no fee transfer.\n This is so as to not add any extra constraints in transaction snark for checking\n \"receiver\" timings. This is OK because timing rules will not be violated when\n balance increases and will be checked whenever an amount is deducted from the\n account (#5973)\n *)\n let%bind coinbase_receiver_timing =\n match transferee_timing_prev with\n | None ->\n let%map new_receiver_timing =\n update_timing_when_no_deduction ~txn_global_slot receiver_account\n in\n new_receiver_timing\n | Some _timing ->\n Ok receiver_account.timing\n in\n let%bind receiver_balance =\n let%bind amount =\n sub_account_creation_fee ~constraint_constants action2 receiver_reward\n in\n add_amount receiver_account.balance amount\n in\n let%bind failures, burned_tokens2 =\n if can_receive then (\n let%map _action2, receiver_account, receiver_location =\n get_or_create t receiver_id\n in\n set t receiver_location\n { receiver_account with\n balance = receiver_balance\n ; timing = coinbase_receiver_timing\n } ;\n (append_entry no_failure failures1, Currency.Amount.zero) )\n else return (append_entry update_failed failures1, receiver_reward)\n in\n Option.iter transferee_update ~f:(fun (l, a) -> set t l a) ;\n let%map burned_tokens =\n error_opt \"burned tokens overflow\"\n (Amount.add burned_tokens1 burned_tokens2)\n in\n let coinbase_with_status =\n if Transaction_status.Failure.Collection.is_empty failures then\n { With_status.data = cb; status = Applied }\n else { With_status.data = cb; status = Failed failures }\n in\n Transaction_applied.Coinbase_applied.\n { coinbase = coinbase_with_status\n ; new_accounts = new_accounts1 @ new_accounts2\n ; burned_tokens\n }\n\n let apply_transaction_first_pass ~constraint_constants ~global_slot\n ~(txn_state_view : Zkapp_precondition.Protocol_state.View.t) ledger\n (t : Transaction.t) : Transaction_partially_applied.t Or_error.t =\n let open Or_error.Let_syntax in\n let previous_hash = merkle_root ledger in\n let txn_global_slot = global_slot in\n match t with\n | Command (Signed_command txn) ->\n let%map applied =\n apply_user_command_unchecked ~constraint_constants ~txn_global_slot\n ledger txn\n in\n Transaction_partially_applied.Signed_command { previous_hash; applied }\n | Command (Zkapp_command txn) ->\n let%map partially_applied =\n apply_zkapp_command_first_pass ~global_slot ~state_view:txn_state_view\n ~constraint_constants ledger txn\n in\n Transaction_partially_applied.Zkapp_command partially_applied\n | Fee_transfer t ->\n let%map applied =\n apply_fee_transfer ~constraint_constants ~txn_global_slot ledger t\n in\n Transaction_partially_applied.Fee_transfer { previous_hash; applied }\n | Coinbase t ->\n let%map applied =\n apply_coinbase ~constraint_constants ~txn_global_slot ledger t\n in\n Transaction_partially_applied.Coinbase { previous_hash; applied }\n\n let apply_transaction_second_pass ledger (t : Transaction_partially_applied.t)\n : Transaction_applied.t Or_error.t =\n let open Or_error.Let_syntax in\n let open Transaction_applied in\n match t with\n | Signed_command { previous_hash; applied } ->\n return\n { previous_hash; varying = Varying.Command (Signed_command applied) }\n | Zkapp_command partially_applied ->\n (* TODO: either here or in second phase of apply, need to update the prior global state statement for the fee payer segment to add the second phase ledger at the end *)\n let%map applied =\n apply_zkapp_command_second_pass ledger partially_applied\n in\n { previous_hash = partially_applied.previous_hash\n ; varying = Varying.Command (Zkapp_command applied)\n }\n | Fee_transfer { previous_hash; applied } ->\n return { previous_hash; varying = Varying.Fee_transfer applied }\n | Coinbase { previous_hash; applied } ->\n return { previous_hash; varying = Varying.Coinbase applied }\n\n let apply_transactions ~constraint_constants ~global_slot ~txn_state_view\n ledger txns =\n let open Or_error in\n Mina_stdlib.Result.List.map txns\n ~f:\n (apply_transaction_first_pass ~constraint_constants ~global_slot\n ~txn_state_view ledger )\n >>= Mina_stdlib.Result.List.map ~f:(apply_transaction_second_pass ledger)\n\n module For_tests = struct\n let validate_timing_with_min_balance = validate_timing_with_min_balance\n\n let validate_timing = validate_timing\n end\nend\n\nmodule For_tests = struct\n open Mina_numbers\n open Currency\n\n module Account_without_receipt_chain_hash = struct\n type t =\n ( Public_key.Compressed.t\n , Token_id.t\n , Account.Token_symbol.t\n , Balance.t\n , Account_nonce.t\n , unit\n , Public_key.Compressed.t option\n , State_hash.t\n , Account_timing.t\n , Permissions.t\n , Zkapp_account.t option )\n Account.Poly.t\n [@@deriving sexp, compare]\n end\n\n let min_init_balance = Int64.of_string \"8000000000\"\n\n let max_init_balance = Int64.of_string \"8000000000000\"\n\n let num_accounts = 10\n\n let num_transactions = 10\n\n let depth = Int.ceil_log2 (num_accounts + num_transactions)\n\n module Init_ledger = struct\n type t = (Keypair.t * int64) array [@@deriving sexp]\n\n let init ?(zkapp = true) (type l) (module L : Ledger_intf.S with type t = l)\n (init_ledger : t) (l : L.t) =\n Array.iter init_ledger ~f:(fun (kp, amount) ->\n let _tag, account, loc =\n L.get_or_create l\n (Account_id.create\n (Public_key.compress kp.public_key)\n Token_id.default )\n |> Or_error.ok_exn\n in\n let permissions : Permissions.t =\n { edit_state = Either\n ; send = Either\n ; receive = None\n ; set_delegate = Either\n ; set_permissions = Either\n ; set_verification_key = Either\n ; set_zkapp_uri = Either\n ; edit_action_state = Either\n ; set_token_symbol = Either\n ; increment_nonce = Either\n ; set_voting_for = Either\n ; access = None\n ; set_timing = Either\n }\n in\n let zkapp =\n if zkapp then\n Some\n { Zkapp_account.default with\n verification_key =\n Some\n { With_hash.hash = Zkapp_basic.F.zero\n ; data = Side_loaded_verification_key.dummy\n }\n }\n else None\n in\n L.set l loc\n { account with\n balance =\n Currency.Balance.of_uint64 (Unsigned.UInt64.of_int64 amount)\n ; permissions\n ; zkapp\n } )\n\n let gen () : t Quickcheck.Generator.t =\n let tbl = Public_key.Compressed.Hash_set.create () in\n let open Quickcheck.Generator in\n let open Let_syntax in\n let rec go acc n =\n if n = 0 then return (Array.of_list acc)\n else\n let%bind kp =\n filter Keypair.gen ~f:(fun kp ->\n not (Hash_set.mem tbl (Public_key.compress kp.public_key)) )\n and amount = Int64.gen_incl min_init_balance max_init_balance in\n Hash_set.add tbl (Public_key.compress kp.public_key) ;\n go ((kp, amount) :: acc) (n - 1)\n in\n go [] num_accounts\n end\n\n module Transaction_spec = struct\n type t =\n { fee : Currency.Fee.t\n ; sender : Keypair.t * Account_nonce.t\n ; receiver : Public_key.Compressed.t\n ; amount : Currency.Amount.t\n }\n [@@deriving sexp]\n\n let gen ~(init_ledger : Init_ledger.t) ~nonces =\n let pk ((kp : Keypair.t), _) = Public_key.compress kp.public_key in\n let open Quickcheck.Let_syntax in\n let%bind receiver_is_new = Bool.quickcheck_generator in\n let gen_index () = Int.gen_incl 0 (Array.length init_ledger - 1) in\n let%bind receiver_index =\n if receiver_is_new then return None else gen_index () >>| Option.return\n in\n let%bind receiver =\n match receiver_index with\n | None ->\n Public_key.Compressed.gen\n | Some i ->\n return (pk init_ledger.(i))\n in\n let%bind sender =\n let%map i =\n match receiver_index with\n | None ->\n gen_index ()\n | Some j ->\n Quickcheck.Generator.filter (gen_index ()) ~f:(( <> ) j)\n in\n fst init_ledger.(i)\n in\n let gen_amount () =\n Currency.Amount.(\n gen_incl\n (of_nanomina_int_exn 1_000_000)\n (of_nanomina_int_exn 100_000_000))\n in\n let gen_fee () =\n Currency.Fee.(\n gen_incl\n (of_nanomina_int_exn 1_000_000)\n (of_nanomina_int_exn 100_000_000))\n in\n let nonce : Account_nonce.t = Map.find_exn nonces sender in\n let%bind fee = gen_fee () in\n let%bind amount = gen_amount () in\n let nonces =\n Map.set nonces ~key:sender ~data:(Account_nonce.succ nonce)\n in\n let spec = { fee; amount; receiver; sender = (sender, nonce) } in\n return (spec, nonces)\n end\n\n module Test_spec = struct\n type t = { init_ledger : Init_ledger.t; specs : Transaction_spec.t list }\n [@@deriving sexp]\n\n let mk_gen ?(num_transactions = num_transactions) () =\n let open Quickcheck.Let_syntax in\n let%bind init_ledger = Init_ledger.gen () in\n let%bind specs =\n let rec go acc n nonces =\n if n = 0 then return (List.rev acc)\n else\n let%bind spec, nonces = Transaction_spec.gen ~init_ledger ~nonces in\n go (spec :: acc) (n - 1) nonces\n in\n go [] num_transactions\n (Keypair.Map.of_alist_exn\n (List.map (Array.to_list init_ledger) ~f:(fun (pk, _) ->\n (pk, Account_nonce.zero) ) ) )\n in\n return { init_ledger; specs }\n\n let gen = mk_gen ~num_transactions ()\n end\n\n let command_send\n { Transaction_spec.fee; sender = sender, sender_nonce; receiver; amount }\n : Signed_command.t =\n let sender_pk = Public_key.compress sender.public_key in\n Signed_command.sign sender\n { common =\n { fee\n ; fee_payer_pk = sender_pk\n ; nonce = sender_nonce\n ; valid_until = Global_slot_since_genesis.max_value\n ; memo = Signed_command_memo.dummy\n }\n ; body = Payment { receiver_pk = receiver; amount }\n }\n |> Signed_command.forget_check\n\n let account_update_send ?(use_full_commitment = true)\n ?(double_sender_nonce = true)\n { Transaction_spec.fee; sender = sender, sender_nonce; receiver; amount }\n : Zkapp_command.t =\n let sender_pk = Public_key.compress sender.public_key in\n let actual_nonce =\n (* Here, we double the spec'd nonce, because we bump the nonce a second\n time for the 'sender' part of the payment.\n *)\n (* TODO: We should make bumping the nonce for signed zkapp_command optional,\n flagged by a field in the account_update (but always true for the fee payer).\n\n This would also allow us to prevent replays of snapp proofs, by\n allowing them to bump their nonce.\n *)\n if double_sender_nonce then\n sender_nonce |> Account.Nonce.to_uint32\n |> Unsigned.UInt32.(mul (of_int 2))\n |> Account.Nonce.to_uint32\n else sender_nonce\n in\n let zkapp_command : Zkapp_command.Simple.t =\n { fee_payer =\n { Account_update.Fee_payer.body =\n { public_key = sender_pk\n ; fee\n ; valid_until = None\n ; nonce = actual_nonce\n }\n (* Real signature added in below *)\n ; authorization = Signature.dummy\n }\n ; account_updates =\n [ { body =\n { public_key = sender_pk\n ; update = Account_update.Update.noop\n ; token_id = Token_id.default\n ; balance_change = Amount.Signed.(negate (of_unsigned amount))\n ; increment_nonce = double_sender_nonce\n ; events = []\n ; actions = []\n ; call_data = Snark_params.Tick.Field.zero\n ; call_depth = 0\n ; preconditions =\n { Account_update.Preconditions.network =\n Zkapp_precondition.Protocol_state.accept\n ; account = Accept\n ; valid_while = Ignore\n }\n ; may_use_token = No\n ; use_full_commitment\n ; implicit_account_creation_fee = true\n ; authorization_kind =\n ( if use_full_commitment then Signature\n else Proof Zkapp_basic.F.zero )\n }\n ; authorization =\n ( if use_full_commitment then Signature Signature.dummy\n else Proof Mina_base.Proof.transaction_dummy )\n }\n ; { body =\n { public_key = receiver\n ; update = Account_update.Update.noop\n ; token_id = Token_id.default\n ; balance_change = Amount.Signed.of_unsigned amount\n ; increment_nonce = false\n ; events = []\n ; actions = []\n ; call_data = Snark_params.Tick.Field.zero\n ; call_depth = 0\n ; preconditions =\n { Account_update.Preconditions.network =\n Zkapp_precondition.Protocol_state.accept\n ; account = Accept\n ; valid_while = Ignore\n }\n ; may_use_token = No\n ; use_full_commitment = false\n ; implicit_account_creation_fee = true\n ; authorization_kind = None_given\n }\n ; authorization = None_given\n }\n ]\n ; memo = Signed_command_memo.empty\n }\n in\n let zkapp_command = Zkapp_command.of_simple zkapp_command in\n let commitment = Zkapp_command.commitment zkapp_command in\n let full_commitment =\n Zkapp_command.Transaction_commitment.create_complete commitment\n ~memo_hash:(Signed_command_memo.hash zkapp_command.memo)\n ~fee_payer_hash:\n (Zkapp_command.Digest.Account_update.create\n (Account_update.of_fee_payer zkapp_command.fee_payer) )\n in\n let account_updates_signature =\n let c = if use_full_commitment then full_commitment else commitment in\n Schnorr.Chunked.sign sender.private_key\n (Random_oracle.Input.Chunked.field c)\n in\n let account_updates =\n Zkapp_command.Call_forest.map zkapp_command.account_updates\n ~f:(fun (account_update : Account_update.t) ->\n match account_update.body.authorization_kind with\n | Signature ->\n { account_update with\n authorization = Control.Signature account_updates_signature\n }\n | _ ->\n account_update )\n in\n let signature =\n Schnorr.Chunked.sign sender.private_key\n (Random_oracle.Input.Chunked.field full_commitment)\n in\n { zkapp_command with\n fee_payer = { zkapp_command.fee_payer with authorization = signature }\n ; account_updates\n }\n\n let test_eq (type l) (module L : Ledger_intf.S with type t = l) accounts\n (l1 : L.t) (l2 : L.t) =\n List.map accounts ~f:(fun a ->\n Or_error.try_with (fun () ->\n let mismatch () =\n failwithf\n !\"One ledger had the account %{sexp:Account_id.t} but the \\\n other did not\"\n a ()\n in\n let hide_rc (a : _ Account.Poly.t) =\n { a with receipt_chain_hash = () }\n in\n match L.(location_of_account l1 a, location_of_account l2 a) with\n | None, None ->\n ()\n | Some _, None | None, Some _ ->\n mismatch ()\n | Some x1, Some x2 -> (\n match L.(get l1 x1, get l2 x2) with\n | None, None ->\n ()\n | Some _, None | None, Some _ ->\n mismatch ()\n | Some a1, Some a2 ->\n [%test_eq: Account_without_receipt_chain_hash.t]\n (hide_rc a1) (hide_rc a2) ) ) )\n |> Or_error.combine_errors_unit\n\n let txn_global_slot = Global_slot_since_genesis.zero\n\n let iter_err ts ~f =\n List.fold_until ts\n ~finish:(fun () -> Ok ())\n ~init:()\n ~f:(fun () t ->\n match f t with Error e -> Stop (Error e) | Ok _ -> Continue () )\n\n let view : Zkapp_precondition.Protocol_state.View.t =\n let h = Frozen_ledger_hash.empty_hash in\n let len = Length.zero in\n let a = Currency.Amount.zero in\n let epoch_data =\n { Epoch_data.Poly.ledger =\n { Epoch_ledger.Poly.hash = h; total_currency = a }\n ; seed = h\n ; start_checkpoint = h\n ; lock_checkpoint = h\n ; epoch_length = len\n }\n in\n { snarked_ledger_hash = h\n ; blockchain_length = len\n ; min_window_density = len\n ; total_currency = a\n ; global_slot_since_genesis = txn_global_slot\n ; staking_epoch_data = epoch_data\n ; next_epoch_data = epoch_data\n }\n\n (* Quickcheck generator for Zkapp_command.t, derived from Test_spec generator *)\n let gen_zkapp_command_from_test_spec =\n let open Quickcheck.Let_syntax in\n let%bind use_full_commitment = Bool.quickcheck_generator in\n match%map Test_spec.mk_gen ~num_transactions:1 () with\n | { specs = [ spec ]; _ } ->\n account_update_send ~use_full_commitment spec\n | { specs; _ } ->\n failwithf \"gen_zkapp_command_from_test_spec: expected one spec, got %d\"\n (List.length specs) ()\nend\n","open Core_kernel\nmodule Js = Js_of_ocaml.Js\nmodule Impl = Pickles.Impls.Step\nmodule Other_impl = Pickles.Impls.Wrap\nmodule Field = Impl.Field\nmodule Account_update = Mina_base.Account_update\nmodule Zkapp_command = Mina_base.Zkapp_command\n\n(* Test - functions that have a ts implementation, exposed for ts-ml consistency tests *)\n\nmodule Encoding = struct\n (* arbitrary base58_check encoding *)\n let binary_string_to_base58_check bin_string (version_byte : int) :\n Js.js_string Js.t =\n let module T = struct\n let version_byte = Char.of_int_exn version_byte\n\n let description = \"any\"\n end in\n let module B58 = Base58_check.Make (T) in\n bin_string |> B58.encode |> Js.string\n\n let binary_string_of_base58_check (base58 : Js.js_string Js.t)\n (version_byte : int) =\n let module T = struct\n let version_byte = Char.of_int_exn version_byte\n\n let description = \"any\"\n end in\n let module B58 = Base58_check.Make (T) in\n base58 |> Js.to_string |> B58.decode_exn\n\n (* base58 encoding of some transaction types *)\n let public_key_to_base58 (pk : Signature_lib.Public_key.Compressed.t) :\n Js.js_string Js.t =\n pk |> Signature_lib.Public_key.Compressed.to_base58_check |> Js.string\n\n let public_key_of_base58 (pk_base58 : Js.js_string Js.t) :\n Signature_lib.Public_key.Compressed.t =\n pk_base58 |> Js.to_string\n |> Signature_lib.Public_key.Compressed.of_base58_check_exn\n\n let private_key_to_base58 (sk : Other_impl.field) : Js.js_string Js.t =\n sk |> Signature_lib.Private_key.to_base58_check |> Js.string\n\n let private_key_of_base58 (sk_base58 : Js.js_string Js.t) : Other_impl.field =\n sk_base58 |> Js.to_string |> Signature_lib.Private_key.of_base58_check_exn\n\n let token_id_to_base58 (field : Impl.field) : Js.js_string Js.t =\n field |> Mina_base.Account_id.Digest.of_field\n |> Mina_base.Account_id.Digest.to_string |> Js.string\n\n let token_id_of_base58 (field : Js.js_string Js.t) : Impl.field =\n Mina_base.Account_id.Digest.to_field_unsafe\n @@ Mina_base.Account_id.Digest.of_string @@ Js.to_string field\n\n let memo_to_base58 (memo : Js.js_string Js.t) : Js.js_string Js.t =\n Js.string @@ Mina_base.Signed_command_memo.to_base58_check\n @@ Mina_base.Signed_command_memo.create_from_string_exn @@ Js.to_string memo\n\n let memo_hash_base58 (memo_base58 : Js.js_string Js.t) : Impl.field =\n memo_base58 |> Js.to_string\n |> Mina_base.Signed_command_memo.of_base58_check_exn\n |> Mina_base.Signed_command_memo.hash\nend\n\nmodule Token_id = struct\n let derive pk token =\n let account_id =\n Mina_base.Account_id.create pk (Mina_base.Token_id.of_field token)\n in\n Mina_base.Account_id.derive_token_id ~owner:account_id\n |> Mina_base.Token_id.to_field_unsafe\n\n let derive_checked pk token =\n let account_id =\n Mina_base.Account_id.Checked.create pk\n (Mina_base.Token_id.Checked.of_field token)\n in\n Mina_base.Account_id.Checked.derive_token_id ~owner:account_id\n |> Mina_base.Account_id.Digest.Checked.to_field_unsafe\nend\n\n(* deriver *)\nlet account_update_of_json, _account_update_to_json =\n let deriver =\n Account_update.Graphql_repr.deriver @@ Fields_derivers_zkapps.Derivers.o ()\n in\n let account_update_of_json (account_update : Js.js_string Js.t) :\n Account_update.t =\n Fields_derivers_zkapps.of_json deriver\n (account_update |> Js.to_string |> Yojson.Safe.from_string)\n |> Account_update.of_graphql_repr\n in\n let account_update_to_json (account_update : Account_update.t) :\n Js.js_string Js.t =\n Fields_derivers_zkapps.to_json deriver\n (Account_update.to_graphql_repr account_update ~call_depth:0)\n |> Yojson.Safe.to_string |> Js.string\n in\n (account_update_of_json, account_update_to_json)\n\nlet body_of_json =\n let body_deriver =\n Mina_base.Account_update.Body.Graphql_repr.deriver\n @@ Fields_derivers_zkapps.o ()\n in\n let body_of_json json =\n json\n |> Fields_derivers_zkapps.of_json body_deriver\n |> Account_update.Body.of_graphql_repr\n in\n body_of_json\n\nmodule Poseidon = struct\n let hash_to_group (xs : Impl.field array) =\n let input = Random_oracle.hash xs in\n Snark_params.Group_map.to_group input\nend\n\nmodule Signature = struct\n let sign_field_element (x : Impl.field) (key : Other_impl.field)\n (is_mainnet : bool Js.t) =\n let network_id =\n Mina_signature_kind.(if Js.to_bool is_mainnet then Mainnet else Testnet)\n in\n Signature_lib.Schnorr.Chunked.sign ~signature_kind:network_id key\n (Random_oracle.Input.Chunked.field x)\n |> Mina_base.Signature.to_base58_check |> Js.string\n\n let dummy_signature () =\n Mina_base.Signature.(dummy |> to_base58_check) |> Js.string\nend\n\nmodule To_fields = struct\n (* helper function to check whether the fields we produce from JS are correct *)\n let fields_of_json\n (typ : ('var, 'value, Field.Constant.t, 'tmp) Impl.Internal_Basic.Typ.typ)\n of_json (json : Js.js_string Js.t) : Impl.field array =\n let json = json |> Js.to_string |> Yojson.Safe.from_string in\n let value = of_json json in\n let (Typ typ) = typ in\n let fields, _ = typ.value_to_fields value in\n fields\n\n let account_update =\n fields_of_json (Mina_base.Account_update.Body.typ ()) body_of_json\nend\n\nmodule Hash_from_json = struct\n let account_update (p : Js.js_string Js.t) =\n p |> account_update_of_json |> Account_update.digest\n\n let transaction_commitments (tx_json : Js.js_string Js.t) =\n let tx =\n Zkapp_command.of_json @@ Yojson.Safe.from_string @@ Js.to_string tx_json\n in\n let commitment = Zkapp_command.commitment tx in\n let fee_payer = Account_update.of_fee_payer tx.fee_payer in\n let fee_payer_hash = Zkapp_command.Digest.Account_update.create fee_payer in\n let full_commitment =\n Zkapp_command.Transaction_commitment.create_complete commitment\n ~memo_hash:(Mina_base.Signed_command_memo.hash tx.memo)\n ~fee_payer_hash\n in\n object%js\n val commitment = commitment\n\n val fullCommitment = full_commitment\n\n val feePayerHash = (fee_payer_hash :> Impl.field)\n end\n\n let zkapp_public_input (tx_json : Js.js_string Js.t)\n (account_update_index : int) =\n let tx =\n Zkapp_command.of_json @@ Yojson.Safe.from_string @@ Js.to_string tx_json\n in\n let account_update = List.nth_exn tx.account_updates account_update_index in\n object%js\n val accountUpdate =\n (account_update.elt.account_update_digest :> Impl.field)\n\n val calls =\n (Zkapp_command.Call_forest.hash account_update.elt.calls :> Impl.field)\n end\nend\n\nmodule Hash_input = struct\n type random_oracle_input = Impl.field Random_oracle_input.Chunked.t\n\n let pack_input (input : random_oracle_input) : Impl.field array =\n Random_oracle.pack_input input\n\n (* hash inputs for various account_update subtypes *)\n let timing_input (json : Js.js_string Js.t) : random_oracle_input =\n let deriver = Account_update.Update.Timing_info.deriver in\n let json = json |> Js.to_string |> Yojson.Safe.from_string in\n let value = Fields_derivers_zkapps.(of_json (deriver @@ o ()) json) in\n let input = Account_update.Update.Timing_info.to_input value in\n input\n\n let permissions_input (json : Js.js_string Js.t) : random_oracle_input =\n let deriver = Mina_base.Permissions.deriver in\n let json = json |> Js.to_string |> Yojson.Safe.from_string in\n let value = Fields_derivers_zkapps.(of_json (deriver @@ o ()) json) in\n let input = Mina_base.Permissions.to_input value in\n input\n\n let update_input (json : Js.js_string Js.t) : random_oracle_input =\n let deriver = Account_update.Update.deriver in\n let json = json |> Js.to_string |> Yojson.Safe.from_string in\n let value = Fields_derivers_zkapps.(of_json (deriver @@ o ()) json) in\n let input = Account_update.Update.to_input value in\n input\n\n let account_precondition_input (json : Js.js_string Js.t) :\n random_oracle_input =\n let deriver = Mina_base.Zkapp_precondition.Account.deriver in\n let json = json |> Js.to_string |> Yojson.Safe.from_string in\n let value = Fields_derivers_zkapps.(of_json (deriver @@ o ()) json) in\n let input = Mina_base.Zkapp_precondition.Account.to_input value in\n input\n\n let network_precondition_input (json : Js.js_string Js.t) :\n random_oracle_input =\n let deriver = Mina_base.Zkapp_precondition.Protocol_state.deriver in\n let json = json |> Js.to_string |> Yojson.Safe.from_string in\n let value = Fields_derivers_zkapps.(of_json (deriver @@ o ()) json) in\n let input = Mina_base.Zkapp_precondition.Protocol_state.to_input value in\n input\n\n let body_input (json : Js.js_string Js.t) : random_oracle_input =\n let json = json |> Js.to_string |> Yojson.Safe.from_string in\n let value = body_of_json json in\n let input = Account_update.Body.to_input value in\n input\nend\n\nmodule Transaction_hash = struct\n module Signed_command = Mina_base.Signed_command\n module Signed_command_payload = Mina_base.Signed_command_payload\n\n let ok_exn result =\n let open Ppx_deriving_yojson_runtime.Result in\n match result with Ok c -> c | Error e -> failwith (\"not ok: \" ^ e)\n\n let keypair () = Signature_lib.Keypair.create ()\n\n let hash_payment (command : Js.js_string Js.t) =\n let command : Signed_command.t =\n command |> Js.to_string |> Yojson.Safe.from_string\n |> Signed_command.of_yojson |> ok_exn\n in\n Mina_transaction.Transaction_hash.(\n command |> hash_signed_command |> to_base58_check |> Js.string)\n\n let hash_payment_v1 (command : Js.js_string Js.t) =\n let command : Signed_command.t_v1 =\n command |> Js.to_string |> Yojson.Safe.from_string\n |> Signed_command.Stable.V1.of_yojson |> ok_exn\n in\n let b58 = Signed_command.to_base58_check_v1 command in\n Mina_transaction.Transaction_hash.(b58 |> digest_string |> to_base58_check)\n |> Js.string\n\n let serialize_common (command : Js.js_string Js.t) =\n let command : Signed_command_payload.Common.t =\n command |> Js.to_string |> Yojson.Safe.from_string\n |> Signed_command_payload.Common.of_yojson |> ok_exn\n in\n Binable.to_bigstring\n (module Signed_command_payload.Common.Stable.Latest)\n command\n\n let serialize_payment (command : Js.js_string Js.t) =\n let command : Signed_command.t =\n command |> Js.to_string |> Yojson.Safe.from_string\n |> Signed_command.of_yojson |> ok_exn\n in\n Binable.to_bigstring (module Signed_command.Stable.Latest) command\n\n let serialize_payment_v1 (command : Js.js_string Js.t) =\n let command : Signed_command.t_v1 =\n command |> Js.to_string |> Yojson.Safe.from_string\n |> Signed_command.Stable.V1.of_yojson |> ok_exn\n in\n Signed_command.to_base58_check_v1 command |> Js.string\n\n let example_payment =\n let kp = keypair () in\n let payload : Signed_command_payload.t =\n { Signed_command_payload.dummy with\n common =\n { Signed_command_payload.dummy.common with\n fee_payer_pk = Signature_lib.Public_key.compress kp.public_key\n }\n }\n in\n let payment = Signed_command.sign kp payload in\n (payment :> Signed_command.t)\n |> Signed_command.to_yojson |> Yojson.Safe.to_string |> Js.string\nend\n\nlet test =\n object%js\n val encoding =\n let open Encoding in\n object%js\n val toBase58 = binary_string_to_base58_check\n\n val ofBase58 = binary_string_of_base58_check\n\n method publicKeyToBase58 = public_key_to_base58\n\n method publicKeyOfBase58 = public_key_of_base58\n\n method privateKeyToBase58 = private_key_to_base58\n\n method privateKeyOfBase58 = private_key_of_base58\n\n method tokenIdToBase58 = token_id_to_base58\n\n method tokenIdOfBase58 = token_id_of_base58\n\n method memoToBase58 = memo_to_base58\n\n method memoHashBase58 = memo_hash_base58\n end\n\n val tokenId =\n object%js\n method derive = Token_id.derive\n\n method deriveChecked = Token_id.derive_checked\n end\n\n val poseidon =\n object%js\n val hashToGroup = Poseidon.hash_to_group\n end\n\n val signature =\n object%js\n method signFieldElement = Signature.sign_field_element\n\n val dummySignature = Signature.dummy_signature\n end\n\n val fieldsFromJson =\n object%js\n method accountUpdate = To_fields.account_update\n end\n\n val hashFromJson =\n object%js\n method accountUpdate = Hash_from_json.account_update\n\n method transactionCommitments = Hash_from_json.transaction_commitments\n\n method zkappPublicInput = Hash_from_json.zkapp_public_input\n end\n\n val hashInputFromJson =\n let open Hash_input in\n object%js\n val packInput = pack_input\n\n val timing = timing_input\n\n val permissions = permissions_input\n\n val accountPrecondition = account_precondition_input\n\n val networkPrecondition = network_precondition_input\n\n val update = update_input\n\n val body = body_input\n end\n\n val transactionHash =\n let open Transaction_hash in\n object%js\n method hashPayment = hash_payment\n\n method hashPaymentV1 = hash_payment_v1\n\n method serializeCommon = serialize_common\n\n method serializePayment = serialize_payment\n\n method serializePaymentV1 = serialize_payment_v1\n\n method examplePayment = example_payment\n end\n end\n","open Core_kernel\nmodule Js = Js_of_ocaml.Js\nmodule Impl = Pickles.Impls.Step\nmodule Field = Impl.Field\nmodule Boolean = Impl.Boolean\nmodule Typ = Impl.Typ\n\nmodule Public_input = struct\n type t = Field.t array\n\n module Constant = struct\n type t = Field.Constant.t array\n end\nend\n\ntype 'a statement = 'a array * 'a array\n\nmodule Statement = struct\n type t = Field.t statement\n\n module Constant = struct\n type t = Field.Constant.t statement\n end\nend\n\nlet public_input_typ (i : int) = Typ.array ~length:i Field.typ\n\nlet statement_typ (input_size : int) (output_size : int) =\n Typ.(array ~length:input_size Field.typ * array ~length:output_size Field.typ)\n\ntype ('prev_proof, 'proof) js_prover =\n Public_input.Constant.t\n -> 'prev_proof array\n -> (Public_input.Constant.t * 'proof) Promise_js_helpers.js_promise\n\nlet dummy_constraints =\n let module Inner_curve = Kimchi_pasta.Pasta.Pallas in\n let module Step_main_inputs = Pickles.Step_main_inputs in\n let inner_curve_typ : (Field.t * Field.t, Inner_curve.t) Typ.t =\n Typ.transport Step_main_inputs.Inner_curve.typ\n ~there:Inner_curve.to_affine_exn ~back:Inner_curve.of_affine\n in\n fun () ->\n let x =\n Impl.exists Field.typ ~compute:(fun () -> Field.Constant.of_int 3)\n in\n let g = Impl.exists inner_curve_typ ~compute:(fun _ -> Inner_curve.one) in\n ignore\n ( Pickles.Scalar_challenge.to_field_checked'\n (module Impl)\n ~num_bits:16\n (Kimchi_backend_common.Scalar_challenge.create x)\n : Field.t * Field.t * Field.t ) ;\n ignore\n ( Step_main_inputs.Ops.scale_fast g ~num_bits:5 (Shifted_value x)\n : Step_main_inputs.Inner_curve.t ) ;\n ignore\n ( Pickles.Step_verifier.Scalar_challenge.endo g ~num_bits:4\n (Kimchi_backend_common.Scalar_challenge.create x)\n : Field.t * Field.t )\n\ntype pickles_rule_js =\n < identifier : Js.js_string Js.t Js.prop\n ; main :\n ( Public_input.t\n -> < publicOutput : Public_input.t Js.prop\n ; previousStatements : Statement.t array Js.prop\n ; shouldVerify : Boolean.var array Js.prop >\n Js.t )\n Js.prop\n ; proofsToVerify :\n < isSelf : bool Js.t Js.prop ; tag : Js.Unsafe.any Js.t Js.prop > Js.t\n array\n Js.prop >\n Js.t\n\nmodule Choices = struct\n open Pickles_types\n open Hlist\n\n module Prevs = struct\n type ('var, 'value, 'width, 'height) t =\n | Prevs :\n ( self:('var, 'value, 'width, 'height) Pickles.Tag.t\n -> ('prev_var, 'prev_values, 'widths, 'heights) H4.T(Pickles.Tag).t\n )\n -> ('var, 'value, 'width, 'height) t\n\n let of_rule (rule : pickles_rule_js) =\n let js_prevs = rule##.proofsToVerify in\n let rec get_tags (Prevs prevs) index =\n if index < 0 then Prevs prevs\n else\n let js_tag = Array.get js_prevs index in\n (* We introduce new opaque types to make sure that the type in the tag\n doesn't escape into the environment or have other ill effects.\n *)\n let module Types = struct\n type var\n\n type value\n\n type width\n\n type height\n end in\n let open Types in\n let to_tag ~self tag : (var, value, width, height) Pickles.Tag.t =\n (* The magic here isn't ideal, but it's safe enough if we immediately\n hide it behind [Types].\n *)\n if Js.to_bool tag##.isSelf then Obj.magic self\n else Obj.magic tag##.tag\n in\n let tag = to_tag js_tag in\n let prevs ~self : _ H4.T(Pickles.Tag).t = tag ~self :: prevs ~self in\n get_tags (Prevs prevs) (index - 1)\n in\n get_tags (Prevs (fun ~self:_ -> [])) (Array.length js_prevs - 1)\n end\n\n module Inductive_rule = struct\n type ( 'var\n , 'value\n , 'width\n , 'height\n , 'arg_var\n , 'arg_value\n , 'ret_var\n , 'ret_value\n , 'auxiliary_var\n , 'auxiliary_value )\n t =\n | Rule :\n ( self:('var, 'value, 'width, 'height) Pickles.Tag.t\n -> ( 'prev_vars\n , 'prev_values\n , 'widths\n , 'heights\n , 'arg_var\n , 'arg_value\n , 'ret_var\n , 'ret_value\n , 'auxiliary_var\n , 'auxiliary_value )\n Pickles.Inductive_rule.t )\n -> ( 'var\n , 'value\n , 'width\n , 'height\n , 'arg_var\n , 'arg_value\n , 'ret_var\n , 'ret_value\n , 'auxiliary_var\n , 'auxiliary_value )\n t\n\n let rec should_verifys :\n type prev_vars prev_values widths heights.\n int\n -> (prev_vars, prev_values, widths, heights) H4.T(Pickles.Tag).t\n -> Boolean.var array\n -> prev_vars H1.T(E01(Pickles.Inductive_rule.B)).t =\n fun index tags should_verifys_js ->\n match tags with\n | [] ->\n []\n | _ :: tags ->\n let js_bool = Array.get should_verifys_js index in\n let should_verifys =\n should_verifys (index + 1) tags should_verifys_js\n in\n js_bool :: should_verifys\n\n let should_verifys tags should_verifys_js =\n should_verifys 0 tags should_verifys_js\n\n let get_typ ~public_input_size ~public_output_size\n (type a1 a2 a3 a4 width height) (tag : (a1, a2, a3, a4) Pickles.Tag.t)\n (self :\n ( Public_input.t * Public_input.t\n , Public_input.Constant.t * Public_input.Constant.t\n , width\n , height )\n Pickles.Tag.t ) =\n match Type_equal.Id.same_witness tag.id self.id with\n | None ->\n Pickles.Types_map.public_input tag\n | Some T ->\n statement_typ public_input_size public_output_size\n\n let rec prev_statements :\n type prev_vars prev_values widths heights width height.\n public_input_size:int\n -> public_output_size:int\n -> self:\n ( Public_input.t * Public_input.t\n , Public_input.Constant.t * Public_input.Constant.t\n , width\n , height )\n Pickles.Tag.t\n -> int\n -> (prev_vars, prev_values, widths, heights) H4.T(Pickles.Tag).t\n -> Statement.t array\n -> prev_vars H1.T(Id).t =\n fun ~public_input_size ~public_output_size ~self i tags statements ->\n match tags with\n | [] ->\n []\n | tag :: tags ->\n let (Typ typ) =\n get_typ ~public_input_size ~public_output_size tag self\n in\n let input, output = Array.get statements i in\n let fields = Array.concat [ input; output ] in\n let aux = typ.constraint_system_auxiliary () in\n let statement = typ.var_of_fields (fields, aux) in\n statement\n :: prev_statements ~public_input_size ~public_output_size ~self\n (i + 1) tags statements\n\n let prev_statements ~public_input_size ~public_output_size ~self tags\n statements =\n prev_statements ~public_input_size ~public_output_size ~self 0 tags\n statements\n\n type _ Snarky_backendless.Request.t +=\n | Get_prev_proof : int -> _ Pickles.Proof.t Snarky_backendless.Request.t\n\n let create ~public_input_size ~public_output_size (rule : pickles_rule_js) :\n ( _\n , _\n , _\n , _\n , Public_input.t\n , Public_input.Constant.t\n , Public_input.t\n , Public_input.Constant.t\n , unit\n , unit )\n t =\n let (Prevs prevs) = Prevs.of_rule rule in\n Rule\n (fun ~(self :\n ( Field.t array * Field.t array\n , Impl.field array * Impl.field array\n , 'b3\n , 'b4 )\n Pickles.Tag.t ) ->\n let prevs = prevs ~self in\n { Pickles.Inductive_rule.identifier = Js.to_string rule##.identifier\n ; feature_flags = Pickles_types.Plonk_types.Features.none_bool\n ; prevs\n ; main =\n (fun { public_input } ->\n dummy_constraints () ;\n let result = rule##.main public_input in\n let public_output = result##.publicOutput in\n let previous_proofs_should_verify =\n should_verifys prevs result##.shouldVerify\n in\n let previous_public_inputs =\n prev_statements ~public_input_size ~public_output_size ~self\n prevs\n result##.previousStatements\n in\n let previous_proof_statements =\n let rec go :\n type prev_vars prev_values widths heights.\n int\n -> prev_vars H1.T(Id).t\n -> prev_vars H1.T(E01(Pickles.Inductive_rule.B)).t\n -> ( prev_vars\n , prev_values\n , widths\n , heights )\n H4.T(Pickles.Tag).t\n -> ( prev_vars\n , widths )\n H2.T(Pickles.Inductive_rule.Previous_proof_statement).t\n =\n fun i public_inputs should_verifys tags ->\n match (public_inputs, should_verifys, tags) with\n | [], [], [] ->\n []\n | ( public_input :: public_inputs\n , proof_must_verify :: should_verifys\n , _tag :: tags ) ->\n let proof =\n Impl.exists (Impl.Typ.Internal.ref ())\n ~request:(fun () -> Get_prev_proof i)\n in\n { public_input; proof; proof_must_verify }\n :: go (i + 1) public_inputs should_verifys tags\n in\n go 0 previous_public_inputs previous_proofs_should_verify\n prevs\n in\n { previous_proof_statements\n ; public_output\n ; auxiliary_output = ()\n } )\n } )\n end\n\n type ( 'var\n , 'value\n , 'width\n , 'height\n , 'arg_var\n , 'arg_value\n , 'ret_var\n , 'ret_value\n , 'auxiliary_var\n , 'auxiliary_value )\n t =\n | Choices :\n ( self:('var, 'value, 'width, 'height) Pickles.Tag.t\n -> ( 'prev_vars\n , 'prev_values\n , 'widths\n , 'heights\n , 'arg_var\n , 'arg_value\n , 'ret_var\n , 'ret_value\n , 'auxiliary_var\n , 'auxiliary_value )\n H4_6.T(Pickles.Inductive_rule).t )\n -> ( 'var\n , 'value\n , 'width\n , 'height\n , 'arg_var\n , 'arg_value\n , 'ret_var\n , 'ret_value\n , 'auxiliary_var\n , 'auxiliary_value )\n t\n\n let of_js ~public_input_size ~public_output_size js_rules =\n let rec get_rules (Choices rules) index :\n ( _\n , _\n , _\n , _\n , Public_input.t\n , Public_input.Constant.t\n , Public_input.t\n , Public_input.Constant.t\n , unit\n , unit )\n t =\n if index < 0 then Choices rules\n else\n let (Rule rule) =\n Inductive_rule.create ~public_input_size ~public_output_size\n (Array.get js_rules index)\n in\n let rules ~self : _ H4_6.T(Pickles.Inductive_rule).t =\n rule ~self :: rules ~self\n in\n get_rules (Choices rules) (index - 1)\n in\n get_rules (Choices (fun ~self:_ -> [])) (Array.length js_rules - 1)\nend\n\ntype proof = (Pickles_types.Nat.N0.n, Pickles_types.Nat.N0.n) Pickles.Proof.t\n\nmodule Public_inputs_with_proofs =\n Pickles_types.Hlist.H3.T (Pickles.Statement_with_proof)\n\nlet nat_modules_list : (module Pickles_types.Nat.Intf) list =\n let open Pickles_types.Nat in\n [ (module N0)\n ; (module N1)\n ; (module N2)\n ; (module N3)\n ; (module N4)\n ; (module N5)\n ; (module N6)\n ; (module N7)\n ; (module N8)\n ; (module N9)\n ; (module N10)\n ; (module N11)\n ; (module N12)\n ; (module N13)\n ; (module N14)\n ; (module N15)\n ; (module N16)\n ; (module N17)\n ; (module N18)\n ; (module N19)\n ; (module N20)\n ]\n\nlet nat_add_modules_list : (module Pickles_types.Nat.Add.Intf) list =\n let open Pickles_types.Nat in\n [ (module N0)\n ; (module N1)\n ; (module N2)\n ; (module N3)\n ; (module N4)\n ; (module N5)\n ; (module N6)\n ; (module N7)\n ; (module N8)\n ; (module N9)\n ; (module N10)\n ; (module N11)\n ; (module N12)\n ; (module N13)\n ; (module N14)\n ; (module N15)\n ; (module N16)\n ; (module N17)\n ; (module N18)\n ; (module N19)\n ; (module N20)\n ]\n\nlet nat_module (i : int) : (module Pickles_types.Nat.Intf) =\n List.nth_exn nat_modules_list i\n\nlet nat_add_module (i : int) : (module Pickles_types.Nat.Add.Intf) =\n List.nth_exn nat_add_modules_list i\n\nlet name = \"smart-contract\"\n\nlet constraint_constants =\n (* TODO these are dummy values *)\n { Snark_keys_header.Constraint_constants.sub_windows_per_window = 0\n ; ledger_depth = 0\n ; work_delay = 0\n ; block_window_duration_ms = 0\n ; transaction_capacity = Log_2 0\n ; pending_coinbase_depth = 0\n ; coinbase_amount = Unsigned.UInt64.of_int 0\n ; supercharged_coinbase_factor = 0\n ; account_creation_fee = Unsigned.UInt64.of_int 0\n ; fork = None\n }\n\nlet pickles_compile (choices : pickles_rule_js array)\n (signature :\n < publicInputSize : int Js.prop\n ; publicOutputSize : int Js.prop\n ; overrideWrapDomain : int Js.optdef_prop >\n Js.t ) =\n (* translate number of branches and recursively verified proofs from JS *)\n let branches = Array.length choices in\n let max_proofs =\n let choices = choices |> Array.to_list in\n List.map choices ~f:(fun c -> c##.proofsToVerify |> Array.length)\n |> List.max_elt ~compare |> Option.value ~default:0\n in\n let (module Branches) = nat_module branches in\n let (module Max_proofs_verified) = nat_add_module max_proofs in\n\n (* translate method circuits from JS *)\n let public_input_size = signature##.publicInputSize in\n let public_output_size = signature##.publicOutputSize in\n let override_wrap_domain =\n Js.Optdef.to_option signature##.overrideWrapDomain\n |> Option.map ~f:Pickles_base.Proofs_verified.of_int\n in\n let (Choices choices) =\n Choices.of_js ~public_input_size ~public_output_size choices\n in\n\n (* call into Pickles *)\n let tag, _cache, p, provers =\n Pickles.compile_promise () ?override_wrap_domain ~choices\n ~public_input:\n (Input_and_output\n ( public_input_typ public_input_size\n , public_input_typ public_output_size ) )\n ~auxiliary_typ:Typ.unit\n ~branches:(module Branches)\n ~max_proofs_verified:(module Max_proofs_verified)\n ~name ~constraint_constants\n in\n\n (* translate returned prover and verify functions to JS *)\n let module Proof = (val p) in\n let to_js_prover prover : ('prev_proof, Proof.t) js_prover =\n let prove (public_input : Public_input.Constant.t)\n (prevs : 'prev_proof array) =\n let handler (Snarky_backendless.Request.With { request; respond }) =\n match request with\n | Choices.Inductive_rule.Get_prev_proof i ->\n respond (Provide (Obj.magic (Array.get prevs i)))\n | _ ->\n respond Unhandled\n in\n prover ?handler:(Some handler) public_input\n |> Promise.map ~f:(fun (output, _, proof) -> (output, proof))\n |> Promise_js_helpers.to_js\n in\n prove\n in\n let rec to_js_provers :\n type a b c.\n ( a\n , b\n , c\n , Public_input.Constant.t\n , (Public_input.Constant.t * unit * Proof.t) Promise.t )\n Pickles.Provers.t\n -> ('prev_proof, Proof.t) js_prover list = function\n | [] ->\n []\n | p :: ps ->\n to_js_prover p :: to_js_provers ps\n in\n let provers : (_, Proof.t) js_prover array =\n provers |> to_js_provers |> Array.of_list\n in\n let verify (statement : Statement.Constant.t) (proof : _ Pickles.Proof.t) =\n Proof.verify_promise [ (statement, proof) ]\n |> Promise.map ~f:(fun x -> Js.bool (Or_error.is_ok x))\n |> Promise_js_helpers.to_js\n in\n object%js\n val provers = Obj.magic provers\n\n val verify = Obj.magic verify\n\n val tag = Obj.magic tag\n\n method getVerificationKey =\n let vk = Pickles.Side_loaded.Verification_key.of_compiled tag in\n let data = Pickles.Side_loaded.Verification_key.to_base64 vk in\n let hash = Mina_base.Zkapp_account.digest_vk vk in\n (data |> Js.string, hash)\n end\n\nmodule Proof0 = Pickles.Proof.Make (Pickles_types.Nat.N0) (Pickles_types.Nat.N0)\nmodule Proof1 = Pickles.Proof.Make (Pickles_types.Nat.N1) (Pickles_types.Nat.N1)\nmodule Proof2 = Pickles.Proof.Make (Pickles_types.Nat.N2) (Pickles_types.Nat.N2)\n\ntype some_proof = Proof0 of Proof0.t | Proof1 of Proof1.t | Proof2 of Proof2.t\n\nlet proof_to_base64 = function\n | Proof0 proof ->\n Proof0.to_base64 proof |> Js.string\n | Proof1 proof ->\n Proof1.to_base64 proof |> Js.string\n | Proof2 proof ->\n Proof2.to_base64 proof |> Js.string\n\nlet proof_of_base64 str i : some_proof =\n let str = Js.to_string str in\n match i with\n | 0 ->\n Proof0 (Proof0.of_base64 str |> Result.ok_or_failwith)\n | 1 ->\n Proof1 (Proof1.of_base64 str |> Result.ok_or_failwith)\n | 2 ->\n Proof2 (Proof2.of_base64 str |> Result.ok_or_failwith)\n | _ ->\n failwith \"invalid proof index\"\n\nlet verify (statement : Statement.Constant.t) (proof : proof)\n (vk : Js.js_string Js.t) =\n let i, o = statement in\n let typ = statement_typ (Array.length i) (Array.length o) in\n let proof = Pickles.Side_loaded.Proof.of_proof proof in\n let vk =\n match Pickles.Side_loaded.Verification_key.of_base64 (Js.to_string vk) with\n | Ok vk_ ->\n vk_\n | Error err ->\n failwithf \"Could not decode base64 verification key: %s\"\n (Error.to_string_hum err) ()\n in\n Pickles.Side_loaded.verify_promise ~typ [ (vk, statement, proof) ]\n |> Promise.map ~f:(fun x -> Js.bool (Or_error.is_ok x))\n |> Promise_js_helpers.to_js\n\nlet dummy_base64_proof () =\n let n2 = Pickles_types.Nat.N2.n in\n let proof = Pickles.Proof.dummy n2 n2 n2 ~domain_log2:15 in\n Proof2.to_base64 proof |> Js.string\n\nlet dummy_verification_key () =\n let vk = Pickles.Side_loaded.Verification_key.dummy in\n let data = Pickles.Side_loaded.Verification_key.to_base64 vk in\n let hash = Mina_base.Zkapp_account.digest_vk vk in\n (data |> Js.string, hash)\n\nlet pickles =\n object%js\n val compile = pickles_compile\n\n val verify = verify\n\n val dummyBase64Proof = dummy_base64_proof\n\n val dummyVerificationKey = dummy_verification_key\n\n val proofToBase64 = proof_to_base64\n\n val proofOfBase64 = proof_of_base64\n\n val proofToBase64Transaction =\n fun (proof : proof) ->\n proof |> Pickles.Side_loaded.Proof.of_proof\n |> Pickles.Side_loaded.Proof.to_base64 |> Js.string\n end\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Benoit Vaugon, ENSTA *)\n(* *)\n(* Copyright 2014 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* Padding position. *)\ntype padty =\n | Left (* Text is left justified ('-' option). *)\n | Right (* Text is right justified (no '-' option). *)\n | Zeros (* Text is right justified by zeros (see '0' option). *)\n\n(***)\n\n(* Integer conversion. *)\ntype int_conv =\n | Int_d | Int_pd | Int_sd (* %d | %+d | % d *)\n | Int_i | Int_pi | Int_si (* %i | %+i | % i *)\n | Int_x | Int_Cx (* %x | %#x *)\n | Int_X | Int_CX (* %X | %#X *)\n | Int_o | Int_Co (* %o | %#o *)\n | Int_u (* %u *)\n | Int_Cd | Int_Ci | Int_Cu (* %#d | %#i | %#u *)\n\n(* Float conversion. *)\ntype float_flag_conv =\n | Float_flag_ (* %[feEgGFhH] *)\n | Float_flag_p (* %+[feEgGFhH] *)\n | Float_flag_s (* % [feEgGFhH] *)\ntype float_kind_conv =\n | Float_f (* %f | %+f | % f *)\n | Float_e (* %e | %+e | % e *)\n | Float_E (* %E | %+E | % E *)\n | Float_g (* %g | %+g | % g *)\n | Float_G (* %G | %+G | % G *)\n | Float_F (* %F | %+F | % F *)\n | Float_h (* %h | %+h | % h *)\n | Float_H (* %H | %+H | % H *)\n | Float_CF (* %#F| %+#F| % #F *)\ntype float_conv = float_flag_conv * float_kind_conv\n\n(***)\n\n(* Char sets (see %[...]) are bitmaps implemented as 32-char strings. *)\ntype char_set = string\n\n(***)\n\n(* Counter used in Scanf. *)\ntype counter =\n | Line_counter (* %l *)\n | Char_counter (* %n *)\n | Token_counter (* %N, %L *)\n\n(***)\n\n(* Padding of strings and numbers. *)\ntype ('a, 'b) padding =\n (* No padding (ex: \"%d\") *)\n | No_padding : ('a, 'a) padding\n (* Literal padding (ex: \"%8d\") *)\n | Lit_padding : padty * int -> ('a, 'a) padding\n (* Padding as extra argument (ex: \"%*d\") *)\n | Arg_padding : padty -> (int -> 'a, 'a) padding\n\n(* Some formats, such as %_d,\n only accept an optional number as padding option (no extra argument) *)\ntype pad_option = int option\n\n(* Precision of floats and '0'-padding of integers. *)\ntype ('a, 'b) precision =\n (* No precision (ex: \"%f\") *)\n | No_precision : ('a, 'a) precision\n (* Literal precision (ex: \"%.3f\") *)\n | Lit_precision : int -> ('a, 'a) precision\n (* Precision as extra argument (ex: \"%.*f\") *)\n | Arg_precision : (int -> 'a, 'a) precision\n\n(* Some formats, such as %_f,\n only accept an optional number as precision option (no extra argument) *)\ntype prec_option = int option\n\n(* see the Custom format combinator *)\ntype ('a, 'b, 'c) custom_arity =\n | Custom_zero : ('a, string, 'a) custom_arity\n | Custom_succ : ('a, 'b, 'c) custom_arity ->\n ('a, 'x -> 'b, 'x -> 'c) custom_arity\n\n(***)\n\n(* Relational format types\n\nIn the first format+gadts implementation, the type for %(..%) in the\nfmt GADT was as follows:\n\n| Format_subst : (* %(...%) *)\n pad_option * ('d1, 'q1, 'd2, 'q2) reader_nb_unifier *\n ('x, 'b, 'c, 'd1, 'q1, 'u) fmtty *\n ('u, 'b, 'c, 'q1, 'e1, 'f) fmt ->\n (('x, 'b, 'c, 'd2, 'q2, 'u) format6 -> 'x, 'b, 'c, 'd1, 'e1, 'f) fmt\n\nNotice that the 'u parameter in 'f position in the format argument\n(('x, .., 'u) format6 -> ..) is equal to the 'u parameter in 'a\nposition in the format tail (('u, .., 'f) fmt). This means that the\ntype of the expected format parameter depends of where the %(...%)\nare in the format string:\n\n # Printf.printf \"%(%)\"\n - : (unit, out_channel, unit, '_a, '_a, unit)\n CamlinternalFormatBasics.format6 -> unit\n = \n # Printf.printf \"%(%)%d\"\n - : (int -> unit, out_channel, unit, '_a, '_a, int -> unit)\n CamlinternalFormatBasics.format6 -> int -> unit\n = \n\nOn the contrary, the legacy typer gives a clever type that does not\ndepend on the position of %(..%) in the format string. For example,\n%(%) will have the polymorphic type ('a, 'b, 'c, 'd, 'd, 'a): it can\nbe concatenated to any format type, and only enforces the constraint\nthat its 'a and 'f parameters are equal (no format arguments) and 'd\nand 'e are equal (no reader argument).\n\nThe weakening of this parameter type in the GADT version broke user\ncode (in fact it essentially made %(...%) unusable except at the last\nposition of a format). In particular, the following would not work\nanymore:\n\n fun sep ->\n Format.printf \"foo%(%)bar%(%)baz\" sep sep\n\nAs the type-checker would require two *incompatible* types for the %(%)\nin different positions.\n\nThe solution to regain a general type for %(..%) is to generalize this\ntechnique, not only on the 'd, 'e parameters, but on all six\nparameters of a format: we introduce a \"relational\" type\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel\nwhose values are proofs that ('a1, .., 'f1) and ('a2, .., 'f2) morally\ncorrespond to the same format type: 'a1 is obtained from 'f1,'b1,'c1\nin the exact same way that 'a2 is obtained from 'f2,'b2,'c2, etc.\n\nFor example, the relation between two format types beginning with a Char\nparameter is as follows:\n\n| Char_ty : (* %c *)\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->\n (char -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n char -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel\n\nIn the general case, the term structure of fmtty_rel is (almost[1])\nisomorphic to the fmtty of the previous implementation: every\nconstructor is re-read with a binary, relational type, instead of the\nprevious unary typing. fmtty can then be re-defined as the diagonal of\nfmtty_rel:\n\n type ('a, 'b, 'c, 'd, 'e, 'f) fmtty =\n ('a, 'b, 'c, 'd, 'e, 'f,\n 'a, 'b, 'c, 'd, 'e, 'f) fmtty_rel\n\nOnce we have this fmtty_rel type in place, we can give the more\ngeneral type to %(...%):\n\n| Format_subst : (* %(...%) *)\n pad_option *\n ('g, 'h, 'i, 'j, 'k, 'l,\n 'g2, 'b, 'c, 'j2, 'd, 'a) fmtty_rel *\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n (('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'g2, 'b, 'c, 'j2, 'e, 'f) fmt\n\nWe accept any format (('g, 'h, 'i, 'j, 'k, 'l) format6) (this is\ncompletely unrelated to the type of the current format), but also\nrequire a proof that this format is in relation to another format that\nis concatenable to the format tail. When executing a %(...%) format\n(in camlinternalFormat.ml:make_printf or scanf.ml:make_scanf), we\ntranstype the format along this relation using the 'recast' function\nto transpose between related format types.\n\n val recast :\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1) fmt\n -> ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel\n -> ('a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmt\n\nNOTE [1]: the typing of Format_subst_ty requires not one format type, but\ntwo, one to establish the link between the format argument and the\nfirst six parameters, and the other for the link between the format\nargument and the last six parameters.\n\n| Format_subst_ty : (* %(...%) *)\n ('g, 'h, 'i, 'j, 'k, 'l,\n 'g1, 'b1, 'c1, 'j1, 'd1, 'a1) fmtty_rel *\n ('g, 'h, 'i, 'j, 'k, 'l,\n 'g2, 'b2, 'c2, 'j2, 'd2, 'a2) fmtty_rel *\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->\n (('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'g1, 'b1, 'c1, 'j1, 'e1, 'f1,\n ('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'g2, 'b2, 'c2, 'j2, 'e2, 'f2) fmtty_rel\n\nWhen we generate a format AST, we generate exactly the same witness\nfor both relations, and the witness-conversion functions in\ncamlinternalFormat do rely on this invariant. For example, the\nfunction that proves that the relation is transitive\n\n val trans :\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel\n -> ('a2, 'b2, 'c2, 'd2, 'e2, 'f2,\n 'a3, 'b3, 'c3, 'd3, 'e3, 'f3) fmtty_rel\n -> ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a3, 'b3, 'c3, 'd3, 'e3, 'f3) fmtty_rel\n\ndoes assume that the two inputs have exactly the same term structure\n(and is only every used for argument witnesses of the\nFormat_subst_ty constructor).\n*)\n\n(* Type of a block used by the Format pretty-printer. *)\ntype block_type =\n | Pp_hbox (* Horizontal block no line breaking *)\n | Pp_vbox (* Vertical block each break leads to a new line *)\n | Pp_hvbox (* Horizontal-vertical block: same as vbox, except if this block\n is small enough to fit on a single line *)\n | Pp_hovbox (* Horizontal or Vertical block: breaks lead to new line\n only when necessary to print the content of the block *)\n | Pp_box (* Horizontal or Indent block: breaks lead to new line\n only when necessary to print the content of the block, or\n when it leads to a new indentation of the current line *)\n | Pp_fits (* Internal usage: when a block fits on a single line *)\n\n(* Formatting element used by the Format pretty-printer. *)\ntype formatting_lit =\n | Close_box (* @] *)\n | Close_tag (* @} *)\n | Break of string * int * int (* @, | @ | @; | @;<> *)\n | FFlush (* @? *)\n | Force_newline (* @\\n *)\n | Flush_newline (* @. *)\n | Magic_size of string * int (* @ *)\n | Escaped_at (* @@ *)\n | Escaped_percent (* @%% *)\n | Scan_indic of char (* @X *)\n\n(* Formatting element used by the Format pretty-printer. *)\ntype ('a, 'b, 'c, 'd, 'e, 'f) formatting_gen =\n | Open_tag : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> (* @{ *)\n ('a, 'b, 'c, 'd, 'e, 'f) formatting_gen\n | Open_box : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> (* @[ *)\n ('a, 'b, 'c, 'd, 'e, 'f) formatting_gen\n\n(***)\n\n(* List of format type elements. *)\n(* In particular used to represent %(...%) and %{...%} contents. *)\nand ('a, 'b, 'c, 'd, 'e, 'f) fmtty =\n ('a, 'b, 'c, 'd, 'e, 'f,\n 'a, 'b, 'c, 'd, 'e, 'f) fmtty_rel\nand ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel =\n | Char_ty : (* %c *)\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->\n (char -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n char -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel\n | String_ty : (* %s *)\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->\n (string -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n string -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel\n | Int_ty : (* %d *)\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->\n (int -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n int -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel\n | Int32_ty : (* %ld *)\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->\n (int32 -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n int32 -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel\n | Nativeint_ty : (* %nd *)\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->\n (nativeint -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n nativeint -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel\n | Int64_ty : (* %Ld *)\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->\n (int64 -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n int64 -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel\n | Float_ty : (* %f *)\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->\n (float -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n float -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel\n | Bool_ty : (* %B *)\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->\n (bool -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n bool -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel\n\n | Format_arg_ty : (* %{...%} *)\n ('g, 'h, 'i, 'j, 'k, 'l) fmtty *\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->\n (('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n ('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2)\n fmtty_rel\n | Format_subst_ty : (* %(...%) *)\n ('g, 'h, 'i, 'j, 'k, 'l,\n 'g1, 'b1, 'c1, 'j1, 'd1, 'a1) fmtty_rel *\n ('g, 'h, 'i, 'j, 'k, 'l,\n 'g2, 'b2, 'c2, 'j2, 'd2, 'a2) fmtty_rel *\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->\n (('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'g1, 'b1, 'c1, 'j1, 'e1, 'f1,\n ('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'g2, 'b2, 'c2, 'j2, 'e2, 'f2)\n fmtty_rel\n\n (* Printf and Format specific constructors. *)\n | Alpha_ty : (* %a *)\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->\n (('b1 -> 'x -> 'c1) -> 'x -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n ('b2 -> 'x -> 'c2) -> 'x -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel\n | Theta_ty : (* %t *)\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->\n (('b1 -> 'c1) -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n ('b2 -> 'c2) -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel\n | Any_ty : (* Used for custom formats *)\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->\n ('x -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'x -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel\n\n (* Scanf specific constructor. *)\n | Reader_ty : (* %r *)\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->\n ('x -> 'a1, 'b1, 'c1, ('b1 -> 'x) -> 'd1, 'e1, 'f1,\n 'x -> 'a2, 'b2, 'c2, ('b2 -> 'x) -> 'd2, 'e2, 'f2) fmtty_rel\n | Ignored_reader_ty : (* %_r *)\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->\n ('a1, 'b1, 'c1, ('b1 -> 'x) -> 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, ('b2 -> 'x) -> 'd2, 'e2, 'f2) fmtty_rel\n\n | End_of_fmtty :\n ('f1, 'b1, 'c1, 'd1, 'd1, 'f1,\n 'f2, 'b2, 'c2, 'd2, 'd2, 'f2) fmtty_rel\n\n(***)\n\n(* List of format elements. *)\nand ('a, 'b, 'c, 'd, 'e, 'f) fmt =\n | Char : (* %c *)\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n (char -> 'a, 'b, 'c, 'd, 'e, 'f) fmt\n | Caml_char : (* %C *)\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n (char -> 'a, 'b, 'c, 'd, 'e, 'f) fmt\n | String : (* %s *)\n ('x, string -> 'a) padding * ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('x, 'b, 'c, 'd, 'e, 'f) fmt\n | Caml_string : (* %S *)\n ('x, string -> 'a) padding * ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('x, 'b, 'c, 'd, 'e, 'f) fmt\n | Int : (* %[dixXuo] *)\n int_conv * ('x, 'y) padding * ('y, int -> 'a) precision *\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('x, 'b, 'c, 'd, 'e, 'f) fmt\n | Int32 : (* %l[dixXuo] *)\n int_conv * ('x, 'y) padding * ('y, int32 -> 'a) precision *\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('x, 'b, 'c, 'd, 'e, 'f) fmt\n | Nativeint : (* %n[dixXuo] *)\n int_conv * ('x, 'y) padding * ('y, nativeint -> 'a) precision *\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('x, 'b, 'c, 'd, 'e, 'f) fmt\n | Int64 : (* %L[dixXuo] *)\n int_conv * ('x, 'y) padding * ('y, int64 -> 'a) precision *\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('x, 'b, 'c, 'd, 'e, 'f) fmt\n | Float : (* %[feEgGFhH] *)\n float_conv * ('x, 'y) padding * ('y, float -> 'a) precision *\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('x, 'b, 'c, 'd, 'e, 'f) fmt\n | Bool : (* %[bB] *)\n ('x, bool -> 'a) padding * ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('x, 'b, 'c, 'd, 'e, 'f) fmt\n | Flush : (* %! *)\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('a, 'b, 'c, 'd, 'e, 'f) fmt\n\n | String_literal : (* abc *)\n string * ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('a, 'b, 'c, 'd, 'e, 'f) fmt\n | Char_literal : (* x *)\n char * ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('a, 'b, 'c, 'd, 'e, 'f) fmt\n\n | Format_arg : (* %{...%} *)\n pad_option * ('g, 'h, 'i, 'j, 'k, 'l) fmtty *\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n (('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'a, 'b, 'c, 'd, 'e, 'f) fmt\n | Format_subst : (* %(...%) *)\n pad_option *\n ('g, 'h, 'i, 'j, 'k, 'l,\n 'g2, 'b, 'c, 'j2, 'd, 'a) fmtty_rel *\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n (('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'g2, 'b, 'c, 'j2, 'e, 'f) fmt\n\n (* Printf and Format specific constructor. *)\n | Alpha : (* %a *)\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n (('b -> 'x -> 'c) -> 'x -> 'a, 'b, 'c, 'd, 'e, 'f) fmt\n | Theta : (* %t *)\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n (('b -> 'c) -> 'a, 'b, 'c, 'd, 'e, 'f) fmt\n\n (* Format specific constructor: *)\n | Formatting_lit : (* @_ *)\n formatting_lit * ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('a, 'b, 'c, 'd, 'e, 'f) fmt\n | Formatting_gen : (* @_ *)\n ('a1, 'b, 'c, 'd1, 'e1, 'f1) formatting_gen *\n ('f1, 'b, 'c, 'e1, 'e2, 'f2) fmt -> ('a1, 'b, 'c, 'd1, 'e2, 'f2) fmt\n\n (* Scanf specific constructors: *)\n | Reader : (* %r *)\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('x -> 'a, 'b, 'c, ('b -> 'x) -> 'd, 'e, 'f) fmt\n | Scan_char_set : (* %[...] *)\n pad_option * char_set * ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n (string -> 'a, 'b, 'c, 'd, 'e, 'f) fmt\n | Scan_get_counter : (* %[nlNL] *)\n counter * ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n (int -> 'a, 'b, 'c, 'd, 'e, 'f) fmt\n | Scan_next_char : (* %0c *)\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n (char -> 'a, 'b, 'c, 'd, 'e, 'f) fmt\n | Ignored_param : (* %_ *)\n ('a, 'b, 'c, 'd, 'y, 'x) ignored * ('x, 'b, 'c, 'y, 'e, 'f) fmt ->\n ('a, 'b, 'c, 'd, 'e, 'f) fmt\n\n (* Custom printing format (PR#6452, GPR#140)\n\n We include a type Custom of \"custom converters\", where an\n arbitrary function can be used to convert one or more\n arguments. There is no syntax for custom converters, it is only\n intended for custom processors that wish to rely on the\n stdlib-defined format GADTs.\n\n For instance a pre-processor could choose to interpret strings\n prefixed with [\"!\"] as format strings where [%{{ ... }}] is\n a special form to pass a to_string function, so that one could\n write:\n\n {[\n type t = { x : int; y : int }\n\n let string_of_t t = Printf.sprintf \"{ x = %d; y = %d }\" t.x t.y\n\n Printf.printf !\"t = %{{string_of_t}}\" { x = 42; y = 42 }\n ]}\n *)\n | Custom :\n ('a, 'x, 'y) custom_arity * (unit -> 'x) * ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('y, 'b, 'c, 'd, 'e, 'f) fmt\n\n (* end of a format specification *)\n | End_of_format :\n ('f, 'b, 'c, 'e, 'e, 'f) fmt\n\n(***)\n\n(* Type for ignored parameters (see \"%_\"). *)\nand ('a, 'b, 'c, 'd, 'e, 'f) ignored =\n | Ignored_char : (* %_c *)\n ('a, 'b, 'c, 'd, 'd, 'a) ignored\n | Ignored_caml_char : (* %_C *)\n ('a, 'b, 'c, 'd, 'd, 'a) ignored\n | Ignored_string : (* %_s *)\n pad_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored\n | Ignored_caml_string : (* %_S *)\n pad_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored\n | Ignored_int : (* %_d *)\n int_conv * pad_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored\n | Ignored_int32 : (* %_ld *)\n int_conv * pad_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored\n | Ignored_nativeint : (* %_nd *)\n int_conv * pad_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored\n | Ignored_int64 : (* %_Ld *)\n int_conv * pad_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored\n | Ignored_float : (* %_f *)\n pad_option * prec_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored\n | Ignored_bool : (* %_B *)\n pad_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored\n | Ignored_format_arg : (* %_{...%} *)\n pad_option * ('g, 'h, 'i, 'j, 'k, 'l) fmtty ->\n ('a, 'b, 'c, 'd, 'd, 'a) ignored\n | Ignored_format_subst : (* %_(...%) *)\n pad_option * ('a, 'b, 'c, 'd, 'e, 'f) fmtty ->\n ('a, 'b, 'c, 'd, 'e, 'f) ignored\n | Ignored_reader : (* %_r *)\n ('a, 'b, 'c, ('b -> 'x) -> 'd, 'd, 'a) ignored\n | Ignored_scan_char_set : (* %_[...] *)\n pad_option * char_set -> ('a, 'b, 'c, 'd, 'd, 'a) ignored\n | Ignored_scan_get_counter : (* %_[nlNL] *)\n counter -> ('a, 'b, 'c, 'd, 'd, 'a) ignored\n | Ignored_scan_next_char : (* %_0c *)\n ('a, 'b, 'c, 'd, 'd, 'a) ignored\n\nand ('a, 'b, 'c, 'd, 'e, 'f) format6 =\n Format of ('a, 'b, 'c, 'd, 'e, 'f) fmt * string\n\nlet rec erase_rel : type a b c d e f g h i j k l .\n (a, b, c, d, e, f,\n g, h, i, j, k, l) fmtty_rel -> (a, b, c, d, e, f) fmtty\n= function\n | Char_ty rest ->\n Char_ty (erase_rel rest)\n | String_ty rest ->\n String_ty (erase_rel rest)\n | Int_ty rest ->\n Int_ty (erase_rel rest)\n | Int32_ty rest ->\n Int32_ty (erase_rel rest)\n | Int64_ty rest ->\n Int64_ty (erase_rel rest)\n | Nativeint_ty rest ->\n Nativeint_ty (erase_rel rest)\n | Float_ty rest ->\n Float_ty (erase_rel rest)\n | Bool_ty rest ->\n Bool_ty (erase_rel rest)\n | Format_arg_ty (ty, rest) ->\n Format_arg_ty (ty, erase_rel rest)\n | Format_subst_ty (ty1, _ty2, rest) ->\n Format_subst_ty (ty1, ty1, erase_rel rest)\n | Alpha_ty rest ->\n Alpha_ty (erase_rel rest)\n | Theta_ty rest ->\n Theta_ty (erase_rel rest)\n | Any_ty rest ->\n Any_ty (erase_rel rest)\n | Reader_ty rest ->\n Reader_ty (erase_rel rest)\n | Ignored_reader_ty rest ->\n Ignored_reader_ty (erase_rel rest)\n | End_of_fmtty -> End_of_fmtty\n\n(******************************************************************************)\n (* Format type concatenation *)\n\n(* Concatenate two format types. *)\n(* Used by:\n * reader_nb_unifier_of_fmtty to count readers in an fmtty,\n * Scanf.take_fmtty_format_readers to extract readers inside %(...%),\n * CamlinternalFormat.fmtty_of_ignored_format to extract format type. *)\n\n(*\nlet rec concat_fmtty : type a b c d e f g h .\n (a, b, c, d, e, f) fmtty ->\n (f, b, c, e, g, h) fmtty ->\n (a, b, c, d, g, h) fmtty =\n*)\nlet rec concat_fmtty :\n type a1 b1 c1 d1 e1 f1\n a2 b2 c2 d2 e2 f2\n g1 j1 g2 j2\n .\n (g1, b1, c1, j1, d1, a1,\n g2, b2, c2, j2, d2, a2) fmtty_rel ->\n (a1, b1, c1, d1, e1, f1,\n a2, b2, c2, d2, e2, f2) fmtty_rel ->\n (g1, b1, c1, j1, e1, f1,\n g2, b2, c2, j2, e2, f2) fmtty_rel =\nfun fmtty1 fmtty2 -> match fmtty1 with\n | Char_ty rest ->\n Char_ty (concat_fmtty rest fmtty2)\n | String_ty rest ->\n String_ty (concat_fmtty rest fmtty2)\n | Int_ty rest ->\n Int_ty (concat_fmtty rest fmtty2)\n | Int32_ty rest ->\n Int32_ty (concat_fmtty rest fmtty2)\n | Nativeint_ty rest ->\n Nativeint_ty (concat_fmtty rest fmtty2)\n | Int64_ty rest ->\n Int64_ty (concat_fmtty rest fmtty2)\n | Float_ty rest ->\n Float_ty (concat_fmtty rest fmtty2)\n | Bool_ty rest ->\n Bool_ty (concat_fmtty rest fmtty2)\n | Alpha_ty rest ->\n Alpha_ty (concat_fmtty rest fmtty2)\n | Theta_ty rest ->\n Theta_ty (concat_fmtty rest fmtty2)\n | Any_ty rest ->\n Any_ty (concat_fmtty rest fmtty2)\n | Reader_ty rest ->\n Reader_ty (concat_fmtty rest fmtty2)\n | Ignored_reader_ty rest ->\n Ignored_reader_ty (concat_fmtty rest fmtty2)\n | Format_arg_ty (ty, rest) ->\n Format_arg_ty (ty, concat_fmtty rest fmtty2)\n | Format_subst_ty (ty1, ty2, rest) ->\n Format_subst_ty (ty1, ty2, concat_fmtty rest fmtty2)\n | End_of_fmtty -> fmtty2\n\n(******************************************************************************)\n (* Format concatenation *)\n\n(* Concatenate two formats. *)\nlet rec concat_fmt : type a b c d e f g h .\n (a, b, c, d, e, f) fmt ->\n (f, b, c, e, g, h) fmt ->\n (a, b, c, d, g, h) fmt =\nfun fmt1 fmt2 -> match fmt1 with\n | String (pad, rest) ->\n String (pad, concat_fmt rest fmt2)\n | Caml_string (pad, rest) ->\n Caml_string (pad, concat_fmt rest fmt2)\n\n | Int (iconv, pad, prec, rest) ->\n Int (iconv, pad, prec, concat_fmt rest fmt2)\n | Int32 (iconv, pad, prec, rest) ->\n Int32 (iconv, pad, prec, concat_fmt rest fmt2)\n | Nativeint (iconv, pad, prec, rest) ->\n Nativeint (iconv, pad, prec, concat_fmt rest fmt2)\n | Int64 (iconv, pad, prec, rest) ->\n Int64 (iconv, pad, prec, concat_fmt rest fmt2)\n | Float (fconv, pad, prec, rest) ->\n Float (fconv, pad, prec, concat_fmt rest fmt2)\n\n | Char (rest) ->\n Char (concat_fmt rest fmt2)\n | Caml_char rest ->\n Caml_char (concat_fmt rest fmt2)\n | Bool (pad, rest) ->\n Bool (pad, concat_fmt rest fmt2)\n | Alpha rest ->\n Alpha (concat_fmt rest fmt2)\n | Theta rest ->\n Theta (concat_fmt rest fmt2)\n | Custom (arity, f, rest) ->\n Custom (arity, f, concat_fmt rest fmt2)\n | Reader rest ->\n Reader (concat_fmt rest fmt2)\n | Flush rest ->\n Flush (concat_fmt rest fmt2)\n\n | String_literal (str, rest) ->\n String_literal (str, concat_fmt rest fmt2)\n | Char_literal (chr, rest) ->\n Char_literal (chr, concat_fmt rest fmt2)\n\n | Format_arg (pad, fmtty, rest) ->\n Format_arg (pad, fmtty, concat_fmt rest fmt2)\n | Format_subst (pad, fmtty, rest) ->\n Format_subst (pad, fmtty, concat_fmt rest fmt2)\n\n | Scan_char_set (width_opt, char_set, rest) ->\n Scan_char_set (width_opt, char_set, concat_fmt rest fmt2)\n | Scan_get_counter (counter, rest) ->\n Scan_get_counter (counter, concat_fmt rest fmt2)\n | Scan_next_char (rest) ->\n Scan_next_char (concat_fmt rest fmt2)\n | Ignored_param (ign, rest) ->\n Ignored_param (ign, concat_fmt rest fmt2)\n\n | Formatting_lit (fmting_lit, rest) ->\n Formatting_lit (fmting_lit, concat_fmt rest fmt2)\n | Formatting_gen (fmting_gen, rest) ->\n Formatting_gen (fmting_gen, concat_fmt rest fmt2)\n\n | End_of_format ->\n fmt2\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Gabriel Scherer, projet Partout, INRIA Paris-Saclay *)\n(* *)\n(* Copyright 2020 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* CamlinternalAtomic is a dependency of Stdlib, so it is compiled with\n -nopervasives. *)\nexternal ( == ) : 'a -> 'a -> bool = \"%eq\"\nexternal ( + ) : int -> int -> int = \"%addint\"\nexternal ignore : 'a -> unit = \"%ignore\"\n\n(* We are not reusing ('a ref) directly to make it easier to reason\n about atomicity if we wish to: even in a sequential implementation,\n signals and other asynchronous callbacks might break atomicity. *)\ntype 'a t = {mutable v: 'a}\n\nlet make v = {v}\nlet get r = r.v\nlet set r v = r.v <- v\n\n(* The following functions are set to never be inlined: Flambda is\n allowed to move surrounding code inside the critical section,\n including allocations. *)\n\nlet[@inline never] exchange r v =\n (* BEGIN ATOMIC *)\n let cur = r.v in\n r.v <- v;\n (* END ATOMIC *)\n cur\n\nlet[@inline never] compare_and_set r seen v =\n (* BEGIN ATOMIC *)\n let cur = r.v in\n if cur == seen then (\n r.v <- v;\n (* END ATOMIC *)\n true\n ) else\n false\n\nlet[@inline never] fetch_and_add r n =\n (* BEGIN ATOMIC *)\n let cur = r.v in\n r.v <- (cur + n);\n (* END ATOMIC *)\n cur\n\nlet incr r = ignore (fetch_and_add r 1)\nlet decr r = ignore (fetch_and_add r (-1))\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* Exceptions *)\n\nexternal register_named_value : string -> 'a -> unit\n = \"caml_register_named_value\"\n\nlet () =\n (* for runtime/fail_nat.c *)\n register_named_value \"Pervasives.array_bound_error\"\n (Invalid_argument \"index out of bounds\")\n\nexternal raise : exn -> 'a = \"%raise\"\nexternal raise_notrace : exn -> 'a = \"%raise_notrace\"\n\nlet failwith s = raise(Failure s)\nlet invalid_arg s = raise(Invalid_argument s)\n\nexception Exit\nexception Match_failure = Match_failure\nexception Assert_failure = Assert_failure\nexception Invalid_argument = Invalid_argument\nexception Failure = Failure\nexception Not_found = Not_found\nexception Out_of_memory = Out_of_memory\nexception Stack_overflow = Stack_overflow\nexception Sys_error = Sys_error\nexception End_of_file = End_of_file\nexception Division_by_zero = Division_by_zero\nexception Sys_blocked_io = Sys_blocked_io\nexception Undefined_recursive_module = Undefined_recursive_module\n\n(* Composition operators *)\n\nexternal ( |> ) : 'a -> ('a -> 'b) -> 'b = \"%revapply\"\nexternal ( @@ ) : ('a -> 'b) -> 'a -> 'b = \"%apply\"\n\n(* Debugging *)\n\nexternal __LOC__ : string = \"%loc_LOC\"\nexternal __FILE__ : string = \"%loc_FILE\"\nexternal __LINE__ : int = \"%loc_LINE\"\nexternal __MODULE__ : string = \"%loc_MODULE\"\nexternal __POS__ : string * int * int * int = \"%loc_POS\"\nexternal __FUNCTION__ : string = \"%loc_FUNCTION\"\n\nexternal __LOC_OF__ : 'a -> string * 'a = \"%loc_LOC\"\nexternal __LINE_OF__ : 'a -> int * 'a = \"%loc_LINE\"\nexternal __POS_OF__ : 'a -> (string * int * int * int) * 'a = \"%loc_POS\"\n\n(* Comparisons *)\n\nexternal ( = ) : 'a -> 'a -> bool = \"%equal\"\nexternal ( <> ) : 'a -> 'a -> bool = \"%notequal\"\nexternal ( < ) : 'a -> 'a -> bool = \"%lessthan\"\nexternal ( > ) : 'a -> 'a -> bool = \"%greaterthan\"\nexternal ( <= ) : 'a -> 'a -> bool = \"%lessequal\"\nexternal ( >= ) : 'a -> 'a -> bool = \"%greaterequal\"\nexternal compare : 'a -> 'a -> int = \"%compare\"\n\nlet min x y = if x <= y then x else y\nlet max x y = if x >= y then x else y\n\nexternal ( == ) : 'a -> 'a -> bool = \"%eq\"\nexternal ( != ) : 'a -> 'a -> bool = \"%noteq\"\n\n(* Boolean operations *)\n\nexternal not : bool -> bool = \"%boolnot\"\nexternal ( & ) : bool -> bool -> bool = \"%sequand\"\nexternal ( && ) : bool -> bool -> bool = \"%sequand\"\nexternal ( or ) : bool -> bool -> bool = \"%sequor\"\nexternal ( || ) : bool -> bool -> bool = \"%sequor\"\n\n(* Integer operations *)\n\nexternal ( ~- ) : int -> int = \"%negint\"\nexternal ( ~+ ) : int -> int = \"%identity\"\nexternal succ : int -> int = \"%succint\"\nexternal pred : int -> int = \"%predint\"\nexternal ( + ) : int -> int -> int = \"%addint\"\nexternal ( - ) : int -> int -> int = \"%subint\"\nexternal ( * ) : int -> int -> int = \"%mulint\"\nexternal ( / ) : int -> int -> int = \"%divint\"\nexternal ( mod ) : int -> int -> int = \"%modint\"\n\nlet abs x = if x >= 0 then x else -x\n\nexternal ( land ) : int -> int -> int = \"%andint\"\nexternal ( lor ) : int -> int -> int = \"%orint\"\nexternal ( lxor ) : int -> int -> int = \"%xorint\"\n\nlet lnot x = x lxor (-1)\n\nexternal ( lsl ) : int -> int -> int = \"%lslint\"\nexternal ( lsr ) : int -> int -> int = \"%lsrint\"\nexternal ( asr ) : int -> int -> int = \"%asrint\"\n\nlet max_int = (-1) lsr 1\nlet min_int = max_int + 1\n\n(* Floating-point operations *)\n\nexternal ( ~-. ) : float -> float = \"%negfloat\"\nexternal ( ~+. ) : float -> float = \"%identity\"\nexternal ( +. ) : float -> float -> float = \"%addfloat\"\nexternal ( -. ) : float -> float -> float = \"%subfloat\"\nexternal ( *. ) : float -> float -> float = \"%mulfloat\"\nexternal ( /. ) : float -> float -> float = \"%divfloat\"\nexternal ( ** ) : float -> float -> float = \"caml_power_float\" \"pow\"\n [@@unboxed] [@@noalloc]\nexternal exp : float -> float = \"caml_exp_float\" \"exp\" [@@unboxed] [@@noalloc]\nexternal expm1 : float -> float = \"caml_expm1_float\" \"caml_expm1\"\n [@@unboxed] [@@noalloc]\nexternal acos : float -> float = \"caml_acos_float\" \"acos\"\n [@@unboxed] [@@noalloc]\nexternal asin : float -> float = \"caml_asin_float\" \"asin\"\n [@@unboxed] [@@noalloc]\nexternal atan : float -> float = \"caml_atan_float\" \"atan\"\n [@@unboxed] [@@noalloc]\nexternal atan2 : float -> float -> float = \"caml_atan2_float\" \"atan2\"\n [@@unboxed] [@@noalloc]\nexternal hypot : float -> float -> float\n = \"caml_hypot_float\" \"caml_hypot\" [@@unboxed] [@@noalloc]\nexternal cos : float -> float = \"caml_cos_float\" \"cos\" [@@unboxed] [@@noalloc]\nexternal cosh : float -> float = \"caml_cosh_float\" \"cosh\"\n [@@unboxed] [@@noalloc]\nexternal acosh : float -> float = \"caml_acosh_float\" \"caml_acosh\"\n [@@unboxed] [@@noalloc]\nexternal log : float -> float = \"caml_log_float\" \"log\" [@@unboxed] [@@noalloc]\nexternal log10 : float -> float = \"caml_log10_float\" \"log10\"\n [@@unboxed] [@@noalloc]\nexternal log1p : float -> float = \"caml_log1p_float\" \"caml_log1p\"\n [@@unboxed] [@@noalloc]\nexternal sin : float -> float = \"caml_sin_float\" \"sin\" [@@unboxed] [@@noalloc]\nexternal sinh : float -> float = \"caml_sinh_float\" \"sinh\"\n [@@unboxed] [@@noalloc]\nexternal asinh : float -> float = \"caml_asinh_float\" \"caml_asinh\"\n [@@unboxed] [@@noalloc]\nexternal sqrt : float -> float = \"caml_sqrt_float\" \"sqrt\"\n [@@unboxed] [@@noalloc]\nexternal tan : float -> float = \"caml_tan_float\" \"tan\" [@@unboxed] [@@noalloc]\nexternal tanh : float -> float = \"caml_tanh_float\" \"tanh\"\n [@@unboxed] [@@noalloc]\nexternal atanh : float -> float = \"caml_atanh_float\" \"caml_atanh\"\n [@@unboxed] [@@noalloc]\nexternal ceil : float -> float = \"caml_ceil_float\" \"ceil\"\n [@@unboxed] [@@noalloc]\nexternal floor : float -> float = \"caml_floor_float\" \"floor\"\n [@@unboxed] [@@noalloc]\nexternal abs_float : float -> float = \"%absfloat\"\nexternal copysign : float -> float -> float\n = \"caml_copysign_float\" \"caml_copysign\"\n [@@unboxed] [@@noalloc]\nexternal mod_float : float -> float -> float = \"caml_fmod_float\" \"fmod\"\n [@@unboxed] [@@noalloc]\nexternal frexp : float -> float * int = \"caml_frexp_float\"\nexternal ldexp : (float [@unboxed]) -> (int [@untagged]) -> (float [@unboxed]) =\n \"caml_ldexp_float\" \"caml_ldexp_float_unboxed\" [@@noalloc]\nexternal modf : float -> float * float = \"caml_modf_float\"\nexternal float : int -> float = \"%floatofint\"\nexternal float_of_int : int -> float = \"%floatofint\"\nexternal truncate : float -> int = \"%intoffloat\"\nexternal int_of_float : float -> int = \"%intoffloat\"\nexternal float_of_bits : int64 -> float\n = \"caml_int64_float_of_bits\" \"caml_int64_float_of_bits_unboxed\"\n [@@unboxed] [@@noalloc]\nlet infinity =\n float_of_bits 0x7F_F0_00_00_00_00_00_00L\nlet neg_infinity =\n float_of_bits 0xFF_F0_00_00_00_00_00_00L\nlet nan =\n float_of_bits 0x7F_F0_00_00_00_00_00_01L\nlet max_float =\n float_of_bits 0x7F_EF_FF_FF_FF_FF_FF_FFL\nlet min_float =\n float_of_bits 0x00_10_00_00_00_00_00_00L\nlet epsilon_float =\n float_of_bits 0x3C_B0_00_00_00_00_00_00L\n\ntype fpclass =\n FP_normal\n | FP_subnormal\n | FP_zero\n | FP_infinite\n | FP_nan\nexternal classify_float : (float [@unboxed]) -> fpclass =\n \"caml_classify_float\" \"caml_classify_float_unboxed\" [@@noalloc]\n\n(* String and byte sequence operations -- more in modules String and Bytes *)\n\nexternal string_length : string -> int = \"%string_length\"\nexternal bytes_length : bytes -> int = \"%bytes_length\"\nexternal bytes_create : int -> bytes = \"caml_create_bytes\"\nexternal string_blit : string -> int -> bytes -> int -> int -> unit\n = \"caml_blit_string\" [@@noalloc]\nexternal bytes_blit : bytes -> int -> bytes -> int -> int -> unit\n = \"caml_blit_bytes\" [@@noalloc]\nexternal bytes_unsafe_to_string : bytes -> string = \"%bytes_to_string\"\n\nlet ( ^ ) s1 s2 =\n let l1 = string_length s1 and l2 = string_length s2 in\n let s = bytes_create (l1 + l2) in\n string_blit s1 0 s 0 l1;\n string_blit s2 0 s l1 l2;\n bytes_unsafe_to_string s\n\n(* Character operations -- more in module Char *)\n\nexternal int_of_char : char -> int = \"%identity\"\nexternal unsafe_char_of_int : int -> char = \"%identity\"\nlet char_of_int n =\n if n < 0 || n > 255 then invalid_arg \"char_of_int\" else unsafe_char_of_int n\n\n(* Unit operations *)\n\nexternal ignore : 'a -> unit = \"%ignore\"\n\n(* Pair operations *)\n\nexternal fst : 'a * 'b -> 'a = \"%field0\"\nexternal snd : 'a * 'b -> 'b = \"%field1\"\n\n(* References *)\n\ntype 'a ref = { mutable contents : 'a }\nexternal ref : 'a -> 'a ref = \"%makemutable\"\nexternal ( ! ) : 'a ref -> 'a = \"%field0\"\nexternal ( := ) : 'a ref -> 'a -> unit = \"%setfield0\"\nexternal incr : int ref -> unit = \"%incr\"\nexternal decr : int ref -> unit = \"%decr\"\n\n(* Result type *)\n\ntype ('a,'b) result = Ok of 'a | Error of 'b\n\n(* String conversion functions *)\n\nexternal format_int : string -> int -> string = \"caml_format_int\"\nexternal format_float : string -> float -> string = \"caml_format_float\"\n\nlet string_of_bool b =\n if b then \"true\" else \"false\"\nlet bool_of_string = function\n | \"true\" -> true\n | \"false\" -> false\n | _ -> invalid_arg \"bool_of_string\"\n\nlet bool_of_string_opt = function\n | \"true\" -> Some true\n | \"false\" -> Some false\n | _ -> None\n\nlet string_of_int n =\n format_int \"%d\" n\n\nexternal int_of_string : string -> int = \"caml_int_of_string\"\n\nlet int_of_string_opt s =\n (* TODO: provide this directly as a non-raising primitive. *)\n try Some (int_of_string s)\n with Failure _ -> None\n\nexternal string_get : string -> int -> char = \"%string_safe_get\"\n\nlet valid_float_lexem s =\n let l = string_length s in\n let rec loop i =\n if i >= l then s ^ \".\" else\n match string_get s i with\n | '0' .. '9' | '-' -> loop (i + 1)\n | _ -> s\n in\n loop 0\n\nlet string_of_float f = valid_float_lexem (format_float \"%.12g\" f)\n\nexternal float_of_string : string -> float = \"caml_float_of_string\"\n\nlet float_of_string_opt s =\n (* TODO: provide this directly as a non-raising primitive. *)\n try Some (float_of_string s)\n with Failure _ -> None\n\n(* List operations -- more in module List *)\n\nlet rec ( @ ) l1 l2 =\n match l1 with\n [] -> l2\n | hd :: tl -> hd :: (tl @ l2)\n\n(* I/O operations *)\n\ntype in_channel\ntype out_channel\n\nexternal open_descriptor_out : int -> out_channel\n = \"caml_ml_open_descriptor_out\"\nexternal open_descriptor_in : int -> in_channel = \"caml_ml_open_descriptor_in\"\n\nlet stdin = open_descriptor_in 0\nlet stdout = open_descriptor_out 1\nlet stderr = open_descriptor_out 2\n\n(* General output functions *)\n\ntype open_flag =\n Open_rdonly | Open_wronly | Open_append\n | Open_creat | Open_trunc | Open_excl\n | Open_binary | Open_text | Open_nonblock\n\nexternal open_desc : string -> open_flag list -> int -> int = \"caml_sys_open\"\n\nexternal set_out_channel_name: out_channel -> string -> unit =\n \"caml_ml_set_channel_name\"\n\nlet open_out_gen mode perm name =\n let c = open_descriptor_out(open_desc name mode perm) in\n set_out_channel_name c name;\n c\n\nlet open_out name =\n open_out_gen [Open_wronly; Open_creat; Open_trunc; Open_text] 0o666 name\n\nlet open_out_bin name =\n open_out_gen [Open_wronly; Open_creat; Open_trunc; Open_binary] 0o666 name\n\nexternal flush : out_channel -> unit = \"caml_ml_flush\"\n\nexternal out_channels_list : unit -> out_channel list\n = \"caml_ml_out_channels_list\"\n\nlet flush_all () =\n let rec iter = function\n [] -> ()\n | a::l ->\n begin try\n flush a\n with Sys_error _ ->\n () (* ignore channels closed during a preceding flush. *)\n end;\n iter l\n in iter (out_channels_list ())\n\nexternal unsafe_output : out_channel -> bytes -> int -> int -> unit\n = \"caml_ml_output_bytes\"\nexternal unsafe_output_string : out_channel -> string -> int -> int -> unit\n = \"caml_ml_output\"\n\nexternal output_char : out_channel -> char -> unit = \"caml_ml_output_char\"\n\nlet output_bytes oc s =\n unsafe_output oc s 0 (bytes_length s)\n\nlet output_string oc s =\n unsafe_output_string oc s 0 (string_length s)\n\nlet output oc s ofs len =\n if ofs < 0 || len < 0 || ofs > bytes_length s - len\n then invalid_arg \"output\"\n else unsafe_output oc s ofs len\n\nlet output_substring oc s ofs len =\n if ofs < 0 || len < 0 || ofs > string_length s - len\n then invalid_arg \"output_substring\"\n else unsafe_output_string oc s ofs len\n\nexternal output_byte : out_channel -> int -> unit = \"caml_ml_output_char\"\nexternal output_binary_int : out_channel -> int -> unit = \"caml_ml_output_int\"\n\nexternal marshal_to_channel : out_channel -> 'a -> unit list -> unit\n = \"caml_output_value\"\nlet output_value chan v = marshal_to_channel chan v []\n\nexternal seek_out : out_channel -> int -> unit = \"caml_ml_seek_out\"\nexternal pos_out : out_channel -> int = \"caml_ml_pos_out\"\nexternal out_channel_length : out_channel -> int = \"caml_ml_channel_size\"\nexternal close_out_channel : out_channel -> unit = \"caml_ml_close_channel\"\nlet close_out oc = flush oc; close_out_channel oc\nlet close_out_noerr oc =\n (try flush oc with _ -> ());\n (try close_out_channel oc with _ -> ())\nexternal set_binary_mode_out : out_channel -> bool -> unit\n = \"caml_ml_set_binary_mode\"\n\n(* General input functions *)\n\nexternal set_in_channel_name: in_channel -> string -> unit =\n \"caml_ml_set_channel_name\"\n\nlet open_in_gen mode perm name =\n let c = open_descriptor_in(open_desc name mode perm) in\n set_in_channel_name c name;\n c\n\nlet open_in name =\n open_in_gen [Open_rdonly; Open_text] 0 name\n\nlet open_in_bin name =\n open_in_gen [Open_rdonly; Open_binary] 0 name\n\nexternal input_char : in_channel -> char = \"caml_ml_input_char\"\n\nexternal unsafe_input : in_channel -> bytes -> int -> int -> int\n = \"caml_ml_input\"\n\nlet input ic s ofs len =\n if ofs < 0 || len < 0 || ofs > bytes_length s - len\n then invalid_arg \"input\"\n else unsafe_input ic s ofs len\n\nlet rec unsafe_really_input ic s ofs len =\n if len <= 0 then () else begin\n let r = unsafe_input ic s ofs len in\n if r = 0\n then raise End_of_file\n else unsafe_really_input ic s (ofs + r) (len - r)\n end\n\nlet really_input ic s ofs len =\n if ofs < 0 || len < 0 || ofs > bytes_length s - len\n then invalid_arg \"really_input\"\n else unsafe_really_input ic s ofs len\n\nlet really_input_string ic len =\n let s = bytes_create len in\n really_input ic s 0 len;\n bytes_unsafe_to_string s\n\nexternal input_scan_line : in_channel -> int = \"caml_ml_input_scan_line\"\n\nlet input_line chan =\n let rec build_result buf pos = function\n [] -> buf\n | hd :: tl ->\n let len = bytes_length hd in\n bytes_blit hd 0 buf (pos - len) len;\n build_result buf (pos - len) tl in\n let rec scan accu len =\n let n = input_scan_line chan in\n if n = 0 then begin (* n = 0: we are at EOF *)\n match accu with\n [] -> raise End_of_file\n | _ -> build_result (bytes_create len) len accu\n end else if n > 0 then begin (* n > 0: newline found in buffer *)\n let res = bytes_create (n - 1) in\n ignore (unsafe_input chan res 0 (n - 1));\n ignore (input_char chan); (* skip the newline *)\n match accu with\n [] -> res\n | _ -> let len = len + n - 1 in\n build_result (bytes_create len) len (res :: accu)\n end else begin (* n < 0: newline not found *)\n let beg = bytes_create (-n) in\n ignore(unsafe_input chan beg 0 (-n));\n scan (beg :: accu) (len - n)\n end\n in bytes_unsafe_to_string (scan [] 0)\n\nexternal input_byte : in_channel -> int = \"caml_ml_input_char\"\nexternal input_binary_int : in_channel -> int = \"caml_ml_input_int\"\nexternal input_value : in_channel -> 'a = \"caml_input_value\"\nexternal seek_in : in_channel -> int -> unit = \"caml_ml_seek_in\"\nexternal pos_in : in_channel -> int = \"caml_ml_pos_in\"\nexternal in_channel_length : in_channel -> int = \"caml_ml_channel_size\"\nexternal close_in : in_channel -> unit = \"caml_ml_close_channel\"\nlet close_in_noerr ic = (try close_in ic with _ -> ())\nexternal set_binary_mode_in : in_channel -> bool -> unit\n = \"caml_ml_set_binary_mode\"\n\n(* Output functions on standard output *)\n\nlet print_char c = output_char stdout c\nlet print_string s = output_string stdout s\nlet print_bytes s = output_bytes stdout s\nlet print_int i = output_string stdout (string_of_int i)\nlet print_float f = output_string stdout (string_of_float f)\nlet print_endline s =\n output_string stdout s; output_char stdout '\\n'; flush stdout\nlet print_newline () = output_char stdout '\\n'; flush stdout\n\n(* Output functions on standard error *)\n\nlet prerr_char c = output_char stderr c\nlet prerr_string s = output_string stderr s\nlet prerr_bytes s = output_bytes stderr s\nlet prerr_int i = output_string stderr (string_of_int i)\nlet prerr_float f = output_string stderr (string_of_float f)\nlet prerr_endline s =\n output_string stderr s; output_char stderr '\\n'; flush stderr\nlet prerr_newline () = output_char stderr '\\n'; flush stderr\n\n(* Input functions on standard input *)\n\nlet read_line () = flush stdout; input_line stdin\nlet read_int () = int_of_string(read_line())\nlet read_int_opt () = int_of_string_opt(read_line())\nlet read_float () = float_of_string(read_line())\nlet read_float_opt () = float_of_string_opt(read_line())\n\n(* Operations on large files *)\n\nmodule LargeFile =\n struct\n external seek_out : out_channel -> int64 -> unit = \"caml_ml_seek_out_64\"\n external pos_out : out_channel -> int64 = \"caml_ml_pos_out_64\"\n external out_channel_length : out_channel -> int64\n = \"caml_ml_channel_size_64\"\n external seek_in : in_channel -> int64 -> unit = \"caml_ml_seek_in_64\"\n external pos_in : in_channel -> int64 = \"caml_ml_pos_in_64\"\n external in_channel_length : in_channel -> int64 = \"caml_ml_channel_size_64\"\n end\n\n(* Formats *)\n\ntype ('a, 'b, 'c, 'd, 'e, 'f) format6\n = ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.format6\n = Format of ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.fmt\n * string\n\ntype ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'c, 'c, 'd) format6\n\ntype ('a, 'b, 'c) format = ('a, 'b, 'c, 'c) format4\n\nlet string_of_format (Format (_fmt, str)) = str\n\nexternal format_of_string :\n ('a, 'b, 'c, 'd, 'e, 'f) format6 ->\n ('a, 'b, 'c, 'd, 'e, 'f) format6 = \"%identity\"\n\nlet ( ^^ ) (Format (fmt1, str1)) (Format (fmt2, str2)) =\n Format (CamlinternalFormatBasics.concat_fmt fmt1 fmt2,\n str1 ^ \"%,\" ^ str2)\n\n(* Miscellaneous *)\n\nexternal sys_exit : int -> 'a = \"caml_sys_exit\"\n\nlet exit_function = CamlinternalAtomic.make flush_all\n\nlet rec at_exit f =\n let module Atomic = CamlinternalAtomic in\n (* MPR#7253, MPR#7796: make sure \"f\" is executed only once *)\n let f_yet_to_run = Atomic.make true in\n let old_exit = Atomic.get exit_function in\n let new_exit () =\n if Atomic.compare_and_set f_yet_to_run true false then f () ;\n old_exit ()\n in\n let success = Atomic.compare_and_set exit_function old_exit new_exit in\n if not success then at_exit f\n\nlet do_at_exit () = (CamlinternalAtomic.get exit_function) ()\n\nlet exit retcode =\n do_at_exit ();\n sys_exit retcode\n\nlet _ = register_named_value \"Pervasives.do_at_exit\" do_at_exit\n\nexternal major : unit -> unit = \"caml_gc_major\"\nexternal naked_pointers_checked : unit -> bool\n = \"caml_sys_const_naked_pointers_checked\"\nlet () = if naked_pointers_checked () then at_exit major\n\n(*MODULE_ALIASES*)\nmodule Arg = Arg\nmodule Array = Array\nmodule ArrayLabels = ArrayLabels\nmodule Atomic = Atomic\nmodule Bigarray = Bigarray\nmodule Bool = Bool\nmodule Buffer = Buffer\nmodule Bytes = Bytes\nmodule BytesLabels = BytesLabels\nmodule Callback = Callback\nmodule Char = Char\nmodule Complex = Complex\nmodule Digest = Digest\nmodule Either = Either\nmodule Ephemeron = Ephemeron\nmodule Filename = Filename\nmodule Float = Float\nmodule Format = Format\nmodule Fun = Fun\nmodule Gc = Gc\nmodule Genlex = Genlex\nmodule Hashtbl = Hashtbl\nmodule In_channel = In_channel\nmodule Int = Int\nmodule Int32 = Int32\nmodule Int64 = Int64\nmodule Lazy = Lazy\nmodule Lexing = Lexing\nmodule List = List\nmodule ListLabels = ListLabels\nmodule Map = Map\nmodule Marshal = Marshal\nmodule MoreLabels = MoreLabels\nmodule Nativeint = Nativeint\nmodule Obj = Obj\nmodule Oo = Oo\nmodule Option = Option\nmodule Out_channel = Out_channel\nmodule Parsing = Parsing\nmodule Pervasives = Pervasives\nmodule Printexc = Printexc\nmodule Printf = Printf\nmodule Queue = Queue\nmodule Random = Random\nmodule Result = Result\nmodule Scanf = Scanf\nmodule Seq = Seq\nmodule Set = Set\nmodule Stack = Stack\nmodule StdLabels = StdLabels\nmodule Stream = Stream\nmodule String = String\nmodule StringLabels = StringLabels\nmodule Sys = Sys\nmodule Uchar = Uchar\nmodule Unit = Unit\nmodule Weak = Weak\n","(** This module is the toplevel of the Base library; it's what you get when you write\n [open Base].\n\n\n The goal of Base is both to be a more complete standard library, with richer APIs,\n and to be more consistent in its design. For instance, in the standard library\n some things have modules and others don't; in Base, everything is a module.\n\n Base extends some modules and data structures from the standard library, like [Array],\n [Buffer], [Bytes], [Char], [Hashtbl], [Int32], [Int64], [Lazy], [List], [Map],\n [Nativeint], [Printf], [Random], [Set], [String], [Sys], and [Uchar]. One key\n difference is that Base doesn't use exceptions as much as the standard library and\n instead makes heavy use of the [Result] type, as in:\n\n {[ type ('a,'b) result = Ok of 'a | Error of 'b ]}\n\n Base also adds entirely new modules, most notably:\n\n - [Comparable], [Comparator], and [Comparisons] in lieu of polymorphic compare.\n - [Container], which provides a consistent interface across container-like data\n structures (arrays, lists, strings).\n - [Result], [Error], and [Or_error], supporting the or-error pattern.\n\n The recommended way to use Base is to build with [-open Base]. Files compiled this\n way will have the environment described in this file as their initial environment.\n*)\n\n(*_ We hide this from the web docs because the line wrapping is bad, making it\n pretty much inscrutable. *)\n(**/**)\n\n(* The intent is to shadow all of INRIA's standard library. Modules below would cause\n compilation errors without being removed from [Shadow_stdlib] before inclusion. *)\n\ninclude (\n Shadow_stdlib :\n module type of struct\n include Shadow_stdlib\n end\n (* Modules defined in Base *)\n with module Array := Shadow_stdlib.Array\n with module Atomic := Shadow_stdlib.Atomic\n with module Bool := Shadow_stdlib.Bool\n with module Buffer := Shadow_stdlib.Buffer\n with module Bytes := Shadow_stdlib.Bytes\n with module Char := Shadow_stdlib.Char\n with module Either := Shadow_stdlib.Either\n with module Float := Shadow_stdlib.Float\n with module Hashtbl := Shadow_stdlib.Hashtbl\n with module In_channel := Shadow_stdlib.In_channel\n with module Int := Shadow_stdlib.Int\n with module Int32 := Shadow_stdlib.Int32\n with module Int64 := Shadow_stdlib.Int64\n with module Lazy := Shadow_stdlib.Lazy\n with module List := Shadow_stdlib.List\n with module Map := Shadow_stdlib.Map\n with module Nativeint := Shadow_stdlib.Nativeint\n with module Option := Shadow_stdlib.Option\n with module Out_channel := Shadow_stdlib.Out_channel\n with module Printf := Shadow_stdlib.Printf\n with module Queue := Shadow_stdlib.Queue\n with module Random := Shadow_stdlib.Random\n with module Result := Shadow_stdlib.Result\n with module Set := Shadow_stdlib.Set\n with module Stack := Shadow_stdlib.Stack\n with module String := Shadow_stdlib.String\n with module Sys := Shadow_stdlib.Sys\n with module Uchar := Shadow_stdlib.Uchar\n with module Unit := Shadow_stdlib.Unit\n (* Support for generated lexers *)\n with module Lexing := Shadow_stdlib.Lexing\n with type ('a, 'b, 'c) format := ('a, 'b, 'c) format\n with type ('a, 'b, 'c, 'd) format4 := ('a, 'b, 'c, 'd) format4\n with type ('a, 'b, 'c, 'd, 'e, 'f) format6 := ('a, 'b, 'c, 'd, 'e, 'f) format6\n with type 'a ref := 'a ref) [@ocaml.warning \"-3\"]\n\n(**/**)\n\nopen! Import\nmodule Applicative = Applicative\nmodule Array = Array\nmodule Avltree = Avltree\nmodule Backtrace = Backtrace\nmodule Binary_search = Binary_search\nmodule Binary_searchable = Binary_searchable\nmodule Blit = Blit\nmodule Bool = Bool\nmodule Buffer = Buffer\nmodule Bytes = Bytes\nmodule Char = Char\nmodule Comparable = Comparable\nmodule Comparator = Comparator\nmodule Comparisons = Comparisons\nmodule Container = Container\nmodule Either = Either\nmodule Equal = Equal\nmodule Error = Error\nmodule Exn = Exn\nmodule Field = Field\nmodule Float = Float\nmodule Floatable = Floatable\nmodule Fn = Fn\nmodule Formatter = Formatter\nmodule Hash = Hash\nmodule Hash_set = Hash_set\nmodule Hashable = Hashable\nmodule Hasher = Hasher\nmodule Hashtbl = Hashtbl\nmodule Identifiable = Identifiable\nmodule Indexed_container = Indexed_container\nmodule Info = Info\nmodule Int = Int\nmodule Int_conversions = Int_conversions\nmodule Int32 = Int32\nmodule Int63 = Int63\nmodule Int64 = Int64\nmodule Intable = Intable\nmodule Int_math = Int_math\nmodule Invariant = Invariant\nmodule Lazy = Lazy\nmodule List = List\nmodule Map = Map\nmodule Maybe_bound = Maybe_bound\nmodule Monad = Monad\nmodule Nativeint = Nativeint\nmodule Nothing = Nothing\nmodule Option = Option\nmodule Option_array = Option_array\nmodule Or_error = Or_error\nmodule Ordered_collection_common = Ordered_collection_common\nmodule Ordering = Ordering\nmodule Poly = Poly\nmodule Polymorphic_compare = Poly [@@deprecated \"[since 2018-11] use [Poly] instead\"]\n\nmodule Popcount = Popcount\n[@@deprecated \"[since 2018-10] use [popcount] functions in the individual int modules\"]\n\nmodule Pretty_printer = Pretty_printer\nmodule Printf = Printf\nmodule Linked_queue = Linked_queue\nmodule Queue = Queue\nmodule Random = Random\nmodule Ref = Ref\nmodule Result = Result\nmodule Sequence = Sequence\nmodule Set = Set\nmodule Sexpable = Sexpable\nmodule Sign = Sign\nmodule Sign_or_nan = Sign_or_nan\nmodule Source_code_position = Source_code_position\nmodule Stack = Stack\nmodule Staged = Staged\nmodule String = String\nmodule Stringable = Stringable\nmodule Sys = Sys\nmodule T = T\nmodule Type_equal = Type_equal\nmodule Uniform_array = Uniform_array\nmodule Unit = Unit\nmodule Uchar = Uchar\nmodule Validate = Validate\nmodule Variant = Variant\nmodule With_return = With_return\nmodule Word_size = Word_size\n\n(* Avoid a level of indirection for uses of the signatures defined in [T]. *)\ninclude T\n\n(* This is a hack so that odoc creates better documentation. *)\nmodule Sexp = struct\n include Sexp_with_comparable (** @inline *)\nend\n\n(**/**)\n\nmodule Exported_for_specific_uses = struct\n module Fieldslib = Fieldslib\n module Ppx_hash_lib = Ppx_hash_lib\n module Sexplib = Sexplib\n module Variantslib = Variantslib\n module Ppx_compare_lib = Ppx_compare_lib\n module Ppx_sexp_conv_lib = Ppx_sexp_conv_lib\n\n let am_testing = am_testing\nend\n\n(**/**)\n\nmodule Export = struct\n include Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.Builtin\n\n (* [deriving hash] is missing for [array] and [ref] since these types are mutable. *)\n type 'a array = 'a Array.t [@@deriving_inline compare, equal, sexp, sexp_grammar]\n\n let compare_array : 'a. ('a -> 'a -> int) -> 'a array -> 'a array -> int =\n Array.compare\n ;;\n\n let equal_array : 'a. ('a -> 'a -> bool) -> 'a array -> 'a array -> bool = Array.equal\n\n let array_of_sexp :\n 'a. (Ppx_sexp_conv_lib.Sexp.t -> 'a) -> Ppx_sexp_conv_lib.Sexp.t -> 'a array\n =\n Array.t_of_sexp\n ;;\n\n let sexp_of_array :\n 'a. ('a -> Ppx_sexp_conv_lib.Sexp.t) -> 'a array -> Ppx_sexp_conv_lib.Sexp.t\n =\n Array.sexp_of_t\n ;;\n\n let (array_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group) =\n { implicit_vars = [ \"Array.t\" ]\n ; ggid = \"r\\177A\\255~\\129%\\178\\226\\196g\\165\\t\\232\\204\\001\"\n ; types =\n [ \"array\", Explicit_bind ([ \"a\" ], Apply (Implicit_var 0, [ Explicit_var 0 ])) ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ Array.t_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"base.ml.Export\"\n }\n in\n let (array_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"array\", _the_group)\n in\n array_sexp_grammar\n ;;\n\n [@@@end]\n\n type bool = Bool.t [@@deriving_inline compare, equal, hash, sexp, sexp_grammar]\n\n let compare_bool = (Bool.compare : bool -> bool -> int)\n let equal_bool = (Bool.equal : bool -> bool -> bool)\n\n let (hash_fold_bool :\n Ppx_hash_lib.Std.Hash.state -> bool -> Ppx_hash_lib.Std.Hash.state)\n =\n Bool.hash_fold_t\n\n and (hash_bool : bool -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func = Bool.hash in\n fun x -> func x\n ;;\n\n let bool_of_sexp = (Bool.t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> bool)\n let sexp_of_bool = (Bool.sexp_of_t : bool -> Ppx_sexp_conv_lib.Sexp.t)\n\n let (bool_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group) =\n { implicit_vars = [ \"Bool.t\" ]\n ; ggid = \"{\\171\\239\\166\\219\\128\\005\\201\\192$\\149\\202\\251?\\186\\164\"\n ; types = [ \"bool\", Implicit_var 0 ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ Bool.t_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"base.ml.Export\"\n }\n in\n let (bool_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"bool\", _the_group)\n in\n bool_sexp_grammar\n ;;\n\n [@@@end]\n\n type char = Char.t [@@deriving_inline compare, equal, hash, sexp, sexp_grammar]\n\n let compare_char = (Char.compare : char -> char -> int)\n let equal_char = (Char.equal : char -> char -> bool)\n\n let (hash_fold_char :\n Ppx_hash_lib.Std.Hash.state -> char -> Ppx_hash_lib.Std.Hash.state)\n =\n Char.hash_fold_t\n\n and (hash_char : char -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func = Char.hash in\n fun x -> func x\n ;;\n\n let char_of_sexp = (Char.t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> char)\n let sexp_of_char = (Char.sexp_of_t : char -> Ppx_sexp_conv_lib.Sexp.t)\n\n let (char_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group) =\n { implicit_vars = [ \"Char.t\" ]\n ; ggid = \"H\\140\\243\\204Y\\222\\191d\\000@\\024Md\\028\\147>\"\n ; types = [ \"char\", Implicit_var 0 ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ Char.t_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"base.ml.Export\"\n }\n in\n let (char_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"char\", _the_group)\n in\n char_sexp_grammar\n ;;\n\n [@@@end]\n\n type exn = Exn.t [@@deriving_inline sexp_of]\n\n let sexp_of_exn = (Exn.sexp_of_t : exn -> Ppx_sexp_conv_lib.Sexp.t)\n\n [@@@end]\n\n type float = Float.t [@@deriving_inline compare, equal, hash, sexp, sexp_grammar]\n\n let compare_float = (Float.compare : float -> float -> int)\n let equal_float = (Float.equal : float -> float -> bool)\n\n let (hash_fold_float :\n Ppx_hash_lib.Std.Hash.state -> float -> Ppx_hash_lib.Std.Hash.state)\n =\n Float.hash_fold_t\n\n and (hash_float : float -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func = Float.hash in\n fun x -> func x\n ;;\n\n let float_of_sexp = (Float.t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> float)\n let sexp_of_float = (Float.sexp_of_t : float -> Ppx_sexp_conv_lib.Sexp.t)\n\n let (float_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group) =\n { implicit_vars = [ \"Float.t\" ]\n ; ggid = \"\\190E\\020\\242\\249\\135C\\240+\\214\\226\\143Ip\\217\\223\"\n ; types = [ \"float\", Implicit_var 0 ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ Float.t_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"base.ml.Export\"\n }\n in\n let (float_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"float\", _the_group)\n in\n float_sexp_grammar\n ;;\n\n [@@@end]\n\n type int = Int.t [@@deriving_inline compare, equal, hash, sexp, sexp_grammar]\n\n let compare_int = (Int.compare : int -> int -> int)\n let equal_int = (Int.equal : int -> int -> bool)\n\n let (hash_fold_int : Ppx_hash_lib.Std.Hash.state -> int -> Ppx_hash_lib.Std.Hash.state)\n =\n Int.hash_fold_t\n\n and (hash_int : int -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func = Int.hash in\n fun x -> func x\n ;;\n\n let int_of_sexp = (Int.t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> int)\n let sexp_of_int = (Int.sexp_of_t : int -> Ppx_sexp_conv_lib.Sexp.t)\n\n let (int_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group) =\n { implicit_vars = [ \"Int.t\" ]\n ; ggid = \"\\159\\159\\197^\\165]\\236\\165\\229\\165R8\\169\\225H\\020\"\n ; types = [ \"int\", Implicit_var 0 ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ Int.t_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"base.ml.Export\"\n }\n in\n let (int_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"int\", _the_group)\n in\n int_sexp_grammar\n ;;\n\n [@@@end]\n\n type int32 = Int32.t [@@deriving_inline compare, equal, hash, sexp, sexp_grammar]\n\n let compare_int32 = (Int32.compare : int32 -> int32 -> int)\n let equal_int32 = (Int32.equal : int32 -> int32 -> bool)\n\n let (hash_fold_int32 :\n Ppx_hash_lib.Std.Hash.state -> int32 -> Ppx_hash_lib.Std.Hash.state)\n =\n Int32.hash_fold_t\n\n and (hash_int32 : int32 -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func = Int32.hash in\n fun x -> func x\n ;;\n\n let int32_of_sexp = (Int32.t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> int32)\n let sexp_of_int32 = (Int32.sexp_of_t : int32 -> Ppx_sexp_conv_lib.Sexp.t)\n\n let (int32_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group) =\n { implicit_vars = [ \"Int32.t\" ]\n ; ggid = \"9\\153\\000*L5O+l\\018\\179b\\198\\248\\026\\177\"\n ; types = [ \"int32\", Implicit_var 0 ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ Int32.t_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"base.ml.Export\"\n }\n in\n let (int32_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"int32\", _the_group)\n in\n int32_sexp_grammar\n ;;\n\n [@@@end]\n\n type int64 = Int64.t [@@deriving_inline compare, equal, hash, sexp, sexp_grammar]\n\n let compare_int64 = (Int64.compare : int64 -> int64 -> int)\n let equal_int64 = (Int64.equal : int64 -> int64 -> bool)\n\n let (hash_fold_int64 :\n Ppx_hash_lib.Std.Hash.state -> int64 -> Ppx_hash_lib.Std.Hash.state)\n =\n Int64.hash_fold_t\n\n and (hash_int64 : int64 -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func = Int64.hash in\n fun x -> func x\n ;;\n\n let int64_of_sexp = (Int64.t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> int64)\n let sexp_of_int64 = (Int64.sexp_of_t : int64 -> Ppx_sexp_conv_lib.Sexp.t)\n\n let (int64_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group) =\n { implicit_vars = [ \"Int64.t\" ]\n ; ggid = \"r\\153\\022\\135\\131L\\155\\236\\235CKa\\197o\\248^\"\n ; types = [ \"int64\", Implicit_var 0 ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ Int64.t_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"base.ml.Export\"\n }\n in\n let (int64_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"int64\", _the_group)\n in\n int64_sexp_grammar\n ;;\n\n [@@@end]\n\n type 'a list = 'a List.t [@@deriving_inline compare, equal, hash, sexp, sexp_grammar]\n\n let compare_list : 'a. ('a -> 'a -> int) -> 'a list -> 'a list -> int = List.compare\n let equal_list : 'a. ('a -> 'a -> bool) -> 'a list -> 'a list -> bool = List.equal\n\n let hash_fold_list :\n 'a. (Ppx_hash_lib.Std.Hash.state -> 'a -> Ppx_hash_lib.Std.Hash.state)\n -> Ppx_hash_lib.Std.Hash.state -> 'a list -> Ppx_hash_lib.Std.Hash.state\n =\n List.hash_fold_t\n ;;\n\n let list_of_sexp :\n 'a. (Ppx_sexp_conv_lib.Sexp.t -> 'a) -> Ppx_sexp_conv_lib.Sexp.t -> 'a list\n =\n List.t_of_sexp\n ;;\n\n let sexp_of_list :\n 'a. ('a -> Ppx_sexp_conv_lib.Sexp.t) -> 'a list -> Ppx_sexp_conv_lib.Sexp.t\n =\n List.sexp_of_t\n ;;\n\n let (list_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group) =\n { implicit_vars = [ \"List.t\" ]\n ; ggid = \"\\144\\022 nativeint -> int)\n let equal_nativeint = (Nativeint.equal : nativeint -> nativeint -> bool)\n\n let (hash_fold_nativeint :\n Ppx_hash_lib.Std.Hash.state -> nativeint -> Ppx_hash_lib.Std.Hash.state)\n =\n Nativeint.hash_fold_t\n\n and (hash_nativeint : nativeint -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func = Nativeint.hash in\n fun x -> func x\n ;;\n\n let nativeint_of_sexp = (Nativeint.t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> nativeint)\n let sexp_of_nativeint = (Nativeint.sexp_of_t : nativeint -> Ppx_sexp_conv_lib.Sexp.t)\n\n let (nativeint_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group) =\n { implicit_vars = [ \"Nativeint.t\" ]\n ; ggid = \"\\019\\184AE\\023\\\\->1fcm\\002\\254\\196\\129\"\n ; types = [ \"nativeint\", Implicit_var 0 ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ Nativeint.t_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"base.ml.Export\"\n }\n in\n let (nativeint_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"nativeint\", _the_group)\n in\n nativeint_sexp_grammar\n ;;\n\n [@@@end]\n\n type 'a option = 'a Option.t\n [@@deriving_inline compare, equal, hash, sexp, sexp_grammar]\n\n let compare_option : 'a. ('a -> 'a -> int) -> 'a option -> 'a option -> int =\n Option.compare\n ;;\n\n let equal_option : 'a. ('a -> 'a -> bool) -> 'a option -> 'a option -> bool =\n Option.equal\n ;;\n\n let hash_fold_option :\n 'a. (Ppx_hash_lib.Std.Hash.state -> 'a -> Ppx_hash_lib.Std.Hash.state)\n -> Ppx_hash_lib.Std.Hash.state -> 'a option -> Ppx_hash_lib.Std.Hash.state\n =\n Option.hash_fold_t\n ;;\n\n let option_of_sexp :\n 'a. (Ppx_sexp_conv_lib.Sexp.t -> 'a) -> Ppx_sexp_conv_lib.Sexp.t -> 'a option\n =\n Option.t_of_sexp\n ;;\n\n let sexp_of_option :\n 'a. ('a -> Ppx_sexp_conv_lib.Sexp.t) -> 'a option -> Ppx_sexp_conv_lib.Sexp.t\n =\n Option.sexp_of_t\n ;;\n\n let (option_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group) =\n { implicit_vars = [ \"Option.t\" ]\n ; ggid = \"\\242@\\255j`*d\\203\\161\\182\\021\\175\\236\\146x\\217\"\n ; types =\n [ \"option\", Explicit_bind ([ \"a\" ], Apply (Implicit_var 0, [ Explicit_var 0 ]))\n ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ Option.t_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"base.ml.Export\"\n }\n in\n let (option_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"option\", _the_group)\n in\n option_sexp_grammar\n ;;\n\n [@@@end]\n\n type 'a ref = 'a Ref.t [@@deriving_inline compare, equal, sexp, sexp_grammar]\n\n let compare_ref : 'a. ('a -> 'a -> int) -> 'a ref -> 'a ref -> int = Ref.compare\n let equal_ref : 'a. ('a -> 'a -> bool) -> 'a ref -> 'a ref -> bool = Ref.equal\n\n let ref_of_sexp :\n 'a. (Ppx_sexp_conv_lib.Sexp.t -> 'a) -> Ppx_sexp_conv_lib.Sexp.t -> 'a ref\n =\n Ref.t_of_sexp\n ;;\n\n let sexp_of_ref :\n 'a. ('a -> Ppx_sexp_conv_lib.Sexp.t) -> 'a ref -> Ppx_sexp_conv_lib.Sexp.t\n =\n Ref.sexp_of_t\n ;;\n\n let (ref_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group) =\n { implicit_vars = [ \"Ref.t\" ]\n ; ggid = \"\\185\\246\\012[\\001\\197\\230\\192y=\\b\\199\\141\\248\\020\\012\"\n ; types =\n [ \"ref\", Explicit_bind ([ \"a\" ], Apply (Implicit_var 0, [ Explicit_var 0 ])) ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ Ref.t_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"base.ml.Export\"\n }\n in\n let (ref_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"ref\", _the_group)\n in\n ref_sexp_grammar\n ;;\n\n [@@@end]\n\n type string = String.t [@@deriving_inline compare, equal, hash, sexp, sexp_grammar]\n\n let compare_string = (String.compare : string -> string -> int)\n let equal_string = (String.equal : string -> string -> bool)\n\n let (hash_fold_string :\n Ppx_hash_lib.Std.Hash.state -> string -> Ppx_hash_lib.Std.Hash.state)\n =\n String.hash_fold_t\n\n and (hash_string : string -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func = String.hash in\n fun x -> func x\n ;;\n\n let string_of_sexp = (String.t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> string)\n let sexp_of_string = (String.sexp_of_t : string -> Ppx_sexp_conv_lib.Sexp.t)\n\n let (string_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group) =\n { implicit_vars = [ \"String.t\" ]\n ; ggid = \"\\141\\195]\\143\\139/M\\t\\159\\t\\152\\214g\\198\\023\\176\"\n ; types = [ \"string\", Implicit_var 0 ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ String.t_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"base.ml.Export\"\n }\n in\n let (string_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"string\", _the_group)\n in\n string_sexp_grammar\n ;;\n\n [@@@end]\n\n type bytes = Bytes.t [@@deriving_inline compare, equal, sexp, sexp_grammar]\n\n let compare_bytes = (Bytes.compare : bytes -> bytes -> int)\n let equal_bytes = (Bytes.equal : bytes -> bytes -> bool)\n let bytes_of_sexp = (Bytes.t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> bytes)\n let sexp_of_bytes = (Bytes.sexp_of_t : bytes -> Ppx_sexp_conv_lib.Sexp.t)\n\n let (bytes_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group) =\n { implicit_vars = [ \"Bytes.t\" ]\n ; ggid = \"\\015\\153L1\\012\\241\\015\\252\\150\\000\\191\\127Jb#3\"\n ; types = [ \"bytes\", Implicit_var 0 ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ Bytes.t_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"base.ml.Export\"\n }\n in\n let (bytes_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"bytes\", _the_group)\n in\n bytes_sexp_grammar\n ;;\n\n [@@@end]\n\n type unit = Unit.t [@@deriving_inline compare, equal, hash, sexp, sexp_grammar]\n\n let compare_unit = (Unit.compare : unit -> unit -> int)\n let equal_unit = (Unit.equal : unit -> unit -> bool)\n\n let (hash_fold_unit :\n Ppx_hash_lib.Std.Hash.state -> unit -> Ppx_hash_lib.Std.Hash.state)\n =\n Unit.hash_fold_t\n\n and (hash_unit : unit -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func = Unit.hash in\n fun x -> func x\n ;;\n\n let unit_of_sexp = (Unit.t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> unit)\n let sexp_of_unit = (Unit.sexp_of_t : unit -> Ppx_sexp_conv_lib.Sexp.t)\n\n let (unit_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group) =\n { implicit_vars = [ \"Unit.t\" ]\n ; ggid = \"=\\005 \\134\\187\\\"64\\197S\\19256,\\031l\"\n ; types = [ \"unit\", Implicit_var 0 ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ Unit.t_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"base.ml.Export\"\n }\n in\n let (unit_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"unit\", _the_group)\n in\n unit_sexp_grammar\n ;;\n\n [@@@end]\n\n (** Format stuff *)\n\n type nonrec ('a, 'b, 'c) format = ('a, 'b, 'c) format\n type nonrec ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'd) format4\n type nonrec ('a, 'b, 'c, 'd, 'e, 'f) format6 = ('a, 'b, 'c, 'd, 'e, 'f) format6\n\n (** {2 Sexp}\n\n Exporting the ad-hoc types that are recognized by [ppx_sexp_*] converters.\n [sexp_array], [sexp_list], and [sexp_option] allow a record field to be absent when\n converting from a sexp, and if absent, the field will take a default value of the\n appropriate type:\n\n {v\n sexp_array [||]\n sexp_bool false\n sexp_list []\n sexp_option None\n v}\n\n [sexp_opaque] causes the conversion to sexp to produce the atom [].\n\n For more documentation, see sexplib/README.md. *)\n\n type 'a sexp_array = 'a array\n [@@deprecated \"[since 2019-03] use [@sexp.array] instead\"]\n\n type 'a sexp_list = 'a list [@@deprecated \"[since 2019-03] use [@sexp.list] instead\"]\n type 'a sexp_opaque = 'a [@@deprecated \"[since 2019-03] use [@sexp.opaque] instead\"]\n\n type 'a sexp_option = 'a option\n [@@deprecated \"[since 2019-03] use [@sexp.option] instead\"]\n\n (** List operators *)\n\n include List.Infix\n\n (** Int operators and comparisons *)\n\n include Int.O\n include Int_replace_polymorphic_compare\n\n (** Float operators *)\n\n include Float.O_dot\n\n (* This is declared as an external to be optimized away in more contexts. *)\n\n (** Reverse application operator. [x |> g |> f] is equivalent to [f (g (x))]. *)\n external ( |> ) : 'a -> ('a -> 'b) -> 'b = \"%revapply\"\n\n (** Application operator. [g @@ f @@ x] is equivalent to [g (f (x))]. *)\n external ( @@ ) : ('a -> 'b) -> 'a -> 'b = \"%apply\"\n\n (** Boolean operations *)\n\n (* These need to be declared as an external to get the lazy behavior *)\n external ( && ) : bool -> bool -> bool = \"%sequand\"\n external ( || ) : bool -> bool -> bool = \"%sequor\"\n external not : bool -> bool = \"%boolnot\"\n\n (* This must be declared as an external for the warnings to work properly. *)\n external ignore : _ -> unit = \"%ignore\"\n\n (** Common string operations *)\n let ( ^ ) = String.( ^ )\n\n (** Reference operations *)\n\n (* Declared as an externals so that the compiler skips the caml_modify when possible and\n to keep reference unboxing working *)\n external ( ! ) : 'a ref -> 'a = \"%field0\"\n external ref : 'a -> 'a ref = \"%makemutable\"\n external ( := ) : 'a ref -> 'a -> unit = \"%setfield0\"\n\n (** Pair operations *)\n\n let fst = fst\n let snd = snd\n\n (** Exceptions stuff *)\n\n (* Declared as an external so that the compiler may rewrite '%raise' as '%reraise'. *)\n external raise : exn -> _ = \"%raise\"\n\n let failwith = failwith\n let invalid_arg = invalid_arg\n let raise_s = Error.raise_s\n\n (** Misc *)\n\n let phys_equal = phys_equal\n\n external force : 'a Lazy.t -> 'a = \"%lazy_force\"\nend\n\ninclude Export\n\ninclude Container_intf.Export (** @inline *)\n\nexception Not_found_s = Not_found_s\n\n(* We perform these side effects here because we want them to run for any code that uses\n [Base]. If this were in another module in [Base] that was not used in some program,\n then the side effects might not be run in that program. This will run as long as the\n program refers to at least one value directly in [Base]; referring to values in\n [Base.Bool], for example, is not sufficient. *)\nlet () = Backtrace.initialize_module ()\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(** The OCaml Standard library.\n\n This module is automatically opened at the beginning of each\n compilation. All components of this module can therefore be\n referred by their short name, without prefixing them by [Stdlib].\n\n It particular, it provides the basic operations over the built-in\n types (numbers, booleans, byte sequences, strings, exceptions,\n references, lists, arrays, input-output channels, ...) and the\n {{!modules}standard library modules}.\n*)\n\n(** {1 Exceptions} *)\n\nexternal raise : exn -> 'a = \"%raise\"\n(** Raise the given exception value *)\n\nexternal raise_notrace : exn -> 'a = \"%raise_notrace\"\n(** A faster version [raise] which does not record the backtrace.\n @since 4.02.0\n*)\n\nval invalid_arg : string -> 'a\n(** Raise exception [Invalid_argument] with the given string. *)\n\nval failwith : string -> 'a\n(** Raise exception [Failure] with the given string. *)\n\nexception Exit\n(** The [Exit] exception is not raised by any library function. It is\n provided for use in your programs. *)\n\nexception Match_failure of (string * int * int)\n [@ocaml.warn_on_literal_pattern]\n(** Exception raised when none of the cases of a pattern-matching\n apply. The arguments are the location of the match keyword in the\n source code (file name, line number, column number). *)\n\nexception Assert_failure of (string * int * int)\n [@ocaml.warn_on_literal_pattern]\n(** Exception raised when an assertion fails. The arguments are the\n location of the assert keyword in the source code (file name, line\n number, column number). *)\n\nexception Invalid_argument of string\n [@ocaml.warn_on_literal_pattern]\n(** Exception raised by library functions to signal that the given\n arguments do not make sense. The string gives some information to\n the programmer. As a general rule, this exception should not be\n caught, it denotes a programming error and the code should be\n modified not to trigger it. *)\n\nexception Failure of string\n [@ocaml.warn_on_literal_pattern]\n(** Exception raised by library functions to signal that they are\n undefined on the given arguments. The string is meant to give some\n information to the programmer; you must not pattern match on the\n string literal because it may change in future versions (use\n Failure _ instead). *)\n\nexception Not_found\n(** Exception raised by search functions when the desired object could\n not be found. *)\n\nexception Out_of_memory\n(** Exception raised by the garbage collector when there is\n insufficient memory to complete the computation. (Not reliable for\n allocations on the minor heap.) *)\n\nexception Stack_overflow\n(** Exception raised by the bytecode interpreter when the evaluation\n stack reaches its maximal size. This often indicates infinite or\n excessively deep recursion in the user's program.\n\n Before 4.10, it was not fully implemented by the native-code\n compiler. *)\n\nexception Sys_error of string\n [@ocaml.warn_on_literal_pattern]\n(** Exception raised by the input/output functions to report an\n operating system error. The string is meant to give some\n information to the programmer; you must not pattern match on the\n string literal because it may change in future versions (use\n Sys_error _ instead). *)\n\nexception End_of_file\n(** Exception raised by input functions to signal that the end of file\n has been reached. *)\n\nexception Division_by_zero\n(** Exception raised by integer division and remainder operations when\n their second argument is zero. *)\n\nexception Sys_blocked_io\n(** A special case of Sys_error raised when no I/O is possible on a\n non-blocking I/O channel. *)\n\nexception Undefined_recursive_module of (string * int * int)\n [@ocaml.warn_on_literal_pattern]\n(** Exception raised when an ill-founded recursive module definition\n is evaluated. The arguments are the location of the definition in\n the source code (file name, line number, column number). *)\n\n(** {1 Comparisons} *)\n\nexternal ( = ) : 'a -> 'a -> bool = \"%equal\"\n(** [e1 = e2] tests for structural equality of [e1] and [e2].\n Mutable structures (e.g. references and arrays) are equal\n if and only if their current contents are structurally equal,\n even if the two mutable objects are not the same physical object.\n Equality between functional values raises [Invalid_argument].\n Equality between cyclic data structures may not terminate.\n Left-associative operator, see {!Ocaml_operators} for more information. *)\n\nexternal ( <> ) : 'a -> 'a -> bool = \"%notequal\"\n(** Negation of {!Stdlib.( = )}.\n Left-associative operator, see {!Ocaml_operators} for more information.\n*)\n\nexternal ( < ) : 'a -> 'a -> bool = \"%lessthan\"\n(** See {!Stdlib.( >= )}.\n Left-associative operator, see {!Ocaml_operators} for more information.\n*)\n\nexternal ( > ) : 'a -> 'a -> bool = \"%greaterthan\"\n(** See {!Stdlib.( >= )}.\n Left-associative operator, see {!Ocaml_operators} for more information.\n*)\n\nexternal ( <= ) : 'a -> 'a -> bool = \"%lessequal\"\n(** See {!Stdlib.( >= )}.\n Left-associative operator, see {!Ocaml_operators} for more information.\n*)\n\nexternal ( >= ) : 'a -> 'a -> bool = \"%greaterequal\"\n(** Structural ordering functions. These functions coincide with\n the usual orderings over integers, characters, strings, byte sequences\n and floating-point numbers, and extend them to a\n total ordering over all types.\n The ordering is compatible with [( = )]. As in the case\n of [( = )], mutable structures are compared by contents.\n Comparison between functional values raises [Invalid_argument].\n Comparison between cyclic structures may not terminate.\n Left-associative operator, see {!Ocaml_operators} for more information.\n*)\n\nexternal compare : 'a -> 'a -> int = \"%compare\"\n(** [compare x y] returns [0] if [x] is equal to [y],\n a negative integer if [x] is less than [y], and a positive integer\n if [x] is greater than [y]. The ordering implemented by [compare]\n is compatible with the comparison predicates [=], [<] and [>]\n defined above, with one difference on the treatment of the float value\n {!Stdlib.nan}. Namely, the comparison predicates treat [nan]\n as different from any other float value, including itself;\n while [compare] treats [nan] as equal to itself and less than any\n other float value. This treatment of [nan] ensures that [compare]\n defines a total ordering relation.\n\n [compare] applied to functional values may raise [Invalid_argument].\n [compare] applied to cyclic structures may not terminate.\n\n The [compare] function can be used as the comparison function\n required by the {!Set.Make} and {!Map.Make} functors, as well as\n the {!List.sort} and {!Array.sort} functions. *)\n\nval min : 'a -> 'a -> 'a\n(** Return the smaller of the two arguments.\n The result is unspecified if one of the arguments contains\n the float value [nan]. *)\n\nval max : 'a -> 'a -> 'a\n(** Return the greater of the two arguments.\n The result is unspecified if one of the arguments contains\n the float value [nan]. *)\n\nexternal ( == ) : 'a -> 'a -> bool = \"%eq\"\n(** [e1 == e2] tests for physical equality of [e1] and [e2].\n On mutable types such as references, arrays, byte sequences, records with\n mutable fields and objects with mutable instance variables,\n [e1 == e2] is true if and only if physical modification of [e1]\n also affects [e2].\n On non-mutable types, the behavior of [( == )] is\n implementation-dependent; however, it is guaranteed that\n [e1 == e2] implies [compare e1 e2 = 0].\n Left-associative operator, see {!Ocaml_operators} for more information.\n*)\n\nexternal ( != ) : 'a -> 'a -> bool = \"%noteq\"\n(** Negation of {!Stdlib.( == )}.\n Left-associative operator, see {!Ocaml_operators} for more information.\n*)\n\n\n(** {1 Boolean operations} *)\n\nexternal not : bool -> bool = \"%boolnot\"\n(** The boolean negation. *)\n\nexternal ( && ) : bool -> bool -> bool = \"%sequand\"\n(** The boolean 'and'. Evaluation is sequential, left-to-right:\n in [e1 && e2], [e1] is evaluated first, and if it returns [false],\n [e2] is not evaluated at all.\n Right-associative operator, see {!Ocaml_operators} for more information.\n*)\n\nexternal ( & ) : bool -> bool -> bool = \"%sequand\"\n [@@ocaml.deprecated \"Use (&&) instead.\"]\n(** @deprecated {!Stdlib.( && )} should be used instead.\n Right-associative operator, see {!Ocaml_operators} for more information.\n*)\n\nexternal ( || ) : bool -> bool -> bool = \"%sequor\"\n(** The boolean 'or'. Evaluation is sequential, left-to-right:\n in [e1 || e2], [e1] is evaluated first, and if it returns [true],\n [e2] is not evaluated at all.\n Right-associative operator, see {!Ocaml_operators} for more information.\n*)\n\nexternal ( or ) : bool -> bool -> bool = \"%sequor\"\n [@@ocaml.deprecated \"Use (||) instead.\"]\n(** @deprecated {!Stdlib.( || )} should be used instead.\n Right-associative operator, see {!Ocaml_operators} for more information.\n*)\n\n(** {1 Debugging} *)\n\nexternal __LOC__ : string = \"%loc_LOC\"\n(** [__LOC__] returns the location at which this expression appears in\n the file currently being parsed by the compiler, with the standard\n error format of OCaml: \"File %S, line %d, characters %d-%d\".\n @since 4.02.0\n*)\n\nexternal __FILE__ : string = \"%loc_FILE\"\n(** [__FILE__] returns the name of the file currently being\n parsed by the compiler.\n @since 4.02.0\n*)\n\nexternal __LINE__ : int = \"%loc_LINE\"\n(** [__LINE__] returns the line number at which this expression\n appears in the file currently being parsed by the compiler.\n @since 4.02.0\n*)\n\nexternal __MODULE__ : string = \"%loc_MODULE\"\n(** [__MODULE__] returns the module name of the file being\n parsed by the compiler.\n @since 4.02.0\n*)\n\nexternal __POS__ : string * int * int * int = \"%loc_POS\"\n(** [__POS__] returns a tuple [(file,lnum,cnum,enum)], corresponding\n to the location at which this expression appears in the file\n currently being parsed by the compiler. [file] is the current\n filename, [lnum] the line number, [cnum] the character position in\n the line and [enum] the last character position in the line.\n @since 4.02.0\n *)\n\nexternal __FUNCTION__ : string = \"%loc_FUNCTION\"\n(** [__FUNCTION__] returns the name of the current function or method, including\n any enclosing modules or classes.\n\n @since 4.12.0 *)\n\nexternal __LOC_OF__ : 'a -> string * 'a = \"%loc_LOC\"\n(** [__LOC_OF__ expr] returns a pair [(loc, expr)] where [loc] is the\n location of [expr] in the file currently being parsed by the\n compiler, with the standard error format of OCaml: \"File %S, line\n %d, characters %d-%d\".\n @since 4.02.0\n*)\n\nexternal __LINE_OF__ : 'a -> int * 'a = \"%loc_LINE\"\n(** [__LINE_OF__ expr] returns a pair [(line, expr)], where [line] is the\n line number at which the expression [expr] appears in the file\n currently being parsed by the compiler.\n @since 4.02.0\n *)\n\nexternal __POS_OF__ : 'a -> (string * int * int * int) * 'a = \"%loc_POS\"\n(** [__POS_OF__ expr] returns a pair [(loc,expr)], where [loc] is a\n tuple [(file,lnum,cnum,enum)] corresponding to the location at\n which the expression [expr] appears in the file currently being\n parsed by the compiler. [file] is the current filename, [lnum] the\n line number, [cnum] the character position in the line and [enum]\n the last character position in the line.\n @since 4.02.0\n *)\n\n(** {1 Composition operators} *)\n\nexternal ( |> ) : 'a -> ('a -> 'b) -> 'b = \"%revapply\"\n(** Reverse-application operator: [x |> f |> g] is exactly equivalent\n to [g (f (x))].\n Left-associative operator, see {!Ocaml_operators} for more information.\n @since 4.01\n*)\n\nexternal ( @@ ) : ('a -> 'b) -> 'a -> 'b = \"%apply\"\n(** Application operator: [g @@ f @@ x] is exactly equivalent to\n [g (f (x))].\n Right-associative operator, see {!Ocaml_operators} for more information.\n @since 4.01\n*)\n\n(** {1 Integer arithmetic} *)\n\n(** Integers are [Sys.int_size] bits wide.\n All operations are taken modulo 2{^[Sys.int_size]}.\n They do not fail on overflow. *)\n\nexternal ( ~- ) : int -> int = \"%negint\"\n(** Unary negation. You can also write [- e] instead of [~- e].\n Unary operator, see {!Ocaml_operators} for more information.\n*)\n\n\nexternal ( ~+ ) : int -> int = \"%identity\"\n(** Unary addition. You can also write [+ e] instead of [~+ e].\n Unary operator, see {!Ocaml_operators} for more information.\n @since 3.12.0\n*)\n\nexternal succ : int -> int = \"%succint\"\n(** [succ x] is [x + 1]. *)\n\nexternal pred : int -> int = \"%predint\"\n(** [pred x] is [x - 1]. *)\n\nexternal ( + ) : int -> int -> int = \"%addint\"\n(** Integer addition.\n Left-associative operator, see {!Ocaml_operators} for more information.\n*)\n\nexternal ( - ) : int -> int -> int = \"%subint\"\n(** Integer subtraction.\n Left-associative operator, , see {!Ocaml_operators} for more information.\n*)\n\nexternal ( * ) : int -> int -> int = \"%mulint\"\n(** Integer multiplication.\n Left-associative operator, see {!Ocaml_operators} for more information.\n*)\n\nexternal ( / ) : int -> int -> int = \"%divint\"\n(** Integer division.\n Integer division rounds the real quotient of its arguments towards zero.\n More precisely, if [x >= 0] and [y > 0], [x / y] is the greatest integer\n less than or equal to the real quotient of [x] by [y]. Moreover,\n [(- x) / y = x / (- y) = - (x / y)].\n Left-associative operator, see {!Ocaml_operators} for more information.\n\n @raise Division_by_zero if the second argument is 0.\n*)\n\nexternal ( mod ) : int -> int -> int = \"%modint\"\n(** Integer remainder. If [y] is not zero, the result\n of [x mod y] satisfies the following properties:\n [x = (x / y) * y + x mod y] and\n [abs(x mod y) <= abs(y) - 1].\n If [y = 0], [x mod y] raises [Division_by_zero].\n Note that [x mod y] is negative only if [x < 0].\n Left-associative operator, see {!Ocaml_operators} for more information.\n\n @raise Division_by_zero if [y] is zero.\n*)\n\nval abs : int -> int\n(** Return the absolute value of the argument. Note that this may be\n negative if the argument is [min_int]. *)\n\nval max_int : int\n(** The greatest representable integer. *)\n\nval min_int : int\n(** The smallest representable integer. *)\n\n\n(** {2 Bitwise operations} *)\n\nexternal ( land ) : int -> int -> int = \"%andint\"\n(** Bitwise logical and.\n Left-associative operator, see {!Ocaml_operators} for more information.\n*)\n\nexternal ( lor ) : int -> int -> int = \"%orint\"\n(** Bitwise logical or.\n Left-associative operator, see {!Ocaml_operators} for more information.\n*)\n\nexternal ( lxor ) : int -> int -> int = \"%xorint\"\n(** Bitwise logical exclusive or.\n Left-associative operator, see {!Ocaml_operators} for more information.\n*)\n\nval lnot : int -> int\n(** Bitwise logical negation. *)\n\nexternal ( lsl ) : int -> int -> int = \"%lslint\"\n(** [n lsl m] shifts [n] to the left by [m] bits.\n The result is unspecified if [m < 0] or [m > Sys.int_size].\n Right-associative operator, see {!Ocaml_operators} for more information.\n*)\n\nexternal ( lsr ) : int -> int -> int = \"%lsrint\"\n(** [n lsr m] shifts [n] to the right by [m] bits.\n This is a logical shift: zeroes are inserted regardless of\n the sign of [n].\n The result is unspecified if [m < 0] or [m > Sys.int_size].\n Right-associative operator, see {!Ocaml_operators} for more information.\n*)\n\nexternal ( asr ) : int -> int -> int = \"%asrint\"\n(** [n asr m] shifts [n] to the right by [m] bits.\n This is an arithmetic shift: the sign bit of [n] is replicated.\n The result is unspecified if [m < 0] or [m > Sys.int_size].\n Right-associative operator, see {!Ocaml_operators} for more information.\n*)\n\n(** {1 Floating-point arithmetic}\n\n OCaml's floating-point numbers follow the\n IEEE 754 standard, using double precision (64 bits) numbers.\n Floating-point operations never raise an exception on overflow,\n underflow, division by zero, etc. Instead, special IEEE numbers\n are returned as appropriate, such as [infinity] for [1.0 /. 0.0],\n [neg_infinity] for [-1.0 /. 0.0], and [nan] ('not a number')\n for [0.0 /. 0.0]. These special numbers then propagate through\n floating-point computations as expected: for instance,\n [1.0 /. infinity] is [0.0], basic arithmetic operations\n ([+.], [-.], [*.], [/.]) with [nan] as an argument return [nan], ...\n*)\n\nexternal ( ~-. ) : float -> float = \"%negfloat\"\n(** Unary negation. You can also write [-. e] instead of [~-. e].\n Unary operator, see {!Ocaml_operators} for more information.\n*)\n\nexternal ( ~+. ) : float -> float = \"%identity\"\n(** Unary addition. You can also write [+. e] instead of [~+. e].\n Unary operator, see {!Ocaml_operators} for more information.\n @since 3.12.0\n*)\n\nexternal ( +. ) : float -> float -> float = \"%addfloat\"\n(** Floating-point addition.\n Left-associative operator, see {!Ocaml_operators} for more information.\n*)\n\nexternal ( -. ) : float -> float -> float = \"%subfloat\"\n(** Floating-point subtraction.\n Left-associative operator, see {!Ocaml_operators} for more information.\n*)\n\nexternal ( *. ) : float -> float -> float = \"%mulfloat\"\n(** Floating-point multiplication.\n Left-associative operator, see {!Ocaml_operators} for more information.\n*)\n\nexternal ( /. ) : float -> float -> float = \"%divfloat\"\n(** Floating-point division.\n Left-associative operator, see {!Ocaml_operators} for more information.\n*)\n\nexternal ( ** ) : float -> float -> float = \"caml_power_float\" \"pow\"\n [@@unboxed] [@@noalloc]\n(** Exponentiation.\n Right-associative operator, see {!Ocaml_operators} for more information.\n*)\n\nexternal sqrt : float -> float = \"caml_sqrt_float\" \"sqrt\"\n [@@unboxed] [@@noalloc]\n(** Square root. *)\n\nexternal exp : float -> float = \"caml_exp_float\" \"exp\" [@@unboxed] [@@noalloc]\n(** Exponential. *)\n\nexternal log : float -> float = \"caml_log_float\" \"log\" [@@unboxed] [@@noalloc]\n(** Natural logarithm. *)\n\nexternal log10 : float -> float = \"caml_log10_float\" \"log10\"\n [@@unboxed] [@@noalloc]\n(** Base 10 logarithm. *)\n\nexternal expm1 : float -> float = \"caml_expm1_float\" \"caml_expm1\"\n [@@unboxed] [@@noalloc]\n(** [expm1 x] computes [exp x -. 1.0], giving numerically-accurate results\n even if [x] is close to [0.0].\n @since 3.12.0\n*)\n\nexternal log1p : float -> float = \"caml_log1p_float\" \"caml_log1p\"\n [@@unboxed] [@@noalloc]\n(** [log1p x] computes [log(1.0 +. x)] (natural logarithm),\n giving numerically-accurate results even if [x] is close to [0.0].\n @since 3.12.0\n*)\n\nexternal cos : float -> float = \"caml_cos_float\" \"cos\" [@@unboxed] [@@noalloc]\n(** Cosine. Argument is in radians. *)\n\nexternal sin : float -> float = \"caml_sin_float\" \"sin\" [@@unboxed] [@@noalloc]\n(** Sine. Argument is in radians. *)\n\nexternal tan : float -> float = \"caml_tan_float\" \"tan\" [@@unboxed] [@@noalloc]\n(** Tangent. Argument is in radians. *)\n\nexternal acos : float -> float = \"caml_acos_float\" \"acos\"\n [@@unboxed] [@@noalloc]\n(** Arc cosine. The argument must fall within the range [[-1.0, 1.0]].\n Result is in radians and is between [0.0] and [pi]. *)\n\nexternal asin : float -> float = \"caml_asin_float\" \"asin\"\n [@@unboxed] [@@noalloc]\n(** Arc sine. The argument must fall within the range [[-1.0, 1.0]].\n Result is in radians and is between [-pi/2] and [pi/2]. *)\n\nexternal atan : float -> float = \"caml_atan_float\" \"atan\"\n [@@unboxed] [@@noalloc]\n(** Arc tangent.\n Result is in radians and is between [-pi/2] and [pi/2]. *)\n\nexternal atan2 : float -> float -> float = \"caml_atan2_float\" \"atan2\"\n [@@unboxed] [@@noalloc]\n(** [atan2 y x] returns the arc tangent of [y /. x]. The signs of [x]\n and [y] are used to determine the quadrant of the result.\n Result is in radians and is between [-pi] and [pi]. *)\n\nexternal hypot : float -> float -> float = \"caml_hypot_float\" \"caml_hypot\"\n [@@unboxed] [@@noalloc]\n(** [hypot x y] returns [sqrt(x *. x + y *. y)], that is, the length\n of the hypotenuse of a right-angled triangle with sides of length\n [x] and [y], or, equivalently, the distance of the point [(x,y)]\n to origin. If one of [x] or [y] is infinite, returns [infinity]\n even if the other is [nan].\n @since 4.00.0 *)\n\nexternal cosh : float -> float = \"caml_cosh_float\" \"cosh\"\n [@@unboxed] [@@noalloc]\n(** Hyperbolic cosine. Argument is in radians. *)\n\nexternal sinh : float -> float = \"caml_sinh_float\" \"sinh\"\n [@@unboxed] [@@noalloc]\n(** Hyperbolic sine. Argument is in radians. *)\n\nexternal tanh : float -> float = \"caml_tanh_float\" \"tanh\"\n [@@unboxed] [@@noalloc]\n(** Hyperbolic tangent. Argument is in radians. *)\n\nexternal acosh : float -> float = \"caml_acosh_float\" \"caml_acosh\"\n [@@unboxed] [@@noalloc]\n(** Hyperbolic arc cosine. The argument must fall within the range\n [[1.0, inf]].\n Result is in radians and is between [0.0] and [inf].\n\n @since 4.13.0\n*)\n\nexternal asinh : float -> float = \"caml_asinh_float\" \"caml_asinh\"\n [@@unboxed] [@@noalloc]\n(** Hyperbolic arc sine. The argument and result range over the entire\n real line.\n Result is in radians.\n\n @since 4.13.0\n*)\n\nexternal atanh : float -> float = \"caml_atanh_float\" \"caml_atanh\"\n [@@unboxed] [@@noalloc]\n(** Hyperbolic arc tangent. The argument must fall within the range\n [[-1.0, 1.0]].\n Result is in radians and ranges over the entire real line.\n\n @since 4.13.0\n*)\n\nexternal ceil : float -> float = \"caml_ceil_float\" \"ceil\"\n [@@unboxed] [@@noalloc]\n(** Round above to an integer value.\n [ceil f] returns the least integer value greater than or equal to [f].\n The result is returned as a float. *)\n\nexternal floor : float -> float = \"caml_floor_float\" \"floor\"\n [@@unboxed] [@@noalloc]\n(** Round below to an integer value.\n [floor f] returns the greatest integer value less than or\n equal to [f].\n The result is returned as a float. *)\n\nexternal abs_float : float -> float = \"%absfloat\"\n(** [abs_float f] returns the absolute value of [f]. *)\n\nexternal copysign : float -> float -> float\n = \"caml_copysign_float\" \"caml_copysign\"\n [@@unboxed] [@@noalloc]\n(** [copysign x y] returns a float whose absolute value is that of [x]\n and whose sign is that of [y]. If [x] is [nan], returns [nan].\n If [y] is [nan], returns either [x] or [-. x], but it is not\n specified which.\n @since 4.00.0 *)\n\nexternal mod_float : float -> float -> float = \"caml_fmod_float\" \"fmod\"\n [@@unboxed] [@@noalloc]\n(** [mod_float a b] returns the remainder of [a] with respect to\n [b]. The returned value is [a -. n *. b], where [n]\n is the quotient [a /. b] rounded towards zero to an integer. *)\n\nexternal frexp : float -> float * int = \"caml_frexp_float\"\n(** [frexp f] returns the pair of the significant\n and the exponent of [f]. When [f] is zero, the\n significant [x] and the exponent [n] of [f] are equal to\n zero. When [f] is non-zero, they are defined by\n [f = x *. 2 ** n] and [0.5 <= x < 1.0]. *)\n\n\nexternal ldexp : (float [@unboxed]) -> (int [@untagged]) -> (float [@unboxed]) =\n \"caml_ldexp_float\" \"caml_ldexp_float_unboxed\" [@@noalloc]\n(** [ldexp x n] returns [x *. 2 ** n]. *)\n\nexternal modf : float -> float * float = \"caml_modf_float\"\n(** [modf f] returns the pair of the fractional and integral\n part of [f]. *)\n\nexternal float : int -> float = \"%floatofint\"\n(** Same as {!Stdlib.float_of_int}. *)\n\nexternal float_of_int : int -> float = \"%floatofint\"\n(** Convert an integer to floating-point. *)\n\nexternal truncate : float -> int = \"%intoffloat\"\n(** Same as {!Stdlib.int_of_float}. *)\n\nexternal int_of_float : float -> int = \"%intoffloat\"\n(** Truncate the given floating-point number to an integer.\n The result is unspecified if the argument is [nan] or falls outside the\n range of representable integers. *)\n\nval infinity : float\n(** Positive infinity. *)\n\nval neg_infinity : float\n(** Negative infinity. *)\n\nval nan : float\n(** A special floating-point value denoting the result of an\n undefined operation such as [0.0 /. 0.0]. Stands for\n 'not a number'. Any floating-point operation with [nan] as\n argument returns [nan] as result. As for floating-point comparisons,\n [=], [<], [<=], [>] and [>=] return [false] and [<>] returns [true]\n if one or both of their arguments is [nan]. *)\n\nval max_float : float\n(** The largest positive finite value of type [float]. *)\n\nval min_float : float\n(** The smallest positive, non-zero, non-denormalized value of type [float]. *)\n\nval epsilon_float : float\n(** The difference between [1.0] and the smallest exactly representable\n floating-point number greater than [1.0]. *)\n\ntype fpclass =\n FP_normal (** Normal number, none of the below *)\n | FP_subnormal (** Number very close to 0.0, has reduced precision *)\n | FP_zero (** Number is 0.0 or -0.0 *)\n | FP_infinite (** Number is positive or negative infinity *)\n | FP_nan (** Not a number: result of an undefined operation *)\n(** The five classes of floating-point numbers, as determined by\n the {!Stdlib.classify_float} function. *)\n\nexternal classify_float : (float [@unboxed]) -> fpclass =\n \"caml_classify_float\" \"caml_classify_float_unboxed\" [@@noalloc]\n(** Return the class of the given floating-point number:\n normal, subnormal, zero, infinite, or not a number. *)\n\n\n(** {1 String operations}\n\n More string operations are provided in module {!String}.\n*)\n\nval ( ^ ) : string -> string -> string\n(** String concatenation.\n Right-associative operator, see {!Ocaml_operators} for more information.\n\n @raise Invalid_argument if the result is longer then\n than {!Sys.max_string_length} bytes.\n*)\n\n(** {1 Character operations}\n\n More character operations are provided in module {!Char}.\n*)\n\nexternal int_of_char : char -> int = \"%identity\"\n(** Return the ASCII code of the argument. *)\n\nval char_of_int : int -> char\n(** Return the character with the given ASCII code.\n @raise Invalid_argument if the argument is\n outside the range 0--255. *)\n\n\n(** {1 Unit operations} *)\n\nexternal ignore : 'a -> unit = \"%ignore\"\n(** Discard the value of its argument and return [()].\n For instance, [ignore(f x)] discards the result of\n the side-effecting function [f]. It is equivalent to\n [f x; ()], except that the latter may generate a\n compiler warning; writing [ignore(f x)] instead\n avoids the warning. *)\n\n\n(** {1 String conversion functions} *)\n\nval string_of_bool : bool -> string\n(** Return the string representation of a boolean. As the returned values\n may be shared, the user should not modify them directly.\n*)\n\nval bool_of_string_opt: string -> bool option\n(** Convert the given string to a boolean.\n\n Return [None] if the string is not [\"true\"] or [\"false\"].\n @since 4.05\n*)\n\nval bool_of_string : string -> bool\n(** Same as {!Stdlib.bool_of_string_opt}, but raise\n [Invalid_argument \"bool_of_string\"] instead of returning [None]. *)\n\nval string_of_int : int -> string\n(** Return the string representation of an integer, in decimal. *)\n\nval int_of_string_opt: string -> int option\n(** Convert the given string to an integer.\n The string is read in decimal (by default, or if the string\n begins with [0u]), in hexadecimal (if it begins with [0x] or\n [0X]), in octal (if it begins with [0o] or [0O]), or in binary\n (if it begins with [0b] or [0B]).\n\n The [0u] prefix reads the input as an unsigned integer in the range\n [[0, 2*max_int+1]]. If the input exceeds {!max_int}\n it is converted to the signed integer\n [min_int + input - max_int - 1].\n\n The [_] (underscore) character can appear anywhere in the string\n and is ignored.\n\n Return [None] if the given string is not a valid representation of an\n integer, or if the integer represented exceeds the range of integers\n representable in type [int].\n @since 4.05\n*)\n\nexternal int_of_string : string -> int = \"caml_int_of_string\"\n(** Same as {!Stdlib.int_of_string_opt}, but raise\n [Failure \"int_of_string\"] instead of returning [None]. *)\n\nval string_of_float : float -> string\n(** Return the string representation of a floating-point number. *)\n\nval float_of_string_opt: string -> float option\n(** Convert the given string to a float. The string is read in decimal\n (by default) or in hexadecimal (marked by [0x] or [0X]).\n\n The format of decimal floating-point numbers is\n [ [-] dd.ddd (e|E) [+|-] dd ], where [d] stands for a decimal digit.\n\n The format of hexadecimal floating-point numbers is\n [ [-] 0(x|X) hh.hhh (p|P) [+|-] dd ], where [h] stands for an\n hexadecimal digit and [d] for a decimal digit.\n\n In both cases, at least one of the integer and fractional parts must be\n given; the exponent part is optional.\n\n The [_] (underscore) character can appear anywhere in the string\n and is ignored.\n\n Depending on the execution platforms, other representations of\n floating-point numbers can be accepted, but should not be relied upon.\n\n Return [None] if the given string is not a valid representation of a float.\n @since 4.05\n*)\n\nexternal float_of_string : string -> float = \"caml_float_of_string\"\n(** Same as {!Stdlib.float_of_string_opt}, but raise\n [Failure \"float_of_string\"] instead of returning [None]. *)\n\n(** {1 Pair operations} *)\n\nexternal fst : 'a * 'b -> 'a = \"%field0\"\n(** Return the first component of a pair. *)\n\nexternal snd : 'a * 'b -> 'b = \"%field1\"\n(** Return the second component of a pair. *)\n\n\n(** {1 List operations}\n\n More list operations are provided in module {!List}.\n*)\n\nval ( @ ) : 'a list -> 'a list -> 'a list\n(** List concatenation. Not tail-recursive (length of the first argument).\n Right-associative operator, see {!Ocaml_operators} for more information.\n*)\n\n(** {1 Input/output}\n Note: all input/output functions can raise [Sys_error] when the system\n calls they invoke fail. *)\n\ntype in_channel\n(** The type of input channel. *)\n\ntype out_channel\n(** The type of output channel. *)\n\nval stdin : in_channel\n(** The standard input for the process. *)\n\nval stdout : out_channel\n(** The standard output for the process. *)\n\nval stderr : out_channel\n(** The standard error output for the process. *)\n\n\n(** {2 Output functions on standard output} *)\n\nval print_char : char -> unit\n(** Print a character on standard output. *)\n\nval print_string : string -> unit\n(** Print a string on standard output. *)\n\nval print_bytes : bytes -> unit\n(** Print a byte sequence on standard output.\n @since 4.02.0 *)\n\nval print_int : int -> unit\n(** Print an integer, in decimal, on standard output. *)\n\nval print_float : float -> unit\n(** Print a floating-point number, in decimal, on standard output. *)\n\nval print_endline : string -> unit\n(** Print a string, followed by a newline character, on\n standard output and flush standard output. *)\n\nval print_newline : unit -> unit\n(** Print a newline character on standard output, and flush\n standard output. This can be used to simulate line\n buffering of standard output. *)\n\n\n(** {2 Output functions on standard error} *)\n\nval prerr_char : char -> unit\n(** Print a character on standard error. *)\n\nval prerr_string : string -> unit\n(** Print a string on standard error. *)\n\nval prerr_bytes : bytes -> unit\n(** Print a byte sequence on standard error.\n @since 4.02.0 *)\n\nval prerr_int : int -> unit\n(** Print an integer, in decimal, on standard error. *)\n\nval prerr_float : float -> unit\n(** Print a floating-point number, in decimal, on standard error. *)\n\nval prerr_endline : string -> unit\n(** Print a string, followed by a newline character on standard\n error and flush standard error. *)\n\nval prerr_newline : unit -> unit\n(** Print a newline character on standard error, and flush\n standard error. *)\n\n\n(** {2 Input functions on standard input} *)\n\nval read_line : unit -> string\n(** Flush standard output, then read characters from standard input\n until a newline character is encountered.\n\n Return the string of all characters read, without the newline character\n at the end.\n\n @raise End_of_file if the end of the file is reached at the beginning of\n line.\n*)\n\nval read_int_opt: unit -> int option\n(** Flush standard output, then read one line from standard input\n and convert it to an integer.\n\n Return [None] if the line read is not a valid representation of an integer.\n @since 4.05\n*)\n\nval read_int : unit -> int\n(** Same as {!Stdlib.read_int_opt}, but raise [Failure \"int_of_string\"]\n instead of returning [None]. *)\n\nval read_float_opt: unit -> float option\n(** Flush standard output, then read one line from standard input\n and convert it to a floating-point number.\n\n Return [None] if the line read is not a valid representation of a\n floating-point number.\n @since 4.05.0\n*)\n\nval read_float : unit -> float\n(** Same as {!Stdlib.read_float_opt}, but raise [Failure \"float_of_string\"]\n instead of returning [None]. *)\n\n\n(** {2 General output functions} *)\n\ntype open_flag =\n Open_rdonly (** open for reading. *)\n | Open_wronly (** open for writing. *)\n | Open_append (** open for appending: always write at end of file. *)\n | Open_creat (** create the file if it does not exist. *)\n | Open_trunc (** empty the file if it already exists. *)\n | Open_excl (** fail if Open_creat and the file already exists. *)\n | Open_binary (** open in binary mode (no conversion). *)\n | Open_text (** open in text mode (may perform conversions). *)\n | Open_nonblock (** open in non-blocking mode. *)\n(** Opening modes for {!Stdlib.open_out_gen} and\n {!Stdlib.open_in_gen}. *)\n\nval open_out : string -> out_channel\n(** Open the named file for writing, and return a new output channel\n on that file, positioned at the beginning of the file. The\n file is truncated to zero length if it already exists. It\n is created if it does not already exists. *)\n\nval open_out_bin : string -> out_channel\n(** Same as {!Stdlib.open_out}, but the file is opened in binary mode,\n so that no translation takes place during writes. On operating\n systems that do not distinguish between text mode and binary\n mode, this function behaves like {!Stdlib.open_out}. *)\n\nval open_out_gen : open_flag list -> int -> string -> out_channel\n(** [open_out_gen mode perm filename] opens the named file for writing,\n as described above. The extra argument [mode]\n specifies the opening mode. The extra argument [perm] specifies\n the file permissions, in case the file must be created.\n {!Stdlib.open_out} and {!Stdlib.open_out_bin} are special\n cases of this function. *)\n\nval flush : out_channel -> unit\n(** Flush the buffer associated with the given output channel,\n performing all pending writes on that channel.\n Interactive programs must be careful about flushing standard\n output and standard error at the right time. *)\n\nval flush_all : unit -> unit\n(** Flush all open output channels; ignore errors. *)\n\nval output_char : out_channel -> char -> unit\n(** Write the character on the given output channel. *)\n\nval output_string : out_channel -> string -> unit\n(** Write the string on the given output channel. *)\n\nval output_bytes : out_channel -> bytes -> unit\n(** Write the byte sequence on the given output channel.\n @since 4.02.0 *)\n\nval output : out_channel -> bytes -> int -> int -> unit\n(** [output oc buf pos len] writes [len] characters from byte sequence [buf],\n starting at offset [pos], to the given output channel [oc].\n @raise Invalid_argument if [pos] and [len] do not\n designate a valid range of [buf]. *)\n\nval output_substring : out_channel -> string -> int -> int -> unit\n(** Same as [output] but take a string as argument instead of\n a byte sequence.\n @since 4.02.0 *)\n\nval output_byte : out_channel -> int -> unit\n(** Write one 8-bit integer (as the single character with that code)\n on the given output channel. The given integer is taken modulo\n 256. *)\n\nval output_binary_int : out_channel -> int -> unit\n(** Write one integer in binary format (4 bytes, big-endian)\n on the given output channel.\n The given integer is taken modulo 2{^32}.\n The only reliable way to read it back is through the\n {!Stdlib.input_binary_int} function. The format is compatible across\n all machines for a given version of OCaml. *)\n\nval output_value : out_channel -> 'a -> unit\n(** Write the representation of a structured value of any type\n to a channel. Circularities and sharing inside the value\n are detected and preserved. The object can be read back,\n by the function {!Stdlib.input_value}. See the description of module\n {!Marshal} for more information. {!Stdlib.output_value} is equivalent\n to {!Marshal.to_channel} with an empty list of flags. *)\n\nval seek_out : out_channel -> int -> unit\n(** [seek_out chan pos] sets the current writing position to [pos]\n for channel [chan]. This works only for regular files. On\n files of other kinds (such as terminals, pipes and sockets),\n the behavior is unspecified. *)\n\nval pos_out : out_channel -> int\n(** Return the current writing position for the given channel. Does\n not work on channels opened with the [Open_append] flag (returns\n unspecified results).\n For files opened in text mode under Windows, the returned position\n is approximate (owing to end-of-line conversion); in particular,\n saving the current position with [pos_out], then going back to\n this position using [seek_out] will not work. For this\n programming idiom to work reliably and portably, the file must be\n opened in binary mode. *)\n\nval out_channel_length : out_channel -> int\n(** Return the size (number of characters) of the regular file\n on which the given channel is opened. If the channel is opened\n on a file that is not a regular file, the result is meaningless. *)\n\nval close_out : out_channel -> unit\n(** Close the given channel, flushing all buffered write operations.\n Output functions raise a [Sys_error] exception when they are\n applied to a closed output channel, except [close_out] and [flush],\n which do nothing when applied to an already closed channel.\n Note that [close_out] may raise [Sys_error] if the operating\n system signals an error when flushing or closing. *)\n\nval close_out_noerr : out_channel -> unit\n(** Same as [close_out], but ignore all errors. *)\n\nval set_binary_mode_out : out_channel -> bool -> unit\n(** [set_binary_mode_out oc true] sets the channel [oc] to binary\n mode: no translations take place during output.\n [set_binary_mode_out oc false] sets the channel [oc] to text\n mode: depending on the operating system, some translations\n may take place during output. For instance, under Windows,\n end-of-lines will be translated from [\\n] to [\\r\\n].\n This function has no effect under operating systems that\n do not distinguish between text mode and binary mode. *)\n\n\n(** {2 General input functions} *)\n\nval open_in : string -> in_channel\n(** Open the named file for reading, and return a new input channel\n on that file, positioned at the beginning of the file. *)\n\nval open_in_bin : string -> in_channel\n(** Same as {!Stdlib.open_in}, but the file is opened in binary mode,\n so that no translation takes place during reads. On operating\n systems that do not distinguish between text mode and binary\n mode, this function behaves like {!Stdlib.open_in}. *)\n\nval open_in_gen : open_flag list -> int -> string -> in_channel\n(** [open_in_gen mode perm filename] opens the named file for reading,\n as described above. The extra arguments\n [mode] and [perm] specify the opening mode and file permissions.\n {!Stdlib.open_in} and {!Stdlib.open_in_bin} are special\n cases of this function. *)\n\nval input_char : in_channel -> char\n(** Read one character from the given input channel.\n @raise End_of_file if there are no more characters to read. *)\n\nval input_line : in_channel -> string\n(** Read characters from the given input channel, until a\n newline character is encountered. Return the string of\n all characters read, without the newline character at the end.\n @raise End_of_file if the end of the file is reached\n at the beginning of line. *)\n\nval input : in_channel -> bytes -> int -> int -> int\n(** [input ic buf pos len] reads up to [len] characters from\n the given channel [ic], storing them in byte sequence [buf], starting at\n character number [pos].\n It returns the actual number of characters read, between 0 and\n [len] (inclusive).\n A return value of 0 means that the end of file was reached.\n A return value between 0 and [len] exclusive means that\n not all requested [len] characters were read, either because\n no more characters were available at that time, or because\n the implementation found it convenient to do a partial read;\n [input] must be called again to read the remaining characters,\n if desired. (See also {!Stdlib.really_input} for reading\n exactly [len] characters.)\n Exception [Invalid_argument \"input\"] is raised if [pos] and [len]\n do not designate a valid range of [buf]. *)\n\nval really_input : in_channel -> bytes -> int -> int -> unit\n(** [really_input ic buf pos len] reads [len] characters from channel [ic],\n storing them in byte sequence [buf], starting at character number [pos].\n @raise End_of_file if the end of file is reached before [len]\n characters have been read.\n @raise Invalid_argument if\n [pos] and [len] do not designate a valid range of [buf]. *)\n\nval really_input_string : in_channel -> int -> string\n(** [really_input_string ic len] reads [len] characters from channel [ic]\n and returns them in a new string.\n @raise End_of_file if the end of file is reached before [len]\n characters have been read.\n @since 4.02.0 *)\n\nval input_byte : in_channel -> int\n(** Same as {!Stdlib.input_char}, but return the 8-bit integer representing\n the character.\n @raise End_of_file if the end of file was reached. *)\n\nval input_binary_int : in_channel -> int\n(** Read an integer encoded in binary format (4 bytes, big-endian)\n from the given input channel. See {!Stdlib.output_binary_int}.\n @raise End_of_file if the end of file was reached while reading the\n integer. *)\n\nval input_value : in_channel -> 'a\n(** Read the representation of a structured value, as produced\n by {!Stdlib.output_value}, and return the corresponding value.\n This function is identical to {!Marshal.from_channel};\n see the description of module {!Marshal} for more information,\n in particular concerning the lack of type safety. *)\n\nval seek_in : in_channel -> int -> unit\n(** [seek_in chan pos] sets the current reading position to [pos]\n for channel [chan]. This works only for regular files. On\n files of other kinds, the behavior is unspecified. *)\n\nval pos_in : in_channel -> int\n(** Return the current reading position for the given channel. For\n files opened in text mode under Windows, the returned position is\n approximate (owing to end-of-line conversion); in particular,\n saving the current position with [pos_in], then going back to this\n position using [seek_in] will not work. For this programming\n idiom to work reliably and portably, the file must be opened in\n binary mode. *)\n\nval in_channel_length : in_channel -> int\n(** Return the size (number of characters) of the regular file\n on which the given channel is opened. If the channel is opened\n on a file that is not a regular file, the result is meaningless.\n The returned size does not take into account the end-of-line\n translations that can be performed when reading from a channel\n opened in text mode. *)\n\nval close_in : in_channel -> unit\n(** Close the given channel. Input functions raise a [Sys_error]\n exception when they are applied to a closed input channel,\n except [close_in], which does nothing when applied to an already\n closed channel. *)\n\nval close_in_noerr : in_channel -> unit\n(** Same as [close_in], but ignore all errors. *)\n\nval set_binary_mode_in : in_channel -> bool -> unit\n(** [set_binary_mode_in ic true] sets the channel [ic] to binary\n mode: no translations take place during input.\n [set_binary_mode_out ic false] sets the channel [ic] to text\n mode: depending on the operating system, some translations\n may take place during input. For instance, under Windows,\n end-of-lines will be translated from [\\r\\n] to [\\n].\n This function has no effect under operating systems that\n do not distinguish between text mode and binary mode. *)\n\n\n(** {2 Operations on large files} *)\n\nmodule LargeFile :\n sig\n val seek_out : out_channel -> int64 -> unit\n val pos_out : out_channel -> int64\n val out_channel_length : out_channel -> int64\n val seek_in : in_channel -> int64 -> unit\n val pos_in : in_channel -> int64\n val in_channel_length : in_channel -> int64\n end\n(** Operations on large files.\n This sub-module provides 64-bit variants of the channel functions\n that manipulate file positions and file sizes. By representing\n positions and sizes by 64-bit integers (type [int64]) instead of\n regular integers (type [int]), these alternate functions allow\n operating on files whose sizes are greater than [max_int]. *)\n\n(** {1 References} *)\n\ntype 'a ref = { mutable contents : 'a }\n(** The type of references (mutable indirection cells) containing\n a value of type ['a]. *)\n\nexternal ref : 'a -> 'a ref = \"%makemutable\"\n(** Return a fresh reference containing the given value. *)\n\nexternal ( ! ) : 'a ref -> 'a = \"%field0\"\n(** [!r] returns the current contents of reference [r].\n Equivalent to [fun r -> r.contents].\n Unary operator, see {!Ocaml_operators} for more information.\n*)\n\nexternal ( := ) : 'a ref -> 'a -> unit = \"%setfield0\"\n(** [r := a] stores the value of [a] in reference [r].\n Equivalent to [fun r v -> r.contents <- v].\n Right-associative operator, see {!Ocaml_operators} for more information.\n*)\n\nexternal incr : int ref -> unit = \"%incr\"\n(** Increment the integer contained in the given reference.\n Equivalent to [fun r -> r := succ !r]. *)\n\nexternal decr : int ref -> unit = \"%decr\"\n(** Decrement the integer contained in the given reference.\n Equivalent to [fun r -> r := pred !r]. *)\n\n(** {1 Result type} *)\n\n(** @since 4.03.0 *)\ntype ('a,'b) result = Ok of 'a | Error of 'b\n\n(** {1 Operations on format strings} *)\n\n(** Format strings are character strings with special lexical conventions\n that defines the functionality of formatted input/output functions. Format\n strings are used to read data with formatted input functions from module\n {!Scanf} and to print data with formatted output functions from modules\n {!Printf} and {!Format}.\n\n Format strings are made of three kinds of entities:\n - {e conversions specifications}, introduced by the special character ['%']\n followed by one or more characters specifying what kind of argument to\n read or print,\n - {e formatting indications}, introduced by the special character ['@']\n followed by one or more characters specifying how to read or print the\n argument,\n - {e plain characters} that are regular characters with usual lexical\n conventions. Plain characters specify string literals to be read in the\n input or printed in the output.\n\n There is an additional lexical rule to escape the special characters ['%']\n and ['@'] in format strings: if a special character follows a ['%']\n character, it is treated as a plain character. In other words, [\"%%\"] is\n considered as a plain ['%'] and [\"%@\"] as a plain ['@'].\n\n For more information about conversion specifications and formatting\n indications available, read the documentation of modules {!Scanf},\n {!Printf} and {!Format}.\n*)\n\n(** Format strings have a general and highly polymorphic type\n [('a, 'b, 'c, 'd, 'e, 'f) format6].\n The two simplified types, [format] and [format4] below are\n included for backward compatibility with earlier releases of\n OCaml.\n\n The meaning of format string type parameters is as follows:\n\n - ['a] is the type of the parameters of the format for formatted output\n functions ([printf]-style functions);\n ['a] is the type of the values read by the format for formatted input\n functions ([scanf]-style functions).\n\n - ['b] is the type of input source for formatted input functions and the\n type of output target for formatted output functions.\n For [printf]-style functions from module {!Printf}, ['b] is typically\n [out_channel];\n for [printf]-style functions from module {!Format}, ['b] is typically\n {!type:Format.formatter};\n for [scanf]-style functions from module {!Scanf}, ['b] is typically\n {!Scanf.Scanning.in_channel}.\n\n Type argument ['b] is also the type of the first argument given to\n user's defined printing functions for [%a] and [%t] conversions,\n and user's defined reading functions for [%r] conversion.\n\n - ['c] is the type of the result of the [%a] and [%t] printing\n functions, and also the type of the argument transmitted to the\n first argument of [kprintf]-style functions or to the\n [kscanf]-style functions.\n\n - ['d] is the type of parameters for the [scanf]-style functions.\n\n - ['e] is the type of the receiver function for the [scanf]-style functions.\n\n - ['f] is the final result type of a formatted input/output function\n invocation: for the [printf]-style functions, it is typically [unit];\n for the [scanf]-style functions, it is typically the result type of the\n receiver function.\n*)\n\ntype ('a, 'b, 'c, 'd, 'e, 'f) format6 =\n ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.format6\n\ntype ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'c, 'c, 'd) format6\n\ntype ('a, 'b, 'c) format = ('a, 'b, 'c, 'c) format4\n\nval string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string\n(** Converts a format string into a string. *)\n\nexternal format_of_string :\n ('a, 'b, 'c, 'd, 'e, 'f) format6 ->\n ('a, 'b, 'c, 'd, 'e, 'f) format6 = \"%identity\"\n(** [format_of_string s] returns a format string read from the string\n literal [s].\n Note: [format_of_string] can not convert a string argument that is not a\n literal. If you need this functionality, use the more general\n {!Scanf.format_from_string} function.\n*)\n\nval ( ^^ ) :\n ('a, 'b, 'c, 'd, 'e, 'f) format6 ->\n ('f, 'b, 'c, 'e, 'g, 'h) format6 ->\n ('a, 'b, 'c, 'd, 'g, 'h) format6\n(** [f1 ^^ f2] catenates format strings [f1] and [f2]. The result is a\n format string that behaves as the concatenation of format strings [f1] and\n [f2]: in case of formatted output, it accepts arguments from [f1], then\n arguments from [f2]; in case of formatted input, it returns results from\n [f1], then results from [f2].\n Right-associative operator, see {!Ocaml_operators} for more information.\n*)\n\n(** {1 Program termination} *)\n\nval exit : int -> 'a\n(** Terminate the process, returning the given status code\n to the operating system: usually 0 to indicate no errors,\n and a small positive integer to indicate failure.\n All open output channels are flushed with [flush_all].\n An implicit [exit 0] is performed each time a program\n terminates normally. An implicit [exit 2] is performed if the program\n terminates early because of an uncaught exception. *)\n\nval at_exit : (unit -> unit) -> unit\n(** Register the given function to be called at program termination\n time. The functions registered with [at_exit] will be called when\n the program does any of the following:\n - executes {!Stdlib.exit}\n - terminates, either normally or because of an uncaught\n exception\n - executes the C function [caml_shutdown].\n The functions are called in 'last in, first out' order: the\n function most recently added with [at_exit] is called first. *)\n\n(**/**)\n\n(* The following is for system use only. Do not call directly. *)\n\nval valid_float_lexem : string -> string\n\nval unsafe_really_input : in_channel -> bytes -> int -> int -> unit\n\nval do_at_exit : unit -> unit\n\n(**/**)\n\n(** {1:modules Standard library modules } *)\n\n(*MODULE_ALIASES*)\nmodule Arg = Arg\nmodule Array = Array\nmodule ArrayLabels = ArrayLabels\nmodule Atomic = Atomic\nmodule Bigarray = Bigarray\nmodule Bool = Bool\nmodule Buffer = Buffer\nmodule Bytes = Bytes\nmodule BytesLabels = BytesLabels\nmodule Callback = Callback\nmodule Char = Char\nmodule Complex = Complex\nmodule Digest = Digest\nmodule Either = Either\nmodule Ephemeron = Ephemeron\nmodule Filename = Filename\nmodule Float = Float\nmodule Format = Format\nmodule Fun = Fun\nmodule Gc = Gc\nmodule Genlex = Genlex\n[@@deprecated \"Use the camlp-streams library instead.\"]\nmodule Hashtbl = Hashtbl\nmodule In_channel = In_channel\nmodule Int = Int\nmodule Int32 = Int32\nmodule Int64 = Int64\nmodule Lazy = Lazy\nmodule Lexing = Lexing\nmodule List = List\nmodule ListLabels = ListLabels\nmodule Map = Map\nmodule Marshal = Marshal\nmodule MoreLabels = MoreLabels\nmodule Nativeint = Nativeint\nmodule Obj = Obj\nmodule Oo = Oo\nmodule Option = Option\nmodule Out_channel = Out_channel\nmodule Parsing = Parsing\nmodule Pervasives = Pervasives\n[@@deprecated \"Use Stdlib instead.\\n\\\n\\n\\\nIf you need to stay compatible with OCaml < 4.07, you can use the \\n\\\nstdlib-shims library: https://github.com/ocaml/stdlib-shims\"]\nmodule Printexc = Printexc\nmodule Printf = Printf\nmodule Queue = Queue\nmodule Random = Random\nmodule Result = Result\nmodule Scanf = Scanf\nmodule Seq = Seq\nmodule Set = Set\nmodule Stack = Stack\nmodule StdLabels = StdLabels\nmodule Stream = Stream\n[@@deprecated \"Use the camlp-streams library instead.\"]\nmodule String = String\nmodule StringLabels = StringLabels\nmodule Sys = Sys\nmodule Uchar = Uchar\nmodule Unit = Unit\nmodule Weak = Weak\n","(** An interface to use for int-like types, e.g., {{!Base.Int}[Int]} and\n {{!Base.Int64}[Int64]}. *)\n\nopen! Import\n\nmodule type Round = sig\n type t\n\n (** [round] rounds an int to a multiple of a given [to_multiple_of] argument, according\n to a direction [dir], with default [dir] being [`Nearest]. [round] will raise if\n [to_multiple_of <= 0]. If the result overflows (too far positive or too far\n negative), [round] returns an incorrect result.\n\n {v\n | `Down | rounds toward Int.neg_infinity |\n | `Up | rounds toward Int.infinity |\n | `Nearest | rounds to the nearest multiple, or `Up in case of a tie |\n | `Zero | rounds toward zero |\n v}\n\n Here are some examples for [round ~to_multiple_of:10] for each direction:\n\n {v\n | `Down | {10 .. 19} --> 10 | { 0 ... 9} --> 0 | {-10 ... -1} --> -10 |\n | `Up | { 1 .. 10} --> 10 | {-9 ... 0} --> 0 | {-19 .. -10} --> -10 |\n | `Zero | {10 .. 19} --> 10 | {-9 ... 9} --> 0 | {-19 .. -10} --> -10 |\n | `Nearest | { 5 .. 14} --> 10 | {-5 ... 4} --> 0 | {-15 ... -6} --> -10 |\n v}\n\n For convenience and performance, there are variants of [round] with [dir]\n hard-coded. If you are writing performance-critical code you should use these. *)\n\n val round : ?dir:[ `Zero | `Nearest | `Up | `Down ] -> t -> to_multiple_of:t -> t\n val round_towards_zero : t -> to_multiple_of:t -> t\n val round_down : t -> to_multiple_of:t -> t\n val round_up : t -> to_multiple_of:t -> t\n val round_nearest : t -> to_multiple_of:t -> t\nend\n\nmodule type Hexable = sig\n type t\n\n module Hex : sig\n type nonrec t = t [@@deriving_inline sexp, compare, hash]\n\n include Ppx_sexp_conv_lib.Sexpable.S with type t := t\n\n val compare : t -> t -> int\n val hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state\n val hash : t -> Ppx_hash_lib.Std.Hash.hash_value\n\n [@@@end]\n\n include Stringable.S with type t := t\n\n val to_string_hum : ?delimiter:char -> t -> string\n end\nend\n\nmodule type S_common = sig\n type t [@@deriving_inline sexp, sexp_grammar]\n\n include Ppx_sexp_conv_lib.Sexpable.S with type t := t\n\n val t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t\n\n [@@@end]\n\n include Floatable.S with type t := t\n include Intable.S with type t := t\n include Identifiable.S with type t := t\n include Comparable.With_zero with type t := t\n include Invariant.S with type t := t\n include Hexable with type t := t\n\n (** [delimiter] is an underscore by default. *)\n val to_string_hum : ?delimiter:char -> t -> string\n\n (** {2 Infix operators and constants} *)\n\n val zero : t\n val one : t\n val minus_one : t\n val ( + ) : t -> t -> t\n val ( - ) : t -> t -> t\n val ( * ) : t -> t -> t\n\n (** Integer exponentiation *)\n val ( ** ) : t -> t -> t\n\n (** Negation *)\n\n val neg : t -> t\n val ( ~- ) : t -> t\n\n (** There are two pairs of integer division and remainder functions, [/%] and [%], and\n [/] and [rem]. They both satisfy the same equation relating the quotient and the\n remainder:\n\n {[\n x = (x /% y) * y + (x % y);\n x = (x / y) * y + (rem x y);\n ]}\n\n The functions return the same values if [x] and [y] are positive. They all raise\n if [y = 0].\n\n The functions differ if [x < 0] or [y < 0].\n\n If [y < 0], then [%] and [/%] raise, whereas [/] and [rem] do not.\n\n [x % y] always returns a value between 0 and [y - 1], even when [x < 0]. On the\n other hand, [rem x y] returns a negative value if and only if [x < 0]; that value\n satisfies [abs (rem x y) <= abs y - 1]. *)\n\n val ( /% ) : t -> t -> t\n val ( % ) : t -> t -> t\n val ( / ) : t -> t -> t\n val rem : t -> t -> t\n\n (** Float division of integers. *)\n val ( // ) : t -> t -> float\n\n (** Same as [bit_and]. *)\n val ( land ) : t -> t -> t\n\n (** Same as [bit_or]. *)\n val ( lor ) : t -> t -> t\n\n (** Same as [bit_xor]. *)\n val ( lxor ) : t -> t -> t\n\n (** Same as [bit_not]. *)\n val lnot : t -> t\n\n (** Same as [shift_left]. *)\n val ( lsl ) : t -> int -> t\n\n (** Same as [shift_right]. *)\n val ( asr ) : t -> int -> t\n\n (** {2 Other common functions} *)\n\n include Round with type t := t\n\n (** Returns the absolute value of the argument. May be negative if the input is\n [min_value]. *)\n val abs : t -> t\n\n (** {2 Successor and predecessor functions} *)\n\n val succ : t -> t\n val pred : t -> t\n\n (** {2 Exponentiation} *)\n\n (** [pow base exponent] returns [base] raised to the power of [exponent]. It is OK if\n [base <= 0]. [pow] raises if [exponent < 0], or an integer overflow would occur. *)\n val pow : t -> t -> t\n\n (** {2 Bit-wise logical operations } *)\n\n (** These are identical to [land], [lor], etc. except they're not infix and have\n different names. *)\n val bit_and : t -> t -> t\n\n val bit_or : t -> t -> t\n val bit_xor : t -> t -> t\n val bit_not : t -> t\n\n (** Returns the number of 1 bits in the binary representation of the input. *)\n val popcount : t -> int\n\n (** {2 Bit-shifting operations }\n\n The results are unspecified for negative shifts and shifts [>= num_bits]. *)\n\n (** Shifts left, filling in with zeroes. *)\n val shift_left : t -> int -> t\n\n (** Shifts right, preserving the sign of the input. *)\n val shift_right : t -> int -> t\n\n (** {2 Increment and decrement functions for integer references } *)\n\n val decr : t ref -> unit\n val incr : t ref -> unit\n\n (** {2 Conversion functions to related integer types} *)\n\n val of_int32_exn : int32 -> t\n val to_int32_exn : t -> int32\n val of_int64_exn : int64 -> t\n val to_int64 : t -> int64\n val of_nativeint_exn : nativeint -> t\n val to_nativeint_exn : t -> nativeint\n\n (** [of_float_unchecked] truncates the given floating point number to an integer,\n rounding towards zero.\n The result is unspecified if the argument is nan or falls outside the range\n of representable integers. *)\n val of_float_unchecked : float -> t\nend\n\nmodule type Operators_unbounded = sig\n type t\n\n val ( + ) : t -> t -> t\n val ( - ) : t -> t -> t\n val ( * ) : t -> t -> t\n val ( / ) : t -> t -> t\n val ( ~- ) : t -> t\n val ( ** ) : t -> t -> t\n\n include Comparisons.Infix with type t := t\n\n val abs : t -> t\n val neg : t -> t\n val zero : t\n val ( % ) : t -> t -> t\n val ( /% ) : t -> t -> t\n val ( // ) : t -> t -> float\n val ( land ) : t -> t -> t\n val ( lor ) : t -> t -> t\n val ( lxor ) : t -> t -> t\n val lnot : t -> t\n val ( lsl ) : t -> int -> t\n val ( asr ) : t -> int -> t\nend\n\nmodule type Operators = sig\n include Operators_unbounded\n\n val ( lsr ) : t -> int -> t\nend\n\n(** [S_unbounded] is a generic interface for unbounded integers, e.g. [Bignum.Bigint].\n [S_unbounded] is a restriction of [S] (below) that omits values that depend on\n fixed-size integers. *)\nmodule type S_unbounded = sig\n include S_common (** @inline *)\n\n (** A sub-module designed to be opened to make working with ints more convenient. *)\n module O : Operators_unbounded with type t := t\nend\n\n(** [S] is a generic interface for fixed-size integers. *)\nmodule type S = sig\n include S_common (** @inline *)\n\n (** The number of bits available in this integer type. Note that the integer\n representations are signed. *)\n val num_bits : int\n\n (** The largest representable integer. *)\n val max_value : t\n\n (** The smallest representable integer. *)\n val min_value : t\n\n (** Same as [shift_right_logical]. *)\n val ( lsr ) : t -> int -> t\n\n (** Shifts right, filling in with zeroes, which will not preserve the sign of the\n input. *)\n val shift_right_logical : t -> int -> t\n\n (** [ceil_pow2 x] returns the smallest power of 2 that is greater than or equal to [x].\n The implementation may only be called for [x > 0]. Example: [ceil_pow2 17 = 32] *)\n val ceil_pow2 : t -> t\n\n (** [floor_pow2 x] returns the largest power of 2 that is less than or equal to [x]. The\n implementation may only be called for [x > 0]. Example: [floor_pow2 17 = 16] *)\n val floor_pow2 : t -> t\n\n (** [ceil_log2 x] returns the ceiling of log-base-2 of [x], and raises if [x <= 0]. *)\n val ceil_log2 : t -> int\n\n (** [floor_log2 x] returns the floor of log-base-2 of [x], and raises if [x <= 0]. *)\n val floor_log2 : t -> int\n\n (** [is_pow2 x] returns true iff [x] is a power of 2. [is_pow2] raises if [x <= 0]. *)\n val is_pow2 : t -> bool\n\n (** Returns the number of leading zeros in the binary representation of the input, as an\n integer between 0 and one less than [num_bits].\n\n The results are unspecified for [t = 0]. *)\n val clz : t -> int\n\n (** Returns the number of trailing zeros in the binary representation of the input, as\n an integer between 0 and one less than [num_bits].\n\n The results are unspecified for [t = 0]. *)\n val ctz : t -> int\n\n (** A sub-module designed to be opened to make working with ints more convenient. *)\n module O : Operators with type t := t\nend\n\ninclude (\nstruct\n (** Various functors whose type-correctness ensures desired relationships between\n interfaces. *)\n\n module Check_O_contained_in_S (M : S) : module type of M.O = M\n module Check_O_contained_in_S_unbounded (M : S_unbounded) : module type of M.O = M\n module Check_S_unbounded_in_S (M : S) : S_unbounded = M\nend :\nsig end)\n\nmodule type Int_without_module_types = sig\n include S with type t = int\n\n (** [max_value_30_bits = 2^30 - 1]. It is useful for writing tests that work on both\n 64-bit and 32-bit platforms. *)\n val max_value_30_bits : t\n\n (** {2 Conversion functions} *)\n\n val of_int : int -> t\n val to_int : t -> int\n val of_int32 : int32 -> t option\n val to_int32 : t -> int32 option\n val of_int64 : int64 -> t option\n val of_nativeint : nativeint -> t option\n val to_nativeint : t -> nativeint\n\n (** {3 Truncating conversions}\n\n These functions return the least-significant bits of the input. In cases\n where optional conversions return [Some x], truncating conversions return [x]. *)\n\n val of_int32_trunc : int32 -> t\n val to_int32_trunc : t -> int32\n val of_int64_trunc : int64 -> t\n val of_nativeint_trunc : nativeint -> t\n\n (** {2 Byte swap operations}\n\n Byte swap operations reverse the order of bytes in an integer. For\n example, {!Int32.bswap32} reorders the bottom 32 bits (or 4 bytes),\n turning [0x1122_3344] to [0x4433_2211]. Byte swap functions exposed by\n Base use OCaml primitives to generate assembly instructions to perform\n the relevant byte swaps.\n\n For a more extensive list of byteswap functions, see {!Int32} and\n {!Int64}.\n *)\n\n (** Byte swaps bottom 16 bits (2 bytes). The values of the remaining bytes\n are undefined. *)\n val bswap16 : t -> t\n\n (**/**)\n\n (*_ See the Jane Street Style Guide for an explanation of [Private] submodules:\n\n https://opensource.janestreet.com/standards/#private-submodules *)\n module Private : sig\n (*_ For ../bench/bench_int.ml *)\n module O_F : sig\n val ( % ) : int -> int -> int\n val ( /% ) : int -> int -> int\n val ( // ) : int -> int -> float\n end\n end\nend\n\n(** OCaml's native integer type.\n\n The number of bits in an integer is platform dependent, being 31-bits on a 32-bit\n platform, and 63-bits on a 64-bit platform. [int] is a signed integer type. [int]s\n are also subject to overflow, meaning that [Int.max_value + 1 = Int.min_value].\n\n [int]s always fit in a machine word. *)\nmodule type Int = sig\n include Int_without_module_types\n\n (** {2 Module types specifying integer operations.} *)\n module type Hexable = Hexable\n\n module type Int_without_module_types = Int_without_module_types\n module type Operators = Operators\n module type Operators_unbounded = Operators_unbounded\n module type Round = Round\n module type S = S\n module type S_common = S_common\n module type S_unbounded = S_unbounded\nend\n","open! Import\n\n(* Open replace_polymorphic_compare after including functor instantiations so they do not\n shadow its definitions. This is here so that efficient versions of the comparison\n functions are available within this module. *)\nopen! Float_replace_polymorphic_compare\n\nlet ceil = Caml.ceil\nlet floor = Caml.floor\nlet mod_float = Caml.mod_float\nlet modf = Caml.modf\nlet float_of_string = Caml.float_of_string\nlet nan = Caml.nan\nlet infinity = Caml.infinity\nlet neg_infinity = Caml.neg_infinity\nlet max_finite_value = Caml.max_float\nlet epsilon_float = Caml.epsilon_float\nlet classify_float = Caml.classify_float\nlet abs_float = Caml.abs_float\nlet ( ** ) = Caml.( ** )\n\n(* The bits of INRIA's [Pervasives] that we just want to expose in [Float]. Most are\n already deprecated in [Pervasives], and eventually all of them should be. *)\ninclude (\n Caml :\n sig\n external frexp : float -> float * int = \"caml_frexp_float\"\n\n external ldexp\n : (float[@unboxed])\n -> (int[@untagged])\n -> (float[@unboxed])\n = \"caml_ldexp_float\" \"caml_ldexp_float_unboxed\"\n [@@noalloc]\n\n external log10 : float -> float = \"caml_log10_float\" \"log10\"\n [@@unboxed] [@@noalloc]\n\n external expm1 : float -> float = \"caml_expm1_float\" \"caml_expm1\"\n [@@unboxed] [@@noalloc]\n\n external log1p : float -> float = \"caml_log1p_float\" \"caml_log1p\"\n [@@unboxed] [@@noalloc]\n\n external copysign : float -> float -> float = \"caml_copysign_float\" \"caml_copysign\"\n [@@unboxed] [@@noalloc]\n\n external cos : float -> float = \"caml_cos_float\" \"cos\" [@@unboxed] [@@noalloc]\n external sin : float -> float = \"caml_sin_float\" \"sin\" [@@unboxed] [@@noalloc]\n external tan : float -> float = \"caml_tan_float\" \"tan\" [@@unboxed] [@@noalloc]\n external acos : float -> float = \"caml_acos_float\" \"acos\" [@@unboxed] [@@noalloc]\n external asin : float -> float = \"caml_asin_float\" \"asin\" [@@unboxed] [@@noalloc]\n external atan : float -> float = \"caml_atan_float\" \"atan\" [@@unboxed] [@@noalloc]\n\n external atan2 : float -> float -> float = \"caml_atan2_float\" \"atan2\"\n [@@unboxed] [@@noalloc]\n\n external hypot : float -> float -> float = \"caml_hypot_float\" \"caml_hypot\"\n [@@unboxed] [@@noalloc]\n\n external cosh : float -> float = \"caml_cosh_float\" \"cosh\" [@@unboxed] [@@noalloc]\n external sinh : float -> float = \"caml_sinh_float\" \"sinh\" [@@unboxed] [@@noalloc]\n external tanh : float -> float = \"caml_tanh_float\" \"tanh\" [@@unboxed] [@@noalloc]\n external sqrt : float -> float = \"caml_sqrt_float\" \"sqrt\" [@@unboxed] [@@noalloc]\n external exp : float -> float = \"caml_exp_float\" \"exp\" [@@unboxed] [@@noalloc]\n external log : float -> float = \"caml_log_float\" \"log\" [@@unboxed] [@@noalloc]\n end)\n\n(* We need this indirection because these are exposed as \"val\" instead of \"external\" *)\nlet frexp = frexp\nlet ldexp = ldexp\nlet is_nan x = (x : float) <> x\n\n(* An order-preserving bijection between all floats except for NaNs, and 99.95% of\n int64s.\n\n Note we don't distinguish 0. and -0. as separate values here, they both map to 0L, which\n maps back to 0.\n\n This should work both on little-endian and high-endian CPUs. Wikipedia says: \"on\n modern standard computers (i.e., implementing IEEE 754), one may in practice safely\n assume that the endianness is the same for floating point numbers as for integers\"\n (http://en.wikipedia.org/wiki/Endianness#Floating-point_and_endianness).\n*)\nlet to_int64_preserve_order t =\n if is_nan t\n then None\n else if t = 0.\n then (* also includes -0. *)\n Some 0L\n else if t > 0.\n then Some (Caml.Int64.bits_of_float t)\n else Some (Caml.Int64.neg (Caml.Int64.bits_of_float (-.t)))\n;;\n\nlet to_int64_preserve_order_exn x = Option.value_exn (to_int64_preserve_order x)\n\nlet of_int64_preserve_order x =\n if Int64_replace_polymorphic_compare.( >= ) x 0L\n then Caml.Int64.float_of_bits x\n else ~-.(Caml.Int64.float_of_bits (Caml.Int64.neg x))\n;;\n\nlet one_ulp dir t =\n match to_int64_preserve_order t with\n | None -> Caml.nan\n | Some x ->\n of_int64_preserve_order\n (Caml.Int64.add\n x\n (match dir with\n | `Up -> 1L\n | `Down -> -1L))\n;;\n\n(* [upper_bound_for_int] and [lower_bound_for_int] are for calculating the max/min float\n that fits in a given-size integer when rounded towards 0 (using [int_of_float]).\n\n max_int/min_int depend on [num_bits], e.g. +/- 2^30, +/- 2^62 if 31-bit, 63-bit\n (respectively) while float is IEEE standard for double (52 significant bits).\n\n In all cases, we want to guarantee that\n [lower_bound_for_int <= x <= upper_bound_for_int]\n iff [int_of_float x] fits in an int with [num_bits] bits.\n\n [2 ** (num_bits - 1)] is the first float greater that max_int, we use the preceding\n float as upper bound.\n\n [- (2 ** (num_bits - 1))] is equal to min_int.\n For lower bound we look for the smallest float [f] satisfying [f > min_int - 1] so that\n [f] rounds toward zero to [min_int]\n\n So in particular we will have:\n [lower_bound_for_int x <= - (2 ** (1-x))]\n [upper_bound_for_int x < 2 ** (1-x) ]\n*)\nlet upper_bound_for_int num_bits =\n let exp = Caml.float_of_int (num_bits - 1) in\n one_ulp `Down (2. ** exp)\n;;\n\nlet is_x_minus_one_exact x =\n (* [x = x -. 1.] does not work with x87 floating point arithmetic backend (which is used\n on 32-bit ocaml) because of 80-bit register precision of intermediate computations.\n\n An alternative way of computing this: [x -. one_ulp `Down x <= 1.] is also prone to\n the same precision issues: you need to make sure [x] is 64-bit.\n *)\n let open Int64_replace_polymorphic_compare in\n not (Caml.Int64.bits_of_float x = Caml.Int64.bits_of_float (x -. 1.))\n;;\n\nlet lower_bound_for_int num_bits =\n let exp = Caml.float_of_int (num_bits - 1) in\n let min_int_as_float = ~-.(2. ** exp) in\n let open Int_replace_polymorphic_compare in\n if num_bits - 1 < 53 (* 53 = #bits in the float's mantissa with sign included *)\n then (\n (* The smallest float that rounds towards zero to [min_int] is\n [min_int - 1 + epsilon] *)\n assert (is_x_minus_one_exact min_int_as_float);\n one_ulp `Up (min_int_as_float -. 1.))\n else (\n (* [min_int_as_float] is already the smallest float [f] satisfying [f > min_int - 1]. *)\n assert (not (is_x_minus_one_exact min_int_as_float));\n min_int_as_float)\n;;\n\n(* Float clamping is structured slightly differently than clamping for other types, so\n that we get the behavior of [clamp_unchecked nan ~min ~max = nan] (for any [min] and\n [max]) for free.\n*)\nlet clamp_unchecked (t : float) ~min ~max =\n if t < min then min else if max < t then max else t\n;;\n\nlet box =\n (* Prevent potential constant folding of [+. 0.] in the near ocamlopt future. *)\n let x = Sys0.opaque_identity 0. in\n fun f -> f +. x\n;;\n\n(* Include type-specific [Replace_polymorphic_compare] at the end, after\n including functor application that could shadow its definitions. This is\n here so that efficient versions of the comparison functions are exported by\n this module. *)\ninclude Float_replace_polymorphic_compare\n","open Core_kernel\nopen Import\nopen Deferred_std\nmodule Stream = Async_stream\n\nlet show_debug_messages = ref false\nlet check_invariant = ref false\n\nmodule Flushed_result = struct\n type t =\n [ `Ok\n | `Reader_closed\n ]\n [@@deriving compare, sexp_of]\n\n let equal = [%compare.equal: t]\n\n let combine (l : t Deferred.t list) =\n let%map l = Deferred.all l in\n match List.mem l `Reader_closed ~equal with\n | true -> `Reader_closed\n | false -> `Ok\n ;;\nend\n\n(* A [Consumer.t] acts as the monitor of some process that reads values from a pipe and\n processes them, allowing that process:\n - to communicate that it has taken responsibility for the values\n - to signal when it has finished with the values to interested parties (via\n [downstream_flushed])\n\n It is used in two steps:\n\n 1. calling [Consumer.start] at the point where the consumer takes values out of the\n Pipe via [read] or [read'].\n\n 2. calling [Consumer.values_sent_downstream].\n\n By calling [values_sent_downstream] one asserts that the [downstream_flushed] function\n supplied to [create] will now wait for this value.\n\n If no [Consumer.t] is supplied when a value is read then the value is defined to be\n flushed at that time. *)\nmodule Consumer : sig\n type t [@@deriving sexp_of]\n\n include Invariant.S with type t := t\n\n val create\n : pipe_id:int\n -> downstream_flushed:(unit -> Flushed_result.t Deferred.t)\n -> t\n\n val pipe_id : t -> int\n val start : t -> unit\n val values_sent_downstream : t -> unit\n val values_sent_downstream_and_flushed : t -> Flushed_result.t Deferred.t\nend = struct\n type t =\n { pipe_id : int\n ; (* [values_read] reflects whether values the consumer has read from the pipe have been\n sent downstream or if not, holds an ivar that is to be filled when they are. *)\n mutable values_read :\n [ `Have_been_sent_downstream | `Have_not_been_sent_downstream of unit Ivar.t ]\n ; (* [downstream_flushed ()] returns when all prior values that the consumer has\n passed downstream have been flushed all the way down the chain of pipes. *)\n downstream_flushed : unit -> Flushed_result.t Deferred.t\n }\n [@@deriving fields, sexp_of]\n\n let invariant t : unit =\n try\n let check f field = f (Field.get field t) in\n Fields.iter\n ~pipe_id:ignore\n ~values_read:\n (check (function\n | `Have_been_sent_downstream -> ()\n | `Have_not_been_sent_downstream ivar -> assert (Ivar.is_empty ivar)))\n ~downstream_flushed:ignore\n with\n | exn ->\n raise_s [%message \"Pipe.Consumer.invariant failed\" (exn : exn) ~pipe:(t : t)]\n ;;\n\n let create ~pipe_id ~downstream_flushed =\n { pipe_id; values_read = `Have_been_sent_downstream; downstream_flushed }\n ;;\n\n let start t =\n match t.values_read with\n | `Have_not_been_sent_downstream _ -> ()\n | `Have_been_sent_downstream ->\n t.values_read <- `Have_not_been_sent_downstream (Ivar.create ())\n ;;\n\n let values_sent_downstream t =\n match t.values_read with\n | `Have_been_sent_downstream -> ()\n | `Have_not_been_sent_downstream ivar ->\n Ivar.fill ivar ();\n t.values_read <- `Have_been_sent_downstream\n ;;\n\n let values_sent_downstream_and_flushed t =\n match t.values_read with\n | `Have_been_sent_downstream -> t.downstream_flushed ()\n | `Have_not_been_sent_downstream when_sent_downstream ->\n let%bind () = Ivar.read when_sent_downstream in\n t.downstream_flushed ()\n ;;\nend\n\nmodule Blocked_read = struct\n (* A [Blocked_read.t] represents a blocked read attempt. If someone reads from an empty\n pipe, they enqueue a [Blocked_read.t] in the queue of [blocked_reads]. Later, when\n values are written to a pipe, that will cause some number of blocked reads to be\n filled, first come first serve. The blocked-read constructor specifies how many\n values a read should consume from the pipe when it gets its turn.\n\n If a pipe is closed, then all blocked reads will be filled with [`Eof]. *)\n type 'a wants =\n | Zero of [ `Eof | `Ok ] Ivar.t\n | One of [ `Eof | `Ok of 'a ] Ivar.t\n | At_most of int * [ `Eof | `Ok of 'a Queue.t ] Ivar.t\n [@@deriving sexp_of]\n\n type 'a t =\n { wants : 'a wants\n ; consumer : Consumer.t option\n }\n [@@deriving fields, sexp_of]\n\n let invariant t : unit =\n try\n let check f field = f (Field.get field t) in\n Fields.iter\n ~wants:\n (check (function\n | Zero _ | One _ -> ()\n | At_most (i, _) -> assert (i > 0)))\n ~consumer:\n (check (function\n | None -> ()\n | Some consumer -> Consumer.invariant consumer))\n with\n | exn ->\n raise_s [%message \"Pipe.Blocked_read.invariant failed\" (exn : exn) ~pipe:(t : _ t)]\n ;;\n\n let create wants consumer = { wants; consumer }\n\n let is_empty t =\n match t.wants with\n | Zero i -> Ivar.is_empty i\n | One i -> Ivar.is_empty i\n | At_most (_, i) -> Ivar.is_empty i\n ;;\n\n let fill_with_eof t =\n match t.wants with\n | Zero i -> Ivar.fill i `Eof\n | One i -> Ivar.fill i `Eof\n | At_most (_, i) -> Ivar.fill i `Eof\n ;;\nend\n\nmodule Blocked_flush = struct\n (* A [Blocked_flush.t] represents a blocked flush operation, which can be enabled by a\n future read. If someone does [flushed p] on a pipe, that blocks until everything\n that's currently in the pipe at that point has drained out of the pipe. When we call\n [flushed], it records the total amount of data that has been written so far in\n [fill_when_num_values_read]. We fill the [Flush.t] with [`Ok] when this amount of\n data has been read from the pipe.\n\n A [Blocked_flush.t] can also be filled with [`Reader_closed], which happens when the\n reader end of the pipe is closed, and we are thus sure that the unread elements\n preceding the flush will never be read. *)\n type t =\n { fill_when_num_values_read : int\n ; ready : [ `Ok | `Reader_closed ] Ivar.t\n }\n [@@deriving fields, sexp_of]\n\n let fill t v = Ivar.fill t.ready v\nend\n\ntype ('a, 'phantom) t =\n { (* [id] is an integer used to distinguish pipes when debugging. *)\n id : int Sexp_hidden_in_test.t\n ; (* [info] is user-provided arbitrary sexp, for debugging purposes. *)\n mutable info : Sexp.t option [@sexp.option]\n ; (* [buffer] holds values written to the pipe that have not yet been read. *)\n mutable buffer : 'a Queue.t\n ; (* [size_budget] governs pushback on writers to the pipe.\n\n There is *no* invariant that [Queue.length buffer <= size_budget]. There is no\n hard upper bound on the number of elements that can be stuffed into the [buffer].\n This is due to the way we handle writes. When we do a write, all of the values\n written are immediately enqueued into [buffer]. After the write, if [Queue.length\n buffer <= t.size_budget], then the writer will be notified to continue writing.\n After the write, if [length t > t.size_budget], then the write will block until the\n pipe is under budget. *)\n mutable size_budget : int\n ; (* [pushback] is used to give feedback to writers about whether they should write to\n the pipe. [pushback] is full iff [length t <= t.size_budget || is_closed t]. *)\n mutable pushback : unit Ivar.t\n ; (* [num_values_read] keeps track of the total number of values that have been read\n from the pipe. We do not have to worry about overflow in [num_values_read]. You'd\n need to write 2^62 elements to the pipe, which would take about 146 years, at a\n flow rate of 1 size-unit/nanosecond. *)\n mutable num_values_read : int\n ; (* [blocked_flushes] holds flushes whose preceding elements have not been completely\n read. For each blocked flush, the number of elements that need to be read from the\n pipe in order to fill the flush is :\n\n fill_when_num_values_read - num_values_read\n\n Keeping the data in this form allows us to change a single field(num_values_read)\n when we consume values instead of having to iterate over the whole queue of\n flushes. *)\n blocked_flushes : Blocked_flush.t Queue.t\n ; (* [blocked_reads] holds reads that are waiting on data to be written to the pipe. *)\n blocked_reads : 'a Blocked_read.t Queue.t\n ; (* [closed] is filled when we close the write end of the pipe. *)\n closed : unit Ivar.t\n ; (* [read_closed] is filled when we close the read end of the pipe. *)\n read_closed : unit Ivar.t\n ; (* [consumers] is a list of all consumers that may be handling values read from the\n pipe. *)\n mutable consumers : Consumer.t list\n ; (* [upstream_flusheds] has a function for each pipe immediately upstream of this one.\n That function walks to the head(s) of the upstream pipe, and calls\n [downstream_flushed] on the head(s). See the definition of [upstream_flushed]\n below. *)\n upstream_flusheds : (unit -> Flushed_result.t Deferred.t) Bag.t\n }\n[@@deriving fields, sexp_of]\n\ntype ('a, 'phantom) pipe = ('a, 'phantom) t [@@deriving sexp_of]\n\nlet hash t = Hashtbl.hash t.id\nlet equal (t1 : (_, _) t) t2 = phys_equal t1 t2\nlet compare t1 t2 = Int.compare t1.id t2.id\nlet is_closed t = Ivar.is_full t.closed\nlet is_read_closed t = Ivar.is_full t.read_closed\nlet closed t = Ivar.read t.closed\nlet pushback t = Ivar.read t.pushback\nlet length t = Queue.length t.buffer\nlet is_empty t = length t = 0\n\nlet invariant t : unit =\n try\n let check f field = f (Field.get field t) in\n Fields.iter\n ~id:ignore\n ~info:ignore\n ~buffer:ignore\n ~size_budget:(check (fun size_budget -> assert (size_budget >= 0)))\n ~pushback:\n (check (fun pushback ->\n assert (\n Bool.equal\n (Ivar.is_full pushback)\n (length t <= t.size_budget || is_closed t))))\n ~num_values_read:ignore\n ~blocked_flushes:\n (check (fun blocked_flushes ->\n Queue.iter blocked_flushes ~f:(fun (f : Blocked_flush.t) ->\n assert (f.fill_when_num_values_read > t.num_values_read));\n assert (\n List.is_sorted\n ~compare:Int.compare\n (List.map\n (Queue.to_list blocked_flushes)\n ~f:Blocked_flush.fill_when_num_values_read));\n if is_empty t then assert (Queue.is_empty blocked_flushes)))\n ~blocked_reads:\n (check (fun blocked_reads ->\n (* If data is available, no one is waiting for it. This would need to change if\n we ever implement [read_exactly] as an atomic operation. *)\n if not (is_empty t) then assert (Queue.is_empty blocked_reads);\n Queue.iter blocked_reads ~f:(fun read ->\n Blocked_read.invariant read;\n assert (Blocked_read.is_empty read));\n (* You never block trying to read a closed pipe. *)\n if is_closed t then assert (Queue.is_empty blocked_reads)))\n ~closed:ignore\n ~read_closed:ignore\n ~consumers:\n (check (fun l ->\n List.iter l ~f:(fun consumer ->\n Consumer.invariant consumer;\n assert (Consumer.pipe_id consumer = t.id))))\n ~upstream_flusheds:ignore\n with\n | exn -> raise_s [%message \"Pipe.invariant failed\" (exn : exn) ~pipe:(t : (_, _) t)]\n;;\n\nmodule Reader = struct\n type phantom [@@deriving sexp_of]\n type 'a t = ('a, phantom) pipe [@@deriving sexp_of]\n\n let invariant = invariant\nend\n\nmodule Writer = struct\n type phantom [@@deriving sexp_of]\n type 'a t = ('a, phantom) pipe [@@deriving sexp_of]\n\n let invariant = invariant\nend\n\nlet id_ref = ref 0\n\nlet create_internal ~info ~initial_buffer =\n incr id_ref;\n let t =\n { id = !id_ref\n ; info\n ; closed = Ivar.create ()\n ; read_closed = Ivar.create ()\n ;\n size_budget = 0\n ; pushback = Ivar.create ()\n ; buffer = initial_buffer\n ; num_values_read = 0\n ; blocked_flushes = Queue.create ()\n ; blocked_reads = Queue.create ()\n ; consumers = []\n ; upstream_flusheds = Bag.create ()\n }\n in\n t\n;;\n\nlet create ?info () =\n let t = create_internal ~info ~initial_buffer:(Queue.create ()) in\n (* initially, the pipe does not pushback *)\n Ivar.fill t.pushback ();\n if !check_invariant then invariant t;\n t, t\n;;\n\nlet update_pushback t =\n if length t <= t.size_budget || is_closed t\n then Ivar.fill_if_empty t.pushback ()\n else if Ivar.is_full t.pushback\n then t.pushback <- Ivar.create ()\n;;\n\nlet close t =\n if !show_debug_messages then eprints \"close\" t [%sexp_of: (_, _) t];\n if !check_invariant then invariant t;\n if not (is_closed t)\n then (\n Ivar.fill t.closed ();\n if is_empty t\n then (\n Queue.iter t.blocked_reads ~f:Blocked_read.fill_with_eof;\n Queue.clear t.blocked_reads);\n update_pushback t)\n;;\n\nlet close_read t =\n if !show_debug_messages then eprints \"close_read\" t [%sexp_of: (_, _) t];\n if !check_invariant then invariant t;\n if not (is_read_closed t)\n then (\n Ivar.fill t.read_closed ();\n Queue.iter t.blocked_flushes ~f:(fun flush ->\n Blocked_flush.fill flush `Reader_closed);\n Queue.clear t.blocked_flushes;\n Queue.clear t.buffer;\n update_pushback t;\n (* we just cleared the buffer, so may need to fill [t.pushback] *)\n close t)\n;;\n\nlet create_reader_not_close_on_exception f =\n let r, w = create () in\n upon (f w) (fun () -> close w);\n r\n;;\n\nlet create_reader ~close_on_exception f =\n if not close_on_exception\n then create_reader_not_close_on_exception f\n else (\n let r, w = create () in\n don't_wait_for\n (Monitor.protect\n (fun () -> f w)\n ~finally:(fun () ->\n close w;\n return ()));\n r)\n;;\n\nlet create_writer f =\n let r, w = create () in\n don't_wait_for\n (Monitor.protect\n (fun () -> f r)\n ~finally:(fun () ->\n close_read r;\n return ()));\n w\n;;\n\nlet values_were_read t consumer =\n Option.iter consumer ~f:Consumer.start;\n let rec loop () =\n match Queue.peek t.blocked_flushes with\n | None -> ()\n | Some flush ->\n if t.num_values_read >= flush.fill_when_num_values_read\n then (\n ignore (Queue.dequeue_exn t.blocked_flushes : Blocked_flush.t);\n (match consumer with\n | None -> Blocked_flush.fill flush `Ok\n | Some consumer ->\n upon\n (Consumer.values_sent_downstream_and_flushed consumer)\n (fun flush_result -> Blocked_flush.fill flush flush_result));\n loop ())\n in\n loop ()\n;;\n\n(* [consume_all t] reads all the elements in [t]. *)\nlet consume_all t consumer =\n let result = t.buffer in\n t.buffer <- Queue.create ();\n t.num_values_read <- t.num_values_read + Queue.length result;\n values_were_read t consumer;\n update_pushback t;\n result\n;;\n\nlet consume_one t consumer =\n assert (length t >= 1);\n let result = Queue.dequeue_exn t.buffer in\n t.num_values_read <- t.num_values_read + 1;\n values_were_read t consumer;\n update_pushback t;\n result\n;;\n\nlet consume t ~max_queue_length consumer =\n assert (max_queue_length >= 0);\n if max_queue_length >= length t\n then consume_all t consumer\n else (\n t.num_values_read <- t.num_values_read + max_queue_length;\n values_were_read t consumer;\n let result = Queue.create ~capacity:max_queue_length () in\n Queue.blit_transfer ~src:t.buffer ~dst:result ~len:max_queue_length ();\n update_pushback t;\n result)\n;;\n\nlet set_size_budget t size_budget =\n if size_budget < 0 then raise_s [%message \"negative size_budget\" (size_budget : int)];\n t.size_budget <- size_budget;\n update_pushback t\n;;\n\nlet fill_blocked_reads t =\n while (not (Queue.is_empty t.blocked_reads)) && not (is_empty t) do\n let blocked_read = Queue.dequeue_exn t.blocked_reads in\n let consumer = blocked_read.consumer in\n match blocked_read.wants with\n | Zero ivar -> Ivar.fill ivar `Ok\n | One ivar -> Ivar.fill ivar (`Ok (consume_one t consumer))\n | At_most (max_queue_length, ivar) ->\n Ivar.fill ivar (`Ok (consume t ~max_queue_length consumer))\n done\n;;\n\n(* checks all invariants, calls a passed in f to handle a write, then updates reads and\n pushback *)\nlet start_write t =\n if !show_debug_messages then eprints \"write\" t [%sexp_of: (_, _) t];\n if !check_invariant then invariant t;\n if is_closed t then raise_s [%message \"write to closed pipe\" ~pipe:(t : (_, _) t)]\n;;\n\nlet finish_write t =\n fill_blocked_reads t;\n update_pushback t\n;;\n\nlet transfer_in_without_pushback t ~from =\n start_write t;\n Queue.blit_transfer ~src:from ~dst:t.buffer ();\n finish_write t\n;;\n\nlet transfer_in t ~from =\n transfer_in_without_pushback t ~from;\n pushback t\n;;\n\nlet copy_in_without_pushback t ~from =\n start_write t;\n Queue.iter from ~f:(fun x -> Queue.enqueue t.buffer x);\n finish_write t\n;;\n\n(* [write'] is used internally *)\nlet write' t q = transfer_in t ~from:q\n\nlet write_without_pushback t value =\n start_write t;\n Queue.enqueue t.buffer value;\n finish_write t\n;;\n\nlet write t value =\n write_without_pushback t value;\n pushback t\n;;\n\nlet write_when_ready t ~f =\n let%map () = pushback t in\n if is_closed t then `Closed else `Ok (f (fun x -> write_without_pushback t x))\n;;\n\nlet write_if_open t x = if not (is_closed t) then write t x else return ()\n\nlet write_without_pushback_if_open t x =\n if not (is_closed t) then write_without_pushback t x\n;;\n\nlet ensure_consumer_matches ?consumer t =\n match consumer with\n | None -> ()\n | Some consumer ->\n if t.id <> Consumer.pipe_id consumer\n then\n raise_s\n [%message\n \"Attempt to use consumer with wrong pipe\"\n (consumer : Consumer.t)\n ~pipe:(t : _ Reader.t)]\n;;\n\nlet start_read ?consumer t label =\n if !show_debug_messages then eprints label t [%sexp_of: (_, _) t];\n if !check_invariant then invariant t;\n ensure_consumer_matches t ?consumer\n;;\n\nlet gen_read_now ?consumer t consume =\n start_read t \"read_now\" ?consumer;\n if is_empty t\n then if is_closed t then `Eof else `Nothing_available\n else (\n assert (Queue.is_empty t.blocked_reads);\n (* from [invariant] and [not (is_empty t)] *)\n `Ok (consume t consumer))\n;;\n\nlet get_max_queue_length ~max_queue_length =\n match max_queue_length with\n | None -> Int.max_value\n | Some max_queue_length ->\n if max_queue_length <= 0\n then raise_s [%message \"max_queue_length <= 0\" (max_queue_length : int)];\n max_queue_length\n;;\n\nlet read_now' ?consumer ?max_queue_length t =\n let max_queue_length = get_max_queue_length ~max_queue_length in\n gen_read_now t ?consumer (fun t consumer -> consume t ~max_queue_length consumer)\n;;\n\nlet read_now ?consumer t = gen_read_now t ?consumer consume_one\nlet peek t = Queue.peek t.buffer\n\nlet clear t =\n match read_now' t with\n | `Eof | `Nothing_available | `Ok _ -> ()\n;;\n\nlet read' ?consumer ?max_queue_length t =\n let max_queue_length = get_max_queue_length ~max_queue_length in\n start_read t \"read'\" ?consumer;\n match read_now' t ?consumer ~max_queue_length with\n | (`Ok _ | `Eof) as r -> return r\n | `Nothing_available ->\n Deferred.create (fun ivar ->\n Queue.enqueue\n t.blocked_reads\n (Blocked_read.create (At_most (max_queue_length, ivar)) consumer))\n;;\n\nlet read ?consumer t =\n start_read t \"read\" ?consumer;\n if is_empty t\n then\n if is_closed t\n then return `Eof\n else\n Deferred.create (fun ivar ->\n Queue.enqueue t.blocked_reads (Blocked_read.(create (One ivar)) consumer))\n else (\n assert (Queue.is_empty t.blocked_reads);\n return (`Ok (consume_one t consumer)))\n;;\n\nlet values_available t =\n start_read t \"values_available\";\n if not (is_empty t)\n then return `Ok\n else if is_closed t\n then return `Eof\n else (\n match Queue.last t.blocked_reads with\n | Some { consumer = None; wants = Zero ivar } ->\n (* This case is an optimization for multiple calls to [values_available] in\n sequence. It causes them to all share the same ivar, rather than allocate\n an ivar per call. *)\n Ivar.read ivar\n | _ ->\n Deferred.create (fun ivar ->\n Queue.enqueue t.blocked_reads (Blocked_read.(create (Zero ivar)) None)))\n;;\n\nlet read_choice t = choice (values_available t) (fun (_ : [ `Ok | `Eof ]) -> read_now t)\n\nlet read_choice_single_consumer_exn t here =\n Deferred.Choice.map (read_choice t) ~f:(function\n | (`Ok _ | `Eof) as x -> x\n | `Nothing_available ->\n raise_s\n [%message\n \"Pipe.read_choice_single_consumer_exn: choice was enabled but pipe is \\\n empty; this is likely due to a race condition with one or more other \\\n consumers\"\n (here : Source_code_position.t)])\n;;\n\n(* [read_exactly t ~num_values] loops, getting you all [num_values] items, up\n to EOF. *)\nlet read_exactly ?consumer t ~num_values =\n start_read t \"read_exactly\" ?consumer;\n if num_values <= 0\n then raise_s [%message \"Pipe.read_exactly got num_values <= 0\" (num_values : int)];\n Deferred.create (fun finish ->\n let result = Queue.create () in\n let rec loop () =\n let already_read = Queue.length result in\n assert (already_read <= num_values);\n if already_read = num_values\n then Ivar.fill finish (`Exactly result)\n else\n read' ?consumer t ~max_queue_length:(num_values - already_read)\n >>> function\n | `Eof -> Ivar.fill finish (if already_read = 0 then `Eof else `Fewer result)\n | `Ok q ->\n Queue.blit_transfer ~src:q ~dst:result ();\n loop ()\n in\n loop ())\n;;\n\nlet downstream_flushed t =\n if is_empty t\n then\n if List.is_empty t.consumers\n then return `Ok\n else\n Flushed_result.combine\n (List.map t.consumers ~f:Consumer.values_sent_downstream_and_flushed)\n else\n (* [t] might be closed. But the read end can't be closed, because if it were, then\n [t] would be empty. If the write end is closed but not the read end, then we want\n to enqueue a blocked flush because the enqueued values may get read. *)\n Deferred.create (fun ready ->\n Queue.enqueue\n t.blocked_flushes\n { fill_when_num_values_read = t.num_values_read + length t; ready })\n;;\n\n(* In practice, along with [Link.create] and [add_upstream_flushed], [upstream_flushed]\n traverses the graph of linked pipes up to the heads and then calls [downstream_flushed]\n on them. *)\nlet upstream_flushed t =\n if Bag.is_empty t.upstream_flusheds\n then downstream_flushed t\n else\n Bag.to_list t.upstream_flusheds\n |> List.map ~f:(fun f -> f ())\n |> Flushed_result.combine\n;;\n\nlet add_upstream_flushed t upstream_flushed =\n Bag.add t.upstream_flusheds upstream_flushed\n;;\n\nlet add_consumer t ~downstream_flushed =\n let consumer = Consumer.create ~pipe_id:t.id ~downstream_flushed in\n t.consumers <- consumer :: t.consumers;\n consumer\n;;\n\n(* A [Link.t] links flushing of two pipes together. *)\nmodule Link : sig\n type t\n\n val create : upstream:(_, _) pipe -> downstream:(_, _) pipe -> t\n val consumer : t -> Consumer.t\n\n (* [unlink_upstream] removes downstream's reference to upstream. *)\n\n val unlink_upstream : t -> unit\nend = struct\n type ('a, 'b) unpacked =\n { downstream : ('a, 'b) t\n ; consumer : Consumer.t\n ; upstream_flusheds_bag_elt : (unit -> Flushed_result.t Deferred.t) Bag.Elt.t\n }\n\n type t = T : (_, _) unpacked -> t\n\n let consumer (T t) = t.consumer\n\n let create ~upstream ~downstream =\n T\n { downstream\n ; consumer =\n add_consumer upstream ~downstream_flushed:(fun () ->\n downstream_flushed downstream)\n ; upstream_flusheds_bag_elt =\n add_upstream_flushed downstream (fun () -> upstream_flushed upstream)\n }\n ;;\n\n let unlink_upstream (T t) =\n Bag.remove t.downstream.upstream_flusheds t.upstream_flusheds_bag_elt\n ;;\nend\n\nmodule Flushed = struct\n type t =\n | Consumer of Consumer.t\n | When_value_processed\n | When_value_read\n [@@deriving sexp_of]\nend\n\nlet fold_gen\n (read_now : ?consumer:Consumer.t -> _ Reader.t -> _)\n ?(flushed = Flushed.When_value_read)\n t\n ~init\n ~f\n =\n let consumer =\n match flushed with\n | When_value_read -> None\n | Consumer consumer -> Some consumer\n | When_value_processed ->\n (* The fact that \"no consumer\" behaves different from \"trivial consumer\" is weird,\n but that's how the consumer machinery works. *)\n Some (add_consumer t ~downstream_flushed:(fun () -> return `Ok))\n in\n if !check_invariant then invariant t;\n ensure_consumer_matches t ?consumer;\n Deferred.create (fun finished ->\n (* We do [return () >>>] to ensure that [f] is only called asynchronously. *)\n return ()\n >>> fun () ->\n let rec loop b =\n match read_now t ?consumer with\n | `Eof -> Ivar.fill finished b\n | `Ok v -> f b v continue\n | `Nothing_available -> values_available t >>> fun _ -> loop b\n and continue b =\n Option.iter consumer ~f:Consumer.values_sent_downstream;\n loop b\n in\n loop init)\n;;\n\nlet fold' ?flushed ?max_queue_length t ~init ~f =\n fold_gen (read_now' ?max_queue_length) ?flushed t ~init ~f:(fun b q loop ->\n f b q >>> loop)\n;;\n\nlet fold ?flushed t ~init ~f =\n fold_gen read_now ?flushed t ~init ~f:(fun b a loop -> f b a >>> loop)\n;;\n\nlet fold_without_pushback ?consumer t ~init ~f =\n fold_gen\n read_now\n t\n ~init\n ~f:(fun b a loop -> loop (f b a))\n ?flushed:\n (match consumer with\n | None -> None\n | Some c -> Some (Consumer c))\n;;\n\nlet with_error_to_current_monitor ?(continue_on_error = false) f a =\n if not continue_on_error\n then f a\n else (\n match%map Monitor.try_with (fun () -> f a) with\n | Ok () -> ()\n | Error exn -> Monitor.send_exn (Monitor.current ()) (Monitor.extract_exn exn))\n;;\n\nlet iter' ?continue_on_error ?flushed ?max_queue_length t ~f =\n fold' ?max_queue_length ?flushed t ~init:() ~f:(fun () q ->\n with_error_to_current_monitor ?continue_on_error f q)\n;;\n\nlet iter ?continue_on_error ?flushed t ~f =\n fold_gen read_now ?flushed t ~init:() ~f:(fun () a loop ->\n with_error_to_current_monitor ?continue_on_error f a >>> fun () -> loop ())\n;;\n\n(* [iter_without_pushback] is a common case, so we implement it in an optimized manner,\n rather than via [iter]. The implementation reads only one element at a time, so that\n if [f] closes [t] or raises, no more elements will be read. *)\nlet iter_without_pushback\n ?consumer\n ?(continue_on_error = false)\n ?max_iterations_per_job\n t\n ~f\n =\n ensure_consumer_matches t ?consumer;\n let max_iterations_per_job =\n match max_iterations_per_job with\n | None -> Int.max_value\n | Some max_iterations_per_job ->\n if max_iterations_per_job <= 0\n then\n raise_s\n [%message\n \"iter_without_pushback got non-positive max_iterations_per_job\"\n (max_iterations_per_job : int)];\n max_iterations_per_job\n in\n let f =\n if not continue_on_error\n then f\n else\n fun a ->\n try f a with\n | exn -> Monitor.send_exn (Monitor.current ()) exn\n in\n Deferred.create (fun finished ->\n (* We do [return () >>>] to ensure that [f] is only called asynchronously. *)\n return ()\n >>> fun () ->\n let rec start () = loop ~remaining:max_iterations_per_job\n and loop ~remaining =\n if remaining = 0\n then return () >>> fun () -> start ()\n else (\n match read_now t ?consumer with\n | `Eof -> Ivar.fill finished ()\n | `Ok a ->\n f a;\n loop ~remaining:(remaining - 1)\n | `Nothing_available -> values_available t >>> fun _ -> start ())\n in\n start ())\n;;\n\nlet drain t = iter' t ~f:(fun _ -> return ())\nlet drain_and_count t = fold' t ~init:0 ~f:(fun sum q -> return (sum + Queue.length q))\n\nlet read_all input =\n let result = Queue.create () in\n let%map () =\n iter' input ~f:(fun q ->\n Queue.blit_transfer ~src:q ~dst:result ();\n return ())\n in\n result\n;;\n\nlet to_list r = read_all r >>| Queue.to_list\n\nlet to_stream_deprecated t =\n Stream.create (fun tail ->\n iter_without_pushback t ~f:(fun x -> Tail.extend tail x)\n >>> fun () -> Tail.close_exn tail)\n;;\n\n(* The implementation of [of_stream_deprecated] does as much batching as possible. It\n grabs as many items as are available into an internal queue. Once it has grabbed\n everything, it writes it to the pipe and then blocks waiting for the next element from\n the stream.\n\n There's no possibility that we'll starve the pipe reading an endless stream, just\n accumulating the elements into our private queue forever without ever writing them\n downstream to the pipe. Why? because while we're running, the stream-producer *isn't*\n running -- there are no Async block points in the queue-accumulator loop. So the\n queue-accumulator loop will eventually catch up to the current stream tail, at which\n point we'll do the pipe-write and then block on the stream... thus giving the\n stream-producer a chance to make more elements.\n\n One can't implement [of_stream] using [Stream.iter] or [Stream.iter'] because you\n need to be able to stop early when the consumer closes the pipe. Also, using either\n of those would entail significantly more deferred overhead, whereas the below\n implementation uses a deferred only when it needs to wait for data from the stream. *)\nlet of_stream_deprecated s =\n let r, w = create () in\n let q = Queue.create () in\n let transfer () =\n if not (Queue.is_empty q)\n then\n (* Can not pushback on the stream, so ignore the pushback on the pipe. *)\n don't_wait_for (write' w q)\n in\n let rec loop s =\n assert (not (is_closed w));\n let next_deferred = Stream.next s in\n match Deferred.peek next_deferred with\n | Some next -> loop_next next\n | None ->\n transfer ();\n upon next_deferred check_closed_loop_next\n and check_closed_loop_next next = if not (is_closed w) then loop_next next\n and loop_next = function\n | Nil ->\n transfer ();\n close w\n | Cons (x, s) ->\n Queue.enqueue q x;\n loop s\n in\n loop s;\n r\n;;\n\nlet transfer_gen\n (read_now : ?consumer:Consumer.t -> _ Reader.t -> _)\n write\n input\n output\n ~f\n =\n if !check_invariant\n then (\n invariant input;\n invariant output);\n let link = Link.create ~upstream:input ~downstream:output in\n let consumer = Link.consumer link in\n (* When we're done with [input], we unlink to remove pointers from\n [output] to [input], which would cause a space leak if we had single long-lived\n output into which we transfer lots of short-lived inputs. *)\n let unlink () = Link.unlink_upstream link in\n Deferred.create (fun result ->\n (* We do [return () >>>] to ensure that [f] is only called asynchronously. *)\n return ()\n >>> fun () ->\n let output_closed () =\n close_read input;\n unlink ();\n Ivar.fill result ()\n in\n let rec loop () =\n if is_closed output\n then output_closed ()\n else (\n match read_now input ~consumer with\n | `Eof ->\n unlink ();\n Ivar.fill result ()\n | `Ok x -> f x continue\n | `Nothing_available ->\n choose\n [ choice (values_available input) ignore; choice (closed output) ignore ]\n >>> fun () -> loop ())\n and continue y =\n if is_closed output\n then output_closed ()\n else (\n let pushback = write output y in\n Consumer.values_sent_downstream consumer;\n pushback >>> fun () -> loop ())\n in\n loop ())\n;;\n\nlet transfer' ?max_queue_length input output ~f =\n transfer_gen (read_now' ?max_queue_length) write' input output ~f:(fun q k ->\n f q >>> k)\n;;\n\nlet transfer input output ~f =\n transfer_gen read_now write input output ~f:(fun a k -> k (f a))\n;;\n\nlet transfer_id ?max_queue_length input output =\n transfer_gen (read_now' ?max_queue_length) write' input output ~f:(fun q k -> k q)\n;;\n\nlet map_gen read write input ~f =\n let info = Option.map input.info ~f:(fun info -> [%sexp Mapped (info : Sexp.t)]) in\n let result, output = create ?info () in\n upon (transfer_gen read write input output ~f) (fun () -> close output);\n result\n;;\n\nlet map' ?max_queue_length input ~f =\n map_gen (read_now' ?max_queue_length) write' input ~f:(fun q k -> f q >>> k)\n;;\n\nlet map input ~f = map_gen read_now write input ~f:(fun a k -> k (f a))\n\nlet filter_map' ?max_queue_length input ~f =\n map' ?max_queue_length input ~f:(fun q -> Deferred.Queue.filter_map q ~f)\n;;\n\nlet filter_map ?max_queue_length input ~f =\n map_gen (read_now' ?max_queue_length) write' input ~f:(fun q k ->\n k (Queue.filter_map q ~f:(fun x -> if is_read_closed input then None else f x)))\n;;\n\nlet folding_filter_map' ?max_queue_length input ~init ~f =\n let accum = ref init in\n filter_map' ?max_queue_length input ~f:(fun x ->\n let%map a, x = f !accum x in\n accum := a;\n x)\n;;\n\nlet folding_filter_map ?max_queue_length input ~init ~f =\n let accum = ref init in\n filter_map ?max_queue_length input ~f:(fun x ->\n let a, x = f !accum x in\n accum := a;\n x)\n;;\n\nlet folding_map ?max_queue_length input ~init ~f =\n folding_filter_map ?max_queue_length input ~init ~f:(fun accum a ->\n let accum, b = f accum a in\n accum, Some b)\n;;\n\nlet filter input ~f = filter_map input ~f:(fun x -> if f x then Some x else None)\n\nlet of_list l =\n let t = create_internal ~info:None ~initial_buffer:(Queue.of_list l) in\n Ivar.fill t.closed ();\n update_pushback t;\n t\n;;\n\nlet empty () = of_list []\n\nlet singleton x =\n let reader, writer = create () in\n write_without_pushback writer x;\n close writer;\n reader\n;;\n\nlet unfold ~init:s ~f =\n (* To get some batching, we run the continuation immediately if the deferred is\n determined. However, we always check for pushback. Because size budget can't be\n infinite, the below loop is guaranteed to eventually yield to the scheduler. *)\n let ( >>=~ ) d f =\n match Deferred.peek d with\n | None -> d >>= f\n | Some x -> f x\n in\n create_reader ~close_on_exception:false (fun writer ->\n let rec loop s =\n f s\n >>=~ function\n | None -> return ()\n | Some (a, s) ->\n if is_closed writer then return () else write writer a >>=~ fun () -> loop s\n in\n loop s)\n;;\n\nlet of_sequence sequence =\n create_reader ~close_on_exception:false (fun writer ->\n let rec enqueue_n sequence i =\n if i <= 0\n then sequence\n else (\n match Sequence.next sequence with\n | None -> sequence\n | Some (a, sequence) ->\n Queue.enqueue writer.buffer a;\n enqueue_n sequence (i - 1))\n in\n let rec loop sequence =\n if is_closed writer || Sequence.is_empty sequence\n then return ()\n else (\n start_write writer;\n let sequence = enqueue_n sequence (1 + writer.size_budget - length writer) in\n finish_write writer;\n let%bind () = pushback writer in\n loop sequence)\n in\n loop sequence)\n;;\n\ntype 'a to_sequence_elt =\n | Value of 'a\n | Wait_for : _ Deferred.t -> _ to_sequence_elt\n\nlet to_sequence t =\n Sequence.unfold ~init:() ~f:(fun () ->\n match read_now t with\n | `Eof -> None\n | `Ok a -> Some (Value a, ())\n | `Nothing_available -> Some (Wait_for (values_available t), ()))\n;;\n\nlet interleave_pipe inputs =\n let output, output_writer = create ~info:[%sexp \"Pipe.interleave\"] () in\n (* We keep a reference count of all the pipes that [interleave_pipe] is managing;\n [inputs] counts as one. When the reference count drops to zero, we know that all\n pipes are closed and we can close [output_writer]. *)\n let num_pipes_remaining = ref 1 in\n let decr_num_pipes_remaining () =\n decr num_pipes_remaining;\n if !num_pipes_remaining = 0 then close output_writer\n in\n don't_wait_for\n (let%map () =\n iter_without_pushback inputs ~f:(fun input ->\n incr num_pipes_remaining;\n don't_wait_for\n (let%map () = transfer_id input output_writer in\n decr_num_pipes_remaining ()))\n in\n decr_num_pipes_remaining ());\n (* for [inputs] *)\n output\n;;\n\nlet interleave inputs =\n if !check_invariant then List.iter inputs ~f:invariant;\n interleave_pipe (of_list inputs)\n;;\n\nlet merge inputs ~compare =\n match inputs with\n | [] -> empty ()\n | [ input ] -> input\n | inputs ->\n let module Heap = Pairing_heap in\n let r, w = create () in\n upon (closed w) (fun () -> List.iter inputs ~f:close_read);\n let heap = Heap.create ~cmp:(fun (a1, _) (a2, _) -> compare a1 a2) () in\n let handle_read input eof_or_ok =\n match eof_or_ok with\n | `Eof -> ()\n | `Ok v -> Heap.add heap (v, input)\n in\n let rec pop_heap_and_loop () =\n (* At this point, all inputs not at Eof occur in [heap] exactly once, so we know\n what the next output element is. [pop_heap_and_loop] repeatedly takes elements\n from the inputs as long as it has one from each input. This is done\n synchronously to avoid the cost of a deferred for each element of the output --\n there's no need to pushback since that is only moving elements from one pipe to\n another. As soon as [pop_heap_and_loop] can't get an element from some input, it\n waits on pushback from the output, since it has to wait on the input anyway.\n This also prevents [merge] from consuming inputs at a rate faster than its output\n is consumed. *)\n match Heap.pop heap with\n | None -> close w\n | Some (v, input) ->\n if not (is_closed w)\n then (\n write_without_pushback w v;\n if Heap.length heap = 0\n then upon (transfer_id input w) (fun () -> close w)\n else (\n match read_now input with\n | (`Eof | `Ok _) as x ->\n handle_read input x;\n pop_heap_and_loop ()\n | `Nothing_available ->\n pushback w\n >>> fun () ->\n read input\n >>> fun x ->\n handle_read input x;\n pop_heap_and_loop ()))\n in\n let initial_push =\n Deferred.List.iter inputs ~f:(fun input ->\n let%map x = read input in\n handle_read input x)\n in\n upon initial_push pop_heap_and_loop;\n r\n;;\n\nlet concat_pipe inputs =\n let r =\n create_reader_not_close_on_exception (fun w ->\n let link = Link.create ~upstream:inputs ~downstream:w in\n let consumer = Link.consumer link in\n iter ~flushed:(Consumer consumer) inputs ~f:(fun input -> transfer_id input w))\n in\n upon (closed r) (fun () -> close inputs);\n r\n;;\n\nlet concat inputs =\n create_reader_not_close_on_exception (fun w ->\n Deferred.List.iter inputs ~f:(fun input -> transfer_id input w))\n;;\n\nlet fork t ~pushback_uses =\n let reader0, writer0 = create () in\n let reader1, writer1 = create () in\n let some_reader_was_closed = ref false in\n let consumer =\n add_consumer t ~downstream_flushed:(fun () ->\n let some_reader_was_closed = !some_reader_was_closed in\n match%map\n Flushed_result.combine\n [ downstream_flushed writer0; downstream_flushed writer1 ]\n with\n | `Reader_closed -> `Reader_closed\n | `Ok ->\n (* In this case, there could have been no pending items in [writer0] nor in\n [writer1], in which case we could have had a closed pipe that missed some\n writes, but [Flushed_result.combine] would still have returned [`Ok] *)\n if some_reader_was_closed then `Reader_closed else `Ok)\n in\n don't_wait_for\n (let still_open = [ writer0; writer1 ] in\n let filter_open still_open =\n (* Only call [filter] and reallocate list if something will get filtered *)\n if not (List.exists still_open ~f:is_closed)\n then still_open\n else (\n some_reader_was_closed := true;\n let still_open = List.filter still_open ~f:(fun w -> not (is_closed w)) in\n if List.is_empty still_open then close t;\n still_open)\n in\n let%bind still_open =\n fold' t ~flushed:(Consumer consumer) ~init:still_open ~f:(fun still_open queue ->\n let still_open = filter_open still_open in\n if List.is_empty still_open\n then return []\n else (\n let%map () =\n match pushback_uses with\n | `Fast_consumer_only -> Deferred.any (List.map still_open ~f:pushback)\n | `Both_consumers -> Deferred.all_unit (List.map still_open ~f:pushback)\n in\n let still_open = filter_open still_open in\n List.iter still_open ~f:(fun w -> copy_in_without_pushback w ~from:queue);\n still_open))\n in\n List.iter still_open ~f:close;\n return ());\n reader0, reader1\n;;\n\nlet set_info t info = set_info t (Some info)\n","open! Import\nmodule Int = Int0\nmodule Sys = Sys0\n\nlet convert_failure x a b to_string =\n Printf.failwithf\n \"conversion from %s to %s failed: %s is out of range\"\n a\n b\n (to_string x)\n ()\n[@@cold] [@@inline never] [@@local never] [@@specialise never]\n;;\n\nlet num_bits_int = Sys.int_size_in_bits\nlet num_bits_int32 = 32\nlet num_bits_int64 = 64\nlet num_bits_nativeint = Word_size.num_bits Word_size.word_size\nlet () = assert (num_bits_int = 63 || num_bits_int = 31 || num_bits_int = 32)\nlet min_int32 = Caml.Int32.min_int\nlet max_int32 = Caml.Int32.max_int\nlet min_int64 = Caml.Int64.min_int\nlet max_int64 = Caml.Int64.max_int\nlet min_nativeint = Caml.Nativeint.min_int\nlet max_nativeint = Caml.Nativeint.max_int\nlet int_to_string = Caml.string_of_int\nlet int32_to_string = Caml.Int32.to_string\nlet int64_to_string = Caml.Int64.to_string\nlet nativeint_to_string = Caml.Nativeint.to_string\n\n(* int <-> int32 *)\n\nlet int_to_int32_failure x = convert_failure x \"int\" \"int32\" int_to_string\nlet int32_to_int_failure x = convert_failure x \"int32\" \"int\" int32_to_string\nlet int32_to_int_trunc = Caml.Int32.to_int\nlet int_to_int32_trunc = Caml.Int32.of_int\n\nlet int_is_representable_as_int32 =\n if num_bits_int <= num_bits_int32\n then fun _ -> true\n else (\n let min = int32_to_int_trunc min_int32 in\n let max = int32_to_int_trunc max_int32 in\n fun x -> compare_int min x <= 0 && compare_int x max <= 0)\n;;\n\nlet int32_is_representable_as_int =\n if num_bits_int32 <= num_bits_int\n then fun _ -> true\n else (\n let min = int_to_int32_trunc Int.min_value in\n let max = int_to_int32_trunc Int.max_value in\n fun x -> compare_int32 min x <= 0 && compare_int32 x max <= 0)\n;;\n\nlet int_to_int32 x =\n if int_is_representable_as_int32 x then Some (int_to_int32_trunc x) else None\n;;\n\nlet int32_to_int x =\n if int32_is_representable_as_int x then Some (int32_to_int_trunc x) else None\n;;\n\nlet int_to_int32_exn x =\n if int_is_representable_as_int32 x\n then int_to_int32_trunc x\n else int_to_int32_failure x\n;;\n\nlet int32_to_int_exn x =\n if int32_is_representable_as_int x\n then int32_to_int_trunc x\n else int32_to_int_failure x\n;;\n\n(* int <-> int64 *)\n\nlet int64_to_int_failure x = convert_failure x \"int64\" \"int\" int64_to_string\nlet () = assert (num_bits_int < num_bits_int64)\nlet int_to_int64 = Caml.Int64.of_int\nlet int64_to_int_trunc = Caml.Int64.to_int\n\nlet int64_is_representable_as_int =\n let min = int_to_int64 Int.min_value in\n let max = int_to_int64 Int.max_value in\n fun x -> compare_int64 min x <= 0 && compare_int64 x max <= 0\n;;\n\nlet int64_to_int x =\n if int64_is_representable_as_int x then Some (int64_to_int_trunc x) else None\n;;\n\nlet int64_to_int_exn x =\n if int64_is_representable_as_int x\n then int64_to_int_trunc x\n else int64_to_int_failure x\n;;\n\n(* int <-> nativeint *)\n\nlet nativeint_to_int_failure x = convert_failure x \"nativeint\" \"int\" nativeint_to_string\nlet () = assert (num_bits_int <= num_bits_nativeint)\nlet int_to_nativeint = Caml.Nativeint.of_int\nlet nativeint_to_int_trunc = Caml.Nativeint.to_int\n\nlet nativeint_is_representable_as_int =\n if num_bits_nativeint <= num_bits_int\n then fun _ -> true\n else (\n let min = int_to_nativeint Int.min_value in\n let max = int_to_nativeint Int.max_value in\n fun x -> compare_nativeint min x <= 0 && compare_nativeint x max <= 0)\n;;\n\nlet nativeint_to_int x =\n if nativeint_is_representable_as_int x then Some (nativeint_to_int_trunc x) else None\n;;\n\nlet nativeint_to_int_exn x =\n if nativeint_is_representable_as_int x\n then nativeint_to_int_trunc x\n else nativeint_to_int_failure x\n;;\n\n(* int32 <-> int64 *)\n\nlet int64_to_int32_failure x = convert_failure x \"int64\" \"int32\" int64_to_string\nlet () = assert (num_bits_int32 < num_bits_int64)\nlet int32_to_int64 = Caml.Int64.of_int32\nlet int64_to_int32_trunc = Caml.Int64.to_int32\n\nlet int64_is_representable_as_int32 =\n let min = int32_to_int64 min_int32 in\n let max = int32_to_int64 max_int32 in\n fun x -> compare_int64 min x <= 0 && compare_int64 x max <= 0\n;;\n\nlet int64_to_int32 x =\n if int64_is_representable_as_int32 x then Some (int64_to_int32_trunc x) else None\n;;\n\nlet int64_to_int32_exn x =\n if int64_is_representable_as_int32 x\n then int64_to_int32_trunc x\n else int64_to_int32_failure x\n;;\n\n(* int32 <-> nativeint *)\n\nlet nativeint_to_int32_failure x =\n convert_failure x \"nativeint\" \"int32\" nativeint_to_string\n;;\n\nlet () = assert (num_bits_int32 <= num_bits_nativeint)\nlet int32_to_nativeint = Caml.Nativeint.of_int32\nlet nativeint_to_int32_trunc = Caml.Nativeint.to_int32\n\nlet nativeint_is_representable_as_int32 =\n if num_bits_nativeint <= num_bits_int32\n then fun _ -> true\n else (\n let min = int32_to_nativeint min_int32 in\n let max = int32_to_nativeint max_int32 in\n fun x -> compare_nativeint min x <= 0 && compare_nativeint x max <= 0)\n;;\n\nlet nativeint_to_int32 x =\n if nativeint_is_representable_as_int32 x\n then Some (nativeint_to_int32_trunc x)\n else None\n;;\n\nlet nativeint_to_int32_exn x =\n if nativeint_is_representable_as_int32 x\n then nativeint_to_int32_trunc x\n else nativeint_to_int32_failure x\n;;\n\n(* int64 <-> nativeint *)\n\nlet int64_to_nativeint_failure x = convert_failure x \"int64\" \"nativeint\" int64_to_string\nlet () = assert (num_bits_int64 >= num_bits_nativeint)\nlet int64_to_nativeint_trunc = Caml.Int64.to_nativeint\nlet nativeint_to_int64 = Caml.Int64.of_nativeint\n\nlet int64_is_representable_as_nativeint =\n if num_bits_int64 <= num_bits_nativeint\n then fun _ -> true\n else (\n let min = nativeint_to_int64 min_nativeint in\n let max = nativeint_to_int64 max_nativeint in\n fun x -> compare_int64 min x <= 0 && compare_int64 x max <= 0)\n;;\n\nlet int64_to_nativeint x =\n if int64_is_representable_as_nativeint x\n then Some (int64_to_nativeint_trunc x)\n else None\n;;\n\nlet int64_to_nativeint_exn x =\n if int64_is_representable_as_nativeint x\n then int64_to_nativeint_trunc x\n else int64_to_nativeint_failure x\n;;\n\n(* int64 <-> int63 *)\n\nlet int64_to_int63_failure x = convert_failure x \"int64\" \"int63\" int64_to_string\n\nlet int64_is_representable_as_int63 =\n let min = Caml.Int64.shift_right min_int64 1 in\n let max = Caml.Int64.shift_right max_int64 1 in\n fun x -> compare_int64 min x <= 0 && compare_int64 x max <= 0\n;;\n\nlet int64_fit_on_int63_exn x =\n if int64_is_representable_as_int63 x then () else int64_to_int63_failure x\n;;\n\n(* string conversions *)\n\nlet insert_delimiter_every input ~delimiter ~chars_per_delimiter =\n let input_length = String.length input in\n if input_length <= chars_per_delimiter\n then input\n else (\n let has_sign =\n match input.[0] with\n | '+' | '-' -> true\n | _ -> false\n in\n let num_digits = if has_sign then input_length - 1 else input_length in\n let num_delimiters = (num_digits - 1) / chars_per_delimiter in\n let output_length = input_length + num_delimiters in\n let output = Bytes.create output_length in\n let input_pos = ref (input_length - 1) in\n let output_pos = ref (output_length - 1) in\n let num_chars_until_delimiter = ref chars_per_delimiter in\n let first_digit_pos = if has_sign then 1 else 0 in\n while !input_pos >= first_digit_pos do\n if !num_chars_until_delimiter = 0\n then (\n Bytes.set output !output_pos delimiter;\n decr output_pos;\n num_chars_until_delimiter := chars_per_delimiter);\n Bytes.set output !output_pos input.[!input_pos];\n decr input_pos;\n decr output_pos;\n decr num_chars_until_delimiter\n done;\n if has_sign then Bytes.set output 0 input.[0];\n Bytes.unsafe_to_string ~no_mutation_while_string_reachable:output)\n;;\n\nlet insert_delimiter input ~delimiter =\n insert_delimiter_every input ~delimiter ~chars_per_delimiter:3\n;;\n\nlet insert_underscores input = insert_delimiter input ~delimiter:'_'\nlet sexp_of_int_style = Sexp.of_int_style\n\nmodule Make (I : sig\n type t\n\n val to_string : t -> string\n end) =\nstruct\n open I\n\n let chars_per_delimiter = 3\n\n let to_string_hum ?(delimiter = '_') t =\n insert_delimiter_every (to_string t) ~delimiter ~chars_per_delimiter\n ;;\n\n let sexp_of_t t =\n let s = to_string t in\n Sexp.Atom\n (match !sexp_of_int_style with\n | `Underscores -> insert_delimiter_every s ~chars_per_delimiter ~delimiter:'_'\n | `No_underscores -> s)\n ;;\nend\n\nmodule Make_hex (I : sig\n type t [@@deriving_inline compare, hash]\n\n val compare : t -> t -> int\n val hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state\n val hash : t -> Ppx_hash_lib.Std.Hash.hash_value\n\n [@@@end]\n\n val to_string : t -> string\n val of_string : string -> t\n val zero : t\n val ( < ) : t -> t -> bool\n val neg : t -> t\n val module_name : string\n end) =\nstruct\n module T_hex = struct\n type t = I.t [@@deriving_inline compare, hash]\n\n let compare = (I.compare : t -> t -> int)\n\n let (hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state) =\n I.hash_fold_t\n\n and (hash : t -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func = I.hash in\n fun x -> func x\n ;;\n\n [@@@end]\n\n let chars_per_delimiter = 4\n\n let to_string' ?delimiter t =\n let make_suffix =\n match delimiter with\n | None -> I.to_string\n | Some delimiter ->\n fun t -> insert_delimiter_every (I.to_string t) ~delimiter ~chars_per_delimiter\n in\n if I.( < ) t I.zero then \"-0x\" ^ make_suffix (I.neg t) else \"0x\" ^ make_suffix t\n ;;\n\n let to_string t = to_string' t ?delimiter:None\n let to_string_hum ?(delimiter = '_') t = to_string' t ~delimiter\n\n let invalid str =\n Printf.failwithf \"%s.of_string: invalid input %S\" I.module_name str ()\n ;;\n\n let of_string_with_delimiter str =\n I.of_string (String.filter str ~f:(fun c -> Char.( <> ) c '_'))\n ;;\n\n let of_string str =\n let module L = Hex_lexer in\n let lex = Caml.Lexing.from_string str in\n let result = Option.try_with (fun () -> L.parse_hex lex) in\n if lex.lex_curr_pos = lex.lex_buffer_len\n then (\n match result with\n | None -> invalid str\n | Some (Neg body) -> I.neg (of_string_with_delimiter body)\n | Some (Pos body) -> of_string_with_delimiter body)\n else invalid str\n ;;\n end\n\n module Hex = struct\n include T_hex\n include Sexpable.Of_stringable (T_hex)\n end\nend\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* An alias for the type of lists. *)\ntype 'a t = 'a list = [] | (::) of 'a * 'a list\n\n(* List operations *)\n\nlet rec length_aux len = function\n [] -> len\n | _::l -> length_aux (len + 1) l\n\nlet length l = length_aux 0 l\n\nlet cons a l = a::l\n\nlet hd = function\n [] -> failwith \"hd\"\n | a::_ -> a\n\nlet tl = function\n [] -> failwith \"tl\"\n | _::l -> l\n\nlet nth l n =\n if n < 0 then invalid_arg \"List.nth\" else\n let rec nth_aux l n =\n match l with\n | [] -> failwith \"nth\"\n | a::l -> if n = 0 then a else nth_aux l (n-1)\n in nth_aux l n\n\nlet nth_opt l n =\n if n < 0 then invalid_arg \"List.nth\" else\n let rec nth_aux l n =\n match l with\n | [] -> None\n | a::l -> if n = 0 then Some a else nth_aux l (n-1)\n in nth_aux l n\n\nlet append = (@)\n\nlet rec rev_append l1 l2 =\n match l1 with\n [] -> l2\n | a :: l -> rev_append l (a :: l2)\n\nlet rev l = rev_append l []\n\nlet rec init_tailrec_aux acc i n f =\n if i >= n then acc\n else init_tailrec_aux (f i :: acc) (i+1) n f\n\nlet rec init_aux i n f =\n if i >= n then []\n else\n let r = f i in\n r :: init_aux (i+1) n f\n\nlet rev_init_threshold =\n match Sys.backend_type with\n | Sys.Native | Sys.Bytecode -> 10_000\n (* We don't know the size of the stack, better be safe and assume it's\n small. *)\n | Sys.Other _ -> 50\n\nlet init len f =\n if len < 0 then invalid_arg \"List.init\" else\n if len > rev_init_threshold then rev (init_tailrec_aux [] 0 len f)\n else init_aux 0 len f\n\nlet rec flatten = function\n [] -> []\n | l::r -> l @ flatten r\n\nlet concat = flatten\n\nlet rec map f = function\n [] -> []\n | a::l -> let r = f a in r :: map f l\n\nlet rec mapi i f = function\n [] -> []\n | a::l -> let r = f i a in r :: mapi (i + 1) f l\n\nlet mapi f l = mapi 0 f l\n\nlet rev_map f l =\n let rec rmap_f accu = function\n | [] -> accu\n | a::l -> rmap_f (f a :: accu) l\n in\n rmap_f [] l\n\n\nlet rec iter f = function\n [] -> ()\n | a::l -> f a; iter f l\n\nlet rec iteri i f = function\n [] -> ()\n | a::l -> f i a; iteri (i + 1) f l\n\nlet iteri f l = iteri 0 f l\n\nlet rec fold_left f accu l =\n match l with\n [] -> accu\n | a::l -> fold_left f (f accu a) l\n\nlet rec fold_right f l accu =\n match l with\n [] -> accu\n | a::l -> f a (fold_right f l accu)\n\nlet rec map2 f l1 l2 =\n match (l1, l2) with\n ([], []) -> []\n | (a1::l1, a2::l2) -> let r = f a1 a2 in r :: map2 f l1 l2\n | (_, _) -> invalid_arg \"List.map2\"\n\nlet rev_map2 f l1 l2 =\n let rec rmap2_f accu l1 l2 =\n match (l1, l2) with\n | ([], []) -> accu\n | (a1::l1, a2::l2) -> rmap2_f (f a1 a2 :: accu) l1 l2\n | (_, _) -> invalid_arg \"List.rev_map2\"\n in\n rmap2_f [] l1 l2\n\n\nlet rec iter2 f l1 l2 =\n match (l1, l2) with\n ([], []) -> ()\n | (a1::l1, a2::l2) -> f a1 a2; iter2 f l1 l2\n | (_, _) -> invalid_arg \"List.iter2\"\n\nlet rec fold_left2 f accu l1 l2 =\n match (l1, l2) with\n ([], []) -> accu\n | (a1::l1, a2::l2) -> fold_left2 f (f accu a1 a2) l1 l2\n | (_, _) -> invalid_arg \"List.fold_left2\"\n\nlet rec fold_right2 f l1 l2 accu =\n match (l1, l2) with\n ([], []) -> accu\n | (a1::l1, a2::l2) -> f a1 a2 (fold_right2 f l1 l2 accu)\n | (_, _) -> invalid_arg \"List.fold_right2\"\n\nlet rec for_all p = function\n [] -> true\n | a::l -> p a && for_all p l\n\nlet rec exists p = function\n [] -> false\n | a::l -> p a || exists p l\n\nlet rec for_all2 p l1 l2 =\n match (l1, l2) with\n ([], []) -> true\n | (a1::l1, a2::l2) -> p a1 a2 && for_all2 p l1 l2\n | (_, _) -> invalid_arg \"List.for_all2\"\n\nlet rec exists2 p l1 l2 =\n match (l1, l2) with\n ([], []) -> false\n | (a1::l1, a2::l2) -> p a1 a2 || exists2 p l1 l2\n | (_, _) -> invalid_arg \"List.exists2\"\n\nlet rec mem x = function\n [] -> false\n | a::l -> compare a x = 0 || mem x l\n\nlet rec memq x = function\n [] -> false\n | a::l -> a == x || memq x l\n\nlet rec assoc x = function\n [] -> raise Not_found\n | (a,b)::l -> if compare a x = 0 then b else assoc x l\n\nlet rec assoc_opt x = function\n [] -> None\n | (a,b)::l -> if compare a x = 0 then Some b else assoc_opt x l\n\nlet rec assq x = function\n [] -> raise Not_found\n | (a,b)::l -> if a == x then b else assq x l\n\nlet rec assq_opt x = function\n [] -> None\n | (a,b)::l -> if a == x then Some b else assq_opt x l\n\nlet rec mem_assoc x = function\n | [] -> false\n | (a, _) :: l -> compare a x = 0 || mem_assoc x l\n\nlet rec mem_assq x = function\n | [] -> false\n | (a, _) :: l -> a == x || mem_assq x l\n\nlet rec remove_assoc x = function\n | [] -> []\n | (a, _ as pair) :: l ->\n if compare a x = 0 then l else pair :: remove_assoc x l\n\nlet rec remove_assq x = function\n | [] -> []\n | (a, _ as pair) :: l -> if a == x then l else pair :: remove_assq x l\n\nlet rec find p = function\n | [] -> raise Not_found\n | x :: l -> if p x then x else find p l\n\nlet rec find_opt p = function\n | [] -> None\n | x :: l -> if p x then Some x else find_opt p l\n\nlet rec find_map f = function\n | [] -> None\n | x :: l ->\n begin match f x with\n | Some _ as result -> result\n | None -> find_map f l\n end\n\nlet find_all p =\n let rec find accu = function\n | [] -> rev accu\n | x :: l -> if p x then find (x :: accu) l else find accu l in\n find []\n\nlet filter = find_all\n\nlet filteri p l =\n let rec aux i acc = function\n | [] -> rev acc\n | x::l -> aux (i + 1) (if p i x then x::acc else acc) l\n in\n aux 0 [] l\n\nlet filter_map f =\n let rec aux accu = function\n | [] -> rev accu\n | x :: l ->\n match f x with\n | None -> aux accu l\n | Some v -> aux (v :: accu) l\n in\n aux []\n\nlet concat_map f l =\n let rec aux f acc = function\n | [] -> rev acc\n | x :: l ->\n let xs = f x in\n aux f (rev_append xs acc) l\n in aux f [] l\n\nlet fold_left_map f accu l =\n let rec aux accu l_accu = function\n | [] -> accu, rev l_accu\n | x :: l ->\n let accu, x = f accu x in\n aux accu (x :: l_accu) l in\n aux accu [] l\n\nlet partition p l =\n let rec part yes no = function\n | [] -> (rev yes, rev no)\n | x :: l -> if p x then part (x :: yes) no l else part yes (x :: no) l in\n part [] [] l\n\nlet partition_map p l =\n let rec part left right = function\n | [] -> (rev left, rev right)\n | x :: l ->\n begin match p x with\n | Either.Left v -> part (v :: left) right l\n | Either.Right v -> part left (v :: right) l\n end\n in\n part [] [] l\n\nlet rec split = function\n [] -> ([], [])\n | (x,y)::l ->\n let (rx, ry) = split l in (x::rx, y::ry)\n\nlet rec combine l1 l2 =\n match (l1, l2) with\n ([], []) -> []\n | (a1::l1, a2::l2) -> (a1, a2) :: combine l1 l2\n | (_, _) -> invalid_arg \"List.combine\"\n\n(** sorting *)\n\nlet rec merge cmp l1 l2 =\n match l1, l2 with\n | [], l2 -> l2\n | l1, [] -> l1\n | h1 :: t1, h2 :: t2 ->\n if cmp h1 h2 <= 0\n then h1 :: merge cmp t1 l2\n else h2 :: merge cmp l1 t2\n\n\nlet stable_sort cmp l =\n let rec rev_merge l1 l2 accu =\n match l1, l2 with\n | [], l2 -> rev_append l2 accu\n | l1, [] -> rev_append l1 accu\n | h1::t1, h2::t2 ->\n if cmp h1 h2 <= 0\n then rev_merge t1 l2 (h1::accu)\n else rev_merge l1 t2 (h2::accu)\n in\n let rec rev_merge_rev l1 l2 accu =\n match l1, l2 with\n | [], l2 -> rev_append l2 accu\n | l1, [] -> rev_append l1 accu\n | h1::t1, h2::t2 ->\n if cmp h1 h2 > 0\n then rev_merge_rev t1 l2 (h1::accu)\n else rev_merge_rev l1 t2 (h2::accu)\n in\n let rec sort n l =\n match n, l with\n | 2, x1 :: x2 :: tl ->\n let s = if cmp x1 x2 <= 0 then [x1; x2] else [x2; x1] in\n (s, tl)\n | 3, x1 :: x2 :: x3 :: tl ->\n let s =\n if cmp x1 x2 <= 0 then\n if cmp x2 x3 <= 0 then [x1; x2; x3]\n else if cmp x1 x3 <= 0 then [x1; x3; x2]\n else [x3; x1; x2]\n else if cmp x1 x3 <= 0 then [x2; x1; x3]\n else if cmp x2 x3 <= 0 then [x2; x3; x1]\n else [x3; x2; x1]\n in\n (s, tl)\n | n, l ->\n let n1 = n asr 1 in\n let n2 = n - n1 in\n let s1, l2 = rev_sort n1 l in\n let s2, tl = rev_sort n2 l2 in\n (rev_merge_rev s1 s2 [], tl)\n and rev_sort n l =\n match n, l with\n | 2, x1 :: x2 :: tl ->\n let s = if cmp x1 x2 > 0 then [x1; x2] else [x2; x1] in\n (s, tl)\n | 3, x1 :: x2 :: x3 :: tl ->\n let s =\n if cmp x1 x2 > 0 then\n if cmp x2 x3 > 0 then [x1; x2; x3]\n else if cmp x1 x3 > 0 then [x1; x3; x2]\n else [x3; x1; x2]\n else if cmp x1 x3 > 0 then [x2; x1; x3]\n else if cmp x2 x3 > 0 then [x2; x3; x1]\n else [x3; x2; x1]\n in\n (s, tl)\n | n, l ->\n let n1 = n asr 1 in\n let n2 = n - n1 in\n let s1, l2 = sort n1 l in\n let s2, tl = sort n2 l2 in\n (rev_merge s1 s2 [], tl)\n in\n let len = length l in\n if len < 2 then l else fst (sort len l)\n\n\nlet sort = stable_sort\nlet fast_sort = stable_sort\n\n(* Note: on a list of length between about 100000 (depending on the minor\n heap size and the type of the list) and Sys.max_array_size, it is\n actually faster to use the following, but it might also use more memory\n because the argument list cannot be deallocated incrementally.\n\n Also, there seems to be a bug in this code or in the\n implementation of obj_truncate.\n\nexternal obj_truncate : 'a array -> int -> unit = \"caml_obj_truncate\"\n\nlet array_to_list_in_place a =\n let l = Array.length a in\n let rec loop accu n p =\n if p <= 0 then accu else begin\n if p = n then begin\n obj_truncate a p;\n loop (a.(p-1) :: accu) (n-1000) (p-1)\n end else begin\n loop (a.(p-1) :: accu) n (p-1)\n end\n end\n in\n loop [] (l-1000) l\n\n\nlet stable_sort cmp l =\n let a = Array.of_list l in\n Array.stable_sort cmp a;\n array_to_list_in_place a\n\n*)\n\n\n(** sorting + removing duplicates *)\n\nlet sort_uniq cmp l =\n let rec rev_merge l1 l2 accu =\n match l1, l2 with\n | [], l2 -> rev_append l2 accu\n | l1, [] -> rev_append l1 accu\n | h1::t1, h2::t2 ->\n let c = cmp h1 h2 in\n if c = 0 then rev_merge t1 t2 (h1::accu)\n else if c < 0\n then rev_merge t1 l2 (h1::accu)\n else rev_merge l1 t2 (h2::accu)\n in\n let rec rev_merge_rev l1 l2 accu =\n match l1, l2 with\n | [], l2 -> rev_append l2 accu\n | l1, [] -> rev_append l1 accu\n | h1::t1, h2::t2 ->\n let c = cmp h1 h2 in\n if c = 0 then rev_merge_rev t1 t2 (h1::accu)\n else if c > 0\n then rev_merge_rev t1 l2 (h1::accu)\n else rev_merge_rev l1 t2 (h2::accu)\n in\n let rec sort n l =\n match n, l with\n | 2, x1 :: x2 :: tl ->\n let s =\n let c = cmp x1 x2 in\n if c = 0 then [x1] else if c < 0 then [x1; x2] else [x2; x1]\n in\n (s, tl)\n | 3, x1 :: x2 :: x3 :: tl ->\n let s =\n let c = cmp x1 x2 in\n if c = 0 then\n let c = cmp x2 x3 in\n if c = 0 then [x2] else if c < 0 then [x2; x3] else [x3; x2]\n else if c < 0 then\n let c = cmp x2 x3 in\n if c = 0 then [x1; x2]\n else if c < 0 then [x1; x2; x3]\n else\n let c = cmp x1 x3 in\n if c = 0 then [x1; x2]\n else if c < 0 then [x1; x3; x2]\n else [x3; x1; x2]\n else\n let c = cmp x1 x3 in\n if c = 0 then [x2; x1]\n else if c < 0 then [x2; x1; x3]\n else\n let c = cmp x2 x3 in\n if c = 0 then [x2; x1]\n else if c < 0 then [x2; x3; x1]\n else [x3; x2; x1]\n in\n (s, tl)\n | n, l ->\n let n1 = n asr 1 in\n let n2 = n - n1 in\n let s1, l2 = rev_sort n1 l in\n let s2, tl = rev_sort n2 l2 in\n (rev_merge_rev s1 s2 [], tl)\n and rev_sort n l =\n match n, l with\n | 2, x1 :: x2 :: tl ->\n let s =\n let c = cmp x1 x2 in\n if c = 0 then [x1] else if c > 0 then [x1; x2] else [x2; x1]\n in\n (s, tl)\n | 3, x1 :: x2 :: x3 :: tl ->\n let s =\n let c = cmp x1 x2 in\n if c = 0 then\n let c = cmp x2 x3 in\n if c = 0 then [x2] else if c > 0 then [x2; x3] else [x3; x2]\n else if c > 0 then\n let c = cmp x2 x3 in\n if c = 0 then [x1; x2]\n else if c > 0 then [x1; x2; x3]\n else\n let c = cmp x1 x3 in\n if c = 0 then [x1; x2]\n else if c > 0 then [x1; x3; x2]\n else [x3; x1; x2]\n else\n let c = cmp x1 x3 in\n if c = 0 then [x2; x1]\n else if c > 0 then [x2; x1; x3]\n else\n let c = cmp x2 x3 in\n if c = 0 then [x2; x1]\n else if c > 0 then [x2; x3; x1]\n else [x3; x2; x1]\n in\n (s, tl)\n | n, l ->\n let n1 = n asr 1 in\n let n2 = n - n1 in\n let s1, l2 = sort n1 l in\n let s2, tl = sort n2 l2 in\n (rev_merge s1 s2 [], tl)\n in\n let len = length l in\n if len < 2 then l else fst (sort len l)\n\n\nlet rec compare_lengths l1 l2 =\n match l1, l2 with\n | [], [] -> 0\n | [], _ -> -1\n | _, [] -> 1\n | _ :: l1, _ :: l2 -> compare_lengths l1 l2\n;;\n\nlet rec compare_length_with l n =\n match l with\n | [] ->\n if n = 0 then 0 else\n if n > 0 then -1 else 1\n | _ :: l ->\n if n <= 0 then 1 else\n compare_length_with l (n-1)\n;;\n\n(** {1 Comparison} *)\n\n(* Note: we are *not* shortcutting the list by using\n [List.compare_lengths] first; this may be slower on long lists\n immediately start with distinct elements. It is also incorrect for\n [compare] below, and it is better (principle of least surprise) to\n use the same approach for both functions. *)\nlet rec equal eq l1 l2 =\n match l1, l2 with\n | [], [] -> true\n | [], _::_ | _::_, [] -> false\n | a1::l1, a2::l2 -> eq a1 a2 && equal eq l1 l2\n\nlet rec compare cmp l1 l2 =\n match l1, l2 with\n | [], [] -> 0\n | [], _::_ -> -1\n | _::_, [] -> 1\n | a1::l1, a2::l2 ->\n let c = cmp a1 a2 in\n if c <> 0 then c\n else compare cmp l1 l2\n\n(** {1 Iterators} *)\n\nlet to_seq l =\n let rec aux l () = match l with\n | [] -> Seq.Nil\n | x :: tail -> Seq.Cons (x, aux tail)\n in\n aux l\n\nlet of_seq seq =\n let rec direct depth seq : _ list =\n if depth=0\n then\n Seq.fold_left (fun acc x -> x::acc) [] seq\n |> rev (* tailrec *)\n else match seq() with\n | Seq.Nil -> []\n | Seq.Cons (x, next) -> x :: direct (depth-1) next\n in\n direct 500 seq\n","include Base\ninclude Ppxlib\ninclude Ast_builder.Default\n\n(* errors and error messages *)\n\nlet ( ^^ ) = Caml.( ^^ )\nlet error ~loc fmt = Location.raise_errorf ~loc (\"ppx_quickcheck: \" ^^ fmt)\nlet invalid ~loc fmt = error ~loc (\"invalid syntax: \" ^^ fmt)\nlet unsupported ~loc fmt = error ~loc (\"unsupported: \" ^^ fmt)\nlet internal_error ~loc fmt = error ~loc (\"internal error: \" ^^ fmt)\n\nlet short_string_of_core_type core_type =\n match core_type.ptyp_desc with\n | Ptyp_any -> \"wildcard type\"\n | Ptyp_var _ -> \"type variable\"\n | Ptyp_arrow _ -> \"function type\"\n | Ptyp_tuple _ -> \"tuple type\"\n | Ptyp_constr _ -> \"type name\"\n | Ptyp_object _ -> \"object type\"\n | Ptyp_class _ -> \"class type\"\n | Ptyp_alias _ -> \"type variable alias\"\n | Ptyp_variant _ -> \"polymorphic variant\"\n | Ptyp_poly _ -> \"explicit polymorphic type\"\n | Ptyp_package _ -> \"first-class module type\"\n | Ptyp_extension _ -> \"ppx extension type\"\n;;\n\n(* little syntax helpers *)\n\nlet loc_map { loc; txt } ~f = { loc; txt = f txt }\nlet lident_loc = loc_map ~f:lident\n\nlet prefixed_type_name prefix type_name =\n match type_name with\n | \"t\" -> prefix\n | _ -> prefix ^ \"_\" ^ type_name\n;;\n\nlet generator_name type_name = prefixed_type_name \"quickcheck_generator\" type_name\nlet observer_name type_name = prefixed_type_name \"quickcheck_observer\" type_name\nlet shrinker_name type_name = prefixed_type_name \"quickcheck_shrinker\" type_name\nlet pname { loc; txt } ~f = pvar ~loc (f txt)\nlet ename { loc; txt } ~f = evar ~loc (f txt)\nlet pgenerator = pname ~f:generator_name\nlet pobserver = pname ~f:observer_name\nlet pshrinker = pname ~f:shrinker_name\nlet egenerator = ename ~f:generator_name\nlet eobserver = ename ~f:observer_name\nlet eshrinker = ename ~f:shrinker_name\n\nlet ptuple ~loc list =\n match list with\n | [] -> [%pat? ()]\n | [ pat ] -> pat\n | _ -> ppat_tuple ~loc list\n;;\n\n(* creating (probably-)unique symbols for generated code *)\n\nlet gensym prefix loc =\n let loc = { loc with loc_ghost = true } in\n let sym = gen_symbol ~prefix:(\"_\" ^ prefix) () in\n pvar ~loc sym, evar ~loc sym\n;;\n\nlet gensyms prefix loc_list = List.map loc_list ~f:(gensym prefix) |> List.unzip\n\nlet gensymss prefix loc_list_list =\n List.map loc_list_list ~f:(gensyms prefix) |> List.unzip\n;;\n\n(* expression to create a higher order function that maps from function with one kind of\n argument label to another *)\n\nlet fn_map_label ~loc ~from ~to_ =\n let f_pat, f_expr = gensym \"f\" loc in\n let x_pat, x_expr = gensym \"x\" loc in\n pexp_fun\n ~loc\n Nolabel\n None\n f_pat\n (pexp_fun ~loc to_ None x_pat (pexp_apply ~loc f_expr [ from, x_expr ]))\n;;\n","(* [Sys0] defines functions that are primitives or can be simply defined in\n terms of [Caml.Sys]. [Sys0] is intended to completely express the part of\n [Caml.Sys] that [Base] uses -- no other file in Base other than sys.ml\n should use [Caml.Sys]. [Sys0] has few dependencies, and so is available\n early in Base's build order. All Base files that need to use these\n functions and come before [Base.Sys] in build order should do\n [module Sys = Sys0]. Defining [module Sys = Sys0] is also necessary because\n it prevents ocamldep from mistakenly causing a file to depend on [Base.Sys]. *)\n\nopen! Import0\n\ntype backend_type = Caml.Sys.backend_type =\n | Native\n | Bytecode\n | Other of string\n\nlet backend_type = Caml.Sys.backend_type\nlet interactive = Caml.Sys.interactive\nlet os_type = Caml.Sys.os_type\nlet unix = Caml.Sys.unix\nlet win32 = Caml.Sys.win32\nlet cygwin = Caml.Sys.cygwin\nlet word_size_in_bits = Caml.Sys.word_size\nlet int_size_in_bits = Caml.Sys.int_size\nlet big_endian = Caml.Sys.big_endian\nlet max_string_length = Caml.Sys.max_string_length\nlet max_array_length = Caml.Sys.max_array_length\nlet runtime_variant = Caml.Sys.runtime_variant\nlet runtime_parameters = Caml.Sys.runtime_parameters\nlet argv = Caml.Sys.argv\nlet get_argv () = Caml.Sys.argv\nlet ocaml_version = Caml.Sys.ocaml_version\nlet enable_runtime_warnings = Caml.Sys.enable_runtime_warnings\nlet runtime_warnings_enabled = Caml.Sys.runtime_warnings_enabled\n\nlet getenv_exn var =\n try Caml.Sys.getenv var with\n | Caml.Not_found ->\n Printf.failwithf \"Sys.getenv_exn: environment variable %s is not set\" var ()\n;;\n\nlet getenv var =\n match Caml.Sys.getenv var with\n | x -> Some x\n | exception Caml.Not_found -> None\n;;\n\nexternal opaque_identity : 'a -> 'a = \"%opaque\"\n\nexception Break = Caml.Sys.Break\n","(* Write_ml: writing values to the binary protocol using (mostly) OCaml. *)\n\n(* Note: the code is this file is carefully written to avoid unnecessary allocations. When\n touching this code, be sure to run the benchmarks to check for regressions. *)\n\nopen Bigarray\nopen Common\n\ntype 'a writer = buf -> pos:pos -> 'a -> pos\ntype ('a, 'b) writer1 = 'a writer -> 'b writer\ntype ('a, 'b, 'c) writer2 = 'a writer -> ('b, 'c) writer1\ntype ('a, 'b, 'c, 'd) writer3 = 'a writer -> ('b, 'c, 'd) writer2\n\nexternal unsafe_set : buf -> int -> char -> unit = \"%caml_ba_unsafe_set_1\"\nexternal unsafe_set8 : buf -> int -> int -> unit = \"%caml_ba_unsafe_set_1\"\nexternal unsafe_set16 : buf -> int -> int -> unit = \"%caml_bigstring_set16u\"\nexternal unsafe_set32 : buf -> int -> int32 -> unit = \"%caml_bigstring_set32u\"\nexternal unsafe_set64 : buf -> int -> int64 -> unit = \"%caml_bigstring_set64u\"\nexternal bswap16 : int -> int = \"%bswap16\"\nexternal bswap32 : int32 -> int32 = \"%bswap_int32\"\nexternal bswap64 : int64 -> int64 = \"%bswap_int64\"\n\n(*$ open Bin_prot_cinaps $*)\n\nlet code_NEG_INT8 = (*$ Code.char NEG_INT8 *) '\\xff' (*$*)\n\nlet code_INT16 = (*$ Code.char INT16 *) '\\xfe' (*$*)\n\nlet code_INT32 = (*$ Code.char INT32 *) '\\xfd' (*$*)\n\nlet code_INT64 = (*$ Code.char INT64 *) '\\xfc' (*$*)\n\nlet arch_sixtyfour = Sys.word_size = 64\nlet arch_big_endian = Sys.big_endian\n\nlet unsafe_set16be =\n if arch_big_endian\n then unsafe_set16\n else fun buf pos x -> unsafe_set16 buf pos (bswap16 x)\n;;\n\nlet unsafe_set32be =\n if arch_big_endian\n then unsafe_set32\n else fun buf pos x -> unsafe_set32 buf pos (bswap32 x)\n;;\n\nlet unsafe_set64be =\n if arch_big_endian\n then unsafe_set64\n else fun buf pos x -> unsafe_set64 buf pos (bswap64 x)\n;;\n\nlet unsafe_set16le =\n if arch_big_endian\n then fun buf pos x -> unsafe_set16 buf pos (bswap16 x)\n else unsafe_set16\n;;\n\nlet unsafe_set32le =\n if arch_big_endian\n then fun buf pos x -> unsafe_set32 buf pos (bswap32 x)\n else unsafe_set32\n;;\n\nlet unsafe_set64le =\n if arch_big_endian\n then fun buf pos x -> unsafe_set64 buf pos (bswap64 x)\n else unsafe_set64\n;;\n\nlet bin_write_unit buf ~pos () =\n assert_pos pos;\n check_pos buf pos;\n unsafe_set buf pos '\\000';\n pos + 1\n;;\n\nlet bin_write_bool buf ~pos b =\n assert_pos pos;\n check_pos buf pos;\n unsafe_set buf pos (if b then '\\001' else '\\000');\n pos + 1\n;;\n\nlet all_bin_write_small_int buf pos n =\n check_pos buf pos;\n unsafe_set8 buf pos n;\n pos + 1\n;;\n\nlet all_bin_write_neg_int8 buf pos n =\n let next = pos + 2 in\n check_next buf next;\n unsafe_set buf pos code_NEG_INT8;\n unsafe_set8 buf (pos + 1) n;\n next\n;;\n\nlet all_bin_write_int16 buf pos n =\n let next = pos + 3 in\n check_next buf next;\n unsafe_set buf pos code_INT16;\n unsafe_set16le buf (pos + 1) n;\n next\n;;\n\nlet all_bin_write_int32 buf pos n =\n let next = pos + 5 in\n check_next buf next;\n unsafe_set buf pos code_INT32;\n unsafe_set32le buf (pos + 1) n;\n next\n[@@inline]\n;;\n\nlet all_bin_write_int64 buf pos n =\n let next = pos + 9 in\n check_next buf next;\n unsafe_set buf pos code_INT64;\n unsafe_set64le buf (pos + 1) n;\n next\n[@@inline]\n;;\n\nlet bin_write_char buf ~pos c =\n assert_pos pos;\n check_pos buf pos;\n unsafe_set buf pos c;\n pos + 1\n;;\n\nlet bin_write_int buf ~pos n =\n assert_pos pos;\n if n >= 0\n then\n if n < 0x00000080\n then all_bin_write_small_int buf pos n\n else if n < 0x00008000\n then all_bin_write_int16 buf pos n\n else if arch_sixtyfour && n >= 1 lsl 31\n then all_bin_write_int64 buf pos (Int64.of_int n)\n else all_bin_write_int32 buf pos (Int32.of_int n)\n else if n >= -0x00000080\n then all_bin_write_neg_int8 buf pos n\n else if n >= -0x00008000\n then all_bin_write_int16 buf pos n\n else if arch_sixtyfour && n < -(1 lsl 31)\n then all_bin_write_int64 buf pos (Int64.of_int n)\n else all_bin_write_int32 buf pos (Int32.of_int n)\n;;\n\nlet bin_write_nat0 buf ~pos nat0 =\n assert_pos pos;\n let n = (nat0 : Nat0.t :> int) in\n if n < 0x00000080\n then all_bin_write_small_int buf pos n\n else if n < 0x00010000\n then all_bin_write_int16 buf pos n\n else if arch_sixtyfour && n >= 1 lsl 32\n then all_bin_write_int64 buf pos (Int64.of_int n)\n else all_bin_write_int32 buf pos (Int32.of_int n)\n;;\n\nlet bin_write_string buf ~pos str =\n let len = String.length str in\n let plen = Nat0.unsafe_of_int len in\n let new_pos = bin_write_nat0 buf ~pos plen in\n let next = new_pos + len in\n check_next buf next;\n (* TODO: optimize for small strings *)\n unsafe_blit_string_buf ~src_pos:0 str ~dst_pos:new_pos buf ~len;\n next\n;;\n\nlet bin_write_bytes buf ~pos str =\n let len = Bytes.length str in\n let plen = Nat0.unsafe_of_int len in\n let new_pos = bin_write_nat0 buf ~pos plen in\n let next = new_pos + len in\n check_next buf next;\n (* TODO: optimize for small bytes *)\n unsafe_blit_bytes_buf ~src_pos:0 str ~dst_pos:new_pos buf ~len;\n next\n;;\n\nlet bin_write_float buf ~pos x =\n assert_pos pos;\n let next = pos + 8 in\n check_next buf next;\n unsafe_set64le buf pos (Int64.bits_of_float x);\n next\n[@@inline]\n;;\n\nlet bin_write_int32 =\n if arch_sixtyfour\n then fun [@inline] buf ~pos n -> bin_write_int buf ~pos (Int32.to_int n)\n else\n fun [@inline] buf ~pos n ->\n if n >= 0x00008000l || n < -0x00008000l\n then (\n assert_pos pos;\n all_bin_write_int32 buf pos n)\n else bin_write_int buf ~pos (Int32.to_int n)\n;;\n\nlet bin_write_int64 buf ~pos n =\n if n >= 0x80000000L || n < -0x80000000L\n then (\n assert_pos pos;\n all_bin_write_int64 buf pos n)\n else if arch_sixtyfour\n then bin_write_int buf ~pos (Int64.to_int n)\n else if n >= 0x00008000L || n < -0x00008000L\n then (\n assert_pos pos;\n all_bin_write_int32 buf pos (Int64.to_int32 n))\n else bin_write_int buf ~pos (Int64.to_int n)\n[@@inline]\n;;\n\nlet bin_write_nativeint buf ~pos n =\n if arch_sixtyfour\n && (n >= (* 0x80000000n *) Nativeint.shift_left 1n 31\n || n < (* -0x80000000n *) Nativeint.neg (Nativeint.shift_left 1n 31))\n then (\n assert_pos pos;\n all_bin_write_int64 buf pos (Int64.of_nativeint n))\n else if ((not arch_sixtyfour) && n >= 0x8000n) || n < -0x8000n\n then (\n assert_pos pos;\n all_bin_write_int32 buf pos (Nativeint.to_int32 n))\n else bin_write_int buf ~pos (Nativeint.to_int n)\n[@@inline]\n;;\n\nlet bin_write_ref bin_write_el buf ~pos r = bin_write_el buf ~pos !r\n\nlet bin_write_lazy bin_write_el buf ~pos lv =\n let v = Lazy.force lv in\n bin_write_el buf ~pos v\n;;\n\nlet bin_write_option bin_write_el buf ~pos = function\n | None -> bin_write_bool buf ~pos false\n | Some v ->\n let next = bin_write_bool buf ~pos true in\n bin_write_el buf ~pos:next v\n;;\n\nlet bin_write_pair bin_write_a bin_write_b buf ~pos (a, b) =\n let next = bin_write_a buf ~pos a in\n bin_write_b buf ~pos:next b\n;;\n\nlet bin_write_triple bin_write_a bin_write_b bin_write_c buf ~pos (a, b, c) =\n let next1 = bin_write_a buf ~pos a in\n let next2 = bin_write_b buf ~pos:next1 b in\n bin_write_c buf ~pos:next2 c\n;;\n\nlet bin_write_list bin_write_el buf ~pos lst =\n let rec loop els_pos = function\n | [] -> els_pos\n | h :: t ->\n let new_els_pos = bin_write_el buf ~pos:els_pos h in\n loop new_els_pos t\n in\n let len = Nat0.unsafe_of_int (List.length lst) in\n let els_pos = bin_write_nat0 buf ~pos len in\n loop els_pos lst\n;;\n\nlet bin_write_float_array buf ~pos a =\n let len = Array.length a in\n let plen = Nat0.unsafe_of_int len in\n let pos = bin_write_nat0 buf ~pos plen in\n let size = len * 8 in\n let next = pos + size in\n check_next buf next;\n unsafe_blit_float_array_buf a buf ~src_pos:0 ~dst_pos:pos ~len;\n next\n;;\n\nlet bin_write_array_loop bin_write_el buf ~els_pos ~n ar =\n let els_pos_ref = ref els_pos in\n for i = 0 to n - 1 do\n els_pos_ref := bin_write_el buf ~pos:!els_pos_ref (Array.unsafe_get ar i)\n done;\n !els_pos_ref\n;;\n\nlet bin_write_array (type a) bin_write_el buf ~pos ar =\n if (Obj.magic (bin_write_el : a writer) : float writer) == bin_write_float\n then bin_write_float_array buf ~pos (Obj.magic (ar : a array) : float array)\n else (\n let n = Array.length ar in\n let pn = Nat0.unsafe_of_int n in\n let els_pos = bin_write_nat0 buf ~pos pn in\n bin_write_array_loop bin_write_el buf ~els_pos ~n ar)\n;;\n\nlet bin_write_hashtbl bin_write_key bin_write_val buf ~pos htbl =\n let len = Hashtbl.length htbl in\n let plen = Nat0.unsafe_of_int len in\n let els_pos = bin_write_nat0 buf ~pos plen in\n let cnt_ref = ref 0 in\n let coll_htbl k v els_pos =\n incr cnt_ref;\n let new_els_pos = bin_write_key buf ~pos:els_pos k in\n bin_write_val buf ~pos:new_els_pos v\n in\n let res_pos = Hashtbl.fold coll_htbl htbl els_pos in\n if !cnt_ref <> len then raise_concurrent_modification \"bin_write_hashtbl\";\n res_pos\n;;\n\nexternal buf_of_vec32 : vec32 -> buf = \"%identity\"\nexternal buf_of_vec64 : vec64 -> buf = \"%identity\"\nexternal buf_of_mat32 : mat32 -> buf = \"%identity\"\nexternal buf_of_mat64 : mat64 -> buf = \"%identity\"\n\nlet bin_write_float32_vec buf ~pos v =\n let len = Array1.dim v in\n let plen = Nat0.unsafe_of_int len in\n let pos = bin_write_nat0 buf ~pos plen in\n let size = len * 4 in\n let next = pos + size in\n check_next buf next;\n unsafe_blit_buf ~src:(buf_of_vec32 v) ~src_pos:0 ~dst:buf ~dst_pos:pos ~len:size;\n next\n;;\n\nlet bin_write_float64_vec buf ~pos v =\n let len = Array1.dim v in\n let plen = Nat0.unsafe_of_int len in\n let pos = bin_write_nat0 buf ~pos plen in\n let size = len * 8 in\n let next = pos + size in\n check_next buf next;\n unsafe_blit_buf ~src:(buf_of_vec64 v) ~src_pos:0 ~dst:buf ~dst_pos:pos ~len:size;\n next\n;;\n\nlet bin_write_vec = bin_write_float64_vec\n\nlet bin_write_float32_mat buf ~pos m =\n let len1 = Array2.dim1 m in\n let len2 = Array2.dim2 m in\n let pos = bin_write_nat0 buf ~pos (Nat0.unsafe_of_int len1) in\n let pos = bin_write_nat0 buf ~pos (Nat0.unsafe_of_int len2) in\n let size = len1 * len2 * 4 in\n let next = pos + size in\n check_next buf next;\n unsafe_blit_buf ~src:(buf_of_mat32 m) ~src_pos:0 ~dst:buf ~dst_pos:pos ~len:size;\n next\n;;\n\nlet bin_write_float64_mat buf ~pos m =\n let len1 = Array2.dim1 m in\n let len2 = Array2.dim2 m in\n let pos = bin_write_nat0 buf ~pos (Nat0.unsafe_of_int len1) in\n let pos = bin_write_nat0 buf ~pos (Nat0.unsafe_of_int len2) in\n let size = len1 * len2 * 8 in\n let next = pos + size in\n check_next buf next;\n unsafe_blit_buf ~src:(buf_of_mat64 m) ~src_pos:0 ~dst:buf ~dst_pos:pos ~len:size;\n next\n;;\n\nlet bin_write_mat = bin_write_float64_mat\n\nlet bin_write_bigstring buf ~pos s =\n let len = Array1.dim s in\n let plen = Nat0.unsafe_of_int len in\n let pos = bin_write_nat0 buf ~pos plen in\n let next = pos + len in\n check_next buf next;\n unsafe_blit_buf ~src:s ~src_pos:0 ~dst:buf ~dst_pos:pos ~len;\n next\n;;\n\nlet bin_write_variant_int buf ~pos x =\n assert_pos pos;\n let next = pos + 4 in\n check_next buf next;\n unsafe_set32le buf pos (Int32.logor (Int32.shift_left (Int32.of_int x) 1) 1l);\n next\n;;\n\nlet bin_write_int_8bit buf ~pos n =\n assert_pos pos;\n check_pos buf pos;\n unsafe_set8 buf pos n;\n pos + 1\n;;\n\nlet bin_write_int_16bit buf ~pos n =\n assert_pos pos;\n let next = pos + 2 in\n check_next buf next;\n unsafe_set16le buf pos n;\n next\n;;\n\nlet bin_write_int_32bit buf ~pos n =\n assert_pos pos;\n let next = pos + 4 in\n check_next buf next;\n unsafe_set32le buf pos (Int32.of_int n);\n next\n;;\n\nlet bin_write_int_64bit buf ~pos n =\n assert_pos pos;\n let next = pos + 8 in\n check_next buf next;\n unsafe_set64le buf pos (Int64.of_int n);\n next\n;;\n\nlet bin_write_int64_bits buf ~pos n =\n assert_pos pos;\n let next = pos + 8 in\n check_next buf next;\n unsafe_set64le buf pos n;\n next\n;;\n\nlet bin_write_network16_int buf ~pos n =\n assert_pos pos;\n let next = pos + 2 in\n check_next buf next;\n unsafe_set16be buf pos n;\n next\n;;\n\nlet bin_write_network32_int buf ~pos n =\n assert_pos pos;\n let next = pos + 4 in\n check_next buf next;\n unsafe_set32be buf pos (Int32.of_int n);\n next\n;;\n\nlet bin_write_network32_int32 buf ~pos n =\n assert_pos pos;\n let next = pos + 4 in\n check_next buf next;\n unsafe_set32be buf pos n;\n next\n;;\n\nlet bin_write_network64_int buf ~pos n =\n assert_pos pos;\n let next = pos + 8 in\n check_next buf next;\n unsafe_set64be buf pos (Int64.of_int n);\n next\n;;\n\nlet bin_write_network64_int64 buf ~pos n =\n assert_pos pos;\n let next = pos + 8 in\n check_next buf next;\n unsafe_set64be buf pos n;\n next\n;;\n\nlet bin_write_array_no_length bin_write_el buf ~pos ar =\n bin_write_array_loop bin_write_el buf ~els_pos:pos ~n:(Array.length ar) ar\n;;\n\nexternal unsafe_string_get32 : string -> int -> int32 = \"%caml_string_get32u\"\nexternal unsafe_string_get64 : string -> int -> int64 = \"%caml_string_get64u\"\n\nlet bin_write_md5 buf ~pos x =\n let x = Md5_lib.to_binary x in\n assert (String.length x = 16);\n assert_pos pos;\n let next = pos + 16 in\n check_next buf next;\n if arch_sixtyfour\n then (\n let a = unsafe_string_get64 x 0 in\n let b = unsafe_string_get64 x 8 in\n unsafe_set64 buf pos a;\n unsafe_set64 buf (pos + 8) b)\n else (\n let a = unsafe_string_get32 x 0 in\n let b = unsafe_string_get32 x 4 in\n let c = unsafe_string_get32 x 8 in\n let d = unsafe_string_get32 x 12 in\n unsafe_set32 buf pos a;\n unsafe_set32 buf (pos + 4) b;\n unsafe_set32 buf (pos + 8) c;\n unsafe_set32 buf (pos + 12) d);\n next\n;;\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Damien Doligez, projet Para, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1997 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* Internals of forcing lazy values. *)\n\ntype 'a t = 'a lazy_t\n\nexception Undefined\n\nlet raise_undefined = Obj.repr (fun () -> raise Undefined)\n\nexternal make_forward : Obj.t -> Obj.t -> unit = \"caml_obj_make_forward\"\n\n(* Assume [blk] is a block with tag lazy *)\nlet force_lazy_block (blk : 'arg lazy_t) =\n let closure = (Obj.obj (Obj.field (Obj.repr blk) 0) : unit -> 'arg) in\n Obj.set_field (Obj.repr blk) 0 raise_undefined;\n try\n let result = closure () in\n make_forward (Obj.repr blk) (Obj.repr result);\n result\n with e ->\n Obj.set_field (Obj.repr blk) 0 (Obj.repr (fun () -> raise e));\n raise e\n\n\n(* Assume [blk] is a block with tag lazy *)\nlet force_val_lazy_block (blk : 'arg lazy_t) =\n let closure = (Obj.obj (Obj.field (Obj.repr blk) 0) : unit -> 'arg) in\n Obj.set_field (Obj.repr blk) 0 raise_undefined;\n let result = closure () in\n make_forward (Obj.repr blk) (Obj.repr result);\n result\n\n\n(* [force] is not used, since [Lazy.force] is declared as a primitive\n whose code inlines the tag tests of its argument, except when afl\n instrumentation is turned on. *)\n\nlet force (lzv : 'arg lazy_t) =\n (* Using [Sys.opaque_identity] prevents two potential problems:\n - If the value is known to have Forward_tag, then its tag could have\n changed during GC, so that information must be forgotten (see GPR#713\n and issue #7301)\n - If the value is known to be immutable, then if the compiler\n cannot prove that the last branch is not taken it will issue a\n warning 59 (modification of an immutable value) *)\n let lzv = Sys.opaque_identity lzv in\n let x = Obj.repr lzv in\n let t = Obj.tag x in\n if t = Obj.forward_tag then (Obj.obj (Obj.field x 0) : 'arg) else\n if t <> Obj.lazy_tag then (Obj.obj x : 'arg)\n else force_lazy_block lzv\n\n\nlet force_val (lzv : 'arg lazy_t) =\n let x = Obj.repr lzv in\n let t = Obj.tag x in\n if t = Obj.forward_tag then (Obj.obj (Obj.field x 0) : 'arg) else\n if t <> Obj.lazy_tag then (Obj.obj x : 'arg)\n else force_val_lazy_block lzv\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Damien Doligez, projet Para, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1997 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* Module [Lazy]: deferred computations *)\n\n\n(*\n WARNING: some purple magic is going on here. Do not take this file\n as an example of how to program in OCaml.\n*)\n\n\n(* We make use of two special tags provided by the runtime:\n [lazy_tag] and [forward_tag].\n\n A value of type ['a Lazy.t] can be one of three things:\n 1. A block of size 1 with tag [lazy_tag]. Its field is a closure of\n type [unit -> 'a] that computes the value.\n 2. A block of size 1 with tag [forward_tag]. Its field is the value\n of type ['a] that was computed.\n 3. Anything else except a float. This has type ['a] and is the value\n that was computed.\n Exceptions are stored in format (1).\n The GC will magically change things from (2) to (3) according to its\n fancy.\n\n If OCaml was configured with the -flat-float-array option (which is\n currently the default), the following is also true:\n We cannot use representation (3) for a [float Lazy.t] because\n [caml_make_array] assumes that only a [float] value can have tag\n [Double_tag].\n\n We have to use the built-in type constructor [lazy_t] to\n let the compiler implement the special typing and compilation\n rules for the [lazy] keyword.\n*)\n\ntype 'a t = 'a CamlinternalLazy.t\n\nexception Undefined = CamlinternalLazy.Undefined\n\nexternal make_forward : 'a -> 'a lazy_t = \"caml_lazy_make_forward\"\n\nexternal force : 'a t -> 'a = \"%lazy_force\"\n\n\nlet force_val = CamlinternalLazy.force_val\n\nlet from_fun (f : unit -> 'arg) =\n let x = Obj.new_block Obj.lazy_tag 1 in\n Obj.set_field x 0 (Obj.repr f);\n (Obj.obj x : 'arg t)\n\nlet from_val (v : 'arg) =\n let t = Obj.tag (Obj.repr v) in\n if t = Obj.forward_tag || t = Obj.lazy_tag || t = Obj.double_tag then begin\n make_forward v\n end else begin\n (Obj.magic v : 'arg t)\n end\n\n\nlet is_val (l : 'arg t) = Obj.tag (Obj.repr l) <> Obj.lazy_tag\n\nlet lazy_from_fun = from_fun\n\nlet lazy_from_val = from_val\n\nlet lazy_is_val = is_val\n\n\nlet map f x =\n lazy (f (force x))\n\nlet map_val f x =\n if is_val x\n then lazy_from_val (f (force x))\n else lazy (f (force x))\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Simon Cruanes *)\n(* *)\n(* Copyright 2017 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* Module [Seq]: functional iterators *)\n\ntype +'a node =\n | Nil\n | Cons of 'a * 'a t\n\nand 'a t = unit -> 'a node\n\nlet empty () = Nil\n\nlet return x () = Cons (x, empty)\n\nlet cons x next () = Cons (x, next)\n\nlet rec append seq1 seq2 () =\n match seq1() with\n | Nil -> seq2()\n | Cons (x, next) -> Cons (x, append next seq2)\n\nlet rec map f seq () = match seq() with\n | Nil -> Nil\n | Cons (x, next) -> Cons (f x, map f next)\n\nlet rec filter_map f seq () = match seq() with\n | Nil -> Nil\n | Cons (x, next) ->\n match f x with\n | None -> filter_map f next ()\n | Some y -> Cons (y, filter_map f next)\n\nlet rec filter f seq () = match seq() with\n | Nil -> Nil\n | Cons (x, next) ->\n if f x\n then Cons (x, filter f next)\n else filter f next ()\n\nlet rec concat seq () = match seq () with\n | Nil -> Nil\n | Cons (x, next) ->\n append x (concat next) ()\n\nlet rec flat_map f seq () = match seq () with\n | Nil -> Nil\n | Cons (x, next) ->\n append (f x) (flat_map f next) ()\n\nlet concat_map = flat_map\n\nlet rec fold_left f acc seq =\n match seq () with\n | Nil -> acc\n | Cons (x, next) ->\n let acc = f acc x in\n fold_left f acc next\n\nlet rec iter f seq =\n match seq () with\n | Nil -> ()\n | Cons (x, next) ->\n f x;\n iter f next\n\nlet rec unfold f u () =\n match f u with\n | None -> Nil\n | Some (x, u') -> Cons (x, unfold f u')\n\nlet is_empty xs =\n match xs() with\n | Nil ->\n true\n | Cons (_, _) ->\n false\n\nlet uncons xs =\n match xs() with\n | Cons (x, xs) ->\n Some (x, xs)\n | Nil ->\n None\n\n\n\nlet rec length_aux accu xs =\n match xs() with\n | Nil ->\n accu\n | Cons (_, xs) ->\n length_aux (accu + 1) xs\n\nlet[@inline] length xs =\n length_aux 0 xs\n\nlet rec iteri_aux f i xs =\n match xs() with\n | Nil ->\n ()\n | Cons (x, xs) ->\n f i x;\n iteri_aux f (i+1) xs\n\nlet[@inline] iteri f xs =\n iteri_aux f 0 xs\n\nlet rec fold_lefti_aux f accu i xs =\n match xs() with\n | Nil ->\n accu\n | Cons (x, xs) ->\n let accu = f accu i x in\n fold_lefti_aux f accu (i+1) xs\n\nlet[@inline] fold_lefti f accu xs =\n fold_lefti_aux f accu 0 xs\n\nlet rec for_all p xs =\n match xs() with\n | Nil ->\n true\n | Cons (x, xs) ->\n p x && for_all p xs\n\nlet rec exists p xs =\n match xs() with\n | Nil ->\n false\n | Cons (x, xs) ->\n p x || exists p xs\n\nlet rec find p xs =\n match xs() with\n | Nil ->\n None\n | Cons (x, xs) ->\n if p x then Some x else find p xs\n\nlet rec find_map f xs =\n match xs() with\n | Nil ->\n None\n | Cons (x, xs) ->\n match f x with\n | None ->\n find_map f xs\n | Some _ as result ->\n result\n\n(* [iter2], [fold_left2], [for_all2], [exists2], [map2], [zip] work also in\n the case where the two sequences have different lengths. They stop as soon\n as one sequence is exhausted. Their behavior is slightly asymmetric: when\n [xs] is empty, they do not force [ys]; however, when [ys] is empty, [xs] is\n forced, even though the result of the function application [xs()] turns out\n to be useless. *)\n\nlet rec iter2 f xs ys =\n match xs() with\n | Nil ->\n ()\n | Cons (x, xs) ->\n match ys() with\n | Nil ->\n ()\n | Cons (y, ys) ->\n f x y;\n iter2 f xs ys\n\nlet rec fold_left2 f accu xs ys =\n match xs() with\n | Nil ->\n accu\n | Cons (x, xs) ->\n match ys() with\n | Nil ->\n accu\n | Cons (y, ys) ->\n let accu = f accu x y in\n fold_left2 f accu xs ys\n\nlet rec for_all2 f xs ys =\n match xs() with\n | Nil ->\n true\n | Cons (x, xs) ->\n match ys() with\n | Nil ->\n true\n | Cons (y, ys) ->\n f x y && for_all2 f xs ys\n\nlet rec exists2 f xs ys =\n match xs() with\n | Nil ->\n false\n | Cons (x, xs) ->\n match ys() with\n | Nil ->\n false\n | Cons (y, ys) ->\n f x y || exists2 f xs ys\n\nlet rec equal eq xs ys =\n match xs(), ys() with\n | Nil, Nil ->\n true\n | Cons (x, xs), Cons (y, ys) ->\n eq x y && equal eq xs ys\n | Nil, Cons (_, _)\n | Cons (_, _), Nil ->\n false\n\nlet rec compare cmp xs ys =\n match xs(), ys() with\n | Nil, Nil ->\n 0\n | Cons (x, xs), Cons (y, ys) ->\n let c = cmp x y in\n if c <> 0 then c else compare cmp xs ys\n | Nil, Cons (_, _) ->\n -1\n | Cons (_, _), Nil ->\n +1\n\n\n\n(* [init_aux f i j] is the sequence [f i, ..., f (j-1)]. *)\n\nlet rec init_aux f i j () =\n if i < j then begin\n Cons (f i, init_aux f (i + 1) j)\n end\n else\n Nil\n\nlet init n f =\n if n < 0 then\n invalid_arg \"Seq.init\"\n else\n init_aux f 0 n\n\nlet rec repeat x () =\n Cons (x, repeat x)\n\nlet rec forever f () =\n Cons (f(), forever f)\n\n(* This preliminary definition of [cycle] requires the sequence [xs]\n to be nonempty. Applying it to an empty sequence would produce a\n sequence that diverges when it is forced. *)\n\nlet rec cycle_nonempty xs () =\n append xs (cycle_nonempty xs) ()\n\n(* [cycle xs] checks whether [xs] is empty and, if so, returns an empty\n sequence. Otherwise, [cycle xs] produces one copy of [xs] followed\n with the infinite sequence [cycle_nonempty xs]. Thus, the nonemptiness\n check is performed just once. *)\n\nlet cycle xs () =\n match xs() with\n | Nil ->\n Nil\n | Cons (x, xs') ->\n Cons (x, append xs' (cycle_nonempty xs))\n\n(* [iterate1 f x] is the sequence [f x, f (f x), ...].\n It is equivalent to [tail (iterate f x)].\n [iterate1] is used as a building block in the definition of [iterate]. *)\n\nlet rec iterate1 f x () =\n let y = f x in\n Cons (y, iterate1 f y)\n\n(* [iterate f x] is the sequence [x, f x, ...]. *)\n\n(* The reason why we give this slightly indirect definition of [iterate],\n as opposed to the more naive definition that may come to mind, is that\n we are careful to avoid evaluating [f x] until this function call is\n actually necessary. The naive definition (not shown here) computes the\n second argument of the sequence, [f x], when the first argument is\n requested by the user. *)\n\nlet iterate f x =\n cons x (iterate1 f x)\n\n\n\nlet rec mapi_aux f i xs () =\n match xs() with\n | Nil ->\n Nil\n | Cons (x, xs) ->\n Cons (f i x, mapi_aux f (i+1) xs)\n\nlet[@inline] mapi f xs =\n mapi_aux f 0 xs\n\n(* [tail_scan f s xs] is equivalent to [tail (scan f s xs)].\n [tail_scan] is used as a building block in the definition of [scan]. *)\n\n(* This slightly indirect definition of [scan] is meant to avoid computing\n elements too early; see the above comment about [iterate1] and [iterate]. *)\n\nlet rec tail_scan f s xs () =\n match xs() with\n | Nil ->\n Nil\n | Cons (x, xs) ->\n let s = f s x in\n Cons (s, tail_scan f s xs)\n\nlet scan f s xs =\n cons s (tail_scan f s xs)\n\n(* [take] is defined in such a way that [take 0 xs] returns [empty]\n immediately, without allocating any memory. *)\n\nlet rec take_aux n xs =\n if n = 0 then\n empty\n else\n fun () ->\n match xs() with\n | Nil ->\n Nil\n | Cons (x, xs) ->\n Cons (x, take_aux (n-1) xs)\n\nlet take n xs =\n if n < 0 then invalid_arg \"Seq.take\";\n take_aux n xs\n\n(* [force_drop n xs] is equivalent to [drop n xs ()].\n [force_drop n xs] requires [n > 0].\n [force_drop] is used as a building block in the definition of [drop]. *)\n\nlet rec force_drop n xs =\n match xs() with\n | Nil ->\n Nil\n | Cons (_, xs) ->\n let n = n - 1 in\n if n = 0 then\n xs()\n else\n force_drop n xs\n\n(* [drop] is defined in such a way that [drop 0 xs] returns [xs] immediately,\n without allocating any memory. *)\n\nlet drop n xs =\n if n < 0 then invalid_arg \"Seq.drop\"\n else if n = 0 then\n xs\n else\n fun () ->\n force_drop n xs\n\nlet rec take_while p xs () =\n match xs() with\n | Nil ->\n Nil\n | Cons (x, xs) ->\n if p x then Cons (x, take_while p xs) else Nil\n\nlet rec drop_while p xs () =\n match xs() with\n | Nil ->\n Nil\n | Cons (x, xs) as node ->\n if p x then drop_while p xs () else node\n\nlet rec group eq xs () =\n match xs() with\n | Nil ->\n Nil\n | Cons (x, xs) ->\n Cons (cons x (take_while (eq x) xs), group eq (drop_while (eq x) xs))\n\nexception Forced_twice\n\nmodule Suspension = struct\n\n type 'a suspension =\n unit -> 'a\n\n (* Conversions. *)\n\n let to_lazy : 'a suspension -> 'a Lazy.t =\n Lazy.from_fun\n (* fun s -> lazy (s()) *)\n\n let from_lazy (s : 'a Lazy.t) : 'a suspension =\n fun () -> Lazy.force s\n\n (* [memoize] turns an arbitrary suspension into a persistent suspension. *)\n\n let memoize (s : 'a suspension) : 'a suspension =\n from_lazy (to_lazy s)\n\n (* [failure] is a suspension that fails when forced. *)\n\n let failure : _ suspension =\n fun () ->\n (* A suspension created by [once] has been forced twice. *)\n raise Forced_twice\n\n (* If [f] is a suspension, then [once f] is a suspension that can be forced\n at most once. If it is forced more than once, then [Forced_twice] is\n raised. *)\n\n let once (f : 'a suspension) : 'a suspension =\n let action = CamlinternalAtomic.make f in\n fun () ->\n (* Get the function currently stored in [action], and write the\n function [failure] in its place, so the next access will result\n in a call to [failure()]. *)\n let f = CamlinternalAtomic.exchange action failure in\n f()\n\nend (* Suspension *)\n\nlet rec memoize xs =\n Suspension.memoize (fun () ->\n match xs() with\n | Nil ->\n Nil\n | Cons (x, xs) ->\n Cons (x, memoize xs)\n )\n\nlet rec once xs =\n Suspension.once (fun () ->\n match xs() with\n | Nil ->\n Nil\n | Cons (x, xs) ->\n Cons (x, once xs)\n )\n\n\nlet rec zip xs ys () =\n match xs() with\n | Nil ->\n Nil\n | Cons (x, xs) ->\n match ys() with\n | Nil ->\n Nil\n | Cons (y, ys) ->\n Cons ((x, y), zip xs ys)\n\nlet rec map2 f xs ys () =\n match xs() with\n | Nil ->\n Nil\n | Cons (x, xs) ->\n match ys() with\n | Nil ->\n Nil\n | Cons (y, ys) ->\n Cons (f x y, map2 f xs ys)\n\nlet rec interleave xs ys () =\n match xs() with\n | Nil ->\n ys()\n | Cons (x, xs) ->\n Cons (x, interleave ys xs)\n\n(* [sorted_merge1l cmp x xs ys] is equivalent to\n [sorted_merge cmp (cons x xs) ys].\n\n [sorted_merge1r cmp xs y ys] is equivalent to\n [sorted_merge cmp xs (cons y ys)].\n\n [sorted_merge1 cmp x xs y ys] is equivalent to\n [sorted_merge cmp (cons x xs) (cons y ys)].\n\n These three functions are used as building blocks in the definition\n of [sorted_merge]. *)\n\nlet rec sorted_merge1l cmp x xs ys () =\n match ys() with\n | Nil ->\n Cons (x, xs)\n | Cons (y, ys) ->\n sorted_merge1 cmp x xs y ys\n\nand sorted_merge1r cmp xs y ys () =\n match xs() with\n | Nil ->\n Cons (y, ys)\n | Cons (x, xs) ->\n sorted_merge1 cmp x xs y ys\n\nand sorted_merge1 cmp x xs y ys =\n if cmp x y <= 0 then\n Cons (x, sorted_merge1r cmp xs y ys)\n else\n Cons (y, sorted_merge1l cmp x xs ys)\n\nlet sorted_merge cmp xs ys () =\n match xs(), ys() with\n | Nil, Nil ->\n Nil\n | Nil, c\n | c, Nil ->\n c\n | Cons (x, xs), Cons (y, ys) ->\n sorted_merge1 cmp x xs y ys\n\n\nlet rec map_fst xys () =\n match xys() with\n | Nil ->\n Nil\n | Cons ((x, _), xys) ->\n Cons (x, map_fst xys)\n\nlet rec map_snd xys () =\n match xys() with\n | Nil ->\n Nil\n | Cons ((_, y), xys) ->\n Cons (y, map_snd xys)\n\nlet unzip xys =\n map_fst xys, map_snd xys\n\nlet split =\n unzip\n\n(* [filter_map_find_left_map f xs] is equivalent to\n [filter_map Either.find_left (map f xs)]. *)\n\nlet rec filter_map_find_left_map f xs () =\n match xs() with\n | Nil ->\n Nil\n | Cons (x, xs) ->\n match f x with\n | Either.Left y ->\n Cons (y, filter_map_find_left_map f xs)\n | Either.Right _ ->\n filter_map_find_left_map f xs ()\n\nlet rec filter_map_find_right_map f xs () =\n match xs() with\n | Nil ->\n Nil\n | Cons (x, xs) ->\n match f x with\n | Either.Left _ ->\n filter_map_find_right_map f xs ()\n | Either.Right z ->\n Cons (z, filter_map_find_right_map f xs)\n\nlet partition_map f xs =\n filter_map_find_left_map f xs,\n filter_map_find_right_map f xs\n\nlet partition p xs =\n filter p xs, filter (fun x -> not (p x)) xs\n\n(* If [xss] is a matrix (a sequence of rows), then [peel xss] is a pair of\n the first column (a sequence of elements) and of the remainder of the\n matrix (a sequence of shorter rows). These two sequences have the same\n length. The rows of the matrix [xss] are not required to have the same\n length. An empty row is ignored. *)\n\n(* Because [peel] uses [unzip], its argument must be persistent. The same\n remark applies to [transpose], [diagonals], [product], etc. *)\n\nlet peel xss =\n unzip (filter_map uncons xss)\n\nlet rec transpose xss () =\n let heads, tails = peel xss in\n if is_empty heads then begin\n assert (is_empty tails);\n Nil\n end\n else\n Cons (heads, transpose tails)\n\n(* The internal function [diagonals] takes an extra argument, [remainders],\n which contains the remainders of the rows that have already been\n discovered. *)\n\nlet rec diagonals remainders xss () =\n match xss() with\n | Cons (xs, xss) ->\n begin match xs() with\n | Cons (x, xs) ->\n (* We discover a new nonempty row [x :: xs]. Thus, the next diagonal\n is [x :: heads]: this diagonal begins with [x] and continues with\n the first element of every row in [remainders]. In the recursive\n call, the argument [remainders] is instantiated with [xs ::\n tails], which means that we have one more remaining row, [xs],\n and that we keep the tails of the pre-existing remaining rows. *)\n let heads, tails = peel remainders in\n Cons (cons x heads, diagonals (cons xs tails) xss)\n | Nil ->\n (* We discover a new empty row. In this case, the new diagonal is\n just [heads], and [remainders] is instantiated with just [tails],\n as we do not have one more remaining row. *)\n let heads, tails = peel remainders in\n Cons (heads, diagonals tails xss)\n end\n | Nil ->\n (* There are no more rows to be discovered. There remains to exhaust\n the remaining rows. *)\n transpose remainders ()\n\n(* If [xss] is a matrix (a sequence of rows), then [diagonals xss] is\n the sequence of its diagonals.\n\n The first diagonal contains just the first element of the\n first row. The second diagonal contains the first element of the\n second row and the second element of the first row; and so on.\n This kind of diagonal is in fact sometimes known as an antidiagonal.\n\n - Every diagonal is a finite sequence.\n - The rows of the matrix [xss] are not required to have the same length.\n - The matrix [xss] is not required to be finite (in either direction).\n - The matrix [xss] must be persistent. *)\n\nlet diagonals xss =\n diagonals empty xss\n\nlet map_product f xs ys =\n concat (diagonals (\n map (fun x ->\n map (fun y ->\n f x y\n ) ys\n ) xs\n ))\n\nlet product xs ys =\n map_product (fun x y -> (x, y)) xs ys\n\nlet of_dispenser it =\n let rec c () =\n match it() with\n | None ->\n Nil\n | Some x ->\n Cons (x, c)\n in\n c\n\nlet to_dispenser xs =\n let s = ref xs in\n fun () ->\n match (!s)() with\n | Nil ->\n None\n | Cons (x, xs) ->\n s := xs;\n Some x\n\n\n\nlet rec ints i () =\n Cons (i, ints (i + 1))\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* The OCaml programmers *)\n(* *)\n(* Copyright 2018 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\ntype 'a t = 'a option = None | Some of 'a\n\nlet none = None\nlet some v = Some v\nlet value o ~default = match o with Some v -> v | None -> default\nlet get = function Some v -> v | None -> invalid_arg \"option is None\"\nlet bind o f = match o with None -> None | Some v -> f v\nlet join = function Some o -> o | None -> None\nlet map f o = match o with None -> None | Some v -> Some (f v)\nlet fold ~none ~some = function Some v -> some v | None -> none\nlet iter f = function Some v -> f v | None -> ()\nlet is_none = function None -> true | Some _ -> false\nlet is_some = function None -> false | Some _ -> true\n\nlet equal eq o0 o1 = match o0, o1 with\n| Some v0, Some v1 -> eq v0 v1\n| None, None -> true\n| _ -> false\n\nlet compare cmp o0 o1 = match o0, o1 with\n| Some v0, Some v1 -> cmp v0 v1\n| None, None -> 0\n| None, Some _ -> -1\n| Some _, None -> 1\n\nlet to_result ~none = function None -> Error none | Some v -> Ok v\nlet to_list = function None -> [] | Some v -> [v]\nlet to_seq = function None -> Seq.empty | Some v -> Seq.return v\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* The OCaml programmers *)\n(* *)\n(* Copyright 2018 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\ntype ('a, 'e) t = ('a, 'e) result = Ok of 'a | Error of 'e\n\nlet ok v = Ok v\nlet error e = Error e\nlet value r ~default = match r with Ok v -> v | Error _ -> default\nlet get_ok = function Ok v -> v | Error _ -> invalid_arg \"result is Error _\"\nlet get_error = function Error e -> e | Ok _ -> invalid_arg \"result is Ok _\"\nlet bind r f = match r with Ok v -> f v | Error _ as e -> e\nlet join = function Ok r -> r | Error _ as e -> e\nlet map f = function Ok v -> Ok (f v) | Error _ as e -> e\nlet map_error f = function Error e -> Error (f e) | Ok _ as v -> v\nlet fold ~ok ~error = function Ok v -> ok v | Error e -> error e\nlet iter f = function Ok v -> f v | Error _ -> ()\nlet iter_error f = function Error e -> f e | Ok _ -> ()\nlet is_ok = function Ok _ -> true | Error _ -> false\nlet is_error = function Error _ -> true | Ok _ -> false\n\nlet equal ~ok ~error r0 r1 = match r0, r1 with\n| Ok v0, Ok v1 -> ok v0 v1\n| Error e0, Error e1 -> error e0 e1\n| _, _ -> false\n\nlet compare ~ok ~error r0 r1 = match r0, r1 with\n| Ok v0, Ok v1 -> ok v0 v1\n| Error e0, Error e1 -> error e0 e1\n| Ok _, Error _ -> -1\n| Error _, Ok _ -> 1\n\nlet to_option = function Ok v -> Some v | Error _ -> None\nlet to_list = function Ok v -> [v] | Error _ -> []\nlet to_seq = function Ok v -> Seq.return v | Error _ -> Seq.empty\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* Character operations *)\n\nexternal code: char -> int = \"%identity\"\nexternal unsafe_chr: int -> char = \"%identity\"\n\nlet chr n =\n if n < 0 || n > 255 then invalid_arg \"Char.chr\" else unsafe_chr n\n\nexternal bytes_create: int -> bytes = \"caml_create_bytes\"\nexternal bytes_unsafe_set : bytes -> int -> char -> unit\n = \"%bytes_unsafe_set\"\nexternal unsafe_to_string : bytes -> string = \"%bytes_to_string\"\n\nlet escaped = function\n | '\\'' -> \"\\\\'\"\n | '\\\\' -> \"\\\\\\\\\"\n | '\\n' -> \"\\\\n\"\n | '\\t' -> \"\\\\t\"\n | '\\r' -> \"\\\\r\"\n | '\\b' -> \"\\\\b\"\n | ' ' .. '~' as c ->\n let s = bytes_create 1 in\n bytes_unsafe_set s 0 c;\n unsafe_to_string s\n | c ->\n let n = code c in\n let s = bytes_create 4 in\n bytes_unsafe_set s 0 '\\\\';\n bytes_unsafe_set s 1 (unsafe_chr (48 + n / 100));\n bytes_unsafe_set s 2 (unsafe_chr (48 + (n / 10) mod 10));\n bytes_unsafe_set s 3 (unsafe_chr (48 + n mod 10));\n unsafe_to_string s\n\nlet lowercase = function\n | 'A' .. 'Z'\n | '\\192' .. '\\214'\n | '\\216' .. '\\222' as c ->\n unsafe_chr(code c + 32)\n | c -> c\n\nlet uppercase = function\n | 'a' .. 'z'\n | '\\224' .. '\\246'\n | '\\248' .. '\\254' as c ->\n unsafe_chr(code c - 32)\n | c -> c\n\nlet lowercase_ascii = function\n | 'A' .. 'Z' as c -> unsafe_chr(code c + 32)\n | c -> c\n\nlet uppercase_ascii = function\n | 'a' .. 'z' as c -> unsafe_chr(code c - 32)\n | c -> c\n\ntype t = char\n\nlet compare c1 c2 = code c1 - code c2\nlet equal (c1: t) (c2: t) = compare c1 c2 = 0\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* The OCaml programmers *)\n(* *)\n(* Copyright 2018 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\ntype t = int\n\nlet zero = 0\nlet one = 1\nlet minus_one = -1\nexternal neg : int -> int = \"%negint\"\nexternal add : int -> int -> int = \"%addint\"\nexternal sub : int -> int -> int = \"%subint\"\nexternal mul : int -> int -> int = \"%mulint\"\nexternal div : int -> int -> int = \"%divint\"\nexternal rem : int -> int -> int = \"%modint\"\nexternal succ : int -> int = \"%succint\"\nexternal pred : int -> int = \"%predint\"\nlet abs x = if x >= 0 then x else -x\nlet max_int = (-1) lsr 1\nlet min_int = max_int + 1\nexternal logand : int -> int -> int = \"%andint\"\nexternal logor : int -> int -> int = \"%orint\"\nexternal logxor : int -> int -> int = \"%xorint\"\nlet lognot x = logxor x (-1)\nexternal shift_left : int -> int -> int = \"%lslint\"\nexternal shift_right : int -> int -> int = \"%asrint\"\nexternal shift_right_logical : int -> int -> int = \"%lsrint\"\nlet equal : int -> int -> bool = ( = )\nlet compare : int -> int -> int = Stdlib.compare\nlet min x y : t = if x <= y then x else y\nlet max x y : t = if x >= y then x else y\nexternal to_float : int -> float = \"%floatofint\"\nexternal of_float : float -> int = \"%intoffloat\"\n\n(*\nexternal int_of_string : string -> int = \"caml_int_of_string\"\nlet of_string s = try Some (int_of_string s) with Failure _ -> None\n*)\n\nexternal format_int : string -> int -> string = \"caml_format_int\"\nlet to_string x = format_int \"%d\" x\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* Byte sequence operations *)\n\n(* WARNING: Some functions in this file are duplicated in string.ml for\n efficiency reasons. When you modify the one in this file you need to\n modify its duplicate in string.ml.\n These functions have a \"duplicated\" comment above their definition.\n*)\n\nexternal length : bytes -> int = \"%bytes_length\"\nexternal string_length : string -> int = \"%string_length\"\nexternal get : bytes -> int -> char = \"%bytes_safe_get\"\nexternal set : bytes -> int -> char -> unit = \"%bytes_safe_set\"\nexternal create : int -> bytes = \"caml_create_bytes\"\nexternal unsafe_get : bytes -> int -> char = \"%bytes_unsafe_get\"\nexternal unsafe_set : bytes -> int -> char -> unit = \"%bytes_unsafe_set\"\nexternal unsafe_fill : bytes -> int -> int -> char -> unit\n = \"caml_fill_bytes\" [@@noalloc]\nexternal unsafe_to_string : bytes -> string = \"%bytes_to_string\"\nexternal unsafe_of_string : string -> bytes = \"%bytes_of_string\"\n\nexternal unsafe_blit : bytes -> int -> bytes -> int -> int -> unit\n = \"caml_blit_bytes\" [@@noalloc]\nexternal unsafe_blit_string : string -> int -> bytes -> int -> int -> unit\n = \"caml_blit_string\" [@@noalloc]\n\nlet make n c =\n let s = create n in\n unsafe_fill s 0 n c;\n s\n\nlet init n f =\n let s = create n in\n for i = 0 to n - 1 do\n unsafe_set s i (f i)\n done;\n s\n\nlet empty = create 0\n\nlet copy s =\n let len = length s in\n let r = create len in\n unsafe_blit s 0 r 0 len;\n r\n\nlet to_string b = unsafe_to_string (copy b)\nlet of_string s = copy (unsafe_of_string s)\n\nlet sub s ofs len =\n if ofs < 0 || len < 0 || ofs > length s - len\n then invalid_arg \"String.sub / Bytes.sub\"\n else begin\n let r = create len in\n unsafe_blit s ofs r 0 len;\n r\n end\n\nlet sub_string b ofs len = unsafe_to_string (sub b ofs len)\n\n(* addition with an overflow check *)\nlet (++) a b =\n let c = a + b in\n match a < 0, b < 0, c < 0 with\n | true , true , false\n | false, false, true -> invalid_arg \"Bytes.extend\" (* overflow *)\n | _ -> c\n\nlet extend s left right =\n let len = length s ++ left ++ right in\n let r = create len in\n let (srcoff, dstoff) = if left < 0 then -left, 0 else 0, left in\n let cpylen = Int.min (length s - srcoff) (len - dstoff) in\n if cpylen > 0 then unsafe_blit s srcoff r dstoff cpylen;\n r\n\nlet fill s ofs len c =\n if ofs < 0 || len < 0 || ofs > length s - len\n then invalid_arg \"String.fill / Bytes.fill\"\n else unsafe_fill s ofs len c\n\nlet blit s1 ofs1 s2 ofs2 len =\n if len < 0 || ofs1 < 0 || ofs1 > length s1 - len\n || ofs2 < 0 || ofs2 > length s2 - len\n then invalid_arg \"Bytes.blit\"\n else unsafe_blit s1 ofs1 s2 ofs2 len\n\nlet blit_string s1 ofs1 s2 ofs2 len =\n if len < 0 || ofs1 < 0 || ofs1 > string_length s1 - len\n || ofs2 < 0 || ofs2 > length s2 - len\n then invalid_arg \"String.blit / Bytes.blit_string\"\n else unsafe_blit_string s1 ofs1 s2 ofs2 len\n\n(* duplicated in string.ml *)\nlet iter f a =\n for i = 0 to length a - 1 do f(unsafe_get a i) done\n\n(* duplicated in string.ml *)\nlet iteri f a =\n for i = 0 to length a - 1 do f i (unsafe_get a i) done\n\nlet ensure_ge (x:int) y = if x >= y then x else invalid_arg \"Bytes.concat\"\n\nlet rec sum_lengths acc seplen = function\n | [] -> acc\n | hd :: [] -> length hd + acc\n | hd :: tl -> sum_lengths (ensure_ge (length hd + seplen + acc) acc) seplen tl\n\nlet rec unsafe_blits dst pos sep seplen = function\n [] -> dst\n | hd :: [] ->\n unsafe_blit hd 0 dst pos (length hd); dst\n | hd :: tl ->\n unsafe_blit hd 0 dst pos (length hd);\n unsafe_blit sep 0 dst (pos + length hd) seplen;\n unsafe_blits dst (pos + length hd + seplen) sep seplen tl\n\nlet concat sep = function\n [] -> empty\n | l -> let seplen = length sep in\n unsafe_blits\n (create (sum_lengths 0 seplen l))\n 0 sep seplen l\n\nlet cat s1 s2 =\n let l1 = length s1 in\n let l2 = length s2 in\n let r = create (l1 + l2) in\n unsafe_blit s1 0 r 0 l1;\n unsafe_blit s2 0 r l1 l2;\n r\n\n\nexternal char_code: char -> int = \"%identity\"\nexternal char_chr: int -> char = \"%identity\"\n\nlet is_space = function\n | ' ' | '\\012' | '\\n' | '\\r' | '\\t' -> true\n | _ -> false\n\nlet trim s =\n let len = length s in\n let i = ref 0 in\n while !i < len && is_space (unsafe_get s !i) do\n incr i\n done;\n let j = ref (len - 1) in\n while !j >= !i && is_space (unsafe_get s !j) do\n decr j\n done;\n if !j >= !i then\n sub s !i (!j - !i + 1)\n else\n empty\n\nlet escaped s =\n let n = ref 0 in\n for i = 0 to length s - 1 do\n n := !n +\n (match unsafe_get s i with\n | '\\\"' | '\\\\' | '\\n' | '\\t' | '\\r' | '\\b' -> 2\n | ' ' .. '~' -> 1\n | _ -> 4)\n done;\n if !n = length s then copy s else begin\n let s' = create !n in\n n := 0;\n for i = 0 to length s - 1 do\n begin match unsafe_get s i with\n | ('\\\"' | '\\\\') as c ->\n unsafe_set s' !n '\\\\'; incr n; unsafe_set s' !n c\n | '\\n' ->\n unsafe_set s' !n '\\\\'; incr n; unsafe_set s' !n 'n'\n | '\\t' ->\n unsafe_set s' !n '\\\\'; incr n; unsafe_set s' !n 't'\n | '\\r' ->\n unsafe_set s' !n '\\\\'; incr n; unsafe_set s' !n 'r'\n | '\\b' ->\n unsafe_set s' !n '\\\\'; incr n; unsafe_set s' !n 'b'\n | (' ' .. '~') as c -> unsafe_set s' !n c\n | c ->\n let a = char_code c in\n unsafe_set s' !n '\\\\';\n incr n;\n unsafe_set s' !n (char_chr (48 + a / 100));\n incr n;\n unsafe_set s' !n (char_chr (48 + (a / 10) mod 10));\n incr n;\n unsafe_set s' !n (char_chr (48 + a mod 10));\n end;\n incr n\n done;\n s'\n end\n\nlet map f s =\n let l = length s in\n if l = 0 then s else begin\n let r = create l in\n for i = 0 to l - 1 do unsafe_set r i (f (unsafe_get s i)) done;\n r\n end\n\nlet mapi f s =\n let l = length s in\n if l = 0 then s else begin\n let r = create l in\n for i = 0 to l - 1 do unsafe_set r i (f i (unsafe_get s i)) done;\n r\n end\n\nlet fold_left f x a =\n let r = ref x in\n for i = 0 to length a - 1 do\n r := f !r (unsafe_get a i)\n done;\n !r\n\nlet fold_right f a x =\n let r = ref x in\n for i = length a - 1 downto 0 do\n r := f (unsafe_get a i) !r\n done;\n !r\n\nlet exists p s =\n let n = length s in\n let rec loop i =\n if i = n then false\n else if p (unsafe_get s i) then true\n else loop (succ i) in\n loop 0\n\nlet for_all p s =\n let n = length s in\n let rec loop i =\n if i = n then true\n else if p (unsafe_get s i) then loop (succ i)\n else false in\n loop 0\n\nlet uppercase_ascii s = map Char.uppercase_ascii s\nlet lowercase_ascii s = map Char.lowercase_ascii s\n\nlet apply1 f s =\n if length s = 0 then s else begin\n let r = copy s in\n unsafe_set r 0 (f(unsafe_get s 0));\n r\n end\n\nlet capitalize_ascii s = apply1 Char.uppercase_ascii s\nlet uncapitalize_ascii s = apply1 Char.lowercase_ascii s\n\n(* duplicated in string.ml *)\nlet starts_with ~prefix s =\n let len_s = length s\n and len_pre = length prefix in\n let rec aux i =\n if i = len_pre then true\n else if unsafe_get s i <> unsafe_get prefix i then false\n else aux (i + 1)\n in len_s >= len_pre && aux 0\n\n(* duplicated in string.ml *)\nlet ends_with ~suffix s =\n let len_s = length s\n and len_suf = length suffix in\n let diff = len_s - len_suf in\n let rec aux i =\n if i = len_suf then true\n else if unsafe_get s (diff + i) <> unsafe_get suffix i then false\n else aux (i + 1)\n in diff >= 0 && aux 0\n\n(* duplicated in string.ml *)\nlet rec index_rec s lim i c =\n if i >= lim then raise Not_found else\n if unsafe_get s i = c then i else index_rec s lim (i + 1) c\n\n(* duplicated in string.ml *)\nlet index s c = index_rec s (length s) 0 c\n\n(* duplicated in string.ml *)\nlet rec index_rec_opt s lim i c =\n if i >= lim then None else\n if unsafe_get s i = c then Some i else index_rec_opt s lim (i + 1) c\n\n(* duplicated in string.ml *)\nlet index_opt s c = index_rec_opt s (length s) 0 c\n\n(* duplicated in string.ml *)\nlet index_from s i c =\n let l = length s in\n if i < 0 || i > l then invalid_arg \"String.index_from / Bytes.index_from\" else\n index_rec s l i c\n\n(* duplicated in string.ml *)\nlet index_from_opt s i c =\n let l = length s in\n if i < 0 || i > l then\n invalid_arg \"String.index_from_opt / Bytes.index_from_opt\"\n else\n index_rec_opt s l i c\n\n(* duplicated in string.ml *)\nlet rec rindex_rec s i c =\n if i < 0 then raise Not_found else\n if unsafe_get s i = c then i else rindex_rec s (i - 1) c\n\n(* duplicated in string.ml *)\nlet rindex s c = rindex_rec s (length s - 1) c\n\n(* duplicated in string.ml *)\nlet rindex_from s i c =\n if i < -1 || i >= length s then\n invalid_arg \"String.rindex_from / Bytes.rindex_from\"\n else\n rindex_rec s i c\n\n(* duplicated in string.ml *)\nlet rec rindex_rec_opt s i c =\n if i < 0 then None else\n if unsafe_get s i = c then Some i else rindex_rec_opt s (i - 1) c\n\n(* duplicated in string.ml *)\nlet rindex_opt s c = rindex_rec_opt s (length s - 1) c\n\n(* duplicated in string.ml *)\nlet rindex_from_opt s i c =\n if i < -1 || i >= length s then\n invalid_arg \"String.rindex_from_opt / Bytes.rindex_from_opt\"\n else\n rindex_rec_opt s i c\n\n\n(* duplicated in string.ml *)\nlet contains_from s i c =\n let l = length s in\n if i < 0 || i > l then\n invalid_arg \"String.contains_from / Bytes.contains_from\"\n else\n try ignore (index_rec s l i c); true with Not_found -> false\n\n\n(* duplicated in string.ml *)\nlet contains s c = contains_from s 0 c\n\n(* duplicated in string.ml *)\nlet rcontains_from s i c =\n if i < 0 || i >= length s then\n invalid_arg \"String.rcontains_from / Bytes.rcontains_from\"\n else\n try ignore (rindex_rec s i c); true with Not_found -> false\n\n\ntype t = bytes\n\nlet compare (x: t) (y: t) = Stdlib.compare x y\nexternal equal : t -> t -> bool = \"caml_bytes_equal\" [@@noalloc]\n\n(* duplicated in string.ml *)\nlet split_on_char sep s =\n let r = ref [] in\n let j = ref (length s) in\n for i = length s - 1 downto 0 do\n if unsafe_get s i = sep then begin\n r := sub s (i + 1) (!j - i - 1) :: !r;\n j := i\n end\n done;\n sub s 0 !j :: !r\n\n(* Deprecated functions implemented via other deprecated functions *)\n[@@@ocaml.warning \"-3\"]\nlet uppercase s = map Char.uppercase s\nlet lowercase s = map Char.lowercase s\n\nlet capitalize s = apply1 Char.uppercase s\nlet uncapitalize s = apply1 Char.lowercase s\n\n(** {1 Iterators} *)\n\nlet to_seq s =\n let rec aux i () =\n if i = length s then Seq.Nil\n else\n let x = get s i in\n Seq.Cons (x, aux (i+1))\n in\n aux 0\n\nlet to_seqi s =\n let rec aux i () =\n if i = length s then Seq.Nil\n else\n let x = get s i in\n Seq.Cons ((i,x), aux (i+1))\n in\n aux 0\n\nlet of_seq i =\n let n = ref 0 in\n let buf = ref (make 256 '\\000') in\n let resize () =\n (* resize *)\n let new_len = Int.min (2 * length !buf) Sys.max_string_length in\n if length !buf = new_len then failwith \"Bytes.of_seq: cannot grow bytes\";\n let new_buf = make new_len '\\000' in\n blit !buf 0 new_buf 0 !n;\n buf := new_buf\n in\n Seq.iter\n (fun c ->\n if !n = length !buf then resize();\n set !buf !n c;\n incr n)\n i;\n sub !buf 0 !n\n\n(** {6 Binary encoding/decoding of integers} *)\n\n(* The get_ functions are all duplicated in string.ml *)\n\nexternal unsafe_get_uint8 : bytes -> int -> int = \"%bytes_unsafe_get\"\nexternal unsafe_get_uint16_ne : bytes -> int -> int = \"%caml_bytes_get16u\"\nexternal get_uint8 : bytes -> int -> int = \"%bytes_safe_get\"\nexternal get_uint16_ne : bytes -> int -> int = \"%caml_bytes_get16\"\nexternal get_int32_ne : bytes -> int -> int32 = \"%caml_bytes_get32\"\nexternal get_int64_ne : bytes -> int -> int64 = \"%caml_bytes_get64\"\n\nexternal unsafe_set_uint8 : bytes -> int -> int -> unit = \"%bytes_unsafe_set\"\nexternal unsafe_set_uint16_ne : bytes -> int -> int -> unit\n = \"%caml_bytes_set16u\"\nexternal set_int8 : bytes -> int -> int -> unit = \"%bytes_safe_set\"\nexternal set_int16_ne : bytes -> int -> int -> unit = \"%caml_bytes_set16\"\nexternal set_int32_ne : bytes -> int -> int32 -> unit = \"%caml_bytes_set32\"\nexternal set_int64_ne : bytes -> int -> int64 -> unit = \"%caml_bytes_set64\"\nexternal swap16 : int -> int = \"%bswap16\"\nexternal swap32 : int32 -> int32 = \"%bswap_int32\"\nexternal swap64 : int64 -> int64 = \"%bswap_int64\"\n\nlet unsafe_get_uint16_le b i =\n if Sys.big_endian\n then swap16 (unsafe_get_uint16_ne b i)\n else unsafe_get_uint16_ne b i\n\nlet unsafe_get_uint16_be b i =\n if Sys.big_endian\n then unsafe_get_uint16_ne b i\n else swap16 (unsafe_get_uint16_ne b i)\n\nlet get_int8 b i =\n ((get_uint8 b i) lsl (Sys.int_size - 8)) asr (Sys.int_size - 8)\n\nlet get_uint16_le b i =\n if Sys.big_endian then swap16 (get_uint16_ne b i)\n else get_uint16_ne b i\n\nlet get_uint16_be b i =\n if not Sys.big_endian then swap16 (get_uint16_ne b i)\n else get_uint16_ne b i\n\nlet get_int16_ne b i =\n ((get_uint16_ne b i) lsl (Sys.int_size - 16)) asr (Sys.int_size - 16)\n\nlet get_int16_le b i =\n ((get_uint16_le b i) lsl (Sys.int_size - 16)) asr (Sys.int_size - 16)\n\nlet get_int16_be b i =\n ((get_uint16_be b i) lsl (Sys.int_size - 16)) asr (Sys.int_size - 16)\n\nlet get_int32_le b i =\n if Sys.big_endian then swap32 (get_int32_ne b i)\n else get_int32_ne b i\n\nlet get_int32_be b i =\n if not Sys.big_endian then swap32 (get_int32_ne b i)\n else get_int32_ne b i\n\nlet get_int64_le b i =\n if Sys.big_endian then swap64 (get_int64_ne b i)\n else get_int64_ne b i\n\nlet get_int64_be b i =\n if not Sys.big_endian then swap64 (get_int64_ne b i)\n else get_int64_ne b i\n\nlet unsafe_set_uint16_le b i x =\n if Sys.big_endian\n then unsafe_set_uint16_ne b i (swap16 x)\n else unsafe_set_uint16_ne b i x\n\nlet unsafe_set_uint16_be b i x =\n if Sys.big_endian\n then unsafe_set_uint16_ne b i x else\n unsafe_set_uint16_ne b i (swap16 x)\n\nlet set_int16_le b i x =\n if Sys.big_endian then set_int16_ne b i (swap16 x)\n else set_int16_ne b i x\n\nlet set_int16_be b i x =\n if not Sys.big_endian then set_int16_ne b i (swap16 x)\n else set_int16_ne b i x\n\nlet set_int32_le b i x =\n if Sys.big_endian then set_int32_ne b i (swap32 x)\n else set_int32_ne b i x\n\nlet set_int32_be b i x =\n if not Sys.big_endian then set_int32_ne b i (swap32 x)\n else set_int32_ne b i x\n\nlet set_int64_le b i x =\n if Sys.big_endian then set_int64_ne b i (swap64 x)\n else set_int64_ne b i x\n\nlet set_int64_be b i x =\n if not Sys.big_endian then set_int64_ne b i (swap64 x)\n else set_int64_ne b i x\n\nlet set_uint8 = set_int8\nlet set_uint16_ne = set_int16_ne\nlet set_uint16_be = set_int16_be\nlet set_uint16_le = set_int16_le\n\n(* UTF codecs and validations *)\n\nlet dec_invalid = Uchar.utf_decode_invalid\nlet[@inline] dec_ret n u = Uchar.utf_decode n (Uchar.unsafe_of_int u)\n\n(* In case of decoding error, if we error on the first byte, we\n consume the byte, otherwise we consume the [n] bytes preceeding\n the erroring byte.\n\n This means that if a client uses decodes without caring about\n validity it naturally replace bogus data with Uchar.rep according\n to the WHATWG Encoding standard. Other schemes are possible by\n consulting the number of used bytes on invalid decodes. For more\n details see https://hsivonen.fi/broken-utf-8/\n\n For this reason in [get_utf_8_uchar] we gradually check the next\n byte is available rather than doing it immediately after the\n first byte. Contrast with [is_valid_utf_8]. *)\n\n(* UTF-8 *)\n\nlet[@inline] not_in_x80_to_xBF b = b lsr 6 <> 0b10\nlet[@inline] not_in_xA0_to_xBF b = b lsr 5 <> 0b101\nlet[@inline] not_in_x80_to_x9F b = b lsr 5 <> 0b100\nlet[@inline] not_in_x90_to_xBF b = b < 0x90 || 0xBF < b\nlet[@inline] not_in_x80_to_x8F b = b lsr 4 <> 0x8\n\nlet[@inline] utf_8_uchar_2 b0 b1 =\n ((b0 land 0x1F) lsl 6) lor\n ((b1 land 0x3F))\n\nlet[@inline] utf_8_uchar_3 b0 b1 b2 =\n ((b0 land 0x0F) lsl 12) lor\n ((b1 land 0x3F) lsl 6) lor\n ((b2 land 0x3F))\n\nlet[@inline] utf_8_uchar_4 b0 b1 b2 b3 =\n ((b0 land 0x07) lsl 18) lor\n ((b1 land 0x3F) lsl 12) lor\n ((b2 land 0x3F) lsl 6) lor\n ((b3 land 0x3F))\n\nlet get_utf_8_uchar b i =\n let b0 = get_uint8 b i in (* raises if [i] is not a valid index. *)\n let get = unsafe_get_uint8 in\n let max = length b - 1 in\n match Char.unsafe_chr b0 with (* See The Unicode Standard, Table 3.7 *)\n | '\\x00' .. '\\x7F' -> dec_ret 1 b0\n | '\\xC2' .. '\\xDF' ->\n let i = i + 1 in if i > max then dec_invalid 1 else\n let b1 = get b i in if not_in_x80_to_xBF b1 then dec_invalid 1 else\n dec_ret 2 (utf_8_uchar_2 b0 b1)\n | '\\xE0' ->\n let i = i + 1 in if i > max then dec_invalid 1 else\n let b1 = get b i in if not_in_xA0_to_xBF b1 then dec_invalid 1 else\n let i = i + 1 in if i > max then dec_invalid 2 else\n let b2 = get b i in if not_in_x80_to_xBF b2 then dec_invalid 2 else\n dec_ret 3 (utf_8_uchar_3 b0 b1 b2)\n | '\\xE1' .. '\\xEC' | '\\xEE' .. '\\xEF' ->\n let i = i + 1 in if i > max then dec_invalid 1 else\n let b1 = get b i in if not_in_x80_to_xBF b1 then dec_invalid 1 else\n let i = i + 1 in if i > max then dec_invalid 2 else\n let b2 = get b i in if not_in_x80_to_xBF b2 then dec_invalid 2 else\n dec_ret 3 (utf_8_uchar_3 b0 b1 b2)\n | '\\xED' ->\n let i = i + 1 in if i > max then dec_invalid 1 else\n let b1 = get b i in if not_in_x80_to_x9F b1 then dec_invalid 1 else\n let i = i + 1 in if i > max then dec_invalid 2 else\n let b2 = get b i in if not_in_x80_to_xBF b2 then dec_invalid 2 else\n dec_ret 3 (utf_8_uchar_3 b0 b1 b2)\n | '\\xF0' ->\n let i = i + 1 in if i > max then dec_invalid 1 else\n let b1 = get b i in if not_in_x90_to_xBF b1 then dec_invalid 1 else\n let i = i + 1 in if i > max then dec_invalid 2 else\n let b2 = get b i in if not_in_x80_to_xBF b2 then dec_invalid 2 else\n let i = i + 1 in if i > max then dec_invalid 3 else\n let b3 = get b i in if not_in_x80_to_xBF b3 then dec_invalid 3 else\n dec_ret 4 (utf_8_uchar_4 b0 b1 b2 b3)\n | '\\xF1' .. '\\xF3' ->\n let i = i + 1 in if i > max then dec_invalid 1 else\n let b1 = get b i in if not_in_x80_to_xBF b1 then dec_invalid 1 else\n let i = i + 1 in if i > max then dec_invalid 2 else\n let b2 = get b i in if not_in_x80_to_xBF b2 then dec_invalid 2 else\n let i = i + 1 in if i > max then dec_invalid 3 else\n let b3 = get b i in if not_in_x80_to_xBF b3 then dec_invalid 3 else\n dec_ret 4 (utf_8_uchar_4 b0 b1 b2 b3)\n | '\\xF4' ->\n let i = i + 1 in if i > max then dec_invalid 1 else\n let b1 = get b i in if not_in_x80_to_x8F b1 then dec_invalid 1 else\n let i = i + 1 in if i > max then dec_invalid 2 else\n let b2 = get b i in if not_in_x80_to_xBF b2 then dec_invalid 2 else\n let i = i + 1 in if i > max then dec_invalid 3 else\n let b3 = get b i in if not_in_x80_to_xBF b3 then dec_invalid 3 else\n dec_ret 4 (utf_8_uchar_4 b0 b1 b2 b3)\n | _ -> dec_invalid 1\n\nlet set_utf_8_uchar b i u =\n let set = unsafe_set_uint8 in\n let max = length b - 1 in\n match Uchar.to_int u with\n | u when u < 0 -> assert false\n | u when u <= 0x007F ->\n set_uint8 b i u;\n 1\n | u when u <= 0x07FF ->\n let last = i + 1 in\n if last > max then 0 else\n (set_uint8 b i (0xC0 lor (u lsr 6));\n set b last (0x80 lor (u land 0x3F));\n 2)\n | u when u <= 0xFFFF ->\n let last = i + 2 in\n if last > max then 0 else\n (set_uint8 b i (0xE0 lor (u lsr 12));\n set b (i + 1) (0x80 lor ((u lsr 6) land 0x3F));\n set b last (0x80 lor (u land 0x3F));\n 3)\n | u when u <= 0x10FFFF ->\n let last = i + 3 in\n if last > max then 0 else\n (set_uint8 b i (0xF0 lor (u lsr 18));\n set b (i + 1) (0x80 lor ((u lsr 12) land 0x3F));\n set b (i + 2) (0x80 lor ((u lsr 6) land 0x3F));\n set b last (0x80 lor (u land 0x3F));\n 4)\n | _ -> assert false\n\nlet is_valid_utf_8 b =\n let rec loop max b i =\n if i > max then true else\n let get = unsafe_get_uint8 in\n match Char.unsafe_chr (get b i) with\n | '\\x00' .. '\\x7F' -> loop max b (i + 1)\n | '\\xC2' .. '\\xDF' ->\n let last = i + 1 in\n if last > max\n || not_in_x80_to_xBF (get b last)\n then false\n else loop max b (last + 1)\n | '\\xE0' ->\n let last = i + 2 in\n if last > max\n || not_in_xA0_to_xBF (get b (i + 1))\n || not_in_x80_to_xBF (get b last)\n then false\n else loop max b (last + 1)\n | '\\xE1' .. '\\xEC' | '\\xEE' .. '\\xEF' ->\n let last = i + 2 in\n if last > max\n || not_in_x80_to_xBF (get b (i + 1))\n || not_in_x80_to_xBF (get b last)\n then false\n else loop max b (last + 1)\n | '\\xED' ->\n let last = i + 2 in\n if last > max\n || not_in_x80_to_x9F (get b (i + 1))\n || not_in_x80_to_xBF (get b last)\n then false\n else loop max b (last + 1)\n | '\\xF0' ->\n let last = i + 3 in\n if last > max\n || not_in_x90_to_xBF (get b (i + 1))\n || not_in_x80_to_xBF (get b (i + 2))\n || not_in_x80_to_xBF (get b last)\n then false\n else loop max b (last + 1)\n | '\\xF1' .. '\\xF3' ->\n let last = i + 3 in\n if last > max\n || not_in_x80_to_xBF (get b (i + 1))\n || not_in_x80_to_xBF (get b (i + 2))\n || not_in_x80_to_xBF (get b last)\n then false\n else loop max b (last + 1)\n | '\\xF4' ->\n let last = i + 3 in\n if last > max\n || not_in_x80_to_x8F (get b (i + 1))\n || not_in_x80_to_xBF (get b (i + 2))\n || not_in_x80_to_xBF (get b last)\n then false\n else loop max b (last + 1)\n | _ -> false\n in\n loop (length b - 1) b 0\n\n(* UTF-16BE *)\n\nlet get_utf_16be_uchar b i =\n let get = unsafe_get_uint16_be in\n let max = length b - 1 in\n if i < 0 || i > max then invalid_arg \"index out of bounds\" else\n if i = max then dec_invalid 1 else\n match get b i with\n | u when u < 0xD800 || u > 0xDFFF -> dec_ret 2 u\n | u when u > 0xDBFF -> dec_invalid 2\n | hi -> (* combine [hi] with a low surrogate *)\n let last = i + 3 in\n if last > max then dec_invalid (max - i + 1) else\n match get b (i + 2) with\n | u when u < 0xDC00 || u > 0xDFFF -> dec_invalid 2 (* retry here *)\n | lo ->\n let u = (((hi land 0x3FF) lsl 10) lor (lo land 0x3FF)) + 0x10000 in\n dec_ret 4 u\n\nlet set_utf_16be_uchar b i u =\n let set = unsafe_set_uint16_be in\n let max = length b - 1 in\n if i < 0 || i > max then invalid_arg \"index out of bounds\" else\n match Uchar.to_int u with\n | u when u < 0 -> assert false\n | u when u <= 0xFFFF ->\n let last = i + 1 in\n if last > max then 0 else (set b i u; 2)\n | u when u <= 0x10FFFF ->\n let last = i + 3 in\n if last > max then 0 else\n let u' = u - 0x10000 in\n let hi = (0xD800 lor (u' lsr 10)) in\n let lo = (0xDC00 lor (u' land 0x3FF)) in\n set b i hi; set b (i + 2) lo; 4\n | _ -> assert false\n\nlet is_valid_utf_16be b =\n let rec loop max b i =\n let get = unsafe_get_uint16_be in\n if i > max then true else\n if i = max then false else\n match get b i with\n | u when u < 0xD800 || u > 0xDFFF -> loop max b (i + 2)\n | u when u > 0xDBFF -> false\n | _hi ->\n let last = i + 3 in\n if last > max then false else\n match get b (i + 2) with\n | u when u < 0xDC00 || u > 0xDFFF -> false\n | _lo -> loop max b (i + 4)\n in\n loop (length b - 1) b 0\n\n(* UTF-16LE *)\n\nlet get_utf_16le_uchar b i =\n let get = unsafe_get_uint16_le in\n let max = length b - 1 in\n if i < 0 || i > max then invalid_arg \"index out of bounds\" else\n if i = max then dec_invalid 1 else\n match get b i with\n | u when u < 0xD800 || u > 0xDFFF -> dec_ret 2 u\n | u when u > 0xDBFF -> dec_invalid 2\n | hi -> (* combine [hi] with a low surrogate *)\n let last = i + 3 in\n if last > max then dec_invalid (max - i + 1) else\n match get b (i + 2) with\n | u when u < 0xDC00 || u > 0xDFFF -> dec_invalid 2 (* retry here *)\n | lo ->\n let u = (((hi land 0x3FF) lsl 10) lor (lo land 0x3FF)) + 0x10000 in\n dec_ret 4 u\n\nlet set_utf_16le_uchar b i u =\n let set = unsafe_set_uint16_le in\n let max = length b - 1 in\n if i < 0 || i > max then invalid_arg \"index out of bounds\" else\n match Uchar.to_int u with\n | u when u < 0 -> assert false\n | u when u <= 0xFFFF ->\n let last = i + 1 in\n if last > max then 0 else (set b i u; 2)\n | u when u <= 0x10FFFF ->\n let last = i + 3 in\n if last > max then 0 else\n let u' = u - 0x10000 in\n let hi = (0xD800 lor (u' lsr 10)) in\n let lo = (0xDC00 lor (u' land 0x3FF)) in\n set b i hi; set b (i + 2) lo; 4\n | _ -> assert false\n\nlet is_valid_utf_16le b =\n let rec loop max b i =\n let get = unsafe_get_uint16_le in\n if i > max then true else\n if i = max then false else\n match get b i with\n | u when u < 0xD800 || u > 0xDFFF -> loop max b (i + 2)\n | u when u > 0xDBFF -> false\n | _hi ->\n let last = i + 3 in\n if last > max then false else\n match get b (i + 2) with\n | u when u < 0xDC00 || u > 0xDFFF -> false\n | _lo -> loop max b (i + 4)\n in\n loop (length b - 1) b 0\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Damien Doligez, projet Gallium, INRIA Rocquencourt *)\n(* *)\n(* Copyright 2014 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* String operations, based on byte sequence operations *)\n\n(* WARNING: Some functions in this file are duplicated in bytes.ml for\n efficiency reasons. When you modify the one in this file you need to\n modify its duplicate in bytes.ml.\n These functions have a \"duplicated\" comment above their definition.\n*)\n\nexternal length : string -> int = \"%string_length\"\nexternal get : string -> int -> char = \"%string_safe_get\"\nexternal set : bytes -> int -> char -> unit = \"%string_safe_set\"\nexternal create : int -> bytes = \"caml_create_string\"\nexternal unsafe_get : string -> int -> char = \"%string_unsafe_get\"\nexternal unsafe_set : bytes -> int -> char -> unit = \"%string_unsafe_set\"\nexternal unsafe_blit : string -> int -> bytes -> int -> int -> unit\n = \"caml_blit_string\" [@@noalloc]\nexternal unsafe_fill : bytes -> int -> int -> char -> unit\n = \"caml_fill_string\" [@@noalloc]\n\nmodule B = Bytes\n\nlet bts = B.unsafe_to_string\nlet bos = B.unsafe_of_string\n\nlet make n c =\n B.make n c |> bts\nlet init n f =\n B.init n f |> bts\nlet empty = \"\"\nlet copy s =\n B.copy (bos s) |> bts\nlet of_bytes = B.to_string\nlet to_bytes = B.of_string\nlet sub s ofs len =\n B.sub (bos s) ofs len |> bts\nlet fill =\n B.fill\nlet blit =\n B.blit_string\n\nlet ensure_ge (x:int) y = if x >= y then x else invalid_arg \"String.concat\"\n\nlet rec sum_lengths acc seplen = function\n | [] -> acc\n | hd :: [] -> length hd + acc\n | hd :: tl -> sum_lengths (ensure_ge (length hd + seplen + acc) acc) seplen tl\n\nlet rec unsafe_blits dst pos sep seplen = function\n [] -> dst\n | hd :: [] ->\n unsafe_blit hd 0 dst pos (length hd); dst\n | hd :: tl ->\n unsafe_blit hd 0 dst pos (length hd);\n unsafe_blit sep 0 dst (pos + length hd) seplen;\n unsafe_blits dst (pos + length hd + seplen) sep seplen tl\n\nlet concat sep = function\n [] -> \"\"\n | l -> let seplen = length sep in bts @@\n unsafe_blits\n (B.create (sum_lengths 0 seplen l))\n 0 sep seplen l\n\nlet cat = ( ^ )\n\n(* duplicated in bytes.ml *)\nlet iter f s =\n for i = 0 to length s - 1 do f (unsafe_get s i) done\n\n(* duplicated in bytes.ml *)\nlet iteri f s =\n for i = 0 to length s - 1 do f i (unsafe_get s i) done\n\nlet map f s =\n B.map f (bos s) |> bts\nlet mapi f s =\n B.mapi f (bos s) |> bts\nlet fold_right f x a =\n B.fold_right f (bos x) a\nlet fold_left f a x =\n B.fold_left f a (bos x)\nlet exists f s =\n B.exists f (bos s)\nlet for_all f s =\n B.for_all f (bos s)\n\n(* Beware: we cannot use B.trim or B.escape because they always make a\n copy, but String.mli spells out some cases where we are not allowed\n to make a copy. *)\n\nlet is_space = function\n | ' ' | '\\012' | '\\n' | '\\r' | '\\t' -> true\n | _ -> false\n\nlet trim s =\n if s = \"\" then s\n else if is_space (unsafe_get s 0) || is_space (unsafe_get s (length s - 1))\n then bts (B.trim (bos s))\n else s\n\nlet escaped s =\n let rec escape_if_needed s n i =\n if i >= n then s else\n match unsafe_get s i with\n | '\\\"' | '\\\\' | '\\000'..'\\031' | '\\127'.. '\\255' ->\n bts (B.escaped (bos s))\n | _ -> escape_if_needed s n (i+1)\n in\n escape_if_needed s (length s) 0\n\n(* duplicated in bytes.ml *)\nlet rec index_rec s lim i c =\n if i >= lim then raise Not_found else\n if unsafe_get s i = c then i else index_rec s lim (i + 1) c\n\n(* duplicated in bytes.ml *)\nlet index s c = index_rec s (length s) 0 c\n\n(* duplicated in bytes.ml *)\nlet rec index_rec_opt s lim i c =\n if i >= lim then None else\n if unsafe_get s i = c then Some i else index_rec_opt s lim (i + 1) c\n\n(* duplicated in bytes.ml *)\nlet index_opt s c = index_rec_opt s (length s) 0 c\n\n(* duplicated in bytes.ml *)\nlet index_from s i c =\n let l = length s in\n if i < 0 || i > l then invalid_arg \"String.index_from / Bytes.index_from\" else\n index_rec s l i c\n\n(* duplicated in bytes.ml *)\nlet index_from_opt s i c =\n let l = length s in\n if i < 0 || i > l then\n invalid_arg \"String.index_from_opt / Bytes.index_from_opt\"\n else\n index_rec_opt s l i c\n\n(* duplicated in bytes.ml *)\nlet rec rindex_rec s i c =\n if i < 0 then raise Not_found else\n if unsafe_get s i = c then i else rindex_rec s (i - 1) c\n\n(* duplicated in bytes.ml *)\nlet rindex s c = rindex_rec s (length s - 1) c\n\n(* duplicated in bytes.ml *)\nlet rindex_from s i c =\n if i < -1 || i >= length s then\n invalid_arg \"String.rindex_from / Bytes.rindex_from\"\n else\n rindex_rec s i c\n\n(* duplicated in bytes.ml *)\nlet rec rindex_rec_opt s i c =\n if i < 0 then None else\n if unsafe_get s i = c then Some i else rindex_rec_opt s (i - 1) c\n\n(* duplicated in bytes.ml *)\nlet rindex_opt s c = rindex_rec_opt s (length s - 1) c\n\n(* duplicated in bytes.ml *)\nlet rindex_from_opt s i c =\n if i < -1 || i >= length s then\n invalid_arg \"String.rindex_from_opt / Bytes.rindex_from_opt\"\n else\n rindex_rec_opt s i c\n\n(* duplicated in bytes.ml *)\nlet contains_from s i c =\n let l = length s in\n if i < 0 || i > l then\n invalid_arg \"String.contains_from / Bytes.contains_from\"\n else\n try ignore (index_rec s l i c); true with Not_found -> false\n\n(* duplicated in bytes.ml *)\nlet contains s c = contains_from s 0 c\n\n(* duplicated in bytes.ml *)\nlet rcontains_from s i c =\n if i < 0 || i >= length s then\n invalid_arg \"String.rcontains_from / Bytes.rcontains_from\"\n else\n try ignore (rindex_rec s i c); true with Not_found -> false\n\nlet uppercase_ascii s =\n B.uppercase_ascii (bos s) |> bts\nlet lowercase_ascii s =\n B.lowercase_ascii (bos s) |> bts\nlet capitalize_ascii s =\n B.capitalize_ascii (bos s) |> bts\nlet uncapitalize_ascii s =\n B.uncapitalize_ascii (bos s) |> bts\n\n(* duplicated in bytes.ml *)\nlet starts_with ~prefix s =\n let len_s = length s\n and len_pre = length prefix in\n let rec aux i =\n if i = len_pre then true\n else if unsafe_get s i <> unsafe_get prefix i then false\n else aux (i + 1)\n in len_s >= len_pre && aux 0\n\n(* duplicated in bytes.ml *)\nlet ends_with ~suffix s =\n let len_s = length s\n and len_suf = length suffix in\n let diff = len_s - len_suf in\n let rec aux i =\n if i = len_suf then true\n else if unsafe_get s (diff + i) <> unsafe_get suffix i then false\n else aux (i + 1)\n in diff >= 0 && aux 0\n\n(* duplicated in bytes.ml *)\nlet split_on_char sep s =\n let r = ref [] in\n let j = ref (length s) in\n for i = length s - 1 downto 0 do\n if unsafe_get s i = sep then begin\n r := sub s (i + 1) (!j - i - 1) :: !r;\n j := i\n end\n done;\n sub s 0 !j :: !r\n\n(* Deprecated functions implemented via other deprecated functions *)\n[@@@ocaml.warning \"-3\"]\nlet uppercase s =\n B.uppercase (bos s) |> bts\nlet lowercase s =\n B.lowercase (bos s) |> bts\nlet capitalize s =\n B.capitalize (bos s) |> bts\nlet uncapitalize s =\n B.uncapitalize (bos s) |> bts\n\ntype t = string\n\nlet compare (x: t) (y: t) = Stdlib.compare x y\nexternal equal : string -> string -> bool = \"caml_string_equal\" [@@noalloc]\n\n(** {1 Iterators} *)\n\nlet to_seq s = bos s |> B.to_seq\n\nlet to_seqi s = bos s |> B.to_seqi\n\nlet of_seq g = B.of_seq g |> bts\n\n(* UTF decoders and validators *)\n\nlet get_utf_8_uchar s i = B.get_utf_8_uchar (bos s) i\nlet is_valid_utf_8 s = B.is_valid_utf_8 (bos s)\n\nlet get_utf_16be_uchar s i = B.get_utf_16be_uchar (bos s) i\nlet is_valid_utf_16be s = B.is_valid_utf_16be (bos s)\n\nlet get_utf_16le_uchar s i = B.get_utf_16le_uchar (bos s) i\nlet is_valid_utf_16le s = B.is_valid_utf_16le (bos s)\n\n(** {6 Binary encoding/decoding of integers} *)\n\nexternal get_uint8 : string -> int -> int = \"%string_safe_get\"\nexternal get_uint16_ne : string -> int -> int = \"%caml_string_get16\"\nexternal get_int32_ne : string -> int -> int32 = \"%caml_string_get32\"\nexternal get_int64_ne : string -> int -> int64 = \"%caml_string_get64\"\n\nlet get_int8 s i = B.get_int8 (bos s) i\nlet get_uint16_le s i = B.get_uint16_le (bos s) i\nlet get_uint16_be s i = B.get_uint16_be (bos s) i\nlet get_int16_ne s i = B.get_int16_ne (bos s) i\nlet get_int16_le s i = B.get_int16_le (bos s) i\nlet get_int16_be s i = B.get_int16_be (bos s) i\nlet get_int32_le s i = B.get_int32_le (bos s) i\nlet get_int32_be s i = B.get_int32_be (bos s) i\nlet get_int64_le s i = B.get_int64_le (bos s) i\nlet get_int64_be s i = B.get_int64_be (bos s) i\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1997 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\ntype extern_flags =\n No_sharing\n | Closures\n | Compat_32\n(* note: this type definition is used in 'runtime/debugger.c' *)\n\nexternal to_channel: out_channel -> 'a -> extern_flags list -> unit\n = \"caml_output_value\"\nexternal to_bytes: 'a -> extern_flags list -> bytes\n = \"caml_output_value_to_bytes\"\nexternal to_string: 'a -> extern_flags list -> string\n = \"caml_output_value_to_string\"\nexternal to_buffer_unsafe:\n bytes -> int -> int -> 'a -> extern_flags list -> int\n = \"caml_output_value_to_buffer\"\n\nlet to_buffer buff ofs len v flags =\n if ofs < 0 || len < 0 || ofs > Bytes.length buff - len\n then invalid_arg \"Marshal.to_buffer: substring out of bounds\"\n else to_buffer_unsafe buff ofs len v flags\n\n(* The functions below use byte sequences as input, never using any\n mutation. It makes sense to use non-mutated [bytes] rather than\n [string], because we really work with sequences of bytes, not\n a text representation.\n*)\n\nexternal from_channel: in_channel -> 'a = \"caml_input_value\"\nexternal from_bytes_unsafe: bytes -> int -> 'a = \"caml_input_value_from_bytes\"\nexternal data_size_unsafe: bytes -> int -> int = \"caml_marshal_data_size\"\n\nlet header_size = 20\nlet data_size buff ofs =\n if ofs < 0 || ofs > Bytes.length buff - header_size\n then invalid_arg \"Marshal.data_size\"\n else data_size_unsafe buff ofs\nlet total_size buff ofs = header_size + data_size buff ofs\n\nlet from_bytes buff ofs =\n if ofs < 0 || ofs > Bytes.length buff - header_size\n then invalid_arg \"Marshal.from_bytes\"\n else begin\n let len = data_size_unsafe buff ofs in\n if ofs > Bytes.length buff - (header_size + len)\n then invalid_arg \"Marshal.from_bytes\"\n else from_bytes_unsafe buff ofs\n end\n\nlet from_string buff ofs =\n (* Bytes.unsafe_of_string is safe here, as the produced byte\n sequence is never mutated *)\n from_bytes (Bytes.unsafe_of_string buff) ofs\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* An alias for the type of arrays. *)\ntype 'a t = 'a array\n\n(* Array operations *)\n\nexternal length : 'a array -> int = \"%array_length\"\nexternal get: 'a array -> int -> 'a = \"%array_safe_get\"\nexternal set: 'a array -> int -> 'a -> unit = \"%array_safe_set\"\nexternal unsafe_get: 'a array -> int -> 'a = \"%array_unsafe_get\"\nexternal unsafe_set: 'a array -> int -> 'a -> unit = \"%array_unsafe_set\"\nexternal make: int -> 'a -> 'a array = \"caml_make_vect\"\nexternal create: int -> 'a -> 'a array = \"caml_make_vect\"\nexternal unsafe_sub : 'a array -> int -> int -> 'a array = \"caml_array_sub\"\nexternal append_prim : 'a array -> 'a array -> 'a array = \"caml_array_append\"\nexternal concat : 'a array list -> 'a array = \"caml_array_concat\"\nexternal unsafe_blit :\n 'a array -> int -> 'a array -> int -> int -> unit = \"caml_array_blit\"\nexternal unsafe_fill :\n 'a array -> int -> int -> 'a -> unit = \"caml_array_fill\"\nexternal create_float: int -> float array = \"caml_make_float_vect\"\nlet make_float = create_float\n\nmodule Floatarray = struct\n external create : int -> floatarray = \"caml_floatarray_create\"\n external length : floatarray -> int = \"%floatarray_length\"\n external get : floatarray -> int -> float = \"%floatarray_safe_get\"\n external set : floatarray -> int -> float -> unit = \"%floatarray_safe_set\"\n external unsafe_get : floatarray -> int -> float = \"%floatarray_unsafe_get\"\n external unsafe_set : floatarray -> int -> float -> unit\n = \"%floatarray_unsafe_set\"\nend\n\nlet init l f =\n if l = 0 then [||] else\n if l < 0 then invalid_arg \"Array.init\"\n (* See #6575. We could also check for maximum array size, but this depends\n on whether we create a float array or a regular one... *)\n else\n let res = create l (f 0) in\n for i = 1 to pred l do\n unsafe_set res i (f i)\n done;\n res\n\nlet make_matrix sx sy init =\n let res = create sx [||] in\n for x = 0 to pred sx do\n unsafe_set res x (create sy init)\n done;\n res\n\nlet create_matrix = make_matrix\n\nlet copy a =\n let l = length a in if l = 0 then [||] else unsafe_sub a 0 l\n\nlet append a1 a2 =\n let l1 = length a1 in\n if l1 = 0 then copy a2\n else if length a2 = 0 then unsafe_sub a1 0 l1\n else append_prim a1 a2\n\nlet sub a ofs len =\n if ofs < 0 || len < 0 || ofs > length a - len\n then invalid_arg \"Array.sub\"\n else unsafe_sub a ofs len\n\nlet fill a ofs len v =\n if ofs < 0 || len < 0 || ofs > length a - len\n then invalid_arg \"Array.fill\"\n else unsafe_fill a ofs len v\n\nlet blit a1 ofs1 a2 ofs2 len =\n if len < 0 || ofs1 < 0 || ofs1 > length a1 - len\n || ofs2 < 0 || ofs2 > length a2 - len\n then invalid_arg \"Array.blit\"\n else unsafe_blit a1 ofs1 a2 ofs2 len\n\nlet iter f a =\n for i = 0 to length a - 1 do f(unsafe_get a i) done\n\nlet iter2 f a b =\n if length a <> length b then\n invalid_arg \"Array.iter2: arrays must have the same length\"\n else\n for i = 0 to length a - 1 do f (unsafe_get a i) (unsafe_get b i) done\n\nlet map f a =\n let l = length a in\n if l = 0 then [||] else begin\n let r = create l (f(unsafe_get a 0)) in\n for i = 1 to l - 1 do\n unsafe_set r i (f(unsafe_get a i))\n done;\n r\n end\n\nlet map2 f a b =\n let la = length a in\n let lb = length b in\n if la <> lb then\n invalid_arg \"Array.map2: arrays must have the same length\"\n else begin\n if la = 0 then [||] else begin\n let r = create la (f (unsafe_get a 0) (unsafe_get b 0)) in\n for i = 1 to la - 1 do\n unsafe_set r i (f (unsafe_get a i) (unsafe_get b i))\n done;\n r\n end\n end\n\nlet iteri f a =\n for i = 0 to length a - 1 do f i (unsafe_get a i) done\n\nlet mapi f a =\n let l = length a in\n if l = 0 then [||] else begin\n let r = create l (f 0 (unsafe_get a 0)) in\n for i = 1 to l - 1 do\n unsafe_set r i (f i (unsafe_get a i))\n done;\n r\n end\n\nlet to_list a =\n let rec tolist i res =\n if i < 0 then res else tolist (i - 1) (unsafe_get a i :: res) in\n tolist (length a - 1) []\n\n(* Cannot use List.length here because the List module depends on Array. *)\nlet rec list_length accu = function\n | [] -> accu\n | _::t -> list_length (succ accu) t\n\nlet of_list = function\n [] -> [||]\n | hd::tl as l ->\n let a = create (list_length 0 l) hd in\n let rec fill i = function\n [] -> a\n | hd::tl -> unsafe_set a i hd; fill (i+1) tl in\n fill 1 tl\n\nlet fold_left f x a =\n let r = ref x in\n for i = 0 to length a - 1 do\n r := f !r (unsafe_get a i)\n done;\n !r\n\nlet fold_left_map f acc input_array =\n let len = length input_array in\n if len = 0 then (acc, [||]) else begin\n let acc, elt = f acc (unsafe_get input_array 0) in\n let output_array = create len elt in\n let acc = ref acc in\n for i = 1 to len - 1 do\n let acc', elt = f !acc (unsafe_get input_array i) in\n acc := acc';\n unsafe_set output_array i elt;\n done;\n !acc, output_array\n end\n\nlet fold_right f a x =\n let r = ref x in\n for i = length a - 1 downto 0 do\n r := f (unsafe_get a i) !r\n done;\n !r\n\nlet exists p a =\n let n = length a in\n let rec loop i =\n if i = n then false\n else if p (unsafe_get a i) then true\n else loop (succ i) in\n loop 0\n\nlet for_all p a =\n let n = length a in\n let rec loop i =\n if i = n then true\n else if p (unsafe_get a i) then loop (succ i)\n else false in\n loop 0\n\nlet for_all2 p l1 l2 =\n let n1 = length l1\n and n2 = length l2 in\n if n1 <> n2 then invalid_arg \"Array.for_all2\"\n else let rec loop i =\n if i = n1 then true\n else if p (unsafe_get l1 i) (unsafe_get l2 i) then loop (succ i)\n else false in\n loop 0\n\nlet exists2 p l1 l2 =\n let n1 = length l1\n and n2 = length l2 in\n if n1 <> n2 then invalid_arg \"Array.exists2\"\n else let rec loop i =\n if i = n1 then false\n else if p (unsafe_get l1 i) (unsafe_get l2 i) then true\n else loop (succ i) in\n loop 0\n\nlet mem x a =\n let n = length a in\n let rec loop i =\n if i = n then false\n else if compare (unsafe_get a i) x = 0 then true\n else loop (succ i) in\n loop 0\n\nlet memq x a =\n let n = length a in\n let rec loop i =\n if i = n then false\n else if x == (unsafe_get a i) then true\n else loop (succ i) in\n loop 0\n\nlet find_opt p a =\n let n = length a in\n let rec loop i =\n if i = n then None\n else\n let x = unsafe_get a i in\n if p x then Some x\n else loop (succ i)\n in\n loop 0\n\nlet find_map f a =\n let n = length a in\n let rec loop i =\n if i = n then None\n else\n match f (unsafe_get a i) with\n | None -> loop (succ i)\n | Some _ as r -> r\n in\n loop 0\n\nlet split x =\n if x = [||] then [||], [||]\n else begin\n let a0, b0 = unsafe_get x 0 in\n let n = length x in\n let a = create n a0 in\n let b = create n b0 in\n for i = 1 to n - 1 do\n let ai, bi = unsafe_get x i in\n unsafe_set a i ai;\n unsafe_set b i bi\n done;\n a, b\n end\n\nlet combine a b =\n let na = length a in\n let nb = length b in\n if na <> nb then invalid_arg \"Array.combine\";\n if na = 0 then [||]\n else begin\n let x = create na (unsafe_get a 0, unsafe_get b 0) in\n for i = 1 to na - 1 do\n unsafe_set x i (unsafe_get a i, unsafe_get b i)\n done;\n x\n end\n\nexception Bottom of int\nlet sort cmp a =\n let maxson l i =\n let i31 = i+i+i+1 in\n let x = ref i31 in\n if i31+2 < l then begin\n if cmp (get a i31) (get a (i31+1)) < 0 then x := i31+1;\n if cmp (get a !x) (get a (i31+2)) < 0 then x := i31+2;\n !x\n end else\n if i31+1 < l && cmp (get a i31) (get a (i31+1)) < 0\n then i31+1\n else if i31 < l then i31 else raise (Bottom i)\n in\n let rec trickledown l i e =\n let j = maxson l i in\n if cmp (get a j) e > 0 then begin\n set a i (get a j);\n trickledown l j e;\n end else begin\n set a i e;\n end;\n in\n let trickle l i e = try trickledown l i e with Bottom i -> set a i e in\n let rec bubbledown l i =\n let j = maxson l i in\n set a i (get a j);\n bubbledown l j\n in\n let bubble l i = try bubbledown l i with Bottom i -> i in\n let rec trickleup i e =\n let father = (i - 1) / 3 in\n assert (i <> father);\n if cmp (get a father) e < 0 then begin\n set a i (get a father);\n if father > 0 then trickleup father e else set a 0 e;\n end else begin\n set a i e;\n end;\n in\n let l = length a in\n for i = (l + 1) / 3 - 1 downto 0 do trickle l i (get a i); done;\n for i = l - 1 downto 2 do\n let e = (get a i) in\n set a i (get a 0);\n trickleup (bubble i 0) e;\n done;\n if l > 1 then (let e = (get a 1) in set a 1 (get a 0); set a 0 e)\n\n\nlet cutoff = 5\nlet stable_sort cmp a =\n let merge src1ofs src1len src2 src2ofs src2len dst dstofs =\n let src1r = src1ofs + src1len and src2r = src2ofs + src2len in\n let rec loop i1 s1 i2 s2 d =\n if cmp s1 s2 <= 0 then begin\n set dst d s1;\n let i1 = i1 + 1 in\n if i1 < src1r then\n loop i1 (get a i1) i2 s2 (d + 1)\n else\n blit src2 i2 dst (d + 1) (src2r - i2)\n end else begin\n set dst d s2;\n let i2 = i2 + 1 in\n if i2 < src2r then\n loop i1 s1 i2 (get src2 i2) (d + 1)\n else\n blit a i1 dst (d + 1) (src1r - i1)\n end\n in loop src1ofs (get a src1ofs) src2ofs (get src2 src2ofs) dstofs;\n in\n let isortto srcofs dst dstofs len =\n for i = 0 to len - 1 do\n let e = (get a (srcofs + i)) in\n let j = ref (dstofs + i - 1) in\n while (!j >= dstofs && cmp (get dst !j) e > 0) do\n set dst (!j + 1) (get dst !j);\n decr j;\n done;\n set dst (!j + 1) e;\n done;\n in\n let rec sortto srcofs dst dstofs len =\n if len <= cutoff then isortto srcofs dst dstofs len else begin\n let l1 = len / 2 in\n let l2 = len - l1 in\n sortto (srcofs + l1) dst (dstofs + l1) l2;\n sortto srcofs a (srcofs + l2) l1;\n merge (srcofs + l2) l1 dst (dstofs + l1) l2 dst dstofs;\n end;\n in\n let l = length a in\n if l <= cutoff then isortto 0 a 0 l else begin\n let l1 = l / 2 in\n let l2 = l - l1 in\n let t = make l2 (get a 0) in\n sortto l1 t 0 l2;\n sortto 0 a l2 l1;\n merge l2 l1 t 0 l2 a 0;\n end\n\n\nlet fast_sort = stable_sort\n\n(** {1 Iterators} *)\n\nlet to_seq a =\n let rec aux i () =\n if i < length a\n then\n let x = unsafe_get a i in\n Seq.Cons (x, aux (i+1))\n else Seq.Nil\n in\n aux 0\n\nlet to_seqi a =\n let rec aux i () =\n if i < length a\n then\n let x = unsafe_get a i in\n Seq.Cons ((i,x), aux (i+1))\n else Seq.Nil\n in\n aux 0\n\nlet of_rev_list = function\n [] -> [||]\n | hd::tl as l ->\n let len = list_length 0 l in\n let a = create len hd in\n let rec fill i = function\n [] -> a\n | hd::tl -> unsafe_set a i hd; fill (i-1) tl\n in\n fill (len-2) tl\n\nlet of_seq i =\n let l = Seq.fold_left (fun acc x -> x::acc) [] i in\n of_rev_list l\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* Module [Int32]: 32-bit integers *)\n\nexternal neg : int32 -> int32 = \"%int32_neg\"\nexternal add : int32 -> int32 -> int32 = \"%int32_add\"\nexternal sub : int32 -> int32 -> int32 = \"%int32_sub\"\nexternal mul : int32 -> int32 -> int32 = \"%int32_mul\"\nexternal div : int32 -> int32 -> int32 = \"%int32_div\"\nexternal rem : int32 -> int32 -> int32 = \"%int32_mod\"\nexternal logand : int32 -> int32 -> int32 = \"%int32_and\"\nexternal logor : int32 -> int32 -> int32 = \"%int32_or\"\nexternal logxor : int32 -> int32 -> int32 = \"%int32_xor\"\nexternal shift_left : int32 -> int -> int32 = \"%int32_lsl\"\nexternal shift_right : int32 -> int -> int32 = \"%int32_asr\"\nexternal shift_right_logical : int32 -> int -> int32 = \"%int32_lsr\"\nexternal of_int : int -> int32 = \"%int32_of_int\"\nexternal to_int : int32 -> int = \"%int32_to_int\"\nexternal of_float : float -> int32\n = \"caml_int32_of_float\" \"caml_int32_of_float_unboxed\"\n [@@unboxed] [@@noalloc]\nexternal to_float : int32 -> float\n = \"caml_int32_to_float\" \"caml_int32_to_float_unboxed\"\n [@@unboxed] [@@noalloc]\nexternal bits_of_float : float -> int32\n = \"caml_int32_bits_of_float\" \"caml_int32_bits_of_float_unboxed\"\n [@@unboxed] [@@noalloc]\nexternal float_of_bits : int32 -> float\n = \"caml_int32_float_of_bits\" \"caml_int32_float_of_bits_unboxed\"\n [@@unboxed] [@@noalloc]\n\nlet zero = 0l\nlet one = 1l\nlet minus_one = -1l\nlet succ n = add n 1l\nlet pred n = sub n 1l\nlet abs n = if n >= 0l then n else neg n\nlet min_int = 0x80000000l\nlet max_int = 0x7FFFFFFFl\nlet lognot n = logxor n (-1l)\n\nlet unsigned_to_int =\n match Sys.word_size with\n | 32 ->\n let max_int = of_int Stdlib.max_int in\n fun n ->\n if compare zero n <= 0 && compare n max_int <= 0 then\n Some (to_int n)\n else\n None\n | 64 ->\n (* So that it compiles in 32-bit *)\n let mask = 0xFFFF lsl 16 lor 0xFFFF in\n fun n -> Some (to_int n land mask)\n | _ ->\n assert false\n\nexternal format : string -> int32 -> string = \"caml_int32_format\"\nlet to_string n = format \"%d\" n\n\nexternal of_string : string -> int32 = \"caml_int32_of_string\"\n\nlet of_string_opt s =\n (* TODO: expose a non-raising primitive directly. *)\n try Some (of_string s)\n with Failure _ -> None\n\ntype t = int32\n\nlet compare (x: t) (y: t) = Stdlib.compare x y\nlet equal (x: t) (y: t) = compare x y = 0\n\nlet unsigned_compare n m =\n compare (sub n min_int) (sub m min_int)\n\nlet min x y : t = if x <= y then x else y\nlet max x y : t = if x >= y then x else y\n\n(* Unsigned division from signed division of the same\n bitness. See Warren Jr., Henry S. (2013). Hacker's Delight (2 ed.), Sec 9-3.\n*)\nlet unsigned_div n d =\n if d < zero then\n if unsigned_compare n d < 0 then zero else one\n else\n let q = shift_left (div (shift_right_logical n 1) d) 1 in\n let r = sub n (mul q d) in\n if unsigned_compare r d >= 0 then succ q else q\n\nlet unsigned_rem n d =\n sub n (mul (unsigned_div n d) d)\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* Module [Nativeint]: processor-native integers *)\n\nexternal neg: nativeint -> nativeint = \"%nativeint_neg\"\nexternal add: nativeint -> nativeint -> nativeint = \"%nativeint_add\"\nexternal sub: nativeint -> nativeint -> nativeint = \"%nativeint_sub\"\nexternal mul: nativeint -> nativeint -> nativeint = \"%nativeint_mul\"\nexternal div: nativeint -> nativeint -> nativeint = \"%nativeint_div\"\nexternal rem: nativeint -> nativeint -> nativeint = \"%nativeint_mod\"\nexternal logand: nativeint -> nativeint -> nativeint = \"%nativeint_and\"\nexternal logor: nativeint -> nativeint -> nativeint = \"%nativeint_or\"\nexternal logxor: nativeint -> nativeint -> nativeint = \"%nativeint_xor\"\nexternal shift_left: nativeint -> int -> nativeint = \"%nativeint_lsl\"\nexternal shift_right: nativeint -> int -> nativeint = \"%nativeint_asr\"\nexternal shift_right_logical: nativeint -> int -> nativeint = \"%nativeint_lsr\"\nexternal of_int: int -> nativeint = \"%nativeint_of_int\"\nexternal to_int: nativeint -> int = \"%nativeint_to_int\"\nexternal of_float : float -> nativeint\n = \"caml_nativeint_of_float\" \"caml_nativeint_of_float_unboxed\"\n [@@unboxed] [@@noalloc]\nexternal to_float : nativeint -> float\n = \"caml_nativeint_to_float\" \"caml_nativeint_to_float_unboxed\"\n [@@unboxed] [@@noalloc]\nexternal of_int32: int32 -> nativeint = \"%nativeint_of_int32\"\nexternal to_int32: nativeint -> int32 = \"%nativeint_to_int32\"\n\nlet zero = 0n\nlet one = 1n\nlet minus_one = -1n\nlet succ n = add n 1n\nlet pred n = sub n 1n\nlet abs n = if n >= 0n then n else neg n\nlet size = Sys.word_size\nlet min_int = shift_left 1n (size - 1)\nlet max_int = sub min_int 1n\nlet lognot n = logxor n (-1n)\n\nlet unsigned_to_int =\n let max_int = of_int Stdlib.max_int in\n fun n ->\n if compare zero n <= 0 && compare n max_int <= 0 then\n Some (to_int n)\n else\n None\n\nexternal format : string -> nativeint -> string = \"caml_nativeint_format\"\nlet to_string n = format \"%d\" n\n\nexternal of_string: string -> nativeint = \"caml_nativeint_of_string\"\n\nlet of_string_opt s =\n (* TODO: expose a non-raising primitive directly. *)\n try Some (of_string s)\n with Failure _ -> None\n\ntype t = nativeint\n\nlet compare (x: t) (y: t) = Stdlib.compare x y\nlet equal (x: t) (y: t) = compare x y = 0\n\nlet unsigned_compare n m =\n compare (sub n min_int) (sub m min_int)\n\nlet min x y : t = if x <= y then x else y\nlet max x y : t = if x >= y then x else y\n\n(* Unsigned division from signed division of the same\n bitness. See Warren Jr., Henry S. (2013). Hacker's Delight (2 ed.), Sec 9-3.\n*)\nlet unsigned_div n d =\n if d < zero then\n if unsigned_compare n d < 0 then zero else one\n else\n let q = shift_left (div (shift_right_logical n 1) d) 1 in\n let r = sub n (mul q d) in\n if unsigned_compare r d >= 0 then succ q else q\n\nlet unsigned_rem n d =\n sub n (mul (unsigned_div n d) d)\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* The parsing engine *)\n\nopen Lexing\n\n(* Internal interface to the parsing engine *)\n\ntype parser_env =\n { mutable s_stack : int array; (* States *)\n mutable v_stack : Obj.t array; (* Semantic attributes *)\n mutable symb_start_stack : position array; (* Start positions *)\n mutable symb_end_stack : position array; (* End positions *)\n mutable stacksize : int; (* Size of the stacks *)\n mutable stackbase : int; (* Base sp for current parse *)\n mutable curr_char : int; (* Last token read *)\n mutable lval : Obj.t; (* Its semantic attribute *)\n mutable symb_start : position; (* Start pos. of the current symbol*)\n mutable symb_end : position; (* End pos. of the current symbol *)\n mutable asp : int; (* The stack pointer for attributes *)\n mutable rule_len : int; (* Number of rhs items in the rule *)\n mutable rule_number : int; (* Rule number to reduce by *)\n mutable sp : int; (* Saved sp for parse_engine *)\n mutable state : int; (* Saved state for parse_engine *)\n mutable errflag : int } (* Saved error flag for parse_engine *)\n[@@warning \"-unused-field\"]\n\ntype parse_tables =\n { actions : (parser_env -> Obj.t) array;\n transl_const : int array;\n transl_block : int array;\n lhs : string;\n len : string;\n defred : string;\n dgoto : string;\n sindex : string;\n rindex : string;\n gindex : string;\n tablesize : int;\n table : string;\n check : string;\n error_function : string -> unit;\n names_const : string;\n names_block : string }\n\nexception YYexit of Obj.t\nexception Parse_error\n\ntype parser_input =\n Start\n | Token_read\n | Stacks_grown_1\n | Stacks_grown_2\n | Semantic_action_computed\n | Error_detected\n\ntype parser_output =\n Read_token\n | Raise_parse_error\n | Grow_stacks_1\n | Grow_stacks_2\n | Compute_semantic_action\n | Call_error_function\n\n(* to avoid warnings *)\nlet _ = [Read_token; Raise_parse_error; Grow_stacks_1; Grow_stacks_2;\n Compute_semantic_action; Call_error_function]\n\nexternal parse_engine :\n parse_tables -> parser_env -> parser_input -> Obj.t -> parser_output\n = \"caml_parse_engine\"\n\nexternal set_trace: bool -> bool\n = \"caml_set_parser_trace\"\n\nlet env =\n { s_stack = Array.make 100 0;\n v_stack = Array.make 100 (Obj.repr ());\n symb_start_stack = Array.make 100 dummy_pos;\n symb_end_stack = Array.make 100 dummy_pos;\n stacksize = 100;\n stackbase = 0;\n curr_char = 0;\n lval = Obj.repr ();\n symb_start = dummy_pos;\n symb_end = dummy_pos;\n asp = 0;\n rule_len = 0;\n rule_number = 0;\n sp = 0;\n state = 0;\n errflag = 0 }\n\nlet grow_stacks() =\n let oldsize = env.stacksize in\n let newsize = oldsize * 2 in\n let new_s = Array.make newsize 0\n and new_v = Array.make newsize (Obj.repr ())\n and new_start = Array.make newsize dummy_pos\n and new_end = Array.make newsize dummy_pos in\n Array.blit env.s_stack 0 new_s 0 oldsize;\n env.s_stack <- new_s;\n Array.blit env.v_stack 0 new_v 0 oldsize;\n env.v_stack <- new_v;\n Array.blit env.symb_start_stack 0 new_start 0 oldsize;\n env.symb_start_stack <- new_start;\n Array.blit env.symb_end_stack 0 new_end 0 oldsize;\n env.symb_end_stack <- new_end;\n env.stacksize <- newsize\n\nlet clear_parser() =\n Array.fill env.v_stack 0 env.stacksize (Obj.repr ());\n env.lval <- Obj.repr ()\n\nlet current_lookahead_fun = ref (fun (_ : Obj.t) -> false)\n\nlet yyparse tables start lexer lexbuf =\n let rec loop cmd arg =\n match parse_engine tables env cmd arg with\n Read_token ->\n let t = Obj.repr(lexer lexbuf) in\n env.symb_start <- lexbuf.lex_start_p;\n env.symb_end <- lexbuf.lex_curr_p;\n loop Token_read t\n | Raise_parse_error ->\n raise Parse_error\n | Compute_semantic_action ->\n let (action, value) =\n try\n (Semantic_action_computed, tables.actions.(env.rule_number) env)\n with Parse_error ->\n (Error_detected, Obj.repr ()) in\n loop action value\n | Grow_stacks_1 ->\n grow_stacks(); loop Stacks_grown_1 (Obj.repr ())\n | Grow_stacks_2 ->\n grow_stacks(); loop Stacks_grown_2 (Obj.repr ())\n | Call_error_function ->\n tables.error_function \"syntax error\";\n loop Error_detected (Obj.repr ()) in\n let init_asp = env.asp\n and init_sp = env.sp\n and init_stackbase = env.stackbase\n and init_state = env.state\n and init_curr_char = env.curr_char\n and init_lval = env.lval\n and init_errflag = env.errflag in\n env.stackbase <- env.sp + 1;\n env.curr_char <- start;\n env.symb_end <- lexbuf.lex_curr_p;\n try\n loop Start (Obj.repr ())\n with exn ->\n let curr_char = env.curr_char in\n env.asp <- init_asp;\n env.sp <- init_sp;\n env.stackbase <- init_stackbase;\n env.state <- init_state;\n env.curr_char <- init_curr_char;\n env.lval <- init_lval;\n env.errflag <- init_errflag;\n match exn with\n YYexit v ->\n Obj.magic v\n | _ ->\n current_lookahead_fun :=\n (fun tok ->\n if Obj.is_block tok\n then tables.transl_block.(Obj.tag tok) = curr_char\n else tables.transl_const.(Obj.magic tok) = curr_char);\n raise exn\n\nlet peek_val env n =\n Obj.magic env.v_stack.(env.asp - n)\n\nlet symbol_start_pos () =\n let rec loop i =\n if i <= 0 then env.symb_end_stack.(env.asp)\n else begin\n let st = env.symb_start_stack.(env.asp - i + 1) in\n let en = env.symb_end_stack.(env.asp - i + 1) in\n if st <> en then st else loop (i - 1)\n end\n in\n loop env.rule_len\n\nlet symbol_end_pos () = env.symb_end_stack.(env.asp)\nlet rhs_start_pos n = env.symb_start_stack.(env.asp - (env.rule_len - n))\nlet rhs_end_pos n = env.symb_end_stack.(env.asp - (env.rule_len - n))\n\nlet symbol_start () = (symbol_start_pos ()).pos_cnum\nlet symbol_end () = (symbol_end_pos ()).pos_cnum\nlet rhs_start n = (rhs_start_pos n).pos_cnum\nlet rhs_end n = (rhs_end_pos n).pos_cnum\n\nlet is_current_lookahead tok =\n (!current_lookahead_fun)(Obj.repr tok)\n\nlet parse_error (_ : string) = ()\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* Sets over ordered types *)\n\nmodule type OrderedType =\n sig\n type t\n val compare: t -> t -> int\n end\n\nmodule type S =\n sig\n type elt\n type t\n val empty: t\n val is_empty: t -> bool\n val mem: elt -> t -> bool\n val add: elt -> t -> t\n val singleton: elt -> t\n val remove: elt -> t -> t\n val union: t -> t -> t\n val inter: t -> t -> t\n val disjoint: t -> t -> bool\n val diff: t -> t -> t\n val compare: t -> t -> int\n val equal: t -> t -> bool\n val subset: t -> t -> bool\n val iter: (elt -> unit) -> t -> unit\n val map: (elt -> elt) -> t -> t\n val fold: (elt -> 'a -> 'a) -> t -> 'a -> 'a\n val for_all: (elt -> bool) -> t -> bool\n val exists: (elt -> bool) -> t -> bool\n val filter: (elt -> bool) -> t -> t\n val filter_map: (elt -> elt option) -> t -> t\n val partition: (elt -> bool) -> t -> t * t\n val cardinal: t -> int\n val elements: t -> elt list\n val min_elt: t -> elt\n val min_elt_opt: t -> elt option\n val max_elt: t -> elt\n val max_elt_opt: t -> elt option\n val choose: t -> elt\n val choose_opt: t -> elt option\n val split: elt -> t -> t * bool * t\n val find: elt -> t -> elt\n val find_opt: elt -> t -> elt option\n val find_first: (elt -> bool) -> t -> elt\n val find_first_opt: (elt -> bool) -> t -> elt option\n val find_last: (elt -> bool) -> t -> elt\n val find_last_opt: (elt -> bool) -> t -> elt option\n val of_list: elt list -> t\n val to_seq_from : elt -> t -> elt Seq.t\n val to_seq : t -> elt Seq.t\n val to_rev_seq : t -> elt Seq.t\n val add_seq : elt Seq.t -> t -> t\n val of_seq : elt Seq.t -> t\n end\n\nmodule Make(Ord: OrderedType) =\n struct\n type elt = Ord.t\n type t = Empty | Node of {l:t; v:elt; r:t; h:int}\n\n (* Sets are represented by balanced binary trees (the heights of the\n children differ by at most 2 *)\n\n let height = function\n Empty -> 0\n | Node {h} -> h\n\n (* Creates a new node with left son l, value v and right son r.\n We must have all elements of l < v < all elements of r.\n l and r must be balanced and | height l - height r | <= 2.\n Inline expansion of height for better speed. *)\n\n let create l v r =\n let hl = match l with Empty -> 0 | Node {h} -> h in\n let hr = match r with Empty -> 0 | Node {h} -> h in\n Node{l; v; r; h=(if hl >= hr then hl + 1 else hr + 1)}\n\n (* Same as create, but performs one step of rebalancing if necessary.\n Assumes l and r balanced and | height l - height r | <= 3.\n Inline expansion of create for better speed in the most frequent case\n where no rebalancing is required. *)\n\n let bal l v r =\n let hl = match l with Empty -> 0 | Node {h} -> h in\n let hr = match r with Empty -> 0 | Node {h} -> h in\n if hl > hr + 2 then begin\n match l with\n Empty -> invalid_arg \"Set.bal\"\n | Node{l=ll; v=lv; r=lr} ->\n if height ll >= height lr then\n create ll lv (create lr v r)\n else begin\n match lr with\n Empty -> invalid_arg \"Set.bal\"\n | Node{l=lrl; v=lrv; r=lrr}->\n create (create ll lv lrl) lrv (create lrr v r)\n end\n end else if hr > hl + 2 then begin\n match r with\n Empty -> invalid_arg \"Set.bal\"\n | Node{l=rl; v=rv; r=rr} ->\n if height rr >= height rl then\n create (create l v rl) rv rr\n else begin\n match rl with\n Empty -> invalid_arg \"Set.bal\"\n | Node{l=rll; v=rlv; r=rlr} ->\n create (create l v rll) rlv (create rlr rv rr)\n end\n end else\n Node{l; v; r; h=(if hl >= hr then hl + 1 else hr + 1)}\n\n (* Insertion of one element *)\n\n let rec add x = function\n Empty -> Node{l=Empty; v=x; r=Empty; h=1}\n | Node{l; v; r} as t ->\n let c = Ord.compare x v in\n if c = 0 then t else\n if c < 0 then\n let ll = add x l in\n if l == ll then t else bal ll v r\n else\n let rr = add x r in\n if r == rr then t else bal l v rr\n\n let singleton x = Node{l=Empty; v=x; r=Empty; h=1}\n\n (* Beware: those two functions assume that the added v is *strictly*\n smaller (or bigger) than all the present elements in the tree; it\n does not test for equality with the current min (or max) element.\n Indeed, they are only used during the \"join\" operation which\n respects this precondition.\n *)\n\n let rec add_min_element x = function\n | Empty -> singleton x\n | Node {l; v; r} ->\n bal (add_min_element x l) v r\n\n let rec add_max_element x = function\n | Empty -> singleton x\n | Node {l; v; r} ->\n bal l v (add_max_element x r)\n\n (* Same as create and bal, but no assumptions are made on the\n relative heights of l and r. *)\n\n let rec join l v r =\n match (l, r) with\n (Empty, _) -> add_min_element v r\n | (_, Empty) -> add_max_element v l\n | (Node{l=ll; v=lv; r=lr; h=lh}, Node{l=rl; v=rv; r=rr; h=rh}) ->\n if lh > rh + 2 then bal ll lv (join lr v r) else\n if rh > lh + 2 then bal (join l v rl) rv rr else\n create l v r\n\n (* Smallest and greatest element of a set *)\n\n let rec min_elt = function\n Empty -> raise Not_found\n | Node{l=Empty; v} -> v\n | Node{l} -> min_elt l\n\n let rec min_elt_opt = function\n Empty -> None\n | Node{l=Empty; v} -> Some v\n | Node{l} -> min_elt_opt l\n\n let rec max_elt = function\n Empty -> raise Not_found\n | Node{v; r=Empty} -> v\n | Node{r} -> max_elt r\n\n let rec max_elt_opt = function\n Empty -> None\n | Node{v; r=Empty} -> Some v\n | Node{r} -> max_elt_opt r\n\n (* Remove the smallest element of the given set *)\n\n let rec remove_min_elt = function\n Empty -> invalid_arg \"Set.remove_min_elt\"\n | Node{l=Empty; r} -> r\n | Node{l; v; r} -> bal (remove_min_elt l) v r\n\n (* Merge two trees l and r into one.\n All elements of l must precede the elements of r.\n Assume | height l - height r | <= 2. *)\n\n let merge t1 t2 =\n match (t1, t2) with\n (Empty, t) -> t\n | (t, Empty) -> t\n | (_, _) -> bal t1 (min_elt t2) (remove_min_elt t2)\n\n (* Merge two trees l and r into one.\n All elements of l must precede the elements of r.\n No assumption on the heights of l and r. *)\n\n let concat t1 t2 =\n match (t1, t2) with\n (Empty, t) -> t\n | (t, Empty) -> t\n | (_, _) -> join t1 (min_elt t2) (remove_min_elt t2)\n\n (* Splitting. split x s returns a triple (l, present, r) where\n - l is the set of elements of s that are < x\n - r is the set of elements of s that are > x\n - present is false if s contains no element equal to x,\n or true if s contains an element equal to x. *)\n\n let rec split x = function\n Empty ->\n (Empty, false, Empty)\n | Node{l; v; r} ->\n let c = Ord.compare x v in\n if c = 0 then (l, true, r)\n else if c < 0 then\n let (ll, pres, rl) = split x l in (ll, pres, join rl v r)\n else\n let (lr, pres, rr) = split x r in (join l v lr, pres, rr)\n\n (* Implementation of the set operations *)\n\n let empty = Empty\n\n let is_empty = function Empty -> true | _ -> false\n\n let rec mem x = function\n Empty -> false\n | Node{l; v; r} ->\n let c = Ord.compare x v in\n c = 0 || mem x (if c < 0 then l else r)\n\n let rec remove x = function\n Empty -> Empty\n | (Node{l; v; r} as t) ->\n let c = Ord.compare x v in\n if c = 0 then merge l r\n else\n if c < 0 then\n let ll = remove x l in\n if l == ll then t\n else bal ll v r\n else\n let rr = remove x r in\n if r == rr then t\n else bal l v rr\n\n let rec union s1 s2 =\n match (s1, s2) with\n (Empty, t2) -> t2\n | (t1, Empty) -> t1\n | (Node{l=l1; v=v1; r=r1; h=h1}, Node{l=l2; v=v2; r=r2; h=h2}) ->\n if h1 >= h2 then\n if h2 = 1 then add v2 s1 else begin\n let (l2, _, r2) = split v1 s2 in\n join (union l1 l2) v1 (union r1 r2)\n end\n else\n if h1 = 1 then add v1 s2 else begin\n let (l1, _, r1) = split v2 s1 in\n join (union l1 l2) v2 (union r1 r2)\n end\n\n let rec inter s1 s2 =\n match (s1, s2) with\n (Empty, _) -> Empty\n | (_, Empty) -> Empty\n | (Node{l=l1; v=v1; r=r1}, t2) ->\n match split v1 t2 with\n (l2, false, r2) ->\n concat (inter l1 l2) (inter r1 r2)\n | (l2, true, r2) ->\n join (inter l1 l2) v1 (inter r1 r2)\n\n (* Same as split, but compute the left and right subtrees\n only if the pivot element is not in the set. The right subtree\n is computed on demand. *)\n\n type split_bis =\n | Found\n | NotFound of t * (unit -> t)\n\n let rec split_bis x = function\n Empty ->\n NotFound (Empty, (fun () -> Empty))\n | Node{l; v; r; _} ->\n let c = Ord.compare x v in\n if c = 0 then Found\n else if c < 0 then\n match split_bis x l with\n | Found -> Found\n | NotFound (ll, rl) -> NotFound (ll, (fun () -> join (rl ()) v r))\n else\n match split_bis x r with\n | Found -> Found\n | NotFound (lr, rr) -> NotFound (join l v lr, rr)\n\n let rec disjoint s1 s2 =\n match (s1, s2) with\n (Empty, _) | (_, Empty) -> true\n | (Node{l=l1; v=v1; r=r1}, t2) ->\n if s1 == s2 then false\n else match split_bis v1 t2 with\n NotFound(l2, r2) -> disjoint l1 l2 && disjoint r1 (r2 ())\n | Found -> false\n\n let rec diff s1 s2 =\n match (s1, s2) with\n (Empty, _) -> Empty\n | (t1, Empty) -> t1\n | (Node{l=l1; v=v1; r=r1}, t2) ->\n match split v1 t2 with\n (l2, false, r2) ->\n join (diff l1 l2) v1 (diff r1 r2)\n | (l2, true, r2) ->\n concat (diff l1 l2) (diff r1 r2)\n\n type enumeration = End | More of elt * t * enumeration\n\n let rec cons_enum s e =\n match s with\n Empty -> e\n | Node{l; v; r} -> cons_enum l (More(v, r, e))\n\n let rec compare_aux e1 e2 =\n match (e1, e2) with\n (End, End) -> 0\n | (End, _) -> -1\n | (_, End) -> 1\n | (More(v1, r1, e1), More(v2, r2, e2)) ->\n let c = Ord.compare v1 v2 in\n if c <> 0\n then c\n else compare_aux (cons_enum r1 e1) (cons_enum r2 e2)\n\n let compare s1 s2 =\n compare_aux (cons_enum s1 End) (cons_enum s2 End)\n\n let equal s1 s2 =\n compare s1 s2 = 0\n\n let rec subset s1 s2 =\n match (s1, s2) with\n Empty, _ ->\n true\n | _, Empty ->\n false\n | Node {l=l1; v=v1; r=r1}, (Node {l=l2; v=v2; r=r2} as t2) ->\n let c = Ord.compare v1 v2 in\n if c = 0 then\n subset l1 l2 && subset r1 r2\n else if c < 0 then\n subset (Node {l=l1; v=v1; r=Empty; h=0}) l2 && subset r1 t2\n else\n subset (Node {l=Empty; v=v1; r=r1; h=0}) r2 && subset l1 t2\n\n let rec iter f = function\n Empty -> ()\n | Node{l; v; r} -> iter f l; f v; iter f r\n\n let rec fold f s accu =\n match s with\n Empty -> accu\n | Node{l; v; r} -> fold f r (f v (fold f l accu))\n\n let rec for_all p = function\n Empty -> true\n | Node{l; v; r} -> p v && for_all p l && for_all p r\n\n let rec exists p = function\n Empty -> false\n | Node{l; v; r} -> p v || exists p l || exists p r\n\n let rec filter p = function\n Empty -> Empty\n | (Node{l; v; r}) as t ->\n (* call [p] in the expected left-to-right order *)\n let l' = filter p l in\n let pv = p v in\n let r' = filter p r in\n if pv then\n if l==l' && r==r' then t else join l' v r'\n else concat l' r'\n\n let rec partition p = function\n Empty -> (Empty, Empty)\n | Node{l; v; r} ->\n (* call [p] in the expected left-to-right order *)\n let (lt, lf) = partition p l in\n let pv = p v in\n let (rt, rf) = partition p r in\n if pv\n then (join lt v rt, concat lf rf)\n else (concat lt rt, join lf v rf)\n\n let rec cardinal = function\n Empty -> 0\n | Node{l; r} -> cardinal l + 1 + cardinal r\n\n let rec elements_aux accu = function\n Empty -> accu\n | Node{l; v; r} -> elements_aux (v :: elements_aux accu r) l\n\n let elements s =\n elements_aux [] s\n\n let choose = min_elt\n\n let choose_opt = min_elt_opt\n\n let rec find x = function\n Empty -> raise Not_found\n | Node{l; v; r} ->\n let c = Ord.compare x v in\n if c = 0 then v\n else find x (if c < 0 then l else r)\n\n let rec find_first_aux v0 f = function\n Empty ->\n v0\n | Node{l; v; r} ->\n if f v then\n find_first_aux v f l\n else\n find_first_aux v0 f r\n\n let rec find_first f = function\n Empty ->\n raise Not_found\n | Node{l; v; r} ->\n if f v then\n find_first_aux v f l\n else\n find_first f r\n\n let rec find_first_opt_aux v0 f = function\n Empty ->\n Some v0\n | Node{l; v; r} ->\n if f v then\n find_first_opt_aux v f l\n else\n find_first_opt_aux v0 f r\n\n let rec find_first_opt f = function\n Empty ->\n None\n | Node{l; v; r} ->\n if f v then\n find_first_opt_aux v f l\n else\n find_first_opt f r\n\n let rec find_last_aux v0 f = function\n Empty ->\n v0\n | Node{l; v; r} ->\n if f v then\n find_last_aux v f r\n else\n find_last_aux v0 f l\n\n let rec find_last f = function\n Empty ->\n raise Not_found\n | Node{l; v; r} ->\n if f v then\n find_last_aux v f r\n else\n find_last f l\n\n let rec find_last_opt_aux v0 f = function\n Empty ->\n Some v0\n | Node{l; v; r} ->\n if f v then\n find_last_opt_aux v f r\n else\n find_last_opt_aux v0 f l\n\n let rec find_last_opt f = function\n Empty ->\n None\n | Node{l; v; r} ->\n if f v then\n find_last_opt_aux v f r\n else\n find_last_opt f l\n\n let rec find_opt x = function\n Empty -> None\n | Node{l; v; r} ->\n let c = Ord.compare x v in\n if c = 0 then Some v\n else find_opt x (if c < 0 then l else r)\n\n let try_join l v r =\n (* [join l v r] can only be called when (elements of l < v <\n elements of r); use [try_join l v r] when this property may\n not hold, but you hope it does hold in the common case *)\n if (l = Empty || Ord.compare (max_elt l) v < 0)\n && (r = Empty || Ord.compare v (min_elt r) < 0)\n then join l v r\n else union l (add v r)\n\n let rec map f = function\n | Empty -> Empty\n | Node{l; v; r} as t ->\n (* enforce left-to-right evaluation order *)\n let l' = map f l in\n let v' = f v in\n let r' = map f r in\n if l == l' && v == v' && r == r' then t\n else try_join l' v' r'\n\n let try_concat t1 t2 =\n match (t1, t2) with\n (Empty, t) -> t\n | (t, Empty) -> t\n | (_, _) -> try_join t1 (min_elt t2) (remove_min_elt t2)\n\n let rec filter_map f = function\n | Empty -> Empty\n | Node{l; v; r} as t ->\n (* enforce left-to-right evaluation order *)\n let l' = filter_map f l in\n let v' = f v in\n let r' = filter_map f r in\n begin match v' with\n | Some v' ->\n if l == l' && v == v' && r == r' then t\n else try_join l' v' r'\n | None ->\n try_concat l' r'\n end\n\n let of_sorted_list l =\n let rec sub n l =\n match n, l with\n | 0, l -> Empty, l\n | 1, x0 :: l -> Node {l=Empty; v=x0; r=Empty; h=1}, l\n | 2, x0 :: x1 :: l ->\n Node{l=Node{l=Empty; v=x0; r=Empty; h=1}; v=x1; r=Empty; h=2}, l\n | 3, x0 :: x1 :: x2 :: l ->\n Node{l=Node{l=Empty; v=x0; r=Empty; h=1}; v=x1;\n r=Node{l=Empty; v=x2; r=Empty; h=1}; h=2}, l\n | n, l ->\n let nl = n / 2 in\n let left, l = sub nl l in\n match l with\n | [] -> assert false\n | mid :: l ->\n let right, l = sub (n - nl - 1) l in\n create left mid right, l\n in\n fst (sub (List.length l) l)\n\n let of_list l =\n match l with\n | [] -> empty\n | [x0] -> singleton x0\n | [x0; x1] -> add x1 (singleton x0)\n | [x0; x1; x2] -> add x2 (add x1 (singleton x0))\n | [x0; x1; x2; x3] -> add x3 (add x2 (add x1 (singleton x0)))\n | [x0; x1; x2; x3; x4] -> add x4 (add x3 (add x2 (add x1 (singleton x0))))\n | _ -> of_sorted_list (List.sort_uniq Ord.compare l)\n\n let add_seq i m =\n Seq.fold_left (fun s x -> add x s) m i\n\n let of_seq i = add_seq i empty\n\n let rec seq_of_enum_ c () = match c with\n | End -> Seq.Nil\n | More (x, t, rest) -> Seq.Cons (x, seq_of_enum_ (cons_enum t rest))\n\n let to_seq c = seq_of_enum_ (cons_enum c End)\n\n let rec snoc_enum s e =\n match s with\n Empty -> e\n | Node{l; v; r} -> snoc_enum r (More(v, l, e))\n\n let rec rev_seq_of_enum_ c () = match c with\n | End -> Seq.Nil\n | More (x, t, rest) -> Seq.Cons (x, rev_seq_of_enum_ (snoc_enum t rest))\n\n let to_rev_seq c = rev_seq_of_enum_ (snoc_enum c End)\n\n let to_seq_from low s =\n let rec aux low s c = match s with\n | Empty -> c\n | Node {l; r; v; _} ->\n begin match Ord.compare v low with\n | 0 -> More (v, r, c)\n | n when n<0 -> aux low r c\n | _ -> aux low l (More (v, r, c))\n end\n in\n seq_of_enum_ (aux low s End)\n end\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nmodule type OrderedType =\n sig\n type t\n val compare: t -> t -> int\n end\n\nmodule type S =\n sig\n type key\n type !+'a t\n val empty: 'a t\n val is_empty: 'a t -> bool\n val mem: key -> 'a t -> bool\n val add: key -> 'a -> 'a t -> 'a t\n val update: key -> ('a option -> 'a option) -> 'a t -> 'a t\n val singleton: key -> 'a -> 'a t\n val remove: key -> 'a t -> 'a t\n val merge:\n (key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t\n val union: (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t\n val compare: ('a -> 'a -> int) -> 'a t -> 'a t -> int\n val equal: ('a -> 'a -> bool) -> 'a t -> 'a t -> bool\n val iter: (key -> 'a -> unit) -> 'a t -> unit\n val fold: (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b\n val for_all: (key -> 'a -> bool) -> 'a t -> bool\n val exists: (key -> 'a -> bool) -> 'a t -> bool\n val filter: (key -> 'a -> bool) -> 'a t -> 'a t\n val filter_map: (key -> 'a -> 'b option) -> 'a t -> 'b t\n val partition: (key -> 'a -> bool) -> 'a t -> 'a t * 'a t\n val cardinal: 'a t -> int\n val bindings: 'a t -> (key * 'a) list\n val min_binding: 'a t -> (key * 'a)\n val min_binding_opt: 'a t -> (key * 'a) option\n val max_binding: 'a t -> (key * 'a)\n val max_binding_opt: 'a t -> (key * 'a) option\n val choose: 'a t -> (key * 'a)\n val choose_opt: 'a t -> (key * 'a) option\n val split: key -> 'a t -> 'a t * 'a option * 'a t\n val find: key -> 'a t -> 'a\n val find_opt: key -> 'a t -> 'a option\n val find_first: (key -> bool) -> 'a t -> key * 'a\n val find_first_opt: (key -> bool) -> 'a t -> (key * 'a) option\n val find_last: (key -> bool) -> 'a t -> key * 'a\n val find_last_opt: (key -> bool) -> 'a t -> (key * 'a) option\n val map: ('a -> 'b) -> 'a t -> 'b t\n val mapi: (key -> 'a -> 'b) -> 'a t -> 'b t\n val to_seq : 'a t -> (key * 'a) Seq.t\n val to_rev_seq : 'a t -> (key * 'a) Seq.t\n val to_seq_from : key -> 'a t -> (key * 'a) Seq.t\n val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t\n val of_seq : (key * 'a) Seq.t -> 'a t\n end\n\nmodule Make(Ord: OrderedType) = struct\n\n type key = Ord.t\n\n type 'a t =\n Empty\n | Node of {l:'a t; v:key; d:'a; r:'a t; h:int}\n\n let height = function\n Empty -> 0\n | Node {h} -> h\n\n let create l x d r =\n let hl = height l and hr = height r in\n Node{l; v=x; d; r; h=(if hl >= hr then hl + 1 else hr + 1)}\n\n let singleton x d = Node{l=Empty; v=x; d; r=Empty; h=1}\n\n let bal l x d r =\n let hl = match l with Empty -> 0 | Node {h} -> h in\n let hr = match r with Empty -> 0 | Node {h} -> h in\n if hl > hr + 2 then begin\n match l with\n Empty -> invalid_arg \"Map.bal\"\n | Node{l=ll; v=lv; d=ld; r=lr} ->\n if height ll >= height lr then\n create ll lv ld (create lr x d r)\n else begin\n match lr with\n Empty -> invalid_arg \"Map.bal\"\n | Node{l=lrl; v=lrv; d=lrd; r=lrr}->\n create (create ll lv ld lrl) lrv lrd (create lrr x d r)\n end\n end else if hr > hl + 2 then begin\n match r with\n Empty -> invalid_arg \"Map.bal\"\n | Node{l=rl; v=rv; d=rd; r=rr} ->\n if height rr >= height rl then\n create (create l x d rl) rv rd rr\n else begin\n match rl with\n Empty -> invalid_arg \"Map.bal\"\n | Node{l=rll; v=rlv; d=rld; r=rlr} ->\n create (create l x d rll) rlv rld (create rlr rv rd rr)\n end\n end else\n Node{l; v=x; d; r; h=(if hl >= hr then hl + 1 else hr + 1)}\n\n let empty = Empty\n\n let is_empty = function Empty -> true | _ -> false\n\n let rec add x data = function\n Empty ->\n Node{l=Empty; v=x; d=data; r=Empty; h=1}\n | Node {l; v; d; r; h} as m ->\n let c = Ord.compare x v in\n if c = 0 then\n if d == data then m else Node{l; v=x; d=data; r; h}\n else if c < 0 then\n let ll = add x data l in\n if l == ll then m else bal ll v d r\n else\n let rr = add x data r in\n if r == rr then m else bal l v d rr\n\n let rec find x = function\n Empty ->\n raise Not_found\n | Node {l; v; d; r} ->\n let c = Ord.compare x v in\n if c = 0 then d\n else find x (if c < 0 then l else r)\n\n let rec find_first_aux v0 d0 f = function\n Empty ->\n (v0, d0)\n | Node {l; v; d; r} ->\n if f v then\n find_first_aux v d f l\n else\n find_first_aux v0 d0 f r\n\n let rec find_first f = function\n Empty ->\n raise Not_found\n | Node {l; v; d; r} ->\n if f v then\n find_first_aux v d f l\n else\n find_first f r\n\n let rec find_first_opt_aux v0 d0 f = function\n Empty ->\n Some (v0, d0)\n | Node {l; v; d; r} ->\n if f v then\n find_first_opt_aux v d f l\n else\n find_first_opt_aux v0 d0 f r\n\n let rec find_first_opt f = function\n Empty ->\n None\n | Node {l; v; d; r} ->\n if f v then\n find_first_opt_aux v d f l\n else\n find_first_opt f r\n\n let rec find_last_aux v0 d0 f = function\n Empty ->\n (v0, d0)\n | Node {l; v; d; r} ->\n if f v then\n find_last_aux v d f r\n else\n find_last_aux v0 d0 f l\n\n let rec find_last f = function\n Empty ->\n raise Not_found\n | Node {l; v; d; r} ->\n if f v then\n find_last_aux v d f r\n else\n find_last f l\n\n let rec find_last_opt_aux v0 d0 f = function\n Empty ->\n Some (v0, d0)\n | Node {l; v; d; r} ->\n if f v then\n find_last_opt_aux v d f r\n else\n find_last_opt_aux v0 d0 f l\n\n let rec find_last_opt f = function\n Empty ->\n None\n | Node {l; v; d; r} ->\n if f v then\n find_last_opt_aux v d f r\n else\n find_last_opt f l\n\n let rec find_opt x = function\n Empty ->\n None\n | Node {l; v; d; r} ->\n let c = Ord.compare x v in\n if c = 0 then Some d\n else find_opt x (if c < 0 then l else r)\n\n let rec mem x = function\n Empty ->\n false\n | Node {l; v; r} ->\n let c = Ord.compare x v in\n c = 0 || mem x (if c < 0 then l else r)\n\n let rec min_binding = function\n Empty -> raise Not_found\n | Node {l=Empty; v; d} -> (v, d)\n | Node {l} -> min_binding l\n\n let rec min_binding_opt = function\n Empty -> None\n | Node {l=Empty; v; d} -> Some (v, d)\n | Node {l}-> min_binding_opt l\n\n let rec max_binding = function\n Empty -> raise Not_found\n | Node {v; d; r=Empty} -> (v, d)\n | Node {r} -> max_binding r\n\n let rec max_binding_opt = function\n Empty -> None\n | Node {v; d; r=Empty} -> Some (v, d)\n | Node {r} -> max_binding_opt r\n\n let rec remove_min_binding = function\n Empty -> invalid_arg \"Map.remove_min_elt\"\n | Node {l=Empty; r} -> r\n | Node {l; v; d; r} -> bal (remove_min_binding l) v d r\n\n let merge t1 t2 =\n match (t1, t2) with\n (Empty, t) -> t\n | (t, Empty) -> t\n | (_, _) ->\n let (x, d) = min_binding t2 in\n bal t1 x d (remove_min_binding t2)\n\n let rec remove x = function\n Empty ->\n Empty\n | (Node {l; v; d; r} as m) ->\n let c = Ord.compare x v in\n if c = 0 then merge l r\n else if c < 0 then\n let ll = remove x l in if l == ll then m else bal ll v d r\n else\n let rr = remove x r in if r == rr then m else bal l v d rr\n\n let rec update x f = function\n Empty ->\n begin match f None with\n | None -> Empty\n | Some data -> Node{l=Empty; v=x; d=data; r=Empty; h=1}\n end\n | Node {l; v; d; r; h} as m ->\n let c = Ord.compare x v in\n if c = 0 then begin\n match f (Some d) with\n | None -> merge l r\n | Some data ->\n if d == data then m else Node{l; v=x; d=data; r; h}\n end else if c < 0 then\n let ll = update x f l in\n if l == ll then m else bal ll v d r\n else\n let rr = update x f r in\n if r == rr then m else bal l v d rr\n\n let rec iter f = function\n Empty -> ()\n | Node {l; v; d; r} ->\n iter f l; f v d; iter f r\n\n let rec map f = function\n Empty ->\n Empty\n | Node {l; v; d; r; h} ->\n let l' = map f l in\n let d' = f d in\n let r' = map f r in\n Node{l=l'; v; d=d'; r=r'; h}\n\n let rec mapi f = function\n Empty ->\n Empty\n | Node {l; v; d; r; h} ->\n let l' = mapi f l in\n let d' = f v d in\n let r' = mapi f r in\n Node{l=l'; v; d=d'; r=r'; h}\n\n let rec fold f m accu =\n match m with\n Empty -> accu\n | Node {l; v; d; r} ->\n fold f r (f v d (fold f l accu))\n\n let rec for_all p = function\n Empty -> true\n | Node {l; v; d; r} -> p v d && for_all p l && for_all p r\n\n let rec exists p = function\n Empty -> false\n | Node {l; v; d; r} -> p v d || exists p l || exists p r\n\n (* Beware: those two functions assume that the added k is *strictly*\n smaller (or bigger) than all the present keys in the tree; it\n does not test for equality with the current min (or max) key.\n\n Indeed, they are only used during the \"join\" operation which\n respects this precondition.\n *)\n\n let rec add_min_binding k x = function\n | Empty -> singleton k x\n | Node {l; v; d; r} ->\n bal (add_min_binding k x l) v d r\n\n let rec add_max_binding k x = function\n | Empty -> singleton k x\n | Node {l; v; d; r} ->\n bal l v d (add_max_binding k x r)\n\n (* Same as create and bal, but no assumptions are made on the\n relative heights of l and r. *)\n\n let rec join l v d r =\n match (l, r) with\n (Empty, _) -> add_min_binding v d r\n | (_, Empty) -> add_max_binding v d l\n | (Node{l=ll; v=lv; d=ld; r=lr; h=lh},\n Node{l=rl; v=rv; d=rd; r=rr; h=rh}) ->\n if lh > rh + 2 then bal ll lv ld (join lr v d r) else\n if rh > lh + 2 then bal (join l v d rl) rv rd rr else\n create l v d r\n\n (* Merge two trees l and r into one.\n All elements of l must precede the elements of r.\n No assumption on the heights of l and r. *)\n\n let concat t1 t2 =\n match (t1, t2) with\n (Empty, t) -> t\n | (t, Empty) -> t\n | (_, _) ->\n let (x, d) = min_binding t2 in\n join t1 x d (remove_min_binding t2)\n\n let concat_or_join t1 v d t2 =\n match d with\n | Some d -> join t1 v d t2\n | None -> concat t1 t2\n\n let rec split x = function\n Empty ->\n (Empty, None, Empty)\n | Node {l; v; d; r} ->\n let c = Ord.compare x v in\n if c = 0 then (l, Some d, r)\n else if c < 0 then\n let (ll, pres, rl) = split x l in (ll, pres, join rl v d r)\n else\n let (lr, pres, rr) = split x r in (join l v d lr, pres, rr)\n\n let rec merge f s1 s2 =\n match (s1, s2) with\n (Empty, Empty) -> Empty\n | (Node {l=l1; v=v1; d=d1; r=r1; h=h1}, _) when h1 >= height s2 ->\n let (l2, d2, r2) = split v1 s2 in\n concat_or_join (merge f l1 l2) v1 (f v1 (Some d1) d2) (merge f r1 r2)\n | (_, Node {l=l2; v=v2; d=d2; r=r2}) ->\n let (l1, d1, r1) = split v2 s1 in\n concat_or_join (merge f l1 l2) v2 (f v2 d1 (Some d2)) (merge f r1 r2)\n | _ ->\n assert false\n\n let rec union f s1 s2 =\n match (s1, s2) with\n | (Empty, s) | (s, Empty) -> s\n | (Node {l=l1; v=v1; d=d1; r=r1; h=h1},\n Node {l=l2; v=v2; d=d2; r=r2; h=h2}) ->\n if h1 >= h2 then\n let (l2, d2, r2) = split v1 s2 in\n let l = union f l1 l2 and r = union f r1 r2 in\n match d2 with\n | None -> join l v1 d1 r\n | Some d2 -> concat_or_join l v1 (f v1 d1 d2) r\n else\n let (l1, d1, r1) = split v2 s1 in\n let l = union f l1 l2 and r = union f r1 r2 in\n match d1 with\n | None -> join l v2 d2 r\n | Some d1 -> concat_or_join l v2 (f v2 d1 d2) r\n\n let rec filter p = function\n Empty -> Empty\n | Node {l; v; d; r} as m ->\n (* call [p] in the expected left-to-right order *)\n let l' = filter p l in\n let pvd = p v d in\n let r' = filter p r in\n if pvd then if l==l' && r==r' then m else join l' v d r'\n else concat l' r'\n\n let rec filter_map f = function\n Empty -> Empty\n | Node {l; v; d; r} ->\n (* call [f] in the expected left-to-right order *)\n let l' = filter_map f l in\n let fvd = f v d in\n let r' = filter_map f r in\n begin match fvd with\n | Some d' -> join l' v d' r'\n | None -> concat l' r'\n end\n\n let rec partition p = function\n Empty -> (Empty, Empty)\n | Node {l; v; d; r} ->\n (* call [p] in the expected left-to-right order *)\n let (lt, lf) = partition p l in\n let pvd = p v d in\n let (rt, rf) = partition p r in\n if pvd\n then (join lt v d rt, concat lf rf)\n else (concat lt rt, join lf v d rf)\n\n type 'a enumeration = End | More of key * 'a * 'a t * 'a enumeration\n\n let rec cons_enum m e =\n match m with\n Empty -> e\n | Node {l; v; d; r} -> cons_enum l (More(v, d, r, e))\n\n let compare cmp m1 m2 =\n let rec compare_aux e1 e2 =\n match (e1, e2) with\n (End, End) -> 0\n | (End, _) -> -1\n | (_, End) -> 1\n | (More(v1, d1, r1, e1), More(v2, d2, r2, e2)) ->\n let c = Ord.compare v1 v2 in\n if c <> 0 then c else\n let c = cmp d1 d2 in\n if c <> 0 then c else\n compare_aux (cons_enum r1 e1) (cons_enum r2 e2)\n in compare_aux (cons_enum m1 End) (cons_enum m2 End)\n\n let equal cmp m1 m2 =\n let rec equal_aux e1 e2 =\n match (e1, e2) with\n (End, End) -> true\n | (End, _) -> false\n | (_, End) -> false\n | (More(v1, d1, r1, e1), More(v2, d2, r2, e2)) ->\n Ord.compare v1 v2 = 0 && cmp d1 d2 &&\n equal_aux (cons_enum r1 e1) (cons_enum r2 e2)\n in equal_aux (cons_enum m1 End) (cons_enum m2 End)\n\n let rec cardinal = function\n Empty -> 0\n | Node {l; r} -> cardinal l + 1 + cardinal r\n\n let rec bindings_aux accu = function\n Empty -> accu\n | Node {l; v; d; r} -> bindings_aux ((v, d) :: bindings_aux accu r) l\n\n let bindings s =\n bindings_aux [] s\n\n let choose = min_binding\n\n let choose_opt = min_binding_opt\n\n let add_seq i m =\n Seq.fold_left (fun m (k,v) -> add k v m) m i\n\n let of_seq i = add_seq i empty\n\n let rec seq_of_enum_ c () = match c with\n | End -> Seq.Nil\n | More (k,v,t,rest) -> Seq.Cons ((k,v), seq_of_enum_ (cons_enum t rest))\n\n let to_seq m =\n seq_of_enum_ (cons_enum m End)\n\n let rec snoc_enum s e =\n match s with\n Empty -> e\n | Node{l; v; d; r} -> snoc_enum r (More(v, d, l, e))\n\n let rec rev_seq_of_enum_ c () = match c with\n | End -> Seq.Nil\n | More (k,v,t,rest) ->\n Seq.Cons ((k,v), rev_seq_of_enum_ (snoc_enum t rest))\n\n let to_rev_seq c =\n rev_seq_of_enum_ (snoc_enum c End)\n\n let to_seq_from low m =\n let rec aux low m c = match m with\n | Empty -> c\n | Node {l; v; d; r; _} ->\n begin match Ord.compare v low with\n | 0 -> More (v, d, r, c)\n | n when n<0 -> aux low r c\n | _ -> aux low l (More (v, d, r, c))\n end\n in\n seq_of_enum_ (aux low m End)\nend\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\ntype 'a t = { mutable c : 'a list; mutable len : int; }\n\nexception Empty\n\nlet create () = { c = []; len = 0; }\n\nlet clear s = s.c <- []; s.len <- 0\n\nlet copy s = { c = s.c; len = s.len; }\n\nlet push x s = s.c <- x :: s.c; s.len <- s.len + 1\n\nlet pop s =\n match s.c with\n | hd::tl -> s.c <- tl; s.len <- s.len - 1; hd\n | [] -> raise Empty\n\nlet pop_opt s =\n match s.c with\n | hd::tl -> s.c <- tl; s.len <- s.len - 1; Some hd\n | [] -> None\n\nlet top s =\n match s.c with\n | hd::_ -> hd\n | [] -> raise Empty\n\nlet top_opt s =\n match s.c with\n | hd::_ -> Some hd\n | [] -> None\n\nlet is_empty s = (s.c = [])\n\nlet length s = s.len\n\nlet iter f s = List.iter f s.c\n\nlet fold f acc s = List.fold_left f acc s.c\n\n(** {1 Iterators} *)\n\nlet to_seq s = List.to_seq s.c\n\nlet add_seq q i = Seq.iter (fun x -> push x q) i\n\nlet of_seq g =\n let s = create() in\n add_seq s g;\n s\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Francois Pottier, projet Cristal, INRIA Rocquencourt *)\n(* Jeremie Dimino, Jane Street Europe *)\n(* *)\n(* Copyright 2002 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nexception Empty\n\ntype 'a cell =\n | Nil\n | Cons of { content: 'a; mutable next: 'a cell }\n\ntype 'a t = {\n mutable length: int;\n mutable first: 'a cell;\n mutable last: 'a cell\n}\n\nlet create () = {\n length = 0;\n first = Nil;\n last = Nil\n}\n\nlet clear q =\n q.length <- 0;\n q.first <- Nil;\n q.last <- Nil\n\nlet add x q =\n let cell = Cons {\n content = x;\n next = Nil\n } in\n match q.last with\n | Nil ->\n q.length <- 1;\n q.first <- cell;\n q.last <- cell\n | Cons last ->\n q.length <- q.length + 1;\n last.next <- cell;\n q.last <- cell\n\nlet push =\n add\n\nlet peek q =\n match q.first with\n | Nil -> raise Empty\n | Cons { content } -> content\n\nlet peek_opt q =\n match q.first with\n | Nil -> None\n | Cons { content } -> Some content\n\nlet top =\n peek\n\nlet take q =\n match q.first with\n | Nil -> raise Empty\n | Cons { content; next = Nil } ->\n clear q;\n content\n | Cons { content; next } ->\n q.length <- q.length - 1;\n q.first <- next;\n content\n\nlet take_opt q =\n match q.first with\n | Nil -> None\n | Cons { content; next = Nil } ->\n clear q;\n Some content\n | Cons { content; next } ->\n q.length <- q.length - 1;\n q.first <- next;\n Some content\n\nlet pop =\n take\n\nlet copy =\n let rec copy q_res prev cell =\n match cell with\n | Nil -> q_res.last <- prev; q_res\n | Cons { content; next } ->\n let res = Cons { content; next = Nil } in\n begin match prev with\n | Nil -> q_res.first <- res\n | Cons p -> p.next <- res\n end;\n copy q_res res next\n in\n fun q -> copy { length = q.length; first = Nil; last = Nil } Nil q.first\n\nlet is_empty q =\n q.length = 0\n\nlet length q =\n q.length\n\nlet iter =\n let rec iter f cell =\n match cell with\n | Nil -> ()\n | Cons { content; next } ->\n f content;\n iter f next\n in\n fun f q -> iter f q.first\n\nlet fold =\n let rec fold f accu cell =\n match cell with\n | Nil -> accu\n | Cons { content; next } ->\n let accu = f accu content in\n fold f accu next\n in\n fun f accu q -> fold f accu q.first\n\nlet transfer q1 q2 =\n if q1.length > 0 then\n match q2.last with\n | Nil ->\n q2.length <- q1.length;\n q2.first <- q1.first;\n q2.last <- q1.last;\n clear q1\n | Cons last ->\n q2.length <- q2.length + q1.length;\n last.next <- q1.first;\n q2.last <- q1.last;\n clear q1\n\n(** {1 Iterators} *)\n\nlet to_seq q =\n let rec aux c () = match c with\n | Nil -> Seq.Nil\n | Cons { content=x; next; } -> Seq.Cons (x, aux next)\n in\n aux q.first\n\nlet add_seq q i = Seq.iter (fun x -> push x q) i\n\nlet of_seq g =\n let q = create() in\n add_seq q g;\n q\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Pierre Weis and Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1999 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* Extensible buffers *)\n\ntype t =\n {mutable buffer : bytes;\n mutable position : int;\n mutable length : int;\n initial_buffer : bytes}\n(* Invariants: all parts of the code preserve the invariants that:\n - [0 <= b.position <= b.length]\n - [b.length = Bytes.length b.buffer]\n\n Note in particular that [b.position = b.length] is legal,\n it means that the buffer is full and will have to be extended\n before any further addition. *)\n\nlet create n =\n let n = if n < 1 then 1 else n in\n let n = if n > Sys.max_string_length then Sys.max_string_length else n in\n let s = Bytes.create n in\n {buffer = s; position = 0; length = n; initial_buffer = s}\n\nlet contents b = Bytes.sub_string b.buffer 0 b.position\nlet to_bytes b = Bytes.sub b.buffer 0 b.position\n\nlet sub b ofs len =\n if ofs < 0 || len < 0 || ofs > b.position - len\n then invalid_arg \"Buffer.sub\"\n else Bytes.sub_string b.buffer ofs len\n\n\nlet blit src srcoff dst dstoff len =\n if len < 0 || srcoff < 0 || srcoff > src.position - len\n || dstoff < 0 || dstoff > (Bytes.length dst) - len\n then invalid_arg \"Buffer.blit\"\n else\n Bytes.unsafe_blit src.buffer srcoff dst dstoff len\n\n\nlet nth b ofs =\n if ofs < 0 || ofs >= b.position then\n invalid_arg \"Buffer.nth\"\n else Bytes.unsafe_get b.buffer ofs\n\n\nlet length b = b.position\n\nlet clear b = b.position <- 0\n\nlet reset b =\n b.position <- 0;\n b.buffer <- b.initial_buffer;\n b.length <- Bytes.length b.buffer\n\n(* [resize b more] ensures that [b.position + more <= b.length] holds\n by dynamically extending [b.buffer] if necessary -- and thus\n increasing [b.length].\n\n In particular, after [resize b more] is called, a direct access of\n size [more] at [b.position] will always be in-bounds, so that\n (unsafe_{get,set}) may be used for performance.\n*)\nlet resize b more =\n let old_pos = b.position in\n let old_len = b.length in\n let new_len = ref old_len in\n while old_pos + more > !new_len do new_len := 2 * !new_len done;\n if !new_len > Sys.max_string_length then begin\n if old_pos + more <= Sys.max_string_length\n then new_len := Sys.max_string_length\n else failwith \"Buffer.add: cannot grow buffer\"\n end;\n let new_buffer = Bytes.create !new_len in\n (* PR#6148: let's keep using [blit] rather than [unsafe_blit] in\n this tricky function that is slow anyway. *)\n Bytes.blit b.buffer 0 new_buffer 0 b.position;\n b.buffer <- new_buffer;\n b.length <- !new_len;\n assert (b.position + more <= b.length);\n assert (old_pos + more <= b.length);\n ()\n (* Note: there are various situations (preemptive threads, signals and\n gc finalizers) where OCaml code may be run asynchronously; in\n particular, there may be a race with another user of [b], changing\n its mutable fields in the middle of the [resize] call. The Buffer\n module does not provide any correctness guarantee if that happens,\n but we must still ensure that the datastructure invariants hold for\n memory-safety -- as we plan to use [unsafe_{get,set}].\n\n There are two potential allocation points in this function,\n [ref] and [Bytes.create], but all reads and writes to the fields\n of [b] happen before both of them or after both of them.\n\n We therefore assume that [b.position] may change at these allocations,\n and check that the [b.position + more <= b.length] postcondition\n holds for both values of [b.position], before or after the function\n is called. More precisely, the following invariants must hold if the\n function returns correctly, in addition to the usual buffer invariants:\n - [old(b.position) + more <= new(b.length)]\n - [new(b.position) + more <= new(b.length)]\n - [old(b.length) <= new(b.length)]\n\n Note: [b.position + more <= old(b.length)] does *not*\n hold in general, as it is precisely the case where you need\n to call [resize] to increase [b.length].\n\n Note: [assert] above does not mean that we know the conditions\n always hold, but that the function may return correctly\n only if they hold.\n\n Note: the other functions in this module does not need\n to be checked with this level of scrutiny, given that they\n read/write the buffer immediately after checking that\n [b.position + more <= b.length] hold or calling [resize].\n *)\n\nlet add_char b c =\n let pos = b.position in\n if pos >= b.length then resize b 1;\n Bytes.unsafe_set b.buffer pos c;\n b.position <- pos + 1\n\nlet uchar_utf_8_byte_length_max = 4\nlet uchar_utf_16_byte_length_max = 4\n\nlet rec add_utf_8_uchar b u =\n let pos = b.position in\n if pos >= b.length then resize b uchar_utf_8_byte_length_max;\n let n = Bytes.set_utf_8_uchar b.buffer pos u in\n if n = 0\n then (resize b uchar_utf_8_byte_length_max; add_utf_8_uchar b u)\n else (b.position <- pos + n)\n\nlet rec add_utf_16be_uchar b u =\n let pos = b.position in\n if pos >= b.length then resize b uchar_utf_16_byte_length_max;\n let n = Bytes.set_utf_16be_uchar b.buffer pos u in\n if n = 0\n then (resize b uchar_utf_16_byte_length_max; add_utf_16be_uchar b u)\n else (b.position <- pos + n)\n\nlet rec add_utf_16le_uchar b u =\n let pos = b.position in\n if pos >= b.length then resize b uchar_utf_16_byte_length_max;\n let n = Bytes.set_utf_16le_uchar b.buffer pos u in\n if n = 0\n then (resize b uchar_utf_16_byte_length_max; add_utf_16le_uchar b u)\n else (b.position <- pos + n)\n\nlet add_substring b s offset len =\n if offset < 0 || len < 0 || offset > String.length s - len\n then invalid_arg \"Buffer.add_substring/add_subbytes\";\n let new_position = b.position + len in\n if new_position > b.length then resize b len;\n Bytes.unsafe_blit_string s offset b.buffer b.position len;\n b.position <- new_position\n\nlet add_subbytes b s offset len =\n add_substring b (Bytes.unsafe_to_string s) offset len\n\nlet add_string b s =\n let len = String.length s in\n let new_position = b.position + len in\n if new_position > b.length then resize b len;\n Bytes.unsafe_blit_string s 0 b.buffer b.position len;\n b.position <- new_position\n\nlet add_bytes b s = add_string b (Bytes.unsafe_to_string s)\n\nlet add_buffer b bs =\n add_subbytes b bs.buffer 0 bs.position\n\n(* this (private) function could move into the standard library *)\nlet really_input_up_to ic buf ofs len =\n let rec loop ic buf ~already_read ~ofs ~to_read =\n if to_read = 0 then already_read\n else begin\n let r = input ic buf ofs to_read in\n if r = 0 then already_read\n else begin\n let already_read = already_read + r in\n let ofs = ofs + r in\n let to_read = to_read - r in\n loop ic buf ~already_read ~ofs ~to_read\n end\n end\n in loop ic buf ~already_read:0 ~ofs ~to_read:len\n\n\nlet unsafe_add_channel_up_to b ic len =\n if b.position + len > b.length then resize b len;\n let n = really_input_up_to ic b.buffer b.position len in\n (* The assertion below may fail in weird scenario where\n threaded/finalizer code, run asynchronously during the\n [really_input_up_to] call, races on the buffer; we don't ensure\n correctness in this case, but need to preserve the invariants for\n memory-safety (see discussion of [resize]). *)\n assert (b.position + n <= b.length);\n b.position <- b.position + n;\n n\n\nlet add_channel b ic len =\n if len < 0 || len > Sys.max_string_length then (* PR#5004 *)\n invalid_arg \"Buffer.add_channel\";\n let n = unsafe_add_channel_up_to b ic len in\n (* It is intentional that a consumer catching End_of_file\n will see the data written (see #6719, #7136). *)\n if n < len then raise End_of_file;\n ()\n\nlet output_buffer oc b =\n output oc b.buffer 0 b.position\n\nlet closing = function\n | '(' -> ')'\n | '{' -> '}'\n | _ -> assert false\n\n(* opening and closing: open and close characters, typically ( and )\n k: balance of opening and closing chars\n s: the string where we are searching\n start: the index where we start the search. *)\nlet advance_to_closing opening closing k s start =\n let rec advance k i lim =\n if i >= lim then raise Not_found else\n if s.[i] = opening then advance (k + 1) (i + 1) lim else\n if s.[i] = closing then\n if k = 0 then i else advance (k - 1) (i + 1) lim\n else advance k (i + 1) lim in\n advance k start (String.length s)\n\nlet advance_to_non_alpha s start =\n let rec advance i lim =\n if i >= lim then lim else\n match s.[i] with\n | 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' -> advance (i + 1) lim\n | _ -> i in\n advance start (String.length s)\n\n(* We are just at the beginning of an ident in s, starting at start. *)\nlet find_ident s start lim =\n if start >= lim then raise Not_found else\n match s.[start] with\n (* Parenthesized ident ? *)\n | '(' | '{' as c ->\n let new_start = start + 1 in\n let stop = advance_to_closing c (closing c) 0 s new_start in\n String.sub s new_start (stop - start - 1), stop + 1\n (* Regular ident *)\n | _ ->\n let stop = advance_to_non_alpha s (start + 1) in\n String.sub s start (stop - start), stop\n\n(* Substitute $ident, $(ident), or ${ident} in s,\n according to the function mapping f. *)\nlet add_substitute b f s =\n let lim = String.length s in\n let rec subst previous i =\n if i < lim then begin\n match s.[i] with\n | '$' as current when previous = '\\\\' ->\n add_char b current;\n subst ' ' (i + 1)\n | '$' ->\n let j = i + 1 in\n let ident, next_i = find_ident s j lim in\n add_string b (f ident);\n subst ' ' next_i\n | current when previous == '\\\\' ->\n add_char b '\\\\';\n add_char b current;\n subst ' ' (i + 1)\n | '\\\\' as current ->\n subst current (i + 1)\n | current ->\n add_char b current;\n subst current (i + 1)\n end else\n if previous = '\\\\' then add_char b previous in\n subst ' ' 0\n\nlet truncate b len =\n if len < 0 || len > length b then\n invalid_arg \"Buffer.truncate\"\n else\n b.position <- len\n\n(** {1 Iterators} *)\n\nlet to_seq b =\n let rec aux i () =\n (* Note that b.position is not a constant and cannot be lifted out of aux *)\n if i >= b.position then Seq.Nil\n else\n let x = Bytes.unsafe_get b.buffer i in\n Seq.Cons (x, aux (i+1))\n in\n aux 0\n\nlet to_seqi b =\n let rec aux i () =\n (* Note that b.position is not a constant and cannot be lifted out of aux *)\n if i >= b.position then Seq.Nil\n else\n let x = Bytes.unsafe_get b.buffer i in\n Seq.Cons ((i,x), aux (i+1))\n in\n aux 0\n\nlet add_seq b seq = Seq.iter (add_char b) seq\n\nlet of_seq i =\n let b = create 32 in\n add_seq b i;\n b\n\n(** {6 Binary encoding of integers} *)\n\nexternal unsafe_set_int8 : bytes -> int -> int -> unit = \"%bytes_unsafe_set\"\nexternal unsafe_set_int16 : bytes -> int -> int -> unit = \"%caml_bytes_set16u\"\nexternal unsafe_set_int32 : bytes -> int -> int32 -> unit = \"%caml_bytes_set32u\"\nexternal unsafe_set_int64 : bytes -> int -> int64 -> unit = \"%caml_bytes_set64u\"\nexternal swap16 : int -> int = \"%bswap16\"\nexternal swap32 : int32 -> int32 = \"%bswap_int32\"\nexternal swap64 : int64 -> int64 = \"%bswap_int64\"\n\n\nlet add_int8 b x =\n let new_position = b.position + 1 in\n if new_position > b.length then resize b 1;\n unsafe_set_int8 b.buffer b.position x;\n b.position <- new_position\n\nlet add_int16_ne b x =\n let new_position = b.position + 2 in\n if new_position > b.length then resize b 2;\n unsafe_set_int16 b.buffer b.position x;\n b.position <- new_position\n\nlet add_int32_ne b x =\n let new_position = b.position + 4 in\n if new_position > b.length then resize b 4;\n unsafe_set_int32 b.buffer b.position x;\n b.position <- new_position\n\nlet add_int64_ne b x =\n let new_position = b.position + 8 in\n if new_position > b.length then resize b 8;\n unsafe_set_int64 b.buffer b.position x;\n b.position <- new_position\n\nlet add_int16_le b x =\n add_int16_ne b (if Sys.big_endian then swap16 x else x)\n\nlet add_int16_be b x =\n add_int16_ne b (if Sys.big_endian then x else swap16 x)\n\nlet add_int32_le b x =\n add_int32_ne b (if Sys.big_endian then swap32 x else x)\n\nlet add_int32_be b x =\n add_int32_ne b (if Sys.big_endian then x else swap32 x)\n\nlet add_int64_le b x =\n add_int64_ne b (if Sys.big_endian then swap64 x else x)\n\nlet add_int64_be b x =\n add_int64_ne b (if Sys.big_endian then x else swap64 x)\n\nlet add_uint8 = add_int8\nlet add_uint16_ne = add_int16_ne\nlet add_uint16_le = add_int16_le\nlet add_uint16_be = add_int16_be\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy and Pierre Weis, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nopen CamlinternalFormatBasics\nopen CamlinternalFormat\n\nlet kfprintf k o (Format (fmt, _)) =\n make_printf (fun acc -> output_acc o acc; k o) End_of_acc fmt\nlet kbprintf k b (Format (fmt, _)) =\n make_printf (fun acc -> bufput_acc b acc; k b) End_of_acc fmt\nlet ikfprintf k oc (Format (fmt, _)) =\n make_iprintf k oc fmt\nlet ikbprintf = ikfprintf\n\nlet fprintf oc fmt = kfprintf ignore oc fmt\nlet bprintf b fmt = kbprintf ignore b fmt\nlet ifprintf oc fmt = ikfprintf ignore oc fmt\nlet ibprintf b fmt = ikbprintf ignore b fmt\nlet printf fmt = fprintf stdout fmt\nlet eprintf fmt = fprintf stderr fmt\n\nlet ksprintf k (Format (fmt, _)) =\n let k' acc =\n let buf = Buffer.create 64 in\n strput_acc buf acc;\n k (Buffer.contents buf) in\n make_printf k' End_of_acc fmt\n\nlet sprintf fmt = ksprintf (fun s -> s) fmt\n\nlet kprintf = ksprintf\n","open! Base\n\nmodule Bigstring0 = struct\n type t =\n ( char\n , Stdlib.Bigarray.int8_unsigned_elt\n , Stdlib.Bigarray.c_layout )\n Stdlib.Bigarray.Array1.t\nend\n\nmodule Array1 = struct\n type ('a, 'b, 'c) t = ('a, 'b, 'c) Stdlib.Bigarray.Array1.t\n\n external get : ('a, 'b, 'c) t -> int -> 'a = \"%caml_ba_ref_1\"\n external set : ('a, 'b, 'c) t -> int -> 'a -> unit = \"%caml_ba_set_1\"\n external unsafe_get : ('a, 'b, 'c) t -> int -> 'a = \"%caml_ba_unsafe_ref_1\"\n external unsafe_set : ('a, 'b, 'c) t -> int -> 'a -> unit = \"%caml_ba_unsafe_set_1\"\n external dim : ('a, 'b, 'c) t -> int = \"%caml_ba_dim_1\"\nend\n\ninclude Bigstring0\n\nexternal aux_create\n : max_mem_waiting_gc_in_bytes:int\n -> size:int\n -> t\n = \"bigstring_alloc\"\n\nlet sprintf = Printf.sprintf\n\n(* One needs to use [Caml.Sys.word_size] so that its value is known at compile-time. *)\nlet arch_sixtyfour = Caml.Sys.word_size = 64\nlet arch_big_endian = Caml.Sys.big_endian\nlet not_on_32bit = Caml.Sys.word_size > 32\n\nlet create ?max_mem_waiting_gc_in_bytes size =\n let max_mem_waiting_gc_in_bytes =\n Option.value max_mem_waiting_gc_in_bytes ~default:(-1)\n in\n (* This check is important because [aux_create ~size:(-1)] raises [Out_of_memory], which\n could be confusing during debugging. *)\n if size < 0 then invalid_arg (sprintf \"create: size = %d < 0\" size);\n aux_create ~max_mem_waiting_gc_in_bytes ~size\n;;\n\nlet length = Array1.dim\n\nexternal is_mmapped : t -> bool = \"bigstring_is_mmapped_stub\" [@@noalloc]\n\nlet init n ~f =\n let t = create n in\n for i = 0 to n - 1 do\n t.{i} <- f i\n done;\n t\n;;\n\nlet check_args ~loc ~pos ~len (bstr : t) =\n if pos < 0 then invalid_arg (loc ^ \": pos < 0\");\n if len < 0 then invalid_arg (loc ^ \": len < 0\");\n let bstr_len = length bstr in\n (* Be careful with overflow! We could have bogons like [pos = Int.max_value] or [len =\n Int.max_value] passed by the user. *)\n if bstr_len - pos < len\n then invalid_arg (sprintf \"Bigstring.%s: length(bstr) < pos + len\" loc)\n;;\n\nlet get_opt_len bstr ~pos = function\n | Some len -> len\n | None -> length bstr - pos\n;;\n\n(* Blitting *)\n\nexternal unsafe_blit\n : src:t\n -> src_pos:int\n -> dst:t\n -> dst_pos:int\n -> len:int\n -> unit\n = \"bigstring_blit_stub\"\n[@@noalloc]\n\n(* Exposing the external version of get/set supports better inlining. *)\nexternal get : t -> int -> char = \"%caml_ba_ref_1\"\nexternal set : t -> int -> char -> unit = \"%caml_ba_set_1\"\n\nmodule Bigstring_sequence = struct\n type nonrec t = t\n\n let create ~len = create len\n let length = length\nend\n\nmodule Bytes_sequence = struct\n type t = bytes\n\n let create ~len = Bytes.create len\n let length = Bytes.length\nend\n\ninclude Blit.Make (struct\n include Bigstring_sequence\n\n let unsafe_blit = unsafe_blit\n end)\n\nmodule From_bytes =\n Blit.Make_distinct\n (Bytes_sequence)\n (struct\n external unsafe_blit\n : src:bytes\n -> src_pos:int\n -> dst:t\n -> dst_pos:int\n -> len:int\n -> unit\n = \"bigstring_blit_bytes_bigstring_stub\"\n [@@noalloc]\n\n include Bigstring_sequence\n end)\n\nmodule To_bytes =\n Blit.Make_distinct\n (Bigstring_sequence)\n (struct\n external unsafe_blit\n : src:t\n -> src_pos:int\n -> dst:bytes\n -> dst_pos:int\n -> len:int\n -> unit\n = \"bigstring_blit_bigstring_bytes_stub\"\n [@@noalloc]\n\n include Bytes_sequence\n end)\n\nmodule From_string =\n Blit.Make_distinct\n (struct\n type t = string\n\n let length = String.length\n end)\n (struct\n external unsafe_blit\n : src:string\n -> src_pos:int\n -> dst:t\n -> dst_pos:int\n -> len:int\n -> unit\n = \"bigstring_blit_string_bigstring_stub\"\n [@@noalloc]\n\n include Bigstring_sequence\n end)\n\nmodule To_string = struct\n include To_bytes\n include Blit.Make_to_string (Bigstring0) (To_bytes)\nend\n\nlet of_string = From_string.subo\nlet of_bytes = From_bytes.subo\nlet to_string = To_string.subo\nlet to_bytes = To_bytes.subo\nlet sexp_of_t t = Sexp.Atom (to_string t)\n\nlet t_of_sexp : Sexp.t -> t = function\n | Atom str -> of_string str\n | List _ as sexp ->\n Sexplib0.Sexp_conv.of_sexp_error \"bigstring_of_sexp: atom needed\" sexp\n;;\n\nlet copy t : t = sub t ~pos:0 ~len:(length t)\n\nlet concat =\n let append ~src ~dst ~dst_pos_ref =\n let len = length src in\n let src_pos = 0 in\n let dst_pos = !dst_pos_ref in\n blit ~dst ~dst_pos ~src ~src_pos ~len;\n dst_pos_ref := dst_pos + len\n in\n fun ?sep list ->\n match list with\n | [] -> create 0\n | head :: tail ->\n let head_len = length head in\n let sep_len = Option.value_map sep ~f:length ~default:0 in\n let tail_count = List.length tail in\n let len =\n head_len + (sep_len * tail_count) + List.sum (module Int) tail ~f:length\n in\n let dst = create len in\n let dst_pos_ref = ref 0 in\n append ~src:head ~dst ~dst_pos_ref;\n List.iter tail ~f:(fun src ->\n (match sep with\n | None -> ()\n | Some sep -> append ~src:sep ~dst ~dst_pos_ref);\n append ~src ~dst ~dst_pos_ref);\n assert (!dst_pos_ref = len);\n dst\n;;\n\nexternal unsafe_memset\n : t\n -> pos:int\n -> len:int\n -> char\n -> unit\n = \"bigstring_memset_stub\"\n[@@noalloc]\n\nlet memset t ~pos ~len c =\n Ordered_collection_common.check_pos_len_exn ~pos ~len ~total_length:(length t);\n unsafe_memset t ~pos ~len c\n;;\n\n(* Comparison *)\n\nexternal unsafe_memcmp\n : t\n -> pos1:int\n -> t\n -> pos2:int\n -> len:int\n -> int\n = \"bigstring_memcmp_stub\"\n[@@noalloc]\n\nlet memcmp t1 ~pos1 t2 ~pos2 ~len =\n Ordered_collection_common.check_pos_len_exn ~pos:pos1 ~len ~total_length:(length t1);\n Ordered_collection_common.check_pos_len_exn ~pos:pos2 ~len ~total_length:(length t2);\n unsafe_memcmp t1 ~pos1 t2 ~pos2 ~len\n;;\n\nlet compare t1 t2 =\n if phys_equal t1 t2\n then 0\n else (\n let len1 = length t1 in\n let len2 = length t2 in\n let len = Int.min len1 len2 in\n match unsafe_memcmp t1 ~pos1:0 t2 ~pos2:0 ~len with\n | 0 -> if len1 < len2 then -1 else if len1 > len2 then 1 else 0\n | n -> n)\n;;\n\nexternal internalhash_fold_bigstring\n : Hash.state\n -> t\n -> Hash.state\n = \"internalhash_fold_bigstring\"\n[@@noalloc]\n\nlet _making_sure_the_C_binding_takes_an_int (x : Hash.state) = (x :> int)\nlet hash_fold_t = internalhash_fold_bigstring\nlet hash = Ppx_hash_lib.Std.Hash.of_fold hash_fold_t\n\ntype t_frozen = t [@@deriving compare, hash, sexp]\n\nlet equal t1 t2 =\n if phys_equal t1 t2\n then true\n else (\n let len1 = length t1 in\n let len2 = length t2 in\n Int.equal len1 len2 && Int.equal (unsafe_memcmp t1 ~pos1:0 t2 ~pos2:0 ~len:len1) 0)\n;;\n\n(* Search *)\n\nexternal unsafe_find : t -> char -> pos:int -> len:int -> int = \"bigstring_find\"\n[@@noalloc]\n\nlet find ?(pos = 0) ?len chr bstr =\n let len = get_opt_len bstr ~pos len in\n check_args ~loc:\"find\" ~pos ~len bstr;\n let res = unsafe_find bstr chr ~pos ~len in\n if res < 0 then None else Some res\n;;\n\n(* vim: set filetype=ocaml : *)\n\n(* Binary-packing like accessors *)\n\nexternal int32_of_int : int -> int32 = \"%int32_of_int\"\nexternal int32_to_int : int32 -> int = \"%int32_to_int\"\nexternal int64_of_int : int -> int64 = \"%int64_of_int\"\nexternal int64_to_int : int64 -> int = \"%int64_to_int\"\nexternal swap16 : int -> int = \"%bswap16\"\nexternal swap32 : int32 -> int32 = \"%bswap_int32\"\nexternal swap64 : int64 -> int64 = \"%bswap_int64\"\nexternal unsafe_get_16 : t -> int -> int = \"%caml_bigstring_get16u\"\nexternal unsafe_get_32 : t -> int -> int32 = \"%caml_bigstring_get32u\"\nexternal unsafe_get_64 : t -> int -> int64 = \"%caml_bigstring_get64u\"\nexternal unsafe_set_16 : t -> int -> int -> unit = \"%caml_bigstring_set16u\"\nexternal unsafe_set_32 : t -> int -> int32 -> unit = \"%caml_bigstring_set32u\"\nexternal unsafe_set_64 : t -> int -> int64 -> unit = \"%caml_bigstring_set64u\"\n\nlet get_16 (t : t) (pos : int) : int =\n check_args ~loc:\"get_16\" ~pos ~len:2 t;\n unsafe_get_16 t pos\n;;\n\nlet get_32 (t : t) (pos : int) : int32 =\n check_args ~loc:\"get_32\" ~pos ~len:4 t;\n unsafe_get_32 t pos\n;;\n\nlet get_64 (t : t) (pos : int) : int64 =\n check_args ~loc:\"get_64\" ~pos ~len:8 t;\n unsafe_get_64 t pos\n;;\n\nlet set_16_trunc (t : t) (pos : int) (v : int) : unit =\n check_args ~loc:\"set_16\" ~pos ~len:2 t;\n unsafe_set_16 t pos v\n;;\n\nlet set_32 (t : t) (pos : int) (v : int32) : unit =\n check_args ~loc:\"set_32\" ~pos ~len:4 t;\n unsafe_set_32 t pos v\n;;\n\nlet set_64 (t : t) (pos : int) (v : int64) : unit =\n check_args ~loc:\"set_64\" ~pos ~len:8 t;\n unsafe_set_64 t pos v\n;;\n\nlet sign_extend_16 u = (u lsl (Int.num_bits - 16)) asr (Int.num_bits - 16)\n\nlet check_valid_uint16 x ~loc =\n if x < 0 || x > 0xFFFF\n then invalid_arg (sprintf \"%s: %d is not a valid unsigned 16-bit integer\" loc x)\n;;\n\nlet check_valid_int16 x ~loc =\n if x < -0x8000 || x > 0x7FFF\n then invalid_arg (sprintf \"%s: %d is not a valid (signed) 16-bit integer\" loc x)\n;;\n\nlet check_valid_uint8 x ~loc =\n if x < 0 || x > 0xFF\n then invalid_arg (sprintf \"%s: %d is not a valid unsigned 8-bit integer\" loc x)\n;;\n\nlet check_valid_int8 x ~loc =\n if x < -0x80 || x > 0x7F\n then invalid_arg (sprintf \"%s: %d is not a valid (signed) 8-bit integer\" loc x)\n;;\n\nlet check_valid_int32 =\n if not arch_sixtyfour\n then fun _ ~loc:_ -> ()\n else\n fun x ~loc ->\n if x >= -1 lsl 31 && x < 1 lsl 31\n then ()\n else invalid_arg (sprintf \"%s: %d is not a valid (signed) 32-bit integer\" loc x)\n;;\n\nlet check_valid_uint32 =\n if not arch_sixtyfour\n then\n fun x ~loc ->\n if x >= 0\n then ()\n else invalid_arg (sprintf \"%s: %d is not a valid unsigned 32-bit integer\" loc x)\n else\n fun x ~loc ->\n if x >= 0 && x < 1 lsl 32\n then ()\n else invalid_arg (sprintf \"%s: %d is not a valid unsigned 32-bit integer\" loc x)\n;;\n\nlet check_valid_uint64 x ~loc =\n if x >= 0\n then ()\n else invalid_arg (sprintf \"%s: %d is not a valid unsigned 64-bit integer\" loc x)\n;;\n\nlet unsafe_read_int16 t ~pos = sign_extend_16 (unsafe_get_16 t pos)\nlet unsafe_read_int16_swap t ~pos = sign_extend_16 (swap16 (unsafe_get_16 t pos))\nlet unsafe_write_int16 t ~pos x = unsafe_set_16 t pos x\nlet unsafe_write_int16_swap t ~pos x = unsafe_set_16 t pos (swap16 x)\nlet read_int16 t ~pos = sign_extend_16 (get_16 t pos)\nlet read_int16_swap t ~pos = sign_extend_16 (swap16 (get_16 t pos))\n\nlet write_int16_exn t ~pos x =\n check_valid_int16 x ~loc:\"Bigstring.write_int16\";\n set_16_trunc t pos x\n;;\n\nlet write_int16_swap_exn t ~pos x =\n (* Omit \"_swap\" from the error message it's bi-endian. *)\n check_valid_int16 x ~loc:\"Bigstring.write_int16\";\n set_16_trunc t pos (swap16 x)\n;;\n\nlet unsafe_read_uint16 t ~pos = unsafe_get_16 t pos\nlet unsafe_read_uint16_swap t ~pos = swap16 (unsafe_get_16 t pos)\nlet unsafe_write_uint16 t ~pos x = unsafe_set_16 t pos x\nlet unsafe_write_uint16_swap t ~pos x = unsafe_set_16 t pos (swap16 x)\nlet read_uint16 t ~pos = get_16 t pos\nlet read_uint16_swap t ~pos = swap16 (get_16 t pos)\n\nlet write_uint16_exn t ~pos x =\n check_valid_uint16 x ~loc:\"Bigstring.write_uint16\";\n set_16_trunc t pos x\n;;\n\nlet write_uint16_swap_exn t ~pos x =\n (* Omit \"_swap\" from the error message it's bi-endian. *)\n check_valid_uint16 x ~loc:\"Bigstring.write_uint16\";\n set_16_trunc t pos (swap16 x)\n;;\n\nlet unsafe_read_int32_int t ~pos = int32_to_int (unsafe_get_32 t pos)\nlet unsafe_read_int32_int_swap t ~pos = int32_to_int (swap32 (unsafe_get_32 t pos))\nlet unsafe_read_int32 t ~pos = unsafe_get_32 t pos\nlet unsafe_read_int32_swap t ~pos = swap32 (unsafe_get_32 t pos)\nlet unsafe_write_int32 t ~pos x = unsafe_set_32 t pos x\nlet unsafe_write_int32_swap t ~pos x = unsafe_set_32 t pos (swap32 x)\nlet unsafe_write_int32_int t ~pos x = unsafe_set_32 t pos (int32_of_int x)\nlet unsafe_write_int32_int_swap t ~pos x = unsafe_set_32 t pos (swap32 (int32_of_int x))\nlet read_int32_int t ~pos = int32_to_int (get_32 t pos)\nlet read_int32_int_swap t ~pos = int32_to_int (swap32 (get_32 t pos))\nlet read_int32 t ~pos = get_32 t pos\nlet read_int32_swap t ~pos = swap32 (get_32 t pos)\nlet write_int32 t ~pos x = set_32 t pos x\nlet write_int32_swap t ~pos x = set_32 t pos (swap32 x)\n\nlet write_int32_int_exn t ~pos x =\n check_valid_int32 x ~loc:\"Bigstring.write_int32_int\";\n set_32 t pos (int32_of_int x)\n;;\n\nlet write_int32_int_swap_exn t ~pos x =\n (* Omit \"_swap\" from the error message it's bi-endian. *)\n check_valid_int32 x ~loc:\"Bigstring.write_int32_int\";\n set_32 t pos (swap32 (int32_of_int x))\n;;\n\nlet unsafe_read_int64_int t ~pos = int64_to_int (unsafe_get_64 t pos)\nlet unsafe_read_int64_int_swap t ~pos = int64_to_int (swap64 (unsafe_get_64 t pos))\nlet unsafe_read_int64 t ~pos = unsafe_get_64 t pos\nlet unsafe_read_int64_swap t ~pos = swap64 (unsafe_get_64 t pos)\nlet unsafe_write_int64 t ~pos x = unsafe_set_64 t pos x\nlet unsafe_write_int64_swap t ~pos x = unsafe_set_64 t pos (swap64 x)\nlet unsafe_write_int64_int t ~pos x = unsafe_set_64 t pos (int64_of_int x)\nlet unsafe_write_int64_int_swap t ~pos x = unsafe_set_64 t pos (swap64 (int64_of_int x))\nlet read_int64_int t ~pos = int64_to_int (get_64 t pos)\nlet read_int64_int_swap t ~pos = int64_to_int (swap64 (get_64 t pos))\nlet read_int64 t ~pos = get_64 t pos\nlet read_int64_swap t ~pos = swap64 (get_64 t pos)\nlet write_int64 t ~pos x = set_64 t pos x\nlet write_int64_swap t ~pos x = set_64 t pos (swap64 x)\nlet write_int64_int t ~pos x = set_64 t pos (int64_of_int x)\nlet write_int64_int_swap t ~pos x = set_64 t pos (swap64 (int64_of_int x))\n\nlet unsafe_get_int16_be =\n if arch_big_endian then unsafe_read_int16 else unsafe_read_int16_swap\n;;\n\nlet unsafe_get_int16_le =\n if arch_big_endian then unsafe_read_int16_swap else unsafe_read_int16\n;;\n\nlet unsafe_get_uint16_be =\n if arch_big_endian then unsafe_read_uint16 else unsafe_read_uint16_swap\n;;\n\nlet unsafe_get_uint16_le =\n if arch_big_endian then unsafe_read_uint16_swap else unsafe_read_uint16\n;;\n\nlet get_int16_be = if arch_big_endian then read_int16 else read_int16_swap\nlet get_int16_le = if arch_big_endian then read_int16_swap else read_int16\nlet get_uint16_be = if arch_big_endian then read_uint16 else read_uint16_swap\nlet get_uint16_le = if arch_big_endian then read_uint16_swap else read_uint16\n\nlet unsafe_set_int16_be =\n if arch_big_endian then unsafe_write_int16 else unsafe_write_int16_swap\n;;\n\nlet unsafe_set_int16_le =\n if arch_big_endian then unsafe_write_int16_swap else unsafe_write_int16\n;;\n\nlet unsafe_set_uint16_be =\n if arch_big_endian then unsafe_write_uint16 else unsafe_write_uint16_swap\n;;\n\nlet unsafe_set_uint16_le =\n if arch_big_endian then unsafe_write_uint16_swap else unsafe_write_uint16\n;;\n\nlet set_int16_be_exn = if arch_big_endian then write_int16_exn else write_int16_swap_exn\nlet set_int16_le_exn = if arch_big_endian then write_int16_swap_exn else write_int16_exn\n\nlet set_uint16_be_exn =\n if arch_big_endian then write_uint16_exn else write_uint16_swap_exn\n;;\n\nlet set_uint16_le_exn =\n if arch_big_endian then write_uint16_swap_exn else write_uint16_exn\n;;\n\nlet unsafe_get_int32_t_be =\n if arch_big_endian then unsafe_read_int32 else unsafe_read_int32_swap\n;;\n\nlet unsafe_get_int32_t_le =\n if arch_big_endian then unsafe_read_int32_swap else unsafe_read_int32\n;;\n\nlet unsafe_set_int32_t_be =\n if arch_big_endian then unsafe_write_int32 else unsafe_write_int32_swap\n;;\n\nlet unsafe_set_int32_t_le =\n if arch_big_endian then unsafe_write_int32_swap else unsafe_write_int32\n;;\n\nlet get_int32_t_be = if arch_big_endian then read_int32 else read_int32_swap\nlet get_int32_t_le = if arch_big_endian then read_int32_swap else read_int32\nlet set_int32_t_be = if arch_big_endian then write_int32 else write_int32_swap\nlet set_int32_t_le = if arch_big_endian then write_int32_swap else write_int32\n\nlet unsafe_get_int32_be =\n if arch_big_endian then unsafe_read_int32_int else unsafe_read_int32_int_swap\n;;\n\nlet unsafe_get_int32_le =\n if arch_big_endian then unsafe_read_int32_int_swap else unsafe_read_int32_int\n;;\n\nlet unsafe_set_int32_be =\n if arch_big_endian then unsafe_write_int32_int else unsafe_write_int32_int_swap\n;;\n\nlet unsafe_set_int32_le =\n if arch_big_endian then unsafe_write_int32_int_swap else unsafe_write_int32_int\n;;\n\nlet get_int32_be = if arch_big_endian then read_int32_int else read_int32_int_swap\nlet get_int32_le = if arch_big_endian then read_int32_int_swap else read_int32_int\n\nlet set_int32_be_exn =\n if arch_big_endian then write_int32_int_exn else write_int32_int_swap_exn\n;;\n\nlet set_int32_le_exn =\n if arch_big_endian then write_int32_int_swap_exn else write_int32_int_exn\n;;\n\nlet unsafe_get_int64_be_trunc =\n if arch_big_endian then unsafe_read_int64_int else unsafe_read_int64_int_swap\n;;\n\nlet unsafe_get_int64_le_trunc =\n if arch_big_endian then unsafe_read_int64_int_swap else unsafe_read_int64_int\n;;\n\nlet unsafe_set_int64_be =\n if arch_big_endian then unsafe_write_int64_int else unsafe_write_int64_int_swap\n;;\n\nlet unsafe_set_int64_le =\n if arch_big_endian then unsafe_write_int64_int_swap else unsafe_write_int64_int\n;;\n\nlet get_int64_be_trunc = if arch_big_endian then read_int64_int else read_int64_int_swap\nlet get_int64_le_trunc = if arch_big_endian then read_int64_int_swap else read_int64_int\nlet set_int64_be = if arch_big_endian then write_int64_int else write_int64_int_swap\nlet set_int64_le = if arch_big_endian then write_int64_int_swap else write_int64_int\n\nlet unsafe_get_int64_t_be =\n if arch_big_endian then unsafe_read_int64 else unsafe_read_int64_swap\n;;\n\nlet unsafe_get_int64_t_le =\n if arch_big_endian then unsafe_read_int64_swap else unsafe_read_int64\n;;\n\nlet unsafe_set_int64_t_be =\n if arch_big_endian then unsafe_write_int64 else unsafe_write_int64_swap\n;;\n\nlet unsafe_set_int64_t_le =\n if arch_big_endian then unsafe_write_int64_swap else unsafe_write_int64\n;;\n\nlet get_int64_t_be = if arch_big_endian then read_int64 else read_int64_swap\nlet get_int64_t_le = if arch_big_endian then read_int64_swap else read_int64\nlet set_int64_t_be = if arch_big_endian then write_int64 else write_int64_swap\nlet set_int64_t_le = if arch_big_endian then write_int64_swap else write_int64\n\nlet int64_conv_error () =\n failwith \"unsafe_read_int64: value cannot be represented unboxed!\"\n;;\n\nlet uint64_conv_error () =\n failwith \"unsafe_read_uint64: value cannot be represented unboxed!\"\n;;\n\n(* [Poly] is required so that we can compare unboxed [int64]. *)\nlet int64_to_int_exn n =\n if arch_sixtyfour\n then\n if Poly.(n >= -0x4000_0000_0000_0000L && n < 0x4000_0000_0000_0000L)\n then int64_to_int n\n else int64_conv_error ()\n else if Poly.(n >= -0x0000_0000_4000_0000L && n < 0x0000_0000_4000_0000L)\n then int64_to_int n\n else int64_conv_error ()\n;;\n\nlet uint64_to_int_exn n =\n if arch_sixtyfour\n then\n if Poly.(n >= 0L && n < 0x4000_0000_0000_0000L)\n then int64_to_int n\n else uint64_conv_error ()\n else if Poly.(n >= 0L && n < 0x0000_0000_4000_0000L)\n then int64_to_int n\n else uint64_conv_error ()\n;;\n\nlet unsafe_get_int64_be_exn t ~pos = int64_to_int_exn (unsafe_get_int64_t_be t ~pos)\nlet unsafe_get_int64_le_exn t ~pos = int64_to_int_exn (unsafe_get_int64_t_le t ~pos)\nlet get_int64_be_exn t ~pos = int64_to_int_exn (get_int64_t_be t ~pos)\nlet get_int64_le_exn t ~pos = int64_to_int_exn (get_int64_t_le t ~pos)\nlet unsafe_get_uint64_be_exn t ~pos = uint64_to_int_exn (unsafe_get_int64_t_be t ~pos)\nlet unsafe_get_uint64_le_exn t ~pos = uint64_to_int_exn (unsafe_get_int64_t_le t ~pos)\nlet get_uint64_be_exn t ~pos = uint64_to_int_exn (get_int64_t_be t ~pos)\nlet get_uint64_le_exn t ~pos = uint64_to_int_exn (get_int64_t_le t ~pos)\nlet unsafe_set_uint64_be = unsafe_set_int64_be\nlet unsafe_set_uint64_le = unsafe_set_int64_le\n\nlet set_uint64_be_exn t ~pos n =\n check_valid_uint64 ~loc:\"Bigstring.set_uint64_be_exn\" n;\n set_int64_be t ~pos n\n;;\n\nlet set_uint64_le_exn t ~pos n =\n check_valid_uint64 ~loc:\"Bigstring.set_uint64_le_exn\" n;\n set_int64_le t ~pos n\n;;\n\n(* Type annotations on the [t]s are important here: in order for the compiler to generate\n optimized code, it needs to know the fully instantiated type of the bigarray. This is\n because the type of the bigarray encodes the element kind and the layout of the\n bigarray. Without the annotation the compiler generates a C call to the generic access\n functions. *)\nlet unsafe_set_uint8 (t : t) ~pos n = Array1.unsafe_set t pos (Char.unsafe_of_int n)\n\nlet unsafe_set_int8 (t : t) ~pos n =\n (* In all the set functions where there are these tests, it looks like the test could be\n removed, since they are only changing the values of the bytes that are not\n written. *)\n let n = if n < 0 then n + 256 else n in\n Array1.unsafe_set t pos (Char.unsafe_of_int n)\n;;\n\nlet unsafe_get_uint8 (t : t) ~pos = Char.to_int (Array1.unsafe_get t pos)\n\nlet unsafe_get_int8 (t : t) ~pos =\n let n = Char.to_int (Array1.unsafe_get t pos) in\n if n >= 128 then n - 256 else n\n;;\n\nlet set_uint8_exn (t : t) ~pos n =\n check_valid_uint8 ~loc:\"Bigstring.set_uint8_exn\" n;\n Array1.set t pos (Char.unsafe_of_int n)\n;;\n\nlet set_int8_exn (t : t) ~pos n =\n check_valid_int8 ~loc:\"Bigstring.set_int8_exn\" n;\n let n = if n < 0 then n + 256 else n in\n Array1.set t pos (Char.unsafe_of_int n)\n;;\n\nlet get_uint8 (t : t) ~pos = Char.to_int (Array1.get t pos)\n\nlet get_int8 (t : t) ~pos =\n let n = Char.to_int (Array1.get t pos) in\n if n >= 128 then n - 256 else n\n;;\n\nlet unsafe_set_uint32_le t ~pos n =\n let n = if not_on_32bit && n >= 1 lsl 31 then n - (1 lsl 32) else n in\n unsafe_set_int32_le t ~pos n\n;;\n\nlet unsafe_set_uint32_be t ~pos n =\n let n = if not_on_32bit && n >= 1 lsl 31 then n - (1 lsl 32) else n in\n unsafe_set_int32_be t ~pos n\n;;\n\nlet unsafe_get_uint32_le t ~pos =\n let n = unsafe_get_int32_le t ~pos in\n if not_on_32bit && n < 0 then n + (1 lsl 32) else n\n;;\n\nlet unsafe_get_uint32_be t ~pos =\n let n = unsafe_get_int32_be t ~pos in\n if not_on_32bit && n < 0 then n + (1 lsl 32) else n\n;;\n\nlet set_uint32_le_exn t ~pos n =\n check_valid_uint32 ~loc:\"Bigstring.set_uint32_le_exn\" n;\n let n = if not_on_32bit && n >= 1 lsl 31 then n - (1 lsl 32) else n in\n set_int32_le_exn t ~pos n\n;;\n\nlet set_uint32_be_exn t ~pos n =\n check_valid_uint32 ~loc:\"Bigstring.set_uint32_be_exn\" n;\n let n = if not_on_32bit && n >= 1 lsl 31 then n - (1 lsl 32) else n in\n set_int32_be_exn t ~pos n\n;;\n\nlet get_uint32_le t ~pos =\n let n = get_int32_le t ~pos in\n if not_on_32bit && n < 0 then n + (1 lsl 32) else n\n;;\n\nlet get_uint32_be t ~pos =\n let n = get_int32_be t ~pos in\n if not_on_32bit && n < 0 then n + (1 lsl 32) else n\n;;\n\nmodule Private = struct\n let sign_extend_16 = sign_extend_16\nend\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Damien Doligez, projet Para, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\ntype key = string\ntype doc = string\ntype usage_msg = string\ntype anon_fun = (string -> unit)\n\ntype spec =\n | Unit of (unit -> unit) (* Call the function with unit argument *)\n | Bool of (bool -> unit) (* Call the function with a bool argument *)\n | Set of bool ref (* Set the reference to true *)\n | Clear of bool ref (* Set the reference to false *)\n | String of (string -> unit) (* Call the function with a string argument *)\n | Set_string of string ref (* Set the reference to the string argument *)\n | Int of (int -> unit) (* Call the function with an int argument *)\n | Set_int of int ref (* Set the reference to the int argument *)\n | Float of (float -> unit) (* Call the function with a float argument *)\n | Set_float of float ref (* Set the reference to the float argument *)\n | Tuple of spec list (* Take several arguments according to the\n spec list *)\n | Symbol of string list * (string -> unit)\n (* Take one of the symbols as argument and\n call the function with the symbol. *)\n | Rest of (string -> unit) (* Stop interpreting keywords and call the\n function with each remaining argument *)\n | Rest_all of (string list -> unit)\n (* Stop interpreting keywords and call the\n function with all remaining arguments. *)\n | Expand of (string -> string array) (* If the remaining arguments to process\n are of the form\n [[\"-foo\"; \"arg\"] @ rest] where \"foo\"\n is registered as [Expand f], then the\n arguments [f \"arg\" @ rest] are\n processed. Only allowed in\n [parse_and_expand_argv_dynamic]. *)\n\nexception Bad of string\nexception Help of string\n\ntype error =\n | Unknown of string\n | Wrong of string * string * string (* option, actual, expected *)\n | Missing of string\n | Message of string\n\nexception Stop of error (* used internally *)\n\nopen Printf\n\nlet rec assoc3 x l =\n match l with\n | [] -> raise Not_found\n | (y1, y2, _) :: _ when y1 = x -> y2\n | _ :: t -> assoc3 x t\n\n\nlet split s =\n let i = String.index s '=' in\n let len = String.length s in\n String.sub s 0 i, String.sub s (i+1) (len-(i+1))\n\n\nlet make_symlist prefix sep suffix l =\n match l with\n | [] -> \"\"\n | h::t -> (List.fold_left (fun x y -> x ^ sep ^ y) (prefix ^ h) t) ^ suffix\n\n\nlet print_spec buf (key, spec, doc) =\n if String.length doc > 0 then\n match spec with\n | Symbol (l, _) ->\n bprintf buf \" %s %s%s\\n\" key (make_symlist \"{\" \"|\" \"}\" l) doc\n | _ ->\n bprintf buf \" %s %s\\n\" key doc\n\n\nlet help_action () = raise (Stop (Unknown \"-help\"))\n\nlet add_help speclist =\n let add1 =\n try ignore (assoc3 \"-help\" speclist); []\n with Not_found ->\n [\"-help\", Unit help_action, \" Display this list of options\"]\n and add2 =\n try ignore (assoc3 \"--help\" speclist); []\n with Not_found ->\n [\"--help\", Unit help_action, \" Display this list of options\"]\n in\n speclist @ (add1 @ add2)\n\n\nlet usage_b buf speclist errmsg =\n bprintf buf \"%s\\n\" errmsg;\n List.iter (print_spec buf) (add_help speclist)\n\n\nlet usage_string speclist errmsg =\n let b = Buffer.create 200 in\n usage_b b speclist errmsg;\n Buffer.contents b\n\n\nlet usage speclist errmsg =\n eprintf \"%s\" (usage_string speclist errmsg)\n\n\nlet current = ref 0\n\nlet bool_of_string_opt x =\n try Some (bool_of_string x)\n with Invalid_argument _ -> None\n\nlet int_of_string_opt x =\n try Some (int_of_string x)\n with Failure _ -> None\n\nlet float_of_string_opt x =\n try Some (float_of_string x)\n with Failure _ -> None\n\nlet parse_and_expand_argv_dynamic_aux allow_expand current argv speclist anonfun\n errmsg =\n let initpos = !current in\n let convert_error error =\n (* convert an internal error to a Bad/Help exception\n *or* add the program name as a prefix and the usage message as a suffix\n to an user-raised Bad exception.\n *)\n let b = Buffer.create 200 in\n let progname =\n if initpos < (Array.length !argv) then !argv.(initpos) else \"(?)\" in\n begin match error with\n | Unknown \"-help\" -> ()\n | Unknown \"--help\" -> ()\n | Unknown s ->\n bprintf b \"%s: unknown option '%s'.\\n\" progname s\n | Missing s ->\n bprintf b \"%s: option '%s' needs an argument.\\n\" progname s\n | Wrong (opt, arg, expected) ->\n bprintf b \"%s: wrong argument '%s'; option '%s' expects %s.\\n\"\n progname arg opt expected\n | Message s -> (* user error message *)\n bprintf b \"%s: %s.\\n\" progname s\n end;\n usage_b b !speclist errmsg;\n if error = Unknown \"-help\" || error = Unknown \"--help\"\n then Help (Buffer.contents b)\n else Bad (Buffer.contents b)\n in\n incr current;\n while !current < (Array.length !argv) do\n begin try\n let s = !argv.(!current) in\n if String.length s >= 1 && s.[0] = '-' then begin\n let action, follow =\n try assoc3 s !speclist, None\n with Not_found ->\n try\n let keyword, arg = split s in\n assoc3 keyword !speclist, Some arg\n with Not_found -> raise (Stop (Unknown s))\n in\n let no_arg () =\n match follow with\n | None -> ()\n | Some arg -> raise (Stop (Wrong (s, arg, \"no argument\"))) in\n let get_arg () =\n match follow with\n | None ->\n if !current + 1 < (Array.length !argv) then !argv.(!current + 1)\n else raise (Stop (Missing s))\n | Some arg -> arg\n in\n let consume_arg () =\n match follow with\n | None -> incr current\n | Some _ -> ()\n in\n let rec treat_action = function\n | Unit f -> no_arg (); f ();\n | Bool f ->\n let arg = get_arg () in\n begin match bool_of_string_opt arg with\n | None -> raise (Stop (Wrong (s, arg, \"a boolean\")))\n | Some s -> f s\n end;\n consume_arg ();\n | Set r -> no_arg (); r := true;\n | Clear r -> no_arg (); r := false;\n | String f ->\n let arg = get_arg () in\n f arg;\n consume_arg ();\n | Symbol (symb, f) ->\n let arg = get_arg () in\n if List.mem arg symb then begin\n f arg;\n consume_arg ();\n end else begin\n raise (Stop (Wrong (s, arg, \"one of: \"\n ^ (make_symlist \"\" \" \" \"\" symb))))\n end\n | Set_string r ->\n r := get_arg ();\n consume_arg ();\n | Int f ->\n let arg = get_arg () in\n begin match int_of_string_opt arg with\n | None -> raise (Stop (Wrong (s, arg, \"an integer\")))\n | Some x -> f x\n end;\n consume_arg ();\n | Set_int r ->\n let arg = get_arg () in\n begin match int_of_string_opt arg with\n | None -> raise (Stop (Wrong (s, arg, \"an integer\")))\n | Some x -> r := x\n end;\n consume_arg ();\n | Float f ->\n let arg = get_arg () in\n begin match float_of_string_opt arg with\n | None -> raise (Stop (Wrong (s, arg, \"a float\")))\n | Some x -> f x\n end;\n consume_arg ();\n | Set_float r ->\n let arg = get_arg () in\n begin match float_of_string_opt arg with\n | None -> raise (Stop (Wrong (s, arg, \"a float\")))\n | Some x -> r := x\n end;\n consume_arg ();\n | Tuple specs ->\n no_arg ();\n List.iter treat_action specs;\n | Rest f ->\n no_arg ();\n while !current < (Array.length !argv) - 1 do\n f !argv.(!current + 1);\n consume_arg ();\n done;\n | Rest_all f ->\n no_arg ();\n let acc = ref [] in\n while !current < Array.length !argv - 1 do\n acc := !argv.(!current + 1) :: !acc;\n consume_arg ();\n done;\n f (List.rev !acc)\n | Expand f ->\n if not allow_expand then\n raise (Invalid_argument \"Arg.Expand is is only allowed with \\\n Arg.parse_and_expand_argv_dynamic\");\n let arg = get_arg () in\n let newarg = f arg in\n consume_arg ();\n let before = Array.sub !argv 0 (!current + 1)\n and after =\n Array.sub !argv (!current + 1)\n ((Array.length !argv) - !current - 1) in\n argv:= Array.concat [before;newarg;after];\n in\n treat_action action end\n else anonfun s\n with | Bad m -> raise (convert_error (Message m));\n | Stop e -> raise (convert_error e);\n end;\n incr current\n done\n\nlet parse_and_expand_argv_dynamic current argv speclist anonfun errmsg =\n parse_and_expand_argv_dynamic_aux true current argv speclist anonfun errmsg\n\nlet parse_argv_dynamic ?(current=current) argv speclist anonfun errmsg =\n parse_and_expand_argv_dynamic_aux false current (ref argv) speclist anonfun\n errmsg\n\n\nlet parse_argv ?(current=current) argv speclist anonfun errmsg =\n parse_argv_dynamic ~current:current argv (ref speclist) anonfun errmsg\n\n\nlet parse l f msg =\n try\n parse_argv Sys.argv l f msg\n with\n | Bad msg -> eprintf \"%s\" msg; exit 2\n | Help msg -> printf \"%s\" msg; exit 0\n\n\nlet parse_dynamic l f msg =\n try\n parse_argv_dynamic Sys.argv l f msg\n with\n | Bad msg -> eprintf \"%s\" msg; exit 2\n | Help msg -> printf \"%s\" msg; exit 0\n\nlet parse_expand l f msg =\n try\n let argv = ref Sys.argv in\n let spec = ref l in\n let current = ref (!current) in\n parse_and_expand_argv_dynamic current argv spec f msg\n with\n | Bad msg -> eprintf \"%s\" msg; exit 2\n | Help msg -> printf \"%s\" msg; exit 0\n\n\nlet second_word s =\n let len = String.length s in\n let rec loop n =\n if n >= len then len\n else if s.[n] = ' ' then loop (n+1)\n else n\n in\n match String.index s '\\t' with\n | n -> loop (n+1)\n | exception Not_found ->\n begin match String.index s ' ' with\n | n -> loop (n+1)\n | exception Not_found -> len\n end\n\n\nlet max_arg_len cur (kwd, spec, doc) =\n match spec with\n | Symbol _ -> Int.max cur (String.length kwd)\n | _ -> Int.max cur (String.length kwd + second_word doc)\n\n\nlet replace_leading_tab s =\n let seen = ref false in\n String.map (function '\\t' when not !seen -> seen := true; ' ' | c -> c) s\n\nlet add_padding len ksd =\n match ksd with\n | (_, _, \"\") ->\n (* Do not pad undocumented options, so that they still don't show up when\n * run through [usage] or [parse]. *)\n ksd\n | (kwd, (Symbol _ as spec), msg) ->\n let cutcol = second_word msg in\n let spaces = String.make ((Int.max 0 (len - cutcol)) + 3) ' ' in\n (kwd, spec, \"\\n\" ^ spaces ^ replace_leading_tab msg)\n | (kwd, spec, msg) ->\n let cutcol = second_word msg in\n let kwd_len = String.length kwd in\n let diff = len - kwd_len - cutcol in\n if diff <= 0 then\n (kwd, spec, replace_leading_tab msg)\n else\n let spaces = String.make diff ' ' in\n let prefix = String.sub (replace_leading_tab msg) 0 cutcol in\n let suffix = String.sub msg cutcol (String.length msg - cutcol) in\n (kwd, spec, prefix ^ spaces ^ suffix)\n\n\nlet align ?(limit=max_int) speclist =\n let completed = add_help speclist in\n let len = List.fold_left max_arg_len 0 completed in\n let len = Int.min len limit in\n List.map (add_padding len) completed\n\nlet trim_cr s =\n let len = String.length s in\n if len > 0 && String.get s (len - 1) = '\\r' then\n String.sub s 0 (len - 1)\n else\n s\n\nlet read_aux trim sep file =\n let ic = open_in_bin file in\n let buf = Buffer.create 200 in\n let words = ref [] in\n let stash () =\n let word = Buffer.contents buf in\n let word = if trim then trim_cr word else word in\n words := word :: !words;\n Buffer.clear buf\n in\n begin\n try while true do\n let c = input_char ic in\n if c = sep then stash () else Buffer.add_char buf c\n done\n with End_of_file -> ()\n end;\n if Buffer.length buf > 0 then stash ();\n close_in ic;\n Array.of_list (List.rev !words)\n\nlet read_arg = read_aux true '\\n'\n\nlet read_arg0 = read_aux false '\\x00'\n\nlet write_aux sep file args =\n let oc = open_out_bin file in\n Array.iter (fun s -> fprintf oc \"%s%c\" s sep) args;\n close_out oc\n\nlet write_arg = write_aux '\\n'\n\nlet write_arg0 = write_aux '\\x00'\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* The OCaml programmers *)\n(* *)\n(* Copyright 2018 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nexternal id : 'a -> 'a = \"%identity\"\nlet const c _ = c\nlet flip f x y = f y x\nlet negate p v = not (p v)\n\nexception Finally_raised of exn\n\nlet () = Printexc.register_printer @@ function\n| Finally_raised exn -> Some (\"Fun.Finally_raised: \" ^ Printexc.to_string exn)\n| _ -> None\n\nlet protect ~(finally : unit -> unit) work =\n let finally_no_exn () =\n try finally () with e ->\n let bt = Printexc.get_raw_backtrace () in\n Printexc.raise_with_backtrace (Finally_raised e) bt\n in\n match work () with\n | result -> finally_no_exn () ; result\n | exception work_exn ->\n let work_bt = Printexc.get_raw_backtrace () in\n finally_no_exn () ;\n Printexc.raise_with_backtrace work_exn work_bt\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* Message digest (MD5) *)\n\ntype t = string\n\nlet compare = String.compare\nlet equal = String.equal\n\nexternal unsafe_string: string -> int -> int -> t = \"caml_md5_string\"\nexternal channel: in_channel -> int -> t = \"caml_md5_chan\"\n\nlet string str =\n unsafe_string str 0 (String.length str)\n\nlet bytes b = string (Bytes.unsafe_to_string b)\n\nlet substring str ofs len =\n if ofs < 0 || len < 0 || ofs > String.length str - len\n then invalid_arg \"Digest.substring\"\n else unsafe_string str ofs len\n\nlet subbytes b ofs len = substring (Bytes.unsafe_to_string b) ofs len\n\nlet file filename =\n let ic = open_in_bin filename in\n match channel ic (-1) with\n | d -> close_in ic; d\n | exception e -> close_in ic; raise e\n\nlet output chan digest =\n output_string chan digest\n\nlet input chan = really_input_string chan 16\n\nlet char_hex n =\n Char.unsafe_chr (n + if n < 10 then Char.code '0' else (Char.code 'a' - 10))\n\nlet to_hex d =\n if String.length d <> 16 then invalid_arg \"Digest.to_hex\";\n let result = Bytes.create 32 in\n for i = 0 to 15 do\n let x = Char.code d.[i] in\n Bytes.unsafe_set result (i*2) (char_hex (x lsr 4));\n Bytes.unsafe_set result (i*2+1) (char_hex (x land 0x0f));\n done;\n Bytes.unsafe_to_string result\n\nlet from_hex s =\n if String.length s <> 32 then invalid_arg \"Digest.from_hex\";\n let digit c =\n match c with\n | '0'..'9' -> Char.code c - Char.code '0'\n | 'A'..'F' -> Char.code c - Char.code 'A' + 10\n | 'a'..'f' -> Char.code c - Char.code 'a' + 10\n | _ -> raise (Invalid_argument \"Digest.from_hex\")\n in\n let byte i = digit s.[i] lsl 4 + digit s.[i+1] in\n let result = Bytes.create 16 in\n for i = 0 to 15 do\n Bytes.set result i (Char.chr (byte (2 * i)));\n done;\n Bytes.unsafe_to_string result\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Damien Doligez, projet Para, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* Pseudo-random number generator\n This is a lagged-Fibonacci F(55, 24, +) with a modified addition\n function to enhance the mixing of bits.\n If we use normal addition, the low-order bit fails tests 1 and 7\n of the Diehard test suite, and bits 1 and 2 also fail test 7.\n If we use multiplication as suggested by Marsaglia, it doesn't fare\n much better.\n By mixing the bits of one of the numbers before addition (XOR the\n 5 high-order bits into the low-order bits), we get a generator that\n passes all the Diehard tests.\n*)\n\nexternal random_seed: unit -> int array = \"caml_sys_random_seed\"\n\nmodule State = struct\n\n type t = { st : int array; mutable idx : int }\n\n let new_state () = { st = Array.make 55 0; idx = 0 }\n let assign st1 st2 =\n Array.blit st2.st 0 st1.st 0 55;\n st1.idx <- st2.idx\n\n\n let full_init s seed =\n let combine accu x = Digest.string (accu ^ Int.to_string x) in\n let extract d =\n Char.code d.[0] + (Char.code d.[1] lsl 8) + (Char.code d.[2] lsl 16)\n + (Char.code d.[3] lsl 24)\n in\n let seed = if Array.length seed = 0 then [| 0 |] else seed in\n let l = Array.length seed in\n for i = 0 to 54 do\n s.st.(i) <- i;\n done;\n let accu = ref \"x\" in\n for i = 0 to 54 + Int.max 55 l do\n let j = i mod 55 in\n let k = i mod l in\n accu := combine !accu seed.(k);\n s.st.(j) <- (s.st.(j) lxor extract !accu) land 0x3FFFFFFF; (* PR#5575 *)\n done;\n s.idx <- 0\n\n\n let make seed =\n let result = new_state () in\n full_init result seed;\n result\n\n\n let make_self_init () = make (random_seed ())\n\n let copy s =\n let result = new_state () in\n assign result s;\n result\n\n\n (* Returns 30 random bits as an integer 0 <= x < 1073741824 *)\n let bits s =\n s.idx <- (s.idx + 1) mod 55;\n let curval = s.st.(s.idx) in\n let newval = s.st.((s.idx + 24) mod 55)\n + (curval lxor ((curval lsr 25) land 0x1F)) in\n let newval30 = newval land 0x3FFFFFFF in (* PR#5575 *)\n s.st.(s.idx) <- newval30;\n newval30\n\n\n let rec intaux s n =\n let r = bits s in\n let v = r mod n in\n if r - v > 0x3FFFFFFF - n + 1 then intaux s n else v\n\n let int s bound =\n if bound > 0x3FFFFFFF || bound <= 0\n then invalid_arg \"Random.int\"\n else intaux s bound\n\n let rec int63aux s n =\n let max_int_32 = (1 lsl 30) + 0x3FFFFFFF in (* 0x7FFFFFFF *)\n let b1 = bits s in\n let b2 = bits s in\n let (r, max_int) =\n if n <= max_int_32 then\n (* 31 random bits on both 64-bit OCaml and JavaScript.\n Use upper 15 bits of b1 and 16 bits of b2. *)\n let bpos =\n (((b2 land 0x3FFFC000) lsl 1) lor (b1 lsr 15))\n in\n (bpos, max_int_32)\n else\n let b3 = bits s in\n (* 62 random bits on 64-bit OCaml; unreachable on JavaScript.\n Use upper 20 bits of b1 and 21 bits of b2 and b3. *)\n let bpos =\n ((((b3 land 0x3FFFFE00) lsl 12) lor (b2 lsr 9)) lsl 20)\n lor (b1 lsr 10)\n in\n (bpos, max_int)\n in\n let v = r mod n in\n if r - v > max_int - n + 1 then int63aux s n else v\n\n let full_int s bound =\n if bound <= 0 then\n invalid_arg \"Random.full_int\"\n else if bound > 0x3FFFFFFF then\n int63aux s bound\n else\n intaux s bound\n\n\n let rec int32aux s n =\n let b1 = Int32.of_int (bits s) in\n let b2 = Int32.shift_left (Int32.of_int (bits s land 1)) 30 in\n let r = Int32.logor b1 b2 in\n let v = Int32.rem r n in\n if Int32.sub r v > Int32.add (Int32.sub Int32.max_int n) 1l\n then int32aux s n\n else v\n\n let int32 s bound =\n if bound <= 0l\n then invalid_arg \"Random.int32\"\n else int32aux s bound\n\n\n let rec int64aux s n =\n let b1 = Int64.of_int (bits s) in\n let b2 = Int64.shift_left (Int64.of_int (bits s)) 30 in\n let b3 = Int64.shift_left (Int64.of_int (bits s land 7)) 60 in\n let r = Int64.logor b1 (Int64.logor b2 b3) in\n let v = Int64.rem r n in\n if Int64.sub r v > Int64.add (Int64.sub Int64.max_int n) 1L\n then int64aux s n\n else v\n\n let int64 s bound =\n if bound <= 0L\n then invalid_arg \"Random.int64\"\n else int64aux s bound\n\n\n let nativeint =\n if Nativeint.size = 32\n then fun s bound -> Nativeint.of_int32 (int32 s (Nativeint.to_int32 bound))\n else fun s bound -> Int64.to_nativeint (int64 s (Int64.of_nativeint bound))\n\n\n (* Returns a float 0 <= x <= 1 with at most 60 bits of precision. *)\n let rawfloat s =\n let scale = 1073741824.0 (* 2^30 *)\n and r1 = Stdlib.float (bits s)\n and r2 = Stdlib.float (bits s)\n in (r1 /. scale +. r2) /. scale\n\n\n let float s bound = rawfloat s *. bound\n\n let bool s = (bits s land 1 = 0)\n\n let bits32 s =\n let b1 = Int32.(shift_right_logical (of_int (bits s)) 14) in (* 16 bits *)\n let b2 = Int32.(shift_right_logical (of_int (bits s)) 14) in (* 16 bits *)\n Int32.(logor b1 (shift_left b2 16))\n\n let bits64 s =\n let b1 = Int64.(shift_right_logical (of_int (bits s)) 9) in (* 21 bits *)\n let b2 = Int64.(shift_right_logical (of_int (bits s)) 9) in (* 21 bits *)\n let b3 = Int64.(shift_right_logical (of_int (bits s)) 8) in (* 22 bits *)\n Int64.(logor b1 (logor (shift_left b2 21) (shift_left b3 42)))\n\n let nativebits =\n if Nativeint.size = 32\n then fun s -> Nativeint.of_int32 (bits32 s)\n else fun s -> Int64.to_nativeint (bits64 s)\n\nend\n\n(* This is the state you get with [init 27182818] and then applying\n the \"land 0x3FFFFFFF\" filter to them. See #5575, #5793, #5977. *)\nlet default = {\n State.st = [|\n 0x3ae2522b; 0x1d8d4634; 0x15b4fad0; 0x18b14ace; 0x12f8a3c4; 0x3b086c47;\n 0x16d467d6; 0x101d91c7; 0x321df177; 0x0176c193; 0x1ff72bf1; 0x1e889109;\n 0x0b464b18; 0x2b86b97c; 0x0891da48; 0x03137463; 0x085ac5a1; 0x15d61f2f;\n 0x3bced359; 0x29c1c132; 0x3a86766e; 0x366d8c86; 0x1f5b6222; 0x3ce1b59f;\n 0x2ebf78e1; 0x27cd1b86; 0x258f3dc3; 0x389a8194; 0x02e4c44c; 0x18c43f7d;\n 0x0f6e534f; 0x1e7df359; 0x055d0b7e; 0x10e84e7e; 0x126198e4; 0x0e7722cb;\n 0x1cbede28; 0x3391b964; 0x3d40e92a; 0x0c59933d; 0x0b8cd0b7; 0x24efff1c;\n 0x2803fdaa; 0x08ebc72e; 0x0f522e32; 0x05398edc; 0x2144a04c; 0x0aef3cbd;\n 0x01ad4719; 0x35b93cd6; 0x2a559d4f; 0x1e6fd768; 0x26e27f36; 0x186f18c3;\n 0x2fbf967a;\n |];\n State.idx = 0;\n}\n\nlet bits () = State.bits default\nlet int bound = State.int default bound\nlet full_int bound = State.full_int default bound\nlet int32 bound = State.int32 default bound\nlet nativeint bound = State.nativeint default bound\nlet int64 bound = State.int64 default bound\nlet float scale = State.float default scale\nlet bool () = State.bool default\nlet bits32 () = State.bits32 default\nlet bits64 () = State.bits64 default\nlet nativebits () = State.nativebits default\n\nlet full_init seed = State.full_init default seed\nlet init seed = State.full_init default [| seed |]\nlet self_init () = full_init (random_seed())\n\n(* Manipulating the current state. *)\n\nlet get_state () = State.copy default\nlet set_state s = State.assign default s\n\n(********************\n\n(* Test functions. Not included in the library.\n The [chisquare] function should be called with n > 10r.\n It returns a triple (low, actual, high).\n If low <= actual <= high, the [g] function passed the test,\n otherwise it failed.\n\n Some results:\n\ninit 27182818; chisquare int 100000 1000\ninit 27182818; chisquare int 100000 100\ninit 27182818; chisquare int 100000 5000\ninit 27182818; chisquare int 1000000 1000\ninit 27182818; chisquare int 100000 1024\ninit 299792643; chisquare int 100000 1024\ninit 14142136; chisquare int 100000 1024\ninit 27182818; init_diff 1024; chisquare diff 100000 1024\ninit 27182818; init_diff 100; chisquare diff 100000 100\ninit 27182818; init_diff2 1024; chisquare diff2 100000 1024\ninit 27182818; init_diff2 100; chisquare diff2 100000 100\ninit 14142136; init_diff2 100; chisquare diff2 100000 100\ninit 299792643; init_diff2 100; chisquare diff2 100000 100\n- : float * float * float = (936.754446796632465, 997.5, 1063.24555320336754)\n# - : float * float * float = (80., 89.7400000000052387, 120.)\n# - : float * float * float = (4858.57864376269, 5045.5, 5141.42135623731)\n# - : float * float * float =\n(936.754446796632465, 944.805999999982305, 1063.24555320336754)\n# - : float * float * float = (960., 1019.19744000000355, 1088.)\n# - : float * float * float = (960., 1059.31776000000536, 1088.)\n# - : float * float * float = (960., 1039.98463999999512, 1088.)\n# - : float * float * float = (960., 1054.38207999999577, 1088.)\n# - : float * float * float = (80., 90.096000000005, 120.)\n# - : float * float * float = (960., 1076.78720000000612, 1088.)\n# - : float * float * float = (80., 85.1760000000067521, 120.)\n# - : float * float * float = (80., 85.2160000000003492, 120.)\n# - : float * float * float = (80., 80.6220000000030268, 120.)\n\n*)\n\n(* Return the sum of the squares of v[i0,i1[ *)\nlet rec sumsq v i0 i1 =\n if i0 >= i1 then 0.0\n else if i1 = i0 + 1 then Stdlib.float v.(i0) *. Stdlib.float v.(i0)\n else sumsq v i0 ((i0+i1)/2) +. sumsq v ((i0+i1)/2) i1\n\n\nlet chisquare g n r =\n if n <= 10 * r then invalid_arg \"chisquare\";\n let f = Array.make r 0 in\n for i = 1 to n do\n let t = g r in\n f.(t) <- f.(t) + 1\n done;\n let t = sumsq f 0 r\n and r = Stdlib.float r\n and n = Stdlib.float n in\n let sr = 2.0 *. sqrt r in\n (r -. sr, (r *. t /. n) -. n, r +. sr)\n\n\n(* This is to test for linear dependencies between successive random numbers.\n*)\nlet st = ref 0\nlet init_diff r = st := int r\nlet diff r =\n let x1 = !st\n and x2 = int r\n in\n st := x2;\n if x1 >= x2 then\n x1 - x2\n else\n r + x1 - x2\n\n\nlet st1 = ref 0\nand st2 = ref 0\n\n\n(* This is to test for quadratic dependencies between successive random\n numbers.\n*)\nlet init_diff2 r = st1 := int r; st2 := int r\nlet diff2 r =\n let x1 = !st1\n and x2 = !st2\n and x3 = int r\n in\n st1 := x2;\n st2 := x3;\n (x3 - x2 - x2 + x1 + 2*r) mod r\n\n\n********************)\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* Hash tables *)\n\n(* We do dynamic hashing, and resize the table and rehash the elements\n when buckets become too long. *)\n\ntype ('a, 'b) t =\n { mutable size: int; (* number of entries *)\n mutable data: ('a, 'b) bucketlist array; (* the buckets *)\n seed: int; (* for randomization *)\n mutable initial_size: int; (* initial array size *)\n }\n\nand ('a, 'b) bucketlist =\n Empty\n | Cons of { mutable key: 'a;\n mutable data: 'b;\n mutable next: ('a, 'b) bucketlist }\n\n(* The sign of initial_size encodes the fact that a traversal is\n ongoing or not.\n\n This disables the efficient in place implementation of resizing.\n*)\n\nlet ongoing_traversal h =\n Obj.size (Obj.repr h) < 4 (* compatibility with old hash tables *)\n || h.initial_size < 0\n\nlet flip_ongoing_traversal h =\n h.initial_size <- - h.initial_size\n\n(* To pick random seeds if requested *)\n\nlet randomized_default =\n let params =\n try Sys.getenv \"OCAMLRUNPARAM\" with Not_found ->\n try Sys.getenv \"CAMLRUNPARAM\" with Not_found -> \"\" in\n String.contains params 'R'\n\nlet randomized = ref randomized_default\n\nlet randomize () = randomized := true\nlet is_randomized () = !randomized\n\nlet prng = lazy (Random.State.make_self_init())\n\n(* Functions which appear before the functorial interface must either be\n independent of the hash function or take it as a parameter (see #2202 and\n code below the functor definitions. *)\n\n(* Creating a fresh, empty table *)\n\nlet rec power_2_above x n =\n if x >= n then x\n else if x * 2 > Sys.max_array_length then x\n else power_2_above (x * 2) n\n\nlet create ?(random = !randomized) initial_size =\n let s = power_2_above 16 initial_size in\n let seed = if random then Random.State.bits (Lazy.force prng) else 0 in\n { initial_size = s; size = 0; seed = seed; data = Array.make s Empty }\n\nlet clear h =\n if h.size > 0 then begin\n h.size <- 0;\n Array.fill h.data 0 (Array.length h.data) Empty\n end\n\nlet reset h =\n let len = Array.length h.data in\n if Obj.size (Obj.repr h) < 4 (* compatibility with old hash tables *)\n || len = abs h.initial_size then\n clear h\n else begin\n h.size <- 0;\n h.data <- Array.make (abs h.initial_size) Empty\n end\n\nlet copy_bucketlist = function\n | Empty -> Empty\n | Cons {key; data; next} ->\n let rec loop prec = function\n | Empty -> ()\n | Cons {key; data; next} ->\n let r = Cons {key; data; next} in\n begin match prec with\n | Empty -> assert false\n | Cons prec -> prec.next <- r\n end;\n loop r next\n in\n let r = Cons {key; data; next} in\n loop r next;\n r\n\nlet copy h = { h with data = Array.map copy_bucketlist h.data }\n\nlet length h = h.size\n\nlet insert_all_buckets indexfun inplace odata ndata =\n let nsize = Array.length ndata in\n let ndata_tail = Array.make nsize Empty in\n let rec insert_bucket = function\n | Empty -> ()\n | Cons {key; data; next} as cell ->\n let cell =\n if inplace then cell\n else Cons {key; data; next = Empty}\n in\n let nidx = indexfun key in\n begin match ndata_tail.(nidx) with\n | Empty -> ndata.(nidx) <- cell;\n | Cons tail -> tail.next <- cell;\n end;\n ndata_tail.(nidx) <- cell;\n insert_bucket next\n in\n for i = 0 to Array.length odata - 1 do\n insert_bucket odata.(i)\n done;\n if inplace then\n for i = 0 to nsize - 1 do\n match ndata_tail.(i) with\n | Empty -> ()\n | Cons tail -> tail.next <- Empty\n done\n\nlet resize indexfun h =\n let odata = h.data in\n let osize = Array.length odata in\n let nsize = osize * 2 in\n if nsize < Sys.max_array_length then begin\n let ndata = Array.make nsize Empty in\n let inplace = not (ongoing_traversal h) in\n h.data <- ndata; (* so that indexfun sees the new bucket count *)\n insert_all_buckets (indexfun h) inplace odata ndata\n end\n\nlet iter f h =\n let rec do_bucket = function\n | Empty ->\n ()\n | Cons{key; data; next} ->\n f key data; do_bucket next in\n let old_trav = ongoing_traversal h in\n if not old_trav then flip_ongoing_traversal h;\n try\n let d = h.data in\n for i = 0 to Array.length d - 1 do\n do_bucket d.(i)\n done;\n if not old_trav then flip_ongoing_traversal h;\n with exn when not old_trav ->\n flip_ongoing_traversal h;\n raise exn\n\nlet rec filter_map_inplace_bucket f h i prec = function\n | Empty ->\n begin match prec with\n | Empty -> h.data.(i) <- Empty\n | Cons c -> c.next <- Empty\n end\n | (Cons ({key; data; next} as c)) as slot ->\n begin match f key data with\n | None ->\n h.size <- h.size - 1;\n filter_map_inplace_bucket f h i prec next\n | Some data ->\n begin match prec with\n | Empty -> h.data.(i) <- slot\n | Cons c -> c.next <- slot\n end;\n c.data <- data;\n filter_map_inplace_bucket f h i slot next\n end\n\nlet filter_map_inplace f h =\n let d = h.data in\n let old_trav = ongoing_traversal h in\n if not old_trav then flip_ongoing_traversal h;\n try\n for i = 0 to Array.length d - 1 do\n filter_map_inplace_bucket f h i Empty h.data.(i)\n done;\n if not old_trav then flip_ongoing_traversal h\n with exn when not old_trav ->\n flip_ongoing_traversal h;\n raise exn\n\nlet fold f h init =\n let rec do_bucket b accu =\n match b with\n Empty ->\n accu\n | Cons{key; data; next} ->\n do_bucket next (f key data accu) in\n let old_trav = ongoing_traversal h in\n if not old_trav then flip_ongoing_traversal h;\n try\n let d = h.data in\n let accu = ref init in\n for i = 0 to Array.length d - 1 do\n accu := do_bucket d.(i) !accu\n done;\n if not old_trav then flip_ongoing_traversal h;\n !accu\n with exn when not old_trav ->\n flip_ongoing_traversal h;\n raise exn\n\ntype statistics = {\n num_bindings: int;\n num_buckets: int;\n max_bucket_length: int;\n bucket_histogram: int array\n}\n\nlet rec bucket_length accu = function\n | Empty -> accu\n | Cons{next} -> bucket_length (accu + 1) next\n\nlet stats h =\n let mbl =\n Array.fold_left (fun m b -> Int.max m (bucket_length 0 b)) 0 h.data in\n let histo = Array.make (mbl + 1) 0 in\n Array.iter\n (fun b ->\n let l = bucket_length 0 b in\n histo.(l) <- histo.(l) + 1)\n h.data;\n { num_bindings = h.size;\n num_buckets = Array.length h.data;\n max_bucket_length = mbl;\n bucket_histogram = histo }\n\n(** {1 Iterators} *)\n\nlet to_seq tbl =\n (* capture current array, so that even if the table is resized we\n keep iterating on the same array *)\n let tbl_data = tbl.data in\n (* state: index * next bucket to traverse *)\n let rec aux i buck () = match buck with\n | Empty ->\n if i = Array.length tbl_data\n then Seq.Nil\n else aux(i+1) tbl_data.(i) ()\n | Cons {key; data; next} ->\n Seq.Cons ((key, data), aux i next)\n in\n aux 0 Empty\n\nlet to_seq_keys m = Seq.map fst (to_seq m)\n\nlet to_seq_values m = Seq.map snd (to_seq m)\n\n(* Functorial interface *)\n\nmodule type HashedType =\n sig\n type t\n val equal: t -> t -> bool\n val hash: t -> int\n end\n\nmodule type SeededHashedType =\n sig\n type t\n val equal: t -> t -> bool\n val hash: int -> t -> int\n end\n\nmodule type S =\n sig\n type key\n type !'a t\n val create: int -> 'a t\n val clear : 'a t -> unit\n val reset : 'a t -> unit\n val copy: 'a t -> 'a t\n val add: 'a t -> key -> 'a -> unit\n val remove: 'a t -> key -> unit\n val find: 'a t -> key -> 'a\n val find_opt: 'a t -> key -> 'a option\n val find_all: 'a t -> key -> 'a list\n val replace : 'a t -> key -> 'a -> unit\n val mem : 'a t -> key -> bool\n val iter: (key -> 'a -> unit) -> 'a t -> unit\n val filter_map_inplace: (key -> 'a -> 'a option) -> 'a t -> unit\n val fold: (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b\n val length: 'a t -> int\n val stats: 'a t -> statistics\n val to_seq : 'a t -> (key * 'a) Seq.t\n val to_seq_keys : _ t -> key Seq.t\n val to_seq_values : 'a t -> 'a Seq.t\n val add_seq : 'a t -> (key * 'a) Seq.t -> unit\n val replace_seq : 'a t -> (key * 'a) Seq.t -> unit\n val of_seq : (key * 'a) Seq.t -> 'a t\n end\n\nmodule type SeededS =\n sig\n type key\n type !'a t\n val create : ?random:bool -> int -> 'a t\n val clear : 'a t -> unit\n val reset : 'a t -> unit\n val copy : 'a t -> 'a t\n val add : 'a t -> key -> 'a -> unit\n val remove : 'a t -> key -> unit\n val find : 'a t -> key -> 'a\n val find_opt: 'a t -> key -> 'a option\n val find_all : 'a t -> key -> 'a list\n val replace : 'a t -> key -> 'a -> unit\n val mem : 'a t -> key -> bool\n val iter : (key -> 'a -> unit) -> 'a t -> unit\n val filter_map_inplace: (key -> 'a -> 'a option) -> 'a t -> unit\n val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b\n val length : 'a t -> int\n val stats: 'a t -> statistics\n val to_seq : 'a t -> (key * 'a) Seq.t\n val to_seq_keys : _ t -> key Seq.t\n val to_seq_values : 'a t -> 'a Seq.t\n val add_seq : 'a t -> (key * 'a) Seq.t -> unit\n val replace_seq : 'a t -> (key * 'a) Seq.t -> unit\n val of_seq : (key * 'a) Seq.t -> 'a t\n end\n\nmodule MakeSeeded(H: SeededHashedType): (SeededS with type key = H.t) =\n struct\n type key = H.t\n type 'a hashtbl = (key, 'a) t\n type 'a t = 'a hashtbl\n let create = create\n let clear = clear\n let reset = reset\n let copy = copy\n\n let key_index h key =\n (H.hash h.seed key) land (Array.length h.data - 1)\n\n let add h key data =\n let i = key_index h key in\n let bucket = Cons{key; data; next=h.data.(i)} in\n h.data.(i) <- bucket;\n h.size <- h.size + 1;\n if h.size > Array.length h.data lsl 1 then resize key_index h\n\n let rec remove_bucket h i key prec = function\n | Empty ->\n ()\n | (Cons {key=k; next}) as c ->\n if H.equal k key\n then begin\n h.size <- h.size - 1;\n match prec with\n | Empty -> h.data.(i) <- next\n | Cons c -> c.next <- next\n end\n else remove_bucket h i key c next\n\n let remove h key =\n let i = key_index h key in\n remove_bucket h i key Empty h.data.(i)\n\n let rec find_rec key = function\n | Empty ->\n raise Not_found\n | Cons{key=k; data; next} ->\n if H.equal key k then data else find_rec key next\n\n let find h key =\n match h.data.(key_index h key) with\n | Empty -> raise Not_found\n | Cons{key=k1; data=d1; next=next1} ->\n if H.equal key k1 then d1 else\n match next1 with\n | Empty -> raise Not_found\n | Cons{key=k2; data=d2; next=next2} ->\n if H.equal key k2 then d2 else\n match next2 with\n | Empty -> raise Not_found\n | Cons{key=k3; data=d3; next=next3} ->\n if H.equal key k3 then d3 else find_rec key next3\n\n let rec find_rec_opt key = function\n | Empty ->\n None\n | Cons{key=k; data; next} ->\n if H.equal key k then Some data else find_rec_opt key next\n\n let find_opt h key =\n match h.data.(key_index h key) with\n | Empty -> None\n | Cons{key=k1; data=d1; next=next1} ->\n if H.equal key k1 then Some d1 else\n match next1 with\n | Empty -> None\n | Cons{key=k2; data=d2; next=next2} ->\n if H.equal key k2 then Some d2 else\n match next2 with\n | Empty -> None\n | Cons{key=k3; data=d3; next=next3} ->\n if H.equal key k3 then Some d3 else find_rec_opt key next3\n\n let find_all h key =\n let rec find_in_bucket = function\n | Empty ->\n []\n | Cons{key=k; data=d; next} ->\n if H.equal k key\n then d :: find_in_bucket next\n else find_in_bucket next in\n find_in_bucket h.data.(key_index h key)\n\n let rec replace_bucket key data = function\n | Empty ->\n true\n | Cons ({key=k; next} as slot) ->\n if H.equal k key\n then (slot.key <- key; slot.data <- data; false)\n else replace_bucket key data next\n\n let replace h key data =\n let i = key_index h key in\n let l = h.data.(i) in\n if replace_bucket key data l then begin\n h.data.(i) <- Cons{key; data; next=l};\n h.size <- h.size + 1;\n if h.size > Array.length h.data lsl 1 then resize key_index h\n end\n\n let mem h key =\n let rec mem_in_bucket = function\n | Empty ->\n false\n | Cons{key=k; next} ->\n H.equal k key || mem_in_bucket next in\n mem_in_bucket h.data.(key_index h key)\n\n let add_seq tbl i =\n Seq.iter (fun (k,v) -> add tbl k v) i\n\n let replace_seq tbl i =\n Seq.iter (fun (k,v) -> replace tbl k v) i\n\n let of_seq i =\n let tbl = create 16 in\n replace_seq tbl i;\n tbl\n\n let iter = iter\n let filter_map_inplace = filter_map_inplace\n let fold = fold\n let length = length\n let stats = stats\n let to_seq = to_seq\n let to_seq_keys = to_seq_keys\n let to_seq_values = to_seq_values\n end\n\nmodule Make(H: HashedType): (S with type key = H.t) =\n struct\n include MakeSeeded(struct\n type t = H.t\n let equal = H.equal\n let hash (_seed: int) x = H.hash x\n end)\n let create sz = create ~random:false sz\n let of_seq i =\n let tbl = create 16 in\n replace_seq tbl i;\n tbl\n end\n\n(* Polymorphic hash function-based tables *)\n(* Code included below the functorial interface to guard against accidental\n use - see #2202 *)\n\nexternal seeded_hash_param :\n int -> int -> int -> 'a -> int = \"caml_hash\" [@@noalloc]\n\nlet hash x = seeded_hash_param 10 100 0 x\nlet hash_param n1 n2 x = seeded_hash_param n1 n2 0 x\nlet seeded_hash seed x = seeded_hash_param 10 100 seed x\n\nlet key_index h key =\n if Obj.size (Obj.repr h) >= 4\n then (seeded_hash_param 10 100 h.seed key) land (Array.length h.data - 1)\n else invalid_arg \"Hashtbl: unsupported hash table format\"\n\nlet add h key data =\n let i = key_index h key in\n let bucket = Cons{key; data; next=h.data.(i)} in\n h.data.(i) <- bucket;\n h.size <- h.size + 1;\n if h.size > Array.length h.data lsl 1 then resize key_index h\n\nlet rec remove_bucket h i key prec = function\n | Empty ->\n ()\n | (Cons {key=k; next}) as c ->\n if compare k key = 0\n then begin\n h.size <- h.size - 1;\n match prec with\n | Empty -> h.data.(i) <- next\n | Cons c -> c.next <- next\n end\n else remove_bucket h i key c next\n\nlet remove h key =\n let i = key_index h key in\n remove_bucket h i key Empty h.data.(i)\n\nlet rec find_rec key = function\n | Empty ->\n raise Not_found\n | Cons{key=k; data; next} ->\n if compare key k = 0 then data else find_rec key next\n\nlet find h key =\n match h.data.(key_index h key) with\n | Empty -> raise Not_found\n | Cons{key=k1; data=d1; next=next1} ->\n if compare key k1 = 0 then d1 else\n match next1 with\n | Empty -> raise Not_found\n | Cons{key=k2; data=d2; next=next2} ->\n if compare key k2 = 0 then d2 else\n match next2 with\n | Empty -> raise Not_found\n | Cons{key=k3; data=d3; next=next3} ->\n if compare key k3 = 0 then d3 else find_rec key next3\n\nlet rec find_rec_opt key = function\n | Empty ->\n None\n | Cons{key=k; data; next} ->\n if compare key k = 0 then Some data else find_rec_opt key next\n\nlet find_opt h key =\n match h.data.(key_index h key) with\n | Empty -> None\n | Cons{key=k1; data=d1; next=next1} ->\n if compare key k1 = 0 then Some d1 else\n match next1 with\n | Empty -> None\n | Cons{key=k2; data=d2; next=next2} ->\n if compare key k2 = 0 then Some d2 else\n match next2 with\n | Empty -> None\n | Cons{key=k3; data=d3; next=next3} ->\n if compare key k3 = 0 then Some d3 else find_rec_opt key next3\n\nlet find_all h key =\n let rec find_in_bucket = function\n | Empty ->\n []\n | Cons{key=k; data; next} ->\n if compare k key = 0\n then data :: find_in_bucket next\n else find_in_bucket next in\n find_in_bucket h.data.(key_index h key)\n\nlet rec replace_bucket key data = function\n | Empty ->\n true\n | Cons ({key=k; next} as slot) ->\n if compare k key = 0\n then (slot.key <- key; slot.data <- data; false)\n else replace_bucket key data next\n\nlet replace h key data =\n let i = key_index h key in\n let l = h.data.(i) in\n if replace_bucket key data l then begin\n h.data.(i) <- Cons{key; data; next=l};\n h.size <- h.size + 1;\n if h.size > Array.length h.data lsl 1 then resize key_index h\n end\n\nlet mem h key =\n let rec mem_in_bucket = function\n | Empty ->\n false\n | Cons{key=k; next} ->\n compare k key = 0 || mem_in_bucket next in\n mem_in_bucket h.data.(key_index h key)\n\nlet add_seq tbl i =\n Seq.iter (fun (k,v) -> add tbl k v) i\n\nlet replace_seq tbl i =\n Seq.iter (fun (k,v) -> replace tbl k v) i\n\nlet of_seq i =\n let tbl = create 16 in\n replace_seq tbl i;\n tbl\n\nlet rebuild ?(random = !randomized) h =\n let s = power_2_above 16 (Array.length h.data) in\n let seed =\n if random then Random.State.bits (Lazy.force prng)\n else if Obj.size (Obj.repr h) >= 4 then h.seed\n else 0 in\n let h' = {\n size = h.size;\n data = Array.make s Empty;\n seed = seed;\n initial_size = if Obj.size (Obj.repr h) >= 4 then h.initial_size else s\n } in\n insert_all_buckets (key_index h') false h.data h'.data;\n h'\n","open! Import\n\nlet poly_equal a b =\n let module Poly = struct\n type t = T : _ -> t\n end in\n Stdppx.Poly.equal (Poly.T a) (Poly.T b)\n\nmodule Context = struct\n type 'a t =\n | Label_declaration : label_declaration t\n | Constructor_declaration : constructor_declaration t\n | Type_declaration : type_declaration t\n | Type_exception : type_exception t\n | Type_extension : type_extension t\n | Extension_constructor : extension_constructor t\n | Pattern : pattern t\n | Core_type : core_type t\n | Expression : expression t\n | Value_description : value_description t\n | Class_type : class_type t\n | Class_type_field : class_type_field t\n | Class_infos : _ class_infos t\n | Class_expr : class_expr t\n | Class_field : class_field t\n | Module_type : module_type t\n | Module_declaration : module_declaration t\n | Module_type_declaration : module_type_declaration t\n | Module_substitution : module_substitution t\n | Open_description : open_description t\n | Open_declaration : open_declaration t\n | Include_infos : _ include_infos t\n | Module_expr : module_expr t\n | Value_binding : value_binding t\n | Module_binding : module_binding t\n | Pstr_eval : structure_item t\n | Pstr_extension : structure_item t\n | Psig_extension : signature_item t\n | Rtag : row_field t\n | Object_type_field : object_field t\n\n let label_declaration = Label_declaration\n let constructor_declaration = Constructor_declaration\n let type_declaration = Type_declaration\n let type_extension = Type_extension\n let type_exception = Type_exception\n let extension_constructor = Extension_constructor\n let pattern = Pattern\n let core_type = Core_type\n let expression = Expression\n let value_description = Value_description\n let class_type = Class_type\n let class_type_field = Class_type_field\n let class_infos = Class_infos\n let class_expr = Class_expr\n let class_field = Class_field\n let module_type = Module_type\n let module_declaration = Module_declaration\n let module_type_declaration = Module_type_declaration\n let open_description = Open_description\n let include_infos = Include_infos\n let module_expr = Module_expr\n let value_binding = Value_binding\n let module_binding = Module_binding\n let pstr_eval = Pstr_eval\n let pstr_extension = Pstr_extension\n let psig_extension = Psig_extension\n let rtag = Rtag\n let object_type_field = Object_type_field\n\n let get_pstr_eval st =\n match st.pstr_desc with\n | Pstr_eval (e, l) -> (e, l)\n | _ -> failwith \"Attribute.Context.get_pstr_eval\"\n\n let get_pstr_extension st =\n match st.pstr_desc with\n | Pstr_extension (e, l) -> (e, l)\n | _ -> failwith \"Attribute.Context.get_pstr_extension\"\n\n let get_psig_extension st =\n match st.psig_desc with\n | Psig_extension (e, l) -> (e, l)\n | _ -> failwith \"Attribute.Context.get_psig_extension\"\n\n let get_attributes : type a. a t -> a -> attributes =\n fun t x ->\n match t with\n | Label_declaration -> x.pld_attributes\n | Constructor_declaration -> x.pcd_attributes\n | Type_declaration -> x.ptype_attributes\n | Type_extension -> x.ptyext_attributes\n | Type_exception -> x.ptyexn_attributes\n | Extension_constructor -> x.pext_attributes\n | Pattern -> x.ppat_attributes\n | Core_type -> x.ptyp_attributes\n | Expression -> x.pexp_attributes\n | Value_description -> x.pval_attributes\n | Class_type -> x.pcty_attributes\n | Class_type_field -> x.pctf_attributes\n | Class_infos -> x.pci_attributes\n | Class_expr -> x.pcl_attributes\n | Class_field -> x.pcf_attributes\n | Module_type -> x.pmty_attributes\n | Module_declaration -> x.pmd_attributes\n | Module_type_declaration -> x.pmtd_attributes\n | Module_substitution -> x.pms_attributes\n | Open_description -> x.popen_attributes\n | Open_declaration -> x.popen_attributes\n | Include_infos -> x.pincl_attributes\n | Module_expr -> x.pmod_attributes\n | Value_binding -> x.pvb_attributes\n | Module_binding -> x.pmb_attributes\n | Pstr_eval -> snd (get_pstr_eval x)\n | Pstr_extension -> snd (get_pstr_extension x)\n | Psig_extension -> snd (get_psig_extension x)\n | Rtag -> x.prf_attributes\n | Object_type_field -> x.pof_attributes\n\n let set_attributes : type a. a t -> a -> attributes -> a =\n fun t x attrs ->\n match t with\n | Label_declaration -> { x with pld_attributes = attrs }\n | Constructor_declaration -> { x with pcd_attributes = attrs }\n | Type_declaration -> { x with ptype_attributes = attrs }\n | Type_extension -> { x with ptyext_attributes = attrs }\n | Type_exception -> { x with ptyexn_attributes = attrs }\n | Extension_constructor -> { x with pext_attributes = attrs }\n | Pattern -> { x with ppat_attributes = attrs }\n | Core_type -> { x with ptyp_attributes = attrs }\n | Expression -> { x with pexp_attributes = attrs }\n | Value_description -> { x with pval_attributes = attrs }\n | Class_type -> { x with pcty_attributes = attrs }\n | Class_type_field -> { x with pctf_attributes = attrs }\n | Class_infos -> { x with pci_attributes = attrs }\n | Class_expr -> { x with pcl_attributes = attrs }\n | Class_field -> { x with pcf_attributes = attrs }\n | Module_type -> { x with pmty_attributes = attrs }\n | Module_declaration -> { x with pmd_attributes = attrs }\n | Module_type_declaration -> { x with pmtd_attributes = attrs }\n | Module_substitution -> { x with pms_attributes = attrs }\n | Open_description -> { x with popen_attributes = attrs }\n | Open_declaration -> { x with popen_attributes = attrs }\n | Include_infos -> { x with pincl_attributes = attrs }\n | Module_expr -> { x with pmod_attributes = attrs }\n | Value_binding -> { x with pvb_attributes = attrs }\n | Module_binding -> { x with pmb_attributes = attrs }\n | Pstr_eval ->\n { x with pstr_desc = Pstr_eval (get_pstr_eval x |> fst, attrs) }\n | Pstr_extension ->\n {\n x with\n pstr_desc = Pstr_extension (get_pstr_extension x |> fst, attrs);\n }\n | Psig_extension ->\n {\n x with\n psig_desc = Psig_extension (get_psig_extension x |> fst, attrs);\n }\n | Rtag -> { x with prf_attributes = attrs }\n | Object_type_field -> { x with pof_attributes = attrs }\n\n let desc : type a. a t -> string = function\n | Label_declaration -> \"label declaration\"\n | Constructor_declaration -> \"constructor declaration\"\n | Type_declaration -> \"type declaration\"\n | Type_extension -> \"type extension\"\n | Type_exception -> \"type exception\"\n | Extension_constructor -> \"extension constructor\"\n | Pattern -> \"pattern\"\n | Core_type -> \"core type\"\n | Expression -> \"expression\"\n | Value_description -> \"value\"\n | Class_type -> \"class type\"\n | Class_type_field -> \"class type field\"\n | Class_infos -> \"class declaration\"\n | Class_expr -> \"class expression\"\n | Class_field -> \"class field\"\n | Module_type -> \"module type\"\n | Module_declaration -> \"module declaration\"\n | Module_type_declaration -> \"module type declaration\"\n | Module_substitution -> \"module substitution\"\n | Open_description -> \"open\"\n | Open_declaration -> \"open\"\n | Include_infos -> \"include\"\n | Module_expr -> \"module expression\"\n | Value_binding -> \"value binding\"\n | Module_binding -> \"module binding\"\n | Pstr_eval -> \"toplevel expression\"\n | Pstr_extension -> \"toplevel extension\"\n | Psig_extension -> \"toplevel signature extension\"\n | Rtag -> \"polymorphic variant tag\"\n | Object_type_field -> \"object type field\"\n\n (*\n let pattern : type a b c d. a t\n -> (attributes, b, c) Ast_pattern.t\n -> (a, c, d) Ast_pattern.t\n -> (a, b, d) Ast_pattern.t = function\n | Label_declaration -> Ast_pattern.pld_attributes\n | Constructor_declaration -> Ast_pattern.pcd_attributes\n | Type_declaration -> Ast_pattern.ptype_attributes\n | Type_extension -> Ast_pattern.ptyext_attributes\n | Extension_constructor -> Ast_pattern.pext_attributes\n*)\n\n let equal : _ t -> _ t -> bool = poly_equal\nend\n\nmodule Floating_context = struct\n type 'a t =\n | Structure_item : structure_item t\n | Signature_item : signature_item t\n | Class_field : class_field t\n | Class_type_field : class_type_field t\n\n let structure_item = Structure_item\n let signature_item = Signature_item\n let class_field = Class_field\n let class_type_field = Class_type_field\n\n let get_attribute_if_is_floating_node : type a. a t -> a -> attribute option =\n fun t x ->\n match (t, x) with\n | Structure_item, { pstr_desc = Pstr_attribute a; _ } -> Some a\n | Signature_item, { psig_desc = Psig_attribute a; _ } -> Some a\n | Class_field, { pcf_desc = Pcf_attribute a; _ } -> Some a\n | Class_type_field, { pctf_desc = Pctf_attribute a; _ } -> Some a\n | _ -> None\n\n let get_attribute t x =\n match get_attribute_if_is_floating_node t x with\n | Some a -> a\n | None -> failwith \"Attribute.Floating.Context.get_attribute\"\n\n let replace_by_dummy : type a. a t -> a -> a =\n let dummy_ext = ({ txt = \"\"; loc = Location.none }, PStr []) in\n fun t x ->\n match t with\n | Structure_item -> { x with pstr_desc = Pstr_extension (dummy_ext, []) }\n | Signature_item -> { x with psig_desc = Psig_extension (dummy_ext, []) }\n | Class_field -> { x with pcf_desc = Pcf_extension dummy_ext }\n | Class_type_field -> { x with pctf_desc = Pctf_extension dummy_ext }\n\n let desc : type a. a t -> string = function\n | Structure_item -> \"structure item\"\n | Signature_item -> \"signature item\"\n | Class_field -> \"class field\"\n | Class_type_field -> \"class type field\"\n\n let equal : _ t -> _ t -> bool = poly_equal\nend\n\ntype packed_context =\n | On_item : _ Context.t -> packed_context\n | Floating : _ Floating_context.t -> packed_context\n\ntype _ payload_parser =\n | Payload_parser :\n (payload, 'a, 'b) Ast_pattern.t * (name_loc:Location.t -> 'a)\n -> 'b payload_parser\n\ntype ('a, 'b) t = {\n name : Name.Pattern.t;\n context : 'a Context.t;\n payload : 'b payload_parser;\n}\n\ntype packed = T : (_, _) t -> packed\n\nlet name t = Name.Pattern.name t.name\nlet context t = t.context\n\nlet registrar =\n Name.Registrar.create ~kind:\"attribute\" ~current_file:__FILE__\n ~string_of_context:(function\n | On_item t -> Some (Context.desc t)\n | Floating t -> Some (Floating_context.desc t ^ \" (floating)\"))\n\nlet declare_with_name_loc name context pattern k =\n Name.Registrar.register ~kind:`Attribute registrar (On_item context) name;\n {\n name = Name.Pattern.make name;\n context;\n payload = Payload_parser (pattern, k);\n }\n\nlet declare name context pattern k =\n declare_with_name_loc name context pattern (fun ~name_loc:_ -> k)\n\nmodule Attribute_table = Caml.Hashtbl.Make (struct\n type t = string loc\n\n let hash : t -> int = Hashtbl.hash\n let equal : t -> t -> bool = Poly.equal\nend)\n\nlet not_seen = Attribute_table.create 128\nlet mark_as_seen { attr_name; _ } = Attribute_table.remove not_seen attr_name\nlet mark_as_handled_manually = mark_as_seen\n\nlet explicitly_drop =\n object\n inherit Ast_traverse.iter\n method! attribute = mark_as_seen\n end\n\nlet get_internal =\n let rec find_best_match t attributes longest_match =\n match attributes with\n | [] -> longest_match\n | ({ attr_name = name; _ } as attr) :: rest ->\n if Name.Pattern.matches t.name name.txt then\n match longest_match with\n | None -> find_best_match t rest (Some attr)\n | Some { attr_name = name'; _ } ->\n let len = String.length name.txt in\n let len' = String.length name'.txt in\n if len > len' then find_best_match t rest (Some attr)\n else if len < len' then find_best_match t rest longest_match\n else Location.raise_errorf ~loc:name.loc \"Duplicated attribute\"\n else find_best_match t rest longest_match\n in\n fun t attributes -> find_best_match t attributes None\n\nlet convert ?(do_mark_as_seen = true) pattern attr =\n if do_mark_as_seen then mark_as_seen attr;\n let (Payload_parser (pattern, k)) = pattern in\n Ast_pattern.parse pattern\n (Common.loc_of_payload attr)\n attr.attr_payload\n (k ~name_loc:attr.attr_name.loc)\n\nlet get t ?mark_as_seen:do_mark_as_seen x =\n let attrs = Context.get_attributes t.context x in\n match get_internal t attrs with\n | None -> None\n | Some attr -> Some (convert t.payload attr ?do_mark_as_seen)\n\nlet consume t x =\n let attrs = Context.get_attributes t.context x in\n match get_internal t attrs with\n | None -> None\n | Some attr ->\n let attrs = List.filter attrs ~f:(fun attr' -> not (attr == attr')) in\n let x = Context.set_attributes t.context x attrs in\n Some (x, convert t.payload attr)\n\nlet remove_seen (type a) (context : a Context.t) packeds (x : a) =\n let attrs = Context.get_attributes context x in\n let matched =\n let rec loop acc = function\n | [] -> acc\n | T t :: rest ->\n if Context.equal t.context context then\n match get_internal t attrs with\n | None -> loop acc rest\n | Some attr ->\n let name = attr.attr_name in\n if Attribute_table.mem not_seen name then loop acc rest\n else loop (attr :: acc) rest\n else loop acc rest\n in\n loop [] packeds\n in\n let attrs =\n List.filter attrs ~f:(fun attr' -> not (List.memq ~set:matched attr'))\n in\n Context.set_attributes context x attrs\n\nlet pattern t p =\n let f = Ast_pattern.to_func p in\n Ast_pattern.of_func (fun ctx loc x k ->\n match consume t x with\n | None -> f ctx loc x (k None)\n | Some (x, v) -> f ctx loc x (k (Some v)))\n\nmodule Floating = struct\n module Context = Floating_context\n\n type ('a, 'b) t = {\n name : Name.Pattern.t;\n context : 'a Context.t;\n payload : 'b payload_parser;\n }\n\n let name t = Name.Pattern.name t.name\n\n let declare name context pattern k =\n Name.Registrar.register ~kind:`Attribute registrar (Floating context) name;\n {\n name = Name.Pattern.make name;\n context;\n payload = Payload_parser (pattern, fun ~name_loc:_ -> k);\n }\n\n let convert ts x =\n match ts with\n | [] -> None\n | { context; _ } :: _ -> (\n assert (List.for_all ts ~f:(fun t -> Context.equal t.context context));\n let attr = Context.get_attribute context x in\n let name = attr.attr_name in\n match\n List.filter ts ~f:(fun t -> Name.Pattern.matches t.name name.txt)\n with\n | [] -> None\n | [ t ] -> Some (convert t.payload attr)\n | l ->\n Location.raise_errorf ~loc:name.loc\n \"Multiple match for floating attributes: %s\"\n (String.concat ~sep:\", \"\n (List.map l ~f:(fun t -> Name.Pattern.name t.name))))\nend\n\nlet check_attribute registrar context name =\n if\n (not\n (Name.Whitelisted.is_whitelisted ~kind:`Attribute name.txt\n || Name.ignore_checks name.txt))\n && Attribute_table.mem not_seen name\n then\n let white_list = Name.Whitelisted.get_attribute_list () in\n Name.Registrar.raise_errorf registrar context ~white_list\n \"Attribute `%s' was not used\" name\n\nlet check_unused =\n object (self)\n inherit Ast_traverse.iter as super\n\n method! attribute { attr_name = name; _ } =\n Location.raise_errorf ~loc:name.loc\n \"attribute not expected here, Ppxlib.Attribute needs updating!\"\n\n method private check_node : type a. a Context.t -> a -> a =\n fun context node ->\n let attrs = Context.get_attributes context node in\n match attrs with\n | [] -> node\n | _ ->\n List.iter attrs\n ~f:(fun ({ attr_name = name; attr_payload = payload; _ } as attr)\n ->\n self#payload payload;\n check_attribute registrar (On_item context) name;\n (* If we allow the attribute to pass through, mark it as seen *)\n mark_as_seen attr);\n Context.set_attributes context node []\n\n method private check_floating : type a. a Floating.Context.t -> a -> a =\n fun context node ->\n match\n Floating.Context.get_attribute_if_is_floating_node context node\n with\n | None -> node\n | Some ({ attr_name = name; attr_payload = payload; _ } as attr) ->\n self#payload payload;\n check_attribute registrar (Floating context) name;\n mark_as_seen attr;\n Floating.Context.replace_by_dummy context node\n\n method! label_declaration x =\n super#label_declaration (self#check_node Label_declaration x)\n\n method! constructor_declaration x =\n super#constructor_declaration (self#check_node Constructor_declaration x)\n\n method! type_declaration x =\n super#type_declaration (self#check_node Type_declaration x)\n\n method! type_extension x =\n super#type_extension (self#check_node Type_extension x)\n\n method! type_exception x =\n super#type_exception (self#check_node Type_exception x)\n\n method! extension_constructor x =\n super#extension_constructor (self#check_node Extension_constructor x)\n\n method! pattern x = super#pattern (self#check_node Pattern x)\n method! core_type x = super#core_type (self#check_node Core_type x)\n method! expression x = super#expression (self#check_node Expression x)\n\n method! value_description x =\n super#value_description (self#check_node Value_description x)\n\n method! class_type x = super#class_type (self#check_node Class_type x)\n\n method! class_infos f x =\n super#class_infos f (self#check_node Class_infos x)\n\n method! class_expr x = super#class_expr (self#check_node Class_expr x)\n method! module_type x = super#module_type (self#check_node Module_type x)\n\n method! module_declaration x =\n super#module_declaration (self#check_node Module_declaration x)\n\n method! module_type_declaration x =\n super#module_type_declaration (self#check_node Module_type_declaration x)\n\n method! open_description x =\n super#open_description (self#check_node Open_description x)\n\n method! open_declaration x =\n super#open_declaration (self#check_node Open_declaration x)\n\n method! include_infos f x =\n super#include_infos f (self#check_node Include_infos x)\n\n method! module_expr x = super#module_expr (self#check_node Module_expr x)\n\n method! value_binding x =\n super#value_binding (self#check_node Value_binding x)\n\n method! module_binding x =\n super#module_binding (self#check_node Module_binding x)\n\n method! class_field x =\n let x = self#check_node Class_field x in\n let x = self#check_floating Class_field x in\n super#class_field x\n\n method! class_type_field x =\n let x = self#check_node Class_type_field x in\n let x = self#check_floating Class_type_field x in\n super#class_type_field x\n\n method! row_field x =\n let x =\n match x.prf_desc with Rtag _ -> self#check_node Rtag x | _ -> x\n in\n super#row_field x\n\n method! core_type_desc x =\n let x =\n match x with\n | Ptyp_object (fields, closed_flag) ->\n let fields =\n List.map fields ~f:(self#check_node Object_type_field)\n in\n Ptyp_object (fields, closed_flag)\n | _ -> x\n in\n super#core_type_desc x\n\n method! structure_item item =\n let item = self#check_floating Structure_item item in\n let item =\n match item.pstr_desc with\n | Pstr_eval _ -> self#check_node Pstr_eval item\n | Pstr_extension _ -> self#check_node Pstr_extension item\n | _ -> item\n in\n super#structure_item item\n\n method! signature_item item =\n let item = self#check_floating Signature_item item in\n let item =\n match item.psig_desc with\n | Psig_extension _ -> self#check_node Psig_extension item\n | _ -> item\n in\n super#signature_item item\n end\n\nlet reset_checks () = Attribute_table.clear not_seen\n\nlet collect =\n object\n inherit Ast_traverse.iter as super\n\n method! attribute ({ attr_name = name; attr_payload = payload; _ } as attr)\n =\n let loc = Common.loc_of_attribute attr in\n super#payload payload;\n Attribute_table.add not_seen name loc\n end\n\nlet check_all_seen () =\n let fail name loc =\n let txt = name.txt in\n if not (Name.ignore_checks txt) then\n Location.raise_errorf ~loc \"Attribute `%s' was silently dropped\" txt\n in\n Attribute_table.iter fail not_seen\n\nlet remove_attributes_present_in table =\n object\n inherit Ast_traverse.iter as super\n\n method! attribute { attr_name = name; attr_payload = payload; _ } =\n super#payload payload;\n Attribute_table.remove table name\n end\n\nlet copy_of_not_seen () =\n let copy = Attribute_table.create (Attribute_table.length not_seen) in\n Attribute_table.iter (Attribute_table.add copy) not_seen;\n copy\n\nlet dropped_so_far_structure st =\n let table = copy_of_not_seen () in\n (remove_attributes_present_in table)#structure st;\n Attribute_table.fold\n (fun name loc acc -> { txt = name.txt; loc } :: acc)\n table []\n\nlet dropped_so_far_signature sg =\n let table = copy_of_not_seen () in\n (remove_attributes_present_in table)#signature sg;\n Attribute_table.fold\n (fun name loc acc -> { txt = name.txt; loc } :: acc)\n table []\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Pierre Weis, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* A pretty-printing facility and definition of formatters for 'parallel'\n (i.e. unrelated or independent) pretty-printing on multiple out channels. *)\n\n(*\n The pretty-printing engine internal data structures.\n*)\n\nlet id x = x\n\n(* A devoted type for sizes to avoid confusion\n between sizes and mere integers. *)\nmodule Size : sig\n type t\n\n val to_int : t -> int\n val of_int : int -> t\n val zero : t\n val unknown : t\n val is_known : t -> bool\nend = struct\n type t = int\n\n let to_int = id\n let of_int = id\n let zero = 0\n let unknown = -1\n let is_known n = n >= 0\nend\n\n\n\n(* The pretty-printing boxes definition:\n a pretty-printing box is either\n - hbox: horizontal box (no line splitting)\n - vbox: vertical box (every break hint splits the line)\n - hvbox: horizontal/vertical box\n (the box behaves as an horizontal box if it fits on\n the current line, otherwise the box behaves as a vertical box)\n - hovbox: horizontal or vertical compacting box\n (the box is compacting material, printing as much material as possible\n on every lines)\n - box: horizontal or vertical compacting box with enhanced box structure\n (the box behaves as an horizontal or vertical box but break hints split\n the line if splitting would move to the left)\n*)\ntype box_type = CamlinternalFormatBasics.block_type =\n | Pp_hbox | Pp_vbox | Pp_hvbox | Pp_hovbox | Pp_box | Pp_fits\n\n\n(* The pretty-printing tokens definition:\n are either text to print or pretty printing\n elements that drive indentation and line splitting. *)\ntype pp_token =\n | Pp_text of string (* normal text *)\n | Pp_break of { (* complete break *)\n fits: string * int * string; (* line is not split *)\n breaks: string * int * string; (* line is split *)\n }\n | Pp_tbreak of int * int (* go to next tabulation *)\n | Pp_stab (* set a tabulation *)\n | Pp_begin of int * box_type (* beginning of a box *)\n | Pp_end (* end of a box *)\n | Pp_tbegin of tbox (* beginning of a tabulation box *)\n | Pp_tend (* end of a tabulation box *)\n | Pp_newline (* to force a newline inside a box *)\n | Pp_if_newline (* to do something only if this very\n line has been broken *)\n | Pp_open_tag of stag (* opening a tag name *)\n | Pp_close_tag (* closing the most recently open tag *)\n\nand stag = ..\n\nand tbox = Pp_tbox of int list ref (* Tabulation box *)\n\ntype tag = string\ntype stag += String_tag of tag\n\n\n(* The pretty-printer queue:\n pretty-printing material is not written in the output as soon as emitted;\n instead, the material is simply recorded in the pretty-printer queue,\n until the enclosing box has a known computed size and proper splitting\n decisions can be made.\n\n The pretty-printer queue contains formatting elements to be printed.\n Each formatting element is a tuple (size, token, length), where\n - length is the declared length of the token,\n - size is effective size of the token when it is printed\n (size is set when the size of the box is known, so that size of break\n hints are definitive). *)\ntype pp_queue_elem = {\n mutable size : Size.t;\n token : pp_token;\n length : int;\n}\n\n\n(* The pretty-printer queue definition. *)\ntype pp_queue = pp_queue_elem Queue.t\n\n(* The pretty-printer scanning stack. *)\n\n(* The pretty-printer scanning stack: scanning element definition. *)\ntype pp_scan_elem = {\n left_total : int; (* Value of pp_left_total when the element was enqueued. *)\n queue_elem : pp_queue_elem\n}\n\n(* The pretty-printer formatting stack:\n the formatting stack contains the description of all the currently active\n boxes; the pretty-printer formatting stack is used to split the lines\n while printing tokens. *)\n\n(* The pretty-printer formatting stack: formatting stack element definition.\n Each stack element describes a pretty-printing box. *)\ntype pp_format_elem = { box_type : box_type; width : int }\n\n(* The formatter definition.\n Each formatter value is a pretty-printer instance with all its\n machinery. *)\ntype formatter = {\n (* The pretty-printer scanning stack. *)\n pp_scan_stack : pp_scan_elem Stack.t;\n (* The pretty-printer formatting stack. *)\n pp_format_stack : pp_format_elem Stack.t;\n pp_tbox_stack : tbox Stack.t;\n (* The pretty-printer semantics tag stack. *)\n pp_tag_stack : stag Stack.t;\n pp_mark_stack : stag Stack.t;\n (* Value of right margin. *)\n mutable pp_margin : int;\n (* Minimal space left before margin, when opening a box. *)\n mutable pp_min_space_left : int;\n (* Maximum value of indentation:\n no box can be opened further. *)\n mutable pp_max_indent : int;\n (* Space remaining on the current line. *)\n mutable pp_space_left : int;\n (* Current value of indentation. *)\n mutable pp_current_indent : int;\n (* True when the line has been broken by the pretty-printer. *)\n mutable pp_is_new_line : bool;\n (* Total width of tokens already printed. *)\n mutable pp_left_total : int;\n (* Total width of tokens ever put in queue. *)\n mutable pp_right_total : int;\n (* Current number of open boxes. *)\n mutable pp_curr_depth : int;\n (* Maximum number of boxes which can be simultaneously open. *)\n mutable pp_max_boxes : int;\n (* Ellipsis string. *)\n mutable pp_ellipsis : string;\n (* Output function. *)\n mutable pp_out_string : string -> int -> int -> unit;\n (* Flushing function. *)\n mutable pp_out_flush : unit -> unit;\n (* Output of new lines. *)\n mutable pp_out_newline : unit -> unit;\n (* Output of break hints spaces. *)\n mutable pp_out_spaces : int -> unit;\n (* Output of indentation of new lines. *)\n mutable pp_out_indent : int -> unit;\n (* Are tags printed ? *)\n mutable pp_print_tags : bool;\n (* Are tags marked ? *)\n mutable pp_mark_tags : bool;\n (* Find opening and closing markers of tags. *)\n mutable pp_mark_open_tag : stag -> string;\n mutable pp_mark_close_tag : stag -> string;\n mutable pp_print_open_tag : stag -> unit;\n mutable pp_print_close_tag : stag -> unit;\n (* The pretty-printer queue. *)\n pp_queue : pp_queue;\n}\n\n\n(* The formatter specific tag handling functions. *)\ntype formatter_stag_functions = {\n mark_open_stag : stag -> string;\n mark_close_stag : stag -> string;\n print_open_stag : stag -> unit;\n print_close_stag : stag -> unit;\n}\n\n\n(* The formatter functions to output material. *)\ntype formatter_out_functions = {\n out_string : string -> int -> int -> unit;\n out_flush : unit -> unit;\n out_newline : unit -> unit;\n out_spaces : int -> unit;\n out_indent : int -> unit;\n}\n\n\n(*\n\n Auxiliaries and basic functions.\n\n*)\n\n(* Enter a token in the pretty-printer queue. *)\nlet pp_enqueue state token =\n state.pp_right_total <- state.pp_right_total + token.length;\n Queue.add token state.pp_queue\n\n\nlet pp_clear_queue state =\n state.pp_left_total <- 1; state.pp_right_total <- 1;\n Queue.clear state.pp_queue\n\n\n(* Pp_infinity: large value for default tokens size.\n\n Pp_infinity is documented as being greater than 1e10; to avoid\n confusion about the word 'greater', we choose pp_infinity greater\n than 1e10 + 1; for correct handling of tests in the algorithm,\n pp_infinity must be even one more than 1e10 + 1; let's stand on the\n safe side by choosing 1.e10+10.\n\n Pp_infinity could probably be 1073741823 that is 2^30 - 1, that is\n the minimal upper bound for integers; now that max_int is defined,\n this limit could also be defined as max_int - 1.\n\n However, before setting pp_infinity to something around max_int, we\n must carefully double-check all the integer arithmetic operations\n that involve pp_infinity, since any overflow would wreck havoc the\n pretty-printing algorithm's invariants. Given that this arithmetic\n correctness check is difficult and error prone and given that 1e10\n + 1 is in practice large enough, there is no need to attempt to set\n pp_infinity to the theoretically maximum limit. It is not worth the\n burden ! *)\nlet pp_infinity = 1000000010\n\n(* Output functions for the formatter. *)\nlet pp_output_string state s = state.pp_out_string s 0 (String.length s)\nand pp_output_newline state = state.pp_out_newline ()\nand pp_output_spaces state n = state.pp_out_spaces n\nand pp_output_indent state n = state.pp_out_indent n\n\n(* Format a textual token *)\nlet format_pp_text state size text =\n state.pp_space_left <- state.pp_space_left - size;\n pp_output_string state text;\n state.pp_is_new_line <- false\n\n(* Format a string by its length, if not empty *)\nlet format_string state s =\n if s <> \"\" then format_pp_text state (String.length s) s\n\n(* To format a break, indenting a new line. *)\nlet break_new_line state (before, offset, after) width =\n format_string state before;\n pp_output_newline state;\n state.pp_is_new_line <- true;\n let indent = state.pp_margin - width + offset in\n (* Don't indent more than pp_max_indent. *)\n let real_indent = Int.min state.pp_max_indent indent in\n state.pp_current_indent <- real_indent;\n state.pp_space_left <- state.pp_margin - state.pp_current_indent;\n pp_output_indent state state.pp_current_indent;\n format_string state after\n\n\n(* To force a line break inside a box: no offset is added. *)\nlet break_line state width = break_new_line state (\"\", 0, \"\") width\n\n(* To format a break that fits on the current line. *)\nlet break_same_line state (before, width, after) =\n format_string state before;\n state.pp_space_left <- state.pp_space_left - width;\n pp_output_spaces state width;\n format_string state after\n\n\n(* To indent no more than pp_max_indent, if one tries to open a box\n beyond pp_max_indent, then the box is rejected on the left\n by simulating a break. *)\nlet pp_force_break_line state =\n match Stack.top_opt state.pp_format_stack with\n | None -> pp_output_newline state\n | Some { box_type; width } ->\n if width > state.pp_space_left then\n match box_type with\n | Pp_fits | Pp_hbox -> ()\n | Pp_vbox | Pp_hvbox | Pp_hovbox | Pp_box -> break_line state width\n\n\n(* To skip a token, if the previous line has been broken. *)\nlet pp_skip_token state =\n match Queue.take_opt state.pp_queue with\n | None -> () (* print_if_newline must have been the last printing command *)\n | Some { size; length; _ } ->\n state.pp_left_total <- state.pp_left_total - length;\n state.pp_space_left <- state.pp_space_left + Size.to_int size\n\n\n(*\n\n The main pretty printing functions.\n\n*)\n\n(* Formatting a token with a given size. *)\nlet format_pp_token state size = function\n\n | Pp_text s ->\n format_pp_text state size s\n\n | Pp_begin (off, ty) ->\n let insertion_point = state.pp_margin - state.pp_space_left in\n if insertion_point > state.pp_max_indent then\n (* can not open a box right there. *)\n begin pp_force_break_line state end;\n let width = state.pp_space_left - off in\n let box_type =\n match ty with\n | Pp_vbox -> Pp_vbox\n | Pp_hbox | Pp_hvbox | Pp_hovbox | Pp_box | Pp_fits ->\n if size > state.pp_space_left then ty else Pp_fits in\n Stack.push { box_type; width } state.pp_format_stack\n\n | Pp_end ->\n Stack.pop_opt state.pp_format_stack |> ignore\n\n | Pp_tbegin (Pp_tbox _ as tbox) ->\n Stack.push tbox state.pp_tbox_stack\n\n | Pp_tend ->\n Stack.pop_opt state.pp_tbox_stack |> ignore\n\n | Pp_stab ->\n begin match Stack.top_opt state.pp_tbox_stack with\n | None -> () (* No open tabulation box. *)\n | Some (Pp_tbox tabs) ->\n let rec add_tab n = function\n | [] -> [n]\n | x :: l as ls -> if n < x then n :: ls else x :: add_tab n l in\n tabs := add_tab (state.pp_margin - state.pp_space_left) !tabs\n end\n\n | Pp_tbreak (n, off) ->\n let insertion_point = state.pp_margin - state.pp_space_left in\n begin match Stack.top_opt state.pp_tbox_stack with\n | None -> () (* No open tabulation box. *)\n | Some (Pp_tbox tabs) ->\n let tab =\n match !tabs with\n | [] -> insertion_point\n | first :: _ ->\n let rec find = function\n | head :: tail ->\n if head >= insertion_point then head else find tail\n | [] -> first in\n find !tabs in\n let offset = tab - insertion_point in\n if offset >= 0\n then break_same_line state (\"\", offset + n, \"\")\n else break_new_line state (\"\", tab + off, \"\") state.pp_margin\n end\n\n | Pp_newline ->\n begin match Stack.top_opt state.pp_format_stack with\n | None -> pp_output_newline state (* No open box. *)\n | Some { width; _} -> break_line state width\n end\n\n | Pp_if_newline ->\n if state.pp_current_indent != state.pp_margin - state.pp_space_left\n then pp_skip_token state\n\n | Pp_break { fits; breaks } ->\n let before, off, _ = breaks in\n begin match Stack.top_opt state.pp_format_stack with\n | None -> () (* No open box. *)\n | Some { box_type; width } ->\n begin match box_type with\n | Pp_hovbox ->\n if size + String.length before > state.pp_space_left\n then break_new_line state breaks width\n else break_same_line state fits\n | Pp_box ->\n (* Have the line just been broken here ? *)\n if state.pp_is_new_line then break_same_line state fits else\n if size + String.length before > state.pp_space_left\n then break_new_line state breaks width else\n (* break the line here leads to new indentation ? *)\n if state.pp_current_indent > state.pp_margin - width + off\n then break_new_line state breaks width\n else break_same_line state fits\n | Pp_hvbox -> break_new_line state breaks width\n | Pp_fits -> break_same_line state fits\n | Pp_vbox -> break_new_line state breaks width\n | Pp_hbox -> break_same_line state fits\n end\n end\n\n | Pp_open_tag tag_name ->\n let marker = state.pp_mark_open_tag tag_name in\n pp_output_string state marker;\n Stack.push tag_name state.pp_mark_stack\n\n | Pp_close_tag ->\n begin match Stack.pop_opt state.pp_mark_stack with\n | None -> () (* No more tag to close. *)\n | Some tag_name ->\n let marker = state.pp_mark_close_tag tag_name in\n pp_output_string state marker\n end\n\n\n(* Print if token size is known else printing is delayed.\n Printing is delayed when the text waiting in the queue requires\n more room to format than exists on the current line. *)\nlet rec advance_left state =\n match Queue.peek_opt state.pp_queue with\n | None -> () (* No tokens to print *)\n | Some { size; token; length } ->\n let pending_count = state.pp_right_total - state.pp_left_total in\n if Size.is_known size || pending_count >= state.pp_space_left then begin\n Queue.take state.pp_queue |> ignore; (* Not empty: we peek into it *)\n let size = if Size.is_known size then Size.to_int size else pp_infinity in\n format_pp_token state size token;\n state.pp_left_total <- length + state.pp_left_total;\n (advance_left [@tailcall]) state\n end\n\n\n(* To enqueue a token : try to advance. *)\nlet enqueue_advance state tok = pp_enqueue state tok; advance_left state\n\n\n(* To enqueue strings. *)\nlet enqueue_string_as state size s =\n enqueue_advance state { size; token = Pp_text s; length = Size.to_int size }\n\n\nlet enqueue_string state s =\n enqueue_string_as state (Size.of_int (String.length s)) s\n\n\n(* Routines for scan stack\n determine size of boxes. *)\n\n(* The scan_stack is never empty. *)\nlet initialize_scan_stack stack =\n Stack.clear stack;\n let queue_elem = { size = Size.unknown; token = Pp_text \"\"; length = 0 } in\n Stack.push { left_total = -1; queue_elem } stack\n\n(* Setting the size of boxes on scan stack:\n if ty = true then size of break is set else size of box is set;\n in each case pp_scan_stack is popped.\n\n Note:\n Pattern matching on scan stack is exhaustive, since scan_stack is never\n empty.\n Pattern matching on token in scan stack is also exhaustive,\n since scan_push is used on breaks and opening of boxes. *)\nlet set_size state ty =\n match Stack.top_opt state.pp_scan_stack with\n | None -> () (* scan_stack is never empty. *)\n | Some { left_total; queue_elem } ->\n let size = Size.to_int queue_elem.size in\n (* test if scan stack contains any data that is not obsolete. *)\n if left_total < state.pp_left_total then\n initialize_scan_stack state.pp_scan_stack\n else\n match queue_elem.token with\n | Pp_break _ | Pp_tbreak (_, _) ->\n if ty then begin\n queue_elem.size <- Size.of_int (state.pp_right_total + size);\n Stack.pop_opt state.pp_scan_stack |> ignore\n end\n | Pp_begin (_, _) ->\n if not ty then begin\n queue_elem.size <- Size.of_int (state.pp_right_total + size);\n Stack.pop_opt state.pp_scan_stack |> ignore\n end\n | Pp_text _ | Pp_stab | Pp_tbegin _ | Pp_tend | Pp_end\n | Pp_newline | Pp_if_newline | Pp_open_tag _ | Pp_close_tag ->\n () (* scan_push is only used for breaks and boxes. *)\n\n\n(* Push a token on pretty-printer scanning stack.\n If b is true set_size is called. *)\nlet scan_push state b token =\n pp_enqueue state token;\n if b then set_size state true;\n let elem = { left_total = state.pp_right_total; queue_elem = token } in\n Stack.push elem state.pp_scan_stack\n\n\n(* To open a new box :\n the user may set the depth bound pp_max_boxes\n any text nested deeper is printed as the ellipsis string. *)\nlet pp_open_box_gen state indent br_ty =\n state.pp_curr_depth <- state.pp_curr_depth + 1;\n if state.pp_curr_depth < state.pp_max_boxes then\n let size = Size.of_int (- state.pp_right_total) in\n let elem = { size; token = Pp_begin (indent, br_ty); length = 0 } in\n scan_push state false elem else\n if state.pp_curr_depth = state.pp_max_boxes\n then enqueue_string state state.pp_ellipsis\n\n\n(* The box which is always open. *)\nlet pp_open_sys_box state = pp_open_box_gen state 0 Pp_hovbox\n\n(* Close a box, setting sizes of its sub boxes. *)\nlet pp_close_box state () =\n if state.pp_curr_depth > 1 then\n begin\n if state.pp_curr_depth < state.pp_max_boxes then\n begin\n pp_enqueue state { size = Size.zero; token = Pp_end; length = 0 };\n set_size state true; set_size state false\n end;\n state.pp_curr_depth <- state.pp_curr_depth - 1;\n end\n\n\n(* Open a tag, pushing it on the tag stack. *)\nlet pp_open_stag state tag_name =\n if state.pp_print_tags then\n begin\n Stack.push tag_name state.pp_tag_stack;\n state.pp_print_open_tag tag_name\n end;\n if state.pp_mark_tags then\n let token = Pp_open_tag tag_name in\n pp_enqueue state { size = Size.zero; token; length = 0 }\n\n\n(* Close a tag, popping it from the tag stack. *)\nlet pp_close_stag state () =\n if state.pp_mark_tags then\n pp_enqueue state { size = Size.zero; token = Pp_close_tag; length = 0 };\n if state.pp_print_tags then\n match Stack.pop_opt state.pp_tag_stack with\n | None -> () (* No more tag to close. *)\n | Some tag_name ->\n state.pp_print_close_tag tag_name\n\nlet pp_open_tag state s = pp_open_stag state (String_tag s)\nlet pp_close_tag state () = pp_close_stag state ()\n\nlet pp_set_print_tags state b = state.pp_print_tags <- b\nlet pp_set_mark_tags state b = state.pp_mark_tags <- b\nlet pp_get_print_tags state () = state.pp_print_tags\nlet pp_get_mark_tags state () = state.pp_mark_tags\nlet pp_set_tags state b =\n pp_set_print_tags state b; pp_set_mark_tags state b\n\n\n(* Handling tag handling functions: get/set functions. *)\nlet pp_get_formatter_stag_functions state () = {\n mark_open_stag = state.pp_mark_open_tag;\n mark_close_stag = state.pp_mark_close_tag;\n print_open_stag = state.pp_print_open_tag;\n print_close_stag = state.pp_print_close_tag;\n}\n\n\nlet pp_set_formatter_stag_functions state {\n mark_open_stag = mot;\n mark_close_stag = mct;\n print_open_stag = pot;\n print_close_stag = pct;\n } =\n state.pp_mark_open_tag <- mot;\n state.pp_mark_close_tag <- mct;\n state.pp_print_open_tag <- pot;\n state.pp_print_close_tag <- pct\n\n\n(* Initialize pretty-printer. *)\nlet pp_rinit state =\n pp_clear_queue state;\n initialize_scan_stack state.pp_scan_stack;\n Stack.clear state.pp_format_stack;\n Stack.clear state.pp_tbox_stack;\n Stack.clear state.pp_tag_stack;\n Stack.clear state.pp_mark_stack;\n state.pp_current_indent <- 0;\n state.pp_curr_depth <- 0;\n state.pp_space_left <- state.pp_margin;\n pp_open_sys_box state\n\nlet clear_tag_stack state =\n Stack.iter (fun _ -> pp_close_tag state ()) state.pp_tag_stack\n\n\n(* Flushing pretty-printer queue. *)\nlet pp_flush_queue state b =\n clear_tag_stack state;\n while state.pp_curr_depth > 1 do\n pp_close_box state ()\n done;\n state.pp_right_total <- pp_infinity;\n advance_left state;\n if b then pp_output_newline state;\n pp_rinit state\n\n(*\n\n Procedures to format values and use boxes.\n\n*)\n\n(* To format a string. *)\nlet pp_print_as_size state size s =\n if state.pp_curr_depth < state.pp_max_boxes\n then enqueue_string_as state size s\n\n\nlet pp_print_as state isize s =\n pp_print_as_size state (Size.of_int isize) s\n\n\nlet pp_print_string state s =\n pp_print_as state (String.length s) s\n\nlet pp_print_bytes state s =\n pp_print_as state (Bytes.length s) (Bytes.to_string s)\n\n(* To format an integer. *)\nlet pp_print_int state i = pp_print_string state (Int.to_string i)\n\n(* To format a float. *)\nlet pp_print_float state f = pp_print_string state (string_of_float f)\n\n(* To format a boolean. *)\nlet pp_print_bool state b = pp_print_string state (string_of_bool b)\n\n(* To format a char. *)\nlet pp_print_char state c =\n pp_print_as state 1 (String.make 1 c)\n\n\n(* Opening boxes. *)\nlet pp_open_hbox state () = pp_open_box_gen state 0 Pp_hbox\nand pp_open_vbox state indent = pp_open_box_gen state indent Pp_vbox\n\nand pp_open_hvbox state indent = pp_open_box_gen state indent Pp_hvbox\nand pp_open_hovbox state indent = pp_open_box_gen state indent Pp_hovbox\nand pp_open_box state indent = pp_open_box_gen state indent Pp_box\n\n\n(* Printing queued text.\n\n [pp_print_flush] prints all pending items in the pretty-printer queue and\n then flushes the low level output device of the formatter to actually\n display printing material.\n\n [pp_print_newline] behaves as [pp_print_flush] after printing an additional\n new line. *)\nlet pp_print_newline state () =\n pp_flush_queue state true; state.pp_out_flush ()\nand pp_print_flush state () =\n pp_flush_queue state false; state.pp_out_flush ()\n\n\n(* To get a newline when one does not want to close the current box. *)\nlet pp_force_newline state () =\n if state.pp_curr_depth < state.pp_max_boxes then\n enqueue_advance state { size = Size.zero; token = Pp_newline; length = 0 }\n\n\n(* To format something, only in case the line has just been broken. *)\nlet pp_print_if_newline state () =\n if state.pp_curr_depth < state.pp_max_boxes then\n enqueue_advance state\n { size = Size.zero; token = Pp_if_newline; length = 0 }\n\n\n(* Generalized break hint that allows printing strings before/after\n same-line offset (width) or new-line offset *)\nlet pp_print_custom_break state ~fits ~breaks =\n let before, width, after = fits in\n if state.pp_curr_depth < state.pp_max_boxes then\n let size = Size.of_int (- state.pp_right_total) in\n let token = Pp_break { fits; breaks } in\n let length = String.length before + width + String.length after in\n let elem = { size; token; length } in\n scan_push state true elem\n\n(* Printing break hints:\n A break hint indicates where a box may be broken.\n If line is broken then offset is added to the indentation of the current\n box else (the value of) width blanks are printed. *)\nlet pp_print_break state width offset =\n pp_print_custom_break state\n ~fits:(\"\", width, \"\") ~breaks:(\"\", offset, \"\")\n\n\n(* Print a space :\n a space is a break hint that prints a single space if the break does not\n split the line;\n a cut is a break hint that prints nothing if the break does not split the\n line. *)\nlet pp_print_space state () = pp_print_break state 1 0\nand pp_print_cut state () = pp_print_break state 0 0\n\n\n(* Tabulation boxes. *)\nlet pp_open_tbox state () =\n state.pp_curr_depth <- state.pp_curr_depth + 1;\n if state.pp_curr_depth < state.pp_max_boxes then\n let size = Size.zero in\n let elem = { size; token = Pp_tbegin (Pp_tbox (ref [])); length = 0 } in\n enqueue_advance state elem\n\n\n(* Close a tabulation box. *)\nlet pp_close_tbox state () =\n if state.pp_curr_depth > 1 then\n begin\n if state.pp_curr_depth < state.pp_max_boxes then\n let elem = { size = Size.zero; token = Pp_tend; length = 0 } in\n enqueue_advance state elem;\n state.pp_curr_depth <- state.pp_curr_depth - 1\n end\n\n\n(* Print a tabulation break. *)\nlet pp_print_tbreak state width offset =\n if state.pp_curr_depth < state.pp_max_boxes then\n let size = Size.of_int (- state.pp_right_total) in\n let elem = { size; token = Pp_tbreak (width, offset); length = width } in\n scan_push state true elem\n\n\nlet pp_print_tab state () = pp_print_tbreak state 0 0\n\nlet pp_set_tab state () =\n if state.pp_curr_depth < state.pp_max_boxes then\n let elem = { size = Size.zero; token = Pp_stab; length = 0 } in\n enqueue_advance state elem\n\n\n(*\n\n Procedures to control the pretty-printers\n\n*)\n\n(* Set_max_boxes. *)\nlet pp_set_max_boxes state n = if n > 1 then state.pp_max_boxes <- n\n\n(* To know the current maximum number of boxes allowed. *)\nlet pp_get_max_boxes state () = state.pp_max_boxes\n\nlet pp_over_max_boxes state () = state.pp_curr_depth = state.pp_max_boxes\n\n(* Ellipsis. *)\nlet pp_set_ellipsis_text state s = state.pp_ellipsis <- s\nand pp_get_ellipsis_text state () = state.pp_ellipsis\n\n\n(* To set the margin of pretty-printer. *)\nlet pp_limit n =\n if n < pp_infinity then n else pred pp_infinity\n\n\n(* Internal pretty-printer functions. *)\nlet pp_set_min_space_left state n =\n if n >= 1 then\n let n = pp_limit n in\n state.pp_min_space_left <- n;\n state.pp_max_indent <- state.pp_margin - state.pp_min_space_left;\n pp_rinit state\n\n\n(* Initially, we have :\n pp_max_indent = pp_margin - pp_min_space_left, and\n pp_space_left = pp_margin. *)\nlet pp_set_max_indent state n =\n if n > 1 then\n pp_set_min_space_left state (state.pp_margin - n)\n\n\nlet pp_get_max_indent state () = state.pp_max_indent\n\nlet pp_set_margin state n =\n if n >= 1 then\n let n = pp_limit n in\n state.pp_margin <- n;\n let new_max_indent =\n (* Try to maintain max_indent to its actual value. *)\n if state.pp_max_indent <= state.pp_margin\n then state.pp_max_indent else\n (* If possible maintain pp_min_space_left to its actual value,\n if this leads to a too small max_indent, take half of the\n new margin, if it is greater than 1. *)\n Int.max (Int.max (state.pp_margin - state.pp_min_space_left)\n (state.pp_margin / 2)) 1 in\n (* Rebuild invariants. *)\n pp_set_max_indent state new_max_indent\n\n\n(** Geometry functions and types *)\ntype geometry = { max_indent:int; margin: int}\n\nlet validate_geometry {margin; max_indent} =\n if max_indent < 2 then\n Error \"max_indent < 2\"\n else if margin <= max_indent then\n Error \"margin <= max_indent\"\n else Ok ()\n\nlet check_geometry geometry =\n match validate_geometry geometry with\n | Ok () -> true\n | Error _ -> false\n\nlet pp_get_margin state () = state.pp_margin\n\nlet pp_set_full_geometry state {margin; max_indent} =\n pp_set_margin state margin;\n pp_set_max_indent state max_indent;\n ()\n\nlet pp_set_geometry state ~max_indent ~margin =\n let geometry = { max_indent; margin } in\n match validate_geometry geometry with\n | Error msg ->\n raise (Invalid_argument (\"Format.pp_set_geometry: \" ^ msg))\n | Ok () ->\n pp_set_full_geometry state geometry\n\nlet pp_safe_set_geometry state ~max_indent ~margin =\n let geometry = { max_indent; margin } in\n match validate_geometry geometry with\n | Error _msg ->\n ()\n | Ok () ->\n pp_set_full_geometry state geometry\n\nlet pp_get_geometry state () =\n { margin = pp_get_margin state (); max_indent = pp_get_max_indent state () }\n\nlet pp_update_geometry state update =\n let geometry = pp_get_geometry state () in\n pp_set_full_geometry state (update geometry)\n\n(* Setting a formatter basic output functions. *)\nlet pp_set_formatter_out_functions state {\n out_string = f;\n out_flush = g;\n out_newline = h;\n out_spaces = i;\n out_indent = j;\n } =\n state.pp_out_string <- f;\n state.pp_out_flush <- g;\n state.pp_out_newline <- h;\n state.pp_out_spaces <- i;\n state.pp_out_indent <- j\n\nlet pp_get_formatter_out_functions state () = {\n out_string = state.pp_out_string;\n out_flush = state.pp_out_flush;\n out_newline = state.pp_out_newline;\n out_spaces = state.pp_out_spaces;\n out_indent = state.pp_out_indent;\n}\n\n\n(* Setting a formatter basic string output and flush functions. *)\nlet pp_set_formatter_output_functions state f g =\n state.pp_out_string <- f; state.pp_out_flush <- g\n\nlet pp_get_formatter_output_functions state () =\n (state.pp_out_string, state.pp_out_flush)\n\n\n(* The default function to output new lines. *)\nlet display_newline state () = state.pp_out_string \"\\n\" 0 1\n\n(* The default function to output spaces. *)\nlet blank_line = String.make 80 ' '\nlet rec display_blanks state n =\n if n > 0 then\n if n <= 80 then state.pp_out_string blank_line 0 n else\n begin\n state.pp_out_string blank_line 0 80;\n display_blanks state (n - 80)\n end\n\n\n(* The default function to output indentation of new lines. *)\nlet display_indent = display_blanks\n\n(* Setting a formatter basic output functions as printing to a given\n [Pervasive.out_channel] value. *)\nlet pp_set_formatter_out_channel state oc =\n state.pp_out_string <- output_substring oc;\n state.pp_out_flush <- (fun () -> flush oc);\n state.pp_out_newline <- display_newline state;\n state.pp_out_spaces <- display_blanks state;\n state.pp_out_indent <- display_indent state\n\n(*\n\n Defining specific formatters\n\n*)\n\nlet default_pp_mark_open_tag = function\n | String_tag s -> \"<\" ^ s ^ \">\"\n | _ -> \"\"\nlet default_pp_mark_close_tag = function\n | String_tag s -> \"\"\n | _ -> \"\"\n\nlet default_pp_print_open_tag = ignore\nlet default_pp_print_close_tag = ignore\n\n(* Building a formatter given its basic output functions.\n Other fields get reasonable default values. *)\nlet pp_make_formatter f g h i j =\n (* The initial state of the formatter contains a dummy box. *)\n let pp_queue = Queue.create () in\n let sys_tok =\n { size = Size.unknown; token = Pp_begin (0, Pp_hovbox); length = 0 } in\n Queue.add sys_tok pp_queue;\n let scan_stack = Stack.create () in\n initialize_scan_stack scan_stack;\n Stack.push { left_total = 1; queue_elem = sys_tok } scan_stack;\n let pp_margin = 78\n and pp_min_space_left = 10 in\n {\n pp_scan_stack = scan_stack;\n pp_format_stack = Stack.create ();\n pp_tbox_stack = Stack.create ();\n pp_tag_stack = Stack.create ();\n pp_mark_stack = Stack.create ();\n pp_margin = pp_margin;\n pp_min_space_left = pp_min_space_left;\n pp_max_indent = pp_margin - pp_min_space_left;\n pp_space_left = pp_margin;\n pp_current_indent = 0;\n pp_is_new_line = true;\n pp_left_total = 1;\n pp_right_total = 1;\n pp_curr_depth = 1;\n pp_max_boxes = max_int;\n pp_ellipsis = \".\";\n pp_out_string = f;\n pp_out_flush = g;\n pp_out_newline = h;\n pp_out_spaces = i;\n pp_out_indent = j;\n pp_print_tags = false;\n pp_mark_tags = false;\n pp_mark_open_tag = default_pp_mark_open_tag;\n pp_mark_close_tag = default_pp_mark_close_tag;\n pp_print_open_tag = default_pp_print_open_tag;\n pp_print_close_tag = default_pp_print_close_tag;\n pp_queue = pp_queue;\n }\n\n\n(* Build a formatter out of its out functions. *)\nlet formatter_of_out_functions out_funs =\n pp_make_formatter\n out_funs.out_string\n out_funs.out_flush\n out_funs.out_newline\n out_funs.out_spaces\n out_funs.out_indent\n\n\n(* Make a formatter with default functions to output spaces,\n indentation, and new lines. *)\nlet make_formatter output flush =\n let ppf = pp_make_formatter output flush ignore ignore ignore in\n ppf.pp_out_newline <- display_newline ppf;\n ppf.pp_out_spaces <- display_blanks ppf;\n ppf.pp_out_indent <- display_indent ppf;\n ppf\n\n\n(* Make a formatter writing to a given [Pervasive.out_channel] value. *)\nlet formatter_of_out_channel oc =\n make_formatter (output_substring oc) (fun () -> flush oc)\n\n\n(* Make a formatter writing to a given [Buffer.t] value. *)\nlet formatter_of_buffer b =\n make_formatter (Buffer.add_substring b) ignore\n\n\n(* Allocating buffer for pretty-printing purposes.\n Default buffer size is pp_buffer_size or 512.\n*)\nlet pp_buffer_size = 512\nlet pp_make_buffer () = Buffer.create pp_buffer_size\n\n(* The standard (shared) buffer. *)\nlet stdbuf = pp_make_buffer ()\n\n(* Predefined formatters standard formatter to print\n to [Stdlib.stdout], [Stdlib.stderr], and {!stdbuf}. *)\nlet std_formatter = formatter_of_out_channel Stdlib.stdout\nand err_formatter = formatter_of_out_channel Stdlib.stderr\nand str_formatter = formatter_of_buffer stdbuf\n\n\n(* [flush_buffer_formatter buf ppf] flushes formatter [ppf],\n then returns the contents of buffer [buf] that is reset.\n Formatter [ppf] is supposed to print to buffer [buf], otherwise this\n function is not really useful. *)\nlet flush_buffer_formatter buf ppf =\n pp_flush_queue ppf false;\n let s = Buffer.contents buf in\n Buffer.reset buf;\n s\n\n\n(* Flush [str_formatter] and get the contents of [stdbuf]. *)\nlet flush_str_formatter () = flush_buffer_formatter stdbuf str_formatter\n\n(*\n Symbolic pretty-printing\n*)\n\n(*\n Symbolic pretty-printing is pretty-printing with no low level output.\n\n When using a symbolic formatter, all regular pretty-printing activities\n occur but output material is symbolic and stored in a buffer of output\n items. At the end of pretty-printing, flushing the output buffer allows\n post-processing of symbolic output before low level output operations.\n*)\n\ntype symbolic_output_item =\n | Output_flush\n | Output_newline\n | Output_string of string\n | Output_spaces of int\n | Output_indent of int\n\ntype symbolic_output_buffer = {\n mutable symbolic_output_contents : symbolic_output_item list;\n}\n\nlet make_symbolic_output_buffer () =\n { symbolic_output_contents = [] }\n\nlet clear_symbolic_output_buffer sob =\n sob.symbolic_output_contents <- []\n\nlet get_symbolic_output_buffer sob =\n List.rev sob.symbolic_output_contents\n\nlet flush_symbolic_output_buffer sob =\n let items = get_symbolic_output_buffer sob in\n clear_symbolic_output_buffer sob;\n items\n\nlet add_symbolic_output_item sob item =\n sob.symbolic_output_contents <- item :: sob.symbolic_output_contents\n\nlet formatter_of_symbolic_output_buffer sob =\n let symbolic_flush sob () =\n add_symbolic_output_item sob Output_flush\n and symbolic_newline sob () =\n add_symbolic_output_item sob Output_newline\n and symbolic_string sob s i n =\n add_symbolic_output_item sob (Output_string (String.sub s i n))\n and symbolic_spaces sob n =\n add_symbolic_output_item sob (Output_spaces n)\n and symbolic_indent sob n =\n add_symbolic_output_item sob (Output_indent n) in\n\n let f = symbolic_string sob\n and g = symbolic_flush sob\n and h = symbolic_newline sob\n and i = symbolic_spaces sob\n and j = symbolic_indent sob in\n pp_make_formatter f g h i j\n\n(*\n\n Basic functions on the 'standard' formatter\n (the formatter that prints to [Stdlib.stdout]).\n\n*)\n\nlet open_hbox = pp_open_hbox std_formatter\nand open_vbox = pp_open_vbox std_formatter\nand open_hvbox = pp_open_hvbox std_formatter\nand open_hovbox = pp_open_hovbox std_formatter\nand open_box = pp_open_box std_formatter\nand close_box = pp_close_box std_formatter\nand open_tag = pp_open_tag std_formatter\nand close_tag = pp_close_tag std_formatter\nand open_stag = pp_open_stag std_formatter\nand close_stag = pp_close_stag std_formatter\nand print_as = pp_print_as std_formatter\nand print_string = pp_print_string std_formatter\nand print_bytes = pp_print_bytes std_formatter\nand print_int = pp_print_int std_formatter\nand print_float = pp_print_float std_formatter\nand print_char = pp_print_char std_formatter\nand print_bool = pp_print_bool std_formatter\nand print_break = pp_print_break std_formatter\nand print_cut = pp_print_cut std_formatter\nand print_space = pp_print_space std_formatter\nand force_newline = pp_force_newline std_formatter\nand print_flush = pp_print_flush std_formatter\nand print_newline = pp_print_newline std_formatter\nand print_if_newline = pp_print_if_newline std_formatter\n\nand open_tbox = pp_open_tbox std_formatter\nand close_tbox = pp_close_tbox std_formatter\nand print_tbreak = pp_print_tbreak std_formatter\n\nand set_tab = pp_set_tab std_formatter\nand print_tab = pp_print_tab std_formatter\n\nand set_margin = pp_set_margin std_formatter\nand get_margin = pp_get_margin std_formatter\n\nand set_max_indent = pp_set_max_indent std_formatter\nand get_max_indent = pp_get_max_indent std_formatter\n\nand set_geometry = pp_set_geometry std_formatter\nand safe_set_geometry = pp_safe_set_geometry std_formatter\nand get_geometry = pp_get_geometry std_formatter\nand update_geometry = pp_update_geometry std_formatter\n\nand set_max_boxes = pp_set_max_boxes std_formatter\nand get_max_boxes = pp_get_max_boxes std_formatter\nand over_max_boxes = pp_over_max_boxes std_formatter\n\nand set_ellipsis_text = pp_set_ellipsis_text std_formatter\nand get_ellipsis_text = pp_get_ellipsis_text std_formatter\n\nand set_formatter_out_channel =\n pp_set_formatter_out_channel std_formatter\n\nand set_formatter_out_functions =\n pp_set_formatter_out_functions std_formatter\nand get_formatter_out_functions =\n pp_get_formatter_out_functions std_formatter\n\nand set_formatter_output_functions =\n pp_set_formatter_output_functions std_formatter\nand get_formatter_output_functions =\n pp_get_formatter_output_functions std_formatter\n\nand set_formatter_stag_functions =\n pp_set_formatter_stag_functions std_formatter\nand get_formatter_stag_functions =\n pp_get_formatter_stag_functions std_formatter\nand set_print_tags =\n pp_set_print_tags std_formatter\nand get_print_tags =\n pp_get_print_tags std_formatter\nand set_mark_tags =\n pp_set_mark_tags std_formatter\nand get_mark_tags =\n pp_get_mark_tags std_formatter\nand set_tags =\n pp_set_tags std_formatter\n\n\n(* Convenience functions *)\n\n(* To format a list *)\nlet rec pp_print_list ?(pp_sep = pp_print_cut) pp_v ppf = function\n | [] -> ()\n | [v] -> pp_v ppf v\n | v :: vs ->\n pp_v ppf v;\n pp_sep ppf ();\n pp_print_list ~pp_sep pp_v ppf vs\n\n(* To format a sequence *)\nlet rec pp_print_seq_in ~pp_sep pp_v ppf seq =\n match seq () with\n | Seq.Nil -> ()\n | Seq.Cons (v, seq) ->\n pp_sep ppf ();\n pp_v ppf v;\n pp_print_seq_in ~pp_sep pp_v ppf seq\n\nlet pp_print_seq ?(pp_sep = pp_print_cut) pp_v ppf seq =\n match seq () with\n | Seq.Nil -> ()\n | Seq.Cons (v, seq) ->\n pp_v ppf v;\n pp_print_seq_in ~pp_sep pp_v ppf seq\n\n(* To format free-flowing text *)\nlet pp_print_text ppf s =\n let len = String.length s in\n let left = ref 0 in\n let right = ref 0 in\n let flush () =\n pp_print_string ppf (String.sub s !left (!right - !left));\n incr right; left := !right;\n in\n while (!right <> len) do\n match s.[!right] with\n | '\\n' ->\n flush ();\n pp_force_newline ppf ()\n | ' ' ->\n flush (); pp_print_space ppf ()\n (* there is no specific support for '\\t'\n as it is unclear what a right semantics would be *)\n | _ -> incr right\n done;\n if !left <> len then flush ()\n\nlet pp_print_option ?(none = fun _ () -> ()) pp_v ppf = function\n| None -> none ppf ()\n| Some v -> pp_v ppf v\n\nlet pp_print_result ~ok ~error ppf = function\n| Ok v -> ok ppf v\n| Error e -> error ppf e\n\nlet pp_print_either ~left ~right ppf = function\n| Either.Left l -> left ppf l\n| Either.Right r -> right ppf r\n\n (**************************************************************)\n\nlet compute_tag output tag_acc =\n let buf = Buffer.create 16 in\n let ppf = formatter_of_buffer buf in\n output ppf tag_acc;\n pp_print_flush ppf ();\n let len = Buffer.length buf in\n if len < 2 then Buffer.contents buf\n else Buffer.sub buf 1 (len - 2)\n\n (**************************************************************\n\n Defining continuations to be passed as arguments of\n CamlinternalFormat.make_printf.\n\n **************************************************************)\n\nopen CamlinternalFormatBasics\nopen CamlinternalFormat\n\n(* Interpret a formatting entity on a formatter. *)\nlet output_formatting_lit ppf fmting_lit = match fmting_lit with\n | Close_box -> pp_close_box ppf ()\n | Close_tag -> pp_close_tag ppf ()\n | Break (_, width, offset) -> pp_print_break ppf width offset\n | FFlush -> pp_print_flush ppf ()\n | Force_newline -> pp_force_newline ppf ()\n | Flush_newline -> pp_print_newline ppf ()\n | Magic_size (_, _) -> ()\n | Escaped_at -> pp_print_char ppf '@'\n | Escaped_percent -> pp_print_char ppf '%'\n | Scan_indic c -> pp_print_char ppf '@'; pp_print_char ppf c\n\n(* Recursively output an \"accumulator\" containing a reversed list of\n printing entities (string, char, flus, ...) in an output_stream. *)\n(* Differ from Printf.output_acc by the interpretation of formatting. *)\n(* Used as a continuation of CamlinternalFormat.make_printf. *)\nlet rec output_acc ppf acc = match acc with\n | Acc_string_literal (Acc_formatting_lit (p, Magic_size (_, size)), s)\n | Acc_data_string (Acc_formatting_lit (p, Magic_size (_, size)), s) ->\n output_acc ppf p;\n pp_print_as_size ppf (Size.of_int size) s;\n | Acc_char_literal (Acc_formatting_lit (p, Magic_size (_, size)), c)\n | Acc_data_char (Acc_formatting_lit (p, Magic_size (_, size)), c) ->\n output_acc ppf p;\n pp_print_as_size ppf (Size.of_int size) (String.make 1 c);\n | Acc_formatting_lit (p, f) ->\n output_acc ppf p;\n output_formatting_lit ppf f;\n | Acc_formatting_gen (p, Acc_open_tag acc') ->\n output_acc ppf p;\n pp_open_stag ppf (String_tag (compute_tag output_acc acc'))\n | Acc_formatting_gen (p, Acc_open_box acc') ->\n output_acc ppf p;\n let (indent, bty) = open_box_of_string (compute_tag output_acc acc') in\n pp_open_box_gen ppf indent bty\n | Acc_string_literal (p, s)\n | Acc_data_string (p, s) -> output_acc ppf p; pp_print_string ppf s;\n | Acc_char_literal (p, c)\n | Acc_data_char (p, c) -> output_acc ppf p; pp_print_char ppf c;\n | Acc_delay (p, f) -> output_acc ppf p; f ppf;\n | Acc_flush p -> output_acc ppf p; pp_print_flush ppf ();\n | Acc_invalid_arg (p, msg) -> output_acc ppf p; invalid_arg msg;\n | End_of_acc -> ()\n\n(* Recursively output an \"accumulator\" containing a reversed list of\n printing entities (string, char, flus, ...) in a buffer. *)\n(* Differ from Printf.bufput_acc by the interpretation of formatting. *)\n(* Used as a continuation of CamlinternalFormat.make_printf. *)\nlet rec strput_acc ppf acc = match acc with\n | Acc_string_literal (Acc_formatting_lit (p, Magic_size (_, size)), s)\n | Acc_data_string (Acc_formatting_lit (p, Magic_size (_, size)), s) ->\n strput_acc ppf p;\n pp_print_as_size ppf (Size.of_int size) s;\n | Acc_char_literal (Acc_formatting_lit (p, Magic_size (_, size)), c)\n | Acc_data_char (Acc_formatting_lit (p, Magic_size (_, size)), c) ->\n strput_acc ppf p;\n pp_print_as_size ppf (Size.of_int size) (String.make 1 c);\n | Acc_delay (Acc_formatting_lit (p, Magic_size (_, size)), f) ->\n strput_acc ppf p;\n pp_print_as_size ppf (Size.of_int size) (f ());\n | Acc_formatting_lit (p, f) ->\n strput_acc ppf p;\n output_formatting_lit ppf f;\n | Acc_formatting_gen (p, Acc_open_tag acc') ->\n strput_acc ppf p;\n pp_open_stag ppf (String_tag (compute_tag strput_acc acc'))\n | Acc_formatting_gen (p, Acc_open_box acc') ->\n strput_acc ppf p;\n let (indent, bty) = open_box_of_string (compute_tag strput_acc acc') in\n pp_open_box_gen ppf indent bty\n | Acc_string_literal (p, s)\n | Acc_data_string (p, s) -> strput_acc ppf p; pp_print_string ppf s;\n | Acc_char_literal (p, c)\n | Acc_data_char (p, c) -> strput_acc ppf p; pp_print_char ppf c;\n | Acc_delay (p, f) -> strput_acc ppf p; pp_print_string ppf (f ());\n | Acc_flush p -> strput_acc ppf p; pp_print_flush ppf ();\n | Acc_invalid_arg (p, msg) -> strput_acc ppf p; invalid_arg msg;\n | End_of_acc -> ()\n\n(*\n\n Defining [fprintf] and various flavors of [fprintf].\n\n*)\n\nlet kfprintf k ppf (Format (fmt, _)) =\n make_printf\n (fun acc -> output_acc ppf acc; k ppf)\n End_of_acc fmt\n\nand ikfprintf k ppf (Format (fmt, _)) =\n make_iprintf k ppf fmt\n\nlet ifprintf _ppf (Format (fmt, _)) =\n make_iprintf ignore () fmt\n\nlet fprintf ppf = kfprintf ignore ppf\nlet printf fmt = fprintf std_formatter fmt\nlet eprintf fmt = fprintf err_formatter fmt\n\nlet kdprintf k (Format (fmt, _)) =\n make_printf\n (fun acc -> k (fun ppf -> output_acc ppf acc))\n End_of_acc fmt\n\nlet dprintf fmt = kdprintf (fun i -> i) fmt\n\nlet ksprintf k (Format (fmt, _)) =\n let b = pp_make_buffer () in\n let ppf = formatter_of_buffer b in\n let k acc =\n strput_acc ppf acc;\n k (flush_buffer_formatter b ppf) in\n make_printf k End_of_acc fmt\n\n\nlet sprintf fmt = ksprintf id fmt\n\nlet kasprintf k (Format (fmt, _)) =\n let b = pp_make_buffer () in\n let ppf = formatter_of_buffer b in\n let k acc =\n output_acc ppf acc;\n k (flush_buffer_formatter b ppf) in\n make_printf k End_of_acc fmt\n\n\nlet asprintf fmt = kasprintf id fmt\n\n(* Flushing standard formatters at end of execution. *)\n\nlet flush_standard_formatters () =\n pp_print_flush std_formatter ();\n pp_print_flush err_formatter ()\n\nlet () = at_exit flush_standard_formatters\n\n(*\n\n Deprecated stuff.\n\n*)\n\n(* Deprecated : subsumed by pp_set_formatter_out_functions *)\nlet pp_set_all_formatter_output_functions state\n ~out:f ~flush:g ~newline:h ~spaces:i =\n pp_set_formatter_output_functions state f g;\n state.pp_out_newline <- h;\n state.pp_out_spaces <- i\n\n(* Deprecated : subsumed by pp_get_formatter_out_functions *)\nlet pp_get_all_formatter_output_functions state () =\n (state.pp_out_string, state.pp_out_flush,\n state.pp_out_newline, state.pp_out_spaces)\n\n\n(* Deprecated : subsumed by set_formatter_out_functions *)\nlet set_all_formatter_output_functions =\n pp_set_all_formatter_output_functions std_formatter\n\n\n(* Deprecated : subsumed by get_formatter_out_functions *)\nlet get_all_formatter_output_functions =\n pp_get_all_formatter_output_functions std_formatter\n\n\n(* Deprecated : error prone function, do not use it.\n This function is neither compositional nor incremental, since it flushes\n the pretty-printer queue at each call.\n To get the same functionality, define a formatter of your own writing to\n the buffer argument, as in\n let ppf = formatter_of_buffer b\n then use {!fprintf ppf} as usual. *)\nlet bprintf b (Format (fmt, _) : ('a, formatter, unit) format) =\n let ppf = formatter_of_buffer b in\n let k acc = output_acc ppf acc; pp_flush_queue ppf false in\n make_printf k End_of_acc fmt\n\n\n(* Deprecated : alias for ksprintf. *)\nlet kprintf = ksprintf\n\n\n\n(* Deprecated tag functions *)\n\ntype formatter_tag_functions = {\n mark_open_tag : tag -> string;\n mark_close_tag : tag -> string;\n print_open_tag : tag -> unit;\n print_close_tag : tag -> unit;\n}\n\n\nlet pp_set_formatter_tag_functions state {\n mark_open_tag = mot;\n mark_close_tag = mct;\n print_open_tag = pot;\n print_close_tag = pct;\n } =\n let stringify f e = function String_tag s -> f s | _ -> e in\n state.pp_mark_open_tag <- stringify mot \"\";\n state.pp_mark_close_tag <- stringify mct \"\";\n state.pp_print_open_tag <- stringify pot ();\n state.pp_print_close_tag <- stringify pct ()\n\nlet pp_get_formatter_tag_functions fmt () =\n let funs = pp_get_formatter_stag_functions fmt () in\n let mark_open_tag s = funs.mark_open_stag (String_tag s) in\n let mark_close_tag s = funs.mark_close_stag (String_tag s) in\n let print_open_tag s = funs.print_open_stag (String_tag s) in\n let print_close_tag s = funs.print_close_stag (String_tag s) in\n {mark_open_tag; mark_close_tag; print_open_tag; print_close_tag}\n\nlet set_formatter_tag_functions =\n pp_set_formatter_tag_functions std_formatter\nand get_formatter_tag_functions =\n pp_get_formatter_tag_functions std_formatter\n","(** Very small tooling for format printers. *)\n\ninclude Format\n\ntype 'a t = Format.formatter -> 'a -> unit\n\n(* Only in the stdlib since 4.02, so we copy. *)\nlet rec list ?(pp_sep = pp_print_cut) pp ppf = function\n | [] -> ()\n | [v] -> pp ppf v\n | v :: vs ->\n pp ppf v;\n pp_sep ppf ();\n list ~pp_sep pp ppf vs\n\n(* want this name to make sure we don't use pp_print_list from stdlib\n accidentally *)\nlet pp_print_list = list\n\nlet str = pp_print_string\nlet sexp fmt s pp x = fprintf fmt \"@[<3>(%s@ %a)@]\" s pp x\nlet pair pp1 pp2 fmt (v1,v2) =\n pp1 fmt v1; pp_print_space fmt () ; pp2 fmt v2\nlet triple pp1 pp2 pp3 fmt (v1, v2, v3) =\n pp1 fmt v1; pp_print_space fmt () ;\n pp2 fmt v2; pp_print_space fmt () ;\n pp3 fmt v3\nlet int = pp_print_int\nlet optint fmt = function\n | None -> ()\n | Some i -> fprintf fmt \"@ %d\" i\n\nlet quote fmt s = Format.fprintf fmt \"\\\"%s\\\"\" s\n\nlet pp_olist pp_elem fmt =\n Format.fprintf fmt \"@[<3>[@ %a@ ]@]\"\n (pp_print_list\n ~pp_sep:(fun fmt () -> fprintf fmt \";@ \")\n pp_elem)\n\nlet pp_str_list = pp_olist quote\n\nlet to_to_string pp x =\n let b = Buffer.create 16 in\n let fmt = Format.formatter_of_buffer b in\n pp fmt x;\n Buffer.contents b\n","\nmodule Pmark = struct\n type t = int\n let equal (x : int) (y : int) = x = y\n let compare (x : int) (y : int) = compare x y\n let r = ref 0\n let gen () = incr r ; !r\n\n let pp = Format.pp_print_int\nend\n\ninclude Pmark\nmodule Set = Set.Make(Pmark)\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Pierre Weis, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 2002 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nopen CamlinternalFormatBasics\nopen CamlinternalFormat\n\n(* alias to avoid warning for ambiguity between\n Stdlib.format6\n and CamlinternalFormatBasics.format6\n\n (the former is in fact an alias for the latter,\n but the ambiguity warning doesn't care)\n*)\ntype ('a, 'b, 'c, 'd, 'e, 'f) format6 =\n ('a, 'b, 'c, 'd, 'e, 'f) Stdlib.format6\n\n\n(* The run-time library for scanners. *)\n\n(* Scanning buffers. *)\nmodule type SCANNING = sig\n\n type in_channel\n\n type scanbuf = in_channel\n\n type file_name = string\n\n val stdin : in_channel\n (* The scanning buffer reading from [Stdlib.stdin].\n [stdib] is equivalent to [Scanning.from_channel Stdlib.stdin]. *)\n\n val stdib : in_channel\n (* An alias for [Scanf.stdin], the scanning buffer reading from\n [Stdlib.stdin]. *)\n\n val next_char : scanbuf -> char\n (* [Scanning.next_char ib] advance the scanning buffer for\n one character.\n If no more character can be read, sets a end of file condition and\n returns '\\000'. *)\n\n val invalidate_current_char : scanbuf -> unit\n (* [Scanning.invalidate_current_char ib] mark the current_char as already\n scanned. *)\n\n val peek_char : scanbuf -> char\n (* [Scanning.peek_char ib] returns the current char available in\n the buffer or reads one if necessary (when the current character is\n already scanned).\n If no character can be read, sets an end of file condition and\n returns '\\000'. *)\n\n val checked_peek_char : scanbuf -> char\n (* Same as [Scanning.peek_char] above but always returns a valid char or\n fails: instead of returning a null char when the reading method of the\n input buffer has reached an end of file, the function raises exception\n [End_of_file]. *)\n\n val store_char : int -> scanbuf -> char -> int\n (* [Scanning.store_char lim ib c] adds [c] to the token buffer\n of the scanning buffer [ib]. It also advances the scanning buffer for\n one character and returns [lim - 1], indicating the new limit for the\n length of the current token. *)\n\n val skip_char : int -> scanbuf -> int\n (* [Scanning.skip_char lim ib] ignores the current character. *)\n\n val ignore_char : int -> scanbuf -> int\n (* [Scanning.ignore_char ib lim] ignores the current character and\n decrements the limit. *)\n\n val token : scanbuf -> string\n (* [Scanning.token ib] returns the string stored into the token\n buffer of the scanning buffer: it returns the token matched by the\n format. *)\n\n val reset_token : scanbuf -> unit\n (* [Scanning.reset_token ib] resets the token buffer of\n the given scanning buffer. *)\n\n val char_count : scanbuf -> int\n (* [Scanning.char_count ib] returns the number of characters\n read so far from the given buffer. *)\n\n val line_count : scanbuf -> int\n (* [Scanning.line_count ib] returns the number of new line\n characters read so far from the given buffer. *)\n\n val token_count : scanbuf -> int\n (* [Scanning.token_count ib] returns the number of tokens read\n so far from [ib]. *)\n\n val eof : scanbuf -> bool\n (* [Scanning.eof ib] returns the end of input condition\n of the given buffer. *)\n\n val end_of_input : scanbuf -> bool\n (* [Scanning.end_of_input ib] tests the end of input condition\n of the given buffer (if no char has ever been read, an attempt to\n read one is performed). *)\n\n val beginning_of_input : scanbuf -> bool\n (* [Scanning.beginning_of_input ib] tests the beginning of input\n condition of the given buffer. *)\n\n val name_of_input : scanbuf -> string\n (* [Scanning.name_of_input ib] returns the name of the character\n source for input buffer [ib]. *)\n\n val open_in : file_name -> in_channel\n val open_in_bin : file_name -> in_channel\n val from_file : file_name -> in_channel\n val from_file_bin : file_name -> in_channel\n val from_string : string -> in_channel\n val from_function : (unit -> char) -> in_channel\n val from_channel : Stdlib.in_channel -> in_channel\n\n val close_in : in_channel -> unit\n\n val memo_from_channel : Stdlib.in_channel -> in_channel\n (* Obsolete. *)\n\nend\n\n\nmodule Scanning : SCANNING = struct\n\n (* The run-time library for scanf. *)\n\n type file_name = string\n\n type in_channel_name =\n | From_channel of Stdlib.in_channel\n | From_file of file_name * Stdlib.in_channel\n | From_function\n | From_string\n\n\n type in_channel = {\n mutable ic_eof : bool;\n mutable ic_current_char : char;\n mutable ic_current_char_is_valid : bool;\n mutable ic_char_count : int;\n mutable ic_line_count : int;\n mutable ic_token_count : int;\n ic_get_next_char : unit -> char;\n ic_token_buffer : Buffer.t;\n ic_input_name : in_channel_name;\n }\n\n\n type scanbuf = in_channel\n\n let null_char = '\\000'\n\n (* Reads a new character from input buffer.\n Next_char never fails, even in case of end of input:\n it then simply sets the end of file condition. *)\n let next_char ib =\n try\n let c = ib.ic_get_next_char () in\n ib.ic_current_char <- c;\n ib.ic_current_char_is_valid <- true;\n ib.ic_char_count <- succ ib.ic_char_count;\n if c = '\\n' then ib.ic_line_count <- succ ib.ic_line_count;\n c with\n | End_of_file ->\n let c = null_char in\n ib.ic_current_char <- c;\n ib.ic_current_char_is_valid <- false;\n ib.ic_eof <- true;\n c\n\n\n let peek_char ib =\n if ib.ic_current_char_is_valid\n then ib.ic_current_char\n else next_char ib\n\n\n (* Returns a valid current char for the input buffer. In particular\n no irrelevant null character (as set by [next_char] in case of end\n of input) is returned, since [End_of_file] is raised when\n [next_char] sets the end of file condition while trying to read a\n new character. *)\n let checked_peek_char ib =\n let c = peek_char ib in\n if ib.ic_eof then raise End_of_file;\n c\n\n\n let end_of_input ib =\n ignore (peek_char ib);\n ib.ic_eof\n\n\n let eof ib = ib.ic_eof\n\n let beginning_of_input ib = ib.ic_char_count = 0\n\n let name_of_input ib =\n match ib.ic_input_name with\n | From_channel _ic -> \"unnamed Stdlib input channel\"\n | From_file (fname, _ic) -> fname\n | From_function -> \"unnamed function\"\n | From_string -> \"unnamed character string\"\n\n\n let char_count ib =\n if ib.ic_current_char_is_valid\n then ib.ic_char_count - 1\n else ib.ic_char_count\n\n\n let line_count ib = ib.ic_line_count\n\n let reset_token ib = Buffer.reset ib.ic_token_buffer\n\n let invalidate_current_char ib = ib.ic_current_char_is_valid <- false\n\n let token ib =\n let token_buffer = ib.ic_token_buffer in\n let tok = Buffer.contents token_buffer in\n Buffer.clear token_buffer;\n ib.ic_token_count <- succ ib.ic_token_count;\n tok\n\n\n let token_count ib = ib.ic_token_count\n\n let skip_char width ib =\n invalidate_current_char ib;\n width\n\n\n let ignore_char width ib = skip_char (width - 1) ib\n\n let store_char width ib c =\n Buffer.add_char ib.ic_token_buffer c;\n ignore_char width ib\n\n\n let default_token_buffer_size = 1024\n\n let create iname next = {\n ic_eof = false;\n ic_current_char = null_char;\n ic_current_char_is_valid = false;\n ic_char_count = 0;\n ic_line_count = 0;\n ic_token_count = 0;\n ic_get_next_char = next;\n ic_token_buffer = Buffer.create default_token_buffer_size;\n ic_input_name = iname;\n }\n\n\n let from_string s =\n let i = ref 0 in\n let len = String.length s in\n let next () =\n if !i >= len then raise End_of_file else\n let c = s.[!i] in\n incr i;\n c in\n create From_string next\n\n\n let from_function = create From_function\n\n (* Scanning from an input channel. *)\n\n (* Position of the problem:\n\n We cannot prevent the scanning mechanism to use one lookahead character,\n if needed by the semantics of the format string specifications (e.g. a\n trailing 'skip space' specification in the format string); in this case,\n the mandatory lookahead character is indeed read from the input and not\n used to return the token read. It is thus mandatory to be able to store\n an unused lookahead character somewhere to get it as the first character\n of the next scan.\n\n To circumvent this problem, all the scanning functions get a low level\n input buffer argument where they store the lookahead character when\n needed; additionally, the input buffer is the only source of character of\n a scanner. The [scanbuf] input buffers are defined in module {!Scanning}.\n\n Now we understand that it is extremely important that related and\n successive calls to scanners indeed read from the same input buffer.\n In effect, if a scanner [scan1] is reading from [ib1] and stores an\n unused lookahead character [c1] into its input buffer [ib1], then\n another scanner [scan2] not reading from the same buffer [ib1] will miss\n the character [c1], seemingly vanished in the air from the point of view\n of [scan2].\n\n This mechanism works perfectly to read from strings, from files, and from\n functions, since in those cases, allocating two buffers reading from the\n same source is unnatural.\n\n Still, there is a difficulty in the case of scanning from an input\n channel. In effect, when scanning from an input channel [ic], this channel\n may not have been allocated from within this library. Hence, it may be\n shared (two functions of the user's program may successively read from\n [ic]). This is highly error prone since, one of the function may seek the\n input channel, while the other function has still an unused lookahead\n character in its input buffer. In conclusion, you should never mix direct\n low level reading and high level scanning from the same input channel.\n\n *)\n\n (* Perform bufferized input to improve efficiency. *)\n let file_buffer_size = ref 1024\n\n (* The scanner closes the input channel at end of input. *)\n let scan_close_at_end ic = Stdlib.close_in ic; raise End_of_file\n\n (* The scanner does not close the input channel at end of input:\n it just raises [End_of_file]. *)\n let scan_raise_at_end _ic = raise End_of_file\n\n let from_ic scan_close_ic iname ic =\n let len = !file_buffer_size in\n let buf = Bytes.create len in\n let i = ref 0 in\n let lim = ref 0 in\n let eof = ref false in\n let next () =\n if !i < !lim then begin let c = Bytes.get buf !i in incr i; c end else\n if !eof then raise End_of_file else begin\n lim := input ic buf 0 len;\n if !lim = 0 then begin eof := true; scan_close_ic ic end else begin\n i := 1;\n Bytes.get buf 0\n end\n end in\n create iname next\n\n\n let from_ic_close_at_end = from_ic scan_close_at_end\n let from_ic_raise_at_end = from_ic scan_raise_at_end\n\n (* The scanning buffer reading from [Stdlib.stdin].\n One could try to define [stdib] as a scanning buffer reading a character\n at a time (no bufferization at all), but unfortunately the top-level\n interaction would be wrong. This is due to some kind of\n 'race condition' when reading from [Stdlib.stdin],\n since the interactive compiler and [Scanf.scanf] will simultaneously\n read the material they need from [Stdlib.stdin]; then, confusion\n will result from what should be read by the top-level and what should be\n read by [Scanf.scanf].\n This is even more complicated by the one character lookahead that\n [Scanf.scanf] is sometimes obliged to maintain: the lookahead character\n will be available for the next [Scanf.scanf] entry, seemingly coming from\n nowhere.\n Also no [End_of_file] is raised when reading from stdin: if not enough\n characters have been read, we simply ask to read more. *)\n let stdin =\n from_ic scan_raise_at_end\n (From_file (\"-\", Stdlib.stdin)) Stdlib.stdin\n\n\n let stdib = stdin\n\n let open_in_file open_in fname =\n match fname with\n | \"-\" -> stdin\n | fname ->\n let ic = open_in fname in\n from_ic_close_at_end (From_file (fname, ic)) ic\n\n\n let open_in = open_in_file Stdlib.open_in\n let open_in_bin = open_in_file Stdlib.open_in_bin\n\n let from_file = open_in\n let from_file_bin = open_in_bin\n\n let from_channel ic =\n from_ic_raise_at_end (From_channel ic) ic\n\n\n let close_in ib =\n match ib.ic_input_name with\n | From_channel ic ->\n Stdlib.close_in ic\n | From_file (_fname, ic) -> Stdlib.close_in ic\n | From_function | From_string -> ()\n\n\n (*\n Obsolete: a memo [from_channel] version to build a [Scanning.in_channel]\n scanning buffer out of a [Stdlib.in_channel].\n This function was used to try to preserve the scanning\n semantics for the (now obsolete) function [fscanf].\n Given that all scanner must read from a [Scanning.in_channel] scanning\n buffer, [fscanf] must read from one!\n More precisely, given [ic], all successive calls [fscanf ic] must read\n from the same scanning buffer.\n This obliged this library to allocated scanning buffers that were\n not properly garbage collectable, hence leading to memory leaks.\n If you need to read from a [Stdlib.in_channel] input channel\n [ic], simply define a [Scanning.in_channel] formatted input channel as in\n [let ib = Scanning.from_channel ic], then use [Scanf.bscanf ib] as usual.\n *)\n let memo_from_ic =\n let memo = ref [] in\n (fun scan_close_ic ic ->\n try List.assq ic !memo with\n | Not_found ->\n let ib =\n from_ic scan_close_ic (From_channel ic) ic in\n memo := (ic, ib) :: !memo;\n ib)\n\n\n (* Obsolete: see {!memo_from_ic} above. *)\n let memo_from_channel = memo_from_ic scan_raise_at_end\n\nend\n\n\n(* Formatted input functions. *)\n\ntype ('a, 'b, 'c, 'd) scanner =\n ('a, Scanning.in_channel, 'b, 'c, 'a -> 'd, 'd) format6 -> 'c\n\n\n(* Reporting errors. *)\nexception Scan_failure of string\n\nlet bad_input s = raise (Scan_failure s)\n\nlet bad_input_escape c =\n bad_input (Printf.sprintf \"illegal escape character %C\" c)\n\n\nlet bad_token_length message =\n bad_input\n (Printf.sprintf\n \"scanning of %s failed: \\\n the specified length was too short for token\"\n message)\n\n\nlet bad_end_of_input message =\n bad_input\n (Printf.sprintf\n \"scanning of %s failed: \\\n premature end of file occurred before end of token\"\n message)\n\n\nlet bad_float () =\n bad_input \"no dot or exponent part found in float token\"\n\n\nlet bad_hex_float () =\n bad_input \"not a valid float in hexadecimal notation\"\n\n\nlet character_mismatch_err c ci =\n Printf.sprintf \"looking for %C, found %C\" c ci\n\n\nlet character_mismatch c ci =\n bad_input (character_mismatch_err c ci)\n\n\nlet rec skip_whites ib =\n let c = Scanning.peek_char ib in\n if not (Scanning.eof ib) then begin\n match c with\n | ' ' | '\\t' | '\\n' | '\\r' ->\n Scanning.invalidate_current_char ib; skip_whites ib\n | _ -> ()\n end\n\n\n(* Checking that [c] is indeed in the input, then skips it.\n In this case, the character [c] has been explicitly specified in the\n format as being mandatory in the input; hence we should fail with\n [End_of_file] in case of end_of_input.\n (Remember that [Scan_failure] is raised only when (we can prove by\n evidence) that the input does not match the format string given. We must\n thus differentiate [End_of_file] as an error due to lack of input, and\n [Scan_failure] which is due to provably wrong input. I am not sure this is\n worth the burden: it is complex and somehow subliminal; should be clearer\n to fail with Scan_failure \"Not enough input to complete scanning\"!)\n\n That's why, waiting for a better solution, we use checked_peek_char here.\n We are also careful to treat \"\\r\\n\" in the input as an end of line marker:\n it always matches a '\\n' specification in the input format string. *)\nlet rec check_char ib c =\n match c with\n | ' ' -> skip_whites ib\n | '\\n' -> check_newline ib\n | c -> check_this_char ib c\n\nand check_this_char ib c =\n let ci = Scanning.checked_peek_char ib in\n if ci = c then Scanning.invalidate_current_char ib else\n character_mismatch c ci\n\nand check_newline ib =\n let ci = Scanning.checked_peek_char ib in\n match ci with\n | '\\n' -> Scanning.invalidate_current_char ib\n | '\\r' -> Scanning.invalidate_current_char ib; check_this_char ib '\\n'\n | _ -> character_mismatch '\\n' ci\n\n\n(* Extracting tokens from the output token buffer. *)\n\nlet token_char ib = (Scanning.token ib).[0]\n\nlet token_string = Scanning.token\n\nlet token_bool ib =\n match Scanning.token ib with\n | \"true\" -> true\n | \"false\" -> false\n | s -> bad_input (Printf.sprintf \"invalid boolean '%s'\" s)\n\n\n(* The type of integer conversions. *)\ntype integer_conversion =\n | B_conversion (* Unsigned binary conversion *)\n | D_conversion (* Signed decimal conversion *)\n | I_conversion (* Signed integer conversion *)\n | O_conversion (* Unsigned octal conversion *)\n | U_conversion (* Unsigned decimal conversion *)\n | X_conversion (* Unsigned hexadecimal conversion *)\n\n\nlet integer_conversion_of_char = function\n | 'b' -> B_conversion\n | 'd' -> D_conversion\n | 'i' -> I_conversion\n | 'o' -> O_conversion\n | 'u' -> U_conversion\n | 'x' | 'X' -> X_conversion\n | _ -> assert false\n\n\n(* Extract an integer literal token.\n Since the functions Stdlib.*int*_of_string do not accept a leading +,\n we skip it if necessary. *)\nlet token_int_literal conv ib =\n let tok =\n match conv with\n | D_conversion | I_conversion -> Scanning.token ib\n | U_conversion -> \"0u\" ^ Scanning.token ib\n | O_conversion -> \"0o\" ^ Scanning.token ib\n | X_conversion -> \"0x\" ^ Scanning.token ib\n | B_conversion -> \"0b\" ^ Scanning.token ib in\n let l = String.length tok in\n if l = 0 || tok.[0] <> '+' then tok else String.sub tok 1 (l - 1)\n\n\n(* All the functions that convert a string to a number raise the exception\n Failure when the conversion is not possible.\n This exception is then trapped in [kscanf]. *)\nlet token_int conv ib = int_of_string (token_int_literal conv ib)\n\nlet token_float ib = float_of_string (Scanning.token ib)\n\n(* To scan native ints, int32 and int64 integers.\n We cannot access to conversions to/from strings for those types,\n Nativeint.of_string, Int32.of_string, and Int64.of_string,\n since those modules are not available to [Scanf].\n However, we can bind and use the corresponding primitives that are\n available in the runtime. *)\nexternal nativeint_of_string : string -> nativeint\n = \"caml_nativeint_of_string\"\n\nexternal int32_of_string : string -> int32\n = \"caml_int32_of_string\"\n\nexternal int64_of_string : string -> int64\n = \"caml_int64_of_string\"\n\n\nlet token_nativeint conv ib = nativeint_of_string (token_int_literal conv ib)\nlet token_int32 conv ib = int32_of_string (token_int_literal conv ib)\nlet token_int64 conv ib = int64_of_string (token_int_literal conv ib)\n\n(* Scanning numbers. *)\n\n(* Digits scanning functions suppose that one character has been checked and\n is available, since they return at end of file with the currently found\n token selected.\n\n Put it in another way, the digits scanning functions scan for a possibly\n empty sequence of digits, (hence, a successful scanning from one of those\n functions does not imply that the token is a well-formed number: to get a\n true number, it is mandatory to check that at least one valid digit is\n available before calling one of the digit scanning functions). *)\n\n(* The decimal case is treated especially for optimization purposes. *)\nlet rec scan_decimal_digit_star width ib =\n if width = 0 then width else\n let c = Scanning.peek_char ib in\n if Scanning.eof ib then width else\n match c with\n | '0' .. '9' as c ->\n let width = Scanning.store_char width ib c in\n scan_decimal_digit_star width ib\n | '_' ->\n let width = Scanning.ignore_char width ib in\n scan_decimal_digit_star width ib\n | _ -> width\n\n\nlet scan_decimal_digit_plus width ib =\n if width = 0 then bad_token_length \"decimal digits\" else\n let c = Scanning.checked_peek_char ib in\n match c with\n | '0' .. '9' ->\n let width = Scanning.store_char width ib c in\n scan_decimal_digit_star width ib\n | c ->\n bad_input (Printf.sprintf \"character %C is not a decimal digit\" c)\n\n\n(* To scan numbers from other bases, we use a predicate argument to\n scan digits. *)\nlet scan_digit_star digitp width ib =\n let rec scan_digits width ib =\n if width = 0 then width else\n let c = Scanning.peek_char ib in\n if Scanning.eof ib then width else\n match c with\n | c when digitp c ->\n let width = Scanning.store_char width ib c in\n scan_digits width ib\n | '_' ->\n let width = Scanning.ignore_char width ib in\n scan_digits width ib\n | _ -> width in\n scan_digits width ib\n\n\nlet scan_digit_plus basis digitp width ib =\n (* Ensure we have got enough width left,\n and read at least one digit. *)\n if width = 0 then bad_token_length \"digits\" else\n let c = Scanning.checked_peek_char ib in\n if digitp c then\n let width = Scanning.store_char width ib c in\n scan_digit_star digitp width ib\n else\n bad_input (Printf.sprintf \"character %C is not a valid %s digit\" c basis)\n\n\nlet is_binary_digit = function\n | '0' .. '1' -> true\n | _ -> false\n\n\nlet scan_binary_int = scan_digit_plus \"binary\" is_binary_digit\n\nlet is_octal_digit = function\n | '0' .. '7' -> true\n | _ -> false\n\n\nlet scan_octal_int = scan_digit_plus \"octal\" is_octal_digit\n\nlet is_hexa_digit = function\n | '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' -> true\n | _ -> false\n\n\nlet scan_hexadecimal_int = scan_digit_plus \"hexadecimal\" is_hexa_digit\n\n(* Scan a decimal integer. *)\nlet scan_unsigned_decimal_int = scan_decimal_digit_plus\n\nlet scan_sign width ib =\n let c = Scanning.checked_peek_char ib in\n match c with\n | '+' -> Scanning.store_char width ib c\n | '-' -> Scanning.store_char width ib c\n | _ -> width\n\n\nlet scan_optionally_signed_decimal_int width ib =\n let width = scan_sign width ib in\n scan_unsigned_decimal_int width ib\n\n\n(* Scan an unsigned integer that could be given in any (common) basis.\n If digits are prefixed by one of 0x, 0X, 0o, or 0b, the number is\n assumed to be written respectively in hexadecimal, hexadecimal,\n octal, or binary. *)\nlet scan_unsigned_int width ib =\n match Scanning.checked_peek_char ib with\n | '0' as c ->\n let width = Scanning.store_char width ib c in\n if width = 0 then width else\n let c = Scanning.peek_char ib in\n if Scanning.eof ib then width else\n begin match c with\n | 'x' | 'X' -> scan_hexadecimal_int (Scanning.store_char width ib c) ib\n | 'o' -> scan_octal_int (Scanning.store_char width ib c) ib\n | 'b' -> scan_binary_int (Scanning.store_char width ib c) ib\n | _ -> scan_decimal_digit_star width ib end\n | _ -> scan_unsigned_decimal_int width ib\n\n\nlet scan_optionally_signed_int width ib =\n let width = scan_sign width ib in\n scan_unsigned_int width ib\n\n\nlet scan_int_conversion conv width ib =\n match conv with\n | B_conversion -> scan_binary_int width ib\n | D_conversion -> scan_optionally_signed_decimal_int width ib\n | I_conversion -> scan_optionally_signed_int width ib\n | O_conversion -> scan_octal_int width ib\n | U_conversion -> scan_unsigned_decimal_int width ib\n | X_conversion -> scan_hexadecimal_int width ib\n\n\n(* Scanning floating point numbers. *)\n\n(* Fractional part is optional and can be reduced to 0 digits. *)\nlet scan_fractional_part width ib =\n if width = 0 then width else\n let c = Scanning.peek_char ib in\n if Scanning.eof ib then width else\n match c with\n | '0' .. '9' as c ->\n scan_decimal_digit_star (Scanning.store_char width ib c) ib\n | _ -> width\n\n\n(* Exp part is optional and can be reduced to 0 digits. *)\nlet scan_exponent_part width ib =\n if width = 0 then width else\n let c = Scanning.peek_char ib in\n if Scanning.eof ib then width else\n match c with\n | 'e' | 'E' as c ->\n scan_optionally_signed_decimal_int (Scanning.store_char width ib c) ib\n | _ -> width\n\n\n(* Scan the integer part of a floating point number, (not using the\n OCaml lexical convention since the integer part can be empty):\n an optional sign, followed by a possibly empty sequence of decimal\n digits (e.g. -.1). *)\nlet scan_integer_part width ib =\n let width = scan_sign width ib in\n scan_decimal_digit_star width ib\n\n\n(*\n For the time being we have (as found in scanf.mli):\n the field width is composed of an optional integer literal\n indicating the maximal width of the token to read.\n Unfortunately, the type-checker let the user write an optional precision,\n since this is valid for printf format strings.\n\n Thus, the next step for Scanf is to support a full width and precision\n indication, more or less similar to the one for printf, possibly extended\n to the specification of a [max, min] range for the width of the token read\n for strings. Something like the following spec for scanf.mli:\n\n The optional [width] is an integer indicating the maximal\n width of the token read. For instance, [%6d] reads an integer,\n having at most 6 characters.\n\n The optional [precision] is a dot [.] followed by an integer:\n\n - in the floating point number conversions ([%f], [%e], [%g], [%F], [%E],\n and [%F] conversions, the [precision] indicates the maximum number of\n digits that may follow the decimal point. For instance, [%.4f] reads a\n [float] with at most 4 fractional digits,\n\n - in the string conversions ([%s], [%S], [%\\[ range \\]]), and in the\n integer number conversions ([%i], [%d], [%u], [%x], [%o], and their\n [int32], [int64], and [native_int] correspondent), the [precision]\n indicates the required minimum width of the token read,\n\n - on all other conversions, the width and precision specify the [max, min]\n range for the width of the token read.\n*)\nlet scan_float width precision ib =\n let width = scan_integer_part width ib in\n if width = 0 then width, precision else\n let c = Scanning.peek_char ib in\n if Scanning.eof ib then width, precision else\n match c with\n | '.' ->\n let width = Scanning.store_char width ib c in\n let precision = Int.min width precision in\n let width = width - (precision - scan_fractional_part precision ib) in\n scan_exponent_part width ib, precision\n | _ ->\n scan_exponent_part width ib, precision\n\n\nlet check_case_insensitive_string width ib error str =\n let lowercase c =\n match c with\n | 'A' .. 'Z' ->\n char_of_int (int_of_char c - int_of_char 'A' + int_of_char 'a')\n | _ -> c in\n let len = String.length str in\n let width = ref width in\n for i = 0 to len - 1 do\n let c = Scanning.peek_char ib in\n if lowercase c <> lowercase str.[i] then error ();\n if !width = 0 then error ();\n width := Scanning.store_char !width ib c;\n done;\n !width\n\n\nlet scan_hex_float width precision ib =\n if width = 0 || Scanning.end_of_input ib then bad_hex_float ();\n let width = scan_sign width ib in\n if width = 0 || Scanning.end_of_input ib then bad_hex_float ();\n match Scanning.peek_char ib with\n | '0' as c -> (\n let width = Scanning.store_char width ib c in\n if width = 0 || Scanning.end_of_input ib then bad_hex_float ();\n let width = check_case_insensitive_string width ib bad_hex_float \"x\" in\n if width = 0 || Scanning.end_of_input ib then width else\n let width = match Scanning.peek_char ib with\n | '.' | 'p' | 'P' -> width\n | _ -> scan_hexadecimal_int width ib in\n if width = 0 || Scanning.end_of_input ib then width else\n let width = match Scanning.peek_char ib with\n | '.' as c -> (\n let width = Scanning.store_char width ib c in\n if width = 0 || Scanning.end_of_input ib then width else\n match Scanning.peek_char ib with\n | 'p' | 'P' -> width\n | _ ->\n let precision = Int.min width precision in\n width - (precision - scan_hexadecimal_int precision ib)\n )\n | _ -> width in\n if width = 0 || Scanning.end_of_input ib then width else\n match Scanning.peek_char ib with\n | 'p' | 'P' as c ->\n let width = Scanning.store_char width ib c in\n if width = 0 || Scanning.end_of_input ib then bad_hex_float ();\n scan_optionally_signed_decimal_int width ib\n | _ -> width\n )\n | 'n' | 'N' as c ->\n let width = Scanning.store_char width ib c in\n if width = 0 || Scanning.end_of_input ib then bad_hex_float ();\n check_case_insensitive_string width ib bad_hex_float \"an\"\n | 'i' | 'I' as c ->\n let width = Scanning.store_char width ib c in\n if width = 0 || Scanning.end_of_input ib then bad_hex_float ();\n check_case_insensitive_string width ib bad_hex_float \"nfinity\"\n | _ -> bad_hex_float ()\n\n\nlet scan_caml_float_rest width precision ib =\n if width = 0 || Scanning.end_of_input ib then bad_float ();\n let width = scan_decimal_digit_star width ib in\n if width = 0 || Scanning.end_of_input ib then bad_float ();\n let c = Scanning.peek_char ib in\n match c with\n | '.' ->\n let width = Scanning.store_char width ib c in\n (* The effective width available for scanning the fractional part is\n the minimum of declared precision and width left. *)\n let precision = Int.min width precision in\n (* After scanning the fractional part with [precision] provisional width,\n [width_precision] is left. *)\n let width_precision = scan_fractional_part precision ib in\n (* Hence, scanning the fractional part took exactly\n [precision - width_precision] chars. *)\n let frac_width = precision - width_precision in\n (* And new provisional width is [width - width_precision. *)\n let width = width - frac_width in\n scan_exponent_part width ib\n | 'e' | 'E' ->\n scan_exponent_part width ib\n | _ -> bad_float ()\n\n\nlet scan_caml_float width precision ib =\n if width = 0 || Scanning.end_of_input ib then bad_float ();\n let width = scan_sign width ib in\n if width = 0 || Scanning.end_of_input ib then bad_float ();\n match Scanning.peek_char ib with\n | '0' as c -> (\n let width = Scanning.store_char width ib c in\n if width = 0 || Scanning.end_of_input ib then bad_float ();\n match Scanning.peek_char ib with\n | 'x' | 'X' as c -> (\n let width = Scanning.store_char width ib c in\n if width = 0 || Scanning.end_of_input ib then bad_float ();\n let width = scan_hexadecimal_int width ib in\n if width = 0 || Scanning.end_of_input ib then bad_float ();\n let width = match Scanning.peek_char ib with\n | '.' as c -> (\n let width = Scanning.store_char width ib c in\n if width = 0 || Scanning.end_of_input ib then width else\n match Scanning.peek_char ib with\n | 'p' | 'P' -> width\n | _ ->\n let precision = Int.min width precision in\n width - (precision - scan_hexadecimal_int precision ib)\n )\n | 'p' | 'P' -> width\n | _ -> bad_float () in\n if width = 0 || Scanning.end_of_input ib then width else\n match Scanning.peek_char ib with\n | 'p' | 'P' as c ->\n let width = Scanning.store_char width ib c in\n if width = 0 || Scanning.end_of_input ib then bad_hex_float ();\n scan_optionally_signed_decimal_int width ib\n | _ -> width\n )\n | _ ->\n scan_caml_float_rest width precision ib\n )\n | '1' .. '9' as c ->\n let width = Scanning.store_char width ib c in\n if width = 0 || Scanning.end_of_input ib then bad_float ();\n scan_caml_float_rest width precision ib\n(* Special case of nan and infinity:\n | 'i' ->\n | 'n' ->\n*)\n | _ -> bad_float ()\n\n\n(* Scan a regular string:\n stops when encountering a space, if no scanning indication has been given;\n otherwise, stops when encountering the characters in the scanning\n indication [stp].\n It also stops at end of file or when the maximum number of characters has\n been read. *)\nlet scan_string stp width ib =\n let rec loop width =\n if width = 0 then width else\n let c = Scanning.peek_char ib in\n if Scanning.eof ib then width else\n match stp with\n | Some c' when c = c' -> Scanning.skip_char width ib\n | Some _ -> loop (Scanning.store_char width ib c)\n | None ->\n match c with\n | ' ' | '\\t' | '\\n' | '\\r' -> width\n | _ -> loop (Scanning.store_char width ib c) in\n loop width\n\n\n(* Scan a char: peek strictly one character in the input, whatsoever. *)\nlet scan_char width ib =\n (* The case width = 0 could not happen here, since it is tested before\n calling scan_char, in the main scanning function.\n if width = 0 then bad_token_length \"a character\" else *)\n Scanning.store_char width ib (Scanning.checked_peek_char ib)\n\n\nlet char_for_backslash = function\n | 'n' -> '\\010'\n | 'r' -> '\\013'\n | 'b' -> '\\008'\n | 't' -> '\\009'\n | c -> c\n\n\n(* The integer value corresponding to the facial value of a valid\n decimal digit character. *)\nlet decimal_value_of_char c = int_of_char c - int_of_char '0'\n\nlet char_for_decimal_code c0 c1 c2 =\n let c =\n 100 * decimal_value_of_char c0 +\n 10 * decimal_value_of_char c1 +\n decimal_value_of_char c2 in\n if c < 0 || c > 255 then\n bad_input\n (Printf.sprintf\n \"bad character decimal encoding \\\\%c%c%c\" c0 c1 c2) else\n char_of_int c\n\n\n(* The integer value corresponding to the facial value of a valid\n hexadecimal digit character. *)\nlet hexadecimal_value_of_char c =\n let d = int_of_char c in\n (* Could also be:\n if d <= int_of_char '9' then d - int_of_char '0' else\n if d <= int_of_char 'F' then 10 + d - int_of_char 'A' else\n if d <= int_of_char 'f' then 10 + d - int_of_char 'a' else assert false\n *)\n if d >= int_of_char 'a' then\n d - 87 (* 10 + int_of_char c - int_of_char 'a' *) else\n if d >= int_of_char 'A' then\n d - 55 (* 10 + int_of_char c - int_of_char 'A' *) else\n d - int_of_char '0'\n\n\nlet char_for_hexadecimal_code c1 c2 =\n let c =\n 16 * hexadecimal_value_of_char c1 +\n hexadecimal_value_of_char c2 in\n if c < 0 || c > 255 then\n bad_input\n (Printf.sprintf \"bad character hexadecimal encoding \\\\%c%c\" c1 c2) else\n char_of_int c\n\n\n(* Called in particular when encountering '\\\\' as starter of a char.\n Stops before the corresponding '\\''. *)\nlet check_next_char message width ib =\n if width = 0 then bad_token_length message else\n let c = Scanning.peek_char ib in\n if Scanning.eof ib then bad_end_of_input message else\n c\n\n\nlet check_next_char_for_char = check_next_char \"a Char\"\nlet check_next_char_for_string = check_next_char \"a String\"\n\nlet scan_backslash_char width ib =\n match check_next_char_for_char width ib with\n | '\\\\' | '\\'' | '\\\"' | 'n' | 't' | 'b' | 'r' as c ->\n Scanning.store_char width ib (char_for_backslash c)\n | '0' .. '9' as c ->\n let get_digit () =\n let c = Scanning.next_char ib in\n match c with\n | '0' .. '9' as c -> c\n | c -> bad_input_escape c in\n let c0 = c in\n let c1 = get_digit () in\n let c2 = get_digit () in\n Scanning.store_char (width - 2) ib (char_for_decimal_code c0 c1 c2)\n | 'x' ->\n let get_digit () =\n let c = Scanning.next_char ib in\n match c with\n | '0' .. '9' | 'A' .. 'F' | 'a' .. 'f' as c -> c\n | c -> bad_input_escape c in\n let c1 = get_digit () in\n let c2 = get_digit () in\n Scanning.store_char (width - 2) ib (char_for_hexadecimal_code c1 c2)\n | c ->\n bad_input_escape c\n\n\n(* Scan a character (an OCaml token). *)\nlet scan_caml_char width ib =\n\n let rec find_start width =\n match Scanning.checked_peek_char ib with\n | '\\'' -> find_char (Scanning.ignore_char width ib)\n | c -> character_mismatch '\\'' c\n\n and find_char width =\n match check_next_char_for_char width ib with\n | '\\\\' ->\n find_stop (scan_backslash_char (Scanning.ignore_char width ib) ib)\n | c ->\n find_stop (Scanning.store_char width ib c)\n\n and find_stop width =\n match check_next_char_for_char width ib with\n | '\\'' -> Scanning.ignore_char width ib\n | c -> character_mismatch '\\'' c in\n\n find_start width\n\n\n(* Scan a delimited string (an OCaml token). *)\nlet scan_caml_string width ib =\n\n let rec find_start width =\n match Scanning.checked_peek_char ib with\n | '\\\"' -> find_stop (Scanning.ignore_char width ib)\n | c -> character_mismatch '\\\"' c\n\n and find_stop width =\n match check_next_char_for_string width ib with\n | '\\\"' -> Scanning.ignore_char width ib\n | '\\\\' -> scan_backslash (Scanning.ignore_char width ib)\n | c -> find_stop (Scanning.store_char width ib c)\n\n and scan_backslash width =\n match check_next_char_for_string width ib with\n | '\\r' -> skip_newline (Scanning.ignore_char width ib)\n | '\\n' -> skip_spaces (Scanning.ignore_char width ib)\n | _ -> find_stop (scan_backslash_char width ib)\n\n and skip_newline width =\n match check_next_char_for_string width ib with\n | '\\n' -> skip_spaces (Scanning.ignore_char width ib)\n | _ -> find_stop (Scanning.store_char width ib '\\r')\n\n and skip_spaces width =\n match check_next_char_for_string width ib with\n | ' ' -> skip_spaces (Scanning.ignore_char width ib)\n | _ -> find_stop width in\n\n find_start width\n\n\n(* Scan a boolean (an OCaml token). *)\nlet scan_bool ib =\n let c = Scanning.checked_peek_char ib in\n let m =\n match c with\n | 't' -> 4\n | 'f' -> 5\n | c ->\n bad_input\n (Printf.sprintf \"the character %C cannot start a boolean\" c) in\n scan_string None m ib\n\n\n(* Scan a string containing elements in char_set and terminated by scan_indic\n if provided. *)\nlet scan_chars_in_char_set char_set scan_indic width ib =\n let rec scan_chars i stp =\n let c = Scanning.peek_char ib in\n if i > 0 && not (Scanning.eof ib) &&\n is_in_char_set char_set c &&\n int_of_char c <> stp then\n let _ = Scanning.store_char max_int ib c in\n scan_chars (i - 1) stp in\n match scan_indic with\n | None -> scan_chars width (-1);\n | Some c ->\n scan_chars width (int_of_char c);\n if not (Scanning.eof ib) then\n let ci = Scanning.peek_char ib in\n if c = ci\n then Scanning.invalidate_current_char ib\n else character_mismatch c ci\n\n\n(* The global error report function for [Scanf]. *)\nlet scanf_bad_input ib = function\n | Scan_failure s | Failure s ->\n let i = Scanning.char_count ib in\n bad_input (Printf.sprintf \"scanf: bad input at char number %i: %s\" i s)\n | x -> raise x\n\n\n(* Get the content of a counter from an input buffer. *)\nlet get_counter ib counter =\n match counter with\n | Line_counter -> Scanning.line_count ib\n | Char_counter -> Scanning.char_count ib\n | Token_counter -> Scanning.token_count ib\n\n\n(* Compute the width of a padding option (see \"%42{\" and \"%123(\"). *)\nlet width_of_pad_opt pad_opt = match pad_opt with\n | None -> max_int\n | Some width -> width\n\n\nlet stopper_of_formatting_lit fmting =\n if fmting = Escaped_percent then '%', \"\" else\n let str = string_of_formatting_lit fmting in\n let stp = str.[1] in\n let sub_str = String.sub str 2 (String.length str - 2) in\n stp, sub_str\n\n\n(******************************************************************************)\n (* Reader management *)\n\n(* A call to take_format_readers on a format is evaluated into functions\n taking readers as arguments and aggregate them into an heterogeneous list *)\n(* When all readers are taken, finally pass the list of the readers to the\n continuation k. *)\nlet rec take_format_readers : type a c d e f .\n ((d, e) heter_list -> e) -> (a, Scanning.in_channel, c, d, e, f) fmt ->\n d =\nfun k fmt -> match fmt with\n | Reader fmt_rest ->\n fun reader ->\n let new_k readers_rest = k (Cons (reader, readers_rest)) in\n take_format_readers new_k fmt_rest\n | Char rest -> take_format_readers k rest\n | Caml_char rest -> take_format_readers k rest\n | String (_, rest) -> take_format_readers k rest\n | Caml_string (_, rest) -> take_format_readers k rest\n | Int (_, _, _, rest) -> take_format_readers k rest\n | Int32 (_, _, _, rest) -> take_format_readers k rest\n | Nativeint (_, _, _, rest) -> take_format_readers k rest\n | Int64 (_, _, _, rest) -> take_format_readers k rest\n | Float (_, _, _, rest) -> take_format_readers k rest\n | Bool (_, rest) -> take_format_readers k rest\n | Alpha rest -> take_format_readers k rest\n | Theta rest -> take_format_readers k rest\n | Flush rest -> take_format_readers k rest\n | String_literal (_, rest) -> take_format_readers k rest\n | Char_literal (_, rest) -> take_format_readers k rest\n | Custom (_, _, rest) -> take_format_readers k rest\n\n | Scan_char_set (_, _, rest) -> take_format_readers k rest\n | Scan_get_counter (_, rest) -> take_format_readers k rest\n | Scan_next_char rest -> take_format_readers k rest\n\n | Formatting_lit (_, rest) -> take_format_readers k rest\n | Formatting_gen (Open_tag (Format (fmt, _)), rest) ->\n take_format_readers k (concat_fmt fmt rest)\n | Formatting_gen (Open_box (Format (fmt, _)), rest) ->\n take_format_readers k (concat_fmt fmt rest)\n\n | Format_arg (_, _, rest) -> take_format_readers k rest\n | Format_subst (_, fmtty, rest) ->\n take_fmtty_format_readers k (erase_rel (symm fmtty)) rest\n | Ignored_param (ign, rest) -> take_ignored_format_readers k ign rest\n\n | End_of_format -> k Nil\n\n(* Take readers associated to an fmtty coming from a Format_subst \"%(...%)\". *)\nand take_fmtty_format_readers : type x y a c d e f .\n ((d, e) heter_list -> e) -> (a, Scanning.in_channel, c, d, x, y) fmtty ->\n (y, Scanning.in_channel, c, x, e, f) fmt -> d =\nfun k fmtty fmt -> match fmtty with\n | Reader_ty fmt_rest ->\n fun reader ->\n let new_k readers_rest = k (Cons (reader, readers_rest)) in\n take_fmtty_format_readers new_k fmt_rest fmt\n | Ignored_reader_ty fmt_rest ->\n fun reader ->\n let new_k readers_rest = k (Cons (reader, readers_rest)) in\n take_fmtty_format_readers new_k fmt_rest fmt\n | Char_ty rest -> take_fmtty_format_readers k rest fmt\n | String_ty rest -> take_fmtty_format_readers k rest fmt\n | Int_ty rest -> take_fmtty_format_readers k rest fmt\n | Int32_ty rest -> take_fmtty_format_readers k rest fmt\n | Nativeint_ty rest -> take_fmtty_format_readers k rest fmt\n | Int64_ty rest -> take_fmtty_format_readers k rest fmt\n | Float_ty rest -> take_fmtty_format_readers k rest fmt\n | Bool_ty rest -> take_fmtty_format_readers k rest fmt\n | Alpha_ty rest -> take_fmtty_format_readers k rest fmt\n | Theta_ty rest -> take_fmtty_format_readers k rest fmt\n | Any_ty rest -> take_fmtty_format_readers k rest fmt\n | Format_arg_ty (_, rest) -> take_fmtty_format_readers k rest fmt\n | End_of_fmtty -> take_format_readers k fmt\n | Format_subst_ty (ty1, ty2, rest) ->\n let ty = trans (symm ty1) ty2 in\n take_fmtty_format_readers k (concat_fmtty ty rest) fmt\n\n(* Take readers associated to an ignored parameter. *)\nand take_ignored_format_readers : type x y a c d e f .\n ((d, e) heter_list -> e) -> (a, Scanning.in_channel, c, d, x, y) ignored ->\n (y, Scanning.in_channel, c, x, e, f) fmt -> d =\nfun k ign fmt -> match ign with\n | Ignored_reader ->\n fun reader ->\n let new_k readers_rest = k (Cons (reader, readers_rest)) in\n take_format_readers new_k fmt\n | Ignored_char -> take_format_readers k fmt\n | Ignored_caml_char -> take_format_readers k fmt\n | Ignored_string _ -> take_format_readers k fmt\n | Ignored_caml_string _ -> take_format_readers k fmt\n | Ignored_int (_, _) -> take_format_readers k fmt\n | Ignored_int32 (_, _) -> take_format_readers k fmt\n | Ignored_nativeint (_, _) -> take_format_readers k fmt\n | Ignored_int64 (_, _) -> take_format_readers k fmt\n | Ignored_float (_, _) -> take_format_readers k fmt\n | Ignored_bool _ -> take_format_readers k fmt\n | Ignored_format_arg _ -> take_format_readers k fmt\n | Ignored_format_subst (_, fmtty) -> take_fmtty_format_readers k fmtty fmt\n | Ignored_scan_char_set _ -> take_format_readers k fmt\n | Ignored_scan_get_counter _ -> take_format_readers k fmt\n | Ignored_scan_next_char -> take_format_readers k fmt\n\n(******************************************************************************)\n (* Generic scanning *)\n\n(* Make a generic scanning function. *)\n(* Scan a stream according to a format and readers obtained by\n take_format_readers, and aggregate scanned values into an\n heterogeneous list. *)\n(* Return the heterogeneous list of scanned values. *)\nlet rec make_scanf : type a c d e f.\n Scanning.in_channel -> (a, Scanning.in_channel, c, d, e, f) fmt ->\n (d, e) heter_list -> (a, f) heter_list =\nfun ib fmt readers -> match fmt with\n | Char rest ->\n let _ = scan_char 0 ib in\n let c = token_char ib in\n Cons (c, make_scanf ib rest readers)\n | Caml_char rest ->\n let _ = scan_caml_char 0 ib in\n let c = token_char ib in\n Cons (c, make_scanf ib rest readers)\n\n | String (pad, Formatting_lit (fmting_lit, rest)) ->\n let stp, str = stopper_of_formatting_lit fmting_lit in\n let scan width _ ib = scan_string (Some stp) width ib in\n let str_rest = String_literal (str, rest) in\n pad_prec_scanf ib str_rest readers pad No_precision scan token_string\n | String (pad, Formatting_gen (Open_tag (Format (fmt', _)), rest)) ->\n let scan width _ ib = scan_string (Some '{') width ib in\n pad_prec_scanf ib (concat_fmt fmt' rest) readers pad No_precision scan\n token_string\n | String (pad, Formatting_gen (Open_box (Format (fmt', _)), rest)) ->\n let scan width _ ib = scan_string (Some '[') width ib in\n pad_prec_scanf ib (concat_fmt fmt' rest) readers pad No_precision scan\n token_string\n | String (pad, rest) ->\n let scan width _ ib = scan_string None width ib in\n pad_prec_scanf ib rest readers pad No_precision scan token_string\n\n | Caml_string (pad, rest) ->\n let scan width _ ib = scan_caml_string width ib in\n pad_prec_scanf ib rest readers pad No_precision scan token_string\n | Int (iconv, pad, prec, rest) ->\n let c = integer_conversion_of_char (char_of_iconv iconv) in\n let scan width _ ib = scan_int_conversion c width ib in\n pad_prec_scanf ib rest readers pad prec scan (token_int c)\n | Int32 (iconv, pad, prec, rest) ->\n let c = integer_conversion_of_char (char_of_iconv iconv) in\n let scan width _ ib = scan_int_conversion c width ib in\n pad_prec_scanf ib rest readers pad prec scan (token_int32 c)\n | Nativeint (iconv, pad, prec, rest) ->\n let c = integer_conversion_of_char (char_of_iconv iconv) in\n let scan width _ ib = scan_int_conversion c width ib in\n pad_prec_scanf ib rest readers pad prec scan (token_nativeint c)\n | Int64 (iconv, pad, prec, rest) ->\n let c = integer_conversion_of_char (char_of_iconv iconv) in\n let scan width _ ib = scan_int_conversion c width ib in\n pad_prec_scanf ib rest readers pad prec scan (token_int64 c)\n | Float ((_, (Float_F | Float_CF)), pad, prec, rest) ->\n pad_prec_scanf ib rest readers pad prec scan_caml_float token_float\n | Float ((_, (Float_f | Float_e | Float_E | Float_g | Float_G)),\n pad, prec, rest) ->\n pad_prec_scanf ib rest readers pad prec scan_float token_float\n | Float ((_, (Float_h | Float_H)), pad, prec, rest) ->\n pad_prec_scanf ib rest readers pad prec scan_hex_float token_float\n | Bool (pad, rest) ->\n let scan _ _ ib = scan_bool ib in\n pad_prec_scanf ib rest readers pad No_precision scan token_bool\n | Alpha _ ->\n invalid_arg \"scanf: bad conversion \\\"%a\\\"\"\n | Theta _ ->\n invalid_arg \"scanf: bad conversion \\\"%t\\\"\"\n | Custom _ ->\n invalid_arg \"scanf: bad conversion \\\"%?\\\" (custom converter)\"\n | Reader fmt_rest ->\n begin match readers with\n | Cons (reader, readers_rest) ->\n let x = reader ib in\n Cons (x, make_scanf ib fmt_rest readers_rest)\n | Nil ->\n invalid_arg \"scanf: missing reader\"\n end\n | Flush rest ->\n if Scanning.end_of_input ib then make_scanf ib rest readers\n else bad_input \"end of input not found\"\n\n | String_literal (str, rest) ->\n String.iter (check_char ib) str;\n make_scanf ib rest readers\n | Char_literal (chr, rest) ->\n check_char ib chr;\n make_scanf ib rest readers\n\n | Format_arg (pad_opt, fmtty, rest) ->\n let _ = scan_caml_string (width_of_pad_opt pad_opt) ib in\n let s = token_string ib in\n let fmt =\n try format_of_string_fmtty s fmtty\n with Failure msg -> bad_input msg\n in\n Cons (fmt, make_scanf ib rest readers)\n | Format_subst (pad_opt, fmtty, rest) ->\n let _ = scan_caml_string (width_of_pad_opt pad_opt) ib in\n let s = token_string ib in\n let fmt, fmt' =\n try\n let Fmt_EBB fmt = fmt_ebb_of_string s in\n let Fmt_EBB fmt' = fmt_ebb_of_string s in\n (* TODO: find a way to avoid reparsing twice *)\n\n (* TODO: these type-checks below *can* fail because of type\n ambiguity in presence of ignored-readers: \"%_r%d\" and \"%d%_r\"\n are typed in the same way.\n\n # Scanf.sscanf \"\\\"%_r%d\\\"3\" \"%(%d%_r%)\" ignore\n (fun fmt n -> string_of_format fmt, n)\n Exception: CamlinternalFormat.Type_mismatch.\n\n We should properly catch this exception.\n *)\n type_format fmt (erase_rel fmtty),\n type_format fmt' (erase_rel (symm fmtty))\n with Failure msg -> bad_input msg\n in\n Cons (Format (fmt, s),\n make_scanf ib (concat_fmt fmt' rest) readers)\n\n | Scan_char_set (width_opt, char_set, Formatting_lit (fmting_lit, rest)) ->\n let stp, str = stopper_of_formatting_lit fmting_lit in\n let width = width_of_pad_opt width_opt in\n scan_chars_in_char_set char_set (Some stp) width ib;\n let s = token_string ib in\n let str_rest = String_literal (str, rest) in\n Cons (s, make_scanf ib str_rest readers)\n | Scan_char_set (width_opt, char_set, rest) ->\n let width = width_of_pad_opt width_opt in\n scan_chars_in_char_set char_set None width ib;\n let s = token_string ib in\n Cons (s, make_scanf ib rest readers)\n | Scan_get_counter (counter, rest) ->\n let count = get_counter ib counter in\n Cons (count, make_scanf ib rest readers)\n | Scan_next_char rest ->\n let c = Scanning.checked_peek_char ib in\n Cons (c, make_scanf ib rest readers)\n\n | Formatting_lit (formatting_lit, rest) ->\n String.iter (check_char ib) (string_of_formatting_lit formatting_lit);\n make_scanf ib rest readers\n | Formatting_gen (Open_tag (Format (fmt', _)), rest) ->\n check_char ib '@'; check_char ib '{';\n make_scanf ib (concat_fmt fmt' rest) readers\n | Formatting_gen (Open_box (Format (fmt', _)), rest) ->\n check_char ib '@'; check_char ib '[';\n make_scanf ib (concat_fmt fmt' rest) readers\n\n | Ignored_param (ign, rest) ->\n let Param_format_EBB fmt' = param_format_of_ignored_format ign rest in\n begin match make_scanf ib fmt' readers with\n | Cons (_, arg_rest) -> arg_rest\n | Nil -> assert false\n end\n\n | End_of_format ->\n Nil\n\n(* Case analysis on padding and precision. *)\n(* Reject formats containing \"%*\" or \"%.*\". *)\n(* Pass padding and precision to the generic scanner `scan'. *)\nand pad_prec_scanf : type a c d e f x y z t .\n Scanning.in_channel -> (a, Scanning.in_channel, c, d, e, f) fmt ->\n (d, e) heter_list -> (x, y) padding -> (y, z -> a) precision ->\n (int -> int -> Scanning.in_channel -> t) ->\n (Scanning.in_channel -> z) ->\n (x, f) heter_list =\nfun ib fmt readers pad prec scan token -> match pad, prec with\n | No_padding, No_precision ->\n let _ = scan max_int max_int ib in\n let x = token ib in\n Cons (x, make_scanf ib fmt readers)\n | No_padding, Lit_precision p ->\n let _ = scan max_int p ib in\n let x = token ib in\n Cons (x, make_scanf ib fmt readers)\n | Lit_padding ((Right | Zeros), w), No_precision ->\n let _ = scan w max_int ib in\n let x = token ib in\n Cons (x, make_scanf ib fmt readers)\n | Lit_padding ((Right | Zeros), w), Lit_precision p ->\n let _ = scan w p ib in\n let x = token ib in\n Cons (x, make_scanf ib fmt readers)\n | Lit_padding (Left, _), _ ->\n invalid_arg \"scanf: bad conversion \\\"%-\\\"\"\n | Lit_padding ((Right | Zeros), _), Arg_precision ->\n invalid_arg \"scanf: bad conversion \\\"%*\\\"\"\n | Arg_padding _, _ ->\n invalid_arg \"scanf: bad conversion \\\"%*\\\"\"\n | No_padding, Arg_precision ->\n invalid_arg \"scanf: bad conversion \\\"%*\\\"\"\n\n(******************************************************************************)\n (* Defining [scanf] and various flavors of [scanf] *)\n\ntype 'a kscanf_result = Args of 'a | Exc of exn\n\nlet kscanf ib ef (Format (fmt, str)) =\n let rec apply : type a b . a -> (a, b) heter_list -> b =\n fun f args -> match args with\n | Cons (x, r) -> apply (f x) r\n | Nil -> f\n in\n let k readers f =\n Scanning.reset_token ib;\n match try Args (make_scanf ib fmt readers) with\n | (Scan_failure _ | Failure _ | End_of_file) as exc -> Exc exc\n | Invalid_argument msg ->\n invalid_arg (msg ^ \" in format \\\"\" ^ String.escaped str ^ \"\\\"\")\n with\n | Args args -> apply f args\n | Exc exc -> ef ib exc\n in\n take_format_readers k fmt\n\n(***)\n\nlet kbscanf = kscanf\nlet bscanf ib fmt = kbscanf ib scanf_bad_input fmt\n\nlet ksscanf s ef fmt = kbscanf (Scanning.from_string s) ef fmt\nlet sscanf s fmt = kbscanf (Scanning.from_string s) scanf_bad_input fmt\n\nlet scanf fmt = kscanf Scanning.stdib scanf_bad_input fmt\n\n(***)\n\n(* Scanning format strings. *)\nlet bscanf_format :\n Scanning.in_channel -> ('a, 'b, 'c, 'd, 'e, 'f) format6 ->\n (('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g) -> 'g =\n fun ib format f ->\n let _ = scan_caml_string max_int ib in\n let str = token_string ib in\n let fmt' =\n try format_of_string_format str format\n with Failure msg -> bad_input msg in\n f fmt'\n\n\nlet sscanf_format :\n string -> ('a, 'b, 'c, 'd, 'e, 'f) format6 ->\n (('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g) -> 'g =\n fun s format f -> bscanf_format (Scanning.from_string s) format f\n\n\nlet format_from_string s fmt =\n sscanf_format (\"\\\"\" ^ String.escaped s ^ \"\\\"\") fmt (fun x -> x)\n\n\nlet unescaped s =\n sscanf (\"\\\"\" ^ s ^ \"\\\"\") \"%S%!\" (fun x -> x)\n\n\n(* Deprecated *)\nlet kfscanf ic ef fmt = kbscanf (Scanning.memo_from_channel ic) ef fmt\nlet fscanf ic fmt = kscanf (Scanning.memo_from_channel ic) scanf_bad_input fmt\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* Registering OCaml values with the C runtime for later callbacks *)\n\nexternal register_named_value : string -> Obj.t -> unit\n = \"caml_register_named_value\"\n\nlet register name v =\n register_named_value name (Obj.repr v)\n\nlet register_exception name (exn : exn) =\n let exn = Obj.repr exn in\n let slot = if Obj.tag exn = Obj.object_tag then exn else Obj.field exn 0 in\n register_named_value name slot\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 2004 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\ntype shape =\n | Function\n | Lazy\n | Class\n | Module of shape array\n | Value of Obj.t\n\nlet rec init_mod_field modu i loc shape =\n let init =\n match shape with\n | Function ->\n let rec fn (x : 'a) =\n let fn' : 'a -> 'b = Obj.obj (Obj.field modu i) in\n if fn == fn' then\n raise (Undefined_recursive_module loc)\n else\n fn' x in\n Obj.repr fn\n | Lazy ->\n let rec l =\n lazy (\n let l' = Obj.obj (Obj.field modu i) in\n if l == l' then\n raise (Undefined_recursive_module loc)\n else\n Lazy.force l') in\n Obj.repr l\n | Class ->\n Obj.repr (CamlinternalOO.dummy_class loc)\n | Module comps ->\n Obj.repr (init_mod_block loc comps)\n | Value v -> v\n in\n Obj.set_field modu i init\n\nand init_mod_block loc comps =\n let length = Array.length comps in\n let modu = Obj.new_block 0 length in\n for i = 0 to length - 1 do\n init_mod_field modu i loc comps.(i)\n done;\n modu\n\nlet init_mod loc shape =\n match shape with\n | Module comps ->\n Obj.repr (init_mod_block loc comps)\n | _ -> failwith \"CamlinternalMod.init_mod: not a module\"\n\nlet rec update_mod_field modu i shape n =\n match shape with\n | Function | Lazy ->\n Obj.set_field modu i n\n | Value _ ->\n () (* the value is already there *)\n | Class ->\n assert (Obj.tag n = 0 && Obj.size n = 4);\n let cl = Obj.field modu i in\n for j = 0 to 3 do\n Obj.set_field cl j (Obj.field n j)\n done\n | Module comps ->\n update_mod_block comps (Obj.field modu i) n\n\nand update_mod_block comps o n =\n assert (Obj.tag n = 0 && Obj.size n >= Array.length comps);\n for i = 0 to Array.length comps - 1 do\n update_mod_field o i comps.(i) (Obj.field n i)\n done\n\nlet update_mod shape o n =\n match shape with\n | Module comps ->\n update_mod_block comps o n\n | _ -> failwith \"CamlinternalMod.update_mod: not a module\"\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Manuel Serrano et Xavier Leroy, INRIA Rocquencourt *)\n(* *)\n(* Copyright 2000 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* Module [Bigarray]: large, multi-dimensional, numerical arrays *)\n\n(* These types in must be kept in sync with the tables in\n ../typing/typeopt.ml *)\n\ntype float32_elt = Float32_elt\ntype float64_elt = Float64_elt\ntype int8_signed_elt = Int8_signed_elt\ntype int8_unsigned_elt = Int8_unsigned_elt\ntype int16_signed_elt = Int16_signed_elt\ntype int16_unsigned_elt = Int16_unsigned_elt\ntype int32_elt = Int32_elt\ntype int64_elt = Int64_elt\ntype int_elt = Int_elt\ntype nativeint_elt = Nativeint_elt\ntype complex32_elt = Complex32_elt\ntype complex64_elt = Complex64_elt\n\ntype ('a, 'b) kind =\n Float32 : (float, float32_elt) kind\n | Float64 : (float, float64_elt) kind\n | Int8_signed : (int, int8_signed_elt) kind\n | Int8_unsigned : (int, int8_unsigned_elt) kind\n | Int16_signed : (int, int16_signed_elt) kind\n | Int16_unsigned : (int, int16_unsigned_elt) kind\n | Int32 : (int32, int32_elt) kind\n | Int64 : (int64, int64_elt) kind\n | Int : (int, int_elt) kind\n | Nativeint : (nativeint, nativeint_elt) kind\n | Complex32 : (Complex.t, complex32_elt) kind\n | Complex64 : (Complex.t, complex64_elt) kind\n | Char : (char, int8_unsigned_elt) kind\n\ntype c_layout = C_layout_typ\ntype fortran_layout = Fortran_layout_typ (**)\n\ntype 'a layout =\n C_layout: c_layout layout\n | Fortran_layout: fortran_layout layout\n\n(* Keep those constants in sync with the caml_ba_kind enumeration\n in bigarray.h *)\n\nlet float32 = Float32\nlet float64 = Float64\nlet int8_signed = Int8_signed\nlet int8_unsigned = Int8_unsigned\nlet int16_signed = Int16_signed\nlet int16_unsigned = Int16_unsigned\nlet int32 = Int32\nlet int64 = Int64\nlet int = Int\nlet nativeint = Nativeint\nlet complex32 = Complex32\nlet complex64 = Complex64\nlet char = Char\n\nlet kind_size_in_bytes : type a b. (a, b) kind -> int = function\n | Float32 -> 4\n | Float64 -> 8\n | Int8_signed -> 1\n | Int8_unsigned -> 1\n | Int16_signed -> 2\n | Int16_unsigned -> 2\n | Int32 -> 4\n | Int64 -> 8\n | Int -> Sys.word_size / 8\n | Nativeint -> Sys.word_size / 8\n | Complex32 -> 8\n | Complex64 -> 16\n | Char -> 1\n\n(* Keep those constants in sync with the caml_ba_layout enumeration\n in bigarray.h *)\n\nlet c_layout = C_layout\nlet fortran_layout = Fortran_layout\n\nmodule Genarray = struct\n type (!'a, !'b, !'c) t\n external create: ('a, 'b) kind -> 'c layout -> int array -> ('a, 'b, 'c) t\n = \"caml_ba_create\"\n external get: ('a, 'b, 'c) t -> int array -> 'a\n = \"caml_ba_get_generic\"\n external set: ('a, 'b, 'c) t -> int array -> 'a -> unit\n = \"caml_ba_set_generic\"\n\n let rec cloop arr idx f col max =\n if col = Array.length idx then set arr idx (f idx)\n else for j = 0 to pred max.(col) do\n idx.(col) <- j;\n cloop arr idx f (succ col) max\n done\n let rec floop arr idx f col max =\n if col < 0 then set arr idx (f idx)\n else for j = 1 to max.(col) do\n idx.(col) <- j;\n floop arr idx f (pred col) max\n done\n let init (type t) kind (layout : t layout) dims f =\n let arr = create kind layout dims in\n match Array.length dims, layout with\n | 0, _ -> arr\n | dlen, C_layout -> cloop arr (Array.make dlen 0) f 0 dims; arr\n | dlen, Fortran_layout -> floop arr (Array.make dlen 1) f (pred dlen) dims;\n arr\n\n external num_dims: ('a, 'b, 'c) t -> int = \"caml_ba_num_dims\"\n external nth_dim: ('a, 'b, 'c) t -> int -> int = \"caml_ba_dim\"\n let dims a =\n let n = num_dims a in\n let d = Array.make n 0 in\n for i = 0 to n-1 do d.(i) <- nth_dim a i done;\n d\n\n external kind: ('a, 'b, 'c) t -> ('a, 'b) kind = \"caml_ba_kind\"\n external layout: ('a, 'b, 'c) t -> 'c layout = \"caml_ba_layout\"\n external change_layout: ('a, 'b, 'c) t -> 'd layout -> ('a, 'b, 'd) t\n = \"caml_ba_change_layout\"\n\n let size_in_bytes arr =\n (kind_size_in_bytes (kind arr)) * (Array.fold_left ( * ) 1 (dims arr))\n\n external sub_left: ('a, 'b, c_layout) t -> int -> int -> ('a, 'b, c_layout) t\n = \"caml_ba_sub\"\n external sub_right: ('a, 'b, fortran_layout) t -> int -> int ->\n ('a, 'b, fortran_layout) t\n = \"caml_ba_sub\"\n external slice_left: ('a, 'b, c_layout) t -> int array ->\n ('a, 'b, c_layout) t\n = \"caml_ba_slice\"\n external slice_right: ('a, 'b, fortran_layout) t -> int array ->\n ('a, 'b, fortran_layout) t\n = \"caml_ba_slice\"\n external blit: ('a, 'b, 'c) t -> ('a, 'b, 'c) t -> unit\n = \"caml_ba_blit\"\n external fill: ('a, 'b, 'c) t -> 'a -> unit = \"caml_ba_fill\"\nend\n\nmodule Array0 = struct\n type (!'a, !'b, !'c) t = ('a, 'b, 'c) Genarray.t\n let create kind layout =\n Genarray.create kind layout [||]\n let get arr = Genarray.get arr [||]\n let set arr = Genarray.set arr [||]\n external kind: ('a, 'b, 'c) t -> ('a, 'b) kind = \"caml_ba_kind\"\n external layout: ('a, 'b, 'c) t -> 'c layout = \"caml_ba_layout\"\n\n external change_layout: ('a, 'b, 'c) t -> 'd layout -> ('a, 'b, 'd) t\n = \"caml_ba_change_layout\"\n\n let size_in_bytes arr = kind_size_in_bytes (kind arr)\n\n external blit: ('a, 'b, 'c) t -> ('a, 'b, 'c) t -> unit = \"caml_ba_blit\"\n external fill: ('a, 'b, 'c) t -> 'a -> unit = \"caml_ba_fill\"\n\n let of_value kind layout v =\n let a = create kind layout in\n set a v;\n a\n let init = of_value\nend\n\nmodule Array1 = struct\n type (!'a, !'b, !'c) t = ('a, 'b, 'c) Genarray.t\n let create kind layout dim =\n Genarray.create kind layout [|dim|]\n external get: ('a, 'b, 'c) t -> int -> 'a = \"%caml_ba_ref_1\"\n external set: ('a, 'b, 'c) t -> int -> 'a -> unit = \"%caml_ba_set_1\"\n external unsafe_get: ('a, 'b, 'c) t -> int -> 'a = \"%caml_ba_unsafe_ref_1\"\n external unsafe_set: ('a, 'b, 'c) t -> int -> 'a -> unit\n = \"%caml_ba_unsafe_set_1\"\n external dim: ('a, 'b, 'c) t -> int = \"%caml_ba_dim_1\"\n external kind: ('a, 'b, 'c) t -> ('a, 'b) kind = \"caml_ba_kind\"\n external layout: ('a, 'b, 'c) t -> 'c layout = \"caml_ba_layout\"\n\n external change_layout: ('a, 'b, 'c) t -> 'd layout -> ('a, 'b, 'd) t\n = \"caml_ba_change_layout\"\n\n let size_in_bytes arr =\n (kind_size_in_bytes (kind arr)) * (dim arr)\n\n external sub: ('a, 'b, 'c) t -> int -> int -> ('a, 'b, 'c) t = \"caml_ba_sub\"\n let slice (type t) (a : (_, _, t) Genarray.t) n =\n match layout a with\n | C_layout -> (Genarray.slice_left a [|n|] : (_, _, t) Genarray.t)\n | Fortran_layout -> (Genarray.slice_right a [|n|]: (_, _, t) Genarray.t)\n external blit: ('a, 'b, 'c) t -> ('a, 'b, 'c) t -> unit = \"caml_ba_blit\"\n external fill: ('a, 'b, 'c) t -> 'a -> unit = \"caml_ba_fill\"\n let c_init arr dim f =\n for i = 0 to pred dim do unsafe_set arr i (f i) done\n let fortran_init arr dim f =\n for i = 1 to dim do unsafe_set arr i (f i) done\n let init (type t) kind (layout : t layout) dim f =\n let arr = create kind layout dim in\n match layout with\n | C_layout -> c_init arr dim f; arr\n | Fortran_layout -> fortran_init arr dim f; arr\n let of_array (type t) kind (layout: t layout) data =\n let ba = create kind layout (Array.length data) in\n let ofs =\n match layout with\n C_layout -> 0\n | Fortran_layout -> 1\n in\n for i = 0 to Array.length data - 1 do unsafe_set ba (i + ofs) data.(i) done;\n ba\nend\n\nmodule Array2 = struct\n type (!'a, !'b, !'c) t = ('a, 'b, 'c) Genarray.t\n let create kind layout dim1 dim2 =\n Genarray.create kind layout [|dim1; dim2|]\n external get: ('a, 'b, 'c) t -> int -> int -> 'a = \"%caml_ba_ref_2\"\n external set: ('a, 'b, 'c) t -> int -> int -> 'a -> unit = \"%caml_ba_set_2\"\n external unsafe_get: ('a, 'b, 'c) t -> int -> int -> 'a\n = \"%caml_ba_unsafe_ref_2\"\n external unsafe_set: ('a, 'b, 'c) t -> int -> int -> 'a -> unit\n = \"%caml_ba_unsafe_set_2\"\n external dim1: ('a, 'b, 'c) t -> int = \"%caml_ba_dim_1\"\n external dim2: ('a, 'b, 'c) t -> int = \"%caml_ba_dim_2\"\n external kind: ('a, 'b, 'c) t -> ('a, 'b) kind = \"caml_ba_kind\"\n external layout: ('a, 'b, 'c) t -> 'c layout = \"caml_ba_layout\"\n\n external change_layout: ('a, 'b, 'c) t -> 'd layout -> ('a, 'b, 'd) t\n = \"caml_ba_change_layout\"\n\n let size_in_bytes arr =\n (kind_size_in_bytes (kind arr)) * (dim1 arr) * (dim2 arr)\n\n external sub_left: ('a, 'b, c_layout) t -> int -> int -> ('a, 'b, c_layout) t\n = \"caml_ba_sub\"\n external sub_right:\n ('a, 'b, fortran_layout) t -> int -> int -> ('a, 'b, fortran_layout) t\n = \"caml_ba_sub\"\n let slice_left a n = Genarray.slice_left a [|n|]\n let slice_right a n = Genarray.slice_right a [|n|]\n external blit: ('a, 'b, 'c) t -> ('a, 'b, 'c) t -> unit = \"caml_ba_blit\"\n external fill: ('a, 'b, 'c) t -> 'a -> unit = \"caml_ba_fill\"\n let c_init arr dim1 dim2 f =\n for i = 0 to pred dim1 do\n for j = 0 to pred dim2 do\n unsafe_set arr i j (f i j)\n done\n done\n let fortran_init arr dim1 dim2 f =\n for j = 1 to dim2 do\n for i = 1 to dim1 do\n unsafe_set arr i j (f i j)\n done\n done\n let init (type t) kind (layout : t layout) dim1 dim2 f =\n let arr = create kind layout dim1 dim2 in\n match layout with\n | C_layout -> c_init arr dim1 dim2 f; arr\n | Fortran_layout -> fortran_init arr dim1 dim2 f; arr\n let of_array (type t) kind (layout: t layout) data =\n let dim1 = Array.length data in\n let dim2 = if dim1 = 0 then 0 else Array.length data.(0) in\n let ba = create kind layout dim1 dim2 in\n let ofs =\n match layout with\n C_layout -> 0\n | Fortran_layout -> 1\n in\n for i = 0 to dim1 - 1 do\n let row = data.(i) in\n if Array.length row <> dim2 then\n invalid_arg(\"Bigarray.Array2.of_array: non-rectangular data\");\n for j = 0 to dim2 - 1 do\n unsafe_set ba (i + ofs) (j + ofs) row.(j)\n done\n done;\n ba\nend\n\nmodule Array3 = struct\n type (!'a, !'b, !'c) t = ('a, 'b, 'c) Genarray.t\n let create kind layout dim1 dim2 dim3 =\n Genarray.create kind layout [|dim1; dim2; dim3|]\n external get: ('a, 'b, 'c) t -> int -> int -> int -> 'a = \"%caml_ba_ref_3\"\n external set: ('a, 'b, 'c) t -> int -> int -> int -> 'a -> unit\n = \"%caml_ba_set_3\"\n external unsafe_get: ('a, 'b, 'c) t -> int -> int -> int -> 'a\n = \"%caml_ba_unsafe_ref_3\"\n external unsafe_set: ('a, 'b, 'c) t -> int -> int -> int -> 'a -> unit\n = \"%caml_ba_unsafe_set_3\"\n external dim1: ('a, 'b, 'c) t -> int = \"%caml_ba_dim_1\"\n external dim2: ('a, 'b, 'c) t -> int = \"%caml_ba_dim_2\"\n external dim3: ('a, 'b, 'c) t -> int = \"%caml_ba_dim_3\"\n external kind: ('a, 'b, 'c) t -> ('a, 'b) kind = \"caml_ba_kind\"\n external layout: ('a, 'b, 'c) t -> 'c layout = \"caml_ba_layout\"\n\n external change_layout: ('a, 'b, 'c) t -> 'd layout -> ('a, 'b, 'd) t\n = \"caml_ba_change_layout\"\n\n let size_in_bytes arr =\n (kind_size_in_bytes (kind arr)) * (dim1 arr) * (dim2 arr) * (dim3 arr)\n\n external sub_left: ('a, 'b, c_layout) t -> int -> int -> ('a, 'b, c_layout) t\n = \"caml_ba_sub\"\n external sub_right:\n ('a, 'b, fortran_layout) t -> int -> int -> ('a, 'b, fortran_layout) t\n = \"caml_ba_sub\"\n let slice_left_1 a n m = Genarray.slice_left a [|n; m|]\n let slice_right_1 a n m = Genarray.slice_right a [|n; m|]\n let slice_left_2 a n = Genarray.slice_left a [|n|]\n let slice_right_2 a n = Genarray.slice_right a [|n|]\n external blit: ('a, 'b, 'c) t -> ('a, 'b, 'c) t -> unit = \"caml_ba_blit\"\n external fill: ('a, 'b, 'c) t -> 'a -> unit = \"caml_ba_fill\"\n let c_init arr dim1 dim2 dim3 f =\n for i = 0 to pred dim1 do\n for j = 0 to pred dim2 do\n for k = 0 to pred dim3 do\n unsafe_set arr i j k (f i j k)\n done\n done\n done\n let fortran_init arr dim1 dim2 dim3 f =\n for k = 1 to dim3 do\n for j = 1 to dim2 do\n for i = 1 to dim1 do\n unsafe_set arr i j k (f i j k)\n done\n done\n done\n let init (type t) kind (layout : t layout) dim1 dim2 dim3 f =\n let arr = create kind layout dim1 dim2 dim3 in\n match layout with\n | C_layout -> c_init arr dim1 dim2 dim3 f; arr\n | Fortran_layout -> fortran_init arr dim1 dim2 dim3 f; arr\n let of_array (type t) kind (layout: t layout) data =\n let dim1 = Array.length data in\n let dim2 = if dim1 = 0 then 0 else Array.length data.(0) in\n let dim3 = if dim2 = 0 then 0 else Array.length data.(0).(0) in\n let ba = create kind layout dim1 dim2 dim3 in\n let ofs =\n match layout with\n C_layout -> 0\n | Fortran_layout -> 1\n in\n for i = 0 to dim1 - 1 do\n let row = data.(i) in\n if Array.length row <> dim2 then\n invalid_arg(\"Bigarray.Array3.of_array: non-cubic data\");\n for j = 0 to dim2 - 1 do\n let col = row.(j) in\n if Array.length col <> dim3 then\n invalid_arg(\"Bigarray.Array3.of_array: non-cubic data\");\n for k = 0 to dim3 - 1 do\n unsafe_set ba (i + ofs) (j + ofs) (k + ofs) col.(k)\n done\n done\n done;\n ba\nend\n\nexternal genarray_of_array0: ('a, 'b, 'c) Array0.t -> ('a, 'b, 'c) Genarray.t\n = \"%identity\"\nexternal genarray_of_array1: ('a, 'b, 'c) Array1.t -> ('a, 'b, 'c) Genarray.t\n = \"%identity\"\nexternal genarray_of_array2: ('a, 'b, 'c) Array2.t -> ('a, 'b, 'c) Genarray.t\n = \"%identity\"\nexternal genarray_of_array3: ('a, 'b, 'c) Array3.t -> ('a, 'b, 'c) Genarray.t\n = \"%identity\"\nlet array0_of_genarray a =\n if Genarray.num_dims a = 0 then a\n else invalid_arg \"Bigarray.array0_of_genarray\"\nlet array1_of_genarray a =\n if Genarray.num_dims a = 1 then a\n else invalid_arg \"Bigarray.array1_of_genarray\"\nlet array2_of_genarray a =\n if Genarray.num_dims a = 2 then a\n else invalid_arg \"Bigarray.array2_of_genarray\"\nlet array3_of_genarray a =\n if Genarray.num_dims a = 3 then a\n else invalid_arg \"Bigarray.array3_of_genarray\"\n\nexternal reshape:\n ('a, 'b, 'c) Genarray.t -> int array -> ('a, 'b, 'c) Genarray.t\n = \"caml_ba_reshape\"\nlet reshape_0 a = reshape a [||]\nlet reshape_1 a dim1 = reshape a [|dim1|]\nlet reshape_2 a dim1 dim2 = reshape a [|dim1;dim2|]\nlet reshape_3 a dim1 dim2 dim3 = reshape a [|dim1;dim2;dim3|]\n\n(* Force caml_ba_get_{1,2,3,N} to be linked in, since we don't refer\n to those primitives directly in this file *)\n\nlet _ =\n let _ = Genarray.get in\n let _ = Array1.get in\n let _ = Array2.get in\n let _ = Array3.get in\n ()\n\n[@@@ocaml.warning \"-32\"]\nexternal get1: unit -> unit = \"caml_ba_get_1\"\nexternal get2: unit -> unit = \"caml_ba_get_2\"\nexternal get3: unit -> unit = \"caml_ba_get_3\"\nexternal set1: unit -> unit = \"caml_ba_set_1\"\nexternal set2: unit -> unit = \"caml_ba_set_2\"\nexternal set3: unit -> unit = \"caml_ba_set_3\"\n","(** Why allocate a ref instead of storing the int directly?\n\n We generate many more sexp grammars than actually get used, so we prefer to defer the\n id until we need it. The compiler can optimize away allocations that nobody touches.\n*)\n\ntype t = int Lazy.t\n\nlet create =\n let next = ref 0 in\n fun () -> lazy (\n (* As long as we don't give up the global Ocaml runtime lock by allocating, we can\n treat the read and write as atomic. See \"20.12.2 Parallel execution of long-running\n C code\" in the 4.09 manual. *)\n let id = !next in\n next := id + 1;\n id)\n\nlet force (t : t) = Lazy.force t\n\nlet compare a b = compare (force a) (force b)\n","[@@@ocaml.warning \"-3\"]\n\n(* blit_string doesn't exist in [StdLabels.Bytes]... *)\nlet bytes_blit_string ~src ~src_pos ~dst ~dst_pos ~len =\n Bytes.blit_string src src_pos dst dst_pos len\n\nopen StdLabels\nopen Format\n\n(** Type of S-expressions *)\ntype t = Atom of string | List of t list\n\nlet sexp_of_t t = t\nlet t_of_sexp t = t\nlet t_sexp_grammar = Raw_grammar.Inline Any\n\nlet rec compare_list a b =\n match a, b with\n | [] , [] -> 0\n | [] , _ -> -1\n | _ , [] -> 1\n | x::xs, y::ys ->\n let res = compare x y in\n if res <> 0 then res\n else compare_list xs ys\n\nand compare a b =\n if a == b then\n 0\n else\n match a, b with\n | Atom a, Atom b -> String.compare a b\n | Atom _, _ -> -1\n | _, Atom _ -> 1\n | List a, List b -> compare_list a b\n\nlet equal a b = compare a b = 0\n\nexception Not_found_s of t\n\nexception Of_sexp_error of exn * t\n\nmodule Printing = struct\n (* Default indentation level for human-readable conversions *)\n\n let default_indent = ref 1\n\n (* Escaping of strings used as atoms in S-expressions *)\n\n let must_escape str =\n let len = String.length str in\n len = 0 ||\n let rec loop str ix =\n match str.[ix] with\n | '\"' | '(' | ')' | ';' | '\\\\' -> true\n | '|' -> ix > 0 && let next = ix - 1 in Char.equal str.[next] '#' || loop str next\n | '#' -> ix > 0 && let next = ix - 1 in Char.equal str.[next] '|' || loop str next\n | '\\000' .. '\\032' | '\\127' .. '\\255' -> true\n | _ -> ix > 0 && loop str (ix - 1)\n in\n loop str (len - 1)\n\n let escaped s =\n let n = ref 0 in\n for i = 0 to String.length s - 1 do\n n := !n +\n (match String.unsafe_get s i with\n | '\\\"' | '\\\\' | '\\n' | '\\t' | '\\r' | '\\b' -> 2\n | ' ' .. '~' -> 1\n | _ -> 4)\n done;\n if !n = String.length s then s else begin\n let s' = Bytes.create !n in\n n := 0;\n for i = 0 to String.length s - 1 do\n begin match String.unsafe_get s i with\n | ('\\\"' | '\\\\') as c ->\n Bytes.unsafe_set s' !n '\\\\'; incr n; Bytes.unsafe_set s' !n c\n | '\\n' ->\n Bytes.unsafe_set s' !n '\\\\'; incr n; Bytes.unsafe_set s' !n 'n'\n | '\\t' ->\n Bytes.unsafe_set s' !n '\\\\'; incr n; Bytes.unsafe_set s' !n 't'\n | '\\r' ->\n Bytes.unsafe_set s' !n '\\\\'; incr n; Bytes.unsafe_set s' !n 'r'\n | '\\b' ->\n Bytes.unsafe_set s' !n '\\\\'; incr n; Bytes.unsafe_set s' !n 'b'\n | (' ' .. '~') as c -> Bytes.unsafe_set s' !n c\n | c ->\n let a = Char.code c in\n Bytes.unsafe_set s' !n '\\\\';\n incr n;\n Bytes.unsafe_set s' !n (Char.chr (48 + a / 100));\n incr n;\n Bytes.unsafe_set s' !n (Char.chr (48 + (a / 10) mod 10));\n incr n;\n Bytes.unsafe_set s' !n (Char.chr (48 + a mod 10));\n end;\n incr n\n done;\n Bytes.unsafe_to_string s'\n end\n\n let esc_str str =\n let estr = escaped str in\n let elen = String.length estr in\n let res = Bytes.create (elen + 2) in\n bytes_blit_string ~src:estr ~src_pos:0 ~dst:res ~dst_pos:1 ~len:elen;\n Bytes.unsafe_set res 0 '\"';\n Bytes.unsafe_set res (elen + 1) '\"';\n Bytes.unsafe_to_string res\n\n let index_of_newline str start =\n try Some (String.index_from str start '\\n')\n with Not_found -> None\n\n let get_substring str index end_pos_opt =\n let end_pos =\n match end_pos_opt with\n | None -> String.length str\n | Some end_pos -> end_pos\n in\n String.sub str ~pos:index ~len:(end_pos - index)\n\n let is_one_line str =\n match index_of_newline str 0 with\n | None -> true\n | Some index -> index + 1 = String.length str\n\n let pp_hum_maybe_esc_str ppf str =\n if not (must_escape str) then\n pp_print_string ppf str\n else if is_one_line str then\n pp_print_string ppf (esc_str str)\n else begin\n let rec loop index =\n let next_newline = index_of_newline str index in\n let next_line = get_substring str index next_newline in\n pp_print_string ppf (escaped next_line);\n match next_newline with\n | None -> ()\n | Some newline_index ->\n pp_print_string ppf \"\\\\\";\n pp_force_newline ppf ();\n pp_print_string ppf \"\\\\n\";\n loop (newline_index + 1)\n in\n pp_open_box ppf 0;\n (* the leading space is to line up the lines *)\n pp_print_string ppf \" \\\"\";\n loop 0;\n pp_print_string ppf \"\\\"\";\n pp_close_box ppf ();\n end\n\n let mach_maybe_esc_str str =\n if must_escape str then esc_str str else str\n\n (* Output of S-expressions to formatters *)\n\n let rec pp_hum_indent indent ppf = function\n | Atom str -> pp_hum_maybe_esc_str ppf str\n | List (h :: t) ->\n pp_open_box ppf indent;\n pp_print_string ppf \"(\";\n pp_hum_indent indent ppf h;\n pp_hum_rest indent ppf t\n | List [] -> pp_print_string ppf \"()\"\n\n and pp_hum_rest indent ppf = function\n | h :: t ->\n pp_print_space ppf ();\n pp_hum_indent indent ppf h;\n pp_hum_rest indent ppf t\n | [] ->\n pp_print_string ppf \")\";\n pp_close_box ppf ()\n\n let rec pp_mach_internal may_need_space ppf = function\n | Atom str ->\n let str' = mach_maybe_esc_str str in\n let new_may_need_space = str' == str in\n if may_need_space && new_may_need_space then pp_print_string ppf \" \";\n pp_print_string ppf str';\n new_may_need_space\n | List (h :: t) ->\n pp_print_string ppf \"(\";\n let may_need_space = pp_mach_internal false ppf h in\n pp_mach_rest may_need_space ppf t;\n false\n | List [] -> pp_print_string ppf \"()\"; false\n\n and pp_mach_rest may_need_space ppf = function\n | h :: t ->\n let may_need_space = pp_mach_internal may_need_space ppf h in\n pp_mach_rest may_need_space ppf t\n | [] -> pp_print_string ppf \")\"\n\n let pp_hum ppf sexp = pp_hum_indent !default_indent ppf sexp\n\n let pp_mach ppf sexp = ignore (pp_mach_internal false ppf sexp)\n let pp = pp_mach\n\n (* Sexp size *)\n\n let rec size_loop (v, c as acc) = function\n | Atom str -> v + 1, c + String.length str\n | List lst -> List.fold_left lst ~init:acc ~f:size_loop\n\n let size sexp = size_loop (0, 0) sexp\n\n (* Buffer conversions *)\n\n let to_buffer_hum ~buf ?(indent = !default_indent) sexp =\n let ppf = Format.formatter_of_buffer buf in\n Format.fprintf ppf \"%a@?\" (pp_hum_indent indent) sexp\n\n let to_buffer_mach ~buf sexp =\n let rec loop may_need_space = function\n | Atom str ->\n let str' = mach_maybe_esc_str str in\n let new_may_need_space = str' == str in\n if may_need_space && new_may_need_space then Buffer.add_char buf ' ';\n Buffer.add_string buf str';\n new_may_need_space\n | List (h :: t) ->\n Buffer.add_char buf '(';\n let may_need_space = loop false h in\n loop_rest may_need_space t;\n false\n | List [] -> Buffer.add_string buf \"()\"; false\n and loop_rest may_need_space = function\n | h :: t ->\n let may_need_space = loop may_need_space h in\n loop_rest may_need_space t\n | [] -> Buffer.add_char buf ')' in\n ignore (loop false sexp)\n\n let to_buffer = to_buffer_mach\n\n let to_buffer_gen ~buf ~add_char ~add_string sexp =\n let rec loop may_need_space = function\n | Atom str ->\n let str' = mach_maybe_esc_str str in\n let new_may_need_space = str' == str in\n if may_need_space && new_may_need_space then add_char buf ' ';\n add_string buf str';\n new_may_need_space\n | List (h :: t) ->\n add_char buf '(';\n let may_need_space = loop false h in\n loop_rest may_need_space t;\n false\n | List [] -> add_string buf \"()\"; false\n and loop_rest may_need_space = function\n | h :: t ->\n let may_need_space = loop may_need_space h in\n loop_rest may_need_space t\n | [] -> add_char buf ')' in\n ignore (loop false sexp)\n\n (* The maximum size of a thing on the minor heap is 256 words.\n Previously, this size of the returned buffer here was 4096 bytes, which\n caused the Buffer to be allocated on the *major* heap every time.\n\n According to a simple benchmark by Ron, we can improve performance for\n small s-expressions by a factor of ~4 if we only allocate 1024 bytes\n (128 words + some small overhead) worth of buffer initially. And one\n can argue that if it's free to allocate strings smaller than 256 words,\n large s-expressions requiring larger expensive buffers won't notice\n the extra two doublings from 1024 bytes to 2048 and 4096. And especially\n performance-sensitive applications to always pass in a larger buffer to\n use. *)\n let buffer () = Buffer.create 1024\n\n (* String conversions *)\n\n let to_string_hum ?indent = function\n | Atom str when (match index_of_newline str 0 with None -> true | Some _ -> false) ->\n mach_maybe_esc_str str\n | sexp ->\n let buf = buffer () in\n to_buffer_hum ?indent sexp ~buf;\n Buffer.contents buf\n\n let to_string_mach = function\n | Atom str -> mach_maybe_esc_str str\n | sexp ->\n let buf = buffer () in\n to_buffer_mach sexp ~buf;\n Buffer.contents buf\n\n let to_string = to_string_mach\nend\ninclude Printing\n\nlet of_float_style : [ `Underscores | `No_underscores ] ref = ref `No_underscores\nlet of_int_style : [ `Underscores | `No_underscores ] ref = ref `No_underscores\n\nmodule Private = struct\n include Printing\n\n module Raw_grammar = struct\n include Raw_grammar\n\n module Builtin = struct\n let unit_sexp_grammar = Inline (List [])\n let bool_sexp_grammar = Inline (Atom Bool)\n let string_sexp_grammar = Inline (Atom String)\n let bytes_sexp_grammar = string_sexp_grammar\n let char_sexp_grammar = Inline (Atom Char)\n let int_sexp_grammar = Inline (Atom Int)\n let float_sexp_grammar = Inline (Atom Float)\n let int32_sexp_grammar = Inline (Atom Int)\n let int64_sexp_grammar = Inline (Atom Int)\n let nativeint_sexp_grammar = Inline (Atom Int)\n let ref_sexp_grammar = Inline (Explicit_bind ([ \"'a\" ], Explicit_var 0))\n let lazy_t_sexp_grammar = Inline (Explicit_bind ([ \"'a\" ], Explicit_var 0))\n let option_sexp_grammar = Inline (Explicit_bind ([ \"'a\" ], Option (Explicit_var 0)))\n\n let list_sexp_grammar =\n Inline (Explicit_bind ([ \"'a\" ], List [ Many (Explicit_var 0) ]))\n ;;\n\n let array_sexp_grammar = list_sexp_grammar\n end\n\n let empty_sexp_grammar = Inline (Union [])\n let opaque_sexp_grammar = empty_sexp_grammar\n let fun_sexp_grammar = empty_sexp_grammar\n let tuple2_sexp_grammar =\n Inline\n (Explicit_bind\n ([ \"'a\"; \"'b\" ], List [ One (Explicit_var 0); One (Explicit_var 1) ]))\n ;;\n end\nend\n\nlet message name fields =\n let rec conv_fields = function\n | [] -> []\n | (fname, fsexp) :: rest ->\n match fname with\n | \"\" -> fsexp :: conv_fields rest\n | _ -> List [ Atom fname; fsexp ] :: conv_fields rest\n in\n List (Atom name :: conv_fields fields)\n","(* Utility Module for S-expression Conversions *)\nlet polymorphic_compare = compare\nopen StdLabels\nopen MoreLabels\nopen Printf\nopen Sexp\n\ntype sexp_bool = bool\ntype 'a sexp_option = 'a option\ntype 'a sexp_list = 'a list\ntype 'a sexp_array = 'a array\ntype 'a sexp_opaque = 'a\n\n(* Conversion of OCaml-values to S-expressions *)\nexternal format_float : string -> float -> string = \"caml_format_float\"\n\n(* '%.17g' is guaranteed to be round-trippable.\n\n '%.15g' will be round-trippable and not have noise at the last digit or two for a float\n which was converted from a decimal (string) with <= 15 significant digits. So it's\n worth trying first to avoid things like \"3.1400000000000001\".\n\n See comment above [to_string_round_trippable] in {!Core_kernel.Float} for\n detailed explanation and examples. *)\nlet default_string_of_float =\n ref (fun x ->\n let y = format_float \"%.15G\" x in\n if (float_of_string y) = x then\n y\n else\n format_float \"%.17G\" x)\n;;\n\nlet read_old_option_format = ref true\nlet write_old_option_format = ref true\n\nlet list_map f l = List.rev (List.rev_map l ~f)\n\nlet sexp_of_unit () = List []\nlet sexp_of_bool b = Atom (string_of_bool b)\nlet sexp_of_string str = Atom str\nlet sexp_of_bytes bytes = Atom (Bytes.to_string bytes)\nlet sexp_of_char c = Atom (String.make 1 c)\nlet sexp_of_int n = Atom (string_of_int n)\nlet sexp_of_float n = Atom (!default_string_of_float n)\nlet sexp_of_int32 n = Atom (Int32.to_string n)\nlet sexp_of_int64 n = Atom (Int64.to_string n)\nlet sexp_of_nativeint n = Atom (Nativeint.to_string n)\nlet sexp_of_ref sexp_of__a rf = sexp_of__a !rf\nlet sexp_of_lazy_t sexp_of__a lv = sexp_of__a (Lazy.force lv)\n\nlet sexp_of_option sexp_of__a = function\n | Some x when !write_old_option_format -> List [sexp_of__a x]\n | Some x -> List [Atom \"some\"; sexp_of__a x]\n | None when !write_old_option_format -> List []\n | None -> Atom \"none\"\n\nlet sexp_of_pair sexp_of__a sexp_of__b (a, b) =\n List [sexp_of__a a; sexp_of__b b]\n\nlet sexp_of_triple sexp_of__a sexp_of__b sexp_of__c (a, b, c) =\n List [sexp_of__a a; sexp_of__b b; sexp_of__c c]\n\n(* List.rev (List.rev_map ...) is tail recursive, the OCaml standard\n library List.map is NOT. *)\nlet sexp_of_list sexp_of__a lst = List (List.rev (List.rev_map lst ~f:sexp_of__a))\n\nlet sexp_of_array sexp_of__a ar =\n let lst_ref = ref [] in\n for i = Array.length ar - 1 downto 0 do\n lst_ref := sexp_of__a ar.(i) :: !lst_ref\n done;\n List !lst_ref\n\nlet sexp_of_hashtbl sexp_of_key sexp_of_val htbl =\n let coll ~key:k ~data:v acc = List [sexp_of_key k; sexp_of_val v] :: acc in\n List (Hashtbl.fold htbl ~init:[] ~f:coll)\n\nlet sexp_of_opaque _ = Atom \"\"\nlet sexp_of_fun _ = Atom \"\"\n\n\n(* Exception converter registration and lookup *)\n\nmodule Exn_converter = struct\n (* These exception registration functions assume that context-switches\n cannot happen unless there is an allocation. It is reasonable to expect\n that this will remain true for the foreseeable future. That way we\n avoid using mutexes and thus a dependency on the threads library. *)\n\n (* Fast and automatic exception registration *)\n\n module Int = struct\n type t = int\n\n let compare t1 t2 = polymorphic_compare (t1 : int) t2\n end\n\n module Exn_ids = Map.Make (Int)\n\n module Obj = struct\n module Extension_constructor = struct\n [@@@ocaml.warning \"-3\"]\n type t = extension_constructor\n let id = Obj.extension_id\n let of_val = Obj.extension_constructor\n end\n end\n\n let exn_id_map\n : (Obj.Extension_constructor.t, exn -> Sexp.t) Ephemeron.K1.t Exn_ids.t ref =\n ref Exn_ids.empty\n\n (* [Obj.extension_id] works on both the exception itself, and the extension slot of the\n exception. *)\n let rec clean_up_handler (slot : Obj.Extension_constructor.t) =\n let id = Obj.Extension_constructor.id slot in\n let old_exn_id_map = !exn_id_map in\n let new_exn_id_map = Exn_ids.remove id old_exn_id_map in\n (* This trick avoids mutexes and should be fairly efficient *)\n if !exn_id_map != old_exn_id_map then\n clean_up_handler slot\n else\n exn_id_map := new_exn_id_map\n\n (* Ephemerons are used so that [sexp_of_exn] closure don't keep the\n extension_constructor live. *)\n let add ?(finalise = true) extension_constructor sexp_of_exn =\n let id = Obj.Extension_constructor.id extension_constructor in\n let rec loop () =\n let old_exn_id_map = !exn_id_map in\n let ephe = Ephemeron.K1.create () in\n Ephemeron.K1.set_data ephe sexp_of_exn;\n Ephemeron.K1.set_key ephe extension_constructor;\n let new_exn_id_map = Exn_ids.add old_exn_id_map ~key:id ~data:ephe in\n (* This trick avoids mutexes and should be fairly efficient *)\n if !exn_id_map != old_exn_id_map then\n loop ()\n else begin\n exn_id_map := new_exn_id_map;\n if finalise then\n try\n Gc.finalise clean_up_handler extension_constructor\n with Invalid_argument _ ->\n (* Pre-allocated extension constructors cannot be finalised *)\n ()\n end\n in\n loop ()\n\n let add_auto ?finalise exn sexp_of_exn =\n add ?finalise (Obj.Extension_constructor.of_val exn) sexp_of_exn\n\n let find_auto exn =\n let id = Obj.Extension_constructor.id (Obj.Extension_constructor.of_val exn) in\n match Exn_ids.find id !exn_id_map with\n | exception Not_found -> None\n | ephe ->\n match Ephemeron.K1.get_data ephe with\n | None -> None\n | Some sexp_of_exn -> Some (sexp_of_exn exn)\n\n\n module For_unit_tests_only = struct\n let size () = Exn_ids.fold !exn_id_map ~init:0 ~f:(fun ~key:_ ~data:ephe acc ->\n match Ephemeron.K1.get_data ephe with\n | None -> acc\n | Some _ -> acc + 1\n )\n end\n\nend\n\nlet sexp_of_exn_opt exn = Exn_converter.find_auto exn\n\n\nlet sexp_of_exn exn =\n match sexp_of_exn_opt exn with\n | None -> List [Atom (Printexc.to_string exn)]\n | Some sexp -> sexp\n\nlet exn_to_string e = Sexp.to_string_hum (sexp_of_exn e)\n\n(* {[exception Blah [@@deriving sexp]]} generates a call to the function\n [Exn_converter.add] defined in this file. So we are guaranted that as soon as we\n mark an exception as sexpable, this module will be linked in and this printer will be\n registered, which is what we want. *)\nlet () =\n Printexc.register_printer (fun exn ->\n match sexp_of_exn_opt exn with\n | None -> None\n | Some sexp ->\n Some (Sexp.to_string_hum ~indent:2 sexp))\n\n(* Conversion of S-expressions to OCaml-values *)\n\nexception Of_sexp_error = Sexp.Of_sexp_error\n\nlet record_check_extra_fields = ref true\n\nlet of_sexp_error_exn exc sexp = raise (Of_sexp_error (exc, sexp))\n\nlet of_sexp_error what sexp = raise (Of_sexp_error (Failure what, sexp))\n\nlet unit_of_sexp sexp = match sexp with\n | List [] -> ()\n | Atom _ | List _ -> of_sexp_error \"unit_of_sexp: empty list needed\" sexp\n\nlet bool_of_sexp sexp = match sexp with\n | Atom (\"true\" | \"True\") -> true\n | Atom (\"false\" | \"False\") -> false\n | Atom _ -> of_sexp_error \"bool_of_sexp: unknown string\" sexp\n | List _ -> of_sexp_error \"bool_of_sexp: atom needed\" sexp\n\nlet string_of_sexp sexp = match sexp with\n | Atom str -> str\n | List _ -> of_sexp_error \"string_of_sexp: atom needed\" sexp\n\nlet bytes_of_sexp sexp = match sexp with\n | Atom str -> Bytes.of_string str\n | List _ -> of_sexp_error \"bytes_of_sexp: atom needed\" sexp\n\n\nlet char_of_sexp sexp = match sexp with\n | Atom str ->\n if String.length str <> 1 then\n of_sexp_error\n \"char_of_sexp: atom string must contain one character only\" sexp;\n str.[0]\n | List _ -> of_sexp_error \"char_of_sexp: atom needed\" sexp\n\nlet int_of_sexp sexp = match sexp with\n | Atom str ->\n (try int_of_string str\n with exc -> of_sexp_error (\"int_of_sexp: \" ^ exn_to_string exc) sexp)\n | List _ -> of_sexp_error \"int_of_sexp: atom needed\" sexp\n\nlet float_of_sexp sexp = match sexp with\n | Atom str ->\n (try float_of_string str\n with exc ->\n of_sexp_error (\"float_of_sexp: \" ^ exn_to_string exc) sexp)\n | List _ -> of_sexp_error \"float_of_sexp: atom needed\" sexp\n\nlet int32_of_sexp sexp = match sexp with\n | Atom str ->\n (try Int32.of_string str\n with exc ->\n of_sexp_error (\"int32_of_sexp: \" ^ exn_to_string exc) sexp)\n | List _ -> of_sexp_error \"int32_of_sexp: atom needed\" sexp\n\nlet int64_of_sexp sexp = match sexp with\n | Atom str ->\n (try Int64.of_string str\n with exc ->\n of_sexp_error (\"int64_of_sexp: \" ^ exn_to_string exc) sexp)\n | List _ -> of_sexp_error \"int64_of_sexp: atom needed\" sexp\n\nlet nativeint_of_sexp sexp = match sexp with\n | Atom str ->\n (try Nativeint.of_string str\n with exc ->\n of_sexp_error (\"nativeint_of_sexp: \" ^ exn_to_string exc) sexp)\n | List _ -> of_sexp_error \"nativeint_of_sexp: atom needed\" sexp\n\nlet ref_of_sexp a__of_sexp sexp = ref (a__of_sexp sexp)\nlet lazy_t_of_sexp a__of_sexp sexp = Lazy.from_val (a__of_sexp sexp)\n\nlet option_of_sexp a__of_sexp sexp =\n if !read_old_option_format then\n match sexp with\n | List [] | Atom (\"none\" | \"None\") -> None\n | List [el] | List [Atom (\"some\" | \"Some\"); el] -> Some (a__of_sexp el)\n | List _ ->\n of_sexp_error \"option_of_sexp: list must represent optional value\" sexp\n | Atom _ -> of_sexp_error \"option_of_sexp: only none can be atom\" sexp\n else\n match sexp with\n | Atom (\"none\" | \"None\") -> None\n | List [Atom (\"some\" | \"Some\"); el] -> Some (a__of_sexp el)\n | Atom _ -> of_sexp_error \"option_of_sexp: only none can be atom\" sexp\n | List _ -> of_sexp_error \"option_of_sexp: list must be (some el)\" sexp\n\nlet pair_of_sexp a__of_sexp b__of_sexp sexp = match sexp with\n | List [a_sexp; b_sexp] ->\n let a = a__of_sexp a_sexp in\n let b = b__of_sexp b_sexp in\n a, b\n | List _ ->\n of_sexp_error\n \"pair_of_sexp: list must contain exactly two elements only\" sexp\n | Atom _ -> of_sexp_error \"pair_of_sexp: list needed\" sexp\n\nlet triple_of_sexp a__of_sexp b__of_sexp c__of_sexp sexp = match sexp with\n | List [a_sexp; b_sexp; c_sexp] ->\n let a = a__of_sexp a_sexp in\n let b = b__of_sexp b_sexp in\n let c = c__of_sexp c_sexp in\n a, b, c\n | List _ ->\n of_sexp_error\n \"triple_of_sexp: list must contain exactly three elements only\" sexp\n | Atom _ -> of_sexp_error \"triple_of_sexp: list needed\" sexp\n\nlet list_of_sexp a__of_sexp sexp = match sexp with\n | List lst ->\n let rev_lst = List.rev_map lst ~f:a__of_sexp in\n List.rev rev_lst\n | Atom _ -> of_sexp_error \"list_of_sexp: list needed\" sexp\n\nlet array_of_sexp a__of_sexp sexp = match sexp with\n | List [] -> [||]\n | List (h :: t) ->\n let len = List.length t + 1 in\n let res = Array.make len (a__of_sexp h) in\n let rec loop i = function\n | [] -> res\n | h :: t -> res.(i) <- a__of_sexp h; loop (i + 1) t in\n loop 1 t\n | Atom _ -> of_sexp_error \"array_of_sexp: list needed\" sexp\n\nlet hashtbl_of_sexp key_of_sexp val_of_sexp sexp = match sexp with\n | List lst ->\n let htbl = Hashtbl.create 0 in\n let act = function\n | List [k_sexp; v_sexp] ->\n Hashtbl.add htbl ~key:(key_of_sexp k_sexp) ~data:(val_of_sexp v_sexp)\n | List _ | Atom _ ->\n of_sexp_error \"hashtbl_of_sexp: tuple list needed\" sexp\n in\n List.iter lst ~f:act;\n htbl\n | Atom _ -> of_sexp_error \"hashtbl_of_sexp: list needed\" sexp\n\nlet opaque_of_sexp sexp =\n of_sexp_error \"opaque_of_sexp: cannot convert opaque values\" sexp\n\nlet fun_of_sexp sexp =\n of_sexp_error \"fun_of_sexp: cannot convert function values\" sexp\n\n(* Registering default exception printers *)\n\nlet get_flc_error name (file, line, chr) =\n Atom (sprintf \"%s %s:%d:%d\" name file line chr)\n\nlet () =\n List.iter\n ~f:(fun (extension_constructor, handler) -> Exn_converter.add ~finalise:false extension_constructor handler)\n [\n (\n [%extension_constructor Assert_failure],\n (function\n | Assert_failure arg -> get_flc_error \"Assert_failure\" arg\n | _ -> assert false)\n );(\n [%extension_constructor Exit],\n (function\n | Exit -> Atom \"Exit\"\n | _ -> assert false)\n );(\n [%extension_constructor End_of_file],\n (function\n | End_of_file -> Atom \"End_of_file\"\n | _ -> assert false)\n );(\n [%extension_constructor Failure],\n (function\n | Failure arg -> List [Atom \"Failure\"; Atom arg ]\n | _ -> assert false)\n );(\n [%extension_constructor Not_found],\n (function\n | Not_found -> Atom \"Not_found\"\n | _ -> assert false)\n );(\n [%extension_constructor Invalid_argument],\n (function\n | Invalid_argument arg -> List [Atom \"Invalid_argument\"; Atom arg ]\n | _ -> assert false)\n );(\n [%extension_constructor Match_failure],\n (function\n | Match_failure arg -> get_flc_error \"Match_failure\" arg\n | _ -> assert false)\n );(\n [%extension_constructor Not_found_s],\n (function\n | Not_found_s arg -> List [Atom \"Not_found_s\"; arg ]\n | _ -> assert false)\n );(\n [%extension_constructor Sys_error],\n (function\n | Sys_error arg -> List [Atom \"Sys_error\"; Atom arg ]\n | _ -> assert false)\n );(\n [%extension_constructor Arg.Help],\n (function\n | Arg.Help arg -> List [Atom \"Arg.Help\"; Atom arg ]\n | _ -> assert false)\n );(\n [%extension_constructor Arg.Bad],\n (function\n | Arg.Bad arg -> List [Atom \"Arg.Bad\"; Atom arg ]\n | _ -> assert false)\n );(\n [%extension_constructor Lazy.Undefined],\n (function\n | Lazy.Undefined -> Atom \"Lazy.Undefined\"\n | _ -> assert false)\n );(\n [%extension_constructor Parsing.Parse_error],\n (function\n | Parsing.Parse_error -> Atom \"Parsing.Parse_error\"\n | _ -> assert false)\n );(\n [%extension_constructor Queue.Empty],\n (function\n | Queue.Empty -> Atom \"Queue.Empty\"\n | _ -> assert false)\n );(\n [%extension_constructor Scanf.Scan_failure],\n (function\n | Scanf.Scan_failure arg -> List [Atom \"Scanf.Scan_failure\"; Atom arg ]\n | _ -> assert false)\n );(\n [%extension_constructor Stack.Empty],\n (function\n | Stack.Empty -> Atom \"Stack.Empty\"\n | _ -> assert false)\n );(\n [%extension_constructor Stream.Failure],\n (function\n | Stream.Failure -> Atom \"Stream.Failure\"\n | _ -> assert false)\n );(\n [%extension_constructor Stream.Error],\n (function\n | Stream.Error arg -> List [Atom \"Stream.Error\"; Atom arg ]\n | _ -> assert false)\n );(\n [%extension_constructor Sys.Break],\n (function\n | Sys.Break -> Atom \"Sys.Break\"\n | _ -> assert false)\n );(\n [%extension_constructor Of_sexp_error],\n (function\n | Of_sexp_error (exc, sexp) ->\n List [Atom \"Sexplib.Conv.Of_sexp_error\"; sexp_of_exn exc; sexp]\n | _ -> assert false)\n );\n ]\n\nexternal ignore : _ -> unit = \"%ignore\"\nexternal ( = ) : 'a -> 'a -> bool = \"%equal\"\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Damien Doligez, projet Para, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1997 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n[@@@ocaml.warning \"-32\"]\n\nmodule type SeededS = sig\n\n type key\n type !'a t\n val create : ?random (*thwart tools/sync_stdlib_docs*) : bool -> int -> 'a t\n val clear : 'a t -> unit\n val reset : 'a t -> unit\n val copy : 'a t -> 'a t\n val add : 'a t -> key -> 'a -> unit\n val remove : 'a t -> key -> unit\n val find : 'a t -> key -> 'a\n val find_opt : 'a t -> key -> 'a option\n val find_all : 'a t -> key -> 'a list\n val replace : 'a t -> key -> 'a -> unit\n val mem : 'a t -> key -> bool\n val iter : (key -> 'a -> unit) -> 'a t -> unit\n [@@alert old_ephemeron_api \"This function won't be available in 5.0\"]\n val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit\n [@@alert old_ephemeron_api \"This function won't be available in 5.0\"]\n val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b\n [@@alert old_ephemeron_api \"This function won't be available in 5.0\"]\n val length : 'a t -> int\n val stats : 'a t -> Hashtbl.statistics\n val to_seq : 'a t -> (key * 'a) Seq.t\n [@@alert old_ephemeron_api \"This function won't be available in 5.0\"]\n val to_seq_keys : _ t -> key Seq.t\n [@@alert old_ephemeron_api \"This function won't be available in 5.0\"]\n val to_seq_values : 'a t -> 'a Seq.t\n [@@alert old_ephemeron_api \"This function won't be available in 5.0\"]\n val add_seq : 'a t -> (key * 'a) Seq.t -> unit\n val replace_seq : 'a t -> (key * 'a) Seq.t -> unit\n val of_seq : (key * 'a) Seq.t -> 'a t\n val clean: 'a t -> unit\n val stats_alive: 'a t -> Hashtbl.statistics\n (** same as {!stats} but only count the alive bindings *)\nend\n\nmodule type S = sig\n\n type key\n type !'a t\n val create : int -> 'a t\n val clear : 'a t -> unit\n val reset : 'a t -> unit\n val copy : 'a t -> 'a t\n val add : 'a t -> key -> 'a -> unit\n val remove : 'a t -> key -> unit\n val find : 'a t -> key -> 'a\n val find_opt : 'a t -> key -> 'a option\n val find_all : 'a t -> key -> 'a list\n val replace : 'a t -> key -> 'a -> unit\n val mem : 'a t -> key -> bool\n val iter : (key -> 'a -> unit) -> 'a t -> unit\n [@@alert old_ephemeron_api \"This function won't be available in 5.0\"]\n val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit\n [@@alert old_ephemeron_api \"This function won't be available in 5.0\"]\n val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b\n [@@alert old_ephemeron_api \"This function won't be available in 5.0\"]\n val length : 'a t -> int\n val stats : 'a t -> Hashtbl.statistics\n val to_seq : 'a t -> (key * 'a) Seq.t\n [@@alert old_ephemeron_api \"This function won't be available in 5.0\"]\n val to_seq_keys : _ t -> key Seq.t\n [@@alert old_ephemeron_api \"This function won't be available in 5.0\"]\n val to_seq_values : 'a t -> 'a Seq.t\n [@@alert old_ephemeron_api \"This function won't be available in 5.0\"]\n val add_seq : 'a t -> (key * 'a) Seq.t -> unit\n val replace_seq : 'a t -> (key * 'a) Seq.t -> unit\n val of_seq : (key * 'a) Seq.t -> 'a t\n val clean: 'a t -> unit\n val stats_alive: 'a t -> Hashtbl.statistics\n (** same as {!stats} but only count the alive bindings *)\nend\n\nmodule GenHashTable = struct\n\n type equal =\n | ETrue | EFalse\n | EDead (** the garbage collector reclaimed the data *)\n\n module MakeSeeded(H: sig\n type t\n type 'a container\n val create: t -> 'a -> 'a container\n val hash: int -> t -> int\n val equal: 'a container -> t -> equal\n val get_data: 'a container -> 'a option\n val get_key: 'a container -> t option\n val set_key_data: 'a container -> t -> 'a -> unit\n val check_key: 'a container -> bool\n end) : SeededS with type key = H.t\n = struct\n\n type 'a t =\n { mutable size: int; (* number of entries *)\n mutable data: 'a bucketlist array; (* the buckets *)\n seed: int; (* for randomization *)\n initial_size: int; (* initial array size *)\n }\n\n and 'a bucketlist =\n | Empty\n | Cons of int (* hash of the key *) * 'a H.container * 'a bucketlist\n\n (** the hash of the key is kept in order to test the equality of the hash\n before the key. Same reason as for Weak.Make *)\n\n type key = H.t\n\n let rec power_2_above x n =\n if x >= n then x\n else if x * 2 > Sys.max_array_length then x\n else power_2_above (x * 2) n\n\n let prng = lazy (Random.State.make_self_init())\n\n let create ?(random = (Hashtbl.is_randomized ())) initial_size =\n let s = power_2_above 16 initial_size in\n let seed = if random then Random.State.bits (Lazy.force prng) else 0 in\n { initial_size = s; size = 0; seed = seed; data = Array.make s Empty }\n\n let clear h =\n h.size <- 0;\n let len = Array.length h.data in\n for i = 0 to len - 1 do\n h.data.(i) <- Empty\n done\n\n let reset h =\n let len = Array.length h.data in\n if len = h.initial_size then\n clear h\n else begin\n h.size <- 0;\n h.data <- Array.make h.initial_size Empty\n end\n\n let copy h = { h with data = Array.copy h.data }\n\n let key_index h hkey =\n hkey land (Array.length h.data - 1)\n\n let clean h =\n let rec do_bucket = function\n | Empty ->\n Empty\n | Cons(_, c, rest) when not (H.check_key c) ->\n h.size <- h.size - 1;\n do_bucket rest\n | Cons(hkey, c, rest) ->\n Cons(hkey, c, do_bucket rest)\n in\n let d = h.data in\n for i = 0 to Array.length d - 1 do\n d.(i) <- do_bucket d.(i)\n done\n\n (** resize is the only function to do the actual cleaning of dead keys\n (remove does it just because it could).\n\n The goal is to:\n\n - not resize infinitely when the actual number of alive keys is\n bounded but keys are continuously added. That would happen if\n this function always resize.\n - not call this function after each addition, that would happen if this\n function don't resize even when only one key is dead.\n\n So the algorithm:\n - clean the keys before resizing\n - if the number of remaining keys is less than half the size of the\n array, don't resize.\n - if it is more, resize.\n\n The second problem remains if the table reaches {!Sys.max_array_length}.\n\n *)\n let resize h =\n let odata = h.data in\n let osize = Array.length odata in\n let nsize = osize * 2 in\n clean h;\n if nsize < Sys.max_array_length && h.size >= osize lsr 1 then begin\n let ndata = Array.make nsize Empty in\n h.data <- ndata; (* so that key_index sees the new bucket count *)\n let rec insert_bucket = function\n Empty -> ()\n | Cons(hkey, data, rest) ->\n insert_bucket rest; (* preserve original order of elements *)\n let nidx = key_index h hkey in\n ndata.(nidx) <- Cons(hkey, data, ndata.(nidx)) in\n for i = 0 to osize - 1 do\n insert_bucket odata.(i)\n done\n end\n\n let add h key info =\n let hkey = H.hash h.seed key in\n let i = key_index h hkey in\n let container = H.create key info in\n let bucket = Cons(hkey, container, h.data.(i)) in\n h.data.(i) <- bucket;\n h.size <- h.size + 1;\n if h.size > Array.length h.data lsl 1 then resize h\n\n let remove h key =\n let hkey = H.hash h.seed key in\n let rec remove_bucket = function\n | Empty -> Empty\n | Cons(hk, c, next) when hkey = hk ->\n begin match H.equal c key with\n | ETrue -> h.size <- h.size - 1; next\n | EFalse -> Cons(hk, c, remove_bucket next)\n | EDead ->\n (* The dead key is automatically removed. It is acceptable\n for this function since it already removes a binding *)\n h.size <- h.size - 1;\n remove_bucket next\n end\n | Cons(hk,c,next) -> Cons(hk, c, remove_bucket next) in\n let i = key_index h hkey in\n h.data.(i) <- remove_bucket h.data.(i)\n\n (** {!find} don't remove dead keys because it would be surprising for\n the user that a read-only function mutates the state (eg. concurrent\n access). Same for {!iter}, {!fold}, {!mem}.\n *)\n let rec find_rec key hkey = function\n | Empty ->\n raise Not_found\n | Cons(hk, c, rest) when hkey = hk ->\n begin match H.equal c key with\n | ETrue ->\n begin match H.get_data c with\n | None ->\n (* This case is not impossible because the gc can run between\n H.equal and H.get_data *)\n find_rec key hkey rest\n | Some d -> d\n end\n | EFalse -> find_rec key hkey rest\n | EDead ->\n find_rec key hkey rest\n end\n | Cons(_, _, rest) ->\n find_rec key hkey rest\n\n let find h key =\n let hkey = H.hash h.seed key in\n (* TODO inline 3 iterations *)\n find_rec key hkey (h.data.(key_index h hkey))\n\n let rec find_rec_opt key hkey = function\n | Empty ->\n None\n | Cons(hk, c, rest) when hkey = hk ->\n begin match H.equal c key with\n | ETrue ->\n begin match H.get_data c with\n | None ->\n (* This case is not impossible because the gc can run between\n H.equal and H.get_data *)\n find_rec_opt key hkey rest\n | Some _ as d -> d\n end\n | EFalse -> find_rec_opt key hkey rest\n | EDead ->\n find_rec_opt key hkey rest\n end\n | Cons(_, _, rest) ->\n find_rec_opt key hkey rest\n\n let find_opt h key =\n let hkey = H.hash h.seed key in\n (* TODO inline 3 iterations *)\n find_rec_opt key hkey (h.data.(key_index h hkey))\n\n let find_all h key =\n let hkey = H.hash h.seed key in\n let rec find_in_bucket = function\n | Empty -> []\n | Cons(hk, c, rest) when hkey = hk ->\n begin match H.equal c key with\n | ETrue -> begin match H.get_data c with\n | None ->\n find_in_bucket rest\n | Some d -> d::find_in_bucket rest\n end\n | EFalse -> find_in_bucket rest\n | EDead ->\n find_in_bucket rest\n end\n | Cons(_, _, rest) ->\n find_in_bucket rest in\n find_in_bucket h.data.(key_index h hkey)\n\n\n let replace h key info =\n let hkey = H.hash h.seed key in\n let rec replace_bucket = function\n | Empty -> raise Not_found\n | Cons(hk, c, next) when hkey = hk ->\n begin match H.equal c key with\n | ETrue -> H.set_key_data c key info\n | EFalse | EDead -> replace_bucket next\n end\n | Cons(_,_,next) -> replace_bucket next\n in\n let i = key_index h hkey in\n let l = h.data.(i) in\n try\n replace_bucket l\n with Not_found ->\n let container = H.create key info in\n h.data.(i) <- Cons(hkey, container, l);\n h.size <- h.size + 1;\n if h.size > Array.length h.data lsl 1 then resize h\n\n let mem h key =\n let hkey = H.hash h.seed key in\n let rec mem_in_bucket = function\n | Empty ->\n false\n | Cons(hk, c, rest) when hk = hkey ->\n begin match H.equal c key with\n | ETrue -> true\n | EFalse | EDead -> mem_in_bucket rest\n end\n | Cons(_hk, _c, rest) -> mem_in_bucket rest in\n mem_in_bucket h.data.(key_index h hkey)\n\n let iter f h =\n let rec do_bucket = function\n | Empty ->\n ()\n | Cons(_, c, rest) ->\n begin match H.get_key c, H.get_data c with\n | None, _ | _, None -> ()\n | Some k, Some d -> f k d\n end; do_bucket rest in\n let d = h.data in\n for i = 0 to Array.length d - 1 do\n do_bucket d.(i)\n done\n\n let fold f h init =\n let rec do_bucket b accu =\n match b with\n Empty ->\n accu\n | Cons(_, c, rest) ->\n let accu = begin match H.get_key c, H.get_data c with\n | None, _ | _, None -> accu\n | Some k, Some d -> f k d accu\n end in\n do_bucket rest accu in\n let d = h.data in\n let accu = ref init in\n for i = 0 to Array.length d - 1 do\n accu := do_bucket d.(i) !accu\n done;\n !accu\n\n let filter_map_inplace f h =\n let rec do_bucket = function\n | Empty ->\n Empty\n | Cons(hk, c, rest) ->\n match H.get_key c, H.get_data c with\n | None, _ | _, None ->\n do_bucket rest\n | Some k, Some d ->\n match f k d with\n | None ->\n do_bucket rest\n | Some new_d ->\n H.set_key_data c k new_d;\n Cons(hk, c, do_bucket rest)\n in\n let d = h.data in\n for i = 0 to Array.length d - 1 do\n d.(i) <- do_bucket d.(i)\n done\n\n let length h = h.size\n\n let rec bucket_length accu = function\n | Empty -> accu\n | Cons(_, _, rest) -> bucket_length (accu + 1) rest\n\n let stats h =\n let mbl =\n Array.fold_left (fun m b -> Int.max m (bucket_length 0 b)) 0 h.data in\n let histo = Array.make (mbl + 1) 0 in\n Array.iter\n (fun b ->\n let l = bucket_length 0 b in\n histo.(l) <- histo.(l) + 1)\n h.data;\n { Hashtbl.num_bindings = h.size;\n num_buckets = Array.length h.data;\n max_bucket_length = mbl;\n bucket_histogram = histo }\n\n let rec bucket_length_alive accu = function\n | Empty -> accu\n | Cons(_, c, rest) when H.check_key c ->\n bucket_length_alive (accu + 1) rest\n | Cons(_, _, rest) -> bucket_length_alive accu rest\n\n let stats_alive h =\n let size = ref 0 in\n let mbl =\n Array.fold_left\n (fun m b -> Int.max m (bucket_length_alive 0 b)) 0 h.data\n in\n let histo = Array.make (mbl + 1) 0 in\n Array.iter\n (fun b ->\n let l = bucket_length_alive 0 b in\n size := !size + l;\n histo.(l) <- histo.(l) + 1)\n h.data;\n { Hashtbl.num_bindings = !size;\n num_buckets = Array.length h.data;\n max_bucket_length = mbl;\n bucket_histogram = histo }\n\n let to_seq tbl =\n (* capture current array, so that even if the table is resized we\n keep iterating on the same array *)\n let tbl_data = tbl.data in\n (* state: index * next bucket to traverse *)\n let rec aux i buck () = match buck with\n | Empty ->\n if i = Array.length tbl_data\n then Seq.Nil\n else aux(i+1) tbl_data.(i) ()\n | Cons (_, c, next) ->\n begin match H.get_key c, H.get_data c with\n | None, _ | _, None -> aux i next ()\n | Some key, Some data ->\n Seq.Cons ((key, data), aux i next)\n end\n in\n aux 0 Empty\n\n let to_seq_keys m = Seq.map fst (to_seq m)\n\n let to_seq_values m = Seq.map snd (to_seq m)\n\n let add_seq tbl i =\n Seq.iter (fun (k,v) -> add tbl k v) i\n\n let replace_seq tbl i =\n Seq.iter (fun (k,v) -> replace tbl k v) i\n\n let of_seq i =\n let tbl = create 16 in\n replace_seq tbl i;\n tbl\n\n end\nend\n\nmodule ObjEph = Obj.Ephemeron\n\nlet _obj_opt : Obj.t option -> 'a option = fun x ->\n match x with\n | None -> x\n | Some v -> Some (Obj.obj v)\n\n(** The previous function is typed so this one is also correct *)\nlet obj_opt : Obj.t option -> 'a option = fun x -> Obj.magic x\n\n\nmodule K1 = struct\n type ('k,'d) t = ObjEph.t\n\n let create () : ('k,'d) t = ObjEph.create 1\n\n let get_key (t:('k,'d) t) : 'k option = obj_opt (ObjEph.get_key t 0)\n let get_key_copy (t:('k,'d) t) : 'k option = obj_opt (ObjEph.get_key_copy t 0)\n let set_key (t:('k,'d) t) (k:'k) : unit = ObjEph.set_key t 0 (Obj.repr k)\n let unset_key (t:('k,'d) t) : unit = ObjEph.unset_key t 0\n let check_key (t:('k,'d) t) : bool = ObjEph.check_key t 0\n\n let blit_key (t1:('k,'d) t) (t2:('k,'d) t): unit =\n ObjEph.blit_key t1 0 t2 0 1\n\n let get_data (t:('k,'d) t) : 'd option = obj_opt (ObjEph.get_data t)\n let get_data_copy (t:('k,'d) t) : 'd option = obj_opt (ObjEph.get_data_copy t)\n let set_data (t:('k,'d) t) (d:'d) : unit = ObjEph.set_data t (Obj.repr d)\n let unset_data (t:('k,'d) t) : unit = ObjEph.unset_data t\n let check_data (t:('k,'d) t) : bool = ObjEph.check_data t\n let blit_data (t1:(_,'d) t) (t2:(_,'d) t) : unit = ObjEph.blit_data t1 t2\n\n let make key data =\n let eph = create () in\n set_data eph data;\n set_key eph key;\n eph\n\n let query eph key =\n match get_key eph with\n | None -> None\n | Some k when k == key -> get_data eph\n | Some _ -> None\n\n module MakeSeeded (H:Hashtbl.SeededHashedType) =\n GenHashTable.MakeSeeded(struct\n type 'a container = (H.t,'a) t\n type t = H.t\n let create k d =\n let c = create () in\n set_data c d;\n set_key c k;\n c\n let hash = H.hash\n let equal c k =\n (* {!get_key_copy} is not used because the equality of the user can be\n the physical equality *)\n match get_key c with\n | None -> GenHashTable.EDead\n | Some k' ->\n if H.equal k k' then GenHashTable.ETrue else GenHashTable.EFalse\n let get_data = get_data\n let get_key = get_key\n let set_key_data c k d =\n unset_data c;\n set_key c k;\n set_data c d\n let check_key = check_key\n end)\n\n module Make(H: Hashtbl.HashedType): (S with type key = H.t) =\n struct\n include MakeSeeded(struct\n type t = H.t\n let equal = H.equal\n let hash (_seed: int) x = H.hash x\n end)\n let create sz = create ~random:false sz\n let of_seq i =\n let tbl = create 16 in\n replace_seq tbl i;\n tbl\n end\n\n module Bucket = struct\n\n type nonrec ('k, 'd) t = ('k, 'd) t list ref\n let k1_make = make\n let make () = ref []\n let add b k d = b := k1_make k d :: !b\n\n let test_key k e =\n match get_key e with\n | Some x when x == k -> true\n | _ -> false\n\n let remove b k =\n let rec loop l acc =\n match l with\n | [] -> ()\n | h :: t when test_key k h -> b := List.rev_append acc t\n | h :: t -> loop t (h :: acc)\n in\n loop !b []\n\n let find b k =\n match List.find_opt (test_key k) !b with\n | Some e -> get_data e\n | None -> None\n\n let length b = List.length !b\n let clear b = b := []\n\n end\n\nend\n\nmodule K2 = struct\n type ('k1, 'k2, 'd) t = ObjEph.t\n\n let create () : ('k1,'k2,'d) t = ObjEph.create 2\n\n let get_key1 (t:('k1,'k2,'d) t) : 'k1 option = obj_opt (ObjEph.get_key t 0)\n let get_key1_copy (t:('k1,'k2,'d) t) : 'k1 option =\n obj_opt (ObjEph.get_key_copy t 0)\n let set_key1 (t:('k1,'k2,'d) t) (k:'k1) : unit =\n ObjEph.set_key t 0 (Obj.repr k)\n let unset_key1 (t:('k1,'k2,'d) t) : unit = ObjEph.unset_key t 0\n let check_key1 (t:('k1,'k2,'d) t) : bool = ObjEph.check_key t 0\n\n let get_key2 (t:('k1,'k2,'d) t) : 'k2 option = obj_opt (ObjEph.get_key t 1)\n let get_key2_copy (t:('k1,'k2,'d) t) : 'k2 option =\n obj_opt (ObjEph.get_key_copy t 1)\n let set_key2 (t:('k1,'k2,'d) t) (k:'k2) : unit =\n ObjEph.set_key t 1 (Obj.repr k)\n let unset_key2 (t:('k1,'k2,'d) t) : unit = ObjEph.unset_key t 1\n let check_key2 (t:('k1,'k2,'d) t) : bool = ObjEph.check_key t 1\n\n\n let blit_key1 (t1:('k1,_,_) t) (t2:('k1,_,_) t) : unit =\n ObjEph.blit_key t1 0 t2 0 1\n let blit_key2 (t1:(_,'k2,_) t) (t2:(_,'k2,_) t) : unit =\n ObjEph.blit_key t1 1 t2 1 1\n let blit_key12 (t1:('k1,'k2,_) t) (t2:('k1,'k2,_) t) : unit =\n ObjEph.blit_key t1 0 t2 0 2\n\n let get_data (t:('k1,'k2,'d) t) : 'd option = obj_opt (ObjEph.get_data t)\n let get_data_copy (t:('k1,'k2,'d) t) : 'd option =\n obj_opt (ObjEph.get_data_copy t)\n let set_data (t:('k1,'k2,'d) t) (d:'d) : unit =\n ObjEph.set_data t (Obj.repr d)\n let unset_data (t:('k1,'k2,'d) t) : unit = ObjEph.unset_data t\n let check_data (t:('k1,'k2,'d) t) : bool = ObjEph.check_data t\n let blit_data (t1:(_,_,'d) t) (t2:(_,_,'d) t) : unit = ObjEph.blit_data t1 t2\n\n let make key1 key2 data =\n let eph = create () in\n set_data eph data;\n set_key1 eph key1;\n set_key2 eph key2;\n ignore (Sys.opaque_identity key1);\n eph\n\n let query eph key1 key2 =\n match get_key1 eph with\n | None -> None\n | Some k when k == key1 ->\n begin match get_key2 eph with\n | None -> None\n | Some k when k == key2 -> get_data eph\n | Some _ -> None\n end\n | Some _ -> None\n\n module MakeSeeded\n (H1:Hashtbl.SeededHashedType)\n (H2:Hashtbl.SeededHashedType) =\n GenHashTable.MakeSeeded(struct\n type 'a container = (H1.t,H2.t,'a) t\n type t = H1.t * H2.t\n let create (k1,k2) d =\n let c = create () in\n set_data c d;\n set_key1 c k1; set_key2 c k2;\n c\n let hash seed (k1,k2) =\n H1.hash seed k1 + H2.hash seed k2 * 65599\n let equal c (k1,k2) =\n match get_key1 c, get_key2 c with\n | None, _ | _ , None -> GenHashTable.EDead\n | Some k1', Some k2' ->\n if H1.equal k1 k1' && H2.equal k2 k2'\n then GenHashTable.ETrue else GenHashTable.EFalse\n let get_data = get_data\n let get_key c =\n match get_key1 c, get_key2 c with\n | None, _ | _ , None -> None\n | Some k1', Some k2' -> Some (k1', k2')\n let set_key_data c (k1,k2) d =\n unset_data c;\n set_key1 c k1; set_key2 c k2;\n set_data c d\n let check_key c = check_key1 c && check_key2 c\n end)\n\n module Make(H1: Hashtbl.HashedType)(H2: Hashtbl.HashedType):\n (S with type key = H1.t * H2.t) =\n struct\n include MakeSeeded\n (struct\n type t = H1.t\n let equal = H1.equal\n let hash (_seed: int) x = H1.hash x\n end)\n (struct\n type t = H2.t\n let equal = H2.equal\n let hash (_seed: int) x = H2.hash x\n end)\n let create sz = create ~random:false sz\n let of_seq i =\n let tbl = create 16 in\n replace_seq tbl i;\n tbl\n end\n\n module Bucket = struct\n\n type nonrec ('k1, 'k2, 'd) t = ('k1, 'k2, 'd) t list ref\n let k2_make = make\n let make () = ref []\n let add b k1 k2 d = b := k2_make k1 k2 d :: !b\n\n let test_keys k1 k2 e =\n match get_key1 e, get_key2 e with\n | Some x1, Some x2 when x1 == k1 && x2 == k2 -> true\n | _ -> false\n\n let remove b k1 k2 =\n let rec loop l acc =\n match l with\n | [] -> ()\n | h :: t when test_keys k1 k2 h -> b := List.rev_append acc t\n | h :: t -> loop t (h :: acc)\n in\n loop !b []\n\n let find b k1 k2 =\n match List.find_opt (test_keys k1 k2) !b with\n | Some e -> get_data e\n | None -> None\n\n let length b = List.length !b\n let clear b = b := []\n\n end\n\nend\n\nmodule Kn = struct\n type ('k,'d) t = ObjEph.t\n\n let create n : ('k,'d) t = ObjEph.create n\n let length (k:('k,'d) t) : int = ObjEph.length k\n\n let get_key (t:('k,'d) t) (n:int) : 'k option = obj_opt (ObjEph.get_key t n)\n let get_key_copy (t:('k,'d) t) (n:int) : 'k option =\n obj_opt (ObjEph.get_key_copy t n)\n let set_key (t:('k,'d) t) (n:int) (k:'k) : unit =\n ObjEph.set_key t n (Obj.repr k)\n let unset_key (t:('k,'d) t) (n:int) : unit = ObjEph.unset_key t n\n let check_key (t:('k,'d) t) (n:int) : bool = ObjEph.check_key t n\n\n let blit_key (t1:('k,'d) t) (o1:int) (t2:('k,'d) t) (o2:int) (l:int) : unit =\n ObjEph.blit_key t1 o1 t2 o2 l\n\n let get_data (t:('k,'d) t) : 'd option = obj_opt (ObjEph.get_data t)\n let get_data_copy (t:('k,'d) t) : 'd option = obj_opt (ObjEph.get_data_copy t)\n let set_data (t:('k,'d) t) (d:'d) : unit = ObjEph.set_data t (Obj.repr d)\n let unset_data (t:('k,'d) t) : unit = ObjEph.unset_data t\n let check_data (t:('k,'d) t) : bool = ObjEph.check_data t\n let blit_data (t1:(_,'d) t) (t2:(_,'d) t) : unit = ObjEph.blit_data t1 t2\n\n let make keys data =\n let l = Array.length keys in\n let eph = create l in\n set_data eph data;\n for i = 0 to l - 1 do set_key eph i keys.(i) done;\n eph\n\n let query eph keys =\n let l = length eph in\n try\n if l <> Array.length keys then raise Exit;\n for i = 0 to l - 1 do\n match get_key eph i with\n | None -> raise Exit\n | Some k when k == keys.(i) -> ()\n | Some _ -> raise Exit\n done;\n get_data eph\n with Exit -> None\n\n module MakeSeeded (H:Hashtbl.SeededHashedType) =\n GenHashTable.MakeSeeded(struct\n type 'a container = (H.t,'a) t\n type t = H.t array\n let create k d =\n let c = create (Array.length k) in\n set_data c d;\n for i=0 to Array.length k -1 do\n set_key c i k.(i);\n done;\n c\n let hash seed k =\n let h = ref 0 in\n for i=0 to Array.length k -1 do\n h := H.hash seed k.(i) * 65599 + !h;\n done;\n !h\n let equal c k =\n let len = Array.length k in\n let len' = length c in\n if len != len' then GenHashTable.EFalse\n else\n let rec equal_array k c i =\n if i < 0 then GenHashTable.ETrue\n else\n match get_key c i with\n | None -> GenHashTable.EDead\n | Some ki ->\n if H.equal k.(i) ki\n then equal_array k c (i-1)\n else GenHashTable.EFalse\n in\n equal_array k c (len-1)\n let get_data = get_data\n let get_key c =\n let len = length c in\n if len = 0 then Some [||]\n else\n match get_key c 0 with\n | None -> None\n | Some k0 ->\n let rec fill a i =\n if i < 1 then Some a\n else\n match get_key c i with\n | None -> None\n | Some ki ->\n a.(i) <- ki;\n fill a (i-1)\n in\n let a = Array.make len k0 in\n fill a (len-1)\n let set_key_data c k d =\n unset_data c;\n for i=0 to Array.length k -1 do\n set_key c i k.(i);\n done;\n set_data c d\n let check_key c =\n let rec check c i =\n i < 0 || (check_key c i && check c (i-1)) in\n check c (length c - 1)\n end)\n\n module Make(H: Hashtbl.HashedType): (S with type key = H.t array) =\n struct\n include MakeSeeded(struct\n type t = H.t\n let equal = H.equal\n let hash (_seed: int) x = H.hash x\n end)\n let create sz = create ~random:false sz\n let of_seq i =\n let tbl = create 16 in\n replace_seq tbl i;\n tbl\n end\n\n module Bucket = struct\n\n type nonrec ('k, 'd) t = ('k, 'd) t list ref\n let kn_make = make\n let make () = ref []\n let add b k d = b := kn_make k d :: !b\n\n let test_keys k e =\n try\n if length e <> Array.length k then raise Exit;\n for i = 0 to Array.length k - 1 do\n match get_key e i with\n | Some x when x == k.(i) -> ()\n | _ -> raise Exit\n done;\n true\n with Exit -> false\n\n let remove b k =\n let rec loop l acc =\n match l with\n | [] -> ()\n | h :: t when test_keys k h -> b := List.rev_append acc t\n | h :: t -> loop t (h :: acc)\n in\n loop !b []\n\n let find b k =\n match List.find_opt (test_keys k) !b with\n | Some e -> get_data e\n | None -> None\n\n let length b = List.length !b\n let clear b = b := []\n\n end\n\nend\n","open! Import\nopen Std_internal\n\nlet randomize span ~percent ~scale =\n let mult = Percent.to_mult percent in\n if Float.( < ) mult 0. || Float.( > ) mult 1.\n then\n raise_s\n [%message \"Span.randomize: percent is out of range [0x, 1x]\" (percent : Percent.t)];\n let factor = Random.float_range (1. -. mult) (Float.one_ulp `Up (1. +. mult)) in\n scale span factor\n;;\n\nlet format_decimal n tenths units =\n assert (tenths >= 0 && tenths < 10);\n if n < 10 && tenths <> 0\n then sprintf \"%d.%d%s\" n tenths units\n else sprintf \"%d%s\" n units\n;;\n\nlet short_string ~sign ~hr ~min ~sec ~ms ~us ~ns =\n let s =\n if hr >= 24\n then format_decimal (hr / 24) (Int.of_float (Float.of_int (hr % 24) /. 2.4)) \"d\"\n else if hr > 0\n then format_decimal hr (min / 6) \"h\"\n else if min > 0\n then format_decimal min (sec / 6) \"m\"\n else if sec > 0\n then format_decimal sec (ms / 100) \"s\"\n else if ms > 0\n then format_decimal ms (us / 100) \"ms\"\n else if us > 0\n then format_decimal us (ns / 100) \"us\"\n else sprintf \"%ins\" ns\n in\n match (sign : Sign.t) with\n | Neg -> \"-\" ^ s\n | Zero | Pos -> s\n;;\n","(* This module is included in [Import]. It is aimed at modules that define the standard\n combinators for [sexp_of], [of_sexp], [compare] and [hash] and are included in\n [Import]. *)\n\ninclude (\n Shadow_stdlib :\n module type of struct\n include Shadow_stdlib\n end\n with type 'a ref := 'a ref\n with type ('a, 'b, 'c) format := ('a, 'b, 'c) format\n with type ('a, 'b, 'c, 'd) format4 := ('a, 'b, 'c, 'd) format4\n with type ('a, 'b, 'c, 'd, 'e, 'f) format6 := ('a, 'b, 'c, 'd, 'e, 'f) format6\n (* These modules are redefined in Base *)\n with module Array := Shadow_stdlib.Array\n with module Atomic := Shadow_stdlib.Atomic\n with module Bool := Shadow_stdlib.Bool\n with module Buffer := Shadow_stdlib.Buffer\n with module Bytes := Shadow_stdlib.Bytes\n with module Char := Shadow_stdlib.Char\n with module Either := Shadow_stdlib.Either\n with module Float := Shadow_stdlib.Float\n with module Hashtbl := Shadow_stdlib.Hashtbl\n with module Int := Shadow_stdlib.Int\n with module Int32 := Shadow_stdlib.Int32\n with module Int64 := Shadow_stdlib.Int64\n with module Lazy := Shadow_stdlib.Lazy\n with module List := Shadow_stdlib.List\n with module Map := Shadow_stdlib.Map\n with module Nativeint := Shadow_stdlib.Nativeint\n with module Option := Shadow_stdlib.Option\n with module Printf := Shadow_stdlib.Printf\n with module Queue := Shadow_stdlib.Queue\n with module Random := Shadow_stdlib.Random\n with module Result := Shadow_stdlib.Result\n with module Set := Shadow_stdlib.Set\n with module Stack := Shadow_stdlib.Stack\n with module String := Shadow_stdlib.String\n with module Sys := Shadow_stdlib.Sys\n with module Uchar := Shadow_stdlib.Uchar\n with module Unit := Shadow_stdlib.Unit) [@ocaml.warning \"-3\"]\n\ntype 'a ref = 'a Caml.ref = { mutable contents : 'a }\n\n(* Reshuffle [Caml] so that we choose the modules using labels when available. *)\nmodule Caml = struct\n\n module Arg = Caml.Arg (** @canonical Caml.Arg *)\n\n module Array = Caml.StdLabels.Array (** @canonical Caml.StdLabels.Array *)\n\n module Bool = Caml.Bool (** @canonical Caml.Bool *)\n\n module Buffer = Caml.Buffer (** @canonical Caml.Buffer *)\n\n module Bytes = Caml.StdLabels.Bytes (** @canonical Caml.StdLabels.Bytes *)\n\n module Char = Caml.Char (** @canonical Caml.Char *)\n\n module Ephemeron = Caml.Ephemeron (** @canonical Caml.Ephemeron *)\n\n module Float = Caml.Float (** @canonical Caml.Float *)\n\n module Format = Caml.Format (** @canonical Caml.Format *)\n\n module Fun = Caml.Fun (** @canonical Caml.Fun *)\n\n module Gc = Caml.Gc (** @canonical Caml.Gc *)\n\n module Hashtbl = Caml.MoreLabels.Hashtbl (** @canonical Caml.MoreLabels.Hashtbl *)\n\n module Int32 = Caml.Int32 (** @canonical Caml.Int32 *)\n\n module Int = Caml.Int (** @canonical Caml.Int *)\n\n module Int64 = Caml.Int64 (** @canonical Caml.Int64 *)\n\n module Lazy = Caml.Lazy (** @canonical Caml.Lazy *)\n\n module Lexing = Caml.Lexing (** @canonical Caml.Lexing *)\n\n module List = Caml.StdLabels.List (** @canonical Caml.StdLabels.List *)\n\n module Map = Caml.MoreLabels.Map (** @canonical Caml.MoreLabels.Map *)\n\n module Nativeint = Caml.Nativeint (** @canonical Caml.Nativeint *)\n\n module Obj = Caml.Obj (** @canonical Caml.Obj *)\n\n module Option = Caml.Option (** @canonical Caml.Option *)\n\n module Parsing = Caml.Parsing (** @canonical Caml.Parsing *)\n\n module Printexc = Caml.Printexc (** @canonical Caml.Printexc *)\n\n module Printf = Caml.Printf (** @canonical Caml.Printf *)\n\n module Queue = Caml.Queue (** @canonical Caml.Queue *)\n\n module Random = Caml.Random (** @canonical Caml.Random *)\n\n module Result = Caml.Result (** @canonical Caml.Result *)\n\n module Scanf = Caml.Scanf (** @canonical Caml.Scanf *)\n\n module Seq = Caml.Seq (** @canonical Caml.Seq *)\n\n module Set = Caml.MoreLabels.Set (** @canonical Caml.MoreLabels.Set *)\n\n module Stack = Caml.Stack (** @canonical Caml.Stack *)\n\n module Stream = Caml.Stream [@ocaml.warning \"-3\"] (** @canonical Caml.Stream *)\n\n module String = Caml.StdLabels.String (** @canonical Caml.StdLabels.String *)\n\n module Sys = Caml.Sys (** @canonical Caml.Sys *)\n\n module Uchar = Caml.Uchar (** @canonical Caml.Uchar *)\n\n module Unit = Caml.Unit (** @canonical Caml.Unit *)\n\n include Pervasives [@ocaml.warning \"-3\"]\n\n exception Not_found = Caml.Not_found\nend\n\nexternal ( |> ) : 'a -> ('a -> 'b) -> 'b = \"%revapply\"\n\n(* These need to be declared as an external to get the lazy behavior *)\nexternal ( && ) : bool -> bool -> bool = \"%sequand\"\nexternal ( || ) : bool -> bool -> bool = \"%sequor\"\nexternal not : bool -> bool = \"%boolnot\"\n\n(* We use [Obj.magic] here as other implementations generate a conditional jump and the\n performance difference is noticeable. *)\nlet bool_to_int (x : bool) : int = Caml.Obj.magic x\n\n(* This need to be declared as an external for the warnings to work properly *)\nexternal ignore : _ -> unit = \"%ignore\"\n\nlet ( != ) = Caml.( != )\nlet ( * ) = Caml.( * )\nlet ( ** ) = Caml.( ** )\nlet ( *. ) = Caml.( *. )\nlet ( + ) = Caml.( + )\nlet ( +. ) = Caml.( +. )\nlet ( - ) = Caml.( - )\nlet ( -. ) = Caml.( -. )\nlet ( / ) = Caml.( / )\nlet ( /. ) = Caml.( /. )\n\nmodule Poly = Poly0 (** @canonical Base.Poly *)\n\nmodule Int_replace_polymorphic_compare = struct\n let ( < ) (x : int) y = Poly.( < ) x y\n let ( <= ) (x : int) y = Poly.( <= ) x y\n let ( <> ) (x : int) y = Poly.( <> ) x y\n let ( = ) (x : int) y = Poly.( = ) x y\n let ( > ) (x : int) y = Poly.( > ) x y\n let ( >= ) (x : int) y = Poly.( >= ) x y\n let compare (x : int) y = bool_to_int (x > y) - bool_to_int (x < y)\n let ascending (x : int) y = compare x y\n let descending (x : int) y = compare y x\n let equal (x : int) y = Poly.equal x y\n let max (x : int) y = if x >= y then x else y\n let min (x : int) y = if x <= y then x else y\nend\n\ninclude Int_replace_polymorphic_compare\n\nmodule Int32_replace_polymorphic_compare = struct\n let ( < ) (x : Caml.Int32.t) y = Poly.( < ) x y\n let ( <= ) (x : Caml.Int32.t) y = Poly.( <= ) x y\n let ( <> ) (x : Caml.Int32.t) y = Poly.( <> ) x y\n let ( = ) (x : Caml.Int32.t) y = Poly.( = ) x y\n let ( > ) (x : Caml.Int32.t) y = Poly.( > ) x y\n let ( >= ) (x : Caml.Int32.t) y = Poly.( >= ) x y\n let ascending (x : Caml.Int32.t) y = Poly.ascending x y\n let descending (x : Caml.Int32.t) y = Poly.descending x y\n let compare (x : Caml.Int32.t) y = Poly.compare x y\n let equal (x : Caml.Int32.t) y = Poly.equal x y\n let max (x : Caml.Int32.t) y = if x >= y then x else y\n let min (x : Caml.Int32.t) y = if x <= y then x else y\nend\n\nmodule Int64_replace_polymorphic_compare = struct\n let ( < ) (x : Caml.Int64.t) y = Poly.( < ) x y\n let ( <= ) (x : Caml.Int64.t) y = Poly.( <= ) x y\n let ( <> ) (x : Caml.Int64.t) y = Poly.( <> ) x y\n let ( = ) (x : Caml.Int64.t) y = Poly.( = ) x y\n let ( > ) (x : Caml.Int64.t) y = Poly.( > ) x y\n let ( >= ) (x : Caml.Int64.t) y = Poly.( >= ) x y\n let ascending (x : Caml.Int64.t) y = Poly.ascending x y\n let descending (x : Caml.Int64.t) y = Poly.descending x y\n let compare (x : Caml.Int64.t) y = Poly.compare x y\n let equal (x : Caml.Int64.t) y = Poly.equal x y\n let max (x : Caml.Int64.t) y = if x >= y then x else y\n let min (x : Caml.Int64.t) y = if x <= y then x else y\nend\n\nmodule Nativeint_replace_polymorphic_compare = struct\n let ( < ) (x : Caml.Nativeint.t) y = Poly.( < ) x y\n let ( <= ) (x : Caml.Nativeint.t) y = Poly.( <= ) x y\n let ( <> ) (x : Caml.Nativeint.t) y = Poly.( <> ) x y\n let ( = ) (x : Caml.Nativeint.t) y = Poly.( = ) x y\n let ( > ) (x : Caml.Nativeint.t) y = Poly.( > ) x y\n let ( >= ) (x : Caml.Nativeint.t) y = Poly.( >= ) x y\n let ascending (x : Caml.Nativeint.t) y = Poly.ascending x y\n let descending (x : Caml.Nativeint.t) y = Poly.descending x y\n let compare (x : Caml.Nativeint.t) y = Poly.compare x y\n let equal (x : Caml.Nativeint.t) y = Poly.equal x y\n let max (x : Caml.Nativeint.t) y = if x >= y then x else y\n let min (x : Caml.Nativeint.t) y = if x <= y then x else y\nend\n\nmodule Bool_replace_polymorphic_compare = struct\n let ( < ) (x : bool) y = Poly.( < ) x y\n let ( <= ) (x : bool) y = Poly.( <= ) x y\n let ( <> ) (x : bool) y = Poly.( <> ) x y\n let ( = ) (x : bool) y = Poly.( = ) x y\n let ( > ) (x : bool) y = Poly.( > ) x y\n let ( >= ) (x : bool) y = Poly.( >= ) x y\n let ascending (x : bool) y = Poly.ascending x y\n let descending (x : bool) y = Poly.descending x y\n let compare (x : bool) y = Poly.compare x y\n let equal (x : bool) y = Poly.equal x y\n let max (x : bool) y = if x >= y then x else y\n let min (x : bool) y = if x <= y then x else y\nend\n\nmodule Char_replace_polymorphic_compare = struct\n let ( < ) (x : char) y = Poly.( < ) x y\n let ( <= ) (x : char) y = Poly.( <= ) x y\n let ( <> ) (x : char) y = Poly.( <> ) x y\n let ( = ) (x : char) y = Poly.( = ) x y\n let ( > ) (x : char) y = Poly.( > ) x y\n let ( >= ) (x : char) y = Poly.( >= ) x y\n let ascending (x : char) y = Poly.ascending x y\n let descending (x : char) y = Poly.descending x y\n let compare (x : char) y = Poly.compare x y\n let equal (x : char) y = Poly.equal x y\n let max (x : char) y = if x >= y then x else y\n let min (x : char) y = if x <= y then x else y\nend\n\nmodule Uchar_replace_polymorphic_compare = struct\n let i x = Caml.Uchar.to_int x\n let ( < ) (x : Caml.Uchar.t) y = Int_replace_polymorphic_compare.( < ) (i x) (i y)\n let ( <= ) (x : Caml.Uchar.t) y = Int_replace_polymorphic_compare.( <= ) (i x) (i y)\n let ( <> ) (x : Caml.Uchar.t) y = Int_replace_polymorphic_compare.( <> ) (i x) (i y)\n let ( = ) (x : Caml.Uchar.t) y = Int_replace_polymorphic_compare.( = ) (i x) (i y)\n let ( > ) (x : Caml.Uchar.t) y = Int_replace_polymorphic_compare.( > ) (i x) (i y)\n let ( >= ) (x : Caml.Uchar.t) y = Int_replace_polymorphic_compare.( >= ) (i x) (i y)\n\n let ascending (x : Caml.Uchar.t) y =\n Int_replace_polymorphic_compare.ascending (i x) (i y)\n ;;\n\n let descending (x : Caml.Uchar.t) y =\n Int_replace_polymorphic_compare.descending (i x) (i y)\n ;;\n\n let compare (x : Caml.Uchar.t) y = Int_replace_polymorphic_compare.compare (i x) (i y)\n let equal (x : Caml.Uchar.t) y = Int_replace_polymorphic_compare.equal (i x) (i y)\n let max (x : Caml.Uchar.t) y = if x >= y then x else y\n let min (x : Caml.Uchar.t) y = if x <= y then x else y\nend\n\nmodule Float_replace_polymorphic_compare = struct\n let ( < ) (x : float) y = Poly.( < ) x y\n let ( <= ) (x : float) y = Poly.( <= ) x y\n let ( <> ) (x : float) y = Poly.( <> ) x y\n let ( = ) (x : float) y = Poly.( = ) x y\n let ( > ) (x : float) y = Poly.( > ) x y\n let ( >= ) (x : float) y = Poly.( >= ) x y\n let ascending (x : float) y = Poly.ascending x y\n let descending (x : float) y = Poly.descending x y\n let compare (x : float) y = Poly.compare x y\n let equal (x : float) y = Poly.equal x y\n let max (x : float) y = if x >= y then x else y\n let min (x : float) y = if x <= y then x else y\nend\n\nmodule String_replace_polymorphic_compare = struct\n let ( < ) (x : string) y = Poly.( < ) x y\n let ( <= ) (x : string) y = Poly.( <= ) x y\n let ( <> ) (x : string) y = Poly.( <> ) x y\n let ( = ) (x : string) y = Poly.( = ) x y\n let ( > ) (x : string) y = Poly.( > ) x y\n let ( >= ) (x : string) y = Poly.( >= ) x y\n let ascending (x : string) y = Poly.ascending x y\n let descending (x : string) y = Poly.descending x y\n let compare (x : string) y = Poly.compare x y\n let equal (x : string) y = Poly.equal x y\n let max (x : string) y = if x >= y then x else y\n let min (x : string) y = if x <= y then x else y\nend\n\nmodule Bytes_replace_polymorphic_compare = struct\n let ( < ) (x : bytes) y = Poly.( < ) x y\n let ( <= ) (x : bytes) y = Poly.( <= ) x y\n let ( <> ) (x : bytes) y = Poly.( <> ) x y\n let ( = ) (x : bytes) y = Poly.( = ) x y\n let ( > ) (x : bytes) y = Poly.( > ) x y\n let ( >= ) (x : bytes) y = Poly.( >= ) x y\n let ascending (x : bytes) y = Poly.ascending x y\n let descending (x : bytes) y = Poly.descending x y\n let compare (x : bytes) y = Poly.compare x y\n let equal (x : bytes) y = Poly.equal x y\n let max (x : bytes) y = if x >= y then x else y\n let min (x : bytes) y = if x <= y then x else y\nend\n\n(* This needs to be defined as an external so that the compiler can specialize it as a\n direct set or caml_modify *)\nexternal ( := ) : 'a ref -> 'a -> unit = \"%setfield0\"\n\n(* These need to be defined as an external otherwise the compiler won't unbox\n references *)\nexternal ( ! ) : 'a ref -> 'a = \"%field0\"\nexternal ref : 'a -> 'a ref = \"%makemutable\"\n\nlet ( @ ) = Caml.( @ )\nlet ( ^ ) = Caml.( ^ )\nlet ( ~- ) = Caml.( ~- )\nlet ( ~-. ) = Caml.( ~-. )\nlet ( asr ) = Caml.( asr )\nlet ( land ) = Caml.( land )\nlet lnot = Caml.lnot\nlet ( lor ) = Caml.( lor )\nlet ( lsl ) = Caml.( lsl )\nlet ( lsr ) = Caml.( lsr )\nlet ( lxor ) = Caml.( lxor )\nlet ( mod ) = Caml.( mod )\nlet abs = Caml.abs\nlet failwith = Caml.failwith\nlet fst = Caml.fst\nlet invalid_arg = Caml.invalid_arg\nlet snd = Caml.snd\n\n(* [raise] needs to be defined as an external as the compiler automatically replaces\n '%raise' by '%reraise' when appropriate. *)\nexternal raise : exn -> _ = \"%raise\"\n\nlet phys_equal = Caml.( == )\nlet decr = Caml.decr\nlet incr = Caml.incr\n\n(* used by sexp_conv, which float0 depends on through option *)\nlet float_of_string = Caml.float_of_string\n\n(* [am_testing] is used in a few places to behave differently when in testing mode, such\n as in [random.ml]. [am_testing] is implemented using [Base_am_testing], a weak C/js\n primitive that returns [false], but when linking an inline-test-runner executable, is\n overridden by another primitive that returns [true]. *)\nexternal am_testing : unit -> bool = \"Base_am_testing\"\n\nlet am_testing = am_testing ()\n","open! Import0\ninclude Caml.Printf\n\n(** failwith, invalid_arg, and exit accepting printf's format. *)\n\nlet failwithf fmt = ksprintf (fun s () -> failwith s) fmt\nlet invalid_argf fmt = ksprintf (fun s () -> invalid_arg s) fmt\n","(* [Array0] defines array functions that are primitives or can be simply defined in terms\n of [Caml.Array]. [Array0] is intended to completely express the part of [Caml.Array]\n that [Base] uses -- no other file in Base other than array0.ml should use [Caml.Array].\n [Array0] has few dependencies, and so is available early in Base's build order. All\n Base files that need to use arrays and come before [Base.Array] in build order should\n do [module Array = Array0]. This includes uses of subscript syntax ([x.(i)], [x.(i) <-\n e]), which the OCaml parser desugars into calls to [Array.get] and [Array.set].\n Defining [module Array = Array0] is also necessary because it prevents ocamldep from\n mistakenly causing a file to depend on [Base.Array]. *)\n\nopen! Import0\nmodule Sys = Sys0\n\nlet invalid_argf = Printf.invalid_argf\n\nmodule Array = struct\n external create : int -> 'a -> 'a array = \"caml_make_vect\"\n external get : 'a array -> int -> 'a = \"%array_safe_get\"\n external length : 'a array -> int = \"%array_length\"\n external set : 'a array -> int -> 'a -> unit = \"%array_safe_set\"\n external unsafe_get : 'a array -> int -> 'a = \"%array_unsafe_get\"\n external unsafe_set : 'a array -> int -> 'a -> unit = \"%array_unsafe_set\"\nend\n\ninclude Array\n\nlet max_length = Sys.max_array_length\n\nlet create ~len x =\n try create len x with\n | Invalid_argument _ -> invalid_argf \"Array.create ~len:%d: invalid length\" len ()\n;;\n\nlet append = Caml.Array.append\nlet blit = Caml.Array.blit\nlet concat = Caml.Array.concat\nlet copy = Caml.Array.copy\nlet fill = Caml.Array.fill\nlet init = Caml.Array.init\nlet make_matrix = Caml.Array.make_matrix\nlet of_list = Caml.Array.of_list\nlet sub = Caml.Array.sub\nlet to_list = Caml.Array.to_list\n\n(* These are eta expanded in order to permute parameter order to follow Base\n conventions. *)\nlet fold t ~init ~f = Caml.Array.fold_left t ~init ~f\nlet fold_right t ~f ~init = Caml.Array.fold_right t ~f ~init\nlet iter t ~f = Caml.Array.iter t ~f\nlet iteri t ~f = Caml.Array.iteri t ~f\nlet map t ~f = Caml.Array.map t ~f\nlet mapi t ~f = Caml.Array.mapi t ~f\nlet stable_sort t ~compare = Caml.Array.stable_sort t ~cmp:compare\n\nlet swap t i j =\n let tmp = t.(i) in\n t.(i) <- t.(j);\n t.(j) <- tmp\n;;\n","(* [Char0] defines char functions that are primitives or can be simply defined in terms of\n [Caml.Char]. [Char0] is intended to completely express the part of [Caml.Char] that\n [Base] uses -- no other file in Base other than char0.ml should use [Caml.Char].\n [Char0] has few dependencies, and so is available early in Base's build order. All\n Base files that need to use chars and come before [Base.Char] in build order should do\n [module Char = Char0]. Defining [module Char = Char0] is also necessary because it\n prevents ocamldep from mistakenly causing a file to depend on [Base.Char]. *)\n\nopen! Import0\n\nlet failwithf = Printf.failwithf\nlet escaped = Caml.Char.escaped\nlet lowercase = Caml.Char.lowercase_ascii\nlet to_int = Caml.Char.code\nlet unsafe_of_int = Caml.Char.unsafe_chr\nlet uppercase = Caml.Char.uppercase_ascii\n\n(* We use our own range test when converting integers to chars rather than\n calling [Caml.Char.chr] because it's simple and it saves us a function call\n and the try-with (exceptions cost, especially in the world with backtraces). *)\nlet int_is_ok i = 0 <= i && i <= 255\nlet min_value = unsafe_of_int 0\nlet max_value = unsafe_of_int 255\nlet of_int i = if int_is_ok i then Some (unsafe_of_int i) else None\n\nlet of_int_exn i =\n if int_is_ok i\n then unsafe_of_int i\n else failwithf \"Char.of_int_exn got integer out of range: %d\" i ()\n;;\n\nlet equal (t1 : char) t2 = Poly.equal t1 t2\n","(* [List0] defines list functions that are primitives or can be simply defined in terms of\n [Caml.List]. [List0] is intended to completely express the part of [Caml.List] that\n [Base] uses -- no other file in Base other than list0.ml should use [Caml.List].\n [List0] has few dependencies, and so is available early in Base's build order. All\n Base files that need to use lists and come before [Base.List] in build order should do\n [module List = List0]. Defining [module List = List0] is also necessary because it\n prevents ocamldep from mistakenly causing a file to depend on [Base.List]. *)\n\nopen! Import0\n\nlet hd_exn = Caml.List.hd\nlet length = Caml.List.length\nlet rev_append = Caml.List.rev_append\nlet tl_exn = Caml.List.tl\nlet unzip = Caml.List.split\n\n(* These are eta expanded in order to permute parameter order to follow Base\n conventions. *)\nlet exists t ~f = Caml.List.exists t ~f\nlet exists2_ok l1 l2 ~f = Caml.List.exists2 l1 l2 ~f\nlet fold t ~init ~f = Caml.List.fold_left t ~f ~init\nlet fold2_ok l1 l2 ~init ~f = Caml.List.fold_left2 l1 l2 ~init ~f\nlet for_all t ~f = Caml.List.for_all t ~f\nlet for_all2_ok l1 l2 ~f = Caml.List.for_all2 l1 l2 ~f\nlet iter t ~f = Caml.List.iter t ~f\nlet iter2_ok l1 l2 ~f = Caml.List.iter2 l1 l2 ~f\nlet nontail_map t ~f = Caml.List.map t ~f\nlet nontail_mapi t ~f = Caml.List.mapi t ~f\nlet partition t ~f = Caml.List.partition t ~f\nlet rev_map t ~f = Caml.List.rev_map t ~f\nlet rev_map2_ok l1 l2 ~f = Caml.List.rev_map2 l1 l2 ~f\nlet sort l ~compare = Caml.List.sort l ~cmp:compare\nlet stable_sort l ~compare = Caml.List.stable_sort l ~cmp:compare\n\nlet rev = function\n | ([] | [ _ ]) as res -> res\n | x :: y :: rest -> rev_append rest [ y; x ]\n;;\n","open Core_kernel\n\nmodule type S = sig\n type 'a t = private 'a list\n\n include Container.S1 with type 'a t := 'a t\n\n val of_list : 'a list -> 'a t\n\n val init : int -> f:(int -> 'a) -> 'a t\n\n val map : 'a t -> f:('a -> 'b) -> 'b t\n\n val pad : padding_length:int -> zero:'a -> 'a t -> 'a t\nend\n\nmodule T = struct\n include List\n\n let of_list = Fn.id\nend\n\nmodule Msb_first = struct\n include T\n\n let of_lsb_first = List.rev\n\n let pad ~padding_length ~zero xs =\n List.init padding_length ~f:(fun _ -> zero) @ xs\nend\n\nmodule Lsb_first = struct\n include T\n\n let of_msb_first = List.rev\n\n let pad ~padding_length ~zero xs =\n xs @ List.init padding_length ~f:(fun _ -> zero)\nend\n\nlet pad_to_triple_list ~default xs =\n let rec go acc = function\n | [] ->\n List.rev acc\n | [ x1 ] ->\n List.rev ((x1, default, default) :: acc)\n | [ x1; x2 ] ->\n List.rev ((x1, x2, default) :: acc)\n | x1 :: x2 :: x3 :: xs ->\n go ((x1, x2, x3) :: acc) xs\n in\n go [] xs\n","(*\n This is the interface to the runtime support for [ppx_hash].\n\n The [ppx_hash] syntax extension supports: [@@deriving hash] and [%hash_fold: TYPE] and\n [%hash: TYPE]\n\n For type [t] a function [hash_fold_t] of type [Hash.state -> t -> Hash.state] is\n generated.\n\n The generated [hash_fold_] function is compositional, following the structure of the\n type; allowing user overrides at every level. This is in contrast to ocaml's builtin\n polymorphic hashing [Hashtbl.hash] which ignores user overrides.\n\n The generator also provides a direct hash-function [hash] (named [hash_] when !=\n \"t\") of type: [t -> Hash.hash_value].\n\n The folding hash function can be accessed as [%hash_fold: TYPE]\n The direct hash function can be accessed as [%hash: TYPE]\n*)\n\nopen! Import0\nmodule Array = Array0\nmodule Char = Char0\nmodule Int = Int0\nmodule List = List0\ninclude Hash_intf\n\n(** Builtin folding-style hash functions, abstracted over [Hash_intf.S] *)\nmodule Folding (Hash : Hash_intf.S) :\n Hash_intf.Builtin_intf\n with type state = Hash.state\n and type hash_value = Hash.hash_value = struct\n type state = Hash.state\n type hash_value = Hash.hash_value\n type 'a folder = state -> 'a -> state\n\n let hash_fold_unit s () = s\n let hash_fold_int = Hash.fold_int\n let hash_fold_int64 = Hash.fold_int64\n let hash_fold_float = Hash.fold_float\n let hash_fold_string = Hash.fold_string\n let as_int f s x = hash_fold_int s (f x)\n\n (* This ignores the sign bit on 32-bit architectures, but it's unlikely to lead to\n frequent collisions (min_value colliding with 0 is the most likely one). *)\n let hash_fold_int32 = as_int Caml.Int32.to_int\n let hash_fold_char = as_int Char.to_int\n\n let hash_fold_bool =\n as_int (function\n | true -> 1\n | false -> 0)\n ;;\n\n let hash_fold_nativeint s x = hash_fold_int64 s (Caml.Int64.of_nativeint x)\n\n let hash_fold_option hash_fold_elem s = function\n | None -> hash_fold_int s 0\n | Some x -> hash_fold_elem (hash_fold_int s 1) x\n ;;\n\n let rec hash_fold_list_body hash_fold_elem s list =\n match list with\n | [] -> s\n | x :: xs -> hash_fold_list_body hash_fold_elem (hash_fold_elem s x) xs\n ;;\n\n let hash_fold_list hash_fold_elem s list =\n (* The [length] of the list must be incorporated into the hash-state so values of\n types such as [unit list] - ([], [()], [();()],..) are hashed differently. *)\n (* The [length] must come before the elements to avoid a violation of the rule\n enforced by Perfect_hash. *)\n let s = hash_fold_int s (List.length list) in\n let s = hash_fold_list_body hash_fold_elem s list in\n s\n ;;\n\n let hash_fold_lazy_t hash_fold_elem s x = hash_fold_elem s (Caml.Lazy.force x)\n let hash_fold_ref_frozen hash_fold_elem s x = hash_fold_elem s !x\n\n let rec hash_fold_array_frozen_i hash_fold_elem s array i =\n if i = Array.length array\n then s\n else (\n let e = Array.unsafe_get array i in\n hash_fold_array_frozen_i hash_fold_elem (hash_fold_elem s e) array (i + 1))\n ;;\n\n let hash_fold_array_frozen hash_fold_elem s array =\n hash_fold_array_frozen_i\n (* [length] must be incorporated for arrays, as it is for lists. See comment above *)\n hash_fold_elem\n (hash_fold_int s (Array.length array))\n array\n 0\n ;;\n\n (* the duplication here is because we think\n ocaml can't eliminate indirect function calls otherwise. *)\n let hash_nativeint x =\n Hash.get_hash_value (hash_fold_nativeint (Hash.reset (Hash.alloc ())) x)\n ;;\n\n let hash_int64 x = Hash.get_hash_value (hash_fold_int64 (Hash.reset (Hash.alloc ())) x)\n let hash_int32 x = Hash.get_hash_value (hash_fold_int32 (Hash.reset (Hash.alloc ())) x)\n let hash_char x = Hash.get_hash_value (hash_fold_char (Hash.reset (Hash.alloc ())) x)\n let hash_int x = Hash.get_hash_value (hash_fold_int (Hash.reset (Hash.alloc ())) x)\n let hash_bool x = Hash.get_hash_value (hash_fold_bool (Hash.reset (Hash.alloc ())) x)\n\n let hash_string x =\n Hash.get_hash_value (hash_fold_string (Hash.reset (Hash.alloc ())) x)\n ;;\n\n let hash_float x = Hash.get_hash_value (hash_fold_float (Hash.reset (Hash.alloc ())) x)\n let hash_unit x = Hash.get_hash_value (hash_fold_unit (Hash.reset (Hash.alloc ())) x)\nend\n\nmodule F (Hash : Hash_intf.S) :\n Hash_intf.Full\n with type hash_value = Hash.hash_value\n and type state = Hash.state\n and type seed = Hash.seed = struct\n include Hash\n\n type 'a folder = state -> 'a -> state\n\n let create ?seed () = reset ?seed (alloc ())\n let of_fold hash_fold_t t = get_hash_value (hash_fold_t (create ()) t)\n\n module Builtin = Folding (Hash)\n\n let run ?seed folder x =\n Hash.get_hash_value (folder (Hash.reset ?seed (Hash.alloc ())) x)\n ;;\nend\n\nmodule Internalhash : sig\n include\n Hash_intf.S\n with type state = Base_internalhash_types.state\n (* We give a concrete type for [state], albeit only partially exposed (see\n Base_internalhash_types), so that it unifies with the same type in [Base_boot],\n and to allow optimizations for the immediate type. *)\n and type seed = Base_internalhash_types.seed\n and type hash_value = Base_internalhash_types.hash_value\n\n external fold_int64 : state -> int64 -> state = \"Base_internalhash_fold_int64\"\n [@@noalloc]\n\n external fold_int : state -> int -> state = \"Base_internalhash_fold_int\" [@@noalloc]\n\n external fold_float : state -> float -> state = \"Base_internalhash_fold_float\"\n [@@noalloc]\n\n external fold_string : state -> string -> state = \"Base_internalhash_fold_string\"\n [@@noalloc]\n\n external get_hash_value : state -> hash_value = \"Base_internalhash_get_hash_value\"\n [@@noalloc]\nend = struct\n let description = \"internalhash\"\n\n include Base_internalhash_types\n\n let alloc () = create_seeded 0\n let reset ?(seed = 0) _t = create_seeded seed\n\n module For_tests = struct\n let compare_state (a : state) (b : state) = compare (a :> int) (b :> int)\n let state_to_string (state : state) = Int.to_string (state :> int)\n end\nend\n\nmodule T = struct\n include Internalhash\n\n type 'a folder = state -> 'a -> state\n\n let create ?seed () = reset ?seed (alloc ())\n let run ?seed folder x = get_hash_value (folder (reset ?seed (alloc ())) x)\n let of_fold hash_fold_t t = get_hash_value (hash_fold_t (create ()) t)\n\n module Builtin = struct\n module Folding = Folding (Internalhash)\n\n include (\n Folding :\n Hash_intf.Builtin_hash_fold_intf\n with type state := state\n and type 'a folder := 'a folder)\n\n let hash_nativeint = Folding.hash_nativeint\n let hash_int64 = Folding.hash_int64\n let hash_int32 = Folding.hash_int32\n let hash_string = Folding.hash_string\n\n (* [Folding] provides some default implementations for the [hash_*] functions below,\n but they are inefficient for some use-cases because of the use of the [hash_fold]\n functions. At this point, the [hash_value] type has been fixed to [int], so this\n module can provide specialized implementations. *)\n\n let hash_char = Char0.to_int\n\n (* This hash was chosen from here: https://gist.github.com/badboy/6267743\n\n It attempts to fulfill the primary goals of a non-cryptographic hash function:\n\n - a bit change in the input should change ~1/2 of the output bits\n - the output should be uniformly distributed across the output range\n - inputs that are close to each other shouldn't lead to outputs that are close to\n each other.\n - all bits of the input are used in generating the output\n\n In our case we also want it to be fast, non-allocating, and inlinable. *)\n let[@inline always] hash_int (t : int) =\n let t = lnot t + (t lsl 21) in\n let t = t lxor (t lsr 24) in\n let t = t + (t lsl 3) + (t lsl 8) in\n let t = t lxor (t lsr 14) in\n let t = t + (t lsl 2) + (t lsl 4) in\n let t = t lxor (t lsr 28) in\n t + (t lsl 31)\n ;;\n\n let hash_bool x = if x then 1 else 0\n\n external hash_float : float -> int = \"Base_hash_double\" [@@noalloc]\n\n let hash_unit () = 0\n end\nend\n\ninclude T\n","open Import0\n\nlet phys_equal = phys_equal\n\nexternal polymorphic_compare : 'a -> 'a -> int = \"%compare\"\nexternal polymorphic_equal : 'a -> 'a -> bool = \"%equal\"\nexternal ( && ) : bool -> bool -> bool = \"%sequand\"\n\nlet compare_abstract ~type_name _ _ =\n Printf.ksprintf\n failwith\n \"Compare called on the type %s, which is abstract in an implementation.\"\n type_name\n;;\n\nlet equal_abstract ~type_name _ _ =\n Printf.ksprintf\n failwith\n \"Equal called on the type %s, which is abstract in an implementation.\"\n type_name\n;;\n\ntype 'a compare = 'a -> 'a -> int\ntype 'a equal = 'a -> 'a -> bool\n\nmodule Builtin = struct\n let compare_bool : bool compare = Poly.compare\n let compare_char : char compare = Poly.compare\n let compare_float : float compare = Poly.compare\n let compare_int : int compare = Poly.compare\n let compare_int32 : int32 compare = Poly.compare\n let compare_int64 : int64 compare = Poly.compare\n let compare_nativeint : nativeint compare = Poly.compare\n let compare_string : string compare = Poly.compare\n let compare_unit : unit compare = Poly.compare\n\n let compare_array compare_elt a b =\n if phys_equal a b\n then 0\n else (\n let len_a = Array0.length a in\n let len_b = Array0.length b in\n let ret = compare len_a len_b in\n if ret <> 0\n then ret\n else (\n let rec loop i =\n if i = len_a\n then 0\n else (\n let l = Array0.unsafe_get a i\n and r = Array0.unsafe_get b i in\n let res = compare_elt l r in\n if res <> 0 then res else loop (i + 1))\n in\n loop 0))\n ;;\n\n let rec compare_list compare_elt a b =\n match a, b with\n | [], [] -> 0\n | [], _ -> -1\n | _, [] -> 1\n | x :: xs, y :: ys ->\n let res = compare_elt x y in\n if res <> 0 then res else compare_list compare_elt xs ys\n ;;\n\n let compare_option compare_elt a b =\n match a, b with\n | None, None -> 0\n | None, Some _ -> -1\n | Some _, None -> 1\n | Some a, Some b -> compare_elt a b\n ;;\n\n let compare_ref compare_elt a b = compare_elt !a !b\n let equal_bool : bool equal = Poly.equal\n let equal_char : char equal = Poly.equal\n let equal_int : int equal = Poly.equal\n let equal_int32 : int32 equal = Poly.equal\n let equal_int64 : int64 equal = Poly.equal\n let equal_nativeint : nativeint equal = Poly.equal\n let equal_string : string equal = Poly.equal\n let equal_unit : unit equal = Poly.equal\n\n (* [Poly.equal] is IEEE compliant, which is not what we want here. *)\n let equal_float x y = equal_int (compare_float x y) 0\n\n let equal_array equal_elt a b =\n phys_equal a b\n ||\n let len_a = Array0.length a in\n let len_b = Array0.length b in\n equal len_a len_b\n &&\n let rec loop i =\n i = len_a\n ||\n let l = Array0.unsafe_get a i\n and r = Array0.unsafe_get b i in\n equal_elt l r && loop (i + 1)\n in\n loop 0\n ;;\n\n let rec equal_list equal_elt a b =\n match a, b with\n | [], [] -> true\n | [], _ | _, [] -> false\n | x :: xs, y :: ys -> equal_elt x y && equal_list equal_elt xs ys\n ;;\n\n let equal_option equal_elt a b =\n match a, b with\n | None, None -> true\n | None, Some _ | Some _, None -> false\n | Some a, Some b -> equal_elt a b\n ;;\n\n let equal_ref equal_elt a b = equal_elt !a !b\nend\n","(* [String0] defines string functions that are primitives or can be simply defined in\n terms of [Caml.String]. [String0] is intended to completely express the part of\n [Caml.String] that [Base] uses -- no other file in Base other than string0.ml should\n use [Caml.String]. [String0] has few dependencies, and so is available early in Base's\n build order.\n\n All Base files that need to use strings, including the subscript syntax\n [x.(i)] or [x.(i) <- e] which the OCaml parser desugars into calls to\n [String], and come before [Base.String] in build order should do\n\n {[\n module String = String0\n ]}\n\n Defining [module String = String0] is also necessary because it prevents\n ocamldep from mistakenly causing a file to depend on [Base.String]. *)\n\nopen! Import0\nmodule Sys = Sys0\n\nmodule String = struct\n external get : string -> int -> char = \"%string_safe_get\"\n external length : string -> int = \"%string_length\"\n external unsafe_get : string -> int -> char = \"%string_unsafe_get\"\n\n include Bytes_set_primitives\nend\n\ninclude String\n\nlet max_length = Sys.max_string_length\nlet ( ^ ) = ( ^ )\nlet capitalize = Caml.String.capitalize_ascii\nlet compare = Caml.String.compare\nlet[@warning \"-3\"] copy = Caml.String.copy\nlet escaped = Caml.String.escaped\nlet lowercase = Caml.String.lowercase_ascii\nlet make = Caml.String.make\nlet sub = Caml.String.sub\nlet uncapitalize = Caml.String.uncapitalize_ascii\nlet unsafe_blit = Caml.String.unsafe_blit\nlet uppercase = Caml.String.uppercase_ascii\n\nlet concat ?(sep = \"\") l =\n match l with\n | [] -> \"\"\n (* The stdlib does not specialize this case because it could break existing projects. *)\n | [ x ] -> x\n | l -> Caml.String.concat ~sep l\n;;\n\n(* These are eta expanded in order to permute parameter order to follow Base\n conventions. *)\nlet iter t ~f = Caml.String.iter t ~f\n","open Hash.Builtin\nopen Ppx_compare_lib.Builtin\nmodule List = List0\nmodule String = String0\ninclude (Sexplib0.Sexp : module type of Sexplib0.Sexp with type t := Sexplib0.Sexp.t)\n\n(** Type of S-expressions *)\ntype t = Sexplib0.Sexp.t =\n | Atom of string\n | List of t list\n[@@deriving_inline compare, hash]\n\nlet rec compare =\n (fun a__001_ b__002_ ->\n if Ppx_compare_lib.phys_equal a__001_ b__002_\n then 0\n else (\n match a__001_, b__002_ with\n | Atom _a__003_, Atom _b__004_ -> compare_string _a__003_ _b__004_\n | Atom _, _ -> -1\n | _, Atom _ -> 1\n | List _a__005_, List _b__006_ -> compare_list compare _a__005_ _b__006_)\n : t -> t -> int)\n;;\n\nlet rec (hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state) =\n (fun hsv arg ->\n match arg with\n | Atom _a0 ->\n let hsv = Ppx_hash_lib.Std.Hash.fold_int hsv 0 in\n let hsv = hsv in\n hash_fold_string hsv _a0\n | List _a0 ->\n let hsv = Ppx_hash_lib.Std.Hash.fold_int hsv 1 in\n let hsv = hsv in\n hash_fold_list hash_fold_t hsv _a0\n : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state)\n\nand (hash : t -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func arg =\n Ppx_hash_lib.Std.Hash.get_hash_value\n (let hsv = Ppx_hash_lib.Std.Hash.create () in\n hash_fold_t hsv arg)\n in\n fun x -> func x\n;;\n\n[@@@end]\n\nlet of_string = ()\nlet invariant (_ : t) = ()\n","open! Import\ninclude Sexplib0.Sexpable\n\nmodule Of_sexpable\n (Sexpable : S) (M : sig\n type t\n\n val to_sexpable : t -> Sexpable.t\n val of_sexpable : Sexpable.t -> t\n end) : S with type t := M.t = struct\n let t_of_sexp sexp =\n let s = Sexpable.t_of_sexp sexp in\n try M.of_sexpable s with\n | exn -> of_sexp_error_exn exn sexp\n ;;\n\n let sexp_of_t t = Sexpable.sexp_of_t (M.to_sexpable t)\nend\n\nmodule Of_sexpable1\n (Sexpable : S1) (M : sig\n type 'a t\n\n val to_sexpable : 'a t -> 'a Sexpable.t\n val of_sexpable : 'a Sexpable.t -> 'a t\n end) : S1 with type 'a t := 'a M.t = struct\n let t_of_sexp a_of_sexp sexp =\n let s = Sexpable.t_of_sexp a_of_sexp sexp in\n try M.of_sexpable s with\n | exn -> of_sexp_error_exn exn sexp\n ;;\n\n let sexp_of_t sexp_of_a t = Sexpable.sexp_of_t sexp_of_a (M.to_sexpable t)\nend\n\nmodule Of_sexpable2\n (Sexpable : S2) (M : sig\n type ('a, 'b) t\n\n val to_sexpable : ('a, 'b) t -> ('a, 'b) Sexpable.t\n val of_sexpable : ('a, 'b) Sexpable.t -> ('a, 'b) t\n end) : S2 with type ('a, 'b) t := ('a, 'b) M.t = struct\n let t_of_sexp a_of_sexp b_of_sexp sexp =\n let s = Sexpable.t_of_sexp a_of_sexp b_of_sexp sexp in\n try M.of_sexpable s with\n | exn -> of_sexp_error_exn exn sexp\n ;;\n\n let sexp_of_t sexp_of_a sexp_of_b t =\n Sexpable.sexp_of_t sexp_of_a sexp_of_b (M.to_sexpable t)\n ;;\nend\n\nmodule Of_sexpable3\n (Sexpable : S3) (M : sig\n type ('a, 'b, 'c) t\n\n val to_sexpable : ('a, 'b, 'c) t -> ('a, 'b, 'c) Sexpable.t\n val of_sexpable : ('a, 'b, 'c) Sexpable.t -> ('a, 'b, 'c) t\n end) : S3 with type ('a, 'b, 'c) t := ('a, 'b, 'c) M.t = struct\n let t_of_sexp a_of_sexp b_of_sexp c_of_sexp sexp =\n let s = Sexpable.t_of_sexp a_of_sexp b_of_sexp c_of_sexp sexp in\n try M.of_sexpable s with\n | exn -> of_sexp_error_exn exn sexp\n ;;\n\n let sexp_of_t sexp_of_a sexp_of_b sexp_of_c t =\n Sexpable.sexp_of_t sexp_of_a sexp_of_b sexp_of_c (M.to_sexpable t)\n ;;\nend\n\nmodule Of_stringable (M : Stringable.S) : S with type t := M.t = struct\n let t_of_sexp sexp =\n match sexp with\n | Sexp.Atom s ->\n (try M.of_string s with\n | exn -> of_sexp_error_exn exn sexp)\n | Sexp.List _ ->\n of_sexp_error\n \"Sexpable.Of_stringable.t_of_sexp expected an atom, but got a list\"\n sexp\n ;;\n\n let sexp_of_t t = Sexp.Atom (M.to_string t)\nend\n","open! Import\nmodule Sys = Sys0\n\ntype t =\n | W32\n | W64\n[@@deriving_inline sexp_of]\n\nlet sexp_of_t =\n (function\n | W32 -> Ppx_sexp_conv_lib.Sexp.Atom \"W32\"\n | W64 -> Ppx_sexp_conv_lib.Sexp.Atom \"W64\"\n : t -> Ppx_sexp_conv_lib.Sexp.t)\n;;\n\n[@@@end]\n\nlet num_bits = function\n | W32 -> 32\n | W64 -> 64\n;;\n\nlet word_size =\n match Sys.word_size_in_bits with\n | 32 -> W32\n | 64 -> W64\n | _ -> failwith \"unknown word size\"\n;;\n","open! Import\n\nlet r = ref [ \"Base.Sexp.pp_hum\" ]\nlet all () = !r\nlet register p = r := p :: !r\n\nmodule type S = sig\n type t\n\n val pp : Formatter.t -> t -> unit\nend\n\nmodule Register_pp (M : sig\n include S\n\n val module_name : string\n end) =\nstruct\n include M\n\n let () = register (M.module_name ^ \".pp\")\nend\n\nmodule Register (M : sig\n type t\n\n val module_name : string\n val to_string : t -> string\n end) =\n Register_pp (struct\n include M\n\n let pp formatter t = Caml.Format.pp_print_string formatter (M.to_string t)\n end)\n","(** [Core_kernel] greatly expands the functionality available in Base while still\n remaining platform-agnostic. Core_kernel changes more frequently (i.e., is less\n stable) than Base.\n\n Some modules are mere extensions of their counterparts in Base, usually adding generic\n functionality by including functors that make them binable, comparable, sexpable,\n blitable, etc. The bulk of Core_kernel, though, is modules providing entirely new\n functionality. *)\n\nopen! Import\n\n\nmodule Applicative = Applicative\nmodule Arg = Arg\nmodule Array = Array\nmodule Avltree = Avltree\nmodule Backtrace = Backtrace\nmodule Bag = Bag\nmodule Bigbuffer = Bigbuffer\nmodule Bigstring = Bigstring\nmodule Bigsubstring = Bigsubstring\nmodule Bin_prot = Core_bin_prot\nmodule Binable = Binable\nmodule Binary_search = Binary_search\nmodule Binary_searchable = Binary_searchable\nmodule Blang = Blang\nmodule Blit = Blit\nmodule Bool = Bool\nmodule Bounded_index = Bounded_index\nmodule Buffer = Base.Buffer\nmodule Byte_units = Byte_units\nmodule Bytes = Bytes\nmodule Caml = Caml\nmodule Char = Char\nmodule Command = Command\nmodule Comparable = Comparable\nmodule Comparator = Comparator\nmodule Comparisons = Comparisons\nmodule Container = Container\nmodule Container_intf = Container_intf\nmodule Continue_or_stop = Continue_or_stop\nmodule Core_kernel_stable = Stable\nmodule Date = Date\nmodule Day_of_week = Day_of_week\nmodule Debug = Debug\nmodule Deque = Deque\nmodule Deriving_hash = Deriving_hash\nmodule Digest = Md5 [@@ocaml.deprecated \"[since 2017-05] Use Md5 instead.\"]\nmodule Doubly_linked = Doubly_linked\nmodule Either = Either\nmodule Ephemeron = Ephemeron\nmodule Equal = Equal\nmodule Error = Error\nmodule Exn = Base.Exn\nmodule Expect_test_config = Expect_test_config\nmodule Fdeque = Fdeque\nmodule Field = Field\nmodule Filename = Filename\nmodule Float = Float\nmodule Float_with_finite_only_serialization = Float_with_finite_only_serialization\nmodule Floatable = Floatable\nmodule Fn = Fn\nmodule Formatter = Formatter\nmodule Fqueue = Fqueue\nmodule Gc = Gc\nmodule Hash = Hash\nmodule Hash_queue = Hash_queue\nmodule Hash_set = Hash_set\nmodule Hashable = Hashable\nmodule Hashtbl = Hashtbl\nmodule Hashtbl_intf = Hashtbl_intf\nmodule Heap_block = Heap_block\nmodule Hexdump = Hexdump\nmodule Hexdump_intf = Hexdump_intf\nmodule Host_and_port = Host_and_port\nmodule Identifiable = Identifiable\nmodule Immediate_option = Immediate_option\nmodule Immediate_option_intf = Immediate_option_intf\nmodule In_channel = In_channel\nmodule Info = Info\nmodule Int = Int\nmodule Int32 = Int32\nmodule Int63 = Int63\nmodule Int64 = Int64\nmodule Int_conversions = Int_conversions\nmodule Int_intf = Int_intf\nmodule Int_math = Int_math\nmodule Intable = Intable\nmodule Interfaces = Interfaces\nmodule Invariant = Invariant\nmodule Lazy = Lazy\nmodule Linked_queue = Linked_queue\nmodule List = List\nmodule Map = Map\nmodule Map_intf = Map_intf\nmodule Maybe_bound = Maybe_bound\nmodule Md5 = Md5\nmodule Memo = Memo\nmodule Monad = Monad\nmodule Month = Month\nmodule Nativeint = Nativeint\nmodule No_polymorphic_compare = No_polymorphic_compare\nmodule Nothing = Nothing\nmodule Only_in_test = Only_in_test\nmodule Option = Option\nmodule Option_array = Option_array\nmodule Optional_syntax = Optional_syntax\nmodule Optional_syntax_intf = Optional_syntax_intf\nmodule Or_error = Or_error\nmodule Ordered_collection_common = Ordered_collection_common\nmodule Ordering = Ordering\nmodule Out_channel = Out_channel\nmodule Percent = Percent\nmodule Perms = Perms\nmodule Pid = Pid\nmodule Poly = Poly\nmodule Polymorphic_compare = Poly [@@deprecated \"[since 2018-11] use [Poly] instead\"]\n\nmodule Popcount = Base.Popcount\n[@@warning \"-3\"]\n[@@deprecated \"[since 2018-10] use [popcount] functions in individual int modules\"]\n\nmodule Pretty_printer = Pretty_printer\nmodule Printexc = Printexc\nmodule Printf = Printf\nmodule Queue = Queue\nmodule Quickcheck = Quickcheck\nmodule Quickcheck_intf = Quickcheck_intf\nmodule Quickcheckable = Quickcheckable\nmodule Random = Base.Random\nmodule Ref = Ref\nmodule Result = Result\nmodule Robustly_comparable = Robustly_comparable\nmodule Sequence = Sequence\nmodule Set = Set\nmodule Set_intf = Set_intf\nmodule Set_once = Set_once\nmodule Sexp_maybe = Sexp.Sexp_maybe\n\nmodule Sexp = Sexp\nmodule Sexpable = Sexpable\nmodule Sign = Sign\nmodule Sign_or_nan = Sign_or_nan\nmodule Source_code_position = Source_code_position\nmodule Splittable_random = Splittable_random\nmodule Stable_comparable = Stable_comparable\nmodule Stable_unit_test = Stable_unit_test\nmodule Stack = Stack\nmodule Staged = Base.Staged\nmodule String = String\nmodule String_id = String_id\nmodule Stringable = Stringable\nmodule Substring = Substring\nmodule Substring_intf = Substring_intf\nmodule Sys = Sys\nmodule Time = Time_float\nmodule Time_ns = Time_ns\nmodule Tuple = Tuple\nmodule Tuple2 = Tuple.T2\nmodule Tuple3 = Tuple.T3\nmodule Type_equal = Type_equal\nmodule Type_immediacy = Type_immediacy\nmodule Uchar = Uchar\nmodule Uniform_array = Uniform_array\nmodule Union_find = Union_find\nmodule Unique_id = Unique_id\nmodule Unit = Unit\nmodule Unit_of_time = Unit_of_time\nmodule Univ_map = Univ_map\n\nmodule Unix = struct end\n[@@deprecated\n \"[since 2020-03] Core_kernel shadows Unix. Use Core.Unix, which overrides some of \\\n Unix's behavior. If necessary, Unix is available and unshadowed as Caml_unix.\"]\n\nmodule Validate = Validate\nmodule Validated = Validated\nmodule Variant = Variant\nmodule Weak = Weak\nmodule With_return = With_return\nmodule Word_size = Word_size\n\nmodule type Unique_id = Unique_id.Id\n\ninclude T (** @open *)\n\ninclude Std_internal\ninclude Not_found\n\n(** {2 Top-level values} *)\n\ntype 'a _maybe_bound = 'a Maybe_bound.t =\n | Incl of 'a\n | Excl of 'a\n | Unbounded\n\nlet am_running_inline_test = am_running_inline_test\nlet am_running_test = am_running_test\nlet does_raise = Exn.does_raise\nlet sec = Time_float.Span.of_sec\n\n(** We perform these side effects here because we want them to run for any code that uses\n [Core_kernel]. If this were in another module in [Core_kernel] that was not used in\n some program, then the side effects might not be run in that program. This will run\n as long as the program refers to at least one value directly in [Std_kernel];\n referring to values in [Std_kernel.Bool], for example, is not sufficient. *)\nlet () = Exn.initialize_module ()\n\n(** To be used in implementing Core, but not by end users. *)\nmodule Core_kernel_private = struct\n module Digit_string_helpers = Digit_string_helpers\n module Time_zone = Zone\n module Ofday_helpers = Ofday_helpers\n module Span_float = Span_float\n\n module Bigbuffer_internal = Bigbuffer_internal\n module Stable_internal = Stable_internal\n module Std_internal = Std_internal\n\n module Time_ns_alternate_sexp = Time_ns_alternate_sexp\nend\n","(* belongs in Common, but moved here to avoid circular dependencies *)\n\nopen! Import\n\ntype 'a return = { return : 'b. 'a -> 'b } [@@unboxed]\n\nlet with_return (type a) f =\n let module M = struct\n (* Raised to indicate ~return was called. Local so that the exception is tied to a\n particular call of [with_return]. *)\n exception Return of a\n end\n in\n let is_alive = ref true in\n let return a =\n if not !is_alive\n then failwith \"use of [return] from a [with_return] that already returned\";\n Exn.raise_without_backtrace (M.Return a)\n in\n try\n let a = f { return } in\n is_alive := false;\n a\n with\n | exn ->\n is_alive := false;\n (match exn with\n | M.Return a -> a\n | _ -> raise exn)\n;;\n\nlet with_return_option f =\n with_return (fun return ->\n f { return = (fun a -> return.return (Some a)) };\n None)\n;;\n\nlet prepend { return } ~f = { return = (fun x -> return (f x)) }\n","open! Import\nmodule List = List0\ninclude Monad_intf\n\nmodule type Basic_general = sig\n type ('a, 'i, 'j, 'd, 'e) t\n\n val bind\n : ('a, 'i, 'j, 'd, 'e) t\n -> f:('a -> ('b, 'j, 'k, 'd, 'e) t)\n -> ('b, 'i, 'k, 'd, 'e) t\n\n val map\n : [ `Define_using_bind\n | `Custom of ('a, 'i, 'j, 'd, 'e) t -> f:('a -> 'b) -> ('b, 'i, 'j, 'd, 'e) t\n ]\n\n val return : 'a -> ('a, 'i, 'i, 'd, 'e) t\nend\n\nmodule Make_general (M : Basic_general) = struct\n let bind = M.bind\n let return = M.return\n let map_via_bind ma ~f = M.bind ma ~f:(fun a -> M.return (f a))\n\n let map =\n match M.map with\n | `Define_using_bind -> map_via_bind\n | `Custom x -> x\n ;;\n\n module Monad_infix = struct\n let ( >>= ) t f = bind t ~f\n let ( >>| ) t f = map t ~f\n end\n\n include Monad_infix\n\n module Let_syntax = struct\n let return = return\n\n include Monad_infix\n\n module Let_syntax = struct\n let return = return\n let bind = bind\n let map = map\n let both a b = a >>= fun a -> b >>| fun b -> a, b\n\n module Open_on_rhs = struct end\n end\n end\n\n let join t = t >>= fun t' -> t'\n let ignore_m t = map t ~f:(fun _ -> ())\n\n let all =\n let rec loop vs = function\n | [] -> return (List.rev vs)\n | t :: ts -> t >>= fun v -> loop (v :: vs) ts\n in\n fun ts -> loop [] ts\n ;;\n\n let rec all_unit = function\n | [] -> return ()\n | t :: ts -> t >>= fun () -> all_unit ts\n ;;\nend\n\nmodule Make_indexed (M : Basic_indexed) :\n S_indexed with type ('a, 'i, 'j) t := ('a, 'i, 'j) M.t = Make_general (struct\n type ('a, 'i, 'j, 'd, 'e) t = ('a, 'i, 'j) M.t\n\n include (M : Basic_indexed with type ('a, 'b, 'c) t := ('a, 'b, 'c) M.t)\n end)\n\nmodule Make3 (M : Basic3) : S3 with type ('a, 'd, 'e) t := ('a, 'd, 'e) M.t =\n Make_general (struct\n type ('a, 'i, 'j, 'd, 'e) t = ('a, 'd, 'e) M.t\n\n include (M : Basic3 with type ('a, 'b, 'c) t := ('a, 'b, 'c) M.t)\n end)\n\nmodule Make2 (M : Basic2) : S2 with type ('a, 'd) t := ('a, 'd) M.t =\n Make_general (struct\n type ('a, 'i, 'j, 'd, 'e) t = ('a, 'd) M.t\n\n include (M : Basic2 with type ('a, 'b) t := ('a, 'b) M.t)\n end)\n\nmodule Make (M : Basic) : S with type 'a t := 'a M.t = Make_general (struct\n type ('a, 'i, 'j, 'd, 'e) t = 'a M.t\n\n include (M : Basic with type 'a t := 'a M.t)\n end)\n\nmodule Ident = struct\n type 'a t = 'a\n\n include Make (struct\n type nonrec 'a t = 'a t\n\n let bind a ~f = f a\n let return a = a\n let map = `Custom (fun a ~f -> f a)\n end)\nend\n","open! Import\n\ntype ('a, 'witness) t =\n { compare : 'a -> 'a -> int\n ; sexp_of_t : 'a -> Sexp.t\n }\n\ntype ('a, 'b) comparator = ('a, 'b) t\n\nmodule type S = sig\n type t\n type comparator_witness\n\n val comparator : (t, comparator_witness) comparator\nend\n\nmodule type S1 = sig\n type 'a t\n type comparator_witness\n\n val comparator : ('a t, comparator_witness) comparator\nend\n\nmodule type S_fc = sig\n type comparable_t\n\n include S with type t := comparable_t\nend\n\nlet make (type t) ~compare ~sexp_of_t =\n (module struct\n type comparable_t = t\n type comparator_witness\n\n let comparator = { compare; sexp_of_t }\n end : S_fc\n with type comparable_t = t)\n;;\n\nmodule S_to_S1 (S : S) = struct\n type 'a t = S.t\n type comparator_witness = S.comparator_witness\n\n open S\n\n let comparator = comparator\nend\n\nmodule Make (M : sig\n type t [@@deriving_inline compare, sexp_of]\n\n val compare : t -> t -> int\n val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t\n\n [@@@end]\n end) =\nstruct\n include M\n\n type comparator_witness\n\n let comparator = M.{ compare; sexp_of_t }\nend\n\nmodule Make1 (M : sig\n type 'a t\n\n val compare : 'a t -> 'a t -> int\n val sexp_of_t : 'a t -> Sexp.t\n end) =\nstruct\n type comparator_witness\n\n let comparator = M.{ compare; sexp_of_t }\nend\n\nmodule Poly = struct\n type 'a t = 'a\n\n include Make1 (struct\n type 'a t = 'a\n\n let compare = Poly.compare\n let sexp_of_t _ = Sexp.Atom \"_\"\n end)\nend\n\nmodule type Derived = sig\n type 'a t\n type 'cmp comparator_witness\n\n val comparator : ('a, 'cmp) comparator -> ('a t, 'cmp comparator_witness) comparator\nend\n\nmodule Derived (M : sig\n type 'a t [@@deriving_inline compare, sexp_of]\n\n val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int\n val sexp_of_t : ('a -> Ppx_sexp_conv_lib.Sexp.t) -> 'a t -> Ppx_sexp_conv_lib.Sexp.t\n\n [@@@end]\n end) =\nstruct\n type 'cmp comparator_witness\n\n let comparator a =\n { compare = M.compare a.compare; sexp_of_t = M.sexp_of_t a.sexp_of_t }\n ;;\nend\n\nmodule type Derived2 = sig\n type ('a, 'b) t\n type ('cmp_a, 'cmp_b) comparator_witness\n\n val comparator\n : ('a, 'cmp_a) comparator\n -> ('b, 'cmp_b) comparator\n -> (('a, 'b) t, ('cmp_a, 'cmp_b) comparator_witness) comparator\nend\n\nmodule Derived2 (M : sig\n type ('a, 'b) t [@@deriving_inline compare, sexp_of]\n\n val compare : ('a -> 'a -> int) -> ('b -> 'b -> int) -> ('a, 'b) t -> ('a, 'b) t -> int\n\n val sexp_of_t\n : ('a -> Ppx_sexp_conv_lib.Sexp.t)\n -> ('b -> Ppx_sexp_conv_lib.Sexp.t)\n -> ('a, 'b) t\n -> Ppx_sexp_conv_lib.Sexp.t\n\n [@@@end]\n end) =\nstruct\n type ('cmp_a, 'cmp_b) comparator_witness\n\n let comparator a b =\n { compare = M.compare a.compare b.compare\n ; sexp_of_t = M.sexp_of_t a.sexp_of_t b.sexp_of_t\n }\n ;;\nend\n\nmodule type Derived_phantom = sig\n type ('a, 'b) t\n type 'cmp comparator_witness\n\n val comparator\n : ('a, 'cmp) comparator\n -> (('a, _) t, 'cmp comparator_witness) comparator\nend\n\nmodule Derived_phantom (M : sig\n type ('a, 'b) t\n\n val compare : ('a -> 'a -> int) -> ('a, 'b) t -> ('a, 'b) t -> int\n val sexp_of_t : ('a -> Sexp.t) -> ('a, _) t -> Sexp.t\n end) =\nstruct\n type 'cmp_a comparator_witness\n\n let comparator a =\n { compare = M.compare a.compare; sexp_of_t = M.sexp_of_t a.sexp_of_t }\n ;;\nend\n","(* The type [t] should be abstract to make the fset and set functions unavailable\n for private types at the level of types (and not by putting None in the field).\n Unfortunately, making the type abstract means that when creating fields (through\n a [create] function) value restriction kicks in. This is worked around by instead\n not making the type abstract, but forcing anyone breaking the abstraction to use\n the [For_generated_code] module, making it obvious to any reader that something ugly\n is going on.\n t_with_perm (and derivatives) is the type that users really use. It is a constructor\n because:\n 1. it makes type errors more readable (less aliasing)\n 2. the typer in ocaml 4.01 allows this:\n\n {[\n module A = struct\n type t = {a : int}\n end\n type t = A.t\n let f (x : t) = x.a\n ]}\n\n (although with Warning 40: a is used out of scope)\n which means that if [t_with_perm] was really an alias on [For_generated_code.t],\n people could say [t.setter] and break the abstraction with no indication that\n something ugly is going on in the source code.\n The warning is (I think) for people who want to make their code compatible with\n previous versions of ocaml, so we may very well turn it off.\n\n The type t_with_perm could also have been a [unit -> For_generated_code.t] to work\n around value restriction and then [For_generated_code.t] would have been a proper\n abstract type, but it looks like it could impact performance (for example, a fold on a\n record type with 40 fields would actually allocate the 40 [For_generated_code.t]'s at\n every single fold.) *)\n\nmodule For_generated_code = struct\n type ('perm, 'record, 'field) t =\n { force_variance : 'perm -> unit\n ; (* force [t] to be contravariant in ['perm], because phantom type variables on\n concrete types don't work that well otherwise (using :> can remove them easily) *)\n name : string\n ; setter : ('record -> 'field -> unit) option\n ; getter : 'record -> 'field\n ; fset : 'record -> 'field -> 'record\n }\n\n let opaque_identity = Sys0.opaque_identity\nend\n\ntype ('perm, 'record, 'field) t_with_perm =\n | Field of ('perm, 'record, 'field) For_generated_code.t\n[@@unboxed]\n\ntype ('record, 'field) t = ([ `Read | `Set_and_create ], 'record, 'field) t_with_perm\ntype ('record, 'field) readonly_t = ([ `Read ], 'record, 'field) t_with_perm\n\nlet name (Field field) = field.name\nlet get (Field field) r = field.getter r\nlet fset (Field field) r v = field.fset r v\nlet setter (Field field) = field.setter\n\ntype ('perm, 'record, 'result) user =\n { f : 'field. ('perm, 'record, 'field) t_with_perm -> 'result }\n\nlet map (Field field) r ~f = field.fset r (f (field.getter r))\n\nlet updater (Field field) =\n match field.setter with\n | None -> None\n | Some setter -> Some (fun r ~f -> setter r (f (field.getter r)))\n;;\n","open! Import\nmodule Int = Int0\nmodule String = String0\n\nmodule T = struct\n type t = Caml.Lexing.position =\n { pos_fname : string\n ; pos_lnum : int\n ; pos_bol : int\n ; pos_cnum : int\n }\n [@@deriving_inline compare, hash, sexp]\n\n let compare =\n (fun a__001_ b__002_ ->\n if Ppx_compare_lib.phys_equal a__001_ b__002_\n then 0\n else (\n match compare_string a__001_.pos_fname b__002_.pos_fname with\n | 0 ->\n (match compare_int a__001_.pos_lnum b__002_.pos_lnum with\n | 0 ->\n (match compare_int a__001_.pos_bol b__002_.pos_bol with\n | 0 -> compare_int a__001_.pos_cnum b__002_.pos_cnum\n | n -> n)\n | n -> n)\n | n -> n)\n : t -> t -> int)\n ;;\n\n let (hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state) =\n fun hsv arg ->\n let hsv =\n let hsv =\n let hsv =\n let hsv = hsv in\n hash_fold_string hsv arg.pos_fname\n in\n hash_fold_int hsv arg.pos_lnum\n in\n hash_fold_int hsv arg.pos_bol\n in\n hash_fold_int hsv arg.pos_cnum\n ;;\n\n let (hash : t -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func arg =\n Ppx_hash_lib.Std.Hash.get_hash_value\n (let hsv = Ppx_hash_lib.Std.Hash.create () in\n hash_fold_t hsv arg)\n in\n fun x -> func x\n ;;\n\n let t_of_sexp =\n (let _tp_loc = \"source_code_position0.ml.T.t\" in\n function\n | Ppx_sexp_conv_lib.Sexp.List field_sexps as sexp ->\n let pos_fname_field = ref Ppx_sexp_conv_lib.Option.None\n and pos_lnum_field = ref Ppx_sexp_conv_lib.Option.None\n and pos_bol_field = ref Ppx_sexp_conv_lib.Option.None\n and pos_cnum_field = ref Ppx_sexp_conv_lib.Option.None\n and duplicates = ref []\n and extra = ref [] in\n let rec iter = function\n | Ppx_sexp_conv_lib.Sexp.List\n (Ppx_sexp_conv_lib.Sexp.Atom field_name :: (([] | [ _ ]) as _field_sexps))\n :: tail ->\n let _field_sexp () =\n match _field_sexps with\n | [ x ] -> x\n | [] -> Ppx_sexp_conv_lib.Conv_error.record_only_pairs_expected _tp_loc sexp\n | _ -> assert false\n in\n (match field_name with\n | \"pos_fname\" ->\n (match !pos_fname_field with\n | Ppx_sexp_conv_lib.Option.None ->\n let _field_sexp = _field_sexp () in\n let fvalue = string_of_sexp _field_sexp in\n pos_fname_field := Ppx_sexp_conv_lib.Option.Some fvalue\n | Ppx_sexp_conv_lib.Option.Some _ -> duplicates := field_name :: !duplicates)\n | \"pos_lnum\" ->\n (match !pos_lnum_field with\n | Ppx_sexp_conv_lib.Option.None ->\n let _field_sexp = _field_sexp () in\n let fvalue = int_of_sexp _field_sexp in\n pos_lnum_field := Ppx_sexp_conv_lib.Option.Some fvalue\n | Ppx_sexp_conv_lib.Option.Some _ -> duplicates := field_name :: !duplicates)\n | \"pos_bol\" ->\n (match !pos_bol_field with\n | Ppx_sexp_conv_lib.Option.None ->\n let _field_sexp = _field_sexp () in\n let fvalue = int_of_sexp _field_sexp in\n pos_bol_field := Ppx_sexp_conv_lib.Option.Some fvalue\n | Ppx_sexp_conv_lib.Option.Some _ -> duplicates := field_name :: !duplicates)\n | \"pos_cnum\" ->\n (match !pos_cnum_field with\n | Ppx_sexp_conv_lib.Option.None ->\n let _field_sexp = _field_sexp () in\n let fvalue = int_of_sexp _field_sexp in\n pos_cnum_field := Ppx_sexp_conv_lib.Option.Some fvalue\n | Ppx_sexp_conv_lib.Option.Some _ -> duplicates := field_name :: !duplicates)\n | _ ->\n if !Ppx_sexp_conv_lib.Conv.record_check_extra_fields\n then extra := field_name :: !extra\n else ());\n iter tail\n | ((Ppx_sexp_conv_lib.Sexp.Atom _ | Ppx_sexp_conv_lib.Sexp.List _) as sexp) :: _\n -> Ppx_sexp_conv_lib.Conv_error.record_only_pairs_expected _tp_loc sexp\n | [] -> ()\n in\n iter field_sexps;\n (match !duplicates with\n | _ :: _ ->\n Ppx_sexp_conv_lib.Conv_error.record_duplicate_fields _tp_loc !duplicates sexp\n | [] ->\n (match !extra with\n | _ :: _ -> Ppx_sexp_conv_lib.Conv_error.record_extra_fields _tp_loc !extra sexp\n | [] ->\n (match !pos_fname_field, !pos_lnum_field, !pos_bol_field, !pos_cnum_field with\n | ( Ppx_sexp_conv_lib.Option.Some pos_fname_value\n , Ppx_sexp_conv_lib.Option.Some pos_lnum_value\n , Ppx_sexp_conv_lib.Option.Some pos_bol_value\n , Ppx_sexp_conv_lib.Option.Some pos_cnum_value ) ->\n { pos_fname = pos_fname_value\n ; pos_lnum = pos_lnum_value\n ; pos_bol = pos_bol_value\n ; pos_cnum = pos_cnum_value\n }\n | _ ->\n Ppx_sexp_conv_lib.Conv_error.record_undefined_elements\n _tp_loc\n sexp\n [ ( Ppx_sexp_conv_lib.Conv.( = )\n !pos_fname_field\n Ppx_sexp_conv_lib.Option.None\n , \"pos_fname\" )\n ; ( Ppx_sexp_conv_lib.Conv.( = )\n !pos_lnum_field\n Ppx_sexp_conv_lib.Option.None\n , \"pos_lnum\" )\n ; ( Ppx_sexp_conv_lib.Conv.( = )\n !pos_bol_field\n Ppx_sexp_conv_lib.Option.None\n , \"pos_bol\" )\n ; ( Ppx_sexp_conv_lib.Conv.( = )\n !pos_cnum_field\n Ppx_sexp_conv_lib.Option.None\n , \"pos_cnum\" )\n ])))\n | Ppx_sexp_conv_lib.Sexp.Atom _ as sexp ->\n Ppx_sexp_conv_lib.Conv_error.record_list_instead_atom _tp_loc sexp\n : Ppx_sexp_conv_lib.Sexp.t -> t)\n ;;\n\n let sexp_of_t =\n (function\n | { pos_fname = v_pos_fname\n ; pos_lnum = v_pos_lnum\n ; pos_bol = v_pos_bol\n ; pos_cnum = v_pos_cnum\n } ->\n let bnds = [] in\n let bnds =\n let arg = sexp_of_int v_pos_cnum in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"pos_cnum\"; arg ]\n :: bnds\n in\n let bnds =\n let arg = sexp_of_int v_pos_bol in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"pos_bol\"; arg ]\n :: bnds\n in\n let bnds =\n let arg = sexp_of_int v_pos_lnum in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"pos_lnum\"; arg ]\n :: bnds\n in\n let bnds =\n let arg = sexp_of_string v_pos_fname in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"pos_fname\"; arg ]\n :: bnds\n in\n Ppx_sexp_conv_lib.Sexp.List bnds\n : t -> Ppx_sexp_conv_lib.Sexp.t)\n ;;\n\n [@@@end]\nend\n\ninclude T\ninclude Comparator.Make (T)\n\n(* This is the same function as Ppx_here.lift_position_as_string. *)\nlet make_location_string ~pos_fname ~pos_lnum ~pos_cnum ~pos_bol =\n String.concat\n [ pos_fname; \":\"; Int.to_string pos_lnum; \":\"; Int.to_string (pos_cnum - pos_bol) ]\n;;\n\nlet to_string { Caml.Lexing.pos_fname; pos_lnum; pos_cnum; pos_bol } =\n make_location_string ~pos_fname ~pos_lnum ~pos_cnum ~pos_bol\n;;\n\nlet sexp_of_t t = Sexp.Atom (to_string t)\n","open! Import\ninclude List0\n\nlet is_empty = function\n | [] -> true\n | _ -> false\n;;\n\nlet partition_map t ~f =\n let rec loop t fst snd =\n match t with\n | [] -> rev fst, rev snd\n | x :: t ->\n (match (f x : _ Either0.t) with\n | First y -> loop t (y :: fst) snd\n | Second y -> loop t fst (y :: snd))\n in\n loop t [] []\n;;\n","open! Import\nmodule Either = Either0\n\ntype ('a, 'b) t = ('a, 'b) Caml.result =\n | Ok of 'a\n | Error of 'b\n[@@deriving_inline sexp, compare, equal, hash]\n\nlet t_of_sexp\n : type a b.\n (Ppx_sexp_conv_lib.Sexp.t -> a)\n -> (Ppx_sexp_conv_lib.Sexp.t -> b)\n -> Ppx_sexp_conv_lib.Sexp.t\n -> (a, b) t\n =\n let _tp_loc = \"result.ml.t\" in\n fun _of_a _of_b -> function\n | Ppx_sexp_conv_lib.Sexp.List\n (Ppx_sexp_conv_lib.Sexp.Atom ((\"ok\" | \"Ok\") as _tag) :: sexp_args) as _sexp ->\n (match sexp_args with\n | [ v0 ] ->\n let v0 = _of_a v0 in\n Ok v0\n | _ -> Ppx_sexp_conv_lib.Conv_error.stag_incorrect_n_args _tp_loc _tag _sexp)\n | Ppx_sexp_conv_lib.Sexp.List\n (Ppx_sexp_conv_lib.Sexp.Atom ((\"error\" | \"Error\") as _tag) :: sexp_args) as _sexp\n ->\n (match sexp_args with\n | [ v0 ] ->\n let v0 = _of_b v0 in\n Error v0\n | _ -> Ppx_sexp_conv_lib.Conv_error.stag_incorrect_n_args _tp_loc _tag _sexp)\n | Ppx_sexp_conv_lib.Sexp.Atom (\"ok\" | \"Ok\") as sexp ->\n Ppx_sexp_conv_lib.Conv_error.stag_takes_args _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.Atom (\"error\" | \"Error\") as sexp ->\n Ppx_sexp_conv_lib.Conv_error.stag_takes_args _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.List (Ppx_sexp_conv_lib.Sexp.List _ :: _) as sexp ->\n Ppx_sexp_conv_lib.Conv_error.nested_list_invalid_sum _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.List [] as sexp ->\n Ppx_sexp_conv_lib.Conv_error.empty_list_invalid_sum _tp_loc sexp\n | sexp -> Ppx_sexp_conv_lib.Conv_error.unexpected_stag _tp_loc sexp\n;;\n\nlet sexp_of_t\n : type a b.\n (a -> Ppx_sexp_conv_lib.Sexp.t)\n -> (b -> Ppx_sexp_conv_lib.Sexp.t)\n -> (a, b) t\n -> Ppx_sexp_conv_lib.Sexp.t\n =\n fun _of_a _of_b -> function\n | Ok v0 ->\n let v0 = _of_a v0 in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"Ok\"; v0 ]\n | Error v0 ->\n let v0 = _of_b v0 in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"Error\"; v0 ]\n;;\n\nlet compare :\n 'a 'b. ('a -> 'a -> int) -> ('b -> 'b -> int) -> ('a, 'b) t -> ('a, 'b) t -> int\n =\n fun _cmp__a _cmp__b a__001_ b__002_ ->\n if Ppx_compare_lib.phys_equal a__001_ b__002_\n then 0\n else (\n match a__001_, b__002_ with\n | Ok _a__003_, Ok _b__004_ -> _cmp__a _a__003_ _b__004_\n | Ok _, _ -> -1\n | _, Ok _ -> 1\n | Error _a__005_, Error _b__006_ -> _cmp__b _a__005_ _b__006_)\n;;\n\nlet equal :\n 'a 'b. ('a -> 'a -> bool) -> ('b -> 'b -> bool) -> ('a, 'b) t -> ('a, 'b) t -> bool\n =\n fun _cmp__a _cmp__b a__007_ b__008_ ->\n if Ppx_compare_lib.phys_equal a__007_ b__008_\n then true\n else (\n match a__007_, b__008_ with\n | Ok _a__009_, Ok _b__010_ -> _cmp__a _a__009_ _b__010_\n | Ok _, _ -> false\n | _, Ok _ -> false\n | Error _a__011_, Error _b__012_ -> _cmp__b _a__011_ _b__012_)\n;;\n\nlet hash_fold_t\n : type a b.\n (Ppx_hash_lib.Std.Hash.state -> a -> Ppx_hash_lib.Std.Hash.state)\n -> (Ppx_hash_lib.Std.Hash.state -> b -> Ppx_hash_lib.Std.Hash.state)\n -> Ppx_hash_lib.Std.Hash.state\n -> (a, b) t\n -> Ppx_hash_lib.Std.Hash.state\n =\n fun _hash_fold_a _hash_fold_b hsv arg ->\n match arg with\n | Ok _a0 ->\n let hsv = Ppx_hash_lib.Std.Hash.fold_int hsv 0 in\n let hsv = hsv in\n _hash_fold_a hsv _a0\n | Error _a0 ->\n let hsv = Ppx_hash_lib.Std.Hash.fold_int hsv 1 in\n let hsv = hsv in\n _hash_fold_b hsv _a0\n;;\n\n[@@@end]\n\ninclude Monad.Make2 (struct\n type nonrec ('a, 'b) t = ('a, 'b) t\n\n let bind x ~f =\n match x with\n | Error _ as x -> x\n | Ok x -> f x\n ;;\n\n let map x ~f =\n match x with\n | Error _ as x -> x\n | Ok x -> Ok (f x)\n ;;\n\n let map = `Custom map\n let return x = Ok x\n end)\n\nlet invariant check_ok check_error t =\n match t with\n | Ok ok -> check_ok ok\n | Error error -> check_error error\n;;\n\nlet fail x = Error x\nlet failf format = Printf.ksprintf fail format\n\nlet map_error t ~f =\n match t with\n | Ok _ as x -> x\n | Error x -> Error (f x)\n;;\n\nlet is_ok = function\n | Ok _ -> true\n | Error _ -> false\n;;\n\nlet is_error = function\n | Ok _ -> false\n | Error _ -> true\n;;\n\nlet ok = function\n | Ok x -> Some x\n | Error _ -> None\n;;\n\nlet error = function\n | Ok _ -> None\n | Error x -> Some x\n;;\n\nlet of_option opt ~error =\n match opt with\n | Some x -> Ok x\n | None -> Error error\n;;\n\nlet iter v ~f =\n match v with\n | Ok x -> f x\n | Error _ -> ()\n;;\n\nlet iter_error v ~f =\n match v with\n | Ok _ -> ()\n | Error x -> f x\n;;\n\nlet to_either : _ t -> _ Either.t = function\n | Ok x -> First x\n | Error x -> Second x\n;;\n\nlet of_either : _ Either.t -> _ t = function\n | First x -> Ok x\n | Second x -> Error x\n;;\n\nlet ok_if_true bool ~error = if bool then Ok () else Error error\n\nlet try_with f =\n try Ok (f ()) with\n | exn -> Error exn\n;;\n\nlet ok_exn = function\n | Ok x -> x\n | Error exn -> raise exn\n;;\n\nlet ok_or_failwith = function\n | Ok x -> x\n | Error str -> failwith str\n;;\n\nmodule Export = struct\n type ('ok, 'err) _result = ('ok, 'err) t =\n | Ok of 'ok\n | Error of 'err\n\n let is_error = is_error\n let is_ok = is_ok\nend\n\nlet combine t1 t2 ~ok ~err =\n match t1, t2 with\n | Ok _, Error e | Error e, Ok _ -> Error e\n | Ok ok1, Ok ok2 -> Ok (ok ok1 ok2)\n | Error err1, Error err2 -> Error (err err1 err2)\n;;\n\nlet combine_errors l =\n let ok, errs = List1.partition_map l ~f:to_either in\n match errs with\n | [] -> Ok ok\n | _ :: _ -> Error errs\n;;\n\nlet combine_errors_unit l = map (combine_errors l) ~f:(fun (_ : unit list) -> ())\n\n(* deprecated binding for export only *)\nlet ok_fst = to_either\n","(** Provides generic signatures for container data structures.\n\n These signatures include functions ([iter], [fold], [exists], [for_all], ...) that\n you would expect to find in any container. Used by including [Container.S0] or\n [Container.S1] in the signature for every container-like data structure ([Array],\n [List], [String], ...) to ensure a consistent interface. *)\n\nopen! Import\n\nmodule Export = struct\n (** [Continue_or_stop.t] is used by the [f] argument to [fold_until] in order to\n indicate whether folding should continue, or stop early. *)\n module Continue_or_stop = struct\n type ('a, 'b) t =\n | Continue of 'a\n | Stop of 'b\n end\nend\n\ninclude Export\n\nmodule type Summable = sig\n type t\n\n (** The result of summing no values. *)\n val zero : t\n\n (** An operation that combines two [t]'s and handles [zero + x] by just returning [x],\n as well as in the symmetric case. *)\n val ( + ) : t -> t -> t\nend\n\n(** Signature for monomorphic container, e.g., string. *)\nmodule type S0 = sig\n type t\n type elt\n\n (** Checks whether the provided element is there, using equality on [elt]s. *)\n val mem : t -> elt -> bool\n\n val length : t -> int\n val is_empty : t -> bool\n\n (** [iter] must allow exceptions raised in [f] to escape, terminating the iteration\n cleanly. The same holds for all functions below taking an [f]. *)\n val iter : t -> f:(elt -> unit) -> unit\n\n (** [fold t ~init ~f] returns [f (... f (f (f init e1) e2) e3 ...) en], where [e1..en]\n are the elements of [t]. *)\n val fold : t -> init:'accum -> f:('accum -> elt -> 'accum) -> 'accum\n\n (** [fold_result t ~init ~f] is a short-circuiting version of [fold] that runs in the\n [Result] monad. If [f] returns an [Error _], that value is returned without any\n additional invocations of [f]. *)\n val fold_result\n : t\n -> init:'accum\n -> f:('accum -> elt -> ('accum, 'e) Result.t)\n -> ('accum, 'e) Result.t\n\n (** [fold_until t ~init ~f ~finish] is a short-circuiting version of [fold]. If [f]\n returns [Stop _] the computation ceases and results in that value. If [f] returns\n [Continue _], the fold will proceed. If [f] never returns [Stop _], the final result\n is computed by [finish].\n\n Example:\n\n {[\n type maybe_negative =\n | Found_negative of int\n | All_nonnegative of { sum : int }\n\n (** [first_neg_or_sum list] returns the first negative number in [list], if any,\n otherwise returns the sum of the list. *)\n let first_neg_or_sum =\n List.fold_until ~init:0\n ~f:(fun sum x ->\n if x < 0\n then Stop (Found_negative x)\n else Continue (sum + x))\n ~finish:(fun sum -> All_nonnegative { sum })\n ;;\n\n let x = first_neg_or_sum [1; 2; 3; 4; 5]\n val x : maybe_negative = All_nonnegative {sum = 15}\n\n let y = first_neg_or_sum [1; 2; -3; 4; 5]\n val y : maybe_negative = Found_negative -3\n ]} *)\n val fold_until\n : t\n -> init:'accum\n -> f:('accum -> elt -> ('accum, 'final) Continue_or_stop.t)\n -> finish:('accum -> 'final)\n -> 'final\n\n (** Returns [true] if and only if there exists an element for which the provided\n function evaluates to [true]. This is a short-circuiting operation. *)\n val exists : t -> f:(elt -> bool) -> bool\n\n (** Returns [true] if and only if the provided function evaluates to [true] for all\n elements. This is a short-circuiting operation. *)\n val for_all : t -> f:(elt -> bool) -> bool\n\n (** Returns the number of elements for which the provided function evaluates to true. *)\n val count : t -> f:(elt -> bool) -> int\n\n (** Returns the sum of [f i] for all [i] in the container. *)\n val sum : (module Summable with type t = 'sum) -> t -> f:(elt -> 'sum) -> 'sum\n\n (** Returns as an [option] the first element for which [f] evaluates to true. *)\n val find : t -> f:(elt -> bool) -> elt option\n\n (** Returns the first evaluation of [f] that returns [Some], and returns [None] if there\n is no such element. *)\n val find_map : t -> f:(elt -> 'a option) -> 'a option\n\n val to_list : t -> elt list\n val to_array : t -> elt array\n\n (** Returns a min (resp. max) element from the collection using the provided [compare]\n function. In case of a tie, the first element encountered while traversing the\n collection is returned. The implementation uses [fold] so it has the same\n complexity as [fold]. Returns [None] iff the collection is empty. *)\n val min_elt : t -> compare:(elt -> elt -> int) -> elt option\n\n val max_elt : t -> compare:(elt -> elt -> int) -> elt option\nend\n\nmodule type S0_phantom = sig\n type elt\n type 'a t\n\n (** Checks whether the provided element is there, using equality on [elt]s. *)\n val mem : _ t -> elt -> bool\n\n val length : _ t -> int\n val is_empty : _ t -> bool\n val iter : _ t -> f:(elt -> unit) -> unit\n\n (** [fold t ~init ~f] returns [f (... f (f (f init e1) e2) e3 ...) en], where [e1..en]\n are the elements of [t]. *)\n val fold : _ t -> init:'accum -> f:('accum -> elt -> 'accum) -> 'accum\n\n (** [fold_result t ~init ~f] is a short-circuiting version of [fold] that runs in the\n [Result] monad. If [f] returns an [Error _], that value is returned without any\n additional invocations of [f]. *)\n val fold_result\n : _ t\n -> init:'accum\n -> f:('accum -> elt -> ('accum, 'e) Result.t)\n -> ('accum, 'e) Result.t\n\n (** [fold_until t ~init ~f ~finish] is a short-circuiting version of [fold]. If [f]\n returns [Stop _] the computation ceases and results in that value. If [f] returns\n [Continue _], the fold will proceed. If [f] never returns [Stop _], the final result\n is computed by [finish].\n\n Example:\n\n {[\n type maybe_negative =\n | Found_negative of int\n | All_nonnegative of { sum : int }\n\n (** [first_neg_or_sum list] returns the first negative number in [list], if any,\n otherwise returns the sum of the list. *)\n let first_neg_or_sum =\n List.fold_until ~init:0\n ~f:(fun sum x ->\n if x < 0\n then Stop (Found_negative x)\n else Continue (sum + x))\n ~finish:(fun sum -> All_nonnegative { sum })\n ;;\n\n let x = first_neg_or_sum [1; 2; 3; 4; 5]\n val x : maybe_negative = All_nonnegative {sum = 15}\n\n let y = first_neg_or_sum [1; 2; -3; 4; 5]\n val y : maybe_negative = Found_negative -3\n ]} *)\n val fold_until\n : _ t\n -> init:'accum\n -> f:('accum -> elt -> ('accum, 'final) Continue_or_stop.t)\n -> finish:('accum -> 'final)\n -> 'final\n\n (** Returns [true] if and only if there exists an element for which the provided\n function evaluates to [true]. This is a short-circuiting operation. *)\n val exists : _ t -> f:(elt -> bool) -> bool\n\n (** Returns [true] if and only if the provided function evaluates to [true] for all\n elements. This is a short-circuiting operation. *)\n val for_all : _ t -> f:(elt -> bool) -> bool\n\n (** Returns the number of elements for which the provided function evaluates to true. *)\n val count : _ t -> f:(elt -> bool) -> int\n\n (** Returns the sum of [f i] for all [i] in the container. The order in which the\n elements will be summed is unspecified. *)\n val sum : (module Summable with type t = 'sum) -> _ t -> f:(elt -> 'sum) -> 'sum\n\n (** Returns as an [option] the first element for which [f] evaluates to true. *)\n val find : _ t -> f:(elt -> bool) -> elt option\n\n (** Returns the first evaluation of [f] that returns [Some], and returns [None] if there\n is no such element. *)\n val find_map : _ t -> f:(elt -> 'a option) -> 'a option\n\n val to_list : _ t -> elt list\n val to_array : _ t -> elt array\n\n (** Returns a min (resp max) element from the collection using the provided [compare]\n function, or [None] if the collection is empty. In case of a tie, the first element\n encountered while traversing the collection is returned. *)\n val min_elt : _ t -> compare:(elt -> elt -> int) -> elt option\n\n val max_elt : _ t -> compare:(elt -> elt -> int) -> elt option\nend\n\n(** Signature for polymorphic container, e.g., ['a list] or ['a array]. *)\nmodule type S1 = sig\n type 'a t\n\n (** Checks whether the provided element is there, using [equal]. *)\n val mem : 'a t -> 'a -> equal:('a -> 'a -> bool) -> bool\n\n val length : 'a t -> int\n val is_empty : 'a t -> bool\n val iter : 'a t -> f:('a -> unit) -> unit\n\n (** [fold t ~init ~f] returns [f (... f (f (f init e1) e2) e3 ...) en], where [e1..en]\n are the elements of [t] *)\n val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum\n\n (** [fold_result t ~init ~f] is a short-circuiting version of [fold] that runs in the\n [Result] monad. If [f] returns an [Error _], that value is returned without any\n additional invocations of [f]. *)\n val fold_result\n : 'a t\n -> init:'accum\n -> f:('accum -> 'a -> ('accum, 'e) Result.t)\n -> ('accum, 'e) Result.t\n\n (** [fold_until t ~init ~f ~finish] is a short-circuiting version of [fold]. If [f]\n returns [Stop _] the computation ceases and results in that value. If [f] returns\n [Continue _], the fold will proceed. If [f] never returns [Stop _], the final result\n is computed by [finish].\n\n Example:\n\n {[\n type maybe_negative =\n | Found_negative of int\n | All_nonnegative of { sum : int }\n\n (** [first_neg_or_sum list] returns the first negative number in [list], if any,\n otherwise returns the sum of the list. *)\n let first_neg_or_sum =\n List.fold_until ~init:0\n ~f:(fun sum x ->\n if x < 0\n then Stop (Found_negative x)\n else Continue (sum + x))\n ~finish:(fun sum -> All_nonnegative { sum })\n ;;\n\n let x = first_neg_or_sum [1; 2; 3; 4; 5]\n val x : maybe_negative = All_nonnegative {sum = 15}\n\n let y = first_neg_or_sum [1; 2; -3; 4; 5]\n val y : maybe_negative = Found_negative -3\n ]} *)\n val fold_until\n : 'a t\n -> init:'accum\n -> f:('accum -> 'a -> ('accum, 'final) Continue_or_stop.t)\n -> finish:('accum -> 'final)\n -> 'final\n\n (** Returns [true] if and only if there exists an element for which the provided\n function evaluates to [true]. This is a short-circuiting operation. *)\n val exists : 'a t -> f:('a -> bool) -> bool\n\n (** Returns [true] if and only if the provided function evaluates to [true] for all\n elements. This is a short-circuiting operation. *)\n val for_all : 'a t -> f:('a -> bool) -> bool\n\n (** Returns the number of elements for which the provided function evaluates to true. *)\n val count : 'a t -> f:('a -> bool) -> int\n\n (** Returns the sum of [f i] for all [i] in the container. *)\n val sum : (module Summable with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum\n\n (** Returns as an [option] the first element for which [f] evaluates to true. *)\n val find : 'a t -> f:('a -> bool) -> 'a option\n\n (** Returns the first evaluation of [f] that returns [Some], and returns [None] if there\n is no such element. *)\n val find_map : 'a t -> f:('a -> 'b option) -> 'b option\n\n val to_list : 'a t -> 'a list\n val to_array : 'a t -> 'a array\n\n (** Returns a minimum (resp maximum) element from the collection using the provided\n [compare] function, or [None] if the collection is empty. In case of a tie, the first\n element encountered while traversing the collection is returned. The implementation\n uses [fold] so it has the same complexity as [fold]. *)\n val min_elt : 'a t -> compare:('a -> 'a -> int) -> 'a option\n\n val max_elt : 'a t -> compare:('a -> 'a -> int) -> 'a option\nend\n\nmodule type S1_phantom_invariant = sig\n type ('a, 'phantom) t\n\n (** Checks whether the provided element is there, using [equal]. *)\n val mem : ('a, _) t -> 'a -> equal:('a -> 'a -> bool) -> bool\n\n val length : (_, _) t -> int\n val is_empty : (_, _) t -> bool\n val iter : ('a, _) t -> f:('a -> unit) -> unit\n\n (** [fold t ~init ~f] returns [f (... f (f (f init e1) e2) e3 ...) en], where [e1..en]\n are the elements of [t]. *)\n val fold : ('a, _) t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum\n\n (** [fold_result t ~init ~f] is a short-circuiting version of [fold] that runs in the\n [Result] monad. If [f] returns an [Error _], that value is returned without any\n additional invocations of [f]. *)\n val fold_result\n : ('a, _) t\n -> init:'accum\n -> f:('accum -> 'a -> ('accum, 'e) Result.t)\n -> ('accum, 'e) Result.t\n\n (** [fold_until t ~init ~f ~finish] is a short-circuiting version of [fold]. If [f]\n returns [Stop _] the computation ceases and results in that value. If [f] returns\n [Continue _], the fold will proceed. If [f] never returns [Stop _], the final result\n is computed by [finish].\n\n Example:\n\n {[\n type maybe_negative =\n | Found_negative of int\n | All_nonnegative of { sum : int }\n\n (** [first_neg_or_sum list] returns the first negative number in [list], if any,\n otherwise returns the sum of the list. *)\n let first_neg_or_sum =\n List.fold_until ~init:0\n ~f:(fun sum x ->\n if x < 0\n then Stop (Found_negative x)\n else Continue (sum + x))\n ~finish:(fun sum -> All_nonnegative { sum })\n ;;\n\n let x = first_neg_or_sum [1; 2; 3; 4; 5]\n val x : maybe_negative = All_nonnegative {sum = 15}\n\n let y = first_neg_or_sum [1; 2; -3; 4; 5]\n val y : maybe_negative = Found_negative -3\n ]} *)\n val fold_until\n : ('a, _) t\n -> init:'accum\n -> f:('accum -> 'a -> ('accum, 'final) Continue_or_stop.t)\n -> finish:('accum -> 'final)\n -> 'final\n\n (** Returns [true] if and only if there exists an element for which the provided\n function evaluates to [true]. This is a short-circuiting operation. *)\n val exists : ('a, _) t -> f:('a -> bool) -> bool\n\n (** Returns [true] if and only if the provided function evaluates to [true] for all\n elements. This is a short-circuiting operation. *)\n val for_all : ('a, _) t -> f:('a -> bool) -> bool\n\n (** Returns the number of elements for which the provided function evaluates to true. *)\n val count : ('a, _) t -> f:('a -> bool) -> int\n\n (** Returns the sum of [f i] for all [i] in the container. *)\n val sum : (module Summable with type t = 'sum) -> ('a, _) t -> f:('a -> 'sum) -> 'sum\n\n (** Returns as an [option] the first element for which [f] evaluates to true. *)\n val find : ('a, _) t -> f:('a -> bool) -> 'a option\n\n (** Returns the first evaluation of [f] that returns [Some], and returns [None] if there\n is no such element. *)\n val find_map : ('a, _) t -> f:('a -> 'b option) -> 'b option\n\n val to_list : ('a, _) t -> 'a list\n val to_array : ('a, _) t -> 'a array\n\n (** Returns a min (resp max) element from the collection using the provided [compare]\n function. In case of a tie, the first element encountered while traversing the\n collection is returned. The implementation uses [fold] so it has the same complexity\n as [fold]. Returns [None] iff the collection is empty. *)\n val min_elt : ('a, _) t -> compare:('a -> 'a -> int) -> 'a option\n\n val max_elt : ('a, _) t -> compare:('a -> 'a -> int) -> 'a option\nend\n\nmodule type S1_phantom = sig\n type ('a, +'phantom) t\n\n include S1_phantom_invariant with type ('a, 'phantom) t := ('a, 'phantom) t\nend\n\nmodule type Generic = sig\n type 'a t\n type 'a elt\n\n val length : _ t -> int\n val is_empty : _ t -> bool\n val iter : 'a t -> f:('a elt -> unit) -> unit\n val fold : 'a t -> init:'accum -> f:('accum -> 'a elt -> 'accum) -> 'accum\n\n val fold_result\n : 'a t\n -> init:'accum\n -> f:('accum -> 'a elt -> ('accum, 'e) Result.t)\n -> ('accum, 'e) Result.t\n\n val fold_until\n : 'a t\n -> init:'accum\n -> f:('accum -> 'a elt -> ('accum, 'final) Continue_or_stop.t)\n -> finish:('accum -> 'final)\n -> 'final\n\n val exists : 'a t -> f:('a elt -> bool) -> bool\n val for_all : 'a t -> f:('a elt -> bool) -> bool\n val count : 'a t -> f:('a elt -> bool) -> int\n val sum : (module Summable with type t = 'sum) -> 'a t -> f:('a elt -> 'sum) -> 'sum\n val find : 'a t -> f:('a elt -> bool) -> 'a elt option\n val find_map : 'a t -> f:('a elt -> 'b option) -> 'b option\n val to_list : 'a t -> 'a elt list\n val to_array : 'a t -> 'a elt array\n val min_elt : 'a t -> compare:('a elt -> 'a elt -> int) -> 'a elt option\n val max_elt : 'a t -> compare:('a elt -> 'a elt -> int) -> 'a elt option\nend\n\nmodule type Generic_phantom = sig\n type ('a, 'phantom) t\n type 'a elt\n\n val length : (_, _) t -> int\n val is_empty : (_, _) t -> bool\n val iter : ('a, _) t -> f:('a elt -> unit) -> unit\n val fold : ('a, _) t -> init:'accum -> f:('accum -> 'a elt -> 'accum) -> 'accum\n\n val fold_result\n : ('a, _) t\n -> init:'accum\n -> f:('accum -> 'a elt -> ('accum, 'e) Result.t)\n -> ('accum, 'e) Result.t\n\n val fold_until\n : ('a, _) t\n -> init:'accum\n -> f:('accum -> 'a elt -> ('accum, 'final) Continue_or_stop.t)\n -> finish:('accum -> 'final)\n -> 'final\n\n val exists : ('a, _) t -> f:('a elt -> bool) -> bool\n val for_all : ('a, _) t -> f:('a elt -> bool) -> bool\n val count : ('a, _) t -> f:('a elt -> bool) -> int\n\n val sum\n : (module Summable with type t = 'sum)\n -> ('a, _) t\n -> f:('a elt -> 'sum)\n -> 'sum\n\n val find : ('a, _) t -> f:('a elt -> bool) -> 'a elt option\n val find_map : ('a, _) t -> f:('a elt -> 'b option) -> 'b option\n val to_list : ('a, _) t -> 'a elt list\n val to_array : ('a, _) t -> 'a elt array\n val min_elt : ('a, _) t -> compare:('a elt -> 'a elt -> int) -> 'a elt option\n val max_elt : ('a, _) t -> compare:('a elt -> 'a elt -> int) -> 'a elt option\nend\n\nmodule type Make_gen_arg = sig\n type 'a t\n type 'a elt\n\n val fold : 'a t -> init:'accum -> f:('accum -> 'a elt -> 'accum) -> 'accum\n\n (** The [iter] argument to [Container.Make] specifies how to implement the\n container's [iter] function. [`Define_using_fold] means to define [iter]\n via:\n\n {[\n iter t ~f = Container.iter ~fold t ~f\n ]}\n\n [`Custom] overrides the default implementation, presumably with something more\n efficient. Several other functions returned by [Container.Make] are defined in\n terms of [iter], so passing in a more efficient [iter] will improve their efficiency\n as well. *)\n val iter : [ `Define_using_fold | `Custom of 'a t -> f:('a elt -> unit) -> unit ]\n\n (** The [length] argument to [Container.Make] specifies how to implement the\n container's [length] function. [`Define_using_fold] means to define\n [length] via:\n\n {[\n length t ~f = Container.length ~fold t ~f\n ]}\n\n [`Custom] overrides the default implementation, presumably with something more\n efficient. Several other functions returned by [Container.Make] are defined in\n terms of [length], so passing in a more efficient [length] will improve their\n efficiency as well. *)\n val length : [ `Define_using_fold | `Custom of 'a t -> int ]\nend\n\nmodule type Make_arg = Make_gen_arg with type 'a elt := 'a Monad.Ident.t\n\nmodule type Make0_arg = sig\n module Elt : sig\n type t\n\n val equal : t -> t -> bool\n end\n\n type t\n\n val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum\n val iter : [ `Define_using_fold | `Custom of t -> f:(Elt.t -> unit) -> unit ]\n val length : [ `Define_using_fold | `Custom of t -> int ]\nend\n\nmodule type Container = sig\n include module type of struct\n include Export\n end\n\n module type S0 = S0\n module type S0_phantom = S0_phantom\n module type S1 = S1\n module type S1_phantom_invariant = S1_phantom_invariant\n module type S1_phantom = S1_phantom\n module type Generic = Generic\n module type Generic_phantom = Generic_phantom\n module type Summable = Summable\n\n (** Generic definitions of container operations in terms of [fold].\n\n E.g.: [iter ~fold t ~f = fold t ~init:() ~f:(fun () a -> f a)]. *)\n\n type ('t, 'a, 'accum) fold = 't -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum\n type ('t, 'a) iter = 't -> f:('a -> unit) -> unit\n type 't length = 't -> int\n\n val iter : fold:('t, 'a, unit) fold -> ('t, 'a) iter\n val count : fold:('t, 'a, int) fold -> 't -> f:('a -> bool) -> int\n\n val min_elt\n : fold:('t, 'a, 'a option) fold\n -> 't\n -> compare:('a -> 'a -> int)\n -> 'a option\n\n val max_elt\n : fold:('t, 'a, 'a option) fold\n -> 't\n -> compare:('a -> 'a -> int)\n -> 'a option\n\n val length : fold:('t, _, int) fold -> 't -> int\n val to_list : fold:('t, 'a, 'a list) fold -> 't -> 'a list\n\n val sum\n : fold:('t, 'a, 'sum) fold\n -> (module Summable with type t = 'sum)\n -> 't\n -> f:('a -> 'sum)\n -> 'sum\n\n val fold_result\n : fold:('t, 'a, 'b) fold\n -> init:'b\n -> f:('b -> 'a -> ('b, 'e) Result.t)\n -> 't\n -> ('b, 'e) Result.t\n\n val fold_until\n : fold:('t, 'a, 'b) fold\n -> init:'b\n -> f:('b -> 'a -> ('b, 'final) Continue_or_stop.t)\n -> finish:('b -> 'final)\n -> 't\n -> 'final\n\n (** Generic definitions of container operations in terms of [iter] and [length]. *)\n val is_empty : iter:('t, 'a) iter -> 't -> bool\n\n val exists : iter:('t, 'a) iter -> 't -> f:('a -> bool) -> bool\n val for_all : iter:('t, 'a) iter -> 't -> f:('a -> bool) -> bool\n val find : iter:('t, 'a) iter -> 't -> f:('a -> bool) -> 'a option\n val find_map : iter:('t, 'a) iter -> 't -> f:('a -> 'b option) -> 'b option\n val to_array : length:'t length -> iter:('t, 'a) iter -> 't -> 'a array\n\n (** The idiom for using [Container.Make] is to bind the resulting module and to\n explicitly import each of the functions that one wants:\n\n {[\n module C = Container.Make (struct ... end)\n let count = C.count\n let exists = C.exists\n let find = C.find\n (* ... *)\n ]}\n\n This is preferable to:\n\n {[\n include Container.Make (struct ... end)\n ]}\n\n because the [include] makes it too easy to shadow specialized implementations of\n container functions ([length] being a common one).\n\n [Container.Make0] is like [Container.Make], but for monomorphic containers like\n [string]. *)\n module Make (T : Make_arg) : S1 with type 'a t := 'a T.t\n\n module Make0 (T : Make0_arg) : S0 with type t := T.t and type elt := T.Elt.t\nend\n","open! Import\nmodule Array = Array0\nmodule List = List0\ninclude Container_intf\n\nlet with_return = With_return.with_return\n\ntype ('t, 'a, 'accum) fold = 't -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum\ntype ('t, 'a) iter = 't -> f:('a -> unit) -> unit\ntype 't length = 't -> int\n\nlet iter ~fold t ~f = fold t ~init:() ~f:(fun () a -> f a)\nlet count ~fold t ~f = fold t ~init:0 ~f:(fun n a -> if f a then n + 1 else n)\n\nlet sum (type a) ~fold (module M : Summable with type t = a) t ~f =\n fold t ~init:M.zero ~f:(fun n a -> M.( + ) n (f a))\n;;\n\nlet fold_result ~fold ~init ~f t =\n with_return (fun { return } ->\n Result.Ok\n (fold t ~init ~f:(fun acc item ->\n match f acc item with\n | Result.Ok x -> x\n | Error _ as e -> return e)))\n;;\n\nlet fold_until ~fold ~init ~f ~finish t =\n with_return (fun { return } ->\n finish\n (fold t ~init ~f:(fun acc item ->\n match f acc item with\n | Continue_or_stop.Continue x -> x\n | Stop x -> return x)))\n;;\n\nlet min_elt ~fold t ~compare =\n fold t ~init:None ~f:(fun acc elt ->\n match acc with\n | None -> Some elt\n | Some min -> if compare min elt > 0 then Some elt else acc)\n;;\n\nlet max_elt ~fold t ~compare =\n fold t ~init:None ~f:(fun acc elt ->\n match acc with\n | None -> Some elt\n | Some max -> if compare max elt < 0 then Some elt else acc)\n;;\n\nlet length ~fold c = fold c ~init:0 ~f:(fun acc _ -> acc + 1)\n\nlet is_empty ~iter c =\n with_return (fun r ->\n iter c ~f:(fun _ -> r.return false);\n true)\n;;\n\nlet exists ~iter c ~f =\n with_return (fun r ->\n iter c ~f:(fun x -> if f x then r.return true);\n false)\n;;\n\nlet for_all ~iter c ~f =\n with_return (fun r ->\n iter c ~f:(fun x -> if not (f x) then r.return false);\n true)\n;;\n\nlet find_map ~iter t ~f =\n with_return (fun r ->\n iter t ~f:(fun x ->\n match f x with\n | None -> ()\n | Some _ as res -> r.return res);\n None)\n;;\n\nlet find ~iter c ~f =\n with_return (fun r ->\n iter c ~f:(fun x -> if f x then r.return (Some x));\n None)\n;;\n\nlet to_list ~fold c = List.rev (fold c ~init:[] ~f:(fun acc x -> x :: acc))\n\nlet to_array ~length ~iter c =\n let array = ref [||] in\n let i = ref 0 in\n iter c ~f:(fun x ->\n if !i = 0 then array := Array.create ~len:(length c) x;\n !array.(!i) <- x;\n incr i);\n !array\n;;\n\nmodule Make_gen (T : Make_gen_arg) : sig\n include Generic with type 'a t := 'a T.t with type 'a elt := 'a T.elt\nend = struct\n let fold = T.fold\n\n let iter =\n match T.iter with\n | `Custom iter -> iter\n | `Define_using_fold -> fun t ~f -> iter ~fold t ~f\n ;;\n\n let length =\n match T.length with\n | `Custom length -> length\n | `Define_using_fold -> fun t -> length ~fold t\n ;;\n\n let is_empty t = is_empty ~iter t\n let sum m t = sum ~fold m t\n let count t ~f = count ~fold t ~f\n let exists t ~f = exists ~iter t ~f\n let for_all t ~f = for_all ~iter t ~f\n let find_map t ~f = find_map ~iter t ~f\n let find t ~f = find ~iter t ~f\n let to_list t = to_list ~fold t\n let to_array t = to_array ~length ~iter t\n let min_elt t ~compare = min_elt ~fold t ~compare\n let max_elt t ~compare = max_elt ~fold t ~compare\n let fold_result t ~init ~f = fold_result t ~fold ~init ~f\n let fold_until t ~init ~f ~finish = fold_until t ~fold ~init ~f ~finish\nend\n\nmodule Make (T : Make_arg) = struct\n include Make_gen (struct\n include T\n\n type 'a elt = 'a\n end)\n\n let mem t a ~equal = exists t ~f:(equal a)\nend\n\nmodule Make0 (T : Make0_arg) = struct\n include Make_gen (struct\n include (T : Make0_arg with type t := T.t with module Elt := T.Elt)\n\n type 'a t = T.t\n type 'a elt = T.Elt.t\n end)\n\n let mem t elt = exists t ~f:(T.Elt.equal elt)\nend\n\nopen T\n\n\n(* The following functors exist as a consistency check among all the various [S?]\n interfaces. They ensure that each particular [S?] is an instance of a more generic\n signature. *)\nmodule Check\n (T : T1)\n (Elt : T1)\n (M : Generic with type 'a t := 'a T.t with type 'a elt := 'a Elt.t) =\nstruct end\n\nmodule Check_S0 (M : S0) =\n Check\n (struct\n type 'a t = M.t\n end)\n (struct\n type 'a t = M.elt\n end)\n (M)\n\nmodule Check_S0_phantom (M : S0_phantom) =\n Check\n (struct\n type 'a t = 'a M.t\n end)\n (struct\n type 'a t = M.elt\n end)\n (M)\n\nmodule Check_S1 (M : S1) =\n Check\n (struct\n type 'a t = 'a M.t\n end)\n (struct\n type 'a t = 'a\n end)\n (M)\n\ntype phantom\n\nmodule Check_S1_phantom (M : S1_phantom) =\n Check\n (struct\n type 'a t = ('a, phantom) M.t\n end)\n (struct\n type 'a t = 'a\n end)\n (M)\n\nmodule Check_S1_phantom_invariant (M : S1_phantom_invariant) =\n Check\n (struct\n type 'a t = ('a, phantom) M.t\n end)\n (struct\n type 'a t = 'a\n end)\n (M)\n","open! Import\n\ntype 'a t = 'a lazy_t [@@deriving_inline sexp]\n\nlet t_of_sexp : 'a. (Ppx_sexp_conv_lib.Sexp.t -> 'a) -> Ppx_sexp_conv_lib.Sexp.t -> 'a t =\n lazy_t_of_sexp\n;;\n\nlet sexp_of_t : 'a. ('a -> Ppx_sexp_conv_lib.Sexp.t) -> 'a t -> Ppx_sexp_conv_lib.Sexp.t =\n sexp_of_lazy_t\n;;\n\n[@@@end]\n\ninclude (Caml.Lazy : module type of Caml.Lazy with type 'a t := 'a t)\n\nlet map t ~f = lazy (f (force t))\n\nlet compare compare_a t1 t2 =\n if phys_equal t1 t2 then 0 else compare_a (force t1) (force t2)\n;;\n\nlet hash_fold_t = Hash.Builtin.hash_fold_lazy_t\n\ninclude Monad.Make (struct\n type nonrec 'a t = 'a t\n\n let return x = from_val x\n let bind t ~f = lazy (force (f (force t)))\n let map = map\n let map = `Custom map\n end)\n\nmodule T_unforcing = struct\n type nonrec 'a t = 'a t\n\n let sexp_of_t sexp_of_a t =\n if is_val t then sexp_of_a (force t) else sexp_of_string \"\"\n ;;\nend\n","open! Import\n\nmodule type Basic = sig\n type 'a t\n\n val bind : 'a t -> f:('a -> 'b t) -> 'b t\n val return : 'a -> 'a t\n\n (** The following identities ought to hold (for some value of =):\n\n - [return x >>= f = f x]\n - [t >>= fun x -> return x = t]\n - [(t >>= f) >>= g = t >>= fun x -> (f x >>= g)]\n\n Note: [>>=] is the infix notation for [bind]) *)\n\n (** The [map] argument to [Monad.Make] says how to implement the monad's [map] function.\n [`Define_using_bind] means to define [map t ~f = bind t ~f:(fun a -> return (f a))].\n [`Custom] overrides the default implementation, presumably with something more\n efficient.\n\n Some other functions returned by [Monad.Make] are defined in terms of [map], so\n passing in a more efficient [map] will improve their efficiency as well. *)\n val map : [ `Define_using_bind | `Custom of 'a t -> f:('a -> 'b) -> 'b t ]\nend\n\nmodule type Infix = sig\n type 'a t\n\n (** [t >>= f] returns a computation that sequences the computations represented by two\n monad elements. The resulting computation first does [t] to yield a value [v], and\n then runs the computation returned by [f v]. *)\n val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t\n\n (** [t >>| f] is [t >>= (fun a -> return (f a))]. *)\n val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t\nend\n\n(** Opening a module of this type allows one to use the [%bind] and [%map] syntax\n extensions defined by ppx_let, and brings [return] into scope. *)\nmodule type Syntax = sig\n type 'a t\n\n module Let_syntax : sig\n (** These are convenient to have in scope when programming with a monad: *)\n\n val return : 'a -> 'a t\n\n include Infix with type 'a t := 'a t\n\n module Let_syntax : sig\n val return : 'a -> 'a t\n val bind : 'a t -> f:('a -> 'b t) -> 'b t\n val map : 'a t -> f:('a -> 'b) -> 'b t\n val both : 'a t -> 'b t -> ('a * 'b) t\n\n module Open_on_rhs : sig end\n end\n end\nend\n\nmodule type S_without_syntax = sig\n type 'a t\n\n include Infix with type 'a t := 'a t\n module Monad_infix : Infix with type 'a t := 'a t\n\n (** [bind t ~f] = [t >>= f] *)\n val bind : 'a t -> f:('a -> 'b t) -> 'b t\n\n (** [return v] returns the (trivial) computation that returns v. *)\n val return : 'a -> 'a t\n\n (** [map t ~f] is t >>| f. *)\n val map : 'a t -> f:('a -> 'b) -> 'b t\n\n (** [join t] is [t >>= (fun t' -> t')]. *)\n val join : 'a t t -> 'a t\n\n (** [ignore_m t] is [map t ~f:(fun _ -> ())]. [ignore_m] used to be called [ignore],\n but we decided that was a bad name, because it shadowed the widely used\n [Caml.ignore]. Some monads still do [let ignore = ignore_m] for historical\n reasons. *)\n val ignore_m : 'a t -> unit t\n\n val all : 'a t list -> 'a list t\n\n (** Like [all], but ensures that every monadic value in the list produces a unit value,\n all of which are discarded rather than being collected into a list. *)\n val all_unit : unit t list -> unit t\nend\n\nmodule type S = sig\n type 'a t\n\n include S_without_syntax with type 'a t := 'a t\n include Syntax with type 'a t := 'a t\nend\n\n(** Multi parameter monad. The second parameter gets unified across all the computation.\n This is used to encode monads working on a multi parameter data structure like\n ([('a,'b) result]). *)\nmodule type Basic2 = sig\n type ('a, 'e) t\n\n val bind : ('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t\n val map : [ `Define_using_bind | `Custom of ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t ]\n val return : 'a -> ('a, _) t\nend\n\n(** Same as Infix, except the monad type has two arguments. The second is always just\n passed through. *)\nmodule type Infix2 = sig\n type ('a, 'e) t\n\n val ( >>= ) : ('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t\n val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t\nend\n\nmodule type Syntax2 = sig\n type ('a, 'e) t\n\n module Let_syntax : sig\n val return : 'a -> ('a, _) t\n\n include Infix2 with type ('a, 'e) t := ('a, 'e) t\n\n module Let_syntax : sig\n val return : 'a -> ('a, _) t\n val bind : ('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t\n val map : ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t\n val both : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t\n\n module Open_on_rhs : sig end\n end\n end\nend\n\n(** The same as S except the monad type has two arguments. The second is always just\n passed through. *)\nmodule type S2 = sig\n type ('a, 'e) t\n\n include Infix2 with type ('a, 'e) t := ('a, 'e) t\n include Syntax2 with type ('a, 'e) t := ('a, 'e) t\n module Monad_infix : Infix2 with type ('a, 'e) t := ('a, 'e) t\n\n val bind : ('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t\n val return : 'a -> ('a, _) t\n val map : ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t\n val join : (('a, 'e) t, 'e) t -> ('a, 'e) t\n val ignore_m : (_, 'e) t -> (unit, 'e) t\n val all : ('a, 'e) t list -> ('a list, 'e) t\n val all_unit : (unit, 'e) t list -> (unit, 'e) t\nend\n\n(** Multi parameter monad. The second and third parameters get unified across all the\n computation. *)\nmodule type Basic3 = sig\n type ('a, 'd, 'e) t\n\n val bind : ('a, 'd, 'e) t -> f:('a -> ('b, 'd, 'e) t) -> ('b, 'd, 'e) t\n\n val map\n : [ `Define_using_bind | `Custom of ('a, 'd, 'e) t -> f:('a -> 'b) -> ('b, 'd, 'e) t ]\n\n val return : 'a -> ('a, _, _) t\nend\n\n(** Same as Infix, except the monad type has three arguments. The second and third are\n always just passed through. *)\nmodule type Infix3 = sig\n type ('a, 'd, 'e) t\n\n val ( >>= ) : ('a, 'd, 'e) t -> ('a -> ('b, 'd, 'e) t) -> ('b, 'd, 'e) t\n val ( >>| ) : ('a, 'd, 'e) t -> ('a -> 'b) -> ('b, 'd, 'e) t\nend\n\nmodule type Syntax3 = sig\n type ('a, 'd, 'e) t\n\n module Let_syntax : sig\n val return : 'a -> ('a, _, _) t\n\n include Infix3 with type ('a, 'd, 'e) t := ('a, 'd, 'e) t\n\n module Let_syntax : sig\n val return : 'a -> ('a, _, _) t\n val bind : ('a, 'd, 'e) t -> f:('a -> ('b, 'd, 'e) t) -> ('b, 'd, 'e) t\n val map : ('a, 'd, 'e) t -> f:('a -> 'b) -> ('b, 'd, 'e) t\n val both : ('a, 'd, 'e) t -> ('b, 'd, 'e) t -> ('a * 'b, 'd, 'e) t\n\n module Open_on_rhs : sig end\n end\n end\nend\n\n(** The same as S except the monad type has three arguments. The second and third are\n always just passed through. *)\nmodule type S3 = sig\n type ('a, 'd, 'e) t\n\n include Infix3 with type ('a, 'd, 'e) t := ('a, 'd, 'e) t\n include Syntax3 with type ('a, 'd, 'e) t := ('a, 'd, 'e) t\n module Monad_infix : Infix3 with type ('a, 'd, 'e) t := ('a, 'd, 'e) t\n\n val bind : ('a, 'd, 'e) t -> f:('a -> ('b, 'd, 'e) t) -> ('b, 'd, 'e) t\n val return : 'a -> ('a, _, _) t\n val map : ('a, 'd, 'e) t -> f:('a -> 'b) -> ('b, 'd, 'e) t\n val join : (('a, 'd, 'e) t, 'd, 'e) t -> ('a, 'd, 'e) t\n val ignore_m : (_, 'd, 'e) t -> (unit, 'd, 'e) t\n val all : ('a, 'd, 'e) t list -> ('a list, 'd, 'e) t\n val all_unit : (unit, 'd, 'e) t list -> (unit, 'd, 'e) t\nend\n\n(** Indexed monad, in the style of Atkey. The second and third parameters are composed\n across all computation. To see this more clearly, you can look at the type of bind:\n\n {[\n val bind : ('a, 'i, 'j) t -> f:('a -> ('b, 'j, 'k) t) -> ('b, 'i, 'k) t\n ]}\n\n and isolate some of the type variables to see their individual behaviors:\n\n {[\n val bind : 'a -> f:('a -> 'b ) -> 'b\n val bind : 'i, 'j -> 'j, 'k -> 'i, 'k\n ]}\n\n For more information on Atkey-style indexed monads, see:\n\n {v\n Parameterised Notions of Computation\n Robert Atkey\n http://bentnib.org/paramnotions-jfp.pdf\n v} *)\nmodule type Basic_indexed = sig\n type ('a, 'i, 'j) t\n\n val bind : ('a, 'i, 'j) t -> f:('a -> ('b, 'j, 'k) t) -> ('b, 'i, 'k) t\n\n val map\n : [ `Define_using_bind | `Custom of ('a, 'i, 'j) t -> f:('a -> 'b) -> ('b, 'i, 'j) t ]\n\n val return : 'a -> ('a, 'i, 'i) t\nend\n\n(** Same as Infix, except the monad type has three arguments. The second and third are\n compose across all computation. *)\nmodule type Infix_indexed = sig\n type ('a, 'i, 'j) t\n\n val ( >>= ) : ('a, 'i, 'j) t -> ('a -> ('b, 'j, 'k) t) -> ('b, 'i, 'k) t\n val ( >>| ) : ('a, 'i, 'j) t -> ('a -> 'b) -> ('b, 'i, 'j) t\nend\n\nmodule type Syntax_indexed = sig\n type ('a, 'i, 'j) t\n\n module Let_syntax : sig\n val return : 'a -> ('a, 'i, 'i) t\n\n include Infix_indexed with type ('a, 'i, 'j) t := ('a, 'i, 'j) t\n\n module Let_syntax : sig\n val return : 'a -> ('a, 'i, 'i) t\n val bind : ('a, 'i, 'j) t -> f:('a -> ('b, 'j, 'k) t) -> ('b, 'i, 'k) t\n val map : ('a, 'i, 'j) t -> f:('a -> 'b) -> ('b, 'i, 'j) t\n val both : ('a, 'i, 'j) t -> ('b, 'j, 'k) t -> ('a * 'b, 'i, 'k) t\n\n module Open_on_rhs : sig end\n end\n end\nend\n\n(** The same as S except the monad type has three arguments. The second and third are\n composed across all computation. *)\nmodule type S_indexed = sig\n type ('a, 'i, 'j) t\n\n include Infix_indexed with type ('a, 'i, 'j) t := ('a, 'i, 'j) t\n include Syntax_indexed with type ('a, 'i, 'j) t := ('a, 'i, 'j) t\n module Monad_infix : Infix_indexed with type ('a, 'i, 'j) t := ('a, 'i, 'j) t\n\n val bind : ('a, 'i, 'j) t -> f:('a -> ('b, 'j, 'k) t) -> ('b, 'i, 'k) t\n val return : 'a -> ('a, 'i, 'i) t\n val map : ('a, 'i, 'j) t -> f:('a -> 'b) -> ('b, 'i, 'j) t\n val join : (('a, 'j, 'k) t, 'i, 'j) t -> ('a, 'i, 'k) t\n val ignore_m : (_, 'i, 'j) t -> (unit, 'i, 'j) t\n val all : ('a, 'i, 'i) t list -> ('a list, 'i, 'i) t\n val all_unit : (unit, 'i, 'i) t list -> (unit, 'i, 'i) t\nend\n\nmodule S_to_S2 (X : S) : S2 with type ('a, 'e) t = 'a X.t = struct\n type ('a, 'e) t = 'a X.t\n\n include (X : S with type 'a t := 'a X.t)\nend\n\nmodule S2_to_S3 (X : S2) : S3 with type ('a, 'd, 'e) t = ('a, 'd) X.t = struct\n type ('a, 'd, 'e) t = ('a, 'd) X.t\n\n include (X : S2 with type ('a, 'd) t := ('a, 'd) X.t)\nend\n\nmodule S_to_S_indexed (X : S) : S_indexed with type ('a, 'i, 'j) t = 'a X.t = struct\n type ('a, 'i, 'j) t = 'a X.t\n\n include (X : S with type 'a t := 'a X.t)\nend\n\nmodule S2_to_S (X : S2) : S with type 'a t = ('a, unit) X.t = struct\n type 'a t = ('a, unit) X.t\n\n include (X : S2 with type ('a, 'e) t := ('a, 'e) X.t)\nend\n\nmodule S3_to_S2 (X : S3) : S2 with type ('a, 'e) t = ('a, 'e, unit) X.t = struct\n type ('a, 'e) t = ('a, 'e, unit) X.t\n\n include (X : S3 with type ('a, 'd, 'e) t := ('a, 'd, 'e) X.t)\nend\n\nmodule S_indexed_to_S2 (X : S_indexed) : S2 with type ('a, 'e) t = ('a, 'e, 'e) X.t =\nstruct\n type ('a, 'e) t = ('a, 'e, 'e) X.t\n\n include (X : S_indexed with type ('a, 'i, 'j) t := ('a, 'i, 'j) X.t)\nend\n\nmodule type Monad = sig\n (** A monad is an abstraction of the concept of sequencing of computations. A value of\n type ['a monad] represents a computation that returns a value of type ['a]. *)\n\n module type Basic = Basic\n module type Basic2 = Basic2\n module type Basic3 = Basic3\n module type Basic_indexed = Basic_indexed\n module type Infix = Infix\n module type Infix2 = Infix2\n module type Infix3 = Infix3\n module type Infix_indexed = Infix_indexed\n module type Syntax = Syntax\n module type Syntax2 = Syntax2\n module type Syntax3 = Syntax3\n module type Syntax_indexed = Syntax_indexed\n module type S_without_syntax = S_without_syntax\n module type S = S\n module type S2 = S2\n module type S3 = S3\n module type S_indexed = S_indexed\n\n module Make (X : Basic) : S with type 'a t := 'a X.t\n module Make2 (X : Basic2) : S2 with type ('a, 'e) t := ('a, 'e) X.t\n module Make3 (X : Basic3) : S3 with type ('a, 'd, 'e) t := ('a, 'd, 'e) X.t\n\n module Make_indexed (X : Basic_indexed) :\n S_indexed with type ('a, 'd, 'e) t := ('a, 'd, 'e) X.t\n\n module Ident : S with type 'a t = 'a\nend\n","open! Import\n\nlet const c _ = c\n\nexternal ignore : _ -> unit = \"%ignore\"\n\n(* this has the same behavior as [Caml.ignore] *)\n\nlet non f x = not (f x)\n\nlet forever f =\n let rec forever () =\n f ();\n forever ()\n in\n try forever () with\n | e -> e\n;;\n\nexternal id : 'a -> 'a = \"%identity\"\nexternal ( |> ) : 'a -> ('a -> 'b) -> 'b = \"%revapply\"\n\n(* The typical use case for these functions is to pass in functional arguments and get\n functions as a result. *)\nlet compose f g x = f (g x)\nlet flip f x y = f y x\nlet rec apply_n_times ~n f x = if n <= 0 then x else apply_n_times ~n:(n - 1) f (f x)\n","open! Import\nmodule Array = Array0\nmodule Either = Either0\n\n\ninclude List1\n\n(* This itself includes [List0]. *)\n\nlet invalid_argf = Printf.invalid_argf\n\nmodule T = struct\n type 'a t = 'a list [@@deriving_inline sexp, sexp_grammar]\n\n let t_of_sexp :\n 'a. (Ppx_sexp_conv_lib.Sexp.t -> 'a) -> Ppx_sexp_conv_lib.Sexp.t -> 'a t\n =\n list_of_sexp\n ;;\n\n let sexp_of_t :\n 'a. ('a -> Ppx_sexp_conv_lib.Sexp.t) -> 'a t -> Ppx_sexp_conv_lib.Sexp.t\n =\n sexp_of_list\n ;;\n\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group) =\n { implicit_vars = [ \"list\" ]\n ; ggid = \"j\\132);\\135qH\\158\\135\\222H\\001\\007\\004\\158\\218\"\n ; types =\n [ \"t\", Explicit_bind ([ \"a\" ], Apply (Implicit_var 0, [ Explicit_var 0 ])) ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ list_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"list.ml.T\"\n }\n in\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"t\", _the_group)\n in\n t_sexp_grammar\n ;;\n\n [@@@end]\nend\n\nmodule Or_unequal_lengths = struct\n type 'a t =\n | Ok of 'a\n | Unequal_lengths\n [@@deriving_inline compare, sexp_of]\n\n let compare : 'a. ('a -> 'a -> int) -> 'a t -> 'a t -> int =\n fun _cmp__a a__001_ b__002_ ->\n if Ppx_compare_lib.phys_equal a__001_ b__002_\n then 0\n else (\n match a__001_, b__002_ with\n | Ok _a__003_, Ok _b__004_ -> _cmp__a _a__003_ _b__004_\n | Ok _, _ -> -1\n | _, Ok _ -> 1\n | Unequal_lengths, Unequal_lengths -> 0)\n ;;\n\n let sexp_of_t\n : type a. (a -> Ppx_sexp_conv_lib.Sexp.t) -> a t -> Ppx_sexp_conv_lib.Sexp.t\n =\n fun _of_a -> function\n | Ok v0 ->\n let v0 = _of_a v0 in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"Ok\"; v0 ]\n | Unequal_lengths -> Ppx_sexp_conv_lib.Sexp.Atom \"Unequal_lengths\"\n ;;\n\n [@@@end]\nend\n\ninclude T\n\nlet invariant f t = iter t ~f\nlet of_list t = t\n\nlet range' ~compare ~stride ?(start = `inclusive) ?(stop = `exclusive) start_i stop_i =\n let next_i = stride start_i in\n let order x y = Ordering.of_int (compare x y) in\n let raise_stride_cannot_return_same_value () =\n invalid_arg \"List.range': stride function cannot return the same value\"\n in\n let initial_stride_order =\n match order start_i next_i with\n | Equal -> raise_stride_cannot_return_same_value ()\n | Less -> `Less\n | Greater -> `Greater\n in\n let rec loop i accum =\n let i_to_stop_order = order i stop_i in\n match i_to_stop_order, initial_stride_order with\n | Less, `Less | Greater, `Greater ->\n (* haven't yet reached [stop_i]. Continue. *)\n let next_i = stride i in\n (match order i next_i, initial_stride_order with\n | Equal, _ -> raise_stride_cannot_return_same_value ()\n | Less, `Greater | Greater, `Less ->\n invalid_arg \"List.range': stride function cannot change direction\"\n | Less, `Less | Greater, `Greater -> loop next_i (i :: accum))\n | Less, `Greater | Greater, `Less ->\n (* stepped past [stop_i]. Finished. *)\n accum\n | Equal, _ ->\n (* reached [stop_i]. Finished. *)\n (match stop with\n | `inclusive -> i :: accum\n | `exclusive -> accum)\n in\n let start_i =\n match start with\n | `inclusive -> start_i\n | `exclusive -> next_i\n in\n rev (loop start_i [])\n;;\n\nlet range ?(stride = 1) ?(start = `inclusive) ?(stop = `exclusive) start_i stop_i =\n if stride = 0 then invalid_arg \"List.range: stride must be non-zero\";\n range' ~compare ~stride:(fun x -> x + stride) ~start ~stop start_i stop_i\n;;\n\nlet hd t =\n match t with\n | [] -> None\n | x :: _ -> Some x\n;;\n\nlet tl t =\n match t with\n | [] -> None\n | _ :: t' -> Some t'\n;;\n\nlet nth t n =\n if n < 0\n then None\n else (\n let rec nth_aux t n =\n match t with\n | [] -> None\n | a :: t -> if n = 0 then Some a else nth_aux t (n - 1)\n in\n nth_aux t n)\n;;\n\nlet nth_exn t n =\n match nth t n with\n | None -> invalid_argf \"List.nth_exn %d called on list of length %d\" n (length t) ()\n | Some a -> a\n;;\n\nlet unordered_append l1 l2 =\n match l1, l2 with\n | [], l | l, [] -> l\n | _ -> rev_append l1 l2\n;;\n\nlet check_length2_exn name l1 l2 =\n let n1 = length l1 in\n let n2 = length l2 in\n if n1 <> n2 then invalid_argf \"length mismatch in %s: %d <> %d\" name n1 n2 ()\n;;\n\nlet check_length3_exn name l1 l2 l3 =\n let n1 = length l1 in\n let n2 = length l2 in\n let n3 = length l3 in\n if n1 <> n2 || n2 <> n3\n then invalid_argf \"length mismatch in %s: %d <> %d || %d <> %d\" name n1 n2 n2 n3 ()\n;;\n\nlet check_length2 l1 l2 ~f =\n if length l1 <> length l2 then Or_unequal_lengths.Unequal_lengths else Ok (f l1 l2)\n;;\n\nlet check_length3 l1 l2 l3 ~f =\n let n1 = length l1 in\n let n2 = length l2 in\n let n3 = length l3 in\n if n1 <> n2 || n2 <> n3 then Or_unequal_lengths.Unequal_lengths else Ok (f l1 l2 l3)\n;;\n\nlet iter2 l1 l2 ~f = check_length2 l1 l2 ~f:(iter2_ok ~f)\n\nlet iter2_exn l1 l2 ~f =\n check_length2_exn \"iter2_exn\" l1 l2;\n iter2_ok l1 l2 ~f\n;;\n\nlet rev_map2 l1 l2 ~f = check_length2 l1 l2 ~f:(rev_map2_ok ~f)\n\nlet rev_map2_exn l1 l2 ~f =\n check_length2_exn \"rev_map2_exn\" l1 l2;\n rev_map2_ok l1 l2 ~f\n;;\n\nlet fold2 l1 l2 ~init ~f = check_length2 l1 l2 ~f:(fold2_ok ~init ~f)\n\nlet fold2_exn l1 l2 ~init ~f =\n check_length2_exn \"fold2_exn\" l1 l2;\n fold2_ok l1 l2 ~init ~f\n;;\n\nlet for_all2 l1 l2 ~f = check_length2 l1 l2 ~f:(for_all2_ok ~f)\n\nlet for_all2_exn l1 l2 ~f =\n check_length2_exn \"for_all2_exn\" l1 l2;\n for_all2_ok l1 l2 ~f\n;;\n\nlet exists2 l1 l2 ~f = check_length2 l1 l2 ~f:(exists2_ok ~f)\n\nlet exists2_exn l1 l2 ~f =\n check_length2_exn \"exists2_exn\" l1 l2;\n exists2_ok l1 l2 ~f\n;;\n\nlet mem t a ~equal =\n let rec loop equal a = function\n | [] -> false\n | b :: bs -> equal a b || loop equal a bs\n in\n loop equal a t\n;;\n\n(* This is a copy of the code from the standard library, with an extra eta-expansion to\n avoid creating partial closures (showed up for [filter]) in profiling). *)\nlet rev_filter t ~f =\n let rec find ~f accu = function\n | [] -> accu\n | x :: l -> if f x then find ~f (x :: accu) l else find ~f accu l\n in\n find ~f [] t\n;;\n\nlet filter t ~f = rev (rev_filter t ~f)\n\nlet find_map t ~f =\n let rec loop = function\n | [] -> None\n | x :: l ->\n (match f x with\n | None -> loop l\n | Some _ as r -> r)\n in\n loop t\n;;\n\nlet find_map_exn =\n let not_found = Not_found_s (Atom \"List.find_map_exn: not found\") in\n let find_map_exn t ~f =\n match find_map t ~f with\n | None -> raise not_found\n | Some x -> x\n in\n (* named to preserve symbol in compiled binary *)\n find_map_exn\n;;\n\nlet find t ~f =\n let rec loop = function\n | [] -> None\n | x :: l -> if f x then Some x else loop l\n in\n loop t\n;;\n\nlet find_exn =\n let not_found = Not_found_s (Atom \"List.find_exn: not found\") in\n let rec find_exn t ~f =\n match t with\n | [] -> raise not_found\n | x :: t -> if f x then x else find_exn t ~f\n in\n (* named to preserve symbol in compiled binary *)\n find_exn\n;;\n\nlet findi t ~f =\n let rec loop i t =\n match t with\n | [] -> None\n | x :: l -> if f i x then Some (i, x) else loop (i + 1) l\n in\n loop 0 t\n;;\n\nlet find_mapi t ~f =\n let rec loop i t =\n match t with\n | [] -> None\n | x :: l ->\n (match f i x with\n | Some _ as result -> result\n | None -> loop (i + 1) l)\n in\n loop 0 t\n;;\n\nlet find_mapi_exn =\n let not_found = Not_found_s (Atom \"List.find_mapi_exn: not found\") in\n let find_mapi_exn t ~f =\n match find_mapi t ~f with\n | None -> raise not_found\n | Some x -> x\n in\n (* named to preserve symbol in compiled binary *)\n find_mapi_exn\n;;\n\nlet for_alli t ~f =\n let rec loop i t =\n match t with\n | [] -> true\n | hd :: tl -> f i hd && loop (i + 1) tl\n in\n loop 0 t\n;;\n\nlet existsi t ~f =\n let rec loop i t =\n match t with\n | [] -> false\n | hd :: tl -> f i hd || loop (i + 1) tl\n in\n loop 0 t\n;;\n\n(** For the container interface. *)\nlet fold_left = fold\n\nlet to_array = Array.of_list\nlet to_list t = t\n\n(** Tail recursive versions of standard [List] module *)\n\nlet slow_append l1 l2 = rev_append (rev l1) l2\n\n(* There are a few optimized list operations here, including append and map. There are\n basically two optimizations in play: loop unrolling, and dynamic switching between\n stack and heap allocation.\n\n The loop-unrolling is straightforward, we just unroll 5 levels of the loop. This makes\n each iteration faster, and also reduces the number of stack frames consumed per list\n element.\n\n The dynamic switching is done by counting the number of stack frames, and then\n switching to the \"slow\" implementation when we exceed a given limit. This means that\n short lists use the fast stack-allocation method, and long lists use a slower one that\n doesn't require stack space. *)\nlet rec count_append l1 l2 count =\n match l2 with\n | [] -> l1\n | _ ->\n (match l1 with\n | [] -> l2\n | [ x1 ] -> x1 :: l2\n | [ x1; x2 ] -> x1 :: x2 :: l2\n | [ x1; x2; x3 ] -> x1 :: x2 :: x3 :: l2\n | [ x1; x2; x3; x4 ] -> x1 :: x2 :: x3 :: x4 :: l2\n | x1 :: x2 :: x3 :: x4 :: x5 :: tl ->\n x1\n :: x2\n :: x3\n :: x4\n :: x5\n :: (if count > 1000 then slow_append tl l2 else count_append tl l2 (count + 1)))\n;;\n\nlet append l1 l2 = count_append l1 l2 0\nlet slow_map l ~f = rev (rev_map l ~f)\n\nlet rec count_map ~f l ctr =\n match l with\n | [] -> []\n | [ x1 ] ->\n let f1 = f x1 in\n [ f1 ]\n | [ x1; x2 ] ->\n let f1 = f x1 in\n let f2 = f x2 in\n [ f1; f2 ]\n | [ x1; x2; x3 ] ->\n let f1 = f x1 in\n let f2 = f x2 in\n let f3 = f x3 in\n [ f1; f2; f3 ]\n | [ x1; x2; x3; x4 ] ->\n let f1 = f x1 in\n let f2 = f x2 in\n let f3 = f x3 in\n let f4 = f x4 in\n [ f1; f2; f3; f4 ]\n | x1 :: x2 :: x3 :: x4 :: x5 :: tl ->\n let f1 = f x1 in\n let f2 = f x2 in\n let f3 = f x3 in\n let f4 = f x4 in\n let f5 = f x5 in\n f1\n :: f2\n :: f3\n :: f4\n :: f5\n :: (if ctr > 1000 then slow_map ~f tl else count_map ~f tl (ctr + 1))\n;;\n\nlet map l ~f = count_map ~f l 0\n\nlet folding_map t ~init ~f =\n let acc = ref init in\n map t ~f:(fun x ->\n let new_acc, y = f !acc x in\n acc := new_acc;\n y)\n;;\n\nlet fold_map t ~init ~f =\n let acc = ref init in\n let result =\n map t ~f:(fun x ->\n let new_acc, y = f !acc x in\n acc := new_acc;\n y)\n in\n !acc, result\n;;\n\nlet ( >>| ) l f = map l ~f\nlet map2_ok l1 l2 ~f = rev (rev_map2_ok l1 l2 ~f)\nlet map2 l1 l2 ~f = check_length2 l1 l2 ~f:(map2_ok ~f)\n\nlet map2_exn l1 l2 ~f =\n check_length2_exn \"map2_exn\" l1 l2;\n map2_ok l1 l2 ~f\n;;\n\nlet rev_map3_ok l1 l2 l3 ~f =\n let rec loop l1 l2 l3 ac =\n match l1, l2, l3 with\n | [], [], [] -> ac\n | x1 :: l1, x2 :: l2, x3 :: l3 -> loop l1 l2 l3 (f x1 x2 x3 :: ac)\n | _ -> assert false\n in\n loop l1 l2 l3 []\n;;\n\nlet rev_map3 l1 l2 l3 ~f = check_length3 l1 l2 l3 ~f:(rev_map3_ok ~f)\n\nlet rev_map3_exn l1 l2 l3 ~f =\n check_length3_exn \"rev_map3_exn\" l1 l2 l3;\n rev_map3_ok l1 l2 l3 ~f\n;;\n\nlet map3_ok l1 l2 l3 ~f = rev (rev_map3_ok l1 l2 l3 ~f)\nlet map3 l1 l2 l3 ~f = check_length3 l1 l2 l3 ~f:(map3_ok ~f)\n\nlet map3_exn l1 l2 l3 ~f =\n check_length3_exn \"map3_exn\" l1 l2 l3;\n map3_ok l1 l2 l3 ~f\n;;\n\nlet rec rev_map_append l1 l2 ~f =\n match l1 with\n | [] -> l2\n | h :: t -> rev_map_append ~f t (f h :: l2)\n;;\n\nlet fold_right l ~f ~init =\n match l with\n | [] -> init (* avoid the allocation of [~f] below *)\n | _ -> fold ~f:(fun a b -> f b a) ~init (rev l)\n;;\n\nlet unzip list =\n let rec loop list l1 l2 =\n match list with\n | [] -> rev l1, rev l2\n | (x, y) :: tl -> loop tl (x :: l1) (y :: l2)\n in\n loop list [] []\n;;\n\nlet unzip3 list =\n let rec loop list l1 l2 l3 =\n match list with\n | [] -> rev l1, rev l2, rev l3\n | (x, y, z) :: tl -> loop tl (x :: l1) (y :: l2) (z :: l3)\n in\n loop list [] [] []\n;;\n\nlet zip_exn l1 l2 =\n check_length2_exn \"zip_exn\" l1 l2;\n map2_ok ~f:(fun a b -> a, b) l1 l2\n;;\n\nlet zip l1 l2 = map2 ~f:(fun a b -> a, b) l1 l2\n\n(** Additional list operations *)\n\nlet rev_mapi l ~f =\n let rec loop i acc = function\n | [] -> acc\n | h :: t -> loop (i + 1) (f i h :: acc) t\n in\n loop 0 [] l\n;;\n\nlet mapi l ~f = rev (rev_mapi l ~f)\n\nlet folding_mapi t ~init ~f =\n let acc = ref init in\n mapi t ~f:(fun i x ->\n let new_acc, y = f i !acc x in\n acc := new_acc;\n y)\n;;\n\nlet fold_mapi t ~init ~f =\n let acc = ref init in\n let result =\n mapi t ~f:(fun i x ->\n let new_acc, y = f i !acc x in\n acc := new_acc;\n y)\n in\n !acc, result\n;;\n\nlet iteri l ~f =\n ignore\n (fold l ~init:0 ~f:(fun i x ->\n f i x;\n i + 1)\n : int)\n;;\n\nlet foldi t ~init ~f =\n snd (fold t ~init:(0, init) ~f:(fun (i, acc) v -> i + 1, f i acc v))\n;;\n\nlet filteri l ~f =\n rev (foldi l ~f:(fun pos acc x -> if f pos x then x :: acc else acc) ~init:[])\n;;\n\nlet reduce l ~f =\n match l with\n | [] -> None\n | hd :: tl -> Some (fold ~init:hd ~f tl)\n;;\n\nlet reduce_exn l ~f =\n match reduce l ~f with\n | None -> invalid_arg \"List.reduce_exn\"\n | Some v -> v\n;;\n\nlet reduce_balanced l ~f =\n (* Call the \"size\" of a value the number of list elements that have been combined into\n it via calls to [f]. We proceed by using [f] to combine elements in the accumulator\n of the same size until we can't combine any more, then getting a new element from the\n input list and repeating.\n\n With this strategy, in the accumulator:\n - we only ever have elements of sizes a power of two\n - we never have more than one element of each size\n - the sum of all the element sizes is equal to the number of elements consumed\n\n These conditions enforce that list of elements of each size is precisely the binary\n expansion of the number of elements consumed: if you've consumed 13 = 0b1101\n elements, you have one element of size 8, one of size 4, and one of size 1. Hence\n when a new element comes along, the number of combinings you need to do is the number\n of trailing 1s in the binary expansion of [num], the number of elements that have\n already gone into the accumulator. The accumulator is in ascending order of size, so\n the next element to combine with is always the head of the list. *)\n let rec step_accum num acc x =\n if num land 1 = 0\n then x :: acc\n else (\n match acc with\n | [] -> assert false\n (* New elements from later in the input list go on the front of the accumulator, so\n the accumulator is in reverse order wrt the original list order, hence [f y x]\n instead of [f x y]. *)\n | y :: ys -> step_accum (num asr 1) ys (f y x))\n in\n (* Experimentally, inlining [foldi] and unrolling this loop a few times can reduce\n runtime down to a third and allocation to 1/16th or so in the microbenchmarks below.\n However, in most use cases [f] is likely to be expensive (otherwise why do you care\n about the order of reduction?) so the overhead of this function itself doesn't really\n matter. If you come up with a use-case where it does, then that's something you might\n want to try: see hg log -pr 49ef065f429d. *)\n match foldi l ~init:[] ~f:step_accum with\n | [] -> None\n | x :: xs -> Some (fold xs ~init:x ~f:(fun x y -> f y x))\n;;\n\nlet reduce_balanced_exn l ~f =\n match reduce_balanced l ~f with\n | None -> invalid_arg \"List.reduce_balanced_exn\"\n | Some v -> v\n;;\n\nlet groupi l ~break =\n let groups =\n foldi l ~init:[] ~f:(fun i acc x ->\n match acc with\n | [] -> [ [ x ] ]\n | current_group :: tl ->\n if break i (hd_exn current_group) x\n then [ x ] :: current_group :: tl (* start new group *)\n else (x :: current_group) :: tl)\n (* extend current group *)\n in\n match groups with\n | [] -> []\n | l -> rev_map l ~f:rev\n;;\n\nlet group l ~break = groupi l ~break:(fun _ x y -> break x y)\n\nlet concat_map l ~f =\n let rec aux acc = function\n | [] -> rev acc\n | hd :: tl -> aux (rev_append (f hd) acc) tl\n in\n aux [] l\n;;\n\nlet concat_mapi l ~f =\n let rec aux cont acc = function\n | [] -> rev acc\n | hd :: tl -> aux (cont + 1) (rev_append (f cont hd) acc) tl\n in\n aux 0 [] l\n;;\n\nlet merge l1 l2 ~compare =\n let rec loop acc l1 l2 =\n match l1, l2 with\n | [], l2 -> rev_append acc l2\n | l1, [] -> rev_append acc l1\n | h1 :: t1, h2 :: t2 ->\n if compare h1 h2 <= 0 then loop (h1 :: acc) t1 l2 else loop (h2 :: acc) l1 t2\n in\n loop [] l1 l2\n;;\n\ninclude struct\n (* We are explicit about what we import from the general Monad functor so that we don't\n accidentally rebind more efficient list-specific functions. *)\n module Monad = Monad.Make (struct\n type 'a t = 'a list\n\n let bind x ~f = concat_map x ~f\n let map = `Custom map\n let return x = [ x ]\n end)\n\n open Monad\n module Monad_infix = Monad_infix\n module Let_syntax = Let_syntax\n\n let ignore_m = ignore_m\n let join = join\n let bind = bind\n let ( >>= ) t f = bind t ~f\n let return = return\n let all = all\n let all_unit = all_unit\nend\n\n(** returns final element of list *)\nlet rec last_exn list =\n match list with\n | [ x ] -> x\n | _ :: tl -> last_exn tl\n | [] -> invalid_arg \"List.last\"\n;;\n\n(** optionally returns final element of list *)\nlet rec last list =\n match list with\n | [ x ] -> Some x\n | _ :: tl -> last tl\n | [] -> None\n;;\n\nlet rec is_prefix list ~prefix ~equal =\n match prefix with\n | [] -> true\n | hd :: tl ->\n (match list with\n | [] -> false\n | hd' :: tl' -> equal hd hd' && is_prefix tl' ~prefix:tl ~equal)\n;;\n\nlet find_consecutive_duplicate t ~equal =\n match t with\n | [] -> None\n | a1 :: t ->\n let rec loop a1 t =\n match t with\n | [] -> None\n | a2 :: t -> if equal a1 a2 then Some (a1, a2) else loop a2 t\n in\n loop a1 t\n;;\n\n(* returns list without adjacent duplicates *)\nlet remove_consecutive_duplicates ?(which_to_keep = `Last) list ~equal =\n let rec loop to_keep accum = function\n | [] -> to_keep :: accum\n | hd :: tl ->\n if equal hd to_keep\n then (\n let to_keep =\n match which_to_keep with\n | `First -> to_keep\n | `Last -> hd\n in\n loop to_keep accum tl)\n else loop hd (to_keep :: accum) tl\n in\n match list with\n | [] -> []\n | hd :: tl -> rev (loop hd [] tl)\n;;\n\n(** returns sorted version of list with duplicates removed *)\nlet dedup_and_sort ~compare list =\n match list with\n | [] | [ _ ] -> list (* performance hack *)\n | _ ->\n let equal x x' = compare x x' = 0 in\n let sorted = sort ~compare list in\n remove_consecutive_duplicates ~equal sorted\n;;\n\nlet find_a_dup ~compare l =\n let sorted = sort ~compare l in\n let rec loop l =\n match l with\n | [] | [ _ ] -> None\n | hd1 :: (hd2 :: _ as tl) -> if compare hd1 hd2 = 0 then Some hd1 else loop tl\n in\n loop sorted\n;;\n\nlet contains_dup ~compare lst =\n match find_a_dup ~compare lst with\n | Some _ -> true\n | None -> false\n;;\n\nlet find_all_dups ~compare l =\n (* We add this reversal, so we can skip a [rev] at the end. We could skip\n [rev] anyway since we don not give any ordering guarantees, but it is\n nice to get results in natural order. *)\n let compare a b = -1 * compare a b in\n let sorted = sort ~compare l in\n (* Walk the list and record the first of each consecutive run of identical elements *)\n let rec loop sorted prev ~already_recorded acc =\n match sorted with\n | [] -> acc\n | hd :: tl ->\n if compare prev hd <> 0\n then loop tl hd ~already_recorded:false acc\n else if already_recorded\n then loop tl hd ~already_recorded:true acc\n else loop tl hd ~already_recorded:true (hd :: acc)\n in\n match sorted with\n | [] -> []\n | hd :: tl -> loop tl hd ~already_recorded:false []\n;;\n\nlet count t ~f = Container.count ~fold t ~f\nlet sum m t ~f = Container.sum ~fold m t ~f\nlet min_elt t ~compare = Container.min_elt ~fold t ~compare\nlet max_elt t ~compare = Container.max_elt ~fold t ~compare\n\nlet counti t ~f =\n foldi t ~init:0 ~f:(fun idx count a -> if f idx a then count + 1 else count)\n;;\n\nlet init n ~f =\n if n < 0 then invalid_argf \"List.init %d\" n ();\n let rec loop i accum =\n assert (i >= 0);\n if i = 0 then accum else loop (i - 1) (f (i - 1) :: accum)\n in\n loop n []\n;;\n\nlet rev_filter_map l ~f =\n let rec loop l accum =\n match l with\n | [] -> accum\n | hd :: tl ->\n (match f hd with\n | Some x -> loop tl (x :: accum)\n | None -> loop tl accum)\n in\n loop l []\n;;\n\nlet filter_map l ~f = rev (rev_filter_map l ~f)\n\nlet rev_filter_mapi l ~f =\n let rec loop i l accum =\n match l with\n | [] -> accum\n | hd :: tl ->\n (match f i hd with\n | Some x -> loop (i + 1) tl (x :: accum)\n | None -> loop (i + 1) tl accum)\n in\n loop 0 l []\n;;\n\nlet filter_mapi l ~f = rev (rev_filter_mapi l ~f)\nlet filter_opt l = filter_map l ~f:Fn.id\n\nlet partition3_map t ~f =\n let rec loop t fst snd trd =\n match t with\n | [] -> rev fst, rev snd, rev trd\n | x :: t ->\n (match f x with\n | `Fst y -> loop t (y :: fst) snd trd\n | `Snd y -> loop t fst (y :: snd) trd\n | `Trd y -> loop t fst snd (y :: trd))\n in\n loop t [] [] []\n;;\n\nlet partition_tf t ~f =\n let f x : _ Either.t = if f x then First x else Second x in\n partition_map t ~f\n;;\n\nlet partition_result t = partition_map t ~f:Result.to_either\n\nmodule Assoc = struct\n type ('a, 'b) t = ('a * 'b) list [@@deriving_inline sexp]\n\n let t_of_sexp :\n 'a 'b. (Ppx_sexp_conv_lib.Sexp.t -> 'a) -> (Ppx_sexp_conv_lib.Sexp.t -> 'b)\n -> Ppx_sexp_conv_lib.Sexp.t -> ('a, 'b) t\n =\n let _tp_loc = \"list.ml.Assoc.t\" in\n fun _of_a _of_b t ->\n list_of_sexp\n (function\n | Ppx_sexp_conv_lib.Sexp.List [ v0; v1 ] ->\n let v0 = _of_a v0\n and v1 = _of_b v1 in\n v0, v1\n | sexp -> Ppx_sexp_conv_lib.Conv_error.tuple_of_size_n_expected _tp_loc 2 sexp)\n t\n ;;\n\n let sexp_of_t :\n 'a 'b. ('a -> Ppx_sexp_conv_lib.Sexp.t) -> ('b -> Ppx_sexp_conv_lib.Sexp.t)\n -> ('a, 'b) t -> Ppx_sexp_conv_lib.Sexp.t\n =\n fun _of_a _of_b v ->\n sexp_of_list\n (function\n | v0, v1 ->\n let v0 = _of_a v0\n and v1 = _of_b v1 in\n Ppx_sexp_conv_lib.Sexp.List [ v0; v1 ])\n v\n ;;\n\n [@@@end]\n\n let find t ~equal key =\n match find t ~f:(fun (key', _) -> equal key key') with\n | None -> None\n | Some x -> Some (snd x)\n ;;\n\n let find_exn =\n let not_found = Not_found_s (Atom \"List.Assoc.find_exn: not found\") in\n let find_exn t ~equal key =\n match find t key ~equal with\n | None -> raise not_found\n | Some value -> value\n in\n (* named to preserve symbol in compiled binary *)\n find_exn\n ;;\n\n let mem t ~equal key =\n match find t ~equal key with\n | None -> false\n | Some _ -> true\n ;;\n\n let remove t ~equal key = filter t ~f:(fun (key', _) -> not (equal key key'))\n\n let add t ~equal key value =\n (* the remove doesn't change the map semantics, but keeps the list small *)\n (key, value) :: remove t ~equal key\n ;;\n\n let inverse t = map t ~f:(fun (x, y) -> y, x)\n let map t ~f = map t ~f:(fun (key, value) -> key, f value)\nend\n\nlet sub l ~pos ~len =\n (* We use [pos > length l - len] rather than [pos + len > length l] to avoid the\n possibility of overflow. *)\n if pos < 0 || len < 0 || pos > length l - len then invalid_arg \"List.sub\";\n rev\n (foldi l ~init:[] ~f:(fun i acc el ->\n if i >= pos && i < pos + len then el :: acc else acc))\n;;\n\nlet split_n t_orig n =\n if n <= 0\n then [], t_orig\n else (\n let rec loop n t accum =\n if n = 0\n then rev accum, t\n else (\n match t with\n | [] -> t_orig, [] (* in this case, t_orig = rev accum *)\n | hd :: tl -> loop (n - 1) tl (hd :: accum))\n in\n loop n t_orig [])\n;;\n\n(* copied from [split_n] to avoid allocating a tuple *)\nlet take t_orig n =\n if n <= 0\n then []\n else (\n let rec loop n t accum =\n if n = 0\n then rev accum\n else (\n match t with\n | [] -> t_orig\n | hd :: tl -> loop (n - 1) tl (hd :: accum))\n in\n loop n t_orig [])\n;;\n\nlet rec drop t n =\n match t with\n | _ :: tl when n > 0 -> drop tl (n - 1)\n | t -> t\n;;\n\nlet chunks_of l ~length =\n if length <= 0\n then invalid_argf \"List.chunks_of: Expected length > 0, got %d\" length ();\n let rec aux of_length acc l =\n match l with\n | [] -> rev acc\n | _ :: _ ->\n let sublist, l = split_n l length in\n aux of_length (sublist :: acc) l\n in\n aux length [] l\n;;\n\nlet split_while xs ~f =\n let rec loop acc = function\n | hd :: tl when f hd -> loop (hd :: acc) tl\n | t -> rev acc, t\n in\n loop [] xs\n;;\n\n(* copied from [split_while] to avoid allocating a tuple *)\nlet take_while xs ~f =\n let rec loop acc = function\n | hd :: tl when f hd -> loop (hd :: acc) tl\n | _ -> rev acc\n in\n loop [] xs\n;;\n\nlet rec drop_while t ~f =\n match t with\n | hd :: tl when f hd -> drop_while tl ~f\n | t -> t\n;;\n\nlet drop_last t =\n match rev t with\n | [] -> None\n | _ :: lst -> Some (rev lst)\n;;\n\nlet drop_last_exn t =\n match drop_last t with\n | None -> failwith \"List.drop_last_exn: empty list\"\n | Some lst -> lst\n;;\n\nlet cartesian_product list1 list2 =\n if is_empty list2\n then []\n else (\n let rec loop l1 l2 accum =\n match l1 with\n | [] -> accum\n | hd :: tl -> loop tl l2 (rev_append (map ~f:(fun x -> hd, x) l2) accum)\n in\n rev (loop list1 list2 []))\n;;\n\nlet concat l = fold_right l ~init:[] ~f:append\nlet concat_no_order l = fold l ~init:[] ~f:(fun acc l -> rev_append l acc)\nlet cons x l = x :: l\n\nlet is_sorted l ~compare =\n let rec loop l =\n match l with\n | [] | [ _ ] -> true\n | x1 :: (x2 :: _ as rest) -> compare x1 x2 <= 0 && loop rest\n in\n loop l\n;;\n\nlet is_sorted_strictly l ~compare =\n let rec loop l =\n match l with\n | [] | [ _ ] -> true\n | x1 :: (x2 :: _ as rest) -> compare x1 x2 < 0 && loop rest\n in\n loop l\n;;\n\nmodule Infix = struct\n let ( @ ) = append\nend\n\nlet permute ?(random_state = Random.State.default) list =\n match list with\n (* special cases to speed things up in trivial cases *)\n | [] | [ _ ] -> list\n | [ x; y ] -> if Random.State.bool random_state then [ y; x ] else list\n | _ ->\n let arr = Array.of_list list in\n Array_permute.permute arr ~random_state;\n Array.to_list arr\n;;\n\nlet random_element_exn ?(random_state = Random.State.default) list =\n if is_empty list\n then failwith \"List.random_element_exn: empty list\"\n else nth_exn list (Random.State.int random_state (length list))\n;;\n\nlet random_element ?(random_state = Random.State.default) list =\n try Some (random_element_exn ~random_state list) with\n | _ -> None\n;;\n\nlet rec compare cmp a b =\n match a, b with\n | [], [] -> 0\n | [], _ -> -1\n | _, [] -> 1\n | x :: xs, y :: ys ->\n let n = cmp x y in\n if n = 0 then compare cmp xs ys else n\n;;\n\nlet hash_fold_t = hash_fold_list\n\nlet equal equal t1 t2 =\n let rec loop ~equal t1 t2 =\n match t1, t2 with\n | [], [] -> true\n | x1 :: t1, x2 :: t2 -> equal x1 x2 && loop ~equal t1 t2\n | _ -> false\n in\n loop ~equal t1 t2\n;;\n\nlet transpose =\n let rec transpose_aux t rev_columns =\n match\n partition_map t ~f:(function\n | [] -> Second ()\n | x :: xs -> First (x, xs))\n with\n | _ :: _, _ :: _ -> None\n | [], _ -> Some (rev_append rev_columns [])\n | heads_and_tails, [] ->\n let column, trimmed_rows = unzip heads_and_tails in\n transpose_aux trimmed_rows (column :: rev_columns)\n in\n fun t -> transpose_aux t []\n;;\n\nexception Transpose_got_lists_of_different_lengths of int list [@@deriving_inline sexp]\n\nlet () =\n Ppx_sexp_conv_lib.Conv.Exn_converter.add\n [%extension_constructor Transpose_got_lists_of_different_lengths]\n (function\n | Transpose_got_lists_of_different_lengths v0 ->\n let v0 = sexp_of_list sexp_of_int v0 in\n Ppx_sexp_conv_lib.Sexp.List\n [ Ppx_sexp_conv_lib.Sexp.Atom\n \"list.ml.Transpose_got_lists_of_different_lengths\"\n ; v0\n ]\n | _ -> assert false)\n;;\n\n[@@@end]\n\nlet transpose_exn l =\n match transpose l with\n | Some l -> l\n | None -> raise (Transpose_got_lists_of_different_lengths (map l ~f:length))\n;;\n\nlet intersperse t ~sep =\n match t with\n | [] -> []\n | x :: xs -> x :: fold_right xs ~init:[] ~f:(fun y acc -> sep :: y :: acc)\n;;\n\nlet fold_result t ~init ~f = Container.fold_result ~fold ~init ~f t\nlet fold_until t ~init ~f = Container.fold_until ~fold ~init ~f t\n\nlet is_suffix list ~suffix ~equal:equal_elt =\n let list_len = length list in\n let suffix_len = length suffix in\n list_len >= suffix_len && equal equal_elt (drop list (list_len - suffix_len)) suffix\n;;\n","open! Import\n\ntype t =\n | Less\n | Equal\n | Greater\n[@@deriving_inline compare, hash, enumerate, sexp]\n\nlet compare = (Ppx_compare_lib.polymorphic_compare : t -> t -> int)\n\nlet (hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state) =\n (fun hsv arg ->\n match arg with\n | Less -> Ppx_hash_lib.Std.Hash.fold_int hsv 0\n | Equal -> Ppx_hash_lib.Std.Hash.fold_int hsv 1\n | Greater -> Ppx_hash_lib.Std.Hash.fold_int hsv 2\n : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state)\n;;\n\nlet (hash : t -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func arg =\n Ppx_hash_lib.Std.Hash.get_hash_value\n (let hsv = Ppx_hash_lib.Std.Hash.create () in\n hash_fold_t hsv arg)\n in\n fun x -> func x\n;;\n\nlet all = ([ Less; Equal; Greater ] : t list)\n\nlet t_of_sexp =\n (let _tp_loc = \"ordering.ml.t\" in\n function\n | Ppx_sexp_conv_lib.Sexp.Atom (\"less\" | \"Less\") -> Less\n | Ppx_sexp_conv_lib.Sexp.Atom (\"equal\" | \"Equal\") -> Equal\n | Ppx_sexp_conv_lib.Sexp.Atom (\"greater\" | \"Greater\") -> Greater\n | Ppx_sexp_conv_lib.Sexp.List (Ppx_sexp_conv_lib.Sexp.Atom (\"less\" | \"Less\") :: _) as\n sexp -> Ppx_sexp_conv_lib.Conv_error.stag_no_args _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.List (Ppx_sexp_conv_lib.Sexp.Atom (\"equal\" | \"Equal\") :: _)\n as sexp -> Ppx_sexp_conv_lib.Conv_error.stag_no_args _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.List\n (Ppx_sexp_conv_lib.Sexp.Atom (\"greater\" | \"Greater\") :: _) as sexp ->\n Ppx_sexp_conv_lib.Conv_error.stag_no_args _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.List (Ppx_sexp_conv_lib.Sexp.List _ :: _) as sexp ->\n Ppx_sexp_conv_lib.Conv_error.nested_list_invalid_sum _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.List [] as sexp ->\n Ppx_sexp_conv_lib.Conv_error.empty_list_invalid_sum _tp_loc sexp\n | sexp -> Ppx_sexp_conv_lib.Conv_error.unexpected_stag _tp_loc sexp\n : Ppx_sexp_conv_lib.Sexp.t -> t)\n;;\n\nlet sexp_of_t =\n (function\n | Less -> Ppx_sexp_conv_lib.Sexp.Atom \"Less\"\n | Equal -> Ppx_sexp_conv_lib.Sexp.Atom \"Equal\"\n | Greater -> Ppx_sexp_conv_lib.Sexp.Atom \"Greater\"\n : t -> Ppx_sexp_conv_lib.Sexp.t)\n;;\n\n[@@@end]\n\nlet equal a b = compare a b = 0\n\nmodule Export = struct\n type _ordering = t =\n | Less\n | Equal\n | Greater\nend\n\nlet of_int n = if n < 0 then Less else if n = 0 then Equal else Greater\n\nlet to_int = function\n | Less -> -1\n | Equal -> 0\n | Greater -> 1\n;;\n","open! Import\ninclude Applicative_intf\n\n(** This module serves mostly as a partial check that [S2] and [S] are in sync, but\n actually calling it is occasionally useful. *)\nmodule S_to_S2 (X : S) : S2 with type ('a, 'e) t = 'a X.t = struct\n type ('a, 'e) t = 'a X.t\n\n include (X : S with type 'a t := 'a X.t)\nend\n\nmodule S2_to_S (X : S2) : S with type 'a t = ('a, unit) X.t = struct\n type 'a t = ('a, unit) X.t\n\n include (X : S2 with type ('a, 'e) t := ('a, 'e) X.t)\nend\n\nmodule S2_to_S3 (X : S2) : S3 with type ('a, 'd, 'e) t = ('a, 'd) X.t = struct\n type ('a, 'd, 'e) t = ('a, 'd) X.t\n\n include (X : S2 with type ('a, 'd) t := ('a, 'd) X.t)\nend\n\nmodule S3_to_S2 (X : S3) : S2 with type ('a, 'd) t = ('a, 'd, unit) X.t = struct\n type ('a, 'd) t = ('a, 'd, unit) X.t\n\n include (X : S3 with type ('a, 'd, 'e) t := ('a, 'd, 'e) X.t)\nend\n\n(* These functors serve only to check that the signatures for various Foo and Foo2 module\n types don't drift apart over time.\n*)\nmodule Check_compatibility = struct\n module Applicative_infix_to_Applicative_infix2 (X : Applicative_infix) :\n Applicative_infix2 with type ('a, 'e) t = 'a X.t = struct\n type ('a, 'e) t = 'a X.t\n\n include (X : Applicative_infix with type 'a t := 'a X.t)\n end\n\n module Applicative_infix2_to_Applicative_infix (X : Applicative_infix2) :\n Applicative_infix with type 'a t = ('a, unit) X.t = struct\n type 'a t = ('a, unit) X.t\n\n include (X : Applicative_infix2 with type ('a, 'e) t := ('a, 'e) X.t)\n end\n\n module Applicative_infix2_to_Applicative_infix3 (X : Applicative_infix2) :\n Applicative_infix3 with type ('a, 'd, 'e) t = ('a, 'd) X.t = struct\n type ('a, 'd, 'e) t = ('a, 'd) X.t\n\n include (X : Applicative_infix2 with type ('a, 'd) t := ('a, 'd) X.t)\n end\n\n module Applicative_infix3_to_Applicative_infix2 (X : Applicative_infix3) :\n Applicative_infix2 with type ('a, 'd) t = ('a, 'd, unit) X.t = struct\n type ('a, 'd) t = ('a, 'd, unit) X.t\n\n include (X : Applicative_infix3 with type ('a, 'd, 'e) t := ('a, 'd, 'e) X.t)\n end\n\n module Let_syntax_to_Let_syntax2 (X : Let_syntax) :\n Let_syntax2 with type ('a, 'e) t = 'a X.t = struct\n type ('a, 'e) t = 'a X.t\n\n include (X : Let_syntax with type 'a t := 'a X.t)\n end\n\n module Let_syntax2_to_Let_syntax (X : Let_syntax2) :\n Let_syntax with type 'a t = ('a, unit) X.t = struct\n type 'a t = ('a, unit) X.t\n\n include (X : Let_syntax2 with type ('a, 'e) t := ('a, 'e) X.t)\n end\n\n module Let_syntax2_to_Let_syntax3 (X : Let_syntax2) :\n Let_syntax3 with type ('a, 'd, 'e) t = ('a, 'd) X.t = struct\n type ('a, 'd, 'e) t = ('a, 'd) X.t\n\n include (X : Let_syntax2 with type ('a, 'd) t := ('a, 'd) X.t)\n end\n\n module Let_syntax3_to_Let_syntax2 (X : Let_syntax3) :\n Let_syntax2 with type ('a, 'd) t = ('a, 'd, unit) X.t = struct\n type ('a, 'd) t = ('a, 'd, unit) X.t\n\n include (X : Let_syntax3 with type ('a, 'd, 'e) t := ('a, 'd, 'e) X.t)\n end\nend\n\nmodule Make3 (X : Basic3) : S3 with type ('a, 'd, 'e) t := ('a, 'd, 'e) X.t = struct\n include X\n\n let ( <*> ) = apply\n let derived_map t ~f = return f <*> t\n\n let map =\n match X.map with\n | `Define_using_apply -> derived_map\n | `Custom x -> x\n ;;\n\n let ( >>| ) t f = map t ~f\n let map2 ta tb ~f = map ~f ta <*> tb\n let map3 ta tb tc ~f = map ~f ta <*> tb <*> tc\n let all ts = List.fold_right ts ~init:(return []) ~f:(map2 ~f:(fun x xs -> x :: xs))\n let both ta tb = map2 ta tb ~f:(fun a b -> a, b)\n let ( *> ) u v = return (fun () y -> y) <*> u <*> v\n let ( <* ) u v = return (fun x () -> x) <*> u <*> v\n let all_unit ts = List.fold ts ~init:(return ()) ~f:( *> )\n\n module Applicative_infix = struct\n let ( <*> ) = ( <*> )\n let ( *> ) = ( *> )\n let ( <* ) = ( <* )\n let ( >>| ) = ( >>| )\n end\nend\n\nmodule Make2 (X : Basic2) : S2 with type ('a, 'e) t := ('a, 'e) X.t = Make3 (struct\n type ('a, 'd, 'e) t = ('a, 'd) X.t\n\n include (X : Basic2 with type ('a, 'e) t := ('a, 'e) X.t)\n end)\n\nmodule Make (X : Basic) : S with type 'a t := 'a X.t = Make2 (struct\n type ('a, 'e) t = 'a X.t\n\n include (X : Basic with type 'a t := 'a X.t)\n end)\n\nmodule Make_let_syntax3\n (X : For_let_syntax3) (Intf : sig\n module type S\n end)\n (Impl : Intf.S) =\nstruct\n module Let_syntax = struct\n include X\n\n module Let_syntax = struct\n include X\n module Open_on_rhs = Impl\n end\n end\nend\n\nmodule Make_let_syntax2\n (X : For_let_syntax2) (Intf : sig\n module type S\n end)\n (Impl : Intf.S) =\n Make_let_syntax3\n (struct\n type ('a, 'd, _) t = ('a, 'd) X.t\n\n include (X : For_let_syntax2 with type ('a, 'e) t := ('a, 'e) X.t)\n end)\n (Intf)\n (Impl)\n\nmodule Make_let_syntax\n (X : For_let_syntax) (Intf : sig\n module type S\n end)\n (Impl : Intf.S) =\n Make_let_syntax2\n (struct\n type ('a, _) t = 'a X.t\n\n include (X : For_let_syntax with type 'a t := 'a X.t)\n end)\n (Intf)\n (Impl)\n\nmodule Make3_using_map2 (X : Basic3_using_map2) = Make3 (struct\n include X\n\n let apply tf tx = map2 tf tx ~f:(fun f x -> f x)\n\n let map =\n match map with\n | `Custom map -> `Custom map\n | `Define_using_map2 -> `Define_using_apply\n ;;\n end)\n\nmodule Make2_using_map2 (X : Basic2_using_map2) :\n S2 with type ('a, 'e) t := ('a, 'e) X.t = Make3_using_map2 (struct\n type ('a, 'd, 'e) t = ('a, 'd) X.t\n\n include (X : Basic2_using_map2 with type ('a, 'e) t := ('a, 'e) X.t)\n end)\n\nmodule Make_using_map2 (X : Basic_using_map2) : S with type 'a t := 'a X.t =\n Make2_using_map2 (struct\n type ('a, 'e) t = 'a X.t\n\n include (X : Basic_using_map2 with type 'a t := 'a X.t)\n end)\n\nmodule Of_monad2 (M : Monad.S2) : S2 with type ('a, 'e) t := ('a, 'e) M.t = Make2 (struct\n type ('a, 'e) t = ('a, 'e) M.t\n\n let return = M.return\n let apply mf mx = M.bind mf ~f:(fun f -> M.map mx ~f)\n let map = `Custom M.map\n end)\n\nmodule Of_monad (M : Monad.S) : S with type 'a t := 'a M.t = Of_monad2 (struct\n type ('a, _) t = 'a M.t\n\n include (M : Monad.S with type 'a t := 'a M.t)\n end)\n\nmodule Compose (F : S) (G : S) : S with type 'a t = 'a F.t G.t = struct\n type 'a t = 'a F.t G.t\n\n include Make (struct\n type nonrec 'a t = 'a t\n\n let return a = G.return (F.return a)\n let apply tf tx = G.apply (G.map ~f:F.apply tf) tx\n let custom_map t ~f = G.map ~f:(F.map ~f) t\n let map = `Custom custom_map\n end)\nend\n\nmodule Pair (F : S) (G : S) : S with type 'a t = 'a F.t * 'a G.t = struct\n type 'a t = 'a F.t * 'a G.t\n\n include Make (struct\n type nonrec 'a t = 'a t\n\n let return a = F.return a, G.return a\n let apply tf tx = F.apply (fst tf) (fst tx), G.apply (snd tf) (snd tx)\n let custom_map t ~f = F.map ~f (fst t), G.map ~f (snd t)\n let map = `Custom custom_map\n end)\nend\n","(* This module is trying to minimize dependencies on modules in Core, so as to allow\n [Info], [Error], and [Or_error] to be used in as many places as possible. Please avoid\n adding new dependencies. *)\n\nopen! Import\ninclude Info_intf\nmodule String = String0\n\nmodule Message = struct\n type t =\n | Could_not_construct of Sexp.t\n | String of string\n | Exn of exn\n | Sexp of Sexp.t\n | Tag_sexp of string * Sexp.t * Source_code_position0.t option\n | Tag_t of string * t\n | Tag_arg of string * Sexp.t * t\n | Of_list of int option * t list\n | With_backtrace of t * string (* backtrace *)\n [@@deriving_inline sexp_of]\n\n let rec sexp_of_t =\n (function\n | Could_not_construct v0 ->\n let v0 = Sexp.sexp_of_t v0 in\n Ppx_sexp_conv_lib.Sexp.List\n [ Ppx_sexp_conv_lib.Sexp.Atom \"Could_not_construct\"; v0 ]\n | String v0 ->\n let v0 = sexp_of_string v0 in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"String\"; v0 ]\n | Exn v0 ->\n let v0 = sexp_of_exn v0 in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"Exn\"; v0 ]\n | Sexp v0 ->\n let v0 = Sexp.sexp_of_t v0 in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"Sexp\"; v0 ]\n | Tag_sexp (v0, v1, v2) ->\n let v0 = sexp_of_string v0\n and v1 = Sexp.sexp_of_t v1\n and v2 = sexp_of_option Source_code_position0.sexp_of_t v2 in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"Tag_sexp\"; v0; v1; v2 ]\n | Tag_t (v0, v1) ->\n let v0 = sexp_of_string v0\n and v1 = sexp_of_t v1 in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"Tag_t\"; v0; v1 ]\n | Tag_arg (v0, v1, v2) ->\n let v0 = sexp_of_string v0\n and v1 = Sexp.sexp_of_t v1\n and v2 = sexp_of_t v2 in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"Tag_arg\"; v0; v1; v2 ]\n | Of_list (v0, v1) ->\n let v0 = sexp_of_option sexp_of_int v0\n and v1 = sexp_of_list sexp_of_t v1 in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"Of_list\"; v0; v1 ]\n | With_backtrace (v0, v1) ->\n let v0 = sexp_of_t v0\n and v1 = sexp_of_string v1 in\n Ppx_sexp_conv_lib.Sexp.List\n [ Ppx_sexp_conv_lib.Sexp.Atom \"With_backtrace\"; v0; v1 ]\n : t -> Ppx_sexp_conv_lib.Sexp.t)\n ;;\n\n [@@@end]\n\n let rec to_strings_hum t ac =\n (* We use [Sexp.to_string_mach], despite the fact that we are implementing\n [to_strings_hum], because we want the info to fit on a single line, and once we've\n had to resort to sexps, the message is going to start not looking so pretty\n anyway. *)\n match t with\n | Could_not_construct sexp ->\n \"could not construct info: \" :: Sexp.to_string_mach sexp :: ac\n | String string -> string :: ac\n | Exn exn -> Sexp.to_string_mach (Exn.sexp_of_t exn) :: ac\n | Sexp sexp -> Sexp.to_string_mach sexp :: ac\n | Tag_sexp (tag, sexp, _) -> tag :: \": \" :: Sexp.to_string_mach sexp :: ac\n | Tag_t (tag, t) -> tag :: \": \" :: to_strings_hum t ac\n | Tag_arg (tag, sexp, t) ->\n let body = Sexp.to_string_mach sexp :: \": \" :: to_strings_hum t ac in\n if String.length tag = 0 then body else tag :: \": \" :: body\n | With_backtrace (t, backtrace) ->\n to_strings_hum t (\"\\nBacktrace:\\n\" :: backtrace :: ac)\n | Of_list (trunc_after, ts) ->\n let ts =\n match trunc_after with\n | None -> ts\n | Some max ->\n let n = List.length ts in\n if n <= max\n then ts\n else List.take ts max @ [ String (Printf.sprintf \"and %d more info\" (n - max)) ]\n in\n List.fold (List.rev ts) ~init:ac ~f:(fun ac t ->\n to_strings_hum t (if List.is_empty ac then ac else \"; \" :: ac))\n ;;\n\n let to_string_hum_deprecated t = String.concat (to_strings_hum t [])\n\n let rec to_sexps_hum t ac =\n match t with\n | Could_not_construct _ as t -> sexp_of_t t :: ac\n | String string -> Atom string :: ac\n | Exn exn -> Exn.sexp_of_t exn :: ac\n | Sexp sexp -> sexp :: ac\n | Tag_sexp (tag, sexp, here) ->\n List\n (Atom tag\n :: sexp\n ::\n (match here with\n | None -> []\n | Some here -> [ Source_code_position0.sexp_of_t here ]))\n :: ac\n | Tag_t (tag, t) -> List (Atom tag :: to_sexps_hum t []) :: ac\n | Tag_arg (tag, sexp, t) ->\n let body = sexp :: to_sexps_hum t [] in\n if String.length tag = 0 then List body :: ac else List (Atom tag :: body) :: ac\n | With_backtrace (t, backtrace) ->\n Sexp.List [ to_sexp_hum t; Sexp.Atom backtrace ] :: ac\n | Of_list (_, ts) ->\n List.fold (List.rev ts) ~init:ac ~f:(fun ac t -> to_sexps_hum t ac)\n\n and to_sexp_hum t =\n match to_sexps_hum t [] with\n | [ sexp ] -> sexp\n | sexps -> Sexp.List sexps\n ;;\n\n (* We use [protect] to guard against exceptions raised by user-supplied functions, so\n that failure to produce one part of an info doesn't interfere with other parts. *)\n let protect f =\n try f () with\n | exn -> Could_not_construct (Exn.sexp_of_t exn)\n ;;\n\n let of_info info = protect (fun () -> Lazy.force info)\n let to_info t = lazy t\nend\n\nopen Message\n\ntype t = Message.t Lazy.t\n\nlet invariant _ = ()\nlet to_message = Message.of_info\nlet of_message = Message.to_info\n\n(* It is OK to use [Message.to_sexp_hum], which is not stable, because [t_of_sexp] below\n can handle any sexp. *)\nlet sexp_of_t t = Message.to_sexp_hum (to_message t)\nlet t_of_sexp sexp = lazy (Message.Sexp sexp)\nlet compare t1 t2 = Sexp.compare (sexp_of_t t1) (sexp_of_t t2)\nlet equal t1 t2 = Sexp.equal (sexp_of_t t1) (sexp_of_t t2)\nlet hash_fold_t state t = Sexp.hash_fold_t state (sexp_of_t t)\nlet hash t = Hash.run hash_fold_t t\n\nlet to_string_hum t =\n match to_message t with\n | String s -> s\n | message -> Sexp.to_string_hum (Message.to_sexp_hum message)\n;;\n\nlet to_string_hum_deprecated t = Message.to_string_hum_deprecated (to_message t)\nlet to_string_mach t = Sexp.to_string_mach (sexp_of_t t)\nlet of_lazy l = lazy (protect (fun () -> String (Lazy.force l)))\nlet of_lazy_t lazy_t = Lazy.join lazy_t\nlet of_string message = Lazy.from_val (String message)\nlet createf format = Printf.ksprintf of_string format\nlet of_thunk f = lazy (protect (fun () -> String (f ())))\n\nlet create ?here ?strict tag x sexp_of_x =\n match strict with\n | None -> lazy (protect (fun () -> Tag_sexp (tag, sexp_of_x x, here)))\n | Some () -> of_message (Tag_sexp (tag, sexp_of_x x, here))\n;;\n\nlet create_s sexp = Lazy.from_val (Sexp sexp)\nlet tag t ~tag = lazy (Tag_t (tag, to_message t))\nlet tag_s t ~tag = lazy (protect (fun () -> Tag_arg (\"\", tag, to_message t)))\n\nlet tag_arg t tag x sexp_of_x =\n lazy (protect (fun () -> Tag_arg (tag, sexp_of_x x, to_message t)))\n;;\n\nlet of_list ?trunc_after ts = lazy (Of_list (trunc_after, List.map ts ~f:to_message))\n\nexception Exn of t\n\nlet () =\n (* We install a custom exn-converter rather than use\n [exception Exn of t [@@deriving_inline sexp] ... [@@@end]] to eliminate the extra\n wrapping of \"(Exn ...)\". *)\n Sexplib.Conv.Exn_converter.add [%extension_constructor Exn] (function\n | Exn t -> sexp_of_t t\n | _ ->\n (* Reaching this branch indicates a bug in sexplib. *)\n assert false)\n;;\n\nlet to_exn t =\n if not (Lazy.is_val t)\n then Exn t\n else (\n match Lazy.force t with\n | Message.Exn exn -> exn\n | _ -> Exn t)\n;;\n\nlet of_exn ?backtrace exn =\n let backtrace =\n match backtrace with\n | None -> None\n | Some `Get -> Some (Caml.Printexc.get_backtrace ())\n | Some (`This s) -> Some s\n in\n match exn, backtrace with\n | Exn t, None -> t\n | Exn t, Some backtrace -> lazy (With_backtrace (to_message t, backtrace))\n | _, None -> Lazy.from_val (Message.Exn exn)\n | _, Some backtrace -> lazy (With_backtrace (Sexp (Exn.sexp_of_t exn), backtrace))\n;;\n\ninclude Pretty_printer.Register_pp (struct\n type nonrec t = t\n\n let module_name = \"Base.Info\"\n let pp ppf t = Caml.Format.pp_print_string ppf (to_string_hum t)\n end)\n\nmodule Internal_repr = Message\n\n","(* This module is trying to minimize dependencies on modules in Core, so as to allow\n [Error] and [Or_error] to be used in various places. Please avoid adding new\n dependencies. *)\n\nopen! Import\ninclude Info\n\nlet raise t = raise (to_exn t)\nlet raise_s sexp = raise (create_s sexp)\nlet to_info t = t\nlet of_info t = t\n\ninclude Pretty_printer.Register_pp (struct\n type nonrec t = t\n\n let module_name = \"Base.Error\"\n let pp = pp\n end)\n","open! Import\ninclude Invariant_intf\n\nlet raise_s = Error.raise_s\n\nlet invariant here t sexp_of_t f : unit =\n try f () with\n | exn ->\n raise_s\n (Sexp.message\n \"invariant failed\"\n [ \"\", Source_code_position0.sexp_of_t here\n ; \"exn\", sexp_of_exn exn\n ; \"\", sexp_of_t t\n ])\n;;\n\nlet check_field t f field =\n try f (Field.get field t) with\n | exn ->\n raise_s\n (Sexp.message\n \"problem with field\"\n [ \"field\", sexp_of_string (Field.name field); \"exn\", sexp_of_exn exn ])\n;;\n","open! Import\n\ntype 'a t =\n | Incl of 'a\n | Excl of 'a\n | Unbounded\n[@@deriving_inline enumerate, sexp]\n\nlet all : 'a. 'a list -> 'a t list =\n fun _all_of_a ->\n Ppx_enumerate_lib.List.append\n (let rec map l acc =\n match l with\n | [] -> Ppx_enumerate_lib.List.rev acc\n | enumerate__001_ :: l -> map l (Incl enumerate__001_ :: acc)\n in\n map _all_of_a [])\n (Ppx_enumerate_lib.List.append\n (let rec map l acc =\n match l with\n | [] -> Ppx_enumerate_lib.List.rev acc\n | enumerate__002_ :: l -> map l (Excl enumerate__002_ :: acc)\n in\n map _all_of_a [])\n [ Unbounded ])\n;;\n\nlet t_of_sexp\n : type a. (Ppx_sexp_conv_lib.Sexp.t -> a) -> Ppx_sexp_conv_lib.Sexp.t -> a t\n =\n let _tp_loc = \"maybe_bound.ml.t\" in\n fun _of_a -> function\n | Ppx_sexp_conv_lib.Sexp.List\n (Ppx_sexp_conv_lib.Sexp.Atom ((\"incl\" | \"Incl\") as _tag) :: sexp_args) as _sexp\n ->\n (match sexp_args with\n | [ v0 ] ->\n let v0 = _of_a v0 in\n Incl v0\n | _ -> Ppx_sexp_conv_lib.Conv_error.stag_incorrect_n_args _tp_loc _tag _sexp)\n | Ppx_sexp_conv_lib.Sexp.List\n (Ppx_sexp_conv_lib.Sexp.Atom ((\"excl\" | \"Excl\") as _tag) :: sexp_args) as _sexp\n ->\n (match sexp_args with\n | [ v0 ] ->\n let v0 = _of_a v0 in\n Excl v0\n | _ -> Ppx_sexp_conv_lib.Conv_error.stag_incorrect_n_args _tp_loc _tag _sexp)\n | Ppx_sexp_conv_lib.Sexp.Atom (\"unbounded\" | \"Unbounded\") -> Unbounded\n | Ppx_sexp_conv_lib.Sexp.Atom (\"incl\" | \"Incl\") as sexp ->\n Ppx_sexp_conv_lib.Conv_error.stag_takes_args _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.Atom (\"excl\" | \"Excl\") as sexp ->\n Ppx_sexp_conv_lib.Conv_error.stag_takes_args _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.List\n (Ppx_sexp_conv_lib.Sexp.Atom (\"unbounded\" | \"Unbounded\") :: _) as sexp ->\n Ppx_sexp_conv_lib.Conv_error.stag_no_args _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.List (Ppx_sexp_conv_lib.Sexp.List _ :: _) as sexp ->\n Ppx_sexp_conv_lib.Conv_error.nested_list_invalid_sum _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.List [] as sexp ->\n Ppx_sexp_conv_lib.Conv_error.empty_list_invalid_sum _tp_loc sexp\n | sexp -> Ppx_sexp_conv_lib.Conv_error.unexpected_stag _tp_loc sexp\n;;\n\nlet sexp_of_t\n : type a. (a -> Ppx_sexp_conv_lib.Sexp.t) -> a t -> Ppx_sexp_conv_lib.Sexp.t\n =\n fun _of_a -> function\n | Incl v0 ->\n let v0 = _of_a v0 in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"Incl\"; v0 ]\n | Excl v0 ->\n let v0 = _of_a v0 in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"Excl\"; v0 ]\n | Unbounded -> Ppx_sexp_conv_lib.Sexp.Atom \"Unbounded\"\n;;\n\n[@@@end]\n\ntype interval_comparison =\n | Below_lower_bound\n | In_range\n | Above_upper_bound\n[@@deriving_inline sexp, compare, hash]\n\nlet interval_comparison_of_sexp =\n (let _tp_loc = \"maybe_bound.ml.interval_comparison\" in\n function\n | Ppx_sexp_conv_lib.Sexp.Atom (\"below_lower_bound\" | \"Below_lower_bound\") ->\n Below_lower_bound\n | Ppx_sexp_conv_lib.Sexp.Atom (\"in_range\" | \"In_range\") -> In_range\n | Ppx_sexp_conv_lib.Sexp.Atom (\"above_upper_bound\" | \"Above_upper_bound\") ->\n Above_upper_bound\n | Ppx_sexp_conv_lib.Sexp.List\n (Ppx_sexp_conv_lib.Sexp.Atom (\"below_lower_bound\" | \"Below_lower_bound\") :: _) as\n sexp -> Ppx_sexp_conv_lib.Conv_error.stag_no_args _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.List\n (Ppx_sexp_conv_lib.Sexp.Atom (\"in_range\" | \"In_range\") :: _) as sexp ->\n Ppx_sexp_conv_lib.Conv_error.stag_no_args _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.List\n (Ppx_sexp_conv_lib.Sexp.Atom (\"above_upper_bound\" | \"Above_upper_bound\") :: _) as\n sexp -> Ppx_sexp_conv_lib.Conv_error.stag_no_args _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.List (Ppx_sexp_conv_lib.Sexp.List _ :: _) as sexp ->\n Ppx_sexp_conv_lib.Conv_error.nested_list_invalid_sum _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.List [] as sexp ->\n Ppx_sexp_conv_lib.Conv_error.empty_list_invalid_sum _tp_loc sexp\n | sexp -> Ppx_sexp_conv_lib.Conv_error.unexpected_stag _tp_loc sexp\n : Ppx_sexp_conv_lib.Sexp.t -> interval_comparison)\n;;\n\nlet sexp_of_interval_comparison =\n (function\n | Below_lower_bound -> Ppx_sexp_conv_lib.Sexp.Atom \"Below_lower_bound\"\n | In_range -> Ppx_sexp_conv_lib.Sexp.Atom \"In_range\"\n | Above_upper_bound -> Ppx_sexp_conv_lib.Sexp.Atom \"Above_upper_bound\"\n : interval_comparison -> Ppx_sexp_conv_lib.Sexp.t)\n;;\n\nlet compare_interval_comparison =\n (Ppx_compare_lib.polymorphic_compare\n : interval_comparison -> interval_comparison -> int)\n;;\n\nlet (hash_fold_interval_comparison :\n Ppx_hash_lib.Std.Hash.state -> interval_comparison -> Ppx_hash_lib.Std.Hash.state)\n =\n (fun hsv arg ->\n match arg with\n | Below_lower_bound -> Ppx_hash_lib.Std.Hash.fold_int hsv 0\n | In_range -> Ppx_hash_lib.Std.Hash.fold_int hsv 1\n | Above_upper_bound -> Ppx_hash_lib.Std.Hash.fold_int hsv 2\n : Ppx_hash_lib.Std.Hash.state -> interval_comparison -> Ppx_hash_lib.Std.Hash.state)\n;;\n\nlet (hash_interval_comparison : interval_comparison -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func arg =\n Ppx_hash_lib.Std.Hash.get_hash_value\n (let hsv = Ppx_hash_lib.Std.Hash.create () in\n hash_fold_interval_comparison hsv arg)\n in\n fun x -> func x\n;;\n\n[@@@end]\n\nlet map t ~f =\n match t with\n | Incl incl -> Incl (f incl)\n | Excl excl -> Excl (f excl)\n | Unbounded -> Unbounded\n;;\n\nlet is_lower_bound t ~of_:a ~compare =\n match t with\n | Incl incl -> compare incl a <= 0\n | Excl excl -> compare excl a < 0\n | Unbounded -> true\n;;\n\nlet is_upper_bound t ~of_:a ~compare =\n match t with\n | Incl incl -> compare a incl <= 0\n | Excl excl -> compare a excl < 0\n | Unbounded -> true\n;;\n\nlet bounds_crossed ~lower ~upper ~compare =\n match lower with\n | Unbounded -> false\n | Incl lower | Excl lower ->\n (match upper with\n | Unbounded -> false\n | Incl upper | Excl upper -> compare lower upper > 0)\n;;\n\nlet check_interval_exn ~lower ~upper ~compare =\n if bounds_crossed ~lower ~upper ~compare\n then failwith \"Maybe_bound.compare_to_interval_exn: lower bound > upper bound\"\n;;\n\nlet compare_to_interval_exn ~lower ~upper a ~compare =\n check_interval_exn ~lower ~upper ~compare;\n if not (is_lower_bound lower ~of_:a ~compare)\n then Below_lower_bound\n else if not (is_upper_bound upper ~of_:a ~compare)\n then Above_upper_bound\n else In_range\n;;\n\nlet interval_contains_exn ~lower ~upper a ~compare =\n match compare_to_interval_exn ~lower ~upper a ~compare with\n | In_range -> true\n | Below_lower_bound | Above_upper_bound -> false\n;;\n","open! Import\n\ntype 'a t = ('a, Error.t) Result.t [@@deriving_inline compare, equal, hash, sexp]\n\nlet compare : 'a. ('a -> 'a -> int) -> 'a t -> 'a t -> int =\n fun _cmp__a a__001_ b__002_ -> Result.compare _cmp__a Error.compare a__001_ b__002_\n;;\n\nlet equal : 'a. ('a -> 'a -> bool) -> 'a t -> 'a t -> bool =\n fun _cmp__a a__007_ b__008_ -> Result.equal _cmp__a Error.equal a__007_ b__008_\n;;\n\nlet hash_fold_t :\n 'a. (Ppx_hash_lib.Std.Hash.state -> 'a -> Ppx_hash_lib.Std.Hash.state)\n -> Ppx_hash_lib.Std.Hash.state -> 'a t -> Ppx_hash_lib.Std.Hash.state\n =\n fun _hash_fold_a hsv arg -> Result.hash_fold_t _hash_fold_a Error.hash_fold_t hsv arg\n;;\n\nlet t_of_sexp : 'a. (Ppx_sexp_conv_lib.Sexp.t -> 'a) -> Ppx_sexp_conv_lib.Sexp.t -> 'a t =\n let _tp_loc = \"or_error.ml.t\" in\n fun _of_a t -> Result.t_of_sexp _of_a Error.t_of_sexp t\n;;\n\nlet sexp_of_t : 'a. ('a -> Ppx_sexp_conv_lib.Sexp.t) -> 'a t -> Ppx_sexp_conv_lib.Sexp.t =\n fun _of_a v -> Result.sexp_of_t _of_a Error.sexp_of_t v\n;;\n\n[@@@end]\n\nlet invariant invariant_a t =\n match t with\n | Ok a -> invariant_a a\n | Error error -> Error.invariant error\n;;\n\ninclude (\n Result :\n Monad.S2\n with type ('a, 'b) t := ('a, 'b) Result.t\n with module Let_syntax := Result.Let_syntax)\n\ninclude Applicative.Make (struct\n type nonrec 'a t = 'a t\n\n let return = return\n\n let apply f x =\n Result.combine f x ~ok:(fun f x -> f x) ~err:(fun e1 e2 -> Error.of_list [ e1; e2 ])\n ;;\n\n let map = `Custom map\n end)\n\nmodule Let_syntax = struct\n let return = return\n\n include Monad_infix\n\n module Let_syntax = struct\n let return = return\n let map = map\n let bind = bind\n let both = both\n\n (* from Applicative.Make *)\n module Open_on_rhs = struct end\n end\nend\n\nlet ok = Result.ok\nlet is_ok = Result.is_ok\nlet is_error = Result.is_error\n\nlet try_with ?(backtrace = false) f =\n try Ok (f ()) with\n | exn -> Error (Error.of_exn exn ?backtrace:(if backtrace then Some `Get else None))\n;;\n\nlet try_with_join ?backtrace f = join (try_with ?backtrace f)\n\nlet ok_exn = function\n | Ok x -> x\n | Error err -> Error.raise err\n;;\n\nlet of_exn ?backtrace exn = Error (Error.of_exn ?backtrace exn)\n\nlet of_exn_result ?backtrace = function\n | Ok _ as z -> z\n | Error exn -> of_exn ?backtrace exn\n;;\n\nlet error ?strict message a sexp_of_a = Error (Error.create ?strict message a sexp_of_a)\nlet error_s sexp = Error (Error.create_s sexp)\nlet error_string message = Error (Error.of_string message)\nlet errorf format = Printf.ksprintf error_string format\nlet tag t ~tag = Result.map_error t ~f:(Error.tag ~tag)\nlet tag_s t ~tag = Result.map_error t ~f:(Error.tag_s ~tag)\n\nlet tag_arg t message a sexp_of_a =\n Result.map_error t ~f:(fun e -> Error.tag_arg e message a sexp_of_a)\n;;\n\nlet unimplemented s = error \"unimplemented\" s sexp_of_string\nlet combine_errors l = Result.map_error (Result.combine_errors l) ~f:Error.of_list\nlet combine_errors_unit l = Result.map (combine_errors l) ~f:(fun (_ : unit list) -> ())\n\nlet filter_ok_at_least_one l =\n let ok, errs = List.partition_map l ~f:Result.to_either in\n match ok with\n | [] -> Error (Error.of_list errs)\n | _ -> Ok ok\n;;\n\nlet find_ok l =\n match List.find_map l ~f:Result.ok with\n | Some x -> Ok x\n | None ->\n Error\n (Error.of_list\n (List.map l ~f:(function\n | Ok _ -> assert false\n | Error err -> err)))\n;;\n\nlet find_map_ok l ~f =\n With_return.with_return (fun { return } ->\n Error\n (Error.of_list\n (List.map l ~f:(fun elt ->\n match f elt with\n | Ok _ as x -> return x\n | Error err -> err))))\n;;\n\nlet map = Result.map\nlet iter = Result.iter\nlet iter_error = Result.iter_error\n","open! Import\ninclude Comparable_intf\n\nmodule Validate (T : sig\n type t [@@deriving_inline compare, sexp_of]\n\n val compare : t -> t -> int\n val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t\n\n [@@@end]\n end) : Validate with type t := T.t = struct\n module V = Validate\n open Maybe_bound\n\n let to_string t = Sexp.to_string (T.sexp_of_t t)\n\n let validate_bound ~min ~max t =\n V.bounded ~name:to_string ~lower:min ~upper:max ~compare:T.compare t\n ;;\n\n let validate_lbound ~min t = validate_bound ~min ~max:Unbounded t\n let validate_ubound ~max t = validate_bound ~max ~min:Unbounded t\nend\n\nmodule With_zero (T : sig\n type t [@@deriving_inline compare]\n\n val compare : t -> t -> int\n\n [@@@end]\n\n val zero : t\n\n include Validate with type t := t\n end) =\nstruct\n open T\n\n (* Preallocate the interesting bounds to minimize allocation in the implementations of\n [validate_*]. *)\n let excl_zero = Maybe_bound.Excl zero\n let incl_zero = Maybe_bound.Incl zero\n let validate_positive t = validate_lbound ~min:excl_zero t\n let validate_non_negative t = validate_lbound ~min:incl_zero t\n let validate_negative t = validate_ubound ~max:excl_zero t\n let validate_non_positive t = validate_ubound ~max:incl_zero t\n let is_positive t = compare t zero > 0\n let is_non_negative t = compare t zero >= 0\n let is_negative t = compare t zero < 0\n let is_non_positive t = compare t zero <= 0\n let sign t = Sign0.of_int (compare t zero)\nend\n\nmodule Validate_with_zero (T : sig\n type t [@@deriving_inline compare, sexp_of]\n\n val compare : t -> t -> int\n val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t\n\n [@@@end]\n\n val zero : t\n end) =\nstruct\n module V = Validate (T)\n include V\n\n include With_zero (struct\n include T\n include V\n end)\nend\n\nmodule Poly (T : sig\n type t [@@deriving_inline sexp_of]\n\n val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t\n\n [@@@end]\n end) =\nstruct\n module Replace_polymorphic_compare = struct\n type t = T.t [@@deriving_inline sexp_of]\n\n let sexp_of_t = (T.sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t)\n\n [@@@end]\n\n include Poly\n end\n\n include Poly\n\n let between t ~low ~high = low <= t && t <= high\n let clamp_unchecked t ~min ~max = if t < min then min else if t <= max then t else max\n\n let clamp_exn t ~min ~max =\n assert (min <= max);\n clamp_unchecked t ~min ~max\n ;;\n\n let clamp t ~min ~max =\n if min > max\n then\n Or_error.error_s\n (Sexp.message\n \"clamp requires [min <= max]\"\n [ \"min\", T.sexp_of_t min; \"max\", T.sexp_of_t max ])\n else Ok (clamp_unchecked t ~min ~max)\n ;;\n\n module C = struct\n include T\n include Comparator.Make (Replace_polymorphic_compare)\n end\n\n include C\n\n include Validate (struct\n type nonrec t = t [@@deriving_inline compare, sexp_of]\n\n let compare = (compare : t -> t -> int)\n let sexp_of_t = (sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t)\n\n [@@@end]\n end)\nend\n\nlet gt cmp a b = cmp a b > 0\nlet lt cmp a b = cmp a b < 0\nlet geq cmp a b = cmp a b >= 0\nlet leq cmp a b = cmp a b <= 0\nlet equal cmp a b = cmp a b = 0\nlet not_equal cmp a b = cmp a b <> 0\nlet min cmp t t' = if leq cmp t t' then t else t'\nlet max cmp t t' = if geq cmp t t' then t else t'\n\nmodule Infix (T : sig\n type t [@@deriving_inline compare]\n\n val compare : t -> t -> int\n\n [@@@end]\n end) : Infix with type t := T.t = struct\n let ( > ) a b = gt T.compare a b\n let ( < ) a b = lt T.compare a b\n let ( >= ) a b = geq T.compare a b\n let ( <= ) a b = leq T.compare a b\n let ( = ) a b = equal T.compare a b\n let ( <> ) a b = not_equal T.compare a b\nend\n\nmodule Polymorphic_compare (T : sig\n type t [@@deriving_inline compare]\n\n val compare : t -> t -> int\n\n [@@@end]\n end) : Polymorphic_compare with type t := T.t = struct\n include Infix (T)\n\n let compare = T.compare\n let equal = ( = )\n let min t t' = min compare t t'\n let max t t' = max compare t t'\nend\n\nmodule Make_using_comparator (T : sig\n type t [@@deriving_inline sexp_of]\n\n val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t\n\n [@@@end]\n\n include Comparator.S with type t := t\n end) : S with type t := T.t and type comparator_witness = T.comparator_witness = struct\n module T = struct\n include T\n\n let compare = comparator.compare\n end\n\n include T\n module Replace_polymorphic_compare = Polymorphic_compare (T)\n include Replace_polymorphic_compare\n\n let ascending = compare\n let descending t t' = compare t' t\n let between t ~low ~high = low <= t && t <= high\n let clamp_unchecked t ~min ~max = if t < min then min else if t <= max then t else max\n\n let clamp_exn t ~min ~max =\n assert (min <= max);\n clamp_unchecked t ~min ~max\n ;;\n\n let clamp t ~min ~max =\n if min > max\n then\n Or_error.error_s\n (Sexp.message\n \"clamp requires [min <= max]\"\n [ \"min\", T.sexp_of_t min; \"max\", T.sexp_of_t max ])\n else Ok (clamp_unchecked t ~min ~max)\n ;;\n\n include Validate (T)\nend\n\nmodule Make (T : sig\n type t [@@deriving_inline compare, sexp_of]\n\n val compare : t -> t -> int\n val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t\n\n [@@@end]\n end) =\n Make_using_comparator (struct\n include T\n include Comparator.Make (T)\n end)\n\nmodule Inherit (C : sig\n type t [@@deriving_inline compare]\n\n val compare : t -> t -> int\n\n [@@@end]\n end) (T : sig\n type t [@@deriving_inline sexp_of]\n\n val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t\n\n [@@@end]\n\n val component : t -> C.t\n end) =\n Make (struct\n type t = T.t [@@deriving_inline sexp_of]\n\n let sexp_of_t = (T.sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t)\n\n [@@@end]\n\n let compare t t' = C.compare (T.component t) (T.component t')\n end)\n\n(* compare [x] and [y] lexicographically using functions in the list [cmps] *)\nlet lexicographic cmps x y =\n let rec loop = function\n | cmp :: cmps ->\n let res = cmp x y in\n if res = 0 then loop cmps else res\n | [] -> 0\n in\n loop cmps\n;;\n\nlet lift cmp ~f x y = cmp (f x) (f y)\nlet reverse cmp x y = cmp y x\n","open! Import\n\nmodule type S = sig\n type t [@@deriving_inline hash, sexp]\n\n val hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state\n val hash : t -> Ppx_hash_lib.Std.Hash.hash_value\n\n include Ppx_sexp_conv_lib.Sexpable.S with type t := t\n\n [@@@end]\n\n include Stringable.S with type t := t\n include Comparable.S with type t := t\n include Pretty_printer.S with type t := t\nend\n\nmodule Make (T : sig\n type t [@@deriving_inline compare, hash, sexp]\n\n val compare : t -> t -> int\n val hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state\n val hash : t -> Ppx_hash_lib.Std.Hash.hash_value\n\n include Ppx_sexp_conv_lib.Sexpable.S with type t := t\n\n [@@@end]\n\n include Stringable.S with type t := t\n\n val module_name : string\n end) =\nstruct\n include T\n include Comparable.Make (T)\n include Pretty_printer.Register (T)\nend\n\nmodule Make_using_comparator (T : sig\n type t [@@deriving_inline hash, sexp]\n\n val hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state\n val hash : t -> Ppx_hash_lib.Std.Hash.hash_value\n\n include Ppx_sexp_conv_lib.Sexpable.S with type t := t\n\n [@@@end]\n\n include Comparator.S with type t := t\n include Stringable.S with type t := t\n\n val module_name : string\n end) =\nstruct\n include T\n include Comparable.Make_using_comparator (T)\n include Pretty_printer.Register (T)\nend\n","open! Import\n\nmodule type Infix = Base.Comparable.Infix\nmodule type Polymorphic_compare = Base.Comparable.Polymorphic_compare\nmodule type Validate = Base.Comparable.Validate\nmodule type With_zero = Base.Comparable.With_zero\n\nmodule type S_common = sig\n include Base.Comparable.S\n module Replace_polymorphic_compare : Polymorphic_compare with type t := t\nend\n\n(** Usage example:\n\n {[\n module Foo : sig\n type t = ...\n include Comparable.S with type t := t\n end\n ]}\n\n Then use [Comparable.Make] in the struct (see comparable.mli for an example). *)\n\nmodule type S_plain = sig\n include S_common\n\n module Map :\n Map.S_plain with type Key.t = t with type Key.comparator_witness = comparator_witness\n\n module Set :\n Set.S_plain with type Elt.t = t with type Elt.comparator_witness = comparator_witness\nend\n\nmodule type S = sig\n include S_common\n\n module Map :\n Map.S with type Key.t = t with type Key.comparator_witness = comparator_witness\n\n module Set :\n Set.S with type Elt.t = t with type Elt.comparator_witness = comparator_witness\nend\n\nmodule type Map_and_set_binable = sig\n type t\n\n include Comparator.S with type t := t\n\n module Map :\n Map.S_binable\n with type Key.t = t\n with type Key.comparator_witness = comparator_witness\n\n module Set :\n Set.S_binable\n with type Elt.t = t\n with type Elt.comparator_witness = comparator_witness\nend\n\nmodule type S_binable = sig\n include S_common\n\n include\n Map_and_set_binable\n with type t := t\n with type comparator_witness := comparator_witness\nend\n\n","open! Import\n\nmodule T = struct\n type t = unit [@@deriving_inline enumerate, hash, sexp, sexp_grammar]\n\n let all = ([ () ] : t list)\n\n let (hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state) =\n hash_fold_unit\n\n and (hash : t -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func = hash_unit in\n fun x -> func x\n ;;\n\n let t_of_sexp = (unit_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t)\n let sexp_of_t = (sexp_of_unit : t -> Ppx_sexp_conv_lib.Sexp.t)\n\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group) =\n { implicit_vars = [ \"unit\" ]\n ; ggid = \"\\146e\\023\\249\\235eE\\139c\\132W\\195\\137\\129\\235\\025\"\n ; types = [ \"t\", Implicit_var 0 ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ unit_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"unit.ml.T\"\n }\n in\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"t\", _the_group)\n in\n t_sexp_grammar\n ;;\n\n [@@@end]\n\n let compare _ _ = 0\n\n let of_string = function\n | \"()\" -> ()\n | _ -> failwith \"Base.Unit.of_string: () expected\"\n ;;\n\n let to_string () = \"()\"\n let module_name = \"Base.Unit\"\nend\n\ninclude T\ninclude Identifiable.Make (T)\n\nlet invariant () = ()\n","open! Import\n\nlet invalid_argf = Printf.invalid_argf\n\nlet slow_check_pos_len_exn ~pos ~len ~total_length =\n if pos < 0 then invalid_argf \"Negative position: %d\" pos ();\n if len < 0 then invalid_argf \"Negative length: %d\" len ();\n (* We use [pos > total_length - len] rather than [pos + len > total_length] to avoid the\n possibility of overflow. *)\n if pos > total_length - len\n then invalid_argf \"pos + len past end: %d + %d > %d\" pos len total_length ()\n[@@cold] [@@inline never] [@@local never] [@@specialise never]\n;;\n\nlet check_pos_len_exn ~pos ~len ~total_length =\n (* This is better than [slow_check_pos_len_exn] for two reasons:\n\n - much less inlined code\n - only one conditional jump\n\n The reason it works is that checking [< 0] is testing the highest order bit, so\n [a < 0 || b < 0] is the same as [a lor b < 0].\n\n [pos + len] can overflow, so [pos > total_length - len] is not equivalent to\n [total_length - len - pos < 0], we need to test for [pos + len] overflow as\n well. *)\n let stop = pos + len in\n if pos lor len lor stop lor (total_length - stop) < 0\n then slow_check_pos_len_exn ~pos ~len ~total_length\n;;\n\nlet get_pos_len_exn ?(pos = 0) ?len () ~total_length =\n let len =\n match len with\n | Some i -> i\n | None -> total_length - pos\n in\n check_pos_len_exn ~pos ~len ~total_length;\n pos, len\n;;\n\nlet get_pos_len ?pos ?len () ~total_length =\n try Result.Ok (get_pos_len_exn () ?pos ?len ~total_length) with\n | Invalid_argument s -> Or_error.error_string s\n;;\n\nmodule Private = struct\n let slow_check_pos_len_exn = slow_check_pos_len_exn\nend\n","open! Import\n\n(* These functions implement a search for the first (resp. last) element\n satisfying a predicate, assuming that the predicate is increasing on\n the container, meaning that, if the container is [u1...un], there exists a\n k such that p(u1)=....=p(uk) = false and p(uk+1)=....=p(un)= true.\n If this k = 1 (resp n), find_last_not_satisfying (resp find_first_satisfying)\n will return None. *)\n\nlet rec linear_search_first_satisfying t ~get ~lo ~hi ~pred =\n if lo > hi\n then None\n else if pred (get t lo)\n then Some lo\n else linear_search_first_satisfying t ~get ~lo:(lo + 1) ~hi ~pred\n;;\n\n(* Takes a container [t], a predicate [pred] and two indices [lo < hi], such that\n [pred] is increasing on [t] between [lo] and [hi].\n\n return a range (lo, hi) where:\n - lo and hi are close enough together for a linear search\n - If [pred] is not constantly [false] on [t] between [lo] and [hi], the first element\n on which [pred] is [true] is between [lo] and [hi]. *)\n(* Invariant: the first element satisfying [pred], if it exists is between [lo] and [hi] *)\nlet rec find_range_near_first_satisfying t ~get ~lo ~hi ~pred =\n (* Warning: this function will not terminate if the constant (currently 8) is\n set <= 1 *)\n if hi - lo <= 8\n then lo, hi\n else (\n let mid = lo + ((hi - lo) / 2) in\n if pred (get t mid)\n (* INVARIANT check: it means the first satisfying element is between [lo] and [mid] *)\n then\n find_range_near_first_satisfying t ~get ~lo ~hi:mid ~pred\n (* INVARIANT check: it means the first satisfying element, if it exists,\n is between [mid+1] and [hi] *)\n else find_range_near_first_satisfying t ~get ~lo:(mid + 1) ~hi ~pred)\n;;\n\nlet find_first_satisfying ?pos ?len t ~get ~length ~pred =\n let pos, len =\n Ordered_collection_common.get_pos_len_exn () ?pos ?len ~total_length:(length t)\n in\n let lo = pos in\n let hi = pos + len - 1 in\n let lo, hi = find_range_near_first_satisfying t ~get ~lo ~hi ~pred in\n linear_search_first_satisfying t ~get ~lo ~hi ~pred\n;;\n\n(* Takes an array with shape [true,...true,false,...false] (i.e., the _reverse_ of what\n is described above) and returns the index of the last true or None if there are no\n true*)\nlet find_last_satisfying ?pos ?len t ~pred ~get ~length =\n let pos, len =\n Ordered_collection_common.get_pos_len_exn () ?pos ?len ~total_length:(length t)\n in\n if len = 0\n then None\n else (\n (* The last satisfying is the one just before the first not satisfying *)\n match find_first_satisfying ~pos ~len t ~get ~length ~pred:(Fn.non pred) with\n | None -> Some (pos + len - 1)\n (* This means that all elements satisfy pred.\n There is at least an element as (len > 0) *)\n | Some i when i = pos -> None (* no element satisfies pred *)\n | Some i -> Some (i - 1))\n;;\n\nlet binary_search ?pos ?len t ~length ~get ~compare how v =\n match how with\n | `Last_strictly_less_than ->\n find_last_satisfying ?pos ?len t ~get ~length ~pred:(fun x -> compare x v < 0)\n | `Last_less_than_or_equal_to ->\n find_last_satisfying ?pos ?len t ~get ~length ~pred:(fun x -> compare x v <= 0)\n | `First_equal_to ->\n (match\n find_first_satisfying ?pos ?len t ~get ~length ~pred:(fun x -> compare x v >= 0)\n with\n | Some x when compare (get t x) v = 0 -> Some x\n | None | Some _ -> None)\n | `Last_equal_to ->\n (match\n find_last_satisfying ?pos ?len t ~get ~length ~pred:(fun x -> compare x v <= 0)\n with\n | Some x when compare (get t x) v = 0 -> Some x\n | None | Some _ -> None)\n | `First_greater_than_or_equal_to ->\n find_first_satisfying ?pos ?len t ~get ~length ~pred:(fun x -> compare x v >= 0)\n | `First_strictly_greater_than ->\n find_first_satisfying ?pos ?len t ~get ~length ~pred:(fun x -> compare x v > 0)\n;;\n\nlet binary_search_segmented ?pos ?len t ~length ~get ~segment_of how =\n let is_left x =\n match segment_of x with\n | `Left -> true\n | `Right -> false\n in\n let is_right x = not (is_left x) in\n match how with\n | `Last_on_left -> find_last_satisfying ?pos ?len t ~length ~get ~pred:is_left\n | `First_on_right -> find_first_satisfying ?pos ?len t ~length ~get ~pred:is_right\n;;\n","open! Import\ninclude Binary_searchable_intf\n\nmodule type Arg = sig\n type 'a elt\n type 'a t\n\n val get : 'a t -> int -> 'a elt\n val length : _ t -> int\nend\n\nmodule Make_gen (T : Arg) = struct\n let get = T.get\n let length = T.length\n\n let binary_search ?pos ?len t ~compare how v =\n Binary_search.binary_search ?pos ?len t ~get ~length ~compare how v\n ;;\n\n let binary_search_segmented ?pos ?len t ~segment_of how =\n Binary_search.binary_search_segmented ?pos ?len t ~get ~length ~segment_of how\n ;;\nend\n\nmodule Make (T : Indexable) = Make_gen (struct\n type 'a elt = T.elt\n type 'a t = T.t\n\n include (T : Indexable with type elt := T.elt with type t := T.t)\n end)\n\nmodule Make1 (T : Indexable1) = Make_gen (struct\n type 'a elt = 'a\n type 'a t = 'a T.t\n\n let get = T.get\n let length = T.length\n end)\n","(* [Bytes0] defines string functions that are primitives or can be simply\n defined in terms of [Caml.Bytes]. [Bytes0] is intended to completely express\n the part of [Caml.Bytes] that [Base] uses -- no other file in Base other\n than bytes0.ml should use [Caml.Bytes]. [Bytes0] has few dependencies, and\n so is available early in Base's build order.\n\n All Base files that need to use strings and come before [Base.Bytes] in\n build order should do:\n\n {[\n module Bytes = Bytes0\n ]}\n\n Defining [module Bytes = Bytes0] is also necessary because it prevents\n ocamldep from mistakenly causing a file to depend on [Base.Bytes]. *)\n\nopen! Import0\nmodule Sys = Sys0\n\nmodule Primitives = struct\n external get : bytes -> int -> char = \"%bytes_safe_get\"\n external length : bytes -> int = \"%bytes_length\"\n external unsafe_get : bytes -> int -> char = \"%bytes_unsafe_get\"\n\n include Bytes_set_primitives\n\n (* [unsafe_blit_string] is not exported in the [stdlib] so we export it here *)\n external unsafe_blit_string\n : src:string\n -> src_pos:int\n -> dst:bytes\n -> dst_pos:int\n -> len:int\n -> unit\n = \"caml_blit_string\"\n [@@noalloc]\nend\n\ninclude Primitives\n\nlet max_length = Sys.max_string_length\nlet blit = Caml.Bytes.blit\nlet blit_string = Caml.Bytes.blit_string\nlet compare = Caml.Bytes.compare\nlet copy = Caml.Bytes.copy\nlet create = Caml.Bytes.create\nlet fill = Caml.Bytes.fill\nlet make = Caml.Bytes.make\nlet map = Caml.Bytes.map\nlet mapi = Caml.Bytes.mapi\nlet sub = Caml.Bytes.sub\nlet unsafe_blit = Caml.Bytes.unsafe_blit\nlet to_string = Caml.Bytes.to_string\nlet of_string = Caml.Bytes.of_string\n\nlet unsafe_to_string ~no_mutation_while_string_reachable:s =\n Caml.Bytes.unsafe_to_string s\n;;\n\nlet unsafe_of_string_promise_no_mutation = Caml.Bytes.unsafe_of_string\n","open! Import\ninclude Blit_intf\n\nmodule type Sequence_gen = sig\n type 'a t\n\n val length : _ t -> int\nend\n\nmodule Make_gen\n (Src : Sequence_gen) (Dst : sig\n include Sequence_gen\n\n val create_like : len:int -> 'a Src.t -> 'a t\n val unsafe_blit : ('a Src.t, 'a t) blit\n end) =\nstruct\n let unsafe_blit = Dst.unsafe_blit\n\n let blit ~src ~src_pos ~dst ~dst_pos ~len =\n Ordered_collection_common.check_pos_len_exn\n ~pos:src_pos\n ~len\n ~total_length:(Src.length src);\n Ordered_collection_common.check_pos_len_exn\n ~pos:dst_pos\n ~len\n ~total_length:(Dst.length dst);\n if len > 0 then unsafe_blit ~src ~src_pos ~dst ~dst_pos ~len\n ;;\n\n let blito\n ~src\n ?(src_pos = 0)\n ?(src_len = Src.length src - src_pos)\n ~dst\n ?(dst_pos = 0)\n ()\n =\n blit ~src ~src_pos ~len:src_len ~dst ~dst_pos\n ;;\n\n (* [sub] and [subo] ensure that every position of the created sequence is populated by\n an element of the source array. Thus every element of [dst] below is well\n defined. *)\n let sub src ~pos ~len =\n Ordered_collection_common.check_pos_len_exn ~pos ~len ~total_length:(Src.length src);\n let dst = Dst.create_like ~len src in\n if len > 0 then unsafe_blit ~src ~src_pos:pos ~dst ~dst_pos:0 ~len;\n dst\n ;;\n\n let subo ?(pos = 0) ?len src =\n sub\n src\n ~pos\n ~len:\n (match len with\n | Some i -> i\n | None -> Src.length src - pos)\n ;;\nend\n\nmodule Make1 (Sequence : sig\n include Sequence_gen\n\n val create_like : len:int -> 'a t -> 'a t\n val unsafe_blit : ('a t, 'a t) blit\n end) =\n Make_gen (Sequence) (Sequence)\n\nmodule Make1_generic (Sequence : Sequence1) = Make_gen (Sequence) (Sequence)\n\nmodule Make (Sequence : sig\n include Sequence\n\n val create : len:int -> t\n val unsafe_blit : (t, t) blit\n end) =\nstruct\n module Sequence = struct\n type 'a t = Sequence.t\n\n open Sequence\n\n let create_like ~len _ = create ~len\n let length = length\n let unsafe_blit = unsafe_blit\n end\n\n include Make_gen (Sequence) (Sequence)\nend\n\nmodule Make_distinct\n (Src : Sequence) (Dst : sig\n include Sequence\n\n val create : len:int -> t\n val unsafe_blit : (Src.t, t) blit\n end) =\n Make_gen\n (struct\n type 'a t = Src.t\n\n open Src\n\n let length = length\n end)\n (struct\n type 'a t = Dst.t\n\n open Dst\n\n let length = length\n let create_like ~len _ = create ~len\n let unsafe_blit = unsafe_blit\n end)\n\nmodule Make_to_string (T : sig\n type t\n end)\n (To_bytes : S_distinct with type src := T.t with type dst := bytes) =\nstruct\n open To_bytes\n\n let sub src ~pos ~len =\n Bytes0.unsafe_to_string ~no_mutation_while_string_reachable:(sub src ~pos ~len)\n ;;\n\n let subo ?pos ?len src =\n Bytes0.unsafe_to_string ~no_mutation_while_string_reachable:(subo ?pos ?len src)\n ;;\nend\n","open! Import\n\ntype 'a t = 'a option =\n | None\n | Some of 'a\n\ninclude (\nstruct\n type 'a t = 'a option [@@deriving_inline compare, hash, sexp, sexp_grammar]\n\n let compare : 'a. ('a -> 'a -> int) -> 'a t -> 'a t -> int = compare_option\n\n let hash_fold_t :\n 'a. (Ppx_hash_lib.Std.Hash.state -> 'a -> Ppx_hash_lib.Std.Hash.state)\n -> Ppx_hash_lib.Std.Hash.state -> 'a t -> Ppx_hash_lib.Std.Hash.state\n =\n hash_fold_option\n ;;\n\n let t_of_sexp :\n 'a. (Ppx_sexp_conv_lib.Sexp.t -> 'a) -> Ppx_sexp_conv_lib.Sexp.t -> 'a t\n =\n option_of_sexp\n ;;\n\n let sexp_of_t :\n 'a. ('a -> Ppx_sexp_conv_lib.Sexp.t) -> 'a t -> Ppx_sexp_conv_lib.Sexp.t\n =\n sexp_of_option\n ;;\n\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group)\n =\n { implicit_vars = [ \"option\" ]\n ; ggid = \"j\\132);\\135qH\\158\\135\\222H\\001\\007\\004\\158\\218\"\n ; types =\n [ \"t\", Explicit_bind ([ \"a\" ], Apply (Implicit_var 0, [ Explicit_var 0 ])) ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ option_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"option.ml\"\n }\n in\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"t\", _the_group)\n in\n t_sexp_grammar\n ;;\n\n [@@@end]\nend :\nsig\n type 'a t = 'a option [@@deriving_inline compare, hash, sexp, sexp_grammar]\n\n val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int\n\n val hash_fold_t\n : (Ppx_hash_lib.Std.Hash.state -> 'a -> Ppx_hash_lib.Std.Hash.state)\n -> Ppx_hash_lib.Std.Hash.state\n -> 'a t\n -> Ppx_hash_lib.Std.Hash.state\n\n include Ppx_sexp_conv_lib.Sexpable.S1 with type 'a t := 'a t\n\n val t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t\n\n [@@@end]\nend\nwith type 'a t := 'a t)\n\nlet is_none = function\n | None -> true\n | _ -> false\n;;\n\nlet is_some = function\n | Some _ -> true\n | _ -> false\n;;\n\nlet value_map o ~default ~f =\n match o with\n | Some x -> f x\n | None -> default\n;;\n\nlet iter o ~f =\n match o with\n | None -> ()\n | Some a -> f a\n;;\n\nlet invariant f t = iter t ~f\n\nlet map2 o1 o2 ~f =\n match o1, o2 with\n | Some a1, Some a2 -> Some (f a1 a2)\n | _ -> None\n;;\n\nlet call x ~f =\n match f with\n | None -> ()\n | Some f -> f x\n;;\n\nlet value t ~default =\n match t with\n | None -> default\n | Some x -> x\n;;\n\nlet value_exn ?here ?error ?message t =\n match t with\n | Some x -> x\n | None ->\n let error =\n match here, error, message with\n | None, None, None -> Error.of_string \"Option.value_exn None\"\n | None, None, Some m -> Error.of_string m\n | None, Some e, None -> e\n | None, Some e, Some m -> Error.tag e ~tag:m\n | Some p, None, None ->\n Error.create \"Option.value_exn\" p Source_code_position0.sexp_of_t\n | Some p, None, Some m -> Error.create m p Source_code_position0.sexp_of_t\n | Some p, Some e, _ ->\n Error.create\n (value message ~default:\"\")\n (e, p)\n (sexp_of_pair Error.sexp_of_t Source_code_position0.sexp_of_t)\n in\n Error.raise error\n;;\n\nlet to_array t =\n match t with\n | None -> [||]\n | Some x -> [| x |]\n;;\n\nlet to_list t =\n match t with\n | None -> []\n | Some x -> [ x ]\n;;\n\nlet min_elt t ~compare:_ = t\nlet max_elt t ~compare:_ = t\n\nlet sum (type a) (module M : Container.Summable with type t = a) t ~f =\n match t with\n | None -> M.zero\n | Some x -> f x\n;;\n\nlet for_all t ~f =\n match t with\n | None -> true\n | Some x -> f x\n;;\n\nlet exists t ~f =\n match t with\n | None -> false\n | Some x -> f x\n;;\n\nlet mem t a ~equal =\n match t with\n | None -> false\n | Some a' -> equal a a'\n;;\n\nlet length t =\n match t with\n | None -> 0\n | Some _ -> 1\n;;\n\nlet is_empty = is_none\n\nlet fold t ~init ~f =\n match t with\n | None -> init\n | Some x -> f init x\n;;\n\nlet count t ~f =\n match t with\n | None -> 0\n | Some a -> if f a then 1 else 0\n;;\n\nlet find t ~f =\n match t with\n | None -> None\n | Some x -> if f x then Some x else None\n;;\n\nlet find_map t ~f =\n match t with\n | None -> None\n | Some a -> f a\n;;\n\nlet equal f t t' =\n match t, t' with\n | None, None -> true\n | Some x, Some x' -> f x x'\n | _ -> false\n;;\n\nlet some x = Some x\n\nlet both x y =\n match x, y with\n | Some a, Some b -> Some (a, b)\n | _ -> None\n;;\n\nlet first_some x y =\n match x with\n | Some _ -> x\n | None -> y\n;;\n\nlet some_if cond x = if cond then Some x else None\n\nlet merge a b ~f =\n match a, b with\n | None, x | x, None -> x\n | Some a, Some b -> Some (f a b)\n;;\n\nlet filter t ~f =\n match t with\n | Some v as o when f v -> o\n | _ -> None\n;;\n\nlet try_with f =\n match f () with\n | x -> Some x\n | exception _ -> None\n;;\n\nlet try_with_join f =\n match f () with\n | x -> x\n | exception _ -> None\n;;\n\ninclude Monad.Make (struct\n type 'a t = 'a option\n\n let return x = Some x\n\n let map t ~f =\n match t with\n | None -> None\n | Some a -> Some (f a)\n ;;\n\n let map = `Custom map\n\n let bind o ~f =\n match o with\n | None -> None\n | Some x -> f x\n ;;\n end)\n\nlet fold_result t ~init ~f = Container.fold_result ~fold ~init ~f t\nlet fold_until t ~init ~f = Container.fold_until ~fold ~init ~f t\n\nlet validate ~none ~some t =\n let module V = Validate in\n match t with\n | None -> V.name \"none\" (V.protect none ())\n | Some x -> V.name \"some\" (V.protect some x)\n;;\n","open! Import\ninclude Either_intf\nmodule Array = Array0\nmodule List = List0\ninclude Either0\n\nlet swap = function\n | First x -> Second x\n | Second x -> First x\n;;\n\nlet is_first = function\n | First _ -> true\n | Second _ -> false\n;;\n\nlet is_second = function\n | First _ -> false\n | Second _ -> true\n;;\n\nlet value (First x | Second x) = x\n\nlet value_map t ~first ~second =\n match t with\n | First x -> first x\n | Second x -> second x\n;;\n\nlet iter = value_map\n\nlet map t ~first ~second =\n match t with\n | First x -> First (first x)\n | Second x -> Second (second x)\n;;\n\nlet first x = First x\nlet second x = Second x\n\nlet equal eq1 eq2 t1 t2 =\n match t1, t2 with\n | First x, First y -> eq1 x y\n | Second x, Second y -> eq2 x y\n | First _, Second _ | Second _, First _ -> false\n;;\n\nlet invariant f s = function\n | First x -> f x\n | Second y -> s y\n;;\n\nmodule Make_focused (M : sig\n type (+'a, +'b) t\n\n val return : 'a -> ('a, _) t\n val other : 'b -> (_, 'b) t\n val either : ('a, 'b) t -> return:('a -> 'c) -> other:('b -> 'c) -> 'c\n\n val combine\n : ('a, 'd) t\n -> ('b, 'd) t\n -> f:('a -> 'b -> 'c)\n -> other:('d -> 'd -> 'd)\n -> ('c, 'd) t\n\n val bind : ('a, 'b) t -> f:('a -> ('c, 'b) t) -> ('c, 'b) t\n end) =\nstruct\n include M\n open With_return\n\n let map t ~f = bind t ~f:(fun x -> return (f x))\n\n include Monad.Make2 (struct\n type nonrec ('a, 'b) t = ('a, 'b) t\n\n let return = return\n let bind = bind\n let map = `Custom map\n end)\n\n module App = Applicative.Make2 (struct\n type nonrec ('a, 'b) t = ('a, 'b) t\n\n let return = return\n let apply t1 t2 = bind t1 ~f:(fun f -> bind t2 ~f:(fun x -> return (f x)))\n let map = `Custom map\n end)\n\n include App\n\n let combine_all =\n let rec other_loop f acc = function\n | [] -> other acc\n | t :: ts ->\n either\n t\n ~return:(fun _ -> other_loop f acc ts)\n ~other:(fun o -> other_loop f (f acc o) ts)\n in\n let rec return_loop f acc = function\n | [] -> return (List.rev acc)\n | t :: ts ->\n either\n t\n ~return:(fun x -> return_loop f (x :: acc) ts)\n ~other:(fun o -> other_loop f o ts)\n in\n fun ts ~f -> return_loop f [] ts\n ;;\n\n let combine_all_unit =\n let rec other_loop f acc = function\n | [] -> other acc\n | t :: ts ->\n either\n t\n ~return:(fun () -> other_loop f acc ts)\n ~other:(fun o -> other_loop f (f acc o) ts)\n in\n let rec return_loop f = function\n | [] -> return ()\n | t :: ts ->\n either t ~return:(fun () -> return_loop f ts) ~other:(fun o -> other_loop f o ts)\n in\n fun ts ~f -> return_loop f ts\n ;;\n\n let to_option t = either t ~return:Option.some ~other:(fun _ -> None)\n let value t ~default = either t ~return:Fn.id ~other:(fun _ -> default)\n\n let with_return f =\n with_return (fun ret -> other (f (With_return.prepend ret ~f:return)))\n ;;\nend\n\nmodule First = Make_focused (struct\n type nonrec ('a, 'b) t = ('a, 'b) t\n\n let return = first\n let other = second\n\n let either t ~return ~other =\n match t with\n | First x -> return x\n | Second y -> other y\n ;;\n\n let combine t1 t2 ~f ~other =\n match t1, t2 with\n | First x, First y -> First (f x y)\n | Second x, Second y -> Second (other x y)\n | Second x, _ | _, Second x -> Second x\n ;;\n\n let bind t ~f =\n match t with\n | First x -> f x\n (* Reuse the value in order to avoid allocation. *)\n | Second _ as y -> y\n ;;\n end)\n\nmodule Second = Make_focused (struct\n type nonrec ('a, 'b) t = ('b, 'a) t\n\n let return = second\n let other = first\n\n let either t ~return ~other =\n match t with\n | Second y -> return y\n | First x -> other x\n ;;\n\n let combine t1 t2 ~f ~other =\n match t1, t2 with\n | Second x, Second y -> Second (f x y)\n | First x, First y -> First (other x y)\n | First x, _ | _, First x -> First x\n ;;\n\n let bind t ~f =\n match t with\n | Second x -> f x\n (* Reuse the value in order to avoid allocation, like [First.bind] above. *)\n | First _ as y -> y\n ;;\n end)\n\nmodule Export = struct\n type ('f, 's) _either = ('f, 's) t =\n | First of 'f\n | Second of 's\nend\n","include Indexed_container_intf\n\nlet with_return = With_return.with_return\n\nlet iteri ~fold t ~f =\n ignore\n (fold t ~init:0 ~f:(fun i x ->\n f i x;\n i + 1)\n : int)\n;;\n\nlet foldi ~fold t ~init ~f =\n let i = ref 0 in\n fold t ~init ~f:(fun acc v ->\n let acc = f !i acc v in\n i := !i + 1;\n acc)\n;;\n\nlet counti ~foldi t ~f = foldi t ~init:0 ~f:(fun i n a -> if f i a then n + 1 else n)\n\nlet existsi ~iteri c ~f =\n with_return (fun r ->\n iteri c ~f:(fun i x -> if f i x then r.return true);\n false)\n;;\n\nlet for_alli ~iteri c ~f =\n with_return (fun r ->\n iteri c ~f:(fun i x -> if not (f i x) then r.return false);\n true)\n;;\n\nlet find_mapi ~iteri t ~f =\n with_return (fun r ->\n iteri t ~f:(fun i x ->\n match f i x with\n | None -> ()\n | Some _ as res -> r.return res);\n None)\n;;\n\nlet findi ~iteri c ~f =\n with_return (fun r ->\n iteri c ~f:(fun i x -> if f i x then r.return (Some (i, x)));\n None)\n;;\n\nmodule Make (T : Make_arg) : S1 with type 'a t := 'a T.t = struct\n include Container.Make (T)\n\n let iteri =\n match T.iteri with\n | `Custom iteri -> iteri\n | `Define_using_fold -> fun t ~f -> iteri ~fold t ~f\n ;;\n\n let foldi =\n match T.foldi with\n | `Custom foldi -> foldi\n | `Define_using_fold -> fun t ~init ~f -> foldi ~fold t ~init ~f\n ;;\n\n let counti t ~f = counti ~foldi t ~f\n let existsi t ~f = existsi ~iteri t ~f\n let for_alli t ~f = for_alli ~iteri t ~f\n let find_mapi t ~f = find_mapi ~iteri t ~f\n let findi t ~f = findi ~iteri t ~f\nend\n","open! Import\nopen Container_intf.Export\nmodule Array = Array0\nmodule List = List1\n\nmodule Step = struct\n (* 'a is an item in the sequence, 's is the state that will produce the remainder of\n the sequence *)\n type ('a, 's) t =\n | Done\n | Skip of 's\n | Yield of 'a * 's\n [@@deriving_inline sexp_of]\n\n let sexp_of_t\n : type a s.\n (a -> Ppx_sexp_conv_lib.Sexp.t)\n -> (s -> Ppx_sexp_conv_lib.Sexp.t)\n -> (a, s) t\n -> Ppx_sexp_conv_lib.Sexp.t\n =\n fun _of_a _of_s -> function\n | Done -> Ppx_sexp_conv_lib.Sexp.Atom \"Done\"\n | Skip v0 ->\n let v0 = _of_s v0 in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"Skip\"; v0 ]\n | Yield (v0, v1) ->\n let v0 = _of_a v0\n and v1 = _of_s v1 in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"Yield\"; v0; v1 ]\n ;;\n\n [@@@end]\nend\n\nopen Step\n\n(* 'a is an item in the sequence, 's is the state that will produce the remainder of the\n sequence *)\ntype +_ t = Sequence : 's * ('s -> ('a, 's) Step.t) -> 'a t\ntype 'a sequence = 'a t\n\nmodule Expert = struct\n let next_step (Sequence (s, f)) =\n match f s with\n | Done -> Done\n | Skip s -> Skip (Sequence (s, f))\n | Yield (a, s) -> Yield (a, Sequence (s, f))\n ;;\n\n let delayed_fold_step s ~init ~f ~finish =\n let rec loop s next finish f acc =\n match next s with\n | Done -> finish acc\n | Skip s -> f acc None ~k:(loop s next finish f)\n | Yield (a, s) -> f acc (Some a) ~k:(loop s next finish f)\n in\n match s with\n | Sequence (s, next) -> loop s next finish f init\n ;;\nend\n\nlet unfold_step ~init ~f = Sequence (init, f)\n\nlet unfold ~init ~f =\n unfold_step ~init ~f:(fun s ->\n match f s with\n | None -> Step.Done\n | Some (a, s) -> Step.Yield (a, s))\n;;\n\nlet unfold_with s ~init ~f =\n match s with\n | Sequence (s, next) ->\n Sequence\n ( (init, s)\n , fun (seed, s) ->\n match next s with\n | Done -> Done\n | Skip s -> Skip (seed, s)\n | Yield (a, s) ->\n (match f seed a with\n | Done -> Done\n | Skip seed -> Skip (seed, s)\n | Yield (a, seed) -> Yield (a, (seed, s))) )\n;;\n\nlet unfold_with_and_finish s ~init ~running_step ~inner_finished ~finishing_step =\n match s with\n | Sequence (s, next) ->\n Sequence\n ( `Inner_running (init, s)\n , fun state ->\n match state with\n | `Inner_running (state, inner_state) ->\n (match next inner_state with\n | Done -> Skip (`Inner_finished (inner_finished state))\n | Skip inner_state -> Skip (`Inner_running (state, inner_state))\n | Yield (x, inner_state) ->\n (match running_step state x with\n | Done -> Done\n | Skip state -> Skip (`Inner_running (state, inner_state))\n | Yield (y, state) -> Yield (y, `Inner_running (state, inner_state))))\n | `Inner_finished state ->\n (match finishing_step state with\n | Done -> Done\n | Skip state -> Skip (`Inner_finished state)\n | Yield (y, state) -> Yield (y, `Inner_finished state)) )\n;;\n\nlet of_list l =\n unfold_step ~init:l ~f:(function\n | [] -> Done\n | x :: l -> Yield (x, l))\n;;\n\n\nlet fold t ~init ~f =\n let rec loop seed v next f =\n match next seed with\n | Done -> v\n | Skip s -> loop s v next f\n | Yield (a, s) -> loop s (f v a) next f\n in\n match t with\n | Sequence (seed, next) -> loop seed init next f\n;;\n\nlet to_list_rev t = fold t ~init:[] ~f:(fun l x -> x :: l)\n\n\nlet to_list (Sequence (s, next)) =\n let safe_to_list t = List.rev (to_list_rev t) in\n let rec to_list s next i =\n if i = 0\n then safe_to_list (Sequence (s, next))\n else (\n match next s with\n | Done -> []\n | Skip s -> to_list s next i\n | Yield (a, s) -> a :: to_list s next (i - 1))\n in\n to_list s next 500\n;;\n\nlet sexp_of_t sexp_of_a t = sexp_of_list sexp_of_a (to_list t)\n\nlet range ?(stride = 1) ?(start = `inclusive) ?(stop = `exclusive) start_v stop_v =\n let step =\n match stop with\n | `inclusive when stride >= 0 ->\n fun i -> if i > stop_v then Done else Yield (i, i + stride)\n | `inclusive -> fun i -> if i < stop_v then Done else Yield (i, i + stride)\n | `exclusive when stride >= 0 ->\n fun i -> if i >= stop_v then Done else Yield (i, i + stride)\n | `exclusive -> fun i -> if i <= stop_v then Done else Yield (i, i + stride)\n in\n let init =\n match start with\n | `inclusive -> start_v\n | `exclusive -> start_v + stride\n in\n unfold_step ~init ~f:step\n;;\n\nlet of_lazy t_lazy =\n unfold_step ~init:t_lazy ~f:(fun t_lazy ->\n let (Sequence (s, next)) = Lazy.force t_lazy in\n match next s with\n | Done -> Done\n | Skip s ->\n Skip\n (let v = Sequence (s, next) in\n lazy v)\n | Yield (x, s) ->\n Yield\n ( x\n , let v = Sequence (s, next) in\n lazy v ))\n;;\n\nlet map t ~f =\n match t with\n | Sequence (seed, next) ->\n Sequence\n ( seed\n , fun seed ->\n match next seed with\n | Done -> Done\n | Skip s -> Skip s\n | Yield (a, s) -> Yield (f a, s) )\n;;\n\nlet mapi t ~f =\n match t with\n | Sequence (s, next) ->\n Sequence\n ( (0, s)\n , fun (i, s) ->\n match next s with\n | Done -> Done\n | Skip s -> Skip (i, s)\n | Yield (a, s) -> Yield (f i a, (i + 1, s)) )\n;;\n\nlet folding_map t ~init ~f =\n unfold_with t ~init ~f:(fun acc x ->\n let acc, x = f acc x in\n Yield (x, acc))\n;;\n\nlet folding_mapi t ~init ~f =\n unfold_with t ~init:(0, init) ~f:(fun (i, acc) x ->\n let acc, x = f i acc x in\n Yield (x, (i + 1, acc)))\n;;\n\nlet filter t ~f =\n match t with\n | Sequence (seed, next) ->\n Sequence\n ( seed\n , fun seed ->\n match next seed with\n | Done -> Done\n | Skip s -> Skip s\n | Yield (a, s) when f a -> Yield (a, s)\n | Yield (_, s) -> Skip s )\n;;\n\nlet filteri t ~f =\n map ~f:snd (filter (mapi t ~f:(fun i s -> i, s)) ~f:(fun (i, s) -> f i s))\n;;\n\nlet length t =\n let rec loop i s next =\n match next s with\n | Done -> i\n | Skip s -> loop i s next\n | Yield (_, s) -> loop (i + 1) s next\n in\n match t with\n | Sequence (seed, next) -> loop 0 seed next\n;;\n\nlet to_list_rev_with_length t = fold t ~init:([], 0) ~f:(fun (l, i) x -> x :: l, i + 1)\n\nlet to_array t =\n let l, len = to_list_rev_with_length t in\n match l with\n | [] -> [||]\n | x :: l ->\n let a = Array.create ~len x in\n let rec loop i l =\n match l with\n | [] -> assert (i = -1)\n | x :: l ->\n a.(i) <- x;\n loop (i - 1) l\n in\n loop (len - 2) l;\n a\n;;\n\nlet find t ~f =\n let rec loop s next f =\n match next s with\n | Done -> None\n | Yield (a, _) when f a -> Some a\n | Yield (_, s) | Skip s -> loop s next f\n in\n match t with\n | Sequence (seed, next) -> loop seed next f\n;;\n\nlet find_map t ~f =\n let rec loop s next f =\n match next s with\n | Done -> None\n | Yield (a, s) ->\n (match f a with\n | None -> loop s next f\n | some_b -> some_b)\n | Skip s -> loop s next f\n in\n match t with\n | Sequence (seed, next) -> loop seed next f\n;;\n\n\nlet find_mapi t ~f =\n let rec loop s next f i =\n match next s with\n | Done -> None\n | Yield (a, s) ->\n (match f i a with\n | None -> loop s next f (i + 1)\n | some_b -> some_b)\n | Skip s -> loop s next f i\n in\n match t with\n | Sequence (seed, next) -> loop seed next f 0\n;;\n\nlet for_all t ~f =\n let rec loop s next f =\n match next s with\n | Done -> true\n | Yield (a, _) when not (f a) -> false\n | Yield (_, s) | Skip s -> loop s next f\n in\n match t with\n | Sequence (seed, next) -> loop seed next f\n;;\n\nlet for_alli t ~f =\n let rec loop s next f i =\n match next s with\n | Done -> true\n | Yield (a, _) when not (f i a) -> false\n | Yield (_, s) -> loop s next f (i + 1)\n | Skip s -> loop s next f i\n in\n match t with\n | Sequence (seed, next) -> loop seed next f 0\n;;\n\nlet exists t ~f =\n let rec loop s next f =\n match next s with\n | Done -> false\n | Yield (a, _) when f a -> true\n | Yield (_, s) | Skip s -> loop s next f\n in\n match t with\n | Sequence (seed, next) -> loop seed next f\n;;\n\nlet existsi t ~f =\n let rec loop s next f i =\n match next s with\n | Done -> false\n | Yield (a, _) when f i a -> true\n | Yield (_, s) -> loop s next f (i + 1)\n | Skip s -> loop s next f i\n in\n match t with\n | Sequence (seed, next) -> loop seed next f 0\n;;\n\nlet iter t ~f =\n let rec loop seed next f =\n match next seed with\n | Done -> ()\n | Skip s -> loop s next f\n | Yield (a, s) ->\n f a;\n loop s next f\n in\n match t with\n | Sequence (seed, next) -> loop seed next f\n;;\n\nlet is_empty t =\n let rec loop s next =\n match next s with\n | Done -> true\n | Skip s -> loop s next\n | Yield _ -> false\n in\n match t with\n | Sequence (seed, next) -> loop seed next\n;;\n\nlet mem t a ~equal =\n let rec loop s next a =\n match next s with\n | Done -> false\n | Yield (b, _) when equal a b -> true\n | Yield (_, s) | Skip s -> loop s next a\n in\n match t with\n | Sequence (seed, next) -> loop seed next a\n;;\n\nlet empty = Sequence ((), fun () -> Done)\n\nlet bind t ~f =\n unfold_step\n ~f:(function\n | Sequence (seed, next), rest ->\n (match next seed with\n | Done ->\n (match rest with\n | Sequence (seed, next) ->\n (match next seed with\n | Done -> Done\n | Skip s -> Skip (empty, Sequence (s, next))\n | Yield (a, s) -> Skip (f a, Sequence (s, next))))\n | Skip s -> Skip (Sequence (s, next), rest)\n | Yield (a, s) -> Yield (a, (Sequence (s, next), rest))))\n ~init:(empty, t)\n;;\n\nlet return x =\n unfold_step ~init:(Some x) ~f:(function\n | None -> Done\n | Some x -> Yield (x, None))\n;;\n\ninclude Monad.Make (struct\n type nonrec 'a t = 'a t\n\n let map = `Custom map\n let bind = bind\n let return = return\n end)\n\nlet nth s n =\n if n < 0\n then None\n else (\n let rec loop i s next =\n match next s with\n | Done -> None\n | Skip s -> loop i s next\n | Yield (a, s) -> if phys_equal i 0 then Some a else loop (i - 1) s next\n in\n match s with\n | Sequence (s, next) -> loop n s next)\n;;\n\nlet nth_exn s n =\n if n < 0\n then invalid_arg \"Sequence.nth\"\n else (\n match nth s n with\n | None -> failwith \"Sequence.nth\"\n | Some x -> x)\n;;\n\nmodule Merge_with_duplicates_element = struct\n type ('a, 'b) t =\n | Left of 'a\n | Right of 'b\n | Both of 'a * 'b\n [@@deriving_inline compare, hash, sexp]\n\n let compare :\n 'a 'b. ('a -> 'a -> int) -> ('b -> 'b -> int) -> ('a, 'b) t -> ('a, 'b) t -> int\n =\n fun _cmp__a _cmp__b a__001_ b__002_ ->\n if Ppx_compare_lib.phys_equal a__001_ b__002_\n then 0\n else (\n match a__001_, b__002_ with\n | Left _a__003_, Left _b__004_ -> _cmp__a _a__003_ _b__004_\n | Left _, _ -> -1\n | _, Left _ -> 1\n | Right _a__005_, Right _b__006_ -> _cmp__b _a__005_ _b__006_\n | Right _, _ -> -1\n | _, Right _ -> 1\n | Both (_a__007_, _a__009_), Both (_b__008_, _b__010_) ->\n (match _cmp__a _a__007_ _b__008_ with\n | 0 -> _cmp__b _a__009_ _b__010_\n | n -> n))\n ;;\n\n let hash_fold_t\n : type a b.\n (Ppx_hash_lib.Std.Hash.state -> a -> Ppx_hash_lib.Std.Hash.state)\n -> (Ppx_hash_lib.Std.Hash.state -> b -> Ppx_hash_lib.Std.Hash.state)\n -> Ppx_hash_lib.Std.Hash.state\n -> (a, b) t\n -> Ppx_hash_lib.Std.Hash.state\n =\n fun _hash_fold_a _hash_fold_b hsv arg ->\n match arg with\n | Left _a0 ->\n let hsv = Ppx_hash_lib.Std.Hash.fold_int hsv 0 in\n let hsv = hsv in\n _hash_fold_a hsv _a0\n | Right _a0 ->\n let hsv = Ppx_hash_lib.Std.Hash.fold_int hsv 1 in\n let hsv = hsv in\n _hash_fold_b hsv _a0\n | Both (_a0, _a1) ->\n let hsv = Ppx_hash_lib.Std.Hash.fold_int hsv 2 in\n let hsv =\n let hsv = hsv in\n _hash_fold_a hsv _a0\n in\n _hash_fold_b hsv _a1\n ;;\n\n let t_of_sexp\n : type a b.\n (Ppx_sexp_conv_lib.Sexp.t -> a)\n -> (Ppx_sexp_conv_lib.Sexp.t -> b)\n -> Ppx_sexp_conv_lib.Sexp.t\n -> (a, b) t\n =\n let _tp_loc = \"sequence.ml.Merge_with_duplicates_element.t\" in\n fun _of_a _of_b -> function\n | Ppx_sexp_conv_lib.Sexp.List\n (Ppx_sexp_conv_lib.Sexp.Atom ((\"left\" | \"Left\") as _tag) :: sexp_args) as _sexp\n ->\n (match sexp_args with\n | [ v0 ] ->\n let v0 = _of_a v0 in\n Left v0\n | _ -> Ppx_sexp_conv_lib.Conv_error.stag_incorrect_n_args _tp_loc _tag _sexp)\n | Ppx_sexp_conv_lib.Sexp.List\n (Ppx_sexp_conv_lib.Sexp.Atom ((\"right\" | \"Right\") as _tag) :: sexp_args) as\n _sexp ->\n (match sexp_args with\n | [ v0 ] ->\n let v0 = _of_b v0 in\n Right v0\n | _ -> Ppx_sexp_conv_lib.Conv_error.stag_incorrect_n_args _tp_loc _tag _sexp)\n | Ppx_sexp_conv_lib.Sexp.List\n (Ppx_sexp_conv_lib.Sexp.Atom ((\"both\" | \"Both\") as _tag) :: sexp_args) as _sexp\n ->\n (match sexp_args with\n | [ v0; v1 ] ->\n let v0 = _of_a v0\n and v1 = _of_b v1 in\n Both (v0, v1)\n | _ -> Ppx_sexp_conv_lib.Conv_error.stag_incorrect_n_args _tp_loc _tag _sexp)\n | Ppx_sexp_conv_lib.Sexp.Atom (\"left\" | \"Left\") as sexp ->\n Ppx_sexp_conv_lib.Conv_error.stag_takes_args _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.Atom (\"right\" | \"Right\") as sexp ->\n Ppx_sexp_conv_lib.Conv_error.stag_takes_args _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.Atom (\"both\" | \"Both\") as sexp ->\n Ppx_sexp_conv_lib.Conv_error.stag_takes_args _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.List (Ppx_sexp_conv_lib.Sexp.List _ :: _) as sexp ->\n Ppx_sexp_conv_lib.Conv_error.nested_list_invalid_sum _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.List [] as sexp ->\n Ppx_sexp_conv_lib.Conv_error.empty_list_invalid_sum _tp_loc sexp\n | sexp -> Ppx_sexp_conv_lib.Conv_error.unexpected_stag _tp_loc sexp\n ;;\n\n let sexp_of_t\n : type a b.\n (a -> Ppx_sexp_conv_lib.Sexp.t)\n -> (b -> Ppx_sexp_conv_lib.Sexp.t)\n -> (a, b) t\n -> Ppx_sexp_conv_lib.Sexp.t\n =\n fun _of_a _of_b -> function\n | Left v0 ->\n let v0 = _of_a v0 in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"Left\"; v0 ]\n | Right v0 ->\n let v0 = _of_b v0 in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"Right\"; v0 ]\n | Both (v0, v1) ->\n let v0 = _of_a v0\n and v1 = _of_b v1 in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"Both\"; v0; v1 ]\n ;;\n\n [@@@end]\nend\n\nlet merge_with_duplicates (Sequence (s1, next1)) (Sequence (s2, next2)) ~compare =\n let unshadowed_compare = compare in\n let open Merge_with_duplicates_element in\n let next = function\n | Skip s1, s2 -> Skip (next1 s1, s2)\n | s1, Skip s2 -> Skip (s1, next2 s2)\n | (Yield (a, s1') as s1), (Yield (b, s2') as s2) ->\n let comparison = unshadowed_compare a b in\n if comparison < 0\n then Yield (Left a, (Skip s1', s2))\n else if comparison = 0\n then Yield (Both (a, b), (Skip s1', Skip s2'))\n else Yield (Right b, (s1, Skip s2'))\n | Done, Done -> Done\n | Yield (a, s1), Done -> Yield (Left a, (Skip s1, Done))\n | Done, Yield (b, s2) -> Yield (Right b, (Done, Skip s2))\n in\n Sequence ((Skip s1, Skip s2), next)\n;;\n\nlet merge s1 s2 ~compare =\n map (merge_with_duplicates s1 s2 ~compare) ~f:(function\n | Left x | Right x | Both (x, _) -> x)\n;;\n\nlet hd s =\n let rec loop s next =\n match next s with\n | Done -> None\n | Skip s -> loop s next\n | Yield (a, _) -> Some a\n in\n match s with\n | Sequence (s, next) -> loop s next\n;;\n\nlet hd_exn s =\n match hd s with\n | None -> failwith \"hd_exn\"\n | Some a -> a\n;;\n\nlet tl s =\n let rec loop s next =\n match next s with\n | Done -> None\n | Skip s -> loop s next\n | Yield (_, a) -> Some a\n in\n match s with\n | Sequence (s, next) ->\n (match loop s next with\n | None -> None\n | Some s -> Some (Sequence (s, next)))\n;;\n\nlet tl_eagerly_exn s =\n match tl s with\n | None -> failwith \"Sequence.tl_exn\"\n | Some s -> s\n;;\n\nlet lift_identity next s =\n match next s with\n | Done -> Done\n | Skip s -> Skip (`Identity s)\n | Yield (a, s) -> Yield (a, `Identity s)\n;;\n\nlet next s =\n let rec loop s next =\n match next s with\n | Done -> None\n | Skip s -> loop s next\n | Yield (a, s) -> Some (a, Sequence (s, next))\n in\n match s with\n | Sequence (s, next) -> loop s next\n;;\n\nlet filter_opt s =\n match s with\n | Sequence (s, next) ->\n Sequence\n ( s\n , fun s ->\n match next s with\n | Done -> Done\n | Skip s -> Skip s\n | Yield (None, s) -> Skip s\n | Yield (Some a, s) -> Yield (a, s) )\n;;\n\nlet filter_map s ~f = filter_opt (map s ~f)\nlet filter_mapi s ~f = filter_map (mapi s ~f:(fun i s -> i, s)) ~f:(fun (i, s) -> f i s)\n\nlet split_n s n =\n let rec loop s i accum next =\n if i <= 0\n then List.rev accum, Sequence (s, next)\n else (\n match next s with\n | Done -> List.rev accum, empty\n | Skip s -> loop s i accum next\n | Yield (a, s) -> loop s (i - 1) (a :: accum) next)\n in\n match s with\n | Sequence (s, next) -> loop s n [] next\n;;\n\nlet chunks_exn t n =\n if n <= 0\n then invalid_arg \"Sequence.chunks_exn\"\n else\n unfold_step ~init:t ~f:(fun t ->\n match split_n t n with\n | [], _empty -> Done\n | (_ :: _ as xs), t -> Yield (xs, t))\n;;\n\nlet findi s ~f = find (mapi s ~f:(fun i s -> i, s)) ~f:(fun (i, s) -> f i s)\n\nlet find_exn s ~f =\n match find s ~f with\n | None -> failwith \"Sequence.find_exn\"\n | Some x -> x\n;;\n\nlet append s1 s2 =\n match s1, s2 with\n | Sequence (s1, next1), Sequence (s2, next2) ->\n Sequence\n ( `First_list s1\n , function\n | `First_list s1 ->\n (match next1 s1 with\n | Done -> Skip (`Second_list s2)\n | Skip s1 -> Skip (`First_list s1)\n | Yield (a, s1) -> Yield (a, `First_list s1))\n | `Second_list s2 ->\n (match next2 s2 with\n | Done -> Done\n | Skip s2 -> Skip (`Second_list s2)\n | Yield (a, s2) -> Yield (a, `Second_list s2)) )\n;;\n\nlet concat_map s ~f = bind s ~f\nlet concat s = concat_map s ~f:Fn.id\nlet concat_mapi s ~f = concat_map (mapi s ~f:(fun i s -> i, s)) ~f:(fun (i, s) -> f i s)\n\nlet zip (Sequence (s1, next1)) (Sequence (s2, next2)) =\n let next = function\n | Yield (a, s1), Yield (b, s2) -> Yield ((a, b), (Skip s1, Skip s2))\n | Done, _ | _, Done -> Done\n | Skip s1, s2 -> Skip (next1 s1, s2)\n | s1, Skip s2 -> Skip (s1, next2 s2)\n in\n Sequence ((Skip s1, Skip s2), next)\n;;\n\nlet zip_full (Sequence (s1, next1)) (Sequence (s2, next2)) =\n let next = function\n | Yield (a, s1), Yield (b, s2) -> Yield (`Both (a, b), (Skip s1, Skip s2))\n | Done, Done -> Done\n | Skip s1, s2 -> Skip (next1 s1, s2)\n | s1, Skip s2 -> Skip (s1, next2 s2)\n | Done, Yield (b, s2) -> Yield (`Right b, (Done, next2 s2))\n | Yield (a, s1), Done -> Yield (`Left a, (next1 s1, Done))\n in\n Sequence ((Skip s1, Skip s2), next)\n;;\n\nlet bounded_length (Sequence (seed, next)) ~at_most =\n let rec loop i seed next =\n if i > at_most\n then `Greater\n else (\n match next seed with\n | Done -> `Is i\n | Skip seed -> loop i seed next\n | Yield (_, seed) -> loop (i + 1) seed next)\n in\n loop 0 seed next\n;;\n\nlet length_is_bounded_by ?(min = -1) ?max t =\n let length_is_at_least (Sequence (s, next)) =\n let rec loop s acc =\n if acc >= min\n then true\n else (\n match next s with\n | Done -> false\n | Skip s -> loop s acc\n | Yield (_, s) -> loop s (acc + 1))\n in\n loop s 0\n in\n match max with\n | None -> length_is_at_least t\n | Some max ->\n (match bounded_length t ~at_most:max with\n | `Is len when len >= min -> true\n | _ -> false)\n;;\n\nlet iteri s ~f = iter (mapi s ~f:(fun i s -> i, s)) ~f:(fun (i, s) -> f i s)\n\nlet foldi s ~init ~f =\n fold ~init (mapi s ~f:(fun i s -> i, s)) ~f:(fun acc (i, s) -> f i acc s)\n;;\n\nlet reduce s ~f =\n match next s with\n | None -> None\n | Some (a, s) -> Some (fold s ~init:a ~f)\n;;\n\nlet reduce_exn s ~f =\n match reduce s ~f with\n | None -> failwith \"Sequence.reduce_exn\"\n | Some res -> res\n;;\n\nlet group (Sequence (s, next)) ~break =\n unfold_step\n ~init:(Some ([], s))\n ~f:(function\n | None -> Done\n | Some (acc, s) ->\n (match acc, next s with\n | _, Skip s -> Skip (Some (acc, s))\n | [], Done -> Done\n | acc, Done -> Yield (List.rev acc, None)\n | [], Yield (cur, s) -> Skip (Some ([ cur ], s))\n | (prev :: _ as acc), Yield (cur, s) ->\n if break prev cur\n then Yield (List.rev acc, Some ([ cur ], s))\n else Skip (Some (cur :: acc, s))))\n;;\n\nlet find_consecutive_duplicate (Sequence (s, next)) ~equal =\n let rec loop last_elt s =\n match next s with\n | Done -> None\n | Skip s -> loop last_elt s\n | Yield (a, s) ->\n (match last_elt with\n | Some b when equal a b -> Some (b, a)\n | None | Some _ -> loop (Some a) s)\n in\n loop None s\n;;\n\nlet remove_consecutive_duplicates s ~equal =\n unfold_with s ~init:None ~f:(fun prev a ->\n match prev with\n | Some b when equal a b -> Skip (Some a)\n | None | Some _ -> Yield (a, Some a))\n;;\n\nlet count s ~f = length (filter s ~f)\nlet counti t ~f = length (filteri t ~f)\nlet sum m t ~f = Container.sum ~fold m t ~f\nlet min_elt t ~compare = Container.min_elt ~fold t ~compare\nlet max_elt t ~compare = Container.max_elt ~fold t ~compare\n\nlet init n ~f =\n unfold_step ~init:0 ~f:(fun i -> if i >= n then Done else Yield (f i, i + 1))\n;;\n\nlet sub s ~pos ~len =\n if pos < 0 || len < 0 then failwith \"Sequence.sub\";\n match s with\n | Sequence (s, next) ->\n Sequence\n ( (0, s)\n , fun (i, s) ->\n if i - pos >= len\n then Done\n else (\n match next s with\n | Done -> Done\n | Skip s -> Skip (i, s)\n | Yield (a, s) when i >= pos -> Yield (a, (i + 1, s))\n | Yield (_, s) -> Skip (i + 1, s)) )\n;;\n\nlet take s len =\n if len < 0 then failwith \"Sequence.take\";\n match s with\n | Sequence (s, next) ->\n Sequence\n ( (0, s)\n , fun (i, s) ->\n if i >= len\n then Done\n else (\n match next s with\n | Done -> Done\n | Skip s -> Skip (i, s)\n | Yield (a, s) -> Yield (a, (i + 1, s))) )\n;;\n\nlet drop s len =\n if len < 0 then failwith \"Sequence.drop\";\n match s with\n | Sequence (s, next) ->\n Sequence\n ( (0, s)\n , fun (i, s) ->\n match next s with\n | Done -> Done\n | Skip s -> Skip (i, s)\n | Yield (a, s) when i >= len -> Yield (a, (i + 1, s))\n | Yield (_, s) -> Skip (i + 1, s) )\n;;\n\nlet take_while s ~f =\n match s with\n | Sequence (s, next) ->\n Sequence\n ( s\n , fun s ->\n match next s with\n | Done -> Done\n | Skip s -> Skip s\n | Yield (a, s) when f a -> Yield (a, s)\n | Yield (_, _) -> Done )\n;;\n\nlet drop_while s ~f =\n match s with\n | Sequence (s, next) ->\n Sequence\n ( `Dropping s\n , function\n | `Dropping s ->\n (match next s with\n | Done -> Done\n | Skip s -> Skip (`Dropping s)\n | Yield (a, s) when f a -> Skip (`Dropping s)\n | Yield (a, s) -> Yield (a, `Identity s))\n | `Identity s -> lift_identity next s )\n;;\n\nlet shift_right s x =\n match s with\n | Sequence (seed, next) ->\n Sequence\n ( `Consing (seed, x)\n , function\n | `Consing (seed, x) -> Yield (x, `Identity seed)\n | `Identity s -> lift_identity next s )\n;;\n\nlet shift_right_with_list s l = append (of_list l) s\nlet shift_left = drop\n\nmodule Infix = struct\n let ( @ ) = append\nend\n\nlet intersperse s ~sep =\n match s with\n | Sequence (s, next) ->\n Sequence\n ( `Init s\n , function\n | `Init s ->\n (match next s with\n | Done -> Done\n | Skip s -> Skip (`Init s)\n | Yield (a, s) -> Yield (a, `Running s))\n | `Running s ->\n (match next s with\n | Done -> Done\n | Skip s -> Skip (`Running s)\n | Yield (a, s) -> Yield (sep, `Putting (a, s)))\n | `Putting (a, s) -> Yield (a, `Running s) )\n;;\n\nlet repeat x = unfold_step ~init:x ~f:(fun x -> Yield (x, x))\n\nlet cycle_list_exn xs =\n if List.is_empty xs then invalid_arg \"Sequence.cycle_list_exn\";\n let s = of_list xs in\n concat_map ~f:(fun () -> s) (repeat ())\n;;\n\nlet cartesian_product sa sb = concat_map sa ~f:(fun a -> zip (repeat a) sb)\nlet singleton x = return x\n\nlet delayed_fold s ~init ~f ~finish =\n Expert.delayed_fold_step s ~init ~finish ~f:(fun acc option ~k ->\n match option with\n | None -> k acc\n | Some a -> f acc a ~k)\n;;\n\nlet fold_m ~bind ~return t ~init ~f =\n Expert.delayed_fold_step\n t\n ~init\n ~f:(fun acc option ~k ->\n match option with\n | None -> bind (return acc) ~f:k\n | Some a -> bind (f acc a) ~f:k)\n ~finish:return\n;;\n\nlet iter_m ~bind ~return t ~f =\n Expert.delayed_fold_step\n t\n ~init:()\n ~f:(fun () option ~k ->\n match option with\n | None -> bind (return ()) ~f:k\n | Some a -> bind (f a) ~f:k)\n ~finish:return\n;;\n\nlet fold_until s ~init ~f ~finish =\n let rec loop s next f acc =\n match next s with\n | Done -> finish acc\n | Skip s -> loop s next f acc\n | Yield (a, s) ->\n (match (f acc a : ('a, 'b) Continue_or_stop.t) with\n | Stop x -> x\n | Continue acc -> loop s next f acc)\n in\n match s with\n | Sequence (s, next) -> loop s next f init\n;;\n\nlet fold_result s ~init ~f =\n let rec loop s next f acc =\n match next s with\n | Done -> Result.return acc\n | Skip s -> loop s next f acc\n | Yield (a, s) ->\n (match (f acc a : (_, _) Result.t) with\n | Error _ as e -> e\n | Ok acc -> loop s next f acc)\n in\n match s with\n | Sequence (s, next) -> loop s next f init\n;;\n\nlet force_eagerly t = of_list (to_list t)\n\nlet memoize (type a) (Sequence (s, next)) =\n let module M = struct\n type t = T of (a, t) Step.t Lazy.t\n end\n in\n let rec memoize s = M.T (lazy (find_step s))\n and find_step s =\n match next s with\n | Done -> Done\n | Skip s -> find_step s\n | Yield (a, s) -> Yield (a, memoize s)\n in\n Sequence (memoize s, fun (M.T l) -> Lazy.force l)\n;;\n\nlet drop_eagerly s len =\n let rec loop i ~len s next =\n if i >= len\n then Sequence (s, next)\n else (\n match next s with\n | Done -> empty\n | Skip s -> loop i ~len s next\n | Yield (_, s) -> loop (i + 1) ~len s next)\n in\n match s with\n | Sequence (s, next) -> loop 0 ~len s next\n;;\n\nlet drop_while_option (Sequence (s, next)) ~f =\n let rec loop s =\n match next s with\n | Done -> None\n | Skip s -> loop s\n | Yield (x, s) -> if f x then loop s else Some (x, Sequence (s, next))\n in\n loop s\n;;\n\nlet compare compare_a t1 t2 =\n With_return.with_return (fun r ->\n iter (zip_full t1 t2) ~f:(function\n | `Left _ -> r.return 1\n | `Right _ -> r.return (-1)\n | `Both (v1, v2) ->\n let c = compare_a v1 v2 in\n if c <> 0 then r.return c);\n 0)\n;;\n\nlet equal equal_a t1 t2 =\n for_all (zip_full t1 t2) ~f:(function\n | `Both (a1, a2) -> equal_a a1 a2\n | `Left _ | `Right _ -> false)\n;;\n\nlet round_robin list =\n let next (todo_stack, done_stack) =\n match todo_stack with\n | Sequence (s, f) :: todo_stack ->\n (match f s with\n | Yield (x, s) -> Yield (x, (todo_stack, Sequence (s, f) :: done_stack))\n | Skip s -> Skip (Sequence (s, f) :: todo_stack, done_stack)\n | Done -> Skip (todo_stack, done_stack))\n | [] -> if List.is_empty done_stack then Done else Skip (List.rev done_stack, [])\n in\n let state = list, [] in\n Sequence (state, next)\n;;\n\nlet interleave (Sequence (s1, f1)) =\n let next (todo_stack, done_stack, s1) =\n match todo_stack with\n | Sequence (s2, f2) :: todo_stack ->\n (match f2 s2 with\n | Yield (x, s2) -> Yield (x, (todo_stack, Sequence (s2, f2) :: done_stack, s1))\n | Skip s2 -> Skip (todo_stack, Sequence (s2, f2) :: done_stack, s1)\n | Done -> Skip (todo_stack, done_stack, s1))\n | [] ->\n (match f1 s1, done_stack with\n | Yield (t, s1), _ -> Skip (List.rev (t :: done_stack), [], s1)\n | Skip s1, _ -> Skip (List.rev done_stack, [], s1)\n | Done, _ :: _ -> Skip (List.rev done_stack, [], s1)\n | Done, [] -> Done)\n in\n let state = [], [], s1 in\n Sequence (state, next)\n;;\n\nlet interleaved_cartesian_product s1 s2 =\n map s1 ~f:(fun x1 -> map s2 ~f:(fun x2 -> x1, x2)) |> interleave\n;;\n\nlet of_seq (seq : _ Caml.Seq.t) =\n unfold_step ~init:seq ~f:(fun seq ->\n match seq () with\n | Nil -> Done\n | Cons (hd, tl) -> Yield (hd, tl))\n;;\n\nlet to_seq (Sequence (state, next)) =\n let rec loop state =\n match next state with\n | Done -> Caml.Seq.Nil\n | Skip state -> loop state\n | Yield (hd, state) -> Caml.Seq.Cons (hd, fun () -> loop state)\n in\n fun () -> loop state\n;;\n\nmodule Generator = struct\n type 'elt steps = Wrap of ('elt, unit -> 'elt steps) Step.t\n\n let unwrap (Wrap step) = step\n\n module T = struct\n type ('a, 'elt) t = ('a -> 'elt steps) -> 'elt steps\n\n let return x k = k x\n\n let bind m ~f k =\n m (fun a ->\n let m' = f a in\n m' k)\n ;;\n\n let map m ~f k = m (fun a -> k (f a))\n let map = `Custom map\n end\n\n include T\n include Monad.Make2 (T)\n\n let yield e k = Wrap (Yield (e, k))\n let to_steps t = t (fun () -> Wrap Done)\n\n let of_sequence sequence =\n delayed_fold\n sequence\n ~init:()\n ~f:(fun () x ~k f -> Wrap (Yield (x, fun () -> k () f)))\n ~finish:return\n ;;\n\n let run t =\n let init () = to_steps t in\n let f thunk = unwrap (thunk ()) in\n unfold_step ~init ~f\n ;;\nend\n","open! Import\ninclude Array0\nmodule Int = Int0\n\ntype 'a t = 'a array [@@deriving_inline compare, sexp, sexp_grammar]\n\nlet compare : 'a. ('a -> 'a -> int) -> 'a t -> 'a t -> int = compare_array\n\nlet t_of_sexp : 'a. (Ppx_sexp_conv_lib.Sexp.t -> 'a) -> Ppx_sexp_conv_lib.Sexp.t -> 'a t =\n array_of_sexp\n;;\n\nlet sexp_of_t : 'a. ('a -> Ppx_sexp_conv_lib.Sexp.t) -> 'a t -> Ppx_sexp_conv_lib.Sexp.t =\n sexp_of_array\n;;\n\nlet (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group) =\n { implicit_vars = [ \"array\" ]\n ; ggid = \"j\\132);\\135qH\\158\\135\\222H\\001\\007\\004\\158\\218\"\n ; types = [ \"t\", Explicit_bind ([ \"a\" ], Apply (Implicit_var 0, [ Explicit_var 0 ])) ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ array_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"array.ml\"\n }\n in\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"t\", _the_group)\n in\n t_sexp_grammar\n;;\n\n[@@@end]\n\n(* This module implements a new in-place, constant heap sorting algorithm to replace the\n one used by the standard libraries. Its only purpose is to be faster (hopefully\n strictly faster) than the base sort and stable_sort.\n\n At a high level the algorithm is:\n - pick two pivot points by:\n - pick 5 arbitrary elements from the array\n - sort them within the array\n - take the elements on either side of the middle element of the sort as the pivots\n - sort the array with:\n - all elements less than pivot1 to the left (range 1)\n - all elements >= pivot1 and <= pivot2 in the middle (range 2)\n - all elements > pivot2 to the right (range 3)\n - if pivot1 and pivot2 are equal, then the middle range is sorted, so ignore it\n - recurse into range 1, 2 (if pivot1 and pivot2 are unequal), and 3\n - during recursion there are two inflection points:\n - if the size of the current range is small, use insertion sort to sort it\n - if the stack depth is large, sort the range with heap-sort to avoid n^2 worst-case\n behavior\n\n See the following for more information:\n - \"Dual-Pivot Quicksort\" by Vladimir Yaroslavskiy.\n Available at\n http://www.kriche.com.ar/root/programming/spaceTimeComplexity/DualPivotQuicksort.pdf\n - \"Quicksort is Optimal\" by Sedgewick and Bentley.\n Slides at http://www.cs.princeton.edu/~rs/talks/QuicksortIsOptimal.pdf\n - http://www.sorting-algorithms.com/quick-sort-3-way *)\n\nmodule Sort = struct\n (* For the sake of speed we could use unsafe get/set throughout, but speed tests don't\n show a significant improvement. *)\n let get = get\n let set = set\n\n let swap arr i j =\n let tmp = get arr i in\n set arr i (get arr j);\n set arr j tmp\n ;;\n\n module type Sort = sig\n val sort\n : 'a t\n -> compare:('a -> 'a -> int)\n -> left:int (* leftmost index of sub-array to sort *)\n -> right:int (* rightmost index of sub-array to sort *)\n -> unit\n end\n\n (* http://en.wikipedia.org/wiki/Insertion_sort *)\n module Insertion_sort : Sort = struct\n let sort arr ~compare ~left ~right =\n (* loop invariant:\n [arr] is sorted from [left] to [pos - 1], inclusive *)\n for pos = left + 1 to right do\n (* loop invariants:\n 1. the subarray arr[left .. i-1] is sorted\n 2. the subarray arr[i+1 .. pos] is sorted and contains only elements > v\n 3. arr[i] may be thought of as containing v\n\n Note that this does not allocate a closure, but is left in the for\n loop for the readability of the documentation. *)\n let rec loop arr ~left ~compare i v =\n let i_next = i - 1 in\n if i_next >= left && compare (get arr i_next) v > 0\n then (\n set arr i (get arr i_next);\n loop arr ~left ~compare i_next v)\n else i\n in\n let v = get arr pos in\n let final_pos = loop arr ~left ~compare pos v in\n set arr final_pos v\n done\n ;;\n end\n\n (* http://en.wikipedia.org/wiki/Heapsort *)\n module Heap_sort : Sort = struct\n (* loop invariant:\n root's children are both either roots of max-heaps or > right *)\n let rec heapify arr ~compare root ~left ~right =\n let relative_root = root - left in\n let left_child = (2 * relative_root) + left + 1 in\n let right_child = (2 * relative_root) + left + 2 in\n let largest =\n if left_child <= right && compare (get arr left_child) (get arr root) > 0\n then left_child\n else root\n in\n let largest =\n if right_child <= right && compare (get arr right_child) (get arr largest) > 0\n then right_child\n else largest\n in\n if largest <> root\n then (\n swap arr root largest;\n heapify arr ~compare largest ~left ~right)\n ;;\n\n let build_heap arr ~compare ~left ~right =\n (* Elements in the second half of the array are already heaps of size 1. We move\n through the first half of the array from back to front examining the element at\n hand, and the left and right children, fixing the heap property as we go. *)\n for i = (left + right) / 2 downto left do\n heapify arr ~compare i ~left ~right\n done\n ;;\n\n let sort arr ~compare ~left ~right =\n build_heap arr ~compare ~left ~right;\n (* loop invariants:\n 1. the subarray arr[left ... i] is a max-heap H\n 2. the subarray arr[i+1 ... right] is sorted (call it S)\n 3. every element of H is less than every element of S *)\n for i = right downto left + 1 do\n swap arr left i;\n heapify arr ~compare left ~left ~right:(i - 1)\n done\n ;;\n end\n\n (* http://en.wikipedia.org/wiki/Introsort *)\n module Intro_sort : sig\n include Sort\n\n val five_element_sort\n : 'a t\n -> compare:('a -> 'a -> int)\n -> int\n -> int\n -> int\n -> int\n -> int\n -> unit\n end = struct\n let five_element_sort arr ~compare m1 m2 m3 m4 m5 =\n let compare_and_swap i j =\n if compare (get arr i) (get arr j) > 0 then swap arr i j\n in\n (* Optimal 5-element sorting network:\n\n {v\n 1--o-----o-----o--------------1\n | | |\n 2--o-----|--o--|-----o--o-----2\n | | | | |\n 3--------o--o--|--o--|--o-----3\n | | |\n 4-----o--------o--o--|-----o--4\n | | |\n 5-----o--------------o-----o--5\n v} *)\n compare_and_swap m1 m2;\n compare_and_swap m4 m5;\n compare_and_swap m1 m3;\n compare_and_swap m2 m3;\n compare_and_swap m1 m4;\n compare_and_swap m3 m4;\n compare_and_swap m2 m5;\n compare_and_swap m2 m3;\n compare_and_swap m4 m5\n ;;\n\n (* choose pivots for the array by sorting 5 elements and examining the center three\n elements. The goal is to choose two pivots that will either:\n - break the range up into 3 even partitions\n or\n - eliminate a commonly appearing element by sorting it into the center partition\n by itself\n To this end we look at the center 3 elements of the 5 and return pairs of equal\n elements or the widest range *)\n let choose_pivots arr ~compare ~left ~right =\n let sixth = (right - left) / 6 in\n let m1 = left + sixth in\n let m2 = m1 + sixth in\n let m3 = m2 + sixth in\n let m4 = m3 + sixth in\n let m5 = m4 + sixth in\n five_element_sort arr ~compare m1 m2 m3 m4 m5;\n let m2_val = get arr m2 in\n let m3_val = get arr m3 in\n let m4_val = get arr m4 in\n if compare m2_val m3_val = 0\n then m2_val, m3_val, true\n else if compare m3_val m4_val = 0\n then m3_val, m4_val, true\n else m2_val, m4_val, false\n ;;\n\n let dual_pivot_partition arr ~compare ~left ~right =\n let pivot1, pivot2, pivots_equal = choose_pivots arr ~compare ~left ~right in\n (* loop invariants:\n 1. left <= l < r <= right\n 2. l <= p <= r\n 3. l <= x < p implies arr[x] >= pivot1\n and arr[x] <= pivot2\n 4. left <= x < l implies arr[x] < pivot1\n 5. r < x <= right implies arr[x] > pivot2 *)\n let rec loop l p r =\n let pv = get arr p in\n if compare pv pivot1 < 0\n then (\n swap arr p l;\n cont (l + 1) (p + 1) r)\n else if compare pv pivot2 > 0\n then (\n (* loop invariants: same as those of the outer loop *)\n let rec scan_backwards r =\n if r > p && compare (get arr r) pivot2 > 0 then scan_backwards (r - 1) else r\n in\n let r = scan_backwards r in\n swap arr r p;\n cont l p (r - 1))\n else cont l (p + 1) r\n and cont l p r = if p > r then l, r else loop l p r in\n let l, r = cont left left right in\n l, r, pivots_equal\n ;;\n\n let rec intro_sort arr ~max_depth ~compare ~left ~right =\n let len = right - left + 1 in\n (* This takes care of some edge cases, such as left > right or very short arrays,\n since Insertion_sort.sort handles these cases properly. Thus we don't need to\n make sure that left and right are valid in recursive calls. *)\n if len <= 32\n then Insertion_sort.sort arr ~compare ~left ~right\n else if max_depth < 0\n then Heap_sort.sort arr ~compare ~left ~right\n else (\n let max_depth = max_depth - 1 in\n let l, r, middle_sorted = dual_pivot_partition arr ~compare ~left ~right in\n intro_sort arr ~max_depth ~compare ~left ~right:(l - 1);\n if not middle_sorted then intro_sort arr ~max_depth ~compare ~left:l ~right:r;\n intro_sort arr ~max_depth ~compare ~left:(r + 1) ~right)\n ;;\n\n let log10_of_3 = Caml.log10 3.\n let log3 x = Caml.log10 x /. log10_of_3\n\n let sort arr ~compare ~left ~right =\n let len = right - left + 1 in\n let heap_sort_switch_depth =\n (* with perfect 3-way partitioning, this is the recursion depth *)\n Int.of_float (log3 (Int.to_float len))\n in\n intro_sort arr ~max_depth:heap_sort_switch_depth ~compare ~left ~right\n ;;\n end\nend\n\nlet sort ?pos ?len arr ~compare =\n let pos, len =\n Ordered_collection_common.get_pos_len_exn () ?pos ?len ~total_length:(length arr)\n in\n Sort.Intro_sort.sort arr ~compare ~left:pos ~right:(pos + len - 1)\n;;\n\nlet to_array t = t\nlet is_empty t = length t = 0\n\nlet is_sorted t ~compare =\n let rec is_sorted_loop t ~compare i =\n if i < 1\n then true\n else compare t.(i - 1) t.(i) <= 0 && is_sorted_loop t ~compare (i - 1)\n in\n is_sorted_loop t ~compare (length t - 1)\n;;\n\nlet is_sorted_strictly t ~compare =\n let rec is_sorted_strictly_loop t ~compare i =\n if i < 1\n then true\n else compare t.(i - 1) t.(i) < 0 && is_sorted_strictly_loop t ~compare (i - 1)\n in\n is_sorted_strictly_loop t ~compare (length t - 1)\n;;\n\nlet folding_map t ~init ~f =\n let acc = ref init in\n map t ~f:(fun x ->\n let new_acc, y = f !acc x in\n acc := new_acc;\n y)\n;;\n\nlet fold_map t ~init ~f =\n let acc = ref init in\n let result =\n map t ~f:(fun x ->\n let new_acc, y = f !acc x in\n acc := new_acc;\n y)\n in\n !acc, result\n;;\n\nlet fold_result t ~init ~f = Container.fold_result ~fold ~init ~f t\nlet fold_until t ~init ~f = Container.fold_until ~fold ~init ~f t\nlet count t ~f = Container.count ~fold t ~f\nlet sum m t ~f = Container.sum ~fold m t ~f\nlet min_elt t ~compare = Container.min_elt ~fold t ~compare\nlet max_elt t ~compare = Container.max_elt ~fold t ~compare\n\nlet foldi t ~init ~f =\n let rec foldi_loop t i ac ~f =\n if i = length t then ac else foldi_loop t (i + 1) (f i ac t.(i)) ~f\n in\n foldi_loop t 0 init ~f\n;;\n\nlet folding_mapi t ~init ~f =\n let acc = ref init in\n mapi t ~f:(fun i x ->\n let new_acc, y = f i !acc x in\n acc := new_acc;\n y)\n;;\n\nlet fold_mapi t ~init ~f =\n let acc = ref init in\n let result =\n mapi t ~f:(fun i x ->\n let new_acc, y = f i !acc x in\n acc := new_acc;\n y)\n in\n !acc, result\n;;\n\nlet counti t ~f =\n foldi t ~init:0 ~f:(fun idx count a -> if f idx a then count + 1 else count)\n;;\n\nlet concat_map t ~f = concat (to_list (map ~f t))\nlet concat_mapi t ~f = concat (to_list (mapi ~f t))\n\nlet rev_inplace t =\n let i = ref 0 in\n let j = ref (length t - 1) in\n while !i < !j do\n swap t !i !j;\n incr i;\n decr j\n done\n;;\n\nlet of_list_rev l =\n match l with\n | [] -> [||]\n | a :: l ->\n let len = 1 + List.length l in\n let t = create ~len a in\n let r = ref l in\n (* We start at [len - 2] because we already put [a] at [t.(len - 1)]. *)\n for i = len - 2 downto 0 do\n match !r with\n | [] -> assert false\n | a :: l ->\n t.(i) <- a;\n r := l\n done;\n t\n;;\n\n(* [of_list_map] and [of_list_rev_map] are based on functions from the OCaml\n distribution. *)\n\nlet of_list_map xs ~f =\n match xs with\n | [] -> [||]\n | hd :: tl ->\n let a = create ~len:(1 + List.length tl) (f hd) in\n let rec fill i = function\n | [] -> a\n | hd :: tl ->\n unsafe_set a i (f hd);\n fill (i + 1) tl\n in\n fill 1 tl\n;;\n\nlet of_list_mapi xs ~f =\n match xs with\n | [] -> [||]\n | hd :: tl ->\n let a = create ~len:(1 + List.length tl) (f 0 hd) in\n let rec fill a i = function\n | [] -> a\n | hd :: tl ->\n unsafe_set a i (f i hd);\n fill a (i + 1) tl\n in\n fill a 1 tl\n;;\n\nlet of_list_rev_map xs ~f =\n let t = of_list_map xs ~f in\n rev_inplace t;\n t\n;;\n\nlet of_list_rev_mapi xs ~f =\n let t = of_list_mapi xs ~f in\n rev_inplace t;\n t\n;;\n\nlet filter_mapi t ~f =\n let r = ref [||] in\n let k = ref 0 in\n for i = 0 to length t - 1 do\n match f i (unsafe_get t i) with\n | None -> ()\n | Some a ->\n if !k = 0 then r := create ~len:(length t) a;\n unsafe_set !r !k a;\n incr k\n done;\n if !k = length t then !r else if !k > 0 then sub ~pos:0 ~len:!k !r else [||]\n;;\n\nlet filter_map t ~f = filter_mapi t ~f:(fun _i a -> f a)\nlet filter_opt t = filter_map t ~f:Fn.id\n\nlet raise_length_mismatch name n1 n2 =\n invalid_argf \"length mismatch in %s: %d <> %d\" name n1 n2 ()\n[@@cold] [@@inline never] [@@local never] [@@specialise never]\n;;\n\nlet check_length2_exn name t1 t2 =\n let n1 = length t1 in\n let n2 = length t2 in\n if n1 <> n2 then raise_length_mismatch name n1 n2\n;;\n\nlet iter2_exn t1 t2 ~f =\n check_length2_exn \"Array.iter2_exn\" t1 t2;\n iteri t1 ~f:(fun i x1 -> f x1 t2.(i))\n;;\n\nlet map2_exn t1 t2 ~f =\n check_length2_exn \"Array.map2_exn\" t1 t2;\n init (length t1) ~f:(fun i -> f t1.(i) t2.(i))\n;;\n\nlet fold2_exn t1 t2 ~init ~f =\n check_length2_exn \"Array.fold2_exn\" t1 t2;\n foldi t1 ~init ~f:(fun i ac x -> f ac x t2.(i))\n;;\n\nlet filter t ~f = filter_map t ~f:(fun x -> if f x then Some x else None)\nlet filteri t ~f = filter_mapi t ~f:(fun i x -> if f i x then Some x else None)\n\nlet exists t ~f =\n let rec exists_loop t ~f i =\n if i < 0 then false else f t.(i) || exists_loop t ~f (i - 1)\n in\n exists_loop t ~f (length t - 1)\n;;\n\nlet existsi t ~f =\n let rec existsi_loop t ~f i =\n if i < 0 then false else f i t.(i) || existsi_loop t ~f (i - 1)\n in\n existsi_loop t ~f (length t - 1)\n;;\n\nlet mem t a ~equal = exists t ~f:(equal a)\n\nlet for_all t ~f =\n let rec for_all_loop t ~f i =\n if i < 0 then true else f t.(i) && for_all_loop t ~f (i - 1)\n in\n for_all_loop t ~f (length t - 1)\n;;\n\nlet for_alli t ~f =\n let rec for_alli_loop t ~f i =\n if i < 0 then true else f i t.(i) && for_alli_loop t ~f (i - 1)\n in\n for_alli_loop t ~f (length t - 1)\n;;\n\nlet exists2_exn t1 t2 ~f =\n let rec exists2_exn_loop t1 t2 ~f i =\n if i < 0 then false else f t1.(i) t2.(i) || exists2_exn_loop t1 t2 ~f (i - 1)\n in\n check_length2_exn \"Array.exists2_exn\" t1 t2;\n exists2_exn_loop t1 t2 ~f (length t1 - 1)\n;;\n\nlet for_all2_exn t1 t2 ~f =\n let rec for_all2_loop t1 t2 ~f i =\n if i < 0 then true else f t1.(i) t2.(i) && for_all2_loop t1 t2 ~f (i - 1)\n in\n check_length2_exn \"Array.for_all2_exn\" t1 t2;\n for_all2_loop t1 t2 ~f (length t1 - 1)\n;;\n\nlet equal equal t1 t2 = length t1 = length t2 && for_all2_exn t1 t2 ~f:equal\n\n\nlet map_inplace t ~f =\n for i = 0 to length t - 1 do\n t.(i) <- f t.(i)\n done\n;;\n\nlet findi t ~f =\n let rec findi_loop t ~f ~length i =\n if i >= length\n then None\n else if f i t.(i)\n then Some (i, t.(i))\n else findi_loop t ~f ~length (i + 1)\n in\n let length = length t in\n findi_loop t ~f ~length 0\n;;\n\nlet findi_exn =\n let not_found = Not_found_s (Atom \"Array.findi_exn: not found\") in\n let findi_exn t ~f =\n match findi t ~f with\n | None -> raise not_found\n | Some x -> x\n in\n (* named to preserve symbol in compiled binary *)\n findi_exn\n;;\n\nlet find_exn =\n let not_found = Not_found_s (Atom \"Array.find_exn: not found\") in\n let find_exn t ~f =\n match findi t ~f:(fun _i x -> f x) with\n | None -> raise not_found\n | Some (_i, x) -> x\n in\n (* named to preserve symbol in compiled binary *)\n find_exn\n;;\n\nlet find t ~f = Option.map (findi t ~f:(fun _i x -> f x)) ~f:(fun (_i, x) -> x)\n\nlet find_map t ~f =\n let rec find_map_loop t ~f ~length i =\n if i >= length\n then None\n else (\n match f t.(i) with\n | None -> find_map_loop t ~f ~length (i + 1)\n | Some _ as res -> res)\n in\n let length = length t in\n find_map_loop t ~f ~length 0\n;;\n\nlet find_map_exn =\n let not_found = Not_found_s (Atom \"Array.find_map_exn: not found\") in\n let find_map_exn t ~f =\n match find_map t ~f with\n | None -> raise not_found\n | Some x -> x\n in\n (* named to preserve symbol in compiled binary *)\n find_map_exn\n;;\n\nlet find_mapi t ~f =\n let rec find_mapi_loop t ~f ~length i =\n if i >= length\n then None\n else (\n match f i t.(i) with\n | None -> find_mapi_loop t ~f ~length (i + 1)\n | Some _ as res -> res)\n in\n let length = length t in\n find_mapi_loop t ~f ~length 0\n;;\n\nlet find_mapi_exn =\n let not_found = Not_found_s (Atom \"Array.find_mapi_exn: not found\") in\n let find_mapi_exn t ~f =\n match find_mapi t ~f with\n | None -> raise not_found\n | Some x -> x\n in\n (* named to preserve symbol in compiled binary *)\n find_mapi_exn\n;;\n\nlet find_consecutive_duplicate t ~equal =\n let n = length t in\n if n <= 1\n then None\n else (\n let result = ref None in\n let i = ref 1 in\n let prev = ref t.(0) in\n while !i < n do\n let cur = t.(!i) in\n if equal cur !prev\n then (\n result := Some (!prev, cur);\n i := n)\n else (\n prev := cur;\n incr i)\n done;\n !result)\n;;\n\nlet reduce t ~f =\n if length t = 0\n then None\n else (\n let r = ref t.(0) in\n for i = 1 to length t - 1 do\n r := f !r t.(i)\n done;\n Some !r)\n;;\n\nlet reduce_exn t ~f =\n match reduce t ~f with\n | None -> invalid_arg \"Array.reduce_exn\"\n | Some v -> v\n;;\n\nlet permute = Array_permute.permute\n\nlet random_element_exn ?(random_state = Random.State.default) t =\n if is_empty t\n then failwith \"Array.random_element_exn: empty array\"\n else t.(Random.State.int random_state (length t))\n;;\n\nlet random_element ?(random_state = Random.State.default) t =\n try Some (random_element_exn ~random_state t) with\n | _ -> None\n;;\n\nlet zip t1 t2 =\n if length t1 <> length t2 then None else Some (map2_exn t1 t2 ~f:(fun x1 x2 -> x1, x2))\n;;\n\nlet zip_exn t1 t2 =\n if length t1 <> length t2\n then failwith \"Array.zip_exn\"\n else map2_exn t1 t2 ~f:(fun x1 x2 -> x1, x2)\n;;\n\nlet unzip t =\n let n = length t in\n if n = 0\n then [||], [||]\n else (\n let x, y = t.(0) in\n let res1 = create ~len:n x in\n let res2 = create ~len:n y in\n for i = 1 to n - 1 do\n let x, y = t.(i) in\n res1.(i) <- x;\n res2.(i) <- y\n done;\n res1, res2)\n;;\n\nlet sorted_copy t ~compare =\n let t1 = copy t in\n sort t1 ~compare;\n t1\n;;\n\nlet partitioni_tf t ~f =\n let both = mapi t ~f:(fun i x -> if f i x then Either.First x else Either.Second x) in\n let trues =\n filter_map both ~f:(function\n | First x -> Some x\n | Second _ -> None)\n in\n let falses =\n filter_map both ~f:(function\n | First _ -> None\n | Second x -> Some x)\n in\n trues, falses\n;;\n\nlet partition_tf t ~f = partitioni_tf t ~f:(fun _i x -> f x)\nlet last t = t.(length t - 1)\n\n(* Convert to a sequence but does not attempt to protect against modification\n in the array. *)\nlet to_sequence_mutable t =\n Sequence.unfold_step ~init:0 ~f:(fun i ->\n if i >= length t then Sequence.Step.Done else Sequence.Step.Yield (t.(i), i + 1))\n;;\n\nlet to_sequence t = to_sequence_mutable (copy t)\n\nlet cartesian_product t1 t2 =\n if is_empty t1 || is_empty t2\n then [||]\n else (\n let n1 = length t1 in\n let n2 = length t2 in\n let t = create ~len:(n1 * n2) (t1.(0), t2.(0)) in\n let r = ref 0 in\n for i1 = 0 to n1 - 1 do\n for i2 = 0 to n2 - 1 do\n t.(!r) <- (t1.(i1), t2.(i2));\n incr r\n done\n done;\n t)\n;;\n\nlet transpose tt =\n if length tt = 0\n then Some [||]\n else (\n let width = length tt in\n let depth = length tt.(0) in\n if exists tt ~f:(fun t -> length t <> depth)\n then None\n else Some (init depth ~f:(fun d -> init width ~f:(fun w -> tt.(w).(d)))))\n;;\n\nlet transpose_exn tt =\n match transpose tt with\n | None -> invalid_arg \"Array.transpose_exn\"\n | Some tt' -> tt'\n;;\n\ninclude Binary_searchable.Make1 (struct\n type nonrec 'a t = 'a t\n\n let get = get\n let length = length\n end)\n\ninclude Blit.Make1 (struct\n type nonrec 'a t = 'a t\n\n let length = length\n\n let create_like ~len t =\n if len = 0\n then [||]\n else (\n assert (length t > 0);\n create ~len t.(0))\n ;;\n\n let unsafe_blit = blit\n end)\n\nlet invariant invariant_a t = iter t ~f:invariant_a\n\nmodule Private = struct\n module Sort = Sort\nend\n","open! Import\nmodule Int = Int0\nmodule String = String0\nmodule Array = Array0\n\n(* We maintain the property that all values of type [t] do not have the tag\n [double_array_tag]. Some functions below assume this in order to avoid testing the\n tag, and will segfault if this property doesn't hold. *)\ntype t = Caml.Obj.t array\n\nlet invariant t = assert (Caml.Obj.tag (Caml.Obj.repr t) <> Caml.Obj.double_array_tag)\nlet length = Array.length\nlet swap t i j = Array.swap t i j\n\nlet sexp_of_t t =\n Sexp.Atom\n (String.concat ~sep:\"\" [ \"\" ])\n;;\n\nlet zero_obj = Caml.Obj.repr (0 : int)\n\n(* We call [Array.create] with a value that is not a float so that the array doesn't get\n tagged with [Double_array_tag]. *)\nlet create_zero ~len = Array.create ~len zero_obj\n\nlet create ~len x =\n (* If we can, use [Array.create] directly. *)\n if Caml.Obj.tag x <> Caml.Obj.double_tag\n then Array.create ~len x\n else (\n (* Otherwise use [create_zero] and set the contents *)\n let t = create_zero ~len in\n let x = Sys.opaque_identity x in\n for i = 0 to len - 1 do\n Array.unsafe_set t i x\n done;\n t)\n;;\n\nlet empty = [||]\n\ntype not_a_float =\n | Not_a_float_0\n | Not_a_float_1 of int\n\nlet _not_a_float_0 = Not_a_float_0\nlet _not_a_float_1 = Not_a_float_1 42\n\nlet get t i =\n (* Make the compiler believe [t] is an array not containing floats so it does not check\n if [t] is tagged with [Double_array_tag]. It is NOT ok to use [int array] since (if\n this function is inlined and the array contains in-heap boxed values) wrong register\n typing may result, leading to a failure to register necessary GC roots. *)\n Caml.Obj.repr ((Caml.Obj.magic (t : t) : not_a_float array).(i) : not_a_float)\n;;\n\nlet[@inline always] unsafe_get t i =\n (* Make the compiler believe [t] is an array not containing floats so it does not check\n if [t] is tagged with [Double_array_tag]. *)\n Caml.Obj.repr\n (Array.unsafe_get (Caml.Obj.magic (t : t) : not_a_float array) i : not_a_float)\n;;\n\nlet[@inline always] unsafe_set_with_caml_modify t i obj =\n (* Same comment as [unsafe_get]. Sys.opaque_identity prevents the compiler from\n potentially wrongly guessing the type of the array based on the type of element, that\n is prevent the implication: (Obj.tag obj = Obj.double_tag) => (Obj.tag t =\n Obj.double_array_tag) which flambda has tried in the past (at least that's assuming\n the compiler respects Sys.opaque_identity, which is not always the case). *)\n Array.unsafe_set\n (Caml.Obj.magic (t : t) : not_a_float array)\n i\n (Caml.Obj.obj (Sys.opaque_identity obj) : not_a_float)\n;;\n\nlet[@inline always] unsafe_set_int_assuming_currently_int t i int =\n (* This skips [caml_modify], which is OK if both the old and new values are integers. *)\n Array.unsafe_set (Caml.Obj.magic (t : t) : int array) i (Sys.opaque_identity int)\n;;\n\n(* For [set] and [unsafe_set], if a pointer is involved, we first do a physical-equality\n test to see if the pointer is changing. If not, we don't need to do the [set], which\n saves a call to [caml_modify]. We think this physical-equality test is worth it\n because it is very cheap (both values are already available from the [is_int] test)\n and because [caml_modify] is expensive. *)\n\nlet set t i obj =\n (* We use [get] first but then we use [Array.unsafe_set] since we know that [i] is\n valid. *)\n let old_obj = get t i in\n if Caml.Obj.is_int old_obj && Caml.Obj.is_int obj\n then unsafe_set_int_assuming_currently_int t i (Caml.Obj.obj obj : int)\n else if not (phys_equal old_obj obj)\n then unsafe_set_with_caml_modify t i obj\n;;\n\nlet[@inline always] unsafe_set t i obj =\n let old_obj = unsafe_get t i in\n if Caml.Obj.is_int old_obj && Caml.Obj.is_int obj\n then unsafe_set_int_assuming_currently_int t i (Caml.Obj.obj obj : int)\n else if not (phys_equal old_obj obj)\n then unsafe_set_with_caml_modify t i obj\n;;\n\nlet[@inline always] unsafe_set_omit_phys_equal_check t i obj =\n let old_obj = unsafe_get t i in\n if Caml.Obj.is_int old_obj && Caml.Obj.is_int obj\n then unsafe_set_int_assuming_currently_int t i (Caml.Obj.obj obj : int)\n else unsafe_set_with_caml_modify t i obj\n;;\n\nlet singleton obj = create ~len:1 obj\n\n(* Pre-condition: t.(i) is an integer. *)\nlet unsafe_set_assuming_currently_int t i obj =\n if Caml.Obj.is_int obj\n then unsafe_set_int_assuming_currently_int t i (Caml.Obj.obj obj : int)\n else\n (* [t.(i)] is an integer and [obj] is not, so we do not need to check if they are\n equal. *)\n unsafe_set_with_caml_modify t i obj\n;;\n\nlet unsafe_set_int t i int =\n let old_obj = unsafe_get t i in\n if Caml.Obj.is_int old_obj\n then unsafe_set_int_assuming_currently_int t i int\n else unsafe_set_with_caml_modify t i (Caml.Obj.repr int)\n;;\n\nlet unsafe_clear_if_pointer t i =\n let old_obj = unsafe_get t i in\n if not (Caml.Obj.is_int old_obj) then unsafe_set_with_caml_modify t i (Caml.Obj.repr 0)\n;;\n\n(** [unsafe_blit] is like [Array.blit], except it uses our own for-loop to avoid\n caml_modify when possible. Its performance is still not comparable to a memcpy. *)\nlet unsafe_blit ~src ~src_pos ~dst ~dst_pos ~len =\n (* When [phys_equal src dst], we need to check whether [dst_pos < src_pos] and have the\n for loop go in the right direction so that we don't overwrite data that we still need\n to read. When [not (phys_equal src dst)], doing this is harmless. From a\n memory-performance perspective, it doesn't matter whether one loops up or down.\n Constant-stride access, forward or backward, should be indistinguishable (at least on\n an intel i7). So, we don't do a check for [phys_equal src dst] and always loop up in\n that case. *)\n if dst_pos < src_pos\n then\n for i = 0 to len - 1 do\n unsafe_set dst (dst_pos + i) (unsafe_get src (src_pos + i))\n done\n else\n for i = len - 1 downto 0 do\n unsafe_set dst (dst_pos + i) (unsafe_get src (src_pos + i))\n done\n;;\n\ninclude Blit.Make (struct\n type nonrec t = t\n\n let create = create_zero\n let length = length\n let unsafe_blit = unsafe_blit\n end)\n\nlet copy src =\n let dst = create_zero ~len:(length src) in\n blito ~src ~dst ();\n dst\n;;\n","open! Import\n\n(* WARNING:\n We use non-memory-safe things throughout the [Trusted] module.\n Most of it is only safe in combination with the type signature (e.g. exposing\n [val copy : 'a t -> 'b t] would be a big mistake). *)\nmodule Trusted : sig\n type 'a t\n\n val empty : 'a t\n val unsafe_create_uninitialized : len:int -> 'a t\n val create_obj_array : len:int -> 'a t\n val create : len:int -> 'a -> 'a t\n val singleton : 'a -> 'a t\n val get : 'a t -> int -> 'a\n val set : 'a t -> int -> 'a -> unit\n val swap : _ t -> int -> int -> unit\n val unsafe_get : 'a t -> int -> 'a\n val unsafe_set : 'a t -> int -> 'a -> unit\n val unsafe_set_omit_phys_equal_check : 'a t -> int -> 'a -> unit\n val unsafe_set_int : 'a t -> int -> int -> unit\n val unsafe_set_int_assuming_currently_int : 'a t -> int -> int -> unit\n val unsafe_set_assuming_currently_int : 'a t -> int -> 'a -> unit\n val length : 'a t -> int\n val unsafe_blit : ('a t, 'a t) Blit.blit\n val copy : 'a t -> 'a t\n val unsafe_clear_if_pointer : _ t -> int -> unit\nend = struct\n type 'a t = Obj_array.t\n\n let empty = Obj_array.empty\n let unsafe_create_uninitialized ~len = Obj_array.create_zero ~len\n let create_obj_array ~len = Obj_array.create_zero ~len\n let create ~len x = Obj_array.create ~len (Caml.Obj.repr x)\n let singleton x = Obj_array.singleton (Caml.Obj.repr x)\n let swap t i j = Obj_array.swap t i j\n let get arr i = Caml.Obj.obj (Obj_array.get arr i)\n let set arr i x = Obj_array.set arr i (Caml.Obj.repr x)\n let unsafe_get arr i = Caml.Obj.obj (Obj_array.unsafe_get arr i)\n let unsafe_set arr i x = Obj_array.unsafe_set arr i (Caml.Obj.repr x)\n let unsafe_set_int arr i x = Obj_array.unsafe_set_int arr i x\n\n let unsafe_set_int_assuming_currently_int arr i x =\n Obj_array.unsafe_set_int_assuming_currently_int arr i x\n ;;\n\n let unsafe_set_assuming_currently_int arr i x =\n Obj_array.unsafe_set_assuming_currently_int arr i (Caml.Obj.repr x)\n ;;\n\n let length = Obj_array.length\n let unsafe_blit = Obj_array.unsafe_blit\n let copy = Obj_array.copy\n\n let unsafe_set_omit_phys_equal_check t i x =\n Obj_array.unsafe_set_omit_phys_equal_check t i (Caml.Obj.repr x)\n ;;\n\n let unsafe_clear_if_pointer = Obj_array.unsafe_clear_if_pointer\nend\n\ninclude Trusted\n\nlet invariant t = assert (Caml.Obj.tag (Caml.Obj.repr t) <> Caml.Obj.double_array_tag)\n\nlet init l ~f =\n if l < 0\n then invalid_arg \"Uniform_array.init\"\n else (\n let res = unsafe_create_uninitialized ~len:l in\n for i = 0 to l - 1 do\n unsafe_set res i (f i)\n done;\n res)\n;;\n\nlet of_array arr = init ~f:(Array.unsafe_get arr) (Array.length arr)\nlet map a ~f = init ~f:(fun i -> f (unsafe_get a i)) (length a)\n\nlet iter a ~f =\n for i = 0 to length a - 1 do\n f (unsafe_get a i)\n done\n;;\n\nlet iteri a ~f =\n for i = 0 to length a - 1 do\n f i (unsafe_get a i)\n done\n;;\n\nlet to_list t = List.init ~f:(get t) (length t)\n\nlet of_list l =\n let len = List.length l in\n let res = unsafe_create_uninitialized ~len in\n List.iteri l ~f:(fun i x -> set res i x);\n res\n;;\n\n(* It is not safe for [to_array] to be the identity function because we have code that\n relies on [float array]s being unboxed, for example in [bin_write_array]. *)\nlet to_array t = Array.init (length t) ~f:(fun i -> unsafe_get t i)\n\nlet exists t ~f =\n let rec loop t ~f i =\n if i < 0 then false else f (unsafe_get t i) || loop t ~f (i - 1)\n in\n loop t ~f (length t - 1)\n;;\n\nlet map2_exn t1 t2 ~f =\n let len = length t1 in\n if length t2 <> len then invalid_arg \"Array.map2_exn\";\n init len ~f:(fun i -> f (unsafe_get t1 i) (unsafe_get t2 i))\n;;\n\ninclude Sexpable.Of_sexpable1\n (Array)\n (struct\n type nonrec 'a t = 'a t\n\n let to_sexpable = to_array\n let of_sexpable = of_array\n end)\n\ninclude Blit.Make1 (struct\n type nonrec 'a t = 'a t\n\n let length = length\n\n let create_like ~len t =\n if len = 0\n then empty\n else (\n assert (length t > 0);\n create ~len (get t 0))\n ;;\n\n let unsafe_blit = unsafe_blit\n end)\n\nlet fold t ~init ~f =\n let r = ref init in\n for i = 0 to length t - 1 do\n r := f !r (unsafe_get t i)\n done;\n !r\n;;\n\nlet min_elt t ~compare = Container.min_elt ~fold t ~compare\nlet max_elt t ~compare = Container.max_elt ~fold t ~compare\n","open! Import\nmodule Array = Array0\nmodule String = String0\ninclude Char0\n\nmodule T = struct\n type t = char [@@deriving_inline compare, hash, sexp, sexp_grammar]\n\n let compare = (compare_char : t -> t -> int)\n\n let (hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state) =\n hash_fold_char\n\n and (hash : t -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func = hash_char in\n fun x -> func x\n ;;\n\n let t_of_sexp = (char_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t)\n let sexp_of_t = (sexp_of_char : t -> Ppx_sexp_conv_lib.Sexp.t)\n\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group) =\n { implicit_vars = [ \"char\" ]\n ; ggid = \"\\146e\\023\\249\\235eE\\139c\\132W\\195\\137\\129\\235\\025\"\n ; types = [ \"t\", Implicit_var 0 ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ char_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"char.ml.T\"\n }\n in\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"t\", _the_group)\n in\n t_sexp_grammar\n ;;\n\n [@@@end]\n\n let to_string t = String.make 1 t\n\n let of_string s =\n match String.length s with\n | 1 -> s.[0]\n | _ -> failwithf \"Char.of_string: %S\" s ()\n ;;\nend\n\ninclude T\n\ninclude Identifiable.Make (struct\n include T\n\n let module_name = \"Base.Char\"\n end)\n\n(* Open replace_polymorphic_compare after including functor instantiations so they do not\n shadow its definitions. This is here so that efficient versions of the comparison\n functions are available within this module. *)\nopen! Char_replace_polymorphic_compare\n\nlet invariant (_ : t) = ()\nlet all = Array.init 256 ~f:unsafe_of_int |> Array.to_list\n\nlet is_lowercase = function\n | 'a' .. 'z' -> true\n | _ -> false\n;;\n\nlet is_uppercase = function\n | 'A' .. 'Z' -> true\n | _ -> false\n;;\n\nlet is_print = function\n | ' ' .. '~' -> true\n | _ -> false\n;;\n\nlet is_whitespace = function\n | '\\t' | '\\n' | '\\011' (* vertical tab *) | '\\012' (* form feed *) | '\\r' | ' ' -> true\n | _ -> false\n;;\n\nlet is_digit = function\n | '0' .. '9' -> true\n | _ -> false\n;;\n\nlet is_alpha = function\n | 'a' .. 'z' | 'A' .. 'Z' -> true\n | _ -> false\n;;\n\n(* Writing these out, instead of calling [is_alpha] and [is_digit], reduces\n runtime by approx. 30% *)\nlet is_alphanum = function\n | 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' -> true\n | _ -> false\n;;\n\nlet get_digit_unsafe t = to_int t - to_int '0'\n\nlet get_digit_exn t =\n if is_digit t\n then get_digit_unsafe t\n else failwithf \"Char.get_digit_exn %C: not a digit\" t ()\n;;\n\nlet get_digit t = if is_digit t then Some (get_digit_unsafe t) else None\n\nmodule O = struct\n let ( >= ) = ( >= )\n let ( <= ) = ( <= )\n let ( = ) = ( = )\n let ( > ) = ( > )\n let ( < ) = ( < )\n let ( <> ) = ( <> )\nend\n\nmodule Caseless = struct\n module T = struct\n type t = char [@@deriving_inline sexp]\n\n let t_of_sexp = (char_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t)\n let sexp_of_t = (sexp_of_char : t -> Ppx_sexp_conv_lib.Sexp.t)\n\n [@@@end]\n\n let compare c1 c2 = compare (lowercase c1) (lowercase c2)\n let hash_fold_t state t = hash_fold_char state (lowercase t)\n let hash t = Hash.run hash_fold_t t\n end\n\n include T\n include Comparable.Make (T)\nend\n\n(* Include type-specific [Replace_polymorphic_compare] at the end, after\n including functor application that could shadow its definitions. This is\n here so that efficient versions of the comparison functions are exported by\n this module. *)\ninclude Char_replace_polymorphic_compare\n","open! Import\nmodule Array = Array0\nmodule Bytes = Bytes0\ninclude String0\n\nlet invalid_argf = Printf.invalid_argf\nlet raise_s = Error.raise_s\nlet stage = Staged.stage\n\nmodule T = struct\n type t = string [@@deriving_inline hash, sexp, sexp_grammar]\n\n let (hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state) =\n hash_fold_string\n\n and (hash : t -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func = hash_string in\n fun x -> func x\n ;;\n\n let t_of_sexp = (string_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t)\n let sexp_of_t = (sexp_of_string : t -> Ppx_sexp_conv_lib.Sexp.t)\n\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group) =\n { implicit_vars = [ \"string\" ]\n ; ggid = \"\\146e\\023\\249\\235eE\\139c\\132W\\195\\137\\129\\235\\025\"\n ; types = [ \"t\", Implicit_var 0 ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ string_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"string.ml.T\"\n }\n in\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"t\", _the_group)\n in\n t_sexp_grammar\n ;;\n\n [@@@end]\n\n let compare = compare\nend\n\ninclude T\ninclude Comparator.Make (T)\n\ntype elt = char\n\nlet invariant (_ : t) = ()\n\n(* This is copied/adapted from 'blit.ml'.\n [sub], [subo] could be implemented using [Blit.Make(Bytes)] plus unsafe casts to/from\n string but were inlined here to avoid using [Bytes.unsafe_of_string] as much as possible.\n*)\nlet sub src ~pos ~len =\n if pos = 0 && len = String.length src\n then src\n else (\n Ordered_collection_common.check_pos_len_exn ~pos ~len ~total_length:(length src);\n let dst = Bytes.create len in\n if len > 0 then Bytes.unsafe_blit_string ~src ~src_pos:pos ~dst ~dst_pos:0 ~len;\n Bytes.unsafe_to_string ~no_mutation_while_string_reachable:dst)\n;;\n\nlet subo ?(pos = 0) ?len src =\n sub\n src\n ~pos\n ~len:\n (match len with\n | Some i -> i\n | None -> length src - pos)\n;;\n\nlet rec contains_unsafe t ~pos ~end_ char =\n pos < end_\n && (Char.equal (unsafe_get t pos) char || contains_unsafe t ~pos:(pos + 1) ~end_ char)\n;;\n\nlet contains ?(pos = 0) ?len t char =\n let total_length = String.length t in\n let len = Option.value len ~default:(total_length - pos) in\n Ordered_collection_common.check_pos_len_exn ~pos ~len ~total_length;\n contains_unsafe t ~pos ~end_:(pos + len) char\n;;\n\nlet is_empty t = length t = 0\n\nlet rec index_from_exn_internal string ~pos ~len ~not_found char =\n if pos >= len\n then raise not_found\n else if Char.equal (unsafe_get string pos) char\n then pos\n else index_from_exn_internal string ~pos:(pos + 1) ~len ~not_found char\n;;\n\nlet index_exn_internal t ~not_found char =\n index_from_exn_internal t ~pos:0 ~len:(length t) ~not_found char\n;;\n\nlet index_exn =\n let not_found = Not_found_s (Atom \"String.index_exn: not found\") in\n let index_exn t char = index_exn_internal t ~not_found char in\n (* named to preserve symbol in compiled binary *)\n index_exn\n;;\n\nlet index_from_exn =\n let not_found = Not_found_s (Atom \"String.index_from_exn: not found\") in\n let index_from_exn t pos char =\n let len = length t in\n if pos < 0 || pos > len\n then invalid_arg \"String.index_from_exn\"\n else index_from_exn_internal t ~pos ~len ~not_found char\n in\n (* named to preserve symbol in compiled binary *)\n index_from_exn\n;;\n\nlet rec rindex_from_exn_internal string ~pos ~len ~not_found char =\n if pos < 0\n then raise not_found\n else if Char.equal (unsafe_get string pos) char\n then pos\n else rindex_from_exn_internal string ~pos:(pos - 1) ~len ~not_found char\n;;\n\nlet rindex_exn_internal t ~not_found char =\n let len = length t in\n rindex_from_exn_internal t ~pos:(len - 1) ~len ~not_found char\n;;\n\nlet rindex_exn =\n let not_found = Not_found_s (Atom \"String.rindex_exn: not found\") in\n let rindex_exn t char = rindex_exn_internal t ~not_found char in\n (* named to preserve symbol in compiled binary *)\n rindex_exn\n;;\n\nlet rindex_from_exn =\n let not_found = Not_found_s (Atom \"String.rindex_from_exn: not found\") in\n let rindex_from_exn t pos char =\n let len = length t in\n if pos < -1 || pos >= len\n then invalid_arg \"String.rindex_from_exn\"\n else rindex_from_exn_internal t ~pos ~len ~not_found char\n in\n (* named to preserve symbol in compiled binary *)\n rindex_from_exn\n;;\n\nlet index t char =\n try Some (index_exn t char) with\n | Not_found_s _ | Caml.Not_found -> None\n;;\n\nlet rindex t char =\n try Some (rindex_exn t char) with\n | Not_found_s _ | Caml.Not_found -> None\n;;\n\nlet index_from t pos char =\n try Some (index_from_exn t pos char) with\n | Not_found_s _ | Caml.Not_found -> None\n;;\n\nlet rindex_from t pos char =\n try Some (rindex_from_exn t pos char) with\n | Not_found_s _ | Caml.Not_found -> None\n;;\n\nmodule Search_pattern0 = struct\n type t =\n { pattern : string\n ; case_sensitive : bool\n ; kmp_array : int array\n }\n\n let sexp_of_t { pattern; case_sensitive; kmp_array = _ } : Sexp.t =\n List\n [ List [ Atom \"pattern\"; sexp_of_string pattern ]\n ; List [ Atom \"case_sensitive\"; sexp_of_bool case_sensitive ]\n ]\n ;;\n\n let pattern t = t.pattern\n let case_sensitive t = t.case_sensitive\n\n (* Find max number of matched characters at [next_text_char], given the current\n [matched_chars]. Try to extend the current match, if chars don't match, try to match\n fewer chars. If chars match then extend the match. *)\n let kmp_internal_loop ~matched_chars ~next_text_char ~pattern ~kmp_array ~char_equal =\n let matched_chars = ref matched_chars in\n while\n !matched_chars > 0\n && not (char_equal next_text_char (unsafe_get pattern !matched_chars))\n do\n matched_chars := Array.unsafe_get kmp_array (!matched_chars - 1)\n done;\n if char_equal next_text_char (unsafe_get pattern !matched_chars)\n then matched_chars := !matched_chars + 1;\n !matched_chars\n ;;\n\n let get_char_equal ~case_sensitive =\n match case_sensitive with\n | true -> Char.equal\n | false -> Char.Caseless.equal\n ;;\n\n (* Classic KMP pre-processing of the pattern: build the int array, which, for each i,\n contains the length of the longest non-trivial prefix of s which is equal to a suffix\n ending at s.[i] *)\n let create pattern ~case_sensitive =\n let n = length pattern in\n let kmp_array = Array.create ~len:n (-1) in\n if n > 0\n then (\n let char_equal = get_char_equal ~case_sensitive in\n Array.unsafe_set kmp_array 0 0;\n let matched_chars = ref 0 in\n for i = 1 to n - 1 do\n matched_chars\n := kmp_internal_loop\n ~matched_chars:!matched_chars\n ~next_text_char:(unsafe_get pattern i)\n ~pattern\n ~kmp_array\n ~char_equal;\n Array.unsafe_set kmp_array i !matched_chars\n done);\n { pattern; case_sensitive; kmp_array }\n ;;\n\n (* Classic KMP: use the pre-processed pattern to optimize look-behinds on non-matches.\n We return int to avoid allocation in [index_exn]. -1 means no match. *)\n let index_internal ?(pos = 0) { pattern; case_sensitive; kmp_array } ~in_:text =\n if pos < 0 || pos > length text - length pattern\n then -1\n else (\n let char_equal = get_char_equal ~case_sensitive in\n let j = ref pos in\n let matched_chars = ref 0 in\n let k = length pattern in\n let n = length text in\n while !j < n && !matched_chars < k do\n let next_text_char = unsafe_get text !j in\n matched_chars\n := kmp_internal_loop\n ~matched_chars:!matched_chars\n ~next_text_char\n ~pattern\n ~kmp_array\n ~char_equal;\n j := !j + 1\n done;\n if !matched_chars = k then !j - k else -1)\n ;;\n\n let matches t str = index_internal t ~in_:str >= 0\n\n let index ?pos t ~in_ =\n let p = index_internal ?pos t ~in_ in\n if p < 0 then None else Some p\n ;;\n\n let index_exn ?pos t ~in_ =\n let p = index_internal ?pos t ~in_ in\n if p >= 0\n then p\n else\n raise_s\n (Sexp.message \"Substring not found\" [ \"substring\", sexp_of_string t.pattern ])\n ;;\n\n let index_all { pattern; case_sensitive; kmp_array } ~may_overlap ~in_:text =\n if length pattern = 0\n then List.init (1 + length text) ~f:Fn.id\n else (\n let char_equal = get_char_equal ~case_sensitive in\n let matched_chars = ref 0 in\n let k = length pattern in\n let n = length text in\n let found = ref [] in\n for j = 0 to n do\n if !matched_chars = k\n then (\n found := (j - k) :: !found;\n (* we just found a match in the previous iteration *)\n match may_overlap with\n | true -> matched_chars := Array.unsafe_get kmp_array (k - 1)\n | false -> matched_chars := 0);\n if j < n\n then (\n let next_text_char = unsafe_get text j in\n matched_chars\n := kmp_internal_loop\n ~matched_chars:!matched_chars\n ~next_text_char\n ~pattern\n ~kmp_array\n ~char_equal)\n done;\n List.rev !found)\n ;;\n\n let replace_first ?pos t ~in_:s ~with_ =\n match index ?pos t ~in_:s with\n | None -> s\n | Some i ->\n let len_s = length s in\n let len_t = length t.pattern in\n let len_with = length with_ in\n let dst = Bytes.create (len_s + len_with - len_t) in\n Bytes.blit_string ~src:s ~src_pos:0 ~dst ~dst_pos:0 ~len:i;\n Bytes.blit_string ~src:with_ ~src_pos:0 ~dst ~dst_pos:i ~len:len_with;\n Bytes.blit_string\n ~src:s\n ~src_pos:(i + len_t)\n ~dst\n ~dst_pos:(i + len_with)\n ~len:(len_s - i - len_t);\n Bytes.unsafe_to_string ~no_mutation_while_string_reachable:dst\n ;;\n\n\n let replace_all t ~in_:s ~with_ =\n let matches = index_all t ~may_overlap:false ~in_:s in\n match matches with\n | [] -> s\n | _ :: _ ->\n let len_s = length s in\n let len_t = length t.pattern in\n let len_with = length with_ in\n let num_matches = List.length matches in\n let dst = Bytes.create (len_s + ((len_with - len_t) * num_matches)) in\n let next_dst_pos = ref 0 in\n let next_src_pos = ref 0 in\n List.iter matches ~f:(fun i ->\n let len = i - !next_src_pos in\n Bytes.blit_string\n ~src:s\n ~src_pos:!next_src_pos\n ~dst\n ~dst_pos:!next_dst_pos\n ~len;\n Bytes.blit_string\n ~src:with_\n ~src_pos:0\n ~dst\n ~dst_pos:(!next_dst_pos + len)\n ~len:len_with;\n next_dst_pos := !next_dst_pos + len + len_with;\n next_src_pos := !next_src_pos + len + len_t);\n Bytes.blit_string\n ~src:s\n ~src_pos:!next_src_pos\n ~dst\n ~dst_pos:!next_dst_pos\n ~len:(len_s - !next_src_pos);\n Bytes.unsafe_to_string ~no_mutation_while_string_reachable:dst\n ;;\n\n module Private = struct\n type public = t\n\n type nonrec t = t =\n { pattern : string\n ; case_sensitive : bool\n ; kmp_array : int array\n }\n [@@deriving_inline equal, sexp_of]\n\n let equal =\n (fun a__001_ b__002_ ->\n if Ppx_compare_lib.phys_equal a__001_ b__002_\n then true\n else\n Ppx_compare_lib.( && )\n (equal_string a__001_.pattern b__002_.pattern)\n (Ppx_compare_lib.( && )\n (equal_bool a__001_.case_sensitive b__002_.case_sensitive)\n (equal_array equal_int a__001_.kmp_array b__002_.kmp_array))\n : t -> t -> bool)\n ;;\n\n let sexp_of_t =\n (function\n | { pattern = v_pattern\n ; case_sensitive = v_case_sensitive\n ; kmp_array = v_kmp_array\n } ->\n let bnds = [] in\n let bnds =\n let arg = sexp_of_array sexp_of_int v_kmp_array in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"kmp_array\"; arg ]\n :: bnds\n in\n let bnds =\n let arg = sexp_of_bool v_case_sensitive in\n Ppx_sexp_conv_lib.Sexp.List\n [ Ppx_sexp_conv_lib.Sexp.Atom \"case_sensitive\"; arg ]\n :: bnds\n in\n let bnds =\n let arg = sexp_of_string v_pattern in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"pattern\"; arg ]\n :: bnds\n in\n Ppx_sexp_conv_lib.Sexp.List bnds\n : t -> Ppx_sexp_conv_lib.Sexp.t)\n ;;\n\n [@@@end]\n\n let representation = Fn.id\n end\nend\n\nmodule Search_pattern_helper = struct\n module Search_pattern = Search_pattern0\nend\n\nopen Search_pattern_helper\n\nlet substr_index_gen ~case_sensitive ?pos t ~pattern =\n Search_pattern.index ?pos (Search_pattern.create ~case_sensitive pattern) ~in_:t\n;;\n\nlet substr_index_exn_gen ~case_sensitive ?pos t ~pattern =\n Search_pattern.index_exn ?pos (Search_pattern.create ~case_sensitive pattern) ~in_:t\n;;\n\nlet substr_index_all_gen ~case_sensitive t ~may_overlap ~pattern =\n Search_pattern.index_all\n (Search_pattern.create ~case_sensitive pattern)\n ~may_overlap\n ~in_:t\n;;\n\nlet substr_replace_first_gen ~case_sensitive ?pos t ~pattern =\n Search_pattern.replace_first\n ?pos\n (Search_pattern.create ~case_sensitive pattern)\n ~in_:t\n;;\n\nlet substr_replace_all_gen ~case_sensitive t ~pattern =\n Search_pattern.replace_all (Search_pattern.create ~case_sensitive pattern) ~in_:t\n;;\n\nlet is_substring_gen ~case_sensitive t ~substring =\n Option.is_some (substr_index_gen t ~pattern:substring ~case_sensitive)\n;;\n\nlet substr_index = substr_index_gen ~case_sensitive:true\nlet substr_index_exn = substr_index_exn_gen ~case_sensitive:true\nlet substr_index_all = substr_index_all_gen ~case_sensitive:true\nlet substr_replace_first = substr_replace_first_gen ~case_sensitive:true\nlet substr_replace_all = substr_replace_all_gen ~case_sensitive:true\nlet is_substring = is_substring_gen ~case_sensitive:true\n\nlet is_substring_at_gen =\n let rec loop ~str ~str_pos ~sub ~sub_pos ~sub_len ~char_equal =\n if sub_pos = sub_len\n then true\n else if char_equal (unsafe_get str str_pos) (unsafe_get sub sub_pos)\n then\n loop ~str ~str_pos:(str_pos + 1) ~sub ~sub_pos:(sub_pos + 1) ~sub_len ~char_equal\n else false\n in\n fun str ~pos:str_pos ~substring:sub ~char_equal ->\n let str_len = length str in\n let sub_len = length sub in\n if str_pos < 0 || str_pos > str_len\n then\n invalid_argf\n \"String.is_substring_at: invalid index %d for string of length %d\"\n str_pos\n str_len\n ();\n str_pos + sub_len <= str_len\n && loop ~str ~str_pos ~sub ~sub_pos:0 ~sub_len ~char_equal\n;;\n\nlet is_suffix_gen string ~suffix ~char_equal =\n let string_len = length string in\n let suffix_len = length suffix in\n string_len >= suffix_len\n && is_substring_at_gen\n string\n ~pos:(string_len - suffix_len)\n ~substring:suffix\n ~char_equal\n;;\n\nlet is_prefix_gen string ~prefix ~char_equal =\n let string_len = length string in\n let prefix_len = length prefix in\n string_len >= prefix_len\n && is_substring_at_gen string ~pos:0 ~substring:prefix ~char_equal\n;;\n\nmodule Caseless = struct\n module T = struct\n type t = string [@@deriving_inline sexp]\n\n let t_of_sexp = (string_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t)\n let sexp_of_t = (sexp_of_string : t -> Ppx_sexp_conv_lib.Sexp.t)\n\n [@@@end]\n\n let char_compare_caseless c1 c2 =\n Char.compare (Char.lowercase c1) (Char.lowercase c2)\n ;;\n\n let rec compare_loop ~pos ~string1 ~len1 ~string2 ~len2 =\n if pos = len1\n then if pos = len2 then 0 else -1\n else if pos = len2\n then 1\n else (\n let c =\n char_compare_caseless (unsafe_get string1 pos) (unsafe_get string2 pos)\n in\n match c with\n | 0 -> compare_loop ~pos:(pos + 1) ~string1 ~len1 ~string2 ~len2\n | _ -> c)\n ;;\n\n let compare string1 string2 =\n if phys_equal string1 string2\n then 0\n else\n compare_loop\n ~pos:0\n ~string1\n ~len1:(String.length string1)\n ~string2\n ~len2:(String.length string2)\n ;;\n\n let hash_fold_t state t =\n let len = length t in\n let state = ref (hash_fold_int state len) in\n for pos = 0 to len - 1 do\n state := hash_fold_char !state (Char.lowercase (unsafe_get t pos))\n done;\n !state\n ;;\n\n let hash t = Hash.run hash_fold_t t\n let is_suffix s ~suffix = is_suffix_gen s ~suffix ~char_equal:Char.Caseless.equal\n let is_prefix s ~prefix = is_prefix_gen s ~prefix ~char_equal:Char.Caseless.equal\n let substr_index = substr_index_gen ~case_sensitive:false\n let substr_index_exn = substr_index_exn_gen ~case_sensitive:false\n let substr_index_all = substr_index_all_gen ~case_sensitive:false\n let substr_replace_first = substr_replace_first_gen ~case_sensitive:false\n let substr_replace_all = substr_replace_all_gen ~case_sensitive:false\n let is_substring = is_substring_gen ~case_sensitive:false\n let is_substring_at = is_substring_at_gen ~char_equal:Char.Caseless.equal\n end\n\n include T\n include Comparable.Make (T)\nend\n\nlet of_string = Fn.id\nlet to_string = Fn.id\n\nlet init n ~f =\n if n < 0 then invalid_argf \"String.init %d\" n ();\n let t = Bytes.create n in\n for i = 0 to n - 1 do\n Bytes.set t i (f i)\n done;\n Bytes.unsafe_to_string ~no_mutation_while_string_reachable:t\n;;\n\nlet to_list s =\n let rec loop acc i = if i < 0 then acc else loop (s.[i] :: acc) (i - 1) in\n loop [] (length s - 1)\n;;\n\nlet to_list_rev s =\n let len = length s in\n let rec loop acc i = if i = len then acc else loop (s.[i] :: acc) (i + 1) in\n loop [] 0\n;;\n\nlet rev t =\n let len = length t in\n let res = Bytes.create len in\n for i = 0 to len - 1 do\n unsafe_set res i (unsafe_get t (len - 1 - i))\n done;\n Bytes.unsafe_to_string ~no_mutation_while_string_reachable:res\n;;\n\n(** Efficient string splitting *)\n\nlet lsplit2_exn =\n let not_found = Not_found_s (Atom \"String.lsplit2_exn: not found\") in\n let lsplit2_exn line ~on:delim =\n let pos = index_exn_internal line ~not_found delim in\n sub line ~pos:0 ~len:pos, sub line ~pos:(pos + 1) ~len:(length line - pos - 1)\n in\n (* named to preserve symbol in compiled binary *)\n lsplit2_exn\n;;\n\nlet rsplit2_exn =\n let not_found = Not_found_s (Atom \"String.rsplit2_exn: not found\") in\n let rsplit2_exn line ~on:delim =\n let pos = rindex_exn_internal line ~not_found delim in\n sub line ~pos:0 ~len:pos, sub line ~pos:(pos + 1) ~len:(length line - pos - 1)\n in\n (* named to preserve symbol in compiled binary *)\n rsplit2_exn\n;;\n\nlet lsplit2 line ~on =\n try Some (lsplit2_exn line ~on) with\n | Not_found_s _ | Caml.Not_found -> None\n;;\n\nlet rsplit2 line ~on =\n try Some (rsplit2_exn line ~on) with\n | Not_found_s _ | Caml.Not_found -> None\n;;\n\nlet rec char_list_mem l (c : char) =\n match l with\n | [] -> false\n | hd :: tl -> Char.equal hd c || char_list_mem tl c\n;;\n\nlet split_gen str ~on =\n let is_delim =\n match on with\n | `char c' -> fun c -> Char.equal c c'\n | `char_list l -> fun c -> char_list_mem l c\n in\n let len = length str in\n let rec loop acc last_pos pos =\n if pos = -1\n then sub str ~pos:0 ~len:last_pos :: acc\n else if is_delim str.[pos]\n then (\n let pos1 = pos + 1 in\n let sub_str = sub str ~pos:pos1 ~len:(last_pos - pos1) in\n loop (sub_str :: acc) pos (pos - 1))\n else loop acc last_pos (pos - 1)\n in\n loop [] len (len - 1)\n;;\n\nlet split str ~on = split_gen str ~on:(`char on)\nlet split_on_chars str ~on:chars = split_gen str ~on:(`char_list chars)\n\nlet split_lines =\n let back_up_at_newline ~t ~pos ~eol =\n pos := !pos - if !pos > 0 && Char.equal t.[!pos - 1] '\\r' then 2 else 1;\n eol := !pos + 1\n in\n fun t ->\n let n = length t in\n if n = 0\n then []\n else (\n (* Invariant: [-1 <= pos < eol]. *)\n let pos = ref (n - 1) in\n let eol = ref n in\n let ac = ref [] in\n (* We treat the end of the string specially, because if the string ends with a\n newline, we don't want an extra empty string at the end of the output. *)\n if Char.equal t.[!pos] '\\n' then back_up_at_newline ~t ~pos ~eol;\n while !pos >= 0 do\n if Char.( <> ) t.[!pos] '\\n'\n then decr pos\n else (\n (* Because [pos < eol], we know that [start <= eol]. *)\n let start = !pos + 1 in\n ac := sub t ~pos:start ~len:(!eol - start) :: !ac;\n back_up_at_newline ~t ~pos ~eol)\n done;\n sub t ~pos:0 ~len:!eol :: !ac)\n;;\n\nlet is_suffix s ~suffix = is_suffix_gen s ~suffix ~char_equal:Char.equal\nlet is_prefix s ~prefix = is_prefix_gen s ~prefix ~char_equal:Char.equal\n\nlet is_substring_at s ~pos ~substring =\n is_substring_at_gen s ~pos ~substring ~char_equal:Char.equal\n;;\n\nlet wrap_sub_n t n ~name ~pos ~len ~on_error =\n if n < 0\n then invalid_arg (name ^ \" expecting nonnegative argument\")\n else (\n try sub t ~pos ~len with\n | _ -> on_error)\n;;\n\nlet drop_prefix t n =\n wrap_sub_n ~name:\"drop_prefix\" t n ~pos:n ~len:(length t - n) ~on_error:\"\"\n;;\n\nlet drop_suffix t n =\n wrap_sub_n ~name:\"drop_suffix\" t n ~pos:0 ~len:(length t - n) ~on_error:\"\"\n;;\n\nlet prefix t n = wrap_sub_n ~name:\"prefix\" t n ~pos:0 ~len:n ~on_error:t\nlet suffix t n = wrap_sub_n ~name:\"suffix\" t n ~pos:(length t - n) ~len:n ~on_error:t\n\nlet lfindi ?(pos = 0) t ~f =\n let n = length t in\n let rec loop i = if i = n then None else if f i t.[i] then Some i else loop (i + 1) in\n loop pos\n;;\n\nlet find t ~f =\n match lfindi t ~f:(fun _ c -> f c) with\n | None -> None\n | Some i -> Some t.[i]\n;;\n\nlet find_map t ~f =\n let n = length t in\n let rec loop i =\n if i = n\n then None\n else (\n match f t.[i] with\n | None -> loop (i + 1)\n | Some _ as res -> res)\n in\n loop 0\n;;\n\nlet rfindi ?pos t ~f =\n let rec loop i = if i < 0 then None else if f i t.[i] then Some i else loop (i - 1) in\n let pos =\n match pos with\n | Some pos -> pos\n | None -> length t - 1\n in\n loop pos\n;;\n\nlet last_non_drop ~drop t = rfindi t ~f:(fun _ c -> not (drop c))\n\nlet rstrip ?(drop = Char.is_whitespace) t =\n match last_non_drop t ~drop with\n | None -> \"\"\n | Some i -> if i = length t - 1 then t else prefix t (i + 1)\n;;\n\nlet first_non_drop ~drop t = lfindi t ~f:(fun _ c -> not (drop c))\n\nlet lstrip ?(drop = Char.is_whitespace) t =\n match first_non_drop t ~drop with\n | None -> \"\"\n | Some 0 -> t\n | Some n -> drop_prefix t n\n;;\n\n(* [strip t] could be implemented as [lstrip (rstrip t)]. The implementation\n below saves (at least) a factor of two allocation, by only allocating the\n final result. This also saves some amount of time. *)\nlet strip ?(drop = Char.is_whitespace) t =\n let length = length t in\n if length = 0 || not (drop t.[0] || drop t.[length - 1])\n then t\n else (\n match first_non_drop t ~drop with\n | None -> \"\"\n | Some first ->\n (match last_non_drop t ~drop with\n | None -> assert false\n | Some last -> sub t ~pos:first ~len:(last - first + 1)))\n;;\n\nlet mapi t ~f =\n let l = length t in\n let t' = Bytes.create l in\n for i = 0 to l - 1 do\n Bytes.unsafe_set t' i (f i t.[i])\n done;\n Bytes.unsafe_to_string ~no_mutation_while_string_reachable:t'\n;;\n\n(* repeated code to avoid requiring an extra allocation for a closure on each call. *)\nlet map t ~f =\n let l = length t in\n let t' = Bytes.create l in\n for i = 0 to l - 1 do\n Bytes.unsafe_set t' i (f t.[i])\n done;\n Bytes.unsafe_to_string ~no_mutation_while_string_reachable:t'\n;;\n\nlet to_array s = Array.init (length s) ~f:(fun i -> s.[i])\n\nlet exists =\n let rec loop s i ~len ~f = i < len && (f s.[i] || loop s (i + 1) ~len ~f) in\n fun s ~f -> loop s 0 ~len:(length s) ~f\n;;\n\nlet for_all =\n let rec loop s i ~len ~f = i = len || (f s.[i] && loop s (i + 1) ~len ~f) in\n fun s ~f -> loop s 0 ~len:(length s) ~f\n;;\n\nlet fold t ~init ~f =\n let n = length t in\n let rec loop i ac = if i = n then ac else loop (i + 1) (f ac t.[i]) in\n loop 0 init\n;;\n\nlet foldi t ~init ~f =\n let n = length t in\n let rec loop i ac = if i = n then ac else loop (i + 1) (f i ac t.[i]) in\n loop 0 init\n;;\n\nlet count t ~f = Container.count ~fold t ~f\nlet sum m t ~f = Container.sum ~fold m t ~f\nlet min_elt t = Container.min_elt ~fold t\nlet max_elt t = Container.max_elt ~fold t\nlet fold_result t ~init ~f = Container.fold_result ~fold ~init ~f t\nlet fold_until t ~init ~f = Container.fold_until ~fold ~init ~f t\n\nlet mem =\n let rec loop t c ~pos:i ~len =\n i < len && (Char.equal c (unsafe_get t i) || loop t c ~pos:(i + 1) ~len)\n in\n fun t c -> loop t c ~pos:0 ~len:(length t)\n;;\n\nlet tr ~target ~replacement s =\n if Char.equal target replacement\n then s\n else if mem s target\n then map s ~f:(fun c -> if Char.equal c target then replacement else c)\n else s\n;;\n\nlet tr_multi ~target ~replacement =\n if is_empty target\n then stage Fn.id\n else if is_empty replacement\n then invalid_arg \"tr_multi replacement is empty string\"\n else (\n match Bytes_tr.tr_create_map ~target ~replacement with\n | None -> stage Fn.id\n | Some tr_map ->\n stage (fun s ->\n if exists s ~f:(fun c -> Char.( <> ) c (unsafe_get tr_map (Char.to_int c)))\n then map s ~f:(fun c -> unsafe_get tr_map (Char.to_int c))\n else s))\n;;\n\n(* fast version, if we ever need it:\n {[\n let concat_array ~sep ar =\n let ar_len = Array.length ar in\n if ar_len = 0 then \"\"\n else\n let sep_len = length sep in\n let res_len_ref = ref (sep_len * (ar_len - 1)) in\n for i = 0 to ar_len - 1 do\n res_len_ref := !res_len_ref + length ar.(i)\n done;\n let res = create !res_len_ref in\n let str_0 = ar.(0) in\n let len_0 = length str_0 in\n blit ~src:str_0 ~src_pos:0 ~dst:res ~dst_pos:0 ~len:len_0;\n let pos_ref = ref len_0 in\n for i = 1 to ar_len - 1 do\n let pos = !pos_ref in\n blit ~src:sep ~src_pos:0 ~dst:res ~dst_pos:pos ~len:sep_len;\n let new_pos = pos + sep_len in\n let str_i = ar.(i) in\n let len_i = length str_i in\n blit ~src:str_i ~src_pos:0 ~dst:res ~dst_pos:new_pos ~len:len_i;\n pos_ref := new_pos + len_i\n done;\n res\n ]} *)\n\nlet concat_array ?sep ar = concat ?sep (Array.to_list ar)\nlet concat_map ?sep s ~f = concat_array ?sep (Array.map (to_array s) ~f)\n\n(* [filter t f] is implemented by the following algorithm.\n\n Let [n = length t].\n\n 1. Find the lowest [i] such that [not (f t.[i])].\n\n 2. If there is no such [i], then return [t].\n\n 3. If there is such an [i], allocate a string, [out], to hold the result. [out] has\n length [n - 1], which is the maximum possible output size given that there is at least\n one character not satisfying [f].\n\n 4. Copy characters at indices 0 ... [i - 1] from [t] to [out].\n\n 5. Walk through characters at indices [i+1] ... [n-1] of [t], copying those that\n satisfy [f] from [t] to [out].\n\n 6. If we completely filled [out], then return it. If not, return the prefix of [out]\n that we did fill in.\n\n This algorithm has the property that it doesn't allocate a new string if there's\n nothing to filter, which is a common case. *)\nlet filter t ~f =\n let n = length t in\n let i = ref 0 in\n while !i < n && f t.[!i] do\n incr i\n done;\n if !i = n\n then t\n else (\n let out = Bytes.create (n - 1) in\n Bytes.blit_string ~src:t ~src_pos:0 ~dst:out ~dst_pos:0 ~len:!i;\n let out_pos = ref !i in\n incr i;\n while !i < n do\n let c = t.[!i] in\n if f c\n then (\n Bytes.set out !out_pos c;\n incr out_pos);\n incr i\n done;\n let out = Bytes.unsafe_to_string ~no_mutation_while_string_reachable:out in\n if !out_pos = n - 1 then out else sub out ~pos:0 ~len:!out_pos)\n;;\n\nlet chop_prefix s ~prefix =\n if is_prefix s ~prefix then Some (drop_prefix s (length prefix)) else None\n;;\n\nlet chop_prefix_if_exists s ~prefix =\n if is_prefix s ~prefix then drop_prefix s (length prefix) else s\n;;\n\nlet chop_prefix_exn s ~prefix =\n match chop_prefix s ~prefix with\n | Some str -> str\n | None -> invalid_argf \"String.chop_prefix_exn %S %S\" s prefix ()\n;;\n\nlet chop_suffix s ~suffix =\n if is_suffix s ~suffix then Some (drop_suffix s (length suffix)) else None\n;;\n\nlet chop_suffix_if_exists s ~suffix =\n if is_suffix s ~suffix then drop_suffix s (length suffix) else s\n;;\n\nlet chop_suffix_exn s ~suffix =\n match chop_suffix s ~suffix with\n | Some str -> str\n | None -> invalid_argf \"String.chop_suffix_exn %S %S\" s suffix ()\n;;\n\n(* There used to be a custom implementation that was faster for very short strings\n (peaking at 40% faster for 4-6 char long strings).\n This new function is around 20% faster than the default hash function, but slower\n than the previous custom implementation. However, the new OCaml function is well\n behaved, and this implementation is less likely to diverge from the default OCaml\n implementation does, which is a desirable property. (The only way to avoid the\n divergence is to expose the macro redefined in hash_stubs.c in the hash.h header of\n the OCaml compiler.) *)\nmodule Hash = struct\n external hash : string -> int = \"Base_hash_string\" [@@noalloc]\nend\n\n(* [include Hash] to make the [external] version override the [hash] from\n [Hashable.Make_binable], so that we get a little bit of a speedup by exposing it as\n external in the mli. *)\nlet _ = hash\n\ninclude Hash\ninclude Comparable.Validate (T)\n\n(* for interactive top-levels -- modules deriving from String should have String's pretty\n printer. *)\nlet pp = Caml.Format.pp_print_string\nlet of_char c = make 1 c\n\nlet of_char_list l =\n let t = Bytes.create (List.length l) in\n List.iteri l ~f:(fun i c -> Bytes.set t i c);\n Bytes.unsafe_to_string ~no_mutation_while_string_reachable:t\n;;\n\nmodule Escaping = struct\n (* If this is changed, make sure to update [escape], which attempts to ensure all the\n invariants checked here. *)\n let build_and_validate_escapeworthy_map escapeworthy_map escape_char func =\n let escapeworthy_map =\n if List.Assoc.mem escapeworthy_map ~equal:Char.equal escape_char\n then escapeworthy_map\n else (escape_char, escape_char) :: escapeworthy_map\n in\n let arr = Array.create ~len:256 (-1) in\n let vals = Array.create ~len:256 false in\n let rec loop = function\n | [] -> Ok arr\n | (c_from, c_to) :: l ->\n let k, v =\n match func with\n | `Escape -> Char.to_int c_from, c_to\n | `Unescape -> Char.to_int c_to, c_from\n in\n if arr.(k) <> -1 || vals.(Char.to_int v)\n then\n Or_error.error_s\n (Sexp.message\n \"escapeworthy_map not one-to-one\"\n [ \"c_from\", sexp_of_char c_from\n ; \"c_to\", sexp_of_char c_to\n ; ( \"escapeworthy_map\"\n , sexp_of_list (sexp_of_pair sexp_of_char sexp_of_char) escapeworthy_map\n )\n ])\n else (\n arr.(k) <- Char.to_int v;\n vals.(Char.to_int v) <- true;\n loop l)\n in\n loop escapeworthy_map\n ;;\n\n let escape_gen ~escapeworthy_map ~escape_char =\n match build_and_validate_escapeworthy_map escapeworthy_map escape_char `Escape with\n | Error _ as x -> x\n | Ok escapeworthy ->\n Ok\n (fun src ->\n (* calculate a list of (index of char to escape * escaped char) first, the order\n is from tail to head *)\n let to_escape_len = ref 0 in\n let to_escape =\n foldi src ~init:[] ~f:(fun i acc c ->\n match escapeworthy.(Char.to_int c) with\n | -1 -> acc\n | n ->\n (* (index of char to escape * escaped char) *)\n incr to_escape_len;\n (i, Char.unsafe_of_int n) :: acc)\n in\n match to_escape with\n | [] -> src\n | _ ->\n (* [to_escape] divide [src] to [List.length to_escape + 1] pieces separated by\n the chars to escape.\n\n Lets take\n {[\n escape_gen_exn\n ~escapeworthy_map:[('a', 'A'); ('b', 'B'); ('c', 'C')]\n ~escape_char:'_'\n ]}\n for example, and assume the string to escape is\n\n \"000a111b222c333\"\n\n then [to_escape] is [(11, 'C'); (7, 'B'); (3, 'A')].\n\n Then we create a [dst] of length [length src + 3] to store the\n result, copy piece \"333\" to [dst] directly, then copy '_' and 'C' to [dst];\n then move on to next; after 3 iterations, copy piece \"000\" and we are done.\n\n Finally the result will be\n\n \"000_A111_B222_C333\" *)\n let src_len = length src in\n let dst_len = src_len + !to_escape_len in\n let dst = Bytes.create dst_len in\n let rec loop last_idx last_dst_pos = function\n | [] ->\n (* copy \"000\" at last *)\n Bytes.blit_string ~src ~src_pos:0 ~dst ~dst_pos:0 ~len:last_idx\n | (idx, escaped_char) :: to_escape ->\n (*[idx] = the char to escape*)\n (* take first iteration for example *)\n (* calculate length of \"333\", minus 1 because we don't copy 'c' *)\n let len = last_idx - idx - 1 in\n (* set the dst_pos to copy to *)\n let dst_pos = last_dst_pos - len in\n (* copy \"333\", set [src_pos] to [idx + 1] to skip 'c' *)\n Bytes.blit_string ~src ~src_pos:(idx + 1) ~dst ~dst_pos ~len;\n (* backoff [dst_pos] by 2 to copy '_' and 'C' *)\n let dst_pos = dst_pos - 2 in\n Bytes.set dst dst_pos escape_char;\n Bytes.set dst (dst_pos + 1) escaped_char;\n loop idx dst_pos to_escape\n in\n (* set [last_dst_pos] and [last_idx] to length of [dst] and [src] first *)\n loop src_len dst_len to_escape;\n Bytes.unsafe_to_string ~no_mutation_while_string_reachable:dst)\n ;;\n\n let escape_gen_exn ~escapeworthy_map ~escape_char =\n Or_error.ok_exn (escape_gen ~escapeworthy_map ~escape_char) |> stage\n ;;\n\n let escape ~escapeworthy ~escape_char =\n (* For [escape_gen_exn], we don't know how to fix invalid escapeworthy_map so we have\n to raise exception; but in this case, we know how to fix duplicated elements in\n escapeworthy list, so we just fix it instead of raising exception to make this\n function easier to use. *)\n let escapeworthy_map =\n escapeworthy\n |> List.dedup_and_sort ~compare:Char.compare\n |> List.map ~f:(fun c -> c, c)\n in\n escape_gen_exn ~escapeworthy_map ~escape_char\n ;;\n\n (* In an escaped string, any char is either `Escaping, `Escaped or `Literal. For\n example, the escape statuses of chars in string \"a_a__\" with escape_char = '_' are\n\n a : `Literal\n _ : `Escaping\n a : `Escaped\n _ : `Escaping\n _ : `Escaped\n\n [update_escape_status str ~escape_char i previous_status] gets escape status of\n str.[i] basing on escape status of str.[i - 1] *)\n let update_escape_status str ~escape_char i = function\n | `Escaping -> `Escaped\n | `Literal | `Escaped ->\n if Char.equal str.[i] escape_char then `Escaping else `Literal\n ;;\n\n let unescape_gen ~escapeworthy_map ~escape_char =\n match build_and_validate_escapeworthy_map escapeworthy_map escape_char `Unescape with\n | Error _ as x -> x\n | Ok escapeworthy ->\n Ok\n (fun src ->\n (* Continue the example in [escape_gen_exn], now we unescape\n\n \"000_A111_B222_C333\"\n\n back to\n\n \"000a111b222c333\"\n\n Then [to_unescape] is [14; 9; 4], which is indexes of '_'s.\n\n Then we create a string [dst] to store the result, copy \"333\" to it, then copy\n 'c', then move on to next iteration. After 3 iterations copy \"000\" and we are\n done. *)\n (* indexes of escape chars *)\n let to_unescape =\n let rec loop i status acc =\n if i >= length src\n then acc\n else (\n let status = update_escape_status src ~escape_char i status in\n loop\n (i + 1)\n status\n (match status with\n | `Escaping -> i :: acc\n | `Escaped | `Literal -> acc))\n in\n loop 0 `Literal []\n in\n match to_unescape with\n | [] -> src\n | idx :: to_unescape' ->\n let dst = Bytes.create (length src - List.length to_unescape) in\n let rec loop last_idx last_dst_pos = function\n | [] ->\n (* copy \"000\" at last *)\n Bytes.blit_string ~src ~src_pos:0 ~dst ~dst_pos:0 ~len:last_idx\n | idx :: to_unescape ->\n (* [idx] = index of escaping char *)\n (* take 1st iteration as example, calculate the length of \"333\", minus 2 to\n skip '_C' *)\n let len = last_idx - idx - 2 in\n (* point [dst_pos] to the position to copy \"333\" to *)\n let dst_pos = last_dst_pos - len in\n (* copy \"333\" *)\n Bytes.blit_string ~src ~src_pos:(idx + 2) ~dst ~dst_pos ~len;\n (* backoff [dst_pos] by 1 to copy 'c' *)\n let dst_pos = dst_pos - 1 in\n Bytes.set\n dst\n dst_pos\n (match escapeworthy.(Char.to_int src.[idx + 1]) with\n | -1 -> src.[idx + 1]\n | n -> Char.unsafe_of_int n);\n (* update [last_dst_pos] and [last_idx] *)\n loop idx dst_pos to_unescape\n in\n if idx < length src - 1\n then\n (* set [last_dst_pos] and [last_idx] to length of [dst] and [src] *)\n loop (length src) (Bytes.length dst) to_unescape\n else\n (* for escaped string ending with an escaping char like \"000_\", just ignore\n the last escaping char *)\n loop (length src - 1) (Bytes.length dst) to_unescape';\n Bytes.unsafe_to_string ~no_mutation_while_string_reachable:dst)\n ;;\n\n let unescape_gen_exn ~escapeworthy_map ~escape_char =\n Or_error.ok_exn (unescape_gen ~escapeworthy_map ~escape_char) |> stage\n ;;\n\n let unescape ~escape_char = unescape_gen_exn ~escapeworthy_map:[] ~escape_char\n\n let preceding_escape_chars str ~escape_char pos =\n let rec loop p cnt =\n if p < 0 || Char.( <> ) str.[p] escape_char then cnt else loop (p - 1) (cnt + 1)\n in\n loop (pos - 1) 0\n ;;\n\n (* In an escaped string, any char is either `Escaping, `Escaped or `Literal. For\n example, the escape statuses of chars in string \"a_a__\" with escape_char = '_' are\n\n a : `Literal\n _ : `Escaping\n a : `Escaped\n _ : `Escaping\n _ : `Escaped\n\n [update_escape_status str ~escape_char i previous_status] gets escape status of\n str.[i] basing on escape status of str.[i - 1] *)\n let update_escape_status str ~escape_char i = function\n | `Escaping -> `Escaped\n | `Literal | `Escaped ->\n if Char.equal str.[i] escape_char then `Escaping else `Literal\n ;;\n\n let escape_status str ~escape_char pos =\n let odd = preceding_escape_chars str ~escape_char pos mod 2 = 1 in\n match odd, Char.equal str.[pos] escape_char with\n | true, (true | false) -> `Escaped\n | false, true -> `Escaping\n | false, false -> `Literal\n ;;\n\n let check_bound str pos function_name =\n if pos >= length str || pos < 0\n then invalid_argf \"%s: out of bounds\" function_name ()\n ;;\n\n let is_char_escaping str ~escape_char pos =\n check_bound str pos \"is_char_escaping\";\n match escape_status str ~escape_char pos with\n | `Escaping -> true\n | `Escaped | `Literal -> false\n ;;\n\n let is_char_escaped str ~escape_char pos =\n check_bound str pos \"is_char_escaped\";\n match escape_status str ~escape_char pos with\n | `Escaped -> true\n | `Escaping | `Literal -> false\n ;;\n\n let is_char_literal str ~escape_char pos =\n check_bound str pos \"is_char_literal\";\n match escape_status str ~escape_char pos with\n | `Literal -> true\n | `Escaped | `Escaping -> false\n ;;\n\n let index_from str ~escape_char pos char =\n check_bound str pos \"index_from\";\n let rec loop i status =\n if i >= pos\n && (match status with\n | `Literal -> true\n | `Escaped | `Escaping -> false)\n && Char.equal str.[i] char\n then Some i\n else (\n let i = i + 1 in\n if i >= length str\n then None\n else loop i (update_escape_status str ~escape_char i status))\n in\n loop pos (escape_status str ~escape_char pos)\n ;;\n\n let index_from_exn str ~escape_char pos char =\n match index_from str ~escape_char pos char with\n | None ->\n raise_s\n (Sexp.message\n \"index_from_exn: not found\"\n [ \"str\", sexp_of_t str\n ; \"escape_char\", sexp_of_char escape_char\n ; \"pos\", sexp_of_int pos\n ; \"char\", sexp_of_char char\n ])\n | Some pos -> pos\n ;;\n\n let index str ~escape_char char = index_from str ~escape_char 0 char\n let index_exn str ~escape_char char = index_from_exn str ~escape_char 0 char\n\n let rindex_from str ~escape_char pos char =\n check_bound str pos \"rindex_from\";\n (* if the target char is the same as [escape_char], we have no way to determine which\n escape_char is literal, so just return None *)\n if Char.equal char escape_char\n then None\n else (\n let rec loop pos =\n if pos < 0\n then None\n else (\n let escape_chars = preceding_escape_chars str ~escape_char pos in\n if escape_chars mod 2 = 0 && Char.equal str.[pos] char\n then Some pos\n else loop (pos - escape_chars - 1))\n in\n loop pos)\n ;;\n\n let rindex_from_exn str ~escape_char pos char =\n match rindex_from str ~escape_char pos char with\n | None ->\n raise_s\n (Sexp.message\n \"rindex_from_exn: not found\"\n [ \"str\", sexp_of_t str\n ; \"escape_char\", sexp_of_char escape_char\n ; \"pos\", sexp_of_int pos\n ; \"char\", sexp_of_char char\n ])\n | Some pos -> pos\n ;;\n\n let rindex str ~escape_char char =\n if is_empty str then None else rindex_from str ~escape_char (length str - 1) char\n ;;\n\n let rindex_exn str ~escape_char char =\n rindex_from_exn str ~escape_char (length str - 1) char\n ;;\n\n (* [split_gen str ~escape_char ~on] works similarly to [String.split_gen], with an\n additional requirement: only split on literal chars, not escaping or escaped *)\n let split_gen str ~escape_char ~on =\n let is_delim =\n match on with\n | `char c' -> fun c -> Char.equal c c'\n | `char_list l -> fun c -> char_list_mem l c\n in\n let len = length str in\n let rec loop acc status last_pos pos =\n if pos = len\n then List.rev (sub str ~pos:last_pos ~len:(len - last_pos) :: acc)\n else (\n let status = update_escape_status str ~escape_char pos status in\n if (match status with\n | `Literal -> true\n | `Escaped | `Escaping -> false)\n && is_delim str.[pos]\n then (\n let sub_str = sub str ~pos:last_pos ~len:(pos - last_pos) in\n loop (sub_str :: acc) status (pos + 1) (pos + 1))\n else loop acc status last_pos (pos + 1))\n in\n loop [] `Literal 0 0\n ;;\n\n let split str ~on = split_gen str ~on:(`char on)\n let split_on_chars str ~on:chars = split_gen str ~on:(`char_list chars)\n\n let split_at str pos =\n sub str ~pos:0 ~len:pos, sub str ~pos:(pos + 1) ~len:(length str - pos - 1)\n ;;\n\n let lsplit2 str ~on ~escape_char =\n Option.map (index str ~escape_char on) ~f:(fun x -> split_at str x)\n ;;\n\n let rsplit2 str ~on ~escape_char =\n Option.map (rindex str ~escape_char on) ~f:(fun x -> split_at str x)\n ;;\n\n let lsplit2_exn str ~on ~escape_char = split_at str (index_exn str ~escape_char on)\n let rsplit2_exn str ~on ~escape_char = split_at str (rindex_exn str ~escape_char on)\n\n (* [last_non_drop_literal] and [first_non_drop_literal] are either both [None] or both\n [Some]. If [Some], then the former is >= the latter. *)\n let last_non_drop_literal ~drop ~escape_char t =\n rfindi t ~f:(fun i c ->\n (not (drop c))\n || is_char_escaping t ~escape_char i\n || is_char_escaped t ~escape_char i)\n ;;\n\n let first_non_drop_literal ~drop ~escape_char t =\n lfindi t ~f:(fun i c ->\n (not (drop c))\n || is_char_escaping t ~escape_char i\n || is_char_escaped t ~escape_char i)\n ;;\n\n let rstrip_literal ?(drop = Char.is_whitespace) t ~escape_char =\n match last_non_drop_literal t ~drop ~escape_char with\n | None -> \"\"\n | Some i -> if i = length t - 1 then t else prefix t (i + 1)\n ;;\n\n let lstrip_literal ?(drop = Char.is_whitespace) t ~escape_char =\n match first_non_drop_literal t ~drop ~escape_char with\n | None -> \"\"\n | Some 0 -> t\n | Some n -> drop_prefix t n\n ;;\n\n (* [strip t] could be implemented as [lstrip (rstrip t)]. The implementation\n below saves (at least) a factor of two allocation, by only allocating the\n final result. This also saves some amount of time. *)\n let strip_literal ?(drop = Char.is_whitespace) t ~escape_char =\n let length = length t in\n (* performance hack: avoid copying [t] in common cases *)\n if length = 0 || not (drop t.[0] || drop t.[length - 1])\n then t\n else (\n match first_non_drop_literal t ~drop ~escape_char with\n | None -> \"\"\n | Some first ->\n (match last_non_drop_literal t ~drop ~escape_char with\n | None -> assert false\n | Some last -> sub t ~pos:first ~len:(last - first + 1)))\n ;;\nend\n\n(* Open replace_polymorphic_compare after including functor instantiations so they do not\n shadow its definitions. This is here so that efficient versions of the comparison\n functions are available within this module. *)\nopen! String_replace_polymorphic_compare\n\nlet between t ~low ~high = low <= t && t <= high\nlet clamp_unchecked t ~min ~max = if t < min then min else if t <= max then t else max\n\nlet clamp_exn t ~min ~max =\n assert (min <= max);\n clamp_unchecked t ~min ~max\n;;\n\nlet clamp t ~min ~max =\n if min > max\n then\n Or_error.error_s\n (Sexp.message\n \"clamp requires [min <= max]\"\n [ \"min\", T.sexp_of_t min; \"max\", T.sexp_of_t max ])\n else Ok (clamp_unchecked t ~min ~max)\n;;\n\n(* Override [Search_pattern] with default case-sensitivity argument at the end of the\n file, so that call sites above are forced to supply case-sensitivity explicitly. *)\nmodule Search_pattern = struct\n include Search_pattern0\n\n let create ?(case_sensitive = true) pattern = create pattern ~case_sensitive\nend\n\n(* Include type-specific [Replace_polymorphic_compare] at the end, after\n including functor application that could shadow its definitions. This is\n here so that efficient versions of the comparison functions are exported by\n this module. *)\ninclude String_replace_polymorphic_compare\n","open! Import\nmodule Array = Array0\n\nlet stage = Staged.stage\n\nmodule T = struct\n type t = bytes [@@deriving_inline sexp, sexp_grammar]\n\n let t_of_sexp = (bytes_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t)\n let sexp_of_t = (sexp_of_bytes : t -> Ppx_sexp_conv_lib.Sexp.t)\n\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group) =\n { implicit_vars = [ \"bytes\" ]\n ; ggid = \"\\146e\\023\\249\\235eE\\139c\\132W\\195\\137\\129\\235\\025\"\n ; types = [ \"t\", Implicit_var 0 ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ bytes_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"bytes.ml.T\"\n }\n in\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"t\", _the_group)\n in\n t_sexp_grammar\n ;;\n\n [@@@end]\n\n include Bytes0\n\n let module_name = \"Base.Bytes\"\n let pp fmt t = Caml.Format.fprintf fmt \"%S\" (to_string t)\nend\n\ninclude T\n\nmodule To_bytes = Blit.Make (struct\n include T\n\n let create ~len = create len\n end)\n\ninclude To_bytes\ninclude Comparator.Make (T)\ninclude Comparable.Validate (T)\ninclude Pretty_printer.Register_pp (T)\n\n(* Open replace_polymorphic_compare after including functor instantiations so they do not\n shadow its definitions. This is here so that efficient versions of the comparison\n functions are available within this module. *)\nopen! Bytes_replace_polymorphic_compare\nmodule To_string = Blit.Make_to_string (T) (To_bytes)\n\nmodule From_string =\n Blit.Make_distinct\n (struct\n type t = string\n\n let length = String.length\n end)\n (struct\n type nonrec t = t\n\n let create ~len = create len\n let length = length\n let unsafe_blit = unsafe_blit_string\n end)\n\nlet invariant (_ : t) = ()\n\nlet init n ~f =\n if Int_replace_polymorphic_compare.( < ) n 0\n then Printf.invalid_argf \"Bytes.init %d\" n ();\n let t = create n in\n for i = 0 to n - 1 do\n unsafe_set t i (f i)\n done;\n t\n;;\n\nlet of_char_list l =\n let t = create (List.length l) in\n List.iteri l ~f:(fun i c -> set t i c);\n t\n;;\n\nlet to_list t =\n let rec loop t i acc =\n if Int_replace_polymorphic_compare.( < ) i 0\n then acc\n else loop t (i - 1) (unsafe_get t i :: acc)\n in\n loop t (length t - 1) []\n;;\n\nlet to_array t = Array.init (length t) ~f:(fun i -> unsafe_get t i)\nlet map t ~f = map t ~f\nlet mapi t ~f = mapi t ~f\n\nlet fold =\n let rec loop t ~f ~len ~pos acc =\n if Int_replace_polymorphic_compare.equal pos len\n then acc\n else loop t ~f ~len ~pos:(pos + 1) (f acc (unsafe_get t pos))\n in\n fun t ~init ~f -> loop t ~f ~len:(length t) ~pos:0 init\n;;\n\nlet foldi =\n let rec loop t ~f ~len ~pos acc =\n if Int_replace_polymorphic_compare.equal pos len\n then acc\n else loop t ~f ~len ~pos:(pos + 1) (f pos acc (unsafe_get t pos))\n in\n fun t ~init ~f -> loop t ~f ~len:(length t) ~pos:0 init\n;;\n\nlet tr ~target ~replacement s =\n for i = 0 to length s - 1 do\n if Char.equal (unsafe_get s i) target then unsafe_set s i replacement\n done\n;;\n\nlet tr_multi ~target ~replacement =\n if Int_replace_polymorphic_compare.( = ) (String.length target) 0\n then stage ignore\n else if Int_replace_polymorphic_compare.( = ) (String.length replacement) 0\n then invalid_arg \"tr_multi: replacement is the empty string\"\n else (\n match Bytes_tr.tr_create_map ~target ~replacement with\n | None -> stage ignore\n | Some tr_map ->\n stage (fun s ->\n for i = 0 to length s - 1 do\n unsafe_set s i (String.unsafe_get tr_map (Char.to_int (unsafe_get s i)))\n done))\n;;\n\nlet between t ~low ~high = low <= t && t <= high\nlet clamp_unchecked t ~min ~max = if t < min then min else if t <= max then t else max\n\nlet clamp_exn t ~min ~max =\n assert (min <= max);\n clamp_unchecked t ~min ~max\n;;\n\nlet clamp t ~min ~max =\n if min > max\n then\n Or_error.error_s\n (Sexp.message\n \"clamp requires [min <= max]\"\n [ \"min\", T.sexp_of_t min; \"max\", T.sexp_of_t max ])\n else Ok (clamp_unchecked t ~min ~max)\n;;\n\nlet contains ?pos ?len t char =\n let pos, len =\n Ordered_collection_common.get_pos_len_exn () ?pos ?len ~total_length:(length t)\n in\n let last = pos + len in\n let rec loop i =\n Int_replace_polymorphic_compare.( < ) i last\n && (Char.equal (get t i) char || loop (i + 1))\n in\n loop pos\n;;\n\n(* Include type-specific [Replace_polymorphic_compare] at the end, after\n including functor application that could shadow its definitions. This is\n here so that efficient versions of the comparison functions are exported by\n this module. *)\ninclude Bytes_replace_polymorphic_compare\n","(* This file was autogenerated by ../generate/generate_pow_overflow_bounds.exe *)\n\nopen! Import\n\nmodule Array = Array0\n\n(* We have to use Int64.to_int_exn instead of int constants to make\n sure that file can be preprocessed on 32-bit machines. *)\n\nlet overflow_bound_max_int32_value : int32 =\n 2147483647l\n\nlet int32_positive_overflow_bounds : int32 array =\n [| 2147483647l\n ; 2147483647l\n ; 46340l\n ; 1290l\n ; 215l\n ; 73l\n ; 35l\n ; 21l\n ; 14l\n ; 10l\n ; 8l\n ; 7l\n ; 5l\n ; 5l\n ; 4l\n ; 4l\n ; 3l\n ; 3l\n ; 3l\n ; 3l\n ; 2l\n ; 2l\n ; 2l\n ; 2l\n ; 2l\n ; 2l\n ; 2l\n ; 2l\n ; 2l\n ; 2l\n ; 2l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n |]\n\nlet overflow_bound_max_int_value : int =\n (-1) lsr 1\n\nlet int_positive_overflow_bounds : int array =\n match Int_conversions.num_bits_int with\n | 32 -> Array.map int32_positive_overflow_bounds ~f:Caml.Int32.to_int\n | 63 ->\n [| Caml.Int64.to_int 4611686018427387903L\n ; Caml.Int64.to_int 4611686018427387903L\n ; Caml.Int64.to_int 2147483647L\n ; 1664510\n ; 46340\n ; 5404\n ; 1290\n ; 463\n ; 215\n ; 118\n ; 73\n ; 49\n ; 35\n ; 27\n ; 21\n ; 17\n ; 14\n ; 12\n ; 10\n ; 9\n ; 8\n ; 7\n ; 7\n ; 6\n ; 5\n ; 5\n ; 5\n ; 4\n ; 4\n ; 4\n ; 4\n ; 3\n ; 3\n ; 3\n ; 3\n ; 3\n ; 3\n ; 3\n ; 3\n ; 3\n ; 2\n ; 2\n ; 2\n ; 2\n ; 2\n ; 2\n ; 2\n ; 2\n ; 2\n ; 2\n ; 2\n ; 2\n ; 2\n ; 2\n ; 2\n ; 2\n ; 2\n ; 2\n ; 2\n ; 2\n ; 2\n ; 2\n ; 1\n ; 1\n |]\n | 31 ->\n [| 1073741823\n ; 1073741823\n ; 32767\n ; 1023\n ; 181\n ; 63\n ; 31\n ; 19\n ; 13\n ; 10\n ; 7\n ; 6\n ; 5\n ; 4\n ; 4\n ; 3\n ; 3\n ; 3\n ; 3\n ; 2\n ; 2\n ; 2\n ; 2\n ; 2\n ; 2\n ; 2\n ; 2\n ; 2\n ; 2\n ; 2\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n |]\n | _ -> assert false\n\nlet overflow_bound_max_int63_on_int64_value : int64 =\n 4611686018427387903L\n\nlet int63_on_int64_positive_overflow_bounds : int64 array =\n [| 4611686018427387903L\n ; 4611686018427387903L\n ; 2147483647L\n ; 1664510L\n ; 46340L\n ; 5404L\n ; 1290L\n ; 463L\n ; 215L\n ; 118L\n ; 73L\n ; 49L\n ; 35L\n ; 27L\n ; 21L\n ; 17L\n ; 14L\n ; 12L\n ; 10L\n ; 9L\n ; 8L\n ; 7L\n ; 7L\n ; 6L\n ; 5L\n ; 5L\n ; 5L\n ; 4L\n ; 4L\n ; 4L\n ; 4L\n ; 3L\n ; 3L\n ; 3L\n ; 3L\n ; 3L\n ; 3L\n ; 3L\n ; 3L\n ; 3L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 1L\n ; 1L\n |]\n\nlet overflow_bound_max_int64_value : int64 =\n 9223372036854775807L\n\nlet int64_positive_overflow_bounds : int64 array =\n [| 9223372036854775807L\n ; 9223372036854775807L\n ; 3037000499L\n ; 2097151L\n ; 55108L\n ; 6208L\n ; 1448L\n ; 511L\n ; 234L\n ; 127L\n ; 78L\n ; 52L\n ; 38L\n ; 28L\n ; 22L\n ; 18L\n ; 15L\n ; 13L\n ; 11L\n ; 9L\n ; 8L\n ; 7L\n ; 7L\n ; 6L\n ; 6L\n ; 5L\n ; 5L\n ; 5L\n ; 4L\n ; 4L\n ; 4L\n ; 4L\n ; 3L\n ; 3L\n ; 3L\n ; 3L\n ; 3L\n ; 3L\n ; 3L\n ; 3L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 1L\n |]\n\nlet int64_negative_overflow_bounds : int64 array =\n [| -9223372036854775807L\n ; -9223372036854775807L\n ; -3037000499L\n ; -2097151L\n ; -55108L\n ; -6208L\n ; -1448L\n ; -511L\n ; -234L\n ; -127L\n ; -78L\n ; -52L\n ; -38L\n ; -28L\n ; -22L\n ; -18L\n ; -15L\n ; -13L\n ; -11L\n ; -9L\n ; -8L\n ; -7L\n ; -7L\n ; -6L\n ; -6L\n ; -5L\n ; -5L\n ; -5L\n ; -4L\n ; -4L\n ; -4L\n ; -4L\n ; -3L\n ; -3L\n ; -3L\n ; -3L\n ; -3L\n ; -3L\n ; -3L\n ; -3L\n ; -2L\n ; -2L\n ; -2L\n ; -2L\n ; -2L\n ; -2L\n ; -2L\n ; -2L\n ; -2L\n ; -2L\n ; -2L\n ; -2L\n ; -2L\n ; -2L\n ; -2L\n ; -2L\n ; -2L\n ; -2L\n ; -2L\n ; -2L\n ; -2L\n ; -2L\n ; -2L\n ; -1L\n |]\n","open! Import\n\nlet invalid_argf = Printf.invalid_argf\nlet negative_exponent () = Printf.invalid_argf \"exponent can not be negative\" ()\nlet overflow () = Printf.invalid_argf \"integer overflow in pow\" ()\n\n(* To implement [int64_pow], we use C code rather than OCaml to eliminate allocation. *)\nexternal int_math_int_pow : int -> int -> int = \"Base_int_math_int_pow_stub\" [@@noalloc]\nexternal int_math_int64_pow : int64 -> int64 -> int64 = \"Base_int_math_int64_pow_stub\"\n\nlet int_pow base exponent =\n if exponent < 0 then negative_exponent ();\n if abs base > 1\n && (exponent > 63\n || abs base > Pow_overflow_bounds.int_positive_overflow_bounds.(exponent))\n then overflow ();\n int_math_int_pow base exponent\n;;\n\nmodule Int64_with_comparisons = struct\n include Caml.Int64\n\n external ( < ) : int64 -> int64 -> bool = \"%lessthan\"\n external ( > ) : int64 -> int64 -> bool = \"%greaterthan\"\n external ( >= ) : int64 -> int64 -> bool = \"%greaterequal\"\nend\n\n(* we don't do [abs] in int64 case to avoid allocation *)\nlet int64_pow base exponent =\n let open Int64_with_comparisons in\n if exponent < 0L then negative_exponent ();\n if (base > 1L || base < -1L)\n && (exponent > 63L\n || (base >= 0L\n && base > Pow_overflow_bounds.int64_positive_overflow_bounds.(to_int exponent)\n )\n || (base < 0L\n && base < Pow_overflow_bounds.int64_negative_overflow_bounds.(to_int exponent)\n ))\n then overflow ();\n int_math_int64_pow base exponent\n;;\n\nlet int63_pow_on_int64 base exponent =\n let open Int64_with_comparisons in\n if exponent < 0L then negative_exponent ();\n if abs base > 1L\n && (exponent > 63L\n || abs base\n > Pow_overflow_bounds.int63_on_int64_positive_overflow_bounds.(to_int exponent)\n )\n then overflow ();\n int_math_int64_pow base exponent\n;;\n\nmodule type Make_arg = sig\n type t\n\n include Floatable.S with type t := t\n include Stringable.S with type t := t\n\n val ( + ) : t -> t -> t\n val ( - ) : t -> t -> t\n val ( * ) : t -> t -> t\n val ( / ) : t -> t -> t\n val ( ~- ) : t -> t\n\n include Comparisons.Infix with type t := t\n\n val abs : t -> t\n val neg : t -> t\n val zero : t\n val of_int_exn : int -> t\n val rem : t -> t -> t\nend\n\nmodule Make (X : Make_arg) = struct\n open X\n\n let ( % ) x y =\n if y <= zero\n then\n invalid_argf\n \"%s %% %s in core_int.ml: modulus should be positive\"\n (to_string x)\n (to_string y)\n ();\n let rval = X.rem x y in\n if rval < zero then rval + y else rval\n ;;\n\n let one = of_int_exn 1\n\n let ( /% ) x y =\n if y <= zero\n then\n invalid_argf\n \"%s /%% %s in core_int.ml: divisor should be positive\"\n (to_string x)\n (to_string y)\n ();\n if x < zero then ((x + one) / y) - one else x / y\n ;;\n\n (** float division of integers *)\n let ( // ) x y = to_float x /. to_float y\n\n let round_down i ~to_multiple_of:modulus = i - (i % modulus)\n\n let round_up i ~to_multiple_of:modulus =\n let remainder = i % modulus in\n if remainder = zero then i else i + modulus - remainder\n ;;\n\n let round_towards_zero i ~to_multiple_of =\n if i = zero\n then zero\n else if i > zero\n then round_down i ~to_multiple_of\n else round_up i ~to_multiple_of\n ;;\n\n let round_nearest i ~to_multiple_of:modulus =\n let remainder = i % modulus in\n let modulus_minus_remainder = modulus - remainder in\n if modulus_minus_remainder <= remainder\n then i + modulus_minus_remainder\n else i - remainder\n ;;\n\n let round ?(dir = `Nearest) i ~to_multiple_of =\n match dir with\n | `Nearest -> round_nearest i ~to_multiple_of\n | `Down -> round_down i ~to_multiple_of\n | `Up -> round_up i ~to_multiple_of\n | `Zero -> round_towards_zero i ~to_multiple_of\n ;;\nend\n\nmodule Private = struct\n let int_pow = int_pow\n let int64_pow = int64_pow\n let int63_pow_on_int64 = int63_pow_on_int64\n\n module Pow_overflow_bounds = Pow_overflow_bounds\nend\n","open! Import\ninclude Int_intf\ninclude Int0\n\nmodule T = struct\n type t = int [@@deriving_inline hash, sexp, sexp_grammar]\n\n let (hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state) =\n hash_fold_int\n\n and (hash : t -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func = hash_int in\n fun x -> func x\n ;;\n\n let t_of_sexp = (int_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t)\n let sexp_of_t = (sexp_of_int : t -> Ppx_sexp_conv_lib.Sexp.t)\n\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group) =\n { implicit_vars = [ \"int\" ]\n ; ggid = \"\\146e\\023\\249\\235eE\\139c\\132W\\195\\137\\129\\235\\025\"\n ; types = [ \"t\", Implicit_var 0 ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ int_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"int.ml.T\"\n }\n in\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"t\", _the_group)\n in\n t_sexp_grammar\n ;;\n\n [@@@end]\n\n let compare x y = Int_replace_polymorphic_compare.compare x y\n\n let of_string s =\n try of_string s with\n | _ -> Printf.failwithf \"Int.of_string: %S\" s ()\n ;;\n\n let to_string = to_string\nend\n\nlet num_bits = Int_conversions.num_bits_int\nlet float_lower_bound = Float0.lower_bound_for_int num_bits\nlet float_upper_bound = Float0.upper_bound_for_int num_bits\nlet to_float = Caml.float_of_int\nlet of_float_unchecked = Caml.int_of_float\n\nlet of_float f =\n if Float_replace_polymorphic_compare.( >= ) f float_lower_bound\n && Float_replace_polymorphic_compare.( <= ) f float_upper_bound\n then Caml.int_of_float f\n else\n Printf.invalid_argf\n \"Int.of_float: argument (%f) is out of range or NaN\"\n (Float0.box f)\n ()\n;;\n\nlet zero = 0\nlet one = 1\nlet minus_one = -1\n\ninclude T\ninclude Comparator.Make (T)\n\ninclude Comparable.Validate_with_zero (struct\n include T\n\n let zero = zero\n end)\n\nmodule Conv = Int_conversions\ninclude Conv.Make (T)\n\ninclude Conv.Make_hex (struct\n open Int_replace_polymorphic_compare\n\n type t = int [@@deriving_inline compare, hash]\n\n let compare = (compare_int : t -> t -> int)\n\n let (hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state) =\n hash_fold_int\n\n and (hash : t -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func = hash_int in\n fun x -> func x\n ;;\n\n [@@@end]\n\n let zero = zero\n let neg = ( ~- )\n let ( < ) = ( < )\n let to_string i = Printf.sprintf \"%x\" i\n let of_string s = Caml.Scanf.sscanf s \"%x\" Fn.id\n let module_name = \"Base.Int.Hex\"\n end)\n\ninclude Pretty_printer.Register (struct\n type nonrec t = t\n\n let to_string = to_string\n let module_name = \"Base.Int\"\n end)\n\n(* Open replace_polymorphic_compare after including functor instantiations so\n they do not shadow its definitions. This is here so that efficient versions\n of the comparison functions are available within this module. *)\nopen! Int_replace_polymorphic_compare\n\nlet invariant (_ : t) = ()\nlet between t ~low ~high = low <= t && t <= high\nlet clamp_unchecked t ~min ~max = if t < min then min else if t <= max then t else max\n\nlet clamp_exn t ~min ~max =\n assert (min <= max);\n clamp_unchecked t ~min ~max\n;;\n\nlet clamp t ~min ~max =\n if min > max\n then\n Or_error.error_s\n (Sexp.message\n \"clamp requires [min <= max]\"\n [ \"min\", T.sexp_of_t min; \"max\", T.sexp_of_t max ])\n else Ok (clamp_unchecked t ~min ~max)\n;;\n\nlet pred i = i - 1\nlet succ i = i + 1\nlet to_int i = i\nlet to_int_exn = to_int\nlet of_int i = i\nlet of_int_exn = of_int\nlet max_value = Caml.max_int\nlet min_value = Caml.min_int\nlet max_value_30_bits = 0x3FFF_FFFF\nlet of_int32 = Conv.int32_to_int\nlet of_int32_exn = Conv.int32_to_int_exn\nlet of_int32_trunc = Conv.int32_to_int_trunc\nlet to_int32 = Conv.int_to_int32\nlet to_int32_exn = Conv.int_to_int32_exn\nlet to_int32_trunc = Conv.int_to_int32_trunc\nlet of_int64 = Conv.int64_to_int\nlet of_int64_exn = Conv.int64_to_int_exn\nlet of_int64_trunc = Conv.int64_to_int_trunc\nlet to_int64 = Conv.int_to_int64\nlet of_nativeint = Conv.nativeint_to_int\nlet of_nativeint_exn = Conv.nativeint_to_int_exn\nlet of_nativeint_trunc = Conv.nativeint_to_int_trunc\nlet to_nativeint = Conv.int_to_nativeint\nlet to_nativeint_exn = to_nativeint\nlet abs x = abs x\nlet ( + ) x y = x + y\nlet ( - ) x y = x - y\nlet ( * ) x y = x * y\nlet ( / ) x y = x / y\nlet neg x = -x\nlet ( ~- ) = neg\n\n(* note that rem is not same as % *)\nlet rem a b = a mod b\nlet incr = Caml.incr\nlet decr = Caml.decr\nlet shift_right a b = a asr b\nlet shift_right_logical a b = a lsr b\nlet shift_left a b = a lsl b\nlet bit_not a = lnot a\nlet bit_or a b = a lor b\nlet bit_and a b = a land b\nlet bit_xor a b = a lxor b\nlet pow = Int_math.Private.int_pow\nlet ( ** ) b e = pow b e\n\nmodule Pow2 = struct\n open! Import\n module Sys = Sys0\n\n let raise_s = Error.raise_s\n\n let non_positive_argument () =\n Printf.invalid_argf \"argument must be strictly positive\" ()\n ;;\n\n\n (** \"ceiling power of 2\" - Least power of 2 greater than or equal to x. *)\n let ceil_pow2 x =\n if x <= 0 then non_positive_argument ();\n let x = x - 1 in\n let x = x lor (x lsr 1) in\n let x = x lor (x lsr 2) in\n let x = x lor (x lsr 4) in\n let x = x lor (x lsr 8) in\n let x = x lor (x lsr 16) in\n (* The next line is superfluous on 32-bit architectures, but it's faster to do it\n anyway than to branch *)\n let x = x lor (x lsr 32) in\n x + 1\n ;;\n\n (** \"floor power of 2\" - Largest power of 2 less than or equal to x. *)\n let floor_pow2 x =\n if x <= 0 then non_positive_argument ();\n let x = x lor (x lsr 1) in\n let x = x lor (x lsr 2) in\n let x = x lor (x lsr 4) in\n let x = x lor (x lsr 8) in\n let x = x lor (x lsr 16) in\n (* The next line is superfluous on 32-bit architectures, but it's faster to do it\n anyway than to branch *)\n let x = x lor (x lsr 32) in\n x - (x lsr 1)\n ;;\n\n let is_pow2 x =\n if x <= 0 then non_positive_argument ();\n x land (x - 1) = 0\n ;;\n\n (* C stubs for int clz and ctz to use the CLZ/BSR/CTZ/BSF instruction where possible *)\n external clz\n : (* Note that we pass the tagged int here. See int_math_stubs.c for details on why\n this is correct. *)\n int\n -> (int[@untagged])\n = \"Base_int_math_int_clz\" \"Base_int_math_int_clz_untagged\"\n [@@noalloc]\n\n external ctz\n : (int[@untagged])\n -> (int[@untagged])\n = \"Base_int_math_int_ctz\" \"Base_int_math_int_ctz_untagged\"\n [@@noalloc]\n\n (** Hacker's Delight Second Edition p106 *)\n let floor_log2 i =\n if i <= 0\n then\n raise_s (Sexp.message \"[Int.floor_log2] got invalid input\" [ \"\", sexp_of_int i ]);\n num_bits - 1 - clz i\n ;;\n\n let ceil_log2 i =\n if i <= 0\n then raise_s (Sexp.message \"[Int.ceil_log2] got invalid input\" [ \"\", sexp_of_int i ]);\n if i = 1 then 0 else num_bits - clz (i - 1)\n ;;\nend\n\ninclude Pow2\n\n(* This is already defined by Comparable.Validate_with_zero, but Sign.of_int is\n more direct. *)\nlet sign = Sign.of_int\nlet popcount = Popcount.int_popcount\n\nmodule Pre_O = struct\n let ( + ) = ( + )\n let ( - ) = ( - )\n let ( * ) = ( * )\n let ( / ) = ( / )\n let ( ~- ) = ( ~- )\n let ( ** ) = ( ** )\n\n include (Int_replace_polymorphic_compare : Comparisons.Infix with type t := t)\n\n let abs = abs\n let neg = neg\n let zero = zero\n let of_int_exn = of_int_exn\nend\n\nmodule O = struct\n include Pre_O\n\n module F = Int_math.Make (struct\n type nonrec t = t\n\n include Pre_O\n\n let rem = rem\n let to_float = to_float\n let of_float = of_float\n let of_string = T.of_string\n let to_string = T.to_string\n end)\n\n include F\n\n external bswap16 : int -> int = \"%bswap16\"\n\n (* These inlined versions of (%), (/%), and (//) perform better than their functorized\n counterparts in [F] (see benchmarks below).\n\n The reason these functions are inlined in [Int] but not in any of the other integer\n modules is that they existed in [Int] and [Int] alone prior to the introduction of\n the [Int_math.Make] functor, and we didn't want to degrade their performance.\n\n We won't pre-emptively do the same for new functions, unless someone cares, on a case\n by case fashion. *)\n\n let ( % ) x y =\n if y <= zero\n then\n Printf.invalid_argf\n \"%s %% %s in core_int.ml: modulus should be positive\"\n (to_string x)\n (to_string y)\n ();\n let rval = rem x y in\n if rval < zero then rval + y else rval\n ;;\n\n let ( /% ) x y =\n if y <= zero\n then\n Printf.invalid_argf\n \"%s /%% %s in core_int.ml: divisor should be positive\"\n (to_string x)\n (to_string y)\n ();\n if x < zero then ((x + one) / y) - one else x / y\n ;;\n\n let ( // ) x y = to_float x /. to_float y\n let ( land ) = ( land )\n let ( lor ) = ( lor )\n let ( lxor ) = ( lxor )\n let lnot = lnot\n let ( lsl ) = ( lsl )\n let ( asr ) = ( asr )\n let ( lsr ) = ( lsr )\nend\n\ninclude O\n\n(* [Int] and [Int.O] agree value-wise *)\n\nmodule Private = struct\n module O_F = O.F\nend\n\n(* Include type-specific [Replace_polymorphic_compare] at the end, after including functor\n application that could shadow its definitions. This is here so that efficient versions\n of the comparison functions are exported by this module. *)\ninclude Int_replace_polymorphic_compare\n","open! Import\n\ntype ('a, 'b) t = T : ('a, 'a) t [@@deriving_inline sexp_of]\n\nlet sexp_of_t\n : type a b.\n (a -> Ppx_sexp_conv_lib.Sexp.t)\n -> (b -> Ppx_sexp_conv_lib.Sexp.t)\n -> (a, b) t\n -> Ppx_sexp_conv_lib.Sexp.t\n =\n fun _of_a _of_b -> function\n | T -> Ppx_sexp_conv_lib.Sexp.Atom \"T\"\n;;\n\n[@@@end]\n\ntype ('a, 'b) equal = ('a, 'b) t\n\nlet refl = T\nlet sym (type a b) (T : (a, b) t) : (b, a) t = T\nlet trans (type a b c) (T : (a, b) t) (T : (b, c) t) : (a, c) t = T\nlet conv (type a b) (T : (a, b) t) (a : a) : b = a\n\nmodule Lift (X : sig\n type 'a t\n end) =\nstruct\n let lift (type a b) (T : (a, b) t) : (a X.t, b X.t) t = T\nend\n\nmodule Lift2 (X : sig\n type ('a1, 'a2) t\n end) =\nstruct\n let lift (type a1 b1 a2 b2) (T : (a1, b1) t) (T : (a2, b2) t)\n : ((a1, a2) X.t, (b1, b2) X.t) t\n =\n T\n ;;\nend\n\nmodule Lift3 (X : sig\n type ('a1, 'a2, 'a3) t\n end) =\nstruct\n let lift (type a1 b1 a2 b2 a3 b3) (T : (a1, b1) t) (T : (a2, b2) t) (T : (a3, b3) t)\n : ((a1, a2, a3) X.t, (b1, b2, b3) X.t) t\n =\n T\n ;;\nend\n\nlet detuple2 (type a1 a2 b1 b2) (T : (a1 * a2, b1 * b2) t) : (a1, b1) t * (a2, b2) t =\n T, T\n;;\n\nlet tuple2 (type a1 a2 b1 b2) (T : (a1, b1) t) (T : (a2, b2) t) : (a1 * a2, b1 * b2) t =\n T\n;;\n\nmodule type Injective = sig\n type 'a t\n\n val strip : ('a t, 'b t) equal -> ('a, 'b) equal\nend\n\nmodule type Injective2 = sig\n type ('a1, 'a2) t\n\n val strip : (('a1, 'a2) t, ('b1, 'b2) t) equal -> ('a1, 'b1) equal * ('a2, 'b2) equal\nend\n\nmodule Composition_preserves_injectivity (M1 : Injective) (M2 : Injective) = struct\n type 'a t = 'a M1.t M2.t\n\n let strip e = M1.strip (M2.strip e)\nend\n\nmodule Obj = struct\n module Extension_constructor = struct\n [@@@ocaml.warning \"-3\"]\n\n let id = Caml.Obj.extension_id\n let of_val = Caml.Obj.extension_constructor\n end\nend\n\nmodule Id = struct\n module Uid = Int\n\n module Witness = struct\n module Key = struct\n type _ t = ..\n type type_witness_int = [ `type_witness of int ] [@@deriving_inline sexp_of]\n\n let sexp_of_type_witness_int =\n (function\n | `type_witness v0 ->\n Ppx_sexp_conv_lib.Sexp.List\n [ Ppx_sexp_conv_lib.Sexp.Atom \"type_witness\"; sexp_of_int v0 ]\n : type_witness_int -> Ppx_sexp_conv_lib.Sexp.t)\n ;;\n\n [@@@end]\n\n let sexp_of_t _sexp_of_a t =\n `type_witness (Obj.Extension_constructor.id (Obj.Extension_constructor.of_val t))\n |> sexp_of_type_witness_int\n ;;\n end\n\n module type S = sig\n type t\n type _ Key.t += Key : t Key.t\n end\n\n type 'a t = (module S with type t = 'a)\n\n let sexp_of_t (type a) sexp_of_a (module M : S with type t = a) =\n M.Key |> Key.sexp_of_t sexp_of_a\n ;;\n\n let create (type t) () =\n let module M = struct\n type nonrec t = t\n type _ Key.t += Key : t Key.t\n end\n in\n (module M : S with type t = t)\n ;;\n\n let uid (type a) (module M : S with type t = a) =\n Obj.Extension_constructor.id (Obj.Extension_constructor.of_val M.Key)\n ;;\n\n (* We want a constant allocated once that [same] can return whenever it gets the same\n witnesses. If we write the constant inside the body of [same], the native-code\n compiler will do the right thing and lift it out. But for clarity and robustness,\n we do it ourselves. *)\n let some_t = Some T\n\n let same (type a b) (a : a t) (b : b t) : (a, b) equal option =\n let module A = (val a : S with type t = a) in\n let module B = (val b : S with type t = b) in\n match A.Key with\n | B.Key -> some_t\n | _ -> None\n ;;\n end\n\n\n type 'a t =\n { witness : 'a Witness.t\n ; name : string\n ; to_sexp : 'a -> Sexp.t\n }\n\n let sexp_of_t _ { witness; name; to_sexp } : Sexp.t =\n if am_testing\n then Atom name\n else\n List\n [ List [ Atom \"name\"; Atom name ]\n ; List [ Atom \"witness\"; witness |> Witness.sexp_of_t to_sexp ]\n ]\n ;;\n\n let to_sexp t = t.to_sexp\n let name t = t.name\n let create ~name to_sexp = { witness = Witness.create (); name; to_sexp }\n let uid t = Witness.uid t.witness\n let hash t = uid t\n let hash_fold_t s t = hash_fold_int s (uid t)\n let same_witness t1 t2 = Witness.same t1.witness t2.witness\n let same t1 t2 = Option.is_some (same_witness t1 t2)\n\n let same_witness_exn t1 t2 =\n match same_witness t1 t2 with\n | Some w -> w\n | None ->\n Error.raise_s\n (Sexp.message\n \"Type_equal.Id.same_witness_exn got different ids\"\n [ ( \"\"\n , sexp_of_pair (sexp_of_t sexp_of_opaque) (sexp_of_t sexp_of_opaque) (t1, t2)\n )\n ])\n ;;\nend\n","open! Import\nopen Std_internal\ninclude Univ_map_intf\nmodule Uid = Type_equal.Id.Uid\n\nmodule Make1\n (Key : Key) (Data : sig\n type ('s, 'a) t [@@deriving sexp_of]\n end) =\nstruct\n (* A wrapper for the [Key] module that adds a dynamic check to [Key.to_type_id].\n\n It's a bug if the user-provided [Key.to_type_id] gives different type ids on\n different calls. Because this check should be fairly cheap, we do it dynamically to\n avoid subtler problems later.\n\n Of course, we're not checking truly pathological things like the provided\n [Key.to_type_id] only changes the value it returns on every third call...\n *)\n module Key = struct\n type 'a t = 'a Key.t [@@deriving sexp_of]\n\n (* test-friendly sexp conversion *)\n let sexp_of_type_id type_id =\n [%sexp\n { name = (Type_equal.Id.name type_id : string)\n ; uid =\n ((if am_running_inline_test\n then Sexp.Atom \"\"\n else Type_equal.Id.Uid.sexp_of_t (Type_equal.Id.uid type_id)) : Sexp.t)\n }]\n ;;\n\n let to_type_id key =\n let type_id1 = Key.to_type_id key in\n let type_id2 = Key.to_type_id key in\n if Type_equal.Id.same type_id1 type_id2\n then type_id1\n else\n raise_s\n [%message\n \"[Key.to_type_id] must not provide different type ids when called on the \\\n same input\"\n (key : _ Key.t)\n (type_id1 : type_id)\n (type_id2 : type_id)]\n ;;\n end\n\n type ('s, 'a) data = ('s, 'a) Data.t\n\n let name_of_key key = Type_equal.Id.name (Key.to_type_id key)\n let uid_of_key key = Type_equal.Id.uid (Key.to_type_id key)\n\n module Packed = struct\n type 's t = T : 'a Key.t * ('s, 'a) Data.t -> 's t\n\n let sexp_of_t sexp_of_a (T (key, data)) =\n Data.sexp_of_t sexp_of_a (Type_equal.Id.to_sexp (Key.to_type_id key)) data\n ;;\n\n let type_id_name (T (key, _)) = name_of_key key\n let type_id_uid (T (key, _)) = uid_of_key key\n end\n\n type 's t = 's Packed.t Uid.Map.t\n\n let sexp_of_t sexp_of_a t =\n Map.data t\n |> List.map ~f:(fun u -> Packed.type_id_name u, u)\n |> List.sort ~compare:(fun (a, _) (b, _) -> String.compare a b)\n |> [%sexp_of: (string * a Packed.t) list]\n ;;\n\n let invariant (t : _ t) =\n Invariant.invariant [%here] t [%sexp_of: _ t] (fun () ->\n Map.iteri t ~f:(fun ~key ~data ->\n assert (Uid.equal key (Packed.type_id_uid data))))\n ;;\n\n let set t key data = Map.set t ~key:(uid_of_key key) ~data:(Packed.T (key, data))\n let mem_by_id t id = Map.mem t id\n let mem t key = mem_by_id t (uid_of_key key)\n let remove_by_id t id = Map.remove t id\n let remove t key = remove_by_id t (uid_of_key key)\n let empty = Uid.Map.empty\n let is_empty = Map.is_empty\n\n let find (type b) t (key : b Key.t) =\n match Map.find t (uid_of_key key) with\n | None -> None\n | Some (Packed.T (key', value)) ->\n (* cannot raise -- see [invariant] *)\n let Type_equal.T =\n Type_equal.Id.same_witness_exn (Key.to_type_id key) (Key.to_type_id key')\n in\n Some (value : (_, b) Data.t)\n ;;\n\n let find_exn t key =\n match find t key with\n | Some data -> data\n | None -> failwithf \"Univ_map.find_exn on unknown key %s\" (name_of_key key) ()\n ;;\n\n let add t key data = if mem t key then `Duplicate else `Ok (set t key data)\n\n let add_exn t key data =\n match add t key data with\n | `Ok t -> t\n | `Duplicate -> failwithf \"Univ_map.add_exn on existing key %s\" (name_of_key key) ()\n ;;\n\n let change_exn t key ~f:update =\n match find t key with\n | Some data -> set t key (update data)\n | None -> failwithf \"Univ_map.change_exn on unknown key %s\" (name_of_key key) ()\n ;;\n\n let change t key ~f:update =\n let orig = find t key in\n let next = update orig in\n match next with\n | Some data -> set t key data\n | None -> if Option.is_none orig then t else remove t key\n ;;\n\n let update t key ~f = change t key ~f:(fun data -> Some (f data))\n let to_alist t = Map.data t\n\n let of_alist_exn t =\n Uid.Map.of_alist_exn (List.map t ~f:(fun p -> Packed.type_id_uid p, p))\n ;;\nend\n\nmodule Make\n (Key : Key) (Data : sig\n type 'a t [@@deriving sexp_of]\n end) =\nstruct\n module M =\n Make1\n (Key)\n (struct\n type (_, 'a) t = 'a Data.t [@@deriving sexp_of]\n end)\n\n type t = unit M.t [@@deriving sexp_of]\n\n module Key = Key\n\n type 'a data = 'a Data.t\n\n let invariant = M.invariant\n let empty = M.empty\n let is_empty = M.is_empty\n let set = M.set\n let mem = M.mem\n let mem_by_id = M.mem_by_id\n let find = M.find\n let find_exn = M.find_exn\n let add = M.add\n let add_exn = M.add_exn\n let change = M.change\n let change_exn = M.change_exn\n let update = M.update\n let remove = M.remove\n let remove_by_id = M.remove_by_id\n\n module Packed = struct\n type t = T : 'a Key.t * 'a Data.t -> t\n end\n\n let to_alist t =\n List.map (M.to_alist t) ~f:(function M.Packed.T (key, data) -> Packed.T (key, data))\n ;;\n\n let of_alist_exn t =\n M.of_alist_exn\n (List.map t ~f:(function Packed.T (key, data) -> M.Packed.T (key, data)))\n ;;\nend\n\nmodule Merge\n (Key : Key)\n (Input1_data : Data1)\n (Input2_data : Data1)\n (Output_data : Data1) =\nstruct\n type 's f =\n { f :\n 'a. key:'a Key.t\n -> [ `Left of ('s, 'a) Input1_data.t\n | `Right of ('s, 'a) Input2_data.t\n | `Both of ('s, 'a) Input1_data.t * ('s, 'a) Input2_data.t\n ] -> ('s, 'a) Output_data.t option\n }\n\n module Output = Make1 (Key) (Output_data)\n\n let merge\n (type s)\n (t1 : s Make1(Key)(Input1_data).t)\n (t2 : s Make1(Key)(Input2_data).t)\n ~f:{ f }\n =\n let f ~key merge_result =\n Option.map (f ~key merge_result) ~f:(fun data -> Output.Packed.T (key, data))\n in\n Map.merge t1 t2 ~f:(fun ~key:_ ->\n function\n | `Left (T (key, data)) -> f ~key (`Left data)\n | `Right (T (key, data)) -> f ~key (`Right data)\n | `Both (T (left_key, left_data), T (right_key, right_data)) ->\n (* Can't raise due to the invariant *)\n let Type_equal.T =\n Type_equal.Id.same_witness_exn\n (Key.to_type_id left_key)\n (Key.to_type_id right_key)\n in\n f ~key:left_key (`Both (left_data, right_data)))\n ;;\nend\n\nmodule Type_id_key = struct\n type 'a t = 'a Type_equal.Id.t [@@deriving sexp_of]\n\n let to_type_id = Fn.id\nend\n\ninclude (\n Make\n (Type_id_key)\n (struct\n type 'a t = 'a [@@deriving sexp_of]\n end) :\n S with type 'a data = 'a and module Key := Type_id_key)\n\nmodule Key = Type_equal.Id\n\nmodule With_default = struct\n module Key = struct\n type 'a t =\n { key : 'a Type_equal.Id.t\n ; default : 'a\n }\n\n let create ~default ~name sexp_of =\n { default; key = Type_equal.Id.create ~name sexp_of }\n ;;\n\n let id t = t.key\n end\n\n let find t { Key.key; default } = Option.value ~default (find t key)\n let set t { Key.key; default = _ } v = set t key v\n let change t k ~f:update = set t k (update (find t k))\nend\n\nmodule With_fold = struct\n module Key = struct\n type ('a, 'b) t =\n { key : 'b With_default.Key.t\n ; f : 'b -> 'a -> 'b\n }\n\n let create ~init ~f ~name sexp_of =\n { f; key = With_default.Key.create ~default:init ~name sexp_of }\n ;;\n\n let id t = With_default.Key.id t.key\n end\n\n let find t { Key.key; f = _ } = With_default.find t key\n let set t { Key.key; f = _ } v = With_default.set t key v\n let change t { Key.key; f = _ } ~f:update = With_default.change t key ~f:update\n let add t { Key.key; f } v = With_default.change t key ~f:(fun acc -> f acc v)\nend\n\nmodule Multi = struct\n open With_fold\n\n module Key = struct\n type 'a t = ('a, 'a list) Key.t\n\n let create ~name sexp_of =\n Key.create ~init:[] ~f:(fun xs x -> x :: xs) ~name (List.sexp_of_t sexp_of)\n ;;\n\n let id = With_fold.Key.id\n end\n\n let set = set\n let find = find\n let add = add\n let change = change\nend\n","open! Import\n\n(** ['a Cheap_option.t] is like ['a option], but it doesn't box [some _] values.\n\n There are several things that are unsafe about it:\n\n - [float t array] (or any array-backed container) is not memory-safe\n because float array optimization is incompatible with unboxed option\n optimization. You have to use [Uniform_array.t] instead of [array].\n\n - Nested options (['a t t]) don't work. They are believed to be\n memory-safe, but not parametric.\n\n - A record with [float t]s in it should be safe, but it's only [t] being\n abstract that gives you safety. If the compiler was smart enough to peek\n through the module signature then it could decide to construct a float\n array instead. *)\nmodule Cheap_option = struct\n (* This is taken from core_kernel. Rather than expose it in the public\n interface of base, just keep a copy around here. *)\n let phys_same (type a b) (a : a) (b : b) = phys_equal a (Caml.Obj.magic b : a)\n\n module T0 : sig\n type 'a t\n\n val none : _ t\n val some : 'a -> 'a t\n val is_none : _ t -> bool\n val is_some : _ t -> bool\n val value_exn : 'a t -> 'a\n val value_unsafe : 'a t -> 'a\n end = struct\n type +'a t\n\n (* Being a pointer, no one outside this module can construct a value that is\n [phys_same] as this one.\n\n It would be simpler to use this value as [none], but we use an immediate instead\n because it lets us avoid caml_modify when setting to [none], making certain\n benchmarks significantly faster (e.g. ../bench/array_queue.exe).\n\n this code is duplicated in Moption, and if we find yet another place where we want\n it we should reconsider making it shared. *)\n let none_substitute : _ t = Caml.Obj.obj (Caml.Obj.new_block Caml.Obj.abstract_tag 1)\n\n let none : _ t =\n (* The number was produced by\n [< /dev/urandom tr -c -d '1234567890abcdef' | head -c 16].\n\n The idea is that a random number will have lower probability to collide with\n anything than any number we can choose ourselves.\n\n We are using a polymorphic variant instead of an integer constant because there\n is a compiler bug where it wrongly assumes that the result of [if _ then c else\n y] is not a pointer if [c] is an integer compile-time constant. This is being\n fixed in https://github.com/ocaml/ocaml/pull/555. The \"memory corruption\" test\n below demonstrates the issue. *)\n Caml.Obj.magic `x6e8ee3478e1d7449\n ;;\n\n let is_none x = phys_equal x none\n let is_some x = not (phys_equal x none)\n\n let some (type a) (x : a) : a t =\n if phys_same x none then none_substitute else Caml.Obj.magic x\n ;;\n\n let value_unsafe (type a) (x : a t) : a =\n if phys_equal x none_substitute then Caml.Obj.magic none else Caml.Obj.magic x\n ;;\n\n let value_exn x =\n if is_some x\n then value_unsafe x\n else failwith \"Option_array.get_some_exn: the element is [None]\"\n ;;\n end\n\n module T1 = struct\n include T0\n\n let of_option = function\n | None -> none\n | Some x -> some x\n ;;\n\n let to_option x = if is_some x then Some (value_unsafe x) else None\n let to_sexpable = to_option\n let of_sexpable = of_option\n end\n\n include T1\n include Sexpable.Of_sexpable1 (Option) (T1)\nend\n\ntype 'a t = 'a Cheap_option.t Uniform_array.t [@@deriving_inline sexp]\n\nlet t_of_sexp : 'a. (Ppx_sexp_conv_lib.Sexp.t -> 'a) -> Ppx_sexp_conv_lib.Sexp.t -> 'a t =\n let _tp_loc = \"option_array.ml.t\" in\n fun _of_a t -> Uniform_array.t_of_sexp (Cheap_option.t_of_sexp _of_a) t\n;;\n\nlet sexp_of_t : 'a. ('a -> Ppx_sexp_conv_lib.Sexp.t) -> 'a t -> Ppx_sexp_conv_lib.Sexp.t =\n fun _of_a v -> Uniform_array.sexp_of_t (Cheap_option.sexp_of_t _of_a) v\n;;\n\n[@@@end]\n\nlet empty = Uniform_array.empty\nlet create ~len = Uniform_array.create ~len Cheap_option.none\nlet init n ~f = Uniform_array.init n ~f:(fun i -> Cheap_option.of_option (f i))\nlet init_some n ~f = Uniform_array.init n ~f:(fun i -> Cheap_option.some (f i))\nlet length = Uniform_array.length\nlet get t i = Cheap_option.to_option (Uniform_array.get t i)\nlet get_some_exn t i = Cheap_option.value_exn (Uniform_array.get t i)\nlet is_none t i = Cheap_option.is_none (Uniform_array.get t i)\nlet is_some t i = Cheap_option.is_some (Uniform_array.get t i)\nlet set t i x = Uniform_array.set t i (Cheap_option.of_option x)\nlet set_some t i x = Uniform_array.set t i (Cheap_option.some x)\nlet set_none t i = Uniform_array.set t i Cheap_option.none\nlet swap t i j = Uniform_array.swap t i j\nlet unsafe_get t i = Cheap_option.to_option (Uniform_array.unsafe_get t i)\nlet unsafe_get_some_exn t i = Cheap_option.value_exn (Uniform_array.unsafe_get t i)\n\nlet unsafe_get_some_assuming_some t i =\n Cheap_option.value_unsafe (Uniform_array.unsafe_get t i)\n;;\n\nlet unsafe_is_some t i = Cheap_option.is_some (Uniform_array.unsafe_get t i)\nlet unsafe_set t i x = Uniform_array.unsafe_set t i (Cheap_option.of_option x)\nlet unsafe_set_some t i x = Uniform_array.unsafe_set t i (Cheap_option.some x)\nlet unsafe_set_none t i = Uniform_array.unsafe_set t i Cheap_option.none\n\nlet clear t =\n for i = 0 to length t - 1 do\n unsafe_set_none t i\n done\n;;\n\ninclude Blit.Make1_generic (struct\n type nonrec 'a t = 'a t\n\n let length = length\n let create_like ~len _ = create ~len\n let unsafe_blit = Uniform_array.unsafe_blit\n end)\n\nlet copy = Uniform_array.copy\n\nmodule For_testing = struct\n module Unsafe_cheap_option = Cheap_option\nend\n","open! Import\ninclude Stack_intf\n\nlet raise_s = Error.raise_s\n\n(* This implementation is similar to [Deque] in that it uses an array of ['a] and\n a mutable [int] to indicate what in the array is used. We choose to implement [Stack]\n directly rather than on top of [Deque] for performance reasons. E.g. a simple\n microbenchmark shows that push/pop is about 20% faster. *)\ntype 'a t =\n { mutable length : int\n ; mutable elts : 'a Option_array.t\n }\n[@@deriving_inline sexp_of]\n\nlet sexp_of_t : 'a. ('a -> Ppx_sexp_conv_lib.Sexp.t) -> 'a t -> Ppx_sexp_conv_lib.Sexp.t =\n fun _of_a -> function\n | { length = v_length; elts = v_elts } ->\n let bnds = [] in\n let bnds =\n let arg = Option_array.sexp_of_t _of_a v_elts in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"elts\"; arg ] :: bnds\n in\n let bnds =\n let arg = sexp_of_int v_length in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"length\"; arg ] :: bnds\n in\n Ppx_sexp_conv_lib.Sexp.List bnds\n;;\n\n[@@@end]\n\nlet sexp_of_t_internal = sexp_of_t\nlet sexp_of_t = `Rebound_later\nlet _ = sexp_of_t\nlet capacity t = Option_array.length t.elts\n\nlet invariant invariant_a ({ length; elts } as t) : unit =\n try\n assert (0 <= length && length <= Option_array.length elts);\n for i = 0 to length - 1 do\n invariant_a (Option_array.get_some_exn elts i)\n done;\n (* We maintain the invariant that unused elements are unset to avoid a space\n leak. *)\n for i = length to Option_array.length elts - 1 do\n assert (not (Option_array.is_some elts i))\n done\n with\n | exn ->\n raise_s\n (Sexp.message\n \"Stack.invariant failed\"\n [ \"exn\", exn |> Exn.sexp_of_t; \"stack\", t |> sexp_of_t_internal sexp_of_opaque ])\n;;\n\nlet create (type a) () : a t = { length = 0; elts = Option_array.empty }\nlet length t = t.length\nlet is_empty t = length t = 0\n\n(* The order in which elements are visited has been chosen so as to be backwards\n compatible with both [Linked_stack] and [Caml.Stack] *)\nlet fold t ~init ~f =\n let r = ref init in\n for i = t.length - 1 downto 0 do\n r := f !r (Option_array.get_some_exn t.elts i)\n done;\n !r\n;;\n\nlet iter t ~f =\n for i = t.length - 1 downto 0 do\n f (Option_array.get_some_exn t.elts i)\n done\n;;\n\nmodule C = Container.Make (struct\n type nonrec 'a t = 'a t\n\n let fold = fold\n let iter = `Custom iter\n let length = `Custom length\n end)\n\nlet mem = C.mem\nlet exists = C.exists\nlet for_all = C.for_all\nlet count = C.count\nlet sum = C.sum\nlet find = C.find\nlet find_map = C.find_map\nlet to_list = C.to_list\nlet to_array = C.to_array\nlet min_elt = C.min_elt\nlet max_elt = C.max_elt\nlet fold_result = C.fold_result\nlet fold_until = C.fold_until\n\nlet of_list (type a) (l : a list) =\n if List.is_empty l\n then create ()\n else (\n let length = List.length l in\n let elts = Option_array.create ~len:(2 * length) in\n let r = ref l in\n for i = length - 1 downto 0 do\n match !r with\n | [] -> assert false\n | a :: l ->\n Option_array.set_some elts i a;\n r := l\n done;\n { length; elts })\n;;\n\nlet sexp_of_t sexp_of_a t = List.sexp_of_t sexp_of_a (to_list t)\nlet t_of_sexp a_of_sexp sexp = of_list (List.t_of_sexp a_of_sexp sexp)\n\nlet resize t size =\n let arr = Option_array.create ~len:size in\n Option_array.blit ~src:t.elts ~dst:arr ~src_pos:0 ~dst_pos:0 ~len:t.length;\n t.elts <- arr\n;;\n\nlet set_capacity t new_capacity =\n let new_capacity = max new_capacity (length t) in\n if new_capacity <> capacity t then resize t new_capacity\n;;\n\nlet push t a =\n if t.length = Option_array.length t.elts then resize t (2 * (t.length + 1));\n Option_array.set_some t.elts t.length a;\n t.length <- t.length + 1\n;;\n\nlet pop_nonempty t =\n let i = t.length - 1 in\n let result = Option_array.get_some_exn t.elts i in\n Option_array.set_none t.elts i;\n t.length <- i;\n result\n;;\n\nlet pop_error = Error.of_string \"Stack.pop of empty stack\"\nlet pop t = if is_empty t then None else Some (pop_nonempty t)\nlet pop_exn t = if is_empty t then Error.raise pop_error else pop_nonempty t\nlet top_nonempty t = Option_array.get_some_exn t.elts (t.length - 1)\nlet top_error = Error.of_string \"Stack.top of empty stack\"\nlet top t = if is_empty t then None else Some (top_nonempty t)\nlet top_exn t = if is_empty t then Error.raise top_error else top_nonempty t\nlet copy { length; elts } = { length; elts = Option_array.copy elts }\n\nlet clear t =\n if t.length > 0\n then (\n for i = 0 to t.length - 1 do\n Option_array.set_none t.elts i\n done;\n t.length <- 0)\n;;\n\nlet until_empty t f =\n let rec loop () =\n if t.length > 0\n then (\n f (pop_nonempty t);\n loop ())\n in\n loop ()\n;;\n\nlet singleton x =\n let t = create () in\n push t x;\n t\n;;\n","(***********************************************************************)\n(* *)\n(* Objective Caml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. All rights reserved. This file is distributed *)\n(* under the terms of the Apache 2.0 license. See ../THIRD-PARTY.txt *)\n(* for details. *)\n(* *)\n(***********************************************************************)\n\n(* Sets over ordered types *)\n\nopen! Import\ninclude Set_intf\n\nlet with_return = With_return.with_return\n\n\nmodule Tree0 = struct\n type 'a t =\n | Empty\n (* (Leaf x) is the same as (Node (Empty, x, Empty, 1, 1)) but uses less space. *)\n | Leaf of 'a\n (* first int is height, second is sub-tree size *)\n | Node of 'a t * 'a * 'a t * int * int\n\n type 'a tree = 'a t\n\n (* Sets are represented by balanced binary trees (the heights of the children differ by\n at most 2. *)\n let height = function\n | Empty -> 0\n | Leaf _ -> 1\n | Node (_, _, _, h, _) -> h\n ;;\n\n let length = function\n | Empty -> 0\n | Leaf _ -> 1\n | Node (_, _, _, _, s) -> s\n ;;\n\n let invariants =\n let in_range lower upper compare_elt v =\n (match lower with\n | None -> true\n | Some lower -> compare_elt lower v < 0)\n &&\n match upper with\n | None -> true\n | Some upper -> compare_elt v upper < 0\n in\n let rec loop lower upper compare_elt t =\n match t with\n | Empty -> true\n | Leaf v -> in_range lower upper compare_elt v\n | Node (l, v, r, h, n) ->\n let hl = height l\n and hr = height r in\n abs (hl - hr) <= 2\n && h = max hl hr + 1\n && n = length l + length r + 1\n && in_range lower upper compare_elt v\n && loop lower (Some v) compare_elt l\n && loop (Some v) upper compare_elt r\n in\n fun t ~compare_elt -> loop None None compare_elt t\n ;;\n\n let is_empty = function\n | Empty -> true\n | Leaf _ | Node _ -> false\n ;;\n\n (* Creates a new node with left son l, value v and right son r.\n We must have all elements of l < v < all elements of r.\n l and r must be balanced and | height l - height r | <= 2.\n Inline expansion of height for better speed. *)\n\n let create l v r =\n let hl =\n match l with\n | Empty -> 0\n | Leaf _ -> 1\n | Node (_, _, _, h, _) -> h\n in\n let hr =\n match r with\n | Empty -> 0\n | Leaf _ -> 1\n | Node (_, _, _, h, _) -> h\n in\n let h = if hl >= hr then hl + 1 else hr + 1 in\n if h = 1\n then Leaf v\n else (\n let sl =\n match l with\n | Empty -> 0\n | Leaf _ -> 1\n | Node (_, _, _, _, s) -> s\n in\n let sr =\n match r with\n | Empty -> 0\n | Leaf _ -> 1\n | Node (_, _, _, _, s) -> s\n in\n Node (l, v, r, h, sl + sr + 1))\n ;;\n\n (* We must call [f] with increasing indexes, because the bin_prot reader in\n Core_kernel.Set needs it. *)\n let of_increasing_iterator_unchecked ~len ~f =\n let rec loop n ~f i =\n match n with\n | 0 -> Empty\n | 1 ->\n let k = f i in\n Leaf k\n | 2 ->\n let kl = f i in\n let k = f (i + 1) in\n create (Leaf kl) k Empty\n | 3 ->\n let kl = f i in\n let k = f (i + 1) in\n let kr = f (i + 2) in\n create (Leaf kl) k (Leaf kr)\n | n ->\n let left_length = n lsr 1 in\n let right_length = n - left_length - 1 in\n let left = loop left_length ~f i in\n let k = f (i + left_length) in\n let right = loop right_length ~f (i + left_length + 1) in\n create left k right\n in\n loop len ~f 0\n ;;\n\n let of_sorted_array_unchecked array ~compare_elt =\n let array_length = Array.length array in\n let next =\n (* We don't check if the array is sorted or keys are duplicated, because that\n checking is slower than the whole [of_sorted_array] function *)\n if array_length < 2 || compare_elt array.(0) array.(1) < 0\n then fun i -> array.(i)\n else fun i -> array.(array_length - 1 - i)\n in\n of_increasing_iterator_unchecked ~len:array_length ~f:next\n ;;\n\n let of_sorted_array array ~compare_elt =\n match array with\n | [||] | [| _ |] -> Result.Ok (of_sorted_array_unchecked array ~compare_elt)\n | _ ->\n with_return (fun r ->\n let increasing =\n match compare_elt array.(0) array.(1) with\n | 0 ->\n r.return (Or_error.error_string \"of_sorted_array: duplicated elements\")\n | i -> i < 0\n in\n for i = 1 to Array.length array - 2 do\n match compare_elt array.(i) array.(i + 1) with\n | 0 ->\n r.return (Or_error.error_string \"of_sorted_array: duplicated elements\")\n | i ->\n if Poly.( <> ) (i < 0) increasing\n then\n r.return\n (Or_error.error_string \"of_sorted_array: elements are not ordered\")\n done;\n Result.Ok (of_sorted_array_unchecked array ~compare_elt))\n ;;\n\n (* Same as create, but performs one step of rebalancing if necessary.\n Assumes l and r balanced and | height l - height r | <= 3.\n Inline expansion of create for better speed in the most frequent case\n where no rebalancing is required. *)\n\n let bal l v r =\n let hl =\n match l with\n | Empty -> 0\n | Leaf _ -> 1\n | Node (_, _, _, h, _) -> h\n in\n let hr =\n match r with\n | Empty -> 0\n | Leaf _ -> 1\n | Node (_, _, _, h, _) -> h\n in\n if hl > hr + 2\n then (\n match l with\n | Empty -> assert false\n | Leaf _ -> assert false (* because h(l)>h(r)+2 and h(leaf)=1 *)\n | Node (ll, lv, lr, _, _) ->\n if height ll >= height lr\n then create ll lv (create lr v r)\n else (\n match lr with\n | Empty -> assert false\n | Leaf lrv ->\n assert (is_empty ll);\n create (create ll lv Empty) lrv (create Empty v r)\n | Node (lrl, lrv, lrr, _, _) -> create (create ll lv lrl) lrv (create lrr v r)))\n else if hr > hl + 2\n then (\n match r with\n | Empty -> assert false\n | Leaf rv -> create (create l v Empty) rv Empty\n | Node (rl, rv, rr, _, _) ->\n if height rr >= height rl\n then create (create l v rl) rv rr\n else (\n match rl with\n | Empty -> assert false\n | Leaf rlv ->\n assert (is_empty rr);\n create (create l v Empty) rlv (create Empty rv rr)\n | Node (rll, rlv, rlr, _, _) -> create (create l v rll) rlv (create rlr rv rr)))\n else (\n let h = if hl >= hr then hl + 1 else hr + 1 in\n let sl =\n match l with\n | Empty -> 0\n | Leaf _ -> 1\n | Node (_, _, _, _, s) -> s\n in\n let sr =\n match r with\n | Empty -> 0\n | Leaf _ -> 1\n | Node (_, _, _, _, s) -> s\n in\n if h = 1 then Leaf v else Node (l, v, r, h, sl + sr + 1))\n ;;\n\n (* Insertion of one element *)\n\n exception Same\n\n let add t x ~compare_elt =\n let rec aux = function\n | Empty -> Leaf x\n | Leaf v ->\n let c = compare_elt x v in\n if c = 0\n then raise Same\n else if c < 0\n then bal (Leaf x) v Empty\n else bal Empty v (Leaf x)\n | Node (l, v, r, _, _) ->\n let c = compare_elt x v in\n if c = 0 then raise Same else if c < 0 then bal (aux l) v r else bal l v (aux r)\n in\n try aux t with\n | Same -> t\n ;;\n\n (* Same as create and bal, but no assumptions are made on the relative heights of l and\n r. *)\n let rec join l v r ~compare_elt =\n match l, r with\n | Empty, _ -> add r v ~compare_elt\n | _, Empty -> add l v ~compare_elt\n | Leaf lv, _ -> add (add r v ~compare_elt) lv ~compare_elt\n | _, Leaf rv -> add (add l v ~compare_elt) rv ~compare_elt\n | Node (ll, lv, lr, lh, _), Node (rl, rv, rr, rh, _) ->\n if lh > rh + 2\n then bal ll lv (join lr v r ~compare_elt)\n else if rh > lh + 2\n then bal (join l v rl ~compare_elt) rv rr\n else create l v r\n ;;\n\n (* Smallest and greatest element of a set *)\n let rec min_elt = function\n | Empty -> None\n | Leaf v | Node (Empty, v, _, _, _) -> Some v\n | Node (l, _, _, _, _) -> min_elt l\n ;;\n\n exception Set_min_elt_exn_of_empty_set [@@deriving_inline sexp]\n\n let () =\n Ppx_sexp_conv_lib.Conv.Exn_converter.add\n [%extension_constructor Set_min_elt_exn_of_empty_set]\n (function\n | Set_min_elt_exn_of_empty_set ->\n Ppx_sexp_conv_lib.Sexp.Atom \"set.ml.Tree0.Set_min_elt_exn_of_empty_set\"\n | _ -> assert false)\n ;;\n\n [@@@end]\n\n exception Set_max_elt_exn_of_empty_set [@@deriving_inline sexp]\n\n let () =\n Ppx_sexp_conv_lib.Conv.Exn_converter.add\n [%extension_constructor Set_max_elt_exn_of_empty_set]\n (function\n | Set_max_elt_exn_of_empty_set ->\n Ppx_sexp_conv_lib.Sexp.Atom \"set.ml.Tree0.Set_max_elt_exn_of_empty_set\"\n | _ -> assert false)\n ;;\n\n [@@@end]\n\n let min_elt_exn t =\n match min_elt t with\n | None -> raise Set_min_elt_exn_of_empty_set\n | Some v -> v\n ;;\n\n let fold_until t ~init ~f ~finish =\n let rec fold_until_helper ~f t acc =\n match t with\n | Empty -> Continue_or_stop.Continue acc\n | Leaf value -> f acc value\n | Node (left, value, right, _, _) ->\n (match fold_until_helper ~f left acc with\n | Stop _a as x -> x\n | Continue acc ->\n (match f acc value with\n | Stop _a as x -> x\n | Continue a -> fold_until_helper ~f right a))\n in\n match fold_until_helper ~f t init with\n | Continue x -> finish x\n | Stop x -> x\n ;;\n\n let rec max_elt = function\n | Empty -> None\n | Leaf v | Node (_, v, Empty, _, _) -> Some v\n | Node (_, _, r, _, _) -> max_elt r\n ;;\n\n let max_elt_exn t =\n match max_elt t with\n | None -> raise Set_max_elt_exn_of_empty_set\n | Some v -> v\n ;;\n\n (* Remove the smallest element of the given set *)\n\n let rec remove_min_elt = function\n | Empty -> invalid_arg \"Set.remove_min_elt\"\n | Leaf _ -> Empty\n | Node (Empty, _, r, _, _) -> r\n | Node (l, v, r, _, _) -> bal (remove_min_elt l) v r\n ;;\n\n (* Merge two trees l and r into one. All elements of l must precede the elements of r.\n Assume | height l - height r | <= 2. *)\n let merge t1 t2 =\n match t1, t2 with\n | Empty, t -> t\n | t, Empty -> t\n | _, _ -> bal t1 (min_elt_exn t2) (remove_min_elt t2)\n ;;\n\n (* Merge two trees l and r into one. All elements of l must precede the elements of r.\n No assumption on the heights of l and r. *)\n let concat t1 t2 ~compare_elt =\n match t1, t2 with\n | Empty, t | t, Empty -> t\n | _, _ -> join t1 (min_elt_exn t2) (remove_min_elt t2) ~compare_elt\n ;;\n\n let split t x ~compare_elt =\n let rec split t =\n match t with\n | Empty -> Empty, None, Empty\n | Leaf v ->\n let c = compare_elt x v in\n if c = 0\n then Empty, Some v, Empty\n else if c < 0\n then Empty, None, Leaf v\n else Leaf v, None, Empty\n | Node (l, v, r, _, _) ->\n let c = compare_elt x v in\n if c = 0\n then l, Some v, r\n else if c < 0\n then (\n let ll, maybe_elt, rl = split l in\n ll, maybe_elt, join rl v r ~compare_elt)\n else (\n let lr, maybe_elt, rr = split r in\n join l v lr ~compare_elt, maybe_elt, rr)\n in\n split t\n ;;\n\n (* Implementation of the set operations *)\n\n let empty = Empty\n\n let rec mem t x ~compare_elt =\n match t with\n | Empty -> false\n | Leaf v ->\n let c = compare_elt x v in\n c = 0\n | Node (l, v, r, _, _) ->\n let c = compare_elt x v in\n c = 0 || mem (if c < 0 then l else r) x ~compare_elt\n ;;\n\n let singleton x = Leaf x\n\n let remove t x ~compare_elt =\n let rec aux t =\n match t with\n | Empty -> raise Same\n | Leaf v -> if compare_elt x v = 0 then Empty else raise Same\n | Node (l, v, r, _, _) ->\n let c = compare_elt x v in\n if c = 0 then merge l r else if c < 0 then bal (aux l) v r else bal l v (aux r)\n in\n try aux t with\n | Same -> t\n ;;\n\n let remove_index t i ~compare_elt:_ =\n let rec aux t i =\n match t with\n | Empty -> raise Same\n | Leaf _ -> if i = 0 then Empty else raise Same\n | Node (l, v, r, _, _) ->\n let l_size = length l in\n let c = Poly.compare i l_size in\n if c = 0\n then merge l r\n else if c < 0\n then bal (aux l i) v r\n else bal l v (aux r (i - l_size - 1))\n in\n try aux t i with\n | Same -> t\n ;;\n\n let union s1 s2 ~compare_elt =\n let rec union s1 s2 =\n if phys_equal s1 s2\n then s1\n else (\n match s1, s2 with\n | Empty, t | t, Empty -> t\n | Leaf v1, _ -> union (Node (Empty, v1, Empty, 1, 1)) s2\n | _, Leaf v2 -> union s1 (Node (Empty, v2, Empty, 1, 1))\n | Node (l1, v1, r1, h1, _), Node (l2, v2, r2, h2, _) ->\n if h1 >= h2\n then\n if h2 = 1\n then add s1 v2 ~compare_elt\n else (\n let l2, _, r2 = split s2 v1 ~compare_elt in\n join (union l1 l2) v1 (union r1 r2) ~compare_elt)\n else if h1 = 1\n then add s2 v1 ~compare_elt\n else (\n let l1, _, r1 = split s1 v2 ~compare_elt in\n join (union l1 l2) v2 (union r1 r2) ~compare_elt))\n in\n union s1 s2\n ;;\n\n let union_list ~comparator ~to_tree xs =\n let compare_elt = comparator.Comparator.compare in\n List.fold xs ~init:empty ~f:(fun ac x -> union ac (to_tree x) ~compare_elt)\n ;;\n\n let inter s1 s2 ~compare_elt =\n let rec inter s1 s2 =\n if phys_equal s1 s2\n then s1\n else (\n match s1, s2 with\n | Empty, _ | _, Empty -> Empty\n | (Leaf elt as singleton), other_set | other_set, (Leaf elt as singleton) ->\n if mem other_set elt ~compare_elt then singleton else Empty\n | Node (l1, v1, r1, _, _), t2 ->\n (match split t2 v1 ~compare_elt with\n | l2, None, r2 -> concat (inter l1 l2) (inter r1 r2) ~compare_elt\n | l2, Some v1, r2 -> join (inter l1 l2) v1 (inter r1 r2) ~compare_elt))\n in\n inter s1 s2\n ;;\n\n let diff s1 s2 ~compare_elt =\n let rec diff s1 s2 =\n if phys_equal s1 s2\n then Empty\n else (\n match s1, s2 with\n | Empty, _ -> Empty\n | t1, Empty -> t1\n | Leaf v1, t2 -> diff (Node (Empty, v1, Empty, 1, 1)) t2\n | Node (l1, v1, r1, _, _), t2 ->\n (match split t2 v1 ~compare_elt with\n | l2, None, r2 -> join (diff l1 l2) v1 (diff r1 r2) ~compare_elt\n | l2, Some _, r2 -> concat (diff l1 l2) (diff r1 r2) ~compare_elt))\n in\n diff s1 s2\n ;;\n\n module Enum = struct\n type increasing\n type decreasing\n\n type ('a, 'direction) t =\n | End\n | More of 'a * 'a tree * ('a, 'direction) t\n\n let rec cons s (e : (_, increasing) t) : (_, increasing) t =\n match s with\n | Empty -> e\n | Leaf v -> More (v, Empty, e)\n | Node (l, v, r, _, _) -> cons l (More (v, r, e))\n ;;\n\n let rec cons_right s (e : (_, decreasing) t) : (_, decreasing) t =\n match s with\n | Empty -> e\n | Leaf v -> More (v, Empty, e)\n | Node (l, v, r, _, _) -> cons_right r (More (v, l, e))\n ;;\n\n let of_set s : (_, increasing) t = cons s End\n let of_set_right s : (_, decreasing) t = cons_right s End\n\n let starting_at_increasing t key compare : (_, increasing) t =\n let rec loop t e =\n match t with\n | Empty -> e\n | Leaf v -> loop (Node (Empty, v, Empty, 1, 1)) e\n | Node (_, v, r, _, _) when compare v key < 0 -> loop r e\n | Node (l, v, r, _, _) -> loop l (More (v, r, e))\n in\n loop t End\n ;;\n\n let starting_at_decreasing t key compare : (_, decreasing) t =\n let rec loop t e =\n match t with\n | Empty -> e\n | Leaf v -> loop (Node (Empty, v, Empty, 1, 1)) e\n | Node (l, v, _, _, _) when compare v key > 0 -> loop l e\n | Node (l, v, r, _, _) -> loop r (More (v, l, e))\n in\n loop t End\n ;;\n\n let compare compare_elt e1 e2 =\n let rec loop e1 e2 =\n match e1, e2 with\n | End, End -> 0\n | End, _ -> -1\n | _, End -> 1\n | More (v1, r1, e1), More (v2, r2, e2) ->\n let c = compare_elt v1 v2 in\n if c <> 0\n then c\n else if phys_equal r1 r2\n then loop e1 e2\n else loop (cons r1 e1) (cons r2 e2)\n in\n loop e1 e2\n ;;\n\n let rec iter ~f = function\n | End -> ()\n | More (a, tree, enum) ->\n f a;\n iter (cons tree enum) ~f\n ;;\n\n let iter2 compare_elt t1 t2 ~f =\n let rec loop t1 t2 =\n match t1, t2 with\n | End, End -> ()\n | End, _ -> iter t2 ~f:(fun a -> f (`Right a))\n | _, End -> iter t1 ~f:(fun a -> f (`Left a))\n | More (a1, tree1, enum1), More (a2, tree2, enum2) ->\n let compare_result = compare_elt a1 a2 in\n if compare_result = 0\n then (\n f (`Both (a1, a2));\n loop (cons tree1 enum1) (cons tree2 enum2))\n else if compare_result < 0\n then (\n f (`Left a1);\n loop (cons tree1 enum1) t2)\n else (\n f (`Right a2);\n loop t1 (cons tree2 enum2))\n in\n loop t1 t2\n ;;\n\n let symmetric_diff t1 t2 ~compare_elt =\n let step state : ((_, _) Either.t, _) Sequence.Step.t =\n match state with\n | End, End -> Done\n | End, More (elt, tree, enum) -> Yield (Second elt, (End, cons tree enum))\n | More (elt, tree, enum), End -> Yield (First elt, (cons tree enum, End))\n | (More (a1, tree1, enum1) as left), (More (a2, tree2, enum2) as right) ->\n let compare_result = compare_elt a1 a2 in\n if compare_result = 0\n then (\n let next_state =\n if phys_equal tree1 tree2\n then enum1, enum2\n else cons tree1 enum1, cons tree2 enum2\n in\n Skip next_state)\n else if compare_result < 0\n then Yield (First a1, (cons tree1 enum1, right))\n else Yield (Second a2, (left, cons tree2 enum2))\n in\n Sequence.unfold_step ~init:(of_set t1, of_set t2) ~f:step\n ;;\n end\n\n let to_sequence_increasing comparator ~from_elt t =\n let next enum =\n match enum with\n | Enum.End -> Sequence.Step.Done\n | Enum.More (k, t, e) -> Sequence.Step.Yield (k, Enum.cons t e)\n in\n let init =\n match from_elt with\n | None -> Enum.of_set t\n | Some key -> Enum.starting_at_increasing t key comparator.Comparator.compare\n in\n Sequence.unfold_step ~init ~f:next\n ;;\n\n let to_sequence_decreasing comparator ~from_elt t =\n let next enum =\n match enum with\n | Enum.End -> Sequence.Step.Done\n | Enum.More (k, t, e) -> Sequence.Step.Yield (k, Enum.cons_right t e)\n in\n let init =\n match from_elt with\n | None -> Enum.of_set_right t\n | Some key -> Enum.starting_at_decreasing t key comparator.Comparator.compare\n in\n Sequence.unfold_step ~init ~f:next\n ;;\n\n let to_sequence\n comparator\n ?(order = `Increasing)\n ?greater_or_equal_to\n ?less_or_equal_to\n t\n =\n let inclusive_bound side t bound =\n let compare_elt = comparator.Comparator.compare in\n let l, maybe, r = split t bound ~compare_elt in\n let t = side (l, r) in\n match maybe with\n | None -> t\n | Some elt -> add t elt ~compare_elt\n in\n match order with\n | `Increasing ->\n let t = Option.fold less_or_equal_to ~init:t ~f:(inclusive_bound fst) in\n to_sequence_increasing comparator ~from_elt:greater_or_equal_to t\n | `Decreasing ->\n let t = Option.fold greater_or_equal_to ~init:t ~f:(inclusive_bound snd) in\n to_sequence_decreasing comparator ~from_elt:less_or_equal_to t\n ;;\n\n\n let rec find_first_satisfying t ~f =\n match t with\n | Empty -> None\n | Leaf v -> if f v then Some v else None\n | Node (l, v, r, _, _) ->\n if f v\n then (\n match find_first_satisfying l ~f with\n | None -> Some v\n | Some _ as x -> x)\n else find_first_satisfying r ~f\n ;;\n\n let rec find_last_satisfying t ~f =\n match t with\n | Empty -> None\n | Leaf v -> if f v then Some v else None\n | Node (l, v, r, _, _) ->\n if f v\n then (\n match find_last_satisfying r ~f with\n | None -> Some v\n | Some _ as x -> x)\n else find_last_satisfying l ~f\n ;;\n\n let binary_search t ~compare how v =\n match how with\n | `Last_strictly_less_than -> find_last_satisfying t ~f:(fun x -> compare x v < 0)\n | `Last_less_than_or_equal_to ->\n find_last_satisfying t ~f:(fun x -> compare x v <= 0)\n | `First_equal_to ->\n (match find_first_satisfying t ~f:(fun x -> compare x v >= 0) with\n | Some x as elt when compare x v = 0 -> elt\n | None | Some _ -> None)\n | `Last_equal_to ->\n (match find_last_satisfying t ~f:(fun x -> compare x v <= 0) with\n | Some x as elt when compare x v = 0 -> elt\n | None | Some _ -> None)\n | `First_greater_than_or_equal_to ->\n find_first_satisfying t ~f:(fun x -> compare x v >= 0)\n | `First_strictly_greater_than ->\n find_first_satisfying t ~f:(fun x -> compare x v > 0)\n ;;\n\n let binary_search_segmented t ~segment_of how =\n let is_left x =\n match segment_of x with\n | `Left -> true\n | `Right -> false\n in\n let is_right x = not (is_left x) in\n match how with\n | `Last_on_left -> find_last_satisfying t ~f:is_left\n | `First_on_right -> find_first_satisfying t ~f:is_right\n ;;\n\n let merge_to_sequence\n comparator\n ?(order = `Increasing)\n ?greater_or_equal_to\n ?less_or_equal_to\n t\n t'\n =\n Sequence.merge_with_duplicates\n (to_sequence comparator ~order ?greater_or_equal_to ?less_or_equal_to t)\n (to_sequence comparator ~order ?greater_or_equal_to ?less_or_equal_to t')\n ~compare:\n (match order with\n | `Increasing -> comparator.compare\n | `Decreasing -> Fn.flip comparator.compare)\n ;;\n\n let compare compare_elt s1 s2 =\n Enum.compare compare_elt (Enum.of_set s1) (Enum.of_set s2)\n ;;\n\n let iter2 s1 s2 ~compare_elt = Enum.iter2 compare_elt (Enum.of_set s1) (Enum.of_set s2)\n let equal s1 s2 ~compare_elt = compare compare_elt s1 s2 = 0\n\n let is_subset s1 ~of_:s2 ~compare_elt =\n let rec is_subset s1 ~of_:s2 =\n match s1, s2 with\n | Empty, _ -> true\n | _, Empty -> false\n | Leaf v1, t2 -> mem t2 v1 ~compare_elt\n | Node (l1, v1, r1, _, _), Leaf v2 ->\n (match l1, r1 with\n | Empty, Empty ->\n (* This case shouldn't occur in practice because we should have constructed\n a Leaf rather than a Node with two Empty subtrees *)\n compare_elt v1 v2 = 0\n | _, _ -> false)\n | Node (l1, v1, r1, _, _), (Node (l2, v2, r2, _, _) as t2) ->\n let c = compare_elt v1 v2 in\n if c = 0\n then\n phys_equal s1 s2 || (is_subset l1 ~of_:l2 && is_subset r1 ~of_:r2)\n (* Note that height and size don't matter here. *)\n else if c < 0\n then is_subset (Node (l1, v1, Empty, 0, 0)) ~of_:l2 && is_subset r1 ~of_:t2\n else is_subset (Node (Empty, v1, r1, 0, 0)) ~of_:r2 && is_subset l1 ~of_:t2\n in\n is_subset s1 ~of_:s2\n ;;\n\n let rec are_disjoint s1 s2 ~compare_elt =\n match s1, s2 with\n | Empty, _ | _, Empty -> true\n | Leaf elt, other_set | other_set, Leaf elt -> not (mem other_set elt ~compare_elt)\n | Node (l1, v1, r1, _, _), t2 ->\n if phys_equal s1 s2\n then false\n else (\n match split t2 v1 ~compare_elt with\n | l2, None, r2 ->\n are_disjoint l1 l2 ~compare_elt && are_disjoint r1 r2 ~compare_elt\n | _, Some _, _ -> false)\n ;;\n\n let iter t ~f =\n let rec iter = function\n | Empty -> ()\n | Leaf v -> f v\n | Node (l, v, r, _, _) ->\n iter l;\n f v;\n iter r\n in\n iter t\n ;;\n\n let symmetric_diff = Enum.symmetric_diff\n\n let rec fold s ~init:accu ~f =\n match s with\n | Empty -> accu\n | Leaf v -> f accu v\n | Node (l, v, r, _, _) -> fold ~f r ~init:(f (fold ~f l ~init:accu) v)\n ;;\n\n let hash_fold_t_ignoring_structure hash_fold_elem state t =\n fold t ~init:(hash_fold_int state (length t)) ~f:hash_fold_elem\n ;;\n\n let count t ~f = Container.count ~fold t ~f\n let sum m t ~f = Container.sum ~fold m t ~f\n\n let rec fold_right s ~init:accu ~f =\n match s with\n | Empty -> accu\n | Leaf v -> f v accu\n | Node (l, v, r, _, _) -> fold_right ~f l ~init:(f v (fold_right ~f r ~init:accu))\n ;;\n\n let rec for_all t ~f:p =\n match t with\n | Empty -> true\n | Leaf v -> p v\n | Node (l, v, r, _, _) -> p v && for_all ~f:p l && for_all ~f:p r\n ;;\n\n let rec exists t ~f:p =\n match t with\n | Empty -> false\n | Leaf v -> p v\n | Node (l, v, r, _, _) -> p v || exists ~f:p l || exists ~f:p r\n ;;\n\n let filter s ~f:p ~compare_elt =\n let rec filt accu = function\n | Empty -> accu\n | Leaf v -> if p v then add accu v ~compare_elt else accu\n | Node (l, v, r, _, _) ->\n filt (filt (if p v then add accu v ~compare_elt else accu) l) r\n in\n filt Empty s\n ;;\n\n let filter_map s ~f:p ~compare_elt =\n let rec filt accu = function\n | Empty -> accu\n | Leaf v ->\n (match p v with\n | None -> accu\n | Some v -> add accu v ~compare_elt)\n | Node (l, v, r, _, _) ->\n filt\n (filt\n (match p v with\n | None -> accu\n | Some v -> add accu v ~compare_elt)\n l)\n r\n in\n filt Empty s\n ;;\n\n let partition_tf s ~f:p ~compare_elt =\n let rec part ((t, f) as accu) = function\n | Empty -> accu\n | Leaf v -> if p v then add t v ~compare_elt, f else t, add f v ~compare_elt\n | Node (l, v, r, _, _) ->\n part\n (part (if p v then add t v ~compare_elt, f else t, add f v ~compare_elt) l)\n r\n in\n part (Empty, Empty) s\n ;;\n\n let rec elements_aux accu = function\n | Empty -> accu\n | Leaf v -> v :: accu\n | Node (l, v, r, _, _) -> elements_aux (v :: elements_aux accu r) l\n ;;\n\n let elements s = elements_aux [] s\n\n let choose t =\n match t with\n | Empty -> None\n | Leaf v -> Some v\n | Node (_, v, _, _, _) -> Some v\n ;;\n\n let choose_exn =\n let not_found = Not_found_s (Atom \"Set.choose_exn: empty set\") in\n let choose_exn t =\n match choose t with\n | None -> raise not_found\n | Some v -> v\n in\n (* named to preserve symbol in compiled binary *)\n choose_exn\n ;;\n\n let of_list lst ~compare_elt =\n List.fold lst ~init:empty ~f:(fun t x -> add t x ~compare_elt)\n ;;\n\n let to_list s = elements s\n\n let of_array a ~compare_elt =\n Array.fold a ~init:empty ~f:(fun t x -> add t x ~compare_elt)\n ;;\n\n (* faster but equivalent to [Array.of_list (to_list t)] *)\n let to_array = function\n | Empty -> [||]\n | Leaf v -> [| v |]\n | Node (l, v, r, _, s) ->\n let res = Array.create ~len:s v in\n let pos_ref = ref 0 in\n let rec loop = function\n (* Invariant: on entry and on exit to [loop], !pos_ref is the next\n available cell in the array. *)\n | Empty -> ()\n | Leaf v ->\n res.(!pos_ref) <- v;\n incr pos_ref\n | Node (l, v, r, _, _) ->\n loop l;\n res.(!pos_ref) <- v;\n incr pos_ref;\n loop r\n in\n loop l;\n (* res.(!pos_ref) is already initialized (by Array.create ~len:above). *)\n incr pos_ref;\n loop r;\n res\n ;;\n\n let map t ~f ~compare_elt = fold t ~init:empty ~f:(fun t x -> add t (f x) ~compare_elt)\n\n let group_by set ~equiv ~compare_elt =\n let rec loop set equiv_classes =\n if is_empty set\n then equiv_classes\n else (\n let x = choose_exn set in\n let equiv_x, not_equiv_x =\n partition_tf set ~f:(fun elt -> phys_equal x elt || equiv x elt) ~compare_elt\n in\n loop not_equiv_x (equiv_x :: equiv_classes))\n in\n loop set []\n ;;\n\n let rec find t ~f =\n match t with\n | Empty -> None\n | Leaf v -> if f v then Some v else None\n | Node (l, v, r, _, _) ->\n if f v\n then Some v\n else (\n match find l ~f with\n | None -> find r ~f\n | Some _ as r -> r)\n ;;\n\n let rec find_map t ~f =\n match t with\n | Empty -> None\n | Leaf v -> f v\n | Node (l, v, r, _, _) ->\n (match f v with\n | Some _ as r -> r\n | None ->\n (match find_map l ~f with\n | None -> find_map r ~f\n | Some _ as r -> r))\n ;;\n\n let find_exn t ~f =\n match find t ~f with\n | None -> failwith \"Set.find_exn failed to find a matching element\"\n | Some e -> e\n ;;\n\n let rec nth t i =\n match t with\n | Empty -> None\n | Leaf v -> if i = 0 then Some v else None\n | Node (l, v, r, _, s) ->\n if i >= s\n then None\n else (\n let l_size = length l in\n let c = Poly.compare i l_size in\n if c < 0 then nth l i else if c = 0 then Some v else nth r (i - l_size - 1))\n ;;\n\n let stable_dedup_list xs ~compare_elt =\n let rec loop xs leftovers already_seen =\n match xs with\n | [] -> List.rev leftovers\n | hd :: tl ->\n if mem already_seen hd ~compare_elt\n then loop tl leftovers already_seen\n else loop tl (hd :: leftovers) (add already_seen hd ~compare_elt)\n in\n loop xs [] empty\n ;;\n\n let t_of_sexp_direct a_of_sexp sexp ~compare_elt =\n match sexp with\n | Sexp.List lst ->\n let elt_lst = List.map lst ~f:a_of_sexp in\n let set = of_list elt_lst ~compare_elt in\n if length set = List.length lst\n then set\n else (\n let set = ref empty in\n List.iter2_exn lst elt_lst ~f:(fun el_sexp el ->\n if mem !set el ~compare_elt\n then of_sexp_error \"Set.t_of_sexp: duplicate element in set\" el_sexp\n else set := add !set el ~compare_elt);\n assert false)\n | sexp -> of_sexp_error \"Set.t_of_sexp: list needed\" sexp\n ;;\n\n let sexp_of_t sexp_of_a t =\n Sexp.List (fold_right t ~init:[] ~f:(fun el acc -> sexp_of_a el :: acc))\n ;;\n\n module Named = struct\n type nonrec ('a, 'cmp) t =\n { tree : 'a t\n ; name : string\n }\n\n let is_subset (subset : _ t) ~of_:(superset : _ t) ~sexp_of_elt ~compare_elt =\n let invalid_elements = diff subset.tree superset.tree ~compare_elt in\n if is_empty invalid_elements\n then Ok ()\n else (\n let invalid_elements_sexp = sexp_of_t sexp_of_elt invalid_elements in\n Or_error.error_s\n (Sexp.message\n (subset.name ^ \" is not a subset of \" ^ superset.name)\n [ \"invalid_elements\", invalid_elements_sexp ]))\n ;;\n\n let equal s1 s2 ~sexp_of_elt ~compare_elt =\n Or_error.combine_errors_unit\n [ is_subset s1 ~of_:s2 ~sexp_of_elt ~compare_elt\n ; is_subset s2 ~of_:s1 ~sexp_of_elt ~compare_elt\n ]\n ;;\n end\nend\n\ntype ('a, 'comparator) t =\n { (* [comparator] is the first field so that polymorphic equality fails on a map due\n to the functional value in the comparator.\n Note that this does not affect polymorphic [compare]: that still produces\n nonsense. *)\n comparator : ('a, 'comparator) Comparator.t\n ; tree : 'a Tree0.t\n }\n\ntype ('a, 'comparator) tree = 'a Tree0.t\n\nlet like { tree = _; comparator } tree = { tree; comparator }\nlet compare_elt t = t.comparator.Comparator.compare\n\nmodule Accessors = struct\n let comparator t = t.comparator\n let invariants t = Tree0.invariants t.tree ~compare_elt:(compare_elt t)\n let length t = Tree0.length t.tree\n let is_empty t = Tree0.is_empty t.tree\n let elements t = Tree0.elements t.tree\n let min_elt t = Tree0.min_elt t.tree\n let min_elt_exn t = Tree0.min_elt_exn t.tree\n let max_elt t = Tree0.max_elt t.tree\n let max_elt_exn t = Tree0.max_elt_exn t.tree\n let choose t = Tree0.choose t.tree\n let choose_exn t = Tree0.choose_exn t.tree\n let to_list t = Tree0.to_list t.tree\n let to_array t = Tree0.to_array t.tree\n let fold t ~init ~f = Tree0.fold t.tree ~init ~f\n let fold_until t ~init ~f = Tree0.fold_until t.tree ~init ~f\n let fold_right t ~init ~f = Tree0.fold_right t.tree ~init ~f\n let fold_result t ~init ~f = Container.fold_result ~fold ~init ~f t\n let iter t ~f = Tree0.iter t.tree ~f\n let iter2 a b ~f = Tree0.iter2 a.tree b.tree ~f ~compare_elt:(compare_elt a)\n let exists t ~f = Tree0.exists t.tree ~f\n let for_all t ~f = Tree0.for_all t.tree ~f\n let count t ~f = Tree0.count t.tree ~f\n let sum m t ~f = Tree0.sum m t.tree ~f\n let find t ~f = Tree0.find t.tree ~f\n let find_exn t ~f = Tree0.find_exn t.tree ~f\n let find_map t ~f = Tree0.find_map t.tree ~f\n let mem t a = Tree0.mem t.tree a ~compare_elt:(compare_elt t)\n let filter t ~f = like t (Tree0.filter t.tree ~f ~compare_elt:(compare_elt t))\n let add t a = like t (Tree0.add t.tree a ~compare_elt:(compare_elt t))\n let remove t a = like t (Tree0.remove t.tree a ~compare_elt:(compare_elt t))\n let union t1 t2 = like t1 (Tree0.union t1.tree t2.tree ~compare_elt:(compare_elt t1))\n let inter t1 t2 = like t1 (Tree0.inter t1.tree t2.tree ~compare_elt:(compare_elt t1))\n let diff t1 t2 = like t1 (Tree0.diff t1.tree t2.tree ~compare_elt:(compare_elt t1))\n\n let symmetric_diff t1 t2 =\n Tree0.symmetric_diff t1.tree t2.tree ~compare_elt:(compare_elt t1)\n ;;\n\n let compare_direct t1 t2 = Tree0.compare (compare_elt t1) t1.tree t2.tree\n let equal t1 t2 = Tree0.equal t1.tree t2.tree ~compare_elt:(compare_elt t1)\n\n let is_subset t ~of_ =\n Tree0.is_subset t.tree ~of_:of_.tree ~compare_elt:(compare_elt t)\n ;;\n\n let are_disjoint t1 t2 =\n Tree0.are_disjoint t1.tree t2.tree ~compare_elt:(compare_elt t1)\n ;;\n\n module Named = struct\n type nonrec ('a, 'cmp) t =\n { set : ('a, 'cmp) t\n ; name : string\n }\n\n let to_named_tree { set; name } = { Tree0.Named.tree = set.tree; name }\n\n let is_subset (subset : (_, _) t) ~of_:(superset : (_, _) t) =\n Tree0.Named.is_subset\n (to_named_tree subset)\n ~of_:(to_named_tree superset)\n ~compare_elt:(compare_elt subset.set)\n ~sexp_of_elt:subset.set.comparator.sexp_of_t\n ;;\n\n let equal t1 t2 =\n Or_error.combine_errors_unit [ is_subset t1 ~of_:t2; is_subset t2 ~of_:t1 ]\n ;;\n end\n\n let partition_tf t ~f =\n let tree_t, tree_f = Tree0.partition_tf t.tree ~f ~compare_elt:(compare_elt t) in\n like t tree_t, like t tree_f\n ;;\n\n let split t a =\n let tree1, b, tree2 = Tree0.split t.tree a ~compare_elt:(compare_elt t) in\n like t tree1, b, like t tree2\n ;;\n\n let group_by t ~equiv =\n List.map (Tree0.group_by t.tree ~equiv ~compare_elt:(compare_elt t)) ~f:(like t)\n ;;\n\n let nth t i = Tree0.nth t.tree i\n\n let remove_index t i =\n like t (Tree0.remove_index t.tree i ~compare_elt:(compare_elt t))\n ;;\n\n let sexp_of_t sexp_of_a _ t = Tree0.sexp_of_t sexp_of_a t.tree\n\n let to_sequence ?order ?greater_or_equal_to ?less_or_equal_to t =\n Tree0.to_sequence t.comparator ?order ?greater_or_equal_to ?less_or_equal_to t.tree\n ;;\n\n let binary_search t ~compare how v = Tree0.binary_search t.tree ~compare how v\n\n let binary_search_segmented t ~segment_of how =\n Tree0.binary_search_segmented t.tree ~segment_of how\n ;;\n\n let merge_to_sequence ?order ?greater_or_equal_to ?less_or_equal_to t t' =\n Tree0.merge_to_sequence\n t.comparator\n ?order\n ?greater_or_equal_to\n ?less_or_equal_to\n t.tree\n t'.tree\n ;;\n\n let hash_fold_direct hash_fold_key state t =\n Tree0.hash_fold_t_ignoring_structure hash_fold_key state t.tree\n ;;\nend\n\ninclude Accessors\n\nlet compare _ _ t1 t2 = compare_direct t1 t2\n\nmodule Tree = struct\n type ('a, 'comparator) t = ('a, 'comparator) tree\n\n let ce comparator = comparator.Comparator.compare\n\n let t_of_sexp_direct ~comparator a_of_sexp sexp =\n Tree0.t_of_sexp_direct ~compare_elt:(ce comparator) a_of_sexp sexp\n ;;\n\n let empty_without_value_restriction = Tree0.empty\n let empty ~comparator:_ = empty_without_value_restriction\n let singleton ~comparator:_ e = Tree0.singleton e\n let length t = Tree0.length t\n let invariants ~comparator t = Tree0.invariants t ~compare_elt:(ce comparator)\n let is_empty t = Tree0.is_empty t\n let elements t = Tree0.elements t\n let min_elt t = Tree0.min_elt t\n let min_elt_exn t = Tree0.min_elt_exn t\n let max_elt t = Tree0.max_elt t\n let max_elt_exn t = Tree0.max_elt_exn t\n let choose t = Tree0.choose t\n let choose_exn t = Tree0.choose_exn t\n let to_list t = Tree0.to_list t\n let to_array t = Tree0.to_array t\n let iter t ~f = Tree0.iter t ~f\n let exists t ~f = Tree0.exists t ~f\n let for_all t ~f = Tree0.for_all t ~f\n let count t ~f = Tree0.count t ~f\n let sum m t ~f = Tree0.sum m t ~f\n let find t ~f = Tree0.find t ~f\n let find_exn t ~f = Tree0.find_exn t ~f\n let find_map t ~f = Tree0.find_map t ~f\n let fold t ~init ~f = Tree0.fold t ~init ~f\n let fold_until t ~init ~f = Tree0.fold_until t ~init ~f\n let fold_right t ~init ~f = Tree0.fold_right t ~init ~f\n let map ~comparator t ~f = Tree0.map t ~f ~compare_elt:(ce comparator)\n let filter ~comparator t ~f = Tree0.filter t ~f ~compare_elt:(ce comparator)\n let filter_map ~comparator t ~f = Tree0.filter_map t ~f ~compare_elt:(ce comparator)\n\n let partition_tf ~comparator t ~f =\n Tree0.partition_tf t ~f ~compare_elt:(ce comparator)\n ;;\n\n let iter2 ~comparator a b ~f = Tree0.iter2 a b ~f ~compare_elt:(ce comparator)\n let mem ~comparator t a = Tree0.mem t a ~compare_elt:(ce comparator)\n let add ~comparator t a = Tree0.add t a ~compare_elt:(ce comparator)\n let remove ~comparator t a = Tree0.remove t a ~compare_elt:(ce comparator)\n let union ~comparator t1 t2 = Tree0.union t1 t2 ~compare_elt:(ce comparator)\n let inter ~comparator t1 t2 = Tree0.inter t1 t2 ~compare_elt:(ce comparator)\n let diff ~comparator t1 t2 = Tree0.diff t1 t2 ~compare_elt:(ce comparator)\n\n let symmetric_diff ~comparator t1 t2 =\n Tree0.symmetric_diff t1 t2 ~compare_elt:(ce comparator)\n ;;\n\n let compare_direct ~comparator t1 t2 = Tree0.compare (ce comparator) t1 t2\n let equal ~comparator t1 t2 = Tree0.equal t1 t2 ~compare_elt:(ce comparator)\n let is_subset ~comparator t ~of_ = Tree0.is_subset t ~of_ ~compare_elt:(ce comparator)\n\n let are_disjoint ~comparator t1 t2 =\n Tree0.are_disjoint t1 t2 ~compare_elt:(ce comparator)\n ;;\n\n let of_list ~comparator l = Tree0.of_list l ~compare_elt:(ce comparator)\n let of_array ~comparator a = Tree0.of_array a ~compare_elt:(ce comparator)\n\n let of_sorted_array_unchecked ~comparator a =\n Tree0.of_sorted_array_unchecked a ~compare_elt:(ce comparator)\n ;;\n\n let of_increasing_iterator_unchecked ~comparator:_ ~len ~f =\n Tree0.of_increasing_iterator_unchecked ~len ~f\n ;;\n\n let of_sorted_array ~comparator a =\n Tree0.of_sorted_array a ~compare_elt:(ce comparator)\n ;;\n\n let union_list ~comparator l = Tree0.union_list l ~to_tree:Fn.id ~comparator\n\n let stable_dedup_list ~comparator xs =\n Tree0.stable_dedup_list xs ~compare_elt:(ce comparator)\n ;;\n\n let group_by ~comparator t ~equiv =\n Tree0.group_by t ~equiv ~compare_elt:(ce comparator)\n ;;\n\n let split ~comparator t a = Tree0.split t a ~compare_elt:(ce comparator)\n let nth t i = Tree0.nth t i\n let remove_index ~comparator t i = Tree0.remove_index t i ~compare_elt:(ce comparator)\n let sexp_of_t sexp_of_a _ t = Tree0.sexp_of_t sexp_of_a t\n let to_tree t = t\n let of_tree ~comparator:_ t = t\n\n let to_sequence ~comparator ?order ?greater_or_equal_to ?less_or_equal_to t =\n Tree0.to_sequence comparator ?order ?greater_or_equal_to ?less_or_equal_to t\n ;;\n\n let binary_search ~comparator:_ t ~compare how v = Tree0.binary_search t ~compare how v\n\n let binary_search_segmented ~comparator:_ t ~segment_of how =\n Tree0.binary_search_segmented t ~segment_of how\n ;;\n\n let merge_to_sequence ~comparator ?order ?greater_or_equal_to ?less_or_equal_to t t' =\n Tree0.merge_to_sequence comparator ?order ?greater_or_equal_to ?less_or_equal_to t t'\n ;;\n\n let fold_result t ~init ~f = Container.fold_result ~fold ~init ~f t\n\n module Named = struct\n include Tree0.Named\n\n let is_subset ~comparator t1 ~of_:t2 =\n Tree0.Named.is_subset\n t1\n ~of_:t2\n ~compare_elt:(ce comparator)\n ~sexp_of_elt:comparator.Comparator.sexp_of_t\n ;;\n\n let equal ~comparator t1 t2 =\n Tree0.Named.equal\n t1\n t2\n ~compare_elt:(ce comparator)\n ~sexp_of_elt:comparator.Comparator.sexp_of_t\n ;;\n end\nend\n\nmodule Using_comparator = struct\n type nonrec ('elt, 'cmp) t = ('elt, 'cmp) t\n\n include Accessors\n\n let to_tree t = t.tree\n let of_tree ~comparator tree = { comparator; tree }\n\n let t_of_sexp_direct ~comparator a_of_sexp sexp =\n of_tree\n ~comparator\n (Tree0.t_of_sexp_direct ~compare_elt:comparator.compare a_of_sexp sexp)\n ;;\n\n let empty ~comparator = { comparator; tree = Tree0.empty }\n\n module Empty_without_value_restriction (Elt : Comparator.S1) = struct\n let empty = { comparator = Elt.comparator; tree = Tree0.empty }\n end\n\n let singleton ~comparator e = { comparator; tree = Tree0.singleton e }\n\n let union_list ~comparator l =\n of_tree ~comparator (Tree0.union_list ~comparator ~to_tree l)\n ;;\n\n let of_sorted_array_unchecked ~comparator array =\n let tree =\n Tree0.of_sorted_array_unchecked array ~compare_elt:comparator.Comparator.compare\n in\n { comparator; tree }\n ;;\n\n let of_increasing_iterator_unchecked ~comparator ~len ~f =\n of_tree ~comparator (Tree0.of_increasing_iterator_unchecked ~len ~f)\n ;;\n\n let of_sorted_array ~comparator array =\n Or_error.Monad_infix.(\n Tree0.of_sorted_array array ~compare_elt:comparator.Comparator.compare\n >>| fun tree -> { comparator; tree })\n ;;\n\n let of_list ~comparator l =\n { comparator; tree = Tree0.of_list l ~compare_elt:comparator.Comparator.compare }\n ;;\n\n let of_array ~comparator a =\n { comparator; tree = Tree0.of_array a ~compare_elt:comparator.Comparator.compare }\n ;;\n\n let stable_dedup_list ~comparator xs =\n Tree0.stable_dedup_list xs ~compare_elt:comparator.Comparator.compare\n ;;\n\n let map ~comparator t ~f =\n { comparator; tree = Tree0.map t.tree ~f ~compare_elt:comparator.Comparator.compare }\n ;;\n\n let filter_map ~comparator t ~f =\n { comparator\n ; tree = Tree0.filter_map t.tree ~f ~compare_elt:comparator.Comparator.compare\n }\n ;;\n\n module Tree = Tree\nend\n\ntype ('elt, 'cmp) comparator =\n (module Comparator.S with type t = 'elt and type comparator_witness = 'cmp)\n\nlet comparator_s (type k cmp) t : (k, cmp) comparator =\n (module struct\n type t = k\n type comparator_witness = cmp\n\n let comparator = t.comparator\n end)\n;;\n\nlet to_comparator (type elt cmp) ((module M) : (elt, cmp) comparator) = M.comparator\nlet empty m = Using_comparator.empty ~comparator:(to_comparator m)\nlet singleton m a = Using_comparator.singleton ~comparator:(to_comparator m) a\nlet union_list m a = Using_comparator.union_list ~comparator:(to_comparator m) a\n\nlet of_sorted_array_unchecked m a =\n Using_comparator.of_sorted_array_unchecked ~comparator:(to_comparator m) a\n;;\n\nlet of_increasing_iterator_unchecked m ~len ~f =\n Using_comparator.of_increasing_iterator_unchecked ~comparator:(to_comparator m) ~len ~f\n;;\n\nlet of_sorted_array m a =\n Using_comparator.of_sorted_array ~comparator:(to_comparator m) a\n;;\n\nlet of_list m a = Using_comparator.of_list ~comparator:(to_comparator m) a\nlet of_array m a = Using_comparator.of_array ~comparator:(to_comparator m) a\n\nlet stable_dedup_list m a =\n Using_comparator.stable_dedup_list ~comparator:(to_comparator m) a\n;;\n\nlet map m a ~f = Using_comparator.map ~comparator:(to_comparator m) a ~f\nlet filter_map m a ~f = Using_comparator.filter_map ~comparator:(to_comparator m) a ~f\n\nmodule M (Elt : sig\n type t\n type comparator_witness\n end) =\nstruct\n type nonrec t = (Elt.t, Elt.comparator_witness) t\nend\n\nmodule type Sexp_of_m = sig\n type t [@@deriving_inline sexp_of]\n\n val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t\n\n [@@@end]\nend\n\nmodule type M_of_sexp = sig\n type t [@@deriving_inline of_sexp]\n\n val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t\n\n [@@@end]\n\n include Comparator.S with type t := t\nend\n\nmodule type Compare_m = sig end\nmodule type Equal_m = sig end\nmodule type Hash_fold_m = Hasher.S\n\nlet sexp_of_m__t (type elt) (module Elt : Sexp_of_m with type t = elt) t =\n sexp_of_t Elt.sexp_of_t (fun _ -> Sexp.Atom \"_\") t\n;;\n\nlet m__t_of_sexp\n (type elt cmp)\n (module Elt : M_of_sexp with type t = elt and type comparator_witness = cmp)\n sexp\n =\n Using_comparator.t_of_sexp_direct ~comparator:Elt.comparator Elt.t_of_sexp sexp\n;;\n\nlet compare_m__t (module Elt : Compare_m) t1 t2 = compare_direct t1 t2\nlet equal_m__t (module Elt : Equal_m) t1 t2 = equal t1 t2\n\nlet hash_fold_m__t (type elt) (module Elt : Hash_fold_m with type t = elt) state =\n hash_fold_direct Elt.hash_fold_t state\n;;\n\nlet hash_m__t folder t =\n let state = hash_fold_m__t folder (Hash.create ()) t in\n Hash.get_hash_value state\n;;\n\nmodule Poly = struct\n type comparator_witness = Comparator.Poly.comparator_witness\n type nonrec ('elt, 'cmp) set = ('elt, comparator_witness) t\n type nonrec 'elt t = ('elt, comparator_witness) t\n type nonrec 'elt tree = ('elt, comparator_witness) tree\n type nonrec 'elt named = ('elt, comparator_witness) Named.t\n\n include Accessors\n\n let comparator = Comparator.Poly.comparator\n\n include Using_comparator.Empty_without_value_restriction (Comparator.Poly)\n\n let singleton a = Using_comparator.singleton ~comparator a\n let union_list a = Using_comparator.union_list ~comparator a\n\n let of_sorted_array_unchecked a =\n Using_comparator.of_sorted_array_unchecked ~comparator a\n ;;\n\n let of_increasing_iterator_unchecked ~len ~f =\n Using_comparator.of_increasing_iterator_unchecked ~comparator ~len ~f\n ;;\n\n let of_sorted_array a = Using_comparator.of_sorted_array ~comparator a\n let of_list a = Using_comparator.of_list ~comparator a\n let of_array a = Using_comparator.of_array ~comparator a\n let stable_dedup_list a = Using_comparator.stable_dedup_list ~comparator a\n let map a ~f = Using_comparator.map ~comparator a ~f\n let filter_map a ~f = Using_comparator.filter_map ~comparator a ~f\n let of_tree tree = { comparator; tree }\n let to_tree t = t.tree\nend\n","open! Import\nopen! T\n\nmodule type Elt_plain = sig\n type t [@@deriving_inline compare, sexp_of]\n\n val compare : t -> t -> int\n val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t\n\n [@@@end]\nend\n\nmodule Without_comparator = Map_intf.Without_comparator\nmodule With_comparator = Map_intf.With_comparator\nmodule With_first_class_module = Map_intf.With_first_class_module\ninclude Container_intf.Export\nmodule Merge_to_sequence_element = Sequence.Merge_with_duplicates_element\n\nmodule type Accessors_generic = sig\n include Container.Generic_phantom\n\n type ('a, 'cmp) tree\n\n (** The [options] type is used to make [Accessors_generic] flexible as to whether a\n comparator is required to be passed to certain functions. *)\n type ('a, 'cmp, 'z) options\n\n type 'cmp cmp\n\n val invariants : ('a, 'cmp, ('a, 'cmp) t -> bool) options\n\n (** override [Container]'s [mem] *)\n val mem : ('a, 'cmp, ('a, 'cmp) t -> 'a elt -> bool) options\n\n val add : ('a, 'cmp, ('a, 'cmp) t -> 'a elt -> ('a, 'cmp) t) options\n val remove : ('a, 'cmp, ('a, 'cmp) t -> 'a elt -> ('a, 'cmp) t) options\n val union : ('a, 'cmp, ('a, 'cmp) t -> ('a, 'cmp) t -> ('a, 'cmp) t) options\n val inter : ('a, 'cmp, ('a, 'cmp) t -> ('a, 'cmp) t -> ('a, 'cmp) t) options\n val diff : ('a, 'cmp, ('a, 'cmp) t -> ('a, 'cmp) t -> ('a, 'cmp) t) options\n\n val symmetric_diff\n : ( 'a\n , 'cmp\n , ('a, 'cmp) t -> ('a, 'cmp) t -> ('a elt, 'a elt) Either.t Sequence.t )\n options\n\n val compare_direct : ('a, 'cmp, ('a, 'cmp) t -> ('a, 'cmp) t -> int) options\n val equal : ('a, 'cmp, ('a, 'cmp) t -> ('a, 'cmp) t -> bool) options\n val is_subset : ('a, 'cmp, ('a, 'cmp) t -> of_:('a, 'cmp) t -> bool) options\n val are_disjoint : ('a, 'cmp, ('a, 'cmp) t -> ('a, 'cmp) t -> bool) options\n\n type ('a, 'cmp) named\n\n module Named : sig\n val is_subset\n : ('a, 'cmp, ('a, 'cmp) named -> of_:('a, 'cmp) named -> unit Or_error.t) options\n\n val equal\n : ('a, 'cmp, ('a, 'cmp) named -> ('a, 'cmp) named -> unit Or_error.t) options\n end\n\n val fold_until\n : ('a, _) t\n -> init:'b\n -> f:('b -> 'a elt -> ('b, 'final) Continue_or_stop.t)\n -> finish:('b -> 'final)\n -> 'final\n\n val fold_right : ('a, _) t -> init:'b -> f:('a elt -> 'b -> 'b) -> 'b\n\n val iter2\n : ( 'a\n , 'cmp\n , ('a, 'cmp) t\n -> ('a, 'cmp) t\n -> f:([ `Left of 'a elt | `Right of 'a elt | `Both of 'a elt * 'a elt ] -> unit)\n -> unit )\n options\n\n val filter : ('a, 'cmp, ('a, 'cmp) t -> f:('a elt -> bool) -> ('a, 'cmp) t) options\n\n val partition_tf\n : ( 'a\n , 'cmp\n , ('a, 'cmp) t -> f:('a elt -> bool) -> ('a, 'cmp) t * ('a, 'cmp) t )\n options\n\n val elements : ('a, _) t -> 'a elt list\n val min_elt : ('a, _) t -> 'a elt option\n val min_elt_exn : ('a, _) t -> 'a elt\n val max_elt : ('a, _) t -> 'a elt option\n val max_elt_exn : ('a, _) t -> 'a elt\n val choose : ('a, _) t -> 'a elt option\n val choose_exn : ('a, _) t -> 'a elt\n\n val split\n : ( 'a\n , 'cmp\n , ('a, 'cmp) t -> 'a elt -> ('a, 'cmp) t * 'a elt option * ('a, 'cmp) t )\n options\n\n val group_by\n : ( 'a\n , 'cmp\n , ('a, 'cmp) t -> equiv:('a elt -> 'a elt -> bool) -> ('a, 'cmp) t list )\n options\n\n val find_exn : ('a, _) t -> f:('a elt -> bool) -> 'a elt\n val nth : ('a, _) t -> int -> 'a elt option\n val remove_index : ('a, 'cmp, ('a, 'cmp) t -> int -> ('a, 'cmp) t) options\n val to_tree : ('a, 'cmp) t -> ('a elt, 'cmp) tree\n\n val to_sequence\n : ( 'a\n , 'cmp\n , ?order:[ `Increasing | `Decreasing ]\n -> ?greater_or_equal_to:'a elt\n -> ?less_or_equal_to:'a elt\n -> ('a, 'cmp) t\n -> 'a elt Sequence.t )\n options\n\n val binary_search\n : ( 'a\n , 'cmp\n , ('a, 'cmp) t\n -> compare:('a elt -> 'key -> int)\n -> [ `Last_strictly_less_than\n | `Last_less_than_or_equal_to\n | `Last_equal_to\n | `First_equal_to\n | `First_greater_than_or_equal_to\n | `First_strictly_greater_than\n ]\n -> 'key\n -> 'a elt option )\n options\n\n val binary_search_segmented\n : ( 'a\n , 'cmp\n , ('a, 'cmp) t\n -> segment_of:('a elt -> [ `Left | `Right ])\n -> [ `Last_on_left | `First_on_right ]\n -> 'a elt option )\n options\n\n val merge_to_sequence\n : ( 'a\n , 'cmp\n , ?order:[ `Increasing | `Decreasing ]\n -> ?greater_or_equal_to:'a elt\n -> ?less_or_equal_to:'a elt\n -> ('a, 'cmp) t\n -> ('a, 'cmp) t\n -> ('a elt, 'a elt) Merge_to_sequence_element.t Sequence.t )\n options\nend\n\nmodule type Accessors0 = sig\n include Container.S0\n\n type tree\n type comparator_witness\n\n val invariants : t -> bool\n val mem : t -> elt -> bool\n val add : t -> elt -> t\n val remove : t -> elt -> t\n val union : t -> t -> t\n val inter : t -> t -> t\n val diff : t -> t -> t\n val symmetric_diff : t -> t -> (elt, elt) Either.t Sequence.t\n val compare_direct : t -> t -> int\n val equal : t -> t -> bool\n val is_subset : t -> of_:t -> bool\n val are_disjoint : t -> t -> bool\n\n type named\n\n module Named : sig\n val is_subset : named -> of_:named -> unit Or_error.t\n val equal : named -> named -> unit Or_error.t\n end\n\n val fold_until\n : t\n -> init:'b\n -> f:('b -> elt -> ('b, 'final) Continue_or_stop.t)\n -> finish:('b -> 'final)\n -> 'final\n\n val fold_right : t -> init:'b -> f:(elt -> 'b -> 'b) -> 'b\n\n val iter2\n : t\n -> t\n -> f:([ `Left of elt | `Right of elt | `Both of elt * elt ] -> unit)\n -> unit\n\n val filter : t -> f:(elt -> bool) -> t\n val partition_tf : t -> f:(elt -> bool) -> t * t\n val elements : t -> elt list\n val min_elt : t -> elt option\n val min_elt_exn : t -> elt\n val max_elt : t -> elt option\n val max_elt_exn : t -> elt\n val choose : t -> elt option\n val choose_exn : t -> elt\n val split : t -> elt -> t * elt option * t\n val group_by : t -> equiv:(elt -> elt -> bool) -> t list\n val find_exn : t -> f:(elt -> bool) -> elt\n val nth : t -> int -> elt option\n val remove_index : t -> int -> t\n val to_tree : t -> tree\n\n val to_sequence\n : ?order:[ `Increasing | `Decreasing ]\n -> ?greater_or_equal_to:elt\n -> ?less_or_equal_to:elt\n -> t\n -> elt Sequence.t\n\n val binary_search\n : t\n -> compare:(elt -> 'key -> int)\n -> [ `Last_strictly_less_than\n | `Last_less_than_or_equal_to\n | `Last_equal_to\n | `First_equal_to\n | `First_greater_than_or_equal_to\n | `First_strictly_greater_than\n ]\n -> 'key\n -> elt option\n\n val binary_search_segmented\n : t\n -> segment_of:(elt -> [ `Left | `Right ])\n -> [ `Last_on_left | `First_on_right ]\n -> elt option\n\n val merge_to_sequence\n : ?order:[ `Increasing | `Decreasing ]\n -> ?greater_or_equal_to:elt\n -> ?less_or_equal_to:elt\n -> t\n -> t\n -> (elt, elt) Merge_to_sequence_element.t Sequence.t\nend\n\nmodule type Accessors1 = sig\n include Container.S1\n\n type 'a tree\n type comparator_witness\n\n val invariants : _ t -> bool\n val mem : 'a t -> 'a -> bool\n val add : 'a t -> 'a -> 'a t\n val remove : 'a t -> 'a -> 'a t\n val union : 'a t -> 'a t -> 'a t\n val inter : 'a t -> 'a t -> 'a t\n val diff : 'a t -> 'a t -> 'a t\n val symmetric_diff : 'a t -> 'a t -> ('a, 'a) Either.t Sequence.t\n val compare_direct : 'a t -> 'a t -> int\n val equal : 'a t -> 'a t -> bool\n val is_subset : 'a t -> of_:'a t -> bool\n val are_disjoint : 'a t -> 'a t -> bool\n\n type 'a named\n\n module Named : sig\n val is_subset : 'a named -> of_:'a named -> unit Or_error.t\n val equal : 'a named -> 'a named -> unit Or_error.t\n end\n\n val fold_until\n : 'a t\n -> init:'b\n -> f:('b -> 'a -> ('b, 'final) Continue_or_stop.t)\n -> finish:('b -> 'final)\n -> 'final\n\n val fold_right : 'a t -> init:'b -> f:('a -> 'b -> 'b) -> 'b\n\n val iter2\n : 'a t\n -> 'a t\n -> f:([ `Left of 'a | `Right of 'a | `Both of 'a * 'a ] -> unit)\n -> unit\n\n val filter : 'a t -> f:('a -> bool) -> 'a t\n val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t\n val elements : 'a t -> 'a list\n val min_elt : 'a t -> 'a option\n val min_elt_exn : 'a t -> 'a\n val max_elt : 'a t -> 'a option\n val max_elt_exn : 'a t -> 'a\n val choose : 'a t -> 'a option\n val choose_exn : 'a t -> 'a\n val split : 'a t -> 'a -> 'a t * 'a option * 'a t\n val group_by : 'a t -> equiv:('a -> 'a -> bool) -> 'a t list\n val find_exn : 'a t -> f:('a -> bool) -> 'a\n val nth : 'a t -> int -> 'a option\n val remove_index : 'a t -> int -> 'a t\n val to_tree : 'a t -> 'a tree\n\n val to_sequence\n : ?order:[ `Increasing | `Decreasing ]\n -> ?greater_or_equal_to:'a\n -> ?less_or_equal_to:'a\n -> 'a t\n -> 'a Sequence.t\n\n val binary_search\n : 'a t\n -> compare:('a -> 'key -> int)\n -> [ `Last_strictly_less_than\n | `Last_less_than_or_equal_to\n | `Last_equal_to\n | `First_equal_to\n | `First_greater_than_or_equal_to\n | `First_strictly_greater_than\n ]\n -> 'key\n -> 'a option\n\n val binary_search_segmented\n : 'a t\n -> segment_of:('a -> [ `Left | `Right ])\n -> [ `Last_on_left | `First_on_right ]\n -> 'a option\n\n val merge_to_sequence\n : ?order:[ `Increasing | `Decreasing ]\n -> ?greater_or_equal_to:'a\n -> ?less_or_equal_to:'a\n -> 'a t\n -> 'a t\n -> ('a, 'a) Merge_to_sequence_element.t Sequence.t\nend\n\nmodule type Accessors2 = sig\n include Container.S1_phantom_invariant\n\n type ('a, 'cmp) tree\n\n val invariants : (_, _) t -> bool\n val mem : ('a, _) t -> 'a -> bool\n val add : ('a, 'cmp) t -> 'a -> ('a, 'cmp) t\n val remove : ('a, 'cmp) t -> 'a -> ('a, 'cmp) t\n val union : ('a, 'cmp) t -> ('a, 'cmp) t -> ('a, 'cmp) t\n val inter : ('a, 'cmp) t -> ('a, 'cmp) t -> ('a, 'cmp) t\n val diff : ('a, 'cmp) t -> ('a, 'cmp) t -> ('a, 'cmp) t\n val symmetric_diff : ('a, 'cmp) t -> ('a, 'cmp) t -> ('a, 'a) Either.t Sequence.t\n val compare_direct : ('a, 'cmp) t -> ('a, 'cmp) t -> int\n val equal : ('a, 'cmp) t -> ('a, 'cmp) t -> bool\n val is_subset : ('a, 'cmp) t -> of_:('a, 'cmp) t -> bool\n val are_disjoint : ('a, 'cmp) t -> ('a, 'cmp) t -> bool\n\n type ('a, 'cmp) named\n\n module Named : sig\n val is_subset : ('a, 'cmp) named -> of_:('a, 'cmp) named -> unit Or_error.t\n val equal : ('a, 'cmp) named -> ('a, 'cmp) named -> unit Or_error.t\n end\n\n val fold_until\n : ('a, _) t\n -> init:'b\n -> f:('b -> 'a -> ('b, 'final) Continue_or_stop.t)\n -> finish:('b -> 'final)\n -> 'final\n\n val fold_right : ('a, _) t -> init:'b -> f:('a -> 'b -> 'b) -> 'b\n\n val iter2\n : ('a, 'cmp) t\n -> ('a, 'cmp) t\n -> f:([ `Left of 'a | `Right of 'a | `Both of 'a * 'a ] -> unit)\n -> unit\n\n val filter : ('a, 'cmp) t -> f:('a -> bool) -> ('a, 'cmp) t\n val partition_tf : ('a, 'cmp) t -> f:('a -> bool) -> ('a, 'cmp) t * ('a, 'cmp) t\n val elements : ('a, _) t -> 'a list\n val min_elt : ('a, _) t -> 'a option\n val min_elt_exn : ('a, _) t -> 'a\n val max_elt : ('a, _) t -> 'a option\n val max_elt_exn : ('a, _) t -> 'a\n val choose : ('a, _) t -> 'a option\n val choose_exn : ('a, _) t -> 'a\n val split : ('a, 'cmp) t -> 'a -> ('a, 'cmp) t * 'a option * ('a, 'cmp) t\n val group_by : ('a, 'cmp) t -> equiv:('a -> 'a -> bool) -> ('a, 'cmp) t list\n val find_exn : ('a, _) t -> f:('a -> bool) -> 'a\n val nth : ('a, _) t -> int -> 'a option\n val remove_index : ('a, 'cmp) t -> int -> ('a, 'cmp) t\n val to_tree : ('a, 'cmp) t -> ('a, 'cmp) tree\n\n val to_sequence\n : ?order:[ `Increasing | `Decreasing ]\n -> ?greater_or_equal_to:'a\n -> ?less_or_equal_to:'a\n -> ('a, 'cmp) t\n -> 'a Sequence.t\n\n val binary_search\n : ('a, 'cmp) t\n -> compare:('a -> 'key -> int)\n -> [ `Last_strictly_less_than\n | `Last_less_than_or_equal_to\n | `Last_equal_to\n | `First_equal_to\n | `First_greater_than_or_equal_to\n | `First_strictly_greater_than\n ]\n -> 'key\n -> 'a option\n\n val binary_search_segmented\n : ('a, 'cmp) t\n -> segment_of:('a -> [ `Left | `Right ])\n -> [ `Last_on_left | `First_on_right ]\n -> 'a option\n\n val merge_to_sequence\n : ?order:[ `Increasing | `Decreasing ]\n -> ?greater_or_equal_to:'a\n -> ?less_or_equal_to:'a\n -> ('a, 'cmp) t\n -> ('a, 'cmp) t\n -> ('a, 'a) Merge_to_sequence_element.t Sequence.t\nend\n\nmodule type Accessors2_with_comparator = sig\n include Container.S1_phantom_invariant\n\n type ('a, 'cmp) tree\n\n val invariants : comparator:('a, 'cmp) Comparator.t -> ('a, 'cmp) t -> bool\n val mem : comparator:('a, 'cmp) Comparator.t -> ('a, 'cmp) t -> 'a -> bool\n val add : comparator:('a, 'cmp) Comparator.t -> ('a, 'cmp) t -> 'a -> ('a, 'cmp) t\n val remove : comparator:('a, 'cmp) Comparator.t -> ('a, 'cmp) t -> 'a -> ('a, 'cmp) t\n\n val union\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'cmp) t\n -> ('a, 'cmp) t\n -> ('a, 'cmp) t\n\n val inter\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'cmp) t\n -> ('a, 'cmp) t\n -> ('a, 'cmp) t\n\n val diff\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'cmp) t\n -> ('a, 'cmp) t\n -> ('a, 'cmp) t\n\n val symmetric_diff\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'cmp) t\n -> ('a, 'cmp) t\n -> ('a, 'a) Either.t Sequence.t\n\n val compare_direct\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'cmp) t\n -> ('a, 'cmp) t\n -> int\n\n val equal : comparator:('a, 'cmp) Comparator.t -> ('a, 'cmp) t -> ('a, 'cmp) t -> bool\n\n val is_subset\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'cmp) t\n -> of_:('a, 'cmp) t\n -> bool\n\n val are_disjoint\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'cmp) t\n -> ('a, 'cmp) t\n -> bool\n\n type ('a, 'cmp) named\n\n module Named : sig\n val is_subset\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'cmp) named\n -> of_:('a, 'cmp) named\n -> unit Or_error.t\n\n val equal\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'cmp) named\n -> ('a, 'cmp) named\n -> unit Or_error.t\n end\n\n val fold_until\n : ('a, _) t\n -> init:'accum\n -> f:('accum -> 'a -> ('accum, 'final) Continue_or_stop.t)\n -> finish:('accum -> 'final)\n -> 'final\n\n val fold_right : ('a, _) t -> init:'accum -> f:('a -> 'accum -> 'accum) -> 'accum\n\n val iter2\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'cmp) t\n -> ('a, 'cmp) t\n -> f:([ `Left of 'a | `Right of 'a | `Both of 'a * 'a ] -> unit)\n -> unit\n\n val filter\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'cmp) t\n -> f:('a -> bool)\n -> ('a, 'cmp) t\n\n val partition_tf\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'cmp) t\n -> f:('a -> bool)\n -> ('a, 'cmp) t * ('a, 'cmp) t\n\n val elements : ('a, _) t -> 'a list\n val min_elt : ('a, _) t -> 'a option\n val min_elt_exn : ('a, _) t -> 'a\n val max_elt : ('a, _) t -> 'a option\n val max_elt_exn : ('a, _) t -> 'a\n val choose : ('a, _) t -> 'a option\n val choose_exn : ('a, _) t -> 'a\n\n val split\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'cmp) t\n -> 'a\n -> ('a, 'cmp) t * 'a option * ('a, 'cmp) t\n\n val group_by\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'cmp) t\n -> equiv:('a -> 'a -> bool)\n -> ('a, 'cmp) t list\n\n val find_exn : ('a, _) t -> f:('a -> bool) -> 'a\n val nth : ('a, _) t -> int -> 'a option\n\n val remove_index\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'cmp) t\n -> int\n -> ('a, 'cmp) t\n\n val to_tree : ('a, 'cmp) t -> ('a, 'cmp) tree\n\n val to_sequence\n : comparator:('a, 'cmp) Comparator.t\n -> ?order:[ `Increasing | `Decreasing ]\n -> ?greater_or_equal_to:'a\n -> ?less_or_equal_to:'a\n -> ('a, 'cmp) t\n -> 'a Sequence.t\n\n val binary_search\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'cmp) t\n -> compare:('a -> 'key -> int)\n -> [ `Last_strictly_less_than\n | `Last_less_than_or_equal_to\n | `Last_equal_to\n | `First_equal_to\n | `First_greater_than_or_equal_to\n | `First_strictly_greater_than\n ]\n -> 'key\n -> 'a option\n\n val binary_search_segmented\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'cmp) t\n -> segment_of:('a -> [ `Left | `Right ])\n -> [ `Last_on_left | `First_on_right ]\n -> 'a option\n\n val merge_to_sequence\n : comparator:('a, 'cmp) Comparator.t\n -> ?order:[ `Increasing | `Decreasing ]\n -> ?greater_or_equal_to:'a\n -> ?less_or_equal_to:'a\n -> ('a, 'cmp) t\n -> ('a, 'cmp) t\n -> ('a, 'a) Merge_to_sequence_element.t Sequence.t\nend\n\n(** Consistency checks (same as in [Container]). *)\nmodule Check_accessors\n (T : T2)\n (Tree : T2)\n (Elt : T1)\n (Named : T2)\n (Cmp : T1)\n (Options : T3)\n (M : Accessors_generic\n with type ('a, 'b, 'c) options := ('a, 'b, 'c) Options.t\n with type ('a, 'b) t := ('a, 'b) T.t\n with type ('a, 'b) tree := ('a, 'b) Tree.t\n with type 'a elt := 'a Elt.t\n with type 'cmp cmp := 'cmp Cmp.t\n with type ('a, 'b) named := ('a, 'b) Named.t) =\nstruct end\n\nmodule Check_accessors0 (M : Accessors0) =\n Check_accessors\n (struct\n type ('a, 'b) t = M.t\n end)\n (struct\n type ('a, 'b) t = M.tree\n end)\n (struct\n type 'a t = M.elt\n end)\n (struct\n type ('a, 'b) t = M.named\n end)\n (struct\n type 'a t = M.comparator_witness\n end)\n (Without_comparator)\n (M)\n\nmodule Check_accessors1 (M : Accessors1) =\n Check_accessors\n (struct\n type ('a, 'b) t = 'a M.t\n end)\n (struct\n type ('a, 'b) t = 'a M.tree\n end)\n (struct\n type 'a t = 'a\n end)\n (struct\n type ('a, 'b) t = 'a M.named\n end)\n (struct\n type 'a t = M.comparator_witness\n end)\n (Without_comparator)\n (M)\n\nmodule Check_accessors2 (M : Accessors2) =\n Check_accessors\n (struct\n type ('a, 'b) t = ('a, 'b) M.t\n end)\n (struct\n type ('a, 'b) t = ('a, 'b) M.tree\n end)\n (struct\n type 'a t = 'a\n end)\n (struct\n type ('a, 'b) t = ('a, 'b) M.named\n end)\n (struct\n type 'a t = 'a\n end)\n (Without_comparator)\n (M)\n\nmodule Check_accessors2_with_comparator (M : Accessors2_with_comparator) =\n Check_accessors\n (struct\n type ('a, 'b) t = ('a, 'b) M.t\n end)\n (struct\n type ('a, 'b) t = ('a, 'b) M.tree\n end)\n (struct\n type 'a t = 'a\n end)\n (struct\n type ('a, 'b) t = ('a, 'b) M.named\n end)\n (struct\n type 'a t = 'a\n end)\n (With_comparator)\n (M)\n\nmodule type Creators_generic = sig\n type ('a, 'cmp) t\n type ('a, 'cmp) set\n type ('a, 'cmp) tree\n type 'a elt\n type ('a, 'cmp, 'z) options\n type 'cmp cmp\n\n val empty : ('a, 'cmp, ('a, 'cmp) t) options\n val singleton : ('a, 'cmp, 'a elt -> ('a, 'cmp) t) options\n val union_list : ('a, 'cmp, ('a, 'cmp) t list -> ('a, 'cmp) t) options\n val of_list : ('a, 'cmp, 'a elt list -> ('a, 'cmp) t) options\n val of_array : ('a, 'cmp, 'a elt array -> ('a, 'cmp) t) options\n val of_sorted_array : ('a, 'cmp, 'a elt array -> ('a, 'cmp) t Or_error.t) options\n val of_sorted_array_unchecked : ('a, 'cmp, 'a elt array -> ('a, 'cmp) t) options\n\n val of_increasing_iterator_unchecked\n : ('a, 'cmp, len:int -> f:(int -> 'a elt) -> ('a, 'cmp) t) options\n\n val stable_dedup_list : ('a, _, 'a elt list -> 'a elt list) options\n\n (** The types of [map] and [filter_map] are subtle. The input set, [('a, _) set],\n reflects the fact that these functions take a set of *any* type, with any\n comparator, while the output set, [('b, 'cmp) t], reflects that the output set has\n the particular ['cmp] of the creation function. The comparator can come in one of\n three ways, depending on which set module is used\n\n - [Set.map] -- comparator comes as an argument\n - [Set.Poly.map] -- comparator is polymorphic comparison\n - [Foo.Set.map] -- comparator is [Foo.comparator] *)\n val map : ('b, 'cmp, ('a, _) set -> f:('a -> 'b elt) -> ('b, 'cmp) t) options\n\n val filter_map\n : ('b, 'cmp, ('a, _) set -> f:('a -> 'b elt option) -> ('b, 'cmp) t) options\n\n val of_tree : ('a, 'cmp, ('a elt, 'cmp) tree -> ('a, 'cmp) t) options\nend\n\nmodule type Creators0 = sig\n type ('a, 'cmp) set\n type t\n type tree\n type elt\n type comparator_witness\n\n val empty : t\n val singleton : elt -> t\n val union_list : t list -> t\n val of_list : elt list -> t\n val of_array : elt array -> t\n val of_sorted_array : elt array -> t Or_error.t\n val of_sorted_array_unchecked : elt array -> t\n val of_increasing_iterator_unchecked : len:int -> f:(int -> elt) -> t\n val stable_dedup_list : elt list -> elt list\n val map : ('a, _) set -> f:('a -> elt) -> t\n val filter_map : ('a, _) set -> f:('a -> elt option) -> t\n val of_tree : tree -> t\nend\n\nmodule type Creators1 = sig\n type ('a, 'cmp) set\n type 'a t\n type 'a tree\n type comparator_witness\n\n val empty : 'a t\n val singleton : 'a -> 'a t\n val union_list : 'a t list -> 'a t\n val of_list : 'a list -> 'a t\n val of_array : 'a array -> 'a t\n val of_sorted_array : 'a array -> 'a t Or_error.t\n val of_sorted_array_unchecked : 'a array -> 'a t\n val of_increasing_iterator_unchecked : len:int -> f:(int -> 'a) -> 'a t\n val stable_dedup_list : 'a list -> 'a list\n val map : ('a, _) set -> f:('a -> 'b) -> 'b t\n val filter_map : ('a, _) set -> f:('a -> 'b option) -> 'b t\n val of_tree : 'a tree -> 'a t\nend\n\nmodule type Creators2 = sig\n type ('a, 'cmp) set\n type ('a, 'cmp) t\n type ('a, 'cmp) tree\n\n val empty : ('a, 'cmp) t\n val singleton : 'a -> ('a, 'cmp) t\n val union_list : ('a, 'cmp) t list -> ('a, 'cmp) t\n val of_list : 'a list -> ('a, 'cmp) t\n val of_array : 'a array -> ('a, 'cmp) t\n val of_sorted_array : 'a array -> ('a, 'cmp) t Or_error.t\n val of_sorted_array_unchecked : 'a array -> ('a, 'cmp) t\n val of_increasing_iterator_unchecked : len:int -> f:(int -> 'a) -> ('a, 'cmp) t\n val stable_dedup_list : 'a list -> 'a list\n val map : ('a, _) set -> f:('a -> 'b) -> ('b, 'cmp) t\n val filter_map : ('a, _) set -> f:('a -> 'b option) -> ('b, 'cmp) t\n val of_tree : ('a, 'cmp) tree -> ('a, 'cmp) t\nend\n\nmodule type Creators2_with_comparator = sig\n type ('a, 'cmp) set\n type ('a, 'cmp) t\n type ('a, 'cmp) tree\n\n val empty : comparator:('a, 'cmp) Comparator.t -> ('a, 'cmp) t\n val singleton : comparator:('a, 'cmp) Comparator.t -> 'a -> ('a, 'cmp) t\n\n val union_list\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'cmp) t list\n -> ('a, 'cmp) t\n\n val of_list : comparator:('a, 'cmp) Comparator.t -> 'a list -> ('a, 'cmp) t\n val of_array : comparator:('a, 'cmp) Comparator.t -> 'a array -> ('a, 'cmp) t\n\n val of_sorted_array\n : comparator:('a, 'cmp) Comparator.t\n -> 'a array\n -> ('a, 'cmp) t Or_error.t\n\n val of_sorted_array_unchecked\n : comparator:('a, 'cmp) Comparator.t\n -> 'a array\n -> ('a, 'cmp) t\n\n val of_increasing_iterator_unchecked\n : comparator:('a, 'cmp) Comparator.t\n -> len:int\n -> f:(int -> 'a)\n -> ('a, 'cmp) t\n\n val stable_dedup_list : comparator:('a, 'cmp) Comparator.t -> 'a list -> 'a list\n\n val map\n : comparator:('b, 'cmp) Comparator.t\n -> ('a, _) set\n -> f:('a -> 'b)\n -> ('b, 'cmp) t\n\n val filter_map\n : comparator:('b, 'cmp) Comparator.t\n -> ('a, _) set\n -> f:('a -> 'b option)\n -> ('b, 'cmp) t\n\n val of_tree : comparator:('a, 'cmp) Comparator.t -> ('a, 'cmp) tree -> ('a, 'cmp) t\nend\n\nmodule Check_creators\n (T : T2)\n (Tree : T2)\n (Elt : T1)\n (Cmp : T1)\n (Options : T3)\n (M : Creators_generic\n with type ('a, 'b, 'c) options := ('a, 'b, 'c) Options.t\n with type ('a, 'b) t := ('a, 'b) T.t\n with type ('a, 'b) tree := ('a, 'b) Tree.t\n with type 'a elt := 'a Elt.t\n with type 'cmp cmp := 'cmp Cmp.t) =\nstruct end\n\nmodule Check_creators0 (M : Creators0) =\n Check_creators\n (struct\n type ('a, 'b) t = M.t\n end)\n (struct\n type ('a, 'b) t = M.tree\n end)\n (struct\n type 'a t = M.elt\n end)\n (struct\n type 'cmp t = M.comparator_witness\n end)\n (Without_comparator)\n (M)\n\nmodule Check_creators1 (M : Creators1) =\n Check_creators\n (struct\n type ('a, 'b) t = 'a M.t\n end)\n (struct\n type ('a, 'b) t = 'a M.tree\n end)\n (struct\n type 'a t = 'a\n end)\n (struct\n type 'cmp t = M.comparator_witness\n end)\n (Without_comparator)\n (M)\n\nmodule Check_creators2 (M : Creators2) =\n Check_creators\n (struct\n type ('a, 'b) t = ('a, 'b) M.t\n end)\n (struct\n type ('a, 'b) t = ('a, 'b) M.tree\n end)\n (struct\n type 'a t = 'a\n end)\n (struct\n type 'cmp t = 'cmp\n end)\n (Without_comparator)\n (M)\n\nmodule Check_creators2_with_comparator (M : Creators2_with_comparator) =\n Check_creators\n (struct\n type ('a, 'b) t = ('a, 'b) M.t\n end)\n (struct\n type ('a, 'b) t = ('a, 'b) M.tree\n end)\n (struct\n type 'a t = 'a\n end)\n (struct\n type 'cmp t = 'cmp\n end)\n (With_comparator)\n (M)\n\nmodule type Creators_and_accessors_generic = sig\n include Accessors_generic\n\n include\n Creators_generic\n with type ('a, 'b, 'c) options := ('a, 'b, 'c) options\n with type ('a, 'b) t := ('a, 'b) t\n with type ('a, 'b) tree := ('a, 'b) tree\n with type 'a elt := 'a elt\n with type 'cmp cmp := 'cmp cmp\nend\n\nmodule type Creators_and_accessors0 = sig\n include Accessors0\n\n include\n Creators0\n with type t := t\n with type tree := tree\n with type elt := elt\n with type comparator_witness := comparator_witness\nend\n\nmodule type Creators_and_accessors1 = sig\n include Accessors1\n\n include\n Creators1\n with type 'a t := 'a t\n with type 'a tree := 'a tree\n with type comparator_witness := comparator_witness\nend\n\nmodule type Creators_and_accessors2 = sig\n include Accessors2\n\n include\n Creators2 with type ('a, 'b) t := ('a, 'b) t with type ('a, 'b) tree := ('a, 'b) tree\nend\n\nmodule type Creators_and_accessors2_with_comparator = sig\n include Accessors2_with_comparator\n\n include\n Creators2_with_comparator\n with type ('a, 'b) t := ('a, 'b) t\n with type ('a, 'b) tree := ('a, 'b) tree\nend\n\nmodule type S_poly = Creators_and_accessors1\n\nmodule type For_deriving = sig\n type ('a, 'b) t\n\n module type Sexp_of_m = sig\n type t [@@deriving_inline sexp_of]\n\n val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t\n\n [@@@end]\n end\n\n module type M_of_sexp = sig\n type t [@@deriving_inline of_sexp]\n\n val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t\n\n [@@@end]\n\n include Comparator.S with type t := t\n end\n\n module type Compare_m = sig end\n module type Equal_m = sig end\n module type Hash_fold_m = Hasher.S\n\n val sexp_of_m__t : (module Sexp_of_m with type t = 'elt) -> ('elt, 'cmp) t -> Sexp.t\n\n val m__t_of_sexp\n : (module M_of_sexp with type t = 'elt and type comparator_witness = 'cmp)\n -> Sexp.t\n -> ('elt, 'cmp) t\n\n val compare_m__t : (module Compare_m) -> ('elt, 'cmp) t -> ('elt, 'cmp) t -> int\n val equal_m__t : (module Equal_m) -> ('elt, 'cmp) t -> ('elt, 'cmp) t -> bool\n\n val hash_fold_m__t\n : (module Hash_fold_m with type t = 'elt)\n -> Hash.state\n -> ('elt, _) t\n -> Hash.state\n\n val hash_m__t : (module Hash_fold_m with type t = 'elt) -> ('elt, _) t -> int\nend\n\nmodule type Set = sig\n (** This module defines the [Set] module for [Base]. Functions that construct a set take\n as an argument the comparator for the element type. *)\n\n (** The type of a set. The first type parameter identifies the type of the element, and\n the second identifies the comparator, which determines the comparison function that\n is used for ordering elements in this set. Many operations (e.g., {!union}),\n require that they be passed sets with the same element type and the same comparator\n type. *)\n type ('elt, 'cmp) t [@@deriving_inline compare]\n\n val compare\n : ('elt -> 'elt -> int)\n -> ('cmp -> 'cmp -> int)\n -> ('elt, 'cmp) t\n -> ('elt, 'cmp) t\n -> int\n\n [@@@end]\n\n type ('k, 'cmp) comparator =\n (module Comparator.S with type t = 'k and type comparator_witness = 'cmp)\n\n (** Tests internal invariants of the set data structure. Returns true on success. *)\n val invariants : (_, _) t -> bool\n\n (** Returns a first-class module that can be used to build other map/set/etc\n with the same notion of comparison. *)\n val comparator_s : ('a, 'cmp) t -> ('a, 'cmp) comparator\n\n val comparator : ('a, 'cmp) t -> ('a, 'cmp) Comparator.t\n\n (** Creates an empty set based on the provided comparator. *)\n val empty : ('a, 'cmp) comparator -> ('a, 'cmp) t\n\n (** Creates a set based on the provided comparator that contains only the provided\n element. *)\n val singleton : ('a, 'cmp) comparator -> 'a -> ('a, 'cmp) t\n\n (** Returns the cardinality of the set. [O(1)]. *)\n val length : (_, _) t -> int\n\n (** [is_empty t] is [true] iff [t] is empty. [O(1)]. *)\n val is_empty : (_, _) t -> bool\n\n (** [mem t a] returns [true] iff [a] is in [t]. [O(log n)]. *)\n val mem : ('a, _) t -> 'a -> bool\n\n (** [add t a] returns a new set with [a] added to [t], or returns [t] if [mem t a].\n [O(log n)]. *)\n val add : ('a, 'cmp) t -> 'a -> ('a, 'cmp) t\n\n (** [remove t a] returns a new set with [a] removed from [t] if [mem t a], or returns [t]\n otherwise. [O(log n)]. *)\n val remove : ('a, 'cmp) t -> 'a -> ('a, 'cmp) t\n\n (** [union t1 t2] returns the union of the two sets. [O(length t1 + length t2)]. *)\n val union : ('a, 'cmp) t -> ('a, 'cmp) t -> ('a, 'cmp) t\n\n (** [union c list] returns the union of all the sets in [list]. The\n [comparator] argument is required for the case where [list] is empty.\n [O(max(List.length list, n log n))], where [n] is the sum of sizes of the input sets. *)\n val union_list : ('a, 'cmp) comparator -> ('a, 'cmp) t list -> ('a, 'cmp) t\n\n (** [inter t1 t2] computes the intersection of sets [t1] and [t2]. [O(length t1 +\n length t2)]. *)\n val inter : ('a, 'cmp) t -> ('a, 'cmp) t -> ('a, 'cmp) t\n\n (** [diff t1 t2] computes the set difference [t1 - t2], i.e., the set containing all\n elements in [t1] that are not in [t2]. [O(length t1 + length t2)]. *)\n val diff : ('a, 'cmp) t -> ('a, 'cmp) t -> ('a, 'cmp) t\n\n (** [symmetric_diff t1 t2] returns a sequence of changes between [t1] and [t2]. It is\n intended to be efficient in the case where [t1] and [t2] share a large amount of\n structure. *)\n val symmetric_diff : ('a, 'cmp) t -> ('a, 'cmp) t -> ('a, 'a) Either.t Sequence.t\n\n (** [compare_direct t1 t2] compares the sets [t1] and [t2]. It returns the same result\n as [compare], but unlike compare, doesn't require arguments to be passed in for the\n type parameters of the set. [O(length t1 + length t2)]. *)\n val compare_direct : ('a, 'cmp) t -> ('a, 'cmp) t -> int\n\n (** Hash function: a building block to use when hashing data structures containing sets in\n them. [hash_fold_direct hash_fold_key] is compatible with [compare_direct] iff\n [hash_fold_key] is compatible with [(comparator s).compare] of the set [s] being\n hashed. *)\n val hash_fold_direct : 'a Hash.folder -> ('a, 'cmp) t Hash.folder\n\n (** [equal t1 t2] returns [true] iff the two sets have the same elements. [O(length t1 +\n length t2)] *)\n val equal : ('a, 'cmp) t -> ('a, 'cmp) t -> bool\n\n (** [exists t ~f] returns [true] iff there exists an [a] in [t] for which [f a]. [O(n)],\n but returns as soon as it finds an [a] for which [f a]. *)\n val exists : ('a, _) t -> f:('a -> bool) -> bool\n\n (** [for_all t ~f] returns [true] iff for all [a] in [t], [f a]. [O(n)], but returns as\n soon as it finds an [a] for which [not (f a)]. *)\n val for_all : ('a, _) t -> f:('a -> bool) -> bool\n\n (** [count t] returns the number of elements of [t] for which [f] returns [true].\n [O(n)]. *)\n val count : ('a, _) t -> f:('a -> bool) -> int\n\n (** [sum t] returns the sum of [f t] for each [t] in the set.\n [O(n)]. *)\n val sum\n : (module Container.Summable with type t = 'sum)\n -> ('a, _) t\n -> f:('a -> 'sum)\n -> 'sum\n\n (** [find t f] returns an element of [t] for which [f] returns true, with no guarantee as\n to which element is returned. [O(n)], but returns as soon as a suitable element is\n found. *)\n val find : ('a, _) t -> f:('a -> bool) -> 'a option\n\n (** [find_map t f] returns [b] for some [a] in [t] for which [f a = Some b]. If no such\n [a] exists, then [find] returns [None]. [O(n)], but returns as soon as a suitable\n element is found. *)\n val find_map : ('a, _) t -> f:('a -> 'b option) -> 'b option\n\n (** Like [find], but throws an exception on failure. *)\n val find_exn : ('a, _) t -> f:('a -> bool) -> 'a\n\n (** [nth t i] returns the [i]th smallest element of [t], in [O(log n)] time. The\n smallest element has [i = 0]. Returns [None] if [i < 0] or [i >= length t]. *)\n val nth : ('a, _) t -> int -> 'a option\n\n (** [remove_index t i] returns a version of [t] with the [i]th smallest element removed,\n in [O(log n)] time. The smallest element has [i = 0]. Returns [t] if [i < 0] or\n [i >= length t]. *)\n val remove_index : ('a, 'cmp) t -> int -> ('a, 'cmp) t\n\n (** [is_subset t1 ~of_:t2] returns true iff [t1] is a subset of [t2]. *)\n val is_subset : ('a, 'cmp) t -> of_:('a, 'cmp) t -> bool\n\n (** [are_disjoint t1 t2] returns [true] iff [is_empty (inter t1 t2)], but is more\n efficient. *)\n val are_disjoint : ('a, 'cmp) t -> ('a, 'cmp) t -> bool\n\n (** [Named] allows the validation of subset and equality relationships between sets. A\n [Named.t] is a record of a set and a name, where the name is used in error messages,\n and [Named.is_subset] and [Named.equal] validate subset and equality relationships\n respectively.\n\n The error message for, e.g.,\n {[\n Named.is_subset { set = set1; name = \"set1\" } ~of_:{set = set2; name = \"set2\" }\n ]}\n\n looks like\n {v\n (\"set1 is not a subset of set2\" (invalid_elements (...elements of set1 - set2...)))\n v}\n\n so [name] should be a noun phrase that doesn't sound awkward in the above error\n message. Even though it adds verbosity, choosing [name]s that start with the phrase\n \"the set of\" often makes the error message sound more natural.\n *)\n module Named : sig\n type nonrec ('a, 'cmp) t =\n { set : ('a, 'cmp) t\n ; name : string\n }\n\n (** [is_subset t1 ~of_:t2] returns [Ok ()] if [t1] is a subset of [t2] and a\n human-readable error otherwise. *)\n val is_subset : ('a, 'cmp) t -> of_:('a, 'cmp) t -> unit Or_error.t\n\n (** [equal t1 t2] returns [Ok ()] if [t1] is equal to [t2] and a human-readable\n error otherwise. *)\n val equal : ('a, 'cmp) t -> ('a, 'cmp) t -> unit Or_error.t\n end\n\n (** The list or array given to [of_list] and [of_array] need not be sorted. *)\n val of_list : ('a, 'cmp) comparator -> 'a list -> ('a, 'cmp) t\n\n val of_array : ('a, 'cmp) comparator -> 'a array -> ('a, 'cmp) t\n\n (** [to_list] and [to_array] produce sequences sorted in ascending order according to the\n comparator. *)\n val to_list : ('a, _) t -> 'a list\n\n val to_array : ('a, _) t -> 'a array\n\n (** Create set from sorted array. The input must be sorted (either in ascending or\n descending order as given by the comparator) and contain no duplicates, otherwise the\n result is an error. The complexity of this function is [O(n)]. *)\n val of_sorted_array : ('a, 'cmp) comparator -> 'a array -> ('a, 'cmp) t Or_error.t\n\n (** Similar to [of_sorted_array], but without checking the input array. *)\n val of_sorted_array_unchecked : ('a, 'cmp) comparator -> 'a array -> ('a, 'cmp) t\n\n (** [of_increasing_iterator_unchecked c ~len ~f] behaves like [of_sorted_array_unchecked c\n (Array.init len ~f)], with the additional restriction that a decreasing order is not\n supported. The advantage is not requiring you to allocate an intermediate array. [f]\n will be called with 0, 1, ... [len - 1], in order. *)\n val of_increasing_iterator_unchecked\n : ('a, 'cmp) comparator\n -> len:int\n -> f:(int -> 'a)\n -> ('a, 'cmp) t\n\n (** [stable_dedup_list] is here rather than in the [List] module because the\n implementation relies crucially on sets, and because doing so allows one to avoid uses\n of polymorphic comparison by instantiating the functor at a different implementation\n of [Comparator] and using the resulting [stable_dedup_list]. *)\n val stable_dedup_list : ('a, _) comparator -> 'a list -> 'a list\n\n (** [map c t ~f] returns a new set created by applying [f] to every element in\n [t]. The returned set is based on the provided [comparator]. [O(n log n)]. *)\n val map : ('b, 'cmp) comparator -> ('a, _) t -> f:('a -> 'b) -> ('b, 'cmp) t\n\n (** Like {!map}, except elements for which [f] returns [None] will be dropped. *)\n val filter_map\n : ('b, 'cmp) comparator\n -> ('a, _) t\n -> f:('a -> 'b option)\n -> ('b, 'cmp) t\n\n (** [filter t ~f] returns the subset of [t] for which [f] evaluates to true. [O(n log\n n)]. *)\n val filter : ('a, 'cmp) t -> f:('a -> bool) -> ('a, 'cmp) t\n\n (** [fold t ~init ~f] folds over the elements of the set from smallest to largest. *)\n val fold : ('a, _) t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum\n\n (** [fold_result ~init ~f] folds over the elements of the set from smallest to\n largest, short circuiting the fold if [f accum x] is an [Error _] *)\n val fold_result\n : ('a, _) t\n -> init:'accum\n -> f:('accum -> 'a -> ('accum, 'e) Result.t)\n -> ('accum, 'e) Result.t\n\n (** [fold_until t ~init ~f] is a short-circuiting version of [fold]. If [f]\n returns [Stop _] the computation ceases and results in that value. If [f] returns\n [Continue _], the fold will proceed. *)\n val fold_until\n : ('a, _) t\n -> init:'accum\n -> f:('accum -> 'a -> ('accum, 'final) Continue_or_stop.t)\n -> finish:('accum -> 'final)\n -> 'final\n\n\n (** Like {!fold}, except that it goes from the largest to the smallest element. *)\n val fold_right : ('a, _) t -> init:'accum -> f:('a -> 'accum -> 'accum) -> 'accum\n\n (** [iter t ~f] calls [f] on every element of [t], going in order from the smallest to\n largest. *)\n val iter : ('a, _) t -> f:('a -> unit) -> unit\n\n (** Iterate two sets side by side. Complexity is [O(m+n)] where [m] and [n] are the sizes\n of the two input sets. As an example, with the inputs [0; 1] and [1; 2], [f] will be\n called with [`Left 0]; [`Both (1, 1)]; and [`Right 2]. *)\n val iter2\n : ('a, 'cmp) t\n -> ('a, 'cmp) t\n -> f:([ `Left of 'a | `Right of 'a | `Both of 'a * 'a ] -> unit)\n -> unit\n\n (** if [a, b = partition_tf set ~f] then [a] is the elements on which [f] produced [true],\n and [b] is the elements on which [f] produces [false]. *)\n val partition_tf : ('a, 'cmp) t -> f:('a -> bool) -> ('a, 'cmp) t * ('a, 'cmp) t\n\n (** Same as {!to_list}. *)\n val elements : ('a, _) t -> 'a list\n\n (** Returns the smallest element of the set. [O(log n)]. *)\n val min_elt : ('a, _) t -> 'a option\n\n (** Like {!min_elt}, but throws an exception when given an empty set. *)\n val min_elt_exn : ('a, _) t -> 'a\n\n (** Returns the largest element of the set. [O(log n)]. *)\n val max_elt : ('a, _) t -> 'a option\n\n (** Like {!max_elt}, but throws an exception when given an empty set. *)\n val max_elt_exn : ('a, _) t -> 'a\n\n (** returns an arbitrary element, or [None] if the set is empty. *)\n val choose : ('a, _) t -> 'a option\n\n (** Like {!choose}, but throws an exception on an empty set. *)\n val choose_exn : ('a, _) t -> 'a\n\n (** [split t x] produces a triple [(t1, maybe_x, t2)] where [t1] is the set of elements\n strictly less than [x], [maybe_x] is the member (if any) of [t] which compares equal\n to [x], and [t2] is the set of elements strictly larger than [x]. *)\n val split : ('a, 'cmp) t -> 'a -> ('a, 'cmp) t * 'a option * ('a, 'cmp) t\n\n (** if [equiv] is an equivalence predicate, then [group_by set ~equiv] produces a list\n of equivalence classes (i.e., a set-theoretic quotient). E.g.,\n\n {[\n let chars = Set.of_list ['A'; 'a'; 'b'; 'c'] in\n let equiv c c' = Char.equal (Char.uppercase c) (Char.uppercase c') in\n group_by chars ~equiv\n ]}\n\n produces:\n\n {[\n [Set.of_list ['A';'a']; Set.singleton 'b'; Set.singleton 'c']\n ]}\n\n [group_by] runs in O(n^2) time, so if you have a comparison function, it's usually\n much faster to use [Set.of_list]. *)\n val group_by : ('a, 'cmp) t -> equiv:('a -> 'a -> bool) -> ('a, 'cmp) t list\n\n (** [to_sequence t] converts the set [t] to a sequence of the elements between\n [greater_or_equal_to] and [less_or_equal_to] inclusive in the order indicated by\n [order]. If [greater_or_equal_to > less_or_equal_to] the sequence is empty. Cost is\n O(log n) up front and amortized O(1) for each element produced. *)\n val to_sequence\n : ?order:[ `Increasing (** default *) | `Decreasing ]\n -> ?greater_or_equal_to:'a\n -> ?less_or_equal_to:'a\n -> ('a, 'cmp) t\n -> 'a Sequence.t\n\n (** [binary_search t ~compare which elt] returns the element in [t] specified by\n [compare] and [which], if one exists.\n\n [t] must be sorted in increasing order according to [compare], where [compare] and\n [elt] divide [t] into three (possibly empty) segments:\n\n {v\n | < elt | = elt | > elt |\n v}\n\n [binary_search] returns an element on the boundary of segments as specified by\n [which]. See the diagram below next to the [which] variants.\n\n [binary_search] does not check that [compare] orders [t], and behavior is\n unspecified if [compare] doesn't order [t]. Behavior is also unspecified if\n [compare] mutates [t]. *)\n val binary_search\n : ('a, 'cmp) t\n -> compare:('a -> 'key -> int)\n -> [ `Last_strictly_less_than (** {v | < elt X | v} *)\n | `Last_less_than_or_equal_to (** {v | <= elt X | v} *)\n | `Last_equal_to (** {v | = elt X | v} *)\n | `First_equal_to (** {v | X = elt | v} *)\n | `First_greater_than_or_equal_to (** {v | X >= elt | v} *)\n | `First_strictly_greater_than (** {v | X > elt | v} *)\n ]\n -> 'key\n -> 'a option\n\n (** [binary_search_segmented t ~segment_of which] takes a [segment_of] function that\n divides [t] into two (possibly empty) segments:\n\n {v\n | segment_of elt = `Left | segment_of elt = `Right |\n v}\n\n [binary_search_segmented] returns the element on the boundary of the segments as\n specified by [which]: [`Last_on_left] yields the last element of the left segment,\n while [`First_on_right] yields the first element of the right segment. It returns\n [None] if the segment is empty.\n\n [binary_search_segmented] does not check that [segment_of] segments [t] as in the\n diagram, and behavior is unspecified if [segment_of] doesn't segment [t]. Behavior\n is also unspecified if [segment_of] mutates [t]. *)\n val binary_search_segmented\n : ('a, 'cmp) t\n -> segment_of:('a -> [ `Left | `Right ])\n -> [ `Last_on_left | `First_on_right ]\n -> 'a option\n\n (** Produces the elements of the two sets between [greater_or_equal_to] and\n [less_or_equal_to] in [order], noting whether each element appears in the left set,\n the right set, or both. In the both case, both elements are returned, in case the\n caller can distinguish between elements that are equal to the sets' comparator. Runs\n in O(length t + length t'). *)\n module Merge_to_sequence_element : sig\n type ('a, 'b) t = ('a, 'b) Sequence.Merge_with_duplicates_element.t =\n | Left of 'a\n | Right of 'b\n | Both of 'a * 'b\n [@@deriving_inline compare, sexp]\n\n val compare\n : ('a -> 'a -> int)\n -> ('b -> 'b -> int)\n -> ('a, 'b) t\n -> ('a, 'b) t\n -> int\n\n include Ppx_sexp_conv_lib.Sexpable.S2 with type ('a, 'b) t := ('a, 'b) t\n\n [@@@end]\n end\n\n val merge_to_sequence\n : ?order:[ `Increasing (** default *) | `Decreasing ]\n -> ?greater_or_equal_to:'a\n -> ?less_or_equal_to:'a\n -> ('a, 'cmp) t\n -> ('a, 'cmp) t\n -> ('a, 'a) Merge_to_sequence_element.t Sequence.t\n\n (** [M] is meant to be used in combination with OCaml applicative functor types:\n\n {[\n type string_set = Set.M(String).t\n ]}\n\n which stands for:\n\n {[\n type string_set = (String.t, String.comparator_witness) Set.t\n ]}\n\n The point is that [Set.M(String).t] supports deriving, whereas the second syntax\n doesn't (because there is no such thing as, say, String.sexp_of_comparator_witness,\n instead you would want to pass the comparator directly). *)\n module M (Elt : sig\n type t\n type comparator_witness\n end) : sig\n type nonrec t = (Elt.t, Elt.comparator_witness) t\n end\n\n include For_deriving with type ('a, 'b) t := ('a, 'b) t\n\n (** A polymorphic Set. *)\n module Poly : S_poly with type 'elt t = ('elt, Comparator.Poly.comparator_witness) t\n\n (** Using comparator is a similar interface as the toplevel of [Set], except the functions\n take a [~comparator:('elt, 'cmp) Comparator.t] where the functions at the toplevel of\n [Set] takes a [('elt, 'cmp) comparator]. *)\n module Using_comparator : sig\n type nonrec ('elt, 'cmp) t = ('elt, 'cmp) t [@@deriving_inline sexp_of]\n\n val sexp_of_t\n : ('elt -> Ppx_sexp_conv_lib.Sexp.t)\n -> ('cmp -> Ppx_sexp_conv_lib.Sexp.t)\n -> ('elt, 'cmp) t\n -> Ppx_sexp_conv_lib.Sexp.t\n\n [@@@end]\n\n val t_of_sexp_direct\n : comparator:('elt, 'cmp) Comparator.t\n -> (Sexp.t -> 'elt)\n -> Sexp.t\n -> ('elt, 'cmp) t\n\n module Tree : sig\n (** A [Tree.t] contains just the tree data structure that a set is based on, without\n including the comparator. Accordingly, any operation on a [Tree.t] must also take\n as an argument the corresponding comparator. *)\n type ('a, 'cmp) t [@@deriving_inline sexp_of]\n\n val sexp_of_t\n : ('a -> Ppx_sexp_conv_lib.Sexp.t)\n -> ('cmp -> Ppx_sexp_conv_lib.Sexp.t)\n -> ('a, 'cmp) t\n -> Ppx_sexp_conv_lib.Sexp.t\n\n [@@@end]\n\n val t_of_sexp_direct\n : comparator:('elt, 'cmp) Comparator.t\n -> (Sexp.t -> 'elt)\n -> Sexp.t\n -> ('elt, 'cmp) t\n\n module Named : sig\n type nonrec ('a, 'cmp) t =\n { tree : ('a, 'cmp) t\n ; name : string\n }\n\n val is_subset\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'cmp) t\n -> of_:('a, 'cmp) t\n -> unit Or_error.t\n\n val equal\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'cmp) t\n -> ('a, 'cmp) t\n -> unit Or_error.t\n end\n\n include\n Creators_and_accessors2_with_comparator\n with type ('a, 'b) set := ('a, 'b) t\n with type ('a, 'b) t := ('a, 'b) t\n with type ('a, 'b) tree := ('a, 'b) t\n with type ('a, 'b) named := ('a, 'b) Named.t\n with module Named := Named\n\n val empty_without_value_restriction : (_, _) t\n end\n\n include\n Accessors2\n with type ('a, 'b) t := ('a, 'b) t\n with type ('a, 'b) tree := ('a, 'b) Tree.t\n with type ('a, 'b) named := ('a, 'b) Named.t\n\n include\n Creators2_with_comparator\n with type ('a, 'b) t := ('a, 'b) t\n with type ('a, 'b) tree := ('a, 'b) Tree.t\n with type ('a, 'b) set := ('a, 'b) t\n\n val comparator : ('a, 'cmp) t -> ('a, 'cmp) Comparator.t\n val hash_fold_direct : 'elt Hash.folder -> ('elt, 'cmp) t Hash.folder\n\n module Empty_without_value_restriction (Elt : Comparator.S1) : sig\n val empty : ('a Elt.t, Elt.comparator_witness) t\n end\n end\n\n (** {2 Modules and module types for extending [Set]}\n\n For use in extensions of Base, like [Core_kernel]. *)\n\n module With_comparator = With_comparator\n module With_first_class_module = With_first_class_module\n module Without_comparator = Without_comparator\n\n module type For_deriving = For_deriving\n module type S_poly = S_poly\n module type Accessors0 = Accessors0\n module type Accessors1 = Accessors1\n module type Accessors2 = Accessors2\n module type Accessors2_with_comparator = Accessors2_with_comparator\n module type Accessors_generic = Accessors_generic\n module type Creators0 = Creators0\n module type Creators1 = Creators1\n module type Creators2 = Creators2\n module type Creators2_with_comparator = Creators2_with_comparator\n module type Creators_and_accessors0 = Creators_and_accessors0\n module type Creators_and_accessors1 = Creators_and_accessors1\n module type Creators_and_accessors2 = Creators_and_accessors2\n\n module type Creators_and_accessors2_with_comparator =\n Creators_and_accessors2_with_comparator\n\n module type Creators_generic = Creators_generic\n module type Elt_plain = Elt_plain\nend\n","open! Import\n\n\n(* [t] stores the [t.length] queue elements at consecutive increasing indices of [t.elts],\n mod the capacity of [t], which is [Option_array.length t.elts]. The capacity is\n required to be a power of two (user-requested capacities are rounded up to the nearest\n power), so that mod can quickly be computed using [land t.mask], where [t.mask =\n capacity t - 1]. So, queue element [i] is at [t.elts.( (t.front + i) land t.mask )].\n\n [num_mutations] is used to detect modification during iteration. *)\ntype 'a t =\n { mutable num_mutations : int\n ; mutable front : int\n ; mutable mask : int\n ; mutable length : int\n ; mutable elts : 'a Option_array.t\n }\n[@@deriving_inline sexp_of]\n\nlet sexp_of_t : 'a. ('a -> Ppx_sexp_conv_lib.Sexp.t) -> 'a t -> Ppx_sexp_conv_lib.Sexp.t =\n fun _of_a -> function\n | { num_mutations = v_num_mutations\n ; front = v_front\n ; mask = v_mask\n ; length = v_length\n ; elts = v_elts\n } ->\n let bnds = [] in\n let bnds =\n let arg = Option_array.sexp_of_t _of_a v_elts in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"elts\"; arg ] :: bnds\n in\n let bnds =\n let arg = sexp_of_int v_length in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"length\"; arg ] :: bnds\n in\n let bnds =\n let arg = sexp_of_int v_mask in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"mask\"; arg ] :: bnds\n in\n let bnds =\n let arg = sexp_of_int v_front in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"front\"; arg ] :: bnds\n in\n let bnds =\n let arg = sexp_of_int v_num_mutations in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"num_mutations\"; arg ]\n :: bnds\n in\n Ppx_sexp_conv_lib.Sexp.List bnds\n;;\n\n[@@@end]\n\nmodule type S = Queue_intf.S\n\nlet inc_num_mutations t = t.num_mutations <- t.num_mutations + 1\nlet capacity t = t.mask + 1\nlet elts_index t i = (t.front + i) land t.mask\nlet unsafe_get t i = Option_array.unsafe_get_some_exn t.elts (elts_index t i)\nlet unsafe_is_set t i = Option_array.unsafe_is_some t.elts (elts_index t i)\nlet unsafe_set t i a = Option_array.unsafe_set_some t.elts (elts_index t i) a\nlet unsafe_unset t i = Option_array.unsafe_set_none t.elts (elts_index t i)\n\nlet check_index_exn t i =\n if i < 0 || i >= t.length\n then\n Error.raise_s\n (Sexp.message\n \"Queue index out of bounds\"\n [ \"index\", i |> Int.sexp_of_t; \"length\", t.length |> Int.sexp_of_t ])\n;;\n\nlet get t i =\n check_index_exn t i;\n unsafe_get t i\n;;\n\nlet set t i a =\n check_index_exn t i;\n inc_num_mutations t;\n unsafe_set t i a\n;;\n\nlet is_empty t = t.length = 0\nlet length { length; _ } = length\n\nlet ensure_no_mutation t num_mutations =\n if t.num_mutations <> num_mutations\n then\n Error.raise_s\n (Sexp.message\n \"mutation of queue during iteration\"\n [ \"\", t |> sexp_of_t (fun _ -> Sexp.Atom \"_\") ])\n;;\n\nlet compare =\n let rec unsafe_compare_from compare_elt pos ~t1 ~t2 ~len1 ~len2 ~mut1 ~mut2 =\n match pos = len1, pos = len2 with\n | true, true -> 0\n | true, false -> -1\n | false, true -> 1\n | false, false ->\n let x = compare_elt (unsafe_get t1 pos) (unsafe_get t2 pos) in\n ensure_no_mutation t1 mut1;\n ensure_no_mutation t2 mut2;\n (match x with\n | 0 -> unsafe_compare_from compare_elt (pos + 1) ~t1 ~t2 ~len1 ~len2 ~mut1 ~mut2\n | n -> n)\n in\n fun compare_elt t1 t2 ->\n if phys_equal t1 t2\n then 0\n else\n unsafe_compare_from\n compare_elt\n 0\n ~t1\n ~t2\n ~len1:t1.length\n ~len2:t2.length\n ~mut1:t1.num_mutations\n ~mut2:t2.num_mutations\n;;\n\nlet equal =\n let rec unsafe_equal_from equal_elt pos ~t1 ~t2 ~mut1 ~mut2 ~len =\n pos = len\n ||\n let b = equal_elt (unsafe_get t1 pos) (unsafe_get t2 pos) in\n ensure_no_mutation t1 mut1;\n ensure_no_mutation t2 mut2;\n b && unsafe_equal_from equal_elt (pos + 1) ~t1 ~t2 ~mut1 ~mut2 ~len\n in\n fun equal_elt t1 t2 ->\n phys_equal t1 t2\n ||\n let len1 = t1.length in\n let len2 = t2.length in\n len1 = len2\n && unsafe_equal_from\n equal_elt\n 0\n ~t1\n ~t2\n ~len:len1\n ~mut1:t1.num_mutations\n ~mut2:t2.num_mutations\n;;\n\nlet invariant invariant_a t =\n let { num_mutations; mask = _; elts; front; length } = t in\n assert (front >= 0);\n assert (front < capacity t);\n let capacity = capacity t in\n assert (capacity = Option_array.length elts);\n assert (capacity >= 1);\n assert (Int.is_pow2 capacity);\n assert (length >= 0);\n assert (length <= capacity);\n for i = 0 to capacity - 1 do\n if i < t.length\n then (\n invariant_a (unsafe_get t i);\n ensure_no_mutation t num_mutations)\n else assert (not (unsafe_is_set t i))\n done\n;;\n\nlet create (type a) ?capacity () : a t =\n let capacity =\n match capacity with\n | None -> 1\n | Some capacity ->\n if capacity < 0\n then\n Error.raise_s\n (Sexp.message\n \"cannot have queue with negative capacity\"\n [ \"capacity\", capacity |> Int.sexp_of_t ])\n else if capacity = 0\n then 1\n else Int.ceil_pow2 capacity\n in\n { num_mutations = 0\n ; front = 0\n ; mask = capacity - 1\n ; length = 0\n ; elts = Option_array.create ~len:capacity\n }\n;;\n\nlet blit_to_array ~src dst =\n assert (src.length <= Option_array.length dst);\n let front_len = Int.min src.length (capacity src - src.front) in\n let rest_len = src.length - front_len in\n Option_array.blit ~len:front_len ~src:src.elts ~src_pos:src.front ~dst ~dst_pos:0;\n Option_array.blit ~len:rest_len ~src:src.elts ~src_pos:0 ~dst ~dst_pos:front_len\n;;\n\nlet set_capacity t desired_capacity =\n (* We allow arguments less than 1 to [set_capacity], but translate them to 1 to simplify\n the code that relies on the array length being a power of 2. *)\n inc_num_mutations t;\n let new_capacity = Int.ceil_pow2 (max 1 (max desired_capacity t.length)) in\n if new_capacity <> capacity t\n then (\n let dst = Option_array.create ~len:new_capacity in\n blit_to_array ~src:t dst;\n t.front <- 0;\n t.mask <- new_capacity - 1;\n t.elts <- dst)\n;;\n\nlet enqueue t a =\n inc_num_mutations t;\n if t.length = capacity t then set_capacity t (2 * t.length);\n unsafe_set t t.length a;\n t.length <- t.length + 1\n;;\n\nlet dequeue_nonempty t =\n inc_num_mutations t;\n let elts = t.elts in\n let front = t.front in\n let res = Option_array.get_some_exn elts front in\n Option_array.set_none elts front;\n t.front <- elts_index t 1;\n t.length <- t.length - 1;\n res\n;;\n\nlet dequeue_exn t = if is_empty t then raise Caml.Queue.Empty else dequeue_nonempty t\nlet dequeue t = if is_empty t then None else Some (dequeue_nonempty t)\nlet front_nonempty t = Option_array.unsafe_get_some_exn t.elts t.front\nlet last_nonempty t = unsafe_get t (t.length - 1)\nlet peek t = if is_empty t then None else Some (front_nonempty t)\nlet peek_exn t = if is_empty t then raise Caml.Queue.Empty else front_nonempty t\nlet last t = if is_empty t then None else Some (last_nonempty t)\nlet last_exn t = if is_empty t then raise Caml.Queue.Empty else last_nonempty t\n\nlet clear t =\n inc_num_mutations t;\n if t.length > 0\n then (\n for i = 0 to t.length - 1 do\n unsafe_unset t i\n done;\n t.length <- 0;\n t.front <- 0)\n;;\n\nlet blit_transfer ~src ~dst ?len () =\n inc_num_mutations src;\n inc_num_mutations dst;\n let len =\n match len with\n | None -> src.length\n | Some len ->\n if len < 0\n then\n Error.raise_s\n (Sexp.message\n \"Queue.blit_transfer: negative length\"\n [ \"length\", len |> Int.sexp_of_t ]);\n min len src.length\n in\n if len > 0\n then (\n set_capacity dst (max (capacity dst) (dst.length + len));\n let dst_start = dst.front + dst.length in\n for i = 0 to len - 1 do\n (* This is significantly faster than simply [enqueue dst (dequeue_nonempty src)] *)\n let src_i = (src.front + i) land src.mask in\n let dst_i = (dst_start + i) land dst.mask in\n Option_array.unsafe_set_some\n dst.elts\n dst_i\n (Option_array.unsafe_get_some_exn src.elts src_i);\n Option_array.unsafe_set_none src.elts src_i\n done;\n dst.length <- dst.length + len;\n src.front <- (src.front + len) land src.mask;\n src.length <- src.length - len)\n;;\n\nlet enqueue_all t l =\n (* Traversing the list up front to compute its length is probably (but not definitely)\n better than doubling the underlying array size several times for large queues. *)\n set_capacity t (Int.max (capacity t) (t.length + List.length l));\n List.iter l ~f:(fun x -> enqueue t x)\n;;\n\nlet fold t ~init ~f =\n if t.length = 0\n then init\n else (\n let num_mutations = t.num_mutations in\n let r = ref init in\n for i = 0 to t.length - 1 do\n r := f !r (unsafe_get t i);\n ensure_no_mutation t num_mutations\n done;\n !r)\n;;\n\nlet foldi t ~init ~f =\n let i = ref 0 in\n fold t ~init ~f:(fun acc a ->\n let acc = f !i acc a in\n i := !i + 1;\n acc)\n;;\n\n\n(* [iter] is implemented directly because implementing it in terms of [fold] is\n slower. *)\nlet iter t ~f =\n let num_mutations = t.num_mutations in\n for i = 0 to t.length - 1 do\n f (unsafe_get t i);\n ensure_no_mutation t num_mutations\n done\n;;\n\nlet iteri t ~f =\n let num_mutations = t.num_mutations in\n for i = 0 to t.length - 1 do\n f i (unsafe_get t i);\n ensure_no_mutation t num_mutations\n done\n;;\n\nmodule C = Indexed_container.Make (struct\n type nonrec 'a t = 'a t\n\n let fold = fold\n let iter = `Custom iter\n let length = `Custom length\n let foldi = `Custom foldi\n let iteri = `Custom iteri\n end)\n\nlet count = C.count\nlet exists = C.exists\nlet find = C.find\nlet find_map = C.find_map\nlet fold_result = C.fold_result\nlet fold_until = C.fold_until\nlet for_all = C.for_all\nlet max_elt = C.max_elt\nlet mem = C.mem\nlet min_elt = C.min_elt\nlet sum = C.sum\nlet to_list = C.to_list\nlet counti = C.counti\nlet existsi = C.existsi\nlet find_mapi = C.find_mapi\nlet findi = C.findi\nlet for_alli = C.for_alli\n\n\n(* For [concat_map], [filter_map], and [filter], we don't create [t_result] with [t]'s\n capacity because we have no idea how many elements [t_result] will ultimately hold. *)\nlet concat_map t ~f =\n let t_result = create () in\n iter t ~f:(fun a -> List.iter (f a) ~f:(fun b -> enqueue t_result b));\n t_result\n;;\n\nlet concat_mapi t ~f =\n let t_result = create () in\n iteri t ~f:(fun i a -> List.iter (f i a) ~f:(fun b -> enqueue t_result b));\n t_result\n;;\n\nlet filter_map t ~f =\n let t_result = create () in\n iter t ~f:(fun a ->\n match f a with\n | None -> ()\n | Some b -> enqueue t_result b);\n t_result\n;;\n\nlet filter_mapi t ~f =\n let t_result = create () in\n iteri t ~f:(fun i a ->\n match f i a with\n | None -> ()\n | Some b -> enqueue t_result b);\n t_result\n;;\n\nlet filter t ~f =\n let t_result = create () in\n iter t ~f:(fun a -> if f a then enqueue t_result a);\n t_result\n;;\n\nlet filteri t ~f =\n let t_result = create () in\n iteri t ~f:(fun i a -> if f i a then enqueue t_result a);\n t_result\n;;\n\nlet filter_inplace t ~f =\n let t2 = filter t ~f in\n clear t;\n blit_transfer ~src:t2 ~dst:t ()\n;;\n\nlet filteri_inplace t ~f =\n let t2 = filteri t ~f in\n clear t;\n blit_transfer ~src:t2 ~dst:t ()\n;;\n\nlet copy src =\n let dst = create ~capacity:src.length () in\n blit_to_array ~src dst.elts;\n dst.length <- src.length;\n dst\n;;\n\nlet of_list l =\n (* Traversing the list up front to compute its length is probably (but not definitely)\n better than doubling the underlying array size several times for large queues. *)\n let t = create ~capacity:(List.length l) () in\n List.iter l ~f:(fun x -> enqueue t x);\n t\n;;\n\n(* The queue [t] returned by [create] will have [t.length = 0], [t.front = 0], and\n [capacity t = Int.ceil_pow2 len]. So, we only have to set [t.length] to [len] after\n the blit to maintain all the invariants: [t.length] is equal to the number of elements\n in the queue, [t.front] is the array index of the first element in the queue, and\n [capacity t = Option_array.length t.elts]. *)\nlet init len ~f =\n if len < 0\n then\n Error.raise_s\n (Sexp.message \"Queue.init: negative length\" [ \"length\", len |> Int.sexp_of_t ]);\n let t = create ~capacity:len () in\n assert (Option_array.length t.elts >= len);\n for i = 0 to len - 1 do\n Option_array.unsafe_set_some t.elts i (f i)\n done;\n t.length <- len;\n t\n;;\n\nlet of_array a = init (Array.length a) ~f:(Array.unsafe_get a)\nlet to_array t = Array.init t.length ~f:(fun i -> unsafe_get t i)\n\nlet map ta ~f =\n let num_mutations = ta.num_mutations in\n let tb = create ~capacity:ta.length () in\n tb.length <- ta.length;\n for i = 0 to ta.length - 1 do\n let b = f (unsafe_get ta i) in\n ensure_no_mutation ta num_mutations;\n Option_array.unsafe_set_some tb.elts i b\n done;\n tb\n;;\n\nlet mapi t ~f =\n let i = ref 0 in\n map t ~f:(fun a ->\n let result = f !i a in\n i := !i + 1;\n result)\n;;\n\nlet singleton x =\n let t = create () in\n enqueue t x;\n t\n;;\n\nlet sexp_of_t sexp_of_a t = to_list t |> List.sexp_of_t sexp_of_a\nlet t_of_sexp a_of_sexp sexp = List.t_of_sexp a_of_sexp sexp |> of_list\n","open! Import\n\nmodule T = struct\n type t = |\n\n let unreachable_code = function\n | (_ : t) -> .\n ;;\n\n let all = []\n let hash_fold_t _ t = unreachable_code t\n let hash = unreachable_code\n let compare a _ = unreachable_code a\n let sexp_of_t = unreachable_code\n let t_of_sexp sexp = Sexplib.Conv_error.empty_type \"Base.Nothing.t\" sexp\n let to_string = unreachable_code\n let of_string (_ : string) = failwith \"Base.Nothing.of_string: not supported\"\nend\n\ninclude T\n\ninclude Identifiable.Make (struct\n include T\n\n let module_name = \"Base.Nothing\"\n end)\n","(** [never_returns] should be used as the return type of functions that don't return and\n might block forever, rather than ['a] or [_]. This forces callers of such functions\n to have a call to [never_returns] at the call site, which makes it clear to readers\n what's going on. We do not intend to use this type for functions such as [failwithf]\n that always raise an exception. *)\n\nopen! Import\n\ntype never_returns = Nothing.t [@@deriving sexp_of]\n\nlet never_returns = Nothing.unreachable_code\n","open! Import\nopen! Caml.Nativeint\ninclude Nativeint_replace_polymorphic_compare\n\nmodule T = struct\n type t = nativeint [@@deriving_inline hash, sexp, sexp_grammar]\n\n let (hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state) =\n hash_fold_nativeint\n\n and (hash : t -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func = hash_nativeint in\n fun x -> func x\n ;;\n\n let t_of_sexp = (nativeint_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t)\n let sexp_of_t = (sexp_of_nativeint : t -> Ppx_sexp_conv_lib.Sexp.t)\n\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group) =\n { implicit_vars = [ \"nativeint\" ]\n ; ggid = \"\\146e\\023\\249\\235eE\\139c\\132W\\195\\137\\129\\235\\025\"\n ; types = [ \"t\", Implicit_var 0 ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ nativeint_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"nativeint.ml.T\"\n }\n in\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"t\", _the_group)\n in\n t_sexp_grammar\n ;;\n\n [@@@end]\n\n let compare = Nativeint_replace_polymorphic_compare.compare\n let to_string = to_string\n let of_string = of_string\nend\n\ninclude T\ninclude Comparator.Make (T)\n\ninclude Comparable.Validate_with_zero (struct\n include T\n\n let zero = zero\n end)\n\nmodule Conv = Int_conversions\ninclude Conv.Make (T)\n\ninclude Conv.Make_hex (struct\n open Nativeint_replace_polymorphic_compare\n\n type t = nativeint [@@deriving_inline compare, hash]\n\n let compare = (compare_nativeint : t -> t -> int)\n\n let (hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state) =\n hash_fold_nativeint\n\n and (hash : t -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func = hash_nativeint in\n fun x -> func x\n ;;\n\n [@@@end]\n\n let zero = zero\n let neg = neg\n let ( < ) = ( < )\n let to_string i = Printf.sprintf \"%nx\" i\n let of_string s = Caml.Scanf.sscanf s \"%nx\" Fn.id\n let module_name = \"Base.Nativeint.Hex\"\n end)\n\ninclude Pretty_printer.Register (struct\n type nonrec t = t\n\n let to_string = to_string\n let module_name = \"Base.Nativeint\"\n end)\n\n(* Open replace_polymorphic_compare after including functor instantiations so they do not\n shadow its definitions. This is here so that efficient versions of the comparison\n functions are available within this module. *)\nopen! Nativeint_replace_polymorphic_compare\n\nlet invariant (_ : t) = ()\nlet num_bits = Word_size.num_bits Word_size.word_size\nlet float_lower_bound = Float0.lower_bound_for_int num_bits\nlet float_upper_bound = Float0.upper_bound_for_int num_bits\nlet shift_right_logical = shift_right_logical\nlet shift_right = shift_right\nlet shift_left = shift_left\nlet bit_not = lognot\nlet bit_xor = logxor\nlet bit_or = logor\nlet bit_and = logand\nlet min_value = min_int\nlet max_value = max_int\nlet abs = abs\nlet pred = pred\nlet succ = succ\nlet rem = rem\nlet neg = neg\nlet minus_one = minus_one\nlet one = one\nlet zero = zero\nlet to_float = to_float\nlet of_float_unchecked = of_float\n\nlet of_float f =\n if Float_replace_polymorphic_compare.( >= ) f float_lower_bound\n && Float_replace_polymorphic_compare.( <= ) f float_upper_bound\n then of_float f\n else\n Printf.invalid_argf\n \"Nativeint.of_float: argument (%f) is out of range or NaN\"\n (Float0.box f)\n ()\n;;\n\nmodule Pow2 = struct\n open! Import\n open Nativeint_replace_polymorphic_compare\n module Sys = Sys0\n\n let raise_s = Error.raise_s\n\n let non_positive_argument () =\n Printf.invalid_argf \"argument must be strictly positive\" ()\n ;;\n\n let ( lor ) = Caml.Nativeint.logor\n let ( lsr ) = Caml.Nativeint.shift_right_logical\n let ( land ) = Caml.Nativeint.logand\n\n (** \"ceiling power of 2\" - Least power of 2 greater than or equal to x. *)\n let ceil_pow2 (x : nativeint) =\n if x <= 0n then non_positive_argument ();\n let x = Caml.Nativeint.pred x in\n let x = x lor (x lsr 1) in\n let x = x lor (x lsr 2) in\n let x = x lor (x lsr 4) in\n let x = x lor (x lsr 8) in\n let x = x lor (x lsr 16) in\n (* The next line is superfluous on 32-bit architectures, but it's faster to do it\n anyway than to branch *)\n let x = x lor (x lsr 32) in\n Caml.Nativeint.succ x\n ;;\n\n (** \"floor power of 2\" - Largest power of 2 less than or equal to x. *)\n let floor_pow2 x =\n if x <= 0n then non_positive_argument ();\n let x = x lor (x lsr 1) in\n let x = x lor (x lsr 2) in\n let x = x lor (x lsr 4) in\n let x = x lor (x lsr 8) in\n let x = x lor (x lsr 16) in\n let x = x lor (x lsr 32) in\n Caml.Nativeint.sub x (x lsr 1)\n ;;\n\n let is_pow2 x =\n if x <= 0n then non_positive_argument ();\n x land Caml.Nativeint.pred x = 0n\n ;;\n\n (* C stubs for nativeint clz and ctz to use the CLZ/BSR/CTZ/BSF instruction where possible *)\n external clz\n : (nativeint[@unboxed])\n -> (int[@untagged])\n = \"Base_int_math_nativeint_clz\" \"Base_int_math_nativeint_clz_unboxed\"\n [@@noalloc]\n\n external ctz\n : (nativeint[@unboxed])\n -> (int[@untagged])\n = \"Base_int_math_nativeint_ctz\" \"Base_int_math_nativeint_ctz_unboxed\"\n [@@noalloc]\n\n (** Hacker's Delight Second Edition p106 *)\n let floor_log2 i =\n if Poly.( <= ) i Caml.Nativeint.zero\n then\n raise_s\n (Sexp.message\n \"[Nativeint.floor_log2] got invalid input\"\n [ \"\", sexp_of_nativeint i ]);\n num_bits - 1 - clz i\n ;;\n\n (** Hacker's Delight Second Edition p106 *)\n let ceil_log2 i =\n if Poly.( <= ) i Caml.Nativeint.zero\n then\n raise_s\n (Sexp.message\n \"[Nativeint.ceil_log2] got invalid input\"\n [ \"\", sexp_of_nativeint i ]);\n if Caml.Nativeint.equal i Caml.Nativeint.one\n then 0\n else num_bits - clz (Caml.Nativeint.pred i)\n ;;\nend\n\ninclude Pow2\n\nlet between t ~low ~high = low <= t && t <= high\nlet clamp_unchecked t ~min ~max = if t < min then min else if t <= max then t else max\n\nlet clamp_exn t ~min ~max =\n assert (min <= max);\n clamp_unchecked t ~min ~max\n;;\n\nlet clamp t ~min ~max =\n if min > max\n then\n Or_error.error_s\n (Sexp.message\n \"clamp requires [min <= max]\"\n [ \"min\", T.sexp_of_t min; \"max\", T.sexp_of_t max ])\n else Ok (clamp_unchecked t ~min ~max)\n;;\n\nlet ( / ) = div\nlet ( * ) = mul\nlet ( - ) = sub\nlet ( + ) = add\nlet ( ~- ) = neg\nlet incr r = r := !r + one\nlet decr r = r := !r - one\nlet of_nativeint t = t\nlet of_nativeint_exn = of_nativeint\nlet to_nativeint t = t\nlet to_nativeint_exn = to_nativeint\nlet popcount = Popcount.nativeint_popcount\nlet of_int = Conv.int_to_nativeint\nlet of_int_exn = of_int\nlet to_int = Conv.nativeint_to_int\nlet to_int_exn = Conv.nativeint_to_int_exn\nlet to_int_trunc = Conv.nativeint_to_int_trunc\nlet of_int32 = Conv.int32_to_nativeint\nlet of_int32_exn = of_int32\nlet to_int32 = Conv.nativeint_to_int32\nlet to_int32_exn = Conv.nativeint_to_int32_exn\nlet to_int32_trunc = Conv.nativeint_to_int32_trunc\nlet of_int64 = Conv.int64_to_nativeint\nlet of_int64_exn = Conv.int64_to_nativeint_exn\nlet of_int64_trunc = Conv.int64_to_nativeint_trunc\nlet to_int64 = Conv.nativeint_to_int64\nlet pow b e = of_int_exn (Int_math.Private.int_pow (to_int_exn b) (to_int_exn e))\nlet ( ** ) b e = pow b e\n\nmodule Pre_O = struct\n let ( + ) = ( + )\n let ( - ) = ( - )\n let ( * ) = ( * )\n let ( / ) = ( / )\n let ( ~- ) = ( ~- )\n let ( ** ) = ( ** )\n\n include (Nativeint_replace_polymorphic_compare : Comparisons.Infix with type t := t)\n\n let abs = abs\n let neg = neg\n let zero = zero\n let of_int_exn = of_int_exn\nend\n\nmodule O = struct\n include Pre_O\n\n include Int_math.Make (struct\n type nonrec t = t\n\n include Pre_O\n\n let rem = rem\n let to_float = to_float\n let of_float = of_float\n let of_string = T.of_string\n let to_string = T.to_string\n end)\n\n let ( land ) = bit_and\n let ( lor ) = bit_or\n let ( lxor ) = bit_xor\n let lnot = bit_not\n let ( lsl ) = shift_left\n let ( asr ) = shift_right\n let ( lsr ) = shift_right_logical\nend\n\ninclude O\n\n(* [Nativeint] and [Nativeint.O] agree value-wise *)\n\n(* Include type-specific [Replace_polymorphic_compare] at the end, after\n including functor application that could shadow its definitions. This is\n here so that efficient versions of the comparison functions are exported by\n this module. *)\ninclude Nativeint_replace_polymorphic_compare\n\nexternal bswap : t -> t = \"%bswap_native\"\n","(***********************************************************************)\n(* *)\n(* Objective Caml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. All rights reserved. This file is distributed *)\n(* under the terms of the Apache 2.0 license. See ../THIRD-PARTY.txt *)\n(* for details. *)\n(* *)\n(***********************************************************************)\n\nopen! Import\nmodule List = List0\n\ninclude (\n Map_intf :\n sig\n module Or_duplicate = Map_intf.Or_duplicate\n module Continue_or_stop = Map_intf.Continue_or_stop\n module With_comparator = Map_intf.With_comparator\n module With_first_class_module = Map_intf.With_first_class_module\n module Without_comparator = Map_intf.Without_comparator\n\n (* The module susbstitutions below are needed for older versions of OCaml\n (before 4.07), because back then [module type of] did not keep module\n aliases. *)\n\n include module type of struct\n include Map_intf\n end\n with module Finished_or_unfinished := Map_intf.Finished_or_unfinished\n and module Or_duplicate := Or_duplicate\n and module Continue_or_stop := Continue_or_stop\n and module With_comparator := With_comparator\n and module With_first_class_module := With_first_class_module\n and module Without_comparator := Without_comparator\n end)\n\nmodule Finished_or_unfinished = struct\n include Map_intf.Finished_or_unfinished\n\n (* These two functions are tested in [test_map.ml] to make sure our use of\n [Caml.Obj.magic] is correct and safe. *)\n let of_continue_or_stop : Continue_or_stop.t -> t = Caml.Obj.magic\n let to_continue_or_stop : t -> Continue_or_stop.t = Caml.Obj.magic\nend\n\nlet with_return = With_return.with_return\n\nexception Duplicate [@@deriving_inline sexp]\n\nlet () =\n Ppx_sexp_conv_lib.Conv.Exn_converter.add [%extension_constructor Duplicate] (function\n | Duplicate -> Ppx_sexp_conv_lib.Sexp.Atom \"map.ml.Duplicate\"\n | _ -> assert false)\n;;\n\n[@@@end]\n\nmodule Tree0 = struct\n type ('k, 'v) t =\n | Empty\n | Leaf of 'k * 'v\n | Node of ('k, 'v) t * 'k * 'v * ('k, 'v) t * int\n\n type ('k, 'v) tree = ('k, 'v) t\n\n let height = function\n | Empty -> 0\n | Leaf _ -> 1\n | Node (_, _, _, _, h) -> h\n ;;\n\n let invariants =\n let in_range lower upper compare_key k =\n (match lower with\n | None -> true\n | Some lower -> compare_key lower k < 0)\n &&\n match upper with\n | None -> true\n | Some upper -> compare_key k upper < 0\n in\n let rec loop lower upper compare_key t =\n match t with\n | Empty -> true\n | Leaf (k, _) -> in_range lower upper compare_key k\n | Node (l, k, _, r, h) ->\n let hl = height l\n and hr = height r in\n abs (hl - hr) <= 2\n && h = max hl hr + 1\n && in_range lower upper compare_key k\n && loop lower (Some k) compare_key l\n && loop (Some k) upper compare_key r\n in\n fun t ~compare_key -> loop None None compare_key t\n ;;\n\n (* precondition: |height(l) - height(r)| <= 2 *)\n let create l x d r =\n let hl = height l\n and hr = height r in\n if hl = 0 && hr = 0\n then Leaf (x, d)\n else Node (l, x, d, r, if hl >= hr then hl + 1 else hr + 1)\n ;;\n\n let singleton key data = Leaf (key, data)\n\n (* We must call [f] with increasing indexes, because the bin_prot reader in\n Core_kernel.Map needs it. *)\n let of_increasing_iterator_unchecked ~len ~f =\n let rec loop n ~f i : (_, _) t =\n match n with\n | 0 -> Empty\n | 1 ->\n let k, v = f i in\n Leaf (k, v)\n | 2 ->\n let kl, vl = f i in\n let k, v = f (i + 1) in\n Node (Leaf (kl, vl), k, v, Empty, 2)\n | 3 ->\n let kl, vl = f i in\n let k, v = f (i + 1) in\n let kr, vr = f (i + 2) in\n Node (Leaf (kl, vl), k, v, Leaf (kr, vr), 2)\n | n ->\n let left_length = n lsr 1 in\n let right_length = n - left_length - 1 in\n let left = loop left_length ~f i in\n let k, v = f (i + left_length) in\n let right = loop right_length ~f (i + left_length + 1) in\n create left k v right\n in\n loop len ~f 0\n ;;\n\n let of_sorted_array_unchecked array ~compare_key =\n let array_length = Array.length array in\n let next =\n if array_length < 2\n ||\n let k0, _ = array.(0) in\n let k1, _ = array.(1) in\n compare_key k0 k1 < 0\n then fun i -> array.(i)\n else fun i -> array.(array_length - 1 - i)\n in\n of_increasing_iterator_unchecked ~len:array_length ~f:next, array_length\n ;;\n\n let of_sorted_array array ~compare_key =\n match array with\n | [||] | [| _ |] -> Result.Ok (of_sorted_array_unchecked array ~compare_key)\n | _ ->\n with_return (fun r ->\n let increasing =\n match compare_key (fst array.(0)) (fst array.(1)) with\n | 0 ->\n r.return (Or_error.error_string \"of_sorted_array: duplicated elements\")\n | i -> i < 0\n in\n for i = 1 to Array.length array - 2 do\n match compare_key (fst array.(i)) (fst array.(i + 1)) with\n | 0 ->\n r.return (Or_error.error_string \"of_sorted_array: duplicated elements\")\n | i ->\n if Poly.( <> ) (i < 0) increasing\n then\n r.return\n (Or_error.error_string \"of_sorted_array: elements are not ordered\")\n done;\n Result.Ok (of_sorted_array_unchecked array ~compare_key))\n ;;\n\n (* precondition: |height(l) - height(r)| <= 3 *)\n let bal l x d r =\n let hl = height l in\n let hr = height r in\n if hl > hr + 2\n then (\n match l with\n | Empty -> invalid_arg \"Map.bal\"\n | Leaf _ -> assert false (* height(Leaf) = 1 && 1 is not larger than hr + 2 *)\n | Node (ll, lv, ld, lr, _) ->\n if height ll >= height lr\n then create ll lv ld (create lr x d r)\n else (\n match lr with\n | Empty -> invalid_arg \"Map.bal\"\n | Leaf (lrv, lrd) ->\n create (create ll lv ld Empty) lrv lrd (create Empty x d r)\n | Node (lrl, lrv, lrd, lrr, _) ->\n create (create ll lv ld lrl) lrv lrd (create lrr x d r)))\n else if hr > hl + 2\n then (\n match r with\n | Empty -> invalid_arg \"Map.bal\"\n | Leaf _ -> assert false (* height(Leaf) = 1 && 1 is not larger than hl + 2 *)\n | Node (rl, rv, rd, rr, _) ->\n if height rr >= height rl\n then create (create l x d rl) rv rd rr\n else (\n match rl with\n | Empty -> invalid_arg \"Map.bal\"\n | Leaf (rlv, rld) ->\n create (create l x d Empty) rlv rld (create Empty rv rd rr)\n | Node (rll, rlv, rld, rlr, _) ->\n create (create l x d rll) rlv rld (create rlr rv rd rr)))\n else create l x d r\n ;;\n\n let empty = Empty\n\n let is_empty = function\n | Empty -> true\n | _ -> false\n ;;\n\n let raise_key_already_present ~key ~sexp_of_key =\n Error.raise_s\n (Sexp.message \"[Map.add_exn] got key already present\" [ \"key\", key |> sexp_of_key ])\n ;;\n\n module Add_or_set = struct\n type t =\n | Add_exn_internal\n | Add_exn\n | Set\n end\n\n\n let rec find_and_add_or_set\n t\n ~length\n ~key:x\n ~data\n ~compare_key\n ~sexp_of_key\n ~(add_or_set : Add_or_set.t)\n =\n match t with\n | Empty -> Leaf (x, data), length + 1\n | Leaf (v, d) ->\n let c = compare_key x v in\n if c = 0\n then (\n match add_or_set with\n | Add_exn_internal -> Exn.raise_without_backtrace Duplicate\n | Add_exn -> raise_key_already_present ~key:x ~sexp_of_key\n | Set -> Leaf (x, data), length)\n else if c < 0\n then Node (Leaf (x, data), v, d, Empty, 2), length + 1\n else Node (Empty, v, d, Leaf (x, data), 2), length + 1\n | Node (l, v, d, r, h) ->\n let c = compare_key x v in\n if c = 0\n then (\n match add_or_set with\n | Add_exn_internal -> Exn.raise_without_backtrace Duplicate\n | Add_exn -> raise_key_already_present ~key:x ~sexp_of_key\n | Set -> Node (l, x, data, r, h), length)\n else if c < 0\n then (\n let l, length =\n find_and_add_or_set\n ~length\n ~key:x\n ~data\n l\n ~compare_key\n ~sexp_of_key\n ~add_or_set\n in\n bal l v d r, length)\n else (\n let r, length =\n find_and_add_or_set\n ~length\n ~key:x\n ~data\n r\n ~compare_key\n ~sexp_of_key\n ~add_or_set\n in\n bal l v d r, length)\n ;;\n\n let add_exn t ~length ~key ~data ~compare_key ~sexp_of_key =\n find_and_add_or_set\n t\n ~length\n ~key\n ~data\n ~compare_key\n ~sexp_of_key\n ~add_or_set:Add_exn\n ;;\n\n let add_exn_internal t ~length ~key ~data ~compare_key ~sexp_of_key =\n find_and_add_or_set\n t\n ~length\n ~key\n ~data\n ~compare_key\n ~sexp_of_key\n ~add_or_set:Add_exn_internal\n ;;\n\n let set t ~length ~key ~data ~compare_key =\n find_and_add_or_set\n t\n ~length\n ~key\n ~data\n ~compare_key\n ~sexp_of_key:(fun _ -> List [])\n ~add_or_set:Set\n ;;\n\n let set' t key data ~compare_key = fst (set t ~length:0 ~key ~data ~compare_key)\n\n module Build_increasing = struct\n module Fragment = struct\n type nonrec ('k, 'v) t =\n { left_subtree : ('k, 'v) t\n ; key : 'k\n ; data : 'v\n }\n\n let singleton_to_tree_exn = function\n | { left_subtree = Empty; key; data } -> singleton key data\n | _ -> failwith \"Map.singleton_to_tree_exn: not a singleton\"\n ;;\n\n let singleton ~key ~data = { left_subtree = Empty; key; data }\n\n (* precondition: |height(l.left_subtree) - height(r)| <= 2,\n max_key(l) < min_key(r)\n *)\n let collapse l r = create l.left_subtree l.key l.data r\n\n (* precondition: |height(l.left_subtree) - height(r.left_subtree)| <= 2,\n max_key(l) < min_key(r)\n *)\n let join l r = { r with left_subtree = collapse l r.left_subtree }\n let max_key t = t.key\n end\n\n (** Build trees from singletons in a balanced way by using skew binary encoding.\n Each level contains trees of the same height, consecutive levels have consecutive\n heights. There are no gaps. The first level are single keys.\n *)\n type ('k, 'v) t =\n | Zero of unit\n (* [unit] to make pattern matching faster *)\n | One of ('k, 'v) t * ('k, 'v) Fragment.t\n | Two of ('k, 'v) t * ('k, 'v) Fragment.t * ('k, 'v) Fragment.t\n\n let empty = Zero ()\n\n let add_unchecked =\n let rec go t x =\n match t with\n | Zero () -> One (t, x)\n | One (t, y) -> Two (t, y, x)\n | Two (t, z, y) -> One (go t (Fragment.join z y), x)\n in\n fun t ~key ~data -> go t (Fragment.singleton ~key ~data)\n ;;\n\n let to_tree =\n let rec go t r =\n match t with\n | Zero () -> r\n | One (t, l) -> go t (Fragment.collapse l r)\n | Two (t, ll, l) -> go t (Fragment.collapse (Fragment.join ll l) r)\n in\n function\n | Zero () -> Empty\n | One (t, r) -> go t (Fragment.singleton_to_tree_exn r)\n | Two (t, l, r) -> go (One (t, l)) (Fragment.singleton_to_tree_exn r)\n ;;\n\n let max_key = function\n | Zero () -> None\n | One (_, r) | Two (_, _, r) -> Some (Fragment.max_key r)\n ;;\n end\n\n let of_increasing_sequence seq ~compare_key =\n with_return (fun { return } ->\n let builder, length =\n Sequence.fold\n seq\n ~init:(Build_increasing.empty, 0)\n ~f:(fun (builder, length) (key, data) ->\n match Build_increasing.max_key builder with\n | Some prev_key when compare_key prev_key key >= 0 ->\n return\n (Or_error.error_string \"of_increasing_sequence: non-increasing key\")\n | _ -> Build_increasing.add_unchecked builder ~key ~data, length + 1)\n in\n Ok (Build_increasing.to_tree builder, length))\n ;;\n\n (* Like [bal] but allows any difference in height between [l] and [r].\n\n O(|height l - height r|) *)\n let rec join l k d r ~compare_key =\n match l, r with\n | Empty, _ -> set' r k d ~compare_key\n | _, Empty -> set' l k d ~compare_key\n | Leaf (lk, ld), _ -> set' (set' r k d ~compare_key) lk ld ~compare_key\n | _, Leaf (rk, rd) -> set' (set' l k d ~compare_key) rk rd ~compare_key\n | Node (ll, lk, ld, lr, lh), Node (rl, rk, rd, rr, rh) ->\n (* [bal] requires height difference <= 3. *)\n if lh > rh + 3\n (* [height lr >= height r],\n therefore [height (join lr k d r ...)] is [height rl + 1] or [height rl]\n therefore the height difference with [ll] will be <= 3 *)\n then bal ll lk ld (join lr k d r ~compare_key)\n else if rh > lh + 3\n then bal (join l k d rl ~compare_key) rk rd rr\n else bal l k d r\n ;;\n\n let rec split t x ~compare_key =\n match t with\n | Empty -> Empty, None, Empty\n | Leaf (k, d) ->\n let cmp = compare_key x k in\n if cmp = 0\n then Empty, Some (k, d), Empty\n else if cmp < 0\n then Empty, None, t\n else t, None, Empty\n | Node (l, k, d, r, _) ->\n let cmp = compare_key x k in\n if cmp = 0\n then l, Some (k, d), r\n else if cmp < 0\n then (\n let ll, maybe, lr = split l x ~compare_key in\n ll, maybe, join lr k d r ~compare_key)\n else (\n let rl, maybe, rr = split r x ~compare_key in\n join l k d rl ~compare_key, maybe, rr)\n ;;\n\n let split_and_reinsert_boundary t ~into x ~compare_key =\n let left, boundary_opt, right = split t x ~compare_key in\n match boundary_opt with\n | None -> left, right\n | Some (key, data) ->\n let insert_into tree = fst (set tree ~key ~data ~length:0 ~compare_key) in\n (match into with\n | `Left -> insert_into left, right\n | `Right -> left, insert_into right)\n ;;\n\n let split_range\n t\n ~(lower_bound : 'a Maybe_bound.t)\n ~(upper_bound : 'a Maybe_bound.t)\n ~compare_key\n =\n if Maybe_bound.bounds_crossed\n ~compare:compare_key\n ~lower:lower_bound\n ~upper:upper_bound\n then empty, empty, empty\n else (\n let left, mid_and_right =\n match lower_bound with\n | Unbounded -> empty, t\n | Incl lb -> split_and_reinsert_boundary ~into:`Right t lb ~compare_key\n | Excl lb -> split_and_reinsert_boundary ~into:`Left t lb ~compare_key\n in\n let mid, right =\n match upper_bound with\n | Unbounded -> mid_and_right, empty\n | Incl lb ->\n split_and_reinsert_boundary ~into:`Left mid_and_right lb ~compare_key\n | Excl lb ->\n split_and_reinsert_boundary ~into:`Right mid_and_right lb ~compare_key\n in\n left, mid, right)\n ;;\n\n let rec find t x ~compare_key =\n match t with\n | Empty -> None\n | Leaf (v, d) -> if compare_key x v = 0 then Some d else None\n | Node (l, v, d, r, _) ->\n let c = compare_key x v in\n if c = 0 then Some d else find (if c < 0 then l else r) x ~compare_key\n ;;\n\n let add_multi t ~length ~key ~data ~compare_key =\n let data = data :: Option.value (find t key ~compare_key) ~default:[] in\n set ~length ~key ~data t ~compare_key\n ;;\n\n let find_multi t x ~compare_key =\n match find t x ~compare_key with\n | None -> []\n | Some l -> l\n ;;\n\n let find_exn =\n let if_not_found key ~sexp_of_key =\n raise (Not_found_s (List [ Atom \"Map.find_exn: not found\"; sexp_of_key key ]))\n in\n let rec find_exn t x ~compare_key ~sexp_of_key =\n match t with\n | Empty -> if_not_found x ~sexp_of_key\n | Leaf (v, d) -> if compare_key x v = 0 then d else if_not_found x ~sexp_of_key\n | Node (l, v, d, r, _) ->\n let c = compare_key x v in\n if c = 0\n then d\n else find_exn (if c < 0 then l else r) x ~compare_key ~sexp_of_key\n in\n (* named to preserve symbol in compiled binary *)\n find_exn\n ;;\n\n let mem t x ~compare_key = Option.is_some (find t x ~compare_key)\n\n let rec min_elt = function\n | Empty -> None\n | Leaf (k, d) -> Some (k, d)\n | Node (Empty, k, d, _, _) -> Some (k, d)\n | Node (l, _, _, _, _) -> min_elt l\n ;;\n\n exception Map_min_elt_exn_of_empty_map [@@deriving_inline sexp]\n\n let () =\n Ppx_sexp_conv_lib.Conv.Exn_converter.add\n [%extension_constructor Map_min_elt_exn_of_empty_map]\n (function\n | Map_min_elt_exn_of_empty_map ->\n Ppx_sexp_conv_lib.Sexp.Atom \"map.ml.Tree0.Map_min_elt_exn_of_empty_map\"\n | _ -> assert false)\n ;;\n\n [@@@end]\n\n exception Map_max_elt_exn_of_empty_map [@@deriving_inline sexp]\n\n let () =\n Ppx_sexp_conv_lib.Conv.Exn_converter.add\n [%extension_constructor Map_max_elt_exn_of_empty_map]\n (function\n | Map_max_elt_exn_of_empty_map ->\n Ppx_sexp_conv_lib.Sexp.Atom \"map.ml.Tree0.Map_max_elt_exn_of_empty_map\"\n | _ -> assert false)\n ;;\n\n [@@@end]\n\n let min_elt_exn t =\n match min_elt t with\n | None -> raise Map_min_elt_exn_of_empty_map\n | Some v -> v\n ;;\n\n let rec max_elt = function\n | Empty -> None\n | Leaf (k, d) -> Some (k, d)\n | Node (_, k, d, Empty, _) -> Some (k, d)\n | Node (_, _, _, r, _) -> max_elt r\n ;;\n\n let max_elt_exn t =\n match max_elt t with\n | None -> raise Map_max_elt_exn_of_empty_map\n | Some v -> v\n ;;\n\n let rec remove_min_elt t =\n match t with\n | Empty -> invalid_arg \"Map.remove_min_elt\"\n | Leaf _ -> Empty\n | Node (Empty, _, _, r, _) -> r\n | Node (l, x, d, r, _) -> bal (remove_min_elt l) x d r\n ;;\n\n let append ~lower_part ~upper_part ~compare_key =\n match max_elt lower_part, min_elt upper_part with\n | None, _ -> `Ok upper_part\n | _, None -> `Ok lower_part\n | Some (max_lower, _), Some (min_upper, v) when compare_key max_lower min_upper < 0\n ->\n let upper_part_without_min = remove_min_elt upper_part in\n `Ok (join ~compare_key lower_part min_upper v upper_part_without_min)\n | _ -> `Overlapping_key_ranges\n ;;\n\n let fold_range_inclusive =\n (* This assumes that min <= max, which is checked by the outer function. *)\n let rec go t ~min ~max ~init ~f ~compare_key =\n match t with\n | Empty -> init\n | Leaf (k, d) ->\n if compare_key k min < 0 || compare_key k max > 0\n then (* k < min || k > max *)\n init\n else f ~key:k ~data:d init\n | Node (l, k, d, r, _) ->\n let c_min = compare_key k min in\n if c_min < 0\n then\n (* if k < min, then this node and its left branch are outside our range *)\n go r ~min ~max ~init ~f ~compare_key\n else if c_min = 0\n then\n (* if k = min, then this node's left branch is outside our range *)\n go r ~min ~max ~init:(f ~key:k ~data:d init) ~f ~compare_key\n else (\n (* k > min *)\n let z = go l ~min ~max ~init ~f ~compare_key in\n let c_max = compare_key k max in\n (* if k > max, we're done *)\n if c_max > 0\n then z\n else (\n let z = f ~key:k ~data:d z in\n (* if k = max, then we fold in this one last value and we're done *)\n if c_max = 0 then z else go r ~min ~max ~init:z ~f ~compare_key))\n in\n fun t ~min ~max ~init ~f ~compare_key ->\n if compare_key min max <= 0 then go t ~min ~max ~init ~f ~compare_key else init\n ;;\n\n let range_to_alist t ~min ~max ~compare_key =\n List.rev\n (fold_range_inclusive\n t\n ~min\n ~max\n ~init:[]\n ~f:(fun ~key ~data l -> (key, data) :: l)\n ~compare_key)\n ;;\n\n let concat_unchecked t1 t2 =\n match t1, t2 with\n | Empty, t -> t\n | t, Empty -> t\n | _, _ ->\n let x, d = min_elt_exn t2 in\n bal t1 x d (remove_min_elt t2)\n ;;\n\n let rec remove t x ~length ~compare_key =\n match t with\n | Empty -> Empty, length\n | Leaf (v, _) -> if compare_key x v = 0 then Empty, length - 1 else t, length\n | Node (l, v, d, r, _) ->\n let c = compare_key x v in\n if c = 0\n then concat_unchecked l r, length - 1\n else if c < 0\n then (\n let l, length = remove l x ~length ~compare_key in\n bal l v d r, length)\n else (\n let r, length = remove r x ~length ~compare_key in\n bal l v d r, length)\n ;;\n\n (* Use exception to avoid tree-rebuild in no-op case *)\n exception Change_no_op\n\n let change t key ~f ~length ~compare_key =\n let rec change_core t key f =\n match t with\n | Empty ->\n (match f None with\n | None -> raise Change_no_op (* equivalent to returning: Empty *)\n | Some data -> Leaf (key, data), length + 1)\n | Leaf (v, d) ->\n let c = compare_key key v in\n if c = 0\n then (\n match f (Some d) with\n | None -> Empty, length - 1\n | Some d' -> Leaf (v, d'), length)\n else if c < 0\n then (\n let l, length = change_core Empty key f in\n bal l v d Empty, length)\n else (\n let r, length = change_core Empty key f in\n bal Empty v d r, length)\n | Node (l, v, d, r, h) ->\n let c = compare_key key v in\n if c = 0\n then (\n match f (Some d) with\n | None -> concat_unchecked l r, length - 1\n | Some data -> Node (l, key, data, r, h), length)\n else if c < 0\n then (\n let l, length = change_core l key f in\n bal l v d r, length)\n else (\n let r, length = change_core r key f in\n bal l v d r, length)\n in\n try change_core t key f with\n | Change_no_op -> t, length\n ;;\n\n let update t key ~f ~length ~compare_key =\n let rec update_core t key f =\n match t with\n | Empty ->\n let data = f None in\n Leaf (key, data), length + 1\n | Leaf (v, d) ->\n let c = compare_key key v in\n if c = 0\n then (\n let d' = f (Some d) in\n Leaf (v, d'), length)\n else if c < 0\n then (\n let l, length = update_core Empty key f in\n bal l v d Empty, length)\n else (\n let r, length = update_core Empty key f in\n bal Empty v d r, length)\n | Node (l, v, d, r, h) ->\n let c = compare_key key v in\n if c = 0\n then (\n let data = f (Some d) in\n Node (l, key, data, r, h), length)\n else if c < 0\n then (\n let l, length = update_core l key f in\n bal l v d r, length)\n else (\n let r, length = update_core r key f in\n bal l v d r, length)\n in\n update_core t key f\n ;;\n\n let remove_multi t key ~length ~compare_key =\n change t key ~length ~compare_key ~f:(function\n | None | Some ([] | [ _ ]) -> None\n | Some (_ :: (_ :: _ as non_empty_tail)) -> Some non_empty_tail)\n ;;\n\n let rec iter_keys t ~f =\n match t with\n | Empty -> ()\n | Leaf (v, _) -> f v\n | Node (l, v, _, r, _) ->\n iter_keys ~f l;\n f v;\n iter_keys ~f r\n ;;\n\n let rec iter t ~f =\n match t with\n | Empty -> ()\n | Leaf (_, d) -> f d\n | Node (l, _, d, r, _) ->\n iter ~f l;\n f d;\n iter ~f r\n ;;\n\n let rec iteri t ~f =\n match t with\n | Empty -> ()\n | Leaf (v, d) -> f ~key:v ~data:d\n | Node (l, v, d, r, _) ->\n iteri ~f l;\n f ~key:v ~data:d;\n iteri ~f r\n ;;\n\n let iteri_until =\n let rec iteri_until_loop t ~f : Continue_or_stop.t =\n match t with\n | Empty -> Continue\n | Leaf (v, d) -> f ~key:v ~data:d\n | Node (l, v, d, r, _) ->\n (match iteri_until_loop ~f l with\n | Stop -> Stop\n | Continue ->\n (match f ~key:v ~data:d with\n | Stop -> Stop\n | Continue -> iteri_until_loop ~f r))\n in\n fun t ~f -> Finished_or_unfinished.of_continue_or_stop (iteri_until_loop t ~f)\n ;;\n\n let rec map t ~f =\n match t with\n | Empty -> Empty\n | Leaf (v, d) -> Leaf (v, f d)\n | Node (l, v, d, r, h) ->\n let l' = map ~f l in\n let d' = f d in\n let r' = map ~f r in\n Node (l', v, d', r', h)\n ;;\n\n let rec mapi t ~f =\n match t with\n | Empty -> Empty\n | Leaf (v, d) -> Leaf (v, f ~key:v ~data:d)\n | Node (l, v, d, r, h) ->\n let l' = mapi ~f l in\n let d' = f ~key:v ~data:d in\n let r' = mapi ~f r in\n Node (l', v, d', r', h)\n ;;\n\n let rec fold t ~init:accu ~f =\n match t with\n | Empty -> accu\n | Leaf (v, d) -> f ~key:v ~data:d accu\n | Node (l, v, d, r, _) -> fold ~f r ~init:(f ~key:v ~data:d (fold ~f l ~init:accu))\n ;;\n\n let rec fold_right t ~init:accu ~f =\n match t with\n | Empty -> accu\n | Leaf (v, d) -> f ~key:v ~data:d accu\n | Node (l, v, d, r, _) ->\n fold_right ~f l ~init:(f ~key:v ~data:d (fold_right ~f r ~init:accu))\n ;;\n\n let filter_keys t ~f ~compare_key =\n fold ~init:(Empty, 0) t ~f:(fun ~key ~data (accu, length) ->\n if f key then set ~length ~key ~data accu ~compare_key else accu, length)\n ;;\n\n\n let filter t ~f ~compare_key =\n fold ~init:(Empty, 0) t ~f:(fun ~key ~data (accu, length) ->\n if f data then set ~length ~key ~data accu ~compare_key else accu, length)\n ;;\n\n let filteri t ~f ~compare_key =\n fold ~init:(Empty, 0) t ~f:(fun ~key ~data (accu, length) ->\n if f ~key ~data then set ~length ~key ~data accu ~compare_key else accu, length)\n ;;\n\n let filter_map t ~f ~compare_key =\n fold ~init:(Empty, 0) t ~f:(fun ~key ~data (accu, length) ->\n match f data with\n | None -> accu, length\n | Some b -> set ~length ~key ~data:b accu ~compare_key)\n ;;\n\n let filter_mapi t ~f ~compare_key =\n fold ~init:(Empty, 0) t ~f:(fun ~key ~data (accu, length) ->\n match f ~key ~data with\n | None -> accu, length\n | Some b -> set ~length ~key ~data:b accu ~compare_key)\n ;;\n\n let partition_mapi t ~f ~compare_key =\n fold\n t\n ~init:((Empty, 0), (Empty, 0))\n ~f:(fun ~key ~data (pair1, pair2) ->\n match (f ~key ~data : _ Either.t) with\n | First x ->\n let t, length = pair1 in\n set t ~key ~data:x ~compare_key ~length, pair2\n | Second y ->\n let t, length = pair2 in\n pair1, set t ~key ~data:y ~compare_key ~length)\n ;;\n\n let partition_map t ~f ~compare_key =\n partition_mapi t ~compare_key ~f:(fun ~key:_ ~data -> f data)\n ;;\n\n let partitioni_tf t ~f ~compare_key =\n partition_mapi t ~compare_key ~f:(fun ~key ~data ->\n if f ~key ~data then First data else Second data)\n ;;\n\n let partition_tf t ~f ~compare_key =\n partition_mapi t ~compare_key ~f:(fun ~key:_ ~data ->\n if f data then First data else Second data)\n ;;\n\n module Enum = struct\n type increasing\n type decreasing\n\n type ('k, 'v, 'direction) t =\n | End\n | More of 'k * 'v * ('k, 'v) tree * ('k, 'v, 'direction) t\n\n let rec cons t (e : (_, _, increasing) t) : (_, _, increasing) t =\n match t with\n | Empty -> e\n | Leaf (v, d) -> More (v, d, Empty, e)\n | Node (l, v, d, r, _) -> cons l (More (v, d, r, e))\n ;;\n\n let rec cons_right t (e : (_, _, decreasing) t) : (_, _, decreasing) t =\n match t with\n | Empty -> e\n | Leaf (v, d) -> More (v, d, Empty, e)\n | Node (l, v, d, r, _) -> cons_right r (More (v, d, l, e))\n ;;\n\n let of_tree tree : (_, _, increasing) t = cons tree End\n let of_tree_right tree : (_, _, decreasing) t = cons_right tree End\n\n let starting_at_increasing t key compare : (_, _, increasing) t =\n let rec loop t e =\n match t with\n | Empty -> e\n | Leaf (v, d) -> loop (Node (Empty, v, d, Empty, 1)) e\n | Node (_, v, _, r, _) when compare v key < 0 -> loop r e\n | Node (l, v, d, r, _) -> loop l (More (v, d, r, e))\n in\n loop t End\n ;;\n\n let starting_at_decreasing t key compare : (_, _, decreasing) t =\n let rec loop t e =\n match t with\n | Empty -> e\n | Leaf (v, d) -> loop (Node (Empty, v, d, Empty, 1)) e\n | Node (l, v, _, _, _) when compare v key > 0 -> loop l e\n | Node (l, v, d, r, _) -> loop r (More (v, d, l, e))\n in\n loop t End\n ;;\n\n let compare compare_key compare_data t1 t2 =\n let rec loop t1 t2 =\n match t1, t2 with\n | End, End -> 0\n | End, _ -> -1\n | _, End -> 1\n | More (v1, d1, r1, e1), More (v2, d2, r2, e2) ->\n let c = compare_key v1 v2 in\n if c <> 0\n then c\n else (\n let c = compare_data d1 d2 in\n if c <> 0\n then c\n else if phys_equal r1 r2\n then loop e1 e2\n else loop (cons r1 e1) (cons r2 e2))\n in\n loop t1 t2\n ;;\n\n let equal compare_key data_equal t1 t2 =\n let rec loop t1 t2 =\n match t1, t2 with\n | End, End -> true\n | End, _ | _, End -> false\n | More (v1, d1, r1, e1), More (v2, d2, r2, e2) ->\n compare_key v1 v2 = 0\n && data_equal d1 d2\n && if phys_equal r1 r2 then loop e1 e2 else loop (cons r1 e1) (cons r2 e2)\n in\n loop t1 t2\n ;;\n\n let rec fold ~init ~f = function\n | End -> init\n | More (key, data, tree, enum) ->\n let next = f ~key ~data init in\n fold (cons tree enum) ~init:next ~f\n ;;\n\n let fold2 compare_key t1 t2 ~init ~f =\n let rec loop t1 t2 curr =\n match t1, t2 with\n | End, End -> curr\n | End, _ ->\n fold t2 ~init:curr ~f:(fun ~key ~data acc -> f ~key ~data:(`Right data) acc)\n | _, End ->\n fold t1 ~init:curr ~f:(fun ~key ~data acc -> f ~key ~data:(`Left data) acc)\n | More (k1, v1, tree1, enum1), More (k2, v2, tree2, enum2) ->\n let compare_result = compare_key k1 k2 in\n if compare_result = 0\n then (\n let next = f ~key:k1 ~data:(`Both (v1, v2)) curr in\n loop (cons tree1 enum1) (cons tree2 enum2) next)\n else if compare_result < 0\n then (\n let next = f ~key:k1 ~data:(`Left v1) curr in\n loop (cons tree1 enum1) t2 next)\n else (\n let next = f ~key:k2 ~data:(`Right v2) curr in\n loop t1 (cons tree2 enum2) next)\n in\n loop t1 t2 init\n ;;\n\n let symmetric_diff t1 t2 ~compare_key ~data_equal =\n let step state =\n match state with\n | End, End -> Sequence.Step.Done\n | End, More (key, data, tree, enum) ->\n Sequence.Step.Yield ((key, `Right data), (End, cons tree enum))\n | More (key, data, tree, enum), End ->\n Sequence.Step.Yield ((key, `Left data), (cons tree enum, End))\n | (More (k1, v1, tree1, enum1) as left), (More (k2, v2, tree2, enum2) as right)\n ->\n let compare_result = compare_key k1 k2 in\n if compare_result = 0\n then (\n let next_state =\n if phys_equal tree1 tree2\n then enum1, enum2\n else cons tree1 enum1, cons tree2 enum2\n in\n if data_equal v1 v2\n then Sequence.Step.Skip next_state\n else Sequence.Step.Yield ((k1, `Unequal (v1, v2)), next_state))\n else if compare_result < 0\n then Sequence.Step.Yield ((k1, `Left v1), (cons tree1 enum1, right))\n else Sequence.Step.Yield ((k2, `Right v2), (left, cons tree2 enum2))\n in\n Sequence.unfold_step ~init:(of_tree t1, of_tree t2) ~f:step\n ;;\n\n let fold_symmetric_diff t1 t2 ~compare_key ~data_equal ~init ~f =\n let add acc k v = f acc (k, `Right v) in\n let remove acc k v = f acc (k, `Left v) in\n let rec loop left right acc =\n match left, right with\n | End, enum -> fold enum ~init:acc ~f:(fun ~key ~data acc -> add acc key data)\n | enum, End -> fold enum ~init:acc ~f:(fun ~key ~data acc -> remove acc key data)\n | (More (k1, v1, tree1, enum1) as left), (More (k2, v2, tree2, enum2) as right)\n ->\n let compare_result = compare_key k1 k2 in\n if compare_result = 0\n then (\n let acc = if data_equal v1 v2 then acc else f acc (k1, `Unequal (v1, v2)) in\n if phys_equal tree1 tree2\n then loop enum1 enum2 acc\n else loop (cons tree1 enum1) (cons tree2 enum2) acc)\n else if compare_result < 0\n then (\n let acc = remove acc k1 v1 in\n loop (cons tree1 enum1) right acc)\n else (\n let acc = add acc k2 v2 in\n loop left (cons tree2 enum2) acc)\n in\n loop (of_tree t1) (of_tree t2) init\n ;;\n end\n\n let to_sequence_increasing comparator ~from_key t =\n let next enum =\n match enum with\n | Enum.End -> Sequence.Step.Done\n | Enum.More (k, v, t, e) -> Sequence.Step.Yield ((k, v), Enum.cons t e)\n in\n let init =\n match from_key with\n | None -> Enum.of_tree t\n | Some key -> Enum.starting_at_increasing t key comparator.Comparator.compare\n in\n Sequence.unfold_step ~init ~f:next\n ;;\n\n let to_sequence_decreasing comparator ~from_key t =\n let next enum =\n match enum with\n | Enum.End -> Sequence.Step.Done\n | Enum.More (k, v, t, e) -> Sequence.Step.Yield ((k, v), Enum.cons_right t e)\n in\n let init =\n match from_key with\n | None -> Enum.of_tree_right t\n | Some key -> Enum.starting_at_decreasing t key comparator.Comparator.compare\n in\n Sequence.unfold_step ~init ~f:next\n ;;\n\n let to_sequence\n comparator\n ?(order = `Increasing_key)\n ?keys_greater_or_equal_to\n ?keys_less_or_equal_to\n t\n =\n let inclusive_bound side t bound =\n let compare_key = comparator.Comparator.compare in\n let l, maybe, r = split t bound ~compare_key in\n let t = side (l, r) in\n match maybe with\n | None -> t\n | Some (key, data) -> set' t key data ~compare_key\n in\n match order with\n | `Increasing_key ->\n let t = Option.fold keys_less_or_equal_to ~init:t ~f:(inclusive_bound fst) in\n to_sequence_increasing comparator ~from_key:keys_greater_or_equal_to t\n | `Decreasing_key ->\n let t = Option.fold keys_greater_or_equal_to ~init:t ~f:(inclusive_bound snd) in\n to_sequence_decreasing comparator ~from_key:keys_less_or_equal_to t\n ;;\n\n let compare compare_key compare_data t1 t2 =\n Enum.compare compare_key compare_data (Enum.of_tree t1) (Enum.of_tree t2)\n ;;\n\n let equal compare_key compare_data t1 t2 =\n Enum.equal compare_key compare_data (Enum.of_tree t1) (Enum.of_tree t2)\n ;;\n\n let iter2 t1 t2 ~f ~compare_key =\n Enum.fold2\n compare_key\n (Enum.of_tree t1)\n (Enum.of_tree t2)\n ~init:()\n ~f:(fun ~key ~data () -> f ~key ~data)\n ;;\n\n let fold2 t1 t2 ~init ~f ~compare_key =\n Enum.fold2 compare_key (Enum.of_tree t1) (Enum.of_tree t2) ~f ~init\n ;;\n\n let symmetric_diff = Enum.symmetric_diff\n\n let fold_symmetric_diff t1 t2 ~compare_key ~data_equal ~init ~f =\n (* [Enum.fold_diffs] is a correct implementation of this function, but is considerably\n slower, as we have to allocate quite a lot of state to track enumeration of a tree.\n Avoid if we can.\n *)\n let slow x y ~init =\n Enum.fold_symmetric_diff x y ~compare_key ~data_equal ~f ~init\n in\n let add acc k v = f acc (k, `Right v) in\n let remove acc k v = f acc (k, `Left v) in\n let delta acc k v v' =\n if data_equal v v' then acc else f acc (k, `Unequal (v, v'))\n in\n (* If two trees have the same structure at the root (and the same key, if they're\n [Node]s) we can trivially diff each subpart in obvious ways. *)\n let rec loop t t' acc =\n if phys_equal t t'\n then acc\n else (\n match t, t' with\n | Empty, new_vals ->\n fold new_vals ~init:acc ~f:(fun ~key ~data acc -> add acc key data)\n | old_vals, Empty ->\n fold old_vals ~init:acc ~f:(fun ~key ~data acc -> remove acc key data)\n | Leaf (k, v), Leaf (k', v') ->\n (match compare_key k k' with\n | x when x = 0 -> delta acc k v v'\n | x when x < 0 ->\n let acc = remove acc k v in\n add acc k' v'\n | _ (* when x > 0 *) ->\n let acc = add acc k' v' in\n remove acc k v)\n | Node (l, k, v, r, _), Node (l', k', v', r', _) when compare_key k k' = 0 ->\n let acc = loop l l' acc in\n let acc = delta acc k v v' in\n loop r r' acc\n (* Our roots aren't the same key. Fallback to the slow mode. Trees with small\n diffs will only do this on very small parts of the tree (hopefully - if the\n overall root is rebalanced, we'll eat the whole cost, unfortunately.) *)\n | Node _, Node _ | Node _, Leaf _ | Leaf _, Node _ -> slow t t' ~init:acc)\n in\n loop t1 t2 init\n ;;\n\n let rec length = function\n | Empty -> 0\n | Leaf _ -> 1\n | Node (l, _, _, r, _) -> length l + length r + 1\n ;;\n\n let hash_fold_t_ignoring_structure hash_fold_key hash_fold_data state t =\n fold\n t\n ~init:(hash_fold_int state (length t))\n ~f:(fun ~key ~data state -> hash_fold_data (hash_fold_key state key) data)\n ;;\n\n let keys t = fold_right ~f:(fun ~key ~data:_ list -> key :: list) t ~init:[]\n let data t = fold_right ~f:(fun ~key:_ ~data list -> data :: list) t ~init:[]\n\n module type Foldable = sig\n val name : string\n\n type 'a t\n\n val fold : 'a t -> init:'b -> f:('b -> 'a -> 'b) -> 'b\n end\n\n module Of_foldable (M : Foldable) = struct\n let of_foldable_fold foldable ~init ~f ~compare_key =\n M.fold foldable ~init:(empty, 0) ~f:(fun (accum, length) (key, data) ->\n let prev_data =\n match find accum key ~compare_key with\n | None -> init\n | Some prev -> prev\n in\n let data = f prev_data data in\n set accum ~length ~key ~data ~compare_key)\n ;;\n\n let of_foldable_reduce foldable ~f ~compare_key =\n M.fold foldable ~init:(empty, 0) ~f:(fun (accum, length) (key, data) ->\n let new_data =\n match find accum key ~compare_key with\n | None -> data\n | Some prev -> f prev data\n in\n set accum ~length ~key ~data:new_data ~compare_key)\n ;;\n\n let of_foldable foldable ~compare_key =\n with_return (fun r ->\n let map =\n M.fold foldable ~init:(empty, 0) ~f:(fun (t, length) (key, data) ->\n let ((_, length') as acc) = set ~length ~key ~data t ~compare_key in\n if length = length' then r.return (`Duplicate_key key) else acc)\n in\n `Ok map)\n ;;\n\n let of_foldable_or_error foldable ~comparator =\n match of_foldable foldable ~compare_key:comparator.Comparator.compare with\n | `Ok x -> Result.Ok x\n | `Duplicate_key key ->\n Or_error.error\n (\"Map.of_\" ^ M.name ^ \"_or_error: duplicate key\")\n key\n comparator.sexp_of_t\n ;;\n\n let of_foldable_exn foldable ~comparator =\n match of_foldable foldable ~compare_key:comparator.Comparator.compare with\n | `Ok x -> x\n | `Duplicate_key key ->\n Error.create\n (\"Map.of_\" ^ M.name ^ \"_exn: duplicate key\")\n key\n comparator.sexp_of_t\n |> Error.raise\n ;;\n end\n\n module Of_alist = Of_foldable (struct\n let name = \"alist\"\n\n type 'a t = 'a list\n\n let fold = List.fold\n end)\n\n let of_alist_fold = Of_alist.of_foldable_fold\n let of_alist_reduce = Of_alist.of_foldable_reduce\n let of_alist = Of_alist.of_foldable\n let of_alist_or_error = Of_alist.of_foldable_or_error\n let of_alist_exn = Of_alist.of_foldable_exn\n\n (* Reverse the input, then fold from left to right. The resulting map uses the first\n instance of each key from the input list. The relative ordering of elements in each\n output list is the same as in the input list. *)\n let of_foldable_multi foldable ~fold ~compare_key =\n let alist = fold foldable ~init:[] ~f:(fun l x -> x :: l) in\n of_alist_fold alist ~init:[] ~f:(fun l x -> x :: l) ~compare_key\n ;;\n\n let of_alist_multi alist ~compare_key =\n of_foldable_multi alist ~fold:List.fold ~compare_key\n ;;\n\n module Of_sequence = Of_foldable (struct\n let name = \"sequence\"\n\n type 'a t = 'a Sequence.t\n\n let fold = Sequence.fold\n end)\n\n let of_sequence_fold = Of_sequence.of_foldable_fold\n let of_sequence_reduce = Of_sequence.of_foldable_reduce\n let of_sequence = Of_sequence.of_foldable\n let of_sequence_or_error = Of_sequence.of_foldable_or_error\n let of_sequence_exn = Of_sequence.of_foldable_exn\n\n let of_sequence_multi sequence ~compare_key =\n of_foldable_multi sequence ~fold:Sequence.fold ~compare_key\n ;;\n\n let for_all t ~f =\n with_return (fun r ->\n iter t ~f:(fun data -> if not (f data) then r.return false);\n true)\n ;;\n\n let for_alli t ~f =\n with_return (fun r ->\n iteri t ~f:(fun ~key ~data -> if not (f ~key ~data) then r.return false);\n true)\n ;;\n\n let exists t ~f =\n with_return (fun r ->\n iter t ~f:(fun data -> if f data then r.return true);\n false)\n ;;\n\n let existsi t ~f =\n with_return (fun r ->\n iteri t ~f:(fun ~key ~data -> if f ~key ~data then r.return true);\n false)\n ;;\n\n let count t ~f =\n fold t ~init:0 ~f:(fun ~key:_ ~data acc -> if f data then acc + 1 else acc)\n ;;\n\n let counti t ~f =\n fold t ~init:0 ~f:(fun ~key ~data acc -> if f ~key ~data then acc + 1 else acc)\n ;;\n\n let to_alist ?(key_order = `Increasing) t =\n match key_order with\n | `Increasing -> fold_right t ~init:[] ~f:(fun ~key ~data x -> (key, data) :: x)\n | `Decreasing -> fold t ~init:[] ~f:(fun ~key ~data x -> (key, data) :: x)\n ;;\n\n let merge t1 t2 ~f ~compare_key =\n let elts = Uniform_array.unsafe_create_uninitialized ~len:(length t1 + length t2) in\n let i = ref 0 in\n iter2 t1 t2 ~compare_key ~f:(fun ~key ~data:values ->\n match f ~key values with\n | Some value ->\n Uniform_array.set elts !i (key, value);\n incr i\n | None -> ());\n let len = !i in\n let get i = Uniform_array.get elts i in\n let tree = of_increasing_iterator_unchecked ~len ~f:get in\n tree, len\n ;;\n\n module Closest_key_impl = struct\n (* [marker] and [repackage] allow us to create \"logical\" options without actually\n allocating any options. Passing [Found key value] to a function is equivalent to\n passing [Some (key, value)]; passing [Missing () ()] is equivalent to passing\n [None]. *)\n type ('k, 'v, 'k_opt, 'v_opt) marker =\n | Missing : ('k, 'v, unit, unit) marker\n | Found : ('k, 'v, 'k, 'v) marker\n\n let repackage\n (type k v k_opt v_opt)\n (marker : (k, v, k_opt, v_opt) marker)\n (k : k_opt)\n (v : v_opt)\n : (k * v) option\n =\n match marker with\n | Missing -> None\n | Found -> Some (k, v)\n ;;\n\n (* The type signature is explicit here to allow polymorphic recursion. *)\n let rec loop :\n 'k 'v 'k_opt 'v_opt. ('k, 'v) tree\n -> [ `Greater_or_equal_to | `Greater_than | `Less_or_equal_to | `Less_than ]\n -> 'k -> compare_key:('k -> 'k -> int) -> ('k, 'v, 'k_opt, 'v_opt) marker\n -> 'k_opt -> 'v_opt -> ('k * 'v) option\n =\n fun t dir k ~compare_key found_marker found_key found_value ->\n match t with\n | Empty -> repackage found_marker found_key found_value\n | Leaf (k', v') ->\n let c = compare_key k' k in\n if match dir with\n | `Greater_or_equal_to -> c >= 0\n | `Greater_than -> c > 0\n | `Less_or_equal_to -> c <= 0\n | `Less_than -> c < 0\n then Some (k', v')\n else repackage found_marker found_key found_value\n | Node (l, k', v', r, _) ->\n let c = compare_key k' k in\n if c = 0\n then (\n (* This is a base case (no recursive call). *)\n match dir with\n | `Greater_or_equal_to | `Less_or_equal_to -> Some (k', v')\n | `Greater_than ->\n if is_empty r\n then repackage found_marker found_key found_value\n else min_elt r\n | `Less_than ->\n if is_empty l\n then repackage found_marker found_key found_value\n else max_elt l)\n else (\n (* We are guaranteed here that k' <> k. *)\n (* This is the only recursive case. *)\n match dir with\n | `Greater_or_equal_to | `Greater_than ->\n if c > 0\n then loop l dir k ~compare_key Found k' v'\n else loop r dir k ~compare_key found_marker found_key found_value\n | `Less_or_equal_to | `Less_than ->\n if c < 0\n then loop r dir k ~compare_key Found k' v'\n else loop l dir k ~compare_key found_marker found_key found_value)\n ;;\n\n let closest_key t dir k ~compare_key = loop t dir k ~compare_key Missing () ()\n end\n\n let closest_key = Closest_key_impl.closest_key\n\n let rec rank t k ~compare_key =\n match t with\n | Empty -> None\n | Leaf (k', _) -> if compare_key k' k = 0 then Some 0 else None\n | Node (l, k', _, r, _) ->\n let c = compare_key k' k in\n if c = 0\n then Some (length l)\n else if c > 0\n then rank l k ~compare_key\n else Option.map (rank r k ~compare_key) ~f:(fun rank -> rank + 1 + length l)\n ;;\n\n (* this could be implemented using [Sequence] interface but the following implementation\n allocates only 2 words and doesn't require write-barrier *)\n let rec nth' num_to_search = function\n | Empty -> None\n | Leaf (k, v) ->\n if !num_to_search = 0\n then Some (k, v)\n else (\n decr num_to_search;\n None)\n | Node (l, k, v, r, _) ->\n (match nth' num_to_search l with\n | Some _ as some -> some\n | None ->\n if !num_to_search = 0\n then Some (k, v)\n else (\n decr num_to_search;\n nth' num_to_search r))\n ;;\n\n let nth t n = nth' (ref n) t\n\n\n let rec find_first_satisfying t ~f =\n match t with\n | Empty -> None\n | Leaf (k, v) -> if f ~key:k ~data:v then Some (k, v) else None\n | Node (l, k, v, r, _) ->\n if f ~key:k ~data:v\n then (\n match find_first_satisfying l ~f with\n | None -> Some (k, v)\n | Some _ as x -> x)\n else find_first_satisfying r ~f\n ;;\n\n let rec find_last_satisfying t ~f =\n match t with\n | Empty -> None\n | Leaf (k, v) -> if f ~key:k ~data:v then Some (k, v) else None\n | Node (l, k, v, r, _) ->\n if f ~key:k ~data:v\n then (\n match find_last_satisfying r ~f with\n | None -> Some (k, v)\n | Some _ as x -> x)\n else find_last_satisfying l ~f\n ;;\n\n let binary_search t ~compare how v =\n match how with\n | `Last_strictly_less_than ->\n find_last_satisfying t ~f:(fun ~key ~data -> compare ~key ~data v < 0)\n | `Last_less_than_or_equal_to ->\n find_last_satisfying t ~f:(fun ~key ~data -> compare ~key ~data v <= 0)\n | `First_equal_to ->\n (match\n find_first_satisfying t ~f:(fun ~key ~data -> compare ~key ~data v >= 0)\n with\n | Some (key, data) as pair when compare ~key ~data v = 0 -> pair\n | None | Some _ -> None)\n | `Last_equal_to ->\n (match find_last_satisfying t ~f:(fun ~key ~data -> compare ~key ~data v <= 0) with\n | Some (key, data) as pair when compare ~key ~data v = 0 -> pair\n | None | Some _ -> None)\n | `First_greater_than_or_equal_to ->\n find_first_satisfying t ~f:(fun ~key ~data -> compare ~key ~data v >= 0)\n | `First_strictly_greater_than ->\n find_first_satisfying t ~f:(fun ~key ~data -> compare ~key ~data v > 0)\n ;;\n\n let binary_search_segmented t ~segment_of how =\n let is_left ~key ~data =\n match segment_of ~key ~data with\n | `Left -> true\n | `Right -> false\n in\n let is_right ~key ~data = not (is_left ~key ~data) in\n match how with\n | `Last_on_left -> find_last_satisfying t ~f:is_left\n | `First_on_right -> find_first_satisfying t ~f:is_right\n ;;\n\n type ('k, 'v) acc =\n { mutable bad_key : 'k option\n ; mutable map_length : ('k, 'v) t * int\n }\n\n let of_iteri ~iteri ~compare_key =\n let acc = { bad_key = None; map_length = empty, 0 } in\n iteri ~f:(fun ~key ~data ->\n let map, length = acc.map_length in\n let ((_, length') as pair) = set ~length ~key ~data map ~compare_key in\n if length = length' && Option.is_none acc.bad_key\n then acc.bad_key <- Some key\n else acc.map_length <- pair);\n match acc.bad_key with\n | None -> `Ok acc.map_length\n | Some key -> `Duplicate_key key\n ;;\n\n let t_of_sexp_direct key_of_sexp value_of_sexp sexp ~(comparator : _ Comparator.t) =\n let alist = list_of_sexp (pair_of_sexp key_of_sexp value_of_sexp) sexp in\n let compare_key = comparator.compare in\n match of_alist alist ~compare_key with\n | `Ok v -> v\n | `Duplicate_key k ->\n (* find the sexp of a duplicate key, so the error is narrowed to a key and not\n the whole map *)\n let alist_sexps = list_of_sexp (pair_of_sexp Fn.id Fn.id) sexp in\n let found_first_k = ref false in\n List.iter2_ok alist alist_sexps ~f:(fun (k2, _) (k2_sexp, _) ->\n if compare_key k k2 = 0\n then\n if !found_first_k\n then of_sexp_error \"Map.t_of_sexp_direct: duplicate key\" k2_sexp\n else found_first_k := true);\n assert false\n ;;\n\n let sexp_of_t sexp_of_key sexp_of_value t =\n let f ~key ~data acc = Sexp.List [ sexp_of_key key; sexp_of_value data ] :: acc in\n Sexp.List (fold_right ~f t ~init:[])\n ;;\n\n let combine_errors t ~compare_key ~sexp_of_key =\n let oks, (error_tree, _) = partition_map t ~compare_key ~f:Result.to_either in\n if is_empty error_tree\n then Ok oks\n else Or_error.error_s (sexp_of_t sexp_of_key Error.sexp_of_t error_tree)\n ;;\nend\n\ntype ('k, 'v, 'comparator) t =\n { (* [comparator] is the first field so that polymorphic equality fails on a map due\n to the functional value in the comparator.\n Note that this does not affect polymorphic [compare]: that still produces\n nonsense. *)\n comparator : ('k, 'comparator) Comparator.t\n ; tree : ('k, 'v) Tree0.t\n ; length : int\n }\n\ntype ('k, 'v, 'comparator) tree = ('k, 'v) Tree0.t\n\nlet compare_key t = t.comparator.Comparator.compare\n\n\nlet like { tree = _; length = _; comparator } (tree, length) =\n { tree; length; comparator }\n;;\n\nlet like2 x (y, z) = like x y, like x z\nlet with_same_length { tree = _; comparator; length } tree = { tree; comparator; length }\nlet of_tree ~comparator tree = { tree; comparator; length = Tree0.length tree }\n\n(* Exposing this function would make it very easy for the invariants\n of this module to be broken. *)\nlet of_tree_unsafe ~comparator ~length tree = { tree; comparator; length }\n\nmodule Accessors = struct\n let comparator t = t.comparator\n let to_tree t = t.tree\n let invariants t = Tree0.invariants t.tree ~compare_key:(compare_key t)\n let is_empty t = Tree0.is_empty t.tree\n let length t = t.length\n\n let set t ~key ~data =\n like t (Tree0.set t.tree ~length:t.length ~key ~data ~compare_key:(compare_key t))\n ;;\n\n let add_exn t ~key ~data =\n like\n t\n (Tree0.add_exn\n t.tree\n ~length:t.length\n ~key\n ~data\n ~compare_key:(compare_key t)\n ~sexp_of_key:t.comparator.sexp_of_t)\n ;;\n\n let add_exn_internal t ~key ~data =\n like\n t\n (Tree0.add_exn_internal\n t.tree\n ~length:t.length\n ~key\n ~data\n ~compare_key:(compare_key t)\n ~sexp_of_key:t.comparator.sexp_of_t)\n ;;\n\n let add t ~key ~data =\n match add_exn_internal t ~key ~data with\n | result -> `Ok result\n | exception Duplicate -> `Duplicate\n ;;\n\n let add_multi t ~key ~data =\n like\n t\n (Tree0.add_multi t.tree ~length:t.length ~key ~data ~compare_key:(compare_key t))\n ;;\n\n let remove_multi t key =\n like t (Tree0.remove_multi t.tree ~length:t.length key ~compare_key:(compare_key t))\n ;;\n\n let find_multi t key = Tree0.find_multi t.tree key ~compare_key:(compare_key t)\n\n let change t key ~f =\n like t (Tree0.change t.tree key ~f ~length:t.length ~compare_key:(compare_key t))\n ;;\n\n let update t key ~f =\n like t (Tree0.update t.tree key ~f ~length:t.length ~compare_key:(compare_key t))\n ;;\n\n let find_exn t key =\n Tree0.find_exn\n t.tree\n key\n ~compare_key:(compare_key t)\n ~sexp_of_key:t.comparator.sexp_of_t\n ;;\n\n let find t key = Tree0.find t.tree key ~compare_key:(compare_key t)\n\n let remove t key =\n like t (Tree0.remove t.tree key ~length:t.length ~compare_key:(compare_key t))\n ;;\n\n let mem t key = Tree0.mem t.tree key ~compare_key:(compare_key t)\n let iter_keys t ~f = Tree0.iter_keys t.tree ~f\n let iter t ~f = Tree0.iter t.tree ~f\n let iteri t ~f = Tree0.iteri t.tree ~f\n let iteri_until t ~f = Tree0.iteri_until t.tree ~f\n let iter2 t1 t2 ~f = Tree0.iter2 t1.tree t2.tree ~f ~compare_key:(compare_key t1)\n let map t ~f = with_same_length t (Tree0.map t.tree ~f)\n let mapi t ~f = with_same_length t (Tree0.mapi t.tree ~f)\n let fold t ~init ~f = Tree0.fold t.tree ~f ~init\n let fold_right t ~init ~f = Tree0.fold_right t.tree ~f ~init\n\n let fold2 t1 t2 ~init ~f =\n Tree0.fold2 t1.tree t2.tree ~init ~f ~compare_key:(compare_key t1)\n ;;\n\n let filter_keys t ~f =\n like t (Tree0.filter_keys t.tree ~f ~compare_key:(compare_key t))\n ;;\n\n let filter t ~f = like t (Tree0.filter t.tree ~f ~compare_key:(compare_key t))\n let filteri t ~f = like t (Tree0.filteri t.tree ~f ~compare_key:(compare_key t))\n let filter_map t ~f = like t (Tree0.filter_map t.tree ~f ~compare_key:(compare_key t))\n\n let filter_mapi t ~f =\n like t (Tree0.filter_mapi t.tree ~f ~compare_key:(compare_key t))\n ;;\n\n let partition_mapi t ~f =\n like2 t (Tree0.partition_mapi t.tree ~f ~compare_key:(compare_key t))\n ;;\n\n let partition_map t ~f =\n like2 t (Tree0.partition_map t.tree ~f ~compare_key:(compare_key t))\n ;;\n\n let partitioni_tf t ~f =\n like2 t (Tree0.partitioni_tf t.tree ~f ~compare_key:(compare_key t))\n ;;\n\n let partition_tf t ~f =\n like2 t (Tree0.partition_tf t.tree ~f ~compare_key:(compare_key t))\n ;;\n\n let combine_errors t =\n Or_error.map\n ~f:(like t)\n (Tree0.combine_errors\n t.tree\n ~compare_key:(compare_key t)\n ~sexp_of_key:t.comparator.sexp_of_t)\n ;;\n\n let compare_direct compare_data t1 t2 =\n Tree0.compare (compare_key t1) compare_data t1.tree t2.tree\n ;;\n\n let equal compare_data t1 t2 =\n Tree0.equal (compare_key t1) compare_data t1.tree t2.tree\n ;;\n\n let keys t = Tree0.keys t.tree\n let data t = Tree0.data t.tree\n let to_alist ?key_order t = Tree0.to_alist ?key_order t.tree\n let validate ~name f t = Validate.alist ~name f (to_alist t)\n let validatei ~name f t = Validate.list ~name:(Fn.compose name fst) f (to_alist t)\n\n let symmetric_diff t1 t2 ~data_equal =\n Tree0.symmetric_diff t1.tree t2.tree ~compare_key:(compare_key t1) ~data_equal\n ;;\n\n let fold_symmetric_diff t1 t2 ~data_equal ~init ~f =\n Tree0.fold_symmetric_diff\n t1.tree\n t2.tree\n ~compare_key:(compare_key t1)\n ~data_equal\n ~init\n ~f\n ;;\n\n let merge t1 t2 ~f =\n like t1 (Tree0.merge t1.tree t2.tree ~f ~compare_key:(compare_key t1))\n ;;\n\n let min_elt t = Tree0.min_elt t.tree\n let min_elt_exn t = Tree0.min_elt_exn t.tree\n let max_elt t = Tree0.max_elt t.tree\n let max_elt_exn t = Tree0.max_elt_exn t.tree\n let for_all t ~f = Tree0.for_all t.tree ~f\n let for_alli t ~f = Tree0.for_alli t.tree ~f\n let exists t ~f = Tree0.exists t.tree ~f\n let existsi t ~f = Tree0.existsi t.tree ~f\n let count t ~f = Tree0.count t.tree ~f\n let counti t ~f = Tree0.counti t.tree ~f\n\n let split t k =\n let l, maybe, r = Tree0.split t.tree k ~compare_key:(compare_key t) in\n let comparator = comparator t in\n (* Try to traverse the least amount possible to calculate the length,\n using height as a heuristic. *)\n let both_len = if Option.is_some maybe then t.length - 1 else t.length in\n if Tree0.height l < Tree0.height r\n then (\n let l = of_tree l ~comparator in\n l, maybe, of_tree_unsafe r ~comparator ~length:(both_len - length l))\n else (\n let r = of_tree r ~comparator in\n of_tree_unsafe l ~comparator ~length:(both_len - length r), maybe, r)\n ;;\n\n let subrange t ~lower_bound ~upper_bound =\n let left, mid, right =\n Tree0.split_range t.tree ~lower_bound ~upper_bound ~compare_key:(compare_key t)\n in\n (* Try to traverse the least amount possible to calculate the length,\n using height as a heuristic. *)\n let outer_joined_height =\n let h_l = Tree0.height left\n and h_r = Tree0.height right in\n if h_l = h_r then h_l + 1 else max h_l h_r\n in\n if outer_joined_height < Tree0.height mid\n then (\n let mid_length = t.length - (Tree0.length left + Tree0.length right) in\n of_tree_unsafe mid ~comparator:(comparator t) ~length:mid_length)\n else of_tree mid ~comparator:(comparator t)\n ;;\n\n let append ~lower_part ~upper_part =\n match\n Tree0.append\n ~compare_key:(compare_key lower_part)\n ~lower_part:lower_part.tree\n ~upper_part:upper_part.tree\n with\n | `Ok tree ->\n `Ok\n (of_tree_unsafe\n tree\n ~comparator:(comparator lower_part)\n ~length:(lower_part.length + upper_part.length))\n | `Overlapping_key_ranges -> `Overlapping_key_ranges\n ;;\n\n let fold_range_inclusive t ~min ~max ~init ~f =\n Tree0.fold_range_inclusive t.tree ~min ~max ~init ~f ~compare_key:(compare_key t)\n ;;\n\n let range_to_alist t ~min ~max =\n Tree0.range_to_alist t.tree ~min ~max ~compare_key:(compare_key t)\n ;;\n\n let closest_key t dir key =\n Tree0.closest_key t.tree dir key ~compare_key:(compare_key t)\n ;;\n\n let nth t n = Tree0.nth t.tree n\n let nth_exn t n = Option.value_exn (nth t n)\n let rank t key = Tree0.rank t.tree key ~compare_key:(compare_key t)\n let sexp_of_t sexp_of_k sexp_of_v _ t = Tree0.sexp_of_t sexp_of_k sexp_of_v t.tree\n\n let to_sequence ?order ?keys_greater_or_equal_to ?keys_less_or_equal_to t =\n Tree0.to_sequence\n t.comparator\n ?order\n ?keys_greater_or_equal_to\n ?keys_less_or_equal_to\n t.tree\n ;;\n\n let binary_search t ~compare how v = Tree0.binary_search t.tree ~compare how v\n\n let binary_search_segmented t ~segment_of how =\n Tree0.binary_search_segmented t.tree ~segment_of how\n ;;\n\n let hash_fold_direct hash_fold_key hash_fold_data state t =\n Tree0.hash_fold_t_ignoring_structure hash_fold_key hash_fold_data state t.tree\n ;;\nend\n\n(* [0] is used as the [length] argument everywhere in this module, since trees do not\n have their lengths stored at the root, unlike maps. The values are discarded always. *)\nmodule Tree = struct\n type ('k, 'v, 'comparator) t = ('k, 'v, 'comparator) tree\n\n let empty_without_value_restriction = Tree0.empty\n let empty ~comparator:_ = empty_without_value_restriction\n let of_tree ~comparator:_ tree = tree\n let singleton ~comparator:_ k v = Tree0.singleton k v\n\n let of_sorted_array_unchecked ~comparator array =\n fst\n (Tree0.of_sorted_array_unchecked array ~compare_key:comparator.Comparator.compare)\n ;;\n\n let of_sorted_array ~comparator array =\n Tree0.of_sorted_array array ~compare_key:comparator.Comparator.compare\n |> Or_error.map ~f:fst\n ;;\n\n let of_alist ~comparator alist =\n match Tree0.of_alist alist ~compare_key:comparator.Comparator.compare with\n | `Duplicate_key _ as d -> d\n | `Ok (tree, _size) -> `Ok tree\n ;;\n\n let of_alist_or_error ~comparator alist =\n Tree0.of_alist_or_error alist ~comparator |> Or_error.map ~f:fst\n ;;\n\n let of_alist_exn ~comparator alist = fst (Tree0.of_alist_exn alist ~comparator)\n\n let of_alist_multi ~comparator alist =\n fst (Tree0.of_alist_multi alist ~compare_key:comparator.Comparator.compare)\n ;;\n\n let of_alist_fold ~comparator alist ~init ~f =\n fst (Tree0.of_alist_fold alist ~init ~f ~compare_key:comparator.Comparator.compare)\n ;;\n\n let of_alist_reduce ~comparator alist ~f =\n fst (Tree0.of_alist_reduce alist ~f ~compare_key:comparator.Comparator.compare)\n ;;\n\n let of_iteri ~comparator ~iteri =\n match Tree0.of_iteri ~iteri ~compare_key:comparator.Comparator.compare with\n | `Ok (tree, _size) -> `Ok tree\n | `Duplicate_key _ as d -> d\n ;;\n\n let of_increasing_iterator_unchecked ~comparator:_required_by_intf ~len ~f =\n Tree0.of_increasing_iterator_unchecked ~len ~f\n ;;\n\n let of_increasing_sequence ~comparator seq =\n Or_error.map\n ~f:fst\n (Tree0.of_increasing_sequence seq ~compare_key:comparator.Comparator.compare)\n ;;\n\n let of_sequence ~comparator seq =\n match Tree0.of_sequence seq ~compare_key:comparator.Comparator.compare with\n | `Duplicate_key _ as d -> d\n | `Ok (tree, _size) -> `Ok tree\n ;;\n\n let of_sequence_or_error ~comparator seq =\n Tree0.of_sequence_or_error seq ~comparator |> Or_error.map ~f:fst\n ;;\n\n let of_sequence_exn ~comparator seq = fst (Tree0.of_sequence_exn seq ~comparator)\n\n let of_sequence_multi ~comparator seq =\n fst (Tree0.of_sequence_multi seq ~compare_key:comparator.Comparator.compare)\n ;;\n\n let of_sequence_fold ~comparator seq ~init ~f =\n fst (Tree0.of_sequence_fold seq ~init ~f ~compare_key:comparator.Comparator.compare)\n ;;\n\n let of_sequence_reduce ~comparator seq ~f =\n fst (Tree0.of_sequence_reduce seq ~f ~compare_key:comparator.Comparator.compare)\n ;;\n\n let to_tree t = t\n\n let invariants ~comparator t =\n Tree0.invariants t ~compare_key:comparator.Comparator.compare\n ;;\n\n let is_empty t = Tree0.is_empty t\n let length t = Tree0.length t\n\n let set ~comparator t ~key ~data =\n fst (Tree0.set t ~key ~data ~length:0 ~compare_key:comparator.Comparator.compare)\n ;;\n\n let add_exn ~comparator t ~key ~data =\n fst\n (Tree0.add_exn\n t\n ~key\n ~data\n ~length:0\n ~compare_key:comparator.Comparator.compare\n ~sexp_of_key:comparator.sexp_of_t)\n ;;\n\n let add ~comparator t ~key ~data =\n try `Ok (add_exn t ~comparator ~key ~data) with\n | _ -> `Duplicate\n ;;\n\n let add_multi ~comparator t ~key ~data =\n Tree0.add_multi t ~key ~data ~length:0 ~compare_key:comparator.Comparator.compare\n |> fst\n ;;\n\n let remove_multi ~comparator t key =\n Tree0.remove_multi t key ~length:0 ~compare_key:comparator.Comparator.compare |> fst\n ;;\n\n let find_multi ~comparator t key =\n Tree0.find_multi t key ~compare_key:comparator.Comparator.compare\n ;;\n\n let change ~comparator t key ~f =\n fst (Tree0.change t key ~f ~length:0 ~compare_key:comparator.Comparator.compare)\n ;;\n\n let update ~comparator t key ~f =\n change ~comparator t key ~f:(fun data -> Some (f data))\n ;;\n\n let find_exn ~comparator t key =\n Tree0.find_exn\n t\n key\n ~compare_key:comparator.Comparator.compare\n ~sexp_of_key:comparator.Comparator.sexp_of_t\n ;;\n\n let find ~comparator t key =\n Tree0.find t key ~compare_key:comparator.Comparator.compare\n ;;\n\n let remove ~comparator t key =\n fst (Tree0.remove t key ~length:0 ~compare_key:comparator.Comparator.compare)\n ;;\n\n let mem ~comparator t key = Tree0.mem t key ~compare_key:comparator.Comparator.compare\n let iter_keys t ~f = Tree0.iter_keys t ~f\n let iter t ~f = Tree0.iter t ~f\n let iteri t ~f = Tree0.iteri t ~f\n let iteri_until t ~f = Tree0.iteri_until t ~f\n\n let iter2 ~comparator t1 t2 ~f =\n Tree0.iter2 t1 t2 ~f ~compare_key:comparator.Comparator.compare\n ;;\n\n let map t ~f = Tree0.map t ~f\n let mapi t ~f = Tree0.mapi t ~f\n let fold t ~init ~f = Tree0.fold t ~f ~init\n let fold_right t ~init ~f = Tree0.fold_right t ~f ~init\n\n let fold2 ~comparator t1 t2 ~init ~f =\n Tree0.fold2 t1 t2 ~init ~f ~compare_key:comparator.Comparator.compare\n ;;\n\n let filter_keys ~comparator t ~f =\n fst (Tree0.filter_keys t ~f ~compare_key:comparator.Comparator.compare)\n ;;\n\n let filter ~comparator t ~f =\n fst (Tree0.filter t ~f ~compare_key:comparator.Comparator.compare)\n ;;\n\n let filteri ~comparator t ~f =\n fst (Tree0.filteri t ~f ~compare_key:comparator.Comparator.compare)\n ;;\n\n let filter_map ~comparator t ~f =\n fst (Tree0.filter_map t ~f ~compare_key:comparator.Comparator.compare)\n ;;\n\n let filter_mapi ~comparator t ~f =\n fst (Tree0.filter_mapi t ~f ~compare_key:comparator.Comparator.compare)\n ;;\n\n let partition_mapi ~comparator t ~f =\n let (a, _), (b, _) =\n Tree0.partition_mapi t ~f ~compare_key:comparator.Comparator.compare\n in\n a, b\n ;;\n\n let partition_map ~comparator t ~f =\n let (a, _), (b, _) =\n Tree0.partition_map t ~f ~compare_key:comparator.Comparator.compare\n in\n a, b\n ;;\n\n let partitioni_tf ~comparator t ~f =\n let (a, _), (b, _) =\n Tree0.partitioni_tf t ~f ~compare_key:comparator.Comparator.compare\n in\n a, b\n ;;\n\n let partition_tf ~comparator t ~f =\n let (a, _), (b, _) =\n Tree0.partition_tf t ~f ~compare_key:comparator.Comparator.compare\n in\n a, b\n ;;\n\n let combine_errors ~comparator t =\n Or_error.map\n ~f:fst\n (Tree0.combine_errors\n t\n ~compare_key:comparator.Comparator.compare\n ~sexp_of_key:comparator.Comparator.sexp_of_t)\n ;;\n\n let compare_direct ~comparator compare_data t1 t2 =\n Tree0.compare comparator.Comparator.compare compare_data t1 t2\n ;;\n\n let equal ~comparator compare_data t1 t2 =\n Tree0.equal comparator.Comparator.compare compare_data t1 t2\n ;;\n\n let keys t = Tree0.keys t\n let data t = Tree0.data t\n let to_alist ?key_order t = Tree0.to_alist ?key_order t\n let validate ~name f t = Validate.alist ~name f (to_alist t)\n let validatei ~name f t = Validate.list ~name:(Fn.compose name fst) f (to_alist t)\n\n let symmetric_diff ~comparator t1 t2 ~data_equal =\n Tree0.symmetric_diff t1 t2 ~compare_key:comparator.Comparator.compare ~data_equal\n ;;\n\n let fold_symmetric_diff ~comparator t1 t2 ~data_equal ~init ~f =\n Tree0.fold_symmetric_diff\n t1\n t2\n ~compare_key:comparator.Comparator.compare\n ~data_equal\n ~init\n ~f\n ;;\n\n let merge ~comparator t1 t2 ~f =\n fst (Tree0.merge t1 t2 ~f ~compare_key:comparator.Comparator.compare)\n ;;\n\n let min_elt t = Tree0.min_elt t\n let min_elt_exn t = Tree0.min_elt_exn t\n let max_elt t = Tree0.max_elt t\n let max_elt_exn t = Tree0.max_elt_exn t\n let for_all t ~f = Tree0.for_all t ~f\n let for_alli t ~f = Tree0.for_alli t ~f\n let exists t ~f = Tree0.exists t ~f\n let existsi t ~f = Tree0.existsi t ~f\n let count t ~f = Tree0.count t ~f\n let counti t ~f = Tree0.counti t ~f\n let split ~comparator t k = Tree0.split t k ~compare_key:comparator.Comparator.compare\n\n let append ~comparator ~lower_part ~upper_part =\n Tree0.append ~lower_part ~upper_part ~compare_key:comparator.Comparator.compare\n ;;\n\n let subrange ~comparator t ~lower_bound ~upper_bound =\n let _, ret, _ =\n Tree0.split_range\n t\n ~lower_bound\n ~upper_bound\n ~compare_key:comparator.Comparator.compare\n in\n ret\n ;;\n\n let fold_range_inclusive ~comparator t ~min ~max ~init ~f =\n Tree0.fold_range_inclusive\n t\n ~min\n ~max\n ~init\n ~f\n ~compare_key:comparator.Comparator.compare\n ;;\n\n let range_to_alist ~comparator t ~min ~max =\n Tree0.range_to_alist t ~min ~max ~compare_key:comparator.Comparator.compare\n ;;\n\n let closest_key ~comparator t dir key =\n Tree0.closest_key t dir key ~compare_key:comparator.Comparator.compare\n ;;\n\n let nth ~comparator:_ t n = Tree0.nth t n\n let nth_exn ~comparator t n = Option.value_exn (nth ~comparator t n)\n\n let rank ~comparator t key =\n Tree0.rank t key ~compare_key:comparator.Comparator.compare\n ;;\n\n let sexp_of_t sexp_of_k sexp_of_v _ t = Tree0.sexp_of_t sexp_of_k sexp_of_v t\n\n let t_of_sexp_direct ~comparator k_of_sexp v_of_sexp sexp =\n fst (Tree0.t_of_sexp_direct k_of_sexp v_of_sexp sexp ~comparator)\n ;;\n\n let to_sequence ~comparator ?order ?keys_greater_or_equal_to ?keys_less_or_equal_to t =\n Tree0.to_sequence\n comparator\n ?order\n ?keys_greater_or_equal_to\n ?keys_less_or_equal_to\n t\n ;;\n\n let binary_search ~comparator:_ t ~compare how v = Tree0.binary_search t ~compare how v\n\n let binary_search_segmented ~comparator:_ t ~segment_of how =\n Tree0.binary_search_segmented t ~segment_of how\n ;;\nend\n\nmodule Using_comparator = struct\n type nonrec ('k, 'v, 'cmp) t = ('k, 'v, 'cmp) t\n\n include Accessors\n\n let empty ~comparator = { tree = Tree0.empty; comparator; length = 0 }\n let singleton ~comparator k v = { comparator; tree = Tree0.singleton k v; length = 1 }\n let of_tree0 ~comparator (tree, length) = { comparator; tree; length }\n let of_tree ~comparator tree = of_tree0 ~comparator (tree, Tree0.length tree)\n let to_tree = to_tree\n\n let of_sorted_array_unchecked ~comparator array =\n of_tree0\n ~comparator\n (Tree0.of_sorted_array_unchecked array ~compare_key:comparator.Comparator.compare)\n ;;\n\n let of_sorted_array ~comparator array =\n Or_error.map\n (Tree0.of_sorted_array array ~compare_key:comparator.Comparator.compare)\n ~f:(fun tree -> of_tree0 ~comparator tree)\n ;;\n\n let of_alist ~comparator alist =\n match Tree0.of_alist alist ~compare_key:comparator.Comparator.compare with\n | `Ok (tree, length) -> `Ok { comparator; tree; length }\n | `Duplicate_key _ as z -> z\n ;;\n\n let of_alist_or_error ~comparator alist =\n Result.map (Tree0.of_alist_or_error alist ~comparator) ~f:(fun tree ->\n of_tree0 ~comparator tree)\n ;;\n\n let of_alist_exn ~comparator alist =\n of_tree0 ~comparator (Tree0.of_alist_exn alist ~comparator)\n ;;\n\n let of_alist_multi ~comparator alist =\n of_tree0\n ~comparator\n (Tree0.of_alist_multi alist ~compare_key:comparator.Comparator.compare)\n ;;\n\n let of_alist_fold ~comparator alist ~init ~f =\n of_tree0\n ~comparator\n (Tree0.of_alist_fold alist ~init ~f ~compare_key:comparator.Comparator.compare)\n ;;\n\n let of_alist_reduce ~comparator alist ~f =\n of_tree0\n ~comparator\n (Tree0.of_alist_reduce alist ~f ~compare_key:comparator.Comparator.compare)\n ;;\n\n let of_iteri ~comparator ~iteri =\n match Tree0.of_iteri ~compare_key:comparator.Comparator.compare ~iteri with\n | `Ok tree_length -> `Ok (of_tree0 ~comparator tree_length)\n | `Duplicate_key _ as z -> z\n ;;\n\n let of_increasing_iterator_unchecked ~comparator ~len ~f =\n of_tree0 ~comparator (Tree0.of_increasing_iterator_unchecked ~len ~f, len)\n ;;\n\n let of_increasing_sequence ~comparator seq =\n Or_error.map\n ~f:(of_tree0 ~comparator)\n (Tree0.of_increasing_sequence seq ~compare_key:comparator.Comparator.compare)\n ;;\n\n let of_sequence ~comparator seq =\n match Tree0.of_sequence seq ~compare_key:comparator.Comparator.compare with\n | `Ok (tree, length) -> `Ok { comparator; tree; length }\n | `Duplicate_key _ as z -> z\n ;;\n\n let of_sequence_or_error ~comparator seq =\n Result.map (Tree0.of_sequence_or_error seq ~comparator) ~f:(fun tree ->\n of_tree0 ~comparator tree)\n ;;\n\n let of_sequence_exn ~comparator seq =\n of_tree0 ~comparator (Tree0.of_sequence_exn seq ~comparator)\n ;;\n\n let of_sequence_multi ~comparator seq =\n of_tree0\n ~comparator\n (Tree0.of_sequence_multi seq ~compare_key:comparator.Comparator.compare)\n ;;\n\n let of_sequence_fold ~comparator seq ~init ~f =\n of_tree0\n ~comparator\n (Tree0.of_sequence_fold seq ~init ~f ~compare_key:comparator.Comparator.compare)\n ;;\n\n let of_sequence_reduce ~comparator seq ~f =\n of_tree0\n ~comparator\n (Tree0.of_sequence_reduce seq ~f ~compare_key:comparator.Comparator.compare)\n ;;\n\n let t_of_sexp_direct ~comparator k_of_sexp v_of_sexp sexp =\n of_tree0 ~comparator (Tree0.t_of_sexp_direct k_of_sexp v_of_sexp sexp ~comparator)\n ;;\n\n module Empty_without_value_restriction (K : Comparator.S1) = struct\n let empty = { tree = Tree0.empty; comparator = K.comparator; length = 0 }\n end\n\n module Tree = Tree\nend\n\ninclude Accessors\n\ntype ('k, 'cmp) comparator =\n (module Comparator.S with type t = 'k and type comparator_witness = 'cmp)\n\nlet comparator_s (type k cmp) t : (k, cmp) comparator =\n (module struct\n type t = k\n type comparator_witness = cmp\n\n let comparator = t.comparator\n end)\n;;\n\nlet to_comparator (type k cmp) ((module M) : (k, cmp) comparator) = M.comparator\nlet empty m = Using_comparator.empty ~comparator:(to_comparator m)\nlet singleton m a = Using_comparator.singleton ~comparator:(to_comparator m) a\nlet of_alist m a = Using_comparator.of_alist ~comparator:(to_comparator m) a\n\nlet of_alist_or_error m a =\n Using_comparator.of_alist_or_error ~comparator:(to_comparator m) a\n;;\n\nlet of_alist_exn m a = Using_comparator.of_alist_exn ~comparator:(to_comparator m) a\nlet of_alist_multi m a = Using_comparator.of_alist_multi ~comparator:(to_comparator m) a\n\nlet of_alist_fold m a ~init ~f =\n Using_comparator.of_alist_fold ~comparator:(to_comparator m) a ~init ~f\n;;\n\nlet of_alist_reduce m a ~f =\n Using_comparator.of_alist_reduce ~comparator:(to_comparator m) a ~f\n;;\n\nlet of_sorted_array_unchecked m a =\n Using_comparator.of_sorted_array_unchecked ~comparator:(to_comparator m) a\n;;\n\nlet of_sorted_array m a =\n Using_comparator.of_sorted_array ~comparator:(to_comparator m) a\n;;\n\nlet of_iteri m ~iteri = Using_comparator.of_iteri ~iteri ~comparator:(to_comparator m)\n\nlet of_increasing_iterator_unchecked m ~len ~f =\n Using_comparator.of_increasing_iterator_unchecked ~len ~f ~comparator:(to_comparator m)\n;;\n\nlet of_increasing_sequence m seq =\n Using_comparator.of_increasing_sequence ~comparator:(to_comparator m) seq\n;;\n\nlet of_sequence m s = Using_comparator.of_sequence ~comparator:(to_comparator m) s\n\nlet of_sequence_or_error m s =\n Using_comparator.of_sequence_or_error ~comparator:(to_comparator m) s\n;;\n\nlet of_sequence_exn m s =\n Using_comparator.of_sequence_exn ~comparator:(to_comparator m) s\n;;\n\nlet of_sequence_multi m s =\n Using_comparator.of_sequence_multi ~comparator:(to_comparator m) s\n;;\n\nlet of_sequence_fold m s ~init ~f =\n Using_comparator.of_sequence_fold ~comparator:(to_comparator m) s ~init ~f\n;;\n\nlet of_sequence_reduce m s ~f =\n Using_comparator.of_sequence_reduce ~comparator:(to_comparator m) s ~f\n;;\n\nmodule M (K : sig\n type t\n type comparator_witness\n end) =\nstruct\n type nonrec 'v t = (K.t, 'v, K.comparator_witness) t\nend\n\nmodule type Sexp_of_m = sig\n type t [@@deriving_inline sexp_of]\n\n val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t\n\n [@@@end]\nend\n\nmodule type M_of_sexp = sig\n type t [@@deriving_inline of_sexp]\n\n val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t\n\n [@@@end]\n\n include Comparator.S with type t := t\nend\n\nmodule type Compare_m = sig end\nmodule type Equal_m = sig end\nmodule type Hash_fold_m = Hasher.S\n\nlet sexp_of_m__t (type k) (module K : Sexp_of_m with type t = k) sexp_of_v t =\n sexp_of_t K.sexp_of_t sexp_of_v (fun _ -> Sexp.Atom \"_\") t\n;;\n\nlet m__t_of_sexp\n (type k cmp)\n (module K : M_of_sexp with type t = k and type comparator_witness = cmp)\n v_of_sexp\n sexp\n =\n Using_comparator.t_of_sexp_direct ~comparator:K.comparator K.t_of_sexp v_of_sexp sexp\n;;\n\nlet m__t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t =\n Inline\n (Explicit_bind\n ( [ \"'k\"; \"'v\" ]\n , Apply\n ( Grammar list_sexp_grammar\n , [ Apply\n ( Grammar Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.tuple2_sexp_grammar\n , [ Explicit_var 0; Explicit_var 1 ] )\n ] ) ))\n;;\n\nlet compare_m__t (module K : Compare_m) compare_v t1 t2 = compare_direct compare_v t1 t2\nlet equal_m__t (module K : Equal_m) equal_v t1 t2 = equal equal_v t1 t2\n\nlet hash_fold_m__t (type k) (module K : Hash_fold_m with type t = k) hash_fold_v state =\n hash_fold_direct K.hash_fold_t hash_fold_v state\n;;\n\nlet merge_skewed t1 t2 ~combine =\n let t1, t2, combine =\n if length t2 <= length t1\n then t1, t2, combine\n else t2, t1, fun ~key v1 v2 -> combine ~key v2 v1\n in\n fold t2 ~init:t1 ~f:(fun ~key ~data:v2 t1 ->\n change t1 key ~f:(function\n | None -> Some v2\n | Some v1 -> Some (combine ~key v1 v2)))\n;;\n\nmodule Poly = struct\n type nonrec ('k, 'v) t = ('k, 'v, Comparator.Poly.comparator_witness) t\n type nonrec ('k, 'v) tree = ('k, 'v) Tree0.t\n type comparator_witness = Comparator.Poly.comparator_witness\n\n include Accessors\n\n let comparator = Comparator.Poly.comparator\n let of_tree tree = { tree; comparator; length = Tree0.length tree }\n\n include Using_comparator.Empty_without_value_restriction (Comparator.Poly)\n\n let singleton a = Using_comparator.singleton ~comparator a\n let of_alist a = Using_comparator.of_alist ~comparator a\n let of_alist_or_error a = Using_comparator.of_alist_or_error ~comparator a\n let of_alist_exn a = Using_comparator.of_alist_exn ~comparator a\n let of_alist_multi a = Using_comparator.of_alist_multi ~comparator a\n let of_alist_fold a ~init ~f = Using_comparator.of_alist_fold ~comparator a ~init ~f\n let of_alist_reduce a ~f = Using_comparator.of_alist_reduce ~comparator a ~f\n\n let of_sorted_array_unchecked a =\n Using_comparator.of_sorted_array_unchecked ~comparator a\n ;;\n\n let of_sorted_array a = Using_comparator.of_sorted_array ~comparator a\n let of_iteri ~iteri = Using_comparator.of_iteri ~iteri ~comparator\n\n let of_increasing_iterator_unchecked ~len ~f =\n Using_comparator.of_increasing_iterator_unchecked ~len ~f ~comparator\n ;;\n\n let of_increasing_sequence seq =\n Using_comparator.of_increasing_sequence ~comparator seq\n ;;\n\n let of_sequence s = Using_comparator.of_sequence ~comparator s\n let of_sequence_or_error s = Using_comparator.of_sequence_or_error ~comparator s\n let of_sequence_exn s = Using_comparator.of_sequence_exn ~comparator s\n let of_sequence_multi s = Using_comparator.of_sequence_multi ~comparator s\n\n let of_sequence_fold s ~init ~f =\n Using_comparator.of_sequence_fold ~comparator s ~init ~f\n ;;\n\n let of_sequence_reduce s ~f = Using_comparator.of_sequence_reduce ~comparator s ~f\nend\n","open! Import\nopen! T\n\nmodule Or_duplicate = struct\n type 'a t =\n [ `Ok of 'a\n | `Duplicate\n ]\n [@@deriving_inline sexp_of]\n\n let sexp_of_t :\n 'a. ('a -> Ppx_sexp_conv_lib.Sexp.t) -> 'a t -> Ppx_sexp_conv_lib.Sexp.t\n =\n fun _of_a -> function\n | `Ok v0 -> Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"Ok\"; _of_a v0 ]\n | `Duplicate -> Ppx_sexp_conv_lib.Sexp.Atom \"Duplicate\"\n ;;\n\n [@@@end]\nend\n\nmodule Without_comparator = struct\n type ('key, 'cmp, 'z) t = 'z\nend\n\nmodule With_comparator = struct\n type ('key, 'cmp, 'z) t = comparator:('key, 'cmp) Comparator.t -> 'z\nend\n\nmodule With_first_class_module = struct\n type ('key, 'cmp, 'z) t =\n (module Comparator.S with type t = 'key and type comparator_witness = 'cmp) -> 'z\nend\n\nmodule Symmetric_diff_element = struct\n type ('k, 'v) t = 'k * [ `Left of 'v | `Right of 'v | `Unequal of 'v * 'v ]\n [@@deriving_inline compare, sexp]\n\n let compare :\n 'k 'v. ('k -> 'k -> int) -> ('v -> 'v -> int) -> ('k, 'v) t -> ('k, 'v) t -> int\n =\n fun _cmp__k _cmp__v a__001_ b__002_ ->\n let t__003_, t__004_ = a__001_ in\n let t__005_, t__006_ = b__002_ in\n match _cmp__k t__003_ t__005_ with\n | 0 ->\n if Ppx_compare_lib.phys_equal t__004_ t__006_\n then 0\n else (\n match t__004_, t__006_ with\n | `Left _left__007_, `Left _right__008_ -> _cmp__v _left__007_ _right__008_\n | `Right _left__009_, `Right _right__010_ -> _cmp__v _left__009_ _right__010_\n | `Unequal _left__011_, `Unequal _right__012_ ->\n let t__013_, t__014_ = _left__011_ in\n let t__015_, t__016_ = _right__012_ in\n (match _cmp__v t__013_ t__015_ with\n | 0 -> _cmp__v t__014_ t__016_\n | n -> n)\n | x, y -> Ppx_compare_lib.polymorphic_compare x y)\n | n -> n\n ;;\n\n let t_of_sexp :\n 'k 'v. (Ppx_sexp_conv_lib.Sexp.t -> 'k) -> (Ppx_sexp_conv_lib.Sexp.t -> 'v)\n -> Ppx_sexp_conv_lib.Sexp.t -> ('k, 'v) t\n =\n let _tp_loc = \"map_intf.ml.Symmetric_diff_element.t\" in\n fun _of_k _of_v -> function\n | Ppx_sexp_conv_lib.Sexp.List [ v0; v1 ] ->\n let v0 = _of_k v0\n and v1 =\n (fun sexp ->\n try\n match sexp with\n | Ppx_sexp_conv_lib.Sexp.Atom atom as _sexp ->\n (match atom with\n | \"Left\" -> Ppx_sexp_conv_lib.Conv_error.ptag_takes_args _tp_loc _sexp\n | \"Right\" -> Ppx_sexp_conv_lib.Conv_error.ptag_takes_args _tp_loc _sexp\n | \"Unequal\" -> Ppx_sexp_conv_lib.Conv_error.ptag_takes_args _tp_loc _sexp\n | _ -> Ppx_sexp_conv_lib.Conv_error.no_variant_match ())\n | Ppx_sexp_conv_lib.Sexp.List\n (Ppx_sexp_conv_lib.Sexp.Atom atom :: sexp_args) as _sexp ->\n (match atom with\n | \"Left\" as _tag ->\n (match sexp_args with\n | [ v0 ] ->\n let v0 = _of_v v0 in\n `Left v0\n | _ ->\n Ppx_sexp_conv_lib.Conv_error.ptag_incorrect_n_args _tp_loc _tag _sexp)\n | \"Right\" as _tag ->\n (match sexp_args with\n | [ v0 ] ->\n let v0 = _of_v v0 in\n `Right v0\n | _ ->\n Ppx_sexp_conv_lib.Conv_error.ptag_incorrect_n_args _tp_loc _tag _sexp)\n | \"Unequal\" as _tag ->\n (match sexp_args with\n | [ v0 ] ->\n let v0 =\n match v0 with\n | Ppx_sexp_conv_lib.Sexp.List [ v0; v1 ] ->\n let v0 = _of_v v0\n and v1 = _of_v v1 in\n v0, v1\n | sexp ->\n Ppx_sexp_conv_lib.Conv_error.tuple_of_size_n_expected\n _tp_loc\n 2\n sexp\n in\n `Unequal v0\n | _ ->\n Ppx_sexp_conv_lib.Conv_error.ptag_incorrect_n_args _tp_loc _tag _sexp)\n | _ -> Ppx_sexp_conv_lib.Conv_error.no_variant_match ())\n | Ppx_sexp_conv_lib.Sexp.List (Ppx_sexp_conv_lib.Sexp.List _ :: _) as sexp\n -> Ppx_sexp_conv_lib.Conv_error.nested_list_invalid_poly_var _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.List [] as sexp ->\n Ppx_sexp_conv_lib.Conv_error.empty_list_invalid_poly_var _tp_loc sexp\n with\n | Ppx_sexp_conv_lib.Conv_error.No_variant_match ->\n Ppx_sexp_conv_lib.Conv_error.no_matching_variant_found _tp_loc sexp)\n v1\n in\n v0, v1\n | sexp -> Ppx_sexp_conv_lib.Conv_error.tuple_of_size_n_expected _tp_loc 2 sexp\n ;;\n\n let sexp_of_t :\n 'k 'v. ('k -> Ppx_sexp_conv_lib.Sexp.t) -> ('v -> Ppx_sexp_conv_lib.Sexp.t)\n -> ('k, 'v) t -> Ppx_sexp_conv_lib.Sexp.t\n =\n fun _of_k _of_v -> function\n | v0, v1 ->\n let v0 = _of_k v0\n and v1 =\n match v1 with\n | `Left v0 ->\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"Left\"; _of_v v0 ]\n | `Right v0 ->\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"Right\"; _of_v v0 ]\n | `Unequal v0 ->\n Ppx_sexp_conv_lib.Sexp.List\n [ Ppx_sexp_conv_lib.Sexp.Atom \"Unequal\"\n ; (let v0, v1 = v0 in\n let v0 = _of_v v0\n and v1 = _of_v v1 in\n Ppx_sexp_conv_lib.Sexp.List [ v0; v1 ])\n ]\n in\n Ppx_sexp_conv_lib.Sexp.List [ v0; v1 ]\n ;;\n\n [@@@end]\nend\n\nmodule Continue_or_stop = struct\n type t =\n | Continue\n | Stop\n [@@deriving_inline compare, enumerate, equal, sexp_of]\n\n let compare = (Ppx_compare_lib.polymorphic_compare : t -> t -> int)\n let all = ([ Continue; Stop ] : t list)\n let equal = (Ppx_compare_lib.polymorphic_equal : t -> t -> bool)\n\n let sexp_of_t =\n (function\n | Continue -> Ppx_sexp_conv_lib.Sexp.Atom \"Continue\"\n | Stop -> Ppx_sexp_conv_lib.Sexp.Atom \"Stop\"\n : t -> Ppx_sexp_conv_lib.Sexp.t)\n ;;\n\n [@@@end]\nend\n\nmodule Finished_or_unfinished = struct\n type t =\n | Finished\n | Unfinished\n [@@deriving_inline compare, enumerate, equal, sexp_of]\n\n let compare = (Ppx_compare_lib.polymorphic_compare : t -> t -> int)\n let all = ([ Finished; Unfinished ] : t list)\n let equal = (Ppx_compare_lib.polymorphic_equal : t -> t -> bool)\n\n let sexp_of_t =\n (function\n | Finished -> Ppx_sexp_conv_lib.Sexp.Atom \"Finished\"\n | Unfinished -> Ppx_sexp_conv_lib.Sexp.Atom \"Unfinished\"\n : t -> Ppx_sexp_conv_lib.Sexp.t)\n ;;\n\n [@@@end]\nend\n\nmodule type Accessors_generic = sig\n type ('a, 'b, 'cmp) t\n type ('a, 'b, 'cmp) tree\n type 'a key\n type 'cmp cmp\n type ('a, 'cmp, 'z) options\n\n val invariants : ('k, 'cmp, ('k, 'v, 'cmp) t -> bool) options\n val is_empty : (_, _, _) t -> bool\n val length : (_, _, _) t -> int\n\n val add\n : ( 'k\n , 'cmp\n , ('k, 'v, 'cmp) t -> key:'k key -> data:'v -> ('k, 'v, 'cmp) t Or_duplicate.t )\n options\n\n val add_exn\n : ('k, 'cmp, ('k, 'v, 'cmp) t -> key:'k key -> data:'v -> ('k, 'v, 'cmp) t) options\n\n val set\n : ('k, 'cmp, ('k, 'v, 'cmp) t -> key:'k key -> data:'v -> ('k, 'v, 'cmp) t) options\n\n val add_multi\n : ( 'k\n , 'cmp\n , ('k, 'v list, 'cmp) t -> key:'k key -> data:'v -> ('k, 'v list, 'cmp) t )\n options\n\n val remove_multi\n : ('k, 'cmp, ('k, 'v list, 'cmp) t -> 'k key -> ('k, 'v list, 'cmp) t) options\n\n val find_multi : ('k, 'cmp, ('k, 'v list, 'cmp) t -> 'k key -> 'v list) options\n\n val change\n : ( 'k\n , 'cmp\n , ('k, 'v, 'cmp) t -> 'k key -> f:('v option -> 'v option) -> ('k, 'v, 'cmp) t )\n options\n\n val update\n : ( 'k\n , 'cmp\n , ('k, 'v, 'cmp) t -> 'k key -> f:('v option -> 'v) -> ('k, 'v, 'cmp) t )\n options\n\n val find : ('k, 'cmp, ('k, 'v, 'cmp) t -> 'k key -> 'v option) options\n val find_exn : ('k, 'cmp, ('k, 'v, 'cmp) t -> 'k key -> 'v) options\n val remove : ('k, 'cmp, ('k, 'v, 'cmp) t -> 'k key -> ('k, 'v, 'cmp) t) options\n val mem : ('k, 'cmp, ('k, _, 'cmp) t -> 'k key -> bool) options\n val iter_keys : ('k, _, _) t -> f:('k key -> unit) -> unit\n val iter : (_, 'v, _) t -> f:('v -> unit) -> unit\n val iteri : ('k, 'v, _) t -> f:(key:'k key -> data:'v -> unit) -> unit\n\n val iteri_until\n : ('k, 'v, _) t\n -> f:(key:'k key -> data:'v -> Continue_or_stop.t)\n -> Finished_or_unfinished.t\n\n val iter2\n : ( 'k\n , 'cmp\n , ('k, 'v1, 'cmp) t\n -> ('k, 'v2, 'cmp) t\n -> f:(key:'k key\n -> data:[ `Left of 'v1 | `Right of 'v2 | `Both of 'v1 * 'v2 ]\n -> unit)\n -> unit )\n options\n\n val map : ('k, 'v1, 'cmp) t -> f:('v1 -> 'v2) -> ('k, 'v2, 'cmp) t\n val mapi : ('k, 'v1, 'cmp) t -> f:(key:'k key -> data:'v1 -> 'v2) -> ('k, 'v2, 'cmp) t\n val fold : ('k, 'v, _) t -> init:'a -> f:(key:'k key -> data:'v -> 'a -> 'a) -> 'a\n\n val fold_right\n : ('k, 'v, _) t\n -> init:'a\n -> f:(key:'k key -> data:'v -> 'a -> 'a)\n -> 'a\n\n val fold2\n : ( 'k\n , 'cmp\n , ('k, 'v1, 'cmp) t\n -> ('k, 'v2, 'cmp) t\n -> init:'a\n -> f:(key:'k key\n -> data:[ `Left of 'v1 | `Right of 'v2 | `Both of 'v1 * 'v2 ]\n -> 'a\n -> 'a)\n -> 'a )\n options\n\n val filter_keys\n : ('k, 'cmp, ('k, 'v, 'cmp) t -> f:('k key -> bool) -> ('k, 'v, 'cmp) t) options\n\n val filter : ('k, 'cmp, ('k, 'v, 'cmp) t -> f:('v -> bool) -> ('k, 'v, 'cmp) t) options\n\n val filteri\n : ( 'k\n , 'cmp\n , ('k, 'v, 'cmp) t -> f:(key:'k key -> data:'v -> bool) -> ('k, 'v, 'cmp) t )\n options\n\n val filter_map\n : ('k, 'cmp, ('k, 'v1, 'cmp) t -> f:('v1 -> 'v2 option) -> ('k, 'v2, 'cmp) t) options\n\n val filter_mapi\n : ( 'k\n , 'cmp\n , ('k, 'v1, 'cmp) t\n -> f:(key:'k key -> data:'v1 -> 'v2 option)\n -> ('k, 'v2, 'cmp) t )\n options\n\n val partition_mapi\n : ( 'k\n , 'cmp\n , ('k, 'v1, 'cmp) t\n -> f:(key:'k key -> data:'v1 -> ('v2, 'v3) Either.t)\n -> ('k, 'v2, 'cmp) t * ('k, 'v3, 'cmp) t )\n options\n\n val partition_map\n : ( 'k\n , 'cmp\n , ('k, 'v1, 'cmp) t\n -> f:('v1 -> ('v2, 'v3) Either.t)\n -> ('k, 'v2, 'cmp) t * ('k, 'v3, 'cmp) t )\n options\n\n val partitioni_tf\n : ( 'k\n , 'cmp\n , ('k, 'v, 'cmp) t\n -> f:(key:'k key -> data:'v -> bool)\n -> ('k, 'v, 'cmp) t * ('k, 'v, 'cmp) t )\n options\n\n val partition_tf\n : ( 'k\n , 'cmp\n , ('k, 'v, 'cmp) t -> f:('v -> bool) -> ('k, 'v, 'cmp) t * ('k, 'v, 'cmp) t )\n options\n\n val combine_errors\n : ('k, 'cmp, ('k, 'v Or_error.t, 'cmp) t -> ('k, 'v, 'cmp) t Or_error.t) options\n\n val compare_direct\n : ( 'k\n , 'cmp\n , ('v -> 'v -> int) -> ('k, 'v, 'cmp) t -> ('k, 'v, 'cmp) t -> int )\n options\n\n val equal\n : ( 'k\n , 'cmp\n , ('v -> 'v -> bool) -> ('k, 'v, 'cmp) t -> ('k, 'v, 'cmp) t -> bool )\n options\n\n val keys : ('k, _, _) t -> 'k key list\n val data : (_, 'v, _) t -> 'v list\n\n val to_alist\n : ?key_order:[ `Increasing | `Decreasing ]\n -> ('k, 'v, _) t\n -> ('k key * 'v) list\n\n val validate\n : name:('k key -> string)\n -> 'v Validate.check\n -> ('k, 'v, _) t Validate.check\n\n val validatei\n : name:('k key -> string)\n -> ('k key * 'v) Validate.check\n -> ('k, 'v, _) t Validate.check\n\n val merge\n : ( 'k\n , 'cmp\n , ('k, 'v1, 'cmp) t\n -> ('k, 'v2, 'cmp) t\n -> f:(key:'k key\n -> [ `Left of 'v1 | `Right of 'v2 | `Both of 'v1 * 'v2 ]\n -> 'v3 option)\n -> ('k, 'v3, 'cmp) t )\n options\n\n val symmetric_diff\n : ( 'k\n , 'cmp\n , ('k, 'v, 'cmp) t\n -> ('k, 'v, 'cmp) t\n -> data_equal:('v -> 'v -> bool)\n -> ('k key, 'v) Symmetric_diff_element.t Sequence.t )\n options\n\n val fold_symmetric_diff\n : ( 'k\n , 'cmp\n , ('k, 'v, 'cmp) t\n -> ('k, 'v, 'cmp) t\n -> data_equal:('v -> 'v -> bool)\n -> init:'a\n -> f:('a -> ('k key, 'v) Symmetric_diff_element.t -> 'a)\n -> 'a )\n options\n\n val min_elt : ('k, 'v, _) t -> ('k key * 'v) option\n val min_elt_exn : ('k, 'v, _) t -> 'k key * 'v\n val max_elt : ('k, 'v, _) t -> ('k key * 'v) option\n val max_elt_exn : ('k, 'v, _) t -> 'k key * 'v\n val for_all : ('k, 'v, _) t -> f:('v -> bool) -> bool\n val for_alli : ('k, 'v, _) t -> f:(key:'k key -> data:'v -> bool) -> bool\n val exists : ('k, 'v, _) t -> f:('v -> bool) -> bool\n val existsi : ('k, 'v, _) t -> f:(key:'k key -> data:'v -> bool) -> bool\n val count : ('k, 'v, _) t -> f:('v -> bool) -> int\n val counti : ('k, 'v, _) t -> f:(key:'k key -> data:'v -> bool) -> int\n\n val split\n : ( 'k\n , 'cmp\n , ('k, 'v, 'cmp) t\n -> 'k key\n -> ('k, 'v, 'cmp) t * ('k key * 'v) option * ('k, 'v, 'cmp) t )\n options\n\n val append\n : ( 'k\n , 'cmp\n , lower_part:('k, 'v, 'cmp) t\n -> upper_part:('k, 'v, 'cmp) t\n -> [ `Ok of ('k, 'v, 'cmp) t | `Overlapping_key_ranges ] )\n options\n\n val subrange\n : ( 'k\n , 'cmp\n , ('k, 'v, 'cmp) t\n -> lower_bound:'k key Maybe_bound.t\n -> upper_bound:'k key Maybe_bound.t\n -> ('k, 'v, 'cmp) t )\n options\n\n val fold_range_inclusive\n : ( 'k\n , 'cmp\n , ('k, 'v, 'cmp) t\n -> min:'k key\n -> max:'k key\n -> init:'a\n -> f:(key:'k key -> data:'v -> 'a -> 'a)\n -> 'a )\n options\n\n val range_to_alist\n : ( 'k\n , 'cmp\n , ('k, 'v, 'cmp) t -> min:'k key -> max:'k key -> ('k key * 'v) list )\n options\n\n val closest_key\n : ( 'k\n , 'cmp\n , ('k, 'v, 'cmp) t\n -> [ `Greater_or_equal_to | `Greater_than | `Less_or_equal_to | `Less_than ]\n -> 'k key\n -> ('k key * 'v) option )\n options\n\n val nth : ('k, 'cmp, ('k, 'v, 'cmp) t -> int -> ('k key * 'v) option) options\n val nth_exn : ('k, 'cmp, ('k, 'v, 'cmp) t -> int -> 'k key * 'v) options\n val rank : ('k, 'cmp, ('k, _, 'cmp) t -> 'k key -> int option) options\n val to_tree : ('k, 'v, 'cmp) t -> ('k key, 'v, 'cmp) tree\n\n val to_sequence\n : ( 'k\n , 'cmp\n , ?order:[ `Increasing_key | `Decreasing_key ]\n -> ?keys_greater_or_equal_to:'k key\n -> ?keys_less_or_equal_to:'k key\n -> ('k, 'v, 'cmp) t\n -> ('k key * 'v) Sequence.t )\n options\n\n val binary_search\n : ( 'k\n , 'cmp\n , ('k, 'v, 'cmp) t\n -> compare:(key:'k key -> data:'v -> 'key -> int)\n -> [ `Last_strictly_less_than\n | `Last_less_than_or_equal_to\n | `Last_equal_to\n | `First_equal_to\n | `First_greater_than_or_equal_to\n | `First_strictly_greater_than\n ]\n -> 'key\n -> ('k key * 'v) option )\n options\n\n val binary_search_segmented\n : ( 'k\n , 'cmp\n , ('k, 'v, 'cmp) t\n -> segment_of:(key:'k key -> data:'v -> [ `Left | `Right ])\n -> [ `Last_on_left | `First_on_right ]\n -> ('k key * 'v) option )\n options\nend\n\nmodule type Accessors1 = sig\n type 'a t\n type 'a tree\n type key\n type comparator_witness\n\n val invariants : _ t -> bool\n val is_empty : _ t -> bool\n val length : _ t -> int\n val add : 'a t -> key:key -> data:'a -> 'a t Or_duplicate.t\n val add_exn : 'a t -> key:key -> data:'a -> 'a t\n val set : 'a t -> key:key -> data:'a -> 'a t\n val add_multi : 'a list t -> key:key -> data:'a -> 'a list t\n val remove_multi : 'a list t -> key -> 'a list t\n val find_multi : 'a list t -> key -> 'a list\n val change : 'a t -> key -> f:('a option -> 'a option) -> 'a t\n val update : 'a t -> key -> f:('a option -> 'a) -> 'a t\n val find : 'a t -> key -> 'a option\n val find_exn : 'a t -> key -> 'a\n val remove : 'a t -> key -> 'a t\n val mem : _ t -> key -> bool\n val iter_keys : _ t -> f:(key -> unit) -> unit\n val iter : 'a t -> f:('a -> unit) -> unit\n val iteri : 'a t -> f:(key:key -> data:'a -> unit) -> unit\n\n val iteri_until\n : 'a t\n -> f:(key:key -> data:'a -> Continue_or_stop.t)\n -> Finished_or_unfinished.t\n\n val iter2\n : 'a t\n -> 'b t\n -> f:(key:key -> data:[ `Left of 'a | `Right of 'b | `Both of 'a * 'b ] -> unit)\n -> unit\n\n val map : 'a t -> f:('a -> 'b) -> 'b t\n val mapi : 'a t -> f:(key:key -> data:'a -> 'b) -> 'b t\n val fold : 'a t -> init:'b -> f:(key:key -> data:'a -> 'b -> 'b) -> 'b\n val fold_right : 'a t -> init:'b -> f:(key:key -> data:'a -> 'b -> 'b) -> 'b\n\n val fold2\n : 'a t\n -> 'b t\n -> init:'c\n -> f:(key:key -> data:[ `Left of 'a | `Right of 'b | `Both of 'a * 'b ] -> 'c -> 'c)\n -> 'c\n\n val filter_keys : 'a t -> f:(key -> bool) -> 'a t\n val filter : 'a t -> f:('a -> bool) -> 'a t\n val filteri : 'a t -> f:(key:key -> data:'a -> bool) -> 'a t\n val filter_map : 'a t -> f:('a -> 'b option) -> 'b t\n val filter_mapi : 'a t -> f:(key:key -> data:'a -> 'b option) -> 'b t\n val partition_mapi : 'a t -> f:(key:key -> data:'a -> ('b, 'c) Either.t) -> 'b t * 'c t\n val partition_map : 'a t -> f:('a -> ('b, 'c) Either.t) -> 'b t * 'c t\n val partitioni_tf : 'a t -> f:(key:key -> data:'a -> bool) -> 'a t * 'a t\n val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t\n val combine_errors : 'a Or_error.t t -> 'a t Or_error.t\n val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int\n val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool\n val keys : _ t -> key list\n val data : 'a t -> 'a list\n val to_alist : ?key_order:[ `Increasing | `Decreasing ] -> 'a t -> (key * 'a) list\n val validate : name:(key -> string) -> 'a Validate.check -> 'a t Validate.check\n\n val validatei\n : name:(key -> string)\n -> (key * 'a) Validate.check\n -> 'a t Validate.check\n\n val merge\n : 'a t\n -> 'b t\n -> f:(key:key -> [ `Left of 'a | `Right of 'b | `Both of 'a * 'b ] -> 'c option)\n -> 'c t\n\n val symmetric_diff\n : 'a t\n -> 'a t\n -> data_equal:('a -> 'a -> bool)\n -> (key, 'a) Symmetric_diff_element.t Sequence.t\n\n val fold_symmetric_diff\n : 'a t\n -> 'a t\n -> data_equal:('a -> 'a -> bool)\n -> init:'c\n -> f:('c -> (key, 'a) Symmetric_diff_element.t -> 'c)\n -> 'c\n\n val min_elt : 'a t -> (key * 'a) option\n val min_elt_exn : 'a t -> key * 'a\n val max_elt : 'a t -> (key * 'a) option\n val max_elt_exn : 'a t -> key * 'a\n val for_all : 'a t -> f:('a -> bool) -> bool\n val for_alli : 'a t -> f:(key:key -> data:'a -> bool) -> bool\n val exists : 'a t -> f:('a -> bool) -> bool\n val existsi : 'a t -> f:(key:key -> data:'a -> bool) -> bool\n val count : 'a t -> f:('a -> bool) -> int\n val counti : 'a t -> f:(key:key -> data:'a -> bool) -> int\n val split : 'a t -> key -> 'a t * (key * 'a) option * 'a t\n\n val append\n : lower_part:'a t\n -> upper_part:'a t\n -> [ `Ok of 'a t | `Overlapping_key_ranges ]\n\n val subrange\n : 'a t\n -> lower_bound:key Maybe_bound.t\n -> upper_bound:key Maybe_bound.t\n -> 'a t\n\n val fold_range_inclusive\n : 'a t\n -> min:key\n -> max:key\n -> init:'b\n -> f:(key:key -> data:'a -> 'b -> 'b)\n -> 'b\n\n val range_to_alist : 'a t -> min:key -> max:key -> (key * 'a) list\n\n val closest_key\n : 'a t\n -> [ `Greater_or_equal_to | `Greater_than | `Less_or_equal_to | `Less_than ]\n -> key\n -> (key * 'a) option\n\n val nth : 'a t -> int -> (key * 'a) option\n val nth_exn : 'a t -> int -> key * 'a\n val rank : _ t -> key -> int option\n val to_tree : 'a t -> 'a tree\n\n val to_sequence\n : ?order:[ `Increasing_key | `Decreasing_key ]\n -> ?keys_greater_or_equal_to:key\n -> ?keys_less_or_equal_to:key\n -> 'a t\n -> (key * 'a) Sequence.t\n\n val binary_search\n : 'a t\n -> compare:(key:key -> data:'a -> 'key -> int)\n -> [ `Last_strictly_less_than\n | `Last_less_than_or_equal_to\n | `Last_equal_to\n | `First_equal_to\n | `First_greater_than_or_equal_to\n | `First_strictly_greater_than\n ]\n -> 'key\n -> (key * 'a) option\n\n val binary_search_segmented\n : 'a t\n -> segment_of:(key:key -> data:'a -> [ `Left | `Right ])\n -> [ `Last_on_left | `First_on_right ]\n -> (key * 'a) option\nend\n\nmodule type Accessors2 = sig\n type ('a, 'b) t\n type ('a, 'b) tree\n type comparator_witness\n\n val invariants : (_, _) t -> bool\n val is_empty : (_, _) t -> bool\n val length : (_, _) t -> int\n val add : ('a, 'b) t -> key:'a -> data:'b -> ('a, 'b) t Or_duplicate.t\n val add_exn : ('a, 'b) t -> key:'a -> data:'b -> ('a, 'b) t\n val set : ('a, 'b) t -> key:'a -> data:'b -> ('a, 'b) t\n val add_multi : ('a, 'b list) t -> key:'a -> data:'b -> ('a, 'b list) t\n val remove_multi : ('a, 'b list) t -> 'a -> ('a, 'b list) t\n val find_multi : ('a, 'b list) t -> 'a -> 'b list\n val change : ('a, 'b) t -> 'a -> f:('b option -> 'b option) -> ('a, 'b) t\n val update : ('a, 'b) t -> 'a -> f:('b option -> 'b) -> ('a, 'b) t\n val find : ('a, 'b) t -> 'a -> 'b option\n val find_exn : ('a, 'b) t -> 'a -> 'b\n val remove : ('a, 'b) t -> 'a -> ('a, 'b) t\n val mem : ('a, 'b) t -> 'a -> bool\n val iter_keys : ('a, _) t -> f:('a -> unit) -> unit\n val iter : (_, 'b) t -> f:('b -> unit) -> unit\n val iteri : ('a, 'b) t -> f:(key:'a -> data:'b -> unit) -> unit\n\n val iteri_until\n : ('a, 'b) t\n -> f:(key:'a -> data:'b -> Continue_or_stop.t)\n -> Finished_or_unfinished.t\n\n val iter2\n : ('a, 'b) t\n -> ('a, 'c) t\n -> f:(key:'a -> data:[ `Left of 'b | `Right of 'c | `Both of 'b * 'c ] -> unit)\n -> unit\n\n val map : ('a, 'b) t -> f:('b -> 'c) -> ('a, 'c) t\n val mapi : ('a, 'b) t -> f:(key:'a -> data:'b -> 'c) -> ('a, 'c) t\n val fold : ('a, 'b) t -> init:'c -> f:(key:'a -> data:'b -> 'c -> 'c) -> 'c\n val fold_right : ('a, 'b) t -> init:'c -> f:(key:'a -> data:'b -> 'c -> 'c) -> 'c\n\n val fold2\n : ('a, 'b) t\n -> ('a, 'c) t\n -> init:'d\n -> f:(key:'a -> data:[ `Left of 'b | `Right of 'c | `Both of 'b * 'c ] -> 'd -> 'd)\n -> 'd\n\n val filter_keys : ('a, 'b) t -> f:('a -> bool) -> ('a, 'b) t\n val filter : ('a, 'b) t -> f:('b -> bool) -> ('a, 'b) t\n val filteri : ('a, 'b) t -> f:(key:'a -> data:'b -> bool) -> ('a, 'b) t\n val filter_map : ('a, 'b) t -> f:('b -> 'c option) -> ('a, 'c) t\n val filter_mapi : ('a, 'b) t -> f:(key:'a -> data:'b -> 'c option) -> ('a, 'c) t\n\n val partition_mapi\n : ('a, 'b) t\n -> f:(key:'a -> data:'b -> ('c, 'd) Either.t)\n -> ('a, 'c) t * ('a, 'd) t\n\n val partition_map\n : ('a, 'b) t\n -> f:('b -> ('c, 'd) Either.t)\n -> ('a, 'c) t * ('a, 'd) t\n\n val partitioni_tf\n : ('a, 'b) t\n -> f:(key:'a -> data:'b -> bool)\n -> ('a, 'b) t * ('a, 'b) t\n\n val partition_tf : ('a, 'b) t -> f:('b -> bool) -> ('a, 'b) t * ('a, 'b) t\n val combine_errors : ('a, 'b Or_error.t) t -> ('a, 'b) t Or_error.t\n val compare_direct : ('b -> 'b -> int) -> ('a, 'b) t -> ('a, 'b) t -> int\n val equal : ('b -> 'b -> bool) -> ('a, 'b) t -> ('a, 'b) t -> bool\n val keys : ('a, _) t -> 'a list\n val data : (_, 'b) t -> 'b list\n val to_alist : ?key_order:[ `Increasing | `Decreasing ] -> ('a, 'b) t -> ('a * 'b) list\n val validate : name:('a -> string) -> 'b Validate.check -> ('a, 'b) t Validate.check\n\n val validatei\n : name:('a -> string)\n -> ('a * 'b) Validate.check\n -> ('a, 'b) t Validate.check\n\n val merge\n : ('a, 'b) t\n -> ('a, 'c) t\n -> f:(key:'a -> [ `Left of 'b | `Right of 'c | `Both of 'b * 'c ] -> 'd option)\n -> ('a, 'd) t\n\n val symmetric_diff\n : ('a, 'b) t\n -> ('a, 'b) t\n -> data_equal:('b -> 'b -> bool)\n -> ('a, 'b) Symmetric_diff_element.t Sequence.t\n\n val fold_symmetric_diff\n : ('a, 'b) t\n -> ('a, 'b) t\n -> data_equal:('b -> 'b -> bool)\n -> init:'c\n -> f:('c -> ('a, 'b) Symmetric_diff_element.t -> 'c)\n -> 'c\n\n val min_elt : ('a, 'b) t -> ('a * 'b) option\n val min_elt_exn : ('a, 'b) t -> 'a * 'b\n val max_elt : ('a, 'b) t -> ('a * 'b) option\n val max_elt_exn : ('a, 'b) t -> 'a * 'b\n val for_all : (_, 'b) t -> f:('b -> bool) -> bool\n val for_alli : ('a, 'b) t -> f:(key:'a -> data:'b -> bool) -> bool\n val exists : (_, 'b) t -> f:('b -> bool) -> bool\n val existsi : ('a, 'b) t -> f:(key:'a -> data:'b -> bool) -> bool\n val count : (_, 'b) t -> f:('b -> bool) -> int\n val counti : ('a, 'b) t -> f:(key:'a -> data:'b -> bool) -> int\n val split : ('a, 'b) t -> 'a -> ('a, 'b) t * ('a * 'b) option * ('a, 'b) t\n\n val append\n : lower_part:('a, 'b) t\n -> upper_part:('a, 'b) t\n -> [ `Ok of ('a, 'b) t | `Overlapping_key_ranges ]\n\n val subrange\n : ('a, 'b) t\n -> lower_bound:'a Maybe_bound.t\n -> upper_bound:'a Maybe_bound.t\n -> ('a, 'b) t\n\n val fold_range_inclusive\n : ('a, 'b) t\n -> min:'a\n -> max:'a\n -> init:'c\n -> f:(key:'a -> data:'b -> 'c -> 'c)\n -> 'c\n\n val range_to_alist : ('a, 'b) t -> min:'a -> max:'a -> ('a * 'b) list\n\n val closest_key\n : ('a, 'b) t\n -> [ `Greater_or_equal_to | `Greater_than | `Less_or_equal_to | `Less_than ]\n -> 'a\n -> ('a * 'b) option\n\n val nth : ('a, 'b) t -> int -> ('a * 'b) option\n val nth_exn : ('a, 'b) t -> int -> 'a * 'b\n val rank : ('a, _) t -> 'a -> int option\n val to_tree : ('a, 'b) t -> ('a, 'b) tree\n\n val to_sequence\n : ?order:[ `Increasing_key | `Decreasing_key ]\n -> ?keys_greater_or_equal_to:'a\n -> ?keys_less_or_equal_to:'a\n -> ('a, 'b) t\n -> ('a * 'b) Sequence.t\n\n val binary_search\n : ('k, 'v) t\n -> compare:(key:'k -> data:'v -> 'key -> int)\n -> [ `Last_strictly_less_than\n | `Last_less_than_or_equal_to\n | `Last_equal_to\n | `First_equal_to\n | `First_greater_than_or_equal_to\n | `First_strictly_greater_than\n ]\n -> 'key\n -> ('k * 'v) option\n\n val binary_search_segmented\n : ('k, 'v) t\n -> segment_of:(key:'k -> data:'v -> [ `Left | `Right ])\n -> [ `Last_on_left | `First_on_right ]\n -> ('k * 'v) option\nend\n\nmodule type Accessors3 = sig\n type ('a, 'b, 'cmp) t\n type ('a, 'b, 'cmp) tree\n\n val invariants : (_, _, _) t -> bool\n val is_empty : (_, _, _) t -> bool\n val length : (_, _, _) t -> int\n val add : ('a, 'b, 'cmp) t -> key:'a -> data:'b -> ('a, 'b, 'cmp) t Or_duplicate.t\n val add_exn : ('a, 'b, 'cmp) t -> key:'a -> data:'b -> ('a, 'b, 'cmp) t\n val set : ('a, 'b, 'cmp) t -> key:'a -> data:'b -> ('a, 'b, 'cmp) t\n val add_multi : ('a, 'b list, 'cmp) t -> key:'a -> data:'b -> ('a, 'b list, 'cmp) t\n val remove_multi : ('a, 'b list, 'cmp) t -> 'a -> ('a, 'b list, 'cmp) t\n val find_multi : ('a, 'b list, 'cmp) t -> 'a -> 'b list\n val change : ('a, 'b, 'cmp) t -> 'a -> f:('b option -> 'b option) -> ('a, 'b, 'cmp) t\n val update : ('a, 'b, 'cmp) t -> 'a -> f:('b option -> 'b) -> ('a, 'b, 'cmp) t\n val find : ('a, 'b, 'cmp) t -> 'a -> 'b option\n val find_exn : ('a, 'b, 'cmp) t -> 'a -> 'b\n val remove : ('a, 'b, 'cmp) t -> 'a -> ('a, 'b, 'cmp) t\n val mem : ('a, 'b, 'cmp) t -> 'a -> bool\n val iter_keys : ('a, _, 'cmp) t -> f:('a -> unit) -> unit\n val iter : (_, 'b, 'cmp) t -> f:('b -> unit) -> unit\n val iteri : ('a, 'b, 'cmp) t -> f:(key:'a -> data:'b -> unit) -> unit\n\n val iteri_until\n : ('a, 'b, 'cmp) t\n -> f:(key:'a -> data:'b -> Continue_or_stop.t)\n -> Finished_or_unfinished.t\n\n val iter2\n : ('a, 'b, 'cmp) t\n -> ('a, 'c, 'cmp) t\n -> f:(key:'a -> data:[ `Left of 'b | `Right of 'c | `Both of 'b * 'c ] -> unit)\n -> unit\n\n val map : ('a, 'b, 'cmp) t -> f:('b -> 'c) -> ('a, 'c, 'cmp) t\n val mapi : ('a, 'b, 'cmp) t -> f:(key:'a -> data:'b -> 'c) -> ('a, 'c, 'cmp) t\n val fold : ('a, 'b, _) t -> init:'c -> f:(key:'a -> data:'b -> 'c -> 'c) -> 'c\n val fold_right : ('a, 'b, _) t -> init:'c -> f:(key:'a -> data:'b -> 'c -> 'c) -> 'c\n\n val fold2\n : ('a, 'b, 'cmp) t\n -> ('a, 'c, 'cmp) t\n -> init:'d\n -> f:(key:'a -> data:[ `Left of 'b | `Right of 'c | `Both of 'b * 'c ] -> 'd -> 'd)\n -> 'd\n\n val filter_keys : ('a, 'b, 'cmp) t -> f:('a -> bool) -> ('a, 'b, 'cmp) t\n val filter : ('a, 'b, 'cmp) t -> f:('b -> bool) -> ('a, 'b, 'cmp) t\n val filteri : ('a, 'b, 'cmp) t -> f:(key:'a -> data:'b -> bool) -> ('a, 'b, 'cmp) t\n val filter_map : ('a, 'b, 'cmp) t -> f:('b -> 'c option) -> ('a, 'c, 'cmp) t\n\n val filter_mapi\n : ('a, 'b, 'cmp) t\n -> f:(key:'a -> data:'b -> 'c option)\n -> ('a, 'c, 'cmp) t\n\n val partition_mapi\n : ('a, 'b, 'cmp) t\n -> f:(key:'a -> data:'b -> ('c, 'd) Either.t)\n -> ('a, 'c, 'cmp) t * ('a, 'd, 'cmp) t\n\n val partition_map\n : ('a, 'b, 'cmp) t\n -> f:('b -> ('c, 'd) Either.t)\n -> ('a, 'c, 'cmp) t * ('a, 'd, 'cmp) t\n\n val partitioni_tf\n : ('a, 'b, 'cmp) t\n -> f:(key:'a -> data:'b -> bool)\n -> ('a, 'b, 'cmp) t * ('a, 'b, 'cmp) t\n\n val partition_tf\n : ('a, 'b, 'cmp) t\n -> f:('b -> bool)\n -> ('a, 'b, 'cmp) t * ('a, 'b, 'cmp) t\n\n val combine_errors : ('a, 'b Or_error.t, 'cmp) t -> ('a, 'b, 'cmp) t Or_error.t\n val compare_direct : ('b -> 'b -> int) -> ('a, 'b, 'cmp) t -> ('a, 'b, 'cmp) t -> int\n val equal : ('b -> 'b -> bool) -> ('a, 'b, 'cmp) t -> ('a, 'b, 'cmp) t -> bool\n val keys : ('a, _, _) t -> 'a list\n val data : (_, 'b, _) t -> 'b list\n\n val to_alist\n : ?key_order:[ `Increasing | `Decreasing ]\n -> ('a, 'b, _) t\n -> ('a * 'b) list\n\n val validate : name:('a -> string) -> 'b Validate.check -> ('a, 'b, _) t Validate.check\n\n val validatei\n : name:('a -> string)\n -> ('a * 'b) Validate.check\n -> ('a, 'b, _) t Validate.check\n\n val merge\n : ('a, 'b, 'cmp) t\n -> ('a, 'c, 'cmp) t\n -> f:(key:'a -> [ `Left of 'b | `Right of 'c | `Both of 'b * 'c ] -> 'd option)\n -> ('a, 'd, 'cmp) t\n\n val symmetric_diff\n : ('a, 'b, 'cmp) t\n -> ('a, 'b, 'cmp) t\n -> data_equal:('b -> 'b -> bool)\n -> ('a, 'b) Symmetric_diff_element.t Sequence.t\n\n val fold_symmetric_diff\n : ('a, 'b, 'cmp) t\n -> ('a, 'b, 'cmp) t\n -> data_equal:('b -> 'b -> bool)\n -> init:'c\n -> f:('c -> ('a, 'b) Symmetric_diff_element.t -> 'c)\n -> 'c\n\n val min_elt : ('a, 'b, 'cmp) t -> ('a * 'b) option\n val min_elt_exn : ('a, 'b, 'cmp) t -> 'a * 'b\n val max_elt : ('a, 'b, 'cmp) t -> ('a * 'b) option\n val max_elt_exn : ('a, 'b, 'cmp) t -> 'a * 'b\n val for_all : (_, 'b, _) t -> f:('b -> bool) -> bool\n val for_alli : ('a, 'b, _) t -> f:(key:'a -> data:'b -> bool) -> bool\n val exists : (_, 'b, _) t -> f:('b -> bool) -> bool\n val existsi : ('a, 'b, _) t -> f:(key:'a -> data:'b -> bool) -> bool\n val count : (_, 'b, _) t -> f:('b -> bool) -> int\n val counti : ('a, 'b, _) t -> f:(key:'a -> data:'b -> bool) -> int\n\n val split\n : ('k, 'v, 'cmp) t\n -> 'k\n -> ('k, 'v, 'cmp) t * ('k * 'v) option * ('k, 'v, 'cmp) t\n\n val append\n : lower_part:('k, 'v, 'cmp) t\n -> upper_part:('k, 'v, 'cmp) t\n -> [ `Ok of ('k, 'v, 'cmp) t | `Overlapping_key_ranges ]\n\n val subrange\n : ('k, 'v, 'cmp) t\n -> lower_bound:'k Maybe_bound.t\n -> upper_bound:'k Maybe_bound.t\n -> ('k, 'v, 'cmp) t\n\n val fold_range_inclusive\n : ('a, 'b, _) t\n -> min:'a\n -> max:'a\n -> init:'c\n -> f:(key:'a -> data:'b -> 'c -> 'c)\n -> 'c\n\n val range_to_alist : ('a, 'b, _) t -> min:'a -> max:'a -> ('a * 'b) list\n\n val closest_key\n : ('a, 'b, _) t\n -> [ `Greater_or_equal_to | `Greater_than | `Less_or_equal_to | `Less_than ]\n -> 'a\n -> ('a * 'b) option\n\n val nth : ('a, 'b, _) t -> int -> ('a * 'b) option\n val nth_exn : ('a, 'b, _) t -> int -> 'a * 'b\n val rank : ('a, _, _) t -> 'a -> int option\n val to_tree : ('a, 'b, 'cmp) t -> ('a, 'b, 'cmp) tree\n\n val to_sequence\n : ?order:[ `Increasing_key | `Decreasing_key ]\n -> ?keys_greater_or_equal_to:'a\n -> ?keys_less_or_equal_to:'a\n -> ('a, 'b, _) t\n -> ('a * 'b) Sequence.t\n\n val binary_search\n : ('k, 'v, _) t\n -> compare:(key:'k -> data:'v -> 'key -> int)\n -> [ `Last_strictly_less_than\n | `Last_less_than_or_equal_to\n | `Last_equal_to\n | `First_equal_to\n | `First_greater_than_or_equal_to\n | `First_strictly_greater_than\n ]\n -> 'key\n -> ('k * 'v) option\n\n val binary_search_segmented\n : ('k, 'v, _) t\n -> segment_of:(key:'k -> data:'v -> [ `Left | `Right ])\n -> [ `Last_on_left | `First_on_right ]\n -> ('k * 'v) option\nend\n\nmodule type Accessors3_with_comparator = sig\n type ('a, 'b, 'cmp) t\n type ('a, 'b, 'cmp) tree\n\n val invariants : comparator:('a, 'cmp) Comparator.t -> ('a, 'b, 'cmp) t -> bool\n val is_empty : ('a, 'b, 'cmp) t -> bool\n val length : ('a, 'b, 'cmp) t -> int\n\n val add\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b, 'cmp) t\n -> key:'a\n -> data:'b\n -> ('a, 'b, 'cmp) t Or_duplicate.t\n\n val add_exn\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b, 'cmp) t\n -> key:'a\n -> data:'b\n -> ('a, 'b, 'cmp) t\n\n val set\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b, 'cmp) t\n -> key:'a\n -> data:'b\n -> ('a, 'b, 'cmp) t\n\n val add_multi\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b list, 'cmp) t\n -> key:'a\n -> data:'b\n -> ('a, 'b list, 'cmp) t\n\n val remove_multi\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b list, 'cmp) t\n -> 'a\n -> ('a, 'b list, 'cmp) t\n\n val find_multi\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b list, 'cmp) t\n -> 'a\n -> 'b list\n\n val change\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b, 'cmp) t\n -> 'a\n -> f:('b option -> 'b option)\n -> ('a, 'b, 'cmp) t\n\n val update\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b, 'cmp) t\n -> 'a\n -> f:('b option -> 'b)\n -> ('a, 'b, 'cmp) t\n\n val find : comparator:('a, 'cmp) Comparator.t -> ('a, 'b, 'cmp) t -> 'a -> 'b option\n val find_exn : comparator:('a, 'cmp) Comparator.t -> ('a, 'b, 'cmp) t -> 'a -> 'b\n\n val remove\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b, 'cmp) t\n -> 'a\n -> ('a, 'b, 'cmp) t\n\n val mem : comparator:('a, 'cmp) Comparator.t -> ('a, 'b, 'cmp) t -> 'a -> bool\n val iter_keys : ('a, _, 'cmp) t -> f:('a -> unit) -> unit\n val iter : (_, 'b, 'cmp) t -> f:('b -> unit) -> unit\n val iteri : ('a, 'b, 'cmp) t -> f:(key:'a -> data:'b -> unit) -> unit\n\n val iteri_until\n : ('a, 'b, 'cmp) t\n -> f:(key:'a -> data:'b -> Continue_or_stop.t)\n -> Finished_or_unfinished.t\n\n val iter2\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b, 'cmp) t\n -> ('a, 'c, 'cmp) t\n -> f:(key:'a -> data:[ `Left of 'b | `Right of 'c | `Both of 'b * 'c ] -> unit)\n -> unit\n\n val map : ('a, 'b, 'cmp) t -> f:('b -> 'c) -> ('a, 'c, 'cmp) t\n val mapi : ('a, 'b, 'cmp) t -> f:(key:'a -> data:'b -> 'c) -> ('a, 'c, 'cmp) t\n val fold : ('a, 'b, _) t -> init:'c -> f:(key:'a -> data:'b -> 'c -> 'c) -> 'c\n val fold_right : ('a, 'b, _) t -> init:'c -> f:(key:'a -> data:'b -> 'c -> 'c) -> 'c\n\n val fold2\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b, 'cmp) t\n -> ('a, 'c, 'cmp) t\n -> init:'d\n -> f:(key:'a -> data:[ `Left of 'b | `Right of 'c | `Both of 'b * 'c ] -> 'd -> 'd)\n -> 'd\n\n val filter_keys\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b, 'cmp) t\n -> f:('a -> bool)\n -> ('a, 'b, 'cmp) t\n\n val filter\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b, 'cmp) t\n -> f:('b -> bool)\n -> ('a, 'b, 'cmp) t\n\n val filteri\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b, 'cmp) t\n -> f:(key:'a -> data:'b -> bool)\n -> ('a, 'b, 'cmp) t\n\n val filter_map\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b, 'cmp) t\n -> f:('b -> 'c option)\n -> ('a, 'c, 'cmp) t\n\n val filter_mapi\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b, 'cmp) t\n -> f:(key:'a -> data:'b -> 'c option)\n -> ('a, 'c, 'cmp) t\n\n val partition_mapi\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b, 'cmp) t\n -> f:(key:'a -> data:'b -> ('c, 'd) Either.t)\n -> ('a, 'c, 'cmp) t * ('a, 'd, 'cmp) t\n\n val partition_map\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b, 'cmp) t\n -> f:('b -> ('c, 'd) Either.t)\n -> ('a, 'c, 'cmp) t * ('a, 'd, 'cmp) t\n\n val partitioni_tf\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b, 'cmp) t\n -> f:(key:'a -> data:'b -> bool)\n -> ('a, 'b, 'cmp) t * ('a, 'b, 'cmp) t\n\n val partition_tf\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b, 'cmp) t\n -> f:('b -> bool)\n -> ('a, 'b, 'cmp) t * ('a, 'b, 'cmp) t\n\n val combine_errors\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b Or_error.t, 'cmp) t\n -> ('a, 'b, 'cmp) t Or_error.t\n\n val compare_direct\n : comparator:('a, 'cmp) Comparator.t\n -> ('b -> 'b -> int)\n -> ('a, 'b, 'cmp) t\n -> ('a, 'b, 'cmp) t\n -> int\n\n val equal\n : comparator:('a, 'cmp) Comparator.t\n -> ('b -> 'b -> bool)\n -> ('a, 'b, 'cmp) t\n -> ('a, 'b, 'cmp) t\n -> bool\n\n val keys : ('a, _, _) t -> 'a list\n val data : (_, 'b, _) t -> 'b list\n\n val to_alist\n : ?key_order:[ `Increasing | `Decreasing ]\n -> ('a, 'b, _) t\n -> ('a * 'b) list\n\n val validate : name:('a -> string) -> 'b Validate.check -> ('a, 'b, _) t Validate.check\n\n val validatei\n : name:('a -> string)\n -> ('a * 'b) Validate.check\n -> ('a, 'b, _) t Validate.check\n\n val merge\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b, 'cmp) t\n -> ('a, 'c, 'cmp) t\n -> f:(key:'a -> [ `Left of 'b | `Right of 'c | `Both of 'b * 'c ] -> 'd option)\n -> ('a, 'd, 'cmp) t\n\n val symmetric_diff\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b, 'cmp) t\n -> ('a, 'b, 'cmp) t\n -> data_equal:('b -> 'b -> bool)\n -> ('a, 'b) Symmetric_diff_element.t Sequence.t\n\n val fold_symmetric_diff\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b, 'cmp) t\n -> ('a, 'b, 'cmp) t\n -> data_equal:('b -> 'b -> bool)\n -> init:'c\n -> f:('c -> ('a, 'b) Symmetric_diff_element.t -> 'c)\n -> 'c\n\n val min_elt : ('a, 'b, 'cmp) t -> ('a * 'b) option\n val min_elt_exn : ('a, 'b, 'cmp) t -> 'a * 'b\n val max_elt : ('a, 'b, 'cmp) t -> ('a * 'b) option\n val max_elt_exn : ('a, 'b, 'cmp) t -> 'a * 'b\n val for_all : ('a, 'b, 'cmp) t -> f:('b -> bool) -> bool\n val for_alli : ('a, 'b, 'cmp) t -> f:(key:'a -> data:'b -> bool) -> bool\n val exists : ('a, 'b, 'cmp) t -> f:('b -> bool) -> bool\n val existsi : ('a, 'b, 'cmp) t -> f:(key:'a -> data:'b -> bool) -> bool\n val count : ('a, 'b, 'cmp) t -> f:('b -> bool) -> int\n val counti : ('a, 'b, 'cmp) t -> f:(key:'a -> data:'b -> bool) -> int\n\n val split\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b, 'cmp) t\n -> 'a\n -> ('a, 'b, 'cmp) t * ('a * 'b) option * ('a, 'b, 'cmp) t\n\n val append\n : comparator:('a, 'cmp) Comparator.t\n -> lower_part:('a, 'b, 'cmp) t\n -> upper_part:('a, 'b, 'cmp) t\n -> [ `Ok of ('a, 'b, 'cmp) t | `Overlapping_key_ranges ]\n\n val subrange\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b, 'cmp) t\n -> lower_bound:'a Maybe_bound.t\n -> upper_bound:'a Maybe_bound.t\n -> ('a, 'b, 'cmp) t\n\n val fold_range_inclusive\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b, 'cmp) t\n -> min:'a\n -> max:'a\n -> init:'c\n -> f:(key:'a -> data:'b -> 'c -> 'c)\n -> 'c\n\n val range_to_alist\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b, 'cmp) t\n -> min:'a\n -> max:'a\n -> ('a * 'b) list\n\n val closest_key\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b, 'cmp) t\n -> [ `Greater_or_equal_to | `Greater_than | `Less_or_equal_to | `Less_than ]\n -> 'a\n -> ('a * 'b) option\n\n val nth\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b, 'cmp) t\n -> int\n -> ('a * 'b) option\n\n val nth_exn : comparator:('a, 'cmp) Comparator.t -> ('a, 'b, 'cmp) t -> int -> 'a * 'b\n val rank : comparator:('a, 'cmp) Comparator.t -> ('a, 'b, 'cmp) t -> 'a -> int option\n val to_tree : ('a, 'b, 'cmp) t -> ('a, 'b, 'cmp) tree\n\n val to_sequence\n : comparator:('a, 'cmp) Comparator.t\n -> ?order:[ `Increasing_key | `Decreasing_key ]\n -> ?keys_greater_or_equal_to:'a\n -> ?keys_less_or_equal_to:'a\n -> ('a, 'b, 'cmp) t\n -> ('a * 'b) Sequence.t\n\n val binary_search\n : comparator:('k, 'cmp) Comparator.t\n -> ('k, 'v, 'cmp) t\n -> compare:(key:'k -> data:'v -> 'key -> int)\n -> [ `Last_strictly_less_than\n | `Last_less_than_or_equal_to\n | `Last_equal_to\n | `First_equal_to\n | `First_greater_than_or_equal_to\n | `First_strictly_greater_than\n ]\n -> 'key\n -> ('k * 'v) option\n\n val binary_search_segmented\n : comparator:('k, 'cmp) Comparator.t\n -> ('k, 'v, 'cmp) t\n -> segment_of:(key:'k -> data:'v -> [ `Left | `Right ])\n -> [ `Last_on_left | `First_on_right ]\n -> ('k * 'v) option\nend\n\n(** Consistency checks (same as in [Container]). *)\nmodule Check_accessors\n (T : T3)\n (Tree : T3)\n (Key : T1)\n (Cmp : T1)\n (Options : T3)\n (M : Accessors_generic\n with type ('a, 'b, 'c) options := ('a, 'b, 'c) Options.t\n with type ('a, 'b, 'c) t := ('a, 'b, 'c) T.t\n with type ('a, 'b, 'c) tree := ('a, 'b, 'c) Tree.t\n with type 'a key := 'a Key.t\n with type 'cmp cmp := 'cmp Cmp.t) =\nstruct end\n\nmodule Check_accessors1 (M : Accessors1) =\n Check_accessors\n (struct\n type ('a, 'b, 'c) t = 'b M.t\n end)\n (struct\n type ('a, 'b, 'c) t = 'b M.tree\n end)\n (struct\n type 'a t = M.key\n end)\n (struct\n type 'a t = M.comparator_witness\n end)\n (Without_comparator)\n (M)\n\nmodule Check_accessors2 (M : Accessors2) =\n Check_accessors\n (struct\n type ('a, 'b, 'c) t = ('a, 'b) M.t\n end)\n (struct\n type ('a, 'b, 'c) t = ('a, 'b) M.tree\n end)\n (struct\n type 'a t = 'a\n end)\n (struct\n type 'a t = M.comparator_witness\n end)\n (Without_comparator)\n (M)\n\nmodule Check_accessors3 (M : Accessors3) =\n Check_accessors\n (struct\n type ('a, 'b, 'c) t = ('a, 'b, 'c) M.t\n end)\n (struct\n type ('a, 'b, 'c) t = ('a, 'b, 'c) M.tree\n end)\n (struct\n type 'a t = 'a\n end)\n (struct\n type 'a t = 'a\n end)\n (Without_comparator)\n (M)\n\nmodule Check_accessors3_with_comparator (M : Accessors3_with_comparator) =\n Check_accessors\n (struct\n type ('a, 'b, 'c) t = ('a, 'b, 'c) M.t\n end)\n (struct\n type ('a, 'b, 'c) t = ('a, 'b, 'c) M.tree\n end)\n (struct\n type 'a t = 'a\n end)\n (struct\n type 'a t = 'a\n end)\n (With_comparator)\n (M)\n\nmodule type Creators_generic = sig\n type ('k, 'v, 'cmp) t\n type ('k, 'v, 'cmp) tree\n type 'k key\n type ('a, 'cmp, 'z) options\n type 'cmp cmp\n\n val empty : ('k, 'cmp, ('k, _, 'cmp) t) options\n val singleton : ('k, 'cmp, 'k key -> 'v -> ('k, 'v, 'cmp) t) options\n\n val of_sorted_array\n : ('k, 'cmp, ('k key * 'v) array -> ('k, 'v, 'cmp) t Or_error.t) options\n\n val of_sorted_array_unchecked\n : ('k, 'cmp, ('k key * 'v) array -> ('k, 'v, 'cmp) t) options\n\n val of_increasing_iterator_unchecked\n : ('k, 'cmp, len:int -> f:(int -> 'k key * 'v) -> ('k, 'v, 'cmp) t) options\n\n val of_alist\n : ( 'k\n , 'cmp\n , ('k key * 'v) list -> [ `Ok of ('k, 'v, 'cmp) t | `Duplicate_key of 'k key ] )\n options\n\n val of_alist_or_error\n : ('k, 'cmp, ('k key * 'v) list -> ('k, 'v, 'cmp) t Or_error.t) options\n\n val of_alist_exn : ('k, 'cmp, ('k key * 'v) list -> ('k, 'v, 'cmp) t) options\n val of_alist_multi : ('k, 'cmp, ('k key * 'v) list -> ('k, 'v list, 'cmp) t) options\n\n val of_alist_fold\n : ( 'k\n , 'cmp\n , ('k key * 'v1) list -> init:'v2 -> f:('v2 -> 'v1 -> 'v2) -> ('k, 'v2, 'cmp) t )\n options\n\n val of_alist_reduce\n : ('k, 'cmp, ('k key * 'v) list -> f:('v -> 'v -> 'v) -> ('k, 'v, 'cmp) t) options\n\n val of_increasing_sequence\n : ('k, 'cmp, ('k key * 'v) Sequence.t -> ('k, 'v, 'cmp) t Or_error.t) options\n\n val of_sequence\n : ( 'k\n , 'cmp\n , ('k key * 'v) Sequence.t -> [ `Ok of ('k, 'v, 'cmp) t | `Duplicate_key of 'k key ]\n )\n options\n\n val of_sequence_or_error\n : ('k, 'cmp, ('k key * 'v) Sequence.t -> ('k, 'v, 'cmp) t Or_error.t) options\n\n val of_sequence_exn : ('k, 'cmp, ('k key * 'v) Sequence.t -> ('k, 'v, 'cmp) t) options\n\n val of_sequence_multi\n : ('k, 'cmp, ('k key * 'v) Sequence.t -> ('k, 'v list, 'cmp) t) options\n\n val of_sequence_fold\n : ( 'k\n , 'cmp\n , ('k key * 'v1) Sequence.t\n -> init:'v2\n -> f:('v2 -> 'v1 -> 'v2)\n -> ('k, 'v2, 'cmp) t )\n options\n\n val of_sequence_reduce\n : ( 'k\n , 'cmp\n , ('k key * 'v) Sequence.t -> f:('v -> 'v -> 'v) -> ('k, 'v, 'cmp) t )\n options\n\n val of_iteri\n : ( 'k\n , 'cmp\n , iteri:(f:(key:'k key -> data:'v -> unit) -> unit)\n -> [ `Ok of ('k, 'v, 'cmp) t | `Duplicate_key of 'k key ] )\n options\n\n val of_tree : ('k, 'cmp, ('k key, 'v, 'cmp) tree -> ('k, 'v, 'cmp) t) options\nend\n\nmodule type Creators1 = sig\n type 'a t\n type 'a tree\n type key\n type comparator_witness\n\n val empty : _ t\n val singleton : key -> 'a -> 'a t\n val of_alist : (key * 'a) list -> [ `Ok of 'a t | `Duplicate_key of key ]\n val of_alist_or_error : (key * 'a) list -> 'a t Or_error.t\n val of_alist_exn : (key * 'a) list -> 'a t\n val of_alist_multi : (key * 'a) list -> 'a list t\n val of_alist_fold : (key * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t\n val of_alist_reduce : (key * 'a) list -> f:('a -> 'a -> 'a) -> 'a t\n val of_sorted_array : (key * 'a) array -> 'a t Or_error.t\n val of_sorted_array_unchecked : (key * 'a) array -> 'a t\n val of_increasing_iterator_unchecked : len:int -> f:(int -> key * 'a) -> 'a t\n val of_increasing_sequence : (key * 'a) Sequence.t -> 'a t Or_error.t\n val of_sequence : (key * 'a) Sequence.t -> [ `Ok of 'a t | `Duplicate_key of key ]\n val of_sequence_or_error : (key * 'a) Sequence.t -> 'a t Or_error.t\n val of_sequence_exn : (key * 'a) Sequence.t -> 'a t\n val of_sequence_multi : (key * 'a) Sequence.t -> 'a list t\n val of_sequence_fold : (key * 'a) Sequence.t -> init:'b -> f:('b -> 'a -> 'b) -> 'b t\n val of_sequence_reduce : (key * 'a) Sequence.t -> f:('a -> 'a -> 'a) -> 'a t\n\n val of_iteri\n : iteri:(f:(key:key -> data:'v -> unit) -> unit)\n -> [ `Ok of 'v t | `Duplicate_key of key ]\n\n val of_tree : 'a tree -> 'a t\nend\n\nmodule type Creators2 = sig\n type ('a, 'b) t\n type ('a, 'b) tree\n type comparator_witness\n\n val empty : (_, _) t\n val singleton : 'a -> 'b -> ('a, 'b) t\n val of_alist : ('a * 'b) list -> [ `Ok of ('a, 'b) t | `Duplicate_key of 'a ]\n val of_alist_or_error : ('a * 'b) list -> ('a, 'b) t Or_error.t\n val of_alist_exn : ('a * 'b) list -> ('a, 'b) t\n val of_alist_multi : ('a * 'b) list -> ('a, 'b list) t\n val of_alist_fold : ('a * 'b) list -> init:'c -> f:('c -> 'b -> 'c) -> ('a, 'c) t\n val of_alist_reduce : ('a * 'b) list -> f:('b -> 'b -> 'b) -> ('a, 'b) t\n val of_sorted_array : ('a * 'b) array -> ('a, 'b) t Or_error.t\n val of_sorted_array_unchecked : ('a * 'b) array -> ('a, 'b) t\n val of_increasing_iterator_unchecked : len:int -> f:(int -> 'a * 'b) -> ('a, 'b) t\n val of_increasing_sequence : ('a * 'b) Sequence.t -> ('a, 'b) t Or_error.t\n val of_sequence : ('a * 'b) Sequence.t -> [ `Ok of ('a, 'b) t | `Duplicate_key of 'a ]\n val of_sequence_or_error : ('a * 'b) Sequence.t -> ('a, 'b) t Or_error.t\n val of_sequence_exn : ('a * 'b) Sequence.t -> ('a, 'b) t\n val of_sequence_multi : ('a * 'b) Sequence.t -> ('a, 'b list) t\n\n val of_sequence_fold\n : ('a * 'b) Sequence.t\n -> init:'c\n -> f:('c -> 'b -> 'c)\n -> ('a, 'c) t\n\n val of_sequence_reduce : ('a * 'b) Sequence.t -> f:('b -> 'b -> 'b) -> ('a, 'b) t\n\n val of_iteri\n : iteri:(f:(key:'a -> data:'b -> unit) -> unit)\n -> [ `Ok of ('a, 'b) t | `Duplicate_key of 'a ]\n\n val of_tree : ('a, 'b) tree -> ('a, 'b) t\nend\n\nmodule type Creators3_with_comparator = sig\n type ('a, 'b, 'cmp) t\n type ('a, 'b, 'cmp) tree\n\n val empty : comparator:('a, 'cmp) Comparator.t -> ('a, _, 'cmp) t\n val singleton : comparator:('a, 'cmp) Comparator.t -> 'a -> 'b -> ('a, 'b, 'cmp) t\n\n val of_alist\n : comparator:('a, 'cmp) Comparator.t\n -> ('a * 'b) list\n -> [ `Ok of ('a, 'b, 'cmp) t | `Duplicate_key of 'a ]\n\n val of_alist_or_error\n : comparator:('a, 'cmp) Comparator.t\n -> ('a * 'b) list\n -> ('a, 'b, 'cmp) t Or_error.t\n\n val of_alist_exn\n : comparator:('a, 'cmp) Comparator.t\n -> ('a * 'b) list\n -> ('a, 'b, 'cmp) t\n\n val of_alist_multi\n : comparator:('a, 'cmp) Comparator.t\n -> ('a * 'b) list\n -> ('a, 'b list, 'cmp) t\n\n val of_alist_fold\n : comparator:('a, 'cmp) Comparator.t\n -> ('a * 'b) list\n -> init:'c\n -> f:('c -> 'b -> 'c)\n -> ('a, 'c, 'cmp) t\n\n val of_alist_reduce\n : comparator:('a, 'cmp) Comparator.t\n -> ('a * 'b) list\n -> f:('b -> 'b -> 'b)\n -> ('a, 'b, 'cmp) t\n\n val of_sorted_array\n : comparator:('a, 'cmp) Comparator.t\n -> ('a * 'b) array\n -> ('a, 'b, 'cmp) t Or_error.t\n\n val of_sorted_array_unchecked\n : comparator:('a, 'cmp) Comparator.t\n -> ('a * 'b) array\n -> ('a, 'b, 'cmp) t\n\n val of_increasing_iterator_unchecked\n : comparator:('a, 'cmp) Comparator.t\n -> len:int\n -> f:(int -> 'a * 'b)\n -> ('a, 'b, 'cmp) t\n\n val of_increasing_sequence\n : comparator:('a, 'cmp) Comparator.t\n -> ('a * 'b) Sequence.t\n -> ('a, 'b, 'cmp) t Or_error.t\n\n val of_sequence\n : comparator:('a, 'cmp) Comparator.t\n -> ('a * 'b) Sequence.t\n -> [ `Ok of ('a, 'b, 'cmp) t | `Duplicate_key of 'a ]\n\n val of_sequence_or_error\n : comparator:('a, 'cmp) Comparator.t\n -> ('a * 'b) Sequence.t\n -> ('a, 'b, 'cmp) t Or_error.t\n\n val of_sequence_exn\n : comparator:('a, 'cmp) Comparator.t\n -> ('a * 'b) Sequence.t\n -> ('a, 'b, 'cmp) t\n\n val of_sequence_multi\n : comparator:('a, 'cmp) Comparator.t\n -> ('a * 'b) Sequence.t\n -> ('a, 'b list, 'cmp) t\n\n val of_sequence_fold\n : comparator:('a, 'cmp) Comparator.t\n -> ('a * 'b) Sequence.t\n -> init:'c\n -> f:('c -> 'b -> 'c)\n -> ('a, 'c, 'cmp) t\n\n val of_sequence_reduce\n : comparator:('a, 'cmp) Comparator.t\n -> ('a * 'b) Sequence.t\n -> f:('b -> 'b -> 'b)\n -> ('a, 'b, 'cmp) t\n\n val of_iteri\n : comparator:('a, 'cmp) Comparator.t\n -> iteri:(f:(key:'a -> data:'b -> unit) -> unit)\n -> [ `Ok of ('a, 'b, 'cmp) t | `Duplicate_key of 'a ]\n\n val of_tree\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b, 'cmp) tree\n -> ('a, 'b, 'cmp) t\nend\n\nmodule Check_creators\n (T : T3)\n (Tree : T3)\n (Key : T1)\n (Cmp : T1)\n (Options : T3)\n (M : Creators_generic\n with type ('a, 'b, 'c) options := ('a, 'b, 'c) Options.t\n with type ('a, 'b, 'c) t := ('a, 'b, 'c) T.t\n with type ('a, 'b, 'c) tree := ('a, 'b, 'c) Tree.t\n with type 'a key := 'a Key.t\n with type 'a cmp := 'a Cmp.t) =\nstruct end\n\nmodule Check_creators1 (M : Creators1) =\n Check_creators\n (struct\n type ('a, 'b, 'c) t = 'b M.t\n end)\n (struct\n type ('a, 'b, 'c) t = 'b M.tree\n end)\n (struct\n type 'a t = M.key\n end)\n (struct\n type 'a t = M.comparator_witness\n end)\n (Without_comparator)\n (M)\n\nmodule Check_creators2 (M : Creators2) =\n Check_creators\n (struct\n type ('a, 'b, 'c) t = ('a, 'b) M.t\n end)\n (struct\n type ('a, 'b, 'c) t = ('a, 'b) M.tree\n end)\n (struct\n type 'a t = 'a\n end)\n (struct\n type 'a t = M.comparator_witness\n end)\n (Without_comparator)\n (M)\n\nmodule Check_creators3_with_comparator (M : Creators3_with_comparator) =\n Check_creators\n (struct\n type ('a, 'b, 'c) t = ('a, 'b, 'c) M.t\n end)\n (struct\n type ('a, 'b, 'c) t = ('a, 'b, 'c) M.tree\n end)\n (struct\n type 'a t = 'a\n end)\n (struct\n type 'a t = 'a\n end)\n (With_comparator)\n (M)\n\nmodule type Creators_and_accessors_generic = sig\n include Creators_generic\n\n include\n Accessors_generic\n with type ('a, 'b, 'c) t := ('a, 'b, 'c) t\n with type ('a, 'b, 'c) tree := ('a, 'b, 'c) tree\n with type 'a key := 'a key\n with type 'a cmp := 'a cmp\n with type ('a, 'b, 'c) options := ('a, 'b, 'c) options\nend\n\nmodule type Creators_and_accessors1 = sig\n include Creators1\n\n include\n Accessors1\n with type 'a t := 'a t\n with type 'a tree := 'a tree\n with type key := key\n with type comparator_witness := comparator_witness\nend\n\nmodule type Creators_and_accessors2 = sig\n include Creators2\n\n include\n Accessors2\n with type ('a, 'b) t := ('a, 'b) t\n with type ('a, 'b) tree := ('a, 'b) tree\n with type comparator_witness := comparator_witness\nend\n\nmodule type Creators_and_accessors3_with_comparator = sig\n include Creators3_with_comparator\n\n include\n Accessors3_with_comparator\n with type ('a, 'b, 'c) t := ('a, 'b, 'c) t\n with type ('a, 'b, 'c) tree := ('a, 'b, 'c) tree\nend\n\nmodule type S_poly = Creators_and_accessors2\n\nmodule type For_deriving = sig\n type ('a, 'b, 'c) t\n\n module type Sexp_of_m = sig\n type t [@@deriving_inline sexp_of]\n\n val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t\n\n [@@@end]\n end\n\n module type M_of_sexp = sig\n type t [@@deriving_inline of_sexp]\n\n val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t\n\n [@@@end]\n\n include Comparator.S with type t := t\n end\n\n module type Compare_m = sig end\n module type Equal_m = sig end\n module type Hash_fold_m = Hasher.S\n\n val sexp_of_m__t\n : (module Sexp_of_m with type t = 'k)\n -> ('v -> Sexp.t)\n -> ('k, 'v, 'cmp) t\n -> Sexp.t\n\n val m__t_of_sexp\n : (module M_of_sexp with type t = 'k and type comparator_witness = 'cmp)\n -> (Sexp.t -> 'v)\n -> Sexp.t\n -> ('k, 'v, 'cmp) t\n\n val m__t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t\n\n val compare_m__t\n : (module Compare_m)\n -> ('v -> 'v -> int)\n -> ('k, 'v, 'cmp) t\n -> ('k, 'v, 'cmp) t\n -> int\n\n val equal_m__t\n : (module Equal_m)\n -> ('v -> 'v -> bool)\n -> ('k, 'v, 'cmp) t\n -> ('k, 'v, 'cmp) t\n -> bool\n\n val hash_fold_m__t\n : (module Hash_fold_m with type t = 'k)\n -> (Hash.state -> 'v -> Hash.state)\n -> Hash.state\n -> ('k, 'v, _) t\n -> Hash.state\nend\n\nmodule type Map = sig\n (** [Map] is a functional data structure (balanced binary tree) implementing finite maps\n over a totally-ordered domain, called a \"key\". *)\n\n type ('key, +'value, 'cmp) t\n\n module Or_duplicate = Or_duplicate\n module Continue_or_stop = Continue_or_stop\n\n module Finished_or_unfinished : sig\n type t = Finished_or_unfinished.t =\n | Finished\n | Unfinished\n [@@deriving_inline compare, enumerate, equal, sexp_of]\n\n val compare : t -> t -> int\n val all : t list\n val equal : t -> t -> bool\n val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t\n\n [@@@end]\n\n (** Maps [Continue] to [Finished] and [Stop] to [Unfinished]. *)\n val of_continue_or_stop : Continue_or_stop.t -> t\n\n (** Maps [Finished] to [Continue] and [Unfinished] to [Stop]. *)\n val to_continue_or_stop : t -> Continue_or_stop.t\n end\n\n type ('k, 'cmp) comparator =\n (module Comparator.S with type t = 'k and type comparator_witness = 'cmp)\n\n (** Test if the invariants of the internal AVL search tree hold. *)\n val invariants : (_, _, _) t -> bool\n\n (** Returns a first-class module that can be used to build other map/set/etc.\n with the same notion of comparison. *)\n val comparator_s : ('a, _, 'cmp) t -> ('a, 'cmp) comparator\n\n val comparator : ('a, _, 'cmp) t -> ('a, 'cmp) Comparator.t\n\n (** The empty map. *)\n val empty : ('a, 'cmp) comparator -> ('a, 'b, 'cmp) t\n\n (** A map with one (key, data) pair. *)\n val singleton : ('a, 'cmp) comparator -> 'a -> 'b -> ('a, 'b, 'cmp) t\n\n (** Creates a map from an association list with unique keys. *)\n val of_alist\n : ('a, 'cmp) comparator\n -> ('a * 'b) list\n -> [ `Ok of ('a, 'b, 'cmp) t | `Duplicate_key of 'a ]\n\n (** Creates a map from an association list with unique keys, returning an error if\n duplicate ['a] keys are found. *)\n val of_alist_or_error\n : ('a, 'cmp) comparator\n -> ('a * 'b) list\n -> ('a, 'b, 'cmp) t Or_error.t\n\n (** Creates a map from an association list with unique keys, raising an exception if\n duplicate ['a] keys are found. *)\n val of_alist_exn : ('a, 'cmp) comparator -> ('a * 'b) list -> ('a, 'b, 'cmp) t\n\n (** Creates a map from an association list with possibly repeated keys. The values in\n the map for a given key appear in the same order as they did in the association\n list. *)\n val of_alist_multi : ('a, 'cmp) comparator -> ('a * 'b) list -> ('a, 'b list, 'cmp) t\n\n (** Combines an association list into a map, folding together bound values with common\n keys. *)\n val of_alist_fold\n : ('a, 'cmp) comparator\n -> ('a * 'b) list\n -> init:'c\n -> f:('c -> 'b -> 'c)\n -> ('a, 'c, 'cmp) t\n\n (** Combines an association list into a map, reducing together bound values with common\n keys. *)\n val of_alist_reduce\n : ('a, 'cmp) comparator\n -> ('a * 'b) list\n -> f:('b -> 'b -> 'b)\n -> ('a, 'b, 'cmp) t\n\n (** [of_iteri ~iteri] behaves like [of_alist], except that instead of taking a concrete\n data structure, it takes an iteration function. For instance, to convert a string table\n into a map: [of_iteri (module String) ~f:(Hashtbl.iteri table)]. It is faster than\n adding the elements one by one. *)\n val of_iteri\n : ('a, 'cmp) comparator\n -> iteri:(f:(key:'a -> data:'b -> unit) -> unit)\n -> [ `Ok of ('a, 'b, 'cmp) t | `Duplicate_key of 'a ]\n\n (** Creates a map from a sorted array of key-data pairs. The input array must be sorted\n (either in ascending or descending order), as given by the relevant comparator, and\n must not contain duplicate keys. If either of these conditions does not hold,\n an error is returned. *)\n val of_sorted_array\n : ('a, 'cmp) comparator\n -> ('a * 'b) array\n -> ('a, 'b, 'cmp) t Or_error.t\n\n (** Like [of_sorted_array] except that it returns a map with broken invariants when an\n [Error] would have been returned. *)\n val of_sorted_array_unchecked\n : ('a, 'cmp) comparator\n -> ('a * 'b) array\n -> ('a, 'b, 'cmp) t\n\n (** [of_increasing_iterator_unchecked c ~len ~f] behaves like [of_sorted_array_unchecked c\n (Array.init len ~f)], with the additional restriction that a decreasing order is not\n supported. The advantage is not requiring you to allocate an intermediate array. [f]\n will be called with 0, 1, ... [len - 1], in order. *)\n val of_increasing_iterator_unchecked\n : ('a, 'cmp) comparator\n -> len:int\n -> f:(int -> 'a * 'b)\n -> ('a, 'b, 'cmp) t\n\n (** [of_increasing_sequence c seq] behaves like [of_sorted_array c (Sequence.to_array\n seq)], but does not allocate the intermediate array.\n\n The sequence will be folded over once, and the additional time complexity is {e O(n)}.\n *)\n val of_increasing_sequence\n : ('k, 'cmp) comparator\n -> ('k * 'v) Sequence.t\n -> ('k, 'v, 'cmp) t Or_error.t\n\n (** Creates a map from an association sequence with unique keys.\n\n [of_sequence c seq] behaves like [of_alist c (Sequence.to_list seq)] but\n does not allocate the intermediate list.\n\n If your sequence is increasing, use [of_increasing_sequence].\n *)\n val of_sequence\n : ('k, 'cmp) comparator\n -> ('k * 'v) Sequence.t\n -> [ `Ok of ('k, 'v, 'cmp) t | `Duplicate_key of 'k ]\n\n (** Creates a map from an association sequence with unique keys, returning an error if\n duplicate ['a] keys are found.\n\n [of_sequence_or_error c seq] behaves like [of_alist_or_error c (Sequence.to_list seq)]\n but does not allocate the intermediate list.\n *)\n val of_sequence_or_error\n : ('a, 'cmp) comparator\n -> ('a * 'b) Sequence.t\n -> ('a, 'b, 'cmp) t Or_error.t\n\n (** Creates a map from an association sequence with unique keys, raising an exception if\n duplicate ['a] keys are found.\n\n [of_sequence_exn c seq] behaves like [of_alist_exn c (Sequence.to_list seq)] but\n does not allocate the intermediate list.\n *)\n val of_sequence_exn : ('a, 'cmp) comparator -> ('a * 'b) Sequence.t -> ('a, 'b, 'cmp) t\n\n (** Creates a map from an association sequence with possibly repeated keys. The values in\n the map for a given key appear in the same order as they did in the association\n list.\n\n [of_sequence_multi c seq] behaves like [of_alist_exn c (Sequence.to_list seq)] but\n does not allocate the intermediate list.\n *)\n val of_sequence_multi\n : ('a, 'cmp) comparator\n -> ('a * 'b) Sequence.t\n -> ('a, 'b list, 'cmp) t\n\n (** Combines an association sequence into a map, folding together bound values with common\n keys.\n\n [of_sequence_fold c seq ~init ~f] behaves like [of_alist_fold c (Sequence.to_list seq) ~init ~f]\n but does not allocate the intermediate list.\n *)\n val of_sequence_fold\n : ('a, 'cmp) comparator\n -> ('a * 'b) Sequence.t\n -> init:'c\n -> f:('c -> 'b -> 'c)\n -> ('a, 'c, 'cmp) t\n\n (** Combines an association sequence into a map, reducing together bound values with common\n keys.\n\n [of_sequence_reduce c seq ~f] behaves like [of_alist_reduce c (Sequence.to_list seq) ~f]\n but does not allocate the intermediate list. *)\n val of_sequence_reduce\n : ('a, 'cmp) comparator\n -> ('a * 'b) Sequence.t\n -> f:('b -> 'b -> 'b)\n -> ('a, 'b, 'cmp) t\n\n (** Tests whether a map is empty. *)\n val is_empty : (_, _, _) t -> bool\n\n (** [length map] returns the number of elements in [map]. O(1), but [Tree.length] is\n O(n). *)\n val length : (_, _, _) t -> int\n\n (** Returns a new map with the specified new binding; if the key was already bound, its\n previous binding disappears. *)\n val set : ('k, 'v, 'cmp) t -> key:'k -> data:'v -> ('k, 'v, 'cmp) t\n\n (** [add t ~key ~data] adds a new entry to [t] mapping [key] to [data] and returns [`Ok]\n with the new map, or if [key] is already present in [t], returns [`Duplicate]. *)\n val add : ('k, 'v, 'cmp) t -> key:'k -> data:'v -> ('k, 'v, 'cmp) t Or_duplicate.t\n\n val add_exn : ('k, 'v, 'cmp) t -> key:'k -> data:'v -> ('k, 'v, 'cmp) t\n\n (** If [key] is not present then add a singleton list, otherwise, cons data onto the\n head of the existing list. *)\n val add_multi : ('k, 'v list, 'cmp) t -> key:'k -> data:'v -> ('k, 'v list, 'cmp) t\n\n (** If the key is present, then remove its head element; if the result is empty, remove\n the key. *)\n val remove_multi : ('k, 'v list, 'cmp) t -> 'k -> ('k, 'v list, 'cmp) t\n\n (** Returns the value bound to the given key, or the empty list if there is none. *)\n val find_multi : ('k, 'v list, 'cmp) t -> 'k -> 'v list\n\n (** [change t key ~f] returns a new map [m] that is the same as [t] on all keys except\n for [key], and whose value for [key] is defined by [f], i.e., [find m key = f (find\n t key)]. *)\n val change : ('k, 'v, 'cmp) t -> 'k -> f:('v option -> 'v option) -> ('k, 'v, 'cmp) t\n\n (** [update t key ~f] is [change t key ~f:(fun o -> Some (f o))]. *)\n val update : ('k, 'v, 'cmp) t -> 'k -> f:('v option -> 'v) -> ('k, 'v, 'cmp) t\n\n\n (** Returns [Some value] bound to the given key, or [None] if none exists. *)\n val find : ('k, 'v, 'cmp) t -> 'k -> 'v option\n\n (** Returns the value bound to the given key, raising [Caml.Not_found] or [Not_found_s]\n if none exists. *)\n val find_exn : ('k, 'v, 'cmp) t -> 'k -> 'v\n\n (** Returns a new map with any binding for the key in question removed. *)\n val remove : ('k, 'v, 'cmp) t -> 'k -> ('k, 'v, 'cmp) t\n\n (** [mem map key] tests whether [map] contains a binding for [key]. *)\n val mem : ('k, _, 'cmp) t -> 'k -> bool\n\n val iter_keys : ('k, _, _) t -> f:('k -> unit) -> unit\n val iter : (_, 'v, _) t -> f:('v -> unit) -> unit\n val iteri : ('k, 'v, _) t -> f:(key:'k -> data:'v -> unit) -> unit\n\n (** Iterates until the first time [f] returns [Stop]. If [f] returns [Stop], the final\n result is [Unfinished]. Otherwise, the final result is [Finished]. *)\n val iteri_until\n : ('k, 'v, _) t\n -> f:(key:'k -> data:'v -> Continue_or_stop.t)\n -> Finished_or_unfinished.t\n\n (** Iterates two maps side by side. The complexity of this function is O(M + N). If two\n inputs are [[(0, a); (1, a)]] and [[(1, b); (2, b)]], [f] will be called with [[(0,\n `Left a); (1, `Both (a, b)); (2, `Right b)]]. *)\n val iter2\n : ('k, 'v1, 'cmp) t\n -> ('k, 'v2, 'cmp) t\n -> f:(key:'k -> data:[ `Left of 'v1 | `Right of 'v2 | `Both of 'v1 * 'v2 ] -> unit)\n -> unit\n\n (** Returns a new map with bound values replaced by [f] applied to the bound values.*)\n val map : ('k, 'v1, 'cmp) t -> f:('v1 -> 'v2) -> ('k, 'v2, 'cmp) t\n\n (** Like [map], but the passed function takes both [key] and [data] as arguments. *)\n val mapi : ('k, 'v1, 'cmp) t -> f:(key:'k -> data:'v1 -> 'v2) -> ('k, 'v2, 'cmp) t\n\n (** Folds over keys and data in the map in increasing order of [key]. *)\n val fold : ('k, 'v, _) t -> init:'a -> f:(key:'k -> data:'v -> 'a -> 'a) -> 'a\n\n (** Folds over keys and data in the map in decreasing order of [key]. *)\n val fold_right : ('k, 'v, _) t -> init:'a -> f:(key:'k -> data:'v -> 'a -> 'a) -> 'a\n\n (** Folds over two maps side by side, like [iter2]. *)\n val fold2\n : ('k, 'v1, 'cmp) t\n -> ('k, 'v2, 'cmp) t\n -> init:'a\n -> f:(key:'k\n -> data:[ `Left of 'v1 | `Right of 'v2 | `Both of 'v1 * 'v2 ]\n -> 'a\n -> 'a)\n -> 'a\n\n (** [filter], [filteri], [filter_keys], [filter_map], and [filter_mapi] run in O(n * lg\n n) time; they simply accumulate each key & data pair retained by [f] into a new map\n using [add]. *)\n val filter_keys : ('k, 'v, 'cmp) t -> f:('k -> bool) -> ('k, 'v, 'cmp) t\n\n val filter : ('k, 'v, 'cmp) t -> f:('v -> bool) -> ('k, 'v, 'cmp) t\n val filteri : ('k, 'v, 'cmp) t -> f:(key:'k -> data:'v -> bool) -> ('k, 'v, 'cmp) t\n\n (** Returns a new map with bound values filtered by [f] applied to the bound values. *)\n val filter_map : ('k, 'v1, 'cmp) t -> f:('v1 -> 'v2 option) -> ('k, 'v2, 'cmp) t\n\n (** Like [filter_map], but the passed function takes both [key] and [data] as\n arguments. *)\n val filter_mapi\n : ('k, 'v1, 'cmp) t\n -> f:(key:'k -> data:'v1 -> 'v2 option)\n -> ('k, 'v2, 'cmp) t\n\n (** [partition_mapi t ~f] returns two new [t]s, with each key in [t] appearing in\n exactly one of the resulting maps depending on its mapping in [f]. *)\n val partition_mapi\n : ('k, 'v1, 'cmp) t\n -> f:(key:'k -> data:'v1 -> ('v2, 'v3) Either.t)\n -> ('k, 'v2, 'cmp) t * ('k, 'v3, 'cmp) t\n\n (** [partition_map t ~f = partition_mapi t ~f:(fun ~key:_ ~data -> f data)] *)\n val partition_map\n : ('k, 'v1, 'cmp) t\n -> f:('v1 -> ('v2, 'v3) Either.t)\n -> ('k, 'v2, 'cmp) t * ('k, 'v3, 'cmp) t\n\n (**\n {[\n partitioni_tf t ~f\n =\n partition_mapi t ~f:(fun ~key ~data ->\n if f ~key ~data\n then First data\n else Second data)\n ]} *)\n val partitioni_tf\n : ('k, 'v, 'cmp) t\n -> f:(key:'k -> data:'v -> bool)\n -> ('k, 'v, 'cmp) t * ('k, 'v, 'cmp) t\n\n (** [partition_tf t ~f = partitioni_tf t ~f:(fun ~key:_ ~data -> f data)] *)\n val partition_tf\n : ('k, 'v, 'cmp) t\n -> f:('v -> bool)\n -> ('k, 'v, 'cmp) t * ('k, 'v, 'cmp) t\n\n (** Produces [Ok] of a map including all keys if all data is [Ok], or an [Error]\n including all errors otherwise. *)\n val combine_errors : ('k, 'v Or_error.t, 'cmp) t -> ('k, 'v, 'cmp) t Or_error.t\n\n (** Returns a total ordering between maps. The first argument is a total ordering used\n to compare data associated with equal keys in the two maps. *)\n val compare_direct : ('v -> 'v -> int) -> ('k, 'v, 'cmp) t -> ('k, 'v, 'cmp) t -> int\n\n (** Hash function: a building block to use when hashing data structures containing maps in\n them. [hash_fold_direct hash_fold_key] is compatible with [compare_direct] iff\n [hash_fold_key] is compatible with [(comparator m).compare] of the map [m] being\n hashed. *)\n val hash_fold_direct : 'k Hash.folder -> 'v Hash.folder -> ('k, 'v, 'cmp) t Hash.folder\n\n (** [equal cmp m1 m2] tests whether the maps [m1] and [m2] are equal, that is, contain\n the same keys and associate each key with the same value. [cmp] is the equality\n predicate used to compare the values associated with the keys. *)\n val equal : ('v -> 'v -> bool) -> ('k, 'v, 'cmp) t -> ('k, 'v, 'cmp) t -> bool\n\n (** Returns a list of the keys in the given map. *)\n val keys : ('k, _, _) t -> 'k list\n\n (** Returns a list of the data in the given map. *)\n val data : (_, 'v, _) t -> 'v list\n\n (** Creates an association list from the given map. *)\n val to_alist\n : ?key_order:[ `Increasing | `Decreasing ] (** default is [`Increasing] *)\n -> ('k, 'v, _) t\n -> ('k * 'v) list\n\n val validate : name:('k -> string) -> 'v Validate.check -> ('k, 'v, _) t Validate.check\n\n val validatei\n : name:('k -> string)\n -> ('k * 'v) Validate.check\n -> ('k, 'v, _) t Validate.check\n\n (** {2 Additional operations on maps} *)\n\n (** Merges two maps. The runtime is O(length(t1) + length(t2)). You shouldn't use this\n function to merge a list of maps; consider using [merge_skewed] instead. *)\n val merge\n : ('k, 'v1, 'cmp) t\n -> ('k, 'v2, 'cmp) t\n -> f:(key:'k -> [ `Left of 'v1 | `Right of 'v2 | `Both of 'v1 * 'v2 ] -> 'v3 option)\n -> ('k, 'v3, 'cmp) t\n\n (** A special case of [merge], [merge_skewed t1 t2] is a map containing all the\n bindings of [t1] and [t2]. Bindings that appear in both [t1] and [t2] are\n combined into a single value using the [combine] function. In a call\n [combine ~key v1 v2], the value [v1] comes from [t1] and [v2] from [t2].\n\n The runtime of [merge_skewed] is [O(l1 * log(l2))], where [l1] is the length\n of the smaller map and [l2] the length of the larger map. This is likely to\n be faster than [merge] when one of the maps is a lot smaller, or when you\n merge a list of maps. *)\n val merge_skewed\n : ('k, 'v, 'cmp) t\n -> ('k, 'v, 'cmp) t\n -> combine:(key:'k -> 'v -> 'v -> 'v)\n -> ('k, 'v, 'cmp) t\n\n module Symmetric_diff_element : sig\n type ('k, 'v) t = 'k * [ `Left of 'v | `Right of 'v | `Unequal of 'v * 'v ]\n [@@deriving_inline compare, sexp]\n\n val compare\n : ('k -> 'k -> int)\n -> ('v -> 'v -> int)\n -> ('k, 'v) t\n -> ('k, 'v) t\n -> int\n\n include Ppx_sexp_conv_lib.Sexpable.S2 with type ('k, 'v) t := ('k, 'v) t\n\n [@@@end]\n end\n\n (** [symmetric_diff t1 t2 ~data_equal] returns a list of changes between [t1] and [t2].\n It is intended to be efficient in the case where [t1] and [t2] share a large amount\n of structure. The keys in the output sequence will be in sorted order.\n\n It is assumed that [data_equal] is at least as equating as physical equality: that\n [phys_equal x y] implies [data_equal x y]. Otherwise, [symmetric_diff] may behave in\n unexpected ways. For example, with [~data_equal:(fun _ _ -> false)] it is NOT\n necessarily the case the resulting change sequence will contain an element\n [(k, `Unequal _)] for every key [k] shared by both maps.\n\n Warning: Float equality violates this property! [phys_equal Float.nan Float.nan] is\n true, but [Float.(=) Float.nan Float.nan] is false. *)\n val symmetric_diff\n : ('k, 'v, 'cmp) t\n -> ('k, 'v, 'cmp) t\n -> data_equal:('v -> 'v -> bool)\n -> ('k, 'v) Symmetric_diff_element.t Sequence.t\n\n (** [fold_symmetric_diff t1 t2 ~data_equal] folds across an implicit sequence of changes\n between [t1] and [t2], in sorted order by keys. Equivalent to\n [Sequence.fold (symmetric_diff t1 t2 ~data_equal)], and more efficient. *)\n val fold_symmetric_diff\n : ('k, 'v, 'cmp) t\n -> ('k, 'v, 'cmp) t\n -> data_equal:('v -> 'v -> bool)\n -> init:'a\n -> f:('a -> ('k, 'v) Symmetric_diff_element.t -> 'a)\n -> 'a\n\n (** [min_elt map] returns [Some (key, data)] pair corresponding to the minimum key in\n [map], or [None] if empty. *)\n val min_elt : ('k, 'v, _) t -> ('k * 'v) option\n\n val min_elt_exn : ('k, 'v, _) t -> 'k * 'v\n\n (** [max_elt map] returns [Some (key, data)] pair corresponding to the maximum key in\n [map], or [None] if [map] is empty. *)\n val max_elt : ('k, 'v, _) t -> ('k * 'v) option\n\n val max_elt_exn : ('k, 'v, _) t -> 'k * 'v\n\n (** These functions have the same semantics as similar functions in [List]. *)\n\n val for_all : ('k, 'v, _) t -> f:('v -> bool) -> bool\n val for_alli : ('k, 'v, _) t -> f:(key:'k -> data:'v -> bool) -> bool\n val exists : ('k, 'v, _) t -> f:('v -> bool) -> bool\n val existsi : ('k, 'v, _) t -> f:(key:'k -> data:'v -> bool) -> bool\n val count : ('k, 'v, _) t -> f:('v -> bool) -> int\n val counti : ('k, 'v, _) t -> f:(key:'k -> data:'v -> bool) -> int\n\n\n (** [split t key] returns a map of keys strictly less than [key], the mapping of [key] if\n any, and a map of keys strictly greater than [key].\n\n Runtime is O(m + log n), where n is the size of the input map and m is the size of\n the smaller of the two output maps. The O(m) term is due to the need to calculate\n the length of the output maps. *)\n val split\n : ('k, 'v, 'cmp) t\n -> 'k\n -> ('k, 'v, 'cmp) t * ('k * 'v) option * ('k, 'v, 'cmp) t\n\n (** [append ~lower_part ~upper_part] returns [`Ok map] where [map] contains all the\n [(key, value)] pairs from the two input maps if all the keys from [lower_part] are\n less than all the keys from [upper_part]. Otherwise it returns\n [`Overlapping_key_ranges].\n\n Runtime is O(log n) where n is the size of the larger input map. This can be\n significantly faster than [Map.merge] or repeated [Map.add].\n\n {[\n assert (match Map.append ~lower_part ~upper_part with\n | `Ok whole_map ->\n Map.to_alist whole_map\n = List.append (to_alist lower_part) (to_alist upper_part)\n | `Overlapping_key_ranges -> true);\n ]} *)\n val append\n : lower_part:('k, 'v, 'cmp) t\n -> upper_part:('k, 'v, 'cmp) t\n -> [ `Ok of ('k, 'v, 'cmp) t | `Overlapping_key_ranges ]\n\n (** [subrange t ~lower_bound ~upper_bound] returns a map containing all the entries from\n [t] whose keys lie inside the interval indicated by [~lower_bound] and\n [~upper_bound]. If this interval is empty, an empty map is returned.\n\n Runtime is O(m + log n), where n is the size of the input map and m is the size of\n the output map. The O(m) term is due to the need to calculate the length of the\n output map. *)\n val subrange\n : ('k, 'v, 'cmp) t\n -> lower_bound:'k Maybe_bound.t\n -> upper_bound:'k Maybe_bound.t\n -> ('k, 'v, 'cmp) t\n\n (** [fold_range_inclusive t ~min ~max ~init ~f] folds [f] (with initial value [~init])\n over all keys (and their associated values) that are in the range [[min, max]]\n (inclusive). *)\n val fold_range_inclusive\n : ('k, 'v, 'cmp) t\n -> min:'k\n -> max:'k\n -> init:'a\n -> f:(key:'k -> data:'v -> 'a -> 'a)\n -> 'a\n\n (** [range_to_alist t ~min ~max] returns an associative list of the elements whose keys\n lie in [[min, max]] (inclusive), with the smallest key being at the head of the\n list. *)\n val range_to_alist : ('k, 'v, 'cmp) t -> min:'k -> max:'k -> ('k * 'v) list\n\n (** [closest_key t dir k] returns the [(key, value)] pair in [t] with [key] closest to\n [k] that satisfies the given inequality bound.\n\n For example, [closest_key t `Less_than k] would be the pair with the closest key to\n [k] where [key < k].\n\n [to_sequence] can be used to get the same results as [closest_key]. It is less\n efficient for individual lookups but more efficient for finding many elements starting\n at some value. *)\n val closest_key\n : ('k, 'v, 'cmp) t\n -> [ `Greater_or_equal_to | `Greater_than | `Less_or_equal_to | `Less_than ]\n -> 'k\n -> ('k * 'v) option\n\n (** [nth t n] finds the (key, value) pair of rank n (i.e., such that there are exactly n\n keys strictly less than the found key), if one exists. O(log(length t) + n) time. *)\n val nth : ('k, 'v, _) t -> int -> ('k * 'v) option\n\n val nth_exn : ('k, 'v, _) t -> int -> 'k * 'v\n\n (** [rank t k] If [k] is in [t], returns the number of keys strictly less than [k] in\n [t], and [None] otherwise. *)\n val rank : ('k, 'v, 'cmp) t -> 'k -> int option\n\n\n\n (** [to_sequence ?order ?keys_greater_or_equal_to ?keys_less_or_equal_to t]\n gives a sequence of key-value pairs between [keys_less_or_equal_to] and\n [keys_greater_or_equal_to] inclusive, presented in [order]. If\n [keys_greater_or_equal_to > keys_less_or_equal_to], the sequence is\n empty.\n\n When neither [keys_greater_or_equal_to] nor [keys_less_or_equal_to] are\n provided, the cost is O(log n) up front and amortized O(1) to produce\n each element. If either is provided (and is used by the order parameter\n provided), then the the cost is O(n) up front, and amortized O(1) to\n produce each element. *)\n val to_sequence\n : ?order:[ `Increasing_key (** default *) | `Decreasing_key ]\n -> ?keys_greater_or_equal_to:'k\n -> ?keys_less_or_equal_to:'k\n -> ('k, 'v, 'cmp) t\n -> ('k * 'v) Sequence.t\n\n (** [binary_search t ~compare which elt] returns the [(key, value)] pair in [t]\n specified by [compare] and [which], if one exists.\n\n [t] must be sorted in increasing order according to [compare], where [compare] and\n [elt] divide [t] into three (possibly empty) segments:\n\n {v\n | < elt | = elt | > elt |\n v}\n\n [binary_search] returns an element on the boundary of segments as specified by\n [which]. See the diagram below next to the [which] variants.\n\n [binary_search] does not check that [compare] orders [t], and behavior is\n unspecified if [compare] doesn't order [t]. Behavior is also unspecified if\n [compare] mutates [t]. *)\n val binary_search\n : ('k, 'v, 'cmp) t\n -> compare:(key:'k -> data:'v -> 'key -> int)\n -> [ `Last_strictly_less_than (** {v | < elt X | v} *)\n | `Last_less_than_or_equal_to (** {v | <= elt X | v} *)\n | `Last_equal_to (** {v | = elt X | v} *)\n | `First_equal_to (** {v | X = elt | v} *)\n | `First_greater_than_or_equal_to (** {v | X >= elt | v} *)\n | `First_strictly_greater_than (** {v | X > elt | v} *)\n ]\n -> 'key\n -> ('k * 'v) option\n\n (** [binary_search_segmented t ~segment_of which] takes a [segment_of] function that\n divides [t] into two (possibly empty) segments:\n\n {v\n | segment_of elt = `Left | segment_of elt = `Right |\n v}\n\n [binary_search_segmented] returns the [(key, value)] pair on the boundary of the\n segments as specified by [which]: [`Last_on_left] yields the last element of the\n left segment, while [`First_on_right] yields the first element of the right segment.\n It returns [None] if the segment is empty.\n\n [binary_search_segmented] does not check that [segment_of] segments [t] as in the\n diagram, and behavior is unspecified if [segment_of] doesn't segment [t]. Behavior\n is also unspecified if [segment_of] mutates [t]. *)\n val binary_search_segmented\n : ('k, 'v, 'cmp) t\n -> segment_of:(key:'k -> data:'v -> [ `Left | `Right ])\n -> [ `Last_on_left | `First_on_right ]\n -> ('k * 'v) option\n\n (** [M] is meant to be used in combination with OCaml applicative functor types:\n\n {[\n type string_to_int_map = int Map.M(String).t\n ]}\n\n which stands for:\n\n {[\n type string_to_int_map = (String.t, int, String.comparator_witness) Map.t\n ]}\n\n The point is that [int Map.M(String).t] supports deriving, whereas the second syntax\n doesn't (because there is no such thing as, say, [String.sexp_of_comparator_witness]\n -- instead you would want to pass the comparator directly).\n\n In addition, when using [@@deriving], the requirements on the key module are only\n those needed to satisfy what you are trying to derive on the map itself. Say you\n write:\n\n {[\n type t = int Map.M(X).t [@@deriving hash]\n ]}\n\n then this will be well typed exactly if [X] contains at least:\n - a type [t] with no parameters\n - a comparator witness\n - a [hash_fold_t] function with the right type *)\n module M (K : sig\n type t\n type comparator_witness\n end) : sig\n type nonrec 'v t = (K.t, 'v, K.comparator_witness) t\n end\n\n include For_deriving with type ('key, 'value, 'cmp) t := ('key, 'value, 'cmp) t\n\n (** A polymorphic Map. *)\n module Poly :\n S_poly\n with type ('key, +'value) t = ('key, 'value, Comparator.Poly.comparator_witness) t\n\n (** [Using_comparator] is a similar interface as the toplevel of [Map], except the\n functions take a [~comparator:('k, 'cmp) Comparator.t], whereas the functions at the\n toplevel of [Map] take a [('k, 'cmp) comparator]. *)\n module Using_comparator : sig\n type nonrec ('k, +'v, 'cmp) t = ('k, 'v, 'cmp) t [@@deriving_inline sexp_of]\n\n val sexp_of_t\n : ('k -> Ppx_sexp_conv_lib.Sexp.t)\n -> ('v -> Ppx_sexp_conv_lib.Sexp.t)\n -> ('cmp -> Ppx_sexp_conv_lib.Sexp.t)\n -> ('k, 'v, 'cmp) t\n -> Ppx_sexp_conv_lib.Sexp.t\n\n [@@@end]\n\n val t_of_sexp_direct\n : comparator:('k, 'cmp) Comparator.t\n -> (Sexp.t -> 'k)\n -> (Sexp.t -> 'v)\n -> Sexp.t\n -> ('k, 'v, 'cmp) t\n\n module Tree : sig\n type ('k, +'v, 'cmp) t [@@deriving_inline sexp_of]\n\n val sexp_of_t\n : ('k -> Ppx_sexp_conv_lib.Sexp.t)\n -> ('v -> Ppx_sexp_conv_lib.Sexp.t)\n -> ('cmp -> Ppx_sexp_conv_lib.Sexp.t)\n -> ('k, 'v, 'cmp) t\n -> Ppx_sexp_conv_lib.Sexp.t\n\n [@@@end]\n\n val t_of_sexp_direct\n : comparator:('k, 'cmp) Comparator.t\n -> (Sexp.t -> 'k)\n -> (Sexp.t -> 'v)\n -> Sexp.t\n -> ('k, 'v, 'cmp) t\n\n include\n Creators_and_accessors3_with_comparator\n with type ('a, 'b, 'c) t := ('a, 'b, 'c) t\n with type ('a, 'b, 'c) tree := ('a, 'b, 'c) t\n\n val empty_without_value_restriction : (_, _, _) t\n end\n\n include\n Accessors3\n with type ('a, 'b, 'c) t := ('a, 'b, 'c) t\n with type ('a, 'b, 'c) tree := ('a, 'b, 'c) Tree.t\n\n include\n Creators3_with_comparator\n with type ('a, 'b, 'c) t := ('a, 'b, 'c) t\n with type ('a, 'b, 'c) tree := ('a, 'b, 'c) Tree.t\n\n val comparator : ('a, _, 'cmp) t -> ('a, 'cmp) Comparator.t\n\n val hash_fold_direct\n : 'k Hash.folder\n -> 'v Hash.folder\n -> ('k, 'v, 'cmp) t Hash.folder\n\n (** To get around the value restriction, apply the functor and include it. You\n can see an example of this in the [Poly] submodule below. *)\n module Empty_without_value_restriction (K : Comparator.S1) : sig\n val empty : ('a K.t, 'v, K.comparator_witness) t\n end\n end\n\n\n (** {2 Modules and module types for extending [Map]}\n\n For use in extensions of Base, like [Core_kernel]. *)\n\n module With_comparator = With_comparator\n module With_first_class_module = With_first_class_module\n module Without_comparator = Without_comparator\n\n module type For_deriving = For_deriving\n module type S_poly = S_poly\n module type Accessors1 = Accessors1\n module type Accessors2 = Accessors2\n module type Accessors3 = Accessors3\n module type Accessors3_with_comparator = Accessors3_with_comparator\n module type Accessors_generic = Accessors_generic\n module type Creators1 = Creators1\n module type Creators2 = Creators2\n module type Creators3_with_comparator = Creators3_with_comparator\n module type Creators_and_accessors1 = Creators_and_accessors1\n module type Creators_and_accessors2 = Creators_and_accessors2\n\n module type Creators_and_accessors3_with_comparator =\n Creators_and_accessors3_with_comparator\n\n module type Creators_and_accessors_generic = Creators_and_accessors_generic\n module type Creators_generic = Creators_generic\nend\n","open! Import\nopen! Caml.Int64\n\nmodule T = struct\n type t = int64 [@@deriving_inline hash, sexp, sexp_grammar]\n\n let (hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state) =\n hash_fold_int64\n\n and (hash : t -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func = hash_int64 in\n fun x -> func x\n ;;\n\n let t_of_sexp = (int64_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t)\n let sexp_of_t = (sexp_of_int64 : t -> Ppx_sexp_conv_lib.Sexp.t)\n\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group) =\n { implicit_vars = [ \"int64\" ]\n ; ggid = \"\\146e\\023\\249\\235eE\\139c\\132W\\195\\137\\129\\235\\025\"\n ; types = [ \"t\", Implicit_var 0 ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ int64_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"int64.ml.T\"\n }\n in\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"t\", _the_group)\n in\n t_sexp_grammar\n ;;\n\n [@@@end]\n\n let compare = Int64_replace_polymorphic_compare.compare\n let to_string = to_string\n let of_string = of_string\nend\n\ninclude T\ninclude Comparator.Make (T)\n\nlet num_bits = 64\nlet float_lower_bound = Float0.lower_bound_for_int num_bits\nlet float_upper_bound = Float0.upper_bound_for_int num_bits\nlet float_of_bits = float_of_bits\nlet bits_of_float = bits_of_float\nlet shift_right_logical = shift_right_logical\nlet shift_right = shift_right\nlet shift_left = shift_left\nlet bit_not = lognot\nlet bit_xor = logxor\nlet bit_or = logor\nlet bit_and = logand\nlet min_value = min_int\nlet max_value = max_int\nlet abs = abs\nlet pred = pred\nlet succ = succ\nlet pow = Int_math.Private.int64_pow\nlet rem = rem\nlet neg = neg\nlet minus_one = minus_one\nlet one = one\nlet zero = zero\nlet to_float = to_float\nlet of_float_unchecked = Caml.Int64.of_float\n\nlet of_float f =\n if Float_replace_polymorphic_compare.( >= ) f float_lower_bound\n && Float_replace_polymorphic_compare.( <= ) f float_upper_bound\n then Caml.Int64.of_float f\n else\n Printf.invalid_argf\n \"Int64.of_float: argument (%f) is out of range or NaN\"\n (Float0.box f)\n ()\n;;\n\nlet ( ** ) b e = pow b e\n\nexternal bswap64 : t -> t = \"%bswap_int64\"\n\nlet[@inline always] bswap16 x = Caml.Int64.shift_right_logical (bswap64 x) 48\n\nlet[@inline always] bswap32 x =\n (* This is strictly better than coercing to an int32 to perform byteswap. Coercing\n from an int32 will add unnecessary shift operations to sign extend the number\n appropriately.\n *)\n Caml.Int64.shift_right_logical (bswap64 x) 32\n;;\n\nlet[@inline always] bswap48 x = Caml.Int64.shift_right_logical (bswap64 x) 16\n\ninclude Comparable.Validate_with_zero (struct\n include T\n\n let zero = zero\n end)\n\n(* Open replace_polymorphic_compare after including functor instantiations so they do not\n shadow its definitions. This is here so that efficient versions of the comparison\n functions are available within this module. *)\nopen Int64_replace_polymorphic_compare\n\nlet invariant (_ : t) = ()\nlet between t ~low ~high = low <= t && t <= high\nlet clamp_unchecked t ~min ~max = if t < min then min else if t <= max then t else max\n\nlet clamp_exn t ~min ~max =\n assert (min <= max);\n clamp_unchecked t ~min ~max\n;;\n\nlet clamp t ~min ~max =\n if min > max\n then\n Or_error.error_s\n (Sexp.message\n \"clamp requires [min <= max]\"\n [ \"min\", T.sexp_of_t min; \"max\", T.sexp_of_t max ])\n else Ok (clamp_unchecked t ~min ~max)\n;;\n\nlet ( / ) = div\nlet ( * ) = mul\nlet ( - ) = sub\nlet ( + ) = add\nlet ( ~- ) = neg\nlet incr r = r := !r + one\nlet decr r = r := !r - one\nlet of_int64 t = t\nlet of_int64_exn = of_int64\nlet to_int64 t = t\nlet popcount = Popcount.int64_popcount\n\nmodule Conv = Int_conversions\n\nlet of_int = Conv.int_to_int64\nlet of_int_exn = of_int\nlet to_int = Conv.int64_to_int\nlet to_int_exn = Conv.int64_to_int_exn\nlet to_int_trunc = Conv.int64_to_int_trunc\nlet of_int32 = Conv.int32_to_int64\nlet of_int32_exn = of_int32\nlet to_int32 = Conv.int64_to_int32\nlet to_int32_exn = Conv.int64_to_int32_exn\nlet to_int32_trunc = Conv.int64_to_int32_trunc\nlet of_nativeint = Conv.nativeint_to_int64\nlet of_nativeint_exn = of_nativeint\nlet to_nativeint = Conv.int64_to_nativeint\nlet to_nativeint_exn = Conv.int64_to_nativeint_exn\nlet to_nativeint_trunc = Conv.int64_to_nativeint_trunc\n\nmodule Pow2 = struct\n open! Import\n open Int64_replace_polymorphic_compare\n module Sys = Sys0\n\n let raise_s = Error.raise_s\n\n let non_positive_argument () =\n Printf.invalid_argf \"argument must be strictly positive\" ()\n ;;\n\n let ( lor ) = Caml.Int64.logor\n let ( lsr ) = Caml.Int64.shift_right_logical\n let ( land ) = Caml.Int64.logand\n\n (** \"ceiling power of 2\" - Least power of 2 greater than or equal to x. *)\n let ceil_pow2 x =\n if x <= Caml.Int64.zero then non_positive_argument ();\n let x = Caml.Int64.pred x in\n let x = x lor (x lsr 1) in\n let x = x lor (x lsr 2) in\n let x = x lor (x lsr 4) in\n let x = x lor (x lsr 8) in\n let x = x lor (x lsr 16) in\n let x = x lor (x lsr 32) in\n Caml.Int64.succ x\n ;;\n\n (** \"floor power of 2\" - Largest power of 2 less than or equal to x. *)\n let floor_pow2 x =\n if x <= Caml.Int64.zero then non_positive_argument ();\n let x = x lor (x lsr 1) in\n let x = x lor (x lsr 2) in\n let x = x lor (x lsr 4) in\n let x = x lor (x lsr 8) in\n let x = x lor (x lsr 16) in\n let x = x lor (x lsr 32) in\n Caml.Int64.sub x (x lsr 1)\n ;;\n\n let is_pow2 x =\n if x <= Caml.Int64.zero then non_positive_argument ();\n x land Caml.Int64.pred x = Caml.Int64.zero\n ;;\n\n (* C stubs for int clz and ctz to use the CLZ/BSR/CTZ/BSF instruction where possible *)\n external clz\n : (int64[@unboxed])\n -> (int[@untagged])\n = \"Base_int_math_int64_clz\" \"Base_int_math_int64_clz_unboxed\"\n [@@noalloc]\n\n external ctz\n : (int64[@unboxed])\n -> (int[@untagged])\n = \"Base_int_math_int64_ctz\" \"Base_int_math_int64_ctz_unboxed\"\n [@@noalloc]\n\n (** Hacker's Delight Second Edition p106 *)\n let floor_log2 i =\n if i <= Caml.Int64.zero\n then\n raise_s\n (Sexp.message \"[Int64.floor_log2] got invalid input\" [ \"\", sexp_of_int64 i ]);\n num_bits - 1 - clz i\n ;;\n\n (** Hacker's Delight Second Edition p106 *)\n let ceil_log2 i =\n if Poly.( <= ) i Caml.Int64.zero\n then\n raise_s\n (Sexp.message \"[Int64.ceil_log2] got invalid input\" [ \"\", sexp_of_int64 i ]);\n if Caml.Int64.equal i Caml.Int64.one then 0 else num_bits - clz (Caml.Int64.pred i)\n ;;\nend\n\ninclude Pow2\ninclude Conv.Make (T)\n\ninclude Conv.Make_hex (struct\n type t = int64 [@@deriving_inline compare, hash]\n\n let compare = (compare_int64 : t -> t -> int)\n\n let (hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state) =\n hash_fold_int64\n\n and (hash : t -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func = hash_int64 in\n fun x -> func x\n ;;\n\n [@@@end]\n\n let zero = zero\n let neg = ( ~- )\n let ( < ) = ( < )\n let to_string i = Printf.sprintf \"%Lx\" i\n let of_string s = Caml.Scanf.sscanf s \"%Lx\" Fn.id\n let module_name = \"Base.Int64.Hex\"\n end)\n\ninclude Pretty_printer.Register (struct\n type nonrec t = t\n\n let to_string = to_string\n let module_name = \"Base.Int64\"\n end)\n\nmodule Pre_O = struct\n let ( + ) = ( + )\n let ( - ) = ( - )\n let ( * ) = ( * )\n let ( / ) = ( / )\n let ( ~- ) = ( ~- )\n let ( ** ) = ( ** )\n\n include (Int64_replace_polymorphic_compare : Comparisons.Infix with type t := t)\n\n let abs = abs\n let neg = neg\n let zero = zero\n let of_int_exn = of_int_exn\nend\n\nmodule O = struct\n include Pre_O\n\n include Int_math.Make (struct\n type nonrec t = t\n\n include Pre_O\n\n let rem = rem\n let to_float = to_float\n let of_float = of_float\n let of_string = T.of_string\n let to_string = T.to_string\n end)\n\n let ( land ) = bit_and\n let ( lor ) = bit_or\n let ( lxor ) = bit_xor\n let lnot = bit_not\n let ( lsl ) = shift_left\n let ( asr ) = shift_right\n let ( lsr ) = shift_right_logical\nend\n\ninclude O\n\n(* [Int64] and [Int64.O] agree value-wise *)\n\n(* Include type-specific [Replace_polymorphic_compare] at the end, after\n including functor application that could shadow its definitions. This is\n here so that efficient versions of the comparison functions are exported by\n this module. *)\ninclude Int64_replace_polymorphic_compare\n","open! Import\n\nlet invalid_argf = Printf.invalid_argf\n\nmodule T = struct\n type t = bool [@@deriving_inline compare, enumerate, hash, sexp, sexp_grammar]\n\n let compare = (compare_bool : t -> t -> int)\n let all = ([ false; true ] : t list)\n\n let (hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state) =\n hash_fold_bool\n\n and (hash : t -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func = hash_bool in\n fun x -> func x\n ;;\n\n let t_of_sexp = (bool_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t)\n let sexp_of_t = (sexp_of_bool : t -> Ppx_sexp_conv_lib.Sexp.t)\n\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group) =\n { implicit_vars = [ \"bool\" ]\n ; ggid = \"\\146e\\023\\249\\235eE\\139c\\132W\\195\\137\\129\\235\\025\"\n ; types = [ \"t\", Implicit_var 0 ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ bool_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"bool.ml.T\"\n }\n in\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"t\", _the_group)\n in\n t_sexp_grammar\n ;;\n\n [@@@end]\n\n let of_string = function\n | \"true\" -> true\n | \"false\" -> false\n | s -> invalid_argf \"Bool.of_string: expected true or false but got %s\" s ()\n ;;\n\n let to_string = Caml.string_of_bool\nend\n\ninclude T\ninclude Comparator.Make (T)\ninclude Comparable.Validate (T)\n\ninclude Pretty_printer.Register (struct\n type nonrec t = t\n\n let to_string = to_string\n let module_name = \"Base.Bool\"\n end)\n\n(* Open replace_polymorphic_compare after including functor instantiations so they do not\n shadow its definitions. This is here so that efficient versions of the comparison\n functions are available within this module. *)\nopen! Bool_replace_polymorphic_compare\n\nlet invariant (_ : t) = ()\nlet between t ~low ~high = low <= t && t <= high\nlet clamp_unchecked t ~min ~max = if t < min then min else if t <= max then t else max\n\nlet clamp_exn t ~min ~max =\n assert (min <= max);\n clamp_unchecked t ~min ~max\n;;\n\nlet clamp t ~min ~max =\n if min > max\n then\n Or_error.error_s\n (Sexp.message\n \"clamp requires [min <= max]\"\n [ \"min\", T.sexp_of_t min; \"max\", T.sexp_of_t max ])\n else Ok (clamp_unchecked t ~min ~max)\n;;\n\nlet to_int x = bool_to_int x\n\nmodule Non_short_circuiting = struct\n (* We don't expose this, since we don't want to break the invariant mentioned below of\n (to_int true = 1) and (to_int false = 0). *)\n let unsafe_of_int (x : int) : bool = Caml.Obj.magic x\n let ( || ) a b = unsafe_of_int (to_int a lor to_int b)\n let ( && ) a b = unsafe_of_int (to_int a land to_int b)\nend\n\n(* We do this as a direct assert on the theory that it's a cheap thing to test and a\n really core invariant that we never expect to break, and we should be happy for a\n program to fail immediately if this is violated. *)\nlet () = assert (Poly.( = ) (to_int true) 1 && Poly.( = ) (to_int false) 0)\n\n(* Include type-specific [Replace_polymorphic_compare] at the end, after\n including functor application that could shadow its definitions. This is\n here so that efficient versions of the comparison functions are exported by\n this module. *)\ninclude Bool_replace_polymorphic_compare\n","open! Import\nopen! Caml.Int32\n\nmodule T = struct\n type t = int32 [@@deriving_inline hash, sexp, sexp_grammar]\n\n let (hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state) =\n hash_fold_int32\n\n and (hash : t -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func = hash_int32 in\n fun x -> func x\n ;;\n\n let t_of_sexp = (int32_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t)\n let sexp_of_t = (sexp_of_int32 : t -> Ppx_sexp_conv_lib.Sexp.t)\n\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group) =\n { implicit_vars = [ \"int32\" ]\n ; ggid = \"\\146e\\023\\249\\235eE\\139c\\132W\\195\\137\\129\\235\\025\"\n ; types = [ \"t\", Implicit_var 0 ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ int32_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"int32.ml.T\"\n }\n in\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"t\", _the_group)\n in\n t_sexp_grammar\n ;;\n\n [@@@end]\n\n let compare (x : t) y = compare x y\n let to_string = to_string\n let of_string = of_string\nend\n\ninclude T\ninclude Comparator.Make (T)\n\nlet num_bits = 32\nlet float_lower_bound = Float0.lower_bound_for_int num_bits\nlet float_upper_bound = Float0.upper_bound_for_int num_bits\nlet float_of_bits = float_of_bits\nlet bits_of_float = bits_of_float\nlet shift_right_logical = shift_right_logical\nlet shift_right = shift_right\nlet shift_left = shift_left\nlet bit_not = lognot\nlet bit_xor = logxor\nlet bit_or = logor\nlet bit_and = logand\nlet min_value = min_int\nlet max_value = max_int\nlet abs = abs\nlet pred = pred\nlet succ = succ\nlet rem = rem\nlet neg = neg\nlet minus_one = minus_one\nlet one = one\nlet zero = zero\nlet compare = compare\nlet to_float = to_float\nlet of_float_unchecked = of_float\n\nlet of_float f =\n if Float_replace_polymorphic_compare.( >= ) f float_lower_bound\n && Float_replace_polymorphic_compare.( <= ) f float_upper_bound\n then of_float f\n else\n Printf.invalid_argf\n \"Int32.of_float: argument (%f) is out of range or NaN\"\n (Float0.box f)\n ()\n;;\n\ninclude Comparable.Validate_with_zero (struct\n include T\n\n let zero = zero\n end)\n\nmodule Infix_compare = struct\n open Poly\n\n let ( >= ) (x : t) y = x >= y\n let ( <= ) (x : t) y = x <= y\n let ( = ) (x : t) y = x = y\n let ( > ) (x : t) y = x > y\n let ( < ) (x : t) y = x < y\n let ( <> ) (x : t) y = x <> y\nend\n\nmodule Compare = struct\n include Infix_compare\n\n let compare = compare\n let ascending = compare\n let descending x y = compare y x\n let min (x : t) y = if x < y then x else y\n let max (x : t) y = if x > y then x else y\n let equal (x : t) y = x = y\n let between t ~low ~high = low <= t && t <= high\n let clamp_unchecked t ~min ~max = if t < min then min else if t <= max then t else max\n\n let clamp_exn t ~min ~max =\n assert (min <= max);\n clamp_unchecked t ~min ~max\n ;;\n\n let clamp t ~min ~max =\n if min > max\n then\n Or_error.error_s\n (Sexp.message\n \"clamp requires [min <= max]\"\n [ \"min\", T.sexp_of_t min; \"max\", T.sexp_of_t max ])\n else Ok (clamp_unchecked t ~min ~max)\n ;;\nend\n\ninclude Compare\n\nlet invariant (_ : t) = ()\nlet ( / ) = div\nlet ( * ) = mul\nlet ( - ) = sub\nlet ( + ) = add\nlet ( ~- ) = neg\nlet incr r = r := !r + one\nlet decr r = r := !r - one\nlet of_int32 t = t\nlet of_int32_exn = of_int32\nlet to_int32 t = t\nlet to_int32_exn = to_int32\nlet popcount = Popcount.int32_popcount\n\nmodule Conv = Int_conversions\n\nlet of_int = Conv.int_to_int32\nlet of_int_exn = Conv.int_to_int32_exn\nlet of_int_trunc = Conv.int_to_int32_trunc\nlet to_int = Conv.int32_to_int\nlet to_int_exn = Conv.int32_to_int_exn\nlet to_int_trunc = Conv.int32_to_int_trunc\nlet of_int64 = Conv.int64_to_int32\nlet of_int64_exn = Conv.int64_to_int32_exn\nlet of_int64_trunc = Conv.int64_to_int32_trunc\nlet to_int64 = Conv.int32_to_int64\nlet of_nativeint = Conv.nativeint_to_int32\nlet of_nativeint_exn = Conv.nativeint_to_int32_exn\nlet of_nativeint_trunc = Conv.nativeint_to_int32_trunc\nlet to_nativeint = Conv.int32_to_nativeint\nlet to_nativeint_exn = to_nativeint\nlet pow b e = of_int_exn (Int_math.Private.int_pow (to_int_exn b) (to_int_exn e))\nlet ( ** ) b e = pow b e\n\nexternal bswap32 : t -> t = \"%bswap_int32\"\n\nlet bswap16 x = Caml.Int32.shift_right_logical (bswap32 x) 16\n\nmodule Pow2 = struct\n open! Import\n open Int32_replace_polymorphic_compare\n module Sys = Sys0\n\n let raise_s = Error.raise_s\n\n let non_positive_argument () =\n Printf.invalid_argf \"argument must be strictly positive\" ()\n ;;\n\n let ( lor ) = Caml.Int32.logor\n let ( lsr ) = Caml.Int32.shift_right_logical\n let ( land ) = Caml.Int32.logand\n\n (** \"ceiling power of 2\" - Least power of 2 greater than or equal to x. *)\n let ceil_pow2 x =\n if x <= Caml.Int32.zero then non_positive_argument ();\n let x = Caml.Int32.pred x in\n let x = x lor (x lsr 1) in\n let x = x lor (x lsr 2) in\n let x = x lor (x lsr 4) in\n let x = x lor (x lsr 8) in\n let x = x lor (x lsr 16) in\n Caml.Int32.succ x\n ;;\n\n (** \"floor power of 2\" - Largest power of 2 less than or equal to x. *)\n let floor_pow2 x =\n if x <= Caml.Int32.zero then non_positive_argument ();\n let x = x lor (x lsr 1) in\n let x = x lor (x lsr 2) in\n let x = x lor (x lsr 4) in\n let x = x lor (x lsr 8) in\n let x = x lor (x lsr 16) in\n Caml.Int32.sub x (x lsr 1)\n ;;\n\n let is_pow2 x =\n if x <= Caml.Int32.zero then non_positive_argument ();\n x land Caml.Int32.pred x = Caml.Int32.zero\n ;;\n\n (* C stubs for int32 clz and ctz to use the CLZ/BSR/CTZ/BSF instruction where possible *)\n external clz\n : (int32[@unboxed])\n -> (int[@untagged])\n = \"Base_int_math_int32_clz\" \"Base_int_math_int32_clz_unboxed\"\n [@@noalloc]\n\n external ctz\n : (int32[@unboxed])\n -> (int[@untagged])\n = \"Base_int_math_int32_ctz\" \"Base_int_math_int32_ctz_unboxed\"\n [@@noalloc]\n\n (** Hacker's Delight Second Edition p106 *)\n let floor_log2 i =\n if i <= Caml.Int32.zero\n then\n raise_s\n (Sexp.message \"[Int32.floor_log2] got invalid input\" [ \"\", sexp_of_int32 i ]);\n num_bits - 1 - clz i\n ;;\n\n (** Hacker's Delight Second Edition p106 *)\n let ceil_log2 i =\n if i <= Caml.Int32.zero\n then\n raise_s\n (Sexp.message \"[Int32.ceil_log2] got invalid input\" [ \"\", sexp_of_int32 i ]);\n (* The [i = 1] check is needed because clz(0) is undefined *)\n if Caml.Int32.equal i Caml.Int32.one then 0 else num_bits - clz (Caml.Int32.pred i)\n ;;\nend\n\ninclude Pow2\ninclude Conv.Make (T)\n\ninclude Conv.Make_hex (struct\n type t = int32 [@@deriving_inline compare, hash]\n\n let compare = (compare_int32 : t -> t -> int)\n\n let (hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state) =\n hash_fold_int32\n\n and (hash : t -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func = hash_int32 in\n fun x -> func x\n ;;\n\n [@@@end]\n\n let zero = zero\n let neg = ( ~- )\n let ( < ) = ( < )\n let to_string i = Printf.sprintf \"%lx\" i\n let of_string s = Caml.Scanf.sscanf s \"%lx\" Fn.id\n let module_name = \"Base.Int32.Hex\"\n end)\n\ninclude Pretty_printer.Register (struct\n type nonrec t = t\n\n let to_string = to_string\n let module_name = \"Base.Int32\"\n end)\n\nmodule Pre_O = struct\n let ( + ) = ( + )\n let ( - ) = ( - )\n let ( * ) = ( * )\n let ( / ) = ( / )\n let ( ~- ) = ( ~- )\n let ( ** ) = ( ** )\n\n include (Compare : Comparisons.Infix with type t := t)\n\n let abs = abs\n let neg = neg\n let zero = zero\n let of_int_exn = of_int_exn\nend\n\nmodule O = struct\n include Pre_O\n\n include Int_math.Make (struct\n type nonrec t = t\n\n include Pre_O\n\n let rem = rem\n let to_float = to_float\n let of_float = of_float\n let of_string = T.of_string\n let to_string = T.to_string\n end)\n\n let ( land ) = bit_and\n let ( lor ) = bit_or\n let ( lxor ) = bit_xor\n let lnot = bit_not\n let ( lsl ) = shift_left\n let ( asr ) = shift_right\n let ( lsr ) = shift_right_logical\nend\n\ninclude O\n\n(* [Int32] and [Int32.O] agree value-wise *)\n","open! Import\n\nlet raise_s = Error.raise_s\n\nmodule Repr = Int63_emul.Repr\n\n(* In a world where the compiler would understand [@@immediate64] attributes on type\n declarations, this module is how one would produce a [type t] with this attribute. *)\nmodule Immediate64 : sig\n module type Non_immediate = sig\n type t\n end\n\n module type Immediate = sig\n type t [@@immediate]\n end\n\n module Make (Immediate : Immediate) (Non_immediate : Non_immediate) : sig\n type t [@@immediate64]\n\n type 'a repr =\n | Immediate : Immediate.t repr\n | Non_immediate : Non_immediate.t repr\n\n val repr : t repr\n end\nend = struct\n module type Non_immediate = sig\n type t\n end\n\n module type Immediate = sig\n type t [@@immediate]\n end\n\n module Make (Immediate : Immediate) (Non_immediate : Non_immediate) = struct\n type t [@@immediate64]\n\n type 'a repr =\n | Immediate : Immediate.t repr\n | Non_immediate : Non_immediate.t repr\n\n let repr =\n match Word_size.word_size with\n | W64 -> (Caml.Obj.magic Immediate : t repr)\n | W32 -> (Caml.Obj.magic Non_immediate : t repr)\n ;;\n end\nend\n\ninclude Immediate64.Make (Int) (Int63_emul)\n\nmodule Backend = struct\n module type S = sig\n type t\n\n include Int_intf.S with type t := t\n\n val of_int : int -> t\n val to_int : t -> int option\n val to_int_trunc : t -> int\n val of_int32 : int32 -> t\n val to_int32 : t -> Int32.t option\n val to_int32_trunc : t -> Int32.t\n val of_int64 : Int64.t -> t option\n val of_int64_trunc : Int64.t -> t\n val of_nativeint : nativeint -> t option\n val to_nativeint : t -> nativeint option\n val of_nativeint_trunc : nativeint -> t\n val to_nativeint_trunc : t -> nativeint\n val of_float_unchecked : float -> t\n val repr : (t, t) Int63_emul.Repr.t\n val bswap16 : t -> t\n val bswap32 : t -> t\n val bswap48 : t -> t\n end\n with type t := t\n\n module Native = struct\n include Int\n\n let to_int x = Some x\n let to_int_trunc x = x\n\n (* [of_int32_exn] is a safe operation on platforms with 64-bit word sizes. *)\n let of_int32 = of_int32_exn\n let to_nativeint_trunc x = to_nativeint x\n let to_nativeint x = Some (to_nativeint x)\n let repr = Int63_emul.Repr.Int\n let bswap32 t = Int64.to_int_trunc (Int64.bswap32 (Int64.of_int t))\n let bswap48 t = Int64.to_int_trunc (Int64.bswap48 (Int64.of_int t))\n end\n\n let impl : (module S) =\n match repr with\n | Immediate -> (module Native : S)\n | Non_immediate -> (module Int63_emul : S)\n ;;\nend\n\ninclude (val Backend.impl : Backend.S)\n\nmodule Overflow_exn = struct\n let ( + ) t u =\n let sum = t + u in\n if bit_or (bit_xor t u) (bit_xor t (bit_not sum)) < zero\n then sum\n else\n raise_s\n (Sexp.message\n \"( + ) overflow\"\n [ \"t\", sexp_of_t t; \"u\", sexp_of_t u; \"sum\", sexp_of_t sum ])\n ;;\n\n let ( - ) t u =\n let diff = t - u in\n let pos_diff = t > u in\n if t <> u && Bool.( <> ) pos_diff (is_positive diff)\n then\n raise_s\n (Sexp.message\n \"( - ) overflow\"\n [ \"t\", sexp_of_t t; \"u\", sexp_of_t u; \"diff\", sexp_of_t diff ])\n else diff\n ;;\n\n let abs t = if t = min_value then failwith \"abs overflow\" else abs t\n let neg t = if t = min_value then failwith \"neg overflow\" else neg t\nend\n\nlet () = assert (Int.( = ) num_bits 63)\n\nlet random_of_int ?(state = Random.State.default) bound =\n of_int (Random.State.int state (to_int_exn bound))\n;;\n\nlet random_of_int64 ?(state = Random.State.default) bound =\n of_int64_exn (Random.State.int64 state (to_int64 bound))\n;;\n\nlet random =\n match Word_size.word_size with\n | W64 -> random_of_int\n | W32 -> random_of_int64\n;;\n\nlet random_incl_of_int ?(state = Random.State.default) lo hi =\n of_int (Random.State.int_incl state (to_int_exn lo) (to_int_exn hi))\n;;\n\nlet random_incl_of_int64 ?(state = Random.State.default) lo hi =\n of_int64_exn (Random.State.int64_incl state (to_int64 lo) (to_int64 hi))\n;;\n\nlet random_incl =\n match Word_size.word_size with\n | W64 -> random_incl_of_int\n | W32 -> random_incl_of_int64\n;;\n\nlet floor_log2 t =\n match Word_size.word_size with\n | W64 -> t |> to_int_exn |> Int.floor_log2\n | W32 ->\n if t <= zero\n then raise_s (Sexp.message \"[Int.floor_log2] got invalid input\" [ \"\", sexp_of_t t ]);\n let floor_log2 = ref (Int.( - ) num_bits 2) in\n while equal zero (bit_and t (shift_left one !floor_log2)) do\n floor_log2 := Int.( - ) !floor_log2 1\n done;\n !floor_log2\n;;\n\nmodule Private = struct\n module Repr = Repr\n\n let repr = repr\n\n module Emul = Int63_emul\nend\n","open! Import\ninclude Hashtbl_intf\n\nmodule type Key = Key.S\n\nlet with_return = With_return.with_return\nlet hash_param = Hashable.hash_param\nlet hash = Hashable.hash\nlet raise_s = Error.raise_s\n\ntype ('k, 'v) t =\n { mutable table : ('k, 'v) Avltree.t array\n ; mutable length : int\n (* [recently_added] is the reference passed to [Avltree.add]. We put it in the hash\n table to avoid allocating it at every [set]. *)\n ; recently_added : bool ref\n ; growth_allowed : bool\n ; hashable : 'k Hashable.t\n ; mutable mutation_allowed : bool (* Set during all iteration operations *)\n }\n\ntype 'a key = 'a\n\nlet sexp_of_key t = t.hashable.Hashable.sexp_of_t\nlet compare_key t = t.hashable.Hashable.compare\n\nlet ensure_mutation_allowed t =\n if not t.mutation_allowed\n then failwith \"Hashtbl: mutation not allowed during iteration\"\n;;\n\nlet without_mutating t f =\n if t.mutation_allowed\n then (\n t.mutation_allowed <- false;\n match f () with\n | x ->\n t.mutation_allowed <- true;\n x\n | exception exn ->\n t.mutation_allowed <- true;\n raise exn)\n else f ()\n;;\n\n(** Internally use a maximum size that is a power of 2. Reverses the above to find the\n floor power of 2 below the system max array length *)\nlet max_table_length = Int.floor_pow2 Array.max_length\n\n(* The default size is chosen to be 0 (as opposed to 128 as it was before) because:\n - 128 can create substantial memory overhead (x10) when creating many tables, most\n of which are not big (say, if you have a hashtbl of hashtbl). And memory overhead is\n not that easy to profile.\n - if a hashtbl is going to grow, it's not clear why 128 is markedly better than other\n sizes (if you going to stick 1000 elements, you're going to grow the hashtable once\n or twice anyway)\n - in other languages (like rust, python, and apparently go), the default is also a\n small size. *)\nlet create ?(growth_allowed = true) ?(size = 0) ~hashable () =\n let size = Int.min (Int.max 1 size) max_table_length in\n let size = Int.ceil_pow2 size in\n { table = Array.create ~len:size Avltree.empty\n ; length = 0\n ; growth_allowed\n ; recently_added = ref false\n ; hashable\n ; mutation_allowed = true\n }\n;;\n\n(** Supplemental hash. This may not be necessary, it is intended as a defense against poor\n hash functions, for which the power of 2 sized table will be especially sensitive.\n With some testing we may choose to add it, but this table is designed to be robust to\n collisions, and in most of my testing this degrades performance. *)\nlet _supplemental_hash h =\n let h = h lxor ((h lsr 20) lxor (h lsr 12)) in\n h lxor (h lsr 7) lxor (h lsr 4)\n;;\n\nlet slot t key =\n let hash = t.hashable.Hashable.hash key in\n (* this is always non-negative because we do [land] with non-negative number *)\n hash land (Array.length t.table - 1)\n;;\n\nlet add_worker t ~replace ~key ~data =\n let i = slot t key in\n let root = t.table.(i) in\n let added = t.recently_added in\n added := false;\n let new_root =\n (* The avl tree might replace the value [replace=true] or do nothing [replace=false]\n to the entry, in that case the table did not get bigger, so we should not\n increment length, we pass in the bool ref t.added so that it can tell us whether\n it added or replaced. We do it this way to avoid extra allocation. Since the bool\n is an immediate it does not go through the write barrier. *)\n Avltree.add ~replace root ~compare:(compare_key t) ~added ~key ~data\n in\n if !added then t.length <- t.length + 1;\n (* This little optimization saves a caml_modify when the tree\n hasn't been rebalanced. *)\n if not (phys_equal new_root root) then t.table.(i) <- new_root\n;;\n\nlet maybe_resize_table t =\n let len = Array.length t.table in\n let should_grow = t.length > len in\n if should_grow && t.growth_allowed\n then (\n let new_array_length = Int.min (len * 2) max_table_length in\n if new_array_length > len\n then (\n let new_table = Array.create ~len:new_array_length Avltree.empty in\n let old_table = t.table in\n t.table <- new_table;\n t.length <- 0;\n let f ~key ~data = add_worker ~replace:true t ~key ~data in\n for i = 0 to Array.length old_table - 1 do\n Avltree.iter old_table.(i) ~f\n done))\n;;\n\nlet set t ~key ~data =\n ensure_mutation_allowed t;\n add_worker ~replace:true t ~key ~data;\n maybe_resize_table t\n;;\n\nlet add t ~key ~data =\n ensure_mutation_allowed t;\n add_worker ~replace:false t ~key ~data;\n if !(t.recently_added)\n then (\n maybe_resize_table t;\n `Ok)\n else `Duplicate\n;;\n\nlet add_exn t ~key ~data =\n match add t ~key ~data with\n | `Ok -> ()\n | `Duplicate ->\n let sexp_of_key = sexp_of_key t in\n let error = Error.create \"Hashtbl.add_exn got key already present\" key sexp_of_key in\n Error.raise error\n;;\n\nlet clear t =\n ensure_mutation_allowed t;\n for i = 0 to Array.length t.table - 1 do\n t.table.(i) <- Avltree.empty\n done;\n t.length <- 0\n;;\n\nlet find_and_call t key ~if_found ~if_not_found =\n (* with a good hash function these first two cases will be the overwhelming majority,\n and Avltree.find is recursive, so it can't be inlined, so doing this avoids a\n function call in most cases. *)\n match t.table.(slot t key) with\n | Avltree.Empty -> if_not_found key\n | Avltree.Leaf { key = k; value = v } ->\n if compare_key t k key = 0 then if_found v else if_not_found key\n | tree ->\n Avltree.find_and_call tree ~compare:(compare_key t) key ~if_found ~if_not_found\n;;\n\nlet find_and_call1 t key ~a ~if_found ~if_not_found =\n match t.table.(slot t key) with\n | Avltree.Empty -> if_not_found key a\n | Avltree.Leaf { key = k; value = v } ->\n if compare_key t k key = 0 then if_found v a else if_not_found key a\n | tree ->\n Avltree.find_and_call1 tree ~compare:(compare_key t) key ~a ~if_found ~if_not_found\n;;\n\nlet find_and_call2 t key ~a ~b ~if_found ~if_not_found =\n match t.table.(slot t key) with\n | Avltree.Empty -> if_not_found key a b\n | Avltree.Leaf { key = k; value = v } ->\n if compare_key t k key = 0 then if_found v a b else if_not_found key a b\n | tree ->\n Avltree.find_and_call2\n tree\n ~compare:(compare_key t)\n key\n ~a\n ~b\n ~if_found\n ~if_not_found\n;;\n\nlet findi_and_call t key ~if_found ~if_not_found =\n (* with a good hash function these first two cases will be the overwhelming majority,\n and Avltree.find is recursive, so it can't be inlined, so doing this avoids a\n function call in most cases. *)\n match t.table.(slot t key) with\n | Avltree.Empty -> if_not_found key\n | Avltree.Leaf { key = k; value = v } ->\n if compare_key t k key = 0 then if_found ~key:k ~data:v else if_not_found key\n | tree ->\n Avltree.findi_and_call tree ~compare:(compare_key t) key ~if_found ~if_not_found\n;;\n\nlet findi_and_call1 t key ~a ~if_found ~if_not_found =\n match t.table.(slot t key) with\n | Avltree.Empty -> if_not_found key a\n | Avltree.Leaf { key = k; value = v } ->\n if compare_key t k key = 0 then if_found ~key:k ~data:v a else if_not_found key a\n | tree ->\n Avltree.findi_and_call1 tree ~compare:(compare_key t) key ~a ~if_found ~if_not_found\n;;\n\nlet findi_and_call2 t key ~a ~b ~if_found ~if_not_found =\n match t.table.(slot t key) with\n | Avltree.Empty -> if_not_found key a b\n | Avltree.Leaf { key = k; value = v } ->\n if compare_key t k key = 0 then if_found ~key:k ~data:v a b else if_not_found key a b\n | tree ->\n Avltree.findi_and_call2\n tree\n ~compare:(compare_key t)\n key\n ~a\n ~b\n ~if_found\n ~if_not_found\n;;\n\nlet find =\n let if_found v = Some v in\n let if_not_found _ = None in\n fun t key -> find_and_call t key ~if_found ~if_not_found\n;;\n\nlet mem t key =\n match t.table.(slot t key) with\n | Avltree.Empty -> false\n | Avltree.Leaf { key = k; value = _ } -> compare_key t k key = 0\n | tree -> Avltree.mem tree ~compare:(compare_key t) key\n;;\n\nlet remove t key =\n ensure_mutation_allowed t;\n let i = slot t key in\n let root = t.table.(i) in\n let added_or_removed = t.recently_added in\n added_or_removed := false;\n let new_root =\n Avltree.remove root ~removed:added_or_removed ~compare:(compare_key t) key\n in\n if not (phys_equal root new_root) then t.table.(i) <- new_root;\n if !added_or_removed then t.length <- t.length - 1\n;;\n\nlet length t = t.length\nlet is_empty t = length t = 0\n\nlet fold t ~init ~f =\n if length t = 0\n then init\n else (\n let n = Array.length t.table in\n let acc = ref init in\n let m = t.mutation_allowed in\n match\n t.mutation_allowed <- false;\n for i = 0 to n - 1 do\n match Array.unsafe_get t.table i with\n | Avltree.Empty -> ()\n | Avltree.Leaf { key; value = data } -> acc := f ~key ~data !acc\n | bucket -> acc := Avltree.fold bucket ~init:!acc ~f\n done\n with\n | () ->\n t.mutation_allowed <- m;\n !acc\n | exception exn ->\n t.mutation_allowed <- m;\n raise exn)\n;;\n\nlet iteri t ~f =\n if t.length = 0\n then ()\n else (\n let n = Array.length t.table in\n let m = t.mutation_allowed in\n match\n t.mutation_allowed <- false;\n for i = 0 to n - 1 do\n match Array.unsafe_get t.table i with\n | Avltree.Empty -> ()\n | Avltree.Leaf { key; value = data } -> f ~key ~data\n | bucket -> Avltree.iter bucket ~f\n done\n with\n | () -> t.mutation_allowed <- m\n | exception exn ->\n t.mutation_allowed <- m;\n raise exn)\n;;\n\nlet iter t ~f = iteri t ~f:(fun ~key:_ ~data -> f data)\nlet iter_keys t ~f = iteri t ~f:(fun ~key ~data:_ -> f key)\n\nlet rec choose_nonempty table i =\n let avltree = table.(i) in\n if Avltree.is_empty avltree\n then choose_nonempty table (i + 1)\n else Avltree.choose_exn avltree\n;;\n\nlet choose_exn t =\n if t.length = 0 then raise_s (Sexp.message \"[Hashtbl.choose_exn] of empty hashtbl\" []);\n choose_nonempty t.table 0\n;;\n\nlet choose t = if is_empty t then None else Some (choose_nonempty t.table 0)\n\nlet invariant invariant_key invariant_data t =\n for i = 0 to Array.length t.table - 1 do\n Avltree.invariant t.table.(i) ~compare:(compare_key t)\n done;\n let real_len =\n fold t ~init:0 ~f:(fun ~key ~data i ->\n invariant_key key;\n invariant_data data;\n i + 1)\n in\n assert (real_len = t.length)\n;;\n\nlet find_exn =\n let if_found v _ = v in\n let if_not_found k t =\n raise\n (Not_found_s (List [ Atom \"Hashtbl.find_exn: not found\"; t.hashable.sexp_of_t k ]))\n in\n let find_exn t key = find_and_call1 t key ~a:t ~if_found ~if_not_found in\n (* named to preserve symbol in compiled binary *)\n find_exn\n;;\n\nlet existsi t ~f =\n with_return (fun r ->\n iteri t ~f:(fun ~key ~data -> if f ~key ~data then r.return true);\n false)\n;;\n\nlet exists t ~f = existsi t ~f:(fun ~key:_ ~data -> f data)\nlet for_alli t ~f = not (existsi t ~f:(fun ~key ~data -> not (f ~key ~data)))\nlet for_all t ~f = not (existsi t ~f:(fun ~key:_ ~data -> not (f data)))\n\nlet counti t ~f =\n fold t ~init:0 ~f:(fun ~key ~data acc -> if f ~key ~data then acc + 1 else acc)\n;;\n\nlet count t ~f =\n fold t ~init:0 ~f:(fun ~key:_ ~data acc -> if f data then acc + 1 else acc)\n;;\n\nlet mapi t ~f =\n let new_t =\n create ~growth_allowed:t.growth_allowed ~hashable:t.hashable ~size:t.length ()\n in\n iteri t ~f:(fun ~key ~data -> set new_t ~key ~data:(f ~key ~data));\n new_t\n;;\n\nlet map t ~f = mapi t ~f:(fun ~key:_ ~data -> f data)\nlet copy t = map t ~f:Fn.id\n\nlet filter_mapi t ~f =\n let new_t =\n create ~growth_allowed:t.growth_allowed ~hashable:t.hashable ~size:t.length ()\n in\n iteri t ~f:(fun ~key ~data ->\n match f ~key ~data with\n | Some new_data -> set new_t ~key ~data:new_data\n | None -> ());\n new_t\n;;\n\nlet filter_map t ~f = filter_mapi t ~f:(fun ~key:_ ~data -> f data)\n\nlet filteri t ~f =\n filter_mapi t ~f:(fun ~key ~data -> if f ~key ~data then Some data else None)\n;;\n\nlet filter t ~f = filteri t ~f:(fun ~key:_ ~data -> f data)\nlet filter_keys t ~f = filteri t ~f:(fun ~key ~data:_ -> f key)\n\nlet partition_mapi t ~f =\n let t0 =\n create ~growth_allowed:t.growth_allowed ~hashable:t.hashable ~size:t.length ()\n in\n let t1 =\n create ~growth_allowed:t.growth_allowed ~hashable:t.hashable ~size:t.length ()\n in\n iteri t ~f:(fun ~key ~data ->\n match (f ~key ~data : _ Either.t) with\n | First new_data -> set t0 ~key ~data:new_data\n | Second new_data -> set t1 ~key ~data:new_data);\n t0, t1\n;;\n\nlet partition_map t ~f = partition_mapi t ~f:(fun ~key:_ ~data -> f data)\n\nlet partitioni_tf t ~f =\n partition_mapi t ~f:(fun ~key ~data ->\n if f ~key ~data then First data else Second data)\n;;\n\nlet partition_tf t ~f = partitioni_tf t ~f:(fun ~key:_ ~data -> f data)\n\nlet find_or_add t id ~default =\n match find t id with\n | Some x -> x\n | None ->\n let default = default () in\n set t ~key:id ~data:default;\n default\n;;\n\nlet findi_or_add t id ~default =\n match find t id with\n | Some x -> x\n | None ->\n let default = default id in\n set t ~key:id ~data:default;\n default\n;;\n\n(* Some hashtbl implementations may be able to perform this more efficiently than two\n separate lookups *)\nlet find_and_remove t id =\n let result = find t id in\n if Option.is_some result then remove t id;\n result\n;;\n\n\nlet change t id ~f =\n match f (find t id) with\n | None -> remove t id\n | Some data -> set t ~key:id ~data\n;;\n\nlet update t id ~f = set t ~key:id ~data:(f (find t id))\n\nlet incr_by ~remove_if_zero t key by =\n if remove_if_zero\n then\n change t key ~f:(fun opt ->\n match by + Option.value opt ~default:0 with\n | 0 -> None\n | n -> Some n)\n else\n update t key ~f:(function\n | None -> by\n | Some i -> by + i)\n;;\n\nlet incr ?(by = 1) ?(remove_if_zero = false) t key = incr_by ~remove_if_zero t key by\nlet decr ?(by = 1) ?(remove_if_zero = false) t key = incr_by ~remove_if_zero t key (-by)\n\nlet add_multi t ~key ~data =\n update t key ~f:(function\n | None -> [ data ]\n | Some l -> data :: l)\n;;\n\nlet remove_multi t key =\n match find t key with\n | None -> ()\n | Some [] | Some [ _ ] -> remove t key\n | Some (_ :: tl) -> set t ~key ~data:tl\n;;\n\nlet find_multi t key =\n match find t key with\n | None -> []\n | Some l -> l\n;;\n\nlet create_mapped ?growth_allowed ?size ~hashable ~get_key ~get_data rows =\n let size =\n match size with\n | Some s -> s\n | None -> List.length rows\n in\n let res = create ?growth_allowed ~hashable ~size () in\n let dupes = ref [] in\n List.iter rows ~f:(fun r ->\n let key = get_key r in\n let data = get_data r in\n if mem res key then dupes := key :: !dupes else set res ~key ~data);\n match !dupes with\n | [] -> `Ok res\n | keys -> `Duplicate_keys (List.dedup_and_sort ~compare:hashable.Hashable.compare keys)\n;;\n\nlet create_mapped_multi ?growth_allowed ?size ~hashable ~get_key ~get_data rows =\n let size =\n match size with\n | Some s -> s\n | None -> List.length rows\n in\n let res = create ?growth_allowed ~size ~hashable () in\n List.iter rows ~f:(fun r ->\n let key = get_key r in\n let data = get_data r in\n add_multi res ~key ~data);\n res\n;;\n\nlet of_alist ?growth_allowed ?size ~hashable lst =\n match create_mapped ?growth_allowed ?size ~hashable ~get_key:fst ~get_data:snd lst with\n | `Ok t -> `Ok t\n | `Duplicate_keys k -> `Duplicate_key (List.hd_exn k)\n;;\n\nlet of_alist_report_all_dups ?growth_allowed ?size ~hashable lst =\n create_mapped ?growth_allowed ?size ~hashable ~get_key:fst ~get_data:snd lst\n;;\n\nlet of_alist_or_error ?growth_allowed ?size ~hashable lst =\n match of_alist ?growth_allowed ?size ~hashable lst with\n | `Ok v -> Result.Ok v\n | `Duplicate_key key ->\n let sexp_of_key = hashable.Hashable.sexp_of_t in\n Or_error.error \"Hashtbl.of_alist_exn: duplicate key\" key sexp_of_key\n;;\n\nlet of_alist_exn ?growth_allowed ?size ~hashable lst =\n match of_alist_or_error ?growth_allowed ?size ~hashable lst with\n | Result.Ok v -> v\n | Result.Error e -> Error.raise e\n;;\n\nlet of_alist_multi ?growth_allowed ?size ~hashable lst =\n create_mapped_multi ?growth_allowed ?size ~hashable ~get_key:fst ~get_data:snd lst\n;;\n\nlet to_alist t = fold ~f:(fun ~key ~data list -> (key, data) :: list) ~init:[] t\n\nlet sexp_of_t sexp_of_key sexp_of_data t =\n t\n |> to_alist\n |> List.sort ~compare:(fun (k1, _) (k2, _) -> t.hashable.compare k1 k2)\n |> sexp_of_list (sexp_of_pair sexp_of_key sexp_of_data)\n;;\n\nlet t_of_sexp ~hashable k_of_sexp d_of_sexp sexp =\n let alist = list_of_sexp (pair_of_sexp k_of_sexp d_of_sexp) sexp in\n match of_alist ~hashable alist ~size:(List.length alist) with\n | `Ok v -> v\n | `Duplicate_key k ->\n (* find the sexp of a duplicate key, so the error is narrowed to a key and not\n the whole map *)\n let alist_sexps = list_of_sexp (pair_of_sexp Fn.id Fn.id) sexp in\n let found_first_k = ref false in\n List.iter2_exn alist alist_sexps ~f:(fun (k2, _) (k2_sexp, _) ->\n if hashable.compare k k2 = 0\n then\n if !found_first_k\n then of_sexp_error \"Hashtbl.t_of_sexp: duplicate key\" k2_sexp\n else found_first_k := true);\n assert false\n;;\n\nlet validate ~name f t = Validate.alist ~name f (to_alist t)\nlet keys t = fold t ~init:[] ~f:(fun ~key ~data:_ acc -> key :: acc)\nlet data t = fold ~f:(fun ~key:_ ~data list -> data :: list) ~init:[] t\n\nlet add_to_groups groups ~get_key ~get_data ~combine ~rows =\n List.iter rows ~f:(fun row ->\n let key = get_key row in\n let data = get_data row in\n let data =\n match find groups key with\n | None -> data\n | Some old -> combine old data\n in\n set groups ~key ~data)\n;;\n\nlet group ?growth_allowed ?size ~hashable ~get_key ~get_data ~combine rows =\n let res = create ?growth_allowed ?size ~hashable () in\n add_to_groups res ~get_key ~get_data ~combine ~rows;\n res\n;;\n\nlet create_with_key ?growth_allowed ?size ~hashable ~get_key rows =\n create_mapped ?growth_allowed ?size ~hashable ~get_key ~get_data:Fn.id rows\n;;\n\nlet create_with_key_or_error ?growth_allowed ?size ~hashable ~get_key rows =\n match create_with_key ?growth_allowed ?size ~hashable ~get_key rows with\n | `Ok t -> Result.Ok t\n | `Duplicate_keys keys ->\n let sexp_of_key = hashable.Hashable.sexp_of_t in\n Or_error.error_s\n (Sexp.message\n \"Hashtbl.create_with_key: duplicate keys\"\n [ \"keys\", sexp_of_list sexp_of_key keys ])\n;;\n\nlet create_with_key_exn ?growth_allowed ?size ~hashable ~get_key rows =\n Or_error.ok_exn\n (create_with_key_or_error ?growth_allowed ?size ~hashable ~get_key rows)\n;;\n\nlet merge =\n let maybe_set t ~key ~f d =\n match f ~key d with\n | None -> ()\n | Some v -> set t ~key ~data:v\n in\n fun t_left t_right ~f ->\n if not (Hashable.equal t_left.hashable t_right.hashable)\n then invalid_arg \"Hashtbl.merge: different 'hashable' values\";\n let new_t =\n create\n ~growth_allowed:t_left.growth_allowed\n ~hashable:t_left.hashable\n ~size:t_left.length\n ()\n in\n without_mutating t_left (fun () ->\n without_mutating t_right (fun () ->\n iteri t_left ~f:(fun ~key ~data:left ->\n match find t_right key with\n | None -> maybe_set new_t ~key ~f (`Left left)\n | Some right -> maybe_set new_t ~key ~f (`Both (left, right)));\n iteri t_right ~f:(fun ~key ~data:right ->\n match find t_left key with\n | None -> maybe_set new_t ~key ~f (`Right right)\n | Some _ -> ()\n (* already done above *))));\n new_t\n;;\n\nlet merge_into ~src ~dst ~f =\n iteri src ~f:(fun ~key ~data ->\n let dst_data = find dst key in\n let action = without_mutating dst (fun () -> f ~key data dst_data) in\n match (action : _ Merge_into_action.t) with\n | Remove -> remove dst key\n | Set_to data ->\n (match dst_data with\n | None -> set dst ~key ~data\n | Some dst_data -> if not (phys_equal dst_data data) then set dst ~key ~data))\n;;\n\nlet filteri_inplace t ~f =\n let to_remove =\n fold t ~init:[] ~f:(fun ~key ~data ac -> if f ~key ~data then ac else key :: ac)\n in\n List.iter to_remove ~f:(fun key -> remove t key)\n;;\n\nlet filter_inplace t ~f = filteri_inplace t ~f:(fun ~key:_ ~data -> f data)\nlet filter_keys_inplace t ~f = filteri_inplace t ~f:(fun ~key ~data:_ -> f key)\n\nlet filter_mapi_inplace t ~f =\n let map_results =\n fold t ~init:[] ~f:(fun ~key ~data ac -> (key, f ~key ~data) :: ac)\n in\n List.iter map_results ~f:(fun (key, result) ->\n match result with\n | None -> remove t key\n | Some data -> set t ~key ~data)\n;;\n\nlet filter_map_inplace t ~f = filter_mapi_inplace t ~f:(fun ~key:_ ~data -> f data)\n\nlet mapi_inplace t ~f =\n ensure_mutation_allowed t;\n without_mutating t (fun () -> Array.iter t.table ~f:(Avltree.mapi_inplace ~f))\n;;\n\nlet map_inplace t ~f = mapi_inplace t ~f:(fun ~key:_ ~data -> f data)\n\nlet equal equal t t' =\n length t = length t'\n && with_return (fun r ->\n without_mutating t' (fun () ->\n iteri t ~f:(fun ~key ~data ->\n match find t' key with\n | None -> r.return false\n | Some data' -> if not (equal data data') then r.return false));\n true)\n;;\n\nlet similar = equal\n\nmodule Accessors = struct\n let invariant = invariant\n let choose = choose\n let choose_exn = choose_exn\n let clear = clear\n let copy = copy\n let remove = remove\n let set = set\n let add = add\n let add_exn = add_exn\n let change = change\n let update = update\n let add_multi = add_multi\n let remove_multi = remove_multi\n let find_multi = find_multi\n let mem = mem\n let iter_keys = iter_keys\n let iter = iter\n let iteri = iteri\n let exists = exists\n let existsi = existsi\n let for_all = for_all\n let for_alli = for_alli\n let count = count\n let counti = counti\n let fold = fold\n let length = length\n let is_empty = is_empty\n let map = map\n let mapi = mapi\n let filter_map = filter_map\n let filter_mapi = filter_mapi\n let filter_keys = filter_keys\n let filter = filter\n let filteri = filteri\n let partition_map = partition_map\n let partition_mapi = partition_mapi\n let partition_tf = partition_tf\n let partitioni_tf = partitioni_tf\n let find_or_add = find_or_add\n let findi_or_add = findi_or_add\n let find = find\n let find_exn = find_exn\n let find_and_call = find_and_call\n let find_and_call1 = find_and_call1\n let find_and_call2 = find_and_call2\n let findi_and_call = findi_and_call\n let findi_and_call1 = findi_and_call1\n let findi_and_call2 = findi_and_call2\n let find_and_remove = find_and_remove\n let to_alist = to_alist\n let validate = validate\n let merge = merge\n let merge_into = merge_into\n let keys = keys\n let data = data\n let filter_keys_inplace = filter_keys_inplace\n let filter_inplace = filter_inplace\n let filteri_inplace = filteri_inplace\n let map_inplace = map_inplace\n let mapi_inplace = mapi_inplace\n let filter_map_inplace = filter_map_inplace\n let filter_mapi_inplace = filter_mapi_inplace\n let equal = equal\n let similar = similar\n let incr = incr\n let decr = decr\n let sexp_of_key = sexp_of_key\nend\n\nmodule Creators (Key : sig\n type 'a t\n\n val hashable : 'a t Hashable.t\n end) : sig\n type ('a, 'b) t_ = ('a Key.t, 'b) t\n\n val t_of_sexp : (Sexp.t -> 'a Key.t) -> (Sexp.t -> 'b) -> Sexp.t -> ('a, 'b) t_\n\n include\n Creators_generic\n with type ('a, 'b) t := ('a, 'b) t_\n with type 'a key := 'a Key.t\n with type ('key, 'data, 'a) create_options :=\n ('key, 'data, 'a) create_options_without_first_class_module\nend = struct\n let hashable = Key.hashable\n\n type ('a, 'b) t_ = ('a Key.t, 'b) t\n\n let create ?growth_allowed ?size () = create ?growth_allowed ?size ~hashable ()\n let of_alist ?growth_allowed ?size l = of_alist ?growth_allowed ~hashable ?size l\n\n let of_alist_report_all_dups ?growth_allowed ?size l =\n of_alist_report_all_dups ?growth_allowed ~hashable ?size l\n ;;\n\n let of_alist_or_error ?growth_allowed ?size l =\n of_alist_or_error ?growth_allowed ~hashable ?size l\n ;;\n\n let of_alist_exn ?growth_allowed ?size l =\n of_alist_exn ?growth_allowed ~hashable ?size l\n ;;\n\n let t_of_sexp k_of_sexp d_of_sexp sexp = t_of_sexp ~hashable k_of_sexp d_of_sexp sexp\n\n let of_alist_multi ?growth_allowed ?size l =\n of_alist_multi ?growth_allowed ~hashable ?size l\n ;;\n\n let create_mapped ?growth_allowed ?size ~get_key ~get_data l =\n create_mapped ?growth_allowed ~hashable ?size ~get_key ~get_data l\n ;;\n\n let create_with_key ?growth_allowed ?size ~get_key l =\n create_with_key ?growth_allowed ~hashable ?size ~get_key l\n ;;\n\n let create_with_key_or_error ?growth_allowed ?size ~get_key l =\n create_with_key_or_error ?growth_allowed ~hashable ?size ~get_key l\n ;;\n\n let create_with_key_exn ?growth_allowed ?size ~get_key l =\n create_with_key_exn ?growth_allowed ~hashable ?size ~get_key l\n ;;\n\n let group ?growth_allowed ?size ~get_key ~get_data ~combine l =\n group ?growth_allowed ~hashable ?size ~get_key ~get_data ~combine l\n ;;\nend\n\nmodule Poly = struct\n type nonrec ('a, 'b) t = ('a, 'b) t\n type 'a key = 'a\n\n let hashable = Hashable.poly\n\n include Creators (struct\n type 'a t = 'a\n\n let hashable = hashable\n end)\n\n include Accessors\n\n let sexp_of_t = sexp_of_t\nend\n\nmodule Private = struct\n module type Creators_generic = Creators_generic\n module type Hashable = Hashable.Hashable\n\n type nonrec ('key, 'data, 'z) create_options_without_first_class_module =\n ('key, 'data, 'z) create_options_without_first_class_module\n\n let hashable t = t.hashable\nend\n\nlet create ?growth_allowed ?size m =\n create ~hashable:(Hashable.of_key m) ?growth_allowed ?size ()\n;;\n\nlet of_alist ?growth_allowed ?size m l =\n of_alist ~hashable:(Hashable.of_key m) ?growth_allowed ?size l\n;;\n\nlet of_alist_report_all_dups ?growth_allowed ?size m l =\n of_alist_report_all_dups ~hashable:(Hashable.of_key m) ?growth_allowed ?size l\n;;\n\nlet of_alist_or_error ?growth_allowed ?size m l =\n of_alist_or_error ~hashable:(Hashable.of_key m) ?growth_allowed ?size l\n;;\n\nlet of_alist_exn ?growth_allowed ?size m l =\n of_alist_exn ~hashable:(Hashable.of_key m) ?growth_allowed ?size l\n;;\n\nlet of_alist_multi ?growth_allowed ?size m l =\n of_alist_multi ~hashable:(Hashable.of_key m) ?growth_allowed ?size l\n;;\n\nlet create_mapped ?growth_allowed ?size m ~get_key ~get_data l =\n create_mapped ~hashable:(Hashable.of_key m) ?growth_allowed ?size ~get_key ~get_data l\n;;\n\nlet create_with_key ?growth_allowed ?size m ~get_key l =\n create_with_key ~hashable:(Hashable.of_key m) ?growth_allowed ?size ~get_key l\n;;\n\nlet create_with_key_or_error ?growth_allowed ?size m ~get_key l =\n create_with_key_or_error ~hashable:(Hashable.of_key m) ?growth_allowed ?size ~get_key l\n;;\n\nlet create_with_key_exn ?growth_allowed ?size m ~get_key l =\n create_with_key_exn ~hashable:(Hashable.of_key m) ?growth_allowed ?size ~get_key l\n;;\n\nlet group ?growth_allowed ?size m ~get_key ~get_data ~combine l =\n group ~hashable:(Hashable.of_key m) ?growth_allowed ?size ~get_key ~get_data ~combine l\n;;\n\nlet hashable_s t = Hashable.to_key t.hashable\n\nmodule M (K : T.T) = struct\n type nonrec 'v t = (K.t, 'v) t\nend\n\nmodule type Sexp_of_m = sig\n type t [@@deriving_inline sexp_of]\n\n val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t\n\n [@@@end]\nend\n\nmodule type M_of_sexp = sig\n type t [@@deriving_inline of_sexp]\n\n val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t\n\n [@@@end]\n\n include Key.S with type t := t\nend\n\nlet sexp_of_m__t (type k) (module K : Sexp_of_m with type t = k) sexp_of_v t =\n sexp_of_t K.sexp_of_t sexp_of_v t\n;;\n\nlet m__t_of_sexp (type k) (module K : M_of_sexp with type t = k) v_of_sexp sexp =\n t_of_sexp ~hashable:(Hashable.of_key (module K)) K.t_of_sexp v_of_sexp sexp\n;;\n\n(* typechecking this code is a compile-time test that [Creators] is a specialization of\n [Creators_generic]. *)\nmodule Check : sig end = struct\n module Make_creators_check\n (Type : T.T2)\n (Key : T.T1)\n (Options : T.T3)\n (M : Creators_generic\n with type ('a, 'b) t := ('a, 'b) Type.t\n with type 'a key := 'a Key.t\n with type ('a, 'b, 'z) create_options := ('a, 'b, 'z) Options.t) =\n struct end\n\n module Check_creators_is_specialization_of_creators_generic (M : Creators) =\n Make_creators_check\n (struct\n type ('a, 'b) t = ('a, 'b) M.t\n end)\n (struct\n type 'a t = 'a\n end)\n (struct\n type ('a, 'b, 'z) t = ('a, 'b, 'z) create_options\n end)\n (struct\n include M\n\n let create ?growth_allowed ?size m () = create ?growth_allowed ?size m\n end)\nend\n","open! Import\n\nmodule Key = struct\n module type S = sig\n type t [@@deriving_inline compare, sexp_of]\n\n val compare : t -> t -> int\n val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t\n\n [@@@end]\n\n (** Two [t]s that [compare] equal must have equal hashes for the hashtable\n to behave properly. *)\n val hash : t -> int\n end\n\n type 'a t = (module S with type t = 'a)\nend\n\nmodule Merge_into_action = struct\n type 'a t =\n | Remove\n | Set_to of 'a\nend\n\nmodule type Accessors = sig\n (** {2 Accessors} *)\n\n type ('a, 'b) t\n type 'a key\n\n val sexp_of_key : ('a, _) t -> 'a key -> Sexp.t\n val clear : (_, _) t -> unit\n val copy : ('a, 'b) t -> ('a, 'b) t\n\n (** Attempting to modify ([set], [remove], etc.) the hashtable during iteration ([fold],\n [iter], [iter_keys], [iteri]) will raise an exception. *)\n val fold : ('a, 'b) t -> init:'c -> f:(key:'a key -> data:'b -> 'c -> 'c) -> 'c\n\n val iter_keys : ('a, _) t -> f:('a key -> unit) -> unit\n val iter : (_, 'b) t -> f:('b -> unit) -> unit\n\n (** Iterates over both keys and values.\n\n Example:\n\n {v\n let h = Hashtbl.of_alist_exn (module Int) [(1, 4); (5, 6)] in\n Hashtbl.iteri h ~f:(fun ~key ~data ->\n print_endline (Printf.sprintf \"%d-%d\" key data));;\n 1-4\n 5-6\n - : unit = ()\n v} *)\n val iteri : ('a, 'b) t -> f:(key:'a key -> data:'b -> unit) -> unit\n\n val existsi : ('a, 'b) t -> f:(key:'a key -> data:'b -> bool) -> bool\n val exists : (_, 'b) t -> f:('b -> bool) -> bool\n val for_alli : ('a, 'b) t -> f:(key:'a key -> data:'b -> bool) -> bool\n val for_all : (_, 'b) t -> f:('b -> bool) -> bool\n val counti : ('a, 'b) t -> f:(key:'a key -> data:'b -> bool) -> int\n val count : (_, 'b) t -> f:('b -> bool) -> int\n val length : (_, _) t -> int\n val is_empty : (_, _) t -> bool\n val mem : ('a, _) t -> 'a key -> bool\n val remove : ('a, _) t -> 'a key -> unit\n val choose : ('a, 'b) t -> ('a key * 'b) option\n val choose_exn : ('a, 'b) t -> 'a key * 'b\n\n (** Sets the given [key] to [data]. *)\n val set : ('a, 'b) t -> key:'a key -> data:'b -> unit\n\n (** [add] and [add_exn] leave the table unchanged if the key was already present. *)\n val add : ('a, 'b) t -> key:'a key -> data:'b -> [ `Ok | `Duplicate ]\n\n val add_exn : ('a, 'b) t -> key:'a key -> data:'b -> unit\n\n (** [change t key ~f] changes [t]'s value for [key] to be [f (find t key)]. *)\n val change : ('a, 'b) t -> 'a key -> f:('b option -> 'b option) -> unit\n\n (** [update t key ~f] is [change t key ~f:(fun o -> Some (f o))]. *)\n val update : ('a, 'b) t -> 'a key -> f:('b option -> 'b) -> unit\n\n (** [map t f] returns a new table with values replaced by the result of applying [f]\n to the current values.\n\n Example:\n\n {v\n let h = Hashtbl.of_alist_exn (module Int) [(1, 4); (5, 6)] in\n let h' = Hashtbl.map h ~f:(fun x -> x * 2) in\n Hashtbl.to_alist h';;\n - : (int * int) list = [(5, 12); (1, 8)]\n v} *)\n val map : ('a, 'b) t -> f:('b -> 'c) -> ('a, 'c) t\n\n (** Like [map], but the function [f] takes both key and data as arguments. *)\n val mapi : ('a, 'b) t -> f:(key:'a key -> data:'b -> 'c) -> ('a, 'c) t\n\n (** Returns a new table by filtering the given table's values by [f]: the keys for which\n [f] applied to the current value returns [Some] are kept, and those for which it\n returns [None] are discarded.\n\n Example:\n\n {v\n let h = Hashtbl.of_alist_exn (module Int) [(1, 4); (5, 6)] in\n Hashtbl.filter_map h ~f:(fun x -> if x > 5 then Some x else None)\n |> Hashtbl.to_alist;;\n - : (int * int) list = [(5, 6)]\n v} *)\n val filter_map : ('a, 'b) t -> f:('b -> 'c option) -> ('a, 'c) t\n\n (** Like [filter_map], but the function [f] takes both key and data as arguments. *)\n val filter_mapi : ('a, 'b) t -> f:(key:'a key -> data:'b -> 'c option) -> ('a, 'c) t\n\n val filter_keys : ('a, 'b) t -> f:('a key -> bool) -> ('a, 'b) t\n val filter : ('a, 'b) t -> f:('b -> bool) -> ('a, 'b) t\n val filteri : ('a, 'b) t -> f:(key:'a key -> data:'b -> bool) -> ('a, 'b) t\n\n (** Returns new tables with bound values partitioned by [f] applied to the bound\n values. *)\n val partition_map\n : ('a, 'b) t\n -> f:('b -> ('c, 'd) Either.t)\n -> ('a, 'c) t * ('a, 'd) t\n\n (** Like [partition_map], but the function [f] takes both key and data as arguments. *)\n val partition_mapi\n : ('a, 'b) t\n -> f:(key:'a key -> data:'b -> ('c, 'd) Either.t)\n -> ('a, 'c) t * ('a, 'd) t\n\n (** Returns a pair of tables [(t1, t2)], where [t1] contains all the elements of the\n initial table which satisfy the predicate [f], and [t2] contains the rest. *)\n val partition_tf : ('a, 'b) t -> f:('b -> bool) -> ('a, 'b) t * ('a, 'b) t\n\n (** Like [partition_tf], but the function [f] takes both key and data as arguments. *)\n val partitioni_tf\n : ('a, 'b) t\n -> f:(key:'a key -> data:'b -> bool)\n -> ('a, 'b) t * ('a, 'b) t\n\n (** [find_or_add t k ~default] returns the data associated with key [k] if it is in the\n table [t], and otherwise assigns [k] the value returned by [default ()]. *)\n val find_or_add : ('a, 'b) t -> 'a key -> default:(unit -> 'b) -> 'b\n\n (** Like [find_or_add] but [default] takes the key as an argument. *)\n val findi_or_add : ('a, 'b) t -> 'a key -> default:('a key -> 'b) -> 'b\n\n (** [find t k] returns [Some] (the current binding) of [k] in [t], or [None] if no such\n binding exists. *)\n val find : ('a, 'b) t -> 'a key -> 'b option\n\n (** [find_exn t k] returns the current binding of [k] in [t], or raises [Caml.Not_found]\n or [Not_found_s] if no such binding exists. *)\n val find_exn : ('a, 'b) t -> 'a key -> 'b\n\n (** [find_and_call t k ~if_found ~if_not_found]\n\n is equivalent to:\n\n [match find t k with Some v -> if_found v | None -> if_not_found k]\n\n except that it doesn't allocate the option. *)\n val find_and_call\n : ('a, 'b) t\n -> 'a key\n -> if_found:('b -> 'c)\n -> if_not_found:('a key -> 'c)\n -> 'c\n\n (** Just like [find_and_call], but takes an extra argument which is passed to [if_found]\n and [if_not_found], so that the client code can avoid allocating closures or using\n refs to pass this additional information. This function is only useful in code\n which tries to minimize heap allocation. *)\n val find_and_call1\n : ('a, 'b) t\n -> 'a key\n -> a:'d\n -> if_found:('b -> 'd -> 'c)\n -> if_not_found:('a key -> 'd -> 'c)\n -> 'c\n\n val find_and_call2\n : ('a, 'b) t\n -> 'a key\n -> a:'d\n -> b:'e\n -> if_found:('b -> 'd -> 'e -> 'c)\n -> if_not_found:('a key -> 'd -> 'e -> 'c)\n -> 'c\n\n val findi_and_call\n : ('a, 'b) t\n -> 'a key\n -> if_found:(key:'a key -> data:'b -> 'c)\n -> if_not_found:('a key -> 'c)\n -> 'c\n\n val findi_and_call1\n : ('a, 'b) t\n -> 'a key\n -> a:'d\n -> if_found:(key:'a key -> data:'b -> 'd -> 'c)\n -> if_not_found:('a key -> 'd -> 'c)\n -> 'c\n\n val findi_and_call2\n : ('a, 'b) t\n -> 'a key\n -> a:'d\n -> b:'e\n -> if_found:(key:'a key -> data:'b -> 'd -> 'e -> 'c)\n -> if_not_found:('a key -> 'd -> 'e -> 'c)\n -> 'c\n\n (** [find_and_remove t k] returns Some (the current binding) of k in t and removes it,\n or None is no such binding exists. *)\n val find_and_remove : ('a, 'b) t -> 'a key -> 'b option\n\n (** Merges two hashtables.\n\n The result of [merge f h1 h2] has as keys the set of all [k] in the union of the\n sets of keys of [h1] and [h2] for which [d(k)] is not None, where:\n\n d(k) =\n - [f ~key:k (`Left d1)]\n if [k] in [h1] maps to d1, and [h2] does not have data for [k];\n\n - [f ~key:k (`Right d2)]\n if [k] in [h2] maps to d2, and [h1] does not have data for [k];\n\n - [f ~key:k (`Both (d1, d2))]\n otherwise, where [k] in [h1] maps to [d1] and [k] in [h2] maps to [d2].\n\n Each key [k] is mapped to a single piece of data [x], where [d(k) = Some x].\n\n Example:\n\n {v\n let h1 = Hashtbl.of_alist_exn (module Int) [(1, 5); (2, 3232)] in\n let h2 = Hashtbl.of_alist_exn (module Int) [(1, 3)] in\n Hashtbl.merge h1 h2 ~f:(fun ~key:_ -> function\n | `Left x -> Some (`Left x)\n | `Right x -> Some (`Right x)\n | `Both (x, y) -> if x=y then None else Some (`Both (x,y))\n ) |> Hashtbl.to_alist;;\n - : (int * [> `Both of int * int | `Left of int | `Right of int ]) list =\n [(2, `Left 3232); (1, `Both (5, 3))]\n v} *)\n val merge\n : ('k, 'a) t\n -> ('k, 'b) t\n -> f:(key:'k key -> [ `Left of 'a | `Right of 'b | `Both of 'a * 'b ] -> 'c option)\n -> ('k, 'c) t\n\n\n (** Every [key] in [src] will be removed or set in [dst] according to the return value\n of [f]. *)\n val merge_into\n : src:('k, 'a) t\n -> dst:('k, 'b) t\n -> f:(key:'k key -> 'a -> 'b option -> 'b Merge_into_action.t)\n -> unit\n\n (** Returns the list of all keys for given hashtable. *)\n val keys : ('a, _) t -> 'a key list\n\n (** Returns the list of all data for given hashtable. *)\n val data : (_, 'b) t -> 'b list\n\n (** [filter_inplace t ~f] removes all the elements from [t] that don't satisfy [f]. *)\n val filter_keys_inplace : ('a, _) t -> f:('a key -> bool) -> unit\n\n val filter_inplace : (_, 'b) t -> f:('b -> bool) -> unit\n val filteri_inplace : ('a, 'b) t -> f:(key:'a key -> data:'b -> bool) -> unit\n\n (** [map_inplace t ~f] applies [f] to all elements in [t], transforming them in\n place. *)\n val map_inplace : (_, 'b) t -> f:('b -> 'b) -> unit\n\n val mapi_inplace : ('a, 'b) t -> f:(key:'a key -> data:'b -> 'b) -> unit\n\n (** [filter_map_inplace] combines the effects of [map_inplace] and [filter_inplace]. *)\n val filter_map_inplace : (_, 'b) t -> f:('b -> 'b option) -> unit\n\n val filter_mapi_inplace : ('a, 'b) t -> f:(key:'a key -> data:'b -> 'b option) -> unit\n\n (** [equal f t1 t2] and [similar f t1 t2] both return true iff [t1] and [t2] have the\n same keys and for all keys [k], [f (find_exn t1 k) (find_exn t2 k)]. [equal] and\n [similar] only differ in their types. *)\n val equal : ('b -> 'b -> bool) -> ('a, 'b) t -> ('a, 'b) t -> bool\n\n val similar : ('b1 -> 'b2 -> bool) -> ('a, 'b1) t -> ('a, 'b2) t -> bool\n\n (** Returns the list of all (key, data) pairs for given hashtable. *)\n val to_alist : ('a, 'b) t -> ('a key * 'b) list\n\n val validate\n : name:('a key -> string)\n -> 'b Validate.check\n -> ('a, 'b) t Validate.check\n\n\n (** [remove_if_zero]'s default is [false]. *)\n val incr : ?by:int -> ?remove_if_zero:bool -> ('a, int) t -> 'a key -> unit\n\n val decr : ?by:int -> ?remove_if_zero:bool -> ('a, int) t -> 'a key -> unit\nend\n\nmodule type Multi = sig\n type ('a, 'b) t\n type 'a key\n\n (** [add_multi t ~key ~data] if [key] is present in the table then cons\n [data] on the list, otherwise add [key] with a single element list. *)\n val add_multi : ('a, 'b list) t -> key:'a key -> data:'b -> unit\n\n (** [remove_multi t key] updates the table, removing the head of the list bound to\n [key]. If the list has only one element (or is empty) then the binding is\n removed. *)\n val remove_multi : ('a, _ list) t -> 'a key -> unit\n\n (** [find_multi t key] returns the empty list if [key] is not present in the table,\n returns [t]'s values for [key] otherwise. *)\n val find_multi : ('a, 'b list) t -> 'a key -> 'b list\nend\n\ntype ('key, 'data, 'z) create_options =\n ?growth_allowed:bool (** defaults to [true] *)\n -> ?size:int (** initial size -- default 0 *)\n -> 'key Key.t\n -> 'z\n\ntype ('key, 'data, 'z) create_options_without_first_class_module =\n ?growth_allowed:bool (** defaults to [true] *)\n -> ?size:int (** initial size -- default 0 *)\n -> 'z\n\nmodule type Creators_generic = sig\n type ('a, 'b) t\n type 'a key\n type ('key, 'data, 'z) create_options\n\n val create : ('a key, 'b, unit -> ('a, 'b) t) create_options\n\n\n val of_alist\n : ( 'a key\n , 'b\n , ('a key * 'b) list -> [ `Ok of ('a, 'b) t | `Duplicate_key of 'a key ] )\n create_options\n\n val of_alist_report_all_dups\n : ( 'a key\n , 'b\n , ('a key * 'b) list -> [ `Ok of ('a, 'b) t | `Duplicate_keys of 'a key list ] )\n create_options\n\n val of_alist_or_error\n : ('a key, 'b, ('a key * 'b) list -> ('a, 'b) t Or_error.t) create_options\n\n val of_alist_exn : ('a key, 'b, ('a key * 'b) list -> ('a, 'b) t) create_options\n\n val of_alist_multi\n : ('a key, 'b list, ('a key * 'b) list -> ('a, 'b list) t) create_options\n\n\n (** {[ create_mapped get_key get_data [x1,...,xn]\n = of_alist [get_key x1, get_data x1; ...; get_key xn, get_data xn] ]} *)\n val create_mapped\n : ( 'a key\n , 'b\n , get_key:('r -> 'a key)\n -> get_data:('r -> 'b)\n -> 'r list\n -> [ `Ok of ('a, 'b) t | `Duplicate_keys of 'a key list ] )\n create_options\n\n\n (** {[ create_with_key ~get_key [x1,...,xn]\n = of_alist [get_key x1, x1; ...; get_key xn, xn] ]} *)\n val create_with_key\n : ( 'a key\n , 'r\n , get_key:('r -> 'a key)\n -> 'r list\n -> [ `Ok of ('a, 'r) t | `Duplicate_keys of 'a key list ] )\n create_options\n\n val create_with_key_or_error\n : ( 'a key\n , 'r\n , get_key:('r -> 'a key) -> 'r list -> ('a, 'r) t Or_error.t )\n create_options\n\n val create_with_key_exn\n : ('a key, 'r, get_key:('r -> 'a key) -> 'r list -> ('a, 'r) t) create_options\n\n\n val group\n : ( 'a key\n , 'b\n , get_key:('r -> 'a key)\n -> get_data:('r -> 'b)\n -> combine:('b -> 'b -> 'b)\n -> 'r list\n -> ('a, 'b) t )\n create_options\nend\n\nmodule type Creators = sig\n type ('a, 'b) t\n\n (** {2 Creators} *)\n\n (** The module you pass to [create] must have a type that is hashable, sexpable, and\n comparable.\n\n Example:\n\n {v\n Hashtbl.create (module Int);;\n - : (int, '_a) Hashtbl.t = ;;\n v} *)\n val create\n : ?growth_allowed:bool (** defaults to [true] *)\n -> ?size:int (** initial size -- default 0 *)\n -> 'a Key.t\n -> ('a, 'b) t\n\n (** Example:\n\n {v\n Hashtbl.of_alist (module Int) [(3, \"something\"); (2, \"whatever\")]\n - : [ `Duplicate_key of int | `Ok of (int, string) Hashtbl.t ] = `Ok \n v} *)\n val of_alist\n : ?growth_allowed:bool (** defaults to [true] *)\n -> ?size:int (** initial size -- default 0 *)\n -> 'a Key.t\n -> ('a * 'b) list\n -> [ `Ok of ('a, 'b) t | `Duplicate_key of 'a ]\n\n (** Whereas [of_alist] will report [Duplicate_key] no matter how many dups there are in\n your list, [of_alist_report_all_dups] will report each and every duplicate entry.\n\n For example:\n\n {v\n Hashtbl.of_alist (module Int) [(1, \"foo\"); (1, \"bar\"); (2, \"foo\"); (2, \"bar\")];;\n - : [ `Duplicate_key of int | `Ok of (int, string) Hashtbl.t ] = `Duplicate_key 1\n\n Hashtbl.of_alist_report_all_dups (module Int) [(1, \"foo\"); (1, \"bar\"); (2, \"foo\"); (2, \"bar\")];;\n - : [ `Duplicate_keys of int list | `Ok of (int, string) Hashtbl.t ] = `Duplicate_keys [1; 2]\n v} *)\n val of_alist_report_all_dups\n : ?growth_allowed:bool (** defaults to [true] *)\n -> ?size:int (** initial size -- default 0 *)\n -> 'a Key.t\n -> ('a * 'b) list\n -> [ `Ok of ('a, 'b) t | `Duplicate_keys of 'a list ]\n\n val of_alist_or_error\n : ?growth_allowed:bool (** defaults to [true] *)\n -> ?size:int (** initial size -- default 0 *)\n -> 'a Key.t\n -> ('a * 'b) list\n -> ('a, 'b) t Or_error.t\n\n val of_alist_exn\n : ?growth_allowed:bool (** defaults to [true] *)\n -> ?size:int (** initial size -- default 0 *)\n -> 'a Key.t\n -> ('a * 'b) list\n -> ('a, 'b) t\n\n (** Creates a {{!Multi} \"multi\"} hashtable, i.e., a hashtable where each key points to a\n list potentially containing multiple values. So instead of short-circuiting with a\n [`Duplicate_key] variant on duplicates, as in [of_alist], [of_alist_multi] folds\n those values into a list for the given key:\n\n {v\n let h = Hashtbl.of_alist_multi (module Int) [(1, \"a\"); (1, \"b\"); (2, \"c\"); (2, \"d\")];;\n val h : (int, string list) Hashtbl.t = \n\n Hashtbl.find_exn h 1;;\n - : string list = [\"b\"; \"a\"]\n v} *)\n val of_alist_multi\n : ?growth_allowed:bool (** defaults to [true] *)\n -> ?size:int (** initial size -- default 0 *)\n -> 'a Key.t\n -> ('a * 'b) list\n -> ('a, 'b list) t\n\n (** Applies the [get_key] and [get_data] functions to the ['r list] to create the\n initial keys and values, respectively, for the new hashtable.\n\n {[ create_mapped get_key get_data [x1;...;xn]\n = of_alist [get_key x1, get_data x1; ...; get_key xn, get_data xn]\n ]}\n\n Example:\n\n {v\n let h =\n Hashtbl.create_mapped (module Int)\n ~get_key:(fun x -> x)\n ~get_data:(fun x -> x + 1)\n [1; 2; 3];;\n val h : [ `Duplicate_keys of int list | `Ok of (int, int) Hashtbl.t ] = `Ok \n\n let h =\n match h with\n | `Ok x -> x\n | `Duplicate_keys _ -> failwith \"\"\n in\n Hashtbl.find_exn h 1;;\n - : int = 2\n v} *)\n val create_mapped\n : ?growth_allowed:bool (** defaults to [true] *)\n -> ?size:int (** initial size -- default 0 *)\n -> 'a Key.t\n -> get_key:('r -> 'a)\n -> get_data:('r -> 'b)\n -> 'r list\n -> [ `Ok of ('a, 'b) t | `Duplicate_keys of 'a list ]\n\n (** {[ create_with_key ~get_key [x1;...;xn]\n = of_alist [get_key x1, x1; ...; get_key xn, xn] ]} *)\n val create_with_key\n : ?growth_allowed:bool (** defaults to [true] *)\n -> ?size:int (** initial size -- default 0 *)\n -> 'a Key.t\n -> get_key:('r -> 'a)\n -> 'r list\n -> [ `Ok of ('a, 'r) t | `Duplicate_keys of 'a list ]\n\n val create_with_key_or_error\n : ?growth_allowed:bool (** defaults to [true] *)\n -> ?size:int (** initial size -- default 0 *)\n -> 'a Key.t\n -> get_key:('r -> 'a)\n -> 'r list\n -> ('a, 'r) t Or_error.t\n\n val create_with_key_exn\n : ?growth_allowed:bool (** defaults to [true] *)\n -> ?size:int (** initial size -- default 0 *)\n -> 'a Key.t\n -> get_key:('r -> 'a)\n -> 'r list\n -> ('a, 'r) t\n\n (** Like [create_mapped], applies the [get_key] and [get_data] functions to the ['r\n list] to create the initial keys and values, respectively, for the new hashtable --\n and then, like [add_multi], folds together values belonging to the same keys. Here,\n though, the function used for the folding is given by [combine] (instead of just\n being a [cons]).\n\n Example:\n\n {v\n Hashtbl.group (module Int)\n ~get_key:(fun x -> x / 2)\n ~get_data:(fun x -> x)\n ~combine:(fun x y -> x * y)\n [ 1; 2; 3; 4]\n |> Hashtbl.to_alist;;\n - : (int * int) list = [(2, 4); (1, 6); (0, 1)]\n v} *)\n val group\n : ?growth_allowed:bool (** defaults to [true] *)\n -> ?size:int (** initial size -- default 0 *)\n -> 'a Key.t\n -> get_key:('r -> 'a)\n -> get_data:('r -> 'b)\n -> combine:('b -> 'b -> 'b)\n -> 'r list\n -> ('a, 'b) t\nend\n\nmodule type S_without_submodules = sig\n val hash : 'a -> int\n val hash_param : int -> int -> 'a -> int\n\n type ('a, 'b) t\n\n (** We provide a [sexp_of_t] but not a [t_of_sexp] for this type because one needs to be\n explicit about the hash and comparison functions used when creating a hashtable.\n Note that [Hashtbl.Poly.t] does have [[@@deriving sexp]], and uses OCaml's built-in\n polymorphic comparison and and polymorphic hashing. *)\n val sexp_of_t : ('a -> Sexp.t) -> ('b -> Sexp.t) -> ('a, 'b) t -> Sexp.t\n\n include Creators with type ('a, 'b) t := ('a, 'b) t (** @inline *)\n\n include\n Accessors with type ('a, 'b) t := ('a, 'b) t with type 'a key = 'a\n (** @inline *)\n\n\n include\n Multi with type ('a, 'b) t := ('a, 'b) t with type 'a key := 'a key\n (** @inline *)\n\n val hashable_s : ('key, _) t -> 'key Key.t\n\n include Invariant.S2 with type ('a, 'b) t := ('a, 'b) t\nend\n\nmodule type S_poly = sig\n type ('a, 'b) t [@@deriving_inline sexp]\n\n include Ppx_sexp_conv_lib.Sexpable.S2 with type ('a, 'b) t := ('a, 'b) t\n\n [@@@end]\n\n val hashable : 'a Hashable.t\n\n include Invariant.S2 with type ('a, 'b) t := ('a, 'b) t\n\n include\n Creators_generic\n with type ('a, 'b) t := ('a, 'b) t\n with type 'a key = 'a\n with type ('key, 'data, 'z) create_options :=\n ('key, 'data, 'z) create_options_without_first_class_module\n\n include Accessors with type ('a, 'b) t := ('a, 'b) t with type 'a key := 'a key\n include Multi with type ('a, 'b) t := ('a, 'b) t with type 'a key := 'a key\nend\n\nmodule type For_deriving = sig\n type ('k, 'v) t\n\n module type Sexp_of_m = sig\n type t [@@deriving_inline sexp_of]\n\n val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t\n\n [@@@end]\n end\n\n module type M_of_sexp = sig\n type t [@@deriving_inline of_sexp]\n\n val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t\n\n [@@@end]\n\n include Key.S with type t := t\n end\n\n val sexp_of_m__t\n : (module Sexp_of_m with type t = 'k)\n -> ('v -> Sexp.t)\n -> ('k, 'v) t\n -> Sexp.t\n\n val m__t_of_sexp\n : (module M_of_sexp with type t = 'k)\n -> (Sexp.t -> 'v)\n -> Sexp.t\n -> ('k, 'v) t\nend\n\nmodule type Hashtbl = sig\n (** A hash table is a mutable data structure implementing a map between keys and values.\n It supports constant-time lookup and in-place modification.\n\n {1 Usage}\n\n As a simple example, we'll create a hash table with string keys using the\n {{!create}[create]} constructor, which expects a module defining the key's type:\n\n {[\n let h = Hashtbl.create (module String);;\n val h : (string, '_a) Hashtbl.t = \n ]}\n\n We can set the values of individual keys with {{!set}[set]}. If the key already has\n a value, it will be overwritten.\n\n {v\n Hashtbl.set h ~key:\"foo\" ~data:5;;\n - : unit = ()\n\n Hashtbl.set h ~key:\"foo\" ~data:6;;\n - : unit = ()\n\n Hashtbl.set h ~key:\"bar\" ~data:6;;\n - : unit = ()\n v}\n\n We can access values by key, or dump all of the hash table's data:\n\n {v\n Hashtbl.find h \"foo\";;\n - : int option = Some 6\n\n Hashtbl.find_exn h \"foo\";;\n - : int = 6\n\n Hashtbl.to_alist h;;\n - : (string * int) list = [(\"foo\", 6); (\"bar\", 6)]\n v}\n\n {{!change}[change]} lets us change a key's value by applying the given function:\n\n {v\n Hashtbl.change h \"foo\" (fun x ->\n match x with\n | Some x -> Some (x * 2)\n | None -> None\n );;\n - : unit = ()\n\n Hashtbl.to_alist h;;\n - : (string * int) list = [(\"foo\", 12); (\"bar\", 6)]\n v}\n\n\n We can use {{!merge}[merge]} to merge two hashtables with fine-grained control over\n how we choose values when a key is present in the first (\"left\") hashtable, the\n second (\"right\"), or both. Here, we'll cons the values when both hashtables have a\n key:\n\n {v\n let h1 = Hashtbl.of_alist_exn (module Int) [(1, 5); (2, 3232)] in\n let h2 = Hashtbl.of_alist_exn (module Int) [(1, 3)] in\n Hashtbl.merge h1 h2 ~f:(fun ~key:_ -> function\n | `Left x -> Some (`Left x)\n | `Right x -> Some (`Right x)\n | `Both (x, y) -> if x=y then None else Some (`Both (x,y))\n ) |> Hashtbl.to_alist;;\n - : (int * [> `Both of int * int | `Left of int | `Right of int ]) list =\n [(2, `Left 3232); (1, `Both (5, 3))]\n v}\n\n {1 Interface} *)\n\n include S_without_submodules (** @inline *)\n\n module type Accessors = Accessors\n module type Creators = Creators\n module type Key = Key.S [@@deprecated \"[since 2019-03] Use [Hashtbl.Key.S]\"]\n module type Multi = Multi\n module type S_poly = S_poly\n module type S_without_submodules = S_without_submodules\n module type For_deriving = For_deriving\n\n module Key = Key\n module Merge_into_action = Merge_into_action\n\n type nonrec ('key, 'data, 'z) create_options = ('key, 'data, 'z) create_options\n\n module Creators (Key : sig\n type 'a t\n\n val hashable : 'a t Hashable.t\n end) : sig\n type ('a, 'b) t_ = ('a Key.t, 'b) t\n\n val t_of_sexp : (Sexp.t -> 'a Key.t) -> (Sexp.t -> 'b) -> Sexp.t -> ('a, 'b) t_\n\n include\n Creators_generic\n with type ('a, 'b) t := ('a, 'b) t_\n with type 'a key := 'a Key.t\n with type ('key, 'data, 'a) create_options :=\n ('key, 'data, 'a) create_options_without_first_class_module\n end\n\n module Poly : S_poly with type ('a, 'b) t = ('a, 'b) t\n\n (** [M] is meant to be used in combination with OCaml applicative functor types:\n\n {[\n type string_to_int_table = int Hashtbl.M(String).t\n ]}\n\n which stands for:\n\n {[\n type string_to_int_table = (String.t, int) Hashtbl.t\n ]}\n\n The point is that [int Hashtbl.M(String).t] supports deriving, whereas the second\n syntax doesn't (because [t_of_sexp] doesn't know what comparison/hash function to\n use). *)\n module M (K : T.T) : sig\n type nonrec 'v t = (K.t, 'v) t\n end\n\n include For_deriving with type ('a, 'b) t := ('a, 'b) t\n\n (**/**)\n\n (*_ See the Jane Street Style Guide for an explanation of [Private] submodules:\n\n https://opensource.janestreet.com/standards/#private-submodules *)\n module Private : sig\n module type Creators_generic = Creators_generic\n\n type nonrec ('key, 'data, 'z) create_options_without_first_class_module =\n ('key, 'data, 'z) create_options_without_first_class_module\n\n val hashable : ('key, _) t -> 'key Hashable.t\n end\nend\n","open! Import\n\nmodule type Key = sig\n type t [@@deriving_inline compare, sexp_of]\n\n val compare : t -> t -> int\n val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t\n\n [@@@end]\n\n (** Values returned by [hash] must be non-negative. An exception will be raised in the\n case that [hash] returns a negative value. *)\n val hash : t -> int\nend\n\nmodule Hashable = struct\n type 'a t =\n { hash : 'a -> int\n ; compare : 'a -> 'a -> int\n ; sexp_of_t : 'a -> Sexp.t\n }\n\n (** This function is sound but not complete, meaning that if it returns [true] then it's\n safe to use the two interchangeably. If it's [false], you have no guarantees. For\n example:\n\n {[\n > utop\n open Core;;\n let equal (a : 'a Hashtbl_intf.Hashable.t) b =\n phys_equal a b\n || (phys_equal a.hash b.hash\n && phys_equal a.compare b.compare\n && phys_equal a.sexp_of_t b.sexp_of_t)\n ;;\n let a = Hashtbl_intf.Hashable.{ hash; compare; sexp_of_t = Int.sexp_of_t };;\n let b = Hashtbl_intf.Hashable.{ hash; compare; sexp_of_t = Int.sexp_of_t };;\n equal a b;; (* false?! *)\n ]}\n *)\n let equal a b =\n phys_equal a b\n || (phys_equal a.hash b.hash\n && phys_equal a.compare b.compare\n && phys_equal a.sexp_of_t b.sexp_of_t)\n ;;\n\n let hash_param = Caml.Hashtbl.hash_param\n let hash = Caml.Hashtbl.hash\n let poly = { hash; compare = Poly.compare; sexp_of_t = (fun _ -> Sexp.Atom \"_\") }\n\n let of_key (type a) (module Key : Key with type t = a) =\n { hash = Key.hash; compare = Key.compare; sexp_of_t = Key.sexp_of_t }\n ;;\n\n let to_key (type a) { hash; compare; sexp_of_t } =\n (module struct\n type t = a\n\n let hash = hash\n let compare = compare\n let sexp_of_t = sexp_of_t\n end : Key\n with type t = a)\n ;;\nend\n\ninclude Hashable\n\nmodule type Hashable = sig\n type 'a t = 'a Hashable.t =\n { hash : 'a -> int\n ; compare : 'a -> 'a -> int\n ; sexp_of_t : 'a -> Sexp.t\n }\n\n val equal : 'a t -> 'a t -> bool\n val poly : 'a t\n val of_key : (module Key with type t = 'a) -> 'a t\n val to_key : 'a t -> (module Key with type t = 'a)\n val hash_param : int -> int -> 'a -> int\n val hash : 'a -> int\nend\n","(* A few small things copied from other parts of Base because they depend on us, so we\n can't use them. *)\n\nopen! Import\n\nlet raise_s = Error.raise_s\n\nmodule Int = struct\n type t = int\n\n let max (x : t) y = if x > y then x else y\nend\n\n(* Its important that Empty have no args. It's tempting to make this type a record\n (e.g. to hold the compare function), but a lot of memory is saved by Empty being an\n immediate, since all unused buckets in the hashtbl don't use any memory (besides the\n array cell) *)\ntype ('k, 'v) t =\n | Empty\n | Node of\n { mutable left : ('k, 'v) t\n ; key : 'k\n ; mutable value : 'v\n ; mutable height : int\n ; mutable right : ('k, 'v) t\n }\n | Leaf of\n { key : 'k\n ; mutable value : 'v\n }\n\nlet empty = Empty\n\nlet is_empty = function\n | Empty -> true\n | Leaf _ | Node _ -> false\n;;\n\nlet height = function\n | Empty -> 0\n | Leaf _ -> 1\n | Node { left = _; key = _; value = _; height; right = _ } -> height\n;;\n\nlet invariant compare =\n let legal_left_key key = function\n | Empty -> ()\n | Leaf { key = left_key; value = _ }\n | Node { left = _; key = left_key; value = _; height = _; right = _ } ->\n assert (compare left_key key < 0)\n in\n let legal_right_key key = function\n | Empty -> ()\n | Leaf { key = right_key; value = _ }\n | Node { left = _; key = right_key; value = _; height = _; right = _ } ->\n assert (compare right_key key > 0)\n in\n let rec inv = function\n | Empty | Leaf _ -> ()\n | Node { left; key = k; value = _; height = h; right } ->\n let hl, hr = height left, height right in\n inv left;\n inv right;\n legal_left_key k left;\n legal_right_key k right;\n assert (h = Int.max hl hr + 1);\n assert (abs (hl - hr) <= 2)\n in\n inv\n;;\n\nlet invariant t ~compare = invariant compare t\n\n(* In the following comments,\n 't is balanced' means that 'invariant t' does not\n raise an exception. This implies of course that each node's height field is\n correct.\n 't is balanceable' means that height of the left and right subtrees of t\n differ by at most 3. *)\n\n(* @pre: left and right subtrees have correct heights\n @post: output has the correct height *)\nlet update_height = function\n | Node ({ left; key = _; value = _; height = old_height; right } as x) ->\n let new_height = Int.max (height left) (height right) + 1 in\n if new_height <> old_height then x.height <- new_height\n | Empty | Leaf _ -> assert false\n;;\n\n(* @pre: left and right subtrees are balanced\n @pre: tree is balanceable\n @post: output is balanced (in particular, height is correct) *)\nlet balance tree =\n match tree with\n | Empty | Leaf _ -> tree\n | Node ({ left; key = _; value = _; height = _; right } as root_node) ->\n let hl = height left\n and hr = height right in\n (* + 2 is critically important, lowering it to 1 will break the Leaf\n assumptions in the code below, and will force us to promote leaf nodes in\n the balance routine. It's also faster, since it will balance less often.\n Note that the following code is delicate. The update_height calls must\n occur in the correct order, since update_height assumes its children have\n the correct heights. *)\n if hl > hr + 2\n then (\n match left with\n (* It cannot be a leaf, because even if right is empty, a leaf\n is only height 1 *)\n | Empty | Leaf _ -> assert false\n | Node\n ({ left = left_node_left\n ; key = _\n ; value = _\n ; height = _\n ; right = left_node_right\n } as left_node) ->\n if height left_node_left >= height left_node_right\n then (\n root_node.left <- left_node_right;\n left_node.right <- tree;\n update_height tree;\n update_height left;\n left)\n else (\n (* if right is a leaf, then left must be empty. That means\n height is 2. Even if hr is empty we still can't get here. *)\n match left_node_right with\n | Empty | Leaf _ -> assert false\n | Node\n ({ left = lr_left; key = _; value = _; height = _; right = lr_right } as\n lr_node) ->\n left_node.right <- lr_left;\n root_node.left <- lr_right;\n lr_node.right <- tree;\n lr_node.left <- left;\n update_height left;\n update_height tree;\n update_height left_node_right;\n left_node_right))\n else if hr > hl + 2\n then (\n (* see above for an explanation of why right cannot be a leaf *)\n match right with\n | Empty | Leaf _ -> assert false\n | Node\n ({ left = right_node_left\n ; key = _\n ; value = _\n ; height = _\n ; right = right_node_right\n } as right_node) ->\n if height right_node_right >= height right_node_left\n then (\n root_node.right <- right_node_left;\n right_node.left <- tree;\n update_height tree;\n update_height right;\n right)\n else (\n (* see above for an explanation of why this cannot be a leaf *)\n match right_node_left with\n | Empty | Leaf _ -> assert false\n | Node\n ({ left = rl_left; key = _; value = _; height = _; right = rl_right } as\n rl_node) ->\n right_node.left <- rl_right;\n root_node.right <- rl_left;\n rl_node.left <- tree;\n rl_node.right <- right;\n update_height right;\n update_height tree;\n update_height right_node_left;\n right_node_left))\n else (\n update_height tree;\n tree)\n;;\n\n(* @pre: tree is balanceable\n @pre: abs (height (right node) - height (balance tree)) <= 3\n @post: result is balanceable *)\n\n(* @pre: tree is balanceable\n @pre: abs (height (right node) - height (balance tree)) <= 3\n @post: result is balanceable *)\nlet set_left node tree =\n let tree = balance tree in\n match node with\n | Node ({ left; key = _; value = _; height = _; right = _ } as r) ->\n if phys_equal left tree then () else r.left <- tree;\n update_height node\n | _ -> assert false\n;;\n\n(* @pre: tree is balanceable\n @pre: abs (height (left node) - height (balance tree)) <= 3\n @post: result is balanceable *)\nlet set_right node tree =\n let tree = balance tree in\n match node with\n | Node ({ left = _; key = _; value = _; height = _; right } as r) ->\n if phys_equal right tree then () else r.right <- tree;\n update_height node\n | _ -> assert false\n;;\n\n(* @pre: t is balanced.\n @post: result is balanced, with new node inserted\n @post: !added = true iff the shape of the input tree changed. *)\nlet add =\n let rec add t replace added compare k v =\n match t with\n | Empty ->\n added := true;\n Leaf { key = k; value = v }\n | Leaf ({ key = k'; value = _ } as r) ->\n let c = compare k' k in\n (* This compare is reversed on purpose, we are pretending\n that the leaf was just inserted instead of the other way\n round, that way we only allocate one node. *)\n if c = 0\n then (\n added := false;\n if replace then r.value <- v;\n t)\n else (\n added := true;\n if c < 0\n then Node { left = t; key = k; value = v; height = 2; right = Empty }\n else Node { left = Empty; key = k; value = v; height = 2; right = t })\n | Node ({ left; key = k'; value = _; height = _; right } as r) ->\n let c = compare k k' in\n if c = 0\n then (\n added := false;\n if replace then r.value <- v)\n else if c < 0\n then set_left t (add left replace added compare k v)\n else set_right t (add right replace added compare k v);\n t\n in\n fun t ~replace ~compare ~added ~key ~data ->\n let t = add t replace added compare key data in\n if !added then balance t else t\n;;\n\nlet rec first t =\n match t with\n | Empty -> None\n | Leaf { key = k; value = v }\n | Node { left = Empty; key = k; value = v; height = _; right = _ } -> Some (k, v)\n | Node { left = l; key = _; value = _; height = _; right = _ } -> first l\n;;\n\nlet rec last t =\n match t with\n | Empty -> None\n | Leaf { key = k; value = v }\n | Node { left = _; key = k; value = v; height = _; right = Empty } -> Some (k, v)\n | Node { left = _; key = _; value = _; height = _; right = r } -> last r\n;;\n\n\nlet[@inline always] rec findi_and_call_impl\n t\n ~compare\n k\n arg1\n arg2\n ~call_if_found\n ~call_if_not_found\n ~if_found\n ~if_not_found\n =\n match t with\n | Empty -> call_if_not_found ~if_not_found k arg1 arg2\n | Leaf { key = k'; value = v } ->\n if compare k k' = 0\n then call_if_found ~if_found ~key:k' ~data:v arg1 arg2\n else call_if_not_found ~if_not_found k arg1 arg2\n | Node { left; key = k'; value = v; height = _; right } ->\n let c = compare k k' in\n if c = 0\n then call_if_found ~if_found ~key:k' ~data:v arg1 arg2\n else\n findi_and_call_impl\n (if c < 0 then left else right)\n ~compare\n k\n arg1\n arg2\n ~call_if_found\n ~call_if_not_found\n ~if_found\n ~if_not_found\n;;\n\nlet find_and_call =\n let call_if_found ~if_found ~key:_ ~data () () = if_found data in\n let call_if_not_found ~if_not_found key () () = if_not_found key in\n fun t ~compare k ~if_found ~if_not_found ->\n findi_and_call_impl\n t\n ~compare\n k\n ()\n ()\n ~call_if_found\n ~call_if_not_found\n ~if_found\n ~if_not_found\n;;\n\nlet findi_and_call =\n let call_if_found ~if_found ~key ~data () () = if_found ~key ~data in\n let call_if_not_found ~if_not_found key () () = if_not_found key in\n fun t ~compare k ~if_found ~if_not_found ->\n findi_and_call_impl\n t\n ~compare\n k\n ()\n ()\n ~call_if_found\n ~call_if_not_found\n ~if_found\n ~if_not_found\n;;\n\nlet find_and_call1 =\n let call_if_found ~if_found ~key:_ ~data arg () = if_found data arg in\n let call_if_not_found ~if_not_found key arg () = if_not_found key arg in\n fun t ~compare k ~a ~if_found ~if_not_found ->\n findi_and_call_impl\n t\n ~compare\n k\n a\n ()\n ~call_if_found\n ~call_if_not_found\n ~if_found\n ~if_not_found\n;;\n\nlet findi_and_call1 =\n let call_if_found ~if_found ~key ~data arg () = if_found ~key ~data arg in\n let call_if_not_found ~if_not_found key arg () = if_not_found key arg in\n fun t ~compare k ~a ~if_found ~if_not_found ->\n findi_and_call_impl\n t\n ~compare\n k\n a\n ()\n ~call_if_found\n ~call_if_not_found\n ~if_found\n ~if_not_found\n;;\n\nlet find_and_call2 =\n let call_if_found ~if_found ~key:_ ~data arg1 arg2 = if_found data arg1 arg2 in\n let call_if_not_found ~if_not_found key arg1 arg2 = if_not_found key arg1 arg2 in\n fun t ~compare k ~a ~b ~if_found ~if_not_found ->\n findi_and_call_impl\n t\n ~compare\n k\n a\n b\n ~call_if_found\n ~call_if_not_found\n ~if_found\n ~if_not_found\n;;\n\nlet findi_and_call2 =\n let call_if_found ~if_found ~key ~data arg1 arg2 = if_found ~key ~data arg1 arg2 in\n let call_if_not_found ~if_not_found key arg1 arg2 = if_not_found key arg1 arg2 in\n fun t ~compare k ~a ~b ~if_found ~if_not_found ->\n findi_and_call_impl\n t\n ~compare\n k\n a\n b\n ~call_if_found\n ~call_if_not_found\n ~if_found\n ~if_not_found\n;;\n\nlet find =\n let if_found v = Some v in\n let if_not_found _ = None in\n fun t ~compare k -> find_and_call t ~compare k ~if_found ~if_not_found\n;;\n\nlet mem =\n let if_found _ = true in\n let if_not_found _ = false in\n fun t ~compare k -> find_and_call t ~compare k ~if_found ~if_not_found\n;;\n\nlet remove =\n let rec min_elt tree =\n match tree with\n | Empty -> Empty\n | Leaf _ -> tree\n | Node { left = Empty; key = _; value = _; height = _; right = _ } -> tree\n | Node { left; key = _; value = _; height = _; right = _ } -> min_elt left\n in\n let rec remove_min_elt tree =\n match tree with\n | Empty -> assert false\n | Leaf _ -> Empty (* This must be the root *)\n | Node { left = Empty; key = _; value = _; height = _; right } -> right\n | Node { left = Leaf _; key = k; value = v; height = _; right = Empty } ->\n Leaf { key = k; value = v }\n | Node { left = Leaf _; key = _; value = _; height = _; right = _ } as node ->\n set_left node Empty;\n tree\n | Node { left; key = _; value = _; height = _; right = _ } as node ->\n set_left node (remove_min_elt left);\n tree\n in\n let merge t1 t2 =\n match t1, t2 with\n | Empty, t -> t\n | t, Empty -> t\n | _, _ ->\n let tree = min_elt t2 in\n (match tree with\n | Empty -> assert false\n | Leaf { key = k; value = v } ->\n let t2 = balance (remove_min_elt t2) in\n Node\n { left = t1\n ; key = k\n ; value = v\n ; height = Int.max (height t1) (height t2) + 1\n ; right = t2\n }\n | Node _ as node ->\n set_right node (remove_min_elt t2);\n set_left node t1;\n node)\n in\n let rec remove t removed compare k =\n match t with\n | Empty ->\n removed := false;\n Empty\n | Leaf { key = k'; value = _ } ->\n if compare k k' = 0\n then (\n removed := true;\n Empty)\n else (\n removed := false;\n t)\n | Node { left; key = k'; value = _; height = _; right } ->\n let c = compare k k' in\n if c = 0\n then (\n removed := true;\n merge left right)\n else if c < 0\n then (\n set_left t (remove left removed compare k);\n t)\n else (\n set_right t (remove right removed compare k);\n t)\n in\n fun t ~removed ~compare k -> balance (remove t removed compare k)\n;;\n\nlet rec fold t ~init ~f =\n match t with\n | Empty -> init\n | Leaf { key; value = data } -> f ~key ~data init\n | Node\n { left = Leaf { key = lkey; value = ldata }\n ; key\n ; value = data\n ; height = _\n ; right = Leaf { key = rkey; value = rdata }\n } -> f ~key:rkey ~data:rdata (f ~key ~data (f ~key:lkey ~data:ldata init))\n | Node\n { left = Leaf { key = lkey; value = ldata }\n ; key\n ; value = data\n ; height = _\n ; right = Empty\n } -> f ~key ~data (f ~key:lkey ~data:ldata init)\n | Node\n { left = Empty\n ; key\n ; value = data\n ; height = _\n ; right = Leaf { key = rkey; value = rdata }\n } -> f ~key:rkey ~data:rdata (f ~key ~data init)\n | Node\n { left; key; value = data; height = _; right = Leaf { key = rkey; value = rdata } }\n -> f ~key:rkey ~data:rdata (f ~key ~data (fold left ~init ~f))\n | Node\n { left = Leaf { key = lkey; value = ldata }; key; value = data; height = _; right }\n -> fold right ~init:(f ~key ~data (f ~key:lkey ~data:ldata init)) ~f\n | Node { left; key; value = data; height = _; right } ->\n fold right ~init:(f ~key ~data (fold left ~init ~f)) ~f\n;;\n\nlet rec iter t ~f =\n match t with\n | Empty -> ()\n | Leaf { key; value = data } -> f ~key ~data\n | Node { left; key; value = data; height = _; right } ->\n iter left ~f;\n f ~key ~data;\n iter right ~f\n;;\n\nlet rec mapi_inplace t ~f =\n match t with\n | Empty -> ()\n | Leaf ({ key; value } as t) -> t.value <- f ~key ~data:value\n | Node ({ left; key; value; height = _; right } as t) ->\n mapi_inplace ~f left;\n t.value <- f ~key ~data:value;\n mapi_inplace ~f right\n;;\n\nlet choose_exn = function\n | Empty -> raise_s (Sexp.message \"[Avltree.choose_exn] of empty hashtbl\" [])\n | Leaf { key; value; _ } | Node { key; value; _ } -> key, value\n;;\n","open! Import\nmodule Key = Hashtbl_intf.Key\n\nmodule type Accessors = sig\n include Container.Generic\n\n (** override [Container.Generic.mem] *)\n val mem : 'a t -> 'a -> bool\n\n (** preserves the equality function *)\n val copy : 'a t -> 'a t\n\n val add : 'a t -> 'a -> unit\n\n (** [strict_add t x] returns [Ok ()] if the [x] was not in [t], or an [Error] if it\n was. *)\n val strict_add : 'a t -> 'a -> unit Or_error.t\n\n val strict_add_exn : 'a t -> 'a -> unit\n val remove : 'a t -> 'a -> unit\n\n (** [strict_remove t x] returns [Ok ()] if the [x] was in [t], or an [Error] if it\n was not. *)\n val strict_remove : 'a t -> 'a -> unit Or_error.t\n\n val strict_remove_exn : 'a t -> 'a -> unit\n val clear : 'a t -> unit\n val equal : 'a t -> 'a t -> bool\n val filter : 'a t -> f:('a -> bool) -> 'a t\n val filter_inplace : 'a t -> f:('a -> bool) -> unit\n\n (** [inter t1 t2] computes the set intersection of [t1] and [t2]. Runs in O(min(length\n t1, length t2)). Behavior is undefined if [t1] and [t2] don't have the same\n equality function. *)\n val inter : 'key t -> 'key t -> 'key t\n\n val union : 'a t -> 'a t -> 'a t\n val diff : 'a t -> 'a t -> 'a t\n val of_hashtbl_keys : ('a, _) Hashtbl.t -> 'a t\n val to_hashtbl : 'key t -> f:('key -> 'data) -> ('key, 'data) Hashtbl.t\nend\n\ntype ('key, 'z) create_options = ('key, unit, 'z) Hashtbl_intf.create_options\n\ntype ('key, 'z) create_options_without_first_class_module =\n ('key, unit, 'z) Hashtbl_intf.create_options_without_first_class_module\n\nmodule type Creators = sig\n type 'a t\n\n val create\n : ?growth_allowed:bool (** defaults to [true] *)\n -> ?size:int (** initial size -- default 0 *)\n -> 'a Key.t\n -> 'a t\n\n val of_list\n : ?growth_allowed:bool (** defaults to [true] *)\n -> ?size:int (** initial size -- default 0 *)\n -> 'a Key.t\n -> 'a list\n -> 'a t\nend\n\nmodule type Creators_generic = sig\n type 'a t\n type 'a elt\n type ('a, 'z) create_options\n\n val create : ('a, unit -> 'a t) create_options\n val of_list : ('a, 'a elt list -> 'a t) create_options\nend\n\nmodule Check = struct\n module Make_creators_check\n (Type : T.T1)\n (Elt : T.T1)\n (Options : T.T2)\n (M : Creators_generic\n with type 'a t := 'a Type.t\n with type 'a elt := 'a Elt.t\n with type ('a, 'z) create_options := ('a, 'z) Options.t) =\n struct end\n\n module Check_creators_is_specialization_of_creators_generic (M : Creators) =\n Make_creators_check\n (struct\n type 'a t = 'a M.t\n end)\n (struct\n type 'a t = 'a\n end)\n (struct\n type ('a, 'z) t = ('a, 'z) create_options\n end)\n (struct\n include M\n\n let create ?growth_allowed ?size m () = create ?growth_allowed ?size m\n end)\nend\n\nmodule type Hash_set = sig\n type 'a t [@@deriving_inline sexp_of]\n\n val sexp_of_t : ('a -> Ppx_sexp_conv_lib.Sexp.t) -> 'a t -> Ppx_sexp_conv_lib.Sexp.t\n\n [@@@end]\n\n (** We use [[@@deriving sexp_of]] but not [[@@deriving sexp]] because we want people to be\n explicit about the hash and comparison functions used when creating hashtables. One\n can use [Hash_set.Poly.t], which does have [[@@deriving sexp]], to use polymorphic\n comparison and hashing. *)\n\n module Key = Key\n\n module type Creators = Creators\n module type Creators_generic = Creators_generic\n\n type nonrec ('key, 'z) create_options = ('key, 'z) create_options\n\n include Creators with type 'a t := 'a t (** @open *)\n\n module type Accessors = Accessors\n\n include Accessors with type 'a t := 'a t with type 'a elt = 'a (** @open *)\n\n val hashable_s : 'key t -> 'key Key.t\n\n type nonrec ('key, 'z) create_options_without_first_class_module =\n ('key, 'z) create_options_without_first_class_module\n\n (** A hash set that uses polymorphic comparison *)\n module Poly : sig\n type nonrec 'a t = 'a t [@@deriving_inline sexp]\n\n include Ppx_sexp_conv_lib.Sexpable.S1 with type 'a t := 'a t\n\n [@@@end]\n\n include\n Creators_generic\n with type 'a t := 'a t\n with type 'a elt = 'a\n with type ('key, 'z) create_options :=\n ('key, 'z) create_options_without_first_class_module\n\n include Accessors with type 'a t := 'a t with type 'a elt := 'a elt\n end\n\n (** [M] is meant to be used in combination with OCaml applicative functor types:\n\n {[\n type string_hash_set = Hash_set.M(String).t\n ]}\n\n which stands for:\n\n {[\n type string_hash_set = (String.t, int) Hash_set.t\n ]}\n\n The point is that [Hash_set.M(String).t] supports deriving, whereas the second\n syntax doesn't (because [t_of_sexp] doesn't know what comparison/hash function to\n use). *)\n module M (Elt : T.T) : sig\n type nonrec t = Elt.t t\n end\n\n module type Sexp_of_m = sig\n type t [@@deriving_inline sexp_of]\n\n val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t\n\n [@@@end]\n end\n\n module type M_of_sexp = sig\n type t [@@deriving_inline of_sexp]\n\n val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t\n\n [@@@end]\n\n include Hashtbl_intf.Key.S with type t := t\n end\n\n val sexp_of_m__t : (module Sexp_of_m with type t = 'elt) -> 'elt t -> Sexp.t\n val m__t_of_sexp : (module M_of_sexp with type t = 'elt) -> Sexp.t -> 'elt t\n\n module Creators (Elt : sig\n type 'a t\n\n val hashable : 'a t Hashable.t\n end) : sig\n type 'a t_ = 'a Elt.t t\n\n val t_of_sexp : (Sexp.t -> 'a Elt.t) -> Sexp.t -> 'a t_\n\n include\n Creators_generic\n with type 'a t := 'a t_\n with type 'a elt := 'a Elt.t\n with type ('elt, 'z) create_options :=\n ('elt, 'z) create_options_without_first_class_module\n end\n\n (**/**)\n\n (*_ See the Jane Street Style Guide for an explanation of [Private] submodules:\n\n https://opensource.janestreet.com/standards/#private-submodules *)\n module Private : sig\n val hashable : 'a t -> 'a Hashable.t\n end\nend\n","open! Import\ninclude Hash_set_intf\n\nlet hashable_s = Hashtbl.hashable_s\nlet hashable = Hashtbl.Private.hashable\nlet poly_hashable = Hashtbl.Poly.hashable\nlet with_return = With_return.with_return\n\ntype 'a t = ('a, unit) Hashtbl.t\ntype 'a hash_set = 'a t\ntype 'a elt = 'a\n\nmodule Accessors = struct\n let hashable = hashable\n let clear = Hashtbl.clear\n let length = Hashtbl.length\n let mem = Hashtbl.mem\n let is_empty t = Hashtbl.is_empty t\n\n let find_map t ~f =\n with_return (fun r ->\n Hashtbl.iter_keys t ~f:(fun elt ->\n match f elt with\n | None -> ()\n | Some _ as o -> r.return o);\n None)\n ;;\n\n let find t ~f = find_map t ~f:(fun a -> if f a then Some a else None)\n let add t k = Hashtbl.set t ~key:k ~data:()\n\n let strict_add t k =\n if mem t k\n then Or_error.error_string \"element already exists\"\n else (\n Hashtbl.set t ~key:k ~data:();\n Result.Ok ())\n ;;\n\n let strict_add_exn t k = Or_error.ok_exn (strict_add t k)\n let remove = Hashtbl.remove\n\n let strict_remove t k =\n if mem t k\n then (\n remove t k;\n Result.Ok ())\n else Or_error.error \"element not in set\" k (Hashtbl.sexp_of_key t)\n ;;\n\n let strict_remove_exn t k = Or_error.ok_exn (strict_remove t k)\n let fold t ~init ~f = Hashtbl.fold t ~init ~f:(fun ~key ~data:() acc -> f acc key)\n let iter t ~f = Hashtbl.iter_keys t ~f\n let count t ~f = Container.count ~fold t ~f\n let sum m t ~f = Container.sum ~fold m t ~f\n let min_elt t ~compare = Container.min_elt ~fold t ~compare\n let max_elt t ~compare = Container.max_elt ~fold t ~compare\n let fold_result t ~init ~f = Container.fold_result ~fold ~init ~f t\n let fold_until t ~init ~f = Container.fold_until ~fold ~init ~f t\n let to_list = Hashtbl.keys\n\n let sexp_of_t sexp_of_e t =\n sexp_of_list sexp_of_e (to_list t |> List.sort ~compare:(hashable t).compare)\n ;;\n\n let to_array t =\n let len = length t in\n let index = ref (len - 1) in\n fold t ~init:[||] ~f:(fun acc key ->\n if Array.length acc = 0\n then Array.create ~len key\n else (\n index := !index - 1;\n acc.(!index) <- key;\n acc))\n ;;\n\n let exists t ~f = Hashtbl.existsi t ~f:(fun ~key ~data:() -> f key)\n let for_all t ~f = not (Hashtbl.existsi t ~f:(fun ~key ~data:() -> not (f key)))\n let equal t1 t2 = Hashtbl.equal (fun () () -> true) t1 t2\n let copy t = Hashtbl.copy t\n let filter t ~f = Hashtbl.filteri t ~f:(fun ~key ~data:() -> f key)\n let union t1 t2 = Hashtbl.merge t1 t2 ~f:(fun ~key:_ _ -> Some ())\n let diff t1 t2 = filter t1 ~f:(fun key -> not (Hashtbl.mem t2 key))\n\n let inter t1 t2 =\n let smaller, larger = if length t1 > length t2 then t2, t1 else t1, t2 in\n Hashtbl.filteri smaller ~f:(fun ~key ~data:() -> Hashtbl.mem larger key)\n ;;\n\n let filter_inplace t ~f =\n let to_remove = fold t ~init:[] ~f:(fun ac x -> if f x then ac else x :: ac) in\n List.iter to_remove ~f:(fun x -> remove t x)\n ;;\n\n let of_hashtbl_keys hashtbl = Hashtbl.map hashtbl ~f:ignore\n let to_hashtbl t ~f = Hashtbl.mapi t ~f:(fun ~key ~data:() -> f key)\nend\n\ninclude Accessors\n\nlet create ?growth_allowed ?size m = Hashtbl.create ?growth_allowed ?size m\n\nlet of_list ?growth_allowed ?size m l =\n let size =\n match size with\n | Some x -> x\n | None -> List.length l\n in\n let t = Hashtbl.create ?growth_allowed ~size m in\n List.iter l ~f:(fun k -> add t k);\n t\n;;\n\nlet t_of_sexp m e_of_sexp sexp =\n match sexp with\n | Sexp.Atom _ -> of_sexp_error \"Hash_set.t_of_sexp requires a list\" sexp\n | Sexp.List list ->\n let t = create m ~size:(List.length list) in\n List.iter list ~f:(fun sexp ->\n let e = e_of_sexp sexp in\n match strict_add t e with\n | Ok () -> ()\n | Error _ -> of_sexp_error \"Hash_set.t_of_sexp got a duplicate element\" sexp);\n t\n;;\n\nmodule Creators (Elt : sig\n type 'a t\n\n val hashable : 'a t Hashable.t\n end) : sig\n type 'a t_ = 'a Elt.t t\n\n val t_of_sexp : (Sexp.t -> 'a Elt.t) -> Sexp.t -> 'a t_\n\n include\n Creators_generic\n with type 'a t := 'a t_\n with type 'a elt := 'a Elt.t\n with type ('elt, 'z) create_options :=\n ('elt, 'z) create_options_without_first_class_module\nend = struct\n type 'a t_ = 'a Elt.t t\n\n let create ?growth_allowed ?size () =\n create ?growth_allowed ?size (Hashable.to_key Elt.hashable)\n ;;\n\n let of_list ?growth_allowed ?size l =\n of_list ?growth_allowed ?size (Hashable.to_key Elt.hashable) l\n ;;\n\n let t_of_sexp e_of_sexp sexp = t_of_sexp (Hashable.to_key Elt.hashable) e_of_sexp sexp\nend\n\nmodule Poly = struct\n type 'a t = 'a hash_set\n type 'a elt = 'a\n\n let hashable = poly_hashable\n\n include Creators (struct\n type 'a t = 'a\n\n let hashable = hashable\n end)\n\n include Accessors\n\n let sexp_of_t = sexp_of_t\nend\n\nmodule M (Elt : T.T) = struct\n type nonrec t = Elt.t t\nend\n\nmodule type Sexp_of_m = sig\n type t [@@deriving_inline sexp_of]\n\n val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t\n\n [@@@end]\nend\n\nmodule type M_of_sexp = sig\n type t [@@deriving_inline of_sexp]\n\n val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t\n\n [@@@end]\n\n include Hashtbl_intf.Key.S with type t := t\nend\n\nlet sexp_of_m__t (type elt) (module Elt : Sexp_of_m with type t = elt) t =\n sexp_of_t Elt.sexp_of_t t\n;;\n\nlet m__t_of_sexp (type elt) (module Elt : M_of_sexp with type t = elt) sexp =\n t_of_sexp (module Elt) Elt.t_of_sexp sexp\n;;\n\nmodule Private = struct\n let hashable = Hashtbl.Private.hashable\nend\n","open! Import\nopen! Printf\nmodule Bytes = Bytes0\ninclude Float0\n\nlet raise_s = Error.raise_s\n\nmodule T = struct\n type t = float [@@deriving_inline hash, sexp, sexp_grammar]\n\n let (hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state) =\n hash_fold_float\n\n and (hash : t -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func = hash_float in\n fun x -> func x\n ;;\n\n let t_of_sexp = (float_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t)\n let sexp_of_t = (sexp_of_float : t -> Ppx_sexp_conv_lib.Sexp.t)\n\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group) =\n { implicit_vars = [ \"float\" ]\n ; ggid = \"\\146e\\023\\249\\235eE\\139c\\132W\\195\\137\\129\\235\\025\"\n ; types = [ \"t\", Implicit_var 0 ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ float_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"float.ml.T\"\n }\n in\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"t\", _the_group)\n in\n t_sexp_grammar\n ;;\n\n [@@@end]\n\n let compare = Float_replace_polymorphic_compare.compare\nend\n\ninclude T\ninclude Comparator.Make (T)\n\n(* Open replace_polymorphic_compare after including functor instantiations so they do not\n shadow its definitions. This is here so that efficient versions of the comparison\n functions are available within this module. *)\nopen Float_replace_polymorphic_compare\n\nlet invariant (_ : t) = ()\nlet to_float x = x\nlet of_float x = x\n\nlet of_string s =\n try float_of_string s with\n | _ -> invalid_argf \"Float.of_string %s\" s ()\n;;\n\nexternal format_float : string -> float -> string = \"caml_format_float\"\n\n(* Stolen from [pervasives.ml]. Adds a \".\" at the end if needed. It is in\n [pervasives.mli], but it also says not to use it directly, so we copy and paste the\n code. It makes the assumption on the string passed in argument that it was returned by\n [format_float]. *)\nlet valid_float_lexem s =\n let l = String.length s in\n let rec loop i =\n if Int_replace_polymorphic_compare.( >= ) i l\n then s ^ \".\"\n else (\n match s.[i] with\n | '0' .. '9' | '-' -> loop (i + 1)\n | _ -> s)\n in\n loop 0\n;;\n\n(* Let [y] be a power of 2. Then the next representable float is:\n [z = y * (1 + 2 ** -52)]\n and the previous one is\n [x = y * (1 - 2 ** -53)]\n\n In general, every two adjacent floats are within a factor of between [1 + 2**-53]\n and [1 + 2**-52] from each other, that is within [1 + 1.1e-16] and [1 + 2.3e-16].\n\n So if the decimal representation of a float starts with \"1\", then its adjacent floats\n will usually differ from it by 1, and sometimes by 2, at the 17th significant digit\n (counting from 1).\n\n On the other hand, if the decimal representation starts with \"9\", then the adjacent\n floats will be off by no more than 23 at the 16th and 17th significant digits.\n\n E.g.:\n\n {v\n # sprintf \"%.17g\" (1024. *. (1. -. 2.** (-53.)));;\n 11111111\n 1234 5678901234567\n - : string = \"1023.9999999999999\"\n v}\n Printing a couple of extra digits reveals that the difference indeed is roughly 11 at\n digits 17th and 18th (that is, 13th and 14th after \".\"):\n\n {v\n # sprintf \"%.19g\" (1024. *. (1. -. 2.** (-53.)));;\n 1111111111\n 1234 567890123456789\n - : string = \"1023.999999999999886\"\n v}\n\n The ulp (the difference between adjacent floats) is twice as big on the other side of\n 1024.:\n\n {v\n # sprintf \"%.19g\" (1024. *. (1. +. 2.** (-52.)));;\n 1111111111\n 1234 567890123456789\n - : string = \"1024.000000000000227\"\n v}\n\n Now take a power of 2 which starts with 99:\n\n {v\n # 2.**93. ;;\n 1111111111\n 1 23456789012345678\n - : float = 9.9035203142830422e+27\n\n # 2.**93. *. (1. +. 2.** (-52.));;\n - : float = 9.9035203142830444e+27\n\n # 2.**93. *. (1. -. 2.** (-53.));;\n - : float = 9.9035203142830411e+27\n v}\n\n The difference between 2**93 and its two neighbors is slightly more than, respectively,\n 1 and 2 at significant digit 16.\n\n Those examples show that:\n - 17 significant digits is always sufficient to represent a float without ambiguity\n - 15th significant digit can always be represented accurately\n - converting a decimal number with 16 significant digits to its nearest float and back\n can change the last decimal digit by no more than 1\n\n To make sure that floats obtained by conversion from decimal fractions (e.g. \"3.14\")\n are printed without trailing non-zero digits, one should choose the first among the\n '%.15g', '%.16g', and '%.17g' representations which does round-trip:\n\n {v\n # sprintf \"%.15g\" 3.14;;\n - : string = \"3.14\" (* pick this one *)\n # sprintf \"%.16g\" 3.14;;\n - : string = \"3.14\"\n # sprintf \"%.17g\" 3.14;;\n - : string = \"3.1400000000000001\" (* do not pick this one *)\n\n # sprintf \"%.15g\" 8.000000000000002;;\n - : string = \"8\" (* do not pick this one--does not round-trip *)\n # sprintf \"%.16g\" 8.000000000000002;;\n - : string = \"8.000000000000002\" (* prefer this one *)\n # sprintf \"%.17g\" 8.000000000000002;;\n - : string = \"8.0000000000000018\" (* this one has one digit of junk at the end *)\n v}\n\n Skipping the '%.16g' in the above procedure saves us some time, but it means that, as\n seen in the second example above, occasionally numbers with exactly 16 significant\n digits will have an error introduced at the 17th digit. That is probably OK for\n typical use, because a number with 16 significant digits is \"ugly\" already. Adding one\n more doesn't make it much worse for a human reader.\n\n On the other hand, we cannot skip '%.15g' and only look at '%.16g' and '%.17g', since\n the inaccuracy at the 16th digit might introduce the noise we want to avoid:\n\n {v\n # sprintf \"%.15g\" 9.992;;\n - : string = \"9.992\" (* pick this one *)\n # sprintf \"%.16g\" 9.992;;\n - : string = \"9.992000000000001\" (* do not pick this one--junk at the end *)\n # sprintf \"%.17g\" 9.992;;\n - : string = \"9.9920000000000009\"\n v}\n*)\nlet to_string x =\n valid_float_lexem\n (let y = format_float \"%.15g\" x in\n if float_of_string y = x then y else format_float \"%.17g\" x)\n;;\n\nlet max_value = infinity\nlet min_value = neg_infinity\nlet min_positive_subnormal_value = 2. ** -1074.\nlet min_positive_normal_value = 2. ** -1022.\nlet zero = 0.\nlet one = 1.\nlet minus_one = -1.\nlet pi = 0x3.243F6A8885A308D313198A2E037073\nlet sqrt_pi = 0x1.C5BF891B4EF6AA79C3B0520D5DB938\nlet sqrt_2pi = 0x2.81B263FEC4E0B2CAF9483F5CE459DC\nlet euler = 0x0.93C467E37DB0C7A4D1BE3F810152CB\nlet of_int = Int.to_float\nlet to_int = Int.of_float\nlet of_int63 i = Int63.to_float i\nlet of_int64 i = Caml.Int64.to_float i\nlet to_int64 = Caml.Int64.of_float\nlet iround_lbound = lower_bound_for_int Int.num_bits\nlet iround_ubound = upper_bound_for_int Int.num_bits\n\n(* The performance of the \"exn\" rounding functions is important, so they are written\n out separately, and tuned individually. (We could have the option versions call\n the \"exn\" versions, but that imposes arguably gratuitous overhead---especially\n in the case where the capture of backtraces is enabled upon \"with\"---and that seems\n not worth it when compared to the relatively small amount of code duplication.) *)\n\n(* Error reporting below is very carefully arranged so that, e.g., [iround_nearest_exn]\n itself can be inlined into callers such that they don't need to allocate a box for the\n [float] argument. This is done with a box [box] function carefully chosen to allow the\n compiler to create a separate box for the float only in error cases. See, e.g.,\n [../../zero/test/price_test.ml] for a mechanical test of this property when building\n with [X_LIBRARY_INLINING=true]. *)\n\nlet iround_up t =\n if t > 0.0\n then (\n let t' = ceil t in\n if t' <= iround_ubound then Some (Int.of_float_unchecked t') else None)\n else if t >= iround_lbound\n then Some (Int.of_float_unchecked t)\n else None\n;;\n\nlet[@ocaml.inline always] iround_up_exn t =\n if t > 0.0\n then (\n let t' = ceil t in\n if t' <= iround_ubound\n then Int.of_float_unchecked t'\n else invalid_argf \"Float.iround_up_exn: argument (%f) is too large\" (box t) ())\n else if t >= iround_lbound\n then Int.of_float_unchecked t\n else invalid_argf \"Float.iround_up_exn: argument (%f) is too small or NaN\" (box t) ()\n;;\n\nlet iround_down t =\n if t >= 0.0\n then if t <= iround_ubound then Some (Int.of_float_unchecked t) else None\n else (\n let t' = floor t in\n if t' >= iround_lbound then Some (Int.of_float_unchecked t') else None)\n;;\n\nlet[@ocaml.inline always] iround_down_exn t =\n if t >= 0.0\n then\n if t <= iround_ubound\n then Int.of_float_unchecked t\n else invalid_argf \"Float.iround_down_exn: argument (%f) is too large\" (box t) ()\n else (\n let t' = floor t in\n if t' >= iround_lbound\n then Int.of_float_unchecked t'\n else\n invalid_argf \"Float.iround_down_exn: argument (%f) is too small or NaN\" (box t) ())\n;;\n\nlet iround_towards_zero t =\n if t >= iround_lbound && t <= iround_ubound\n then Some (Int.of_float_unchecked t)\n else None\n;;\n\nlet[@ocaml.inline always] iround_towards_zero_exn t =\n if t >= iround_lbound && t <= iround_ubound\n then Int.of_float_unchecked t\n else\n invalid_argf\n \"Float.iround_towards_zero_exn: argument (%f) is out of range or NaN\"\n (box t)\n ()\n;;\n\n(* Outside of the range (round_nearest_lb..round_nearest_ub), all representable doubles\n are integers in the mathematical sense, and [round_nearest] should be identity.\n\n However, for odd numbers with the absolute value between 2**52 and 2**53, the formula\n [round_nearest x = floor (x + 0.5)] does not hold:\n\n {v\n # let naive_round_nearest x = floor (x +. 0.5);;\n # let x = 2. ** 52. +. 1.;;\n val x : float = 4503599627370497.\n # naive_round_nearest x;;\n - : float = 4503599627370498.\n v}\n*)\n\nlet round_nearest_lb = -.(2. ** 52.)\nlet round_nearest_ub = 2. ** 52.\n\n(* For [x = one_ulp `Down 0.5], the formula [floor (x +. 0.5)] for rounding to nearest\n does not work, because the exact result is halfway between [one_ulp `Down 1.] and [1.],\n and it gets rounded up to [1.] due to the round-ties-to-even rule. *)\nlet one_ulp_less_than_half = one_ulp `Down 0.5\n\nlet add_half_for_round_nearest t =\n t\n +.\n if t = one_ulp_less_than_half\n then one_ulp_less_than_half (* since t < 0.5, make sure the result is < 1.0 *)\n else 0.5\n;;\n\nlet iround_nearest_32 t =\n if t >= 0.\n then (\n let t' = add_half_for_round_nearest t in\n if t' <= iround_ubound then Some (Int.of_float_unchecked t') else None)\n else (\n let t' = floor (t +. 0.5) in\n if t' >= iround_lbound then Some (Int.of_float_unchecked t') else None)\n;;\n\nlet iround_nearest_64 t =\n if t >= 0.\n then\n if t < round_nearest_ub\n then Some (Int.of_float_unchecked (add_half_for_round_nearest t))\n else if t <= iround_ubound\n then Some (Int.of_float_unchecked t)\n else None\n else if t > round_nearest_lb\n then Some (Int.of_float_unchecked (floor (t +. 0.5)))\n else if t >= iround_lbound\n then Some (Int.of_float_unchecked t)\n else None\n;;\n\nlet iround_nearest =\n match Word_size.word_size with\n | W64 -> iround_nearest_64\n | W32 -> iround_nearest_32\n;;\n\nlet iround_nearest_exn_32 t =\n if t >= 0.\n then (\n let t' = add_half_for_round_nearest t in\n if t' <= iround_ubound\n then Int.of_float_unchecked t'\n else invalid_argf \"Float.iround_nearest_exn: argument (%f) is too large\" (box t) ())\n else (\n let t' = floor (t +. 0.5) in\n if t' >= iround_lbound\n then Int.of_float_unchecked t'\n else invalid_argf \"Float.iround_nearest_exn: argument (%f) is too small\" (box t) ())\n;;\n\nlet[@ocaml.inline always] iround_nearest_exn_64 t =\n if t >= 0.\n then\n if t < round_nearest_ub\n then Int.of_float_unchecked (add_half_for_round_nearest t)\n else if t <= iround_ubound\n then Int.of_float_unchecked t\n else invalid_argf \"Float.iround_nearest_exn: argument (%f) is too large\" (box t) ()\n else if t > round_nearest_lb\n then Int.of_float_unchecked (floor (t +. 0.5))\n else if t >= iround_lbound\n then Int.of_float_unchecked t\n else\n invalid_argf \"Float.iround_nearest_exn: argument (%f) is too small or NaN\" (box t) ()\n;;\n\nlet iround_nearest_exn =\n match Word_size.word_size with\n | W64 -> iround_nearest_exn_64\n | W32 -> iround_nearest_exn_32\n;;\n\n(* The following [iround_exn] and [iround] functions are slower than the ones above.\n Their equivalence to those functions is tested in the unit tests below. *)\n\nlet[@inline] iround_exn ?(dir = `Nearest) t =\n match dir with\n | `Zero -> iround_towards_zero_exn t\n | `Nearest -> iround_nearest_exn t\n | `Up -> iround_up_exn t\n | `Down -> iround_down_exn t\n;;\n\nlet iround ?(dir = `Nearest) t =\n try Some (iround_exn ~dir t) with\n | _ -> None\n;;\n\nlet is_inf x =\n match classify_float x with\n | FP_infinite -> true\n | _ -> false\n;;\n\nlet min_inan (x : t) y =\n if is_nan y then x else if is_nan x then y else if x < y then x else y\n;;\n\nlet max_inan (x : t) y =\n if is_nan y then x else if is_nan x then y else if x > y then x else y\n;;\n\nlet add = ( +. )\nlet sub = ( -. )\nlet neg = ( ~-. )\nlet abs = abs_float\nlet scale = ( *. )\nlet square x = x *. x\n\nmodule Parts : sig\n type t\n\n val fractional : t -> float\n val integral : t -> float\n val modf : float -> t\nend = struct\n type t = float * float\n\n let fractional t = fst t\n let integral t = snd t\n let modf = modf\nend\n\nlet modf = Parts.modf\nlet round_down = floor\nlet round_up = ceil\nlet round_towards_zero t = if t >= 0. then round_down t else round_up t\n\n(* see the comment above [round_nearest_lb] and [round_nearest_ub] for an explanation *)\nlet round_nearest t =\n if t > round_nearest_lb && t < round_nearest_ub\n then floor (add_half_for_round_nearest t)\n else t +. 0.\n;;\n\nlet round_nearest_half_to_even t =\n if t <= round_nearest_lb || t >= round_nearest_ub\n then t +. 0.\n else (\n let floor = floor t in\n (* [ceil_or_succ = if t is an integer then t +. 1. else ceil t]. Faster than [ceil]. *)\n let ceil_or_succ = floor +. 1. in\n let diff_floor = t -. floor in\n let diff_ceil = ceil_or_succ -. t in\n if diff_floor < diff_ceil\n then floor\n else if diff_floor > diff_ceil\n then ceil_or_succ\n else if (* exact tie, pick the even *)\n mod_float floor 2. = 0.\n then floor\n else ceil_or_succ)\n;;\n\nlet int63_round_lbound = lower_bound_for_int Int63.num_bits\nlet int63_round_ubound = upper_bound_for_int Int63.num_bits\n\nlet int63_round_up_exn t =\n if t > 0.0\n then (\n let t' = ceil t in\n if t' <= int63_round_ubound\n then Int63.of_float_unchecked t'\n else\n invalid_argf\n \"Float.int63_round_up_exn: argument (%f) is too large\"\n (Float0.box t)\n ())\n else if t >= int63_round_lbound\n then Int63.of_float_unchecked t\n else\n invalid_argf\n \"Float.int63_round_up_exn: argument (%f) is too small or NaN\"\n (Float0.box t)\n ()\n;;\n\nlet int63_round_down_exn t =\n if t >= 0.0\n then\n if t <= int63_round_ubound\n then Int63.of_float_unchecked t\n else\n invalid_argf\n \"Float.int63_round_down_exn: argument (%f) is too large\"\n (Float0.box t)\n ()\n else (\n let t' = floor t in\n if t' >= int63_round_lbound\n then Int63.of_float_unchecked t'\n else\n invalid_argf\n \"Float.int63_round_down_exn: argument (%f) is too small or NaN\"\n (Float0.box t)\n ())\n;;\n\nlet int63_round_nearest_portable_alloc_exn t0 =\n let t = round_nearest t0 in\n if t > 0.\n then\n if t <= int63_round_ubound\n then Int63.of_float_unchecked t\n else\n invalid_argf\n \"Float.int63_round_nearest_portable_alloc_exn: argument (%f) is too large\"\n (box t0)\n ()\n else if t >= int63_round_lbound\n then Int63.of_float_unchecked t\n else\n invalid_argf\n \"Float.int63_round_nearest_portable_alloc_exn: argument (%f) is too small or NaN\"\n (box t0)\n ()\n;;\n\nlet int63_round_nearest_arch64_noalloc_exn f = Int63.of_int (iround_nearest_exn f)\n\nlet int63_round_nearest_exn =\n match Word_size.word_size with\n | W64 -> int63_round_nearest_arch64_noalloc_exn\n | W32 -> int63_round_nearest_portable_alloc_exn\n;;\n\nlet round ?(dir = `Nearest) t =\n match dir with\n | `Nearest -> round_nearest t\n | `Down -> round_down t\n | `Up -> round_up t\n | `Zero -> round_towards_zero t\n;;\n\nmodule Class = struct\n type t =\n | Infinite\n | Nan\n | Normal\n | Subnormal\n | Zero\n [@@deriving_inline compare, enumerate, sexp]\n\n let compare = (Ppx_compare_lib.polymorphic_compare : t -> t -> int)\n let all = ([ Infinite; Nan; Normal; Subnormal; Zero ] : t list)\n\n let t_of_sexp =\n (let _tp_loc = \"float.ml.Class.t\" in\n function\n | Ppx_sexp_conv_lib.Sexp.Atom (\"infinite\" | \"Infinite\") -> Infinite\n | Ppx_sexp_conv_lib.Sexp.Atom (\"nan\" | \"Nan\") -> Nan\n | Ppx_sexp_conv_lib.Sexp.Atom (\"normal\" | \"Normal\") -> Normal\n | Ppx_sexp_conv_lib.Sexp.Atom (\"subnormal\" | \"Subnormal\") -> Subnormal\n | Ppx_sexp_conv_lib.Sexp.Atom (\"zero\" | \"Zero\") -> Zero\n | Ppx_sexp_conv_lib.Sexp.List\n (Ppx_sexp_conv_lib.Sexp.Atom (\"infinite\" | \"Infinite\") :: _) as sexp ->\n Ppx_sexp_conv_lib.Conv_error.stag_no_args _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.List (Ppx_sexp_conv_lib.Sexp.Atom (\"nan\" | \"Nan\") :: _) as\n sexp -> Ppx_sexp_conv_lib.Conv_error.stag_no_args _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.List\n (Ppx_sexp_conv_lib.Sexp.Atom (\"normal\" | \"Normal\") :: _) as sexp ->\n Ppx_sexp_conv_lib.Conv_error.stag_no_args _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.List\n (Ppx_sexp_conv_lib.Sexp.Atom (\"subnormal\" | \"Subnormal\") :: _) as sexp ->\n Ppx_sexp_conv_lib.Conv_error.stag_no_args _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.List (Ppx_sexp_conv_lib.Sexp.Atom (\"zero\" | \"Zero\") :: _)\n as sexp -> Ppx_sexp_conv_lib.Conv_error.stag_no_args _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.List (Ppx_sexp_conv_lib.Sexp.List _ :: _) as sexp ->\n Ppx_sexp_conv_lib.Conv_error.nested_list_invalid_sum _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.List [] as sexp ->\n Ppx_sexp_conv_lib.Conv_error.empty_list_invalid_sum _tp_loc sexp\n | sexp -> Ppx_sexp_conv_lib.Conv_error.unexpected_stag _tp_loc sexp\n : Ppx_sexp_conv_lib.Sexp.t -> t)\n ;;\n\n let sexp_of_t =\n (function\n | Infinite -> Ppx_sexp_conv_lib.Sexp.Atom \"Infinite\"\n | Nan -> Ppx_sexp_conv_lib.Sexp.Atom \"Nan\"\n | Normal -> Ppx_sexp_conv_lib.Sexp.Atom \"Normal\"\n | Subnormal -> Ppx_sexp_conv_lib.Sexp.Atom \"Subnormal\"\n | Zero -> Ppx_sexp_conv_lib.Sexp.Atom \"Zero\"\n : t -> Ppx_sexp_conv_lib.Sexp.t)\n ;;\n\n [@@@end]\n\n let to_string t = string_of_sexp (sexp_of_t t)\n let of_string s = t_of_sexp (sexp_of_string s)\nend\n\nlet classify t =\n let module C = Class in\n match classify_float t with\n | FP_normal -> C.Normal\n | FP_subnormal -> C.Subnormal\n | FP_zero -> C.Zero\n | FP_infinite -> C.Infinite\n | FP_nan -> C.Nan\n;;\n\nlet is_finite t = not (t = infinity || t = neg_infinity || is_nan t)\n\nlet insert_underscores ?(delimiter = '_') ?(strip_zero = false) string =\n match String.lsplit2 string ~on:'.' with\n | None -> Int_conversions.insert_delimiter string ~delimiter\n | Some (left, right) ->\n let left = Int_conversions.insert_delimiter left ~delimiter in\n let right =\n if strip_zero then String.rstrip right ~drop:(fun c -> Char.( = ) c '0') else right\n in\n (match right with\n | \"\" -> left\n | _ -> left ^ \".\" ^ right)\n;;\n\nlet to_string_hum ?delimiter ?(decimals = 3) ?strip_zero f =\n if Int_replace_polymorphic_compare.( < ) decimals 0\n then invalid_argf \"to_string_hum: invalid argument ~decimals=%d\" decimals ();\n match classify f with\n | Class.Infinite -> if f > 0. then \"inf\" else \"-inf\"\n | Class.Nan -> \"nan\"\n | Class.Normal | Class.Subnormal | Class.Zero ->\n insert_underscores (sprintf \"%.*f\" decimals f) ?delimiter ?strip_zero\n;;\n\nlet sexp_of_t t =\n let sexp = sexp_of_t t in\n match !Sexp.of_float_style with\n | `No_underscores -> sexp\n | `Underscores ->\n (match sexp with\n | List _ ->\n raise_s\n (Sexp.message\n \"[sexp_of_float] produced strange sexp\"\n [ \"sexp\", Sexp.sexp_of_t sexp ])\n | Atom string ->\n if String.contains string 'E' then sexp else Atom (insert_underscores string))\n;;\n\nlet to_padded_compact_string_custom t ?(prefix = \"\") ~kilo ~mega ~giga ~tera ?peta () =\n (* Round a ratio toward the nearest integer, resolving ties toward the nearest even\n number. For sane inputs (in particular, when [denominator] is an integer and\n [abs numerator < 2e52]) this should be accurate. Otherwise, the result might be a\n little bit off, but we don't really use that case. *)\n let iround_ratio_exn ~numerator ~denominator =\n let k = floor (numerator /. denominator) in\n (* if [abs k < 2e53], then both [k] and [k +. 1.] are accurately represented, and in\n particular [k +. 1. > k]. If [denominator] is also an integer, and\n [abs (denominator *. (k +. 1)) < 2e53] (and in some other cases, too), then [lower]\n and [higher] are actually both accurate. Since (roughly)\n [numerator = denominator *. k] then for [abs numerator < 2e52] we should be\n fine. *)\n let lower = denominator *. k in\n let higher = denominator *. (k +. 1.) in\n (* Subtracting numbers within a factor of two from each other is accurate.\n So either the two subtractions below are accurate, or k = 0, or k = -1.\n In case of a tie, round to even. *)\n let diff_right = higher -. numerator in\n let diff_left = numerator -. lower in\n let k = iround_nearest_exn k in\n if diff_right < diff_left\n then k + 1\n else if diff_right > diff_left\n then k\n else if (* a tie *)\n Int_replace_polymorphic_compare.( = ) (k mod 2) 0\n then k\n else k + 1\n in\n match classify t with\n | Class.Infinite -> if t < 0.0 then \"-inf \" else \"inf \"\n | Class.Nan -> \"nan \"\n | Class.Subnormal | Class.Normal | Class.Zero ->\n let go t =\n let conv_one t =\n assert (0. <= t && t < 999.95);\n let x = prefix ^ format_float \"%.1f\" t in\n (* Fix the \".0\" suffix *)\n if String.is_suffix x ~suffix:\".0\"\n then (\n let x = Bytes.of_string x in\n let n = Bytes.length x in\n Bytes.set x (n - 1) ' ';\n Bytes.set x (n - 2) ' ';\n Bytes.unsafe_to_string ~no_mutation_while_string_reachable:x)\n else x\n in\n let conv mag t denominator =\n assert (\n (denominator = 100. && t >= 999.95)\n || (denominator >= 100_000. && t >= round_nearest (denominator *. 9.999_5)));\n assert (t < round_nearest (denominator *. 9_999.5));\n let i, d =\n let k = iround_ratio_exn ~numerator:t ~denominator in\n (* [mod] is okay here because we know i >= 0. *)\n k / 10, k mod 10\n in\n let open Int_replace_polymorphic_compare in\n assert (0 <= i && i < 1000);\n assert (0 <= d && d < 10);\n if d = 0\n then sprintf \"%s%d%s \" prefix i mag\n else sprintf \"%s%d%s%d\" prefix i mag d\n in\n (* While the standard metric prefixes (e.g. capital \"M\" rather than \"m\", [1]) are\n nominally more correct, this hinders readability in our case. E.g., 10G6 and\n 1066 look too similar. That's an extreme example, but in general k,m,g,t,p\n probably stand out better than K,M,G,T,P when interspersed with digits.\n\n [1] http://en.wikipedia.org/wiki/Metric_prefix *)\n (* The trick here is that:\n - the first boundary (999.95) as a float is slightly over-represented (so it is\n better approximated as \"1k\" than as \"999.9\"),\n - the other boundaries are accurately represented, because they are integers.\n That's why the strict equalities below do exactly what we want. *)\n if t < 999.95E0\n then conv_one t\n else if t < 999.95E3\n then conv kilo t 100.\n else if t < 999.95E6\n then conv mega t 100_000.\n else if t < 999.95E9\n then conv giga t 100_000_000.\n else if t < 999.95E12\n then conv tera t 100_000_000_000.\n else (\n match peta with\n | None -> sprintf \"%s%.1e\" prefix t\n | Some peta ->\n if t < 999.95E15\n then conv peta t 100_000_000_000_000.\n else sprintf \"%s%.1e\" prefix t)\n in\n if t >= 0. then go t else \"-\" ^ go ~-.t\n;;\n\nlet to_padded_compact_string t =\n to_padded_compact_string_custom t ~kilo:\"k\" ~mega:\"m\" ~giga:\"g\" ~tera:\"t\" ~peta:\"p\" ()\n;;\n\n(* Performance note: Initializing the accumulator to 1 results in one extra\n multiply; e.g., to compute x ** 4, we in principle only need 2 multiplies,\n but this function will have 3 multiplies. However, attempts to avoid this\n (like decrementing n and initializing accum to be x, or handling small\n exponents as a special case) have not yielded anything that is a net\n improvement.\n*)\nlet int_pow x n =\n let open Int_replace_polymorphic_compare in\n if n = 0\n then 1.\n else (\n (* Using [x +. (-0.)] on the following line convinces the compiler to avoid a certain\n boxing (that would result in allocation in each iteration). Soon, the compiler\n shouldn't need this \"hint\" to avoid the boxing. The reason we add -0 rather than 0\n is that [x +. (-0.)] is apparently always the same as [x], whereas [x +. 0.] is\n not, in that it sends [-0.] to [0.]. This makes a difference because we want\n [int_pow (-0.) (-1)] to return neg_infinity just like [-0. ** -1.] would. *)\n let x = ref (x +. -0.) in\n let n = ref n in\n let accum = ref 1. in\n if !n < 0\n then (\n (* x ** n = (1/x) ** -n *)\n x := 1. /. !x;\n n := ~- (!n);\n if !n < 0\n then (\n (* n must have been min_int, so it is now so big that it has wrapped around.\n We decrement it so that it looks positive again, but accordingly have\n to put an extra factor of x in the accumulator.\n *)\n accum := !x;\n decr n));\n (* Letting [a] denote (the original value of) [x ** n], we maintain\n the invariant that [(x ** n) *. accum = a]. *)\n while !n > 1 do\n if !n land 1 <> 0 then accum := !x *. !accum;\n x := !x *. !x;\n n := !n lsr 1\n done;\n (* n is necessarily 1 at this point, so there is one additional\n multiplication by x. *)\n !x *. !accum)\n;;\n\nlet round_gen x ~how =\n if x = 0.\n then 0.\n else if not (is_finite x)\n then x\n else (\n (* Significant digits and decimal digits. *)\n let sd, dd =\n match how with\n | `significant_digits sd ->\n let dd = sd - to_int (round_up (log10 (abs x))) in\n sd, dd\n | `decimal_digits dd ->\n let sd = dd + to_int (round_up (log10 (abs x))) in\n sd, dd\n in\n let open Int_replace_polymorphic_compare in\n if sd < 0\n then 0.\n else if sd >= 17\n then x\n else (\n (* Choose the order that is exactly representable as a float. Small positive\n integers are, but their inverses in most cases are not. *)\n let abs_dd = Int.abs dd in\n if abs_dd > 22 || sd >= 16\n (* 10**22 is exactly representable as a float, but 10**23 is not, so use the slow\n path. Similarly, if we need 16 significant digits in the result, then the integer\n [round_nearest (x order)] might not be exactly representable as a float, since\n for some ranges we only have 15 digits of precision guaranteed.\n\n That said, we are still rounding twice here:\n\n 1) first time when rounding [x *. order] or [x /. order] to the nearest float\n (just the normal way floating-point multiplication or division works),\n\n 2) second time when applying [round_nearest_half_to_even] to the result of the\n above operation\n\n So for arguments within an ulp from a tie we might still produce an off-by-one\n result. *)\n then of_string (sprintf \"%.*g\" sd x)\n else (\n let order = int_pow 10. abs_dd in\n if dd >= 0\n then round_nearest_half_to_even (x *. order) /. order\n else round_nearest_half_to_even (x /. order) *. order)))\n;;\n\nlet round_significant x ~significant_digits =\n if Int_replace_polymorphic_compare.( <= ) significant_digits 0\n then\n invalid_argf\n \"Float.round_significant: invalid argument significant_digits:%d\"\n significant_digits\n ()\n else round_gen x ~how:(`significant_digits significant_digits)\n;;\n\nlet round_decimal x ~decimal_digits = round_gen x ~how:(`decimal_digits decimal_digits)\nlet between t ~low ~high = low <= t && t <= high\n\nlet clamp_exn t ~min ~max =\n (* Also fails if [min] or [max] is nan *)\n assert (min <= max);\n (* clamp_unchecked is in float0.ml *)\n clamp_unchecked t ~min ~max\n;;\n\nlet clamp t ~min ~max =\n (* Also fails if [min] or [max] is nan *)\n if min <= max\n then Ok (clamp_unchecked t ~min ~max)\n else\n Or_error.error_s\n (Sexp.message\n \"clamp requires [min <= max]\"\n [ \"min\", T.sexp_of_t min; \"max\", T.sexp_of_t max ])\n;;\n\nlet ( + ) = ( +. )\nlet ( - ) = ( -. )\nlet ( * ) = ( *. )\nlet ( ** ) = ( ** )\nlet ( / ) = ( /. )\nlet ( ~- ) = ( ~-. )\n\nlet sign_exn t : Sign.t =\n if t > 0.\n then Pos\n else if t < 0.\n then Neg\n else if t = 0.\n then Zero\n else Error.raise_s (Sexp.message \"Float.sign_exn of NAN\" [ \"\", sexp_of_t t ])\n;;\n\nlet sign_or_nan t : Sign_or_nan.t =\n if t > 0. then Pos else if t < 0. then Neg else if t = 0. then Zero else Nan\n;;\n\nlet ieee_negative t =\n let bits = Caml.Int64.bits_of_float t in\n Poly.(bits < Caml.Int64.zero)\n;;\n\nlet exponent_bits = 11\nlet mantissa_bits = 52\nlet exponent_mask64 = Int64.(shift_left one exponent_bits - one)\nlet exponent_mask = Int64.to_int_exn exponent_mask64\nlet mantissa_mask = Int63.(shift_left one mantissa_bits - one)\nlet mantissa_mask64 = Int63.to_int64 mantissa_mask\n\nlet ieee_exponent t =\n let bits = Caml.Int64.bits_of_float t in\n Int64.(bit_and (shift_right_logical bits mantissa_bits) exponent_mask64)\n |> Caml.Int64.to_int\n;;\n\nlet ieee_mantissa t =\n let bits = Caml.Int64.bits_of_float t in\n Int63.of_int64_exn Caml.Int64.(logand bits mantissa_mask64)\n;;\n\nlet create_ieee_exn ~negative ~exponent ~mantissa =\n if Int.(bit_and exponent exponent_mask <> exponent)\n then failwithf \"exponent %d out of range [0, %d]\" exponent exponent_mask ()\n else if Int63.(bit_and mantissa mantissa_mask <> mantissa)\n then\n failwithf\n \"mantissa %s out of range [0, %s]\"\n (Int63.to_string mantissa)\n (Int63.to_string mantissa_mask)\n ()\n else (\n let sign_bits = if negative then Caml.Int64.min_int else Caml.Int64.zero in\n let expt_bits = Caml.Int64.shift_left (Caml.Int64.of_int exponent) mantissa_bits in\n let mant_bits = Int63.to_int64 mantissa in\n let bits = Caml.Int64.(logor sign_bits (logor expt_bits mant_bits)) in\n Caml.Int64.float_of_bits bits)\n;;\n\nlet create_ieee ~negative ~exponent ~mantissa =\n Or_error.try_with (fun () -> create_ieee_exn ~negative ~exponent ~mantissa)\n;;\n\nmodule Terse = struct\n type nonrec t = t\n\n let t_of_sexp = t_of_sexp\n let to_string x = Printf.sprintf \"%.8G\" x\n let sexp_of_t x = Sexp.Atom (to_string x)\n let of_string x = of_string x\nend\n\nlet validate_ordinary t =\n Validate.of_error_opt\n (let module C = Class in\n match classify t with\n | C.Normal | C.Subnormal | C.Zero -> None\n | C.Infinite -> Some \"value is infinite\"\n | C.Nan -> Some \"value is NaN\")\n;;\n\nmodule V = struct\n module ZZ = Comparable.Validate (T)\n\n let validate_bound ~min ~max t =\n Validate.first_failure (validate_ordinary t) (ZZ.validate_bound t ~min ~max)\n ;;\n\n let validate_lbound ~min t =\n Validate.first_failure (validate_ordinary t) (ZZ.validate_lbound t ~min)\n ;;\n\n let validate_ubound ~max t =\n Validate.first_failure (validate_ordinary t) (ZZ.validate_ubound t ~max)\n ;;\nend\n\ninclude V\n\ninclude Comparable.With_zero (struct\n include T\n\n let zero = zero\n\n include V\n end)\n\n(* These are partly here as a performance hack to avoid some boxing we're getting with\n the versions we get from [With_zero]. They also make [Float.is_negative nan] and\n [Float.is_non_positive nan] return [false]; the versions we get from [With_zero] return\n [true]. *)\nlet is_positive t = t > 0.\nlet is_non_negative t = t >= 0.\nlet is_negative t = t < 0.\nlet is_non_positive t = t <= 0.\n\ninclude Pretty_printer.Register (struct\n include T\n\n let module_name = \"Base.Float\"\n let to_string = to_string\n end)\n\nmodule O = struct\n let ( + ) = ( + )\n let ( - ) = ( - )\n let ( * ) = ( * )\n let ( / ) = ( / )\n let ( ~- ) = ( ~- )\n let ( ** ) = ( ** )\n\n include (Float_replace_polymorphic_compare : Comparisons.Infix with type t := t)\n\n let abs = abs\n let neg = neg\n let zero = zero\n let of_int = of_int\n let of_float x = x\nend\n\nmodule O_dot = struct\n let ( *. ) = ( * )\n let ( +. ) = ( + )\n let ( -. ) = ( - )\n let ( /. ) = ( / )\n let ( ~-. ) = ( ~- )\n let ( **. ) = ( ** )\nend\n\nmodule Private = struct\n let box = box\n let clamp_unchecked = clamp_unchecked\n let lower_bound_for_int = lower_bound_for_int\n let upper_bound_for_int = upper_bound_for_int\n let specialized_hash = hash_float\n let one_ulp_less_than_half = one_ulp_less_than_half\n let int63_round_nearest_portable_alloc_exn = int63_round_nearest_portable_alloc_exn\n let int63_round_nearest_arch64_noalloc_exn = int63_round_nearest_arch64_noalloc_exn\n let iround_nearest_exn_64 = iround_nearest_exn_64\nend\n\n(* Include type-specific [Replace_polymorphic_compare] at the end, after\n including functor application that could shadow its definitions. This is\n here so that efficient versions of the comparison functions are exported by\n this module. *)\ninclude Float_replace_polymorphic_compare\n\n(* These functions specifically replace defaults in replace_polymorphic_compare.\n\n The desired behavior here is to propagate a nan if either argument is nan. Because the\n first comparison will always return false if either argument is nan, it suffices to\n check if x is nan. Then, when x is nan or both x and y are nan, we return x = nan; and\n when y is nan but not x, we return y = nan.\n\n There are various ways to implement these functions. The benchmark below shows a few\n different versions. This benchmark was run over an array of random floats (none of\n which are nan).\n\n ┌────────────────────────────────────────────────┬──────────┐\n │ Name │ Time/Run │\n ├────────────────────────────────────────────────┼──────────┤\n │ if is_nan x then x else if x < y then x else y │ 2.42us │\n │ if is_nan x || x < y then x else y │ 2.02us │\n │ if x < y || is_nan x then x else y │ 1.88us │\n └────────────────────────────────────────────────┴──────────┘\n\n The benchmark below was run when x > y is always true (again, no nan values).\n\n ┌────────────────────────────────────────────────┬──────────┐\n │ Name │ Time/Run │\n ├────────────────────────────────────────────────┼──────────┤\n │ if is_nan x then x else if x < y then x else y │ 2.83us │\n │ if is_nan x || x < y then x else y │ 1.97us │\n │ if x < y || is_nan x then x else y │ 1.56us │\n └────────────────────────────────────────────────┴──────────┘\n*)\nlet min (x : t) y = if x < y || is_nan x then x else y\nlet max (x : t) y = if x > y || is_nan x then x else y\n","open! Import\ninclude Buffer_intf\ninclude Caml.Buffer\n\nlet contents_bytes = to_bytes\nlet add_substring t s ~pos ~len = add_substring t s pos len\nlet add_subbytes t s ~pos ~len = add_subbytes t s pos len\nlet sexp_of_t t = sexp_of_string (contents t)\n\nmodule To_bytes =\n Blit.Make_distinct\n (struct\n type nonrec t = t\n\n let length = length\n end)\n (struct\n type t = Bytes.t\n\n let create ~len = Bytes.create len\n let length = Bytes.length\n\n let unsafe_blit ~src ~src_pos ~dst ~dst_pos ~len =\n Caml.Buffer.blit src src_pos dst dst_pos len\n ;;\n end)\n\ninclude To_bytes\nmodule To_string = Blit.Make_to_string (Caml.Buffer) (To_bytes)\n","open Base\n\ntype 'a test_pred\n = ?here:Lexing.position list\n -> ?message:string\n -> ('a -> bool)\n -> 'a\n -> unit\n\ntype 'a test_eq\n = ?here:Lexing.position list\n -> ?message:string\n -> ?equal:('a -> 'a -> bool)\n -> 'a\n -> 'a\n -> unit\n\ntype 'a test_result\n = ?here:Lexing.position list\n -> ?message:string\n -> ?equal:('a -> 'a -> bool)\n -> expect:'a\n -> 'a\n -> unit\n\nexception E of string * Sexp.t [@@deriving sexp]\n\nlet failwith message sexp = raise (E (message, sexp))\n\nlet fail_in_sexp_style ~message ~pos ~here ~tag body =\n let message =\n match message with\n | None -> tag\n | Some s -> s ^ \": \" ^ tag\n in\n let sexp =\n Sexp.List (\n body\n @ [ Sexp.List [ Sexp.Atom \"Loc\"; Sexp.Atom pos ] ]\n @ begin match here with\n | [] -> []\n | _ -> [ Sexp.List [ Sexp.Atom \"Stack\"\n ; [%sexp_of: Source_code_position.t list] here\n ] ]\n end\n )\n in\n failwith message sexp\n\nlet [@cold] test_pred_failed ~message ~pos ~here ~sexpifier t =\n fail_in_sexp_style ~message ~pos ~here ~tag:\"predicate failed\" [\n Sexp.List [Sexp.Atom \"Value\"; sexpifier t]\n ]\n\nlet test_pred ~pos ~sexpifier ~here ?message predicate t =\n if not (predicate t) then\n test_pred_failed ~message ~pos ~here ~sexpifier t\n\nlet r_diff : (from_:string -> to_:string -> unit) option ref = ref None\nlet set_diff_function f = r_diff := f\n\nlet [@cold] test_result_or_eq_failed ~sexpifier ~expect ~got =\n let got = sexpifier got in\n let expect = sexpifier expect in\n begin match !r_diff with\n | None -> ()\n | Some diff ->\n let from_ = Sexp.to_string_hum expect in\n let to_ = Sexp.to_string_hum got in\n diff ~from_ ~to_\n end;\n `Fail (expect, got)\n\nlet test_result_or_eq ~sexpifier ~comparator ?equal ~expect ~got =\n let pass =\n match equal with\n | None -> comparator got expect = 0\n | Some f -> f got expect\n in\n if pass\n then `Pass\n else test_result_or_eq_failed ~sexpifier ~expect ~got\n\nlet [@cold] test_eq_failed ~message ~pos ~here ~t1 ~t2 =\n fail_in_sexp_style ~message ~pos ~here ~tag:\"comparison failed\" [\n t1;\n Sexp.Atom \"vs\";\n t2;\n ]\n\nlet test_eq ~pos ~sexpifier ~comparator ~here ?message ?equal t1 t2 =\n match test_result_or_eq ~sexpifier ~comparator ?equal ~expect:t1 ~got:t2 with\n | `Pass -> ()\n | `Fail (t1, t2) -> test_eq_failed ~message ~pos ~here ~t1 ~t2\n\nlet [@cold] test_result_failed ~message ~pos ~here ~expect ~got =\n fail_in_sexp_style ~message ~pos ~here ~tag:\"got unexpected result\" [\n Sexp.List [Sexp.Atom \"expected\"; expect];\n Sexp.List [Sexp.Atom \"got\"; got];\n ]\n\nlet test_result ~pos ~sexpifier ~comparator ~here ?message ?equal ~expect ~got =\n match test_result_or_eq ~sexpifier ~comparator ?equal ~expect ~got with\n | `Pass -> ()\n | `Fail (expect, got) -> test_result_failed ~message ~pos ~here ~expect ~got\n","type t = string\n\n(* Share the digest of the empty string *)\nlet empty = Digest.string \"\"\nlet make s =\n if s = empty then\n empty\n else\n s\n\nlet compare = compare\n\nlet length = 16\n\nlet to_binary s = s\nlet of_binary_exn s = assert (String.length s = length); make s\nlet unsafe_of_binary = make\n\nlet to_hex = Digest.to_hex\nlet of_hex_exn s = make (Digest.from_hex s)\n\nlet string s = make (Digest.string s)\n\nlet bytes s = make (Digest.bytes s)\n\nlet subbytes bytes ~pos ~len = make (Digest.subbytes bytes pos len)\n","(* Common: common definitions used by binary protocol converters *)\n\nopen Base\nopen Printf\nopen Bigarray\n\ntype pos = int [@@deriving sexp_of]\n\n(* Errors and exceptions *)\n\nexception Buffer_short\nexception No_variant_match\n\nmodule ReadError = struct\n type t =\n | Neg_int8\n | Int_code\n | Int_overflow\n | Nat0_code\n | Nat0_overflow\n | Int32_code\n | Int64_code\n | Nativeint_code\n | Unit_code\n | Bool_code\n | Option_code\n | String_too_long\n | Variant_tag\n | Array_too_long\n | List_too_long of\n { len : int\n ; max_len : int\n }\n | Hashtbl_too_long\n | Sum_tag of string\n | Variant of string\n | Poly_rec_bound of string\n | Variant_wrong_type of string\n | Silly_type of string\n | Empty_type of string\n\n let to_string = function\n | Neg_int8 -> \"Neg_int8\"\n | Int_code -> \"Int_code\"\n | Int_overflow -> \"Int_overflow\"\n | Nat0_code -> \"Nat0_code\"\n | Nat0_overflow -> \"Nat0_overflow\"\n | Int32_code -> \"Int32_code\"\n | Int64_code -> \"Int64_code\"\n | Nativeint_code -> \"Nativeint_code\"\n | Unit_code -> \"Unit_code\"\n | Bool_code -> \"Bool_code\"\n | Option_code -> \"Option_code\"\n | String_too_long -> \"String_too_long\"\n | Variant_tag -> \"Variant_tag\"\n | Array_too_long -> \"Array_too_long\"\n | List_too_long { len; max_len } -> sprintf \"List_too_long / %d (max %d)\" len max_len\n | Hashtbl_too_long -> \"Hashtbl_too_long\"\n | Sum_tag loc -> \"Sum_tag / \" ^ loc\n | Variant loc -> \"Variant / \" ^ loc\n | Poly_rec_bound loc -> \"Poly_rec_bound / \" ^ loc\n | Variant_wrong_type loc -> \"Variant_wrong_type / \" ^ loc\n | Silly_type loc -> \"Silly_type / \" ^ loc\n | Empty_type loc -> \"Empty_type / \" ^ loc\n ;;\n\n let sexp_of_t t = Sexp.Atom (to_string t)\nend\n\nexception Read_error of ReadError.t * pos [@@deriving sexp_of]\nexception Poly_rec_write of string\nexception Empty_type of string\n\nlet raise_read_error err pos = raise (Read_error (err, pos))\n\nlet raise_variant_wrong_type name pos =\n raise (Read_error (ReadError.Variant_wrong_type name, pos))\n;;\n\nlet raise_concurrent_modification loc = failwith (loc ^ \": concurrent modification\")\nlet array_bound_error () = invalid_arg \"index out of bounds\"\n\n(* Buffers *)\n\ntype pos_ref = pos ref\ntype buf = (char, int8_unsigned_elt, c_layout) Array1.t\n\nlet create_buf n = Array1.create Bigarray.char c_layout n\nlet buf_len buf = Array1.dim buf\nlet assert_pos pos = if pos < 0 then array_bound_error ()\nlet check_pos (buf : buf) pos = if pos >= Array1.dim buf then raise Buffer_short\n\nlet safe_get_pos buf pos_ref =\n let pos = !pos_ref in\n check_pos buf pos;\n pos\n;;\n\nlet check_next (buf : buf) next = if next > Array1.dim buf then raise Buffer_short\n\nlet get_opt_pos ~loc ~var = function\n | Some pos ->\n if pos < 0 then invalid_arg (sprintf \"Bin_prot.Common.%s: %s < 0\" loc var);\n pos\n | None -> 0\n;;\n\nexternal unsafe_blit_buf\n : src_pos:int\n -> src:buf\n -> dst_pos:int\n -> dst:buf\n -> len:int\n -> unit\n = \"bin_prot_blit_buf_stub\"\n\nlet blit_buf ?src_pos ~src ?dst_pos ~dst len =\n let loc = \"blit_buf\" in\n let src_pos = get_opt_pos ~loc ~var:\"src_pos\" src_pos in\n let dst_pos = get_opt_pos ~loc ~var:\"dst_pos\" dst_pos in\n if len < 0\n then invalid_arg \"Bin_prot.Common.blit_buf: len < 0\"\n else if len = 0\n then (\n if src_pos > Array1.dim src\n then invalid_arg \"Bin_prot.Common.blit_buf: src_pos > src_len\";\n if dst_pos > Array1.dim dst\n then invalid_arg \"Bin_prot.Common.blit_buf: dst_pos > dst_len\")\n else if src_pos + len > Array1.dim src\n then invalid_arg \"Bin_prot.Common.blit_buf: src_pos + len > src_len\"\n else if dst_pos + len > Array1.dim dst\n then invalid_arg \"Bin_prot.Common.blit_buf: dst_pos + len > dst_len\"\n else unsafe_blit_buf ~src_pos ~src ~dst_pos ~dst ~len\n;;\n\nexternal unsafe_blit_string_buf\n : src_pos:int\n -> string\n -> dst_pos:int\n -> buf\n -> len:int\n -> unit\n = \"bin_prot_blit_string_buf_stub\"\n[@@noalloc]\n\nexternal unsafe_blit_bytes_buf\n : src_pos:int\n -> bytes\n -> dst_pos:int\n -> buf\n -> len:int\n -> unit\n = \"bin_prot_blit_bytes_buf_stub\"\n[@@noalloc]\n\nlet blit_string_buf ?src_pos str ?dst_pos buf ~len =\n let loc = \"blit_string_buf\" in\n let src_pos = get_opt_pos ~loc ~var:\"src_pos\" src_pos in\n let dst_pos = get_opt_pos ~loc ~var:\"dst_pos\" dst_pos in\n if len < 0\n then invalid_arg \"Bin_prot.Common.blit_string_buf: len < 0\"\n else if len = 0\n then (\n if src_pos > String.length str\n then invalid_arg \"Bin_prot.Common.blit_string_buf: src_pos > str_len\";\n if dst_pos > Array1.dim buf\n then invalid_arg \"Bin_prot.Common.blit_string_buf: src_pos > buf\")\n else if src_pos + len > String.length str\n then invalid_arg \"Bin_prot.Common.blit_string_buf: src_pos + len > str_len\"\n else if dst_pos + len > Array1.dim buf\n then invalid_arg \"Bin_prot.Common.blit_string_buf: src_pos + len > buf\"\n else unsafe_blit_string_buf ~src_pos str ~dst_pos buf ~len\n;;\n\nlet blit_bytes_buf ?src_pos str ?dst_pos buf ~len =\n let loc = \"blit_bytes_buf\" in\n let src_pos = get_opt_pos ~loc ~var:\"src_pos\" src_pos in\n let dst_pos = get_opt_pos ~loc ~var:\"dst_pos\" dst_pos in\n if len < 0\n then invalid_arg \"Bin_prot.Common.blit_bytes_buf: len < 0\"\n else if len = 0\n then (\n if src_pos > Bytes.length str\n then invalid_arg \"Bin_prot.Common.blit_bytes_buf: src_pos > str_len\";\n if dst_pos > Array1.dim buf\n then invalid_arg \"Bin_prot.Common.blit_bytes_buf: src_pos > buf\")\n else if src_pos + len > Bytes.length str\n then invalid_arg \"Bin_prot.Common.blit_bytes_buf: src_pos + len > str_len\"\n else if dst_pos + len > Array1.dim buf\n then invalid_arg \"Bin_prot.Common.blit_bytes_buf: src_pos + len > buf\"\n else unsafe_blit_bytes_buf ~src_pos str ~dst_pos buf ~len\n;;\n\nexternal unsafe_blit_buf_string\n : src_pos:int\n -> buf\n -> dst_pos:int\n -> bytes\n -> len:int\n -> unit\n = \"bin_prot_blit_buf_bytes_stub\"\n[@@noalloc]\n\nexternal unsafe_blit_buf_bytes\n : src_pos:int\n -> buf\n -> dst_pos:int\n -> bytes\n -> len:int\n -> unit\n = \"bin_prot_blit_buf_bytes_stub\"\n[@@noalloc]\n\nlet blit_buf_bytes ?src_pos buf ?dst_pos str ~len =\n let loc = \"blit_buf_string\" in\n let src_pos = get_opt_pos ~loc ~var:\"src_pos\" src_pos in\n let dst_pos = get_opt_pos ~loc ~var:\"dst_pos\" dst_pos in\n if len < 0\n then invalid_arg \"Bin_prot.Common.blit_buf_string: len < 0\"\n else if len = 0\n then (\n if src_pos > Array1.dim buf\n then invalid_arg \"Bin_prot.Common.blit_buf_string: src_pos > buf_len\";\n if dst_pos > Bytes.length str\n then invalid_arg \"Bin_prot.Common.blit_buf_string: src_pos > str_len\")\n else if src_pos + len > Array1.dim buf\n then invalid_arg \"Bin_prot.Common.blit_buf_string: src_pos + len > buf_len\"\n else if dst_pos + len > Bytes.length str\n then invalid_arg \"Bin_prot.Common.blit_buf_string: src_pos + len > str_len\"\n else unsafe_blit_buf_bytes ~src_pos buf ~dst_pos str ~len\n;;\n\nlet blit_buf_string = blit_buf_bytes\n\n(* Miscellaneous *)\n\nlet rec copy_htbl_list htbl = function\n | [] -> htbl\n | (k, v) :: rest ->\n Caml.Hashtbl.add htbl k v;\n copy_htbl_list htbl rest\n;;\n\n(* Bigarrays *)\n\ntype vec32 = (float, float32_elt, fortran_layout) Array1.t\ntype vec64 = (float, float64_elt, fortran_layout) Array1.t\ntype vec = vec64\ntype mat32 = (float, float32_elt, fortran_layout) Array2.t\ntype mat64 = (float, float64_elt, fortran_layout) Array2.t\ntype mat = mat64\n\n(* Float arrays *)\n\nexternal unsafe_blit_float_array_buf\n : src_pos:int\n -> float array\n -> dst_pos:int\n -> buf\n -> len:int\n -> unit\n = \"bin_prot_blit_float_array_buf_stub\"\n[@@noalloc]\n\nexternal unsafe_blit_buf_float_array\n : src_pos:int\n -> buf\n -> dst_pos:int\n -> float array\n -> len:int\n -> unit\n = \"bin_prot_blit_buf_float_array_stub\"\n[@@noalloc]\n\n(***)\n\nlet ( + ) = ( + )\n","open Core_kernel\n\nmodule type Nat_intf = Nat.Intf\n\ntype z = Nat.z\n\ntype 'a s = 'a Nat.s\n\nmodule T = struct\n type ('a, _) t = [] : ('a, z) t | ( :: ) : 'a * ('a, 'n) t -> ('a, 'n s) t\nend\n\ninclude T\n\nlet singleton a = [ a ]\n\nlet unsingleton (type a) ([ x ] : (a, z s) t) : a = x\n\nlet rec iter : type a n. (a, n) t -> f:(a -> unit) -> unit =\n fun t ~f -> match t with [] -> () | x :: xs -> f x ; iter xs ~f\n\nlet iteri (type a n) (t : (a, n) t) ~(f : int -> a -> unit) : unit =\n let rec go : type n. int -> (a, n) t -> unit =\n fun acc t ->\n match t with\n | [] ->\n ()\n | x :: xs ->\n f acc x ;\n go (acc + 1) xs\n in\n go 0 t\n\nlet rec length : type a n. (a, n) t -> n Nat.t = function\n | [] ->\n Z\n | _ :: xs ->\n S (length xs)\n\nlet nth v i =\n let rec loop : type a n. int -> (a, n) t -> a option =\n fun j -> function\n | [] ->\n None\n | x :: xs ->\n if Int.equal i j then Some x else loop (j + 1) xs\n in\n loop 0 v\n\nlet nth_exn v i =\n match nth v i with\n | None ->\n invalid_argf \"Vector.nth_exn %d called on a vector of length %d\" i\n (length v |> Nat.to_int)\n ()\n | Some e ->\n e\n\nlet rec iter2 : type a b n. (a, n) t -> (b, n) t -> f:(a -> b -> unit) -> unit =\n fun t1 t2 ~f ->\n match (t1, t2) with\n | [], [] ->\n ()\n | x :: xs, y :: ys ->\n f x y ; iter2 xs ys ~f\n\nlet rec map2 : type a b c n. (a, n) t -> (b, n) t -> f:(a -> b -> c) -> (c, n) t\n =\n fun t1 t2 ~f ->\n match (t1, t2) with\n | [], [] ->\n []\n | x :: xs, y :: ys ->\n f x y :: map2 xs ys ~f\n\nlet rec hhead_off :\n type xs n.\n (xs, n s) Hlist0.H1_1(T).t -> xs Hlist0.HlistId.t * (xs, n) Hlist0.H1_1(T).t\n =\n fun xss ->\n match xss with\n | [] ->\n ([], [])\n | (x :: xs) :: xss ->\n let hds, tls = hhead_off xss in\n (x :: hds, xs :: tls)\n\nlet rec mapn :\n type xs y n.\n (xs, n) Hlist0.H1_1(T).t -> f:(xs Hlist0.HlistId.t -> y) -> (y, n) t =\n fun xss ~f ->\n match xss with\n | [] :: _xss ->\n []\n | (_ :: _) :: _ ->\n let hds, tls = hhead_off xss in\n let y = f hds in\n let ys = mapn tls ~f in\n y :: ys\n | [] ->\n failwith \"mapn: Empty args\"\n\nlet rec nth : type a n. (a, n) t -> int -> a option =\n fun t idx ->\n match t with\n | [] ->\n None\n | x :: _ when idx = 0 ->\n Some x\n | _ :: t ->\n nth t (idx - 1)\n\nlet zip xs ys = map2 xs ys ~f:(fun x y -> (x, y))\n\nlet rec to_list : type a n. (a, n) t -> a list =\n fun t -> match t with [] -> [] | x :: xs -> x :: to_list xs\n\nlet sexp_of_t a _ v = List.sexp_of_t a (to_list v)\n\nlet to_array t = Array.of_list (to_list t)\n\nlet rec init : type a n. int -> n Nat.t -> f:(int -> a) -> (a, n) t =\n fun i n ~f -> match n with Z -> [] | S n -> f i :: init (i + 1) n ~f\n\nlet init n ~f = init 0 n ~f\n\nlet rec _fold_map :\n type acc a b n.\n (a, n) t -> f:(acc -> a -> acc * b) -> init:acc -> acc * (b, n) t =\n fun t ~f ~init ->\n match t with\n | [] ->\n (init, [])\n | x :: xs ->\n let acc, y = f init x in\n let res, ys = _fold_map xs ~f ~init:acc in\n (res, y :: ys)\n\nlet rec map : type a b n. (a, n) t -> f:(a -> b) -> (b, n) t =\n fun t ~f -> match t with [] -> [] | x :: xs -> f x :: map xs ~f\n\nlet mapi (type a b m) (t : (a, m) t) ~(f : int -> a -> b) =\n let rec go : type n. int -> (a, n) t -> (b, n) t =\n fun i t -> match t with [] -> [] | x :: xs -> f i x :: go (i + 1) xs\n in\n go 0 t\n\nlet unzip ts = (map ts ~f:fst, map ts ~f:snd)\n\ntype _ e = T : ('a, 'n) t -> 'a e\n\nlet rec of_list : type a. a list -> a e = function\n | [] ->\n T []\n | x :: xs ->\n let (T xs) = of_list xs in\n T (x :: xs)\n\nlet rec of_list_and_length_exn : type a n. a list -> n Nat.t -> (a, n) t =\n fun xs n ->\n match (xs, n) with\n | [], Z ->\n []\n | x :: xs, S n ->\n x :: of_list_and_length_exn xs n\n | [], S _ | _ :: _, Z ->\n failwith \"Vector: Length mismatch\"\n\nlet of_array_and_length_exn : type a n. a array -> n Nat.t -> (a, n) t =\n fun xs n ->\n if Array.length xs <> Nat.to_int n then\n failwithf \"of_array_and_length_exn: got %d (expected %d)\" (Array.length xs)\n (Nat.to_int n) () ;\n init n ~f:(Array.get xs)\n\nlet rec _take_from_list : type a n. a list -> n Nat.t -> (a, n) t =\n fun xs n ->\n match (xs, n) with\n | _, Z ->\n []\n | x :: xs, S n ->\n x :: _take_from_list xs n\n | [], S _ ->\n failwith \"take_from_list: Not enough to take\"\n\nlet rec fold : type acc a n. (a, n) t -> f:(acc -> a -> acc) -> init:acc -> acc\n =\n fun t ~f ~init ->\n match t with\n | [] ->\n init\n | x :: xs ->\n let acc = f init x in\n fold xs ~f ~init:acc\n\nlet for_all : type a n. (a, n) t -> f:(a -> bool) -> bool =\n fun v ~f ->\n with_return (fun { return } ->\n iter v ~f:(fun x -> if not (f x) then return false) ;\n true )\n\nlet foldi t ~f ~init =\n snd (fold t ~f:(fun (i, acc) x -> (i + 1, f i acc x)) ~init:(0, init))\n\nlet reduce_exn (type n) (t : (_, n) t) ~f =\n match t with\n | [] ->\n failwith \"reduce_exn: empty list\"\n | init :: xs ->\n fold xs ~f ~init\n\nmodule L = struct\n type 'a t = 'a list [@@deriving yojson]\nend\n\nmodule Make = struct\n module Cata (F : sig\n type _ t\n\n val pair : 'a t -> 'b t -> ('a * 'b) t\n\n val cnv : ('a -> 'b) -> ('b -> 'a) -> 'b t -> 'a t\n\n val unit : unit t\n end) =\n struct\n let rec f : type n a. n Nat.t -> a F.t -> (a, n) t F.t =\n fun n tc ->\n match n with\n | Z ->\n F.cnv (function [] -> ()) (fun () -> []) F.unit\n | S n ->\n let tl = f n tc in\n F.cnv\n (function x :: xs -> (x, xs))\n (fun (x, xs) -> x :: xs)\n (F.pair tc tl)\n end\n\n module Sexpable (N : Nat_intf) : Sexpable.S1 with type 'a t := ('a, N.n) t =\n struct\n let sexp_of_t f t = List.sexp_of_t f (to_list t)\n\n let t_of_sexp f s = of_list_and_length_exn (List.t_of_sexp f s) N.n\n end\n\n module Yojson (N : Nat_intf) :\n Sigs.Jsonable.S1 with type 'a t := ('a, N.n) t = struct\n let to_yojson f t = L.to_yojson f (to_list t)\n\n let of_yojson f s =\n Result.map (L.of_yojson f s) ~f:(Fn.flip of_list_and_length_exn N.n)\n end\n\n module Binable (N : Nat_intf) : Binable.S1 with type 'a t := ('a, N.n) t =\n struct\n open Bin_prot\n\n module Tc = Cata (struct\n type 'a t = 'a Type_class.t\n\n let pair = Type_class.bin_pair\n\n let cnv t = Type_class.cnv Fn.id t\n\n let unit = Type_class.bin_unit\n end)\n\n module Shape = Cata (struct\n type _ t = Shape.t\n\n let pair = Shape.bin_shape_pair\n\n let cnv _ _ = Fn.id\n\n let unit = Shape.bin_shape_unit\n end)\n\n module Size = Cata (struct\n type 'a t = 'a Size.sizer\n\n let pair = Size.bin_size_pair\n\n let cnv a_to_b _b_to_a b_sizer a = b_sizer (a_to_b a)\n\n let unit = Size.bin_size_unit\n end)\n\n module Write = Cata (struct\n type 'a t = 'a Write.writer\n\n let pair = Write.bin_write_pair\n\n let cnv a_to_b _b_to_a b_writer buf ~pos a = b_writer buf ~pos (a_to_b a)\n\n let unit = Write.bin_write_unit\n end)\n\n module Writer = Cata (struct\n type 'a t = 'a Type_class.writer\n\n let pair = Type_class.bin_writer_pair\n\n let cnv a_to_b _b_to_a b_writer = Type_class.cnv_writer a_to_b b_writer\n\n let unit = Type_class.bin_writer_unit\n end)\n\n module Reader = Cata (struct\n type 'a t = 'a Type_class.reader\n\n let pair = Type_class.bin_reader_pair\n\n let cnv _a_to_b b_to_a b_reader = Type_class.cnv_reader b_to_a b_reader\n\n let unit = Type_class.bin_reader_unit\n end)\n\n module Read = Cata (struct\n type 'a t = 'a Read.reader\n\n let pair = Read.bin_read_pair\n\n let cnv _a_to_b b_to_a b_reader buf ~pos_ref =\n b_to_a (b_reader buf ~pos_ref)\n\n let unit = Read.bin_read_unit\n end)\n\n let bin_shape_t sh = Shape.f N.n sh\n\n let bin_size_t sz = Size.f N.n sz\n\n let bin_write_t wr = Write.f N.n wr\n\n let bin_writer_t wr = Writer.f N.n wr\n\n let bin_t tc = Tc.f N.n tc\n\n let bin_reader_t re = Reader.f N.n re\n\n let bin_read_t re = Read.f N.n re\n\n let __bin_read_t__ _f _buf ~pos_ref _vint =\n Common.raise_variant_wrong_type \"vector\" !pos_ref\n end\nend\n\ntype ('a, 'n) vec = ('a, 'n) t\n\nmodule With_length (N : Nat.Intf) = struct\n type 'a t = ('a, N.n) vec\n\n let compare c t1 t2 = Base.List.compare c (to_list t1) (to_list t2)\n\n let hash_fold_t f s v = List.hash_fold_t f s (to_list v)\n\n let equal f t1 t2 = List.equal f (to_list t1) (to_list t2)\n\n include Make.Yojson (N)\n include Make.Sexpable (N)\n\n let map (t : 'a t) = map t\n\n let of_list_exn : 'a list -> 'a t = fun ls -> of_list_and_length_exn ls N.n\n\n let to_list : 'a t -> 'a list = to_list\nend\n\nlet rec typ' :\n type f var value n.\n ((var, value, f) Snarky_backendless.Typ.t, n) t\n -> ((var, n) t, (value, n) t, f) Snarky_backendless.Typ.t =\n let open Snarky_backendless.Typ in\n fun elts ->\n match elts with\n | elt :: elts ->\n let tl = typ' elts in\n let there = function x :: xs -> (x, xs) in\n let back (x, xs) = x :: xs in\n transport (elt * tl) ~there ~back |> transport_var ~there ~back\n | [] ->\n let there [] = () in\n let back () = [] in\n transport (unit ()) ~there ~back |> transport_var ~there ~back\n\nlet typ elt n = typ' (init n ~f:(fun _ -> elt))\n\nlet rec append :\n type n m n_m a. (a, n) t -> (a, m) t -> (n, m, n_m) Nat.Adds.t -> (a, n_m) t\n =\n fun t1 t2 adds ->\n match (t1, adds) with\n | [], Z ->\n t2\n | x :: t1, S adds ->\n x :: append t1 t2 adds\n\n(* TODO: Make more efficient *)\nlet rev (type a n) (xs : (a, n) t) : (a, n) t =\n of_list_and_length_exn\n (fold ~init:[] ~f:(fun acc x -> List.cons x acc) xs)\n (length xs)\n\nlet rec _last : type a n. (a, n s) t -> a = function\n | [ x ] ->\n x\n | _ :: (_ :: _ as xs) ->\n _last xs\n\nlet rec split :\n type n m n_m a. (a, n_m) t -> (n, m, n_m) Nat.Adds.t -> (a, n) t * (a, m) t\n =\n fun t adds ->\n match (t, adds) with\n | [], Z ->\n ([], [])\n | _ :: _, Z ->\n ([], t)\n | x :: t1, S adds ->\n let xs, ys = split t1 adds in\n (x :: xs, ys)\n\nlet rec transpose : type a n m. ((a, n) t, m) t -> ((a, m) t, n) t =\n fun xss ->\n match xss with\n | [] ->\n failwith \"transpose: empty list\"\n | [] :: _ ->\n []\n | (_ :: _) :: _ ->\n let heads, tails = unzip (map xss ~f:(fun (x :: xs) -> (x, xs))) in\n heads :: transpose tails\n\nlet rec trim : type a n m. (a, m) t -> (n, m) Nat.Lte.t -> (a, n) t =\n fun v p -> match (v, p) with _, Z -> [] | x :: xs, S p -> x :: trim xs p\n\nlet trim_front (type a n m) (v : (a, m) t) (p : (n, m) Nat.Lte.t) : (a, n) t =\n rev (trim (rev v) p)\n\nlet extend_front_exn : type n m a. (a, n) t -> m Nat.t -> a -> (a, m) t =\n fun v m dummy ->\n let v = to_array v in\n let n = Array.length v in\n let m' = Nat.to_int m in\n assert (n <= m') ;\n let padding = m' - n in\n init m ~f:(fun i -> if i < padding then dummy else v.(i - padding))\n\nlet rec extend_exn : type n m a. (a, n) t -> m Nat.t -> a -> (a, m) t =\n fun v m default ->\n match (v, m) with\n | [], Z ->\n []\n | [], S n ->\n default :: extend_exn [] n default\n | _x :: _xs, Z ->\n failwith \"extend_exn: list too long\"\n | x :: xs, S m ->\n let extended = extend_exn xs m default in\n x :: extended\n\nlet rec extend :\n type a n m. (a, n) t -> (n, m) Nat.Lte.t -> m Nat.t -> a -> (a, m) t =\n fun v p m default ->\n match (v, p, m) with\n | _, Z, Z ->\n []\n | _, Z, S m ->\n default :: extend [] Z m default\n | x :: xs, S p, S m ->\n x :: extend xs p m default\n\nlet extend_front :\n type a n m. (a, n) t -> (n, m) Nat.Lte.t -> m Nat.t -> a -> (a, m) t =\n fun v _p m default -> extend_front_exn v m default\n\nmodule type S = sig\n type 'a t [@@deriving compare, yojson, sexp, hash, equal]\n\n val map : 'a t -> f:('a -> 'b) -> 'b t\n\n val of_list_exn : 'a list -> 'a t\n\n val to_list : 'a t -> 'a list\nend\n\nmodule type VECTOR = sig\n type 'a t\n\n include S with type 'a t := 'a t\n\n module Stable : sig\n module V1 : sig\n include S with type 'a t = 'a t\n\n include Sigs.Binable.S1 with type 'a t = 'a t\n\n include Sigs.VERSIONED\n end\n end\nend\n\nmodule With_version (N : Nat.Intf) = struct\n module type S = sig\n [%%versioned:\n module Stable : sig\n module V1 : sig\n type 'a t = ('a, N.n) vec\n [@@deriving compare, yojson, sexp, hash, equal]\n end\n end]\n\n val map : 'a t -> f:('a -> 'b) -> 'b t\n\n val of_list_exn : 'a list -> 'a t\n\n val to_list : 'a t -> 'a list\n end\nend\n\nmodule Vector_2 = struct\n module T = With_length (Nat.N2)\n\n [%%versioned_binable\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n type 'a t = ('a, Nat.N2.n) vec\n\n include Make.Binable (Nat.N2)\n\n include (T : module type of T with type 'a t := 'a t)\n end\n end]\n\n include T\n\n let _type_equal : type a. (a t, a Stable.Latest.t) Type_equal.t = Type_equal.T\nend\n\nmodule Vector_4 = struct\n module T = With_length (Nat.N4)\n\n [%%versioned_binable\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n type 'a t = ('a, Nat.N4.n) vec\n\n include Make.Binable (Nat.N4)\n\n include (T : module type of T with type 'a t := 'a t)\n end\n end]\n\n include T\n\n let _type_equal : type a. (a t, a Stable.Latest.t) Type_equal.t = Type_equal.T\nend\n\nmodule Vector_5 = struct\n module T = With_length (Nat.N5)\n\n [%%versioned_binable\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n type 'a t = ('a, Nat.N5.n) vec\n\n include Make.Binable (Nat.N5)\n\n include (T : module type of T with type 'a t := 'a t)\n end\n end]\n\n include T\n\n let _type_equal : type a. (a t, a Stable.Latest.t) Type_equal.t = Type_equal.T\nend\n\nmodule Vector_6 = struct\n module T = With_length (Nat.N6)\n\n [%%versioned_binable\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n type 'a t = ('a, Nat.N6.n) vec\n\n include Make.Binable (Nat.N6)\n\n include (T : module type of T with type 'a t := 'a t)\n end\n end]\n\n include T\n\n let _type_equal : type a. (a t, a Stable.Latest.t) Type_equal.t = Type_equal.T\nend\n\nmodule Vector_7 = struct\n module T = With_length (Nat.N7)\n\n [%%versioned_binable\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n type 'a t = ('a, Nat.N7.n) vec\n\n include Make.Binable (Nat.N7)\n\n include (T : module type of T with type 'a t := 'a t)\n end\n end]\n\n include T\n\n let _type_equal : type a. (a t, a Stable.Latest.t) Type_equal.t = Type_equal.T\nend\n\nmodule Vector_8 = struct\n module T = With_length (Nat.N8)\n\n [%%versioned_binable\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n type 'a t = ('a, Nat.N8.n) vec\n\n include Make.Binable (Nat.N8)\n\n include (T : module type of T with type 'a t := 'a t)\n end\n end]\n\n include T\n\n let _type_equal : type a. (a t, a Stable.Latest.t) Type_equal.t = Type_equal.T\nend\n\nmodule Vector_15 = struct\n module T = With_length (Nat.N15)\n\n [%%versioned_binable\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n type 'a t = ('a, Nat.N15.n) vec\n\n include Make.Binable (Nat.N15)\n\n include (T : module type of T with type 'a t := 'a t)\n end\n end]\n\n include T\n\n let _type_equal : type a. (a t, a Stable.Latest.t) Type_equal.t = Type_equal.T\nend\n\nmodule Vector_16 = struct\n module T = With_length (Nat.N16)\n\n [%%versioned_binable\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n type 'a t = ('a, Nat.N16.n) vec\n\n include Make.Binable (Nat.N16)\n\n include (T : module type of T with type 'a t := 'a t)\n end\n end]\n\n include T\n\n let _type_equal : type a. (a t, a Stable.Latest.t) Type_equal.t = Type_equal.T\nend\n","(* Read_ml: reading values from the binary protocol using (mostly) OCaml. *)\n\n(* Note: the code is this file is carefully written to avoid unnecessary allocations. When\n touching this code, be sure to run the benchmarks to check for regressions. *)\n\nopen Bigarray\nopen Common\n\ntype 'a reader = buf -> pos_ref:pos_ref -> 'a\ntype ('a, 'b) reader1 = 'a reader -> 'b reader\ntype ('a, 'b, 'c) reader2 = 'a reader -> ('b, 'c) reader1\ntype ('a, 'b, 'c, 'd) reader3 = 'a reader -> ('b, 'c, 'd) reader2\n\nexternal unsafe_get : buf -> int -> char = \"%caml_ba_unsafe_ref_1\"\nexternal unsafe_get8 : buf -> int -> int = \"%caml_ba_unsafe_ref_1\"\n\nlet unsafe_get8_signed buf pos =\n let c = unsafe_get8 buf pos in\n if c >= 128 then c - 256 else c\n;;\n\n(*$ open Bin_prot_cinaps $*)\n\nlet arch_sixtyfour = Sys.word_size = 64\nlet arch_big_endian = Sys.big_endian\nlet max_int_int32 = if arch_sixtyfour then Int32.max_int else Int32.of_int max_int\nlet min_int_int32 = if arch_sixtyfour then Int32.max_int else Int32.of_int min_int\nlet max_int_int64 = Int64.of_int max_int\nlet min_int_int64 = Int64.of_int min_int\n\nlet safe_int_of_int32 pos x =\n if arch_sixtyfour\n then Int32.to_int x\n else if x >= min_int_int32 && x <= max_int_int32\n then Int32.to_int x\n else raise_read_error ReadError.Int_overflow pos\n;;\n\nlet safe_int_of_int64 pos x =\n if x >= min_int_int64 && x <= max_int_int64\n then Int64.to_int x\n else raise_read_error ReadError.Int_overflow pos\n;;\n\nlet safe_nativeint_of_int64 =\n if arch_sixtyfour\n then fun _pos x -> Int64.to_nativeint x\n else\n fun pos x ->\n if x >= Int64.of_nativeint Nativeint.min_int\n && x <= Int64.of_nativeint Nativeint.max_int\n then Int64.to_nativeint x\n else raise_read_error ReadError.Int_overflow pos\n;;\n\nexternal unsafe_get16 : buf -> int -> int = \"%caml_bigstring_get16u\"\nexternal unsafe_get32 : buf -> int -> int32 = \"%caml_bigstring_get32u\"\nexternal unsafe_get64 : buf -> int -> int64 = \"%caml_bigstring_get64u\"\nexternal bswap16 : int -> int = \"%bswap16\"\nexternal bswap32 : int32 -> int32 = \"%bswap_int32\"\nexternal bswap64 : int64 -> int64 = \"%bswap_int64\"\n\nlet unsafe_get16be_unsigned =\n if arch_big_endian\n then unsafe_get16\n else fun buf pos -> unsafe_get16 buf pos |> bswap16\n;;\n\nlet unsafe_get32be =\n if arch_big_endian\n then unsafe_get32\n else fun buf pos -> unsafe_get32 buf pos |> bswap32\n;;\n\nlet unsafe_get64be =\n if arch_big_endian\n then unsafe_get64\n else fun buf pos -> unsafe_get64 buf pos |> bswap64\n;;\n\nlet unsafe_get16le_unsigned =\n if arch_big_endian\n then fun buf pos -> unsafe_get16 buf pos |> bswap16\n else unsafe_get16\n;;\n\nlet unsafe_get32le =\n if arch_big_endian\n then fun buf pos -> unsafe_get32 buf pos |> bswap32\n else unsafe_get32\n;;\n\nlet unsafe_get64le =\n if arch_big_endian\n then fun buf pos -> unsafe_get64 buf pos |> bswap64\n else unsafe_get64\n;;\n\nlet unsafe_get16le_signed buf pos =\n let x = unsafe_get16le_unsigned buf pos in\n if x > 32767 then x - 65536 else x\n;;\n\nlet bin_read_unit buf ~pos_ref =\n let pos = safe_get_pos buf pos_ref in\n assert_pos pos;\n if unsafe_get buf pos = '\\000'\n then pos_ref := pos + 1\n else raise_read_error ReadError.Unit_code pos\n;;\n\nlet bin_read_bool buf ~pos_ref =\n let pos = safe_get_pos buf pos_ref in\n assert_pos pos;\n match unsafe_get buf pos with\n | '\\000' ->\n pos_ref := pos + 1;\n false\n | '\\001' ->\n pos_ref := pos + 1;\n true\n | _ -> raise_read_error ReadError.Bool_code pos\n;;\n\nlet safe_bin_read_neg_int8 buf ~pos_ref ~pos =\n let next = pos + 1 in\n check_next buf next;\n let n = unsafe_get8_signed buf pos in\n if n >= 0 then raise_read_error ReadError.Neg_int8 !pos_ref;\n pos_ref := next;\n n\n;;\n\nlet safe_bin_read_int16 buf ~pos_ref ~pos =\n let next = pos + 2 in\n check_next buf next;\n pos_ref := next;\n (* Can be above next line (no errors possible with 16bit).\n This should improve the generated code. *)\n unsafe_get16le_signed buf pos\n;;\n\nlet safe_bin_read_int32 buf ~pos_ref ~pos =\n let next = pos + 4 in\n check_next buf next;\n pos_ref := next;\n (* No error possible either. *)\n unsafe_get32le buf pos\n;;\n\nlet safe_bin_read_int64 buf ~pos_ref ~pos =\n let next = pos + 8 in\n check_next buf next;\n pos_ref := next;\n (* No error possible either. *)\n unsafe_get64le buf pos\n;;\n\nlet safe_bin_read_int32_as_int buf ~pos_ref ~pos =\n let next = pos + 4 in\n check_next buf next;\n let n = unsafe_get32le buf pos in\n let n = safe_int_of_int32 !pos_ref n in\n pos_ref := next;\n n\n;;\n\nlet safe_bin_read_int64_as_int buf ~pos_ref ~pos =\n let next = pos + 8 in\n check_next buf next;\n let n = unsafe_get64le buf pos in\n let n = safe_int_of_int64 !pos_ref n in\n pos_ref := next;\n n\n;;\n\nlet safe_bin_read_int32_as_int64 buf ~pos_ref ~pos =\n let next = pos + 4 in\n check_next buf next;\n pos_ref := next;\n let n = unsafe_get32le buf pos in\n Int64.of_int32 n\n;;\n\nlet safe_bin_read_int32_as_nativeint buf ~pos_ref ~pos =\n let next = pos + 4 in\n check_next buf next;\n pos_ref := next;\n let n = unsafe_get32le buf pos in\n Nativeint.of_int32 n\n;;\n\nlet safe_bin_read_int64_as_nativeint buf ~pos_ref ~pos =\n let next = pos + 8 in\n check_next buf next;\n let n = unsafe_get64le buf pos in\n let n = safe_nativeint_of_int64 pos n in\n pos_ref := next;\n n\n;;\n\nlet safe_bin_read_nat0_16 buf ~pos_ref ~pos =\n let next = pos + 2 in\n check_next buf next;\n pos_ref := next;\n Nat0.unsafe_of_int (unsafe_get16le_unsigned buf pos)\n;;\n\nlet safe_bin_read_nat0_32 =\n if arch_sixtyfour\n then (\n let mask_32bit = Int64.to_int 0xffff_ffffL in\n fun buf ~pos_ref ~pos ->\n let next = pos + 4 in\n check_next buf next;\n pos_ref := next;\n let n = Int32.to_int (unsafe_get32le buf pos) in\n if n >= 0\n then Nat0.unsafe_of_int n\n else\n (* Erase the upper bits that were set to 1 during the int32 -> int conversion. *)\n Nat0.unsafe_of_int (n land mask_32bit))\n else\n fun buf ~pos_ref ~pos ->\n let next = pos + 4 in\n check_next buf next;\n let n = unsafe_get32le buf pos in\n if n >= 0l && n <= max_int_int32\n then (\n let n = Nat0.unsafe_of_int (Int32.to_int n) in\n pos_ref := next;\n n)\n else raise_read_error ReadError.Nat0_overflow !pos_ref\n;;\n\nlet safe_bin_read_nat0_64 buf ~pos_ref ~pos =\n let next = pos + 8 in\n check_next buf next;\n let n = unsafe_get64le buf pos in\n if n >= 0L && n <= max_int_int64\n then (\n let n = Nat0.unsafe_of_int (Int64.to_int n) in\n pos_ref := next;\n n)\n else raise_read_error ReadError.Nat0_overflow !pos_ref\n;;\n\nlet bin_read_nat0 buf ~pos_ref =\n let pos = safe_get_pos buf pos_ref in\n assert_pos pos;\n match unsafe_get buf pos with\n | '\\x00'..'\\x7f' as ch ->\n pos_ref := pos + 1;\n Nat0.unsafe_of_int (Char.code ch)\n | (*$ Code.char INT16 *)'\\xfe'(*$*) ->\n safe_bin_read_nat0_16 buf ~pos_ref ~pos:(pos + 1)\n | (*$ Code.char INT32 *)'\\xfd'(*$*) ->\n safe_bin_read_nat0_32 buf ~pos_ref ~pos:(pos + 1)\n | (*$ Code.char INT64 *)'\\xfc'(*$*) ->\n if arch_sixtyfour then\n safe_bin_read_nat0_64 buf ~pos_ref ~pos:(pos + 1)\n else\n raise_read_error ReadError.Nat0_overflow pos\n | _ ->\n raise_read_error ReadError.Nat0_code pos\n[@@ocamlformat \"disable\"]\n\nlet bin_read_bytes buf ~pos_ref =\n let start_pos = !pos_ref in\n let len = (bin_read_nat0 buf ~pos_ref :> int) in\n if len > Sys.max_string_length\n then raise_read_error ReadError.String_too_long start_pos;\n let pos = !pos_ref in\n let next = pos + len in\n check_next buf next;\n pos_ref := next;\n let str = Bytes.create len in\n unsafe_blit_buf_bytes ~src_pos:pos buf ~dst_pos:0 str ~len;\n str\n;;\n\nlet bin_read_string buf ~pos_ref =\n let str = bin_read_bytes buf ~pos_ref in\n Bytes.unsafe_to_string str\n;;\n\nlet bin_read_char buf ~pos_ref =\n let pos = safe_get_pos buf pos_ref in\n assert_pos pos;\n pos_ref := pos + 1;\n unsafe_get buf pos\n;;\n\nlet bin_read_int buf ~pos_ref =\n let pos = safe_get_pos buf pos_ref in\n assert_pos pos;\n match unsafe_get buf pos with\n | '\\x00'..'\\x7f' as ch ->\n pos_ref := pos + 1;\n Char.code ch\n | (*$ Code.char NEG_INT8 *)'\\xff'(*$*) ->\n safe_bin_read_neg_int8 buf ~pos_ref ~pos:(pos + 1)\n | (*$ Code.char INT16 *)'\\xfe'(*$*) ->\n safe_bin_read_int16 buf ~pos_ref ~pos:(pos + 1)\n | (*$ Code.char INT32 *)'\\xfd'(*$*) ->\n safe_bin_read_int32_as_int buf ~pos_ref ~pos:(pos + 1)\n | (*$ Code.char INT64 *)'\\xfc'(*$*) ->\n if arch_sixtyfour then\n safe_bin_read_int64_as_int buf ~pos_ref ~pos:(pos + 1)\n else\n raise_read_error ReadError.Int_overflow pos\n | _ ->\n raise_read_error ReadError.Int_code pos\n[@@ocamlformat \"disable\"]\n\nlet bin_read_float buf ~pos_ref =\n let pos = safe_get_pos buf pos_ref in\n assert_pos pos;\n let next = pos + 8 in\n check_next buf next;\n pos_ref := next;\n (* No error possible either. *)\n Int64.float_of_bits (unsafe_get64le buf pos)\n;;\n\nlet bin_read_int32 buf ~pos_ref =\n let pos = safe_get_pos buf pos_ref in\n assert_pos pos;\n match unsafe_get buf pos with\n | '\\x00'..'\\x7f' as ch ->\n pos_ref := pos + 1;\n Int32.of_int (Char.code ch)\n | (*$ Code.char NEG_INT8 *)'\\xff'(*$*) ->\n Int32.of_int (safe_bin_read_neg_int8 buf ~pos_ref ~pos:(pos + 1))\n | (*$ Code.char INT16 *)'\\xfe'(*$*) ->\n Int32.of_int (safe_bin_read_int16 buf ~pos_ref ~pos:(pos + 1))\n | (*$ Code.char INT32 *)'\\xfd'(*$*) ->\n safe_bin_read_int32 buf ~pos_ref ~pos:(pos + 1)\n | _ ->\n raise_read_error ReadError.Int32_code pos\n[@@ocamlformat \"disable\"]\n\nlet bin_read_int64 buf ~pos_ref =\n let pos = safe_get_pos buf pos_ref in\n assert_pos pos;\n match unsafe_get buf pos with\n | '\\x00'..'\\x7f' as ch ->\n pos_ref := pos + 1;\n Int64.of_int (Char.code ch)\n | (*$ Code.char NEG_INT8 *)'\\xff'(*$*) ->\n Int64.of_int (safe_bin_read_neg_int8 buf ~pos_ref ~pos:(pos + 1))\n | (*$ Code.char INT16 *)'\\xfe'(*$*) ->\n Int64.of_int (safe_bin_read_int16 buf ~pos_ref ~pos:(pos + 1))\n | (*$ Code.char INT32 *)'\\xfd'(*$*) ->\n safe_bin_read_int32_as_int64 buf ~pos_ref ~pos:(pos + 1)\n | (*$ Code.char INT64 *)'\\xfc'(*$*) ->\n safe_bin_read_int64 buf ~pos_ref ~pos:(pos + 1)\n | _ ->\n raise_read_error ReadError.Int64_code pos\n[@@ocamlformat \"disable\"]\n\nlet bin_read_nativeint buf ~pos_ref =\n let pos = safe_get_pos buf pos_ref in\n assert_pos pos;\n match unsafe_get buf pos with\n | '\\x00'..'\\x7f' as ch ->\n pos_ref := pos + 1;\n Nativeint.of_int (Char.code ch)\n | (*$ Code.char NEG_INT8 *)'\\xff'(*$*) ->\n Nativeint.of_int (safe_bin_read_neg_int8 buf ~pos_ref ~pos:(pos + 1))\n | (*$ Code.char INT16 *)'\\xfe'(*$*) ->\n Nativeint.of_int (safe_bin_read_int16 buf ~pos_ref ~pos:(pos + 1))\n | (*$ Code.char INT32 *)'\\xfd'(*$*) ->\n safe_bin_read_int32_as_nativeint buf ~pos_ref ~pos:(pos + 1)\n | (*$ Code.char INT64 *)'\\xfc'(*$*) when arch_sixtyfour ->\n safe_bin_read_int64_as_nativeint buf ~pos_ref ~pos:(pos + 1)\n | _ ->\n raise_read_error ReadError.Nativeint_code pos\n[@@ocamlformat \"disable\"]\n\nlet bin_read_ref bin_read_el buf ~pos_ref =\n let el = bin_read_el buf ~pos_ref in\n ref el\n;;\n\nlet bin_read_lazy bin_read_el buf ~pos_ref =\n let el = bin_read_el buf ~pos_ref in\n Lazy.from_val el\n;;\n\nlet bin_read_option bin_read_el buf ~pos_ref =\n let pos = safe_get_pos buf pos_ref in\n assert_pos pos;\n match unsafe_get buf pos with\n | '\\000' ->\n pos_ref := pos + 1;\n None\n | '\\001' ->\n pos_ref := pos + 1;\n let el = bin_read_el buf ~pos_ref in\n Some el\n | _ -> raise_read_error ReadError.Option_code pos\n;;\n\nlet bin_read_pair bin_read_a bin_read_b buf ~pos_ref =\n let a = bin_read_a buf ~pos_ref in\n let b = bin_read_b buf ~pos_ref in\n a, b\n;;\n\nlet bin_read_triple bin_read_a bin_read_b bin_read_c buf ~pos_ref =\n let a = bin_read_a buf ~pos_ref in\n let b = bin_read_b buf ~pos_ref in\n let c = bin_read_c buf ~pos_ref in\n a, b, c\n;;\n\nlet bin_read_n_rev_list bin_read_el buf ~pos_ref len =\n let rec loop n acc =\n if n = 0 then acc else loop (n - 1) (bin_read_el buf ~pos_ref :: acc)\n in\n loop len []\n;;\n\nlet bin_read_list_with_max_len ~max_len bin_read_el buf ~pos_ref =\n let len = (bin_read_nat0 buf ~pos_ref :> int) in\n if len > max_len then raise_read_error (List_too_long { len; max_len }) !pos_ref;\n let rev_lst = bin_read_n_rev_list bin_read_el buf ~pos_ref len in\n List.rev rev_lst\n;;\n\nlet bin_read_list bin_read_el buf ~pos_ref =\n bin_read_list_with_max_len ~max_len:max_int bin_read_el buf ~pos_ref\n;;\n\nlet dummy_float_buf = create_buf 8\nlet () = ignore (Write.bin_write_float dummy_float_buf ~pos:0 3.1)\n\nlet max_float_array_length =\n if arch_sixtyfour then Sys.max_array_length else Sys.max_array_length / 2\n;;\n\nlet bin_read_float_array buf ~pos_ref =\n let pos = !pos_ref in\n let len = (bin_read_nat0 buf ~pos_ref :> int) in\n if len > max_float_array_length then raise_read_error ReadError.Array_too_long pos;\n let size = len * 8 in\n let pos = !pos_ref in\n let next = pos + size in\n check_next buf next;\n let arr = Array.create_float len in\n unsafe_blit_buf_float_array buf arr ~src_pos:pos ~dst_pos:0 ~len;\n pos_ref := next;\n arr\n;;\n\nlet bin_read_array (type a) bin_read_el buf ~pos_ref =\n if (Obj.magic (bin_read_el : a reader) : float reader) == bin_read_float\n then (Obj.magic (bin_read_float_array buf ~pos_ref : float array) : a array)\n else (\n let start_pos = !pos_ref in\n let len = (bin_read_nat0 buf ~pos_ref :> int) in\n if len = 0\n then [||]\n else (\n if arch_sixtyfour\n then (\n if len > Sys.max_array_length\n then raise_read_error ReadError.Array_too_long start_pos)\n else if len > Sys.max_array_length / 2\n then (\n let maybe_float =\n try\n let el = bin_read_el dummy_float_buf ~pos_ref:(ref 0) in\n Some el\n with\n | _ -> None\n in\n match maybe_float with\n | None ->\n if len > Sys.max_array_length\n then raise_read_error ReadError.Array_too_long start_pos\n | Some el ->\n if Obj.tag (Obj.repr el) = Obj.double_tag || len > Sys.max_array_length\n then raise_read_error ReadError.Array_too_long start_pos);\n let first = bin_read_el buf ~pos_ref in\n let res = Array.make len first in\n for i = 1 to len - 1 do\n let el = bin_read_el buf ~pos_ref in\n Array.unsafe_set res i el\n done;\n res))\n;;\n\nlet bin_read_hashtbl bin_read_key bin_read_val buf ~pos_ref =\n let len = (bin_read_nat0 buf ~pos_ref :> int) in\n let htbl = Hashtbl.create len in\n let read_kv_pair = bin_read_pair bin_read_key bin_read_val in\n let els = bin_read_n_rev_list read_kv_pair buf ~pos_ref len in\n copy_htbl_list htbl els\n;;\n\nexternal buf_of_vec32 : vec32 -> buf = \"%identity\"\nexternal buf_of_vec64 : vec64 -> buf = \"%identity\"\nexternal buf_of_mat32 : mat32 -> buf = \"%identity\"\nexternal buf_of_mat64 : mat64 -> buf = \"%identity\"\n\nlet bin_read_float32_vec buf ~pos_ref =\n let len = (bin_read_nat0 buf ~pos_ref :> int) in\n let size = len * 4 in\n let pos = !pos_ref in\n let next = pos + size in\n check_next buf next;\n let vec = Array1.create float32 fortran_layout len in\n unsafe_blit_buf ~src:buf ~src_pos:pos ~dst:(buf_of_vec32 vec) ~dst_pos:0 ~len:size;\n pos_ref := next;\n vec\n;;\n\nlet bin_read_float64_vec buf ~pos_ref =\n let len = (bin_read_nat0 buf ~pos_ref :> int) in\n let size = len * 8 in\n let pos = !pos_ref in\n let next = pos + size in\n check_next buf next;\n let vec = Array1.create float64 fortran_layout len in\n unsafe_blit_buf ~src:buf ~src_pos:pos ~dst:(buf_of_vec64 vec) ~dst_pos:0 ~len:size;\n pos_ref := next;\n vec\n;;\n\nlet bin_read_vec = bin_read_float64_vec\n\nlet bin_read_float32_mat buf ~pos_ref =\n let len1 = (bin_read_nat0 buf ~pos_ref :> int) in\n let len2 = (bin_read_nat0 buf ~pos_ref :> int) in\n let size = len1 * len2 * 4 in\n let pos = !pos_ref in\n let next = pos + size in\n check_next buf next;\n let mat = Array2.create float32 fortran_layout len1 len2 in\n unsafe_blit_buf ~src:buf ~src_pos:pos ~dst:(buf_of_mat32 mat) ~dst_pos:0 ~len:size;\n pos_ref := next;\n mat\n;;\n\nlet bin_read_float64_mat buf ~pos_ref =\n let len1 = (bin_read_nat0 buf ~pos_ref :> int) in\n let len2 = (bin_read_nat0 buf ~pos_ref :> int) in\n let size = len1 * len2 * 8 in\n let pos = !pos_ref in\n let next = pos + size in\n check_next buf next;\n let mat = Array2.create float64 fortran_layout len1 len2 in\n unsafe_blit_buf ~src:buf ~src_pos:pos ~dst:(buf_of_mat64 mat) ~dst_pos:0 ~len:size;\n pos_ref := next;\n mat\n;;\n\nlet bin_read_mat = bin_read_float64_mat\n\nlet bin_read_bigstring buf ~pos_ref =\n let len = (bin_read_nat0 buf ~pos_ref :> int) in\n let pos = !pos_ref in\n let next = pos + len in\n check_next buf next;\n let str = create_buf len in\n unsafe_blit_buf ~src:buf ~src_pos:pos ~dst:str ~dst_pos:0 ~len;\n pos_ref := next;\n str\n;;\n\nlet bin_read_variant_int buf ~pos_ref =\n let pos = !pos_ref in\n assert_pos pos;\n let next = pos + 4 in\n check_next buf next;\n let n = unsafe_get32le buf pos in\n (* [n] must contain an integer already encoded, i.e. [n = 2 * k + 1]. *)\n if Int32.logand n 1l = 0l\n then raise (Read_error (ReadError.Variant_tag, pos))\n else (\n (* We shift it by one bit to the right se we get back [2 * k + 1] in the end. *)\n pos_ref := next;\n Int32.to_int (Int32.shift_right n 1))\n;;\n\nlet bin_read_int_8bit buf ~pos_ref =\n let pos = safe_get_pos buf pos_ref in\n assert_pos pos;\n pos_ref := pos + 1;\n unsafe_get8 buf pos\n;;\n\nlet bin_read_int_16bit buf ~pos_ref =\n let pos = !pos_ref in\n assert_pos pos;\n let next = pos + 2 in\n check_next buf next;\n pos_ref := next;\n unsafe_get16le_unsigned buf pos\n;;\n\nlet bin_read_int_32bit buf ~pos_ref =\n let pos = !pos_ref in\n assert_pos pos;\n let next = pos + 4 in\n check_next buf next;\n pos_ref := next;\n let n = unsafe_get32le buf pos in\n safe_int_of_int32 pos n\n;;\n\nlet bin_read_int_64bit buf ~pos_ref =\n let pos = !pos_ref in\n assert_pos pos;\n let next = pos + 8 in\n check_next buf next;\n pos_ref := next;\n let n = unsafe_get64le buf pos in\n safe_int_of_int64 pos n\n;;\n\nlet bin_read_int64_bits buf ~pos_ref =\n let pos = !pos_ref in\n assert_pos pos;\n let next = pos + 8 in\n check_next buf next;\n pos_ref := next;\n unsafe_get64le buf pos\n;;\n\nlet bin_read_network16_int buf ~pos_ref =\n let pos = !pos_ref in\n assert_pos pos;\n let next = pos + 2 in\n check_next buf next;\n pos_ref := next;\n unsafe_get16be_unsigned buf pos\n;;\n\nlet bin_read_network32_int buf ~pos_ref =\n let pos = !pos_ref in\n assert_pos pos;\n let next = pos + 4 in\n check_next buf next;\n pos_ref := next;\n let n = unsafe_get32be buf pos in\n safe_int_of_int32 pos n\n;;\n\nlet bin_read_network32_int32 buf ~pos_ref =\n let pos = !pos_ref in\n assert_pos pos;\n let next = pos + 4 in\n check_next buf next;\n pos_ref := next;\n unsafe_get32be buf pos\n;;\n\nlet bin_read_network64_int buf ~pos_ref =\n let pos = !pos_ref in\n assert_pos pos;\n let next = pos + 8 in\n check_next buf next;\n pos_ref := next;\n let n = unsafe_get64be buf pos in\n safe_int_of_int64 pos n\n;;\n\nlet bin_read_network64_int64 buf ~pos_ref =\n let pos = !pos_ref in\n assert_pos pos;\n let next = pos + 8 in\n check_next buf next;\n pos_ref := next;\n unsafe_get64be buf pos\n;;\n\n[%%if\n ocaml_version < (4, 07, 0)]\n\nexternal unsafe_bytes_set32 : bytes -> int -> int32 -> unit = \"%caml_string_set32u\"\nexternal unsafe_bytes_set64 : bytes -> int -> int64 -> unit = \"%caml_string_set64u\"\n\n[%%else]\n\nexternal unsafe_bytes_set32 : bytes -> int -> int32 -> unit = \"%caml_bytes_set32u\"\nexternal unsafe_bytes_set64 : bytes -> int -> int64 -> unit = \"%caml_bytes_set64u\"\n\n[%%endif]\n\nlet bin_read_md5 buf ~pos_ref =\n let pos = !pos_ref in\n assert_pos pos;\n let next = pos + 16 in\n check_next buf next;\n pos_ref := next;\n let res = Bytes.create 16 in\n if arch_sixtyfour\n then (\n let a = unsafe_get64 buf pos in\n let b = unsafe_get64 buf (pos + 8) in\n unsafe_bytes_set64 res 0 a;\n unsafe_bytes_set64 res 8 b)\n else (\n let a = unsafe_get32 buf pos in\n let b = unsafe_get32 buf (pos + 4) in\n let c = unsafe_get32 buf (pos + 8) in\n let d = unsafe_get32 buf (pos + 12) in\n unsafe_bytes_set32 res 0 a;\n unsafe_bytes_set32 res 4 b;\n unsafe_bytes_set32 res 8 c;\n unsafe_bytes_set32 res 12 d);\n Md5_lib.unsafe_of_binary (Bytes.unsafe_to_string res)\n;;\n","include Bin_shape_lib.Std.Shape\n\n(* new base shapes *)\nlet bin_shape_unit = basetype (Uuid.of_string \"unit\") []\nlet bin_shape_bool = basetype (Uuid.of_string \"bool\") []\nlet bin_shape_string = basetype (Uuid.of_string \"string\") []\nlet bin_shape_bytes = basetype (Uuid.of_string \"bytes\") []\nlet bin_shape_char = basetype (Uuid.of_string \"char\") []\nlet bin_shape_float = basetype (Uuid.of_string \"float\") []\nlet bin_shape_int = basetype (Uuid.of_string \"int\") []\nlet bin_shape_int32 = basetype (Uuid.of_string \"int32\") []\nlet bin_shape_int63 = basetype (Uuid.of_string \"int63\") []\nlet bin_shape_int64 = basetype (Uuid.of_string \"int64\") []\nlet bin_shape_nativeint = basetype (Uuid.of_string \"nativeint\") []\nlet bin_shape_nat0 = basetype (Uuid.of_string \"nat0\") []\nlet bin_shape_digest = basetype (Uuid.of_string \"digest\") []\nlet bin_shape_float32_vec = basetype (Uuid.of_string \"float32_vec\") []\nlet bin_shape_float64_vec = basetype (Uuid.of_string \"float64_vec\") []\nlet bin_shape_vec = basetype (Uuid.of_string \"vec\") []\nlet bin_shape_float32_mat = basetype (Uuid.of_string \"float32_mat\") []\nlet bin_shape_float64_mat = basetype (Uuid.of_string \"float64_mat\") []\nlet bin_shape_mat = basetype (Uuid.of_string \"mat\") []\nlet bin_shape_bigstring = basetype (Uuid.of_string \"bigstring\") []\nlet bin_shape_variant_int = basetype (Uuid.of_string \"variant_int\") []\nlet bin_shape_int_8bit = basetype (Uuid.of_string \"int_8bit\") []\nlet bin_shape_int_16bit = basetype (Uuid.of_string \"int_16bit\") []\nlet bin_shape_int_32bit = basetype (Uuid.of_string \"int_32bit\") []\nlet bin_shape_int_64bit = basetype (Uuid.of_string \"int_64bit\") []\nlet bin_shape_int64_bits = basetype (Uuid.of_string \"int64_bits\") []\nlet bin_shape_network16_int = basetype (Uuid.of_string \"network16_int\") []\nlet bin_shape_network32_int = basetype (Uuid.of_string \"network32_int\") []\nlet bin_shape_network32_int32 = basetype (Uuid.of_string \"network32_int32\") []\nlet bin_shape_network64_int = basetype (Uuid.of_string \"network64_int\") []\nlet bin_shape_network64_int64 = basetype (Uuid.of_string \"network64_int64\") []\n\n(* new shape constructors *)\nlet bin_shape_ref x = basetype (Uuid.of_string \"ref\") [ x ]\nlet bin_shape_option x = basetype (Uuid.of_string \"option\") [ x ]\nlet bin_shape_list x = basetype (Uuid.of_string \"list\") [ x ]\nlet bin_shape_array x = basetype (Uuid.of_string \"array\") [ x ]\nlet bin_shape_hashtbl x y = basetype (Uuid.of_string \"hashtbl\") [ x; y ]\n\n(* shape alias *)\nlet bin_shape_float_array = bin_shape_array bin_shape_float\n\n(* shape-constructor aliases *)\nlet bin_shape_lazy x = x\nlet bin_shape_pair x y = tuple [ x; y ]\nlet bin_shape_triple x y z = tuple [ x; y; z ]\n","(* Size: compute size of values in the binary protocol. *)\n\nopen Bigarray\n\nlet arch_sixtyfour = Sys.word_size = 64\n\nopen Common\n\nmodule Maximum = struct\n let bin_size_unit = 1\n let bin_size_bool = 1\n let bin_size_char = 1\n let bin_size_md5 = 16\n let bin_size_int_nat0 = if arch_sixtyfour then 9 else 5\n let bin_size_int_negative = if arch_sixtyfour then 9 else 5\n let bin_size_int = max bin_size_int_nat0 bin_size_int_negative\n let bin_size_float = 8\n let bin_size_int32 = 5\n let bin_size_int64 = 9\n let bin_size_nativeint = bin_size_int\n let bin_size_nat0 = bin_size_int_nat0\n let bin_size_variant_int = 4\n let bin_size_int_8bit = 1\n let bin_size_int_16bit = 2\n let bin_size_int_32bit = 4\n let bin_size_int_64bit = 8\n let bin_size_int64_bits = 8\n let bin_size_network16_int = 2\n let bin_size_network32_int = 4\n let bin_size_network32_int32 = 4\n let bin_size_network64_int = 8\n let bin_size_network64_int64 = 8\nend\n\nmodule Minimum = struct\n let bin_size_unit = Maximum.bin_size_unit\n let bin_size_bool = Maximum.bin_size_bool\n let bin_size_char = Maximum.bin_size_char\n let bin_size_md5 = 16\n let bin_size_int_nat0 = 1\n let bin_size_int_negative = 2\n let bin_size_int = min bin_size_int_nat0 bin_size_int_negative\n let bin_size_float = Maximum.bin_size_float\n let bin_size_int32 = bin_size_int\n let bin_size_int64 = bin_size_int\n let bin_size_nativeint = bin_size_int\n let bin_size_nat0 = 1\n let bin_size_ref = 1\n let bin_size_lazy_t = 1\n let bin_size_option = 1\n let bin_size_pair = 1 + 1\n let bin_size_triple = 1 + 1 + 1\n let bin_size_len = bin_size_nat0\n let bin_size_list = bin_size_len\n let bin_size_array = bin_size_len\n let bin_size_hashtbl = bin_size_len\n let bin_size_string = bin_size_len\n let bin_size_bytes = bin_size_len\n let bin_size_vec = bin_size_len\n let bin_size_float32_vec = bin_size_vec\n let bin_size_float64_vec = bin_size_vec\n let bin_size_mat = bin_size_len + bin_size_len\n let bin_size_float32_mat = bin_size_mat\n let bin_size_float64_mat = bin_size_mat\n let bin_size_bigstring = bin_size_len\n let bin_size_float_array = bin_size_len\n let bin_size_variant_int = Maximum.bin_size_variant_int\n let bin_size_int_8bit = Maximum.bin_size_int_8bit\n let bin_size_int_16bit = Maximum.bin_size_int_16bit\n let bin_size_int_32bit = Maximum.bin_size_int_32bit\n let bin_size_int_64bit = Maximum.bin_size_int_64bit\n let bin_size_int64_bits = Maximum.bin_size_int64_bits\n let bin_size_network16_int = Maximum.bin_size_network16_int\n let bin_size_network32_int = Maximum.bin_size_network32_int\n let bin_size_network32_int32 = Maximum.bin_size_network32_int32\n let bin_size_network64_int = Maximum.bin_size_network64_int\n let bin_size_network64_int64 = Maximum.bin_size_network64_int64\nend\n\ntype 'a sizer = 'a -> int\ntype ('a, 'b) sizer1 = 'a sizer -> 'b sizer\ntype ('a, 'b, 'c) sizer2 = 'a sizer -> ('b, 'c) sizer1\ntype ('a, 'b, 'c, 'd) sizer3 = 'a sizer -> ('b, 'c, 'd) sizer2\n\nlet bin_size_unit () = 1\nlet bin_size_bool _ = 1\n\nlet bin_size_int_nat0 n =\n if n < 0x00000080\n then 1\n else if n < 0x00008000\n then 3\n else if arch_sixtyfour && n >= (* 0x80000000 *) 1 lsl 31\n then 9\n else 5\n;;\n\nlet bin_size_int_negative n =\n if n >= -0x00000080\n then 2\n else if n >= -0x00008000\n then 3\n else if arch_sixtyfour && n < (* -0x80000000 *) -(1 lsl 31)\n then 9\n else 5\n;;\n\nlet bin_size_char _ = 1\nlet bin_size_int n = if n >= 0 then bin_size_int_nat0 n else bin_size_int_negative n\n\nlet bin_size_nat0 nat0 =\n let n = (nat0 : Nat0.t :> int) in\n if n < 0x00000080\n then 1\n else if n < 0x00010000\n then 3\n else if arch_sixtyfour && n >= (* 0x100000000 *) 1 lsl 32\n then 9\n else 5\n;;\n\nlet bin_size_string_or_bytes len =\n let plen = Nat0.unsafe_of_int len in\n let size_len = bin_size_nat0 plen in\n size_len + len\n;;\n\nlet bin_size_string str = bin_size_string_or_bytes (String.length str)\nlet bin_size_bytes str = bin_size_string_or_bytes (Bytes.length str)\nlet bin_size_md5 _ = 16\n\nlet bin_size_float f =\n (* If we just ignore the argument the compiler will still require it to exist and be\n boxed. This means that if for instance we call this for a field of a float record,\n the compiler will allocate the float for nothing.\n\n With this line the compiler really ignores the float. *)\n ignore (truncate f);\n 8\n;;\n\nlet bin_size_int32 =\n if arch_sixtyfour\n then fun n -> bin_size_int (Int32.to_int n)\n else\n fun n ->\n if n >= 0x00008000l || n < -0x00008000l then 5 else bin_size_int (Int32.to_int n)\n;;\n\nlet bin_size_int64 =\n if arch_sixtyfour\n then\n fun n ->\n if n >= 0x80000000L || n < -0x80000000L then 9 else bin_size_int (Int64.to_int n)\n else\n fun n ->\n if n >= 0x80000000L || n < -0x80000000L then 9 else bin_size_int32 (Int64.to_int32 n)\n;;\n\nlet bin_size_nativeint =\n if arch_sixtyfour\n then fun n -> bin_size_int64 (Int64.of_nativeint n)\n else fun n -> bin_size_int32 (Nativeint.to_int32 n)\n;;\n\nlet bin_size_ref bin_size_el r = bin_size_el !r\nlet bin_size_lazy_t bin_size_el lv = bin_size_el (Lazy.force lv)\nlet bin_size_lazy = bin_size_lazy_t\n\nlet bin_size_option bin_size_el = function\n | None -> 1\n | Some v -> 1 + bin_size_el v\n;;\n\nlet bin_size_pair bin_size_a bin_size_b (a, b) = bin_size_a a + bin_size_b b\n\nlet bin_size_triple bin_size_a bin_size_b bin_size_c (a, b, c) =\n bin_size_a a + bin_size_b b + bin_size_c c\n;;\n\nlet bin_size_list bin_size_el lst =\n let rec loop len = function\n | [] -> len\n | h :: t -> loop (len + bin_size_el h) t\n in\n let len = Nat0.unsafe_of_int (List.length lst) in\n let size_len = bin_size_nat0 len in\n loop size_len lst\n;;\n\nlet bin_size_len len =\n let plen = Nat0.unsafe_of_int len in\n bin_size_nat0 plen\n;;\n\nlet bin_size_float_array ar =\n let len = Array.length ar in\n bin_size_len len + (8 * len)\n;;\n\nlet bin_size_array_loop bin_size_el ar ~total_len ~n =\n let total_len_ref = ref total_len in\n for i = 0 to n - 1 do\n let el = Array.unsafe_get ar i in\n total_len_ref := !total_len_ref + bin_size_el el\n done;\n !total_len_ref\n;;\n\nlet bin_size_array (type a) bin_size_el ar =\n if (Obj.magic (bin_size_el : a sizer) : float sizer) == bin_size_float\n then bin_size_float_array (Obj.magic (ar : a array) : float array)\n else (\n let n = Array.length ar in\n let total_len = bin_size_len n in\n bin_size_array_loop bin_size_el ar ~total_len ~n)\n;;\n\nlet bin_size_hashtbl bin_size_key bin_size_val htbl =\n let cnt_ref = ref 0 in\n let coll_htbl k v total_len =\n incr cnt_ref;\n total_len + bin_size_key k + bin_size_val v\n in\n let len = Hashtbl.length htbl in\n let total_len = Hashtbl.fold coll_htbl htbl (bin_size_len len) in\n if !cnt_ref <> len then raise_concurrent_modification \"bin_size_hashtbl\";\n total_len\n;;\n\nlet bin_size_gen_vec vec multiplier =\n let len = Array1.dim vec in\n bin_size_len len + (multiplier * len)\n;;\n\nlet bin_size_float32_vec vec = bin_size_gen_vec vec 4\nlet bin_size_float64_vec vec = bin_size_gen_vec vec 8\nlet bin_size_vec = bin_size_float64_vec\n\nlet bin_size_gen_mat mat multiplier =\n let dim1 = Array2.dim1 mat in\n let dim2 = Array2.dim2 mat in\n let size = dim1 * dim2 in\n bin_size_len dim1 + bin_size_len dim2 + (multiplier * size)\n;;\n\nlet bin_size_float32_mat mat = bin_size_gen_mat mat 4\nlet bin_size_float64_mat mat = bin_size_gen_mat mat 8\nlet bin_size_mat = bin_size_float64_mat\nlet bin_size_bigstring buf = bin_size_gen_vec buf 1\nlet bin_size_variant_int _ = 4\nlet bin_size_int_8bit _ = 1\nlet bin_size_int_16bit _ = 2\nlet bin_size_int_32bit _ = 4\nlet bin_size_int_64bit _ = 8\nlet bin_size_int64_bits _ = 8\nlet bin_size_network16_int _ = 2\nlet bin_size_network32_int _ = 4\nlet bin_size_network32_int32 _ = 4\nlet bin_size_network64_int _ = 8\nlet bin_size_network64_int64 _ = 8\n\nlet bin_size_array_no_length bin_size_el ar =\n bin_size_array_loop bin_size_el ar ~total_len:0 ~n:(Array.length ar)\n;;\n","(* Tp_class: sizers, writers, and readers in records *)\n\ntype 'a writer =\n { size : 'a Size.sizer\n ; write : 'a Write.writer\n }\n\ntype 'a reader =\n { read : 'a Read.reader\n ; vtag_read : (int -> 'a) Read.reader\n }\n\ntype 'a t =\n { shape : Shape.t\n ; writer : 'a writer\n ; reader : 'a reader\n }\n\ntype 'a writer0 = 'a writer\ntype 'a reader0 = 'a reader\ntype 'a t0 = 'a t\n\nmodule S1 = struct\n type ('a, 'b) writer = 'a writer0 -> 'b writer0\n type ('a, 'b) reader = 'a reader0 -> 'b reader0\n type ('a, 'b) t = 'a t0 -> 'b t0\nend\n\nmodule S2 = struct\n type ('a, 'b, 'c) writer = 'a writer0 -> ('b, 'c) S1.writer\n type ('a, 'b, 'c) reader = 'a reader0 -> ('b, 'c) S1.reader\n type ('a, 'b, 'c) t = 'a t0 -> ('b, 'c) S1.t\nend\n\nmodule S3 = struct\n type ('a, 'b, 'c, 'd) writer = 'a writer0 -> ('b, 'c, 'd) S2.writer\n type ('a, 'b, 'c, 'd) reader = 'a reader0 -> ('b, 'c, 'd) S2.reader\n type ('a, 'b, 'c, 'd) t = 'a t0 -> ('b, 'c, 'd) S2.t\nend\n\nlet variant_wrong_type name _buf ~pos_ref _x =\n Common.raise_variant_wrong_type name !pos_ref\n;;\n\n(*$ open Bin_prot_cinaps.Str *)\n(*$ mk_base \"unit\" *)\nlet bin_writer_unit = { size = Size.bin_size_unit; write = Write.bin_write_unit }\n\nlet bin_reader_unit =\n { read = Read.bin_read_unit; vtag_read = variant_wrong_type \"unit\" }\n;;\n\nlet bin_shape_unit = Shape.bin_shape_unit\n\nlet bin_unit =\n { shape = bin_shape_unit; writer = bin_writer_unit; reader = bin_reader_unit }\n;;\n\n(*$ mk_base \"bool\" *)\nlet bin_writer_bool = { size = Size.bin_size_bool; write = Write.bin_write_bool }\n\nlet bin_reader_bool =\n { read = Read.bin_read_bool; vtag_read = variant_wrong_type \"bool\" }\n;;\n\nlet bin_shape_bool = Shape.bin_shape_bool\n\nlet bin_bool =\n { shape = bin_shape_bool; writer = bin_writer_bool; reader = bin_reader_bool }\n;;\n\n(*$ mk_base \"string\" *)\nlet bin_writer_string = { size = Size.bin_size_string; write = Write.bin_write_string }\n\nlet bin_reader_string =\n { read = Read.bin_read_string; vtag_read = variant_wrong_type \"string\" }\n;;\n\nlet bin_shape_string = Shape.bin_shape_string\n\nlet bin_string =\n { shape = bin_shape_string; writer = bin_writer_string; reader = bin_reader_string }\n;;\n\n(*$ mk_base \"bytes\" *)\nlet bin_writer_bytes = { size = Size.bin_size_bytes; write = Write.bin_write_bytes }\n\nlet bin_reader_bytes =\n { read = Read.bin_read_bytes; vtag_read = variant_wrong_type \"bytes\" }\n;;\n\nlet bin_shape_bytes = Shape.bin_shape_bytes\n\nlet bin_bytes =\n { shape = bin_shape_bytes; writer = bin_writer_bytes; reader = bin_reader_bytes }\n;;\n\n(*$ mk_base \"char\" *)\nlet bin_writer_char = { size = Size.bin_size_char; write = Write.bin_write_char }\n\nlet bin_reader_char =\n { read = Read.bin_read_char; vtag_read = variant_wrong_type \"char\" }\n;;\n\nlet bin_shape_char = Shape.bin_shape_char\n\nlet bin_char =\n { shape = bin_shape_char; writer = bin_writer_char; reader = bin_reader_char }\n;;\n\n(*$ mk_base \"int\" *)\nlet bin_writer_int = { size = Size.bin_size_int; write = Write.bin_write_int }\nlet bin_reader_int = { read = Read.bin_read_int; vtag_read = variant_wrong_type \"int\" }\nlet bin_shape_int = Shape.bin_shape_int\nlet bin_int = { shape = bin_shape_int; writer = bin_writer_int; reader = bin_reader_int }\n\n(*$ mk_base \"float\" *)\nlet bin_writer_float = { size = Size.bin_size_float; write = Write.bin_write_float }\n\nlet bin_reader_float =\n { read = Read.bin_read_float; vtag_read = variant_wrong_type \"float\" }\n;;\n\nlet bin_shape_float = Shape.bin_shape_float\n\nlet bin_float =\n { shape = bin_shape_float; writer = bin_writer_float; reader = bin_reader_float }\n;;\n\n(*$ mk_base \"int32\" *)\nlet bin_writer_int32 = { size = Size.bin_size_int32; write = Write.bin_write_int32 }\n\nlet bin_reader_int32 =\n { read = Read.bin_read_int32; vtag_read = variant_wrong_type \"int32\" }\n;;\n\nlet bin_shape_int32 = Shape.bin_shape_int32\n\nlet bin_int32 =\n { shape = bin_shape_int32; writer = bin_writer_int32; reader = bin_reader_int32 }\n;;\n\n(*$ mk_base \"int64\" *)\nlet bin_writer_int64 = { size = Size.bin_size_int64; write = Write.bin_write_int64 }\n\nlet bin_reader_int64 =\n { read = Read.bin_read_int64; vtag_read = variant_wrong_type \"int64\" }\n;;\n\nlet bin_shape_int64 = Shape.bin_shape_int64\n\nlet bin_int64 =\n { shape = bin_shape_int64; writer = bin_writer_int64; reader = bin_reader_int64 }\n;;\n\n(*$ mk_base \"nativeint\" *)\nlet bin_writer_nativeint =\n { size = Size.bin_size_nativeint; write = Write.bin_write_nativeint }\n;;\n\nlet bin_reader_nativeint =\n { read = Read.bin_read_nativeint; vtag_read = variant_wrong_type \"nativeint\" }\n;;\n\nlet bin_shape_nativeint = Shape.bin_shape_nativeint\n\nlet bin_nativeint =\n { shape = bin_shape_nativeint\n ; writer = bin_writer_nativeint\n ; reader = bin_reader_nativeint\n }\n;;\n\n(*$ mk_base \"nat0\" *)\nlet bin_writer_nat0 = { size = Size.bin_size_nat0; write = Write.bin_write_nat0 }\n\nlet bin_reader_nat0 =\n { read = Read.bin_read_nat0; vtag_read = variant_wrong_type \"nat0\" }\n;;\n\nlet bin_shape_nat0 = Shape.bin_shape_nat0\n\nlet bin_nat0 =\n { shape = bin_shape_nat0; writer = bin_writer_nat0; reader = bin_reader_nat0 }\n;;\n\n(*$ mk_base1 \"ref\" *)\nlet bin_writer_ref bin_writer_el =\n { size = (fun v -> Size.bin_size_ref bin_writer_el.size v)\n ; write = (fun buf ~pos v -> Write.bin_write_ref bin_writer_el.write buf ~pos v)\n }\n;;\n\nlet bin_reader_ref bin_reader_el =\n { read = (fun buf ~pos_ref -> Read.bin_read_ref bin_reader_el.read buf ~pos_ref)\n ; vtag_read = variant_wrong_type \"ref\"\n }\n;;\n\nlet bin_shape_ref x1 = Shape.bin_shape_ref x1\n\nlet bin_ref bin_el =\n { shape = bin_shape_ref bin_el.shape\n ; writer = bin_writer_ref bin_el.writer\n ; reader = bin_reader_ref bin_el.reader\n }\n;;\n\n(*$ mk_base1 \"lazy\" *)\nlet bin_writer_lazy bin_writer_el =\n { size = (fun v -> Size.bin_size_lazy bin_writer_el.size v)\n ; write = (fun buf ~pos v -> Write.bin_write_lazy bin_writer_el.write buf ~pos v)\n }\n;;\n\nlet bin_reader_lazy bin_reader_el =\n { read = (fun buf ~pos_ref -> Read.bin_read_lazy bin_reader_el.read buf ~pos_ref)\n ; vtag_read = variant_wrong_type \"lazy\"\n }\n;;\n\nlet bin_shape_lazy x1 = Shape.bin_shape_lazy x1\n\nlet bin_lazy bin_el =\n { shape = bin_shape_lazy bin_el.shape\n ; writer = bin_writer_lazy bin_el.writer\n ; reader = bin_reader_lazy bin_el.reader\n }\n;;\n\n(*$ mk_base1 \"option\" *)\nlet bin_writer_option bin_writer_el =\n { size = (fun v -> Size.bin_size_option bin_writer_el.size v)\n ; write = (fun buf ~pos v -> Write.bin_write_option bin_writer_el.write buf ~pos v)\n }\n;;\n\nlet bin_reader_option bin_reader_el =\n { read = (fun buf ~pos_ref -> Read.bin_read_option bin_reader_el.read buf ~pos_ref)\n ; vtag_read = variant_wrong_type \"option\"\n }\n;;\n\nlet bin_shape_option x1 = Shape.bin_shape_option x1\n\nlet bin_option bin_el =\n { shape = bin_shape_option bin_el.shape\n ; writer = bin_writer_option bin_el.writer\n ; reader = bin_reader_option bin_el.reader\n }\n;;\n\n(*$ mk_base2 \"pair\" *)\nlet bin_writer_pair bin_writer_el1 bin_writer_el2 =\n { size = (fun v -> Size.bin_size_pair bin_writer_el1.size bin_writer_el2.size v)\n ; write =\n (fun buf ~pos v ->\n Write.bin_write_pair bin_writer_el1.write bin_writer_el2.write buf ~pos v)\n }\n;;\n\nlet bin_reader_pair bin_reader_el1 bin_reader_el2 =\n { read =\n (fun buf ~pos_ref ->\n Read.bin_read_pair bin_reader_el1.read bin_reader_el2.read buf ~pos_ref)\n ; vtag_read = variant_wrong_type \"pair\"\n }\n;;\n\nlet bin_shape_pair x1 x2 = Shape.bin_shape_pair x1 x2\n\nlet bin_pair bin_el1 bin_el2 =\n { shape = bin_shape_pair bin_el1.shape bin_el2.shape\n ; writer = bin_writer_pair bin_el1.writer bin_el2.writer\n ; reader = bin_reader_pair bin_el1.reader bin_el2.reader\n }\n;;\n\n(*$ mk_base3 \"triple\" *)\nlet bin_writer_triple bin_writer_el1 bin_writer_el2 bin_writer_el3 =\n { size =\n (fun v ->\n Size.bin_size_triple\n bin_writer_el1.size\n bin_writer_el2.size\n bin_writer_el3.size\n v)\n ; write =\n (fun buf ~pos v ->\n Write.bin_write_triple\n bin_writer_el1.write\n bin_writer_el2.write\n bin_writer_el3.write\n buf\n ~pos\n v)\n }\n;;\n\nlet bin_reader_triple bin_reader_el1 bin_reader_el2 bin_reader_el3 =\n { read =\n (fun buf ~pos_ref ->\n Read.bin_read_triple\n bin_reader_el1.read\n bin_reader_el2.read\n bin_reader_el3.read\n buf\n ~pos_ref)\n ; vtag_read = variant_wrong_type \"triple\"\n }\n;;\n\nlet bin_shape_triple x1 x2 x3 = Shape.bin_shape_triple x1 x2 x3\n\nlet bin_triple bin_el1 bin_el2 bin_el3 =\n { shape = bin_shape_triple bin_el1.shape bin_el2.shape bin_el3.shape\n ; writer = bin_writer_triple bin_el1.writer bin_el2.writer bin_el3.writer\n ; reader = bin_reader_triple bin_el1.reader bin_el2.reader bin_el3.reader\n }\n;;\n\n(*$ mk_base1 \"list\" *)\nlet bin_writer_list bin_writer_el =\n { size = (fun v -> Size.bin_size_list bin_writer_el.size v)\n ; write = (fun buf ~pos v -> Write.bin_write_list bin_writer_el.write buf ~pos v)\n }\n;;\n\nlet bin_reader_list bin_reader_el =\n { read = (fun buf ~pos_ref -> Read.bin_read_list bin_reader_el.read buf ~pos_ref)\n ; vtag_read = variant_wrong_type \"list\"\n }\n;;\n\nlet bin_shape_list x1 = Shape.bin_shape_list x1\n\nlet bin_list bin_el =\n { shape = bin_shape_list bin_el.shape\n ; writer = bin_writer_list bin_el.writer\n ; reader = bin_reader_list bin_el.reader\n }\n;;\n\n(*$ mk_base1 \"array\" *)\nlet bin_writer_array bin_writer_el =\n { size = (fun v -> Size.bin_size_array bin_writer_el.size v)\n ; write = (fun buf ~pos v -> Write.bin_write_array bin_writer_el.write buf ~pos v)\n }\n;;\n\nlet bin_reader_array bin_reader_el =\n { read = (fun buf ~pos_ref -> Read.bin_read_array bin_reader_el.read buf ~pos_ref)\n ; vtag_read = variant_wrong_type \"array\"\n }\n;;\n\nlet bin_shape_array x1 = Shape.bin_shape_array x1\n\nlet bin_array bin_el =\n { shape = bin_shape_array bin_el.shape\n ; writer = bin_writer_array bin_el.writer\n ; reader = bin_reader_array bin_el.reader\n }\n;;\n\n(*$ mk_base2 \"hashtbl\" *)\nlet bin_writer_hashtbl bin_writer_el1 bin_writer_el2 =\n { size = (fun v -> Size.bin_size_hashtbl bin_writer_el1.size bin_writer_el2.size v)\n ; write =\n (fun buf ~pos v ->\n Write.bin_write_hashtbl bin_writer_el1.write bin_writer_el2.write buf ~pos v)\n }\n;;\n\nlet bin_reader_hashtbl bin_reader_el1 bin_reader_el2 =\n { read =\n (fun buf ~pos_ref ->\n Read.bin_read_hashtbl bin_reader_el1.read bin_reader_el2.read buf ~pos_ref)\n ; vtag_read = variant_wrong_type \"hashtbl\"\n }\n;;\n\nlet bin_shape_hashtbl x1 x2 = Shape.bin_shape_hashtbl x1 x2\n\nlet bin_hashtbl bin_el1 bin_el2 =\n { shape = bin_shape_hashtbl bin_el1.shape bin_el2.shape\n ; writer = bin_writer_hashtbl bin_el1.writer bin_el2.writer\n ; reader = bin_reader_hashtbl bin_el1.reader bin_el2.reader\n }\n;;\n\n(*$ mk_base \"float32_vec\" *)\nlet bin_writer_float32_vec =\n { size = Size.bin_size_float32_vec; write = Write.bin_write_float32_vec }\n;;\n\nlet bin_reader_float32_vec =\n { read = Read.bin_read_float32_vec; vtag_read = variant_wrong_type \"float32_vec\" }\n;;\n\nlet bin_shape_float32_vec = Shape.bin_shape_float32_vec\n\nlet bin_float32_vec =\n { shape = bin_shape_float32_vec\n ; writer = bin_writer_float32_vec\n ; reader = bin_reader_float32_vec\n }\n;;\n\n(*$ mk_base \"float64_vec\" *)\nlet bin_writer_float64_vec =\n { size = Size.bin_size_float64_vec; write = Write.bin_write_float64_vec }\n;;\n\nlet bin_reader_float64_vec =\n { read = Read.bin_read_float64_vec; vtag_read = variant_wrong_type \"float64_vec\" }\n;;\n\nlet bin_shape_float64_vec = Shape.bin_shape_float64_vec\n\nlet bin_float64_vec =\n { shape = bin_shape_float64_vec\n ; writer = bin_writer_float64_vec\n ; reader = bin_reader_float64_vec\n }\n;;\n\n(*$ mk_base \"vec\" *)\nlet bin_writer_vec = { size = Size.bin_size_vec; write = Write.bin_write_vec }\nlet bin_reader_vec = { read = Read.bin_read_vec; vtag_read = variant_wrong_type \"vec\" }\nlet bin_shape_vec = Shape.bin_shape_vec\nlet bin_vec = { shape = bin_shape_vec; writer = bin_writer_vec; reader = bin_reader_vec }\n\n(*$ mk_base \"float32_mat\" *)\nlet bin_writer_float32_mat =\n { size = Size.bin_size_float32_mat; write = Write.bin_write_float32_mat }\n;;\n\nlet bin_reader_float32_mat =\n { read = Read.bin_read_float32_mat; vtag_read = variant_wrong_type \"float32_mat\" }\n;;\n\nlet bin_shape_float32_mat = Shape.bin_shape_float32_mat\n\nlet bin_float32_mat =\n { shape = bin_shape_float32_mat\n ; writer = bin_writer_float32_mat\n ; reader = bin_reader_float32_mat\n }\n;;\n\n(*$ mk_base \"float64_mat\" *)\nlet bin_writer_float64_mat =\n { size = Size.bin_size_float64_mat; write = Write.bin_write_float64_mat }\n;;\n\nlet bin_reader_float64_mat =\n { read = Read.bin_read_float64_mat; vtag_read = variant_wrong_type \"float64_mat\" }\n;;\n\nlet bin_shape_float64_mat = Shape.bin_shape_float64_mat\n\nlet bin_float64_mat =\n { shape = bin_shape_float64_mat\n ; writer = bin_writer_float64_mat\n ; reader = bin_reader_float64_mat\n }\n;;\n\n(*$ mk_base \"mat\" *)\nlet bin_writer_mat = { size = Size.bin_size_mat; write = Write.bin_write_mat }\nlet bin_reader_mat = { read = Read.bin_read_mat; vtag_read = variant_wrong_type \"mat\" }\nlet bin_shape_mat = Shape.bin_shape_mat\nlet bin_mat = { shape = bin_shape_mat; writer = bin_writer_mat; reader = bin_reader_mat }\n\n(*$ mk_base \"bigstring\" *)\nlet bin_writer_bigstring =\n { size = Size.bin_size_bigstring; write = Write.bin_write_bigstring }\n;;\n\nlet bin_reader_bigstring =\n { read = Read.bin_read_bigstring; vtag_read = variant_wrong_type \"bigstring\" }\n;;\n\nlet bin_shape_bigstring = Shape.bin_shape_bigstring\n\nlet bin_bigstring =\n { shape = bin_shape_bigstring\n ; writer = bin_writer_bigstring\n ; reader = bin_reader_bigstring\n }\n;;\n\n(*$*)\ntype float_array = float array\n\n(*$ mk_base \"float_array\" *)\nlet bin_writer_float_array =\n { size = Size.bin_size_float_array; write = Write.bin_write_float_array }\n;;\n\nlet bin_reader_float_array =\n { read = Read.bin_read_float_array; vtag_read = variant_wrong_type \"float_array\" }\n;;\n\nlet bin_shape_float_array = Shape.bin_shape_float_array\n\nlet bin_float_array =\n { shape = bin_shape_float_array\n ; writer = bin_writer_float_array\n ; reader = bin_reader_float_array\n }\n;;\n\n(*$ mk_base \"variant_int\" *)\nlet bin_writer_variant_int =\n { size = Size.bin_size_variant_int; write = Write.bin_write_variant_int }\n;;\n\nlet bin_reader_variant_int =\n { read = Read.bin_read_variant_int; vtag_read = variant_wrong_type \"variant_int\" }\n;;\n\nlet bin_shape_variant_int = Shape.bin_shape_variant_int\n\nlet bin_variant_int =\n { shape = bin_shape_variant_int\n ; writer = bin_writer_variant_int\n ; reader = bin_reader_variant_int\n }\n;;\n\n(*$ mk_base \"int_8bit\" *)\nlet bin_writer_int_8bit =\n { size = Size.bin_size_int_8bit; write = Write.bin_write_int_8bit }\n;;\n\nlet bin_reader_int_8bit =\n { read = Read.bin_read_int_8bit; vtag_read = variant_wrong_type \"int_8bit\" }\n;;\n\nlet bin_shape_int_8bit = Shape.bin_shape_int_8bit\n\nlet bin_int_8bit =\n { shape = bin_shape_int_8bit\n ; writer = bin_writer_int_8bit\n ; reader = bin_reader_int_8bit\n }\n;;\n\n(*$ mk_base \"int_16bit\" *)\nlet bin_writer_int_16bit =\n { size = Size.bin_size_int_16bit; write = Write.bin_write_int_16bit }\n;;\n\nlet bin_reader_int_16bit =\n { read = Read.bin_read_int_16bit; vtag_read = variant_wrong_type \"int_16bit\" }\n;;\n\nlet bin_shape_int_16bit = Shape.bin_shape_int_16bit\n\nlet bin_int_16bit =\n { shape = bin_shape_int_16bit\n ; writer = bin_writer_int_16bit\n ; reader = bin_reader_int_16bit\n }\n;;\n\n(*$ mk_base \"int_32bit\" *)\nlet bin_writer_int_32bit =\n { size = Size.bin_size_int_32bit; write = Write.bin_write_int_32bit }\n;;\n\nlet bin_reader_int_32bit =\n { read = Read.bin_read_int_32bit; vtag_read = variant_wrong_type \"int_32bit\" }\n;;\n\nlet bin_shape_int_32bit = Shape.bin_shape_int_32bit\n\nlet bin_int_32bit =\n { shape = bin_shape_int_32bit\n ; writer = bin_writer_int_32bit\n ; reader = bin_reader_int_32bit\n }\n;;\n\n(*$ mk_base \"int_64bit\" *)\nlet bin_writer_int_64bit =\n { size = Size.bin_size_int_64bit; write = Write.bin_write_int_64bit }\n;;\n\nlet bin_reader_int_64bit =\n { read = Read.bin_read_int_64bit; vtag_read = variant_wrong_type \"int_64bit\" }\n;;\n\nlet bin_shape_int_64bit = Shape.bin_shape_int_64bit\n\nlet bin_int_64bit =\n { shape = bin_shape_int_64bit\n ; writer = bin_writer_int_64bit\n ; reader = bin_reader_int_64bit\n }\n;;\n\n(*$ mk_base \"int64_bits\" *)\nlet bin_writer_int64_bits =\n { size = Size.bin_size_int64_bits; write = Write.bin_write_int64_bits }\n;;\n\nlet bin_reader_int64_bits =\n { read = Read.bin_read_int64_bits; vtag_read = variant_wrong_type \"int64_bits\" }\n;;\n\nlet bin_shape_int64_bits = Shape.bin_shape_int64_bits\n\nlet bin_int64_bits =\n { shape = bin_shape_int64_bits\n ; writer = bin_writer_int64_bits\n ; reader = bin_reader_int64_bits\n }\n;;\n\n(*$ mk_base \"network16_int\" *)\nlet bin_writer_network16_int =\n { size = Size.bin_size_network16_int; write = Write.bin_write_network16_int }\n;;\n\nlet bin_reader_network16_int =\n { read = Read.bin_read_network16_int; vtag_read = variant_wrong_type \"network16_int\" }\n;;\n\nlet bin_shape_network16_int = Shape.bin_shape_network16_int\n\nlet bin_network16_int =\n { shape = bin_shape_network16_int\n ; writer = bin_writer_network16_int\n ; reader = bin_reader_network16_int\n }\n;;\n\n(*$ mk_base \"network32_int\" *)\nlet bin_writer_network32_int =\n { size = Size.bin_size_network32_int; write = Write.bin_write_network32_int }\n;;\n\nlet bin_reader_network32_int =\n { read = Read.bin_read_network32_int; vtag_read = variant_wrong_type \"network32_int\" }\n;;\n\nlet bin_shape_network32_int = Shape.bin_shape_network32_int\n\nlet bin_network32_int =\n { shape = bin_shape_network32_int\n ; writer = bin_writer_network32_int\n ; reader = bin_reader_network32_int\n }\n;;\n\n(*$ mk_base \"network32_int32\" *)\nlet bin_writer_network32_int32 =\n { size = Size.bin_size_network32_int32; write = Write.bin_write_network32_int32 }\n;;\n\nlet bin_reader_network32_int32 =\n { read = Read.bin_read_network32_int32\n ; vtag_read = variant_wrong_type \"network32_int32\"\n }\n;;\n\nlet bin_shape_network32_int32 = Shape.bin_shape_network32_int32\n\nlet bin_network32_int32 =\n { shape = bin_shape_network32_int32\n ; writer = bin_writer_network32_int32\n ; reader = bin_reader_network32_int32\n }\n;;\n\n(*$ mk_base \"network64_int\" *)\nlet bin_writer_network64_int =\n { size = Size.bin_size_network64_int; write = Write.bin_write_network64_int }\n;;\n\nlet bin_reader_network64_int =\n { read = Read.bin_read_network64_int; vtag_read = variant_wrong_type \"network64_int\" }\n;;\n\nlet bin_shape_network64_int = Shape.bin_shape_network64_int\n\nlet bin_network64_int =\n { shape = bin_shape_network64_int\n ; writer = bin_writer_network64_int\n ; reader = bin_reader_network64_int\n }\n;;\n\n(*$ mk_base \"network64_int64\" *)\nlet bin_writer_network64_int64 =\n { size = Size.bin_size_network64_int64; write = Write.bin_write_network64_int64 }\n;;\n\nlet bin_reader_network64_int64 =\n { read = Read.bin_read_network64_int64\n ; vtag_read = variant_wrong_type \"network64_int64\"\n }\n;;\n\nlet bin_shape_network64_int64 = Shape.bin_shape_network64_int64\n\nlet bin_network64_int64 =\n { shape = bin_shape_network64_int64\n ; writer = bin_writer_network64_int64\n ; reader = bin_reader_network64_int64\n }\n;;\n\n(*$*)\nlet bin_writer_array_no_length bin_writer_el =\n { size =\n (fun v -> (Size.bin_size_array_no_length [@warning \"-3\"]) bin_writer_el.size v)\n ; write =\n (fun buf ~pos v ->\n (Write.bin_write_array_no_length [@warning \"-3\"]) bin_writer_el.write buf ~pos v)\n }\n;;\n\n(* Conversion of binable types *)\n\nlet cnv_writer cnv tp_class =\n { size = (fun v -> tp_class.size (cnv v))\n ; write = (fun buf ~pos v -> tp_class.write buf ~pos (cnv v))\n }\n;;\n\nlet cnv_reader cnv tp_class =\n { read = (fun buf ~pos_ref -> cnv (tp_class.read buf ~pos_ref))\n ; vtag_read = (fun buf ~pos_ref vtag -> cnv (tp_class.vtag_read buf ~pos_ref vtag))\n }\n;;\n\nlet cnv for_shape for_writer for_reader tp_class =\n { shape = for_shape tp_class.shape\n ; writer = cnv_writer for_writer tp_class.writer\n ; reader = cnv_reader for_reader tp_class.reader\n }\n;;\n","(* Utils: utility functions for user convenience *)\n\nopen Common\nopen Size\nopen Type_class\ninclude Utils_intf\n\nlet size_header_length = 8\nlet bin_write_size_header = Write.bin_write_int_64bit\nlet bin_read_size_header = Read.bin_read_int_64bit\n\nlet bin_dump ?(header = false) writer v =\n let buf, pos, pos_len =\n let v_len = writer.size v in\n if header\n then (\n let tot_len = v_len + size_header_length in\n let buf = create_buf tot_len in\n let pos = bin_write_size_header buf ~pos:0 v_len in\n buf, pos, pos + v_len)\n else (\n let buf = create_buf v_len in\n buf, 0, v_len)\n in\n let pos = writer.write buf ~pos v in\n if pos = pos_len\n then buf\n else failwith \"Bin_prot.Utils.bin_dump: size changed during writing\"\n;;\n\n(* Reading from streams *)\n\nlet bin_read_stream ?max_size ~read reader =\n let buf = create_buf size_header_length in\n read buf ~pos:0 ~len:size_header_length;\n let pos_ref = ref 0 in\n let len = bin_read_size_header buf ~pos_ref in\n match max_size with\n | Some max_size when len > max_size ->\n failwith\n (Printf.sprintf\n \"Bin_prot.Utils.bin_read_stream: size exceeds max_size: %d > %d\"\n len\n max_size)\n | _ ->\n let buf = if len > size_header_length then create_buf len else buf in\n read buf ~pos:0 ~len;\n pos_ref := 0;\n let res = reader.read buf ~pos_ref in\n if !pos_ref = len\n then res\n else (\n let msg =\n Printf.sprintf\n \"Bin_prot.Utils.bin_read_stream: protocol lied about length of value: \\\n expected %d, received %d\"\n len\n !pos_ref\n in\n failwith msg)\n;;\n\n(* Conversion of binable types *)\n\nmodule Of_minimal (S : Binable.Minimal.S) : Binable.S with type t := S.t = struct\n include S\n\n let bin_writer_t = { size = bin_size_t; write = bin_write_t }\n let bin_reader_t = { read = bin_read_t; vtag_read = __bin_read_t__ }\n let bin_t = { shape = bin_shape_t; writer = bin_writer_t; reader = bin_reader_t }\nend\n\nlet maybe_annotate_shape maybe_uuid shape =\n match maybe_uuid with\n | None -> shape\n | Some uuid -> Shape.annotate uuid shape\n;;\n\nmodule Make_binable_gen (S : sig\n include Make_binable_without_uuid_spec\n\n val maybe_caller_identity : Shape.Uuid.t option\n end) =\nstruct\n include Of_minimal (struct\n module B = S.Binable\n\n type t = S.t\n\n let bin_shape_t = maybe_annotate_shape S.maybe_caller_identity B.bin_shape_t\n let bin_size_t t = B.bin_size_t (S.to_binable t)\n let bin_write_t buf ~pos t = B.bin_write_t buf ~pos (S.to_binable t)\n let bin_read_t buf ~pos_ref = S.of_binable (B.bin_read_t buf ~pos_ref)\n let __bin_read_t__ buf ~pos_ref n = S.of_binable (B.__bin_read_t__ buf ~pos_ref n)\n end)\nend\n\nmodule Make_binable1_gen (S : sig\n include Make_binable1_without_uuid_spec\n\n val maybe_caller_identity : Shape.Uuid.t option\n end) =\nstruct\n module B = S.Binable\n\n let bin_shape_t bin_shape_el =\n maybe_annotate_shape S.maybe_caller_identity (B.bin_shape_t bin_shape_el)\n ;;\n\n let bin_size_t bin_size_el t = B.bin_size_t bin_size_el (S.to_binable t)\n\n let bin_write_t bin_write_el buf ~pos t =\n B.bin_write_t bin_write_el buf ~pos (S.to_binable t)\n ;;\n\n let bin_read_t bin_read_el buf ~pos_ref =\n S.of_binable (B.bin_read_t bin_read_el buf ~pos_ref)\n ;;\n\n let __bin_read_t__ bin_read_el buf ~pos_ref n =\n S.of_binable (B.__bin_read_t__ bin_read_el buf ~pos_ref n)\n ;;\n\n let bin_writer_t bin_writer =\n { size = (fun v -> bin_size_t bin_writer.size v)\n ; write = (fun buf ~pos v -> bin_write_t bin_writer.write buf ~pos v)\n }\n ;;\n\n let bin_reader_t bin_reader =\n { read = (fun buf ~pos_ref -> bin_read_t bin_reader.read buf ~pos_ref)\n ; vtag_read =\n (fun _buf ~pos_ref _n ->\n raise_variant_wrong_type \"Bin_prot.Utils.Make_binable1.bin_reader_t\" !pos_ref)\n }\n ;;\n\n let bin_t type_class =\n { shape = bin_shape_t type_class.shape\n ; writer = bin_writer_t type_class.writer\n ; reader = bin_reader_t type_class.reader\n }\n ;;\nend\n\nmodule Make_binable2_gen (S : sig\n include Make_binable2_without_uuid_spec\n\n val maybe_caller_identity : Shape.Uuid.t option\n end) =\nstruct\n module B = S.Binable\n\n let bin_shape_t bin_shape_el1 bin_shape_el2 =\n maybe_annotate_shape\n S.maybe_caller_identity\n (B.bin_shape_t bin_shape_el1 bin_shape_el2)\n ;;\n\n let bin_size_t bin_size_el1 bin_size_el2 t =\n B.bin_size_t bin_size_el1 bin_size_el2 (S.to_binable t)\n ;;\n\n let bin_write_t bin_write_el1 bin_write_el2 buf ~pos t =\n B.bin_write_t bin_write_el1 bin_write_el2 buf ~pos (S.to_binable t)\n ;;\n\n let bin_read_t bin_read_el1 bin_read_el2 buf ~pos_ref =\n S.of_binable (B.bin_read_t bin_read_el1 bin_read_el2 buf ~pos_ref)\n ;;\n\n let __bin_read_t__ bin_read_el1 bin_read_el2 buf ~pos_ref n =\n S.of_binable (B.__bin_read_t__ bin_read_el1 bin_read_el2 buf ~pos_ref n)\n ;;\n\n let bin_writer_t bin_writer1 bin_writer2 =\n { size = (fun v -> bin_size_t bin_writer1.size bin_writer2.size v)\n ; write =\n (fun buf ~pos v -> bin_write_t bin_writer1.write bin_writer2.write buf ~pos v)\n }\n ;;\n\n let bin_reader_t bin_reader1 bin_reader2 =\n { read =\n (fun buf ~pos_ref -> bin_read_t bin_reader1.read bin_reader2.read buf ~pos_ref)\n ; vtag_read =\n (fun _buf ~pos_ref _n ->\n raise_variant_wrong_type \"Bin_prot.Utils.Make_binable2.bin_reader_t\" !pos_ref)\n }\n ;;\n\n let bin_t type_class1 type_class2 =\n { shape = bin_shape_t type_class1.shape type_class2.shape\n ; writer = bin_writer_t type_class1.writer type_class2.writer\n ; reader = bin_reader_t type_class1.reader type_class2.reader\n }\n ;;\nend\n\nmodule Make_binable3_gen (S : sig\n include Make_binable3_without_uuid_spec\n\n val maybe_caller_identity : Shape.Uuid.t option\n end) =\nstruct\n module B = S.Binable\n\n let bin_shape_t bin_shape_el1 bin_shape_el2 bin_shape_el3 =\n maybe_annotate_shape\n S.maybe_caller_identity\n (B.bin_shape_t bin_shape_el1 bin_shape_el2 bin_shape_el3)\n ;;\n\n let bin_size_t bin_size_el1 bin_size_el2 bin_size_el3 t =\n B.bin_size_t bin_size_el1 bin_size_el2 bin_size_el3 (S.to_binable t)\n ;;\n\n let bin_write_t bin_write_el1 bin_write_el2 bin_write_el3 buf ~pos t =\n B.bin_write_t bin_write_el1 bin_write_el2 bin_write_el3 buf ~pos (S.to_binable t)\n ;;\n\n let bin_read_t bin_read_el1 bin_read_el2 bin_read_el3 buf ~pos_ref =\n S.of_binable (B.bin_read_t bin_read_el1 bin_read_el2 bin_read_el3 buf ~pos_ref)\n ;;\n\n let __bin_read_t__ bin_read_el1 bin_read_el2 bin_read_el3 buf ~pos_ref n =\n S.of_binable (B.__bin_read_t__ bin_read_el1 bin_read_el2 bin_read_el3 buf ~pos_ref n)\n ;;\n\n let bin_writer_t bin_writer1 bin_writer2 bin_writer3 =\n { size = (fun v -> bin_size_t bin_writer1.size bin_writer2.size bin_writer3.size v)\n ; write =\n (fun buf ~pos v ->\n bin_write_t bin_writer1.write bin_writer2.write bin_writer3.write buf ~pos v)\n }\n ;;\n\n let bin_reader_t bin_reader1 bin_reader2 bin_reader3 =\n { read =\n (fun buf ~pos_ref ->\n bin_read_t bin_reader1.read bin_reader2.read bin_reader3.read buf ~pos_ref)\n ; vtag_read =\n (fun _buf ~pos_ref _n ->\n raise_variant_wrong_type \"Bin_prot.Utils.Make_binable3.bin_reader_t\" !pos_ref)\n }\n ;;\n\n let bin_t type_class1 type_class2 type_class3 =\n { shape = bin_shape_t type_class1.shape type_class2.shape type_class3.shape\n ; writer = bin_writer_t type_class1.writer type_class2.writer type_class3.writer\n ; reader = bin_reader_t type_class1.reader type_class2.reader type_class3.reader\n }\n ;;\nend\n\nmodule Make_binable_with_uuid (S : Make_binable_with_uuid_spec) =\n Make_binable_gen (struct\n include S\n\n let maybe_caller_identity = Some S.caller_identity\n end)\n\nmodule Make_binable1_with_uuid (S : Make_binable1_with_uuid_spec) =\n Make_binable1_gen (struct\n include S\n\n let maybe_caller_identity = Some S.caller_identity\n end)\n\nmodule Make_binable2_with_uuid (S : Make_binable2_with_uuid_spec) =\n Make_binable2_gen (struct\n include S\n\n let maybe_caller_identity = Some S.caller_identity\n end)\n\nmodule Make_binable3_with_uuid (S : Make_binable3_with_uuid_spec) =\n Make_binable3_gen (struct\n include S\n\n let maybe_caller_identity = Some S.caller_identity\n end)\n\nmodule Make_binable_without_uuid (S : Make_binable_without_uuid_spec) =\n Make_binable_gen (struct\n include S\n\n let maybe_caller_identity = None\n end)\n\nmodule Make_binable1_without_uuid (S : Make_binable1_without_uuid_spec) =\n Make_binable1_gen (struct\n include S\n\n let maybe_caller_identity = None\n end)\n\nmodule Make_binable2_without_uuid (S : Make_binable2_without_uuid_spec) =\n Make_binable2_gen (struct\n include S\n\n let maybe_caller_identity = None\n end)\n\nmodule Make_binable3_without_uuid (S : Make_binable3_without_uuid_spec) =\n Make_binable3_gen (struct\n include S\n\n let maybe_caller_identity = None\n end)\n\nmodule Make_binable = Make_binable_without_uuid\nmodule Make_binable1 = Make_binable1_without_uuid\nmodule Make_binable2 = Make_binable2_without_uuid\nmodule Make_binable3 = Make_binable3_without_uuid\n\nlet with_module_name f ~module_name function_name =\n match module_name with\n | None -> f function_name\n | Some module_name -> Printf.ksprintf f \"%s.%s\" module_name function_name\n;;\n\nlet raise_concurrent_modification = with_module_name raise_concurrent_modification\n\nlet raise_read_too_much =\n with_module_name\n (Printf.ksprintf failwith \"%s: tried to read more elements than available\")\n;;\n\nlet raise_read_not_enough =\n with_module_name (Printf.ksprintf failwith \"%s: didn't read all elements\")\n;;\n\nmodule Make_iterable_binable (S : Make_iterable_binable_spec) = struct\n open S\n\n let bin_shape_t =\n Shape.(\n basetype\n caller_identity\n [ basetype\n (Uuid.of_string \"6592371a-4994-11e6-923a-7748e4182764\")\n [ S.bin_shape_el ]\n ])\n ;;\n\n let bin_size_t t =\n let size_ref = ref 0 in\n let cnt_ref = ref 0 in\n iter t ~f:(fun el ->\n size_ref := !size_ref + bin_size_el el;\n incr cnt_ref);\n let len = length t in\n if !cnt_ref = len\n then bin_size_nat0 (Nat0.unsafe_of_int len) + !size_ref\n else raise_concurrent_modification ~module_name \"bin_size_t\"\n ;;\n\n let bin_write_t buf ~pos t =\n let len = length t in\n let plen = Nat0.unsafe_of_int len in\n let pos_ref = ref (Write.bin_write_nat0 buf ~pos plen) in\n let cnt_ref = ref 0 in\n iter t ~f:(fun el ->\n pos_ref := bin_write_el buf ~pos:!pos_ref el;\n incr cnt_ref);\n if !cnt_ref = len\n then !pos_ref\n else raise_concurrent_modification ~module_name \"bin_write_t\"\n ;;\n\n let bin_read_t buf ~pos_ref =\n let len = (Read.bin_read_nat0 buf ~pos_ref :> int) in\n let idx = ref 0 in\n let next () =\n if !idx >= len then raise_read_too_much ~module_name \"bin_read_t\";\n incr idx;\n bin_read_el buf ~pos_ref\n in\n let result = init ~len ~next in\n if !idx < len then raise_read_not_enough ~module_name \"bin_read_t\";\n result\n ;;\n\n let __bin_read_t__ _buf ~pos_ref _n = raise_variant_wrong_type \"t\" !pos_ref\n let bin_writer_t = { size = bin_size_t; write = bin_write_t }\n let bin_reader_t = { read = bin_read_t; vtag_read = __bin_read_t__ }\n let bin_t = { shape = bin_shape_t; writer = bin_writer_t; reader = bin_reader_t }\nend\n\nmodule Make_iterable_binable1 (S : Make_iterable_binable1_spec) = struct\n open S\n\n let bin_shape_t t =\n Shape.(\n basetype\n caller_identity\n [ basetype\n (Uuid.of_string \"ac8a9ff4-4994-11e6-9a1b-9fb4e933bd9d\")\n [ S.bin_shape_el t ]\n ])\n ;;\n\n let bin_size_t bin_size_a t =\n let size_ref = ref 0 in\n let cnt_ref = ref 0 in\n iter t ~f:(fun el ->\n size_ref := !size_ref + bin_size_el bin_size_a el;\n incr cnt_ref);\n let len = length t in\n if !cnt_ref = len\n then bin_size_nat0 (Nat0.unsafe_of_int len) + !size_ref\n else raise_concurrent_modification ~module_name \"bin_size_t\"\n ;;\n\n let bin_write_t bin_write_a buf ~pos t =\n let len = length t in\n let plen = Nat0.unsafe_of_int len in\n let pos_ref = ref (Write.bin_write_nat0 buf ~pos plen) in\n let cnt_ref = ref 0 in\n iter t ~f:(fun el ->\n pos_ref := bin_write_el bin_write_a buf ~pos:!pos_ref el;\n incr cnt_ref);\n if !cnt_ref = len\n then !pos_ref\n else raise_concurrent_modification ~module_name \"bin_write_t\"\n ;;\n\n let bin_read_t bin_read_a buf ~pos_ref =\n let len = (Read.bin_read_nat0 buf ~pos_ref :> int) in\n let idx = ref 0 in\n let next () =\n if !idx >= len then raise_read_too_much ~module_name \"bin_read_t\";\n incr idx;\n bin_read_el bin_read_a buf ~pos_ref\n in\n let result = init ~len ~next in\n if !idx < len then raise_read_not_enough ~module_name \"bin_read_t\";\n result\n ;;\n\n let __bin_read_t__ _bin_read_a _buf ~pos_ref _n = raise_variant_wrong_type \"t\" !pos_ref\n\n let bin_writer_t bin_writer =\n { size = (fun v -> bin_size_t bin_writer.size v)\n ; write = (fun buf ~pos v -> bin_write_t bin_writer.write buf ~pos v)\n }\n ;;\n\n let bin_reader_t bin_reader =\n { read = (fun buf ~pos_ref -> bin_read_t bin_reader.read buf ~pos_ref)\n ; vtag_read = (fun buf ~pos_ref _n -> __bin_read_t__ bin_reader.read buf ~pos_ref _n)\n }\n ;;\n\n let bin_t type_class =\n { shape = bin_shape_t type_class.shape\n ; writer = bin_writer_t type_class.writer\n ; reader = bin_reader_t type_class.reader\n }\n ;;\nend\n\nmodule Make_iterable_binable2 (S : Make_iterable_binable2_spec) = struct\n open S\n\n let bin_shape_t t1 t2 =\n Shape.(\n basetype\n caller_identity\n [ basetype\n (Uuid.of_string \"b4e54ad2-4994-11e6-b8df-87c2997f9f52\")\n [ S.bin_shape_el t1 t2 ]\n ])\n ;;\n\n let bin_size_t bin_size_a bin_size_b t =\n let size_ref = ref 0 in\n let cnt_ref = ref 0 in\n iter t ~f:(fun el ->\n size_ref := !size_ref + bin_size_el bin_size_a bin_size_b el;\n incr cnt_ref);\n let len = length t in\n if !cnt_ref = len\n then bin_size_nat0 (Nat0.unsafe_of_int len) + !size_ref\n else raise_concurrent_modification ~module_name \"bin_size_t\"\n ;;\n\n let bin_write_t bin_write_a bin_write_b buf ~pos t =\n let len = length t in\n let plen = Nat0.unsafe_of_int len in\n let pos_ref = ref (Write.bin_write_nat0 buf ~pos plen) in\n let cnt_ref = ref 0 in\n iter t ~f:(fun el ->\n pos_ref := bin_write_el bin_write_a bin_write_b buf ~pos:!pos_ref el;\n incr cnt_ref);\n if !cnt_ref = len\n then !pos_ref\n else raise_concurrent_modification ~module_name \"bin_write_t\"\n ;;\n\n let bin_read_t bin_read_a bin_read_b buf ~pos_ref =\n let len = (Read.bin_read_nat0 buf ~pos_ref :> int) in\n let idx = ref 0 in\n let next () =\n if !idx >= len then raise_read_too_much ~module_name \"bin_read_t\";\n incr idx;\n bin_read_el bin_read_a bin_read_b buf ~pos_ref\n in\n let result = init ~len ~next in\n if !idx < len then raise_read_not_enough ~module_name \"bin_read_t\";\n result\n ;;\n\n let __bin_read_t__ _bin_read_a _bin_read_b _buf ~pos_ref _n =\n raise_variant_wrong_type \"t\" !pos_ref\n ;;\n\n let bin_writer_t bin_writer1 bin_writer2 =\n { size = (fun v -> bin_size_t bin_writer1.size bin_writer2.size v)\n ; write =\n (fun buf ~pos v -> bin_write_t bin_writer1.write bin_writer2.write buf ~pos v)\n }\n ;;\n\n let bin_reader_t bin_reader1 bin_reader2 =\n { read =\n (fun buf ~pos_ref -> bin_read_t bin_reader1.read bin_reader2.read buf ~pos_ref)\n ; vtag_read =\n (fun buf ~pos_ref n ->\n __bin_read_t__ bin_reader1.read bin_reader2.read buf ~pos_ref n)\n }\n ;;\n\n let bin_t type_class1 type_class2 =\n { shape = bin_shape_t type_class1.shape type_class2.shape\n ; writer = bin_writer_t type_class1.writer type_class2.writer\n ; reader = bin_reader_t type_class1.reader type_class2.reader\n }\n ;;\nend\n\nmodule Make_iterable_binable3 (S : Make_iterable_binable3_spec) = struct\n open S\n\n let bin_shape_t t1 t2 t3 =\n Shape.(\n basetype\n caller_identity\n [ basetype\n (Uuid.of_string \"f2112eda-e7d7-11e6-bb36-072e9ce159db\")\n [ S.bin_shape_el t1 t2 t3 ]\n ])\n ;;\n\n let bin_size_t bin_size_a bin_size_b bin_size_c t =\n let size_ref = ref 0 in\n let cnt_ref = ref 0 in\n iter t ~f:(fun el ->\n size_ref := !size_ref + bin_size_el bin_size_a bin_size_b bin_size_c el;\n incr cnt_ref);\n let len = length t in\n if !cnt_ref = len\n then bin_size_nat0 (Nat0.unsafe_of_int len) + !size_ref\n else raise_concurrent_modification ~module_name \"bin_size_t\"\n ;;\n\n let bin_write_t bin_write_a bin_write_b bin_write_c buf ~pos t =\n let len = length t in\n let plen = Nat0.unsafe_of_int len in\n let pos_ref = ref (Write.bin_write_nat0 buf ~pos plen) in\n let cnt_ref = ref 0 in\n iter t ~f:(fun el ->\n pos_ref := bin_write_el bin_write_a bin_write_b bin_write_c buf ~pos:!pos_ref el;\n incr cnt_ref);\n if !cnt_ref = len\n then !pos_ref\n else raise_concurrent_modification ~module_name \"bin_write_t\"\n ;;\n\n let bin_read_t bin_read_a bin_read_b bin_read_c buf ~pos_ref =\n let len = (Read.bin_read_nat0 buf ~pos_ref :> int) in\n let idx = ref 0 in\n let next () =\n if !idx >= len then raise_read_too_much ~module_name \"bin_read_t\";\n incr idx;\n bin_read_el bin_read_a bin_read_b bin_read_c buf ~pos_ref\n in\n let result = init ~len ~next in\n if !idx < len then raise_read_not_enough ~module_name \"bin_read_t\";\n result\n ;;\n\n let __bin_read_t__ _bin_read_a _bin_read_b _bin_read_c _buf ~pos_ref _n =\n raise_variant_wrong_type \"t\" !pos_ref\n ;;\n\n let bin_writer_t bin_writer1 bin_writer2 bin_writer3 =\n { size = (fun v -> bin_size_t bin_writer1.size bin_writer2.size bin_writer3.size v)\n ; write =\n (fun buf ~pos v ->\n bin_write_t bin_writer1.write bin_writer2.write bin_writer3.write buf ~pos v)\n }\n ;;\n\n let bin_reader_t bin_reader1 bin_reader2 bin_reader3 =\n { read =\n (fun buf ~pos_ref ->\n bin_read_t bin_reader1.read bin_reader2.read bin_reader3.read buf ~pos_ref)\n ; vtag_read =\n (fun buf ~pos_ref n ->\n __bin_read_t__\n bin_reader1.read\n bin_reader2.read\n bin_reader3.read\n buf\n ~pos_ref\n n)\n }\n ;;\n\n let bin_t type_class1 type_class2 type_class3 =\n { shape = bin_shape_t type_class1.shape type_class2.shape type_class3.shape\n ; writer = bin_writer_t type_class1.writer type_class2.writer type_class3.writer\n ; reader = bin_reader_t type_class1.reader type_class2.reader type_class3.reader\n }\n ;;\nend\n","(**\n This module defines default converters for the types defined in the OCaml\n standard library.\n*)\n\ninclude Size\n\nlet bin_unit = Type_class.bin_unit\nlet bin_shape_unit = Type_class.bin_shape_unit\nlet bin_writer_unit = Type_class.bin_writer_unit\nlet bin_write_unit = Write.bin_write_unit\nlet bin_reader_unit = Type_class.bin_reader_unit\nlet bin_read_unit = Read.bin_read_unit\n\nlet __bin_read_unit__ _buf ~pos_ref _vint =\n Common.raise_variant_wrong_type \"unit\" !pos_ref\n;;\n\nlet bin_bool = Type_class.bin_bool\nlet bin_shape_bool = Type_class.bin_shape_bool\nlet bin_writer_bool = Type_class.bin_writer_bool\nlet bin_write_bool = Write.bin_write_bool\nlet bin_reader_bool = Type_class.bin_reader_bool\nlet bin_read_bool = Read.bin_read_bool\n\nlet __bin_read_bool__ _buf ~pos_ref _vint =\n Common.raise_variant_wrong_type \"bool\" !pos_ref\n;;\n\nlet bin_string = Type_class.bin_string\nlet bin_shape_string = Type_class.bin_shape_string\nlet bin_writer_string = Type_class.bin_writer_string\nlet bin_write_string = Write.bin_write_string\nlet bin_reader_string = Type_class.bin_reader_string\nlet bin_read_string = Read.bin_read_string\n\nlet __bin_read_string__ _buf ~pos_ref _vint =\n Common.raise_variant_wrong_type \"string\" !pos_ref\n;;\n\nlet bin_bytes = Type_class.bin_bytes\nlet bin_shape_bytes = Type_class.bin_shape_bytes\nlet bin_writer_bytes = Type_class.bin_writer_bytes\nlet bin_write_bytes = Write.bin_write_bytes\nlet bin_reader_bytes = Type_class.bin_reader_bytes\nlet bin_read_bytes = Read.bin_read_bytes\n\nlet __bin_read_bytes__ _buf ~pos_ref _vint =\n Common.raise_variant_wrong_type \"bytes\" !pos_ref\n;;\n\nlet bin_char = Type_class.bin_char\nlet bin_shape_char = Type_class.bin_shape_char\nlet bin_writer_char = Type_class.bin_writer_char\nlet bin_write_char = Write.bin_write_char\nlet bin_reader_char = Type_class.bin_reader_char\nlet bin_read_char = Read.bin_read_char\n\nlet __bin_read_char__ _buf ~pos_ref _vint =\n Common.raise_variant_wrong_type \"char\" !pos_ref\n;;\n\nlet bin_int = Type_class.bin_int\nlet bin_shape_int = Type_class.bin_shape_int\nlet bin_writer_int = Type_class.bin_writer_int\nlet bin_write_int = Write.bin_write_int\nlet bin_reader_int = Type_class.bin_reader_int\nlet bin_read_int = Read.bin_read_int\nlet __bin_read_int__ _buf ~pos_ref _vint = Common.raise_variant_wrong_type \"int\" !pos_ref\nlet bin_float = Type_class.bin_float\nlet bin_shape_float = Type_class.bin_shape_float\nlet bin_writer_float = Type_class.bin_writer_float\nlet bin_write_float = Write.bin_write_float\nlet bin_reader_float = Type_class.bin_reader_float\nlet bin_read_float = Read.bin_read_float\n\nlet __bin_read_float__ _buf ~pos_ref _vint =\n Common.raise_variant_wrong_type \"float\" !pos_ref\n;;\n\ntype float_array = float array\n\nlet bin_float_array = Type_class.bin_float_array\nlet bin_shape_float_array = Type_class.bin_shape_float_array\nlet bin_writer_float_array = Type_class.bin_writer_float_array\nlet bin_write_float_array = Write.bin_write_float_array\nlet bin_reader_float_array = Type_class.bin_reader_float_array\nlet bin_read_float_array = Read.bin_read_float_array\n\nlet __bin_read_float_array__ _buf ~pos_ref _vint =\n Common.raise_variant_wrong_type \"float_array\" !pos_ref\n;;\n\nlet bin_int32 = Type_class.bin_int32\nlet bin_shape_int32 = Type_class.bin_shape_int32\nlet bin_writer_int32 = Type_class.bin_writer_int32\nlet bin_write_int32 = Write.bin_write_int32\nlet bin_reader_int32 = Type_class.bin_reader_int32\nlet bin_read_int32 = Read.bin_read_int32\n\nlet __bin_read_int32__ _buf ~pos_ref _vint =\n Common.raise_variant_wrong_type \"int32\" !pos_ref\n;;\n\nlet bin_int64 = Type_class.bin_int64\nlet bin_shape_int64 = Type_class.bin_shape_int64\nlet bin_writer_int64 = Type_class.bin_writer_int64\nlet bin_write_int64 = Write.bin_write_int64\nlet bin_reader_int64 = Type_class.bin_reader_int64\nlet bin_read_int64 = Read.bin_read_int64\n\nlet __bin_read_int64__ _buf ~pos_ref _vint =\n Common.raise_variant_wrong_type \"int64\" !pos_ref\n;;\n\nlet bin_nativeint = Type_class.bin_nativeint\nlet bin_shape_nativeint = Type_class.bin_shape_nativeint\nlet bin_writer_nativeint = Type_class.bin_writer_nativeint\nlet bin_write_nativeint = Write.bin_write_nativeint\nlet bin_reader_nativeint = Type_class.bin_reader_nativeint\nlet bin_read_nativeint = Read.bin_read_nativeint\n\nlet __bin_read_nativeint__ _buf ~pos_ref _vint =\n Common.raise_variant_wrong_type \"nativeint\" !pos_ref\n;;\n\nlet bin_ref = Type_class.bin_ref\nlet bin_shape_ref = Type_class.bin_shape_ref\nlet bin_writer_ref = Type_class.bin_writer_ref\nlet bin_write_ref = Write.bin_write_ref\nlet bin_reader_ref = Type_class.bin_reader_ref\nlet bin_read_ref = Read.bin_read_ref\n\nlet __bin_read_ref__ _f _buf ~pos_ref _vint =\n Common.raise_variant_wrong_type \"ref\" !pos_ref\n;;\n\nlet bin_lazy_t = Type_class.bin_lazy\nlet bin_shape_lazy_t = Type_class.bin_shape_lazy\nlet bin_writer_lazy_t = Type_class.bin_writer_lazy\nlet bin_write_lazy_t = Write.bin_write_lazy\nlet bin_reader_lazy_t = Type_class.bin_reader_lazy\nlet bin_read_lazy_t = Read.bin_read_lazy\n\nlet __bin_read_lazy_t__ _f _buf ~pos_ref _vint =\n Common.raise_variant_wrong_type \"lazy\" !pos_ref\n;;\n\nlet bin_lazy = Type_class.bin_lazy\nlet bin_shape_lazy = Type_class.bin_shape_lazy\nlet bin_writer_lazy = Type_class.bin_writer_lazy\nlet bin_write_lazy = Write.bin_write_lazy\nlet bin_reader_lazy = Type_class.bin_reader_lazy\nlet bin_read_lazy = Read.bin_read_lazy\n\nlet __bin_read_lazy__ _f _buf ~pos_ref _vint =\n Common.raise_variant_wrong_type \"lazy\" !pos_ref\n;;\n\nlet bin_option = Type_class.bin_option\nlet bin_shape_option = Type_class.bin_shape_option\nlet bin_writer_option = Type_class.bin_writer_option\nlet bin_write_option = Write.bin_write_option\nlet bin_reader_option = Type_class.bin_reader_option\nlet bin_read_option = Read.bin_read_option\n\nlet __bin_read_option__ _f _buf ~pos_ref _vint =\n Common.raise_variant_wrong_type \"option\" !pos_ref\n;;\n\nlet bin_list = Type_class.bin_list\nlet bin_shape_list = Type_class.bin_shape_list\nlet bin_writer_list = Type_class.bin_writer_list\nlet bin_write_list = Write.bin_write_list\nlet bin_reader_list = Type_class.bin_reader_list\nlet bin_read_list = Read.bin_read_list\n\nlet __bin_read_list__ _f _buf ~pos_ref _vint =\n Common.raise_variant_wrong_type \"list\" !pos_ref\n;;\n\nlet bin_array = Type_class.bin_array\nlet bin_shape_array = Type_class.bin_shape_array\nlet bin_writer_array = Type_class.bin_writer_array\nlet bin_write_array = Write.bin_write_array\nlet bin_reader_array = Type_class.bin_reader_array\nlet bin_read_array = Read.bin_read_array\n\nlet __bin_read_array__ _f _buf ~pos_ref _vint =\n Common.raise_variant_wrong_type \"array\" !pos_ref\n;;\n\nlet bin_hashtbl = Type_class.bin_hashtbl\nlet bin_shape_hashtbl = Type_class.bin_shape_hashtbl\nlet bin_writer_hashtbl = Type_class.bin_writer_hashtbl\nlet bin_write_hashtbl = Write.bin_write_hashtbl\nlet bin_reader_hashtbl = Type_class.bin_reader_hashtbl\nlet bin_read_hashtbl = Read.bin_read_hashtbl\n\nlet __bin_read_hashtbl__ _f _g _buf ~pos_ref _vint =\n Common.raise_variant_wrong_type \"hashtbl\" !pos_ref\n;;\n\nlet bin_bigstring = Type_class.bin_bigstring\nlet bin_shape_bigstring = Type_class.bin_shape_bigstring\nlet bin_writer_bigstring = Type_class.bin_writer_bigstring\nlet bin_write_bigstring = Write.bin_write_bigstring\nlet bin_reader_bigstring = Type_class.bin_reader_bigstring\nlet bin_read_bigstring = Read.bin_read_bigstring\n\nlet __bin_read_bigstring__ _buf ~pos_ref _vint =\n Common.raise_variant_wrong_type \"bigstring\" !pos_ref\n;;\n\nlet bin_mat = Type_class.bin_mat\nlet bin_shape_mat = Type_class.bin_shape_mat\nlet bin_writer_mat = Type_class.bin_writer_mat\nlet bin_write_mat = Write.bin_write_mat\nlet bin_reader_mat = Type_class.bin_reader_mat\nlet bin_read_mat = Read.bin_read_mat\nlet __bin_read_mat__ _buf ~pos_ref _vint = Common.raise_variant_wrong_type \"mat\" !pos_ref\nlet bin_float32_mat = Type_class.bin_float32_mat\nlet bin_shape_float32_mat = Type_class.bin_shape_float32_mat\nlet bin_writer_float32_mat = Type_class.bin_writer_float32_mat\nlet bin_write_float32_mat = Write.bin_write_float32_mat\nlet bin_reader_float32_mat = Type_class.bin_reader_float32_mat\nlet bin_read_float32_mat = Read.bin_read_float32_mat\n\nlet __bin_read_float32_mat__ _buf ~pos_ref _vint =\n Common.raise_variant_wrong_type \"float32_mat\" !pos_ref\n;;\n\nlet bin_float64_mat = Type_class.bin_float64_mat\nlet bin_shape_float64_mat = Type_class.bin_shape_float64_mat\nlet bin_writer_float64_mat = Type_class.bin_writer_float64_mat\nlet bin_write_float64_mat = Write.bin_write_float64_mat\nlet bin_reader_float64_mat = Type_class.bin_reader_float64_mat\nlet bin_read_float64_mat = Read.bin_read_float64_mat\n\nlet __bin_read_float64_mat__ _buf ~pos_ref _vint =\n Common.raise_variant_wrong_type \"float64_mat\" !pos_ref\n;;\n\nlet bin_vec = Type_class.bin_vec\nlet bin_shape_vec = Type_class.bin_shape_vec\nlet bin_writer_vec = Type_class.bin_writer_vec\nlet bin_write_vec = Write.bin_write_vec\nlet bin_reader_vec = Type_class.bin_reader_vec\nlet bin_read_vec = Read.bin_read_vec\nlet __bin_read_vec__ _buf ~pos_ref _vint = Common.raise_variant_wrong_type \"vec\" !pos_ref\nlet bin_float32_vec = Type_class.bin_float32_vec\nlet bin_shape_float32_vec = Type_class.bin_shape_float32_vec\nlet bin_writer_float32_vec = Type_class.bin_writer_float32_vec\nlet bin_write_float32_vec = Write.bin_write_float32_vec\nlet bin_reader_float32_vec = Type_class.bin_reader_float32_vec\nlet bin_read_float32_vec = Read.bin_read_float32_vec\n\nlet __bin_read_float32_vec__ _buf ~pos_ref _vint =\n Common.raise_variant_wrong_type \"float32_vec\" !pos_ref\n;;\n\nlet bin_float64_vec = Type_class.bin_float64_vec\nlet bin_shape_float64_vec = Type_class.bin_shape_float64_vec\nlet bin_writer_float64_vec = Type_class.bin_writer_float64_vec\nlet bin_write_float64_vec = Write.bin_write_float64_vec\nlet bin_reader_float64_vec = Type_class.bin_reader_float64_vec\nlet bin_read_float64_vec = Read.bin_read_float64_vec\n\nlet __bin_read_float64_vec__ _buf ~pos_ref _vint =\n Common.raise_variant_wrong_type \"float64_vec\" !pos_ref\n;;\n","module type S = sig\n val pre_test_hook : unit -> unit\nend\n\nlet pre_test_hook = ignore\n","[%%import\n \"config.h\"]\n\nopen! Base\n\n[%%ifdef\n JSC_ARCH_SIXTYFOUR]\n\nexternal nanoseconds_since_unix_epoch_or_zero\n : unit\n -> Int63.t\n = \"time_now_nanoseconds_since_unix_epoch_or_zero\"\n[@@noalloc]\n\n[%%else]\n\nexternal nanoseconds_since_unix_epoch_or_zero\n : unit\n -> Int63.t\n = \"time_now_nanoseconds_since_unix_epoch_or_zero\"\n\n[%%endif]\n\n[%%ifdef\n JSC_POSIX_TIMERS]\n\nlet[@cold] gettime_failed () = failwith \"clock_gettime(CLOCK_REALTIME) failed\"\n\n[%%else]\n\nlet[@cold] gettime_failed () = failwith \"gettimeofday failed\"\n\n[%%endif]\n\nlet nanoseconds_since_unix_epoch () =\n let t = nanoseconds_since_unix_epoch_or_zero () in\n if Int63.( <> ) t Int63.zero then t else gettime_failed ()\n;;\n","module Test_result = struct\n type t = Success | Failure | Error\n\n let to_exit_code = function\n | Success -> 0\n | Failure -> 2\n | Error -> 1\n ;;\n\n let to_string = function\n | Success -> \"success\"\n | Failure -> \"failure\"\n | Error -> \"error\"\n ;;\n\n let combine t1 t2 =\n match t1, t2 with\n | Success, Success -> Success\n | Error , _ | _, Error -> Error\n | Failure, _ | _, Failure -> Failure\n ;;\n\n let combine_all ts = List.fold_left combine Success ts\nend\n\nlet parse_argv argv l f msg =\n try\n Arg.parse_argv argv l f msg\n with\n | Arg.Bad msg -> Printf.eprintf \"%s\" msg; exit 1\n | Arg.Help msg -> Printf.printf \"%s\" msg; exit 0\n;;\n\ntype descr = string\nlet test_modules_ran = ref 0\nlet test_modules_failed = ref 0\nlet tests_ran = ref 0\nlet tests_failed = ref 0\nlet dynamic_lib : string option ref = ref None\ntype filename = string\ntype line_number = int\ntype start_pos = int\ntype end_pos = int\ntype config = (module Inline_test_config.S)\ntype 'a test_function_args\n = config:config\n -> descr:descr\n -> tags:string list\n -> filename:filename\n -> line_number:line_number\n -> start_pos:start_pos\n -> end_pos:end_pos\n -> 'a\n\nmodule Tag_predicate = struct\n type t =\n { required_tags : string list\n ; dropped_tags : string list\n }\n\n let enable_everything = { required_tags = []; dropped_tags = [] }\n\n let drop t tag =\n { dropped_tags = tag :: t.dropped_tags\n ; required_tags = List.filter ((<>) tag) t.required_tags\n }\n\n let require t tag =\n { dropped_tags = List.filter ((<>) tag) t.dropped_tags\n ; required_tags = tag :: t.required_tags\n }\n\n let entire_module_disabled t ~partial_tags:tags =\n List.exists (fun dropped -> List.mem dropped tags) t.dropped_tags\n\n let disabled t ~complete_tags:tags =\n List.exists (fun req -> not (List.mem req tags)) t.required_tags\n || List.exists (fun dropped -> List.mem dropped tags) t.dropped_tags\nend\n\n\ntype which_tests =\n { libname : string\n ; only_test_location : (filename * line_number option * bool ref) list\n ; which_tags : Tag_predicate.t\n }\ntype test_mode =\n { which_tests : which_tests\n ; what_to_do :\n [ `Run_partition of string option\n | `List_partitions\n ]\n }\n\nmodule Action : sig\n type t = [\n | `Ignore\n | `Test_mode of test_mode\n ]\n val get : unit -> t\n val set : t -> unit\nend = struct\n type t = [\n | `Ignore\n | `Test_mode of test_mode\n ]\n let action : t ref = ref `Ignore\n let force_drop =\n try ignore (Sys.getenv \"FORCE_DROP_INLINE_TEST\" : string); true\n with Not_found -> false\n let get () =\n (* This is useful when compiling to javascript.\n Js_of_ocaml can statically evaluate [Sys.getenv \"FORCE_DROP_INLINE_TEST\"]\n and inline the result ([`Ignore]) whenever [get ()] is called.\n Unit tests can then be treated as deadcode since the argument [f] of the [test]\n function below is never used. *)\n if force_drop\n then `Ignore\n else !action\n\n let set v = action := v\nend\n\nmodule Partition : sig\n val found_test : unit -> unit\n val set_current : string -> unit\n val is_current : string option -> bool\n val all : unit -> string list\nend = struct\n let all = Hashtbl.create 23\n let current = ref \"\" let set_current x = current := x\n let found_test () =\n if !current <> \"\" && not (Hashtbl.mem all !current) then\n Hashtbl.add all !current ()\n ;;\n let is_current = function\n | None -> true\n | Some p -> p = !current\n ;;\n let all () =\n List.sort String.compare\n (Hashtbl.fold (fun k () acc -> k :: acc) all [])\n ;;\nend\n\nmodule Module_context = struct\n module T = struct\n type one_module =\n { descr : string\n ; tags : string list\n }\n\n type t = one_module list\n\n let descr t = List.map (fun m -> m.descr) t\n let tags t = List.concat (List.map (fun m -> m.tags) t)\n end\n\n let current : T.t ref = ref []\n\n let with_ ~descr ~tags f =\n let prev = !current in\n current := { T. descr; tags } :: prev;\n try\n f ();\n current := prev;\n with e ->\n current := prev;\n raise e\n\n let current_descr () = T.descr !current\n let current_tags () = T.tags !current\nend\n\nlet verbose = ref false\nlet strict = ref false\nlet show_counts = ref false\nlet list_test_names = ref false\nlet delayed_errors = ref []\nlet stop_on_error = ref false\n\nlet log = ref None\n\nlet time_sec = ref 0.\n\nlet use_color = ref true\nlet in_place = ref false\nlet diff_command = ref None\nlet source_tree_root = ref None\nlet allow_output_patterns = ref false\n\nlet displayed_descr descr filename line start_pos end_pos =\n Printf.sprintf \"File %S, line %d, characters %d-%d%s\"\n filename line start_pos end_pos descr\nlet parse_descr str =\n try Some (Scanf.sscanf str \" File %S , line %d , characters %d - %d %!\"\n (fun file line _start_pos _end_pos -> file, Some line))\n with _ ->\n try Some (Scanf.sscanf str \" File %S , line %d %!\" (fun file line -> file, Some line))\n with _ ->\n try Some (Scanf.sscanf str \" File %S %!\" (fun file -> file, None))\n with _ -> None\n\nlet indent ~by = function\n | \"\" -> \"\"\n | str ->\n let len = String.length str in\n let buf = Buffer.create (len * 2) in\n let indentation = String.make by ' ' in\n Buffer.add_string buf indentation;\n for i = 0 to len - 1; do\n Buffer.add_char buf str.[i];\n if str.[i] = '\\n' && i <> len - 1 then Buffer.add_string buf indentation\n done;\n Buffer.contents buf\n\nlet backtrace_indented ~by =\n let str = Printexc.get_backtrace () in\n indent str ~by\n\nlet () =\n match Array.to_list Sys.argv with\n | name :: \"inline-test-runner\" :: lib :: rest\n when Base.Exported_for_specific_uses.am_testing -> begin\n (* when we see this argument, we switch to test mode *)\n let tests = ref [] in\n let list_partitions = ref false in\n let partition = ref None in\n let tag_predicate = ref Tag_predicate.enable_everything in\n parse_argv (Array.of_list (name :: rest)) (Arg.align [\n \"-list-test-names\", Arg.Unit (fun () -> list_test_names := true; verbose := true),\n \" Do not run tests but show what would have been run\";\n \"-list-partitions\", Arg.Unit (fun () -> list_partitions := true),\n \" Lists all the partitions that contain at least one test or test_module\";\n \"-partition\", Arg.String (fun i -> partition := Some i),\n \" Only run the tests in the given partition\";\n \"-verbose\", Arg.Set verbose, \" Show the tests as they run\";\n \"-stop-on-error\", Arg.Set stop_on_error, \" Run tests only up to the first error \\\n (doesn't work for expect tests)\";\n \"-strict\", Arg.Set strict, \" End with an error if no tests were run\";\n \"-show-counts\", Arg.Set show_counts, \" Show the number of tests ran\";\n \"-log\", Arg.Unit (fun () ->\n (try Sys.remove \"inline_tests.log\" with _ -> ());\n log := Some (open_out \"inline_tests.log\")\n ), \" Log the tests run in inline_tests.log\";\n \"-drop-tag\", Arg.String (fun s ->\n tag_predicate := Tag_predicate.drop !tag_predicate s\n ), \"tag Only run tests not tagged with [tag] (overrides previous -require-tag)\";\n \"-require-tag\", Arg.String (fun s ->\n tag_predicate := Tag_predicate.require !tag_predicate s\n ), \"tag Only run tests tagged with [tag] (overrides previous -drop-tag)\";\n \"-only-test\", Arg.String (fun s ->\n let filename, index =\n match parse_descr s with\n | Some (file, index) -> file, index\n | None ->\n if String.contains s ':' then\n let i = String.index s ':' in\n let filename = String.sub s 0 i in\n let index_string = String.sub s (i + 1) (String.length s - i - 1) in\n let index =\n try int_of_string index_string\n with Failure _ ->\n Printf.eprintf\n \"Argument %s doesn't fit the format filename[:line_number]\\n%!\" s;\n exit 1\n in\n filename, Some index\n else\n s, None\n in\n tests := (filename, index, ref false) :: !tests\n ), \"location Run only the tests specified by all the -only-test options.\n Locations can be one of these forms:\n - file.ml\n - file.ml:line_number\n - File \\\"file.ml\\\"\n - File \\\"file.ml\\\", line 23\n - File \\\"file.ml\\\", line 23, characters 2-3\";\n \"-no-color\", Arg.Clear use_color, \" Summarize tests without using color\";\n \"-in-place\", Arg.Set in_place, \" Update expect tests in place\";\n \"-diff-cmd\", Arg.String (fun s -> diff_command := Some s),\n \" Diff command for tests that require diffing (use - to disable diffing)\";\n \"-allow-output-patterns\", Arg.Set allow_output_patterns,\n \" Allow output patterns in tests expectations\";\n \"-source-tree-root\", Arg.String (fun s -> source_tree_root := Some s),\n \" Path to the root of the source tree\"\n ]) (fun anon ->\n Printf.eprintf \"%s: unexpected anonymous argument %s\\n%!\" name anon;\n exit 1\n ) (Printf.sprintf \"%s %s %s [args]\" name \"inline-test-runner\" lib);\n Action.set (\n `Test_mode\n { which_tests =\n { libname = lib\n ; only_test_location = !tests;\n which_tags = !tag_predicate;\n }\n ; what_to_do =\n if !list_partitions\n then `List_partitions\n else `Run_partition !partition\n })\n end\n | _ ->\n ()\n\nlet am_test_runner =\n match Action.get () with\n | `Test_mode _ -> true\n | `Ignore -> false\n\nlet am_running_inline_test_env_var =\n (* for approximate compatibility, given that the variable is not exactly equivalent\n to what PPX_INLINE_TEST_LIB_AM_RUNNING_INLINE_TEST used to be *)\n \"TESTING_FRAMEWORK\"\n\n(* This value is deprecated in principle, in favor of Core_kernel.am_running_test, so\n we're going to live with the ugly pattern match. *)\nlet am_running_inline_test =\n match Sys.getenv \"PPX_INLINE_TEST_LIB_AM_RUNNING_INLINE_TEST\" with\n | (_ : string) -> true (* for compatibility with people setting this variable directly *)\n | exception Not_found ->\n match Sys.getenv am_running_inline_test_env_var with\n | \"inline-test\" -> true\n | exception Not_found -> false\n | _ -> false\n\nlet testing =\n if am_test_runner\n then `Testing `Am_test_runner\n else\n (if am_running_inline_test\n then `Testing `Am_child_of_test_runner\n else `Not_testing)\n\nlet wall_time_clock_ns () =\n Time_now.nanoseconds_since_unix_epoch ()\n\n\nlet time_without_resetting_random_seeds f =\n let before_ns = wall_time_clock_ns () in\n Base.Exn.protect ~finally:(fun[@inline] () ->\n time_sec := Base.Int63.(wall_time_clock_ns () - before_ns |> to_float) /. 1e9)\n ~f\n\n\nlet saved_caml_random_state = lazy (Caml.Random.State.make [| 100; 200; 300 |])\nlet saved_base_random_state = lazy (Base.Random.State.make [| 111; 222; 333 |])\n\nlet time_and_reset_random_seeds f =\n let caml_random_state = Caml.Random.get_state () in\n let base_random_state = Base.Random.State.copy Base.Random.State.default in\n Caml.Random.set_state (Lazy.force saved_caml_random_state);\n Base.Random.set_state (Lazy.force saved_base_random_state);\n let result = time_without_resetting_random_seeds f in\n Caml.Random.set_state caml_random_state;\n Base.Random.set_state base_random_state;\n result\n\nlet string_of_module_descr () =\n String.concat \"\" (\n List.map (fun s -> \" in TES\" ^ \"T_MODULE at \" ^ String.uncapitalize_ascii s ^ \"\\n\")\n (Module_context.current_descr ())\n )\n\nlet position_match def_filename def_line_number l =\n List.exists (fun (filename, line_number_opt, used) ->\n let position_start =\n String.length def_filename - String.length filename in\n let found =\n position_start >= 0 &&\n let end_of_def_filename =\n String.sub def_filename\n position_start\n (String.length filename) in\n end_of_def_filename = filename\n && (position_start = 0 || def_filename.[position_start - 1] = '/')\n && (match line_number_opt with\n | None -> true\n | Some line_number -> def_line_number = line_number)\n in\n if found then used := true;\n found\n ) l\n\nlet print_delayed_errors () =\n match List.rev !delayed_errors with\n | [] -> ()\n | _ :: _ as delayed_errors ->\n Printf.eprintf \"\\n%s\\n%!\" (String.make 70 '=');\n List.iter (fun message ->\n Printf.eprintf \"%s%!\" message\n ) delayed_errors\n\nlet eprintf_or_delay fmt =\n Printf.ksprintf (fun s ->\n if !verbose then delayed_errors := s :: !delayed_errors\n else Printf.eprintf \"%s%!\" s;\n if !stop_on_error then begin\n print_delayed_errors ();\n exit 2\n end\n ) fmt\n\nlet add_hooks ((module C) : config) f =\n fun () -> C.pre_test_hook (); f ()\n\nlet[@inline never] test ~config ~descr ~tags ~filename:def_filename ~line_number:def_line_number\n ~start_pos ~end_pos f =\n match Action.get () with\n | `Ignore -> ()\n | `Test_mode { which_tests = { libname; only_test_location; which_tags }; what_to_do } ->\n let f = add_hooks config f in\n let descr () = displayed_descr descr def_filename def_line_number start_pos end_pos in\n let complete_tags = tags @ Module_context.current_tags () in\n let should_run =\n Some libname = !dynamic_lib\n && begin match only_test_location with\n | [] -> true\n | _ :: _ -> position_match def_filename def_line_number only_test_location\n end\n && not (Tag_predicate.disabled which_tags ~complete_tags)\n in\n if should_run then begin\n match what_to_do with\n | `List_partitions -> Partition.found_test ()\n | `Run_partition partition ->\n if Partition.is_current partition then begin\n let descr = descr () in\n incr tests_ran;\n begin match !log with\n | None -> ()\n | Some ch -> Printf.fprintf ch \"%s\\n%s\" descr (string_of_module_descr ())\n end;\n if !verbose then begin\n Printf.printf \"%s%!\" descr\n end;\n let print_time_taken () =\n (* If !list_test_names, this is is a harmless zero. *)\n if !verbose then Printf.printf \" (%.3f sec)\\n%!\" !time_sec;\n in\n try\n let failed = not !list_test_names && not (time_and_reset_random_seeds f) in\n print_time_taken ();\n if failed then begin\n incr tests_failed;\n eprintf_or_delay \"%s is false.\\n%s\\n%!\" descr\n (string_of_module_descr ())\n end\n with exn ->\n print_time_taken ();\n let backtrace = backtrace_indented ~by:2 in\n incr tests_failed;\n let exn_str = Printexc.to_string exn in\n let sep = if String.contains exn_str '\\n' then \"\\n\" else \" \" in\n eprintf_or_delay \"%s threw%s%s.\\n%s%s\\n%!\" descr sep exn_str\n backtrace (string_of_module_descr ())\n end\n end\n\nlet set_lib_and_partition static_lib partition =\n match !dynamic_lib with\n | Some _ ->\n (* possible if the interface is used explicitly or if we happen to dynlink something\n that contain tests *)\n ()\n | None ->\n dynamic_lib := Some static_lib;\n match Action.get () with\n | `Ignore -> ()\n | `Test_mode { which_tests; what_to_do } ->\n if which_tests.libname = static_lib then begin\n let requires_partition =\n match what_to_do with\n | `List_partitions | `Run_partition (Some _) -> true\n | `Run_partition None -> false\n in\n if partition = \"\" && requires_partition\n then failwith \"ppx_inline_test: cannot use -list-partition or -partition \\\n without specifying a partition at preprocessing time\"\n else Partition.set_current partition\n end\n\nlet unset_lib static_lib =\n match !dynamic_lib with\n | None ->\n (* not giving an error, because when some annoying people put pa_ounit in their list\n of preprocessors, pa_ounit is set up twice and we have two calls to unset_lib at\n the end of the file, and the second one comes in this branch *)\n ()\n | Some lib ->\n if lib = static_lib then dynamic_lib := None\n\nlet test_unit ~config ~descr ~tags ~filename ~line_number ~start_pos ~end_pos f =\n test ~config ~descr ~tags ~filename ~line_number ~start_pos ~end_pos\n (fun () -> f (); true)\n\nlet[@inline never] test_module ~config ~descr ~tags ~filename:def_filename ~line_number:def_line_number\n ~start_pos ~end_pos f =\n match Action.get () with\n | `Ignore -> ()\n | `Test_mode { which_tests = { libname; only_test_location = _; which_tags }; what_to_do } ->\n let f = add_hooks config f in\n let descr () = displayed_descr descr def_filename def_line_number start_pos end_pos in\n let partial_tags = tags @ Module_context.current_tags () in\n let should_run =\n Some libname = !dynamic_lib\n (* If, no matter what tags a test defines, we certainly will drop all tests within\n this module, then don't run the module at all. This means people can write\n things like the following without breaking the 32-bit build:\n let%test_module [@tags \"64-bits-only\"] = (module struct\n let i = Int64.to_int_exn ....\n end)\n We don't shortcut based on position, as we can't tell what positions the\n inner tests will have. *)\n && not (Tag_predicate.entire_module_disabled which_tags ~partial_tags)\n in\n if should_run then begin\n match what_to_do with\n | `List_partitions -> Partition.found_test ()\n | `Run_partition partition ->\n if Partition.is_current partition then begin\n incr test_modules_ran;\n let descr = descr () in\n try\n Module_context.with_ ~descr ~tags (fun () ->\n (* We do not reset random states upon entering [let%test_module].\n\n Con: Code in test modules can accidentally depend on top-level random\n state effects.\n\n Pros: (1) We don't reset to the same seed on entering a [let%test_module]\n and then a [let%test] inside that module, which could lead to\n accidentally randomly generating the same values in some test. (2) Moving\n code into and out of [let%test_module] does not change its random seed.\n *)\n time_without_resetting_random_seeds f)\n with exn ->\n let backtrace = backtrace_indented ~by:2 in\n incr test_modules_failed;\n let exn_str = Printexc.to_string exn in\n let sep = if String.contains exn_str '\\n' then \"\\n\" else \" \" in\n eprintf_or_delay (\"TES\" ^^ \"T_MODULE at %s threw%s%s.\\n%s%s\\n%!\")\n (String.uncapitalize_ascii descr) sep exn_str backtrace (string_of_module_descr ())\n end\n end\n\nlet summarize () =\n match Action.get () with\n | `Ignore ->\n if Sys.argv <> [||] && Filename.basename Sys.argv.(0) = \"inline_tests_runner.exe\" then\n Printf.eprintf \"inline_tests_runner.exe is not supposed to be run by hand, you \\n\\\n should run the inline_tests_runner script instead.\\n%!\"\n else\n Printf.eprintf \"You are doing something unexpected with the tests. No tests have \\n\\\n been run. You should use the inline_tests_runner script to run \\n\\\n tests.\\n%!\";\n Test_result.Error\n | `Test_mode { which_tests = _; what_to_do = `List_partitions } ->\n List.iter (Printf.printf \"%s\\n\") (Partition.all ());\n Test_result.Success\n | `Test_mode { what_to_do = `Run_partition _; which_tests } -> begin\n begin match !log with\n | None -> ()\n | Some ch -> close_out ch\n end;\n print_delayed_errors ();\n match !tests_failed, !test_modules_failed with\n | 0, 0 -> begin\n if !show_counts then begin\n Printf.eprintf \"%d tests ran, %d test_modules ran\\n%!\" !tests_ran !test_modules_ran\n end;\n let errors =\n let unused_tests =\n List.filter (fun (_, _, used) -> not !used) which_tests.only_test_location\n in\n match unused_tests with\n | [] -> None\n | _ :: _ -> Some unused_tests\n in\n match errors with\n | Some tests ->\n Printf.eprintf \"ppx_inline_test error: the following -only-test flags matched nothing:\";\n List.iter (fun (filename, line_number_opt, _) ->\n match line_number_opt with\n | None -> Printf.eprintf \" %s\" filename\n | Some line_number -> Printf.eprintf \" %s:%d\" filename line_number\n ) tests;\n Printf.eprintf \".\\n%!\";\n Test_result.Error\n | None ->\n if !tests_ran = 0 && !strict then begin\n Printf.eprintf \"ppx_inline_test error: no tests have been run.\\n%!\";\n Test_result.Error\n end else begin\n Test_result.Success\n end\n end\n | count, count_test_modules ->\n Printf.eprintf \"FAILED %d / %d tests%s\\n%!\" count !tests_ran\n (if count_test_modules = 0 then \"\" else Printf.sprintf (\", %d TES\" ^^ \"T_MODULES\") count_test_modules);\n Test_result.Failure\n end\n\nlet use_color = !use_color\nlet in_place = !in_place\nlet diff_command = !diff_command\nlet source_tree_root = !source_tree_root\nlet allow_output_patterns = !allow_output_patterns\n\nlet evaluators = ref [summarize]\nlet add_evaluator ~f = evaluators := f :: !evaluators\nlet exit () =\n List.map (fun f -> f ()) (List.rev !evaluators)\n |> Test_result.combine_all\n |> Test_result.to_exit_code\n |> exit\n","(* this lib should not depend on core *)\nmodule List = struct\n include List\n let compare cmp a b =\n let rec loop a b =\n match a, b with\n | [], [] -> 0\n | [], _ -> -1\n | _ , [] -> 1\n | x :: xs, y :: ys ->\n let n = cmp x y in\n if n = 0 then loop xs ys\n else n\n in\n loop a b\nend\n\nmodule Uid : sig\n type t\n val compare : t -> t -> int\n val equal : t -> t -> bool\n val next : string -> t\n val hash : t -> int\n val name : t -> string\n val static : t\nend = struct\n type t = {\n code : int;\n name : string;\n }\n let compare a b = compare (a.code : int) b.code\n let equal a b = (a.code : int) = b.code\n let uid = ref 0\n let next name = let code = !uid in incr uid; {code; name}\n let hash a = Hashtbl.hash a.code\n let name a = a.name\n let static = next \"static\"\nend\n\nmodule Key = struct\n type t = {\n uid : Uid.t;\n params : t list;\n }\n let rec compare k1 k2 =\n if k1 == k2 then 0 else\n let cmp = Uid.compare k1.uid k2.uid in\n if cmp <> 0 then cmp else\n List.compare compare k1.params k2.params\n let equal a b = compare a b = 0\n let hash = (Hashtbl.hash : t -> int)\n let static = { uid = Uid.static ; params = [] }\nend\n\ntype 'a t = Key.t\ntype 'a typename = 'a t\n\nlet key t = t\nlet uid t = t.Key.uid\nlet name t = Uid.name t.Key.uid\nlet static = Key.static\n\nlet create ?(name=\"Typename.create\") () = { Key.uid = Uid.next name ; params = [] }\n\ninclude struct\n (* The argument for Obj.magic here is the same as the one in core/type_equal *)\n\n let same (type a) (type b) (nm1 : a t) (nm2 : b t) = Key.compare nm1 nm2 = 0\n\n let same_witness (type a) (type b) (nm1 : a t) (nm2 : b t) =\n if Key.compare nm1 nm2 = 0\n then Some (Obj.magic Type_equal.refl : (a, b) Type_equal.t)\n else None\n\n let same_witness_exn (type a) (type b) (nm1 : a t) (nm2 : b t) =\n if Key.compare nm1 nm2 = 0\n then (Obj.magic Type_equal.refl : (a, b) Type_equal.t)\n else failwith \"Typename.same_witness_exn\"\n\nend\n\nmodule type S0 = sig\n type t\n val typename_of_t : t typename\nend\n\nmodule type S1 = sig\n type 'a t\n val typename_of_t : 'a typename -> 'a t typename\nend\n\nmodule type S2 = sig\n type ('a, 'b) t\n val typename_of_t :\n 'a typename\n -> 'b typename\n -> ('a, 'b) t typename\nend\n\nmodule type S3 = sig\n type ('a, 'b, 'c) t\n val typename_of_t :\n 'a typename\n -> 'b typename\n -> 'c typename\n -> ('a, 'b, 'c) t typename\nend\n\nmodule type S4 = sig\n type ('a, 'b, 'c, 'd) t\n val typename_of_t :\n 'a typename\n -> 'b typename\n -> 'c typename\n -> 'd typename\n -> ('a, 'b, 'c, 'd) t typename\nend\n\nmodule type S5 = sig\n type ('a, 'b, 'c, 'd, 'e) t\n val typename_of_t :\n 'a typename\n -> 'b typename\n -> 'c typename\n -> 'd typename\n -> 'e typename\n -> ('a, 'b, 'c, 'd, 'e) t typename\nend\n\nmodule Make0 (X : Named_intf.S0) = struct\n let uid = Uid.next X.name\n let typename_of_t = { Key.uid ; params = [] }\nend\n\nmodule Make1 (X : Named_intf.S1) = struct\n let uid = Uid.next X.name\n let typename_of_t a = { Key.uid ; params = [ a ] }\nend\n\nmodule Make2 (X : Named_intf.S2) = struct\n let uid = Uid.next X.name\n let typename_of_t a b = { Key.uid ; params = [ a ; b ] }\nend\n\nmodule Make3 (X : Named_intf.S3) = struct\n let uid = Uid.next X.name\n let typename_of_t a b c = { Key.uid ; params = [ a ; b ; c ] }\nend\n\nmodule Make4 (X : Named_intf.S4) = struct\n let uid = Uid.next X.name\n let typename_of_t a b c d = { Key.uid ; params = [ a ; b ; c ; d ] }\nend\n\nmodule Make5 (X : Named_intf.S5) = struct\n let uid = Uid.next X.name\n let typename_of_t a b c d e = { Key.uid ; params = [ a ; b ; c ; d ; e ] }\nend\n\nmodule Key_table = Hashtbl.Make (Key)\n\nmodule Table (X : sig\n type 'a t\nend) = struct\n\n type data = Data : 'a t * 'a X.t -> data\n type t = data Key_table.t\n\n let create int = Key_table.create int\n\n let mem table name = Key_table.mem table (key name)\n\n let set table name data =\n Key_table.replace table (key name) (Data (name, data))\n\n let find (type a) table (name : a typename) =\n let data =\n try Some (Key_table.find table (key name))\n with Base.Not_found_s _ | Caml.Not_found -> None\n in\n match data with\n | None -> None\n | Some (Data (name', data)) ->\n (fun (type b) (name' : b typename) (data : b X.t) ->\n let Type_equal.T = (same_witness_exn name' name : (b, a) Type_equal.t) in\n Some (data : a X.t)\n ) name' data\nend\n\nlet fail uid_a uid_b =\n let msg =\n Printf.sprintf \"Typename.Same_witness_exn %S %S\" (Uid.name uid_a) (Uid.name uid_b)\n in\n failwith msg\n\nmodule Same_witness_exn_1 (A : S1) (B : S1) = struct\n type t = { eq : 'a. ('a A.t, 'a B.t) Type_equal.t }\n\n let witness =\n let uid_a = uid (A.typename_of_t static) in\n let uid_b = uid (B.typename_of_t static) in\n if Uid.equal uid_a uid_b\n then { eq = Obj.magic Type_equal.refl }\n else fail uid_a uid_b\nend\n\nmodule Same_witness_exn_2 (A : S2) (B : S2) = struct\n type t = {\n eq : 'a 'b. ( ('a, 'b) A.t,\n ('a, 'b) B.t ) Type_equal.t\n }\n\n let witness =\n let uid_a = uid (A.typename_of_t static static) in\n let uid_b = uid (B.typename_of_t static static) in\n if Uid.equal uid_a uid_b\n then { eq = Obj.magic Type_equal.refl }\n else fail uid_a uid_b\nend\n\nmodule Same_witness_exn_3 (A : S3) (B : S3) = struct\n type t = {\n eq : 'a 'b 'c. ( ('a, 'b, 'c) A.t,\n ('a, 'b, 'c) B.t ) Type_equal.t\n }\n\n let witness =\n let uid_a = uid (A.typename_of_t static static static) in\n let uid_b = uid (B.typename_of_t static static static) in\n if Uid.equal uid_a uid_b\n then { eq = Obj.magic Type_equal.refl }\n else fail uid_a uid_b\nend\n\nmodule Same_witness_exn_4 (A : S4) (B : S4) = struct\n type t = {\n eq : 'a 'b 'c 'd. ( ('a, 'b, 'c, 'd) A.t,\n ('a, 'b, 'c, 'd) B.t ) Type_equal.t\n }\n\n let witness =\n let uid_a = uid (A.typename_of_t static static static static) in\n let uid_b = uid (B.typename_of_t static static static static) in\n if Uid.equal uid_a uid_b\n then { eq = Obj.magic Type_equal.refl }\n else fail uid_a uid_b\nend\n\nmodule Same_witness_exn_5 (A : S5) (B : S5) = struct\n type t = {\n eq : 'a 'b 'c 'd 'e. ( ('a, 'b, 'c, 'd, 'e) A.t,\n ('a, 'b, 'c, 'd, 'e) B.t ) Type_equal.t\n }\n\n let witness =\n let uid_a = uid (A.typename_of_t static static static static static) in\n let uid_b = uid (B.typename_of_t static static static static static) in\n if Uid.equal uid_a uid_b\n then { eq = Obj.magic Type_equal.refl }\n else fail uid_a uid_b\nend\n","open Std_internal\n\nmodule Make0 (X : Named_intf.S0) = struct\n module Name_of_x = Typename.Make0 (X)\n let typename_of_t = Name_of_x.typename_of_t\n let named =\n Typerep.Named.T0 (module struct\n type named = X.t\n type t = X.t\n let typename_of_named = Name_of_x.typename_of_t\n let typename_of_t = typename_of_t\n let witness = Type_equal.refl\n end : Typerep.Named.T0 with type t = X.t)\nend\n\nmodule Make1 (X : Named_intf.S1) = struct\n module Name_of_x = Typename.Make1 (X)\n let typename_of_t = Name_of_x.typename_of_t\n let named (type p1) of_p1 =\n let typename_of_t = Name_of_x.typename_of_t\n (Typerep.typename_of_t of_p1)\n in\n Typerep.Named.T1 (module struct\n type 'a named = 'a X.t\n type a = p1 let a = of_p1\n type t = p1 X.t\n let typename_of_named = Name_of_x.typename_of_t\n let typename_of_t = typename_of_t\n let witness = Type_equal.refl\n end : Typerep.Named.T1 with type t = p1 X.t)\nend\n\nmodule Make2 (X : Named_intf.S2) = struct\n module Name_of_x = Typename.Make2 (X)\n let typename_of_t = Name_of_x.typename_of_t\n let named (type p1) (type p2) of_p1 of_p2 =\n let typename_of_t = Name_of_x.typename_of_t\n (Typerep.typename_of_t of_p1)\n (Typerep.typename_of_t of_p2)\n in\n Typerep.Named.T2 (module struct\n type ('a, 'b) named = ('a, 'b) X.t\n type a = p1 let a = of_p1\n type b = p2 let b = of_p2\n type t = (p1, p2) X.t\n let typename_of_named = Name_of_x.typename_of_t\n let typename_of_t = typename_of_t\n let witness = Type_equal.refl\n end : Typerep.Named.T2 with type t = (p1, p2) X.t)\nend\n\nmodule Make3 (X : Named_intf.S3) = struct\n module Name_of_x = Typename.Make3 (X)\n let typename_of_t = Name_of_x.typename_of_t\n let named (type p1) (type p2) (type p3) of_p1 of_p2 of_p3 =\n let typename_of_t = Name_of_x.typename_of_t\n (Typerep.typename_of_t of_p1)\n (Typerep.typename_of_t of_p2)\n (Typerep.typename_of_t of_p3)\n in\n Typerep.Named.T3 (module struct\n type ('a, 'b, 'c) named = ('a, 'b, 'c) X.t\n type a = p1 let a = of_p1\n type b = p2 let b = of_p2\n type c = p3 let c = of_p3\n type t = (p1, p2, p3) X.t\n let typename_of_named = Name_of_x.typename_of_t\n let typename_of_t = typename_of_t\n let witness = Type_equal.refl\n end : Typerep.Named.T3 with type t = (p1, p2, p3) X.t)\nend\n\nmodule Make4 (X : Named_intf.S4) = struct\n module Name_of_x = Typename.Make4 (X)\n let typename_of_t = Name_of_x.typename_of_t\n let named (type p1) (type p2) (type p3) (type p4) of_p1 of_p2 of_p3 of_p4 =\n let typename_of_t = Name_of_x.typename_of_t\n (Typerep.typename_of_t of_p1)\n (Typerep.typename_of_t of_p2)\n (Typerep.typename_of_t of_p3)\n (Typerep.typename_of_t of_p4)\n in\n Typerep.Named.T4 (module struct\n type ('a, 'b, 'c, 'd) named = ('a, 'b, 'c, 'd) X.t\n type a = p1 let a = of_p1\n type b = p2 let b = of_p2\n type c = p3 let c = of_p3\n type d = p4 let d = of_p4\n type t = (p1, p2, p3, p4) X.t\n let typename_of_named = Name_of_x.typename_of_t\n let typename_of_t = typename_of_t\n let witness = Type_equal.refl\n end : Typerep.Named.T4 with type t = (p1, p2, p3, p4) X.t)\nend\n\nmodule Make5 (X : Named_intf.S5) = struct\n module Name_of_x = Typename.Make5 (X)\n let typename_of_t = Name_of_x.typename_of_t\n let named\n (type p1) (type p2) (type p3) (type p4) (type p5)\n of_p1 of_p2 of_p3 of_p4 of_p5 =\n let typename_of_t = Name_of_x.typename_of_t\n (Typerep.typename_of_t of_p1)\n (Typerep.typename_of_t of_p2)\n (Typerep.typename_of_t of_p3)\n (Typerep.typename_of_t of_p4)\n (Typerep.typename_of_t of_p5)\n in\n Typerep.Named.T5 (module struct\n type ('a, 'b, 'c, 'd, 'e) named = ('a, 'b, 'c, 'd, 'e) X.t\n type a = p1 let a = of_p1\n type b = p2 let b = of_p2\n type c = p3 let c = of_p3\n type d = p4 let d = of_p4\n type e = p5 let e = of_p5\n type t = (p1, p2, p3, p4, p5) X.t\n let typename_of_named = Name_of_x.typename_of_t\n let typename_of_t = typename_of_t\n let witness = Type_equal.refl\n end : Typerep.Named.T5 with type t = (p1, p2, p3, p4, p5) X.t)\nend\n","(**\n Place holder for common Variants and Fields interface\n*)\n\nmodule M (X : sig\n\n (**\n This functor is essentially there because we use this same interface in different\n contexts, with different types for ['a t].\n\n 1) One use case for it is where ['a X.t = 'a Typerep.t]. These interfaces are then\n part of the type witness built for a type containing a record or a variant in its\n structure. [traverse] will give a way of accessing the type representation for the\n arguments of a variant or record type.\n\n 2) Another use case is for building \"staged generic computations\". In that case, the\n type ['a X.t] is the type of the computation that is being built. [traverse]\n returns the computation built for the argument. The interface no longer exports\n the typerep of the arguments in hopes of enforcing that no typerep traversal\n happens at runtime if the computation happen to be a function.\n *)\n type 'a t\nend) = struct\n\n (* The functions prefixed by [internal] as well as the module suffixed by [_internal]\n are used by the code generated by the camlp4 extension [with typerep] as well as some\n internals of the typerep library. Do not consider using these somewhere else. They\n should ideally not be exported outside the typerep library, but the generated code\n needs somehow to access this, even outside. *)\n\n module Tag_internal = struct\n type ('variant, 'args) create = Args of ('args -> 'variant) | Const of 'variant\n type ('variant, 'args) t =\n { label : string\n ; rep : 'args X.t\n ; arity : int\n ; args_labels: string list\n ; index : int\n ; ocaml_repr : int\n ; tyid : 'args Typename.t\n ; create : ('variant, 'args) create\n }\n end\n\n (**\n Witness of a tag, that is an item in a variant type, also called an \"applied\n variant Constructor\"\n\n The first parameter is the variant type, the second is the type of the tag\n parameters. Example:\n\n {[\n type t =\n | A of (int * string)\n | B of string\n | C of { x : int; y : string }\n ]}\n\n this type has three constructors. For each of them we'll have a corresponding\n [Tag.t]:\n\n {[\n val tag_A : (t, (int * string)) Tag.t\n val tag_B : (t, string ) Tag.t\n val tag_C : (t, (int * string)) Tag.t\n ]}\n\n Note, inline record in variant are typed as if their definition was using tuples,\n without the parenthesis. This is consistent with their runtime representation. But\n the distinction is carried and available for introspection as part of the [Tag.t].\n See [args_labels]. *)\n module Tag : sig\n type ('variant, 'args) create = Args of ('args -> 'variant) | Const of 'variant\n type ('variant, 'args) t\n\n (**\n The name of the constructor as it is given in the concrete syntax\n Examples:\n\n {v\n Constructor | label\n -------------------------\n | A of int | \"A\"\n | `a of int | \"a\"\n | `A of int | \"A\"\n | A of { x : int } | \"A\"\n v}\n\n for standard variant, the ocaml syntax implies that this label will always starts\n with a capital letter. For polymorphic variants, this might be a lowercase char.\n For polymorphic variant, this label does not include the [`] character.\n *)\n val label : (_, _) t -> string\n\n (**\n The size of the ocaml heap block containing the arguments\n\n Examples:\n {v\n 0: | A | 'A\n 1: | A of int | `A of int | A of (int * int) | `A of (int * int)\n | `A of int * int\n | A of { x : int}\n 2: | A of int * float\n | A of { x : int; y : string }\n etc.\n v}\n *)\n val arity : (_, _) t -> int\n\n (** The label of the fields for inline records. For other forms of tags, this is the\n empty list. When this returns a non empty list, the length of the returned list\n is equal to the arity.\n\n Example:\n\n {v\n (1) Empty:\n\n | A | 'A\n | A of int | `A of int | A of (int * int) | `A of (int * int)\n | `A of int * int\n | A of int * float\n\n (2) Non empty:\n\n | A of { x : int } -> [ \"x\" ]\n | A of { x : int; y : string } -> [ \"x\" ; \"y\" ]\n v}\n *)\n val args_labels : (_, _) t -> string list\n\n (**\n The index of the constructor in the list of all the variant type's constructors\n Examples:\n {[\n type t =\n | A of int (* 0 *)\n | B (* 1 *)\n | C of int (* 2 *)\n | D of char (* 3 *)\n | E of { x : int } (* 4 *)\n ]}\n *)\n val index : (_, _) t -> int\n\n (**\n ocaml_repr is related to the runtime of objects. this is essentially a way of\n giving one the ability to rebuild dynamically an [Obj.t] representing a tag.\n\n Polymorphic variants:\n ---------------------\n\n [ocaml_repr] is the hash of the label, as done by the compiler.\n Example:\n print_int (Obj.magic `bar) (* 4895187 *)\n print_int (Obj.magic 'foo) (* 5097222 *)\n\n Standards variants:\n -------------------\n\n [ocaml_repr] is the tag corresponding to the constructor within the type.\n the way it works in the ocaml runtime is by partitioning the constructors regarding\n if they have some arguments or not, preserving the order, then assign increasing\n index withing each partition.\n Example:\n\n {[\n type t = (* no arg *) (* args *)\n | A (* 0 *)\n | B of int (* 0 *)\n | C (* 1 *)\n | D of (float * string) (* 1 *)\n | E (* 2 *)\n | F (* 3 *)\n | G of string (* 2 *)\n | H of { x : int } (* 3 *)\n ]}\n *)\n val ocaml_repr : (_, _) t -> int\n\n (**\n Give back a way of constructing a value of that constructor from its arguments.\n\n Examples:\n\n {[\n type t =\n | A of (int * string)\n | B of int * float\n | C\n | D of { x : int; y : string }\n ]}\n\n [create] will return something equivalent to:\n tag_A : [Args (fun (d : (int * string) -> A d)]\n tag_B : [Args (fun (i, f) -> B (i, f))]\n tag_C : [Const C]\n tag_D : [Args (fun (x, y) -> D { x; y })]\n *)\n val create : ('variant, 'args) t -> ('variant, 'args) create\n\n (** return the type_name of the arguments. might be used to perform some lookup based\n on it while building a computation for example *)\n val tyid : (_, 'args) t -> 'args Typename.t\n\n (** get the representation/computation of the arguments *)\n val traverse : (_, 'args) t -> 'args X.t\n\n (* used by the camlp4 extension to build type witnesses, or by some internal parts of\n typerep. you should feel bad if you need to use it in some user code *)\n val internal_use_only : ('a, 'b) Tag_internal.t -> ('a, 'b) t\n end = struct\n include Tag_internal\n let label t = t.label\n let arity t = t.arity\n let args_labels t = t.args_labels\n let index t = t.index\n let ocaml_repr t = t.ocaml_repr\n let create t = t.create\n let tyid t = t.tyid\n let traverse t = t.rep\n\n let internal_use_only t = t\n end\n\n module Variant_internal = struct\n type _ tag = Tag : ('variant, 'a) Tag.t -> 'variant tag\n type _ value = Value : ('variant, 'a) Tag.t * 'a -> 'variant value\n type 'a t = {\n typename : 'a Typename.t;\n tags : 'a tag array;\n polymorphic : bool;\n value : 'a -> 'a value;\n }\n end\n\n module Variant : sig\n\n (**\n An existential type used to gather all the tags constituing a variant\n type. the ['variant] parameter is the variant type, it is the same for all the\n constructors of that variant type. The type of the parameters might be different\n for each constructor and is thus existential\n *)\n type _ tag = Tag : ('variant, 'args) Tag.t -> 'variant tag\n\n (**\n A similar existential constructor to [_ tag] but this one holds a value whose type\n is the arguments of the tag constructor. A value of type ['a value] is a pair of\n (1) a value of variant type ['a] along with (2) some information about the\n constructor within the type ['a]\n *)\n type _ value = Value : ('variant, 'args) Tag.t * 'args -> 'variant value\n\n (**\n Witness of a variant type. The parameter is the type of the variant type witnessed.\n *)\n type 'a t\n\n val typename_of_t : 'a t -> 'a Typename.t\n\n (**\n Returns the number of tags of this variant type definition.\n *)\n val length : 'a t -> int\n\n (**\n Get the nth tag of this variant type, indexed from 0.\n *)\n val tag : 'a t -> int -> 'a tag\n\n (**\n Distinguish polymorphic variants and standard variants. Typically, polymorphic\n variants tags starts with the [`] character.\n Example\n polymorphic variant: type t = [ `A | `B ]\n standard variant: type t = A | B\n *)\n val is_polymorphic : _ t -> bool\n\n (**\n Pattern matching on a value of this variant type.\n *)\n val value : 'a t -> 'a -> 'a value\n\n (**\n folding along the tags of the variant type\n *)\n val fold : 'a t -> init:'acc -> f:('acc -> 'a tag -> 'acc) -> 'acc\n\n (* used by the camlp4 extension to build type witnesses, or by some internal parts of\n typerep. you should feel bad if you need to use it in some user code *)\n val internal_use_only : 'a Variant_internal.t -> 'a t\n end = struct\n include Variant_internal\n let typename_of_t t = t.typename\n let length t = Array.length t.tags\n let tag t index = t.tags.(index)\n let is_polymorphic t = t.polymorphic\n let value t = t.value\n\n let fold t ~init ~f = Array.fold_left f init t.tags\n\n let internal_use_only t = t\n end\n\n module Field_internal = struct\n type ('record, 'field) t = {\n label : string;\n rep : 'field X.t;\n index : int;\n tyid : 'field Typename.t;\n get : ('record -> 'field);\n (* set : ('record -> 'field -> unit) option; (\\* mutable field *\\) *)\n is_mutable : bool;\n }\n end\n\n (**\n Witness of a field, that is an item in a record type.\n The first parameter is the record type, the second is the type of the field.\n Example:\n {[\n type t = { x : int ; y : string }\n ]}\n This type has two fields. for each of them we'll have a corresponding [Field.t]\n\n val field_x : (t, int) Field.t\n val field_y : (t, string) Field.t\n *)\n module Field : sig\n type ('record, 'field) t\n\n (**\n The name of the field as it is given in the concrete syntax\n Examples:\n {[\n { x : int; (* \"x\" *)\n foo : string; (* \"foo\" *)\n bar : float; (* \"bar\" *)\n }\n ]}\n *)\n val label : (_, _) t -> string\n\n (**\n The 0-based index of the field in the list of all fields for this record type.\n Example:\n {[\n type t = {\n x : int; (* 0 *)\n foo : string; (* 1 *)\n bar : string; (* 2 *)\n }\n ]}\n *)\n val index : (_, _) t -> int\n\n (**\n Field accessors. This corresponds to the dot operation.\n [Field.get bar_field t] returns the field [bar] of the record value [t], just the\n same as [t.bar]\n *)\n val get : ('record, 'field) t -> 'record -> 'field\n\n (** return whether the field is mutable, i.e. whether its declaration is prefixed with\n the keyword [mutable] *)\n val is_mutable : (_, _) t -> bool\n\n (** return the type_name of the arguments. Might be used to perform some lookup based\n on it *)\n val tyid : (_, 'field) t -> 'field Typename.t\n\n (** get the computation of the arguments *)\n val traverse : (_, 'field) t -> 'field X.t\n\n (* used by the camlp4 extension to build type witnesses, or by some internal parts of\n typerep. you should feel bad if you need to use it in some user code *)\n val internal_use_only : ('a, 'b) Field_internal.t -> ('a, 'b) t\n end = struct\n include Field_internal\n let label t = t.label\n let index t = t.index\n let get t = t.get\n let is_mutable t = t.is_mutable\n let tyid t = t.tyid\n let traverse t = t.rep\n\n let internal_use_only t = t\n end\n\n module Record_internal = struct\n type _ field = Field : ('record, 'a) Field.t -> 'record field\n type 'record fields = { get : 'field. ('record, 'field) Field.t -> 'field }\n type 'a t = {\n typename : 'a Typename.t;\n fields : 'a field array;\n has_double_array_tag : bool;\n create : 'a fields -> 'a;\n }\n end\n\n module Record : sig\n\n (**\n An existential type used to gather all the fields constituing a record type. the\n ['record] parameter is the record type, it is the same for all the field of that\n record type. The type of the fields might be different for each field and is thus\n existential.\n *)\n type _ field = Field : ('record, 'a) Field.t -> 'record field\n\n (**\n ['record fields] is a type isomorphic to ['record]. This gives a way to get the\n field value for each field of the record. The advantage of this representation is\n that it is convenient for writing generic computations.\n *)\n type 'record fields = { get : 'field. ('record, 'field) Field.t -> 'field }\n\n (**\n Witness of a record type. The parameter is the type of the record type witnessed.\n *)\n type 'a t\n\n val typename_of_t : 'a t -> 'a Typename.t\n\n (**\n Returns the number of fields of this record type definition.\n *)\n val length : 'a t -> int\n\n (**\n Get the nth field of this record type, indexed from 0.\n *)\n val field : 'a t -> int -> 'a field\n\n (**\n This is a low level metadata regarding the way the ocaml compiler represent the\n array underneath that is the runtime value of a record of type ['a] given a witness\n of type ['a t]. [has_double_array_tag w] returns [true] if the array that\n represents runtime values of this type is an optimized ocaml float array.\n Typically, this will be true for record where all fields are statically known as to\n be [floats].\n\n Note that you can't get this information dynamically by inspecting the typerep once\n it is applied, because there is at this point no way to tell whether one of the\n field is polymorphic in the type definition.\n *)\n val has_double_array_tag : _ t -> bool\n\n (**\n Expose one direction of the isomorphism between a value of type ['a] and a value of\n type ['a fields]. Basically, given an encoding way of accessing the value of all\n the fields of a record, create that record and return it.\n *)\n val create : 'a t -> 'a fields -> 'a\n\n (**\n folding along the tags of the variant type\n *)\n val fold : 'a t -> init:'acc -> f:('acc -> 'a field -> 'acc) -> 'acc\n\n (* used by the camlp4 extension to build type witnesses, or by some internal parts of\n typerep. you should feel bad if you need to use it in some user code *)\n val internal_use_only : 'a Record_internal.t -> 'a t\n end = struct\n include Record_internal\n let typename_of_t t = t.typename\n let length t = Array.length t.fields\n let field t index = t.fields.(index)\n let has_double_array_tag t = t.has_double_array_tag\n let create t = t.create\n let fold t ~init ~f = Array.fold_left f init t.fields\n\n let internal_use_only t = t\n end\nend\n\nmodule type S = sig\n type 'a t\n include (module type of M (struct type 'a rep = 'a t type 'a t = 'a rep end))\nend\n","(* using the hash_variant of pa_type_conv at compile time *)\nlet repr_of_poly_variant : [> ] -> int = fun variant ->\n let obj = Obj.repr variant in\n if Obj.is_int obj then Obj.obj obj\n else\n let size = Obj.size obj in\n assert (size = 2);\n let repr = Obj.field obj 0 in\n (assert (Obj.is_int repr));\n Obj.obj repr\n\nlet hash_variant s =\n let accu = ref 0 in\n for i = 0 to String.length s - 1 do\n accu := 223 * !accu + Char.code s.[i]\n done;\n (* reduce to 31 bits *)\n accu := !accu land (1 lsl 31 - 1);\n (* make it signed for 64 bits architectures *)\n if !accu > 0x3FFFFFFF then !accu - (1 lsl 31) else !accu\n\n(* a few unit tests of cases that have triggered diffs in the past of this\n lib *)\nlet () = assert (repr_of_poly_variant `Latency_stats = hash_variant \"Latency_stats\")\nlet () = assert (repr_of_poly_variant `zero = hash_variant \"zero\")\n\nlet double_array_value = Obj.magic 0.\nlet has_double_array_tag a = Obj.double_array_tag = (Obj.tag (Obj.repr a))\nlet () =\n let module M = struct\n type double = { a : float ; b : float }\n type simple = { c : float ; d : int }\n let double = { a = double_array_value; b = double_array_value; }\n let simple = { c = double_array_value; d = double_array_value; }\n end in\n assert (has_double_array_tag M.double);\n assert (not (has_double_array_tag M.simple));\n;;\n","open Std_internal\n\nmodule Make0 (X : Named_intf.S0) : Typerepable.S\n with type t := X.t\n= struct\n module M = Make_typename.Make0(X)\n let typerep_of_t =\n Typerep.Named (M.named, None)\n let typename_of_t = M.typename_of_t\nend\n\nmodule Make1 (X : Named_intf.S1) : Typerepable.S1\n with type 'a t := 'a X.t\n= struct\n module M = Make_typename.Make1(X)\n let typerep_of_t of_p1 =\n Typerep.Named (M.named of_p1, None)\n let typename_of_t = M.typename_of_t\nend\n\nmodule Make2 (X : Named_intf.S2) : Typerepable.S2\n with type ('a, 'b) t := ('a, 'b) X.t\n= struct\n module M = Make_typename.Make2(X)\n let typerep_of_t of_p1 of_p2 =\n Typerep.Named (M.named of_p1 of_p2, None)\n let typename_of_t = M.typename_of_t\nend\n\nmodule Make3 (X : Named_intf.S3) : Typerepable.S3\n with type ('a, 'b, 'c) t := ('a, 'b, 'c) X.t\n= struct\n module M = Make_typename.Make3(X)\n let typerep_of_t of_p1 of_p2 of_p3 =\n Typerep.Named (M.named of_p1 of_p2 of_p3, None)\n let typename_of_t = M.typename_of_t\nend\n\nmodule Make4 (X : Named_intf.S4) : Typerepable.S4\n with type ('a, 'b, 'c, 'd) t := ('a, 'b, 'c, 'd) X.t\n= struct\n module M = Make_typename.Make4(X)\n let typerep_of_t of_p1 of_p2 of_p3 of_p4 =\n Typerep.Named (M.named of_p1 of_p2 of_p3 of_p4, None)\n let typename_of_t = M.typename_of_t\nend\n\nmodule Make5 (X : Named_intf.S5) : Typerepable.S5\n with type ('a, 'b, 'c, 'd, 'e) t := ('a, 'b, 'c, 'd, 'e) X.t\n= struct\n module M = Make_typename.Make5(X)\n let typerep_of_t of_p1 of_p2 of_p3 of_p4 of_p5 =\n Typerep.Named (M.named of_p1 of_p2 of_p3 of_p4 of_p5, None)\n let typename_of_t = M.typename_of_t\nend\n","open! Base\nopen Import\n\nmodule Name : sig\n type t [@@deriving_inline sexp, compare]\n\n include sig\n [@@@ocaml.warning \"-32\"]\n\n include Ppx_sexp_conv_lib.Sexpable.S with type t := t\n\n val compare : t -> t -> int\n end\n [@@ocaml.doc \"@inline\"]\n\n [@@@end]\n\n val relative_to : dir:string -> t -> string\n\n include Identifiable.S with type t := t\nend = struct\n include String\n\n let relative_to ~dir t =\n if not (Caml.Filename.is_relative t) then t else Caml.Filename.concat dir t\n ;;\nend\n\nlet initial_dir =\n let dir_or_error =\n match Caml.Sys.getcwd () with\n | v -> `Ok v\n | exception exn -> `Exn exn\n in\n fun () ->\n match dir_or_error with\n | `Ok v -> v\n | `Exn exn -> raise exn\n;;\n\nmodule Location = struct\n module T = struct\n type t =\n { filename : Name.t\n ; line_number : int\n ; line_start : int\n ; start_pos : int\n ; end_pos : int\n }\n [@@deriving_inline sexp, compare]\n\n let _ = fun (_ : t) -> ()\n\n let t_of_sexp =\n (let _tp_loc = \"file.ml.Location.T.t\" in\n function\n | Ppx_sexp_conv_lib.Sexp.List field_sexps as sexp ->\n let filename_field = ref Ppx_sexp_conv_lib.Option.None\n and line_number_field = ref Ppx_sexp_conv_lib.Option.None\n and line_start_field = ref Ppx_sexp_conv_lib.Option.None\n and start_pos_field = ref Ppx_sexp_conv_lib.Option.None\n and end_pos_field = ref Ppx_sexp_conv_lib.Option.None\n and duplicates = ref []\n and extra = ref [] in\n let rec iter = function\n | Ppx_sexp_conv_lib.Sexp.List\n (Ppx_sexp_conv_lib.Sexp.Atom field_name :: (([] | [ _ ]) as _field_sexps))\n :: tail ->\n let _field_sexp () =\n match _field_sexps with\n | [ x ] -> x\n | [] ->\n Ppx_sexp_conv_lib.Conv_error.record_only_pairs_expected _tp_loc sexp\n | _ -> assert false\n in\n (match field_name with\n | \"filename\" ->\n (match !filename_field with\n | Ppx_sexp_conv_lib.Option.None ->\n let _field_sexp = _field_sexp () in\n let fvalue = Name.t_of_sexp _field_sexp in\n filename_field := Ppx_sexp_conv_lib.Option.Some fvalue\n | Ppx_sexp_conv_lib.Option.Some _ ->\n duplicates := field_name :: !duplicates)\n | \"line_number\" ->\n (match !line_number_field with\n | Ppx_sexp_conv_lib.Option.None ->\n let _field_sexp = _field_sexp () in\n let fvalue = int_of_sexp _field_sexp in\n line_number_field := Ppx_sexp_conv_lib.Option.Some fvalue\n | Ppx_sexp_conv_lib.Option.Some _ ->\n duplicates := field_name :: !duplicates)\n | \"line_start\" ->\n (match !line_start_field with\n | Ppx_sexp_conv_lib.Option.None ->\n let _field_sexp = _field_sexp () in\n let fvalue = int_of_sexp _field_sexp in\n line_start_field := Ppx_sexp_conv_lib.Option.Some fvalue\n | Ppx_sexp_conv_lib.Option.Some _ ->\n duplicates := field_name :: !duplicates)\n | \"start_pos\" ->\n (match !start_pos_field with\n | Ppx_sexp_conv_lib.Option.None ->\n let _field_sexp = _field_sexp () in\n let fvalue = int_of_sexp _field_sexp in\n start_pos_field := Ppx_sexp_conv_lib.Option.Some fvalue\n | Ppx_sexp_conv_lib.Option.Some _ ->\n duplicates := field_name :: !duplicates)\n | \"end_pos\" ->\n (match !end_pos_field with\n | Ppx_sexp_conv_lib.Option.None ->\n let _field_sexp = _field_sexp () in\n let fvalue = int_of_sexp _field_sexp in\n end_pos_field := Ppx_sexp_conv_lib.Option.Some fvalue\n | Ppx_sexp_conv_lib.Option.Some _ ->\n duplicates := field_name :: !duplicates)\n | _ ->\n if !Ppx_sexp_conv_lib.Conv.record_check_extra_fields\n then extra := field_name :: !extra\n else ());\n iter tail\n | ((Ppx_sexp_conv_lib.Sexp.Atom _ | Ppx_sexp_conv_lib.Sexp.List _) as sexp)\n :: _ -> Ppx_sexp_conv_lib.Conv_error.record_only_pairs_expected _tp_loc sexp\n | [] -> ()\n in\n iter field_sexps;\n (match !duplicates with\n | _ :: _ ->\n Ppx_sexp_conv_lib.Conv_error.record_duplicate_fields _tp_loc !duplicates sexp\n | [] ->\n (match !extra with\n | _ :: _ ->\n Ppx_sexp_conv_lib.Conv_error.record_extra_fields _tp_loc !extra sexp\n | [] ->\n (match\n ( !filename_field\n , !line_number_field\n , !line_start_field\n , !start_pos_field\n , !end_pos_field )\n with\n | ( Ppx_sexp_conv_lib.Option.Some filename_value\n , Ppx_sexp_conv_lib.Option.Some line_number_value\n , Ppx_sexp_conv_lib.Option.Some line_start_value\n , Ppx_sexp_conv_lib.Option.Some start_pos_value\n , Ppx_sexp_conv_lib.Option.Some end_pos_value ) ->\n { filename = filename_value\n ; line_number = line_number_value\n ; line_start = line_start_value\n ; start_pos = start_pos_value\n ; end_pos = end_pos_value\n }\n | _ ->\n Ppx_sexp_conv_lib.Conv_error.record_undefined_elements\n _tp_loc\n sexp\n [ ( Ppx_sexp_conv_lib.Conv.( = )\n !filename_field\n Ppx_sexp_conv_lib.Option.None\n , \"filename\" )\n ; ( Ppx_sexp_conv_lib.Conv.( = )\n !line_number_field\n Ppx_sexp_conv_lib.Option.None\n , \"line_number\" )\n ; ( Ppx_sexp_conv_lib.Conv.( = )\n !line_start_field\n Ppx_sexp_conv_lib.Option.None\n , \"line_start\" )\n ; ( Ppx_sexp_conv_lib.Conv.( = )\n !start_pos_field\n Ppx_sexp_conv_lib.Option.None\n , \"start_pos\" )\n ; ( Ppx_sexp_conv_lib.Conv.( = )\n !end_pos_field\n Ppx_sexp_conv_lib.Option.None\n , \"end_pos\" )\n ])))\n | Ppx_sexp_conv_lib.Sexp.Atom _ as sexp ->\n Ppx_sexp_conv_lib.Conv_error.record_list_instead_atom _tp_loc sexp\n : Ppx_sexp_conv_lib.Sexp.t -> t)\n ;;\n\n let _ = t_of_sexp\n\n let sexp_of_t =\n (function\n | { filename = v_filename\n ; line_number = v_line_number\n ; line_start = v_line_start\n ; start_pos = v_start_pos\n ; end_pos = v_end_pos\n } ->\n let bnds = [] in\n let bnds =\n let arg = sexp_of_int v_end_pos in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"end_pos\"; arg ]\n :: bnds\n in\n let bnds =\n let arg = sexp_of_int v_start_pos in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"start_pos\"; arg ]\n :: bnds\n in\n let bnds =\n let arg = sexp_of_int v_line_start in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"line_start\"; arg ]\n :: bnds\n in\n let bnds =\n let arg = sexp_of_int v_line_number in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"line_number\"; arg ]\n :: bnds\n in\n let bnds =\n let arg = Name.sexp_of_t v_filename in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"filename\"; arg ]\n :: bnds\n in\n Ppx_sexp_conv_lib.Sexp.List bnds\n : t -> Ppx_sexp_conv_lib.Sexp.t)\n ;;\n\n let _ = sexp_of_t\n\n let compare =\n (fun a__001_ b__002_ ->\n if Ppx_compare_lib.phys_equal a__001_ b__002_\n then 0\n else (\n match Name.compare a__001_.filename b__002_.filename with\n | 0 ->\n (match compare_int a__001_.line_number b__002_.line_number with\n | 0 ->\n (match compare_int a__001_.line_start b__002_.line_start with\n | 0 ->\n (match compare_int a__001_.start_pos b__002_.start_pos with\n | 0 -> compare_int a__001_.end_pos b__002_.end_pos\n | n -> n)\n | n -> n)\n | n -> n)\n | n -> n)\n : t -> t -> int)\n ;;\n\n let _ = compare\n\n [@@@end]\n\n let compare a b =\n if not (Name.equal a.filename b.filename)\n then invalid_arg \"Expect_test_collector.File.Location.compare\"\n else compare a b\n ;;\n end\n\n include T\n include Comparable.Make (T)\n\n let beginning_of_file filename =\n { filename; line_number = 1; line_start = 0; start_pos = 0; end_pos = 0 }\n ;;\nend\n\nmodule Digest : sig\n type t [@@deriving_inline sexp_of, compare]\n\n include sig\n [@@@ocaml.warning \"-32\"]\n\n val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t\n val compare : t -> t -> int\n end\n [@@ocaml.doc \"@inline\"]\n\n [@@@end]\n\n val to_string : t -> string\n val of_string : string -> t\nend = struct\n type t = string [@@deriving_inline sexp_of, compare]\n\n let _ = fun (_ : t) -> ()\n let sexp_of_t = (sexp_of_string : t -> Ppx_sexp_conv_lib.Sexp.t)\n let _ = sexp_of_t\n let compare = (compare_string : t -> t -> int)\n let _ = compare\n\n [@@@end]\n\n let to_string t = t\n\n let of_string s =\n let expected_length = 32 in\n if String.length s <> expected_length\n then invalid_arg \"Expect_test_collector.File.Digest.of_string, unexpected length\";\n for i = 0 to expected_length - 1 do\n match s.[i] with\n | '0' .. '9' | 'a' .. 'f' -> ()\n | _ -> invalid_arg \"Expect_test_collector.File.Digest.of_string\"\n done;\n s\n ;;\nend\n","open Expect_test_common\nmodule List = ListLabels\n\nmodule Test_outcome = struct\n type t =\n { file_digest : File.Digest.t\n ; location : File.Location.t\n ; expectations : Expectation.Raw.t list\n ; uncaught_exn_expectation : Expectation.Raw.t option\n ; saved_output : (File.Location.t * string) list\n ; trailing_output : string\n ; upon_unreleasable_issue : Expect_test_config_types.Upon_unreleasable_issue.t\n ; uncaught_exn : (exn * Printexc.raw_backtrace) option\n }\nend\n\nlet tests_run : Test_outcome.t list ref = ref []\n\nlet protect ~finally ~f =\n match f () with\n | x ->\n finally ();\n x\n | exception e ->\n finally ();\n raise e\n;;\n\nmodule Current_file = struct\n let current = ref None\n\n let set ~absolute_filename =\n match !current with\n | None -> current := Some absolute_filename\n | Some _ -> failwith \"Expect_test_collector.set: already set\"\n ;;\n\n let unset () =\n match !current with\n | Some _ -> current := None\n | None -> failwith \"Expect_test_collector.unset: not set\"\n ;;\n\n let get () =\n match !current with\n | Some fn -> fn\n | None -> failwith \"Expect_test_collector.get: not set\"\n ;;\nend\n\nmodule Make (C : Expect_test_config_types.S) = struct\n let ( >>= ) t f = C.IO_flush.bind t ~f\n let return = C.IO_flush.return\n\n module C = struct\n include C\n\n let flush () =\n Format.pp_print_flush Format.std_formatter ();\n Format.pp_print_flush Format.err_formatter ();\n Caml.flush Caml.stdout;\n Caml.flush Caml.stderr;\n C.flush ()\n ;;\n end\n\n module Instance : sig\n val save_output : File.Location.t -> unit C.IO_flush.t\n val save_and_return_output : File.Location.t -> string C.IO_flush.t\n\n val exec\n : file_digest:File.Digest.t\n -> location:File.Location.t\n -> expectations:Expectation.Raw.t list\n -> uncaught_exn_expectation:Expectation.Raw.t option\n -> f:(unit -> unit C.IO_run.t)\n -> unit\n end = struct\n type t =\n { mutable saved : (File.Location.t * int) list\n ; chan : out_channel\n ; filename : File.Name.t\n }\n\n external before_test\n : output:out_channel\n -> stdout:out_channel\n -> stderr:out_channel\n -> unit\n = \"expect_test_collector_before_test\"\n\n external after_test\n : stdout:out_channel\n -> stderr:out_channel\n -> unit\n = \"expect_test_collector_after_test\"\n\n external pos_out : out_channel -> int = \"caml_out_channel_pos_fd\"\n\n let get_position () = pos_out stdout\n\n let create () =\n let filename = Filename.temp_file \"expect-test\" \"output\" in\n let chan = open_out_bin filename in\n before_test ~output:chan ~stdout ~stderr;\n { chan; filename = File.Name.of_string filename; saved = [] }\n ;;\n\n let extract_output ic len =\n let s = really_input_string ic len in\n if not (Check_backtraces.contains_backtraces s)\n then s\n else\n Expect_test_config_types.Upon_unreleasable_issue\n .message_when_expectation_contains_backtrace\n C.upon_unreleasable_issue\n ^ s\n ;;\n\n let relative_filename t = File.Name.relative_to ~dir:(File.initial_dir ()) t.filename\n\n let with_ic fname ~f =\n let ic = open_in_bin fname in\n protect ~finally:(fun () -> close_in ic) ~f:(fun () -> f ic)\n ;;\n\n let get_outputs_and_cleanup t =\n let last_ofs = get_position () in\n after_test ~stdout ~stderr;\n close_out t.chan;\n let fname = relative_filename t in\n protect\n ~finally:(fun () -> Sys.remove fname)\n ~f:(fun () ->\n with_ic fname ~f:(fun ic ->\n let ofs, outputs =\n List.fold_left\n (List.rev t.saved)\n ~init:(0, [])\n ~f:(fun (ofs, acc) (loc, next_ofs) ->\n let s = extract_output ic (next_ofs - ofs) in\n next_ofs, (loc, s) :: acc)\n in\n let trailing_output = extract_output ic (last_ofs - ofs) in\n List.rev outputs, trailing_output))\n ;;\n\n let current_test : (File.Location.t * t) option ref = ref None\n\n let get_current () =\n match !current_test with\n | Some (_, t) -> t\n | None ->\n failwith \"Expect_test_collector.Instance.get_current called outside a test.\"\n ;;\n\n let save_output location =\n let t = get_current () in\n C.flush ()\n >>= fun () ->\n let pos = get_position () in\n t.saved <- (location, pos) :: t.saved;\n return ()\n ;;\n\n let save_and_return_output location =\n let t = get_current () in\n C.flush ()\n >>= fun () ->\n let pos = get_position () in\n let prev_pos =\n match t.saved with\n | [] -> 0\n | (_, prev_pos) :: _ -> prev_pos\n in\n t.saved <- (location, pos) :: t.saved;\n flush t.chan;\n let len = pos - prev_pos in\n return\n (with_ic (relative_filename t) ~f:(fun ic ->\n seek_in ic prev_pos;\n really_input_string ic len))\n ;;\n\n let () =\n Caml.at_exit (fun () ->\n match !current_test with\n | None -> ()\n | Some (loc, t) ->\n let blocks, trailing = get_outputs_and_cleanup t in\n Printf.eprintf\n \"File %S, line %d, characters %d-%d:\\n\\\n Error: program exited while expect test was running!\\n\\\n Output captured so far:\\n\\\n %!\"\n (File.Name.to_string loc.filename)\n loc.line_number\n (loc.start_pos - loc.line_start)\n (loc.end_pos - loc.line_start);\n List.iter blocks ~f:(fun (_, s) -> Printf.eprintf \"%s%!\" s);\n Printf.eprintf \"%s%!\" trailing)\n ;;\n\n let rec final_flush ?(count = 0) k =\n let max_attempts = 10 in\n C.flush ()\n >>= fun () ->\n if C.flushed ()\n then k ~append:\"\"\n else if count = max_attempts\n then\n k\n ~append:\n (Printf.sprintf\n \"\\n\\\n STOPPED COLLECTING OUTPUT AFTER %d FLUSHING ATTEMPS\\n\\\n THERE MUST BE A BACKGROUND JOB PRINTING TO STDOUT\\n\"\n max_attempts)\n else final_flush ~count:(count + 1) k\n ;;\n\n let exec ~file_digest ~location ~expectations ~uncaught_exn_expectation ~f =\n let t = create () in\n current_test := Some (location, t);\n let finally uncaught_exn =\n C.run (fun () ->\n C.IO_flush.to_run\n (final_flush (fun ~append ->\n current_test := None;\n let saved_output, trailing_output = get_outputs_and_cleanup t in\n tests_run\n := { file_digest\n ; location\n ; expectations\n ; uncaught_exn_expectation\n ; saved_output\n ; trailing_output = trailing_output ^ append\n ; upon_unreleasable_issue = C.upon_unreleasable_issue\n ; uncaught_exn\n }\n :: !tests_run;\n return ())))\n in\n match C.run f with\n | () -> finally None\n | exception exn ->\n let bt = Printexc.get_raw_backtrace () in\n finally (Some (exn, bt))\n ;;\n end\n\n let save_output = Instance.save_output\n let save_and_return_output = Instance.save_and_return_output\n\n let run\n ~file_digest\n ~(location : File.Location.t)\n ~absolute_filename:defined_in\n ~description\n ~tags\n ~expectations\n ~uncaught_exn_expectation\n ~inline_test_config\n f\n =\n Ppx_inline_test_lib.Runtime.test\n ~config:inline_test_config\n ~descr:\n (match description with\n | None -> \"\"\n | Some s -> \": \" ^ s)\n ~tags\n ~filename:(File.Name.to_string location.filename)\n ~line_number:location.line_number\n ~start_pos:(location.start_pos - location.line_start)\n ~end_pos:(location.end_pos - location.line_start)\n (fun () ->\n let registering_tests_for = Current_file.get () in\n if defined_in <> registering_tests_for\n then\n Printf.ksprintf\n failwith\n \"Trying to run an expect test from the wrong file.\\n\\\n - test declared at %s:%d\\n\\\n - trying to run it from %s\\n\"\n defined_in\n location.line_number\n registering_tests_for\n else (\n (* To avoid capturing not-yet flushed data of the stdout buffer *)\n C.run (fun () -> C.IO_flush.to_run (C.flush ()));\n Instance.exec ~file_digest ~location ~expectations ~uncaught_exn_expectation ~f;\n true))\n ;;\nend\n[@@inline never]\n\nlet tests_run () =\n (* We prepend tests when we encounter them, so reverse the list to reinstate order *)\n List.rev !tests_run\n;;\n","module Upon_unreleasable_issue = struct\n type t =\n [ `CR (** Leaves a CR, so that features cannot be released. *)\n | `Warning_for_collector_testing (** Only for ppx_expect testing; do not use. *)\n ]\nend\n\nmodule type S = sig\n module IO_run : sig\n type 'a t\n end\n\n module IO_flush : sig\n type 'a t\n\n val return : 'a -> 'a t\n val bind : 'a t -> f:('a -> 'b t) -> 'b t\n val to_run : 'a t -> 'a IO_run.t\n end\n\n (** Flush whatever need to be to get pending output out on file descriptor 0. *)\n val flush : unit -> unit IO_flush.t\n\n (** Run an IO operation until completion *)\n val run : (unit -> unit IO_run.t) -> unit\n\n (** Synchronous check that there is no pending output on file description 0. With async,\n there is no guarantee that on the rhs of a [IO.bind (flush ()) ...] the output is\n completely flushed, that's why we need this. *)\n val flushed : unit -> bool\n\n\n (** [upon_unreleasable_issue] specifies how to deal with output that should not be\n released even if it is accepted (e.g. backtraces). The default is [`CR]. *)\n val upon_unreleasable_issue : Upon_unreleasable_issue.t\nend\n\n(** Configuration for running expect tests *)\nmodule type Expect_test_config_types = sig\n (** To configure expect_test, add the following at the top of your .ml file, or in some\n import.ml:\n\n {[\n module Expect_test_config = struct\n include Expect_test_config\n let pre_redirect_hook () = ...\n end\n ]}\n\n Note that since all expect test are also inline tests, the inline test configuration\n also applies to all expect test.\n *)\n\n module Upon_unreleasable_issue : sig\n include module type of Upon_unreleasable_issue\n\n val equal : t -> t -> bool\n val comment_prefix : t -> string\n\n (** Message to print when an expectation contains a backtrace *)\n val message_when_expectation_contains_backtrace : t -> string\n end\n\n module type S = S\nend\n","module type S = Expect_test_config_types_intf.S\n\nmodule type Expect_test_config_types =\n Expect_test_config_types_intf.Expect_test_config_types\n\nmodule Upon_unreleasable_issue = struct\n include Expect_test_config_types_intf.Upon_unreleasable_issue\n\n let equal t1 t2 = t1 = t2\n\n let comment_prefix = function\n | `CR -> \"CR \"\n | `Warning_for_collector_testing -> \"\"\n ;;\n\n let message_when_expectation_contains_backtrace t =\n Printf.sprintf\n {|\n(* %sexpect_test_collector: This test expectation appears to contain a backtrace.\n This is strongly discouraged as backtraces are fragile.\n Please change this test to not include a backtrace. *)\n\n|}\n (comment_prefix t)\n ;;\nend\n","module IO_run = struct\n type 'a t = 'a\n\n let return x = x\n let bind t ~f = f t\nend\n\nmodule IO_flush = struct\n include IO_run\n\n let to_run t = t\nend\n\nlet flush () = () (* the runtime already flushes [stdout] *)\n\nlet run f = f ()\nlet flushed () = true (* the runtime flushed [stdout] before calling this function *)\n\nlet upon_unreleasable_issue = `CR\n","open! Base\n\nmodule T : sig\n type +'a t\n\n val create : (size:int -> random:Splittable_random.State.t -> 'a) -> 'a t\n val generate : 'a t -> size:int -> random:Splittable_random.State.t -> 'a\nend = struct\n type 'a t = (size:int -> random:Splittable_random.State.t -> 'a) Staged.t\n\n let create f : _ t = Staged.stage f\n\n let generate (t : _ t) ~size ~random =\n if size < 0\n then raise_s [%message \"Base_quickcheck.Generator.generate: size < 0\" (size : int)]\n else Staged.unstage t ~size ~random\n ;;\nend\n\ninclude T\n\nlet size = create (fun ~size ~random:_ -> size)\n\nlet fn dom rng =\n create (fun ~size ~random ->\n let random = Splittable_random.State.split random in\n fun x ->\n let hash = Observer0.observe dom x ~size ~hash:(Hash.alloc ()) in\n let random = Splittable_random.State.copy random in\n Splittable_random.State.perturb random (Hash.get_hash_value hash);\n generate rng ~size ~random)\n;;\n\nlet with_size t ~size = create (fun ~size:_ ~random -> generate t ~size ~random)\n\nlet perturb t salt =\n create (fun ~size ~random ->\n Splittable_random.State.perturb random salt;\n generate t ~size ~random)\n;;\n\nlet filter_map t ~f =\n let rec loop ~size ~random =\n let x = generate t ~size ~random in\n match f x with\n | Some y -> y\n | None -> loop ~size:(size + 1) ~random\n in\n create loop\n;;\n\nlet filter t ~f = filter_map t ~f:(fun x -> if f x then Some x else None)\nlet return x = create (fun ~size:_ ~random:_ -> x)\nlet map t ~f = create (fun ~size ~random -> f (generate t ~size ~random))\n\nlet apply tf tx =\n create (fun ~size ~random ->\n let f = generate tf ~size ~random in\n let x = generate tx ~size ~random in\n f x)\n;;\n\nlet bind t ~f =\n create (fun ~size ~random ->\n let x = generate t ~size ~random in\n generate (f x) ~size ~random)\n;;\n\nlet all list = create (fun ~size ~random -> List.map list ~f:(generate ~size ~random))\n\nlet all_unit list =\n create (fun ~size ~random -> List.iter list ~f:(generate ~size ~random))\n;;\n\nmodule For_applicative = Applicative.Make (struct\n type nonrec 'a t = 'a t\n\n let return = return\n let apply = apply\n let map = `Custom map\n end)\n\nlet both = For_applicative.both\nlet map2 = For_applicative.map2\nlet map3 = For_applicative.map3\n\nmodule Applicative_infix = For_applicative.Applicative_infix\ninclude Applicative_infix\n\nmodule For_monad = Monad.Make (struct\n type nonrec 'a t = 'a t\n\n let return = return\n let bind = bind\n let map = `Custom map\n end)\n\nlet ignore_m = For_monad.ignore_m\nlet join = For_monad.join\n\nmodule Monad_infix = For_monad.Monad_infix\ninclude Monad_infix\nmodule Let_syntax = For_monad.Let_syntax\nopen Let_syntax\n\nlet of_list list =\n if List.is_empty list\n then Error.raise_s [%message \"Base_quickcheck.Generator.of_list: empty list\"];\n let array = Array.of_list list in\n let lo = 0 in\n let hi = Array.length array - 1 in\n create (fun ~size:_ ~random ->\n let index = Splittable_random.int random ~lo ~hi in\n array.(index))\n;;\n\nlet union list = join (of_list list)\n\nlet of_weighted_list alist =\n if List.is_empty alist\n then Error.raise_s [%message \"Base_quickcheck.Generator.of_weighted_list: empty list\"];\n let weights, values = List.unzip alist in\n let value_array = Array.of_list values in\n let total_weight, cumulative_weight_array =\n let array = Array.init (Array.length value_array) ~f:(fun _ -> 0.) in\n let sum =\n List.foldi weights ~init:0. ~f:(fun index acc weight ->\n if not (Float.is_finite weight)\n then\n Error.raise_s\n [%message\n \"Base_quickcheck.Generator.of_weighted_list: weight is not finite\"\n (weight : float)];\n if Float.( < ) weight 0.\n then\n Error.raise_s\n [%message\n \"Base_quickcheck.Generator.of_weighted_list: weight is negative\"\n (weight : float)];\n let cumulative = acc +. weight in\n array.(index) <- cumulative;\n cumulative)\n in\n if Float.( <= ) sum 0.\n then\n Error.raise_s\n [%message \"Base_quickcheck.Generator.of_weighted_list: total weight is zero\"];\n sum, array\n in\n create (fun ~size:_ ~random ->\n let choice = Splittable_random.float random ~lo:0. ~hi:total_weight in\n match\n Array.binary_search\n cumulative_weight_array\n ~compare:Float.compare\n `First_greater_than_or_equal_to\n choice\n with\n | Some index -> value_array.(index)\n | None -> assert false)\n;;\n\nlet weighted_union alist = join (of_weighted_list alist)\nlet of_lazy lazy_t = create (fun ~size ~random -> generate (force lazy_t) ~size ~random)\n\nlet fixed_point of_generator =\n let rec lazy_t = lazy (of_generator (of_lazy lazy_t)) in\n force lazy_t\n;;\n\nlet weighted_recursive_union nonrec_list ~f =\n fixed_point (fun self ->\n let rec_list =\n List.map (f self) ~f:(fun (w, t) ->\n ( w\n , let%bind n = size in\n with_size ~size:(n - 1) t ))\n in\n if List.is_empty nonrec_list || List.is_empty rec_list\n then\n raise_s\n [%message\n \"Base_quickcheck.Generator.weighted_recursive_union: lists must be non-empty\"];\n let nonrec_gen = weighted_union nonrec_list in\n let rec_gen = weighted_union (nonrec_list @ rec_list) in\n match%bind size with\n | 0 -> nonrec_gen\n | _ -> rec_gen)\n;;\n\nlet recursive_union nonrec_list ~f =\n let weighted list = List.map list ~f:(fun t -> 1., t) in\n weighted_recursive_union (weighted nonrec_list) ~f:(fun self -> weighted (f self))\n;;\n\nlet sizes ?(min_length = 0) ?(max_length = Int.max_value) () =\n create (fun ~size ~random ->\n assert (min_length <= max_length);\n let upper_bound = min_length + size in\n let max_length =\n if upper_bound >= min_length (* guard against overflow *)\n then min max_length upper_bound\n else max_length\n in\n (* pick a length, weighted low so that most of the size is spent on elements *)\n let len = Splittable_random.Log_uniform.int random ~lo:min_length ~hi:max_length in\n (* if there are no elements return an empty array, otherwise return a non-empty array\n with the size distributed among the elements *)\n if len = 0\n then []\n else (\n let sizes = Array.init len ~f:(fun _ -> 0) in\n let remaining = size - (len - min_length) in\n let max_index = len - 1 in\n for _ = 1 to remaining do\n (* pick an index, weighted low so that we see unbalanced distributions often *)\n let index = Splittable_random.Log_uniform.int random ~lo:0 ~hi:max_index in\n sizes.(index) <- sizes.(index) + 1\n done;\n (* permute the array so that no index is favored over another *)\n for i = 0 to max_index - 1 do\n let j = Splittable_random.int random ~lo:i ~hi:max_index in\n Array.swap sizes i j\n done;\n assert (Array.sum (module Int) sizes ~f:Fn.id + (len - min_length) = size);\n Array.to_list sizes))\n;;\n\nlet unit = return ()\nlet bool = create (fun ~size:_ ~random -> Splittable_random.bool random)\nlet option value_t = union [ return None; map value_t ~f:Option.return ]\nlet either fst_t snd_t = union [ map fst_t ~f:Either.first; map snd_t ~f:Either.second ]\n\nlet result ok_t err_t =\n map (either ok_t err_t) ~f:(function\n | First ok -> Ok ok\n | Second err -> Error err)\n;;\n\nlet list_generic ?min_length ?max_length elt_gen =\n let%bind sizes = sizes ?min_length ?max_length () in\n List.map sizes ~f:(fun size -> with_size ~size elt_gen) |> all\n;;\n\nlet list elt_gen = list_generic elt_gen\nlet list_non_empty elt_gen = list_generic ~min_length:1 elt_gen\n\nlet list_with_length elt_gen ~length =\n list_generic ~min_length:length ~max_length:length elt_gen\n;;\n\nlet list_filtered elts =\n let elts = Array.of_list elts in\n let length_of_input = Array.length elts in\n create (fun ~size:_ ~random ->\n let length_of_output = Splittable_random.int random ~lo:0 ~hi:length_of_input in\n let indices = Array.init length_of_input ~f:Fn.id in\n (* Choose [length_of_output] random values in the prefix of [indices]. *)\n for i = 0 to length_of_output - 1 do\n let j = Splittable_random.int random ~lo:i ~hi:(length_of_input - 1) in\n Array.swap indices i j\n done;\n (* Sort the chosen indices because we don't want to reorder them. *)\n Array.sort indices ~pos:0 ~len:length_of_output ~compare:Int.compare;\n (* Return the chosen elements. *)\n List.init length_of_output ~f:(fun i -> elts.(indices.(i))))\n;;\n\nlet list_permutations list =\n create (fun ~size:_ ~random ->\n let array = Array.of_list list in\n for i = 1 to Array.length array - 1 do\n let j = Splittable_random.int random ~lo:0 ~hi:i in\n Array.swap array i j\n done;\n Array.to_list array)\n;;\n\nlet char_uniform_inclusive lo hi =\n create (fun ~size:_ ~random ->\n Splittable_random.int random ~lo:(Char.to_int lo) ~hi:(Char.to_int hi)\n |> Char.unsafe_of_int)\n;;\n\nlet char_uppercase = char_uniform_inclusive 'A' 'Z'\nlet char_lowercase = char_uniform_inclusive 'a' 'z'\nlet char_digit = char_uniform_inclusive '0' '9'\nlet char_print_uniform = char_uniform_inclusive ' ' '~'\nlet char_uniform = char_uniform_inclusive Char.min_value Char.max_value\nlet char_alpha = union [ char_lowercase; char_uppercase ]\n\nlet char_alphanum =\n weighted_union\n (* Most people probably expect this to be a uniform distribution, not weighted\n toward digits like we would get with [union] (since there are fewer digits than\n letters). *)\n [ 52., char_alpha; 10., char_digit ]\n;;\n\nlet char_whitespace = of_list (List.filter Char.all ~f:Char.is_whitespace)\nlet char_print = weighted_union [ 10., char_alphanum; 1., char_print_uniform ]\n\nlet char =\n weighted_union\n [ 100., char_print\n ; 10., char_uniform\n ; 1., return Char.min_value\n ; 1., return Char.max_value\n ]\n;;\n\n(* Produces a number from 0 or 1 to size + 1, weighted high. We have found this\n distribution empirically useful for string lengths. *)\nlet small_int ~allow_zero =\n create (fun ~size ~random ->\n let lower_bound = if allow_zero then 0 else 1 in\n let upper_bound = size + 1 in\n let weighted_low =\n Splittable_random.Log_uniform.int random ~lo:0 ~hi:(upper_bound - lower_bound)\n in\n let weighted_high = upper_bound - weighted_low in\n weighted_high)\n;;\n\nlet small_positive_or_zero_int = small_int ~allow_zero:true\nlet small_strictly_positive_int = small_int ~allow_zero:false\n\nmodule type Int_with_random = sig\n include Int.S\n\n val uniform : Splittable_random.State.t -> lo:t -> hi:t -> t\n val log_uniform : Splittable_random.State.t -> lo:t -> hi:t -> t\nend\n\nmodule For_integer (Integer : Int_with_random) = struct\n let uniform_inclusive lo hi =\n create (fun ~size:_ ~random -> Integer.uniform random ~lo ~hi)\n ;;\n\n let log_uniform_inclusive lo hi =\n create (fun ~size:_ ~random -> Integer.log_uniform random ~lo ~hi)\n ;;\n\n let non_uniform f lo hi =\n weighted_union [ 0.05, return lo; 0.05, return hi; 0.9, f lo hi ]\n ;;\n\n let inclusive = non_uniform uniform_inclusive\n let log_inclusive = non_uniform log_uniform_inclusive\n let uniform_all = uniform_inclusive Integer.min_value Integer.max_value\n\n let all =\n [%map\n let negative = bool\n and magnitude = log_inclusive Integer.zero Integer.max_value in\n if negative then Integer.bit_not magnitude else magnitude]\n ;;\nend\n\nmodule For_int = For_integer (struct\n include Int\n\n let uniform = Splittable_random.int\n let log_uniform = Splittable_random.Log_uniform.int\n end)\n\nlet int = For_int.all\nlet int_uniform = For_int.uniform_all\nlet int_inclusive = For_int.inclusive\nlet int_uniform_inclusive = For_int.uniform_inclusive\nlet int_log_inclusive = For_int.log_inclusive\nlet int_log_uniform_inclusive = For_int.log_uniform_inclusive\n\nmodule For_int32 = For_integer (struct\n include Int32\n\n let uniform = Splittable_random.int32\n let log_uniform = Splittable_random.Log_uniform.int32\n end)\n\nlet int32 = For_int32.all\nlet int32_uniform = For_int32.uniform_all\nlet int32_inclusive = For_int32.inclusive\nlet int32_uniform_inclusive = For_int32.uniform_inclusive\nlet int32_log_inclusive = For_int32.log_inclusive\nlet int32_log_uniform_inclusive = For_int32.log_uniform_inclusive\n\nmodule For_int63 = For_integer (struct\n include Int63\n\n let uniform = Splittable_random.int63\n let log_uniform = Splittable_random.Log_uniform.int63\n end)\n\nlet int63 = For_int63.all\nlet int63_uniform = For_int63.uniform_all\nlet int63_inclusive = For_int63.inclusive\nlet int63_uniform_inclusive = For_int63.uniform_inclusive\nlet int63_log_inclusive = For_int63.log_inclusive\nlet int63_log_uniform_inclusive = For_int63.log_uniform_inclusive\n\nmodule For_int64 = For_integer (struct\n include Int64\n\n let uniform = Splittable_random.int64\n let log_uniform = Splittable_random.Log_uniform.int64\n end)\n\nlet int64 = For_int64.all\nlet int64_uniform = For_int64.uniform_all\nlet int64_inclusive = For_int64.inclusive\nlet int64_uniform_inclusive = For_int64.uniform_inclusive\nlet int64_log_inclusive = For_int64.log_inclusive\nlet int64_log_uniform_inclusive = For_int64.log_uniform_inclusive\n\nmodule For_nativeint = For_integer (struct\n include Nativeint\n\n let uniform = Splittable_random.nativeint\n let log_uniform = Splittable_random.Log_uniform.nativeint\n end)\n\nlet nativeint = For_nativeint.all\nlet nativeint_uniform = For_nativeint.uniform_all\nlet nativeint_inclusive = For_nativeint.inclusive\nlet nativeint_uniform_inclusive = For_nativeint.uniform_inclusive\nlet nativeint_log_inclusive = For_nativeint.log_inclusive\nlet nativeint_log_uniform_inclusive = For_nativeint.log_uniform_inclusive\nlet float_zero_exponent = Float.ieee_exponent 0.\nlet float_zero_mantissa = Float.ieee_mantissa 0.\n\nlet float_max_positive_subnormal_value =\n Float.one_ulp `Down Float.min_positive_normal_value\n;;\n\nlet float_subnormal_exponent = Float.ieee_exponent Float.min_positive_subnormal_value\nlet float_min_subnormal_mantissa = Float.ieee_mantissa Float.min_positive_subnormal_value\nlet float_max_subnormal_mantissa = Float.ieee_mantissa float_max_positive_subnormal_value\nlet float_max_positive_normal_value = Float.max_finite_value\nlet float_min_normal_exponent = Float.ieee_exponent Float.min_positive_normal_value\nlet float_max_normal_exponent = Float.ieee_exponent float_max_positive_normal_value\nlet float_max_normal_mantissa = Float.ieee_mantissa float_max_positive_normal_value\nlet float_inf_exponent = Float.ieee_exponent Float.infinity\nlet float_inf_mantissa = Float.ieee_mantissa Float.infinity\nlet float_nan_exponent = Float.ieee_exponent Float.nan\nlet float_min_nan_mantissa = Int63.succ float_inf_mantissa\nlet float_max_nan_mantissa = float_max_normal_mantissa\nlet float_num_mantissa_bits = 52\n\n(* We weight mantissas so that \"integer-like\" values, and values with only a few digits\n past the decimal, are reasonably common. *)\nlet float_normal_mantissa =\n let%bind num_bits = For_int.uniform_inclusive 0 float_num_mantissa_bits in\n let%map bits =\n For_int63.inclusive Int63.zero (Int63.pred (Int63.shift_left Int63.one num_bits))\n in\n Int63.shift_left bits (Int.( - ) float_num_mantissa_bits num_bits)\n;;\n\nlet float_exponent_weighted_low lower_bound upper_bound =\n let%map offset = For_int.log_inclusive 0 (Int.( - ) upper_bound lower_bound) in\n Int.( + ) lower_bound offset\n;;\n\nlet float_exponent_weighted_high lower_bound upper_bound =\n let%map offset = For_int.log_inclusive 0 (Int.( - ) upper_bound lower_bound) in\n Int.( - ) upper_bound offset\n;;\n\n(* We weight exponents such that values near 1 are more likely. *)\nlet float_exponent =\n let midpoint = Float.ieee_exponent 1. in\n union\n [ float_exponent_weighted_high float_min_normal_exponent midpoint\n ; float_exponent_weighted_low midpoint float_max_normal_exponent\n ]\n;;\n\nlet float_zero =\n let%map negative = bool in\n Float.create_ieee_exn\n ~negative\n ~exponent:float_zero_exponent\n ~mantissa:float_zero_mantissa\n;;\n\nlet float_subnormal =\n let%map negative = bool\n and exponent = return float_subnormal_exponent\n and mantissa =\n For_int63.log_inclusive float_min_subnormal_mantissa float_max_subnormal_mantissa\n in\n Float.create_ieee_exn ~negative ~exponent ~mantissa\n;;\n\nlet float_normal =\n let%map negative = bool\n and exponent = float_exponent\n and mantissa = float_normal_mantissa in\n Float.create_ieee_exn ~negative ~exponent ~mantissa\n;;\n\nlet float_infinite =\n let%map negative = bool in\n Float.create_ieee_exn\n ~negative\n ~exponent:float_inf_exponent\n ~mantissa:float_inf_mantissa\n;;\n\nlet float_nan =\n let%map negative = bool\n and exponent = return float_nan_exponent\n and mantissa = For_int63.inclusive float_min_nan_mantissa float_max_nan_mantissa in\n Float.create_ieee_exn ~negative ~exponent ~mantissa\n;;\n\nlet float_of_class c =\n match (c : Float.Class.t) with\n | Zero -> float_zero\n | Subnormal -> float_subnormal\n | Normal -> float_normal\n | Infinite -> float_infinite\n | Nan -> float_nan\n;;\n\nlet float_weight_of_class c =\n match (c : Float.Class.t) with\n | Zero -> 1.\n | Subnormal -> 10.\n | Normal -> 100.\n | Infinite -> 1.\n | Nan -> 1.\n;;\n\nlet float_matching_classes filter =\n List.filter_map Float.Class.all ~f:(fun c ->\n if filter c then Some (float_weight_of_class c, float_of_class c) else None)\n |> weighted_union\n;;\n\nlet float_finite =\n float_matching_classes (function\n | Zero | Subnormal | Normal -> true\n | Infinite | Nan -> false)\n;;\n\nlet float_without_nan =\n float_matching_classes (function\n | Zero | Subnormal | Normal | Infinite -> true\n | Nan -> false)\n;;\n\nlet float = float_matching_classes (fun _ -> true)\n\nlet float_finite_non_zero =\n float_matching_classes (function\n | Subnormal | Normal -> true\n | Zero | Infinite | Nan -> false)\n;;\n\nlet float_strictly_positive =\n let%map t = float_finite_non_zero in\n Float.abs t\n;;\n\nlet float_strictly_negative =\n let%map t = float_finite_non_zero in\n ~-.(Float.abs t)\n;;\n\nlet float_positive_or_zero =\n let%map t = float_finite in\n Float.abs t\n;;\n\nlet float_negative_or_zero =\n let%map t = float_finite in\n ~-.(Float.abs t)\n;;\n\nlet float_uniform_exclusive lower_bound upper_bound =\n let open Float.O in\n if (not (Float.is_finite lower_bound)) || not (Float.is_finite upper_bound)\n then\n raise_s\n [%message\n \"Float.uniform_exclusive: bounds are not finite\"\n (lower_bound : float)\n (upper_bound : float)];\n let lower_inclusive = Float.one_ulp `Up lower_bound in\n let upper_inclusive = Float.one_ulp `Down upper_bound in\n if lower_inclusive > upper_inclusive\n then\n raise_s\n [%message\n \"Float.uniform_exclusive: requested range is empty\"\n (lower_bound : float)\n (upper_bound : float)];\n create (fun ~size:_ ~random ->\n Splittable_random.float random ~lo:lower_inclusive ~hi:upper_inclusive)\n;;\n\nlet float_inclusive lower_bound upper_bound =\n weighted_union\n [ 0.05, return lower_bound\n ; 0.05, return upper_bound\n ; 0.9, float_uniform_exclusive lower_bound upper_bound\n ]\n;;\n\nlet string_with_length_of char_gen ~length =\n list_with_length char_gen ~length |> map ~f:String.of_char_list\n;;\n\nlet string_of char_gen =\n bind small_positive_or_zero_int ~f:(fun length ->\n string_with_length_of char_gen ~length)\n;;\n\nlet string_non_empty_of char_gen =\n bind small_strictly_positive_int ~f:(fun length ->\n string_with_length_of char_gen ~length)\n;;\n\nlet string = string_of char\nlet string_non_empty = string_non_empty_of char\nlet string_with_length ~length = string_with_length_of char ~length\n\nlet sexp_of atom =\n fixed_point (fun self ->\n let%bind size = size in\n (* choose a number weighted low so we have a decreasing, but not vanishing, chance\n to generate atoms as size grows *)\n match%bind For_int.log_uniform_inclusive 0 (size + 1) with\n (* generate an atom using the given size *)\n | 0 ->\n let%map atom = atom in\n Sexp.Atom atom\n (* relying on [List.gen] to distribute [size] over sub-sexps *)\n | _ ->\n let%map list = list self in\n Sexp.List list)\n;;\n\nlet sexp = sexp_of string\n\nlet map_tree_using_comparator ~comparator key_gen data_gen =\n let%bind keys = list key_gen in\n let keys = List.dedup_and_sort keys ~compare:comparator.Comparator.compare in\n let%bind data = list_with_length data_gen ~length:(List.length keys) in\n return (Map.Using_comparator.Tree.of_alist_exn ~comparator (List.zip_exn keys data))\n;;\n\nlet set_tree_using_comparator ~comparator elt_gen =\n map (list elt_gen) ~f:(Set.Using_comparator.Tree.of_list ~comparator)\n;;\n\nlet comparator_of_m\n (type a c)\n (module M : Comparator.S with type t = a and type comparator_witness = c)\n =\n M.comparator\n;;\n\nlet map_t_m m key_gen data_gen =\n let comparator = comparator_of_m m in\n map_tree_using_comparator ~comparator key_gen data_gen\n |> map ~f:(Map.Using_comparator.of_tree ~comparator)\n;;\n\nlet set_t_m m elt_gen =\n let comparator = comparator_of_m m in\n set_tree_using_comparator ~comparator elt_gen\n |> map ~f:(Set.Using_comparator.of_tree ~comparator)\n;;\n\nlet bigarray1 t kind layout =\n let%map elts = list t in\n let elts = Array.of_list elts in\n let dim = Array.length elts in\n let offset = Bigarray_helpers.Layout.offset layout in\n Bigarray_helpers.Array1.init kind layout dim ~f:(fun i -> elts.(i - offset))\n;;\n\nlet bigstring = bigarray1 char Char C_layout\nlet float32_vec = bigarray1 float Float32 Fortran_layout\nlet float64_vec = bigarray1 float Float64 Fortran_layout\n\nlet bigarray2_dim =\n match%bind size with\n | 0 -> return (0, 0)\n | max_total_size ->\n let%bind a =\n (* choose a dimension up to [max_total_size], weighted low to give the other\n dimension a good chance of being comparatively high *)\n int_log_uniform_inclusive 1 max_total_size\n in\n let%bind b =\n (* choose a dimension up to [max_total_size / a], weighted high to reach close to\n [max_total_size] most of the time *)\n let max_b = max_total_size / a in\n let%map b_weighted_low = int_log_uniform_inclusive 0 max_b in\n max_b - b_weighted_low\n in\n (* avoid any skew of a vs b by randomly swapping *)\n if%map bool then a, b else b, a\n;;\n\nlet bigarray2 t kind layout =\n let%bind dim1, dim2 = bigarray2_dim in\n let%map elts = list_with_length ~length:dim1 (list_with_length ~length:dim2 t) in\n let elts = Array.of_list_map ~f:Array.of_list elts in\n let offset = Bigarray_helpers.Layout.offset layout in\n Bigarray_helpers.Array2.init kind layout dim1 dim2 ~f:(fun i j ->\n elts.(i - offset).(j - offset))\n;;\n\nlet float32_mat = bigarray2 float Float32 Fortran_layout\nlet float64_mat = bigarray2 float Float64 Fortran_layout\n","open! Base\n\nmodule Layout = struct\n type 'a t = 'a Bigarray.layout\n\n let offset : type a. a t -> int = function\n | Bigarray.Fortran_layout -> 1\n | Bigarray.C_layout -> 0\n ;;\nend\n\nmodule Array1 = struct\n type ('a, 'b, 'c) t = ('a, 'b, 'c) Bigarray.Array1.t\n\n let iteri t ~f =\n let offset = Layout.offset (Bigarray.Array1.layout t) in\n for i = 0 to Bigarray.Array1.dim t - 1 do\n f (i + offset) t.{i + offset}\n done\n ;;\n\n let init (type elt) (kind : (elt, _) Bigarray.kind) layout dim ~f =\n let t = Bigarray.Array1.create kind layout dim in\n iteri t ~f:(fun i (_ : elt) -> t.{i} <- f i);\n t\n ;;\n\n let fold (type elt) (t : (elt, _, _) t) ~init ~f =\n let init = ref init in\n iteri t ~f:(fun i (_ : elt) -> init := f !init t.{i});\n !init\n ;;\n\n let to_array t =\n let offset = Layout.offset (Bigarray.Array1.layout t) in\n Array.init (Bigarray.Array1.dim t) ~f:(fun i -> t.{i + offset})\n ;;\n\n let sexp_of_t sexp_of_elt _sexp_of_pack _sexp_of_layout t =\n [%sexp (to_array t : elt array)]\n ;;\n\n let hash_fold hash_fold_elt state t =\n let state = hash_fold_int state (Bigarray.Array1.dim t) in\n fold t ~init:state ~f:hash_fold_elt\n ;;\nend\n\nmodule Array2 = struct\n type ('a, 'b, 'c) t = ('a, 'b, 'c) Bigarray.Array2.t\n\n let iteri t ~f =\n let offset = Layout.offset (Bigarray.Array2.layout t) in\n for i = 0 to Bigarray.Array2.dim1 t - 1 do\n for j = 0 to Bigarray.Array2.dim2 t - 1 do\n f (i + offset) (j + offset) t.{i + offset, j + offset}\n done\n done\n ;;\n\n let init (type elt) (kind : (elt, _) Bigarray.kind) layout dim1 dim2 ~f =\n let t = Bigarray.Array2.create kind layout dim1 dim2 in\n iteri t ~f:(fun i j (_ : elt) -> t.{i, j} <- f i j);\n t\n ;;\n\n let fold (type elt) (t : (elt, _, _) t) ~init ~f =\n let init = ref init in\n iteri t ~f:(fun (_ : int) (_ : int) elt -> init := f !init elt);\n !init\n ;;\n\n let to_array t =\n let offset = Layout.offset (Bigarray.Array2.layout t) in\n Array.init (Bigarray.Array2.dim1 t) ~f:(fun i ->\n Array.init (Bigarray.Array2.dim2 t) ~f:(fun j -> t.{i + offset, j + offset}))\n ;;\n\n let sexp_of_t sexp_of_elt _sexp_of_pack _sexp_of_layout t =\n [%sexp (to_array t : elt array array)]\n ;;\n\n let hash_fold hash_fold_elt state t =\n let state = hash_fold_int state (Bigarray.Array2.dim1 t) in\n let state = hash_fold_int state (Bigarray.Array2.dim2 t) in\n fold t ~init:state ~f:hash_fold_elt\n ;;\nend\n","open! Base\n\ntype 'a t = 'a -> size:int -> hash:Hash.state -> Hash.state\n\nlet create f : _ t = f\n\nlet observe (t : _ t) x ~size ~hash =\n if size < 0\n then raise_s [%message \"Base_quickcheck.Observer.observe: size < 0\" (size : int)]\n else t x ~size ~hash\n;;\n\nlet opaque _ ~size:_ ~hash = hash\n","open Core_kernel\n\n(* This module implements snarky functions for a sponge that can *conditionally* absorb input,\n while branching minimally. Specifically, if absorbing N field elements, this sponge can absorb\n a variable subset of N field elements, while performing N + 1 invocations of the sponge's\n underlying permutation. *)\n\nlet m = 3\n\nlet capacity = 1\n\nlet rate = m - capacity\n\ntype 'f sponge_state =\n | Absorbing of\n { next_index : 'f Snarky_backendless.Boolean.t\n ; xs : ('f Snarky_backendless.Boolean.t * 'f) list\n }\n | Squeezed of int\n\ntype 'f t =\n { mutable state : 'f array\n ; params : 'f Sponge.Params.t\n ; needs_final_permute_if_empty : bool\n ; mutable sponge_state : 'f sponge_state\n }\n\nmodule Make\n (Impl : Snarky_backendless.Snark_intf.Run)\n (P : Sponge.Intf.Permutation with type Field.t = Impl.Field.t) =\nstruct\n open P\n open Impl\n\n type nonrec t = Field.t t\n\n let _state { state; _ } = Array.copy state\n\n let _copy { state; params; sponge_state; needs_final_permute_if_empty } =\n { state = Array.copy state\n ; params\n ; sponge_state\n ; needs_final_permute_if_empty\n }\n\n let initial_state = Array.init m ~f:(fun _ -> Field.zero)\n\n let of_sponge { Sponge.state; params; sponge_state; id = _ } =\n match sponge_state with\n | Sponge.Squeezed n ->\n { sponge_state = Squeezed n\n ; state = Array.copy state\n ; needs_final_permute_if_empty = true\n ; params\n }\n | Sponge.Absorbed n -> (\n let abs i =\n { sponge_state = Absorbing { next_index = i; xs = [] }\n ; state = Array.copy state\n ; params\n ; needs_final_permute_if_empty = true\n }\n in\n match n with\n | 0 ->\n abs Boolean.false_\n | 1 ->\n abs Boolean.true_\n | 2 ->\n { sponge_state = Absorbing { next_index = Boolean.false_; xs = [] }\n ; state = P.block_cipher params state\n ; needs_final_permute_if_empty = false\n ; params\n }\n | _ ->\n assert false )\n\n let create ?(init = initial_state) params =\n { params\n ; state = Array.copy init\n ; needs_final_permute_if_empty = true\n ; sponge_state = Absorbing { next_index = Boolean.false_; xs = [] }\n }\n\n let () = assert (rate = 2)\n\n let add_in a i x =\n let i_equals_0 = Boolean.not i in\n let i_equals_1 = i in\n (*\n a.(0) <- a.(0) + i_equals_0 * x\n a.(1) <- a.(1) + i_equals_1 * x *)\n List.iteri [ i_equals_0; i_equals_1 ] ~f:(fun j i_equals_j ->\n let a_j' =\n exists Field.typ\n ~compute:\n As_prover.(\n fun () ->\n let a_j = read Field.typ a.(j) in\n if read Boolean.typ i_equals_j then\n Field.Constant.(a_j + read Field.typ x)\n else a_j)\n in\n assert_r1cs x (i_equals_j :> Field.t) Field.(a_j' - a.(j)) ;\n a.(j) <- a_j' )\n\n let consume ~needs_final_permute_if_empty ~params ~start_pos input state =\n assert (Array.length state = m) ;\n let n = Array.length input in\n let pos = ref start_pos in\n let cond_permute permute =\n let permuted = P.block_cipher params (Array.copy state) in\n for i = 0 to m - 1 do\n state.(i) <- Field.if_ permute ~then_:permuted.(i) ~else_:state.(i)\n done\n in\n let pairs = n / 2 in\n let remaining = n - (2 * pairs) in\n for i = 0 to pairs - 1 do\n (* Semantically, we want to do this.\n match b, b' with\n | 1, 1 ->\n if p = 0\n then state := perm {state with .0 += x, .1 += y }\n else state := {perm {state with .1 += x} with .0 += y}\n | 1, 0 ->\n if p = 0\n then state := {state with .0 += x}\n else state := perm {state with .1 += x}\n | 0, 1 ->\n if p = 0\n then state := {state with .0 += y }\n else state := perm {state with .1 += y}\n | 0, 0 ->\n state\n *)\n let b, x = input.(2 * i) in\n let b', y = input.((2 * i) + 1) in\n let p = !pos in\n let p' = Boolean.( lxor ) p b in\n pos := Boolean.( lxor ) p' b' ;\n let y = Field.(y * (b' :> t)) in\n let add_in_y_after_perm =\n (* post\n add in\n (1, 1, 1)\n\n do not add in\n (1, 1, 0)\n (0, 1, 0)\n (0, 1, 1)\n\n (1, 0, 0)\n (1, 0, 1)\n (0, 0, 0)\n (0, 0, 1)\n *)\n (* Only one case where we add in y after the permutation is applied *)\n Boolean.all [ b; b'; p ]\n in\n let add_in_y_before_perm = Boolean.not add_in_y_after_perm in\n add_in state p Field.(x * (b :> t)) ;\n add_in state p' Field.(y * (add_in_y_before_perm :> t)) ;\n let permute =\n (* (b, b', p)\n true:\n (0, 1, 1)\n (1, 0, 1)\n (1, 1, 0)\n (1, 1, 1)\n\n false:\n (0, 0, 0)\n (0, 0, 1)\n (0, 1, 0)\n (1, 0, 0)\n *)\n (* (b && b') || (p && (b || b')) *)\n Boolean.(any [ all [ b; b' ]; all [ p; b ||| b' ] ])\n in\n cond_permute permute ;\n add_in state p' Field.(y * (add_in_y_after_perm :> t))\n done ;\n let empty_imput =\n Boolean.not (Boolean.Array.any (Array.map input ~f:fst))\n in\n let should_permute =\n match remaining with\n | 0 ->\n if needs_final_permute_if_empty then Boolean.(empty_imput ||| !pos)\n else !pos\n | 1 ->\n let b, x = input.(n - 1) in\n let p = !pos in\n pos := Boolean.( lxor ) p b ;\n add_in state p Field.(x * (b :> t)) ;\n if needs_final_permute_if_empty then Boolean.any [ p; b; empty_imput ]\n else Boolean.any [ p; b ]\n | _ ->\n assert false\n in\n cond_permute should_permute\n\n let absorb (t : t) x =\n match t.sponge_state with\n | Absorbing { next_index; xs } ->\n t.sponge_state <- Absorbing { next_index; xs = x :: xs }\n | Squeezed _ ->\n t.sponge_state <- Absorbing { next_index = Boolean.false_; xs = [ x ] }\n\n let squeeze (t : t) =\n match t.sponge_state with\n | Squeezed n ->\n if n = rate then (\n t.state <- block_cipher t.params t.state ;\n t.sponge_state <- Squeezed 1 ;\n t.state.(0) )\n else (\n t.sponge_state <- Squeezed (n + 1) ;\n t.state.(n) )\n | Absorbing { next_index; xs } ->\n consume ~needs_final_permute_if_empty:t.needs_final_permute_if_empty\n ~start_pos:next_index ~params:t.params (Array.of_list_rev xs) t.state ;\n t.sponge_state <- Squeezed 1 ;\n t.state.(0)\n\n let%test_module \"opt_sponge\" =\n ( module struct\n module S = Sponge.Make_sponge (P)\n\n let%test_unit \"correctness\" =\n let params : _ Sponge.Params.t =\n let a () =\n Array.init 3 ~f:(fun _ -> Field.(constant (Constant.random ())))\n in\n { mds = Array.init 3 ~f:(fun _ -> a ())\n ; round_constants = Array.init 40 ~f:(fun _ -> a ())\n }\n in\n let gen =\n let open Quickcheck.Generator.Let_syntax in\n let%bind n = Quickcheck.Generator.small_positive_int\n and n_pre = Quickcheck.Generator.small_positive_int in\n let%map xs = List.gen_with_length n Field.Constant.gen\n and bs = List.gen_with_length n Bool.quickcheck_generator\n and pre = List.gen_with_length n_pre Field.Constant.gen in\n (pre, List.zip_exn bs xs)\n in\n Quickcheck.test gen ~trials:10 ~f:(fun (pre, ps) ->\n let filtered =\n List.filter_map ps ~f:(fun (b, x) -> if b then Some x else None)\n in\n let init () =\n let pre =\n exists\n (Typ.list ~length:(List.length pre) Field.typ)\n ~compute:(fun () -> pre)\n in\n let s = S.create params in\n List.iter pre ~f:(S.absorb s) ;\n s\n in\n let filtered_res =\n let n = List.length filtered in\n Impl.Internal_Basic.Test.checked_to_unchecked\n (Typ.list ~length:n Field.typ)\n Field.typ\n (fun xs ->\n make_checked (fun () ->\n let s = init () in\n List.iter xs ~f:(S.absorb s) ;\n S.squeeze s ) )\n filtered\n in\n let opt_res =\n let n = List.length ps in\n Impl.Internal_Basic.Test.checked_to_unchecked\n (Typ.list ~length:n (Typ.tuple2 Boolean.typ Field.typ))\n Field.typ\n (fun xs ->\n make_checked (fun () ->\n let s =\n if List.length pre = 0 then create params\n else of_sponge (init ())\n in\n List.iter xs ~f:(absorb s) ;\n squeeze s ) )\n ps\n in\n if not (Field.Constant.equal filtered_res opt_res) then\n failwithf\n !\"hash(%{sexp:Field.Constant.t list}) = %{sexp:Field.Constant.t}\\n\\\n hash(%{sexp:(bool * Field.Constant.t) list}) = \\\n %{sexp:Field.Constant.t}\"\n filtered filtered_res ps opt_res () )\n end )\nend\n","open! Base\n\nmodule T : sig\n type 'a t\n\n val atomic : _ t\n val create : ('a -> 'a Sequence.t) -> 'a t\n val shrink : 'a t -> 'a -> 'a Sequence.t\nend = struct\n type 'a t = 'a -> 'a Sequence.t\n\n let atomic _ = Sequence.empty\n let create = Fn.id\n let shrink = Fn.id\nend\n\ninclude T\n\nlet map t ~f ~f_inverse = create (fun x -> Sequence.map ~f (shrink t (f_inverse x)))\nlet filter t ~f = create (fun x -> Sequence.filter ~f (shrink t x))\n\nlet filter_map t ~f ~f_inverse =\n create (fun x -> Sequence.filter_map ~f (shrink t (f_inverse x)))\n;;\n\nlet of_lazy lazy_t = create (fun x -> Sequence.of_lazy (lazy (shrink (force lazy_t) x)))\n\nlet fixed_point of_shrinker =\n let rec lazy_t = lazy (of_shrinker (of_lazy lazy_t)) in\n of_lazy lazy_t\n;;\n\nlet both fst_t snd_t =\n create (fun (fst, snd) ->\n Sequence.round_robin\n [ Sequence.map (shrink fst_t fst) ~f:(fun fst -> fst, snd)\n ; Sequence.map (shrink snd_t snd) ~f:(fun snd -> fst, snd)\n ])\n;;\n\nlet unit = atomic\nlet bool = atomic\nlet char = atomic\nlet int = atomic\nlet int32 = atomic\nlet int63 = atomic\nlet int64 = atomic\nlet nativeint = atomic\nlet float = atomic\n\nlet bigarray1 src =\n let dim = Bigarray.Array1.dim src in\n match dim with\n | 0 -> Sequence.empty\n | _ ->\n let kind = Bigarray.Array1.kind src in\n let layout = Bigarray.Array1.layout src in\n let offset = Bigarray_helpers.Layout.offset layout in\n Sequence.init dim ~f:(fun to_skip ->\n let to_skip = to_skip + offset in\n Bigarray_helpers.Array1.init kind layout (dim - 1) ~f:(fun i ->\n src.{(if i < to_skip then i else i + 1)}))\n;;\n\nlet bigstring = create bigarray1\nlet float32_vec = create bigarray1\nlet float64_vec = create bigarray1\n\nlet bigarray2 =\n let module Dims = struct\n type t =\n { dim1 : int\n ; dim2 : int\n }\n [@@deriving fields]\n\n let create a = Bigarray.Array2.{ dim1 = dim1 a; dim2 = dim2 a }\n end\n in\n let shrink field src =\n let dims = Dims.create src in\n match Field.get field dims with\n | 0 -> Sequence.empty\n | _ ->\n let kind = Bigarray.Array2.kind src in\n let layout = Bigarray.Array2.layout src in\n let offset = Bigarray_helpers.Layout.offset layout in\n let ({ dim1; dim2 } : Dims.t) = Field.map field dims ~f:Int.pred in\n Sequence.init (Field.get field dims) ~f:(fun to_skip ->\n let to_skip = to_skip + offset in\n let skip i = if i < to_skip then i else i + 1 in\n Bigarray_helpers.Array2.init kind layout dim1 dim2 ~f:(fun dim1 dim2 ->\n let ({ dim1; dim2 } : Dims.t) = Field.map field { dim1; dim2 } ~f:skip in\n src.{dim1, dim2}))\n in\n fun src ->\n Sequence.round_robin [ shrink Dims.Fields.dim1 src; shrink Dims.Fields.dim2 src ]\n;;\n\nlet float32_mat = create bigarray2\nlet float64_mat = create bigarray2\n\nlet option value_t =\n create (function\n | None -> Sequence.empty\n | Some value ->\n Sequence.append\n (Sequence.singleton None)\n (Sequence.map ~f:Option.return (shrink value_t value)))\n;;\n\nlet list elt_t =\n fixed_point (fun list_t ->\n create (function\n | [] -> Sequence.empty\n | head :: tail ->\n Sequence.round_robin\n [ Sequence.singleton tail\n ; Sequence.map (shrink elt_t head) ~f:(fun head -> head :: tail)\n ; Sequence.map (shrink list_t tail) ~f:(fun tail -> head :: tail)\n ]))\n;;\n\nlet string = map (list char) ~f:String.of_char_list ~f_inverse:String.to_list\n\nlet sexp =\n fixed_point (fun shrinker ->\n create (function\n | Sexp.Atom _ -> Sequence.empty\n | Sexp.List l ->\n let shrink_list =\n shrink (list shrinker) l |> Sequence.map ~f:(fun l -> Sexp.List l)\n in\n let shrink_tree = Sequence.of_list l in\n Sequence.round_robin [ shrink_list; shrink_tree ]))\n;;\n\nlet either fst_t snd_t =\n create (fun either ->\n match (either : _ Either.t) with\n | First fst -> Sequence.map (shrink fst_t fst) ~f:Either.first\n | Second snd -> Sequence.map (shrink snd_t snd) ~f:Either.second)\n;;\n\nlet result ok_t err_t =\n map\n (either ok_t err_t)\n ~f:(function\n | First ok -> Ok ok\n | Second err -> Error err)\n ~f_inverse:(function\n | Ok ok -> First ok\n | Error err -> Second err)\n;;\n\nlet map_tree_using_comparator ~comparator key_t data_t =\n create (fun tree ->\n let alist = Map.Using_comparator.Tree.to_alist tree in\n let drop_keys =\n Sequence.map (Sequence.of_list alist) ~f:(fun (k, _) ->\n Map.Using_comparator.Tree.remove ~comparator tree k)\n in\n let shrink_keys =\n Sequence.round_robin\n (List.map alist ~f:(fun (key, data) ->\n let tree = Map.Using_comparator.Tree.remove ~comparator tree key in\n Sequence.filter_map (shrink key_t key) ~f:(fun smaller_key ->\n match\n Map.Using_comparator.Tree.add\n ~comparator\n tree\n ~key:smaller_key\n ~data\n with\n | `Ok tree -> Some tree\n | `Duplicate -> None)))\n in\n let shrink_data =\n Sequence.round_robin\n (List.map alist ~f:(fun (key, data) ->\n Sequence.map (shrink data_t data) ~f:(fun smaller_data ->\n Map.Using_comparator.Tree.set ~comparator tree ~key ~data:smaller_data)))\n in\n Sequence.round_robin [ drop_keys; shrink_keys; shrink_data ])\n;;\n\nlet set_tree_using_comparator ~comparator elt_t =\n create (fun tree ->\n let list = Set.Using_comparator.Tree.to_list tree in\n let drop_elts =\n Sequence.map (Sequence.of_list list) ~f:(fun elt ->\n Set.Using_comparator.Tree.remove ~comparator tree elt)\n in\n let shrink_elts =\n Sequence.round_robin\n (List.map list ~f:(fun elt ->\n let tree = Set.Using_comparator.Tree.remove ~comparator tree elt in\n Sequence.filter_map (shrink elt_t elt) ~f:(fun smaller_elt ->\n match Set.Using_comparator.Tree.mem ~comparator tree smaller_elt with\n | true -> None\n | false ->\n Some (Set.Using_comparator.Tree.add tree ~comparator smaller_elt))))\n in\n Sequence.round_robin [ drop_elts; shrink_elts ])\n;;\n\nlet map_t key_t data_t =\n create (fun map_t ->\n let comparator = Map.comparator map_t in\n let t =\n map\n (map_tree_using_comparator ~comparator key_t data_t)\n ~f:(Map.Using_comparator.of_tree ~comparator)\n ~f_inverse:Map.Using_comparator.to_tree\n in\n shrink t map_t)\n;;\n\nlet set_t elt_t =\n create (fun set_t ->\n let comparator = Set.comparator set_t in\n let t =\n map\n (set_tree_using_comparator ~comparator elt_t)\n ~f:(Set.Using_comparator.of_tree ~comparator)\n ~f_inverse:Set.Using_comparator.to_tree\n in\n shrink t set_t)\n;;\n","open! Base\ninclude Test_intf\n\nmodule Config = struct\n module Seed = struct\n type t =\n | Nondeterministic\n | Deterministic of string\n [@@deriving sexp_of]\n end\n\n module Potentially_infinite_sequence = struct\n type 'a t = 'a Sequence.t\n\n let sexp_of_t sexp_of_elt sequence =\n let prefix, suffix = Sequence.split_n sequence 100 in\n let prefix = List.map prefix ~f:sexp_of_elt in\n let suffix =\n match Sequence.is_empty suffix with\n | true -> []\n | false -> [ [%message \"...\"] ]\n in\n Sexp.List (prefix @ suffix)\n ;;\n end\n\n type t =\n { seed : Seed.t\n ; test_count : int\n ; shrink_count : int\n ; sizes : int Potentially_infinite_sequence.t\n }\n [@@deriving fields, sexp_of]\nend\n\nlet default_config : Config.t =\n { seed = Deterministic \"an arbitrary but deterministic string\"\n ; test_count = 10_000\n ; shrink_count = 10_000\n ; sizes = Sequence.cycle_list_exn (List.range 0 ~start:`inclusive 30 ~stop:`inclusive)\n }\n;;\n\nlet lazy_nondeterministic_state = lazy (Random.State.make_self_init ())\n\nlet initial_random_state ~config =\n match Config.seed config with\n | Nondeterministic ->\n Splittable_random.State.create (force lazy_nondeterministic_state)\n | Deterministic string -> Splittable_random.State.of_int (String.hash string)\n;;\n\nlet one_size_per_test ~(config : Config.t) =\n Sequence.unfold ~init:(config.sizes, 0) ~f:(fun (sizes, number_of_size_values) ->\n match number_of_size_values >= config.test_count with\n | true -> None\n | false ->\n (match Sequence.next sizes with\n | Some (size, remaining_sizes) ->\n Some (size, (remaining_sizes, number_of_size_values + 1))\n | None ->\n raise_s\n [%message\n \"Base_quickcheck.Test.run: insufficient size values for test count\"\n ~test_count:(config.test_count : int)\n (number_of_size_values : int)]))\n;;\n\nlet shrink_error ~shrinker ~config ~f input error =\n let rec loop ~shrink_count ~alternates input error =\n match shrink_count with\n | 0 -> input, error\n | _ ->\n let shrink_count = shrink_count - 1 in\n (match Sequence.next alternates with\n | None -> input, error\n | Some (alternate, alternates) ->\n (match f alternate with\n | Ok () -> loop ~shrink_count ~alternates input error\n | Error error ->\n let alternates = Shrinker.shrink shrinker alternate in\n loop ~shrink_count ~alternates alternate error))\n in\n let shrink_count = Config.shrink_count config in\n let alternates = Shrinker.shrink shrinker input in\n loop ~shrink_count ~alternates input error\n;;\n\nlet input_sequence ~config ~examples ~generator =\n let random = initial_random_state ~config in\n Sequence.append\n (Sequence.of_list examples)\n (one_size_per_test ~config\n |> Sequence.map ~f:(fun size -> Generator.generate generator ~size ~random))\n;;\n\nlet with_sample ~f ?(config = default_config) ?(examples = []) generator =\n let sequence = input_sequence ~config ~examples ~generator in\n f sequence\n;;\n\nlet result (type a) ~f ?(config = default_config) ?(examples = []) m =\n let (module M : S with type t = a) = m in\n with_sample M.quickcheck_generator ~config ~examples ~f:(fun sequence ->\n match\n Sequence.fold_result sequence ~init:() ~f:(fun () input ->\n match f input with\n | Ok () -> Ok ()\n | Error error -> Error (input, error))\n with\n | Ok () -> Ok ()\n | Error (input, error) ->\n let shrinker = M.quickcheck_shrinker in\n let input, error = shrink_error ~shrinker ~config ~f input error in\n Error (input, error))\n;;\n\nlet run (type a) ~f ?config ?examples (module M : S with type t = a) =\n let f x =\n Or_error.try_with_join ~backtrace:(Backtrace.Exn.am_recording ()) (fun () -> f x)\n in\n match result ~f ?config ?examples (module M) with\n | Ok () -> Ok ()\n | Error (input, error) ->\n Or_error.error_s\n [%message \"Base_quickcheck.Test.run: test failed\" (input : M.t) (error : Error.t)]\n;;\n\nlet with_sample_exn ~f ?config ?examples generator =\n let f x = Or_error.try_with (fun () -> f x) in\n with_sample ~f ?config ?examples generator |> Or_error.ok_exn\n;;\n\nlet run_exn ~f ?config ?examples testable =\n let f x =\n Or_error.try_with ~backtrace:(Backtrace.Exn.am_recording ()) (fun () -> f x)\n in\n run ~f ?config ?examples testable |> Or_error.ok_exn\n;;\n","open! Base\ninclude Observer0\n\nlet unmap t ~f = create (fun x ~size ~hash -> observe t (f x) ~size ~hash)\nlet of_hash_fold f = create (fun x ~size:_ ~hash -> f hash x)\nlet of_lazy lazy_t = create (fun x ~size ~hash -> observe (force lazy_t) x ~size ~hash)\n\nlet fixed_point wrap =\n let rec lazy_t = lazy (wrap (of_lazy lazy_t)) in\n of_lazy lazy_t\n;;\n\nlet unit = opaque\nlet bool = of_hash_fold Bool.hash_fold_t\nlet char = of_hash_fold Char.hash_fold_t\nlet int = of_hash_fold Int.hash_fold_t\nlet int32 = of_hash_fold Int32.hash_fold_t\nlet int63 = of_hash_fold Int63.hash_fold_t\nlet int64 = of_hash_fold Int64.hash_fold_t\nlet nativeint = of_hash_fold Nativeint.hash_fold_t\nlet float = of_hash_fold Float.hash_fold_t\nlet string = of_hash_fold String.hash_fold_t\nlet sexp = of_hash_fold Sexp.hash_fold_t\nlet bigstring = of_hash_fold (Bigarray_helpers.Array1.hash_fold hash_fold_char)\nlet float32_vec = of_hash_fold (Bigarray_helpers.Array1.hash_fold hash_fold_float)\nlet float64_vec = of_hash_fold (Bigarray_helpers.Array1.hash_fold hash_fold_float)\nlet float32_mat = of_hash_fold (Bigarray_helpers.Array2.hash_fold hash_fold_float)\nlet float64_mat = of_hash_fold (Bigarray_helpers.Array2.hash_fold hash_fold_float)\n\nlet either fst_t snd_t =\n create (fun either ~size ~hash ->\n match (either : _ Either.t) with\n | First fst -> observe fst_t fst ~size ~hash:(hash_fold_int hash 1)\n | Second snd -> observe snd_t snd ~size ~hash:(hash_fold_int hash 2))\n;;\n\nlet result ok_t err_t =\n unmap (either ok_t err_t) ~f:(function\n | Ok ok -> First ok\n | Error err -> Second err)\n;;\n\nlet both fst_t snd_t =\n create (fun (fst, snd) ~size ~hash ->\n let hash = observe fst_t fst ~size ~hash in\n let hash = observe snd_t snd ~size ~hash in\n hash)\n;;\n\nlet option value_t =\n unmap (either opaque value_t) ~f:(function\n | None -> First ()\n | Some value -> Second value)\n;;\n\nlet list elt_t =\n create (fun list ~size ~hash ->\n let random = Splittable_random.State.of_int (Hash.get_hash_value hash) in\n let length = List.length list in\n let sizes =\n Generator.sizes ~min_length:length ~max_length:length ()\n |> Generator.generate ~size ~random\n in\n List.fold2_exn list sizes ~init:(hash_fold_int hash 0) ~f:(fun hash elt size ->\n observe elt_t elt ~size ~hash:(hash_fold_int hash 1)))\n;;\n\nlet fn dom rng =\n create (fun f ~size ~hash ->\n let random = Splittable_random.State.of_int (Hash.get_hash_value hash) in\n let sizes =\n (* Empirically, doubling the size when generating the list of inputs gives us much\n better coverage of the space of functions. *)\n Generator.generate (Generator.sizes ()) ~size:(size * 2) ~random\n in\n List.fold sizes ~init:hash ~f:(fun hash size ->\n let x = Generator.generate dom ~size ~random in\n observe rng (f x) ~size ~hash))\n;;\n\nlet map_tree key_obs data_obs =\n unmap (list (both key_obs data_obs)) ~f:Map.Using_comparator.Tree.to_alist\n;;\n\nlet set_tree elt_obs = unmap (list elt_obs) ~f:Set.Using_comparator.Tree.to_list\n\nlet map_t key_obs data_obs =\n unmap (map_tree key_obs data_obs) ~f:Map.Using_comparator.to_tree\n;;\n\nlet set_t elt_obs = unmap (set_tree elt_obs) ~f:Set.Using_comparator.to_tree\n","open! Base\nopen! Blit\n\ninclude Test_blit_intf\n\nmodule type S_gen = sig\n open Blit\n type 'a src\n type 'a dst\n (* val blit : ('a src, 'a dst) blit*)\n val blito : ('a src, 'a dst) blito\n (* val unsafe_blit : ('a src, 'a dst) blit*)\n val sub : ('a src, 'a dst) sub\n (*val subo : ('a src, 'a dst) subo*)\nend\n\nmodule type For_tests_gen = sig\n module Elt : sig\n type 'a t\n val equal : bool t -> bool t -> bool\n val of_bool : bool -> bool t\n end\n\n type 'a z\n\n module Src : sig\n type 'a t\n val length : _ t -> int\n val create_bool : len:int -> bool z t\n val get : 'a z t -> int -> 'a Elt.t\n val set : 'a z t -> int -> 'a Elt.t -> unit\n end\n\n module Dst : sig\n type 'a t\n val length : _ t -> int\n val create_bool : len:int -> bool z t\n val get : 'a z t -> int -> 'a Elt.t\n val set : 'a z t -> int -> 'a Elt.t -> unit\n val overlapping_src_dst\n : [ `Do_not_check\n | `Check of ('a Src.t -> 'a t)\n ]\n end\nend\n\nmodule Test_gen\n (For_tests : For_tests_gen)\n (Tested : S_gen\n with type 'a src := 'a For_tests.Src.t\n with type 'a dst := 'a For_tests.Dst.t)\n= struct\n open Tested\n open For_tests\n\n let init ~len ~create ~set ~f =\n let t = create ~len in\n for i = 0 to len - 1 do\n set t i (f i);\n done;\n t\n ;;\n\n (* Test [blit]. *)\n let%test_unit _ =\n let elt1 = Elt.of_bool true in\n let elt2 = Elt.of_bool false in\n assert (not (Elt.equal elt1 elt2));\n let src_bit i = if i land 0x1 = 0 then elt1 else elt2 in\n let dst_bit i = if i land 0x1 = 0 then elt2 else elt1 in\n let n = 4 in\n for src_length = 0 to n do\n for dst_length = 0 to n do\n for src_pos = 0 to src_length do\n for dst_pos = 0 to dst_length do\n for src_len = 0 to min (src_length - src_pos) (dst_length - dst_pos) do\n try\n let is_in_range i = i >= dst_pos && i < dst_pos + src_len in\n let check length get =\n fun name sequence ~expect ->\n for i = 0 to length sequence - 1 do\n if not (Elt.equal (get sequence i) (expect i)) then\n raise_s [%message \"bug\" (name : string) (i : int)]\n done;\n in\n let check_src = check Src.length Src.get in\n let check_dst = check Dst.length Dst.get in\n let src =\n init ~len:src_length ~create:Src.create_bool ~set:Src.set ~f:src_bit\n in\n assert (Src.length src = src_length);\n let dst =\n init ~len:dst_length ~create:Dst.create_bool ~set:Dst.set ~f:dst_bit\n in\n assert (Dst.length dst = dst_length);\n let init_src () =\n for i = 0 to src_length - 1 do\n Src.set src i (src_bit i);\n done\n in\n blito ~src ~src_pos ~src_len ~dst ~dst_pos ();\n check_src \"blit src\" src ~expect:src_bit;\n check_dst \"blit dst\" dst ~expect:(fun i ->\n if is_in_range i\n then src_bit (src_pos + i - dst_pos)\n else dst_bit i);\n begin match Dst.overlapping_src_dst with\n | `Do_not_check -> ()\n | `Check src_to_dst ->\n if dst_pos + src_len <= src_length then begin\n init_src ();\n let dst = src_to_dst src in\n if false then begin\n blito ~src ~src_pos ~src_len ~dst ~dst_pos ();\n check_dst \"blit dst overlapping\" dst ~expect:(fun i ->\n src_bit (if is_in_range i then (src_pos + i - dst_pos) else i));\n end;\n end;\n end;\n (* Check [sub]. *)\n init_src ();\n let dst = sub src ~pos:src_pos ~len:src_len in\n check_src \"sub src\" src ~expect:src_bit;\n check_dst \"sub dst\" dst ~expect:(fun i -> src_bit (src_pos + i));\n with exn ->\n raise_s [%message\n \"bug\"\n (exn : exn)\n (src_length : int) (src_pos : int)\n (dst_length : int) (dst_pos : int)]\n done;\n done;\n done;\n done;\n done\n ;;\nend\n\nmodule Test1\n (Sequence : Sequence1 with type 'a elt := 'a poly)\n (Tested : S1 with type 'a t := 'a Sequence.t)\n = Test_gen\n (struct\n module Elt = struct\n type 'a t = 'a\n let equal = Poly.equal\n let of_bool = Fn.id\n end\n type 'a z = 'a Sequence.z\n module Src = Sequence\n module Dst = struct\n include Sequence\n let overlapping_src_dst = `Check Fn.id\n end\n end)\n (Tested)\n\nmodule Test1_generic\n (Elt : Elt1)\n (Sequence : Sequence1 with type 'a elt := 'a Elt.t)\n (Tested : S1 with type 'a t := 'a Sequence.t)\n = Test_gen\n (struct\n module Elt = Elt\n type 'a z = 'a Sequence.z\n module Src = Sequence\n module Dst = struct\n include Sequence\n let overlapping_src_dst = `Check Fn.id\n end\n end)\n (Tested)\n\nmodule Elt_to_elt1 (Elt : Elt) = struct\n type 'a t = Elt.t\n let equal = Elt.equal\n let of_bool = Elt.of_bool\nend\n\nmodule Test\n (Elt : Elt)\n (Sequence : Sequence with type elt := Elt.t)\n (Tested : S with type t := Sequence.t)\n = Test_gen\n (struct\n module Elt = Elt_to_elt1(Elt)\n type 'a z = unit\n module Src = struct\n open Sequence\n type nonrec 'a t = t\n let length = length\n let get = get\n let set = set\n let create_bool = create\n end\n module Dst = struct\n include Src\n let overlapping_src_dst = `Check Fn.id\n end\n end)\n (Tested)\n\nmodule Test_distinct\n (Elt : Elt)\n (Src : Sequence with type elt := Elt.t)\n (Dst : Sequence with type elt := Elt.t)\n (Tested : S_distinct\n with type src := Src.t\n with type dst := Dst.t)\n = Test_gen\n (struct\n module Elt = Elt_to_elt1 (Elt)\n type 'a z = unit\n module Src = struct\n open Src\n type nonrec 'a t = t\n let length = length\n let get = get\n let set = set\n let create_bool = create\n end\n module Dst = struct\n open Dst\n type nonrec 'a t = t\n let length = length\n let get = get\n let set = set\n let create_bool = create\n let overlapping_src_dst = `Do_not_check\n end\n end)\n (Tested)\n\nmodule Make_and_test\n (Elt : Elt)\n (Sequence : sig\n include Sequence with type elt := Elt.t\n val unsafe_blit : (t, t) blit\n end) = struct\n module B = Make (Sequence)\n include Test (Elt) (Sequence) (B)\n include B\nend\n\nmodule Make_distinct_and_test\n (Elt : Elt)\n (Src : Sequence with type elt := Elt.t)\n (Dst : sig\n include Sequence with type elt := Elt.t\n val unsafe_blit : (Src.t, t) blit\n end) = struct\n module B = Make_distinct (Src) (Dst)\n include Test_distinct (Elt) (Src) (Dst) (B)\n include B\nend\n\nmodule Make1_and_test\n (Sequence : sig\n include Blit.Sequence1\n include Sequence1\n with type 'a t := 'a t\n with type 'a elt := 'a poly\n end) = struct\n module B = Make1 (Sequence)\n include Test1 (Sequence) (B)\n include B\nend\n\nmodule Make1_generic_and_test\n (Elt : Elt1)\n (Sequence : sig\n include Blit.Sequence1\n include Sequence1\n with type 'a t := 'a t\n with type 'a elt := 'a Elt.t\n end) = struct\n module B = Make1_generic (Sequence)\n include Test1_generic (Elt) (Sequence) (B)\n include B\nend\n","open! Base\nopen! Binary_searchable\n\ninclude Test_binary_searchable_intf\n\nmodule type S_gen = sig\n open Binary_searchable\n\n type 'a t\n type 'a elt\n\n val binary_search : ('a t, 'a elt, 'a elt) binary_search\n val binary_search_segmented : ('a t, 'a elt) binary_search_segmented\nend\n\nmodule type Indexable_gen_and_for_test = sig\n include S_gen\n\n module For_test : sig\n val compare : bool elt -> bool elt -> int\n val small : bool elt\n val big : bool elt\n val of_array : bool elt array -> bool t\n end\nend\n\nmodule Test_gen (M : Indexable_gen_and_for_test) = struct\n open M\n\n let%test_module \"test_binary_searchable\" =\n (module struct\n let compare = For_test.compare\n let elt_compare = For_test.compare\n\n let s = For_test.small\n let b = For_test.big\n\n let binary_search ?pos ?len ~compare t how v =\n binary_search ?pos ?len ~compare (For_test.of_array t) how v\n\n let (=) = Poly.equal\n\n let%test _ = binary_search ~compare [| |] `First_equal_to s = None\n let%test _ = binary_search ~compare [| s |] `First_equal_to s = Some 0\n let%test _ = binary_search ~compare [| s |] `First_equal_to b = None\n let%test _ = binary_search ~compare [| s ; b |] `First_equal_to s = Some 0\n let%test _ = binary_search ~compare [| s ; b |] `First_equal_to b = Some 1\n let%test _ = binary_search ~compare [| b ; b |] `First_equal_to s = None\n let%test _ = binary_search ~compare [| s ; s |] `First_equal_to b = None\n let%test _ = binary_search ~compare [| s ; b ; b |] `First_equal_to b = Some 1\n let%test _ = binary_search ~compare [| s ; s ; b |] `First_equal_to s = Some 0\n let%test _ = binary_search ~compare [| b ; b ; b |] `First_equal_to s = None\n\n let%test _ = binary_search ~compare [| |] `Last_equal_to s = None\n let%test _ = binary_search ~compare [| s |] `Last_equal_to s = Some 0\n let%test _ = binary_search ~compare [| s |] `Last_equal_to b = None\n let%test _ = binary_search ~compare [| s ; b |] `Last_equal_to b = Some 1\n let%test _ = binary_search ~compare [| s ; b |] `Last_equal_to s = Some 0\n let%test _ = binary_search ~compare [| b ; b |] `Last_equal_to s = None\n let%test _ = binary_search ~compare [| s ; s |] `Last_equal_to b = None\n let%test _ = binary_search ~compare [| s ; b ; b |] `Last_equal_to b = Some 2\n let%test _ = binary_search ~compare [| s ; s ; b |] `Last_equal_to s = Some 1\n let%test _ = binary_search ~compare [| b ; b; b |] `Last_equal_to s = None\n\n let%test _ = binary_search ~compare [||] `First_greater_than_or_equal_to s = None\n let%test _ = binary_search ~compare [| b |] `First_greater_than_or_equal_to s = Some 0\n let%test _ = binary_search ~compare [| s |] `First_greater_than_or_equal_to s = Some 0\n let%test _ = binary_search ~compare [| s |] `First_strictly_greater_than s = None\n\n let%test _ = binary_search ~compare [||] `Last_less_than_or_equal_to s = None\n let%test _ = binary_search ~compare [| b |] `Last_less_than_or_equal_to s = None\n let%test _ = binary_search ~compare [| s |] `Last_less_than_or_equal_to s = Some 0\n let%test _ = binary_search ~compare [| s |] `Last_strictly_less_than s = None\n\n let create_test_case (num_s, num_b) =\n let arr = Array.create b ~len:(num_s + num_b) in\n for i = 0 to num_s -1 do\n arr.(i) <- s\n done;\n arr\n ;;\n\n let only_small = (10_000, 0)\n let only_big = (0, 10_000)\n\n let both = (2531, 4717)\n\n let%test _ =\n match binary_search (create_test_case only_small) ~compare `First_equal_to s with\n | None -> false\n | Some _ -> true\n\n let%test _ =\n let arr = create_test_case both in\n match binary_search arr ~compare `First_equal_to b with\n | None -> false\n | Some v -> v = 2531\n\n let%test _ =\n let arr = create_test_case only_small in\n binary_search arr ~compare `First_equal_to b = None\n\n let create_deterministic_test () =\n Array.init 100_000 ~f:(fun i -> if i > 50_000 then b else s)\n\n let%test _ =\n let arr = create_deterministic_test () in\n binary_search arr ~compare `First_equal_to s = Some 0\n\n let%test _ =\n let arr = create_deterministic_test () in\n binary_search arr ~compare `Last_equal_to s = Some 50_000\n\n let%test _ =\n let arr = create_deterministic_test () in\n binary_search arr ~compare `First_greater_than_or_equal_to s = Some 0\n\n let%test _ =\n let arr = create_deterministic_test () in\n binary_search arr ~compare `Last_less_than_or_equal_to s = Some 50_000\n\n let%test _ =\n let arr = create_deterministic_test () in\n binary_search arr ~compare `First_strictly_greater_than s = Some 50_001\n\n let%test _ =\n let arr = create_deterministic_test () in\n binary_search arr ~compare `Last_strictly_less_than b = Some 50_000\n\n (* tests around a gap*)\n let%test _ =\n let arr = create_deterministic_test () in\n binary_search arr ~compare `First_equal_to b = Some 50_001\n\n let%test _ =\n let arr = create_deterministic_test () in\n binary_search arr ~compare `Last_equal_to b = Some 99_999\n\n let%test _ =\n let arr = create_deterministic_test () in\n binary_search arr ~compare `First_greater_than_or_equal_to b = Some 50_001\n\n let%test _ =\n let arr = create_deterministic_test () in\n binary_search arr ~compare `Last_less_than_or_equal_to b = Some 99_999\n\n let%test _ =\n let arr = create_deterministic_test () in\n binary_search arr ~compare `First_strictly_greater_than b = None\n\n let%test _ =\n let arr = create_deterministic_test () in\n binary_search arr ~compare `Last_strictly_less_than b = Some 50_000\n\n (* test beginning of array *)\n\n let%test _ =\n let arr = create_test_case only_big in\n binary_search arr ~compare `First_equal_to s = None\n\n let%test _ =\n let arr = create_test_case only_big in\n binary_search arr ~compare `Last_equal_to s = None\n\n let%test _ =\n let arr = create_test_case only_big in\n binary_search arr ~compare `First_greater_than_or_equal_to s = Some 0\n\n let%test _ =\n let arr = create_test_case only_big in\n binary_search arr ~compare `Last_less_than_or_equal_to s = None\n\n let%test _ =\n let arr = create_test_case only_big in\n binary_search arr ~compare `First_strictly_greater_than s = Some 0\n\n let%test _ =\n let arr = create_test_case only_big in\n binary_search arr ~compare `Last_strictly_less_than b = None\n\n\n (* test end of array *)\n\n let%test _ =\n let arr = create_test_case only_small in\n binary_search arr ~compare `First_equal_to b = None\n\n let%test _ =\n let arr = create_test_case only_small in\n binary_search arr ~compare `Last_equal_to b = None\n\n let%test _ =\n let arr = create_test_case only_small in\n binary_search arr ~compare `First_greater_than_or_equal_to b = None\n\n let%test _ =\n let arr = create_test_case only_small in\n binary_search arr ~compare `Last_less_than_or_equal_to b = Some 9_999\n\n let%test _ =\n let arr = create_test_case only_small in\n binary_search arr ~compare `First_strictly_greater_than s = None\n\n let%test _ =\n let arr = create_test_case only_small in\n binary_search arr ~compare `Last_strictly_less_than b = Some 9_999\n\n let%test_unit _ =\n for length = 0 to 5 do\n for num_s = 0 to length do\n let arr = Array.init length ~f:(fun i -> if i < num_s then s else b) in\n for pos = -1 to length do\n for len = -1 to length + 1 do\n (*try*)\n let should_raise =\n Exn.does_raise (fun () ->\n Ordered_collection_common.check_pos_len_exn ~pos ~len\n ~total_length:length)\n in\n let result =\n Result.try_with (fun () ->\n binary_search arr ~pos ~len ~compare:elt_compare `Last_equal_to s)\n in\n match should_raise, result with\n | true , Error _ -> ()\n | true , Ok _ -> failwith \"expected it to raise but it didn't\"\n | false, Error _ -> failwith \"expected it to not raise, but it raised\"\n | false, Ok result ->\n let searched = num_s - 1 in\n let correct_result =\n if searched < pos then None\n else if len = 0 then None\n else if searched >= pos + len then Some(pos + len - 1)\n else Some searched\n in\n if not (correct_result = result) then failwith \"Wrong result\"\n (*with exn ->\n failwiths \"binary_search bug\"\n (exn, `length length, `search_key search_key, `pos pos, `len len)\n <:sexp_of< exn * [ `length of int ] * [ `search_key of int ]\n * [ `pos of int ] * [ `len of int ] >>*)\n done;\n done;\n done;\n done\n ;;\n\n let binary_search_segmented a = binary_search_segmented (For_test.of_array a)\n\n (*test for binary_search_segmented*)\n let%test _ =\n let arr = create_deterministic_test () in\n let segment_of x = if x = b then `Right else `Left in\n binary_search_segmented arr ~segment_of `Last_on_left = Some 50_000 &&\n binary_search_segmented arr ~segment_of `First_on_right = Some 50_001\n\n let%test _ =\n let arr = create_deterministic_test () in\n let segment_of _ = `Right in\n binary_search_segmented arr ~segment_of `Last_on_left = None &&\n binary_search_segmented arr ~segment_of `First_on_right = Some 0\n\n let%test _ =\n let arr = create_deterministic_test () in\n let segment_of _ = `Left in\n binary_search_segmented arr ~segment_of `Last_on_left = Some 99_999 &&\n binary_search_segmented arr ~segment_of `First_on_right = None\n\n end)\nend\n\nmodule Test (M : Binary_searchable_and_for_test) =\n Test_gen\n (struct\n type 'a t = M.t\n type 'a elt = M.elt\n let binary_search = M.binary_search\n let binary_search_segmented = M.binary_search_segmented\n module For_test = M.For_test\n end)\n\nmodule Test1 (M : Binary_searchable1_and_for_test) =\n Test_gen\n (struct\n type 'a t = 'a M.t\n type 'a elt = 'a\n let binary_search = M.binary_search\n let binary_search_segmented = M.binary_search_segmented\n module For_test = struct\n let of_array = M.For_test.of_array\n let compare = Bool.compare\n let small = false\n let big = true\n end\n end)\n\nmodule Make_and_test (M : Indexable_and_for_test) = struct\n module B = Binary_searchable.Make (M)\n include B\n include Test (struct\n type t = M.t\n type elt = M.elt\n include B\n module For_test = M.For_test\n end)\nend\n\nmodule Make1_and_test (M : Indexable1_and_for_test) = struct\n module B = Binary_searchable.Make1 (M)\n include B\n include Test1 (struct\n type 'a t = 'a M.t\n include B\n module For_test = M.For_test\n end)\nend\n","open! Import\n\nmodule type Conv = Conv.S\nmodule type Parser = Parser.S\nmodule type Eager_parser = Parser.S_eager\n\nmodule Conv_error = Conv_error\nmodule Of_sexp_error = Of_sexp_error\nmodule Old_parser_cont_state = Old_parser_cont_state\nmodule Parse_error = Parse_error\nmodule Positions = Positions\nmodule Cst = Cst\nmodule A = Parser_automaton\n\nexception Parse_error = Parse_error.Parse_error\nexception Of_sexp_error = Of_sexp_error.Of_sexp_error\n\nmodule Single =\n Parser.Make\n (Kind.Sexp)\n (struct\n type parsed_value = Sexp.t\n\n let mode = A.Single\n let make_value _ stack = Automaton_stack.get_single stack\n end)\n\nmodule Many =\n Parser.Make\n (Kind.Sexp)\n (struct\n type parsed_value = Sexp.t list\n\n let mode = A.Many\n let make_value _ stack = Automaton_stack.get_many stack\n end)\n\nmodule Eager =\n Parser.Make_eager\n (Kind.Sexp)\n (struct\n type parsed_value = Sexp.t\n\n let make_value _ stack = Automaton_stack.get_single stack\n end)\n\nmodule Single_and_positions =\n Parser.Make\n (Kind.Sexp_with_positions)\n (struct\n type parsed_value = Sexp.t * Positions.t\n\n let mode = A.Single\n let make_value state stack = Automaton_stack.get_single stack, A.positions state\n end)\n\nmodule Many_and_positions =\n Parser.Make\n (Kind.Sexp_with_positions)\n (struct\n type parsed_value = Sexp.t list * Positions.t\n\n let mode = A.Many\n let make_value state stack = Automaton_stack.get_many stack, A.positions state\n end)\n\nmodule Eager_and_positions =\n Parser.Make_eager\n (Kind.Sexp_with_positions)\n (struct\n type parsed_value = Sexp.t * Positions.t\n\n let make_value state stack = Automaton_stack.get_single stack, A.positions state\n end)\n\nmodule Single_just_positions =\n Parser.Make\n (Kind.Positions)\n (struct\n type parsed_value = Positions.t\n\n let mode = A.Single\n let make_value state () = A.positions state\n end)\n\nmodule Many_just_positions =\n Parser.Make\n (Kind.Positions)\n (struct\n type parsed_value = Positions.t\n\n let mode = A.Many\n let make_value state () = A.positions state\n end)\n\nmodule Eager_just_positions =\n Parser.Make_eager\n (Kind.Positions)\n (struct\n type parsed_value = Positions.t\n\n let make_value state () = A.positions state\n end)\n\nmodule Many_cst =\n Parser.Make\n (Kind.Cst)\n (struct\n type parsed_value = Cst.t_or_comment list\n\n let mode = A.Many\n let make_value _ stack = Automaton_stack.For_cst.get_many stack\n end)\n\nmodule Eager_cst =\n Parser.Make_eager\n (Kind.Cst)\n (struct\n type parsed_value = Cst.t_or_comment\n\n let make_value _ stack =\n match Automaton_stack.For_cst.get_many stack with\n | [ sexp ] -> sexp\n | _ -> assert false\n ;;\n end)\n\ntype 'a id = 'a\ntype sexp_list = Sexp.t list\n\nmodule Conv_single =\n Conv.Make\n (struct\n type 'a res = 'a\n type parsed_sexp = Sexp.t\n type chunk_to_conv = Sexp.t\n\n let apply_f x ~f = f x\n let find = Positions.find_sub_sexp_phys\n end)\n (Single)\n (Single_just_positions)\n\nmodule Conv_many =\n Conv.Make\n (struct\n type 'a res = 'a list\n type parsed_sexp = Sexp.t list\n type chunk_to_conv = Sexp.t\n\n let apply_f x ~f = List.rev (List.rev_map x ~f)\n let find = Positions.find_sub_sexp_in_list_phys\n end)\n (Many)\n (Many_just_positions)\n\nmodule Conv_many_at_once =\n Conv.Make\n (struct\n type 'a res = 'a\n type parsed_sexp = Sexp.t list\n type chunk_to_conv = Sexp.t list\n\n let apply_f x ~f = f x\n let find = Positions.find_sub_sexp_in_list_phys\n end)\n (Many)\n (Many_just_positions)\n\nmodule Private = struct\n module Automaton_stack = Automaton_stack\n module Parser_automaton = Parser_automaton\nend\n","open! Import\ninclude Automaton_stack_intf\n\nmodule For_cst = struct\n type t =\n | Empty\n | T_or_comment of Cst.t_or_comment * t\n | Open of Positions.pos * t\n | In_sexp_comment of\n { hash_semi_pos : Positions.pos\n ; rev_comments : Cst.comment list\n ; stack : t\n }\n\n let empty = Empty\n\n let get_many =\n let rec loop acc = function\n | Empty -> acc\n | T_or_comment (t, stack) -> loop (t :: acc) stack\n | Open _ | In_sexp_comment _ -> failwith \"Automaton_stack.For_cst.get_many\"\n in\n fun stack -> loop [] stack\n ;;\nend\n\nmodule Just_positions = struct\n type t = unit\n\n let empty = ()\nend\n\ntype t =\n | Empty\n | Open of t\n | Sexp of Sexp.t * t\n\nlet empty = Empty\n\nlet get_single = function\n | Sexp (sexp, Empty) -> sexp\n | _ -> failwith \"Automaton_stack.get_single\"\n;;\n\nlet get_many =\n let rec loop acc = function\n | Empty -> acc\n | Open _ -> failwith \"Automaton_stack.get_many\"\n | Sexp (sexp, stack) -> loop (sexp :: acc) stack\n in\n fun stack -> loop [] stack\n;;\n","open! Import\n\ntype t =\n { user_exn : exn\n ; sub_sexp : Sexp.t\n ; location : Positions.range option\n }\n[@@deriving_inline sexp_of]\n\nlet sexp_of_t =\n (function\n | { user_exn = v_user_exn; sub_sexp = v_sub_sexp; location = v_location } ->\n let bnds = [] in\n let bnds =\n let arg = sexp_of_option Positions.sexp_of_range v_location in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"location\"; arg ]\n :: bnds\n in\n let bnds =\n let arg = Sexp.sexp_of_t v_sub_sexp in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"sub_sexp\"; arg ]\n :: bnds\n in\n let bnds =\n let arg = sexp_of_exn v_user_exn in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"user_exn\"; arg ]\n :: bnds\n in\n Ppx_sexp_conv_lib.Sexp.List bnds\n : t -> Ppx_sexp_conv_lib.Sexp.t)\n;;\n\n[@@@end]\n\nlet user_exn t = t.user_exn\nlet sub_sexp t = t.sub_sexp\nlet location t = t.location\n\nlet report ppf ~filename t =\n let line, start, stop =\n match t.location with\n | None -> 1, 0, 0\n | Some { start_pos; end_pos } ->\n start_pos.line, start_pos.col, start_pos.col + end_pos.offset - start_pos.offset\n in\n Format.fprintf\n ppf\n \"File \\\"%s\\\", line %d, characters %d-%d:\\n\\\n Error: s-expression conversion error;\\n\\\n exception %s\\n\"\n filename\n line\n start\n stop\n (Printexc.to_string t.user_exn)\n;;\n\nexception Of_sexp_error of t [@@deriving_inline sexp_of]\n\nlet () =\n Ppx_sexp_conv_lib.Conv.Exn_converter.add\n [%extension_constructor Of_sexp_error]\n (function\n | Of_sexp_error v0 ->\n let v0 = sexp_of_t v0 in\n Ppx_sexp_conv_lib.Sexp.List\n [ Ppx_sexp_conv_lib.Sexp.Atom \"of_sexp_error.ml.Of_sexp_error\"; v0 ]\n | _ -> assert false)\n;;\n\n[@@@end]\n\nlet raise ~user_exn ~sub_sexp ~location =\n raise (Of_sexp_error { user_exn; sub_sexp; location })\n;;\n","open! Import\ninclude Parse_error_intf\n\ntype t =\n { position : Positions.pos\n ; message : string\n ; old_parser_exn : [ `Parse_error | `Failure ]\n }\n\nlet sexp_of_t { position; message; old_parser_exn = _ } : Sexp.t =\n List\n [ List [ Atom \"position\"; Positions.sexp_of_pos position ]\n ; List [ Atom \"message\"; sexp_of_string message ]\n ]\n;;\n\nlet position t = t.position\nlet message t = t.message\nlet old_parser_exn t = t.old_parser_exn\n\nlet report ppf ~filename t =\n let pos = position t in\n let msg = message t in\n Format.fprintf\n ppf\n \"File \\\"%s\\\", line %d, character %d:\\nError: s-expression parsing error;\\n%s\\n\"\n filename\n pos.line\n pos.col\n msg\n;;\n\nexception Parse_error of t [@@deriving_inline sexp]\n\nlet () =\n Ppx_sexp_conv_lib.Conv.Exn_converter.add [%extension_constructor Parse_error] (function\n | Parse_error v0 ->\n let v0 = sexp_of_t v0 in\n Ppx_sexp_conv_lib.Sexp.List\n [ Ppx_sexp_conv_lib.Sexp.Atom \"parse_error.ml.Parse_error\"; v0 ]\n | _ -> assert false)\n;;\n\n[@@@end]\n\nlet raise (reason : Reason.t) position ~at_eof ~atom_buffer =\n let message =\n (* These messages where choosen such that we can build the various Sexplib parsing\n functions on top of Parsexp and keep the same exceptions.\n\n At the time of writing this, a simple layer on top of parsexp to implement the\n sexplib API is passing all the sexplib tests.\n\n Note that parsexp matches the semantic of Sexp.parse which is slightly\n different from the ocamllex/ocamlyacc based parser of Sexplib. The latter one\n is less tested and assumed to be less used. *)\n match reason with\n | Unexpected_char_parsing_hex_escape -> \"unterminated hexadecimal escape sequence\"\n | Unexpected_char_parsing_dec_escape -> \"unterminated decimal escape sequence\"\n | Unterminated_quoted_string -> \"unterminated quoted string\"\n | Unterminated_block_comment -> \"unterminated block comment\"\n | Escape_sequence_out_of_range -> \"escape sequence in quoted string out of range\"\n | Unclosed_paren -> \"unclosed parentheses at end of input\"\n | Too_many_sexps -> \"s-expression followed by data\"\n | Closed_paren_without_opened -> \"unexpected character: ')'\"\n | Comment_token_in_unquoted_atom ->\n if String.equal (Buffer.contents atom_buffer) \"|\"\n then \"illegal end of comment\"\n else \"comment tokens in unquoted atom\"\n | Sexp_comment_without_sexp -> \"unterminated sexp comment\"\n | Unexpected_character_after_cr ->\n if at_eof\n then \"unexpected end of input after carriage return\"\n else \"unexpected character after carriage return\"\n | No_sexp_found_in_input -> \"no s-expression found in input\"\n | Automaton_in_error_state -> failwith \"Parsexp.Parser_automaton: parser is dead\"\n in\n let old_parser_exn =\n match reason, at_eof with\n | Too_many_sexps, _ | _, true -> `Failure\n | Comment_token_in_unquoted_atom, _\n when String.equal (Buffer.contents atom_buffer) \"|\" -> `Failure\n | _ -> `Parse_error\n in\n raise (Parse_error { position; message; old_parser_exn })\n;;\n\nmodule Private = struct\n module Reason = Reason\n\n let old_parser_exn = old_parser_exn\n let raise = raise\nend\n","open! Import\n\nmodule Public = struct\n type state_cst =\n { token_buffer : Buffer.t\n ; (* Starting positions of the current token *)\n mutable token_start_pos : Positions.pos\n }\n\n type ('u, 's) kind =\n | Positions : (Positions.Builder.t, unit) kind\n | Sexp : (unit, Automaton_stack.t) kind\n | Sexp_with_positions : (Positions.Builder.t, Automaton_stack.t) kind\n | Cst : (state_cst, Automaton_stack.For_cst.t) kind\n\n type ('u, 's) state =\n { mutable automaton_state : int\n ; kind : ('u, 's) kind\n ; mutable depth : int\n ; (* Number of opened #| when parsing a block comment *)\n mutable block_comment_depth : int\n ; (* Stack of ignoring depths; the current depth is pushed\n each time a #; comment is entered. *)\n mutable ignoring_stack : int list\n ; (* When parsing an escape sequence of the form \"\\\\NNN\" or \"\\\\XX\", this accumulates\n the computed number *)\n mutable escaped_value : int\n ; (* Buffer for accumulating atoms *)\n atom_buffer : Buffer.t\n ; user_state : 'u\n ; mode : ('u, 's) mode\n ; mutable full_sexps : int\n ; mutable offset : int (* global offset *)\n ; mutable line_number : int\n ; mutable bol_offset : int (* offset of beginning of line *)\n }\n\n and ('u, 's) mode =\n | Single\n | Many\n | Eager of\n { got_sexp : ('u, 's) state -> 's -> 's\n ; mutable no_sexp_is_error : bool\n }\n\n let initial_user_state : type u s. (u, s) kind -> Positions.pos -> u =\n fun kind initial_pos ->\n match kind with\n | Positions -> Positions.Builder.create ~initial_pos ()\n | Sexp -> ()\n | Sexp_with_positions -> Positions.Builder.create ~initial_pos ()\n | Cst ->\n (* [token_start_pos] is set to a dummy location here. It is properly set when we\n start to capture a token from the input *)\n { token_buffer = Buffer.create 128; token_start_pos = Positions.beginning_of_file }\n ;;\n\n (* these magic numbers are checked in gen_parser_automaton.ml:\n let () = assert (initial = 0)\n let () = assert (to_int Error = 1) *)\n let initial_state = 0\n let error_state = 1\n\n let new_state ?(initial_pos = Positions.beginning_of_file) mode kind =\n { kind\n ; depth = 0\n ; automaton_state = initial_state\n ; block_comment_depth = 0\n ; ignoring_stack = []\n ; escaped_value = 0\n ; atom_buffer = Buffer.create 128\n ; user_state = initial_user_state kind initial_pos\n ; mode\n ; full_sexps = 0\n ; offset = initial_pos.offset\n ; line_number = initial_pos.line\n ; bol_offset = initial_pos.offset - initial_pos.col\n }\n ;;\n\n let mode t = t.mode\n let positions t = Positions.Builder.contents t.user_state\n let atom_buffer t = t.atom_buffer\n let offset state = state.offset\n let line state = state.line_number\n let column state = state.offset - state.bol_offset\n let position t = { Positions.col = column t; line = line t; offset = offset t }\n\n let reset_user_state : type u s. (u, s) state -> unit =\n fun t ->\n match t.kind with\n | Positions -> Positions.Builder.reset t.user_state (position t)\n | Sexp -> ()\n | Sexp_with_positions -> Positions.Builder.reset t.user_state (position t)\n | Cst -> Buffer.clear t.user_state.token_buffer\n ;;\n\n let reset ?(pos = Positions.beginning_of_file) t =\n t.depth <- 0;\n t.automaton_state <- initial_state;\n t.block_comment_depth <- 0;\n t.ignoring_stack <- [];\n t.escaped_value <- 0;\n t.full_sexps <- 0;\n t.offset <- pos.offset;\n t.line_number <- pos.line;\n t.bol_offset <- pos.offset - pos.col;\n reset_user_state t;\n Buffer.clear t.atom_buffer\n ;;\n\n type context =\n | Sexp_comment\n | Sexp\n\n let is_ignoring state =\n match state.ignoring_stack with\n | _ :: _ -> true\n | [] -> false\n ;;\n\n let is_not_ignoring state = not (is_ignoring state)\n let context state = if is_not_ignoring state then Sexp else Sexp_comment\n let has_unclosed_paren state = state.depth > 0\n let set_error_state state = state.automaton_state <- error_state\n\n module Error = Parse_error\n\n let automaton_state state = state.automaton_state\nend\n\nopen Public\n\nlet raise_error : type a b. (a, b) state -> _ =\n fun state ~at_eof reason ->\n set_error_state state;\n Parse_error.Private.raise\n reason\n { line = state.line_number\n ; col = state.offset - state.bol_offset\n ; offset = state.offset\n }\n ~at_eof\n ~atom_buffer:state.atom_buffer\n;;\n\ntype nonrec context = context =\n | Sexp_comment\n | Sexp\n\nlet context = context\n\ntype ('u, 's) action = ('u, 's) state -> char -> 's -> 's\ntype ('u, 's) epsilon_action = ('u, 's) state -> 's -> 's\n\nlet current_pos ?(delta = 0) state : Positions.pos =\n let offset = state.offset + delta in\n { line = state.line_number; col = offset - state.bol_offset; offset }\n;;\n\nlet set_automaton_state state x = state.automaton_state <- x\nlet advance state = state.offset <- state.offset + 1\n\nlet advance_eol : type u s. (u, s) state -> unit =\n fun state ->\n let newline_offset = state.offset in\n state.offset <- newline_offset + 1;\n state.bol_offset <- state.offset;\n state.line_number <- state.line_number + 1;\n match state.kind with\n | Positions -> Positions.Builder.add_newline state.user_state ~offset:newline_offset\n | Sexp_with_positions ->\n Positions.Builder.add_newline state.user_state ~offset:newline_offset\n | _ -> ()\n;;\n\nlet block_comment_depth state = state.block_comment_depth\n\nlet add_token_char : type u s. (u, s) action =\n fun state char stack ->\n match state.kind with\n | Cst ->\n Buffer.add_char state.user_state.token_buffer char;\n stack\n | _ -> stack\n;;\n\nlet add_atom_char state c stack =\n Buffer.add_char state.atom_buffer c;\n stack\n;;\n\nlet add_quoted_atom_char state c stack =\n Buffer.add_char state.atom_buffer c;\n add_token_char state c stack\n;;\n\nlet check_new_sexp_allowed state =\n let is_single =\n match state.mode with\n | Single -> true\n | _ -> false\n in\n if is_single && state.full_sexps > 0 && is_not_ignoring state\n then raise_error state ~at_eof:false Too_many_sexps\n;;\n\nlet add_pos state ~delta =\n Positions.Builder.add state.user_state ~offset:(state.offset + delta)\n;;\n\nlet add_first_char : type u s. (u, s) action =\n fun state char stack ->\n check_new_sexp_allowed state;\n Buffer.add_char state.atom_buffer char;\n (* For non-quoted atoms, we save both positions at the end. We can always determine the\n start position from the end position and the atom length for non-quoted atoms.\n\n Doing it this way allows us to detect single characater atoms for which we need to\n save the position twice. *)\n stack\n;;\n\nlet eps_add_first_char_hash : type u s. (u, s) epsilon_action =\n fun state stack ->\n check_new_sexp_allowed state;\n Buffer.add_char state.atom_buffer '#';\n stack\n;;\n\nlet start_quoted_string : type u s. (u, s) action =\n fun state _char stack ->\n check_new_sexp_allowed state;\n match state.kind with\n | Positions ->\n if is_not_ignoring state then add_pos state ~delta:0;\n stack\n | Sexp_with_positions ->\n if is_not_ignoring state then add_pos state ~delta:0;\n stack\n | Cst ->\n state.user_state.token_start_pos <- current_pos state;\n Buffer.add_char state.user_state.token_buffer '\"';\n stack\n | Sexp -> stack\n;;\n\nlet add_escaped state c stack =\n let c' =\n match c with\n | 'n' -> '\\n'\n | 'r' -> '\\r'\n | 'b' -> '\\b'\n | 't' -> '\\t'\n | '\\\\' | '\\'' | '\"' -> c\n | _ ->\n Buffer.add_char state.atom_buffer '\\\\';\n c\n in\n Buffer.add_char state.atom_buffer c';\n add_token_char state c stack\n;;\n\nlet eps_add_escaped_cr state stack =\n Buffer.add_char state.atom_buffer '\\r';\n stack\n;;\n\nlet dec_val c = Char.code c - Char.code '0'\n\nlet hex_val c =\n match c with\n | '0' .. '9' -> Char.code c - Char.code '0'\n | 'a' .. 'f' -> Char.code c - Char.code 'a' + 10\n | _ -> Char.code c - Char.code 'A' + 10\n;;\n\nlet add_dec_escape_char state c stack =\n state.escaped_value <- (state.escaped_value * 10) + dec_val c;\n add_token_char state c stack\n;;\n\nlet add_last_dec_escape_char state c stack =\n let value = (state.escaped_value * 10) + dec_val c in\n state.escaped_value <- 0;\n if value > 255 then raise_error state ~at_eof:false Escape_sequence_out_of_range;\n Buffer.add_char state.atom_buffer (Char.chr value);\n add_token_char state c stack\n;;\n\nlet comment_add_last_dec_escape_char state c stack =\n let value = (state.escaped_value * 10) + dec_val c in\n state.escaped_value <- 0;\n if value > 255 then raise_error state ~at_eof:false Escape_sequence_out_of_range;\n add_token_char state c stack\n;;\n\nlet add_hex_escape_char state c stack =\n state.escaped_value <- (state.escaped_value lsl 4) lor hex_val c;\n add_token_char state c stack\n;;\n\nlet add_last_hex_escape_char state c stack =\n let value = (state.escaped_value lsl 4) lor hex_val c in\n state.escaped_value <- 0;\n Buffer.add_char state.atom_buffer (Char.chr value);\n add_token_char state c stack\n;;\n\nlet opening : type u s. (u, s) state -> char -> s -> s =\n fun state _char stack ->\n check_new_sexp_allowed state;\n state.depth <- state.depth + 1;\n match state.kind with\n | Positions ->\n if is_not_ignoring state then add_pos state ~delta:0;\n stack\n | Sexp -> if is_not_ignoring state then Open stack else stack\n | Sexp_with_positions ->\n if is_not_ignoring state\n then (\n add_pos state ~delta:0;\n Open stack)\n else stack\n | Cst -> Open (current_pos state, stack)\n;;\n\nlet do_reset_positions state =\n Positions.Builder.reset\n state.user_state\n { line = state.line_number\n ; col = state.offset - state.bol_offset\n ; offset = state.offset\n }\n;;\n\nlet reset_positions : type u s. (u, s) state -> unit =\n fun state ->\n match state.kind with\n | Positions -> do_reset_positions state\n | Sexp_with_positions -> do_reset_positions state\n | Sexp -> ()\n | Cst -> ()\n;;\n\nlet toplevel_sexp_or_comment_added state stack ~delta =\n match state.mode with\n | Single | Many -> stack\n | Eager { got_sexp = f; _ } ->\n (* Modify the offset so that [f] get a state pointing to the end of the current\n s-expression *)\n let saved_offset = state.offset in\n state.offset <- state.offset + delta;\n let saved_full_sexps = state.full_sexps in\n (match f state stack with\n | exception e ->\n set_error_state state;\n raise e\n | stack ->\n (* This assert is not a full protection against the user mutating the state but\n it should catch most cases. *)\n assert (state.offset = saved_offset + delta && state.full_sexps = saved_full_sexps);\n state.offset <- saved_offset;\n reset_positions state;\n stack)\n;;\n\nlet is_top_level state = is_not_ignoring state && state.depth = 0\n\nlet comment_added_assuming_cst state stack ~delta =\n if is_top_level state then toplevel_sexp_or_comment_added state stack ~delta else stack\n;;\n\nlet maybe_pop_ignoring_stack state =\n match state.ignoring_stack with\n | inner_comment_depth :: _tl when inner_comment_depth > state.depth ->\n raise_error state ~at_eof:false Sexp_comment_without_sexp\n | inner_comment_depth :: tl when inner_comment_depth = state.depth ->\n state.ignoring_stack <- tl;\n true\n | _ -> false\n;;\n\nlet sexp_added : type u s. (u, s) state -> s -> delta:int -> s =\n fun state stack ~delta ->\n let is_comment = maybe_pop_ignoring_stack state in\n if is_top_level state\n then (\n if not is_comment then state.full_sexps <- state.full_sexps + 1;\n if (not is_comment)\n ||\n match state.kind with\n | Cst -> true\n | _ -> false\n then toplevel_sexp_or_comment_added state stack ~delta\n else stack)\n else stack\n;;\n\nlet rec make_list acc : Automaton_stack.t -> Automaton_stack.t = function\n | Empty -> assert false\n | Open stack -> Sexp (List acc, stack)\n | Sexp (sexp, stack) -> make_list (sexp :: acc) stack\n;;\n\nlet add_comment_to_stack_cst comment (stack : Automaton_stack.For_cst.t)\n : Automaton_stack.For_cst.t\n =\n match stack with\n | In_sexp_comment r ->\n In_sexp_comment { r with rev_comments = comment :: r.rev_comments }\n | _ -> T_or_comment (Comment comment, stack)\n;;\n\nlet add_sexp_to_stack_cst sexp : Automaton_stack.For_cst.t -> Automaton_stack.For_cst.t\n = function\n | In_sexp_comment { hash_semi_pos; rev_comments; stack } ->\n let comment : Cst.comment =\n Sexp_comment { hash_semi_pos; comments = List.rev rev_comments; sexp }\n in\n add_comment_to_stack_cst comment stack\n | stack -> T_or_comment (Sexp sexp, stack)\n;;\n\nlet rec make_list_cst end_pos acc\n : Automaton_stack.For_cst.t -> Automaton_stack.For_cst.t\n = function\n | T_or_comment (t, stack) -> make_list_cst end_pos (t :: acc) stack\n | Open (start_pos, stack) ->\n let sexp : Cst.t = List { loc = { start_pos; end_pos }; elements = acc } in\n add_sexp_to_stack_cst sexp stack\n | Empty | In_sexp_comment _ -> assert false\n;;\n\nlet closing : type u s. (u, s) state -> char -> s -> s =\n fun state _char stack ->\n if state.depth > 0\n then (\n let stack : s =\n match state.kind with\n | Positions ->\n (* Note we store end positions as inclusive in [Positions.t], so we use [delta:0],\n while in the [Cst] case we save directly the final ranges, so we use\n [delta:1]. *)\n if is_not_ignoring state then add_pos state ~delta:0;\n stack\n | Sexp -> if is_not_ignoring state then make_list [] stack else stack\n | Sexp_with_positions ->\n if is_not_ignoring state\n then (\n add_pos state ~delta:0;\n make_list [] stack)\n else stack\n | Cst -> make_list_cst (current_pos state ~delta:1) [] stack\n in\n state.depth <- state.depth - 1;\n sexp_added state stack ~delta:1)\n else raise_error state ~at_eof:false Closed_paren_without_opened\n;;\n\nlet make_loc ?(delta = 0) state : Positions.range =\n { start_pos = state.user_state.token_start_pos; end_pos = current_pos state ~delta }\n;;\n\n(* This is always called on the position exactly following the last character of a\n non-quoted atom *)\nlet add_non_quoted_atom_pos state ~atom =\n let len = String.length atom in\n if len = 1\n then Positions.Builder.add_twice state.user_state ~offset:(state.offset - 1)\n else (\n add_pos state ~delta:(-len);\n add_pos state ~delta:(-1))\n;;\n\nlet eps_push_atom : type u s. (u, s) epsilon_action =\n fun state stack ->\n let str = Buffer.contents state.atom_buffer in\n Buffer.clear state.atom_buffer;\n let stack : s =\n match state.kind with\n | Positions ->\n if is_not_ignoring state then add_non_quoted_atom_pos state ~atom:str;\n stack\n | Sexp -> if is_not_ignoring state then Sexp (Atom str, stack) else stack\n | Sexp_with_positions ->\n if is_not_ignoring state\n then (\n add_non_quoted_atom_pos state ~atom:str;\n Sexp (Atom str, stack))\n else stack\n | Cst ->\n let loc : Positions.range =\n { start_pos = current_pos state ~delta:(-String.length str)\n ; end_pos = current_pos state ~delta:0\n }\n in\n let sexp : Cst.t = Atom { loc; atom = str; unescaped = Some str } in\n add_sexp_to_stack_cst sexp stack\n in\n sexp_added state stack ~delta:0\n;;\n\nlet push_quoted_atom : type u s. (u, s) action =\n fun state _char stack ->\n let str = Buffer.contents state.atom_buffer in\n Buffer.clear state.atom_buffer;\n let stack : s =\n match state.kind with\n | Positions ->\n if is_not_ignoring state then add_pos state ~delta:0;\n stack\n | Sexp -> if is_not_ignoring state then Sexp (Atom str, stack) else stack\n | Sexp_with_positions ->\n if is_not_ignoring state\n then (\n add_pos state ~delta:0;\n Sexp (Atom str, stack))\n else stack\n | Cst ->\n let buf = state.user_state.token_buffer in\n Buffer.add_char buf '\"';\n let s = Buffer.contents buf in\n Buffer.clear buf;\n let sexp : Cst.t =\n Atom { loc = make_loc state ~delta:1; atom = str; unescaped = Some s }\n in\n add_sexp_to_stack_cst sexp stack\n in\n sexp_added state stack ~delta:1\n;;\n\nlet start_sexp_comment : type u s. (u, s) action =\n fun state _char stack ->\n state.ignoring_stack <- state.depth :: state.ignoring_stack;\n match state.kind with\n | Cst ->\n In_sexp_comment\n { hash_semi_pos = current_pos state ~delta:(-1); rev_comments = []; stack }\n | _ -> stack\n;;\n\nlet start_block_comment : type u s. (u, s) state -> char -> s -> s =\n fun state char stack ->\n state.block_comment_depth <- state.block_comment_depth + 1;\n match state.kind with\n | Positions -> stack\n | Sexp -> stack\n | Sexp_with_positions -> stack\n | Cst ->\n if state.block_comment_depth = 1\n then (\n state.user_state.token_start_pos <- current_pos state ~delta:(-1);\n Buffer.add_char state.user_state.token_buffer '#');\n Buffer.add_char state.user_state.token_buffer char;\n stack\n;;\n\nlet end_block_comment : type u s. (u, s) state -> char -> s -> s =\n fun state char stack ->\n state.block_comment_depth <- state.block_comment_depth - 1;\n match state.kind with\n | Positions -> stack\n | Sexp -> stack\n | Sexp_with_positions -> stack\n | Cst ->\n let buf = state.user_state.token_buffer in\n Buffer.add_char buf char;\n if state.block_comment_depth = 0\n then (\n let s = Buffer.contents buf in\n Buffer.clear buf;\n let comment : Cst.comment =\n Plain_comment { loc = make_loc state ~delta:1; comment = s }\n in\n let stack = add_comment_to_stack_cst comment stack in\n comment_added_assuming_cst state stack ~delta:1)\n else stack\n;;\n\nlet start_line_comment : type u s. (u, s) action =\n fun state char stack ->\n match state.kind with\n | Cst ->\n state.user_state.token_start_pos <- current_pos state;\n Buffer.add_char state.user_state.token_buffer char;\n stack\n | _ -> stack\n;;\n\nlet end_line_comment : type u s. (u, s) epsilon_action =\n fun state stack ->\n match state.kind with\n | Positions -> stack\n | Sexp -> stack\n | Sexp_with_positions -> stack\n | Cst ->\n let buf = state.user_state.token_buffer in\n let s = Buffer.contents buf in\n Buffer.clear buf;\n let comment : Cst.comment = Plain_comment { loc = make_loc state; comment = s } in\n let stack = add_comment_to_stack_cst comment stack in\n comment_added_assuming_cst state stack ~delta:0\n;;\n\nlet eps_eoi_check : type u s. (u, s) epsilon_action =\n fun state stack ->\n if state.depth > 0 then raise_error state ~at_eof:true Unclosed_paren;\n if is_ignoring state then raise_error state ~at_eof:true Sexp_comment_without_sexp;\n if state.full_sexps = 0\n then (\n match state.mode with\n | Many | Eager { no_sexp_is_error = false; _ } -> ()\n | Single | Eager { no_sexp_is_error = true; _ } ->\n raise_error state ~at_eof:true No_sexp_found_in_input);\n stack\n;;\n","open Parser_automaton_internal\ninclude Public\n\nlet raise = Parser_automaton_internal.raise_error\n\ntype u'\ntype s'\n\n(*$ open Parsexp_cinaps_helpers.Gen_parser_automaton ;; *)\n(*$ print_code () ;; *)\n\nlet tr_00 state char stack =\n let stack = add_first_char state char stack in\n set_automaton_state state 3;\n advance state;\n stack\n;;\n\nlet tr_01 state _char stack =\n set_automaton_state state 0;\n advance state;\n stack\n;;\n\nlet tr_02 state _char stack =\n set_automaton_state state 0;\n advance_eol state;\n stack\n;;\n\nlet tr_03 state _char stack =\n set_automaton_state state 2;\n advance state;\n stack\n;;\n\nlet tr_04 state char stack =\n let stack = start_quoted_string state char stack in\n set_automaton_state state 8;\n advance state;\n stack\n;;\n\nlet tr_05 state _char stack =\n set_automaton_state state 7;\n advance state;\n stack\n;;\n\nlet tr_06 state char stack =\n let stack = opening state char stack in\n set_automaton_state state 0;\n advance state;\n stack\n;;\n\nlet tr_07 state char stack =\n let stack = closing state char stack in\n set_automaton_state state 0;\n advance state;\n stack\n;;\n\nlet tr_08 state char stack =\n let stack = start_line_comment state char stack in\n set_automaton_state state 6;\n advance state;\n stack\n;;\n\nlet tr_09 state char stack =\n let stack = add_first_char state char stack in\n set_automaton_state state 5;\n advance state;\n stack\n;;\n\nlet tr_10 _state _char _stack = raise _state ~at_eof:false Automaton_in_error_state\nlet tr_11 _state _char _stack = raise _state ~at_eof:false Unexpected_character_after_cr\n\nlet tr_12 state char stack =\n let stack = add_atom_char state char stack in\n set_automaton_state state 3;\n advance state;\n stack\n;;\n\nlet tr_13 state _char stack =\n let stack = eps_push_atom state stack in\n set_automaton_state state 0;\n advance state;\n stack\n;;\n\nlet tr_14 state _char stack =\n let stack = eps_push_atom state stack in\n set_automaton_state state 0;\n advance_eol state;\n stack\n;;\n\nlet tr_15 state _char stack =\n let stack = eps_push_atom state stack in\n set_automaton_state state 2;\n advance state;\n stack\n;;\n\nlet tr_16 state char stack =\n let stack = eps_push_atom state stack in\n let stack = start_quoted_string state char stack in\n set_automaton_state state 8;\n advance state;\n stack\n;;\n\nlet tr_17 state char stack =\n let stack = add_atom_char state char stack in\n set_automaton_state state 4;\n advance state;\n stack\n;;\n\nlet tr_18 state char stack =\n let stack = eps_push_atom state stack in\n let stack = opening state char stack in\n set_automaton_state state 0;\n advance state;\n stack\n;;\n\nlet tr_19 state char stack =\n let stack = eps_push_atom state stack in\n let stack = closing state char stack in\n set_automaton_state state 0;\n advance state;\n stack\n;;\n\nlet tr_20 state char stack =\n let stack = eps_push_atom state stack in\n let stack = start_line_comment state char stack in\n set_automaton_state state 6;\n advance state;\n stack\n;;\n\nlet tr_21 state char stack =\n let stack = add_atom_char state char stack in\n set_automaton_state state 5;\n advance state;\n stack\n;;\n\nlet tr_22 _state _char _stack = raise _state ~at_eof:false Comment_token_in_unquoted_atom\n\nlet tr_23 state char stack =\n let stack = add_token_char state char stack in\n set_automaton_state state 6;\n advance state;\n stack\n;;\n\nlet tr_24 state _char stack =\n let stack = end_line_comment state stack in\n set_automaton_state state 0;\n advance_eol state;\n stack\n;;\n\nlet tr_25 state _char stack =\n let stack = end_line_comment state stack in\n set_automaton_state state 2;\n advance state;\n stack\n;;\n\nlet tr_26 state char stack =\n let stack = eps_add_first_char_hash state stack in\n let stack = add_atom_char state char stack in\n set_automaton_state state 3;\n advance state;\n stack\n;;\n\nlet tr_27 state _char stack =\n let stack = eps_add_first_char_hash state stack in\n let stack = eps_push_atom state stack in\n set_automaton_state state 0;\n advance state;\n stack\n;;\n\nlet tr_28 state _char stack =\n let stack = eps_add_first_char_hash state stack in\n let stack = eps_push_atom state stack in\n set_automaton_state state 0;\n advance_eol state;\n stack\n;;\n\nlet tr_29 state _char stack =\n let stack = eps_add_first_char_hash state stack in\n let stack = eps_push_atom state stack in\n set_automaton_state state 2;\n advance state;\n stack\n;;\n\nlet tr_30 state char stack =\n let stack = eps_add_first_char_hash state stack in\n let stack = eps_push_atom state stack in\n let stack = start_quoted_string state char stack in\n set_automaton_state state 8;\n advance state;\n stack\n;;\n\nlet tr_31 state char stack =\n let stack = eps_add_first_char_hash state stack in\n let stack = add_atom_char state char stack in\n set_automaton_state state 4;\n advance state;\n stack\n;;\n\nlet tr_32 state char stack =\n let stack = eps_add_first_char_hash state stack in\n let stack = eps_push_atom state stack in\n let stack = opening state char stack in\n set_automaton_state state 0;\n advance state;\n stack\n;;\n\nlet tr_33 state char stack =\n let stack = eps_add_first_char_hash state stack in\n let stack = eps_push_atom state stack in\n let stack = closing state char stack in\n set_automaton_state state 0;\n advance state;\n stack\n;;\n\nlet tr_34 state char stack =\n let stack = start_sexp_comment state char stack in\n set_automaton_state state 0;\n advance state;\n stack\n;;\n\nlet tr_35 state char stack =\n let stack = start_block_comment state char stack in\n set_automaton_state state 16;\n advance state;\n stack\n;;\n\nlet tr_36 state char stack =\n let stack = add_quoted_atom_char state char stack in\n set_automaton_state state 8;\n advance state;\n stack\n;;\n\nlet tr_37 state char stack =\n let stack = add_quoted_atom_char state char stack in\n set_automaton_state state 8;\n advance_eol state;\n stack\n;;\n\nlet tr_38 state char stack =\n let stack = push_quoted_atom state char stack in\n set_automaton_state state 0;\n advance state;\n stack\n;;\n\nlet tr_39 state char stack =\n let stack = add_token_char state char stack in\n set_automaton_state state 9;\n advance state;\n stack\n;;\n\nlet tr_40 state char stack =\n let stack = add_escaped state char stack in\n set_automaton_state state 8;\n advance state;\n stack\n;;\n\nlet tr_41 state char stack =\n let stack = add_token_char state char stack in\n set_automaton_state state 15;\n advance_eol state;\n stack\n;;\n\nlet tr_42 state char stack =\n let stack = add_token_char state char stack in\n set_automaton_state state 10;\n advance state;\n stack\n;;\n\nlet tr_43 state char stack =\n let stack = add_dec_escape_char state char stack in\n set_automaton_state state 11;\n advance state;\n stack\n;;\n\nlet tr_44 state char stack =\n let stack = add_token_char state char stack in\n set_automaton_state state 13;\n advance state;\n stack\n;;\n\nlet tr_45 state char stack =\n let stack = eps_add_escaped_cr state stack in\n let stack = add_quoted_atom_char state char stack in\n set_automaton_state state 8;\n advance state;\n stack\n;;\n\nlet tr_46 state char stack =\n let stack = eps_add_escaped_cr state stack in\n let stack = push_quoted_atom state char stack in\n set_automaton_state state 0;\n advance state;\n stack\n;;\n\nlet tr_47 state char stack =\n let stack = eps_add_escaped_cr state stack in\n let stack = add_token_char state char stack in\n set_automaton_state state 9;\n advance state;\n stack\n;;\n\nlet tr_48 _state _char _stack =\n raise _state ~at_eof:false Unexpected_char_parsing_dec_escape\n;;\n\nlet tr_49 state char stack =\n let stack = add_dec_escape_char state char stack in\n set_automaton_state state 12;\n advance state;\n stack\n;;\n\nlet tr_50 state char stack =\n let stack = add_last_dec_escape_char state char stack in\n set_automaton_state state 8;\n advance state;\n stack\n;;\n\nlet tr_51 _state _char _stack =\n raise _state ~at_eof:false Unexpected_char_parsing_hex_escape\n;;\n\nlet tr_52 state char stack =\n let stack = add_hex_escape_char state char stack in\n set_automaton_state state 14;\n advance state;\n stack\n;;\n\nlet tr_53 state char stack =\n let stack = add_last_hex_escape_char state char stack in\n set_automaton_state state 8;\n advance state;\n stack\n;;\n\nlet tr_54 state char stack =\n let stack = add_quoted_atom_char state char stack in\n set_automaton_state state 8;\n advance state;\n stack\n;;\n\nlet tr_55 state char stack =\n let stack = add_token_char state char stack in\n set_automaton_state state 15;\n advance state;\n stack\n;;\n\nlet tr_56 state char stack =\n let stack = add_quoted_atom_char state char stack in\n set_automaton_state state 8;\n advance_eol state;\n stack\n;;\n\nlet tr_57 state char stack =\n let stack = push_quoted_atom state char stack in\n set_automaton_state state 0;\n advance state;\n stack\n;;\n\nlet tr_58 state char stack =\n let stack = add_token_char state char stack in\n set_automaton_state state 9;\n advance state;\n stack\n;;\n\nlet tr_59 state char stack =\n let stack = add_token_char state char stack in\n set_automaton_state state 16;\n advance state;\n stack\n;;\n\nlet tr_60 state char stack =\n let stack = add_token_char state char stack in\n set_automaton_state state 16;\n advance_eol state;\n stack\n;;\n\nlet tr_61 state char stack =\n let stack = add_token_char state char stack in\n set_automaton_state state 19;\n advance state;\n stack\n;;\n\nlet tr_62 state char stack =\n let stack = add_token_char state char stack in\n set_automaton_state state 18;\n advance state;\n stack\n;;\n\nlet tr_63 state char stack =\n let stack = add_token_char state char stack in\n set_automaton_state state 17;\n advance state;\n stack\n;;\n\nlet tr_64 state char stack =\n let stack = end_block_comment state char stack in\n set_automaton_state state (if block_comment_depth state <> 0 then 16 else 0);\n advance state;\n stack\n;;\n\nlet tr_65 state char stack =\n let stack = add_token_char state char stack in\n set_automaton_state state 19;\n advance_eol state;\n stack\n;;\n\nlet tr_66 state char stack =\n let stack = add_token_char state char stack in\n set_automaton_state state 20;\n advance state;\n stack\n;;\n\nlet tr_67 state char stack =\n let stack = add_token_char state char stack in\n set_automaton_state state 26;\n advance_eol state;\n stack\n;;\n\nlet tr_68 state char stack =\n let stack = add_token_char state char stack in\n set_automaton_state state 21;\n advance state;\n stack\n;;\n\nlet tr_69 state char stack =\n let stack = add_dec_escape_char state char stack in\n set_automaton_state state 22;\n advance state;\n stack\n;;\n\nlet tr_70 state char stack =\n let stack = add_token_char state char stack in\n set_automaton_state state 24;\n advance state;\n stack\n;;\n\nlet tr_71 state char stack =\n let stack = add_token_char state char stack in\n set_automaton_state state 19;\n advance state;\n stack\n;;\n\nlet tr_72 state char stack =\n let stack = add_token_char state char stack in\n set_automaton_state state 16;\n advance state;\n stack\n;;\n\nlet tr_73 state char stack =\n let stack = add_token_char state char stack in\n set_automaton_state state 20;\n advance state;\n stack\n;;\n\nlet tr_74 state char stack =\n let stack = add_dec_escape_char state char stack in\n set_automaton_state state 23;\n advance state;\n stack\n;;\n\nlet tr_75 state char stack =\n let stack = comment_add_last_dec_escape_char state char stack in\n set_automaton_state state 19;\n advance state;\n stack\n;;\n\nlet tr_76 state char stack =\n let stack = add_token_char state char stack in\n set_automaton_state state 25;\n advance state;\n stack\n;;\n\nlet tr_77 state char stack =\n let stack = add_token_char state char stack in\n set_automaton_state state 26;\n advance state;\n stack\n;;\n\nlet tr_78 state char stack =\n let stack = add_token_char state char stack in\n set_automaton_state state 19;\n advance_eol state;\n stack\n;;\n\nlet tr_eoi_00 state stack = eps_eoi_check state stack\nlet tr_eoi_01 state _stack = raise state ~at_eof:true Automaton_in_error_state\nlet tr_eoi_02 state _stack = raise state ~at_eof:true Unexpected_character_after_cr\n\nlet tr_eoi_03 state stack =\n let stack = eps_push_atom state stack in\n eps_eoi_check state stack\n;;\n\nlet tr_eoi_04 state stack =\n let stack = end_line_comment state stack in\n eps_eoi_check state stack\n;;\n\nlet tr_eoi_05 state stack =\n let stack = eps_add_first_char_hash state stack in\n let stack = eps_push_atom state stack in\n eps_eoi_check state stack\n;;\n\nlet tr_eoi_06 state _stack = raise state ~at_eof:true Unterminated_quoted_string\nlet tr_eoi_07 state _stack = raise state ~at_eof:true Unterminated_block_comment\n\nlet transitions =\n [| tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_01\n ; tr_02\n ; tr_00\n ; tr_01\n ; tr_03\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_01\n ; tr_00\n ; tr_04\n ; tr_05\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_06\n ; tr_07\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_08\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_09\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_02\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_13\n ; tr_14\n ; tr_12\n ; tr_13\n ; tr_15\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_13\n ; tr_12\n ; tr_16\n ; tr_17\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_18\n ; tr_19\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_20\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_21\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_13\n ; tr_14\n ; tr_12\n ; tr_13\n ; tr_15\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_13\n ; tr_12\n ; tr_16\n ; tr_17\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_18\n ; tr_19\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_20\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_22\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_13\n ; tr_14\n ; tr_12\n ; tr_13\n ; tr_15\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_13\n ; tr_12\n ; tr_16\n ; tr_22\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_18\n ; tr_19\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_20\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_21\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_24\n ; tr_23\n ; tr_23\n ; tr_25\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_27\n ; tr_28\n ; tr_26\n ; tr_27\n ; tr_29\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_27\n ; tr_26\n ; tr_30\n ; tr_31\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_32\n ; tr_33\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_34\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_35\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_37\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_38\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_39\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_41\n ; tr_40\n ; tr_40\n ; tr_42\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_43\n ; tr_43\n ; tr_43\n ; tr_43\n ; tr_43\n ; tr_43\n ; tr_43\n ; tr_43\n ; tr_43\n ; tr_43\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_44\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_41\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_46\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_47\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_49\n ; tr_49\n ; tr_49\n ; tr_49\n ; tr_49\n ; tr_49\n ; tr_49\n ; tr_49\n ; tr_49\n ; tr_49\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_50\n ; tr_50\n ; tr_50\n ; tr_50\n ; tr_50\n ; tr_50\n ; tr_50\n ; tr_50\n ; tr_50\n ; tr_50\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_52\n ; tr_52\n ; tr_52\n ; tr_52\n ; tr_52\n ; tr_52\n ; tr_52\n ; tr_52\n ; tr_52\n ; tr_52\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_52\n ; tr_52\n ; tr_52\n ; tr_52\n ; tr_52\n ; tr_52\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_52\n ; tr_52\n ; tr_52\n ; tr_52\n ; tr_52\n ; tr_52\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_53\n ; tr_53\n ; tr_53\n ; tr_53\n ; tr_53\n ; tr_53\n ; tr_53\n ; tr_53\n ; tr_53\n ; tr_53\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_53\n ; tr_53\n ; tr_53\n ; tr_53\n ; tr_53\n ; tr_53\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_53\n ; tr_53\n ; tr_53\n ; tr_53\n ; tr_53\n ; tr_53\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_55\n ; tr_56\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_55\n ; tr_54\n ; tr_57\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_58\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_60\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_61\n ; tr_62\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_63\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_60\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_61\n ; tr_64\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_63\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_60\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_61\n ; tr_62\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_35\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_65\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_59\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_66\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_67\n ; tr_61\n ; tr_61\n ; tr_68\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_69\n ; tr_69\n ; tr_69\n ; tr_69\n ; tr_69\n ; tr_69\n ; tr_69\n ; tr_69\n ; tr_69\n ; tr_69\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_70\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_67\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_72\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_73\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_74\n ; tr_74\n ; tr_74\n ; tr_74\n ; tr_74\n ; tr_74\n ; tr_74\n ; tr_74\n ; tr_74\n ; tr_74\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_75\n ; tr_75\n ; tr_75\n ; tr_75\n ; tr_75\n ; tr_75\n ; tr_75\n ; tr_75\n ; tr_75\n ; tr_75\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_76\n ; tr_76\n ; tr_76\n ; tr_76\n ; tr_76\n ; tr_76\n ; tr_76\n ; tr_76\n ; tr_76\n ; tr_76\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_76\n ; tr_76\n ; tr_76\n ; tr_76\n ; tr_76\n ; tr_76\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_76\n ; tr_76\n ; tr_76\n ; tr_76\n ; tr_76\n ; tr_76\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_77\n ; tr_78\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_77\n ; tr_71\n ; tr_72\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_73\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n |]\n;;\n\nlet transitions_eoi =\n [| tr_eoi_00\n ; tr_eoi_01\n ; tr_eoi_02\n ; tr_eoi_03\n ; tr_eoi_03\n ; tr_eoi_03\n ; tr_eoi_04\n ; tr_eoi_05\n ; tr_eoi_06\n ; tr_eoi_06\n ; tr_eoi_06\n ; tr_eoi_06\n ; tr_eoi_06\n ; tr_eoi_06\n ; tr_eoi_06\n ; tr_eoi_06\n ; tr_eoi_07\n ; tr_eoi_07\n ; tr_eoi_07\n ; tr_eoi_07\n ; tr_eoi_07\n ; tr_eoi_07\n ; tr_eoi_07\n ; tr_eoi_07\n ; tr_eoi_07\n ; tr_eoi_07\n ; tr_eoi_07\n |]\n;;\n\nlet old_parser_approx_cont_states : Old_parser_cont_state.t array =\n [| Parsing_toplevel_whitespace\n ; Parsing_toplevel_whitespace\n ; Parsing_nested_whitespace\n ; Parsing_atom\n ; Parsing_atom\n ; Parsing_atom\n ; Parsing_toplevel_whitespace\n ; Parsing_atom\n ; Parsing_atom\n ; Parsing_atom\n ; Parsing_atom\n ; Parsing_atom\n ; Parsing_atom\n ; Parsing_atom\n ; Parsing_atom\n ; Parsing_atom\n ; Parsing_block_comment\n ; Parsing_block_comment\n ; Parsing_block_comment\n ; Parsing_block_comment\n ; Parsing_block_comment\n ; Parsing_block_comment\n ; Parsing_block_comment\n ; Parsing_block_comment\n ; Parsing_block_comment\n ; Parsing_block_comment\n ; Parsing_block_comment\n |]\n;;\n\n(*$*)\n\nlet feed (type u s) (state : (u, s) state) char (stack : s) : s =\n let idx = (automaton_state state lsl 8) lor Char.code char in\n (* We need an Obj.magic as the type of the array can't be generalized.\n This problem will go away when we get immutable arrays. *)\n let magic\n : ((u', s') state -> char -> s' -> s') array\n -> ((u, s) state -> char -> s -> s) array\n =\n Obj.magic\n in\n (magic transitions).(idx) state char stack\n[@@inline always]\n;;\n\nlet feed_eoi (type u s) (state : (u, s) state) (stack : s) : s =\n let magic : ((u', s') state -> s' -> s') array -> ((u, s) state -> s -> s) array =\n Obj.magic\n in\n let stack = (magic transitions_eoi).(automaton_state state) state stack in\n set_error_state state;\n stack\n;;\n\nlet old_parser_cont_state state : Old_parser_cont_state.t =\n match context state with\n | Sexp_comment -> Parsing_sexp_comment\n | Sexp ->\n (match\n old_parser_approx_cont_states.(automaton_state state), has_unclosed_paren state\n with\n | Parsing_toplevel_whitespace, true -> Parsing_list\n | s, _ -> s)\n;;\n","open! Import\ninclude Kind_intf\n\nlet create (type stack state) (module Stack : Stack with type t = stack) kind\n : (module S with type Stack.t = stack and type state = state)\n =\n (module struct\n module Stack = Stack\n\n type nonrec state = state\n\n let kind = kind\n end)\n;;\n\nmodule Sexp = (val create (module Automaton_stack) Sexp)\nmodule Sexp_with_positions = (val create (module Automaton_stack) Sexp_with_positions)\nmodule Positions = (val create (module Automaton_stack.Just_positions) Positions)\nmodule Cst = (val create (module Automaton_stack.For_cst) Cst)\n","open! Import\n\nlet rec feed_substring_unsafe str state stack i stop =\n if i < stop\n then (\n let c = String.unsafe_get str i in\n let stack = Parser_automaton.feed state c stack in\n feed_substring_unsafe str state stack (i + 1) stop)\n else stack\n;;\n\nlet rec feed_subbytes_unsafe str state stack i stop =\n if i < stop\n then (\n let c = Bytes.unsafe_get str i in\n let stack = Parser_automaton.feed state c stack in\n feed_subbytes_unsafe str state stack (i + 1) stop)\n else stack\n;;\n\nlet feed_substring state str ~pos ~len stack =\n let str_len = String.length str in\n if pos < 0 || len < 0 || pos > str_len - len then invalid_arg \"Parsexp.feed_substring\";\n feed_substring_unsafe str state stack pos (pos + len)\n;;\n\nlet feed_subbytes state str ~pos ~len stack =\n let str_len = Bytes.length str in\n if pos < 0 || len < 0 || pos > str_len - len then invalid_arg \"Parsexp.feed_subbytes\";\n feed_subbytes_unsafe str state stack pos (pos + len)\n;;\n\nlet feed_string state str stack =\n feed_substring_unsafe str state stack 0 (String.length str)\n;;\n\nlet feed_bytes state str stack =\n feed_subbytes_unsafe str state stack 0 (Bytes.length str)\n;;\n","open! Import\ninclude Parser_intf\n\n\nmodule Make (Kind : Kind.S) (Mode : Mode(Kind).S) :\n S\n with type parsed_value = Mode.parsed_value\n with type State.t = (Kind.state, Kind.Stack.t) A.state\n with module Stack = Kind.Stack = struct\n type parsed_value = Mode.parsed_value\n\n module Stack = Kind.Stack\n\n module State = struct\n type t = (Kind.state, Kind.Stack.t) A.state\n\n let create ?pos () = A.new_state ?initial_pos:pos Mode.mode Kind.kind\n let reset = A.reset\n let offset = A.offset\n let line = A.line\n let column = A.column\n let position t : Positions.pos = { offset = offset t; line = line t; col = column t }\n let stop state = A.set_error_state state\n end\n\n let feed = A.feed\n let feed_eoi state stack = Mode.make_value state (A.feed_eoi state stack)\n let feed_substring = Automaton_helpers.feed_substring\n let feed_string = Automaton_helpers.feed_string\n let feed_subbytes = Automaton_helpers.feed_subbytes\n let feed_bytes = Automaton_helpers.feed_bytes\n\n let parse_string_exn str =\n let state = State.create () in\n feed_eoi state (feed_string state str Kind.Stack.empty)\n ;;\n\n let parse_string str =\n match parse_string_exn str with\n | x -> Ok x\n | exception Parse_error.Parse_error e -> Error e\n ;;\nend\n\nmodule Make_eager (Kind : Kind.S) (Mode : Mode_eager(Kind).S) :\n S_eager\n with type parsed_value = Mode.parsed_value\n with type State.t = (Kind.state, Kind.Stack.t) A.state\n with module Stack = Kind.Stack = struct\n type parsed_value = Mode.parsed_value\n\n module Stack = Kind.Stack\n\n module State = struct\n module Read_only = struct\n type t = (Kind.state, Kind.Stack.t) A.state\n\n let offset = A.offset\n let line = A.line\n let column = A.column\n\n let position t : Positions.pos =\n { offset = offset t; line = line t; col = column t }\n ;;\n end\n\n include Read_only\n\n let create ?pos ?(no_sexp_is_error = false) f =\n let got_sexp state stack =\n let parsed_value = Mode.make_value state stack in\n f state parsed_value;\n Stack.empty\n in\n A.new_state ?initial_pos:pos (Eager { got_sexp; no_sexp_is_error }) Kind.kind\n ;;\n\n let reset = A.reset\n let stop t = A.set_error_state t\n let old_parser_cont_state t = Parser_automaton.old_parser_cont_state t\n end\n\n let feed = A.feed\n let feed_eoi state stack = ignore (A.feed_eoi state stack : Stack.t)\n let feed_substring = Automaton_helpers.feed_substring\n let feed_string = Automaton_helpers.feed_string\n let feed_subbytes = Automaton_helpers.feed_subbytes\n let feed_bytes = Automaton_helpers.feed_bytes\n\n module Lexbuf_consumer = struct\n type t = State.t\n\n exception Got_sexp of parsed_value * Positions.pos\n\n let got_sexp state parsed_value =\n raise_notrace (Got_sexp (parsed_value, State.position state))\n ;;\n\n let create () = State.create got_sexp\n\n let pos_of_lexbuf lexbuf =\n let p = lexbuf.Lexing.lex_curr_p in\n { Positions.line = p.pos_lnum; col = p.pos_cnum - p.pos_bol; offset = p.pos_cnum }\n ;;\n\n let update_lexbuf (lexbuf : Lexing.lexbuf) (pos : Positions.pos) =\n let p = pos.offset - lexbuf.lex_abs_pos in\n lexbuf.lex_curr_pos <- p;\n lexbuf.lex_start_pos <- p;\n lexbuf.lex_curr_p\n <- { lexbuf.lex_curr_p with\n pos_lnum = pos.line\n ; pos_cnum = pos.offset\n ; pos_bol = pos.offset - pos.col\n }\n ;;\n\n let rec feed_lexbuf t (lexbuf : Lexing.lexbuf) stack =\n let stack =\n feed_subbytes\n t\n lexbuf.lex_buffer\n stack\n ~pos:lexbuf.lex_curr_pos\n ~len:(lexbuf.lex_buffer_len - lexbuf.lex_curr_pos)\n in\n lexbuf.lex_curr_pos <- lexbuf.lex_buffer_len;\n lexbuf.lex_start_pos <- lexbuf.lex_buffer_len;\n if not lexbuf.lex_eof_reached\n then (\n lexbuf.refill_buff lexbuf;\n feed_lexbuf t lexbuf stack)\n else feed_eoi t stack\n ;;\n\n let parse_gen t (lexbuf : Lexing.lexbuf) =\n A.reset t ~pos:(pos_of_lexbuf lexbuf);\n match feed_lexbuf t lexbuf Stack.empty with\n | () ->\n update_lexbuf lexbuf (State.position t);\n None\n | exception Got_sexp (parsed_value, pos) ->\n update_lexbuf lexbuf pos;\n Some parsed_value\n | exception exn ->\n update_lexbuf lexbuf (State.position t);\n raise exn\n ;;\n\n let set_no_sexp_is_error t x =\n match A.mode t with\n | Eager e -> e.no_sexp_is_error <- x\n | _ -> assert false\n ;;\n\n let parse t lexbuf =\n set_no_sexp_is_error t true;\n match parse_gen t lexbuf with\n | Some x -> x\n | None -> failwith \"Parsexp.parse_gen: None\"\n ;;\n\n let parse_opt t lexbuf =\n set_no_sexp_is_error t false;\n parse_gen t lexbuf\n ;;\n end\nend\n","open! Import\ninclude Conv_intf\n\nmodule Make\n (Mode : Mode)\n (Sexp_parser : Parser.S with type parsed_value = Mode.parsed_sexp)\n (Positions_parser : Parser.S with type parsed_value = Positions.t) =\nstruct\n let reraise positions parsed_value ~sub user_exn =\n let location = Mode.find positions parsed_value ~sub in\n Of_sexp_error.raise ~user_exn ~sub_sexp:sub ~location\n ;;\n\n let parse_string_exn str f =\n let parsed_value = Sexp_parser.parse_string_exn str in\n match Mode.apply_f parsed_value ~f with\n | x -> x\n | exception Sexp.Of_sexp_error (exn, sub) ->\n let positions = Positions_parser.parse_string_exn str in\n reraise positions parsed_value exn ~sub\n ;;\n\n let parse_string str f : (_, Conv_error.t) result =\n match parse_string_exn str f with\n | x -> Ok x\n | exception Parse_error.Parse_error e -> Error (Parse_error e)\n | exception Of_sexp_error.Of_sexp_error e -> Error (Of_sexp_error e)\n ;;\n\n let conv_exn (parsed_value, positions) f =\n match Mode.apply_f parsed_value ~f with\n | x -> x\n | exception Sexp.Of_sexp_error (exn, sub) -> reraise positions parsed_value exn ~sub\n ;;\n\n let conv x f =\n match conv_exn x f with\n | x -> Ok x\n | exception Of_sexp_error.Of_sexp_error e -> Error e\n ;;\n\n let conv_combine result f : (_, Conv_error.t) result =\n match result with\n | Error e -> Error (Parse_error e)\n | Ok x ->\n (match conv x f with\n | Ok _ as r -> r\n | Error e -> Error (Of_sexp_error e))\n ;;\nend\n","(* Sexp: Module for handling S-expressions (I/O, etc.) *)\n\nopen Format\nopen Bigarray\nmodule Sexplib = Sexplib0\nmodule Conv = Sexplib.Sexp_conv\n\n(* conv.ml depends on us so we can only use this module *)\n\ninclude Type\n\ntype bigstring = (char, int8_unsigned_elt, c_layout) Array1.t\n\ninclude (\n Sexplib.Sexp :\n module type of struct\n include Sexplib.Sexp\n end\n with type t := t)\n\ninclude Private\n\n(* Output of S-expressions to I/O-channels *)\n\nlet with_new_buffer oc f =\n let buf = buffer () in\n f buf;\n Buffer.output_buffer oc buf\n;;\n\nlet output_hum oc sexp = with_new_buffer oc (fun buf -> to_buffer_hum sexp ~buf)\n\nlet output_hum_indent indent oc sexp =\n with_new_buffer oc (fun buf -> to_buffer_hum ~indent sexp ~buf)\n;;\n\nlet output_mach oc sexp = with_new_buffer oc (fun buf -> to_buffer_mach sexp ~buf)\nlet output = output_mach\n\n(* Output of S-expressions to file *)\n\n(* The temp file functions in the OCaml Filename module do not support\n permissions. But opening a file with given permissions is different\n from opening it and chmoding it to these permissions, because the umask\n is taken in account. Under Unix there's no easy way to get the umask in\n a thread-safe way. *)\nmodule Tmp_file = struct\n let prng = ref None\n\n let temp_file_name prefix suffix =\n let rand_state =\n match !prng with\n | Some v -> v\n | None ->\n let ret = Random.State.make_self_init () in\n prng := Some ret;\n ret\n in\n let rnd = Random.State.bits rand_state land 0xFFFFFF in\n Printf.sprintf \"%s%06x%s\" prefix rnd suffix\n ;;\n\n (* Keep the permissions loose. Sexps are usually shared and rarely private*)\n let open_temp_file ?(perm = 0o666) prefix suffix =\n let rec try_name counter =\n let name = temp_file_name prefix suffix in\n try\n let oc =\n open_out_gen [ Open_wronly; Open_creat; Open_excl; Open_text ] perm name\n in\n name, oc\n with\n | Sys_error _ as e -> if counter >= 1000 then raise e else try_name (counter + 1)\n in\n try_name 0\n ;;\nend\n\nlet save_of_output ?perm output_function file sexp =\n let tmp_name, oc = Tmp_file.open_temp_file ?perm file \"tmp\" in\n (try\n output_function oc sexp;\n close_out oc\n with\n | e ->\n close_out_noerr oc;\n (try Sys.remove tmp_name with\n | _ -> ());\n raise e);\n Sys.rename tmp_name file\n;;\n\nlet output_sexp_nl do_output oc sexp =\n do_output oc sexp;\n output_string oc \"\\n\"\n;;\n\nlet save_hum ?perm file sexp = save_of_output ?perm (output_sexp_nl output_hum) file sexp\nlet save_mach ?perm file sexp = save_of_output ?perm output_mach file sexp\nlet save = save_mach\nlet output_sexps_nl do_output oc sexps = List.iter (output_sexp_nl do_output oc) sexps\n\nlet save_sexps_hum ?perm file sexps =\n save_of_output ?perm (output_sexps_nl output_hum) file sexps\n;;\n\nlet save_sexps_mach ?perm file sexps =\n save_of_output ?perm (output_sexps_nl output_mach) file sexps\n;;\n\nlet save_sexps = save_sexps_mach\n\n(* Scan functions *)\n\nlet scan_sexp ?buf lexbuf = Parser.sexp (Lexer.main ?buf) lexbuf\nlet scan_sexp_opt ?buf lexbuf = Parser.sexp_opt (Lexer.main ?buf) lexbuf\nlet scan_sexps ?buf lexbuf = Parser.sexps (Lexer.main ?buf) lexbuf\nlet scan_rev_sexps ?buf lexbuf = Parser.rev_sexps (Lexer.main ?buf) lexbuf\n\nlet get_main_buf buf =\n let buf =\n match buf with\n | None -> Buffer.create 128\n | Some buf -> buf\n in\n Lexer.main ~buf\n;;\n\nlet scan_fold_sexps ?buf ~f ~init lexbuf =\n let main = get_main_buf buf in\n let rec loop acc =\n match Parser.sexp_opt main lexbuf with\n | None -> acc\n | Some sexp -> loop (f acc sexp)\n in\n loop init\n;;\n\nlet scan_iter_sexps ?buf ~f lexbuf =\n scan_fold_sexps ?buf lexbuf ~init:() ~f:(fun () sexp -> f sexp)\n;;\n\nlet scan_sexps_conv ?buf ~f lexbuf =\n let coll acc sexp = f sexp :: acc in\n List.rev (scan_fold_sexps ?buf ~f:coll ~init:[] lexbuf)\n;;\n\nlet sexp_conversion_error_message ?containing_sexp ?location ?invalid_sexp () ~exn : t =\n List\n (List.concat\n [ [ Atom \"Of_sexp_error\" ]\n ; (match location with\n | None -> []\n | Some x -> [ Atom x ])\n ; [ (match exn with\n | Failure x -> Atom x\n | _ -> Conv.sexp_of_exn exn)\n ]\n ; (match invalid_sexp with\n | None -> []\n | Some x -> [ List [ Atom \"invalid_sexp\"; x ] ])\n ; (match containing_sexp with\n | None -> []\n | Some x -> [ List [ Atom \"containing_sexp\"; x ] ])\n ])\n;;\n\n(* Partial parsing *)\n\nmodule Annot = struct\n type pos = Parsexp.Positions.pos =\n { line : int\n ; col : int\n ; offset : int\n }\n\n type range = Parsexp.Positions.range =\n { start_pos : pos\n ; end_pos : pos\n }\n\n type t =\n | Atom of range * Type.t\n | List of range * t list * Type.t\n\n type 'a conv =\n [ `Result of 'a\n | `Error of exn * t\n ]\n\n exception Conv_exn of string * exn\n\n let () =\n Conv.Exn_converter.add ~finalise:false [%extension_constructor Conv_exn] (function\n | Conv_exn (location, exn) -> sexp_conversion_error_message () ~location ~exn\n | _ -> assert false)\n ;;\n\n type stack =\n { mutable positions : pos list\n ; mutable stack : t list list\n }\n\n let get_sexp = function\n | Atom (_, sexp) | List (_, _, sexp) -> sexp\n ;;\n\n let get_range = function\n | Atom (range, _) | List (range, _, _) -> range\n ;;\n\n let sexp_of_conv sexp_of_a = function\n | `Result a -> Type.List [ Atom \"Result\"; a |> sexp_of_a ]\n | `Error (exn, t) ->\n List [ Atom \"Error\"; List [ exn |> Conv.sexp_of_exn; t |> get_sexp ] ]\n ;;\n\n exception Annot_sexp of t\n\n let find_sexp annot_sexp sexp =\n let rec loop annot_sexp =\n match annot_sexp with\n | (Atom (_, sub_sexp) | List (_, _, sub_sexp)) when sexp == sub_sexp ->\n raise (Annot_sexp annot_sexp)\n | List (_, annots, _) -> List.iter loop annots\n | Atom _ -> ()\n in\n try\n loop annot_sexp;\n None\n with\n | Annot_sexp res -> Some res\n ;;\nend\n\nlet () =\n Conv.Exn_converter.add ~finalise:false [%extension_constructor Of_sexp_error] (function\n | Of_sexp_error (Annot.Conv_exn (location, exn), invalid_sexp) ->\n sexp_conversion_error_message () ~location ~invalid_sexp ~exn\n | Of_sexp_error (exn, invalid_sexp) ->\n sexp_conversion_error_message () ~invalid_sexp ~exn\n | _ ->\n (* Reaching this branch indicates a bug in sexplib. *)\n assert false)\n;;\n\nmodule Parse_pos = struct\n type t =\n { mutable text_line : int\n ; mutable text_char : int\n ; mutable global_offset : int\n ; mutable buf_pos : int\n }\n\n let create ?(text_line = 1) ?(text_char = 0) ?(buf_pos = 0) ?(global_offset = 0) () =\n let fail msg = failwith (\"Sexplib.Sexp.Parse_pos.create: \" ^ msg) in\n if text_line < 1\n then fail \"text_line < 1\"\n else if text_char < 0\n then fail \"text_char < 0\"\n else if global_offset < 0\n then fail \"global_offset < 0\"\n else if buf_pos < 0\n then fail \"buf_pos < 0\"\n else { text_line; text_char; global_offset; buf_pos }\n ;;\n\n let with_buf_pos t buf_pos = { t with buf_pos }\nend\n\nmodule Cont_state = Parsexp.Old_parser_cont_state\n\ntype ('a, 't) parse_result =\n | Done of 't * Parse_pos.t\n | Cont of Cont_state.t * ('a, 't) parse_fun\n\nand ('a, 't) parse_fun = pos:int -> len:int -> 'a -> ('a, 't) parse_result\n\ntype 't parse_state = { parse_pos : Parse_pos.t }\n\ntype parse_error =\n { err_msg : string\n ; parse_state : [ `Sexp of t list list parse_state | `Annot of Annot.stack parse_state ]\n }\n\nexception Parse_error of parse_error\n\nlet () =\n Conv.Exn_converter.add ~finalise:false [%extension_constructor Parse_error] (function\n | Parse_error pe ->\n let ppos =\n match pe.parse_state with\n | `Sexp { parse_pos } | `Annot { parse_pos } -> parse_pos\n in\n List\n [ Atom \"Sexplib.Sexp.Parse_error\"\n ; List\n [ List [ Atom \"err_msg\"; Atom pe.err_msg ]\n ; List [ Atom \"text_line\"; Conv.sexp_of_int ppos.Parse_pos.text_line ]\n ; List [ Atom \"text_char\"; Conv.sexp_of_int ppos.Parse_pos.text_char ]\n ; List\n [ Atom \"global_offset\"; Conv.sexp_of_int ppos.Parse_pos.global_offset ]\n ; List [ Atom \"buf_pos\"; Conv.sexp_of_int ppos.Parse_pos.buf_pos ]\n ]\n ]\n | _ -> assert false)\n;;\n\nmodule Parser_output : sig\n module type T = sig\n module Impl : Parsexp.Eager_parser\n\n type output\n\n exception Found of output\n\n val raise_found : Impl.State.Read_only.t -> Impl.parsed_value -> unit\n end\n\n module Bare_sexp : T with type output = Type.t\n module Annotated_sexp : T with type output = Annot.t\nend = struct\n module type T = sig\n module Impl : Parsexp.Eager_parser\n\n type output\n\n exception Found of output\n\n val raise_found : Impl.State.Read_only.t -> Impl.parsed_value -> unit\n end\n\n module I = Parsexp.Positions.Iterator\n\n let rec annotate_sexp sexp iter =\n match sexp with\n | Type.Atom _ ->\n let start_pos = I.advance_exn iter ~skip:0 in\n let end_pos = I.advance_exn iter ~skip:0 in\n Annot.Atom ({ start_pos; end_pos }, sexp)\n | Type.List l ->\n let start_pos = I.advance_exn iter ~skip:0 in\n let annot = annotate_sexp_list l iter in\n let end_pos = I.advance_exn iter ~skip:0 in\n Annot.List ({ start_pos; end_pos }, annot, sexp)\n\n and annotate_sexp_list sexps iter =\n List.rev (List.rev_map (fun sexp -> annotate_sexp sexp iter) sexps)\n ;;\n\n module Bare_sexp = struct\n module Impl = Parsexp.Eager\n\n type output = Type.t\n\n exception Found of output\n\n let raise_found _state sexp = raise_notrace (Found sexp)\n end\n\n module Annotated_sexp = struct\n module Impl = Parsexp.Eager_and_positions\n\n type output = Annot.t\n\n exception Found of output\n\n let raise_found _state (sexp, positions) =\n let annot = annotate_sexp sexp (I.create positions) in\n raise_notrace (Found annot)\n ;;\n end\nend\n\nmodule Make_parser (T : sig\n include Parser_output.T\n\n type input\n\n val length : input -> int\n\n val unsafe_feed_loop\n : Impl.State.t\n -> Impl.Stack.t\n -> input\n -> max_pos:int\n -> pos:int\n -> Impl.Stack.t\n end) : sig\n val parse\n : ?parse_pos:Parse_pos.t\n -> ?len:int\n -> T.input\n -> (T.input, T.output) parse_result\nend = struct\n let parse_pos_of_state state buf_pos =\n { Parse_pos.text_line = T.Impl.State.line state\n ; Parse_pos.text_char = T.Impl.State.column state\n ; Parse_pos.global_offset = T.Impl.State.offset state\n ; Parse_pos.buf_pos\n }\n ;;\n\n let check_str_bounds ~pos ~len str =\n if pos < 0 then invalid_arg \"parse: pos < 0\";\n if len < 0 then invalid_arg \"parse: len < 0\";\n let str_len = T.length str in\n let pos_len = pos + len in\n if pos_len > str_len then invalid_arg \"parse: pos + len > str_len\";\n pos_len - 1\n ;;\n\n let raise_parse_error state pos msg =\n let parse_state = { parse_pos = parse_pos_of_state state pos } in\n let parse_error = { err_msg = msg; parse_state = `Sexp parse_state } in\n raise (Parse_error parse_error)\n ;;\n\n let handle_parsexp_error state pos e =\n let msg = Parsexp.Parse_error.message e in\n match Parsexp.Parse_error.Private.old_parser_exn e with\n | `Parse_error -> raise_parse_error state pos msg\n | `Failure -> failwith msg\n ;;\n\n let rec run_feed_loop state stack ~pos ~len str =\n let max_pos = check_str_bounds ~pos ~len str in\n let previous_offset = T.Impl.State.offset state in\n match T.unsafe_feed_loop state stack str ~max_pos ~pos with\n | stack -> mk_cont_state state stack\n | exception T.Found result ->\n let offset = T.Impl.State.offset state in\n let next_pos = pos + (offset - previous_offset) in\n Done (result, parse_pos_of_state state next_pos)\n | exception Parsexp.Parse_error.Parse_error err ->\n handle_parsexp_error\n state\n (pos + (T.Impl.State.offset state - previous_offset))\n err\n\n and mk_cont_state state stack =\n let parse_fun =\n let used_ref = ref false in\n fun ~pos ~len str ->\n if !used_ref\n then failwith \"Sexplib.Sexp: parser continuation called twice\"\n else (\n used_ref := true;\n run_feed_loop state stack ~pos ~len str)\n in\n let cont_state = T.Impl.State.old_parser_cont_state state in\n Cont (cont_state, parse_fun)\n ;;\n\n let parse ?(parse_pos = Parse_pos.create ()) ?len str =\n let pos, buf_pos =\n let { Parse_pos.text_line; text_char; global_offset; buf_pos } = parse_pos in\n ( { Parsexp.Positions.line = text_line; col = text_char; offset = global_offset }\n , buf_pos )\n in\n let state = T.Impl.State.create ~pos ~no_sexp_is_error:false T.raise_found in\n let stack = T.Impl.Stack.empty in\n let len =\n match len with\n | Some x -> x\n | None -> T.length str - buf_pos\n in\n run_feed_loop state stack str ~pos:buf_pos ~len\n ;;\nend\n[@@inline always]\n\nmodule String_single_sexp = Make_parser (struct\n include Parser_output.Bare_sexp\n\n type input = string\n\n let length = String.length\n\n let rec unsafe_feed_loop state stack str ~max_pos ~pos =\n if pos <= max_pos\n then (\n let stack = Impl.feed state (String.unsafe_get str pos) stack in\n unsafe_feed_loop state stack str ~max_pos ~pos:(pos + 1))\n else stack\n ;;\n end)\n\nlet parse_str = String_single_sexp.parse\nlet parse = String_single_sexp.parse\n\nmodule String_single_annot = Make_parser (struct\n include Parser_output.Annotated_sexp\n\n type input = string\n\n let length = String.length\n\n let rec unsafe_feed_loop state stack str ~max_pos ~pos =\n if pos <= max_pos\n then (\n let stack = Impl.feed state (String.unsafe_get str pos) stack in\n unsafe_feed_loop state stack str ~max_pos ~pos:(pos + 1))\n else stack\n ;;\n end)\n\nlet parse_str_annot = String_single_annot.parse\n\nmodule Bigstring_single_sexp = Make_parser (struct\n include Parser_output.Bare_sexp\n\n type input = bigstring\n\n let length = Array1.dim\n\n let rec unsafe_feed_loop state stack (str : input) ~max_pos ~pos =\n if pos <= max_pos\n then (\n let stack = Impl.feed state (Array1.unsafe_get str pos) stack in\n unsafe_feed_loop state stack str ~max_pos ~pos:(pos + 1))\n else stack\n ;;\n end)\n\nlet parse_bigstring = Bigstring_single_sexp.parse\n\nmodule Bigstring_single_annot = Make_parser (struct\n include Parser_output.Annotated_sexp\n\n type input = bigstring\n\n let length = Array1.dim\n\n let rec unsafe_feed_loop state stack (str : input) ~max_pos ~pos =\n if pos <= max_pos\n then (\n let stack = Impl.feed state (Array1.unsafe_get str pos) stack in\n unsafe_feed_loop state stack str ~max_pos ~pos:(pos + 1))\n else stack\n ;;\n end)\n\nlet parse_bigstring_annot = Bigstring_single_annot.parse\n\n(* Input functions *)\n\nlet mk_this_parse ?parse_pos my_parse =\n ();\n fun ~pos ~len str ->\n let parse_pos =\n match parse_pos with\n | None -> Parse_pos.create ~buf_pos:pos ()\n | Some parse_pos ->\n parse_pos.Parse_pos.buf_pos <- pos;\n parse_pos\n in\n my_parse ?parse_pos:(Some parse_pos) ?len:(Some len) str\n;;\n\n(* [ws_buf] must contain a single space character *)\nlet feed_end_of_input ~this_parse ~ws_buf =\n (* When parsing atoms, the incremental parser cannot tell whether\n it is at the end until it hits whitespace. We therefore feed it\n one space to determine whether it is finished. *)\n match this_parse ~pos:0 ~len:1 ws_buf with\n | Done (sexp, _) -> Ok sexp\n | Cont (cont_state, _) -> Error cont_state\n;;\n\nlet gen_input_sexp my_parse ?parse_pos ic =\n let buf = Bytes.create 1 in\n let rec loop this_parse =\n match input_char ic with\n | exception End_of_file ->\n (match feed_end_of_input ~this_parse ~ws_buf:\" \" with\n | Ok sexp -> sexp\n | Error _ -> raise End_of_file)\n | c ->\n Bytes.set buf 0 c;\n (match this_parse ~pos:0 ~len:1 (Bytes.unsafe_to_string buf) with\n | Done (sexp, _) -> sexp\n | Cont (_, this_parse) -> loop this_parse)\n in\n loop (mk_this_parse ?parse_pos my_parse)\n;;\n\nlet input_sexp ?parse_pos ic = gen_input_sexp parse ?parse_pos ic\n\nlet gen_input_rev_sexps my_parse ~ws_buf ?parse_pos ?(buf = Bytes.create 8192) ic =\n let rev_sexps_ref = ref [] in\n let buf_len = Bytes.length buf in\n let rec loop this_parse ~pos ~len =\n if len > 0\n then (\n match this_parse ~pos ~len (Bytes.unsafe_to_string buf) with\n | Done (sexp, ({ Parse_pos.buf_pos; _ } as parse_pos)) ->\n rev_sexps_ref := sexp :: !rev_sexps_ref;\n let n_parsed = buf_pos - pos in\n let this_parse = mk_this_parse ~parse_pos my_parse in\n if n_parsed = len\n then (\n let new_len = input ic buf 0 buf_len in\n loop this_parse ~pos:0 ~len:new_len)\n else loop this_parse ~pos:buf_pos ~len:(len - n_parsed)\n | Cont (_, this_parse) -> loop this_parse ~pos:0 ~len:(input ic buf 0 buf_len))\n else (\n match feed_end_of_input ~this_parse ~ws_buf with\n | Ok sexp -> sexp :: !rev_sexps_ref\n | Error Parsing_toplevel_whitespace -> !rev_sexps_ref\n | Error cont_state ->\n failwith\n (\"Sexplib.Sexp.input_rev_sexps: reached EOF while in state \"\n ^ Cont_state.to_string cont_state))\n in\n let len = input ic buf 0 buf_len in\n let this_parse = mk_this_parse ?parse_pos my_parse in\n loop this_parse ~pos:0 ~len\n;;\n\nlet input_rev_sexps ?parse_pos ?buf ic =\n gen_input_rev_sexps parse ~ws_buf:\" \" ?parse_pos ?buf ic\n;;\n\nlet input_sexps ?parse_pos ?buf ic = List.rev (input_rev_sexps ?parse_pos ?buf ic)\n\n(* of_string and of_bigstring *)\n\nlet of_string_bigstring loc my_parse ws_buf get_len get_sub str =\n match my_parse ?parse_pos:None ?len:None str with\n | Done (sexp, parse_pos) ->\n (match my_parse ?parse_pos:(Some parse_pos) ?len:None str with\n | Done (_sexp2, _) ->\n failwith\n (sprintf\n \"Sexplib.Sexp.%s: got multiple S-expressions where only one was expected.\"\n loc)\n | Cont (Cont_state.Parsing_toplevel_whitespace, _) -> sexp\n | Cont (_, _) ->\n (* not using [feed_end_of_input] here means \"a b\" will end up here and not in\n \"multiple S-expressions\" branch, but it doesn't matter that much *)\n failwith\n (sprintf\n \"Sexplib.Sexp.%s: S-expression followed by data at position %d...\"\n loc\n parse_pos.buf_pos))\n | Cont (_, this_parse) ->\n (match feed_end_of_input ~this_parse ~ws_buf with\n | Ok sexp -> sexp\n | Error cont_state ->\n let cont_state_str = Cont_state.to_string cont_state in\n failwith\n (sprintf\n \"Sexplib.Sexp.%s: incomplete S-expression while in state %s: %s\"\n loc\n cont_state_str\n (get_sub str 0 (get_len str))))\n;;\n\nlet of_string str =\n of_string_bigstring \"of_string\" parse \" \" String.length String.sub str\n;;\n\nlet get_bstr_sub_str bstr pos len =\n let str = Bytes.create len in\n for i = 0 to len - 1 do\n Bytes.set str i bstr.{pos + i}\n done;\n Bytes.unsafe_to_string str\n;;\n\nlet bstr_ws_buf = Array1.create char c_layout 1\nlet () = bstr_ws_buf.{0} <- ' '\n\nlet of_bigstring bstr =\n of_string_bigstring\n \"of_bigstring\"\n parse_bigstring\n bstr_ws_buf\n Array1.dim\n get_bstr_sub_str\n bstr\n;;\n\n(* Loading *)\n\nlet gen_load_rev_sexps input_rev_sexps ?buf file =\n let ic = open_in file in\n try\n let sexps = input_rev_sexps ?parse_pos:None ?buf ic in\n close_in ic;\n sexps\n with\n | exc ->\n close_in_noerr ic;\n raise exc\n;;\n\nlet load_rev_sexps ?buf file = gen_load_rev_sexps input_rev_sexps ?buf file\nlet load_sexps ?buf file = List.rev (load_rev_sexps ?buf file)\nlet gen_load_sexp_loc = \"Sexplib.Sexp.gen_load_sexp\"\n\nlet gen_load_sexp my_parse ?(strict = true) ?(buf = Bytes.create 8192) file =\n let buf_len = Bytes.length buf in\n let ic = open_in file in\n let rec loop this_parse =\n let len = input ic buf 0 buf_len in\n if len = 0\n then (\n match feed_end_of_input ~this_parse ~ws_buf:\" \" with\n | Ok sexp -> sexp\n | Error cont_state ->\n failwith\n (sprintf\n \"%s: EOF in %s while in state %s\"\n gen_load_sexp_loc\n file\n (Cont_state.to_string cont_state)))\n else (\n match this_parse ~pos:0 ~len (Bytes.unsafe_to_string buf) with\n | Done (sexp, ({ Parse_pos.buf_pos; _ } as parse_pos)) when strict ->\n let rec strict_loop this_parse ~pos ~len =\n match this_parse ~pos ~len (Bytes.unsafe_to_string buf) with\n | Done _ ->\n failwith\n (sprintf \"%s: more than one S-expression in file %s\" gen_load_sexp_loc file)\n | Cont (cont_state, this_parse) ->\n let len = input ic buf 0 buf_len in\n if len > 0\n then strict_loop this_parse ~pos:0 ~len\n else if cont_state = Cont_state.Parsing_toplevel_whitespace\n then sexp\n else\n failwith\n (sprintf\n \"%s: %s in state %s loading file %s\"\n gen_load_sexp_loc\n \"additional incomplete data\"\n (Cont_state.to_string cont_state)\n file)\n in\n let this_parse = mk_this_parse ~parse_pos my_parse in\n strict_loop this_parse ~pos:buf_pos ~len:(len - buf_pos)\n | Done (sexp, _) -> sexp\n | Cont (_, this_parse) -> loop this_parse)\n in\n try\n let sexp = loop (mk_this_parse my_parse) in\n close_in ic;\n sexp\n with\n | exc ->\n close_in_noerr ic;\n raise exc\n;;\n\nlet load_sexp ?strict ?buf file = gen_load_sexp parse ?strict ?buf file\n\nmodule Annotated = struct\n include Annot\n\n let parse = parse_str_annot\n let parse_bigstring = parse_bigstring_annot\n\n let input_rev_sexps ?parse_pos ?buf ic =\n gen_input_rev_sexps parse ~ws_buf:\" \" ?parse_pos ?buf ic\n ;;\n\n let input_sexp ?parse_pos ic = gen_input_sexp parse ?parse_pos ic\n let input_sexps ?parse_pos ?buf ic = List.rev (input_rev_sexps ?parse_pos ?buf ic)\n\n let of_string str =\n of_string_bigstring \"Annotated.of_string\" parse \" \" String.length String.sub str\n ;;\n\n let of_bigstring bstr =\n of_string_bigstring\n \"Annotated.of_bigstring\"\n parse_bigstring\n bstr_ws_buf\n Array1.dim\n get_bstr_sub_str\n bstr\n ;;\n\n let load_rev_sexps ?buf file = gen_load_rev_sexps input_rev_sexps ?buf file\n let load_sexps ?buf file = List.rev (load_rev_sexps ?buf file)\n let load_sexp ?strict ?buf file = gen_load_sexp parse ?strict ?buf file\n\n let conv f annot_sexp =\n let sexp = get_sexp annot_sexp in\n try `Result (f sexp) with\n | Of_sexp_error (exc, bad_sexp) as e ->\n (match find_sexp annot_sexp bad_sexp with\n | None -> raise e\n | Some bad_annot_sexp -> `Error (exc, bad_annot_sexp))\n ;;\n\n let get_conv_exn ~file ~exc annot_sexp =\n let range = get_range annot_sexp in\n let { start_pos = { line; col; offset = _ }; end_pos = _ } = range in\n let loc = sprintf \"%s:%d:%d\" file line col in\n Of_sexp_error (Annot.Conv_exn (loc, exc), get_sexp annot_sexp)\n ;;\nend\n\nlet load_sexp_conv ?(strict = true) ?(buf = Bytes.create 8192) file f =\n let sexp = load_sexp ~strict ~buf file in\n try `Result (f sexp) with\n | Of_sexp_error _ -> Annotated.conv f (Annotated.load_sexp ~strict ~buf file)\n;;\n\nlet raise_conv_exn ~file = function\n | `Result res -> res\n | `Error (exc, annot_sexp) -> raise (Annotated.get_conv_exn ~file ~exc annot_sexp)\n;;\n\nlet load_sexp_conv_exn ?strict ?buf file f =\n raise_conv_exn ~file (load_sexp_conv ?strict ?buf file f)\n;;\n\nlet load_sexps_conv ?(buf = Bytes.create 8192) file f =\n let rev_sexps = load_rev_sexps ~buf file in\n try List.rev_map (fun sexp -> `Result (f sexp)) rev_sexps with\n | Of_sexp_error _ as e ->\n (match Annotated.load_rev_sexps ~buf file with\n | [] ->\n (* File is now empty - perhaps it was a temporary file handle? *)\n raise e\n | rev_annot_sexps ->\n List.rev_map (fun annot_sexp -> Annotated.conv f annot_sexp) rev_annot_sexps)\n;;\n\nlet load_sexps_conv_exn ?(buf = Bytes.create 8192) file f =\n let rev_sexps = load_rev_sexps ~buf file in\n try List.rev_map f rev_sexps with\n | Of_sexp_error _ as e ->\n (match Annotated.load_rev_sexps ~buf file with\n | [] ->\n (* File is now empty - perhaps it was a temporary file handle? *)\n raise e\n | rev_annot_sexps ->\n List.rev_map\n (fun annot_sexp -> raise_conv_exn ~file (Annotated.conv f annot_sexp))\n rev_annot_sexps)\n;;\n\nlet gen_of_string_conv of_string annot_of_string str f =\n let sexp = of_string str in\n try `Result (f sexp) with\n | Of_sexp_error _ -> Annotated.conv f (annot_of_string str)\n;;\n\nlet of_string_conv str f = gen_of_string_conv of_string Annotated.of_string str f\n\nlet of_bigstring_conv bstr f =\n gen_of_string_conv of_bigstring Annotated.of_bigstring bstr f\n;;\n\nmodule Of_string_conv_exn = struct\n type t =\n { exc : exn\n ; sexp : Type.t\n ; sub_sexp : Type.t\n }\n\n exception E of t\n\n let () =\n Conv.Exn_converter.add ~finalise:false [%extension_constructor E] (function\n | E osce ->\n sexp_conversion_error_message\n ()\n ~invalid_sexp:osce.sub_sexp\n ~exn:osce.exc\n ~containing_sexp:osce.sexp\n | _ -> assert false)\n ;;\nend\n\nlet gen_of_string_conv_exn of_string str f =\n let sexp = of_string str in\n try f sexp with\n | Of_sexp_error (exc, sub_sexp) ->\n raise (Of_string_conv_exn.E { Of_string_conv_exn.exc; sexp; sub_sexp })\n;;\n\nlet of_string_conv_exn str f = gen_of_string_conv_exn of_string str f\nlet of_bigstring_conv_exn bstr f = gen_of_string_conv_exn of_bigstring bstr f\n\n(* Utilities for automated type conversions *)\n\nlet unit = List []\n\nlet is_unit = function\n | List [] -> true\n | _ -> false\n;;\n\nexternal sexp_of_t : t -> t = \"%identity\"\nexternal t_of_sexp : t -> t = \"%identity\"\n\n(* Utilities for conversion error handling *)\n\ntype found =\n [ `Found\n | `Pos of int * found\n ]\n\ntype search_result =\n [ `Not_found\n | found\n ]\n\nlet rec search_physical sexp ~contained =\n if sexp == contained\n then `Found\n else (\n match sexp with\n | Atom _ -> `Not_found\n | List lst ->\n let rec loop i = function\n | [] -> `Not_found\n | h :: t ->\n let res = search_physical h ~contained in\n (match res with\n | `Not_found -> loop (i + 1) t\n | #found as found -> `Pos (i, found))\n in\n loop 0 lst)\n;;\n\nlet rec subst_found sexp ~subst = function\n | `Found -> subst\n | `Pos (pos, found) ->\n (match sexp with\n | Atom _ -> failwith \"Sexplib.Sexp.subst_found: atom when position requested\"\n | List lst ->\n let rec loop acc pos = function\n | [] -> failwith \"Sexplib.Sexp.subst_found: short list when position requested\"\n | h :: t when pos <> 0 -> loop (h :: acc) (pos - 1) t\n | h :: t -> List (List.rev_append acc (subst_found h ~subst found :: t))\n in\n loop [] pos lst)\n;;\n","open! Import\n\ntype t =\n | Parsing_toplevel_whitespace\n | Parsing_nested_whitespace\n | Parsing_atom\n | Parsing_list\n | Parsing_sexp_comment\n | Parsing_block_comment\n[@@deriving_inline sexp_of]\n\nlet sexp_of_t =\n (function\n | Parsing_toplevel_whitespace ->\n Ppx_sexp_conv_lib.Sexp.Atom \"Parsing_toplevel_whitespace\"\n | Parsing_nested_whitespace -> Ppx_sexp_conv_lib.Sexp.Atom \"Parsing_nested_whitespace\"\n | Parsing_atom -> Ppx_sexp_conv_lib.Sexp.Atom \"Parsing_atom\"\n | Parsing_list -> Ppx_sexp_conv_lib.Sexp.Atom \"Parsing_list\"\n | Parsing_sexp_comment -> Ppx_sexp_conv_lib.Sexp.Atom \"Parsing_sexp_comment\"\n | Parsing_block_comment -> Ppx_sexp_conv_lib.Sexp.Atom \"Parsing_block_comment\"\n : t -> Ppx_sexp_conv_lib.Sexp.t)\n;;\n\n[@@@end]\n\nlet to_string t =\n match sexp_of_t t with\n | Atom s -> s\n | List _ -> failwith \"BUG: [sexp_of_t] returned a [List _]\"\n;;\n","open Printf\nopen Bigarray\ninclude Sexplib0.Sexp_conv\nopen Sexp\n\ntype bigstring = (char, int8_unsigned_elt, c_layout) Array1.t\ntype float32_vec = (float, float32_elt, fortran_layout) Array1.t\ntype float64_vec = (float, float64_elt, fortran_layout) Array1.t\ntype vec = float64_vec\ntype float32_mat = (float, float32_elt, fortran_layout) Array2.t\ntype float64_mat = (float, float64_elt, fortran_layout) Array2.t\ntype mat = float64_mat\n\nlet sexp_of_float_vec vec =\n let lst_ref = ref [] in\n for i = Array1.dim vec downto 1 do\n lst_ref := sexp_of_float vec.{i} :: !lst_ref\n done;\n List !lst_ref\n;;\n\nlet sexp_of_bigstring (bstr : bigstring) =\n let n = Array1.dim bstr in\n let str = Bytes.create n in\n for i = 0 to n - 1 do\n Bytes.set str i bstr.{i}\n done;\n Atom (Bytes.unsafe_to_string str)\n;;\n\nlet sexp_of_float32_vec (vec : float32_vec) = sexp_of_float_vec vec\nlet sexp_of_float64_vec (vec : float64_vec) = sexp_of_float_vec vec\nlet sexp_of_vec (vec : vec) = sexp_of_float_vec vec\n\nlet sexp_of_float_mat mat =\n let m = Array2.dim1 mat in\n let n = Array2.dim2 mat in\n let lst_ref = ref [] in\n (* It's surprising that we serialize [Fortran_layout] matrices in row-major order. I can\n only speculate that it was chosen for readability. The cache performance is\n irrelevant because people who care won't serialize to sexp. *)\n for row = n downto 1 do\n for col = m downto 1 do\n lst_ref := sexp_of_float mat.{col, row} :: !lst_ref\n done\n done;\n List (sexp_of_int m :: sexp_of_int n :: !lst_ref)\n;;\n\nlet sexp_of_float32_mat (mat : float32_mat) = sexp_of_float_mat mat\nlet sexp_of_float64_mat (mat : float64_mat) = sexp_of_float_mat mat\nlet sexp_of_mat (mat : mat) = sexp_of_float_mat mat\nlet bigstring_sexp_grammar : Sexplib0.Sexp.Private.Raw_grammar.t = Inline (Atom String)\n\nlet bigstring_of_sexp sexp =\n match sexp with\n | Atom str ->\n let len = String.length str in\n let bstr = Array1.create char c_layout len in\n for i = 0 to len - 1 do\n bstr.{i} <- str.[i]\n done;\n bstr\n | List _ -> of_sexp_error \"bigstring_of_sexp: atom needed\" sexp\n;;\n\nlet float_vec_of_sexp empty_float_vec create_float_vec sexp =\n match sexp with\n | List [] -> empty_float_vec\n | List lst ->\n let len = List.length lst in\n let res = create_float_vec len in\n let rec loop i = function\n | [] -> res\n | h :: t ->\n res.{i} <- float_of_sexp h;\n loop (i + 1) t\n in\n loop 1 lst\n | Atom _ -> of_sexp_error \"float_vec_of_sexp: list needed\" sexp\n;;\n\nlet create_float32_vec = Array1.create float32 fortran_layout\nlet create_float64_vec = Array1.create float64 fortran_layout\nlet empty_float32_vec = create_float32_vec 0\nlet empty_float64_vec = create_float64_vec 0\nlet float32_vec_of_sexp = float_vec_of_sexp empty_float32_vec create_float32_vec\nlet float64_vec_of_sexp = float_vec_of_sexp empty_float64_vec create_float64_vec\nlet vec_of_sexp = float_vec_of_sexp empty_float64_vec create_float64_vec\n\nlet vec_sexp_grammar : Sexplib0.Sexp.Private.Raw_grammar.t =\n Inline (List [ Many (Atom Float) ])\n;;\n\nlet float32_vec_sexp_grammar = vec_sexp_grammar\nlet float64_vec_sexp_grammar = vec_sexp_grammar\n\nlet check_too_much_data sexp data res =\n if data = [] then res else of_sexp_error \"float_mat_of_sexp: too much data\" sexp\n;;\n\nlet float_mat_of_sexp create_float_mat sexp =\n match sexp with\n | List (sm :: sn :: data) ->\n let m = int_of_sexp sm in\n let n = int_of_sexp sn in\n let res = create_float_mat m n in\n if m = 0 || n = 0\n then check_too_much_data sexp data res\n else (\n let rec loop_cols col data =\n let vec = Array2.slice_right res col in\n let rec loop_rows row = function\n | [] -> of_sexp_error \"float_mat_of_sexp: not enough data\" sexp\n | h :: t ->\n vec.{row} <- float_of_sexp h;\n if row = m\n then\n if col = n then check_too_much_data sexp t res else loop_cols (col + 1) t\n else loop_rows (row + 1) t\n in\n loop_rows 1 data\n in\n loop_cols 1 data)\n | List _ -> of_sexp_error \"float_mat_of_sexp: list too short\" sexp\n | Atom _ -> of_sexp_error \"float_mat_of_sexp: list needed\" sexp\n;;\n\nlet create_float32_mat = Array2.create float32 fortran_layout\nlet create_float64_mat = Array2.create float64 fortran_layout\nlet float32_mat_of_sexp = float_mat_of_sexp create_float32_mat\nlet float64_mat_of_sexp = float_mat_of_sexp create_float64_mat\nlet mat_of_sexp = float_mat_of_sexp create_float64_mat\n\nlet mat_sexp_grammar : Sexplib0.Sexp.Private.Raw_grammar.t =\n Inline (List [ One (Atom Int); One (Atom Int); Many (Atom Float) ])\n;;\n\nlet float32_mat_sexp_grammar = mat_sexp_grammar\nlet float64_mat_sexp_grammar = mat_sexp_grammar\nlet string_of__of__sexp_of to_sexp x = Sexp.to_string (to_sexp x)\n\nlet of_string__of__of_sexp of_sexp s =\n try\n let sexp = Sexp.of_string s in\n of_sexp sexp\n with\n | e ->\n failwith\n (sprintf \"of_string failed on %s with %s\" s (Sexp.to_string_hum (sexp_of_exn e)))\n;;\n","\n(* We do not [include Base] here, and instead import modules that [Core_kernel] doesn't\n extend, because we want code in [Core_kernel] to be clear when it references a [Base]\n module that [Core_kernel] is overriding. *)\nmodule Applicative = Base.Applicative\nmodule Avltree = Base.Avltree\nmodule Backtrace = Base.Backtrace\nmodule Binary_search = Base.Binary_search\nmodule Comparisons = Base.Comparisons\nmodule Continue_or_stop = Base.Continue_or_stop\nmodule Equal = Base.Equal\nmodule Exn = Base.Exn\nmodule Floatable = Base.Floatable\nmodule Formatter = Base.Formatter\nmodule Hash = Base.Hash\nmodule Hasher = Base.Hasher\nmodule Indexed_container = Base.Indexed_container\nmodule Intable = Base.Intable\nmodule Int_conversions = Base.Int_conversions\nmodule Int_math = Base.Int_math\nmodule Invariant = Base.Invariant\nmodule Monad = Base.Monad\nmodule Poly = Base.Poly\n\nmodule Popcount = Base.Popcount\n[@@warning \"-3\"]\n[@@deprecated \"[since 2018-10] use [popcount] functions in individual int modules\"]\n\nmodule Pretty_printer = Base.Pretty_printer\nmodule Random = Base.Random\nmodule Staged = Base.Staged\nmodule Stringable = Base.Stringable\nmodule Uchar = Base.Uchar\nmodule Validate = Base.Validate\nmodule With_return = Base.With_return\nmodule Word_size = Base.Word_size\n\n(* We do include [Base]'s top-level value and type bindings, because they don't cause\n any confusion, and duplicating them would be error prone. *)\ninclude Base.Export\ninclude Stdio\ninclude Base_for_tests\ninclude Bin_prot.Std\nmodule Field = Fieldslib.Field\n\nmodule From_sexplib : sig\n type bigstring = Sexplib.Conv.bigstring [@@deriving sexp]\n type mat = Sexplib.Conv.mat [@@deriving sexp]\n type vec = Sexplib.Conv.vec [@@deriving sexp]\n\n (* [sexp_of_opaque] and [opaque_of_sexp] are used by the code generated from\n [[@@deriving sexp]], [[%sexp_of: ]], and [[%of_sexp: ]]. The type [_ sexp_opaque]\n expands to uses of [sexp_of_opaque] and [opaque_of_sexp]. *)\n\n val sexp_of_opaque : _ -> Base.Sexp.t\n val opaque_of_sexp : Base.Sexp.t -> _\n val sexp_of_pair : ('a -> Base.Sexp.t) -> ('b -> Base.Sexp.t) -> 'a * 'b -> Base.Sexp.t\n val pair_of_sexp : (Base.Sexp.t -> 'a) -> (Base.Sexp.t -> 'b) -> Base.Sexp.t -> 'a * 'b\n\n exception Of_sexp_error of exn * Base.Sexp.t\n\n val of_sexp_error : string -> Base.Sexp.t -> _\n val of_sexp_error_exn : exn -> Base.Sexp.t -> _\nend =\n Sexplib.Conv\n\ninclude From_sexplib\n\n(* [sexp_opaque] indicates to [ppx_sexp_conv] that a value should be rendered as [_], i.e.\n [Sexp.Atom \"_\"]. Here we expose the [@@deriving] aspects of [sexp_opaque] so that\n other ppx's treat [sexp_opaque] correctly, by ignoring it and processing the underlying\n type. *)\ninclude (\nstruct\n type 'a sexp_opaque = 'a [@@deriving bin_io, compare, hash, typerep]\nend :\nsig\n type 'a sexp_opaque [@@deriving bin_io, compare, hash, typerep]\nend\nwith type 'a sexp_opaque := 'a)\n\ninclude (\n Typerep_lib.Std :\n module type of struct\n include Typerep_lib.Std\n end\n with module Type_equal := Typerep_lib.Std.Type_equal)\n\nmodule Variant = Variantslib.Variant\n\nlet with_return = With_return.with_return\nlet am_running_inline_test = Ppx_inline_test_lib.Runtime.am_running_inline_test\n\nlet am_running_test =\n try\n ignore (Caml.Sys.getenv \"TESTING_FRAMEWORK\" : string);\n true\n with\n (* [Caml.*] never raises [Not_found_s] *)\n | Caml.Not_found -> false\n;;\n\ntype 'a identity = 'a\n\nmodule Not_found = struct\n exception\n Not_found = Not_found\n [@deprecated\n {|[since 2018-02] Instead of raising [Not_found], consider using [raise_s] with an\ninformative error message. If code needs to distinguish [Not_found] from other\nexceptions, please change it to handle both [Not_found] and [Not_found_s]. Then, instead\nof raising [Not_found], raise [Not_found_s] with an informative error message.|}]\n\n exception Not_found_s = Base.Not_found_s\nend\n\ninclude Not_found\n","open! Import\ninclude Base.Sexpable\n\nmodule Stable = struct\n module Of_sexpable = struct\n module V1\n (Sexpable : S) (M : sig\n type t\n\n val to_sexpable : t -> Sexpable.t\n val of_sexpable : Sexpable.t -> t\n end) : S with type t := M.t = struct\n let t_of_sexp sexp =\n let s = Sexpable.t_of_sexp sexp in\n try M.of_sexpable s with\n | exn -> of_sexp_error_exn exn sexp\n ;;\n\n let sexp_of_t t = Sexpable.sexp_of_t (M.to_sexpable t)\n end\n end\n\n module Of_sexpable1 = struct\n module V1\n (Sexpable : S1) (M : sig\n type 'a t\n\n val to_sexpable : 'a t -> 'a Sexpable.t\n val of_sexpable : 'a Sexpable.t -> 'a t\n end) : S1 with type 'a t := 'a M.t = struct\n let t_of_sexp a_of_sexp sexp =\n let s = Sexpable.t_of_sexp a_of_sexp sexp in\n try M.of_sexpable s with\n | exn -> of_sexp_error_exn exn sexp\n ;;\n\n let sexp_of_t sexp_of_a t = Sexpable.sexp_of_t sexp_of_a (M.to_sexpable t)\n end\n end\n\n module Of_sexpable2 = struct\n module V1\n (Sexpable : S2) (M : sig\n type ('a, 'b) t\n\n val to_sexpable : ('a, 'b) t -> ('a, 'b) Sexpable.t\n val of_sexpable : ('a, 'b) Sexpable.t -> ('a, 'b) t\n end) : S2 with type ('a, 'b) t := ('a, 'b) M.t = struct\n let t_of_sexp a_of_sexp b_of_sexp sexp =\n let s = Sexpable.t_of_sexp a_of_sexp b_of_sexp sexp in\n try M.of_sexpable s with\n | exn -> of_sexp_error_exn exn sexp\n ;;\n\n let sexp_of_t sexp_of_a sexp_of_b t =\n Sexpable.sexp_of_t sexp_of_a sexp_of_b (M.to_sexpable t)\n ;;\n end\n end\n\n module Of_sexpable3 = struct\n module V1\n (Sexpable : S3) (M : sig\n type ('a, 'b, 'c) t\n\n val to_sexpable : ('a, 'b, 'c) t -> ('a, 'b, 'c) Sexpable.t\n val of_sexpable : ('a, 'b, 'c) Sexpable.t -> ('a, 'b, 'c) t\n end) : S3 with type ('a, 'b, 'c) t := ('a, 'b, 'c) M.t = struct\n let t_of_sexp a_of_sexp b_of_sexp c_of_sexp sexp =\n let s = Sexpable.t_of_sexp a_of_sexp b_of_sexp c_of_sexp sexp in\n try M.of_sexpable s with\n | exn -> of_sexp_error_exn exn sexp\n ;;\n\n let sexp_of_t sexp_of_a sexp_of_b sexp_of_c t =\n Sexpable.sexp_of_t sexp_of_a sexp_of_b sexp_of_c (M.to_sexpable t)\n ;;\n end\n end\n\n module Of_stringable = struct\n module V1 (M : Stringable.S) : S with type t := M.t = struct\n let t_of_sexp sexp =\n match sexp with\n | Sexplib.Sexp.Atom s ->\n (try M.of_string s with\n | exn -> of_sexp_error_exn exn sexp)\n | Sexplib.Sexp.List _ ->\n of_sexp_error\n \"Sexpable.Of_stringable.t_of_sexp expected an atom, but got a list\"\n sexp\n ;;\n\n let sexp_of_t t = Sexplib.Sexp.Atom (M.to_string t)\n end\n end\n\n module To_stringable = struct\n module V1 (M : S) : Stringable.S with type t := M.t = struct\n let of_string x = Sexplib.Conv.of_string__of__of_sexp M.t_of_sexp x\n let to_string x = Sexplib.Conv.string_of__of__sexp_of M.sexp_of_t x\n end\n end\nend\n\nmodule To_stringable = Stable.To_stringable.V1\n","open! Import\nopen Bin_prot.Binable\nopen Bigarray\n\nmodule type Conv_without_uuid = sig\n type binable\n type t\n\n val to_binable : t -> binable\n val of_binable : binable -> t\nend\n\nmodule type Conv1_without_uuid = sig\n type 'a binable\n type 'a t\n\n val to_binable : 'a t -> 'a binable\n val of_binable : 'a binable -> 'a t\nend\n\nmodule type Conv2_without_uuid = sig\n type ('a, 'b) binable\n type ('a, 'b) t\n\n val to_binable : ('a, 'b) t -> ('a, 'b) binable\n val of_binable : ('a, 'b) binable -> ('a, 'b) t\nend\n\nmodule type Conv3_without_uuid = sig\n type ('a, 'b, 'c) binable\n type ('a, 'b, 'c) t\n\n val to_binable : ('a, 'b, 'c) t -> ('a, 'b, 'c) binable\n val of_binable : ('a, 'b, 'c) binable -> ('a, 'b, 'c) t\nend\n\nmodule type Conv = sig\n include Conv_without_uuid\n\n val caller_identity : Bin_prot.Shape.Uuid.t\nend\n\nmodule type Conv1 = sig\n include Conv1_without_uuid\n\n val caller_identity : Bin_prot.Shape.Uuid.t\nend\n\nmodule type Conv2 = sig\n include Conv2_without_uuid\n\n val caller_identity : Bin_prot.Shape.Uuid.t\nend\n\nmodule type Conv3 = sig\n include Conv3_without_uuid\n\n val caller_identity : Bin_prot.Shape.Uuid.t\nend\n\nmodule type Conv_sexpable = sig\n include Sexpable.S\n\n val caller_identity : Bin_prot.Shape.Uuid.t\nend\n\nmodule type Conv_stringable = sig\n include Stringable.S\n\n val caller_identity : Bin_prot.Shape.Uuid.t\nend\n\n(** Module types and utilities for dealing with types that support the bin-io binary\n encoding. *)\nmodule type Binable = sig\n (** We copy the definition of the bigstring type here, because we cannot depend on\n bigstring.ml *)\n type bigstring = (char, int8_unsigned_elt, c_layout) Array1.t\n\n (** New code should use [@@deriving bin_io]. These module types ([S], [S1], and [S2])\n are exported only for backwards compatibility. *)\n module type S = S\n\n module type S_only_functions = S_only_functions\n module type S1 = S1\n module type S2 = S2\n module type S3 = S3\n\n module Minimal : sig\n module type S = Minimal.S\n module type S1 = Minimal.S1\n module type S2 = Minimal.S2\n module type S3 = Minimal.S3\n end\n\n module type Conv = Conv\n module type Conv1 = Conv1\n module type Conv2 = Conv2\n module type Conv3 = Conv3\n module type Conv_sexpable = Conv_sexpable\n module type Conv_stringable = Conv_stringable\n module type Conv_without_uuid = Conv_without_uuid\n module type Conv1_without_uuid = Conv1_without_uuid\n module type Conv2_without_uuid = Conv2_without_uuid\n module type Conv3_without_uuid = Conv3_without_uuid\n\n (** [Of_binable*] functors are for when you want the binary representation of one type\n to be the same as that for some other isomorphic type. *)\n\n module Of_binable_with_uuid\n (Binable : Minimal.S)\n (M : Conv with type binable := Binable.t) : S with type t := M.t\n\n module Of_binable1_with_uuid\n (Binable : Minimal.S1)\n (M : Conv1 with type 'a binable := 'a Binable.t) : S1 with type 'a t := 'a M.t\n\n module Of_binable2_with_uuid\n (Binable : Minimal.S2)\n (M : Conv2 with type ('a, 'b) binable := ('a, 'b) Binable.t) :\n S2 with type ('a, 'b) t := ('a, 'b) M.t\n\n module Of_binable3_with_uuid\n (Binable : Minimal.S3)\n (M : Conv3 with type ('a, 'b, 'c) binable := ('a, 'b, 'c) Binable.t) :\n S3 with type ('a, 'b, 'c) t := ('a, 'b, 'c) M.t\n\n module Of_binable_without_uuid\n (Binable : Minimal.S)\n (M : Conv_without_uuid with type binable := Binable.t) : S with type t := M.t\n [@@alert legacy \"Use [Of_binable_with_uuid] if possible.\"]\n\n module Of_binable1_without_uuid\n (Binable : Minimal.S1)\n (M : Conv1_without_uuid with type 'a binable := 'a Binable.t) :\n S1 with type 'a t := 'a M.t\n [@@alert legacy \"Use [Of_binable1_with_uuid] if possible.\"]\n\n module Of_binable2_without_uuid\n (Binable : Minimal.S2)\n (M : Conv2_without_uuid with type ('a, 'b) binable := ('a, 'b) Binable.t) :\n S2 with type ('a, 'b) t := ('a, 'b) M.t\n [@@alert legacy \"Use [Of_binable2_with_uuid] if possible.\"]\n\n module Of_binable3_without_uuid\n (Binable : Minimal.S3)\n (M : Conv3_without_uuid with type ('a, 'b, 'c) binable := ('a, 'b, 'c) Binable.t) :\n S3 with type ('a, 'b, 'c) t := ('a, 'b, 'c) M.t\n [@@alert legacy \"Use [Of_binable3_with_uuid] if possible.\"]\n\n module Of_binable = Of_binable_without_uuid\n [@@alert \"-legacy\"]\n [@@deprecated\n \"[since 2019-11] Use [Of_binable_with_uuid] if possible, otherwise use \\\n [Of_binable_without_uuid].\"]\n\n module Of_binable1 = Of_binable1_without_uuid\n [@@alert \"-legacy\"]\n [@@deprecated\n \"[since 2019-11] Use [Of_binable1_with_uuid] if possible, otherwise use \\\n [Of_binable1_without_uuid].\"]\n\n module Of_binable2 = Of_binable2_without_uuid\n [@@alert \"-legacy\"]\n [@@deprecated\n \"[since 2019-11] Use [Of_binable2_with_uuid] if possible, otherwise use \\\n [Of_binable2_without_uuid].\"]\n\n module Of_binable3 = Of_binable3_without_uuid\n [@@alert \"-legacy\"]\n [@@deprecated\n \"[since 2019-11] Use [Of_binable3_with_uuid] if possible, otherwise use \\\n [Of_binable3_without_uuid].\"]\n\n (** [Of_sexpable_with_uuid] serializes a value using the bin-io of the sexp\n serialization of the value. This is not as efficient as using [@@deriving bin_io].\n However, it is useful when performance isn't important and there are obstacles to\n using [@@deriving bin_io], e.g., some type missing [@@deriving bin_io].\n [Of_sexpable_with_uuid] is also useful when one wants to be forgiving about format\n changes, due to the sexp serialization being more robust to changes like adding or\n removing a constructor. *)\n\n module Of_sexpable_with_uuid (M : Conv_sexpable) : S with type t := M.t\n module Of_stringable_with_uuid (M : Conv_stringable) : S with type t := M.t\n\n module Of_sexpable_without_uuid (M : Sexpable.S) : S with type t := M.t\n [@@alert legacy \"Use [Of_sexpable_with_uuid] if possible.\"]\n\n module Of_stringable_without_uuid (M : Stringable.S) : S with type t := M.t\n [@@alert legacy \"Use [Of_stringable_with_uuid] if possible.\"]\n\n module Of_sexpable = Of_sexpable_without_uuid\n [@@alert \"-legacy\"]\n [@@deprecated\n \"[since 2019-11] Use [Of_sexpable_with_uuid] if possible, otherwise use \\\n [Of_sexpable_without_uuid].\"]\n\n module Of_stringable = Of_stringable_without_uuid\n [@@alert \"-legacy\"]\n [@@deprecated\n \"[since 2019-11] Use [Of_stringable_with_uuid] if possible, otherwise use \\\n [Of_stringable_without_uuid].\"]\n\n type 'a m = (module S with type t = 'a)\n\n val of_bigstring : 'a m -> bigstring -> 'a\n\n val to_bigstring\n : ?prefix_with_length:bool (** defaults to false *)\n -> 'a m\n -> 'a\n -> bigstring\n\n val of_string : 'a m -> string -> 'a\n val to_string : 'a m -> 'a -> string\n\n (** The following functors preserve stability: if applied to stable types with stable\n (de)serializations, they will produce stable types with stable (de)serializations.\n\n Note: In all cases, stability of the input (and therefore the output) depends on the\n semantics of all conversion functions (e.g. [to_string], [to_sexpable]) not changing\n in the future.\n *)\n\n module Stable : sig\n module Of_binable : sig\n module V1 : (module type of Of_binable_without_uuid) [@alert \"-legacy\"]\n [@@alert legacy \"Use [V2] instead.\"]\n\n module V2 : module type of Of_binable_with_uuid\n end\n\n module Of_binable1 : sig\n module V1 : (module type of Of_binable1_without_uuid) [@alert \"-legacy\"]\n [@@alert legacy \"Use [V2] instead.\"]\n\n module V2 : module type of Of_binable1_with_uuid\n end\n\n module Of_binable2 : sig\n module V1 : (module type of Of_binable2_without_uuid) [@alert \"-legacy\"]\n [@@alert legacy \"Use [V2] instead.\"]\n\n module V2 : module type of Of_binable2_with_uuid\n end\n\n module Of_binable3 : sig\n module V1 : (module type of Of_binable3_without_uuid) [@alert \"-legacy\"]\n [@@alert legacy \"Use [V2] instead.\"]\n\n module V2 : module type of Of_binable3_with_uuid\n end\n\n module Of_sexpable : sig\n module V1 : (module type of Of_sexpable_without_uuid) [@alert \"-legacy\"]\n [@@alert legacy \"Use [V2] instead.\"]\n\n module V2 : module type of Of_sexpable_with_uuid\n end\n\n module Of_stringable : sig\n module V1 : (module type of Of_stringable_without_uuid) [@alert \"-legacy\"]\n [@@alert legacy \"Use [V2] instead.\"]\n\n module V2 : module type of Of_stringable_with_uuid\n end\n end\nend\n","open! Import\nopen Binable_intf\ninclude Bin_prot.Binable\nmodule Shape = Bin_prot.Shape\nmodule List = Base.List\n\nmodule Stable = struct\n module Of_binable = struct\n module V1\n (Binable : Minimal.S)\n (M : Conv_without_uuid with type binable := Binable.t) : S with type t := M.t =\n Bin_prot.Utils.Make_binable_without_uuid (struct\n module Binable = Binable\n include M\n end)\n [@@alert \"-legacy\"]\n\n module V2 (Binable : Minimal.S) (M : Conv with type binable := Binable.t) :\n S with type t := M.t = Bin_prot.Utils.Make_binable_with_uuid (struct\n module Binable = Binable\n include M\n end)\n end\n\n module Of_binable1 = struct\n module V1\n (Binable : Minimal.S1)\n (M : Conv1_without_uuid with type 'a binable := 'a Binable.t) :\n S1 with type 'a t := 'a M.t = Bin_prot.Utils.Make_binable1_without_uuid (struct\n module Binable = Binable\n include M\n end)\n [@@alert \"-legacy\"]\n\n module V2 (Binable : Minimal.S1) (M : Conv1 with type 'a binable := 'a Binable.t) :\n S1 with type 'a t := 'a M.t = Bin_prot.Utils.Make_binable1_with_uuid (struct\n module Binable = Binable\n include M\n end)\n end\n\n module Of_binable2 = struct\n module V1\n (Binable : Minimal.S2)\n (M : Conv2_without_uuid with type ('a, 'b) binable := ('a, 'b) Binable.t) :\n S2 with type ('a, 'b) t := ('a, 'b) M.t =\n Bin_prot.Utils.Make_binable2_without_uuid (struct\n module Binable = Binable\n include M\n end)\n [@@alert \"-legacy\"]\n\n module V2\n (Binable : Minimal.S2)\n (M : Conv2 with type ('a, 'b) binable := ('a, 'b) Binable.t) :\n S2 with type ('a, 'b) t := ('a, 'b) M.t =\n Bin_prot.Utils.Make_binable2_with_uuid (struct\n module Binable = Binable\n include M\n end)\n end\n\n module Of_binable3 = struct\n module V1\n (Binable : Minimal.S3)\n (M : Conv3_without_uuid with type ('a, 'b, 'c) binable := ('a, 'b, 'c) Binable.t) :\n S3 with type ('a, 'b, 'c) t := ('a, 'b, 'c) M.t =\n Bin_prot.Utils.Make_binable3_without_uuid (struct\n module Binable = Binable\n include M\n end)\n [@@alert \"-legacy\"]\n\n module V2\n (Binable : Minimal.S3)\n (M : Conv3 with type ('a, 'b, 'c) binable := ('a, 'b, 'c) Binable.t) :\n S3 with type ('a, 'b, 'c) t := ('a, 'b, 'c) M.t =\n Bin_prot.Utils.Make_binable3_with_uuid (struct\n module Binable = Binable\n include M\n end)\n end\n\n module Of_sexpable = struct\n module V1 (M : Sexpable.S) =\n Of_binable.V1\n (struct\n type t = Base.Sexp.t =\n | Atom of string\n | List of t list\n [@@deriving bin_io]\n end)\n (struct\n type t = M.t\n\n let to_binable = M.sexp_of_t\n let of_binable = M.t_of_sexp\n end)\n\n module V2 (M : Conv_sexpable) =\n Of_binable.V2\n (struct\n type t = Base.Sexp.t =\n | Atom of string\n | List of t list\n [@@deriving bin_io]\n end)\n (struct\n type t = M.t\n\n let to_binable = M.sexp_of_t\n let of_binable = M.t_of_sexp\n let caller_identity = M.caller_identity\n end)\n end\n\n module Of_stringable = struct\n module V1 (M : Stringable.S) = Bin_prot.Utils.Make_binable_without_uuid (struct\n module Binable = struct\n type t = string [@@deriving bin_io]\n end\n\n type t = M.t\n\n let to_binable = M.to_string\n\n (* Wrap exception for improved diagnostics. *)\n exception Of_binable of string * exn [@@deriving sexp]\n\n let of_binable s =\n try M.of_string s with\n | x -> raise (Of_binable (s, x))\n ;;\n end)\n [@@alert \"-legacy\"]\n\n module V2 (M : Conv_stringable) = Bin_prot.Utils.Make_binable_with_uuid (struct\n module Binable = struct\n type t = string [@@deriving bin_io]\n end\n\n type t = M.t\n\n let to_binable = M.to_string\n\n (* Wrap exception for improved diagnostics. *)\n exception Of_binable of string * exn [@@deriving sexp]\n\n let of_binable s =\n try M.of_string s with\n | x -> raise (Of_binable (s, x))\n ;;\n\n let caller_identity = M.caller_identity\n end)\n end\nend\n\nopen Bigarray\n\ntype bigstring = (char, int8_unsigned_elt, c_layout) Array1.t\n\n\ntype 'a m = (module S with type t = 'a)\n\nlet of_bigstring (type a) m bigstring =\n let module M = (val m : S with type t = a) in\n let pos_ref = ref 0 in\n let t = M.bin_read_t bigstring ~pos_ref in\n assert (!pos_ref = Array1.dim bigstring);\n t\n;;\n\n(* Using the [Bigstring] module would introduce a cyclic dependency. *)\nlet create_bigstring size = Array1.create Bigarray.char Bigarray.c_layout size\n\nlet to_bigstring ?(prefix_with_length = false) (type a) m t =\n let module M = (val m : S with type t = a) in\n let t_length = M.bin_size_t t in\n let bigstring_length =\n if prefix_with_length then t_length + 8 (* the size of a 64-bit int *) else t_length\n in\n let bigstring = create_bigstring bigstring_length in\n let pos =\n if prefix_with_length\n then Bin_prot.Write.bin_write_int_64bit bigstring ~pos:0 t_length\n else 0\n in\n let pos = M.bin_write_t bigstring ~pos t in\n assert (pos = bigstring_length);\n bigstring\n;;\n\nmodule Of_binable_with_uuid = Stable.Of_binable.V2\nmodule Of_binable1_with_uuid = Stable.Of_binable1.V2\nmodule Of_binable2_with_uuid = Stable.Of_binable2.V2\nmodule Of_binable3_with_uuid = Stable.Of_binable3.V2\nmodule Of_sexpable_with_uuid = Stable.Of_sexpable.V2\nmodule Of_stringable_with_uuid = Stable.Of_stringable.V2\n\nmodule Of_binable_without_uuid = Stable.Of_binable.V1\n[@@alert legacy \"Use [Of_binable_with_uuid] if possible.\"]\n\nmodule Of_binable1_without_uuid = Stable.Of_binable1.V1\n[@@alert legacy \"Use [Of_binable1_with_uuid] if possible.\"]\n\nmodule Of_binable2_without_uuid = Stable.Of_binable2.V1\n[@@alert legacy \"Use [Of_binable2_with_uuid] if possible.\"]\n\nmodule Of_binable3_without_uuid = Stable.Of_binable3.V1\n[@@alert legacy \"Use [Of_binable3_with_uuid] if possible.\"]\n\nmodule Of_sexpable_without_uuid = Stable.Of_sexpable.V1\n[@@alert legacy \"Use [Of_sexpable_with_uuid] if possible.\"]\n\nmodule Of_stringable_without_uuid = Stable.Of_stringable.V1\n[@@alert legacy \"Use [Of_stringable_with_uuid] if possible.\"]\n\nmodule type S_only_functions_and_shape = sig\n include S_only_functions\n\n val bin_shape_t : Shape.t\nend\n\n(* check that only the functions & shape are sufficient for [@@deriving bin_io] *)\nmodule Of_only_functions_and_shape (X : S_only_functions_and_shape) : S = struct\n type t = X.t [@@deriving bin_io]\nend\n","(** This module extends {{!Base.Printf}[Base.Printf]}. *)\n\nopen! Import\n\ninclude Base.Printf (** @open *)\n\nlet eprintf = Stdio.Out_channel.eprintf\nlet fprintf = Stdio.Out_channel.fprintf\nlet kfprintf = Stdio.Out_channel.kfprintf\nlet printf = Stdio.Out_channel.printf\n\n\n(** print to stderr; exit 1 *)\nlet exitf fmt =\n ksprintf\n (fun s () ->\n eprintf \"%s\\n%!\" s;\n exit 1)\n fmt\n;;\n","open! Import\nmodule Comparator = Base.Comparator\n\ntype ('a, 'witness) t = ('a, 'witness) Comparator.t = private\n { compare : 'a -> 'a -> int\n ; sexp_of_t : 'a -> Base.Sexp.t\n }\n\nmodule type Base_mask = module type of Comparator with type ('a, 'b) t := ('a, 'b) t\n\ninclude (Comparator : Base_mask)\n\nmodule Stable = struct\n module V1 = struct\n type nonrec ('a, 'witness) t = ('a, 'witness) t = private\n { compare : 'a -> 'a -> int\n ; sexp_of_t : 'a -> Base.Sexp.t\n }\n\n type ('a, 'b) comparator = ('a, 'b) t\n\n module type S = S\n module type S1 = S1\n\n let make = make\n\n module Make = Make\n module Make1 = Make1\n end\nend\n","open! Import\nmodule Result = Base.Result\n\nmodule Stable = struct\n module V1 = struct\n type ('a, 'b) t = ('a, 'b) Result.t =\n | Ok of 'a\n | Error of 'b\n [@@deriving bin_io, compare, hash, sexp]\n\n let map x ~f1 ~f2 =\n match x with\n | Error err -> Error (f2 err)\n | Ok x -> Ok (f1 x)\n ;;\n end\n\n module V1_stable_unit_test = struct\n type t = (string, int) V1.t [@@deriving bin_io, compare, hash, sexp]\n\n let equal = [%compare.equal: t]\n\n let tests =\n [ V1.Ok \"foo\", \"(Ok foo)\", \"\\000\\003foo\"; V1.Error 7, \"(Error 7)\", \"\\001\\007\" ]\n ;;\n end\nend\n\ninclude Stable.V1\ninclude Result\n","include Base.Container\n\nmodule type S1_permissions = Container_intf.S1_permissions\n","let ( |! ) x y = x |> y\n","(** Extends {{!Base.Fn}[Base.Fn]}. *)\n\ninclude Base.Fn (** @open *)\n\ninclude Deprecate_pipe_bang\n","include Base.Ordered_collection_common\n\nlet normalize ~length_fun t i = if i < 0 then i + length_fun t else i\n\nlet slice ~length_fun ~sub_fun t start stop =\n let stop = if stop = 0 then length_fun t else stop in\n let pos = normalize ~length_fun t start in\n let len = normalize ~length_fun t stop - pos in\n sub_fun t ~pos ~len\n;;\n","open! Import\ninclude Base.Sequence\n\ninclude Bin_prot.Utils.Make_binable1_without_uuid [@alert \"-legacy\"] (struct\n module Binable = struct\n type 'a t = 'a list [@@deriving bin_io]\n end\n\n type 'a t = 'a Base.Sequence.t\n\n let of_binable = Base.Sequence.of_list\n let to_binable = Base.Sequence.to_list\n end)\n\nmodule Step = struct\n include Step\n\n type ('a, 's) t = ('a, 's) Step.t =\n | Done\n | Skip of 's\n | Yield of 'a * 's\n [@@deriving bin_io]\nend\n\nmodule Merge_with_duplicates_element = struct\n include Merge_with_duplicates_element\n\n type ('a, 'b) t = ('a, 'b) Merge_with_duplicates_element.t =\n | Left of 'a\n | Right of 'b\n | Both of 'a * 'b\n [@@deriving bin_io]\nend\n\nmodule type Heap = sig\n type 'a t\n\n val create : compare:('a -> 'a -> int) -> 'a t\n val add : 'a t -> 'a -> 'a t\n val remove_min : 'a t -> ('a * 'a t) option\nend\n\nlet merge_all (module Heap : Heap) seqs ~compare =\n let module Merge_all_state = struct\n type 'a t =\n { heap : ('a * 'a Base.Sequence.t) Heap.t\n ; not_yet_in_heap : 'a Base.Sequence.t list\n }\n [@@deriving fields]\n\n let create = Fields.create\n end\n in\n unfold_step\n ~init:\n (Merge_all_state.create\n ~heap:(Heap.create ~compare:(Base.Comparable.lift compare ~f:fst))\n ~not_yet_in_heap:seqs)\n ~f:(fun { heap; not_yet_in_heap } ->\n match not_yet_in_heap with\n | seq :: not_yet_in_heap ->\n (match Expert.next_step seq with\n | Done -> Skip { not_yet_in_heap; heap }\n | Skip seq -> Skip { not_yet_in_heap = seq :: not_yet_in_heap; heap }\n | Yield (elt, seq) -> Skip { not_yet_in_heap; heap = Heap.add heap (elt, seq) })\n | [] ->\n (match Heap.remove_min heap with\n | None -> Done\n | Some ((elt, seq), heap) -> Yield (elt, { heap; not_yet_in_heap = [ seq ] })))\n;;\n","open! Import\nopen Perms.Export\nmodule Array = Base.Array\nmodule Core_sequence = Sequence\n\ninclude (\n Base.Array :\n sig\n type 'a t = 'a array [@@deriving sexp, compare, sexp_grammar]\n end)\n\ntype 'a t = 'a array [@@deriving bin_io, typerep]\n\nmodule Private = Base.Array.Private\n\nmodule T = struct\n include Base.Array\n\n let normalize t i = Ordered_collection_common.normalize ~length_fun:length t i\n\n let slice t start stop =\n Ordered_collection_common.slice ~length_fun:length ~sub_fun:sub t start stop\n ;;\n\n let nget t i = t.(normalize t i)\n let nset t i v = t.(normalize t i) <- v\n\n module Sequence = struct\n open Base.Array\n\n let length = length\n let get = get\n let set = set\n end\n\n (* See OCaml perf notes for why these array blits are special cased -- in particular,\n the section entitled \"Fast, Slow and Incorrect Array blits\" of\n https://janestreet.github.io/ocaml-perf-notes.html *)\n module Int = struct\n type t_ = int array [@@deriving bin_io, compare, sexp]\n\n module Unsafe_blit = struct\n external unsafe_blit\n : src:t_\n -> src_pos:int\n -> dst:t_\n -> dst_pos:int\n -> len:int\n -> unit\n = \"core_array_unsafe_int_blit\"\n [@@noalloc]\n end\n\n include Test_blit.Make_and_test\n (struct\n type t = int\n\n let equal = ( = )\n let of_bool b = if b then 1 else 0\n end)\n (struct\n type t = t_ [@@deriving sexp_of]\n\n include Sequence\n\n let create ~len = create ~len 0\n\n include Unsafe_blit\n end)\n\n include Unsafe_blit\n end\n\n module Float = struct\n type t_ = float array [@@deriving bin_io, compare, sexp]\n\n module Unsafe_blit = struct\n external unsafe_blit\n : src:t_\n -> src_pos:int\n -> dst:t_\n -> dst_pos:int\n -> len:int\n -> unit\n = \"core_array_unsafe_float_blit\"\n [@@noalloc]\n end\n\n include Test_blit.Make_and_test\n (struct\n type t = float\n\n let equal = Base.Float.equal\n let of_bool b = if b then 1. else 0.\n end)\n (struct\n type t = t_ [@@deriving sexp_of]\n\n include Sequence\n\n let create ~len = create ~len 0.\n\n include Unsafe_blit\n end)\n\n include Unsafe_blit\n end\nend\n\nmodule type Permissioned = sig\n type ('a, -'perms) t\n\n include Container.S1_permissions with type ('a, 'perms) t := ('a, 'perms) t\n include Blit.S1_permissions with type ('a, 'perms) t := ('a, 'perms) t\n include Binary_searchable.S1_permissions with type ('a, 'perms) t := ('a, 'perms) t\n\n val length : (_, _) t -> int\n val is_empty : (_, _) t -> bool\n external get : ('a, [> read ]) t -> int -> 'a = \"%array_safe_get\"\n external set : ('a, [> write ]) t -> int -> 'a -> unit = \"%array_safe_set\"\n external unsafe_get : ('a, [> read ]) t -> int -> 'a = \"%array_unsafe_get\"\n external unsafe_set : ('a, [> write ]) t -> int -> 'a -> unit = \"%array_unsafe_set\"\n val create : len:int -> 'a -> ('a, [< _ perms ]) t\n val init : int -> f:(int -> 'a) -> ('a, [< _ perms ]) t\n val make_matrix : dimx:int -> dimy:int -> 'a -> (('a, [< _ perms ]) t, [< _ perms ]) t\n val append : ('a, [> read ]) t -> ('a, [> read ]) t -> ('a, [< _ perms ]) t\n val concat : ('a, [> read ]) t list -> ('a, [< _ perms ]) t\n val copy : ('a, [> read ]) t -> ('a, [< _ perms ]) t\n val fill : ('a, [> write ]) t -> pos:int -> len:int -> 'a -> unit\n val of_list : 'a list -> ('a, [< _ perms ]) t\n val map : ('a, [> read ]) t -> f:('a -> 'b) -> ('b, [< _ perms ]) t\n\n val folding_map\n : ('a, [> read ]) t\n -> init:'b\n -> f:('b -> 'a -> 'b * 'c)\n -> ('c, [< _ perms ]) t\n\n val fold_map\n : ('a, [> read ]) t\n -> init:'b\n -> f:('b -> 'a -> 'b * 'c)\n -> 'b * ('c, [< _ perms ]) t\n\n val mapi : ('a, [> read ]) t -> f:(int -> 'a -> 'b) -> ('b, [< _ perms ]) t\n val iteri : ('a, [> read ]) t -> f:(int -> 'a -> unit) -> unit\n val foldi : ('a, [> read ]) t -> init:'b -> f:(int -> 'b -> 'a -> 'b) -> 'b\n\n val folding_mapi\n : ('a, [> read ]) t\n -> init:'b\n -> f:(int -> 'b -> 'a -> 'b * 'c)\n -> ('c, [< _ perms ]) t\n\n val fold_mapi\n : ('a, [> read ]) t\n -> init:'b\n -> f:(int -> 'b -> 'a -> 'b * 'c)\n -> 'b * ('c, [< _ perms ]) t\n\n val fold_right : ('a, [> read ]) t -> f:('a -> 'b -> 'b) -> init:'b -> 'b\n\n val sort\n : ?pos:int\n -> ?len:int\n -> ('a, [> read_write ]) t\n -> compare:('a -> 'a -> int)\n -> unit\n\n val stable_sort : ('a, [> read_write ]) t -> compare:('a -> 'a -> int) -> unit\n val is_sorted : ('a, [> read ]) t -> compare:('a -> 'a -> int) -> bool\n val is_sorted_strictly : ('a, [> read ]) t -> compare:('a -> 'a -> int) -> bool\n\n val concat_map\n : ('a, [> read ]) t\n -> f:('a -> ('b, [> read ]) t)\n -> ('b, [< _ perms ]) t\n\n val concat_mapi\n : ('a, [> read ]) t\n -> f:(int -> 'a -> ('b, [> read ]) t)\n -> ('b, [< _ perms ]) t\n\n val partition_tf\n : ('a, [> read ]) t\n -> f:('a -> bool)\n -> ('a, [< _ perms ]) t * ('a, [< _ perms ]) t\n\n val partitioni_tf\n : ('a, [> read ]) t\n -> f:(int -> 'a -> bool)\n -> ('a, [< _ perms ]) t * ('a, [< _ perms ]) t\n\n val cartesian_product\n : ('a, [> read ]) t\n -> ('b, [> read ]) t\n -> ('a * 'b, [< _ perms ]) t\n\n val transpose\n : (('a, [> read ]) t, [> read ]) t\n -> (('a, [< _ perms ]) t, [< _ perms ]) t option\n\n val transpose_exn\n : (('a, [> read ]) t, [> read ]) t\n -> (('a, [< _ perms ]) t, [< _ perms ]) t\n\n val normalize : ('a, _) t -> int -> int\n val slice : ('a, [> read ]) t -> int -> int -> ('a, [< _ perms ]) t\n val nget : ('a, [> read ]) t -> int -> 'a\n val nset : ('a, [> write ]) t -> int -> 'a -> unit\n val filter_opt : ('a option, [> read ]) t -> ('a, [< _ perms ]) t\n val filter_map : ('a, [> read ]) t -> f:('a -> 'b option) -> ('b, [< _ perms ]) t\n\n val filter_mapi\n : ('a, [> read ]) t\n -> f:(int -> 'a -> 'b option)\n -> ('b, [< _ perms ]) t\n\n val for_alli : ('a, [> read ]) t -> f:(int -> 'a -> bool) -> bool\n val existsi : ('a, [> read ]) t -> f:(int -> 'a -> bool) -> bool\n val counti : ('a, [> read ]) t -> f:(int -> 'a -> bool) -> int\n val iter2_exn : ('a, [> read ]) t -> ('b, [> read ]) t -> f:('a -> 'b -> unit) -> unit\n\n val map2_exn\n : ('a, [> read ]) t\n -> ('b, [> read ]) t\n -> f:('a -> 'b -> 'c)\n -> ('c, [< _ perms ]) t\n\n val fold2_exn\n : ('a, [> read ]) t\n -> ('b, [> read ]) t\n -> init:'c\n -> f:('c -> 'a -> 'b -> 'c)\n -> 'c\n\n val for_all2_exn\n : ('a, [> read ]) t\n -> ('b, [> read ]) t\n -> f:('a -> 'b -> bool)\n -> bool\n\n val exists2_exn\n : ('a, [> read ]) t\n -> ('b, [> read ]) t\n -> f:('a -> 'b -> bool)\n -> bool\n\n val filter : ('a, [> read ]) t -> f:('a -> bool) -> ('a, [< _ perms ]) t\n val filteri : ('a, [> read ]) t -> f:(int -> 'a -> bool) -> ('a, [< _ perms ]) t\n val swap : ('a, [> read_write ]) t -> int -> int -> unit\n val rev_inplace : ('a, [> read_write ]) t -> unit\n val of_list_rev : 'a list -> ('a, [< _ perms ]) t\n val of_list_map : 'a list -> f:('a -> 'b) -> ('b, [< _ perms ]) t\n val of_list_mapi : 'a list -> f:(int -> 'a -> 'b) -> ('b, [< _ perms ]) t\n val of_list_rev_map : 'a list -> f:('a -> 'b) -> ('b, [< _ perms ]) t\n val of_list_rev_mapi : 'a list -> f:(int -> 'a -> 'b) -> ('b, [< _ perms ]) t\n val map_inplace : ('a, [> read_write ]) t -> f:('a -> 'a) -> unit\n val find_exn : ('a, [> read ]) t -> f:('a -> bool) -> 'a\n val find_map_exn : ('a, [> read ]) t -> f:('a -> 'b option) -> 'b\n val findi : ('a, [> read ]) t -> f:(int -> 'a -> bool) -> (int * 'a) option\n val findi_exn : ('a, [> read ]) t -> f:(int -> 'a -> bool) -> int * 'a\n val find_mapi : ('a, [> read ]) t -> f:(int -> 'a -> 'b option) -> 'b option\n val find_mapi_exn : ('a, [> read ]) t -> f:(int -> 'a -> 'b option) -> 'b\n\n val find_consecutive_duplicate\n : ('a, [> read ]) t\n -> equal:('a -> 'a -> bool)\n -> ('a * 'a) option\n\n val reduce : ('a, [> read ]) t -> f:('a -> 'a -> 'a) -> 'a option\n val reduce_exn : ('a, [> read ]) t -> f:('a -> 'a -> 'a) -> 'a\n val permute : ?random_state:Random.State.t -> ('a, [> read_write ]) t -> unit\n val random_element : ?random_state:Random.State.t -> ('a, [> read ]) t -> 'a option\n val random_element_exn : ?random_state:Random.State.t -> ('a, [> read ]) t -> 'a\n val zip : ('a, [> read ]) t -> ('b, [> read ]) t -> ('a * 'b, [< _ perms ]) t option\n val zip_exn : ('a, [> read ]) t -> ('b, [> read ]) t -> ('a * 'b, [< _ perms ]) t\n val unzip : ('a * 'b, [> read ]) t -> ('a, [< _ perms ]) t * ('b, [< _ perms ]) t\n\n val sorted_copy\n : ('a, [> read ]) t\n -> compare:('a -> 'a -> int)\n -> ('a, [< _ perms ]) t\n\n val last : ('a, [> read ]) t -> 'a\n val equal : ('a -> 'a -> bool) -> ('a, [> read ]) t -> ('a, [> read ]) t -> bool\n val to_sequence : ('a, [> read ]) t -> 'a Sequence.t\n val to_sequence_mutable : ('a, [> read ]) t -> 'a Sequence.t\nend\n\nmodule Permissioned : sig\n type ('a, -'perms) t [@@deriving bin_io, compare, sexp]\n\n module Int : sig\n type nonrec -'perms t = (int, 'perms) t [@@deriving bin_io, compare, sexp]\n\n include Blit.S_permissions with type 'perms t := 'perms t\n\n external unsafe_blit\n : src:[> read ] t\n -> src_pos:int\n -> dst:[> write ] t\n -> dst_pos:int\n -> len:int\n -> unit\n = \"core_array_unsafe_int_blit\"\n [@@noalloc]\n end\n\n module Float : sig\n type nonrec -'perms t = (float, 'perms) t [@@deriving bin_io, compare, sexp]\n\n include Blit.S_permissions with type 'perms t := 'perms t\n\n external unsafe_blit\n : src:[> read ] t\n -> src_pos:int\n -> dst:[> write ] t\n -> dst_pos:int\n -> len:int\n -> unit\n = \"core_array_unsafe_float_blit\"\n [@@noalloc]\n end\n\n val of_array_id : 'a array -> ('a, [< read_write ]) t\n val to_array_id : ('a, [> read_write ]) t -> 'a array\n val to_sequence_immutable : ('a, [> immutable ]) t -> 'a Sequence.t\n\n include Permissioned with type ('a, 'perms) t := ('a, 'perms) t\nend = struct\n type ('a, -'perms) t = 'a array [@@deriving bin_io, compare, sexp, typerep]\n\n module Int = struct\n include T.Int\n\n type -'perms t = t_ [@@deriving bin_io, compare, sexp]\n end\n\n module Float = struct\n include T.Float\n\n type -'perms t = t_ [@@deriving bin_io, compare, sexp]\n end\n\n let to_array_id = Fn.id\n let of_array_id = Fn.id\n\n include (T : Permissioned with type ('a, 'b) t := ('a, 'b) t) [@ocaml.warning \"-3\"]\n\n let to_array = copy\n let to_sequence_immutable = to_sequence_mutable\nend\n\nmodule type S = sig\n type 'a t\n\n include Binary_searchable.S1 with type 'a t := 'a t\n include Container.S1 with type 'a t := 'a t\n\n external get : 'a t -> int -> 'a = \"%array_safe_get\"\n external set : 'a t -> int -> 'a -> unit = \"%array_safe_set\"\n external unsafe_get : 'a t -> int -> 'a = \"%array_unsafe_get\"\n external unsafe_set : 'a t -> int -> 'a -> unit = \"%array_unsafe_set\"\n val create : len:int -> 'a -> 'a t\n val init : int -> f:(int -> 'a) -> 'a t\n val make_matrix : dimx:int -> dimy:int -> 'a -> 'a t t\n val append : 'a t -> 'a t -> 'a t\n val concat : 'a t list -> 'a t\n val copy : 'a t -> 'a t\n val fill : 'a t -> pos:int -> len:int -> 'a -> unit\n\n include Blit.S1 with type 'a t := 'a t\n\n val of_list : 'a list -> 'a t\n val map : 'a t -> f:('a -> 'b) -> 'b t\n val folding_map : 'a t -> init:'b -> f:('b -> 'a -> 'b * 'c) -> 'c t\n val fold_map : 'a t -> init:'b -> f:('b -> 'a -> 'b * 'c) -> 'b * 'c t\n val mapi : 'a t -> f:(int -> 'a -> 'b) -> 'b t\n val iteri : 'a t -> f:(int -> 'a -> unit) -> unit\n val foldi : 'a t -> init:'b -> f:(int -> 'b -> 'a -> 'b) -> 'b\n val folding_mapi : 'a t -> init:'b -> f:(int -> 'b -> 'a -> 'b * 'c) -> 'c t\n val fold_mapi : 'a t -> init:'b -> f:(int -> 'b -> 'a -> 'b * 'c) -> 'b * 'c t\n val fold_right : 'a t -> f:('a -> 'b -> 'b) -> init:'b -> 'b\n val sort : ?pos:int -> ?len:int -> 'a t -> compare:('a -> 'a -> int) -> unit\n val stable_sort : 'a t -> compare:('a -> 'a -> int) -> unit\n val is_sorted : 'a t -> compare:('a -> 'a -> int) -> bool\n val is_sorted_strictly : 'a t -> compare:('a -> 'a -> int) -> bool\n val concat_map : 'a t -> f:('a -> 'b t) -> 'b t\n val concat_mapi : 'a t -> f:(int -> 'a -> 'b t) -> 'b t\n val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t\n val partitioni_tf : 'a t -> f:(int -> 'a -> bool) -> 'a t * 'a t\n val cartesian_product : 'a t -> 'b t -> ('a * 'b) t\n val transpose : 'a t t -> 'a t t option\n val transpose_exn : 'a t t -> 'a t t\n val normalize : 'a t -> int -> int\n val slice : 'a t -> int -> int -> 'a t\n val nget : 'a t -> int -> 'a\n val nset : 'a t -> int -> 'a -> unit\n val filter_opt : 'a option t -> 'a t\n val filter_map : 'a t -> f:('a -> 'b option) -> 'b t\n val filter_mapi : 'a t -> f:(int -> 'a -> 'b option) -> 'b t\n val for_alli : 'a t -> f:(int -> 'a -> bool) -> bool\n val existsi : 'a t -> f:(int -> 'a -> bool) -> bool\n val counti : 'a t -> f:(int -> 'a -> bool) -> int\n val iter2_exn : 'a t -> 'b t -> f:('a -> 'b -> unit) -> unit\n val map2_exn : 'a t -> 'b t -> f:('a -> 'b -> 'c) -> 'c t\n val fold2_exn : 'a t -> 'b t -> init:'c -> f:('c -> 'a -> 'b -> 'c) -> 'c\n val for_all2_exn : 'a t -> 'b t -> f:('a -> 'b -> bool) -> bool\n val exists2_exn : 'a t -> 'b t -> f:('a -> 'b -> bool) -> bool\n val filter : 'a t -> f:('a -> bool) -> 'a t\n val filteri : 'a t -> f:(int -> 'a -> bool) -> 'a t\n val swap : 'a t -> int -> int -> unit\n val rev_inplace : 'a t -> unit\n val of_list_rev : 'a list -> 'a t\n val of_list_map : 'a list -> f:('a -> 'b) -> 'b t\n val of_list_mapi : 'a list -> f:(int -> 'a -> 'b) -> 'b t\n val of_list_rev_map : 'a list -> f:('a -> 'b) -> 'b t\n val of_list_rev_mapi : 'a list -> f:(int -> 'a -> 'b) -> 'b t\n val map_inplace : 'a t -> f:('a -> 'a) -> unit\n val find_exn : 'a t -> f:('a -> bool) -> 'a\n val find_map_exn : 'a t -> f:('a -> 'b option) -> 'b\n val findi : 'a t -> f:(int -> 'a -> bool) -> (int * 'a) option\n val findi_exn : 'a t -> f:(int -> 'a -> bool) -> int * 'a\n val find_mapi : 'a t -> f:(int -> 'a -> 'b option) -> 'b option\n val find_mapi_exn : 'a t -> f:(int -> 'a -> 'b option) -> 'b\n val find_consecutive_duplicate : 'a t -> equal:('a -> 'a -> bool) -> ('a * 'a) option\n val reduce : 'a t -> f:('a -> 'a -> 'a) -> 'a option\n val reduce_exn : 'a t -> f:('a -> 'a -> 'a) -> 'a\n val permute : ?random_state:Random.State.t -> 'a t -> unit\n val random_element : ?random_state:Random.State.t -> 'a t -> 'a option\n val random_element_exn : ?random_state:Random.State.t -> 'a t -> 'a\n val zip : 'a t -> 'b t -> ('a * 'b) t option\n val zip_exn : 'a t -> 'b t -> ('a * 'b) t\n val unzip : ('a * 'b) t -> 'a t * 'b t\n val sorted_copy : 'a t -> compare:('a -> 'a -> int) -> 'a t\n val last : 'a t -> 'a\n val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool\n val to_sequence : 'a t -> 'a Core_sequence.t\n val to_sequence_mutable : 'a t -> 'a Core_sequence.t\nend\n\ninclude (T : S with type 'a t := 'a array) [@ocaml.warning \"-3\"]\n\nlet invariant invariant_a t = iter t ~f:invariant_a\nlet max_length = Sys.max_array_length\n\nmodule Int = struct\n include T.Int\n\n type t = t_ [@@deriving bin_io, compare, sexp]\nend\n\nmodule Float = struct\n include T.Float\n\n type t = t_ [@@deriving bin_io, compare, sexp]\nend\n\nmodule Check1 (M : S) : sig\n type ('a, -'perm) t_\n\n include Permissioned with type ('a, 'perm) t := ('a, 'perm) t_\nend = struct\n include M\n\n type ('a, -'perm) t_ = 'a t\nend\n\nmodule Check2 (M : Permissioned) : sig\n type 'a t_\n\n include S with type 'a t := 'a t_\nend = struct\n include M\n\n type 'a t_ = ('a, read_write) t\nend\n","open! Import\n\nmodule Stable = struct\n module V1 = struct\n include Base.Source_code_position\n\n type t = Base.Source_code_position.t =\n { pos_fname : string\n ; pos_lnum : int\n ; pos_bol : int\n ; pos_cnum : int\n }\n [@@deriving bin_io, compare, hash, sexp]\n end\nend\n\ninclude Stable.V1\n\nlet to_string = Base.Source_code_position.to_string\nlet sexp_of_t = Base.Source_code_position.sexp_of_t\n","(* This module is trying to minimize dependencies on modules in Core, so as to allow\n [Info], [Error], and [Or_error] to be used in is many places places as possible.\n Please avoid adding new dependencies. *)\n\nopen! Import\nopen! Info_intf\n\nmodule type S = Base.Info.S\n\nmodule Source_code_position = Source_code_position0\nmodule Binable = Binable0\n\nmodule Sexp = struct\n include Sexplib.Sexp\n\n include (\n struct\n type t = Base.Sexp.t =\n | Atom of string\n | List of t list\n [@@deriving bin_io, compare, hash]\n end :\n sig\n type t [@@deriving bin_io, compare, hash]\n end\n with type t := t)\nend\n\nmodule Binable_exn = struct\n module Stable = struct\n module V1 = struct\n module T = struct\n type t = exn [@@deriving sexp_of]\n end\n\n include T\n\n include Binable.Stable.Of_binable.V1 [@alert \"-legacy\"]\n (Sexp)\n (struct\n include T\n\n let to_binable t = t |> [%sexp_of: t]\n let of_binable = Exn.create_s\n end)\n end\n end\nend\n\nmodule Extend (Info : Base.Info.S) = struct\n include Info\n\n module Internal_repr = struct\n module Stable = struct\n module Binable_exn = Binable_exn.Stable\n\n module Source_code_position = struct\n module V1 = struct\n type t = Source_code_position.Stable.V1.t [@@deriving bin_io]\n\n (* [sexp_of_t] as defined here is unstable; this is OK because there is no\n [t_of_sexp]. [sexp_of_t] is only used to produce a sexp that is never\n deserialized as a [Source_code_position]. *)\n let sexp_of_t = Source_code_position.sexp_of_t\n end\n end\n\n module V2 = struct\n type t = Info.Internal_repr.t =\n | Could_not_construct of Sexp.t\n | String of string\n | Exn of Binable_exn.V1.t\n | Sexp of Sexp.t\n | Tag_sexp of string * Sexp.t * Source_code_position.V1.t option\n | Tag_t of string * t\n | Tag_arg of string * Sexp.t * t\n | Of_list of int option * t list\n | With_backtrace of t * string (* backtrace *)\n [@@deriving bin_io, sexp_of]\n end\n end\n\n include Stable.V2\n\n let to_info = Info.Internal_repr.to_info\n let of_info = Info.Internal_repr.of_info\n end\n\n module Stable = struct\n module V2 = struct\n module T = struct\n type t = Info.t [@@deriving sexp, compare, hash]\n end\n\n include T\n include Comparator.Stable.V1.Make (T)\n\n include Binable.Stable.Of_binable.V1 [@alert \"-legacy\"]\n (Internal_repr.Stable.V2)\n (struct\n type nonrec t = t\n\n let to_binable = Info.Internal_repr.of_info\n let of_binable = Info.Internal_repr.to_info\n end)\n end\n\n module V1 = struct\n module T = struct\n type t = Info.t [@@deriving compare]\n\n include Sexpable.Stable.Of_sexpable.V1\n (Sexp)\n (struct\n type nonrec t = t\n\n let to_sexpable = Info.sexp_of_t\n let of_sexpable = Info.t_of_sexp\n end)\n\n let compare = compare\n end\n\n include T\n include Comparator.Stable.V1.Make (T)\n\n include Binable.Stable.Of_binable.V1 [@alert \"-legacy\"]\n (Sexp)\n (struct\n type nonrec t = t\n\n let to_binable = sexp_of_t\n let of_binable = t_of_sexp\n end)\n end\n end\n\n type t = Stable.V2.t [@@deriving bin_io]\nend\n\ninclude Extend (Base.Info)\n\n","include Base.Error\ninclude Info.Extend (Base.Error)\n\nlet failwiths ?strict ~here message a sexp_of_a =\n raise (create ?strict ~here message a sexp_of_a)\n;;\n\nlet failwithp ?strict here message a sexp_of_a =\n raise (create ?strict ~here message a sexp_of_a)\n;;\n","(** Derived from [Base.T]. Used for matching bare signatures with just a type. *)\n\nopen! Import\ninclude Base.T\n\nmodule type T_bin = sig\n type t [@@deriving bin_io]\nend\n","open! Import\nopen! Typerep_lib.Std\nmodule Array = Base.Array\ninclude Base.List\n\ntype 'a t = 'a list [@@deriving bin_io, typerep]\n\nmodule Assoc = struct\n include Assoc\n\n type ('a, 'b) t = ('a * 'b) list [@@deriving bin_io]\n\n let[@deprecated\n \"[since 2016-06] This does not respect the equivalence class promised by \\\n List.Assoc. Use List.compare directly if that's what you want.\"] compare\n (type a b)\n compare_a\n compare_b\n =\n [%compare: (a * b) list]\n ;;\nend\n\nlet to_string ~f t =\n Sexplib.Sexp.to_string (sexp_of_t (fun x -> Sexplib.Sexp.Atom x) (map t ~f))\n;;\n\ninclude Comparator.Derived (struct\n type nonrec 'a t = 'a t [@@deriving sexp_of, compare]\n end)\n\nlet quickcheck_generator = Base_quickcheck.Generator.list\nlet gen_non_empty = Base_quickcheck.Generator.list_non_empty\n\nlet gen_with_length length quickcheck_generator =\n Base_quickcheck.Generator.list_with_length quickcheck_generator ~length\n;;\n\nlet gen_filtered = Base_quickcheck.Generator.list_filtered\nlet gen_permutations = Base_quickcheck.Generator.list_permutations\nlet quickcheck_observer = Base_quickcheck.Observer.list\nlet quickcheck_shrinker = Base_quickcheck.Shrinker.list\n","open! Import\nopen Hashtbl_intf\nmodule Avltree = Avltree\nmodule Binable = Binable0\nmodule Hashable = Hashtbl_intf.Hashable\nmodule Merge_into_action = Hashtbl_intf.Merge_into_action\nmodule List = List0\n\nlet failwiths = Error.failwiths\n\nmodule Creators = Hashtbl.Creators\n\ninclude (\n Hashtbl :\n sig\n type ('a, 'b) t = ('a, 'b) Hashtbl.t [@@deriving sexp_of]\n\n include Base.Hashtbl.S_without_submodules with type ('a, 'b) t := ('a, 'b) t\n end)\n\nmodule Using_hashable = struct\n type nonrec ('a, 'b) t = ('a, 'b) t [@@deriving sexp_of]\n\n let create ?growth_allowed ?size ~hashable () =\n create ?growth_allowed ?size (Base.Hashable.to_key hashable)\n ;;\n\n let of_alist ?growth_allowed ?size ~hashable l =\n of_alist ?growth_allowed ?size (Base.Hashable.to_key hashable) l\n ;;\n\n let of_alist_report_all_dups ?growth_allowed ?size ~hashable l =\n of_alist_report_all_dups ?growth_allowed ?size (Base.Hashable.to_key hashable) l\n ;;\n\n let of_alist_or_error ?growth_allowed ?size ~hashable l =\n of_alist_or_error ?growth_allowed ?size (Base.Hashable.to_key hashable) l\n ;;\n\n let of_alist_exn ?growth_allowed ?size ~hashable l =\n of_alist_exn ?growth_allowed ?size (Base.Hashable.to_key hashable) l\n ;;\n\n let of_alist_multi ?growth_allowed ?size ~hashable l =\n of_alist_multi ?growth_allowed ?size (Base.Hashable.to_key hashable) l\n ;;\n\n let create_mapped ?growth_allowed ?size ~hashable ~get_key ~get_data l =\n create_mapped\n ?growth_allowed\n ?size\n (Base.Hashable.to_key hashable)\n ~get_key\n ~get_data\n l\n ;;\n\n let create_with_key ?growth_allowed ?size ~hashable ~get_key l =\n create_with_key ?growth_allowed ?size (Base.Hashable.to_key hashable) ~get_key l\n ;;\n\n let create_with_key_or_error ?growth_allowed ?size ~hashable ~get_key l =\n create_with_key_or_error\n ?growth_allowed\n ?size\n (Base.Hashable.to_key hashable)\n ~get_key\n l\n ;;\n\n let create_with_key_exn ?growth_allowed ?size ~hashable ~get_key l =\n create_with_key_exn ?growth_allowed ?size (Base.Hashable.to_key hashable) ~get_key l\n ;;\n\n let group ?growth_allowed ?size ~hashable ~get_key ~get_data ~combine l =\n group\n ?growth_allowed\n ?size\n (Base.Hashable.to_key hashable)\n ~get_key\n ~get_data\n ~combine\n l\n ;;\nend\n\nmodule type S_plain = S_plain with type ('a, 'b) hashtbl = ('a, 'b) t\nmodule type S = S with type ('a, 'b) hashtbl = ('a, 'b) t\nmodule type S_binable = S_binable with type ('a, 'b) hashtbl = ('a, 'b) t\nmodule type Key_plain = Key_plain\nmodule type Key = Key\nmodule type Key_binable = Key_binable\n\nmodule Poly = struct\n include Hashtbl.Poly\n\n include Bin_prot.Utils.Make_iterable_binable2 (struct\n type nonrec ('a, 'b) t = ('a, 'b) t\n type ('a, 'b) el = 'a * 'b [@@deriving bin_io]\n\n let caller_identity =\n Bin_prot.Shape.Uuid.of_string \"8f3e445c-4992-11e6-a279-3703be311e7b\"\n ;;\n\n let module_name = Some \"Core_kernel.Hashtbl\"\n let length = length\n let iter t ~f = iteri t ~f:(fun ~key ~data -> f (key, data))\n\n let init ~len ~next =\n let t = create ~size:len () in\n for _i = 0 to len - 1 do\n let key, data = next () in\n match find t key with\n | None -> set t ~key ~data\n | Some _ -> failwith \"Core_hashtbl.bin_read_t_: duplicate key\"\n done;\n t\n ;;\n end)\nend\n\nmodule Make_plain (Key : Key_plain) = struct\n let hashable =\n { Hashable.hash = Key.hash; compare = Key.compare; sexp_of_t = Key.sexp_of_t }\n ;;\n\n type key = Key.t\n type ('a, 'b) hashtbl = ('a, 'b) t\n type 'a t = (Key.t, 'a) hashtbl\n type ('a, 'b) t__ = (Key.t, 'b) hashtbl\n type 'a key_ = Key.t\n\n include Creators (struct\n type 'a t = Key.t\n\n let hashable = hashable\n end)\n\n include (\n Hashtbl :\n sig\n include\n Hashtbl.Accessors\n with type ('a, 'b) t := ('a, 'b) t__\n with type 'a key := 'a key_\n\n include\n Hashtbl.Multi with type ('a, 'b) t := ('a, 'b) t__ with type 'a key := 'a key_\n\n include Invariant.S2 with type ('a, 'b) t := ('a, 'b) hashtbl\n end)\n\n let invariant invariant_key t = invariant ignore invariant_key t\n let sexp_of_t sexp_of_v t = Poly.sexp_of_t Key.sexp_of_t sexp_of_v t\n\n module Provide_of_sexp\n (Key : sig\n type t [@@deriving of_sexp]\n end\n with type t := key) =\n struct\n let t_of_sexp v_of_sexp sexp = t_of_sexp Key.t_of_sexp v_of_sexp sexp\n end\n\n module Provide_bin_io\n (Key' : sig\n type t [@@deriving bin_io]\n end\n with type t := key) =\n Bin_prot.Utils.Make_iterable_binable1 (struct\n module Key = struct\n include Key\n include Key'\n end\n\n type nonrec 'a t = 'a t\n type 'a el = Key.t * 'a [@@deriving bin_io]\n\n let caller_identity =\n Bin_prot.Shape.Uuid.of_string \"8fabab0a-4992-11e6-8cca-9ba2c4686d9e\"\n ;;\n\n let module_name = Some \"Core_kernel.Hashtbl\"\n let length = length\n let iter t ~f = iteri t ~f:(fun ~key ~data -> f (key, data))\n\n let init ~len ~next =\n let t = create ~size:len () in\n for _i = 0 to len - 1 do\n let key, data = next () in\n match find t key with\n | None -> set t ~key ~data\n | Some _ ->\n failwiths\n ~here:[%here]\n \"Hashtbl.bin_read_t: duplicate key\"\n key\n [%sexp_of: Key.t]\n done;\n t\n ;;\n end)\nend\n\nmodule Make (Key : Key) = struct\n include Make_plain (Key)\n include Provide_of_sexp (Key)\nend\n\nmodule Make_binable (Key : Key_binable) = struct\n include Make (Key)\n include Provide_bin_io (Key)\nend\n\nmodule M = Hashtbl.M\n\nmodule type For_deriving = For_deriving\n\ninclude (Hashtbl : For_deriving with type ('a, 'b) t := ('a, 'b) t)\n\nlet hashable = Hashtbl.Private.hashable\n","open! Import\nopen Hash_set_intf\ninclude Base.Hash_set\n\nmodule type S_plain = S_plain with type 'a hash_set := 'a t\nmodule type S = S with type 'a hash_set := 'a t\nmodule type S_binable = S_binable with type 'a hash_set := 'a t\nmodule type Elt_plain = Hashtbl.Key_plain\nmodule type Elt = Hashtbl.Key\nmodule type Elt_binable = Hashtbl.Key_binable\n\nmodule Make_plain (Elt : Elt_plain) = struct\n type elt = Elt.t\n type nonrec t = elt t\n type 'a elt_ = elt\n\n include Creators (struct\n type 'a t = Elt.t\n\n let hashable = Hashtbl.Hashable.of_key (module Elt)\n end)\n\n let sexp_of_t t = Poly.sexp_of_t Elt.sexp_of_t t\n\n module Provide_of_sexp\n (X : sig\n type t [@@deriving of_sexp]\n end\n with type t := elt) =\n struct\n let t_of_sexp sexp = t_of_sexp X.t_of_sexp sexp\n end\n\n module Provide_bin_io\n (X : sig\n type t [@@deriving bin_io]\n end\n with type t := elt) =\n Bin_prot.Utils.Make_iterable_binable (struct\n module Elt = struct\n include Elt\n include X\n end\n\n type nonrec t = t\n type el = Elt.t [@@deriving bin_io]\n\n let _ = bin_el\n\n let caller_identity =\n Bin_prot.Shape.Uuid.of_string \"ad381672-4992-11e6-9e36-b76dc8cd466f\"\n ;;\n\n let module_name = Some \"Core_kernel.Hash_set\"\n let length = length\n let iter = iter\n\n let init ~len ~next =\n let t = create ~size:len () in\n for _i = 0 to len - 1 do\n let v = next () in\n add t v\n done;\n t\n ;;\n end)\nend\n\nmodule Make (Elt : Elt) = struct\n include Make_plain (Elt)\n include Provide_of_sexp (Elt)\nend\n\nmodule Make_binable (Elt : Elt_binable) = struct\n include Make (Elt)\n include Provide_bin_io (Elt)\nend\n\nmodule Using_hashable = struct\n type 'a elt = 'a\n\n let create ?growth_allowed ?size ~hashable () =\n create ?growth_allowed ?size (Base.Hashable.to_key hashable)\n ;;\n\n let of_list ?growth_allowed ?size ~hashable l =\n of_list ?growth_allowed ?size (Base.Hashable.to_key hashable) l\n ;;\nend\n\nlet hashable = Private.hashable\nlet create ?growth_allowed ?size m = create ?growth_allowed ?size m\n","open! Import\ninclude Base.Or_error\n\ntype 'a t = ('a, Error.t) Result.t [@@deriving bin_io]\n\nmodule Expect_test_config = struct\n module IO = Base.Or_error\n module IO_run = IO\n\n module IO_flush = struct\n include IO\n\n let to_run t = t\n end\n\n let flush () = return ()\n let run f = ok_exn (f ())\n let flushed () = true\n let upon_unreleasable_issue = Expect_test_config.upon_unreleasable_issue\nend\n\nmodule Stable = struct\n module V1 = struct\n type 'a t = ('a, Error.Stable.V1.t) Result.Stable.V1.t\n [@@deriving bin_io, compare, sexp]\n\n let map x ~f = Result.Stable.V1.map x ~f1:f ~f2:Fn.id\n end\n\n module V2 = struct\n type 'a t = ('a, Error.Stable.V2.t) Result.Stable.V1.t\n [@@deriving bin_io, compare, sexp]\n\n let map x ~f = Result.Stable.V1.map x ~f1:f ~f2:Fn.id\n end\nend\n","open! Import\nopen Map_intf\nmodule List = List0\n\nmodule Symmetric_diff_element = struct\n module Stable = struct\n module V1 = struct\n type ('k, 'v) t = 'k * [ `Left of 'v | `Right of 'v | `Unequal of 'v * 'v ]\n [@@deriving bin_io, compare, sexp]\n\n let%expect_test _ =\n print_endline [%bin_digest: (int, string) t];\n [%expect {| 00674be9fe8dfe9e9ad476067d7d8101 |}]\n ;;\n\n let map (k, diff) ~f1 ~f2 =\n let k = f1 k in\n let diff =\n match diff with\n | `Left v -> `Left (f2 v)\n | `Right v -> `Right (f2 v)\n | `Unequal (v1, v2) -> `Unequal (f2 v1, f2 v2)\n in\n k, diff\n ;;\n\n let map_data t ~f = map t ~f1:Fn.id ~f2:f\n\n let left (_key, diff) =\n match diff with\n | `Left x | `Unequal (x, _) -> Some x\n | `Right _ -> None\n ;;\n\n let right (_key, diff) =\n match diff with\n | `Right x | `Unequal (_, x) -> Some x\n | `Left _ -> None\n ;;\n end\n end\n\n include Stable.V1\nend\n\nmodule Continue_or_stop = Base.Map.Continue_or_stop\nmodule Finished_or_unfinished = Base.Map.Finished_or_unfinished\n\ntype ('k, 'cmp) comparator =\n (module Comparator.S with type t = 'k and type comparator_witness = 'cmp)\n\nlet to_comparator (type k cmp) ((module M) : (k, cmp) Map.comparator) = M.comparator\n\nlet of_comparator (type k cmp) comparator : (k, cmp) Map.comparator =\n (module struct\n type t = k\n type comparator_witness = cmp\n\n let comparator = comparator\n end)\n;;\n\nmodule For_quickcheck = struct\n let gen_tree ~comparator k_gen v_gen =\n Base_quickcheck.Generator.map_tree_using_comparator ~comparator k_gen v_gen\n ;;\n\n let quickcheck_generator ~comparator k_gen v_gen =\n Base_quickcheck.Generator.map_t_m (of_comparator comparator) k_gen v_gen\n ;;\n\n let obs_tree k_obs v_obs = Base_quickcheck.Observer.map_tree k_obs v_obs\n\n let shr_tree ~comparator k_shr v_shr =\n Base_quickcheck.Shrinker.map_tree_using_comparator ~comparator k_shr v_shr\n ;;\nend\n\nlet quickcheck_generator = Base_quickcheck.Generator.map_t_m\nlet quickcheck_observer = Base_quickcheck.Observer.map_t\nlet quickcheck_shrinker = Base_quickcheck.Shrinker.map_t\n\nmodule Using_comparator = struct\n include Map.Using_comparator\n include For_quickcheck\n\n let of_hashtbl_exn ~comparator hashtbl =\n match of_iteri ~comparator ~iteri:(Hashtbl.iteri hashtbl) with\n | `Ok map -> map\n | `Duplicate_key key ->\n Error.failwiths\n ~here:[%here]\n \"Map.of_hashtbl_exn: duplicate key\"\n key\n comparator.sexp_of_t\n ;;\n\n let tree_of_hashtbl_exn ~comparator hashtbl =\n to_tree (of_hashtbl_exn ~comparator hashtbl)\n ;;\n\n let key_set ~comparator t =\n Base.Set.Using_comparator.of_sorted_array_unchecked\n ~comparator\n (List.to_array (keys t))\n ;;\n\n let key_set_of_tree ~comparator t = key_set ~comparator (of_tree ~comparator t)\n\n let of_key_set key_set ~f =\n of_sorted_array_unchecked\n ~comparator:(Base.Set.comparator key_set)\n (Array.map (Base.Set.to_array key_set) ~f:(fun key -> key, f key))\n ;;\n\n let tree_of_key_set key_set ~f = to_tree (of_key_set key_set ~f)\nend\n\nmodule Accessors = struct\n include (\n Map.Using_comparator :\n Map.Accessors3\n with type ('a, 'b, 'c) t := ('a, 'b, 'c) Map.t\n with type ('a, 'b, 'c) tree := ('a, 'b, 'c) Tree.t)\n\n let quickcheck_observer k v = quickcheck_observer k v\n let quickcheck_shrinker k v = quickcheck_shrinker k v\n let key_set t = Using_comparator.key_set t ~comparator:(Using_comparator.comparator t)\nend\n\nlet key_set t = Using_comparator.key_set ~comparator:(Using_comparator.comparator t) t\nlet of_key_set = Using_comparator.of_key_set\nlet hash_fold_direct = Using_comparator.hash_fold_direct\nlet comparator = Using_comparator.comparator\nlet comparator_s = Base.Map.comparator_s\n\ntype 'k key = 'k\ntype 'c cmp = 'c\n\ninclude (\nstruct\n include Map\n\n let of_tree m = Map.Using_comparator.of_tree ~comparator:(to_comparator m)\n let to_tree = Map.Using_comparator.to_tree\nend :\nsig\n type ('a, 'b, 'c) t = ('a, 'b, 'c) Map.t\n\n include\n Map.Creators_generic\n with type ('a, 'b, 'c) options := ('a, 'b, 'c) Map.With_first_class_module.t\n with type ('a, 'b, 'c) t := ('a, 'b, 'c) t\n with type ('a, 'b, 'c) tree := ('a, 'b, 'c) Tree.t\n with type 'k key := 'k key\n with type 'c cmp := 'c cmp\n\n include\n Map.Accessors3\n with type ('a, 'b, 'c) t := ('a, 'b, 'c) t\n with type ('a, 'b, 'c) tree := ('a, 'b, 'c) Tree.t\nend)\n\nmodule Empty_without_value_restriction = Using_comparator.Empty_without_value_restriction\n\nlet find_or_error t key =\n let comparator = comparator t in\n match find t key with\n | Some data -> Ok data\n | None ->\n let sexp_of_key = comparator.sexp_of_t in\n Or_error.error_s [%message \"key not found\" ~_:(key : key)]\n;;\n\nlet merge_skewed = Map.merge_skewed\nlet of_hashtbl_exn m t = Using_comparator.of_hashtbl_exn ~comparator:(to_comparator m) t\n\nmodule Creators (Key : Comparator.S1) : sig\n type ('a, 'b, 'c) t_ = ('a Key.t, 'b, Key.comparator_witness) t\n type ('a, 'b, 'c) tree = ('a, 'b, Key.comparator_witness) Tree.t\n type ('a, 'b, 'c) options = ('a, 'b, 'c) Without_comparator.t\n\n val t_of_sexp\n : (Base.Sexp.t -> 'a Key.t)\n -> (Base.Sexp.t -> 'b)\n -> Base.Sexp.t\n -> ('a, 'b, _) t_\n\n include\n Creators_generic\n with type ('a, 'b, 'c) t := ('a, 'b, 'c) t_\n with type ('a, 'b, 'c) tree := ('a, 'b, 'c) tree\n with type 'a key := 'a Key.t\n with type 'a cmp := Key.comparator_witness\n with type ('a, 'b, 'c) options := ('a, 'b, 'c) options\nend = struct\n type ('a, 'b, 'c) options = ('a, 'b, 'c) Without_comparator.t\n\n let comparator = Key.comparator\n\n type ('a, 'b, 'c) t_ = ('a Key.t, 'b, Key.comparator_witness) t\n type ('a, 'b, 'c) tree = ('a, 'b, Key.comparator_witness) Tree.t\n\n module M_empty = Empty_without_value_restriction (Key)\n\n let empty = M_empty.empty\n let of_tree tree = Using_comparator.of_tree ~comparator tree\n let singleton k v = Using_comparator.singleton ~comparator k v\n\n let of_sorted_array_unchecked array =\n Using_comparator.of_sorted_array_unchecked ~comparator array\n ;;\n\n let of_sorted_array array = Using_comparator.of_sorted_array ~comparator array\n\n let of_increasing_iterator_unchecked ~len ~f =\n Using_comparator.of_increasing_iterator_unchecked ~comparator ~len ~f\n ;;\n\n let of_increasing_sequence seq =\n Using_comparator.of_increasing_sequence ~comparator seq\n ;;\n\n let of_sequence seq = Using_comparator.of_sequence ~comparator seq\n let of_sequence_or_error seq = Using_comparator.of_sequence_or_error ~comparator seq\n let of_sequence_exn seq = Using_comparator.of_sequence_exn ~comparator seq\n let of_sequence_multi seq = Using_comparator.of_sequence_multi ~comparator seq\n\n let of_sequence_fold seq ~init ~f =\n Using_comparator.of_sequence_fold ~comparator seq ~init ~f\n ;;\n\n let of_sequence_reduce seq ~f = Using_comparator.of_sequence_reduce ~comparator seq ~f\n let of_alist alist = Using_comparator.of_alist ~comparator alist\n let of_alist_or_error alist = Using_comparator.of_alist_or_error ~comparator alist\n let of_alist_exn alist = Using_comparator.of_alist_exn ~comparator alist\n let of_hashtbl_exn hashtbl = Using_comparator.of_hashtbl_exn ~comparator hashtbl\n let of_alist_multi alist = Using_comparator.of_alist_multi ~comparator alist\n\n let of_alist_fold alist ~init ~f =\n Using_comparator.of_alist_fold ~comparator alist ~init ~f\n ;;\n\n let of_alist_reduce alist ~f = Using_comparator.of_alist_reduce ~comparator alist ~f\n let of_iteri ~iteri = Using_comparator.of_iteri ~comparator ~iteri\n\n let t_of_sexp k_of_sexp v_of_sexp sexp =\n Using_comparator.t_of_sexp_direct ~comparator k_of_sexp v_of_sexp sexp\n ;;\n\n let of_key_set key_set ~f = Using_comparator.of_key_set key_set ~f\n\n let quickcheck_generator gen_k gen_v =\n Using_comparator.quickcheck_generator ~comparator gen_k gen_v\n ;;\nend\n\nmodule Make_tree (Key : Comparator.S1) = struct\n open Tree\n\n let comparator = Key.comparator\n let sexp_of_t = sexp_of_t\n let t_of_sexp a b c = t_of_sexp_direct a b c ~comparator\n let empty = empty_without_value_restriction\n let of_tree tree = tree\n let singleton a = singleton a ~comparator\n let of_sorted_array_unchecked a = of_sorted_array_unchecked a ~comparator\n let of_sorted_array a = of_sorted_array a ~comparator\n\n let of_increasing_iterator_unchecked ~len ~f =\n of_increasing_iterator_unchecked ~len ~f ~comparator\n ;;\n\n let of_increasing_sequence seq = of_increasing_sequence ~comparator seq\n let of_sequence s = of_sequence s ~comparator\n let of_sequence_or_error s = of_sequence_or_error s ~comparator\n let of_sequence_exn s = of_sequence_exn s ~comparator\n let of_sequence_multi s = of_sequence_multi s ~comparator\n let of_sequence_fold s ~init ~f = of_sequence_fold s ~init ~f ~comparator\n let of_sequence_reduce s ~f = of_sequence_reduce s ~f ~comparator\n let of_alist a = of_alist a ~comparator\n let of_alist_or_error a = of_alist_or_error a ~comparator\n let of_alist_exn a = of_alist_exn a ~comparator\n let of_hashtbl_exn a = Using_comparator.tree_of_hashtbl_exn a ~comparator\n let of_alist_multi a = of_alist_multi a ~comparator\n let of_alist_fold a ~init ~f = of_alist_fold a ~init ~f ~comparator\n let of_alist_reduce a ~f = of_alist_reduce a ~f ~comparator\n let of_iteri ~iteri = of_iteri ~iteri ~comparator\n let of_key_set = Using_comparator.tree_of_key_set\n let to_tree t = t\n let invariants a = invariants a ~comparator\n let is_empty a = is_empty a\n let length a = length a\n let set a ~key ~data = set a ~key ~data ~comparator\n let add a ~key ~data = add a ~key ~data ~comparator\n let add_exn a ~key ~data = add_exn a ~key ~data ~comparator\n let add_multi a ~key ~data = add_multi a ~key ~data ~comparator\n let remove_multi a b = remove_multi a b ~comparator\n let find_multi a b = find_multi a b ~comparator\n let change a b ~f = change a b ~f ~comparator\n let update a b ~f = update a b ~f ~comparator\n let find_exn a b = find_exn a b ~comparator\n let find a b = find a b ~comparator\n let remove a b = remove a b ~comparator\n let mem a b = mem a b ~comparator\n let iter_keys = iter_keys\n let iter = iter\n let iteri = iteri\n let iteri_until = iteri_until\n let iter2 a b ~f = iter2 a b ~f ~comparator\n let map = map\n let mapi = mapi\n let fold = fold\n let fold_right = fold_right\n let fold2 a b ~init ~f = fold2 a b ~init ~f ~comparator\n let filter_keys a ~f = filter_keys a ~f ~comparator\n let filter a ~f = filter a ~f ~comparator\n let filteri a ~f = filteri a ~f ~comparator\n let filter_map a ~f = filter_map a ~f ~comparator\n let filter_mapi a ~f = filter_mapi a ~f ~comparator\n let partition_mapi t ~f = partition_mapi t ~f ~comparator\n let partition_map t ~f = partition_map t ~f ~comparator\n let partitioni_tf t ~f = partitioni_tf t ~f ~comparator\n let partition_tf t ~f = partition_tf t ~f ~comparator\n let combine_errors t = combine_errors t ~comparator\n let compare_direct a b c = compare_direct a b c ~comparator\n let equal a b c = equal a b c ~comparator\n let keys = keys\n let data = data\n let to_alist = to_alist\n let validate = validate\n let validatei = validatei\n let symmetric_diff a b ~data_equal = symmetric_diff a b ~data_equal ~comparator\n\n let fold_symmetric_diff a b ~data_equal ~init ~f =\n fold_symmetric_diff a b ~data_equal ~f ~init ~comparator\n ;;\n\n let merge a b ~f = merge a b ~f ~comparator\n let min_elt = min_elt\n let min_elt_exn = min_elt_exn\n let max_elt = max_elt\n let max_elt_exn = max_elt_exn\n let for_all = for_all\n let for_alli = for_alli\n let exists = exists\n let existsi = existsi\n let count = count\n let counti = counti\n let split a b = split a b ~comparator\n let append ~lower_part ~upper_part = append ~lower_part ~upper_part ~comparator\n\n let subrange t ~lower_bound ~upper_bound =\n subrange t ~lower_bound ~upper_bound ~comparator\n ;;\n\n let fold_range_inclusive t ~min ~max ~init ~f =\n fold_range_inclusive t ~min ~max ~init ~f ~comparator\n ;;\n\n let range_to_alist t ~min ~max = range_to_alist t ~min ~max ~comparator\n let closest_key a b c = closest_key a b c ~comparator\n let nth a = nth a ~comparator\n let nth_exn a = nth_exn a ~comparator\n let rank a b = rank a b ~comparator\n\n let to_sequence ?order ?keys_greater_or_equal_to ?keys_less_or_equal_to t =\n to_sequence ~comparator ?order ?keys_greater_or_equal_to ?keys_less_or_equal_to t\n ;;\n\n let binary_search t ~compare how v = binary_search ~comparator t ~compare how v\n\n let binary_search_segmented t ~segment_of how =\n binary_search_segmented ~comparator t ~segment_of how\n ;;\n\n let key_set t = Using_comparator.key_set_of_tree ~comparator t\n let quickcheck_generator k v = For_quickcheck.gen_tree ~comparator k v\n let quickcheck_observer k v = For_quickcheck.obs_tree k v\n let quickcheck_shrinker k v = For_quickcheck.shr_tree ~comparator k v\nend\n\n(* Don't use [of_sorted_array] to avoid the allocation of an intermediate array *)\nlet init_for_bin_prot ~len ~f ~comparator =\n let map = Using_comparator.of_increasing_iterator_unchecked ~len ~f ~comparator in\n if invariants map\n then map\n else (\n (* The invariants are broken, but we can still traverse the structure. *)\n match Using_comparator.of_iteri ~iteri:(iteri map) ~comparator with\n | `Ok map -> map\n | `Duplicate_key _key -> failwith \"Map.bin_read_t: duplicate element in map\")\n;;\n\nmodule Poly = struct\n include Creators (Comparator.Poly)\n\n type ('a, 'b, 'c) map = ('a, 'b, 'c) t\n type ('k, 'v) t = ('k, 'v, Comparator.Poly.comparator_witness) map\n type comparator_witness = Comparator.Poly.comparator_witness\n\n include Accessors\n\n let compare _ cmpv t1 t2 = compare_direct cmpv t1 t2\n\n let sexp_of_t sexp_of_k sexp_of_v t =\n Using_comparator.sexp_of_t sexp_of_k sexp_of_v [%sexp_of: _] t\n ;;\n\n include Bin_prot.Utils.Make_iterable_binable2 (struct\n type nonrec ('a, 'b) t = ('a, 'b) t\n type ('a, 'b) el = 'a * 'b [@@deriving bin_io]\n\n let _ = bin_el\n\n let caller_identity =\n Bin_prot.Shape.Uuid.of_string \"b7d7b1a0-4992-11e6-8a32-bbb221fa025c\"\n ;;\n\n let module_name = Some \"Core_kernel.Map\"\n let length = length\n let iter t ~f = iteri t ~f:(fun ~key ~data -> f (key, data))\n\n let init ~len ~next =\n init_for_bin_prot ~len ~f:(fun _ -> next ()) ~comparator:Comparator.Poly.comparator\n ;;\n end)\n\n module Tree = struct\n include Make_tree (Comparator.Poly)\n\n type ('k, +'v) t = ('k, 'v, Comparator.Poly.comparator_witness) tree\n type comparator_witness = Comparator.Poly.comparator_witness\n\n let sexp_of_t sexp_of_k sexp_of_v t = sexp_of_t sexp_of_k sexp_of_v [%sexp_of: _] t\n end\nend\n\nmodule type Key_plain = Key_plain\nmodule type Key = Key\nmodule type Key_binable = Key_binable\nmodule type Key_hashable = Key_hashable\nmodule type Key_binable_hashable = Key_binable_hashable\nmodule type S_plain = S_plain\nmodule type S = S\nmodule type S_binable = S_binable\n\nmodule Key_bin_io = Key_bin_io\n\nmodule Provide_bin_io (Key : Key_bin_io.S) =\n Bin_prot.Utils.Make_iterable_binable1 (struct\n module Key = Key\n\n type nonrec 'v t = (Key.t, 'v, Key.comparator_witness) t\n type 'v el = Key.t * 'v [@@deriving bin_io]\n\n let _ = bin_el\n\n let caller_identity =\n Bin_prot.Shape.Uuid.of_string \"dfb300f8-4992-11e6-9c15-73a2ac6b815c\"\n ;;\n\n let module_name = Some \"Core_kernel.Map\"\n let length = length\n let iter t ~f = iteri t ~f:(fun ~key ~data -> f (key, data))\n\n let init ~len ~next =\n init_for_bin_prot ~len ~f:(fun _ -> next ()) ~comparator:Key.comparator\n ;;\n end)\n\nmodule Make_plain_using_comparator (Key : sig\n type t [@@deriving sexp_of]\n\n include Comparator.S with type t := t\n end) =\nstruct\n module Key = Key\n module Key_S1 = Comparator.S_to_S1 (Key)\n include Creators (Key_S1)\n\n type key = Key.t\n type ('a, 'b, 'c) map = ('a, 'b, 'c) t\n type 'v t = (key, 'v, Key.comparator_witness) map\n\n include Accessors\n\n let compare cmpv t1 t2 = compare_direct cmpv t1 t2\n\n let sexp_of_t sexp_of_v t =\n Using_comparator.sexp_of_t Key.sexp_of_t sexp_of_v [%sexp_of: _] t\n ;;\n\n module Provide_of_sexp\n (Key : sig\n type t [@@deriving of_sexp]\n end\n with type t := Key.t) =\n struct\n let t_of_sexp v_of_sexp sexp = t_of_sexp Key.t_of_sexp v_of_sexp sexp\n end\n\n module Provide_hash (Key' : Hasher.S with type t := Key.t) = struct\n let hash_fold_t (type a) hash_fold_data state (t : a t) =\n Using_comparator.hash_fold_direct Key'.hash_fold_t hash_fold_data state t\n ;;\n end\n\n module Provide_bin_io\n (Key' : sig\n type t [@@deriving bin_io]\n end\n with type t := Key.t) =\n Provide_bin_io (struct\n include Key\n include Key'\n end)\n\n module Tree = struct\n include Make_tree (Key_S1)\n\n type +'v t = (Key.t, 'v, Key.comparator_witness) tree\n\n let sexp_of_t sexp_of_v t = sexp_of_t Key.sexp_of_t sexp_of_v [%sexp_of: _] t\n\n module Provide_of_sexp\n (X : sig\n type t [@@deriving of_sexp]\n end\n with type t := Key.t) =\n struct\n let t_of_sexp v_of_sexp sexp = t_of_sexp X.t_of_sexp v_of_sexp sexp\n end\n end\nend\n\nmodule Make_plain (Key : Key_plain) = Make_plain_using_comparator (struct\n include Key\n include Comparator.Make (Key)\n end)\n\nmodule Make_using_comparator (Key_sexp : sig\n type t [@@deriving sexp]\n\n include Comparator.S with type t := t\n end) =\nstruct\n include Make_plain_using_comparator (Key_sexp)\n module Key = Key_sexp\n include Provide_of_sexp (Key)\n\n module Tree = struct\n include Tree\n include Provide_of_sexp (Key)\n end\nend\n\nmodule Make (Key : Key) = Make_using_comparator (struct\n include Key\n include Comparator.Make (Key)\n end)\n\nmodule Make_binable_using_comparator (Key_bin_sexp : sig\n type t [@@deriving bin_io, sexp]\n\n include Comparator.S with type t := t\n end) =\nstruct\n include Make_using_comparator (Key_bin_sexp)\n module Key = Key_bin_sexp\n include Provide_bin_io (Key)\nend\n\nmodule Make_binable (Key : Key_binable) = Make_binable_using_comparator (struct\n include Key\n include Comparator.Make (Key)\n end)\n\nmodule For_deriving = struct\n module M = Map.M\n\n let bin_shape_m__t (type t c) (m : (t, c) Key_bin_io.t) =\n let module M = Provide_bin_io ((val m)) in\n M.bin_shape_t\n ;;\n\n let bin_size_m__t (type t c) (m : (t, c) Key_bin_io.t) =\n let module M = Provide_bin_io ((val m)) in\n M.bin_size_t\n ;;\n\n let bin_write_m__t (type t c) (m : (t, c) Key_bin_io.t) =\n let module M = Provide_bin_io ((val m)) in\n M.bin_write_t\n ;;\n\n let bin_read_m__t (type t c) (m : (t, c) Key_bin_io.t) =\n let module M = Provide_bin_io ((val m)) in\n M.bin_read_t\n ;;\n\n let __bin_read_m__t__ (type t c) (m : (t, c) Key_bin_io.t) =\n let module M = Provide_bin_io ((val m)) in\n M.__bin_read_t__\n ;;\n\n module type Quickcheck_generator_m = sig\n include Comparator.S\n\n val quickcheck_generator : t Quickcheck.Generator.t\n end\n\n module type Quickcheck_observer_m = sig\n include Comparator.S\n\n val quickcheck_observer : t Quickcheck.Observer.t\n end\n\n module type Quickcheck_shrinker_m = sig\n include Comparator.S\n\n val quickcheck_shrinker : t Quickcheck.Shrinker.t\n end\n\n let quickcheck_generator_m__t\n (type k cmp)\n (module Key : Quickcheck_generator_m\n with type t = k\n and type comparator_witness = cmp)\n v_generator\n =\n quickcheck_generator (module Key) Key.quickcheck_generator v_generator\n ;;\n\n let quickcheck_observer_m__t\n (type k cmp)\n (module Key : Quickcheck_observer_m\n with type t = k\n and type comparator_witness = cmp)\n v_observer\n =\n quickcheck_observer Key.quickcheck_observer v_observer\n ;;\n\n let quickcheck_shrinker_m__t\n (type k cmp)\n (module Key : Quickcheck_shrinker_m\n with type t = k\n and type comparator_witness = cmp)\n v_shrinker\n =\n quickcheck_shrinker Key.quickcheck_shrinker v_shrinker\n ;;\n\n module type For_deriving = Map.For_deriving\n\n include (Map : For_deriving with type ('a, 'b, 'c) t := ('a, 'b, 'c) t)\nend\n\ninclude For_deriving\n\nmodule Tree = struct\n include Tree\n\n let of_hashtbl_exn = Using_comparator.tree_of_hashtbl_exn\n let key_set = Using_comparator.key_set_of_tree\n let of_key_set = Using_comparator.tree_of_key_set\n let quickcheck_generator ~comparator k v = For_quickcheck.gen_tree ~comparator k v\n let quickcheck_observer k v = For_quickcheck.obs_tree k v\n let quickcheck_shrinker ~comparator k v = For_quickcheck.shr_tree ~comparator k v\nend\n\nmodule Stable = struct\n module V1 = struct\n type nonrec ('k, 'v, 'cmp) t = ('k, 'v, 'cmp) t\n\n module type S = sig\n type key\n type comparator_witness\n type nonrec 'a t = (key, 'a, comparator_witness) t\n\n include Stable_module_types.S1 with type 'a t := 'a t\n end\n\n module Make (Key : Stable_module_types.S0) = Make_binable_using_comparator (Key)\n end\n\n module Symmetric_diff_element = Symmetric_diff_element.Stable\nend\n","open! Import\nmodule List = List0\nopen Set_intf\nmodule Merge_to_sequence_element = Merge_to_sequence_element\nmodule Named = Named\n\nmodule type Elt_plain = Elt_plain\nmodule type Elt = Elt\nmodule type Elt_binable = Elt_binable\n\nlet to_comparator (type k cmp) ((module M) : (k, cmp) Set.comparator) = M.comparator\n\nlet of_comparator (type k cmp) comparator : (k, cmp) Set.comparator =\n (module struct\n type t = k\n type comparator_witness = cmp\n\n let comparator = comparator\n end)\n;;\n\nmodule For_quickcheck = struct\n let quickcheck_generator ~comparator elt_gen =\n Base_quickcheck.Generator.set_t_m (of_comparator comparator) elt_gen\n ;;\n\n let gen_tree ~comparator elt_gen =\n Base_quickcheck.Generator.set_tree_using_comparator ~comparator elt_gen\n ;;\n\n let quickcheck_observer elt_obs = Base_quickcheck.Observer.set_t elt_obs\n let obs_tree elt_obs = Base_quickcheck.Observer.set_tree elt_obs\n let quickcheck_shrinker elt_shr = Base_quickcheck.Shrinker.set_t elt_shr\n\n let shr_tree ~comparator elt_shr =\n Base_quickcheck.Shrinker.set_tree_using_comparator ~comparator elt_shr\n ;;\nend\n\nlet quickcheck_generator m elt_gen =\n For_quickcheck.quickcheck_generator ~comparator:(to_comparator m) elt_gen\n;;\n\nlet quickcheck_observer = For_quickcheck.quickcheck_observer\nlet quickcheck_shrinker = For_quickcheck.quickcheck_shrinker\n\nmodule Tree = struct\n include Tree\n\n let to_map ~comparator t = Map.of_key_set (Set.Using_comparator.of_tree t ~comparator)\n let of_map_keys m = Set.Using_comparator.to_tree (Map.key_set m)\n\n let of_hash_set ~comparator hset =\n Hash_set.fold hset ~init:(empty ~comparator) ~f:(fun t x -> add t x ~comparator)\n ;;\n\n let of_hashtbl_keys ~comparator hashtbl =\n Hashtbl.fold hashtbl ~init:(empty ~comparator) ~f:(fun ~key:x ~data:_ t ->\n add t x ~comparator)\n ;;\n\n let quickcheck_generator = For_quickcheck.gen_tree\n let quickcheck_observer = For_quickcheck.obs_tree\n let quickcheck_shrinker = For_quickcheck.shr_tree\nend\n\nmodule Accessors = struct\n include (\n Set.Using_comparator :\n Set.Accessors2\n with type ('a, 'b) t := ('a, 'b) Set.t\n with type ('a, 'b) tree := ('a, 'b) Tree.t\n with type ('a, 'b) named := ('a, 'b) Set.Named.t)\n\n let to_map = Map.of_key_set\n let quickcheck_observer = quickcheck_observer\n let quickcheck_shrinker = quickcheck_shrinker\nend\n\ntype 'a cmp = 'a\ntype 'a elt = 'a\n\ninclude (\nstruct\n include Set\n\n let of_tree m = Set.Using_comparator.of_tree ~comparator:(to_comparator m)\n let to_tree = Set.Using_comparator.to_tree\n let sexp_of_t = Set.Using_comparator.sexp_of_t\n\n module Empty_without_value_restriction =\n Set.Using_comparator.Empty_without_value_restriction\nend :\nsig\n type ('a, 'b) t = ('a, 'b) Set.t [@@deriving sexp_of]\n\n include\n Set.Creators_generic\n with type ('a, 'b, 'c) options := ('a, 'b, 'c) Set.With_first_class_module.t\n with type ('a, 'b) t := ('a, 'b) t\n with type ('a, 'b) set := ('a, 'b) t\n with type ('a, 'b) tree := ('a, 'b) Tree.t\n with type 'a cmp := 'a cmp\n with type 'a elt := 'a elt\n\n include\n Set.Accessors2\n with type ('a, 'b) t := ('a, 'b) t\n with type ('a, 'b) tree := ('a, 'b) Tree.t\n with type ('a, 'b) named := ('a, 'b) Set.Named.t\n with module Named := Named\nend)\n\ntype ('k, 'cmp) comparator =\n (module Comparator.S with type t = 'k and type comparator_witness = 'cmp)\n\nlet compare _ _ t1 t2 = compare_direct t1 t2\n\nmodule Using_comparator = struct\n include (\n Set.Using_comparator :\n module type of struct\n include Set.Using_comparator\n end\n with module Tree := Set.Using_comparator.Tree)\n\n include For_quickcheck\n\n let of_map_keys = Map.key_set\n\n let of_hash_set ~comparator hset =\n of_tree ~comparator (Tree.of_hash_set hset ~comparator)\n ;;\n\n let of_hashtbl_keys ~comparator hashtbl =\n of_tree ~comparator (Tree.of_hashtbl_keys hashtbl ~comparator)\n ;;\nend\n\nlet to_map = Map.of_key_set\nlet of_map_keys = Map.key_set\nlet hash_fold_direct = Using_comparator.hash_fold_direct\nlet comparator = Using_comparator.comparator\nlet of_hash_set m hset = Using_comparator.of_hash_set ~comparator:(to_comparator m) hset\n\nlet of_hashtbl_keys m hashtbl =\n Using_comparator.of_hashtbl_keys ~comparator:(to_comparator m) hashtbl\n;;\n\nmodule Creators (Elt : Comparator.S1) : sig\n type nonrec ('a, 'comparator) t_ = ('a Elt.t, Elt.comparator_witness) t\n type ('a, 'b) tree = ('a, Elt.comparator_witness) Tree.t\n type 'a elt_ = 'a Elt.t\n type 'a cmp_ = Elt.comparator_witness\n\n val t_of_sexp : (Base.Sexp.t -> 'a Elt.t) -> Base.Sexp.t -> ('a, 'comparator) t_\n\n include\n Creators_generic\n with type ('a, 'b) t := ('a, 'b) t_\n with type ('a, 'b) set := ('a, 'b) t\n with type ('a, 'b) tree := ('a, 'b) tree\n with type 'a elt := 'a elt_\n with type ('a, 'b, 'c) options := ('a, 'b, 'c) Without_comparator.t\n with type 'a cmp := 'a cmp_\nend = struct\n open Using_comparator\n\n type nonrec ('a, 'comparator) t_ = ('a Elt.t, Elt.comparator_witness) t\n type ('a, 'b) tree = ('a, Elt.comparator_witness) Tree.t\n type 'a elt_ = 'a Elt.t\n type 'cmp cmp_ = Elt.comparator_witness\n\n let comparator = Elt.comparator\n let of_tree tree = of_tree ~comparator tree\n let of_sorted_array_unchecked array = of_sorted_array_unchecked ~comparator array\n\n let of_increasing_iterator_unchecked ~len ~f =\n of_increasing_iterator_unchecked ~comparator ~len ~f\n ;;\n\n let of_sorted_array array = of_sorted_array ~comparator array\n\n module M_empty = Empty_without_value_restriction (Elt)\n\n let empty = M_empty.empty\n let singleton e = singleton ~comparator e\n let union_list l = union_list ~comparator l\n let of_list l = of_list ~comparator l\n let of_hash_set h = of_hash_set ~comparator h\n let of_hashtbl_keys h = of_hashtbl_keys ~comparator h\n let of_array a = of_array ~comparator a\n let stable_dedup_list xs = stable_dedup_list ~comparator xs\n let map t ~f = map ~comparator t ~f\n let filter_map t ~f = filter_map ~comparator t ~f\n\n let t_of_sexp a_of_sexp sexp =\n of_tree (Tree.t_of_sexp_direct a_of_sexp sexp ~comparator)\n ;;\n\n let of_map_keys = Map.key_set\n let quickcheck_generator elt = quickcheck_generator ~comparator elt\nend\n\nmodule Make_tree (Elt : Comparator.S1) = struct\n let comparator = Elt.comparator\n let empty = Tree.empty_without_value_restriction\n let singleton e = Tree.singleton ~comparator e\n let invariants t = Tree.invariants t ~comparator\n let length t = Tree.length t\n let is_empty t = Tree.is_empty t\n let elements t = Tree.elements t\n let min_elt t = Tree.min_elt t\n let min_elt_exn t = Tree.min_elt_exn t\n let max_elt t = Tree.max_elt t\n let max_elt_exn t = Tree.max_elt_exn t\n let choose t = Tree.choose t\n let choose_exn t = Tree.choose_exn t\n let to_list t = Tree.to_list t\n let to_array t = Tree.to_array t\n let iter t ~f = Tree.iter t ~f\n let iter2 a b ~f = Tree.iter2 a b ~f ~comparator\n let exists t ~f = Tree.exists t ~f\n let for_all t ~f = Tree.for_all t ~f\n let count t ~f = Tree.count t ~f\n let sum m t ~f = Tree.sum m t ~f\n let find t ~f = Tree.find t ~f\n let find_exn t ~f = Tree.find_exn t ~f\n let find_map t ~f = Tree.find_map t ~f\n let fold t ~init ~f = Tree.fold t ~init ~f\n let fold_until t ~init ~f = Tree.fold_until t ~init ~f\n let fold_right t ~init ~f = Tree.fold_right t ~init ~f\n let fold_result t ~init ~f = Container.fold_result ~fold ~init ~f t\n let map t ~f = Tree.map t ~f ~comparator\n let filter t ~f = Tree.filter t ~f ~comparator\n let filter_map t ~f = Tree.filter_map t ~f ~comparator\n let partition_tf t ~f = Tree.partition_tf t ~f ~comparator\n let mem t a = Tree.mem t a ~comparator\n let add t a = Tree.add t a ~comparator\n let remove t a = Tree.remove t a ~comparator\n let union t1 t2 = Tree.union t1 t2 ~comparator\n let inter t1 t2 = Tree.inter t1 t2 ~comparator\n let diff t1 t2 = Tree.diff t1 t2 ~comparator\n let symmetric_diff t1 t2 = Tree.symmetric_diff t1 t2 ~comparator\n let compare_direct t1 t2 = Tree.compare_direct ~comparator t1 t2\n let equal t1 t2 = Tree.equal t1 t2 ~comparator\n let is_subset t ~of_ = Tree.is_subset t ~of_ ~comparator\n let are_disjoint t1 t2 = Tree.are_disjoint t1 t2 ~comparator\n let of_list l = Tree.of_list l ~comparator\n let of_hash_set h = Tree.of_hash_set h ~comparator\n let of_hashtbl_keys h = Tree.of_hashtbl_keys h ~comparator\n let of_array a = Tree.of_array a ~comparator\n let of_sorted_array_unchecked a = Tree.of_sorted_array_unchecked a ~comparator\n\n let of_increasing_iterator_unchecked ~len ~f =\n Tree.of_increasing_iterator_unchecked ~len ~f ~comparator\n ;;\n\n let of_sorted_array a = Tree.of_sorted_array a ~comparator\n let union_list l = Tree.union_list l ~comparator\n let stable_dedup_list xs = Tree.stable_dedup_list xs ~comparator\n let group_by t ~equiv = Tree.group_by t ~equiv ~comparator\n let split t a = Tree.split t a ~comparator\n let nth t i = Tree.nth t i\n let remove_index t i = Tree.remove_index t i ~comparator\n let to_tree t = t\n let of_tree t = t\n\n let to_sequence ?order ?greater_or_equal_to ?less_or_equal_to t =\n Tree.to_sequence ~comparator ?order ?greater_or_equal_to ?less_or_equal_to t\n ;;\n\n let binary_search t ~compare how v = Tree.binary_search ~comparator t ~compare how v\n\n let binary_search_segmented t ~segment_of how =\n Tree.binary_search_segmented ~comparator t ~segment_of how\n ;;\n\n let merge_to_sequence ?order ?greater_or_equal_to ?less_or_equal_to t t' =\n Tree.merge_to_sequence ~comparator ?order ?greater_or_equal_to ?less_or_equal_to t t'\n ;;\n\n let of_map_keys = Tree.of_map_keys\n let to_map t ~f = Tree.to_map ~comparator t ~f\n\n module Named = struct\n let is_subset t ~of_ = Tree.Named.is_subset t ~of_ ~comparator\n let equal t1 t2 = Tree.Named.equal t1 t2 ~comparator\n end\n\n let quickcheck_generator elt = For_quickcheck.gen_tree elt ~comparator\n let quickcheck_observer elt = For_quickcheck.obs_tree elt\n let quickcheck_shrinker elt = For_quickcheck.shr_tree elt ~comparator\nend\n\n(* Don't use [of_sorted_array] to avoid the allocation of an intermediate array *)\nlet init_for_bin_prot ~len ~f ~comparator =\n let set = Using_comparator.of_increasing_iterator_unchecked ~comparator ~len ~f in\n if invariants set\n then set\n else\n Using_comparator.of_tree\n ~comparator\n (fold set ~init:(Tree.empty ~comparator) ~f:(fun acc elt ->\n if Tree.mem acc elt ~comparator\n then failwith \"Set.bin_read_t: duplicate element in map\"\n else Tree.add acc elt ~comparator))\n;;\n\nmodule Poly = struct\n module Elt = Comparator.Poly\n include Creators (Elt)\n\n type nonrec 'a t = ('a, Elt.comparator_witness) t\n type 'a named = ('a, Elt.comparator_witness) Named.t\n\n include Accessors\n\n let compare _ t1 t2 = compare_direct t1 t2\n let sexp_of_t sexp_of_k t = sexp_of_t sexp_of_k [%sexp_of: _] t\n\n include Bin_prot.Utils.Make_iterable_binable1 (struct\n type nonrec 'a t = 'a t\n type 'a el = 'a [@@deriving bin_io]\n\n let _ = bin_el\n\n let caller_identity =\n Bin_prot.Shape.Uuid.of_string \"88bcc478-4992-11e6-a95d-ff4831acf410\"\n ;;\n\n let module_name = Some \"Core_kernel.Set\"\n let length = length\n let iter t ~f = iter ~f:(fun key -> f key) t\n\n let init ~len ~next =\n init_for_bin_prot ~len ~f:(fun _ -> next ()) ~comparator:Comparator.Poly.comparator\n ;;\n end)\n\n module Tree = struct\n include Make_tree (Comparator.Poly)\n\n type 'elt t = ('elt, Comparator.Poly.comparator_witness) tree\n type 'a named = ('a, Elt.comparator_witness) Tree.Named.t\n\n let sexp_of_t sexp_of_elt t = Tree.sexp_of_t sexp_of_elt [%sexp_of: _] t\n\n let t_of_sexp elt_of_sexp sexp =\n Tree.t_of_sexp_direct elt_of_sexp sexp ~comparator:Comparator.Poly.comparator\n ;;\n end\nend\n\nmodule type S_plain = S_plain\nmodule type S = S\nmodule type S_binable = S_binable\n\nmodule Elt_bin_io = Elt_bin_io\n\nmodule Provide_bin_io (Elt : Elt_bin_io.S) = Bin_prot.Utils.Make_iterable_binable (struct\n type nonrec t = (Elt.t, Elt.comparator_witness) t\n type el = Elt.t [@@deriving bin_io]\n\n let _ = bin_el\n\n let caller_identity =\n Bin_prot.Shape.Uuid.of_string \"8989278e-4992-11e6-8f4a-6b89776b1e53\"\n ;;\n\n let module_name = Some \"Core_kernel.Set\"\n let length = length\n let iter t ~f = iter ~f:(fun key -> f key) t\n\n let init ~len ~next =\n init_for_bin_prot ~len ~f:(fun _ -> next ()) ~comparator:Elt.comparator\n ;;\n end)\n\nmodule Make_plain_using_comparator (Elt : sig\n type t [@@deriving sexp_of]\n\n include Comparator.S with type t := t\n end) =\nstruct\n module Elt = Elt\n module Elt_S1 = Comparator.S_to_S1 (Elt)\n include Creators (Elt_S1)\n\n type ('a, 'b) set = ('a, 'b) t\n type t = (Elt.t, Elt.comparator_witness) set\n type named = (Elt.t, Elt.comparator_witness) Named.t\n\n include Accessors\n\n let compare t1 t2 = compare_direct t1 t2\n let sexp_of_t t = sexp_of_t Elt.sexp_of_t [%sexp_of: _] t\n\n module Provide_of_sexp\n (Elt : sig\n type t [@@deriving of_sexp]\n end\n with type t := Elt.t) =\n struct\n let t_of_sexp sexp = t_of_sexp Elt.t_of_sexp sexp\n end\n\n module Provide_hash (Elt : Hasher.S with type t := Elt.t) = struct\n let hash_fold_t state t = Using_comparator.hash_fold_direct Elt.hash_fold_t state t\n\n let hash t =\n Ppx_hash_lib.Std.Hash.get_hash_value\n (hash_fold_t (Ppx_hash_lib.Std.Hash.create ()) t)\n ;;\n end\n\n module Provide_bin_io\n (Elt' : sig\n type t [@@deriving bin_io]\n end\n with type t := Elt.t) =\n Provide_bin_io (struct\n include Elt\n include Elt'\n end)\n\n module Tree = struct\n include Make_tree (Elt_S1)\n\n type t = (Elt.t, Elt.comparator_witness) tree\n type named = (Elt.t, Elt.comparator_witness) Tree.Named.t\n\n let compare t1 t2 = compare_direct t1 t2\n let sexp_of_t t = Tree.sexp_of_t Elt.sexp_of_t [%sexp_of: _] t\n\n module Provide_of_sexp\n (X : sig\n type t [@@deriving of_sexp]\n end\n with type t := Elt.t) =\n struct\n let t_of_sexp sexp =\n Tree.t_of_sexp_direct X.t_of_sexp sexp ~comparator:Elt_S1.comparator\n ;;\n end\n end\nend\n\nmodule Make_plain (Elt : Elt_plain) = Make_plain_using_comparator (struct\n include Elt\n include Comparator.Make (Elt)\n end)\n\nmodule Make_using_comparator (Elt_sexp : sig\n type t [@@deriving sexp]\n\n include Comparator.S with type t := t\n end) =\nstruct\n include Make_plain_using_comparator (Elt_sexp)\n module Elt = Elt_sexp\n include Provide_of_sexp (Elt)\n\n module Tree = struct\n include Tree\n include Provide_of_sexp (Elt)\n end\nend\n\nmodule Make (Elt : Elt) = Make_using_comparator (struct\n include Elt\n include Comparator.Make (Elt)\n end)\n\nmodule Make_binable_using_comparator (Elt_bin_sexp : sig\n type t [@@deriving bin_io, sexp]\n\n include Comparator.S with type t := t\n end) =\nstruct\n include Make_using_comparator (Elt_bin_sexp)\n module Elt = Elt_bin_sexp\n include Provide_bin_io (Elt)\nend\n\nmodule Make_binable (Elt : Elt_binable) = Make_binable_using_comparator (struct\n include Elt\n include Comparator.Make (Elt)\n end)\n\nmodule For_deriving = struct\n module M = Set.M\n\n let bin_shape_m__t (type t c) (m : (t, c) Elt_bin_io.t) =\n let module M = Provide_bin_io ((val m)) in\n M.bin_shape_t\n ;;\n\n let bin_size_m__t (type t c) (m : (t, c) Elt_bin_io.t) =\n let module M = Provide_bin_io ((val m)) in\n M.bin_size_t\n ;;\n\n let bin_write_m__t (type t c) (m : (t, c) Elt_bin_io.t) =\n let module M = Provide_bin_io ((val m)) in\n M.bin_write_t\n ;;\n\n let bin_read_m__t (type t c) (m : (t, c) Elt_bin_io.t) =\n let module M = Provide_bin_io ((val m)) in\n M.bin_read_t\n ;;\n\n let __bin_read_m__t__ (type t c) (m : (t, c) Elt_bin_io.t) =\n let module M = Provide_bin_io ((val m)) in\n M.__bin_read_t__\n ;;\n\n module type Quickcheck_generator_m = sig\n include Comparator.S\n\n val quickcheck_generator : t Quickcheck.Generator.t\n end\n\n module type Quickcheck_observer_m = sig\n include Comparator.S\n\n val quickcheck_observer : t Quickcheck.Observer.t\n end\n\n module type Quickcheck_shrinker_m = sig\n include Comparator.S\n\n val quickcheck_shrinker : t Quickcheck.Shrinker.t\n end\n\n let quickcheck_generator_m__t\n (type t cmp)\n (module Elt : Quickcheck_generator_m\n with type t = t\n and type comparator_witness = cmp)\n =\n quickcheck_generator (module Elt) Elt.quickcheck_generator\n ;;\n\n let quickcheck_observer_m__t\n (type t cmp)\n (module Elt : Quickcheck_observer_m\n with type t = t\n and type comparator_witness = cmp)\n =\n quickcheck_observer Elt.quickcheck_observer\n ;;\n\n let quickcheck_shrinker_m__t\n (type t cmp)\n (module Elt : Quickcheck_shrinker_m\n with type t = t\n and type comparator_witness = cmp)\n =\n quickcheck_shrinker Elt.quickcheck_shrinker\n ;;\n\n module type For_deriving = Set.For_deriving\n\n include (Set : For_deriving with type ('a, 'b) t := ('a, 'b) t)\nend\n\ninclude For_deriving\n\nmodule Stable = struct\n module V1 = struct\n type nonrec ('a, 'cmp) t = ('a, 'cmp) t\n\n module type S = sig\n type elt\n type elt_comparator_witness\n type nonrec t = (elt, elt_comparator_witness) t\n\n include Stable_module_types.S0_without_comparator with type t := t\n end\n\n include For_deriving\n module Make (Elt : Stable_module_types.S0) = Make_binable_using_comparator (Elt)\n end\nend\n","open! Import\nmodule List = Base.List\ninclude Comparable_intf\nmodule Infix = Base.Comparable.Infix\nmodule Polymorphic_compare = Base.Comparable.Polymorphic_compare\nmodule Validate = Base.Comparable.Validate\n\nmodule With_zero (T : sig\n type t [@@deriving compare, sexp]\n\n val zero : t\n\n include Validate with type t := t\n end) =\n Base.Comparable.With_zero (T)\n\nmodule Validate_with_zero (T : sig\n type t [@@deriving compare, sexp]\n\n val zero : t\n end) =\n Base.Comparable.Validate_with_zero (T)\n\nmodule Map_and_set_binable_using_comparator (T : sig\n type t [@@deriving bin_io, compare, sexp]\n\n include Comparator.S with type t := t\n end) =\nstruct\n include T\n module Map = Map.Make_binable_using_comparator (T)\n module Set = Set.Make_binable_using_comparator (T)\nend\n\nmodule Map_and_set_binable (T : sig\n type t [@@deriving bin_io, compare, sexp]\n end) =\n Map_and_set_binable_using_comparator (struct\n include T\n include Comparator.Make (T)\n end)\n\nmodule Poly (T : sig\n type t [@@deriving sexp]\n end) =\nstruct\n module C = struct\n include T\n include Base.Comparable.Poly (T)\n end\n\n include C\n module Replace_polymorphic_compare : Polymorphic_compare with type t := t = C\n module Map = Map.Make_using_comparator (C)\n module Set = Set.Make_using_comparator (C)\nend\n\nmodule Make_plain_using_comparator (T : sig\n type t [@@deriving sexp_of]\n\n include Comparator.S with type t := t\n end) : S_plain with type t := T.t and type comparator_witness = T.comparator_witness =\nstruct\n include T\n module M = Base.Comparable.Make_using_comparator (T)\n include M\n module Replace_polymorphic_compare : Polymorphic_compare with type t := t = M\n module Map = Map.Make_plain_using_comparator (T)\n module Set = Set.Make_plain_using_comparator (T)\nend\n\nmodule Make_plain (T : sig\n type t [@@deriving compare, sexp_of]\n end) =\n Make_plain_using_comparator (struct\n include T\n include Comparator.Make (T)\n end)\n\nmodule Make_using_comparator (T : sig\n type t [@@deriving sexp]\n\n include Comparator.S with type t := t\n end) : S with type t := T.t and type comparator_witness = T.comparator_witness = struct\n include T\n module M = Base.Comparable.Make_using_comparator (T)\n include M\n module Replace_polymorphic_compare : Polymorphic_compare with type t := t = M\n module Map = Map.Make_using_comparator (T)\n module Set = Set.Make_using_comparator (T)\nend\n\nmodule Make (T : sig\n type t [@@deriving compare, sexp]\n end) : S with type t := T.t = Make_using_comparator (struct\n include T\n include Comparator.Make (T)\n end)\n\nmodule Make_binable_using_comparator (T : sig\n type t [@@deriving bin_io, sexp]\n\n include Comparator.S with type t := t\n end) =\nstruct\n include T\n module M = Base.Comparable.Make_using_comparator (T)\n include M\n module Replace_polymorphic_compare : Polymorphic_compare with type t := t = M\n module Map = Map.Make_binable_using_comparator (T)\n module Set = Set.Make_binable_using_comparator (T)\nend\n\nmodule Make_binable (T : sig\n type t [@@deriving bin_io, compare, sexp]\n end) =\n Make_binable_using_comparator (struct\n include T\n include Comparator.Make (T)\n end)\n\nmodule Extend\n (M : Base.Comparable.S) (X : sig\n type t = M.t [@@deriving sexp]\n end) =\nstruct\n module T = struct\n include M\n\n include (\n X :\n sig\n type t = M.t [@@deriving sexp]\n end\n with type t := t)\n end\n\n include T\n module Replace_polymorphic_compare : Comparisons.S with type t := t = M\n module Map = Map.Make_using_comparator (T)\n module Set = Set.Make_using_comparator (T)\nend\n\nmodule Extend_binable\n (M : Base.Comparable.S) (X : sig\n type t = M.t [@@deriving bin_io, sexp]\n end) =\nstruct\n module T = struct\n include M\n\n include (\n X :\n sig\n type t = M.t [@@deriving bin_io, sexp]\n end\n with type t := t)\n end\n\n include T\n module Replace_polymorphic_compare : Comparisons.S with type t := t = M\n module Map = Map.Make_binable_using_comparator (T)\n module Set = Set.Make_binable_using_comparator (T)\nend\n\nmodule Inherit (C : sig\n type t [@@deriving compare]\n end) (T : sig\n type t [@@deriving sexp]\n\n val component : t -> C.t\n end) =\n Make (struct\n type t = T.t [@@deriving sexp]\n\n let compare t t' = C.compare (T.component t) (T.component t')\n end)\n\nlet lexicographic = Base.Comparable.lexicographic\nlet lift = Base.Comparable.lift\nlet reverse = Base.Comparable.reverse\n\nmodule Stable = struct\n module V1 = struct\n module type S = sig\n type comparable\n type comparator_witness\n\n module Map :\n Map.Stable.V1.S\n with type key := comparable\n with type comparator_witness := comparator_witness\n\n module Set :\n Set.Stable.V1.S\n with type elt := comparable\n with type elt_comparator_witness := comparator_witness\n end\n\n module Make (X : Stable_module_types.S0) = struct\n module Map = Map.Stable.V1.Make (X)\n module Set = Set.Stable.V1.Make (X)\n end\n end\nend\n","(** Doubly-linked lists.\n\n Compared to other doubly-linked lists, in this one:\n\n 1. Calls to modification functions ([insert*], [move*], ...) detect if the list is\n being iterated over ([iter], [fold], ...), and if so raise an exception. For example,\n a use like the following would raise:\n\n {[\n iter t ~f:(fun _ -> ... remove t e ...)\n ]}\n\n 2. There is a designated \"front\" and \"back\" of each list, rather than viewing each\n element as an equal in a ring.\n\n 3. Elements know which list they're in. Each operation that takes an [Elt.t] also\n takes a [t], first checks that the [Elt] belongs to the [t], and if not, raises.\n\n 4. Related to (3), lists cannot be split, though a sort of splicing is available as\n [transfer]. In other words, no operation will cause one list to become two. This\n makes this module unsuitable for maintaining the faces of a planar graph under edge\n insertion and deletion, for example.\n\n 5. Another property permitted by (3) and (4) is that [length] is O(1).\n*)\n\nopen! Import\n\nmodule type S = sig\n module Elt : sig\n type 'a t\n\n val value : 'a t -> 'a\n\n (** pointer equality *)\n val equal : 'a t -> 'a t -> bool\n\n val set : 'a t -> 'a -> unit\n val sexp_of_t : ('a -> Base.Sexp.t) -> 'a t -> Base.Sexp.t\n end\n\n type 'a t [@@deriving compare, sexp]\n\n include Container.S1 with type 'a t := 'a t\n include Invariant.S1 with type 'a t := 'a t\n\n (** {2 Creating doubly-linked lists} *)\n\n val create : unit -> 'a t\n\n (** [of_list l] returns a doubly-linked list [t] with the same elements as [l] and in the\n same order (i.e., the first element of [l] is the first element of [t]). It is always\n the case that [l = to_list (of_list l)]. *)\n val of_list : 'a list -> 'a t\n\n val of_array : 'a array -> 'a t\n\n (** {2 Predicates} *)\n\n (** pointer equality *)\n val equal : 'a t -> 'a t -> bool\n\n val is_first : 'a t -> 'a Elt.t -> bool\n val is_last : 'a t -> 'a Elt.t -> bool\n val mem_elt : 'a t -> 'a Elt.t -> bool\n\n (** {2 Constant-time extraction of first and last elements} *)\n\n val first_elt : 'a t -> 'a Elt.t option\n val last_elt : 'a t -> 'a Elt.t option\n val first : 'a t -> 'a option\n val last : 'a t -> 'a option\n\n (** {2 Constant-time retrieval of next or previous element} *)\n\n val next : 'a t -> 'a Elt.t -> 'a Elt.t option\n val prev : 'a t -> 'a Elt.t -> 'a Elt.t option\n\n (** {2 Constant-time insertion of a new element} *)\n\n val insert_before : 'a t -> 'a Elt.t -> 'a -> 'a Elt.t\n val insert_after : 'a t -> 'a Elt.t -> 'a -> 'a Elt.t\n val insert_first : 'a t -> 'a -> 'a Elt.t\n val insert_last : 'a t -> 'a -> 'a Elt.t\n\n (** {2 Constant-time move of an element from and to positions in the same list}\n\n An exception is raised if [elt] is equal to [anchor]. *)\n\n val move_to_front : 'a t -> 'a Elt.t -> unit\n val move_to_back : 'a t -> 'a Elt.t -> unit\n val move_after : 'a t -> 'a Elt.t -> anchor:'a Elt.t -> unit\n val move_before : 'a t -> 'a Elt.t -> anchor:'a Elt.t -> unit\n\n (** {2 Constant-time removal of an element} *)\n\n val remove : 'a t -> 'a Elt.t -> unit\n val remove_first : 'a t -> 'a option\n val remove_last : 'a t -> 'a option\n val iteri : 'a t -> f:(int -> 'a -> unit) -> unit\n val foldi : 'a t -> init:'b -> f:(int -> 'b -> 'a -> 'b) -> 'b\n\n (** [fold_elt t ~init ~f] is the same as fold, except [f] is called with the ['a Elt.t]'s\n from the list instead of the contained ['a] values.\n\n Note that like other iteration functions, it is an error to mutate [t] inside the\n fold. If you'd like to call [remove] on any of the ['a Elt.t]'s, use\n [filter_inplace]. *)\n val fold_elt : 'a t -> init:'b -> f:('b -> 'a Elt.t -> 'b) -> 'b\n\n val foldi_elt : 'a t -> init:'b -> f:(int -> 'b -> 'a Elt.t -> 'b) -> 'b\n val iter_elt : 'a t -> f:('a Elt.t -> unit) -> unit\n val iteri_elt : 'a t -> f:(int -> 'a Elt.t -> unit) -> unit\n\n\n val fold_right : 'a t -> init:'b -> f:('a -> 'b -> 'b) -> 'b\n val fold_right_elt : 'a t -> init:'b -> f:('a Elt.t -> 'b -> 'b) -> 'b\n\n (** [find_elt t ~f] finds the first element in [t] that satisfies [f], by testing each of\n element of [t] in turn until [f] succeeds. *)\n val find_elt : 'a t -> f:('a -> bool) -> 'a Elt.t option\n\n val findi_elt : 'a t -> f:(int -> 'a -> bool) -> (int * 'a Elt.t) option\n\n (** [clear t] removes all elements from the list in constant time. *)\n val clear : 'a t -> unit\n\n val copy : 'a t -> 'a t\n\n (** [transfer ~src ~dst] has the same behavior as\n [iter src ~f:(insert_last dst); clear src] except that it runs in constant time.\n\n If [s = to_list src] and [d = to_list dst], then after [transfer ~src ~dst]:\n\n [to_list src = []]\n\n [to_list dst = d @ s] *)\n val transfer : src:'a t -> dst:'a t -> unit\n\n (** {2 Linear-time mapping of lists (creates a new list)} *)\n\n val map : 'a t -> f:('a -> 'b) -> 'b t\n val mapi : 'a t -> f:(int -> 'a -> 'b) -> 'b t\n val filter : 'a t -> f:('a -> bool) -> 'a t\n val filteri : 'a t -> f:(int -> 'a -> bool) -> 'a t\n val filter_map : 'a t -> f:('a -> 'b option) -> 'b t\n val filter_mapi : 'a t -> f:(int -> 'a -> 'b option) -> 'b t\n\n (** {2 Linear-time partition of lists (creates two new lists)} *)\n\n val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t\n val partitioni_tf : 'a t -> f:(int -> 'a -> bool) -> 'a t * 'a t\n val partition_map : 'a t -> f:('a -> ('b, 'c) Either.t) -> 'b t * 'c t\n val partition_mapi : 'a t -> f:(int -> 'a -> ('b, 'c) Either.t) -> 'b t * 'c t\n\n (** {2 Linear-time in-place mapping of lists} *)\n\n (** [map_inplace t ~f] replaces all values [v] with [f v] *)\n val map_inplace : 'a t -> f:('a -> 'a) -> unit\n\n val mapi_inplace : 'a t -> f:(int -> 'a -> 'a) -> unit\n\n (** [filter_inplace t ~f] removes all elements of [t] that don't satisfy [f]. *)\n val filter_inplace : 'a t -> f:('a -> bool) -> unit\n\n val filteri_inplace : 'a t -> f:(int -> 'a -> bool) -> unit\n\n (** If [f] returns [None], the element is removed, else the value is replaced with the\n contents of the [Some] *)\n val filter_map_inplace : 'a t -> f:('a -> 'a option) -> unit\n\n val filter_mapi_inplace : 'a t -> f:(int -> 'a -> 'a option) -> unit\n\n (** [unchecked_iter t ~f] behaves like [iter t ~f] except that [f] is allowed to modify\n [t]. Adding or removing elements before the element currently being visited has no\n effect on the traversal. Elements added after the element currently being visited\n will be traversed. Elements deleted after the element currently being visited will\n not be traversed. Deleting the element currently being visited is an error that is not\n detected (presumably leading to an infinite loop). *)\n val unchecked_iter : 'a t -> f:('a -> unit) -> unit\n\n\n (** A sequence of values from the doubly-linked list. It makes an intermediate copy of the\n list so that the returned sequence is immune to any subsequent mutation of the\n original list. *)\n val to_sequence : 'a t -> 'a Sequence.t\nend\n\nmodule type Doubly_linked = sig\n module type S = S\n\n include S\nend\n","include List0 (** @inline *)\n\n(** [stable_dedup] Same as [dedup] but maintains the order of the list and doesn't allow\n compare function to be specified (otherwise, the implementation in terms of Set.t\n would hide a heavyweight functor instantiation at each call). *)\nlet stable_dedup = Set.Poly.stable_dedup_list\n\n(* This function is staged to indicate that real work (the functor application) takes\n place after a partial application. *)\nlet stable_dedup_staged (type a) ~(compare : a -> a -> int)\n : (a list -> a list) Base.Staged.t\n =\n let module Set =\n Set.Make (struct\n type t = a\n\n let compare = compare\n\n (* [stable_dedup_list] never calls these *)\n let t_of_sexp _ = assert false\n let sexp_of_t _ = assert false\n end)\n in\n Base.Staged.stage Set.stable_dedup_list\n;;\n\nlet zip_with_remainder =\n let rec zip_with_acc_and_remainder acc xs ys =\n match xs, ys with\n | [], [] -> rev acc, None\n | fst, [] -> rev acc, Some (Either.First fst)\n | [], snd -> rev acc, Some (Either.Second snd)\n | x :: xs, y :: ys -> zip_with_acc_and_remainder ((x, y) :: acc) xs ys\n in\n fun xs ys -> zip_with_acc_and_remainder [] xs ys\n;;\n\ntype sexp_thunk = unit -> Base.Sexp.t\n\nlet sexp_of_sexp_thunk x = x ()\n\nexception Duplicate_found of sexp_thunk * Base.String.t [@@deriving sexp]\n\nlet exn_if_dup ~compare ?(context = \"exn_if_dup\") t ~to_sexp =\n match find_a_dup ~compare t with\n | None -> ()\n | Some dup -> raise (Duplicate_found ((fun () -> to_sexp dup), context))\n;;\n\nlet slice a start stop =\n Ordered_collection_common.slice ~length_fun:length ~sub_fun:sub a start stop\n;;\n\nmodule Stable = struct\n module V1 = struct\n type nonrec 'a t = 'a t [@@deriving sexp, bin_io, compare]\n end\nend\n","open! Import\ninclude Base.Option\n\ntype 'a t = 'a option [@@deriving bin_io, typerep]\n\ninclude Comparator.Derived (struct\n type nonrec 'a t = 'a t [@@deriving sexp_of, compare]\n end)\n\nlet quickcheck_generator = Base_quickcheck.Generator.option\nlet quickcheck_observer = Base_quickcheck.Observer.option\nlet quickcheck_shrinker = Base_quickcheck.Shrinker.option\n\nmodule Stable = struct\n module V1 = struct\n type nonrec 'a t = 'a t [@@deriving bin_io, compare, equal, sexp]\n end\nend\n\nmodule Optional_syntax = struct\n module Optional_syntax = struct\n let is_none = is_none\n\n (* [unsafe_value] is only safe to call when [is_none] returns [false]. To avoid\n repeating the [is_none] check, we declare [Unchecked_some]. [Unchecked_some x]\n has the same representation as [Some x], but the type has no [None] clause.\n\n We make sure all this works with tests of [unsafe_value] in test_option.ml.\n\n We tried using [Obj.field] instead. It generates much worse native code due to\n float array representations. *)\n\n module Unchecked_some = struct\n (* Warning 37 tells us [Unchecked_some] is never used as a constructor. This is\n intentional, so we disable the warning. *)\n type 'a t = Unchecked_some of 'a [@@ocaml.boxed] [@@ocaml.warning \"-37\"]\n end\n\n let unsafe_value (type a) (t : a t) : a =\n let (Unchecked_some value) = (Obj.magic t : a Unchecked_some.t) in\n value\n ;;\n end\nend\n","(* This code is based on the MLton library set/disjoint.fun, which has the\n following copyright notice.\n*)\n(* Copyright (C) 1999-2005 Henry Cejtin, Matthew Fluet, Suresh\n * Jagannathan, and Stephen Weeks.\n *\n * MLton is released under a BSD-style license.\n * See the file MLton-LICENSE for details.\n*)\n\nopen! Import\n\n(*\n {v\n Root\n |\n Inner\n / .. | .. \\\n Inner Inner Inner\n /|\\ /|\\ /|\\\n ... ... ...\n v}\n\n We construct the `inverted' tree in the ML representation.\n The direction of the edges is UPWARDS.\n Starting with any ['a t] we can step directly to its parent.\n But we can't (and don't need to) start from the root and step to its children.\n*)\n\n(*\n [rank] is an upper bound on the depth of any node in the up-tree.\n\n Imagine an unlucky sequence of operations in which you create N\n individual [t]-values and then union them together in such a way\n that you always pick the root of each tree to union together, so that\n no path compression takes place. If you don't take care to somehow\n balance the resulting up-tree, it is possible that you end up with one\n big long chain of N links, and then calling [representative] on the\n deepest node takes Theta(N) time. With the balancing scheme of never\n increasing the rank of a node unnecessarily, it would take O(log N).\n*)\ntype 'a root =\n { mutable value : 'a\n ; mutable rank : int\n }\n\ntype 'a t = { mutable node : 'a node }\n\nand 'a node =\n | Inner of 'a t\n (* [Inner x] is a node whose parent is [x]. *)\n | Root of 'a root\n\nlet invariant _ t =\n let rec loop t depth =\n match t.node with\n | Inner t -> loop t (depth + 1)\n | Root r -> assert (depth <= r.rank)\n in\n loop t 0\n;;\n\nlet create v = { node = Root { value = v; rank = 0 } }\n\n(* invariants:\n [inner.node] = [inner_node] = [Inner t].\n [descendants] are the proper descendants of [inner] we've visited.\n*)\nlet rec compress t ~inner_node ~inner ~descendants =\n match t.node with\n | Root r ->\n (* t is the root of the tree.\n Re-point all descendants directly to it by setting them to [Inner t].\n Note: we don't re-point [inner] as it already points there. *)\n List.iter descendants ~f:(fun t -> t.node <- inner_node);\n t, r\n | Inner t' as node ->\n compress t' ~inner_node:node ~inner:t ~descendants:(inner :: descendants)\n;;\n\nlet representative t =\n match t.node with\n | Root r -> t, r\n | Inner t' as node -> compress t' ~inner_node:node ~inner:t ~descendants:[]\n;;\n\nlet root t =\n match t.node with\n | Root r ->\n (* avoid tuple allocation in the fast path *)\n r\n | _ -> snd (representative t)\n;;\n\nlet rank t = (root t).rank\nlet get t = (root t).value\nlet set t v = (root t).value <- v\nlet same_class t1 t2 = phys_equal (root t1) (root t2)\n\nlet union t1 t2 =\n let t1, r1 = representative t1 in\n let t2, r2 = representative t2 in\n if phys_equal r1 r2\n then ()\n else (\n let n1 = r1.rank in\n let n2 = r2.rank in\n if n1 < n2\n then t1.node <- Inner t2\n else (\n t2.node <- Inner t1;\n if n1 = n2 then r1.rank <- r1.rank + 1))\n;;\n\nlet is_compressed t =\n invariant ignore t;\n match t.node with\n | Root _ -> true\n | Inner t ->\n (match t.node with\n | Root _ -> true\n | Inner _ -> false)\n;;\n\nmodule Private = struct\n let is_compressed = is_compressed\n let rank = rank\nend\n","open! Import\ninclude Doubly_linked_intf\n\n(* INVARIANT: This exception is raised if a list is mutated during a pending iteration.\n\n This invariant is guaranteed by the Header and Elt modules in conjunction. All\n downstream code in this module need not be concerned with this invariant.\n*)\nexception Attempt_to_mutate_list_during_iteration\n\nlet phys_equal = ( == )\n\nmodule Header : sig\n type t\n\n val create : unit -> t\n val length : t -> int\n val equal : t -> t -> bool\n val incr_length : by:int -> t -> unit\n val check_no_pending_iterations : t -> unit\n\n (* Unfortunate, but by specializing [with_iteration] for different arities, a large\n amount of allocation during folds and iterations is avoided.\n\n The original type of [with_iteration] was\n [val with_iteration : t -> (unit -> 'a) -> 'a]\n\n The difference between\n {[\n let x = e in\n let f () = g x in\n f ()\n ]}\n and\n {[\n let x = e in\n let f x = g x in\n f x\n ]}\n is that in the first case the closure for [f] contains a pointer to [x],\n and in the second case it doesn't. A closure without pointers to enclosing\n environment is implemented as a naked function pointer, so we don't\n allocate at all.\n\n For the same reason we make sure not to call [Result.try_with (fun () -> ...)]\n inside [with_iteration] and do an explicit match statement instead. *)\n\n val with_iteration_2 : t -> 'a -> 'b -> ('a -> 'b -> 'c) -> 'c\n val with_iteration_3 : t -> 'a -> 'b -> 'c -> ('a -> 'b -> 'c -> 'd) -> 'd\n val with_iteration_4 : t -> 'a -> 'b -> 'c -> 'd -> ('a -> 'b -> 'c -> 'd -> 'e) -> 'e\n val merge : t -> t -> [ `Same_already | `Merged ]\nend = struct\n type s =\n { mutable length : int\n ;\n mutable pending_iterations : int\n }\n\n type t = s Union_find.t\n\n let create () = Union_find.create { length = 1; pending_iterations = 0 }\n let equal (t1 : t) t2 = Union_find.same_class t1 t2\n let length t = (Union_find.get t).length\n\n let union_find_get__check_no_pending_iterations t =\n let s = Union_find.get t in\n if s.pending_iterations > 0 then raise Attempt_to_mutate_list_during_iteration else s\n ;;\n\n let check_no_pending_iterations t =\n ignore (union_find_get__check_no_pending_iterations t : s)\n ;;\n\n let incr_length ~by:n t =\n let s = union_find_get__check_no_pending_iterations t in\n s.length <- s.length + n\n ;;\n\n (* Care is taken not to allocate in [with_iteration_*], since it is called every second\n by [every_second] in [writer0.ml] *)\n\n let incr_pending_iters s = s.pending_iterations <- s.pending_iterations + 1\n let decr_pending_iters s = s.pending_iterations <- s.pending_iterations - 1\n\n let with_iteration_2 t a b f =\n let s = Union_find.get t in\n incr_pending_iters s;\n match f a b with\n | exception exn ->\n decr_pending_iters s;\n raise exn\n | r ->\n decr_pending_iters s;\n r\n ;;\n\n let with_iteration_3 t a b c f =\n let s = Union_find.get t in\n incr_pending_iters s;\n match f a b c with\n | exception exn ->\n decr_pending_iters s;\n raise exn\n | r ->\n decr_pending_iters s;\n r\n ;;\n\n let with_iteration_4 t a b c d f =\n let s = Union_find.get t in\n incr_pending_iters s;\n match f a b c d with\n | exception exn ->\n decr_pending_iters s;\n raise exn\n | r ->\n decr_pending_iters s;\n r\n ;;\n\n let merge (t1 : t) t2 =\n if Union_find.same_class t1 t2\n then `Same_already\n else (\n let n1 = (union_find_get__check_no_pending_iterations t1).length in\n let n2 = (union_find_get__check_no_pending_iterations t2).length in\n with_iteration_4 t1 t1 t2 n1 n2 (fun t1 t2 n1 n2 ->\n with_iteration_4 t2 t1 t2 n1 n2 (fun t1 t2 n1 n2 ->\n Union_find.union t1 t2;\n Union_find.set t1 { length = n1 + n2; pending_iterations = 0 }));\n `Merged)\n ;;\nend\n\nmodule Elt : sig\n type 'a t [@@deriving sexp_of]\n\n val header : 'a t -> Header.t\n val equal : 'a t -> 'a t -> bool\n val create : 'a -> 'a t\n val value : 'a t -> 'a\n val set : 'a t -> 'a -> unit\n val unlink : 'a t -> unit\n val split_or_splice_before : 'a t -> 'a t -> unit\n val split_or_splice_after : 'a t -> 'a t -> unit\n val insert_after : 'a t -> 'a -> 'a t\n val insert_before : 'a t -> 'a -> 'a t\n val unlink_before : 'a t -> 'a t\n val next : 'a t -> 'a t\n val prev : 'a t -> 'a t\nend = struct\n type 'a t =\n { mutable value : 'a\n ; mutable prev : 'a t\n ; mutable next : 'a t\n ; mutable header : Header.t\n }\n\n let equal = phys_equal\n let next t = t.next\n let prev t = t.prev\n let header t = t.header\n\n let create_aux v header =\n let rec t = { value = v; prev = t; next = t; header } in\n t\n ;;\n\n let is_singleton t = equal t t.prev\n let sexp_of_t sexp_of_a t = sexp_of_a t.value\n let create v = create_aux v (Header.create ())\n let value t = t.value\n let set t v = t.value <- v\n\n (*\n [split_or_splice] is sufficient as the lone primitive for\n accomplishing all pointer updates on cyclic loops of list nodes.\n It takes two \"gaps\" between adjacent linked list nodes. If the gaps\n point into the same list, the result is that it will be split into\n two lists afterwards. If the gaps point into different lists, the\n result is that they will be spliced together into one list afterwards.\n\n {v\n Before After\n -----+ +----- -----+ +-----\n A | <--> | B A | <--- ---> | B\n -----+ +----- -----+ \\ / +-----\n X\n -----+ +----- -----+ / \\ +-----\n C | <--> | D C | <--- ---> | D\n -----+ +----- -----+ +-----\n v} *)\n\n let unsafe_split_or_splice ~prev1:a ~next1:b ~prev2:c ~next2:d =\n a.next <- d;\n d.prev <- a;\n c.next <- b;\n b.prev <- c\n ;;\n\n let unsafe_split_or_splice_after t1 t2 =\n unsafe_split_or_splice\n ~next1:t1.next\n ~prev1:t1.next.prev\n ~next2:t2.next\n ~prev2:t2.next.prev\n ;;\n\n let unsafe_split_or_splice_before t1 t2 =\n unsafe_split_or_splice\n ~prev1:t1.prev\n ~next1:t1.prev.next\n ~prev2:t2.prev\n ~next2:t2.prev.next\n ;;\n\n let check_two_nodes_no_pending_iterations t1 t2 =\n Header.check_no_pending_iterations t1.header;\n if not (Header.equal t1.header t2.header)\n then Header.check_no_pending_iterations t2.header\n ;;\n\n (* We redefine safe versions for export *)\n let split_or_splice_after t1 t2 =\n check_two_nodes_no_pending_iterations t1 t2;\n unsafe_split_or_splice_after t1 t2\n ;;\n\n let split_or_splice_before t1 t2 =\n check_two_nodes_no_pending_iterations t1 t2;\n unsafe_split_or_splice_before t1 t2\n ;;\n\n let insert_before t v =\n Header.incr_length t.header ~by:1;\n let node = create_aux v t.header in\n unsafe_split_or_splice_before t node;\n node\n ;;\n\n let insert_after t v =\n Header.incr_length t.header ~by:1;\n let node = create_aux v t.header in\n unsafe_split_or_splice_after t node;\n node\n ;;\n\n let dummy_header = Header.create ()\n\n let unlink_before t =\n let node = t.prev in\n if is_singleton node\n then node\n else (\n Header.incr_length t.header ~by:(-1);\n unsafe_split_or_splice_before t node;\n node.header <- dummy_header;\n node)\n ;;\n\n let unlink_after t =\n let node = t.next in\n if is_singleton node\n then node\n else (\n Header.incr_length t.header ~by:(-1);\n unsafe_split_or_splice_after t node;\n node.header <- dummy_header;\n node)\n ;;\n\n let unlink t = ignore (unlink_after t.prev : _ t)\nend\n\ntype 'a t = 'a Elt.t option ref\n\nlet invariant invariant_a t =\n match !t with\n | None -> ()\n | Some head ->\n let header = Elt.header head in\n let rec loop n elt =\n let next_elt = Elt.next elt in\n let prev_elt = Elt.prev elt in\n assert (Elt.equal elt (Elt.prev next_elt));\n assert (Elt.equal elt (Elt.next prev_elt));\n assert (Header.equal (Elt.header elt) header);\n invariant_a (Elt.value elt);\n if Elt.equal next_elt head then n else loop (n + 1) next_elt\n in\n let len = loop 1 head in\n assert (len = Header.length header)\n;;\n\nlet create (type a) () : a t = ref None\nlet equal (t : _ t) t' = phys_equal t t'\n\nlet of_list = function\n | [] -> create ()\n | x :: xs ->\n let first = Elt.create x in\n let _last = List.fold xs ~init:first ~f:Elt.insert_after in\n ref (Some first)\n;;\n\nlet of_array = function\n | [||] -> create ()\n | arr ->\n let first = Elt.create arr.(0) in\n let rec loop arr elt i =\n if i < Array.length arr then loop arr (Elt.insert_after elt arr.(i)) (i + 1)\n in\n loop arr first 1;\n ref (Some first)\n;;\n\nlet map t ~f =\n match !t with\n | None -> create ()\n | Some first ->\n let new_first = Elt.create (f (Elt.value first)) in\n Header.with_iteration_3\n (Elt.header first)\n f\n new_first\n first\n (fun f new_first first ->\n let rec loop f acc first elt =\n let acc = Elt.insert_after acc (f (Elt.value elt)) in\n let next = Elt.next elt in\n if not (phys_equal next first) then loop f acc first next\n in\n (* unroll and skip first elt *)\n let next = Elt.next first in\n if not (phys_equal next first) then loop f new_first first next);\n ref (Some new_first)\n;;\n\nlet mapi t ~f =\n match !t with\n | None -> create ()\n | Some first ->\n let new_first = Elt.create (f 0 (Elt.value first)) in\n Header.with_iteration_3\n (Elt.header first)\n f\n new_first\n first\n (fun f new_first first ->\n let rec loop f i acc first elt =\n let acc = Elt.insert_after acc (f i (Elt.value elt)) in\n let next = Elt.next elt in\n if not (phys_equal next first) then loop f (i + 1) acc first next\n in\n (* unroll and skip first elt *)\n let next = Elt.next first in\n if not (phys_equal next first) then loop f 1 new_first first next);\n ref (Some new_first)\n;;\n\nlet fold_elt t ~init ~f =\n match !t with\n | None -> init\n | Some first ->\n Header.with_iteration_3 (Elt.header first) f init first (fun f init first ->\n let rec loop f acc first elt =\n let acc = f acc elt in\n let next = Elt.next elt in\n if phys_equal next first then acc else loop f acc first next\n in\n loop f init first first)\n;;\n\nlet foldi_elt t ~init ~f =\n match !t with\n | None -> init\n | Some first ->\n Header.with_iteration_3 (Elt.header first) f init first (fun f init first ->\n let rec loop f i acc first elt =\n let acc = f i acc elt in\n let next = Elt.next elt in\n if phys_equal next first then acc else loop f (i + 1) acc first next\n in\n loop f 0 init first first)\n;;\n\nlet fold_elt_1 t ~init ~f a =\n match !t with\n | None -> init\n | Some first ->\n Header.with_iteration_4 (Elt.header first) f a init first (fun f a init first ->\n let rec loop f a acc first elt =\n let acc = f a acc elt in\n let next = Elt.next elt in\n if phys_equal next first then acc else loop f a acc first next\n in\n loop f a init first first)\n;;\n\nlet foldi_elt_1 t ~init ~f a =\n match !t with\n | None -> init\n | Some first ->\n Header.with_iteration_4 (Elt.header first) f a init first (fun f a init first ->\n let rec loop f i a acc first elt =\n let acc = f i a acc elt in\n let next = Elt.next elt in\n if phys_equal next first then acc else loop f (i + 1) a acc first next\n in\n loop f 0 a init first first)\n;;\n\nlet iter_elt t ~f = fold_elt_1 t ~init:() ~f:(fun f () elt -> f elt) f\nlet iteri_elt t ~f = foldi_elt t ~init:() ~f:(fun i () elt -> f i elt)\n\nopen With_return\n\nlet find_elt t ~f =\n with_return (fun r ->\n fold_elt_1 t f ~init:() ~f:(fun f () elt ->\n if f (Elt.value elt) then r.return (Some elt));\n None)\n;;\n\nlet findi_elt t ~f =\n with_return (fun r ->\n foldi_elt_1 t f ~init:() ~f:(fun i f () elt ->\n if f i (Elt.value elt) then r.return (Some (i, elt)));\n None)\n;;\n\n(* this function is lambda lifted for performance, to make direct recursive calls instead\n of calls through its closure. It also avoids the initial closure allocation. *)\nlet rec iter_loop first f elt =\n f (Elt.value elt);\n let next = Elt.next elt in\n if not (phys_equal next first) then iter_loop first f next\n;;\n\nlet iter t ~f =\n match !t with\n | None -> ()\n | Some first ->\n Header.with_iteration_2 (Elt.header first) first f (fun first f ->\n iter_loop first f first)\n;;\n\nlet length t =\n match !t with\n | None -> 0\n | Some first -> Header.length (Elt.header first)\n;;\n\nlet rec iteri_loop first f i elt =\n f i (Elt.value elt);\n let next = Elt.next elt in\n if not (phys_equal next first) then iteri_loop first f (i + 1) next\n;;\n\nlet iteri t ~f =\n match !t with\n | None -> ()\n | Some first ->\n Header.with_iteration_2 (Elt.header first) first f (fun first f ->\n iteri_loop first f 0 first)\n;;\n\nlet foldi t ~init ~f =\n foldi_elt_1 t ~init f ~f:(fun i f acc elt -> f i acc (Elt.value elt))\n;;\n\nmodule C = Container.Make (struct\n type nonrec 'a t = 'a t\n\n let fold t ~init ~f = fold_elt_1 t ~init f ~f:(fun f acc elt -> f acc (Elt.value elt))\n let iter = `Custom iter\n let length = `Custom length\n end)\n\nlet count = C.count\nlet sum = C.sum\nlet exists = C.exists\nlet find = C.find\nlet find_map = C.find_map\nlet fold = C.fold\nlet for_all = C.for_all\nlet mem = C.mem\nlet to_array = C.to_array\nlet min_elt = C.min_elt\nlet max_elt = C.max_elt\nlet fold_result = C.fold_result\nlet fold_until = C.fold_until\n\nlet unchecked_iter t ~f =\n match !t with\n | None -> ()\n | Some first ->\n let rec loop t f elt =\n f (Elt.value elt);\n let next = Elt.next elt in\n match !t with\n (* the first element of the bag may have been changed by [f] *)\n | None -> ()\n | Some first -> if not (phys_equal first next) then loop t f next\n in\n loop t f first\n;;\n\nlet is_empty t = Option.is_none !t\n\n(* more efficient than what Container.Make returns *)\n\nlet fold_right t ~init ~f =\n match !t with\n | None -> init\n | Some first ->\n Header.with_iteration_3 (Elt.header first) f init first (fun f init first ->\n let rec loop f acc elt =\n let prev = Elt.prev elt in\n let acc = f (Elt.value prev) acc in\n if phys_equal prev first then acc else loop f acc prev\n in\n loop f init first)\n;;\n\nlet fold_right_elt t ~init ~f =\n match !t with\n | None -> init\n | Some first ->\n Header.with_iteration_3 (Elt.header first) f init first (fun f init first ->\n let rec loop f acc elt =\n let prev = Elt.prev elt in\n let acc = f prev acc in\n if phys_equal prev first then acc else loop f acc prev\n in\n loop f init first)\n;;\n\nlet to_list t = fold_right t ~init:[] ~f:(fun x tl -> x :: tl)\nlet sexp_of_t sexp_of_a t = List.sexp_of_t sexp_of_a (to_list t)\nlet t_of_sexp a_of_sexp s = of_list (List.t_of_sexp a_of_sexp s)\nlet copy t = of_list (to_list t)\nlet clear t = t := None\n\nlet compare compare_elt t1 t2 =\n match !t1, !t2 with\n | None, None -> 0\n | None, _ -> -1\n | _, None -> 1\n | Some f1, Some f2 ->\n Header.with_iteration_3 (Elt.header f1) compare_elt f1 f2 (fun compare_elt f1 f2 ->\n Header.with_iteration_3\n (Elt.header f2)\n compare_elt\n f1\n f2\n (fun compare_elt f1 f2 ->\n let rec loop compare_elt elt1 f1 elt2 f2 =\n let compare_result = compare_elt (Elt.value elt1) (Elt.value elt2) in\n if compare_result <> 0\n then compare_result\n else (\n let next1 = Elt.next elt1 in\n let next2 = Elt.next elt2 in\n match phys_equal next1 f1, phys_equal next2 f2 with\n | true, true -> 0\n | true, false -> -1\n | false, true -> 1\n | false, false -> loop compare_elt next1 f1 next2 f2)\n in\n loop compare_elt f1 f1 f2 f2))\n;;\n\nexception Transfer_src_and_dst_are_same_list\n\nlet transfer ~src ~dst =\n if phys_equal src dst then raise Transfer_src_and_dst_are_same_list;\n match !src with\n | None -> ()\n | Some src_head ->\n (match !dst with\n | None ->\n dst := Some src_head;\n clear src\n | Some dst_head ->\n (match Header.merge (Elt.header src_head) (Elt.header dst_head) with\n | `Same_already -> raise Transfer_src_and_dst_are_same_list\n | `Merged ->\n Elt.split_or_splice_before dst_head src_head;\n clear src))\n;;\n\nlet map_inplace t ~f = iter_elt t ~f:(fun elt -> Elt.set elt (f (Elt.value elt)))\nlet mapi_inplace t ~f = iteri_elt t ~f:(fun i elt -> Elt.set elt (f i (Elt.value elt)))\n\nlet remove_list t to_remove =\n List.iter to_remove ~f:(fun elt ->\n (match !t with\n | None -> ()\n | Some head ->\n if Elt.equal head elt\n then (\n let next_elt = Elt.next elt in\n t := if Elt.equal head next_elt then None else Some next_elt));\n Elt.unlink elt)\n;;\n\nlet filter_inplace t ~f =\n let to_remove =\n List.rev\n (fold_elt t ~init:[] ~f:(fun elts elt ->\n if f (Elt.value elt) then elts else elt :: elts))\n in\n remove_list t to_remove\n;;\n\nlet filteri_inplace t ~f =\n let to_remove =\n List.rev\n (foldi_elt t ~init:[] ~f:(fun i elts elt ->\n if f i (Elt.value elt) then elts else elt :: elts))\n in\n remove_list t to_remove\n;;\n\nlet filter_map_inplace t ~f =\n let to_remove =\n List.rev\n (fold_elt t ~init:[] ~f:(fun elts elt ->\n match f (Elt.value elt) with\n | None -> elt :: elts\n | Some value ->\n Elt.set elt value;\n elts))\n in\n remove_list t to_remove\n;;\n\nlet filter_mapi_inplace t ~f =\n let to_remove =\n List.rev\n (foldi_elt t ~init:[] ~f:(fun i elts elt ->\n match f i (Elt.value elt) with\n | None -> elt :: elts\n | Some value ->\n Elt.set elt value;\n elts))\n in\n remove_list t to_remove\n;;\n\nexception Elt_does_not_belong_to_list\n\nlet first_elt t = !t\nlet last_elt t = Option.map ~f:Elt.prev !t\nlet first t = Option.map ~f:Elt.value (first_elt t)\nlet last t = Option.map ~f:Elt.value (last_elt t)\n\nlet is_first t elt =\n match !t with\n | None -> raise Elt_does_not_belong_to_list\n | Some first ->\n if Header.equal (Elt.header first) (Elt.header elt)\n then Elt.equal elt first\n else raise Elt_does_not_belong_to_list\n;;\n\nlet is_last t elt =\n match !t with\n | None -> raise Elt_does_not_belong_to_list\n | Some first ->\n if Header.equal (Elt.header first) (Elt.header elt)\n then (\n let last = Elt.prev first in\n Elt.equal elt last)\n else raise Elt_does_not_belong_to_list\n;;\n\nlet mem_elt t elt =\n match !t with\n | None -> false\n | Some first -> Header.equal (Elt.header first) (Elt.header elt)\n;;\n\nlet prev t elt =\n match !t with\n | None -> raise Elt_does_not_belong_to_list\n | Some first ->\n if Elt.equal elt first\n then None\n else if Header.equal (Elt.header first) (Elt.header elt)\n then Some (Elt.prev elt)\n else raise Elt_does_not_belong_to_list\n;;\n\nlet next t elt =\n match !t with\n | None -> raise Elt_does_not_belong_to_list\n | Some first ->\n let last = Elt.prev first in\n if Elt.equal elt last\n then None\n else if Header.equal (Elt.header first) (Elt.header elt)\n then Some (Elt.next elt)\n else raise Elt_does_not_belong_to_list\n;;\n\nlet insert_after t elt v =\n match !t with\n | None -> raise Elt_does_not_belong_to_list\n | Some first ->\n if Header.equal (Elt.header first) (Elt.header elt)\n then Elt.insert_after elt v\n else raise Elt_does_not_belong_to_list\n;;\n\nlet insert_before t elt v =\n match !t with\n | None -> raise Elt_does_not_belong_to_list\n | Some first ->\n if Elt.equal elt first\n then (\n let new_elt = Elt.insert_before first v in\n t := Some new_elt;\n new_elt)\n else if Header.equal (Elt.header first) (Elt.header elt)\n then Elt.insert_before elt v\n else raise Elt_does_not_belong_to_list\n;;\n\nlet insert_empty t v =\n let new_elt = Elt.create v in\n t := Some new_elt;\n new_elt\n;;\n\nlet insert_last t v =\n match !t with\n | None -> insert_empty t v\n | Some first -> Elt.insert_before first v\n;;\n\nlet insert_first t v =\n match !t with\n | None -> insert_empty t v\n | Some first ->\n let new_elt = Elt.insert_before first v in\n t := Some new_elt;\n new_elt\n;;\n\nlet remove_last t =\n match !t with\n | None -> None\n | Some first ->\n let last = Elt.unlink_before first in\n if Elt.equal first last then t := None;\n Some (Elt.value last)\n;;\n\nlet remove_first t =\n match !t with\n | None -> None\n | Some first ->\n let second = Elt.next first in\n Elt.unlink first;\n t := if Elt.equal first second then None else Some second;\n Some (Elt.value first)\n;;\n\nlet remove t elt =\n match !t with\n | None -> raise Elt_does_not_belong_to_list\n | Some first ->\n if Elt.equal elt first\n then ignore (remove_first t : _ option)\n else if Header.equal (Elt.header first) (Elt.header elt)\n then Elt.unlink elt\n else raise Elt_does_not_belong_to_list\n;;\n\nlet filter t ~f =\n let new_t = create () in\n (match !t with\n | None -> ()\n | Some first ->\n Header.with_iteration_3 (Elt.header first) f new_t first (fun f new_t first ->\n let rec loop f new_t first elt =\n if f (Elt.value elt)\n then insert_last new_t (Elt.value elt) |> (ignore : _ Elt.t -> unit);\n let next = Elt.next elt in\n if not (phys_equal next first) then loop f new_t first next\n in\n loop f new_t first first));\n new_t\n;;\n\nlet filteri t ~f =\n let new_t = create () in\n (match !t with\n | None -> ()\n | Some first ->\n Header.with_iteration_3 (Elt.header first) f new_t first (fun f new_t first ->\n let rec loop f i new_t first elt =\n if f i (Elt.value elt)\n then insert_last new_t (Elt.value elt) |> (ignore : _ Elt.t -> unit);\n let next = Elt.next elt in\n if not (phys_equal next first) then loop f (i + 1) new_t first next\n in\n loop f 0 new_t first first));\n new_t\n;;\n\nlet filter_map t ~f =\n let new_t = create () in\n (match !t with\n | None -> ()\n | Some first ->\n Header.with_iteration_3 (Elt.header first) f new_t first (fun f new_t first ->\n let rec loop f new_t first elt =\n (match f (Elt.value elt) with\n | None -> ()\n | Some value -> insert_last new_t value |> (ignore : _ Elt.t -> unit));\n let next = Elt.next elt in\n if not (phys_equal next first) then loop f new_t first next\n in\n loop f new_t first first));\n new_t\n;;\n\nlet filter_mapi t ~f =\n let new_t = create () in\n (match !t with\n | None -> ()\n | Some first ->\n Header.with_iteration_3 (Elt.header first) f new_t first (fun f new_t first ->\n let rec loop f i new_t first elt =\n (match f i (Elt.value elt) with\n | None -> ()\n | Some value -> insert_last new_t value |> (ignore : _ Elt.t -> unit));\n let next = Elt.next elt in\n if not (phys_equal next first) then loop f (i + 1) new_t first next\n in\n loop f 0 new_t first first));\n new_t\n;;\n\nlet partition_tf t ~f =\n let t1 = create () in\n let t2 = create () in\n (match !t with\n | None -> ()\n | Some first ->\n Header.with_iteration_4 (Elt.header first) f t1 t2 first (fun f t1 t2 first ->\n let rec loop f t1 t2 first elt =\n insert_last (if f (Elt.value elt) then t1 else t2) (Elt.value elt)\n |> (ignore : _ Elt.t -> unit);\n let next = Elt.next elt in\n if not (phys_equal next first) then loop f t1 t2 first next\n in\n loop f t1 t2 first first));\n t1, t2\n;;\n\nlet partitioni_tf t ~f =\n let t1 = create () in\n let t2 = create () in\n (match !t with\n | None -> ()\n | Some first ->\n Header.with_iteration_4 (Elt.header first) f t1 t2 first (fun f t1 t2 first ->\n let rec loop f i t1 t2 first elt =\n insert_last (if f i (Elt.value elt) then t1 else t2) (Elt.value elt)\n |> (ignore : _ Elt.t -> unit);\n let next = Elt.next elt in\n if not (phys_equal next first) then loop f (i + 1) t1 t2 first next\n in\n loop f 0 t1 t2 first first));\n t1, t2\n;;\n\nlet partition_map t ~f =\n let t1 = create () in\n let t2 = create () in\n (match !t with\n | None -> ()\n | Some first ->\n Header.with_iteration_4 (Elt.header first) f t1 t2 first (fun f t1 t2 first ->\n let rec loop f t1 t2 first elt =\n (match (f (Elt.value elt) : (_, _) Either.t) with\n | First value -> insert_last t1 value |> (ignore : _ Elt.t -> unit)\n | Second value -> insert_last t2 value |> (ignore : _ Elt.t -> unit));\n let next = Elt.next elt in\n if not (phys_equal next first) then loop f t1 t2 first next\n in\n loop f t1 t2 first first));\n t1, t2\n;;\n\nlet partition_mapi t ~f =\n let t1 = create () in\n let t2 = create () in\n (match !t with\n | None -> ()\n | Some first ->\n Header.with_iteration_4 (Elt.header first) f t1 t2 first (fun f t1 t2 first ->\n let rec loop f i t1 t2 first elt =\n (match (f i (Elt.value elt) : (_, _) Either.t) with\n | First value -> insert_last t1 value |> (ignore : _ Elt.t -> unit)\n | Second value -> insert_last t2 value |> (ignore : _ Elt.t -> unit));\n let next = Elt.next elt in\n if not (phys_equal next first) then loop f (i + 1) t1 t2 first next\n in\n loop f 0 t1 t2 first first));\n t1, t2\n;;\n\nexception Invalid_move__elt_equals_anchor\n\nlet move_before t elt ~anchor =\n if Elt.equal anchor elt then raise Invalid_move__elt_equals_anchor;\n if Header.equal (Elt.header anchor) (Elt.header elt)\n then (\n match !t with\n | None -> raise Elt_does_not_belong_to_list\n | Some first ->\n if Header.equal (Elt.header first) (Elt.header elt)\n then (\n (* unlink [elt] *)\n let after_elt = Elt.next elt in\n Elt.split_or_splice_before elt after_elt;\n let first =\n if Elt.equal first elt\n then (\n t := Some after_elt;\n after_elt)\n else first\n in\n (* splice [elt] in before [anchor] *)\n Elt.split_or_splice_before anchor elt;\n if Elt.equal first anchor then t := Some elt)\n else raise Elt_does_not_belong_to_list)\n else raise Elt_does_not_belong_to_list\n;;\n\nlet move_to_front t elt =\n match !t with\n | None -> raise Elt_does_not_belong_to_list\n | Some first -> if not (Elt.equal elt first) then move_before t elt ~anchor:first\n;;\n\nlet move_after t elt ~anchor =\n if Elt.equal anchor elt then raise Invalid_move__elt_equals_anchor;\n if Header.equal (Elt.header anchor) (Elt.header elt)\n then (\n match !t with\n | None -> raise Elt_does_not_belong_to_list\n | Some first ->\n if Header.equal (Elt.header first) (Elt.header elt)\n then (\n (* unlink [elt] *)\n let after_elt = Elt.next elt in\n Elt.split_or_splice_before elt after_elt;\n if Elt.equal first elt then t := Some after_elt;\n (* splice [elt] in after [anchor] *)\n Elt.split_or_splice_after anchor elt)\n else raise Elt_does_not_belong_to_list)\n else raise Elt_does_not_belong_to_list\n;;\n\nlet move_to_back t elt =\n match !t with\n | None -> raise Elt_does_not_belong_to_list\n | Some first ->\n let last = Elt.prev first in\n if not (Elt.equal elt last) then move_after t elt ~anchor:last\n;;\n\nlet to_sequence t = to_list t |> Sequence.of_list\n","open! Import\ninclude Bag_intf\ninclude (Doubly_linked : Doubly_linked.S)\n\nlet add = insert_first\nlet add_unit t v = add t v |> (ignore : _ Elt.t -> unit)\nlet elts t = fold_elt t ~init:[] ~f:(fun acc elt -> elt :: acc)\nlet remove_one = remove_first\nlet choose = first_elt\n\nlet until_empty t f =\n let rec loop () =\n Option.iter (remove_one t) ~f:(fun v ->\n f v;\n loop ())\n in\n loop ()\n;;\n","open! Import\n\nmodule Stable = struct\n module V1 = struct\n type t = Base.Sexp.t =\n | Atom of string\n | List of t list\n [@@deriving bin_io, compare, hash]\n\n let t_of_sexp = Sexplib.Sexp.t_of_sexp\n let sexp_of_t = Sexplib.Sexp.sexp_of_t\n end\nend\n\ninclude Stable.V1\n\ninclude (\n Base.Sexp :\n module type of struct\n include Base.Sexp\n end\n with type t := t)\n\ninclude (\n Sexplib.Sexp :\n module type of struct\n include Sexplib.Sexp\n end\n with type t := t)\n\nmodule O = struct\n type sexp = Base.Sexp.t =\n | Atom of string\n | List of t list\nend\n\nmodule Sexp_maybe = struct\n type nonrec 'a t = ('a, t * Error.t) Result.t [@@deriving bin_io, compare, hash]\n\n let sexp_of_t sexp_of_a t =\n match t with\n | Result.Ok a -> sexp_of_a a\n | Result.Error (sexp, err) ->\n List [ Atom \"sexp_parse_error\"; sexp; Error.sexp_of_t err ]\n ;;\n\n let t_of_sexp a_of_sexp sexp =\n match sexp with\n | List [ Atom \"sexp_parse_error\"; sexp; _ ] | sexp ->\n (try Result.Ok (a_of_sexp sexp) with\n | exn -> Result.Error (sexp, Error.of_exn exn))\n ;;\nend\n\nmodule With_text = struct\n open Result.Export\n\n type 'a t =\n { value : 'a\n ; text : string\n }\n [@@deriving bin_io]\n\n let sexp_of_t _ t = Atom t.text\n\n let of_text value_of_sexp ?(filename = \"\") text =\n match Or_error.try_with (fun () -> of_string_conv text value_of_sexp) with\n | Ok (`Result value) -> Ok { value; text }\n | Error _ as err -> err\n | Ok (`Error (exn, annotated)) ->\n Error (Error.of_exn (Annotated.get_conv_exn annotated ~file:filename ~exc:exn))\n ;;\n\n let t_of_sexp a_of_sexp sexp =\n match sexp with\n | List _ ->\n of_sexp_error\n \"With_text.t should be stored as an atom, but instead a list was found.\"\n sexp\n | Atom text -> of_text a_of_sexp text |> Or_error.ok_exn\n ;;\n\n let text t = t.text\n let value t = t.value\n\n let of_value sexp_of_value value =\n let text = sexp_of_value value |> to_string_hum in\n { value; text }\n ;;\nend\n\ntype 'a no_raise = 'a [@@deriving bin_io, sexp]\n\nlet sexp_of_no_raise sexp_of_a a =\n try sexp_of_a a with\n | exn ->\n (try List [ Atom \"failure building sexp\"; sexp_of_exn exn ] with\n | _ -> Atom \"could not build sexp for exn raised when building sexp for value\")\n;;\n\ninclude Comparable.Extend (Base.Sexp) (Base.Sexp)\n\nlet of_sexp_allow_extra_fields_recursively of_sexp sexp =\n let r = Sexplib.Conv.record_check_extra_fields in\n let prev = !r in\n Exn.protect\n ~finally:(fun () -> r := prev)\n ~f:(fun () ->\n r := false;\n of_sexp sexp)\n;;\n\nlet quickcheck_generator = Base_quickcheck.Generator.sexp\nlet quickcheck_observer = Base_quickcheck.Observer.sexp\nlet quickcheck_shrinker = Base_quickcheck.Shrinker.sexp\n","open! Import\nopen Hash_queue_intf\n\nmodule type Key = Key\nmodule type S_backend = S_backend\n\nmodule Make_backend (Table : Hashtbl_intf.Hashtbl) : S_backend = struct\n module type Backend =\n S1\n with type 'key create_arg := 'key Hashtbl.Hashable.t\n with type 'key create_key := 'key\n\n module Backend : Backend = struct\n module Key_value = struct\n module T = struct\n type ('key, 'value) t =\n { key : 'key\n ; mutable value : 'value\n }\n end\n\n include T\n\n let key t = t.key\n let value t = t.value\n\n let sexp_of_t sexp_of_key sexp_of_data { key; value } =\n [%sexp_of: key * data] (key, value)\n ;;\n end\n\n open Key_value.T\n module Elt = Doubly_linked.Elt\n\n type ('key, 'data) t =\n { mutable num_readers : int\n ; queue : ('key, 'data) Key_value.t Doubly_linked.t\n ; table : ('key, ('key, 'data) Key_value.t Elt.t) Table.t\n }\n\n let sexp_of_t sexp_of_key sexp_of_data t =\n [%sexp_of: (key, data) Key_value.t Doubly_linked.t] t.queue\n ;;\n\n let invariant t =\n assert (Doubly_linked.length t.queue = Table.length t.table);\n (* Look at each element in the queue, checking:\n * - every element in the queue is in the hash table\n * - there are no duplicate keys\n *)\n let keys = Table.create ~size:(Table.length t.table) (Table.hashable_s t.table) in\n Doubly_linked.iter t.queue ~f:(fun kv ->\n let key = kv.key in\n match Table.find t.table key with\n | None -> assert false\n | Some _ ->\n assert (not (Table.mem keys key));\n Table.set keys ~key ~data:())\n ;;\n\n let create ?(growth_allowed = true) ?(size = 16) hashable =\n { num_readers = 0\n ; queue = Doubly_linked.create ()\n ; table = Table.create ~growth_allowed ~size (Table.Hashable.to_key hashable)\n }\n ;;\n\n let read t f =\n t.num_readers <- t.num_readers + 1;\n Exn.protect ~f ~finally:(fun () -> t.num_readers <- t.num_readers - 1)\n ;;\n\n let ensure_can_modify t =\n if t.num_readers > 0\n then failwith \"It is an error to modify a Hash_queue.t while iterating over it.\"\n ;;\n\n let clear t =\n ensure_can_modify t;\n Doubly_linked.clear t.queue;\n Table.clear t.table\n ;;\n\n let length t = Table.length t.table\n let is_empty t = length t = 0\n\n let lookup t k =\n match Table.find t.table k with\n | None -> None\n | Some elt -> Some (Elt.value elt).value\n ;;\n\n let lookup_exn t k = (Elt.value (Table.find_exn t.table k)).value\n let mem t k = Table.mem t.table k\n\n (* Note that this is the tail-recursive Core_list.map *)\n let to_list t = List.map (Doubly_linked.to_list t.queue) ~f:Key_value.value\n let to_array t = Array.map (Doubly_linked.to_array t.queue) ~f:Key_value.value\n\n let for_all t ~f =\n read t (fun () -> Doubly_linked.for_all t.queue ~f:(fun kv -> f kv.value))\n ;;\n\n let exists t ~f =\n read t (fun () -> Doubly_linked.exists t.queue ~f:(fun kv -> f kv.value))\n ;;\n\n let find_map t ~f =\n read t (fun () -> Doubly_linked.find_map t.queue ~f:(fun kv -> f kv.value))\n ;;\n\n let find t ~f =\n read t (fun () ->\n Option.map\n (Doubly_linked.find t.queue ~f:(fun kv -> f kv.value))\n ~f:Key_value.value)\n ;;\n\n let enqueue t back_or_front key value =\n ensure_can_modify t;\n if Table.mem t.table key\n then `Key_already_present\n else (\n let contents = { Key_value.key; value } in\n let elt =\n match back_or_front with\n | `back -> Doubly_linked.insert_last t.queue contents\n | `front -> Doubly_linked.insert_first t.queue contents\n in\n Table.set t.table ~key ~data:elt;\n `Ok)\n ;;\n\n let enqueue_back t = enqueue t `back\n let enqueue_front t = enqueue t `front\n\n let raise_enqueue_duplicate_key t key =\n raise_s\n [%message\n \"Hash_queue.enqueue_exn: duplicate key\"\n ~_:(Table.sexp_of_key t.table key : Sexp.t)]\n ;;\n\n let enqueue_exn t back_or_front key value =\n match enqueue t back_or_front key value with\n | `Key_already_present -> raise_enqueue_duplicate_key t key\n | `Ok -> ()\n ;;\n\n let enqueue_back_exn t = enqueue_exn t `back\n let enqueue_front_exn t = enqueue_exn t `front\n\n (* Performance hack: we implement this version separately to avoid allocation from the\n option. *)\n let lookup_and_move_to_back_exn t key =\n ensure_can_modify t;\n let elt = Table.find_exn t.table key in\n Doubly_linked.move_to_back t.queue elt;\n Key_value.value (Elt.value elt)\n ;;\n\n let lookup_and_move_to_back t key =\n let open Option.Let_syntax in\n ensure_can_modify t;\n let%map elt = Table.find t.table key in\n Doubly_linked.move_to_back t.queue elt;\n Key_value.value (Elt.value elt)\n ;;\n\n let lookup_and_move_to_front_exn t key =\n ensure_can_modify t;\n let elt = Table.find_exn t.table key in\n Doubly_linked.move_to_front t.queue elt;\n Key_value.value (Elt.value elt)\n ;;\n\n let lookup_and_move_to_front t key =\n let open Option.Let_syntax in\n ensure_can_modify t;\n let%map elt = Table.find t.table key in\n Doubly_linked.move_to_front t.queue elt;\n Key_value.value (Elt.value elt)\n ;;\n\n let dequeue_with_key t back_or_front =\n ensure_can_modify t;\n let maybe_kv =\n match back_or_front with\n | `back -> Doubly_linked.remove_last t.queue\n | `front -> Doubly_linked.remove_first t.queue\n in\n match maybe_kv with\n | None -> None\n | Some kv ->\n Table.remove t.table kv.key;\n Some (kv.key, kv.value)\n ;;\n\n let raise_dequeue_with_key_empty () =\n raise_s [%message \"Hash_queue.dequeue_with_key: empty queue\"]\n ;;\n\n let dequeue_with_key_exn t back_or_front =\n match dequeue_with_key t back_or_front with\n | None -> raise_dequeue_with_key_empty ()\n | Some (k, v) -> k, v\n ;;\n\n let dequeue_back_with_key t = dequeue_with_key t `back\n let dequeue_back_with_key_exn t = dequeue_with_key_exn t `back\n let dequeue_front_with_key t = dequeue_with_key t `front\n let dequeue_front_with_key_exn t = dequeue_with_key_exn t `front\n\n let dequeue t back_or_front =\n match dequeue_with_key t back_or_front with\n | None -> None\n | Some (_, v) -> Some v\n ;;\n\n let dequeue_back t = dequeue t `back\n let dequeue_front t = dequeue t `front\n\n let first_with_key t =\n match Doubly_linked.first t.queue with\n | None -> None\n | Some { key; value } -> Some (key, value)\n ;;\n\n let first t =\n match Doubly_linked.first t.queue with\n | None -> None\n | Some kv -> Some kv.value\n ;;\n\n let raise_dequeue_empty () = raise_s [%message \"Hash_queue.dequeue_exn: empty queue\"]\n\n let dequeue_exn t back_or_front =\n match dequeue t back_or_front with\n | None -> raise_dequeue_empty ()\n | Some v -> v\n ;;\n\n let dequeue_back_exn t = dequeue_exn t `back\n let dequeue_front_exn t = dequeue_exn t `front\n\n let keys t =\n (* Return the keys in the order of the queue. *)\n List.map (Doubly_linked.to_list t.queue) ~f:Key_value.key\n ;;\n\n let iteri t ~f =\n read t (fun () ->\n Doubly_linked.iter t.queue ~f:(fun kv -> f ~key:kv.key ~data:kv.value))\n ;;\n\n let iter t ~f = iteri t ~f:(fun ~key:_ ~data -> f data)\n\n let foldi t ~init ~f =\n read t (fun () ->\n Doubly_linked.fold t.queue ~init ~f:(fun ac kv ->\n f ac ~key:kv.key ~data:kv.value))\n ;;\n\n let fold t ~init ~f = foldi t ~init ~f:(fun ac ~key:_ ~data -> f ac data)\n let count t ~f = Container.count ~fold t ~f\n let sum m t ~f = Container.sum m ~fold t ~f\n let min_elt t ~compare = Container.min_elt ~fold t ~compare\n let max_elt t ~compare = Container.max_elt ~fold t ~compare\n let fold_result t ~init ~f = Container.fold_result ~fold ~init ~f t\n let fold_until t ~init ~f = Container.fold_until ~fold ~init ~f t\n\n let dequeue_all t ~f =\n let rec loop () =\n match dequeue_front t with\n | None -> ()\n | Some v ->\n f v;\n loop ()\n in\n loop ()\n ;;\n\n let remove t k =\n ensure_can_modify t;\n match Table.find_and_remove t.table k with\n | None -> `No_such_key\n | Some elt ->\n Doubly_linked.remove t.queue elt;\n `Ok\n ;;\n\n let raise_remove_unknown_key t key =\n raise_s\n [%message\n \"Hash_queue.remove_exn: unknown key\"\n ~_:(Table.sexp_of_key t.table key : Sexp.t)]\n ;;\n\n let remove_exn t k =\n ensure_can_modify t;\n match remove t k with\n | `No_such_key -> raise_remove_unknown_key t k\n | `Ok -> ()\n ;;\n\n let lookup_and_remove t k =\n ensure_can_modify t;\n match Table.find_and_remove t.table k with\n | None -> None\n | Some elt ->\n Doubly_linked.remove t.queue elt;\n Some (Elt.value elt).value\n ;;\n\n let replace t k v =\n ensure_can_modify t;\n match Table.find t.table k with\n | None -> `No_such_key\n | Some elt ->\n (Elt.value elt).value <- v;\n `Ok\n ;;\n\n let raise_replace_unknown_key t key =\n raise_s\n [%message\n \"Hash_queue.replace_exn: unknown key\"\n ~_:(Table.sexp_of_key t.table key : Sexp.t)]\n ;;\n\n let replace_exn t k v =\n ensure_can_modify t;\n match replace t k v with\n | `No_such_key -> raise_replace_unknown_key t k\n | `Ok -> ()\n ;;\n\n let drop ?(n = 1) t back_or_front =\n if n >= length t\n then clear t\n else\n for _ = 1 to n do\n ignore (dequeue_with_key t back_or_front : _ option)\n done\n ;;\n\n let drop_back ?n t = drop ?n t `back\n let drop_front ?n t = drop ?n t `front\n end\n\n module type S = S0 with type ('key, 'data) hash_queue := ('key, 'data) Backend.t\n\n module Make (Key : Key) : S with type key = Key.t = struct\n include (Backend : Backend with type ('k, 'd) t := ('k, 'd) Backend.t)\n\n type key = Key.t\n type 'data t = (Key.t, 'data) Backend.t [@@deriving sexp_of]\n\n let hashable = Table.Hashable.of_key (module Key)\n let create ?growth_allowed ?size () = create ?growth_allowed ?size hashable\n end\n\n include Backend\nend\n\ninclude Make_backend (Hashtbl)\n","(** Functors and interfaces used to make modules hashable. *)\n\nopen! Import\nmodule Binable = Binable0\n\nmodule type Common = sig\n type t [@@deriving compare, hash]\n\n val hashable : t Hashtbl.Hashable.t\nend\n\nmodule type S_plain = sig\n include Common\n module Table : Hashtbl.S_plain with type key = t\n module Hash_set : Hash_set.S_plain with type elt = t\n module Hash_queue : Hash_queue.S with type key = t\nend\n\nmodule type S = sig\n include Common\n module Table : Hashtbl.S with type key = t\n module Hash_set : Hash_set.S with type elt = t\n module Hash_queue : Hash_queue.S with type key = t\nend\n\nmodule Make_plain (T : sig\n type t [@@deriving hash]\n\n include Hashtbl.Key_plain with type t := t\n end) : S_plain with type t := T.t = struct\n include T\n module Table = Hashtbl.Make_plain (T)\n module Hash_set = Hash_set.Make_plain (T)\n module Hash_queue = Hash_queue.Make (T)\n\n let hashable = Table.hashable\nend\n\nmodule Make_plain_and_derive_hash_fold_t (T : Hashtbl.Key_plain) :\n S_plain with type t := T.t = Make_plain (struct\n include T\n\n let hash_fold_t state t = hash_fold_int state (hash t)\n end)\n\nmodule Make (T : sig\n type t [@@deriving hash]\n\n include Hashtbl.Key with type t := t\n end) : S with type t := T.t = struct\n include T\n module Table = Hashtbl.Make (T)\n module Hash_set = Hash_set.Make (T)\n module Hash_queue = Hash_queue.Make (T)\n\n let hashable = Table.hashable\nend\n\nmodule Make_and_derive_hash_fold_t (T : Hashtbl.Key) : S with type t := T.t =\n Make (struct\n include T\n\n let hash_fold_t state t = hash_fold_int state (hash t)\n end)\n\nmodule type S_binable = sig\n type t [@@deriving hash]\n\n val hashable : t Hashtbl.Hashable.t\n\n module Table : Hashtbl.S_binable with type key = t\n module Hash_set : Hash_set.S_binable with type elt = t\n module Hash_queue : Hash_queue.S with type key = t\nend\n\nmodule Make_binable (T : sig\n type t [@@deriving hash]\n\n include Hashtbl.Key_binable with type t := t\n end) : S_binable with type t := T.t = struct\n module Table = Hashtbl.Make_binable (T)\n module Hash_set = Hash_set.Make_binable (T)\n module Hash_queue = Hash_queue.Make (T)\n include T\n\n let hashable = Table.hashable\nend\n\nmodule Make_binable_and_derive_hash_fold_t (T : Hashtbl.Key_binable) :\n S_binable with type t := T.t = Make_binable (struct\n include T\n\n let hash_fold_t state t = hash_fold_int state (hash t)\n end)\n\nmodule Stable : sig\n module V1 : sig\n module type S = sig\n type key\n\n module Table : sig\n type 'a t = (key, 'a) Hashtbl.t [@@deriving sexp, bin_io]\n end\n\n module Hash_set : sig\n type t = key Hash_set.t [@@deriving sexp, bin_io]\n end\n end\n\n module Make (Key : Hashtbl.Key_binable) : S with type key := Key.t\n end\nend = struct\n module V1 = struct\n module type S = sig\n type key\n\n module Table : sig\n type 'a t = (key, 'a) Hashtbl.t [@@deriving sexp, bin_io]\n end\n\n module Hash_set : sig\n type t = key Hash_set.t [@@deriving sexp, bin_io]\n end\n end\n\n module Make (Key : Hashtbl.Key_binable) : S with type key := Key.t = struct\n module Table = Hashtbl.Make_binable (Key)\n module Hash_set = Hash_set.Make_binable (Key)\n end\n end\nend\n","open! Import\nmodule Binable = Binable0\n\nmodule type S_common = sig\n type t [@@deriving compare, hash, sexp_of]\n\n include Stringable.S with type t := t\n include Pretty_printer.S with type t := t\nend\n\nmodule type S_plain = sig\n include S_common\n include Comparable.S_plain with type t := t\n include Hashable.S_plain with type t := t\nend\n\nmodule type S_not_binable = sig\n type t [@@deriving hash, sexp]\n\n include S_common with type t := t\n include Comparable.S with type t := t\n include Hashable.S with type t := t\nend\n\nmodule type S = sig\n type t [@@deriving bin_io, hash, sexp]\n\n include S_common with type t := t\n include Comparable.S_binable with type t := t\n include Hashable.S_binable with type t := t\nend\n\nmodule Make_plain (T : sig\n type t [@@deriving compare, hash, sexp_of]\n\n include Stringable.S with type t := t\n\n val module_name : string\n end) =\nstruct\n include T\n include Comparable.Make_plain (T)\n include Hashable.Make_plain (T)\n include Pretty_printer.Register (T)\nend\n\nmodule Make (T : sig\n type t [@@deriving bin_io, compare, hash, sexp]\n\n include Stringable.S with type t := t\n\n val module_name : string\n end) =\nstruct\n include T\n include Comparable.Make_binable (T)\n include Hashable.Make_binable (T)\n include Pretty_printer.Register (T)\nend\n\nmodule Make_and_derive_hash_fold_t (T : sig\n type t [@@deriving bin_io, compare, sexp]\n\n include Stringable.S with type t := t\n\n val hash : t -> int\n val module_name : string\n end) =\n Make (struct\n include T\n\n let hash_fold_t state t = hash_fold_int state (hash t)\n end)\n\nmodule Make_using_comparator (T : sig\n type t [@@deriving bin_io, compare, hash, sexp]\n\n include Comparator.S with type t := t\n include Stringable.S with type t := t\n\n val module_name : string\n end) =\nstruct\n include T\n include Comparable.Make_binable_using_comparator (T)\n include Hashable.Make_binable (T)\n include Pretty_printer.Register (T)\nend\n\nmodule Make_using_comparator_and_derive_hash_fold_t (T : sig\n type t [@@deriving bin_io, compare, sexp]\n\n include Comparator.S with type t := t\n include Stringable.S with type t := t\n\n val hash : t -> int\n val module_name : string\n end) =\n Make_using_comparator (struct\n include T\n\n let hash_fold_t state t = hash_fold_int state (hash t)\n end)\n\nmodule Extend (M : Base.Identifiable.S) (B : Binable0.S with type t = M.t) = struct\n module T = struct\n include M\n include (B : Binable.S with type t := t)\n end\n\n include T\n include Comparable.Extend_binable (M) (T)\n include Hashable.Make_binable (T)\nend\n","open! Import\n\ntype t = bool [@@deriving bin_io, typerep]\n\ninclude Identifiable.Extend\n (Base.Bool)\n (struct\n type nonrec t = t [@@deriving bin_io]\n end)\n\nmodule Replace_polymorphic_compare = Base.Bool\n\ninclude (\n Base.Bool :\n module type of struct\n include Base.Bool\n end\n with type t := t)\n\nlet quickcheck_generator = Base_quickcheck.Generator.bool\nlet quickcheck_observer = Base_quickcheck.Observer.bool\nlet quickcheck_shrinker = Base_quickcheck.Shrinker.bool\n\nmodule Stable = struct\n module V1 = struct\n type nonrec t = t [@@deriving compare, sexp, bin_io]\n end\nend\n","(** A functor for displaying a type as a sequence of ASCII characters printed in\n hexadecimal.\n\n [sexp_of_t] and [to_string_hum] print [t] in a similar format to 'hexdump' on Unix\n systems. For example, the string \"Back off, man, I'm a scientist.\" renders as:\n\n {v\n00000000 42 61 63 6b 20 6f 66 66 2c 20 6d 61 6e 2c 20 49 |Back off, man, I|\n00000010 27 6d 20 61 20 73 63 69 65 6e 74 69 73 74 2e |'m a scientist.|\n v}\n\n [to_sequence] produces a sequence of strings representing lines in the hex dump. It\n can be used to process a hex dump incrementally, for example with potentially infinite\n values, or to avoid keeping the entire output in memory at once. *)\n\nopen! Import\n\nmodule type S = sig\n type t\n\n module Hexdump : sig\n type nonrec t = t [@@deriving sexp_of]\n\n (** [to_string_hum] renders [t] as a multi-line ASCII string in hexdump format. [pos]\n and [len] select a subrange of [t] to render. [max_lines] determines the maximum\n number of lines of hex dump to produce. If the full hex dump exceeds this number,\n lines in the middle are replaced by a single \"...\"; the beginning and end of the\n hex dump are left intact. In order to produce at least some readable hex dump, at\n least 3 lines are always produced. *)\n val to_string_hum\n : ?max_lines:int (** default: [!default_max_lines] *)\n -> ?pos:int\n -> ?len:int\n -> t\n -> string\n\n (** [to_sequence] produces the lines of [to_string_hum] as a sequence of strings.\n This may be useful for incrementally rendering a large hex dump without producing\n the whole thing in memory. Optional arguments function as in [to_string_hum]. *)\n val to_sequence\n : ?max_lines:int (** default: [!default_max_lines] *)\n -> ?pos:int\n -> ?len:int\n -> t\n -> string Sequence.t\n\n (** [[%sexp_of: Hexdump.Pretty.t]] is the same as [[%sexp_of: Hexdump.t]], unless the\n underlying sequence of characters is entirely printable. In that case, it is\n rendered directly as a string. This allows e.g. test output to be much more\n compact in the common (printable) case while still being interpretable for any\n byte sequence. *)\n module Pretty : sig\n type nonrec t = t [@@deriving sexp_of]\n end\n end\nend\n\nmodule type S1 = sig\n type _ t\n\n module Hexdump : sig\n type nonrec 'a t = 'a t [@@deriving sexp_of]\n\n val to_string_hum : ?max_lines:int -> ?pos:int -> ?len:int -> _ t -> string\n\n\n val to_sequence : ?max_lines:int -> ?pos:int -> ?len:int -> _ t -> string Sequence.t\n\n module Pretty : sig\n type nonrec 'a t = 'a t [@@deriving sexp_of]\n end\n end\nend\n\nmodule type S2 = sig\n type (_, _) t\n\n module Hexdump : sig\n type nonrec ('a, 'b) t = ('a, 'b) t [@@deriving sexp_of]\n\n val to_string_hum : ?max_lines:int -> ?pos:int -> ?len:int -> (_, _) t -> string\n\n val to_sequence\n : ?max_lines:int\n -> ?pos:int\n -> ?len:int\n -> (_, _) t\n -> string Sequence.t\n\n module Pretty : sig\n type nonrec ('a, 'b) t = ('a, 'b) t [@@deriving sexp_of]\n end\n end\nend\n\n(** The functor [Hexdump.Of_indexable] uses [length] and [get] to iterate over the\n characters in a value and produce a hex dump. *)\nmodule type Indexable = sig\n type t\n\n val length : t -> int\n val get : t -> int -> char\nend\n\nmodule type Indexable1 = sig\n type _ t\n\n val length : _ t -> int\n val get : _ t -> int -> char\nend\n\nmodule type Indexable2 = sig\n type (_, _) t\n\n val length : (_, _) t -> int\n val get : (_, _) t -> int -> char\nend\n\nmodule type Hexdump = sig\n module type Indexable = Indexable\n module type Indexable1 = Indexable1\n module type Indexable2 = Indexable2\n module type S = S\n module type S1 = S1\n module type S2 = S2\n\n (** Can be used to override the default [~lines] argument for [to_string_hum] and\n [to_sequence] in [S]. *)\n val default_max_lines : int ref\n\n module Of_indexable (T : Indexable) : S with type t := T.t\n module Of_indexable1 (T : Indexable1) : S1 with type 'a t := 'a T.t\n module Of_indexable2 (T : Indexable2) : S2 with type ('a, 'b) t := ('a, 'b) T.t\nend\n","open! Import\nmodule Char = Base.Char\nmodule Int = Base.Int\nmodule String = Base.String\ninclude Hexdump_intf\n\nlet bytes_per_line = 16\n\n(* Initialize to enough lines to display 4096 bytes -- large enough that, for example, a\n complete Ethernet packet can always be displayed -- including the line containing the\n final index. *)\nlet default_max_lines = ref ((4096 / bytes_per_line) + 1)\n\nmodule Of_indexable2 (T : Indexable2) = struct\n module Hexdump = struct\n include T\n\n let hex_of_pos pos = Printf.sprintf \"%08x\" pos\n\n let hex_of_char t ~start ~until offset =\n let pos = start + offset in\n if pos >= until then \" \" else Printf.sprintf \"%02x\" (Char.to_int (get t pos))\n ;;\n\n let hex_of_line t ~start ~until =\n Printf.sprintf\n \"%s %s %s %s %s %s %s %s %s %s %s %s %s %s %s %s\"\n (hex_of_char t ~start ~until 0)\n (hex_of_char t ~start ~until 1)\n (hex_of_char t ~start ~until 2)\n (hex_of_char t ~start ~until 3)\n (hex_of_char t ~start ~until 4)\n (hex_of_char t ~start ~until 5)\n (hex_of_char t ~start ~until 6)\n (hex_of_char t ~start ~until 7)\n (hex_of_char t ~start ~until 8)\n (hex_of_char t ~start ~until 9)\n (hex_of_char t ~start ~until 10)\n (hex_of_char t ~start ~until 11)\n (hex_of_char t ~start ~until 12)\n (hex_of_char t ~start ~until 13)\n (hex_of_char t ~start ~until 14)\n (hex_of_char t ~start ~until 15)\n ;;\n\n let printable_string t ~start ~until =\n String.init (until - start) ~f:(fun i ->\n let char = get t (start + i) in\n if Char.is_print char then char else '.')\n ;;\n\n let line t ~pos ~len ~line_index =\n let start = pos + (line_index * bytes_per_line) in\n let until = min (start + bytes_per_line) (pos + len) in\n Printf.sprintf\n \"%s %s |%s|\"\n (hex_of_pos start)\n (hex_of_line t ~start ~until)\n (printable_string t ~start ~until)\n ;;\n\n let to_sequence ?max_lines ?pos ?len t =\n let pos, len =\n Ordered_collection_common.get_pos_len_exn () ?pos ?len ~total_length:(length t)\n in\n let max_lines =\n match max_lines with\n | Some max_lines -> max_lines\n | None -> !default_max_lines\n in\n (* always produce at least 3 lines: first line of hex, ellipsis, last line of hex *)\n let max_lines = max max_lines 3 in\n (* unabridged lines = lines of hex + line with final index *)\n let unabridged_lines =\n Int.round_up len ~to_multiple_of:bytes_per_line / bytes_per_line\n in\n (* Figure out where we need to skip from and to if [max_lines < unabridged_lines].\n Skip after half the actual hex lines (subtracting one line for the ellipsis).\n Skip to near the end, less the number of lines remaining to produce, plus the\n ellipsis line. *)\n let skip_from = (max_lines - 1) / 2 in\n let skip_to = unabridged_lines - (max_lines - skip_from) + 1 in\n Sequence.unfold_step ~init:0 ~f:(fun line_index ->\n if line_index >= unabridged_lines\n then Done\n else if line_index = skip_from && max_lines < unabridged_lines\n then Yield (\"...\", skip_to)\n else Yield (line t ~pos ~len ~line_index, line_index + 1))\n ;;\n\n let to_string_hum ?max_lines ?pos ?len t =\n to_sequence ?max_lines ?pos ?len t |> Sequence.to_list |> String.concat ~sep:\"\\n\"\n ;;\n\n let sexp_of_t _ _ t = to_sequence t |> Sequence.to_list |> [%sexp_of: string list]\n\n module Pretty = struct\n include T\n\n let printable =\n let rec printable_from t ~pos ~length =\n pos >= length\n || (Char.is_print (get t pos) && printable_from t ~pos:(pos + 1) ~length)\n in\n fun t -> printable_from t ~pos:0 ~length:(length t)\n ;;\n\n let to_string t = String.init (length t) ~f:(fun pos -> get t pos)\n\n let sexp_of_t sexp_of_a sexp_of_b t =\n if printable t then [%sexp (to_string t : string)] else [%sexp (t : (a, b) t)]\n ;;\n end\n end\nend\n\nmodule Of_indexable1 (T : Indexable1) = struct\n module M = Of_indexable2 (struct\n type ('a, _) t = 'a T.t\n\n let length = T.length\n let get = T.get\n end)\n\n module Hexdump = struct\n include T\n\n let sexp_of_t x t = M.Hexdump.sexp_of_t x [%sexp_of: _] t\n let to_sequence = M.Hexdump.to_sequence\n let to_string_hum = M.Hexdump.to_string_hum\n\n module Pretty = struct\n include T\n\n let sexp_of_t sexp_of_a t = [%sexp (t : (a, _) M.Hexdump.Pretty.t)]\n end\n end\nend\n\nmodule Of_indexable (T : Indexable) = struct\n module M = Of_indexable1 (struct\n type _ t = T.t\n\n let length = T.length\n let get = T.get\n end)\n\n module Hexdump = struct\n include T\n\n let sexp_of_t t = M.Hexdump.sexp_of_t [%sexp_of: _] t\n let to_sequence = M.Hexdump.to_sequence\n let to_string_hum = M.Hexdump.to_string_hum\n\n module Pretty = struct\n include T\n\n let sexp_of_t t = [%sexp (t : _ M.Hexdump.Pretty.t)]\n end\n end\nend\n","open! Import\ninclude Base.String\n\n(* These two are needed because [include Identifiable.Extend] (present later in the file)\n binds new [Map] and [Set] modules. *)\nmodule Core_map = Map\nmodule Core_set = Set\n\nmodule Stable = struct\n module V1 = struct\n module T = struct\n include Base.String\n\n type t = string [@@deriving bin_io]\n end\n\n include T\n\n let to_string = Fn.id\n let of_string = Fn.id\n\n include Comparable.Stable.V1.Make (T)\n include Hashable.Stable.V1.Make (T)\n end\nend\n\nmodule Caseless = struct\n module T = struct\n include Caseless\n\n type t = string [@@deriving bin_io]\n end\n\n include T\n include Comparable.Make_binable_using_comparator (T)\n include Hashable.Make_binable (T)\nend\n\ntype t = string [@@deriving typerep]\n\ninclude Identifiable.Extend\n (Base.String)\n (struct\n type t = string [@@deriving bin_io]\n end)\n\ninclude Hexdump.Of_indexable (struct\n type t = string\n\n let length = length\n let get = get\n end)\n\nlet quickcheck_generator = Base_quickcheck.Generator.string\nlet quickcheck_observer = Base_quickcheck.Observer.string\nlet quickcheck_shrinker = Base_quickcheck.Shrinker.string\nlet gen_nonempty = Base_quickcheck.Generator.string_non_empty\nlet gen' = Base_quickcheck.Generator.string_of\nlet gen_nonempty' = Base_quickcheck.Generator.string_non_empty_of\n\nlet gen_with_length length chars =\n Base_quickcheck.Generator.string_with_length_of chars ~length\n;;\n\nlet take_while t ~f =\n match lfindi t ~f:(fun _ elt -> not (f elt)) with\n | None -> t\n | Some i -> sub t ~pos:0 ~len:i\n;;\n\nlet rtake_while t ~f =\n match rfindi t ~f:(fun _ elt -> not (f elt)) with\n | None -> t\n | Some i -> sub t ~pos:(i + 1) ~len:(length t - i - 1)\n;;\n\n(** See {!Array.normalize} for the following 4 functions. *)\nlet normalize t i = Ordered_collection_common.normalize ~length_fun:length t i\n\nlet slice t start stop =\n Ordered_collection_common.slice ~length_fun:length ~sub_fun:sub t start stop\n;;\n\nlet nget x i =\n let module String = Base.String in\n x.[normalize x i]\n;;\n","open! Import\n\nmodule Stable = struct\n module V1 = struct\n include Base.Bytes\n\n type t = bytes [@@deriving bin_io, typerep]\n end\nend\n\ninclude Stable.V1\n\ninclude Hexdump.Of_indexable (struct\n type t = bytes\n\n let length = length\n let get = get\n end)\n\nlet quickcheck_generator =\n String.quickcheck_generator |> Quickcheck.Generator.map ~f:of_string\n;;\n\nlet quickcheck_observer =\n String.quickcheck_observer |> Quickcheck.Observer.unmap ~f:to_string\n;;\n\nlet quickcheck_shrinker =\n String.quickcheck_shrinker |> Quickcheck.Shrinker.map ~f:of_string ~f_inverse:to_string\n;;\n\nlet gen' char_gen = String.gen' char_gen |> Quickcheck.Generator.map ~f:of_string\n\nlet gen_with_length len char_gen =\n String.gen_with_length len char_gen |> Quickcheck.Generator.map ~f:of_string\n;;\n","open! Import\n\ntype t = char [@@deriving typerep]\n\ninclude Identifiable.Extend\n (Base.Char)\n (struct\n type t = char [@@deriving bin_io]\n end)\n\n(* include [Base.Char] after the application of [Identifiable.Extend] to replace the\n [Comparable] functions with the pervasive versions *)\ninclude (\n Base.Char :\n module type of struct\n include Base.Char\n end\n with type t := t)\n\nmodule Caseless = struct\n module T = struct\n include Caseless\n\n type t = char [@@deriving bin_io]\n end\n\n include T\n include Comparable.Make_binable_using_comparator (T)\n include Hashable.Make_binable (T)\nend\n\nmodule Replace_polymorphic_compare = Base.Char\n\nlet quickcheck_generator = Base_quickcheck.Generator.char\nlet quickcheck_observer = Base_quickcheck.Observer.char\nlet quickcheck_shrinker = Base_quickcheck.Shrinker.char\nlet gen_digit = Base_quickcheck.Generator.char_digit\nlet gen_lowercase = Base_quickcheck.Generator.char_lowercase\nlet gen_uppercase = Base_quickcheck.Generator.char_uppercase\nlet gen_alpha = Base_quickcheck.Generator.char_alpha\nlet gen_alphanum = Base_quickcheck.Generator.char_alphanum\nlet gen_print = Base_quickcheck.Generator.char_print\nlet gen_whitespace = Base_quickcheck.Generator.char_whitespace\nlet gen_uniform_inclusive = Base_quickcheck.Generator.char_uniform_inclusive\n","include Caml\n\n(* At Jane Street, the OCaml stdlib is patched to define [Pervasives.raise] as the\n [\"%reraise\"] primitive. We do this as the compiler is currently not good enough at\n automatically detecting reraise [1]. We patch the stdlib so that everything is\n affected, including libraries defined before base such as sexplib or non Jane Street\n libraries.\n\n We need this definition so that this implementation can match its interface with the\n patched stdlib and with the original one.\n\n [[1] http://caml.inria.fr/mantis/view.php?id=6556\n*)\nexternal raise : exn -> 'a = \"%reraise\"\n","open! Import\nmodule Sign = Base.Sign\n\nmodule Stable = struct\n module V1 = struct\n type t = Sign.t =\n | Neg\n | Zero\n | Pos\n [@@deriving sexp, bin_io, compare, hash, typerep, enumerate]\n end\nend\n\ninclude Stable.V1\ninclude Sign\ninclude Identifiable.Extend (Sign) (Stable.V1)\n","external format_float : string -> float -> string = \"caml_format_float\"\n\n(* Stolen from [pervasives.ml]. Adds a \".\" at the end if needed. It is in\n [pervasives.mli], but it also says not to use it directly, so we copy and paste the\n code. It makes the assumption on the string passed in argument that it was returned by\n [format_float] *)\nlet valid_float_lexem s =\n let l = String.length s in\n let rec loop i =\n if i >= l\n then s ^ \".\"\n else (\n match s.[i] with\n | '0' .. '9' | '-' -> loop (i + 1)\n | _ -> s)\n in\n loop 0\n;;\n\nopen! Import\nmodule List = Base.List\n\nmodule T = struct\n include Base.Float\n\n type t = float [@@deriving bin_io, typerep]\nend\n\ninclude T\ninclude Hashable.Make_binable (T)\ninclude Comparable.Map_and_set_binable_using_comparator (T)\nmodule Replace_polymorphic_compare : Comparisons.S with type t := t = T\n\nmodule Robust_compare = struct\n module type S = sig\n (* intended to be a tolerance on human-entered floats *)\n\n val robust_comparison_tolerance : float\n\n include Robustly_comparable.S with type t := float\n end\n\n module Make (T : sig\n val robust_comparison_tolerance : float\n end) : S = struct\n (* We have test in the tree that rely on these functions not allocating, even without\n X_LIBRARY_INLING. The only way to ensure that these don't create temporary boxed\n floats without X_LIBRARY_INLING is for this code to see the float operations as\n externals, as defined in [Pervasives]. That's why we use [Poly] and float\n arithmetic from [Caml]. *)\n open Poly\n\n let robust_comparison_tolerance = T.robust_comparison_tolerance\n let ( >=. ) x y = x >= Caml.( -. ) y robust_comparison_tolerance\n let ( <=. ) x y = y >=. x\n let ( =. ) x y = x >=. y && y >=. x\n let ( >. ) x y = x > Caml.( +. ) y robust_comparison_tolerance\n let ( <. ) x y = y >. x\n let ( <>. ) x y = not (x =. y)\n\n let robustly_compare x y =\n let d = Caml.( -. ) x y in\n if d < Caml.( ~-. ) robust_comparison_tolerance\n then -1\n else if d > robust_comparison_tolerance\n then 1\n else 0\n ;;\n end\nend\n\nmodule Robustly_comparable = Robust_compare.Make (struct\n let robust_comparison_tolerance = 1E-7\n end)\n\ninclude Robustly_comparable\n\nmodule O = struct\n include Base.Float.O\n include Robustly_comparable\nend\n\nmodule Terse = struct\n type nonrec t = t [@@deriving bin_io]\n\n include (\n Base.Float.Terse :\n module type of struct\n include Base.Float.Terse\n end\n with type t := t)\nend\n\nlet robust_sign t : Sign.t = if t >. 0. then Pos else if t <. 0. then Neg else Zero\n\n(* There are two issues:\n - Float.sign used to use robust comparison, and users of [Core] might have come to\n depend on this.\n - Robustness aside, what we get from Comparable.With_zero would map nan to Neg.\n*)\nlet sign = robust_sign\n\n(* Standard 12 significant digits, exponential notation used as necessary, guaranteed to\n be a valid OCaml float lexem, not to look like an int. *)\nlet to_string_12 x = valid_float_lexem (format_float \"%.12g\" x)\nlet quickcheck_generator = Base_quickcheck.Generator.float\nlet quickcheck_observer = Base_quickcheck.Observer.float\nlet quickcheck_shrinker = Base_quickcheck.Shrinker.float\nlet gen_uniform_excl = Base_quickcheck.Generator.float_uniform_exclusive\nlet gen_incl = Base_quickcheck.Generator.float_inclusive\nlet gen_without_nan = Base_quickcheck.Generator.float_without_nan\nlet gen_finite = Base_quickcheck.Generator.float_finite\nlet gen_positive = Base_quickcheck.Generator.float_strictly_positive\nlet gen_negative = Base_quickcheck.Generator.float_strictly_negative\nlet gen_zero = Base_quickcheck.Generator.float_of_class Zero\nlet gen_nan = Base_quickcheck.Generator.float_of_class Nan\nlet gen_subnormal = Base_quickcheck.Generator.float_of_class Subnormal\nlet gen_normal = Base_quickcheck.Generator.float_of_class Normal\nlet gen_infinite = Base_quickcheck.Generator.float_of_class Infinite\n","open! Import\n\nmodule Stable = struct\n module V1 = struct\n module T = struct\n include Base.Int\n\n type t = int [@@deriving hash, bin_io, sexp]\n end\n\n include T\n include Comparable.Stable.V1.Make (T)\n end\nend\n\ninclude Identifiable.Extend\n (Base.Int)\n (struct\n type t = int [@@deriving bin_io]\n end)\n\nmodule Replace_polymorphic_compare = Base.Int\ninclude Base.Int\n\ntype t = int [@@deriving typerep]\n\nmodule Hex = struct\n include Hex\n\n type nonrec t = t [@@deriving typerep, bin_io]\nend\n\nlet quickcheck_generator = Base_quickcheck.Generator.int\nlet quickcheck_observer = Base_quickcheck.Observer.int\nlet quickcheck_shrinker = Base_quickcheck.Shrinker.int\nlet gen_incl = Base_quickcheck.Generator.int_inclusive\nlet gen_uniform_incl = Base_quickcheck.Generator.int_uniform_inclusive\nlet gen_log_incl = Base_quickcheck.Generator.int_log_inclusive\nlet gen_log_uniform_incl = Base_quickcheck.Generator.int_log_uniform_inclusive\n","open! Import\n\ninclude Identifiable.Extend\n (Base.Int32)\n (struct\n type t = int32 [@@deriving bin_io]\n end)\n\ninclude Base.Int32\n\ntype t = int32 [@@deriving typerep]\n\nmodule Hex = struct\n include Hex\n\n type nonrec t = t [@@deriving typerep, bin_io]\nend\n\nlet quickcheck_generator = Base_quickcheck.Generator.int32\nlet quickcheck_observer = Base_quickcheck.Observer.int32\nlet quickcheck_shrinker = Base_quickcheck.Shrinker.int32\nlet gen_incl = Base_quickcheck.Generator.int32_inclusive\nlet gen_uniform_incl = Base_quickcheck.Generator.int32_uniform_inclusive\nlet gen_log_incl = Base_quickcheck.Generator.int32_log_inclusive\nlet gen_log_uniform_incl = Base_quickcheck.Generator.int32_log_uniform_inclusive\n","(* unsigned_extended.ml *)\n\nopen Core_kernel\ninclude Intf\nopen Snark_params\nopen Tick\n\nmodule type Unsigned_intf = Unsigned.S\n\nmodule Extend\n (Unsigned : Unsigned.S) (M : sig\n val length : int\n end) : S with type t = Unsigned.t = struct\n assert (M.length < Field.size_in_bits - 3)\n\n let length_in_bits = M.length\n\n module T = struct\n include Sexpable.Of_stringable (Unsigned)\n\n type t = Unsigned.t\n\n let compare = Unsigned.compare\n\n let hash_fold_t s t = Int64.hash_fold_t s (Unsigned.to_int64 t)\n\n let hash t = Int64.hash (Unsigned.to_int64 t)\n\n let to_bigint t =\n let i64 = Unsigned.to_int64 t in\n if Int64.(i64 >= 0L) then Bignum_bigint.of_int64 i64\n else\n Bignum_bigint.(\n of_int64 i64 - of_int64 Int64.min_value + of_int64 Int64.max_value\n + one)\n end\n\n include T\n include Hashable.Make (T)\n\n include (Unsigned : Unsigned_intf with type t := t)\n\n (* serializes to and from json as strings since bit lengths > 32 cannot be represented in json *)\n let to_yojson n = `String (to_string n)\n\n let of_yojson = function\n | `String s ->\n Ok (of_string s)\n | _ ->\n Error \"expected string\"\n\n let ( < ) x y = compare x y < 0\n\n let ( > ) x y = compare x y > 0\n\n let ( = ) x y = compare x y = 0\n\n let ( <= ) x y = compare x y <= 0\n\n let ( >= ) x y = compare x y >= 0\nend\n\nmodule UInt64 = struct\n module M =\n Extend\n (Unsigned.UInt64)\n (struct\n let length = 64\n end)\n\n (* this module allows use to generate With_all_version_tags from the\n Binable.Of_binable functor below, needed to decode transaction ids\n for V1 signed commands; it does not add any tags\n *)\n module Int64_for_version_tags = struct\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n type t = (Int64.t[@version_asserted])\n\n let to_latest = Fn.id\n\n module With_all_version_tags = struct\n type typ = t [@@deriving bin_io_unversioned]\n\n type t = typ [@@deriving bin_io_unversioned]\n end\n end\n end]\n end\n\n [%%versioned_binable\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n [@@@with_all_version_tags]\n\n type t = Unsigned.UInt64.t\n\n let to_latest = Fn.id\n\n (* these are defined in the Extend functor, rather than derived, so import them *)\n [%%define_locally\n M.\n ( equal\n , compare\n , hash\n , hash_fold_t\n , sexp_of_t\n , t_of_sexp\n , to_yojson\n , of_yojson )]\n\n module M = struct\n type t = Unsigned.UInt64.t\n\n let to_binable = Unsigned.UInt64.to_int64\n\n let of_binable = Unsigned.UInt64.of_int64\n end\n\n include Binable.Of_binable (Int64_for_version_tags.Stable.V1) (M)\n end\n end]\n\n include M\n\n let dhall_type = Ppx_dhall_type.Dhall_type.Text\n\n let to_uint64 : t -> uint64 = Fn.id\n\n let of_uint64 : uint64 -> t = Fn.id\nend\n\nmodule UInt32 = struct\n module M =\n Extend\n (Unsigned.UInt32)\n (struct\n let length = 32\n end)\n\n (* this module allows use to generate With_all_version_tags from the\n Binable.Of_binable functor below, needed to decode transaction ids\n for V1 signed commands; it does not add any tags\n *)\n module Int32_for_version_tags = struct\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n type t = (Int32.t[@version_asserted])\n\n let to_latest = Fn.id\n\n module With_all_version_tags = struct\n type typ = t [@@deriving bin_io_unversioned]\n\n type t = typ [@@deriving bin_io_unversioned]\n end\n end\n end]\n end\n\n [%%versioned_binable\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n [@@@with_all_version_tags]\n\n type t = Unsigned.UInt32.t\n\n let to_latest = Fn.id\n\n (* these are defined in the Extend functor, rather than derived, so import them *)\n [%%define_locally\n M.\n ( equal\n , compare\n , hash\n , hash_fold_t\n , sexp_of_t\n , t_of_sexp\n , to_yojson\n , of_yojson )]\n\n module M = struct\n type t = Unsigned.UInt32.t\n\n let to_binable = Unsigned.UInt32.to_int32\n\n let of_binable = Unsigned.UInt32.of_int32\n end\n\n include Binable.Of_binable (Int32_for_version_tags.Stable.V1) (M)\n end\n end]\n\n include M\n\n let to_uint32 : t -> uint32 = Fn.id\n\n let of_uint32 : uint32 -> t = Fn.id\nend\n","open! Import\n\ninclude Identifiable.Extend\n (Base.Int64)\n (struct\n type t = int64 [@@deriving bin_io]\n end)\n\ninclude Base.Int64\n\ntype t = int64 [@@deriving typerep]\n\nmodule Hex = struct\n include Hex\n\n type nonrec t = t [@@deriving typerep, bin_io]\nend\n\nlet quickcheck_generator = Base_quickcheck.Generator.int64\nlet quickcheck_observer = Base_quickcheck.Observer.int64\nlet quickcheck_shrinker = Base_quickcheck.Shrinker.int64\nlet gen_incl = Base_quickcheck.Generator.int64_inclusive\nlet gen_uniform_incl = Base_quickcheck.Generator.int64_uniform_inclusive\nlet gen_log_incl = Base_quickcheck.Generator.int64_log_inclusive\nlet gen_log_uniform_incl = Base_quickcheck.Generator.int64_log_uniform_inclusive\n","open! Import\n\nmodule Bin : Binable0.S with type t := Base.Int63.t = struct\n module Bin_emulated = struct\n type t = Base.Int63.Private.Emul.t\n\n include Binable0.Of_binable_without_uuid [@alert \"-legacy\"]\n (Int64)\n (struct\n type nonrec t = t\n\n let of_binable = Base.Int63.Private.Emul.W.wrap_exn\n let to_binable = Base.Int63.Private.Emul.W.unwrap\n end)\n end\n\n type 'a binable = (module Binable0.S with type t = 'a)\n\n let binable_of_repr : type a b. (a, b) Base.Int63.Private.Repr.t -> b binable\n = function\n | Base.Int63.Private.Repr.Int -> (module Int)\n | Base.Int63.Private.Repr.Int64 -> (module Bin_emulated)\n ;;\n\n let binable : Base.Int63.t binable = binable_of_repr Base.Int63.Private.repr\n\n include (val binable)\n\n let bin_shape_t = Bin_prot.Shape.bin_shape_int63\nend\n\nmodule Stable = struct\n module V1 = struct\n module T = struct\n type t = Base.Int63.t [@@deriving hash, sexp]\n\n include Bin\n\n include (\n Base.Int63 :\n Base.Comparable.S\n with type t := t\n with type comparator_witness = Base.Int63.comparator_witness)\n end\n\n include T\n include Comparable.Stable.V1.Make (T)\n end\nend\n\n(* This [include struct] is required because it lets us shadow [t] when we include\n [Base.Int63] later on. *)\ninclude struct\n type t = Base.Int63.t\nend\n\nlet typerep_of_t = typerep_of_int63\nlet typename_of_t = typename_of_int63\n\ninclude Identifiable.Extend\n (Base.Int63)\n (struct\n type nonrec t = t\n\n include Bin\n end)\n\nmodule Replace_polymorphic_compare : Comparable.Polymorphic_compare with type t := t =\n Base.Int63\n\ninclude Base.Int63\n\nmodule Hex = struct\n include Hex\n\n type nonrec t = t [@@deriving typerep, bin_io]\nend\n\nlet quickcheck_generator = Base_quickcheck.Generator.int63\nlet quickcheck_observer = Base_quickcheck.Observer.int63\nlet quickcheck_shrinker = Base_quickcheck.Shrinker.int63\nlet gen_incl = Base_quickcheck.Generator.int63_inclusive\nlet gen_uniform_incl = Base_quickcheck.Generator.int63_uniform_inclusive\nlet gen_log_incl = Base_quickcheck.Generator.int63_log_inclusive\nlet gen_log_uniform_incl = Base_quickcheck.Generator.int63_log_uniform_inclusive\n","module Stable = struct\n open Base.Export\n open Bin_prot.Std\n\n module V1 = struct\n module T = struct\n type t = unit [@@deriving bin_io, compare, sexp]\n end\n\n include T\n include Comparator.Stable.V1.Make (T)\n\n let%expect_test _ =\n print_endline [%bin_digest: t];\n [%expect {| 86ba5df747eec837f0b391dd49f33f9e |}]\n ;;\n end\nend\n\nopen! Import\n\ninclude Identifiable.Extend\n (Base.Unit)\n (struct\n type t = unit [@@deriving bin_io]\n end)\n\ninclude Base.Unit\n\ntype t = unit [@@deriving typerep]\n\nlet quickcheck_generator = Base_quickcheck.Generator.unit\nlet quickcheck_observer = Base_quickcheck.Observer.unit\nlet quickcheck_shrinker = Base_quickcheck.Shrinker.unit\n\nmodule type S = sig end\n\ntype m = (module S)\n","(** Various interface exports. *)\n\nopen! Import\n\nmodule type Applicative = Applicative.S\nmodule type Binable = Binable0.S\nmodule type Comparable = Comparable.S\nmodule type Comparable_binable = Comparable.S_binable\nmodule type Floatable = Floatable.S\nmodule type Hashable = Hashable.S\nmodule type Hashable_binable = Hashable.S_binable\nmodule type Identifiable = Identifiable.S\nmodule type Infix_comparators = Comparable.Infix\nmodule type Intable = Intable.S\nmodule type Monad = Monad.S\nmodule type Quickcheckable = Quickcheckable.S\nmodule type Robustly_comparable = Robustly_comparable.S\nmodule type Sexpable = Sexpable.S\nmodule type Stable = Stable_module_types.S0\nmodule type Stable_int63able = Stable_int63able.S\nmodule type Stable_without_comparator = Stable_module_types.S0_without_comparator\nmodule type Stable1 = Stable_module_types.S1\nmodule type Stable2 = Stable_module_types.S2\nmodule type Stable3 = Stable_module_types.S3\nmodule type Stable4 = Stable_module_types.S4\nmodule type Stringable = Stringable.S\nmodule type Unit = Unit.S\n","open! Import\n\nmodule Stable = struct\n module V1 = struct\n open Sexplib.Std\n\n type 'a t = 'a lazy_t [@@deriving bin_io, sexp, typerep]\n\n let map = Base.Lazy.map\n let compare = Base.Lazy.compare\n let t_sexp_grammar = lazy_t_sexp_grammar\n end\nend\n\nmodule type Base_mask = module type of Base.Lazy with type 'a t := 'a Stable.V1.t\n\ninclude Stable.V1\ninclude (Base.Lazy : Base_mask)\n","open! Import\n\ninclude Identifiable.Extend\n (Base.Nativeint)\n (struct\n type t = nativeint [@@deriving bin_io]\n end)\n\ninclude Base.Nativeint\n\ntype t = nativeint [@@deriving typerep]\n\nmodule Hex = struct\n include Hex\n\n type nonrec t = t [@@deriving typerep, bin_io]\nend\n\nlet quickcheck_generator = Base_quickcheck.Generator.nativeint\nlet quickcheck_observer = Base_quickcheck.Observer.nativeint\nlet quickcheck_shrinker = Base_quickcheck.Shrinker.nativeint\nlet gen_incl = Base_quickcheck.Generator.nativeint_inclusive\nlet gen_uniform_incl = Base_quickcheck.Generator.nativeint_uniform_inclusive\nlet gen_log_incl = Base_quickcheck.Generator.nativeint_log_inclusive\nlet gen_log_uniform_incl = Base_quickcheck.Generator.nativeint_log_uniform_inclusive\n","open! Import\n\nmodule Stable = struct\n module V1 = struct\n type t = Base.Nothing.t = |\n\n module Shape = struct\n type t [@@deriving bin_shape]\n end\n\n let unreachable_code = Base.Nothing.unreachable_code\n let bin_shape_t = Shape.bin_shape_t\n let tp_loc = [%here].pos_fname ^ \".Stable.V1.t\"\n let all = []\n let hash_fold_t _ t = unreachable_code t\n let hash = unreachable_code\n let compare a _ = unreachable_code a\n let bin_size_t = unreachable_code\n let bin_write_t _buf ~pos:_ t = unreachable_code t\n let bin_writer_t = { Bin_prot.Type_class.size = bin_size_t; write = bin_write_t }\n\n let __bin_read_t__ _buf ~pos_ref _ =\n Bin_prot.Common.raise_variant_wrong_type tp_loc !pos_ref\n ;;\n\n let bin_read_t _buf ~pos_ref =\n Bin_prot.Common.raise_read_error (Empty_type tp_loc) !pos_ref\n ;;\n\n let bin_reader_t =\n { Bin_prot.Type_class.read = bin_read_t; vtag_read = __bin_read_t__ }\n ;;\n\n let bin_t =\n { Bin_prot.Type_class.writer = bin_writer_t\n ; reader = bin_reader_t\n ; shape = bin_shape_t\n }\n ;;\n\n let sexp_of_t = unreachable_code\n let t_of_sexp sexp = Sexplib.Conv_error.empty_type tp_loc sexp\n end\nend\n\ninclude Stable.V1\ninclude Base.Nothing\ninclude Identifiable.Extend (Base.Nothing) (Stable.V1)\n","open! Import\n\ntype t = Base.Ordering.t =\n | Less\n | Equal\n | Greater\n[@@deriving bin_io, compare, hash, sexp]\n\nmodule type Base_mask = module type of Base.Ordering with type t := t\n\ninclude (Base.Ordering : Base_mask)\n","open! Import\n\nmodule T = struct\n include Base.Ref\n\n include (\n struct\n type 'a t = 'a ref [@@deriving bin_io, typerep]\n end :\n sig\n type 'a t = 'a ref [@@deriving bin_io, typerep]\n end\n with type 'a t := 'a t)\nend\n\ninclude T\n\nmodule Permissioned = struct\n include T\n\n type ('a, -'perms) t = 'a T.t [@@deriving bin_io, sexp]\n\n let read_only = Fn.id\n let of_ref = Fn.id\n let to_ref = Fn.id\n let set = ( := )\n let get = ( ! )\nend\n","(* zkapp_command_logic.ml *)\n\nopen Core_kernel\nopen Mina_base\n\nmodule type Iffable = sig\n type bool\n\n type t\n\n val if_ : bool -> then_:t -> else_:t -> t\nend\n\nmodule type Bool_intf = sig\n type t\n\n include Iffable with type t := t and type bool := t\n\n val true_ : t\n\n val false_ : t\n\n val equal : t -> t -> t\n\n val not : t -> t\n\n val ( ||| ) : t -> t -> t\n\n val ( &&& ) : t -> t -> t\n\n module Assert : sig\n (* [pos] is file,line,col,endcol from __POS__ *)\n val is_true : pos:string * int * int * int -> t -> unit\n\n (* [pos] is file,line,col,endcol from __POS__ *)\n val any : pos:string * int * int * int -> t list -> unit\n end\n\n val display : t -> label:string -> string\n\n val all : t list -> t\n\n type failure_status\n\n type failure_status_tbl\n\n (* [pos] is file,line,col,endcol from __POS__ *)\n val assert_with_failure_status_tbl :\n pos:string * int * int * int -> t -> failure_status_tbl -> unit\nend\n\nmodule type Balance_intf = sig\n include Iffable\n\n type amount\n\n type signed_amount\n\n val sub_amount_flagged : t -> amount -> t * [ `Underflow of bool ]\n\n val add_signed_amount_flagged : t -> signed_amount -> t * [ `Overflow of bool ]\nend\n\nmodule type Receipt_chain_hash_intf = sig\n include Iffable\n\n type transaction_commitment\n\n type index\n\n module Elt : sig\n type t\n\n val of_transaction_commitment : transaction_commitment -> t\n end\n\n val cons_zkapp_command_commitment : index -> Elt.t -> t -> t\nend\n\nmodule type Amount_intf = sig\n include Iffable\n\n type unsigned = t\n\n module Signed : sig\n include Iffable with type bool := bool\n\n val equal : t -> t -> bool\n\n val is_neg : t -> bool\n\n val is_non_neg : t -> bool\n\n val negate : t -> t\n\n val add_flagged : t -> t -> t * [ `Overflow of bool ]\n\n val of_unsigned : unsigned -> t\n end\n\n val zero : t\n\n val equal : t -> t -> bool\n\n val add_flagged : t -> t -> t * [ `Overflow of bool ]\n\n val add_signed_flagged : t -> Signed.t -> t * [ `Overflow of bool ]\n\n val of_constant_fee : Currency.Fee.t -> t\nend\n\nmodule type Account_id_intf = sig\n include Iffable\n\n type public_key\n\n type token_id\n\n val invalid : t\n\n val equal : t -> t -> bool\n\n val create : public_key -> token_id -> t\n\n val derive_token_id : owner:t -> token_id\nend\n\nmodule type Global_slot_since_genesis_intf = sig\n include Iffable\n\n val zero : t\n\n val ( > ) : t -> t -> bool\n\n val equal : t -> t -> bool\nend\n\nmodule type Global_slot_span_intf = sig\n include Iffable\n\n val zero : t\n\n val ( > ) : t -> t -> bool\nend\n\nmodule type Verification_key_hash_intf = sig\n type t\n\n type bool\n\n val equal : t -> t -> bool\nend\n\nmodule type Timing_intf = sig\n include Iffable\n\n type global_slot_span\n\n val vesting_period : t -> global_slot_span\nend\n\nmodule type Token_id_intf = sig\n include Iffable\n\n val equal : t -> t -> bool\n\n val default : t\nend\n\nmodule type Actions_intf = sig\n type t\n\n type bool\n\n type field\n\n val is_empty : t -> bool\n\n val push_events : field -> t -> field\nend\n\nmodule type Protocol_state_precondition_intf = sig\n type t\nend\n\nmodule type Valid_while_precondition_intf = sig\n type t\nend\n\nmodule Local_state = struct\n open Core_kernel\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n type ( 'stack_frame\n , 'call_stack\n , 'signed_amount\n , 'ledger\n , 'bool\n , 'comm\n , 'length\n , 'failure_status_tbl )\n t =\n ( 'stack_frame\n , 'call_stack\n , 'signed_amount\n , 'ledger\n , 'bool\n , 'comm\n , 'length\n , 'failure_status_tbl )\n Mina_wire_types.Mina_transaction_logic.Zkapp_command_logic\n .Local_state\n .V1\n .t =\n { stack_frame : 'stack_frame\n ; call_stack : 'call_stack\n ; transaction_commitment : 'comm\n ; full_transaction_commitment : 'comm\n ; excess : 'signed_amount\n ; supply_increase : 'signed_amount\n ; ledger : 'ledger\n ; success : 'bool\n ; account_update_index : 'length\n ; failure_status_tbl : 'failure_status_tbl\n ; will_succeed : 'bool\n }\n [@@deriving compare, equal, hash, sexp, yojson, fields, hlist]\n end\n end]\n\n let typ stack_frame call_stack excess supply_increase ledger bool comm length\n failure_status_tbl =\n Pickles.Impls.Step.Typ.of_hlistable\n [ stack_frame\n ; call_stack\n ; comm\n ; comm\n ; excess\n ; supply_increase\n ; ledger\n ; bool\n ; length\n ; failure_status_tbl\n ; bool\n ]\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist\n\n module Value = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t =\n ( Mina_base.Stack_frame.Digest.Stable.V1.t\n , Mina_base.Call_stack_digest.Stable.V1.t\n , ( Currency.Amount.Stable.V1.t\n , Sgn.Stable.V1.t )\n Currency.Signed_poly.Stable.V1.t\n , Ledger_hash.Stable.V1.t\n , bool\n , Zkapp_command.Transaction_commitment.Stable.V1.t\n , Mina_numbers.Index.Stable.V1.t\n , Transaction_status.Failure.Collection.Stable.V1.t )\n Stable.V1.t\n [@@deriving equal, compare, hash, yojson, sexp]\n\n let to_latest = Fn.id\n end\n end]\n end\n\n module Checked = struct\n open Pickles.Impls.Step\n\n type t =\n ( Stack_frame.Digest.Checked.t\n , Call_stack_digest.Checked.t\n , Currency.Amount.Signed.Checked.t\n , Ledger_hash.var\n , Boolean.var\n , Zkapp_command.Transaction_commitment.Checked.t\n , Mina_numbers.Index.Checked.t\n , unit )\n Stable.Latest.t\n end\nend\n\nmodule type Set_or_keep_intf = sig\n type _ t\n\n type bool\n\n val is_set : _ t -> bool\n\n val is_keep : _ t -> bool\n\n val set_or_keep : if_:(bool -> then_:'a -> else_:'a -> 'a) -> 'a t -> 'a -> 'a\nend\n\nmodule type Account_update_intf = sig\n type t\n\n type bool\n\n type call_forest\n\n type signed_amount\n\n type transaction_commitment\n\n type protocol_state_precondition\n\n type valid_while_precondition\n\n type public_key\n\n type token_id\n\n type account_id\n\n type account\n\n type nonce\n\n type verification_key_hash\n\n type _ or_ignore\n\n val balance_change : t -> signed_amount\n\n val protocol_state_precondition : t -> protocol_state_precondition\n\n val valid_while_precondition : t -> valid_while_precondition\n\n val public_key : t -> public_key\n\n val token_id : t -> token_id\n\n val account_id : t -> account_id\n\n val may_use_parents_own_token : t -> bool\n\n val may_use_token_inherited_from_parent : t -> bool\n\n val use_full_commitment : t -> bool\n\n val increment_nonce : t -> bool\n\n val implicit_account_creation_fee : t -> bool\n\n val check_authorization :\n will_succeed:bool\n -> commitment:transaction_commitment\n -> calls:call_forest\n -> t\n -> [ `Proof_verifies of bool ] * [ `Signature_verifies of bool ]\n\n val is_signed : t -> bool\n\n val is_proved : t -> bool\n\n val verification_key_hash : t -> verification_key_hash\n\n module Update : sig\n type _ set_or_keep\n\n type timing\n\n val timing : t -> timing set_or_keep\n\n type field\n\n val app_state : t -> field set_or_keep Zkapp_state.V.t\n\n type verification_key\n\n val verification_key : t -> verification_key set_or_keep\n\n type actions\n\n val actions : t -> actions\n\n type zkapp_uri\n\n val zkapp_uri : t -> zkapp_uri set_or_keep\n\n type token_symbol\n\n val token_symbol : t -> token_symbol set_or_keep\n\n val delegate : t -> public_key set_or_keep\n\n type state_hash\n\n val voting_for : t -> state_hash set_or_keep\n\n type permissions\n\n val permissions : t -> permissions set_or_keep\n end\n\n module Account_precondition : sig\n val nonce : t -> nonce Zkapp_precondition.Closed_interval.t or_ignore\n end\nend\n\nmodule type Opt_intf = sig\n type bool\n\n type 'a t\n\n val is_some : 'a t -> bool\n\n val map : 'a t -> f:('a -> 'b) -> 'b t\n\n val or_default :\n if_:(bool -> then_:'a -> else_:'a -> 'a) -> 'a t -> default:'a -> 'a\n\n val or_exn : 'a t -> 'a\nend\n\nmodule type Stack_intf = sig\n include Iffable\n\n module Opt : Opt_intf with type bool := bool\n\n type elt\n\n val empty : unit -> t\n\n val is_empty : t -> bool\n\n val pop_exn : t -> elt * t\n\n val pop : t -> (elt * t) Opt.t\n\n val push : elt -> onto:t -> t\nend\n\nmodule type Call_forest_intf = sig\n include Iffable\n\n type account_update\n\n module Opt : Opt_intf with type bool := bool\n\n val empty : unit -> t\n\n val is_empty : t -> bool\n\n val pop_exn : t -> (account_update * t) * t\nend\n\nmodule type Stack_frame_intf = sig\n type caller\n\n type call_forest\n\n include Iffable\n\n val caller : t -> caller\n\n val caller_caller : t -> caller\n\n val calls : t -> call_forest\n\n val make : caller:caller -> caller_caller:caller -> calls:call_forest -> t\nend\n\nmodule type Call_stack_intf = sig\n type stack_frame\n\n include Stack_intf with type elt := stack_frame\nend\n\nmodule type Ledger_intf = sig\n include Iffable\n\n type public_key\n\n type token_id\n\n type account_update\n\n type account\n\n type inclusion_proof\n\n val empty : depth:int -> unit -> t\n\n val get_account : account_update -> t -> account * inclusion_proof\n\n val set_account : t -> account * inclusion_proof -> t\n\n val check_inclusion : t -> account * inclusion_proof -> unit\n\n val check_account :\n public_key -> token_id -> account * inclusion_proof -> [ `Is_new of bool ]\nend\n\nmodule type Controller_intf = sig\n include Iffable\n\n val check : proof_verifies:bool -> signature_verifies:bool -> t -> bool\nend\n\nmodule type Account_intf = sig\n type t\n\n type bool\n\n type public_key\n\n type account_id\n\n module Permissions : sig\n type controller\n\n val access : t -> controller\n\n val edit_state : t -> controller\n\n val send : t -> controller\n\n val receive : t -> controller\n\n val set_delegate : t -> controller\n\n val set_permissions : t -> controller\n\n val set_verification_key : t -> controller\n\n val set_zkapp_uri : t -> controller\n\n val edit_action_state : t -> controller\n\n val set_token_symbol : t -> controller\n\n val increment_nonce : t -> controller\n\n val set_voting_for : t -> controller\n\n val set_timing : t -> controller\n\n include Iffable with type bool := bool\n end\n\n type timing\n\n type token_id\n\n type receipt_chain_hash\n\n val timing : t -> timing\n\n val set_timing : t -> timing -> t\n\n val is_timed : t -> bool\n\n val set_token_id : t -> token_id -> t\n\n type balance\n\n val balance : t -> balance\n\n val set_balance : balance -> t -> t\n\n type global_slot\n\n val check_timing :\n txn_global_slot:global_slot\n -> t\n -> [ `Invalid_timing of bool | `Insufficient_balance of bool ] * timing\n\n val receipt_chain_hash : t -> receipt_chain_hash\n\n val set_receipt_chain_hash : t -> receipt_chain_hash -> t\n\n (** Fill the zkapp field of the account if it's currently [None] *)\n val make_zkapp : t -> t\n\n (** If the current account has no zkApp fields set, reset its zkapp field to\n [None].\n *)\n val unmake_zkapp : t -> t\n\n val proved_state : t -> bool\n\n val set_proved_state : bool -> t -> t\n\n type field\n\n val app_state : t -> field Zkapp_state.V.t\n\n val set_app_state : field Zkapp_state.V.t -> t -> t\n\n val register_verification_key : t -> unit\n\n type verification_key\n\n val verification_key : t -> verification_key\n\n val set_verification_key : verification_key -> t -> t\n\n type verification_key_hash\n\n val verification_key_hash : t -> verification_key_hash\n\n val last_action_slot : t -> global_slot\n\n val set_last_action_slot : global_slot -> t -> t\n\n val action_state : t -> field Pickles_types.Vector.Vector_5.t\n\n val set_action_state : field Pickles_types.Vector.Vector_5.t -> t -> t\n\n type zkapp_uri\n\n val zkapp_uri : t -> zkapp_uri\n\n val set_zkapp_uri : zkapp_uri -> t -> t\n\n type token_symbol\n\n val token_symbol : t -> token_symbol\n\n val set_token_symbol : token_symbol -> t -> t\n\n val public_key : t -> public_key\n\n val set_public_key : public_key -> t -> t\n\n val delegate : t -> public_key\n\n val set_delegate : public_key -> t -> t\n\n type nonce\n\n val nonce : t -> nonce\n\n val set_nonce : nonce -> t -> t\n\n type state_hash\n\n val voting_for : t -> state_hash\n\n val set_voting_for : state_hash -> t -> t\n\n val permissions : t -> Permissions.t\n\n val set_permissions : Permissions.t -> t -> t\nend\n\nmodule Eff = struct\n type (_, _) t =\n | Check_valid_while_precondition :\n 'valid_while_precondition * 'global_state\n -> ( 'bool\n , < bool : 'bool\n ; valid_while_precondition : 'valid_while_precondition\n ; global_state : 'global_state\n ; .. > )\n t\n | Check_account_precondition :\n (* the bool input is a new_account flag *)\n 'account_update\n * 'account\n * 'bool\n * 'local_state\n -> ( 'local_state\n , < bool : 'bool\n ; account_update : 'account_update\n ; account : 'account\n ; local_state : 'local_state\n ; .. > )\n t\n | Check_protocol_state_precondition :\n 'protocol_state_pred * 'global_state\n -> ( 'bool\n , < bool : 'bool\n ; global_state : 'global_state\n ; protocol_state_precondition : 'protocol_state_pred\n ; .. > )\n t\n | Init_account :\n { account_update : 'account_update; account : 'account }\n -> ( 'account\n , < account_update : 'account_update ; account : 'account ; .. > )\n t\nend\n\ntype 'e handler = { perform : 'r. ('r, 'e) Eff.t -> 'r }\n\nmodule type Inputs_intf = sig\n val with_label : label:string -> (unit -> 'a) -> 'a\n\n module Bool : Bool_intf\n\n module Field : Iffable with type bool := Bool.t\n\n module Amount : Amount_intf with type bool := Bool.t\n\n module Balance :\n Balance_intf\n with type bool := Bool.t\n and type amount := Amount.t\n and type signed_amount := Amount.Signed.t\n\n module Public_key : Iffable with type bool := Bool.t\n\n module Token_id : Token_id_intf with type bool := Bool.t\n\n module Account_id :\n Account_id_intf\n with type bool := Bool.t\n and type public_key := Public_key.t\n and type token_id := Token_id.t\n\n module Set_or_keep : Set_or_keep_intf with type bool := Bool.t\n\n module Protocol_state_precondition : Protocol_state_precondition_intf\n\n module Valid_while_precondition : Valid_while_precondition_intf\n\n module Controller : Controller_intf with type bool := Bool.t\n\n module Global_slot_since_genesis :\n Global_slot_since_genesis_intf with type bool := Bool.t\n\n module Global_slot_span : Global_slot_span_intf with type bool := Bool.t\n\n module Nonce : sig\n include Iffable with type bool := Bool.t\n\n val succ : t -> t\n end\n\n module State_hash : Iffable with type bool := Bool.t\n\n module Timing :\n Timing_intf\n with type bool := Bool.t\n and type global_slot_span := Global_slot_span.t\n\n module Zkapp_uri : Iffable with type bool := Bool.t\n\n module Token_symbol : Iffable with type bool := Bool.t\n\n module Opt : Opt_intf with type bool := Bool.t\n\n module rec Receipt_chain_hash :\n (Receipt_chain_hash_intf\n with type bool := Bool.t\n and type transaction_commitment := Transaction_commitment.t\n and type index := Index.t)\n\n and Verification_key : (Iffable with type bool := Bool.t)\n and Verification_key_hash :\n (Verification_key_hash_intf with type bool := Bool.t)\n\n and Account :\n (Account_intf\n with type Permissions.controller := Controller.t\n and type timing := Timing.t\n and type balance := Balance.t\n and type receipt_chain_hash := Receipt_chain_hash.t\n and type bool := Bool.t\n and type global_slot := Global_slot_since_genesis.t\n and type field := Field.t\n and type verification_key := Verification_key.t\n and type verification_key_hash := Verification_key_hash.t\n and type zkapp_uri := Zkapp_uri.t\n and type token_symbol := Token_symbol.t\n and type public_key := Public_key.t\n and type nonce := Nonce.t\n and type state_hash := State_hash.t\n and type token_id := Token_id.t\n and type account_id := Account_id.t)\n\n and Actions :\n (Actions_intf with type bool := Bool.t and type field := Field.t)\n\n and Account_update :\n (Account_update_intf\n with type signed_amount := Amount.Signed.t\n and type protocol_state_precondition := Protocol_state_precondition.t\n and type valid_while_precondition := Valid_while_precondition.t\n and type token_id := Token_id.t\n and type bool := Bool.t\n and type account := Account.t\n and type public_key := Public_key.t\n and type nonce := Nonce.t\n and type account_id := Account_id.t\n and type verification_key_hash := Verification_key_hash.t\n and type Update.timing := Timing.t\n and type 'a Update.set_or_keep := 'a Set_or_keep.t\n and type Update.field := Field.t\n and type Update.verification_key := Verification_key.t\n and type Update.actions := Actions.t\n and type Update.zkapp_uri := Zkapp_uri.t\n and type Update.token_symbol := Token_symbol.t\n and type Update.state_hash := State_hash.t\n and type Update.permissions := Account.Permissions.t)\n\n and Nonce_precondition : sig\n val is_constant :\n Nonce.t Zkapp_precondition.Closed_interval.t Account_update.or_ignore\n -> Bool.t\n end\n\n and Ledger :\n (Ledger_intf\n with type bool := Bool.t\n and type account := Account.t\n and type account_update := Account_update.t\n and type token_id := Token_id.t\n and type public_key := Public_key.t)\n\n and Call_forest :\n (Call_forest_intf\n with type t = Account_update.call_forest\n and type bool := Bool.t\n and type account_update := Account_update.t\n and module Opt := Opt)\n\n and Stack_frame :\n (Stack_frame_intf\n with type bool := Bool.t\n and type call_forest := Call_forest.t\n and type caller := Token_id.t)\n\n and Call_stack :\n (Call_stack_intf\n with type stack_frame := Stack_frame.t\n and type bool := Bool.t\n and module Opt := Opt)\n\n and Transaction_commitment : sig\n include\n Iffable\n with type bool := Bool.t\n and type t = Account_update.transaction_commitment\n\n val empty : t\n\n val commitment : account_updates:Call_forest.t -> t\n\n val full_commitment :\n account_update:Account_update.t -> memo_hash:Field.t -> commitment:t -> t\n end\n\n and Index : sig\n include Iffable with type bool := Bool.t\n\n val zero : t\n\n val succ : t -> t\n end\n\n module Local_state : sig\n type t =\n ( Stack_frame.t\n , Call_stack.t\n , Amount.Signed.t\n , Ledger.t\n , Bool.t\n , Transaction_commitment.t\n , Index.t\n , Bool.failure_status_tbl )\n Local_state.t\n\n val add_check : t -> Transaction_status.Failure.t -> Bool.t -> t\n\n val update_failure_status_tbl : t -> Bool.failure_status -> Bool.t -> t\n\n val add_new_failure_status_bucket : t -> t\n end\n\n module Global_state : sig\n type t\n\n val first_pass_ledger : t -> Ledger.t\n\n val set_first_pass_ledger : should_update:Bool.t -> t -> Ledger.t -> t\n\n val second_pass_ledger : t -> Ledger.t\n\n val set_second_pass_ledger : should_update:Bool.t -> t -> Ledger.t -> t\n\n val fee_excess : t -> Amount.Signed.t\n\n val set_fee_excess : t -> Amount.Signed.t -> t\n\n val supply_increase : t -> Amount.Signed.t\n\n val set_supply_increase : t -> Amount.Signed.t -> t\n\n val block_global_slot : t -> Global_slot_since_genesis.t\n end\nend\n\nmodule Start_data = struct\n open Core_kernel\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n type ('account_updates, 'field, 'bool) t =\n { account_updates : 'account_updates\n ; memo_hash : 'field\n ; will_succeed : 'bool\n }\n [@@deriving sexp, yojson]\n end\n end]\nend\n\nmodule Make (Inputs : Inputs_intf) = struct\n open Inputs\n\n let default_caller = Token_id.default\n\n let stack_frame_default () =\n Stack_frame.make ~caller:default_caller ~caller_caller:default_caller\n ~calls:(Call_forest.empty ())\n\n let assert_ ~pos b = Bool.Assert.is_true ~pos b\n\n (* Pop from the call stack, returning dummy values if the stack is empty. *)\n let pop_call_stack (s : Call_stack.t) : Stack_frame.t * Call_stack.t =\n let res = Call_stack.pop s in\n (* Split out the option returned by Call_stack.pop into two options *)\n let next_frame, next_call_stack =\n (Opt.map ~f:fst res, Opt.map ~f:snd res)\n in\n (* Handle the None cases *)\n ( Opt.or_default ~if_:Stack_frame.if_ ~default:(stack_frame_default ())\n next_frame\n , Opt.or_default ~if_:Call_stack.if_ ~default:(Call_stack.empty ())\n next_call_stack )\n\n type get_next_account_update_result =\n { account_update : Account_update.t\n ; caller_id : Token_id.t\n ; account_update_forest : Call_forest.t\n ; new_call_stack : Call_stack.t\n ; new_frame : Stack_frame.t\n }\n\n let get_next_account_update (current_forest : Stack_frame.t)\n (* The stack for the most recent zkApp *)\n (call_stack : Call_stack.t) (* The partially-completed parent stacks *)\n : get_next_account_update_result =\n (* If the current stack is complete, 'return' to the previous\n partially-completed one.\n *)\n let current_forest, call_stack =\n let next_forest, next_call_stack =\n (* Invariant: call_stack contains only non-empty forests. *)\n pop_call_stack call_stack\n in\n (* TODO: I believe current should only be empty for the first account_update in\n a transaction. *)\n let current_is_empty =\n Call_forest.is_empty (Stack_frame.calls current_forest)\n in\n ( Stack_frame.if_ current_is_empty ~then_:next_forest ~else_:current_forest\n , Call_stack.if_ current_is_empty ~then_:next_call_stack ~else_:call_stack\n )\n in\n let (account_update, account_update_forest), remainder_of_current_forest =\n Call_forest.pop_exn (Stack_frame.calls current_forest)\n in\n let may_use_parents_own_token =\n Account_update.may_use_parents_own_token account_update\n in\n let may_use_token_inherited_from_parent =\n Account_update.may_use_token_inherited_from_parent account_update\n in\n let caller_id =\n Token_id.if_ may_use_token_inherited_from_parent\n ~then_:(Stack_frame.caller_caller current_forest)\n ~else_:\n (Token_id.if_ may_use_parents_own_token\n ~then_:(Stack_frame.caller current_forest)\n ~else_:Token_id.default )\n in\n (* Cases:\n - [account_update_forest] is empty, [remainder_of_current_forest] is empty.\n Pop from the call stack to get another forest, which is guaranteed to be non-empty.\n The result of popping becomes the \"current forest\".\n - [account_update_forest] is empty, [remainder_of_current_forest] is non-empty.\n Push nothing to the stack. [remainder_of_current_forest] becomes new \"current forest\"\n - [account_update_forest] is non-empty, [remainder_of_current_forest] is empty.\n Push nothing to the stack. [account_update_forest] becomes new \"current forest\"\n - [account_update_forest] is non-empty, [remainder_of_current_forest] is non-empty:\n Push [remainder_of_current_forest] to the stack. [account_update_forest] becomes new \"current forest\".\n *)\n let account_update_forest_empty =\n Call_forest.is_empty account_update_forest\n in\n let remainder_of_current_forest_empty =\n Call_forest.is_empty remainder_of_current_forest\n in\n let newly_popped_frame, popped_call_stack = pop_call_stack call_stack in\n let remainder_of_current_forest_frame : Stack_frame.t =\n Stack_frame.make\n ~caller:(Stack_frame.caller current_forest)\n ~caller_caller:(Stack_frame.caller_caller current_forest)\n ~calls:remainder_of_current_forest\n in\n let new_call_stack =\n Call_stack.if_ account_update_forest_empty\n ~then_:\n (Call_stack.if_ remainder_of_current_forest_empty\n ~then_:\n (* Don't actually need the or_default used in this case. *)\n popped_call_stack ~else_:call_stack )\n ~else_:\n (Call_stack.if_ remainder_of_current_forest_empty ~then_:call_stack\n ~else_:\n (Call_stack.push remainder_of_current_forest_frame\n ~onto:call_stack ) )\n in\n let new_frame =\n Stack_frame.if_ account_update_forest_empty\n ~then_:\n (Stack_frame.if_ remainder_of_current_forest_empty\n ~then_:newly_popped_frame ~else_:remainder_of_current_forest_frame )\n ~else_:\n (let caller =\n Account_id.derive_token_id\n ~owner:(Account_update.account_id account_update)\n and caller_caller = caller_id in\n Stack_frame.make ~calls:account_update_forest ~caller ~caller_caller\n )\n in\n { account_update\n ; caller_id\n ; account_update_forest\n ; new_frame\n ; new_call_stack\n }\n\n let update_action_state (action_state : _ Pickles_types.Vector.t) actions\n ~txn_global_slot ~last_action_slot =\n (* Push events to s1. *)\n let [ s1'; s2'; s3'; s4'; s5' ] = action_state in\n let is_empty = Actions.is_empty actions in\n let s1_updated = Actions.push_events s1' actions in\n let s1 = Field.if_ is_empty ~then_:s1' ~else_:s1_updated in\n (* Shift along if not empty and last update wasn't this slot *)\n let is_this_slot =\n Global_slot_since_genesis.equal txn_global_slot last_action_slot\n in\n let is_empty_or_this_slot = Bool.(is_empty ||| is_this_slot) in\n let s5 = Field.if_ is_empty_or_this_slot ~then_:s5' ~else_:s4' in\n let s4 = Field.if_ is_empty_or_this_slot ~then_:s4' ~else_:s3' in\n let s3 = Field.if_ is_empty_or_this_slot ~then_:s3' ~else_:s2' in\n let s2 = Field.if_ is_empty_or_this_slot ~then_:s2' ~else_:s1' in\n let last_action_slot =\n Global_slot_since_genesis.if_ is_empty ~then_:last_action_slot\n ~else_:txn_global_slot\n in\n (([ s1; s2; s3; s4; s5 ] : _ Pickles_types.Vector.t), last_action_slot)\n\n let apply ~(constraint_constants : Genesis_constants.Constraint_constants.t)\n ~(is_start : [ `Yes of _ Start_data.t | `No | `Compute of _ Start_data.t ])\n (h :\n (< global_state : Global_state.t\n ; transaction_commitment : Transaction_commitment.t\n ; full_transaction_commitment : Transaction_commitment.t\n ; amount : Amount.t\n ; bool : Bool.t\n ; failure : Bool.failure_status\n ; .. >\n as\n 'env )\n handler )\n ((global_state : Global_state.t), (local_state : Local_state.t)) =\n let open Inputs in\n let is_start' =\n let is_empty_call_forest =\n Call_forest.is_empty (Stack_frame.calls local_state.stack_frame)\n in\n ( match is_start with\n | `Compute _ ->\n ()\n | `Yes _ ->\n assert_ ~pos:__POS__ is_empty_call_forest\n | `No ->\n assert_ ~pos:__POS__ (Bool.not is_empty_call_forest) ) ;\n match is_start with\n | `Yes _ ->\n Bool.true_\n | `No ->\n Bool.false_\n | `Compute _ ->\n is_empty_call_forest\n in\n let will_succeed =\n match is_start with\n | `Compute start_data ->\n Bool.if_ is_start' ~then_:start_data.will_succeed\n ~else_:local_state.will_succeed\n | `Yes start_data ->\n start_data.will_succeed\n | `No ->\n local_state.will_succeed\n in\n let local_state =\n { local_state with\n ledger =\n Inputs.Ledger.if_ is_start'\n ~then_:(Inputs.Global_state.first_pass_ledger global_state)\n ~else_:local_state.ledger\n ; will_succeed\n }\n in\n let ( (account_update, remaining, call_stack)\n , account_update_forest\n , local_state\n , (a, inclusion_proof) ) =\n let to_pop, call_stack =\n match is_start with\n | `Compute start_data ->\n ( Stack_frame.if_ is_start'\n ~then_:\n (Stack_frame.make ~calls:start_data.account_updates\n ~caller:default_caller ~caller_caller:default_caller )\n ~else_:local_state.stack_frame\n , Call_stack.if_ is_start' ~then_:(Call_stack.empty ())\n ~else_:local_state.call_stack )\n | `Yes start_data ->\n ( Stack_frame.make ~calls:start_data.account_updates\n ~caller:default_caller ~caller_caller:default_caller\n , Call_stack.empty () )\n | `No ->\n (local_state.stack_frame, local_state.call_stack)\n in\n let { account_update\n ; caller_id\n ; account_update_forest\n ; new_frame = remaining\n ; new_call_stack = call_stack\n } =\n with_label ~label:\"get next account update\" (fun () ->\n (* TODO: Make the stack frame hashed inside of the local state *)\n get_next_account_update to_pop call_stack )\n in\n let local_state =\n with_label ~label:\"token owner not caller\" (fun () ->\n let default_token_or_token_owner_was_caller =\n (* Check that the token owner was consulted if using a non-default\n token *)\n let account_update_token_id =\n Account_update.token_id account_update\n in\n Bool.( ||| )\n (Token_id.equal account_update_token_id Token_id.default)\n (Token_id.equal account_update_token_id caller_id)\n in\n Local_state.add_check local_state Token_owner_not_caller\n default_token_or_token_owner_was_caller )\n in\n let ((a, inclusion_proof) as acct) =\n with_label ~label:\"get account\" (fun () ->\n Inputs.Ledger.get_account account_update local_state.ledger )\n in\n Inputs.Ledger.check_inclusion local_state.ledger (a, inclusion_proof) ;\n let transaction_commitment, full_transaction_commitment =\n match is_start with\n | `No ->\n ( local_state.transaction_commitment\n , local_state.full_transaction_commitment )\n | `Yes start_data | `Compute start_data ->\n let tx_commitment_on_start =\n Transaction_commitment.commitment\n ~account_updates:(Stack_frame.calls remaining)\n in\n let full_tx_commitment_on_start =\n Transaction_commitment.full_commitment ~account_update\n ~memo_hash:start_data.memo_hash\n ~commitment:tx_commitment_on_start\n in\n let tx_commitment =\n Transaction_commitment.if_ is_start' ~then_:tx_commitment_on_start\n ~else_:local_state.transaction_commitment\n in\n let full_tx_commitment =\n Transaction_commitment.if_ is_start'\n ~then_:full_tx_commitment_on_start\n ~else_:local_state.full_transaction_commitment\n in\n (tx_commitment, full_tx_commitment)\n in\n let local_state =\n { local_state with transaction_commitment; full_transaction_commitment }\n in\n ( (account_update, remaining, call_stack)\n , account_update_forest\n , local_state\n , acct )\n in\n let local_state =\n { local_state with stack_frame = remaining; call_stack }\n in\n let local_state = Local_state.add_new_failure_status_bucket local_state in\n (* Register verification key, in case it needs to be 'side-loaded' to\n verify a zkapp proof.\n *)\n Account.register_verification_key a ;\n let (`Is_new account_is_new) =\n Inputs.Ledger.check_account\n (Account_update.public_key account_update)\n (Account_update.token_id account_update)\n (a, inclusion_proof)\n in\n (* delegate to public key if new account using default token *)\n let a =\n let self_delegate =\n let account_update_token_id = Account_update.token_id account_update in\n Bool.(\n account_is_new\n &&& Token_id.equal account_update_token_id Token_id.default)\n in\n (* in-SNARK, a new account has the empty public key here\n in that case, use the public key from the account update, not the account\n *)\n Account.set_delegate\n (Public_key.if_ self_delegate\n ~then_:(Account_update.public_key account_update)\n ~else_:(Account.delegate a) )\n a\n in\n let matching_verification_key_hashes =\n Inputs.Bool.(\n (not (Account_update.is_proved account_update))\n ||| Verification_key_hash.equal\n (Account.verification_key_hash a)\n (Account_update.verification_key_hash account_update))\n in\n let local_state =\n Local_state.add_check local_state Unexpected_verification_key_hash\n matching_verification_key_hashes\n in\n let local_state =\n h.perform\n (Check_account_precondition\n (account_update, a, account_is_new, local_state) )\n in\n let protocol_state_predicate_satisfied =\n h.perform\n (Check_protocol_state_precondition\n ( Account_update.protocol_state_precondition account_update\n , global_state ) )\n in\n let local_state =\n Local_state.add_check local_state Protocol_state_precondition_unsatisfied\n protocol_state_predicate_satisfied\n in\n let local_state =\n let valid_while_satisfied =\n h.perform\n (Check_valid_while_precondition\n ( Account_update.valid_while_precondition account_update\n , global_state ) )\n in\n Local_state.add_check local_state Valid_while_precondition_unsatisfied\n valid_while_satisfied\n in\n let `Proof_verifies proof_verifies, `Signature_verifies signature_verifies =\n let commitment =\n Inputs.Transaction_commitment.if_\n (Inputs.Account_update.use_full_commitment account_update)\n ~then_:local_state.full_transaction_commitment\n ~else_:local_state.transaction_commitment\n in\n Inputs.Account_update.check_authorization\n ~will_succeed:local_state.will_succeed ~commitment\n ~calls:account_update_forest account_update\n in\n assert_ ~pos:__POS__\n (Bool.equal proof_verifies (Account_update.is_proved account_update)) ;\n assert_ ~pos:__POS__\n (Bool.equal signature_verifies (Account_update.is_signed account_update)) ;\n (* The fee-payer must increment their nonce. *)\n let local_state =\n Local_state.add_check local_state Fee_payer_nonce_must_increase\n Inputs.Bool.(\n Inputs.Account_update.increment_nonce account_update ||| not is_start')\n in\n let local_state =\n Local_state.add_check local_state Fee_payer_must_be_signed\n Inputs.Bool.(signature_verifies ||| not is_start')\n in\n let local_state =\n let precondition_has_constant_nonce =\n Inputs.Account_update.Account_precondition.nonce account_update\n |> Inputs.Nonce_precondition.is_constant\n in\n let increments_nonce_and_constrains_its_old_value =\n Inputs.Bool.(\n Inputs.Account_update.increment_nonce account_update\n &&& precondition_has_constant_nonce)\n in\n let depends_on_the_fee_payers_nonce_and_isnt_the_fee_payer =\n Inputs.Bool.(\n Inputs.Account_update.use_full_commitment account_update\n &&& not is_start')\n in\n let does_not_use_a_signature = Inputs.Bool.not signature_verifies in\n Local_state.add_check local_state Zkapp_command_replay_check_failed\n Inputs.Bool.(\n increments_nonce_and_constrains_its_old_value\n ||| depends_on_the_fee_payers_nonce_and_isnt_the_fee_payer\n ||| does_not_use_a_signature)\n in\n let a = Account.set_token_id a (Account_update.token_id account_update) in\n let account_update_token = Account_update.token_id account_update in\n let account_update_token_is_default =\n Token_id.(equal default) account_update_token\n in\n let account_is_untimed = Bool.not (Account.is_timed a) in\n (* Set account timing. *)\n let a, local_state =\n let timing = Account_update.Update.timing account_update in\n let has_permission =\n Controller.check ~proof_verifies ~signature_verifies\n (Account.Permissions.set_timing a)\n in\n let local_state =\n Local_state.add_check local_state Update_not_permitted_timing\n Bool.(\n Set_or_keep.is_keep timing\n ||| (account_is_untimed &&& has_permission))\n in\n let timing =\n Set_or_keep.set_or_keep ~if_:Timing.if_ timing (Account.timing a)\n in\n let vesting_period = Timing.vesting_period timing in\n (* Assert that timing is valid, otherwise we may have a division by 0. *)\n assert_ ~pos:__POS__ Global_slot_span.(vesting_period > zero) ;\n let a = Account.set_timing a timing in\n (a, local_state)\n in\n let account_creation_fee =\n Amount.of_constant_fee constraint_constants.account_creation_fee\n in\n let implicit_account_creation_fee =\n Account_update.implicit_account_creation_fee account_update\n in\n (* Check the token for implicit account creation fee payment. *)\n let local_state =\n Local_state.add_check local_state Cannot_pay_creation_fee_in_token\n Bool.(\n (not implicit_account_creation_fee)\n ||| account_update_token_is_default)\n in\n (* Compute the change to the account balance. *)\n let local_state, actual_balance_change =\n let balance_change = Account_update.balance_change account_update in\n let neg_creation_fee =\n let open Amount.Signed in\n negate (of_unsigned account_creation_fee)\n in\n let balance_change_for_creation, `Overflow creation_overflow =\n let open Amount.Signed in\n add_flagged balance_change neg_creation_fee\n in\n let pay_creation_fee =\n Bool.(account_is_new &&& implicit_account_creation_fee)\n in\n let creation_overflow = Bool.(pay_creation_fee &&& creation_overflow) in\n let balance_change =\n Amount.Signed.if_ pay_creation_fee ~then_:balance_change_for_creation\n ~else_:balance_change\n in\n let local_state =\n Local_state.add_check local_state Amount_insufficient_to_create_account\n Bool.(\n not\n ( pay_creation_fee\n &&& (creation_overflow ||| Amount.Signed.is_neg balance_change) ))\n in\n (local_state, balance_change)\n in\n (* Apply balance change. *)\n let a, local_state =\n let pay_creation_fee_from_excess =\n Bool.(account_is_new &&& not implicit_account_creation_fee)\n in\n let balance, `Overflow failed1 =\n Balance.add_signed_amount_flagged (Account.balance a)\n actual_balance_change\n in\n (* TODO: Should this report 'insufficient balance'? *)\n let local_state =\n Local_state.add_check local_state Overflow (Bool.not failed1)\n in\n let account_creation_fee =\n Amount.of_constant_fee constraint_constants.account_creation_fee\n in\n let local_state =\n (* Conditionally subtract account creation fee from fee excess *)\n let excess_minus_creation_fee, `Overflow excess_update_failed =\n Amount.Signed.add_flagged local_state.excess\n Amount.Signed.(negate (of_unsigned account_creation_fee))\n in\n let local_state =\n Local_state.add_check local_state Local_excess_overflow\n Bool.(not (pay_creation_fee_from_excess &&& excess_update_failed))\n in\n { local_state with\n excess =\n Amount.Signed.if_ pay_creation_fee_from_excess\n ~then_:excess_minus_creation_fee ~else_:local_state.excess\n }\n in\n let local_state =\n (* Conditionally subtract account creation fee from supply increase *)\n let ( supply_increase_minus_creation_fee\n , `Overflow supply_increase_update_failed ) =\n Amount.Signed.add_flagged local_state.supply_increase\n Amount.Signed.(negate (of_unsigned account_creation_fee))\n in\n let local_state =\n Local_state.add_check local_state Local_supply_increase_overflow\n Bool.(not (account_is_new &&& supply_increase_update_failed))\n in\n { local_state with\n supply_increase =\n Amount.Signed.if_ account_is_new\n ~then_:supply_increase_minus_creation_fee\n ~else_:local_state.supply_increase\n }\n in\n let is_receiver = Amount.Signed.is_non_neg actual_balance_change in\n let local_state =\n let controller =\n Controller.if_ is_receiver\n ~then_:(Account.Permissions.receive a)\n ~else_:(Account.Permissions.send a)\n in\n let has_permission =\n Controller.check ~proof_verifies ~signature_verifies controller\n in\n Local_state.add_check local_state Update_not_permitted_balance\n Bool.(\n has_permission\n ||| Amount.Signed.(\n equal (of_unsigned Amount.zero) actual_balance_change))\n in\n let a = Account.set_balance balance a in\n (a, local_state)\n in\n let txn_global_slot = Global_state.block_global_slot global_state in\n (* Check timing with current balance *)\n let a, local_state =\n let `Invalid_timing invalid_timing, timing =\n match Account.check_timing ~txn_global_slot a with\n | `Insufficient_balance _, _ ->\n failwith \"Did not propose a balance change at this timing check!\"\n | `Invalid_timing invalid_timing, timing ->\n (* NB: Have to destructure to remove the possibility of\n [`Insufficient_balance _] in the type.\n *)\n (`Invalid_timing invalid_timing, timing)\n in\n let local_state =\n Local_state.add_check local_state Source_minimum_balance_violation\n (Bool.not invalid_timing)\n in\n let a = Account.set_timing a timing in\n (a, local_state)\n in\n (* Transform into a zkApp account.\n This must be done before updating zkApp fields!\n *)\n let a = Account.make_zkapp a in\n (* Check that the account can be accessed with the given authorization. *)\n let local_state =\n let has_permission =\n Controller.check ~proof_verifies ~signature_verifies\n (Account.Permissions.access a)\n in\n Local_state.add_check local_state Update_not_permitted_access\n has_permission\n in\n (* Update app state. *)\n let a, local_state =\n let app_state = Account_update.Update.app_state account_update in\n let keeping_app_state =\n Bool.all\n (List.map ~f:Set_or_keep.is_keep\n (Pickles_types.Vector.to_list app_state) )\n in\n let changing_entire_app_state =\n Bool.all\n (List.map ~f:Set_or_keep.is_set\n (Pickles_types.Vector.to_list app_state) )\n in\n let proved_state =\n (* The [proved_state] tracks whether the app state has been entirely\n determined by proofs ([true] if so), to allow zkApp authors to be\n confident that their initialization logic has been run, rather than\n some malicious deployer instantiating the zkApp in an account with\n some fake non-initial state.\n The logic here is:\n * if the state is unchanged, keep the previous value;\n * if the state has been entirely replaced, and the authentication\n was a proof, the state has been 'proved' and [proved_state] is set\n to [true];\n * if the state has been partially updated by a proof, the\n [proved_state] is unchanged;\n * if the state has been changed by some authentication other than a\n proof, the state is considered to have been tampered with, and\n [proved_state] is reset to [false].\n *)\n Bool.if_ keeping_app_state ~then_:(Account.proved_state a)\n ~else_:\n (Bool.if_ proof_verifies\n ~then_:\n (Bool.if_ changing_entire_app_state ~then_:Bool.true_\n ~else_:(Account.proved_state a) )\n ~else_:Bool.false_ )\n in\n let a = Account.set_proved_state proved_state a in\n let has_permission =\n Controller.check ~proof_verifies ~signature_verifies\n (Account.Permissions.edit_state a)\n in\n let local_state =\n Local_state.add_check local_state Update_not_permitted_app_state\n Bool.(keeping_app_state ||| has_permission)\n in\n let app_state =\n Pickles_types.Vector.map2 app_state (Account.app_state a)\n ~f:(Set_or_keep.set_or_keep ~if_:Field.if_)\n in\n let a = Account.set_app_state app_state a in\n (a, local_state)\n in\n (* Set verification key. *)\n let a, local_state =\n let verification_key =\n Account_update.Update.verification_key account_update\n in\n let has_permission =\n Controller.check ~proof_verifies ~signature_verifies\n (Account.Permissions.set_verification_key a)\n in\n let local_state =\n Local_state.add_check local_state Update_not_permitted_verification_key\n Bool.(Set_or_keep.is_keep verification_key ||| has_permission)\n in\n let verification_key =\n Set_or_keep.set_or_keep ~if_:Verification_key.if_ verification_key\n (Account.verification_key a)\n in\n let a = Account.set_verification_key verification_key a in\n (a, local_state)\n in\n (* Update action state. *)\n let a, local_state =\n let actions = Account_update.Update.actions account_update in\n let last_action_slot = Account.last_action_slot a in\n let action_state, last_action_slot =\n update_action_state (Account.action_state a) actions ~txn_global_slot\n ~last_action_slot\n in\n let is_empty =\n (* also computed in update_action_state, but messy to return it *)\n Actions.is_empty actions\n in\n let has_permission =\n Controller.check ~proof_verifies ~signature_verifies\n (Account.Permissions.edit_action_state a)\n in\n let local_state =\n Local_state.add_check local_state Update_not_permitted_action_state\n Bool.(is_empty ||| has_permission)\n in\n let a =\n a\n |> Account.set_action_state action_state\n |> Account.set_last_action_slot last_action_slot\n in\n (a, local_state)\n in\n (* Update zkApp URI. *)\n let a, local_state =\n let zkapp_uri = Account_update.Update.zkapp_uri account_update in\n let has_permission =\n Controller.check ~proof_verifies ~signature_verifies\n (Account.Permissions.set_zkapp_uri a)\n in\n let local_state =\n Local_state.add_check local_state Update_not_permitted_zkapp_uri\n Bool.(Set_or_keep.is_keep zkapp_uri ||| has_permission)\n in\n let zkapp_uri =\n Set_or_keep.set_or_keep ~if_:Zkapp_uri.if_ zkapp_uri\n (Account.zkapp_uri a)\n in\n let a = Account.set_zkapp_uri zkapp_uri a in\n (a, local_state)\n in\n (* At this point, all possible changes have been made to the zkapp\n part of an account. Reset zkApp state to [None] if that part\n is unmodified.\n *)\n let a = Account.unmake_zkapp a in\n (* Update token symbol. *)\n let a, local_state =\n let token_symbol = Account_update.Update.token_symbol account_update in\n let has_permission =\n Controller.check ~proof_verifies ~signature_verifies\n (Account.Permissions.set_token_symbol a)\n in\n let local_state =\n Local_state.add_check local_state Update_not_permitted_token_symbol\n Bool.(Set_or_keep.is_keep token_symbol ||| has_permission)\n in\n let token_symbol =\n Set_or_keep.set_or_keep ~if_:Token_symbol.if_ token_symbol\n (Account.token_symbol a)\n in\n let a = Account.set_token_symbol token_symbol a in\n (a, local_state)\n in\n (* Update delegate. *)\n let a, local_state =\n let delegate = Account_update.Update.delegate account_update in\n (* for new accounts using the default token, we've already\n set the delegate to the public key\n *)\n let base_delegate = Account.delegate a in\n let has_permission =\n Controller.check ~proof_verifies ~signature_verifies\n (Account.Permissions.set_delegate a)\n in\n let local_state =\n (* Note: only accounts for the default token can delegate. *)\n Local_state.add_check local_state Update_not_permitted_delegate\n Bool.(\n Set_or_keep.is_keep delegate\n ||| (has_permission &&& account_update_token_is_default))\n in\n let delegate =\n Set_or_keep.set_or_keep ~if_:Public_key.if_ delegate base_delegate\n in\n let a = Account.set_delegate delegate a in\n (a, local_state)\n in\n (* Update nonce. *)\n let a, local_state =\n let nonce = Account.nonce a in\n let increment_nonce = Account_update.increment_nonce account_update in\n let nonce =\n Nonce.if_ increment_nonce ~then_:(Nonce.succ nonce) ~else_:nonce\n in\n let has_permission =\n Controller.check ~proof_verifies ~signature_verifies\n (Account.Permissions.increment_nonce a)\n in\n let local_state =\n Local_state.add_check local_state Update_not_permitted_nonce\n Bool.((not increment_nonce) ||| has_permission)\n in\n let a = Account.set_nonce nonce a in\n (a, local_state)\n in\n (* Update voting-for. *)\n let a, local_state =\n let voting_for = Account_update.Update.voting_for account_update in\n let has_permission =\n Controller.check ~proof_verifies ~signature_verifies\n (Account.Permissions.set_voting_for a)\n in\n let local_state =\n Local_state.add_check local_state Update_not_permitted_voting_for\n Bool.(Set_or_keep.is_keep voting_for ||| has_permission)\n in\n let voting_for =\n Set_or_keep.set_or_keep ~if_:State_hash.if_ voting_for\n (Account.voting_for a)\n in\n let a = Account.set_voting_for voting_for a in\n (a, local_state)\n in\n (* Update receipt chain hash *)\n let a =\n let new_hash =\n let old_hash = Account.receipt_chain_hash a in\n Receipt_chain_hash.if_\n (let open Inputs.Bool in\n signature_verifies ||| proof_verifies)\n ~then_:\n (let elt =\n local_state.full_transaction_commitment\n |> Receipt_chain_hash.Elt.of_transaction_commitment\n in\n Receipt_chain_hash.cons_zkapp_command_commitment\n local_state.account_update_index elt old_hash )\n ~else_:old_hash\n in\n Account.set_receipt_chain_hash a new_hash\n in\n (* Finally, update permissions.\n This should be the last update applied, to ensure that any earlier\n updates use the account's existing permissions, and not permissions that\n are specified by the account_update!\n *)\n let a, local_state =\n let permissions = Account_update.Update.permissions account_update in\n let has_permission =\n Controller.check ~proof_verifies ~signature_verifies\n (Account.Permissions.set_permissions a)\n in\n let local_state =\n Local_state.add_check local_state Update_not_permitted_permissions\n Bool.(Set_or_keep.is_keep permissions ||| has_permission)\n in\n let permissions =\n Set_or_keep.set_or_keep ~if_:Account.Permissions.if_ permissions\n (Account.permissions a)\n in\n let a = Account.set_permissions permissions a in\n (a, local_state)\n in\n (* Initialize account's pk, in case it is new. *)\n let a = h.perform (Init_account { account_update; account = a }) in\n (* DO NOT ADD ANY UPDATES HERE. They must be earlier in the code.\n See comment above.\n *)\n let local_delta =\n (* NOTE: It is *not* correct to use the actual change in balance here.\n Indeed, if the account creation fee is paid, using that amount would\n be equivalent to paying it out to the block producer.\n In the case of a failure that prevents any updates from being applied,\n every other account_update in this transaction will also fail, and the\n excess will never be promoted to the global excess, so this amount is\n irrelevant.\n *)\n Amount.Signed.negate (Account_update.balance_change account_update)\n in\n let new_local_fee_excess, `Overflow overflowed =\n (* We only allow the default token for fees. *)\n Bool.(\n assert_ ~pos:__POS__\n ( (not is_start')\n ||| ( account_update_token_is_default\n &&& Amount.Signed.is_non_neg local_delta ) )) ;\n let new_local_fee_excess, `Overflow overflow =\n Amount.Signed.add_flagged local_state.excess local_delta\n in\n ( Amount.Signed.if_ account_update_token_is_default\n ~then_:new_local_fee_excess ~else_:local_state.excess\n , (* No overflow if we aren't using the result of the addition (which we don't in the case that account_update token is not default). *)\n `Overflow (Bool.( &&& ) account_update_token_is_default overflow) )\n in\n let local_state = { local_state with excess = new_local_fee_excess } in\n let local_state =\n Local_state.add_check local_state Local_excess_overflow\n (Bool.not overflowed)\n in\n (* If a's token ID differs from that in the local state, then\n the local state excess gets moved into the execution state's fee excess.\n\n If there are more zkapp_command to execute after this one, then the local delta gets\n accumulated in the local state.\n\n If there are no more zkapp_command to execute, then we do the same as if we switch tokens.\n The local state excess (plus the local delta) gets moved to the fee excess if it is default token.\n *)\n let new_ledger =\n Inputs.Ledger.set_account local_state.ledger (a, inclusion_proof)\n in\n let is_last_account_update =\n Call_forest.is_empty (Stack_frame.calls remaining)\n in\n let local_state =\n { local_state with\n ledger = new_ledger\n ; transaction_commitment =\n Transaction_commitment.if_ is_last_account_update\n ~then_:Transaction_commitment.empty\n ~else_:local_state.transaction_commitment\n ; full_transaction_commitment =\n Transaction_commitment.if_ is_last_account_update\n ~then_:Transaction_commitment.empty\n ~else_:local_state.full_transaction_commitment\n }\n in\n let valid_fee_excess =\n let delta_settled =\n Amount.Signed.equal local_state.excess Amount.(Signed.of_unsigned zero)\n in\n (* 1) ignore local excess if it is_start because it will be promoted to global\n excess and then set to zero later in the code\n 2) ignore everything but last account update since the excess wouldn't have\n been settled\n 3) Excess should be settled after the last account update has been applied.\n *)\n Bool.(is_start' ||| not is_last_account_update ||| delta_settled)\n in\n let local_state =\n Local_state.add_check local_state Invalid_fee_excess valid_fee_excess\n in\n let is_start_or_last = Bool.(is_start' ||| is_last_account_update) in\n let update_global_state_fee_excess =\n Bool.(is_start_or_last &&& local_state.success)\n in\n let global_state, global_excess_update_failed =\n let amt = Global_state.fee_excess global_state in\n let res, `Overflow overflow =\n Amount.Signed.add_flagged amt local_state.excess\n in\n let global_excess_update_failed =\n Bool.(update_global_state_fee_excess &&& overflow)\n in\n let new_amt =\n Amount.Signed.if_ update_global_state_fee_excess ~then_:res ~else_:amt\n in\n ( Global_state.set_fee_excess global_state new_amt\n , global_excess_update_failed )\n in\n let local_state =\n { local_state with\n excess =\n Amount.Signed.if_ is_start_or_last\n ~then_:Amount.(Signed.of_unsigned zero)\n ~else_:local_state.excess\n }\n in\n let local_state =\n Local_state.add_check local_state Global_excess_overflow\n Bool.(not global_excess_update_failed)\n in\n (* add local supply increase in global state *)\n let new_global_supply_increase, global_supply_increase_update_failed =\n let res, `Overflow overflow =\n Amount.Signed.add_flagged\n (Global_state.supply_increase global_state)\n local_state.supply_increase\n in\n (res, overflow)\n in\n let local_state =\n Local_state.add_check local_state Global_supply_increase_overflow\n Bool.(not global_supply_increase_update_failed)\n in\n (* The first account_update must succeed. *)\n Bool.(\n assert_with_failure_status_tbl ~pos:__POS__\n ((not is_start') ||| local_state.success)\n local_state.failure_status_tbl) ;\n (* If we are the fee payer (is_start' = true), push the first pass ledger\n and set the local ledger to be the second pass ledger in preparation for\n the children.\n *)\n let local_state, global_state =\n let is_fee_payer = is_start' in\n let global_state =\n Global_state.set_first_pass_ledger ~should_update:is_fee_payer\n global_state local_state.ledger\n in\n let local_state =\n { local_state with\n ledger =\n Inputs.Ledger.if_ is_fee_payer\n ~then_:(Global_state.second_pass_ledger global_state)\n ~else_:local_state.ledger\n }\n in\n (local_state, global_state)\n in\n (* If this is the last account update, and [will_succeed] is false, then\n [success] must also be false.\n *)\n Bool.(\n Assert.any ~pos:__POS__\n [ not is_last_account_update\n ; local_state.will_succeed\n ; not local_state.success\n ]) ;\n (* If this is the last party and there were no failures, update the second\n pass ledger and the supply increase.\n *)\n let global_state =\n let is_successful_last_party =\n Bool.(is_last_account_update &&& local_state.success)\n in\n let global_state =\n Global_state.set_supply_increase global_state\n (Amount.Signed.if_ is_successful_last_party\n ~then_:new_global_supply_increase\n ~else_:(Global_state.supply_increase global_state) )\n in\n Global_state.set_second_pass_ledger\n ~should_update:is_successful_last_party global_state local_state.ledger\n in\n let local_state =\n (* Make sure to reset the local_state at the end of a transaction.\n The following fields are already reset\n - zkapp_command\n - transaction_commitment\n - full_transaction_commitment\n - excess\n so we need to reset\n - token_id = Token_id.default\n - ledger = Frozen_ledger_hash.empty_hash\n - success = true\n - account_update_index = Index.zero\n - supply_increase = Amount.Signed.zero\n *)\n { local_state with\n ledger =\n Inputs.Ledger.if_ is_last_account_update\n ~then_:(Inputs.Ledger.empty ~depth:0 ())\n ~else_:local_state.ledger\n ; success =\n Bool.if_ is_last_account_update ~then_:Bool.true_\n ~else_:local_state.success\n ; account_update_index =\n Inputs.Index.if_ is_last_account_update ~then_:Inputs.Index.zero\n ~else_:(Inputs.Index.succ local_state.account_update_index)\n ; supply_increase =\n Amount.Signed.if_ is_last_account_update\n ~then_:Amount.(Signed.of_unsigned zero)\n ~else_:local_state.supply_increase\n ; will_succeed =\n Bool.if_ is_last_account_update ~then_:Bool.true_\n ~else_:local_state.will_succeed\n }\n in\n (global_state, local_state)\n\n let step h state = apply ~is_start:`No h state\n\n let start start_data h state = apply ~is_start:(`Yes start_data) h state\nend\n","open! Import\nopen Std_internal\nmodule Repr = Int63\n\nmodule T : sig\n type t [@@deriving compare, hash, sexp_of]\n\n val to_string : t -> string\n val of_repr : Repr.t -> t\n val to_repr : t -> Repr.t\nend = struct\n type t = Repr.t [@@deriving compare, hash]\n\n let of_repr = Fn.id\n let to_repr = Fn.id\n\n let to_string n =\n let open Repr in\n let kib = of_int 1024 in\n let mib = kib * kib in\n let gib = kib * mib in\n let n_abs = abs n in\n if n_abs < kib\n then sprintf \"%dB\" (to_int_exn n)\n else if n_abs < mib\n then sprintf \"%gK\" (to_float n /. to_float kib)\n else if n_abs < gib\n then sprintf \"%gM\" (to_float n /. to_float mib)\n else sprintf \"%gG\" (to_float n /. to_float gib)\n ;;\n\n let sexp_of_t n = Sexp.Atom (to_string n)\nend\n\ninclude T\n\nlet bytes_int_exn t = Repr.to_int_exn (to_repr t)\n","open! Import\nopen Std_internal\nopen Bigarray\nmodule Binable = Binable0\n\nmodule Stable = struct\n module V1 = struct\n include Base_bigstring\n\n module Z : sig\n type t = (char, int8_unsigned_elt, c_layout) Array1.t [@@deriving bin_io]\n end = struct\n type t = bigstring [@@deriving bin_io]\n end\n\n include Z\n\n type t_frozen = t [@@deriving bin_io]\n end\nend\n\nmodule T = Stable.V1\ninclude T\nmodule Unstable = T\n\nlet create ?max_mem_waiting_gc size =\n let max_mem_waiting_gc_in_bytes =\n Option.map max_mem_waiting_gc ~f:Byte_units0.bytes_int_exn\n in\n create ?max_mem_waiting_gc_in_bytes size\n;;\n\nlet sub_shared ?(pos = 0) ?len (bstr : t) =\n let len = get_opt_len bstr ~pos len in\n Array1.sub bstr pos len\n;;\n\n(* Destruction *)\n\nexternal unsafe_destroy : t -> unit = \"bigstring_destroy_stub\"\n\nexternal unsafe_destroy_and_resize : t -> len:int -> t = \"bigstring_realloc\"\n\n(* Reading / writing bin-prot *)\n\nlet read_bin_prot_verbose_errors t ?(pos = 0) ?len reader =\n let len = get_opt_len t len ~pos in\n let limit = pos + len in\n check_args ~loc:\"read_bin_prot_verbose_errors\" t ~pos ~len;\n let invalid_data message a sexp_of_a =\n `Invalid_data (Error.create message a sexp_of_a)\n in\n let read bin_reader ~pos ~len =\n if len > limit - pos\n then `Not_enough_data\n else (\n let pos_ref = ref pos in\n match\n try `Ok (bin_reader t ~pos_ref) with\n | exn -> `Invalid_data (Error.of_exn exn)\n with\n | `Invalid_data _ as x -> x\n | `Ok result ->\n let expected_pos = pos + len in\n if !pos_ref = expected_pos\n then `Ok (result, expected_pos)\n else\n invalid_data\n \"pos_ref <> expected_pos\"\n (!pos_ref, expected_pos)\n [%sexp_of: int * int])\n in\n match\n read Bin_prot.Utils.bin_read_size_header ~pos ~len:Bin_prot.Utils.size_header_length\n with\n | (`Not_enough_data | `Invalid_data _) as x -> x\n | `Ok (element_length, pos) ->\n if element_length < 0\n then invalid_data \"negative element length %d\" element_length [%sexp_of: int]\n else read reader.Bin_prot.Type_class.read ~pos ~len:element_length\n;;\n\nlet read_bin_prot t ?pos ?len reader =\n match read_bin_prot_verbose_errors t ?pos ?len reader with\n | `Ok x -> Ok x\n | `Invalid_data e -> Error (Error.tag e ~tag:\"Invalid data\")\n | `Not_enough_data -> Or_error.error_string \"not enough data\"\n;;\n\nlet write_bin_prot t ?(pos = 0) writer v =\n let data_len = writer.Bin_prot.Type_class.size v in\n let total_len = data_len + Bin_prot.Utils.size_header_length in\n if pos < 0\n then\n failwiths ~here:[%here] \"Bigstring.write_bin_prot: negative pos\" pos [%sexp_of: int];\n if pos + total_len > length t\n then\n failwiths\n ~here:[%here]\n \"Bigstring.write_bin_prot: not enough room\"\n (`pos pos, `pos_after_writing (pos + total_len), `bigstring_length (length t))\n [%sexp_of:\n [ `pos of int ] * [ `pos_after_writing of int ] * [ `bigstring_length of int ]];\n let pos_after_size_header = Bin_prot.Utils.bin_write_size_header t ~pos data_len in\n let pos_after_data = writer.Bin_prot.Type_class.write t ~pos:pos_after_size_header v in\n if pos_after_data - pos <> total_len\n then\n failwiths\n ~here:[%here]\n \"Bigstring.write_bin_prot bug!\"\n ( `pos_after_data pos_after_data\n , `start_pos pos\n , `bin_prot_size_header_length Bin_prot.Utils.size_header_length\n , `data_len data_len\n , `total_len total_len )\n [%sexp_of:\n [ `pos_after_data of int ]\n * [ `start_pos of int ]\n * [ `bin_prot_size_header_length of int ]\n * [ `data_len of int ]\n * [ `total_len of int ]];\n pos_after_data\n;;\n\n(* Hex dump *)\n\ninclude Hexdump.Of_indexable (struct\n type nonrec t = t\n\n let length = length\n let get = get\n end)\n\nlet rec last_nonmatch_plus_one ~buf ~min_pos ~pos ~char =\n let pos' = pos - 1 in\n if pos' >= min_pos && Char.( = ) (get buf pos') char\n then last_nonmatch_plus_one ~buf ~min_pos ~pos:pos' ~char\n else pos\n;;\n\nlet get_tail_padded_fixed_string ~padding t ~pos ~len () =\n let data_end =\n last_nonmatch_plus_one ~buf:t ~min_pos:pos ~pos:(pos + len) ~char:padding\n in\n to_string t ~pos ~len:(data_end - pos)\n;;\n\nlet set_tail_padded_fixed_string ~padding t ~pos ~len value =\n let slen = String.length value in\n if slen > len\n then\n Printf.failwithf\n \"Bigstring.set_tail_padded_fixed_string: %S is longer than %d\"\n value\n len\n ();\n From_string.blit ~src:value ~dst:t ~src_pos:0 ~dst_pos:pos ~len:slen;\n for i = pos + slen to pos + len - 1 do\n set t i padding\n done\n;;\n\nlet rec first_nonmatch ~buf ~pos ~max_pos ~char =\n if pos <= max_pos && Char.( = ) (get buf pos) char\n then first_nonmatch ~buf ~pos:(Int.succ pos) ~max_pos ~char\n else pos\n;;\n\nlet set_head_padded_fixed_string ~padding t ~pos ~len value =\n let slen = String.length value in\n if slen > len\n then\n Printf.failwithf\n \"Bigstring.set_head_padded_fixed_string: %S is longer than %d\"\n value\n len\n ();\n From_string.blit ~src:value ~dst:t ~src_pos:0 ~dst_pos:(pos + len - slen) ~len:slen;\n for i = pos to pos + len - slen - 1 do\n set t i padding\n done\n;;\n\nlet get_head_padded_fixed_string ~padding t ~pos ~len () =\n let data_begin = first_nonmatch ~buf:t ~pos ~max_pos:(pos + len - 1) ~char:padding in\n to_string t ~pos:data_begin ~len:(len - (data_begin - pos))\n;;\n","open! Import\ninclude Bin_prot\n\nmodule Writer = struct\n type 'a t = 'a Bin_prot.Type_class.writer =\n { size : 'a Size.sizer\n ; write : 'a Write.writer\n }\n\n let to_string t v =\n let len = t.size v in\n let buf = Bigstring.create len in\n let pos = t.write buf ~pos:0 v in\n assert (pos = Bigstring.length buf);\n let str = Bigstring.to_string buf in\n Bigstring.unsafe_destroy buf;\n str\n ;;\n\n let to_bytes t v =\n let len = t.size v in\n let buf = Bigstring.create len in\n let pos = t.write buf ~pos:0 v in\n assert (pos = Bigstring.length buf);\n let str = Bigstring.to_bytes buf in\n Bigstring.unsafe_destroy buf;\n str\n ;;\nend\n\nmodule Reader = struct\n type 'a t = 'a Bin_prot.Type_class.reader =\n { read : 'a Read.reader\n ; vtag_read : (int -> 'a) Read.reader\n }\n\n let of_string t string =\n let buf = Bigstring.of_string string in\n let pos_ref = ref 0 in\n let v = t.read buf ~pos_ref in\n assert (!pos_ref = Bigstring.length buf);\n Bigstring.unsafe_destroy buf;\n v\n ;;\n\n let of_bytes t bytes =\n let buf = Bigstring.of_bytes bytes in\n let pos_ref = ref 0 in\n let v = t.read buf ~pos_ref in\n assert (!pos_ref = Bigstring.length buf);\n Bigstring.unsafe_destroy buf;\n v\n ;;\nend\n","module T = struct\n include Bin_prot.Md5\n\n let sexp_of_t t = t |> to_hex |> String.sexp_of_t\n let t_of_sexp s = s |> String.t_of_sexp |> of_hex_exn\nend\n\nlet hash_fold_t accum t = String.hash_fold_t accum (T.to_binary t)\nlet hash t = String.hash (T.to_binary t)\n\nmodule As_binary_string = struct\n module Stable = struct\n module V1 = struct\n type t = T.t [@@deriving compare]\n\n let hash_fold_t = hash_fold_t\n let hash = hash\n let sexp_of_t x = String.sexp_of_t (T.to_binary x)\n let t_of_sexp x = T.of_binary_exn (String.t_of_sexp x)\n\n include Bin_prot.Utils.Make_binable_without_uuid [@alert \"-legacy\"] (struct\n module Binable = String\n\n type t = Bin_prot.Md5.t\n\n let to_binable = T.to_binary\n let of_binable = T.of_binary_exn\n end)\n end\n end\n\n include Stable.V1\n include Comparable.Make (Stable.V1)\n include Hashable.Make (Stable.V1)\nend\n\nmodule Stable = struct\n module V1 = struct\n type t = T.t [@@deriving compare, sexp]\n\n let hash_fold_t = hash_fold_t\n let hash = hash\n\n include Bin_prot.Utils.Make_binable_without_uuid [@alert \"-legacy\"] (struct\n module Binable = Bin_prot.Md5\n\n type t = Bin_prot.Md5.t\n\n let to_binable = Fn.id\n let of_binable = Fn.id\n end)\n end\n\n let digest_string s = Md5_lib.string s\nend\n\ninclude Stable.V1\ninclude Comparable.Make (Stable.V1)\ninclude Hashable.Make (Stable.V1)\n\nlet digest_num_bytes = 16\nlet to_hex = T.to_hex\nlet from_hex = T.of_hex_exn\nlet of_hex_exn = T.of_hex_exn\nlet of_binary_exn = T.of_binary_exn\nlet to_binary = T.to_binary\nlet digest_string = Stable.digest_string\nlet digest_bytes = Md5_lib.bytes\n\nexternal caml_sys_open\n : string\n -> Caml.open_flag list\n -> perm:int\n -> int\n = \"caml_sys_open\"\n\nexternal caml_sys_close : int -> unit = \"caml_sys_close\"\nexternal digest_fd_blocking : int -> string = \"core_md5_fd\"\n\nlet digest_file_blocking path =\n of_binary_exn\n (Base.Exn.protectx\n (caml_sys_open path [ Open_rdonly; Open_binary ] ~perm:0o000)\n ~f:digest_fd_blocking\n ~finally:caml_sys_close)\n;;\n\nlet file = digest_file_blocking\n\nlet digest_channel_blocking_without_releasing_runtime_lock channel ~len =\n of_binary_exn (Caml.Digest.channel channel len)\n;;\n\nlet channel channel len =\n digest_channel_blocking_without_releasing_runtime_lock channel ~len\n;;\n\nlet output_blocking t oc = Caml.Digest.output oc (to_binary t)\nlet output oc t = output_blocking t oc\nlet input_blocking ic = of_binary_exn (Caml.Digest.input ic)\nlet input = input_blocking\nlet digest_subbytes = Md5_lib.subbytes\nlet string = digest_string\nlet bytes = digest_bytes\nlet subbytes s pos len = digest_subbytes s ~pos ~len\n\nlet digest_bin_prot writer value =\n digest_string (Core_bin_prot.Writer.to_string writer value)\n;;\n\nexternal c_digest_subbigstring\n : Bigstring.t\n -> pos:int\n -> len:int\n -> res:Bytes.t\n -> unit\n = \"core_md5_digest_subbigstring\"\n\nlet unsafe_digest_subbigstring buf ~pos ~len =\n (* It's more efficient to allocate the result on the OCaml side and declare the C\n function as noalloc than to let the C function allocate. *)\n let res = Bytes.create 16 in\n c_digest_subbigstring buf ~pos ~len ~res;\n Md5_lib.unsafe_of_binary\n (Bytes.unsafe_to_string ~no_mutation_while_string_reachable:res)\n;;\n\nlet digest_subbigstring buf ~pos ~len =\n Ordered_collection_common.check_pos_len_exn\n ~pos\n ~len\n ~total_length:(Bigstring.length buf);\n unsafe_digest_subbigstring buf ~pos ~len\n;;\n\nlet digest_bigstring buf =\n unsafe_digest_subbigstring buf ~pos:0 ~len:(Bigstring.length buf)\n;;\n","(** Time-zone handling. *)\n\nopen! Import\n\n(** The internal time representation of [Zone.t]. This is a tiny subset of [Time0_intf.S],\n see that interface for details such as the meaning of [Span] and [Date_and_ofday].\n\n The name of the interface reflects the fact that the interface only gives you access\n to the seconds of the [t]. But you can use this interface with types that have higher\n precision than that, hence the rounding implied in the name of\n [to_int63_seconds_round_down_exn].\n*)\nmodule type Time_in_seconds = sig\n module Span : sig\n type t\n\n val of_int63_seconds : Int63.t -> t\n val to_int63_seconds_round_down_exn : t -> Int63.t\n end\n\n module Date_and_ofday : sig\n type t\n\n val of_synthetic_span_since_epoch : Span.t -> t\n val to_synthetic_span_since_epoch : t -> Span.t\n end\n\n type t\n\n val of_span_since_epoch : Span.t -> t\n val to_span_since_epoch : t -> Span.t\nend\n\n(** This is the interface of [Zone], but not the interface of [Time.Zone] or\n [Time_ns.Zone]. For those, look at [Time_intf.Zone] *)\nmodule type S = sig\n (** {1 User-friendly interface} *)\n\n (** The type of a time-zone.\n\n bin_io and sexp representations of Zone.t are the name of the zone, and\n not the full data that is read from disk when Zone.find is called. The\n full Zone.t is reconstructed on the receiving/reading side by reloading\n the zone file from disk. Any zone name that is accepted by [find] is\n acceptable in the bin_io and sexp representations. *)\n type t [@@deriving sexp_of, compare]\n\n (** [input_tz_file ~zonename ~filename] read in [filename] and return [t]\n with [name t] = [zonename] *)\n val input_tz_file : zonename:string -> filename:string -> t\n\n (** [likely_machine_zones] is a list of zone names that will be searched\n first when trying to determine the machine zone of a box. Setting this\n to a likely set of zones for your application will speed the very first\n use of the local timezone. *)\n val likely_machine_zones : string list ref\n\n (** [of_utc_offset offset] returns a timezone with a static UTC offset (given in\n hours). *)\n val of_utc_offset : hours:int -> t\n\n (** [utc] the UTC time zone. Included for convenience *)\n val utc : t\n\n val name : t -> string\n\n (** [original_filename t] return the filename [t] was loaded from (if any) *)\n val original_filename : t -> string option\n\n (** [digest t] return the MD5 digest of the file the t was created from (if any) *)\n val digest : t -> Md5.t option\n\n module Time_in_seconds : Time_in_seconds\n\n (** For performance testing only; [reset_transition_cache t] resets an internal cache in\n [t] used to speed up repeated lookups of the same clock shift transition. *)\n val reset_transition_cache : t -> unit\n\n (** A time zone index refers to a range of times delimited by DST transitions at one or\n both ends. Every time belongs to exactly one such range. The times of DST\n transitions themselves belong to the range for which they are the lower bound. *)\n module Index : sig\n type t [@@immediate]\n\n val next : t -> t\n val prev : t -> t\n end\n\n (** Gets the index of a time. *)\n val index : t -> Time_in_seconds.t -> Index.t\n\n val index_of_date_and_ofday : t -> Time_in_seconds.Date_and_ofday.t -> Index.t\n\n (** Gets the UTC offset of times in a specific range.\n\n This can raise if you use an [Index.t] that is out of bounds for this [t]. *)\n val index_offset_from_utc_exn : t -> Index.t -> Time_in_seconds.Span.t\n\n (** [index_abbreviation_exn t index] returns the abbreviation name (such as EDT, EST,\n JST) of given zone [t] for the range of [index]. This string conversion is one-way\n only, and cannot reliably be turned back into a [t]. This function reads and writes\n the zone's cached index. Raises if [index] is out of bounds for [t]. *)\n val index_abbreviation_exn : t -> Index.t -> string\n\n (** Accessors for the DST transitions delimiting the start and end of a range, if any.\n The [_exn] accessors raise if there is no such transition. These accessors are split\n up to increase performance and improve allocation; they are intended as a low-level\n back-end for commonly-used time conversion functions. See [Time.Zone] and\n [Time_ns.Zone] for higher-level accessors that return an optional tuple for clock\n shifts in either direction. *)\n val index_has_prev_clock_shift : t -> Index.t -> bool\n\n val index_prev_clock_shift_time_exn : t -> Index.t -> Time_in_seconds.t\n val index_prev_clock_shift_amount_exn : t -> Index.t -> Time_in_seconds.Span.t\n val index_has_next_clock_shift : t -> Index.t -> bool\n val index_next_clock_shift_time_exn : t -> Index.t -> Time_in_seconds.t\n val index_next_clock_shift_amount_exn : t -> Index.t -> Time_in_seconds.Span.t\nend\n\nmodule type S_stable = sig\n type t\n\n module Full_data : sig\n module V1 : Stable_module_types.S0_without_comparator with type t = t\n end\nend\n\nmodule type Zone = sig\n module type S = S\n module type S_stable = S_stable\n\n include S\n module Stable : S_stable with type t := t\nend\n","open! Import\ninclude Binable_intf\ninclude Binable0\n\n(* [of_string] and [to_string] can't go in binable0.ml due to a cyclic dependency. *)\nlet of_string m string = of_bigstring m (Bigstring.of_string string)\nlet to_string m t = Bigstring.to_string (to_bigstring m t)\n\nmodule Of_binable = Of_binable_without_uuid [@@alert \"-legacy\"]\nmodule Of_binable1 = Of_binable1_without_uuid [@@alert \"-legacy\"]\nmodule Of_binable2 = Of_binable2_without_uuid [@@alert \"-legacy\"]\nmodule Of_binable3 = Of_binable3_without_uuid [@@alert \"-legacy\"]\nmodule Of_sexpable = Of_sexpable_without_uuid [@@alert \"-legacy\"]\nmodule Of_stringable = Of_stringable_without_uuid [@@alert \"-legacy\"]\n","(* Functions for parsing time zone database files (zic files).\n\n A time zone file consists (conceptually - the representation is more\n compact) of an ordered list of (Time.t * [local_time_type]) that mark\n the boundaries (marked from the epoch) at which various time adjustment\n regimes are in effect. This can also be thought of as breaking down all\n time past the epoch into ranges with a [local_time_type] that describes the\n offset from GMT to apply to each range to get local time.\n*)\n\nopen Import\nopen Std_internal\nopen! Int.Replace_polymorphic_compare\ninclude Zone_intf\n\nexception Invalid_file_format of string [@@deriving sexp]\n\nmodule Stable = struct\n module Full_data = struct\n module V1 = struct\n module Index = struct\n type t = int\n\n let next = Int.succ\n let prev = Int.pred\n let before_first_transition = -1\n\n (* Some existing clients expect [index >= 0], so we never serialize a negative\n index. This conversion can be removed if new stable versions are minted. *)\n let to_external t = max 0 t\n\n (* When the index of a time zone with no transitions is converted via to_external,\n its value becomes 0 even though its transition array is empty (and it should\n have been -1). When the converted value is changed back to a Zone.t through\n of_external, returning this value for its index could result in unsafe array\n accesses to the transition array of the zone (since there is no transition at\n index 0). Also, it does not make sense to keep the converted index because it\n is intended to be a mutable value used for caching. So of_external always sets\n the index to -1, which is a safe value. *)\n let of_external (_ : t) = -1\n\n include Binable.Of_binable_without_uuid [@alert \"-legacy\"]\n (Int)\n (struct\n type t = int\n\n let to_binable = to_external\n let of_binable = of_external\n end)\n\n include Sexpable.Of_sexpable\n (Int)\n (struct\n type t = int\n\n let to_sexpable = to_external\n let of_sexpable = of_external\n end)\n end\n\n module Regime = struct\n type t =\n { utc_offset_in_seconds : Int63.Stable.V1.t\n ; is_dst : bool\n ; abbrv : string\n }\n [@@deriving bin_io, sexp]\n end\n\n (* holds information about when leap seconds should be applied - unused\n because we are translating based on a epoch system clock (see the Core_zone\n documentation). *)\n module Leap_second = struct\n type t =\n { time_in_seconds_since_epoch : Int63.Stable.V1.t\n ; seconds : int\n }\n [@@deriving bin_io, sexp]\n end\n\n module Transition = struct\n type t =\n { start_time_in_seconds_since_epoch : Int63.Stable.V1.t\n ; new_regime : Regime.t\n }\n [@@deriving bin_io, sexp]\n end\n\n type t =\n { name : string\n ; original_filename : string option\n ;\n digest : Md5.As_binary_string.t option\n ; transitions : Transition.t array\n ; (* caches the index of the last transition we used to make lookups faster *)\n mutable last_regime_index : Index.t\n ; default_local_time_type : Regime.t\n ; leap_seconds : Leap_second.t list\n }\n [@@deriving bin_io, sexp]\n\n (* this relies on zones with the same name having the same transitions *)\n let compare t1 t2 = String.compare t1.name t2.name\n let original_filename zone = zone.original_filename\n let digest zone = zone.digest\n\n module Zone_file : sig\n val input_tz_file : zonename:string -> filename:string -> t\n end = struct\n let bool_of_int i = i <> 0\n\n let input_long_as_int32 =\n let long = Bytes.create 4 in\n let int32_of_char chr = Int32.of_int_exn (int_of_char chr) in\n fun ic ->\n In_channel.really_input_exn ic ~buf:long ~pos:0 ~len:4;\n let sb1 = Int32.shift_left (int32_of_char (Bytes.get long 0)) 24 in\n let sb2 = Int32.shift_left (int32_of_char (Bytes.get long 1)) 16 in\n let sb3 = Int32.shift_left (int32_of_char (Bytes.get long 2)) 8 in\n let sb4 = int32_of_char (Bytes.get long 3) in\n Int32.bit_or (Int32.bit_or sb1 sb2) (Int32.bit_or sb3 sb4)\n ;;\n\n (* Note that this is only safe to use on numbers that will fit into a 31-bit\n int. UNIX timestamps won't, for example. In our case this is only used\n to hold small numbers that are never interpreted as timestamps. *)\n let input_long_as_int ic = Int32.to_int_exn (input_long_as_int32 ic)\n let input_long_as_int63 ic = Int63.of_int32 (input_long_as_int32 ic)\n\n let input_long_long_as_int63 ic =\n let int63_of_char chr = Int63.of_int_exn (int_of_char chr) in\n let shift c bits = Int63.shift_left (int63_of_char c) bits in\n let long_long = Bytes.create 8 in\n In_channel.really_input_exn ic ~buf:long_long ~pos:0 ~len:8;\n let result = shift (Bytes.get long_long 0) 56 in\n let result = Int63.bit_or result (shift (Bytes.get long_long 1) 48) in\n let result = Int63.bit_or result (shift (Bytes.get long_long 2) 40) in\n let result = Int63.bit_or result (shift (Bytes.get long_long 3) 32) in\n let result = Int63.bit_or result (shift (Bytes.get long_long 4) 24) in\n let result = Int63.bit_or result (shift (Bytes.get long_long 5) 16) in\n let result = Int63.bit_or result (shift (Bytes.get long_long 6) 8) in\n let result = Int63.bit_or result (int63_of_char (Bytes.get long_long 7)) in\n result\n ;;\n\n let input_list ic ~len ~f =\n let rec loop c lst =\n if c > 0 then loop (c - 1) (f ic :: lst) else List.rev lst\n in\n loop len []\n ;;\n\n let input_array ic ~len ~f = Array.of_list (input_list ic ~len ~f)\n\n let input_regime ic =\n let utc_offset_in_seconds = input_long_as_int63 ic in\n let is_dst = bool_of_int (Option.value_exn (In_channel.input_byte ic)) in\n let abbrv_index = Option.value_exn (In_channel.input_byte ic) in\n let lt abbrv = { Regime.utc_offset_in_seconds; is_dst; abbrv } in\n lt, abbrv_index\n ;;\n\n let input_abbreviations ic ~len =\n let raw_abbrvs =\n input_list ic ~len ~f:(fun ic -> Option.value_exn (In_channel.input_char ic))\n in\n let buf = Buffer.create len in\n let _, indexed_abbrvs =\n List.fold raw_abbrvs ~init:(0, Map.Poly.empty) ~f:(fun (index, abbrvs) c ->\n match c with\n | '\\000' ->\n let data = Buffer.contents buf in\n let next_index = index + String.length data + 1 in\n let abbrvs = Map.set abbrvs ~key:index ~data in\n Buffer.clear buf;\n next_index, abbrvs\n | c ->\n Buffer.add_char buf c;\n index, abbrvs)\n in\n if Buffer.length buf <> 0\n then\n raise\n (Invalid_file_format\n \"missing \\000 terminating character in input_abbreviations\");\n indexed_abbrvs\n ;;\n\n let input_tz_file_gen ~input_transition ~input_leap_second ic =\n let utc_local_count = input_long_as_int ic in\n let std_wall_count = input_long_as_int ic in\n let leap_count = input_long_as_int ic in\n let transition_count = input_long_as_int ic in\n let type_count = input_long_as_int ic in\n let abbrv_char_count = input_long_as_int ic in\n let transition_times =\n input_list ic ~f:input_transition ~len:transition_count\n in\n let transition_indices =\n input_list\n ic\n ~f:(fun ic -> Option.value_exn (In_channel.input_byte ic))\n ~len:transition_count\n in\n let regimes = input_list ic ~f:input_regime ~len:type_count in\n let abbreviations = input_abbreviations ic ~len:abbrv_char_count in\n let leap_seconds = input_list ic ~f:input_leap_second ~len:leap_count in\n (* The following two arrays indicate two boolean values per regime that\n represent a three-value type that would translate to:\n\n type transition_type = UTC | Standard | Wall_clock\n\n However, these are only used by the system library when handling the case where the\n TZ variable is set, not to a time zone name, but instead is of the form:\n\n TZ = \"std offset dst offset, rule\"\n\n Which is deeply obscure, and almost certainly a mistake to use. This library makes\n no pretense about handling this case. We continue to read them in for\n completeness, and because it's possible that we will later discover a case where\n they are used. *)\n let _std_wall_indicators =\n input_array ic ~len:std_wall_count ~f:(fun ic ->\n bool_of_int (Option.value_exn (In_channel.input_byte ic)))\n in\n let _utc_local_indicators =\n input_array ic ~len:utc_local_count ~f:(fun ic ->\n bool_of_int (Option.value_exn (In_channel.input_byte ic)))\n in\n let regimes =\n Array.of_list\n (List.map regimes ~f:(fun (lt, abbrv_index) ->\n let abbrv = Map.find_exn abbreviations abbrv_index in\n lt abbrv))\n in\n let raw_transitions =\n List.map2_exn transition_times transition_indices ~f:(fun time index ->\n let regime = regimes.(index) in\n time, regime)\n in\n let transitions =\n let rec make_transitions acc l =\n match l with\n | [] -> Array.of_list (List.rev acc)\n | (start_time_in_seconds_since_epoch, new_regime) :: rest ->\n make_transitions\n ({ Transition.start_time_in_seconds_since_epoch; new_regime } :: acc)\n rest\n in\n make_transitions [] raw_transitions\n in\n let default_local_time_type =\n match Array.find regimes ~f:(fun r -> not r.Regime.is_dst) with\n | None -> regimes.(0)\n | Some ltt -> ltt\n in\n fun name ~original_filename ~digest ->\n { name\n ; original_filename = Some original_filename\n ; digest = Some digest\n ; transitions\n ; last_regime_index = Index.before_first_transition\n ; default_local_time_type\n ; leap_seconds\n }\n ;;\n\n let input_leap_second_gen ~input_leap_second ic =\n let time_in_seconds_since_epoch = input_leap_second ic in\n let seconds = input_long_as_int ic in\n { Leap_second.time_in_seconds_since_epoch; seconds }\n ;;\n\n let read_header ic =\n let magic =\n let buf = Bytes.create 4 in\n In_channel.really_input_exn ic ~buf ~pos:0 ~len:4;\n Bytes.unsafe_to_string ~no_mutation_while_string_reachable:buf\n in\n if not (String.equal magic \"TZif\")\n then raise (Invalid_file_format \"magic characters TZif not present\");\n let version =\n match In_channel.input_char ic with\n | Some '\\000' -> `V1\n | Some '2' -> `V2\n | Some '3' -> `V3\n | None -> raise (Invalid_file_format \"expected version, found nothing\")\n | Some bad_version ->\n raise (Invalid_file_format (sprintf \"version (%c) is invalid\" bad_version))\n in\n (* space reserved for future use in the format *)\n In_channel.really_input_exn ic ~buf:(Bytes.create 15) ~pos:0 ~len:15;\n version\n ;;\n\n let input_tz_file_v1 ic =\n let input_leap_second =\n input_leap_second_gen ~input_leap_second:input_long_as_int63\n in\n input_tz_file_gen ~input_transition:input_long_as_int63 ~input_leap_second ic\n ;;\n\n (*\n version 2 timezone files have the format:\n\n part 1 - exactly the same as v1\n\n part 2 - same format as v1, except that 8 bytes are used to store\n transition times and leap seconds\n\n part 3 - a newline-encloded, POSIX-TZ-environment-variable-style\n string for use in handling instants after the last transition time\n stored in the file (with nothing between the newlines if there is no\n POSIX representation for such instants)\n\n We handle files in this format by parsing the first part exactly as a v1\n timezone file and then continuing to parse with 64bit reading functions in the\n right places.\n\n Version 3 timezone files are the same as version 2, except the\n POSIX-TZ-environment-variable-style string in part 3 may use two minor\n extensions to the POSIX TZ format (the hours part of its transition\n times may be signed and range from -167 through 167 instead of the\n POSIX-required unsigned values from 0 through 24; and DST is in effect all\n year if it starts January 1 at 00:00 and ends December 31 at 24:00 plus the\n difference between daylight saving and standard time).\n\n As we don't actually do anything with part 3 anyway, we can just read v3\n files as v2.\n *)\n let input_tz_file_v2_or_v3 ~version ic =\n let (_ : string -> original_filename:string -> digest:Md5_lib.t -> t) =\n input_tz_file_v1 ic\n in\n (* the header is fully repeated *)\n assert ([%compare.equal: [ `V1 | `V2 | `V3 ]] (read_header ic) version);\n let input_leap_second =\n input_leap_second_gen ~input_leap_second:input_long_long_as_int63\n in\n input_tz_file_gen\n ~input_transition:input_long_long_as_int63\n ~input_leap_second\n ic\n ;;\n\n let input_tz_file ~zonename ~filename =\n try\n protectx (In_channel.create filename) ~finally:In_channel.close ~f:(fun ic ->\n let make_zone =\n match read_header ic with\n | `V1 -> input_tz_file_v1 ic\n | (`V2 | `V3) as version -> input_tz_file_v2_or_v3 ~version ic\n in\n let digest = Md5.digest_file_blocking filename in\n let r = make_zone zonename ~original_filename:filename ~digest in\n r)\n with\n | Invalid_file_format reason ->\n raise (Invalid_file_format (sprintf \"%s - %s\" filename reason))\n ;;\n end\n\n let of_utc_offset ~hours:offset =\n assert (offset >= -24 && offset <= 24);\n let name =\n if offset = 0\n then \"UTC\"\n else sprintf \"UTC%s%d\" (if offset < 0 then \"-\" else \"+\") (abs offset)\n in\n let utc_offset_in_seconds = Int63.of_int (offset * 60 * 60) in\n { name\n ; original_filename = None\n ; digest = None\n ; transitions = [||]\n ; last_regime_index = Index.before_first_transition\n ; default_local_time_type =\n { Regime.utc_offset_in_seconds; is_dst = false; abbrv = name }\n ; leap_seconds = []\n }\n ;;\n end\n end\nend\n\ninclude Stable.Full_data.V1\n\nlet sexp_of_t t = Sexp.Atom t.name\n\nlet likely_machine_zones =\n ref [ \"America/New_York\"; \"Europe/London\"; \"Asia/Hong_Kong\"; \"America/Chicago\" ]\n;;\n\nlet input_tz_file = Zone_file.input_tz_file\nlet utc = of_utc_offset ~hours:0\nlet name zone = zone.name\nlet reset_transition_cache t = t.last_regime_index <- Index.before_first_transition\n\n(* Raises if [index >= Array.length t.transitions] *)\nlet get_regime_exn t index =\n if index < 0 then t.default_local_time_type else t.transitions.(index).new_regime\n;;\n\n(* In \"absolute mode\", a number of seconds is interpreted as an offset of that many\n seconds from the UNIX epoch, ignoring leap seconds.\n\n In \"date and ofday mode\", you interpret the number of seconds as a number of days in\n combination with a number of seconds since midnight, which gives you a calendar day and\n a clock face time. Then you take the time that those represent in some relevant\n timezone.\n\n Of course, if the timezone in question has DST shifts, the date and ofday might\n represent two or zero times. These times will be interpreted according to either the\n previous UTC offset or the next one, in a way whose precise details you probably\n shouldn't depend on.\n\n (For the curious, what we do is: compute the \"relative time\" of the shift according to\n the new regime, and assign relative times to the old regime or new regime depending on\n which side of the shift time they occur. Since this amounts to using the old regime\n when the clocks move forward and the new regime when the clocks move back, it's\n equivalent to calculating the corresponding Time.t's relative to both the old and the\n new regime and picking the one that occurs later. Yes, later. I had to draw a diagram\n to persuade myself that it's that way round, but it is.)\n*)\nmodule Mode = struct\n type t =\n | Absolute\n | Date_and_ofday\nend\n\nlet effective_start_time ~mode (x : Transition.t) =\n let open Int63.O in\n match (mode : Mode.t) with\n | Absolute -> x.start_time_in_seconds_since_epoch\n | Date_and_ofday ->\n x.start_time_in_seconds_since_epoch + x.new_regime.utc_offset_in_seconds\n;;\n\nlet index_lower_bound_contains_seconds_since_epoch t index ~mode seconds =\n index < 0 || Int63.( >= ) seconds (effective_start_time ~mode t.transitions.(index))\n;;\n\nlet index_upper_bound_contains_seconds_since_epoch t index ~mode seconds =\n index + 1 >= Array.length t.transitions\n || Int63.( < ) seconds (effective_start_time ~mode t.transitions.(index + 1))\n;;\n\nlet binary_search_index_of_seconds_since_epoch t ~mode seconds : Index.t =\n Array.binary_search_segmented\n t.transitions\n `Last_on_left\n ~segment_of:(fun transition ->\n if Int63.( <= ) (effective_start_time transition ~mode) seconds\n then `Left\n else `Right)\n |> Option.value ~default:Index.before_first_transition\n;;\n\nlet index_of_seconds_since_epoch t ~mode seconds =\n let index =\n let index = t.last_regime_index in\n if not (index_lower_bound_contains_seconds_since_epoch t index ~mode seconds)\n (* time is before cached index; try previous index *)\n then (\n let index = index - 1 in\n if not (index_lower_bound_contains_seconds_since_epoch t index ~mode seconds)\n (* time is before previous index; fall back on binary search *)\n then\n binary_search_index_of_seconds_since_epoch t ~mode seconds\n (* time is before cached index and not before previous, so within previous *)\n else index)\n else if not (index_upper_bound_contains_seconds_since_epoch t index ~mode seconds)\n (* time is after cached index; try next index *)\n then (\n let index = index + 1 in\n if not (index_upper_bound_contains_seconds_since_epoch t index ~mode seconds)\n (* time is after next index; fall back on binary search *)\n then\n binary_search_index_of_seconds_since_epoch t ~mode seconds\n (* time is after cached index and not after next, so within next *)\n else index (* time is within cached index *))\n else index\n in\n t.last_regime_index <- index;\n index\n;;\n\nmodule Time_in_seconds : sig\n include Zone_intf.Time_in_seconds\nend = struct\n module Span = struct\n type t = Int63.t\n\n let of_int63_seconds = ident\n let to_int63_seconds_round_down_exn = ident\n end\n\n module Absolute = struct\n type t = Int63.t\n\n let of_span_since_epoch = ident\n let to_span_since_epoch = ident\n end\n\n module Date_and_ofday = struct\n type t = Int63.t\n\n let of_synthetic_span_since_epoch = ident\n let to_synthetic_span_since_epoch = ident\n end\n\n include Absolute\nend\n\nlet index t time =\n Time_in_seconds.to_span_since_epoch time\n |> Time_in_seconds.Span.to_int63_seconds_round_down_exn\n |> index_of_seconds_since_epoch t ~mode:Absolute\n;;\n\nlet index_of_date_and_ofday t time =\n Time_in_seconds.Date_and_ofday.to_synthetic_span_since_epoch time\n |> Time_in_seconds.Span.to_int63_seconds_round_down_exn\n |> index_of_seconds_since_epoch t ~mode:Date_and_ofday\n;;\n\nlet index_has_prev_clock_shift t index = index >= 0 && index < Array.length t.transitions\nlet index_has_next_clock_shift t index = index_has_prev_clock_shift t (index + 1)\n\nlet index_prev_clock_shift_time_exn t index =\n let transition = t.transitions.(index) in\n transition.start_time_in_seconds_since_epoch\n |> Time_in_seconds.Span.of_int63_seconds\n |> Time_in_seconds.of_span_since_epoch\n;;\n\nlet index_next_clock_shift_time_exn t index =\n index_prev_clock_shift_time_exn t (index + 1)\n;;\n\nlet index_prev_clock_shift_amount_exn t index =\n let transition = t.transitions.(index) in\n let after = transition.new_regime in\n let before =\n if index = 0 then t.default_local_time_type else t.transitions.(index - 1).new_regime\n in\n Int63.( - ) after.utc_offset_in_seconds before.utc_offset_in_seconds\n |> Time_in_seconds.Span.of_int63_seconds\n;;\n\nlet index_next_clock_shift_amount_exn t index =\n index_prev_clock_shift_amount_exn t (index + 1)\n;;\n\nlet index_abbreviation_exn t index =\n let regime = get_regime_exn t index in\n regime.abbrv\n;;\n\nlet index_offset_from_utc_exn t index =\n let regime = get_regime_exn t index in\n Time_in_seconds.Span.of_int63_seconds regime.utc_offset_in_seconds\n;;\n","open! Import\ninclude Base.Source_code_position\ninclude Source_code_position0\ninclude Comparable.Extend (Base.Source_code_position) (Source_code_position0)\ninclude Hashable.Make (Source_code_position0)\n","open! Import\nopen Std_internal\nopen Validated_intf\n\nmodule type Raw = Raw\n\ntype ('raw, 'witness) t = 'raw\n\nmodule type S = S with type ('a, 'b) validated := ('a, 'b) t\nmodule type S_bin_io = S_bin_io with type ('a, 'b) validated := ('a, 'b) t\n\nmodule type S_bin_io_compare_hash_sexp =\n S_bin_io_compare_hash_sexp with type ('a, 'b) validated := ('a, 'b) t\n\nlet raw t = t\n\nmodule Make (Raw : Raw) = struct\n type witness\n type t = Raw.t [@@deriving sexp_of]\n\n let validation_failed t error =\n Error.create\n \"validation failed\"\n (t, error, Raw.here)\n [%sexp_of: Raw.t * Error.t * Source_code_position.t]\n ;;\n\n let create_exn t =\n match Validate.result (Raw.validate t) with\n | Ok () -> t\n | Error error -> Error.raise (validation_failed t error)\n ;;\n\n let create t =\n match Validate.result (Raw.validate t) with\n | Ok () -> Ok t\n | Error error -> Error (validation_failed t error)\n ;;\n\n let t_of_sexp sexp = create_exn (Raw.t_of_sexp sexp)\n let raw t = t\nend\n\nmodule Add_bin_io (Raw : sig\n type t [@@deriving bin_io]\n\n include Raw_bin_io with type t := t\n end)\n (Validated : S with type raw := Raw.t) =\nstruct\n include Binable.Of_binable_without_uuid [@alert \"-legacy\"]\n (Raw)\n (struct\n type t = Raw.t\n\n let of_binable raw =\n if Raw.validate_binio_deserialization\n then Validated.create_exn raw\n else raw\n ;;\n\n let to_binable = Fn.id\n end)\nend\n\nmodule Add_compare (Raw : sig\n type t [@@deriving compare]\n\n include Raw with type t := t\n end)\n (Validated : S with type raw := Raw.t) =\nstruct\n let compare t1 t2 = [%compare: Raw.t] (raw t1) (raw t2)\nend\n\nmodule Add_hash (Raw : sig\n type t [@@deriving hash]\n\n include Raw with type t := t\n end)\n (Validated : S with type raw := Raw.t) =\nstruct\n let hash_fold_t state t = Raw.hash_fold_t state (Validated.raw t)\n let hash t = Raw.hash (Validated.raw t)\nend\n\nmodule Add_typerep (Raw : sig\n type t [@@deriving typerep]\n\n include Raw with type t := t\n end)\n (Validated : S with type raw := Raw.t) =\nstruct\n type t = Raw.t [@@deriving typerep]\nend\n\nmodule Make_binable (Raw : Raw_bin_io) = struct\n module T0 = Make (Raw)\n include T0\n include Add_bin_io (Raw) (T0)\nend\n\nmodule Make_bin_io_compare_hash_sexp (Raw : sig\n type t [@@deriving compare, hash]\n\n include Raw_bin_io with type t := t\n end) =\nstruct\n module T = Make_binable (Raw)\n include T\n include Add_compare (Raw) (T)\n\n include (\n Add_hash (Raw) (T) :\n sig\n type t [@@deriving hash]\n end\n with type t := t)\nend\n","include Base.Type_equal\n\nmodule Id = struct\n include Id\n\n module Uid = struct\n module Upstream = Base.Type_equal.Id.Uid\n include Base.Type_equal.Id.Uid\n\n include Comparable.Extend\n (Upstream)\n (struct\n type t = Base.Type_equal.Id.Uid.t [@@deriving sexp]\n end)\n\n include Hashable.Make (Upstream)\n end\nend\n","(** Universal/heterogeneous maps, useful for storing values of arbitrary type in a single\n map.\n\n In order to recover a value, it must be looked up with exactly the [Key.t] it was\n stored in. In other words, given different [Key.t]s from the same [string], one will\n not be able to recover the key stored in the other one.\n\n This is similar to [Univ] in spirit.\n*)\n\nopen! Import\n\nmodule type Key = sig\n type 'a t [@@deriving sexp_of]\n\n (** For correct behavior of the map, [to_type_id] must return the same\n [Type_equal.Id] on different calls on the same input.\n *)\n val to_type_id : 'a t -> 'a Type_equal.Id.t\nend\n\nmodule type Data = sig\n type 'a t [@@deriving sexp_of]\nend\n\nmodule type Data1 = sig\n type ('s, 'a) t [@@deriving sexp_of]\nend\n\nmodule type S = sig\n type t [@@deriving sexp_of]\n\n module Key : Key\n\n type 'a data\n\n include Invariant.S with type t := t\n\n val empty : t\n val is_empty : t -> bool\n val set : t -> 'a Key.t -> 'a data -> t\n val mem : t -> 'a Key.t -> bool\n val mem_by_id : t -> Type_equal.Id.Uid.t -> bool\n val find : t -> 'a Key.t -> 'a data option\n val find_exn : t -> 'a Key.t -> 'a data\n val add : t -> 'a Key.t -> 'a data -> [ `Ok of t | `Duplicate ]\n val add_exn : t -> 'a Key.t -> 'a data -> t\n val change : t -> 'a Key.t -> f:('a data option -> 'a data option) -> t\n val change_exn : t -> 'a Key.t -> f:('a data -> 'a data) -> t\n val update : t -> 'a Key.t -> f:('a data option -> 'a data) -> t\n val remove : t -> 'a Key.t -> t\n val remove_by_id : t -> Type_equal.Id.Uid.t -> t\n\n module Packed : sig\n type t = T : 'a Key.t * 'a data -> t\n end\n\n val to_alist : t -> Packed.t list\n val of_alist_exn : Packed.t list -> t\nend\n\nmodule type S1 = sig\n (** The ['s] parameter is shared across all values stored in the map. *)\n type 's t [@@deriving sexp_of]\n\n module Key : Key\n\n type ('s, 'a) data\n\n val invariant : _ t -> unit\n val empty : _ t\n val is_empty : _ t -> bool\n val set : 's t -> 'a Key.t -> ('s, 'a) data -> 's t\n val mem : _ t -> _ Key.t -> bool\n val mem_by_id : _ t -> Type_equal.Id.Uid.t -> bool\n val find : 's t -> 'a Key.t -> ('s, 'a) data option\n val find_exn : 's t -> 'a Key.t -> ('s, 'a) data\n val add : 's t -> 'a Key.t -> ('s, 'a) data -> [ `Ok of 's t | `Duplicate ]\n val add_exn : 's t -> 'a Key.t -> ('s, 'a) data -> 's t\n\n val change\n : 's t\n -> 'a Key.t\n -> f:(('s, 'a) data option -> ('s, 'a) data option)\n -> 's t\n\n val change_exn : 's t -> 'a Key.t -> f:(('s, 'a) data -> ('s, 'a) data) -> 's t\n val update : 's t -> 'a Key.t -> f:(('s, 'a) data option -> ('s, 'a) data) -> 's t\n val remove : 's t -> 'a Key.t -> 's t\n val remove_by_id : 's t -> Type_equal.Id.Uid.t -> 's t\n\n module Packed : sig\n type 's t = T : 'a Key.t * ('s, 'a) data -> 's t\n end\n\n val to_alist : 's t -> 's Packed.t list\n val of_alist_exn : 's Packed.t list -> 's t\nend\n\nmodule type Univ_map = sig\n module type S = S\n module type S1 = S1\n module type Key = Key\n module type Data = Data\n\n module Type_id_key : Key with type 'a t = 'a Type_equal.Id.t\n include S with type 'a data = 'a and module Key := Type_id_key\n\n (** This binding is convenient because existing call sites often refer to\n [Univ_map.Key.create].\n *)\n module Key = Type_equal.Id\n\n module Make (Key : Key) (Data : Data) :\n S with type 'a data = 'a Data.t and module Key = Key\n\n module Make1 (Key : Key) (Data : Data1) :\n S1 with type ('s, 'a) data = ('s, 'a) Data.t and module Key = Key\n\n module Merge\n (Key : Key)\n (Input1_data : Data1)\n (Input2_data : Data1)\n (Output_data : Data1) : sig\n type 's f =\n { f :\n 'a. key:'a Key.t\n -> [ `Left of ('s, 'a) Input1_data.t\n | `Right of ('s, 'a) Input2_data.t\n | `Both of ('s, 'a) Input1_data.t * ('s, 'a) Input2_data.t\n ] -> ('s, 'a) Output_data.t option\n }\n\n (** The analogue of the normal [Map.merge] function. *)\n val merge\n : 's Make1(Key)(Input1_data).t\n -> 's Make1(Key)(Input2_data).t\n -> f:'s f\n -> 's Make1(Key)(Output_data).t\n end\n\n (** keys with associated default values, so that [find] is no longer partial *)\n module With_default : sig\n module Key : sig\n type 'a t\n\n val create : default:'a -> name:string -> ('a -> Sexp.t) -> 'a t\n val id : 'a t -> 'a Type_equal.Id.t\n end\n\n val set : t -> 'a Key.t -> 'a -> t\n val find : t -> 'a Key.t -> 'a\n val change : t -> 'a Key.t -> f:('a -> 'a) -> t\n end\n\n (** keys that map to an accumulator value with an associated fold operation *)\n module With_fold : sig\n module Key : sig\n type ('a, 'b) t\n\n val create\n : init:'b\n -> f:('b -> 'a -> 'b)\n -> name:string\n -> ('b -> Sexp.t)\n -> ('a, 'b) t\n\n val id : ('a, 'b) t -> 'b Type_equal.Id.t\n end\n\n (** reset the accumulator *)\n val set : t -> ('a, 'b) Key.t -> 'b -> t\n\n (** the current accumulator *)\n val find : t -> ('a, 'b) Key.t -> 'b\n\n (** fold value into accumulator *)\n val add : t -> ('a, 'b) Key.t -> 'a -> t\n\n (** accumulator update *)\n val change : t -> ('a, 'b) Key.t -> f:('b -> 'b) -> t\n end\n\n (** list-accumulating keys with a default value of the empty list *)\n module Multi : sig\n module Key : sig\n type 'a t\n\n val create : name:string -> ('a -> Sexp.t) -> 'a t\n val id : 'a t -> 'a list Type_equal.Id.t\n end\n\n val set : t -> 'a Key.t -> 'a list -> t\n val find : t -> 'a Key.t -> 'a list\n val add : t -> 'a Key.t -> 'a -> t\n val change : t -> 'a Key.t -> f:('a list -> 'a list) -> t\n end\nend\n","open! Import\n\ntype t =\n | Nanosecond\n | Microsecond\n | Millisecond\n | Second\n | Minute\n | Hour\n | Day\n[@@deriving sexp, compare, enumerate, hash]\n","open! Import\nopen Std_internal\nopen Unique_id_intf\n\nmodule type Id = Id\n\n(* Only \"make\" can cause a context-switch that might lead to a race.\n Thus we have to check whether the contents of the cell remained\n unchanged across this call. The subsequent comparison, dereferencing\n and assignment cannot cause context switches. If the contents of the\n cell had changed, we will have to try again to obtain a unique id.\n This is essentially like a spin-lock and is virtually guaranteed to\n succeed quickly. *)\nlet rec race_free_create_loop cell make =\n let x = !cell in\n let new_x = make x in\n if phys_equal !cell x\n then (\n cell := new_x;\n x)\n else race_free_create_loop cell make\n;;\n\nmodule Int () = struct\n include Int\n\n let current = ref zero\n let create () = race_free_create_loop current succ\nend\n\nmodule Int63 () = struct\n include Int63\n\n let current = ref zero\n let create () = race_free_create_loop current succ\nend\n","open! Import\ninclude Base.Uniform_array\n\ninclude Binable.Of_binable1_without_uuid [@alert \"-legacy\"]\n (Array)\n (struct\n type nonrec 'a t = 'a t\n\n let to_binable = to_array\n let of_binable = of_array\n end)\n","open! Import\n\nlet failwithf = Printf.failwithf\n\nmodule Stable = struct\n module V1 = struct\n module T = struct\n type t =\n | Sun\n | Mon\n | Tue\n | Wed\n | Thu\n | Fri\n | Sat\n [@@deriving bin_io, compare, hash, quickcheck]\n\n let to_string t =\n match t with\n | Sun -> \"SUN\"\n | Mon -> \"MON\"\n | Tue -> \"TUE\"\n | Wed -> \"WED\"\n | Thu -> \"THU\"\n | Fri -> \"FRI\"\n | Sat -> \"SAT\"\n ;;\n\n let to_string_long t =\n match t with\n | Sun -> \"Sunday\"\n | Mon -> \"Monday\"\n | Tue -> \"Tuesday\"\n | Wed -> \"Wednesday\"\n | Thu -> \"Thursday\"\n | Fri -> \"Friday\"\n | Sat -> \"Saturday\"\n ;;\n\n let of_string_internal s =\n match String.uppercase s with\n | \"SUN\" | \"SUNDAY\" -> Sun\n | \"MON\" | \"MONDAY\" -> Mon\n | \"TUE\" | \"TUESDAY\" -> Tue\n | \"WED\" | \"WEDNESDAY\" -> Wed\n | \"THU\" | \"THURSDAY\" -> Thu\n | \"FRI\" | \"FRIDAY\" -> Fri\n | \"SAT\" | \"SATURDAY\" -> Sat\n | _ -> failwithf \"Day_of_week.of_string: %S\" s ()\n ;;\n\n let of_int_exn i =\n match i with\n | 0 -> Sun\n | 1 -> Mon\n | 2 -> Tue\n | 3 -> Wed\n | 4 -> Thu\n | 5 -> Fri\n | 6 -> Sat\n | _ -> failwithf \"Day_of_week.of_int_exn: %d\" i ()\n ;;\n\n (* Be very generous with of_string. We accept all possible capitalizations and the\n integer representations as well. *)\n let of_string s =\n try of_string_internal s with\n | _ ->\n (try of_int_exn (Int.of_string s) with\n | _ -> failwithf \"Day_of_week.of_string: %S\" s ())\n ;;\n\n (* this is in T rather than outside so that the later functor application to build maps\n uses this sexp representation *)\n include Sexpable.Stable.Of_stringable.V1 (struct\n type nonrec t = t\n\n let of_string = of_string\n let to_string = to_string\n end)\n end\n\n include T\n\n module Unstable = struct\n include T\n include (Comparable.Make_binable (T) : Comparable.S_binable with type t := t)\n include Hashable.Make_binable (T)\n end\n\n include Comparable.Stable.V1.Make (Unstable)\n include Hashable.Stable.V1.Make (Unstable)\n end\nend\n\ninclude Stable.V1.Unstable\n\nlet weekdays = [ Mon; Tue; Wed; Thu; Fri ]\nlet weekends = [ Sat; Sun ]\n\n(* written out to save overhead when loading modules. The members of the set and the\n ordering should never change, so speed wins over something more complex that proves\n the order = the order in t at runtime *)\nlet all = [ Sun; Mon; Tue; Wed; Thu; Fri; Sat ]\n\nlet of_int i =\n try Some (of_int_exn i) with\n | _ -> None\n;;\n\nlet to_int t =\n match t with\n | Sun -> 0\n | Mon -> 1\n | Tue -> 2\n | Wed -> 3\n | Thu -> 4\n | Fri -> 5\n | Sat -> 6\n;;\n\nlet iso_8601_weekday_number t =\n match t with\n | Mon -> 1\n | Tue -> 2\n | Wed -> 3\n | Thu -> 4\n | Fri -> 5\n | Sat -> 6\n | Sun -> 7\n;;\n\nlet num_days_in_week = 7\nlet shift t i = of_int_exn (Int.( % ) (to_int t + i) num_days_in_week)\n\nlet num_days ~from ~to_ =\n let d = to_int to_ - to_int from in\n if Int.(d < 0) then d + num_days_in_week else d\n;;\n\nlet is_sun_or_sat t = t = Sun || t = Sat\n","open! Import\nopen Std_internal\nopen Digit_string_helpers\n\nlet suffixes char =\n let sprintf = Printf.sprintf in\n [ sprintf \"%c\" char; sprintf \"%cM\" char; sprintf \"%c.M\" char; sprintf \"%c.M.\" char ]\n |> List.concat_map ~f:(fun suffix ->\n [ String.lowercase suffix; String.uppercase suffix ])\n;;\n\nlet am_suffixes = lazy (suffixes 'A')\nlet pm_suffixes = lazy (suffixes 'P')\n\n(* Avoids the allocation that [List.find] would entail in both both the closure input and\n the option output. *)\nlet rec find_suffix string suffixes =\n match suffixes with\n | suffix :: suffixes ->\n if String.is_suffix string ~suffix then suffix else find_suffix string suffixes\n | [] -> \"\"\n;;\n\nlet has_colon string pos ~until = pos < until && Char.equal ':' string.[pos]\n\n(* This function defines what we meant by \"decimal point\", because in some string formats\n it means '.' and in some it can be '.' or ','. There's no particular demand for support\n for ',', and using just '.' lets us use [Float.of_string] for the decimal substring\n without any substitutions. *)\nlet char_is_decimal_point string pos = Char.equal '.' string.[pos]\n\nlet decrement_length_if_ends_in_space string len =\n if len > 0 && Char.equal ' ' string.[len - 1] then len - 1 else len\n;;\n\nlet[@cold] invalid_string string ~reason =\n raise_s [%message \"Time.Ofday: invalid string\" string reason]\n;;\n\nlet check_digits_with_underscore_and_return_if_nonzero string pos ~until =\n let nonzero = ref false in\n for pos = pos to until - 1 do\n match string.[pos] with\n | '0' | '_' -> ()\n | '1' .. '9' -> nonzero := true\n | _ ->\n invalid_string\n string\n ~reason:\"expected digits and/or underscores after decimal point\"\n done;\n !nonzero\n;;\n\nlet check_digits_without_underscore_and_return_if_nonzero string pos ~until =\n let nonzero = ref false in\n for pos = pos to until - 1 do\n match string.[pos] with\n | '0' -> ()\n | '1' .. '9' -> nonzero := true\n | _ -> invalid_string string ~reason:\"expected digits after decimal point\"\n done;\n !nonzero\n;;\n\nlet parse string ~f =\n let len = String.length string in\n let am_or_pm, until =\n (* discriminate among AM (1:30am), PM (12:30:00 P.M.), or 24-hr (13:00). *)\n match\n ( find_suffix string (Lazy.force am_suffixes)\n , find_suffix string (Lazy.force pm_suffixes) )\n with\n | \"\", \"\" -> `hr_24, len\n | am, \"\" -> `hr_AM, decrement_length_if_ends_in_space string (len - String.length am)\n | \"\", pm -> `hr_PM, decrement_length_if_ends_in_space string (len - String.length pm)\n | _, _ -> `hr_24, assert false\n (* Immediately above, it may seem nonsensical to write [`hr_24, assert false] when the\n [`hr_24] can never be returned. We do this to help the compiler figure out never to\n allocate a tuple in this code: the [let] pattern is syntactically a tuple and every\n match clause is syntactically a tuple. *)\n in\n let pos = 0 in\n let pos, hr, expect_minutes_and_seconds =\n (* e.g. \"1:00\" or \"1:00:00\" *)\n if has_colon string (pos + 1) ~until\n then\n pos + 2, read_1_digit_int string ~pos, `Minutes_and_maybe_seconds\n (* e.g. \"12:00\" or \"12:00:00\" *)\n else if has_colon string (pos + 2) ~until\n then\n pos + 3, read_2_digit_int string ~pos, `Minutes_and_maybe_seconds\n (* e.g. \"1am\"; must have AM or PM (checked below) *)\n else if pos + 1 = until\n then\n pos + 1, read_1_digit_int string ~pos, `Neither_minutes_nor_seconds\n (* e.g. \"12am\"; must have AM or PM (checked below) *)\n else if pos + 2 = until\n then\n pos + 2, read_2_digit_int string ~pos, `Neither_minutes_nor_seconds\n (* e.g. \"0930\"; must not have seconds *)\n else pos + 2, read_2_digit_int string ~pos, `Minutes_but_not_seconds\n in\n let pos, min, expect_seconds =\n match expect_minutes_and_seconds with\n | `Neither_minutes_nor_seconds ->\n (* e.g. \"12am\" *)\n pos, 0, false\n | (`Minutes_and_maybe_seconds | `Minutes_but_not_seconds) as maybe_seconds ->\n (* e.g. \"12:00:00\" *)\n if has_colon string (pos + 2) ~until\n then\n ( pos + 3\n , read_2_digit_int string ~pos\n , match maybe_seconds with\n | `Minutes_and_maybe_seconds -> true\n | `Minutes_but_not_seconds ->\n invalid_string string ~reason:\"expected end of string after minutes\" )\n (* e.g. \"12:00\" *)\n else if pos + 2 = until\n then pos + 2, read_2_digit_int string ~pos, false\n else\n invalid_string\n string\n ~reason:\"expected colon or am/pm suffix with optional space after minutes\"\n in\n let sec, subsec_pos, subsec_len, subsec_nonzero =\n match expect_seconds with\n | false ->\n (* e.g. \"12am\" or \"12:00\" *)\n if pos = until\n then 0, pos, 0, false\n else\n (* This case is actually unreachable, based on the various ways that\n [expect_seconds] can end up false. *)\n invalid_string string ~reason:\"BUG: did not expect seconds, but found them\"\n | true ->\n (* e.g. \"12:00:00\" *)\n if pos + 2 > until\n then\n (* e.g. \"12:00:0\" *)\n invalid_string string ~reason:\"expected two digits of seconds\"\n else (\n let sec = read_2_digit_int string ~pos in\n let pos = pos + 2 in\n (* e.g. \"12:00:00\" *)\n if pos = until\n then sec, pos, 0, false (* e.g. \"12:00:00.123\" *)\n else if pos < until && char_is_decimal_point string pos\n then\n ( sec\n , pos\n , until - pos\n , check_digits_with_underscore_and_return_if_nonzero string (pos + 1) ~until )\n else\n invalid_string\n string\n ~reason:\"expected decimal point or am/pm suffix after seconds\")\n in\n let hr =\n (* NB. We already know [hr] is non-negative, because it's the result of\n [read_2_digit_int]. *)\n match am_or_pm with\n | `hr_AM ->\n (* e.g. \"12:00am\" *)\n if hr < 1 || hr > 12\n then invalid_string string ~reason:\"hours out of bounds\"\n else if hr = 12\n then 0\n else hr\n | `hr_PM ->\n (* e.g. \"12:00pm\" *)\n if hr < 1 || hr > 12\n then invalid_string string ~reason:\"hours out of bounds\"\n else if hr = 12\n then 12\n else hr + 12\n | `hr_24 ->\n (match expect_minutes_and_seconds with\n | `Neither_minutes_nor_seconds ->\n invalid_string string ~reason:\"hours without minutes or AM/PM\"\n | `Minutes_but_not_seconds | `Minutes_and_maybe_seconds ->\n if hr > 24\n then invalid_string string ~reason:\"hours out of bounds\"\n else if hr = 24 && (min > 0 || sec > 0 || subsec_nonzero)\n then invalid_string string ~reason:\"time is past 24:00:00\" (* e.g. \"13:00:00\" *)\n else hr)\n in\n let min =\n if min > 59 then invalid_string string ~reason:\"minutes out of bounds\" else min\n in\n let sec =\n if sec > 60 then invalid_string string ~reason:\"seconds out of bounds\" else sec\n in\n let subsec_len = if sec = 60 || not subsec_nonzero then 0 else subsec_len in\n f string ~hr ~min ~sec ~subsec_pos ~subsec_len\n;;\n\nlet parse_iso8601_extended ?pos ?len str ~f =\n let pos, len =\n match\n Ordered_collection_common.get_pos_len\n ()\n ?pos\n ?len\n ~total_length:(String.length str)\n with\n | Result.Ok z -> z\n | Result.Error s ->\n failwithf \"Ofday.of_string_iso8601_extended: %s\" (Error.to_string_mach s) ()\n in\n if len < 2\n then failwith \"len < 2\"\n else (\n let hr = read_2_digit_int str ~pos in\n if hr > 24 then failwith \"hour > 24\";\n if len = 2\n then f str ~hr ~min:0 ~sec:0 ~subsec_pos:(pos + len) ~subsec_len:0\n else if len < 5\n then failwith \"2 < len < 5\"\n else if not (Char.equal str.[pos + 2] ':')\n then failwith \"first colon missing\"\n else (\n let min = read_2_digit_int str ~pos:(pos + 3) in\n if min >= 60 then failwith \"minute > 60\";\n if hr = 24 && min <> 0 then failwith \"24 hours and non-zero minute\";\n if len = 5\n then f str ~hr ~min ~sec:0 ~subsec_pos:(pos + len) ~subsec_len:0\n else if len < 8\n then failwith \"5 < len < 8\"\n else if not (Char.equal str.[pos + 5] ':')\n then failwith \"second colon missing\"\n else (\n let sec = read_2_digit_int str ~pos:(pos + 6) in\n (* second can be 60 in the case of a leap second. Unfortunately, what with\n non-hour-multiple timezone offsets, we can't say anything about what\n the hour or minute must be in that case *)\n if sec > 60 then failwithf \"invalid second: %i\" sec ();\n if hr = 24 && sec <> 0 then failwith \"24 hours and non-zero seconds\";\n if len = 8\n then f str ~hr ~min ~sec ~subsec_pos:(pos + len) ~subsec_len:0\n else if len = 9\n then failwith \"length = 9\"\n else (\n match str.[pos + 8] with\n | '.' | ',' ->\n let subsec_pos = pos + 8 in\n let subsec_len =\n match\n check_digits_without_underscore_and_return_if_nonzero\n str\n (subsec_pos + 1)\n ~until:(pos + len)\n with\n | true when sec = 60 -> 0\n | true when hr = 24 -> failwith \"24 hours and non-zero subseconds\"\n | _ -> len - 8\n in\n f str ~hr ~min ~sec ~subsec_pos ~subsec_len\n | _ -> failwith \"missing subsecond separator\"))))\n;;\n","open! Import\ninclude Bin_prot.Std\ninclude Hash.Builtin\n\ninclude (\n Base :\n sig\n type nonrec 'a array = 'a array [@@deriving sexp, sexp_grammar]\n type nonrec bool = bool [@@deriving sexp, sexp_grammar]\n type nonrec char = char [@@deriving sexp, sexp_grammar]\n type nonrec exn = exn [@@deriving sexp_of]\n type nonrec float = float [@@deriving sexp, sexp_grammar]\n type nonrec int = int [@@deriving sexp, sexp_grammar]\n type nonrec int32 = int32 [@@deriving sexp, sexp_grammar]\n type nonrec int64 = int64 [@@deriving sexp, sexp_grammar]\n type nonrec 'a list = 'a list [@@deriving sexp, sexp_grammar]\n type nonrec nativeint = nativeint [@@deriving sexp, sexp_grammar]\n type nonrec 'a option = 'a option [@@deriving sexp, sexp_grammar]\n type nonrec 'a ref = 'a ref [@@deriving sexp, sexp_grammar]\n type nonrec string = string [@@deriving sexp, sexp_grammar]\n type nonrec bytes = bytes [@@deriving sexp, sexp_grammar]\n type nonrec unit = unit [@@deriving sexp, sexp_grammar]\n end\n with type 'a array := 'a array\n with type bool := bool\n with type char := char\n with type exn := exn\n with type float := float\n with type int := int\n with type int32 := int32\n with type int64 := int64\n with type 'a list := 'a list\n with type nativeint := nativeint\n with type 'a option := 'a option\n with type 'a ref := 'a ref\n with type string := string\n with type bytes := bytes\n with type unit := unit)\n\ninclude (\nstruct\n type 'a sexp_option = ('a Std_internal.sexp_option[@ocaml.warning \"-3\"])\n [@@deriving bin_io, compare, hash]\n\n type 'a sexp_list = ('a Std_internal.sexp_list[@ocaml.warning \"-3\"])\n [@@deriving bin_io, compare, hash]\nend :\nsig\n type 'a sexp_option = ('a Std_internal.sexp_option[@ocaml.warning \"-3\"])\n [@@deriving bin_io, compare, hash]\n\n type 'a sexp_list = ('a Std_internal.sexp_list[@ocaml.warning \"-3\"])\n [@@deriving bin_io, compare, hash]\nend\nwith type 'a sexp_option := ('a Std_internal.sexp_option[@ocaml.warning \"-3\"])\nwith type 'a sexp_list := ('a Std_internal.sexp_list[@ocaml.warning \"-3\"]))\n\ntype 'a sexp_option = ('a Std_internal.sexp_option[@ocaml.warning \"-3\"])\n[@@deprecated \"[since 2019-03] use [@sexp.option] instead\"]\n\ntype 'a sexp_list = ('a Std_internal.sexp_list[@ocaml.warning \"-3\"])\n[@@deprecated \"[since 2019-03] use [@sexp.list] instead\"]\n","open Ppx_compare_lib.Builtin\n\nmodule Stable = struct\n open Stable_internal\n module Binable = Binable.Stable\n\n module V1 = struct\n exception Nan_or_inf [@@deriving sexp]\n\n type t = float [@@deriving compare, hash]\n\n let verify t =\n match Caml.classify_float t with\n | FP_normal | FP_subnormal | FP_zero -> ()\n | FP_infinite | FP_nan -> raise Nan_or_inf\n ;;\n\n include Binable.Of_binable.V1 [@alert \"-legacy\"]\n (Float)\n (struct\n type nonrec t = t\n\n let of_binable t =\n verify t;\n t\n ;;\n\n let to_binable t =\n verify t;\n t\n ;;\n end)\n\n let sexp_of_t = Float.sexp_of_t\n\n let t_of_sexp = function\n | Sexp.Atom _ as sexp ->\n let t = Float.t_of_sexp sexp in\n (try verify t with\n | e -> Import.of_sexp_error (Import.Exn.to_string e) sexp);\n t\n | s -> Import.of_sexp_error \"Decimal.t_of_sexp: Expected Atom, found List\" s\n ;;\n end\nend\n\ninclude Stable.V1\n","open Async_kernel\nopen Core_kernel\n\nmodule type Time_intf = sig\n type t\n\n module Span : sig\n type t\n\n val to_time_ns_span : t -> Time_ns.Span.t\n\n val ( - ) : t -> t -> t\n end\n\n module Controller : sig\n type t\n end\n\n val now : Controller.t -> t\n\n val diff : t -> t -> Span.t\nend\n\nmodule Timeout_intf (Time : Time_intf) = struct\n module type S = sig\n type 'a t\n\n val create : Time.Controller.t -> Time.Span.t -> f:(Time.t -> 'a) -> 'a t\n\n val to_deferred : 'a t -> 'a Async_kernel.Deferred.t\n\n val peek : 'a t -> 'a option\n\n val cancel : Time.Controller.t -> 'a t -> 'a -> unit\n\n val remaining_time : 'a t -> Time.Span.t\n\n val await :\n timeout_duration:Time.Span.t\n -> Time.Controller.t\n -> 'a Deferred.t\n -> [ `Ok of 'a | `Timeout ] Deferred.t\n\n val await_exn :\n timeout_duration:Time.Span.t\n -> Time.Controller.t\n -> 'a Deferred.t\n -> 'a Deferred.t\n end\nend\n\nmodule Make (Time : Time_intf) : Timeout_intf(Time).S = struct\n type 'a t =\n { deferred : 'a Deferred.t\n ; cancel : 'a -> unit\n ; start_time : Time.t\n ; span : Time.Span.t\n ; ctrl : Time.Controller.t\n }\n\n let create ctrl span ~f:action =\n let open Deferred.Let_syntax in\n let cancel_ivar = Ivar.create () in\n let timeout = after (Time.Span.to_time_ns_span span) >>| fun () -> None in\n let deferred =\n Deferred.any [ Ivar.read cancel_ivar; timeout ]\n >>| function None -> action (Time.now ctrl) | Some x -> x\n in\n let cancel value = Ivar.fill_if_empty cancel_ivar (Some value) in\n { ctrl; deferred; cancel; start_time = Time.now ctrl; span }\n\n let to_deferred { deferred; _ } = deferred\n\n let peek { deferred; _ } = Deferred.peek deferred\n\n let cancel _ { cancel; _ } value = cancel value\n\n let remaining_time { ctrl : _; start_time; span; _ } =\n let current_time = Time.now ctrl in\n let time_elapsed = Time.diff current_time start_time in\n Time.Span.(span - time_elapsed)\n\n let await ~timeout_duration time_controller deferred =\n let timeout =\n Deferred.create (fun ivar ->\n ignore\n ( create time_controller timeout_duration ~f:(fun x ->\n if Ivar.is_full ivar then\n [%log' error (Logger.create ())] \"Ivar.fill bug is here!\" ;\n Ivar.fill_if_empty ivar x )\n : unit t ) )\n in\n Deferred.(\n choose\n [ choice deferred (fun x -> `Ok x); choice timeout (Fn.const `Timeout) ])\n\n let await_exn ~timeout_duration time_controller deferred =\n match%map await ~timeout_duration time_controller deferred with\n | `Timeout ->\n failwith \"timeout\"\n | `Ok x ->\n x\nend\n\nmodule Core_time = Make (struct\n include (\n Core_kernel.Time :\n module type of Core_kernel.Time\n with module Span := Core_kernel.Time.Span\n and type underlying = float )\n\n module Controller = struct\n type t = unit\n end\n\n module Span = struct\n include Core_kernel.Time.Span\n\n let to_time_ns_span = Fn.compose Core_kernel.Time_ns.Span.of_ns to_ns\n end\n\n let diff x y =\n let x_ns = Span.to_ns @@ to_span_since_epoch x in\n let y_ns = Span.to_ms @@ to_span_since_epoch y in\n Span.of_ns (x_ns -. y_ns)\nend)\n\nmodule Core_time_ns = Make (struct\n include (\n Core_kernel.Time_ns :\n module type of Core_kernel.Time_ns\n with module Span := Core_kernel.Time_ns.Span )\n\n module Controller = struct\n type t = unit\n end\n\n module Span = struct\n include Core_kernel.Time_ns.Span\n\n let to_time_ns_span = Fn.id\n end\n\n let diff x y =\n let x_ns = Span.to_ns @@ to_span_since_epoch x in\n let y_ns = Span.to_ms @@ to_span_since_epoch y in\n Span.of_ns (x_ns -. y_ns)\nend)\n","open! Import\nopen! Std_internal\nmodule Date = Date0\n\nmodule type Zone = sig\n module Time : Time0_intf.S\n include Zone.S with type t = Zone.t and module Time_in_seconds := Time\n\n (** [abbreviation t time] returns the abbreviation name (such as EDT, EST, JST) of given\n zone [t] at [time]. This string conversion is one-way only, and cannot reliably be\n turned back into a [t]. This function reads and writes the zone's cached index. *)\n val abbreviation : t -> Time.t -> string\n\n (** [absolute_time_of_date_and_ofday] and [date_and_ofday_of_absolute_time] convert\n between absolute times and date + ofday forms. These are low level functions not\n intended for most clients. These functions read and write the zone's cached index.\n *)\n val absolute_time_of_date_and_ofday : t -> Time.Date_and_ofday.t -> Time.t\n\n val date_and_ofday_of_absolute_time : t -> Time.t -> Time.Date_and_ofday.t\n\n (** Takes a [Time.t] and returns the next [Time.t] strictly after it, if any, that the\n time zone UTC offset changes, and by how much it does so. *)\n val next_clock_shift : t -> strictly_after:Time.t -> (Time.t * Time.Span.t) option\n\n (** As [next_clock_shift], but *at or before* the given time. *)\n val prev_clock_shift : t -> at_or_before:Time.t -> (Time.t * Time.Span.t) option\nend\n\nmodule type Basic = sig\n module Time : Time0_intf.S\n\n (*_ necessary to preserve type equality with the Time functor argument *)\n\n include module type of struct\n include Time\n end\n [@ocaml.remove_aliases]\n\n (** [now ()] returns a [t] representing the current time *)\n val now : unit -> t\n\n module Zone : Zone with module Time := Time\n\n (** {6 Basic operations on times} *)\n\n (** [add t s] adds the span [s] to time [t] and returns the resulting time.\n\n NOTE: adding spans as a means of adding days is not accurate, and may run into trouble\n due to shifts in daylight savings time, float arithmetic issues, and leap seconds.\n See the comment at the top of Zone.mli for a more complete discussion of some of\n the issues of time-keeping. For spans that cross date boundaries, use date functions\n instead.\n *)\n val add : t -> Span.t -> t\n\n (** [sub t s] subtracts the span [s] from time [t] and returns the\n resulting time. See important note for [add]. *)\n val sub : t -> Span.t -> t\n\n (** [diff t1 t2] returns time [t1] minus time [t2]. *)\n val diff : t -> t -> Span.t\n\n (** [abs_diff t1 t2] returns the absolute span of time [t1] minus time [t2]. *)\n val abs_diff : t -> t -> Span.t\nend\n\nmodule type Shared = sig\n type t\n\n include Quickcheck.S_range with type t := t\n\n module Span : sig\n type t\n end\n\n module Ofday : sig\n type t\n end\n\n (** {6 Comparisons} *)\n\n val is_earlier : t -> than:t -> bool\n val is_later : t -> than:t -> bool\n\n (** {6 Conversions} *)\n\n val of_date_ofday : zone:Zone.t -> Date.t -> Ofday.t -> t\n\n (** Because timezone offsets change throughout the year (clocks go forward or back) some\n local times can occur twice or not at all. In the case that they occur twice, this\n function gives [`Twice] with both occurrences in order; if they do not occur at all,\n this function gives [`Never] with the time at which the local clock skips over the\n desired time of day.\n\n Note that this is really only intended to work with DST transitions and not unusual or\n dramatic changes, like the calendar change in 1752 (run \"cal 9 1752\" in a shell to\n see). In particular it makes the assumption that midnight of each day is unambiguous.\n\n Most callers should use {!of_date_ofday} rather than this function. In the [`Twice]\n and [`Never] cases, {!of_date_ofday} will return reasonable times for most uses. *)\n val of_date_ofday_precise\n : Date.t\n -> Ofday.t\n -> zone:Zone.t\n -> [ `Once of t | `Twice of t * t | `Never of t ]\n\n val to_date_ofday : t -> zone:Zone.t -> Date.t * Ofday.t\n\n (** Always returns the [Date.t * Ofday.t] that [to_date_ofday] would have returned, and in\n addition returns a variant indicating whether the time is associated with a time zone\n transition.\n\n {v\n - `Only -> there is a one-to-one mapping between [t]'s and\n [Date.t * Ofday.t] pairs\n - `Also_at -> there is another [t] that maps to the same [Date.t * Ofday.t]\n (this date/time pair happened twice because the clock fell back)\n - `Also_skipped -> there is another [Date.t * Ofday.t] pair that never happened (due\n to a jump forward) that [of_date_ofday] would map to the same\n [t].\n v}\n *)\n val to_date_ofday_precise\n : t\n -> zone:Zone.t\n -> Date.t * Ofday.t * [ `Only | `Also_at of t | `Also_skipped of Date.t * Ofday.t ]\n\n val to_date : t -> zone:Zone.t -> Date.t\n val to_ofday : t -> zone:Zone.t -> Ofday.t\n\n (** For performance testing only; [reset_date_cache ()] resets an internal cache used to\n speed up [to_date] and related functions when called repeatedly on times that fall\n within the same day. *)\n val reset_date_cache : unit -> unit\n\n (** Unlike [Time_ns], this module purposely omits [max_value] and [min_value]:\n 1. They produce unintuitive corner cases because most people's mental models of time\n do not include +/- infinity as concrete values\n 2. In practice, when people ask for these values, it is for questionable uses, e.g.,\n as null values to use in place of explicit options. *)\n\n (** midnight, Jan 1, 1970 in UTC *)\n val epoch : t\n\n (** It's unspecified what happens if the given date/ofday/zone correspond to more than\n one date/ofday pair in the other zone. *)\n val convert : from_tz:Zone.t -> to_tz:Zone.t -> Date.t -> Ofday.t -> Date.t * Ofday.t\n\n val utc_offset : t -> zone:Zone.t -> Span.t\n\n (** {6 Other string conversions} *)\n\n (** The [{to,of}_string] functions in [Time] convert to UTC time, because a local time\n zone is not necessarily available. They are generous in what they will read in. *)\n include\n Stringable with type t := t\n\n (** [to_filename_string t ~zone] converts [t] to string with format\n YYYY-MM-DD_HH-MM-SS.mmm which is suitable for using in filenames. *)\n val to_filename_string : t -> zone:Zone.t -> string\n\n (** [of_filename_string s ~zone] converts [s] that has format YYYY-MM-DD_HH-MM-SS.mmm into\n time. *)\n val of_filename_string : string -> zone:Zone.t -> t\n\n (** [to_string_abs ~zone t] is the same as [to_string t] except that it uses the given\n time zone. *)\n val to_string_abs : t -> zone:Zone.t -> string\n\n (** [to_string_abs_trimmed] is the same as [to_string_abs], but drops trailing seconds\n and milliseconds if they are 0. *)\n val to_string_abs_trimmed : t -> zone:Zone.t -> string\n\n val to_string_abs_parts : t -> zone:Zone.t -> string list\n\n (** Same as [to_string_abs_trimmed], except it leaves off the timezone, so won't\n reliably round trip. *)\n val to_string_trimmed : t -> zone:Zone.t -> string\n\n (** Same as [to_string_abs], but without milliseconds *)\n val to_sec_string : t -> zone:Zone.t -> string\n\n (** [of_localized_string ~zone str] read in the given string assuming that it represents\n a time in zone and return the appropriate Time.t *)\n val of_localized_string : zone:Zone.t -> string -> t\n\n (** [of_string_gen ~default_zone ~find_zone s] attempts to parse [s] as a [t], calling\n out to [default_zone] and [find_zone] as needed. *)\n val of_string_gen\n : default_zone:(unit -> Zone.t)\n -> find_zone:(string -> Zone.t)\n -> string\n -> t\n\n (** [to_string_iso8601_basic] return a string representation of the following form:\n %Y-%m-%dT%H:%M:%S.%s%Z\n e.g.\n [ to_string_iso8601_basic ~zone:Time.Zone.utc epoch = \"1970-01-01T00:00:00.000000Z\" ]\n *)\n val to_string_iso8601_basic : t -> zone:Zone.t -> string\n\n (** [occurrence side time ~ofday ~zone] returns a [Time.t] that is the occurrence of\n ofday (in the given [zone]) that is the latest occurrence (<=) [time] or the\n earliest occurrence (>=) [time], according to [side].\n\n NOTE: If the given time converted to wall clock time in the given zone is equal to\n ofday then the t returned will be equal to the t given.\n *)\n val occurrence\n : [ `First_after_or_at | `Last_before_or_at ]\n -> t\n -> ofday:Ofday.t\n -> zone:Zone.t\n -> t\nend\n\nmodule type S = sig\n include Basic\n include Shared with type t := t with module Span := Span with module Ofday := Ofday\nend\n\nmodule type Time = sig\n module type S = S\n\n module Make (Time : Time0_intf.S) : S with module Time := Time\nend\n","(* See Time_float.ml for the primary instantiation of this functor that is visible outside\n of Core_kernel as Time (see core_kernel.ml and std.ml). *)\nopen! Import\nopen Std_internal\nopen! Int.Replace_polymorphic_compare\ninclude Time_intf\nmodule Zone0 = Zone\n\nmodule Make (Time0 : Time0_intf.S) = struct\n module Time0 = Time0\n include Time0\n\n let epoch = of_span_since_epoch Span.zero\n let is_earlier t1 ~than:t2 = t1 <. t2\n let is_later t1 ~than:t2 = t1 >. t2\n\n module Zone : sig\n include Time_intf.Zone with module Time := Time0\n end = struct\n include Zone\n\n let of_span_in_seconds span_in_seconds =\n (* NB. no actual rounding or exns can occur here *)\n Time_in_seconds.Span.to_int63_seconds_round_down_exn span_in_seconds\n |> Time0.Span.of_int63_seconds\n ;;\n\n let of_time_in_seconds time_in_seconds =\n Time_in_seconds.to_span_since_epoch time_in_seconds\n (* NB. no actual rounding or exns can occur here *)\n |> Time_in_seconds.Span.to_int63_seconds_round_down_exn\n |> Time0.Span.of_int63_seconds\n |> Time0.of_span_since_epoch\n ;;\n\n let to_time_in_seconds_round_down_exn time =\n Time0.to_span_since_epoch time\n |> Time0.Span.to_int63_seconds_round_down_exn\n |> Time_in_seconds.Span.of_int63_seconds\n |> Time_in_seconds.of_span_since_epoch\n ;;\n\n let to_date_and_ofday_in_seconds_round_down_exn relative =\n Time0.Date_and_ofday.to_synthetic_span_since_epoch relative\n |> Time0.Span.to_int63_seconds_round_down_exn\n |> Time_in_seconds.Span.of_int63_seconds\n |> Time_in_seconds.Date_and_ofday.of_synthetic_span_since_epoch\n ;;\n\n let index t time = index t (to_time_in_seconds_round_down_exn time)\n\n let index_of_date_and_ofday t relative =\n index_of_date_and_ofday t (to_date_and_ofday_in_seconds_round_down_exn relative)\n ;;\n\n let index_offset_from_utc_exn t index =\n of_span_in_seconds (index_offset_from_utc_exn t index)\n ;;\n\n let index_prev_clock_shift_time_exn t index =\n of_time_in_seconds (index_prev_clock_shift_time_exn t index)\n ;;\n\n let index_next_clock_shift_time_exn t index =\n of_time_in_seconds (index_next_clock_shift_time_exn t index)\n ;;\n\n let index_prev_clock_shift_amount_exn t index =\n of_span_in_seconds (index_prev_clock_shift_amount_exn t index)\n ;;\n\n let index_next_clock_shift_amount_exn t index =\n of_span_in_seconds (index_next_clock_shift_amount_exn t index)\n ;;\n\n let abbreviation t time =\n (* no exn because [index] always returns a valid index *)\n index_abbreviation_exn t (index t time)\n ;;\n\n let index_prev_clock_shift t index =\n match index_has_prev_clock_shift t index with\n | false -> None\n | true ->\n Some\n ( index_prev_clock_shift_time_exn t index\n , index_prev_clock_shift_amount_exn t index )\n ;;\n\n let index_next_clock_shift t index = index_prev_clock_shift t (Index.next index)\n let prev_clock_shift t ~at_or_before:time = index_prev_clock_shift t (index t time)\n let next_clock_shift t ~strictly_after:time = index_next_clock_shift t (index t time)\n\n let date_and_ofday_of_absolute_time t time =\n let index = index t time in\n (* no exn because [index] always returns a valid index *)\n let offset_from_utc = index_offset_from_utc_exn t index in\n Time0.Date_and_ofday.of_absolute time ~offset_from_utc\n ;;\n\n let absolute_time_of_date_and_ofday t relative =\n let index = index_of_date_and_ofday t relative in\n (* no exn because [index_of_date_and_ofday] always returns a valid index *)\n let offset_from_utc = index_offset_from_utc_exn t index in\n Time0.Date_and_ofday.to_absolute relative ~offset_from_utc\n ;;\n end\n\n let abs_diff t1 t2 = Span.abs (diff t1 t2)\n\n let of_date_ofday ~zone date ofday =\n let relative = Date_and_ofday.of_date_ofday date ofday in\n Zone.absolute_time_of_date_and_ofday zone relative\n ;;\n\n let of_date_ofday_precise date ofday ~zone =\n (* We assume that there will be only one zone shift within a given local day. *)\n let start_of_day = of_date_ofday ~zone date Ofday.start_of_day in\n let proposed_time = add start_of_day (Ofday.to_span_since_start_of_day ofday) in\n match Zone.next_clock_shift zone ~strictly_after:start_of_day with\n | None -> `Once proposed_time\n | Some (shift_start, shift_amount) ->\n let shift_backwards = Span.(shift_amount < zero) in\n (* start and end of the \"problematic region\" *)\n let s, e =\n if shift_backwards\n then add shift_start shift_amount, shift_start\n else shift_start, add shift_start shift_amount\n in\n if proposed_time < s\n then `Once proposed_time\n else if s <= proposed_time && proposed_time < e\n then\n if shift_backwards\n then `Twice (proposed_time, sub proposed_time shift_amount)\n else `Never shift_start\n else `Once (sub proposed_time shift_amount)\n ;;\n\n module Date_cache = struct\n type t =\n { mutable zone : Zone.t\n ; mutable cache_start_incl : Time0.t\n ; mutable cache_until_excl : Time0.t\n ; mutable effective_day_start : Time0.t\n ; mutable date : Date0.t\n }\n end\n\n let date_cache : Date_cache.t =\n { zone = Zone.utc\n ; cache_start_incl = epoch\n ; cache_until_excl = epoch\n ; effective_day_start = epoch\n ; date = Date0.unix_epoch\n }\n ;;\n\n let reset_date_cache () =\n date_cache.zone <- Zone.utc;\n date_cache.cache_start_incl <- epoch;\n date_cache.cache_until_excl <- epoch;\n date_cache.effective_day_start <- epoch;\n date_cache.date <- Date0.unix_epoch\n ;;\n\n let is_in_cache time ~zone =\n phys_equal zone date_cache.zone\n && Time0.( >= ) time date_cache.cache_start_incl\n && Time0.( < ) time date_cache.cache_until_excl\n ;;\n\n let set_date_cache time ~zone =\n match is_in_cache time ~zone with\n | true -> ()\n | false ->\n let index = Zone.index zone time in\n (* no exn because [Zone.index] always returns a valid index *)\n let offset_from_utc = Zone.index_offset_from_utc_exn zone index in\n let rel = Date_and_ofday.of_absolute time ~offset_from_utc in\n let date = Date_and_ofday.to_date rel in\n let span = Date_and_ofday.to_ofday rel |> Ofday.to_span_since_start_of_day in\n let effective_day_start =\n Time0.sub (Date_and_ofday.to_absolute rel ~offset_from_utc) span\n in\n let effective_day_until = Time0.add effective_day_start Span.day in\n let cache_start_incl =\n match Zone.index_has_prev_clock_shift zone index with\n | false -> effective_day_start\n | true ->\n effective_day_start\n |> Time0.max (Zone.index_prev_clock_shift_time_exn zone index)\n in\n let cache_until_excl =\n match Zone.index_has_next_clock_shift zone index with\n | false -> effective_day_until\n | true ->\n effective_day_until\n |> Time0.min (Zone.index_next_clock_shift_time_exn zone index)\n in\n date_cache.zone <- zone;\n date_cache.cache_start_incl <- cache_start_incl;\n date_cache.cache_until_excl <- cache_until_excl;\n date_cache.effective_day_start <- effective_day_start;\n date_cache.date <- date\n ;;\n\n let to_date time ~zone =\n set_date_cache time ~zone;\n date_cache.date\n ;;\n\n let to_ofday time ~zone =\n set_date_cache time ~zone;\n Time0.diff time date_cache.effective_day_start\n |> Ofday.of_span_since_start_of_day_exn\n ;;\n\n let to_date_ofday time ~zone = to_date time ~zone, to_ofday time ~zone\n\n (* The correctness of this algorithm (interface, even) depends on the fact that\n timezone shifts aren't too close together (as in, it can't simultaneously be the\n case that a timezone shift of X hours occurred less than X hours ago, *and*\n a timezone shift of Y hours will occur in less than Y hours' time) *)\n let to_date_ofday_precise time ~zone =\n let date, ofday = to_date_ofday time ~zone in\n let clock_shift_after = Zone.next_clock_shift zone ~strictly_after:time in\n let clock_shift_before_or_at = Zone.prev_clock_shift zone ~at_or_before:time in\n let also_skipped_earlier amount =\n (* Using [date] and raising on [None] here is OK on the assumption that clock\n shifts can't cross date boundaries. This is true in all cases I've ever heard\n of (and [of_date_ofday_precise] would need revisiting if it turned out to be\n false) *)\n match Ofday.sub ofday amount with\n | Some ofday -> `Also_skipped (date, ofday)\n | None ->\n raise_s\n [%message\n \"Time.to_date_ofday_precise\"\n ~span_since_epoch:(to_span_since_epoch time : Span.t)\n (zone : Zone.t)]\n in\n let ambiguity =\n (* Edge cases: the instant of transition belongs to the new zone regime. So if the\n clock moved by an hour exactly one hour ago, there's no ambiguity, because the\n hour-ago time belongs to the same regime as you, and conversely, if the clock\n will move by an hour in an hours' time, there *is* ambiguity. Hence [>.] for\n the first case and [<=.] for the second. *)\n match clock_shift_before_or_at, clock_shift_after with\n | Some (start, amount), _ when add start (Span.abs amount) >. time ->\n (* clock shifted recently *)\n if Span.(amount > zero)\n then\n (* clock shifted forward recently: we skipped a time *)\n also_skipped_earlier amount\n else (\n (* clock shifted back recently: this date/ofday already happened *)\n assert (Span.(amount < zero));\n `Also_at (sub time (Span.abs amount)))\n | _, Some (start, amount) when sub start (Span.abs amount) <=. time ->\n (* clock is about to shift *)\n if Span.(amount > zero)\n then (* clock about to shift forward: no effect *)\n `Only\n else (\n (* clock about to shift back: this date/ofday will be repeated *)\n assert (Span.(amount < zero));\n `Also_at (add time (Span.abs amount)))\n | _ -> `Only\n in\n date, ofday, ambiguity\n ;;\n\n let convert ~from_tz ~to_tz date ofday =\n let start_time = of_date_ofday ~zone:from_tz date ofday in\n to_date_ofday ~zone:to_tz start_time\n ;;\n\n let utc_offset t ~zone =\n let utc_epoch = Zone.date_and_ofday_of_absolute_time zone t in\n Span.( - )\n (Date_and_ofday.to_synthetic_span_since_epoch utc_epoch)\n (to_span_since_epoch t)\n ;;\n\n let offset_string time ~zone =\n let utc_offset = utc_offset time ~zone in\n let is_utc = Span.( = ) utc_offset Span.zero in\n if is_utc\n then \"Z\"\n else\n String.concat\n [ (if Span.( < ) utc_offset Span.zero then \"-\" else \"+\")\n ; Ofday.to_string_trimmed\n (Ofday.of_span_since_start_of_day_exn (Span.abs utc_offset))\n ]\n ;;\n\n let to_string_abs_parts time ~zone =\n let date, ofday = to_date_ofday time ~zone in\n let offset_string = offset_string time ~zone in\n [ Date0.to_string date\n ; String.concat ~sep:\"\" [ Ofday.to_string ofday; offset_string ]\n ]\n ;;\n\n let to_string_abs_trimmed time ~zone =\n let date, ofday = to_date_ofday time ~zone in\n let offset_string = offset_string time ~zone in\n String.concat\n ~sep:\" \"\n [ Date0.to_string date; Ofday.to_string_trimmed ofday ^ offset_string ]\n ;;\n\n let to_string_abs time ~zone = String.concat ~sep:\" \" (to_string_abs_parts ~zone time)\n let to_string t = to_string_abs t ~zone:Zone.utc\n\n let to_string_iso8601_basic time ~zone =\n String.concat ~sep:\"T\" (to_string_abs_parts ~zone time)\n ;;\n\n let to_string_trimmed t ~zone =\n let date, sec = to_date_ofday ~zone t in\n Date0.to_string date ^ \" \" ^ Ofday.to_string_trimmed sec\n ;;\n\n let to_sec_string t ~zone =\n let date, sec = to_date_ofday ~zone t in\n Date0.to_string date ^ \" \" ^ Ofday.to_sec_string sec\n ;;\n\n let to_filename_string t ~zone =\n let date, ofday = to_date_ofday ~zone t in\n Date0.to_string date\n ^ \"_\"\n ^ String.tr ~target:':' ~replacement:'-' (Ofday.to_string ofday)\n ;;\n\n let of_filename_string s ~zone =\n try\n match String.lsplit2 s ~on:'_' with\n | None -> failwith \"no space in filename string\"\n | Some (date, ofday) ->\n let date = Date0.of_string date in\n let ofday = String.tr ~target:'-' ~replacement:':' ofday in\n let ofday = Ofday.of_string ofday in\n of_date_ofday date ofday ~zone\n with\n | exn -> invalid_argf \"Time.of_filename_string (%s): %s\" s (Exn.to_string exn) ()\n ;;\n\n let of_localized_string ~zone str =\n try\n match String.lsplit2 str ~on:' ' with\n | None -> invalid_arg (sprintf \"no space in date_ofday string: %s\" str)\n | Some (date, time) ->\n let date = Date0.of_string date in\n let ofday = Ofday.of_string time in\n of_date_ofday ~zone date ofday\n with\n | e -> Exn.reraise e \"Time.of_localized_string\"\n ;;\n\n let occurrence before_or_after t ~ofday ~zone =\n let first_guess_date = to_date t ~zone in\n let first_guess = of_date_ofday ~zone first_guess_date ofday in\n let cmp, increment =\n match before_or_after with\n | `Last_before_or_at -> ( <= ), -1\n | `First_after_or_at -> ( >= ), 1\n in\n if cmp first_guess t\n then first_guess\n else of_date_ofday ~zone (Date0.add_days first_guess_date increment) ofday\n ;;\n\n let ensure_colon_in_offset offset =\n let offset_length = String.length offset in\n if Int.( <= ) offset_length 2\n && Char.is_digit offset.[0]\n && Char.is_digit offset.[offset_length - 1]\n then offset ^ \":00\"\n else if Char.( = ) offset.[1] ':' || Char.( = ) offset.[2] ':'\n then offset\n else if Int.( < ) offset_length 3 || Int.( > ) offset_length 4\n then failwithf \"invalid offset %s\" offset ()\n else\n String.concat\n [ String.slice offset 0 (offset_length - 2)\n ; \":\"\n ; String.slice offset (offset_length - 2) offset_length\n ]\n ;;\n\n exception Time_of_string of string * Exn.t [@@deriving sexp]\n\n let of_string_gen ~default_zone ~find_zone s =\n try\n let date, ofday, tz =\n match String.split s ~on:' ' with\n | [ day; month; year; ofday ] ->\n String.concat [ day; \" \"; month; \" \"; year ], ofday, None\n | [ date; ofday; tz ] -> date, ofday, Some tz\n | [ date; ofday ] -> date, ofday, None\n | [ s ] ->\n (match String.rsplit2 ~on:'T' s with\n | Some (date, ofday) -> date, ofday, None\n | None -> failwith \"no spaces or T found\")\n | _ -> failwith \"too many spaces\"\n in\n let ofday_to_sec od = Span.to_sec (Ofday.to_span_since_start_of_day od) in\n let ofday, utc_offset =\n match tz with\n | Some _ -> ofday, None\n | None ->\n if Char.( = ) ofday.[String.length ofday - 1] 'Z'\n then String.sub ofday ~pos:0 ~len:(String.length ofday - 1), Some 0.\n else (\n match String.lsplit2 ~on:'+' ofday with\n | Some (l, r) ->\n l, Some (ofday_to_sec (Ofday.of_string (ensure_colon_in_offset r)))\n | None ->\n (match String.lsplit2 ~on:'-' ofday with\n | Some (l, r) ->\n l, Some (-1. *. ofday_to_sec (Ofday.of_string (ensure_colon_in_offset r)))\n | None -> ofday, None))\n in\n let date = Date0.of_string date in\n let ofday = Ofday.of_string ofday in\n match tz with\n | Some tz -> of_date_ofday ~zone:(find_zone tz) date ofday\n | None ->\n (match utc_offset with\n | None ->\n let zone = default_zone () in\n of_date_ofday ~zone date ofday\n | Some utc_offset ->\n let utc_t = of_date_ofday ~zone:Zone.utc date ofday in\n sub utc_t (Span.of_sec utc_offset))\n with\n | e -> raise (Time_of_string (s, e))\n ;;\n\n let of_string s =\n let default_zone () = raise_s [%message \"time has no time zone or UTC offset\" s] in\n let find_zone zone_name =\n failwithf \"unable to lookup Zone %s. Try using Core.Time.of_string\" zone_name ()\n in\n of_string_gen ~default_zone ~find_zone s\n ;;\n\n let quickcheck_shrinker =\n Quickcheck.Shrinker.map\n Span.quickcheck_shrinker\n ~f:of_span_since_epoch\n ~f_inverse:to_span_since_epoch\n ;;\n\n let quickcheck_observer =\n Quickcheck.Observer.unmap Span.quickcheck_observer ~f:to_span_since_epoch\n ;;\n\n let quickcheck_generator =\n Quickcheck.Generator.map Span.quickcheck_generator ~f:of_span_since_epoch\n ;;\n\n let gen_incl lo hi =\n Span.gen_incl (to_span_since_epoch lo) (to_span_since_epoch hi)\n |> Quickcheck.Generator.map ~f:of_span_since_epoch\n ;;\n\n let gen_uniform_incl lo hi =\n Span.gen_uniform_incl (to_span_since_epoch lo) (to_span_since_epoch hi)\n |> Quickcheck.Generator.map ~f:of_span_since_epoch\n ;;\nend\n","open! Import\nopen Std_internal\nopen! Int.Replace_polymorphic_compare\nmodule Span = Span_float\nmodule Ofday = Ofday_float\n\nmodule Absolute = struct\n type underlying = Float.t\n\n include (\n Float :\n sig\n type t = float [@@deriving bin_io, hash, typerep]\n\n include Comparable.S_common with type t := t\n\n include module type of struct\n include Float.O\n end\n end)\n\n (* due to precision limitations in float we can't expect better than microsecond\n precision *)\n include Float.Robust_compare.Make (struct\n let robust_comparison_tolerance = 1E-6\n end)\n\n let diff t1 t2 = Span.of_sec (t1 - t2)\n let add t span = t +. Span.to_sec span\n let sub t span = t -. Span.to_sec span\n let prev t = Float.one_ulp `Down t\n let next t = Float.one_ulp `Up t\n let to_span_since_epoch = Span.of_sec\n let of_span_since_epoch = Span.to_sec\nend\n\ninclude Absolute\n\nmodule Date_and_ofday = struct\n type t = float\n\n let of_synthetic_span_since_epoch span = Span.to_sec span\n let to_synthetic_span_since_epoch t = Span.of_sec t\n\n let of_date_ofday date ofday =\n let days =\n Float.of_int (Date0.Days.diff (Date0.Days.of_date date) Date0.Days.unix_epoch)\n in\n (days *. 86400.) +. Span.to_sec (Ofday.to_span_since_start_of_day ofday)\n ;;\n\n let to_absolute relative ~offset_from_utc = sub relative offset_from_utc\n let of_absolute absolute ~offset_from_utc = add absolute offset_from_utc\n\n (* Years out of range for [Date.create_exn]. *)\n let[@cold] assert_in_bounds ~sec_since_epoch =\n (* $ TZ=UTC date --date=@-62167219200\n Sat Jan 1 00:00:00 UTC 0000 *)\n let gmtime_lower_bound = -62_167_219_200. in\n (* $ TZ=UTC date --date=@253402300799\n Fri Dec 31 23:59:59 UTC 9999 *)\n let gmtime_upper_bound = 253_402_300_799. in\n if Float.( >= ) sec_since_epoch (gmtime_upper_bound +. 1.)\n || Float.( < ) sec_since_epoch gmtime_lower_bound\n then failwithf \"Time.gmtime: out of range (%f)\" sec_since_epoch ()\n ;;\n\n let sec_per_day = Int63.of_int 86_400\n\n let to_days_from_epoch t =\n assert_in_bounds ~sec_since_epoch:t;\n let open Int63.O in\n let days_from_epoch_approx = Int63.of_float t / sec_per_day in\n (* when [t] is negative the integer division that calculated days_from_epoch_approx\n will leave us one day short because it truncates (e.g. -100 / 86_400 = 0 and we\n want -1) -- adjust for that here. *)\n if Float.( < ) t (Int63.to_float (days_from_epoch_approx * sec_per_day))\n then Int63.pred days_from_epoch_approx\n else days_from_epoch_approx\n ;;\n\n let ofday_of_days_from_epoch t ~days_from_epoch =\n let open Int63.O in\n let days_from_epoch_in_sec = Int63.to_float (days_from_epoch * sec_per_day) in\n let remainder = t -. days_from_epoch_in_sec in\n Span.of_sec remainder |> Ofday.of_span_since_start_of_day_exn\n ;;\n\n let date_of_days_from_epoch ~days_from_epoch =\n Int63.to_int_exn days_from_epoch\n |> Date0.Days.add_days Date0.Days.unix_epoch\n |> Date0.Days.to_date\n ;;\n\n let to_date t =\n let days_from_epoch = to_days_from_epoch t in\n date_of_days_from_epoch ~days_from_epoch\n ;;\n\n let to_ofday t =\n let days_from_epoch = to_days_from_epoch t in\n ofday_of_days_from_epoch t ~days_from_epoch\n ;;\n\n let to_date_ofday t =\n let days_from_epoch = to_days_from_epoch t in\n let date = date_of_days_from_epoch ~days_from_epoch in\n let ofday = ofday_of_days_from_epoch t ~days_from_epoch in\n date, ofday\n ;;\nend\n\nlet next_multiple_internal ~can_equal_after ~base ~after ~interval =\n if Span.( <= ) interval Span.zero\n then\n failwiths\n ~here:[%here]\n \"Time.next_multiple got nonpositive interval\"\n interval\n [%sexp_of: Span.t];\n let base_to_after = diff after base in\n if Span.( < ) base_to_after Span.zero\n then base (* [after < base], choose [k = 0]. *)\n else (\n let next =\n add\n base\n (Span.scale\n interval\n (Float.round ~dir:`Down (Span.( // ) base_to_after interval)))\n in\n if next > after || (can_equal_after && next = after) then next else add next interval)\n;;\n\nlet next_multiple ?(can_equal_after = false) ~base ~after ~interval () =\n next_multiple_internal ~can_equal_after ~base ~after ~interval\n;;\n\nlet prev_multiple ?(can_equal_before = false) ~base ~before ~interval () =\n next_multiple_internal\n ~can_equal_after:(not can_equal_before)\n ~base\n ~after:(sub before interval)\n ~interval\n;;\n\nlet now () =\n let float_ns = Time_now.nanoseconds_since_unix_epoch () |> Int63.to_float in\n of_span_since_epoch (Span.of_sec (float_ns *. 1E-9))\n;;\n\nmodule Stable = struct\n module Span = Span.Stable\n module Ofday = Ofday.Stable\nend\n","open! Import\nopen! Std_internal\n\nmodule type S_kernel_without_zone = Time0_intf.S\nmodule type S_kernel = Time_intf.S\n\nmodule Zone_stable = Zone.Stable\ninclude Time.Make (Time_float0)\ninclude Time_float0\n\nmodule Stable = struct\n include Time_float0.Stable\n\n module With_utc_sexp = struct\n (* V2 is actually the first version of this in Core_kernel, but a V1 stable module\n with generous parsing, unix-dependent [t_of_sexp] already existed in Core *)\n module V2 = struct\n type nonrec t = t [@@deriving bin_io, compare, hash]\n\n let sexp_of_t t = [%sexp (to_string_abs_parts t ~zone:Zone.utc : string list)]\n\n let t_of_sexp sexp =\n try\n match sexp with\n | Sexp.List [ Sexp.Atom date; Sexp.Atom ofday_and_possibly_zone ] ->\n of_string_gen\n ~default_zone:(fun () -> Zone.utc)\n ~find_zone:(fun _ ->\n of_sexp_error \"Time.Stable.With_utc.V2.t_of_sexp: unknown time zone\" sexp)\n (date ^ \" \" ^ ofday_and_possibly_zone)\n | _ -> of_sexp_error \"Time.Stable.With_utc.V2.t_of_sexp\" sexp\n with\n | Of_sexp_error _ as e -> raise e\n | e ->\n of_sexp_error\n (sprintf \"Time.Stable.With_utc.V2.t_of_sexp: %s\" (Exn.to_string e))\n sexp\n ;;\n end\n end\n\n module Zone = Zone_stable\nend\n","open! Import\nopen Std_internal\n\nlet arch_sixtyfour = Sys.word_size = 64\n\nmodule Span = Span_ns\nmodule Ofday = Ofday_ns\n\ntype t = Span.t (* since the Unix epoch (1970-01-01 00:00:00 UTC) *)\n[@@deriving bin_io, compare, hash, typerep]\n\ninclude (Span : Comparable.Infix with type t := t)\ninclude (Span : Quickcheck.S_range with type t := t)\n\nlet now = Span.since_unix_epoch\nlet equal = Span.equal\nlet min_value_for_1us_rounding = Span.min_value_for_1us_rounding\nlet max_value_for_1us_rounding = Span.max_value_for_1us_rounding\nlet epoch = Span.zero\nlet add = Span.( + )\nlet sub = Span.( - )\nlet diff = Span.( - )\nlet abs_diff t u = Span.abs (diff t u)\nlet max = Span.max\nlet min = Span.min\nlet next = Span.next\nlet prev = Span.prev\nlet to_span_since_epoch t = t\nlet of_span_since_epoch s = s\nlet to_int63_ns_since_epoch t : Int63.t = Span.to_int63_ns (to_span_since_epoch t)\nlet of_int63_ns_since_epoch i = of_span_since_epoch (Span.of_int63_ns i)\nlet[@cold] overflow () = raise_s [%message \"Time_ns: overflow\"]\nlet is_earlier t1 ~than:t2 = t1 < t2\nlet is_later t1 ~than:t2 = t1 > t2\n\nlet add_overflowed x y ~sum =\n if Span.( > ) y Span.zero then Span.( < ) sum x else Span.( > ) sum x\n;;\n\nlet sub_overflowed x y ~diff =\n if Span.( > ) y Span.zero then Span.( > ) diff x else Span.( < ) diff x\n;;\n\nlet add_exn x y =\n let sum = add x y in\n if add_overflowed x y ~sum then overflow () else sum\n;;\n\nlet sub_exn x y =\n let diff = sub x y in\n if sub_overflowed x y ~diff then overflow () else diff\n;;\n\nlet add_saturating x y =\n let sum = add x y in\n if add_overflowed x y ~sum\n then\n if Span.(y > zero)\n then Span.max_value_representable\n else Span.min_value_representable\n else sum\n;;\n\nlet sub_saturating x y =\n let diff = sub x y in\n if sub_overflowed x y ~diff\n then\n if Span.(y > zero)\n then Span.min_value_representable\n else Span.max_value_representable\n else diff\n;;\n\nlet to_int_ns_since_epoch =\n if arch_sixtyfour\n then fun t -> Int63.to_int_exn (to_int63_ns_since_epoch t)\n else fun _ -> failwith \"Time_ns.to_int_ns_since_epoch: unsupported on 32bit machines\"\n;;\n\nlet of_int_ns_since_epoch i = of_int63_ns_since_epoch (Int63.of_int i)\n\nlet to_time_float_round_nearest t =\n Time_float.of_span_since_epoch\n (Span.to_span_float_round_nearest (to_span_since_epoch t))\n;;\n\nlet to_time_float_round_nearest_microsecond t =\n Time_float.of_span_since_epoch\n (Span.to_span_float_round_nearest_microsecond (to_span_since_epoch t))\n;;\n\nlet min_time_value_for_1us_rounding =\n to_time_float_round_nearest min_value_for_1us_rounding\n;;\n\nlet max_time_value_for_1us_rounding =\n to_time_float_round_nearest max_value_for_1us_rounding\n;;\n\nlet check_before_conversion_for_1us_rounding time =\n if Time_float.( < ) time min_time_value_for_1us_rounding\n || Time_float.( > ) time max_time_value_for_1us_rounding\n then\n failwiths\n ~here:[%here]\n \"Time_ns does not support this time\"\n time\n [%sexp_of: Time_float.Stable.With_utc_sexp.V2.t]\n;;\n\nlet of_time_float_round_nearest time =\n of_span_since_epoch\n (Span.of_span_float_round_nearest (Time_float.to_span_since_epoch time))\n;;\n\nlet of_time_float_round_nearest_microsecond time =\n check_before_conversion_for_1us_rounding time;\n of_span_since_epoch\n (Span.of_span_float_round_nearest_microsecond (Time_float.to_span_since_epoch time))\n;;\n\nlet[@cold] raise_next_multiple_got_nonpositive_interval interval =\n failwiths\n ~here:[%here]\n \"Time_ns.next_multiple got nonpositive interval\"\n interval\n [%sexp_of: Span.t]\n;;\n\nlet next_multiple_internal ~can_equal_after ~base ~after ~interval =\n if Span.( <= ) interval Span.zero\n then raise_next_multiple_got_nonpositive_interval interval;\n let base_to_after = diff after base in\n if Span.( < ) base_to_after Span.zero\n then base (* [after < base], choose [k = 0]. *)\n else (\n let next = add base (Span.scale_int63 interval (Span.div base_to_after interval)) in\n if next > after || (can_equal_after && next = after) then next else add next interval)\n;;\n\nlet next_multiple ?(can_equal_after = false) ~base ~after ~interval () =\n next_multiple_internal ~can_equal_after ~base ~after ~interval\n;;\n\nlet prev_multiple ?(can_equal_before = false) ~base ~before ~interval () =\n next_multiple_internal\n ~can_equal_after:(not can_equal_before)\n ~base\n ~after:(sub before interval)\n ~interval\n;;\n\nlet random ?state () = Span.random ?state ()\n\nmodule Utc : sig\n val to_date_and_span_since_start_of_day : t -> Date0.t * Span.t\n val of_date_and_span_since_start_of_day : Date0.t -> Span.t -> t\nend = struct\n (* a recreation of the system call gmtime specialized to the fields we need that also\n doesn't rely on Unix. *)\n let to_date_and_span_since_start_of_day t =\n let open Int63.O in\n let ( !< ) i = Int63.of_int_exn i in\n let ( !> ) t = Int63.to_int_exn t in\n let ns_since_epoch = to_int63_ns_since_epoch t in\n let ns_per_day = !<86_400 * !<1_000_000_000 in\n let approx_days_from_epoch = ns_since_epoch / ns_per_day in\n let days_from_epoch =\n if ns_since_epoch < !<0 && approx_days_from_epoch * ns_per_day <> ns_since_epoch\n then approx_days_from_epoch - !<1\n else approx_days_from_epoch\n in\n let ns_since_start_of_day = ns_since_epoch - (ns_per_day * days_from_epoch) in\n let date =\n Date0.Days.add_days Date0.Days.unix_epoch !>days_from_epoch |> Date0.Days.to_date\n in\n let span_since_start_of_day = Span.of_int63_ns ns_since_start_of_day in\n date, span_since_start_of_day\n ;;\n\n let of_date_and_span_since_start_of_day date span_since_start_of_day =\n assert (\n Span.( >= ) span_since_start_of_day Span.zero\n && Span.( < ) span_since_start_of_day Span.day);\n let days_from_epoch =\n Date0.Days.diff (Date0.Days.of_date date) Date0.Days.unix_epoch\n in\n let span_in_days_since_epoch = Span.scale_int Span.day days_from_epoch in\n let span_since_epoch = Span.( + ) span_in_days_since_epoch span_since_start_of_day in\n of_span_since_epoch span_since_epoch\n ;;\nend\n\nmodule Alternate_sexp = struct\n type nonrec t = t\n\n module Ofday_as_span = struct\n open Int.O\n\n let seconds_to_string seconds_span =\n let seconds = Span.to_int_sec seconds_span in\n let h = seconds / 3600 in\n let m = seconds / 60 % 60 in\n let s = seconds % 60 in\n sprintf \"%02d:%02d:%02d\" h m s\n ;;\n\n let two_digit_of_string string =\n assert (String.length string = 2 && String.for_all string ~f:Char.is_digit);\n Int.of_string string\n ;;\n\n let seconds_of_string seconds_string =\n match String.split seconds_string ~on:':' with\n | [ h_string; m_string; s_string ] ->\n let h = two_digit_of_string h_string in\n let m = two_digit_of_string m_string in\n let s = two_digit_of_string s_string in\n Span.of_int_sec ((((h * 60) + m) * 60) + s)\n | _ -> assert false\n ;;\n\n let ns_of_100_ms = 100_000_000\n let ns_of_10_ms = 10_000_000\n let ns_of_1_ms = 1_000_000\n let ns_of_100_us = 100_000\n let ns_of_10_us = 10_000\n let ns_of_1_us = 1_000\n let ns_of_100_ns = 100\n let ns_of_10_ns = 10\n let ns_of_1_ns = 1\n\n let sub_second_to_string sub_second_span =\n let open Int.O in\n let ns = Span.to_int63_ns sub_second_span |> Int63.to_int_exn in\n if ns = 0\n then \"\"\n else if ns % ns_of_100_ms = 0\n then sprintf \".%01d\" (ns / ns_of_100_ms)\n else if ns % ns_of_10_ms = 0\n then sprintf \".%02d\" (ns / ns_of_10_ms)\n else if ns % ns_of_1_ms = 0\n then sprintf \".%03d\" (ns / ns_of_1_ms)\n else if ns % ns_of_100_us = 0\n then sprintf \".%04d\" (ns / ns_of_100_us)\n else if ns % ns_of_10_us = 0\n then sprintf \".%05d\" (ns / ns_of_10_us)\n else if ns % ns_of_1_us = 0\n then sprintf \".%06d\" (ns / ns_of_1_us)\n else if ns % ns_of_100_ns = 0\n then sprintf \".%07d\" (ns / ns_of_100_ns)\n else if ns % ns_of_10_ns = 0\n then sprintf \".%08d\" (ns / ns_of_10_ns)\n else sprintf \".%09d\" ns\n ;;\n\n let sub_second_of_string string =\n if String.is_empty string\n then Span.zero\n else (\n let digits = String.chop_prefix_exn string ~prefix:\".\" in\n assert (String.for_all digits ~f:Char.is_digit);\n let multiplier =\n match String.length digits with\n | 1 -> ns_of_100_ms\n | 2 -> ns_of_10_ms\n | 3 -> ns_of_1_ms\n | 4 -> ns_of_100_us\n | 5 -> ns_of_10_us\n | 6 -> ns_of_1_us\n | 7 -> ns_of_100_ns\n | 8 -> ns_of_10_ns\n | 9 -> ns_of_1_ns\n | _ -> assert false\n in\n Span.of_int63_ns (Int63.of_int (Int.of_string digits * multiplier)))\n ;;\n\n let to_string span =\n assert (Span.( >= ) span Span.zero && Span.( < ) span Span.day);\n let seconds_span = span |> Span.to_int_sec |> Span.of_int_sec in\n let sub_second_span = Span.( - ) span seconds_span in\n seconds_to_string seconds_span ^ sub_second_to_string sub_second_span\n ;;\n\n let of_string string =\n let len = String.length string in\n let prefix_len = 8 in\n (* \"HH:MM:DD\" *)\n let suffix_len = len - prefix_len in\n let seconds_string = String.sub string ~pos:0 ~len:prefix_len in\n let sub_second_string = String.sub string ~pos:prefix_len ~len:suffix_len in\n let seconds_span = seconds_of_string seconds_string in\n let sub_second_span = sub_second_of_string sub_second_string in\n Span.( + ) seconds_span sub_second_span\n ;;\n end\n\n let to_string t =\n let date, span_since_start_of_day = Utc.to_date_and_span_since_start_of_day t in\n Date0.to_string date ^ \" \" ^ Ofday_as_span.to_string span_since_start_of_day ^ \"Z\"\n ;;\n\n let of_string string =\n let date_string, ofday_string_with_zone = String.lsplit2_exn string ~on:' ' in\n let ofday_string = String.chop_suffix_exn ofday_string_with_zone ~suffix:\"Z\" in\n let date = Date0.of_string date_string in\n let ofday = Ofday_as_span.of_string ofday_string in\n Utc.of_date_and_span_since_start_of_day date ofday\n ;;\n\n include Sexpable.Of_stringable (struct\n type nonrec t = t\n\n let to_string = to_string\n let of_string = of_string\n end)\n\n module Stable = struct\n module V1 = struct\n (* see tests in lib/core_kernel/test/test_time_ns that ensure stability of this\n representation *)\n type nonrec t = t [@@deriving bin_io, compare, sexp]\n end\n end\nend\n\nmodule Stable = struct\n module Alternate_sexp = Alternate_sexp.Stable\n module Span = Span.Stable\n module Ofday = Ofday.Stable\nend\n\n(* this code is directly duplicated from Time.ml functor, converted enough to get Time_ns\n to/of_string working *)\nmodule To_and_of_string : sig\n val of_date_ofday : zone:Zone.t -> Date.t -> Ofday.t -> t\n\n val of_date_ofday_precise\n : Date.t\n -> Ofday.t\n -> zone:Zone.t\n -> [ `Once of t | `Twice of t * t | `Never of t ]\n\n val to_date_ofday : t -> zone:Zone.t -> Date.t * Ofday.t\n\n val to_date_ofday_precise\n : t\n -> zone:Zone.t\n -> Date.t * Ofday.t * [ `Only | `Also_at of t | `Also_skipped of Date.t * Ofday.t ]\n\n val to_date : t -> zone:Zone.t -> Date.t\n val to_ofday : t -> zone:Zone.t -> Ofday.t\n val convert : from_tz:Zone.t -> to_tz:Zone.t -> Date.t -> Ofday.t -> Date.t * Ofday.t\n val reset_date_cache : unit -> unit\n val utc_offset : t -> zone:Zone.t -> Span.t\n\n include Stringable with type t := t\n\n val to_filename_string : t -> zone:Zone.t -> string\n val of_filename_string : string -> zone:Zone.t -> t\n val to_string_trimmed : t -> zone:Zone.t -> string\n val to_sec_string : t -> zone:Zone.t -> string\n val of_localized_string : zone:Zone.t -> string -> t\n\n val of_string_gen\n : default_zone:(unit -> Zone.t)\n -> find_zone:(string -> Zone.t)\n -> string\n -> t\n\n val to_string_abs : t -> zone:Zone.t -> string\n val to_string_abs_trimmed : t -> zone:Zone.t -> string\n val to_string_abs_parts : t -> zone:Zone.t -> string list\n val to_string_iso8601_basic : t -> zone:Zone.t -> string\n\n val occurrence\n : [ `First_after_or_at | `Last_before_or_at ]\n -> t\n -> ofday:Ofday.t\n -> zone:Zone.t\n -> t\nend = struct\n (* this code is directly duplicated from Time_float0.ml, converted enough to get\n Time_ns to/of_string working *)\n module Date_and_ofday = struct\n type t = Int63.t\n\n let to_synthetic_span_since_epoch t = Span.of_int63_ns t\n\n let of_date_ofday date ofday =\n let days =\n Date0.Days.diff (Date0.Days.of_date date) Date0.Days.unix_epoch |> Int63.of_int\n in\n let open Int63.O in\n (days * Span.to_int63_ns Span.day)\n + Span.to_int63_ns (Ofday.to_span_since_start_of_day ofday)\n ;;\n\n let to_absolute relative ~offset_from_utc =\n sub_exn (Span.of_int63_ns relative) offset_from_utc\n ;;\n\n let of_absolute absolute ~offset_from_utc =\n Span.to_int63_ns (add_exn absolute offset_from_utc)\n ;;\n\n let ns_per_day = Span.to_int63_ns Span.day\n\n let to_days_from_epoch t =\n (* note Time_ns represents about 146 years, not enough for [Date.create_exn] to ever\n raise *)\n let open Int63.O in\n let days_from_epoch_approx = t / ns_per_day in\n (* when [t] is negative the integer division that calculated days_from_epoch_approx\n will leave us one day short because it truncates (e.g. -100 / 86_400 = 0 and we\n want -1) -- adjust for that here. *)\n if t < days_from_epoch_approx * ns_per_day\n then Int63.pred days_from_epoch_approx\n else days_from_epoch_approx\n ;;\n\n let ofday_of_days_from_epoch t ~days_from_epoch =\n let open Int63.O in\n let days_from_epoch_in_ns = days_from_epoch * ns_per_day in\n let remainder = t - days_from_epoch_in_ns in\n Span.of_int63_ns remainder |> Ofday.of_span_since_start_of_day_exn\n ;;\n\n let date_of_days_from_epoch ~days_from_epoch =\n Int63.to_int_exn days_from_epoch\n |> Date0.Days.add_days Date0.Days.unix_epoch\n |> Date0.Days.to_date\n ;;\n\n let to_date t =\n let days_from_epoch = to_days_from_epoch t in\n date_of_days_from_epoch ~days_from_epoch\n ;;\n\n let to_ofday t =\n let days_from_epoch = to_days_from_epoch t in\n ofday_of_days_from_epoch t ~days_from_epoch\n ;;\n end\n\n module Zone0 = Zone\n\n module Zone : sig\n (* This interface is directly duplicated from Time_intf.Zone, converted enough to get\n this to work.\n\n The problem is has references to Time0_intf.S, which is the functor input interface\n that Time_ns currently does not satisfy. *)\n\n type time = t\n type t = Zone.t [@@deriving sexp_of]\n\n module Index = Zone.Index\n\n (* copied functions reexported from Zone *)\n\n val utc : t\n val index_has_prev_clock_shift : t -> Index.t -> bool\n val index_has_next_clock_shift : t -> Index.t -> bool\n\n (* new functions defined below *)\n\n val index : t -> time -> Index.t\n val index_offset_from_utc_exn : t -> Index.t -> time\n val index_prev_clock_shift_time_exn : t -> Index.t -> time\n val index_next_clock_shift_time_exn : t -> Index.t -> time\n val absolute_time_of_date_and_ofday : t -> Date_and_ofday.t -> time\n val date_and_ofday_of_absolute_time : t -> time -> Date_and_ofday.t\n val next_clock_shift : t -> strictly_after:time -> (time * Span.t) option\n val prev_clock_shift : t -> at_or_before:time -> (time * Span.t) option\n end = struct\n type time = t\n\n include Zone\n\n let of_span_in_seconds span_in_seconds =\n (* NB. no actual rounding or exns can occur here *)\n Time_in_seconds.Span.to_int63_seconds_round_down_exn span_in_seconds\n |> Span.of_int63_seconds\n ;;\n\n let of_time_in_seconds time_in_seconds =\n Time_in_seconds.to_span_since_epoch time_in_seconds\n (* NB. no actual rounding or exns can occur here *)\n |> Time_in_seconds.Span.to_int63_seconds_round_down_exn\n |> Span.of_int63_seconds\n |> of_span_since_epoch\n ;;\n\n let to_time_in_seconds_round_down_exn time =\n to_span_since_epoch time\n |> Span.to_int63_seconds_round_down_exn\n |> Time_in_seconds.Span.of_int63_seconds\n |> Time_in_seconds.of_span_since_epoch\n ;;\n\n let to_date_and_ofday_in_seconds_round_down_exn relative =\n Date_and_ofday.to_synthetic_span_since_epoch relative\n |> Span.to_int63_seconds_round_down_exn\n |> Time_in_seconds.Span.of_int63_seconds\n |> Time_in_seconds.Date_and_ofday.of_synthetic_span_since_epoch\n ;;\n\n let index t time = index t (to_time_in_seconds_round_down_exn time)\n\n let index_of_date_and_ofday t relative =\n index_of_date_and_ofday t (to_date_and_ofday_in_seconds_round_down_exn relative)\n ;;\n\n let index_offset_from_utc_exn t index =\n of_span_in_seconds (index_offset_from_utc_exn t index)\n ;;\n\n let index_prev_clock_shift_time_exn t index =\n of_time_in_seconds (index_prev_clock_shift_time_exn t index)\n ;;\n\n let index_next_clock_shift_time_exn t index =\n of_time_in_seconds (index_next_clock_shift_time_exn t index)\n ;;\n\n let index_prev_clock_shift_amount_exn t index =\n of_span_in_seconds (index_prev_clock_shift_amount_exn t index)\n ;;\n\n let index_prev_clock_shift t index =\n match index_has_prev_clock_shift t index with\n | false -> None\n | true ->\n Some\n ( index_prev_clock_shift_time_exn t index\n , index_prev_clock_shift_amount_exn t index )\n ;;\n\n let index_next_clock_shift t index = index_prev_clock_shift t (Index.next index)\n let prev_clock_shift t ~at_or_before:time = index_prev_clock_shift t (index t time)\n let next_clock_shift t ~strictly_after:time = index_next_clock_shift t (index t time)\n\n let date_and_ofday_of_absolute_time t time =\n let index = index t time in\n (* no exn because [index] always returns a valid index *)\n let offset_from_utc = index_offset_from_utc_exn t index in\n Date_and_ofday.of_absolute time ~offset_from_utc\n ;;\n\n let absolute_time_of_date_and_ofday t relative =\n let index = index_of_date_and_ofday t relative in\n (* no exn because [index_of_date_and_ofday] always returns a valid index *)\n let offset_from_utc = index_offset_from_utc_exn t index in\n Date_and_ofday.to_absolute relative ~offset_from_utc\n ;;\n end\n\n let of_date_ofday ~zone date ofday =\n let relative = Date_and_ofday.of_date_ofday date ofday in\n Zone.absolute_time_of_date_and_ofday zone relative\n ;;\n\n let of_date_ofday_precise date ofday ~zone =\n (* We assume that there will be only one zone shift within a given local day. *)\n let start_of_day = of_date_ofday ~zone date Ofday.start_of_day in\n let proposed_time = add start_of_day (Ofday.to_span_since_start_of_day ofday) in\n match Zone.next_clock_shift zone ~strictly_after:start_of_day with\n | None -> `Once proposed_time\n | Some (shift_start, shift_amount) ->\n let shift_backwards = Span.(shift_amount < zero) in\n (* start and end of the \"problematic region\" *)\n let s, e =\n if shift_backwards\n then add shift_start shift_amount, shift_start\n else shift_start, add shift_start shift_amount\n in\n if proposed_time < s\n then `Once proposed_time\n else if s <= proposed_time && proposed_time < e\n then\n if shift_backwards\n then `Twice (proposed_time, sub proposed_time shift_amount)\n else `Never shift_start\n else `Once (sub proposed_time shift_amount)\n ;;\n\n module Date_cache = struct\n type nonrec t =\n { mutable zone : Zone.t\n ; mutable cache_start_incl : t\n ; mutable cache_until_excl : t\n ; mutable effective_day_start : t\n ; mutable date : Date0.t\n }\n end\n\n let date_cache : Date_cache.t =\n { zone = Zone.utc\n ; cache_start_incl = epoch\n ; cache_until_excl = epoch\n ; effective_day_start = epoch\n ; date = Date0.unix_epoch\n }\n ;;\n\n let reset_date_cache () =\n date_cache.zone <- Zone.utc;\n date_cache.cache_start_incl <- epoch;\n date_cache.cache_until_excl <- epoch;\n date_cache.effective_day_start <- epoch;\n date_cache.date <- Date0.unix_epoch\n ;;\n\n let is_in_cache time ~zone =\n phys_equal zone date_cache.zone\n && time >= date_cache.cache_start_incl\n && time < date_cache.cache_until_excl\n ;;\n\n let set_date_cache time ~zone =\n match is_in_cache time ~zone with\n | true -> ()\n | false ->\n let index = Zone.index zone time in\n (* no exn because [Zone.index] always returns a valid index *)\n let offset_from_utc = Zone.index_offset_from_utc_exn zone index in\n let rel = Date_and_ofday.of_absolute time ~offset_from_utc in\n let date = Date_and_ofday.to_date rel in\n let span = Date_and_ofday.to_ofday rel |> Ofday.to_span_since_start_of_day in\n let effective_day_start =\n sub (Date_and_ofday.to_absolute rel ~offset_from_utc) span\n in\n let effective_day_until = add effective_day_start Span.day in\n let cache_start_incl =\n match Zone.index_has_prev_clock_shift zone index with\n | false -> effective_day_start\n | true ->\n effective_day_start |> max (Zone.index_prev_clock_shift_time_exn zone index)\n in\n let cache_until_excl =\n match Zone.index_has_next_clock_shift zone index with\n | false -> effective_day_until\n | true ->\n effective_day_until |> min (Zone.index_next_clock_shift_time_exn zone index)\n in\n date_cache.zone <- zone;\n date_cache.cache_start_incl <- cache_start_incl;\n date_cache.cache_until_excl <- cache_until_excl;\n date_cache.effective_day_start <- effective_day_start;\n date_cache.date <- date\n ;;\n\n let to_date time ~zone =\n set_date_cache time ~zone;\n date_cache.date\n ;;\n\n let to_ofday time ~zone =\n set_date_cache time ~zone;\n diff time date_cache.effective_day_start |> Ofday.of_span_since_start_of_day_exn\n ;;\n\n let to_date_ofday time ~zone = to_date time ~zone, to_ofday time ~zone\n\n (* The correctness of this algorithm (interface, even) depends on the fact that\n timezone shifts aren't too close together (as in, it can't simultaneously be the\n case that a timezone shift of X hours occurred less than X hours ago, *and*\n a timezone shift of Y hours will occur in less than Y hours' time) *)\n let to_date_ofday_precise time ~zone =\n let date, ofday = to_date_ofday time ~zone in\n let clock_shift_after = Zone.next_clock_shift zone ~strictly_after:time in\n let clock_shift_before_or_at = Zone.prev_clock_shift zone ~at_or_before:time in\n let also_skipped_earlier amount =\n (* Using [date] and raising on [None] here is OK on the assumption that clock\n shifts can't cross date boundaries. This is true in all cases I've ever heard\n of (and [of_date_ofday_precise] would need revisiting if it turned out to be\n false) *)\n match Ofday.sub ofday amount with\n | Some ofday -> `Also_skipped (date, ofday)\n | None ->\n raise_s\n [%message\n \"Time.to_date_ofday_precise\"\n ~span_since_epoch:(to_span_since_epoch time : Span.t)\n (zone : Zone.t)]\n in\n let ambiguity =\n (* Edge cases: the instant of transition belongs to the new zone regime. So if the\n clock moved by an hour exactly one hour ago, there's no ambiguity, because the\n hour-ago time belongs to the same regime as you, and conversely, if the clock\n will move by an hour in an hours' time, there *is* ambiguity. Hence [>.] for\n the first case and [<=.] for the second. *)\n match clock_shift_before_or_at, clock_shift_after with\n | Some (start, amount), _ when add start (Span.abs amount) > time ->\n (* clock shifted recently *)\n if Span.(amount > zero)\n then\n (* clock shifted forward recently: we skipped a time *)\n also_skipped_earlier amount\n else (\n (* clock shifted back recently: this date/ofday already happened *)\n assert (Span.(amount < zero));\n `Also_at (sub time (Span.abs amount)))\n | _, Some (start, amount) when sub start (Span.abs amount) <= time ->\n (* clock is about to shift *)\n if Span.(amount > zero)\n then (* clock about to shift forward: no effect *)\n `Only\n else (\n (* clock about to shift back: this date/ofday will be repeated *)\n assert (Span.(amount < zero));\n `Also_at (add time (Span.abs amount)))\n | _ -> `Only\n in\n date, ofday, ambiguity\n ;;\n\n let convert ~from_tz ~to_tz date ofday =\n let start_time = of_date_ofday ~zone:from_tz date ofday in\n to_date_ofday ~zone:to_tz start_time\n ;;\n\n let utc_offset t ~zone =\n let utc_epoch = Zone.date_and_ofday_of_absolute_time zone t in\n Span.( - )\n (Date_and_ofday.to_synthetic_span_since_epoch utc_epoch)\n (to_span_since_epoch t)\n ;;\n\n let offset_string time ~zone =\n let utc_offset = utc_offset time ~zone in\n let is_utc = Span.( = ) utc_offset Span.zero in\n if is_utc\n then \"Z\"\n else\n String.concat\n [ (if Span.( < ) utc_offset Span.zero then \"-\" else \"+\")\n ; Ofday.to_string_trimmed\n (Ofday.of_span_since_start_of_day_exn (Span.abs utc_offset))\n ]\n ;;\n\n let to_string_abs_parts =\n let attempt time ~zone =\n let date, ofday = to_date_ofday time ~zone in\n let offset_string = offset_string time ~zone in\n [ Date0.to_string date\n ; String.concat ~sep:\"\" [ Ofday.to_string ofday; offset_string ]\n ]\n in\n fun time ~zone ->\n try attempt time ~zone with\n | (_ : exn) ->\n (* If we overflow applying the UTC offset, try again with UTC time. *)\n attempt time ~zone:Zone.utc\n ;;\n\n let to_string_abs_trimmed time ~zone =\n let date, ofday = to_date_ofday time ~zone in\n let offset_string = offset_string time ~zone in\n String.concat\n ~sep:\" \"\n [ Date0.to_string date; Ofday.to_string_trimmed ofday ^ offset_string ]\n ;;\n\n let to_string_abs time ~zone = String.concat ~sep:\" \" (to_string_abs_parts ~zone time)\n let to_string t = to_string_abs t ~zone:Zone.utc\n\n let to_string_iso8601_basic time ~zone =\n String.concat ~sep:\"T\" (to_string_abs_parts ~zone time)\n ;;\n\n let to_string_trimmed t ~zone =\n let date, sec = to_date_ofday ~zone t in\n Date0.to_string date ^ \" \" ^ Ofday.to_string_trimmed sec\n ;;\n\n let to_sec_string t ~zone =\n let date, sec = to_date_ofday ~zone t in\n Date0.to_string date ^ \" \" ^ Ofday.to_sec_string sec\n ;;\n\n let to_filename_string t ~zone =\n let date, ofday = to_date_ofday ~zone t in\n Date0.to_string date\n ^ \"_\"\n ^ String.tr\n ~target:':'\n ~replacement:'-'\n (String.drop_suffix (Ofday.to_string ofday) 3)\n ;;\n\n let of_filename_string s ~zone =\n try\n match String.lsplit2 s ~on:'_' with\n | None -> failwith \"no space in filename string\"\n | Some (date, ofday) ->\n let date = Date0.of_string date in\n let ofday = String.tr ~target:'-' ~replacement:':' ofday in\n let ofday = Ofday.of_string ofday in\n of_date_ofday date ofday ~zone\n with\n | exn -> invalid_argf \"Time.of_filename_string (%s): %s\" s (Exn.to_string exn) ()\n ;;\n\n let of_localized_string ~zone str =\n try\n match String.lsplit2 str ~on:' ' with\n | None -> invalid_arg (sprintf \"no space in date_ofday string: %s\" str)\n | Some (date, time) ->\n let date = Date0.of_string date in\n let ofday = Ofday.of_string time in\n of_date_ofday ~zone date ofday\n with\n | e -> Exn.reraise e \"Time.of_localized_string\"\n ;;\n\n let occurrence before_or_after t ~ofday ~zone =\n let first_guess_date = to_date t ~zone in\n let first_guess = of_date_ofday ~zone first_guess_date ofday in\n let cmp, increment =\n match before_or_after with\n | `Last_before_or_at -> ( <= ), -1\n | `First_after_or_at -> ( >= ), 1\n in\n if cmp first_guess t\n then first_guess\n else of_date_ofday ~zone (Date0.add_days first_guess_date increment) ofday\n ;;\n\n let ensure_colon_in_offset offset =\n let offset_length = String.length offset in\n if Int.( <= ) offset_length 2\n && Char.is_digit offset.[0]\n && Char.is_digit offset.[offset_length - 1]\n then offset ^ \":00\"\n else if Char.( = ) offset.[1] ':' || Char.( = ) offset.[2] ':'\n then offset\n else if Int.( < ) offset_length 3 || Int.( > ) offset_length 4\n then failwithf \"invalid offset %s\" offset ()\n else\n String.concat\n [ String.slice offset 0 (offset_length - 2)\n ; \":\"\n ; String.slice offset (offset_length - 2) offset_length\n ]\n ;;\n\n exception Time_ns_of_string of string * Exn.t [@@deriving sexp]\n\n let of_string_gen ~default_zone ~find_zone s =\n try\n let date, ofday, tz =\n match String.split s ~on:' ' with\n | [ day; month; year; ofday ] ->\n String.concat [ day; \" \"; month; \" \"; year ], ofday, None\n | [ date; ofday; tz ] -> date, ofday, Some tz\n | [ date; ofday ] -> date, ofday, None\n | [ s ] ->\n (match String.rsplit2 ~on:'T' s with\n | Some (date, ofday) -> date, ofday, None\n | None -> failwith \"no spaces or T found\")\n | _ -> failwith \"too many spaces\"\n in\n let ofday_to_sec od = Span.to_sec (Ofday.to_span_since_start_of_day od) in\n let ofday, utc_offset =\n match tz with\n | Some _ -> ofday, None\n | None ->\n if Char.( = ) ofday.[String.length ofday - 1] 'Z'\n then String.sub ofday ~pos:0 ~len:(String.length ofday - 1), Some 0.\n else (\n match String.lsplit2 ~on:'+' ofday with\n | Some (l, r) ->\n l, Some (ofday_to_sec (Ofday.of_string (ensure_colon_in_offset r)))\n | None ->\n (match String.lsplit2 ~on:'-' ofday with\n | Some (l, r) ->\n l, Some (-1. *. ofday_to_sec (Ofday.of_string (ensure_colon_in_offset r)))\n | None -> ofday, None))\n in\n let date = Date0.of_string date in\n let ofday = Ofday.of_string ofday in\n match tz with\n | Some tz -> of_date_ofday ~zone:(find_zone tz) date ofday\n | None ->\n (match utc_offset with\n | None ->\n let zone = default_zone () in\n of_date_ofday ~zone date ofday\n | Some utc_offset ->\n let utc_t = of_date_ofday ~zone:Zone.utc date ofday in\n sub utc_t (Span.of_sec utc_offset))\n with\n | e -> raise (Time_ns_of_string (s, e))\n ;;\n\n let of_string s =\n let default_zone () = raise_s [%message \"time has no time zone or UTC offset\" s] in\n let find_zone zone_name =\n failwithf \"unable to lookup Zone %s. Try using Core.Time.of_string\" zone_name ()\n in\n of_string_gen ~default_zone ~find_zone s\n ;;\nend\n\ninclude To_and_of_string\n\nlet min_value_representable = of_span_since_epoch Span.min_value_representable\nlet max_value_representable = of_span_since_epoch Span.max_value_representable\n\n(* Legacy definitions based on rounding to the nearest microsecond. *)\nlet min_value = min_value_for_1us_rounding\nlet max_value = max_value_for_1us_rounding\nlet to_time = to_time_float_round_nearest_microsecond\nlet of_time = of_time_float_round_nearest_microsecond\n\nmodule For_ppx_module_timer = struct\n open Ppx_module_timer_runtime\n\n let () =\n Duration.format\n := (module struct\n let duration_of_span s = s |> Span.to_int63_ns |> Duration.of_nanoseconds\n let span_of_duration d = d |> Duration.to_nanoseconds |> Span.of_int63_ns\n let of_string string = string |> Span.of_string |> duration_of_span\n\n let to_string_with_same_unit durations =\n let spans = durations |> List.map ~f:span_of_duration in\n let unit_of_time =\n spans\n |> List.max_elt ~compare:Span.compare\n |> Option.value_map\n ~f:Span.to_unit_of_time\n ~default:Unit_of_time.Nanosecond\n in\n spans |> List.map ~f:(Span.to_string_hum ~unit_of_time ~align_decimal:true)\n ;;\n end)\n ;;\nend\n","open! Import\n\n(* A [Time_ns] that uses its alternate sexp representation. *)\ninclude Time_ns\ninclude Alternate_sexp\n","module Stable = struct\n open Stable_internal\n\n module T = struct\n type 'a t =\n { mutable value : 'a option\n ; mutable set_at : Source_code_position.Stable.V1.t\n }\n [@@deriving fields]\n end\n\n module V1 = struct\n module Format = struct\n type 'a t = 'a option ref [@@deriving bin_io, sexp]\n end\n\n module T = struct\n type 'a t = 'a T.t\n\n let of_format (v1 : 'a Format.t) : 'a t = { value = !v1; set_at = [%here] }\n let to_format (t : 'a t) : 'a Format.t = ref t.value\n end\n\n include T\n\n include Binable.Of_binable1_without_uuid [@alert \"-legacy\"]\n (Format)\n (struct\n include T\n\n let of_binable = of_format\n let to_binable = to_format\n end)\n\n include Sexpable.Of_sexpable1\n (Format)\n (struct\n include T\n\n let of_sexpable = of_format\n let to_sexpable = to_format\n end)\n end\nend\n\nopen! Import\nmodule Unstable = Stable.V1\nopen Stable.T\n\ntype 'a t = 'a Stable.T.t\n\nlet sexp_of_t sexp_of_a { value; set_at } =\n match value with\n | None -> [%message \"unset\"]\n | Some value ->\n [%message \"\" (value : a) ~set_at:(set_at |> Source_code_position.to_string)]\n;;\n\nlet invariant invariant_a t =\n match t.value with\n | None -> ()\n | Some a -> invariant_a a\n;;\n\nlet create () = { value = None; set_at = [%here] }\n\nlet set_internal t here value =\n t.value <- Some value;\n t.set_at <- here\n;;\n\nlet set_if_none t here value = if Option.is_none t.value then set_internal t here value\n\nlet set t here value =\n if Option.is_none t.value\n then (\n set_internal t here value;\n Ok ())\n else\n Or_error.error_s\n [%message\n \"[Set_once.set_exn] already set\"\n ~setting_at:(here : Source_code_position.t)\n ~previously_set_at:(t.set_at : Source_code_position.t)]\n;;\n\nlet set_exn t here value = Or_error.ok_exn (set t here value)\nlet get t = t.value\n\nlet get_exn (t : _ t) here =\n match t.value with\n | Some a -> a\n | None ->\n raise_s [%message \"[Set_once.get_exn] unset\" ~at:(here : Source_code_position.t)]\n;;\n\nlet is_none t = Option.is_none t.value\nlet is_some t = Option.is_some t.value\nlet iter t ~f = Option.iter t.value ~f\n\nmodule Optional_syntax = struct\n module Optional_syntax = struct\n let is_none = is_none\n let unsafe_value t = get_exn t [%here]\n end\nend\n","open! Import\n\ntype 'a t = 'a [@@deriving sexp_of]\n\nexternal is_heap_block : Caml.Obj.t -> bool = \"Core_kernel_heap_block_is_heap_block\"\n[@@noalloc]\n\nlet is_ok v = is_heap_block (Caml.Obj.repr v)\nlet create v = if is_ok v then Some v else None\n\nlet create_exn v =\n if is_ok v then v else failwith \"Heap_block.create_exn called with non heap block\"\n;;\n\nlet value t = t\nlet bytes_per_word = Word_size.(num_bits word_size) / 8\n\nlet bytes (type a) (t : a t) =\n (Caml.Obj.size (Caml.Obj.repr (t : a t)) + 1) * bytes_per_word\n;;\n","open! Import\ninclude Base.Queue\n\ninclude Test_binary_searchable.Make1_and_test (struct\n type nonrec 'a t = 'a t\n\n let get = get\n let length = length\n\n module For_test = struct\n let of_array a =\n let r = create () in\n (* We enqueue everything twice, and dequeue it once to ensure:\n - that the queue has the same content as the array.\n - that it has, in most cases, an interesting internal structure*)\n for i = 0 to Array.length a - 1 do\n enqueue r a.(i)\n done;\n for i = 0 to Array.length a - 1 do\n ignore (dequeue_exn r : bool);\n enqueue r a.(i)\n done;\n r\n ;;\n end\n end)\n\nmodule Serialization_v1 = struct\n let sexp_of_t = sexp_of_t\n let t_of_sexp = t_of_sexp\n\n include Bin_prot.Utils.Make_iterable_binable1 (struct\n type nonrec 'a t = 'a t\n type 'a el = 'a [@@deriving bin_io]\n\n let caller_identity =\n Bin_prot.Shape.Uuid.of_string \"b4c84254-4992-11e6-9ba7-734e154027bd\"\n ;;\n\n let module_name = Some \"Core_kernel.Queue\"\n let length = length\n let iter = iter\n let init ~len ~next = init len ~f:(fun _ -> next ())\n end)\nend\n\ninclude Serialization_v1\n\nmodule Stable = struct\n module V1 = struct\n type nonrec 'a t = 'a t [@@deriving compare]\n\n include Serialization_v1\n\n (* We don't have a [%bin_digest] expect test here because the bin_io is mostly hand\n written, and [core_queue_unit_tests.ml] has unit tests for specific values. *)\n\n let map = map\n end\nend\n","open! Import\ninclude Base.Option_array\n\nlet to_array t = Array.init (length t) ~f:(fun i -> unsafe_get t i)\nlet of_array a = init (Array.length a) ~f:(fun i -> Array.unsafe_get a i)\n\ninclude Binable.Of_binable1_without_uuid [@alert \"-legacy\"]\n (struct\n type 'a t = 'a option array [@@deriving sexp, bin_io]\n end)\n (struct\n type nonrec 'a t = 'a t\n\n let to_binable = to_array\n let of_binable = of_array\n end)\n","open! Import\nopen Std_internal\n\ntype ('a, 'b) fn = 'a -> 'b\n\nmodule Result = struct\n type 'a t =\n | Rval of 'a\n | Expt of exn\n\n let return = function\n | Rval v -> v\n | Expt e -> raise e\n ;;\n\n let capture f x =\n try Rval (f x) with\n | Sys.Break as e -> raise e\n | e -> Expt e\n ;;\nend\n\nlet unit f =\n let l = Lazy.from_fun f in\n fun () -> Lazy.force l\n;;\n\nlet unbounded (type a) ?(hashable = Hashtbl.Hashable.poly) f =\n let cache =\n let module A =\n Hashable.Make_plain_and_derive_hash_fold_t (struct\n type t = a\n\n let { Hashtbl.Hashable.hash; compare; sexp_of_t } = hashable\n end)\n in\n A.Table.create () ~size:0\n in\n (* Allocate this closure at the call to [unbounded], not at each call to the memoized\n function. *)\n let really_call_f arg = Result.capture f arg in\n fun arg -> Result.return (Hashtbl.findi_or_add cache arg ~default:really_call_f)\n;;\n\n(* the same but with a bound on cache size *)\nlet lru (type a) ?(hashable = Hashtbl.Hashable.poly) ~max_cache_size f =\n if max_cache_size <= 0\n then failwithf \"Memo.lru: max_cache_size of %i <= 0\" max_cache_size ();\n let module Cache =\n Hash_queue.Make (struct\n type t = a\n\n let { Hashtbl.Hashable.hash; compare; sexp_of_t } = hashable\n end)\n in\n let cache = Cache.create () in\n fun arg ->\n Result.return\n (match Cache.lookup_and_move_to_back cache arg with\n | Some result -> result\n | None ->\n let result = Result.capture f arg in\n Cache.enqueue_back_exn cache arg result;\n (* eject least recently used cache entry *)\n if Cache.length cache > max_cache_size\n then ignore (Cache.dequeue_front_exn cache : _ Result.t);\n result)\n;;\n\nlet general ?hashable ?cache_size_bound f =\n match cache_size_bound with\n | None -> unbounded ?hashable f\n | Some n -> lru ?hashable ~max_cache_size:n f\n;;\n\nlet of_comparable (type index) (module M : Comparable.S_plain with type t = index) f =\n let m = ref M.Map.empty in\n fun (x : M.t) ->\n let v =\n match Map.find !m x with\n | Some v -> v\n | None ->\n let v = Result.capture f x in\n m := Map.set !m ~key:x ~data:v;\n v\n in\n Result.return v\n;;\n","open! Import\nopen Std_internal\n\ntype 'a t =\n { (* [arr] is a cyclic buffer *)\n mutable arr : 'a Option_array.t\n ; (* [front_index] and [back_index] are the positions in which new elements may be\n enqueued. This makes the active part of [arr] the range from [front_index+1] to\n [back_index-1] (modulo the length of [arr] and wrapping around if necessary). Note\n that this means the active range is maximized when [front_index = back_index], which\n occurs when there are [Array.length arr - 1] active elements. *)\n mutable front_index : int\n ; mutable back_index : int\n ; (* apparent_front_index is what is exposed as the front index externally. It has no\n real relation to the array -- every enqueue to the front decrements it and every\n dequeue from the front increments it. *)\n mutable apparent_front_index : int\n ; mutable length : int\n ; (* We keep arr_length here as a speed hack. Calling Array.length on arr is actually\n meaningfully slower. *)\n mutable arr_length : int\n ; never_shrink : bool\n }\n\nlet create ?initial_length ?never_shrink () =\n let never_shrink =\n match never_shrink with\n | None -> Option.is_some initial_length\n | Some b -> b\n in\n let initial_length = Option.value ~default:7 initial_length in\n if initial_length < 0\n then\n invalid_argf \"passed negative initial_length to Deque.create: %i\" initial_length ();\n (* Make the initial array length be [initial_length + 1] so we can fit [initial_length]\n elements without growing. We never quite use the whole array. *)\n let arr_length = initial_length + 1 in\n { arr = Option_array.create ~len:arr_length\n ; front_index = 0\n ; back_index = 1\n ; apparent_front_index = 0\n ; length = 0\n ; arr_length\n ; never_shrink\n }\n;;\n\nlet length t = t.length\nlet is_empty t = length t = 0\n\n(* We keep track of the length in a mutable field for speed, but this calculation should\n be correct by construction, and can be used for testing. *)\nlet _invariant_length t =\n let constructed_length =\n if t.front_index < t.back_index\n then t.back_index - t.front_index - 1\n else t.back_index - t.front_index - 1 + t.arr_length\n in\n assert (length t = constructed_length)\n;;\n\n(* The various \"when_not_empty\" functions return misleading numbers when the dequeue is\n empty. They are safe to call if it is known that the dequeue is non-empty. *)\nlet apparent_front_index_when_not_empty t = t.apparent_front_index\nlet apparent_back_index_when_not_empty t = t.apparent_front_index + length t - 1\n\nlet actual_front_index_when_not_empty t =\n if t.front_index = t.arr_length - 1 then 0 else t.front_index + 1\n;;\n\nlet actual_back_index_when_not_empty t =\n if t.back_index = 0 then t.arr_length - 1 else t.back_index - 1\n;;\n\nlet checked t f = if is_empty t then None else Some (f t)\nlet apparent_front_index t = checked t apparent_front_index_when_not_empty\nlet apparent_back_index t = checked t apparent_back_index_when_not_empty\n\nlet foldi' t dir ~init ~f =\n if is_empty t\n then init\n else (\n let apparent_front = apparent_front_index_when_not_empty t in\n let apparent_back = apparent_back_index_when_not_empty t in\n let actual_front = actual_front_index_when_not_empty t in\n let actual_back = actual_back_index_when_not_empty t in\n let rec loop acc ~apparent_i ~real_i ~stop_pos ~step =\n if real_i = stop_pos\n then acc, apparent_i\n else\n loop\n (f apparent_i acc (Option_array.get_some_exn t.arr real_i))\n ~apparent_i:(apparent_i + step)\n ~real_i:(real_i + step)\n ~stop_pos\n ~step\n in\n (* We want to iterate from actual_front to actual_back (or vice versa), but we may\n need to wrap around the array to do so. Thus we do the following:\n 1. If the active range is contiguous (i.e. actual_front <= actual_back), then loop\n starting at the appropriate end of the active range until we reach the first\n element outside of it.\n 2. If it is not contiguous (actual_front > actual_back), then first loop from the\n appropriate end of the active range to the end of the array. Then, loop from\n the opposite end of the array to the opposite end of the active range.\n *)\n match dir with\n | `front_to_back ->\n if actual_front <= actual_back\n then (\n let acc, _ =\n loop\n init\n ~apparent_i:apparent_front\n ~real_i:actual_front\n ~stop_pos:(actual_back + 1)\n ~step:1\n in\n acc)\n else (\n let acc, apparent_i =\n loop\n init\n ~apparent_i:apparent_front\n ~real_i:actual_front\n ~stop_pos:t.arr_length\n ~step:1\n in\n let acc, _ =\n loop acc ~apparent_i ~real_i:0 ~stop_pos:(actual_back + 1) ~step:1\n in\n acc)\n | `back_to_front ->\n if actual_front <= actual_back\n then (\n let acc, _ =\n loop\n init\n ~apparent_i:apparent_back\n ~real_i:actual_back\n ~stop_pos:(actual_front - 1)\n ~step:(-1)\n in\n acc)\n else (\n let acc, apparent_i =\n loop\n init\n ~apparent_i:apparent_back\n ~real_i:actual_back\n ~stop_pos:(-1)\n ~step:(-1)\n in\n let acc, _ =\n loop\n acc\n ~apparent_i\n ~real_i:(t.arr_length - 1)\n ~stop_pos:(actual_front - 1)\n ~step:(-1)\n in\n acc))\n;;\n\nlet fold' t dir ~init ~f = foldi' t dir ~init ~f:(fun _ acc v -> f acc v)\nlet iteri' t dir ~f = foldi' t dir ~init:() ~f:(fun i () v -> f i v)\nlet iter' t dir ~f = foldi' t dir ~init:() ~f:(fun _ () v -> f v)\nlet fold t ~init ~f = fold' t `front_to_back ~init ~f\nlet foldi t ~init ~f = foldi' t `front_to_back ~init ~f\nlet iteri t ~f = iteri' t `front_to_back ~f\n\nlet iteri_internal t ~f =\n if not (is_empty t)\n then (\n let actual_front = actual_front_index_when_not_empty t in\n let actual_back = actual_back_index_when_not_empty t in\n let rec loop ~real_i ~stop_pos =\n if real_i < stop_pos\n then (\n f t.arr real_i;\n loop ~real_i:(real_i + 1) ~stop_pos)\n in\n if actual_front <= actual_back\n then loop ~real_i:actual_front ~stop_pos:(actual_back + 1)\n else (\n loop ~real_i:actual_front ~stop_pos:t.arr_length;\n loop ~real_i:0 ~stop_pos:(actual_back + 1)))\n;;\n\nlet iter t ~f = iteri_internal t ~f:(fun arr i -> Option_array.get_some_exn arr i |> f)\n\nlet clear t =\n if t.never_shrink\n then\n (* clear the array to allow elements to be garbage collected *)\n iteri_internal t ~f:Option_array.unsafe_set_none\n else t.arr <- Option_array.create ~len:8;\n t.front_index <- 0;\n t.back_index <- 1;\n t.length <- 0;\n t.arr_length <- Option_array.length t.arr\n;;\n\n(* We have to be careful here, importing all of Container.Make would change the runtime of\n some functions ([length] minimally) silently without changing the semantics. We get\n around that by importing things explicitly. *)\nmodule C = Container.Make (struct\n type nonrec 'a t = 'a t\n\n let fold = fold\n let iter = `Custom iter\n let length = `Custom length\n end)\n\nlet count = C.count\nlet sum = C.sum\nlet exists = C.exists\nlet mem = C.mem\nlet for_all = C.for_all\nlet find_map = C.find_map\nlet find = C.find\nlet to_list = C.to_list\nlet min_elt = C.min_elt\nlet max_elt = C.max_elt\nlet fold_result = C.fold_result\nlet fold_until = C.fold_until\n\nlet blit new_arr t =\n assert (not (is_empty t));\n let actual_front = actual_front_index_when_not_empty t in\n let actual_back = actual_back_index_when_not_empty t in\n let old_arr = t.arr in\n if actual_front <= actual_back\n then\n Option_array.blit\n ~src:old_arr\n ~dst:new_arr\n ~src_pos:actual_front\n ~dst_pos:0\n ~len:(length t)\n else (\n let break_pos = Option_array.length old_arr - actual_front in\n Option_array.blit\n ~src:old_arr\n ~dst:new_arr\n ~src_pos:actual_front\n ~dst_pos:0\n ~len:break_pos;\n Option_array.blit\n ~src:old_arr\n ~dst:new_arr\n ~src_pos:0\n ~dst_pos:break_pos\n ~len:(actual_back + 1));\n (* length depends on t.arr and t.front_index, so this needs to be first *)\n t.back_index <- length t;\n t.arr <- new_arr;\n t.arr_length <- Option_array.length new_arr;\n t.front_index <- Option_array.length new_arr - 1;\n (* Since t.front_index = Option_array.length new_arr - 1, this is asserting that t.back_index\n is a valid index in the array and that the array can support at least one more\n element -- recall, if t.front_index = t.back_index then the array is full.\n\n Note that this is true if and only if Option_array.length new_arr > length t + 1.\n *)\n assert (t.front_index > t.back_index)\n;;\n\nlet maybe_shrink_underlying t =\n if (not t.never_shrink) && t.arr_length > 10 && t.arr_length / 3 > length t\n then (\n let new_arr = Option_array.create ~len:(t.arr_length / 2) in\n blit new_arr t)\n;;\n\nlet grow_underlying t =\n let new_arr = Option_array.create ~len:(t.arr_length * 2) in\n blit new_arr t\n;;\n\nlet enqueue_back t v =\n if t.front_index = t.back_index then grow_underlying t;\n Option_array.set_some t.arr t.back_index v;\n t.back_index <- (if t.back_index = t.arr_length - 1 then 0 else t.back_index + 1);\n t.length <- t.length + 1\n;;\n\nlet enqueue_front t v =\n if t.front_index = t.back_index then grow_underlying t;\n Option_array.set_some t.arr t.front_index v;\n t.front_index <- (if t.front_index = 0 then t.arr_length - 1 else t.front_index - 1);\n t.apparent_front_index <- t.apparent_front_index - 1;\n t.length <- t.length + 1\n;;\n\nlet enqueue t back_or_front v =\n match back_or_front with\n | `back -> enqueue_back t v\n | `front -> enqueue_front t v\n;;\n\nlet peek_front_nonempty t =\n Option_array.get_some_exn t.arr (actual_front_index_when_not_empty t)\n;;\n\nlet peek_front_exn t =\n if is_empty t\n then failwith \"Deque.peek_front_exn passed an empty queue\"\n else peek_front_nonempty t\n;;\n\nlet peek_front t = if is_empty t then None else Some (peek_front_nonempty t)\n\nlet peek_back_nonempty t =\n Option_array.get_some_exn t.arr (actual_back_index_when_not_empty t)\n;;\n\nlet peek_back_exn t =\n if is_empty t\n then failwith \"Deque.peek_back_exn passed an empty queue\"\n else peek_back_nonempty t\n;;\n\nlet peek_back t = if is_empty t then None else Some (peek_back_nonempty t)\n\nlet peek t back_or_front =\n match back_or_front with\n | `back -> peek_back t\n | `front -> peek_front t\n;;\n\nlet dequeue_front_nonempty t =\n let i = actual_front_index_when_not_empty t in\n let res = Option_array.get_some_exn t.arr i in\n Option_array.set_none t.arr i;\n t.front_index <- i;\n t.apparent_front_index <- t.apparent_front_index + 1;\n t.length <- t.length - 1;\n maybe_shrink_underlying t;\n res\n;;\n\nlet dequeue_front_exn t =\n if is_empty t\n then failwith \"Deque.dequeue_front_exn passed an empty queue\"\n else dequeue_front_nonempty t\n;;\n\nlet dequeue_front t = if is_empty t then None else Some (dequeue_front_nonempty t)\n\nlet dequeue_back_nonempty t =\n let i = actual_back_index_when_not_empty t in\n let res = Option_array.get_some_exn t.arr i in\n Option_array.set_none t.arr i;\n t.back_index <- i;\n t.length <- t.length - 1;\n maybe_shrink_underlying t;\n res\n;;\n\nlet dequeue_back_exn t =\n if is_empty t\n then failwith \"Deque.dequeue_back_exn passed an empty queue\"\n else dequeue_back_nonempty t\n;;\n\nlet dequeue_back t = if is_empty t then None else Some (dequeue_back_nonempty t)\n\nlet dequeue_exn t back_or_front =\n match back_or_front with\n | `front -> dequeue_front_exn t\n | `back -> dequeue_back_exn t\n;;\n\nlet dequeue t back_or_front =\n match back_or_front with\n | `front -> dequeue_front t\n | `back -> dequeue_back t\n;;\n\nlet drop_gen ?(n = 1) ~dequeue t =\n if n < 0 then invalid_argf \"Deque.drop: negative input (%d)\" n ();\n let rec loop n =\n if n > 0\n then (\n match dequeue t with\n | None -> ()\n | Some _ -> loop (n - 1))\n in\n loop n\n;;\n\nlet drop_front ?n t = drop_gen ?n ~dequeue:dequeue_front t\nlet drop_back ?n t = drop_gen ?n ~dequeue:dequeue_back t\n\nlet drop ?n t back_or_front =\n match back_or_front with\n | `back -> drop_back ?n t\n | `front -> drop_front ?n t\n;;\n\nlet assert_not_empty t name = if is_empty t then failwithf \"%s: Deque.t is empty\" name ()\n\nlet true_index_exn t i =\n let i_from_zero = i - t.apparent_front_index in\n if i_from_zero < 0 || length t <= i_from_zero\n then (\n assert_not_empty t \"Deque.true_index_exn\";\n let apparent_front = apparent_front_index_when_not_empty t in\n let apparent_back = apparent_back_index_when_not_empty t in\n invalid_argf\n \"invalid index: %i for array with indices (%i,%i)\"\n i\n apparent_front\n apparent_back\n ());\n let true_i = t.front_index + 1 + i_from_zero in\n if true_i >= t.arr_length then true_i - t.arr_length else true_i\n;;\n\nlet get t i = Option_array.get_some_exn t.arr (true_index_exn t i)\n\nlet get_opt t i =\n try Some (get t i) with\n | _ -> None\n;;\n\nlet set_exn t i v = Option_array.set_some t.arr (true_index_exn t i) v\n\nlet to_array t =\n match peek_front t with\n | None -> [||]\n | Some front ->\n let arr = Array.create ~len:(length t) front in\n ignore\n (fold t ~init:0 ~f:(fun i v ->\n arr.(i) <- v;\n i + 1)\n : int);\n arr\n;;\n\nlet of_array arr =\n let t = create ~initial_length:(Array.length arr + 1) () in\n Array.iter arr ~f:(fun v -> enqueue_back t v);\n t\n;;\n\ninclude Bin_prot.Utils.Make_iterable_binable1 (struct\n type nonrec 'a t = 'a t\n type 'a el = 'a [@@deriving bin_io]\n\n let caller_identity =\n Bin_prot.Shape.Uuid.of_string \"34c1e9ca-4992-11e6-a686-8b4bd4f87796\"\n ;;\n\n let module_name = Some \"Core_kernel.Deque\"\n let length = length\n let iter t ~f = iter t ~f\n\n let init ~len ~next =\n let t = create ~initial_length:len () in\n for _i = 0 to len - 1 do\n let x = next () in\n enqueue_back t x\n done;\n t\n ;;\n end)\n\nlet t_of_sexp f sexp = of_array (Array.t_of_sexp f sexp)\nlet sexp_of_t f t = Array.sexp_of_t f (to_array t)\n\n(* re-expose these here under a different name to avoid internal confusion *)\nlet back_index = apparent_back_index\nlet front_index = apparent_front_index\n\nlet back_index_exn t =\n assert_not_empty t \"Deque.back_index_exn\";\n apparent_back_index_when_not_empty t\n;;\n\nlet front_index_exn t =\n assert_not_empty t \"Deque.front_index_exn\";\n apparent_front_index_when_not_empty t\n;;\n\nmodule Binary_searchable = Test_binary_searchable.Make1_and_test (struct\n type nonrec 'a t = 'a t\n\n let get t i = get t (front_index_exn t + i)\n let length = length\n\n module For_test = struct\n let of_array = of_array\n end\n end)\n\n(* The \"stable\" indices used in this module make the application of the\n [Binary_searchable] functor awkward. We need to be sure to translate incoming\n positions from stable space to the expected 0 -> length - 1 space and then we need to\n translate them back on return. *)\nlet binary_search ?pos ?len t ~compare how v =\n let pos =\n match pos with\n | None -> None\n | Some pos -> Some (pos - t.apparent_front_index)\n in\n match Binary_searchable.binary_search ?pos ?len t ~compare how v with\n | None -> None\n | Some untranslated_i -> Some (t.apparent_front_index + untranslated_i)\n;;\n\nlet binary_search_segmented ?pos ?len t ~segment_of how =\n let pos =\n match pos with\n | None -> None\n | Some pos -> Some (pos - t.apparent_front_index)\n in\n match Binary_searchable.binary_search_segmented ?pos ?len t ~segment_of how with\n | None -> None\n | Some untranslated_i -> Some (t.apparent_front_index + untranslated_i)\n;;\n","open! Import\nmodule List = Base.List\nmodule String = Base.String\n\nlet eprint message = Printf.eprintf \"%s\\n%!\" message\nlet eprint_s sexp = eprint (Sexp.to_string_hum sexp)\nlet eprints message a sexp_of_a = eprint_s ([%sexp_of: string * a] (message, a))\nlet eprintf format = Printf.ksprintf eprint format\nlet failwiths = Error.failwiths\n\nmodule Make () = struct\n let check_invariant = ref true\n let show_messages = ref true\n\n let debug invariant ~module_name name ts arg sexp_of_arg sexp_of_result f =\n if !show_messages\n then eprints (String.concat ~sep:\"\" [ module_name; \".\"; name ]) arg sexp_of_arg;\n if !check_invariant\n then (\n try List.iter ts ~f:invariant with\n | exn ->\n failwiths\n ~here:[%here]\n \"invariant pre-condition failed\"\n (name, exn)\n [%sexp_of: string * exn]);\n let result_or_exn = Result.try_with f in\n if !check_invariant\n then (\n try List.iter ts ~f:invariant with\n | exn ->\n failwiths\n ~here:[%here]\n \"invariant post-condition failed\"\n (name, exn)\n [%sexp_of: string * exn]);\n if !show_messages\n then\n eprints\n (String.concat ~sep:\"\" [ module_name; \".\"; name; \"-result\" ])\n result_or_exn\n [%sexp_of: (result, exn) Result.t];\n Result.ok_exn result_or_exn\n ;;\nend\n\nlet should_print_backtrace = ref false\n\nlet am_internal here message =\n (* In this function we use [Printf.eprintf] rather than [Debug.eprintf], because the\n former doesn't flush, while the latter does. We'd rather flush once at the end,\n rather than three times. *)\n Printf.eprintf \"%s:\\n\" (Source_code_position.to_string here);\n if !should_print_backtrace\n then\n Printf.eprintf\n \"%s\\n\"\n (Backtrace.get () |> [%sexp_of: Backtrace.t] |> Sexp.to_string_hum);\n (match message with\n | None -> ()\n | Some message -> Printf.eprintf \"%s\\n\" message);\n Printf.eprintf \"%!\"\n;;\n\nlet am here = am_internal here None\nlet amf here fmt = Printf.ksprintf (fun string -> am_internal here (Some string)) fmt\n\nlet ams here message a sexp_of_a =\n am_internal here (Some ((message, a) |> [%sexp_of: string * a] |> Sexp.to_string_hum))\n;;\n","(** Imperative set-like data structure.\n\n There are a few differences from simple sets:\n\n - Duplicates are allowed.\n - It doesn't require anything (hashable, comparable) of elements in the bag.\n - Addition and removal are constant time operations.\n\n It is an error to modify a bag ([add], [remove], [remove_one], ...) during iteration\n ([fold], [iter], ...). *)\n\nopen! Import\n\nmodule type S = sig\n module Elt : sig\n type 'a t\n\n val equal : 'a t -> 'a t -> bool\n val sexp_of_t : ('a -> Sexp.t) -> 'a t -> Sexp.t\n val value : 'a t -> 'a\n end\n\n type 'a t [@@deriving sexp]\n\n (** Much of a bag's interface comes from the generic {!Base.Container} module. *)\n include\n Container.S1 with type 'a t := 'a t\n\n include Invariant.S1 with type 'a t := 'a t\n\n (** [create ()] returns an empty bag. *)\n val create : unit -> 'a t\n\n (** [add t v] adds [v] to the bag [t], returning an element that can\n later be removed from the bag. [add] runs in constant time. *)\n val add : 'a t -> 'a -> 'a Elt.t\n\n val add_unit : 'a t -> 'a -> unit\n\n (** [mem_elt t elt] returns whether or not [elt] is in [t]. It is like [mem] (included\n from [Container]), but it takes an ['a Elt.t] instead of an ['a] and runs in constant\n time instead of linear time. *)\n val mem_elt : 'a t -> 'a Elt.t -> bool\n\n (** [remove t elt] removes [elt] from the bag [t], raising an exception if [elt]\n is not in the bag. [remove] runs in constant time. *)\n val remove : 'a t -> 'a Elt.t -> unit\n\n (** [choose t] returns some element in the bag. *)\n val choose : 'a t -> 'a Elt.t option\n\n (** [remove_one t] removes some element from the bag, and returns its value.\n [remove_one] runs in constant time. *)\n val remove_one : 'a t -> 'a option\n\n (** [clear t] removes all elements from the bag. [clear] runs in constant time. *)\n val clear : 'a t -> unit\n\n (** [filter_inplace t ~f] removes all the elements from [t] that don't satisfy [f]. *)\n val filter_inplace : 'a t -> f:('a -> bool) -> unit\n\n val iter_elt : 'a t -> f:('a Elt.t -> unit) -> unit\n\n (** [find_elt t ~f] returns the first element in the bag satisfying [f], returning [None]\n if none is found. *)\n val find_elt : 'a t -> f:('a -> bool) -> 'a Elt.t option\n\n (** [until_empty t f] repeatedly removes values [v] from [t], running [f v] on each one,\n until [t] is empty. Running [f] may add elements to [t] if it wants. *)\n val until_empty : 'a t -> ('a -> unit) -> unit\n\n (** [transfer ~src ~dst] moves all of the elements from [src] to [dst] in constant\n time. *)\n val transfer : src:'a t -> dst:'a t -> unit\n\n val of_list : 'a list -> 'a t\n val elts : 'a t -> 'a Elt.t list\n\n (** [unchecked_iter t ~f] behaves like [iter t ~f] except that [f] is allowed to modify\n [t]. Elements added by [f] may or may not be visited; elements removed by [f] that\n have not been visited will not be visited. It is an (undetected) error to delete the\n current element. *)\n val unchecked_iter : 'a t -> f:('a -> unit) -> unit\nend\n\nmodule type Bag = sig\n (** The module type of the Bag module.\n\n Example usage:\n {[\n module My_bag : Bag.S = Bag\n ]}\n\n Now [My_bag.Elt.t] can't be used with any other [Bag.t] type.\n *)\n module type S = S\n\n include S\nend\n","(*\n * Copyright (c) 2013 Jeremy Yallop.\n *\n * This file is distributed under the terms of the MIT License.\n * See the file LICENSE for details.\n *)\n\nmodule Pervasives = Pervasives [@@ocaml.warning \"-3\"]\n\nexternal init : unit -> unit = \"integers_unsigned_init\"\nlet () = init ()\n\n(* Boxed unsigned types *)\nmodule type Basics = sig\n type t\n\n val add : t -> t -> t\n val sub : t -> t -> t\n val mul : t -> t -> t\n val div : t -> t -> t\n val rem : t -> t -> t\n val max_int : t\n val logand : t -> t -> t\n val logor : t -> t -> t\n val logxor : t -> t -> t\n val shift_left : t -> int -> t\n val shift_right : t -> int -> t\n val of_int : int -> t\n val to_int : t -> int\n val of_int64 : int64 -> t\n val to_int64 : t -> int64\n val of_string : string -> t\n val to_string : t -> string\nend\n\n\nmodule type Extras = sig\n type t\n\n val zero : t\n val one : t\n val lognot : t -> t\n val succ : t -> t\n val pred : t -> t\n val compare : t -> t -> int\n val equal : t -> t -> bool\n val max : t -> t -> t\n val min : t -> t -> t\n val pp : Format.formatter -> t -> unit\nend\n\n\nmodule type Infix = sig\n type t\n val (+) : t -> t -> t\n val (-) : t -> t -> t\n val ( * ) : t -> t -> t\n val (/) : t -> t -> t\n val (mod) : t -> t -> t\n val (land) : t -> t -> t\n val (lor) : t -> t -> t\n val (lxor) : t -> t -> t\n val (lsl) : t -> int -> t\n val (lsr) : t -> int -> t\nend\n\n\nmodule type S = sig\n include Basics\n include Extras with type t := t\n\n module Infix : Infix with type t := t\nend\n\n\nmodule MakeInfix (B : Basics) =\nstruct\n open B\n let (+) = add\n let (-) = sub\n let ( * ) = mul\n let (/) = div\n let (mod) = rem\n let (land) = logand\n let (lor) = logor\n let (lxor) = logxor\n let (lsl) = shift_left\n let (lsr) = shift_right\nend\n\n\nmodule Extras(Basics : Basics) : Extras with type t := Basics.t =\nstruct\n open Basics\n let zero = of_int 0\n let one = of_int 1\n let succ n = add n one\n let pred n = sub n one\n let lognot n = logxor n max_int\n let compare (x : t) (y : t) = Pervasives.compare x y\n let equal (x : t) (y : t) = Pervasives.(=) x y\n let max (x : t) (y : t) = Pervasives.max x y\n let min (x : t) (y : t) = Pervasives.min x y\n let pp fmt x = Format.fprintf fmt \"%s\" (to_string x)\nend\n\n\nmodule UInt8 : S with type t = private int =\nstruct\n module B =\n struct\n type t = int\n let max_int = 255\n let add : t -> t -> t = fun x y -> (x + y) land max_int\n let sub : t -> t -> t = fun x y -> (x - y) land max_int\n let mul : t -> t -> t = fun x y -> (x * y) land max_int\n let div : t -> t -> t = (/)\n let rem : t -> t -> t = (mod)\n let logand: t -> t -> t = (land)\n let logor: t -> t -> t = (lor)\n let logxor : t -> t -> t = (lxor)\n let shift_left : t -> int -> t = fun x y -> (x lsl y) land max_int\n let shift_right : t -> int -> t = (lsr)\n let of_int (x: int): t =\n (* For backwards compatibility, this wraps *)\n x land max_int\n external to_int : t -> int = \"%identity\"\n let of_int64 : int64 -> t = fun x -> of_int (Int64.to_int x)\n let to_int64 : t -> int64 = fun x -> Int64.of_int (to_int x)\n external of_string : string -> t = \"integers_uint8_of_string\"\n let to_string : t -> string = string_of_int\n end\n include B\n include Extras(B)\n module Infix = MakeInfix(B)\nend\n\n\nmodule UInt16 : S with type t = private int =\nstruct\n module B =\n struct\n type t = int\n let max_int = 65535\n let add : t -> t -> t = fun x y -> (x + y) land max_int\n let sub : t -> t -> t = fun x y -> (x - y) land max_int\n let mul : t -> t -> t = fun x y -> (x * y) land max_int\n let div : t -> t -> t = (/)\n let rem : t -> t -> t = (mod)\n let logand: t -> t -> t = (land)\n let logor: t -> t -> t = (lor)\n let logxor : t -> t -> t = (lxor)\n let shift_left : t -> int -> t = fun x y -> (x lsl y) land max_int\n let shift_right : t -> int -> t = (lsr)\n let of_int (x: int): t =\n (* For backwards compatibility, this wraps *)\n x land max_int\n external to_int : t -> int = \"%identity\"\n let of_int64 : int64 -> t = fun x -> Int64.to_int x |> of_int\n let to_int64 : t -> int64 = fun x -> to_int x |> Int64.of_int\n external of_string : string -> t = \"integers_uint16_of_string\"\n let to_string : t -> string = string_of_int\n end\n include B\n include Extras(B)\n module Infix = MakeInfix(B)\nend\n\n\nmodule UInt32 : sig\n include S\n external of_int32 : int32 -> t = \"integers_uint32_of_int32\"\n external to_int32 : t -> int32 = \"integers_int32_of_uint32\"\nend = \nstruct\n module B =\n struct\n type t\n external add : t -> t -> t = \"integers_uint32_add\"\n external sub : t -> t -> t = \"integers_uint32_sub\"\n external mul : t -> t -> t = \"integers_uint32_mul\"\n external div : t -> t -> t = \"integers_uint32_div\"\n external rem : t -> t -> t = \"integers_uint32_rem\"\n external logand : t -> t -> t = \"integers_uint32_logand\"\n external logor : t -> t -> t = \"integers_uint32_logor\"\n external logxor : t -> t -> t = \"integers_uint32_logxor\"\n external shift_left : t -> int -> t = \"integers_uint32_shift_left\"\n external shift_right : t -> int -> t = \"integers_uint32_shift_right\"\n external of_int : int -> t = \"integers_uint32_of_int\"\n external to_int : t -> int = \"integers_uint32_to_int\"\n external of_int64 : int64 -> t = \"integers_uint32_of_int64\"\n external to_int64 : t -> int64 = \"integers_uint32_to_int64\"\n external of_string : string -> t = \"integers_uint32_of_string\"\n external to_string : t -> string = \"integers_uint32_to_string\"\n external _max_int : unit -> t = \"integers_uint32_max\"\n let max_int = _max_int ()\n end\n include B\n include Extras(B)\n module Infix = MakeInfix(B)\n external of_int32 : int32 -> t = \"integers_uint32_of_int32\"\n external to_int32 : t -> int32 = \"integers_int32_of_uint32\"\nend\n\n\nmodule UInt64 : sig\n include S\n external of_int64 : int64 -> t = \"integers_uint64_of_int64\"\n external to_int64 : t -> int64 = \"integers_uint64_to_int64\"\n external of_uint32 : UInt32.t -> t = \"integers_uint64_of_uint32\"\n external to_uint32 : t -> UInt32.t = \"integers_uint32_of_uint64\"\nend = \nstruct\n module B =\n struct\n type t\n external add : t -> t -> t = \"integers_uint64_add\"\n external sub : t -> t -> t = \"integers_uint64_sub\"\n external mul : t -> t -> t = \"integers_uint64_mul\"\n external div : t -> t -> t = \"integers_uint64_div\"\n external rem : t -> t -> t = \"integers_uint64_rem\"\n external logand : t -> t -> t = \"integers_uint64_logand\"\n external logor : t -> t -> t = \"integers_uint64_logor\"\n external logxor : t -> t -> t = \"integers_uint64_logxor\"\n external shift_left : t -> int -> t = \"integers_uint64_shift_left\"\n external shift_right : t -> int -> t = \"integers_uint64_shift_right\"\n external of_int : int -> t = \"integers_uint64_of_int\"\n external to_int : t -> int = \"integers_uint64_to_int\"\n external of_int64 : int64 -> t = \"integers_uint64_of_int64\"\n external to_int64 : t -> int64 = \"integers_uint64_to_int64\"\n external of_uint32 : UInt32.t -> t = \"integers_uint64_of_uint32\"\n external to_uint32 : t -> UInt32.t = \"integers_uint32_of_uint64\"\n external of_string : string -> t = \"integers_uint64_of_string\"\n external to_string : t -> string = \"integers_uint64_to_string\"\n external _max_int : unit -> t = \"integers_uint64_max\"\n let max_int = _max_int ()\n end\n include B\n include Extras(B)\n module Infix = MakeInfix(B)\nend\n\n\nlet of_byte_size : int -> (module S) = function\n | 1 -> (module UInt8)\n | 2 -> (module UInt16)\n | 4 -> (module UInt32)\n | 8 -> (module UInt64)\n | _ -> invalid_arg \"Unsigned.of_byte_size\"\n\n \nexternal size_t_size : unit -> int = \"integers_size_t_size\"\nexternal ushort_size : unit -> int = \"integers_ushort_size\"\nexternal uint_size : unit -> int = \"integers_uint_size\"\nexternal ulong_size : unit -> int = \"integers_ulong_size\"\nexternal ulonglong_size : unit -> int = \"integers_ulonglong_size\"\n\nmodule Size_t : S = (val of_byte_size (size_t_size ()))\nmodule UChar = UInt8\nmodule UShort : S = (val of_byte_size (ushort_size ()))\nmodule UInt : S = (val of_byte_size (uint_size ()))\nmodule ULong : S = (val of_byte_size (ulong_size ()))\nmodule ULLong : S = (val of_byte_size (ulonglong_size ()))\n\ntype uchar = UChar.t\ntype uint8 = UInt8.t\ntype uint16 = UInt16.t\ntype uint32 = UInt32.t\ntype uint64 = UInt64.t\ntype size_t = Size_t.t\ntype ushort = UShort.t\ntype uint = UInt.t\ntype ulong = ULong.t\ntype ullong = ULLong.t\n","exception Error of string\n\nlet error s = raise (Error s)\n\n\n(*\n Debugging utilities.\n*)\n\nlet string8_of_int x =\n let s = Bytes.create 8 in\n for i = 0 to 7 do\n Bytes.set s (7-i) (Char.chr (0xff land (x lsr (8 * i))))\n done;\n Bytes.to_string s\n\nlet string4_of_int x =\n let s = Bytes.create 4 in\n for i = 0 to 3 do\n Bytes.set s (3-i) (Char.chr (0xff land (x lsr (8 * i))))\n done;\n Bytes.to_string s\n\nlet print_bits ?(pos = 0) ?len s =\n let slen = String.length s in\n if pos < 0 || (pos > 0 && pos >= slen) then\n invalid_arg \"Bi_util.print_bits\";\n let len =\n match len with\n None -> slen - pos\n | Some len ->\n if len > slen - pos then invalid_arg \"Bi_util.print_bits\"\n else len\n in\n\n let r = Bytes.create (len * 9) in\n for i = 0 to len - 1 do\n let k = i * 9 in\n let x = Char.code s.[pos+i] in\n for j = 0 to 7 do\n Bytes.set r (k+j) (if (x lsr (7 - j)) land 1 = 0 then '0' else '1')\n done;\n Bytes.set r (k+8) (if (i + 1) mod 8 = 0 then '\\n' else ' ')\n done;\n Bytes.to_string r\n\n(* int size in bits *)\nlet int_size =\n let c = ref 0 in\n let r = ref (-1) in\n while !r <> 0 do\n r := !r lsr 1;\n incr c\n done;\n !c\n","type t = {\n mutable o_s : bytes;\n mutable o_max_len : int;\n mutable o_len : int;\n mutable o_offs : int;\n o_init_len : int;\n o_make_room : (t -> int -> unit);\n mutable o_shared : Bi_share.Wr.tbl;\n o_shared_init_len : int;\n}\n\nlet really_extend b n =\n let slen0 = b.o_max_len in\n let reqlen = b.o_len + n in\n let slen =\n let x = max reqlen (2 * slen0) in\n if x <= Sys.max_string_length then x\n else\n if Sys.max_string_length < reqlen then\n\tinvalid_arg \"Buf.extend: reached Sys.max_string_length\"\n else\n\tSys.max_string_length\n in\n let s = Bytes.create slen in\n Bytes.blit b.o_s 0 s 0 b.o_len;\n b.o_s <- s;\n b.o_max_len <- slen\n\nlet flush_to_output abstract_output b n =\n abstract_output (Bytes.to_string b.o_s) 0 b.o_len;\n b.o_offs <- b.o_offs + b.o_len;\n b.o_len <- 0;\n if n > b.o_max_len then\n really_extend b n\n\nlet flush_to_channel oc = flush_to_output (output_substring oc)\n\n\nlet create ?(make_room = really_extend) ?(shrlen = 16) n = {\n o_s = Bytes.create n;\n o_max_len = n;\n o_len = 0;\n o_offs = 0;\n o_init_len = n;\n o_make_room = make_room;\n o_shared = Bi_share.Wr.create shrlen;\n o_shared_init_len = shrlen;\n}\n\nlet create_channel_writer ?(len = 4096) ?shrlen oc =\n create ~make_room:(flush_to_channel oc) ?shrlen len\n\nlet flush_channel_writer b =\n b.o_make_room b 0\n\nlet create_output_writer ?(len = 4096) ?shrlen out =\n create ~make_room:(flush_to_output out#output) ?shrlen len\n\nlet flush_output_writer = flush_channel_writer\n\n\n(*\n Guarantee that the buffer string has enough room for n additional bytes.\n*)\nlet extend b n =\n if b.o_len + n > b.o_max_len then\n b.o_make_room b n\n\nlet alloc b n =\n extend b n;\n let pos = b.o_len in\n b.o_len <- pos + n;\n pos\n\nlet add_sub blit b s pos len =\n extend b len;\n blit s pos b.o_s b.o_len len;\n b.o_len <- b.o_len + len\n\nlet add_substring = add_sub String.blit\nlet add_subbytes = add_sub Bytes.blit\n\nlet add_string b s =\n add_substring b s 0 (String.length s)\n\nlet add_bytes b s =\n add_subbytes b s 0 (Bytes.length s)\n\n\nlet add_char b c =\n let pos = alloc b 1 in\n Bytes.set b.o_s pos c\n\nlet unsafe_add_char b c =\n let len = b.o_len in\n Bytes.set b.o_s len c;\n b.o_len <- len + 1\n\nlet add_char2 b c1 c2 =\n let pos = alloc b 2 in\n let s = b.o_s in\n Bytes.unsafe_set s pos c1;\n Bytes.unsafe_set s (pos+1) c2\n\nlet add_char4 b c1 c2 c3 c4 =\n let pos = alloc b 4 in\n let s = b.o_s in\n Bytes.unsafe_set s pos c1;\n Bytes.unsafe_set s (pos+1) c2;\n Bytes.unsafe_set s (pos+2) c3;\n Bytes.unsafe_set s (pos+3) c4\n\n\n\nlet clear b =\n b.o_offs <- 0;\n b.o_len <- 0;\n Bi_share.Wr.clear b.o_shared\n\nlet reset b =\n if Bytes.length b.o_s <> b.o_init_len then\n b.o_s <- Bytes.create b.o_init_len;\n b.o_offs <- 0;\n b.o_len <- 0;\n b.o_shared <- Bi_share.Wr.create b.o_shared_init_len\n\nlet contents b = Bytes.sub_string b.o_s 0 b.o_len\n","type type_id = int\n\nlet dummy_type_id = 0\n\nlet create_type_id =\n let n = ref dummy_type_id in\n fun () ->\n incr n;\n if !n < 0 then\n failwith \"Bi_share.Rd_poly.create_type_id: \\\n exhausted available type_id's\"\n else\n !n\n\nmodule Wr =\nstruct\n module H = Hashtbl.Make (\n struct\n type t = Obj.t * type_id\n let equal (x1, t1) (x2, t2) = x1 == x2 && t1 == t2\n let hash = Hashtbl.hash\n end\n )\n\n type tbl = int H.t\n\n let create = H.create\n let clear tbl =\n if H.length tbl > 0 then\n H.clear tbl\n\n let put tbl k pos =\n try\n let pos0 = H.find tbl (Obj.magic k) in\n pos - pos0\n with Not_found ->\n H.add tbl (Obj.magic k) pos;\n 0\nend\n\nmodule Rd =\nstruct\n type tbl = ((int * type_id), Obj.t) Hashtbl.t\n\n let create n = Hashtbl.create n\n let clear = Hashtbl.clear\n\n let put tbl pos x =\n Hashtbl.add tbl pos x\n\n let get tbl pos =\n try Hashtbl.find tbl pos\n with Not_found ->\n Bi_util.error \"Corrupted data (invalid reference)\"\nend\n","include Ppx_deriving_runtime\n\nlet (>>=) x f =\n match x with Result.Ok x -> f x | (Result.Error _) as x -> x\n\nlet (>|=) x f =\n x >>= fun x -> Result.Ok (f x)\n\nlet rec map_bind f acc xs =\n match xs with\n | x :: xs -> f x >>= fun x -> map_bind f (x :: acc) xs\n | [] -> Result.Ok (List.rev acc)\n\ntype 'a error_or = ('a, string) Result.result\n\n(** [safe_map f l] returns the same value as [List.map f l], but\n computes it tail-recursively so that large list lengths don't\n cause a stack overflow *)\nlet safe_map f l = List.rev (List.rev_map f l)\n","(* This file is generated automatically with ocaml_gen. *)\n\nmodule BigInt256 = struct\n type nonrec t\n\n external of_numeral : string -> int -> int -> t = \"caml_bigint_256_of_numeral\"\n\n external of_decimal_string : string -> t = \"caml_bigint_256_of_decimal_string\"\n\n external num_limbs : unit -> int = \"caml_bigint_256_num_limbs\"\n\n external bytes_per_limb : unit -> int = \"caml_bigint_256_bytes_per_limb\"\n\n external div : t -> t -> t = \"caml_bigint_256_div\"\n\n external compare : t -> t -> int = \"caml_bigint_256_compare\"\n\n external print : t -> unit = \"caml_bigint_256_print\"\n\n external to_string : t -> string = \"caml_bigint_256_to_string\"\n\n external test_bit : t -> int -> bool = \"caml_bigint_256_test_bit\"\n\n external to_bytes : t -> bytes = \"caml_bigint_256_to_bytes\"\n\n external of_bytes : bytes -> t = \"caml_bigint_256_of_bytes\"\n\n external deep_copy : t -> t = \"caml_bigint_256_deep_copy\"\nend\n\nmodule Fp = struct\n type nonrec t\n\n external size_in_bits : unit -> int = \"caml_pasta_fp_size_in_bits\"\n\n external size : unit -> BigInt256.t = \"caml_pasta_fp_size\"\n\n external add : t -> t -> t = \"caml_pasta_fp_add\"\n\n external sub : t -> t -> t = \"caml_pasta_fp_sub\"\n\n external negate : t -> t = \"caml_pasta_fp_negate\"\n\n external mul : t -> t -> t = \"caml_pasta_fp_mul\"\n\n external div : t -> t -> t = \"caml_pasta_fp_div\"\n\n external inv : t -> t option = \"caml_pasta_fp_inv\"\n\n external square : t -> t = \"caml_pasta_fp_square\"\n\n external is_square : t -> bool = \"caml_pasta_fp_is_square\"\n\n external sqrt : t -> t option = \"caml_pasta_fp_sqrt\"\n\n external of_int : int -> t = \"caml_pasta_fp_of_int\"\n\n external to_string : t -> string = \"caml_pasta_fp_to_string\"\n\n external of_string : string -> t = \"caml_pasta_fp_of_string\"\n\n external print : t -> unit = \"caml_pasta_fp_print\"\n\n external copy : t -> t -> unit = \"caml_pasta_fp_copy\"\n\n external mut_add : t -> t -> unit = \"caml_pasta_fp_mut_add\"\n\n external mut_sub : t -> t -> unit = \"caml_pasta_fp_mut_sub\"\n\n external mut_mul : t -> t -> unit = \"caml_pasta_fp_mut_mul\"\n\n external mut_square : t -> unit = \"caml_pasta_fp_mut_square\"\n\n external compare : t -> t -> int = \"caml_pasta_fp_compare\"\n\n external equal : t -> t -> bool = \"caml_pasta_fp_equal\"\n\n external random : unit -> t = \"caml_pasta_fp_random\"\n\n external rng : int -> t = \"caml_pasta_fp_rng\"\n\n external to_bigint : t -> BigInt256.t = \"caml_pasta_fp_to_bigint\"\n\n external of_bigint : BigInt256.t -> t = \"caml_pasta_fp_of_bigint\"\n\n external two_adic_root_of_unity : unit -> t\n = \"caml_pasta_fp_two_adic_root_of_unity\"\n\n external domain_generator : int -> t = \"caml_pasta_fp_domain_generator\"\n\n external to_bytes : t -> bytes = \"caml_pasta_fp_to_bytes\"\n\n external of_bytes : bytes -> t = \"caml_pasta_fp_of_bytes\"\n\n external deep_copy : t -> t = \"caml_pasta_fp_deep_copy\"\nend\n\nmodule Fq = struct\n type nonrec t\n\n external size_in_bits : unit -> int = \"caml_pasta_fq_size_in_bits\"\n\n external size : unit -> BigInt256.t = \"caml_pasta_fq_size\"\n\n external add : t -> t -> t = \"caml_pasta_fq_add\"\n\n external sub : t -> t -> t = \"caml_pasta_fq_sub\"\n\n external negate : t -> t = \"caml_pasta_fq_negate\"\n\n external mul : t -> t -> t = \"caml_pasta_fq_mul\"\n\n external div : t -> t -> t = \"caml_pasta_fq_div\"\n\n external inv : t -> t option = \"caml_pasta_fq_inv\"\n\n external square : t -> t = \"caml_pasta_fq_square\"\n\n external is_square : t -> bool = \"caml_pasta_fq_is_square\"\n\n external sqrt : t -> t option = \"caml_pasta_fq_sqrt\"\n\n external of_int : int -> t = \"caml_pasta_fq_of_int\"\n\n external to_string : t -> string = \"caml_pasta_fq_to_string\"\n\n external of_string : string -> t = \"caml_pasta_fq_of_string\"\n\n external print : t -> unit = \"caml_pasta_fq_print\"\n\n external copy : t -> t -> unit = \"caml_pasta_fq_copy\"\n\n external mut_add : t -> t -> unit = \"caml_pasta_fq_mut_add\"\n\n external mut_sub : t -> t -> unit = \"caml_pasta_fq_mut_sub\"\n\n external mut_mul : t -> t -> unit = \"caml_pasta_fq_mut_mul\"\n\n external mut_square : t -> unit = \"caml_pasta_fq_mut_square\"\n\n external compare : t -> t -> int = \"caml_pasta_fq_compare\"\n\n external equal : t -> t -> bool = \"caml_pasta_fq_equal\"\n\n external random : unit -> t = \"caml_pasta_fq_random\"\n\n external rng : int -> t = \"caml_pasta_fq_rng\"\n\n external to_bigint : t -> BigInt256.t = \"caml_pasta_fq_to_bigint\"\n\n external of_bigint : BigInt256.t -> t = \"caml_pasta_fq_of_bigint\"\n\n external two_adic_root_of_unity : unit -> t\n = \"caml_pasta_fq_two_adic_root_of_unity\"\n\n external domain_generator : int -> t = \"caml_pasta_fq_domain_generator\"\n\n external to_bytes : t -> bytes = \"caml_pasta_fq_to_bytes\"\n\n external of_bytes : bytes -> t = \"caml_pasta_fq_of_bytes\"\n\n external deep_copy : t -> t = \"caml_pasta_fq_deep_copy\"\nend\n\nmodule Vesta = struct\n module BaseField = struct\n type nonrec t = Fq.t\n end\n\n module ScalarField = struct\n type nonrec t = Fp.t\n end\n\n module Affine = struct\n type nonrec t = Fq.t Kimchi_types.or_infinity\n end\n\n type nonrec t\n\n external one : unit -> t = \"caml_vesta_one\"\n\n external add : t -> t -> t = \"caml_vesta_add\"\n\n external sub : t -> t -> t = \"caml_vesta_sub\"\n\n external negate : t -> t = \"caml_vesta_negate\"\n\n external double : t -> t = \"caml_vesta_double\"\n\n external scale : t -> Fp.t -> t = \"caml_vesta_scale\"\n\n external random : unit -> t = \"caml_vesta_random\"\n\n external rng : int -> t = \"caml_vesta_rng\"\n\n external endo_base : unit -> Fq.t = \"caml_vesta_endo_base\"\n\n external endo_scalar : unit -> Fp.t = \"caml_vesta_endo_scalar\"\n\n external to_affine : t -> Fq.t Kimchi_types.or_infinity\n = \"caml_vesta_to_affine\"\n\n external of_affine : Fq.t Kimchi_types.or_infinity -> t\n = \"caml_vesta_of_affine\"\n\n external of_affine_coordinates : Fq.t -> Fq.t -> t\n = \"caml_vesta_of_affine_coordinates\"\n\n external deep_copy :\n Fq.t Kimchi_types.or_infinity -> Fq.t Kimchi_types.or_infinity\n = \"caml_vesta_affine_deep_copy\"\nend\n\nmodule Pallas = struct\n module BaseField = struct\n type nonrec t = Fp.t\n end\n\n module ScalarField = struct\n type nonrec t = Fq.t\n end\n\n module Affine = struct\n type nonrec t = Fp.t Kimchi_types.or_infinity\n end\n\n type nonrec t\n\n external one : unit -> t = \"caml_pallas_one\"\n\n external add : t -> t -> t = \"caml_pallas_add\"\n\n external sub : t -> t -> t = \"caml_pallas_sub\"\n\n external negate : t -> t = \"caml_pallas_negate\"\n\n external double : t -> t = \"caml_pallas_double\"\n\n external scale : t -> Fq.t -> t = \"caml_pallas_scale\"\n\n external random : unit -> t = \"caml_pallas_random\"\n\n external rng : int -> t = \"caml_pallas_rng\"\n\n external endo_base : unit -> Fp.t = \"caml_pallas_endo_base\"\n\n external endo_scalar : unit -> Fq.t = \"caml_pallas_endo_scalar\"\n\n external to_affine : t -> Fp.t Kimchi_types.or_infinity\n = \"caml_pallas_to_affine\"\n\n external of_affine : Fp.t Kimchi_types.or_infinity -> t\n = \"caml_pallas_of_affine\"\n\n external of_affine_coordinates : Fp.t -> Fp.t -> t\n = \"caml_pallas_of_affine_coordinates\"\n\n external deep_copy :\n Fp.t Kimchi_types.or_infinity -> Fp.t Kimchi_types.or_infinity\n = \"caml_pallas_affine_deep_copy\"\nend\n","open Core_kernel\n\ntype 'a t = 'a * 'a [@@deriving bin_io, sexp, eq, compare]\n\nlet map (x1, x2) ~f = (f x1, f x2)\n\nlet map2 (x1, x2) (y1, y2) ~f = (f x1 y1, f x2 y2)\n\nlet iter (x1, x2) ~f = f x1 ; f x2\n","open Core_kernel\n\nmodule type S = sig\n type 'a t [@@deriving bin_io, sexp, eq, compare]\n\n val iter : 'a t -> f:('a -> unit) -> unit\n\n val map : 'a t -> f:('a -> 'b) -> 'b t\n\n val map2 : 'a t -> 'b t -> f:('a -> 'b -> 'c) -> 'c t\nend\n","open Core_kernel\n\ntype t = Zero | One | Two | Three [@@deriving sexp, eq, bin_io, hash]\n\nlet of_bits_lsb : bool Double.t -> t = function\n | false, false ->\n Zero\n | true, false ->\n One\n | false, true ->\n Two\n | true, true ->\n Three\n","open Core_kernel\n\ntype 'a t = 'a * 'a * 'a * 'a [@@deriving bin_io, sexp, eq, compare]\n\nlet get ((x0, x1, x2, x3) : 'a t) (i : Four.t) =\n match i with Zero -> x0 | One -> x1 | Two -> x2 | Three -> x3\n\nlet map (x1, x2, x3, x4) ~f = (f x1, f x2, f x3, f x4)\n\nlet map2 (x1, x2, x3, x4) (y1, y2, y3, y4) ~f =\n (f x1 y1, f x2 y2, f x3 y3, f x4 y4)\n\nlet iter (x1, x2, x3, x4) ~f = f x1 ; f x2 ; f x3 ; f x4\n","open Core_kernel\n\ntype 'a t = 'a * 'a * 'a [@@deriving bin_io, sexp, eq, compare]\n\nlet map (x1, x2, x3) ~f = (f x1, f x2, f x3)\n\nlet map2 (x1, x2, x3) (y1, y2, y3) ~f = (f x1 y1, f x2 y2, f x3 y3)\n\nlet iter (x1, x2, x3) ~f = f x1 ; f x2 ; f x3\n","module Double = Double\nmodule Triple = Triple\nmodule Quadruple = Quadruple\nmodule Four = Four\n","(* bits.ml *)\n\n[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Fold_lib\nopen Bitstring_lib\n\n(* Someday: Make more efficient by giving Field.unpack a length argument in\n camlsnark *)\nlet unpack_field unpack ~bit_length x = List.take (unpack x) bit_length\n\nlet bits_per_char = 8\n\nlet pad (type a) ~length ~default (bs : a Bitstring.Lsb_first.t) =\n let bs = (bs :> a list) in\n let padding = length - List.length bs in\n assert (padding >= 0) ;\n bs @ List.init padding ~f:(fun _ -> default)\n\nmodule Vector = struct\n module type Basic = sig\n type t\n\n val length : int\n\n val get : t -> int -> bool\n\n val set : t -> int -> bool -> t\n end\n\n module type S = sig\n include Basic\n\n val empty : t\n\n val set : t -> int -> bool -> t\n end\n\n module UInt64 : S with type t = Unsigned.UInt64.t = struct\n open Unsigned.UInt64.Infix\n include Unsigned.UInt64\n\n let length = 64\n\n let empty = zero\n\n let get t i = equal ((t lsr i) land one) one\n\n let set t i b = if b then t lor (one lsl i) else t land lognot (one lsl i)\n end\n\n module UInt32 : S with type t = Unsigned.UInt32.t = struct\n open Unsigned.UInt32.Infix\n include Unsigned.UInt32\n\n let length = 32\n\n let empty = zero\n\n let get t i = equal ((t lsr i) land one) one\n\n let set t i b = if b then t lor (one lsl i) else t land lognot (one lsl i)\n end\n\n module Make (V : S) : Bits_intf.Convertible_bits with type t = V.t = struct\n type t = V.t\n\n let fold t =\n { Fold.fold =\n (fun ~init ~f ->\n let rec go acc i =\n if i = V.length then acc else go (f acc (V.get t i)) (i + 1)\n in\n go init 0 )\n }\n\n let iter t ~f =\n for i = 0 to V.length - 1 do\n f (V.get t i)\n done\n\n let to_bits t = List.init V.length ~f:(V.get t)\n\n let of_bits bools =\n List.foldi bools ~init:V.empty ~f:(fun i t bool -> V.set t i bool)\n\n let size_in_bits = V.length\n end\nend\n\nmodule UInt64 : Bits_intf.Convertible_bits with type t := Unsigned.UInt64.t =\n Vector.Make (Vector.UInt64)\n\nmodule UInt32 : Bits_intf.Convertible_bits with type t := Unsigned.UInt32.t =\n Vector.Make (Vector.UInt32)\n\n[%%ifdef consensus_mechanism]\n\nmodule type Big_int_intf = sig\n include Snarky_backendless.Bigint_intf.S\n\n val to_field : t -> field\nend\n\nmodule Make_field0\n (Field : Snarky_backendless.Field_intf.S)\n (Bigint : Big_int_intf with type field := Field.t) (M : sig\n val bit_length : int\n end) : Bits_intf.S with type t = Field.t = struct\n open M\n\n type t = Field.t\n\n let fold t =\n { Fold.fold =\n (fun ~init ~f ->\n let n = Bigint.of_field t in\n let rec go acc i =\n if i = bit_length then acc\n else go (f acc (Bigint.test_bit n i)) (i + 1)\n in\n go init 0 )\n }\n\n let iter t ~f =\n let n = Bigint.of_field t in\n for i = 0 to bit_length - 1 do\n f (Bigint.test_bit n i)\n done\n\n let to_bits t =\n let n = Bigint.of_field t in\n let rec go acc i =\n if i < 0 then acc else go (Bigint.test_bit n i :: acc) (i - 1)\n in\n go [] (bit_length - 1)\n\n let size_in_bits = bit_length\nend\n\nmodule Make_field\n (Field : Snarky_backendless.Field_intf.S)\n (Bigint : Big_int_intf with type field := Field.t) :\n Bits_intf.S with type t = Field.t =\n Make_field0 (Field) (Bigint)\n (struct\n let bit_length = Field.size_in_bits\n end)\n\nmodule Small\n (Field : Snarky_backendless.Field_intf.S)\n (Bigint : Big_int_intf with type field := Field.t) (M : sig\n val bit_length : int\n end) : Bits_intf.S with type t = Field.t = struct\n let () = assert (M.bit_length < Field.size_in_bits)\n\n include Make_field0 (Field) (Bigint) (M)\nend\n\nmodule Snarkable = struct\n module Small_bit_vector\n (Impl : Snarky_backendless.Snark_intf.S) (V : sig\n type t\n\n val empty : t\n\n val length : int\n\n val get : t -> int -> bool\n\n val set : t -> int -> bool -> t\n end) :\n Bits_intf.Snarkable.Small\n with type ('a, 'b) typ := ('a, 'b) Impl.Typ.t\n and type 'a checked := 'a Impl.Checked.t\n and type boolean_var := Impl.Boolean.var\n and type field_var := Impl.Field.Var.t\n and type Packed.var = Impl.Field.Var.t\n and type Packed.value = V.t\n and type Unpacked.var = Impl.Boolean.var list\n and type Unpacked.value = V.t\n and type comparison_result := Impl.Field.Checked.comparison_result =\n struct\n open Impl\n\n let bit_length = V.length\n\n let () = assert (bit_length < Field.size_in_bits)\n\n let size_in_bits = bit_length\n\n let init ~f =\n let rec go acc i =\n if i = V.length then acc else go (V.set acc i (f i)) (i + 1)\n in\n go V.empty 0\n\n module Packed = struct\n type var = Field.Var.t\n\n type value = V.t\n\n let typ : (var, value) Typ.t =\n Field.typ\n |> Typ.transport\n ~there:(fun t ->\n let rec go two_to_the_i i acc =\n if i = V.length then acc\n else\n let acc =\n if V.get t i then Field.add two_to_the_i acc else acc\n in\n go (Field.add two_to_the_i two_to_the_i) (i + 1) acc\n in\n go Field.one 0 Field.zero )\n ~back:(fun t ->\n let n = Bigint.of_field t in\n init ~f:(fun i -> Bigint.test_bit n i) )\n\n let size_in_bits = size_in_bits\n end\n\n let v_to_list n v =\n List.init n ~f:(fun i -> if i < V.length then V.get v i else false)\n\n let v_of_list vs =\n List.foldi vs ~init:V.empty ~f:(fun i acc b ->\n if i < V.length then V.set acc i b else acc )\n\n let pack_var = Field.Var.project\n\n let pack_value = Fn.id\n\n module Unpacked = struct\n type var = Boolean.var list\n\n type value = V.t\n\n let typ : (var, value) Typ.t =\n Typ.transport\n (Typ.list ~length:V.length Boolean.typ)\n ~there:(v_to_list V.length) ~back:v_of_list\n\n let var_to_bits = Bitstring.Lsb_first.of_list\n\n let var_of_bits = pad ~length:V.length ~default:Boolean.false_\n\n let var_to_triples (bs : var) =\n Bitstring_lib.Bitstring.pad_to_triple_list ~default:Boolean.false_ bs\n\n let var_of_value v =\n List.init V.length ~f:(fun i -> Boolean.var_of_value (V.get v i))\n\n let size_in_bits = size_in_bits\n end\n\n let unpack_var x = Impl.Field.Checked.unpack x ~length:bit_length\n\n let var_of_field = unpack_var\n\n let var_of_field_unsafe = Fn.id\n\n let unpack_value (x : Packed.value) : Unpacked.value = x\n\n let compare_var x y =\n Impl.Field.Checked.compare ~bit_length:V.length (pack_var x) (pack_var y)\n\n let%snarkydef_ increment_if_var bs (b : Boolean.var) =\n let open Impl in\n let v = Field.Var.pack bs in\n let v' = Field.Var.add v (b :> Field.Var.t) in\n Field.Checked.unpack v' ~length:V.length\n\n let%snarkydef_ increment_var bs =\n let open Impl in\n let v = Field.Var.pack bs in\n let v' = Field.Var.add v (Field.Var.constant Field.one) in\n Field.Checked.unpack v' ~length:V.length\n\n let%snarkydef_ equal_var (n : Unpacked.var) (n' : Unpacked.var) =\n Field.Checked.equal (pack_var n) (pack_var n')\n\n let%snarkydef_ assert_equal_var (n : Unpacked.var) (n' : Unpacked.var) =\n Field.Checked.Assert.equal (pack_var n) (pack_var n')\n\n let if_ (cond : Boolean.var) ~(then_ : Unpacked.var) ~(else_ : Unpacked.var)\n : Unpacked.var Checked.t =\n match\n List.map2 then_ else_ ~f:(fun then_ else_ ->\n Boolean.if_ cond ~then_ ~else_ )\n with\n | Ok result ->\n Checked.List.all result\n | Unequal_lengths ->\n failwith \"Bits.if_: unpacked bit lengths were unequal\"\n end\n\n module UInt64 (Impl : Snarky_backendless.Snark_intf.S) =\n Small_bit_vector (Impl) (Vector.UInt64)\n module UInt32 (Impl : Snarky_backendless.Snark_intf.S) =\n Small_bit_vector (Impl) (Vector.UInt32)\n\n module Field_backed\n (Impl : Snarky_backendless.Snark_intf.S) (M : sig\n val bit_length : int\n end) =\n struct\n open Impl\n include M\n\n let size_in_bits = bit_length\n\n module Packed = struct\n type var = Field.Var.t\n\n type value = Field.t\n\n let typ = Typ.field\n\n let assert_equal = Field.Checked.Assert.equal\n\n let size_in_bits = size_in_bits\n end\n\n module Unpacked = struct\n type var = Boolean.var list\n\n type value = Field.t\n\n let typ : (var, value) Typ.t =\n Typ.transport\n (Typ.list ~length:bit_length Boolean.typ)\n ~there:(unpack_field Field.unpack ~bit_length)\n ~back:Field.project\n\n let var_to_bits = Bitstring_lib.Bitstring.Lsb_first.of_list\n\n let var_of_bits = pad ~length:bit_length ~default:Boolean.false_\n\n let var_to_triples (bs : var) =\n Bitstring_lib.Bitstring.pad_to_triple_list ~default:Boolean.false_ bs\n\n let var_of_value v =\n unpack_field Field.unpack ~bit_length v\n |> List.map ~f:Boolean.var_of_value\n\n let size_in_bits = size_in_bits\n end\n\n let project_value = Fn.id\n\n let project_var = Field.Var.project\n\n let choose_preimage_var : Packed.var -> Unpacked.var Checked.t =\n Field.Checked.choose_preimage_var ~length:bit_length\n\n let unpack_value = Fn.id\n end\n\n module Field (Impl : Snarky_backendless.Snark_intf.S) :\n Bits_intf.Snarkable.Lossy\n with type ('a, 'b) typ := ('a, 'b) Impl.Typ.t\n and type 'a checked := 'a Impl.Checked.t\n and type boolean_var := Impl.Boolean.var\n and type Packed.var = Impl.Field.Var.t\n and type Packed.value = Impl.Field.t\n and type Unpacked.var = Impl.Boolean.var list\n and type Unpacked.value = Impl.Field.t =\n Field_backed\n (Impl)\n (struct\n let bit_length = Impl.Field.size_in_bits\n end)\n\n module Small\n (Impl : Snarky_backendless.Snark_intf.S) (M : sig\n val bit_length : int\n end) :\n Bits_intf.Snarkable.Faithful\n with type ('a, 'b) typ := ('a, 'b) Impl.Typ.t\n and type 'a checked := 'a Impl.Checked.t\n and type boolean_var := Impl.Boolean.var\n and type Packed.var = Impl.Field.Var.t\n and type Packed.value = Impl.Field.t\n and type Unpacked.var = Impl.Boolean.var list\n and type Unpacked.value = Impl.Field.t = struct\n let () = assert (M.bit_length < Impl.Field.size_in_bits)\n\n include Field_backed (Impl) (M)\n\n let pack_var bs =\n assert (Mina_stdlib.List.Length.Compare.(bs = M.bit_length)) ;\n project_var bs\n\n let pack_value = Fn.id\n\n let unpack_var = Impl.Field.Checked.unpack ~length:M.bit_length\n end\nend\n\nmodule Make_unpacked\n (Impl : Snarky_backendless.Snark_intf.S) (M : sig\n val bit_length : int\n end) =\nstruct\n open Impl\n\n module T = struct\n type var = Boolean.var list\n\n type value = Boolean.value list\n end\n\n include T\n\n let typ : (var, value) Typ.t = Typ.list ~length:M.bit_length Boolean.typ\nend\n\n[%%endif]\n","open Core_kernel\n\nmodule Interval = struct\n (* Semantically (a, b) : t is the closed interval [a, b] *)\n type t = int * int [@@deriving eq, sexp]\n\n let before (_, b1) (a2, _) = b1 <= a2\n\n let gen_from start =\n let open Quickcheck.Generator.Let_syntax in\n let%bind x = Int.gen_incl start Int.max_value_30_bits in\n let%map y = Int.gen_incl x Int.max_value_30_bits in\n (x, y)\n\n let gen =\n let open Quickcheck.Generator.Let_syntax in\n let%bind x = Int.gen_incl Int.min_value Int.max_value_30_bits in\n let%map y = Int.gen_incl x Int.max_value_30_bits in\n (x, y)\n\n let%test_unit \"gen is correct\" =\n Quickcheck.test gen ~f:(fun (x, y) -> assert (x <= y))\nend\n\n(* Simplest possible implementation. Should be an increasing list of\n disjoint intervals.\n Semantically is the set of ints corresponding to the union of these\n ntervals. *)\ntype t = Interval.t list [@@deriving eq, sexp]\n\nlet empty : t = []\n\nlet union_intervals_exn (a1, b1) (a2, b2) =\n let ( = ) = Int.( = ) in\n if b1 = a2 then `Combine (a1, b2)\n else if b2 = a1 then `Combine (a2, b1)\n else if b1 < a2 then `Disjoint_ordered\n else if b2 < a1 then `Disjoint_inverted\n else failwithf \"Intervals not disjoint: (%d, %d) and (%d, %d)\" a1 b1 a2 b2 ()\n\nlet of_interval i = [ i ]\n\nlet rec canonicalize = function\n | [] ->\n []\n | [ i1 ] ->\n [ i1 ]\n | (a1, a2) :: (a3, a4) :: t ->\n if a2 = a3 then canonicalize ((a1, a4) :: t)\n else (a1, a2) :: canonicalize ((a3, a4) :: t)\n\nlet rec disjoint_union_exn t1 t2 =\n match (t1, t2) with\n | t, [] | [], t ->\n t\n | i1 :: t1', i2 :: t2' -> (\n match union_intervals_exn i1 i2 with\n | `Combine (a, b) ->\n (a, b) :: disjoint_union_exn t1' t2'\n | `Disjoint_ordered ->\n i1 :: disjoint_union_exn t1' t2\n | `Disjoint_inverted ->\n i2 :: disjoint_union_exn t1 t2' )\n\nlet disjoint_union_exn t1 t2 = canonicalize (disjoint_union_exn t1 t2)\n\nlet rec disjoint t1 t2 =\n match (t1, t2) with\n | _, [] | [], _ ->\n true\n | i1 :: t1', i2 :: t2' ->\n if Interval.before i1 i2 then disjoint t1' t2\n else if Interval.before i2 i1 then disjoint t1 t2'\n else false\n\n(* Someday: inefficient *)\nlet of_intervals_exn is =\n match is with\n | [] ->\n []\n | i :: is ->\n List.fold is ~init:(of_interval i) ~f:(fun acc x ->\n disjoint_union_exn (of_interval x) acc )\n\nlet to_interval = function\n | [ i ] ->\n Ok i\n | [] ->\n Or_error.error_string \"Interval_union.to_interval: the union is empty\\n\"\n | _ :: _ :: _ as xs ->\n Or_error.error_string\n (Printf.sprintf\n !\"Interval_union.to_interval: expected a single interval in the \\\n union, got multiple disjoint intervals %{sexp: Interval.t list}\\n\"\n xs )\n\nlet right_endpoint t = Option.map ~f:snd (List.last t)\n\nlet left_endpoint t = Option.map ~f:fst (List.hd t)\n\nlet invariant t =\n let rec go = function\n | [ (a, b) ] ->\n assert (a <= b)\n | [] ->\n ()\n | (a1, b1) :: ((a2, _) :: _ as t) ->\n assert (a1 <= b1) ;\n assert (b1 < a2) ;\n go t\n in\n go t\n\nlet gen_from ?(min_size = 0) start =\n let open Quickcheck.Generator.Let_syntax in\n let rec go acc size start =\n if size = 0 then return (of_intervals_exn (List.rev acc))\n else\n let%bind ((_, y) as i) = Interval.gen_from start in\n go (i :: acc) (size - 1) y\n in\n let%bind size = Quickcheck.Generator.small_positive_int in\n go [] (min_size + size) start\n\nlet gen = gen_from Int.min_value\n\nlet%test_unit \"check invariant\" = Quickcheck.test gen ~f:invariant\n\nlet gen_disjoint_pair =\n let open Quickcheck.Generator.Let_syntax in\n let%bind t1 = gen in\n let y = List.last_exn t1 |> snd in\n let%map t2 = gen_from y in\n (t1, t2)\n\nlet%test_unit \"canonicalize\" =\n assert (equal (canonicalize [ (1, 2); (2, 3) ]) [ (1, 3) ])\n\nlet%test_unit \"disjoint union doesn't care about order\" =\n Quickcheck.test gen_disjoint_pair ~f:(fun (a, b) ->\n assert (equal (disjoint_union_exn a b) (disjoint_union_exn b a)) )\n\nlet%test_unit \"check invariant on disjoint union\" =\n Quickcheck.test gen_disjoint_pair ~f:(fun (a, b) ->\n invariant (disjoint_union_exn a b) )\n\nlet%test_unit \"disjoint_union works with holes\" =\n let gen =\n let open Quickcheck.Generator.Let_syntax in\n let s = 1000000 in\n let%bind y0 = Int.gen_incl 0 s in\n let%bind y1 = Int.gen_incl (y0 + 1) (y0 + s) in\n let%bind y2 = Int.gen_incl (y1 + 1) (y1 + s) in\n let%bind y3 = Int.gen_incl (y2 + 1) (y2 + s) in\n return (of_interval (y1, y2), of_intervals_exn [ (y0, y1); (y2, y3) ])\n in\n Quickcheck.test gen ~f:(fun (x, y) -> invariant (disjoint_union_exn x y))\n","open Core_kernel\n\ntype t = Big_int.big_int\n\nlet equal = Big_int.eq_big_int\n\nlet num_bits = Big_int.num_bits_big_int\n\nlet shift_right = Big_int.shift_right_big_int\n\nlet shift_left = Big_int.shift_left_big_int\n\nlet log_and = Big_int.and_big_int\n\nlet log_or = Big_int.or_big_int\n\nlet of_int = Big_int.big_int_of_int\n\nlet test_bit t i =\n equal (log_and Big_int.unit_big_int (shift_right t i)) Big_int.unit_big_int\n\nlet to_bytes x =\n let n = num_bits x in\n let num_bytes = (n + 7) / 8 in\n String.init num_bytes ~f:(fun byte ->\n let c i =\n let bit = (8 * byte) + i in\n if test_bit x bit then 1 lsl i else 0\n in\n Char.of_int_exn\n (c 0 lor c 1 lor c 2 lor c 3 lor c 4 lor c 5 lor c 6 lor c 7) )\n\nlet of_bytes x =\n String.foldi x ~init:Big_int.zero_big_int ~f:(fun i acc c ->\n log_or acc (shift_left (of_int (Char.to_int c)) (8 * i)) )\n\nlet ( + ) = Big_int.add_big_int\n\nlet ( - ) = Big_int.sub_big_int\n\nlet ( * ) = Big_int.mult_big_int\n\nlet ( % ) = Big_int.mod_big_int\n\nlet ( // ) = Big_int.div_big_int\n\nlet ( < ) = Big_int.lt_big_int\n\nlet to_int_exn = Big_int.int_of_big_int\n\nlet compare = Big_int.compare_big_int\n\nmodule String_hum = struct\n type nonrec t = t\n\n let of_string = Big_int.big_int_of_string\n\n let to_string = Big_int.string_of_big_int\nend\n\ninclude Sexpable.Of_stringable (String_hum)\n\ninclude (String_hum : Stringable.S with type t := t)\n\nlet hash t = Stdlib.Hashtbl.hash t\n\nlet hash_fold_t h t = hash_fold_int h (hash t)\n\nlet to_yojson t = `String (to_string t)\n\nlet of_yojson = function\n | `String s ->\n Ok (of_string s)\n | _ ->\n Error \"Nat.of_yojson: Expected string\"\n\n[@@@alert \"-legacy\"]\n\n(** this serialization is not used for fields *)\ninclude Binable.Of_stringable_without_uuid (struct\n type nonrec t = t\n\n let of_string = of_bytes\n\n let to_string = to_bytes\nend)\n","type ('var, 'value) t = { var : 'var; mutable value : 'value option }\n\nlet var { var; _ } = var\n","(** The usual Janestreet [Monad] interfaces, with [Let_syntax] included in the\n monad module. *)\nopen Core_kernel\n\nopen Monad\n\nmodule type Let_syntax = sig\n type 'a t\n\n val return : 'a -> 'a t\n\n val bind : 'a t -> f:('a -> 'b t) -> 'b t\n\n val map : 'a t -> f:('a -> 'b) -> 'b t\n\n val both : 'a t -> 'b t -> ('a * 'b) t\n\n module Open_on_rhs : sig end\nend\n\nmodule type Base_syntax = sig\n type 'a t\n\n val return : 'a -> 'a t\n\n include Infix with type 'a t := 'a t\nend\n\nmodule type Syntax = sig\n include Base_syntax\n\n include Let_syntax with type 'a t := 'a t\nend\n\nmodule type S = sig\n type 'a t\n\n include S_without_syntax with type 'a t := 'a t\n\n module Let_syntax : sig\n include Base_syntax with type 'a t := 'a t\n\n include Let_syntax with type 'a t := 'a t\n\n module Let_syntax : Let_syntax with type 'a t := 'a t\n end\nend\n\nmodule type Let_syntax2 = sig\n type ('a, 'e) t\n\n val return : 'a -> ('a, 'e) t\n\n val bind : ('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t\n\n val map : ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t\n\n val both : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t\n\n module Open_on_rhs : sig end\nend\n\nmodule type Base_syntax2 = sig\n type ('a, 'e) t\n\n val return : 'a -> ('a, 'e) t\n\n include Infix2 with type ('a, 'e) t := ('a, 'e) t\nend\n\nmodule type Syntax2 = sig\n include Base_syntax2\n\n include Let_syntax2 with type ('a, 'e) t := ('a, 'e) t\nend\n\nmodule type S_without_syntax2 = sig\n type ('a, 'e) t\n\n include Infix2 with type ('a, 'e) t := ('a, 'e) t\n\n module Monad_infix : Infix2 with type ('a, 'e) t := ('a, 'e) t\n\n val bind : ('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t\n\n val return : 'a -> ('a, _) t\n\n val map : ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t\n\n val join : (('a, 'e) t, 'e) t -> ('a, 'e) t\n\n val ignore_m : (_, 'e) t -> (unit, 'e) t\n\n val all : ('a, 'e) t list -> ('a list, 'e) t\n\n val all_unit : (unit, 'e) t list -> (unit, 'e) t\nend\n\nmodule type S2 = sig\n type ('a, 'e) t\n\n include S_without_syntax2 with type ('a, 'e) t := ('a, 'e) t\n\n module Let_syntax : sig\n include Base_syntax2 with type ('a, 'e) t := ('a, 'e) t\n\n include Let_syntax2 with type ('a, 'e) t := ('a, 'e) t\n\n module Let_syntax : Let_syntax2 with type ('a, 'e) t := ('a, 'e) t\n end\nend\n\nmodule type Let_syntax3 = sig\n type ('a, 'd, 'e) t\n\n val return : 'a -> ('a, 'd, 'e) t\n\n val bind : ('a, 'd, 'e) t -> f:('a -> ('b, 'd, 'e) t) -> ('b, 'd, 'e) t\n\n val map : ('a, 'd, 'e) t -> f:('a -> 'b) -> ('b, 'd, 'e) t\n\n val both : ('a, 'd, 'e) t -> ('b, 'd, 'e) t -> ('a * 'b, 'd, 'e) t\n\n module Open_on_rhs : sig end\nend\n\nmodule type Base_syntax3 = sig\n type ('a, 'd, 'e) t\n\n val return : 'a -> ('a, 'd, 'e) t\n\n include Infix3 with type ('a, 'd, 'e) t := ('a, 'd, 'e) t\nend\n\nmodule type Syntax3 = sig\n include Base_syntax3\n\n include Let_syntax3 with type ('a, 'd, 'e) t := ('a, 'd, 'e) t\nend\n\nmodule type S_without_syntax3 = sig\n type ('a, 'd, 'e) t\n\n include Infix3 with type ('a, 'd, 'e) t := ('a, 'd, 'e) t\n\n module Monad_infix : Infix3 with type ('a, 'd, 'e) t := ('a, 'd, 'e) t\n\n val bind : ('a, 'd, 'e) t -> f:('a -> ('b, 'd, 'e) t) -> ('b, 'd, 'e) t\n\n val return : 'a -> ('a, _, _) t\n\n val map : ('a, 'd, 'e) t -> f:('a -> 'b) -> ('b, 'd, 'e) t\n\n val join : (('a, 'd, 'e) t, 'd, 'e) t -> ('a, 'd, 'e) t\n\n val ignore_m : (_, 'd, 'e) t -> (unit, 'd, 'e) t\n\n val all : ('a, 'd, 'e) t list -> ('a list, 'd, 'e) t\n\n val all_unit : (unit, 'd, 'e) t list -> (unit, 'd, 'e) t\nend\n\nmodule type S3 = sig\n type ('a, 'd, 'e) t\n\n include S_without_syntax3 with type ('a, 'd, 'e) t := ('a, 'd, 'e) t\n\n module Let_syntax : sig\n include Base_syntax3 with type ('a, 'd, 'e) t := ('a, 'd, 'e) t\n\n include Let_syntax3 with type ('a, 'd, 'e) t := ('a, 'd, 'e) t\n\n module Let_syntax : Let_syntax3 with type ('a, 'd, 'e) t := ('a, 'd, 'e) t\n end\nend\n\nmodule Make3 (X : Monad.Basic3) :\n S3 with type ('a, 'd, 'e) t := ('a, 'd, 'e) X.t = struct\n include X\n module M = Monad.Make3 (X)\n module Let = M.Let_syntax.Let_syntax\n\n [@@@warning \"-3\"]\n\n include (M : S_without_syntax3 with type ('a, 'd, 'e) t := ('a, 'd, 'e) t)\n\n module Let_syntax = struct\n include (\n M.Let_syntax : Base_syntax3 with type ('a, 'd, 'e) t := ('a, 'd, 'e) t )\n\n include (Let : Let_syntax3 with type ('a, 'd, 'e) t := ('a, 'd, 'e) t)\n\n module Let_syntax = Let\n end\nend\n\nmodule Make2 (X : Monad.Basic2) : S2 with type ('a, 'e) t := ('a, 'e) X.t =\nMake3 (struct\n type ('a, 'd, 'e) t = ('a, 'e) X.t\n\n include (X : Monad.Basic3 with type ('a, 'd, 'e) t := ('a, 'e) X.t)\nend)\n\nmodule Make (X : Monad.Basic) : S with type 'a t := 'a X.t = Make2 (struct\n type ('a, 'e) t = 'a X.t\n\n include (X : Monad.Basic2 with type ('a, 'e) t := 'a X.t)\nend)\n","type _ t = ..\n\ntype _ t += Fail : 'a t\n\ntype 'a req = 'a t\n\ntype response = ..\n\ntype response += Unhandled\n\nlet unhandled = Unhandled\n\nmodule Response = struct\n type 'a t = Provide of 'a | Delegate of 'a req | Unhandled\nend\n\ntype request =\n | With : { request : 'a t; respond : 'a Response.t -> response } -> request\n\nmodule Handler = struct\n type single = { handle : 'a. 'a t -> 'a Response.t }\n\n type t = single list\n\n let fail = []\n\n let run : t -> string list -> 'a req -> 'a =\n fun stack0 label_stack req0 ->\n let rec go req = function\n | [] ->\n failwith\n ( \"Unhandled request: \"\n ^ Core_kernel.String.concat ~sep:\"\\n\" label_stack )\n | { handle } :: hs -> (\n match handle req with\n | Provide x ->\n x\n | Delegate req' ->\n go req' hs\n | Unhandled ->\n go req hs )\n in\n go req0 stack0\n\n let create_single (handler : request -> response) : single =\n let handle : type a. a req -> a Response.t =\n fun request ->\n let module T = struct\n type response += T of a Response.t\n end in\n match handler (With { request; respond = (fun x -> T.T x) }) with\n | T.T x ->\n x\n | _ ->\n Response.Unhandled\n in\n { handle }\n\n let push (t : t) (single : single) : t = single :: t\nend\n","open Core_kernel\n\nmodule Make (Field : sig\n type t [@@deriving sexp]\n\n val equal : t -> t -> bool\nend)\n(Basic : Checked_intf.Basic with type 'f field = Field.t)\n(As_prover : As_prover_intf.Basic with type 'f field := 'f Basic.field) :\n Checked_intf.S\n with module Types = Basic.Types\n with type 'f field = 'f Basic.field = struct\n include Basic\n\n let request_witness (typ : ('var, 'value, 'f field) Types.Typ.t)\n (r : ('value Request.t, 'f field) As_prover.t) =\n let%map h = exists typ (Request r) in\n Handle.var h\n\n let request ?such_that typ r =\n match such_that with\n | None ->\n request_witness typ (As_prover.return r)\n | Some such_that ->\n let open Let_syntax in\n let%bind x = request_witness typ (As_prover.return r) in\n let%map () = such_that x in\n x\n\n let exists_handle ?request ?compute typ =\n let provider =\n let request =\n Option.value request ~default:(As_prover.return Request.Fail)\n in\n match compute with\n | None ->\n Types.Provider.Request request\n | Some c ->\n Types.Provider.Both (request, c)\n in\n exists typ provider\n\n let exists ?request ?compute typ =\n let%map h = exists_handle ?request ?compute typ in\n Handle.var h\n\n type response = Request.response\n\n let unhandled = Request.unhandled\n\n type request = Request.request =\n | With :\n { request : 'a Request.t; respond : 'a Request.Response.t -> response }\n -> request\n\n let handle t k = with_handler (Request.Handler.create_single k) t\n\n let handle_as_prover t k =\n let handler = ref None in\n let%bind () =\n as_prover\n As_prover.(\n let%map h = k in\n handler := Some h)\n in\n handle t (fun request -> (Option.value_exn !handler) request)\n\n let assert_ ?label c = add_constraint (Constraint.override_label c label)\n\n let assert_r1cs ?label a b c = assert_ (Constraint.r1cs ?label a b c)\n\n let assert_square ?label a c = assert_ (Constraint.square ?label a c)\n\n let assert_all ?label cs =\n List.fold_right cs ~init:(return ()) ~f:(fun c (acc : _ t) ->\n bind acc ~f:(fun () ->\n add_constraint (Constraint.override_label c label) ) )\n\n let assert_equal ?label x y =\n match (x, y) with\n | Cvar.Constant x, Cvar.Constant y ->\n if Field.equal x y then return ()\n else\n failwithf !\"assert_equal: %{sexp: Field.t} != %{sexp: Field.t}\" x y ()\n | _ ->\n assert_ (Constraint.equal ?label x y)\nend\n","module As_prover = struct\n type ('a, 'f) t = ('f Cvar.t -> 'f) -> 'a\nend\n\nmodule Provider = struct\n module T = struct\n (** The different ways to generate a value for the circuit witness.\n\n If [Both], this attempts the request first, and falls back on compute\n if the request is unhandled or raises an exception.\n *)\n type ('request, 'compute) provider =\n | Request of 'request\n | Compute of 'compute\n | Both of 'request * 'compute\n end\n\n include T\n\n type ('request, 'compute) t = ('request, 'compute) provider\nend\n\nmodule Typ = struct\n module T = struct\n (** The type [('var, 'value, 'field, 'checked) t] describes a mapping from\n OCaml types to the variables and constraints they represent:\n - ['value] is the OCaml type\n - ['field] is the type of the field elements\n - ['var] is some other type that contains some R1CS variables\n - ['checked] is the type of checked computation that verifies the stored\n contents as R1CS variables.\n\n For convenience and readability, it is usually best to have the ['var]\n type mirror the ['value] type in structure, for example:\n{[\n type t = {b1 : bool; b2 : bool} (* 'value *)\n\n let or (x : t) = x.b1 || x.b2\n\n module Checked = struct\n type t = {b1 : Snark.Boolean.var; b2 : Snark.Boolean.var} (* 'var *)\n\n let or (x : t) = Snark.Boolean.(x.b1 || x.b2)\n end\n]}*)\n type ('var, 'value, 'aux, 'field, 'checked) typ' =\n { var_to_fields : 'var -> 'field Cvar.t array * 'aux\n ; var_of_fields : 'field Cvar.t array * 'aux -> 'var\n ; value_to_fields : 'value -> 'field array * 'aux\n ; value_of_fields : 'field array * 'aux -> 'value\n ; size_in_field_elements : int\n ; constraint_system_auxiliary : unit -> 'aux\n ; check : 'var -> 'checked\n }\n\n type ('var, 'value, 'field, 'checked) typ =\n | Typ :\n ('var, 'value, 'aux, 'field, 'checked) typ'\n -> ('var, 'value, 'field, 'checked) typ\n end\n\n include T\n\n type ('var, 'value, 'field, 'checked) t = ('var, 'value, 'field, 'checked) typ\nend\n\nmodule type Types = sig\n module Checked : sig\n type ('a, 'f) t\n end\n\n module Typ : sig\n include module type of Typ.T\n\n type ('var, 'value, 'f) t = ('var, 'value, 'f, (unit, 'f) Checked.t) Typ.t\n end\n\n module Provider : sig\n include module type of Provider.T\n\n type ('a, 'f) t =\n (('a Request.t, 'f) As_prover.t, ('a, 'f) As_prover.t) provider\n end\nend\n","open Core_kernel\n\ntype ('a, 'f) t = ('a, 'f) Types.As_prover.t\n\nlet map t ~f tbl =\n let x = t tbl in\n f x\n\nlet bind t ~f tbl =\n let x = t tbl in\n f x tbl\n\nlet return x _ = x\n\nlet run t tbl = t tbl\n\nlet get_state _tbl s = (s, s)\n\nlet set_state s _tbl _ = (s, ())\n\nlet modify_state f _tbl s = (f s, ())\n\nlet map2 x y ~f tbl =\n let x = x tbl in\n let y = y tbl in\n f x y\n\nlet read_var (v : 'var) : ('field, 'field) t = fun tbl -> tbl v\n\nlet read\n (Typ { var_to_fields; value_of_fields; _ } :\n ('var, 'value, 'field, _) Types.Typ.t ) (var : 'var) : ('value, 'field) t\n =\n fun tbl ->\n let field_vars, aux = var_to_fields var in\n let fields = Array.map ~f:tbl field_vars in\n value_of_fields (fields, aux)\n\ninclude Monad_let.Make2 (struct\n type nonrec ('a, 'e) t = ('a, 'e) t\n\n let map = `Custom map\n\n let bind = bind\n\n let return = return\nend)\n\nmodule Provider = struct\n (** The different ways to generate a value of type ['a] for a circuit\n witness over field ['f].\n\n This is one of:\n * a [Request], dispatching an ['a Request.t];\n * [Compute], running a computation to generate the value;\n * [Both], attempting to dispatch an ['a Request.t], and falling back to\n the computation if the request is unhandled or raises an exception.\n *)\n type nonrec ('a, 'f) t = (('a Request.t, 'f) t, ('a, 'f) t) Types.Provider.t\n\n open Types.Provider\n\n let run t stack tbl (handler : Request.Handler.t) =\n match t with\n | Request rc ->\n let r = run rc tbl in\n Request.Handler.run handler stack r\n | Compute c ->\n run c tbl\n | Both (rc, c) -> (\n let r = run rc tbl in\n match Request.Handler.run handler stack r with\n | exception _ ->\n run c tbl\n | x ->\n x )\nend\n\nmodule Handle = struct\n let value (t : ('var, 'value) Handle.t) : ('value, 'field) t =\n fun _ -> Option.value_exn t.value\nend\n\nmodule type Extended = sig\n type field\n\n include As_prover_intf.Basic with type 'f field := field\n\n type nonrec 'a t = ('a, field) t\nend\n\nmodule Make_extended (Env : sig\n type field\nend)\n(As_prover : As_prover_intf.Basic with type 'f field := Env.field) =\nstruct\n include Env\n include As_prover\n\n type nonrec 'a t = ('a, field) t\nend\n","module Vector = struct\n open Core_kernel\n\n type 'elt t =\n | T :\n (module Snarky_intf.Vector.S with type elt = 'elt and type t = 't)\n * 't Type_equal.Id.t\n * 't\n -> 'elt t\n\n let unit = Type_equal.Id.create ~name:\"unit\" Unit.sexp_of_t\n\n let null : type a. a t =\n let module T = struct\n type elt = a\n\n type t = unit\n\n let create () = ()\n\n let get _ _ = failwith \"Vector.null: get\"\n\n let emplace_back _ _ = failwith \"Vector.null: emplace_back\"\n\n let length () = 0\n end in\n T ((module T), unit, ())\n\n let get (type x) (T ((module T), _, t) : x t) i = T.get t i\n\n let emplace_back (type x) (T ((module T), _, t) : x t) x = T.emplace_back t x\nend\n\n(** The internal state used to run a checked computation. *)\ntype 'field t =\n { system : 'field Constraint_system.t option\n ; input : 'field Vector.t\n ; aux : 'field Vector.t\n ; eval_constraints : bool\n ; num_inputs : int\n ; next_auxiliary : int ref\n ; has_witness : bool\n ; stack : string list\n ; handler : Request.Handler.t\n ; is_running : bool\n ; as_prover : bool ref\n ; log_constraint :\n ( ?at_label_boundary:[ `Start | `End ] * string\n -> ('field Cvar.t, 'field) Constraint.t option\n -> unit )\n option\n }\n\nlet make ~num_inputs ~input ~next_auxiliary ~aux ?system ~eval_constraints\n ?log_constraint ?handler ~with_witness ?(stack = []) ?(is_running = true) ()\n =\n next_auxiliary := num_inputs ;\n (* We can't evaluate the constraints if we are not computing over a value. *)\n let eval_constraints = eval_constraints && with_witness in\n { system\n ; input\n ; aux\n ; eval_constraints\n ; num_inputs\n ; next_auxiliary\n ; has_witness = with_witness\n ; stack\n ; handler = Option.value handler ~default:Request.Handler.fail\n ; is_running\n ; as_prover = ref false\n ; log_constraint\n }\n\nlet dump (t : _ t) =\n Format.sprintf\n \"state { is_running: %B; as_prover: %B; has_witness: %B; eval_constraints: \\\n %B; num_inputs: %d; next_auxiliary: %d }\\n\"\n t.is_running !(t.as_prover) t.has_witness t.eval_constraints t.num_inputs\n !(t.next_auxiliary)\n\nlet get_variable_value { num_inputs; input; aux; _ } : int -> 'field =\n fun i ->\n if i < num_inputs then Vector.get input i else Vector.get aux (i - num_inputs)\n\nlet store_field_elt { next_auxiliary; aux; _ } x =\n let v = !next_auxiliary in\n incr next_auxiliary ; Vector.emplace_back aux x ; Cvar.Unsafe.of_index v\n\nlet alloc_var { next_auxiliary; _ } () =\n let v = !next_auxiliary in\n incr next_auxiliary ; Cvar.Unsafe.of_index v\n\nlet has_witness { has_witness; _ } = has_witness\n\nlet as_prover { as_prover; _ } = !as_prover\n\nlet set_as_prover t as_prover = t.as_prover := as_prover\n\nlet stack { stack; _ } = stack\n\nlet set_stack t stack = { t with stack }\n\nlet log_constraint { log_constraint; _ } = log_constraint\n\nlet eval_constraints { eval_constraints; _ } = eval_constraints\n\nlet system { system; _ } = system\n\nlet handler { handler; _ } = handler\n\nlet set_handler t handler = { t with handler }\n\nlet is_running { is_running; _ } = is_running\n\nlet set_is_running t is_running = { t with is_running }\n\nlet next_auxiliary { next_auxiliary; _ } = !next_auxiliary\n","module type Basic = sig\n module Types : Types.Types\n\n type ('a, 'f) t = ('a, 'f) Types.Checked.t\n\n type 'f field\n\n include Monad_let.S2 with type ('a, 'f) t := ('a, 'f) t\n\n val add_constraint :\n ('f field Cvar.t, 'f field) Constraint.t -> (unit, 'f field) t\n\n val as_prover : (unit, 'f field) As_prover0.t -> (unit, 'f field) t\n\n val mk_lazy : (unit -> ('a, 'f) t) -> ('a Lazy.t, 'f) t\n\n val with_label : string -> (unit -> ('a, 'f field) t) -> ('a, 'f field) t\n\n val with_handler :\n Request.Handler.single -> (unit -> ('a, 'f field) t) -> ('a, 'f field) t\n\n val exists :\n ('var, 'value, 'f field) Types.Typ.t\n -> ('value, 'f field) Types.Provider.t\n -> (('var, 'value) Handle.t, 'f field) t\n\n val next_auxiliary : unit -> (int, 'f field) t\n\n val direct :\n ('f field Run_state.t -> 'f field Run_state.t * 'a) -> ('a, 'f field) t\n\n val constraint_count :\n ?weight:(('f field Cvar.t, 'f field) Constraint.t -> int)\n -> ?log:(?start:bool -> string -> int -> unit)\n -> (unit -> ('a, 'f field) t)\n -> int\nend\n\nmodule type S = sig\n module Types : Types.Types\n\n type ('a, 'f) t = ('a, 'f) Types.Checked.t\n\n type 'f field\n\n include Monad_let.S2 with type ('a, 'f) t := ('a, 'f) t\n\n val as_prover : (unit, 'f field) As_prover0.t -> (unit, 'f field) t\n\n val mk_lazy : (unit -> ('a, 'f) t) -> ('a Lazy.t, 'f) t\n\n val request_witness :\n ('var, 'value, 'f field) Types.Typ.t\n -> ('value Request.t, 'f field) As_prover0.t\n -> ('var, 'f field) t\n\n val request :\n ?such_that:('var -> (unit, 'f field) t)\n -> ('var, 'value, 'f field) Types.Typ.t\n -> 'value Request.t\n -> ('var, 'f field) t\n\n val exists_handle :\n ?request:('value Request.t, 'f field) As_prover0.t\n -> ?compute:('value, 'f field) As_prover0.t\n -> ('var, 'value, 'f field) Types.Typ.t\n -> (('var, 'value) Handle.t, 'f field) t\n\n val exists :\n ?request:('value Request.t, 'f field) As_prover0.t\n -> ?compute:('value, 'f field) As_prover0.t\n -> ('var, 'value, 'f field) Types.Typ.t\n -> ('var, 'f field) t\n\n type response = Request.response\n\n val unhandled : response\n\n type request = Request.request =\n | With :\n { request : 'a Request.t; respond : 'a Request.Response.t -> response }\n -> request\n\n val handle :\n (unit -> ('a, 'f field) t) -> (request -> response) -> ('a, 'f field) t\n\n val handle_as_prover :\n (unit -> ('a, 'f field) t)\n -> (request -> response, 'f field) As_prover0.t\n -> ('a, 'f field) t\n\n val next_auxiliary : unit -> (int, 'f field) t\n\n val with_label : string -> (unit -> ('a, 'f field) t) -> ('a, 'f field) t\n\n val assert_ :\n ?label:Base.string\n -> ('f field Cvar.t, 'f field) Constraint.t\n -> (unit, 'f field) t\n\n val assert_r1cs :\n ?label:Base.string\n -> 'f field Cvar.t\n -> 'f field Cvar.t\n -> 'f field Cvar.t\n -> (unit, 'f field) t\n\n val assert_square :\n ?label:Base.string\n -> 'f field Cvar.t\n -> 'f field Cvar.t\n -> (unit, 'f field) t\n\n val assert_all :\n ?label:Base.string\n -> ('f field Cvar.t, 'f field) Constraint.t list\n -> (unit, 'f field) t\n\n val assert_equal :\n ?label:Base.string\n -> 'f field Cvar.t\n -> 'f field Cvar.t\n -> (unit, 'f field) t\n\n val direct :\n ('f field Run_state.t -> 'f field Run_state.t * 'a) -> ('a, 'f field) t\n\n val constraint_count :\n ?weight:(('f field Cvar.t, 'f field) Constraint.t -> int)\n -> ?log:(?start:bool -> string -> int -> unit)\n -> (unit -> ('a, 'f field) t)\n -> int\nend\n\nmodule type Extended = sig\n type field\n\n module Types : Types.Types\n\n type 'a t = ('a, field) Types.Checked.t\n\n include\n S\n with module Types := Types\n with type 'f field := field\n and type ('a, 'f) t := ('a, 'f) Types.Checked.t\n\n val run : 'a t -> field Run_state.t -> field Run_state.t * 'a\nend\n\nmodule Unextend (Checked : Extended) :\n S with module Types = Checked.Types with type 'f field = Checked.field =\nstruct\n include (\n Checked :\n S\n with module Types = Checked.Types\n with type 'f field := Checked.field\n and type ('a, 'f) t := ('a, 'f) Checked.Types.Checked.t )\n\n type 'f field = Checked.field\n\n type ('a, 'f) t = ('a, 'f) Types.Checked.t\nend\n","open Core_kernel\n\ntype 'a t = 'a option ref\n\nmodule Make_ref_typ (Checked : Monad_let.S2) = struct\n let typ : ('a t, 'a, _, _) Types.Typ.t =\n Typ\n { var_to_fields = (fun x -> ([||], !x))\n ; var_of_fields = (fun (_, x) -> ref x)\n ; value_to_fields = (fun x -> ([||], Some x))\n ; value_of_fields = (fun (_, x) -> Option.value_exn x)\n ; size_in_field_elements = 0\n ; constraint_system_auxiliary = (fun () -> None)\n ; check = (fun _ -> Checked.return ())\n }\nend\n\nmodule type S = sig\n module Types : Types.Types\n\n type ('a, 'f) checked\n\n type 'f field\n\n type nonrec 'a t = 'a t\n\n val create : ('a, 'f field) As_prover0.t -> ('a t, 'f field) checked\n\n val get : 'a t -> ('a, 'f field) As_prover0.t\n\n val set : 'a t -> 'a -> (unit, 'f field) As_prover0.t\nend\n\nmodule Make\n (Checked : Checked_intf.S)\n (As_prover : As_prover_intf.Basic\n with type 'f field := 'f Checked.field\n and type ('a, 'f) Provider.t =\n ('a, 'f) Checked.Types.Provider.t) :\n S\n with module Types = Checked.Types\n and type ('a, 'f) checked := ('a, 'f) Checked.t\n and type 'f field = 'f Checked.field = struct\n module Types = Checked.Types\n\n type 'f field = 'f Checked.field\n\n type nonrec 'a t = 'a t\n\n let create (x : ('a, 'f Checked.field) As_prover.t) :\n ('a t, 'f Checked.field) Checked.t =\n let r = ref None in\n let open Checked in\n let%map () =\n Checked.as_prover (As_prover.map x ~f:(fun x -> r := Some x))\n in\n r\n\n open As_prover.Let_syntax\n\n let get (r : 'a t) =\n let%map () = As_prover.return () in\n Option.value_exn !r\n\n let set (r : 'a t) x =\n let%map () = As_prover.return () in\n r := Some x\nend\n","type 'v t = 'v\n\nmodule Unsafe = struct\n let create x = x\nend\n","open Core_kernel\nmodule Types0 = Types\n\nmodule Make\n (Backend : Backend_extended.S)\n (Checked : Checked_intf.Extended with type field = Backend.Field.t)\n (As_prover : As_prover0.Extended with type field := Backend.Field.t)\n (Runner : Checked_runner.S\n with module Types := Checked.Types\n with type field := Backend.Field.t\n and type cvar := Backend.Cvar.t\n and type constr := Backend.Constraint.t option\n and type r1cs := Backend.R1CS_constraint_system.t) =\nstruct\n open Backend\n\n let set_constraint_logger = Runner.set_constraint_logger\n\n let clear_constraint_logger = Runner.clear_constraint_logger\n\n type field = Field.t\n\n let field_vec_id : Field.Vector.t Type_equal.Id.t =\n Type_equal.Id.create ~name:\"field-vector\" sexp_of_opaque\n\n let pack_field_vec v =\n Run_state.Vector.T ((module Field.Vector), field_vec_id, v)\n\n let field_vec () = pack_field_vec (Field.Vector.create ())\n\n module Proof_inputs = struct\n type t =\n { public_inputs : Field.Vector.t; auxiliary_inputs : Field.Vector.t }\n end\n\n module Bigint = Bigint\n module Field0 = Field\n module Cvar = Cvar\n module Constraint = Constraint\n\n module Handler = struct\n type t = Request.request -> Request.response\n end\n\n module Runner = Runner\n\n (* TODO-someday: Add pass to unify variables which have an Equal constraint *)\n let constraint_system ~run ~num_inputs ~return_typ:(Types.Typ.Typ return_typ)\n output t : R1CS_constraint_system.t =\n let input = field_vec () in\n let next_auxiliary = ref num_inputs in\n let aux = field_vec () in\n let system = R1CS_constraint_system.create () in\n let state =\n Runner.State.make ~num_inputs ~input ~next_auxiliary ~aux ~system\n ~with_witness:false ()\n in\n let state, res = run t state in\n let res, _ = return_typ.var_to_fields res in\n let output, _ = return_typ.var_to_fields output in\n let _state =\n Array.fold2_exn ~init:state res output ~f:(fun state res output ->\n fst @@ Checked.run (Checked.assert_equal res output) state )\n in\n let auxiliary_input_size = !next_auxiliary - num_inputs in\n R1CS_constraint_system.set_auxiliary_input_size system auxiliary_input_size ;\n system\n\n let auxiliary_input ?system ~run ~num_inputs\n ?(handlers = ([] : Handler.t list)) t0 (input : Field.Vector.t)\n ~return_typ:(Types.Typ.Typ return_typ) ~output : Field.Vector.t * _ =\n let next_auxiliary = ref num_inputs in\n let aux = Field.Vector.create () in\n let handler =\n List.fold ~init:Request.Handler.fail handlers ~f:(fun handler h ->\n Request.Handler.(push handler (create_single h)) )\n in\n let state =\n Runner.State.make ?system ~num_inputs ~input:(pack_field_vec input)\n ~next_auxiliary ~aux:(pack_field_vec aux) ~handler ~with_witness:true ()\n in\n let state, res = run t0 state in\n let res, auxiliary_output_data = return_typ.var_to_fields res in\n let output, _ = return_typ.var_to_fields output in\n let _state =\n Array.fold2_exn ~init:state res output ~f:(fun state res output ->\n Field.Vector.emplace_back input (Runner.get_value state res) ;\n fst @@ Checked.run (Checked.assert_equal res output) state )\n in\n let true_output =\n return_typ.var_of_fields (output, auxiliary_output_data)\n in\n Option.iter system ~f:(fun system ->\n let auxiliary_input_size = !next_auxiliary - num_inputs in\n R1CS_constraint_system.set_auxiliary_input_size system\n auxiliary_input_size ;\n R1CS_constraint_system.finalize system ) ;\n (aux, true_output)\n\n let run_and_check_exn' ~run t0 =\n let num_inputs = 0 in\n let input = field_vec () in\n let next_auxiliary = ref 0 in\n let aux = Field.Vector.create () in\n let system = R1CS_constraint_system.create () in\n let get_value : Cvar.t -> Field.t =\n let get_one v = Field.Vector.get aux v in\n Cvar.eval (`Return_values_will_be_mutated get_one)\n in\n let state =\n Runner.State.make ~num_inputs ~input ~next_auxiliary\n ~aux:(pack_field_vec aux) ~system ~eval_constraints:true\n ~with_witness:true ()\n in\n let _, x = run t0 state in\n (x, get_value)\n\n let run_and_check' ~run t0 =\n match run_and_check_exn' ~run t0 with\n | exception e ->\n Or_error.of_exn ~backtrace:`Get e\n | res ->\n Ok res\n\n let run_and_check_deferred_exn' ~map ~run t0 =\n let num_inputs = 0 in\n let input = field_vec () in\n let next_auxiliary = ref 0 in\n let aux = Field.Vector.create () in\n let system = R1CS_constraint_system.create () in\n let get_value : Cvar.t -> Field.t =\n let get_one v = Field.Vector.get aux v in\n Cvar.eval (`Return_values_will_be_mutated get_one)\n in\n let state =\n Runner.State.make ~num_inputs ~input ~next_auxiliary\n ~aux:(pack_field_vec aux) ~system ~eval_constraints:true\n ~with_witness:true ()\n in\n let res = run t0 state in\n map res ~f:(function _, x -> (x, get_value))\n\n let run_and_check_deferred' ~map ~return ~run t0 =\n match\n run_and_check_deferred_exn'\n ~map:(fun x ~f -> map x ~f:(fun x -> Ok (f x)))\n ~run t0\n with\n | exception e ->\n return (Or_error.of_exn ~backtrace:`Get e)\n | res ->\n res\n\n let run_unchecked ~run t0 =\n let num_inputs = 0 in\n let input = field_vec () in\n let next_auxiliary = ref 0 in\n let aux = field_vec () in\n let state =\n Runner.State.make ~num_inputs ~input ~next_auxiliary ~aux\n ~with_witness:true ()\n in\n match run t0 state with _, x -> x\n\n let run_and_check_exn ~run t =\n let x, get_value = run_and_check_exn' ~run t in\n let x = As_prover.run x get_value in\n x\n\n let run_and_check ~run t =\n Or_error.map (run_and_check' ~run t) ~f:(fun (x, get_value) ->\n let x = As_prover.run x get_value in\n x )\n\n let check_exn ~run t = run_and_check_exn' ~run t |> Fn.const ()\n\n let check ~run t = run_and_check' ~run t |> Result.map ~f:(Fn.const ())\n\n module Run = struct\n let alloc_var next_input () =\n let v = !next_input in\n incr next_input ; Cvar.Unsafe.of_index v\n\n let store_field_elt primary_input next_input x =\n let v = alloc_var next_input () in\n Field.Vector.emplace_back primary_input x ;\n v\n\n let collect_input_constraints :\n type checked input_var input_value.\n int ref\n -> input_typ:\n ( input_var\n , input_value\n , field\n , (unit, field) Checked.Types.Checked.t )\n Types.Typ.typ\n -> return_typ:_ Types.Typ.t\n -> (unit -> input_var -> checked)\n -> _ * (unit -> checked) Checked.t =\n fun next_input ~input_typ:(Typ input_typ) ~return_typ:(Typ return_typ) k ->\n (* allocate variables for the public input and the public output *)\n let open Checked in\n let alloc_input\n { Types0.Typ.var_of_fields\n ; size_in_field_elements\n ; constraint_system_auxiliary\n ; _\n } =\n var_of_fields\n ( Core_kernel.Array.init size_in_field_elements ~f:(fun _ ->\n alloc_var next_input () )\n , constraint_system_auxiliary () )\n in\n let var = alloc_input input_typ in\n let retval = alloc_input return_typ in\n\n (* create constraints to validate the input (using the input [Typ]'s [check]) *)\n let circuit =\n let%bind () = input_typ.check var in\n Checked.return (fun () -> k () var)\n in\n (retval, circuit)\n\n let r1cs_h :\n type a checked input_var input_value retval.\n run:(a, checked) Runner.run\n -> int ref\n -> input_typ:\n ( input_var\n , input_value\n , field\n , (unit, field) Checked.Types.Checked.t )\n Types.Typ.typ\n -> return_typ:(a, retval, _, _) Types.Typ.t\n -> (input_var -> checked)\n -> R1CS_constraint_system.t =\n fun ~run next_input ~input_typ ~return_typ k ->\n (* allocate variables for the public input and the public output *)\n let retval, checked =\n collect_input_constraints next_input ~input_typ ~return_typ (fun () ->\n k )\n in\n\n (* ? *)\n let run_in_run checked state =\n let state, x = Checked.run checked state in\n run x state\n in\n\n (* ? *)\n constraint_system ~run:run_in_run ~num_inputs:!next_input ~return_typ\n retval\n (Checked.map ~f:(fun r -> r ()) checked)\n\n let constraint_system (type a checked input_var) :\n run:(a, checked) Runner.run\n -> input_typ:(input_var, _, _, _) Types.Typ.typ\n -> return_typ:_\n -> (input_var -> checked)\n -> R1CS_constraint_system.t =\n fun ~run ~input_typ ~return_typ k ->\n r1cs_h ~run (ref 0) ~input_typ ~return_typ k\n\n let generate_public_input :\n ('input_var, 'input_value, _, _) Types.Typ.typ\n -> 'input_value\n -> Field.Vector.t =\n fun (Typ { value_to_fields; _ }) value ->\n let primary_input = Field.Vector.create () in\n let next_input = ref 0 in\n let store_field_elt = store_field_elt primary_input next_input in\n let fields, _aux = value_to_fields value in\n let _fields = Array.map ~f:store_field_elt fields in\n primary_input\n\n let conv :\n type r_var r_value.\n (int -> _ -> r_var -> Field.Vector.t -> r_value)\n -> ('input_var, 'input_value, _, _) Types.Typ.t\n -> _ Types.Typ.t\n -> (unit -> 'input_var -> r_var)\n -> 'input_value\n -> r_value =\n fun cont0 input_typ (Typ return_typ) k0 ->\n let primary_input = Field.Vector.create () in\n let next_input = ref 0 in\n let store_field_elt x =\n let v = !next_input in\n incr next_input ;\n Field.Vector.emplace_back primary_input x ;\n Cvar.Unsafe.of_index v\n in\n let (Typ { var_of_fields; value_to_fields; _ }) = input_typ in\n fun value ->\n let fields, aux = value_to_fields value in\n let fields = Array.map ~f:store_field_elt fields in\n let var = var_of_fields (fields, aux) in\n let retval =\n return_typ.var_of_fields\n ( Core_kernel.Array.init return_typ.size_in_field_elements\n ~f:(fun _ -> alloc_var next_input ())\n , return_typ.constraint_system_auxiliary () )\n in\n cont0 !next_input retval (k0 () var) primary_input\n\n let generate_auxiliary_input :\n run:('a, 'checked) Runner.run\n -> input_typ:_ Types.Typ.t\n -> return_typ:(_, _, _, _) Types.Typ.t\n -> ?handlers:Handler.t list\n -> 'k_var\n -> 'k_value =\n fun ~run ~input_typ ~return_typ ?handlers k ->\n conv\n (fun num_inputs output c primary ->\n let auxiliary =\n auxiliary_input ~run ?handlers ~return_typ ~output ~num_inputs c\n primary\n in\n ignore auxiliary )\n input_typ return_typ\n (fun () -> k)\n\n let generate_witness_conv :\n run:('a, 'checked) Runner.run\n -> f:(Proof_inputs.t -> _ -> 'out)\n -> input_typ:_ Types.Typ.t\n -> return_typ:_ Types.Typ.t\n -> ?handlers:Handler.t list\n -> 'k_var\n -> 'k_value =\n fun ~run ~f ~input_typ ~return_typ ?handlers k ->\n conv\n (fun num_inputs output c primary ->\n let auxiliary, output =\n auxiliary_input ~run ?handlers ~return_typ ~output ~num_inputs c\n primary\n in\n let output =\n let (Typ return_typ) = return_typ in\n let fields, aux = return_typ.var_to_fields output in\n let read_cvar =\n let get_one i =\n if i < num_inputs then Field.Vector.get primary i\n else Field.Vector.get auxiliary (i - num_inputs)\n in\n Cvar.eval (`Return_values_will_be_mutated get_one)\n in\n let fields = Array.map ~f:read_cvar fields in\n return_typ.value_of_fields (fields, aux)\n in\n f\n { Proof_inputs.public_inputs = primary\n ; auxiliary_inputs = auxiliary\n }\n output )\n input_typ return_typ\n (fun () -> k)\n\n let generate_witness =\n generate_witness_conv ~f:(fun inputs _output -> inputs)\n end\n\n module Perform = struct\n let generate_witness ~run t ~return_typ k =\n Run.generate_witness ~run t ~return_typ k\n\n let generate_witness_conv ~run ~f t ~return_typ k =\n Run.generate_witness_conv ~run ~f t ~return_typ k\n\n let constraint_system = Run.constraint_system\n\n let run_unchecked = run_unchecked\n\n let run_and_check_exn = run_and_check_exn\n\n let run_and_check = run_and_check\n\n let check_exn = check_exn\n\n let check = check\n end\n\n let conv f spec return_typ k =\n Run.conv (fun _ _ x _ -> f x) spec return_typ (fun () -> k)\n\n let generate_auxiliary_input ~input_typ ~return_typ k =\n Run.generate_auxiliary_input ~run:Checked.run ~input_typ ~return_typ k\n\n let generate_public_input = Run.generate_public_input\n\n let generate_witness ~input_typ ~return_typ k =\n Run.generate_witness ~run:Checked.run ~input_typ ~return_typ k\n\n let generate_witness_conv ~f ~input_typ ~return_typ k =\n Run.generate_witness_conv ~run:Checked.run ~f ~input_typ ~return_typ k\n\n let constraint_system ~input_typ ~return_typ k =\n Run.constraint_system ~run:Checked.run ~input_typ ~return_typ k\n\n let run_unchecked t = run_unchecked ~run:Checked.run t\n\n let run_and_check t = run_and_check ~run:Checked.run t\n\n let run_and_check_exn t = run_and_check_exn ~run:Checked.run t\n\n let check t = check ~run:Checked.run t\n\n let check_exn t = check_exn ~run:Checked.run t\nend\n","open Core_kernel\nopen Types.Typ\n\nmodule Data_spec0 = struct\n (** A list of {!type:Type.Typ.t} values, describing the inputs to a checked\n computation. The type [('r_var, 'r_value, 'k_var, 'k_value, 'field) t]\n represents\n - ['k_value] is the OCaml type of the computation\n - ['r_value] is the OCaml type of the result\n - ['k_var] is the type of the computation within the R1CS\n - ['k_value] is the type of the result within the R1CS\n - ['field] is the field over which the R1CS operates\n - ['checked] is the type of checked computation that verifies the stored\n contents as R1CS variables.\n\n This functions the same as OCaml's default list type:\n{[\n Data_spec.[typ1; typ2; typ3]\n\n Data_spec.(typ1 :: typs)\n\n let open Data_spec in\n [typ1; typ2; typ3; typ4; typ5]\n\n let open Data_spec in\n typ1 :: typ2 :: typs\n\n]}\n all function as you would expect.\n *)\n type ('r_var, 'r_value, 'k_var, 'k_value, 'f, 'checked) data_spec =\n | ( :: ) :\n ('var, 'value, 'f, 'checked) Types.Typ.t\n * ('r_var, 'r_value, 'k_var, 'k_value, 'f, 'checked) data_spec\n -> ( 'r_var\n , 'r_value\n , 'var -> 'k_var\n , 'value -> 'k_value\n , 'f\n , 'checked )\n data_spec\n | [] : ('r_var, 'r_value, 'r_var, 'r_value, 'f, 'checked) data_spec\nend\n\nmodule Intf = struct\n module type S = sig\n type field\n\n type field_var\n\n type 'field checked\n\n module Var : sig\n type t\n\n val size_in_field_elements : int\n\n val to_field_elements : t -> field_var array\n\n val of_field_elements : field_var array -> t\n\n val check : t -> field checked\n end\n\n module Value : sig\n type t\n\n val size_in_field_elements : int\n\n val to_field_elements : t -> field array\n\n val of_field_elements : field array -> t\n end\n end\nend\n\nmodule type Checked_monad = sig\n type ('a, 'f) t\n\n type 'f field\n\n include Monad_let.S2 with type ('a, 'e) t := ('a, 'e) t\n\n module Types : Types.Types\nend\n\nmodule Make (Checked : Checked_monad) = struct\n type ('var, 'value, 'field) t =\n ('var, 'value, 'field, (unit, 'field) Checked.t) Types.Typ.t\n\n type ('var, 'value, 'field) typ = ('var, 'value, 'field) t\n\n module type S = sig\n type field\n\n include\n Intf.S\n with type 'field checked := (unit, 'field) Checked.t\n and type field := field\n and type field_var := field Cvar.t\n end\n\n module Data_spec = struct\n include Data_spec0\n\n type ('r_var, 'r_value, 'k_var, 'k_value, 'f) t =\n ('r_var, 'r_value, 'k_var, 'k_value, 'f, (unit, 'f) Checked.t) data_spec\n\n let size t =\n let rec go :\n type r_var r_value k_var k_value.\n int -> (r_var, r_value, k_var, k_value, 'f) t -> int =\n fun acc t ->\n match t with\n | [] ->\n acc\n | Typ { size_in_field_elements; _ } :: t' ->\n go (acc + size_in_field_elements) t'\n in\n go 0 t\n end\n\n module T = struct\n let unit () : (unit, unit, 'field) t =\n Typ\n { var_to_fields = (fun () -> ([||], ()))\n ; var_of_fields = (fun _ -> ())\n ; value_to_fields = (fun () -> ([||], ()))\n ; value_of_fields = (fun _ -> ())\n ; size_in_field_elements = 0\n ; constraint_system_auxiliary = (fun () -> ())\n ; check = (fun () -> Checked.return ())\n }\n\n let field () : ('field Cvar.t, 'field, 'field) t =\n Typ\n { var_to_fields = (fun f -> ([| f |], ()))\n ; var_of_fields = (fun (fields, _) -> fields.(0))\n ; value_to_fields = (fun f -> ([| f |], ()))\n ; value_of_fields = (fun (fields, _) -> fields.(0))\n ; size_in_field_elements = 1\n ; constraint_system_auxiliary = (fun () -> ())\n ; check = (fun _ -> Checked.return ())\n }\n\n module Internal = struct\n let snarkless value : _ t =\n Typ\n { var_to_fields = (fun _ -> ([||], ()))\n ; var_of_fields = (fun _ -> value)\n ; value_to_fields =\n (fun value' ->\n assert (phys_equal value value') ;\n ([||], ()) )\n ; value_of_fields = (fun _ -> value)\n ; size_in_field_elements = 0\n ; constraint_system_auxiliary = (fun () -> ())\n ; check = (fun _ -> Checked.return ())\n }\n\n module Ref_typ = As_prover_ref.Make_ref_typ (Checked)\n\n let ref () = Ref_typ.typ\n end\n\n let transport (type var value1 value2 field)\n (Typ\n { var_to_fields\n ; var_of_fields\n ; value_to_fields\n ; value_of_fields\n ; size_in_field_elements\n ; constraint_system_auxiliary\n ; check\n } :\n (var, value1, field) t ) ~(there : value2 -> value1)\n ~(back : value1 -> value2) : (var, value2, field) t =\n Typ\n { var_to_fields\n ; var_of_fields\n ; value_to_fields = (fun x -> value_to_fields (there x))\n ; value_of_fields = (fun x -> back (value_of_fields x))\n ; size_in_field_elements\n ; constraint_system_auxiliary\n ; check\n }\n\n let transport_var (type var1 var2 value field)\n (Typ\n { var_to_fields\n ; var_of_fields\n ; value_to_fields\n ; value_of_fields\n ; size_in_field_elements\n ; constraint_system_auxiliary\n ; check\n } :\n (var1, value, field) t ) ~(there : var2 -> var1) ~(back : var1 -> var2)\n : (var2, value, field) t =\n Typ\n { var_to_fields = (fun x -> var_to_fields (there x))\n ; var_of_fields = (fun x -> back (var_of_fields x))\n ; value_to_fields\n ; value_of_fields\n ; size_in_field_elements\n ; constraint_system_auxiliary\n ; check = (fun x -> check (there x))\n }\n\n let list ~length\n (Typ\n { var_to_fields\n ; var_of_fields\n ; value_to_fields\n ; value_of_fields\n ; size_in_field_elements\n ; constraint_system_auxiliary\n ; check\n } :\n ('elt_var, 'elt_value, 'field) t ) :\n ('elt_var list, 'elt_value list, 'field) t =\n (* NB: We store the size_in_field_elements of each in the auxiliary\n data, to allow for 'reads' of e.g. list of lists of different\n lengths.\n *)\n Typ\n { var_to_fields =\n (fun ts ->\n let rec go ts ((fieldss, auxes) as acc) =\n match ts with\n | [] ->\n acc\n | t :: tl ->\n let fields, aux = var_to_fields t in\n let acc =\n ( Array.append fieldss fields\n , (aux, Array.length fields) :: auxes )\n in\n go tl acc\n in\n go ts ([||], []) )\n ; var_of_fields =\n (fun (fields, auxes) ->\n let vars, _ =\n List.fold\n ~init:([], Array.length fields)\n auxes\n ~f:(fun (vars, end_pos) (aux, num_fields) ->\n let end_pos = end_pos - num_fields in\n let var =\n var_of_fields\n (Array.sub ~pos:end_pos ~len:num_fields fields, aux)\n in\n (var :: vars, end_pos) )\n in\n vars )\n ; value_to_fields =\n (fun ts ->\n let rec go ts ((fieldss, auxes) as acc) =\n match ts with\n | [] ->\n acc\n | t :: tl ->\n let fields, aux = value_to_fields t in\n let acc =\n ( Array.append fieldss fields\n , (aux, Array.length fields) :: auxes )\n in\n go tl acc\n in\n go ts ([||], []) )\n ; value_of_fields =\n (fun (fields, auxes) ->\n let vars, _ =\n List.fold\n ~init:([], Array.length fields)\n auxes\n ~f:(fun (vars, end_pos) (aux, num_fields) ->\n let end_pos = end_pos - num_fields in\n let var =\n value_of_fields\n (Array.sub ~pos:end_pos ~len:num_fields fields, aux)\n in\n (var :: vars, end_pos) )\n in\n vars )\n ; size_in_field_elements = length * size_in_field_elements\n ; constraint_system_auxiliary =\n (fun () ->\n List.init length ~f:(fun _ ->\n (constraint_system_auxiliary (), size_in_field_elements) ) )\n ; check = (fun ts -> Checked.all_unit (List.map ts ~f:check))\n }\n\n let array ~length typ =\n list ~length typ\n |> transport ~there:Array.to_list ~back:Array.of_list\n |> transport_var ~there:Array.to_list ~back:Array.of_list\n\n let hlist (type k_var k_value)\n (spec0 : (unit, unit, k_var, k_value, 'f) Data_spec.t) :\n ((unit, k_var) H_list.t, (unit, k_value) H_list.t, 'f) t =\n let rec go :\n type k_var k_value.\n (unit, unit, k_var, k_value, 'f) Data_spec.t\n -> ((unit, k_var) H_list.t, (unit, k_value) H_list.t, 'f) t =\n fun spec0 ->\n let open H_list in\n match spec0 with\n | [] ->\n Typ\n { var_to_fields = (fun [] -> ([||], ()))\n ; var_of_fields = (fun _ -> [])\n ; value_to_fields = (fun [] -> ([||], ()))\n ; value_of_fields = (fun _ -> [])\n ; size_in_field_elements = 0\n ; constraint_system_auxiliary = (fun () -> ())\n ; check = (fun [] -> Checked.return ())\n }\n | Typ\n { var_to_fields\n ; var_of_fields\n ; value_to_fields\n ; value_of_fields\n ; size_in_field_elements\n ; constraint_system_auxiliary\n ; check\n }\n :: spec0 ->\n let (Typ typ) = go spec0 in\n let open H_list in\n Typ\n { var_to_fields =\n (fun (x :: tl) ->\n let fields, aux = var_to_fields x in\n let fieldss, auxes = typ.var_to_fields tl in\n ( Array.append fields fieldss\n , (aux, Array.length fields, auxes) ) )\n ; var_of_fields =\n (fun (fields, (hd, len, tl)) ->\n let var =\n var_of_fields (Array.sub ~pos:0 ~len fields, hd)\n in\n let tl =\n typ.var_of_fields\n ( Array.sub ~pos:len\n ~len:(Array.length fields - len)\n fields\n , tl )\n in\n var :: tl )\n ; value_to_fields =\n (fun (x :: tl) ->\n let fields, aux = value_to_fields x in\n let fieldss, auxes = typ.value_to_fields tl in\n ( Array.append fields fieldss\n , (aux, Array.length fields, auxes) ) )\n ; value_of_fields =\n (fun (fields, (hd, len, tl)) ->\n let value =\n value_of_fields (Array.sub ~pos:0 ~len fields, hd)\n in\n let tl =\n typ.value_of_fields\n ( Array.sub ~pos:len\n ~len:(Array.length fields - len)\n fields\n , tl )\n in\n value :: tl )\n ; size_in_field_elements =\n size_in_field_elements + typ.size_in_field_elements\n ; constraint_system_auxiliary =\n (fun () ->\n let hd = constraint_system_auxiliary () in\n let auxes = typ.constraint_system_auxiliary () in\n (hd, size_in_field_elements, auxes) )\n ; check =\n (fun (x :: tl) ->\n Checked.bind (check x) ~f:(fun () -> typ.check tl) )\n }\n in\n go spec0\n\n let tuple2 typ1 typ2 =\n let open H_list in\n hlist [ typ1; typ2 ]\n |> transport\n ~there:(fun (a, b) -> [ a; b ])\n ~back:(fun ([ a; b ] : (unit, _ -> _ -> unit) H_list.t) -> (a, b))\n |> transport_var\n ~there:(fun (a, b) -> [ a; b ])\n ~back:(fun ([ a; b ] : (unit, _ -> _ -> unit) H_list.t) -> (a, b))\n\n let ( * ) = tuple2\n\n let tuple3 typ1 typ2 typ3 =\n let open H_list in\n hlist [ typ1; typ2; typ3 ]\n |> transport\n ~there:(fun (a, b, c) -> [ a; b; c ])\n ~back:(fun ([ a; b; c ] : (unit, _ -> _ -> _ -> unit) H_list.t) ->\n (a, b, c) )\n |> transport_var\n ~there:(fun (a, b, c) -> [ a; b; c ])\n ~back:(fun ([ a; b; c ] : (unit, _ -> _ -> _ -> unit) H_list.t) ->\n (a, b, c) )\n\n let tuple4 typ1 typ2 typ3 typ4 =\n let open H_list in\n hlist [ typ1; typ2; typ3; typ4 ]\n |> transport\n ~there:(fun (a, b, c, d) -> [ a; b; c; d ])\n ~back:(fun ([ a; b; c; d ] :\n (unit, _ -> _ -> _ -> _ -> unit) H_list.t ) ->\n (a, b, c, d) )\n |> transport_var\n ~there:(fun (a, b, c, d) -> [ a; b; c; d ])\n ~back:(fun ([ a; b; c; d ] :\n (unit, _ -> _ -> _ -> _ -> unit) H_list.t ) ->\n (a, b, c, d) )\n\n let tuple5 typ1 typ2 typ3 typ4 typ5 =\n let open H_list in\n hlist [ typ1; typ2; typ3; typ4; typ5 ]\n |> transport\n ~there:(fun (a, b, c, d, e) -> [ a; b; c; d; e ])\n ~back:(fun ([ a; b; c; d; e ] :\n (unit, _ -> _ -> _ -> _ -> _ -> unit) H_list.t ) ->\n (a, b, c, d, e) )\n |> transport_var\n ~there:(fun (a, b, c, d, e) -> [ a; b; c; d; e ])\n ~back:(fun ([ a; b; c; d; e ] :\n (unit, _ -> _ -> _ -> _ -> _ -> unit) H_list.t ) ->\n (a, b, c, d, e) )\n\n let tuple6 typ1 typ2 typ3 typ4 typ5 typ6 =\n let open H_list in\n hlist [ typ1; typ2; typ3; typ4; typ5; typ6 ]\n |> transport\n ~there:(fun (a, b, c, d, e, f) -> [ a; b; c; d; e; f ])\n ~back:(fun ([ a; b; c; d; e; f ] :\n (unit, _ -> _ -> _ -> _ -> _ -> _ -> unit) H_list.t ) ->\n (a, b, c, d, e, f) )\n |> transport_var\n ~there:(fun (a, b, c, d, e, f) -> [ a; b; c; d; e; f ])\n ~back:(fun ([ a; b; c; d; e; f ] :\n (unit, _ -> _ -> _ -> _ -> _ -> _ -> unit) H_list.t ) ->\n (a, b, c, d, e, f) )\n\n let of_hlistable (spec : (unit, unit, 'k_var, 'k_value, 'f) Data_spec.t)\n ~(var_to_hlist : 'var -> (unit, 'k_var) H_list.t)\n ~(var_of_hlist : (unit, 'k_var) H_list.t -> 'var)\n ~(value_to_hlist : 'value -> (unit, 'k_value) H_list.t)\n ~(value_of_hlist : (unit, 'k_value) H_list.t -> 'value) :\n ('var, 'value, 'f) t =\n hlist spec\n |> transport ~there:value_to_hlist ~back:value_of_hlist\n |> transport_var ~there:var_to_hlist ~back:var_of_hlist\n end\n\n include T\nend\n\ninclude Make (Checked_runner.Simple)\n","open Core_kernel\n\n(** Helpers for operating over a sequence of data (currently, either an array\n or a list) inside of a monad.\n*)\nmodule type S = sig\n type 'a monad\n\n type 'a t\n\n type boolean\n\n val foldi : 'a t -> init:'b -> f:(int -> 'b -> 'a -> 'b monad) -> 'b monad\n\n val fold : 'a t -> init:'b -> f:('b -> 'a -> 'b monad) -> 'b monad\n\n val fold_map :\n 'a t -> init:'b -> f:('b -> 'a -> ('b * 'c) monad) -> ('b * 'c t) monad\n\n val exists : 'a t -> f:('a -> boolean monad) -> boolean monad\n\n val existsi : 'a t -> f:(int -> 'a -> boolean monad) -> boolean monad\n\n val for_all : 'a t -> f:('a -> boolean monad) -> boolean monad\n\n val for_alli : 'a t -> f:(int -> 'a -> boolean monad) -> boolean monad\n\n val all : 'a monad t -> 'a t monad\n\n val all_unit : unit monad t -> unit monad\n\n val init : int -> f:(int -> 'a monad) -> 'a t monad\n\n val iter : 'a t -> f:('a -> unit monad) -> unit monad\n\n val iteri : 'a t -> f:(int -> 'a -> unit monad) -> unit monad\n\n val map : 'a t -> f:('a -> 'b monad) -> 'b t monad\n\n val mapi : 'a t -> f:(int -> 'a -> 'b monad) -> 'b t monad\nend\n\nmodule List\n (M : Monad_let.S) (Bool : sig\n type t\n\n val any : t list -> t M.t\n\n val all : t list -> t M.t\n end) :\n S\n with type 'a t = 'a list\n and type 'a monad := 'a M.t\n and type boolean := Bool.t = struct\n type 'a t = 'a list\n\n open M.Let_syntax\n\n let foldi t ~init ~f =\n let rec go i acc = function\n | [] ->\n return acc\n | x :: xs ->\n let%bind acc = f i acc x in\n go (i + 1) acc xs\n in\n go 0 init t\n\n let fold t ~init ~f = foldi t ~init ~f:(fun _ acc x -> f acc x)\n\n let fold_map xs ~init ~f =\n let%map res, ys =\n fold xs ~init:(init, []) ~f:(fun (acc, ys) x ->\n let%map acc, y = f acc x in\n (acc, y :: ys) )\n in\n (res, List.rev ys)\n\n let all = M.all\n\n let all_unit = M.all_unit\n\n let init n ~f =\n let rec go acc i =\n if i < 0 then return acc\n else\n let%bind x = f i in\n go (x :: acc) (i - 1)\n in\n go [] (n - 1)\n\n let iteri t ~f =\n let rec go i = function\n | [] ->\n return ()\n | x :: xs ->\n let%bind () = f i x in\n go (i + 1) xs\n in\n go 0 t\n\n let iter t ~f = iteri t ~f:(fun _i x -> f x)\n\n let mapi t ~f =\n let rec go i acc = function\n | [] ->\n return (List.rev acc)\n | x :: xs ->\n let%bind y = f i x in\n go (i + 1) (y :: acc) xs\n in\n go 0 [] t\n\n let map t ~f = mapi t ~f:(fun _i x -> f x)\n\n (* The following functions use [map] to evaluate [f] on every element, since\n * we can't shortcut in the snark -- every constraint is either always\n present or always absent -- so we need to apply [f] to all of them\n * [Bool.any]/[Bool.all] operate by calculating the sum of the array,\n which requires an R1CS variable representing each element to be\n available.\n *)\n\n let existsi t ~f = mapi t ~f >>= Bool.any\n\n let exists t ~f = map t ~f >>= Bool.any\n\n let for_alli t ~f = mapi t ~f >>= Bool.all\n\n let for_all t ~f = map t ~f >>= Bool.all\nend\n\nmodule Array\n (M : Monad_let.S) (Bool : sig\n type t\n\n val any : t array -> t M.t\n\n val all : t array -> t M.t\n end) :\n S\n with type 'a t = 'a array\n and type 'a monad := 'a M.t\n and type boolean := Bool.t = struct\n type 'a t = 'a array\n\n open M.Let_syntax\n\n let foldi t ~init ~f =\n Array.foldi t ~init:(M.return init) ~f:(fun i acc x ->\n let%bind acc = acc in\n f i acc x )\n\n let fold t ~init ~f =\n Array.fold t ~init:(M.return init) ~f:(fun acc x ->\n let%bind acc = acc in\n f acc x )\n\n let iteri t ~f = foldi t ~init:() ~f:(fun i () x -> f i x)\n\n let iter t ~f = fold t ~init:() ~f:(fun () x -> f x)\n\n let init n ~f =\n let rec go arr i =\n if i < 0 then M.return arr\n else\n let%bind x = f i in\n Array.unsafe_set arr i x ;\n go arr (i - 1)\n in\n if n < 0 then invalid_arg \"Monad_sequence.Array.init\"\n else if n = 0 then M.return [||]\n else\n let%bind last = f (n - 1) in\n let arr = Array.create ~len:n last in\n go arr (n - 2)\n\n let mapi t ~f = init (Array.length t) ~f:(fun i -> f i (Array.unsafe_get t i))\n\n let map t ~f = mapi t ~f:(fun _i x -> f x)\n\n let fold_map t ~init ~f =\n let res = ref init in\n let%map t =\n map t ~f:(fun x ->\n let%map acc, y = f !res x in\n res := acc ;\n y )\n in\n (!res, t)\n\n let all = map ~f:(fun x -> x)\n\n let all_unit = iter ~f:(fun x -> x)\n\n (* The following functions use [map] to evaluate [f] on every element, since\n * we can't shortcut in the snark -- every constraint is either always\n present or always absent -- so we need to apply [f] to all of them\n * [Bool.any]/[Bool.all] operate by calculating the sum of the array,\n which requires an R1CS variable representing each element to be\n available.\n *)\n\n let existsi t ~f = mapi t ~f >>= Bool.any\n\n let exists t ~f = map t ~f >>= Bool.any\n\n let for_alli t ~f = mapi t ~f >>= Bool.all\n\n let for_all t ~f = map t ~f >>= Bool.all\nend\n","open Core_kernel\n\nlet int_to_bits ~length n =\n let ith_bit i = (n lsr i) land 1 = 1 in\n List.init length ~f:ith_bit\n\nlet int_of_bits bs =\n List.foldi bs ~init:0 ~f:(fun i acc b -> if b then acc + (1 lsl i) else acc)\n\nmodule Make\n (Impl : Snark_intf.Basic) (M : sig\n type t [@@deriving enum]\n end) =\nstruct\n open Impl\n\n (* TODO: Make this throw when the elt is too big *)\n let field_to_int x = int_of_bits (List.take (Field.unpack x) 62)\n\n open M\n\n let _unused = M.min (* generate unused variable error *)\n\n let bit_length =\n let n = Int.ceil_log2 (M.max + 1) in\n assert (n < Field.size_in_bits) ;\n n\n\n type var = Field.Var.t\n\n let to_field t = Field.of_int (to_enum t)\n\n let of_field x = Option.value_exn (of_enum (field_to_int x))\n\n let assert_equal x y = Field.Checked.Assert.equal x y\n\n let typ : (var, t) Typ.t =\n let check =\n if M.max = 1 then fun x -> assert_ (Constraint.boolean x)\n else fun x ->\n Field.Checked.Assert.lte ~bit_length x\n (constant Field.typ (Field.of_int M.max))\n in\n let (Typ typ) = Typ.transport Field.typ ~there:to_field ~back:of_field in\n Typ { typ with check }\n\n let var_to_bits : var -> Boolean.var list Checked.t =\n Field.Checked.unpack ~length:bit_length\n\n let to_bits t = int_to_bits ~length:bit_length (to_enum t)\n\n let if_ b ~(then_ : var) ~(else_ : var) = Field.Checked.if_ b ~then_ ~else_\n\n let var t : var = constant Field.typ (to_field t)\n\n let ( = ) = Field.Checked.equal\nend\n\nmodule Run = struct\n module Make\n (Impl : Snark_intf.Run_basic) (M : sig\n type t [@@deriving enum]\n end) =\n struct\n open Impl\n include Make (Impl.Internal_Basic) (M)\n\n let assert_equal x y = run_checked (assert_equal x y)\n\n let var_to_bits x = run_checked (var_to_bits x)\n\n let if_ x ~then_ ~else_ = run_checked (if_ x ~then_ ~else_)\n\n let ( = ) x y = run_checked (x = y)\n end\nend\n","module Bignum_bigint = Bigint\nopen Core_kernel\n\nlet pow2 n = Bignum_bigint.(pow (of_int 2) (of_int n))\n\nlet bigint_num_bits =\n let rec go acc i =\n if Bignum_bigint.(acc = zero) then i\n else go (Bignum_bigint.shift_right acc 1) (i + 1)\n in\n fun n -> go n 0\n\nmodule Make (Impl : Snark_intf.Basic) = struct\n open Impl\n open Let_syntax\n\n type t =\n { upper_bound : Bignum_bigint.t\n ; lower_bound : Bignum_bigint.t\n ; var : Field.Var.t\n ; bits : Boolean.var list option\n }\n\n let two_to_the n =\n let rec go acc i = if i <= 0 then acc else go (Field.add acc acc) (i - 1) in\n go Field.one n\n\n let to_bits { var; bits; upper_bound; lower_bound = _ } =\n let length = bigint_num_bits upper_bound in\n with_label \"Number.to_bits\" (fun () ->\n match bits with\n | Some bs ->\n return (List.take bs length)\n | None ->\n Field.Checked.unpack var ~length )\n\n let of_bits bs =\n let n = List.length bs in\n assert (n < Field.size_in_bits) ;\n { upper_bound = Bignum_bigint.(pow2 n - one)\n ; lower_bound = Bignum_bigint.zero\n ; var = Field.Var.pack bs\n ; bits = Some bs\n }\n\n let mul_pow_2 n (`Two_to_the k) =\n let%map bits = to_bits n in\n let multiplied = List.init k ~f:(fun _ -> Boolean.false_) @ bits in\n let upper_bound =\n Bignum_bigint.(n.upper_bound * pow (of_int 2) (of_int k))\n in\n assert (Bignum_bigint.(upper_bound < Field.size)) ;\n { upper_bound\n ; lower_bound = Bignum_bigint.(n.lower_bound * pow (of_int 2) (of_int k))\n ; var = Field.Var.pack multiplied\n ; bits = Some multiplied\n }\n\n let div_pow_2 n (`Two_to_the k) =\n let%map bits = to_bits n in\n let divided = List.drop bits k in\n let divided_of_bits = of_bits divided in\n { upper_bound =\n Bignum_bigint.(divided_of_bits.upper_bound / pow (of_int 2) (of_int k))\n ; lower_bound =\n Bignum_bigint.(divided_of_bits.lower_bound / pow (of_int 2) (of_int k))\n ; var = divided_of_bits.var\n ; bits = divided_of_bits.bits\n }\n\n let clamp_to_n_bits t n =\n assert (n < Field.size_in_bits) ;\n with_label \"Number.clamp_to_n_bits\" (fun () ->\n let k = pow2 n in\n if Bignum_bigint.(t.upper_bound < k) then return t\n else\n let%bind bs = to_bits t in\n let bs' = List.take bs n in\n let g = Field.Var.project bs' in\n let%bind fits = Field.Checked.equal t.var g in\n let%map r =\n Field.Checked.if_ fits ~then_:g\n ~else_:(constant Field.typ Field.(sub (two_to_the n) one))\n in\n { upper_bound = Bignum_bigint.(k - one)\n ; lower_bound = t.lower_bound\n ; var = r\n ; bits = None\n } )\n\n let ( < ) x y =\n let open Bignum_bigint in\n (*\n x [ ]\n y [ ]\n\n x [ ]\n y [ ]\n *)\n with_label \"Number.(<)\" (fun () ->\n if x.upper_bound < y.lower_bound then return Boolean.true_\n else if x.lower_bound >= y.upper_bound then return Boolean.false_\n else\n let bit_length =\n Int.max\n (bigint_num_bits x.upper_bound)\n (bigint_num_bits y.upper_bound)\n in\n let%map { less; _ } = Field.Checked.compare ~bit_length x.var y.var in\n less )\n\n let ( <= ) x y =\n let open Bignum_bigint in\n (*\n x [ ]\n y [ ]\n\n x [ ]\n y [ ]\n *)\n with_label \"Number.(<=)\" (fun () ->\n if x.upper_bound <= y.lower_bound then return Boolean.true_\n else if x.lower_bound > y.upper_bound then return Boolean.false_\n else\n let bit_length =\n Int.max\n (bigint_num_bits x.upper_bound)\n (bigint_num_bits y.upper_bound)\n in\n let%map { less_or_equal; _ } =\n Field.Checked.compare ~bit_length x.var y.var\n in\n less_or_equal )\n\n let ( > ) x y = y < x\n\n let ( >= ) x y = y <= x\n\n let ( = ) x y =\n (* TODO: Have \"short circuiting\" for efficiency as above. *)\n Field.Checked.equal x.var y.var\n\n let to_var { var; _ } = var\n\n let constant x =\n let tick_n = Bigint.of_field x in\n let n = Bigint.to_bignum_bigint tick_n in\n { upper_bound = n\n ; lower_bound = n\n ; var = constant Field.typ x\n ; bits =\n Some\n (List.init (bigint_num_bits n) ~f:(fun i ->\n constant Boolean.typ (Bigint.test_bit tick_n i) ) )\n }\n\n let one = constant Field.one\n\n let zero = constant Field.zero\n\n let of_pow_2 (`Two_to_the k) = constant (Field.of_int (Int.pow 2 k))\n\n let if_ b ~then_ ~else_ =\n let%map var = Field.Checked.if_ b ~then_:then_.var ~else_:else_.var in\n let open Bignum_bigint in\n { upper_bound = max then_.upper_bound else_.upper_bound\n ; lower_bound = min then_.lower_bound else_.lower_bound\n ; var\n ; bits = None\n }\n\n let ( + ) x y =\n let open Bignum_bigint in\n let upper_bound = x.upper_bound + y.upper_bound in\n if upper_bound < Field.size then\n { upper_bound\n ; lower_bound = x.lower_bound + y.lower_bound\n ; var = Field.Var.add x.var y.var\n ; bits = None\n }\n else\n failwithf \"Number.+: Potential overflow: (%s + %s > Field.size)\"\n (to_string x.upper_bound) (to_string y.upper_bound) ()\n\n (* Compute (n, k) -> ceil(n / 2^k) using the identity\n\n ceil(n / m)\n =\n if n % m = 0\n then floor(n / m)\n else floor(n / m) + 1\n =\n if m * floor(n / m) = n\n then floor(n / m)\n else floor(n / m) + 1\n *)\n let ceil_div_pow_2 n m =\n let%bind floor_div = div_pow_2 n m in\n let%bind m_divides_n = mul_pow_2 floor_div m >>= ( = ) n in\n if_ m_divides_n ~then_:floor_div ~else_:(floor_div + one)\n\n let ( - ) x y =\n let open Bignum_bigint in\n (* x_upper_bound >= x >= x_lower_bound >= y_upper_bound >= y >= y_lower_bound *)\n if x.lower_bound >= y.upper_bound then\n { upper_bound = x.upper_bound - y.lower_bound\n ; lower_bound = x.lower_bound - y.upper_bound\n ; var = Field.Var.sub x.var y.var\n ; bits = None\n }\n else\n failwithf \"Number.-: Potential underflow (%s < %s)\"\n (to_string x.lower_bound) (to_string y.upper_bound) ()\n\n let ( * ) x y =\n let open Bignum_bigint in\n with_label \"Number.(*)\" (fun () ->\n let upper_bound = x.upper_bound * y.upper_bound in\n if upper_bound < Field.size then\n let%map var = Field.Checked.mul x.var y.var in\n { upper_bound\n ; lower_bound = x.lower_bound * y.lower_bound\n ; var\n ; bits = None\n }\n else\n failwithf \"Number.*: Potential overflow: (%s * %s > Field.size)\"\n (to_string x.upper_bound) (to_string y.upper_bound) () )\n\n (* x mod n = x - n * floor(x / n) *)\n let mod_pow_2 x n =\n let%bind x_div_n = div_pow_2 x n in\n let%map n_x_div_n = mul_pow_2 x_div_n n in\n let res = x - n_x_div_n in\n { res with\n lower_bound = Bignum_bigint.zero\n ; upper_bound =\n (let (`Two_to_the k) = n in\n Bignum_bigint.(pow (of_int 2) (of_int k)) )\n }\n\n let min x y =\n let%bind less = x < y in\n if_ less ~then_:x ~else_:y\n\n let max x y =\n let%bind less = x < y in\n if_ less ~then_:y ~else_:x\nend\n\nmodule Run = struct\n module Make (Impl : Snark_intf.Run_basic) = struct\n open Impl\n include Make (Impl.Internal_Basic)\n\n let ( * ) x y = run_checked (x * y)\n\n let if_ x ~then_ ~else_ = run_checked (if_ x ~then_ ~else_)\n\n let ( < ) x y = run_checked (x < y)\n\n let ( > ) x y = run_checked (x > y)\n\n let ( <= ) x y = run_checked (x <= y)\n\n let ( >= ) x y = run_checked (x >= y)\n\n let ( = ) x y = run_checked (x = y)\n\n let min x y = run_checked (min x y)\n\n let max x y = run_checked (max x y)\n\n let to_bits x = run_checked (to_bits x)\n\n let div_pow_2 x y = run_checked (div_pow_2 x y)\n\n let ceil_div_pow_2 x y = run_checked (ceil_div_pow_2 x y)\n\n let mul_pow_2 x y = run_checked (mul_pow_2 x y)\n\n let mod_pow_2 x y = run_checked (mod_pow_2 x y)\n\n let clamp_to_n_bits x y = run_checked (clamp_to_n_bits x y)\n end\nend\n","include Snark0\nmodule Backend_intf = Backend_intf\nmodule Merkle_tree = Merkle_tree\n","(* shapes.ml -- registry of Bin_prot shapes *)\n\nopen Core_kernel\nmodule Shape_tbl = Hashtbl.Make (Base.String)\n\nlet shape_tbl : (Bin_prot.Shape.t * string) Shape_tbl.t = Shape_tbl.create ()\n\nlet find path_to_type = Shape_tbl.find shape_tbl path_to_type\n\nlet iteri ~f = Shape_tbl.iteri shape_tbl ~f\n\nlet equal_shapes shape1 shape2 =\n let canonical1 = Bin_prot.Shape.eval shape1 in\n let canonical2 = Bin_prot.Shape.eval shape2 in\n Bin_prot.Shape.Canonical.compare canonical1 canonical2 = 0\n\nlet register path_to_type (shape : Bin_prot.Shape.t) (ty_decl : string) =\n match Shape_tbl.add shape_tbl ~key:path_to_type ~data:(shape, ty_decl) with\n | `Ok ->\n ()\n | `Duplicate -> (\n (* versioned types inside functors that are called more than\n once will yield duplicates; OK if the shapes are the same\n *)\n match find path_to_type with\n | Some (shape', _ty_decl) ->\n if not (equal_shapes shape shape') then\n failwithf \"Different type shapes at path %s\" path_to_type ()\n else ()\n | None ->\n failwithf \"Expected to find registered shape at path %s\" path_to_type\n () )\n","(*----------------------------------------------------------------------------\n Copyright (c) 2017 Inhabited Type LLC.\n\n All rights reserved.\n\n Redistribution and use in source and binary forms, with or without\n modification, are permitted provided that the following conditions\n are met:\n\n 1. Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n\n 2. Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n\n 3. Neither the name of the author nor the names of his contributors\n may be used to endorse or promote products derived from this software\n without specific prior written permission.\n\n THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS ``AS IS'' AND ANY EXPRESS\n OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\n WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR\n ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\n DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS\n OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\n HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,\n STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN\n ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n POSSIBILITY OF SUCH DAMAGE.\n ----------------------------------------------------------------------------*)\n\ntype t =\n { mutable parser_committed_bytes : int\n ; client_committed_bytes : int\n ; off : int\n ; len : int\n ; buffer : Bigstringaf.t\n }\n\nlet create buffer ~off ~len ~committed_bytes =\n { parser_committed_bytes = committed_bytes\n ; client_committed_bytes = committed_bytes\n ; off\n ; len\n ; buffer }\n\nlet length t = t.client_committed_bytes + t.len\nlet client_committed_bytes t = t.client_committed_bytes\nlet parser_committed_bytes t = t.parser_committed_bytes\n\nlet committed_bytes_discrepancy t = t.parser_committed_bytes - t.client_committed_bytes\nlet bytes_for_client_to_commit t = committed_bytes_discrepancy t\n\nlet parser_uncommitted_bytes t = t.len - bytes_for_client_to_commit t\n\nlet invariant t =\n assert (parser_committed_bytes t + parser_uncommitted_bytes t = length t);\n assert (parser_committed_bytes t - client_committed_bytes t = bytes_for_client_to_commit t);\n;;\n\nlet offset_in_buffer t pos =\n t.off + pos - t.client_committed_bytes\n\nlet apply t pos len ~f =\n let off = offset_in_buffer t pos in\n f t.buffer ~off ~len\n\nlet unsafe_get_char t pos =\n let off = offset_in_buffer t pos in\n Bigstringaf.unsafe_get t.buffer off\n\nlet unsafe_get_int16_le t pos =\n let off = offset_in_buffer t pos in\n Bigstringaf.unsafe_get_int16_le t.buffer off\n\nlet unsafe_get_int32_le t pos =\n let off = offset_in_buffer t pos in\n Bigstringaf.unsafe_get_int32_le t.buffer off\n\nlet unsafe_get_int64_le t pos =\n let off = offset_in_buffer t pos in\n Bigstringaf.unsafe_get_int64_le t.buffer off\n\nlet unsafe_get_int16_be t pos =\n let off = offset_in_buffer t pos in\n Bigstringaf.unsafe_get_int16_be t.buffer off\n\nlet unsafe_get_int32_be t pos =\n let off = offset_in_buffer t pos in\n Bigstringaf.unsafe_get_int32_be t.buffer off\n\nlet unsafe_get_int64_be t pos =\n let off = offset_in_buffer t pos in\n Bigstringaf.unsafe_get_int64_be t.buffer off\n\nlet count_while t pos ~f =\n let buffer = t.buffer in\n let off = offset_in_buffer t pos in\n let i = ref off in\n let limit = t.off + t.len in\n while !i < limit && f (Bigstringaf.unsafe_get buffer !i) do\n incr i\n done;\n !i - off\n;;\n\nlet commit t pos =\n t.parser_committed_bytes <- pos\n;;\n","module State = struct\n type 'a t =\n | Partial of 'a partial\n | Lazy of 'a t Lazy.t\n | Done of int * 'a\n | Fail of int * string list * string\n\n and 'a partial =\n { committed : int\n ; continue : Bigstringaf.t -> off:int -> len:int -> More.t -> 'a t }\n\nend\ntype 'a with_state = Input.t -> int -> More.t -> 'a\n\ntype 'a failure = (string list -> string -> 'a State.t) with_state\ntype ('a, 'r) success = ('a -> 'r State.t) with_state\n\ntype 'a t =\n { run : 'r. ('r failure -> ('a, 'r) success -> 'r State.t) with_state }\n\nlet fail_k input pos _ marks msg =\n State.Fail(pos - Input.client_committed_bytes input, marks, msg)\nlet succeed_k input pos _ v =\n State.Done(pos - Input.client_committed_bytes input, v)\n\nlet rec to_exported_state = function\n | State.Partial {committed;continue} ->\n Exported_state.Partial\n { committed\n ; continue =\n fun bs ~off ~len more ->\n to_exported_state (continue bs ~off ~len more)}\n | State.Done (i,x) -> Exported_state.Done (i,x)\n | State.Fail (i, sl, s) -> Exported_state.Fail (i, sl, s)\n | State.Lazy x -> to_exported_state (Lazy.force x)\n\nlet parse p =\n let input = Input.create Bigstringaf.empty ~committed_bytes:0 ~off:0 ~len:0 in\n to_exported_state (p.run input 0 Incomplete fail_k succeed_k)\n\nlet parse_bigstring p input =\n let input = Input.create input ~committed_bytes:0 ~off:0 ~len:(Bigstringaf.length input) in\n Exported_state.state_to_result (to_exported_state (p.run input 0 Complete fail_k succeed_k))\n\nmodule Monad = struct\n let return v =\n { run = fun input pos more _fail succ ->\n succ input pos more v\n }\n\n let fail msg =\n { run = fun input pos more fail _succ ->\n fail input pos more [] msg\n }\n\n let (>>=) p f =\n { run = fun input pos more fail succ ->\n let succ' input' pos' more' v = (f v).run input' pos' more' fail succ in\n p.run input pos more fail succ'\n }\n\n let (>>|) p f =\n { run = fun input pos more fail succ ->\n let succ' input' pos' more' v = succ input' pos' more' (f v) in\n p.run input pos more fail succ'\n }\n\n let (<$>) f m =\n m >>| f\n\n let (<*>) f m =\n (* f >>= fun f -> m >>| f *)\n { run = fun input pos more fail succ ->\n let succ0 input0 pos0 more0 f =\n let succ1 input1 pos1 more1 m = succ input1 pos1 more1 (f m) in\n m.run input0 pos0 more0 fail succ1\n in\n f.run input pos more fail succ0 }\n\n let lift f m =\n f <$> m\n\n let lift2 f m1 m2 =\n { run = fun input pos more fail succ ->\n let succ1 input1 pos1 more1 m1 =\n let succ2 input2 pos2 more2 m2 = succ input2 pos2 more2 (f m1 m2) in\n m2.run input1 pos1 more1 fail succ2\n in\n m1.run input pos more fail succ1 }\n\n let lift3 f m1 m2 m3 =\n { run = fun input pos more fail succ ->\n let succ1 input1 pos1 more1 m1 =\n let succ2 input2 pos2 more2 m2 =\n let succ3 input3 pos3 more3 m3 =\n succ input3 pos3 more3 (f m1 m2 m3) in\n m3.run input2 pos2 more2 fail succ3 in\n m2.run input1 pos1 more1 fail succ2\n in\n m1.run input pos more fail succ1 }\n\n let lift4 f m1 m2 m3 m4 =\n { run = fun input pos more fail succ ->\n let succ1 input1 pos1 more1 m1 =\n let succ2 input2 pos2 more2 m2 =\n let succ3 input3 pos3 more3 m3 =\n let succ4 input4 pos4 more4 m4 =\n succ input4 pos4 more4 (f m1 m2 m3 m4) in\n m4.run input3 pos3 more3 fail succ4 in\n m3.run input2 pos2 more2 fail succ3 in\n m2.run input1 pos1 more1 fail succ2\n in\n m1.run input pos more fail succ1 }\n\n let ( *>) a b =\n (* a >>= fun _ -> b *)\n { run = fun input pos more fail succ ->\n let succ' input' pos' more' _ = b.run input' pos' more' fail succ in\n a.run input pos more fail succ'\n }\n\n let (<* ) a b =\n (* a >>= fun x -> b >>| fun _ -> x *)\n { run = fun input pos more fail succ ->\n let succ0 input0 pos0 more0 x =\n let succ1 input1 pos1 more1 _ = succ input1 pos1 more1 x in\n b.run input0 pos0 more0 fail succ1\n in\n a.run input pos more fail succ0 }\nend\n\nmodule Choice = struct\n let () p mark =\n { run = fun input pos more fail succ ->\n let fail' input' pos' more' marks msg =\n fail input' pos' more' (mark::marks) msg in\n p.run input pos more fail' succ\n }\n\n let (<|>) p q =\n { run = fun input pos more fail succ ->\n let fail' input' pos' more' marks msg =\n (* The only two constructors that introduce new failure continuations are\n * [] and [<|>]. If the initial input position is less than the length\n * of the committed input, then calling the failure continuation will\n * have the effect of unwinding all choices and collecting marks along\n * the way. *)\n if pos < Input.parser_committed_bytes input' then\n fail input' pos' more marks msg\n else\n q.run input' pos more' fail succ in\n p.run input pos more fail' succ\n }\nend\n\nmodule Monad_use_for_debugging = struct\n let return = Monad.return\n let fail = Monad.fail\n let (>>=) = Monad.(>>=)\n\n let (>>|) m f = m >>= fun x -> return (f x)\n\n let (<$>) f m = m >>| f\n let (<*>) f m = f >>= fun f -> m >>| f\n\n let lift = (>>|)\n let lift2 f m1 m2 = f <$> m1 <*> m2\n let lift3 f m1 m2 m3 = f <$> m1 <*> m2 <*> m3\n let lift4 f m1 m2 m3 m4 = f <$> m1 <*> m2 <*> m3 <*> m4\n\n let ( *>) a b = a >>= fun _ -> b\n let (<* ) a b = a >>= fun x -> b >>| fun _ -> x\nend\n","(*----------------------------------------------------------------------------\n Copyright (c) 2016 Inhabited Type LLC.\n\n All rights reserved.\n\n Redistribution and use in source and binary forms, with or without\n modification, are permitted provided that the following conditions\n are met:\n\n 1. Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n\n 2. Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n\n 3. Neither the name of the author nor the names of his contributors\n may be used to endorse or promote products derived from this software\n without specific prior written permission.\n\n THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS ``AS IS'' AND ANY EXPRESS\n OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\n WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR\n ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\n DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS\n OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\n HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,\n STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN\n ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n POSSIBILITY OF SUCH DAMAGE.\n ----------------------------------------------------------------------------*)\n\nmodule Bigarray = struct\n (* Do not access Bigarray operations directly. If anything's needed, refer to\n * the internal Bigstring module. *)\nend\n\ntype bigstring = Bigstringaf.t\n\n\nmodule Unbuffered = struct\n include Parser\n\n include Exported_state\n\n type more = More.t =\n | Complete\n | Incomplete\nend\n\ninclude Unbuffered\ninclude Parser.Monad\ninclude Parser.Choice\n\nmodule Buffered = struct\n type unconsumed = Buffering.unconsumed =\n { buf : bigstring\n ; off : int\n ; len : int }\n\n type input =\n [ `Bigstring of bigstring\n | `String of string ]\n\n type 'a state =\n | Partial of ([ input | `Eof ] -> 'a state)\n | Done of unconsumed * 'a\n | Fail of unconsumed * string list * string\n\n let from_unbuffered_state ~f buffering = function\n | Unbuffered.Partial p -> Partial (f p)\n | Unbuffered.Done(consumed, v) ->\n let unconsumed = Buffering.unconsumed ~shift:consumed buffering in\n Done(unconsumed, v)\n | Unbuffered.Fail(consumed, marks, msg) ->\n let unconsumed = Buffering.unconsumed ~shift:consumed buffering in\n Fail(unconsumed, marks, msg)\n\n let parse ?(initial_buffer_size=0x1000) p =\n if initial_buffer_size < 1 then\n failwith \"parse: invalid argument, initial_buffer_size < 1\";\n let buffering = Buffering.create initial_buffer_size in\n let rec f p input =\n Buffering.shift buffering p.committed;\n let more : More.t =\n match input with\n | `Eof -> Complete\n | #input as input ->\n Buffering.feed_input buffering input;\n Incomplete\n in\n let for_reading = Buffering.for_reading buffering in\n p.continue for_reading ~off:0 ~len:(Bigstringaf.length for_reading) more\n |> from_unbuffered_state buffering ~f\n in\n Unbuffered.parse p\n |> from_unbuffered_state buffering ~f\n\n let feed state input =\n match state with\n | Partial k -> k input\n | Fail(unconsumed, marks, msg) ->\n begin match input with\n | `Eof -> state\n | #input as input ->\n let buffering = Buffering.of_unconsumed unconsumed in\n Buffering.feed_input buffering input;\n Fail(Buffering.unconsumed buffering, marks, msg)\n end\n | Done(unconsumed, v) ->\n begin match input with\n | `Eof -> state\n | #input as input ->\n let buffering = Buffering.of_unconsumed unconsumed in\n Buffering.feed_input buffering input;\n Done(Buffering.unconsumed buffering, v)\n end\n\n let state_to_option = function\n | Done(_, v) -> Some v\n | Partial _ -> None\n | Fail _ -> None\n\n let state_to_result = function\n | Partial _ -> Error \"incomplete input\"\n | Done(_, v) -> Ok v\n | Fail(_, marks, msg) -> Error (Unbuffered.fail_to_string marks msg)\n\n let state_to_unconsumed = function\n | Done(unconsumed, _)\n | Fail(unconsumed, _, _) -> Some unconsumed\n | Partial _ -> None\n\nend\n\n(** BEGIN: getting input *)\n\nlet rec prompt input pos fail succ =\n (* [prompt] should only call [succ] if it has received more input. If there\n * is no chance that the input will grow, i.e., [more = Complete], then\n * [prompt] should call [fail]. Otherwise (in the case where the input\n * hasn't grown but [more = Incomplete] just prompt again. *)\n let parser_uncommitted_bytes = Input.parser_uncommitted_bytes input in\n let parser_committed_bytes = Input.parser_committed_bytes input in\n (* The continuation should not hold any references to input above. *)\n let continue input ~off ~len more =\n if len < parser_uncommitted_bytes then\n failwith \"prompt: input shrunk!\";\n let input = Input.create input ~off ~len ~committed_bytes:parser_committed_bytes in\n if len = parser_uncommitted_bytes then\n match (more : More.t) with\n | Complete -> fail input pos More.Complete\n | Incomplete -> prompt input pos fail succ\n else\n succ input pos more\n in\n State.Partial { committed = Input.bytes_for_client_to_commit input; continue }\n\nlet demand_input =\n { run = fun input pos more fail succ ->\n match (more : More.t) with\n | Complete -> fail input pos more [] \"not enough input\"\n | Incomplete ->\n let succ' input' pos' more' = succ input' pos' more' ()\n and fail' input' pos' more' = fail input' pos' more' [] \"not enough input\" in\n prompt input pos fail' succ'\n }\n\nlet ensure_suspended n input pos more fail succ =\n let rec go =\n { run = fun input' pos' more' fail' succ' ->\n if pos' + n <= Input.length input' then\n succ' input' pos' more' ()\n else\n (demand_input *> go).run input' pos' more' fail' succ'\n }\n in\n (demand_input *> go).run input pos more fail succ\n\nlet unsafe_apply len ~f =\n { run = fun input pos more _fail succ ->\n succ input (pos + len) more (Input.apply input pos len ~f)\n }\n\nlet unsafe_apply_opt len ~f =\n { run = fun input pos more fail succ ->\n match Input.apply input pos len ~f with\n | Error e -> fail input pos more [] e\n | Ok x -> succ input (pos + len) more x\n }\n\nlet ensure n p =\n { run = fun input pos more fail succ ->\n if pos + n <= Input.length input\n then p.run input pos more fail succ\n else\n let succ' input' pos' more' () = p.run input' pos' more' fail succ in\n ensure_suspended n input pos more fail succ' }\n\n(** END: getting input *)\n\nlet at_end_of_input =\n { run = fun input pos more _ succ ->\n if pos < Input.length input then\n succ input pos more false\n else match more with\n | Complete -> succ input pos more true\n | Incomplete ->\n let succ' input' pos' more' = succ input' pos' more' false\n and fail' input' pos' more' = succ input' pos' more' true in\n prompt input pos fail' succ'\n }\n\nlet end_of_input =\n at_end_of_input\n >>= function\n | true -> return ()\n | false -> fail \"end_of_input\"\n\nlet advance n =\n if n < 0\n then fail \"advance\"\n else\n let p =\n { run = fun input pos more _fail succ -> succ input (pos + n) more () }\n in\n ensure n p\n\nlet pos =\n { run = fun input pos more _fail succ -> succ input pos more pos }\n\nlet available =\n { run = fun input pos more _fail succ ->\n succ input pos more (Input.length input - pos)\n }\n\nlet commit =\n { run = fun input pos more _fail succ ->\n Input.commit input pos;\n succ input pos more () }\n\n(* Do not use this if [p] contains a [commit]. *)\nlet unsafe_lookahead p =\n { run = fun input pos more fail succ ->\n let succ' input' _ more' v = succ input' pos more' v in\n p.run input pos more fail succ' }\n\nlet peek_char =\n { run = fun input pos more _fail succ ->\n if pos < Input.length input then\n succ input pos more (Some (Input.unsafe_get_char input pos))\n else if more = Complete then\n succ input pos more None\n else\n let succ' input' pos' more' =\n succ input' pos' more' (Some (Input.unsafe_get_char input' pos'))\n and fail' input' pos' more' =\n succ input' pos' more' None in\n prompt input pos fail' succ'\n }\n\n(* This parser is too important to not be optimized. Do a custom job. *)\nlet rec peek_char_fail =\n { run = fun input pos more fail succ ->\n if pos < Input.length input\n then succ input pos more (Input.unsafe_get_char input pos)\n else\n let succ' input' pos' more' () =\n peek_char_fail.run input' pos' more' fail succ in\n ensure_suspended 1 input pos more fail succ' }\n\nlet satisfy f =\n { run = fun input pos more fail succ ->\n if pos < Input.length input then\n let c = Input.unsafe_get_char input pos in\n if f c\n then succ input (pos + 1) more c\n else Printf.ksprintf (fail input pos more []) \"satisfy: %C\" c\n else\n let succ' input' pos' more' () =\n let c = Input.unsafe_get_char input' pos' in\n if f c\n then succ input' (pos' + 1) more' c\n else Printf.ksprintf (fail input' pos' more' []) \"satisfy: %C\" c\n in\n ensure_suspended 1 input pos more fail succ' }\n\nlet char c =\n let p =\n { run = fun input pos more fail succ ->\n if Input.unsafe_get_char input pos = c\n then succ input (pos + 1) more c\n else fail input pos more [] (Printf.sprintf \"char %C\" c) }\n in\n ensure 1 p\n\nlet not_char c =\n let p =\n { run = fun input pos more fail succ ->\n let c' = Input.unsafe_get_char input pos in\n if c <> c'\n then succ input (pos + 1) more c'\n else fail input pos more [] (Printf.sprintf \"not char %C\" c) }\n in\n ensure 1 p\n\nlet any_char =\n let p =\n { run = fun input pos more _fail succ ->\n succ input (pos + 1) more (Input.unsafe_get_char input pos) }\n in\n ensure 1 p\n\nlet int8 i =\n let p =\n { run = fun input pos more fail succ ->\n let c = Char.code (Input.unsafe_get_char input pos) in\n if c = i land 0xff\n then succ input (pos + 1) more c\n else fail input pos more [] (Printf.sprintf \"int8 %d\" i) }\n in\n ensure 1 p\n\nlet any_uint8 =\n let p =\n { run = fun input pos more _fail succ ->\n let c = Input.unsafe_get_char input pos in\n succ input (pos + 1) more (Char.code c) }\n in\n ensure 1 p\n\nlet any_int8 =\n (* https://graphics.stanford.edu/~seander/bithacks.html#VariableSignExtendRisky *)\n let s = Sys.int_size - 8 in\n let p =\n { run = fun input pos more _fail succ ->\n let c = Input.unsafe_get_char input pos in\n succ input (pos + 1) more ((Char.code c lsl s) asr s) }\n in\n ensure 1 p\n\nlet skip f =\n let p =\n { run = fun input pos more fail succ ->\n if f (Input.unsafe_get_char input pos)\n then succ input (pos + 1) more ()\n else fail input pos more [] \"skip\" }\n in\n ensure 1 p\n\nlet rec count_while ~init ~f ~with_buffer =\n { run = fun input pos more fail succ ->\n let len = Input.count_while input (pos + init) ~f in\n let input_len = Input.length input in\n let init' = init + len in\n (* Check if the loop terminated because it reached the end of the input\n * buffer. If so, then prompt for additional input and continue. *)\n if pos + init' < input_len || more = Complete\n then succ input (pos + init') more (Input.apply input pos init' ~f:with_buffer)\n else\n let succ' input' pos' more' =\n (count_while ~init:init' ~f ~with_buffer).run input' pos' more' fail succ\n and fail' input' pos' more' =\n succ input' (pos' + init') more' (Input.apply input' pos' init' ~f:with_buffer)\n in\n prompt input pos fail' succ'\n }\n\nlet rec count_while1 ~f ~with_buffer =\n { run = fun input pos more fail succ ->\n let len = Input.count_while input pos ~f in\n let input_len = Input.length input in\n (* Check if the loop terminated because it reached the end of the input\n * buffer. If so, then prompt for additional input and continue. *)\n if len < 1\n then\n if pos < input_len || more = Complete\n then fail input pos more [] \"count_while1\"\n else\n let succ' input' pos' more' =\n (count_while1 ~f ~with_buffer).run input' pos' more' fail succ\n and fail' input' pos' more' =\n fail input' pos' more' [] \"count_while1\"\n in\n prompt input pos fail' succ'\n else if pos + len < input_len || more = Complete\n then succ input (pos + len) more (Input.apply input pos len ~f:with_buffer)\n else\n let succ' input' pos' more' =\n (count_while ~init:len ~f ~with_buffer).run input' pos' more' fail succ\n and fail' input' pos' more' =\n succ input' (pos' + len) more' (Input.apply input' pos' len ~f:with_buffer)\n in\n prompt input pos fail' succ'\n }\n\nlet string_ f s =\n (* XXX(seliopou): Inefficient. Could check prefix equality to short-circuit\n * the io. *)\n let len = String.length s in\n ensure len (unsafe_apply_opt len ~f:(fun buffer ~off ~len ->\n let i = ref 0 in\n while !i < len && Char.equal (f (Bigstringaf.unsafe_get buffer (off + !i)))\n (f (String.unsafe_get s !i))\n do\n incr i\n done;\n if len = !i\n then Ok (Bigstringaf.substring buffer ~off ~len)\n else Error \"string\"))\n\nlet string s = string_ (fun x -> x) s\nlet string_ci s = string_ Char.lowercase_ascii s\n\nlet skip_while f =\n count_while ~init:0 ~f ~with_buffer:(fun _ ~off:_ ~len:_ -> ())\n\nlet take n =\n if n < 0\n then fail \"take: n < 0\"\n else\n let n = max n 0 in\n ensure n (unsafe_apply n ~f:Bigstringaf.substring)\n\nlet take_bigstring n =\n if n < 0\n then fail \"take_bigstring: n < 0\"\n else\n let n = max n 0 in\n ensure n (unsafe_apply n ~f:Bigstringaf.copy)\n\nlet take_bigstring_while f =\n count_while ~init:0 ~f ~with_buffer:Bigstringaf.copy\n\nlet take_bigstring_while1 f =\n count_while1 ~f ~with_buffer:Bigstringaf.copy\n\nlet take_bigstring_till f =\n take_bigstring_while (fun c -> not (f c))\n\nlet peek_string n =\n unsafe_lookahead (take n)\n\nlet take_while f =\n count_while ~init:0 ~f ~with_buffer:Bigstringaf.substring\n\nlet take_while1 f =\n count_while1 ~f ~with_buffer:Bigstringaf.substring\n\nlet take_till f =\n take_while (fun c -> not (f c))\n\nlet choice ?(failure_msg=\"no more choices\") ps =\n List.fold_right (<|>) ps (fail failure_msg)\n\nlet fix_direct f =\n let rec p = lazy (f r)\n and r = { run = fun buf pos more fail succ ->\n (Lazy.force p).run buf pos more fail succ }\n in\n r\n\nlet fix_lazy f =\n let max_steps = 20 in\n let steps = ref max_steps in\n let rec p = lazy (f r)\n and r = { run = fun buf pos more fail succ ->\n decr steps;\n if !steps < 0\n then (\n steps := max_steps;\n State.Lazy (lazy ((Lazy.force p).run buf pos more fail succ)))\n else\n (Lazy.force p).run buf pos more fail succ\n }\n in\n r\n\nlet fix = match Sys.backend_type with\n | Native -> fix_direct\n | Bytecode -> fix_direct\n | Other _ -> fix_lazy\n\nlet option x p =\n p <|> return x\n\nlet cons x xs = x :: xs\n\nlet rec list ps =\n match ps with\n | [] -> return []\n | p::ps -> lift2 cons p (list ps)\n\nlet count n p =\n if n < 0 \n then fail \"count: n < 0\"\n else \n let rec loop = function\n | 0 -> return []\n | n -> lift2 cons p (loop (n - 1))\n in\n loop n\n\nlet many p =\n fix (fun m ->\n (lift2 cons p m) <|> return [])\n\nlet many1 p =\n lift2 cons p (many p)\n\nlet many_till p t =\n fix (fun m ->\n (t *> return []) <|> (lift2 cons p m))\n\nlet sep_by1 s p =\n fix (fun m ->\n lift2 cons p ((s *> m) <|> return []))\n\nlet sep_by s p =\n (lift2 cons p ((s *> sep_by1 s p) <|> return [])) <|> return []\n\nlet skip_many p =\n fix (fun m ->\n (p *> m) <|> return ())\n\nlet skip_many1 p =\n p *> skip_many p\n\nlet end_of_line =\n (char '\\n' *> return ()) <|> (string \"\\r\\n\" *> return ()) \"end_of_line\"\n\nlet scan_ state f ~with_buffer =\n { run = fun input pos more fail succ ->\n let state = ref state in\n let parser =\n count_while ~init:0 ~f:(fun c ->\n match f !state c with\n | None -> false\n | Some state' -> state := state'; true)\n ~with_buffer\n >>| fun x -> x, !state\n in\n parser.run input pos more fail succ }\n\nlet scan state f =\n scan_ state f ~with_buffer:Bigstringaf.substring\n\nlet scan_state state f =\n scan_ state f ~with_buffer:(fun _ ~off:_ ~len:_ -> ())\n >>| fun ((), state) -> state\n\nlet scan_string state f =\n scan state f >>| fst\n\nlet consume_with p f =\n { run = fun input pos more fail succ ->\n let start = pos in\n let parser_committed_bytes = Input.parser_committed_bytes input in\n let succ' input' pos' more' _ =\n if parser_committed_bytes <> Input.parser_committed_bytes input'\n then fail input' pos' more' [] \"consumed: parser committed\"\n else (\n let len = pos' - start in\n let consumed = Input.apply input' start len ~f in\n succ input' pos' more' consumed)\n in\n p.run input pos more fail succ'\n }\n\nlet consumed p = consume_with p Bigstringaf.substring\nlet consumed_bigstring p = consume_with p Bigstringaf.copy\n\nlet both a b = lift2 (fun a b -> a, b) a b\nlet map t ~f = t >>| f\nlet bind t ~f = t >>= f\nlet map2 a b ~f = lift2 f a b\nlet map3 a b c ~f = lift3 f a b c\nlet map4 a b c d ~f = lift4 f a b c d\n\nmodule Let_syntax = struct\n let return = return\n let ( >>| ) = ( >>| )\n let ( >>= ) = ( >>= )\n\n module Let_syntax = struct\n let return = return\n let map = map\n let bind = bind\n let both = both\n let map2 = map2\n let map3 = map3\n let map4 = map4\n end\nend\n\nlet ( let+ ) = ( >>| )\nlet ( let* ) = ( >>= )\nlet ( and+ ) = both\n\nmodule BE = struct\n (* XXX(seliopou): The pattern in both this module and [LE] are a compromise\n * between efficiency and code reuse. By inlining [ensure] you can recover\n * about 2 nanoseconds on average. That may add up in certain applications.\n *\n * This pattern does not allocate in the fast (success) path.\n * *)\n let int16 n =\n let bytes = 2 in\n let p =\n { run = fun input pos more fail succ ->\n if Input.unsafe_get_int16_be input pos = (n land 0xffff)\n then succ input (pos + bytes) more ()\n else fail input pos more [] \"BE.int16\" }\n in\n ensure bytes p\n\n let int32 n =\n let bytes = 4 in\n let p =\n { run = fun input pos more fail succ ->\n if Int32.equal (Input.unsafe_get_int32_be input pos) n\n then succ input (pos + bytes) more ()\n else fail input pos more [] \"BE.int32\" }\n in\n ensure bytes p\n\n let int64 n =\n let bytes = 8 in\n let p =\n { run = fun input pos more fail succ ->\n if Int64.equal (Input.unsafe_get_int64_be input pos) n\n then succ input (pos + bytes) more ()\n else fail input pos more [] \"BE.int64\" }\n in\n ensure bytes p\n\n let any_uint16 =\n ensure 2 (unsafe_apply 2 ~f:(fun bs ~off ~len:_ -> Bigstringaf.unsafe_get_int16_be bs off))\n\n let any_int16 =\n ensure 2 (unsafe_apply 2 ~f:(fun bs ~off ~len:_ -> Bigstringaf.unsafe_get_int16_sign_extended_be bs off))\n\n let any_int32 =\n ensure 4 (unsafe_apply 4 ~f:(fun bs ~off ~len:_ -> Bigstringaf.unsafe_get_int32_be bs off))\n\n let any_int64 =\n ensure 8 (unsafe_apply 8 ~f:(fun bs ~off ~len:_ -> Bigstringaf.unsafe_get_int64_be bs off))\n\n let any_float =\n ensure 4 (unsafe_apply 4 ~f:(fun bs ~off ~len:_ -> Int32.float_of_bits (Bigstringaf.unsafe_get_int32_be bs off)))\n\n let any_double =\n ensure 8 (unsafe_apply 8 ~f:(fun bs ~off ~len:_ -> Int64.float_of_bits (Bigstringaf.unsafe_get_int64_be bs off)))\nend\n\nmodule LE = struct\n let int16 n =\n let bytes = 2 in\n let p =\n { run = fun input pos more fail succ ->\n if Input.unsafe_get_int16_le input pos = (n land 0xffff)\n then succ input (pos + bytes) more ()\n else fail input pos more [] \"LE.int16\" }\n in\n ensure bytes p\n\n let int32 n =\n let bytes = 4 in\n let p =\n { run = fun input pos more fail succ ->\n if Int32.equal (Input.unsafe_get_int32_le input pos) n\n then succ input (pos + bytes) more ()\n else fail input pos more [] \"LE.int32\" }\n in\n ensure bytes p\n\n let int64 n =\n let bytes = 8 in\n let p =\n { run = fun input pos more fail succ ->\n if Int64.equal (Input.unsafe_get_int64_le input pos) n\n then succ input (pos + bytes) more ()\n else fail input pos more [] \"LE.int64\" }\n in\n ensure bytes p\n\n\n let any_uint16 =\n ensure 2 (unsafe_apply 2 ~f:(fun bs ~off ~len:_ -> Bigstringaf.unsafe_get_int16_le bs off))\n\n let any_int16 =\n ensure 2 (unsafe_apply 2 ~f:(fun bs ~off ~len:_ -> Bigstringaf.unsafe_get_int16_sign_extended_le bs off))\n\n let any_int32 =\n ensure 4 (unsafe_apply 4 ~f:(fun bs ~off ~len:_ -> Bigstringaf.unsafe_get_int32_le bs off))\n\n let any_int64 =\n ensure 8 (unsafe_apply 8 ~f:(fun bs ~off ~len:_ -> Bigstringaf.unsafe_get_int64_le bs off))\n\n let any_float =\n ensure 4 (unsafe_apply 4 ~f:(fun bs ~off ~len:_ -> Int32.float_of_bits (Bigstringaf.unsafe_get_int32_le bs off)))\n\n let any_double =\n ensure 8 (unsafe_apply 8 ~f:(fun bs ~off ~len:_ -> Int64.float_of_bits (Bigstringaf.unsafe_get_int64_le bs off)))\nend\n\nmodule Unsafe = struct\n let take n f =\n let n = max n 0 in\n ensure n (unsafe_apply n ~f)\n\n let peek n f =\n unsafe_lookahead (take n f)\n\n let take_while check f =\n count_while ~init:0 ~f:check ~with_buffer:f\n\n let take_while1 check f =\n count_while1 ~f:check ~with_buffer:f\n\n let take_till check f =\n take_while (fun c -> not (check c)) f\nend\n\nmodule Consume = struct\n type t =\n | Prefix\n | All\nend\n\nlet parse_bigstring ~consume p bs =\n let p =\n match (consume : Consume.t) with\n | Prefix -> p\n | All -> p <* end_of_input\n in\n Unbuffered.parse_bigstring p bs\n\nlet parse_string ~consume p s =\n let len = String.length s in\n let bs = Bigstringaf.create len in\n Bigstringaf.unsafe_blit_from_string s ~src_off:0 bs ~dst_off:0 ~len;\n parse_bigstring ~consume p bs\n","open Core_kernel\n\ntype mode = Hidden | Inline | After\n\ntype config =\n { mode : mode; max_interpolation_length : int; pretty_print : bool }\n\nlet rec result_fold_left ls ~init ~f =\n match ls with\n | [] ->\n Ok init\n | h :: t -> (\n match f init h with\n | Ok init' ->\n result_fold_left t ~init:init' ~f\n | Error err ->\n Error err )\n\nlet parser =\n let open Angstrom in\n let not_f f x = not (f x) in\n let or_f f g x = f x || g x in\n let is_alpha = function\n | 'a' .. 'z' | 'A' .. 'Z' | '_' ->\n true\n | _ ->\n false\n in\n let is_numeric = function '0' .. '9' -> true | _ -> false in\n let interpolation =\n lift2\n (fun c s -> String.of_char c ^ s)\n (char '$' *> commit *> satisfy is_alpha)\n (take_while (or_f is_alpha is_numeric))\n in\n let message =\n many1\n (choice\n [ (take_while1 (not_f (Char.equal '$')) >>| fun x -> `Raw x)\n ; (interpolation >>| fun x -> `Interpolate x)\n ] )\n in\n message <* end_of_input\n\nlet parse = Angstrom.parse_string ~consume:All parser\n\n(* map and concat vs. fold: which is better for strings? *)\nlet render ~max_interpolation_length ~format_json metadata items =\n let open Result.Let_syntax in\n let%map msg, extra =\n result_fold_left items ~init:(\"\", []) ~f:(fun (msg_acc, extra_acc) el ->\n match el with\n | `Raw str ->\n Ok (msg_acc ^ str, extra_acc)\n | `Interpolate id ->\n let%map json =\n String.Map.find metadata id\n |> Result.of_option ~error:(sprintf \"bad interpolation for %s\" id)\n in\n let str = format_json json in\n if String.length str > max_interpolation_length then\n (msg_acc ^ \"$\" ^ id, (id, str) :: extra_acc)\n else (msg_acc ^ str, extra_acc) )\n in\n (msg, List.rev extra)\n\nlet interpolate { mode; max_interpolation_length; pretty_print } msg metadata =\n let open Result.Let_syntax in\n let format_json =\n if pretty_print then Yojson.Safe.pretty_to_string\n else Yojson.Safe.to_string ?buf:None ?len:None\n in\n match mode with\n | Hidden ->\n Ok (msg, [])\n | Inline ->\n let%bind items = parse msg in\n render ~max_interpolation_length ~format_json metadata items\n | After ->\n Ok\n ( msg\n , List.map (String.Map.to_alist metadata) ~f:(fun (k, v) ->\n (k, format_json v) ) )\n","open Core_kernel\n\ntype t = ..\n\ntype id = string [@@deriving equal, yojson, sexp]\n\nmodule Set = String.Set\n\nlet id_of_string s = s\n\nlet string_of_id s = s\n\ntype repr =\n { id : id\n ; event_name : string\n ; arguments : String.Set.t\n ; log : t -> (string * (string * Yojson.Safe.t) list) option\n ; parse : (string * Yojson.Safe.t) list -> t option\n }\n\nmodule Registry = struct\n let reprs : repr list ref = ref []\n\n let register_constructor repr = reprs := repr :: !reprs\nend\n\nlet parse_exn id json_pairs =\n let result =\n List.find_map !Registry.reprs ~f:(fun repr ->\n if equal_id id repr.id then\n let json_pairs =\n (* Remove additional metadata that may have been added to the log\n message.\n *)\n List.filter json_pairs ~f:(fun (field_name, _) ->\n Set.mem repr.arguments field_name )\n in\n match repr.parse json_pairs with\n | Some t ->\n Some t\n | None ->\n failwithf\n \"parse_exn: parser for id %s found, but failed when applied to \\\n arguments: %s\"\n id\n ( List.map json_pairs ~f:(fun (name, json) ->\n sprintf \"%s = %s\" name (Yojson.Safe.to_string json) )\n |> String.concat ~sep:\",\" )\n ()\n else None )\n in\n match result with\n | Some data ->\n data\n | None ->\n failwithf \"parse_exn: did not find matching parser for id %s\" id ()\n\nlet log t =\n let result =\n List.find_map !Registry.reprs ~f:(fun repr ->\n Option.map (repr.log t) ~f:(fun (msg, fields) -> (msg, repr.id, fields)) )\n in\n match result with\n | Some data ->\n data\n | None ->\n let[@warning \"-3\"] name =\n Obj.extension_name (Obj.extension_constructor t)\n in\n failwithf \"log: did not find matching logger for %s\" name ()\n\nlet register_constructor = Registry.register_constructor\n\nlet dump_registered_events () =\n List.map !Registry.reprs ~f:(fun { event_name; id; arguments; _ } ->\n (event_name, id, Set.to_list arguments) )\n\nlet check_interpolations_exn ~msg_loc msg label_names =\n (* don't use Logproc_lib, which depends on C++ code\n using Interpolator_lib allows use in js_of_ocaml\n the `parse` code is the same\n *)\n match Interpolator_lib.Interpolator.parse msg with\n | Error err ->\n failwithf\n \"%s\\nEncountered an error while parsing the structured log message: %s\"\n msg_loc err ()\n | Ok items ->\n List.iter items ~f:(function\n | `Interpolate interp\n when not (List.mem ~equal:String.equal label_names interp) ->\n failwithf\n \"%s\\n\\\n The structured log message contains interpolation point \\\"$%s\\\" \\\n which is not a field in the record\"\n msg_loc interp ()\n | _ ->\n () )\n","type z = Z of z\n\ntype 'a s = Z | S of 'a\n\ntype _ t = Z : z t | S : 'n t -> 'n s t\n\ntype 'a nat = 'a t\n\ntype e = T : 'n nat -> e\n\nlet to_int : type n. n t -> int =\n let rec go : type n. int -> n t -> int =\n fun acc n -> match n with Z -> acc | S n -> go (acc + 1) n\n in\n fun x -> go 0 x\n\nlet rec of_int : int -> e =\n fun n ->\n if n < 0 then failwith \"of_int: negative\"\n else if n = 0 then T Z\n else\n let (T n) = of_int (n - 1) in\n T (S n)\n\nmodule type Intf = sig\n type n\n\n val n : n t\nend\n\nmodule Adds = struct\n type ('a, 'b, 'c) t =\n | Z : (z, 'n, 'n) t\n | S : ('a, 'b, 'c) t -> ('a s, 'b, 'c s) t\n\n let rec add_zr : type n. n nat -> (n, z, n) t = function\n | Z ->\n Z\n | S n ->\n let pi = add_zr n in\n S pi\nend\n\nmodule Lte = struct\n type (_, _) t = Z : (z, _) t | S : ('n, 'm) t -> ('n s, 'm s) t\n\n let rec refl : type n. n nat -> (n, n) t = function\n | Z ->\n Z\n | S n ->\n S (refl n)\n\n let rec trans : type a b c. (a, b) t -> (b, c) t -> (a, c) t =\n fun t1 t2 -> match (t1, t2) with Z, _ -> Z | S t1, S t2 -> S (trans t1 t2)\nend\n\nmodule N0 = struct\n type 'a plus_n = 'a\n\n type n = z\n\n let n = Z\n\n let add m = (m, Adds.Z)\n\n let eq = Core_kernel.Type_equal.T\nend\n\nmodule Add = struct\n module type Intf = sig\n type _ plus_n\n\n type n\n\n val eq : (n, z plus_n) Core_kernel.Type_equal.t\n\n val n : z plus_n t\n\n val add : 'm nat -> 'm plus_n nat * (z plus_n, 'm, 'm plus_n) Adds.t\n end\n\n let rec create : type n. n nat -> (module Intf with type n = n) = function\n | Z ->\n (module N0)\n | S n ->\n let (module N) = create n in\n let T = N.eq in\n let module Sn = struct\n type 'a plus_n = 'a N.plus_n s\n\n type n = N.n s\n\n let n = S N.n\n\n let eq = Core_kernel.Type_equal.T\n\n let add t =\n let t_plus_n, pi = N.add t in\n (S t_plus_n, Adds.S pi)\n end in\n (module Sn)\n\n let n : type n. (module Intf with type n = n) -> n nat =\n fun (module N) ->\n let T = N.eq in\n N.n\n\n module type Intf_transparent = sig\n type _ plus_n\n\n type n = z plus_n\n\n val eq : (n, z plus_n) Core_kernel.Type_equal.t\n\n val n : z plus_n t\n\n val add : 'm nat -> 'm plus_n nat * (z plus_n, 'm, 'm plus_n) Adds.t\n end\nend\n\nmodule S (N : Add.Intf) = struct\n type 'a plus_n = 'a N.plus_n s\n\n type n = z plus_n\n\n let n = S N.n\n\n let add m =\n let k, pi = N.add m in\n (S k, Adds.S pi)\n\n let eq = match N.eq with T -> Core_kernel.Type_equal.T\nend\n\nmodule N1 = S (N0)\nmodule N2 = S (N1)\nmodule N3 = S (N2)\nmodule N4 = S (N3)\nmodule N5 = S (N4)\nmodule N6 = S (N5)\nmodule N7 = S (N6)\nmodule N8 = S (N7)\nmodule N9 = S (N8)\nmodule N10 = S (N9)\nmodule N11 = S (N10)\nmodule N12 = S (N11)\nmodule N13 = S (N12)\nmodule N14 = S (N13)\nmodule N15 = S (N14)\nmodule N16 = S (N15)\nmodule N17 = S (N16)\nmodule N18 = S (N17)\nmodule N19 = S (N18)\nmodule N20 = S (N19)\nmodule N21 = S (N20)\nmodule N22 = S (N21)\nmodule N23 = S (N22)\nmodule N24 = S (N23)\nmodule N25 = S (N24)\nmodule N26 = S (N25)\nmodule N27 = S (N26)\nmodule N28 = S (N27)\nmodule N29 = S (N28)\nmodule N30 = S (N29)\nmodule N31 = S (N30)\nmodule N32 = S (N31)\nmodule N33 = S (N32)\nmodule N34 = S (N33)\nmodule N35 = S (N34)\nmodule N36 = S (N35)\nmodule N37 = S (N36)\nmodule N38 = S (N37)\nmodule N39 = S (N38)\nmodule N40 = S (N39)\nmodule N41 = S (N40)\nmodule N42 = S (N41)\nmodule N43 = S (N42)\nmodule N44 = S (N43)\nmodule N45 = S (N44)\nmodule N46 = S (N45)\nmodule N47 = S (N46)\nmodule N48 = S (N47)\n\nmodule Empty = struct\n type t = T of t\n\n let rec elim : type a. t -> a = function T t -> elim t\nend\n\nmodule Not = struct\n type 'a t = 'a -> Empty.t\nend\n\nopen Core_kernel\n\nlet rec compare :\n type n m. n t -> m t -> [ `Lte of (n, m) Lte.t | `Gt of (n, m) Lte.t Not.t ]\n =\n fun n m ->\n match (n, m) with\n | Z, _ ->\n `Lte Lte.Z\n | S _, Z ->\n `Gt (function _ -> .)\n | S n, S m -> (\n match compare n m with\n | `Lte pi ->\n `Lte (S pi)\n | `Gt gt ->\n `Gt (function S pi -> gt pi) )\n\nlet lte_exn n m =\n match compare n m with `Lte pi -> pi | `Gt _gt -> failwith \"lte_exn\"\n\nlet rec gt_implies_gte :\n type n m. n nat -> m nat -> (n, m) Lte.t Not.t -> (m, n) Lte.t =\n fun n m not_lte ->\n match (n, m) with\n | Z, _ ->\n Empty.elim (not_lte Z)\n | S _, Z ->\n Z\n | S n, S m ->\n S (gt_implies_gte n m (fun pi -> not_lte (S pi)))\n\nlet rec eq :\n type n m.\n n nat\n -> m nat\n -> [ `Equal of (n, m) Type_equal.t\n | `Not_equal of (n, m) Type_equal.t Not.t ] =\n fun n m ->\n match (n, m) with\n | Z, Z ->\n `Equal T\n | S _, Z ->\n `Not_equal (function _ -> .)\n | Z, S _ ->\n `Not_equal (function _ -> .)\n | S n, S m -> (\n match eq n m with\n | `Equal T ->\n `Equal T\n | `Not_equal f ->\n `Not_equal (function T -> f T) )\n\nlet eq_exn : type n m. n nat -> m nat -> (n, m) Type_equal.t =\n fun n m ->\n match eq n m with\n | `Equal t ->\n t\n | `Not_equal _ ->\n failwithf \"eq_exn: %d vs %d\" (to_int n) (to_int m) ()\n\nmodule type I = Add.Intf_transparent\n","module Length = struct\n type (_, _) t =\n | Z : (unit, Nat.z) t\n | S : ('tail, 'n) t -> ('a * 'tail, 'n Nat.s) t\n\n let rec to_nat : type xs n. (xs, n) t -> n Nat.t = function\n | Z ->\n Z\n | S n ->\n S (to_nat n)\n\n type 'xs n = T : 'n Nat.t * ('xs, 'n) t -> 'xs n\n\n let rec contr :\n type xs n m. (xs, n) t -> (xs, m) t -> (n, m) Core_kernel.Type_equal.t =\n fun t1 t2 ->\n match (t1, t2) with\n | Z, Z ->\n T\n | S n, S m ->\n let T = contr n m in\n T\nend\n\nmodule H1 (F : Poly_types.T1) = struct\n type _ t = [] : unit t | ( :: ) : 'a F.t * 'b t -> ('a * 'b) t\n\n let rec length : type tail1. tail1 t -> tail1 Length.n = function\n | [] ->\n T (Z, Z)\n | _ :: xs ->\n let (T (n, p)) = length xs in\n T (S n, S p)\nend\n\nmodule H1_1 (F : Poly_types.T2) = struct\n type (_, 's) t =\n | [] : (unit, _) t\n | ( :: ) : ('a, 's) F.t * ('b, 's) t -> ('a * 'b, 's) t\n\n let rec length : type tail1 tail2. (tail1, tail2) t -> tail1 Length.n =\n function\n | [] ->\n T (Z, Z)\n | _ :: xs ->\n let (T (n, p)) = length xs in\n T (S n, S p)\nend\n\nmodule Id = struct\n type 'a t = 'a\nend\n\nmodule HlistId = H1 (Id)\n","open Core_kernel\nopen Pickles_types\nmodule Max_state_size = Nat.N8\n\nmodule V = struct\n (* Think about versioning here! These vector types *will* change\n serialization if the numbers above change, and so will require a new\n version number. Thus, it's important that these are modules with new\n versioned types, and not just module aliases to the corresponding vector\n implementation.\n *)\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n type 'a t = 'a Vector.Vector_8.Stable.V1.t\n [@@deriving compare, yojson, sexp, hash, equal]\n end\n end]\n\n type 'a t = 'a Vector.Vector_8.t\n [@@deriving compare, yojson, sexp, hash, equal]\n\n let map = Vector.map\n\n let of_list_exn = Vector.Vector_8.of_list_exn\n\n let to_list = Vector.to_list\nend\n\nlet _type_equal :\n type a. (a V.t, a Vector.With_length(Max_state_size).t) Type_equal.t =\n Type_equal.T\n\nlet typ t = Vector.typ t Max_state_size.n\n\nopen Core_kernel\n\nmodule Value = struct\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n type t = Zkapp_basic.F.Stable.V1.t V.Stable.V1.t\n [@@deriving sexp, equal, yojson, hash, compare]\n\n let to_latest = Fn.id\n end\n end]\n\n type t = Zkapp_basic.F.t V.t [@@deriving sexp, equal, yojson, hash, compare]\n\n let (_ : (t, Stable.Latest.t) Type_equal.t) = Type_equal.T\nend\n\nlet to_input (t : _ V.t) ~f =\n Vector.(reduce_exn (map t ~f) ~f:Random_oracle_input.Chunked.append)\n\nlet deriver inner obj =\n let open Fields_derivers_zkapps.Derivers in\n iso ~map:V.of_list_exn ~contramap:V.to_list\n ((list ~static_length:(Nat.to_int Max_state_size.n) @@ inner @@ o ())\n (o ()) )\n obj\n","open Core_kernel\nopen Kimchi_backend_common\n\nmodule Rounds : sig\n open Pickles_types\n\n module Wrap : Nat.Add.Intf_transparent\n\n module Wrap_vector : Vector.With_version(Wrap).S\n\n module Step : Nat.Add.Intf_transparent\n\n module Step_vector : Vector.With_version(Step).S\nend = struct\n open Pickles_types\n module Wrap = Nat.N15\n module Step = Nat.N16\n\n (* Think about versioning here! These vector types *will* change\n serialization if the numbers above change, and so will require a new\n version number. Thus, it's important that these are modules with new\n versioned types, and not just module aliases to the corresponding vector\n implementation.\n *)\n\n module Wrap_vector = struct\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n type 'a t = 'a Vector.Vector_15.Stable.V1.t\n [@@deriving compare, yojson, sexp, hash, equal]\n end\n end]\n\n type 'a t = 'a Vector.Vector_15.t\n [@@deriving compare, yojson, sexp, hash, equal]\n\n let map = Vector.map\n\n let of_list_exn = Vector.Vector_15.of_list_exn\n\n let to_list = Vector.to_list\n end\n\n module Step_vector = struct\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n type 'a t = 'a Vector.Vector_16.Stable.V1.t\n [@@deriving compare, yojson, sexp, hash, equal]\n end\n end]\n\n type 'a t = 'a Vector.Vector_16.t\n [@@deriving compare, yojson, sexp, hash, equal]\n\n let map = Vector.map\n\n let of_list_exn = Vector.Vector_16.of_list_exn\n\n let to_list = Vector.to_list\n end\nend\n\n(* why use a functor here? *)\nmodule Bigint256 =\n Kimchi_backend_common.Bigint.Make\n (Pasta_bindings.BigInt256)\n (struct\n let length_in_bytes = 32\n end)\n\n(* the two pasta fields and curves *)\n\nmodule Fp = Field.Make (struct\n module Bigint = Bigint256\n include Pasta_bindings.Fp\n module Vector = Kimchi_bindings.FieldVectors.Fp\nend)\n\nmodule Fq = Field.Make (struct\n module Bigint = Bigint256\n include Pasta_bindings.Fq\n module Vector = Kimchi_bindings.FieldVectors.Fq\nend)\n\nmodule Vesta = struct\n module Params = struct\n open Fq\n\n let a = zero\n\n let b = of_int 5\n end\n\n include Curve.Make (Fq) (Fp) (Params) (Pasta_bindings.Vesta)\nend\n\nmodule Pallas = struct\n module Params = struct\n open Fp\n\n let a = zero\n\n let b = of_int 5\n end\n\n include Curve.Make (Fp) (Fq) (Params) (Pasta_bindings.Pallas)\nend\n\n(* the polynomial commitment types *)\n\nmodule Fq_poly_comm = Kimchi_backend_common.Poly_comm.Make (struct\n module Curve = Pallas\n module Base_field = Fp\n\n module Backend = struct\n type t = Curve.Affine.Backend.t Kimchi_types.poly_comm\n\n let shifted ({ shifted; _ } : t) = shifted\n\n let unshifted ({ unshifted; _ } : t) = unshifted\n\n let make :\n Curve.Affine.Backend.t array -> Curve.Affine.Backend.t option -> t =\n fun unshifted shifted : t -> { shifted; unshifted }\n end\nend)\n\nmodule Fp_poly_comm = Kimchi_backend_common.Poly_comm.Make (struct\n module Curve = Vesta\n module Base_field = Fq\n\n module Backend = struct\n type t = Curve.Affine.Backend.t Kimchi_types.poly_comm\n\n let shifted ({ shifted; _ } : t) = shifted\n\n let unshifted ({ unshifted; _ } : t) = unshifted\n\n let make :\n Curve.Affine.Backend.t array -> Curve.Affine.Backend.t option -> t =\n fun unshifted shifted : t -> { shifted; unshifted }\n end\nend)\n","open Core_kernel\nopen Poly_types\nmodule Id = Hlist0.Id\nmodule HlistId = Hlist0.HlistId\nmodule H1_1 = Hlist0.H1_1\n\nmodule E13 (T : T1) = struct\n type ('a, _, _) t = 'a T.t\nend\n\nmodule E23 (T : T2) = struct\n type ('a, 'b, _) t = ('a, 'b) T.t\nend\n\nmodule E01 (T : T0) = struct\n type _ t = T.t\nend\n\nmodule E02 (T : T0) = struct\n type (_, _) t = T.t\nend\n\nmodule E03 (T : T0) = struct\n type (_, _, _) t = T.t\nend\n\nmodule E04 (T : T0) = struct\n type (_, _, _, _) t = T.t\nend\n\nmodule E06 (T : T0) = struct\n type (_, _, _, _, _, _) t = T.t\nend\n\nmodule Tuple2 (F : T3) (G : T3) = struct\n type ('a, 'b, 'c) t = ('a, 'b, 'c) F.t * ('a, 'b, 'c) G.t\nend\n\nmodule Tuple3 (F : T3) (G : T3) (H : T3) = struct\n type ('a, 'b, 'c) t = ('a, 'b, 'c) F.t * ('a, 'b, 'c) G.t * ('a, 'b, 'c) H.t\nend\n\nmodule Tuple4 (F : T3) (G : T3) (H : T3) (I : T3) = struct\n type ('a, 'b, 'c) t =\n ('a, 'b, 'c) F.t * ('a, 'b, 'c) G.t * ('a, 'b, 'c) H.t * ('a, 'b, 'c) I.t\nend\n\nmodule Tuple5 (F : T3) (G : T3) (H : T3) (I : T3) (J : T3) = struct\n type ('a, 'b, 'c) t =\n ('a, 'b, 'c) F.t\n * ('a, 'b, 'c) G.t\n * ('a, 'b, 'c) H.t\n * ('a, 'b, 'c) I.t\n * ('a, 'b, 'c) J.t\nend\n\nmodule Arg1 = struct\n type ('a, _, _) t = 'a\nend\n\nmodule Arg2 = struct\n type (_, 'a, _) t = 'a\nend\n\nmodule Apply2 (F : T2) (X : T1) (Y : T1) = struct\n type ('a, 'b) t = ('a X.t, 'b Y.t) F.t\nend\n\nmodule Dup (F : T2) = struct\n type 'a t = ('a, 'a) F.t\nend\n\nmodule Length = Hlist0.Length\n\nmodule H1 = struct\n module T = Hlist0.H1\n\n module Iter\n (F : T1) (C : sig\n val f : 'a F.t -> unit\n end) =\n struct\n let rec f : type a. a T(F).t -> unit = function\n | [] ->\n ()\n | x :: xs ->\n C.f x ; f xs\n end\n\n module Of_vector (X : T0) = struct\n let rec f :\n type xs length.\n (xs, length) Length.t -> (X.t, length) Vector.t -> xs T(E01(X)).t =\n fun l1 v ->\n match (l1, v) with Z, [] -> [] | S n1, x :: xs -> x :: f n1 xs\n end\n\n module Map\n (F : T1)\n (G : T1) (C : sig\n val f : 'a F.t -> 'a G.t\n end) =\n struct\n let rec f : type a. a T(F).t -> a T(G).t = function\n | [] ->\n []\n | x :: xs ->\n let y = C.f x in\n y :: f xs\n end\n\n module Fold\n (F : T1)\n (X : T0) (C : sig\n val f : X.t -> 'a F.t -> X.t\n end) =\n struct\n let rec f : type a. init:X.t -> a T(F).t -> X.t =\n fun ~init xs ->\n match xs with [] -> init | x :: xs -> f ~init:(C.f init x) xs\n end\n\n module Map_reduce\n (F : T1)\n (X : T0) (C : sig\n val reduce : X.t -> X.t -> X.t\n\n val map : 'a F.t -> X.t\n end) =\n struct\n let rec f : type a. X.t -> a T(F).t -> X.t =\n fun acc xs ->\n match xs with [] -> acc | x :: xs -> f (C.reduce acc (C.map x)) xs\n\n let f (type a) (xs : a T(F).t) =\n match xs with\n | [] ->\n failwith \"Hlist.Map_reduce: empty list\"\n | x :: xs ->\n f (C.map x) xs\n end\n\n module To_vector (X : T0) = struct\n let rec f :\n type xs length.\n (xs, length) Length.t -> xs T(E01(X)).t -> (X.t, length) Vector.t =\n fun l1 v ->\n match (l1, v) with Z, [] -> [] | S n1, x :: xs -> x :: f n1 xs\n end\n\n module Tuple2 (F : T1) (G : T1) = struct\n type 'a t = 'a F.t * 'a G.t\n end\n\n module Zip (F : T1) (G : T1) = struct\n let rec f : type a. a T(F).t -> a T(G).t -> a T(Tuple2(F)(G)).t =\n fun xs ys ->\n match (xs, ys) with [], [] -> [] | x :: xs, y :: ys -> (x, y) :: f xs ys\n end\n\n module Typ (Impl : sig\n type field\n end)\n (F : T1)\n (Var : T1)\n (Val : T1) (C : sig\n val f : 'a F.t -> ('a Var.t, 'a Val.t, Impl.field) Snarky_backendless.Typ.t\n end) =\n struct\n let rec f :\n type xs.\n xs T(F).t\n -> (xs T(Var).t, xs T(Val).t, Impl.field) Snarky_backendless.Typ.t =\n let transport, transport_var, tuple2, unit =\n Snarky_backendless.Typ.(transport, transport_var, tuple2, unit)\n in\n fun ts ->\n match ts with\n | t :: ts ->\n let tail = f ts in\n transport\n (tuple2 (C.f t) tail)\n ~there:(fun (x :: xs : _ T(Val).t) -> (x, xs))\n ~back:(fun (x, xs) -> x :: xs)\n |> transport_var\n ~there:(fun (x :: xs : _ T(Var).t) -> (x, xs))\n ~back:(fun (x, xs) -> x :: xs)\n | [] ->\n let there _ = () in\n transport (unit ()) ~there ~back:(fun () : _ T(Val).t -> [])\n |> transport_var ~there ~back:(fun () : _ T(Var).t -> [])\n end\nend\n\nmodule H2 = struct\n module Arg1 = struct\n type ('a, _) t = 'a\n end\n\n module Arg2 = struct\n type (_, 'a) t = 'a\n end\n\n module Tuple2 (F : T2) (G : T2) = struct\n type ('a, 'b) t = ('a, 'b) F.t * ('a, 'b) G.t\n end\n\n module T (F : T2) = struct\n type (_, _) t =\n | [] : (unit, unit) t\n | ( :: ) : ('a1, 'a2) F.t * ('b1, 'b2) t -> ('a1 * 'b1, 'a2 * 'b2) t\n\n let rec length : type tail1 tail2. (tail1, tail2) t -> tail1 Length.n =\n function\n | [] ->\n T (Z, Z)\n | _ :: xs ->\n let (T (n, p)) = length xs in\n T (S n, S p)\n end\n\n module Zip (F : T2) (G : T2) = struct\n let rec f :\n type a b. (a, b) T(F).t -> (a, b) T(G).t -> (a, b) T(Tuple2(F)(G)).t =\n fun xs ys ->\n match (xs, ys) with [], [] -> [] | x :: xs, y :: ys -> (x, y) :: f xs ys\n end\n\n module Map\n (F : T2)\n (G : T2) (C : sig\n val f : ('a, 'b) F.t -> ('a, 'b) G.t\n end) =\n struct\n let rec f : type a b. (a, b) T(F).t -> (a, b) T(G).t = function\n | [] ->\n []\n | x :: xs ->\n let y = C.f x in\n y :: f xs\n end\n\n module Typ (Impl : sig\n type field\n\n module Typ : sig\n type ('var, 'value) t = ('var, 'value, field) Snarky_backendless.Typ.t\n end\n end) =\n struct\n let transport, transport_var, tuple2, unit =\n Snarky_backendless.Typ.(transport, transport_var, tuple2, unit)\n\n let rec f :\n type vars values.\n (vars, values) T(Impl.Typ).t\n -> ( vars H1.T(Id).t\n , values H1.T(Id).t\n , Impl.field )\n Snarky_backendless.Typ.t =\n fun ts ->\n match ts with\n | [] ->\n let there _ = () in\n transport (unit ()) ~there ~back:(fun () : _ H1.T(Id).t -> [])\n |> transport_var ~there ~back:(fun () : _ H1.T(Id).t -> [])\n | t :: ts ->\n transport\n (tuple2 t (f ts))\n ~there:(fun (x :: xs : _ H1.T(Id).t) -> (x, xs))\n ~back:(fun (x, xs) -> x :: xs)\n |> transport_var\n ~there:(fun (x :: xs : _ H1.T(Id).t) -> (x, xs))\n ~back:(fun (x, xs) -> x :: xs)\n end\nend\n\nmodule H3_2 = struct\n module T (F : sig\n type (_, _, _, _, _) t\n end) =\n struct\n type (_, _, _, 's1, 's2) t =\n | [] : (unit, unit, unit, _, _) t\n | ( :: ) :\n ('a1, 'a2, 'a3, 's1, 's2) F.t * ('b1, 'b2, 'b3, 's1, 's2) t\n -> ('a1 * 'b1, 'a2 * 'b2, 'a3 * 'b3, 's1, 's2) t\n\n let rec length : type t1 t2 t3 e1 e2. (t1, t2, t3, e1, e2) t -> t1 Length.n\n = function\n | [] ->\n T (Z, Z)\n | _ :: xs ->\n let (T (n, p)) = length xs in\n T (S n, S p)\n end\nend\n\nmodule H3_3 = struct\n module T (F : sig\n type (_, _, _, _, _, _) t\n end) =\n struct\n type (_, _, _, 's1, 's2, 's3) t =\n | [] : (unit, unit, unit, _, _, _) t\n | ( :: ) :\n ('a1, 'a2, 'a3, 's1, 's2, 's3) F.t * ('b1, 'b2, 'b3, 's1, 's2, 's3) t\n -> ('a1 * 'b1, 'a2 * 'b2, 'a3 * 'b3, 's1, 's2, 's3) t\n\n let rec length :\n type t1 t2 t3 e1 e2 e3. (t1, t2, t3, e1, e2, e3) t -> t1 Length.n =\n function\n | [] ->\n T (Z, Z)\n | _ :: xs ->\n let (T (n, p)) = length xs in\n T (S n, S p)\n end\nend\n\nmodule H3_4 = struct\n module T (F : sig\n type (_, _, _, _, _, _, _) t\n end) =\n struct\n type (_, _, _, 's1, 's2, 's3, 's4) t =\n | [] : (unit, unit, unit, _, _, _, _) t\n | ( :: ) :\n ('a1, 'a2, 'a3, 's1, 's2, 's3, 's4) F.t\n * ('b1, 'b2, 'b3, 's1, 's2, 's3, 's4) t\n -> ('a1 * 'b1, 'a2 * 'b2, 'a3 * 'b3, 's1, 's2, 's3, 's4) t\n\n let rec length :\n type t1 t2 t3 e1 e2 e3 e4. (t1, t2, t3, e1, e2, e3, e4) t -> t1 Length.n\n = function\n | [] ->\n T (Z, Z)\n | _ :: xs ->\n let (T (n, p)) = length xs in\n T (S n, S p)\n end\nend\n\nmodule H2_1 = struct\n module T (F : sig\n type (_, _, _) t\n end) =\n struct\n type (_, _, 's) t =\n | [] : (unit, unit, _) t\n | ( :: ) :\n ('a1, 'a2, 's) F.t * ('b1, 'b2, 's) t\n -> ('a1 * 'b1, 'a2 * 'b2, 's) t\n\n let rec length : type tail1 tail2 e. (tail1, tail2, e) t -> tail1 Length.n =\n function\n | [] ->\n T (Z, Z)\n | _ :: xs ->\n let (T (n, p)) = length xs in\n T (S n, S p)\n end\n\n module Iter\n (F : T3) (C : sig\n val f : ('a, 'b, 'c) F.t -> unit\n end) =\n struct\n let rec f : type a b c. (a, b, c) T(F).t -> unit = function\n | [] ->\n ()\n | x :: xs ->\n C.f x ; f xs\n end\n\n module Map_\n (F : T3)\n (G : T3) (Env : sig\n type t\n end) (C : sig\n val f : ('a, 'b, Env.t) F.t -> ('a, 'b, Env.t) G.t\n end) =\n struct\n let rec f : type a b. (a, b, Env.t) T(F).t -> (a, b, Env.t) T(G).t =\n function\n | [] ->\n []\n | x :: xs ->\n let y = C.f x in\n y :: f xs\n end\n\n module Map\n (F : T3)\n (G : T3) (C : sig\n val f : ('a, 'b, 'c) F.t -> ('a, 'b, 'c) G.t\n end) =\n struct\n let f : type a b c. (a, b, c) T(F).t -> (a, b, c) T(G).t =\n fun xs ->\n let module M =\n Map_ (F) (G)\n (struct\n type t = c\n end)\n (struct\n let f = C.f\n end)\n in\n M.f xs\n end\n\n module Zip (F : T3) (G : T3) = struct\n let rec f :\n type a b c.\n (a, b, c) T(F).t -> (a, b, c) T(G).t -> (a, b, c) T(Tuple2(F)(G)).t =\n fun xs ys ->\n match (xs, ys) with [], [] -> [] | x :: xs, y :: ys -> (x, y) :: f xs ys\n end\n\n module Zip3 (F1 : T3) (F2 : T3) (F3 : T3) = struct\n let rec f :\n type a b c.\n (a, b, c) T(F1).t\n -> (a, b, c) T(F2).t\n -> (a, b, c) T(F3).t\n -> (a, b, c) T(Tuple3(F1)(F2)(F3)).t =\n fun xs ys zs ->\n match (xs, ys, zs) with\n | [], [], [] ->\n []\n | x :: xs, y :: ys, z :: zs ->\n (x, y, z) :: f xs ys zs\n end\n\n module Unzip3 (F1 : T3) (F2 : T3) (F3 : T3) = struct\n let rec f :\n type a b c.\n (a, b, c) T(Tuple3(F1)(F2)(F3)).t\n -> (a, b, c) T(F1).t * (a, b, c) T(F2).t * (a, b, c) T(F3).t =\n fun ts ->\n match ts with\n | [] ->\n ([], [], [])\n | (x, y, z) :: ts ->\n let xs, ys, zs = f ts in\n (x :: xs, y :: ys, z :: zs)\n end\n\n module Zip4 (F1 : T3) (F2 : T3) (F3 : T3) (F4 : T3) = struct\n let rec f :\n type a b c.\n (a, b, c) T(F1).t\n -> (a, b, c) T(F2).t\n -> (a, b, c) T(F3).t\n -> (a, b, c) T(F4).t\n -> (a, b, c) T(Tuple4(F1)(F2)(F3)(F4)).t =\n fun xs ys zs ws ->\n match (xs, ys, zs, ws) with\n | [], [], [], [] ->\n []\n | x :: xs, y :: ys, z :: zs, w :: ws ->\n (x, y, z, w) :: f xs ys zs ws\n end\n\n module Zip5 (F1 : T3) (F2 : T3) (F3 : T3) (F4 : T3) (F5 : T3) = struct\n let rec f :\n type a b c.\n (a, b, c) T(F1).t\n -> (a, b, c) T(F2).t\n -> (a, b, c) T(F3).t\n -> (a, b, c) T(F4).t\n -> (a, b, c) T(F5).t\n -> (a, b, c) T(Tuple5(F1)(F2)(F3)(F4)(F5)).t =\n fun l1 l2 l3 l4 l5 ->\n match (l1, l2, l3, l4, l5) with\n | [], [], [], [], [] ->\n []\n | x1 :: l1, x2 :: l2, x3 :: l3, x4 :: l4, x5 :: l5 ->\n (x1, x2, x3, x4, x5) :: f l1 l2 l3 l4 l5\n end\n\n module Of_vector (X : T0) = struct\n let rec f :\n type e xs ys length.\n (xs, length) Length.t\n -> (ys, length) Length.t\n -> (X.t, length) Vector.t\n -> (xs, ys, e) T(E03(X)).t =\n fun l1 l2 v ->\n match (l1, l2, v) with\n | Z, Z, [] ->\n []\n | S n1, S n2, x :: xs ->\n x :: f n1 n2 xs\n end\n\n module To_vector (X : T0) = struct\n let rec f :\n type e xs ys length.\n (xs, length) Length.t\n -> (xs, ys, e) T(E03(X)).t\n -> (X.t, length) Vector.t =\n fun l1 v ->\n match (l1, v) with Z, [] -> [] | S n1, x :: xs -> x :: f n1 xs\n end\nend\n\nmodule H3 = struct\n module T (F : sig\n type (_, _, _) t\n end) =\n struct\n type (_, _, _) t =\n | [] : (unit, unit, unit) t\n | ( :: ) :\n ('a1, 'a2, 'a3) F.t * ('b1, 'b2, 'b3) t\n -> ('a1 * 'b1, 'a2 * 'b2, 'a3 * 'b3) t\n\n let rec length :\n type tail1 tail2 tail3. (tail1, tail2, tail3) t -> tail1 Length.n =\n function\n | [] ->\n T (Z, Z)\n | _ :: xs ->\n let (T (n, p)) = length xs in\n T (S n, S p)\n end\n\n module To_vector (X : T0) = struct\n let rec f :\n type a b c length.\n (a, length) Length.t -> (a, b, c) T(E03(X)).t -> (X.t, length) Vector.t\n =\n fun l1 v ->\n match (l1, v) with Z, [] -> [] | S n1, x :: xs -> x :: f n1 xs\n end\n\n module Zip (F : T3) (G : T3) = struct\n let rec f :\n type a b c.\n (a, b, c) T(F).t -> (a, b, c) T(G).t -> (a, b, c) T(Tuple2(F)(G)).t =\n fun xs ys ->\n match (xs, ys) with [], [] -> [] | x :: xs, y :: ys -> (x, y) :: f xs ys\n end\n\n module Arg1 = struct\n type ('a, _, _) t = 'a\n end\n\n module Map1_to_H1\n (F : T3)\n (G : T1) (C : sig\n val f : ('a, 'b, 'c) F.t -> 'a G.t\n end) =\n struct\n let rec f : type a b c. (a, b, c) T(F).t -> a H1.T(G).t = function\n | [] ->\n []\n | x :: xs ->\n let y = C.f x in\n y :: f xs\n end\n\n module Map2_to_H1\n (F : T3)\n (G : T1) (C : sig\n val f : ('a, 'b, 'c) F.t -> 'b G.t\n end) =\n struct\n let rec f : type a b c. (a, b, c) T(F).t -> b H1.T(G).t = function\n | [] ->\n []\n | x :: xs ->\n let y = C.f x in\n y :: f xs\n end\n\n module Map\n (F : T3)\n (G : T3) (C : sig\n val f : ('a, 'b, 'c) F.t -> ('a, 'b, 'c) G.t\n end) =\n struct\n let rec f : type a b c. (a, b, c) T(F).t -> (a, b, c) T(G).t = function\n | [] ->\n []\n | x :: xs ->\n let y = C.f x in\n y :: f xs\n end\nend\n\nmodule H4 = struct\n module T (F : sig\n type (_, _, _, _) t\n end) =\n struct\n type (_, _, _, _) t =\n | [] : (unit, unit, unit, unit) t\n | ( :: ) :\n ('a1, 'a2, 'a3, 'a4) F.t * ('b1, 'b2, 'b3, 'b4) t\n -> ('a1 * 'b1, 'a2 * 'b2, 'a3 * 'b3, 'a4 * 'b4) t\n\n let rec length :\n type tail1 tail2 tail3 tail4.\n (tail1, tail2, tail3, tail4) t -> tail1 Length.n = function\n | [] ->\n T (Z, Z)\n | _ :: xs ->\n let (T (n, p)) = length xs in\n T (S n, S p)\n end\n\n module Fold\n (F : T4)\n (X : T0) (C : sig\n val f : X.t -> _ F.t -> X.t\n end) =\n struct\n let rec f : type a b c d. init:X.t -> (a, b, c, d) T(F).t -> X.t =\n fun ~init xs ->\n match xs with [] -> init | x :: xs -> f ~init:(C.f init x) xs\n end\n\n module Iter\n (F : T4) (C : sig\n val f : _ F.t -> unit\n end) =\n struct\n let rec f : type a b c d. (a, b, c, d) T(F).t -> unit =\n fun xs -> match xs with [] -> () | x :: xs -> C.f x ; f xs\n end\n\n module Map\n (F : T4)\n (G : T4) (C : sig\n val f : ('a, 'b, 'c, 'd) F.t -> ('a, 'b, 'c, 'd) G.t\n end) =\n struct\n let rec f : type a b c d. (a, b, c, d) T(F).t -> (a, b, c, d) T(G).t =\n function\n | [] ->\n []\n | x :: xs ->\n let y = C.f x in\n y :: f xs\n end\n\n module To_vector (X : T0) = struct\n let rec f :\n type a b c d length.\n (a, length) Length.t\n -> (a, b, c, d) T(E04(X)).t\n -> (X.t, length) Vector.t =\n fun l1 v ->\n match (l1, v) with Z, [] -> [] | S n1, x :: xs -> x :: f n1 xs\n end\n\n module Tuple2 (F : T4) (G : T4) = struct\n type ('a, 'b, 'c, 'd) t = ('a, 'b, 'c, 'd) F.t * ('a, 'b, 'c, 'd) G.t\n end\n\n module Zip (F : T4) (G : T4) = struct\n let rec f :\n type a b c d.\n (a, b, c, d) T(F).t\n -> (a, b, c, d) T(G).t\n -> (a, b, c, d) T(Tuple2(F)(G)).t =\n fun xs ys ->\n match (xs, ys) with [], [] -> [] | x :: xs, y :: ys -> (x, y) :: f xs ys\n end\n\n module Length_1_to_2 (F : T4) = struct\n let rec f :\n type n xs ys a b.\n (xs, ys, a, b) T(F).t -> (xs, n) Length.t -> (ys, n) Length.t =\n fun xs n -> match (xs, n) with [], Z -> Z | _ :: xs, S n -> S (f xs n)\n end\n\n module Typ (Impl : sig\n type field\n end)\n (F : T4)\n (Var : T3)\n (Val : T3) (C : sig\n val f :\n ('var, 'value, 'n1, 'n2) F.t\n -> ( ('var, 'n1, 'n2) Var.t\n , ('value, 'n1, 'n2) Val.t\n , Impl.field )\n Snarky_backendless.Typ.t\n end) =\n struct\n let transport, transport_var, tuple2, unit =\n Snarky_backendless.Typ.(transport, transport_var, tuple2, unit)\n\n let rec f :\n type vars values ns1 ns2.\n (vars, values, ns1, ns2) T(F).t\n -> ( (vars, ns1, ns2) H3.T(Var).t\n , (values, ns1, ns2) H3.T(Val).t\n , Impl.field )\n Snarky_backendless.Typ.t =\n fun ts ->\n match ts with\n | [] ->\n let there _ = () in\n transport (unit ()) ~there ~back:(fun () : _ H3.T(Val).t -> [])\n |> transport_var ~there ~back:(fun () : _ H3.T(Var).t -> [])\n | t :: ts ->\n transport\n (tuple2 (C.f t) (f ts))\n ~there:(fun (x :: xs : _ H3.T(Val).t) -> (x, xs))\n ~back:(fun (x, xs) -> x :: xs)\n |> transport_var\n ~there:(fun (x :: xs : _ H3.T(Var).t) -> (x, xs))\n ~back:(fun (x, xs) -> x :: xs)\n end\nend\n\nmodule H6 = struct\n module T (F : sig\n type (_, _, _, _, _, _) t\n end) =\n struct\n type (_, _, _, _, _, _) t =\n | [] : (unit, unit, unit, unit, unit, unit) t\n | ( :: ) :\n ('a1, 'a2, 'a3, 'a4, 'a5, 'a6) F.t * ('b1, 'b2, 'b3, 'b4, 'b5, 'b6) t\n -> ( 'a1 * 'b1\n , 'a2 * 'b2\n , 'a3 * 'b3\n , 'a4 * 'b4\n , 'a5 * 'b5\n , 'a6 * 'b6 )\n t\n\n let rec length :\n type tail1 tail2 tail3 tail4 tail5 tail6.\n (tail1, tail2, tail3, tail4, tail5, tail6) t -> tail1 Length.n =\n function\n | [] ->\n T (Z, Z)\n | _ :: xs ->\n let (T (n, p)) = length xs in\n T (S n, S p)\n end\n\n module Fold\n (F : T6)\n (X : T0) (C : sig\n val f : X.t -> _ F.t -> X.t\n end) =\n struct\n let rec f :\n type a1 a2 a3 a4 a5 a6.\n init:X.t -> (a1, a2, a3, a4, a5, a6) T(F).t -> X.t =\n fun ~init xs ->\n match xs with [] -> init | x :: xs -> f ~init:(C.f init x) xs\n end\n\n module Iter\n (F : T6) (C : sig\n val f : _ F.t -> unit\n end) =\n struct\n let rec f : type a1 a2 a3 a4 a5 a6. (a1, a2, a3, a4, a5, a6) T(F).t -> unit\n =\n fun xs -> match xs with [] -> () | x :: xs -> C.f x ; f xs\n end\n\n module Map\n (F : T6)\n (G : T6) (C : sig\n val f :\n ('a1, 'a2, 'a3, 'a4, 'a5, 'a6) F.t\n -> ('a1, 'a2, 'a3, 'a4, 'a5, 'a6) G.t\n end) =\n struct\n let rec f :\n type a1 a2 a3 a4 a5 a6.\n (a1, a2, a3, a4, a5, a6) T(F).t -> (a1, a2, a3, a4, a5, a6) T(G).t =\n function\n | [] ->\n []\n | x :: xs ->\n let y = C.f x in\n y :: f xs\n end\n\n module To_vector (X : T0) = struct\n let rec f :\n type a1 a2 a3 a4 a5 a6 length.\n (a1, length) Length.t\n -> (a1, a2, a3, a4, a5, a6) T(E06(X)).t\n -> (X.t, length) Vector.t =\n fun l1 v ->\n match (l1, v) with Z, [] -> [] | S n1, x :: xs -> x :: f n1 xs\n end\n\n module Tuple2 (F : T6) (G : T6) = struct\n type ('a1, 'a2, 'a3, 'a4, 'a5, 'a6) t =\n ('a1, 'a2, 'a3, 'a4, 'a5, 'a6) F.t * ('a1, 'a2, 'a3, 'a4, 'a5, 'a6) G.t\n end\n\n module Zip (F : T6) (G : T6) = struct\n let rec f :\n type a1 a2 a3 a4 a5 a6.\n (a1, a2, a3, a4, a5, a6) T(F).t\n -> (a1, a2, a3, a4, a5, a6) T(G).t\n -> (a1, a2, a3, a4, a5, a6) T(Tuple2(F)(G)).t =\n fun xs ys ->\n match (xs, ys) with [], [] -> [] | x :: xs, y :: ys -> (x, y) :: f xs ys\n end\n\n module Length_1_to_2 (F : T6) = struct\n let rec f :\n type n a1 a2 a3 a4 a5 a6.\n (a1, a2, a3, a4, a5, a6) T(F).t -> (a1, n) Length.t -> (a2, n) Length.t\n =\n fun xs n -> match (xs, n) with [], Z -> Z | _ :: xs, S n -> S (f xs n)\n end\n\n module Typ (Impl : sig\n type field\n end)\n (F : T6)\n (Var : T4)\n (Val : T4) (C : sig\n val f :\n ('var, 'value, 'ret_var, 'ret_value, 'n1, 'n2) F.t\n -> ( ('var, 'ret_var, 'n1, 'n2) Var.t\n , ('value, 'ret_value, 'n1, 'n2) Val.t\n , Impl.field )\n Snarky_backendless.Typ.t\n end) =\n struct\n let transport, transport_var, tuple2, unit =\n Snarky_backendless.Typ.(transport, transport_var, tuple2, unit)\n\n let rec f :\n type vars values ret_vars ret_values ns1 ns2.\n (vars, values, ret_vars, ret_values, ns1, ns2) T(F).t\n -> ( (vars, ret_vars, ns1, ns2) H4.T(Var).t\n , (values, ret_values, ns1, ns2) H4.T(Val).t\n , Impl.field )\n Snarky_backendless.Typ.t =\n fun ts ->\n match ts with\n | [] ->\n let there _ = () in\n transport (unit ()) ~there ~back:(fun () : _ H4.T(Val).t -> [])\n |> transport_var ~there ~back:(fun () : _ H4.T(Var).t -> [])\n | t :: ts ->\n transport\n (tuple2 (C.f t) (f ts))\n ~there:(fun (x :: xs : _ H4.T(Val).t) -> (x, xs))\n ~back:(fun (x, xs) -> x :: xs)\n |> transport_var\n ~there:(fun (x :: xs : _ H4.T(Var).t) -> (x, xs))\n ~back:(fun (x, xs) -> x :: xs)\n end\nend\n\nmodule H4_2 = struct\n module T (F : sig\n type (_, _, _, _, _, _) t\n end) =\n struct\n type (_, _, _, _, 's1, 's2) t =\n | [] : (unit, unit, unit, unit, _, _) t\n | ( :: ) :\n ('a1, 'a2, 'a3, 'a4, 's1, 's2) F.t * ('b1, 'b2, 'b3, 'b4, 's1, 's2) t\n -> ('a1 * 'b1, 'a2 * 'b2, 'a3 * 'b3, 'a4 * 'b4, 's1, 's2) t\n\n let rec length :\n type t1 t2 t3 t4 e1 e2. (t1, t2, t3, t4, e1, e2) t -> t1 Length.n =\n function\n | [] ->\n T (Z, Z)\n | _ :: xs ->\n let (T (n, p)) = length xs in\n T (S n, S p)\n end\nend\n\nmodule H4_4 = struct\n module T (F : sig\n type (_, _, _, _, _, _, _, _) t\n end) =\n struct\n type (_, _, _, _, 's1, 's2, 's3, 's4) t =\n | [] : (unit, unit, unit, unit, _, _, _, _) t\n | ( :: ) :\n ('a1, 'a2, 'a3, 'a4, 's1, 's2, 's3, 's4) F.t\n * ('b1, 'b2, 'b3, 'b4, 's1, 's2, 's3, 's4) t\n -> ('a1 * 'b1, 'a2 * 'b2, 'a3 * 'b3, 'a4 * 'b4, 's1, 's2, 's3, 's4) t\n\n let rec length :\n type t1 t2 t3 t4 e1 e2 e3 e4.\n (t1, t2, t3, t4, e1, e2, e3, e4) t -> t1 Length.n = function\n | [] ->\n T (Z, Z)\n | _ :: xs ->\n let (T (n, p)) = length xs in\n T (S n, S p)\n end\nend\n\nmodule H4_6 = struct\n module T (F : sig\n type (_, _, _, _, _, _, _, _, _, _) t\n end) =\n struct\n type (_, _, _, _, 's1, 's2, 's3, 's4, 's5, 's6) t =\n | [] : (unit, unit, unit, unit, _, _, _, _, _, _) t\n | ( :: ) :\n ('a1, 'a2, 'a3, 'a4, 's1, 's2, 's3, 's4, 's5, 's6) F.t\n * ('b1, 'b2, 'b3, 'b4, 's1, 's2, 's3, 's4, 's5, 's6) t\n -> ( 'a1 * 'b1\n , 'a2 * 'b2\n , 'a3 * 'b3\n , 'a4 * 'b4\n , 's1\n , 's2\n , 's3\n , 's4\n , 's5\n , 's6 )\n t\n\n let rec length :\n type t1 t2 t3 t4 e1 e2 e3 e4 e5 e6.\n (t1, t2, t3, t4, e1, e2, e3, e4, e5, e6) t -> t1 Length.n = function\n | [] ->\n T (Z, Z)\n | _ :: xs ->\n let (T (n, p)) = length xs in\n T (S n, S p)\n end\nend\n\nmodule H6_2 = struct\n module T (F : sig\n type (_, _, _, _, _, _, _, _) t\n end) =\n struct\n type (_, _, _, _, _, _, 's1, 's2) t =\n | [] : (unit, unit, unit, unit, unit, unit, _, _) t\n | ( :: ) :\n ('a1, 'a2, 'a3, 'a4, 'a5, 'a6, 's1, 's2) F.t\n * ('b1, 'b2, 'b3, 'b4, 'b5, 'b6, 's1, 's2) t\n -> ( 'a1 * 'b1\n , 'a2 * 'b2\n , 'a3 * 'b3\n , 'a4 * 'b4\n , 'a5 * 'b5\n , 'a6 * 'b6\n , 's1\n , 's2 )\n t\n\n let rec length :\n type t1 t2 t3 t4 t5 t6 e1 e2.\n (t1, t2, t3, t4, t5, t6, e1, e2) t -> t1 Length.n = function\n | [] ->\n T (Z, Z)\n | _ :: xs ->\n let (T (n, p)) = length xs in\n T (S n, S p)\n end\nend\n\nmodule H6_4 = struct\n module T (F : sig\n type (_, _, _, _, _, _, _, _, _, _) t\n end) =\n struct\n type (_, _, _, _, _, _, 's1, 's2, 's3, 's4) t =\n | [] : (unit, unit, unit, unit, unit, unit, _, _, _, _) t\n | ( :: ) :\n ('a1, 'a2, 'a3, 'a4, 'a5, 'a6, 's1, 's2, 's3, 's4) F.t\n * ('b1, 'b2, 'b3, 'b4, 'b5, 'b6, 's1, 's2, 's3, 's4) t\n -> ( 'a1 * 'b1\n , 'a2 * 'b2\n , 'a3 * 'b3\n , 'a4 * 'b4\n , 'a5 * 'b5\n , 'a6 * 'b6\n , 's1\n , 's2\n , 's3\n , 's4 )\n t\n\n let rec length :\n type t1 t2 t3 t4 t5 t6 e1 e2 e3 e4.\n (t1, t2, t3, t4, t5, t6, e1, e2, e3, e4) t -> t1 Length.n = function\n | [] ->\n T (Z, Z)\n | _ :: xs ->\n let (T (n, p)) = length xs in\n T (S n, S p)\n end\nend\n\nmodule H3_1 (F : sig\n type (_, _, _, _) t\nend) =\nstruct\n type (_, _, _, 's) t =\n | [] : (unit, unit, unit, _) t\n | ( :: ) :\n ('a1, 'a2, 'a3, 's) F.t * ('b1, 'b2, 'b3, 's) t\n -> ('a1 * 'b1, 'a2 * 'b2, 'a3 * 'b3, 's) t\n\n let rec length :\n type tail1 tail2 tail3 e. (tail1, tail2, tail3, e) t -> tail1 Length.n =\n function\n | [] ->\n T (Z, Z)\n | _ :: xs ->\n let (T (n, p)) = length xs in\n T (S n, S p)\nend\n\nmodule Map_1_specific\n (F : T2)\n (G : T2) (C : sig\n type b1\n\n type b2\n\n val f : ('a, b1) F.t -> ('a, b2) G.t\n end) =\nstruct\n let rec f : type a. (a, C.b1) H1_1(F).t -> (a, C.b2) H1_1(G).t = function\n | [] ->\n []\n | x :: xs ->\n let y = C.f x in\n y :: f xs\nend\n\nopen Nat\n\nmodule type Max_s = sig\n type ns\n\n type n\n\n val n : n t\n\n val p : (ns, n) H1_1(Lte).t\nend\n\ntype 'ns max = (module Max_s with type ns = 'ns)\n\nlet rec max : type n ns. (n * ns) H1.T(Nat).t -> (n * ns) max =\n fun xs ->\n match xs with\n | [ x ] ->\n let module M = struct\n type nonrec ns = n * ns\n\n type nonrec n = n\n\n let n = x\n\n let p : (_, _) H1_1(Lte).t = [ Lte.refl x ]\n end in\n (module M : Max_s with type ns = n * ns)\n | x :: (_ :: _ as ys) -> (\n let (module Max) = max ys in\n match compare x Max.n with\n | `Lte p_x ->\n let module M = struct\n type nonrec ns = n * ns\n\n type n = Max.n\n\n let n = Max.n\n\n let p : (ns, Max.n) H1_1(Lte).t = p_x :: Max.p\n end in\n (module M)\n | `Gt gt ->\n let max_lt_x = gt_implies_gte x Max.n gt in\n let module M =\n Map_1_specific (Lte) (Lte)\n (struct\n type b1 = Max.n\n\n type b2 = n\n\n let f : type a. (a, Max.n) Lte.t -> (a, n) Lte.t =\n fun a_lt_max -> Lte.trans a_lt_max max_lt_x\n end)\n in\n let module M : Max_s with type ns = n * ns = struct\n type nonrec ns = n * ns\n\n type nonrec n = n\n\n let n = x\n\n let p : (ns, n) H1_1(Lte).t = Lte.refl x :: M.f Max.p\n end in\n (module M) )\n\nlet max_exn : type ns. ns H1.T(Nat).t -> ns max = function\n | [] ->\n failwith \"max_exn: empty list\"\n | _ :: _ as xs ->\n max xs\n\nmodule Maxes = struct\n module type S = sig\n type ns\n\n type length\n\n val length : (ns, length) Length.t\n\n val maxes : ns H1.T(Nat).t\n end\n\n type 'length t = T : 'ns H1.T(Nat).t * ('ns, 'length) Length.t -> 'length t\n\n let rec f : type branches n. ((int, branches) Vector.t, n) Vector.t -> n t =\n function\n | [] ->\n T ([], Length.Z)\n | v :: vs ->\n let (T (maxes, len)) = f vs in\n let (T n) = Nat.of_int (Vector.reduce_exn v ~f:Int.max) in\n T (n :: maxes, S len)\n\n let m (type length) (vs : (_, length) Vector.t) :\n (module S with type length = length) =\n let g :\n type length ns.\n ns H1.T(Nat).t\n -> (ns, length) Length.t\n -> (module S with type length = length) =\n fun maxes length ->\n ( module struct\n type nonrec length = length\n\n type nonrec ns = ns\n\n let length = length\n\n let maxes = maxes\n end )\n in\n let (T (ms, len)) = f vs in\n g ms len\nend\n\nmodule Lengths = struct\n let rec extract :\n type prev_varss ns env.\n (prev_varss, ns, env) H2_1.T(E23(Length)).t -> ns H1.T(Nat).t = function\n | [] ->\n []\n | n :: ns ->\n (* TODO: This is quadratic because of Length.to_nat *)\n Length.to_nat n :: extract ns\n\n type ('prev_varss, 'prev_valss, 'env) t =\n | T :\n ('prev_varss, 'ns, 'env) H2_1.T(E23(Length)).t\n -> ('prev_varss, 'prev_valss, 'env) t\nend\n","open Core_kernel\n\n[@@@warning \"-4\"]\n\n[%%versioned\nmodule Stable = struct\n module V1 = struct\n type 'a t = Infinity | Finite of 'a\n [@@deriving sexp, equal, compare, hash, yojson]\n end\nend]\n\n[@@@warning \"+4\"]\n\nlet finite_exn = function\n | Finite x ->\n x\n | Infinity ->\n failwith \"curve point must not be the point at infinity\"\n","open Core_kernel\nopen Pickles_types\nopen Pickles_base\nmodule Scalars = Scalars\nmodule Domain = Domain\nmodule Opt = Plonk_types.Opt\n\ntype 'field vanishing_polynomial_domain =\n < vanishing_polynomial : 'field -> 'field >\n\ntype 'field plonk_domain =\n < vanishing_polynomial : 'field -> 'field\n ; shifts : 'field Plonk_types.Shifts.t\n ; generator : 'field >\n\ntype 'field domain = < size : 'field ; vanishing_polynomial : 'field -> 'field >\n\nmodule type Bool_intf = sig\n type t\n\n val true_ : t\n\n val false_ : t\n\n val ( &&& ) : t -> t -> t\n\n val ( ||| ) : t -> t -> t\n\n val any : t list -> t\nend\n\nmodule type Field_intf = sig\n type t\n\n val size_in_bits : int\n\n val zero : t\n\n val one : t\n\n val of_int : int -> t\n\n val ( * ) : t -> t -> t\n\n val ( / ) : t -> t -> t\n\n val ( + ) : t -> t -> t\n\n val ( - ) : t -> t -> t\n\n val inv : t -> t\n\n val negate : t -> t\nend\n\nmodule type Field_with_if_intf = sig\n include Field_intf\n\n type bool\n\n val if_ : bool -> then_:(unit -> t) -> else_:(unit -> t) -> t\nend\n\ntype 'f field = (module Field_intf with type t = 'f)\n\nlet pow2pow (type t) ((module F) : t field) (x : t) n : t =\n let rec go acc i = if i = 0 then acc else go F.(acc * acc) (i - 1) in\n go x n\n\n(* x^{2 ^ k} - 1 *)\nlet vanishing_polynomial (type t) ((module F) : t field) domain x =\n let k = Domain.log2_size domain in\n F.(pow2pow (module F) x k - one)\n\nlet domain (type t) ((module F) : t field) ~shifts ~domain_generator\n (domain : Domain.t) : t plonk_domain =\n let log2_size = Domain.log2_size domain in\n let shifts = shifts ~log2_size in\n let generator = domain_generator ~log2_size in\n object\n method shifts = shifts\n\n method vanishing_polynomial x = vanishing_polynomial (module F) domain x\n\n method generator = generator\n end\n\nlet actual_evaluation (type f) (module Field : Field_intf with type t = f)\n (e : Field.t array) (pt : Field.t) ~rounds : Field.t =\n let pt_n =\n let rec go acc i = if i = 0 then acc else go Field.(acc * acc) (i - 1) in\n go pt rounds\n in\n match List.rev (Array.to_list e) with\n | e :: es ->\n List.fold ~init:e es ~f:(fun acc fx -> Field.(fx + (pt_n * acc)))\n | [] ->\n Field.of_int 0\n\nlet evals_of_split_evals field ~zeta ~zetaw (es : _ Plonk_types.Evals.t) ~rounds\n =\n let e = Fn.flip (actual_evaluation field ~rounds) in\n Plonk_types.Evals.map es ~f:(fun (x1, x2) -> (e zeta x1, e zetaw x2))\n\nopen Composition_types.Wrap.Proof_state.Deferred_values.Plonk\n\ntype 'bool all_feature_flags =\n { lookup_tables : 'bool Lazy.t\n ; table_width_at_least_1 : 'bool Lazy.t\n ; table_width_at_least_2 : 'bool Lazy.t\n ; table_width_3 : 'bool Lazy.t\n ; lookups_per_row_3 : 'bool Lazy.t\n ; lookups_per_row_4 : 'bool Lazy.t\n ; lookup_pattern_xor : 'bool Lazy.t\n ; lookup_pattern_range_check : 'bool Lazy.t\n ; features : 'bool Plonk_types.Features.t\n }\n\nlet expand_feature_flags (type boolean)\n (module B : Bool_intf with type t = boolean)\n ({ range_check0\n ; range_check1\n ; foreign_field_add = _\n ; foreign_field_mul\n ; xor\n ; rot\n ; lookup\n ; runtime_tables = _\n } as features :\n boolean Plonk_types.Features.t ) : boolean all_feature_flags =\n let lookup_pattern_range_check =\n (* RangeCheck, Rot gates use RangeCheck lookup pattern *)\n lazy B.(range_check0 ||| range_check1 ||| rot)\n in\n let lookup_pattern_xor =\n (* Xor lookup pattern *)\n lazy xor\n in\n (* Make sure these stay up-to-date with the layouts!! *)\n let table_width_3 =\n (* Xor have max_joint_size = 3 *)\n lookup_pattern_xor\n in\n let table_width_at_least_2 =\n (* Lookup has max_joint_size = 2 *)\n lazy (B.( ||| ) (Lazy.force table_width_3) lookup)\n in\n let table_width_at_least_1 =\n (* RangeCheck, ForeignFieldMul have max_joint_size = 1 *)\n lazy\n (B.any\n [ Lazy.force table_width_at_least_2\n ; Lazy.force lookup_pattern_range_check\n ; foreign_field_mul\n ] )\n in\n let lookups_per_row_4 =\n (* Xor, RangeCheckGate, ForeignFieldMul, have max_lookups_per_row = 4 *)\n lazy\n (B.any\n [ Lazy.force lookup_pattern_xor\n ; Lazy.force lookup_pattern_range_check\n ; foreign_field_mul\n ] )\n in\n let lookups_per_row_3 =\n (* Lookup has max_lookups_per_row = 3 *)\n lazy (B.( ||| ) (Lazy.force lookups_per_row_4) lookup)\n in\n { lookup_tables = lookups_per_row_3\n ; table_width_at_least_1\n ; table_width_at_least_2\n ; table_width_3\n ; lookups_per_row_3\n ; lookups_per_row_4\n ; lookup_pattern_xor\n ; lookup_pattern_range_check\n ; features\n }\n\nlet lookup_tables_used feature_flags =\n let module Bool = struct\n type t = Plonk_types.Opt.Flag.t\n\n let (true_ : t) = Yes\n\n let (false_ : t) = No\n\n let ( &&& ) (x : t) (y : t) : t =\n match (x, y) with\n | Yes, Yes ->\n Yes\n | Maybe, _ | _, Maybe ->\n Maybe\n | No, _ | _, No ->\n No\n\n let ( ||| ) (x : t) (y : t) : t =\n match (x, y) with\n | Yes, _ | _, Yes ->\n Yes\n | Maybe, _ | _, Maybe ->\n Maybe\n | No, No ->\n No\n\n let any = List.fold_left ~f:( ||| ) ~init:false_\n end in\n let all_feature_flags = expand_feature_flags (module Bool) feature_flags in\n Lazy.force all_feature_flags.lookup_tables\n\nlet get_feature_flag (feature_flags : _ all_feature_flags)\n (feature : Kimchi_types.feature_flag) =\n match feature with\n | RangeCheck0 ->\n Some feature_flags.features.range_check0\n | RangeCheck1 ->\n Some feature_flags.features.range_check1\n | ForeignFieldAdd ->\n Some feature_flags.features.foreign_field_add\n | ForeignFieldMul ->\n Some feature_flags.features.foreign_field_mul\n | Xor ->\n Some feature_flags.features.xor\n | Rot ->\n Some feature_flags.features.rot\n | LookupTables ->\n Some (Lazy.force feature_flags.lookup_tables)\n | RuntimeLookupTables ->\n Some feature_flags.features.runtime_tables\n | TableWidth 3 ->\n Some (Lazy.force feature_flags.table_width_3)\n | TableWidth 2 ->\n Some (Lazy.force feature_flags.table_width_at_least_2)\n | TableWidth i when i <= 1 ->\n Some (Lazy.force feature_flags.table_width_at_least_1)\n | TableWidth _ ->\n None\n | LookupsPerRow 4 ->\n Some (Lazy.force feature_flags.lookups_per_row_4)\n | LookupsPerRow i when i <= 3 ->\n Some (Lazy.force feature_flags.lookups_per_row_3)\n | LookupsPerRow _ ->\n None\n | LookupPattern Lookup ->\n Some feature_flags.features.lookup\n | LookupPattern Xor ->\n Some (Lazy.force feature_flags.lookup_pattern_xor)\n | LookupPattern RangeCheck ->\n Some (Lazy.force feature_flags.lookup_pattern_range_check)\n | LookupPattern ForeignFieldMul ->\n Some feature_flags.features.foreign_field_mul\n\nlet scalars_env (type boolean t) (module B : Bool_intf with type t = boolean)\n (module F : Field_with_if_intf with type t = t and type bool = boolean)\n ~endo ~mds ~field_of_hex ~domain ~srs_length_log2\n ({ alpha; beta; gamma; zeta; joint_combiner; feature_flags } :\n (t, _, boolean) Minimal.t ) (e : (_ * _, _) Plonk_types.Evals.In_circuit.t)\n =\n let feature_flags = expand_feature_flags (module B) feature_flags in\n let witness = Vector.to_array e.w in\n let coefficients = Vector.to_array e.coefficients in\n let var (col, row) =\n let get_eval =\n match (row : Scalars.curr_or_next) with Curr -> fst | Next -> snd\n in\n match[@warning \"-4\"] (col : Scalars.Column.t) with\n | Witness i ->\n get_eval witness.(i)\n | Index Poseidon ->\n get_eval e.poseidon_selector\n | Index Generic ->\n get_eval e.generic_selector\n | Index CompleteAdd ->\n get_eval e.complete_add_selector\n | Index VarBaseMul ->\n get_eval e.mul_selector\n | Index EndoMul ->\n get_eval e.emul_selector\n | Index EndoMulScalar ->\n get_eval e.endomul_scalar_selector\n | Index RangeCheck0 ->\n get_eval (Opt.value_exn e.range_check0_selector)\n | Index RangeCheck1 ->\n get_eval (Opt.value_exn e.range_check1_selector)\n | Index ForeignFieldAdd ->\n get_eval (Opt.value_exn e.foreign_field_add_selector)\n | Index ForeignFieldMul ->\n get_eval (Opt.value_exn e.foreign_field_mul_selector)\n | Index Xor16 ->\n get_eval (Opt.value_exn e.xor_selector)\n | Index Rot64 ->\n get_eval (Opt.value_exn e.rot_selector)\n | Index i ->\n failwithf\n !\"Index %{sexp:Scalars.Gate_type.t}\\n\\\n %! should have been linearized away\"\n i ()\n | Coefficient i ->\n get_eval coefficients.(i)\n | LookupTable ->\n get_eval (Opt.value_exn e.lookup_table)\n | LookupSorted i ->\n get_eval\n (Opt.value_exn (Option.value_exn (Vector.nth e.lookup_sorted i)))\n | LookupAggreg ->\n get_eval (Opt.value_exn e.lookup_aggregation)\n | LookupRuntimeTable ->\n get_eval (Opt.value_exn e.runtime_lookup_table)\n | LookupKindIndex Lookup ->\n get_eval (Opt.value_exn e.lookup_gate_lookup_selector)\n | LookupKindIndex Xor ->\n get_eval (Opt.value_exn e.xor_lookup_selector)\n | LookupKindIndex RangeCheck ->\n get_eval (Opt.value_exn e.range_check_lookup_selector)\n | LookupKindIndex ForeignFieldMul ->\n get_eval (Opt.value_exn e.foreign_field_mul_lookup_selector)\n | LookupRuntimeSelector ->\n get_eval (Opt.value_exn e.runtime_lookup_table_selector)\n in\n let open F in\n let square x = x * x in\n let rec pow x n =\n if n = 0 then one\n else if n = 1 then x\n else\n let y = pow (square x) Int.(n / 2) in\n if n mod 2 = 0 then y else x * y\n in\n let alpha_pows =\n let arr = Array.create ~len:71 one in\n arr.(1) <- alpha ;\n for i = 2 to Int.(Array.length arr - 1) do\n arr.(i) <- alpha * arr.(Int.(i - 1))\n done ;\n arr\n in\n let w4, w3, w2, w1 =\n (* generator^{n - 3} *)\n let gen = domain#generator in\n (* gen_inv = gen^{n - 1} = gen^{-1} *)\n let w1 = one / gen in\n let w2 = square w1 in\n let w3 = w2 * w1 in\n let w4 = lazy (w3 * w1) in\n (w4, w3, w2, w1)\n in\n let zk_polynomial =\n (* Vanishing polynomial of [w1, w2, w3]\n evaluated at x = zeta\n *)\n (zeta - w1) * (zeta - w2) * (zeta - w3)\n in\n let zeta_to_n_minus_1 = lazy (domain#vanishing_polynomial zeta) in\n { Scalars.Env.add = ( + )\n ; sub = ( - )\n ; mul = ( * )\n ; square\n ; alpha_pow = (fun i -> alpha_pows.(i))\n ; var\n ; pow = Tuple2.uncurry pow\n ; field = field_of_hex\n ; cell = Fn.id\n ; double = (fun x -> of_int 2 * x)\n ; zk_polynomial\n ; omega_to_minus_3 = w3\n ; zeta_to_n_minus_1 = domain#vanishing_polynomial zeta\n ; endo_coefficient = endo\n ; mds = (fun (row, col) -> mds.(row).(col))\n ; srs_length_log2\n ; vanishes_on_last_4_rows =\n ( match joint_combiner with\n | None ->\n (* No need to compute anything when not using lookups *)\n F.one\n | Some _ ->\n zk_polynomial * (zeta - Lazy.force w4) )\n ; joint_combiner = Option.value joint_combiner ~default:F.one\n ; beta\n ; gamma\n ; unnormalized_lagrange_basis =\n (fun i ->\n let w_to_i =\n match i with\n | 0 ->\n one\n | 1 ->\n domain#generator\n | -1 ->\n w1\n | -2 ->\n w2\n | -3 ->\n w3\n | -4 ->\n Lazy.force w4\n | _ ->\n failwith \"TODO\"\n in\n Lazy.force zeta_to_n_minus_1 / (zeta - w_to_i) )\n ; if_feature =\n (fun (feature, e1, e2) ->\n let if_ b ~then_ ~else_ =\n match b with None -> e2 () | Some b -> F.if_ b ~then_ ~else_\n in\n let b = get_feature_flag feature_flags feature in\n if_ b ~then_:e1 ~else_:e2 )\n }\n\n(* TODO: not true anymore if lookup is used *)\n\n(** The offset of the powers of alpha for the permutation.\n(see https://github.com/o1-labs/proof-systems/blob/516b16fc9b0fdcab5c608cd1aea07c0c66b6675d/kimchi/src/index.rs#L190) *)\nlet perm_alpha0 : int = 21\n\nmodule Make (Shifted_value : Shifted_value.S) (Sc : Scalars.S) = struct\n (** Computes the ft evaluation at zeta.\n (see https://o1-labs.github.io/mina-book/crypto/plonk/maller_15.html#the-evaluation-of-l)\n *)\n let ft_eval0 (type t) (module F : Field_intf with type t = t) ~domain\n ~(env : t Scalars.Env.t)\n ({ alpha = _; beta; gamma; zeta; joint_combiner = _; feature_flags = _ } :\n _ Minimal.t ) (e : (_ * _, _) Plonk_types.Evals.In_circuit.t) p_eval0 =\n let open Plonk_types.Evals.In_circuit in\n let e0 field = fst (field e) in\n let e1 field = snd (field e) in\n let e0_s = Vector.map e.s ~f:fst in\n let zkp = env.zk_polynomial in\n let alpha_pow = env.alpha_pow in\n let zeta1m1 = env.zeta_to_n_minus_1 in\n let open F in\n let w0 = Vector.to_array e.w |> Array.map ~f:fst in\n let ft_eval0 =\n let a0 = alpha_pow perm_alpha0 in\n let w_n = w0.(Nat.to_int Plonk_types.Permuts_minus_1.n) in\n let init = (w_n + gamma) * e1 z * a0 * zkp in\n (* TODO: This shares some computation with the permutation scalar in\n derive_plonk. Could share between them. *)\n Vector.foldi e0_s ~init ~f:(fun i acc s ->\n ((beta * s) + w0.(i) + gamma) * acc )\n in\n let shifts = domain#shifts in\n let ft_eval0 = ft_eval0 - p_eval0 in\n let ft_eval0 =\n ft_eval0\n - Array.foldi shifts\n ~init:(alpha_pow perm_alpha0 * zkp * e0 z)\n ~f:(fun i acc s -> acc * (gamma + (beta * zeta * s) + w0.(i)))\n in\n let nominator =\n ( zeta1m1\n * alpha_pow Int.(perm_alpha0 + 1)\n * (zeta - env.omega_to_minus_3)\n + (zeta1m1 * alpha_pow Int.(perm_alpha0 + 2) * (zeta - one)) )\n * (one - e0 z)\n in\n let denominator = (zeta - env.omega_to_minus_3) * (zeta - one) in\n let ft_eval0 = ft_eval0 + (nominator / denominator) in\n let constant_term = Sc.constant_term env in\n ft_eval0 - constant_term\n\n (** Computes the list of scalars used in the linearization. *)\n let derive_plonk (type t) ?(with_label = fun _ (f : unit -> t) -> f ())\n (module F : Field_intf with type t = t) ~(env : t Scalars.Env.t) ~shift =\n let _ = with_label in\n let open F in\n fun ({ alpha\n ; beta\n ; gamma\n ; zeta\n ; joint_combiner\n ; feature_flags = actual_feature_flags\n } :\n _ Minimal.t )\n (e : (_ * _, _) Plonk_types.Evals.In_circuit.t)\n (*((e0, e1) : _ Plonk_types.Evals.In_circuit.t Double.t) *) ->\n let open Plonk_types.Evals.In_circuit in\n let e1 field = snd (field e) in\n let zkp = env.zk_polynomial in\n let alpha_pow = env.alpha_pow in\n let w0 = Vector.map e.w ~f:fst in\n let perm =\n let w0 = Vector.to_array w0 in\n with_label __LOC__ (fun () ->\n Vector.foldi e.s\n ~init:(e1 z * beta * alpha_pow perm_alpha0 * zkp)\n ~f:(fun i acc (s, _) -> acc * (gamma + (beta * s) + w0.(i)))\n |> negate )\n in\n In_circuit.map_fields\n ~f:(Shifted_value.of_field (module F) ~shift)\n { alpha\n ; beta\n ; gamma\n ; zeta\n ; zeta_to_domain_size = env.zeta_to_n_minus_1 + F.one\n ; zeta_to_srs_length = pow2pow (module F) zeta env.srs_length_log2\n ; perm\n ; lookup =\n ( match joint_combiner with\n | None ->\n Plonk_types.Opt.None\n | Some joint_combiner ->\n Some { joint_combiner } )\n ; feature_flags = actual_feature_flags\n }\n\n (** Check that computed proof scalars match the expected ones,\n using the native field.\n Note that the expected scalars are used to check\n the linearization in a proof over the other field\n (where those checks are more efficient),\n but we deferred the arithmetic checks until here\n so that we have the efficiency of the native field.\n *)\n let checked (type t)\n (module Impl : Snarky_backendless.Snark_intf.Run with type field = t)\n ~shift ~env (plonk : (_, _, _, _ Opt.t, _ Opt.t, _) In_circuit.t) evals =\n let actual =\n derive_plonk ~with_label:Impl.with_label\n (module Impl.Field)\n ~shift ~env\n { alpha = plonk.alpha\n ; beta = plonk.beta\n ; gamma = plonk.gamma\n ; zeta = plonk.zeta\n ; joint_combiner =\n ( match plonk.lookup with\n | Plonk_types.Opt.None ->\n None\n | Some l | Maybe (_, l) ->\n Some l.In_circuit.Lookup.joint_combiner )\n ; feature_flags = plonk.feature_flags\n }\n evals\n in\n let open Impl in\n let open In_circuit in\n with_label __LOC__ (fun () ->\n with_label __LOC__ (fun () ->\n List.map\n ~f:(fun f -> Shifted_value.equal Field.equal (f plonk) (f actual))\n [ perm ] )\n |> Boolean.all )\nend\n","type ('a, _) t =\n | [] : ('a, 'n) t\n | ( :: ) : 'a * ('a, 'n) t -> ('a, 'n Nat.s) t\n\nlet rec to_list : type a n. (a, n) t -> a list = function\n | [] ->\n []\n | x :: xs ->\n x :: to_list xs\n\nlet rec _length : type a n. (a, n) t -> int = function\n | [] ->\n 0\n | _ :: xs ->\n 1 + _length xs\n\nlet rec to_vector : type a n. (a, n) t -> a Vector.e = function\n | [] ->\n T []\n | x :: xs ->\n let (T xs) = to_vector xs in\n T (x :: xs)\n\nlet rec of_vector : type a n m. (a, n) Vector.t -> (n, m) Nat.Lte.t -> (a, m) t\n =\n fun v p ->\n match (v, p) with [], _ -> [] | x :: xs, S p -> x :: of_vector xs p\n\nlet rec of_list_and_length_exn : type a n. a list -> n Nat.t -> (a, n) t =\n fun xs n ->\n match (xs, n) with\n | [], _ ->\n []\n | x :: xs, S n ->\n x :: of_list_and_length_exn xs n\n | _ :: _, Z ->\n failwith \"At_most: Length mismatch\"\n\nmodule type S = sig\n type 'a t\n\n include Sigs.Hash_foldable.S1 with type 'a t := 'a t\n\n include Sigs.Comparable.S1 with type 'a t := 'a t\n\n include Sigs.Jsonable.S1 with type 'a t := 'a t\n\n include Sigs.Sexpable.S1 with type 'a t := 'a t\nend\n\nmodule type VERSIONED = sig\n type 'a ty\n\n module Stable : sig\n module V1 : sig\n type 'a t = 'a ty\n\n include Sigs.VERSIONED\n\n include Sigs.Binable.S1 with type 'a t := 'a t\n\n include S with type 'a t := 'a t\n end\n end\n\n type 'a t = 'a Stable.V1.t\n\n include S with type 'a t := 'a t\nend\n\nmodule Make = struct\n module Yojson (N : Nat.Intf) :\n Sigs.Jsonable.S1 with type 'a t := ('a, N.n) t = struct\n let to_yojson f t = Vector.L.to_yojson f (to_list t)\n\n let of_yojson f s =\n Core_kernel.Result.map (Vector.L.of_yojson f s)\n ~f:(Base.Fn.flip of_list_and_length_exn N.n)\n end\n\n module Sexpable (N : Nat.Intf) :\n Core_kernel.Sexpable.S1 with type 'a t := ('a, N.n) t =\n Core_kernel.Sexpable.Of_sexpable1\n (Base.List)\n (struct\n type nonrec 'a t = ('a, N.n) t\n\n let to_sexpable = to_list\n\n let of_sexpable xs = of_list_and_length_exn xs N.n\n end)\nend\n\ntype ('a, 'n) at_most = ('a, 'n) t\n\nmodule With_length (N : Nat.Intf) : S with type 'a t = ('a, N.n) at_most =\nstruct\n type 'a t = ('a, N.n) at_most\n\n let compare c t1 t2 = Base.List.compare c (to_list t1) (to_list t2)\n\n let hash_fold_t f s v = Base.List.hash_fold_t f s (to_list v)\n\n let equal f t1 t2 = List.equal f (to_list t1) (to_list t2)\n\n include Make.Sexpable (N)\n include Make.Yojson (N)\nend\n\nmodule At_most_2 = struct\n [%%versioned_binable\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n type 'a t = ('a, Nat.N2.n) at_most\n\n include\n Core_kernel.Binable.Of_binable1_without_uuid\n (Core_kernel.List.Stable.V1)\n (struct\n type nonrec 'a t = 'a t\n\n let to_binable = to_list\n\n let of_binable xs = of_list_and_length_exn xs Nat.N2.n\n end)\n\n include (\n With_length\n (Nat.N2) :\n module type of With_length (Nat.N2) with type 'a t := 'a t )\n end\n end]\n\n type 'a t = 'a Stable.Latest.t [@@deriving sexp, equal, compare, hash, yojson]\n\n type 'a ty = 'a t\n end\n\nmodule At_most_8 = struct\n [%%versioned_binable\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n type 'a t = ('a, Nat.N8.n) at_most\n\n include\n Core_kernel.Binable.Of_binable1_without_uuid\n (Core_kernel.List.Stable.V1)\n (struct\n type nonrec 'a t = 'a t\n\n let to_binable = to_list\n\n let of_binable xs = of_list_and_length_exn xs Nat.N8.n\n end)\n\n include (\n With_length\n (Nat.N8) :\n module type of With_length (Nat.N8) with type 'a t := 'a t )\n end\n end]\n\n type 'a t = 'a Stable.Latest.t [@@deriving sexp, equal, compare, hash, yojson]\n\n type 'a ty = 'a t\n end\n","(* This file is generated automatically with ocaml_gen. *)\n\nmodule FieldVectors = struct\n module Fp = struct\n type nonrec t\n\n type nonrec elt = Pasta_bindings.Fp.t\n\n external create : unit -> t = \"caml_fp_vector_create\"\n\n external length : t -> int = \"caml_fp_vector_length\"\n\n external emplace_back : t -> elt -> unit = \"caml_fp_vector_emplace_back\"\n\n external get : t -> int -> elt = \"caml_fp_vector_get\"\n\n external set : t -> int -> elt -> unit = \"caml_fp_vector_set\"\n end\n\n module Fq = struct\n type nonrec t\n\n type nonrec elt = Pasta_bindings.Fq.t\n\n external create : unit -> t = \"caml_fq_vector_create\"\n\n external length : t -> int = \"caml_fq_vector_length\"\n\n external emplace_back : t -> elt -> unit = \"caml_fq_vector_emplace_back\"\n\n external get : t -> int -> elt = \"caml_fq_vector_get\"\n\n external set : t -> int -> elt -> unit = \"caml_fq_vector_set\"\n end\nend\n\nmodule Protocol = struct\n module Gates = struct\n module Vector = struct\n module Fp = struct\n type nonrec t\n\n type nonrec elt = Pasta_bindings.Fp.t Kimchi_types.circuit_gate\n\n external create : unit -> t = \"caml_pasta_fp_plonk_gate_vector_create\"\n\n external add : t -> elt -> unit = \"caml_pasta_fp_plonk_gate_vector_add\"\n\n external get : t -> int -> elt = \"caml_pasta_fp_plonk_gate_vector_get\"\n\n external len : t -> int = \"caml_pasta_fp_plonk_gate_vector_len\"\n\n external wrap : t -> Kimchi_types.wire -> Kimchi_types.wire -> unit\n = \"caml_pasta_fp_plonk_gate_vector_wrap\"\n\n external digest : int -> t -> bytes\n = \"caml_pasta_fp_plonk_gate_vector_digest\"\n\n external to_json : int -> t -> string\n = \"caml_pasta_fp_plonk_circuit_serialize\"\n end\n\n module Fq = struct\n type nonrec t\n\n type nonrec elt = Pasta_bindings.Fq.t Kimchi_types.circuit_gate\n\n external create : unit -> t = \"caml_pasta_fq_plonk_gate_vector_create\"\n\n external add : t -> elt -> unit = \"caml_pasta_fq_plonk_gate_vector_add\"\n\n external get : t -> int -> elt = \"caml_pasta_fq_plonk_gate_vector_get\"\n\n external len : t -> int = \"caml_pasta_fq_plonk_gate_vector_len\"\n\n external wrap : t -> Kimchi_types.wire -> Kimchi_types.wire -> unit\n = \"caml_pasta_fq_plonk_gate_vector_wrap\"\n\n external digest : int -> t -> bytes\n = \"caml_pasta_fq_plonk_gate_vector_digest\"\n\n external to_json : int -> t -> string\n = \"caml_pasta_fq_plonk_circuit_serialize\"\n end\n end\n end\n\n module SRS = struct\n module Fp = struct\n type nonrec t\n\n module Poly_comm = struct\n type nonrec t =\n Pasta_bindings.Fp.t Kimchi_types.or_infinity Kimchi_types.poly_comm\n end\n\n external create : int -> t = \"caml_fp_srs_create\"\n\n external write : bool option -> t -> string -> unit = \"caml_fp_srs_write\"\n\n external read : int option -> string -> t option = \"caml_fp_srs_read\"\n\n external lagrange_commitment :\n t\n -> int\n -> int\n -> Pasta_bindings.Fq.t Kimchi_types.or_infinity Kimchi_types.poly_comm\n = \"caml_fp_srs_lagrange_commitment\"\n\n external add_lagrange_basis : t -> int -> unit\n = \"caml_fp_srs_add_lagrange_basis\"\n\n external commit_evaluations :\n t\n -> int\n -> Pasta_bindings.Fp.t array\n -> Pasta_bindings.Fq.t Kimchi_types.or_infinity Kimchi_types.poly_comm\n = \"caml_fp_srs_commit_evaluations\"\n\n external b_poly_commitment :\n t\n -> Pasta_bindings.Fp.t array\n -> Pasta_bindings.Fq.t Kimchi_types.or_infinity Kimchi_types.poly_comm\n = \"caml_fp_srs_b_poly_commitment\"\n\n external batch_accumulator_check :\n t\n -> Pasta_bindings.Fq.t Kimchi_types.or_infinity array\n -> Pasta_bindings.Fp.t array\n -> bool = \"caml_fp_srs_batch_accumulator_check\"\n\n external batch_accumulator_generate :\n t\n -> int\n -> Pasta_bindings.Fp.t array\n -> Pasta_bindings.Fq.t Kimchi_types.or_infinity array\n = \"caml_fp_srs_batch_accumulator_generate\"\n\n external urs_h : t -> Pasta_bindings.Fq.t Kimchi_types.or_infinity\n = \"caml_fp_srs_h\"\n end\n\n module Fq = struct\n type nonrec t\n\n external create : int -> t = \"caml_fq_srs_create\"\n\n external write : bool option -> t -> string -> unit = \"caml_fq_srs_write\"\n\n external read : int option -> string -> t option = \"caml_fq_srs_read\"\n\n external lagrange_commitment :\n t\n -> int\n -> int\n -> Pasta_bindings.Fp.t Kimchi_types.or_infinity Kimchi_types.poly_comm\n = \"caml_fq_srs_lagrange_commitment\"\n\n external add_lagrange_basis : t -> int -> unit\n = \"caml_fq_srs_add_lagrange_basis\"\n\n external commit_evaluations :\n t\n -> int\n -> Pasta_bindings.Fq.t array\n -> Pasta_bindings.Fp.t Kimchi_types.or_infinity Kimchi_types.poly_comm\n = \"caml_fq_srs_commit_evaluations\"\n\n external b_poly_commitment :\n t\n -> Pasta_bindings.Fq.t array\n -> Pasta_bindings.Fp.t Kimchi_types.or_infinity Kimchi_types.poly_comm\n = \"caml_fq_srs_b_poly_commitment\"\n\n external batch_accumulator_check :\n t\n -> Pasta_bindings.Fp.t Kimchi_types.or_infinity array\n -> Pasta_bindings.Fq.t array\n -> bool = \"caml_fq_srs_batch_accumulator_check\"\n\n external batch_accumulator_generate :\n t\n -> int\n -> Pasta_bindings.Fq.t array\n -> Pasta_bindings.Fp.t Kimchi_types.or_infinity array\n = \"caml_fq_srs_batch_accumulator_generate\"\n\n external urs_h : t -> Pasta_bindings.Fp.t Kimchi_types.or_infinity\n = \"caml_fq_srs_h\"\n end\n end\n\n module Index = struct\n module Fp = struct\n type nonrec t\n\n external create :\n Gates.Vector.Fp.t\n -> int\n -> Pasta_bindings.Fp.t Kimchi_types.runtime_table_cfg array\n -> int\n -> SRS.Fp.t\n -> t = \"caml_pasta_fp_plonk_index_create\"\n\n external max_degree : t -> int = \"caml_pasta_fp_plonk_index_max_degree\"\n\n external public_inputs : t -> int\n = \"caml_pasta_fp_plonk_index_public_inputs\"\n\n external domain_d1_size : t -> int\n = \"caml_pasta_fp_plonk_index_domain_d1_size\"\n\n external domain_d4_size : t -> int\n = \"caml_pasta_fp_plonk_index_domain_d4_size\"\n\n external domain_d8_size : t -> int\n = \"caml_pasta_fp_plonk_index_domain_d8_size\"\n\n external read : int option -> SRS.Fp.t -> string -> t\n = \"caml_pasta_fp_plonk_index_read\"\n\n external write : bool option -> t -> string -> unit\n = \"caml_pasta_fp_plonk_index_write\"\n end\n\n module Fq = struct\n type nonrec t\n\n external create :\n Gates.Vector.Fq.t\n -> int\n -> Pasta_bindings.Fq.t Kimchi_types.runtime_table_cfg array\n -> int\n -> SRS.Fq.t\n -> t = \"caml_pasta_fq_plonk_index_create\"\n\n external max_degree : t -> int = \"caml_pasta_fq_plonk_index_max_degree\"\n\n external public_inputs : t -> int\n = \"caml_pasta_fq_plonk_index_public_inputs\"\n\n external domain_d1_size : t -> int\n = \"caml_pasta_fq_plonk_index_domain_d1_size\"\n\n external domain_d4_size : t -> int\n = \"caml_pasta_fq_plonk_index_domain_d4_size\"\n\n external domain_d8_size : t -> int\n = \"caml_pasta_fq_plonk_index_domain_d8_size\"\n\n external read : int option -> SRS.Fq.t -> string -> t\n = \"caml_pasta_fq_plonk_index_read\"\n\n external write : bool option -> t -> string -> unit\n = \"caml_pasta_fq_plonk_index_write\"\n end\n end\n\n module VerifierIndex = struct\n module Fp = struct\n type nonrec t =\n ( Pasta_bindings.Fp.t\n , SRS.Fp.t\n , Pasta_bindings.Fq.t Kimchi_types.or_infinity Kimchi_types.poly_comm\n )\n Kimchi_types.VerifierIndex.verifier_index\n\n external create : Index.Fp.t -> t\n = \"caml_pasta_fp_plonk_verifier_index_create\"\n\n external read : int option -> SRS.Fp.t -> string -> t\n = \"caml_pasta_fp_plonk_verifier_index_read\"\n\n external write : bool option -> t -> string -> unit\n = \"caml_pasta_fp_plonk_verifier_index_write\"\n\n external shifts : int -> Pasta_bindings.Fp.t array\n = \"caml_pasta_fp_plonk_verifier_index_shifts\"\n\n external dummy : unit -> t = \"caml_pasta_fp_plonk_verifier_index_dummy\"\n\n external deep_copy : t -> t\n = \"caml_pasta_fp_plonk_verifier_index_deep_copy\"\n end\n\n module Fq = struct\n type nonrec t =\n ( Pasta_bindings.Fq.t\n , SRS.Fq.t\n , Pasta_bindings.Fp.t Kimchi_types.or_infinity Kimchi_types.poly_comm\n )\n Kimchi_types.VerifierIndex.verifier_index\n\n external create : Index.Fq.t -> t\n = \"caml_pasta_fq_plonk_verifier_index_create\"\n\n external read : int option -> SRS.Fq.t -> string -> t\n = \"caml_pasta_fq_plonk_verifier_index_read\"\n\n external write : bool option -> t -> string -> unit\n = \"caml_pasta_fq_plonk_verifier_index_write\"\n\n external shifts : int -> Pasta_bindings.Fq.t array\n = \"caml_pasta_fq_plonk_verifier_index_shifts\"\n\n external dummy : unit -> t = \"caml_pasta_fq_plonk_verifier_index_dummy\"\n\n external deep_copy : t -> t\n = \"caml_pasta_fq_plonk_verifier_index_deep_copy\"\n end\n end\n\n module Oracles = struct\n module Fp = struct\n type nonrec t = Pasta_bindings.Fp.t Kimchi_types.oracles\n\n external create :\n Pasta_bindings.Fq.t Kimchi_types.or_infinity Kimchi_types.poly_comm\n array\n -> ( Pasta_bindings.Fp.t\n , SRS.Fp.t\n , Pasta_bindings.Fq.t Kimchi_types.or_infinity Kimchi_types.poly_comm\n )\n Kimchi_types.VerifierIndex.verifier_index\n -> ( Pasta_bindings.Fq.t Kimchi_types.or_infinity\n , Pasta_bindings.Fp.t )\n Kimchi_types.prover_proof\n -> t = \"fp_oracles_create\"\n\n external dummy : unit -> Pasta_bindings.Fp.t Kimchi_types.random_oracles\n = \"fp_oracles_dummy\"\n\n external deep_copy :\n Pasta_bindings.Fp.t Kimchi_types.random_oracles\n -> Pasta_bindings.Fp.t Kimchi_types.random_oracles\n = \"fp_oracles_deep_copy\"\n end\n\n module Fq = struct\n type nonrec t = Pasta_bindings.Fq.t Kimchi_types.oracles\n\n external create :\n Pasta_bindings.Fp.t Kimchi_types.or_infinity Kimchi_types.poly_comm\n array\n -> ( Pasta_bindings.Fq.t\n , SRS.Fq.t\n , Pasta_bindings.Fp.t Kimchi_types.or_infinity Kimchi_types.poly_comm\n )\n Kimchi_types.VerifierIndex.verifier_index\n -> ( Pasta_bindings.Fp.t Kimchi_types.or_infinity\n , Pasta_bindings.Fq.t )\n Kimchi_types.prover_proof\n -> t = \"fq_oracles_create\"\n\n external dummy : unit -> Pasta_bindings.Fq.t Kimchi_types.random_oracles\n = \"fq_oracles_dummy\"\n\n external deep_copy :\n Pasta_bindings.Fq.t Kimchi_types.random_oracles\n -> Pasta_bindings.Fq.t Kimchi_types.random_oracles\n = \"fq_oracles_deep_copy\"\n end\n end\n\n module Proof = struct\n module Fp = struct\n external create :\n Index.Fp.t\n -> FieldVectors.Fp.t array\n -> Pasta_bindings.Fp.t array\n -> Pasta_bindings.Fq.t Kimchi_types.or_infinity array\n -> ( Pasta_bindings.Fq.t Kimchi_types.or_infinity\n , Pasta_bindings.Fp.t )\n Kimchi_types.prover_proof = \"caml_pasta_fp_plonk_proof_create\"\n\n external create_and_verify :\n Index.Fp.t\n -> FieldVectors.Fp.t array\n -> Pasta_bindings.Fp.t array\n -> Pasta_bindings.Fq.t Kimchi_types.or_infinity array\n -> ( Pasta_bindings.Fq.t Kimchi_types.or_infinity\n , Pasta_bindings.Fp.t )\n Kimchi_types.prover_proof\n = \"caml_pasta_fp_plonk_proof_create_and_verify\"\n\n external example_with_lookup :\n SRS.Fp.t\n -> Index.Fp.t\n * Pasta_bindings.Fp.t\n * ( Pasta_bindings.Fq.t Kimchi_types.or_infinity\n , Pasta_bindings.Fp.t )\n Kimchi_types.prover_proof\n = \"caml_pasta_fp_plonk_proof_example_with_lookup\"\n\n external example_with_ffadd :\n SRS.Fp.t\n -> Index.Fp.t\n * Pasta_bindings.Fp.t\n * ( Pasta_bindings.Fq.t Kimchi_types.or_infinity\n , Pasta_bindings.Fp.t )\n Kimchi_types.prover_proof\n = \"caml_pasta_fp_plonk_proof_example_with_ffadd\"\n\n external example_with_xor :\n SRS.Fp.t\n -> Index.Fp.t\n * (Pasta_bindings.Fp.t * Pasta_bindings.Fp.t)\n * ( Pasta_bindings.Fq.t Kimchi_types.or_infinity\n , Pasta_bindings.Fp.t )\n Kimchi_types.prover_proof\n = \"caml_pasta_fp_plonk_proof_example_with_xor\"\n\n external example_with_rot :\n SRS.Fp.t\n -> Index.Fp.t\n * (Pasta_bindings.Fp.t * Pasta_bindings.Fp.t)\n * ( Pasta_bindings.Fq.t Kimchi_types.or_infinity\n , Pasta_bindings.Fp.t )\n Kimchi_types.prover_proof\n = \"caml_pasta_fp_plonk_proof_example_with_rot\"\n\n external example_with_foreign_field_mul :\n SRS.Fp.t\n -> Index.Fp.t\n * ( Pasta_bindings.Fq.t Kimchi_types.or_infinity\n , Pasta_bindings.Fp.t )\n Kimchi_types.prover_proof\n = \"caml_pasta_fp_plonk_proof_example_with_foreign_field_mul\"\n\n external example_with_range_check :\n SRS.Fp.t\n -> Index.Fp.t\n * ( Pasta_bindings.Fq.t Kimchi_types.or_infinity\n , Pasta_bindings.Fp.t )\n Kimchi_types.prover_proof\n = \"caml_pasta_fp_plonk_proof_example_with_range_check\"\n\n external example_with_range_check0 :\n SRS.Fp.t\n -> Index.Fp.t\n * ( Pasta_bindings.Fq.t Kimchi_types.or_infinity\n , Pasta_bindings.Fp.t )\n Kimchi_types.prover_proof\n = \"caml_pasta_fp_plonk_proof_example_with_range_check0\"\n\n external verify :\n ( Pasta_bindings.Fp.t\n , SRS.Fp.t\n , Pasta_bindings.Fq.t Kimchi_types.or_infinity Kimchi_types.poly_comm\n )\n Kimchi_types.VerifierIndex.verifier_index\n -> ( Pasta_bindings.Fq.t Kimchi_types.or_infinity\n , Pasta_bindings.Fp.t )\n Kimchi_types.prover_proof\n -> bool = \"caml_pasta_fp_plonk_proof_verify\"\n\n external batch_verify :\n ( Pasta_bindings.Fp.t\n , SRS.Fp.t\n , Pasta_bindings.Fq.t Kimchi_types.or_infinity Kimchi_types.poly_comm\n )\n Kimchi_types.VerifierIndex.verifier_index\n array\n -> ( Pasta_bindings.Fq.t Kimchi_types.or_infinity\n , Pasta_bindings.Fp.t )\n Kimchi_types.prover_proof\n array\n -> bool = \"caml_pasta_fp_plonk_proof_batch_verify\"\n\n external dummy :\n unit\n -> ( Pasta_bindings.Fq.t Kimchi_types.or_infinity\n , Pasta_bindings.Fp.t )\n Kimchi_types.prover_proof = \"caml_pasta_fp_plonk_proof_dummy\"\n\n external deep_copy :\n ( Pasta_bindings.Fq.t Kimchi_types.or_infinity\n , Pasta_bindings.Fp.t )\n Kimchi_types.prover_proof\n -> ( Pasta_bindings.Fq.t Kimchi_types.or_infinity\n , Pasta_bindings.Fp.t )\n Kimchi_types.prover_proof = \"caml_pasta_fp_plonk_proof_deep_copy\"\n end\n\n module Fq = struct\n external create :\n Index.Fq.t\n -> FieldVectors.Fq.t array\n -> Pasta_bindings.Fq.t array\n -> Pasta_bindings.Fp.t Kimchi_types.or_infinity array\n -> ( Pasta_bindings.Fp.t Kimchi_types.or_infinity\n , Pasta_bindings.Fq.t )\n Kimchi_types.prover_proof = \"caml_pasta_fq_plonk_proof_create\"\n\n external verify :\n ( Pasta_bindings.Fq.t\n , SRS.Fq.t\n , Pasta_bindings.Fp.t Kimchi_types.or_infinity Kimchi_types.poly_comm\n )\n Kimchi_types.VerifierIndex.verifier_index\n -> ( Pasta_bindings.Fp.t Kimchi_types.or_infinity\n , Pasta_bindings.Fq.t )\n Kimchi_types.prover_proof\n -> bool = \"caml_pasta_fq_plonk_proof_verify\"\n\n external batch_verify :\n ( Pasta_bindings.Fq.t\n , SRS.Fq.t\n , Pasta_bindings.Fp.t Kimchi_types.or_infinity Kimchi_types.poly_comm\n )\n Kimchi_types.VerifierIndex.verifier_index\n array\n -> ( Pasta_bindings.Fp.t Kimchi_types.or_infinity\n , Pasta_bindings.Fq.t )\n Kimchi_types.prover_proof\n array\n -> bool = \"caml_pasta_fq_plonk_proof_batch_verify\"\n\n external dummy :\n unit\n -> ( Pasta_bindings.Fp.t Kimchi_types.or_infinity\n , Pasta_bindings.Fq.t )\n Kimchi_types.prover_proof = \"caml_pasta_fq_plonk_proof_dummy\"\n\n external deep_copy :\n ( Pasta_bindings.Fp.t Kimchi_types.or_infinity\n , Pasta_bindings.Fq.t )\n Kimchi_types.prover_proof\n -> ( Pasta_bindings.Fp.t Kimchi_types.or_infinity\n , Pasta_bindings.Fq.t )\n Kimchi_types.prover_proof = \"caml_pasta_fq_plonk_proof_deep_copy\"\n end\n end\nend\n","open Core_kernel\n\ntype 'a t = { mds : 'a array array; round_constants : 'a array array }\n[@@deriving bin_io]\n\nlet map { mds; round_constants } ~f =\n let f = Array.map ~f:(Array.map ~f) in\n { mds = f mds; round_constants = f round_constants }\n","let params_Bn128 =\n { Params.mds =\n [| [| \"15913613074278028058360498857043999222867772811338037425231170199156889337604\"\n ; \"65180538277771794992983614695816638391617290189527384182155063505825555179\"\n ; \"5394145287608961087977235806233358974273334844303649346024304966582176196487\"\n |]\n ; [| \"15414815283538893716009156559702084916211023875136356807248219032453798152465\"\n ; \"3463018243616155786290732419705147785020336294529003837260493734746385539469\"\n ; \"12716468877825667500219920861172138145894921271005565146996037137547785771411\"\n |]\n ; [| \"1792045203208933407244693490495238027092197802128268175009298962707699842710\"\n ; \"76356542649790718492035692281837451271781062546545119705441901238018861818\"\n ; \"9520069514281255561624128661339565451189764370791651000392579220353790670830\"\n |]\n |]\n ; round_constants =\n [| [| \"12455131979215983316735047846658291859029812584241282581257197013302738138666\"\n ; \"20029656970890966196099810168066995443524989185718089119520857141365451679654\"\n ; \"8929913078653797661905726823410775654210481762974885244818731639242977419622\"\n |]\n ; [| \"8662787891019924101534530927954444401015394189462080864609938870691307539536\"\n ; \"20294115837600366998212029140165760858924828875933683067126492672917588261877\"\n ; \"2682014173266320611146882768057075830238591616831154961603507352639750394592\"\n |]\n ; [| \"18907515456503482670621260399010811269866082079896285203284611749350771281411\"\n ; \"1424609887444859910324043210736091906100438801135358613993092433663809225411\"\n ; \"1531059541788158835714117823424146308635531997487162670061618032695665453831\"\n |]\n ; [| \"19444238474448321066398700689084787616548516614414549514749853660756611792379\"\n ; \"2236237945310446639621733106225706828551103453944652411264620402517164583264\"\n ; \"12605646628049520919535266096828454658561884709869426105979276828733666269521\"\n |]\n ; [| \"14653124040822125428573681427514890989900893513402451718822527259901516216058\"\n ; \"1535968898232047429062068090527484451997796559364245278047376516596586180554\"\n ; \"3307538294663905716144414865227035949873283327379581103741297483063276195183\"\n |]\n ; [| \"21111467054595055527346262240389751012262991994706430976179289552457483727796\"\n ; \"17649294376560630922417546944777537620537408190408066211453084495108565929366\"\n ; \"7683463515567855955851784553909126014159314191075450219244796328948411069744\"\n |]\n ; [| \"21262229851583325466767017312569047417622760705999088078958228786464449033067\"\n ; \"11691182518884460508022694337582074624192039580202157360389815110719437213363\"\n ; \"8690728446593494554377477996892461126663797704587025899930929227865493269824\"\n |]\n ; [| \"21622260498668079571860417097494779160364898191075577203239012897437375456411\"\n ; \"21067767847052854366896470071519184914663018103241392453030719014890445499665\"\n ; \"21348828409856354758094844442899573788047317201055667836817119877806560465334\"\n |]\n ; [| \"2704440995725305992776846806711930876273040749514871232837487081811513368296\"\n ; \"1142050494870706434296077676238780951797136607536187326800297147932619878418\"\n ; \"3652944740784795248484484454916800802095288396765069024258114251561069674735\"\n |]\n ; [| \"1747641587474624832364464288237802774971629275511085691789065855359044028198\"\n ; \"14935834110027005954806028171080511939971704126366459140378790942754129686907\"\n ; \"3215720726490672077485888789426411334496962379737529853320875594879037332594\"\n |]\n ; [| \"2892159931078719741396670290810431382361178666606213506995456264415113913847\"\n ; \"1938538891009879014088646889644828497511974353410971027478866497380422633484\"\n ; \"13916214761542255527505866254811968868327635410573168146297241319868121689821\"\n |]\n ; [| \"266821775768872344171470219200118028338254464492956024813242747554382748942\"\n ; \"11055386921184594780372263378420826851562920740321950336882051897732501262543\"\n ; \"2504617730099125455929793538006173214604536705392412461363354681040283013164\"\n |]\n ; [| \"8077046888362371937918818344109572894796988781119069525502907016581642522710\"\n ; \"7281012798633884984170366068851653834509460567285503188952416990462599509288\"\n ; \"11914125581503780978633571238267986373793149282818856451291452464271781243920\"\n |]\n ; [| \"5911373857383996424444312456230128887937254975139357544835683280828995545397\"\n ; \"20728259298426389276714612941176977888429183727869747381529137474366072279101\"\n ; \"8331123017723440628782766975941869108307759426898189357261715346312601104654\"\n |]\n ; [| \"19978529403683797449165109778464832800224916941903951374610236813523844409526\"\n ; \"17316158269457914256007584527534747738658973027567786054549020564540952112346\"\n ; \"7848194400773744361171082305364633343688318123652518347170031226439829254882\"\n |]\n ; [| \"17698087730709566968258013675219881840614043344609152682517330801348583470562\"\n ; \"2484533502052370851335172153342694835144795809438965797062785488685902188726\"\n ; \"13372068881052003992228272108672679285817785895634149926809187580418595890381\"\n |]\n ; [| \"4450005426773734601782625050142815413017019480402129494014819930729323864775\"\n ; \"15031465389782276133463098319911853017052619244999605688724393058338301291115\"\n ; \"6028902109643218557806340932181364476799161079643636815411563224652423572198\"\n |]\n ; [| \"2957732585137901025626087202113249345076588554941059487693780861098604986119\"\n ; \"12565476532112137808460978474958060441970941349010371267577877299656634907765\"\n ; \"10508327646678453674728048391759640526197954899878596680197847666563367632543\"\n |]\n ; [| \"4493451765845812430310778141104432201437429164475176054680492630627878568332\"\n ; \"15095408309586969968044201398966210357547906905122453139947200130015688526573\"\n ; \"10819130048432875198797495465270179395954461390529553930221225323229387202234\"\n |]\n ; [| \"15905267794015672354278595057670574122197927816429433548802165993220415414073\"\n ; \"19290205907831398371768999387869637435049824367233327965730120884036212709842\"\n ; \"15451920390057917627290027104082580122165965120355347782937661856388593985245\"\n |]\n ; [| \"6425598873527092853966039409614693840647173123073098849086711894647944582332\"\n ; \"17307716513182567320564075539526480893558355908652993731441220999922946005081\"\n ; \"19372285427179952013203092658533484049593114439149219035606060254764845851391\"\n |]\n ; [| \"14724939606645168531546334343600232253284320276481307778787768813885931648950\"\n ; \"4684996260500305121238590806572541849891754312215139285622888510153705963000\"\n ; \"19906278135333202031075665370853003279083131420237405129919260859757146418025\"\n |]\n ; [| \"3999693912508849442569285360026642503093489903926874133118153062461080435481\"\n ; \"20129375303694053217240183105192753906500831553949001131297105718176015558964\"\n ; \"17281496576809338419011697046933296343189100335422897604615575811331627359485\"\n |]\n ; [| \"15637748291684046440453413703705692658155214802161964102299272768648229342362\"\n ; \"2094444825794502002152585986969571562449905861771519270554787618649438333195\"\n ; \"1152889601932463959824817875107315518104722504910095364729880245759523916044\"\n |]\n ; [| \"12114165850379066500859611262167642397834899331804245444372878412987365128590\"\n ; \"20821227542001445006023346122554483849065713580779858784021328359824080462519\"\n ; \"3440756720132945332811173288138999408441021502908547499697282473681525253805\"\n |]\n ; [| \"20938628428302899368158656913047855118000040623605421135349389583331392728782\"\n ; \"8850081254230234130482383430433176873344633494243110112848647064077741649744\"\n ; \"1819639941546179668398979507053724449231350395599747300736218202072168364980\"\n |]\n ; [| \"21219092773772827667886204262476112905428217689703647484316763603169544906986\"\n ; \"13148487544990345541730567143235754764404038697816450525897467218977412799129\"\n ; \"13598807739063229961519663325640861142062394342851403440808670891533339780790\"\n |]\n ; [| \"18784327298376147342042823437947970462892869194728299228507919810276864843414\"\n ; \"2764493745803317574883853704043825342340808631956690807684613803167040529511\"\n ; \"21531775639025076953020023111055490895978901214310417059307899853240995381819\"\n |]\n ; [| \"19964398501876039777029130298682737202257582985971095863290288610857831427638\"\n ; \"15003442983970848114681480873546789629160262059108570865485071572172687676835\"\n ; \"20614241966717622390914334053622572167995367802051836931454426877074875942253\"\n |]\n ; [| \"19733168743390283576337440585736332292298547880804855952734808967278966077887\"\n ; \"20530621481603446397085836296967350209890164029268319619481535419199429275412\"\n ; \"12361620530467399202722610329149901344545851901477091854159960517963801528971\"\n |]\n ; [| \"9497854724940806346676139162466690071592872530638144182764466319052293463165\"\n ; \"7549205476288061047040852944548942878112823732145584918107208536541712726277\"\n ; \"9010672859023729500640324904403960830965495099902505763591033382017769059028\"\n |]\n ; [| \"809006882768062359480853341102632220777932068978149301935174282279746446958\"\n ; \"7106371976957177712230305966566701811850820970657101896348127436646177656365\"\n ; \"18845123379649840503129460949570724717923057602542920800815047452665097128575\"\n |]\n ; [| \"14712923944932171466124439335703740452883296028663247289510978550197451911919\"\n ; \"19555759172327736128240171000715903945570888389700763573790859521156095228287\"\n ; \"17179695917466049633838471880559548490881310699092342418090873652775810295378\"\n |]\n ; [| \"18944876856792381816055068913314141690530834943354883079085532905267119397008\"\n ; \"3257630700960849517603336097571474897923100547762764495987576852490355943460\"\n ; \"3963500912949736174926372928446487843084987377580944585294277449817215093365\"\n |]\n ; [| \"21304716730402869084944080869903443431235336418077153507261240151959530377653\"\n ; \"18998265936988640248585036755202701418246223100957416731998639191794797638003\"\n ; \"16839625825914009701942141907800050396084195897386326382915730670235616618695\"\n |]\n ; [| \"16907937154215020261110468963982390213438461071031811101554056252102505124726\"\n ; \"1294898660752289889975651445755491766586322714088107994205473403531724749589\"\n ; \"9172546393414544394143001120250095355087186863911844697260687867341704896778\"\n |]\n ; [| \"18891778779724165209072874482651171817270086247356116562427206569585293483055\"\n ; \"13093554332096549605604948416229955030385793767090042194569924056338021838108\"\n ; \"6540069282618873496342140872069384185118574828832026154295825270730722501809\"\n |]\n ; [| \"11698805795265597745890922320669982345748592147825010914959366790903803563027\"\n ; \"11128587690756409041400570351324823090287237584985813997261416805030246953137\"\n ; \"574796972312053991589591668868339165343116554180562026519971681663627339366\"\n |]\n ; [| \"8263653526367544279471418475309371793291954818747935714794248360166503487859\"\n ; \"495546618036723566920914648951352373868059898268055487677897567226892784967\"\n ; \"2528292188392170914010448139211586215817069915670005292953294092269979070980\"\n |]\n ; [| \"14954597262610438728753406794870316034770442280143947719391702684620418262496\"\n ; \"2873290581141877304970576969082349138229332018341156071844198415188999408160\"\n ; \"7877226570858832633875209751493918650976179001613717862579011309181456152753\"\n |]\n ; [| \"5290811263292128650829809831924435265520706616680110737471312421357061576251\"\n ; \"5711353914598993184207904758686192904620948114158132435163135551043392236587\"\n ; \"9671966951859991559346179676315084295317241890404128352532995814366687016784\"\n |]\n ; [| \"20648234869018782942484412385329986060607455807332118750782252709151244400533\"\n ; \"1521221467156754943933671253020851096017281629892920730907443291972734010497\"\n ; \"6375300799036358132607612364454746219201386369274233783761503007631282551380\"\n |]\n ; [| \"18921242117750773300194037006101341214923275379274370683247849512779159129078\"\n ; \"7813033521740037204631731835076108697814182206021466630450781049551634237483\"\n ; \"7795208366125068859216483161820518701837348485078219412133643408967011329822\"\n |]\n ; [| \"21634048616875364065210304993971256601326650069082669576726378272437410251852\"\n ; \"1440291557054822025042926468154900761163167753541613162663250995564641638121\"\n ; \"8030862880899531201072645375229460968330384014296763956553993045932171788794\"\n |]\n ; [| \"18227143364048378671809657511264604955612895339528675264153781365139338073044\"\n ; \"21758886539711282145698252967647695643837152466011063420158481037553923112829\"\n ; \"2085588517087605436136379278738013214233743532079287631079316773925068862732\"\n |]\n ; [| \"9513664655545306376987968929852776467090105742275395185801917554996684570014\"\n ; \"3550496136894926428779047632731319031180547135184616875506154252232382772731\"\n ; \"17611757480287922505786279147168077243913583114117625089682651438292645979006\"\n |]\n ; [| \"9510531870810299962531161626148485102758508164021526746981465493469502973181\"\n ; \"13147395489659079072941169740078305253501735721348147621757420460777184976765\"\n ; \"20981004218820236011689230170078809973840534961691702543937445515733151438851\"\n |]\n ; [| \"7510474971056266438887013036637998526887329893492694485779774584612719651459\"\n ; \"1410506880075029891986606588556057112819357276074907152324471561666187504226\"\n ; \"8531153700191448965915372279944017070557402838400132057846710117192547288312\"\n |]\n ; [| \"9754021311900999917627020811752417367253388211990562024285328010011773088524\"\n ; \"2596434275792412604724294796434266571220373976229139969740378299737237088707\"\n ; \"12362606196840499695717697542757730593369897628148107607660372162713524022091\"\n |]\n ; [| \"7436712609498458515091822640340398689078308761236724993140849063351217155692\"\n ; \"13658397008139421803306375444518324400013880452735832208526361116879733324843\"\n ; \"8172299227253932586074375157726142633344272790321861656172484971306271304428\"\n |]\n ; [| \"8605586894544301092657394167906502995894014247978769840701086209902531650480\"\n ; \"8900145888985471928279988821934068156350024482295663273746853580585203659117\"\n ; \"10470367937616887936936637392485540045417066546520320064401889047735866701687\"\n |]\n ; [| \"11506602210275354295255815678397482725225279643868372198705067756030230710066\"\n ; \"17848856881287888035559207919717746181941756011012420474955535369227552058196\"\n ; \"19621145748343950799654655801831590696734631175445290325293238308726746856381\"\n |]\n ; [| \"12864577757979281303137787677967581089249504938390812240088160999517854207023\"\n ; \"18146514933233558325125054842576736679593504913006946427595273862389774486334\"\n ; \"17884323247493851213892188228998881081766487773962855826892871743190914823275\"\n |]\n ; [| \"15402752720164650756401756498467037967910822997380610100998339390049962612988\"\n ; \"7603833157231114748089157493970988832295123465399487746989788482408777456140\"\n ; \"2397354421161661799662850246720819176952681967344524176801474312220041680576\"\n |]\n ; [| \"4644616545339594419852483555455431260822330146405566037177120172304445909733\"\n ; \"5263316028405817083848964416595634986103420395264546879434975622138579030157\"\n ; \"17782273009863750298483603933610732253879825505411230932533407287574651036994\"\n |]\n ; [| \"6757311365906043231713330034681410088312690560822302805339061832230418577842\"\n ; \"1747290142831105666564148972092238090059848968766027623980111244846463775952\"\n ; \"15626225602106279302483693031455114927351808163854564654776963760236790234423\"\n |]\n ; [| \"4913834867494755682369542218157533479788980551925269537630059523083653281581\"\n ; \"9877617390649361889067963484857474874019563445507538784053773745685676317984\"\n ; \"8907943459697784281828563593274242625606699321626165523327303792165072591809\"\n |]\n ; [| \"14664441047816797924985624056829230652985567659075289185564514710695287602702\"\n ; \"7007559757050385070202651829819464617707337597545855825279581955097245183469\"\n ; \"9907785227545441866241924986174555965766785257012652276622736289520175209842\"\n |]\n ; [| \"7597089497072493253646609764279824048404496412283438400323292326749646956121\"\n ; \"17909115638003629710512488646279326535029895707443505816458395075119245680309\"\n ; \"19899288359840151413448648239934294957736422087766709732366801832575234898200\"\n |]\n ; [| \"2776453255551777594442164922386336989357594907242688467733231910101268428455\"\n ; \"8731512921802677638551206899688496704819923065834522157915668185471088199231\"\n ; \"4270476107979642660344328132306502268479679050594759895042187137572326348178\"\n |]\n ; [| \"372963191403207230700085823960930798511810380777302780932220121859190714585\"\n ; \"1925392345596430848747460046135384348851089627416455489129305703977614383441\"\n ; \"17789118105598492176513882528357022912279065134405326075480819364512109487507\"\n |]\n ; [| \"20825008332751730091153821568987055752818061964131515789006779860691972036326\"\n ; \"12268072226614207724192089529070006978828099093641075700056577974897967878044\"\n ; \"8022939345678575485891537869705234790517539631432710130025799605516328239965\"\n |]\n ; [| \"15920446357440463160102379501579737913732417583637399015449814673775945192536\"\n ; \"4889967763577997404116252754960720158524059605911680924823220236886032161368\"\n ; \"13012115310019421859484865413402512912208022868124085927375736053832542569552\"\n |]\n ; [| \"11184812848348784840758139578916764774803469528077342079324383443440533140274\"\n ; \"10919525644265283860710095821750480494008303946536963464168615308937735732928\"\n ; \"16643027351354734329387947050668943310718100664075062130784371167893146427056\"\n |]\n ; [| \"2547391079287933146721925003560805204947901674695385307171999864858240689647\"\n ; \"5461671591847528192305502006203904211083239588855740323679605269651748982133\"\n ; \"1475483405991676112203600016600397946486872901513454996978092595555024286449\"\n |]\n ; [| \"5284066352388289958166453130467461920311116585098603685258698324490583696214\"\n ; \"11079707743980425617427448803513138667107248696505015838485445487813501565055\"\n ; \"18819466619498056228169794477791931948230648942982309978769076145394195937041\"\n |]\n ; [| \"20108313126965297449432768889178575293551084908049301416432179490902972394331\"\n ; \"18446218870769123862937242938812447270514023886221086573211479802027270358088\"\n ; \"16636528128134911466622907961467317982179835733058354229921170933476186200761\"\n |]\n ; [| \"21580255665898770000010464770058710398562069327783167608746916860519840032223\"\n ; \"14719915601901504081829966027980062397831689039960210526441564682684152170817\"\n ; \"797386830910520008361185815477523544664694040635544500916993469578452189812\"\n |]\n ; [| \"9191954826842055432037975444679415772735351199913945274909680288228536535340\"\n ; \"11513278700830950317038408125611466230422950302149566779135423862866530023329\"\n ; \"13459513701495368402370574098477760729128222868352131109204646186188457791240\"\n |]\n ; [| \"5838069727284828316721466034821618997221603062621589223178808662165373261546\"\n ; \"6979902978975477924362644821755411140298300026935490428140425890908442375988\"\n ; \"16599678038272927378481138839511139789855186087290435109798146115836043579679\"\n |]\n ; [| \"12381797209422929428691015082010109537263140181969703876017444022025467803832\"\n ; \"6196650026284414689888119006953515712490610535320673834463816720858366634575\"\n ; \"18782265413128936113173411940279630009396595382244197409034789821410800698518\"\n |]\n ; [| \"18317002472599225949038448120242542829985613745531554876060436499109578301758\"\n ; \"1113479082803535302111716504211921283895099225074844625686926178204705529642\"\n ; \"5260759667255734667421232066934840926892602367345740699882163520384512718144\"\n |]\n ; [| \"127322212868745470136356444796372247628159800282485305190839131621480537609\"\n ; \"12956514709922286639520985225111137950302442378466870763868693820049405409474\"\n ; \"16137538628380664965477096166491883462931577135505027115582810475234963977421\"\n |]\n ; [| \"11057045636926688236651567778699977961671424092293844825634750356999128470728\"\n ; \"20835936071817504066403719723663997794776505092359954695254304206506756731833\"\n ; \"11961388648747677421997837882451601307689195235077835309786508479783430361445\"\n |]\n ; [| \"1793573889039951715150662350698925328676543592757846244725079508391393408932\"\n ; \"13402289137612357934827599869485046878369856459821775713222740005646790544884\"\n ; \"6508055411788943934719705492602467864380077642763636443982129530687343724318\"\n |]\n ; [| \"17607902685988307931266356493635411696470169831190714792315124728753478035177\"\n ; \"8194273390415023152581060020119881338779571723515253104919314696738194355344\"\n ; \"14994505851254731180804912001382376960436431877822495675906581329931114145032\"\n |]\n ; [| \"18381184948945816702338052755591260342844745389721883995323025098702517473904\"\n ; \"9186573784864449816023279170257163602574499515262252135042448697937263179368\"\n ; \"16881796086836744646703159464114164393240695449455598565494759189917589453976\"\n |]\n ; [| \"20572234397819806324185746612386811237648846766146640064924937718650897781978\"\n ; \"15398960110011455954857390264976694406010423055791889624651258877641756178391\"\n ; \"7626627472565586612974136909394190701438927259101824156422280944508708088979\"\n |]\n ; [| \"5225513048091970342186287982290643286434413678466132108172918521639972895801\"\n ; \"20796219142718322272479527852102350372678035311367637066794738260059405761892\"\n ; \"18867914789735779656943683552060466421616672953566565464125163675462552310225\"\n |]\n ; [| \"1082743678015977585514191190870862236773423558498135453104771878687511906366\"\n ; \"12623224059252254308457589993365174837697684756635908936641223908438823373531\"\n ; \"12555890586414377546838955106772636059664719538696271061728900536297596172906\"\n |]\n ; [| \"15264924047176739600757644598701762120134127746088692861582462406342309222440\"\n ; \"13735945315945382005247895569035266667172550063549145646185577935658666385507\"\n ; \"16846296242516834547231537358954027537902709068158411294345086281698311539718\"\n |]\n ; [| \"5529559903327977764360588597603235134251022845353553657623467329197099735440\"\n ; \"17896661983150937411004047429485556264820315976705642986609974816436222162633\"\n ; \"6132147645856673317909222426799071493032959293586440635818225286067400272621\"\n |]\n ; [| \"19910536448857177568998054979673460274356626268309923630750601690129744044143\"\n ; \"21837022717353361125929262770547893899304355057483567328441690117551675150495\"\n ; \"18222937567706439527101614170488289588444167715669706061945406480673991437911\"\n |]\n ; [| \"1444795096087046870164826172194881116549489406599247123900277072374333222523\"\n ; \"7789285740743619796571024808404378017415878533792118428790588967260363950606\"\n ; \"2733591517253510124338232417535938539627593736745105875672348998709544742241\"\n |]\n ; [| \"10797236245657229835704604790990749002913266164534811352882924972411330424481\"\n ; \"8586865110658270624125510090452038681539626362312203247529227232785490000213\"\n ; \"16990606351055720221300633612533434675038905235719867684891402550154692840579\"\n |]\n ; [| \"13886834869596827027283068322204563244577723967928602405785473534631482228259\"\n ; \"15370041030312982119820349355806306848945675230473045778175606920520020444465\"\n ; \"4892392164144856036080673702415932177491638051096567008590655427718905654995\"\n |]\n ; [| \"7156056361402750618478307158538015778512650133626207855710105646992193371811\"\n ; \"18611994297623980580066352324654520696209128189173454279498506046357017146863\"\n ; \"20685574625754044704454597610042653981655420607405749168756591785339765348017\"\n |]\n ; [| \"19771798755427122057663307238031585225333077748195038834574552418532105026109\"\n ; \"7198246770791404776745997973411401046335399072925979346193035999274650139809\"\n ; \"4023053642231617394331377349850999955271972515156538475518460583299482183537\"\n |]\n ; [| \"8600241056877374090996492763915201371612819917708477598778176717657922462947\"\n ; \"13457797645730052033686724345687857978500724093559828625307818927699840833531\"\n ; \"16026530057488171235747101959040626414628692240827947554707033614704824950299\"\n |]\n ; [| \"17395049232451382970906883167116397657891664802601579276725674512534883408665\"\n ; \"9339859050789350561021790367067195330588925099928812336960590308144433379361\"\n ; \"2949098252117356570135518983407292742860689840833413663842097549831698684366\"\n |]\n ; [| \"20556719902345568138970735755829852608784985449829745172855204153387982836579\"\n ; \"17130405757403641097651484965062131526367059595476924144885570325828777794585\"\n ; \"12098791849907955483840555979771849699037912527654257328360429401569823685788\"\n |]\n ; [| \"17814517977679061356584950826520510701145481336316888282105225134451035883368\"\n ; \"18340263833447961155645725374025776400999561225129160795675360757778486987388\"\n ; \"2393071357700172397099185245759131983536576193657235776526704600015951290441\"\n |]\n ; [| \"4212550607122984812935174903270756328485507924528581618288369631872316849833\"\n ; \"4619648579309903974086199484827129282821840232468518761664883379486001128848\"\n ; \"11830688953328429351984357834116389341476681935757757908813724623462162230171\"\n |]\n ; [| \"9433820477150269924006815701757707228705128802452735931367255389078887381031\"\n ; \"19125188968599512029274834491491595733696896208317777847233033576184416289376\"\n ; \"5918385816682866756860679567405784562483373873565987668410277610868983146285\"\n |]\n ; [| \"11679489428851609457960439894174478045625452323813143057634803520728058419797\"\n ; \"5724733785096476011403606227853139854344547354731648536310363676109859979599\"\n ; \"17573793517331212796808333696068548553394697853729636886331034644281465518715\"\n |]\n ; [| \"282611654311082728776282944765587839903391931876410017096206359579538734085\"\n ; \"742728073451137928865285752406697012428821295824901554854990717103000537584\"\n ; \"20306380368695786945008272690438693745796297843799468268993907772341096948885\"\n |]\n ; [| \"18100113160685180514467703718098463577197975190144073884222766672672318113538\"\n ; \"3596350844916320672068639652188042917240676939829686824217717083735102849099\"\n ; \"20838832950303269747058536033620845977209873531644245727210334971563271393066\"\n |]\n ; [| \"6253957843395630813948692334683334608532810817769598722493240718085139817265\"\n ; \"19309791485130397858271625213458465097936495981008767692231734090527713082114\"\n ; \"5939164146353625472313254161303475736537743070584069770562424769865448756665\"\n |]\n ; [| \"12298194698807155456066733319264594344499679328227389872285371269582859681345\"\n ; \"10410720333027720675907856932360489614426170334449240317306371002856268450593\"\n ; \"13207537521011022812319141236421268356825327806625537047299253455889808792527\"\n |]\n ; [| \"2622643323130765702269424224791233611920515499144047449633123689743564676648\"\n ; \"7934318163093606910388307192320021056510770283350564327826894301919432120323\"\n ; \"7390981975273378581893427566935692330605702531948453130383999822487328794460\"\n |]\n |]\n }\n\nlet params_Mnt4_298 =\n { Params.mds =\n [| [| \"181324588122329172048070802614406344967661900669343676997796156524662650229663511778086513\"\n ; \"263839662794798230944406038483748877420003467481254943330033497627810628977768312588897021\"\n ; \"47787034086054868794736504598805355240746067397315425760363325479582067585554122384528750\"\n |]\n ; [| \"391385728862913577230643656405794210023251219169789744235774373121108965138889307827345939\"\n ; \"368056256556859616791833365938123080683505948787537081082804782658777406001515743364112843\"\n ; \"249229689710372851346889167834108105226843437678081232334602983010385341756350839066179566\"\n |]\n ; [| \"391761630355250451965959916078641131603140945583687294349414005799846378806556028223600720\"\n ; \"309426222273897994989187985039896323914733463925481353595665936771905869408957537639744345\"\n ; \"429282034891350663871556405902853196474768911490694799502975387461169986038745882893853806\"\n |]\n |]\n ; round_constants =\n [| [| \"78119860594733808983474265082430117124674905785489385612351809573030163625517\"\n ; \"41917899842730241418346215913324270532073353586134123463219061327941260175271\"\n ; \"74594641694171623328644944059182600919855574964222988275913344198970402906473\"\n |]\n ; [| \"96215759378377024990520153908983544755208851791126218239402755616994541522004\"\n ; \"64070601581278917442704840630680311036021557676765751754522901046069205253111\"\n ; \"112123228532462696722378911494343451272980413618911326680094528285518792872677\"\n |]\n ; [| \"84572244072021308337360477634782636535511175281144388234379224309078196768262\"\n ; \"45201095631123410354816854701250642083197167601967427301389500806815426216645\"\n ; \"23419302413627434057960523568681421397183896397903197013759822219271473949448\"\n |]\n ; [| \"63220724218126871510891512179599337793645245415246618202146262033908228783613\"\n ; \"67900966560828272306360950341997532094196196655192755442359232962244590070115\"\n ; \"56382132371728071364028077587343004835658613510701494793375685201885283260755\"\n |]\n ; [| \"80317852656339951095312898663286716255545986714650554749917139819628941702909\"\n ; \"110977183257428423540294096816813859894739618561444416996538397449475628658639\"\n ; \"25195781166503180938390820610484311038421647727795615447439501669639084690800\"\n |]\n ; [| \"108664438541952156416331885221418851366456449596370568350972106298760717710264\"\n ; \"17649294376560630922417546944777537620537408190408066211453084495108565929366\"\n ; \"95236435002924956844837407534938226368352771792739587594037613075251645052212\"\n |]\n ; [| \"43150472723422600689013423057826322506171125106415122422656432973040257528684\"\n ; \"77355911134402286174761911573353899889837132781450260391484427670446862700214\"\n ; \"8690728446593494554377477996892461126663797704587025899930929227865493269824\"\n |]\n ; [| \"109175231986025180460846040078523879514558355792739714578031829643740609438879\"\n ; \"64844253590731404811389281562033735091759746904073461140427127388042062490899\"\n ; \"43237071281695629980341250188156848876595681601471702180515324064382368960951\"\n |]\n ; [| \"2704440995725305992776846806711930876273040749514871232837487081811513368296\"\n ; \"66806779110388532101035294912010606217442229808784290357894909707660045365269\"\n ; \"25541187612624070470730890200174075890643652797181103367956318438136878170352\"\n |]\n ; [| \"89300613074831725721350087269266903129165086877175223066581882601662278010666\"\n ; \"36824076981866281177052433916337787028520068526782493484076995129329938182524\"\n ; \"68880449342008497744225106025198236600142055580985632884415488154606462819445\"\n |]\n ; [| \"68556888546596545408135887526582256648006271867854316538090068824142539400698\"\n ; \"111379753250206255125320675615931203940253796355491142745969887430259465111569\"\n ; \"101469186248899356416491489235841069222521093012237305521090058066171355672289\"\n |]\n ; [| \"87819793263125973233157093200229218382531712066157093399606059493857616731410\"\n ; \"11055386921184594780372263378420826851562920740321950336882051897732501262543\"\n ; \"111945832089295501567161822264292548657346358707472584179854375613919325491249\"\n |]\n ; [| \"95630018375719472826904441325138673248990446382783206900295723762884876505178\"\n ; \"94833984285990985873155989049880754188702918168949640563745233736765833491756\"\n ; \"77578854197021606645372788474039811639438242484066959482386065023999206730771\"\n |]\n ; [| \"27799616729223271646690718201487403976485619375555391888533887467404804041014\"\n ; \"42616502170265664498961018686434252976977548128285781725227341660941880774718\"\n ; \"95884094505080541517768389956970969462501217028562326732054532092615835087122\"\n |]\n ; [| \"107531500891040898338150732759493933154418374543568088749403053559827078391994\"\n ; \"17316158269457914256007584527534747738658973027567786054549020564540952112346\"\n ; \"51624680144452294805663893795879183520785046924484587034566439599591446246116\"\n |]\n ; [| \"17698087730709566968258013675219881840614043344609152682517330801348583470562\"\n ; \"111925747861248746962567200879629070277886617811519137515553806421564944666811\"\n ; \"57148554624730554436721083599187229462914514696466218614205595953570212881615\"\n |]\n ; [| \"92002976914130835490768248031171915767210477082066266868807636677032557847243\"\n ; \"58807951133460826577955909810426403194149348045831674376120801431489918282349\"\n ; \"93581873597000319446791963913210464830992618681307774190204379970955657554666\"\n |]\n ; [| \"46734218328816451470118898692627799522173317355773128175090189234250221977353\"\n ; \"12565476532112137808460978474958060441970941349010371267577877299656634907765\"\n ; \"54284813390357004119220859882274190703294683700710665367594256039714984623777\"\n |]\n ; [| \"92046423253202913319296401122133532555630886766139313429473309376931112550800\"\n ; \"15095408309586969968044201398966210357547906905122453139947200130015688526573\"\n ; \"76483858663950700865536712701042004661599554591777656961315837882956812689085\"\n |]\n ; [| \"37793510665854947576525000802927849210746292216845467892500370179796223909690\"\n ; \"84954934523349224038508216623641462700694917568481430996824733443763638196693\"\n ; \"81116649005575743294029244339854405387811058321603450814032274416116019472096\"\n |]\n ; [| \"28313841745366368076212445154871968929195537523489133192784916081223753077949\"\n ; \"17307716513182567320564075539526480893558355908652993731441220999922946005081\"\n ; \"63148771170858502457695904149048034226689843239981287723002468627916462842625\"\n |]\n ; [| \"14724939606645168531546334343600232253284320276481307778787768813885931648950\"\n ; \"4684996260500305121238590806572541849891754312215139285622888510153705963000\"\n ; \"63682763879011752475568476861367553456179860221069473817315669232908763409259\"\n |]\n ; [| \"47776179656187399887062096850541192680190218704758942820514561435612697426715\"\n ; \"42017618175533328439486588850450028995049195954365035474995309904751824054581\"\n ; \"39169739448648613641258102792190571431737464735838931948313779997907435855102\"\n |]\n ; [| \"37525991163523321662699819448962967746703579202577998445997476955224037837979\"\n ; \"67759173441312327668891803222741396828094999063019622301649400178376863820046\"\n ; \"23041132473771739182071223620364590606653086905326129708428084432335332411661\"\n |]\n ; [| \"77778894465896892167598828497939467663479992533052348475467490972714790615441\"\n ; \"20821227542001445006023346122554483849065713580779858784021328359824080462519\"\n ; \"47217242463811495777303984778653549585537750303740616187093690846833142245039\"\n |]\n ; [| \"42826871300142174590405062658305130206548405024021455479047593769907201224399\"\n ; \"8850081254230234130482383430433176873344633494243110112848647064077741649744\"\n ; \"1819639941546179668398979507053724449231350395599747300736218202072168364980\"\n |]\n ; [| \"21219092773772827667886204262476112905428217689703647484316763603169544906986\"\n ; \"35036730416829620763976972888493029852952403098232484869595671405553221294746\"\n ; \"35487050610902505183766069070898136230610758743267437784506875078109148276407\"\n |]\n ; [| \"62560813042054697786535634928462520639989597995560367915904328183428481834648\"\n ; \"112205708104999693686115882430330200785082630634036862526175634736046083007596\"\n ; \"109084747126382177842005646092084591250172358815974554434100716599544229364287\"\n |]\n ; [| \"63740884245554590221521941789197287379354311786803164550686696984009448418872\"\n ; \"58779928727649398559174292364061339806256990859940639552881479945324304668069\"\n ; \"20614241966717622390914334053622572167995367802051836931454426877074875942253\"\n |]\n ; [| \"41621411615229558798583846330993607380846912281220890296433013153854774573504\"\n ; \"20530621481603446397085836296967350209890164029268319619481535419199429275412\"\n ; \"99914592017824500091708233310179001698739309503141229228952777264267035511439\"\n |]\n ; [| \"9497854724940806346676139162466690071592872530638144182764466319052293463165\"\n ; \"7549205476288061047040852944548942878112823732145584918107208536541712726277\"\n ; \"30898915730863004722886730649661235919513859500318540107289237568593577554645\"\n |]\n ; [| \"22697249754607337581727259086359907309326296469394183645633378468855554942575\"\n ; \"72771100592475003378969523202338527077495914171905204927442739996373603143216\"\n ; \"84509851995167666169868678185342549983568150803791023831909660012392522615426\"\n |]\n ; [| \"36601166816771446688370845080961015541431660429079281633209182736773260407536\"\n ; \"19555759172327736128240171000715903945570888389700763573790859521156095228287\"\n ; \"82844424532983875300577689116331373756526403900340445449185486212503235782229\"\n |]\n ; [| \"40833119728631657038301474658571416779079199343770917422783737091842927892625\"\n ; \"68922359316478675184342553333343300163568193749010867527082189412217781430311\"\n ; \"91516472400306837063911995909475588197278444979245081960087094196120449075833\"\n |]\n ; [| \"21304716730402869084944080869903443431235336418077153507261240151959530377653\"\n ; \"106551237424345741137570659736231801772439680702621554106791455938098031620471\"\n ; \"104392597313271110590927764888829150750277653499050463757708547416538850601163\"\n |]\n ; [| \"16907937154215020261110468963982390213438461071031811101554056252102505124726\"\n ; \"23183141532591565112222057191012766855134687114504142337903677590107533245206\"\n ; \"96725517880771645283128624101279195709280644465575982072053504613644938879246\"\n |]\n ; [| \"84556507395241990875812091718422997082915179448604219593521819129312718969906\"\n ; \"100646525819453650494590571397259055384579251368754179569362740802641255820576\"\n ; \"50316555026297423940834952362583934362215303629664094841692233643882339493043\"\n |]\n ; [| \"77363534410783423412630139556441807611393685349073113946053979350631229049878\"\n ; \"54905073434434959485893381841839373267383966385817882684657825178181863944371\"\n ; \"110016011331508430102821620395154714608084938556260733745010992614542669817451\"\n |]\n ; [| \"52040139270046094723964229965823921970388683619580004402190656733318120479093\"\n ; \"495546618036723566920914648951352373868059898268055487677897567226892784967\"\n ; \"2528292188392170914010448139211586215817069915670005292953294092269979070980\"\n |]\n ; [| \"36842840134449713950999812540127591123318806680559982063089906871196226758113\"\n ; \"112314504940338253416202605695368724580971154020421327790335219348068041886245\"\n ; \"51653712314537383078368021242008468828072907802445786549975419682333073143987\"\n |]\n ; [| \"27179054135131403873076215577181710354069071017096145081169516607932870071868\"\n ; \"93264325401956094073193527739715293258814405715822269809955952297346626219055\"\n ; \"75336695567377817226085396912086909560962335091652231383627608374094112503635\"\n |]\n ; [| \"42536477740858058164730818130587261149155820207748153094480456895727052896150\"\n ; \"45297707210835305388426482743535401273114010430724989418303851665124351001731\"\n ; \"28263543670875633354854018109712021307749750769690268127459707194207091046997\"\n |]\n ; [| \"40809484989590048522440442751358616303471639779690405026946053699354967624695\"\n ; \"51589519265418587649124543325590658874910911006853535317847189422703251228717\"\n ; \"73459936981642894525955700397592343967482441686326322443228255968694436816673\"\n |]\n ; [| \"87298777232393189731949522229743081866971743270330772607820990832164835738703\"\n ; \"23328534428894097247289332213412175849711532153957647506361455182140450133738\"\n ; \"51807348624578081645565456865744011145427112815128832643950401419083788780028\"\n |]\n ; [| \"62003629107726929116302469001779155132709624140360743951550189738290955064278\"\n ; \"109311858027068383034683875948676795998030610067675200794951297783857157095297\"\n ; \"2085588517087605436136379278738013214233743532079287631079316773925068862732\"\n |]\n ; [| \"9513664655545306376987968929852776467090105742275395185801917554996684570014\"\n ; \"91103467624252027317764670613760419385374004736848754250298970998535616755199\"\n ; \"39500000352127197728032684892425352332461947514533659433380855624868454474623\"\n |]\n ; [| \"75175260486328125629270378861920310368403601365269629778076078053196928460032\"\n ; \"56923881233337629517433981230592855430598464522180216309153828833928801967999\"\n ; \"20981004218820236011689230170078809973840534961691702543937445515733151438851\"\n |]\n ; [| \"73175203586574092105626230272409823792532423094740797516874387144340145138310\"\n ; \"45186992623753580336479418079070607289916086076906975839720879934817804495460\"\n ; \"96084125187548549854900995260973117424750860440064269432639526863495781270780\"\n |]\n ; [| \"53530507055579550362119832302266967544350117012822630711681736383163390079758\"\n ; \"24484677147631687826970700541691541659768738376645174313438582486313045584324\"\n ; \"99915577684197600584703320523786830947563355229812244982453188909016758004559\"\n |]\n ; [| \"73101441225016284181831039876112223954723401962484828024235461623078642642543\"\n ; \"57434882751817972247799186935032874577110609253567900895922769490031350316077\"\n ; \"73837027842771758252813592393497967898989365991569964687267097531033696791279\"\n |]\n ; [| \"8605586894544301092657394167906502995894014247978769840701086209902531650480\"\n ; \"8900145888985471928279988821934068156350024482295663273746853580585203659117\"\n ; \"76135096553134713603675854628257365311062159747768423095496501607463292188538\"\n |]\n ; [| \"77171330825793179961995032914169307990870372845116475229799680315757656196917\"\n ; \"17848856881287888035559207919717746181941756011012420474955535369227552058196\"\n ; \"85285874363861776466393873037603415962379724376693393356387850868454172343232\"\n |]\n ; [| \"34752820629818556525384193423224856177797869338806846583786365186093662702640\"\n ; \"61923000676912108769617866333091286856690233713839015114991682235541391477568\"\n ; \"105437294734850952102877811210027981435959945375626993201685688489494148805743\"\n |]\n ; [| \"37290995592003925978648162243724313056459187397796644444696543576625771108605\"\n ; \"95156804644588215637074780475000089186488581067063625121782605228712011438608\"\n ; \"111838568780358037910894878973007194619694503969424695895292495245099084158661\"\n |]\n ; [| \"114085830904535970531084512281741806703564152148485737755668141105183488387818\"\n ; \"27151558900245092306095370161852910074651784795680581223133179808714387525774\"\n ; \"17782273009863750298483603933610732253879825505411230932533407287574651036994\"\n |]\n ; [| \"72422039981423868898452547270453235353957783762070405836433674391957844064693\"\n ; \"23635533014670380888810554717349513178608213369182061967678315431422272271569\"\n ; \"59402711345784829746976504521969665104448536964686633342173372133388407225657\"\n |]\n ; [| \"92466806354851856571355165199186633833982438153589406912422876269386887264049\"\n ; \"9877617390649361889067963484857474874019563445507538784053773745685676317984\"\n ; \"74572672075215609948567780829046067891251792522874268554421916351892498078660\"\n |]\n ; [| \"36552683919656073147232029802086505741533932059491323529262718897271096098319\"\n ; \"28895802628889660292449057575076739706255701997961890168977786141673053679086\"\n ; \"9907785227545441866241924986174555965766785257012652276622736289520175209842\"\n |]\n ; [| \"29485332368911768475893015509537099136952860812699472744021496513325455451738\"\n ; \"39797358509842904932758894391536601623578260107859540160156599261695054175926\"\n ; \"107452259847197252302434271220963395311929879689430847107159618578878468880668\"\n |]\n ; [| \"24664696127391052816688570667643612077905959307658722811431436096677076924072\"\n ; \"52507998665481228083044018390203046881916651866666590845312076558622705190465\"\n ; \"69935204723497468327083545368078327534124772251842862926136799697299751835029\"\n |]\n ; [| \"372963191403207230700085823960930798511810380777302780932220121859190714585\"\n ; \"111366606704792806959979488772421759791592911629496627207620326636856656861526\"\n ; \"39677360977437767398760288273614298000827429534821360419179023551087917983124\"\n |]\n ; [| \"64601494076430280535646633059501605929914790764963584476403188233843589027560\"\n ; \"34156315098453482946438495274327282067376463494057110043754782161473776373661\"\n ; \"73687667961196401152630755105477060056162632832680813161120412165243753726816\"\n |]\n ; [| \"37808689229279738382348785246837013002280781984053433359148018860351753688153\"\n ; \"26778210635417272626362658500217995247072424006327715268521424423461840656985\"\n ; \"13012115310019421859484865413402512912208022868124085927375736053832542569552\"\n |]\n ; [| \"33073055720188060063004545324174039863351833928493376423022587630016341635891\"\n ; \"76584254259783109527449313057522305759653397147785066495263227868665161219779\"\n ; \"38531270223194009551634352795926218399266465064491096474482575354468954922673\"\n |]\n ; [| \"90100362566645034035707547984589905559141359276359522681964816611161474672115\"\n ; \"93014643079204629081291124987233004565276697190519877698472422015954982964601\"\n ; \"110916697765188052223435628742886773389228694903593626715469113528434066764534\"\n |]\n ; [| \"114725280711584666069398481856753837363052938587178775403749719257369626174299\"\n ; \"32967950615819700839673854548770413755655613096921050182183649674389310060672\"\n ; \"106372438106855157117155417458821032302424106544646447353561892891697429919509\"\n |]\n ; [| \"41996555998804572671679174634435850382099449308465335760130383677478780889948\"\n ; \"105999190358126224751922865919841547624707481487885223948004296548330504340556\"\n ; \"16636528128134911466622907961467317982179835733058354229921170933476186200761\"\n |]\n ; [| \"43468498537738045222256870515315985487110433728199201952445121047095648527840\"\n ; \"102272887089258604970815589009009162752025146641624347901234381428987386153285\"\n ; \"797386830910520008361185815477523544664694040635544500916993469578452189812\"\n |]\n ; [| \"96744926314199156321023598425708516126928808801578082649702497034531770517808\"\n ; \"99066250188188051206024031106640566584616407903813704153928240609169764005797\"\n ; \"101012485188852469291356197079506861083321680470016268483997462932491691773708\"\n |]\n ; [| \"49614555470963378761214277525336169174318331863453657910575217035316990252780\"\n ; \"94532874466332578813348267802784511494491757628599627802933242637211676358456\"\n ; \"60376163781951477822973950330025689966951914888122503797194554488987660570913\"\n |]\n ; [| \"99934768696780030317676638063039209891456597783633841250810260768328701786300\"\n ; \"71861378641802240356627336242725340978135703736568776865558429280585792121426\"\n ; \"84446994028646761779912629176051455275041688583492300440129402381138226185369\"\n |]\n ; [| \"18317002472599225949038448120242542829985613745531554876060436499109578301758\"\n ; \"23001721954642810524358122249469196372443463625490878969385130364780514025259\"\n ; \"49037245410934285111914043557449391103989331168177809387278571893536129709378\"\n |]\n ; [| \"65792050828386571136875573680568197513273253001530588336285451691348906024460\"\n ; \"12956514709922286639520985225111137950302442378466870763868693820049405409474\"\n ; \"38025781500219940187723501911749158551479941535921061459281014661810772473038\"\n |]\n ; [| \"98610017124283789125637190759729078315864881693957982200427567103302362453196\"\n ; \"42724178943656779288650125468921272883324869492775989038952508393082565227450\"\n ; \"99514360136104778310983460863480701661882652836741972684579325226086664343913\"\n |]\n ; [| \"111234788248236327826382691076985300771418365594838017963216100441270435887017\"\n ; \"35290532009451633157074005614742321966918220860237810056920944192222599040501\"\n ; \"72172784027306769601458922728374293130025170844011739475076742090414769211169\"\n |]\n ; [| \"61384388429666858375759167984149961873566898632022783479711533101905095026411\"\n ; \"8194273390415023152581060020119881338779571723515253104919314696738194355344\"\n ; \"80659234466772556847544129237154202226081525079070598707001193889658539631883\"\n |]\n ; [| \"62157670692624367146830864246105810519941474190553952682719433471854134465138\"\n ; \"74851302400382275482762496406028988868219592716510355166137061257664688666219\"\n ; \"16881796086836744646703159464114164393240695449455598565494759189917589453976\"\n |]\n ; [| \"42460477269659081546432152357644086326197211166562674408623141905226706277595\"\n ; \"81063688725529281621596607500748519671655516257039992655745871437369181665242\"\n ; \"51403113216244137057466948399908740878535656059933892843818689317660325080213\"\n |]\n ; [| \"49001998791770520786679099472805193463531142479298200795569326894791589887035\"\n ; \"42684462014557597494725933597359625461226399711783671410492942446635214257509\"\n ; \"106420886277092880545929306533089566775810130555230702838917980421765786292693\"\n |]\n ; [| \"110523958037212353696746219917157237679515245560578307171595792811566554384451\"\n ; \"56399709802930804752950401483879725014794413557467977624037632281590440364765\"\n ; \"100108862073771478435824578087801736413858177140360408436521717282600830155374\"\n |]\n ; [| \"59041409790855290045250456089216312297230856546920761548978870779493926213674\"\n ; \"13735945315945382005247895569035266667172550063549145646185577935658666385507\"\n ; \"16846296242516834547231537358954027537902709068158411294345086281698311539718\"\n |]\n ; [| \"114970774262524353875592617323889610576992844847433725376114488262076142213525\"\n ; \"17896661983150937411004047429485556264820315976705642986609974816436222162633\"\n ; \"115573362005053049429141251153085446935774781295666612354309246218946442750706\"\n |]\n ; [| \"85575265064375003235737272215445285540001719469558026661845214249857169530994\"\n ; \"87501751332871186792668480006319719164949448258731670359536302677279100637346\"\n ; \"105775909055063540416087237151517389942637625317333843436738223226977225420379\"\n |]\n ; [| \"110886009455283422981396854898481256559291311408679418842391298005253375700608\"\n ; \"95342257228100720685556647789433478371609336135456255803583405713563597933074\"\n ; \"2733591517253510124338232417535938539627593736745105875672348998709544742241\"\n |]\n ; [| \"32685479117496505057951010536248024091461630564950845696581129158987138920098\"\n ; \"96139836598015371513111133071481139035733083963976340622322043979088723982681\"\n ; \"16990606351055720221300633612533434675038905235719867684891402550154692840579\"\n |]\n ; [| \"13886834869596827027283068322204563244577723967928602405785473534631482228259\"\n ; \"81034769645830807786559566591578132114590768431721148809270219480247445931316\"\n ; \"26780635035984131258327079447673207266040002451512601352288859614294714150612\"\n |]\n ; [| \"72820784976920576285217524394309841044157743334874310886804718206719618858662\"\n ; \"84276722913141806246805569560426345961854221390421557310593118606084442633714\"\n ; \"42573817497593319926701003355299929070203785007821783512454795971915573843634\"\n |]\n ; [| \"41660041627266397279909712983288860313881442148611073178272756605107913521726\"\n ; \"7198246770791404776745997973411401046335399072925979346193035999274650139809\"\n ; \"91576025129588718283317000330880100309465430116820675850311277329602716166005\"\n |]\n ; [| \"30488483928716649313242898509172476460161184318124511942476380904233730958564\"\n ; \"35346040517569327255933130090945133067049088493975862969006023114275649329148\"\n ; \"59803015801166721680239913449555176591725421041660016242103441987856441941533\"\n |]\n ; [| \"17395049232451382970906883167116397657891664802601579276725674512534883408665\"\n ; \"96892830538146451450007413348096295684782382701592949711753407054447667361829\"\n ; \"46725583995795907014628330473921842919957418641665482351238505922983315675600\"\n |]\n ; [| \"20556719902345568138970735755829852608784985449829745172855204153387982836579\"\n ; \"17130405757403641097651484965062131526367059595476924144885570325828777794585\"\n ; \"99651763337265056372826178960800950053231370129318394703153246147873057668256\"\n |]\n ; [| \"17814517977679061356584950826520510701145481336316888282105225134451035883368\"\n ; \"62116749577126511600138536864540326578096290025961229483071769130930103978622\"\n ; \"68057799973217998063838402481530957249181669394905338807621317159743376777292\"\n |]\n ; [| \"26100793478962260035181580648528031417033872324944615961986573818448125345450\"\n ; \"26507891451149179196332605230084404371370204632884553105363087566061809624465\"\n ; \"55607174697006979796477169324630939518573410736589826596210132996613779221405\"\n |]\n ; [| \"75098549092668095590746032937529532494350222003700838962461867948806312867882\"\n ; \"62901674712278062473767645982006145910793625009149846534629441949336033280610\"\n ; \"5918385816682866756860679567405784562483373873565987668410277610868983146285\"\n |]\n ; [| \"99232460916208710346946062875203578399818909925477280432427620267031292402265\"\n ; \"115165948144292852122635634954139515297086369356811820254801384608988902457684\"\n ; \"39462036389170488019054739441325823641943062254145671230029238830857274014332\"\n |]\n ; [| \"109723826013507458840008311671051963282645213933956581735587227292458581212170\"\n ; \"88295699560808238817850908733435797366622278897489038929647807463406234520052\"\n ; \"20306380368695786945008272690438693745796297843799468268993907772341096948885\"\n |]\n ; [| \"39988356032524455736714109463355738665746339590560108227920970859248126609155\"\n ; \"47372836588594871116561451142702593094337405740661755511614125456886719840333\"\n ; \"42727075822142544969304941778878121065758237932060280070908539158139079888683\"\n |]\n ; [| \"115695172202592006925180721060969710051274632819849770440984261650964182295350\"\n ; \"41198034356969673080518030958715740186484860381424802035929938277103521577731\"\n ; \"115380378505550001583545282887589851179279565072664241489053445702744491234750\"\n |]\n ; [| \"56074680442485705900559544809779144521596408129059458559681779642734476672579\"\n ; \"54187206076706271120400668422875039791522899135281309004702779376007885441827\"\n ; \"100760509008368123701304764217450368711018785408289674422092070202193042774995\"\n |]\n ; [| \"2622643323130765702269424224791233611920515499144047449633123689743564676648\"\n ; \"95487289650450707799373930173349121410704227885014701702619711048222666102791\"\n ; \"94943953462630479470879050547964792684799160133612590505176816568790562776928\"\n |]\n |]\n }\n\nlet params_Mnt4_753 =\n { Params.mds =\n [| [| \"18008368437737423474309001369890301521976028259557869102888851965525650962978826556079921598599098888590302388431866694591858505845787597588918688371226882207991627422083815074127761663891796146172734531991290402968541914191945\"\n ; \"32962087054539410523956712909309686802653898657605569239066684150412875533806729129396719808139132458477579312916467576544007112173179883702872518317566248974424872120316787037296877442303550788674087649228607529914336317231815\"\n ; \"5483644920564955035638567475101171013329909513705951195576914157062781400017095978578204379959018576768230785151221956162299596069033091214145892295417145700700562355150808732841416210677611704678816316579070697592848376918151\"\n |]\n ; [| \"22978648816866328436434244623482365207916416489037627250857600725663194263360344221738155318310265722276036466391561221273100146793047089336717612168000266025808046352571957200240941276891050003938106626328014785436301089444973\"\n ; \"30994637628885441247541289546067547358628828834593234742882770745561956454298316691254641971835514862825457645395555821312465912408960063865618013131940007283956832467402859348036195396599351702172170219903104023278420827940135\"\n ; \"7096546890972108774287040498267941446510912236116268882520023333699636048386130304511472040490894498194252489942856762189629237475878134498814298584446894911200379613916180563419809701971057277837757006070684068787238347669992\"\n |]\n ; [| \"36972350749469737754741804679554799140755989986720531577443294433161553396641362942311484418395414339763390349161399190591697773588979458652577643792428305947365748981633559835484411429153283032734484874265223184021528054671667\"\n ; \"41737243523985324129413602960234190443256387558212939183466624464606481865667576817406507424236723364751044981130064473555650490691461017936143464747647507236853158008794221676669840197156981325463879378696484711828785706949884\"\n ; \"17173689835840458026597473076649786448044751322360472626284380020090825232350642484368920024327948574743378803111953285570783101340571478325610471380479472689631139762331626281838772360396878623880994496993923849428256427219637\"\n |]\n |]\n ; round_constants =\n [| [| \"78119860594733808983474265082430117124674905785489385612351809573030163625517\"\n ; \"41917899842730241418346215913324270532073353586134123463219061327941260175271\"\n ; \"74594641694171623328644944059182600919855574964222988275913344198970402906473\"\n |]\n ; [| \"96215759378377024990520153908983544755208851791126218239402755616994541522004\"\n ; \"64070601581278917442704840630680311036021557676765751754522901046069205253111\"\n ; \"112123228532462696722378911494343451272980413618911326680094528285518792872677\"\n |]\n ; [| \"84572244072021308337360477634782636535511175281144388234379224309078196768262\"\n ; \"45201095631123410354816854701250642083197167601967427301389500806815426216645\"\n ; \"23419302413627434057960523568681421397183896397903197013759822219271473949448\"\n |]\n ; [| \"63220724218126871510891512179599337793645245415246618202146262033908228783613\"\n ; \"67900966560828272306360950341997532094196196655192755442359232962244590070115\"\n ; \"56382132371728071364028077587343004835658613510701494793375685201885283260755\"\n |]\n ; [| \"80317852656339951095312898663286716255545986714650554749917139819628941702909\"\n ; \"110977183257428423540294096816813859894739618561444416996538397449475628658639\"\n ; \"25195781166503180938390820610484311038421647727795615447439501669639084690800\"\n |]\n ; [| \"108664438541952156416331885221418851366456449596370568350972106298760717710264\"\n ; \"17649294376560630922417546944777537620537408190408066211453084495108565929366\"\n ; \"95236435002924956844837407534938226368352771792739587594037613075251645052212\"\n |]\n ; [| \"43150472723422600689013423057826322506171125106415122422656432973040257528684\"\n ; \"77355911134402286174761911573353899889837132781450260391484427670446862700214\"\n ; \"8690728446593494554377477996892461126663797704587025899930929227865493269824\"\n |]\n ; [| \"109175231986025180460846040078523879514558355792739714578031829643740609438879\"\n ; \"64844253590731404811389281562033735091759746904073461140427127388042062490899\"\n ; \"43237071281695629980341250188156848876595681601471702180515324064382368960951\"\n |]\n ; [| \"2704440995725305992776846806711930876273040749514871232837487081811513368296\"\n ; \"66806779110388532101035294912010606217442229808784290357894909707660045365269\"\n ; \"25541187612624070470730890200174075890643652797181103367956318438136878170352\"\n |]\n ; [| \"89300613074831725721350087269266903129165086877175223066581882601662278010666\"\n ; \"36824076981866281177052433916337787028520068526782493484076995129329938182524\"\n ; \"68880449342008497744225106025198236600142055580985632884415488154606462819445\"\n |]\n ; [| \"68556888546596545408135887526582256648006271867854316538090068824142539400698\"\n ; \"111379753250206255125320675615931203940253796355491142745969887430259465111569\"\n ; \"101469186248899356416491489235841069222521093012237305521090058066171355672289\"\n |]\n ; [| \"87819793263125973233157093200229218382531712066157093399606059493857616731410\"\n ; \"11055386921184594780372263378420826851562920740321950336882051897732501262543\"\n ; \"111945832089295501567161822264292548657346358707472584179854375613919325491249\"\n |]\n ; [| \"95630018375719472826904441325138673248990446382783206900295723762884876505178\"\n ; \"94833984285990985873155989049880754188702918168949640563745233736765833491756\"\n ; \"77578854197021606645372788474039811639438242484066959482386065023999206730771\"\n |]\n ; [| \"27799616729223271646690718201487403976485619375555391888533887467404804041014\"\n ; \"42616502170265664498961018686434252976977548128285781725227341660941880774718\"\n ; \"95884094505080541517768389956970969462501217028562326732054532092615835087122\"\n |]\n ; [| \"107531500891040898338150732759493933154418374543568088749403053559827078391994\"\n ; \"17316158269457914256007584527534747738658973027567786054549020564540952112346\"\n ; \"51624680144452294805663893795879183520785046924484587034566439599591446246116\"\n |]\n ; [| \"17698087730709566968258013675219881840614043344609152682517330801348583470562\"\n ; \"111925747861248746962567200879629070277886617811519137515553806421564944666811\"\n ; \"57148554624730554436721083599187229462914514696466218614205595953570212881615\"\n |]\n ; [| \"92002976914130835490768248031171915767210477082066266868807636677032557847243\"\n ; \"58807951133460826577955909810426403194149348045831674376120801431489918282349\"\n ; \"93581873597000319446791963913210464830992618681307774190204379970955657554666\"\n |]\n ; [| \"46734218328816451470118898692627799522173317355773128175090189234250221977353\"\n ; \"12565476532112137808460978474958060441970941349010371267577877299656634907765\"\n ; \"54284813390357004119220859882274190703294683700710665367594256039714984623777\"\n |]\n ; [| \"92046423253202913319296401122133532555630886766139313429473309376931112550800\"\n ; \"15095408309586969968044201398966210357547906905122453139947200130015688526573\"\n ; \"76483858663950700865536712701042004661599554591777656961315837882956812689085\"\n |]\n ; [| \"37793510665854947576525000802927849210746292216845467892500370179796223909690\"\n ; \"84954934523349224038508216623641462700694917568481430996824733443763638196693\"\n ; \"81116649005575743294029244339854405387811058321603450814032274416116019472096\"\n |]\n ; [| \"28313841745366368076212445154871968929195537523489133192784916081223753077949\"\n ; \"17307716513182567320564075539526480893558355908652993731441220999922946005081\"\n ; \"63148771170858502457695904149048034226689843239981287723002468627916462842625\"\n |]\n ; [| \"14724939606645168531546334343600232253284320276481307778787768813885931648950\"\n ; \"4684996260500305121238590806572541849891754312215139285622888510153705963000\"\n ; \"63682763879011752475568476861367553456179860221069473817315669232908763409259\"\n |]\n ; [| \"47776179656187399887062096850541192680190218704758942820514561435612697426715\"\n ; \"42017618175533328439486588850450028995049195954365035474995309904751824054581\"\n ; \"39169739448648613641258102792190571431737464735838931948313779997907435855102\"\n |]\n ; [| \"37525991163523321662699819448962967746703579202577998445997476955224037837979\"\n ; \"67759173441312327668891803222741396828094999063019622301649400178376863820046\"\n ; \"23041132473771739182071223620364590606653086905326129708428084432335332411661\"\n |]\n ; [| \"77778894465896892167598828497939467663479992533052348475467490972714790615441\"\n ; \"20821227542001445006023346122554483849065713580779858784021328359824080462519\"\n ; \"47217242463811495777303984778653549585537750303740616187093690846833142245039\"\n |]\n ; [| \"42826871300142174590405062658305130206548405024021455479047593769907201224399\"\n ; \"8850081254230234130482383430433176873344633494243110112848647064077741649744\"\n ; \"1819639941546179668398979507053724449231350395599747300736218202072168364980\"\n |]\n ; [| \"21219092773772827667886204262476112905428217689703647484316763603169544906986\"\n ; \"35036730416829620763976972888493029852952403098232484869595671405553221294746\"\n ; \"35487050610902505183766069070898136230610758743267437784506875078109148276407\"\n |]\n ; [| \"62560813042054697786535634928462520639989597995560367915904328183428481834648\"\n ; \"112205708104999693686115882430330200785082630634036862526175634736046083007596\"\n ; \"109084747126382177842005646092084591250172358815974554434100716599544229364287\"\n |]\n ; [| \"63740884245554590221521941789197287379354311786803164550686696984009448418872\"\n ; \"58779928727649398559174292364061339806256990859940639552881479945324304668069\"\n ; \"20614241966717622390914334053622572167995367802051836931454426877074875942253\"\n |]\n ; [| \"41621411615229558798583846330993607380846912281220890296433013153854774573504\"\n ; \"20530621481603446397085836296967350209890164029268319619481535419199429275412\"\n ; \"99914592017824500091708233310179001698739309503141229228952777264267035511439\"\n |]\n ; [| \"9497854724940806346676139162466690071592872530638144182764466319052293463165\"\n ; \"7549205476288061047040852944548942878112823732145584918107208536541712726277\"\n ; \"30898915730863004722886730649661235919513859500318540107289237568593577554645\"\n |]\n ; [| \"22697249754607337581727259086359907309326296469394183645633378468855554942575\"\n ; \"72771100592475003378969523202338527077495914171905204927442739996373603143216\"\n ; \"84509851995167666169868678185342549983568150803791023831909660012392522615426\"\n |]\n ; [| \"36601166816771446688370845080961015541431660429079281633209182736773260407536\"\n ; \"19555759172327736128240171000715903945570888389700763573790859521156095228287\"\n ; \"82844424532983875300577689116331373756526403900340445449185486212503235782229\"\n |]\n ; [| \"40833119728631657038301474658571416779079199343770917422783737091842927892625\"\n ; \"68922359316478675184342553333343300163568193749010867527082189412217781430311\"\n ; \"91516472400306837063911995909475588197278444979245081960087094196120449075833\"\n |]\n ; [| \"21304716730402869084944080869903443431235336418077153507261240151959530377653\"\n ; \"106551237424345741137570659736231801772439680702621554106791455938098031620471\"\n ; \"104392597313271110590927764888829150750277653499050463757708547416538850601163\"\n |]\n ; [| \"16907937154215020261110468963982390213438461071031811101554056252102505124726\"\n ; \"23183141532591565112222057191012766855134687114504142337903677590107533245206\"\n ; \"96725517880771645283128624101279195709280644465575982072053504613644938879246\"\n |]\n ; [| \"84556507395241990875812091718422997082915179448604219593521819129312718969906\"\n ; \"100646525819453650494590571397259055384579251368754179569362740802641255820576\"\n ; \"50316555026297423940834952362583934362215303629664094841692233643882339493043\"\n |]\n ; [| \"77363534410783423412630139556441807611393685349073113946053979350631229049878\"\n ; \"54905073434434959485893381841839373267383966385817882684657825178181863944371\"\n ; \"110016011331508430102821620395154714608084938556260733745010992614542669817451\"\n |]\n ; [| \"52040139270046094723964229965823921970388683619580004402190656733318120479093\"\n ; \"495546618036723566920914648951352373868059898268055487677897567226892784967\"\n ; \"2528292188392170914010448139211586215817069915670005292953294092269979070980\"\n |]\n ; [| \"36842840134449713950999812540127591123318806680559982063089906871196226758113\"\n ; \"112314504940338253416202605695368724580971154020421327790335219348068041886245\"\n ; \"51653712314537383078368021242008468828072907802445786549975419682333073143987\"\n |]\n ; [| \"27179054135131403873076215577181710354069071017096145081169516607932870071868\"\n ; \"93264325401956094073193527739715293258814405715822269809955952297346626219055\"\n ; \"75336695567377817226085396912086909560962335091652231383627608374094112503635\"\n |]\n ; [| \"42536477740858058164730818130587261149155820207748153094480456895727052896150\"\n ; \"45297707210835305388426482743535401273114010430724989418303851665124351001731\"\n ; \"28263543670875633354854018109712021307749750769690268127459707194207091046997\"\n |]\n ; [| \"40809484989590048522440442751358616303471639779690405026946053699354967624695\"\n ; \"51589519265418587649124543325590658874910911006853535317847189422703251228717\"\n ; \"73459936981642894525955700397592343967482441686326322443228255968694436816673\"\n |]\n ; [| \"87298777232393189731949522229743081866971743270330772607820990832164835738703\"\n ; \"23328534428894097247289332213412175849711532153957647506361455182140450133738\"\n ; \"51807348624578081645565456865744011145427112815128832643950401419083788780028\"\n |]\n ; [| \"62003629107726929116302469001779155132709624140360743951550189738290955064278\"\n ; \"109311858027068383034683875948676795998030610067675200794951297783857157095297\"\n ; \"2085588517087605436136379278738013214233743532079287631079316773925068862732\"\n |]\n ; [| \"9513664655545306376987968929852776467090105742275395185801917554996684570014\"\n ; \"91103467624252027317764670613760419385374004736848754250298970998535616755199\"\n ; \"39500000352127197728032684892425352332461947514533659433380855624868454474623\"\n |]\n ; [| \"75175260486328125629270378861920310368403601365269629778076078053196928460032\"\n ; \"56923881233337629517433981230592855430598464522180216309153828833928801967999\"\n ; \"20981004218820236011689230170078809973840534961691702543937445515733151438851\"\n |]\n ; [| \"73175203586574092105626230272409823792532423094740797516874387144340145138310\"\n ; \"45186992623753580336479418079070607289916086076906975839720879934817804495460\"\n ; \"96084125187548549854900995260973117424750860440064269432639526863495781270780\"\n |]\n ; [| \"53530507055579550362119832302266967544350117012822630711681736383163390079758\"\n ; \"24484677147631687826970700541691541659768738376645174313438582486313045584324\"\n ; \"99915577684197600584703320523786830947563355229812244982453188909016758004559\"\n |]\n ; [| \"73101441225016284181831039876112223954723401962484828024235461623078642642543\"\n ; \"57434882751817972247799186935032874577110609253567900895922769490031350316077\"\n ; \"73837027842771758252813592393497967898989365991569964687267097531033696791279\"\n |]\n ; [| \"8605586894544301092657394167906502995894014247978769840701086209902531650480\"\n ; \"8900145888985471928279988821934068156350024482295663273746853580585203659117\"\n ; \"76135096553134713603675854628257365311062159747768423095496501607463292188538\"\n |]\n ; [| \"77171330825793179961995032914169307990870372845116475229799680315757656196917\"\n ; \"17848856881287888035559207919717746181941756011012420474955535369227552058196\"\n ; \"85285874363861776466393873037603415962379724376693393356387850868454172343232\"\n |]\n ; [| \"34752820629818556525384193423224856177797869338806846583786365186093662702640\"\n ; \"61923000676912108769617866333091286856690233713839015114991682235541391477568\"\n ; \"105437294734850952102877811210027981435959945375626993201685688489494148805743\"\n |]\n ; [| \"37290995592003925978648162243724313056459187397796644444696543576625771108605\"\n ; \"95156804644588215637074780475000089186488581067063625121782605228712011438608\"\n ; \"111838568780358037910894878973007194619694503969424695895292495245099084158661\"\n |]\n ; [| \"114085830904535970531084512281741806703564152148485737755668141105183488387818\"\n ; \"27151558900245092306095370161852910074651784795680581223133179808714387525774\"\n ; \"17782273009863750298483603933610732253879825505411230932533407287574651036994\"\n |]\n ; [| \"72422039981423868898452547270453235353957783762070405836433674391957844064693\"\n ; \"23635533014670380888810554717349513178608213369182061967678315431422272271569\"\n ; \"59402711345784829746976504521969665104448536964686633342173372133388407225657\"\n |]\n ; [| \"92466806354851856571355165199186633833982438153589406912422876269386887264049\"\n ; \"9877617390649361889067963484857474874019563445507538784053773745685676317984\"\n ; \"74572672075215609948567780829046067891251792522874268554421916351892498078660\"\n |]\n ; [| \"36552683919656073147232029802086505741533932059491323529262718897271096098319\"\n ; \"28895802628889660292449057575076739706255701997961890168977786141673053679086\"\n ; \"9907785227545441866241924986174555965766785257012652276622736289520175209842\"\n |]\n ; [| \"29485332368911768475893015509537099136952860812699472744021496513325455451738\"\n ; \"39797358509842904932758894391536601623578260107859540160156599261695054175926\"\n ; \"107452259847197252302434271220963395311929879689430847107159618578878468880668\"\n |]\n ; [| \"24664696127391052816688570667643612077905959307658722811431436096677076924072\"\n ; \"52507998665481228083044018390203046881916651866666590845312076558622705190465\"\n ; \"69935204723497468327083545368078327534124772251842862926136799697299751835029\"\n |]\n ; [| \"372963191403207230700085823960930798511810380777302780932220121859190714585\"\n ; \"111366606704792806959979488772421759791592911629496627207620326636856656861526\"\n ; \"39677360977437767398760288273614298000827429534821360419179023551087917983124\"\n |]\n ; [| \"64601494076430280535646633059501605929914790764963584476403188233843589027560\"\n ; \"34156315098453482946438495274327282067376463494057110043754782161473776373661\"\n ; \"73687667961196401152630755105477060056162632832680813161120412165243753726816\"\n |]\n ; [| \"37808689229279738382348785246837013002280781984053433359148018860351753688153\"\n ; \"26778210635417272626362658500217995247072424006327715268521424423461840656985\"\n ; \"13012115310019421859484865413402512912208022868124085927375736053832542569552\"\n |]\n ; [| \"33073055720188060063004545324174039863351833928493376423022587630016341635891\"\n ; \"76584254259783109527449313057522305759653397147785066495263227868665161219779\"\n ; \"38531270223194009551634352795926218399266465064491096474482575354468954922673\"\n |]\n ; [| \"90100362566645034035707547984589905559141359276359522681964816611161474672115\"\n ; \"93014643079204629081291124987233004565276697190519877698472422015954982964601\"\n ; \"110916697765188052223435628742886773389228694903593626715469113528434066764534\"\n |]\n ; [| \"114725280711584666069398481856753837363052938587178775403749719257369626174299\"\n ; \"32967950615819700839673854548770413755655613096921050182183649674389310060672\"\n ; \"106372438106855157117155417458821032302424106544646447353561892891697429919509\"\n |]\n ; [| \"41996555998804572671679174634435850382099449308465335760130383677478780889948\"\n ; \"105999190358126224751922865919841547624707481487885223948004296548330504340556\"\n ; \"16636528128134911466622907961467317982179835733058354229921170933476186200761\"\n |]\n ; [| \"43468498537738045222256870515315985487110433728199201952445121047095648527840\"\n ; \"102272887089258604970815589009009162752025146641624347901234381428987386153285\"\n ; \"797386830910520008361185815477523544664694040635544500916993469578452189812\"\n |]\n ; [| \"96744926314199156321023598425708516126928808801578082649702497034531770517808\"\n ; \"99066250188188051206024031106640566584616407903813704153928240609169764005797\"\n ; \"101012485188852469291356197079506861083321680470016268483997462932491691773708\"\n |]\n ; [| \"49614555470963378761214277525336169174318331863453657910575217035316990252780\"\n ; \"94532874466332578813348267802784511494491757628599627802933242637211676358456\"\n ; \"60376163781951477822973950330025689966951914888122503797194554488987660570913\"\n |]\n ; [| \"99934768696780030317676638063039209891456597783633841250810260768328701786300\"\n ; \"71861378641802240356627336242725340978135703736568776865558429280585792121426\"\n ; \"84446994028646761779912629176051455275041688583492300440129402381138226185369\"\n |]\n ; [| \"18317002472599225949038448120242542829985613745531554876060436499109578301758\"\n ; \"23001721954642810524358122249469196372443463625490878969385130364780514025259\"\n ; \"49037245410934285111914043557449391103989331168177809387278571893536129709378\"\n |]\n ; [| \"65792050828386571136875573680568197513273253001530588336285451691348906024460\"\n ; \"12956514709922286639520985225111137950302442378466870763868693820049405409474\"\n ; \"38025781500219940187723501911749158551479941535921061459281014661810772473038\"\n |]\n ; [| \"98610017124283789125637190759729078315864881693957982200427567103302362453196\"\n ; \"42724178943656779288650125468921272883324869492775989038952508393082565227450\"\n ; \"99514360136104778310983460863480701661882652836741972684579325226086664343913\"\n |]\n ; [| \"111234788248236327826382691076985300771418365594838017963216100441270435887017\"\n ; \"35290532009451633157074005614742321966918220860237810056920944192222599040501\"\n ; \"72172784027306769601458922728374293130025170844011739475076742090414769211169\"\n |]\n ; [| \"61384388429666858375759167984149961873566898632022783479711533101905095026411\"\n ; \"8194273390415023152581060020119881338779571723515253104919314696738194355344\"\n ; \"80659234466772556847544129237154202226081525079070598707001193889658539631883\"\n |]\n ; [| \"62157670692624367146830864246105810519941474190553952682719433471854134465138\"\n ; \"74851302400382275482762496406028988868219592716510355166137061257664688666219\"\n ; \"16881796086836744646703159464114164393240695449455598565494759189917589453976\"\n |]\n ; [| \"42460477269659081546432152357644086326197211166562674408623141905226706277595\"\n ; \"81063688725529281621596607500748519671655516257039992655745871437369181665242\"\n ; \"51403113216244137057466948399908740878535656059933892843818689317660325080213\"\n |]\n ; [| \"49001998791770520786679099472805193463531142479298200795569326894791589887035\"\n ; \"42684462014557597494725933597359625461226399711783671410492942446635214257509\"\n ; \"106420886277092880545929306533089566775810130555230702838917980421765786292693\"\n |]\n ; [| \"110523958037212353696746219917157237679515245560578307171595792811566554384451\"\n ; \"56399709802930804752950401483879725014794413557467977624037632281590440364765\"\n ; \"100108862073771478435824578087801736413858177140360408436521717282600830155374\"\n |]\n ; [| \"59041409790855290045250456089216312297230856546920761548978870779493926213674\"\n ; \"13735945315945382005247895569035266667172550063549145646185577935658666385507\"\n ; \"16846296242516834547231537358954027537902709068158411294345086281698311539718\"\n |]\n ; [| \"114970774262524353875592617323889610576992844847433725376114488262076142213525\"\n ; \"17896661983150937411004047429485556264820315976705642986609974816436222162633\"\n ; \"115573362005053049429141251153085446935774781295666612354309246218946442750706\"\n |]\n ; [| \"85575265064375003235737272215445285540001719469558026661845214249857169530994\"\n ; \"87501751332871186792668480006319719164949448258731670359536302677279100637346\"\n ; \"105775909055063540416087237151517389942637625317333843436738223226977225420379\"\n |]\n ; [| \"110886009455283422981396854898481256559291311408679418842391298005253375700608\"\n ; \"95342257228100720685556647789433478371609336135456255803583405713563597933074\"\n ; \"2733591517253510124338232417535938539627593736745105875672348998709544742241\"\n |]\n ; [| \"32685479117496505057951010536248024091461630564950845696581129158987138920098\"\n ; \"96139836598015371513111133071481139035733083963976340622322043979088723982681\"\n ; \"16990606351055720221300633612533434675038905235719867684891402550154692840579\"\n |]\n ; [| \"13886834869596827027283068322204563244577723967928602405785473534631482228259\"\n ; \"81034769645830807786559566591578132114590768431721148809270219480247445931316\"\n ; \"26780635035984131258327079447673207266040002451512601352288859614294714150612\"\n |]\n ; [| \"72820784976920576285217524394309841044157743334874310886804718206719618858662\"\n ; \"84276722913141806246805569560426345961854221390421557310593118606084442633714\"\n ; \"42573817497593319926701003355299929070203785007821783512454795971915573843634\"\n |]\n ; [| \"41660041627266397279909712983288860313881442148611073178272756605107913521726\"\n ; \"7198246770791404776745997973411401046335399072925979346193035999274650139809\"\n ; \"91576025129588718283317000330880100309465430116820675850311277329602716166005\"\n |]\n ; [| \"30488483928716649313242898509172476460161184318124511942476380904233730958564\"\n ; \"35346040517569327255933130090945133067049088493975862969006023114275649329148\"\n ; \"59803015801166721680239913449555176591725421041660016242103441987856441941533\"\n |]\n ; [| \"17395049232451382970906883167116397657891664802601579276725674512534883408665\"\n ; \"96892830538146451450007413348096295684782382701592949711753407054447667361829\"\n ; \"46725583995795907014628330473921842919957418641665482351238505922983315675600\"\n |]\n ; [| \"20556719902345568138970735755829852608784985449829745172855204153387982836579\"\n ; \"17130405757403641097651484965062131526367059595476924144885570325828777794585\"\n ; \"99651763337265056372826178960800950053231370129318394703153246147873057668256\"\n |]\n ; [| \"17814517977679061356584950826520510701145481336316888282105225134451035883368\"\n ; \"62116749577126511600138536864540326578096290025961229483071769130930103978622\"\n ; \"68057799973217998063838402481530957249181669394905338807621317159743376777292\"\n |]\n ; [| \"26100793478962260035181580648528031417033872324944615961986573818448125345450\"\n ; \"26507891451149179196332605230084404371370204632884553105363087566061809624465\"\n ; \"55607174697006979796477169324630939518573410736589826596210132996613779221405\"\n |]\n ; [| \"75098549092668095590746032937529532494350222003700838962461867948806312867882\"\n ; \"62901674712278062473767645982006145910793625009149846534629441949336033280610\"\n ; \"5918385816682866756860679567405784562483373873565987668410277610868983146285\"\n |]\n ; [| \"99232460916208710346946062875203578399818909925477280432427620267031292402265\"\n ; \"115165948144292852122635634954139515297086369356811820254801384608988902457684\"\n ; \"39462036389170488019054739441325823641943062254145671230029238830857274014332\"\n |]\n ; [| \"109723826013507458840008311671051963282645213933956581735587227292458581212170\"\n ; \"88295699560808238817850908733435797366622278897489038929647807463406234520052\"\n ; \"20306380368695786945008272690438693745796297843799468268993907772341096948885\"\n |]\n ; [| \"39988356032524455736714109463355738665746339590560108227920970859248126609155\"\n ; \"47372836588594871116561451142702593094337405740661755511614125456886719840333\"\n ; \"42727075822142544969304941778878121065758237932060280070908539158139079888683\"\n |]\n ; [| \"115695172202592006925180721060969710051274632819849770440984261650964182295350\"\n ; \"41198034356969673080518030958715740186484860381424802035929938277103521577731\"\n ; \"115380378505550001583545282887589851179279565072664241489053445702744491234750\"\n |]\n ; [| \"56074680442485705900559544809779144521596408129059458559681779642734476672579\"\n ; \"54187206076706271120400668422875039791522899135281309004702779376007885441827\"\n ; \"100760509008368123701304764217450368711018785408289674422092070202193042774995\"\n |]\n ; [| \"2622643323130765702269424224791233611920515499144047449633123689743564676648\"\n ; \"95487289650450707799373930173349121410704227885014701702619711048222666102791\"\n ; \"94943953462630479470879050547964792684799160133612590505176816568790562776928\"\n |]\n |]\n }\n\nlet params_Bn382_p =\n { Params.mds =\n [| [| \"4926718831512540855203478495979679874185641835428705237807701341316303469093728860979847281433445543762468419547411\"\n ; \"4453596550915421838691584449484083455887331059810907256950733279540412430443020452528503585415545381600691692720802\"\n ; \"1809585458879543727351605930307281128231661313471183867681242998028598391382436278589655704222701087043779610899776\"\n |]\n ; [| \"3780881913608981191949291171826187563049531728010823449829977324390598960444713739971716972221840264885560113043153\"\n ; \"2776232227357305515637478180339794495756715372405744816056109665788926102619439001152349187314657683550310562099867\"\n ; \"5103043266714397927073209822516498302262227174566336138856687248083295588845596823903140201767618523431001452833199\"\n |]\n ; [| \"2159355678817062797712812554732125404698639502388517586006300841333631216487588790808135492514630783259920881851018\"\n ; \"3193464442349738376799117666463048091278737759406985595335727474699041234966227606028409475413066859111860974240541\"\n ; \"3068849848776138129466484826306219095394321880438971409892892215677003762666783452446184790715435684915272918256552\"\n |]\n |]\n ; round_constants =\n [| [| \"78119860594733808983474265082430117124674905785489385612351809573030163625517\"\n ; \"41917899842730241418346215913324270532073353586134123463219061327941260175271\"\n ; \"74594641694171623328644944059182600919855574964222988275913344198970402906473\"\n |]\n ; [| \"96215759378377024990520153908983544755208851791126218239402755616994541522004\"\n ; \"64070601581278917442704840630680311036021557676765751754522901046069205253111\"\n ; \"112123228532462696722378911494343451272980413618911326680094528285518792872677\"\n |]\n ; [| \"84572244072021308337360477634782636535511175281144388234379224309078196768262\"\n ; \"45201095631123410354816854701250642083197167601967427301389500806815426216645\"\n ; \"23419302413627434057960523568681421397183896397903197013759822219271473949448\"\n |]\n ; [| \"63220724218126871510891512179599337793645245415246618202146262033908228783613\"\n ; \"67900966560828272306360950341997532094196196655192755442359232962244590070115\"\n ; \"56382132371728071364028077587343004835658613510701494793375685201885283260755\"\n |]\n ; [| \"80317852656339951095312898663286716255545986714650554749917139819628941702909\"\n ; \"110977183257428423540294096816813859894739618561444416996538397449475628658639\"\n ; \"25195781166503180938390820610484311038421647727795615447439501669639084690800\"\n |]\n ; [| \"108664438541952156416331885221418851366456449596370568350972106298760717710264\"\n ; \"17649294376560630922417546944777537620537408190408066211453084495108565929366\"\n ; \"95236435002924956844837407534938226368352771792739587594037613075251645052212\"\n |]\n ; [| \"43150472723422600689013423057826322506171125106415122422656432973040257528684\"\n ; \"77355911134402286174761911573353899889837132781450260391484427670446862700214\"\n ; \"8690728446593494554377477996892461126663797704587025899930929227865493269824\"\n |]\n ; [| \"109175231986025180460846040078523879514558355792739714578031829643740609438879\"\n ; \"64844253590731404811389281562033735091759746904073461140427127388042062490899\"\n ; \"43237071281695629980341250188156848876595681601471702180515324064382368960951\"\n |]\n ; [| \"2704440995725305992776846806711930876273040749514871232837487081811513368296\"\n ; \"66806779110388532101035294912010606217442229808784290357894909707660045365269\"\n ; \"25541187612624070470730890200174075890643652797181103367956318438136878170352\"\n |]\n ; [| \"89300613074831725721350087269266903129165086877175223066581882601662278010666\"\n ; \"36824076981866281177052433916337787028520068526782493484076995129329938182524\"\n ; \"68880449342008497744225106025198236600142055580985632884415488154606462819445\"\n |]\n ; [| \"68556888546596545408135887526582256648006271867854316538090068824142539400698\"\n ; \"111379753250206255125320675615931203940253796355491142745969887430259465111569\"\n ; \"101469186248899356416491489235841069222521093012237305521090058066171355672289\"\n |]\n ; [| \"87819793263125973233157093200229218382531712066157093399606059493857616731410\"\n ; \"11055386921184594780372263378420826851562920740321950336882051897732501262543\"\n ; \"111945832089295501567161822264292548657346358707472584179854375613919325491249\"\n |]\n ; [| \"95630018375719472826904441325138673248990446382783206900295723762884876505178\"\n ; \"94833984285990985873155989049880754188702918168949640563745233736765833491756\"\n ; \"77578854197021606645372788474039811639438242484066959482386065023999206730771\"\n |]\n ; [| \"27799616729223271646690718201487403976485619375555391888533887467404804041014\"\n ; \"42616502170265664498961018686434252976977548128285781725227341660941880774718\"\n ; \"95884094505080541517768389956970969462501217028562326732054532092615835087122\"\n |]\n ; [| \"107531500891040898338150732759493933154418374543568088749403053559827078391994\"\n ; \"17316158269457914256007584527534747738658973027567786054549020564540952112346\"\n ; \"51624680144452294805663893795879183520785046924484587034566439599591446246116\"\n |]\n ; [| \"17698087730709566968258013675219881840614043344609152682517330801348583470562\"\n ; \"111925747861248746962567200879629070277886617811519137515553806421564944666811\"\n ; \"57148554624730554436721083599187229462914514696466218614205595953570212881615\"\n |]\n ; [| \"92002976914130835490768248031171915767210477082066266868807636677032557847243\"\n ; \"58807951133460826577955909810426403194149348045831674376120801431489918282349\"\n ; \"93581873597000319446791963913210464830992618681307774190204379970955657554666\"\n |]\n ; [| \"46734218328816451470118898692627799522173317355773128175090189234250221977353\"\n ; \"12565476532112137808460978474958060441970941349010371267577877299656634907765\"\n ; \"54284813390357004119220859882274190703294683700710665367594256039714984623777\"\n |]\n ; [| \"92046423253202913319296401122133532555630886766139313429473309376931112550800\"\n ; \"15095408309586969968044201398966210357547906905122453139947200130015688526573\"\n ; \"76483858663950700865536712701042004661599554591777656961315837882956812689085\"\n |]\n ; [| \"37793510665854947576525000802927849210746292216845467892500370179796223909690\"\n ; \"84954934523349224038508216623641462700694917568481430996824733443763638196693\"\n ; \"81116649005575743294029244339854405387811058321603450814032274416116019472096\"\n |]\n ; [| \"28313841745366368076212445154871968929195537523489133192784916081223753077949\"\n ; \"17307716513182567320564075539526480893558355908652993731441220999922946005081\"\n ; \"63148771170858502457695904149048034226689843239981287723002468627916462842625\"\n |]\n ; [| \"14724939606645168531546334343600232253284320276481307778787768813885931648950\"\n ; \"4684996260500305121238590806572541849891754312215139285622888510153705963000\"\n ; \"63682763879011752475568476861367553456179860221069473817315669232908763409259\"\n |]\n ; [| \"47776179656187399887062096850541192680190218704758942820514561435612697426715\"\n ; \"42017618175533328439486588850450028995049195954365035474995309904751824054581\"\n ; \"39169739448648613641258102792190571431737464735838931948313779997907435855102\"\n |]\n ; [| \"37525991163523321662699819448962967746703579202577998445997476955224037837979\"\n ; \"67759173441312327668891803222741396828094999063019622301649400178376863820046\"\n ; \"23041132473771739182071223620364590606653086905326129708428084432335332411661\"\n |]\n ; [| \"77778894465896892167598828497939467663479992533052348475467490972714790615441\"\n ; \"20821227542001445006023346122554483849065713580779858784021328359824080462519\"\n ; \"47217242463811495777303984778653549585537750303740616187093690846833142245039\"\n |]\n ; [| \"42826871300142174590405062658305130206548405024021455479047593769907201224399\"\n ; \"8850081254230234130482383430433176873344633494243110112848647064077741649744\"\n ; \"1819639941546179668398979507053724449231350395599747300736218202072168364980\"\n |]\n ; [| \"21219092773772827667886204262476112905428217689703647484316763603169544906986\"\n ; \"35036730416829620763976972888493029852952403098232484869595671405553221294746\"\n ; \"35487050610902505183766069070898136230610758743267437784506875078109148276407\"\n |]\n ; [| \"62560813042054697786535634928462520639989597995560367915904328183428481834648\"\n ; \"112205708104999693686115882430330200785082630634036862526175634736046083007596\"\n ; \"109084747126382177842005646092084591250172358815974554434100716599544229364287\"\n |]\n ; [| \"63740884245554590221521941789197287379354311786803164550686696984009448418872\"\n ; \"58779928727649398559174292364061339806256990859940639552881479945324304668069\"\n ; \"20614241966717622390914334053622572167995367802051836931454426877074875942253\"\n |]\n ; [| \"41621411615229558798583846330993607380846912281220890296433013153854774573504\"\n ; \"20530621481603446397085836296967350209890164029268319619481535419199429275412\"\n ; \"99914592017824500091708233310179001698739309503141229228952777264267035511439\"\n |]\n ; [| \"9497854724940806346676139162466690071592872530638144182764466319052293463165\"\n ; \"7549205476288061047040852944548942878112823732145584918107208536541712726277\"\n ; \"30898915730863004722886730649661235919513859500318540107289237568593577554645\"\n |]\n ; [| \"22697249754607337581727259086359907309326296469394183645633378468855554942575\"\n ; \"72771100592475003378969523202338527077495914171905204927442739996373603143216\"\n ; \"84509851995167666169868678185342549983568150803791023831909660012392522615426\"\n |]\n ; [| \"36601166816771446688370845080961015541431660429079281633209182736773260407536\"\n ; \"19555759172327736128240171000715903945570888389700763573790859521156095228287\"\n ; \"82844424532983875300577689116331373756526403900340445449185486212503235782229\"\n |]\n ; [| \"40833119728631657038301474658571416779079199343770917422783737091842927892625\"\n ; \"68922359316478675184342553333343300163568193749010867527082189412217781430311\"\n ; \"91516472400306837063911995909475588197278444979245081960087094196120449075833\"\n |]\n ; [| \"21304716730402869084944080869903443431235336418077153507261240151959530377653\"\n ; \"106551237424345741137570659736231801772439680702621554106791455938098031620471\"\n ; \"104392597313271110590927764888829150750277653499050463757708547416538850601163\"\n |]\n ; [| \"16907937154215020261110468963982390213438461071031811101554056252102505124726\"\n ; \"23183141532591565112222057191012766855134687114504142337903677590107533245206\"\n ; \"96725517880771645283128624101279195709280644465575982072053504613644938879246\"\n |]\n ; [| \"84556507395241990875812091718422997082915179448604219593521819129312718969906\"\n ; \"100646525819453650494590571397259055384579251368754179569362740802641255820576\"\n ; \"50316555026297423940834952362583934362215303629664094841692233643882339493043\"\n |]\n ; [| \"77363534410783423412630139556441807611393685349073113946053979350631229049878\"\n ; \"54905073434434959485893381841839373267383966385817882684657825178181863944371\"\n ; \"110016011331508430102821620395154714608084938556260733745010992614542669817451\"\n |]\n ; [| \"52040139270046094723964229965823921970388683619580004402190656733318120479093\"\n ; \"495546618036723566920914648951352373868059898268055487677897567226892784967\"\n ; \"2528292188392170914010448139211586215817069915670005292953294092269979070980\"\n |]\n ; [| \"36842840134449713950999812540127591123318806680559982063089906871196226758113\"\n ; \"112314504940338253416202605695368724580971154020421327790335219348068041886245\"\n ; \"51653712314537383078368021242008468828072907802445786549975419682333073143987\"\n |]\n ; [| \"27179054135131403873076215577181710354069071017096145081169516607932870071868\"\n ; \"93264325401956094073193527739715293258814405715822269809955952297346626219055\"\n ; \"75336695567377817226085396912086909560962335091652231383627608374094112503635\"\n |]\n ; [| \"42536477740858058164730818130587261149155820207748153094480456895727052896150\"\n ; \"45297707210835305388426482743535401273114010430724989418303851665124351001731\"\n ; \"28263543670875633354854018109712021307749750769690268127459707194207091046997\"\n |]\n ; [| \"40809484989590048522440442751358616303471639779690405026946053699354967624695\"\n ; \"51589519265418587649124543325590658874910911006853535317847189422703251228717\"\n ; \"73459936981642894525955700397592343967482441686326322443228255968694436816673\"\n |]\n ; [| \"87298777232393189731949522229743081866971743270330772607820990832164835738703\"\n ; \"23328534428894097247289332213412175849711532153957647506361455182140450133738\"\n ; \"51807348624578081645565456865744011145427112815128832643950401419083788780028\"\n |]\n ; [| \"62003629107726929116302469001779155132709624140360743951550189738290955064278\"\n ; \"109311858027068383034683875948676795998030610067675200794951297783857157095297\"\n ; \"2085588517087605436136379278738013214233743532079287631079316773925068862732\"\n |]\n ; [| \"9513664655545306376987968929852776467090105742275395185801917554996684570014\"\n ; \"91103467624252027317764670613760419385374004736848754250298970998535616755199\"\n ; \"39500000352127197728032684892425352332461947514533659433380855624868454474623\"\n |]\n ; [| \"75175260486328125629270378861920310368403601365269629778076078053196928460032\"\n ; \"56923881233337629517433981230592855430598464522180216309153828833928801967999\"\n ; \"20981004218820236011689230170078809973840534961691702543937445515733151438851\"\n |]\n ; [| \"73175203586574092105626230272409823792532423094740797516874387144340145138310\"\n ; \"45186992623753580336479418079070607289916086076906975839720879934817804495460\"\n ; \"96084125187548549854900995260973117424750860440064269432639526863495781270780\"\n |]\n ; [| \"53530507055579550362119832302266967544350117012822630711681736383163390079758\"\n ; \"24484677147631687826970700541691541659768738376645174313438582486313045584324\"\n ; \"99915577684197600584703320523786830947563355229812244982453188909016758004559\"\n |]\n ; [| \"73101441225016284181831039876112223954723401962484828024235461623078642642543\"\n ; \"57434882751817972247799186935032874577110609253567900895922769490031350316077\"\n ; \"73837027842771758252813592393497967898989365991569964687267097531033696791279\"\n |]\n ; [| \"8605586894544301092657394167906502995894014247978769840701086209902531650480\"\n ; \"8900145888985471928279988821934068156350024482295663273746853580585203659117\"\n ; \"76135096553134713603675854628257365311062159747768423095496501607463292188538\"\n |]\n ; [| \"77171330825793179961995032914169307990870372845116475229799680315757656196917\"\n ; \"17848856881287888035559207919717746181941756011012420474955535369227552058196\"\n ; \"85285874363861776466393873037603415962379724376693393356387850868454172343232\"\n |]\n ; [| \"34752820629818556525384193423224856177797869338806846583786365186093662702640\"\n ; \"61923000676912108769617866333091286856690233713839015114991682235541391477568\"\n ; \"105437294734850952102877811210027981435959945375626993201685688489494148805743\"\n |]\n ; [| \"37290995592003925978648162243724313056459187397796644444696543576625771108605\"\n ; \"95156804644588215637074780475000089186488581067063625121782605228712011438608\"\n ; \"111838568780358037910894878973007194619694503969424695895292495245099084158661\"\n |]\n ; [| \"114085830904535970531084512281741806703564152148485737755668141105183488387818\"\n ; \"27151558900245092306095370161852910074651784795680581223133179808714387525774\"\n ; \"17782273009863750298483603933610732253879825505411230932533407287574651036994\"\n |]\n ; [| \"72422039981423868898452547270453235353957783762070405836433674391957844064693\"\n ; \"23635533014670380888810554717349513178608213369182061967678315431422272271569\"\n ; \"59402711345784829746976504521969665104448536964686633342173372133388407225657\"\n |]\n ; [| \"92466806354851856571355165199186633833982438153589406912422876269386887264049\"\n ; \"9877617390649361889067963484857474874019563445507538784053773745685676317984\"\n ; \"74572672075215609948567780829046067891251792522874268554421916351892498078660\"\n |]\n ; [| \"36552683919656073147232029802086505741533932059491323529262718897271096098319\"\n ; \"28895802628889660292449057575076739706255701997961890168977786141673053679086\"\n ; \"9907785227545441866241924986174555965766785257012652276622736289520175209842\"\n |]\n ; [| \"29485332368911768475893015509537099136952860812699472744021496513325455451738\"\n ; \"39797358509842904932758894391536601623578260107859540160156599261695054175926\"\n ; \"107452259847197252302434271220963395311929879689430847107159618578878468880668\"\n |]\n ; [| \"24664696127391052816688570667643612077905959307658722811431436096677076924072\"\n ; \"52507998665481228083044018390203046881916651866666590845312076558622705190465\"\n ; \"69935204723497468327083545368078327534124772251842862926136799697299751835029\"\n |]\n ; [| \"372963191403207230700085823960930798511810380777302780932220121859190714585\"\n ; \"111366606704792806959979488772421759791592911629496627207620326636856656861526\"\n ; \"39677360977437767398760288273614298000827429534821360419179023551087917983124\"\n |]\n ; [| \"64601494076430280535646633059501605929914790764963584476403188233843589027560\"\n ; \"34156315098453482946438495274327282067376463494057110043754782161473776373661\"\n ; \"73687667961196401152630755105477060056162632832680813161120412165243753726816\"\n |]\n ; [| \"37808689229279738382348785246837013002280781984053433359148018860351753688153\"\n ; \"26778210635417272626362658500217995247072424006327715268521424423461840656985\"\n ; \"13012115310019421859484865413402512912208022868124085927375736053832542569552\"\n |]\n ; [| \"33073055720188060063004545324174039863351833928493376423022587630016341635891\"\n ; \"76584254259783109527449313057522305759653397147785066495263227868665161219779\"\n ; \"38531270223194009551634352795926218399266465064491096474482575354468954922673\"\n |]\n ; [| \"90100362566645034035707547984589905559141359276359522681964816611161474672115\"\n ; \"93014643079204629081291124987233004565276697190519877698472422015954982964601\"\n ; \"110916697765188052223435628742886773389228694903593626715469113528434066764534\"\n |]\n ; [| \"114725280711584666069398481856753837363052938587178775403749719257369626174299\"\n ; \"32967950615819700839673854548770413755655613096921050182183649674389310060672\"\n ; \"106372438106855157117155417458821032302424106544646447353561892891697429919509\"\n |]\n ; [| \"41996555998804572671679174634435850382099449308465335760130383677478780889948\"\n ; \"105999190358126224751922865919841547624707481487885223948004296548330504340556\"\n ; \"16636528128134911466622907961467317982179835733058354229921170933476186200761\"\n |]\n ; [| \"43468498537738045222256870515315985487110433728199201952445121047095648527840\"\n ; \"102272887089258604970815589009009162752025146641624347901234381428987386153285\"\n ; \"797386830910520008361185815477523544664694040635544500916993469578452189812\"\n |]\n ; [| \"96744926314199156321023598425708516126928808801578082649702497034531770517808\"\n ; \"99066250188188051206024031106640566584616407903813704153928240609169764005797\"\n ; \"101012485188852469291356197079506861083321680470016268483997462932491691773708\"\n |]\n ; [| \"49614555470963378761214277525336169174318331863453657910575217035316990252780\"\n ; \"94532874466332578813348267802784511494491757628599627802933242637211676358456\"\n ; \"60376163781951477822973950330025689966951914888122503797194554488987660570913\"\n |]\n ; [| \"99934768696780030317676638063039209891456597783633841250810260768328701786300\"\n ; \"71861378641802240356627336242725340978135703736568776865558429280585792121426\"\n ; \"84446994028646761779912629176051455275041688583492300440129402381138226185369\"\n |]\n ; [| \"18317002472599225949038448120242542829985613745531554876060436499109578301758\"\n ; \"23001721954642810524358122249469196372443463625490878969385130364780514025259\"\n ; \"49037245410934285111914043557449391103989331168177809387278571893536129709378\"\n |]\n ; [| \"65792050828386571136875573680568197513273253001530588336285451691348906024460\"\n ; \"12956514709922286639520985225111137950302442378466870763868693820049405409474\"\n ; \"38025781500219940187723501911749158551479941535921061459281014661810772473038\"\n |]\n ; [| \"98610017124283789125637190759729078315864881693957982200427567103302362453196\"\n ; \"42724178943656779288650125468921272883324869492775989038952508393082565227450\"\n ; \"99514360136104778310983460863480701661882652836741972684579325226086664343913\"\n |]\n ; [| \"111234788248236327826382691076985300771418365594838017963216100441270435887017\"\n ; \"35290532009451633157074005614742321966918220860237810056920944192222599040501\"\n ; \"72172784027306769601458922728374293130025170844011739475076742090414769211169\"\n |]\n ; [| \"61384388429666858375759167984149961873566898632022783479711533101905095026411\"\n ; \"8194273390415023152581060020119881338779571723515253104919314696738194355344\"\n ; \"80659234466772556847544129237154202226081525079070598707001193889658539631883\"\n |]\n ; [| \"62157670692624367146830864246105810519941474190553952682719433471854134465138\"\n ; \"74851302400382275482762496406028988868219592716510355166137061257664688666219\"\n ; \"16881796086836744646703159464114164393240695449455598565494759189917589453976\"\n |]\n ; [| \"42460477269659081546432152357644086326197211166562674408623141905226706277595\"\n ; \"81063688725529281621596607500748519671655516257039992655745871437369181665242\"\n ; \"51403113216244137057466948399908740878535656059933892843818689317660325080213\"\n |]\n ; [| \"49001998791770520786679099472805193463531142479298200795569326894791589887035\"\n ; \"42684462014557597494725933597359625461226399711783671410492942446635214257509\"\n ; \"106420886277092880545929306533089566775810130555230702838917980421765786292693\"\n |]\n ; [| \"110523958037212353696746219917157237679515245560578307171595792811566554384451\"\n ; \"56399709802930804752950401483879725014794413557467977624037632281590440364765\"\n ; \"100108862073771478435824578087801736413858177140360408436521717282600830155374\"\n |]\n ; [| \"59041409790855290045250456089216312297230856546920761548978870779493926213674\"\n ; \"13735945315945382005247895569035266667172550063549145646185577935658666385507\"\n ; \"16846296242516834547231537358954027537902709068158411294345086281698311539718\"\n |]\n ; [| \"114970774262524353875592617323889610576992844847433725376114488262076142213525\"\n ; \"17896661983150937411004047429485556264820315976705642986609974816436222162633\"\n ; \"115573362005053049429141251153085446935774781295666612354309246218946442750706\"\n |]\n ; [| \"85575265064375003235737272215445285540001719469558026661845214249857169530994\"\n ; \"87501751332871186792668480006319719164949448258731670359536302677279100637346\"\n ; \"105775909055063540416087237151517389942637625317333843436738223226977225420379\"\n |]\n ; [| \"110886009455283422981396854898481256559291311408679418842391298005253375700608\"\n ; \"95342257228100720685556647789433478371609336135456255803583405713563597933074\"\n ; \"2733591517253510124338232417535938539627593736745105875672348998709544742241\"\n |]\n ; [| \"32685479117496505057951010536248024091461630564950845696581129158987138920098\"\n ; \"96139836598015371513111133071481139035733083963976340622322043979088723982681\"\n ; \"16990606351055720221300633612533434675038905235719867684891402550154692840579\"\n |]\n ; [| \"13886834869596827027283068322204563244577723967928602405785473534631482228259\"\n ; \"81034769645830807786559566591578132114590768431721148809270219480247445931316\"\n ; \"26780635035984131258327079447673207266040002451512601352288859614294714150612\"\n |]\n ; [| \"72820784976920576285217524394309841044157743334874310886804718206719618858662\"\n ; \"84276722913141806246805569560426345961854221390421557310593118606084442633714\"\n ; \"42573817497593319926701003355299929070203785007821783512454795971915573843634\"\n |]\n ; [| \"41660041627266397279909712983288860313881442148611073178272756605107913521726\"\n ; \"7198246770791404776745997973411401046335399072925979346193035999274650139809\"\n ; \"91576025129588718283317000330880100309465430116820675850311277329602716166005\"\n |]\n ; [| \"30488483928716649313242898509172476460161184318124511942476380904233730958564\"\n ; \"35346040517569327255933130090945133067049088493975862969006023114275649329148\"\n ; \"59803015801166721680239913449555176591725421041660016242103441987856441941533\"\n |]\n ; [| \"17395049232451382970906883167116397657891664802601579276725674512534883408665\"\n ; \"96892830538146451450007413348096295684782382701592949711753407054447667361829\"\n ; \"46725583995795907014628330473921842919957418641665482351238505922983315675600\"\n |]\n ; [| \"20556719902345568138970735755829852608784985449829745172855204153387982836579\"\n ; \"17130405757403641097651484965062131526367059595476924144885570325828777794585\"\n ; \"99651763337265056372826178960800950053231370129318394703153246147873057668256\"\n |]\n ; [| \"17814517977679061356584950826520510701145481336316888282105225134451035883368\"\n ; \"62116749577126511600138536864540326578096290025961229483071769130930103978622\"\n ; \"68057799973217998063838402481530957249181669394905338807621317159743376777292\"\n |]\n ; [| \"26100793478962260035181580648528031417033872324944615961986573818448125345450\"\n ; \"26507891451149179196332605230084404371370204632884553105363087566061809624465\"\n ; \"55607174697006979796477169324630939518573410736589826596210132996613779221405\"\n |]\n ; [| \"75098549092668095590746032937529532494350222003700838962461867948806312867882\"\n ; \"62901674712278062473767645982006145910793625009149846534629441949336033280610\"\n ; \"5918385816682866756860679567405784562483373873565987668410277610868983146285\"\n |]\n ; [| \"99232460916208710346946062875203578399818909925477280432427620267031292402265\"\n ; \"115165948144292852122635634954139515297086369356811820254801384608988902457684\"\n ; \"39462036389170488019054739441325823641943062254145671230029238830857274014332\"\n |]\n ; [| \"109723826013507458840008311671051963282645213933956581735587227292458581212170\"\n ; \"88295699560808238817850908733435797366622278897489038929647807463406234520052\"\n ; \"20306380368695786945008272690438693745796297843799468268993907772341096948885\"\n |]\n ; [| \"39988356032524455736714109463355738665746339590560108227920970859248126609155\"\n ; \"47372836588594871116561451142702593094337405740661755511614125456886719840333\"\n ; \"42727075822142544969304941778878121065758237932060280070908539158139079888683\"\n |]\n ; [| \"115695172202592006925180721060969710051274632819849770440984261650964182295350\"\n ; \"41198034356969673080518030958715740186484860381424802035929938277103521577731\"\n ; \"115380378505550001583545282887589851179279565072664241489053445702744491234750\"\n |]\n ; [| \"56074680442485705900559544809779144521596408129059458559681779642734476672579\"\n ; \"54187206076706271120400668422875039791522899135281309004702779376007885441827\"\n ; \"100760509008368123701304764217450368711018785408289674422092070202193042774995\"\n |]\n ; [| \"2622643323130765702269424224791233611920515499144047449633123689743564676648\"\n ; \"95487289650450707799373930173349121410704227885014701702619711048222666102791\"\n ; \"94943953462630479470879050547964792684799160133612590505176816568790562776928\"\n |]\n |]\n }\n\nlet params_Bn382_q =\n { Params.mds =\n [| [| \"2663538809597650435844500745640128112500797729229320076136089551791530014683740176469459837095745057420024990698304\"\n ; \"3372673220977743741609068262704292488957271565700673274891426149291073445433316668667874458522247135736401556339737\"\n ; \"4702399048364054789745695060954166226249916683594965873315202085308155435886379283955080194729213218481069112754347\"\n |]\n ; [| \"2215778453553447259216822687321394545528815439827126692759606056122905656424424554076355712016973336681821219494537\"\n ; \"1284753801167450198664971157009572170099813485759371112881157467066929464161583508786486164543283350228782139803094\"\n ; \"1136441139974396511543268992916724168911879411721635269198331720240499757381302440272659128030869203409955304203115\"\n |]\n ; [| \"5295202322853619951220986804473857321275810243906349721146315070442772012272591642930885737122084843222525444659152\"\n ; \"2585574180998322214773500417577043354533137309395421285678021891228333612974808568921533701659765694493897008321886\"\n ; \"4327637570022845964174929847928171567054668769686956705326721990617716210727017530524703225454617877992054172811917\"\n |]\n |]\n ; round_constants =\n [| [| \"78119860594733808983474265082430117124674905785489385612351809573030163625517\"\n ; \"41917899842730241418346215913324270532073353586134123463219061327941260175271\"\n ; \"74594641694171623328644944059182600919855574964222988275913344198970402906473\"\n |]\n ; [| \"96215759378377024990520153908983544755208851791126218239402755616994541522004\"\n ; \"64070601581278917442704840630680311036021557676765751754522901046069205253111\"\n ; \"112123228532462696722378911494343451272980413618911326680094528285518792872677\"\n |]\n ; [| \"84572244072021308337360477634782636535511175281144388234379224309078196768262\"\n ; \"45201095631123410354816854701250642083197167601967427301389500806815426216645\"\n ; \"23419302413627434057960523568681421397183896397903197013759822219271473949448\"\n |]\n ; [| \"63220724218126871510891512179599337793645245415246618202146262033908228783613\"\n ; \"67900966560828272306360950341997532094196196655192755442359232962244590070115\"\n ; \"56382132371728071364028077587343004835658613510701494793375685201885283260755\"\n |]\n ; [| \"80317852656339951095312898663286716255545986714650554749917139819628941702909\"\n ; \"110977183257428423540294096816813859894739618561444416996538397449475628658639\"\n ; \"25195781166503180938390820610484311038421647727795615447439501669639084690800\"\n |]\n ; [| \"108664438541952156416331885221418851366456449596370568350972106298760717710264\"\n ; \"17649294376560630922417546944777537620537408190408066211453084495108565929366\"\n ; \"95236435002924956844837407534938226368352771792739587594037613075251645052212\"\n |]\n ; [| \"43150472723422600689013423057826322506171125106415122422656432973040257528684\"\n ; \"77355911134402286174761911573353899889837132781450260391484427670446862700214\"\n ; \"8690728446593494554377477996892461126663797704587025899930929227865493269824\"\n |]\n ; [| \"109175231986025180460846040078523879514558355792739714578031829643740609438879\"\n ; \"64844253590731404811389281562033735091759746904073461140427127388042062490899\"\n ; \"43237071281695629980341250188156848876595681601471702180515324064382368960951\"\n |]\n ; [| \"2704440995725305992776846806711930876273040749514871232837487081811513368296\"\n ; \"66806779110388532101035294912010606217442229808784290357894909707660045365269\"\n ; \"25541187612624070470730890200174075890643652797181103367956318438136878170352\"\n |]\n ; [| \"89300613074831725721350087269266903129165086877175223066581882601662278010666\"\n ; \"36824076981866281177052433916337787028520068526782493484076995129329938182524\"\n ; \"68880449342008497744225106025198236600142055580985632884415488154606462819445\"\n |]\n ; [| \"68556888546596545408135887526582256648006271867854316538090068824142539400698\"\n ; \"111379753250206255125320675615931203940253796355491142745969887430259465111569\"\n ; \"101469186248899356416491489235841069222521093012237305521090058066171355672289\"\n |]\n ; [| \"87819793263125973233157093200229218382531712066157093399606059493857616731410\"\n ; \"11055386921184594780372263378420826851562920740321950336882051897732501262543\"\n ; \"111945832089295501567161822264292548657346358707472584179854375613919325491249\"\n |]\n ; [| \"95630018375719472826904441325138673248990446382783206900295723762884876505178\"\n ; \"94833984285990985873155989049880754188702918168949640563745233736765833491756\"\n ; \"77578854197021606645372788474039811639438242484066959482386065023999206730771\"\n |]\n ; [| \"27799616729223271646690718201487403976485619375555391888533887467404804041014\"\n ; \"42616502170265664498961018686434252976977548128285781725227341660941880774718\"\n ; \"95884094505080541517768389956970969462501217028562326732054532092615835087122\"\n |]\n ; [| \"107531500891040898338150732759493933154418374543568088749403053559827078391994\"\n ; \"17316158269457914256007584527534747738658973027567786054549020564540952112346\"\n ; \"51624680144452294805663893795879183520785046924484587034566439599591446246116\"\n |]\n ; [| \"17698087730709566968258013675219881840614043344609152682517330801348583470562\"\n ; \"111925747861248746962567200879629070277886617811519137515553806421564944666811\"\n ; \"57148554624730554436721083599187229462914514696466218614205595953570212881615\"\n |]\n ; [| \"92002976914130835490768248031171915767210477082066266868807636677032557847243\"\n ; \"58807951133460826577955909810426403194149348045831674376120801431489918282349\"\n ; \"93581873597000319446791963913210464830992618681307774190204379970955657554666\"\n |]\n ; [| \"46734218328816451470118898692627799522173317355773128175090189234250221977353\"\n ; \"12565476532112137808460978474958060441970941349010371267577877299656634907765\"\n ; \"54284813390357004119220859882274190703294683700710665367594256039714984623777\"\n |]\n ; [| \"92046423253202913319296401122133532555630886766139313429473309376931112550800\"\n ; \"15095408309586969968044201398966210357547906905122453139947200130015688526573\"\n ; \"76483858663950700865536712701042004661599554591777656961315837882956812689085\"\n |]\n ; [| \"37793510665854947576525000802927849210746292216845467892500370179796223909690\"\n ; \"84954934523349224038508216623641462700694917568481430996824733443763638196693\"\n ; \"81116649005575743294029244339854405387811058321603450814032274416116019472096\"\n |]\n ; [| \"28313841745366368076212445154871968929195537523489133192784916081223753077949\"\n ; \"17307716513182567320564075539526480893558355908652993731441220999922946005081\"\n ; \"63148771170858502457695904149048034226689843239981287723002468627916462842625\"\n |]\n ; [| \"14724939606645168531546334343600232253284320276481307778787768813885931648950\"\n ; \"4684996260500305121238590806572541849891754312215139285622888510153705963000\"\n ; \"63682763879011752475568476861367553456179860221069473817315669232908763409259\"\n |]\n ; [| \"47776179656187399887062096850541192680190218704758942820514561435612697426715\"\n ; \"42017618175533328439486588850450028995049195954365035474995309904751824054581\"\n ; \"39169739448648613641258102792190571431737464735838931948313779997907435855102\"\n |]\n ; [| \"37525991163523321662699819448962967746703579202577998445997476955224037837979\"\n ; \"67759173441312327668891803222741396828094999063019622301649400178376863820046\"\n ; \"23041132473771739182071223620364590606653086905326129708428084432335332411661\"\n |]\n ; [| \"77778894465896892167598828497939467663479992533052348475467490972714790615441\"\n ; \"20821227542001445006023346122554483849065713580779858784021328359824080462519\"\n ; \"47217242463811495777303984778653549585537750303740616187093690846833142245039\"\n |]\n ; [| \"42826871300142174590405062658305130206548405024021455479047593769907201224399\"\n ; \"8850081254230234130482383430433176873344633494243110112848647064077741649744\"\n ; \"1819639941546179668398979507053724449231350395599747300736218202072168364980\"\n |]\n ; [| \"21219092773772827667886204262476112905428217689703647484316763603169544906986\"\n ; \"35036730416829620763976972888493029852952403098232484869595671405553221294746\"\n ; \"35487050610902505183766069070898136230610758743267437784506875078109148276407\"\n |]\n ; [| \"62560813042054697786535634928462520639989597995560367915904328183428481834648\"\n ; \"112205708104999693686115882430330200785082630634036862526175634736046083007596\"\n ; \"109084747126382177842005646092084591250172358815974554434100716599544229364287\"\n |]\n ; [| \"63740884245554590221521941789197287379354311786803164550686696984009448418872\"\n ; \"58779928727649398559174292364061339806256990859940639552881479945324304668069\"\n ; \"20614241966717622390914334053622572167995367802051836931454426877074875942253\"\n |]\n ; [| \"41621411615229558798583846330993607380846912281220890296433013153854774573504\"\n ; \"20530621481603446397085836296967350209890164029268319619481535419199429275412\"\n ; \"99914592017824500091708233310179001698739309503141229228952777264267035511439\"\n |]\n ; [| \"9497854724940806346676139162466690071592872530638144182764466319052293463165\"\n ; \"7549205476288061047040852944548942878112823732145584918107208536541712726277\"\n ; \"30898915730863004722886730649661235919513859500318540107289237568593577554645\"\n |]\n ; [| \"22697249754607337581727259086359907309326296469394183645633378468855554942575\"\n ; \"72771100592475003378969523202338527077495914171905204927442739996373603143216\"\n ; \"84509851995167666169868678185342549983568150803791023831909660012392522615426\"\n |]\n ; [| \"36601166816771446688370845080961015541431660429079281633209182736773260407536\"\n ; \"19555759172327736128240171000715903945570888389700763573790859521156095228287\"\n ; \"82844424532983875300577689116331373756526403900340445449185486212503235782229\"\n |]\n ; [| \"40833119728631657038301474658571416779079199343770917422783737091842927892625\"\n ; \"68922359316478675184342553333343300163568193749010867527082189412217781430311\"\n ; \"91516472400306837063911995909475588197278444979245081960087094196120449075833\"\n |]\n ; [| \"21304716730402869084944080869903443431235336418077153507261240151959530377653\"\n ; \"106551237424345741137570659736231801772439680702621554106791455938098031620471\"\n ; \"104392597313271110590927764888829150750277653499050463757708547416538850601163\"\n |]\n ; [| \"16907937154215020261110468963982390213438461071031811101554056252102505124726\"\n ; \"23183141532591565112222057191012766855134687114504142337903677590107533245206\"\n ; \"96725517880771645283128624101279195709280644465575982072053504613644938879246\"\n |]\n ; [| \"84556507395241990875812091718422997082915179448604219593521819129312718969906\"\n ; \"100646525819453650494590571397259055384579251368754179569362740802641255820576\"\n ; \"50316555026297423940834952362583934362215303629664094841692233643882339493043\"\n |]\n ; [| \"77363534410783423412630139556441807611393685349073113946053979350631229049878\"\n ; \"54905073434434959485893381841839373267383966385817882684657825178181863944371\"\n ; \"110016011331508430102821620395154714608084938556260733745010992614542669817451\"\n |]\n ; [| \"52040139270046094723964229965823921970388683619580004402190656733318120479093\"\n ; \"495546618036723566920914648951352373868059898268055487677897567226892784967\"\n ; \"2528292188392170914010448139211586215817069915670005292953294092269979070980\"\n |]\n ; [| \"36842840134449713950999812540127591123318806680559982063089906871196226758113\"\n ; \"112314504940338253416202605695368724580971154020421327790335219348068041886245\"\n ; \"51653712314537383078368021242008468828072907802445786549975419682333073143987\"\n |]\n ; [| \"27179054135131403873076215577181710354069071017096145081169516607932870071868\"\n ; \"93264325401956094073193527739715293258814405715822269809955952297346626219055\"\n ; \"75336695567377817226085396912086909560962335091652231383627608374094112503635\"\n |]\n ; [| \"42536477740858058164730818130587261149155820207748153094480456895727052896150\"\n ; \"45297707210835305388426482743535401273114010430724989418303851665124351001731\"\n ; \"28263543670875633354854018109712021307749750769690268127459707194207091046997\"\n |]\n ; [| \"40809484989590048522440442751358616303471639779690405026946053699354967624695\"\n ; \"51589519265418587649124543325590658874910911006853535317847189422703251228717\"\n ; \"73459936981642894525955700397592343967482441686326322443228255968694436816673\"\n |]\n ; [| \"87298777232393189731949522229743081866971743270330772607820990832164835738703\"\n ; \"23328534428894097247289332213412175849711532153957647506361455182140450133738\"\n ; \"51807348624578081645565456865744011145427112815128832643950401419083788780028\"\n |]\n ; [| \"62003629107726929116302469001779155132709624140360743951550189738290955064278\"\n ; \"109311858027068383034683875948676795998030610067675200794951297783857157095297\"\n ; \"2085588517087605436136379278738013214233743532079287631079316773925068862732\"\n |]\n ; [| \"9513664655545306376987968929852776467090105742275395185801917554996684570014\"\n ; \"91103467624252027317764670613760419385374004736848754250298970998535616755199\"\n ; \"39500000352127197728032684892425352332461947514533659433380855624868454474623\"\n |]\n ; [| \"75175260486328125629270378861920310368403601365269629778076078053196928460032\"\n ; \"56923881233337629517433981230592855430598464522180216309153828833928801967999\"\n ; \"20981004218820236011689230170078809973840534961691702543937445515733151438851\"\n |]\n ; [| \"73175203586574092105626230272409823792532423094740797516874387144340145138310\"\n ; \"45186992623753580336479418079070607289916086076906975839720879934817804495460\"\n ; \"96084125187548549854900995260973117424750860440064269432639526863495781270780\"\n |]\n ; [| \"53530507055579550362119832302266967544350117012822630711681736383163390079758\"\n ; \"24484677147631687826970700541691541659768738376645174313438582486313045584324\"\n ; \"99915577684197600584703320523786830947563355229812244982453188909016758004559\"\n |]\n ; [| \"73101441225016284181831039876112223954723401962484828024235461623078642642543\"\n ; \"57434882751817972247799186935032874577110609253567900895922769490031350316077\"\n ; \"73837027842771758252813592393497967898989365991569964687267097531033696791279\"\n |]\n ; [| \"8605586894544301092657394167906502995894014247978769840701086209902531650480\"\n ; \"8900145888985471928279988821934068156350024482295663273746853580585203659117\"\n ; \"76135096553134713603675854628257365311062159747768423095496501607463292188538\"\n |]\n ; [| \"77171330825793179961995032914169307990870372845116475229799680315757656196917\"\n ; \"17848856881287888035559207919717746181941756011012420474955535369227552058196\"\n ; \"85285874363861776466393873037603415962379724376693393356387850868454172343232\"\n |]\n ; [| \"34752820629818556525384193423224856177797869338806846583786365186093662702640\"\n ; \"61923000676912108769617866333091286856690233713839015114991682235541391477568\"\n ; \"105437294734850952102877811210027981435959945375626993201685688489494148805743\"\n |]\n ; [| \"37290995592003925978648162243724313056459187397796644444696543576625771108605\"\n ; \"95156804644588215637074780475000089186488581067063625121782605228712011438608\"\n ; \"111838568780358037910894878973007194619694503969424695895292495245099084158661\"\n |]\n ; [| \"114085830904535970531084512281741806703564152148485737755668141105183488387818\"\n ; \"27151558900245092306095370161852910074651784795680581223133179808714387525774\"\n ; \"17782273009863750298483603933610732253879825505411230932533407287574651036994\"\n |]\n ; [| \"72422039981423868898452547270453235353957783762070405836433674391957844064693\"\n ; \"23635533014670380888810554717349513178608213369182061967678315431422272271569\"\n ; \"59402711345784829746976504521969665104448536964686633342173372133388407225657\"\n |]\n ; [| \"92466806354851856571355165199186633833982438153589406912422876269386887264049\"\n ; \"9877617390649361889067963484857474874019563445507538784053773745685676317984\"\n ; \"74572672075215609948567780829046067891251792522874268554421916351892498078660\"\n |]\n ; [| \"36552683919656073147232029802086505741533932059491323529262718897271096098319\"\n ; \"28895802628889660292449057575076739706255701997961890168977786141673053679086\"\n ; \"9907785227545441866241924986174555965766785257012652276622736289520175209842\"\n |]\n ; [| \"29485332368911768475893015509537099136952860812699472744021496513325455451738\"\n ; \"39797358509842904932758894391536601623578260107859540160156599261695054175926\"\n ; \"107452259847197252302434271220963395311929879689430847107159618578878468880668\"\n |]\n ; [| \"24664696127391052816688570667643612077905959307658722811431436096677076924072\"\n ; \"52507998665481228083044018390203046881916651866666590845312076558622705190465\"\n ; \"69935204723497468327083545368078327534124772251842862926136799697299751835029\"\n |]\n ; [| \"372963191403207230700085823960930798511810380777302780932220121859190714585\"\n ; \"111366606704792806959979488772421759791592911629496627207620326636856656861526\"\n ; \"39677360977437767398760288273614298000827429534821360419179023551087917983124\"\n |]\n ; [| \"64601494076430280535646633059501605929914790764963584476403188233843589027560\"\n ; \"34156315098453482946438495274327282067376463494057110043754782161473776373661\"\n ; \"73687667961196401152630755105477060056162632832680813161120412165243753726816\"\n |]\n ; [| \"37808689229279738382348785246837013002280781984053433359148018860351753688153\"\n ; \"26778210635417272626362658500217995247072424006327715268521424423461840656985\"\n ; \"13012115310019421859484865413402512912208022868124085927375736053832542569552\"\n |]\n ; [| \"33073055720188060063004545324174039863351833928493376423022587630016341635891\"\n ; \"76584254259783109527449313057522305759653397147785066495263227868665161219779\"\n ; \"38531270223194009551634352795926218399266465064491096474482575354468954922673\"\n |]\n ; [| \"90100362566645034035707547984589905559141359276359522681964816611161474672115\"\n ; \"93014643079204629081291124987233004565276697190519877698472422015954982964601\"\n ; \"110916697765188052223435628742886773389228694903593626715469113528434066764534\"\n |]\n ; [| \"114725280711584666069398481856753837363052938587178775403749719257369626174299\"\n ; \"32967950615819700839673854548770413755655613096921050182183649674389310060672\"\n ; \"106372438106855157117155417458821032302424106544646447353561892891697429919509\"\n |]\n ; [| \"41996555998804572671679174634435850382099449308465335760130383677478780889948\"\n ; \"105999190358126224751922865919841547624707481487885223948004296548330504340556\"\n ; \"16636528128134911466622907961467317982179835733058354229921170933476186200761\"\n |]\n ; [| \"43468498537738045222256870515315985487110433728199201952445121047095648527840\"\n ; \"102272887089258604970815589009009162752025146641624347901234381428987386153285\"\n ; \"797386830910520008361185815477523544664694040635544500916993469578452189812\"\n |]\n ; [| \"96744926314199156321023598425708516126928808801578082649702497034531770517808\"\n ; \"99066250188188051206024031106640566584616407903813704153928240609169764005797\"\n ; \"101012485188852469291356197079506861083321680470016268483997462932491691773708\"\n |]\n ; [| \"49614555470963378761214277525336169174318331863453657910575217035316990252780\"\n ; \"94532874466332578813348267802784511494491757628599627802933242637211676358456\"\n ; \"60376163781951477822973950330025689966951914888122503797194554488987660570913\"\n |]\n ; [| \"99934768696780030317676638063039209891456597783633841250810260768328701786300\"\n ; \"71861378641802240356627336242725340978135703736568776865558429280585792121426\"\n ; \"84446994028646761779912629176051455275041688583492300440129402381138226185369\"\n |]\n ; [| \"18317002472599225949038448120242542829985613745531554876060436499109578301758\"\n ; \"23001721954642810524358122249469196372443463625490878969385130364780514025259\"\n ; \"49037245410934285111914043557449391103989331168177809387278571893536129709378\"\n |]\n ; [| \"65792050828386571136875573680568197513273253001530588336285451691348906024460\"\n ; \"12956514709922286639520985225111137950302442378466870763868693820049405409474\"\n ; \"38025781500219940187723501911749158551479941535921061459281014661810772473038\"\n |]\n ; [| \"98610017124283789125637190759729078315864881693957982200427567103302362453196\"\n ; \"42724178943656779288650125468921272883324869492775989038952508393082565227450\"\n ; \"99514360136104778310983460863480701661882652836741972684579325226086664343913\"\n |]\n ; [| \"111234788248236327826382691076985300771418365594838017963216100441270435887017\"\n ; \"35290532009451633157074005614742321966918220860237810056920944192222599040501\"\n ; \"72172784027306769601458922728374293130025170844011739475076742090414769211169\"\n |]\n ; [| \"61384388429666858375759167984149961873566898632022783479711533101905095026411\"\n ; \"8194273390415023152581060020119881338779571723515253104919314696738194355344\"\n ; \"80659234466772556847544129237154202226081525079070598707001193889658539631883\"\n |]\n ; [| \"62157670692624367146830864246105810519941474190553952682719433471854134465138\"\n ; \"74851302400382275482762496406028988868219592716510355166137061257664688666219\"\n ; \"16881796086836744646703159464114164393240695449455598565494759189917589453976\"\n |]\n ; [| \"42460477269659081546432152357644086326197211166562674408623141905226706277595\"\n ; \"81063688725529281621596607500748519671655516257039992655745871437369181665242\"\n ; \"51403113216244137057466948399908740878535656059933892843818689317660325080213\"\n |]\n ; [| \"49001998791770520786679099472805193463531142479298200795569326894791589887035\"\n ; \"42684462014557597494725933597359625461226399711783671410492942446635214257509\"\n ; \"106420886277092880545929306533089566775810130555230702838917980421765786292693\"\n |]\n ; [| \"110523958037212353696746219917157237679515245560578307171595792811566554384451\"\n ; \"56399709802930804752950401483879725014794413557467977624037632281590440364765\"\n ; \"100108862073771478435824578087801736413858177140360408436521717282600830155374\"\n |]\n ; [| \"59041409790855290045250456089216312297230856546920761548978870779493926213674\"\n ; \"13735945315945382005247895569035266667172550063549145646185577935658666385507\"\n ; \"16846296242516834547231537358954027537902709068158411294345086281698311539718\"\n |]\n ; [| \"114970774262524353875592617323889610576992844847433725376114488262076142213525\"\n ; \"17896661983150937411004047429485556264820315976705642986609974816436222162633\"\n ; \"115573362005053049429141251153085446935774781295666612354309246218946442750706\"\n |]\n ; [| \"85575265064375003235737272215445285540001719469558026661845214249857169530994\"\n ; \"87501751332871186792668480006319719164949448258731670359536302677279100637346\"\n ; \"105775909055063540416087237151517389942637625317333843436738223226977225420379\"\n |]\n ; [| \"110886009455283422981396854898481256559291311408679418842391298005253375700608\"\n ; \"95342257228100720685556647789433478371609336135456255803583405713563597933074\"\n ; \"2733591517253510124338232417535938539627593736745105875672348998709544742241\"\n |]\n ; [| \"32685479117496505057951010536248024091461630564950845696581129158987138920098\"\n ; \"96139836598015371513111133071481139035733083963976340622322043979088723982681\"\n ; \"16990606351055720221300633612533434675038905235719867684891402550154692840579\"\n |]\n ; [| \"13886834869596827027283068322204563244577723967928602405785473534631482228259\"\n ; \"81034769645830807786559566591578132114590768431721148809270219480247445931316\"\n ; \"26780635035984131258327079447673207266040002451512601352288859614294714150612\"\n |]\n ; [| \"72820784976920576285217524394309841044157743334874310886804718206719618858662\"\n ; \"84276722913141806246805569560426345961854221390421557310593118606084442633714\"\n ; \"42573817497593319926701003355299929070203785007821783512454795971915573843634\"\n |]\n ; [| \"41660041627266397279909712983288860313881442148611073178272756605107913521726\"\n ; \"7198246770791404776745997973411401046335399072925979346193035999274650139809\"\n ; \"91576025129588718283317000330880100309465430116820675850311277329602716166005\"\n |]\n ; [| \"30488483928716649313242898509172476460161184318124511942476380904233730958564\"\n ; \"35346040517569327255933130090945133067049088493975862969006023114275649329148\"\n ; \"59803015801166721680239913449555176591725421041660016242103441987856441941533\"\n |]\n ; [| \"17395049232451382970906883167116397657891664802601579276725674512534883408665\"\n ; \"96892830538146451450007413348096295684782382701592949711753407054447667361829\"\n ; \"46725583995795907014628330473921842919957418641665482351238505922983315675600\"\n |]\n ; [| \"20556719902345568138970735755829852608784985449829745172855204153387982836579\"\n ; \"17130405757403641097651484965062131526367059595476924144885570325828777794585\"\n ; \"99651763337265056372826178960800950053231370129318394703153246147873057668256\"\n |]\n ; [| \"17814517977679061356584950826520510701145481336316888282105225134451035883368\"\n ; \"62116749577126511600138536864540326578096290025961229483071769130930103978622\"\n ; \"68057799973217998063838402481530957249181669394905338807621317159743376777292\"\n |]\n ; [| \"26100793478962260035181580648528031417033872324944615961986573818448125345450\"\n ; \"26507891451149179196332605230084404371370204632884553105363087566061809624465\"\n ; \"55607174697006979796477169324630939518573410736589826596210132996613779221405\"\n |]\n ; [| \"75098549092668095590746032937529532494350222003700838962461867948806312867882\"\n ; \"62901674712278062473767645982006145910793625009149846534629441949336033280610\"\n ; \"5918385816682866756860679567405784562483373873565987668410277610868983146285\"\n |]\n ; [| \"99232460916208710346946062875203578399818909925477280432427620267031292402265\"\n ; \"115165948144292852122635634954139515297086369356811820254801384608988902457684\"\n ; \"39462036389170488019054739441325823641943062254145671230029238830857274014332\"\n |]\n ; [| \"109723826013507458840008311671051963282645213933956581735587227292458581212170\"\n ; \"88295699560808238817850908733435797366622278897489038929647807463406234520052\"\n ; \"20306380368695786945008272690438693745796297843799468268993907772341096948885\"\n |]\n ; [| \"39988356032524455736714109463355738665746339590560108227920970859248126609155\"\n ; \"47372836588594871116561451142702593094337405740661755511614125456886719840333\"\n ; \"42727075822142544969304941778878121065758237932060280070908539158139079888683\"\n |]\n ; [| \"115695172202592006925180721060969710051274632819849770440984261650964182295350\"\n ; \"41198034356969673080518030958715740186484860381424802035929938277103521577731\"\n ; \"115380378505550001583545282887589851179279565072664241489053445702744491234750\"\n |]\n ; [| \"56074680442485705900559544809779144521596408129059458559681779642734476672579\"\n ; \"54187206076706271120400668422875039791522899135281309004702779376007885441827\"\n ; \"100760509008368123701304764217450368711018785408289674422092070202193042774995\"\n |]\n ; [| \"2622643323130765702269424224791233611920515499144047449633123689743564676648\"\n ; \"95487289650450707799373930173349121410704227885014701702619711048222666102791\"\n ; \"94943953462630479470879050547964792684799160133612590505176816568790562776928\"\n |]\n |]\n }\n\nlet params_Tweedle_p =\n { Params.mds =\n [| [| \"7892482395656804349644706591899634788891398382785975587948820587975527991027\"\n ; \"11929678886172339432249632245409218061683715785450195046937244296345281508001\"\n ; \"14031028727666215233628980515424371116641513455277823607571812548899776279020\"\n |]\n ; [| \"7068151019014908222760412877815939864640073704531562607661785991407609364631\"\n ; \"20000306279614657869922305271027332599039933086359117559307552225546808822661\"\n ; \"11789548007016973514330291636006559052177068373404372008308286066331957081587\"\n |]\n ; [| \"4596429675096962119861928990065498834900102715520185745595618370978168039762\"\n ; \"2419382603939993361171611462560649281200390612440053944534827125842944774778\"\n ; \"4204784055784266414484460653790149892220936342148543538356735100428170988226\"\n |]\n |]\n ; round_constants =\n [| [| \"23871411633030431908815309679954664955316835501833596382711537998018196877083\"\n ; \"10266075254464775081489705012423357777448464454058081904455633881524670629031\"\n ; \"25330590157378829472296364867033252573045672523068709711474216638118028547521\"\n |]\n ; [| \"17731890776914364842025248625325793211421093305063918487984842622991225662959\"\n ; \"11733994571128449437695833182309936427385843597031955163409472509305883070660\"\n ; \"24434628986405408065629924634775662413138564617325268165975978656343592221427\"\n |]\n ; [| \"24536402423562099407865959531182080003010952879037409125240233415066893274478\"\n ; \"6659347569024195568957991805519163899458248905612848191888227437243439812692\"\n ; \"5960767186841646855432896459128104017951108167445308950169111825889581577061\"\n |]\n ; [| \"4971911842906289673901226938513151439879412562713230347716896457803333981940\"\n ; \"309541453644722548825874753903709706899515232384157286261751156736135339003\"\n ; \"2269569616427699911129222135189454646445178229181823882769580159958019242097\"\n |]\n ; [| \"26993878188558092116624938696043644448548700311708990249335713416846104251941\"\n ; \"24517651748676427005644984612090266723222512573361699639974666939135208353913\"\n ; \"1097726622863402924577966380605322382732118204644384325315739877029330402588\"\n |]\n ; [| \"6426758383747111723734570359305954670329012940529176997601958694540682554431\"\n ; \"21998569714212750241527571701712502925679335862585921971643825857153225305984\"\n ; \"11047558033241019082897471004499357092985291837411225795336191143257516860961\"\n |]\n ; [| \"9093665141362071558275397247216897637652502299054137932451490373194253077166\"\n ; \"1800243967051770052116464993247352026875477402681617776355019059173229087774\"\n ; \"26123174928857348712960596162051313701754733407348331834302644408819678596924\"\n |]\n ; [| \"23812410588002831655659233838637953883343555294778677500694584331113461461429\"\n ; \"16568937332253520415004151553015144261880434455738996526515454547064570797856\"\n ; \"17416986733486903313008211792802080561485956593184988794629480990990241332753\"\n |]\n ; [| \"18850099810484503215488003706456560440897969494004838374239261525322319819433\"\n ; \"11994895177966687446998282218714100449449665604701986885520927508332599942486\"\n ; \"1425492478667258597960503405197195915139351100492375612463171033833952312365\"\n |]\n ; [| \"26851566219342728401327392853793780102411433232004161234295219003581835075094\"\n ; \"344621744446962141869707506851008584085694659330775548168637253712934505608\"\n ; \"27869765162837447936932893631710126670776990181965052553686418664996771747596\"\n |]\n ; [| \"16748261191950640387981479364297758560864676430387245694151916012002124597033\"\n ; \"14637099470938912277872449097875538968878222997977657926224477080477442009809\"\n ; \"20134098049637875993058446069963966007404168258760138083222194380042623128253\"\n |]\n ; [| \"172643149346341872053831853059095100992686236318507345773031309275063274280\"\n ; \"21874843113613945727298268457562401417065305917171338167509212463100548326138\"\n ; \"1700476193411517352507365601977550539756670894414173315822287469432716857784\"\n |]\n ; [| \"1993872240998785476519726097091542582716493962333829952600400285464827481667\"\n ; \"8472968691234464451203870490242938239228570177726710854613935637388109305350\"\n ; \"3164353924636797794161130496213914461962109666565363218256253978570495482041\"\n |]\n ; [| \"18244688836192292124520893341941070140825196416664991549095593577108644921872\"\n ; \"19859999153394936655973233989554564211615670588445691525235383025282647829759\"\n ; \"14768311403338750313336252298369831176491426375153840900301806527515974149276\"\n |]\n ; [| \"25048746858150888741163510410158558227335767837462499905107113911114136816901\"\n ; \"9227230998590560160520502436666565937931267956328463227409811272485685606743\"\n ; \"4696776701448869702784130024458706731441259445875220148105235193026890671102\"\n |]\n ; [| \"11301287347994988321521498920971508070471338636236053007115010700214623134272\"\n ; \"748252891813253856881595793948847132117119525095726183576703279303135116231\"\n ; \"1209563742600434023250112835996756101387112259967014633008182172249296990489\"\n |]\n ; [| \"22609170854153903022054335214005629175374223898873094415826508662474540012601\"\n ; \"5756488621395177188006147242675038050365093553404446887430772051137609241084\"\n ; \"12204891034723523196031315166164117720044397647721380430344188362824579202559\"\n |]\n ; [| \"77948413643208929474117747177500706081858969144437292876038062365116961856\"\n ; \"4819244967439699230735093723487091713222852277599700902443121153586483108261\"\n ; \"27255193365519906102265579122686066635100777748346545926565256522831777732553\"\n |]\n ; [| \"17483513281289738114320990201034187042331906234136726563186654929503890752423\"\n ; \"34539753269842243397370782720638857152602526530856732612587217775462538897\"\n ; \"26670389866012575823645511883620356698491268371217559959046672563897471132762\"\n |]\n ; [| \"6221497512567057828130180875424737245292473047926600299819610408205436413046\"\n ; \"19660878074830892741426544634587706872027677058382555048951769961524177907107\"\n ; \"18156934729803692033361542236751723515055361449102326383067242692178901601513\"\n |]\n ; [| \"20073967418251150136032317311523223358394853170230955059721556689651929220184\"\n ; \"27772273899948728907116549961890766782916787451941456619762132483552045169192\"\n ; \"15971692165674397331342925986736499624826262396209267283406828364924966200635\"\n |]\n ; [| \"16416286997172332555663573131890151419265070164405909524639440666852040213934\"\n ; \"20103224377910718515832192173396139379357815331321992767836849578341263715617\"\n ; \"1992082765658661183841193649461040448653056879234437404013909283532649563512\"\n |]\n ; [| \"19951269645786270967009199575056978741590225092285762370657308905017645787726\"\n ; \"9251473059263374648207691341973093388418035271819559725381912479353472754743\"\n ; \"2444980378309704186211898448086030379464888548066321109843797635753120477485\"\n |]\n ; [| \"10928282022919314114783091884635542308337867197724629946199953660957345275397\"\n ; \"20860003419679976346116549953191442898649396106318245755983695478063963781522\"\n ; \"9125646500493112058936359272551424490842840477766749690227538466206819804312\"\n |]\n ; [| \"20177768780524517369036303031063597036475507744395182409567531978700484378289\"\n ; \"23849136275489209274738706275875891467606042431504310216391474226820256396157\"\n ; \"7976082325486396563438765887430351103212480060205218817888924447342264023448\"\n |]\n ; [| \"21218093079130866432053178184495259038615729811686678720305378508679861852386\"\n ; \"22222629794092576664613127689533080951595674722722217395604438734265291507137\"\n ; \"16117082350553416755654415094185598367594750430516162377370652361756124580927\"\n |]\n ; [| \"15386072248373014774707633578974000489889916088461822982033430186915251599101\"\n ; \"20059444943956181967567300338884496353066968918285957577453937920821326774911\"\n ; \"15969043598280333886921493788703960477679932825020353079985508309173442399807\"\n |]\n ; [| \"18441908288363677832500730109945652708871777726808321883963939341572708678438\"\n ; \"9156742662968671243472647671483446293299984596395820828399187385978257187180\"\n ; \"26117513962333705951186643847036445264112495570596099092098117311469761624146\"\n |]\n ; [| \"9227362126330995448990863192270789313546500545949776416489812561581590597341\"\n ; \"1651638493276735214427785026108815161181550587953472105263074483216056083718\"\n ; \"19754190980633296736565417422427507009115461976496493840015545861722778641757\"\n |]\n ; [| \"24059801258623894209907222963420795819610514468735113836904109681657134646406\"\n ; \"2507773721870400383553935214026283806800287719784543798652125141300020939070\"\n ; \"11545619277487756168659369622509301766172311628766869964453828841442812398464\"\n |]\n ; [| \"18599404251801695916676262627086229256833226846935875794848292474360329710182\"\n ; \"7672585728603312485277463389894405790617721546034983006052523579994187672256\"\n ; \"11663243875044039826255065018193844285574447293546626080552543307831236101532\"\n |]\n ; [| \"3736737114971552038249889038312531109770417843384959461392265945390839075490\"\n ; \"15405041123991166901995181017584204362284350353917954151561434093358377932416\"\n ; \"21190402840771768305757114855125881983900480564766015821826135703463049645985\"\n |]\n ; [| \"27657612144465152844076751970773624300501046484432872648148700499103897742199\"\n ; \"20388430216478368624703227056329193371722737732187907129943643410513691213535\"\n ; \"3344820289563345194933219828087298037081196856323727299522946086140971056423\"\n |]\n ; [| \"8527890306194452597728380300408050856248447791462807214374322801696709074298\"\n ; \"3344453085657711280093205964282996094870704440396012352126082601788308767424\"\n ; \"24129621344772065907359832544790760848535846792550779738943452820186937321016\"\n |]\n ; [| \"16682281929114205892868637273887744852593056654081569289385196216494586052059\"\n ; \"13390546402723680321309451408062261872073917009165123815466701909179323058725\"\n ; \"12454401735435545041240744062413508439776638863019945214106500639361960301753\"\n |]\n ; [| \"22691978545214712333682322509829714302565160720214993370385276444403705409774\"\n ; \"9304194978657396762457989504468955280882290742713614422164474050373984880419\"\n ; \"24518330162580075369755426938387542128644607789410819379604533097820563945147\"\n |]\n ; [| \"7793343388923696013769312876044250715843242497839331541419306365445952124334\"\n ; \"15474893610836752417132140205467036343146784962533163791549972307193429176684\"\n ; \"11116443861170111868320138692617094510473035491476329457635995671799970535803\"\n |]\n ; [| \"16877979504226807061419377389528064425375368470773322489308736865456734785901\"\n ; \"12194411710031950769113984418215809481238312707786246344424020890556957457012\"\n ; \"21329761519619810559319231763677758647122208920134924045388361417919054295294\"\n |]\n ; [| \"15486704070124713197776757158780492106937367947624672577943214567891933787258\"\n ; \"21879500021741312414877635555959377131752915257473724817131516706125013556007\"\n ; \"5043420522702480930107029442863985487527788786987286425206067343205474678396\"\n |]\n ; [| \"28416728565535371153714147767297875894376657006631966873680443521362574322416\"\n ; \"28188295006821213084652983277541040229663295908823345264477158493251950224190\"\n ; \"811696348709499453953485215191565713676093511624729934721077050082968313251\"\n |]\n ; [| \"14655407507725921832105500951552761181971660775931368508685072434505922507512\"\n ; \"15452937371493366546640620581126461399707812646853303452806945678641253144882\"\n ; \"2286261699720696752622655970051026147406838467804385944265035557798199981133\"\n |]\n ; [| \"1992557442353308000623574109100253608701924636766704840114158126271278280731\"\n ; \"21694450413109623921951195958057854484852090181678130751969309977692551536018\"\n ; \"9249731319012017779017326743606194923643668526628748858217378905811538368382\"\n |]\n ; [| \"3939219222555454896586029131514042607480723623744884435463307473774574605152\"\n ; \"10797179208934709183850676357345550930799476411664074421966228250898236909457\"\n ; \"16003349341141317690412220236365636756328414540434964599637729177724750393340\"\n |]\n ; [| \"7139886020914795212662604367684684711418131042431587260958077772503994611059\"\n ; \"14548527492795536984793003371667969667596401576140783527415224992442661296652\"\n ; \"27784961580458637262287375576745710987249457442419641954865148924289640098875\"\n |]\n ; [| \"12713866702735338063343936521670481149781186654485300349666527843472483230312\"\n ; \"9092010170409960335483537084430885053488154353385070704782245279718737955046\"\n ; \"5094923690647683377313391496286927104459466521704225286803035696710155177995\"\n |]\n ; [| \"25569861054853573619838769694313237597861085179963737149403330254183532535529\"\n ; \"5878170049851666055783493866996165172583448340223151974352193778036352307943\"\n ; \"3872169186443882698001210463876163485285999493224352597337453067537500276246\"\n |]\n ; [| \"18665784052407501847083570675839500069230593336210620138506436003881713609889\"\n ; \"18152379076079140594000518889838158343416361432991548307242241800589989006514\"\n ; \"15293096858608991177688271468787656348083923851728718260954929346470077552533\"\n |]\n ; [| \"27458404667733046540990542309129625717764044091884418745028933631962947220717\"\n ; \"8006229583150739842023227507854792176671075468287456095936807010603225964853\"\n ; \"6673337136101970490098396053273218923846658878925354650729739777392657741321\"\n |]\n ; [| \"2866189528434329040657150614965317384179174137415824086986689674293245440869\"\n ; \"850286832335872065552208685923468151432517596206010380489009288659201960609\"\n ; \"826167896454325673153913201896766310675528897953588379016483511428072705149\"\n |]\n ; [| \"11091353885350315399281534279307640099073252617438924758095267005171197532901\"\n ; \"24332996362686645308612352679547748916117510430673097992758824281388269163049\"\n ; \"7697281120418309884363241543849152373040915185661630590946085871626953307630\"\n |]\n ; [| \"26903415823976566965446163261389520506645994486239829395342314389345167145490\"\n ; \"16331473399937436063872600675479075998365344725582239128025161788438169634490\"\n ; \"27478782423978673109458866577304881582710228942880032866222151681880849121754\"\n |]\n ; [| \"9157575957419463790299788535651375681659171956515351213017221629165597230565\"\n ; \"7212846269226025424784660189052377648721231465719295820195086840304302908764\"\n ; \"15079360452490344164815517579543356820049766968077892340838182489029333395345\"\n |]\n ; [| \"2164387758948063499404878920144621238577478053584327446777845938241996921307\"\n ; \"21971530571660454464263042379401691171478093875859848797664553305525096942047\"\n ; \"24996214603829854187327550321668003124272776524258345997409641809486816101711\"\n |]\n ; [| \"5012530167147645132123926239187192574015992833971936940239020886743588014969\"\n ; \"3538797852945828178389690727899551008654641317873025930608250831273186708784\"\n ; \"16351872580375794420559957848346781277378485393541927811867651422570033372488\"\n |]\n ; [| \"6649114213329992677018914668592605228429520774140774692558017652328554186338\"\n ; \"18665440706841919461000547042069933770374154186835596054373579551791088230368\"\n ; \"12068241390808361251909200960327581910129328275585071206860621578629194685379\"\n |]\n ; [| \"15905233165225780889629861680805819536375352205513425939444748949014424918343\"\n ; \"12508454002472469574115566912186222048654143934720930056557327011774683943013\"\n ; \"7034709393479901734220602275921317679827342926959053187089378763382019774818\"\n |]\n ; [| \"15071057763697867068980601577937010855726002209360872455781029717330270540558\"\n ; \"26837903264629473479982710556353240390490167539626299502592215453725741017346\"\n ; \"15815857256588462989339312138660989790088642030075547425161293150909179052889\"\n |]\n ; [| \"17790122309815232908548524561514677539176024837185249994150799440752116986971\"\n ; \"25681654720833964361368816492300991096107229186861423365051433302640152727160\"\n ; \"25092605033552047946753252380591729771370646821844905835767238550702091926466\"\n |]\n ; [| \"9133411374125723094094125880554229361676050614544252095679163115115894136841\"\n ; \"26932002400667217014602216630093364493283860795391062254701152928395308796018\"\n ; \"22106228556612087153532192407561886213520535606346621942342426362558131787963\"\n |]\n ; [| \"9406311227783101741290261235550552478435250008098267151139650559181505389852\"\n ; \"27348341640941808284285285580081335760088527770841163602103782109071842104934\"\n ; \"23559463527614164053397335039301766055455415575615533929384690127861601499457\"\n |]\n ; [| \"5619769611055946079310055282596239209008895876149398331145676663636029101157\"\n ; \"13578163259668232168333668013435506407087237516177382960962039602890195751920\"\n ; \"7413830766934399815434854130814997370862812666201550415594211525136216734282\"\n |]\n ; [| \"13792443813595271204983556094168533754933130020885607088800378971405796327369\"\n ; \"27980816529551052578978463084908633402261105969483057107732537724040827783618\"\n ; \"9086585172488644340339192486024741212137636677834987669856236495399842977922\"\n |]\n ; [| \"11313421680706870429846305787628308653216330618143751161363947025312249024761\"\n ; \"4021066901602104243187251101773896805730813605469425950314405128776613579602\"\n ; \"14767121153557006971815403909933008062947309032922288476507340789333378073654\"\n |]\n ; [| \"20370619771295344300690236727919219226792483779515051540457737461170706414475\"\n ; \"19057013717580762168292421969225077213646512718101800237917624429055981813838\"\n ; \"18802159878265458151106922138846829134121904345009173021788332776013230402104\"\n |]\n ; [| \"24016190866456985740426033746487501435211791016346499791546425666381940738421\"\n ; \"287764449305195377184537313636736253449783439200917075011454826449334249192\"\n ; \"28924625533476565101998318658547220617045362556325453564311201040145506030261\"\n |]\n ; [| \"7599844266964312760321206419543935528432789425869947893826782118191539450266\"\n ; \"27134279976752686312431326985386138880800506706870947398386273393113450719312\"\n ; \"16691817056677639737321251699552704590963223686119737935250825199787652805166\"\n |]\n ; [| \"22998044684431557794791841708335486493573768985622899417439899102757564768837\"\n ; \"9401177121715465262238174135751147495308547205972761175814504972150026367535\"\n ; \"26790130566347368063997033116765929382273650193131343958415387299771850673985\"\n |]\n ; [| \"3677775394669979862889071463502051146295423081411873494668961683260168561200\"\n ; \"15979374501543368828047096104571216535562304582450829728472504102636784119438\"\n ; \"27983949821598015961883988148799706647207081688438954093427232113605924435366\"\n |]\n ; [| \"27544538692601828352117435876403689629911776874104761257423949309268045763185\"\n ; \"26518335501934972769761573274318670551390596750003847775195848446258018442847\"\n ; \"4394131430649458263649250511378672198908409479410475627536485368480589477325\"\n |]\n ; [| \"17852065984807648650789061534513315071882379764409167220327155188497750610044\"\n ; \"18175119138227704225937550148743137184987075122850987480893509516338237125431\"\n ; \"9213947738410262749305252213461572203334592178012688401993745223133683403178\"\n |]\n ; [| \"27122114905718250703139963834720424986105744685568269961612244344496328439886\"\n ; \"4760667796367744574889553071124411738303713877930746202875952709775583533416\"\n ; \"6869551919316193097108785401949737566268346424578556997536454243546346759675\"\n |]\n ; [| \"23037512317774976799069981329205938965143927594538311039095844313686020797562\"\n ; \"5054896342931452597037605872652090619656314276168870046892307499425423949760\"\n ; \"23203714262075719720359794801639953965353238316905585901583196491094684440749\"\n |]\n ; [| \"28934221989290923495677613925521064896104825372643558590174660971609344537462\"\n ; \"8088721343567483152949374218613505786573889657303344700058590499312426775261\"\n ; \"21917953186139856111153943474716456656175171733392297547383518245334653482436\"\n |]\n ; [| \"13961331694190054971056058301976924809966415553682688755720832242614168486723\"\n ; \"12544911152480935441357195703690990795365136419393151814200219795399220718629\"\n ; \"21695520803994090395949407367250368059907198292643658069384062711565918112344\"\n |]\n ; [| \"3716150465866919736709076695055976565597785970845650354410730126658608015494\"\n ; \"327336957994661404033945962575518119150720065183392456042720063992483355163\"\n ; \"3665947140103366584087139828849494245835014110441785513464272098210192613654\"\n |]\n ; [| \"26369492318428928735445021592697190549303995382614357682017136715337112747935\"\n ; \"27749815921003845385723497945745117881231921684907697336156182087899053510673\"\n ; \"10355044492217226758344497131673377893070994153140912920311451906060821340248\"\n |]\n ; [| \"4628431130793759981513415398028190279858542396207977476299170127225184781705\"\n ; \"11394587544387541452118107143659899713641924256823223827419604528665720745426\"\n ; \"27501113180347337346361365060944451586249867412705472720376921357546323344395\"\n |]\n ; [| \"28278837938314100710292020893318211455155607281093551519038981321116602349373\"\n ; \"4157302910095235339431818149458321721626091681389723550549352022675823861398\"\n ; \"10647753346148135279439456095440861046789212730332155466632561589399089133326\"\n |]\n ; [| \"16276422291909940897533508339274805427392027844787029744067454575137039713632\"\n ; \"23729032431762932898115881024840919797648524831708845029533918801044987536615\"\n ; \"22905612910561717552380974405189058153230663615322248220713638543054825797666\"\n |]\n ; [| \"5444504530356500737158011550177553406072045906791914738537751528417224842639\"\n ; \"28510386747999403469810407444832806233927676089588288134899522943795774693661\"\n ; \"19805413841948596162239177018362584237164470208997373794301520395085284750539\"\n |]\n ; [| \"19122547678583805564624026606820513504429328853794128995861987147454516637234\"\n ; \"14149390468608933390700184668781640373558946294178094543601697991189519008854\"\n ; \"20866357658195086764903364035397344007481887992484022195436866986726691198910\"\n |]\n ; [| \"3091400614672562681643141264311087165471646584668481415815002651728679925334\"\n ; \"19494024337294025984052821389584821264663721932805988242535888300060571638572\"\n ; \"17644592732159647749467251733367874632398437355549297444150061364959517600595\"\n |]\n ; [| \"20396032354914064522098028139725361423909280526354910804413358051025918529619\"\n ; \"8139121339158552499821459368548404840589616792874943249851117821336073953085\"\n ; \"10922434269468548872208754791993251262753058094227791965335951350558389242990\"\n |]\n ; [| \"15649912252593120246156581284146963323803608017723227709583948225917889870238\"\n ; \"21372394998583927818008072510481270840383010669604639655072625570587680791691\"\n ; \"8898065452020133817419600668300082490862298528579716847829659770466997068972\"\n |]\n ; [| \"18650547661483668504889775893476275079031609582673355265573607371710055926487\"\n ; \"23618674478465955845441421736720381271262239925598902631963493613481722447464\"\n ; \"12891746797231517000473007152761525047439710094872911258902687687042685332250\"\n |]\n ; [| \"1833893631568920050533599834904970213411923339935020486417653785575000615143\"\n ; \"21710180770129352998141024499580964469666455613123734716169584679669510873775\"\n ; \"8320010738639970594139541432443041967828948675894027397631123863826975291437\"\n |]\n ; [| \"20373837152733625366974701596758373355440504238040809868686624790270197493528\"\n ; \"12781438644864943427350664202279855672900381345640622661363395863727232461941\"\n ; \"5622234659258862655204519959448765784253304067430902712408596795866706826032\"\n |]\n ; [| \"1029291849649659108434334644503982141075719243675099861198550852722630712209\"\n ; \"3399484996504249361098308540916753999551454215950119214258113924944098529133\"\n ; \"4228806379514872892076346437718106945625482776494389450700910204388632399170\"\n |]\n ; [| \"16757668050571560648475639292687013846146697092325505133502515482647055695358\"\n ; \"18015084288230839372033169918933220044489391040316918002447358599016172874588\"\n ; \"22518355405199157615512407427389375489730975216718755365792251880852001347523\"\n |]\n ; [| \"20573368860115893940170639217949296882201199808293037762710789923980031371642\"\n ; \"9960840295218443524938341356473179849353725032041141822502293175783147220810\"\n ; \"16607996476430852400280109630637008547605338554739450722762338812055064961040\"\n |]\n ; [| \"7171658568863901784323661701131019863889729147856087046438022012589987643202\"\n ; \"10419002933357804877530761113458274768874412386136675204576115138741608012739\"\n ; \"18861306008102317898949274209011264398227868370415517665809396034224603196914\"\n |]\n ; [| \"1158669061044700880156383735717084681300773582244764163190588381073092936750\"\n ; \"22580910367253859335421514059655021468195876007209097419255510855097011721727\"\n ; \"25227641011701829958282079681052124431202635521215558068499733331989655141417\"\n |]\n ; [| \"17631556489231839623790313532079202613255385273277758734940753078216858815087\"\n ; \"12364579808565613988949646111979230705580282638991093972288646497224214207629\"\n ; \"27329142993476341161848962227966301919437953833554828144399467978240930742586\"\n |]\n ; [| \"18928954276816129093422581186438144214889196137619925522418500128918638106192\"\n ; \"2694991762120052049414391511440055444192349820338943254217225671225856705354\"\n ; \"24550218467559691781293396903076544150117989130151493573851599275085996606415\"\n |]\n ; [| \"2263637838316531719424059727023190126413315239400030877929788886432292775329\"\n ; \"17640968677322424538098309260107170953689147177463962461922714776240524875178\"\n ; \"19443928844574086327434242479460066104315747577578735497796887088983936043942\"\n |]\n ; [| \"11946837349828339651553745139029680016817294186050265590839923356905805035357\"\n ; \"22348022813139862849068148377528486325131041514035743832201785720676226808476\"\n ; \"26916778334032102178669575567836710673110496650392713945070999799105131256857\"\n |]\n ; [| \"6772367578799449199630493680882624055636516414598646521039901701866152406803\"\n ; \"12963643276721087785826784687244852783616903441339291312110495293886231701342\"\n ; \"3495180091566437950872177051556773503914696078922351249973160522225629648761\"\n |]\n ; [| \"19636722086015988900698322500132161186603083218895346390169893819062129539093\"\n ; \"5666220019570366878592707781772835552094759159906603422414363731979336135967\"\n ; \"7874102875783310620499310739194930556976996287514313823549459686051373482140\"\n |]\n ; [| \"14280578027404451144128482988128079454347604231057136906257574339598355143304\"\n ; \"5144471065355127918389406816656570319104327848925794556365711516976530276907\"\n ; \"14225884822276867436898370040228402906367131879332823332133680447067984518507\"\n |]\n ; [| \"28941268628390287870660292646709031665780090480358777746775844529193861308069\"\n ; \"13377111905191945833969566484261585035643984609846866899463874566132398229000\"\n ; \"22564078765828517667859311123307256081299021587637307540298808998440794108520\"\n |]\n |]\n }\n\nlet params_Tweedle_q =\n { Params.mds =\n [| [| \"25915736081177016241546598112391708036536987432422305635260260760208122221944\"\n ; \"16297879259961607025362014922234140032361260365432098634487800168878994764928\"\n ; \"6033733257175634837476818019847848256912403026667817175660404282168388911176\"\n |]\n ; [| \"14045886505657516091660160567697347035599074026719425910347091110613125329282\"\n ; \"28063323679221750580410141978618538612191923017649765586082296380600660325013\"\n ; \"16819697298174473653322938069684433995665518997062997223549599541089417145617\"\n |]\n ; [| \"15413524273045791515306211887939932559344561300389872507948116835986601106260\"\n ; \"36421043490025209186163871592492585408887527098720780722489614383638192290\"\n ; \"19794181301775644846947316991663934780462668882189182094267354309951373752713\"\n |]\n |]\n ; round_constants =\n [| [| \"1407093205071385134019160203229442695267924164910042285561052671714302327117\"\n ; \"11779724282856814171131489762288461172831486048510303387508269258305405159494\"\n ; \"20501356828629986222924519680141334519157249096910596964295651887901812757851\"\n |]\n ; [| \"23419085236318922177448829791267506851321183371308368120588907466638891990218\"\n ; \"23622615725307076779847815917182329276803050417362884676509671384840820735432\"\n ; \"9803250007852134109663616761249682289000165070757264268444033227122154712435\"\n |]\n ; [| \"8258125311635369235384004583299440393524061932038233801638278824513198056900\"\n ; \"7351712538809193694641892798746315547120734114915787568462574210306016208172\"\n ; \"3059129220572147109518378560013963561504677918762824375487834543428745926058\"\n |]\n ; [| \"2042383557155251217884643242454382272036567754448083296933565675865119461967\"\n ; \"15129675271994104178514880712320024929034675263917539062120100905141109232670\"\n ; \"2643699531755105343660845635266167445623854478292984863437116378029552006216\"\n |]\n ; [| \"21874906039195160027003265247067314884270948612748992177669773940314010123091\"\n ; \"19764685963582912390728638382178998584043501872176444130158409984862908383367\"\n ; \"24731701819796788156889906156124721070820824358000508514589474587782991304615\"\n |]\n ; [| \"23349997101843053192913636118003774827214499818459416641628849125511955859433\"\n ; \"24717674860585372478964575915011580548457995997758548284742988139987280611508\"\n ; \"28526106831601024593647394922551831336459814654587212090704645596629587939482\"\n |]\n ; [| \"11124237076008500471717934253870630742394346079041199265139475769025505862924\"\n ; \"5603568104404435184153167261671260274794550222989896759977234085169877356121\"\n ; \"18631968134615245163535085925543871536654560418979608277352837363265788104887\"\n |]\n ; [| \"25622000111684154876169657771818113353862466658383499382458602104118482932612\"\n ; \"14685553097248008037900441153689553464954749573708220558483151708440673116626\"\n ; \"22638290793036874494380252722781129323329912946279958525645948986012903271588\"\n |]\n ; [| \"26722642316240919944771155748582214575762636956156192045531407557947082330441\"\n ; \"11688527178001319047781582359974030014986749568962572618484185726534538143302\"\n ; \"4132435099492261681531450855031935115318187070155419444963918466294918478458\"\n |]\n ; [| \"20141284225901340938890656022639520931541470876509036146369749046098483015757\"\n ; \"18736332138502980964445308743240819782522235173987082303305443804684531454297\"\n ; \"17600693717098925665126422004940106422694608593016843967562670357150381420609\"\n |]\n ; [| \"18592614129146387690177360441516834331069369945676621261719641293117078327702\"\n ; \"14150577074637411884886261168762693600439005064514241836521926118301097417857\"\n ; \"19031036144447273288422615508693769842934451415657310442034112526338125336308\"\n |]\n ; [| \"26053352781064856963576604784372156952426155549559043326273302769112379165473\"\n ; \"12778639913079427028917330759671637587295979742641290726186546285252525246028\"\n ; \"21084419118692958743436020036593002996130380427307664962379311458126599853734\"\n |]\n ; [| \"1683679732388236007430336774551658766186300637910023597309960010871812663155\"\n ; \"382382265518823882035704612421171594350637534457994341641249505478238999843\"\n ; \"24103231983573822934379730503341131278940831646017600293219010706164863268100\"\n |]\n ; [| \"15002924105159692538984514753644972208898096660405454273558411866368262628713\"\n ; \"8060462184755100984999826027229470284760371993470314636251170461776357079944\"\n ; \"8014397154910879842052615519912717212158245202057892272449783600873015574114\"\n |]\n ; [| \"22515836383808274667935072370173638116426359208031587416631515348588332802165\"\n ; \"16360177906204352406408982804994067585455569983797470664902705838290946655225\"\n ; \"7377024122149545148833892203521810447795322854651603924615290711324827954389\"\n |]\n ; [| \"13822535231889686674929431810384661533456403404275348094834293881078653521828\"\n ; \"11336050547636194564207457615233402475265718541062192408495224405268258092008\"\n ; \"18805821644425041501933345241847488386094077373308766699152348641373866215637\"\n |]\n ; [| \"2953706678908410496027875422038498650868917425939787828661796632154883847146\"\n ; \"22240918382283561059183778204822808538520952332636130676150942209160161480801\"\n ; \"16015663662903953014672458804500981049100146349056166187951058089247981862386\"\n |]\n ; [| \"24566120104055916417636960820360051385362045582201684271866443305615866009754\"\n ; \"15228716568582234525417425530930303055506743342549413293218302255768537007353\"\n ; \"28426124059260498940560550539619538039187481771001333967681038135790962915359\"\n |]\n ; [| \"12599554983931780658667521993267051645893868162155451498896637831795673118184\"\n ; \"1743852770826535536371230785504182299307419480962231494027537273484933148311\"\n ; \"16732518316750597282164750160114357349321948404345032126728303794088049194652\"\n |]\n ; [| \"2939281672959978006600800750725734354669446788664764296199685579097815688131\"\n ; \"556549314727718724918645466738763616425350766385166232734551188399043650782\"\n ; \"6329117812888271765311270770521948075037705083688439409207121873030159665123\"\n |]\n ; [| \"6923365867589651412567397268415595797793475737512742162240319715473926481537\"\n ; \"4709424083348196884624344278997759837872647743148178850362091985071988205427\"\n ; \"1605876544033197953000953983514955993933721338350067171290806459066306025695\"\n |]\n ; [| \"4856902810419335425286300966705023110125381957049978608074194350995662024158\"\n ; \"20115199687715104656653685599631056012389662876070860842940278390288575808663\"\n ; \"22603228560902176600736298140950778622069342058615699936072284883863656072632\"\n |]\n ; [| \"24638889469288846994071707357580162402582890839221549302411376340642923220642\"\n ; \"8913206227935260631493024400945766094870661822141101533706907528294845461904\"\n ; \"8927637538483897027107933030206270470499387407187148996083180177802476521625\"\n |]\n ; [| \"25384650098348911768966273053118959028169194481031323865282329732266030144680\"\n ; \"8576715726771771074868969966299138879569870568699811773298590613391459414307\"\n ; \"3736564798057387316276742408343458912069444888643530254776791689428332583857\"\n |]\n ; [| \"20271224536548381827255516591952574401260411805623699585521321246109241454930\"\n ; \"22919819358488746629260266084595897095209320929848482502446393294056491878897\"\n ; \"25806583473442384033721287178211835499298441266111076622895704944892288698730\"\n |]\n ; [| \"11271425654462192981130104009501267954567715499141722773571838183810298369617\"\n ; \"11963379853558729949243781995772428902494203393999693908696977832618218983729\"\n ; \"13559702535330349895320048426685665280396765028909072427284399240094315358267\"\n |]\n ; [| \"27798947305954309531282132451491992692211979630877274468503798794516296093624\"\n ; \"10139836872400883770038180190686397055576624900289129633646571009821193103303\"\n ; \"1681175063131614831383428140062517416675656042319902366945851342455320095975\"\n |]\n ; [| \"762311789472828450694939050895584869062612821719579283252590387322583966709\"\n ; \"2491291459395889912950418486840554679531585085810901240245257580168300654138\"\n ; \"26335391344920052134408519665978324228030775533115901754595026922650621387203\"\n |]\n ; [| \"5213934155193667555020919712276789476025967849892310766358967009263904788906\"\n ; \"21596654192879006807545262299640391626541355389417053174982949135914632601259\"\n ; \"11543651420409105093285035822258612547933041509768934342943688172902948155496\"\n |]\n ; [| \"6912476548173319038280387824458412456324099644037049670165470126637201776352\"\n ; \"1249979215389391088361432819941458017849901973474233553675756693352168310261\"\n ; \"8800672549391869855287240050462700541180857572619168816793782094195159154680\"\n |]\n ; [| \"28839355932304714762685479310377995008738258609935766418698284661589499598024\"\n ; \"9159710460329873378525040285653524567247412401936807205880030247592503719192\"\n ; \"3169998943567105341123452675041701435607857255203848874399754618805253622740\"\n |]\n ; [| \"10847531416223195148660243132827532434469902981120107367281282638460589851312\"\n ; \"14278009698362110794389980561773702824351567830428544578500093225142170712282\"\n ; \"9939277074183953713358210481928994846174442435889738896177490616666695764405\"\n |]\n ; [| \"326943879771829400219165757090427396897467323936588117324383366036029433704\"\n ; \"9374630771131918886890707351323606275428692663736893032376887751531034826056\"\n ; \"11290359581308816011059133790190691320815711617432693226101285885253555535565\"\n |]\n ; [| \"3911773409691474638225302262361438181771774863685935030974147227178932759469\"\n ; \"22956796290890941726039085400420127418179229593189943764136263359967499205095\"\n ; \"24905285680262095209614295868376139501135921243025528029309869104981722146091\"\n |]\n ; [| \"15396187849300264600949181619153171915541270808841426006223982193824166071313\"\n ; \"2021103552199756934225861737484570471349644013573281450873950919842892776230\"\n ; \"27806074863915516268783086994108941110298172438899852542592001290302316983529\"\n |]\n ; [| \"20850985044745265985587285429983550433472508184202273658904387230312500935146\"\n ; \"26750188037261381177305438051189173436844269300804365655670910061723402311840\"\n ; \"5346322587722845563528031827169305184007234875695836707960307122364690080342\"\n |]\n ; [| \"6220486513127683592919002338026088751244535283268014603675952476125549409312\"\n ; \"19903676557766566961511712707831152869695369024367352451363145661501930906935\"\n ; \"1180890285168209978184781715739655933965222804468162152537914819015316336929\"\n |]\n ; [| \"14777748415006576804127517907788573988371775407557947805900937323975909847953\"\n ; \"20105710741166769379631189443035554033451548978342191459802351018727518338375\"\n ; \"15000279473920339785489843141790752670514139742561441953224274301751356279088\"\n |]\n ; [| \"10845580737423146858413611539996656798831260499192914333052323948287095325896\"\n ; \"9807299453661141796892511560669448305233135023678812710641622817525465476789\"\n ; \"18820070346872194506701007873416449730211513161354530152730232231128055179020\"\n |]\n ; [| \"21552635109132824636995550194415349978714050563816356406378271654768042443914\"\n ; \"424252812084212000584148587569013716105926976846895922827871912164530554017\"\n ; \"19731111636912344832419806270898792823432039785853920997930198140374517037138\"\n |]\n ; [| \"22034227457855960657032112217714947497269347815575055932350706059498866808825\"\n ; \"28900549436482563321706115220019073654618056963014478327301367425569435393025\"\n ; \"9690323567346977726143631917040896368566497117131585170975102457752911385070\"\n |]\n ; [| \"24901777589153809722090856106322215040853844303892027345081846927117655474799\"\n ; \"24618629228062397341252905498799061176053328430774401516486784312004562743191\"\n ; \"28607940154394052066154355049458241016994677703128094815451893517962352487603\"\n |]\n ; [| \"28028628276659162325922057320540093432599391103119722511477699756313028345898\"\n ; \"22855357183685501398606162033830514721290735737703014103574096507164859341813\"\n ; \"27834367819357692909285882545810100377631199500915361384737671966983146025809\"\n |]\n ; [| \"1152586797671427538966496719385915934546059520122802470413322678492958894682\"\n ; \"508384107034063705486611598325755112413731704833369868231768120077490444630\"\n ; \"19300657361561951607131776332671479212098250434693263049514294780805629653473\"\n |]\n ; [| \"15470960985350481400842167015023775571355492800121582793999502093397427698383\"\n ; \"17720942074350206208330220964590971549266016335665304491607989853024314401251\"\n ; \"28851134571887486837044103758388058466256575668947796957305978438699899353287\"\n |]\n ; [| \"3578785053164294612963526112344478663211208096085744338409755465254754875674\"\n ; \"21326437066553963598520552760114586864776638322466352011871692222662384645363\"\n ; \"13429745934270095487255860144847939327740721270623398376981782305947706095670\"\n |]\n ; [| \"26319050026331552836426774369067652650059182744902567571224496539143745005789\"\n ; \"1078263435617676875695007120605477838039487913270059992176509301150569425787\"\n ; \"20512958822951485066323868584206248027312484777844371817239233161574729401619\"\n |]\n ; [| \"3439862210936907243622471091733755342416004198449084092526552267425888891334\"\n ; \"26344024615038835357968358502500389300221110985359344438627145422128854936010\"\n ; \"4407509671483019180323111663733989542669030294423331160640503012574051046463\"\n |]\n ; [| \"23686502687109748462558238297713453205336655550865311005650407347470798706276\"\n ; \"20935865617522634258880604534809753050761951325231883554583651243657755177384\"\n ; \"28068466419776916874263313788106583531149883580106732537932576845496874610760\"\n |]\n ; [| \"9340583216031797210406121496934538779821608465213537538754368179509091190496\"\n ; \"8378478185794583011191561708485020796460113225246093188020296866408689405447\"\n ; \"13593729876983630500293152970812869181694169206857373826104652065849275824904\"\n |]\n ; [| \"225582802476164593958918341784756417052231176877435466478201328339339298792\"\n ; \"11190000628324239936372479652026730262762535908110580922398549511844970564726\"\n ; \"14408510109047970600383365920163973974300511112581396474451952115423633760669\"\n |]\n ; [| \"15419712893693617903799150033771605514243986042167614240262941635002474003403\"\n ; \"7731439925760230991749404015249576908754514348048350297750723620909282729431\"\n ; \"19666770682774865023295895307812388197776507921636129891377759111914829255638\"\n |]\n ; [| \"8087212899093356791510655283154899277086785698103236127882829927797366304828\"\n ; \"20433944315277380264641847906582628806193939008300369182185651050982835630279\"\n ; \"19313210645126659866795487832507797079135783289793587088105157706081916299559\"\n |]\n ; [| \"9123328805166387524465533579226697545839760827737590290669661663774141633743\"\n ; \"3879879306261238409785977281757250639343229913301993681022375404219618433235\"\n ; \"9517409716012760917696192179044536803939394129766651220028362590735480122573\"\n |]\n ; [| \"20332463768718929699130730432447025575189976076426482297440430469341755042921\"\n ; \"23053672884236177934514268600149479745125027580775805056144654269680148757624\"\n ; \"25226946353885521968414981773406166683897441042573998588821906686512894266029\"\n |]\n ; [| \"21175609603299698220053961274718080893444373067044100451463712419133495237612\"\n ; \"9553694240553762923597118226736247618469252203348132132110825914961792198835\"\n ; \"17843854580091429191163038608499805869715159461506741160730374911681651289471\"\n |]\n ; [| \"14269966061002750716248007081424385164175906346684599134425437034554624251236\"\n ; \"5362620995145057363259413950799285152609317352806427035690937773014391566299\"\n ; \"4205064533075248547624548681629884406823264917512221686783667975932358100596\"\n |]\n ; [| \"1447928410709031033534935853216514556147486755632766593078722977427728960730\"\n ; \"28245240921931699941506083221177914425757254840948018801597419359119971216733\"\n ; \"26525902932142017663120008236364707593713540498564605735573010501454347937720\"\n |]\n ; [| \"7368631296987951000711115613504553604704592237398914353915901403543114662889\"\n ; \"5554881053965220973295749123586734879290036494602787556161693926447302760390\"\n ; \"24967171202016264042634677694667363841007103245517469364248634966946756557992\"\n |]\n ; [| \"11573826089465863056429265227887713664716641745106347139398991914839486636523\"\n ; \"1937718699958481554769675564975554369566343919737475668546953656937087754563\"\n ; \"11930922536251020493907238369241004043321211518887691790013224522248735046033\"\n |]\n ; [| \"22785017658870359000526032391904855161537701900296638953930381770914415145341\"\n ; \"25976628305796286420142020978093161249350138636110131585936062956834855313329\"\n ; \"16303236307764870561352823146290518191951038219791428310990760657710142544538\"\n |]\n ; [| \"27093108982678491292736852279722292369809241753037402387831341673617292355433\"\n ; \"7240163250117019016769197875995700032806501977645639130984508545602324096827\"\n ; \"22203724525852948038550437387972982668395471437091775649961488356662998264151\"\n |]\n ; [| \"4684246545018636131749425719987566020282183864196151512373949996479685177204\"\n ; \"25146969866420782139590198915491672984778622065064131222228045794185882122026\"\n ; \"27592425452661098730505196328609404774740926022433368462118081059212268546033\"\n |]\n ; [| \"17586009379821990524587867681671154015571782654760878221394286500330572879956\"\n ; \"17466109782412583174035666757463650324907665895615102404350838404505294814861\"\n ; \"6801099680371208186449438911369486272231733437775451500294923992271849771500\"\n |]\n ; [| \"14709234089749348360616371037761032504562743719673952659049173960937006221457\"\n ; \"20550184887334781662092751106487190173000191851604597380877613197870113909079\"\n ; \"28406290890506223928300453112417162962784806964069027890524481548485194752847\"\n |]\n ; [| \"481714770023051785525400834238336329808423276768584726829869103876837700377\"\n ; \"4020991797205864659257764480061098490500855823437474389403990553320209934398\"\n ; \"16337095167623579562847225379575824048052657014596464618336659839371535688692\"\n |]\n ; [| \"23217111278739825984846557926350102803991056777137304871503782411490597852276\"\n ; \"12165535003710678763048152747651928445434323221944097116678948970350369208929\"\n ; \"9488689094750447786105144162385165112898472220919295987197253237633013659895\"\n |]\n ; [| \"15982980312773671675473213613073972898714178082762602910121113887258972139946\"\n ; \"21878657311388335888708327724490657766902944759667044620416025845959804126630\"\n ; \"13675090710467970179628129651886021836957928350486496127049130621993923573755\"\n |]\n ; [| \"20917518447937574010663058701489181063333313587680044759711243380728520685863\"\n ; \"6170213040301483568981693148798365424121650111680781917289361228522864615996\"\n ; \"21775919999815502126259344494851143760329007416636852564546368286124982536695\"\n |]\n ; [| \"24368490522730194755777521472193388991367336341364002103399150275833011922423\"\n ; \"23758037332911549734847840203343330629256629298188143399488142378421247847690\"\n ; \"27571203431800228771338832670745356383939659914478358343820683195821147658740\"\n |]\n ; [| \"13755890941050195595545518932064686480206338615096777475340391971161142758063\"\n ; \"1146646539267290799737842332448542194132747795692489481869657131476583545261\"\n ; \"12804413470423903667943767263817101023115585083457063162343920360142649266798\"\n |]\n ; [| \"14409531300005419187223363160445506887342750079089420367658939335895822993543\"\n ; \"17814204056137953075459933026732902773040596329028927521838357681289997118113\"\n ; \"7817950203232955618618957010364419159456278143380878513604058657652018062980\"\n |]\n ; [| \"25960264684815433578190462022149634694335702464818992353329781703033013233121\"\n ; \"25759640500090985800437893091627346304260382311106694139575298427306966520523\"\n ; \"28367407529609657391892674962602105816261356754665670959257133180337999840539\"\n |]\n ; [| \"14266800571483937742793133924056626153889815742052966634816685646807339508312\"\n ; \"19127339481560024189602206365457486575195002728494501053095019117702139872893\"\n ; \"28519789563308940253093752790854817966629126140155280689836626891738001080737\"\n |]\n ; [| \"6956040341676069594538770374637867923851690699633394576277451833826951657961\"\n ; \"21005839334445364578511922473026653470661503168441639424115223139672665178130\"\n ; \"28315945273881727033707996355494725432549327504432844662583768252508930919892\"\n |]\n ; [| \"23821368050370699560443847027609270446880531147779436118159731211758008434917\"\n ; \"16481474195192864226077436336148187210130651787958956807674920780544075759296\"\n ; \"9201162478838874386717176037702794693750993812982695310231747629926752684935\"\n |]\n ; [| \"28632598467805640977248891280150694716252721359271588938464824193707123356074\"\n ; \"26685464290112784835718410452005685502357915255553654159429733217095134319675\"\n ; \"23238436156616628957271098742219023373736106288667637787431116054734729902810\"\n |]\n ; [| \"11100700451337429910479488290132218019001384186778460632129760648736641453089\"\n ; \"1514360569355020424898405719576361021811778172693203007691280959952152364455\"\n ; \"8340047814157949706510940907075594981467165368035215496966506269014211515161\"\n |]\n ; [| \"2427640653249618892553580189088976454401710146993511837542094625722279344011\"\n ; \"13594733327028460655848011453697829703783521855510653296924838920678502849608\"\n ; \"23299557907058685778984064294190866024328373590131005250950142719507348823505\"\n |]\n ; [| \"16957366136159159628470985738911466666552608209993423872602970163277075193826\"\n ; \"18413473853520613049315131192841305891076833008669861411383562686504219287358\"\n ; \"23006926050889222476128897576830486416666235970076803315213892539278411622015\"\n |]\n ; [| \"9774905316340561579539853883151948424138741303135183297579387042285531085133\"\n ; \"10269962303207382593854468302115992150940915300353510160768219325150644267118\"\n ; \"7959157234270969248940923336563675290410277851870343572948477386731238161393\"\n |]\n ; [| \"16106024964504098503571852149534027928523108637339842287012373190722613251659\"\n ; \"14745173385311451223498911097599033554863252099869795844775385009273683860264\"\n ; \"19937960969760569200449808442711281818884901583558873199752602417155970563987\"\n |]\n ; [| \"3182366146375526747362994559814691338395593175949415378173407263876720083397\"\n ; \"17413302548292738580314411603626834416295685927950587784515273510105438873422\"\n ; \"4889919393105279580426440996922797206571373750340190707744646290242059542853\"\n |]\n ; [| \"12846868702289135169703545726353247801195875942556949295948719366264621666233\"\n ; \"216026894661943610141047365076631027216797294256741428193225490408409896066\"\n ; \"5594507038710796719799954595203002154918429779115131548267228293545608955934\"\n |]\n ; [| \"20683325187150331608421945253309437504612179745536037022444222877738935657188\"\n ; \"17258155199327171857088567149720370973460517702673221805327154937215155098037\"\n ; \"19531451346903375647980488842525266722395393577734760487171780808563121552715\"\n |]\n ; [| \"15001316252470008872398592005036567799341341008679319658354851032874333308382\"\n ; \"3153366364932652911576884248299389708958131128720414599588818761136290661667\"\n ; \"6755239607153943600624506592209826209761618621309160929893160538996653160964\"\n |]\n ; [| \"27386913053417648783169595109305635785586212401824032172587510910095445670008\"\n ; \"13255419335681899162220762381979787288418216927844199356802168847207218078328\"\n ; \"24056932697318807312802542300271008041574260214121915600042800629313367235460\"\n |]\n ; [| \"681706469194140471433006526218256921616949602161281492934799081124952223492\"\n ; \"7859466024237704991714057608591467007441884809553786534483120034131115786526\"\n ; \"16700668341177433681838948975596616692527529309395474903935090736709940070878\"\n |]\n ; [| \"22901316653569929238119228745362176008602504925113946861459962514753719309663\"\n ; \"22640283367220911539563798732800666806616130576227469449706008775827807382817\"\n ; \"19535281588527177916573861327698030605390832518994091195537441015284187660038\"\n |]\n ; [| \"24027911193734335746676746844040947617820732337092851583866178947775548114262\"\n ; \"18133232728995811983770470174587129261332348411742016303225452920487624098342\"\n ; \"5194749654862040835697949936835668263923802179629880492924388865332422989363\"\n |]\n ; [| \"9316005463786577585413113516915677504827184958655839058352363543312786833160\"\n ; \"19044257614252585758763026210126521817485691264322479305708941715087727988354\"\n ; \"24488455675278660807809390650162487037017599485528141481545441190036504950534\"\n |]\n ; [| \"20189530657293446691983795945222508167625355746118650082940427940595276845732\"\n ; \"18164715324891407664606312435855154695754327590709603495801185914278567423821\"\n ; \"3777285533445984127387924239502713396887498568124548831616871789655039173588\"\n |]\n ; [| \"15592830182691848850373386427196961486282012390610273530420460470172877717683\"\n ; \"25760859528166610551872518774575759523111878433095409331041961249196989169616\"\n ; \"24722046352010883056709269730597243888430933191481739010765617998146349934086\"\n |]\n ; [| \"28753571052849887152802307457879116732346031260848508112338593673454875118992\"\n ; \"3001384261845987887110277211273546956213661938635022280612595622904841185681\"\n ; \"14677009419547603678203788843515487352782342288802842850372444676527117589395\"\n |]\n ; [| \"22844611608619408029685336179217843453642421101233912107898751889136663864792\"\n ; \"17906137102637384489732199749359922643081810160900805140716991796711023316200\"\n ; \"586544213343455846993111183121079851951145071960141918284223009850760128570\"\n |]\n ; [| \"10073022737051199071936469142782915912111557650707356761559885949095600793223\"\n ; \"18767707439586621911012683484743285554245197776295242644551355924169214852141\"\n ; \"4119962398253504109413010562733363762918650892359086980174059883847160426733\"\n |]\n ; [| \"22822667561075354253870135521524118501968910357712769905157593725117077725730\"\n ; \"19021134546417697443807407377942768385512805335328886525219419127991328099808\"\n ; \"543520545955418275520704370531208732549254996101593838150191956610790962041\"\n |]\n ; [| \"13465682039988507334664785354077591628283934378748051390584708440723246405022\"\n ; \"14968258475921764664246292128413258686551060309754574320898450232154678954678\"\n ; \"21308271006956028514569991019983954873714018423377636189886404602491045197837\"\n |]\n ; [| \"8144208462590654621513596158704608446866068401332835980335197042714849642337\"\n ; \"20834284501721431645327510539019601687008489803392802952240179181017009408562\"\n ; \"28229089440547774816202807517944174133449953515318622356237408090506536035121\"\n |]\n ; [| \"4701139152778460212311525289989698272661680893554566356761097167593286071097\"\n ; \"1311177055788535572979185179079106285448805711141806719704208925309029338758\"\n ; \"15261537101227695093574937572139198753629872383884947512058428039104133367921\"\n |]\n |]\n }\n\nlet params_Pasta_p_legacy =\n { Params.mds =\n [| [| \"5328350144166205084223774245058198666309664348635459768305312917086056785354\"\n ; \"15214731724107930304595906373487084110291887262136882623959435918484004667388\"\n ; \"22399519358931858664262538157042328690232277435337286643350379269028878354609\"\n |]\n ; [| \"10086628405675314879458652402278736459294354590428582803795166650930540770072\"\n ; \"17127968360683744052278857147989507037142007029142438136689352416106177192235\"\n ; \"14207324749280135281015658576564097509614634975132487654324863824516044294735\"\n |]\n ; [| \"3059104278162906687184746935153057867173086006783171716838577369156969739687\"\n ; \"16755849208683706534025643823697988418063305979108082130624352443958404325985\"\n ; \"16889774624482628108075965871448623911656600744832339664842346756371603433407\"\n |]\n |]\n ; round_constants =\n [| [| \"1346081094044643970582493287085428191977688221215786919106342366360741041016\"\n ; \"10635969173348128974923358283368657934408577270968219574411363948927109531877\"\n ; \"18431955373344919956072236142080066866861234899777299873162413437379924987003\"\n |]\n ; [| \"5797044060651575840084283729791357462720161727701814038830889113712361837236\"\n ; \"931288489507796144596974766082847744938192694315568692730730202141894005205\"\n ; \"13659894470945121760517769979107966886673294523737498361566285362771110125394\"\n |]\n ; [| \"6076231707445968054305995680347976771585015308155855387339303513025362636128\"\n ; \"28822740034050339685362260108484262889265034407340240070058997651710236456303\"\n ; \"23420266473857869790486107029614186913447272961845992963194006142267563993493\"\n |]\n ; [| \"13753917374184785903125509246122783296344288469304898921025291716613575849357\"\n ; \"22396739346703340038555577564698139382745239004673153148674304627904081092826\"\n ; \"13064238335532551154986111986409392866270911640785653458047811526842088084911\"\n |]\n ; [| \"23165923875642452719095776619341762858050322341374771345641255745672274104746\"\n ; \"1876216571769482372914291210815859835162659440705283782713345335434924136736\"\n ; \"25448252060136178247213604035267580231762596830634036926922217427938159849142\"\n |]\n ; [| \"2161875315509206970842862195937323600322108268401381254431163181777726747153\"\n ; \"19159855698625842998331760283165907305622417625829203038229273729196960321630\"\n ; \"24828563875172432296791053766778475681869974948122169083176331088266823626561\"\n |]\n ; [| \"15959479662608710141128458274961057999257961784282074767105536637788386907463\"\n ; \"8006369581283017287449277389162056290714176164680299906116833200510117952858\"\n ; \"18794336794618132129607701188430371953320538976527988886453665523008714542779\"\n |]\n ; [| \"19408271715954593722501381885401160867835377473312521553027032015227895029571\"\n ; \"13654747284005184272412579731446984220568337794941823533879059135026064413631\"\n ; \"14094055032353750931629930778481002727722804310855727808905931659115939920989\"\n |]\n ; [| \"13241818625838429282823260827177433104574315653706102174619924764342778921524\"\n ; \"25709259239494174564705048436260891089407557689981668111890003079561388887725\"\n ; \"26866626910239634723971078462134580196819809568632305020800296809092442642381\"\n |]\n ; [| \"23886826350713085163238005260075062110062681905356997481925492650252417143049\"\n ; \"16853602711255261520713463306790360324679500458440235992292027384928526778856\"\n ; \"18444710386168488194610417945072711530390091945738595259171890487504771614189\"\n |]\n ; [| \"16896789009769903615328691751424474161656500693270070895928499575572871141439\"\n ; \"23842266984616972287898037872537536999393060934879414668030219493005225085992\"\n ; \"24369698563802298585444760814856330583118549706483939267059237951238240608187\"\n |]\n ; [| \"25360195173713628054110426524260405937218170863260484655473435413697869858790\"\n ; \"1486437708678506228822038923353468635394979165769861487132708983207562337116\"\n ; \"18653498960429911228442559598959970807723487073275324556015861725806677047150\"\n |]\n ; [| \"18878179044241268037057256060083772636369783391816038647949347814518015576522\"\n ; \"178715779905629247116805974152863592571182389085419970371289655361443016848\"\n ; \"8381006794425876451998903949255801618132578446062133243427381291481465852184\"\n |]\n ; [| \"4176946262813877719206528849579392120806054050640974718891398605746592169324\"\n ; \"16376345520728802444699629729684297833862527190772376028981704525651968727081\"\n ; \"8399065769082251057361366626601550736334213197703006866551331927128775757919\"\n |]\n ; [| \"15435308585611812393531506745122614542196708285088622615406141986333182280857\"\n ; \"4082259282787276939431186930090898350392871145699460879678141552997816391817\"\n ; \"26348742719959309014730178326877937464605873211235784184917342950648457078699\"\n |]\n ; [| \"9707631711734344681918469569872517425107158187591261754498805460753455298868\"\n ; \"27910768846011709391567916011595957279088224137468948238696800459136335473132\"\n ; \"20407239095656434708569263842372155762970847207558227886302782130015730063802\"\n |]\n ; [| \"22726225412881182965250630589245572283256255052470345984553083359461473893802\"\n ; \"12443967854426795490638709950679156338200426963050610832781263082981525248175\"\n ; \"27102543658848146076219989119639465430524061997280788166887046421706499775415\"\n |]\n ; [| \"14427224233985680214097547669945064793149553513421479297921556194475574770861\"\n ; \"22917454832925781549840198815703114840452733537799472739275668965081704937832\"\n ; \"3455076056123630366063931123762198941796412458154689469887583689725886013901\"\n |]\n ; [| \"4513100023937785913596662867311227004762025658663076805918211014066645403017\"\n ; \"18187619530784075723418065322038024507729605774832001333883311123910954334059\"\n ; \"9447065431426150382325592560406989926365684509675374414068135115024495130938\"\n |]\n ; [| \"3227816098015819796753427754968234889554095489076864339942014527747604603014\"\n ; \"14798316759185072116520458171957899889489461918408669809912344751222514418582\"\n ; \"23013904852315603905843158448056763116188801262838729536210355401378476650033\"\n |]\n ; [| \"20979191509934291452182967564058656088941447895799901211038858159903580333267\"\n ; \"20772973010251235271448378823573767262405703078344288856168565499702414379868\"\n ; \"10105446427739226002497411811738001382334316505480517822035303561899927603685\"\n |]\n ; [| \"11079074761356717003579108002319997196881121172538617046865136940931215263187\"\n ; \"4693927775411489288330326150094711670434597808961717172753867514688725690438\"\n ; \"18581720304902876944842830383273503265470859268712618325357902881821721540119\"\n |]\n ; [| \"3065369948183164725765083504606321683481629263177690053939474679689088169185\"\n ; \"18515622379147081456114962668688706121098539582467584736624699157043365677487\"\n ; \"17563088600719312877716085528177751048248154461245613291986010180187238198006\"\n |]\n ; [| \"26199746176994924146211004840756471702409132230831594954444947705902602287290\"\n ; \"7576136600627345523051497639367002272003104458453478964661395239732811642605\"\n ; \"20058687874612168338994287374025378897088936171250328231848098497610185784281\"\n |]\n ; [| \"16894722532414195606958290526999761110785277556463400588047573469106594850228\"\n ; \"13961730805696859614283621225672002906734926278118993580398533742874863598733\"\n ; \"25256842011135514243352951950573936602906198374305137963222382546140030647211\"\n |]\n ; [| \"18530360047537856737482157200091774590035773602620205695980247565433703032532\"\n ; \"23014819965938599260086897799541446473887833964178378497976832161473586995397\"\n ; \"27911426213258307990762460361663504655967992659180759140364181941291843542489\"\n |]\n ; [| \"1067338118323302017358103178057182291035336430305886255160210378977812067042\"\n ; \"17219092885519007424608854460610388434712113621163885775309496940189894433620\"\n ; \"16432921127615937542183846559291144733339643093361323334499888895135356545408\"\n |]\n ; [| \"28608851042959977114787048070153637607786033079364369200270218128830983558707\"\n ; \"10121629780013165888398831090128011045011860641816380162950736555305748332191\"\n ; \"2348036340843128746981122630521268144839343500596932561106759754644596320722\"\n |]\n ; [| \"16619881370356823200358060093334065394764987467483650323706184068451904156452\"\n ; \"2302436627861989749837563733434625231689351276818486757748445924305258835336\"\n ; \"27514536540953539473280001431110316405453388911725550380123851609652679788049\"\n |]\n ; [| \"9459277727420672604737117687200019308525004979918488827092207438664125039815\"\n ; \"23425670740358068509956137586663046763224562225383386726193078231034380596217\"\n ; \"7641885067011661443791509688937280323563328029517832788240965464798835873658\"\n |]\n ; [| \"9579420382351699601929202663836555665702024548386778299996961509578687980280\"\n ; \"18513671386572584282611234979588379470994484682444053600751415262497237017703\"\n ; \"24923151431234706142737221165378041700050312199585085101919834422744926421604\"\n |]\n ; [| \"21131320841803068139502705966375283830095161079635803028011171241658723560073\"\n ; \"19208476595309656066589572658712717685014329237892885950958199953675225096566\"\n ; \"24023185216737416080949689106968568821656545490748664446389634158498624398204\"\n |]\n ; [| \"7510552996848634969347937904645640209946785877619890235458182993413526028718\"\n ; \"3694415017252995094553868781762548289196990492336482360084813900937464847638\"\n ; \"9219021070107873028263141554048987416559034633883158827414043929220388719352\"\n |]\n ; [| \"5058327241234443421111591959922712922949620710493120384930391763032694640881\"\n ; \"13148252221647574076185511663661016015859769210867362839817254885265598775418\"\n ; \"15186790492457240277904880519227706403545816456632095870015828239411033220638\"\n |]\n ; [| \"2775942914650502409705888572245750999561427024488403026572311267798009048466\"\n ; \"6277965230841030155341171319927732572492215818164736949144854827643964384893\"\n ; \"24144742149845235561087977558785057713814731737434473021812189457617252043745\"\n |]\n ; [| \"25789129719327437503403457598813971826156253950521984610569937361506914183550\"\n ; \"21500534320778995945845999974779950304491968082325255355181901574840373597824\"\n ; \"17185359848218837018503091932245529880546896465437232425673134558221638601375\"\n |]\n ; [| \"12253896579078110143384981818031883112606762215016553811786428215758384195713\"\n ; \"12956658260778456372481429232709881794962204180363200699121804724437678625542\"\n ; \"3023603786717368708677300377055384474816569333060487675635618249403832078921\"\n |]\n ; [| \"4186492855716808019562789862833898284927736051002588766326482010810259565130\"\n ; \"4263939782228419774639068267872291539552889472311225829898746091327730032923\"\n ; \"24068843626280451423530509388397151179174104901782990365720205643492047328816\"\n |]\n ; [| \"14564937827374621319716285527475223392664010281568256859627186463065876537730\"\n ; \"28367596550218705971881480694115935470211319172596432472834880507822452927283\"\n ; \"28712267437482356021504544448225827500268648754270274754623969882031853409874\"\n |]\n ; [| \"4542596163006916397403529184431773692747461300288194722982487051249951403191\"\n ; \"2530461821259252672899452671728393208543894014761816288817584587718369998371\"\n ; \"12886393063011539390567049190923398676964700147222878509238966758839020897414\"\n |]\n ; [| \"21593897590707514492037699253654745501762191795293908682495110982956631870528\"\n ; \"13233005790593128135480716846773978578237145313006994631606474472023504621256\"\n ; \"21621863098292803642478350494794106282518362577273973885587684567452726939909\"\n |]\n ; [| \"26068620073001644720969640099644251616742620988609091568084348314770436291745\"\n ; \"18248589586787935500122854210401321966459127818593446990365211078521058875685\"\n ; \"21247134484403265289037859533347798468858819117600251067578809852124865474448\"\n |]\n ; [| \"7947383127165915366383984718363902897504221803836013123394785749404572432524\"\n ; \"22173041014621867335598230447618036223462011647696367239478182269973488867154\"\n ; \"16773227734018849308448505860847939069870370055633571816925675705713088305139\"\n |]\n ; [| \"10708707957340055662073314227607620808612686977606082605219160019699644826999\"\n ; \"21249897193797038261479589555720746994050836195265348846222835266344091683000\"\n ; \"12581195059139097540117398803363514148192715293133623516709277290477633379593\"\n |]\n ; [| \"19779599816866992123290302397082614570282926215253589712189610064229996603178\"\n ; \"21749216503901548676985371189807470207364320167486559936962401093285243029177\"\n ; \"17600045923623503357380202389718735904174992978547372448837488832457719009224\"\n |]\n ; [| \"2732872979548118117758016335601225525660858727422778256671975055129965858636\"\n ; \"13703031005128062046175331918702218558750713240446179585947851411173844703597\"\n ; \"28447710105386636841938034820015573492556750872924193415447818187228356409281\"\n |]\n ; [| \"28539960355005748517007309210788803416171161412204526246799800716567376494244\"\n ; \"21329318452221893900731030722137844458345358926323127858742388587761302609863\"\n ; \"28135302149599894709369178097439582767613940517471323224020113411362601191873\"\n |]\n ; [| \"24980774120400248734054527936006392540889095705961960837980443629260392758683\"\n ; \"20339911045808632098936066397942175169549806052128535543540543556255197716643\"\n ; \"7929293103930252545581851978492699598413941396422930641071359388697302362494\"\n |]\n ; [| \"8911092207145893152276662096451247820054843777071569723455408545101628926203\"\n ; \"19648860643145256523615441075182036100116634560394529500146405733687718224516\"\n ; \"14635387208623683806428528837466762532853903031263830054986064902455379735903\"\n |]\n ; [| \"11555212214346132926966321609673228184079851030522218543981385635403167028692\"\n ; \"20896918157639814425520058178561910811657326967880217845710779511927814874973\"\n ; \"4650158165912007049140499755153804318686705949436165235742106170124284287326\"\n |]\n ; [| \"13880660273492757167295696447853232191657893303250187467329180558670697369810\"\n ; \"8043529172463774320604378774840863923445982272478964686447801046272917236836\"\n ; \"2134399296482715903442913099374581981696436050603410080564843555725771329441\"\n |]\n ; [| \"27320952903412641133501507962185246982787769547770982814240701526492601978122\"\n ; \"23417491374379751329394424924400186404791519133465537872457405970098902747611\"\n ; \"17612427354278346772575179176139417348059847375297761006336024476146551185903\"\n |]\n ; [| \"10710998507064742997612080847223278109404482930427999113323732519626499166548\"\n ; \"14958094513415797513745395709487730603918953350067504982704138489305723550923\"\n ; \"24096319595904213497633343966229498735553590589105811393277073274927955202995\"\n |]\n ; [| \"17983724131200292654039765185049138356840415443160477259330748730019147254309\"\n ; \"17598096800487588874709548646068838880468456205252324677357706597166777506441\"\n ; \"27420647821110229619898200875848631488422182349567475956209153112306555222281\"\n |]\n ; [| \"448538544835457571662601142415301047108854812427100562339376187510452313026\"\n ; \"23494184556634922103535803143214434479598067155171780264810485708203176455201\"\n ; \"22626342941879801989161990529511235538216563009907378573817996229389756621777\"\n |]\n ; [| \"26128268137723417163973860961686381960826033145738852158792607959175787222856\"\n ; \"20225791828042873305317281581105429726352058325970107209484198122707862156597\"\n ; \"7538871133759632802857159609785118198934349221046986784429069814655215585732\"\n |]\n ; [| \"26184554861259642274153262777073624024579929401668865520166966302070394487366\"\n ; \"28755259264665180745537307265993667261709206143628938749669440804401623257679\"\n ; \"11896066093033549470312328497237649508068258723531931099214795928200015717321\"\n |]\n ; [| \"21657721599978732693249012287058163532690942515202465984736373311077240614059\"\n ; \"9214914097169852704753116653702415951907628005986883140609006971322091003693\"\n ; \"18710111680849814325169297240208687402588261569152088592693815711857504371037\"\n |]\n ; [| \"6813635166770764528979084175325709935892248249948967889926276426090222296643\"\n ; \"20546585456429436268067726231902751119458200511988152296570567167520382569278\"\n ; \"20087466019194902429054761607398988292568594301671509779549344754172952693871\"\n |]\n ; [| \"28185105286740691904534067831357491310995891986363455251895371651360605333143\"\n ; \"10108348212894231193041286244259038275269464277821588425688314560368589986063\"\n ; \"11433633215392393209829215018579238412423821563056156785641278458497271271546\"\n |]\n ; [| \"27870881917195016999862550657996865268956893566432995492427618003637597051321\"\n ; \"102309803677783876701097881491240456320211833502658383473112057006867019389\"\n ; \"22844040227595875612525628393174357057929113317578127744718774517498324646590\"\n |]\n ; [| \"18364790233947478619325319418813215212267974311771564959136180502266118026133\"\n ; \"2480624341921718230432383518425561514824501138863702825916674641657321180841\"\n ; \"16778939567530361665956758171503829349658551798564323167725356065198936433124\"\n |]\n ; [| \"11947564511486966895926950599696532964589539443187518177489990556481125699966\"\n ; \"3133187646540385483015602955087323554103587039123577645562801570574691666057\"\n ; \"27704797101265438206569218421707753788081674727344603874614391656565567951541\"\n |]\n ; [| \"13001484695584753475562184349533365512515447041450030471627087395341039487710\"\n ; \"477322000667279478600757543806155989948171541982639893984064422067850617496\"\n ; \"13913755821658634147813329813115566967428755223601185963529801459396673113438\"\n |]\n ; [| \"16621869429023470107454028095846067937827722393398508604914831452950874033411\"\n ; \"21755744236927410239079501831014076529931327263341620300431356747367343619046\"\n ; \"26538666591151124505694487799121414506088199961481579132019627484065014831180\"\n |]\n ; [| \"3066480818457008068617042549071052338581291837882909165666223566402713429090\"\n ; \"16182268213934119294035309949459684472027705439038023775276926916166831108357\"\n ; \"28907604876608422892474268478706783033050951245339691569015166507728369585190\"\n |]\n ; [| \"27973960109508292680965426133498827831691369851701664449575719912259359998113\"\n ; \"1456924360278399121996742356757866616312146358469991014696110099534285524446\"\n ; \"8234248752911525485438611255163504976087091103090603316695312869292347668495\"\n |]\n ; [| \"8716078950082339630026654067608811496722305720644485560320987802533380421009\"\n ; \"19016744645809919602099479306503354923553336014593353020688463619133130053825\"\n ; \"24379650661051444982012238084495990858827340608012118841005379796362233056432\"\n |]\n ; [| \"2245379544097631382062919677963998259142792890502492881341386639439507471783\"\n ; \"28788137434161061988371619554419440748189388934884757179010092973102292086583\"\n ; \"7187000185648741287953633167647835668543536354944774631102766873251849991238\"\n |]\n ; [| \"18319349500538500800225762827448369057030532278398270164660609327776487168142\"\n ; \"2622932985948021877314529887962683530522545893985767148345336304947201715671\"\n ; \"13805188629797792210337544360632964855143280581052079479249966961215582531026\"\n |]\n ; [| \"27457600993464082637917106210690168172469473943609357897393615707457194410878\"\n ; \"15448646156961779103834447043970817898237835202826003934642165760908058355399\"\n ; \"9396792545729486882231669677795667529746274932273033601723318032992363022062\"\n |]\n ; [| \"9927877141952679457141759789181418464292082444806533413864151258248124544859\"\n ; \"23827901395971835838179844085051957393677906360196119690926757794561937573142\"\n ; \"3273544693673216914876067527455588276979859627093391584406340272737391174619\"\n |]\n ; [| \"19571510438350300564152393820251652609646082150148656806391655428002614034315\"\n ; \"4458840243585913642400750597703353770666314833058197517675446022682775625834\"\n ; \"6452218213610300363069953741424106105609715382419342511693148495219793324457\"\n |]\n ; [| \"14558167930891460678441266912176752652821641543245953113671886345167213541771\"\n ; \"10650967986920075561478528461783351160938460620955779955379459848889204404950\"\n ; \"19990009778942542934049216419052172134625404062770188357110708518621145688588\"\n |]\n ; [| \"26855242974447190235826233682457047761532515293146087151296725996543442567035\"\n ; \"22785340043356532865086769889360674409753343398766563441587096485751538658065\"\n ; \"28603049427449348335651629195385434188071937908693764500052489540779792538285\"\n |]\n ; [| \"20545812864989828913452616721240947168977365844984763819184465128164378967167\"\n ; \"23234068381345797209897730226956922073109641728569353961504167817770340037954\"\n ; \"26031714567641615877877111172701145299483019910006153132858512509897185854695\"\n |]\n ; [| \"9512221744061419790435674197238913998387834650389922233458121639503195504983\"\n ; \"12587458000103271975978240683793268604398305885278203470492658961734100340536\"\n ; \"9670291694005369437277651504604785512303147991710650505302465204429311229197\"\n |]\n ; [| \"26995526763045548800439747262386290359229145489609341602564040676717570935439\"\n ; \"23742712112104280264401317024221734961713400615669958343926511931219510484675\"\n ; \"27931469778579449247589315744656633392873808631802461175539563849884447358271\"\n |]\n ; [| \"20669006894143187877081688942720159738269397552445286314270368345994751825389\"\n ; \"26891772301075275370472640177651637211280740381619976926886106618375467277414\"\n ; \"28387986011980449959047232529988203397251084614417760995257355718700961696092\"\n |]\n ; [| \"6579105010484741592730389416372694666279917604793318157514380025250233913402\"\n ; \"11007035767869292700964744408562802781669930023548892567535397874932420229930\"\n ; \"981148366863906885900456473323410468923514528856216824044152942069412627408\"\n |]\n ; [| \"22213671088722307302576907504985884923571642958053627659840326928319445671280\"\n ; \"1318836216310789598614608105109389429335273432455224127576823891011367206122\"\n ; \"25586582796990779718352441955439394949194222626688223867952982491529809559257\"\n |]\n ; [| \"4923739488579452777913681531125585976446366144127161879759262506690369040090\"\n ; \"23505612338866210737103599484620591026802005128655081877133994175016351514827\"\n ; \"323887003859465324514901860965142186539600668250760639664361851354147799637\"\n |]\n ; [| \"10198923064967306784017949469108033682156920551672348936591491217255268794658\"\n ; \"9593680688139131432883442351722730169325112619984238956948153423155998917175\"\n ; \"27027988263960602112273050725720071355535922812577299127302015348825197871870\"\n |]\n ; [| \"14419883951157390867695097127684346981136020111885301573583640959136319507752\"\n ; \"5104414988075833278683649298543440897371415916271358703850262680431809374355\"\n ; \"24739655595299332818980677669648719986462429574612913501586844601377825836782\"\n |]\n ; [| \"28522818684103966731129743408029731246564480741348128436668680764518115102581\"\n ; \"21520350704208288978690888796633940487888044365108767319141211249242880355961\"\n ; \"17391005598311948834360476853940353239444383292422171321575043660157438608537\"\n |]\n ; [| \"15367833944125677011173327826570204350687925236257190051755087781855930646142\"\n ; \"21715073802090413714601069529558707101797361591183718695054701329871284436172\"\n ; \"8994093285353831008525761670339342200997965950202092028313103110478252647618\"\n |]\n ; [| \"8370824693889782161629525898408725452177580012023459750897244954935682978671\"\n ; \"16123253540853556024347150096993154278773652905830608614979368087152152043083\"\n ; \"3535380953353495025888433493640531836449699255364366295870140701379497967423\"\n |]\n ; [| \"6954518484798178646508803478426114267143074508396663899281411171704702743829\"\n ; \"28903134801897070276701950388422104654018369750191967384271618837091859516942\"\n ; \"20872505363530172448468374920196608937030884647150175861507911076568784054834\"\n |]\n ; [| \"6902861581703501105786795670676641959401710346423594578401934671029571262513\"\n ; \"10124161387604183369443890585742198433184078889862870469507328332805848271064\"\n ; \"10488004060799269337071647841224034919633445750252076195310163972966405029030\"\n |]\n ; [| \"507704911991278613147490289466075160618843900088471236546244459176211783848\"\n ; \"7252739745607302667257774481690407709040936359589867974787811552896597703097\"\n ; \"23278073497974004442836030100920157527910770509761505828038443336325476654930\"\n |]\n ; [| \"22766285055433137793164317120096790621982728188995759745859222009100808389090\"\n ; \"23129058299483468195787339200845749049960038336751758017949899311636830205152\"\n ; \"16665333681978951552434356320651834889869437822496200946959897681307959400425\"\n |]\n ; [| \"12145699202182574939376505075528461451757079041659894988784442097333218352048\"\n ; \"26340666275844437932755852805027863696219004039301187587209926587657008948704\"\n ; \"19208771804191839410002226941825269105677187954811130189835856228258013753206\"\n |]\n ; [| \"21957102494792377508237608216278079874536155315851198461024084071231867104453\"\n ; \"6933367436450995525851693784691226222726503560893470094614235356287049091852\"\n ; \"15707767379191450768747057313641112321773921923533732633534831270357733757271\"\n |]\n ; [| \"27661963645951389261638591385668507557739541354225916772550248746235106571003\"\n ; \"19699458096897937575096494582288688995241392471402204995195057374756282223421\"\n ; \"902873385171181344315871113842580653512118892800584003934454469411716098791\"\n |]\n ; [| \"17184835876565576154014372215369798779520343573944211203710896053325717110660\"\n ; \"664657295519303589036289440053175741110032988007278988577620229144220576240\"\n ; \"10803972669668998371638869508774217165881281885838503958226056357738500321396\"\n |]\n ; [| \"2329846733754251453632375727999372856194157027336139087170310553870624325301\"\n ; \"14139944357035048486675740400655356660678187875721949218090128899571575479791\"\n ; \"18368148273419807418427674359327442879484531833435081951870369910704734685351\"\n |]\n ; [| \"10480273665080572189328459165704340191901489646067580012574464138528963201459\"\n ; \"21773636700078124500346009061678153597323236568110076029811348966753228682835\"\n ; \"18184268307211429260956076021417309535471438696101133218049142374847151474905\"\n |]\n ; [| \"25957533025669311312382992376854735734491934602484112256289764602447226406852\"\n ; \"22223261506176684934865714490719116745135417403915426392159449667435294570739\"\n ; \"22937309162832499167063076416585504361695925730111272512450449042837586253575\"\n |]\n ; [| \"16956181785481598286719868503945127919581091625126206673934113115358441284347\"\n ; \"8497782777197814773596870810881707148695901557289856910220737358078100998191\"\n ; \"21135503731586600979470064722475007625236017670426339278983640892218291297054\"\n |]\n ; [| \"17809297343844488723046665739910571149089769215421130894378638450427880983923\"\n ; \"72435395972188389387093550708873189001876361107443937983754878061522372356\"\n ; \"7511239878692099209014947248389283109997289411550315391143819429585903287870\"\n |]\n |]\n }\n\nlet params_Pasta_q_legacy =\n { Params.mds =\n [| [| \"25059545165736646824438510995018528850798284624488112529736697979897721366717\"\n ; \"16698749787253722942243837797889445179074274353678606740096686335476872429399\"\n ; \"8431542578059462988142441820574484670502416261430105626118810753064502454172\"\n |]\n ; [| \"24729854844697760654067608751525498327180690314591492982304918187023029914826\"\n ; \"1121552144213806241339137182024814961508305746462827911242566288860442556748\"\n ; \"13091758359064753420271764138904670126701916846914918026096660522220974412796\"\n |]\n ; [| \"14318325434506839029297004068378670093722923223466359838374948921878384497878\"\n ; \"21049625586117008961018856577112352485632537866388888422067379870460247825481\"\n ; \"11967204246156045515212780049644733421582972293043836026003728262137316485428\"\n |]\n |]\n ; round_constants =\n [| [| \"27823288320934189888335104419667051541440213716337979953029039814477122015803\"\n ; \"7253519329434178666336171171011092435792450637855327869661074429483992798663\"\n ; \"12943190030917713819083161989292505641412002214667543002424543294305586713622\"\n |]\n ; [| \"27652450736585745228854776198724711889399928847227796610514615862285675851603\"\n ; \"14974144387861463358629448488728583756510094143360287299992064027672013096218\"\n ; \"7097911473075039536684392748485048129620058816999734741035507137919094344000\"\n |]\n ; [| \"9833471627477871590542564294396788818371219099618369953520953128833069622998\"\n ; \"1216722705894969315906023467727879380441696627034784137237245320657648994073\"\n ; \"23711484374443627488130462875874481115682053816071105446952037381155017895779\"\n |]\n ; [| \"20334834189812750348389095362218130162301260954195045344340626330588177435942\"\n ; \"4366529093468402654059406041856606540091882399834904947969748538808812090209\"\n ; \"19522556558624240319308906783506879200944684005866343832929046513996276368523\"\n |]\n ; [| \"23468156490044127088707992399042874063294495237928703268006456122691893114531\"\n ; \"10734041842950229608874281327056547473719120183996972794393760960989413485309\"\n ; \"3234488841736382875399536096222344212453291206089588556042783786752950726222\"\n |]\n ; [| \"7306686533350672818132556583061081086083445583634785280645571504913340166178\"\n ; \"10055837153364380487257619433543992440564488619143210451383396316865395141767\"\n ; \"17005554504252596333905431799020688136174578956026736789538843112027911340688\"\n |]\n ; [| \"11088831290647913265184319169987825710158339243590017331996929570375044581141\"\n ; \"18272514567796081346048223631818362002154999137167000861967874931307115963229\"\n ; \"2041522009924764288246767723256644894737485859434724922096489305438150594740\"\n |]\n ; [| \"11154210356751829838084431411705166756691650190195364032751879907682556256563\"\n ; \"23653929191474563116794828027291046485627178938492016942565292972650213420708\"\n ; \"10285757729660670290227890459658768244478343389595417793240783735403842747803\"\n |]\n ; [| \"27122162076320933627388879342386660773804566925381935727677186578594924773004\"\n ; \"25134653885736994960102027470761976149413229279137043556790564613470281817026\"\n ; \"6659993804933127797936877003954612022106867848874586482405999929720922911898\"\n |]\n ; [| \"1999981756946475588545224006048368808065463727746380893415897089701535614681\"\n ; \"117353258519553885966322353309393133659964765643696354970870351531909803419\"\n ; \"6394630448856946333677807337170062255969284635756530106258303122060761829375\"\n |]\n ; [| \"10402812455948335282625861441472459100503153859758204506020258199084032529891\"\n ; \"24521576250845873373537149390654765866957414335470107480004100764170074644129\"\n ; \"28343148273143818383375888384222625178643820136230475659994359540667696060401\"\n |]\n ; [| \"19466274031477176253567256907114468319559962421369951854132011198919308086813\"\n ; \"15950373298313107490097624474333726880960801439930364792944142444680782981647\"\n ; \"17502012461772831993035812876278636151120700925824710547719185259039723973873\"\n |]\n ; [| \"13427943193313984564171438077343446106584745896824089935661921301233540577663\"\n ; \"19169237962582795898123052276700824726897554497737731003794686518711369308701\"\n ; \"9083808098781854981749406088158848274120691731417104666413783119140757689434\"\n |]\n ; [| \"3085572928600572710130215355481483413152463940337003200200686333839836936060\"\n ; \"6423923726405952993270285921266354528708083436156049822651047436988725799335\"\n ; \"11711163607312960445460153090393005414044253191457667104588071606706527083035\"\n |]\n ; [| \"22862764769570580579955370870655020558642400260785510683021349826526091593487\"\n ; \"27106527830212782583531586155197640258773355519954630305727973089302997251797\"\n ; \"16868720082666046473782251283858811018289758418191781142790257643516182531272\"\n |]\n ; [| \"23158332713461282002423665990353034524451940720249144308509697639018478890344\"\n ; \"4196222884247438401050717959999141753538715859111095883718384227804271580571\"\n ; \"22572557742560406175483660351232922626321427879380236408573364865152875751999\"\n |]\n ; [| \"6498384178588263785275487016065720553418371000134613854044334919909896078231\"\n ; \"19713457172464396779910830357144111010125169288012289325852007667562797201617\"\n ; \"9370618609381654599580351346089018265074763897101213494189302119360756555515\"\n |]\n ; [| \"17332110085907729652621872688438506098032926644356340523235380228784153361946\"\n ; \"15828217198541208438489225959666895536847479530801819210983017536719128875310\"\n ; \"22909304389117426005516739639132057953847831090140119017131773808660581359339\"\n |]\n ; [| \"13274846258473860762348270229895556617343668531781906800111616196606379168678\"\n ; \"20563817685937794654177709363835160405142894424010788995801747935877119235477\"\n ; \"20063600011389636949850146896035168067037303328482473908141578341678944583640\"\n |]\n ; [| \"15561372644915625354729031742269409074452750500059702572378336917069173281200\"\n ; \"1198490580487628040011397824278054034135841708228898001350812771879916960859\"\n ; \"18879421345448691096589106007214815329241576402832734110268197859756832871926\"\n |]\n ; [| \"27399632471000964892968952930054846863781961828780329177494048571243833336763\"\n ; \"2834864942083315409826100384502236980961959328095446142898875620023252496233\"\n ; \"4869045848545701242953923765295279010470656159359352534992875895020324731123\"\n |]\n ; [| \"14325690392479768681007652408098324173976655892283539787053225046370602615453\"\n ; \"25414347192966841451685828069955147897403238857128755301675290249558576625379\"\n ; \"16590289516213461810017744664371295027301564689635234008641715363769691252951\"\n |]\n ; [| \"7999784177991937194560403228390571132248134775394758539082341051882961743020\"\n ; \"27627395050531728876502002078316976742781103442109539911472055005902825690089\"\n ; \"18036356111926470640247668504029296840956365668466479796170120459318979414011\"\n |]\n ; [| \"5913242795575813219801658492942666827872903959995896555280069960017119884723\"\n ; \"14937809672911513589131385409454363020800493802245991188388679796557583708641\"\n ; \"3172852326416764473757677332305817213305384800572730229499136253125245597387\"\n |]\n ; [| \"1832396283457909430686926169612235735546922286254241081539828449889942491358\"\n ; \"28715821183944831340251190244581222742951105435037341519427068245935486106710\"\n ; \"14690804016462235339916279821852369558429158839477443587616468985654313024916\"\n |]\n ; [| \"10594946257886875886350188493790544854294225726533811714616959802551003511354\"\n ; \"16258660270470428008977128056439132854218579917105801771424980524100431529141\"\n ; \"14389177900004589865692617486629808338224936524382373991229450083375030187419\"\n |]\n ; [| \"5254897446260226925010930278774739002366094838197608352776711034691419167908\"\n ; \"10017451766970898293191969301037043760556997294605718695671614691099240320486\"\n ; \"10377472495000399544094005473576037833003171018156457133642162749306784348836\"\n |]\n ; [| \"23218136335641731339524766058408447175805302377930780974300993009302336516500\"\n ; \"20191488824991124775021487716004416112776365506510575739204924567600203901269\"\n ; \"110606975331244410915904098772946457859594892267516924942421765736318866617\"\n |]\n ; [| \"23027069668757981664879070455867290821752779218098836684714327441246591774759\"\n ; \"4589247739673767474307973868199446429401684489991453077155492434850787381702\"\n ; \"6379670142720597470858520674745082918596505550095259476677356817872026090713\"\n |]\n ; [| \"19764864476474764903616550282446756103765436833072775572851316648333869235114\"\n ; \"12894898442410371982703732271804085318212494678649934125021268012840299185637\"\n ; \"4894374129066677193060314651654909732906317879933995748486904122303748724381\"\n |]\n ; [| \"9392947448126670174003480248219776361392113047007441983095267747240201787052\"\n ; \"17448004227122961073493138290943872881683504888463872361350949670680638193246\"\n ; \"24898908270148995600292988565336948748670477048995196059344166957302253353468\"\n |]\n ; [| \"17672969484563875329340665269765905710099865885284111146969980578304648998989\"\n ; \"17315183356963381222871645160515357484888194239021894873634846607120433299603\"\n ; \"16657291105770020999163388035414073826686069942847209725990896237129724531623\"\n |]\n ; [| \"20045358898180937726150285529789401521185856403599282370725965114285467221394\"\n ; \"7604720689465762204259558177050824657125765219907087093134275946944476764623\"\n ; \"4946157133141303389791048466320735878774808191447977218588320463643439643617\"\n |]\n ; [| \"16095543778893367554646246146733094380954235388863918230797975064302848608110\"\n ; \"9495028757440948201524349973141898811031260740727574963230822567659024070475\"\n ; \"15652394153551772951410898217296838776100645778717025418259184512269824513281\"\n |]\n ; [| \"22221075851011525495207739030167842998461976982084095286887110082203892655949\"\n ; \"9773505979109619840461605806117798267810157941804844442655531835520967463113\"\n ; \"9699921110253873916726596291176974227884871755181878140734719120429532053002\"\n |]\n ; [| \"17682231260051753498617845281951269726537935653976607531850308842757348601329\"\n ; \"18026887242590310014427209724078991193599958030254077118842503456583403950827\"\n ; \"25015306241717221564050692754953747248185536052663170582824605966511132780487\"\n |]\n ; [| \"16913017783534832741366331557377027835283393598087920619147327295000966841306\"\n ; \"14346687497088016967038616732353182101844963538110413455107565365722012953284\"\n ; \"5306566980905870284116776586767806070957377455264987606648038923624253495328\"\n |]\n ; [| \"1776756375313230649731428479835496304149043878892306245847918259342669070843\"\n ; \"490116546446566363527874936210269421699868025744627465261205141315457929764\"\n ; \"15895862901922909582174688550455317647454688607836801729345729632260371594678\"\n |]\n ; [| \"13688862447353097641921417721564599384304916802983599264426675175604875742315\"\n ; \"24548198092994361104088706233911543485350973671834385909863857501675802878279\"\n ; \"13459479827606540544689621578844182868859283770589890980132135394570347186061\"\n |]\n ; [| \"24044394058320635022361075601656905043313553792325674538366784156913803812196\"\n ; \"13224911244448701263582762940879464967836683002210854167321246073960841644522\"\n ; \"8458040493721843207908979005771386571338972860793346258045061108188537269575\"\n |]\n ; [| \"3373954096140863425424783847439718500809124286660183499962641073452219575239\"\n ; \"20786023834921480994573103385555575391782193954100981434750965529916600088428\"\n ; \"4062313531423140960397881434049476366932415559401603628257162927863296206641\"\n |]\n ; [| \"1898020409546207805320648144920011726191859363441411206281917919526161244598\"\n ; \"24277367400752675228358431727080852820923883244494414698417676920127526770088\"\n ; \"27041649732785968593009926556186278849799597604234485085263424041769060430672\"\n |]\n ; [| \"21584002498671958383320932658470323644925729001241157174062149135688934590153\"\n ; \"296461973635637542200993277788422285516983090690405454296351759221006819546\"\n ; \"8818839967799505500555627771598501831696804919367222237507197660660892665148\"\n |]\n ; [| \"4439337387294703935549667847378420965887876421209156336246561071020526953695\"\n ; \"27771844118085313731256751422668441516968763521122036346441924658635531209834\"\n ; \"7599670163703076794117421319905831310613637703095599713786252660612843368075\"\n |]\n ; [| \"12193036087689296361781682831088176514376474290884092260169857032550680408546\"\n ; \"25791228645469784134598013409595043692878987806412190415747720776255632142972\"\n ; \"8504882545271841062057911639581320453656588156705418395838850434018335784764\"\n |]\n ; [| \"9130894449689099154616722799255778500706692445872833148087121191022987751351\"\n ; \"21553577145491938499114888018915447040714863615699957078888430024590510223125\"\n ; \"8307396866731830889712140446282281226154409273955284908758959517111805068379\"\n |]\n ; [| \"20697895431092576068009892921110410029570860731610412906827921169156559036877\"\n ; \"25847730491997591203980701133953084257949899509409890411883471391399589272255\"\n ; \"27068530132452520868806589188908435601314783511462339379808399629696227108300\"\n |]\n ; [| \"20579165271364650486101631743580639117276566815442383429004130800710012624677\"\n ; \"2049872261441584532266169243588650339607343237488816821021818230059988793881\"\n ; \"5229222520976935575159907831883087156061470447412599430611711892673497144820\"\n |]\n ; [| \"16888076312477210105490768408731364790051105858421097779712165387651960648918\"\n ; \"2063328481371063362698477795877294174447601367525854450572877036817950486588\"\n ; \"9978860706589405700636863259000379424111716695830255414810479786243742448788\"\n |]\n ; [| \"10317246955612741053663756285229154782235034400014758881046851747850823867516\"\n ; \"13593887292763642751523995903547641851467767154363297491262315140569344482619\"\n ; \"23402502496341059894809445627668621422181262255992641144517916256091271283596\"\n |]\n ; [| \"21967434350664893350794692419887682460286669021917537287854750673456386148796\"\n ; \"23353689534149296842880441871386688481067867589772985300786059302345245225322\"\n ; \"23735357311909906399385947858290446886270449558355528121401365099315742122681\"\n |]\n ; [| \"10912898365787795098976682182552503726774830131561177111534481011887568028225\"\n ; \"24870024081013773996332492735582388115312107253015059784314149687041374665561\"\n ; \"14959251092871859358484341584905048546998757007023469906733200814028817787676\"\n |]\n ; [| \"4862971281682736739478329712142805000991054403202074379778464975706269552737\"\n ; \"18880974505260055428677233450169574923539187497744705144686621167223290501713\"\n ; \"15019860251830177408295304948562135143018077531659007557525973719668356977506\"\n |]\n ; [| \"20568371280002005481616540220671990391004159655382801184704914533391923227442\"\n ; \"17618564901060519653065801707062565705965252069071642419351201848751288646311\"\n ; \"6175806441176276214249342720153255252512916129811023844537243081853881530586\"\n |]\n ; [| \"296698681032659410437385638424768886607081580850224832109048866253174706324\"\n ; \"7268871617745116292779237678539517235521185661165310960197803054547440338193\"\n ; \"16341563652551468195688432165785741488638381548308118992703945905571040710551\"\n |]\n ; [| \"20802839862702262365306655858469071118895773474002102559223288884562755221802\"\n ; \"8463358659774659224604995990679067672391550969286021897665237635502349549078\"\n ; \"15978158329915368408793563753006455633333602546915141756185279989524351398011\"\n |]\n ; [| \"17622341778239430423221939745175386197971754657696111634181640277323050526814\"\n ; \"10608335237642480929422693089800206983573202659550442733156493623334131463648\"\n ; \"4030685945296549297325867649675145444613863086399488872024691844215015865404\"\n |]\n ; [| \"13622512335702925704246239293965891829357706731007005465669806728128070589631\"\n ; \"28096860376731134760587904422020552532782566250134663540225061105608367763617\"\n ; \"23408844245917750106421907693053932839460443870282241477420090247810403742130\"\n |]\n ; [| \"1333283643113200911795408607575124847498003548266053936354869116413818233994\"\n ; \"5114627784027951102582115213264649034477290065123683766415035791913182621990\"\n ; \"12764392856508616755454501281162355366590010491252202055937861522683929322726\"\n |]\n ; [| \"17151467035003081822551161487450697402952914914532916714361135117937359660435\"\n ; \"5790806510531167647314677971786602969791369262808321427822737321737295918626\"\n ; \"25402570155872412453028168278079114058150183483929245811506328339445321991585\"\n |]\n ; [| \"12920564330262937347355086382215038686842973035591062422536047377306795551956\"\n ; \"12250718187966551349934722909284957659425918779784022718640942555655844833782\"\n ; \"20895727170003937274470408646745579174029123755980503191289166493378198853753\"\n |]\n ; [| \"15956841763991535793203092153585710767934653432429666292367107371891246878431\"\n ; \"165004921874760145525553135393467831289178931448821175010841518884068397358\"\n ; \"21701359314438421232412634090067127199084976819670003578888860920096628455908\"\n |]\n ; [| \"6848902582754636090737517131578591551788309332465803574486567584842713095075\"\n ; \"9148729239860297908222294166176107790125495380930731971791358581588488088179\"\n ; \"8358777029774639487464736856867300896187008886831215496030522112768313792659\"\n |]\n ; [| \"27763005231503543326388909385720946430141828710795454442053340035715385775564\"\n ; \"22636772741960501900595405662321074335936299276173491651140399382705798268766\"\n ; \"24200783367862580793810376984298862005065285339141826318611417638508272680935\"\n |]\n ; [| \"822600333766772255824054922496304222560196931439044456446485963982870790028\"\n ; \"11620067212793640354075687381092798024341928813664220586751309617921494471627\"\n ; \"25396694389942268941157432367167881033474136344183279866045115614823524486381\"\n |]\n ; [| \"7950044866662305700342331645322097694799649174330586954392082006195652431589\"\n ; \"22840933456350447931596740831047097851905435130998852812846918451453709541072\"\n ; \"5952562873278923355396014494234833112602416727163262543950012068378966526374\"\n |]\n ; [| \"14941744106899001396490468834896552276228477518658489130424851675983796484223\"\n ; \"8411858922787427790040186603365979935733234451728885815156429633351516622170\"\n ; \"25728130512642084604375585079417861667709258338193885601642539891291402554672\"\n |]\n ; [| \"20604517750643336005470932595806868673102682184328905598449933465373164368567\"\n ; \"18692086501272312775058232861104840534405554074751818414995965413576504506898\"\n ; \"5269470419857278770474250796707995245651827289253410681285877302520855951649\"\n |]\n ; [| \"132958317750014592125353639381410869535729112359715476758774573020346177038\"\n ; \"17193272337125758342712697198430394405858515930784181707588441236523237399507\"\n ; \"6907588900146294348775248591028498082882128985613063249028470164033147125714\"\n |]\n ; [| \"16309200565821244573168333253815499203949927814550835828103574182056728678956\"\n ; \"4607702890113363215119270116443817064683508025122288758534057630367234921015\"\n ; \"11237233790658676278102726466515564713414270355327201961157117083230382852243\"\n |]\n ; [| \"10064330808822528140235288193284673078859867025792057686345339813053087817354\"\n ; \"25051392317202122071857024659315208391485135039862063722352057784569902851363\"\n ; \"22126617513529506569359166365810362424423294611767941651490344758258540414004\"\n |]\n ; [| \"12091746476208536681080525048942500448418433204654951972926283776785275935445\"\n ; \"12111265990251598624141275756247422663513559759757319153701374783734518534525\"\n ; \"26739984777421171183341767053331505211465422029143782259686543457935639077074\"\n |]\n ; [| \"7819054201259648899956766259173509994826070622646983709427380262867238635463\"\n ; \"10445115028929965619698941897016402172414044576496139170399391316067978563932\"\n ; \"19684711726373570147937187126430934630002495670017015298886915356480224463252\"\n |]\n ; [| \"11239307846668865409559961011092791606629566617449107300929575297206367273772\"\n ; \"28805033990368921872277896029043745855817246151363711680251631474098318414959\"\n ; \"18401979852581903763050302976527384564541846667710514970197455751949363551773\"\n |]\n ; [| \"28263368266760706140556936890723050350981960590399696453960533699777929937332\"\n ; \"13171701559671490165454061311663500722478022888953080003164558696925706691950\"\n ; \"19602525380638837013300511621093845194121859856160220235414966930348094741920\"\n |]\n ; [| \"25875044639134258735138554352016034131847861924507451443931721478575773042344\"\n ; \"1286919834973261464274310810959674232070230673485764517044208498391267530988\"\n ; \"12782511029953763844753944101233413908378422219581060868637062846684140416599\"\n |]\n ; [| \"13777170936966635591451775007775796682884247670199445877358680218373012583133\"\n ; \"13914069095415962019849305704612514109938496116014955678392598600149568146470\"\n ; \"6783088795558416833900023860884913748051142639172416787734707305655085393583\"\n |]\n ; [| \"23759768419633407428810307098986751935262813445177317925266674188878521655568\"\n ; \"6216329803333944314103957880878676099988045568818271561443283432381325370083\"\n ; \"25114051080902804484727511815467173212803244349938543937989789439460074114186\"\n |]\n ; [| \"1180226883916835404878157801250992605812628262348217873510319284727730147381\"\n ; \"28284648834460517620415684321276302970692148546984768206724059094698247703614\"\n ; \"24033429483804377793699007789045563117176754720883449007735536724064971910209\"\n |]\n ; [| \"24837980504224007072003842463132805986188595503848986775222831487536454430702\"\n ; \"7321472857412311158120212341338101751477713807416898032253162676888996785560\"\n ; \"16969570257066093255532410834694788936815887939867116143226504248562357179280\"\n |]\n ; [| \"4125673734564343532339577642546830393637205447174011175535077670456408467503\"\n ; \"10632713303134500465283168727266716395067246541628032088845987128902453337705\"\n ; \"9574680283229048309682722855094170144602083182060214720561022770315159925050\"\n |]\n ; [| \"25200516884616393326554198239117840577353244771178619578270272915036798525203\"\n ; \"8016037998616729200273828218865709942562955788458067024686069967773623280702\"\n ; \"23152730567726048528634883257060835573481024340136073260056069507023870894846\"\n |]\n ; [| \"4936905020024289826614920724630062129669650361835193562496220267355967500709\"\n ; \"18184641423707818974834811540508053654673520711184768800680158891503991754351\"\n ; \"27444333582924293137279963432375877042954535401580653830648855025913046131946\"\n |]\n ; [| \"19258787990037904339970574900663327047151333605558856194461096727736980981409\"\n ; \"7307247571008211080591958435739460884694126720317257874083215846110062993851\"\n ; \"26746958803361511836036369403239292474668097850167071971132263374551313661859\"\n |]\n ; [| \"2986707284687082908367239099770334052301679778803284796428725648583327571996\"\n ; \"11076872572044729168706875668696902097477024573484865352103135025101837260335\"\n ; \"7676893881767745856368855909105588397337840304590696665395773396488415841368\"\n |]\n ; [| \"8035879860710675293804855837795384803722427367423273349615911494186867635695\"\n ; \"8777228662288028976220651807443998778731851272244712495838227067153229552036\"\n ; \"9404729766074943289512201205781943537326342248324517034957699512018199204738\"\n |]\n ; [| \"28138039971941229743877350137198714871803339371774209928210486168306126282046\"\n ; \"24746372913562546565307551019536112359520027514996722419915199065654026706269\"\n ; \"5992908251399318789048901337027258610373870655662449861810221050890563237785\"\n |]\n ; [| \"8986662495311798908019190514368815106790964767556070538172234209887075670815\"\n ; \"7819511120920480038906806637526904433010099047963872696607543518954984324963\"\n ; \"20040748576462413617236432113139264992338669108015478382493668322296306085726\"\n |]\n ; [| \"12604124251667268108802430657250418818373981324591677149693775791311237018115\"\n ; \"3713446680888938926487722727702881477451007635693922407499275812693082163524\"\n ; \"4729722979346651955109002515433891123630816656581607922377526264122826791278\"\n |]\n ; [| \"16455155466899261355363975391464726179721089911718581260053823330812044805329\"\n ; \"27164824221249686345132567624748537410457840627513096638619870411838704887939\"\n ; \"16276969634012778467682584281076733912813949584479602315250697584070339970173\"\n |]\n ; [| \"25641921087422510763187305803178924090589997867692682422161021888360562111214\"\n ; \"3667017006482520184366983251713265998942338144600409725070021931240855063242\"\n ; \"16624027448839826107498199322162430278228409173124621849582911009734159268523\"\n |]\n ; [| \"26317000137938324098695631123138063604840025944173958478354566632124186905402\"\n ; \"26340841271036888065816939024344358177648115802586515509528813558078622483283\"\n ; \"26760792070192677486356259617078495242352693159824472284838522738202103374517\"\n |]\n ; [| \"12721771512080997403280267277695539784262535121086502864139373913498888705215\"\n ; \"22548741447254480389350118476622153801605101093013811309651936063066499340364\"\n ; \"27978367330497576661463216897542761474015119849207592150731961184044447336019\"\n |]\n ; [| \"25747063373517637067792390107027157627279718780430393414118399515398493230570\"\n ; \"20151199118555759838932276113163555479083735668386566652089241087017456180596\"\n ; \"18879014815739649515414305835536994932451911664341341839193146489857284960764\"\n |]\n ; [| \"3810373645102571961856835110796286023878561472775937446095180271215591973482\"\n ; \"21670724524877659990430014767408914315012249576025971870416576542969889929722\"\n ; \"3915354581322191374887706360194439190056113572215823372708498368264986411752\"\n |]\n ; [| \"25396010083988081390296945409600690498532747776857675039749936403891275914607\"\n ; \"27390501373018759994091671141783422648482925902652559051505224556105818276432\"\n ; \"21943756395113869385673889596972393684048914861116005493936041142864388308640\"\n |]\n ; [| \"21009529429359499435346117020843766611662779822918934812595290904562681460194\"\n ; \"4403095793362209982879649985124453117401775317228756238293170861698283724152\"\n ; \"13402721305808954031052740171341806281977967539270936940650446104784640742956\"\n |]\n ; [| \"27491349623398243944682353258003517841463983130426355707277141054509970413931\"\n ; \"839162295650533705111165213845914661169544698196543148318540951139745338443\"\n ; \"2360031015226134235320333722839592171180466963140089662936226146376372598269\"\n |]\n ; [| \"23187073805281466301515357725635655379740035976872552251192653562569108948332\"\n ; \"13415450340633894897579130593672628357474718745976391717544515771527056769433\"\n ; \"20551598721856083916810924558283736201557848101716997060847530300465710342492\"\n |]\n ; [| \"3672594647865661748928752317746079229095373133257293162774720337138304704736\"\n ; \"28656412123828764424722913154831876184400121058128257557942467880106263931024\"\n ; \"12488798341044520189714771416078903136558391518843419705687775573556817797577\"\n |]\n |]\n }\n\nlet params_Pasta_p_kimchi =\n { Params.mds =\n [| [| \"12035446894107573964500871153637039653510326950134440362813193268448863222019\"\n ; \"25461374787957152039031444204194007219326765802730624564074257060397341542093\"\n ; \"27667907157110496066452777015908813333407980290333709698851344970789663080149\"\n |]\n ; [| \"4491931056866994439025447213644536587424785196363427220456343191847333476930\"\n ; \"14743631939509747387607291926699970421064627808101543132147270746750887019919\"\n ; \"9448400033389617131295304336481030167723486090288313334230651810071857784477\"\n |]\n ; [| \"10525578725509990281643336361904863911009900817790387635342941550657754064843\"\n ; \"27437632000253211280915908546961303399777448677029255413769125486614773776695\"\n ; \"27566319851776897085443681456689352477426926500749993803132851225169606086988\"\n |]\n |]\n ; round_constants =\n [| [| \"21155079691556475130150866428468322463125560312786319980770950159250751855431\"\n ; \"16883442198399350202652499677723930673110172289234921799701652810789093522349\"\n ; \"17030687036425314703519085065002231920937594822150793091243263847382891822670\"\n |]\n ; [| \"25216718237129482752721276445368692059997901880654047883630276346421457427360\"\n ; \"9054264347380455706540423067244764093107767235485930776517975315876127782582\"\n ; \"26439087121446593160953570192891907825526260324480347638727375735543609856888\"\n |]\n ; [| \"15251000790817261169639394496851831733819930596125214313084182526610855787494\"\n ; \"10861916012597714684433535077722887124099023163589869801449218212493070551767\"\n ; \"18597653523270601187312528478986388028263730767495975370566527202946430104139\"\n |]\n ; [| \"15831416454198644276563319006805490049460322229057756462580029181847589006611\"\n ; \"15171856919255965617705854914448645702014039524159471542852132430360867202292\"\n ; \"15488495958879593647482715143904752785889816789652405888927117106448507625751\"\n |]\n ; [| \"19039802679983063488134304670998725949842655199289961967801223969839823940152\"\n ; \"4720101937153217036737330058775388037616286510783561045464678919473230044408\"\n ; \"10226318327254973427513859412126640040910264416718766418164893837597674300190\"\n |]\n ; [| \"20878756131129218406920515859235137275859844638301967889441262030146031838819\"\n ; \"7178475685651744631172532830973371642652029385893667810726019303466125436953\"\n ; \"1996970955918516145107673266490486752153434673064635795711751450164177339618\"\n |]\n ; [| \"15205545916434157464929420145756897321482314798910153575340430817222504672630\"\n ; \"25660296961552699573824264215804279051322332899472350724416657386062327210698\"\n ; \"13842611741937412200312851417353455040950878279339067816479233688850376089318\"\n |]\n ; [| \"1383799642177300432144836486981606294838630135265094078921115713566691160459\"\n ; \"1135532281155277588005319334542025976079676424839948500020664227027300010929\"\n ; \"4384117336930380014868572224801371377488688194169758696438185377724744869360\"\n |]\n ; [| \"21725577575710270071808882335900370909424604447083353471892004026180492193649\"\n ; \"676128913284806802699862508051022306366147359505124346651466289788974059668\"\n ; \"25186611339598418732666781049829183886812651492845008333418424746493100589207\"\n |]\n ; [| \"10402240124664763733060094237696964473609580414190944671778761753887884341073\"\n ; \"11918307118590866200687906627767559273324023585642003803337447146531313172441\"\n ; \"16895677254395661024186292503536662354181715337630376909778003268311296637301\"\n |]\n ; [| \"23818602699032741669874498456696325705498383130221297580399035778119213224810\"\n ; \"4285193711150023248690088154344086684336247475445482883105661485741762600154\"\n ; \"19133204443389422404056150665863951250222934590192266371578950735825153238612\"\n |]\n ; [| \"5515589673266504033533906836494002702866463791762187140099560583198974233395\"\n ; \"11830435563729472715615302060564876527985621376031612798386367965451821182352\"\n ; \"7510711479224915247011074129666445216001563200717943545636462819681638560128\"\n |]\n ; [| \"24694843201907722940091503626731830056550128225297370217610328578733387733444\"\n ; \"27361655066973784653563425664091383058914302579694897188019422193564924110528\"\n ; \"21606788186194534241166833954371013788633495786419718955480491478044413102713\"\n |]\n ; [| \"19934060063390905409309407607814787335159021816537006003398035237707924006757\"\n ; \"8495813630060004961768092461554180468161254914257386012937942498774724649553\"\n ; \"27524960680529762202005330464726908693944660961000958842417927307941561848461\"\n |]\n ; [| \"15178481650950399259757805400615635703086255035073919114667254549690862896985\"\n ; \"16164780354695672259791105197274509251141405713012804937107314962551600380870\"\n ; \"10529167793600778056702353412758954281652843049850979705476598375597148191979\"\n |]\n ; [| \"721141070179074082553302896292167103755384741083338957818644728290501449040\"\n ; \"22044408985956234023934090378372374883099115753118261312473550998188148912041\"\n ; \"27068254103241989852888872162525066148367014691482601147536314217249046186315\"\n |]\n ; [| \"3880429241956357176819112098792744584376727450211873998699580893624868748961\"\n ; \"17387097125522937623262508065966749501583017524609697127088211568136333655623\"\n ; \"6256814421247770895467770393029354017922744712896100913895513234184920631289\"\n |]\n ; [| \"2942627347777337187690939671601251987500285937340386328746818861972711408579\"\n ; \"24031654937764287280548628128490074801809101323243546313826173430897408945397\"\n ; \"14401457902976567713827506689641442844921449636054278900045849050301331732143\"\n |]\n ; [| \"20170632877385406450742199836933900257692624353889848352407590794211839130727\"\n ; \"24056496193857444725324410428861722338174099794084586764867109123681727290181\"\n ; \"11257913009612703357266904349759250619633397075667824800196659858304604714965\"\n |]\n ; [| \"22228158921984425749199071461510152694025757871561406897041788037116931009246\"\n ; \"9152163378317846541430311327336774331416267016980485920222768197583559318682\"\n ; \"13906695403538884432896105059360907560653506400343268230130536740148070289175\"\n |]\n ; [| \"7220714562509721437034241786731185291972496952091254931195414855962344025067\"\n ; \"27608867305903811397208862801981345878179337369367554478205559689592889691927\"\n ; \"13288465747219756218882697408422850918209170830515545272152965967042670763153\"\n |]\n ; [| \"8251343892709140154567051772980662609566359215743613773155065627504813327653\"\n ; \"22035238365102171608166944627493632660244312563934708756134297161332908879090\"\n ; \"13560937766273321037807329177749403409731524715067067740487246745322577571823\"\n |]\n ; [| \"21652518608959234550262559135285358020552897349934571164032339186996805408040\"\n ; \"22479086963324173427634460342145551255011746993910136574926173581069603086891\"\n ; \"13676501958531751140966255121288182631772843001727158043704693838707387130095\"\n |]\n ; [| \"5680310394102577950568930199056707827608275306479994663197187031893244826674\"\n ; \"25125360450906166639190392763071557410047335755341060350879819485506243289998\"\n ; \"22659254028501616785029594492374243581602744364859762239504348429834224676676\"\n |]\n ; [| \"23101411405087512171421838856759448177512679869882987631073569441496722536782\"\n ; \"24149774013240355952057123660656464942409328637280437515964899830988178868108\"\n ; \"5782097512368226173095183217893826020351125522160843964147125728530147423065\"\n |]\n ; [| \"13540762114500083869920564649399977644344247485313990448129838910231204868111\"\n ; \"20421637734328811337527547703833013277831804985438407401987624070721139913982\"\n ; \"7742664118615900772129122541139124149525273579639574972380600206383923500701\"\n |]\n ; [| \"1109643801053963021778418773196543643970146666329661268825691230294798976318\"\n ; \"16580663920817053843121063692728699890952505074386761779275436996241901223840\"\n ; \"14638514680222429058240285918830106208025229459346033470787111294847121792366\"\n |]\n ; [| \"17080385857812672649489217965285727739557573467014392822992021264701563205891\"\n ; \"26176268111736737558502775993925696791974738793095023824029827577569530708665\"\n ; \"4382756253392449071896813428140986330161215829425086284611219278674857536001\"\n |]\n ; [| \"13934033814940585315406666445960471293638427404971553891617533231178815348902\"\n ; \"27054912732979753314774418228399230433963143177662848084045249524271046173121\"\n ; \"28916070403698593376490976676534962592542013020010643734621202484860041243391\"\n |]\n ; [| \"24820015636966360150164458094894587765384135259446295278101998130934963922381\"\n ; \"7969535238488580655870884015145760954416088335296905520306227531221721881868\"\n ; \"7690547696740080985104189563436871930607055124031711216224219523236060212249\"\n |]\n ; [| \"9712576468091272384496248353414290908377825697488757134833205246106605867289\"\n ; \"12148698031438398980683630141370402088785182722473169207262735228500190477924\"\n ; \"14359657643133476969781351728574842164124292705609900285041476162075031948227\"\n |]\n ; [| \"23563839965372067275137992801035780013422228997724286060975035719045352435470\"\n ; \"4184634822776323233231956802962638484057536837393405750680645555481330909086\"\n ; \"16249511905185772125762038789038193114431085603985079639889795722501216492487\"\n |]\n ; [| \"11001863048692031559800673473526311616702863826063550559568315794438941516621\"\n ; \"4702354107983530219070178410740869035350641284373933887080161024348425080464\"\n ; \"23751680507533064238793742311430343910720206725883441625894258483004979501613\"\n |]\n ; [| \"28670526516158451470169873496541739545860177757793329093045522432279094518766\"\n ; \"3568312993091537758218792253361873752799472566055209125947589819564395417072\"\n ; \"1819755756343439646550062754332039103654718693246396323207323333948654200950\"\n |]\n ; [| \"5372129954699791301953948907349887257752247843844511069896766784624930478273\"\n ; \"17512156688034945920605615850550150476471921176481039715733979181538491476080\"\n ; \"25777105342317622165159064911913148785971147228777677435200128966844208883059\"\n |]\n ; [| \"25350392006158741749134238306326265756085455157012701586003300872637887157982\"\n ; \"20096724945283767296886159120145376967480397366990493578897615204296873954844\"\n ; \"8063283381910110762785892100479219642751540456251198202214433355775540036851\"\n |]\n ; [| \"4393613870462297385565277757207010824900723217720226130342463666351557475823\"\n ; \"9874972555132910032057499689351411450892722671352476280351715757363137891038\"\n ; \"23590926474329902351439438151596866311245682682435235170001347511997242904868\"\n |]\n ; [| \"17723373371137275859467518615551278584842947963894791032296774955869958211070\"\n ; \"2350345015303336966039836492267992193191479606566494799781846958620636621159\"\n ; \"27755207882790211140683010581856487965587066971982625511152297537534623405016\"\n |]\n ; [| \"6584607987789185408123601849106260907671314994378225066806060862710814193906\"\n ; \"609759108847171587253578490536519506369136135254150754300671591987320319770\"\n ; \"28435187585965602110074342250910608316032945187476441868666714022529803033083\"\n |]\n ; [| \"16016664911651770663938916450245705908287192964254704641717751103464322455303\"\n ; \"17551273293154696089066968171579395800922204266630874071186322718903959339163\"\n ; \"20414195497994754529479032467015716938594722029047207834858832838081413050198\"\n |]\n ; [| \"19773307918850685463180290966774465805537520595602496529624568184993487593855\"\n ; \"24598603838812162820757838364185126333280131847747737533989799467867231166980\"\n ; \"11040972566103463398651864390163813377135738019556270484707889323659789290225\"\n |]\n ; [| \"5189242080957784038860188184443287562488963023922086723850863987437818393811\"\n ; \"1435203288979376557721239239445613396009633263160237764653161500252258220144\"\n ; \"13066591163578079667911016543985168493088721636164837520689376346534152547210\"\n |]\n ; [| \"17345901407013599418148210465150865782628422047458024807490502489711252831342\"\n ; \"22139633362249671900128029132387275539363684188353969065288495002671733200348\"\n ; \"1061056418502836172283188490483332922126033656372467737207927075184389487061\"\n |]\n ; [| \"10241738906190857416046229928455551829189196941239601756375665129874835232299\"\n ; \"27808033332417845112292408673209999320983657696373938259351951416571545364415\"\n ; \"18820154989873674261497645724903918046694142479240549687085662625471577737140\"\n |]\n ; [| \"7983688435214640842673294735439196010654951226956101271763849527529940619307\"\n ; \"17067928657801807648925755556866676899145460770352731818062909643149568271566\"\n ; \"24472070825156236829515738091791182856425635433388202153358580534810244942762\"\n |]\n ; [| \"25752201169361795911258625731016717414310986450004737514595241038036936283227\"\n ; \"26041505376284666160132119888949817249574689146924196064963008712979256107535\"\n ; \"23977050489096115210391718599021827780049209314283111721864956071820102846008\"\n |]\n ; [| \"26678257097278788410676026718736087312816016749016738933942134600725962413805\"\n ; \"10480026985951498884090911619636977502506079971893083605102044931823547311729\"\n ; \"21126631300593007055117122830961273871167754554670317425822083333557535463396\"\n |]\n ; [| \"1564862894215434177641156287699106659379648851457681469848362532131406827573\"\n ; \"13247162472821152334486419054854847522301612781818744556576865965657773174584\"\n ; \"8673615954922496961704442777870253767001276027366984739283715623634850885984\"\n |]\n ; [| \"2794525076937490807476666942602262298677291735723129868457629508555429470085\"\n ; \"4656175953888995612264371467596648522808911819700660048695373348629527757049\"\n ; \"23221574237857660318443567292601561932489621919104226163978909845174616477329\"\n |]\n ; [| \"1878392460078272317716114458784636517603142716091316893054365153068227117145\"\n ; \"2370412714505757731457251173604396662292063533194555369091306667486647634097\"\n ; \"17409784861870189930766639925394191888667317762328427589153989811980152373276\"\n |]\n ; [| \"25869136641898166514111941708608048269584233242773814014385564101168774293194\"\n ; \"11361209360311194794795494027949518465383235799633128250259863567683341091323\"\n ; \"14913258820718821235077379851098720071902170702113538811112331615559409988569\"\n |]\n ; [| \"12957012022018304419868287033513141736995211906682903915897515954290678373899\"\n ; \"17128889547450684566010972445328859295804027707361763477802050112063630550300\"\n ; \"23329219085372232771288306767242735245018143857623151155581182779769305489903\"\n |]\n ; [| \"1607741027962933685476527275858938699728586794398382348454736018784568853937\"\n ; \"2611953825405141009309433982109911976923326848135736099261873796908057448476\"\n ; \"7372230383134982628913227482618052530364724821976589156840317933676130378411\"\n |]\n ; [| \"20203606758501212620842735123770014952499754751430660463060696990317556818571\"\n ; \"4678361398979174017885631008335559529633853759463947250620930343087749944307\"\n ; \"27176462634198471376002287271754121925750749676999036165457559387195124025594\"\n |]\n ; [| \"6361981813552614697928697527332318530502852015189048838072565811230204474643\"\n ; \"13815234633287489023151647353581705241145927054858922281829444557905946323248\"\n ; \"10888828634279127981352133512429657747610298502219125571406085952954136470354\"\n |]\n |]\n }\n\nlet params_Pasta_q_kimchi =\n { Params.mds =\n [| [| \"28115781186772277486790024060542467295096710153315236019619365740021995624782\"\n ; \"22098002279041163367053200604969603243328318626084412751290336872362628294144\"\n ; \"10518156075882958317589806716220047551309200159506906232124952575033472931386\"\n |]\n ; [| \"8515206633865386306014865142947895502833797732365705727001733785057042819852\"\n ; \"19310731234716792175834594131802557577955166208124819468043130037927500684373\"\n ; \"361439796332338311597104753147071943681730695313819021679602959964518909239\"\n |]\n ; [| \"2193808570710678216879007026210418088296432071066284289131688133644970611483\"\n ; \"1201496953174589855481629688627002262719699487577300614284420648015658009380\"\n ; \"11619800255560837597192574795389782851917036920101027584480912719351481334717\"\n |]\n |]\n ; round_constants =\n [| [| \"2517640872121921965298496967863234221143680281046699148760560696057284005606\"\n ; \"3391756047431116221709518926936538303706203177575259437741546230828058541679\"\n ; \"28193080211857729746868575888309975056941007202713113547154010421664334143056\"\n |]\n ; [| \"25261619184426186938919514618416881383323154981235406731208902193655587998749\"\n ; \"5438499261516835502981531641588657477212528137520578797088407969732830437134\"\n ; \"1447697894671779324954748568939217281372628544919576009518449387265606369859\"\n |]\n ; [| \"5035532530235542599906399941203951970682478985022204457211063504597080640029\"\n ; \"18548939393800290417015907795270784249198528773378593112394621615021029911007\"\n ; \"28314657632459005492203969796973258399484591559931227050853551342156833947891\"\n |]\n ; [| \"10075465805557971120845970058070916255338843492716768289922460436606689369477\"\n ; \"21985996556868691161386211003270106475915714625334030557267947035839814254081\"\n ; \"9778523497398309788873186849997676949503189428912377745814036481347657299161\"\n |]\n ; [| \"6085447467925843146276340167082679235758707259098174769103982431882228334038\"\n ; \"11214803418623679719680560978819619149235769633101428825693192995405955507848\"\n ; \"20585482519401972421539035665320299097144487427998598740316244173221216198246\"\n |]\n ; [| \"18602266896623204184748247002001496873223612100325866696399863661914256384486\"\n ; \"22165919841309962137671309308234475433816142848229812860682345190836583925843\"\n ; \"22833505632200982123686653495190412951871851216487329681987951602744930627412\"\n |]\n ; [| \"200996541962081036547810490655955282117589336000744078845964972887355639644\"\n ; \"17159390488590225463405148524511348095493761844950655304775985535830170165304\"\n ; \"7519689807382250126180254188667761476713509751388558140260305473388567529705\"\n |]\n ; [| \"14159331841037307097148990917607709903712709092721125605507719995418592745663\"\n ; \"10490695046555645615062072066940833278139280813429718770298136076375411280286\"\n ; \"9996921069626538041923613626115903019578182147993504053879837245826104687293\"\n |]\n ; [| \"28009241574980093348462093077828465154604666812509186537490618830383877236685\"\n ; \"18925279443828804264179873719494108834579217607847079902207023181925588871175\"\n ; \"13126164514615718686767880517156253918404905174962666942976286681458411835722\"\n |]\n ; [| \"1125667389564136291825905670957082668987611691949011617627091942772124917554\"\n ; \"12737072162917928935765906421286553437026542524142430058538254259863452556200\"\n ; \"9855113244149548216327019561589719324434080884827484555441182992249251832158\"\n |]\n ; [| \"6006604346195593001833550983798183088851044846011297061071167569148810544010\"\n ; \"23783465709464699444911580329342599880163107932561352210466223087637763994288\"\n ; \"1581060363083815351710754851350813999229829634252940169154424073664057276774\"\n |]\n ; [| \"24121961545310887440574053281799796355427122479626872394472157625455666323022\"\n ; \"23925781309638869606256007860000699567158045595326122474217734988331349678475\"\n ; \"433512980570318160778040929743715681206456334448542248765142091911433454703\"\n |]\n ; [| \"8080307140515367021419180108267113624095868360927897204642243727009503935719\"\n ; \"13661807750191096117929173962837770733539092996971801228126331071941306856508\"\n ; \"9268394414065063505331314418649987795374055416089324253185088859000252370756\"\n |]\n ; [| \"22374115023493407761095751712373350824513305398485824175669182288521610150311\"\n ; \"22951274634403942446739133926874770994604864227598567536319143390467218980824\"\n ; \"21411532836345163980832919797897483979345524322135010935120723250070247464549\"\n |]\n ; [| \"20688285497159372157224857370703211924056803904697620218749985029000049442943\"\n ; \"8350087190167057556241775495760369408781696125331535735138679647687106863977\"\n ; \"13485893160159637778707269611856683957779710980787754997470728774769162419576\"\n |]\n ; [| \"4621792784192688819920303666439776744566536330750316034321950771579978771021\"\n ; \"13900656491552343190424687336475573267660717627286734246676255663734655019912\"\n ; \"16577037405341365304416318048187907895286388691199320947077947552959834207823\"\n |]\n ; [| \"17453637937712580666297652202332273322112052411250919589546137386514183913993\"\n ; \"9852736110707561006399582579453396957225552488023642073454517393228764176471\"\n ; \"8053970357622019747109700798952789019805031210730923951116580579194625334710\"\n |]\n ; [| \"14566849926060034944494603512439278530775668595134329897253012222562109882008\"\n ; \"8863944349051942080060073891691580009950648437676309749771884964336231381737\"\n ; \"16455762285584757654310476505019438984453107876908065440396394186006196612077\"\n |]\n ; [| \"28098375311516838082882166381119795701982164671360574802728073046992978741339\"\n ; \"13538346067341652694825445642847479918140731375902310280683284825070643960891\"\n ; \"18313412784975078534612748781201087502203257054025866271209086293337241477805\"\n |]\n ; [| \"24807061345703288899043018750567607387907450632666147403804744880717736838940\"\n ; \"16638378638176552952794487891875614248110181610295183306789394461536640085108\"\n ; \"2342874860138849081032934096750004917991517717553229739958552529472431319656\"\n |]\n ; [| \"21631810094765090996871180483650934431972930909326270651252393395613356531282\"\n ; \"2220759912186713489010197903069023809260408491503960321105305330086947471014\"\n ; \"14815764944505758746761442212662459585220143243155504464852948007238083120696\"\n |]\n ; [| \"23947619952183462858644581465494050309407721428302029371055887418452994318961\"\n ; \"25035254658153233628169609451068923631269927394392748023889572264723092874720\"\n ; \"17468020412163678868776493601957969748197290347006692843306595815987772942732\"\n |]\n ; [| \"15262198027618900223004625662874755104828479630165814039838611768431063172994\"\n ; \"25161066724266754383358798644805908588326959881061318668106454787543611445887\"\n ; \"2454250001039770891411267760383268680504653332090622148533496270387793031332\"\n |]\n ; [| \"9171946491887082474979985164918822959719377078284664312866368737511724712644\"\n ; \"6672870238005411132577302023934139592378291207852994424857452575898007687159\"\n ; \"2950400608762766076731526167833938554190979516192019010641815746350334547745\"\n |]\n ; [| \"10653725154501691589476837895400001173933804810435931645261606197625601363132\"\n ; \"12717400214508961810851553873706609743505640660238109459222577386574996883747\"\n ; \"5871058785976817081042949511195036111847495052209270758342334312740290470200\"\n |]\n ; [| \"18192562665205900830717234913238180302424621739145466326708104656354353538015\"\n ; \"19946412409172091711185698839696950657650658896270607012902209489827790455314\"\n ; \"21997416257528392077410699901606794827305154904508120972585193876767785262539\"\n |]\n ; [| \"16525092684784199198745517563091041705366544303388462641935777835264970071331\"\n ; \"27613372589672512522307803997948488817865025374001297632527692577079750053456\"\n ; \"23369674747888778238616865774843237791546925005553032792584302158017141634655\"\n |]\n ; [| \"11012136308159330675912474383855146192700147583104742924419195363346115019405\"\n ; \"20632243971343595216801828590185617698839041744000918292113739726624680548813\"\n ; \"10530371852841765918702282883445676639977895775479854136871270050807595649710\"\n |]\n ; [| \"1610594053831245596683250788274018471388810111366046583216577135605955718023\"\n ; \"452300846172044702598793611907955884294868639769163388132276731316720796255\"\n ; \"22297945145153422883128810575530182077542612397826351322358420927950400316504\"\n |]\n ; [| \"28212510899948152845929142163236606049756849316851154583029383581129293825706\"\n ; \"28325924586146971645663587791728624896861517146549428987043066595915712075981\"\n ; \"23489013325315178311518261165509151135555509351661386106070231815049642443022\"\n |]\n ; [| \"10150108696154604591036176090028652090941375062280095655463112192524823306544\"\n ; \"14935856239824547404885450872472169780177654619496758596151670953532153419587\"\n ; \"4367251608666794961207658726914177158125339342277880902441218521648798930454\"\n |]\n ; [| \"14278046449956534912766622635951826857049583276976844525135170835571509013020\"\n ; \"11627801940273881243235293875277734806211947530882079339115454640100174268255\"\n ; \"22853853581419894582873479603685652928885253184240650995805892818180355600894\"\n |]\n ; [| \"4405193089432137585625363585733613667088817369599257533888439029942466720878\"\n ; \"26434497741746827048559732407319982377645052620918789373329661707603241810667\"\n ; \"23558650878002025381506445692526977061352711282820117441110868042756853707843\"\n |]\n ; [| \"27427423077748345654234924309581695092179468167973406115643356520054395647078\"\n ; \"17585801825757985265979208086560185342609289319992678737491966299829354657891\"\n ; \"22079131836316223121286612953926945430480043835170303484162677394496378207190\"\n |]\n ; [| \"20126865597655889981803452476686954944892814234259869552204215672627920656068\"\n ; \"5591585339015997308682985123056479221565470335707041924016523106405300562835\"\n ; \"9422316572086279209843572429137982927615080330725918371521370800874341571474\"\n |]\n ; [| \"2735677349719528139570614238939713941030373684882307164259316901880218894412\"\n ; \"16229147459127626384090303399894157248853232127961182470501666316464149067069\"\n ; \"17151067888069760812629817914442472623785916486309268828873486698948911058517\"\n |]\n ; [| \"13833972862865550568348750465964022581895521701070662509936215512761615491351\"\n ; \"9624679817699048440664645568701817641311119158936258215534754849666144699339\"\n ; \"10273179847163882031630140477902608240997857384703412878925192706057610103613\"\n |]\n ; [| \"3172037826021850467928085880043492158321918352296515787555947245998877188849\"\n ; \"28890802281119993101506497911757988639840653958256859430239635494708187190915\"\n ; \"23496953773368274731821824281559682992786773767847557735733251263969009271239\"\n |]\n ; [| \"1509044982655321910215442389040863370827049078919961070795919190828975736187\"\n ; \"13927172650979098916742472053302036482743492746437467103459483008024082210879\"\n ; \"17248379591027039069313293591621091031164062825086122980769287846951363066520\"\n |]\n ; [| \"11350333545134487336540967650634077894516131586708748380417042089147896079201\"\n ; \"639497848254405996993150855123515463224731962182127668267769103213580096582\"\n ; \"24528361599642320451530127347946798949257664936307333999618279589325586618880\"\n |]\n ; [| \"8217015496508457685301448884203977810298711070026260090660268003968421268717\"\n ; \"6703444480721420507060701216472376128524677965704475494357937059812166295103\"\n ; \"8051365375874262471960241848873604339195556527603956582828833313772444122472\"\n |]\n ; [| \"10412735174026641936105532807659667596947675372330827493649954160029449767122\"\n ; \"8447576362386697729021229138353952824970707645851763166490398451107606293885\"\n ; \"4802965296970904162106502573136505305073730277702271660292532219583823320181\"\n |]\n ; [| \"3244354881334856885788568976540712586633556478250043997221528214026130052269\"\n ; \"817270901440592571623549787267103386561304980129799240746702119063425010300\"\n ; \"6566338353152134577893356938981496347522747926131278635019050445923229718029\"\n |]\n ; [| \"4854521709622003124815206874897232905514824969466266873443062691298769768277\"\n ; \"12830134034124699064152980183243986699241944691238427861184919962819448276943\"\n ; \"24309439157688106320977023683093060719537142150089588950480669629964661236785\"\n |]\n ; [| \"1853791709949511636795588377016980571084333441972847324139062389997895453872\"\n ; \"11399505004623970417786749745036397690793259153591025248188283534764565207306\"\n ; \"6280235834578097246976697944083887557501831809932305676532914637669922657807\"\n |]\n ; [| \"1516294190187225192808636261678393666537186816904214776860202535671714230097\"\n ; \"5835813607391397757416951433662507638966861369364000865214031356023042341328\"\n ; \"25777313996516799380163546628133415256678997511953860435781885414872422583905\"\n |]\n ; [| \"9749298878960864917089442034293906589697892682402070689770627645324414273893\"\n ; \"19986612197193695239708718365565978831607994386509967951279410162135133793419\"\n ; \"5020585421647265067890838871263925730422335215511670656851726444447972642755\"\n |]\n ; [| \"7256822974971238434100017358319972368738353570339258522235883585691301791128\"\n ; \"9789139064283320903202623693175751994730652446378861671859478926598420184293\"\n ; \"19283468246375057076525422714896652730563534118070235174488237489890270899533\"\n |]\n ; [| \"11487321478704551489982188818171823402443882145686911658585221913500937481156\"\n ; \"16513958012405406860890342996091255867910990589443610357743227675107758695101\"\n ; \"24764429351173766080138047602436205744310671344674490826288279531917797263231\"\n |]\n ; [| \"8256258316375000496541664568891934707113720493937218096466691600593595285909\"\n ; \"26919625894863883593081175799908601863265420311251948374988589188905317081443\"\n ; \"10135851848127171199130812615581006825969108287418884763125596866448544567342\"\n |]\n ; [| \"17567146349912867622479843655652582453162587996421871126612027345809646551661\"\n ; \"2524802431860351616270075327416865184018211992251290134350377936184047953453\"\n ; \"3417609143162661859785838333493682460709943782149216513733553607075915176256\"\n |]\n ; [| \"6906455011502599710165862205505812668908382042647994457156780865092846286493\"\n ; \"21042097659487317081899343674473811663642293019125869396575405454328274948985\"\n ; \"25222370053690749913129090298406788520061040938312366403907461864202905656238\"\n |]\n ; [| \"18933201791079410639949505893100361911334261775545573219434897335758052335005\"\n ; \"14503331557348715387048413780116585195932777696828173626366829282421027153184\"\n ; \"3558781473325529402549318082942465709639711182863041375748599816583729962116\"\n |]\n ; [| \"23932570601084008621895097434501731960424360312878373523779451810455362953625\"\n ; \"13286131463754478912858022007443470896920464302917391606059553157137090717219\"\n ; \"9969435194445819847988134248075866286921574284754991873902788928171429847506\"\n |]\n ; [| \"10821551500865029673311799086099720530496516676117927814621168667836737594374\"\n ; \"57689402905128519605376551862931564078571458212398163192591670282543962941\"\n ; \"4484359679395800410695081358212522306960518636189521201445105538223906998486\"\n |]\n |]\n }\n","open! Core_kernel\nopen! Import\n\nmodule type Slots = sig\n (** [Slots] has types [t1], ..., [t12] of arities 1 to 12 that are isomorphic to tuple\n types of the corresponding arities. Type [('a0, ..., 'a) t] corresponds to\n ['a0 * ... * 'a].\n\n Each type [ti] is an instance of type [('tuple, 'variant) t], in which ['tuple] is\n the tuple type ['a0 * ... * 'a] and ['variant] is an encoding of the tuple type\n in the form: [[ `S0 of `a0 | `S1 of `a1 | ... | `S of `a ]].\n\n The encoding of the slots using a polymorphic variant allows one to write functions\n that are polymorphic in the tuple type, and require that a tuple have a certain\n slot, but allow more slots.\n\n We make [t] itself a polymorphic variant type so that one can easily encode cyclic\n types, e.g. lists, like:\n\n {[\n type 'a slots = ('a, 'a slots Pointer.t) Slots.t2\n ]}\n\n Observe that [slots] in the above is cyclic, but that OCaml allows it because the\n definition expands to:\n\n {[\n type 'a slots = [ `Slots of ('a * 'a slots Pointer.t,\n [ `S0 of 'a\n | `S1 of 'a slots Pointer.t\n ]\n ) u\n ]\n ]}\n\n Ultimately, a [Slots.t] is used as a phantom type that ensures consistent usage of\n the tuples in the data structure containing them. *)\n\n type ('tuple, 'variant) u\n type ('tuple, 'variant) t = [ `Slots of ('tuple, 'variant) u ] [@@deriving sexp_of]\n\n val slots_per_tuple : (_, _) t -> int\n\n type 'a0 t1 = ('a0, [ `S0 of 'a0 ]) t [@@deriving sexp_of]\n type ('a0, 'a1) t2 = ('a0 * 'a1, [ `S0 of 'a0 | `S1 of 'a1 ]) t [@@deriving sexp_of]\n\n type ('a0, 'a1, 'a2) t3 = ('a0 * 'a1 * 'a2, [ `S0 of 'a0 | `S1 of 'a1 | `S2 of 'a2 ]) t\n [@@deriving sexp_of]\n\n type ('a0, 'a1, 'a2, 'a3) t4 =\n ('a0 * 'a1 * 'a2 * 'a3, [ `S0 of 'a0 | `S1 of 'a1 | `S2 of 'a2 | `S3 of 'a3 ]) t\n [@@deriving sexp_of]\n\n type ('a0, 'a1, 'a2, 'a3, 'a4) t5 =\n ( 'a0 * 'a1 * 'a2 * 'a3 * 'a4\n , [ `S0 of 'a0 | `S1 of 'a1 | `S2 of 'a2 | `S3 of 'a3 | `S4 of 'a4 ] )\n t\n [@@deriving sexp_of]\n\n type ('a0, 'a1, 'a2, 'a3, 'a4, 'a5) t6 =\n ( 'a0 * 'a1 * 'a2 * 'a3 * 'a4 * 'a5\n , [ `S0 of 'a0 | `S1 of 'a1 | `S2 of 'a2 | `S3 of 'a3 | `S4 of 'a4 | `S5 of 'a5 ] )\n t\n [@@deriving sexp_of]\n\n type ('a0, 'a1, 'a2, 'a3, 'a4, 'a5, 'a6) t7 =\n ( 'a0 * 'a1 * 'a2 * 'a3 * 'a4 * 'a5 * 'a6\n , [ `S0 of 'a0\n | `S1 of 'a1\n | `S2 of 'a2\n | `S3 of 'a3\n | `S4 of 'a4\n | `S5 of 'a5\n | `S6 of 'a6\n ] )\n t\n [@@deriving sexp_of]\n\n type ('a0, 'a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7) t8 =\n ( 'a0 * 'a1 * 'a2 * 'a3 * 'a4 * 'a5 * 'a6 * 'a7\n , [ `S0 of 'a0\n | `S1 of 'a1\n | `S2 of 'a2\n | `S3 of 'a3\n | `S4 of 'a4\n | `S5 of 'a5\n | `S6 of 'a6\n | `S7 of 'a7\n ] )\n t\n [@@deriving sexp_of]\n\n type ('a0, 'a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8) t9 =\n ( 'a0 * 'a1 * 'a2 * 'a3 * 'a4 * 'a5 * 'a6 * 'a7 * 'a8\n , [ `S0 of 'a0\n | `S1 of 'a1\n | `S2 of 'a2\n | `S3 of 'a3\n | `S4 of 'a4\n | `S5 of 'a5\n | `S6 of 'a6\n | `S7 of 'a7\n | `S8 of 'a8\n ] )\n t\n [@@deriving sexp_of]\n\n type ('a0, 'a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8, 'a9) t10 =\n ( 'a0 * 'a1 * 'a2 * 'a3 * 'a4 * 'a5 * 'a6 * 'a7 * 'a8 * 'a9\n , [ `S0 of 'a0\n | `S1 of 'a1\n | `S2 of 'a2\n | `S3 of 'a3\n | `S4 of 'a4\n | `S5 of 'a5\n | `S6 of 'a6\n | `S7 of 'a7\n | `S8 of 'a8\n | `S9 of 'a9\n ] )\n t\n [@@deriving sexp_of]\n\n type ('a0, 'a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8, 'a9, 'a10) t11 =\n ( 'a0 * 'a1 * 'a2 * 'a3 * 'a4 * 'a5 * 'a6 * 'a7 * 'a8 * 'a9 * 'a10\n , [ `S0 of 'a0\n | `S1 of 'a1\n | `S2 of 'a2\n | `S3 of 'a3\n | `S4 of 'a4\n | `S5 of 'a5\n | `S6 of 'a6\n | `S7 of 'a7\n | `S8 of 'a8\n | `S9 of 'a9\n | `S10 of 'a10\n ] )\n t\n [@@deriving sexp_of]\n\n type ('a0, 'a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8, 'a9, 'a10, 'a11) t12 =\n ( 'a0 * 'a1 * 'a2 * 'a3 * 'a4 * 'a5 * 'a6 * 'a7 * 'a8 * 'a9 * 'a10 * 'a11\n , [ `S0 of 'a0\n | `S1 of 'a1\n | `S2 of 'a2\n | `S3 of 'a3\n | `S4 of 'a4\n | `S5 of 'a5\n | `S6 of 'a6\n | `S7 of 'a7\n | `S8 of 'a8\n | `S9 of 'a9\n | `S10 of 'a10\n | `S11 of 'a11\n ] )\n t\n [@@deriving sexp_of]\n\n type ('a0, 'a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8, 'a9, 'a10, 'a11, 'a12) t13 =\n ( 'a0 * 'a1 * 'a2 * 'a3 * 'a4 * 'a5 * 'a6 * 'a7 * 'a8 * 'a9 * 'a10 * 'a11 * 'a12\n , [ `S0 of 'a0\n | `S1 of 'a1\n | `S2 of 'a2\n | `S3 of 'a3\n | `S4 of 'a4\n | `S5 of 'a5\n | `S6 of 'a6\n | `S7 of 'a7\n | `S8 of 'a8\n | `S9 of 'a9\n | `S10 of 'a10\n | `S11 of 'a11\n | `S12 of 'a12\n ] )\n t\n [@@deriving sexp_of]\n\n type ('a0, 'a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8, 'a9, 'a10, 'a11, 'a12, 'a13) t14 =\n ( 'a0\n * 'a1\n * 'a2\n * 'a3\n * 'a4\n * 'a5\n * 'a6\n * 'a7\n * 'a8\n * 'a9\n * 'a10\n * 'a11\n * 'a12\n * 'a13\n , [ `S0 of 'a0\n | `S1 of 'a1\n | `S2 of 'a2\n | `S3 of 'a3\n | `S4 of 'a4\n | `S5 of 'a5\n | `S6 of 'a6\n | `S7 of 'a7\n | `S8 of 'a8\n | `S9 of 'a9\n | `S10 of 'a10\n | `S11 of 'a11\n | `S12 of 'a12\n | `S13 of 'a13\n ] )\n t\n [@@deriving sexp_of]\n\n val t1 : _ t1\n val t2 : (_, _) t2\n val t3 : (_, _, _) t3\n val t4 : (_, _, _, _) t4\n val t5 : (_, _, _, _, _) t5\n val t6 : (_, _, _, _, _, _) t6\n val t7 : (_, _, _, _, _, _, _) t7\n val t8 : (_, _, _, _, _, _, _, _) t8\n val t9 : (_, _, _, _, _, _, _, _, _) t9\n val t10 : (_, _, _, _, _, _, _, _, _, _) t10\n val t11 : (_, _, _, _, _, _, _, _, _, _, _) t11\n val t12 : (_, _, _, _, _, _, _, _, _, _, _, _) t12\n val t13 : (_, _, _, _, _, _, _, _, _, _, _, _, _) t13\n val t14 : (_, _, _, _, _, _, _, _, _, _, _, _, _, _) t14\nend\n\nmodule type Slot = sig\n (** A [Slot.t] represents a slot in a tuple type. *)\n type ('variant, 'a) t [@@deriving sexp_of]\n\n val equal : ('v, 'a) t -> ('v, 'a) t -> bool\n\n (** [ti] is the [i]'th slot. *)\n\n val t0 : ([> `S0 of 'a ], 'a) t\n val t1 : ([> `S1 of 'a ], 'a) t\n val t2 : ([> `S2 of 'a ], 'a) t\n val t3 : ([> `S3 of 'a ], 'a) t\n val t4 : ([> `S4 of 'a ], 'a) t\n val t5 : ([> `S5 of 'a ], 'a) t\n val t6 : ([> `S6 of 'a ], 'a) t\n val t7 : ([> `S7 of 'a ], 'a) t\n val t8 : ([> `S8 of 'a ], 'a) t\n val t9 : ([> `S9 of 'a ], 'a) t\n val t10 : ([> `S10 of 'a ], 'a) t\n val t11 : ([> `S11 of 'a ], 'a) t\n val t12 : ([> `S12 of 'a ], 'a) t\n val t13 : ([> `S13 of 'a ], 'a) t\nend\n","open! Core_kernel\nopen! Import\ninclude Tuple_type_intf\n\nmodule Slots = struct\n type u_ = { slots_per_tuple : int } [@@deriving sexp_of]\n type ('tuple, 'variant) u = u_ [@@deriving sexp_of]\n type t_ = [ `Slots of u_ ] [@@deriving sexp_of]\n type ('tuple, 'variant) t = t_ [@@deriving sexp_of]\n\n let slots_per_tuple (`Slots { slots_per_tuple = n }) = n\n\n type 'a0 t1 = t_ [@@deriving sexp_of]\n type ('a0, 'a1) t2 = t_ [@@deriving sexp_of]\n type ('a0, 'a1, 'a2) t3 = t_ [@@deriving sexp_of]\n type ('a0, 'a1, 'a2, 'a3) t4 = t_ [@@deriving sexp_of]\n type ('a0, 'a1, 'a2, 'a3, 'a4) t5 = t_ [@@deriving sexp_of]\n type ('a0, 'a1, 'a2, 'a3, 'a4, 'a5) t6 = t_ [@@deriving sexp_of]\n type ('a0, 'a1, 'a2, 'a3, 'a4, 'a5, 'a6) t7 = t_ [@@deriving sexp_of]\n type ('a0, 'a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7) t8 = t_ [@@deriving sexp_of]\n type ('a0, 'a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8) t9 = t_ [@@deriving sexp_of]\n type ('a0, 'a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8, 'a9) t10 = t_ [@@deriving sexp_of]\n\n type ('a0, 'a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8, 'a9, 'a10) t11 = t_\n [@@deriving sexp_of]\n\n type ('a0, 'a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8, 'a9, 'a10, 'a11) t12 = t_\n [@@deriving sexp_of]\n\n type ('a0, 'a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8, 'a9, 'a10, 'a11, 'a12) t13 = t_\n [@@deriving sexp_of]\n\n type ('a0, 'a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8, 'a9, 'a10, 'a11, 'a12, 'a13) t14 =\n t_\n [@@deriving sexp_of]\n\n let t1 = `Slots { slots_per_tuple = 1 }\n let t2 = `Slots { slots_per_tuple = 2 }\n let t3 = `Slots { slots_per_tuple = 3 }\n let t4 = `Slots { slots_per_tuple = 4 }\n let t5 = `Slots { slots_per_tuple = 5 }\n let t6 = `Slots { slots_per_tuple = 6 }\n let t7 = `Slots { slots_per_tuple = 7 }\n let t8 = `Slots { slots_per_tuple = 8 }\n let t9 = `Slots { slots_per_tuple = 9 }\n let t10 = `Slots { slots_per_tuple = 10 }\n let t11 = `Slots { slots_per_tuple = 11 }\n let t12 = `Slots { slots_per_tuple = 12 }\n let t13 = `Slots { slots_per_tuple = 13 }\n let t14 = `Slots { slots_per_tuple = 14 }\nend\n","open! Core_kernel\nmodule Pool = Tuple_pool\nmodule Pointer = Pool.Pointer\n\n(* This pool holds nodes that would be represented more traditionally as:\n\n {[\n type 'a t =\n | Empty\n | Heap of 'a * 'a t list ]}\n\n We will represent them as a left-child, right-sibling tree in a triplet\n (value * left_child * right_sibling). The left child and all right siblings\n of the left child form a linked list representing the subheaps of a given heap:\n\n {v\n A\n /\n B -> C -> D -> E -> F\n / / /\n G H->I->J K->L\n v} *)\n\nmodule Node : sig\n (* Exposing [private int] is a significant performance improvement, because it allows\n the compiler to skip the write barrier. *)\n\n type 'a t = private int\n\n module Id : sig\n type t\n\n val of_int : int -> t\n val equal : t -> t -> bool\n end\n\n module Pool : sig\n type 'a node = 'a t\n type 'a t\n\n val create : min_size:int -> 'a t\n val is_full : 'a t -> bool\n val length : 'a t -> int\n val grow : 'a t -> 'a t\n val copy : 'a t -> 'a node -> 'a node * 'a t\n end\n\n (** [allocate v ~pool] allocates a new node from the pool with no child or sibling *)\n val allocate : 'a -> pool:'a Pool.t -> id:Id.t -> 'a t\n\n (** [free t ~pool] frees [t] for reuse. It is an error to access [t] after this. *)\n val free : 'a t -> pool:'a Pool.t -> unit\n\n (** a special [t] that represents the empty node *)\n val empty : unit -> 'a t\n\n val is_empty : 'a t -> bool\n val equal : 'a t -> 'a t -> bool\n\n (** [value_exn t ~pool] return the value of [t], raise if [is_empty t] *)\n val value_exn : 'a t -> pool:'a Pool.t -> 'a\n\n val id : 'a t -> pool:'a Pool.t -> Id.t\n val child : 'a t -> pool:'a Pool.t -> 'a t\n val sibling : 'a t -> pool:'a Pool.t -> 'a t\n\n (** [prev t] is either the parent of [t] or the sibling immediately left of [t] *)\n val prev : 'a t -> pool:'a Pool.t -> 'a t\n\n (** [add_child t ~child ~pool] Add a child to [t], preserving existing children as\n siblings of [child]. [t] and [child] should not be empty and [child] should have no\n sibling and have no prev node. *)\n val add_child : 'a t -> child:'a t -> pool:'a Pool.t -> unit\n\n (** disconnect and return the sibling *)\n val disconnect_sibling : 'a t -> pool:'a Pool.t -> 'a t\n\n (** disconnect and return the child *)\n val disconnect_child : 'a t -> pool:'a Pool.t -> 'a t\n\n (** [detach t ~pool] removes [t] from the tree, adjusting pointers around it. After\n [detach], [t] is the root of a standalone heap, which is detached from the original\n heap. *)\n val detach : 'a t -> pool:'a Pool.t -> unit\nend = struct\n module Id = Int\n\n let dummy_id : Id.t = -1\n\n type 'a node =\n ('a, 'a node Pointer.t, 'a node Pointer.t, 'a node Pointer.t, Id.t) Pool.Slots.t5\n\n type 'a t = 'a node Pointer.t\n\n let empty = Pointer.null\n let is_empty = Pointer.is_null\n let equal = Pointer.phys_equal\n let value t ~pool = Pool.get pool t Pool.Slot.t0\n let child t ~pool = Pool.get pool t Pool.Slot.t1\n let sibling t ~pool = Pool.get pool t Pool.Slot.t2\n let prev t ~pool = Pool.get pool t Pool.Slot.t3\n let id t ~pool = Pool.get pool t Pool.Slot.t4\n\n (* let set_value t v ~pool = Pool.set pool t Pool.Slot.t0 v *)\n let set_child t v ~pool = Pool.set pool t Pool.Slot.t1 v\n let set_sibling t v ~pool = Pool.set pool t Pool.Slot.t2 v\n let set_prev t v ~pool = Pool.set pool t Pool.Slot.t3 v\n\n let value_exn t ~pool =\n assert (not (is_empty t));\n value t ~pool\n ;;\n\n let allocate value ~pool ~id = Pool.new5 pool value (empty ()) (empty ()) (empty ()) id\n let free t ~pool = Pool.unsafe_free pool t\n\n let disconnect_sibling t ~pool =\n let sibling = sibling t ~pool in\n if not (is_empty sibling)\n then (\n set_sibling t (empty ()) ~pool;\n set_prev sibling (empty ()) ~pool);\n sibling\n ;;\n\n let disconnect_child t ~pool =\n let child = child t ~pool in\n if not (is_empty child)\n then (\n set_child t (empty ()) ~pool;\n set_prev child (empty ()) ~pool);\n child\n ;;\n\n let add_child t ~child:new_child ~pool =\n (* assertions we would make, but for speed:\n assert (not (is_empty t));\n assert (not (is_empty new_child));\n assert (is_empty (sibling new_child ~pool));\n assert (is_empty (prev new_child ~pool));\n *)\n let current_child = disconnect_child t ~pool in\n (* add [new_child] to the list of [t]'s children (which may be empty) *)\n set_sibling new_child current_child ~pool;\n if not (is_empty current_child) then set_prev current_child new_child ~pool;\n set_child t new_child ~pool;\n set_prev new_child t ~pool\n ;;\n\n let detach t ~pool =\n if not (is_empty t)\n then (\n let prev = prev t ~pool in\n if not (is_empty prev)\n then (\n let relation_to_prev = if equal t (child prev ~pool) then `child else `sibling in\n set_prev t (empty ()) ~pool;\n let sibling = disconnect_sibling t ~pool in\n (match relation_to_prev with\n | `child -> set_child prev sibling ~pool\n | `sibling -> set_sibling prev sibling ~pool);\n if not (is_empty sibling) then set_prev sibling prev ~pool))\n ;;\n\n module Pool = struct\n type 'a t = 'a node Pool.t\n type nonrec 'a node = 'a node Pointer.t\n\n let create (type a) ~min_size:capacity : a t =\n Pool.create\n Pool.Slots.t5\n ~capacity\n ~dummy:\n ( (Obj.magic None : a)\n , Pointer.null ()\n , Pointer.null ()\n , Pointer.null ()\n , dummy_id )\n ;;\n\n let is_full t = Pool.is_full t\n let length t = Pool.length t\n let grow t = Pool.grow t\n\n let copy t start =\n let t' = create ~min_size:(Pool.capacity t) in\n let copy_node node to_visit =\n if is_empty node\n then empty (), to_visit\n else (\n (* we use the same id, but that's ok since ids should be unique per heap *)\n let new_node =\n allocate (value_exn node ~pool:t) ~pool:t' ~id:(id node ~pool:t)\n in\n let to_visit =\n (new_node, `child, child node ~pool:t)\n :: (new_node, `sibling, sibling node ~pool:t)\n :: to_visit\n in\n new_node, to_visit)\n in\n let rec loop to_visit =\n match to_visit with\n | [] -> ()\n | (node_to_update, slot, node_to_copy) :: rest ->\n let new_node, to_visit = copy_node node_to_copy rest in\n (match slot with\n | `child -> set_child node_to_update new_node ~pool:t'\n | `sibling -> set_sibling node_to_update new_node ~pool:t');\n if not (is_empty new_node) then set_prev new_node node_to_update ~pool:t';\n loop to_visit\n in\n let new_start, to_visit = copy_node start [] in\n loop to_visit;\n new_start, t'\n ;;\n end\nend\n\ntype 'a t =\n { (* cmp is placed first to short-circuit polymorphic compare *)\n cmp : 'a -> 'a -> int\n ; mutable pool : 'a Node.Pool.t\n ; (* invariant: [root] never has a sibling *)\n mutable root : 'a Node.t\n ; mutable num_of_allocated_nodes : int\n }\n\nlet invariant _ t =\n let rec loop to_visit =\n match to_visit with\n | [] -> ()\n | (node, expected_prev, maybe_parent_value) :: rest ->\n if not (Node.is_empty node)\n then (\n let this_value = Node.value_exn node ~pool:t.pool in\n assert (Node.equal (Node.prev node ~pool:t.pool) expected_prev);\n Option.iter maybe_parent_value ~f:(fun parent_value ->\n assert (t.cmp parent_value this_value <= 0));\n loop\n ((Node.child node ~pool:t.pool, node, Some this_value)\n :: (Node.sibling node ~pool:t.pool, node, maybe_parent_value)\n :: rest))\n else loop rest\n in\n assert (Node.is_empty t.root || Node.is_empty (Node.sibling t.root ~pool:t.pool));\n loop [ t.root, Node.empty (), None ]\n;;\n\nlet create ?(min_size = 1) ~cmp () =\n { cmp\n ; pool = Node.Pool.create ~min_size\n ; root = Node.empty ()\n ; num_of_allocated_nodes = 0\n }\n;;\n\nlet copy { cmp; pool; root; num_of_allocated_nodes } =\n let root, pool = Node.Pool.copy pool root in\n { cmp; pool; root; num_of_allocated_nodes }\n;;\n\nlet allocate t v =\n if Node.Pool.is_full t.pool then t.pool <- Node.Pool.grow t.pool;\n t.num_of_allocated_nodes <- t.num_of_allocated_nodes + 1;\n Node.allocate v ~pool:t.pool ~id:(Node.Id.of_int t.num_of_allocated_nodes)\n;;\n\n(* translation:\n {[\n match root1, root2 with\n | None, h | h, None -> h\n | Some (Node (v1, children1)), Some (Node (v2, children2)) ->\n if v1 < v2\n then Some (Node (v1, root2 :: children1))\n else Some (Node (v2, root1 :: children2))\n ]}\n\n This function assumes neither root has a prev node (usually because the inputs come\n from [disconnect_*] or are the top of the heap or are the output of this function). *)\nlet merge t root1 root2 =\n if Node.is_empty root1\n then root2\n else if Node.is_empty root2\n then root1\n else (\n let add_child t node ~child =\n Node.add_child node ~pool:t.pool ~child;\n node\n in\n let v1 = Node.value_exn root1 ~pool:t.pool in\n let v2 = Node.value_exn root2 ~pool:t.pool in\n if t.cmp v1 v2 < 0\n then add_child t root1 ~child:root2\n else add_child t root2 ~child:root1)\n;;\n\nlet top_exn t =\n if Node.is_empty t.root\n then failwith \"Heap.top_exn called on an empty heap\"\n else Node.value_exn t.root ~pool:t.pool\n;;\n\nlet top t = if Node.is_empty t.root then None else Some (top_exn t)\n\nlet add_node t v =\n let node = allocate t v in\n t.root <- merge t t.root node;\n node\n;;\n\nlet add t v = ignore (add_node t v : _ Node.t)\n\n(* [merge_pairs] takes a list of heap roots and merges consecutive pairs, reducing the\n list of length n to n/2. Then it merges the merged pairs into a single heap. One\n intuition is that this is somewhat like building a single level of a binary tree.\n\n The output heap does not contain the value that was at the root of the input heap.\n\n We break the function into two parts. A first stage that is willing to use limited\n stack instead of heap allocation for bookkeeping, and a second stage that shifts to\n using a list as an accumulator if we go too deep.\n\n This can be made tail recursive and non-allocating by starting with an empty heap and\n merging merged pairs into it. Unfortunately this \"left fold\" version is not what is\n described in the original paper by Fredman et al.; they specifically say that\n children should be merged together from the end of the list to the beginning of the\n list. ([merge] is not associative, so order matters.)\n*)\n(* translation:\n {[\n let rec loop acc = function\n | [] -> acc\n | [head] -> head :: acc\n | head :: next1 :: next2 -> loop (merge head next1 :: acc) next2\n in\n match loop [] children with\n | [] -> None\n | [h] -> Some h\n | x :: xs -> Some (List.fold xs ~init:x ~f:merge)\n ]}\n*)\nlet allocating_merge_pairs t head =\n let rec loop acc head =\n if Node.is_empty head\n then acc\n else (\n let next1 = Node.disconnect_sibling head ~pool:t.pool in\n if Node.is_empty next1\n then head :: acc\n else (\n let next2 = Node.disconnect_sibling next1 ~pool:t.pool in\n loop (merge t head next1 :: acc) next2))\n in\n match loop [] head with\n | [] -> Node.empty ()\n | [ h ] -> h\n | x :: xs -> List.fold xs ~init:x ~f:(fun acc heap -> merge t acc heap)\n;;\n\n(* translation:\n {[\n match t.root with\n | Node (_, children) ->\n let rec loop depth children =\n if depth >= max_stack_depth\n then allocating_merge_pairs t childen\n else begin\n match children with\n | [] -> None\n | [head] -> Some head\n | head :: next1 :: next2 ->\n merge (merge head next1) (loop (depth + 1) next2)\n end\n in\n loop 0 children\n ]}\n*)\nlet merge_pairs =\n let max_stack_depth = 1_000 in\n let rec loop t depth head =\n if depth >= max_stack_depth\n then allocating_merge_pairs t head\n else if Node.is_empty head\n then head\n else (\n let next1 = Node.disconnect_sibling head ~pool:t.pool in\n if Node.is_empty next1\n then head\n else (\n let next2 = Node.disconnect_sibling next1 ~pool:t.pool in\n (* merge the first two nodes in our list, and then merge the result with the\n result of recursively calling merge_pairs on the tail *)\n merge t (merge t head next1) (loop t (depth + 1) next2)))\n in\n fun t head -> loop t 0 head\n;;\n\nlet remove_non_empty t node =\n let pool = t.pool in\n Node.detach node ~pool;\n let merged_children = merge_pairs t (Node.disconnect_child node ~pool) in\n let new_root =\n if Node.equal t.root node then merged_children else merge t t.root merged_children\n in\n Node.free node ~pool;\n t.root <- new_root\n;;\n\nlet remove_top t = if not (Node.is_empty t.root) then remove_non_empty t t.root\n\nlet pop_exn t =\n let r = top_exn t in\n remove_top t;\n r\n;;\n\nlet pop t = if Node.is_empty t.root then None else Some (pop_exn t)\n\nlet pop_if t f =\n match top t with\n | None -> None\n | Some v ->\n if f v\n then (\n remove_top t;\n Some v)\n else None\n;;\n\n(* pairing heaps are not balanced trees, and therefore we can't rely on a balance\n property to stop ourselves from overflowing the stack. *)\nlet fold t ~init ~f =\n let pool = t.pool in\n let rec loop acc to_visit =\n match to_visit with\n | [] -> acc\n | node :: rest ->\n if Node.is_empty node\n then loop acc rest\n else (\n let to_visit = Node.sibling ~pool node :: Node.child ~pool node :: rest in\n loop (f acc (Node.value_exn ~pool node)) to_visit)\n in\n loop init [ t.root ]\n;;\n\n(* almost identical to fold, copied for speed purposes *)\nlet iter t ~f =\n let pool = t.pool in\n let rec loop to_visit =\n match to_visit with\n | [] -> ()\n | node :: rest ->\n if Node.is_empty node\n then loop rest\n else (\n f (Node.value_exn ~pool node);\n let to_visit = Node.sibling ~pool node :: Node.child ~pool node :: rest in\n loop to_visit)\n in\n loop [ t.root ]\n;;\n\nlet length t = Node.Pool.length t.pool\n\nmodule C = Container.Make (struct\n type nonrec 'a t = 'a t\n\n let fold = fold\n let iter = `Custom iter\n let length = `Custom length\n end)\n\nlet is_empty t = Node.is_empty t.root\nlet mem = C.mem\nlet exists = C.exists\nlet for_all = C.for_all\nlet count = C.count\nlet sum = C.sum\nlet find = C.find\nlet find_map = C.find_map\nlet to_list = C.to_list\nlet to_array = C.to_array\nlet min_elt = C.min_elt\nlet max_elt = C.max_elt\nlet fold_result = C.fold_result\nlet fold_until = C.fold_until\n\nlet of_array arr ~cmp =\n let t = create ~min_size:(Array.length arr) ~cmp () in\n Array.iter arr ~f:(fun v -> add t v);\n t\n;;\n\nlet of_list l ~cmp = of_array (Array.of_list l) ~cmp\nlet sexp_of_t f t = Array.sexp_of_t f (to_array t |> Array.sorted_copy ~compare:t.cmp)\n\nmodule Elt = struct\n type nonrec 'a t =\n { mutable node : 'a Node.t\n ; node_id : Node.Id.t\n ; heap : 'a t\n }\n\n (* If ids are different, it means that the node has already been removed by some\n other means (and possibly reused). *)\n let is_node_valid t = Node.Id.equal (Node.id ~pool:t.heap.pool t.node) t.node_id\n\n let value t =\n if is_node_valid t then Some (Node.value_exn t.node ~pool:t.heap.pool) else None\n ;;\n\n let value_exn t =\n if is_node_valid t\n then Node.value_exn t.node ~pool:t.heap.pool\n else failwith \"Heap.value_exn: node was removed from the heap\"\n ;;\n\n let sexp_of_t sexp_of_a t = [%sexp (value t : a option)]\nend\n\nlet remove t (token : _ Elt.t) =\n if not (phys_equal t token.heap)\n then failwith \"cannot remove from a different heap\"\n else if not (Node.is_empty token.node)\n then (\n if Elt.is_node_valid token then remove_non_empty t token.node;\n token.node <- Node.empty ())\n;;\n\nlet add_removable t v =\n let node = add_node t v in\n { Elt.node; heap = t; node_id = Node.id ~pool:t.pool node }\n;;\n\nlet update t token v =\n remove t token;\n add_removable t v\n;;\n\nlet find_elt =\n let rec loop t f nodes =\n match nodes with\n | [] -> None\n | node :: rest ->\n if Node.is_empty node\n then loop t f rest\n else if f (Node.value_exn node ~pool:t.pool)\n then Some { Elt.node; heap = t; node_id = Node.id ~pool:t.pool node }\n else\n loop t f (Node.sibling node ~pool:t.pool :: Node.child node ~pool:t.pool :: rest)\n in\n fun t ~f -> loop t f [ t.root ]\n;;\n\nmodule Unsafe = struct\n module Elt = struct\n type 'a heap = 'a t\n type 'a t = 'a Node.t\n\n let value t heap = Node.value_exn ~pool:heap.pool t\n end\n\n let add_removable = add_node\n let remove = remove_non_empty\n\n let update t elt v =\n remove t elt;\n add_removable t v\n ;;\nend\n","open! Core_kernel\n\nmodule Make (M : sig\n val am_running_test : bool\n end) =\nstruct\n type 'a t = 'a [@@deriving bin_io, compare, sexp]\n\n let sexp_of_t sexp_of_a a =\n if M.am_running_test then Sexp.Atom \"\" else sexp_of_a a\n ;;\n\n module With_non_roundtripping_in_test_of_sexp = struct\n type nonrec 'a t = 'a t [@@deriving bin_io, compare, sexp]\n end\nend\n\nlet%test_module _ =\n (module struct\n module Turned_off = struct\n module Sexp_hidden_in_test_turned_off = Make (struct\n let am_running_test = false\n end)\n\n type nonrec t = int Sexp_hidden_in_test_turned_off.t [@@deriving sexp_of]\n end\n\n module Turned_on = struct\n module Sexp_hidden_in_test_turned_on = Make (struct\n let am_running_test = true\n end)\n\n type nonrec t = int Sexp_hidden_in_test_turned_on.t [@@deriving sexp_of]\n end\n\n let%expect_test \"Turned on\" =\n print_s [%sexp (1024 : Turned_on.t)];\n [%expect {| |}]\n ;;\n\n let%expect_test \"Turned off\" =\n print_s ([%sexp_of: Turned_off.t] 1024);\n [%expect {| 1024 |}]\n ;;\n end)\n;;\n\ninclude Make (struct\n let am_running_test = am_running_test\n end)\n","(* This module exploits the fact that OCaml does not perform context-switches under\n certain conditions. It can therefore avoid using mutexes.\n\n Given the semantics of the current OCaml runtime (and for the foreseeable future), code\n sections documented as atomic below will never contain a context-switch. The deciding\n criterion is whether they contain allocations or calls to external/builtin functions.\n If there is none, a context-switch cannot happen. Assignments without allocations,\n field access, pattern-matching, etc., do not trigger context-switches.\n\n Code reviewers should therefore make sure that the sections documented as atomic below\n do not violate the above assumptions. It is prudent to disassemble the .o file (using\n [objdump -dr]) and examine it. *)\n\nopen! Core_kernel\nopen! Import\n\nmodule Elt = struct\n type 'a t =\n { mutable value : 'a Uopt.t\n ; mutable next : ('a t Uopt.t[@sexp.opaque])\n }\n [@@deriving sexp_of]\n\n let create () = { value = Uopt.none; next = Uopt.none }\nend\n\ntype 'a t =\n { mutable length : int\n (* [front] to [back] has [length + 1] linked elements, where the first [length] hold the\n values in the queue, and the last is [back], holding no value. *)\n ; mutable front : 'a Elt.t\n ; mutable back : 'a Elt.t\n (* [unused_elts] is singly linked via [next], and ends with [sentinel]. All elts in\n [unused_elts] have [Uopt.is_none elt.value]. *)\n ; mutable unused_elts : 'a Elt.t Uopt.t\n }\n[@@deriving fields, sexp_of]\n\nlet invariant _invariant_a t =\n Invariant.invariant [%here] t [%sexp_of: _ t] (fun () ->\n let check f = Invariant.check_field t f in\n Fields.iter\n ~length:(check (fun length -> assert (length >= 0)))\n ~front:\n (check (fun front ->\n let i = ref t.length in\n let r = ref front in\n while !i > 0 do\n decr i;\n let elt = !r in\n r := Uopt.value_exn elt.Elt.next;\n assert (Uopt.is_some elt.value)\n done;\n assert (phys_equal !r t.back)))\n ~back:(check (fun back -> assert (Uopt.is_none back.Elt.value)))\n ~unused_elts:\n (check (fun unused_elts ->\n let r = ref unused_elts in\n while Uopt.is_some !r do\n let elt = Uopt.value_exn !r in\n r := elt.Elt.next;\n assert (Uopt.is_none elt.value)\n done)))\n;;\n\nlet create () =\n let elt = Elt.create () in\n { front = elt; back = elt; length = 0; unused_elts = Uopt.none }\n;;\n\nlet get_unused_elt t =\n (* BEGIN ATOMIC SECTION *)\n if Uopt.is_some t.unused_elts\n then (\n let elt = Uopt.unsafe_value t.unused_elts in\n t.unused_elts <- elt.next;\n elt (* END ATOMIC SECTION *))\n else Elt.create ()\n;;\n\nlet enqueue (type a) (t : a t) (a : a) =\n let new_back = get_unused_elt t in\n (* BEGIN ATOMIC SECTION *)\n t.length <- t.length + 1;\n t.back.value <- Uopt.some a;\n t.back.next <- Uopt.some new_back;\n t.back <- new_back\n;;\n\n(* END ATOMIC SECTION *)\n\nlet return_unused_elt t (elt : _ Elt.t) =\n (* BEGIN ATOMIC SECTION *)\n elt.value <- Uopt.none;\n elt.next <- t.unused_elts;\n t.unused_elts <- Uopt.some elt;\n (* END ATOMIC SECTION *)\n ()\n;;\n\nlet[@cold] raise_dequeue_empty t =\n failwiths\n ~here:[%here]\n \"Thread_safe_queue.dequeue_exn of empty queue\"\n t\n [%sexp_of: _ t]\n;;\n\nlet dequeue_exn t =\n (* BEGIN ATOMIC SECTION *)\n if t.length = 0 then raise_dequeue_empty t;\n let elt = t.front in\n let a = elt.value in\n t.front <- Uopt.unsafe_value elt.next;\n t.length <- t.length - 1;\n (* END ATOMIC SECTION *)\n return_unused_elt t elt;\n Uopt.unsafe_value a\n;;\n\nlet clear_internal_pool t = t.unused_elts <- Uopt.none\n\nmodule Private = struct\n module Uopt = Uopt\nend\n","include Core_kernel.Core_kernel_private.Time_ns_alternate_sexp\n\n(* [after] is like [add], but deals nicely with the case of overflow by instead returning\n [max_value]. Time-source functions use [after] to avoid immediately firing events that\n should never fire, due to the overflow leading to a negative time that appears to be in\n the past. We don't check underflow because that is very unlikely, requiring both a\n negative time and a negative span. *)\nlet after t span =\n let result = add t span in\n if Span.( > ) span Span.zero && result < t then max_value_for_1us_rounding else result\n;;\n","open Core_kernel\nopen Import\n\nlet debug = Debug.monitor\n\ntype t = Types.Monitor.t =\n { name : Info.t\n ; here : Source_code_position.t option\n ; id : int\n ; parent : t option\n ; mutable next_error : exn Types.Ivar.t\n ; (* [Monitor.send_exn] schedules a job for each element of [handlers_for_all_errors]. *)\n mutable handlers_for_all_errors : (Types.Execution_context.t * (exn -> unit)) Bag.t\n ; (* [Monitor.send_exn] extends each tail in [tails_for_all_errors]. *)\n mutable tails_for_all_errors : exn Types.Tail.t list\n ; mutable has_seen_error : bool\n ; mutable is_detached : bool\n }\n[@@deriving fields]\n\nmodule Pretty = struct\n type one =\n { name : Info.t\n ; here : Source_code_position.t option\n ; id : int\n ; has_seen_error : bool\n ; is_detached : bool\n }\n [@@deriving sexp_of]\n\n type t = one list [@@deriving sexp_of]\nend\n\nlet to_pretty =\n let rec loop\n { name\n ; here\n ; id\n ; parent\n ; has_seen_error\n ; is_detached\n ; next_error = _\n ; handlers_for_all_errors = _\n ; tails_for_all_errors = _\n }\n ac\n =\n let ac = { Pretty.name; here; id; has_seen_error; is_detached } :: ac in\n match parent with\n | None -> List.rev ac\n | Some t -> loop t ac\n in\n fun t -> loop t []\n;;\n\nlet sexp_of_t t = Pretty.sexp_of_t (to_pretty t)\n\nlet next_id =\n let r = ref 0 in\n fun () ->\n incr r;\n !r\n;;\n\nlet create_with_parent ?here ?info ?name parent =\n let id = next_id () in\n let name =\n match info, name with\n | Some i, None -> i\n | Some i, Some s -> Info.tag i ~tag:s\n | None, Some s -> Info.of_string s\n | None, None -> Info.create \"id\" id [%sexp_of: int]\n in\n let t =\n { name\n ; here\n ; parent\n ; id\n ; next_error = { cell = Empty }\n ; handlers_for_all_errors = Bag.create ()\n ; tails_for_all_errors = []\n ; has_seen_error = false\n ; is_detached = false\n }\n in\n if debug then Debug.log \"created monitor\" t [%sexp_of: t];\n t\n;;\n\nlet main = create_with_parent ~name:\"main\" None\n","module Time_ns_in_this_directory = Time_ns\nopen Core_kernel\nmodule Time_ns = Time_ns_in_this_directory\ninclude Async_kernel_config.Print_debug_messages_for\n\nlet log message a sexp_of_a =\n eprintf\n \"%s\\n%!\"\n (Sexp.to_string_hum\n ([%sexp_of: Sexp.t * Time_ns.t * string * a]\n (!Async_kernel_config.task_id (), Time_ns.now (), message, a)))\n;;\n\nlet log_string message = log message () [%sexp_of: unit]\n","module Debug_in_this_directory = Debug\nmodule Time_ns_in_this_directory = Time_ns\nopen! Core_kernel\ninclude Int.Replace_polymorphic_compare\nmodule Debug = Debug_in_this_directory\nmodule Time_ns = Time_ns_in_this_directory\nmodule Epoll_max_ready_events = Async_kernel_config.Epoll_max_ready_events\nmodule Max_inter_cycle_timeout = Async_kernel_config.Max_inter_cycle_timeout\nmodule Max_num_open_file_descrs = Async_kernel_config.Max_num_open_file_descrs\nmodule Max_num_threads = Async_kernel_config.Max_num_threads\nmodule Pool = Tuple_pool\n\nmodule Max_num_jobs_per_priority_per_cycle =\n Async_kernel_config.Max_num_jobs_per_priority_per_cycle\n\nlet concat = String.concat\nlet eprint = Core_kernel.Debug.eprint\nlet eprint_s = Core_kernel.Debug.eprint_s\nlet eprints = Core_kernel.Debug.eprints\nlet print_s sexp = printf \"%s\\n%!\" (sexp |> Sexp.to_string_hum)\nlet sec = Time_ns.Span.of_sec\n\n(* We don't want to use these modules in Async_kernel, to avoid difficulties with\n using it on js_of_ocaml. *)\nmodule Thread = struct end\nmodule Unix = struct end\n","open! Core_kernel\nopen! Import\n\ntype t =\n | Normal\n | Low\n[@@deriving sexp_of]\n\nlet normal = Normal\nlet low = Low\n","(* This file defines the mutually recursive types at the heart of Async. The functions\n associated with the types are defined in the corresponding file(s) for each module.\n This file should define only types, not functions, since functions defined inside the\n recursive modules are not inlined.\n\n If you need to add functionality to a module but doing so would create a dependency\n cycle, split the file into pieces as needed to break the cycle, e.g. scheduler0.ml,\n scheduler1.ml, scheduler.ml. *)\n\nopen! Core_kernel\nopen! Import\n\nmodule rec Cell : sig\n type any =\n [ `Empty\n | `Empty_one_handler\n | `Empty_one_or_more_handlers\n | `Full\n | `Indir\n ]\n\n type ('a, 'b) t =\n | Empty_one_or_more_handlers :\n { mutable run : 'a -> unit\n ; execution_context : Execution_context.t\n ; mutable prev : 'a Handler.t\n ; mutable next : 'a Handler.t\n }\n -> ('a, [> `Empty_one_or_more_handlers ]) t\n | Empty_one_handler :\n ('a -> unit) * Execution_context.t\n -> ('a, [> `Empty_one_handler ]) t\n | Empty : ('a, [> `Empty ]) t\n | Full : 'a -> ('a, [> `Full ]) t\n | Indir : 'a Ivar.t -> ('a, [> `Indir ]) t\nend =\n Cell\n\nand Handler : sig\n type 'a t = ('a, [ `Empty_one_or_more_handlers ]) Cell.t\nend =\n Handler\n\nand Ivar : sig\n type 'a t = { mutable cell : ('a, Cell.any) Cell.t }\n\n module Immutable : sig\n type 'a t = { cell : ('a, Cell.any) Cell.t }\n end\nend =\n Ivar\n\nand Deferred : sig\n type +'a t\nend =\n Deferred\n\nand Execution_context : sig\n type t =\n { monitor : Monitor.t\n ; priority : Priority.t\n ; local_storage : Univ_map.t\n ; tid : int\n ; backtrace_history : Backtrace.t list\n }\nend =\n Execution_context\n\nand Monitor : sig\n type t =\n { name : Info.t\n ; here : Source_code_position.t option\n ; id : int\n ; parent : t option\n ; mutable next_error : exn Ivar.t\n ; mutable handlers_for_all_errors : (Execution_context.t * (exn -> unit)) Bag.t\n ; mutable tails_for_all_errors : exn Tail.t list\n ; mutable has_seen_error : bool\n ; mutable is_detached : bool\n }\nend =\n Monitor\n\nand Tail : sig\n type 'a t = { mutable next : 'a Stream.next Ivar.t }\nend =\n Tail\n\nand Stream : sig\n type 'a t = 'a next Deferred.t\n\n and 'a next =\n | Nil\n | Cons of 'a * 'a t\nend =\n Stream\n\n(* We avoid using [module rec] to define [Bvar], so that [to_repr] and [of_repr] are\n inlined. *)\nmodule Bvar : sig\n type ('a, -'permission) t\n\n (** [repr] exists so that we may hide the implementation of a [Bvar.t], and then add a\n phantom type to it upstream. Without this, the phantom type variable would allow\n for anything to be coerced in and out, since it is unused. *)\n type 'a repr =\n { mutable has_any_waiters : bool\n ; mutable ivar : 'a Ivar.t\n }\n\n val of_repr : 'a repr -> ('a, 'permission) t\n val to_repr : ('a, 'permission) t -> 'a repr\nend = struct\n type 'a repr =\n { mutable has_any_waiters : bool\n ; mutable ivar : 'a Ivar.t\n }\n\n type ('a, 'permission) t = 'a repr\n\n let to_repr t = t\n let of_repr t = t\nend\n\nmodule rec Event : sig\n module Status : sig\n type t =\n | Aborted\n | Fired\n | Happening\n | Scheduled\n | Unscheduled\n end\n\n type t =\n { mutable alarm : Job_or_event.t Timing_wheel.Alarm.t\n ; mutable at : Time_ns.t\n ; callback : unit -> unit\n ; execution_context : Execution_context.t\n ; mutable interval : Time_ns.Span.t option\n ; mutable next_fired : t\n ; mutable status : Status.t\n }\nend =\n Event\n\nand External_job : sig\n type t = T : Execution_context.t * ('a -> unit) * 'a -> t\nend =\n External_job\n\nand Job : sig\n type slots = (Execution_context.t, Obj.t -> unit, Obj.t) Pool.Slots.t3\n type t = slots Pool.Pointer.t\nend =\n Job\n\nand Job_or_event : sig\n type t\nend =\n Job_or_event\n\nand Job_pool : sig\n type t = Job.slots Pool.t\nend =\n Job_pool\n\nand Job_queue : sig\n type t =\n { mutable num_jobs_run : int\n ; mutable jobs_left_this_cycle : int\n ; mutable jobs : Obj.t Uniform_array.t\n ; mutable mask : int\n ; mutable front : int\n ; mutable length : int\n }\nend =\n Job_queue\n\nand Jobs : sig\n type t =\n { scheduler : Scheduler.t\n ; mutable job_pool : Job_pool.t\n ; normal : Job_queue.t\n ; low : Job_queue.t\n }\nend =\n Jobs\n\nand Scheduler : sig\n\n type t =\n { mutable check_access : (unit -> unit) option\n ; mutable job_pool : Job_pool.t\n ; normal_priority_jobs : Job_queue.t\n ; low_priority_jobs : Job_queue.t\n ; very_low_priority_workers : Very_low_priority_worker.t Deque.t\n ; mutable main_execution_context : Execution_context.t\n ; mutable current_execution_context : Execution_context.t\n ; mutable uncaught_exn : (Exn.t * Sexp.t) option\n ; mutable cycle_count : int\n ; mutable cycle_start : Time_ns.t\n ; mutable in_cycle : bool\n ; mutable run_every_cycle_start : (unit -> unit) list\n ; mutable run_every_cycle_end : (unit -> unit) list\n ; mutable last_cycle_time : Time_ns.Span.t\n ; mutable last_cycle_num_jobs : int\n ; mutable total_cycle_time : Time_ns.Span.t\n ; mutable time_source : read_write Time_source.t1\n ; external_jobs : External_job.t Thread_safe_queue.t\n ; mutable thread_safe_external_job_hook : unit -> unit\n ; mutable job_queued_hook : (Priority.t -> unit) option\n ; mutable event_added_hook : (Time_ns.t -> unit) option\n ; mutable yield : (unit, read_write) Bvar.t\n ; mutable yield_until_no_jobs_remain : (unit, read_write) Bvar.t\n ; mutable check_invariants : bool\n ; mutable max_num_jobs_per_priority_per_cycle : Max_num_jobs_per_priority_per_cycle.t\n ; mutable record_backtraces : bool\n ; mutable on_start_of_cycle : unit -> unit\n ; mutable on_end_of_cycle : unit -> unit\n ; mutable long_jobs_last_cycle : (Execution_context.t * Time_ns.Span.t) list\n ; mutable cycle_started : bool\n }\nend =\n Scheduler\n\nand Time_source_id : Unique_id.Id = Unique_id.Int63 ()\n\nand Time_source : sig\n type -'rw t1 =\n { id : Time_source_id.t\n ; mutable advance_errors : Error.t list\n ; mutable am_advancing : bool\n ; events : Job_or_event.t Timing_wheel.t\n ; mutable fired_events : Event.t\n ; mutable most_recently_fired : Event.t\n ; handle_fired : Job_or_event.t Timing_wheel.Alarm.t -> unit\n ; is_wall_clock : bool\n ; scheduler : Scheduler.t\n }\nend =\n Time_source\n\nand Very_low_priority_worker : sig\n module Exec_result : sig\n type t =\n | Finished\n | Not_finished\n end\n\n type t =\n { execution_context : Execution_context.t\n ; exec : unit -> Exec_result.t\n }\nend =\n Very_low_priority_worker\n","open! Core_kernel\nopen! Import\nmodule Monitor = Monitor0\n\ntype t = Types.Execution_context.t =\n { monitor : Monitor.t\n ; priority : Priority.t\n ; local_storage : Univ_map.t\n ; tid : int\n ; backtrace_history : Backtrace.t list\n }\n[@@deriving fields, sexp_of]\n\nlet invariant (_ : t) = ()\n\nlet main =\n { monitor = Monitor.main\n ; priority = Priority.normal\n ; local_storage = Univ_map.empty\n ; tid = 0\n ; backtrace_history = []\n }\n;;\n\nlet create_like ?monitor ?priority ?local_storage t =\n let monitor = Option.value monitor ~default:t.monitor in\n { monitor\n ; priority = Option.value priority ~default:t.priority\n ; local_storage = Option.value local_storage ~default:t.local_storage\n ; tid = t.tid\n ; backtrace_history = t.backtrace_history\n }\n;;\n\nlet find_local t key = Univ_map.find t.local_storage key\n\nlet with_local t key data =\n { t with local_storage = Univ_map.change t.local_storage key ~f:(fun _ -> data) }\n;;\n\nlet with_tid t tid =\n { t with tid }\n;;\n\nlet record_backtrace t =\n { t with backtrace_history = Backtrace.get () :: t.backtrace_history }\n;;\n","open! Core_kernel\nopen! Import\nmodule Scheduler = Scheduler0\n\nlet dummy_e = Execution_context.main\nlet dummy_f : Obj.t -> unit = ignore\nlet dummy_a : Obj.t = Obj.repr ()\nlet slots_per_elt = 3\n\nmodule A = Uniform_array\n\n(* This is essentially a specialized [Flat_queue], done for reasons of speed. *)\ntype t = Types.Job_queue.t =\n { mutable num_jobs_run : int\n ; mutable jobs_left_this_cycle : int\n ; (* [jobs] is an array of length [capacity t * slots_per_elt], where each elt has the\n three components of a job ([execution_context], [f], [a]) in consecutive spots in\n [jobs]. [enqueue] doubles the length of [jobs] if [jobs] is full. [jobs] never\n shrinks. [jobs] is somewhat like a [Core_kernel.Pool] specialized to 3-tuples; we\n don't use [Pool] because that implements a set, where [jobs] is a queue. *)\n mutable jobs : (Obj.t A.t[@sexp.opaque])\n ; (* [mask] is [capacity t - 1], and is used for quickly computing [i mod (capacity\n t)] *)\n mutable mask : int\n ; (* [front] is the index of the first job in the queue. The array index of that job's\n execution context is [front * slots_per_elt]. *)\n mutable front : int\n ; mutable length : int\n }\n[@@deriving fields, sexp_of]\n\nlet offset t i = (t.front + i) land t.mask * slots_per_elt\nlet capacity t = t.mask + 1\n\nlet invariant t : unit =\n Invariant.invariant [%here] t [%sexp_of: t] (fun () ->\n let check f = Invariant.check_field t f in\n Fields.iter\n ~num_jobs_run:(check (fun num_jobs_run -> assert (num_jobs_run >= 0)))\n ~jobs_left_this_cycle:\n (check (fun jobs_left_this_cycle -> assert (jobs_left_this_cycle >= 0)))\n ~jobs:\n (check (fun jobs ->\n for i = 0 to t.length - 1 do\n Execution_context.invariant\n (Obj.obj (A.get jobs (offset t i)) : Execution_context.t)\n done))\n ~mask:\n (check (fun mask ->\n let capacity = mask + 1 in\n assert (Int.is_pow2 capacity);\n assert (capacity * slots_per_elt = A.length t.jobs)))\n ~front:\n (check (fun front ->\n assert (front >= 0);\n assert (front < capacity t)))\n ~length:\n (check (fun length ->\n assert (length >= 0);\n assert (length <= capacity t))))\n;;\n\nlet create_array ~capacity = A.create_obj_array ~len:(capacity * slots_per_elt)\n\nlet create () =\n let capacity = 1 in\n { num_jobs_run = 0\n ; jobs_left_this_cycle = 0\n ; jobs = create_array ~capacity\n ; mask = capacity - 1\n ; front = 0\n ; length = 0\n }\n;;\n\nlet clear t =\n t.front <- 0;\n t.length <- 0;\n t.jobs_left_this_cycle <- 0\n;;\n\nlet grow t =\n let old_capacity = capacity t in\n let new_capacity = old_capacity * 2 in\n let old_jobs = t.jobs in\n let old_front = t.front in\n let len1 = Int.min t.length (old_capacity - old_front) * slots_per_elt in\n let len2 = (t.length * slots_per_elt) - len1 in\n let new_jobs = create_array ~capacity:new_capacity in\n A.blit\n ~len:len1\n ~src:old_jobs\n ~src_pos:(old_front * slots_per_elt)\n ~dst:new_jobs\n ~dst_pos:0;\n A.blit ~len:len2 ~src:old_jobs ~src_pos:0 ~dst:new_jobs ~dst_pos:len1;\n t.mask <- new_capacity - 1;\n t.jobs <- new_jobs;\n t.front <- 0\n;;\n\nlet set (type a) t i execution_context f a =\n let offset = offset t i in\n A.unsafe_set t.jobs offset (Obj.repr (execution_context : Execution_context.t));\n A.unsafe_set t.jobs (offset + 1) (Obj.repr (f : a -> unit));\n A.unsafe_set t.jobs (offset + 2) (Obj.repr (a : a))\n;;\n\nlet enqueue t execution_context f a =\n if t.length = capacity t then grow t;\n set t t.length execution_context f a;\n t.length <- t.length + 1\n;;\n\nlet set_jobs_left_this_cycle t n =\n if n < 0\n then\n raise_s\n [%message \"Jobs.set_jobs_left_this_cycle got negative number\" (n : int) (t : t)];\n t.jobs_left_this_cycle <- n\n;;\n\nlet can_run_a_job t = t.length > 0 && t.jobs_left_this_cycle > 0\n\nlet run_job t (scheduler : Scheduler.t) execution_context f a =\n t.num_jobs_run <- t.num_jobs_run + 1;\n Scheduler.set_execution_context scheduler execution_context;\n f a\n;;\n\nlet run_external_jobs t (scheduler : Scheduler.t) =\n let external_jobs = scheduler.external_jobs in\n while Thread_safe_queue.length external_jobs > 0 do\n let (External_job.T (execution_context, f, a)) =\n Thread_safe_queue.dequeue_exn external_jobs\n in\n run_job t scheduler execution_context f a\n done\n;;\n\nlet run_jobs (type a) t (scheduler : Scheduler.t) =\n (* We do the [try-with] outside of the [while] because it is cheaper than doing a\n [try-with] for each job. *)\n (* [run_external_jobs] before entering the loop, since it might enqueue a job,\n changing [t.length]. *)\n try\n run_external_jobs t scheduler;\n while can_run_a_job t do\n let this_job = offset t 0 in\n let execution_context : Execution_context.t =\n Obj.obj (A.unsafe_get t.jobs this_job)\n in\n let f : a -> unit = Obj.obj (A.unsafe_get t.jobs (this_job + 1)) in\n let a : a = Obj.obj (A.unsafe_get t.jobs (this_job + 2)) in\n (* We clear out the job right now so that it isn't live at the next minor\n collection. We tried not doing this and saw significant (15% or so) performance\n hits due to spurious promotion. *)\n set t 0 dummy_e dummy_f dummy_a;\n t.front <- (t.front + 1) land t.mask;\n t.length <- t.length - 1;\n t.jobs_left_this_cycle <- t.jobs_left_this_cycle - 1;\n (* It is OK if [run_job] or [run_external_jobs] raises, in which case the exn is\n handled by the outer try-with. The only side effects we have done are to take\n the job out of the queue and decrement [jobs_left_this_cycle]. [run_job] or\n [run_external_jobs] may side effect [t], either by enqueueing jobs, or by\n clearing [t]. *)\n (!Tracing.fns).on_job_enter execution_context ;\n let start = Time_ns.now () in\n run_job t scheduler execution_context f a;\n let this_job_time = Time_ns.(diff (now ()) start) in\n if Float.(Time_ns.Span.to_ms this_job_time >= 2000.) then scheduler.long_jobs_last_cycle <- (execution_context, this_job_time) :: scheduler.long_jobs_last_cycle;\n (!Tracing.fns).on_job_exit execution_context this_job_time ;\n (* [run_external_jobs] at each iteration of the [while] loop, for fairness. *)\n run_external_jobs t scheduler\n done;\n Ok ()\n with\n | exn ->\n (* We call [Exn.backtrace] immediately after catching an unhandled exception, to\n ensure there is no intervening code that interferes with the global backtrace\n state. *)\n let backtrace = Backtrace.Exn.most_recent () in\n Error (exn, backtrace)\n;;\n","type tracing_fns =\n { on_job_enter : Execution_context.t -> unit\n ; on_job_exit : Execution_context.t -> Time_ns.Span.t -> unit }\n\nlet fns = ref { on_job_enter= (fun _ -> ()); on_job_exit= (fun _ _ -> ()) }\n","open! Core_kernel\nopen! Import\ninclude Types.External_job\n\nlet sexp_of_t _ = Sexp.Atom \"\"\n","open! Core_kernel\nopen! Import\nopen Pool\nmodule Pointer = Pointer\nmodule Slot = Slot\n\nlet dummy_e = Execution_context.main\nlet dummy_f : Obj.t -> unit = ignore\nlet dummy_a : Obj.t = Obj.repr ()\n\ntype slots = (Execution_context.t, Obj.t -> unit, (Obj.t[@sexp.opaque])) Slots.t3\n[@@deriving sexp_of]\n\ntype t = slots Pool.t [@@deriving sexp_of]\n\nlet invariant t = Pool.invariant ignore t\nlet create () = create Slots.t3 ~capacity:1 ~dummy:(dummy_e, dummy_f, dummy_a)\n","open! Core_kernel\nopen! Import\nmodule Event = Types.Event\nmodule Job = Types.Job\ninclude Types.Job_or_event\n\n(* This redefinition of [Event] is here so the type checks are right next to\n [Obj.magic]s. *)\nmodule Event_is_block : sig end = struct\n open Types\n open Event\n\n type _t = t =\n { (* must never be immediate *)\n mutable alarm : Job_or_event.t Timing_wheel.Alarm.t\n ; mutable at : Time_ns.t\n ; callback : unit -> unit\n ; execution_context : Execution_context.t\n ; mutable interval : Time_ns.Span.t option\n ; mutable next_fired : t\n ; mutable status : Status.t\n }\nend\n\nmodule Job_is_not_block : sig end = struct\n module Ensure_private_int (M : sig\n type t = private int\n end) =\n struct\n type _t = M.t\n end\n\n include Ensure_private_int (Job)\nend\n\nlet of_event event : t = Obj.magic (event : Event.t)\nlet of_job job : t = Obj.magic (job : Job.t)\nlet is_event (t : t) = Obj.is_block (Obj.repr t)\nlet is_job (t : t) = Obj.is_int (Obj.repr t)\n\nmodule Match = struct\n type _ kind =\n | Event : Event.t kind\n | Job : Job.t kind\n\n type packed = K : _ kind -> packed\n\n let kind t = if is_event t then K Event else K Job\n let project (type a) (_ : a kind) job_or_event = (Obj.magic : t -> a) job_or_event\nend\n","open! Core_kernel\nopen! Import\ninclude Types.Scheduler\n\nlet events t = t.time_source.events\n\nlet set_execution_context t execution_context =\n (* Avoid a caml_modify in most cases. *)\n (* XXX: see where job_queue also modifies current_execution_context *)\n if not (phys_equal t.current_execution_context execution_context) then (\n t.cycle_started <- false ;\n t.current_execution_context <- execution_context )\n","open! Core_kernel\nopen! Import\n\nmodule Time_ns = struct\n include Time_ns\n\n external format : float -> string -> string = \"core_kernel_time_ns_format\"\n\n (* We use a more pleasant format than [Core_kernel.Time_ns.sexp_of_t],\n which has to be messier for round trippability. *)\n let sexp_of_t t =\n [%sexp\n (format (t |> to_span_since_epoch |> Span.to_sec) \"%Y-%m-%dT%H:%M:%S%z\" : string)]\n ;;\nend\n\nmodule Alarm = struct\n include Timing_wheel.Alarm\n\n let is_null t = phys_equal t (null ())\nend\n\nmodule Alarm_precision = Timing_wheel.Alarm_precision\n\nlet default_timing_wheel_config =\n (* 1/8th of a millisecond alarm_precision seems sufficient to avoid having many alarms\n in the same interval, which avoids quadratic insertion sort when firing alarms. And\n the level bits give us levels of >1s, >1m, >1h, >1d. See test in\n [../test/test_synchronous_time_source.ml]. *)\n Timing_wheel.Config.create\n ~alarm_precision:Alarm_precision.(div about_one_millisecond ~pow2:3)\n ~level_bits:(Timing_wheel.Level_bits.create_exn [ 13; 6; 6; 5 ])\n ()\n;;\n\ntype callback = unit -> unit\n\nmodule Id = Types.Time_source_id\n\nmodule T1 = struct\n module Event = struct\n module Status = struct\n type t = Types.Event.Status.t =\n | Aborted\n (* in [fired_events], must not run *)\n | Fired\n (* in [fired_events], ready to run *)\n | Happening\n (* currently running the callback *)\n | Scheduled\n (* in the timing wheel *)\n | Unscheduled (* not in timing wheel or [fired_events] *)\n [@@deriving compare, sexp_of]\n\n let transition_is_allowed ~from ~to_ =\n match from, to_ with\n | Aborted, Unscheduled (* skipped running callback *)\n | Fired, Happening (* started running callback *)\n | Fired, Aborted (* aborted *)\n | Happening, Scheduled (* for repeating events *)\n | Happening, Unscheduled (* event callback finished *)\n | Scheduled, Fired (* moved from timing wheel to [fired_events] *)\n | Scheduled, Unscheduled (* aborted *)\n | Unscheduled, Fired (* event scheduled in the past *)\n | Unscheduled, Scheduled (* event scheduled in the future *) -> true\n | (Aborted | Fired | Happening | Scheduled | Unscheduled), _ -> false\n ;;\n end\n\n type t = Types.Event.t =\n { (* [alarm] is non-null iff the event is in the timing wheel. *)\n mutable alarm : Job_or_event.t Alarm.t\n ; mutable at : Time_ns.t\n ; callback : unit -> unit\n ; execution_context : Execution_context.t\n ; (* [interval] is the period for the periodic events *)\n mutable interval : Time_ns.Span.t option\n ; (* [next_fired] is a singly-linked list of fired events, linked via [next_fired].\n An event is added to the list when it fires, either because it is added with a\n time in the past, or because time advances. [advance_by_alarms] iterates over\n the events in [next_fired] and runs them, emptying the list. *)\n mutable next_fired : t\n ; mutable status : Status.t\n }\n [@@deriving fields]\n\n (* [none] is used to indicate the end of the singly-linked list of fired events. *)\n let rec none =\n { alarm = Alarm.null ()\n ; at = Time_ns.min_value_for_1us_rounding\n ; callback = (fun () -> assert false)\n ; execution_context = Execution_context.main\n ; interval = None\n ; next_fired = none\n ; status = Unscheduled\n }\n ;;\n\n let is_none t = phys_equal t none\n let is_some t = not (is_none t)\n\n let sexp_of_t\n ({ alarm = _\n ; at\n ; callback = _\n ; execution_context = _\n ; interval\n ; next_fired = _\n ; status\n } as t)\n =\n if is_none t\n then [%sexp \"none\"]\n else\n [%message\n \"\" (status : Status.t) (at : Time_ns.t) (interval : Time_ns.Span.t option)]\n ;;\n\n let invariant t =\n Invariant.invariant [%here] t [%sexp_of: t] (fun () ->\n let check f = Invariant.check_field t f in\n Fields.iter\n ~alarm:\n (check (fun alarm ->\n [%test_result: bool]\n (Alarm.is_null alarm)\n ~expect:\n (match t.status with\n | Aborted | Fired | Happening | Unscheduled -> true\n | Scheduled -> false)))\n ~at:ignore\n ~callback:ignore\n ~execution_context:ignore\n ~interval:ignore\n ~next_fired:\n (check (fun next_fired ->\n if is_some next_fired\n then (\n match t.status with\n | Aborted | Fired -> ()\n | Happening | Scheduled | Unscheduled -> assert false)))\n ~status:ignore)\n ;;\n\n let compare_at t1 t2 = Time_ns.compare t1.at t2.at\n\n let set_status t to_ =\n let from = t.status in\n if not (Status.transition_is_allowed ~from ~to_)\n then\n raise_s\n [%message\n [%here]\n \"bug -- set_status transition not allowed\"\n (from : Status.t)\n (to_ : Status.t)\n ~event:(t : t)];\n t.status <- to_\n ;;\n end\n\n module Job_or_event = struct\n include Job_or_event\n\n let sexp_of_t t =\n let open Job_or_event.Match in\n let (K k) = kind t in\n match k, project k t with\n | Event, event -> [%sexp (event : Event.t)]\n | Job, _ ->\n (* We don't display the [Job.t]s in [events] because those are\n pool pointers, which are uninformative. *)\n [%message \"\"]\n ;;\n end\n\n type -'rw t = 'rw Types.Time_source.t1 =\n { id : Id.t\n ; (* [advance_errors] accumulates errors raised by alarms run by\n [advance_by_alarms]. *)\n mutable advance_errors : Error.t list\n ; (* [am_advancing] is true only during [advance_by_alarms], and is used to cause\n callbacks to raise if they call [advance_by_alarms]. *)\n mutable am_advancing : bool\n ; events : Job_or_event.t Timing_wheel.t\n ; (* [fired_events] is the front of the singly linked list of fired events, which is\n stored in increasing order of [Event.at]. *)\n mutable fired_events : Event.t\n ; (* [most_recently_fired] is the event that was most recently inserted into\n [fired_events]. It is used as an optimization to allow insertion of subsequent\n events to start later in the list rather than at the beginning. It specifically\n avoids quadratic behavior when inserting multiple events that have exactly the\n same time -- the time source fires such events in the order they were added, and\n we want them to be in that same order in [fired_events]. *)\n mutable most_recently_fired : Event.t\n ; (* We store [handle_fired] in [t] to avoid allocating it every time we call\n [advance_clock]. *)\n handle_fired : Job_or_event.t Alarm.t -> unit\n ; is_wall_clock : bool\n ; scheduler : Scheduler0.t\n }\n [@@deriving fields]\n\n (* We don't include the [id] in the sexp because the user (rightly) can't control it, so\n it's hard to make it deterministic in tests. *)\n let sexp_of_t\n _\n { id = _\n ; advance_errors = _\n ; am_advancing = _\n ; events\n ; fired_events = _\n ; handle_fired = _\n ; is_wall_clock\n ; most_recently_fired = _\n ; scheduler = _\n }\n =\n let now = Timing_wheel.now events in\n if is_wall_clock\n then [%message \"wall_clock\" (now : Time_ns.t)]\n else (\n let all_events = ref [] in\n Timing_wheel.iter events ~f:(fun alarm ->\n all_events := (Alarm.at events alarm, Alarm.value events alarm) :: !all_events);\n let events =\n List.sort !all_events ~compare:(fun (at1, _) (at2, _) -> Time_ns.compare at1 at2)\n |> List.map ~f:snd\n in\n [%message \"\" (now : Time_ns.t) (events : Job_or_event.t list)])\n ;;\n\n let timing_wheel_now t = Timing_wheel.now t.events\n\n let is_in_fired_events t event =\n with_return (fun r ->\n let current = ref t.fired_events in\n while Event.is_some !current do\n if phys_equal !current event then r.return true;\n current := !current.next_fired\n done;\n false)\n ;;\n\n let invariant_with_jobs (type rw) ~job:(job_invariant : Job.t -> unit) (t : rw t) =\n Invariant.invariant [%here] t [%sexp_of: _ t] (fun () ->\n let check f = Invariant.check_field t f in\n Fields.iter\n ~id:ignore\n ~advance_errors:ignore\n ~am_advancing:ignore\n ~events:\n (check (fun events ->\n Timing_wheel.invariant ignore events;\n Timing_wheel.iter events ~f:(fun alarm ->\n let job_or_event = Alarm.value events alarm in\n let open Job_or_event.Match in\n let (K k) = kind job_or_event in\n match k, project k job_or_event with\n | Job, job -> job_invariant job\n | Event, event ->\n assert (phys_equal alarm event.alarm);\n [%test_result: Time_ns.t] event.at ~expect:(Alarm.at events alarm);\n [%test_result: Event.Status.t] event.status ~expect:Scheduled)))\n ~fired_events:\n (check (fun (fired_events : Event.t) ->\n let current = ref fired_events in\n while Event.is_some !current do\n assert (Time_ns.( <= ) !current.at (timing_wheel_now t));\n let next = !current.next_fired in\n if Event.is_some next then assert (Time_ns.( <= ) !current.at next.at);\n current := next\n done))\n ~handle_fired:ignore\n ~is_wall_clock:ignore\n ~most_recently_fired:\n (check (fun most_recently_fired ->\n if Event.is_some t.most_recently_fired\n then assert (is_in_fired_events t most_recently_fired)))\n ~scheduler:ignore)\n ;;\n\n let invariant t = invariant_with_jobs ~job:(fun _ -> ()) t\nend\n\nopen T1\n\ntype t = read T1.t [@@deriving sexp_of]\n\nlet invariant = invariant\nlet invariant_with_jobs = invariant_with_jobs\n\nmodule Read_write = struct\n type t = read_write T1.t [@@deriving sexp_of]\n\n let invariant = invariant\n let invariant_with_jobs = invariant_with_jobs\nend\n\nlet id t = t.id\nlet is_wall_clock t = t.is_wall_clock\nlet length t = Timing_wheel.length t.events\nlet max_allowed_alarm_time t = Timing_wheel.max_allowed_alarm_time t.events\nlet read_only (t : [> read ] T1.t) = (t :> t)\n\n(* [fire t event] sets [event.status = Fired] and inserts [event] into [t.fired_events] in\n sorted time order. *)\nlet fire t (event : Event.t) =\n Event.set_status event Fired;\n event.alarm <- Alarm.null ();\n let prev = ref Event.none in\n let current = ref t.fired_events in\n (* If [event] belongs after [t.most_recently_fired], then we start the insertion there\n rather than at the front of [t.fired_events]. This works nicely if we're getting the\n alarms in non-decreasing time order, which is close to what [Timing_wheel]\n provides (although [Timing_wheel] doesn't guarantee time ordering for times in the\n same interval). *)\n if Event.is_some t.most_recently_fired\n && Time_ns.( >= ) event.at t.most_recently_fired.at\n then (\n prev := t.most_recently_fired;\n current := !prev.next_fired);\n (* We use [Time_ns.( <= )] rather than [<] so that [event] is added after other events\n at the same time. Since [Timing_wheel] fires alarms in a bucket in the order in\n which they were added, using [<=] keeps events at the same time in the order in which\n they were added. *)\n while Event.is_some !current && Time_ns.( <= ) !current.at event.at do\n prev := !current;\n current := !current.next_fired\n done;\n event.next_fired <- !current;\n t.most_recently_fired <- event;\n if Event.is_none !prev then t.fired_events <- event else !prev.next_fired <- event\n;;\n\nlet alarm_precision t = Timing_wheel.alarm_precision t.events\nlet next_alarm_fires_at t = Timing_wheel.next_alarm_fires_at t.events\nlet now t = if t.is_wall_clock then Time_ns.now () else timing_wheel_now t\nlet timing_wheel_now = timing_wheel_now\n\nlet schedule t (event : Event.t) =\n Event.set_status event Scheduled;\n event.alarm <- Timing_wheel.add t.events ~at:event.at (event |> Job_or_event.of_event)\n;;\n\nmodule Event = struct\n include Event\n\n let create_internal t ~at ~interval ~callback =\n { alarm = Alarm.null ()\n ; at\n ; callback\n ; execution_context = t.scheduler.current_execution_context\n ; interval\n ; next_fired = none\n ; status = Unscheduled\n }\n ;;\n\n let add t event =\n if Time_ns.( <= ) event.at (timing_wheel_now t)\n then fire t event\n else schedule t event\n ;;\n\n let create_and_add t ~at ~interval ~callback =\n let event = create_internal t ~at ~interval ~callback in\n add t event;\n event\n ;;\n\n let at t at callback = create_and_add t ~at ~interval:None ~callback\n\n let after t span callback =\n create_and_add t ~at:(Time_ns.after (now t) span) ~interval:None ~callback\n ;;\n\n let require_span_at_least_alarm_precision t span =\n let alarm_precision = alarm_precision t in\n if Time_ns.Span.( < ) span alarm_precision\n then\n raise_s\n [%message\n \"interval span smaller than alarm precision\"\n (span : Time_ns.Span.t)\n (alarm_precision : Time_ns.Span.t)]\n ;;\n\n let at_intervals t span callback =\n require_span_at_least_alarm_precision t span;\n create_and_add t ~at:(now t) ~interval:(Some span) ~callback\n ;;\n\n module Abort_result = struct\n type t =\n | Ok\n | Currently_happening\n | Previously_unscheduled\n [@@deriving sexp_of]\n end\n\n let abort t (event : t) : Abort_result.t =\n match event.status with\n | Aborted -> Previously_unscheduled\n | Happening ->\n if Option.is_none event.interval\n then Currently_happening\n else (\n event.interval <- None;\n Ok)\n | Fired ->\n Event.set_status event Aborted;\n Ok\n | Scheduled ->\n Event.set_status event Unscheduled;\n Timing_wheel.remove t.events event.alarm;\n event.alarm <- Alarm.null ();\n Ok\n | Unscheduled -> Previously_unscheduled\n ;;\n\n let abort_if_possible t event = ignore (abort t event : Abort_result.t)\n\n let abort_exn t event =\n match abort t event with\n | Ok -> ()\n | reason ->\n raise_s\n [%message\n \"[Synchronous_time_source.abort_exn] cannot abort event\"\n (reason : Abort_result.t)]\n ;;\n\n let create t callback = create_internal t ~at:Time_ns.epoch ~interval:None ~callback\n\n let schedule_at_internal t (event : t) at ~interval =\n (* [Fired] is disallowed to prevent the user from entering into an infinite loop. The\n user could specify [at] in the past which would constantly add [callback] to the\n back of [t.next_fired] if this function is called from [callback]. *)\n match event.status with\n | (Aborted | Happening | Scheduled | Fired) as status ->\n Or_error.error_s\n [%message \"cannot schedule an event with status\" ~_:(status : Event.Status.t)]\n | Unscheduled ->\n event.at <- at;\n event.interval <- interval;\n add t event;\n Ok ()\n ;;\n\n let schedule_at t event at = schedule_at_internal t event at ~interval:None\n let schedule_after t event span = schedule_at t event (Time_ns.after (now t) span)\n\n let schedule_at_intervals t event span =\n require_span_at_least_alarm_precision t span;\n schedule_at_internal t event (now t) ~interval:(Some span)\n ;;\n\n module Reschedule_result = struct\n type t =\n | Ok\n | Currently_happening\n | Recently_aborted\n | Recently_fired\n [@@deriving sexp_of]\n end\n\n let reschedule_at t event at : Reschedule_result.t =\n match event.status with\n | Aborted -> Recently_aborted\n | Fired -> Recently_fired\n | Happening -> Currently_happening\n | Scheduled ->\n event.at <- at;\n if Time_ns.( > ) at (timing_wheel_now t)\n then Timing_wheel.reschedule t.events event.alarm ~at\n else (\n Timing_wheel.remove t.events event.alarm;\n fire t event);\n Ok\n | Unscheduled ->\n event.at <- at;\n event.interval <- None;\n add t event;\n Ok\n ;;\n\n let reschedule_after t event span = reschedule_at t event (Time_ns.after (now t) span)\n\n module Option = struct\n type value = t\n type nonrec t = t\n\n let is_none = is_none\n let is_some = is_some\n\n let some value =\n (* This assert shouldn't fail because [t] is a [value] and so should never\n be [none]. *)\n assert (is_some value);\n value\n ;;\n\n (* It should be impossible for [some_is_representable] to return [false]\n because its input is a [value], but since it's only loosely enforced we\n handle the general case. *)\n let some_is_representable value =\n assert (is_some value);\n true\n ;;\n\n let none = none\n let unchecked_value = Fn.id\n let value t ~default = if is_none t then default else unchecked_value t\n\n let value_exn t =\n if is_none t\n then raise_s [%message \"[Synchronous_time_source.Event.Option.value_exn None]\"];\n t\n ;;\n\n let to_option t = if is_none t then None else Some t\n\n let of_option = function\n | None -> none\n | Some t -> some t\n ;;\n\n let sexp_of_t t = to_option t |> [%sexp_of: t option]\n\n module Optional_syntax = struct\n module Optional_syntax = struct\n let is_none = is_none\n let unsafe_value = Fn.id\n end\n end\n end\n\nend\n\nlet run_after t span callback = ignore (Event.after t span callback : Event.t)\nlet run_at t at callback = ignore (Event.at t at callback : Event.t)\n\nlet run_at_intervals t span callback =\n ignore (Event.at_intervals t span callback : Event.t)\n;;\n\ntype send_exn = Monitor0.t -> ?backtrace:[ `Get | `This of Backtrace.t ] -> exn -> unit\n\nlet run_fired_events t ~(send_exn : send_exn option) =\n let current_execution_context = t.scheduler.current_execution_context in\n while Event.is_some t.fired_events do\n let event = t.fired_events in\n if phys_equal event t.most_recently_fired then t.most_recently_fired <- Event.none;\n t.fired_events <- event.next_fired;\n event.next_fired <- Event.none;\n match event.status with\n | Aborted -> Event.set_status event Unscheduled\n | Happening | Scheduled | Unscheduled -> assert false\n | Fired ->\n Event.set_status event Happening;\n (* We set the execution context so that [event.callback] runs in the same context\n that was in place when [event] was created. *)\n Scheduler0.set_execution_context t.scheduler event.execution_context;\n (match event.callback () with\n | exception exn ->\n (match send_exn with\n | None -> t.advance_errors <- Error.of_exn exn :: t.advance_errors\n | Some send_exn ->\n let backtrace = Backtrace.get () in\n send_exn event.execution_context.monitor exn ~backtrace:(`This backtrace));\n Event.set_status event Unscheduled\n | () ->\n (match event.interval with\n | None -> Event.set_status event Unscheduled\n | Some interval ->\n event.at\n <- Time_ns.next_multiple\n ()\n ~base:event.at\n ~after:(timing_wheel_now t)\n ~interval;\n schedule t event))\n done;\n Scheduler0.set_execution_context t.scheduler current_execution_context\n;;\n\nlet advance_clock t ~to_ ~send_exn =\n Timing_wheel.advance_clock t.events ~to_ ~handle_fired:t.handle_fired;\n run_fired_events t ~send_exn\n;;\n\nlet fire_past_alarms t ~send_exn =\n Timing_wheel.fire_past_alarms t.events ~handle_fired:t.handle_fired;\n run_fired_events t ~send_exn\n;;\n\nlet advance_internal t ~to_ ~send_exn =\n advance_clock t ~to_ ~send_exn;\n fire_past_alarms t ~send_exn\n;;\n\nlet prepare_to_advance t ~send_exn =\n if t.am_advancing\n then raise_s [%message \"cannot call [advance_by_alarms] from callback\"];\n t.am_advancing <- true;\n (match t.advance_errors with\n | [] -> ()\n | _ -> t.advance_errors <- []);\n run_fired_events t ~send_exn\n;;\n\nlet finish_advancing t =\n t.am_advancing <- false;\n match t.advance_errors with\n | [] -> Ok ()\n | errors ->\n t.advance_errors <- [];\n Error (Error.of_list errors)\n;;\n\nlet advance_by_alarms t ~to_ =\n let send_exn = None in\n prepare_to_advance t ~send_exn;\n let continue = ref true in\n while !continue do\n if Timing_wheel.is_empty t.events\n then continue := false\n else (\n let next_alarm_fires_at = Timing_wheel.next_alarm_fires_at_exn t.events in\n if Time_ns.( >= ) next_alarm_fires_at to_\n then continue := false\n else\n (* We use the actual alarm time, rather than [next_alarm_fires_at], so as not to\n expose (or accumulate errors associated with) the precision of\n [Timing_wheel]. *)\n advance_internal\n t\n ~to_:(Timing_wheel.max_alarm_time_in_min_interval_exn t.events)\n ~send_exn)\n done;\n advance_internal t ~to_ ~send_exn;\n finish_advancing t\n;;\n\nlet advance_directly t ~to_ =\n let send_exn = None in\n prepare_to_advance t ~send_exn;\n advance_internal t ~to_ ~send_exn;\n finish_advancing t\n;;\n\nmodule Expert = struct\n let max_alarm_time_in_min_timing_wheel_interval t =\n Timing_wheel.max_alarm_time_in_min_interval t.events\n ;;\n\n let has_events_to_run t = Event.is_some t.fired_events\nend\n","open Core_kernel\nopen Import\ninclude Scheduler0\nmodule Synchronous_time_source = Synchronous_time_source0\nmodule Event = Synchronous_time_source.Event\nmodule Alarm = Timing_wheel.Alarm\nmodule Job_or_event = Synchronous_time_source.T1.Job_or_event\n\nlet debug = Debug.scheduler\n\nmodule Ivar = struct\n open Types.Ivar\n\n let create_with_cell cell = { cell }\n let create () = create_with_cell Empty\n\n let create_full (type a) (a : a) =\n (* We allocate an immutable ivar and then cast it to a mutable ivar. The immutability\n allows OCaml to statically allocate the ivar if [a] is constant. This cast is safe\n because a full ivar is never mutated. We also believe that we will not trigger\n flambda to spuriously repor warning 59, mutation of known immutable data. All\n mutations of an ivar cell, i.e. [foo.cell <- ...], are directly preceded by a\n [match foo.cell] that prevents the [Full] case from reaching the modification. So\n flambda should always eliminate the [foo.cell <- ...] of a constant [Full] ivar,\n and not warn. *)\n (Obj.magic : a Immutable.t -> a t) { cell = Full a }\n ;;\nend\n\nmodule Bvar = struct\n open Types.Bvar\n\n let create () = of_repr { has_any_waiters = false; ivar = Ivar.create () }\nend\n\nmodule Very_low_priority_worker = struct\n module Exec_result = struct\n type t = Types.Very_low_priority_worker.Exec_result.t =\n | Finished\n | Not_finished\n [@@deriving sexp_of]\n end\n\n type t = Types.Very_low_priority_worker.t =\n { execution_context : Execution_context.t\n ; exec : unit -> Exec_result.t\n }\n [@@deriving fields, sexp_of]\n\n let invariant t =\n Invariant.invariant [%here] t [%sexp_of: t] (fun () ->\n let check f = Invariant.check_field t f in\n Fields.iter ~execution_context:(check Execution_context.invariant) ~exec:ignore)\n ;;\nend\n\ntype t = Scheduler0.t =\n { (* [check_access] optionally holds a function to run to check whether access to [t] is\n currently allowed. It is used to detect invalid access to the scheduler from a\n thread. *)\n mutable check_access : (unit -> unit) option\n ; mutable job_pool : Job_pool.t\n ; normal_priority_jobs : Job_queue.t\n ; low_priority_jobs : Job_queue.t\n ; very_low_priority_workers : Very_low_priority_worker.t Deque.t\n ; mutable main_execution_context : Execution_context.t\n ; mutable current_execution_context : Execution_context.t\n (* The scheduler calls [got_uncaught_exn] when an exception bubbles to the top of the\n monitor tree without being handled. This function guarantees to never run another\n job after this by calling [clear] and because [enqueue_job] will never add another\n job. *)\n ; mutable uncaught_exn : (Exn.t * Sexp.t) option\n ; mutable cycle_count : int\n ; mutable cycle_start : Time_ns.t\n ; mutable in_cycle : bool\n ; mutable run_every_cycle_start : (unit -> unit) list\n ; mutable run_every_cycle_end : (unit -> unit) list\n ; mutable last_cycle_time : Time_ns.Span.t\n ; mutable last_cycle_num_jobs : int\n ; mutable total_cycle_time : Time_ns.Span.t\n ; mutable time_source : read_write Synchronous_time_source.T1.t\n (* [external_jobs] is a queue of actions sent from outside of async. This is for the\n case where we want to schedule a job or fill an ivar from a context where it is not\n safe to run async code, because the async lock isn't held. For instance: - in an\n OCaml finalizer, as they can run at any time in any thread.\n\n The way to do it is to queue a thunk in [external_jobs] and call\n [thread_safe_external_job_hook], which is responsible for notifying the scheduler\n that new actions are available.\n\n When using Async on unix, [thread_safe_external_job_hook] is set in [Async_unix]\n to call [Interruptor.thread_safe_interrupt], which will wake up the\n [Async_unix] scheduler and run a cycle.\n\n Note that this hook might be used in other context (js_of_ocaml, mirage).\n\n When running a cycle, we pull external actions at every job and perform them\n immediately. *)\n ; external_jobs : External_job.t Thread_safe_queue.t\n ; mutable thread_safe_external_job_hook : unit -> unit\n (* [job_queued_hook] and [event_added_hook] aim to be used by js_of_ocaml. *)\n (* We use [_ option] here because those hooks will not be set in the common case\n and we want to avoid extra function calls. *)\n ; mutable job_queued_hook : (Priority.t -> unit) option\n ; mutable event_added_hook : (Time_ns.t -> unit) option\n ; mutable yield : ((unit, read_write) Types.Bvar.t[@sexp.opaque])\n ; mutable yield_until_no_jobs_remain :\n ((unit, read_write) Types.Bvar.t[@sexp.opaque] (* configuration*))\n ; mutable check_invariants : bool\n ; mutable max_num_jobs_per_priority_per_cycle : Max_num_jobs_per_priority_per_cycle.t\n ; mutable record_backtraces : bool\n ; mutable on_start_of_cycle : unit -> unit\n ; mutable on_end_of_cycle : unit -> unit\n ; mutable long_jobs_last_cycle : (Execution_context.t * Time_ns.Span.t) list\n ; mutable cycle_started : bool\n }\n[@@deriving fields, sexp_of]\n\nlet uncaught_exn_unwrapped = uncaught_exn\n\nlet uncaught_exn t =\n match t.uncaught_exn with\n | None -> None\n | Some (exn, sexp) ->\n Some (Error.create \"unhandled exception\" (exn, sexp) [%sexp_of: Exn.t * Sexp.t])\n;;\n\nlet num_pending_jobs t =\n Job_queue.length t.normal_priority_jobs + Job_queue.length t.low_priority_jobs\n;;\n\nlet num_jobs_run t =\n Job_queue.num_jobs_run t.normal_priority_jobs\n + Job_queue.num_jobs_run t.low_priority_jobs\n;;\n\nlet last_cycle_num_jobs t = t.last_cycle_num_jobs\n\nlet invariant t : unit =\n try\n let check f field = f (Field.get field t) in\n Fields.iter\n ~check_access:ignore\n ~job_pool:(check Job_pool.invariant)\n ~normal_priority_jobs:(check Job_queue.invariant)\n ~low_priority_jobs:(check Job_queue.invariant)\n ~very_low_priority_workers:\n (check (fun q -> Deque.iter q ~f:Very_low_priority_worker.invariant))\n ~main_execution_context:(check Execution_context.invariant)\n ~current_execution_context:(check Execution_context.invariant)\n ~uncaught_exn:\n (check (fun uncaught_exn ->\n if is_some uncaught_exn then assert (num_pending_jobs t = 0)))\n ~cycle_count:(check (fun cycle_count -> assert (cycle_count >= 0)))\n ~cycle_start:ignore\n ~in_cycle:ignore\n ~run_every_cycle_start:ignore\n ~run_every_cycle_end:ignore\n ~last_cycle_time:ignore\n ~total_cycle_time:ignore\n ~last_cycle_num_jobs:\n (check (fun last_cycle_num_jobs -> assert (last_cycle_num_jobs >= 0)))\n ~time_source:\n (check\n (Synchronous_time_source.Read_write.invariant_with_jobs ~job:(fun job ->\n assert (Pool.pointer_is_valid t.job_pool job))))\n ~external_jobs:ignore\n ~thread_safe_external_job_hook:ignore\n ~job_queued_hook:ignore\n ~event_added_hook:ignore\n ~yield:ignore\n ~yield_until_no_jobs_remain:ignore\n ~check_invariants:ignore\n ~max_num_jobs_per_priority_per_cycle:ignore\n ~record_backtraces:ignore\n ~cycle_started:ignore\n ~long_jobs_last_cycle:ignore\n ~on_start_of_cycle:ignore\n ~on_end_of_cycle:ignore\n with\n | exn -> raise_s [%message \"Scheduler.invariant failed\" (exn : exn) (t : t)]\n;;\n\nlet free_job t job = Pool.free t.job_pool job\n\nlet enqueue t (execution_context : Execution_context.t) f a =\n (* If there's been an uncaught exn, we don't add the job, since we don't want any jobs\n to run once there's been an uncaught exn. *)\n if is_none t.uncaught_exn\n then (\n let priority = execution_context.priority in\n let job_queue =\n match priority with\n | Normal -> t.normal_priority_jobs\n | Low -> t.low_priority_jobs\n in\n Job_queue.enqueue job_queue execution_context f a;\n match t.job_queued_hook with\n | None -> ()\n | Some f -> f priority)\n;;\n\nlet enqueue_job t job ~free_job =\n let job_pool = t.job_pool in\n enqueue\n t\n (Pool.get job_pool job Pool.Slot.t0)\n (Pool.get job_pool job Pool.Slot.t1)\n (Pool.get job_pool job Pool.Slot.t2);\n if free_job then Pool.free t.job_pool job\n;;\n\nlet handle_fired (time_source : _ Synchronous_time_source.T1.t) job_or_event =\n let open Job_or_event.Match in\n let (K k) = kind job_or_event in\n match k, project k job_or_event with\n | Job, job -> enqueue_job time_source.scheduler job ~free_job:true\n | Event, event -> Synchronous_time_source.fire time_source event\n;;\n\nlet create () =\n let now = Time_ns.now () in\n let rec t =\n { check_access = None\n ; job_pool = Job_pool.create ()\n ; normal_priority_jobs = Job_queue.create ()\n ; low_priority_jobs = Job_queue.create ()\n ; very_low_priority_workers = Deque.create ()\n ; main_execution_context = Execution_context.main\n ; current_execution_context = Execution_context.main\n ; uncaught_exn = None\n ; cycle_start = now\n ; cycle_count = 0\n ; in_cycle = false\n ; run_every_cycle_start = []\n ; run_every_cycle_end = []\n ; last_cycle_time = sec 0.\n ; last_cycle_num_jobs = 0\n ; total_cycle_time = sec 0.\n ; time_source\n ; external_jobs = Thread_safe_queue.create ()\n ; thread_safe_external_job_hook = ignore\n ; job_queued_hook = None\n ; event_added_hook = None\n ; yield = Bvar.create ()\n ; yield_until_no_jobs_remain = Bvar.create () (* configuration *)\n ; check_invariants = Async_kernel_config.check_invariants\n ; max_num_jobs_per_priority_per_cycle =\n Async_kernel_config.max_num_jobs_per_priority_per_cycle\n ; record_backtraces = Async_kernel_config.record_backtraces\n ; cycle_started = false\n ; on_start_of_cycle = Fn.id\n ; on_end_of_cycle = Fn.id\n ; long_jobs_last_cycle= []\n }\n and events =\n Timing_wheel.create ~config:Async_kernel_config.timing_wheel_config ~start:now\n and time_source : _ Synchronous_time_source.T1.t =\n { id = Types.Time_source_id.create ()\n ; advance_errors = []\n ; am_advancing = false\n ; events\n ; handle_fired = (fun alarm -> handle_fired time_source (Alarm.value events alarm))\n ; fired_events = Event.none\n ; is_wall_clock = true\n ; most_recently_fired = Event.none\n ; scheduler = t\n }\n in\n t\n;;\n\nlet is_dead t = is_some t.uncaught_exn\nlet set_check_access t f = t.check_access <- f\n\nlet t_ref =\n match Result.try_with create with\n | Ok t -> ref t\n | Error exn ->\n Debug.log \"Async cannot create its raw scheduler\" exn [%sexp_of: exn];\n exit 1\n;;\n\nlet check_access t =\n match t.check_access with\n | None -> ()\n | Some f -> f ()\n;;\n\nlet t () =\n let t = !t_ref in\n check_access t;\n t\n;;\n\nlet current_execution_context t =\n if t.record_backtraces\n then Execution_context.record_backtrace t.current_execution_context\n else t.current_execution_context\n;;\n\nlet with_execution_context t tmp_context ~f =\n let old_context = current_execution_context t in\n set_execution_context t tmp_context;\n protect ~f ~finally:(fun () -> set_execution_context t old_context)\n;;\n\nlet create_job (type a) t execution_context f a =\n if Pool.is_full t.job_pool then t.job_pool <- Pool.grow t.job_pool;\n Pool.new3\n t.job_pool\n execution_context\n (Obj.magic (f : a -> unit) : Obj.t -> unit)\n (Obj.repr (a : a))\n;;\n\nlet got_uncaught_exn t exn sexp =\n if debug then Debug.log \"got_uncaught_exn\" (exn, sexp) [%sexp_of: Exn.t * Sexp.t];\n List.iter [ t.normal_priority_jobs; t.low_priority_jobs ] ~f:Job_queue.clear;\n t.uncaught_exn <- Some (exn, sexp)\n;;\n\n(* [start_cycle t ~max_num_jobs_per_priority] enables subsequent calls of [run_jobs]\n to run up to [max_num_jobs_per_priority] jobs of each priority level. *)\nlet start_cycle t ~max_num_jobs_per_priority =\n let n = Max_num_jobs_per_priority_per_cycle.raw max_num_jobs_per_priority in\n Job_queue.set_jobs_left_this_cycle t.normal_priority_jobs n;\n Job_queue.set_jobs_left_this_cycle t.low_priority_jobs n\n;;\n\n(* [run_jobs t] removes jobs from [t] one at a time and runs them, stopping as soon\n as an unhandled exception is raised, or when no more jobs can be run at any priority,\n as per [~max_num_jobs_per_priority]. *)\nlet rec run_jobs t =\n match Job_queue.run_jobs t.normal_priority_jobs t with\n | Error _ as e -> e\n | Ok () ->\n (match Job_queue.run_jobs t.low_priority_jobs t with\n | Error _ as e -> e\n | Ok () ->\n if Job_queue.can_run_a_job t.normal_priority_jobs\n || Job_queue.can_run_a_job t.low_priority_jobs\n then run_jobs t\n else Ok ())\n;;\n\nlet stabilize t =\n start_cycle\n t\n ~max_num_jobs_per_priority:\n (Max_num_jobs_per_priority_per_cycle.create_exn Int.max_value);\n match run_jobs t with\n | Ok () -> Ok ()\n | Error (exn, _backtrace) -> Error exn\n;;\n\nlet create_time_source\n ?(timing_wheel_config = Async_kernel_config.timing_wheel_config)\n ~now\n ()\n =\n let t = t () in\n let events = Timing_wheel.create ~config:timing_wheel_config ~start:now in\n let rec time_source : _ Synchronous_time_source.T1.t =\n { id = Types.Time_source_id.create ()\n ; advance_errors = []\n ; am_advancing = false\n ; events\n ; handle_fired = (fun alarm -> handle_fired time_source (Alarm.value events alarm))\n ; fired_events = Event.none\n ; is_wall_clock = false\n ; most_recently_fired = Event.none\n ; scheduler = t\n }\n in\n time_source\n;;\n\nlet wall_clock () = Synchronous_time_source.read_only (t ()).time_source\n","open! Core_kernel\nopen! Import\nopen! Deferred_std\nmodule Deferred = Deferred1\nmodule Scheduler = Scheduler1\nmodule Stream = Async_stream\ninclude (Scheduler : module type of Scheduler with module Bvar := Scheduler.Bvar)\n\nlet t = Scheduler.t\n\ninclude Monitor.Exported_for_scheduler\n\nlet find_local key = Execution_context.find_local (current_execution_context (t ())) key\n\nlet with_local key value ~f =\n let t = t () in\n let execution_context =\n Execution_context.with_local (current_execution_context t) key value\n in\n with_execution_context t execution_context ~f\n;;\n\nlet main_execution_context = (t ()).main_execution_context\nlet can_run_a_job t = num_pending_jobs t > 0 || Bvar.has_any_waiters t.yield\nlet has_upcoming_event t = not (Timing_wheel.is_empty (events t))\nlet next_upcoming_event t = Timing_wheel.next_alarm_fires_at (events t)\nlet next_upcoming_event_exn t = Timing_wheel.next_alarm_fires_at_exn (events t)\nlet event_precision t = Timing_wheel.alarm_precision (events t)\nlet cycle_start t = t.cycle_start\nlet run_every_cycle_start t ~f = t.run_every_cycle_start <- f :: t.run_every_cycle_start\nlet run_every_cycle_end t ~f = t.run_every_cycle_end <- f :: t.run_every_cycle_end\n\nlet map_cycle_times t ~f =\n Stream.create (fun tail ->\n run_every_cycle_start t ~f:(fun () -> Tail.extend tail (f t.last_cycle_time)))\n;;\n\nlet long_cycles t ~at_least =\n Stream.create (fun tail ->\n run_every_cycle_start t ~f:(fun () ->\n if Time_ns.Span.( >= ) t.last_cycle_time at_least\n then Tail.extend tail t.last_cycle_time))\n;;\n\nlet long_cycles_with_context t ~at_least =\n Stream.create (fun tail ->\n run_every_cycle_start t ~f:(fun () ->\n if Time_ns.Span.( >= ) t.last_cycle_time at_least\n then Tail.extend tail (t.last_cycle_time,t.current_execution_context)))\n;;\n\nlet long_jobs_with_context t =\n Stream.create (fun tail ->\n run_every_cycle_start t ~f:(fun () ->\n List.iter t.long_jobs_last_cycle ~f:(fun job -> Tail.extend tail job) ; t.long_jobs_last_cycle <- [] ))\n;;\n\nlet cycle_num_jobs t =\n Stream.create (fun tail ->\n run_every_cycle_start t ~f:(fun () -> Tail.extend tail t.last_cycle_num_jobs))\n;;\n\nlet cycle_count t = t.cycle_count\n\nlet set_max_num_jobs_per_priority_per_cycle t int =\n t.max_num_jobs_per_priority_per_cycle\n <- Max_num_jobs_per_priority_per_cycle.create_exn int\n;;\n\nlet max_num_jobs_per_priority_per_cycle t =\n Max_num_jobs_per_priority_per_cycle.raw t.max_num_jobs_per_priority_per_cycle\n;;\n\nlet set_thread_safe_external_job_hook t f = t.thread_safe_external_job_hook <- f\n\nlet thread_safe_enqueue_external_job t execution_context f a =\n Thread_safe_queue.enqueue t.external_jobs (External_job.T (execution_context, f, a));\n t.thread_safe_external_job_hook ()\n;;\n\nlet set_event_added_hook t f = t.event_added_hook <- Some f\nlet set_job_queued_hook t f = t.job_queued_hook <- Some f\n\nlet create_alarm t f =\n let execution_context = current_execution_context t in\n Gc.Expert.Alarm.create (fun () ->\n thread_safe_enqueue_external_job t execution_context f ())\n;;\n\nlet add_finalizer t heap_block f =\n let execution_context = current_execution_context t in\n let finalizer heap_block =\n (* Here we can be in any thread, and may not be holding the async lock. So, we can\n only do thread-safe things.\n\n By putting [heap_block] in [external_jobs], we are keeping it alive until the next\n time the async scheduler gets around to dequeueing it. Calling\n [t.thread_safe_external_job_hook] ensures that will happen in short order. Thus,\n we are not dramatically increasing the lifetime of [heap_block], since the OCaml\n runtime already resurrected [heap_block] so that we could refer to it here. The\n OCaml runtime already removed the finalizer function when it noticed [heap_block]\n could be finalized, so there is no infinite loop in which we are causing the\n finalizer to run again. Also, OCaml does not impose any requirement on finalizer\n functions that they need to dispose of the block, so it's fine that we keep\n [heap_block] around until later. *)\n if Debug.finalizers then Debug.log_string \"enqueueing finalizer\";\n thread_safe_enqueue_external_job t execution_context f heap_block\n in\n if Debug.finalizers then Debug.log_string \"adding finalizer\";\n (* We use [Caml.Gc.finalise] instead of [Core_kernel.Gc.add_finalizer] because the latter\n has its own wrapper around [Caml.Gc.finalise] to run finalizers synchronously. *)\n try Caml.Gc.finalise finalizer heap_block with\n | Invalid_argument _ ->\n (* [Heap_block] ensures that this will only fail for static data, in which case we\n can drop the finalizer since the block will never be collected.*)\n ()\n;;\n\nlet add_finalizer_exn t x f =\n add_finalizer t (Heap_block.create_exn x) (fun heap_block ->\n f (Heap_block.value heap_block))\n;;\n\nlet add_finalizer_last t heap_block f =\n let execution_context = current_execution_context t in\n let finalizer () =\n (* Here we can be in any thread, and may not be holding the async lock. So, we can\n only do thread-safe things. *)\n if Debug.finalizers\n then Debug.log_string \"enqueueing finalizer (using 'last' semantic)\";\n thread_safe_enqueue_external_job t execution_context f ()\n in\n if Debug.finalizers then Debug.log_string \"adding finalizer (using 'last' semantic)\";\n (* We use [Caml.Gc.finalise_last] instead of [Core_kernel.Gc.add_finalizer_last] because\n the latter has its own wrapper around [Caml.Gc.finalise_last] to run finalizers\n synchronously. *)\n try Caml.Gc.finalise_last finalizer heap_block with\n | Invalid_argument _ ->\n (* [Heap_block] ensures that this will only fail for static data, in which case we\n can drop the finalizer since the block will never be collected.*)\n ()\n;;\n\nlet add_finalizer_last_exn t x f = add_finalizer_last t (Heap_block.create_exn x) f\n\n(** [force_current_cycle_to_end] sets the number of normal jobs allowed to run in this\n cycle to zero. Thus, after the currently running job completes, the scheduler will\n switch to low priority jobs and then end the current cycle. *)\nlet force_current_cycle_to_end t =\n Job_queue.set_jobs_left_this_cycle t.normal_priority_jobs 0\n;;\n\n(* We preallocate [send_exn] to avoid allocating it on each call to [advance_clock]. *)\nlet send_exn = Some Monitor.send_exn\n\nlet advance_clock t ~now =\n Synchronous_time_source0.advance_internal t.time_source ~to_:now ~send_exn\n;;\n\nlet run_cycle t =\n if debug then Debug.log \"run_cycle starting\" t [%sexp_of: t];\n t.on_start_of_cycle ();\n let now = Time_ns.now () in\n t.cycle_count <- t.cycle_count + 1;\n t.cycle_start <- now;\n t.in_cycle <- true;\n Bvar.broadcast t.yield ();\n let num_jobs_run_at_start_of_cycle = num_jobs_run t in\n List.iter t.run_every_cycle_start ~f:(fun f -> f ());\n advance_clock t ~now;\n start_cycle t ~max_num_jobs_per_priority:t.max_num_jobs_per_priority_per_cycle;\n let rec run_jobs t =\n match Scheduler.run_jobs t with\n | Ok () -> ()\n | Error (exn, backtrace) ->\n Monitor.send_exn (Monitor.current ()) exn ~backtrace:(`This backtrace);\n (* [run_jobs] stopped due to an exn. There may still be jobs that could be\n run this cycle, so [run_jobs] again. *)\n run_jobs t\n in\n run_jobs t;\n let cycle_time = Time_ns.diff (Time_ns.now ()) t.cycle_start in\n t.last_cycle_time <- cycle_time;\n t.last_cycle_num_jobs <- num_jobs_run t - num_jobs_run_at_start_of_cycle;\n t.total_cycle_time <- Time_ns.Span.(t.total_cycle_time + cycle_time);\n if Bvar.has_any_waiters t.yield_until_no_jobs_remain && num_pending_jobs t = 0\n then Bvar.broadcast t.yield_until_no_jobs_remain ();\n List.iter t.run_every_cycle_end ~f:(fun f -> f ());\n t.in_cycle <- false;\n t.on_end_of_cycle ();\n if debug\n then\n Debug.log\n \"run_cycle finished\"\n (uncaught_exn t, is_some (next_upcoming_event t))\n [%sexp_of: Error.t option * bool]\n;;\n\nlet run_cycles_until_no_jobs_remain () =\n if debug then Debug.log_string \"run_cycles_until_no_jobs_remain starting\";\n let t = t () in\n if is_dead t\n then\n raise_s\n [%message\n \"run_cycles_until_no_jobs_remain cannot proceed -- scheduler is dead\"\n ~scheduler:(t : t)];\n let rec loop () =\n run_cycle t;\n advance_clock t ~now:(Time_ns.now ());\n if can_run_a_job t then loop ()\n in\n loop ();\n (* Reset the current execution context to maintain the invariant that when we're not in\n a job, [current_execution_context = main_execution_context]. *)\n set_execution_context t t.main_execution_context;\n if debug then Debug.log_string \"run_cycles_until_no_jobs_remain finished\";\n Option.iter (uncaught_exn t) ~f:Error.raise\n;;\n\nlet make_async_unusable () =\n let t = !t_ref in\n t.check_access\n <- Some\n (fun () ->\n raise_s [%sexp \"Async scheduler is unusable due to [make_async_unusable]\"])\n;;\n\nlet reset_in_forked_process () =\n if debug then Debug.log_string \"reset_in_forked_process\";\n (* There is no need to empty [main_monitor_hole]. *)\n Scheduler.(t_ref := create ())\n;;\n\nlet check_invariants t = t.check_invariants\nlet set_check_invariants t b = t.check_invariants <- b\nlet set_record_backtraces t b = t.record_backtraces <- b\nlet set_on_start_of_cycle t f = t.on_start_of_cycle <- f\nlet set_on_end_of_cycle t f = t.on_end_of_cycle <- f\nlet yield t = Bvar.wait t.yield\n\nlet yield_until_no_jobs_remain ?(may_return_immediately = false) t =\n if may_return_immediately && num_pending_jobs t = 0\n then return ()\n else Bvar.wait t.yield_until_no_jobs_remain\n;;\n\nlet yield_every ~n =\n if n <= 0\n then raise_s [%message \"Scheduler.yield_every got nonpositive count\" (n : int)]\n else if n = 1\n then stage (fun t -> yield t)\n else (\n let count_until_yield = ref n in\n stage (fun t ->\n decr count_until_yield;\n if !count_until_yield > 0\n then return ()\n else (\n count_until_yield := n;\n yield t)))\n;;\n\nlet total_cycle_time t =\n (* Adjust for the fact the caller's probably an Async job. *)\n if t.in_cycle\n then (\n let this_cycle_time = Time_ns.(diff (now ()) t.cycle_start) in\n Time_ns.Span.(t.total_cycle_time + this_cycle_time))\n else t.total_cycle_time\n;;\n\nmodule Very_low_priority_work = struct\n module Worker_result = Very_low_priority_worker.Exec_result\n\n\n let rec run t = run_workers t ~num_execs_before_yielding:1_000\n\n and run_workers t ~num_execs_before_yielding =\n if num_execs_before_yielding = 0\n then yield_then_run t\n else if not (Deque.is_empty t.very_low_priority_workers)\n then (\n let worker = Deque.dequeue_front_exn t.very_low_priority_workers in\n set_execution_context t worker.execution_context;\n run_worker t worker ~num_execs_before_yielding)\n\n and yield_then_run t =\n if not (Deque.is_empty t.very_low_priority_workers)\n then Deferred.upon (yield t) (fun () -> run t)\n\n and run_worker t worker ~num_execs_before_yielding =\n assert (phys_equal t.current_execution_context worker.execution_context);\n if num_execs_before_yielding = 0\n then (\n Deque.enqueue_front t.very_low_priority_workers worker;\n yield_then_run t)\n else (\n let num_execs_before_yielding = num_execs_before_yielding - 1 in\n match worker.exec () with\n | Finished -> run_workers t ~num_execs_before_yielding\n | Not_finished -> run_worker t worker ~num_execs_before_yielding\n | exception exn ->\n let bt = Backtrace.Exn.most_recent () in\n Monitor.send_exn (Monitor.current ()) exn ~backtrace:(`This bt);\n run_workers t ~num_execs_before_yielding)\n ;;\n\n let enqueue ~f =\n let t = t () in\n let queue = t.very_low_priority_workers in\n let running = not (Deque.is_empty queue) in\n let execution_context =\n Execution_context.create_like (current_execution_context t) ~priority:Low\n in\n Deque.enqueue_back queue { execution_context; exec = f };\n if not running then enqueue t execution_context run t\n ;;\nend\n\nmodule For_bench = struct\n let advance_clock = advance_clock\nend\n","open! Core_kernel\nopen! Import\nmodule Scheduler = Scheduler1\nmodule Cell = Types.Cell\n\ntype any =\n [ `Empty\n | `Empty_one_handler\n | `Empty_one_or_more_handlers\n | `Full\n | `Indir\n ]\n\ntype 'a t = 'a Types.Ivar.t = { mutable cell : ('a, any) cell }\n\n(* The ['b] is used to encode the constructor. This allows us to write functions that\n take only one of the constructors, with no runtime test.\n\n We maintain the invariant that the directed graph with ivars as nodes and [Indir]s as\n edges is acyclic. The only functions that create an [Indir] are [squash] and\n [connect], and for those, the target of the [Indir] is always a non-[Indir]. Thus, the\n newly added edges are never part of a cycle. *)\nand ('a, 'b) cell = ('a, 'b) Types.Cell.t =\n | Empty_one_or_more_handlers :\n { (* [run] is mutable so we can set it to [ignore] when the handler is removed.\n This is used when we install a handler on a full ivar since it is immediately\n added to the scheduler. *)\n mutable run : 'a -> unit\n ; execution_context : Execution_context.t\n ; (* [prev] and [next] circularly doubly link all handlers of the same ivar. *)\n mutable prev : ('a, [ `Empty_one_or_more_handlers ]) cell\n ; mutable next : ('a, [ `Empty_one_or_more_handlers ]) cell\n }\n -> ('a, [> `Empty_one_or_more_handlers ]) cell\n | Empty_one_handler :\n ('a -> unit) * Execution_context.t\n -> ('a, [> `Empty_one_handler ]) cell\n | Empty : ('a, [> `Empty ]) cell\n | Full : 'a -> ('a, [> `Full ]) cell\n | Indir : 'a t -> ('a, [> `Indir ]) cell\n\nmodule Handler = struct\n type 'a t = ('a, [ `Empty_one_or_more_handlers ]) cell\n\n let run (Empty_one_or_more_handlers t : _ t) = t.run\n let execution_context (Empty_one_or_more_handlers t : _ t) = t.execution_context\n let prev (Empty_one_or_more_handlers t : _ t) = t.prev\n let next (Empty_one_or_more_handlers t : _ t) = t.next\n let set_run (Empty_one_or_more_handlers t : _ t) x = t.run <- x\n let set_prev (Empty_one_or_more_handlers t : _ t) x = t.prev <- x\n let set_next (Empty_one_or_more_handlers t : _ t) x = t.next <- x\n\n let create run execution_context =\n (* An optimized implementation of:\n\n {[\n let rec t =\n Empty_one_or_more_handlers\n { run\n ; execution_context\n ; prev = t\n ; next = t }\n in\n h1 ]}\n\n However the compilation of recursive value in OCaml is not optimal: the value is\n allocated twice and copied once (with a loop calling caml_modify). This is not\n necessary for simple recursive definitions like this one.\n\n Instead we allocate the value with dummy fields and update them after. *)\n let t =\n Empty_one_or_more_handlers\n { run; execution_context; prev = Obj.magic None; next = Obj.magic None }\n in\n set_prev t t;\n set_next t t;\n t\n ;;\n\n let create2 run1 execution_context1 run2 execution_context2 =\n (* An optimized implementation of:\n\n {[\n let rec t1 =\n { run = run1\n ; execution_context = execution_context1\n ; prev = t2\n ; next = t2 }\n and t2 =\n { run = run2\n ; execution_context = execution_context2\n ; prev = t1\n ; next = t1 }\n in\n t1 ]} *)\n let t1 =\n Empty_one_or_more_handlers\n { run = run1\n ; execution_context = execution_context1\n ; prev = Obj.magic None\n ; next = Obj.magic None\n }\n in\n let t2 =\n Empty_one_or_more_handlers\n { run = run2; execution_context = execution_context2; prev = t1; next = t1 }\n in\n set_prev t1 t2;\n set_next t1 t2;\n t1\n ;;\n\n let invariant t =\n Execution_context.invariant (execution_context t);\n let r = ref (next t) in\n while not (phys_equal !r t) do\n let t1 = !r in\n assert (phys_equal (prev (next t1)) t1);\n Execution_context.invariant (execution_context t1);\n r := next !r\n done\n ;;\n\n let is_singleton t = phys_equal t (next t)\n\n let length t =\n let n = ref 1 in\n let r = ref (next t) in\n while not (phys_equal !r t) do\n incr n;\n r := next !r\n done;\n !n\n ;;\n\n let enqueue t scheduler v = Scheduler.enqueue scheduler (execution_context t) (run t) v\n\n let schedule_jobs t v =\n let scheduler = Scheduler.t () in\n enqueue t scheduler v;\n let r = ref (next t) in\n while not (phys_equal !r t) do\n enqueue !r scheduler v;\n r := next !r\n done\n ;;\n\n let unlink t =\n set_prev (next t) (prev t);\n set_next (prev t) (next t);\n set_prev t t;\n set_next t t\n ;;\n\n let add t run execution_context =\n let result =\n Empty_one_or_more_handlers { run; execution_context; prev = prev t; next = t }\n in\n set_next (prev t) result;\n set_prev t result;\n result\n ;;\n\n (* [splice t1 t2] creates:\n\n {v\n --> t1 <--> ... <--> last1 <--> t2 <--> ... <--> last2 <--\n | |\n ----------------------------------------------------------\n v} *)\n let splice t1 t2 =\n let last1 = prev t1 in\n let last2 = prev t2 in\n set_next last1 t2;\n set_next last2 t1;\n set_prev t1 last2;\n set_prev t2 last1\n ;;\n\n let of_list l =\n match l with\n | [] -> None\n | (run, execution_context) :: l ->\n let first = create run execution_context in\n let rec loop prev l =\n match l with\n | [] -> set_prev first prev\n | (run, execution_context) :: l ->\n let t =\n Empty_one_or_more_handlers { run; execution_context; prev; next = first }\n in\n set_next prev t;\n loop t l\n in\n loop first l;\n Some first\n ;;\n\n let to_list first =\n let rec loop t acc =\n let acc = (run t, execution_context t) :: acc in\n if phys_equal t first then acc else loop (prev t) acc\n in\n loop (prev first) []\n ;;\n\n let sexp_of_t _ (t : _ t) =\n let (Empty_one_or_more_handlers { run = _; execution_context; next = _; prev = _ }) =\n t\n in\n [%message (execution_context : Execution_context.t)]\n ;;\nend\n\ntype 'a ivar = 'a t\n\n(* Compiled as the identity. *)\nlet cell_of_handler : _ Handler.t -> _ = function\n | Empty_one_or_more_handlers _ as x -> (x :> (_, any) cell)\n;;\n\nlet equal (t : _ t) t' = phys_equal t t'\nlet indir t = { cell = Indir t }\n\ninclude Scheduler.Ivar\n\n(* [squash t] returns the non-[Indir] ivar at the end of the (possibly empty) chain of\n [Indir]s starting with [t] and ensures that all [Indir]s along that chain are replaced\n with an [Indir] pointing to the end of the chain. *)\nlet squash =\n let rec follow indir t =\n (* [indir = Indir t] *)\n match t.cell with\n | Indir t' as indir' -> follow indir' t'\n | _ -> indir\n in\n let rec update t indir =\n match t.cell with\n | Indir t' ->\n t.cell <- indir;\n update t' indir\n | _ -> t\n in\n fun t ->\n match t.cell with\n | Indir t' ->\n (match t'.cell with\n | Indir t'' as indir -> update t (follow indir t'')\n | _ -> t' (* nothing to do, since [t] is a chain with a single [Indir] *))\n | _ -> t\n;;\n\n(* nothing to do, since [t] isn't an [Indir]. *)\n\nlet invariant a_invariant t =\n let t = squash t in\n match t.cell with\n | Indir _ -> assert false (* fulfilled by [squash] *)\n | Full a -> a_invariant a\n | Empty -> ()\n | Empty_one_handler (_, execution_context) ->\n Execution_context.invariant execution_context\n | Empty_one_or_more_handlers _ as handler -> Handler.invariant handler\n;;\n\nlet sexp_of_t sexp_of_a t : Sexp.t =\n let t = squash t in\n match t.cell with\n | Indir _ -> assert false (* fulfilled by [squash] *)\n | Full a -> List [ Atom \"Full\"; sexp_of_a a ]\n | Empty | Empty_one_handler _ | Empty_one_or_more_handlers _ -> Atom \"Empty\"\n;;\n\nlet peek t =\n let t = squash t in\n match t.cell with\n | Indir _ -> assert false (* fulfilled by [squash] *)\n | Full a -> Some a\n | Empty | Empty_one_handler _ | Empty_one_or_more_handlers _ -> None\n;;\n\nlet value t ~if_empty_then_failwith =\n let t = squash t in\n match t.cell with\n | Indir _ -> assert false (* fulfilled by [squash] *)\n | Full a -> a\n | Empty | Empty_one_handler _ | Empty_one_or_more_handlers _ ->\n failwith if_empty_then_failwith\n;;\n\nlet value_exn t = value t ~if_empty_then_failwith:\"Ivar.value_exn called on empty ivar\"\n\nlet is_empty t =\n let t = squash t in\n match t.cell with\n | Indir _ -> assert false (* fulfilled by [squash] *)\n | Full _ -> false\n | Empty | Empty_one_handler _ | Empty_one_or_more_handlers _ -> true\n;;\n\nlet is_full t = not (is_empty t)\n\nlet fill t v =\n let t = squash t in\n match t.cell with\n | Indir _ -> assert false (* fulfilled by [squash] *)\n | Full _ -> raise_s [%message \"Ivar.fill of full ivar\" (t : _ t)]\n | Empty -> t.cell <- Full v\n | Empty_one_handler (run, execution_context) ->\n t.cell <- Full v;\n Scheduler.(enqueue (t ())) execution_context run v\n | Empty_one_or_more_handlers _ as handler ->\n t.cell <- Full v;\n Handler.schedule_jobs handler v\n;;\n\nlet remove_handler t (handler : _ Handler.t) =\n Handler.set_run handler ignore;\n let t = squash t in\n match t.cell with\n | Indir _ -> assert false (* fulfilled by [squash] *)\n | Empty | Empty_one_handler _ ->\n (* These are only possible if [handler] was already removed. *)\n ()\n | Full _ ->\n (* This is possible if [t] was filled before we try to remove the handler. E.g.\n [Deferred.choose] will do this. *)\n ()\n | Empty_one_or_more_handlers _ as cell ->\n if Handler.is_singleton handler\n then t.cell <- Empty\n else (\n if phys_equal handler cell then t.cell <- cell_of_handler (Handler.next handler);\n Handler.unlink handler)\n;;\n\nlet add_handler t run execution_context =\n let t = squash t in\n match t.cell with\n | Indir _ -> assert false (* fulfilled by [squash] *)\n | Empty ->\n let handler = Handler.create run execution_context in\n t.cell <- cell_of_handler handler;\n handler\n | Empty_one_handler (run', execution_context') ->\n let handler = Handler.create2 run execution_context run' execution_context' in\n t.cell <- cell_of_handler handler;\n handler\n | Empty_one_or_more_handlers _ as handler -> Handler.add handler run execution_context\n | Full v ->\n let handler = Handler.create run execution_context in\n (* [run] calls [handler.run], which, if [handler] has been removed, has been changed\n to [ignore]. *)\n let run v = Handler.run handler v in\n Scheduler.(enqueue (t ())) execution_context run v;\n handler\n;;\n\nlet has_handlers t =\n let t = squash t in\n match t.cell with\n | Indir _ -> assert false (* fulfilled by [squash] *)\n | Empty_one_handler _ | Empty_one_or_more_handlers _ -> true\n | Empty | Full _ -> false\n;;\n\nlet upon' t run = add_handler t run Scheduler.(current_execution_context (t ()))\n\n(* [upon] is conceptually the same as:\n\n {[\n let upon t f = ignore (upon' t run) ]}\n\n However, below is a more efficient implementation, which is worth doing because [upon]\n is very widely used and is so much more common than [upon']. The below implementation\n avoids the use of the bag of handlers in the extremely common case of one handler for\n the deferred. *)\nlet upon t run =\n let scheduler = Scheduler.t () in\n let execution_context = Scheduler.current_execution_context scheduler in\n let t = squash t in\n match t.cell with\n | Indir _ -> assert false (* fulfilled by [squash] *)\n | Full v -> Scheduler.enqueue scheduler execution_context run v\n | Empty -> t.cell <- Empty_one_handler (run, execution_context)\n | Empty_one_handler (run', execution_context') ->\n t.cell\n <- cell_of_handler (Handler.create2 run execution_context run' execution_context')\n | Empty_one_or_more_handlers _ as handler ->\n ignore (Handler.add handler run execution_context : _ Handler.t)\n;;\n\n(* [connect] takes ivars [bind_result] and [bind_rhs], and makes [bind_rhs]\n be an [Indir] pointing to the non-indir cell reachable from [bind_result]. On entry\n to [connect], [bind_result] and [bind_rhs] may be chains, since [bind_rhs] is an\n arbitrary user-supplied deferred, and [bind_result] is returned to the user prior to\n being [connect]ed, and may have been converted to an indirection in the case of\n right-nested binds.\n\n The purpose of [connect] is to make tail-recursive bind loops use constant space.\n E.g.:\n\n {[\n let rec loop i =\n if i = 0\n then return ()\n else (\n let%bind () = after (sec 1.) in\n loop (i - 1)) ]}\n\n [connect] makes intermediate bind results all be [Indir]s pointing at the outermost\n bind, rather than being a linear-length chain, with each pointing to the previous one.\n Then, since the program is only holding on to the innermost and outermost binds all the\n intermediate ones can be garbage collected.\n\n [connect] works by squashing its arguments so that the [bind_rhs] always points at the\n ultimate result. *)\nlet connect =\n (* [repoint_indirs ~ivar ~indir ~bind_result] repoints to [indir] all the ivars in the\n chain reachable from [ivar], and returns the non-[Indir] cell at the end of the\n chain. After repointing, we will merge the handlers in that cell with the handlers\n in [bind_result], and put the merged set of handlers in [bind_result]. *)\n let rec repoint_indirs ~ivar ~indir ~bind_result =\n let cell = ivar.cell in\n match cell with\n | Indir ivar' ->\n ivar.cell <- indir;\n repoint_indirs ~ivar:ivar' ~indir ~bind_result\n | Full _ -> cell\n | Empty | Empty_one_handler _ | Empty_one_or_more_handlers _ ->\n (* It is possible that [bind_result] and [bind_rhs] are not equal, but their chains\n of indirs lead to the same non-[Indir] cell, in which case we cannot set that\n cell to point to itself, because that would introduce a cycle. *)\n if not (phys_equal ivar bind_result) then ivar.cell <- indir;\n cell\n in\n fun ~bind_result ~bind_rhs ->\n if not (phys_equal bind_result bind_rhs)\n then (\n let bind_result = squash bind_result in\n let indir = Indir bind_result in\n let bind_rhs_contents = repoint_indirs ~ivar:bind_rhs ~indir ~bind_result in\n (* update [bind_result] with the union of handlers in [bind_result] and\n [bind_rhs] *)\n match bind_result.cell, bind_rhs_contents with\n | Indir _, _ | _, Indir _ -> assert false\n (* fulfilled by [squash] and [repoint_indirs] *)\n (* [connect] is only used in bind, whose ivar is only ever exported as a read-only\n deferred. Thus, [bind_result] must be empty. *)\n | Full _, _ -> assert false\n | _, Empty -> ()\n | Empty, _ -> bind_result.cell <- bind_rhs_contents\n | Empty_one_handler (run, execution_context), Full v ->\n bind_result.cell <- bind_rhs_contents;\n Scheduler.(enqueue (t ())) execution_context run v\n | (Empty_one_or_more_handlers _ as handler), Full v ->\n bind_result.cell <- bind_rhs_contents;\n Handler.schedule_jobs handler v\n | ( Empty_one_handler (run1, execution_context1)\n , Empty_one_handler (run2, execution_context2) ) ->\n let handler1 = Handler.create2 run1 execution_context1 run2 execution_context2 in\n bind_result.cell <- cell_of_handler handler1\n | ( (Empty_one_or_more_handlers _ as handler1)\n , Empty_one_handler (run2, execution_context2) ) ->\n ignore (Handler.add handler1 run2 execution_context2 : _ Handler.t)\n | ( Empty_one_handler (run1, execution_context1)\n , (Empty_one_or_more_handlers _ as handler2) ) ->\n let handler1 = Handler.add handler2 run1 execution_context1 in\n bind_result.cell <- cell_of_handler handler1\n | ( (Empty_one_or_more_handlers _ as handler1)\n , (Empty_one_or_more_handlers _ as handler2) ) ->\n Handler.splice handler1 handler2)\n;;\n","open! Core_kernel\nopen! Import\nmodule Ivar = Ivar0\nmodule Handler = Ivar.Handler\n\n(* Deferreds present a covariant view of ivars. We could actually implement deferreds\n using a record of closures, as in the [essence_of_deferred] record below, for which the\n OCaml type checker can infer covariance. However, doing so would make [Ivar.read] very\n costly, because it would have to allocate lots of closures and a record. Instead of\n doing this, we make deferreds an abstract covariant type, which concretely is just the\n ivar, and use [Obj.magic] to convert back and forth between a deferred and its concrete\n representation as an ivar. This [Obj.magic] is safe because the representation is\n always just an ivar, and the covariance follows from the fact that all the deferred\n operations are equivalent to those implemented directly on top of the\n [essence_of_deferred].\n\n {[\n type (+'a, 'execution_context) essence_of_deferred =\n { peek : unit -> 'a option\n ; is_determined : unit -> bool\n ; upon : ('a -> unit) -> unit\n ; upon' : ('a -> unit) -> Unregister.t\n ; install_removable_handler : ('a, 'execution_context) Raw_handler.t -> Unregister.t; } ]} *)\n\ntype +'a t = 'a Types.Deferred.t\n\n(* the abstract covariant type, equivalent to ivar *)\n\nlet of_ivar (type a) (ivar : a Ivar.t) : a t = Obj.magic ivar\nlet to_ivar (type a) t : a Ivar.t = Obj.magic (t : a t)\nlet invariant invariant_a t = Ivar.invariant invariant_a (to_ivar t)\nlet sexp_of_t sexp_of_a t = Ivar.sexp_of_t sexp_of_a (to_ivar t)\nlet peek t = Ivar.peek (to_ivar t)\nlet return a = of_ivar (Ivar.create_full a)\nlet is_determined t = Ivar.is_full (to_ivar t)\n\nlet value_exn t =\n Ivar.value\n (to_ivar t)\n ~if_empty_then_failwith:\"Deferred.value_exn called on undetermined deferred\"\n;;\n\nlet upon t f = Ivar.upon (to_ivar t) f\n\nlet create f =\n let result = Ivar.create () in\n f result;\n of_ivar result\n;;\n\n(* don't use [create] here as it would allocate one more closure *)\nlet bind t ~f =\n let bind_result = Ivar.create () in\n upon t (fun a -> Ivar.connect ~bind_result ~bind_rhs:(to_ivar (f a)));\n of_ivar bind_result\n;;\n\nlet add_handler t f execution_context = Ivar.add_handler (to_ivar t) f execution_context\nlet remove_handler t h = Ivar.remove_handler (to_ivar t) h\n","open Core_kernel\nmodule Deferred = Deferred0\ninclude Ivar0\n\nlet read = Deferred.of_ivar\nlet fill_if_empty t v = if is_empty t then fill t v\n\ninclude Binable.Of_binable1 [@alert \"-legacy\"]\n (Option)\n (struct\n type nonrec 'a t = 'a t\n\n let to_binable t = peek t\n\n let of_binable = function\n | None -> create ()\n | Some a -> create_full a\n ;;\n end)\n","(** [Monad_sequence.S] is a generic interface specifying functions that deal with a\n container and a monad. It is specialized to the [Deferred] monad and used with\n various containers in modules [Deferred.Array], [Deferred.List], [Deferred.Queue], and\n [Deferred.Sequence]. The [Monad_sequence.how] type specifies the parallelism of\n container iterators. *)\n\nopen! Core_kernel\nopen! Import\n\ntype how =\n [ `Parallel (** like [`Max_concurrent_jobs Int.max_value] *)\n | `Sequential\n (** [`Sequential] is often but not always the same as [`Max_concurrent_jobs 1]\n (for example, they differ in the [Or_error] monad). *)\n | `Max_concurrent_jobs of int\n ]\n[@@deriving sexp_of]\n\nmodule type S = sig\n type 'a monad\n type 'a t\n\n val foldi : 'a t -> init:'b -> f:(int -> 'b -> 'a -> 'b monad) -> 'b monad\n val fold : 'a t -> init:'b -> f:('b -> 'a -> 'b monad) -> 'b monad\n val find : 'a t -> f:('a -> bool monad) -> 'a option monad\n val findi : 'a t -> f:(int -> 'a -> bool monad) -> (int * 'a) option monad\n val find_map : 'a t -> f:('a -> 'b option monad) -> 'b option monad\n val find_mapi : 'a t -> f:(int -> 'a -> 'b option monad) -> 'b option monad\n val exists : 'a t -> f:('a -> bool monad) -> bool monad\n val existsi : 'a t -> f:(int -> 'a -> bool monad) -> bool monad\n val for_all : 'a t -> f:('a -> bool monad) -> bool monad\n val for_alli : 'a t -> f:(int -> 'a -> bool monad) -> bool monad\n val all : 'a monad t -> 'a t monad\n val all_unit : unit monad t -> unit monad\n\n (** {2 Deferred iterators}\n\n In the following, the default [how] is [`Sequential] *)\n\n val init : ?how:how -> int -> f:(int -> 'a monad) -> 'a t monad\n val iter : ?how:how -> 'a t -> f:('a -> unit monad) -> unit monad\n val iteri : ?how:how -> 'a t -> f:(int -> 'a -> unit monad) -> unit monad\n val map : ?how:how -> 'a t -> f:('a -> 'b monad) -> 'b t monad\n val mapi : ?how:how -> 'a t -> f:(int -> 'a -> 'b monad) -> 'b t monad\n val filter : ?how:how -> 'a t -> f:('a -> bool monad) -> 'a t monad\n val filteri : ?how:how -> 'a t -> f:(int -> 'a -> bool monad) -> 'a t monad\n val filter_map : ?how:how -> 'a t -> f:('a -> 'b option monad) -> 'b t monad\n val filter_mapi : ?how:how -> 'a t -> f:(int -> 'a -> 'b option monad) -> 'b t monad\n val concat_map : ?how:how -> 'a t -> f:('a -> 'b t monad) -> 'b t monad\n val concat_mapi : ?how:how -> 'a t -> f:(int -> 'a -> 'b t monad) -> 'b t monad\nend\n","open Core_kernel\nmodule Scheduler = Scheduler1\ninclude Deferred0\n\n(* To avoid a space leak, it is necessary that [never] allocates a new ivar whenever it is\n called. Code can bind on [never ()], so if we re-used the ivar, we could endlessly\n accumulate handlers. *)\nlet never () = Ivar.read (Ivar.create ())\n\nmodule M = Monad.Make (struct\n include Deferred0\n\n let map t ~f =\n (* We manually inline [Deferred.create] here, because the non-flambda compiler isn't\n able to optimize away the closure that would be be created. *)\n let result = Ivar.create () in\n upon t (fun a -> Ivar.fill result (f a));\n of_ivar result\n ;;\n\n let map = `Custom map\n end)\n\ninclude M\n\n(* We rebind all the various [return]s because the use of the [Monad.Make] functor\n causes the compiler to not inline [return], and hence makes it impossible to\n statically allocate constants like [return ()]. By rebinding [return] as\n [Deferred0.return], the compiler can see that:\n\n {[\n return a = { Ivar.Immutable. cell = Full a } ]}\n\n And hence, if [a] is constant, then the return is constant and can be statically\n allocated. When compiling with flambda, the compiler inlines [return] and this manual\n rebinding would not help; we've decided to do it anyway so that non-flambda builds\n get the optimization. *)\nlet return = Deferred0.return\n\nmodule Let_syntax = struct\n include M.Let_syntax\n\n let return = Deferred0.return\n\n module Let_syntax = struct\n include M.Let_syntax.Let_syntax\n\n let return = Deferred0.return\n end\nend\n\nopen Let_syntax\n\n(* We shadow [all] on-purpose here, since the default definition introduces a chain of\n binds as long as the list. *)\nlet all = `Make_sure_to_define_all_elsewhere\nlet _ = all\nlet unit = return ()\n\nlet both t1 t2 =\n create (fun result ->\n upon t1 (fun a1 -> upon t2 (fun a2 -> Ivar.fill result (a1, a2))))\n;;\n\nmodule Infix = struct\n include Monad_infix\n\n let ( >>> ) = upon\n let ppx_both = both\nend\n\nopen Infix\n\nlet don't_wait_for (_ : unit t) = ()\n\nmodule Choice = struct\n type +'a t = T : 'b Deferred0.t * ('b -> 'a) -> 'a t\n\n let map (T (t, f1)) ~f:f2 = T (t, fun x -> f2 (f1 x))\nend\n\ntype 'a choice = 'a Choice.t\n\nmodule Unregister = struct\n (* This representation saves 2n words for a list of n choices. *)\n type t =\n | Nil : t\n | Cons : 'a Deferred0.t * 'a Deferred0.Handler.t * t -> t\n\n let rec process = function\n | Nil -> ()\n | Cons (t, handler, rest) ->\n remove_handler t handler;\n process rest\n ;;\nend\n\nlet choice t f = Choice.T (t, f)\n\nlet enabled choices =\n let result = Ivar.create () in\n let unregisters = ref Unregister.Nil in\n let ready _ =\n if Ivar.is_empty result\n then (\n Unregister.process !unregisters;\n Ivar.fill result (fun () ->\n List.rev\n (List.fold choices ~init:[] ~f:(fun ac (Choice.T (t, f)) ->\n match peek t with\n | None -> ac\n | Some v -> f v :: ac))))\n in\n let execution_context = Scheduler.(current_execution_context (t ())) in\n unregisters\n := List.fold choices ~init:Unregister.Nil ~f:(fun acc (Choice.T (t, _)) ->\n Cons (t, Deferred0.add_handler t ready execution_context, acc));\n Ivar.read result\n;;\n\nlet rec choose_result choices =\n match choices with\n | [] -> assert false\n | Choice.T (t, f) :: choices ->\n (match peek t with\n | None -> choose_result choices\n | Some v -> f v)\n;;\n\nlet choose choices =\n let result = Ivar.create () in\n let unregisters = ref Unregister.Nil in\n let ready _ =\n if Ivar.is_empty result\n then (\n Unregister.process !unregisters;\n Ivar.fill result (choose_result choices))\n in\n let execution_context = Scheduler.(current_execution_context (t ())) in\n unregisters\n := List.fold choices ~init:Unregister.Nil ~f:(fun acc (Choice.T (t, _)) ->\n Cons (t, Deferred0.add_handler t ready execution_context, acc));\n Ivar.read result\n;;\n\nlet any_f ts f = choose (List.map ts ~f:(fun t -> choice t f))\nlet any ts = any_f ts Fn.id\nlet any_unit ts = any_f ts (Fn.ignore : unit -> unit)\n\nlet for_ start ~to_ ~do_ =\n let rec loop i =\n if i > to_\n then return ()\n else (\n let%bind () = do_ i in\n loop (i + 1))\n in\n loop start\n;;\n\nlet repeat_until_finished state f =\n create (fun finished ->\n let rec loop state =\n f state\n >>> function\n | `Repeat state -> loop state\n | `Finished result -> Ivar.fill finished result\n in\n loop state)\n;;\n\nlet forever state f =\n repeat_until_finished state (fun state ->\n let%map state = f state in\n `Repeat state)\n >>> never_returns\n;;\n\ntype how = Monad_sequence.how [@@deriving sexp_of]\n\nmodule type Monad_sequence = Monad_sequence.S with type 'a monad := 'a t\n\n\nlet fold t ~init ~f =\n create (fun result ->\n let rec loop t b =\n match t with\n | [] -> Ivar.fill result b\n | x :: xs -> f b x >>> fun b -> loop xs b\n in\n loop t init)\n;;\n\nlet seqmap t ~f = fold t ~init:[] ~f:(fun bs a -> f a >>| fun b -> b :: bs) >>| List.rev\nlet all ds = seqmap ds ~f:Fn.id\nlet all_unit ds = fold ds ~init:() ~f:(fun () d -> d)\nlet ok x = x >>| fun x -> Ok x\n","open Deferred1\ninclude Infix\ninclude Let_syntax\n\nlet choice = choice\nlet choose = choose\nlet don't_wait_for = don't_wait_for\nlet never = never\nlet return = return\nlet upon = upon\n","open! Core_kernel\nopen! Import\n\ntype 'a u =\n | Empty of 'a Ivar.t\n | Full\n[@@deriving sexp_of]\n\ntype 'a t = 'a u ref [@@deriving sexp_of]\n\nlet invariant _ t =\n Invariant.invariant [%here] t [%sexp_of: _ t] (fun () ->\n match !t with\n | Full -> ()\n | Empty ivar -> assert (Ivar.is_empty ivar))\n;;\n\nlet create () =\n let ivar = Ivar.create () in\n let t = ref (Empty ivar) in\n t, Ivar.read ivar\n;;\n\nlet is_empty t =\n match !t with\n | Empty _ -> true\n | Full -> false\n;;\n\nlet fill t a =\n match !t with\n | Empty i ->\n t := Full;\n Ivar.fill i a\n | Full -> raise_s [%message \"attempt to fill full ivar\"]\n;;\n","open! Core_kernel\nopen! Import\nmodule Deferred = Deferred1\n\nmodule Stream = struct\n type 'a t = 'a next Deferred.t\n\n and 'a next = 'a Types.Stream.next =\n | Nil\n | Cons of 'a * 'a t\n\n let sexp_of_t sexp_of_a t =\n let rec loop d ac : Sexp.t =\n match Deferred.peek d with\n | None -> List (List.rev (Sexp.Atom \"...\" :: ac))\n | Some Nil -> List (List.rev ac)\n | Some (Cons (a, t)) -> loop t (sexp_of_a a :: ac)\n in\n loop t []\n ;;\n\n let next t = t\nend\n\ntype 'a t = 'a Types.Tail.t =\n { (* [next] points at the tail of the stream *) mutable next : 'a Stream.next Ivar.t }\n[@@deriving fields]\n\nlet sexp_of_t _ t : Sexp.t =\n Atom (if Ivar.is_empty t.next then \"\" else \"\")\n;;\n\nlet create () = { next = Ivar.create () }\nlet collect t = Ivar.read (next t)\nlet is_closed t = Ivar.is_full (next t)\n\nlet fill_exn t v =\n if is_closed t then raise_s [%message \"stream is closed\"] else Ivar.fill (next t) v\n;;\n\nlet close_exn t = fill_exn t Nil\nlet close_if_open t = if not (is_closed t) then Ivar.fill (next t) Nil\n\nlet extend t v =\n let next = Ivar.create () in\n fill_exn t (Cons (v, Ivar.read next));\n t.next <- next\n;;\n","open Core_kernel\nopen Deferred_std\nmodule Deferred = Deferred1\ninclude Tail.Stream\n\nlet first_exn t =\n match%map next t with\n | Nil -> raise_s [%message \"Stream.first of empty stream\"]\n | Cons (x, _) -> x\n;;\n\nlet fold' t ~init ~f =\n Deferred.create (fun result ->\n let rec loop t b =\n upon (next t) (function\n | Nil -> Ivar.fill result b\n | Cons (v, t) -> upon (f b v) (loop t))\n in\n loop t init)\n;;\n\n(* [fold] is implemented to avoid per-stream-element deferred overhead in the case when\n multiple stream elements are available simultaneously. *)\nlet fold t ~init ~f =\n Deferred.create (fun result ->\n let rec loop t b =\n match Deferred.peek (next t) with\n | None -> upon (next t) (fun next -> loop_next next b)\n | Some next -> loop_next next b\n and loop_next next b =\n match next with\n | Nil -> Ivar.fill result b\n | Cons (v, t) -> loop t (f b v)\n in\n loop t init)\n;;\n\nlet length t = fold t ~init:0 ~f:(fun n _ -> n + 1)\nlet iter' t ~f = fold' t ~init:() ~f:(fun () v -> f v)\n\nlet closed t =\n match Deferred.peek (next t) with\n | Some Nil -> return ()\n | _ -> iter' t ~f:(fun _ -> return ())\n;;\n\nlet iter t ~f =\n don't_wait_for\n (iter' t ~f:(fun a ->\n f a;\n return ()))\n;;\n\nlet create f =\n let tail = Tail.create () in\n (* collect before calling [f], in case [f] immediately extends. *)\n let t = Tail.collect tail in\n f tail;\n t\n;;\n\nlet unfold b ~f =\n create (fun tail ->\n let rec loop b =\n upon (f b) (function\n | None -> Tail.close_exn tail\n | Some (a, b) ->\n Tail.extend tail a;\n loop b)\n in\n loop b)\n;;\n\nlet of_list l =\n create (fun tail ->\n List.iter l ~f:(fun x -> Tail.extend tail x);\n Tail.close_exn tail)\n;;\n\nlet to_list s = fold' s ~init:[] ~f:(fun b a -> return (a :: b)) >>| List.rev\nlet copy_to_tail t tail = iter' t ~f:(fun a -> return (Tail.extend tail a))\n\nlet append t1 t2 =\n create (fun tail ->\n upon (copy_to_tail t1 tail) (fun () ->\n upon (copy_to_tail t2 tail) (fun () -> Tail.close_exn tail)))\n;;\n\nlet concat t =\n create (fun tail ->\n upon (iter' t ~f:(fun t -> copy_to_tail t tail)) (fun () -> Tail.close_exn tail))\n;;\n\nlet filter' t ~f =\n create (fun tail ->\n upon\n (iter' t ~f:(fun v ->\n match%map f v with\n | false -> ()\n | true -> Tail.extend tail v))\n (fun () -> Tail.close_exn tail))\n;;\n\nlet filter_deprecated t ~f = filter' t ~f:(fun a -> return (f a))\n\nlet filter_map' t ~f =\n create (fun tail ->\n upon\n (iter' t ~f:(fun v ->\n match%map f v with\n | None -> ()\n | Some v -> Tail.extend tail v))\n (fun () -> Tail.close_exn tail))\n;;\n\nlet filter_map_deprecated t ~f = filter_map' t ~f:(fun a -> return (f a))\n\nlet map' t ~f =\n create (fun tail ->\n upon\n (iter' t ~f:(fun v -> f v >>| Tail.extend tail))\n (fun () -> Tail.close_exn tail))\n;;\n\nlet map t ~f = map' t ~f:(fun a -> return (f a))\n\nlet first_n s n =\n create (fun tail ->\n let rec loop s n =\n if n = 0\n then Tail.close_exn tail\n else\n upon (next s) (function\n | Nil -> Tail.close_exn tail\n | Cons (x, t) ->\n Tail.extend tail x;\n loop t (n - 1))\n in\n loop s n)\n;;\n\nlet available_now t =\n let rec loop t ac =\n match Deferred.peek (next t) with\n | None | Some Nil -> List.rev ac, t\n | Some (Cons (x, t)) -> loop t (x :: ac)\n in\n loop t []\n;;\n\nlet split ?(stop = Deferred.never ()) ?(f = fun _ -> `Continue) t =\n let reason_for_stopping = Ivar.create () in\n let prefix = Tail.create () in\n let finish v =\n Tail.close_exn prefix;\n Ivar.fill reason_for_stopping v\n in\n let rec loop t =\n choose [ choice stop (fun () -> `Stopped); choice (next t) (fun o -> `Next o) ]\n >>> function\n | `Stopped -> finish (`Stopped t)\n | `Next o ->\n (match o with\n | Nil -> finish `End_of_stream\n | Cons (a, t) ->\n (match f a with\n | `Continue ->\n Tail.extend prefix a;\n loop t\n | `Found b -> finish (`Found (b, t))))\n in\n loop t;\n Tail.collect prefix, Ivar.read reason_for_stopping\n;;\n\nlet find t ~f =\n let _, found = split t ~f:(fun a -> if f a then `Found a else `Continue) in\n match%map found with\n | `Stopped _ -> assert false\n | (`End_of_stream | `Found _) as x -> x\n;;\n\nlet ungroup t =\n create (fun tail ->\n upon\n (iter' t ~f:(fun l ->\n List.iter l ~f:(fun x -> Tail.extend tail x);\n return ()))\n (fun () -> Tail.close_exn tail))\n;;\n\nlet interleave ts =\n create (fun tail ->\n (* The interleaved stream should be closed when the outer stream and all of\n the inner streams have been closed. Keep a count of the number of open\n streams and close the interleaved stream when that count becomes\n zero. *)\n let num_open = ref 1 in\n (* 1 for the outer stream that is open *)\n let close () =\n num_open := !num_open - 1;\n if !num_open = 0 then Tail.close_exn tail\n in\n let outer_closed =\n iter' ts ~f:(fun t ->\n num_open := !num_open + 1;\n upon (copy_to_tail t tail) close;\n return ())\n in\n upon outer_closed close)\n;;\n\nlet take_until t d =\n create (fun tail ->\n let rec loop t =\n upon\n (choose [ choice d (fun () -> `Stop); choice (next t) (fun z -> `Next z) ])\n (function\n | `Stop | `Next Nil -> Tail.close_exn tail\n | `Next (Cons (x, t)) ->\n Tail.extend tail x;\n loop t)\n in\n loop t)\n;;\n\nlet iter_durably' t ~f =\n Deferred.create (fun result ->\n let rec loop t =\n next t\n >>> function\n | Nil -> Ivar.fill result ()\n | Cons (x, t) ->\n Monitor.try_with ~rest:`Raise (fun () -> f x)\n >>> fun z ->\n loop t;\n (match z with\n | Ok () -> ()\n | Error e -> Monitor.send_exn (Monitor.current ()) e)\n in\n loop t)\n;;\n\nlet iter_durably_report_end t ~f =\n Deferred.create (fun result ->\n let rec loop t =\n next t\n >>> function\n | Nil -> Ivar.fill result ()\n | Cons (x, t) ->\n (* We immediately call [loop], thus making the iter durable. Any exceptions\n raised by [f] will not prevent the loop from continuing, and will go to the\n monitor of whomever called [iter_durably_report_end]. *)\n loop t;\n f x\n in\n loop t)\n;;\n\nlet iter_durably t ~f = don't_wait_for (iter_durably_report_end t ~f)\n\nlet of_fun f =\n unfold () ~f:(fun () ->\n let%map a = f () in\n Some (a, ()))\n;;\n","include Synchronous_time_source0\n\nlet create = Scheduler1.create_time_source\nlet wall_clock = Scheduler1.wall_clock\n","open! Core_kernel\nopen! Import\n\ntype ('a, 'permission) t = ('a, 'permission) Types.Bvar.t\n\ntype 'a repr = 'a Types.Bvar.repr =\n { mutable has_any_waiters : bool\n ; mutable ivar : 'a Ivar.t\n }\n[@@deriving fields, sexp_of]\n\nlet invariant invariant_a _ t =\n let repr = Types.Bvar.to_repr t in\n Invariant.invariant [%here] repr [%sexp_of: _ repr] (fun () ->\n let check f = Invariant.check_field repr f in\n Fields_of_repr.iter\n ~has_any_waiters:\n (check (fun has_any_waiters ->\n if Ivar.has_handlers repr.ivar then assert has_any_waiters))\n ~ivar:\n (check (fun ivar ->\n Ivar.invariant invariant_a ivar;\n assert (Ivar.is_empty ivar))))\n;;\n\nlet sexp_of_t _ _ t =\n let { has_any_waiters; ivar = _ } = Types.Bvar.to_repr t in\n (* We don't show [ivar] because it's always empty. *)\n [%message (has_any_waiters : bool)]\n;;\n\ninclude Scheduler1.Bvar\n\nlet broadcast t a =\n let repr = Types.Bvar.to_repr t in\n if repr.has_any_waiters\n then (\n repr.has_any_waiters <- false;\n Ivar.fill repr.ivar a;\n repr.ivar <- Ivar.create ())\n;;\n\nlet wait t =\n let repr = Types.Bvar.to_repr t in\n repr.has_any_waiters <- true;\n Ivar.read repr.ivar\n;;\n\nlet has_any_waiters t =\n let repr = Types.Bvar.to_repr t in\n repr.has_any_waiters\n;;\n","open! Core_kernel\nopen! Import\nopen! Deferred_std\n\nlet debug = Debug.clock\n\nmodule Alarm = Timing_wheel.Alarm\nmodule Deferred = Deferred1\nmodule Scheduler = Scheduler1\n\nlet upon = Deferred.upon\nlet choose = Deferred.choose\nlet choice = Deferred.choice\nlet ( >>> ) = upon\n\nmodule T1 = struct\n include Synchronous_time_source0.T1\n\n (* We don't include the [id] in the sexp because the user (rightly) can't control it, so\n it's hard to make it deterministic in tests. *)\n let sexp_of_t\n _\n { id = _\n ; advance_errors = _\n ; am_advancing = _\n ; events\n ; fired_events = _\n ; handle_fired = _\n ; is_wall_clock\n ; most_recently_fired = _\n ; scheduler = _\n }\n =\n if is_wall_clock\n then [%message \"\"]\n else\n [%message\n (is_wall_clock : bool)\n (* We don't display the [Job.t]s in [events] because those are\n pool pointers, which are uninformative. *)\n (events : _ Timing_wheel.t)]\n ;;\nend\n\nopen T1\n\nmodule Read_write = struct\n type t = read_write T1.t [@@deriving sexp_of]\n\n let invariant = invariant\n let invariant_with_jobs = invariant_with_jobs\nend\n\ntype t = read T1.t [@@deriving sexp_of]\n\nlet invariant = invariant\nlet invariant_with_jobs = invariant_with_jobs\nlet read_only (t : [> read ] T1.t) = (t :> t)\nlet create = Scheduler.create_time_source\nlet wall_clock = Scheduler.wall_clock\nlet alarm_precision t = Timing_wheel.alarm_precision t.events\nlet next_alarm_fires_at t = Timing_wheel.next_alarm_fires_at t.events\nlet timing_wheel_now t = Timing_wheel.now t.events\nlet id t = t.id\n\nmodule Id = Synchronous_time_source0.Id\n\nlet now t =\n if t.is_wall_clock\n then\n (* For the wall-clock time-source, we use [Time_ns.now ()] rather than\n [Timing_wheel.now t.events]. The latter is only updated at the start of each\n cycle. There can be substantial difference between the two when people do long\n running computations or mix blocking code with async. And humans expect that\n wall-clock time is based on [Time.now], not some artifact of async\n implementation. *)\n Time_ns.now ()\n else timing_wheel_now t\n;;\n\n(* We preallocate [send_exn] to avoid allocating it on each call to [advance_clock]. *)\nlet send_exn = Some Monitor.send_exn\nlet advance_directly t ~to_ = Synchronous_time_source0.advance_clock t ~to_ ~send_exn\nlet advance_directly_by t by = advance_directly t ~to_:(Time_ns.after (now t) by)\nlet advance = advance_directly\nlet advance_by = advance_directly_by\nlet fire_past_alarms t = Synchronous_time_source0.fire_past_alarms t ~send_exn\nlet yield t = Bvar.wait (Scheduler.yield t.scheduler)\n\nlet advance_by_alarms ?wait_for t ~to_ =\n let run_queued_alarms () =\n (* Every time we want to run queued alarms we need to yield control back to the\n [Async.Scheduler] and [wait_for] any logic that is supposed to finish at this time\n before advancing. If no [wait_for] logic is specified we can simply yield control\n by invoking [yield t], which enqueues another job at the end of the scheduler job\n queue so alarm jobs have the opportunity to run before we advance. *)\n match wait_for with\n | None -> yield t\n | Some f -> f ()\n in\n let finish () =\n advance_directly t ~to_;\n fire_past_alarms t;\n (* so that alarms scheduled at or before [to_] fire *)\n run_queued_alarms ()\n in\n let rec walk_alarms () =\n match next_alarm_fires_at t with\n | None -> finish ()\n | Some next_alarm_fires_at ->\n if Time_ns.( >= ) next_alarm_fires_at to_\n then finish ()\n else (\n advance_directly t ~to_:next_alarm_fires_at;\n let queued_alarms_ran = run_queued_alarms () in\n if Deferred.is_determined queued_alarms_ran\n then walk_alarms ()\n else (\n let%bind () = queued_alarms_ran in\n walk_alarms ()))\n in\n (* This first [run_queued_alarms] call allows [Clock_ns.every] the opportunity to run\n its continuation deferreds so that they can reschedule alarms. This is particularly\n useful in our \"advance hits intermediate alarms\" unit test below, but likely useful\n in other cases where [every] is synchronously followed by [advance]. *)\n let%bind () = run_queued_alarms () in\n walk_alarms ()\n;;\n\nlet advance_by_alarms_by ?wait_for t by =\n advance_by_alarms ?wait_for t ~to_:(Time_ns.after (now t) by)\n;;\n\nlet span_to_time t span = Time_ns.after (now t) span\n\nlet schedule_job t ~at execution_context f a =\n let alarm =\n Timing_wheel.add\n t.events\n ~at\n (Job_or_event.of_job (Scheduler.create_job t.scheduler execution_context f a))\n in\n (match t.scheduler.event_added_hook with\n | None -> ()\n | Some f -> f at);\n alarm\n;;\n\nlet run_at_internal t time f a =\n let execution_context = Scheduler.current_execution_context t.scheduler in\n if Time_ns.( > ) time (Timing_wheel.now t.events)\n then schedule_job t ~at:time execution_context f a\n else (\n Scheduler.enqueue t.scheduler execution_context f a;\n Alarm.null ())\n;;\n\nlet run_at t time f a = ignore (run_at_internal t time f a : _ Alarm.t)\nlet run_after t span f a = run_at t (span_to_time t span) f a\n\nlet at =\n let fill result = Ivar.fill result () in\n fun t time ->\n if Time_ns.( <= ) time (Timing_wheel.now t.events)\n then return ()\n else (\n let result = Ivar.create () in\n ignore (run_at_internal t time fill result : _ Alarm.t);\n Ivar.read result)\n;;\n\nlet after t span = at t (span_to_time t span)\n\nlet remove_alarm t alarm : unit =\n let job_or_event = Alarm.value t.events alarm in\n (let open Job_or_event.Match in\n let (K k) = kind job_or_event in\n match k, project k job_or_event with\n | Job, job -> Scheduler.free_job t.scheduler job\n | Event, _ ->\n (* This is unreachable because [alarm] only ever comes from [Event.alarm] which only\n ever gets populated by a call to [schedule_job]. *)\n assert false);\n Timing_wheel.remove t.events alarm\n;;\n\nlet remove_alarm_if_scheduled t alarm =\n if Timing_wheel.mem t.events alarm then remove_alarm t alarm\n;;\n\nmodule Event = struct\n module Fired = struct\n type ('a, 'h) t =\n | Aborted of 'a\n | Happened of 'h\n [@@deriving sexp_of]\n end\n\n type ('a, 'h) t =\n { mutable alarm : Job_or_event.t Alarm.t\n ; mutable fire : unit -> unit\n ; (* As long as [Ivar.is_empty fired], we have not yet committed to whether the event\n will happen or be aborted. When [Ivar.is_empty fired], the alarm may or may not\n be in the timing wheel -- if it isn't, then there's a job in Async's job queue\n that will fire the event, unless it is aborted before that job can run. *)\n fired : ('a, 'h) Fired.t Ivar.t\n ; (* [num_fires_to_skip] is used to reschedule events that have fired and entered the\n Async job queue, but have not yet run. Those jobs only run if [num_fires_to_skip\n = 0], and otherwise just decrement it. So, to reschedule an event in such a\n state, we increment [num_fires_to_skip] and add a new alarm to the timing\n wheel. *)\n mutable num_fires_to_skip : int\n ; (* [scheduled_at] is the time at which [t] has most recently been scheduled to fire.\n While [t.alarm] is still in the timing wheel, this is the same as [Alarm.at\n t.alarm]. *)\n mutable scheduled_at : Time_ns.t\n ; time_source : Synchronous_time_source.t\n }\n [@@deriving fields, sexp_of]\n\n type t_unit = (unit, unit) t [@@deriving sexp_of]\n\n let fired t = Ivar.read t.fired\n\n let invariant invariant_a invariant_h t =\n Invariant.invariant [%here] t [%sexp_of: (_, _) t] (fun () ->\n let events = t.time_source.events in\n let check f = Invariant.check_field t f in\n Fields.iter\n ~alarm:\n (check (fun alarm ->\n if Ivar.is_full t.fired\n then assert (not (Timing_wheel.mem events alarm))\n else if Timing_wheel.mem events alarm\n then assert (Job_or_event.is_job (Alarm.value events alarm))))\n ~fire:ignore\n ~fired:\n (check (fun (fired : _ Fired.t Ivar.t) ->\n match Deferred.peek (Ivar.read fired) with\n | None -> ()\n | Some (Aborted a) -> invariant_a a\n | Some (Happened h) -> invariant_h h))\n ~num_fires_to_skip:\n (check (fun num_fires_to_skip -> assert (num_fires_to_skip >= 0)))\n ~scheduled_at:\n (check (fun scheduled_at ->\n if Timing_wheel.mem events t.alarm\n then\n [%test_result: Time_ns.t]\n scheduled_at\n ~expect:(Alarm.at events t.alarm)))\n ~time_source:ignore)\n ;;\n\n module Status = struct\n type ('a, 'h) t =\n | Aborted of 'a\n | Happened of 'h\n | Scheduled_at of Time_ns.t\n [@@deriving sexp_of]\n end\n\n let status t : _ Status.t =\n match Deferred.peek (Ivar.read t.fired) with\n | None -> Scheduled_at t.scheduled_at\n | Some (Aborted a) -> Aborted a\n | Some (Happened h) -> Happened h\n ;;\n\n module Abort_result = struct\n type ('a, 'h) t =\n | Ok\n | Previously_aborted of 'a\n | Previously_happened of 'h\n [@@deriving sexp_of]\n end\n\n let abort t a : _ Abort_result.t =\n if debug then Debug.log \"Time_source.Event.abort\" t [%sexp_of: (_, _) t];\n match Deferred.peek (fired t) with\n | Some (Aborted a) -> Previously_aborted a\n | Some (Happened h) -> Previously_happened h\n | None ->\n Ivar.fill t.fired (Aborted a);\n remove_alarm_if_scheduled t.time_source t.alarm;\n Ok\n ;;\n\n let abort_exn t a =\n match abort t a with\n | Ok -> ()\n | Previously_happened _ ->\n raise_s\n [%message \"Clock.Event.abort_exn failed to abort event that previously happened\"]\n | Previously_aborted _ ->\n raise_s\n [%message \"Clock.Event.abort_exn failed to abort event that previously aborted\"]\n ;;\n\n let abort_if_possible t a = ignore (abort t a : _ Abort_result.t)\n let schedule t = t.alarm <- run_at_internal t.time_source t.scheduled_at t.fire ()\n\n module Reschedule_result = struct\n type ('a, 'h) t =\n | Ok\n | Previously_aborted of 'a\n | Previously_happened of 'h\n [@@deriving sexp_of]\n end\n\n let reschedule_at t at : _ Reschedule_result.t =\n if debug\n then\n Debug.log\n \"Time_source.Event.reschedule_at\"\n (t, at)\n [%sexp_of: (_, _) t * Time_ns.t];\n match Deferred.peek (fired t) with\n | Some (Aborted a) -> Previously_aborted a\n | Some (Happened h) -> Previously_happened h\n | None ->\n let events = t.time_source.events in\n let is_in_timing_wheel = Timing_wheel.mem events t.alarm in\n let am_trying_to_reschedule_in_the_future =\n Time_ns.( > ) at (Timing_wheel.now events)\n in\n t.scheduled_at <- at;\n (match am_trying_to_reschedule_in_the_future, is_in_timing_wheel with\n | false, false -> ()\n | false, true ->\n t.time_source.handle_fired t.alarm;\n Timing_wheel.remove events t.alarm\n | true, false ->\n t.num_fires_to_skip <- t.num_fires_to_skip + 1;\n schedule t\n | true, true -> Timing_wheel.reschedule events t.alarm ~at);\n Ok\n ;;\n\n let reschedule_after t span = reschedule_at t (span_to_time t.time_source span)\n\n let run_at time_source scheduled_at f z =\n if debug then Debug.log \"Time_source.Event.run_at\" scheduled_at [%sexp_of: Time_ns.t];\n let t =\n { alarm = Alarm.null ()\n ; fire = ignore (* set below *)\n ; fired = Ivar.create ()\n ; num_fires_to_skip = 0\n ; scheduled_at\n ; time_source = read_only time_source\n }\n in\n let fire () =\n (* [fire] runs in an Async job. The event may have been aborted after the job\n was enqueued, so [fire] must check [fired]. *)\n if Ivar.is_empty t.fired\n then\n if t.num_fires_to_skip > 0\n then t.num_fires_to_skip <- t.num_fires_to_skip - 1\n else (\n let result = f z in\n (* [f z] may have aborted the event, so we must check [fired] again. *)\n if Ivar.is_empty t.fired then Ivar.fill t.fired (Happened result))\n in\n t.fire <- fire;\n schedule t;\n t\n ;;\n\n let at time_source time = run_at time_source time ignore ()\n\n let run_after time_source span f a =\n run_at time_source (span_to_time time_source span) f a\n ;;\n\n let after time_source span = at time_source (span_to_time time_source span)\nend\n\nlet at_times ?(stop = Deferred.never ()) t next_time =\n let tail = Tail.create () in\n let rec loop () =\n choose\n [ choice stop (fun () -> `Stop); choice (at t (next_time ())) (fun () -> `Tick) ]\n >>> function\n | `Stop -> Tail.close_exn tail\n | `Tick ->\n Tail.extend tail ();\n loop ()\n in\n loop ();\n Tail.collect tail\n;;\n\nlet at_varying_intervals ?stop t compute_span =\n at_times t ?stop (fun () -> Time_ns.after (now t) (compute_span ()))\n;;\n\nlet at_intervals ?start ?stop t interval =\n let start =\n match start with\n | Some x -> x\n | None -> now t\n in\n at_times t ?stop (fun () ->\n Time_ns.next_multiple ~base:start ~after:(now t) ~interval ())\n;;\n\nmodule Continue = struct\n type t =\n | Immediately\n | After of Time_ns.Span.t\n | Next_multiple of Time_ns.t * Time_ns.Span.t\n\n let immediately = Immediately\n\n let at t time_source =\n match t with\n | Immediately -> Timing_wheel.now time_source.events\n | After span -> span_to_time time_source span\n | Next_multiple (base, interval) ->\n Time_ns.next_multiple ~base ~after:(now time_source) ~interval ()\n ;;\nend\n\nlet run_repeatedly\n ?(start = return ())\n ?stop\n ?(continue_on_error = true)\n ?(finished = Ivar.create ())\n t\n ~f\n ~continue\n =\n start\n >>> fun () ->\n let alarm = ref (Alarm.null ()) in\n let stop =\n match stop with\n | None -> Deferred.never ()\n | Some stop ->\n upon stop (fun () ->\n if Timing_wheel.mem t.events !alarm\n then (\n remove_alarm t !alarm;\n Ivar.fill_if_empty finished ()));\n stop\n in\n (* [run_f], [continue_f], and [continue_try_with] are defined so that we allocate their\n closures once, not once per iteration. *)\n let rec run_f () =\n (* Before calling [f], we synchronously check whether [stop] is determined. *)\n if Deferred.is_determined stop\n then Ivar.fill_if_empty finished ()\n else if continue_on_error\n then Monitor.try_with f ~run:`Now ~rest:`Raise >>> continue_try_with\n else (\n let d = f () in\n if Deferred.is_determined d then continue_f () else d >>> continue_f)\n and continue_f () =\n if Deferred.is_determined stop\n then Ivar.fill_if_empty finished ()\n else alarm := run_at_internal t (Continue.at continue t) run_f ()\n and continue_try_with or_error =\n (match or_error with\n | Ok () -> ()\n | Error error -> Monitor.send_exn (Monitor.current ()) error);\n continue_f ()\n in\n run_f ()\n;;\n\nlet every' ?start ?stop ?continue_on_error ?finished t span f =\n if Time_ns.Span.( <= ) span Time_ns.Span.zero\n then\n raise_s [%message \"Time_source.every got nonpositive span\" (span : Time_ns.Span.t)];\n run_repeatedly t ?start ?stop ?continue_on_error ?finished ~f ~continue:(After span)\n;;\n\nlet every ?start ?stop ?continue_on_error t span f =\n every' t ?start ?stop ?continue_on_error ?finished:None span (fun () ->\n f ();\n return ())\n;;\n\nlet run_at_intervals' ?start ?stop ?continue_on_error t interval f =\n let now = now t in\n let base, start =\n match start with\n | None -> now, None\n | Some start ->\n ( start\n , Some\n (at\n t\n (Time_ns.next_multiple\n ()\n ~base:start\n ~after:now\n ~can_equal_after:true\n ~interval)) )\n in\n run_repeatedly\n t\n ?start\n ?stop\n ?continue_on_error\n ~f\n ~continue:(Next_multiple (base, interval))\n;;\n\nlet run_at_intervals ?start ?stop ?continue_on_error t interval f =\n run_at_intervals' ?start ?stop ?continue_on_error t interval (fun () ->\n f ();\n return ())\n;;\n\nlet with_timeout t span d =\n let timeout = Event.after t span in\n choose\n (* The code below does exhaustive case analysis in both [choice]s. Because [timeout]\n does not escape the scope of this function, certain cases should be impossible, and\n are marked as such with exceptions. We do not expect those exceptions to occur,\n but if they do, it likely indicates a bug in [choose] rather than\n [with_timeout]. *)\n [ choice d (fun v ->\n (match Event.abort timeout () with\n (* [Previously_happened] can occur if both [d] and [wait] become determined at\n the same time, e.g. [with_timeout (sec 0.) (return ())]. *)\n | Ok | Previously_happened () -> ()\n | Previously_aborted () ->\n raise_s [%message \"Time_source.with_timeout bug: should only abort once\"]);\n `Result v)\n ; choice (Event.fired timeout) (function\n | Happened () -> `Timeout\n | Aborted () ->\n raise_s\n [%message \"Time_source.with_timeout bug: both completed and timed out\"])\n ]\n;;\n\nlet of_synchronous t = t\nlet to_synchronous t = t\n","open! Base\n\ntype _ t =\n | Stack : 'a Stack.t -> 'a t\n | Counter : { mutable length : int } -> unit t\n[@@deriving sexp_of]\n\nlet of_list list = Stack (Stack.of_list list)\n\nlet create_counter ~length =\n if length < 0\n then\n raise_s\n [%message \"[Stack_or_counter.create_counter] got negative length\" (length : int)];\n Counter { length }\n;;\n\nlet length (type a) (t : a t) =\n match t with\n | Stack s -> Stack.length s\n | Counter r -> r.length\n;;\n\nlet clear (type a) (t : a t) =\n match t with\n | Stack s -> Stack.clear s\n | Counter r -> r.length <- 0\n;;\n\nlet push (type a) (t : a t) a =\n match t with\n | Stack s -> Stack.push s a\n | Counter r -> r.length <- r.length + 1\n;;\n\nlet pop_exn (type a) (t : a t) =\n match t with\n | Stack s -> Stack.pop_exn s\n | Counter r ->\n if r.length = 0 then raise_s [%message \"[Stack_or_counter.pop_exn] of empty stack\"];\n r.length <- r.length - 1\n;;\n\nlet iter (type a) (t : a t) ~(f : a -> unit) =\n match t with\n | Stack s -> Stack.iter s ~f\n | Counter r ->\n for _ = 1 to r.length do\n f ()\n done\n;;\n","open! Core_kernel\nopen! Import\nopen! Deferred_std\nmodule Deferred = Deferred1\n\ntype 'a outcome =\n [ `Ok of 'a\n | `Aborted\n | `Raised of exn\n ]\n[@@deriving sexp_of]\n\nmodule Internal_job : sig\n type 'a t [@@deriving sexp_of]\n\n val create : ('a -> 'b Deferred.t) -> 'a t * 'b outcome Deferred.t\n\n (* Every internal job will eventually be either [run] or [abort]ed, but not both. *)\n\n val run : 'a t -> 'a -> [ `Ok | `Raised ] Deferred.t\n val abort : _ t -> unit\nend = struct\n type 'a t =\n { start : [ `Abort | `Start of 'a ] Ivar.t\n ; outcome : [ `Ok | `Aborted | `Raised ] Deferred.t\n }\n [@@deriving sexp_of]\n\n let create work =\n let start = Ivar.create () in\n let result =\n match%bind Ivar.read start with\n | `Abort -> return `Aborted\n | `Start a ->\n (match%map Monitor.try_with (fun () -> work a) with\n | Ok a -> `Ok a\n | Error exn -> `Raised exn)\n in\n let outcome =\n match%map result with\n | `Ok _ -> `Ok\n | `Aborted -> `Aborted\n | `Raised _ -> `Raised\n in\n let t = { start; outcome } in\n t, result\n ;;\n\n let run t a =\n Ivar.fill t.start (`Start a);\n match%map t.outcome with\n | `Aborted -> assert false\n | (`Ok | `Raised) as x -> x\n ;;\n\n let abort t = Ivar.fill t.start `Abort\nend\n\ntype 'a t =\n { continue_on_error : bool\n ; max_concurrent_jobs : int\n ; (* [job_resources_not_in_use] holds resources that are not currently in use by a\n running job. *)\n job_resources_not_in_use : 'a Stack_or_counter.t\n ;\n (* [jobs_waiting_to_start] is the queue of jobs that haven't yet started. *)\n jobs_waiting_to_start : 'a Internal_job.t Queue.t\n ; (* [0 <= num_jobs_running <= max_concurrent_jobs]. *)\n mutable num_jobs_running : int\n ; (* [capacity_available] is [Some ivar] if user code has called [capacity_available t]\n and is waiting to be notified when capacity is available in the throttle.\n [maybe_start_job] will fill [ivar] when capacity becomes available, i.e. when\n [jobs_waiting_to_start] is empty and [num_jobs_running < max_concurrent_jobs]. *)\n mutable capacity_available : unit Ivar.t option\n ; (* [is_dead] is true if [t] was killed due to a job raising an exception or [kill t]\n being called. *)\n mutable is_dead : bool\n ; (* [cleans] holds functions that will be called to clean each resource when [t] is\n killed. *)\n mutable cleans : ('a -> unit Deferred.t) list\n ; (* [num_resources_not_cleaned] is the number of resources whose clean functions have\n not yet completed. While [t] is alive, [num_resources_not_cleaned =\n max_concurrent_jobs]. Once [t] is killed, [num_resources_not_cleaned] decreases to\n zero over time as the clean functions complete. *)\n mutable num_resources_not_cleaned : int\n ; (* [cleaned] becomes determined when [num_resources_not_cleaned] reaches zero,\n i.e. after [t] is killed and all its clean functions complete. *)\n cleaned : unit Ivar.t\n }\n[@@deriving fields, sexp_of]\n\nlet invariant invariant_a t : unit =\n try\n let check f field = f (Field.get field t) in\n Fields.iter\n ~continue_on_error:ignore\n ~max_concurrent_jobs:\n (check (fun max_concurrent_jobs -> assert (max_concurrent_jobs > 0)))\n ~job_resources_not_in_use:\n (check (fun job_resources_not_in_use ->\n Stack_or_counter.iter job_resources_not_in_use ~f:invariant_a;\n assert (\n Stack_or_counter.length job_resources_not_in_use\n = if t.is_dead then 0 else t.max_concurrent_jobs - t.num_jobs_running)))\n ~jobs_waiting_to_start:\n (check (function jobs_waiting_to_start ->\n if t.is_dead then assert (Queue.is_empty jobs_waiting_to_start)))\n ~num_jobs_running:\n (check (fun num_jobs_running ->\n assert (num_jobs_running >= 0);\n assert (num_jobs_running <= t.max_concurrent_jobs);\n if num_jobs_running < t.max_concurrent_jobs\n then assert (Queue.is_empty t.jobs_waiting_to_start)))\n ~capacity_available:\n (check (function\n | None -> ()\n | Some ivar -> assert (Ivar.is_empty ivar)))\n ~is_dead:ignore\n ~cleans:ignore\n ~num_resources_not_cleaned:\n (check (fun num_resources_not_cleaned ->\n assert (num_resources_not_cleaned >= 0);\n assert (num_resources_not_cleaned <= t.max_concurrent_jobs);\n if num_resources_not_cleaned < t.max_concurrent_jobs then assert t.is_dead))\n ~cleaned:\n (check (fun cleaned ->\n if Ivar.is_full cleaned then assert (t.num_resources_not_cleaned = 0)))\n with\n | exn -> raise_s [%message \"Throttle.invariant failed\" (exn : exn) (t : _ t)]\n;;\n\nmodule T2 = struct\n type nonrec ('a, 'kind) t = 'a t [@@deriving sexp_of]\n\n let invariant invariant_a _ t = invariant invariant_a t\nend\n\nlet num_jobs_waiting_to_start t = Queue.length t.jobs_waiting_to_start\n\nlet clean_resource t a =\n Deferred.all_unit (List.map t.cleans ~f:(fun f -> f a))\n >>> fun () ->\n t.num_resources_not_cleaned <- t.num_resources_not_cleaned - 1;\n if t.num_resources_not_cleaned = 0 then Ivar.fill t.cleaned ()\n;;\n\nlet kill t =\n if not t.is_dead\n then (\n t.is_dead <- true;\n Queue.iter t.jobs_waiting_to_start ~f:Internal_job.abort;\n Queue.clear t.jobs_waiting_to_start;\n Stack_or_counter.iter t.job_resources_not_in_use ~f:(fun a -> clean_resource t a);\n Stack_or_counter.clear t.job_resources_not_in_use)\n;;\n\nlet at_kill t f =\n (* We preserve the execution context so that exceptions raised by [f] go to the monitor\n in effect when [at_kill] was called. *)\n let f = unstage (Monitor.Exported_for_scheduler.preserve_execution_context' f) in\n t.cleans <- f :: t.cleans\n;;\n\nlet cleaned t = Ivar.read t.cleaned\n\nlet rec start_job t =\n assert (not t.is_dead);\n assert (t.num_jobs_running < t.max_concurrent_jobs);\n assert (not (Queue.is_empty t.jobs_waiting_to_start));\n let job = Queue.dequeue_exn t.jobs_waiting_to_start in\n t.num_jobs_running <- t.num_jobs_running + 1;\n let job_resource = Stack_or_counter.pop_exn t.job_resources_not_in_use in\n Internal_job.run job job_resource\n >>> fun res ->\n t.num_jobs_running <- t.num_jobs_running - 1;\n (match res with\n | `Ok -> ()\n | `Raised -> if not t.continue_on_error then kill t);\n if t.is_dead\n then clean_resource t job_resource\n else (\n Stack_or_counter.push t.job_resources_not_in_use job_resource;\n if not (Queue.is_empty t.jobs_waiting_to_start)\n then start_job t\n else (\n match t.capacity_available with\n | None -> ()\n | Some ivar ->\n Ivar.fill ivar ();\n t.capacity_available <- None))\n;;\n\nlet create_internal ~continue_on_error job_resources =\n let max_concurrent_jobs = Stack_or_counter.length job_resources in\n { continue_on_error\n ; max_concurrent_jobs\n ; job_resources_not_in_use = job_resources\n ; jobs_waiting_to_start = Queue.create ()\n ; num_jobs_running = 0\n ; capacity_available = None\n ; is_dead = false\n ; cleans = []\n ; num_resources_not_cleaned = max_concurrent_jobs\n ; cleaned = Ivar.create ()\n }\n;;\n\nlet create_with ~continue_on_error job_resources =\n create_internal ~continue_on_error (Stack_or_counter.of_list job_resources)\n;;\n\nmodule Sequencer = struct\n type nonrec 'a t = 'a t [@@deriving sexp_of]\n\n let create ?(continue_on_error = false) a = create_with ~continue_on_error [ a ]\nend\n\nlet create ~continue_on_error ~max_concurrent_jobs =\n if max_concurrent_jobs <= 0\n then\n raise_s\n [%message\n \"Throttle.create requires positive max_concurrent_jobs, but got\"\n (max_concurrent_jobs : int)];\n create_internal\n ~continue_on_error\n (Stack_or_counter.create_counter ~length:max_concurrent_jobs)\n;;\n\nmodule Job = struct\n type ('a, 'b) t =\n { internal_job : 'a Internal_job.t\n ; result : [ `Ok of 'b | `Aborted | `Raised of exn ] Deferred.t\n }\n\n let result t = t.result\n let abort t = Internal_job.abort t.internal_job\n\n let create f =\n let internal_job, result = Internal_job.create f in\n { internal_job; result }\n ;;\nend\n\nlet enqueue' t f =\n let job = Job.create f in\n if t.is_dead\n then Job.abort job\n else (\n Queue.enqueue t.jobs_waiting_to_start job.internal_job;\n if t.num_jobs_running < t.max_concurrent_jobs then start_job t);\n Job.result job\n;;\n\nlet handle_enqueue_result result =\n match result with\n | `Ok a -> a\n | `Aborted -> raise_s [%message \"throttle aborted job\"]\n | `Raised exn -> raise exn\n;;\n\nlet enqueue t f = enqueue' t f >>| handle_enqueue_result\n\nlet enqueue_exclusive t f =\n let n = t.max_concurrent_jobs in\n if Int.( >= ) n 1_000_000\n then\n raise_s\n [%sexp\n \"[enqueue_exclusive] was called with a very large value of \\\n [max_concurrent_jobs]. This doesn't work.\"];\n let done_ = Ivar.create () in\n assert (n > 0);\n let f_placeholder _slot = Ivar.read done_ in\n for _ = 1 to n - 1 do\n don't_wait_for (enqueue t f_placeholder)\n done;\n let%map result = enqueue' t (fun _slot -> f ()) in\n Ivar.fill done_ ();\n handle_enqueue_result result\n;;\n\nlet monad_sequence_how ?(how = `Sequential) ~f =\n stage\n (match how with\n | `Parallel -> f\n | (`Sequential | `Max_concurrent_jobs _) as how ->\n let max_concurrent_jobs =\n match how with\n | `Sequential -> 1\n | `Max_concurrent_jobs max_concurrent_jobs -> max_concurrent_jobs\n in\n let t = create ~continue_on_error:false ~max_concurrent_jobs in\n fun a -> enqueue t (fun () -> f a))\n;;\n\nlet monad_sequence_how2 ?(how = `Sequential) ~f =\n stage\n (match how with\n | `Parallel -> f\n | (`Sequential | `Max_concurrent_jobs _) as how ->\n let max_concurrent_jobs =\n match how with\n | `Sequential -> 1\n | `Max_concurrent_jobs max_concurrent_jobs -> max_concurrent_jobs\n in\n let t = create ~continue_on_error:false ~max_concurrent_jobs in\n fun a1 a2 -> enqueue t (fun () -> f a1 a2))\n;;\n\nlet prior_jobs_done t =\n (* We queue [t.max_concurrent_jobs] dummy jobs and when they are all started we know\n that all prior jobs finished. We make sure that all dummy jobs wait for the last one\n to get started before finishing. *)\n Deferred.create (fun all_dummy_jobs_running ->\n let dummy_jobs_running = ref 0 in\n for _ = 1 to t.max_concurrent_jobs do\n don't_wait_for\n (enqueue t (fun _ ->\n incr dummy_jobs_running;\n if !dummy_jobs_running = t.max_concurrent_jobs\n then Ivar.fill all_dummy_jobs_running ();\n Ivar.read all_dummy_jobs_running))\n done)\n;;\n\nlet capacity_available t =\n if num_jobs_running t < max_concurrent_jobs t\n then return ()\n else (\n match t.capacity_available with\n | Some ivar -> Ivar.read ivar\n | None -> Deferred.create (fun ivar -> t.capacity_available <- Some ivar))\n;;\n","open! Core_kernel\nopen! Import\ninclude Scheduler\n\nlet enqueue_job execution_context f a = enqueue (t ()) execution_context f a\n\nlet thread_safe_enqueue_job execution_context f a =\n thread_safe_enqueue_external_job (t ()) execution_context f a\n;;\n\nlet current_execution_context () = current_execution_context (t ())\nlet cycle_count () = cycle_count (t ())\nlet cycle_start_ns () = cycle_start (t ())\nlet cycle_start () = Time_ns.to_time_float_round_nearest (cycle_start_ns ())\nlet cycle_times_ns () = map_cycle_times (t ()) ~f:Fn.id\nlet cycle_times () = map_cycle_times (t ()) ~f:Time_ns.Span.to_span_float_round_nearest\nlet total_cycle_time () = total_cycle_time (t ())\nlet long_cycles ~at_least = long_cycles (t ()) ~at_least\nlet long_cycles_with_context ~at_least = long_cycles_with_context (t ()) ~at_least\nlet long_jobs_with_context = long_jobs_with_context (t ())\nlet last_cycle_time () = last_cycle_time (t ())\nlet event_precision_ns () = event_precision (t ())\nlet event_precision () = Time_ns.Span.to_span_float_round_nearest (event_precision_ns ())\n\nlet set_max_num_jobs_per_priority_per_cycle i =\n set_max_num_jobs_per_priority_per_cycle (t ()) i\n;;\n\nlet max_num_jobs_per_priority_per_cycle () = max_num_jobs_per_priority_per_cycle (t ())\nlet set_record_backtraces bool = set_record_backtraces (t ()) bool\nlet force_current_cycle_to_end () = force_current_cycle_to_end (t ())\nlet yield () = yield (t ())\nlet yield_until_no_jobs_remain ?may_return_immediately () =\n yield_until_no_jobs_remain ?may_return_immediately (t ())\n;;\n\nlet yield_every ~n =\n let yield_every = Staged.unstage (yield_every ~n) in\n let t = t () in\n stage (fun () -> yield_every t)\n;;\n\nlet num_jobs_run () = num_jobs_run (t ())\nlet num_pending_jobs () = num_pending_jobs (t ())\n\nmodule Expert = struct\n let run_cycles_until_no_jobs_remain = run_cycles_until_no_jobs_remain\n let set_on_start_of_cycle f = set_on_start_of_cycle (t ()) f\n let set_on_end_of_cycle f = set_on_end_of_cycle (t ()) f\n let last_cycle_num_jobs () = last_cycle_num_jobs (t ())\n let run_every_cycle_start f = run_every_cycle_start (t ()) ~f\n let run_every_cycle_end f = run_every_cycle_end (t ()) ~f\nend\n\nmodule Private = Scheduler\n","open! Core_kernel\nopen! Import\n\nmodule type Clock = Clock_intf.Clock\nmodule type Clock_deprecated = Clock_intf.Clock_deprecated\n\nmodule Scheduler = Scheduler1\n\nlet time_source () = (Scheduler.t ()).time_source |> Time_source.of_synchronous\nlet after span = Time_source.after (time_source ()) span\nlet at time = Time_source.at (time_source ()) time\n\nlet at_varying_intervals ?stop compute_span =\n Time_source.at_varying_intervals ?stop (time_source ()) compute_span\n;;\n\nlet at_intervals ?start ?stop interval =\n Time_source.at_intervals ?start ?stop (time_source ()) interval\n;;\n\nlet every' ?start ?stop ?continue_on_error ?finished span f =\n Time_source.every' ?start ?stop ?continue_on_error ?finished (time_source ()) span f\n;;\n\nlet every ?start ?stop ?continue_on_error span f =\n Time_source.every ?start ?stop ?continue_on_error (time_source ()) span f\n;;\n\nlet run_after span f a = Time_source.run_after (time_source ()) span f a\nlet run_at time f a = Time_source.run_at (time_source ()) time f a\n\nlet run_at_intervals ?start ?stop ?continue_on_error interval f =\n Time_source.run_at_intervals\n ?start\n ?stop\n ?continue_on_error\n (time_source ())\n interval\n f\n;;\n\nlet run_at_intervals' ?start ?stop ?continue_on_error interval f =\n Time_source.run_at_intervals'\n ?start\n ?stop\n ?continue_on_error\n (time_source ())\n interval\n f\n;;\n\nlet with_timeout span d = Time_source.with_timeout (time_source ()) span d\n\nmodule Event = struct\n include Time_source.Event\n\n let after span = after (time_source ()) span\n let run_after span f a = run_after (time_source ()) span f a\n let at time = at (time_source ()) time\n let run_at time f z = run_at (time_source ()) time f z\nend\n","open Core_kernel\nopen Deferred_std\nmodule Deferred = Deferred1\n\nlet foldi t ~init ~f =\n Deferred.create (fun result ->\n let rec loop t i b =\n match t with\n | [] -> Ivar.fill result b\n | x :: xs -> f i b x >>> fun b -> loop xs (i + 1) b\n in\n loop t 0 init)\n;;\n\nlet fold t ~init ~f = foldi t ~init ~f:(fun _ a x -> f a x)\n\nlet seqmapi t ~f =\n foldi t ~init:[] ~f:(fun i bs a ->\n let%map b = f i a in\n b :: bs)\n >>| List.rev\n;;\n\nlet all ds = seqmapi ds ~f:(fun _ x -> x)\nlet all_unit ds = Deferred.ignore_m (fold ds ~init:() ~f:(fun () d -> d))\n\nlet iteri ?(how = `Sequential) t ~f =\n match how with\n | (`Parallel | `Max_concurrent_jobs _) as how ->\n all_unit (List.mapi t ~f:(unstage (Throttle.monad_sequence_how2 ~how ~f)))\n | `Sequential -> foldi t ~init:() ~f:(fun i () x -> f i x)\n;;\n\nlet mapi ?(how = `Sequential) t ~f =\n match how with\n | (`Parallel | `Max_concurrent_jobs _) as how ->\n all (List.mapi t ~f:(unstage (Throttle.monad_sequence_how2 ~how ~f)))\n | `Sequential -> seqmapi t ~f\n;;\n\nlet filteri ?how t ~f =\n let%map bools = mapi t ?how ~f in\n List.rev (List.fold2_exn t bools ~init:[] ~f:(fun ac x b -> if b then x :: ac else ac))\n;;\n\nlet filter_mapi ?how t ~f = mapi t ?how ~f >>| List.filter_opt\nlet concat_mapi ?how t ~f = mapi t ?how ~f >>| List.concat\n\nlet find_mapi t ~f =\n let rec find_mapi t ~f i =\n match t with\n | [] -> return None\n | hd :: tl ->\n (match%bind f i hd with\n | None -> find_mapi tl ~f (i + 1)\n | Some _ as some -> return some)\n in\n find_mapi t ~f 0\n;;\n\nlet findi t ~f =\n find_mapi t ~f:(fun i elt ->\n let%map b = f i elt in\n if b then Some (i, elt) else None)\n;;\n\nlet find t ~f =\n find_mapi t ~f:(fun _ elt ->\n let%map b = f elt in\n if b then Some elt else None)\n;;\n\nlet existsi t ~f =\n match%map\n find_mapi t ~f:(fun i elt ->\n let%map b = f i elt in\n if b then Some () else None)\n with\n | Some () -> true\n | None -> false\n;;\n\nlet for_alli t ~f =\n match%map\n find_mapi t ~f:(fun i elt ->\n let%map b = f i elt in\n if not b then Some () else None)\n with\n | Some () -> false\n | None -> true\n;;\n\nlet iter ?how t ~f = iteri ?how t ~f:(fun _ a -> f a)\nlet map ?how t ~f = mapi ?how t ~f:(fun _ a -> f a)\nlet filter ?how t ~f = filteri ?how t ~f:(fun _ a -> f a)\nlet filter_map ?how t ~f = filter_mapi ?how t ~f:(fun _ a -> f a)\nlet concat_map ?how t ~f = concat_mapi ?how t ~f:(fun _ a -> f a)\nlet find_map t ~f = find_mapi t ~f:(fun _ a -> f a)\nlet exists t ~f = existsi t ~f:(fun _ a -> f a)\nlet for_all t ~f = for_alli t ~f:(fun _ a -> f a)\nlet init ?how n ~f = map ?how (List.init n ~f:Fn.id) ~f\n","open Core_kernel\nopen Deferred_std\nmodule Deferred = Deferred1\n\nmodule T = struct\n type ('a, 'error) t = ('a, 'error) Result.t Deferred.t\nend\n\ninclude T\n\nlet combine t1 t2 ~ok ~err =\n let%map t1 = t1\n and t2 = t2 in\n Result.combine t1 t2 ~ok ~err\n;;\n\ninclude Monad.Make2 (struct\n include T\n\n let return a = Deferred.return (Ok a)\n\n let bind t ~f =\n Deferred.bind t ~f:(function\n | Ok a -> f a\n | Error _ as error -> Deferred.return error)\n ;;\n\n let map t ~f = Deferred.map t ~f:(fun r -> Result.map r ~f)\n let map = `Custom map\n end)\n\nlet fail x = Deferred.return (Error x)\nlet failf format = Printf.ksprintf fail format\nlet map_error t ~f = Deferred.map t ~f:(fun r -> Result.map_error r ~f)\n","open! Core_kernel\nopen! Import\nmodule Deferred = Deferred1\n\nmodule Monitor = struct\n let try_with = Monitor.try_with\nend\n\n(* Copied to [eager_deferred_or_error.ml]. There should be no diffs below this line. *)\n\ninclude (Deferred_result : Monad.S2 with type ('a, 'b) t := ('a, 'b) Deferred_result.t)\n\ntype 'a t = 'a Or_error.t Deferred.t\n\ninclude Applicative.Make (struct\n type nonrec 'a t = 'a t\n\n let return = return\n\n let apply f x =\n Deferred_result.combine\n f\n x\n ~ok:(fun f x -> f x)\n ~err:(fun e1 e2 -> Error.of_list [ e1; e2 ])\n ;;\n\n let map = `Custom map\n end)\n\nmodule Let_syntax = struct\n let return = return\n\n include Monad_infix\n\n module Let_syntax = struct\n let return = return\n let map = map\n let bind = bind\n let both = both\n\n (* from Applicative.Make *)\n module Open_on_rhs = struct end\n end\nend\n\nopen Let_syntax\n\nlet fail error = Deferred.return (Result.fail error)\nlet ok_exn t = Deferred.map t ~f:Or_error.ok_exn\nlet of_exn exn = Deferred.return (Or_error.of_exn exn)\nlet of_exn_result t = Deferred.map t ~f:Or_error.of_exn_result\nlet error msg v sexp_of = Deferred.return (Or_error.error msg v sexp_of)\nlet error_s sexp = Deferred.return (Or_error.error_s sexp)\nlet error_string msg = Deferred.return (Or_error.error_string msg)\nlet errorf format = ksprintf error_string format\nlet tag t ~tag = Deferred.map t ~f:(Or_error.tag ~tag)\nlet tag_s t ~tag = Deferred.map t ~f:(Or_error.tag_s ~tag)\n\nlet tag_arg t message a sexp_of_a =\n Deferred.map t ~f:(fun t -> Or_error.tag_arg t message a sexp_of_a)\n;;\n\nlet unimplemented msg = Deferred.return (Or_error.unimplemented msg)\nlet combine_errors l = Deferred.map (Deferred.all l) ~f:Or_error.combine_errors\nlet combine_errors_unit l = Deferred.map (Deferred.all l) ~f:Or_error.combine_errors_unit\n\nlet filter_ok_at_least_one l =\n Deferred.map (Deferred.all l) ~f:Or_error.filter_ok_at_least_one\n;;\n\nlet find_map_ok l ~f =\n Deferred.repeat_until_finished (l, []) (fun (l, errors) ->\n match l with\n | [] ->\n let errors = Error.of_list (List.rev errors) in\n Deferred.return (`Finished (Error errors))\n | hd :: tl ->\n Deferred.map (f hd) ~f:(function\n | Error current_error -> `Repeat (tl, current_error :: errors)\n | Ok result -> `Finished (Ok result)))\n;;\n\nlet ok_unit = return ()\n\nlet try_with ?extract_exn ?run ?here ?name f =\n Deferred.map (Monitor.try_with ?extract_exn ?run ?here ?name f) ~f:(function\n | Error exn -> Error (Error.of_exn exn)\n | Ok _ as ok -> ok)\n;;\n\nlet try_with_join ?extract_exn ?run ?here ?name f =\n Deferred.map (try_with ?extract_exn ?run ?here ?name f) ~f:Or_error.join\n;;\n\nmodule List = struct\n let foldi list ~init:acc ~f =\n let rec loop i acc = function\n | [] -> return acc\n | hd :: tl ->\n let%bind acc = f i acc hd in\n loop (i + 1) acc tl\n in\n loop 0 acc list\n ;;\n\n let fold t ~init ~f = foldi t ~init ~f:(fun _ a x -> f a x)\n\n let seqmapi t ~f =\n foldi t ~init:[] ~f:(fun i bs a ->\n let%map b = f i a in\n b :: bs)\n >>| List.rev\n ;;\n\n let all = all\n let all_unit = all_unit\n\n let iteri ?(how = `Sequential) t ~f =\n match how with\n | (`Parallel | `Max_concurrent_jobs _) as how ->\n all_unit (List.mapi t ~f:(unstage (Throttle.monad_sequence_how2 ~how ~f)))\n | `Sequential -> foldi t ~init:() ~f:(fun i () x -> f i x)\n ;;\n\n let mapi ?(how = `Sequential) t ~f =\n match how with\n | (`Parallel | `Max_concurrent_jobs _) as how ->\n all (List.mapi t ~f:(unstage (Throttle.monad_sequence_how2 ~how ~f)))\n | `Sequential -> seqmapi t ~f\n ;;\n\n let filter_mapi ?how t ~f = mapi t ?how ~f >>| List.filter_opt\n let concat_mapi ?how t ~f = mapi t ?how ~f >>| List.concat\n\n let filteri ?how t ~f =\n filter_mapi ?how t ~f:(fun i x ->\n let%map b = f i x in\n if b then Some x else None)\n ;;\n\n let find_mapi t ~f =\n let rec find_mapi t ~f i =\n match t with\n | [] -> return None\n | hd :: tl ->\n (match%bind f i hd with\n | None -> find_mapi tl ~f (i + 1)\n | Some _ as some -> return some)\n in\n find_mapi t ~f 0\n ;;\n\n let find_map t ~f = find_mapi t ~f:(fun _ a -> f a)\n\n let findi t ~f =\n find_mapi t ~f:(fun i elt ->\n let%map b = f i elt in\n if b then Some (i, elt) else None)\n ;;\n\n let find t ~f =\n find_map t ~f:(fun elt ->\n let%map b = f elt in\n if b then Some elt else None)\n ;;\n\n let existsi t ~f =\n match%map\n find_mapi t ~f:(fun i elt ->\n let%map b = f i elt in\n if b then Some () else None)\n with\n | Some () -> true\n | None -> false\n ;;\n\n let for_alli t ~f =\n match%map\n find_mapi t ~f:(fun i elt ->\n let%map b = f i elt in\n if not b then Some () else None)\n with\n | Some () -> false\n | None -> true\n ;;\n\n let iter ?how t ~f = iteri ?how t ~f:(fun _ a -> f a)\n let map ?how t ~f = mapi ?how t ~f:(fun _ a -> f a)\n let filter ?how t ~f = filteri ?how t ~f:(fun _ a -> f a)\n let filter_map ?how t ~f = filter_mapi ?how t ~f:(fun _ a -> f a)\n let concat_map ?how t ~f = concat_mapi ?how t ~f:(fun _ a -> f a)\n let find_map t ~f = find_mapi t ~f:(fun _ a -> f a)\n let exists t ~f = existsi t ~f:(fun _ a -> f a)\n let for_all t ~f = for_alli t ~f:(fun _ a -> f a)\n let init ?how n ~f = map ?how (List.init n ~f:Fn.id) ~f\nend\n\nlet rec repeat_until_finished state f =\n match%bind f state with\n | `Repeat state -> repeat_until_finished state f\n | `Finished state -> return state\n;;\n","open Core_kernel\nopen Deferred_std\nmodule List = Deferred_list\n\n(* We implement all of the [Queue] operations by converting the queue to a list and then\n using the corresponding [List] operation. We use lists rather than arrays because\n arrays longer than a certain length are allocated in the major heap, which can cause\n unnecessary promotion of the elements in the queue. Also, when one is folding or\n iterating over an array, the entire array must be kept alive. When folding or\n iterating over a list, only the remaining tail of the list is kept alive. So, using\n arrays rather than lists would increase the live-space needed by the program. *)\n\nlet foldi t ~init ~f = List.foldi (Queue.to_list t) ~init ~f\nlet fold t ~init ~f = List.fold (Queue.to_list t) ~init ~f\nlet all t = List.all (Queue.to_list t) >>| Queue.of_list\nlet all_unit t = List.all_unit (Queue.to_list t)\nlet iter ?how t ~f = List.iter ?how (Queue.to_list t) ~f\nlet iteri ?how t ~f = List.iteri ?how (Queue.to_list t) ~f\nlet map ?how t ~f = List.map ?how (Queue.to_list t) ~f >>| Queue.of_list\nlet mapi ?how t ~f = List.mapi ?how (Queue.to_list t) ~f >>| Queue.of_list\nlet init ?how n ~f = List.init ?how n ~f >>| Queue.of_list\nlet filter ?how t ~f = List.filter ?how (Queue.to_list t) ~f >>| Queue.of_list\nlet filteri ?how t ~f = List.filteri ?how (Queue.to_list t) ~f >>| Queue.of_list\nlet filter_map ?how t ~f = List.filter_map ?how (Queue.to_list t) ~f >>| Queue.of_list\nlet filter_mapi ?how t ~f = List.filter_mapi ?how (Queue.to_list t) ~f >>| Queue.of_list\n\nlet concat_map ?how t ~f =\n List.concat_map ?how (Queue.to_list t) ~f:(fun x -> f x >>| Queue.to_list)\n >>| Queue.of_list\n;;\n\nlet concat_mapi ?how t ~f =\n List.concat_mapi ?how (Queue.to_list t) ~f:(fun i x -> f i x >>| Queue.to_list)\n >>| Queue.of_list\n;;\n\nlet find_map t ~f = List.find_map (Queue.to_list t) ~f\nlet find_mapi t ~f = List.find_mapi (Queue.to_list t) ~f\nlet find t ~f = List.find (Queue.to_list t) ~f\nlet findi t ~f = List.findi (Queue.to_list t) ~f\nlet for_all t ~f = List.for_all (Queue.to_list t) ~f\nlet for_alli t ~f = List.for_alli (Queue.to_list t) ~f\nlet exists t ~f = List.exists (Queue.to_list t) ~f\nlet existsi t ~f = List.existsi (Queue.to_list t) ~f\n","include Deferred1\nmodule Array = Deferred_array\nmodule List = Deferred_list\nmodule Map = Deferred_map\nmodule Memo = Deferred_memo\nmodule Option = Deferred_option\nmodule Or_error = Deferred_or_error\nmodule Queue = Deferred_queue\nmodule Result = Deferred_result\nmodule Sequence = Deferred_sequence\n","open Core_kernel\ninclude Gc\n\n(** [add_finalizer f x] is like [Gc.finalise f x], except that the finalizer is guaranteed\n to run as an Async job (i.e. without interrupting other Async jobs). Unprotected use\n of [Caml.Gc.finalise] or [Core.Gc.add_finalizer] in Async programs is wrong, because\n the finalizers won't hold the async lock, and thus could interleave arbitrarily with\n async jobs. *)\nlet add_finalizer heap_block f = Scheduler.(add_finalizer (t ())) heap_block f\n\nlet add_finalizer_exn heap_block f = Scheduler.(add_finalizer_exn (t ())) heap_block f\nlet add_finalizer_last heap_block f = Scheduler.(add_finalizer_last (t ())) heap_block f\n\nlet add_finalizer_last_exn heap_block f =\n Scheduler.(add_finalizer_last_exn (t ())) heap_block f\n;;\n\nmodule Alarm = struct\n module Alarm = Gc.Expert.Alarm\n\n type t = Alarm.t [@@deriving sexp_of]\n\n let create f = Scheduler.(create_alarm (t ())) f\n let delete = Alarm.delete\nend\n","# 1 \"src/digestif_bi.ml\"\nopen Bigarray_compat\n\ntype t = (char, int8_unsigned_elt, c_layout) Array1.t\n\nlet create n = Array1.create Char c_layout n\n\nlet length = Array1.dim\n\nlet sub = Array1.sub\n\nlet empty = Array1.create Char c_layout 0\n\nlet get = Array1.get\n\nlet copy t =\n let r = create (length t) in\n Array1.blit t r ;\n r\n\nlet init l f =\n let v = Array1.create Char c_layout l in\n for i = 0 to l - 1 do\n Array1.set v i (f i)\n done ;\n v\n\nexternal unsafe_get_32 : t -> int -> int32 = \"%caml_bigstring_get32u\"\n\nexternal unsafe_get_64 : t -> int -> int64 = \"%caml_bigstring_get64u\"\n\nlet unsafe_get_nat : t -> int -> nativeint =\n fun s i ->\n if Sys.word_size = 32\n then Nativeint.of_int32 @@ unsafe_get_32 s i\n else Int64.to_nativeint @@ unsafe_get_64 s i\n\nexternal unsafe_set_32 : t -> int -> int32 -> unit = \"%caml_bigstring_set32u\"\n\nexternal unsafe_set_64 : t -> int -> int64 -> unit = \"%caml_bigstring_set64u\"\n\nlet unsafe_set_nat : t -> int -> nativeint -> unit =\n fun s i v ->\n if Sys.word_size = 32\n then unsafe_set_32 s i (Nativeint.to_int32 v)\n else unsafe_set_64 s i (Int64.of_nativeint v)\n\nlet to_string v = String.init (length v) (Array1.get v)\n\nlet blit_from_bytes src src_off dst dst_off len =\n for i = 0 to len - 1 do\n Array1.set dst (dst_off + i) (Bytes.get src (src_off + i))\n done\n\nexternal swap32 : int32 -> int32 = \"%bswap_int32\"\n\nexternal swap64 : int64 -> int64 = \"%bswap_int64\"\n\nexternal swapnat : nativeint -> nativeint = \"%bswap_native\"\n\nlet cpu_to_be32 s i v =\n if Sys.big_endian then unsafe_set_32 s i v else unsafe_set_32 s i (swap32 v)\n\nlet cpu_to_le32 s i v =\n if Sys.big_endian then unsafe_set_32 s i (swap32 v) else unsafe_set_32 s i v\n\nlet cpu_to_be64 s i v =\n if Sys.big_endian then unsafe_set_64 s i v else unsafe_set_64 s i (swap64 v)\n\nlet cpu_to_le64 s i v =\n if Sys.big_endian then unsafe_set_64 s i (swap64 v) else unsafe_set_64 s i v\n\nlet be32_to_cpu s i =\n if Sys.big_endian then unsafe_get_32 s i else swap32 @@ unsafe_get_32 s i\n\nlet le32_to_cpu s i =\n if Sys.big_endian then swap32 @@ unsafe_get_32 s i else unsafe_get_32 s i\n\nlet be64_to_cpu s i =\n if Sys.big_endian then unsafe_get_64 s i else swap64 @@ unsafe_get_64 s i\n\nlet le64_to_cpu s i =\n if Sys.big_endian then swap64 @@ unsafe_get_64 s i else unsafe_get_64 s i\n\nlet benat_to_cpu s i =\n if Sys.big_endian then unsafe_get_nat s i else swapnat @@ unsafe_get_nat s i\n\nlet cpu_to_benat s i v =\n if Sys.big_endian\n then unsafe_set_nat s i v\n else unsafe_set_nat s i (swapnat v)\n","# 1 \"src/digestif_by.ml\"\ninclude Bytes\n\nexternal unsafe_get_32 : t -> int -> int32 = \"%caml_string_get32u\"\n\nexternal unsafe_get_64 : t -> int -> int64 = \"%caml_string_get64u\"\n\nlet unsafe_get_nat : t -> int -> nativeint =\n fun s i ->\n if Sys.word_size = 32\n then Nativeint.of_int32 @@ unsafe_get_32 s i\n else Int64.to_nativeint @@ unsafe_get_64 s i\n\nexternal unsafe_set_32 : t -> int -> int32 -> unit = \"%caml_string_set32u\"\n\nexternal unsafe_set_64 : t -> int -> int64 -> unit = \"%caml_string_set64u\"\n\nlet unsafe_set_nat : t -> int -> nativeint -> unit =\n fun s i v ->\n if Sys.word_size = 32\n then unsafe_set_32 s i (Nativeint.to_int32 v)\n else unsafe_set_64 s i (Int64.of_nativeint v)\n\nlet blit_from_bigstring src src_off dst dst_off len =\n for i = 0 to len - 1 do\n set dst (dst_off + i) src.{src_off + i}\n done\n\nlet rpad a size x =\n let l = length a in\n let b = create size in\n blit a 0 b 0 l ;\n fill b l (size - l) x ;\n b\n\nexternal swap32 : int32 -> int32 = \"%bswap_int32\"\n\nexternal swap64 : int64 -> int64 = \"%bswap_int64\"\n\nexternal swapnat : nativeint -> nativeint = \"%bswap_native\"\n\nlet cpu_to_be32 s i v =\n if Sys.big_endian then unsafe_set_32 s i v else unsafe_set_32 s i (swap32 v)\n\nlet cpu_to_le32 s i v =\n if Sys.big_endian then unsafe_set_32 s i (swap32 v) else unsafe_set_32 s i v\n\nlet cpu_to_be64 s i v =\n if Sys.big_endian then unsafe_set_64 s i v else unsafe_set_64 s i (swap64 v)\n\nlet cpu_to_le64 s i v =\n if Sys.big_endian then unsafe_set_64 s i (swap64 v) else unsafe_set_64 s i v\n\nlet be32_to_cpu s i =\n if Sys.big_endian then unsafe_get_32 s i else swap32 @@ unsafe_get_32 s i\n\nlet le32_to_cpu s i =\n if Sys.big_endian then swap32 @@ unsafe_get_32 s i else unsafe_get_32 s i\n\nlet be64_to_cpu s i =\n if Sys.big_endian then unsafe_get_64 s i else swap64 @@ unsafe_get_64 s i\n\nlet le64_to_cpu s i =\n if Sys.big_endian then swap64 @@ unsafe_get_64 s i else unsafe_get_64 s i\n\nlet benat_to_cpu s i =\n if Sys.big_endian then unsafe_get_nat s i else swapnat @@ unsafe_get_nat s i\n\nlet cpu_to_benat s i v =\n if Sys.big_endian\n then unsafe_set_nat s i v\n else unsafe_set_nat s i (swapnat v)\n","module Nat = struct\n include Nativeint\n\n let ( lxor ) = Nativeint.logxor\nend\n\nmodule type BUFFER = sig\n type t\n\n val length : t -> int\n\n val sub : t -> int -> int -> t\n\n val copy : t -> t\n\n val benat_to_cpu : t -> int -> nativeint\n\n val cpu_to_benat : t -> int -> nativeint -> unit\nend\n\nlet imin (a : int) (b : int) = if a < b then a else b\n\nmodule Make (B : BUFFER) = struct\n let size_of_long = Sys.word_size / 8\n\n (* XXX(dinosaure): I'm not sure about this code. May be we don't need the\n first loop and the _optimization_ is irrelevant. *)\n let xor_into src src_off dst dst_off n =\n let n = ref n in\n let i = ref 0 in\n while !n >= size_of_long do\n B.cpu_to_benat dst (dst_off + !i)\n Nat.(\n B.benat_to_cpu dst (dst_off + !i)\n lxor B.benat_to_cpu src (src_off + !i)) ;\n n := !n - size_of_long ;\n i := !i + size_of_long\n done ;\n while !n > 0 do\n B.cpu_to_benat dst (dst_off + !i)\n Nat.(\n B.benat_to_cpu src (src_off + !i)\n lxor B.benat_to_cpu dst (dst_off + !i)) ;\n incr i ;\n decr n\n done\n\n let xor_into a b n =\n if n > imin (B.length a) (B.length b)\n then raise (Invalid_argument \"Baijiu.Xor.xor_inrot: buffers to small\")\n else xor_into a 0 b 0 n\n\n let xor a b =\n let l = imin (B.length a) (B.length b) in\n let r = B.copy (B.sub b 0 l) in\n xor_into a r l ;\n r\nend\n\nmodule Bytes = Make (Digestif_by)\nmodule Bigstring = Make (Digestif_bi)\n","# 1 \"src/digestif_conv.ml\"\nlet invalid_arg fmt = Format.ksprintf (fun s -> invalid_arg s) fmt\n\nmodule Make (D : sig\n val digest_size : int\nend) =\nstruct\n let to_hex hash =\n let res = Bytes.create (D.digest_size * 2) in\n let chr x =\n match x with\n | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 -> Char.chr (48 + x)\n | _ -> Char.chr (97 + (x - 10)) in\n for i = 0 to D.digest_size - 1 do\n let v = Char.code hash.[i] in\n Bytes.unsafe_set res (i * 2) (chr (v lsr 4)) ;\n Bytes.unsafe_set res ((i * 2) + 1) (chr (v land 0x0F))\n done ;\n Bytes.unsafe_to_string res\n\n let code x =\n match x with\n | '0' .. '9' -> Char.code x - Char.code '0'\n | 'A' .. 'F' -> Char.code x - Char.code 'A' + 10\n | 'a' .. 'f' -> Char.code x - Char.code 'a' + 10\n | _ -> invalid_arg \"of_hex: %02X\" (Char.code x)\n\n let decode chr1 chr2 = Char.chr ((code chr1 lsl 4) lor code chr2)\n\n let of_hex hex =\n let offset = ref 0 in\n let rec go have_first idx =\n if !offset + idx >= String.length hex\n then '\\x00'\n else\n match hex.[!offset + idx] with\n | ' ' | '\\t' | '\\r' | '\\n' ->\n incr offset ;\n go have_first idx\n | chr2 when have_first -> chr2\n | chr1 ->\n incr offset ;\n let chr2 = go true idx in\n if chr2 <> '\\x00'\n then decode chr1 chr2\n else invalid_arg \"of_hex: odd number of hex characters\" in\n String.init D.digest_size (go false)\n\n let of_hex_opt hex =\n match of_hex hex with\n | digest -> Some digest\n | exception Invalid_argument _ -> None\n\n let consistent_of_hex str =\n let offset = ref 0 in\n let rec go have_first idx =\n if !offset + idx >= String.length str\n then invalid_arg \"Not enough hex value\"\n else\n match str.[!offset + idx] with\n | ' ' | '\\t' | '\\r' | '\\n' ->\n incr offset ;\n go have_first idx\n | chr2 when have_first -> chr2\n | chr1 ->\n incr offset ;\n let chr2 = go true idx in\n decode chr1 chr2 in\n let res = String.init D.digest_size (go false) in\n let is_wsp = function ' ' | '\\t' | '\\r' | '\\n' -> true | _ -> false in\n while\n D.digest_size + !offset < String.length str\n && is_wsp str.[!offset + (D.digest_size * 2)]\n do\n incr offset\n done ;\n if !offset + D.digest_size = String.length str\n then res\n else\n invalid_arg \"Too much enough bytes (reach: %d, expect: %d)\"\n (!offset + (D.digest_size * 2))\n (String.length str)\n\n let consistent_of_hex_opt hex =\n match consistent_of_hex hex with\n | digest -> Some digest\n | exception Invalid_argument _ -> None\n\n let pp ppf hash =\n for i = 0 to D.digest_size - 1 do\n Format.fprintf ppf \"%02x\" (Char.code hash.[i])\n done\n\n let of_raw_string x =\n if String.length x <> D.digest_size\n then invalid_arg \"invalid hash size\"\n else x\n\n let of_raw_string_opt x =\n match of_raw_string x with\n | digest -> Some digest\n | exception Invalid_argument _ -> None\n\n let to_raw_string x = x\nend\n","module By = Digestif_by\nmodule Bi = Digestif_bi\n\nmodule Int32 = struct\n include Int32\n\n let ( lsl ) = Int32.shift_left\n\n let ( lsr ) = Int32.shift_right_logical\n\n let ( asr ) = Int32.shift_right\n\n let ( lor ) = Int32.logor\n\n let ( lxor ) = Int32.logxor\n\n let ( land ) = Int32.logand\n\n let lnot = Int32.lognot\n\n let ( + ) = Int32.add\n\n let rol32 a n = (a lsl n) lor (a lsr (32 - n))\n\n let ror32 a n = (a lsr n) lor (a lsl (32 - n))\nend\n\nmodule Int64 = struct\n include Int64\n\n let ( land ) = Int64.logand\n\n let ( lsl ) = Int64.shift_left\nend\n\nmodule type S = sig\n type kind = [ `MD5 ]\n\n type ctx = { mutable size : int64; b : Bytes.t; h : int32 array }\n\n val init : unit -> ctx\n\n val unsafe_feed_bytes : ctx -> By.t -> int -> int -> unit\n\n val unsafe_feed_bigstring : ctx -> Bi.t -> int -> int -> unit\n\n val unsafe_get : ctx -> By.t\n\n val dup : ctx -> ctx\nend\n\nmodule Unsafe : S = struct\n type kind = [ `MD5 ]\n\n type ctx = { mutable size : int64; b : Bytes.t; h : int32 array }\n\n let dup ctx = { size = ctx.size; b = By.copy ctx.b; h = Array.copy ctx.h }\n\n let init () =\n let b = By.make 64 '\\x00' in\n {\n size = 0L;\n b;\n h = [| 0x67452301l; 0xefcdab89l; 0x98badcfel; 0x10325476l |];\n }\n\n let f1 x y z = Int32.(z lxor (x land (y lxor z)))\n\n let f2 x y z = f1 z x y\n\n let f3 x y z = Int32.(x lxor y lxor z)\n\n let f4 x y z = Int32.(y lxor (x lor lnot z))\n\n let md5_do_chunk :\n type a. le32_to_cpu:(a -> int -> int32) -> ctx -> a -> int -> unit =\n fun ~le32_to_cpu ctx buf off ->\n let a, b, c, d =\n (ref ctx.h.(0), ref ctx.h.(1), ref ctx.h.(2), ref ctx.h.(3)) in\n let w = Array.make 16 0l in\n for i = 0 to 15 do\n w.(i) <- le32_to_cpu buf (off + (i * 4))\n done ;\n let round f a b c d i k s =\n let open Int32 in\n a := !a + f !b !c !d + w.(i) + k ;\n a := rol32 !a s ;\n a := !a + !b in\n round f1 a b c d 0 0xd76aa478l 7 ;\n round f1 d a b c 1 0xe8c7b756l 12 ;\n round f1 c d a b 2 0x242070dbl 17 ;\n round f1 b c d a 3 0xc1bdceeel 22 ;\n round f1 a b c d 4 0xf57c0fafl 7 ;\n round f1 d a b c 5 0x4787c62al 12 ;\n round f1 c d a b 6 0xa8304613l 17 ;\n round f1 b c d a 7 0xfd469501l 22 ;\n round f1 a b c d 8 0x698098d8l 7 ;\n round f1 d a b c 9 0x8b44f7afl 12 ;\n round f1 c d a b 10 0xffff5bb1l 17 ;\n round f1 b c d a 11 0x895cd7bel 22 ;\n round f1 a b c d 12 0x6b901122l 7 ;\n round f1 d a b c 13 0xfd987193l 12 ;\n round f1 c d a b 14 0xa679438el 17 ;\n round f1 b c d a 15 0x49b40821l 22 ;\n round f2 a b c d 1 0xf61e2562l 5 ;\n round f2 d a b c 6 0xc040b340l 9 ;\n round f2 c d a b 11 0x265e5a51l 14 ;\n round f2 b c d a 0 0xe9b6c7aal 20 ;\n round f2 a b c d 5 0xd62f105dl 5 ;\n round f2 d a b c 10 0x02441453l 9 ;\n round f2 c d a b 15 0xd8a1e681l 14 ;\n round f2 b c d a 4 0xe7d3fbc8l 20 ;\n round f2 a b c d 9 0x21e1cde6l 5 ;\n round f2 d a b c 14 0xc33707d6l 9 ;\n round f2 c d a b 3 0xf4d50d87l 14 ;\n round f2 b c d a 8 0x455a14edl 20 ;\n round f2 a b c d 13 0xa9e3e905l 5 ;\n round f2 d a b c 2 0xfcefa3f8l 9 ;\n round f2 c d a b 7 0x676f02d9l 14 ;\n round f2 b c d a 12 0x8d2a4c8al 20 ;\n round f3 a b c d 5 0xfffa3942l 4 ;\n round f3 d a b c 8 0x8771f681l 11 ;\n round f3 c d a b 11 0x6d9d6122l 16 ;\n round f3 b c d a 14 0xfde5380cl 23 ;\n round f3 a b c d 1 0xa4beea44l 4 ;\n round f3 d a b c 4 0x4bdecfa9l 11 ;\n round f3 c d a b 7 0xf6bb4b60l 16 ;\n round f3 b c d a 10 0xbebfbc70l 23 ;\n round f3 a b c d 13 0x289b7ec6l 4 ;\n round f3 d a b c 0 0xeaa127fal 11 ;\n round f3 c d a b 3 0xd4ef3085l 16 ;\n round f3 b c d a 6 0x04881d05l 23 ;\n round f3 a b c d 9 0xd9d4d039l 4 ;\n round f3 d a b c 12 0xe6db99e5l 11 ;\n round f3 c d a b 15 0x1fa27cf8l 16 ;\n round f3 b c d a 2 0xc4ac5665l 23 ;\n round f4 a b c d 0 0xf4292244l 6 ;\n round f4 d a b c 7 0x432aff97l 10 ;\n round f4 c d a b 14 0xab9423a7l 15 ;\n round f4 b c d a 5 0xfc93a039l 21 ;\n round f4 a b c d 12 0x655b59c3l 6 ;\n round f4 d a b c 3 0x8f0ccc92l 10 ;\n round f4 c d a b 10 0xffeff47dl 15 ;\n round f4 b c d a 1 0x85845dd1l 21 ;\n round f4 a b c d 8 0x6fa87e4fl 6 ;\n round f4 d a b c 15 0xfe2ce6e0l 10 ;\n round f4 c d a b 6 0xa3014314l 15 ;\n round f4 b c d a 13 0x4e0811a1l 21 ;\n round f4 a b c d 4 0xf7537e82l 6 ;\n round f4 d a b c 11 0xbd3af235l 10 ;\n round f4 c d a b 2 0x2ad7d2bbl 15 ;\n round f4 b c d a 9 0xeb86d391l 21 ;\n let open Int32 in\n ctx.h.(0) <- ctx.h.(0) + !a ;\n ctx.h.(1) <- ctx.h.(1) + !b ;\n ctx.h.(2) <- ctx.h.(2) + !c ;\n ctx.h.(3) <- ctx.h.(3) + !d ;\n ()\n\n let feed :\n type a.\n blit:(a -> int -> By.t -> int -> int -> unit) ->\n le32_to_cpu:(a -> int -> int32) ->\n ctx ->\n a ->\n int ->\n int ->\n unit =\n fun ~blit ~le32_to_cpu ctx buf off len ->\n let idx = ref Int64.(to_int (ctx.size land 0x3FL)) in\n let len = ref len in\n let off = ref off in\n let to_fill = 64 - !idx in\n ctx.size <- Int64.add ctx.size (Int64.of_int !len) ;\n if !idx <> 0 && !len >= to_fill\n then (\n blit buf !off ctx.b !idx to_fill ;\n md5_do_chunk ~le32_to_cpu:By.le32_to_cpu ctx ctx.b 0 ;\n len := !len - to_fill ;\n off := !off + to_fill ;\n idx := 0) ;\n while !len >= 64 do\n md5_do_chunk ~le32_to_cpu ctx buf !off ;\n len := !len - 64 ;\n off := !off + 64\n done ;\n if !len <> 0 then blit buf !off ctx.b !idx !len ;\n ()\n\n let unsafe_feed_bytes = feed ~blit:By.blit ~le32_to_cpu:By.le32_to_cpu\n\n let unsafe_feed_bigstring =\n feed ~blit:By.blit_from_bigstring ~le32_to_cpu:Bi.le32_to_cpu\n\n let unsafe_get ctx =\n let index = Int64.(to_int (ctx.size land 0x3FL)) in\n let padlen = if index < 56 then 56 - index else 64 + 56 - index in\n let padding = By.init padlen (function 0 -> '\\x80' | _ -> '\\x00') in\n let bits = By.create 8 in\n By.cpu_to_le64 bits 0 Int64.(ctx.size lsl 3) ;\n unsafe_feed_bytes ctx padding 0 padlen ;\n unsafe_feed_bytes ctx bits 0 8 ;\n let res = By.create (4 * 4) in\n for i = 0 to 3 do\n By.cpu_to_le32 res (i * 4) ctx.h.(i)\n done ;\n res\nend\n","module By = Digestif_by\nmodule Bi = Digestif_bi\n\nmodule type S = sig\n type ctx\n\n type kind = [ `RMD160 ]\n\n val init : unit -> ctx\n\n val unsafe_feed_bytes : ctx -> By.t -> int -> int -> unit\n\n val unsafe_feed_bigstring : ctx -> Bi.t -> int -> int -> unit\n\n val unsafe_get : ctx -> By.t\n\n val dup : ctx -> ctx\nend\n\nmodule Int32 = struct\n include Int32\n\n let ( lsl ) = Int32.shift_left\n\n let ( lsr ) = Int32.shift_right_logical\n\n let ( asr ) = Int32.shift_right\n\n let ( lor ) = Int32.logor\n\n let ( lxor ) = Int32.logxor\n\n let ( land ) = Int32.logand\n\n let lnot = Int32.lognot\n\n let ( + ) = Int32.add\n\n let rol32 a n = (a lsl n) lor (a lsr (32 - n))\n\n let ror32 a n = (a lsr n) lor (a lsl (32 - n))\nend\n\nmodule Int64 = struct\n include Int64\n\n let ( land ) = Int64.logand\n\n let ( lsl ) = Int64.shift_left\nend\n\nmodule Unsafe : S = struct\n type kind = [ `RMD160 ]\n\n type ctx = { s : int32 array; mutable n : int; h : int32 array; b : Bytes.t }\n\n let dup ctx =\n { s = Array.copy ctx.s; n = ctx.n; h = Array.copy ctx.h; b = By.copy ctx.b }\n\n let init () =\n let b = By.make 64 '\\x00' in\n {\n s = [| 0l; 0l |];\n n = 0;\n b;\n h = [| 0x67452301l; 0xefcdab89l; 0x98badcfel; 0x10325476l; 0xc3d2e1f0l |];\n }\n\n let f x y z = Int32.(x lxor y lxor z)\n\n let g x y z = Int32.(x land y lor (lnot x land z))\n\n let h x y z = Int32.(x lor lnot y lxor z)\n\n let i x y z = Int32.(x land z lor (y land lnot z))\n\n let j x y z = Int32.(x lxor (y lor lnot z))\n\n let ff a b c d e x s =\n let open Int32 in\n a := !a + f !b !c !d + x ;\n a := rol32 !a s + !e ;\n c := rol32 !c 10\n\n let gg a b c d e x s =\n let open Int32 in\n a := !a + g !b !c !d + x + 0x5a827999l ;\n a := rol32 !a s + !e ;\n c := rol32 !c 10\n\n let hh a b c d e x s =\n let open Int32 in\n a := !a + h !b !c !d + x + 0x6ed9eba1l ;\n a := rol32 !a s + !e ;\n c := rol32 !c 10\n\n let ii a b c d e x s =\n let open Int32 in\n a := !a + i !b !c !d + x + 0x8f1bbcdcl ;\n a := rol32 !a s + !e ;\n c := rol32 !c 10\n\n let jj a b c d e x s =\n let open Int32 in\n a := !a + j !b !c !d + x + 0xa953fd4el ;\n a := rol32 !a s + !e ;\n c := rol32 !c 10\n\n let fff a b c d e x s =\n let open Int32 in\n a := !a + f !b !c !d + x ;\n a := rol32 !a s + !e ;\n c := rol32 !c 10\n\n let ggg a b c d e x s =\n let open Int32 in\n a := !a + g !b !c !d + x + 0x7a6d76e9l ;\n a := rol32 !a s + !e ;\n c := rol32 !c 10\n\n let hhh a b c d e x s =\n let open Int32 in\n a := !a + h !b !c !d + x + 0x6d703ef3l ;\n a := rol32 !a s + !e ;\n c := rol32 !c 10\n\n let iii a b c d e x s =\n let open Int32 in\n a := !a + i !b !c !d + x + 0x5c4dd124l ;\n a := rol32 !a s + !e ;\n c := rol32 !c 10\n\n let jjj a b c d e x s =\n let open Int32 in\n a := !a + j !b !c !d + x + 0x50a28be6l ;\n a := rol32 !a s + !e ;\n c := rol32 !c 10\n\n let rmd160_do_chunk :\n type a. le32_to_cpu:(a -> int -> int32) -> ctx -> a -> int -> unit =\n fun ~le32_to_cpu ctx buff off ->\n let aa, bb, cc, dd, ee, aaa, bbb, ccc, ddd, eee =\n ( ref ctx.h.(0),\n ref ctx.h.(1),\n ref ctx.h.(2),\n ref ctx.h.(3),\n ref ctx.h.(4),\n ref ctx.h.(0),\n ref ctx.h.(1),\n ref ctx.h.(2),\n ref ctx.h.(3),\n ref ctx.h.(4) ) in\n let w = Array.make 16 0l in\n for i = 0 to 15 do\n w.(i) <- le32_to_cpu buff (off + (i * 4))\n done ;\n ff aa bb cc dd ee w.(0) 11 ;\n ff ee aa bb cc dd w.(1) 14 ;\n ff dd ee aa bb cc w.(2) 15 ;\n ff cc dd ee aa bb w.(3) 12 ;\n ff bb cc dd ee aa w.(4) 5 ;\n ff aa bb cc dd ee w.(5) 8 ;\n ff ee aa bb cc dd w.(6) 7 ;\n ff dd ee aa bb cc w.(7) 9 ;\n ff cc dd ee aa bb w.(8) 11 ;\n ff bb cc dd ee aa w.(9) 13 ;\n ff aa bb cc dd ee w.(10) 14 ;\n ff ee aa bb cc dd w.(11) 15 ;\n ff dd ee aa bb cc w.(12) 6 ;\n ff cc dd ee aa bb w.(13) 7 ;\n ff bb cc dd ee aa w.(14) 9 ;\n ff aa bb cc dd ee w.(15) 8 ;\n gg ee aa bb cc dd w.(7) 7 ;\n gg dd ee aa bb cc w.(4) 6 ;\n gg cc dd ee aa bb w.(13) 8 ;\n gg bb cc dd ee aa w.(1) 13 ;\n gg aa bb cc dd ee w.(10) 11 ;\n gg ee aa bb cc dd w.(6) 9 ;\n gg dd ee aa bb cc w.(15) 7 ;\n gg cc dd ee aa bb w.(3) 15 ;\n gg bb cc dd ee aa w.(12) 7 ;\n gg aa bb cc dd ee w.(0) 12 ;\n gg ee aa bb cc dd w.(9) 15 ;\n gg dd ee aa bb cc w.(5) 9 ;\n gg cc dd ee aa bb w.(2) 11 ;\n gg bb cc dd ee aa w.(14) 7 ;\n gg aa bb cc dd ee w.(11) 13 ;\n gg ee aa bb cc dd w.(8) 12 ;\n hh dd ee aa bb cc w.(3) 11 ;\n hh cc dd ee aa bb w.(10) 13 ;\n hh bb cc dd ee aa w.(14) 6 ;\n hh aa bb cc dd ee w.(4) 7 ;\n hh ee aa bb cc dd w.(9) 14 ;\n hh dd ee aa bb cc w.(15) 9 ;\n hh cc dd ee aa bb w.(8) 13 ;\n hh bb cc dd ee aa w.(1) 15 ;\n hh aa bb cc dd ee w.(2) 14 ;\n hh ee aa bb cc dd w.(7) 8 ;\n hh dd ee aa bb cc w.(0) 13 ;\n hh cc dd ee aa bb w.(6) 6 ;\n hh bb cc dd ee aa w.(13) 5 ;\n hh aa bb cc dd ee w.(11) 12 ;\n hh ee aa bb cc dd w.(5) 7 ;\n hh dd ee aa bb cc w.(12) 5 ;\n ii cc dd ee aa bb w.(1) 11 ;\n ii bb cc dd ee aa w.(9) 12 ;\n ii aa bb cc dd ee w.(11) 14 ;\n ii ee aa bb cc dd w.(10) 15 ;\n ii dd ee aa bb cc w.(0) 14 ;\n ii cc dd ee aa bb w.(8) 15 ;\n ii bb cc dd ee aa w.(12) 9 ;\n ii aa bb cc dd ee w.(4) 8 ;\n ii ee aa bb cc dd w.(13) 9 ;\n ii dd ee aa bb cc w.(3) 14 ;\n ii cc dd ee aa bb w.(7) 5 ;\n ii bb cc dd ee aa w.(15) 6 ;\n ii aa bb cc dd ee w.(14) 8 ;\n ii ee aa bb cc dd w.(5) 6 ;\n ii dd ee aa bb cc w.(6) 5 ;\n ii cc dd ee aa bb w.(2) 12 ;\n jj bb cc dd ee aa w.(4) 9 ;\n jj aa bb cc dd ee w.(0) 15 ;\n jj ee aa bb cc dd w.(5) 5 ;\n jj dd ee aa bb cc w.(9) 11 ;\n jj cc dd ee aa bb w.(7) 6 ;\n jj bb cc dd ee aa w.(12) 8 ;\n jj aa bb cc dd ee w.(2) 13 ;\n jj ee aa bb cc dd w.(10) 12 ;\n jj dd ee aa bb cc w.(14) 5 ;\n jj cc dd ee aa bb w.(1) 12 ;\n jj bb cc dd ee aa w.(3) 13 ;\n jj aa bb cc dd ee w.(8) 14 ;\n jj ee aa bb cc dd w.(11) 11 ;\n jj dd ee aa bb cc w.(6) 8 ;\n jj cc dd ee aa bb w.(15) 5 ;\n jj bb cc dd ee aa w.(13) 6 ;\n jjj aaa bbb ccc ddd eee w.(5) 8 ;\n jjj eee aaa bbb ccc ddd w.(14) 9 ;\n jjj ddd eee aaa bbb ccc w.(7) 9 ;\n jjj ccc ddd eee aaa bbb w.(0) 11 ;\n jjj bbb ccc ddd eee aaa w.(9) 13 ;\n jjj aaa bbb ccc ddd eee w.(2) 15 ;\n jjj eee aaa bbb ccc ddd w.(11) 15 ;\n jjj ddd eee aaa bbb ccc w.(4) 5 ;\n jjj ccc ddd eee aaa bbb w.(13) 7 ;\n jjj bbb ccc ddd eee aaa w.(6) 7 ;\n jjj aaa bbb ccc ddd eee w.(15) 8 ;\n jjj eee aaa bbb ccc ddd w.(8) 11 ;\n jjj ddd eee aaa bbb ccc w.(1) 14 ;\n jjj ccc ddd eee aaa bbb w.(10) 14 ;\n jjj bbb ccc ddd eee aaa w.(3) 12 ;\n jjj aaa bbb ccc ddd eee w.(12) 6 ;\n iii eee aaa bbb ccc ddd w.(6) 9 ;\n iii ddd eee aaa bbb ccc w.(11) 13 ;\n iii ccc ddd eee aaa bbb w.(3) 15 ;\n iii bbb ccc ddd eee aaa w.(7) 7 ;\n iii aaa bbb ccc ddd eee w.(0) 12 ;\n iii eee aaa bbb ccc ddd w.(13) 8 ;\n iii ddd eee aaa bbb ccc w.(5) 9 ;\n iii ccc ddd eee aaa bbb w.(10) 11 ;\n iii bbb ccc ddd eee aaa w.(14) 7 ;\n iii aaa bbb ccc ddd eee w.(15) 7 ;\n iii eee aaa bbb ccc ddd w.(8) 12 ;\n iii ddd eee aaa bbb ccc w.(12) 7 ;\n iii ccc ddd eee aaa bbb w.(4) 6 ;\n iii bbb ccc ddd eee aaa w.(9) 15 ;\n iii aaa bbb ccc ddd eee w.(1) 13 ;\n iii eee aaa bbb ccc ddd w.(2) 11 ;\n hhh ddd eee aaa bbb ccc w.(15) 9 ;\n hhh ccc ddd eee aaa bbb w.(5) 7 ;\n hhh bbb ccc ddd eee aaa w.(1) 15 ;\n hhh aaa bbb ccc ddd eee w.(3) 11 ;\n hhh eee aaa bbb ccc ddd w.(7) 8 ;\n hhh ddd eee aaa bbb ccc w.(14) 6 ;\n hhh ccc ddd eee aaa bbb w.(6) 6 ;\n hhh bbb ccc ddd eee aaa w.(9) 14 ;\n hhh aaa bbb ccc ddd eee w.(11) 12 ;\n hhh eee aaa bbb ccc ddd w.(8) 13 ;\n hhh ddd eee aaa bbb ccc w.(12) 5 ;\n hhh ccc ddd eee aaa bbb w.(2) 14 ;\n hhh bbb ccc ddd eee aaa w.(10) 13 ;\n hhh aaa bbb ccc ddd eee w.(0) 13 ;\n hhh eee aaa bbb ccc ddd w.(4) 7 ;\n hhh ddd eee aaa bbb ccc w.(13) 5 ;\n ggg ccc ddd eee aaa bbb w.(8) 15 ;\n ggg bbb ccc ddd eee aaa w.(6) 5 ;\n ggg aaa bbb ccc ddd eee w.(4) 8 ;\n ggg eee aaa bbb ccc ddd w.(1) 11 ;\n ggg ddd eee aaa bbb ccc w.(3) 14 ;\n ggg ccc ddd eee aaa bbb w.(11) 14 ;\n ggg bbb ccc ddd eee aaa w.(15) 6 ;\n ggg aaa bbb ccc ddd eee w.(0) 14 ;\n ggg eee aaa bbb ccc ddd w.(5) 6 ;\n ggg ddd eee aaa bbb ccc w.(12) 9 ;\n ggg ccc ddd eee aaa bbb w.(2) 12 ;\n ggg bbb ccc ddd eee aaa w.(13) 9 ;\n ggg aaa bbb ccc ddd eee w.(9) 12 ;\n ggg eee aaa bbb ccc ddd w.(7) 5 ;\n ggg ddd eee aaa bbb ccc w.(10) 15 ;\n ggg ccc ddd eee aaa bbb w.(14) 8 ;\n fff bbb ccc ddd eee aaa w.(12) 8 ;\n fff aaa bbb ccc ddd eee w.(15) 5 ;\n fff eee aaa bbb ccc ddd w.(10) 12 ;\n fff ddd eee aaa bbb ccc w.(4) 9 ;\n fff ccc ddd eee aaa bbb w.(1) 12 ;\n fff bbb ccc ddd eee aaa w.(5) 5 ;\n fff aaa bbb ccc ddd eee w.(8) 14 ;\n fff eee aaa bbb ccc ddd w.(7) 6 ;\n fff ddd eee aaa bbb ccc w.(6) 8 ;\n fff ccc ddd eee aaa bbb w.(2) 13 ;\n fff bbb ccc ddd eee aaa w.(13) 6 ;\n fff aaa bbb ccc ddd eee w.(14) 5 ;\n fff eee aaa bbb ccc ddd w.(0) 15 ;\n fff ddd eee aaa bbb ccc w.(3) 13 ;\n fff ccc ddd eee aaa bbb w.(9) 11 ;\n fff bbb ccc ddd eee aaa w.(11) 11 ;\n let open Int32 in\n ddd := !ddd + !cc + ctx.h.(1) ;\n (* final result for h[0]. *)\n ctx.h.(1) <- ctx.h.(2) + !dd + !eee ;\n ctx.h.(2) <- ctx.h.(3) + !ee + !aaa ;\n ctx.h.(3) <- ctx.h.(4) + !aa + !bbb ;\n ctx.h.(4) <- ctx.h.(0) + !bb + !ccc ;\n ctx.h.(0) <- !ddd ;\n ()\n\n exception Leave\n\n let feed :\n type a.\n le32_to_cpu:(a -> int -> int32) ->\n blit:(a -> int -> By.t -> int -> int -> unit) ->\n ctx ->\n a ->\n int ->\n int ->\n unit =\n fun ~le32_to_cpu ~blit ctx buf off len ->\n let t = ref ctx.s.(0) in\n let off = ref off in\n let len = ref len in\n ctx.s.(0) <- Int32.add !t (Int32.of_int (!len lsl 3)) ;\n if ctx.s.(0) < !t then ctx.s.(1) <- Int32.(ctx.s.(1) + 1l) ;\n ctx.s.(1) <- Int32.add ctx.s.(1) (Int32.of_int (!len lsr 29)) ;\n try\n if ctx.n <> 0\n then (\n let t = 64 - ctx.n in\n if !len < t\n then (\n blit buf !off ctx.b ctx.n !len ;\n ctx.n <- ctx.n + !len ;\n raise Leave) ;\n blit buf !off ctx.b ctx.n t ;\n rmd160_do_chunk ~le32_to_cpu:By.le32_to_cpu ctx ctx.b 0 ;\n off := !off + t ;\n len := !len - t) ;\n while !len >= 64 do\n rmd160_do_chunk ~le32_to_cpu ctx buf !off ;\n off := !off + 64 ;\n len := !len - 64\n done ;\n blit buf !off ctx.b 0 !len ;\n ctx.n <- !len\n with Leave -> ()\n\n let unsafe_feed_bytes ctx buf off len =\n feed ~blit:By.blit ~le32_to_cpu:By.le32_to_cpu ctx buf off len\n\n let unsafe_feed_bigstring ctx buf off len =\n feed ~blit:By.blit_from_bigstring ~le32_to_cpu:Bi.le32_to_cpu ctx buf off\n len\n\n let unsafe_get ctx =\n let i = ref (ctx.n + 1) in\n let res = By.create (5 * 4) in\n By.set ctx.b ctx.n '\\x80' ;\n if !i > 56\n then (\n By.fill ctx.b !i (64 - !i) '\\x00' ;\n rmd160_do_chunk ~le32_to_cpu:By.le32_to_cpu ctx ctx.b 0 ;\n i := 0) ;\n By.fill ctx.b !i (56 - !i) '\\x00' ;\n By.cpu_to_le32 ctx.b 56 ctx.s.(0) ;\n By.cpu_to_le32 ctx.b 60 ctx.s.(1) ;\n rmd160_do_chunk ~le32_to_cpu:By.le32_to_cpu ctx ctx.b 0 ;\n for i = 0 to 4 do\n By.cpu_to_le32 res (i * 4) ctx.h.(i)\n done ;\n res\nend\n","module By = Digestif_by\nmodule Bi = Digestif_bi\n\nmodule Int32 = struct\n include Int32\n\n let ( lsl ) = Int32.shift_left\n\n let ( lsr ) = Int32.shift_right_logical\n\n let ( asr ) = Int32.shift_right\n\n let ( lor ) = Int32.logor\n\n let ( lxor ) = Int32.logxor\n\n let ( land ) = Int32.logand\n\n let ( + ) = Int32.add\n\n let rol32 a n = (a lsl n) lor (a lsr (32 - n))\nend\n\nmodule Int64 = struct\n include Int64\n\n let ( land ) = Int64.logand\n\n let ( lsl ) = Int64.shift_left\nend\n\nmodule type S = sig\n type ctx\n\n type kind = [ `SHA1 ]\n\n val init : unit -> ctx\n\n val unsafe_feed_bytes : ctx -> By.t -> int -> int -> unit\n\n val unsafe_feed_bigstring : ctx -> Bi.t -> int -> int -> unit\n\n val unsafe_get : ctx -> By.t\n\n val dup : ctx -> ctx\nend\n\nmodule Unsafe : S = struct\n type kind = [ `SHA1 ]\n\n type ctx = { mutable size : int64; b : Bytes.t; h : int32 array }\n\n let dup ctx = { size = ctx.size; b = By.copy ctx.b; h = Array.copy ctx.h }\n\n let init () =\n let b = By.make 64 '\\x00' in\n {\n size = 0L;\n b;\n h = [| 0x67452301l; 0xefcdab89l; 0x98badcfel; 0x10325476l; 0xc3d2e1f0l |];\n }\n\n let f1 x y z = Int32.(z lxor (x land (y lxor z)))\n\n let f2 x y z = Int32.(x lxor y lxor z)\n\n let f3 x y z = Int32.((x land y) + (z land (x lxor y)))\n\n let f4 = f2\n\n let k1 = 0x5a827999l\n\n let k2 = 0x6ed9eba1l\n\n let k3 = 0x8f1bbcdcl\n\n let k4 = 0xca62c1d6l\n\n let sha1_do_chunk :\n type a. be32_to_cpu:(a -> int -> int32) -> ctx -> a -> int -> unit =\n fun ~be32_to_cpu ctx buf off ->\n let a = ref ctx.h.(0) in\n let b = ref ctx.h.(1) in\n let c = ref ctx.h.(2) in\n let d = ref ctx.h.(3) in\n let e = ref ctx.h.(4) in\n let w = Array.make 16 0l in\n let m i =\n let ( && ) a b = a land b in\n let ( -- ) a b = a - b in\n let v =\n Int32.(\n rol32\n (w.(i && 0x0F)\n lxor w.((i -- 14) && 0x0F)\n lxor w.((i -- 8) && 0x0F)\n lxor w.((i -- 3) && 0x0F))\n 1) in\n w.(i land 0x0F) <- v ;\n w.(i land 0x0F) in\n let round a b c d e f k w =\n (e := Int32.(!e + rol32 !a 5 + f !b !c !d + k + w)) ;\n b := Int32.(rol32 !b 30) in\n for i = 0 to 15 do\n w.(i) <- be32_to_cpu buf (off + (i * 4))\n done ;\n round a b c d e f1 k1 w.(0) ;\n round e a b c d f1 k1 w.(1) ;\n round d e a b c f1 k1 w.(2) ;\n round c d e a b f1 k1 w.(3) ;\n round b c d e a f1 k1 w.(4) ;\n round a b c d e f1 k1 w.(5) ;\n round e a b c d f1 k1 w.(6) ;\n round d e a b c f1 k1 w.(7) ;\n round c d e a b f1 k1 w.(8) ;\n round b c d e a f1 k1 w.(9) ;\n round a b c d e f1 k1 w.(10) ;\n round e a b c d f1 k1 w.(11) ;\n round d e a b c f1 k1 w.(12) ;\n round c d e a b f1 k1 w.(13) ;\n round b c d e a f1 k1 w.(14) ;\n round a b c d e f1 k1 w.(15) ;\n round e a b c d f1 k1 (m 16) ;\n round d e a b c f1 k1 (m 17) ;\n round c d e a b f1 k1 (m 18) ;\n round b c d e a f1 k1 (m 19) ;\n round a b c d e f2 k2 (m 20) ;\n round e a b c d f2 k2 (m 21) ;\n round d e a b c f2 k2 (m 22) ;\n round c d e a b f2 k2 (m 23) ;\n round b c d e a f2 k2 (m 24) ;\n round a b c d e f2 k2 (m 25) ;\n round e a b c d f2 k2 (m 26) ;\n round d e a b c f2 k2 (m 27) ;\n round c d e a b f2 k2 (m 28) ;\n round b c d e a f2 k2 (m 29) ;\n round a b c d e f2 k2 (m 30) ;\n round e a b c d f2 k2 (m 31) ;\n round d e a b c f2 k2 (m 32) ;\n round c d e a b f2 k2 (m 33) ;\n round b c d e a f2 k2 (m 34) ;\n round a b c d e f2 k2 (m 35) ;\n round e a b c d f2 k2 (m 36) ;\n round d e a b c f2 k2 (m 37) ;\n round c d e a b f2 k2 (m 38) ;\n round b c d e a f2 k2 (m 39) ;\n round a b c d e f3 k3 (m 40) ;\n round e a b c d f3 k3 (m 41) ;\n round d e a b c f3 k3 (m 42) ;\n round c d e a b f3 k3 (m 43) ;\n round b c d e a f3 k3 (m 44) ;\n round a b c d e f3 k3 (m 45) ;\n round e a b c d f3 k3 (m 46) ;\n round d e a b c f3 k3 (m 47) ;\n round c d e a b f3 k3 (m 48) ;\n round b c d e a f3 k3 (m 49) ;\n round a b c d e f3 k3 (m 50) ;\n round e a b c d f3 k3 (m 51) ;\n round d e a b c f3 k3 (m 52) ;\n round c d e a b f3 k3 (m 53) ;\n round b c d e a f3 k3 (m 54) ;\n round a b c d e f3 k3 (m 55) ;\n round e a b c d f3 k3 (m 56) ;\n round d e a b c f3 k3 (m 57) ;\n round c d e a b f3 k3 (m 58) ;\n round b c d e a f3 k3 (m 59) ;\n round a b c d e f4 k4 (m 60) ;\n round e a b c d f4 k4 (m 61) ;\n round d e a b c f4 k4 (m 62) ;\n round c d e a b f4 k4 (m 63) ;\n round b c d e a f4 k4 (m 64) ;\n round a b c d e f4 k4 (m 65) ;\n round e a b c d f4 k4 (m 66) ;\n round d e a b c f4 k4 (m 67) ;\n round c d e a b f4 k4 (m 68) ;\n round b c d e a f4 k4 (m 69) ;\n round a b c d e f4 k4 (m 70) ;\n round e a b c d f4 k4 (m 71) ;\n round d e a b c f4 k4 (m 72) ;\n round c d e a b f4 k4 (m 73) ;\n round b c d e a f4 k4 (m 74) ;\n round a b c d e f4 k4 (m 75) ;\n round e a b c d f4 k4 (m 76) ;\n round d e a b c f4 k4 (m 77) ;\n round c d e a b f4 k4 (m 78) ;\n round b c d e a f4 k4 (m 79) ;\n ctx.h.(0) <- Int32.add ctx.h.(0) !a ;\n ctx.h.(1) <- Int32.add ctx.h.(1) !b ;\n ctx.h.(2) <- Int32.add ctx.h.(2) !c ;\n ctx.h.(3) <- Int32.add ctx.h.(3) !d ;\n ctx.h.(4) <- Int32.add ctx.h.(4) !e ;\n ()\n\n let feed :\n type a.\n blit:(a -> int -> By.t -> int -> int -> unit) ->\n be32_to_cpu:(a -> int -> int32) ->\n ctx ->\n a ->\n int ->\n int ->\n unit =\n fun ~blit ~be32_to_cpu ctx buf off len ->\n let idx = ref Int64.(to_int (ctx.size land 0x3FL)) in\n let len = ref len in\n let off = ref off in\n let to_fill = 64 - !idx in\n ctx.size <- Int64.add ctx.size (Int64.of_int !len) ;\n if !idx <> 0 && !len >= to_fill\n then (\n blit buf !off ctx.b !idx to_fill ;\n sha1_do_chunk ~be32_to_cpu:By.be32_to_cpu ctx ctx.b 0 ;\n len := !len - to_fill ;\n off := !off + to_fill ;\n idx := 0) ;\n while !len >= 64 do\n sha1_do_chunk ~be32_to_cpu ctx buf !off ;\n len := !len - 64 ;\n off := !off + 64\n done ;\n if !len <> 0 then blit buf !off ctx.b !idx !len ;\n ()\n\n let unsafe_feed_bytes = feed ~blit:By.blit ~be32_to_cpu:By.be32_to_cpu\n\n let unsafe_feed_bigstring =\n feed ~blit:By.blit_from_bigstring ~be32_to_cpu:Bi.be32_to_cpu\n\n let unsafe_get ctx =\n let index = Int64.(to_int (ctx.size land 0x3FL)) in\n let padlen = if index < 56 then 56 - index else 64 + 56 - index in\n let padding = By.init padlen (function 0 -> '\\x80' | _ -> '\\x00') in\n let bits = By.create 8 in\n By.cpu_to_be64 bits 0 Int64.(ctx.size lsl 3) ;\n unsafe_feed_bytes ctx padding 0 padlen ;\n unsafe_feed_bytes ctx bits 0 8 ;\n let res = By.create (5 * 4) in\n for i = 0 to 4 do\n By.cpu_to_be32 res (i * 4) ctx.h.(i)\n done ;\n res\nend\n","module By = Digestif_by\nmodule Bi = Digestif_bi\n\nmodule Int32 = struct\n include Int32\n\n let ( lsl ) = Int32.shift_left\n\n let ( lsr ) = Int32.shift_right_logical\n\n let ( asr ) = Int32.shift_right\n\n let ( lor ) = Int32.logor\n\n let ( lxor ) = Int32.logxor\n\n let ( land ) = Int32.logand\n\n let ( + ) = Int32.add\n\n let rol32 a n = (a lsl n) lor (a lsr (32 - n))\n\n let ror32 a n = (a lsr n) lor (a lsl (32 - n))\nend\n\nmodule Int64 = struct\n include Int64\n\n let ( land ) = Int64.logand\n\n let ( lsl ) = Int64.shift_left\nend\n\nmodule type S = sig\n type kind = [ `SHA256 ]\n\n type ctx = { mutable size : int64; b : Bytes.t; h : int32 array }\n\n val init : unit -> ctx\n\n val unsafe_feed_bytes : ctx -> By.t -> int -> int -> unit\n\n val unsafe_feed_bigstring : ctx -> Bi.t -> int -> int -> unit\n\n val unsafe_get : ctx -> By.t\n\n val dup : ctx -> ctx\nend\n\nmodule Unsafe : S = struct\n type kind = [ `SHA256 ]\n\n type ctx = { mutable size : int64; b : Bytes.t; h : int32 array }\n\n let dup ctx = { size = ctx.size; b = By.copy ctx.b; h = Array.copy ctx.h }\n\n let init () =\n let b = By.make 128 '\\x00' in\n {\n size = 0L;\n b;\n h =\n [|\n 0x6a09e667l;\n 0xbb67ae85l;\n 0x3c6ef372l;\n 0xa54ff53al;\n 0x510e527fl;\n 0x9b05688cl;\n 0x1f83d9abl;\n 0x5be0cd19l;\n |];\n }\n\n let k =\n [|\n 0x428a2f98l;\n 0x71374491l;\n 0xb5c0fbcfl;\n 0xe9b5dba5l;\n 0x3956c25bl;\n 0x59f111f1l;\n 0x923f82a4l;\n 0xab1c5ed5l;\n 0xd807aa98l;\n 0x12835b01l;\n 0x243185bel;\n 0x550c7dc3l;\n 0x72be5d74l;\n 0x80deb1fel;\n 0x9bdc06a7l;\n 0xc19bf174l;\n 0xe49b69c1l;\n 0xefbe4786l;\n 0x0fc19dc6l;\n 0x240ca1ccl;\n 0x2de92c6fl;\n 0x4a7484aal;\n 0x5cb0a9dcl;\n 0x76f988dal;\n 0x983e5152l;\n 0xa831c66dl;\n 0xb00327c8l;\n 0xbf597fc7l;\n 0xc6e00bf3l;\n 0xd5a79147l;\n 0x06ca6351l;\n 0x14292967l;\n 0x27b70a85l;\n 0x2e1b2138l;\n 0x4d2c6dfcl;\n 0x53380d13l;\n 0x650a7354l;\n 0x766a0abbl;\n 0x81c2c92el;\n 0x92722c85l;\n 0xa2bfe8a1l;\n 0xa81a664bl;\n 0xc24b8b70l;\n 0xc76c51a3l;\n 0xd192e819l;\n 0xd6990624l;\n 0xf40e3585l;\n 0x106aa070l;\n 0x19a4c116l;\n 0x1e376c08l;\n 0x2748774cl;\n 0x34b0bcb5l;\n 0x391c0cb3l;\n 0x4ed8aa4al;\n 0x5b9cca4fl;\n 0x682e6ff3l;\n 0x748f82eel;\n 0x78a5636fl;\n 0x84c87814l;\n 0x8cc70208l;\n 0x90befffal;\n 0xa4506cebl;\n 0xbef9a3f7l;\n 0xc67178f2l;\n |]\n\n let e0 x = Int32.(ror32 x 2 lxor ror32 x 13 lxor ror32 x 22)\n\n let e1 x = Int32.(ror32 x 6 lxor ror32 x 11 lxor ror32 x 25)\n\n let s0 x = Int32.(ror32 x 7 lxor ror32 x 18 lxor (x lsr 3))\n\n let s1 x = Int32.(ror32 x 17 lxor ror32 x 19 lxor (x lsr 10))\n\n let sha256_do_chunk :\n type a. be32_to_cpu:(a -> int -> int32) -> ctx -> a -> int -> unit =\n fun ~be32_to_cpu ctx buf off ->\n let a, b, c, d, e, f, g, h, t1, t2 =\n ( ref ctx.h.(0),\n ref ctx.h.(1),\n ref ctx.h.(2),\n ref ctx.h.(3),\n ref ctx.h.(4),\n ref ctx.h.(5),\n ref ctx.h.(6),\n ref ctx.h.(7),\n ref 0l,\n ref 0l ) in\n let w = Array.make 64 0l in\n for i = 0 to 15 do\n w.(i) <- be32_to_cpu buf (off + (i * 4))\n done ;\n let ( -- ) a b = a - b in\n for i = 16 to 63 do\n w.(i) <- Int32.(s1 w.(i -- 2) + w.(i -- 7) + s0 w.(i -- 15) + w.(i -- 16))\n done ;\n let round a b c d e f g h k w =\n let open Int32 in\n t1 := !h + e1 !e + (!g lxor (!e land (!f lxor !g))) + k + w ;\n t2 := e0 !a + (!a land !b lor (!c land (!a lor !b))) ;\n d := !d + !t1 ;\n h := !t1 + !t2 in\n for i = 0 to 7 do\n round a b c d e f g h k.((i * 8) + 0) w.((i * 8) + 0) ;\n round h a b c d e f g k.((i * 8) + 1) w.((i * 8) + 1) ;\n round g h a b c d e f k.((i * 8) + 2) w.((i * 8) + 2) ;\n round f g h a b c d e k.((i * 8) + 3) w.((i * 8) + 3) ;\n round e f g h a b c d k.((i * 8) + 4) w.((i * 8) + 4) ;\n round d e f g h a b c k.((i * 8) + 5) w.((i * 8) + 5) ;\n round c d e f g h a b k.((i * 8) + 6) w.((i * 8) + 6) ;\n round b c d e f g h a k.((i * 8) + 7) w.((i * 8) + 7)\n done ;\n let open Int32 in\n ctx.h.(0) <- ctx.h.(0) + !a ;\n ctx.h.(1) <- ctx.h.(1) + !b ;\n ctx.h.(2) <- ctx.h.(2) + !c ;\n ctx.h.(3) <- ctx.h.(3) + !d ;\n ctx.h.(4) <- ctx.h.(4) + !e ;\n ctx.h.(5) <- ctx.h.(5) + !f ;\n ctx.h.(6) <- ctx.h.(6) + !g ;\n ctx.h.(7) <- ctx.h.(7) + !h ;\n ()\n\n let feed :\n type a.\n blit:(a -> int -> By.t -> int -> int -> unit) ->\n be32_to_cpu:(a -> int -> int32) ->\n ctx ->\n a ->\n int ->\n int ->\n unit =\n fun ~blit ~be32_to_cpu ctx buf off len ->\n let idx = ref Int64.(to_int (ctx.size land 0x3FL)) in\n let len = ref len in\n let off = ref off in\n let to_fill = 64 - !idx in\n ctx.size <- Int64.add ctx.size (Int64.of_int !len) ;\n if !idx <> 0 && !len >= to_fill\n then (\n blit buf !off ctx.b !idx to_fill ;\n sha256_do_chunk ~be32_to_cpu:By.be32_to_cpu ctx ctx.b 0 ;\n len := !len - to_fill ;\n off := !off + to_fill ;\n idx := 0) ;\n while !len >= 64 do\n sha256_do_chunk ~be32_to_cpu ctx buf !off ;\n len := !len - 64 ;\n off := !off + 64\n done ;\n if !len <> 0 then blit buf !off ctx.b !idx !len ;\n ()\n\n let unsafe_feed_bytes = feed ~blit:By.blit ~be32_to_cpu:By.be32_to_cpu\n\n let unsafe_feed_bigstring =\n feed ~blit:By.blit_from_bigstring ~be32_to_cpu:Bi.be32_to_cpu\n\n let unsafe_get ctx =\n let index = Int64.(to_int (ctx.size land 0x3FL)) in\n let padlen = if index < 56 then 56 - index else 64 + 56 - index in\n let padding = By.init padlen (function 0 -> '\\x80' | _ -> '\\x00') in\n let bits = By.create 8 in\n By.cpu_to_be64 bits 0 Int64.(ctx.size lsl 3) ;\n unsafe_feed_bytes ctx padding 0 padlen ;\n unsafe_feed_bytes ctx bits 0 8 ;\n let res = By.create (8 * 4) in\n for i = 0 to 7 do\n By.cpu_to_be32 res (i * 4) ctx.h.(i)\n done ;\n res\nend\n","module By = Digestif_by\nmodule Bi = Digestif_bi\n\nmodule type S = sig\n type ctx\n\n type kind = [ `SHA224 ]\n\n val init : unit -> ctx\n\n val unsafe_feed_bytes : ctx -> By.t -> int -> int -> unit\n\n val unsafe_feed_bigstring : ctx -> Bi.t -> int -> int -> unit\n\n val unsafe_get : ctx -> By.t\n\n val dup : ctx -> ctx\nend\n\nmodule Unsafe : S = struct\n type kind = [ `SHA224 ]\n\n open Baijiu_sha256.Unsafe\n\n type nonrec ctx = ctx\n\n let init () =\n let b = By.make 128 '\\x00' in\n {\n size = 0L;\n b;\n h =\n [|\n 0xc1059ed8l;\n 0x367cd507l;\n 0x3070dd17l;\n 0xf70e5939l;\n 0xffc00b31l;\n 0x68581511l;\n 0x64f98fa7l;\n 0xbefa4fa4l;\n |];\n }\n\n let unsafe_get ctx =\n let res = unsafe_get ctx in\n By.sub res 0 28\n\n let dup = dup\n\n let unsafe_feed_bytes = unsafe_feed_bytes\n\n let unsafe_feed_bigstring = unsafe_feed_bigstring\nend\n","module By = Digestif_by\nmodule Bi = Digestif_bi\n\nmodule Int64 = struct\n include Int64\n\n let ( lsl ) = Int64.shift_left\n\n let ( lsr ) = Int64.shift_right_logical\n\n let ( asr ) = Int64.shift_right\n\n let ( lor ) = Int64.logor\n\n let ( land ) = Int64.logand\n\n let ( lxor ) = Int64.logxor\n\n let ( + ) = Int64.add\n\n let ror64 a n = (a lsr n) lor (a lsl (64 - n))\n\n let rol64 a n = (a lsl n) lor (a lsr (64 - n))\nend\n\nmodule Unsafe = struct\n type ctx = {\n q : int64 array;\n rsize : int;\n (* block size *)\n mdlen : int;\n (* output size *)\n mutable pt : int;\n }\n\n let dup ctx =\n { q = Array.copy ctx.q; rsize = ctx.rsize; mdlen = ctx.mdlen; pt = ctx.pt }\n\n let init mdlen =\n let rsize = 200 - (2 * mdlen) in\n { q = Array.make 25 0L; rsize; mdlen; pt = 0 }\n\n let keccakf_rounds = 24\n\n let keccaft_rndc : int64 array =\n [|\n 0x0000000000000001L;\n 0x0000000000008082L;\n 0x800000000000808aL;\n 0x8000000080008000L;\n 0x000000000000808bL;\n 0x0000000080000001L;\n 0x8000000080008081L;\n 0x8000000000008009L;\n 0x000000000000008aL;\n 0x0000000000000088L;\n 0x0000000080008009L;\n 0x000000008000000aL;\n 0x000000008000808bL;\n 0x800000000000008bL;\n 0x8000000000008089L;\n 0x8000000000008003L;\n 0x8000000000008002L;\n 0x8000000000000080L;\n 0x000000000000800aL;\n 0x800000008000000aL;\n 0x8000000080008081L;\n 0x8000000000008080L;\n 0x0000000080000001L;\n 0x8000000080008008L;\n |]\n\n let keccaft_rotc : int array =\n [|\n 1;\n 3;\n 6;\n 10;\n 15;\n 21;\n 28;\n 36;\n 45;\n 55;\n 2;\n 14;\n 27;\n 41;\n 56;\n 8;\n 25;\n 43;\n 62;\n 18;\n 39;\n 61;\n 20;\n 44;\n |]\n\n let keccakf_piln : int array =\n [|\n 10;\n 7;\n 11;\n 17;\n 18;\n 3;\n 5;\n 16;\n 8;\n 21;\n 24;\n 4;\n 15;\n 23;\n 19;\n 13;\n 12;\n 2;\n 20;\n 14;\n 22;\n 9;\n 6;\n 1;\n |]\n\n let swap64 = if Sys.big_endian then By.swap64 else fun x -> x\n\n let sha3_keccakf (q : int64 array) =\n if Sys.big_endian then Array.iteri (fun i sti -> q.(i) <- swap64 sti) q ;\n\n for r = 0 to keccakf_rounds - 1 do\n let ( lxor ) = Int64.( lxor ) in\n let lnot = Int64.lognot in\n let ( land ) = Int64.( land ) in\n (* Theta *)\n let bc =\n Array.init 5 (fun i ->\n q.(i) lxor q.(i + 5) lxor q.(i + 10) lxor q.(i + 15) lxor q.(i + 20))\n in\n for i = 0 to 4 do\n let t = bc.((i + 4) mod 5) lxor Int64.rol64 bc.((i + 1) mod 5) 1 in\n for k = 0 to 4 do\n let j = k * 5 in\n q.(j + i) <- q.(j + i) lxor t\n done\n done ;\n\n (* Rho Pi *)\n let t = ref q.(1) in\n let _ =\n Array.iteri\n (fun i rotc ->\n let j = keccakf_piln.(i) in\n bc.(0) <- q.(j) ;\n q.(j) <- Int64.rol64 !t rotc ;\n t := bc.(0))\n keccaft_rotc in\n\n (* Chi *)\n for k = 0 to 4 do\n let j = k * 5 in\n let bc = Array.init 5 (fun i -> q.(j + i)) in\n for i = 0 to 4 do\n q.(j + i) <-\n q.(j + i) lxor (lnot bc.((i + 1) mod 5) land bc.((i + 2) mod 5))\n done\n done ;\n\n (* Iota *)\n q.(0) <- q.(0) lxor keccaft_rndc.(r)\n done ;\n\n if Sys.big_endian then Array.iteri (fun i sti -> q.(i) <- swap64 sti) q\n\n let masks =\n [|\n 0xffffffffffffff00L;\n 0xffffffffffff00ffL;\n 0xffffffffff00ffffL;\n 0xffffffff00ffffffL;\n 0xffffff00ffffffffL;\n 0xffff00ffffffffffL;\n 0xff00ffffffffffffL;\n 0x00ffffffffffffffL;\n |]\n\n let feed :\n type a. get_uint8:(a -> int -> int) -> ctx -> a -> int -> int -> unit =\n fun ~get_uint8 ctx buf off len ->\n let ( && ) = ( land ) in\n\n let ( lxor ) = Int64.( lxor ) in\n let ( land ) = Int64.( land ) in\n let ( lor ) = Int64.( lor ) in\n let ( lsr ) = Int64.( lsr ) in\n let ( lsl ) = Int64.( lsl ) in\n\n let j = ref ctx.pt in\n\n for i = 0 to len - 1 do\n let v =\n (ctx.q.(!j / 8) land (0xffL lsl ((!j && 0x7) * 8))) lsr ((!j && 0x7) * 8)\n in\n let v = v lxor Int64.of_int (get_uint8 buf (off + i)) in\n ctx.q.(!j / 8) <-\n ctx.q.(!j / 8) land masks.(!j && 0x7) lor (v lsl ((!j && 0x7) * 8)) ;\n incr j ;\n if !j >= ctx.rsize\n then (\n sha3_keccakf ctx.q ;\n j := 0)\n done ;\n\n ctx.pt <- !j\n\n let unsafe_feed_bytes ctx buf off len =\n let get_uint8 buf off = Char.code (By.get buf off) in\n feed ~get_uint8 ctx buf off len\n\n let unsafe_feed_bigstring : ctx -> Bi.t -> int -> int -> unit =\n fun ctx buf off len ->\n let get_uint8 buf off = Char.code (Bi.get buf off) in\n feed ~get_uint8 ctx buf off len\n\n let unsafe_get ctx =\n let ( && ) = ( land ) in\n\n let ( lxor ) = Int64.( lxor ) in\n let ( lsl ) = Int64.( lsl ) in\n\n let v = ctx.q.(ctx.pt / 8) in\n let v = v lxor (0x6L lsl ((ctx.pt && 0x7) * 8)) in\n ctx.q.(ctx.pt / 8) <- v ;\n\n let v = ctx.q.((ctx.rsize - 1) / 8) in\n let v = v lxor (0x80L lsl (((ctx.rsize - 1) && 0x7) * 8)) in\n ctx.q.((ctx.rsize - 1) / 8) <- v ;\n\n sha3_keccakf ctx.q ;\n\n (* Get hash *)\n (* if the hash size in bytes is not a multiple of 8 (meaning it is\n not composed of whole int64 words, like for sha3_224), we\n extract the whole last int64 word from the state [ctx.st] and\n cut the hash at the right size after conversion to bytes. *)\n let n =\n let r = ctx.mdlen mod 8 in\n ctx.mdlen + if r = 0 then 0 else 8 - r in\n\n let hash = By.create n in\n for i = 0 to (n / 8) - 1 do\n By.unsafe_set_64 hash (i * 8) ctx.q.(i)\n done ;\n\n By.sub hash 0 ctx.mdlen\nend\n","module By = Digestif_by\nmodule Bi = Digestif_bi\n\nmodule type S = sig\n type ctx\n\n type kind = [ `SHA3_512 ]\n\n val init : unit -> ctx\n\n val unsafe_feed_bytes : ctx -> By.t -> int -> int -> unit\n\n val unsafe_feed_bigstring : ctx -> Bi.t -> int -> int -> unit\n\n val unsafe_get : ctx -> By.t\n\n val dup : ctx -> ctx\nend\n\nmodule Unsafe : S = struct\n type kind = [ `SHA3_512 ]\n\n open Baijiu_sha3.Unsafe\n\n type nonrec ctx = ctx\n\n let init () = Baijiu_sha3.Unsafe.init 64\n\n let unsafe_get = unsafe_get\n\n let dup = dup\n\n let unsafe_feed_bytes = unsafe_feed_bytes\n\n let unsafe_feed_bigstring = unsafe_feed_bigstring\nend\n","module By = Digestif_by\nmodule Bi = Digestif_bi\n\nmodule Int64 = struct\n include Int64\n\n let ( lsl ) = Int64.shift_left\n\n let ( lsr ) = Int64.shift_right_logical\n\n let ( asr ) = Int64.shift_right\n\n let ( lor ) = Int64.logor\n\n let ( land ) = Int64.logand\n\n let ( lxor ) = Int64.logxor\n\n let ( + ) = Int64.add\n\n let ror64 a n = (a lsr n) lor (a lsl (64 - n))\n\n let rol64 a n = (a lsl n) lor (a lsr (64 - n))\nend\n\nmodule type S = sig\n type kind = [ `SHA512 ]\n\n type ctx = { mutable size : int64 array; b : Bytes.t; h : int64 array }\n\n val init : unit -> ctx\n\n val unsafe_feed_bytes : ctx -> By.t -> int -> int -> unit\n\n val unsafe_feed_bigstring : ctx -> Bi.t -> int -> int -> unit\n\n val unsafe_get : ctx -> By.t\n\n val dup : ctx -> ctx\nend\n\nmodule Unsafe : S = struct\n type kind = [ `SHA512 ]\n\n type ctx = { mutable size : int64 array; b : Bytes.t; h : int64 array }\n\n let dup ctx =\n { size = Array.copy ctx.size; b = By.copy ctx.b; h = Array.copy ctx.h }\n\n let init () =\n let b = By.make 128 '\\x00' in\n {\n size = [| 0L; 0L |];\n b;\n h =\n [|\n 0x6a09e667f3bcc908L;\n 0xbb67ae8584caa73bL;\n 0x3c6ef372fe94f82bL;\n 0xa54ff53a5f1d36f1L;\n 0x510e527fade682d1L;\n 0x9b05688c2b3e6c1fL;\n 0x1f83d9abfb41bd6bL;\n 0x5be0cd19137e2179L;\n |];\n }\n\n let k =\n [|\n 0x428a2f98d728ae22L;\n 0x7137449123ef65cdL;\n 0xb5c0fbcfec4d3b2fL;\n 0xe9b5dba58189dbbcL;\n 0x3956c25bf348b538L;\n 0x59f111f1b605d019L;\n 0x923f82a4af194f9bL;\n 0xab1c5ed5da6d8118L;\n 0xd807aa98a3030242L;\n 0x12835b0145706fbeL;\n 0x243185be4ee4b28cL;\n 0x550c7dc3d5ffb4e2L;\n 0x72be5d74f27b896fL;\n 0x80deb1fe3b1696b1L;\n 0x9bdc06a725c71235L;\n 0xc19bf174cf692694L;\n 0xe49b69c19ef14ad2L;\n 0xefbe4786384f25e3L;\n 0x0fc19dc68b8cd5b5L;\n 0x240ca1cc77ac9c65L;\n 0x2de92c6f592b0275L;\n 0x4a7484aa6ea6e483L;\n 0x5cb0a9dcbd41fbd4L;\n 0x76f988da831153b5L;\n 0x983e5152ee66dfabL;\n 0xa831c66d2db43210L;\n 0xb00327c898fb213fL;\n 0xbf597fc7beef0ee4L;\n 0xc6e00bf33da88fc2L;\n 0xd5a79147930aa725L;\n 0x06ca6351e003826fL;\n 0x142929670a0e6e70L;\n 0x27b70a8546d22ffcL;\n 0x2e1b21385c26c926L;\n 0x4d2c6dfc5ac42aedL;\n 0x53380d139d95b3dfL;\n 0x650a73548baf63deL;\n 0x766a0abb3c77b2a8L;\n 0x81c2c92e47edaee6L;\n 0x92722c851482353bL;\n 0xa2bfe8a14cf10364L;\n 0xa81a664bbc423001L;\n 0xc24b8b70d0f89791L;\n 0xc76c51a30654be30L;\n 0xd192e819d6ef5218L;\n 0xd69906245565a910L;\n 0xf40e35855771202aL;\n 0x106aa07032bbd1b8L;\n 0x19a4c116b8d2d0c8L;\n 0x1e376c085141ab53L;\n 0x2748774cdf8eeb99L;\n 0x34b0bcb5e19b48a8L;\n 0x391c0cb3c5c95a63L;\n 0x4ed8aa4ae3418acbL;\n 0x5b9cca4f7763e373L;\n 0x682e6ff3d6b2b8a3L;\n 0x748f82ee5defb2fcL;\n 0x78a5636f43172f60L;\n 0x84c87814a1f0ab72L;\n 0x8cc702081a6439ecL;\n 0x90befffa23631e28L;\n 0xa4506cebde82bde9L;\n 0xbef9a3f7b2c67915L;\n 0xc67178f2e372532bL;\n 0xca273eceea26619cL;\n 0xd186b8c721c0c207L;\n 0xeada7dd6cde0eb1eL;\n 0xf57d4f7fee6ed178L;\n 0x06f067aa72176fbaL;\n 0x0a637dc5a2c898a6L;\n 0x113f9804bef90daeL;\n 0x1b710b35131c471bL;\n 0x28db77f523047d84L;\n 0x32caab7b40c72493L;\n 0x3c9ebe0a15c9bebcL;\n 0x431d67c49c100d4cL;\n 0x4cc5d4becb3e42b6L;\n 0x597f299cfc657e2aL;\n 0x5fcb6fab3ad6faecL;\n 0x6c44198c4a475817L;\n |]\n\n let e0 x = Int64.(ror64 x 28 lxor ror64 x 34 lxor ror64 x 39)\n\n let e1 x = Int64.(ror64 x 14 lxor ror64 x 18 lxor ror64 x 41)\n\n let s0 x = Int64.(ror64 x 1 lxor ror64 x 8 lxor (x lsr 7))\n\n let s1 x = Int64.(ror64 x 19 lxor ror64 x 61 lxor (x lsr 6))\n\n let sha512_do_chunk :\n type a. be64_to_cpu:(a -> int -> int64) -> ctx -> a -> int -> unit =\n fun ~be64_to_cpu ctx buf off ->\n let a, b, c, d, e, f, g, h, t1, t2 =\n ( ref ctx.h.(0),\n ref ctx.h.(1),\n ref ctx.h.(2),\n ref ctx.h.(3),\n ref ctx.h.(4),\n ref ctx.h.(5),\n ref ctx.h.(6),\n ref ctx.h.(7),\n ref 0L,\n ref 0L ) in\n let w = Array.make 80 0L in\n for i = 0 to 15 do\n w.(i) <- be64_to_cpu buf (off + (i * 8))\n done ;\n let ( -- ) a b = a - b in\n for i = 16 to 79 do\n w.(i) <- Int64.(s1 w.(i -- 2) + w.(i -- 7) + s0 w.(i -- 15) + w.(i -- 16))\n done ;\n let round a b c d e f g h k w =\n let open Int64 in\n t1 := !h + e1 !e + (!g lxor (!e land (!f lxor !g))) + k + w ;\n t2 := e0 !a + (!a land !b lor (!c land (!a lor !b))) ;\n d := !d + !t1 ;\n h := !t1 + !t2 in\n for i = 0 to 9 do\n round a b c d e f g h k.((i * 8) + 0) w.((i * 8) + 0) ;\n round h a b c d e f g k.((i * 8) + 1) w.((i * 8) + 1) ;\n round g h a b c d e f k.((i * 8) + 2) w.((i * 8) + 2) ;\n round f g h a b c d e k.((i * 8) + 3) w.((i * 8) + 3) ;\n round e f g h a b c d k.((i * 8) + 4) w.((i * 8) + 4) ;\n round d e f g h a b c k.((i * 8) + 5) w.((i * 8) + 5) ;\n round c d e f g h a b k.((i * 8) + 6) w.((i * 8) + 6) ;\n round b c d e f g h a k.((i * 8) + 7) w.((i * 8) + 7)\n done ;\n let open Int64 in\n ctx.h.(0) <- ctx.h.(0) + !a ;\n ctx.h.(1) <- ctx.h.(1) + !b ;\n ctx.h.(2) <- ctx.h.(2) + !c ;\n ctx.h.(3) <- ctx.h.(3) + !d ;\n ctx.h.(4) <- ctx.h.(4) + !e ;\n ctx.h.(5) <- ctx.h.(5) + !f ;\n ctx.h.(6) <- ctx.h.(6) + !g ;\n ctx.h.(7) <- ctx.h.(7) + !h ;\n ()\n\n let feed :\n type a.\n blit:(a -> int -> By.t -> int -> int -> unit) ->\n be64_to_cpu:(a -> int -> int64) ->\n ctx ->\n a ->\n int ->\n int ->\n unit =\n fun ~blit ~be64_to_cpu ctx buf off len ->\n let idx = ref Int64.(to_int (ctx.size.(0) land 0x7FL)) in\n let len = ref len in\n let off = ref off in\n let to_fill = 128 - !idx in\n ctx.size.(0) <- Int64.add ctx.size.(0) (Int64.of_int !len) ;\n if ctx.size.(0) < Int64.of_int !len\n then ctx.size.(1) <- Int64.succ ctx.size.(1) ;\n if !idx <> 0 && !len >= to_fill\n then (\n blit buf !off ctx.b !idx to_fill ;\n sha512_do_chunk ~be64_to_cpu:By.be64_to_cpu ctx ctx.b 0 ;\n len := !len - to_fill ;\n off := !off + to_fill ;\n idx := 0) ;\n while !len >= 128 do\n sha512_do_chunk ~be64_to_cpu ctx buf !off ;\n len := !len - 128 ;\n off := !off + 128\n done ;\n if !len <> 0 then blit buf !off ctx.b !idx !len ;\n ()\n\n let unsafe_feed_bytes = feed ~blit:By.blit ~be64_to_cpu:By.be64_to_cpu\n\n let unsafe_feed_bigstring =\n feed ~blit:By.blit_from_bigstring ~be64_to_cpu:Bi.be64_to_cpu\n\n let unsafe_get ctx =\n let index = Int64.(to_int (ctx.size.(0) land 0x7FL)) in\n let padlen = if index < 112 then 112 - index else 128 + 112 - index in\n let padding = By.init padlen (function 0 -> '\\x80' | _ -> '\\x00') in\n let bits = By.create 16 in\n By.cpu_to_be64 bits 0 Int64.((ctx.size.(1) lsl 3) lor (ctx.size.(0) lsr 61)) ;\n By.cpu_to_be64 bits 8 Int64.(ctx.size.(0) lsl 3) ;\n unsafe_feed_bytes ctx padding 0 padlen ;\n unsafe_feed_bytes ctx bits 0 16 ;\n let res = By.create (8 * 8) in\n for i = 0 to 7 do\n By.cpu_to_be64 res (i * 8) ctx.h.(i)\n done ;\n res\nend\n","module By = Digestif_by\nmodule Bi = Digestif_bi\n\nmodule type S = sig\n type ctx\n\n type kind = [ `SHA384 ]\n\n val init : unit -> ctx\n\n val unsafe_feed_bytes : ctx -> By.t -> int -> int -> unit\n\n val unsafe_feed_bigstring : ctx -> Bi.t -> int -> int -> unit\n\n val unsafe_get : ctx -> By.t\n\n val dup : ctx -> ctx\nend\n\nmodule Unsafe : S = struct\n type kind = [ `SHA384 ]\n\n open Baijiu_sha512.Unsafe\n\n type nonrec ctx = ctx\n\n let init () =\n let b = By.make 128 '\\x00' in\n {\n size = [| 0L; 0L |];\n b;\n h =\n [|\n 0xcbbb9d5dc1059ed8L;\n 0x629a292a367cd507L;\n 0x9159015a3070dd17L;\n 0x152fecd8f70e5939L;\n 0x67332667ffc00b31L;\n 0x8eb44a8768581511L;\n 0xdb0c2e0d64f98fa7L;\n 0x47b5481dbefa4fa4L;\n |];\n }\n\n let unsafe_get ctx =\n let res = unsafe_get ctx in\n By.sub res 0 48\n\n let dup = dup\n\n let unsafe_feed_bytes = unsafe_feed_bytes\n\n let unsafe_feed_bigstring = unsafe_feed_bigstring\nend\n","module By = Digestif_by\nmodule Bi = Digestif_bi\n\nmodule type S = sig\n type ctx\n\n type kind = [ `SHA3_224 ]\n\n val init : unit -> ctx\n\n val unsafe_feed_bytes : ctx -> By.t -> int -> int -> unit\n\n val unsafe_feed_bigstring : ctx -> Bi.t -> int -> int -> unit\n\n val unsafe_get : ctx -> By.t\n\n val dup : ctx -> ctx\nend\n\nmodule Unsafe : S = struct\n type kind = [ `SHA3_224 ]\n\n open Baijiu_sha3.Unsafe\n\n type nonrec ctx = ctx\n\n let init () = Baijiu_sha3.Unsafe.init 28\n\n let unsafe_get = unsafe_get\n\n let dup = dup\n\n let unsafe_feed_bytes = unsafe_feed_bytes\n\n let unsafe_feed_bigstring = unsafe_feed_bigstring\nend\n","module By = Digestif_by\nmodule Bi = Digestif_bi\n\nmodule type S = sig\n type ctx\n\n type kind = [ `SHA3_256 ]\n\n val init : unit -> ctx\n\n val unsafe_feed_bytes : ctx -> By.t -> int -> int -> unit\n\n val unsafe_feed_bigstring : ctx -> Bi.t -> int -> int -> unit\n\n val unsafe_get : ctx -> By.t\n\n val dup : ctx -> ctx\nend\n\nmodule Unsafe : S = struct\n type kind = [ `SHA3_256 ]\n\n open Baijiu_sha3.Unsafe\n\n type nonrec ctx = ctx\n\n let init () = Baijiu_sha3.Unsafe.init 32\n\n let unsafe_get = unsafe_get\n\n let dup = dup\n\n let unsafe_feed_bytes = unsafe_feed_bytes\n\n let unsafe_feed_bigstring = unsafe_feed_bigstring\nend\n","module By = Digestif_by\nmodule Bi = Digestif_bi\n\nmodule type S = sig\n type ctx\n\n type kind = [ `SHA3_384 ]\n\n val init : unit -> ctx\n\n val unsafe_feed_bytes : ctx -> By.t -> int -> int -> unit\n\n val unsafe_feed_bigstring : ctx -> Bi.t -> int -> int -> unit\n\n val unsafe_get : ctx -> By.t\n\n val dup : ctx -> ctx\nend\n\nmodule Unsafe : S = struct\n type kind = [ `SHA3_384 ]\n\n open Baijiu_sha3.Unsafe\n\n type nonrec ctx = ctx\n\n let init () = Baijiu_sha3.Unsafe.init 48\n\n let unsafe_get = unsafe_get\n\n let dup = dup\n\n let unsafe_feed_bytes = unsafe_feed_bytes\n\n let unsafe_feed_bigstring = unsafe_feed_bigstring\nend\n","module By = Digestif_by\nmodule Bi = Digestif_bi\n\nmodule Int64 = struct\n include Int64\n\n let ( lsl ) = Int64.shift_left\n\n let ( lsr ) = Int64.shift_right_logical\n\n let ( asr ) = Int64.shift_right\n\n let ( lor ) = Int64.logor\n\n let ( land ) = Int64.logand\n\n let ( lxor ) = Int64.logxor\n\n let ( + ) = Int64.add\n\n let ror64 a n = (a lsr n) lor (a lsl (64 - n))\n\n let rol64 a n = (a lsl n) lor (a lsr (64 - n))\nend\n\nmodule type S = sig\n type kind = [ `WHIRLPOOL ]\n\n type ctx = { mutable size : int64; b : Bytes.t; h : int64 array }\n\n val init : unit -> ctx\n\n val unsafe_feed_bytes : ctx -> By.t -> int -> int -> unit\n\n val unsafe_feed_bigstring : ctx -> Bi.t -> int -> int -> unit\n\n val unsafe_get : ctx -> By.t\n\n val dup : ctx -> ctx\nend\n\nmodule Unsafe : S = struct\n type kind = [ `WHIRLPOOL ]\n\n type ctx = { mutable size : int64; b : Bytes.t; h : int64 array }\n\n let dup ctx = { size = ctx.size; b = By.copy ctx.b; h = Array.copy ctx.h }\n\n let init () =\n let b = By.make 64 '\\x00' in\n { size = 0L; b; h = Array.make 8 Int64.zero }\n\n let k =\n [|\n [|\n 0x18186018c07830d8L;\n 0x23238c2305af4626L;\n 0xc6c63fc67ef991b8L;\n 0xe8e887e8136fcdfbL;\n 0x878726874ca113cbL;\n 0xb8b8dab8a9626d11L;\n 0x0101040108050209L;\n 0x4f4f214f426e9e0dL;\n 0x3636d836adee6c9bL;\n 0xa6a6a2a6590451ffL;\n 0xd2d26fd2debdb90cL;\n 0xf5f5f3f5fb06f70eL;\n 0x7979f979ef80f296L;\n 0x6f6fa16f5fcede30L;\n 0x91917e91fcef3f6dL;\n 0x52525552aa07a4f8L;\n 0x60609d6027fdc047L;\n 0xbcbccabc89766535L;\n 0x9b9b569baccd2b37L;\n 0x8e8e028e048c018aL;\n 0xa3a3b6a371155bd2L;\n 0x0c0c300c603c186cL;\n 0x7b7bf17bff8af684L;\n 0x3535d435b5e16a80L;\n 0x1d1d741de8693af5L;\n 0xe0e0a7e05347ddb3L;\n 0xd7d77bd7f6acb321L;\n 0xc2c22fc25eed999cL;\n 0x2e2eb82e6d965c43L;\n 0x4b4b314b627a9629L;\n 0xfefedffea321e15dL;\n 0x575741578216aed5L;\n 0x15155415a8412abdL;\n 0x7777c1779fb6eee8L;\n 0x3737dc37a5eb6e92L;\n 0xe5e5b3e57b56d79eL;\n 0x9f9f469f8cd92313L;\n 0xf0f0e7f0d317fd23L;\n 0x4a4a354a6a7f9420L;\n 0xdada4fda9e95a944L;\n 0x58587d58fa25b0a2L;\n 0xc9c903c906ca8fcfL;\n 0x2929a429558d527cL;\n 0x0a0a280a5022145aL;\n 0xb1b1feb1e14f7f50L;\n 0xa0a0baa0691a5dc9L;\n 0x6b6bb16b7fdad614L;\n 0x85852e855cab17d9L;\n 0xbdbdcebd8173673cL;\n 0x5d5d695dd234ba8fL;\n 0x1010401080502090L;\n 0xf4f4f7f4f303f507L;\n 0xcbcb0bcb16c08bddL;\n 0x3e3ef83eedc67cd3L;\n 0x0505140528110a2dL;\n 0x676781671fe6ce78L;\n 0xe4e4b7e47353d597L;\n 0x27279c2725bb4e02L;\n 0x4141194132588273L;\n 0x8b8b168b2c9d0ba7L;\n 0xa7a7a6a7510153f6L;\n 0x7d7de97dcf94fab2L;\n 0x95956e95dcfb3749L;\n 0xd8d847d88e9fad56L;\n 0xfbfbcbfb8b30eb70L;\n 0xeeee9fee2371c1cdL;\n 0x7c7ced7cc791f8bbL;\n 0x6666856617e3cc71L;\n 0xdddd53dda68ea77bL;\n 0x17175c17b84b2eafL;\n 0x4747014702468e45L;\n 0x9e9e429e84dc211aL;\n 0xcaca0fca1ec589d4L;\n 0x2d2db42d75995a58L;\n 0xbfbfc6bf9179632eL;\n 0x07071c07381b0e3fL;\n 0xadad8ead012347acL;\n 0x5a5a755aea2fb4b0L;\n 0x838336836cb51befL;\n 0x3333cc3385ff66b6L;\n 0x636391633ff2c65cL;\n 0x02020802100a0412L;\n 0xaaaa92aa39384993L;\n 0x7171d971afa8e2deL;\n 0xc8c807c80ecf8dc6L;\n 0x19196419c87d32d1L;\n 0x494939497270923bL;\n 0xd9d943d9869aaf5fL;\n 0xf2f2eff2c31df931L;\n 0xe3e3abe34b48dba8L;\n 0x5b5b715be22ab6b9L;\n 0x88881a8834920dbcL;\n 0x9a9a529aa4c8293eL;\n 0x262698262dbe4c0bL;\n 0x3232c8328dfa64bfL;\n 0xb0b0fab0e94a7d59L;\n 0xe9e983e91b6acff2L;\n 0x0f0f3c0f78331e77L;\n 0xd5d573d5e6a6b733L;\n 0x80803a8074ba1df4L;\n 0xbebec2be997c6127L;\n 0xcdcd13cd26de87ebL;\n 0x3434d034bde46889L;\n 0x48483d487a759032L;\n 0xffffdbffab24e354L;\n 0x7a7af57af78ff48dL;\n 0x90907a90f4ea3d64L;\n 0x5f5f615fc23ebe9dL;\n 0x202080201da0403dL;\n 0x6868bd6867d5d00fL;\n 0x1a1a681ad07234caL;\n 0xaeae82ae192c41b7L;\n 0xb4b4eab4c95e757dL;\n 0x54544d549a19a8ceL;\n 0x93937693ece53b7fL;\n 0x222288220daa442fL;\n 0x64648d6407e9c863L;\n 0xf1f1e3f1db12ff2aL;\n 0x7373d173bfa2e6ccL;\n 0x12124812905a2482L;\n 0x40401d403a5d807aL;\n 0x0808200840281048L;\n 0xc3c32bc356e89b95L;\n 0xecec97ec337bc5dfL;\n 0xdbdb4bdb9690ab4dL;\n 0xa1a1bea1611f5fc0L;\n 0x8d8d0e8d1c830791L;\n 0x3d3df43df5c97ac8L;\n 0x97976697ccf1335bL;\n 0x0000000000000000L;\n 0xcfcf1bcf36d483f9L;\n 0x2b2bac2b4587566eL;\n 0x7676c57697b3ece1L;\n 0x8282328264b019e6L;\n 0xd6d67fd6fea9b128L;\n 0x1b1b6c1bd87736c3L;\n 0xb5b5eeb5c15b7774L;\n 0xafaf86af112943beL;\n 0x6a6ab56a77dfd41dL;\n 0x50505d50ba0da0eaL;\n 0x45450945124c8a57L;\n 0xf3f3ebf3cb18fb38L;\n 0x3030c0309df060adL;\n 0xefef9bef2b74c3c4L;\n 0x3f3ffc3fe5c37edaL;\n 0x55554955921caac7L;\n 0xa2a2b2a2791059dbL;\n 0xeaea8fea0365c9e9L;\n 0x656589650fecca6aL;\n 0xbabad2bab9686903L;\n 0x2f2fbc2f65935e4aL;\n 0xc0c027c04ee79d8eL;\n 0xdede5fdebe81a160L;\n 0x1c1c701ce06c38fcL;\n 0xfdfdd3fdbb2ee746L;\n 0x4d4d294d52649a1fL;\n 0x92927292e4e03976L;\n 0x7575c9758fbceafaL;\n 0x06061806301e0c36L;\n 0x8a8a128a249809aeL;\n 0xb2b2f2b2f940794bL;\n 0xe6e6bfe66359d185L;\n 0x0e0e380e70361c7eL;\n 0x1f1f7c1ff8633ee7L;\n 0x6262956237f7c455L;\n 0xd4d477d4eea3b53aL;\n 0xa8a89aa829324d81L;\n 0x96966296c4f43152L;\n 0xf9f9c3f99b3aef62L;\n 0xc5c533c566f697a3L;\n 0x2525942535b14a10L;\n 0x59597959f220b2abL;\n 0x84842a8454ae15d0L;\n 0x7272d572b7a7e4c5L;\n 0x3939e439d5dd72ecL;\n 0x4c4c2d4c5a619816L;\n 0x5e5e655eca3bbc94L;\n 0x7878fd78e785f09fL;\n 0x3838e038ddd870e5L;\n 0x8c8c0a8c14860598L;\n 0xd1d163d1c6b2bf17L;\n 0xa5a5aea5410b57e4L;\n 0xe2e2afe2434dd9a1L;\n 0x616199612ff8c24eL;\n 0xb3b3f6b3f1457b42L;\n 0x2121842115a54234L;\n 0x9c9c4a9c94d62508L;\n 0x1e1e781ef0663ceeL;\n 0x4343114322528661L;\n 0xc7c73bc776fc93b1L;\n 0xfcfcd7fcb32be54fL;\n 0x0404100420140824L;\n 0x51515951b208a2e3L;\n 0x99995e99bcc72f25L;\n 0x6d6da96d4fc4da22L;\n 0x0d0d340d68391a65L;\n 0xfafacffa8335e979L;\n 0xdfdf5bdfb684a369L;\n 0x7e7ee57ed79bfca9L;\n 0x242490243db44819L;\n 0x3b3bec3bc5d776feL;\n 0xabab96ab313d4b9aL;\n 0xcece1fce3ed181f0L;\n 0x1111441188552299L;\n 0x8f8f068f0c890383L;\n 0x4e4e254e4a6b9c04L;\n 0xb7b7e6b7d1517366L;\n 0xebeb8beb0b60cbe0L;\n 0x3c3cf03cfdcc78c1L;\n 0x81813e817cbf1ffdL;\n 0x94946a94d4fe3540L;\n 0xf7f7fbf7eb0cf31cL;\n 0xb9b9deb9a1676f18L;\n 0x13134c13985f268bL;\n 0x2c2cb02c7d9c5851L;\n 0xd3d36bd3d6b8bb05L;\n 0xe7e7bbe76b5cd38cL;\n 0x6e6ea56e57cbdc39L;\n 0xc4c437c46ef395aaL;\n 0x03030c03180f061bL;\n 0x565645568a13acdcL;\n 0x44440d441a49885eL;\n 0x7f7fe17fdf9efea0L;\n 0xa9a99ea921374f88L;\n 0x2a2aa82a4d825467L;\n 0xbbbbd6bbb16d6b0aL;\n 0xc1c123c146e29f87L;\n 0x53535153a202a6f1L;\n 0xdcdc57dcae8ba572L;\n 0x0b0b2c0b58271653L;\n 0x9d9d4e9d9cd32701L;\n 0x6c6cad6c47c1d82bL;\n 0x3131c43195f562a4L;\n 0x7474cd7487b9e8f3L;\n 0xf6f6fff6e309f115L;\n 0x464605460a438c4cL;\n 0xacac8aac092645a5L;\n 0x89891e893c970fb5L;\n 0x14145014a04428b4L;\n 0xe1e1a3e15b42dfbaL;\n 0x16165816b04e2ca6L;\n 0x3a3ae83acdd274f7L;\n 0x6969b9696fd0d206L;\n 0x09092409482d1241L;\n 0x7070dd70a7ade0d7L;\n 0xb6b6e2b6d954716fL;\n 0xd0d067d0ceb7bd1eL;\n 0xeded93ed3b7ec7d6L;\n 0xcccc17cc2edb85e2L;\n 0x424215422a578468L;\n 0x98985a98b4c22d2cL;\n 0xa4a4aaa4490e55edL;\n 0x2828a0285d885075L;\n 0x5c5c6d5cda31b886L;\n 0xf8f8c7f8933fed6bL;\n 0x8686228644a411c2L;\n |];\n [|\n 0xd818186018c07830L;\n 0x2623238c2305af46L;\n 0xb8c6c63fc67ef991L;\n 0xfbe8e887e8136fcdL;\n 0xcb878726874ca113L;\n 0x11b8b8dab8a9626dL;\n 0x0901010401080502L;\n 0x0d4f4f214f426e9eL;\n 0x9b3636d836adee6cL;\n 0xffa6a6a2a6590451L;\n 0x0cd2d26fd2debdb9L;\n 0x0ef5f5f3f5fb06f7L;\n 0x967979f979ef80f2L;\n 0x306f6fa16f5fcedeL;\n 0x6d91917e91fcef3fL;\n 0xf852525552aa07a4L;\n 0x4760609d6027fdc0L;\n 0x35bcbccabc897665L;\n 0x379b9b569baccd2bL;\n 0x8a8e8e028e048c01L;\n 0xd2a3a3b6a371155bL;\n 0x6c0c0c300c603c18L;\n 0x847b7bf17bff8af6L;\n 0x803535d435b5e16aL;\n 0xf51d1d741de8693aL;\n 0xb3e0e0a7e05347ddL;\n 0x21d7d77bd7f6acb3L;\n 0x9cc2c22fc25eed99L;\n 0x432e2eb82e6d965cL;\n 0x294b4b314b627a96L;\n 0x5dfefedffea321e1L;\n 0xd5575741578216aeL;\n 0xbd15155415a8412aL;\n 0xe87777c1779fb6eeL;\n 0x923737dc37a5eb6eL;\n 0x9ee5e5b3e57b56d7L;\n 0x139f9f469f8cd923L;\n 0x23f0f0e7f0d317fdL;\n 0x204a4a354a6a7f94L;\n 0x44dada4fda9e95a9L;\n 0xa258587d58fa25b0L;\n 0xcfc9c903c906ca8fL;\n 0x7c2929a429558d52L;\n 0x5a0a0a280a502214L;\n 0x50b1b1feb1e14f7fL;\n 0xc9a0a0baa0691a5dL;\n 0x146b6bb16b7fdad6L;\n 0xd985852e855cab17L;\n 0x3cbdbdcebd817367L;\n 0x8f5d5d695dd234baL;\n 0x9010104010805020L;\n 0x07f4f4f7f4f303f5L;\n 0xddcbcb0bcb16c08bL;\n 0xd33e3ef83eedc67cL;\n 0x2d0505140528110aL;\n 0x78676781671fe6ceL;\n 0x97e4e4b7e47353d5L;\n 0x0227279c2725bb4eL;\n 0x7341411941325882L;\n 0xa78b8b168b2c9d0bL;\n 0xf6a7a7a6a7510153L;\n 0xb27d7de97dcf94faL;\n 0x4995956e95dcfb37L;\n 0x56d8d847d88e9fadL;\n 0x70fbfbcbfb8b30ebL;\n 0xcdeeee9fee2371c1L;\n 0xbb7c7ced7cc791f8L;\n 0x716666856617e3ccL;\n 0x7bdddd53dda68ea7L;\n 0xaf17175c17b84b2eL;\n 0x454747014702468eL;\n 0x1a9e9e429e84dc21L;\n 0xd4caca0fca1ec589L;\n 0x582d2db42d75995aL;\n 0x2ebfbfc6bf917963L;\n 0x3f07071c07381b0eL;\n 0xacadad8ead012347L;\n 0xb05a5a755aea2fb4L;\n 0xef838336836cb51bL;\n 0xb63333cc3385ff66L;\n 0x5c636391633ff2c6L;\n 0x1202020802100a04L;\n 0x93aaaa92aa393849L;\n 0xde7171d971afa8e2L;\n 0xc6c8c807c80ecf8dL;\n 0xd119196419c87d32L;\n 0x3b49493949727092L;\n 0x5fd9d943d9869aafL;\n 0x31f2f2eff2c31df9L;\n 0xa8e3e3abe34b48dbL;\n 0xb95b5b715be22ab6L;\n 0xbc88881a8834920dL;\n 0x3e9a9a529aa4c829L;\n 0x0b262698262dbe4cL;\n 0xbf3232c8328dfa64L;\n 0x59b0b0fab0e94a7dL;\n 0xf2e9e983e91b6acfL;\n 0x770f0f3c0f78331eL;\n 0x33d5d573d5e6a6b7L;\n 0xf480803a8074ba1dL;\n 0x27bebec2be997c61L;\n 0xebcdcd13cd26de87L;\n 0x893434d034bde468L;\n 0x3248483d487a7590L;\n 0x54ffffdbffab24e3L;\n 0x8d7a7af57af78ff4L;\n 0x6490907a90f4ea3dL;\n 0x9d5f5f615fc23ebeL;\n 0x3d202080201da040L;\n 0x0f6868bd6867d5d0L;\n 0xca1a1a681ad07234L;\n 0xb7aeae82ae192c41L;\n 0x7db4b4eab4c95e75L;\n 0xce54544d549a19a8L;\n 0x7f93937693ece53bL;\n 0x2f222288220daa44L;\n 0x6364648d6407e9c8L;\n 0x2af1f1e3f1db12ffL;\n 0xcc7373d173bfa2e6L;\n 0x8212124812905a24L;\n 0x7a40401d403a5d80L;\n 0x4808082008402810L;\n 0x95c3c32bc356e89bL;\n 0xdfecec97ec337bc5L;\n 0x4ddbdb4bdb9690abL;\n 0xc0a1a1bea1611f5fL;\n 0x918d8d0e8d1c8307L;\n 0xc83d3df43df5c97aL;\n 0x5b97976697ccf133L;\n 0x0000000000000000L;\n 0xf9cfcf1bcf36d483L;\n 0x6e2b2bac2b458756L;\n 0xe17676c57697b3ecL;\n 0xe68282328264b019L;\n 0x28d6d67fd6fea9b1L;\n 0xc31b1b6c1bd87736L;\n 0x74b5b5eeb5c15b77L;\n 0xbeafaf86af112943L;\n 0x1d6a6ab56a77dfd4L;\n 0xea50505d50ba0da0L;\n 0x5745450945124c8aL;\n 0x38f3f3ebf3cb18fbL;\n 0xad3030c0309df060L;\n 0xc4efef9bef2b74c3L;\n 0xda3f3ffc3fe5c37eL;\n 0xc755554955921caaL;\n 0xdba2a2b2a2791059L;\n 0xe9eaea8fea0365c9L;\n 0x6a656589650feccaL;\n 0x03babad2bab96869L;\n 0x4a2f2fbc2f65935eL;\n 0x8ec0c027c04ee79dL;\n 0x60dede5fdebe81a1L;\n 0xfc1c1c701ce06c38L;\n 0x46fdfdd3fdbb2ee7L;\n 0x1f4d4d294d52649aL;\n 0x7692927292e4e039L;\n 0xfa7575c9758fbceaL;\n 0x3606061806301e0cL;\n 0xae8a8a128a249809L;\n 0x4bb2b2f2b2f94079L;\n 0x85e6e6bfe66359d1L;\n 0x7e0e0e380e70361cL;\n 0xe71f1f7c1ff8633eL;\n 0x556262956237f7c4L;\n 0x3ad4d477d4eea3b5L;\n 0x81a8a89aa829324dL;\n 0x5296966296c4f431L;\n 0x62f9f9c3f99b3aefL;\n 0xa3c5c533c566f697L;\n 0x102525942535b14aL;\n 0xab59597959f220b2L;\n 0xd084842a8454ae15L;\n 0xc57272d572b7a7e4L;\n 0xec3939e439d5dd72L;\n 0x164c4c2d4c5a6198L;\n 0x945e5e655eca3bbcL;\n 0x9f7878fd78e785f0L;\n 0xe53838e038ddd870L;\n 0x988c8c0a8c148605L;\n 0x17d1d163d1c6b2bfL;\n 0xe4a5a5aea5410b57L;\n 0xa1e2e2afe2434dd9L;\n 0x4e616199612ff8c2L;\n 0x42b3b3f6b3f1457bL;\n 0x342121842115a542L;\n 0x089c9c4a9c94d625L;\n 0xee1e1e781ef0663cL;\n 0x6143431143225286L;\n 0xb1c7c73bc776fc93L;\n 0x4ffcfcd7fcb32be5L;\n 0x2404041004201408L;\n 0xe351515951b208a2L;\n 0x2599995e99bcc72fL;\n 0x226d6da96d4fc4daL;\n 0x650d0d340d68391aL;\n 0x79fafacffa8335e9L;\n 0x69dfdf5bdfb684a3L;\n 0xa97e7ee57ed79bfcL;\n 0x19242490243db448L;\n 0xfe3b3bec3bc5d776L;\n 0x9aabab96ab313d4bL;\n 0xf0cece1fce3ed181L;\n 0x9911114411885522L;\n 0x838f8f068f0c8903L;\n 0x044e4e254e4a6b9cL;\n 0x66b7b7e6b7d15173L;\n 0xe0ebeb8beb0b60cbL;\n 0xc13c3cf03cfdcc78L;\n 0xfd81813e817cbf1fL;\n 0x4094946a94d4fe35L;\n 0x1cf7f7fbf7eb0cf3L;\n 0x18b9b9deb9a1676fL;\n 0x8b13134c13985f26L;\n 0x512c2cb02c7d9c58L;\n 0x05d3d36bd3d6b8bbL;\n 0x8ce7e7bbe76b5cd3L;\n 0x396e6ea56e57cbdcL;\n 0xaac4c437c46ef395L;\n 0x1b03030c03180f06L;\n 0xdc565645568a13acL;\n 0x5e44440d441a4988L;\n 0xa07f7fe17fdf9efeL;\n 0x88a9a99ea921374fL;\n 0x672a2aa82a4d8254L;\n 0x0abbbbd6bbb16d6bL;\n 0x87c1c123c146e29fL;\n 0xf153535153a202a6L;\n 0x72dcdc57dcae8ba5L;\n 0x530b0b2c0b582716L;\n 0x019d9d4e9d9cd327L;\n 0x2b6c6cad6c47c1d8L;\n 0xa43131c43195f562L;\n 0xf37474cd7487b9e8L;\n 0x15f6f6fff6e309f1L;\n 0x4c464605460a438cL;\n 0xa5acac8aac092645L;\n 0xb589891e893c970fL;\n 0xb414145014a04428L;\n 0xbae1e1a3e15b42dfL;\n 0xa616165816b04e2cL;\n 0xf73a3ae83acdd274L;\n 0x066969b9696fd0d2L;\n 0x4109092409482d12L;\n 0xd77070dd70a7ade0L;\n 0x6fb6b6e2b6d95471L;\n 0x1ed0d067d0ceb7bdL;\n 0xd6eded93ed3b7ec7L;\n 0xe2cccc17cc2edb85L;\n 0x68424215422a5784L;\n 0x2c98985a98b4c22dL;\n 0xeda4a4aaa4490e55L;\n 0x752828a0285d8850L;\n 0x865c5c6d5cda31b8L;\n 0x6bf8f8c7f8933fedL;\n 0xc28686228644a411L;\n |];\n [|\n 0x30d818186018c078L;\n 0x462623238c2305afL;\n 0x91b8c6c63fc67ef9L;\n 0xcdfbe8e887e8136fL;\n 0x13cb878726874ca1L;\n 0x6d11b8b8dab8a962L;\n 0x0209010104010805L;\n 0x9e0d4f4f214f426eL;\n 0x6c9b3636d836adeeL;\n 0x51ffa6a6a2a65904L;\n 0xb90cd2d26fd2debdL;\n 0xf70ef5f5f3f5fb06L;\n 0xf2967979f979ef80L;\n 0xde306f6fa16f5fceL;\n 0x3f6d91917e91fcefL;\n 0xa4f852525552aa07L;\n 0xc04760609d6027fdL;\n 0x6535bcbccabc8976L;\n 0x2b379b9b569baccdL;\n 0x018a8e8e028e048cL;\n 0x5bd2a3a3b6a37115L;\n 0x186c0c0c300c603cL;\n 0xf6847b7bf17bff8aL;\n 0x6a803535d435b5e1L;\n 0x3af51d1d741de869L;\n 0xddb3e0e0a7e05347L;\n 0xb321d7d77bd7f6acL;\n 0x999cc2c22fc25eedL;\n 0x5c432e2eb82e6d96L;\n 0x96294b4b314b627aL;\n 0xe15dfefedffea321L;\n 0xaed5575741578216L;\n 0x2abd15155415a841L;\n 0xeee87777c1779fb6L;\n 0x6e923737dc37a5ebL;\n 0xd79ee5e5b3e57b56L;\n 0x23139f9f469f8cd9L;\n 0xfd23f0f0e7f0d317L;\n 0x94204a4a354a6a7fL;\n 0xa944dada4fda9e95L;\n 0xb0a258587d58fa25L;\n 0x8fcfc9c903c906caL;\n 0x527c2929a429558dL;\n 0x145a0a0a280a5022L;\n 0x7f50b1b1feb1e14fL;\n 0x5dc9a0a0baa0691aL;\n 0xd6146b6bb16b7fdaL;\n 0x17d985852e855cabL;\n 0x673cbdbdcebd8173L;\n 0xba8f5d5d695dd234L;\n 0x2090101040108050L;\n 0xf507f4f4f7f4f303L;\n 0x8bddcbcb0bcb16c0L;\n 0x7cd33e3ef83eedc6L;\n 0x0a2d050514052811L;\n 0xce78676781671fe6L;\n 0xd597e4e4b7e47353L;\n 0x4e0227279c2725bbL;\n 0x8273414119413258L;\n 0x0ba78b8b168b2c9dL;\n 0x53f6a7a7a6a75101L;\n 0xfab27d7de97dcf94L;\n 0x374995956e95dcfbL;\n 0xad56d8d847d88e9fL;\n 0xeb70fbfbcbfb8b30L;\n 0xc1cdeeee9fee2371L;\n 0xf8bb7c7ced7cc791L;\n 0xcc716666856617e3L;\n 0xa77bdddd53dda68eL;\n 0x2eaf17175c17b84bL;\n 0x8e45474701470246L;\n 0x211a9e9e429e84dcL;\n 0x89d4caca0fca1ec5L;\n 0x5a582d2db42d7599L;\n 0x632ebfbfc6bf9179L;\n 0x0e3f07071c07381bL;\n 0x47acadad8ead0123L;\n 0xb4b05a5a755aea2fL;\n 0x1bef838336836cb5L;\n 0x66b63333cc3385ffL;\n 0xc65c636391633ff2L;\n 0x041202020802100aL;\n 0x4993aaaa92aa3938L;\n 0xe2de7171d971afa8L;\n 0x8dc6c8c807c80ecfL;\n 0x32d119196419c87dL;\n 0x923b494939497270L;\n 0xaf5fd9d943d9869aL;\n 0xf931f2f2eff2c31dL;\n 0xdba8e3e3abe34b48L;\n 0xb6b95b5b715be22aL;\n 0x0dbc88881a883492L;\n 0x293e9a9a529aa4c8L;\n 0x4c0b262698262dbeL;\n 0x64bf3232c8328dfaL;\n 0x7d59b0b0fab0e94aL;\n 0xcff2e9e983e91b6aL;\n 0x1e770f0f3c0f7833L;\n 0xb733d5d573d5e6a6L;\n 0x1df480803a8074baL;\n 0x6127bebec2be997cL;\n 0x87ebcdcd13cd26deL;\n 0x68893434d034bde4L;\n 0x903248483d487a75L;\n 0xe354ffffdbffab24L;\n 0xf48d7a7af57af78fL;\n 0x3d6490907a90f4eaL;\n 0xbe9d5f5f615fc23eL;\n 0x403d202080201da0L;\n 0xd00f6868bd6867d5L;\n 0x34ca1a1a681ad072L;\n 0x41b7aeae82ae192cL;\n 0x757db4b4eab4c95eL;\n 0xa8ce54544d549a19L;\n 0x3b7f93937693ece5L;\n 0x442f222288220daaL;\n 0xc86364648d6407e9L;\n 0xff2af1f1e3f1db12L;\n 0xe6cc7373d173bfa2L;\n 0x248212124812905aL;\n 0x807a40401d403a5dL;\n 0x1048080820084028L;\n 0x9b95c3c32bc356e8L;\n 0xc5dfecec97ec337bL;\n 0xab4ddbdb4bdb9690L;\n 0x5fc0a1a1bea1611fL;\n 0x07918d8d0e8d1c83L;\n 0x7ac83d3df43df5c9L;\n 0x335b97976697ccf1L;\n 0x0000000000000000L;\n 0x83f9cfcf1bcf36d4L;\n 0x566e2b2bac2b4587L;\n 0xece17676c57697b3L;\n 0x19e68282328264b0L;\n 0xb128d6d67fd6fea9L;\n 0x36c31b1b6c1bd877L;\n 0x7774b5b5eeb5c15bL;\n 0x43beafaf86af1129L;\n 0xd41d6a6ab56a77dfL;\n 0xa0ea50505d50ba0dL;\n 0x8a5745450945124cL;\n 0xfb38f3f3ebf3cb18L;\n 0x60ad3030c0309df0L;\n 0xc3c4efef9bef2b74L;\n 0x7eda3f3ffc3fe5c3L;\n 0xaac755554955921cL;\n 0x59dba2a2b2a27910L;\n 0xc9e9eaea8fea0365L;\n 0xca6a656589650fecL;\n 0x6903babad2bab968L;\n 0x5e4a2f2fbc2f6593L;\n 0x9d8ec0c027c04ee7L;\n 0xa160dede5fdebe81L;\n 0x38fc1c1c701ce06cL;\n 0xe746fdfdd3fdbb2eL;\n 0x9a1f4d4d294d5264L;\n 0x397692927292e4e0L;\n 0xeafa7575c9758fbcL;\n 0x0c3606061806301eL;\n 0x09ae8a8a128a2498L;\n 0x794bb2b2f2b2f940L;\n 0xd185e6e6bfe66359L;\n 0x1c7e0e0e380e7036L;\n 0x3ee71f1f7c1ff863L;\n 0xc4556262956237f7L;\n 0xb53ad4d477d4eea3L;\n 0x4d81a8a89aa82932L;\n 0x315296966296c4f4L;\n 0xef62f9f9c3f99b3aL;\n 0x97a3c5c533c566f6L;\n 0x4a102525942535b1L;\n 0xb2ab59597959f220L;\n 0x15d084842a8454aeL;\n 0xe4c57272d572b7a7L;\n 0x72ec3939e439d5ddL;\n 0x98164c4c2d4c5a61L;\n 0xbc945e5e655eca3bL;\n 0xf09f7878fd78e785L;\n 0x70e53838e038ddd8L;\n 0x05988c8c0a8c1486L;\n 0xbf17d1d163d1c6b2L;\n 0x57e4a5a5aea5410bL;\n 0xd9a1e2e2afe2434dL;\n 0xc24e616199612ff8L;\n 0x7b42b3b3f6b3f145L;\n 0x42342121842115a5L;\n 0x25089c9c4a9c94d6L;\n 0x3cee1e1e781ef066L;\n 0x8661434311432252L;\n 0x93b1c7c73bc776fcL;\n 0xe54ffcfcd7fcb32bL;\n 0x0824040410042014L;\n 0xa2e351515951b208L;\n 0x2f2599995e99bcc7L;\n 0xda226d6da96d4fc4L;\n 0x1a650d0d340d6839L;\n 0xe979fafacffa8335L;\n 0xa369dfdf5bdfb684L;\n 0xfca97e7ee57ed79bL;\n 0x4819242490243db4L;\n 0x76fe3b3bec3bc5d7L;\n 0x4b9aabab96ab313dL;\n 0x81f0cece1fce3ed1L;\n 0x2299111144118855L;\n 0x03838f8f068f0c89L;\n 0x9c044e4e254e4a6bL;\n 0x7366b7b7e6b7d151L;\n 0xcbe0ebeb8beb0b60L;\n 0x78c13c3cf03cfdccL;\n 0x1ffd81813e817cbfL;\n 0x354094946a94d4feL;\n 0xf31cf7f7fbf7eb0cL;\n 0x6f18b9b9deb9a167L;\n 0x268b13134c13985fL;\n 0x58512c2cb02c7d9cL;\n 0xbb05d3d36bd3d6b8L;\n 0xd38ce7e7bbe76b5cL;\n 0xdc396e6ea56e57cbL;\n 0x95aac4c437c46ef3L;\n 0x061b03030c03180fL;\n 0xacdc565645568a13L;\n 0x885e44440d441a49L;\n 0xfea07f7fe17fdf9eL;\n 0x4f88a9a99ea92137L;\n 0x54672a2aa82a4d82L;\n 0x6b0abbbbd6bbb16dL;\n 0x9f87c1c123c146e2L;\n 0xa6f153535153a202L;\n 0xa572dcdc57dcae8bL;\n 0x16530b0b2c0b5827L;\n 0x27019d9d4e9d9cd3L;\n 0xd82b6c6cad6c47c1L;\n 0x62a43131c43195f5L;\n 0xe8f37474cd7487b9L;\n 0xf115f6f6fff6e309L;\n 0x8c4c464605460a43L;\n 0x45a5acac8aac0926L;\n 0x0fb589891e893c97L;\n 0x28b414145014a044L;\n 0xdfbae1e1a3e15b42L;\n 0x2ca616165816b04eL;\n 0x74f73a3ae83acdd2L;\n 0xd2066969b9696fd0L;\n 0x124109092409482dL;\n 0xe0d77070dd70a7adL;\n 0x716fb6b6e2b6d954L;\n 0xbd1ed0d067d0ceb7L;\n 0xc7d6eded93ed3b7eL;\n 0x85e2cccc17cc2edbL;\n 0x8468424215422a57L;\n 0x2d2c98985a98b4c2L;\n 0x55eda4a4aaa4490eL;\n 0x50752828a0285d88L;\n 0xb8865c5c6d5cda31L;\n 0xed6bf8f8c7f8933fL;\n 0x11c28686228644a4L;\n |];\n [|\n 0x7830d818186018c0L;\n 0xaf462623238c2305L;\n 0xf991b8c6c63fc67eL;\n 0x6fcdfbe8e887e813L;\n 0xa113cb878726874cL;\n 0x626d11b8b8dab8a9L;\n 0x0502090101040108L;\n 0x6e9e0d4f4f214f42L;\n 0xee6c9b3636d836adL;\n 0x0451ffa6a6a2a659L;\n 0xbdb90cd2d26fd2deL;\n 0x06f70ef5f5f3f5fbL;\n 0x80f2967979f979efL;\n 0xcede306f6fa16f5fL;\n 0xef3f6d91917e91fcL;\n 0x07a4f852525552aaL;\n 0xfdc04760609d6027L;\n 0x766535bcbccabc89L;\n 0xcd2b379b9b569bacL;\n 0x8c018a8e8e028e04L;\n 0x155bd2a3a3b6a371L;\n 0x3c186c0c0c300c60L;\n 0x8af6847b7bf17bffL;\n 0xe16a803535d435b5L;\n 0x693af51d1d741de8L;\n 0x47ddb3e0e0a7e053L;\n 0xacb321d7d77bd7f6L;\n 0xed999cc2c22fc25eL;\n 0x965c432e2eb82e6dL;\n 0x7a96294b4b314b62L;\n 0x21e15dfefedffea3L;\n 0x16aed55757415782L;\n 0x412abd15155415a8L;\n 0xb6eee87777c1779fL;\n 0xeb6e923737dc37a5L;\n 0x56d79ee5e5b3e57bL;\n 0xd923139f9f469f8cL;\n 0x17fd23f0f0e7f0d3L;\n 0x7f94204a4a354a6aL;\n 0x95a944dada4fda9eL;\n 0x25b0a258587d58faL;\n 0xca8fcfc9c903c906L;\n 0x8d527c2929a42955L;\n 0x22145a0a0a280a50L;\n 0x4f7f50b1b1feb1e1L;\n 0x1a5dc9a0a0baa069L;\n 0xdad6146b6bb16b7fL;\n 0xab17d985852e855cL;\n 0x73673cbdbdcebd81L;\n 0x34ba8f5d5d695dd2L;\n 0x5020901010401080L;\n 0x03f507f4f4f7f4f3L;\n 0xc08bddcbcb0bcb16L;\n 0xc67cd33e3ef83eedL;\n 0x110a2d0505140528L;\n 0xe6ce78676781671fL;\n 0x53d597e4e4b7e473L;\n 0xbb4e0227279c2725L;\n 0x5882734141194132L;\n 0x9d0ba78b8b168b2cL;\n 0x0153f6a7a7a6a751L;\n 0x94fab27d7de97dcfL;\n 0xfb374995956e95dcL;\n 0x9fad56d8d847d88eL;\n 0x30eb70fbfbcbfb8bL;\n 0x71c1cdeeee9fee23L;\n 0x91f8bb7c7ced7cc7L;\n 0xe3cc716666856617L;\n 0x8ea77bdddd53dda6L;\n 0x4b2eaf17175c17b8L;\n 0x468e454747014702L;\n 0xdc211a9e9e429e84L;\n 0xc589d4caca0fca1eL;\n 0x995a582d2db42d75L;\n 0x79632ebfbfc6bf91L;\n 0x1b0e3f07071c0738L;\n 0x2347acadad8ead01L;\n 0x2fb4b05a5a755aeaL;\n 0xb51bef838336836cL;\n 0xff66b63333cc3385L;\n 0xf2c65c636391633fL;\n 0x0a04120202080210L;\n 0x384993aaaa92aa39L;\n 0xa8e2de7171d971afL;\n 0xcf8dc6c8c807c80eL;\n 0x7d32d119196419c8L;\n 0x70923b4949394972L;\n 0x9aaf5fd9d943d986L;\n 0x1df931f2f2eff2c3L;\n 0x48dba8e3e3abe34bL;\n 0x2ab6b95b5b715be2L;\n 0x920dbc88881a8834L;\n 0xc8293e9a9a529aa4L;\n 0xbe4c0b262698262dL;\n 0xfa64bf3232c8328dL;\n 0x4a7d59b0b0fab0e9L;\n 0x6acff2e9e983e91bL;\n 0x331e770f0f3c0f78L;\n 0xa6b733d5d573d5e6L;\n 0xba1df480803a8074L;\n 0x7c6127bebec2be99L;\n 0xde87ebcdcd13cd26L;\n 0xe468893434d034bdL;\n 0x75903248483d487aL;\n 0x24e354ffffdbffabL;\n 0x8ff48d7a7af57af7L;\n 0xea3d6490907a90f4L;\n 0x3ebe9d5f5f615fc2L;\n 0xa0403d202080201dL;\n 0xd5d00f6868bd6867L;\n 0x7234ca1a1a681ad0L;\n 0x2c41b7aeae82ae19L;\n 0x5e757db4b4eab4c9L;\n 0x19a8ce54544d549aL;\n 0xe53b7f93937693ecL;\n 0xaa442f222288220dL;\n 0xe9c86364648d6407L;\n 0x12ff2af1f1e3f1dbL;\n 0xa2e6cc7373d173bfL;\n 0x5a24821212481290L;\n 0x5d807a40401d403aL;\n 0x2810480808200840L;\n 0xe89b95c3c32bc356L;\n 0x7bc5dfecec97ec33L;\n 0x90ab4ddbdb4bdb96L;\n 0x1f5fc0a1a1bea161L;\n 0x8307918d8d0e8d1cL;\n 0xc97ac83d3df43df5L;\n 0xf1335b97976697ccL;\n 0x0000000000000000L;\n 0xd483f9cfcf1bcf36L;\n 0x87566e2b2bac2b45L;\n 0xb3ece17676c57697L;\n 0xb019e68282328264L;\n 0xa9b128d6d67fd6feL;\n 0x7736c31b1b6c1bd8L;\n 0x5b7774b5b5eeb5c1L;\n 0x2943beafaf86af11L;\n 0xdfd41d6a6ab56a77L;\n 0x0da0ea50505d50baL;\n 0x4c8a574545094512L;\n 0x18fb38f3f3ebf3cbL;\n 0xf060ad3030c0309dL;\n 0x74c3c4efef9bef2bL;\n 0xc37eda3f3ffc3fe5L;\n 0x1caac75555495592L;\n 0x1059dba2a2b2a279L;\n 0x65c9e9eaea8fea03L;\n 0xecca6a656589650fL;\n 0x686903babad2bab9L;\n 0x935e4a2f2fbc2f65L;\n 0xe79d8ec0c027c04eL;\n 0x81a160dede5fdebeL;\n 0x6c38fc1c1c701ce0L;\n 0x2ee746fdfdd3fdbbL;\n 0x649a1f4d4d294d52L;\n 0xe0397692927292e4L;\n 0xbceafa7575c9758fL;\n 0x1e0c360606180630L;\n 0x9809ae8a8a128a24L;\n 0x40794bb2b2f2b2f9L;\n 0x59d185e6e6bfe663L;\n 0x361c7e0e0e380e70L;\n 0x633ee71f1f7c1ff8L;\n 0xf7c4556262956237L;\n 0xa3b53ad4d477d4eeL;\n 0x324d81a8a89aa829L;\n 0xf4315296966296c4L;\n 0x3aef62f9f9c3f99bL;\n 0xf697a3c5c533c566L;\n 0xb14a102525942535L;\n 0x20b2ab59597959f2L;\n 0xae15d084842a8454L;\n 0xa7e4c57272d572b7L;\n 0xdd72ec3939e439d5L;\n 0x6198164c4c2d4c5aL;\n 0x3bbc945e5e655ecaL;\n 0x85f09f7878fd78e7L;\n 0xd870e53838e038ddL;\n 0x8605988c8c0a8c14L;\n 0xb2bf17d1d163d1c6L;\n 0x0b57e4a5a5aea541L;\n 0x4dd9a1e2e2afe243L;\n 0xf8c24e616199612fL;\n 0x457b42b3b3f6b3f1L;\n 0xa542342121842115L;\n 0xd625089c9c4a9c94L;\n 0x663cee1e1e781ef0L;\n 0x5286614343114322L;\n 0xfc93b1c7c73bc776L;\n 0x2be54ffcfcd7fcb3L;\n 0x1408240404100420L;\n 0x08a2e351515951b2L;\n 0xc72f2599995e99bcL;\n 0xc4da226d6da96d4fL;\n 0x391a650d0d340d68L;\n 0x35e979fafacffa83L;\n 0x84a369dfdf5bdfb6L;\n 0x9bfca97e7ee57ed7L;\n 0xb44819242490243dL;\n 0xd776fe3b3bec3bc5L;\n 0x3d4b9aabab96ab31L;\n 0xd181f0cece1fce3eL;\n 0x5522991111441188L;\n 0x8903838f8f068f0cL;\n 0x6b9c044e4e254e4aL;\n 0x517366b7b7e6b7d1L;\n 0x60cbe0ebeb8beb0bL;\n 0xcc78c13c3cf03cfdL;\n 0xbf1ffd81813e817cL;\n 0xfe354094946a94d4L;\n 0x0cf31cf7f7fbf7ebL;\n 0x676f18b9b9deb9a1L;\n 0x5f268b13134c1398L;\n 0x9c58512c2cb02c7dL;\n 0xb8bb05d3d36bd3d6L;\n 0x5cd38ce7e7bbe76bL;\n 0xcbdc396e6ea56e57L;\n 0xf395aac4c437c46eL;\n 0x0f061b03030c0318L;\n 0x13acdc565645568aL;\n 0x49885e44440d441aL;\n 0x9efea07f7fe17fdfL;\n 0x374f88a9a99ea921L;\n 0x8254672a2aa82a4dL;\n 0x6d6b0abbbbd6bbb1L;\n 0xe29f87c1c123c146L;\n 0x02a6f153535153a2L;\n 0x8ba572dcdc57dcaeL;\n 0x2716530b0b2c0b58L;\n 0xd327019d9d4e9d9cL;\n 0xc1d82b6c6cad6c47L;\n 0xf562a43131c43195L;\n 0xb9e8f37474cd7487L;\n 0x09f115f6f6fff6e3L;\n 0x438c4c464605460aL;\n 0x2645a5acac8aac09L;\n 0x970fb589891e893cL;\n 0x4428b414145014a0L;\n 0x42dfbae1e1a3e15bL;\n 0x4e2ca616165816b0L;\n 0xd274f73a3ae83acdL;\n 0xd0d2066969b9696fL;\n 0x2d12410909240948L;\n 0xade0d77070dd70a7L;\n 0x54716fb6b6e2b6d9L;\n 0xb7bd1ed0d067d0ceL;\n 0x7ec7d6eded93ed3bL;\n 0xdb85e2cccc17cc2eL;\n 0x578468424215422aL;\n 0xc22d2c98985a98b4L;\n 0x0e55eda4a4aaa449L;\n 0x8850752828a0285dL;\n 0x31b8865c5c6d5cdaL;\n 0x3fed6bf8f8c7f893L;\n 0xa411c28686228644L;\n |];\n [|\n 0xc07830d818186018L;\n 0x05af462623238c23L;\n 0x7ef991b8c6c63fc6L;\n 0x136fcdfbe8e887e8L;\n 0x4ca113cb87872687L;\n 0xa9626d11b8b8dab8L;\n 0x0805020901010401L;\n 0x426e9e0d4f4f214fL;\n 0xadee6c9b3636d836L;\n 0x590451ffa6a6a2a6L;\n 0xdebdb90cd2d26fd2L;\n 0xfb06f70ef5f5f3f5L;\n 0xef80f2967979f979L;\n 0x5fcede306f6fa16fL;\n 0xfcef3f6d91917e91L;\n 0xaa07a4f852525552L;\n 0x27fdc04760609d60L;\n 0x89766535bcbccabcL;\n 0xaccd2b379b9b569bL;\n 0x048c018a8e8e028eL;\n 0x71155bd2a3a3b6a3L;\n 0x603c186c0c0c300cL;\n 0xff8af6847b7bf17bL;\n 0xb5e16a803535d435L;\n 0xe8693af51d1d741dL;\n 0x5347ddb3e0e0a7e0L;\n 0xf6acb321d7d77bd7L;\n 0x5eed999cc2c22fc2L;\n 0x6d965c432e2eb82eL;\n 0x627a96294b4b314bL;\n 0xa321e15dfefedffeL;\n 0x8216aed557574157L;\n 0xa8412abd15155415L;\n 0x9fb6eee87777c177L;\n 0xa5eb6e923737dc37L;\n 0x7b56d79ee5e5b3e5L;\n 0x8cd923139f9f469fL;\n 0xd317fd23f0f0e7f0L;\n 0x6a7f94204a4a354aL;\n 0x9e95a944dada4fdaL;\n 0xfa25b0a258587d58L;\n 0x06ca8fcfc9c903c9L;\n 0x558d527c2929a429L;\n 0x5022145a0a0a280aL;\n 0xe14f7f50b1b1feb1L;\n 0x691a5dc9a0a0baa0L;\n 0x7fdad6146b6bb16bL;\n 0x5cab17d985852e85L;\n 0x8173673cbdbdcebdL;\n 0xd234ba8f5d5d695dL;\n 0x8050209010104010L;\n 0xf303f507f4f4f7f4L;\n 0x16c08bddcbcb0bcbL;\n 0xedc67cd33e3ef83eL;\n 0x28110a2d05051405L;\n 0x1fe6ce7867678167L;\n 0x7353d597e4e4b7e4L;\n 0x25bb4e0227279c27L;\n 0x3258827341411941L;\n 0x2c9d0ba78b8b168bL;\n 0x510153f6a7a7a6a7L;\n 0xcf94fab27d7de97dL;\n 0xdcfb374995956e95L;\n 0x8e9fad56d8d847d8L;\n 0x8b30eb70fbfbcbfbL;\n 0x2371c1cdeeee9feeL;\n 0xc791f8bb7c7ced7cL;\n 0x17e3cc7166668566L;\n 0xa68ea77bdddd53ddL;\n 0xb84b2eaf17175c17L;\n 0x02468e4547470147L;\n 0x84dc211a9e9e429eL;\n 0x1ec589d4caca0fcaL;\n 0x75995a582d2db42dL;\n 0x9179632ebfbfc6bfL;\n 0x381b0e3f07071c07L;\n 0x012347acadad8eadL;\n 0xea2fb4b05a5a755aL;\n 0x6cb51bef83833683L;\n 0x85ff66b63333cc33L;\n 0x3ff2c65c63639163L;\n 0x100a041202020802L;\n 0x39384993aaaa92aaL;\n 0xafa8e2de7171d971L;\n 0x0ecf8dc6c8c807c8L;\n 0xc87d32d119196419L;\n 0x7270923b49493949L;\n 0x869aaf5fd9d943d9L;\n 0xc31df931f2f2eff2L;\n 0x4b48dba8e3e3abe3L;\n 0xe22ab6b95b5b715bL;\n 0x34920dbc88881a88L;\n 0xa4c8293e9a9a529aL;\n 0x2dbe4c0b26269826L;\n 0x8dfa64bf3232c832L;\n 0xe94a7d59b0b0fab0L;\n 0x1b6acff2e9e983e9L;\n 0x78331e770f0f3c0fL;\n 0xe6a6b733d5d573d5L;\n 0x74ba1df480803a80L;\n 0x997c6127bebec2beL;\n 0x26de87ebcdcd13cdL;\n 0xbde468893434d034L;\n 0x7a75903248483d48L;\n 0xab24e354ffffdbffL;\n 0xf78ff48d7a7af57aL;\n 0xf4ea3d6490907a90L;\n 0xc23ebe9d5f5f615fL;\n 0x1da0403d20208020L;\n 0x67d5d00f6868bd68L;\n 0xd07234ca1a1a681aL;\n 0x192c41b7aeae82aeL;\n 0xc95e757db4b4eab4L;\n 0x9a19a8ce54544d54L;\n 0xece53b7f93937693L;\n 0x0daa442f22228822L;\n 0x07e9c86364648d64L;\n 0xdb12ff2af1f1e3f1L;\n 0xbfa2e6cc7373d173L;\n 0x905a248212124812L;\n 0x3a5d807a40401d40L;\n 0x4028104808082008L;\n 0x56e89b95c3c32bc3L;\n 0x337bc5dfecec97ecL;\n 0x9690ab4ddbdb4bdbL;\n 0x611f5fc0a1a1bea1L;\n 0x1c8307918d8d0e8dL;\n 0xf5c97ac83d3df43dL;\n 0xccf1335b97976697L;\n 0x0000000000000000L;\n 0x36d483f9cfcf1bcfL;\n 0x4587566e2b2bac2bL;\n 0x97b3ece17676c576L;\n 0x64b019e682823282L;\n 0xfea9b128d6d67fd6L;\n 0xd87736c31b1b6c1bL;\n 0xc15b7774b5b5eeb5L;\n 0x112943beafaf86afL;\n 0x77dfd41d6a6ab56aL;\n 0xba0da0ea50505d50L;\n 0x124c8a5745450945L;\n 0xcb18fb38f3f3ebf3L;\n 0x9df060ad3030c030L;\n 0x2b74c3c4efef9befL;\n 0xe5c37eda3f3ffc3fL;\n 0x921caac755554955L;\n 0x791059dba2a2b2a2L;\n 0x0365c9e9eaea8feaL;\n 0x0fecca6a65658965L;\n 0xb9686903babad2baL;\n 0x65935e4a2f2fbc2fL;\n 0x4ee79d8ec0c027c0L;\n 0xbe81a160dede5fdeL;\n 0xe06c38fc1c1c701cL;\n 0xbb2ee746fdfdd3fdL;\n 0x52649a1f4d4d294dL;\n 0xe4e0397692927292L;\n 0x8fbceafa7575c975L;\n 0x301e0c3606061806L;\n 0x249809ae8a8a128aL;\n 0xf940794bb2b2f2b2L;\n 0x6359d185e6e6bfe6L;\n 0x70361c7e0e0e380eL;\n 0xf8633ee71f1f7c1fL;\n 0x37f7c45562629562L;\n 0xeea3b53ad4d477d4L;\n 0x29324d81a8a89aa8L;\n 0xc4f4315296966296L;\n 0x9b3aef62f9f9c3f9L;\n 0x66f697a3c5c533c5L;\n 0x35b14a1025259425L;\n 0xf220b2ab59597959L;\n 0x54ae15d084842a84L;\n 0xb7a7e4c57272d572L;\n 0xd5dd72ec3939e439L;\n 0x5a6198164c4c2d4cL;\n 0xca3bbc945e5e655eL;\n 0xe785f09f7878fd78L;\n 0xddd870e53838e038L;\n 0x148605988c8c0a8cL;\n 0xc6b2bf17d1d163d1L;\n 0x410b57e4a5a5aea5L;\n 0x434dd9a1e2e2afe2L;\n 0x2ff8c24e61619961L;\n 0xf1457b42b3b3f6b3L;\n 0x15a5423421218421L;\n 0x94d625089c9c4a9cL;\n 0xf0663cee1e1e781eL;\n 0x2252866143431143L;\n 0x76fc93b1c7c73bc7L;\n 0xb32be54ffcfcd7fcL;\n 0x2014082404041004L;\n 0xb208a2e351515951L;\n 0xbcc72f2599995e99L;\n 0x4fc4da226d6da96dL;\n 0x68391a650d0d340dL;\n 0x8335e979fafacffaL;\n 0xb684a369dfdf5bdfL;\n 0xd79bfca97e7ee57eL;\n 0x3db4481924249024L;\n 0xc5d776fe3b3bec3bL;\n 0x313d4b9aabab96abL;\n 0x3ed181f0cece1fceL;\n 0x8855229911114411L;\n 0x0c8903838f8f068fL;\n 0x4a6b9c044e4e254eL;\n 0xd1517366b7b7e6b7L;\n 0x0b60cbe0ebeb8bebL;\n 0xfdcc78c13c3cf03cL;\n 0x7cbf1ffd81813e81L;\n 0xd4fe354094946a94L;\n 0xeb0cf31cf7f7fbf7L;\n 0xa1676f18b9b9deb9L;\n 0x985f268b13134c13L;\n 0x7d9c58512c2cb02cL;\n 0xd6b8bb05d3d36bd3L;\n 0x6b5cd38ce7e7bbe7L;\n 0x57cbdc396e6ea56eL;\n 0x6ef395aac4c437c4L;\n 0x180f061b03030c03L;\n 0x8a13acdc56564556L;\n 0x1a49885e44440d44L;\n 0xdf9efea07f7fe17fL;\n 0x21374f88a9a99ea9L;\n 0x4d8254672a2aa82aL;\n 0xb16d6b0abbbbd6bbL;\n 0x46e29f87c1c123c1L;\n 0xa202a6f153535153L;\n 0xae8ba572dcdc57dcL;\n 0x582716530b0b2c0bL;\n 0x9cd327019d9d4e9dL;\n 0x47c1d82b6c6cad6cL;\n 0x95f562a43131c431L;\n 0x87b9e8f37474cd74L;\n 0xe309f115f6f6fff6L;\n 0x0a438c4c46460546L;\n 0x092645a5acac8aacL;\n 0x3c970fb589891e89L;\n 0xa04428b414145014L;\n 0x5b42dfbae1e1a3e1L;\n 0xb04e2ca616165816L;\n 0xcdd274f73a3ae83aL;\n 0x6fd0d2066969b969L;\n 0x482d124109092409L;\n 0xa7ade0d77070dd70L;\n 0xd954716fb6b6e2b6L;\n 0xceb7bd1ed0d067d0L;\n 0x3b7ec7d6eded93edL;\n 0x2edb85e2cccc17ccL;\n 0x2a57846842421542L;\n 0xb4c22d2c98985a98L;\n 0x490e55eda4a4aaa4L;\n 0x5d8850752828a028L;\n 0xda31b8865c5c6d5cL;\n 0x933fed6bf8f8c7f8L;\n 0x44a411c286862286L;\n |];\n [|\n 0x18c07830d8181860L;\n 0x2305af462623238cL;\n 0xc67ef991b8c6c63fL;\n 0xe8136fcdfbe8e887L;\n 0x874ca113cb878726L;\n 0xb8a9626d11b8b8daL;\n 0x0108050209010104L;\n 0x4f426e9e0d4f4f21L;\n 0x36adee6c9b3636d8L;\n 0xa6590451ffa6a6a2L;\n 0xd2debdb90cd2d26fL;\n 0xf5fb06f70ef5f5f3L;\n 0x79ef80f2967979f9L;\n 0x6f5fcede306f6fa1L;\n 0x91fcef3f6d91917eL;\n 0x52aa07a4f8525255L;\n 0x6027fdc04760609dL;\n 0xbc89766535bcbccaL;\n 0x9baccd2b379b9b56L;\n 0x8e048c018a8e8e02L;\n 0xa371155bd2a3a3b6L;\n 0x0c603c186c0c0c30L;\n 0x7bff8af6847b7bf1L;\n 0x35b5e16a803535d4L;\n 0x1de8693af51d1d74L;\n 0xe05347ddb3e0e0a7L;\n 0xd7f6acb321d7d77bL;\n 0xc25eed999cc2c22fL;\n 0x2e6d965c432e2eb8L;\n 0x4b627a96294b4b31L;\n 0xfea321e15dfefedfL;\n 0x578216aed5575741L;\n 0x15a8412abd151554L;\n 0x779fb6eee87777c1L;\n 0x37a5eb6e923737dcL;\n 0xe57b56d79ee5e5b3L;\n 0x9f8cd923139f9f46L;\n 0xf0d317fd23f0f0e7L;\n 0x4a6a7f94204a4a35L;\n 0xda9e95a944dada4fL;\n 0x58fa25b0a258587dL;\n 0xc906ca8fcfc9c903L;\n 0x29558d527c2929a4L;\n 0x0a5022145a0a0a28L;\n 0xb1e14f7f50b1b1feL;\n 0xa0691a5dc9a0a0baL;\n 0x6b7fdad6146b6bb1L;\n 0x855cab17d985852eL;\n 0xbd8173673cbdbdceL;\n 0x5dd234ba8f5d5d69L;\n 0x1080502090101040L;\n 0xf4f303f507f4f4f7L;\n 0xcb16c08bddcbcb0bL;\n 0x3eedc67cd33e3ef8L;\n 0x0528110a2d050514L;\n 0x671fe6ce78676781L;\n 0xe47353d597e4e4b7L;\n 0x2725bb4e0227279cL;\n 0x4132588273414119L;\n 0x8b2c9d0ba78b8b16L;\n 0xa7510153f6a7a7a6L;\n 0x7dcf94fab27d7de9L;\n 0x95dcfb374995956eL;\n 0xd88e9fad56d8d847L;\n 0xfb8b30eb70fbfbcbL;\n 0xee2371c1cdeeee9fL;\n 0x7cc791f8bb7c7cedL;\n 0x6617e3cc71666685L;\n 0xdda68ea77bdddd53L;\n 0x17b84b2eaf17175cL;\n 0x4702468e45474701L;\n 0x9e84dc211a9e9e42L;\n 0xca1ec589d4caca0fL;\n 0x2d75995a582d2db4L;\n 0xbf9179632ebfbfc6L;\n 0x07381b0e3f07071cL;\n 0xad012347acadad8eL;\n 0x5aea2fb4b05a5a75L;\n 0x836cb51bef838336L;\n 0x3385ff66b63333ccL;\n 0x633ff2c65c636391L;\n 0x02100a0412020208L;\n 0xaa39384993aaaa92L;\n 0x71afa8e2de7171d9L;\n 0xc80ecf8dc6c8c807L;\n 0x19c87d32d1191964L;\n 0x497270923b494939L;\n 0xd9869aaf5fd9d943L;\n 0xf2c31df931f2f2efL;\n 0xe34b48dba8e3e3abL;\n 0x5be22ab6b95b5b71L;\n 0x8834920dbc88881aL;\n 0x9aa4c8293e9a9a52L;\n 0x262dbe4c0b262698L;\n 0x328dfa64bf3232c8L;\n 0xb0e94a7d59b0b0faL;\n 0xe91b6acff2e9e983L;\n 0x0f78331e770f0f3cL;\n 0xd5e6a6b733d5d573L;\n 0x8074ba1df480803aL;\n 0xbe997c6127bebec2L;\n 0xcd26de87ebcdcd13L;\n 0x34bde468893434d0L;\n 0x487a75903248483dL;\n 0xffab24e354ffffdbL;\n 0x7af78ff48d7a7af5L;\n 0x90f4ea3d6490907aL;\n 0x5fc23ebe9d5f5f61L;\n 0x201da0403d202080L;\n 0x6867d5d00f6868bdL;\n 0x1ad07234ca1a1a68L;\n 0xae192c41b7aeae82L;\n 0xb4c95e757db4b4eaL;\n 0x549a19a8ce54544dL;\n 0x93ece53b7f939376L;\n 0x220daa442f222288L;\n 0x6407e9c86364648dL;\n 0xf1db12ff2af1f1e3L;\n 0x73bfa2e6cc7373d1L;\n 0x12905a2482121248L;\n 0x403a5d807a40401dL;\n 0x0840281048080820L;\n 0xc356e89b95c3c32bL;\n 0xec337bc5dfecec97L;\n 0xdb9690ab4ddbdb4bL;\n 0xa1611f5fc0a1a1beL;\n 0x8d1c8307918d8d0eL;\n 0x3df5c97ac83d3df4L;\n 0x97ccf1335b979766L;\n 0x0000000000000000L;\n 0xcf36d483f9cfcf1bL;\n 0x2b4587566e2b2bacL;\n 0x7697b3ece17676c5L;\n 0x8264b019e6828232L;\n 0xd6fea9b128d6d67fL;\n 0x1bd87736c31b1b6cL;\n 0xb5c15b7774b5b5eeL;\n 0xaf112943beafaf86L;\n 0x6a77dfd41d6a6ab5L;\n 0x50ba0da0ea50505dL;\n 0x45124c8a57454509L;\n 0xf3cb18fb38f3f3ebL;\n 0x309df060ad3030c0L;\n 0xef2b74c3c4efef9bL;\n 0x3fe5c37eda3f3ffcL;\n 0x55921caac7555549L;\n 0xa2791059dba2a2b2L;\n 0xea0365c9e9eaea8fL;\n 0x650fecca6a656589L;\n 0xbab9686903babad2L;\n 0x2f65935e4a2f2fbcL;\n 0xc04ee79d8ec0c027L;\n 0xdebe81a160dede5fL;\n 0x1ce06c38fc1c1c70L;\n 0xfdbb2ee746fdfdd3L;\n 0x4d52649a1f4d4d29L;\n 0x92e4e03976929272L;\n 0x758fbceafa7575c9L;\n 0x06301e0c36060618L;\n 0x8a249809ae8a8a12L;\n 0xb2f940794bb2b2f2L;\n 0xe66359d185e6e6bfL;\n 0x0e70361c7e0e0e38L;\n 0x1ff8633ee71f1f7cL;\n 0x6237f7c455626295L;\n 0xd4eea3b53ad4d477L;\n 0xa829324d81a8a89aL;\n 0x96c4f43152969662L;\n 0xf99b3aef62f9f9c3L;\n 0xc566f697a3c5c533L;\n 0x2535b14a10252594L;\n 0x59f220b2ab595979L;\n 0x8454ae15d084842aL;\n 0x72b7a7e4c57272d5L;\n 0x39d5dd72ec3939e4L;\n 0x4c5a6198164c4c2dL;\n 0x5eca3bbc945e5e65L;\n 0x78e785f09f7878fdL;\n 0x38ddd870e53838e0L;\n 0x8c148605988c8c0aL;\n 0xd1c6b2bf17d1d163L;\n 0xa5410b57e4a5a5aeL;\n 0xe2434dd9a1e2e2afL;\n 0x612ff8c24e616199L;\n 0xb3f1457b42b3b3f6L;\n 0x2115a54234212184L;\n 0x9c94d625089c9c4aL;\n 0x1ef0663cee1e1e78L;\n 0x4322528661434311L;\n 0xc776fc93b1c7c73bL;\n 0xfcb32be54ffcfcd7L;\n 0x0420140824040410L;\n 0x51b208a2e3515159L;\n 0x99bcc72f2599995eL;\n 0x6d4fc4da226d6da9L;\n 0x0d68391a650d0d34L;\n 0xfa8335e979fafacfL;\n 0xdfb684a369dfdf5bL;\n 0x7ed79bfca97e7ee5L;\n 0x243db44819242490L;\n 0x3bc5d776fe3b3becL;\n 0xab313d4b9aabab96L;\n 0xce3ed181f0cece1fL;\n 0x1188552299111144L;\n 0x8f0c8903838f8f06L;\n 0x4e4a6b9c044e4e25L;\n 0xb7d1517366b7b7e6L;\n 0xeb0b60cbe0ebeb8bL;\n 0x3cfdcc78c13c3cf0L;\n 0x817cbf1ffd81813eL;\n 0x94d4fe354094946aL;\n 0xf7eb0cf31cf7f7fbL;\n 0xb9a1676f18b9b9deL;\n 0x13985f268b13134cL;\n 0x2c7d9c58512c2cb0L;\n 0xd3d6b8bb05d3d36bL;\n 0xe76b5cd38ce7e7bbL;\n 0x6e57cbdc396e6ea5L;\n 0xc46ef395aac4c437L;\n 0x03180f061b03030cL;\n 0x568a13acdc565645L;\n 0x441a49885e44440dL;\n 0x7fdf9efea07f7fe1L;\n 0xa921374f88a9a99eL;\n 0x2a4d8254672a2aa8L;\n 0xbbb16d6b0abbbbd6L;\n 0xc146e29f87c1c123L;\n 0x53a202a6f1535351L;\n 0xdcae8ba572dcdc57L;\n 0x0b582716530b0b2cL;\n 0x9d9cd327019d9d4eL;\n 0x6c47c1d82b6c6cadL;\n 0x3195f562a43131c4L;\n 0x7487b9e8f37474cdL;\n 0xf6e309f115f6f6ffL;\n 0x460a438c4c464605L;\n 0xac092645a5acac8aL;\n 0x893c970fb589891eL;\n 0x14a04428b4141450L;\n 0xe15b42dfbae1e1a3L;\n 0x16b04e2ca6161658L;\n 0x3acdd274f73a3ae8L;\n 0x696fd0d2066969b9L;\n 0x09482d1241090924L;\n 0x70a7ade0d77070ddL;\n 0xb6d954716fb6b6e2L;\n 0xd0ceb7bd1ed0d067L;\n 0xed3b7ec7d6eded93L;\n 0xcc2edb85e2cccc17L;\n 0x422a578468424215L;\n 0x98b4c22d2c98985aL;\n 0xa4490e55eda4a4aaL;\n 0x285d8850752828a0L;\n 0x5cda31b8865c5c6dL;\n 0xf8933fed6bf8f8c7L;\n 0x8644a411c2868622L;\n |];\n [|\n 0x6018c07830d81818L;\n 0x8c2305af46262323L;\n 0x3fc67ef991b8c6c6L;\n 0x87e8136fcdfbe8e8L;\n 0x26874ca113cb8787L;\n 0xdab8a9626d11b8b8L;\n 0x0401080502090101L;\n 0x214f426e9e0d4f4fL;\n 0xd836adee6c9b3636L;\n 0xa2a6590451ffa6a6L;\n 0x6fd2debdb90cd2d2L;\n 0xf3f5fb06f70ef5f5L;\n 0xf979ef80f2967979L;\n 0xa16f5fcede306f6fL;\n 0x7e91fcef3f6d9191L;\n 0x5552aa07a4f85252L;\n 0x9d6027fdc0476060L;\n 0xcabc89766535bcbcL;\n 0x569baccd2b379b9bL;\n 0x028e048c018a8e8eL;\n 0xb6a371155bd2a3a3L;\n 0x300c603c186c0c0cL;\n 0xf17bff8af6847b7bL;\n 0xd435b5e16a803535L;\n 0x741de8693af51d1dL;\n 0xa7e05347ddb3e0e0L;\n 0x7bd7f6acb321d7d7L;\n 0x2fc25eed999cc2c2L;\n 0xb82e6d965c432e2eL;\n 0x314b627a96294b4bL;\n 0xdffea321e15dfefeL;\n 0x41578216aed55757L;\n 0x5415a8412abd1515L;\n 0xc1779fb6eee87777L;\n 0xdc37a5eb6e923737L;\n 0xb3e57b56d79ee5e5L;\n 0x469f8cd923139f9fL;\n 0xe7f0d317fd23f0f0L;\n 0x354a6a7f94204a4aL;\n 0x4fda9e95a944dadaL;\n 0x7d58fa25b0a25858L;\n 0x03c906ca8fcfc9c9L;\n 0xa429558d527c2929L;\n 0x280a5022145a0a0aL;\n 0xfeb1e14f7f50b1b1L;\n 0xbaa0691a5dc9a0a0L;\n 0xb16b7fdad6146b6bL;\n 0x2e855cab17d98585L;\n 0xcebd8173673cbdbdL;\n 0x695dd234ba8f5d5dL;\n 0x4010805020901010L;\n 0xf7f4f303f507f4f4L;\n 0x0bcb16c08bddcbcbL;\n 0xf83eedc67cd33e3eL;\n 0x140528110a2d0505L;\n 0x81671fe6ce786767L;\n 0xb7e47353d597e4e4L;\n 0x9c2725bb4e022727L;\n 0x1941325882734141L;\n 0x168b2c9d0ba78b8bL;\n 0xa6a7510153f6a7a7L;\n 0xe97dcf94fab27d7dL;\n 0x6e95dcfb37499595L;\n 0x47d88e9fad56d8d8L;\n 0xcbfb8b30eb70fbfbL;\n 0x9fee2371c1cdeeeeL;\n 0xed7cc791f8bb7c7cL;\n 0x856617e3cc716666L;\n 0x53dda68ea77bddddL;\n 0x5c17b84b2eaf1717L;\n 0x014702468e454747L;\n 0x429e84dc211a9e9eL;\n 0x0fca1ec589d4cacaL;\n 0xb42d75995a582d2dL;\n 0xc6bf9179632ebfbfL;\n 0x1c07381b0e3f0707L;\n 0x8ead012347acadadL;\n 0x755aea2fb4b05a5aL;\n 0x36836cb51bef8383L;\n 0xcc3385ff66b63333L;\n 0x91633ff2c65c6363L;\n 0x0802100a04120202L;\n 0x92aa39384993aaaaL;\n 0xd971afa8e2de7171L;\n 0x07c80ecf8dc6c8c8L;\n 0x6419c87d32d11919L;\n 0x39497270923b4949L;\n 0x43d9869aaf5fd9d9L;\n 0xeff2c31df931f2f2L;\n 0xabe34b48dba8e3e3L;\n 0x715be22ab6b95b5bL;\n 0x1a8834920dbc8888L;\n 0x529aa4c8293e9a9aL;\n 0x98262dbe4c0b2626L;\n 0xc8328dfa64bf3232L;\n 0xfab0e94a7d59b0b0L;\n 0x83e91b6acff2e9e9L;\n 0x3c0f78331e770f0fL;\n 0x73d5e6a6b733d5d5L;\n 0x3a8074ba1df48080L;\n 0xc2be997c6127bebeL;\n 0x13cd26de87ebcdcdL;\n 0xd034bde468893434L;\n 0x3d487a7590324848L;\n 0xdbffab24e354ffffL;\n 0xf57af78ff48d7a7aL;\n 0x7a90f4ea3d649090L;\n 0x615fc23ebe9d5f5fL;\n 0x80201da0403d2020L;\n 0xbd6867d5d00f6868L;\n 0x681ad07234ca1a1aL;\n 0x82ae192c41b7aeaeL;\n 0xeab4c95e757db4b4L;\n 0x4d549a19a8ce5454L;\n 0x7693ece53b7f9393L;\n 0x88220daa442f2222L;\n 0x8d6407e9c8636464L;\n 0xe3f1db12ff2af1f1L;\n 0xd173bfa2e6cc7373L;\n 0x4812905a24821212L;\n 0x1d403a5d807a4040L;\n 0x2008402810480808L;\n 0x2bc356e89b95c3c3L;\n 0x97ec337bc5dfececL;\n 0x4bdb9690ab4ddbdbL;\n 0xbea1611f5fc0a1a1L;\n 0x0e8d1c8307918d8dL;\n 0xf43df5c97ac83d3dL;\n 0x6697ccf1335b9797L;\n 0x0000000000000000L;\n 0x1bcf36d483f9cfcfL;\n 0xac2b4587566e2b2bL;\n 0xc57697b3ece17676L;\n 0x328264b019e68282L;\n 0x7fd6fea9b128d6d6L;\n 0x6c1bd87736c31b1bL;\n 0xeeb5c15b7774b5b5L;\n 0x86af112943beafafL;\n 0xb56a77dfd41d6a6aL;\n 0x5d50ba0da0ea5050L;\n 0x0945124c8a574545L;\n 0xebf3cb18fb38f3f3L;\n 0xc0309df060ad3030L;\n 0x9bef2b74c3c4efefL;\n 0xfc3fe5c37eda3f3fL;\n 0x4955921caac75555L;\n 0xb2a2791059dba2a2L;\n 0x8fea0365c9e9eaeaL;\n 0x89650fecca6a6565L;\n 0xd2bab9686903babaL;\n 0xbc2f65935e4a2f2fL;\n 0x27c04ee79d8ec0c0L;\n 0x5fdebe81a160dedeL;\n 0x701ce06c38fc1c1cL;\n 0xd3fdbb2ee746fdfdL;\n 0x294d52649a1f4d4dL;\n 0x7292e4e039769292L;\n 0xc9758fbceafa7575L;\n 0x1806301e0c360606L;\n 0x128a249809ae8a8aL;\n 0xf2b2f940794bb2b2L;\n 0xbfe66359d185e6e6L;\n 0x380e70361c7e0e0eL;\n 0x7c1ff8633ee71f1fL;\n 0x956237f7c4556262L;\n 0x77d4eea3b53ad4d4L;\n 0x9aa829324d81a8a8L;\n 0x6296c4f431529696L;\n 0xc3f99b3aef62f9f9L;\n 0x33c566f697a3c5c5L;\n 0x942535b14a102525L;\n 0x7959f220b2ab5959L;\n 0x2a8454ae15d08484L;\n 0xd572b7a7e4c57272L;\n 0xe439d5dd72ec3939L;\n 0x2d4c5a6198164c4cL;\n 0x655eca3bbc945e5eL;\n 0xfd78e785f09f7878L;\n 0xe038ddd870e53838L;\n 0x0a8c148605988c8cL;\n 0x63d1c6b2bf17d1d1L;\n 0xaea5410b57e4a5a5L;\n 0xafe2434dd9a1e2e2L;\n 0x99612ff8c24e6161L;\n 0xf6b3f1457b42b3b3L;\n 0x842115a542342121L;\n 0x4a9c94d625089c9cL;\n 0x781ef0663cee1e1eL;\n 0x1143225286614343L;\n 0x3bc776fc93b1c7c7L;\n 0xd7fcb32be54ffcfcL;\n 0x1004201408240404L;\n 0x5951b208a2e35151L;\n 0x5e99bcc72f259999L;\n 0xa96d4fc4da226d6dL;\n 0x340d68391a650d0dL;\n 0xcffa8335e979fafaL;\n 0x5bdfb684a369dfdfL;\n 0xe57ed79bfca97e7eL;\n 0x90243db448192424L;\n 0xec3bc5d776fe3b3bL;\n 0x96ab313d4b9aababL;\n 0x1fce3ed181f0ceceL;\n 0x4411885522991111L;\n 0x068f0c8903838f8fL;\n 0x254e4a6b9c044e4eL;\n 0xe6b7d1517366b7b7L;\n 0x8beb0b60cbe0ebebL;\n 0xf03cfdcc78c13c3cL;\n 0x3e817cbf1ffd8181L;\n 0x6a94d4fe35409494L;\n 0xfbf7eb0cf31cf7f7L;\n 0xdeb9a1676f18b9b9L;\n 0x4c13985f268b1313L;\n 0xb02c7d9c58512c2cL;\n 0x6bd3d6b8bb05d3d3L;\n 0xbbe76b5cd38ce7e7L;\n 0xa56e57cbdc396e6eL;\n 0x37c46ef395aac4c4L;\n 0x0c03180f061b0303L;\n 0x45568a13acdc5656L;\n 0x0d441a49885e4444L;\n 0xe17fdf9efea07f7fL;\n 0x9ea921374f88a9a9L;\n 0xa82a4d8254672a2aL;\n 0xd6bbb16d6b0abbbbL;\n 0x23c146e29f87c1c1L;\n 0x5153a202a6f15353L;\n 0x57dcae8ba572dcdcL;\n 0x2c0b582716530b0bL;\n 0x4e9d9cd327019d9dL;\n 0xad6c47c1d82b6c6cL;\n 0xc43195f562a43131L;\n 0xcd7487b9e8f37474L;\n 0xfff6e309f115f6f6L;\n 0x05460a438c4c4646L;\n 0x8aac092645a5acacL;\n 0x1e893c970fb58989L;\n 0x5014a04428b41414L;\n 0xa3e15b42dfbae1e1L;\n 0x5816b04e2ca61616L;\n 0xe83acdd274f73a3aL;\n 0xb9696fd0d2066969L;\n 0x2409482d12410909L;\n 0xdd70a7ade0d77070L;\n 0xe2b6d954716fb6b6L;\n 0x67d0ceb7bd1ed0d0L;\n 0x93ed3b7ec7d6ededL;\n 0x17cc2edb85e2ccccL;\n 0x15422a5784684242L;\n 0x5a98b4c22d2c9898L;\n 0xaaa4490e55eda4a4L;\n 0xa0285d8850752828L;\n 0x6d5cda31b8865c5cL;\n 0xc7f8933fed6bf8f8L;\n 0x228644a411c28686L;\n |];\n [|\n 0x186018c07830d818L;\n 0x238c2305af462623L;\n 0xc63fc67ef991b8c6L;\n 0xe887e8136fcdfbe8L;\n 0x8726874ca113cb87L;\n 0xb8dab8a9626d11b8L;\n 0x0104010805020901L;\n 0x4f214f426e9e0d4fL;\n 0x36d836adee6c9b36L;\n 0xa6a2a6590451ffa6L;\n 0xd26fd2debdb90cd2L;\n 0xf5f3f5fb06f70ef5L;\n 0x79f979ef80f29679L;\n 0x6fa16f5fcede306fL;\n 0x917e91fcef3f6d91L;\n 0x525552aa07a4f852L;\n 0x609d6027fdc04760L;\n 0xbccabc89766535bcL;\n 0x9b569baccd2b379bL;\n 0x8e028e048c018a8eL;\n 0xa3b6a371155bd2a3L;\n 0x0c300c603c186c0cL;\n 0x7bf17bff8af6847bL;\n 0x35d435b5e16a8035L;\n 0x1d741de8693af51dL;\n 0xe0a7e05347ddb3e0L;\n 0xd77bd7f6acb321d7L;\n 0xc22fc25eed999cc2L;\n 0x2eb82e6d965c432eL;\n 0x4b314b627a96294bL;\n 0xfedffea321e15dfeL;\n 0x5741578216aed557L;\n 0x155415a8412abd15L;\n 0x77c1779fb6eee877L;\n 0x37dc37a5eb6e9237L;\n 0xe5b3e57b56d79ee5L;\n 0x9f469f8cd923139fL;\n 0xf0e7f0d317fd23f0L;\n 0x4a354a6a7f94204aL;\n 0xda4fda9e95a944daL;\n 0x587d58fa25b0a258L;\n 0xc903c906ca8fcfc9L;\n 0x29a429558d527c29L;\n 0x0a280a5022145a0aL;\n 0xb1feb1e14f7f50b1L;\n 0xa0baa0691a5dc9a0L;\n 0x6bb16b7fdad6146bL;\n 0x852e855cab17d985L;\n 0xbdcebd8173673cbdL;\n 0x5d695dd234ba8f5dL;\n 0x1040108050209010L;\n 0xf4f7f4f303f507f4L;\n 0xcb0bcb16c08bddcbL;\n 0x3ef83eedc67cd33eL;\n 0x05140528110a2d05L;\n 0x6781671fe6ce7867L;\n 0xe4b7e47353d597e4L;\n 0x279c2725bb4e0227L;\n 0x4119413258827341L;\n 0x8b168b2c9d0ba78bL;\n 0xa7a6a7510153f6a7L;\n 0x7de97dcf94fab27dL;\n 0x956e95dcfb374995L;\n 0xd847d88e9fad56d8L;\n 0xfbcbfb8b30eb70fbL;\n 0xee9fee2371c1cdeeL;\n 0x7ced7cc791f8bb7cL;\n 0x66856617e3cc7166L;\n 0xdd53dda68ea77bddL;\n 0x175c17b84b2eaf17L;\n 0x47014702468e4547L;\n 0x9e429e84dc211a9eL;\n 0xca0fca1ec589d4caL;\n 0x2db42d75995a582dL;\n 0xbfc6bf9179632ebfL;\n 0x071c07381b0e3f07L;\n 0xad8ead012347acadL;\n 0x5a755aea2fb4b05aL;\n 0x8336836cb51bef83L;\n 0x33cc3385ff66b633L;\n 0x6391633ff2c65c63L;\n 0x020802100a041202L;\n 0xaa92aa39384993aaL;\n 0x71d971afa8e2de71L;\n 0xc807c80ecf8dc6c8L;\n 0x196419c87d32d119L;\n 0x4939497270923b49L;\n 0xd943d9869aaf5fd9L;\n 0xf2eff2c31df931f2L;\n 0xe3abe34b48dba8e3L;\n 0x5b715be22ab6b95bL;\n 0x881a8834920dbc88L;\n 0x9a529aa4c8293e9aL;\n 0x2698262dbe4c0b26L;\n 0x32c8328dfa64bf32L;\n 0xb0fab0e94a7d59b0L;\n 0xe983e91b6acff2e9L;\n 0x0f3c0f78331e770fL;\n 0xd573d5e6a6b733d5L;\n 0x803a8074ba1df480L;\n 0xbec2be997c6127beL;\n 0xcd13cd26de87ebcdL;\n 0x34d034bde4688934L;\n 0x483d487a75903248L;\n 0xffdbffab24e354ffL;\n 0x7af57af78ff48d7aL;\n 0x907a90f4ea3d6490L;\n 0x5f615fc23ebe9d5fL;\n 0x2080201da0403d20L;\n 0x68bd6867d5d00f68L;\n 0x1a681ad07234ca1aL;\n 0xae82ae192c41b7aeL;\n 0xb4eab4c95e757db4L;\n 0x544d549a19a8ce54L;\n 0x937693ece53b7f93L;\n 0x2288220daa442f22L;\n 0x648d6407e9c86364L;\n 0xf1e3f1db12ff2af1L;\n 0x73d173bfa2e6cc73L;\n 0x124812905a248212L;\n 0x401d403a5d807a40L;\n 0x0820084028104808L;\n 0xc32bc356e89b95c3L;\n 0xec97ec337bc5dfecL;\n 0xdb4bdb9690ab4ddbL;\n 0xa1bea1611f5fc0a1L;\n 0x8d0e8d1c8307918dL;\n 0x3df43df5c97ac83dL;\n 0x976697ccf1335b97L;\n 0x0000000000000000L;\n 0xcf1bcf36d483f9cfL;\n 0x2bac2b4587566e2bL;\n 0x76c57697b3ece176L;\n 0x82328264b019e682L;\n 0xd67fd6fea9b128d6L;\n 0x1b6c1bd87736c31bL;\n 0xb5eeb5c15b7774b5L;\n 0xaf86af112943beafL;\n 0x6ab56a77dfd41d6aL;\n 0x505d50ba0da0ea50L;\n 0x450945124c8a5745L;\n 0xf3ebf3cb18fb38f3L;\n 0x30c0309df060ad30L;\n 0xef9bef2b74c3c4efL;\n 0x3ffc3fe5c37eda3fL;\n 0x554955921caac755L;\n 0xa2b2a2791059dba2L;\n 0xea8fea0365c9e9eaL;\n 0x6589650fecca6a65L;\n 0xbad2bab9686903baL;\n 0x2fbc2f65935e4a2fL;\n 0xc027c04ee79d8ec0L;\n 0xde5fdebe81a160deL;\n 0x1c701ce06c38fc1cL;\n 0xfdd3fdbb2ee746fdL;\n 0x4d294d52649a1f4dL;\n 0x927292e4e0397692L;\n 0x75c9758fbceafa75L;\n 0x061806301e0c3606L;\n 0x8a128a249809ae8aL;\n 0xb2f2b2f940794bb2L;\n 0xe6bfe66359d185e6L;\n 0x0e380e70361c7e0eL;\n 0x1f7c1ff8633ee71fL;\n 0x62956237f7c45562L;\n 0xd477d4eea3b53ad4L;\n 0xa89aa829324d81a8L;\n 0x966296c4f4315296L;\n 0xf9c3f99b3aef62f9L;\n 0xc533c566f697a3c5L;\n 0x25942535b14a1025L;\n 0x597959f220b2ab59L;\n 0x842a8454ae15d084L;\n 0x72d572b7a7e4c572L;\n 0x39e439d5dd72ec39L;\n 0x4c2d4c5a6198164cL;\n 0x5e655eca3bbc945eL;\n 0x78fd78e785f09f78L;\n 0x38e038ddd870e538L;\n 0x8c0a8c148605988cL;\n 0xd163d1c6b2bf17d1L;\n 0xa5aea5410b57e4a5L;\n 0xe2afe2434dd9a1e2L;\n 0x6199612ff8c24e61L;\n 0xb3f6b3f1457b42b3L;\n 0x21842115a5423421L;\n 0x9c4a9c94d625089cL;\n 0x1e781ef0663cee1eL;\n 0x4311432252866143L;\n 0xc73bc776fc93b1c7L;\n 0xfcd7fcb32be54ffcL;\n 0x0410042014082404L;\n 0x515951b208a2e351L;\n 0x995e99bcc72f2599L;\n 0x6da96d4fc4da226dL;\n 0x0d340d68391a650dL;\n 0xfacffa8335e979faL;\n 0xdf5bdfb684a369dfL;\n 0x7ee57ed79bfca97eL;\n 0x2490243db4481924L;\n 0x3bec3bc5d776fe3bL;\n 0xab96ab313d4b9aabL;\n 0xce1fce3ed181f0ceL;\n 0x1144118855229911L;\n 0x8f068f0c8903838fL;\n 0x4e254e4a6b9c044eL;\n 0xb7e6b7d1517366b7L;\n 0xeb8beb0b60cbe0ebL;\n 0x3cf03cfdcc78c13cL;\n 0x813e817cbf1ffd81L;\n 0x946a94d4fe354094L;\n 0xf7fbf7eb0cf31cf7L;\n 0xb9deb9a1676f18b9L;\n 0x134c13985f268b13L;\n 0x2cb02c7d9c58512cL;\n 0xd36bd3d6b8bb05d3L;\n 0xe7bbe76b5cd38ce7L;\n 0x6ea56e57cbdc396eL;\n 0xc437c46ef395aac4L;\n 0x030c03180f061b03L;\n 0x5645568a13acdc56L;\n 0x440d441a49885e44L;\n 0x7fe17fdf9efea07fL;\n 0xa99ea921374f88a9L;\n 0x2aa82a4d8254672aL;\n 0xbbd6bbb16d6b0abbL;\n 0xc123c146e29f87c1L;\n 0x535153a202a6f153L;\n 0xdc57dcae8ba572dcL;\n 0x0b2c0b582716530bL;\n 0x9d4e9d9cd327019dL;\n 0x6cad6c47c1d82b6cL;\n 0x31c43195f562a431L;\n 0x74cd7487b9e8f374L;\n 0xf6fff6e309f115f6L;\n 0x4605460a438c4c46L;\n 0xac8aac092645a5acL;\n 0x891e893c970fb589L;\n 0x145014a04428b414L;\n 0xe1a3e15b42dfbae1L;\n 0x165816b04e2ca616L;\n 0x3ae83acdd274f73aL;\n 0x69b9696fd0d20669L;\n 0x092409482d124109L;\n 0x70dd70a7ade0d770L;\n 0xb6e2b6d954716fb6L;\n 0xd067d0ceb7bd1ed0L;\n 0xed93ed3b7ec7d6edL;\n 0xcc17cc2edb85e2ccL;\n 0x4215422a57846842L;\n 0x985a98b4c22d2c98L;\n 0xa4aaa4490e55eda4L;\n 0x28a0285d88507528L;\n 0x5c6d5cda31b8865cL;\n 0xf8c7f8933fed6bf8L;\n 0x86228644a411c286L;\n |];\n |]\n\n let whirlpool_do_chunk :\n type a. be64_to_cpu:(a -> int -> int64) -> ctx -> a -> int -> unit =\n fun ~be64_to_cpu ctx buf off ->\n let key = Array.init 2 (fun _ -> Array.make 8 Int64.zero) in\n let state = Array.init 2 (fun _ -> Array.make 8 Int64.zero) in\n let m = ref 0 in\n let rc =\n [|\n 0x1823c6e887b8014fL;\n 0x36a6d2f5796f9152L;\n 0x60bc9b8ea30c7b35L;\n 0x1de0d7c22e4bfe57L;\n 0x157737e59ff04adaL;\n 0x58c9290ab1a06b85L;\n 0xbd5d10f4cb3e0567L;\n 0xe427418ba77d95d8L;\n 0xfbee7c66dd17479eL;\n 0xca2dbf07ad5a8333L;\n |] in\n for i = 0 to 7 do\n key.(0).(i) <- ctx.h.(i) ;\n let off = off + (i * 8) in\n state.(0).(i) <- Int64.(be64_to_cpu buf off lxor ctx.h.(i)) ;\n ctx.h.(i) <- state.(0).(i)\n done ;\n let wp_op src shift =\n let mask v = Int64.(to_int (v land 0xffL)) in\n let get_k i =\n k.(i).(mask\n (Int64.shift_right src.((shift + 8 - i) land 7) (56 - (8 * i))))\n in\n Array.fold_left Int64.logxor Int64.zero (Array.init 8 get_k) in\n for i = 0 to 9 do\n let m0, m1 = (!m, !m lxor 1) in\n let upd_key i = key.(m1).(i) <- wp_op key.(m0) i in\n let upd_state i =\n state.(m1).(i) <- Int64.(wp_op state.(m0) i lxor key.(m1).(i)) in\n for i = 0 to 7 do\n upd_key i\n done ;\n key.(m1).(0) <- Int64.(key.(m1).(0) lxor rc.(i)) ;\n for i = 0 to 7 do\n upd_state i\n done ;\n m := !m lxor 1\n done ;\n let upd_hash i = Int64.(ctx.h.(i) <- ctx.h.(i) lxor state.(0).(i)) in\n for i = 0 to 7 do\n upd_hash i\n done ;\n ()\n\n let feed :\n type a.\n blit:(a -> int -> By.t -> int -> int -> unit) ->\n be64_to_cpu:(a -> int -> int64) ->\n ctx ->\n a ->\n int ->\n int ->\n unit =\n fun ~blit ~be64_to_cpu ctx buf off len ->\n let idx = ref Int64.(to_int (ctx.size land 0x3FL)) in\n let len = ref len in\n let off = ref off in\n let to_fill = 64 - !idx in\n ctx.size <- Int64.add ctx.size (Int64.of_int !len) ;\n if !idx <> 0 && !len >= to_fill\n then (\n blit buf !off ctx.b !idx to_fill ;\n whirlpool_do_chunk ~be64_to_cpu:By.be64_to_cpu ctx ctx.b 0 ;\n len := !len - to_fill ;\n off := !off + to_fill ;\n idx := 0) ;\n while !len >= 64 do\n whirlpool_do_chunk ~be64_to_cpu ctx buf !off ;\n len := !len - 64 ;\n off := !off + 64\n done ;\n if !len <> 0 then blit buf !off ctx.b !idx !len ;\n ()\n\n let unsafe_feed_bytes = feed ~blit:By.blit ~be64_to_cpu:By.be64_to_cpu\n\n let unsafe_feed_bigstring =\n feed ~blit:By.blit_from_bigstring ~be64_to_cpu:Bi.be64_to_cpu\n\n let unsafe_get ctx =\n let index = Int64.(to_int (ctx.size land 0x3FL)) + 1 in\n By.set ctx.b (index - 1) '\\x80' ;\n if index > 32\n then (\n By.fill ctx.b index (64 - index) '\\x00' ;\n whirlpool_do_chunk ~be64_to_cpu:By.be64_to_cpu ctx ctx.b 0 ;\n By.fill ctx.b 0 56 '\\x00')\n else By.fill ctx.b index (56 - index) '\\x00' ;\n By.cpu_to_be64 ctx.b 56 Int64.(ctx.size lsl 3) ;\n whirlpool_do_chunk ~be64_to_cpu:By.be64_to_cpu ctx ctx.b 0 ;\n let res = By.create (8 * 8) in\n for i = 0 to 7 do\n By.cpu_to_be64 res (i * 8) ctx.h.(i)\n done ;\n res\nend\n","# 1 \"src/digestif_eq.ml\"\nmodule Make (D : sig\n val digest_size : int\nend) =\nstruct\n let _ = D.digest_size\n\n let equal a b = Eqaf.equal a b\n\n let unsafe_compare a b = String.compare a b\nend\n","let[@inline always] char_chr ch =\n (* Char.chr contains a branch on [ch] and a plt indirection, this\n * implementation ensures well-formedness by construction and avoids that: *)\n Char.unsafe_chr (ch land 0xff)\n\nlet[@inline] get x i = String.unsafe_get x i |> Char.code\n\n(* XXX(dinosaure): we use [unsafe_get] to avoid jump to exception:\n\n sarq $1, %rbx\n movzbq (%rax,%rbx), %rax\n leaq 1(%rax,%rax), %rax\n ret\n*)\n\nexternal unsafe_get_int16 : string -> int -> int = \"%caml_string_get16u\"\nlet[@inline] get16 x i = unsafe_get_int16 x i\n\n(* XXX(dinosaure): same as [unsafe_get] but for [int16]:\n\n sarq $1, %rbx\n movzwq (%rax,%rbx), %rax\n leaq 1(%rax,%rax), %rax\n ret\n*)\n\nlet equal ~ln a b =\n let l1 = ln asr 1 in\n\n (*\n sarq $1, %rcx\n orq $1, %rcx\n *)\n\n let r = ref 0 in\n\n (*\n movq $1, %rdx\n *)\n\n for i = 0 to pred l1 do r := !r lor (get16 a (i * 2) lxor get16 b (i * 2)) done ;\n\n (*\n movq $1, %rsi\n addq $-2, %rcx\n cmpq %rcx, %rsi\n jg .L104\n.L105:\n leaq -1(%rsi,%rsi), %r8\n\n sarq $1, %r8\n movzwq (%rdi,%r8), %r9\n leaq 1(%r9,%r9), %r9\n movzwq (%rbx,%r8), %r8\n leaq 1(%r8,%r8), %r8\n\n // [unsafe_get_int16 a i] and [unsafe_get_int6 b i]\n\n xorq %r9, %r8\n orq $1, %r8\n orq %r8, %rdx\n movq %rsi, %r8\n addq $2, %rsi\n cmpq %rcx, %r8\n jne .L105\n.L104:\n *)\n\n for _ = 1 to ln land 1 do r := !r lor (get a (ln - 1) lxor get b (ln - 1)) done ;\n\n (*\n movq $3, %rsi\n movq %rax, %rcx\n andq $3, %rcx\n cmpq %rcx, %rsi\n jg .L102\n.L103:\n movq %rax, %r8\n addq $-2, %r8\n\n sarq $1, %r8\n movzbq (%rdi,%r8), %r9\n leaq 1(%r9,%r9), %r9\n movzbq (%rbx,%r8), %r8\n leaq 1(%r8,%r8), %r8\n\n // [unsafe_get a i] and [unsafe_get b i]\n\n xorq %r9, %r8\n orq $1, %r8\n orq %r8, %rdx\n movq %rsi, %r8\n addq $2, %rsi\n cmpq %rcx, %r8\n jne .L103\n.L102:\n *)\n\n !r = 0\n\n(*\n cmpq $1, %rdx\n sete %al\n movzbq %al, %rax\n leaq 1(%rax,%rax), %rax\n ret\n*)\n\nlet equal a b =\n let al = String.length a in\n let bl = String.length b in\n if al <> bl\n then false\n else equal ~ln:al a b\n\nlet[@inline always] compare (a:int) b = a - b\nlet[@inline always] sixteen_if_minus_one_or_less n = (n asr Sys.int_size) land 16\nlet[@inline always] eight_if_one_or_more n = ((-n) asr Sys.int_size) land 8\n\nlet compare_le ~ln a b =\n let r = ref 0 in\n let i = ref (pred ln) in\n\n while !i >= 0 do\n let xa = get a !i and xb = get b !i in\n let c = compare xa xb in\n r := !r lor ((sixteen_if_minus_one_or_less c + eight_if_one_or_more c) lsr !r) ;\n decr i ;\n done ;\n\n (!r land 8) - (!r land 16)\n\nlet compare_le_with_len ~len:ln a b =\n let al = String.length a in\n let bl = String.length b in\n if ln = 0 then 0\n else if (al lxor ln) lor (bl lxor ln) <> 0\n then invalid_arg \"compare_le_with_len\"\n else compare_le ~ln a b\n\nlet compare_le a b =\n let al = String.length a in\n let bl = String.length b in\n if al < bl\n then 1\n else if al > bl\n then (-1)\n else compare_le ~ln:al (* = bl *) a b\n\nlet compare_be ~ln a b =\n let r = ref 0 in\n let i = ref 0 in\n\n while !i < ln do\n let xa = get a !i and xb = get b !i in\n let c = compare xa xb in\n r := !r lor ((sixteen_if_minus_one_or_less c + eight_if_one_or_more c) lsr !r) ;\n incr i ;\n done ;\n\n (!r land 8) - (!r land 16)\n\nlet compare_be_with_len ~len:ln a b =\n let al = String.length a in\n let bl = String.length b in\n if ln = 0 then 0\n else if (al lxor ln) lor (bl lxor ln) <> 0\n then invalid_arg \"compare_be_with_len\"\n else compare_be ~ln a b\n\nlet compare_be a b =\n let al = String.length a in\n let bl = String.length b in\n if al < bl then 1\n else if al > bl then (-1)\n else compare_be ~ln:al (* = bl *) a b\n\nlet[@inline always] minus_one_or_less n =\n n lsr (Sys.int_size - 1)\n\nlet[@inline always] one_if_not_zero n =\n minus_one_or_less ((- n) lor n)\n\nlet[@inline always] zero_if_not_zero n =\n (one_if_not_zero n) - 1\n\nlet[@inline always] select_int choose_b a b =\n let mask = ((- choose_b) lor choose_b) asr Sys.int_size in\n (a land (lnot mask)) lor (b land mask)\n\nexternal int_of_bool : bool -> int = \"%identity\"\nexternal unsafe_bool_of_int : int -> bool = \"%identity\"\n\nlet[@inline] bool_of_int n =\n unsafe_bool_of_int (one_if_not_zero n)\n\nlet[@inline always] find_uint8 ~off ~len ~f str =\n let i = ref (len - 1) in\n let a = ref (lnot 0) in\n while !i >= off do\n let byte = get str !i in\n let pred = int_of_bool (f byte) in\n (* XXX(dinosaure): a composition of [f] with [bool_of_int] such as\n [let f = bool_of_int <.> f in] implies an allocation (of a closure).\n To be GC-free, we must store result of [f] into a register, and apply\n [bool_of_int] then (introspection was done on OCaml 4.08.1). *)\n a := select_int (((!i - off) land min_int) lor pred) !a !i ;\n decr i ;\n done ; !a\n\nlet find_uint8 ?(off= 0) ~f str =\n (* XXX(dinosaure): with this overload, OCaml is able to produce 2 [find_uint8].\n One with [off= 0] and one other where [off] is an argument. I think it's about\n cross-module optimization where a call to [find_uint8 ~f v] will directly call\n the first one and a call to [find_uint8 ~off:x ~f v] will call the second one. *)\n let len = String.length str in\n find_uint8 ~off ~len ~f str\n\nlet exists_uint8 ?off ~f str =\n let v = find_uint8 ?off ~f str in\n let r = select_int (v + 1) 0 1 in\n unsafe_bool_of_int r\n\nlet divmod ~(x:int32) ~(m:int32) : int32 * int32 =\n (* Division and remainder being constant-time with respect to [x]\n * ( NOT [m] !). The OCaml variant would be:\n * [(x / m , x mod m)] where [x] is a secret and [m] is not secret.\n * Adapted from the NTRU Prime team's algorithm from\n * supercop/crypto_kem/sntrup761/ref/uint32.c\n * cite the round-2 ntru prime submission to nistpqc (march 2019)\n * Note that in practice this works for at least some much larger [x] and [m],\n * but it's unclear to me how to evaluate *which*, so leaving the original\n * restrictions in.\n *)\n let ( - ) , ( + ), ( * ) = Int32.(sub, add, mul) in\n let ( >> ) = Int32.shift_right_logical in\n if (m <= 0l) then raise (Invalid_argument \"m <= 0\") ;\n if (m >= 16348l) then raise (Invalid_argument \"m >= 16348 not supported\") ;\n\n let of_uint32 uint =\n (* apparently Int64.of_int32 sign-extends ... great... avoid that: *)\n let b = Bytes.make 8 '\\x00' in\n Unsafe.set_int32_le b 0 uint ;\n Unsafe.get_int64_le b 0\n in\n\n let x_0 = x in\n\n let x_2, q_1 =\n let int32_div_unsigned n d =\n (* can be replaced by Int32.unsigned_div\n * from OCaml >= 4.10 *)\n let sub,min_int = Int32.(sub,min_int)in\n let int32_unsigned_compare n m =\n Int32.compare (sub n min_int) (sub m min_int)\n in\n if d < 0_l then\n if int32_unsigned_compare n d < 0 then 0_l else 1_l\n else\n let q =\n let open Int32 in\n shift_left (Int32.div (Int32.shift_right_logical n 1) d) 1 in\n let r = sub n (Int32.mul q d) in\n if int32_unsigned_compare r d >= 0 then Int32.succ q else q\n in\n let v = int32_div_unsigned Int32.min_int m |> of_uint32 in\n (*let v = 0x80_00_00_00 / m in*) (* floored div *)\n let x_1, q_0 =\n let qpart_0 =\n let open Int64 in\n shift_right_logical (mul (of_uint32 x_0) v) 31\n |> to_int32\n in\n x_0 - (qpart_0 * m), qpart_0\n in\n let qpart_1 =\n let open Int64 in\n shift_right_logical (mul (of_uint32 x_1) v) 31\n |> to_int32 in\n x_1 - (qpart_1 * m),\n (q_0 + qpart_1 + 1l) in\n let x_3 = x_2 - m in\n let mask = 0l - (x_3 >> 31) in\n q_1 + mask, x_3 + (Int32.logand mask m)\n\nlet ascii_of_int32 ~digits (n:int32) : string =\n (* Recursively calls [divmod n 10]; the remainder is turned into ASCII\n and the quotient is used for the next division.*)\n if digits < 0 then raise (Invalid_argument \"digits < 0\");\n let out = Bytes.make digits '0' in\n let rec loop x = function\n | -1 -> Bytes.unsafe_to_string out\n | idx ->\n let next, this = divmod ~x ~m:10l in\n Bytes.set out idx @@ char_chr (0x30 lor (Int32.to_int this)) ;\n loop next (pred idx)\n in loop n (pred digits)\n\nlet[@inline always] to_hex_nibble f : char =\n let a = 86 + f in\n let c = 1 + ((a - 71 * ((a land 0x10) lsr 4)) lor 0x20) in\n char_chr c\n\nlet hex_of_string rawbytes =\n String.init (2 * String.length rawbytes)\n (fun idx ->\n let byt = String.get rawbytes (idx lsr 1) |> Char.code in\n (* select which 4 bits to use, this can probably be done faster:*)\n let nib = 0xf land (byt lsr (((lnot idx) land 1) lsl 2)) in\n to_hex_nibble nib)\n\nlet hex_of_bytes rawbytes = hex_of_string (Bytes.unsafe_to_string rawbytes)\n\nlet[@inline always] select_a_if_in_range ~low ~high ~n a b =\n (* select [a] if [low <= n <= high] and [b] if [n] is out of range.*)\n (* NB: ONLY WORKS FOR [0 <= low <= high <= max_int]*)\n (* The idea being that:\n 1.a) if low <= n : (n - low) is positive +\n 1.b) if low > n : (n - low) is negative -\n 2.a) if n <= high: (high - n) is positive +\n 2.b) if n > high: (high - n) is negative -\n We OR the numbers together; we only really care about the sign bit\n which is set when negative.\n Thus both numbers are positive iff (low <= n && n <= high).\n We then select the sign bit with (land min_int) and use that to choose:\n *)\n let out_of_range = (* choose b if out of range *)\n ((n - low) lor (high - n)\n land min_int)\n in\n select_int out_of_range a b\n\nlet lowercase_ascii src =\n (* ct version of String.lowercase_ascii *)\n String.map\n ( fun ch -> let n = Char.code ch in\n (* 0x41 is 'A'; 0x5a is 'Z'; 0x20 controls case for ASCII letters *)\n select_a_if_in_range ~low:0x41 ~high:0x5a ~n (n lor 0x20) (n)\n |> char_chr\n ) src\n\nlet uppercase_ascii src =\n (* ct version of String.uppercase_ascii *)\n String.map\n ( fun ch -> let n = Char.code ch in\n (* 0x61 is 'a'; 0x7a is 'z'; 0x20 controls case for ASCII letters *)\n select_a_if_in_range ~low:0x61 ~high:0x7a ~n (n lxor 0x20) (n)\n |> char_chr\n ) src\n\nlet bytes_of_hex rawhex =\n (* hex length must be multiple of 2: *)\n let error_bitmap = ref ((String.length rawhex land 1) lsl 4) in\n let decoded =\n Bytes.init (String.length rawhex lsr 1)\n (fun idx ->\n let idx = idx lsl 1 in\n let nib idx =\n String.get rawhex idx\n |> Char.code\n |> fun n -> (* uppercase -> lowercase: *)\n select_a_if_in_range ~low:0x41 ~high:0x5a\n ~n\n (n lor 0x20) (* set case bit *)\n n (* leave as-is *)\n |> fun n -> (* now either invalid; lowercase; numeric*)\n (select_a_if_in_range ~low:0x30 ~high:0x39\n ~n\n (n - 0x30) (* numeric: subtract '0' to get [0..9] *)\n (select_a_if_in_range ~low:0x61 ~high:0x66\n ~n\n (* a-f: subtract 'a' and add 10 to get [10..15]: *)\n (n - 0x61 + 10)\n (0xff) (* invalid, ensure we set upper bits of error_bitmap *)\n )\n )\n in\n let nibf0 = nib idx\n and nib0f = nib (succ idx) in\n error_bitmap := !error_bitmap lor nibf0 lor nib0f ;\n char_chr ((nibf0 lsl 4) lor nib0f)\n )\n in\n (* if any non-nibble bits were set in !error_bitmap, decoding failed: *)\n decoded, !error_bitmap land (lnot 0xf)\n\nlet string_of_hex rawhex =\n let byt, error = bytes_of_hex rawhex in\n Bytes.unsafe_to_string byt, error\n","open Core_kernel\nopen Async_kernel\n\n[%%import \"/src/config.mlh\"]\n\nmodule Spec = struct\n type t =\n | On_disk of { directory : string; should_write : bool }\n | S3 of { bucket_prefix : string; install_path : string }\nend\n\n[%%inject \"may_download\", download_snark_keys]\n\nlet may_download = ref may_download\n\nlet set_downloads_enabled b = may_download := b\n\nlet may_download () = !may_download\n\nmodule T (M : sig\n type _ t\nend) =\nstruct\n type ('a, 'b) t = { write : 'a -> 'b -> unit M.t; read : 'a -> 'b M.t }\nend\n\nmodule Disk_storable (M : sig\n type _ t\nend) =\nstruct\n type ('k, 'v) t =\n { to_string : 'k -> string\n ; read : 'k -> path:string -> 'v M.t\n ; write : 'k -> 'v -> string -> unit M.t\n }\nend\n\nmodule type S = sig\n module M : sig\n type _ t\n end\n\n type ('a, 'b) t = ('a, 'b) T(M).t =\n { write : 'a -> 'b -> unit M.t; read : 'a -> 'b M.t }\n\n module Disk_storable : sig\n type ('k, 'v) t = ('k, 'v) Disk_storable(M).t =\n { to_string : 'k -> string\n ; read : 'k -> path:string -> 'v M.t\n ; write : 'k -> 'v -> string -> unit M.t\n }\n\n val of_binable :\n ('k -> string) -> (module Binable.S with type t = 'v) -> ('k, 'v) t\n\n val simple :\n ('k -> string)\n -> ('k -> path:string -> 'v M.t)\n -> ('k -> 'v -> string -> unit M.t)\n -> ('k, 'v) t\n end\n\n val read :\n Spec.t list\n -> ('k, 'v) Disk_storable.t\n -> 'k\n -> ('v * [> `Cache_hit | `Locally_generated ]) M.t\n\n val write : Spec.t list -> ('k, 'v) Disk_storable.t -> 'k -> 'v -> unit M.t\nend\n\nmodule type Sync = S with module M := Or_error\n\nmodule type Async = S with module M := Deferred.Or_error\n\nmodule Trivial : Sync = struct\n include T (Or_error)\n\n module Disk_storable = struct\n include Disk_storable (Or_error)\n\n let of_binable to_string _m =\n let read _ ~path:_ =\n Or_error.error_string \"Key_cache: Trivial store cannot read\"\n in\n let write _k _t _path = Ok () in\n { to_string; read; write }\n\n let simple to_string read write = { to_string; read; write }\n end\n\n let read _spec { Disk_storable.to_string = _; read = _; write = _ } _k =\n Or_error.error_string \"Key_cache: Trivial store cannot read\"\n\n let write _spec { Disk_storable.to_string = _; read = _; write = _ } _k _v =\n Ok ()\nend\n\nmodule Trivial_async : Async = struct\n include T (Deferred.Or_error)\n\n module Disk_storable = struct\n include Disk_storable (Deferred.Or_error)\n\n let of_binable to_string _m =\n let read _ ~path:_ =\n Deferred.Or_error.error_string \"Key_cache: Trivial store cannot read\"\n in\n let write _k _t _path = Deferred.Or_error.return () in\n { to_string; read; write }\n\n let simple to_string read write = { to_string; read; write }\n end\n\n let read _spec { Disk_storable.to_string = _; read = _; write = _ } _k =\n Deferred.Or_error.error_string \"Key_cache: Trivial store cannot read\"\n\n let write _spec { Disk_storable.to_string = _; read = _; write = _ } _k _v =\n Deferred.Or_error.return ()\nend\n\nlet sync = ref (module Trivial : Sync)\n\nlet async = ref (module Trivial_async : Async)\n\nlet set_sync_implementation x = sync := x\n\nlet set_async_implementation x = async := x\n\nmodule Sync : Sync = struct\n include T (Or_error)\n\n module Disk_storable = struct\n include Disk_storable (Or_error)\n\n let of_binable to_string binable =\n let (module M) = !sync in\n M.Disk_storable.of_binable to_string binable\n\n let simple to_string read write =\n let (module M) = !sync in\n M.Disk_storable.simple to_string read write\n end\n\n let read spec ds k =\n let (module M) = !sync in\n M.read spec ds k\n\n let write spec ds k v =\n let (module M) = !sync in\n M.write spec ds k v\nend\n\nmodule Async : Async = struct\n include T (Deferred.Or_error)\n\n module Disk_storable = struct\n include Disk_storable (Deferred.Or_error)\n\n let of_binable to_string binable =\n let (module M) = !async in\n M.Disk_storable.of_binable to_string binable\n\n let simple to_string read write =\n let (module M) = !async in\n M.Disk_storable.simple to_string read write\n end\n\n let read spec ds k =\n let (module M) = !async in\n M.read spec ds k\n\n let write spec ds k v =\n let (module M) = !async in\n M.write spec ds k v\nend\n","open Core_kernel\n\nmodule Partial = struct\n module Bin_io (M : Intf.Input.Bin_io_intf) :\n Intf.Partial.Bin_io_intf with type t := M.t = struct\n open Bin_prot.Type_class\n\n let bin_size_t = M.bin_size_t\n\n let bin_write_t = M.bin_write_t\n\n let bin_read_t buf ~pos_ref =\n Table.attach_finalizer M.id (M.bin_read_t buf ~pos_ref)\n\n let __bin_read_t__ buf ~pos_ref i =\n Table.attach_finalizer M.id (M.__bin_read_t__ buf ~pos_ref i)\n\n let bin_shape_t = M.bin_shape_t\n\n let bin_writer_t = M.bin_writer_t\n\n let bin_reader_t = { read = bin_read_t; vtag_read = __bin_read_t__ }\n\n let bin_t =\n { shape = bin_shape_t; writer = bin_writer_t; reader = bin_reader_t }\n end\n\n module Sexp (M : Intf.Input.Sexp_intf) :\n Intf.Partial.Sexp_intf with type t := M.t = struct\n let sexp_of_t = M.sexp_of_t\n\n let t_of_sexp t = Table.attach_finalizer M.id (M.t_of_sexp t)\n end\n\n module Yojson (M : Intf.Input.Yojson_intf) :\n Intf.Partial.Yojson_intf with type t := M.t = struct\n let to_yojson = M.to_yojson\n\n let of_yojson json =\n M.of_yojson json |> Result.map ~f:(Table.attach_finalizer M.id)\n end\nend\n\nmodule Basic (M : Intf.Input.Basic_intf) :\n Intf.Output.Basic_intf with type t = M.t and type 'a creator := 'a M.creator =\nstruct\n type t = M.t\n\n let create = M.map_creator M.create ~f:(Table.attach_finalizer M.id)\nend\n\nmodule Bin_io (M : Intf.Input.Bin_io_intf) :\n Intf.Output.Bin_io_intf with type t = M.t and type 'a creator := 'a M.creator =\nstruct\n include Basic (M)\n include Partial.Bin_io (M)\nend\n\nmodule Sexp (M : Intf.Input.Sexp_intf) :\n Intf.Output.Sexp_intf with type t = M.t and type 'a creator := 'a M.creator =\nstruct\n include Basic (M)\n include Partial.Sexp (M)\nend\n\nmodule Bin_io_and_sexp (M : Intf.Input.Bin_io_and_sexp_intf) :\n Intf.Output.Bin_io_and_sexp_intf\n with type t = M.t\n and type 'a creator := 'a M.creator = struct\n include Basic (M)\n include Partial.Bin_io (M)\n include Partial.Sexp (M)\nend\n\nmodule Yojson (M : Intf.Input.Yojson_intf) :\n Intf.Output.Yojson_intf with type t = M.t and type 'a creator := 'a M.creator =\nstruct\n include Basic (M)\n include Partial.Yojson (M)\nend\n\nmodule Bin_io_and_yojson (M : Intf.Input.Bin_io_and_yojson_intf) :\n Intf.Output.Bin_io_and_yojson_intf\n with type t = M.t\n and type 'a creator := 'a M.creator = struct\n include Basic (M)\n include Partial.Bin_io (M)\n include Partial.Yojson (M)\nend\n\nmodule Full (M : Intf.Input.Full_intf) :\n Intf.Output.Full_intf with type t = M.t and type 'a creator := 'a M.creator =\nstruct\n include Basic (M)\n include Partial.Bin_io (M)\n include Partial.Sexp (M)\n include Partial.Yojson (M)\nend\n\nmodule Versioned_v1 = struct\n module Basic_intf (M : Intf.Input.Versioned_v1.Basic_intf) : sig\n include\n Intf.Output.Versioned_v1.Basic_intf\n with type Stable.V1.t = M.Stable.V1.t\n and type 'a Stable.V1.creator = 'a M.Stable.V1.creator\n end = struct\n module Stable = struct\n module V1 = struct\n include Bin_io (struct\n let id = M.id\n\n include M.Stable.V1\n end)\n\n let __versioned__ = ()\n\n type 'a creator = 'a M.Stable.V1.creator\n end\n\n module Latest = V1\n end\n\n type t = Stable.V1.t\n end\n\n module Sexp (M : Intf.Input.Versioned_v1.Sexp_intf) : sig\n include\n Intf.Output.Versioned_v1.Sexp_intf\n with type Stable.V1.t = M.Stable.V1.t\n and type 'a Stable.V1.creator = 'a M.Stable.V1.creator\n end = struct\n module Stable = struct\n module V1 = struct\n include Bin_io_and_sexp (struct\n let id = M.id\n\n include M.Stable.V1\n end)\n\n let __versioned__ = ()\n\n type 'a creator = 'a M.Stable.V1.creator\n end\n\n module Latest = V1\n end\n\n type t = Stable.V1.t\n end\n\n module Yojson (M : Intf.Input.Versioned_v1.Yojson_intf) : sig\n include\n Intf.Output.Versioned_v1.Yojson_intf\n with type Stable.V1.t = M.Stable.V1.t\n and type 'a Stable.V1.creator = 'a M.Stable.V1.creator\n end = struct\n module Stable = struct\n module V1 = struct\n include Bin_io_and_yojson (struct\n let id = M.id\n\n include M.Stable.V1\n end)\n\n let __versioned__ = ()\n\n type 'a creator = 'a M.Stable.V1.creator\n end\n\n module Latest = V1\n end\n\n type t = Stable.V1.t\n end\n\n module Full_compare_eq_hash\n (M : Intf.Input.Versioned_v1.Full_compare_eq_hash_intf) : sig\n include\n Intf.Output.Versioned_v1.Full_compare_eq_hash_intf\n with type Stable.V1.t = M.Stable.V1.t\n and type 'a Stable.V1.creator = 'a M.Stable.V1.creator\n end = struct\n module Stable = struct\n module V1 = struct\n include Full (struct\n let id = M.id\n\n include M.Stable.V1\n end)\n\n let compare = M.Stable.V1.compare\n\n let equal = M.Stable.V1.equal\n\n let hash = M.Stable.V1.hash\n\n let hash_fold_t = M.Stable.V1.hash_fold_t\n\n let __versioned__ = ()\n\n type 'a creator = 'a M.Stable.V1.creator\n end\n\n module Latest = V1\n end\n\n type t = Stable.V1.t\n\n let equal = M.equal\n\n let compare = M.compare\n\n let hash = M.hash\n\n let hash_fold_t = M.hash_fold_t\n end\n\n module Full (M : Intf.Input.Versioned_v1.Full_intf) : sig\n include\n Intf.Output.Versioned_v1.Full_intf\n with type Stable.V1.t = M.Stable.V1.t\n and type 'a Stable.V1.creator = 'a M.Stable.V1.creator\n end = struct\n module Stable = struct\n module V1 = struct\n include Full (struct\n let id = M.id\n\n include M.Stable.V1\n end)\n\n let __versioned__ = ()\n\n type 'a creator = 'a M.Stable.V1.creator\n end\n\n module Latest = V1\n end\n\n type t = Stable.V1.t\n end\nend\n\nmodule Versioned_v2 = struct\n module Sexp (M : Intf.Input.Versioned_v2.Sexp_intf) : sig\n include\n Intf.Output.Versioned_v2.Sexp_intf\n with type Stable.V2.t = M.Stable.V2.t\n and type 'a Stable.V2.creator = 'a M.Stable.V2.creator\n and type Stable.V1.t = M.Stable.V1.t\n and type 'a Stable.V1.creator = 'a M.Stable.V1.creator\n end = struct\n module Stable = struct\n module V2 = struct\n include Bin_io_and_sexp (struct\n let id = M.id\n\n include M.Stable.V2\n end)\n\n let __versioned__ = ()\n\n type 'a creator = 'a M.Stable.V2.creator\n end\n\n module V1 = struct\n include Bin_io_and_sexp (struct\n let id = M.id\n\n include M.Stable.V1\n end)\n\n let __versioned__ = ()\n\n type 'a creator = 'a M.Stable.V1.creator\n\n let to_latest = M.Stable.V1.to_latest\n end\n\n module Latest = V2\n end\n\n type t = Stable.V2.t\n end\nend\n","type 'a t\n\nexternal run_in_thread : (unit -> 'a) -> 'a t = \"deferred_run\"\n\nlet block_on_async_exn (_ : unit -> 'a t) : 'a =\n failwith \"You can't block on async execution in JS\"\n\nexternal map : 'a t -> f:('a -> 'b) -> 'b t = \"deferred_map\"\n\nexternal bind : 'a t -> f:('a -> 'b t) -> 'b t = \"deferred_bind\"\n\nexternal upon : 'a t -> ('a -> unit) -> unit = \"deferred_upon\"\n\nexternal upon_exn : 'a t -> ('a -> unit) -> unit = \"deferred_upon_exn\"\n\nexternal is_determined : 'a t -> bool = \"deferred_is_determined\"\n\nexternal peek : 'a t -> 'a option = \"deferred_peek\"\n\nexternal value_exn : 'a t -> 'a = \"deferred_value_exn\"\n\nexternal return : 'a -> 'a t = \"deferred_return\"\n\nexternal create : (('a -> unit) -> unit) -> 'a t = \"deferred_create\"\n\nlet to_deferred promise =\n let module Ivar = Async_kernel.Ivar in\n let ivar = Ivar.create () in\n upon_exn promise (fun x -> Ivar.fill ivar x) ;\n Ivar.read ivar\n\ninclude Base.Monad.Make (struct\n type nonrec 'a t = 'a t\n\n let map = `Custom map\n\n let bind = bind\n\n let return = return\nend)\n","open Core_kernel\n\nlet key = Univ_map.Key.create ~name:\"logger\" sexp_of_opaque\n\nlet with_logger logger f =\n Async_kernel.Async_kernel_scheduler.with_local key logger ~f\n\nlet get_opt () = Async_kernel.Async_kernel_scheduler.find_local key\n\nlet get () = Option.value (get_opt ()) ~default:(Logger.null ())\n","open Intf\nopen Core_kernel\n\nmodule type Inputs_intf = sig\n module Base_field : sig\n type t\n end\n\n module Curve : sig\n module Affine : sig\n type t = Base_field.t * Base_field.t\n\n module Backend : sig\n type t = Base_field.t Kimchi_types.or_infinity\n\n val zero : unit -> t\n\n val create : Base_field.t -> Base_field.t -> t\n end\n\n val of_backend :\n Backend.t -> (Base_field.t * Base_field.t) Pickles_types.Or_infinity.t\n end\n end\n\n module Backend : sig\n type t\n\n val make :\n Curve.Affine.Backend.t array -> Curve.Affine.Backend.t option -> t\n\n val shifted : t -> Curve.Affine.Backend.t option\n\n val unshifted : t -> Curve.Affine.Backend.t array\n end\nend\n\ntype 'a t =\n [ `With_degree_bound of\n ('a * 'a) Pickles_types.Or_infinity.t\n Pickles_types.Plonk_types.Poly_comm.With_degree_bound.t\n | `Without_degree_bound of\n ('a * 'a) Pickles_types.Plonk_types.Poly_comm.Without_degree_bound.t ]\n\nmodule Make (Inputs : Inputs_intf) = struct\n open Inputs\n module Backend = Backend\n\n type nonrec t = Base_field.t t\n\n module G_affine = Curve.Affine.Backend\n\n let g (a, b) = G_affine.create a b\n\n let g_vec arr = Array.map ~f:g arr\n\n let or_infinity_to_backend :\n ('a * 'a) Pickles_types.Or_infinity.t -> 'a Kimchi_types.or_infinity =\n function\n | Infinity ->\n Infinity\n | Finite (x, y) ->\n Finite (x, y)\n\n let or_infinity_of_backend :\n 'a Kimchi_types.or_infinity -> ('a * 'a) Pickles_types.Or_infinity.t =\n function\n | Infinity ->\n Infinity\n | Finite (x, y) ->\n Finite (x, y)\n\n let with_degree_bound_to_backend\n (commitment :\n (Base_field.t * Base_field.t) Pickles_types.Or_infinity.t\n Pickles_types.Plonk_types.Poly_comm.With_degree_bound.t ) : Backend.t =\n Backend.make\n (Array.map ~f:or_infinity_to_backend commitment.unshifted)\n (Some (or_infinity_to_backend commitment.shifted))\n\n let without_degree_bound_to_backend\n (commitment :\n (Base_field.t * Base_field.t)\n Pickles_types.Plonk_types.Poly_comm.Without_degree_bound.t ) : Backend.t\n =\n Backend.make\n (Array.map ~f:(fun x -> Kimchi_types.Finite (fst x, snd x)) commitment)\n None\n\n let to_backend (t : t) : Backend.t =\n match t with\n | `With_degree_bound t ->\n with_degree_bound_to_backend t\n | `Without_degree_bound t ->\n without_degree_bound_to_backend t\n\n let of_backend' (t : Backend.t) =\n ( Backend.unshifted t\n , Option.map (Backend.shifted t) ~f:Curve.Affine.of_backend )\n\n let of_backend_with_degree_bound (t : Backend.t) : t =\n let open Pickles_types.Plonk_types.Poly_comm in\n match Backend.shifted t with\n | None ->\n assert false\n | Some shifted ->\n let shifted = or_infinity_of_backend shifted in\n let unshifted =\n Backend.unshifted t |> Array.map ~f:or_infinity_of_backend\n in\n `With_degree_bound { unshifted; shifted }\n\n (*\n type 'a t =\n [ `With_degree_bound of\n ('a * 'a) Pickles_types.Or_infinity.t\n Pickles_types.Plonk_types.Poly_comm.With_degree_bound.t\n | `Without_degree_bound of\n ('a * 'a) Pickles_types.Plonk_types.Poly_comm.Without_degree_bound.t\n ]\n *)\n\n let of_backend_without_degree_bound (t : Backend.t) =\n let open Pickles_types.Plonk_types.Poly_comm in\n let unshifted = Backend.unshifted t in\n match Backend.shifted t with\n | None ->\n `Without_degree_bound\n (Array.map unshifted ~f:(function\n | Infinity ->\n assert false\n | Finite (x, y) ->\n (x, y) ) )\n | _ ->\n assert false\nend\n","open Core_kernel\nopen Intf\n\nmodule type Inputs_intf = sig\n module Verifier_index : T0\n\n module Field : sig\n type t\n end\n\n module Proof : sig\n type t\n\n module Challenge_polynomial : T0\n\n module Backend : sig\n type t\n end\n\n val to_backend :\n Challenge_polynomial.t list -> Field.t list -> t -> Backend.t\n end\n\n module Backend : sig\n type t = Field.t Kimchi_types.oracles\n\n val create : Verifier_index.t -> Proof.Backend.t -> t\n end\nend\n\nmodule Make (Inputs : Inputs_intf) = struct\n open Inputs\n\n let create vk prev_challenge input (pi : Proof.t) =\n let pi = Proof.to_backend prev_challenge input pi in\n Backend.create vk pi\n\n open Backend\n\n let scalar_challenge t = Scalar_challenge.create t\n\n let alpha (t : t) = t.o.alpha_chal\n\n let beta (t : t) = t.o.beta\n\n let gamma (t : t) = t.o.gamma\n\n let zeta (t : t) = t.o.zeta_chal\n\n let joint_combiner_chal (t : t) = Option.map ~f:fst t.o.joint_combiner\n\n let joint_combiner (t : t) = Option.map ~f:snd t.o.joint_combiner\n\n let digest_before_evaluations (t : t) = t.digest_before_evaluations\n\n let v (t : t) = t.o.v_chal\n\n let u (t : t) = t.o.u_chal\n\n let p_eval_1 (t : t) = fst t.p_eval\n\n let p_eval_2 (t : t) = snd t.p_eval\n\n let opening_prechallenges (t : t) =\n Array.map ~f:scalar_challenge t.opening_prechallenges\nend\n","(** number of witness *)\nlet columns = 15\n\n(** number of columns that take part in the permutation *)\nlet permutation_cols = 7\n","module Poly_comm0 = Poly_comm\nopen Unsigned.Size_t\n\nmodule type Stable_v1 = sig\n module Stable : sig\n module V1 : sig\n type t [@@deriving version, bin_io, sexp, compare, yojson, hash, equal]\n end\n\n module Latest = V1\n end\n\n type t = Stable.V1.t [@@deriving sexp, compare, yojson]\nend\n\nmodule type Inputs_intf = sig\n open Intf\n\n val name : string\n\n module Rounds : Pickles_types.Nat.Intf\n\n module Gate_vector : sig\n open Unsigned\n\n type t\n\n val wrap : t -> Kimchi_types.wire -> Kimchi_types.wire -> unit\n end\n\n module Urs : sig\n type t\n\n val read : int option -> string -> t option\n\n val write : bool option -> t -> string -> unit\n\n val create : int -> t\n end\n\n module Scalar_field : sig\n include Stable_v1\n\n val one : t\n end\n\n module Constraint_system : sig\n type t\n\n val get_primary_input_size : t -> int\n\n val get_prev_challenges : t -> int option\n\n val set_prev_challenges : t -> int -> unit\n\n val finalize_and_get_gates : t -> Gate_vector.t\n end\n\n module Index : sig\n type t\n\n (** [create\n gates\n nb_public\n runtime_tables_cfg\n nb_prev_challanges\n srs] *)\n val create :\n Gate_vector.t\n -> int\n -> Scalar_field.t Kimchi_types.runtime_table_cfg array\n -> int\n -> Urs.t\n -> t\n end\n\n module Curve : sig\n module Base_field : sig\n type t\n end\n\n module Affine : sig\n type t = Base_field.t * Base_field.t\n end\n end\n\n module Poly_comm : sig\n module Backend : sig\n type t\n end\n\n type t = Curve.Base_field.t Poly_comm0.t\n\n val of_backend_without_degree_bound : Backend.t -> t\n end\n\n module Verifier_index : sig\n type t =\n ( Scalar_field.t\n , Urs.t\n , Poly_comm.Backend.t )\n Kimchi_types.VerifierIndex.verifier_index\n\n val create : Index.t -> t\n end\nend\n\nmodule Make (Inputs : Inputs_intf) = struct\n open Core_kernel\n\n type t = { index : Inputs.Index.t; cs : Inputs.Constraint_system.t }\n\n let name =\n sprintf \"%s_%d_v4\" Inputs.name (Pickles_types.Nat.to_int Inputs.Rounds.n)\n\n let set_urs_info, load_urs =\n let urs_info = Set_once.create () in\n let urs = ref None in\n let degree = 1 lsl Pickles_types.Nat.to_int Inputs.Rounds.n in\n let set_urs_info specs = Set_once.set_exn urs_info Lexing.dummy_pos specs in\n let load () =\n match !urs with\n | Some urs ->\n urs\n | None ->\n let specs =\n match Set_once.get urs_info with\n | None ->\n failwith \"Dlog_based.urs: Info not set\"\n | Some t ->\n t\n in\n let store =\n Key_cache.Sync.Disk_storable.simple\n (fun () -> name)\n (fun () ~path ->\n Or_error.try_with_join (fun () ->\n match Inputs.Urs.read None path with\n | Some urs ->\n Ok urs\n | None ->\n Or_error.errorf\n \"Could not read the URS from disk; its format did \\\n not match the expected format\" ) )\n (fun _ urs path ->\n Or_error.try_with (fun () -> Inputs.Urs.write None urs path) )\n in\n let u =\n match Key_cache.Sync.read specs store () with\n | Ok (u, _) ->\n u\n | Error _e ->\n let urs = Inputs.Urs.create degree in\n let (_ : (unit, Error.t) Result.t) =\n Key_cache.Sync.write\n (List.filter specs ~f:(function\n | On_disk _ ->\n true\n | S3 _ ->\n false ) )\n store () urs\n in\n urs\n in\n urs := Some u ;\n u\n in\n (set_urs_info, load)\n\n let create ~prev_challenges cs =\n let gates = Inputs.Constraint_system.finalize_and_get_gates cs in\n let public_input_size =\n Inputs.Constraint_system.get_primary_input_size cs\n in\n let prev_challenges =\n match Inputs.Constraint_system.get_prev_challenges cs with\n | None ->\n Inputs.Constraint_system.set_prev_challenges cs prev_challenges ;\n prev_challenges\n | Some prev_challenges' ->\n assert (prev_challenges = prev_challenges') ;\n prev_challenges'\n in\n (* TODO(dw) pass runtime table cfg info *)\n let runtime_table_cfg = [||] in\n let index =\n Inputs.Index.create gates public_input_size runtime_table_cfg\n prev_challenges (load_urs ())\n in\n { index; cs }\n\n let vk t = Inputs.Verifier_index.create t.index\n\n let pk t = t\n\n let array_to_vector a = Pickles_types.Vector.of_list (Array.to_list a)\n\n (** does this convert a backend.verifier_index to a pickles_types.verifier_index? *)\n let vk_commitments (t : Inputs.Verifier_index.t) :\n Inputs.Curve.Affine.t Pickles_types.Plonk_verification_key_evals.t =\n let g c : Inputs.Curve.Affine.t =\n match Inputs.Poly_comm.of_backend_without_degree_bound c with\n | `Without_degree_bound x ->\n x.(0)\n | `With_degree_bound _ ->\n assert false\n in\n { sigma_comm =\n Pickles_types.Vector.init Pickles_types.Plonk_types.Permuts.n\n ~f:(fun i -> g t.evals.sigma_comm.(i))\n ; coefficients_comm =\n Pickles_types.Vector.init Pickles_types.Plonk_types.Columns.n\n ~f:(fun i -> g t.evals.coefficients_comm.(i))\n ; generic_comm = g t.evals.generic_comm\n ; psm_comm = g t.evals.psm_comm\n ; complete_add_comm = g t.evals.complete_add_comm\n ; mul_comm = g t.evals.mul_comm\n ; emul_comm = g t.evals.emul_comm\n ; endomul_scalar_comm = g t.evals.endomul_scalar_comm\n }\nend\n","module Bigint = Bigint\nmodule Field = Field\nmodule Curve = Curve\nmodule Poly_comm = Poly_comm\nmodule Plonk_constraint_system = Plonk_constraint_system\nmodule Dlog_plonk_based_keypair = Dlog_plonk_based_keypair\nmodule Constants = Constants\nmodule Plonk_dlog_proof = Plonk_dlog_proof\nmodule Plonk_dlog_oracles = Plonk_dlog_oracles\nmodule Scalar_challenge = Scalar_challenge\nmodule Endoscale_round = Endoscale_round\nmodule Scale_round = Scale_round\nmodule Endoscale_scalar_round = Endoscale_scalar_round\nmodule Intf = Intf\n","open Kimchi_backend_common\nopen Kimchi_pasta_basic\n\ninclude\n Plonk_constraint_system.Make (Fp) (Kimchi_bindings.Protocol.Gates.Vector.Fp)\n (struct\n let params =\n Sponge.Params.(\n map pasta_p_kimchi ~f:(fun x ->\n Fp.of_bigint (Bigint256.of_decimal_string x) ))\n end)\n","open Kimchi_backend_common\nopen Kimchi_pasta_basic\n\ninclude\n Plonk_constraint_system.Make (Fq) (Kimchi_bindings.Protocol.Gates.Vector.Fq)\n (struct\n let params =\n Sponge.Params.(\n map pasta_q_kimchi ~f:(fun x ->\n Fq.of_bigint (Bigint256.of_decimal_string x) ))\n end)\n","module Basic = Kimchi_pasta_basic\n\nmodule Pallas_based_plonk = struct\n module Field = Pallas_based_plonk.Field\n module Curve = Pallas_based_plonk.Curve\n module Bigint = Pallas_based_plonk.Bigint\n\n let field_size = Pallas_based_plonk.field_size\n\n module Verification_key = Pallas_based_plonk.Verification_key\n module R1CS_constraint_system = Pallas_based_plonk.R1CS_constraint_system\n module Rounds_vector = Pallas_based_plonk.Rounds_vector\n module Rounds = Pallas_based_plonk.Rounds\n module Keypair = Pallas_based_plonk.Keypair\n module Proof = Pallas_based_plonk.Proof\n module Proving_key = Pallas_based_plonk.Proving_key\n module Oracles = Pallas_based_plonk.Oracles\nend\n\nmodule Vesta_based_plonk = struct\n module Field = Vesta_based_plonk.Field\n module Curve = Vesta_based_plonk.Curve\n module Bigint = Vesta_based_plonk.Bigint\n\n let field_size = Vesta_based_plonk.field_size\n\n module Verification_key = Vesta_based_plonk.Verification_key\n module R1CS_constraint_system = Vesta_based_plonk.R1CS_constraint_system\n module Rounds_vector = Vesta_based_plonk.Rounds_vector\n module Rounds = Vesta_based_plonk.Rounds\n module Keypair = Vesta_based_plonk.Keypair\n module Proof = Vesta_based_plonk.Proof\n module Proving_key = Vesta_based_plonk.Proving_key\n module Oracles = Vesta_based_plonk.Oracles\nend\n\nmodule Pasta = struct\n module Rounds = Pasta.Rounds\n module Bigint256 = Pasta.Bigint256\n module Fp = Pasta.Fp\n module Fq = Pasta.Fq\n module Vesta = Pasta.Vesta\n module Pallas = Pasta.Pallas\nend\n","open Utils\n\nmodule Types = struct\n module type S = V1S0\nend\n\nmodule type Concrete = Types.S with type V1.t = Unsigned.UInt64.t\n\nmodule M = struct\n module V1 = struct\n type t = Unsigned.UInt64.t\n end\nend\n\nmodule type Local_sig = Signature(Types).S\n\nmodule Make\n (Signature : Local_sig) (F : functor (A : Concrete) -> Signature(A).S) =\n F (M)\ninclude M\n","open Utils\n\n(** We first define a [Types] module, with the expected final signature of this\n module (hidden types should be hidden here) *)\nmodule Types = struct\n module type S = sig\n module Fee : V1S0\n\n module Amount : V1S0\n\n module Balance : V1S0\n end\nend\n\n(** We define a module type [Concrete], where we replace hidden types in\n {!Types.S} by their actual definition. This module will not be exported. *)\nmodule type Concrete =\n Types.S\n with type Fee.V1.t = Unsigned.UInt64.t\n and type Amount.V1.t = Unsigned.UInt64.t\n and type Balance.V1.t = Unsigned.UInt64.t\n\n(** Then we define the actual module [M] with its type definitions. It must be\n compatible with {!Concrete} *)\nmodule M = struct\n module Fee = struct\n module V1 = struct\n type t = Unsigned.UInt64.t\n end\n end\n\n module Amount = struct\n module V1 = struct\n type t = Unsigned.UInt64.t\n end\n end\n\n module Balance = struct\n module V1 = struct\n type t = Amount.V1.t\n end\n end\nend\n\n(** [Local_sig] is the type of functors which receive a {!Types.S} module and\n return a complete module signature (with operations etc.) based on these\n types. It will be expected to be given by the implementation module. *)\nmodule type Local_sig = Signature(Types).S\n\n(** To make a full module, the implementation module will have to use [Make] and\n provide: (i) a {!Local_sig} functor to know the final signature of the\n module and (ii) a functor which takes the concrete types defined here and\n make the actual full module, adding type equalities where needed. *)\nmodule Make\n (Signature : Local_sig) (F : functor (A : Concrete) -> Signature(A).S) =\n F (M)\n\n(** Finally, we include our module to make the types available to everyone (they\n will be hidden in the MLI *)\ninclude M\n","open Utils\n\nmodule Branch_data = struct\n module Types = struct\n module type S = sig\n module Domain_log2 : V1S0\n\n module V1 : sig\n type t =\n { proofs_verified : Pickles_base.Proofs_verified.V1.t\n ; domain_log2 : Domain_log2.V1.t\n }\n end\n end\n end\n\n module type Concrete = Types.S with type Domain_log2.V1.t = char\n\n module M = struct\n module Domain_log2 = struct\n module V1 = struct\n type t = char\n end\n end\n\n module V1 = struct\n type t =\n { proofs_verified : Pickles_base.Proofs_verified.V1.t\n ; domain_log2 : Domain_log2.V1.t\n }\n end\n end\n\n module type Local_sig = Signature(Types).S\n\n module Make\n (Signature : Local_sig) (F : functor (A : Concrete) -> Signature(A).S) =\n F (M)\n include M\nend\n\nmodule Wrap = struct\n module Proof_state = struct\n module Messages_for_next_wrap_proof = struct\n module V1 = struct\n type ('g1, 'bulletproof_challenges) t =\n { challenge_polynomial_commitment : 'g1\n ; old_bulletproof_challenges : 'bulletproof_challenges\n }\n end\n end\n\n module Deferred_values = struct\n module Plonk = struct\n module Minimal = struct\n module V1 = struct\n type ('challenge, 'scalar_challenge, 'bool) t =\n { alpha : 'scalar_challenge\n ; beta : 'challenge\n ; gamma : 'challenge\n ; zeta : 'scalar_challenge\n ; joint_combiner : 'scalar_challenge option\n ; feature_flags :\n 'bool Pickles_types.Plonk_types.Features.Stable.V1.t\n }\n end\n end\n end\n\n module V1 = struct\n type ( 'plonk\n , 'scalar_challenge\n , 'fp\n , 'bulletproof_challenges\n , 'branch_data )\n t =\n { plonk : 'plonk\n ; combined_inner_product : 'fp\n ; b : 'fp\n ; xi : 'scalar_challenge\n ; bulletproof_challenges : 'bulletproof_challenges\n ; branch_data : 'branch_data\n }\n end\n\n module Minimal = struct\n module V1 = struct\n type ( 'challenge\n , 'scalar_challenge\n , 'fp\n , 'bool\n , 'bulletproof_challenges\n , 'branch_data )\n t =\n { plonk : ('challenge, 'scalar_challenge, 'bool) Plonk.Minimal.V1.t\n ; bulletproof_challenges : 'bulletproof_challenges\n ; branch_data : 'branch_data\n }\n end\n end\n end\n\n module V1 = struct\n type ( 'plonk\n , 'scalar_challenge\n , 'fp\n , 'messages_for_next_wrap_proof\n , 'digest\n , 'bp_chals\n , 'index )\n t =\n { deferred_values :\n ( 'plonk\n , 'scalar_challenge\n , 'fp\n , 'bp_chals\n , 'index )\n Deferred_values.V1.t\n ; sponge_digest_before_evaluations : 'digest\n ; messages_for_next_wrap_proof : 'messages_for_next_wrap_proof\n }\n end\n\n module Minimal = struct\n module V1 = struct\n type ( 'challenge\n , 'scalar_challenge\n , 'fp\n , 'bool\n , 'messages_for_next_wrap_proof\n , 'digest\n , 'bp_chals\n , 'index )\n t =\n { deferred_values :\n ( 'challenge\n , 'scalar_challenge\n , 'fp\n , 'bool\n , 'bp_chals\n , 'index )\n Deferred_values.Minimal.V1.t\n ; sponge_digest_before_evaluations : 'digest\n ; messages_for_next_wrap_proof : 'messages_for_next_wrap_proof\n }\n end\n end\n end\n\n module Statement = struct\n module V1 = struct\n type ( 'plonk\n , 'scalar_challenge\n , 'fp\n , 'messages_for_next_wrap_proof\n , 'digest\n , 'messages_for_next_step_proof\n , 'bp_chals\n , 'index )\n t =\n { proof_state :\n ( 'plonk\n , 'scalar_challenge\n , 'fp\n , 'messages_for_next_wrap_proof\n , 'digest\n , 'bp_chals\n , 'index )\n Proof_state.V1.t\n ; messages_for_next_step_proof : 'messages_for_next_step_proof\n }\n end\n\n module Minimal = struct\n module V1 = struct\n type ( 'challenge\n , 'scalar_challenge\n , 'fp\n , 'bool\n , 'messages_for_next_wrap_proof\n , 'digest\n , 'messages_for_next_step_proof\n , 'bp_chals\n , 'index )\n t =\n { proof_state :\n ( 'challenge\n , 'scalar_challenge\n , 'fp\n , 'bool\n , 'messages_for_next_wrap_proof\n , 'digest\n , 'bp_chals\n , 'index )\n Proof_state.Minimal.V1.t\n ; messages_for_next_step_proof : 'messages_for_next_step_proof\n }\n end\n end\n end\nend\n","open Utils\n\nmodule M = struct\n module Backend = struct\n module Tick = struct\n module Field = struct\n module V1 = struct\n type t = Pasta_bindings.Fp.t\n end\n end\n end\n end\n\n module Wrap_wire_proof = struct\n module Columns_vec = Pickles_types.Vector.Vector_15\n module Coefficients_vec = Pickles_types.Vector.Vector_15\n module Quotient_polynomial_vec = Pickles_types.Vector.Vector_7\n module Permuts_minus_1_vec = Pickles_types.Vector.Vector_6\n\n module Commitments = struct\n module V1 = struct\n type t =\n { w_comm :\n (Pasta_bindings.Fp.t * Pasta_bindings.Fp.t)\n Columns_vec.Stable.V1.t\n ; z_comm : Pasta_bindings.Fp.t * Pasta_bindings.Fp.t\n ; t_comm :\n (Pasta_bindings.Fp.t * Pasta_bindings.Fp.t)\n Quotient_polynomial_vec.Stable.V1.t\n }\n end\n end\n\n module Evaluations = struct\n module V1 = struct\n type t =\n { w :\n (Pasta_bindings.Fq.t * Pasta_bindings.Fq.t)\n Columns_vec.Stable.V1.t\n ; coefficients :\n (Pasta_bindings.Fq.t * Pasta_bindings.Fq.t)\n Columns_vec.Stable.V1.t\n ; z : Pasta_bindings.Fq.t * Pasta_bindings.Fq.t\n ; s :\n (Pasta_bindings.Fq.t * Pasta_bindings.Fq.t)\n Permuts_minus_1_vec.Stable.V1.t\n ; generic_selector : Pasta_bindings.Fq.t * Pasta_bindings.Fq.t\n ; poseidon_selector : Pasta_bindings.Fq.t * Pasta_bindings.Fq.t\n ; complete_add_selector : Pasta_bindings.Fq.t * Pasta_bindings.Fq.t\n ; mul_selector : Pasta_bindings.Fq.t * Pasta_bindings.Fq.t\n ; emul_selector : Pasta_bindings.Fq.t * Pasta_bindings.Fq.t\n ; endomul_scalar_selector : Pasta_bindings.Fq.t * Pasta_bindings.Fq.t\n }\n end\n end\n\n module V1 = struct\n type t =\n { commitments : Commitments.V1.t\n ; evaluations : Evaluations.V1.t\n ; ft_eval1 : Pasta_bindings.Fq.t\n ; bulletproof :\n ( Pasta_bindings.Fp.t * Pasta_bindings.Fp.t\n , Pasta_bindings.Fq.t )\n Pickles_types.Plonk_types.Openings.Bulletproof.Stable.V1.t\n }\n end\n end\n\n module Proof = struct\n type challenge_constant =\n Pickles_limb_vector.Constant.Make(Pickles_types.Nat.N2).t\n\n type tock_affine = Pasta_bindings.Fp.t * Pasta_bindings.Fp.t\n\n type 'a step_bp_vec = 'a Kimchi_pasta.Basic.Rounds.Step_vector.Stable.V1.t\n\n module Base = struct\n module Wrap = struct\n module V2 = struct\n type digest_constant =\n Pickles_limb_vector.Constant.Make(Pickles_types.Nat.N4).t\n\n type ('messages_for_next_wrap_proof, 'messages_for_next_step_proof) t =\n { statement :\n ( challenge_constant\n , challenge_constant Kimchi_types.scalar_challenge\n , Snark_params.Tick.Field.t Pickles_types.Shifted_value.Type1.t\n , bool\n , 'messages_for_next_wrap_proof\n , digest_constant\n , 'messages_for_next_step_proof\n , challenge_constant Kimchi_types.scalar_challenge\n Pickles_bulletproof_challenge.V1.t\n step_bp_vec\n , Pickles_composition_types.Branch_data.V1.t )\n Pickles_composition_types.Wrap.Statement.Minimal.V1.t\n ; prev_evals :\n ( Snark_params.Tick.Field.t\n , Snark_params.Tick.Field.t array )\n Pickles_types.Plonk_types.All_evals.t\n ; proof : Wrap_wire_proof.V1.t\n }\n end\n end\n end\n\n type ('s, 'mlmb, _) with_data =\n | T :\n ( 'mlmb Pickles_reduced_messages_for_next_proof_over_same_field.Wrap.t\n , ( 's\n , (tock_affine, 'most_recent_width) Pickles_types.Vector.t\n , ( challenge_constant Kimchi_types.scalar_challenge\n Pickles_bulletproof_challenge.V1.t\n step_bp_vec\n , 'most_recent_width )\n Pickles_types.Vector.t )\n Pickles_reduced_messages_for_next_proof_over_same_field.Step.V1.t\n )\n Base.Wrap.V2.t\n -> ('s, 'mlmb, _) with_data\n\n type ('max_width, 'mlmb) t = (unit, 'mlmb, 'max_width) with_data\n\n module Proofs_verified_2 = struct\n module V2 = struct\n type nonrec t = (Pickles_types.Nat.N2.n, Pickles_types.Nat.N2.n) t\n end\n end\n end\n\n module Side_loaded = struct\n module Verification_key = struct\n module Vk = struct\n type t =\n ( Pasta_bindings.Fq.t\n , Kimchi_bindings.Protocol.SRS.Fq.t\n , Pasta_bindings.Fp.t Kimchi_types.or_infinity Kimchi_types.poly_comm\n )\n Kimchi_types.VerifierIndex.verifier_index\n end\n\n type tock_curve_affine =\n Snark_params.Tick.Field.t * Snark_params.Tick.Field.t\n\n module V2 = struct\n type t =\n ( tock_curve_affine\n , Pickles_base.Proofs_verified.V1.t\n , Vk.t )\n Pickles_base.Side_loaded_verification_key.Poly.V2.t\n end\n\n module Max_width = Pickles_types.Nat.N2\n end\n\n module Proof = struct\n module V2 = struct\n type t =\n (Verification_key.Max_width.n, Verification_key.Max_width.n) Proof.t\n end\n end\n end\nend\n\nmodule Types = struct\n module type S = sig\n module Proof : sig\n type ('a, 'b) t\n\n module Proofs_verified_2 : sig\n module V2 : sig\n type nonrec t = (Pickles_types.Nat.N2.n, Pickles_types.Nat.N2.n) t\n end\n end\n end\n\n module Side_loaded : sig\n module Verification_key : sig\n module Max_width : module type of Pickles_types.Nat.N2\n\n module V2 : sig\n type t\n end\n end\n\n module Proof : sig\n module V2 : sig\n type t =\n (Verification_key.Max_width.n, Verification_key.Max_width.n) Proof.t\n end\n end\n end\n\n module Backend : sig\n module Tick : sig\n module Field : sig\n module V1 : sig\n type t = Pasta_bindings.Fp.t\n end\n end\n end\n end\n end\nend\n\nmodule Concrete_ = M\n\nmodule type Concrete =\n Types.S\n with type Side_loaded.Verification_key.V2.t =\n M.Side_loaded.Verification_key.V2.t\n and type Backend.Tick.Field.V1.t = Pasta_bindings.Fp.t\n and type ('a, 'b) Proof.t = ('a, 'b) M.Proof.t\n\nmodule type Local_sig = Signature(Types).S\n\nmodule Make\n (Signature : Local_sig) (F : functor (A : Concrete) -> Signature(A).S) =\n F (M)\ninclude M\n","[%%import \"/src/config.mlh\"]\n\nopen Utils\n\nmodule Types = struct\n module type S = sig\n module Digest : V1S0\n\n include V2S0\n end\nend\n\n[%%ifdef consensus_mechanism]\n\nmodule type Concrete =\n Types.S\n with type Digest.V1.t = Pickles.Backend.Tick.Field.V1.t\n and type V2.t =\n Public_key.Compressed.V1.t * Pickles.Backend.Tick.Field.V1.t\n\n[%%else]\n\nmodule type Concrete =\n Types.S\n with type Digest.V1.t = Snark_params.Tick.Field.t\n and type V2.t = Public_key.Compressed.V1.t * Snark_params.Tick.Field.V1.t\n\n[%%endif]\n\nmodule M = struct\n [%%ifdef consensus_mechanism]\n\n module Digest = struct\n module V1 = struct\n type t = Pickles.Backend.Tick.Field.V1.t\n end\n end\n\n module V2 = struct\n type t = Public_key.Compressed.V1.t * Pickles.Backend.Tick.Field.V1.t\n end\n\n [%%else]\n\n module Digest = struct\n module V1 = struct\n type t = Snark_params.Tick.Field.t\n end\n end\n\n module V2 = struct\n type t = Public_key.Compressed.V1.t * Snark_params.Tick.Field.V1.t\n end\n\n [%%endif]\nend\n\nmodule type Local_sig = Signature(Types).S\n\nmodule Make\n (Signature : Local_sig) (F : functor (A : Concrete) -> Signature(A).S) =\n F (M)\ninclude M\n","open Utils\n\nmodule Account_nonce = struct\n module Types = struct\n module type S = V1S0\n end\n\n module type Concrete = Types.S with type V1.t = Unsigned.UInt32.t\n\n module M = struct\n module V1 = struct\n type t = Unsigned.UInt32.t\n end\n end\n\n module type Local_sig = Signature(Types).S\n\n module Make\n (Signature : Local_sig) (F : functor (A : Concrete) -> Signature(A).S) =\n F (M)\n include M\nend\n\nmodule Global_slot_legacy = struct\n module Types = struct\n module type S = V1S0\n end\n\n module type Concrete = Types.S with type V1.t = Unsigned.UInt32.t\n\n module M = struct\n module V1 = struct\n type t = Unsigned.UInt32.t\n end\n end\n\n module type Local_sig = Signature(Types).S\n\n module Make\n (Signature : Local_sig) (F : functor (A : Concrete) -> Signature(A).S) =\n F (M)\n include M\nend\n\nmodule Global_slot_since_genesis = struct\n module Types = struct\n module type S = V1S0\n end\n\n type global_slot = Since_genesis of Unsigned.UInt32.t [@@unboxed]\n\n module type Concrete = Types.S with type V1.t = global_slot\n\n module M = struct\n module V1 = struct\n type t = global_slot\n end\n end\n\n module type Local_sig = Signature(Types).S\n\n module Make\n (Signature : Local_sig) (F : functor (A : Concrete) -> Signature(A).S) =\n F (M)\n include M\nend\n\nmodule Global_slot_since_hard_fork = struct\n module Types = struct\n module type S = V1S0\n end\n\n type global_slot = Since_hard_fork of Unsigned.UInt32.t [@@unboxed]\n\n module type Concrete = Types.S with type V1.t = global_slot\n\n module M = struct\n module V1 = struct\n type t = global_slot\n end\n end\n\n module type Local_sig = Signature(Types).S\n\n module Make\n (Signature : Local_sig) (F : functor (A : Concrete) -> Signature(A).S) =\n F (M)\n include M\nend\n\nmodule Global_slot_span = struct\n module Types = struct\n module type S = V1S0\n end\n\n type global_slot_span = Global_slot_span of Unsigned.UInt32.t [@@unboxed]\n\n module type Concrete = Types.S with type V1.t = global_slot_span\n\n module M = struct\n module V1 = struct\n type t = global_slot_span\n end\n end\n\n module type Local_sig = Signature(Types).S\n\n module Make\n (Signature : Local_sig) (F : functor (A : Concrete) -> Signature(A).S) =\n F (M)\n include M\nend\n\nmodule Length = struct\n module Types = struct\n module type S = V1S0\n end\n\n module type Concrete = Types.S with type V1.t = Unsigned.UInt32.t\n\n module M = struct\n module V1 = struct\n type t = Unsigned.UInt32.t\n end\n end\n\n module type Local_sig = Signature(Types).S\n\n module Make\n (Signature : Local_sig) (F : functor (A : Concrete) -> Signature(A).S) =\n F (M)\n include M\nend\n\nmodule Index = struct\n module Types = struct\n module type S = V1S0\n end\n\n module type Concrete = Types.S with type V1.t = Unsigned.UInt32.t\n\n module M = struct\n module V1 = struct\n type t = Unsigned.UInt32.t\n end\n end\n\n module type Local_sig = Signature(Types).S\n\n module Make\n (Signature : Local_sig) (F : functor (A : Concrete) -> Signature(A).S) =\n F (M)\n include M\nend\n","open Utils\n\nmodule Types = struct\n module type S = sig\n module V1 : sig\n type t = private Mina_base_zkapp_basic.F.V1.t\n end\n end\nend\n\nmodule type Concrete = sig\n module V1 : sig\n type t = Pasta_bindings.Fp.t\n end\nend\n\nmodule M = struct\n module V1 = struct\n type t = Pasta_bindings.Fp.t\n end\nend\n\nmodule type Local_sig = Signature(Types).S\n\nmodule Make\n (Signature : Local_sig) (F : functor (A : Concrete) -> Signature(A).S) =\n F (M)\ninclude M\n","open Utils\n\nmodule Types = struct\n module type S = sig\n module V1 : sig\n type t = private\n { receiver_pk : Public_key.Compressed.V1.t; fee : Currency.Fee.V1.t }\n end\n end\nend\n\nmodule type Concrete = sig\n module V1 : sig\n type t =\n { receiver_pk : Public_key.Compressed.V1.t; fee : Currency.Fee.V1.t }\n end\nend\n\nmodule M = struct\n module V1 = struct\n type t =\n { receiver_pk : Public_key.Compressed.V1.t; fee : Currency.Fee.V1.t }\n end\nend\n\nmodule type Local_sig = Utils.Signature(Types).S\n\nmodule Make\n (Signature : Local_sig) (F : functor (A : Concrete) -> Signature(A).S) =\n F (M)\ninclude M\n","open Utils\n\nmodule Types = struct\n module type S = sig\n module V1 : sig\n type t = private\n { receiver : Public_key.Compressed.V1.t\n ; amount : Currency.Amount.V1.t\n ; fee_transfer : Mina_base_coinbase_fee_transfer.V1.t option\n }\n end\n end\nend\n\nmodule M = struct\n module V1 = struct\n type t =\n { receiver : Public_key.Compressed.V1.t\n ; amount : Currency.Amount.V1.t\n ; fee_transfer : Mina_base_coinbase_fee_transfer.V1.t option\n }\n end\nend\n\nmodule type Concrete = sig\n module V1 : sig\n type t =\n { receiver : Public_key.Compressed.V1.t\n ; amount : Currency.Amount.V1.t\n ; fee_transfer : Mina_base_coinbase_fee_transfer.V1.t option\n }\n end\nend\n\nmodule type Local_sig = Signature(Types).S\n\nmodule Make\n (Signature : Local_sig) (F : functor (A : Concrete) -> Signature(A).S) =\n F (M)\ninclude M\n","open Utils\n\nmodule Types = struct\n module type S = sig\n module Single : sig\n module V2 : sig\n type t = private\n { receiver_pk : Public_key.Compressed.V1.t\n ; fee : Currency.Fee.V1.t\n ; fee_token : Mina_base_token_id.V2.t\n }\n end\n end\n\n module V2 : sig\n type t = private Single.V2.t One_or_two.V1.t\n end\n end\nend\n\nmodule M = struct\n module Single = struct\n module V2 = struct\n type t =\n { receiver_pk : Public_key.Compressed.V1.t\n ; fee : Currency.Fee.V1.t\n ; fee_token : Mina_base_token_id.V2.t\n }\n end\n end\n\n module V2 = struct\n type t = Single.V2.t One_or_two.V1.t\n end\nend\n\nmodule type Concrete = sig\n module Single : sig\n module V2 : sig\n type t =\n { receiver_pk : Public_key.Compressed.V1.t\n ; fee : Currency.Fee.V1.t\n ; fee_token : Mina_base_token_id.V2.t\n }\n end\n end\n\n module V2 : sig\n type t = Single.V2.t One_or_two.V1.t\n end\nend\n\nmodule type Local_sig = Signature(Types).S\n\nmodule Make\n (Signature : Local_sig) (F : functor (A : Concrete) -> Signature(A).S) =\n F (M)\ninclude M\n","open Utils\n\nmodule Types = struct\n module type S = sig\n module State_stack : sig\n module V1 : sig\n type t\n end\n end\n\n module Stack_versioned : sig\n module V1 : sig\n type nonrec t\n end\n end\n\n module Hash_builder : sig\n module V1 : sig\n type t = private Snark_params.Tick.Field.t\n end\n end\n\n module Hash_versioned : sig\n module V1 : sig\n type t = Hash_builder.V1.t\n end\n end\n end\nend\n\nmodule type Concrete = sig\n module Poly : sig\n type ('tree, 'stack_id) t =\n { tree : 'tree; pos_list : 'stack_id list; new_pos : 'stack_id }\n end\n\n module Stack_hash : sig\n module V1 : sig\n type t = Snark_params.Tick.Field.t\n end\n end\n\n module State_stack : sig\n module Poly : sig\n module V1 : sig\n type 'stack_hash t = { init : 'stack_hash; curr : 'stack_hash }\n end\n end\n\n module V1 : sig\n type t = Stack_hash.V1.t Poly.V1.t\n end\n end\n\n module Coinbase_stack : sig\n module V1 : sig\n type t = Snark_params.Tick.Field.t\n end\n end\n\n module Stack_versioned : sig\n module Poly : sig\n module V1 : sig\n type ('data_stack, 'state_stack) t =\n { data : 'data_stack; state : 'state_stack }\n end\n end\n\n module V1 : sig\n type t = (Coinbase_stack.V1.t, State_stack.V1.t) Poly.V1.t\n end\n end\n\n module Hash_builder : sig\n module V1 : sig\n type t = Snark_params.Tick.Field.t\n end\n end\n\n module Hash_versioned : sig\n module V1 : sig\n type t = Hash_builder.V1.t\n end\n end\nend\n\nmodule M = struct\n module Poly = struct\n type ('tree, 'stack_id) t =\n { tree : 'tree; pos_list : 'stack_id list; new_pos : 'stack_id }\n end\n\n module Stack_hash = struct\n module V1 = struct\n type t = Snark_params.Tick.Field.t\n end\n end\n\n module State_stack = struct\n module Poly = struct\n module V1 = struct\n type 'stack_hash t = { init : 'stack_hash; curr : 'stack_hash }\n end\n end\n\n module V1 = struct\n type t = Stack_hash.V1.t Poly.V1.t\n end\n end\n\n module Coinbase_stack = struct\n module V1 = struct\n type t = Snark_params.Tick.Field.t\n end\n end\n\n module Stack_versioned = struct\n module Poly = struct\n module V1 = struct\n type ('data_stack, 'state_stack) t =\n { data : 'data_stack; state : 'state_stack }\n end\n end\n\n module V1 = struct\n type t = (Coinbase_stack.V1.t, State_stack.V1.t) Poly.V1.t\n end\n end\n\n module Hash_builder = struct\n module V1 = struct\n type t = Snark_params.Tick.Field.t\n end\n end\n\n module Hash_versioned = struct\n module V1 = struct\n type t = Hash_builder.V1.t\n end\n end\nend\n\nmodule type Local_sig = Signature(Types).S\n\nmodule Make\n (Signature : Local_sig) (F : functor (A : Concrete) -> Signature(A).S) =\n F (M)\ninclude M\n","open Utils\n\nmodule Types = struct\n module type S = V1S0\nend\n\nmodule type Concrete = Types.S with type V1.t = string\n\nmodule M = struct\n module V1 = struct\n type t = string\n end\nend\n\nmodule type Local_sig = Signature(Types).S\n\nmodule Make\n (Signature : Local_sig) (F : functor (A : Concrete) -> Signature(A).S) =\n F (M)\ninclude M\n","open Utils\n\nmodule Poly = struct\n module V1 = struct\n type ('payload, 'pk, 'signature) t =\n { payload : 'payload; signer : 'pk; signature : 'signature }\n end\nend\n\nmodule V1 = struct\n type t =\n ( Mina_base_signed_command_payload.V1.t\n , Public_key.V1.t\n , Mina_base_signature.V1.t )\n Poly.V1.t\nend\n\nmodule V2 = struct\n type t =\n ( Mina_base_signed_command_payload.V2.t\n , Public_key.V1.t\n , Mina_base_signature.V1.t )\n Poly.V1.t\nend\n\nmodule Types = struct\n module type S = sig\n module With_valid_signature : V2S0 with type V2.t = private V2.t\n end\nend\n\nmodule type Concrete = Types.S with type With_valid_signature.V2.t = V2.t\n\nmodule M = struct\n module With_valid_signature = struct\n module V2 = struct\n type t = V2.t\n end\n end\nend\n\nmodule type Local_sig = Utils.Signature(Types).S\n\nmodule Make\n (Signature : Local_sig) (F : functor (A : Concrete) -> Signature(A).S) =\n F (M)\ninclude M\n","open Utils\n\nmodule Types = struct\n module type S = sig\n module Digest : V1S0\n end\nend\n\nmodule type Concrete = Types.S with type Digest.V1.t = string\n\nmodule M = struct\n module Digest = struct\n module V1 = struct\n type t = string\n end\n end\nend\n\nmodule type Local_sig = Signature(Types).S\n\nmodule Make\n (Signature : Local_sig) (F : functor (A : Concrete) -> Signature(A).S) =\n F (M)\ninclude M\n","open Utils\n\nmodule Digest = struct\n module Types = struct\n module type S = sig\n module V1 : sig\n type t = private Mina_base_zkapp_basic.F.V1.t\n end\n end\n end\n\n module type Concrete = sig\n module V1 : sig\n type t = Pasta_bindings.Fp.t\n end\n end\n\n module M = struct\n module V1 = struct\n type t = Pasta_bindings.Fp.t\n end\n end\n\n module type Local_sig = Signature(Types).S\n\n module Make\n (Signature : Local_sig) (F : functor (A : Concrete) -> Signature(A).S) =\n F (M)\n include M\nend\n","open Utils\n\nmodule Types = struct\n module type S = sig\n module Aux_hash : sig\n type t\n\n module V1 : sig\n type nonrec t = t\n end\n end\n\n module Pending_coinbase_aux : V1S0\n\n module V1 : S0\n end\nend\n\nmodule type Concrete = sig\n module Aux_hash : sig\n type t = string\n\n module V1 : sig\n type nonrec t = t\n end\n end\n\n module Pending_coinbase_aux : sig\n module V1 : sig\n type t = string\n end\n end\n\n module Non_snark : sig\n module V1 : sig\n type t =\n { ledger_hash : Mina_base_ledger_hash.V1.t\n ; aux_hash : Aux_hash.V1.t\n ; pending_coinbase_aux : Pending_coinbase_aux.V1.t\n }\n end\n end\n\n module Poly : sig\n module V1 : sig\n type ('non_snark, 'pending_coinbase_hash) t =\n { non_snark : 'non_snark\n ; pending_coinbase_hash : 'pending_coinbase_hash\n }\n end\n end\n\n module V1 : sig\n type t =\n (Non_snark.V1.t, Mina_base_pending_coinbase.Hash_versioned.V1.t) Poly.V1.t\n end\nend\n\nmodule M = struct\n module Aux_hash = struct\n type t = string\n\n module V1 = struct\n type nonrec t = string\n end\n end\n\n module Pending_coinbase_aux = struct\n module V1 = struct\n type t = string\n end\n end\n\n module Non_snark = struct\n module V1 = struct\n type t =\n { ledger_hash : Mina_base_ledger_hash.V1.t\n ; aux_hash : Aux_hash.V1.t\n ; pending_coinbase_aux : Pending_coinbase_aux.V1.t\n }\n end\n end\n\n module Poly = struct\n module V1 = struct\n type ('non_snark, 'pending_coinbase_hash) t =\n { non_snark : 'non_snark\n ; pending_coinbase_hash : 'pending_coinbase_hash\n }\n end\n end\n\n module V1 = struct\n type t =\n (Non_snark.V1.t, Mina_base_pending_coinbase.Hash_versioned.V1.t) Poly.V1.t\n end\nend\n\nmodule type Local_sig = Signature(Types).S\n\nmodule Make\n (Signature : Local_sig) (F : functor (A : Concrete) -> Signature(A).S) =\n F (M)\ninclude M\n","open Utils\n\nmodule Digest_types = struct\n module type S = sig\n module Account_update : sig\n module V1 : sig\n type t = private Pasta_bindings.Fp.t\n end\n end\n\n module Forest : sig\n module V1 : sig\n type t = private Pasta_bindings.Fp.t\n end\n end\n end\nend\n\nmodule Digest_M = struct\n module Account_update = struct\n module V1 = struct\n type t = Pasta_bindings.Fp.t\n end\n end\n\n module Forest = struct\n module V1 = struct\n type t = Pasta_bindings.Fp.t\n end\n end\nend\n\nmodule type Digest_concrete = sig\n module Account_update : sig\n module V1 : sig\n type t = Pasta_bindings.Fp.t\n end\n end\n\n module Forest : sig\n module V1 : sig\n type t = Pasta_bindings.Fp.t\n end\n end\nend\n\nmodule type Digest_local_sig = Signature(Digest_types).S\n\nmodule Digest_make\n (Signature : Digest_local_sig) (F : functor (A : Digest_concrete) ->\n Signature(A).S) =\n F (Digest_M)\n\nmodule Call_forest = struct\n module Digest = Digest_M\n\n module Tree = struct\n module V1 = struct\n type ('account_update, 'account_update_digest, 'digest) t =\n { account_update : 'account_update\n ; account_update_digest : 'account_update_digest\n ; calls :\n ( ('account_update, 'account_update_digest, 'digest) t\n , 'digest )\n Mina_base_with_stack_hash.V1.t\n list\n }\n end\n end\n\n module V1 = struct\n type ('account_update, 'account_update_digest, 'digest) t =\n ( ('account_update, 'account_update_digest, 'digest) Tree.V1.t\n , 'digest )\n Mina_base_with_stack_hash.V1.t\n list\n end\nend\n\nmodule V1 = struct\n type t =\n { fee_payer : Mina_base_account_update.Fee_payer.V1.t\n ; account_updates :\n ( Mina_base_account_update.V1.t\n , Call_forest.Digest.Account_update.V1.t\n , Call_forest.Digest.Forest.V1.t )\n Call_forest.V1.t\n ; memo : Mina_base_signed_command_memo.V1.t\n }\nend\n\nmodule Valid = struct\n module Verification_key_hash = struct\n module V1 = struct\n type t = Mina_base_zkapp_basic.F.V1.t\n end\n end\n\n module V1 = struct\n type t = { zkapp_command : V1.t }\n end\nend\n\nmodule Transaction_commitment = struct\n module V1 = struct\n type t = Pasta_bindings.Fp.t\n end\nend\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Alain Frisch, LexiFi *)\n(* *)\n(* Copyright 2012 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* TODO: remove this open *)\nopen Stdlib0\nmodule Location = Astlib.Location\nmodule Longident = Astlib.Longident\nopen Astlib.Ast_412\n\n[@@@warning \"-9\"]\n\nopen Asttypes\nopen Parsetree\n\ntype 'a with_loc = 'a Location.loc\ntype loc = Location.t\ntype lid = Longident.t with_loc\ntype str = string with_loc\ntype str_opt = string option with_loc\ntype attrs = attribute list\n\nlet default_loc = ref Location.none\n\ntype ref_and_value = R : 'a ref * 'a -> ref_and_value\n\nlet protect_ref =\n let set_ref (R (r, v)) = r := v in\n fun ref f ->\n let (R (r, _)) = ref in\n let backup = R (r, !r) in\n set_ref ref;\n match f () with\n | x ->\n set_ref backup;\n x\n | exception e ->\n set_ref backup;\n raise e\n\nlet with_default_loc l f = protect_ref (R (default_loc, l)) f\n\nmodule Const = struct\n let integer ?suffix i = Pconst_integer (i, suffix)\n let int ?suffix i = integer ?suffix (Int.to_string i)\n let int32 ?(suffix = 'l') i = integer ~suffix (Int32.to_string i)\n let int64 ?(suffix = 'L') i = integer ~suffix (Int64.to_string i)\n let nativeint ?(suffix = 'n') i = integer ~suffix (Nativeint.to_string i)\n let float ?suffix f = Pconst_float (f, suffix)\n let char c = Pconst_char c\n\n let string ?quotation_delimiter ?(loc = !default_loc) s =\n Pconst_string (s, loc, quotation_delimiter)\nend\n\nmodule Attr = struct\n let mk ?(loc = !default_loc) name payload =\n { attr_name = name; attr_payload = payload; attr_loc = loc }\nend\n\nmodule Typ = struct\n let mk ?(loc = !default_loc) ?(attrs = []) d =\n {\n ptyp_desc = d;\n ptyp_loc = loc;\n ptyp_loc_stack = [];\n ptyp_attributes = attrs;\n }\n\n let attr d a = { d with ptyp_attributes = d.ptyp_attributes @ [ a ] }\n let any ?loc ?attrs () = mk ?loc ?attrs Ptyp_any\n let var ?loc ?attrs a = mk ?loc ?attrs (Ptyp_var a)\n let arrow ?loc ?attrs a b c = mk ?loc ?attrs (Ptyp_arrow (a, b, c))\n let tuple ?loc ?attrs a = mk ?loc ?attrs (Ptyp_tuple a)\n let constr ?loc ?attrs a b = mk ?loc ?attrs (Ptyp_constr (a, b))\n let object_ ?loc ?attrs a b = mk ?loc ?attrs (Ptyp_object (a, b))\n let class_ ?loc ?attrs a b = mk ?loc ?attrs (Ptyp_class (a, b))\n let alias ?loc ?attrs a b = mk ?loc ?attrs (Ptyp_alias (a, b))\n let variant ?loc ?attrs a b c = mk ?loc ?attrs (Ptyp_variant (a, b, c))\n let poly ?loc ?attrs a b = mk ?loc ?attrs (Ptyp_poly (a, b))\n let package ?loc ?attrs a b = mk ?loc ?attrs (Ptyp_package (a, b))\n let extension ?loc ?attrs a = mk ?loc ?attrs (Ptyp_extension a)\n\n let force_poly t =\n match t.ptyp_desc with Ptyp_poly _ -> t | _ -> poly ~loc:t.ptyp_loc [] t\n (* -> ghost? *)\n\n let varify_constructors var_names t =\n let check_variable vl loc v =\n if List.mem v vl then\n Location.raise_errorf ~loc \"variable in scope syntax error: %s\" v\n in\n let var_names = List.map (fun v -> v.txt) var_names in\n let rec loop t =\n let desc =\n match t.ptyp_desc with\n | Ptyp_any -> Ptyp_any\n | Ptyp_var x ->\n check_variable var_names t.ptyp_loc x;\n Ptyp_var x\n | Ptyp_arrow (label, core_type, core_type') ->\n Ptyp_arrow (label, loop core_type, loop core_type')\n | Ptyp_tuple lst -> Ptyp_tuple (List.map loop lst)\n | Ptyp_constr ({ txt = Longident.Lident s }, [])\n when List.mem s var_names ->\n Ptyp_var s\n | Ptyp_constr (longident, lst) ->\n Ptyp_constr (longident, List.map loop lst)\n | Ptyp_object (lst, o) -> Ptyp_object (List.map loop_object_field lst, o)\n | Ptyp_class (longident, lst) ->\n Ptyp_class (longident, List.map loop lst)\n | Ptyp_alias (core_type, string) ->\n check_variable var_names t.ptyp_loc string;\n Ptyp_alias (loop core_type, string)\n | Ptyp_variant (row_field_list, flag, lbl_lst_option) ->\n Ptyp_variant\n (List.map loop_row_field row_field_list, flag, lbl_lst_option)\n | Ptyp_poly (string_lst, core_type) ->\n List.iter\n (fun v -> check_variable var_names t.ptyp_loc v.txt)\n string_lst;\n Ptyp_poly (string_lst, loop core_type)\n | Ptyp_package (longident, lst) ->\n Ptyp_package\n (longident, List.map (fun (n, typ) -> (n, loop typ)) lst)\n | Ptyp_extension (s, arg) -> Ptyp_extension (s, arg)\n in\n { t with ptyp_desc = desc }\n and loop_row_field field =\n let prf_desc =\n match field.prf_desc with\n | Rtag (label, flag, lst) -> Rtag (label, flag, List.map loop lst)\n | Rinherit t -> Rinherit (loop t)\n in\n { field with prf_desc }\n and loop_object_field field =\n let pof_desc =\n match field.pof_desc with\n | Otag (label, t) -> Otag (label, loop t)\n | Oinherit t -> Oinherit (loop t)\n in\n { field with pof_desc }\n in\n loop t\nend\n\nmodule Pat = struct\n let mk ?(loc = !default_loc) ?(attrs = []) d =\n {\n ppat_desc = d;\n ppat_loc = loc;\n ppat_loc_stack = [];\n ppat_attributes = attrs;\n }\n\n let attr d a = { d with ppat_attributes = d.ppat_attributes @ [ a ] }\n let any ?loc ?attrs () = mk ?loc ?attrs Ppat_any\n let var ?loc ?attrs a = mk ?loc ?attrs (Ppat_var a)\n let alias ?loc ?attrs a b = mk ?loc ?attrs (Ppat_alias (a, b))\n let constant ?loc ?attrs a = mk ?loc ?attrs (Ppat_constant a)\n let interval ?loc ?attrs a b = mk ?loc ?attrs (Ppat_interval (a, b))\n let tuple ?loc ?attrs a = mk ?loc ?attrs (Ppat_tuple a)\n let construct ?loc ?attrs a b = mk ?loc ?attrs (Ppat_construct (a, b))\n let variant ?loc ?attrs a b = mk ?loc ?attrs (Ppat_variant (a, b))\n let record ?loc ?attrs a b = mk ?loc ?attrs (Ppat_record (a, b))\n let array ?loc ?attrs a = mk ?loc ?attrs (Ppat_array a)\n let or_ ?loc ?attrs a b = mk ?loc ?attrs (Ppat_or (a, b))\n let constraint_ ?loc ?attrs a b = mk ?loc ?attrs (Ppat_constraint (a, b))\n let type_ ?loc ?attrs a = mk ?loc ?attrs (Ppat_type a)\n let lazy_ ?loc ?attrs a = mk ?loc ?attrs (Ppat_lazy a)\n let unpack ?loc ?attrs a = mk ?loc ?attrs (Ppat_unpack a)\n let open_ ?loc ?attrs a b = mk ?loc ?attrs (Ppat_open (a, b))\n let exception_ ?loc ?attrs a = mk ?loc ?attrs (Ppat_exception a)\n let extension ?loc ?attrs a = mk ?loc ?attrs (Ppat_extension a)\nend\n\nmodule Exp = struct\n let mk ?(loc = !default_loc) ?(attrs = []) d =\n {\n pexp_desc = d;\n pexp_loc = loc;\n pexp_loc_stack = [];\n pexp_attributes = attrs;\n }\n\n let attr d a = { d with pexp_attributes = d.pexp_attributes @ [ a ] }\n let ident ?loc ?attrs a = mk ?loc ?attrs (Pexp_ident a)\n let constant ?loc ?attrs a = mk ?loc ?attrs (Pexp_constant a)\n let let_ ?loc ?attrs a b c = mk ?loc ?attrs (Pexp_let (a, b, c))\n let fun_ ?loc ?attrs a b c d = mk ?loc ?attrs (Pexp_fun (a, b, c, d))\n let function_ ?loc ?attrs a = mk ?loc ?attrs (Pexp_function a)\n let apply ?loc ?attrs a b = mk ?loc ?attrs (Pexp_apply (a, b))\n let match_ ?loc ?attrs a b = mk ?loc ?attrs (Pexp_match (a, b))\n let try_ ?loc ?attrs a b = mk ?loc ?attrs (Pexp_try (a, b))\n let tuple ?loc ?attrs a = mk ?loc ?attrs (Pexp_tuple a)\n let construct ?loc ?attrs a b = mk ?loc ?attrs (Pexp_construct (a, b))\n let variant ?loc ?attrs a b = mk ?loc ?attrs (Pexp_variant (a, b))\n let record ?loc ?attrs a b = mk ?loc ?attrs (Pexp_record (a, b))\n let field ?loc ?attrs a b = mk ?loc ?attrs (Pexp_field (a, b))\n let setfield ?loc ?attrs a b c = mk ?loc ?attrs (Pexp_setfield (a, b, c))\n let array ?loc ?attrs a = mk ?loc ?attrs (Pexp_array a)\n let ifthenelse ?loc ?attrs a b c = mk ?loc ?attrs (Pexp_ifthenelse (a, b, c))\n let sequence ?loc ?attrs a b = mk ?loc ?attrs (Pexp_sequence (a, b))\n let while_ ?loc ?attrs a b = mk ?loc ?attrs (Pexp_while (a, b))\n let for_ ?loc ?attrs a b c d e = mk ?loc ?attrs (Pexp_for (a, b, c, d, e))\n let constraint_ ?loc ?attrs a b = mk ?loc ?attrs (Pexp_constraint (a, b))\n let coerce ?loc ?attrs a b c = mk ?loc ?attrs (Pexp_coerce (a, b, c))\n let send ?loc ?attrs a b = mk ?loc ?attrs (Pexp_send (a, b))\n let new_ ?loc ?attrs a = mk ?loc ?attrs (Pexp_new a)\n let setinstvar ?loc ?attrs a b = mk ?loc ?attrs (Pexp_setinstvar (a, b))\n let override ?loc ?attrs a = mk ?loc ?attrs (Pexp_override a)\n let letmodule ?loc ?attrs a b c = mk ?loc ?attrs (Pexp_letmodule (a, b, c))\n let letexception ?loc ?attrs a b = mk ?loc ?attrs (Pexp_letexception (a, b))\n let assert_ ?loc ?attrs a = mk ?loc ?attrs (Pexp_assert a)\n let lazy_ ?loc ?attrs a = mk ?loc ?attrs (Pexp_lazy a)\n let poly ?loc ?attrs a b = mk ?loc ?attrs (Pexp_poly (a, b))\n let object_ ?loc ?attrs a = mk ?loc ?attrs (Pexp_object a)\n let newtype ?loc ?attrs a b = mk ?loc ?attrs (Pexp_newtype (a, b))\n let pack ?loc ?attrs a = mk ?loc ?attrs (Pexp_pack a)\n let open_ ?loc ?attrs a b = mk ?loc ?attrs (Pexp_open (a, b))\n\n let letop ?loc ?attrs let_ ands body =\n mk ?loc ?attrs (Pexp_letop { let_; ands; body })\n\n let extension ?loc ?attrs a = mk ?loc ?attrs (Pexp_extension a)\n let unreachable ?loc ?attrs () = mk ?loc ?attrs Pexp_unreachable\n let case lhs ?guard rhs = { pc_lhs = lhs; pc_guard = guard; pc_rhs = rhs }\n\n let binding_op op pat exp loc =\n { pbop_op = op; pbop_pat = pat; pbop_exp = exp; pbop_loc = loc }\nend\n\nmodule Mty = struct\n let mk ?(loc = !default_loc) ?(attrs = []) d =\n { pmty_desc = d; pmty_loc = loc; pmty_attributes = attrs }\n\n let attr d a = { d with pmty_attributes = d.pmty_attributes @ [ a ] }\n let ident ?loc ?attrs a = mk ?loc ?attrs (Pmty_ident a)\n let alias ?loc ?attrs a = mk ?loc ?attrs (Pmty_alias a)\n let signature ?loc ?attrs a = mk ?loc ?attrs (Pmty_signature a)\n let functor_ ?loc ?attrs a b = mk ?loc ?attrs (Pmty_functor (a, b))\n let with_ ?loc ?attrs a b = mk ?loc ?attrs (Pmty_with (a, b))\n let typeof_ ?loc ?attrs a = mk ?loc ?attrs (Pmty_typeof a)\n let extension ?loc ?attrs a = mk ?loc ?attrs (Pmty_extension a)\nend\n\nmodule Mod = struct\n let mk ?(loc = !default_loc) ?(attrs = []) d =\n { pmod_desc = d; pmod_loc = loc; pmod_attributes = attrs }\n\n let attr d a = { d with pmod_attributes = d.pmod_attributes @ [ a ] }\n let ident ?loc ?attrs x = mk ?loc ?attrs (Pmod_ident x)\n let structure ?loc ?attrs x = mk ?loc ?attrs (Pmod_structure x)\n let functor_ ?loc ?attrs arg body = mk ?loc ?attrs (Pmod_functor (arg, body))\n let apply ?loc ?attrs m1 m2 = mk ?loc ?attrs (Pmod_apply (m1, m2))\n let constraint_ ?loc ?attrs m mty = mk ?loc ?attrs (Pmod_constraint (m, mty))\n let unpack ?loc ?attrs e = mk ?loc ?attrs (Pmod_unpack e)\n let extension ?loc ?attrs a = mk ?loc ?attrs (Pmod_extension a)\nend\n\nmodule Sig = struct\n let mk ?(loc = !default_loc) d = { psig_desc = d; psig_loc = loc }\n let value ?loc a = mk ?loc (Psig_value a)\n let type_ ?loc rec_flag a = mk ?loc (Psig_type (rec_flag, a))\n let type_subst ?loc a = mk ?loc (Psig_typesubst a)\n let type_extension ?loc a = mk ?loc (Psig_typext a)\n let exception_ ?loc a = mk ?loc (Psig_exception a)\n let module_ ?loc a = mk ?loc (Psig_module a)\n let mod_subst ?loc a = mk ?loc (Psig_modsubst a)\n let rec_module ?loc a = mk ?loc (Psig_recmodule a)\n let modtype ?loc a = mk ?loc (Psig_modtype a)\n let open_ ?loc a = mk ?loc (Psig_open a)\n let include_ ?loc a = mk ?loc (Psig_include a)\n let class_ ?loc a = mk ?loc (Psig_class a)\n let class_type ?loc a = mk ?loc (Psig_class_type a)\n let extension ?loc ?(attrs = []) a = mk ?loc (Psig_extension (a, attrs))\n let attribute ?loc a = mk ?loc (Psig_attribute a)\nend\n\nmodule Str = struct\n let mk ?(loc = !default_loc) d = { pstr_desc = d; pstr_loc = loc }\n let eval ?loc ?(attrs = []) a = mk ?loc (Pstr_eval (a, attrs))\n let value ?loc a b = mk ?loc (Pstr_value (a, b))\n let primitive ?loc a = mk ?loc (Pstr_primitive a)\n let type_ ?loc rec_flag a = mk ?loc (Pstr_type (rec_flag, a))\n let type_extension ?loc a = mk ?loc (Pstr_typext a)\n let exception_ ?loc a = mk ?loc (Pstr_exception a)\n let module_ ?loc a = mk ?loc (Pstr_module a)\n let rec_module ?loc a = mk ?loc (Pstr_recmodule a)\n let modtype ?loc a = mk ?loc (Pstr_modtype a)\n let open_ ?loc a = mk ?loc (Pstr_open a)\n let class_ ?loc a = mk ?loc (Pstr_class a)\n let class_type ?loc a = mk ?loc (Pstr_class_type a)\n let include_ ?loc a = mk ?loc (Pstr_include a)\n let extension ?loc ?(attrs = []) a = mk ?loc (Pstr_extension (a, attrs))\n let attribute ?loc a = mk ?loc (Pstr_attribute a)\nend\n\nmodule Cl = struct\n let mk ?(loc = !default_loc) ?(attrs = []) d =\n { pcl_desc = d; pcl_loc = loc; pcl_attributes = attrs }\n\n let attr d a = { d with pcl_attributes = d.pcl_attributes @ [ a ] }\n let constr ?loc ?attrs a b = mk ?loc ?attrs (Pcl_constr (a, b))\n let structure ?loc ?attrs a = mk ?loc ?attrs (Pcl_structure a)\n let fun_ ?loc ?attrs a b c d = mk ?loc ?attrs (Pcl_fun (a, b, c, d))\n let apply ?loc ?attrs a b = mk ?loc ?attrs (Pcl_apply (a, b))\n let let_ ?loc ?attrs a b c = mk ?loc ?attrs (Pcl_let (a, b, c))\n let constraint_ ?loc ?attrs a b = mk ?loc ?attrs (Pcl_constraint (a, b))\n let extension ?loc ?attrs a = mk ?loc ?attrs (Pcl_extension a)\n let open_ ?loc ?attrs a b = mk ?loc ?attrs (Pcl_open (a, b))\nend\n\nmodule Cty = struct\n let mk ?(loc = !default_loc) ?(attrs = []) d =\n { pcty_desc = d; pcty_loc = loc; pcty_attributes = attrs }\n\n let attr d a = { d with pcty_attributes = d.pcty_attributes @ [ a ] }\n let constr ?loc ?attrs a b = mk ?loc ?attrs (Pcty_constr (a, b))\n let signature ?loc ?attrs a = mk ?loc ?attrs (Pcty_signature a)\n let arrow ?loc ?attrs a b c = mk ?loc ?attrs (Pcty_arrow (a, b, c))\n let extension ?loc ?attrs a = mk ?loc ?attrs (Pcty_extension a)\n let open_ ?loc ?attrs a b = mk ?loc ?attrs (Pcty_open (a, b))\nend\n\nmodule Ctf = struct\n let mk ?(loc = !default_loc) ?(attrs = []) d =\n { pctf_desc = d; pctf_loc = loc; pctf_attributes = attrs }\n\n let inherit_ ?loc ?attrs a = mk ?loc ?attrs (Pctf_inherit a)\n let val_ ?loc ?attrs a b c d = mk ?loc ?attrs (Pctf_val (a, b, c, d))\n let method_ ?loc ?attrs a b c d = mk ?loc ?attrs (Pctf_method (a, b, c, d))\n let constraint_ ?loc ?attrs a b = mk ?loc ?attrs (Pctf_constraint (a, b))\n let extension ?loc ?attrs a = mk ?loc ?attrs (Pctf_extension a)\n let attribute ?loc a = mk ?loc (Pctf_attribute a)\n let attr d a = { d with pctf_attributes = d.pctf_attributes @ [ a ] }\nend\n\nmodule Cf = struct\n let mk ?(loc = !default_loc) ?(attrs = []) d =\n { pcf_desc = d; pcf_loc = loc; pcf_attributes = attrs }\n\n let inherit_ ?loc ?attrs a b c = mk ?loc ?attrs (Pcf_inherit (a, b, c))\n let val_ ?loc ?attrs a b c = mk ?loc ?attrs (Pcf_val (a, b, c))\n let method_ ?loc ?attrs a b c = mk ?loc ?attrs (Pcf_method (a, b, c))\n let constraint_ ?loc ?attrs a b = mk ?loc ?attrs (Pcf_constraint (a, b))\n let initializer_ ?loc ?attrs a = mk ?loc ?attrs (Pcf_initializer a)\n let extension ?loc ?attrs a = mk ?loc ?attrs (Pcf_extension a)\n let attribute ?loc a = mk ?loc (Pcf_attribute a)\n let virtual_ ct = Cfk_virtual ct\n let concrete o e = Cfk_concrete (o, e)\n let attr d a = { d with pcf_attributes = d.pcf_attributes @ [ a ] }\nend\n\nmodule Val = struct\n let mk ?(loc = !default_loc) ?(attrs = []) ?(prim = []) name typ =\n {\n pval_name = name;\n pval_type = typ;\n pval_attributes = attrs;\n pval_loc = loc;\n pval_prim = prim;\n }\nend\n\nmodule Md = struct\n let mk ?(loc = !default_loc) ?(attrs = []) name typ =\n { pmd_name = name; pmd_type = typ; pmd_attributes = attrs; pmd_loc = loc }\nend\n\nmodule Ms = struct\n let mk ?(loc = !default_loc) ?(attrs = []) name syn =\n {\n pms_name = name;\n pms_manifest = syn;\n pms_attributes = attrs;\n pms_loc = loc;\n }\nend\n\nmodule Mtd = struct\n let mk ?(loc = !default_loc) ?(attrs = []) ?typ name =\n {\n pmtd_name = name;\n pmtd_type = typ;\n pmtd_attributes = attrs;\n pmtd_loc = loc;\n }\nend\n\nmodule Mb = struct\n let mk ?(loc = !default_loc) ?(attrs = []) name expr =\n { pmb_name = name; pmb_expr = expr; pmb_attributes = attrs; pmb_loc = loc }\nend\n\nmodule Opn = struct\n let mk ?(loc = !default_loc) ?(attrs = []) ?(override = Fresh) expr =\n {\n popen_expr = expr;\n popen_override = override;\n popen_loc = loc;\n popen_attributes = attrs;\n }\nend\n\nmodule Incl = struct\n let mk ?(loc = !default_loc) ?(attrs = []) mexpr =\n { pincl_mod = mexpr; pincl_loc = loc; pincl_attributes = attrs }\nend\n\nmodule Vb = struct\n let mk ?(loc = !default_loc) ?(attrs = []) pat expr =\n { pvb_pat = pat; pvb_expr = expr; pvb_attributes = attrs; pvb_loc = loc }\nend\n\nmodule Ci = struct\n let mk ?(loc = !default_loc) ?(attrs = []) ?(virt = Concrete) ?(params = [])\n name expr =\n {\n pci_virt = virt;\n pci_params = params;\n pci_name = name;\n pci_expr = expr;\n pci_attributes = attrs;\n pci_loc = loc;\n }\nend\n\nmodule Type = struct\n let mk ?(loc = !default_loc) ?(attrs = []) ?(params = []) ?(cstrs = [])\n ?(kind = Ptype_abstract) ?(priv = Public) ?manifest name =\n {\n ptype_name = name;\n ptype_params = params;\n ptype_cstrs = cstrs;\n ptype_kind = kind;\n ptype_private = priv;\n ptype_manifest = manifest;\n ptype_attributes = attrs;\n ptype_loc = loc;\n }\n\n let constructor ?(loc = !default_loc) ?(attrs = []) ?(args = Pcstr_tuple [])\n ?res name =\n {\n pcd_name = name;\n pcd_args = args;\n pcd_res = res;\n pcd_loc = loc;\n pcd_attributes = attrs;\n }\n\n let field ?(loc = !default_loc) ?(attrs = []) ?(mut = Immutable) name typ =\n {\n pld_name = name;\n pld_mutable = mut;\n pld_type = typ;\n pld_loc = loc;\n pld_attributes = attrs;\n }\nend\n\n(** Type extensions *)\nmodule Te = struct\n let mk ?(loc = !default_loc) ?(attrs = []) ?(params = []) ?(priv = Public)\n path constructors =\n {\n ptyext_path = path;\n ptyext_params = params;\n ptyext_constructors = constructors;\n ptyext_private = priv;\n ptyext_loc = loc;\n ptyext_attributes = attrs;\n }\n\n let mk_exception ?(loc = !default_loc) ?(attrs = []) constructor =\n {\n ptyexn_constructor = constructor;\n ptyexn_loc = loc;\n ptyexn_attributes = attrs;\n }\n\n let constructor ?(loc = !default_loc) ?(attrs = []) name kind =\n {\n pext_name = name;\n pext_kind = kind;\n pext_loc = loc;\n pext_attributes = attrs;\n }\n\n let decl ?(loc = !default_loc) ?(attrs = []) ?(args = Pcstr_tuple []) ?res\n name =\n {\n pext_name = name;\n pext_kind = Pext_decl (args, res);\n pext_loc = loc;\n pext_attributes = attrs;\n }\n\n let rebind ?(loc = !default_loc) ?(attrs = []) name lid =\n {\n pext_name = name;\n pext_kind = Pext_rebind lid;\n pext_loc = loc;\n pext_attributes = attrs;\n }\nend\n\nmodule Csig = struct\n let mk self fields = { pcsig_self = self; pcsig_fields = fields }\nend\n\nmodule Cstr = struct\n let mk self fields = { pcstr_self = self; pcstr_fields = fields }\nend\n\n(** Row fields *)\nmodule Rf = struct\n let mk ?(loc = !default_loc) ?(attrs = []) desc =\n { prf_desc = desc; prf_loc = loc; prf_attributes = attrs }\n\n let tag ?loc ?attrs label const tys =\n mk ?loc ?attrs (Rtag (label, const, tys))\n\n let inherit_ ?loc ty = mk ?loc (Rinherit ty)\nend\n\n(** Object fields *)\nmodule Of = struct\n let mk ?(loc = !default_loc) ?(attrs = []) desc =\n { pof_desc = desc; pof_loc = loc; pof_attributes = attrs }\n\n let tag ?loc ?attrs label ty = mk ?loc ?attrs (Otag (label, ty))\n let inherit_ ?loc ty = mk ?loc (Oinherit ty)\nend\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Daniel C. Buenzli *)\n(* *)\n(* Copyright 2014 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nexternal format_int : string -> int -> string = \"caml_format_int\"\n\nlet err_no_pred = \"U+0000 has no predecessor\"\nlet err_no_succ = \"U+10FFFF has no successor\"\nlet err_not_sv i = format_int \"%X\" i ^ \" is not an Unicode scalar value\"\nlet err_not_latin1 u = \"U+\" ^ format_int \"%04X\" u ^ \" is not a latin1 character\"\n\ntype t = int\n\nlet min = 0x0000\nlet max = 0x10FFFF\nlet lo_bound = 0xD7FF\nlet hi_bound = 0xE000\n\nlet bom = 0xFEFF\nlet rep = 0xFFFD\n\nlet succ u =\n if u = lo_bound then hi_bound else\n if u = max then invalid_arg err_no_succ else\n u + 1\n\nlet pred u =\n if u = hi_bound then lo_bound else\n if u = min then invalid_arg err_no_pred else\n u - 1\n\nlet is_valid i = (min <= i && i <= lo_bound) || (hi_bound <= i && i <= max)\nlet of_int i = if is_valid i then i else invalid_arg (err_not_sv i)\nexternal unsafe_of_int : int -> t = \"%identity\"\nexternal to_int : t -> int = \"%identity\"\n\nlet is_char u = u < 256\nlet of_char c = Char.code c\nlet to_char u =\n if u > 255 then invalid_arg (err_not_latin1 u) else\n Char.unsafe_chr u\n\nlet unsafe_to_char = Char.unsafe_chr\n\nlet equal : int -> int -> bool = ( = )\nlet compare : int -> int -> int = Stdlib.compare\nlet hash = to_int\n\n(* UTF codecs tools *)\n\ntype utf_decode = int\n(* This is an int [0xDUUUUUU] decomposed as follows:\n - [D] is four bits for decode information, the highest bit is set if the\n decode is valid. The three lower bits indicate the number of elements\n from the source that were consumed by the decode.\n - [UUUUUU] is the decoded Unicode character or the Unicode replacement\n character U+FFFD if for invalid decodes. *)\n\nlet valid_bit = 27\nlet decode_bits = 24\n\nlet[@inline] utf_decode_is_valid d = (d lsr valid_bit) = 1\nlet[@inline] utf_decode_length d = (d lsr decode_bits) land 0b111\nlet[@inline] utf_decode_uchar d = unsafe_of_int (d land 0xFFFFFF)\nlet[@inline] utf_decode n u = ((8 lor n) lsl decode_bits) lor (to_int u)\nlet[@inline] utf_decode_invalid n = (n lsl decode_bits) lor rep\n\nlet utf_8_byte_length u = match to_int u with\n| u when u < 0 -> assert false\n| u when u <= 0x007F -> 1\n| u when u <= 0x07FF -> 2\n| u when u <= 0xFFFF -> 3\n| u when u <= 0x10FFFF -> 4\n| _ -> assert false\n\nlet utf_16_byte_length u = match to_int u with\n| u when u < 0 -> assert false\n| u when u <= 0xFFFF -> 2\n| u when u <= 0x10FFFF -> 4\n| _ -> assert false\n","module Int = struct\n let to_string = string_of_int\nend\n\nmodule Option = struct\n let map f o = match o with None -> None | Some v -> Some (f v)\nend\n","include Ocaml_common.Location\n\nlet set_input_name name = input_name := name\n\nmodule Error = struct\n [@@@warning \"-37\"]\n\n type old_t (*IF_NOT_AT_LEAST 408 = Ocaml_common.Location.error *) = {\n loc: t;\n msg: string;\n sub: old_t list;\n if_highlight: string;\n }\n\n type location_report_kind (*IF_AT_LEAST 408 = Ocaml_common.Location.report_kind *) =\n | Report_error\n | Report_warning of string\n | Report_warning_as_error of string\n | Report_alert of string\n | Report_alert_as_error of string\n\n type location_msg = (Format.formatter -> unit) loc\n\n type location_report (*IF_AT_LEAST 408 = Ocaml_common.Location.report *) = {\n kind : location_report_kind;\n main : location_msg;\n sub : location_msg list;\n }\n\n type t (*IF_AT_LEAST 408 = Ocaml_common.Location.error *) (*IF_NOT_AT_LEAST 408 = old_t *)\n (** On ocaml >= 4.08: [t] is a [location_report] for which [location_report_kind] must be [Report_error]. *)\n\n type version_specific_t = [`New_error of location_report | `Old_error of old_t]\n\n let version_specific_t_of_t : t -> version_specific_t = fun x ->\n (*IF_AT_LEAST 408 `New_error x *)\n (*IF_NOT_AT_LEAST 408 `Old_error x *)\n\n let is_well_formed error =\n match version_specific_t_of_t error with\n | `New_error { kind = Report_error; _ } -> true\n | `New_error _ -> false\n | `Old_error _ -> true\n\n let string_of_location_msg (msg : location_msg) = Format.asprintf \"%t\" msg.txt\n\n let main_msg error =\n match version_specific_t_of_t error with\n | `New_error { main; _ } ->\n { txt = string_of_location_msg main; loc = main.loc }\n | `Old_error { msg; loc; _ } -> { txt = msg; loc }\n\n let sub_msgs error =\n match version_specific_t_of_t error with\n | `New_error { sub; _ } ->\n List.map\n (fun err -> { txt = string_of_location_msg err; loc = err.loc })\n sub\n | `Old_error { sub; _ } ->\n let rec deeply_flattened_sub_msgs acc = function\n | [] -> acc\n | { loc; msg; sub; _ } :: tail ->\n deeply_flattened_sub_msgs ({ txt = msg; loc } :: acc) (sub @ tail)\n in\n deeply_flattened_sub_msgs [] sub\n\n let of_exn exn =\n (*IF_AT_LEAST 406 match error_of_exn exn with | Some (`Ok e) -> Some e | None | Some `Already_displayed -> None *)\n (*IF_NOT_AT_LEAST 406 error_of_exn exn*)\n\n let _set_main_msg_old error msg = { error with msg }\n\n let _set_main_msg_new error msg =\n let txt ppf = Format.pp_print_string ppf msg in\n let main = { error.main with txt } in\n { error with main }\n\n let set_main_msg error msg =\n (*IF_NOT_AT_LEAST 408 _set_main_msg_old error msg*)\n (*IF_AT_LEAST 408 _set_main_msg_new error msg*)\n\n let _make_error_of_message_old ~sub { loc; txt } =\n let sub =\n List.map\n (fun { loc; txt } -> { loc; msg = txt; sub = []; if_highlight = txt })\n sub\n in\n { loc; msg = txt; sub; if_highlight = txt }\n\n let _make_error_of_message_new ~sub { loc; txt } =\n let mk_txt x ppf = Format.pp_print_string ppf x in\n let mk loc x = { loc; txt = mk_txt x } in\n {\n kind = Report_error;\n main = mk loc txt;\n sub = List.map (fun { loc; txt } -> mk loc txt) sub;\n }\n\n let make ~sub msg =\n (*IF_NOT_AT_LEAST 408 _make_error_of_message_old ~sub msg*)\n (*IF_AT_LEAST 408 _make_error_of_message_new ~sub msg*)\n\n let _set_main_loc_old error loc = { error with loc }\n\n let _set_main_loc_new error loc =\n let main = { error.main with loc } in\n { error with main }\n\n let set_main_loc error loc =\n (*IF_NOT_AT_LEAST 408 _set_main_loc_old error loc*)\n (*IF_AT_LEAST 408 _set_main_loc_new error loc*)\nend\n\nlet raise_errorf ?loc msg = raise_errorf ?loc msg\n","(*$ open Ppxlib_cinaps_helpers $*)\nopen! Import\nmodule Format = Caml.Format\nmodule Filename = Caml.Filename\n\n(* TODO: make the \"deriving.\" depend on the matching attribute name. *)\nlet end_marker_sig =\n Attribute.Floating.declare \"deriving.end\" Signature_item\n Ast_pattern.(pstr nil)\n ()\n\nlet end_marker_str =\n Attribute.Floating.declare \"deriving.end\" Structure_item\n Ast_pattern.(pstr nil)\n ()\n\nmodule type T1 = sig\n type 'a t\nend\n\nmodule Make (M : sig\n type t\n\n val get_loc : t -> Location.t\n val end_marker : (t, unit) Attribute.Floating.t\n\n module Transform (T : T1) : sig\n val apply :\n < structure_item : structure_item T.t\n ; signature_item : signature_item T.t\n ; .. > ->\n t T.t\n end\n\n val parse : Lexing.lexbuf -> t list\n val pp : Format.formatter -> t -> unit\n val to_sexp : t -> Sexp.t\nend) =\nstruct\n let extract_prefix ~pos l =\n let rec loop acc = function\n | [] ->\n let loc =\n { Location.loc_start = pos; loc_end = pos; loc_ghost = false }\n in\n Location.raise_errorf ~loc \"ppxlib: [@@@@@@%s] attribute missing\"\n (Attribute.Floating.name M.end_marker)\n | x :: l -> (\n match Attribute.Floating.convert [ M.end_marker ] x with\n | None -> loop (x :: acc) l\n | Some () -> (List.rev acc, (M.get_loc x).loc_start)\n | exception Failure _ -> loop (x :: acc) l)\n in\n loop [] l\n\n let remove_loc =\n object\n inherit Ast_traverse.map\n method! location _ = Location.none\n method! location_stack _ = []\n end\n\n module M_map = M.Transform (struct\n type 'a t = 'a -> 'a\n end)\n\n let remove_loc x = M_map.apply remove_loc x\n let rec last prev = function [] -> prev | x :: l -> last x l\n\n let diff_asts ~generated ~round_trip =\n let with_temp_file f =\n Exn.protectx (Filename.temp_file \"ppxlib\" \"\") ~finally:Caml.Sys.remove ~f\n in\n with_temp_file (fun fn1 ->\n with_temp_file (fun fn2 ->\n with_temp_file (fun out ->\n let dump fn ast =\n Out_channel.with_file fn ~f:(fun oc ->\n let ppf = Format.formatter_of_out_channel oc in\n Sexp.pp_hum ppf (M.to_sexp ast);\n Format.pp_print_flush ppf ())\n in\n dump fn1 generated;\n dump fn2 round_trip;\n let cmd =\n Printf.sprintf\n \"patdiff -ascii -alt-old generated -alt-new \\\n 'generated->printed->parsed' %s %s &> %s\"\n (Filename.quote fn1) (Filename.quote fn2)\n (Filename.quote out)\n in\n let ok =\n Caml.Sys.command cmd = 1\n ||\n let cmd =\n Printf.sprintf\n \"diff --label generated --label \\\n 'generated->printed->parsed' %s %s &> %s\"\n (Filename.quote fn1) (Filename.quote fn2)\n (Filename.quote out)\n in\n Caml.Sys.command cmd = 1\n in\n if ok then In_channel.read_all out\n else \"\")))\n\n let parse_string s =\n match M.parse (Lexing.from_string s) with [ x ] -> x | _ -> assert false\n\n let rec match_loop ~end_pos ~mismatch_handler ~expected ~source =\n match (expected, source) with\n | [], [] -> ()\n | [], x :: l ->\n let loc =\n { (M.get_loc x) with loc_end = (M.get_loc (last x l)).loc_end }\n in\n mismatch_handler loc []\n | _, [] ->\n let loc =\n { Location.loc_ghost = false; loc_start = end_pos; loc_end = end_pos }\n in\n mismatch_handler loc expected\n | x :: expected, y :: source ->\n let loc = M.get_loc y in\n let x = remove_loc x in\n let y = remove_loc y in\n if Poly.( <> ) x y then (\n let round_trip =\n remove_loc (parse_string (Format.asprintf \"%a@.\" M.pp x))\n in\n if Poly.( <> ) x round_trip then\n Location.raise_errorf ~loc\n \"ppxlib: the corrected code doesn't round-trip.\\n\\\n This is probably a bug in the OCaml printer:\\n\\\n %s\"\n (diff_asts ~generated:x ~round_trip);\n mismatch_handler loc [ x ]);\n match_loop ~end_pos ~mismatch_handler ~expected ~source\n\n let do_match ~pos ~expected ~mismatch_handler source =\n let source, end_pos = extract_prefix ~pos source in\n match_loop ~end_pos ~mismatch_handler ~expected ~source\nend\n\n(*$*)\nmodule Str = Make (struct\n type t = structure_item\n\n let get_loc x = x.pstr_loc\n let end_marker = end_marker_str\n\n module Transform (T : T1) = struct\n let apply o = o#structure_item\n end\n\n let parse = Parse.implementation\n let pp = Pprintast.structure_item\n let to_sexp = Ast_traverse.sexp_of#structure_item\nend)\n\n(*$ str_to_sig _last_text_block *)\nmodule Sig = Make (struct\n type t = signature_item\n\n let get_loc x = x.psig_loc\n let end_marker = end_marker_sig\n\n module Transform (T : T1) = struct\n let apply o = o#signature_item\n end\n\n let parse = Parse.interface\n let pp = Pprintast.signature_item\n let to_sexp = Ast_traverse.sexp_of#signature_item\nend)\n\n(*$*)\n\nlet match_structure = Str.do_match\nlet match_signature = Sig.do_match\n","open Stdlib0\nmodule From = Ast_414\nmodule To = Ast_413\n\nlet migration_error loc missing_feature =\n Location.raise_errorf ~loc\n \"migration error: %s is not supported before OCaml 4.13\" missing_feature\n\nlet rec copy_toplevel_phrase :\n Ast_414.Parsetree.toplevel_phrase -> Ast_413.Parsetree.toplevel_phrase =\n function\n | Ast_414.Parsetree.Ptop_def x0 ->\n Ast_413.Parsetree.Ptop_def (copy_structure x0)\n | Ast_414.Parsetree.Ptop_dir x0 ->\n Ast_413.Parsetree.Ptop_dir (copy_toplevel_directive x0)\n\nand copy_toplevel_directive :\n Ast_414.Parsetree.toplevel_directive -> Ast_413.Parsetree.toplevel_directive\n =\n fun {\n Ast_414.Parsetree.pdir_name;\n Ast_414.Parsetree.pdir_arg;\n Ast_414.Parsetree.pdir_loc;\n } ->\n {\n Ast_413.Parsetree.pdir_name = copy_loc (fun x -> x) pdir_name;\n Ast_413.Parsetree.pdir_arg = Option.map copy_directive_argument pdir_arg;\n Ast_413.Parsetree.pdir_loc = copy_location pdir_loc;\n }\n\nand copy_directive_argument :\n Ast_414.Parsetree.directive_argument -> Ast_413.Parsetree.directive_argument\n =\n fun { Ast_414.Parsetree.pdira_desc; Ast_414.Parsetree.pdira_loc } ->\n {\n Ast_413.Parsetree.pdira_desc = copy_directive_argument_desc pdira_desc;\n Ast_413.Parsetree.pdira_loc = copy_location pdira_loc;\n }\n\nand copy_directive_argument_desc :\n Ast_414.Parsetree.directive_argument_desc ->\n Ast_413.Parsetree.directive_argument_desc = function\n | Ast_414.Parsetree.Pdir_string x0 -> Ast_413.Parsetree.Pdir_string x0\n | Ast_414.Parsetree.Pdir_int (x0, x1) ->\n Ast_413.Parsetree.Pdir_int (x0, Option.map (fun x -> x) x1)\n | Ast_414.Parsetree.Pdir_ident x0 ->\n Ast_413.Parsetree.Pdir_ident (copy_Longident_t x0)\n | Ast_414.Parsetree.Pdir_bool x0 -> Ast_413.Parsetree.Pdir_bool x0\n\nand copy_expression :\n Ast_414.Parsetree.expression -> Ast_413.Parsetree.expression =\n fun {\n Ast_414.Parsetree.pexp_desc;\n Ast_414.Parsetree.pexp_loc;\n Ast_414.Parsetree.pexp_loc_stack;\n Ast_414.Parsetree.pexp_attributes;\n } ->\n {\n Ast_413.Parsetree.pexp_desc = copy_expression_desc pexp_desc;\n Ast_413.Parsetree.pexp_loc = copy_location pexp_loc;\n Ast_413.Parsetree.pexp_loc_stack = copy_location_stack pexp_loc_stack;\n Ast_413.Parsetree.pexp_attributes = copy_attributes pexp_attributes;\n }\n\nand copy_expression_desc :\n Ast_414.Parsetree.expression_desc -> Ast_413.Parsetree.expression_desc =\n function\n | Ast_414.Parsetree.Pexp_ident x0 ->\n Ast_413.Parsetree.Pexp_ident (copy_loc copy_Longident_t x0)\n | Ast_414.Parsetree.Pexp_constant x0 ->\n Ast_413.Parsetree.Pexp_constant (copy_constant x0)\n | Ast_414.Parsetree.Pexp_let (x0, x1, x2) ->\n Ast_413.Parsetree.Pexp_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_expression x2)\n | Ast_414.Parsetree.Pexp_function x0 ->\n Ast_413.Parsetree.Pexp_function (List.map copy_case x0)\n | Ast_414.Parsetree.Pexp_fun (x0, x1, x2, x3) ->\n Ast_413.Parsetree.Pexp_fun\n ( copy_arg_label x0,\n Option.map copy_expression x1,\n copy_pattern x2,\n copy_expression x3 )\n | Ast_414.Parsetree.Pexp_apply (x0, x1) ->\n Ast_413.Parsetree.Pexp_apply\n ( copy_expression x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | Ast_414.Parsetree.Pexp_match (x0, x1) ->\n Ast_413.Parsetree.Pexp_match (copy_expression x0, List.map copy_case x1)\n | Ast_414.Parsetree.Pexp_try (x0, x1) ->\n Ast_413.Parsetree.Pexp_try (copy_expression x0, List.map copy_case x1)\n | Ast_414.Parsetree.Pexp_tuple x0 ->\n Ast_413.Parsetree.Pexp_tuple (List.map copy_expression x0)\n | Ast_414.Parsetree.Pexp_construct (x0, x1) ->\n Ast_413.Parsetree.Pexp_construct\n (copy_loc copy_Longident_t x0, Option.map copy_expression x1)\n | Ast_414.Parsetree.Pexp_variant (x0, x1) ->\n Ast_413.Parsetree.Pexp_variant\n (copy_label x0, Option.map copy_expression x1)\n | Ast_414.Parsetree.Pexp_record (x0, x1) ->\n Ast_413.Parsetree.Pexp_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_expression x1))\n x0,\n Option.map copy_expression x1 )\n | Ast_414.Parsetree.Pexp_field (x0, x1) ->\n Ast_413.Parsetree.Pexp_field\n (copy_expression x0, copy_loc copy_Longident_t x1)\n | Ast_414.Parsetree.Pexp_setfield (x0, x1, x2) ->\n Ast_413.Parsetree.Pexp_setfield\n (copy_expression x0, copy_loc copy_Longident_t x1, copy_expression x2)\n | Ast_414.Parsetree.Pexp_array x0 ->\n Ast_413.Parsetree.Pexp_array (List.map copy_expression x0)\n | Ast_414.Parsetree.Pexp_ifthenelse (x0, x1, x2) ->\n Ast_413.Parsetree.Pexp_ifthenelse\n (copy_expression x0, copy_expression x1, Option.map copy_expression x2)\n | Ast_414.Parsetree.Pexp_sequence (x0, x1) ->\n Ast_413.Parsetree.Pexp_sequence (copy_expression x0, copy_expression x1)\n | Ast_414.Parsetree.Pexp_while (x0, x1) ->\n Ast_413.Parsetree.Pexp_while (copy_expression x0, copy_expression x1)\n | Ast_414.Parsetree.Pexp_for (x0, x1, x2, x3, x4) ->\n Ast_413.Parsetree.Pexp_for\n ( copy_pattern x0,\n copy_expression x1,\n copy_expression x2,\n copy_direction_flag x3,\n copy_expression x4 )\n | Ast_414.Parsetree.Pexp_constraint (x0, x1) ->\n Ast_413.Parsetree.Pexp_constraint (copy_expression x0, copy_core_type x1)\n | Ast_414.Parsetree.Pexp_coerce (x0, x1, x2) ->\n Ast_413.Parsetree.Pexp_coerce\n (copy_expression x0, Option.map copy_core_type x1, copy_core_type x2)\n | Ast_414.Parsetree.Pexp_send (x0, x1) ->\n Ast_413.Parsetree.Pexp_send (copy_expression x0, copy_loc copy_label x1)\n | Ast_414.Parsetree.Pexp_new x0 ->\n Ast_413.Parsetree.Pexp_new (copy_loc copy_Longident_t x0)\n | Ast_414.Parsetree.Pexp_setinstvar (x0, x1) ->\n Ast_413.Parsetree.Pexp_setinstvar\n (copy_loc copy_label x0, copy_expression x1)\n | Ast_414.Parsetree.Pexp_override x0 ->\n Ast_413.Parsetree.Pexp_override\n (List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_label x0, copy_expression x1))\n x0)\n | Ast_414.Parsetree.Pexp_letmodule (x0, x1, x2) ->\n Ast_413.Parsetree.Pexp_letmodule\n ( copy_loc (fun x -> Option.map (fun x -> x) x) x0,\n copy_module_expr x1,\n copy_expression x2 )\n | Ast_414.Parsetree.Pexp_letexception (x0, x1) ->\n Ast_413.Parsetree.Pexp_letexception\n (copy_extension_constructor x0, copy_expression x1)\n | Ast_414.Parsetree.Pexp_assert x0 ->\n Ast_413.Parsetree.Pexp_assert (copy_expression x0)\n | Ast_414.Parsetree.Pexp_lazy x0 ->\n Ast_413.Parsetree.Pexp_lazy (copy_expression x0)\n | Ast_414.Parsetree.Pexp_poly (x0, x1) ->\n Ast_413.Parsetree.Pexp_poly\n (copy_expression x0, Option.map copy_core_type x1)\n | Ast_414.Parsetree.Pexp_object x0 ->\n Ast_413.Parsetree.Pexp_object (copy_class_structure x0)\n | Ast_414.Parsetree.Pexp_newtype (x0, x1) ->\n Ast_413.Parsetree.Pexp_newtype\n (copy_loc (fun x -> x) x0, copy_expression x1)\n | Ast_414.Parsetree.Pexp_pack x0 ->\n Ast_413.Parsetree.Pexp_pack (copy_module_expr x0)\n | Ast_414.Parsetree.Pexp_open (x0, x1) ->\n Ast_413.Parsetree.Pexp_open (copy_open_declaration x0, copy_expression x1)\n | Ast_414.Parsetree.Pexp_letop x0 ->\n Ast_413.Parsetree.Pexp_letop (copy_letop x0)\n | Ast_414.Parsetree.Pexp_extension x0 ->\n Ast_413.Parsetree.Pexp_extension (copy_extension x0)\n | Ast_414.Parsetree.Pexp_unreachable -> Ast_413.Parsetree.Pexp_unreachable\n\nand copy_letop : Ast_414.Parsetree.letop -> Ast_413.Parsetree.letop =\n fun { Ast_414.Parsetree.let_; Ast_414.Parsetree.ands; Ast_414.Parsetree.body } ->\n {\n Ast_413.Parsetree.let_ = copy_binding_op let_;\n Ast_413.Parsetree.ands = List.map copy_binding_op ands;\n Ast_413.Parsetree.body = copy_expression body;\n }\n\nand copy_binding_op :\n Ast_414.Parsetree.binding_op -> Ast_413.Parsetree.binding_op =\n fun {\n Ast_414.Parsetree.pbop_op;\n Ast_414.Parsetree.pbop_pat;\n Ast_414.Parsetree.pbop_exp;\n Ast_414.Parsetree.pbop_loc;\n } ->\n {\n Ast_413.Parsetree.pbop_op = copy_loc (fun x -> x) pbop_op;\n Ast_413.Parsetree.pbop_pat = copy_pattern pbop_pat;\n Ast_413.Parsetree.pbop_exp = copy_expression pbop_exp;\n Ast_413.Parsetree.pbop_loc = copy_location pbop_loc;\n }\n\nand copy_direction_flag :\n Ast_414.Asttypes.direction_flag -> Ast_413.Asttypes.direction_flag =\n function\n | Ast_414.Asttypes.Upto -> Ast_413.Asttypes.Upto\n | Ast_414.Asttypes.Downto -> Ast_413.Asttypes.Downto\n\nand copy_case : Ast_414.Parsetree.case -> Ast_413.Parsetree.case =\n fun {\n Ast_414.Parsetree.pc_lhs;\n Ast_414.Parsetree.pc_guard;\n Ast_414.Parsetree.pc_rhs;\n } ->\n {\n Ast_413.Parsetree.pc_lhs = copy_pattern pc_lhs;\n Ast_413.Parsetree.pc_guard = Option.map copy_expression pc_guard;\n Ast_413.Parsetree.pc_rhs = copy_expression pc_rhs;\n }\n\nand copy_value_binding :\n Ast_414.Parsetree.value_binding -> Ast_413.Parsetree.value_binding =\n fun {\n Ast_414.Parsetree.pvb_pat;\n Ast_414.Parsetree.pvb_expr;\n Ast_414.Parsetree.pvb_attributes;\n Ast_414.Parsetree.pvb_loc;\n } ->\n {\n Ast_413.Parsetree.pvb_pat = copy_pattern pvb_pat;\n Ast_413.Parsetree.pvb_expr = copy_expression pvb_expr;\n Ast_413.Parsetree.pvb_attributes = copy_attributes pvb_attributes;\n Ast_413.Parsetree.pvb_loc = copy_location pvb_loc;\n }\n\nand copy_pattern : Ast_414.Parsetree.pattern -> Ast_413.Parsetree.pattern =\n fun {\n Ast_414.Parsetree.ppat_desc;\n Ast_414.Parsetree.ppat_loc;\n Ast_414.Parsetree.ppat_loc_stack;\n Ast_414.Parsetree.ppat_attributes;\n } ->\n {\n Ast_413.Parsetree.ppat_desc = copy_pattern_desc ppat_desc;\n Ast_413.Parsetree.ppat_loc = copy_location ppat_loc;\n Ast_413.Parsetree.ppat_loc_stack = copy_location_stack ppat_loc_stack;\n Ast_413.Parsetree.ppat_attributes = copy_attributes ppat_attributes;\n }\n\nand copy_pattern_desc :\n Ast_414.Parsetree.pattern_desc -> Ast_413.Parsetree.pattern_desc = function\n | Ast_414.Parsetree.Ppat_any -> Ast_413.Parsetree.Ppat_any\n | Ast_414.Parsetree.Ppat_var x0 ->\n Ast_413.Parsetree.Ppat_var (copy_loc (fun x -> x) x0)\n | Ast_414.Parsetree.Ppat_alias (x0, x1) ->\n Ast_413.Parsetree.Ppat_alias (copy_pattern x0, copy_loc (fun x -> x) x1)\n | Ast_414.Parsetree.Ppat_constant x0 ->\n Ast_413.Parsetree.Ppat_constant (copy_constant x0)\n | Ast_414.Parsetree.Ppat_interval (x0, x1) ->\n Ast_413.Parsetree.Ppat_interval (copy_constant x0, copy_constant x1)\n | Ast_414.Parsetree.Ppat_tuple x0 ->\n Ast_413.Parsetree.Ppat_tuple (List.map copy_pattern x0)\n | Ast_414.Parsetree.Ppat_construct (x0, x1) ->\n Ast_413.Parsetree.Ppat_construct\n ( copy_loc copy_Longident_t x0,\n Option.map\n (fun x ->\n let x0, x1 = x in\n (List.map (fun x -> copy_loc (fun x -> x) x) x0, copy_pattern x1))\n x1 )\n | Ast_414.Parsetree.Ppat_variant (x0, x1) ->\n Ast_413.Parsetree.Ppat_variant (copy_label x0, Option.map copy_pattern x1)\n | Ast_414.Parsetree.Ppat_record (x0, x1) ->\n Ast_413.Parsetree.Ppat_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_pattern x1))\n x0,\n copy_closed_flag x1 )\n | Ast_414.Parsetree.Ppat_array x0 ->\n Ast_413.Parsetree.Ppat_array (List.map copy_pattern x0)\n | Ast_414.Parsetree.Ppat_or (x0, x1) ->\n Ast_413.Parsetree.Ppat_or (copy_pattern x0, copy_pattern x1)\n | Ast_414.Parsetree.Ppat_constraint (x0, x1) ->\n Ast_413.Parsetree.Ppat_constraint (copy_pattern x0, copy_core_type x1)\n | Ast_414.Parsetree.Ppat_type x0 ->\n Ast_413.Parsetree.Ppat_type (copy_loc copy_Longident_t x0)\n | Ast_414.Parsetree.Ppat_lazy x0 ->\n Ast_413.Parsetree.Ppat_lazy (copy_pattern x0)\n | Ast_414.Parsetree.Ppat_unpack x0 ->\n Ast_413.Parsetree.Ppat_unpack\n (copy_loc (fun x -> Option.map (fun x -> x) x) x0)\n | Ast_414.Parsetree.Ppat_exception x0 ->\n Ast_413.Parsetree.Ppat_exception (copy_pattern x0)\n | Ast_414.Parsetree.Ppat_extension x0 ->\n Ast_413.Parsetree.Ppat_extension (copy_extension x0)\n | Ast_414.Parsetree.Ppat_open (x0, x1) ->\n Ast_413.Parsetree.Ppat_open (copy_loc copy_Longident_t x0, copy_pattern x1)\n\nand copy_core_type : Ast_414.Parsetree.core_type -> Ast_413.Parsetree.core_type\n =\n fun {\n Ast_414.Parsetree.ptyp_desc;\n Ast_414.Parsetree.ptyp_loc;\n Ast_414.Parsetree.ptyp_loc_stack;\n Ast_414.Parsetree.ptyp_attributes;\n } ->\n {\n Ast_413.Parsetree.ptyp_desc = copy_core_type_desc ptyp_desc;\n Ast_413.Parsetree.ptyp_loc = copy_location ptyp_loc;\n Ast_413.Parsetree.ptyp_loc_stack = copy_location_stack ptyp_loc_stack;\n Ast_413.Parsetree.ptyp_attributes = copy_attributes ptyp_attributes;\n }\n\nand copy_location_stack :\n Ast_414.Parsetree.location_stack -> Ast_413.Parsetree.location_stack =\n fun x -> x\n\nand copy_core_type_desc :\n Ast_414.Parsetree.core_type_desc -> Ast_413.Parsetree.core_type_desc =\n function\n | Ast_414.Parsetree.Ptyp_any -> Ast_413.Parsetree.Ptyp_any\n | Ast_414.Parsetree.Ptyp_var x0 -> Ast_413.Parsetree.Ptyp_var x0\n | Ast_414.Parsetree.Ptyp_arrow (x0, x1, x2) ->\n Ast_413.Parsetree.Ptyp_arrow\n (copy_arg_label x0, copy_core_type x1, copy_core_type x2)\n | Ast_414.Parsetree.Ptyp_tuple x0 ->\n Ast_413.Parsetree.Ptyp_tuple (List.map copy_core_type x0)\n | Ast_414.Parsetree.Ptyp_constr (x0, x1) ->\n Ast_413.Parsetree.Ptyp_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_414.Parsetree.Ptyp_object (x0, x1) ->\n Ast_413.Parsetree.Ptyp_object\n (List.map copy_object_field x0, copy_closed_flag x1)\n | Ast_414.Parsetree.Ptyp_class (x0, x1) ->\n Ast_413.Parsetree.Ptyp_class\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_414.Parsetree.Ptyp_alias (x0, x1) ->\n Ast_413.Parsetree.Ptyp_alias (copy_core_type x0, x1)\n | Ast_414.Parsetree.Ptyp_variant (x0, x1, x2) ->\n Ast_413.Parsetree.Ptyp_variant\n ( List.map copy_row_field x0,\n copy_closed_flag x1,\n Option.map (fun x -> List.map copy_label x) x2 )\n | Ast_414.Parsetree.Ptyp_poly (x0, x1) ->\n Ast_413.Parsetree.Ptyp_poly\n (List.map (fun x -> copy_loc (fun x -> x) x) x0, copy_core_type x1)\n | Ast_414.Parsetree.Ptyp_package x0 ->\n Ast_413.Parsetree.Ptyp_package (copy_package_type x0)\n | Ast_414.Parsetree.Ptyp_extension x0 ->\n Ast_413.Parsetree.Ptyp_extension (copy_extension x0)\n\nand copy_package_type :\n Ast_414.Parsetree.package_type -> Ast_413.Parsetree.package_type =\n fun x ->\n let x0, x1 = x in\n ( copy_loc copy_Longident_t x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_core_type x1))\n x1 )\n\nand copy_row_field : Ast_414.Parsetree.row_field -> Ast_413.Parsetree.row_field\n =\n fun {\n Ast_414.Parsetree.prf_desc;\n Ast_414.Parsetree.prf_loc;\n Ast_414.Parsetree.prf_attributes;\n } ->\n {\n Ast_413.Parsetree.prf_desc = copy_row_field_desc prf_desc;\n Ast_413.Parsetree.prf_loc = copy_location prf_loc;\n Ast_413.Parsetree.prf_attributes = copy_attributes prf_attributes;\n }\n\nand copy_row_field_desc :\n Ast_414.Parsetree.row_field_desc -> Ast_413.Parsetree.row_field_desc =\n function\n | Ast_414.Parsetree.Rtag (x0, x1, x2) ->\n Ast_413.Parsetree.Rtag\n (copy_loc copy_label x0, x1, List.map copy_core_type x2)\n | Ast_414.Parsetree.Rinherit x0 ->\n Ast_413.Parsetree.Rinherit (copy_core_type x0)\n\nand copy_object_field :\n Ast_414.Parsetree.object_field -> Ast_413.Parsetree.object_field =\n fun {\n Ast_414.Parsetree.pof_desc;\n Ast_414.Parsetree.pof_loc;\n Ast_414.Parsetree.pof_attributes;\n } ->\n {\n Ast_413.Parsetree.pof_desc = copy_object_field_desc pof_desc;\n Ast_413.Parsetree.pof_loc = copy_location pof_loc;\n Ast_413.Parsetree.pof_attributes = copy_attributes pof_attributes;\n }\n\nand copy_attributes :\n Ast_414.Parsetree.attributes -> Ast_413.Parsetree.attributes =\n fun x -> List.map copy_attribute x\n\nand copy_attribute : Ast_414.Parsetree.attribute -> Ast_413.Parsetree.attribute\n =\n fun {\n Ast_414.Parsetree.attr_name;\n Ast_414.Parsetree.attr_payload;\n Ast_414.Parsetree.attr_loc;\n } ->\n {\n Ast_413.Parsetree.attr_name = copy_loc (fun x -> x) attr_name;\n Ast_413.Parsetree.attr_payload = copy_payload attr_payload;\n Ast_413.Parsetree.attr_loc = copy_location attr_loc;\n }\n\nand copy_payload : Ast_414.Parsetree.payload -> Ast_413.Parsetree.payload =\n function\n | Ast_414.Parsetree.PStr x0 -> Ast_413.Parsetree.PStr (copy_structure x0)\n | Ast_414.Parsetree.PSig x0 -> Ast_413.Parsetree.PSig (copy_signature x0)\n | Ast_414.Parsetree.PTyp x0 -> Ast_413.Parsetree.PTyp (copy_core_type x0)\n | Ast_414.Parsetree.PPat (x0, x1) ->\n Ast_413.Parsetree.PPat (copy_pattern x0, Option.map copy_expression x1)\n\nand copy_structure : Ast_414.Parsetree.structure -> Ast_413.Parsetree.structure\n =\n fun x -> List.map copy_structure_item x\n\nand copy_structure_item :\n Ast_414.Parsetree.structure_item -> Ast_413.Parsetree.structure_item =\n fun { Ast_414.Parsetree.pstr_desc; Ast_414.Parsetree.pstr_loc } ->\n {\n Ast_413.Parsetree.pstr_desc = copy_structure_item_desc pstr_desc;\n Ast_413.Parsetree.pstr_loc = copy_location pstr_loc;\n }\n\nand copy_structure_item_desc :\n Ast_414.Parsetree.structure_item_desc ->\n Ast_413.Parsetree.structure_item_desc = function\n | Ast_414.Parsetree.Pstr_eval (x0, x1) ->\n Ast_413.Parsetree.Pstr_eval (copy_expression x0, copy_attributes x1)\n | Ast_414.Parsetree.Pstr_value (x0, x1) ->\n Ast_413.Parsetree.Pstr_value\n (copy_rec_flag x0, List.map copy_value_binding x1)\n | Ast_414.Parsetree.Pstr_primitive x0 ->\n Ast_413.Parsetree.Pstr_primitive (copy_value_description x0)\n | Ast_414.Parsetree.Pstr_type (x0, x1) ->\n Ast_413.Parsetree.Pstr_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | Ast_414.Parsetree.Pstr_typext x0 ->\n Ast_413.Parsetree.Pstr_typext (copy_type_extension x0)\n | Ast_414.Parsetree.Pstr_exception x0 ->\n Ast_413.Parsetree.Pstr_exception (copy_type_exception x0)\n | Ast_414.Parsetree.Pstr_module x0 ->\n Ast_413.Parsetree.Pstr_module (copy_module_binding x0)\n | Ast_414.Parsetree.Pstr_recmodule x0 ->\n Ast_413.Parsetree.Pstr_recmodule (List.map copy_module_binding x0)\n | Ast_414.Parsetree.Pstr_modtype x0 ->\n Ast_413.Parsetree.Pstr_modtype (copy_module_type_declaration x0)\n | Ast_414.Parsetree.Pstr_open x0 ->\n Ast_413.Parsetree.Pstr_open (copy_open_declaration x0)\n | Ast_414.Parsetree.Pstr_class x0 ->\n Ast_413.Parsetree.Pstr_class (List.map copy_class_declaration x0)\n | Ast_414.Parsetree.Pstr_class_type x0 ->\n Ast_413.Parsetree.Pstr_class_type\n (List.map copy_class_type_declaration x0)\n | Ast_414.Parsetree.Pstr_include x0 ->\n Ast_413.Parsetree.Pstr_include (copy_include_declaration x0)\n | Ast_414.Parsetree.Pstr_attribute x0 ->\n Ast_413.Parsetree.Pstr_attribute (copy_attribute x0)\n | Ast_414.Parsetree.Pstr_extension (x0, x1) ->\n Ast_413.Parsetree.Pstr_extension (copy_extension x0, copy_attributes x1)\n\nand copy_include_declaration :\n Ast_414.Parsetree.include_declaration ->\n Ast_413.Parsetree.include_declaration =\n fun x -> copy_include_infos copy_module_expr x\n\nand copy_class_declaration :\n Ast_414.Parsetree.class_declaration -> Ast_413.Parsetree.class_declaration =\n fun x -> copy_class_infos copy_class_expr x\n\nand copy_class_expr :\n Ast_414.Parsetree.class_expr -> Ast_413.Parsetree.class_expr =\n fun {\n Ast_414.Parsetree.pcl_desc;\n Ast_414.Parsetree.pcl_loc;\n Ast_414.Parsetree.pcl_attributes;\n } ->\n {\n Ast_413.Parsetree.pcl_desc = copy_class_expr_desc pcl_desc;\n Ast_413.Parsetree.pcl_loc = copy_location pcl_loc;\n Ast_413.Parsetree.pcl_attributes = copy_attributes pcl_attributes;\n }\n\nand copy_class_expr_desc :\n Ast_414.Parsetree.class_expr_desc -> Ast_413.Parsetree.class_expr_desc =\n function\n | Ast_414.Parsetree.Pcl_constr (x0, x1) ->\n Ast_413.Parsetree.Pcl_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_414.Parsetree.Pcl_structure x0 ->\n Ast_413.Parsetree.Pcl_structure (copy_class_structure x0)\n | Ast_414.Parsetree.Pcl_fun (x0, x1, x2, x3) ->\n Ast_413.Parsetree.Pcl_fun\n ( copy_arg_label x0,\n Option.map copy_expression x1,\n copy_pattern x2,\n copy_class_expr x3 )\n | Ast_414.Parsetree.Pcl_apply (x0, x1) ->\n Ast_413.Parsetree.Pcl_apply\n ( copy_class_expr x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | Ast_414.Parsetree.Pcl_let (x0, x1, x2) ->\n Ast_413.Parsetree.Pcl_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_class_expr x2)\n | Ast_414.Parsetree.Pcl_constraint (x0, x1) ->\n Ast_413.Parsetree.Pcl_constraint (copy_class_expr x0, copy_class_type x1)\n | Ast_414.Parsetree.Pcl_extension x0 ->\n Ast_413.Parsetree.Pcl_extension (copy_extension x0)\n | Ast_414.Parsetree.Pcl_open (x0, x1) ->\n Ast_413.Parsetree.Pcl_open (copy_open_description x0, copy_class_expr x1)\n\nand copy_class_structure :\n Ast_414.Parsetree.class_structure -> Ast_413.Parsetree.class_structure =\n fun { Ast_414.Parsetree.pcstr_self; Ast_414.Parsetree.pcstr_fields } ->\n {\n Ast_413.Parsetree.pcstr_self = copy_pattern pcstr_self;\n Ast_413.Parsetree.pcstr_fields = List.map copy_class_field pcstr_fields;\n }\n\nand copy_class_field :\n Ast_414.Parsetree.class_field -> Ast_413.Parsetree.class_field =\n fun {\n Ast_414.Parsetree.pcf_desc;\n Ast_414.Parsetree.pcf_loc;\n Ast_414.Parsetree.pcf_attributes;\n } ->\n {\n Ast_413.Parsetree.pcf_desc = copy_class_field_desc pcf_desc;\n Ast_413.Parsetree.pcf_loc = copy_location pcf_loc;\n Ast_413.Parsetree.pcf_attributes = copy_attributes pcf_attributes;\n }\n\nand copy_class_field_desc :\n Ast_414.Parsetree.class_field_desc -> Ast_413.Parsetree.class_field_desc =\n function\n | Ast_414.Parsetree.Pcf_inherit (x0, x1, x2) ->\n Ast_413.Parsetree.Pcf_inherit\n ( copy_override_flag x0,\n copy_class_expr x1,\n Option.map (fun x -> copy_loc (fun x -> x) x) x2 )\n | Ast_414.Parsetree.Pcf_val x0 ->\n Ast_413.Parsetree.Pcf_val\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_mutable_flag x1, copy_class_field_kind x2))\n | Ast_414.Parsetree.Pcf_method x0 ->\n Ast_413.Parsetree.Pcf_method\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_private_flag x1, copy_class_field_kind x2))\n | Ast_414.Parsetree.Pcf_constraint x0 ->\n Ast_413.Parsetree.Pcf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | Ast_414.Parsetree.Pcf_initializer x0 ->\n Ast_413.Parsetree.Pcf_initializer (copy_expression x0)\n | Ast_414.Parsetree.Pcf_attribute x0 ->\n Ast_413.Parsetree.Pcf_attribute (copy_attribute x0)\n | Ast_414.Parsetree.Pcf_extension x0 ->\n Ast_413.Parsetree.Pcf_extension (copy_extension x0)\n\nand copy_class_field_kind :\n Ast_414.Parsetree.class_field_kind -> Ast_413.Parsetree.class_field_kind =\n function\n | Ast_414.Parsetree.Cfk_virtual x0 ->\n Ast_413.Parsetree.Cfk_virtual (copy_core_type x0)\n | Ast_414.Parsetree.Cfk_concrete (x0, x1) ->\n Ast_413.Parsetree.Cfk_concrete (copy_override_flag x0, copy_expression x1)\n\nand copy_open_declaration :\n Ast_414.Parsetree.open_declaration -> Ast_413.Parsetree.open_declaration =\n fun x -> copy_open_infos copy_module_expr x\n\nand copy_module_binding :\n Ast_414.Parsetree.module_binding -> Ast_413.Parsetree.module_binding =\n fun {\n Ast_414.Parsetree.pmb_name;\n Ast_414.Parsetree.pmb_expr;\n Ast_414.Parsetree.pmb_attributes;\n Ast_414.Parsetree.pmb_loc;\n } ->\n {\n Ast_413.Parsetree.pmb_name =\n copy_loc (fun x -> Option.map (fun x -> x) x) pmb_name;\n Ast_413.Parsetree.pmb_expr = copy_module_expr pmb_expr;\n Ast_413.Parsetree.pmb_attributes = copy_attributes pmb_attributes;\n Ast_413.Parsetree.pmb_loc = copy_location pmb_loc;\n }\n\nand copy_module_expr :\n Ast_414.Parsetree.module_expr -> Ast_413.Parsetree.module_expr =\n fun {\n Ast_414.Parsetree.pmod_desc;\n Ast_414.Parsetree.pmod_loc;\n Ast_414.Parsetree.pmod_attributes;\n } ->\n {\n Ast_413.Parsetree.pmod_desc = copy_module_expr_desc pmod_desc;\n Ast_413.Parsetree.pmod_loc = copy_location pmod_loc;\n Ast_413.Parsetree.pmod_attributes = copy_attributes pmod_attributes;\n }\n\nand copy_module_expr_desc :\n Ast_414.Parsetree.module_expr_desc -> Ast_413.Parsetree.module_expr_desc =\n function\n | Ast_414.Parsetree.Pmod_ident x0 ->\n Ast_413.Parsetree.Pmod_ident (copy_loc copy_Longident_t x0)\n | Ast_414.Parsetree.Pmod_structure x0 ->\n Ast_413.Parsetree.Pmod_structure (copy_structure x0)\n | Ast_414.Parsetree.Pmod_functor (x0, x1) ->\n Ast_413.Parsetree.Pmod_functor\n (copy_functor_parameter x0, copy_module_expr x1)\n | Ast_414.Parsetree.Pmod_apply (x0, x1) ->\n Ast_413.Parsetree.Pmod_apply (copy_module_expr x0, copy_module_expr x1)\n | Ast_414.Parsetree.Pmod_constraint (x0, x1) ->\n Ast_413.Parsetree.Pmod_constraint\n (copy_module_expr x0, copy_module_type x1)\n | Ast_414.Parsetree.Pmod_unpack x0 ->\n Ast_413.Parsetree.Pmod_unpack (copy_expression x0)\n | Ast_414.Parsetree.Pmod_extension x0 ->\n Ast_413.Parsetree.Pmod_extension (copy_extension x0)\n\nand copy_functor_parameter :\n Ast_414.Parsetree.functor_parameter -> Ast_413.Parsetree.functor_parameter =\n function\n | Ast_414.Parsetree.Unit -> Ast_413.Parsetree.Unit\n | Ast_414.Parsetree.Named (x0, x1) ->\n Ast_413.Parsetree.Named\n (copy_loc (fun x -> Option.map (fun x -> x) x) x0, copy_module_type x1)\n\nand copy_module_type :\n Ast_414.Parsetree.module_type -> Ast_413.Parsetree.module_type =\n fun {\n Ast_414.Parsetree.pmty_desc;\n Ast_414.Parsetree.pmty_loc;\n Ast_414.Parsetree.pmty_attributes;\n } ->\n {\n Ast_413.Parsetree.pmty_desc = copy_module_type_desc pmty_desc;\n Ast_413.Parsetree.pmty_loc = copy_location pmty_loc;\n Ast_413.Parsetree.pmty_attributes = copy_attributes pmty_attributes;\n }\n\nand copy_module_type_desc :\n Ast_414.Parsetree.module_type_desc -> Ast_413.Parsetree.module_type_desc =\n function\n | Ast_414.Parsetree.Pmty_ident x0 ->\n Ast_413.Parsetree.Pmty_ident (copy_loc copy_Longident_t x0)\n | Ast_414.Parsetree.Pmty_signature x0 ->\n Ast_413.Parsetree.Pmty_signature (copy_signature x0)\n | Ast_414.Parsetree.Pmty_functor (x0, x1) ->\n Ast_413.Parsetree.Pmty_functor\n (copy_functor_parameter x0, copy_module_type x1)\n | Ast_414.Parsetree.Pmty_with (x0, x1) ->\n Ast_413.Parsetree.Pmty_with\n (copy_module_type x0, List.map copy_with_constraint x1)\n | Ast_414.Parsetree.Pmty_typeof x0 ->\n Ast_413.Parsetree.Pmty_typeof (copy_module_expr x0)\n | Ast_414.Parsetree.Pmty_extension x0 ->\n Ast_413.Parsetree.Pmty_extension (copy_extension x0)\n | Ast_414.Parsetree.Pmty_alias x0 ->\n Ast_413.Parsetree.Pmty_alias (copy_loc copy_Longident_t x0)\n\nand copy_with_constraint :\n Ast_414.Parsetree.with_constraint -> Ast_413.Parsetree.with_constraint =\n function\n | Ast_414.Parsetree.Pwith_type (x0, x1) ->\n Ast_413.Parsetree.Pwith_type\n (copy_loc copy_Longident_t x0, copy_type_declaration x1)\n | Ast_414.Parsetree.Pwith_module (x0, x1) ->\n Ast_413.Parsetree.Pwith_module\n (copy_loc copy_Longident_t x0, copy_loc copy_Longident_t x1)\n | Ast_414.Parsetree.Pwith_modtype (x0, x1) ->\n Ast_413.Parsetree.Pwith_modtype\n (copy_loc copy_Longident_t x0, copy_module_type x1)\n | Ast_414.Parsetree.Pwith_modtypesubst (x0, x1) ->\n Ast_413.Parsetree.Pwith_modtypesubst\n (copy_loc copy_Longident_t x0, copy_module_type x1)\n | Ast_414.Parsetree.Pwith_typesubst (x0, x1) ->\n Ast_413.Parsetree.Pwith_typesubst\n (copy_loc copy_Longident_t x0, copy_type_declaration x1)\n | Ast_414.Parsetree.Pwith_modsubst (x0, x1) ->\n Ast_413.Parsetree.Pwith_modsubst\n (copy_loc copy_Longident_t x0, copy_loc copy_Longident_t x1)\n\nand copy_signature : Ast_414.Parsetree.signature -> Ast_413.Parsetree.signature\n =\n fun x -> List.map copy_signature_item x\n\nand copy_signature_item :\n Ast_414.Parsetree.signature_item -> Ast_413.Parsetree.signature_item =\n fun { Ast_414.Parsetree.psig_desc; Ast_414.Parsetree.psig_loc } ->\n {\n Ast_413.Parsetree.psig_desc = copy_signature_item_desc psig_desc;\n Ast_413.Parsetree.psig_loc = copy_location psig_loc;\n }\n\nand copy_signature_item_desc :\n Ast_414.Parsetree.signature_item_desc ->\n Ast_413.Parsetree.signature_item_desc = function\n | Ast_414.Parsetree.Psig_value x0 ->\n Ast_413.Parsetree.Psig_value (copy_value_description x0)\n | Ast_414.Parsetree.Psig_type (x0, x1) ->\n Ast_413.Parsetree.Psig_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | Ast_414.Parsetree.Psig_typesubst x0 ->\n Ast_413.Parsetree.Psig_typesubst (List.map copy_type_declaration x0)\n | Ast_414.Parsetree.Psig_typext x0 ->\n Ast_413.Parsetree.Psig_typext (copy_type_extension x0)\n | Ast_414.Parsetree.Psig_exception x0 ->\n Ast_413.Parsetree.Psig_exception (copy_type_exception x0)\n | Ast_414.Parsetree.Psig_module x0 ->\n Ast_413.Parsetree.Psig_module (copy_module_declaration x0)\n | Ast_414.Parsetree.Psig_modsubst x0 ->\n Ast_413.Parsetree.Psig_modsubst (copy_module_substitution x0)\n | Ast_414.Parsetree.Psig_recmodule x0 ->\n Ast_413.Parsetree.Psig_recmodule (List.map copy_module_declaration x0)\n | Ast_414.Parsetree.Psig_modtype x0 ->\n Ast_413.Parsetree.Psig_modtype (copy_module_type_declaration x0)\n | Ast_414.Parsetree.Psig_modtypesubst x0 ->\n Ast_413.Parsetree.Psig_modtypesubst (copy_module_type_declaration x0)\n | Ast_414.Parsetree.Psig_open x0 ->\n Ast_413.Parsetree.Psig_open (copy_open_description x0)\n | Ast_414.Parsetree.Psig_include x0 ->\n Ast_413.Parsetree.Psig_include (copy_include_description x0)\n | Ast_414.Parsetree.Psig_class x0 ->\n Ast_413.Parsetree.Psig_class (List.map copy_class_description x0)\n | Ast_414.Parsetree.Psig_class_type x0 ->\n Ast_413.Parsetree.Psig_class_type\n (List.map copy_class_type_declaration x0)\n | Ast_414.Parsetree.Psig_attribute x0 ->\n Ast_413.Parsetree.Psig_attribute (copy_attribute x0)\n | Ast_414.Parsetree.Psig_extension (x0, x1) ->\n Ast_413.Parsetree.Psig_extension (copy_extension x0, copy_attributes x1)\n\nand copy_class_type_declaration :\n Ast_414.Parsetree.class_type_declaration ->\n Ast_413.Parsetree.class_type_declaration =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_description :\n Ast_414.Parsetree.class_description -> Ast_413.Parsetree.class_description =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_type :\n Ast_414.Parsetree.class_type -> Ast_413.Parsetree.class_type =\n fun {\n Ast_414.Parsetree.pcty_desc;\n Ast_414.Parsetree.pcty_loc;\n Ast_414.Parsetree.pcty_attributes;\n } ->\n {\n Ast_413.Parsetree.pcty_desc = copy_class_type_desc pcty_desc;\n Ast_413.Parsetree.pcty_loc = copy_location pcty_loc;\n Ast_413.Parsetree.pcty_attributes = copy_attributes pcty_attributes;\n }\n\nand copy_class_type_desc :\n Ast_414.Parsetree.class_type_desc -> Ast_413.Parsetree.class_type_desc =\n function\n | Ast_414.Parsetree.Pcty_constr (x0, x1) ->\n Ast_413.Parsetree.Pcty_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_414.Parsetree.Pcty_signature x0 ->\n Ast_413.Parsetree.Pcty_signature (copy_class_signature x0)\n | Ast_414.Parsetree.Pcty_arrow (x0, x1, x2) ->\n Ast_413.Parsetree.Pcty_arrow\n (copy_arg_label x0, copy_core_type x1, copy_class_type x2)\n | Ast_414.Parsetree.Pcty_extension x0 ->\n Ast_413.Parsetree.Pcty_extension (copy_extension x0)\n | Ast_414.Parsetree.Pcty_open (x0, x1) ->\n Ast_413.Parsetree.Pcty_open (copy_open_description x0, copy_class_type x1)\n\nand copy_class_signature :\n Ast_414.Parsetree.class_signature -> Ast_413.Parsetree.class_signature =\n fun { Ast_414.Parsetree.pcsig_self; Ast_414.Parsetree.pcsig_fields } ->\n {\n Ast_413.Parsetree.pcsig_self = copy_core_type pcsig_self;\n Ast_413.Parsetree.pcsig_fields = List.map copy_class_type_field pcsig_fields;\n }\n\nand copy_class_type_field :\n Ast_414.Parsetree.class_type_field -> Ast_413.Parsetree.class_type_field =\n fun {\n Ast_414.Parsetree.pctf_desc;\n Ast_414.Parsetree.pctf_loc;\n Ast_414.Parsetree.pctf_attributes;\n } ->\n {\n Ast_413.Parsetree.pctf_desc = copy_class_type_field_desc pctf_desc;\n Ast_413.Parsetree.pctf_loc = copy_location pctf_loc;\n Ast_413.Parsetree.pctf_attributes = copy_attributes pctf_attributes;\n }\n\nand copy_class_type_field_desc :\n Ast_414.Parsetree.class_type_field_desc ->\n Ast_413.Parsetree.class_type_field_desc = function\n | Ast_414.Parsetree.Pctf_inherit x0 ->\n Ast_413.Parsetree.Pctf_inherit (copy_class_type x0)\n | Ast_414.Parsetree.Pctf_val x0 ->\n Ast_413.Parsetree.Pctf_val\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_mutable_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | Ast_414.Parsetree.Pctf_method x0 ->\n Ast_413.Parsetree.Pctf_method\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_private_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | Ast_414.Parsetree.Pctf_constraint x0 ->\n Ast_413.Parsetree.Pctf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | Ast_414.Parsetree.Pctf_attribute x0 ->\n Ast_413.Parsetree.Pctf_attribute (copy_attribute x0)\n | Ast_414.Parsetree.Pctf_extension x0 ->\n Ast_413.Parsetree.Pctf_extension (copy_extension x0)\n\nand copy_extension : Ast_414.Parsetree.extension -> Ast_413.Parsetree.extension\n =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_class_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_414.Parsetree.class_infos ->\n 'g0 Ast_413.Parsetree.class_infos =\n fun f0\n {\n Ast_414.Parsetree.pci_virt;\n Ast_414.Parsetree.pci_params;\n Ast_414.Parsetree.pci_name;\n Ast_414.Parsetree.pci_expr;\n Ast_414.Parsetree.pci_loc;\n Ast_414.Parsetree.pci_attributes;\n } ->\n {\n Ast_413.Parsetree.pci_virt = copy_virtual_flag pci_virt;\n Ast_413.Parsetree.pci_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n ( copy_core_type x0,\n let x0, x1 = x1 in\n (copy_variance x0, copy_injectivity x1) ))\n pci_params;\n Ast_413.Parsetree.pci_name = copy_loc (fun x -> x) pci_name;\n Ast_413.Parsetree.pci_expr = f0 pci_expr;\n Ast_413.Parsetree.pci_loc = copy_location pci_loc;\n Ast_413.Parsetree.pci_attributes = copy_attributes pci_attributes;\n }\n\nand copy_virtual_flag :\n Ast_414.Asttypes.virtual_flag -> Ast_413.Asttypes.virtual_flag = function\n | Ast_414.Asttypes.Virtual -> Ast_413.Asttypes.Virtual\n | Ast_414.Asttypes.Concrete -> Ast_413.Asttypes.Concrete\n\nand copy_include_description :\n Ast_414.Parsetree.include_description ->\n Ast_413.Parsetree.include_description =\n fun x -> copy_include_infos copy_module_type x\n\nand copy_include_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_414.Parsetree.include_infos ->\n 'g0 Ast_413.Parsetree.include_infos =\n fun f0\n {\n Ast_414.Parsetree.pincl_mod;\n Ast_414.Parsetree.pincl_loc;\n Ast_414.Parsetree.pincl_attributes;\n } ->\n {\n Ast_413.Parsetree.pincl_mod = f0 pincl_mod;\n Ast_413.Parsetree.pincl_loc = copy_location pincl_loc;\n Ast_413.Parsetree.pincl_attributes = copy_attributes pincl_attributes;\n }\n\nand copy_open_description :\n Ast_414.Parsetree.open_description -> Ast_413.Parsetree.open_description =\n fun x -> copy_open_infos (fun x -> copy_loc copy_Longident_t x) x\n\nand copy_open_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_414.Parsetree.open_infos ->\n 'g0 Ast_413.Parsetree.open_infos =\n fun f0\n {\n Ast_414.Parsetree.popen_expr;\n Ast_414.Parsetree.popen_override;\n Ast_414.Parsetree.popen_loc;\n Ast_414.Parsetree.popen_attributes;\n } ->\n {\n Ast_413.Parsetree.popen_expr = f0 popen_expr;\n Ast_413.Parsetree.popen_override = copy_override_flag popen_override;\n Ast_413.Parsetree.popen_loc = copy_location popen_loc;\n Ast_413.Parsetree.popen_attributes = copy_attributes popen_attributes;\n }\n\nand copy_override_flag :\n Ast_414.Asttypes.override_flag -> Ast_413.Asttypes.override_flag = function\n | Ast_414.Asttypes.Override -> Ast_413.Asttypes.Override\n | Ast_414.Asttypes.Fresh -> Ast_413.Asttypes.Fresh\n\nand copy_module_type_declaration :\n Ast_414.Parsetree.module_type_declaration ->\n Ast_413.Parsetree.module_type_declaration =\n fun {\n Ast_414.Parsetree.pmtd_name;\n Ast_414.Parsetree.pmtd_type;\n Ast_414.Parsetree.pmtd_attributes;\n Ast_414.Parsetree.pmtd_loc;\n } ->\n {\n Ast_413.Parsetree.pmtd_name = copy_loc (fun x -> x) pmtd_name;\n Ast_413.Parsetree.pmtd_type = Option.map copy_module_type pmtd_type;\n Ast_413.Parsetree.pmtd_attributes = copy_attributes pmtd_attributes;\n Ast_413.Parsetree.pmtd_loc = copy_location pmtd_loc;\n }\n\nand copy_module_substitution :\n Ast_414.Parsetree.module_substitution ->\n Ast_413.Parsetree.module_substitution =\n fun {\n Ast_414.Parsetree.pms_name;\n Ast_414.Parsetree.pms_manifest;\n Ast_414.Parsetree.pms_attributes;\n Ast_414.Parsetree.pms_loc;\n } ->\n {\n Ast_413.Parsetree.pms_name = copy_loc (fun x -> x) pms_name;\n Ast_413.Parsetree.pms_manifest = copy_loc copy_Longident_t pms_manifest;\n Ast_413.Parsetree.pms_attributes = copy_attributes pms_attributes;\n Ast_413.Parsetree.pms_loc = copy_location pms_loc;\n }\n\nand copy_module_declaration :\n Ast_414.Parsetree.module_declaration -> Ast_413.Parsetree.module_declaration\n =\n fun {\n Ast_414.Parsetree.pmd_name;\n Ast_414.Parsetree.pmd_type;\n Ast_414.Parsetree.pmd_attributes;\n Ast_414.Parsetree.pmd_loc;\n } ->\n {\n Ast_413.Parsetree.pmd_name =\n copy_loc (fun x -> Option.map (fun x -> x) x) pmd_name;\n Ast_413.Parsetree.pmd_type = copy_module_type pmd_type;\n Ast_413.Parsetree.pmd_attributes = copy_attributes pmd_attributes;\n Ast_413.Parsetree.pmd_loc = copy_location pmd_loc;\n }\n\nand copy_type_exception :\n Ast_414.Parsetree.type_exception -> Ast_413.Parsetree.type_exception =\n fun {\n Ast_414.Parsetree.ptyexn_constructor;\n Ast_414.Parsetree.ptyexn_loc;\n Ast_414.Parsetree.ptyexn_attributes;\n } ->\n {\n Ast_413.Parsetree.ptyexn_constructor =\n copy_extension_constructor ptyexn_constructor;\n Ast_413.Parsetree.ptyexn_loc = copy_location ptyexn_loc;\n Ast_413.Parsetree.ptyexn_attributes = copy_attributes ptyexn_attributes;\n }\n\nand copy_type_extension :\n Ast_414.Parsetree.type_extension -> Ast_413.Parsetree.type_extension =\n fun {\n Ast_414.Parsetree.ptyext_path;\n Ast_414.Parsetree.ptyext_params;\n Ast_414.Parsetree.ptyext_constructors;\n Ast_414.Parsetree.ptyext_private;\n Ast_414.Parsetree.ptyext_loc;\n Ast_414.Parsetree.ptyext_attributes;\n } ->\n {\n Ast_413.Parsetree.ptyext_path = copy_loc copy_Longident_t ptyext_path;\n Ast_413.Parsetree.ptyext_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n ( copy_core_type x0,\n let x0, x1 = x1 in\n (copy_variance x0, copy_injectivity x1) ))\n ptyext_params;\n Ast_413.Parsetree.ptyext_constructors =\n List.map copy_extension_constructor ptyext_constructors;\n Ast_413.Parsetree.ptyext_private = copy_private_flag ptyext_private;\n Ast_413.Parsetree.ptyext_loc = copy_location ptyext_loc;\n Ast_413.Parsetree.ptyext_attributes = copy_attributes ptyext_attributes;\n }\n\nand copy_extension_constructor :\n Ast_414.Parsetree.extension_constructor ->\n Ast_413.Parsetree.extension_constructor =\n fun {\n Ast_414.Parsetree.pext_name;\n Ast_414.Parsetree.pext_kind;\n Ast_414.Parsetree.pext_loc;\n Ast_414.Parsetree.pext_attributes;\n } ->\n {\n Ast_413.Parsetree.pext_name = copy_loc (fun x -> x) pext_name;\n Ast_413.Parsetree.pext_kind = copy_extension_constructor_kind pext_kind;\n Ast_413.Parsetree.pext_loc = copy_location pext_loc;\n Ast_413.Parsetree.pext_attributes = copy_attributes pext_attributes;\n }\n\nand copy_extension_constructor_kind :\n Ast_414.Parsetree.extension_constructor_kind ->\n Ast_413.Parsetree.extension_constructor_kind = function\n | Ast_414.Parsetree.Pext_decl (x0, x1, x2) -> (\n match x0 with\n | [] ->\n Ast_413.Parsetree.Pext_decl\n (copy_constructor_arguments x1, Option.map copy_core_type x2)\n | hd :: _ ->\n migration_error hd.loc \"type parameters in extension constructors\")\n | Ast_414.Parsetree.Pext_rebind x0 ->\n Ast_413.Parsetree.Pext_rebind (copy_loc copy_Longident_t x0)\n\nand copy_type_declaration :\n Ast_414.Parsetree.type_declaration -> Ast_413.Parsetree.type_declaration =\n fun {\n Ast_414.Parsetree.ptype_name;\n Ast_414.Parsetree.ptype_params;\n Ast_414.Parsetree.ptype_cstrs;\n Ast_414.Parsetree.ptype_kind;\n Ast_414.Parsetree.ptype_private;\n Ast_414.Parsetree.ptype_manifest;\n Ast_414.Parsetree.ptype_attributes;\n Ast_414.Parsetree.ptype_loc;\n } ->\n {\n Ast_413.Parsetree.ptype_name = copy_loc (fun x -> x) ptype_name;\n Ast_413.Parsetree.ptype_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n ( copy_core_type x0,\n let x0, x1 = x1 in\n (copy_variance x0, copy_injectivity x1) ))\n ptype_params;\n Ast_413.Parsetree.ptype_cstrs =\n List.map\n (fun x ->\n let x0, x1, x2 = x in\n (copy_core_type x0, copy_core_type x1, copy_location x2))\n ptype_cstrs;\n Ast_413.Parsetree.ptype_kind = copy_type_kind ptype_kind;\n Ast_413.Parsetree.ptype_private = copy_private_flag ptype_private;\n Ast_413.Parsetree.ptype_manifest = Option.map copy_core_type ptype_manifest;\n Ast_413.Parsetree.ptype_attributes = copy_attributes ptype_attributes;\n Ast_413.Parsetree.ptype_loc = copy_location ptype_loc;\n }\n\nand copy_private_flag :\n Ast_414.Asttypes.private_flag -> Ast_413.Asttypes.private_flag = function\n | Ast_414.Asttypes.Private -> Ast_413.Asttypes.Private\n | Ast_414.Asttypes.Public -> Ast_413.Asttypes.Public\n\nand copy_type_kind : Ast_414.Parsetree.type_kind -> Ast_413.Parsetree.type_kind\n = function\n | Ast_414.Parsetree.Ptype_abstract -> Ast_413.Parsetree.Ptype_abstract\n | Ast_414.Parsetree.Ptype_variant x0 ->\n Ast_413.Parsetree.Ptype_variant (List.map copy_constructor_declaration x0)\n | Ast_414.Parsetree.Ptype_record x0 ->\n Ast_413.Parsetree.Ptype_record (List.map copy_label_declaration x0)\n | Ast_414.Parsetree.Ptype_open -> Ast_413.Parsetree.Ptype_open\n\nand copy_constructor_declaration :\n Ast_414.Parsetree.constructor_declaration ->\n Ast_413.Parsetree.constructor_declaration =\n fun {\n Ast_414.Parsetree.pcd_name;\n Ast_414.Parsetree.pcd_vars;\n Ast_414.Parsetree.pcd_args;\n Ast_414.Parsetree.pcd_res;\n Ast_414.Parsetree.pcd_loc;\n Ast_414.Parsetree.pcd_attributes;\n } ->\n match pcd_vars with\n | [] ->\n {\n Ast_413.Parsetree.pcd_name = copy_loc (fun x -> x) pcd_name;\n Ast_413.Parsetree.pcd_args = copy_constructor_arguments pcd_args;\n Ast_413.Parsetree.pcd_res = Option.map copy_core_type pcd_res;\n Ast_413.Parsetree.pcd_loc = copy_location pcd_loc;\n Ast_413.Parsetree.pcd_attributes = copy_attributes pcd_attributes;\n }\n | hd :: _ -> migration_error hd.loc \"pcd_vars in constructor declarations\"\n\nand copy_constructor_arguments :\n Ast_414.Parsetree.constructor_arguments ->\n Ast_413.Parsetree.constructor_arguments = function\n | Ast_414.Parsetree.Pcstr_tuple x0 ->\n Ast_413.Parsetree.Pcstr_tuple (List.map copy_core_type x0)\n | Ast_414.Parsetree.Pcstr_record x0 ->\n Ast_413.Parsetree.Pcstr_record (List.map copy_label_declaration x0)\n\nand copy_label_declaration :\n Ast_414.Parsetree.label_declaration -> Ast_413.Parsetree.label_declaration =\n fun {\n Ast_414.Parsetree.pld_name;\n Ast_414.Parsetree.pld_mutable;\n Ast_414.Parsetree.pld_type;\n Ast_414.Parsetree.pld_loc;\n Ast_414.Parsetree.pld_attributes;\n } ->\n {\n Ast_413.Parsetree.pld_name = copy_loc (fun x -> x) pld_name;\n Ast_413.Parsetree.pld_mutable = copy_mutable_flag pld_mutable;\n Ast_413.Parsetree.pld_type = copy_core_type pld_type;\n Ast_413.Parsetree.pld_loc = copy_location pld_loc;\n Ast_413.Parsetree.pld_attributes = copy_attributes pld_attributes;\n }\n\nand copy_mutable_flag :\n Ast_414.Asttypes.mutable_flag -> Ast_413.Asttypes.mutable_flag = function\n | Ast_414.Asttypes.Immutable -> Ast_413.Asttypes.Immutable\n | Ast_414.Asttypes.Mutable -> Ast_413.Asttypes.Mutable\n\nand copy_injectivity :\n Ast_414.Asttypes.injectivity -> Ast_413.Asttypes.injectivity = function\n | Ast_414.Asttypes.Injective -> Ast_413.Asttypes.Injective\n | Ast_414.Asttypes.NoInjectivity -> Ast_413.Asttypes.NoInjectivity\n\nand copy_variance : Ast_414.Asttypes.variance -> Ast_413.Asttypes.variance =\n function\n | Ast_414.Asttypes.Covariant -> Ast_413.Asttypes.Covariant\n | Ast_414.Asttypes.Contravariant -> Ast_413.Asttypes.Contravariant\n | Ast_414.Asttypes.NoVariance -> Ast_413.Asttypes.NoVariance\n\nand copy_value_description :\n Ast_414.Parsetree.value_description -> Ast_413.Parsetree.value_description =\n fun {\n Ast_414.Parsetree.pval_name;\n Ast_414.Parsetree.pval_type;\n Ast_414.Parsetree.pval_prim;\n Ast_414.Parsetree.pval_attributes;\n Ast_414.Parsetree.pval_loc;\n } ->\n {\n Ast_413.Parsetree.pval_name = copy_loc (fun x -> x) pval_name;\n Ast_413.Parsetree.pval_type = copy_core_type pval_type;\n Ast_413.Parsetree.pval_prim = List.map (fun x -> x) pval_prim;\n Ast_413.Parsetree.pval_attributes = copy_attributes pval_attributes;\n Ast_413.Parsetree.pval_loc = copy_location pval_loc;\n }\n\nand copy_object_field_desc :\n Ast_414.Parsetree.object_field_desc -> Ast_413.Parsetree.object_field_desc =\n function\n | Ast_414.Parsetree.Otag (x0, x1) ->\n Ast_413.Parsetree.Otag (copy_loc copy_label x0, copy_core_type x1)\n | Ast_414.Parsetree.Oinherit x0 ->\n Ast_413.Parsetree.Oinherit (copy_core_type x0)\n\nand copy_arg_label : Ast_414.Asttypes.arg_label -> Ast_413.Asttypes.arg_label =\n function\n | Ast_414.Asttypes.Nolabel -> Ast_413.Asttypes.Nolabel\n | Ast_414.Asttypes.Labelled x0 -> Ast_413.Asttypes.Labelled x0\n | Ast_414.Asttypes.Optional x0 -> Ast_413.Asttypes.Optional x0\n\nand copy_closed_flag :\n Ast_414.Asttypes.closed_flag -> Ast_413.Asttypes.closed_flag = function\n | Ast_414.Asttypes.Closed -> Ast_413.Asttypes.Closed\n | Ast_414.Asttypes.Open -> Ast_413.Asttypes.Open\n\nand copy_label : Ast_414.Asttypes.label -> Ast_413.Asttypes.label = fun x -> x\n\nand copy_rec_flag : Ast_414.Asttypes.rec_flag -> Ast_413.Asttypes.rec_flag =\n function\n | Ast_414.Asttypes.Nonrecursive -> Ast_413.Asttypes.Nonrecursive\n | Ast_414.Asttypes.Recursive -> Ast_413.Asttypes.Recursive\n\nand copy_constant : Ast_414.Parsetree.constant -> Ast_413.Parsetree.constant =\n function\n | Ast_414.Parsetree.Pconst_integer (x0, x1) ->\n Ast_413.Parsetree.Pconst_integer (x0, Option.map (fun x -> x) x1)\n | Ast_414.Parsetree.Pconst_char x0 -> Ast_413.Parsetree.Pconst_char x0\n | Ast_414.Parsetree.Pconst_string (x0, x1, x2) ->\n Ast_413.Parsetree.Pconst_string\n (x0, copy_location x1, Option.map (fun x -> x) x2)\n | Ast_414.Parsetree.Pconst_float (x0, x1) ->\n Ast_413.Parsetree.Pconst_float (x0, Option.map (fun x -> x) x1)\n\nand copy_Longident_t : Longident.t -> Longident.t = fun x -> x\n\nand copy_loc :\n 'f0 'g0.\n ('f0 -> 'g0) -> 'f0 Ast_414.Asttypes.loc -> 'g0 Ast_413.Asttypes.loc =\n fun f0 { Ast_414.Asttypes.txt; Ast_414.Asttypes.loc } ->\n { Ast_413.Asttypes.txt = f0 txt; Ast_413.Asttypes.loc = copy_location loc }\n\nand copy_location : Location.t -> Location.t = fun x -> x\n","open Stdlib0\nmodule From = Ast_413\nmodule To = Ast_414\n\nlet rec copy_toplevel_phrase :\n Ast_413.Parsetree.toplevel_phrase -> Ast_414.Parsetree.toplevel_phrase =\n function\n | Ast_413.Parsetree.Ptop_def x0 ->\n Ast_414.Parsetree.Ptop_def (copy_structure x0)\n | Ast_413.Parsetree.Ptop_dir x0 ->\n Ast_414.Parsetree.Ptop_dir (copy_toplevel_directive x0)\n\nand copy_toplevel_directive :\n Ast_413.Parsetree.toplevel_directive -> Ast_414.Parsetree.toplevel_directive\n =\n fun {\n Ast_413.Parsetree.pdir_name;\n Ast_413.Parsetree.pdir_arg;\n Ast_413.Parsetree.pdir_loc;\n } ->\n {\n Ast_414.Parsetree.pdir_name = copy_loc (fun x -> x) pdir_name;\n Ast_414.Parsetree.pdir_arg = Option.map copy_directive_argument pdir_arg;\n Ast_414.Parsetree.pdir_loc = copy_location pdir_loc;\n }\n\nand copy_directive_argument :\n Ast_413.Parsetree.directive_argument -> Ast_414.Parsetree.directive_argument\n =\n fun { Ast_413.Parsetree.pdira_desc; Ast_413.Parsetree.pdira_loc } ->\n {\n Ast_414.Parsetree.pdira_desc = copy_directive_argument_desc pdira_desc;\n Ast_414.Parsetree.pdira_loc = copy_location pdira_loc;\n }\n\nand copy_directive_argument_desc :\n Ast_413.Parsetree.directive_argument_desc ->\n Ast_414.Parsetree.directive_argument_desc = function\n | Ast_413.Parsetree.Pdir_string x0 -> Ast_414.Parsetree.Pdir_string x0\n | Ast_413.Parsetree.Pdir_int (x0, x1) ->\n Ast_414.Parsetree.Pdir_int (x0, Option.map (fun x -> x) x1)\n | Ast_413.Parsetree.Pdir_ident x0 ->\n Ast_414.Parsetree.Pdir_ident (copy_Longident_t x0)\n | Ast_413.Parsetree.Pdir_bool x0 -> Ast_414.Parsetree.Pdir_bool x0\n\nand copy_expression :\n Ast_413.Parsetree.expression -> Ast_414.Parsetree.expression =\n fun {\n Ast_413.Parsetree.pexp_desc;\n Ast_413.Parsetree.pexp_loc;\n Ast_413.Parsetree.pexp_loc_stack;\n Ast_413.Parsetree.pexp_attributes;\n } ->\n {\n Ast_414.Parsetree.pexp_desc = copy_expression_desc pexp_desc;\n Ast_414.Parsetree.pexp_loc = copy_location pexp_loc;\n Ast_414.Parsetree.pexp_loc_stack = copy_location_stack pexp_loc_stack;\n Ast_414.Parsetree.pexp_attributes = copy_attributes pexp_attributes;\n }\n\nand copy_expression_desc :\n Ast_413.Parsetree.expression_desc -> Ast_414.Parsetree.expression_desc =\n function\n | Ast_413.Parsetree.Pexp_ident x0 ->\n Ast_414.Parsetree.Pexp_ident (copy_loc copy_Longident_t x0)\n | Ast_413.Parsetree.Pexp_constant x0 ->\n Ast_414.Parsetree.Pexp_constant (copy_constant x0)\n | Ast_413.Parsetree.Pexp_let (x0, x1, x2) ->\n Ast_414.Parsetree.Pexp_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_expression x2)\n | Ast_413.Parsetree.Pexp_function x0 ->\n Ast_414.Parsetree.Pexp_function (List.map copy_case x0)\n | Ast_413.Parsetree.Pexp_fun (x0, x1, x2, x3) ->\n Ast_414.Parsetree.Pexp_fun\n ( copy_arg_label x0,\n Option.map copy_expression x1,\n copy_pattern x2,\n copy_expression x3 )\n | Ast_413.Parsetree.Pexp_apply (x0, x1) ->\n Ast_414.Parsetree.Pexp_apply\n ( copy_expression x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | Ast_413.Parsetree.Pexp_match (x0, x1) ->\n Ast_414.Parsetree.Pexp_match (copy_expression x0, List.map copy_case x1)\n | Ast_413.Parsetree.Pexp_try (x0, x1) ->\n Ast_414.Parsetree.Pexp_try (copy_expression x0, List.map copy_case x1)\n | Ast_413.Parsetree.Pexp_tuple x0 ->\n Ast_414.Parsetree.Pexp_tuple (List.map copy_expression x0)\n | Ast_413.Parsetree.Pexp_construct (x0, x1) ->\n Ast_414.Parsetree.Pexp_construct\n (copy_loc copy_Longident_t x0, Option.map copy_expression x1)\n | Ast_413.Parsetree.Pexp_variant (x0, x1) ->\n Ast_414.Parsetree.Pexp_variant\n (copy_label x0, Option.map copy_expression x1)\n | Ast_413.Parsetree.Pexp_record (x0, x1) ->\n Ast_414.Parsetree.Pexp_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_expression x1))\n x0,\n Option.map copy_expression x1 )\n | Ast_413.Parsetree.Pexp_field (x0, x1) ->\n Ast_414.Parsetree.Pexp_field\n (copy_expression x0, copy_loc copy_Longident_t x1)\n | Ast_413.Parsetree.Pexp_setfield (x0, x1, x2) ->\n Ast_414.Parsetree.Pexp_setfield\n (copy_expression x0, copy_loc copy_Longident_t x1, copy_expression x2)\n | Ast_413.Parsetree.Pexp_array x0 ->\n Ast_414.Parsetree.Pexp_array (List.map copy_expression x0)\n | Ast_413.Parsetree.Pexp_ifthenelse (x0, x1, x2) ->\n Ast_414.Parsetree.Pexp_ifthenelse\n (copy_expression x0, copy_expression x1, Option.map copy_expression x2)\n | Ast_413.Parsetree.Pexp_sequence (x0, x1) ->\n Ast_414.Parsetree.Pexp_sequence (copy_expression x0, copy_expression x1)\n | Ast_413.Parsetree.Pexp_while (x0, x1) ->\n Ast_414.Parsetree.Pexp_while (copy_expression x0, copy_expression x1)\n | Ast_413.Parsetree.Pexp_for (x0, x1, x2, x3, x4) ->\n Ast_414.Parsetree.Pexp_for\n ( copy_pattern x0,\n copy_expression x1,\n copy_expression x2,\n copy_direction_flag x3,\n copy_expression x4 )\n | Ast_413.Parsetree.Pexp_constraint (x0, x1) ->\n Ast_414.Parsetree.Pexp_constraint (copy_expression x0, copy_core_type x1)\n | Ast_413.Parsetree.Pexp_coerce (x0, x1, x2) ->\n Ast_414.Parsetree.Pexp_coerce\n (copy_expression x0, Option.map copy_core_type x1, copy_core_type x2)\n | Ast_413.Parsetree.Pexp_send (x0, x1) ->\n Ast_414.Parsetree.Pexp_send (copy_expression x0, copy_loc copy_label x1)\n | Ast_413.Parsetree.Pexp_new x0 ->\n Ast_414.Parsetree.Pexp_new (copy_loc copy_Longident_t x0)\n | Ast_413.Parsetree.Pexp_setinstvar (x0, x1) ->\n Ast_414.Parsetree.Pexp_setinstvar\n (copy_loc copy_label x0, copy_expression x1)\n | Ast_413.Parsetree.Pexp_override x0 ->\n Ast_414.Parsetree.Pexp_override\n (List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_label x0, copy_expression x1))\n x0)\n | Ast_413.Parsetree.Pexp_letmodule (x0, x1, x2) ->\n Ast_414.Parsetree.Pexp_letmodule\n ( copy_loc (fun x -> Option.map (fun x -> x) x) x0,\n copy_module_expr x1,\n copy_expression x2 )\n | Ast_413.Parsetree.Pexp_letexception (x0, x1) ->\n Ast_414.Parsetree.Pexp_letexception\n (copy_extension_constructor x0, copy_expression x1)\n | Ast_413.Parsetree.Pexp_assert x0 ->\n Ast_414.Parsetree.Pexp_assert (copy_expression x0)\n | Ast_413.Parsetree.Pexp_lazy x0 ->\n Ast_414.Parsetree.Pexp_lazy (copy_expression x0)\n | Ast_413.Parsetree.Pexp_poly (x0, x1) ->\n Ast_414.Parsetree.Pexp_poly\n (copy_expression x0, Option.map copy_core_type x1)\n | Ast_413.Parsetree.Pexp_object x0 ->\n Ast_414.Parsetree.Pexp_object (copy_class_structure x0)\n | Ast_413.Parsetree.Pexp_newtype (x0, x1) ->\n Ast_414.Parsetree.Pexp_newtype\n (copy_loc (fun x -> x) x0, copy_expression x1)\n | Ast_413.Parsetree.Pexp_pack x0 ->\n Ast_414.Parsetree.Pexp_pack (copy_module_expr x0)\n | Ast_413.Parsetree.Pexp_open (x0, x1) ->\n Ast_414.Parsetree.Pexp_open (copy_open_declaration x0, copy_expression x1)\n | Ast_413.Parsetree.Pexp_letop x0 ->\n Ast_414.Parsetree.Pexp_letop (copy_letop x0)\n | Ast_413.Parsetree.Pexp_extension x0 ->\n Ast_414.Parsetree.Pexp_extension (copy_extension x0)\n | Ast_413.Parsetree.Pexp_unreachable -> Ast_414.Parsetree.Pexp_unreachable\n\nand copy_letop : Ast_413.Parsetree.letop -> Ast_414.Parsetree.letop =\n fun { Ast_413.Parsetree.let_; Ast_413.Parsetree.ands; Ast_413.Parsetree.body } ->\n {\n Ast_414.Parsetree.let_ = copy_binding_op let_;\n Ast_414.Parsetree.ands = List.map copy_binding_op ands;\n Ast_414.Parsetree.body = copy_expression body;\n }\n\nand copy_binding_op :\n Ast_413.Parsetree.binding_op -> Ast_414.Parsetree.binding_op =\n fun {\n Ast_413.Parsetree.pbop_op;\n Ast_413.Parsetree.pbop_pat;\n Ast_413.Parsetree.pbop_exp;\n Ast_413.Parsetree.pbop_loc;\n } ->\n {\n Ast_414.Parsetree.pbop_op = copy_loc (fun x -> x) pbop_op;\n Ast_414.Parsetree.pbop_pat = copy_pattern pbop_pat;\n Ast_414.Parsetree.pbop_exp = copy_expression pbop_exp;\n Ast_414.Parsetree.pbop_loc = copy_location pbop_loc;\n }\n\nand copy_direction_flag :\n Ast_413.Asttypes.direction_flag -> Ast_414.Asttypes.direction_flag =\n function\n | Ast_413.Asttypes.Upto -> Ast_414.Asttypes.Upto\n | Ast_413.Asttypes.Downto -> Ast_414.Asttypes.Downto\n\nand copy_case : Ast_413.Parsetree.case -> Ast_414.Parsetree.case =\n fun {\n Ast_413.Parsetree.pc_lhs;\n Ast_413.Parsetree.pc_guard;\n Ast_413.Parsetree.pc_rhs;\n } ->\n {\n Ast_414.Parsetree.pc_lhs = copy_pattern pc_lhs;\n Ast_414.Parsetree.pc_guard = Option.map copy_expression pc_guard;\n Ast_414.Parsetree.pc_rhs = copy_expression pc_rhs;\n }\n\nand copy_value_binding :\n Ast_413.Parsetree.value_binding -> Ast_414.Parsetree.value_binding =\n fun {\n Ast_413.Parsetree.pvb_pat;\n Ast_413.Parsetree.pvb_expr;\n Ast_413.Parsetree.pvb_attributes;\n Ast_413.Parsetree.pvb_loc;\n } ->\n {\n Ast_414.Parsetree.pvb_pat = copy_pattern pvb_pat;\n Ast_414.Parsetree.pvb_expr = copy_expression pvb_expr;\n Ast_414.Parsetree.pvb_attributes = copy_attributes pvb_attributes;\n Ast_414.Parsetree.pvb_loc = copy_location pvb_loc;\n }\n\nand copy_pattern : Ast_413.Parsetree.pattern -> Ast_414.Parsetree.pattern =\n fun {\n Ast_413.Parsetree.ppat_desc;\n Ast_413.Parsetree.ppat_loc;\n Ast_413.Parsetree.ppat_loc_stack;\n Ast_413.Parsetree.ppat_attributes;\n } ->\n {\n Ast_414.Parsetree.ppat_desc = copy_pattern_desc ppat_desc;\n Ast_414.Parsetree.ppat_loc = copy_location ppat_loc;\n Ast_414.Parsetree.ppat_loc_stack = copy_location_stack ppat_loc_stack;\n Ast_414.Parsetree.ppat_attributes = copy_attributes ppat_attributes;\n }\n\nand copy_pattern_desc :\n Ast_413.Parsetree.pattern_desc -> Ast_414.Parsetree.pattern_desc = function\n | Ast_413.Parsetree.Ppat_any -> Ast_414.Parsetree.Ppat_any\n | Ast_413.Parsetree.Ppat_var x0 ->\n Ast_414.Parsetree.Ppat_var (copy_loc (fun x -> x) x0)\n | Ast_413.Parsetree.Ppat_alias (x0, x1) ->\n Ast_414.Parsetree.Ppat_alias (copy_pattern x0, copy_loc (fun x -> x) x1)\n | Ast_413.Parsetree.Ppat_constant x0 ->\n Ast_414.Parsetree.Ppat_constant (copy_constant x0)\n | Ast_413.Parsetree.Ppat_interval (x0, x1) ->\n Ast_414.Parsetree.Ppat_interval (copy_constant x0, copy_constant x1)\n | Ast_413.Parsetree.Ppat_tuple x0 ->\n Ast_414.Parsetree.Ppat_tuple (List.map copy_pattern x0)\n | Ast_413.Parsetree.Ppat_construct (x0, x1) ->\n Ast_414.Parsetree.Ppat_construct\n ( copy_loc copy_Longident_t x0,\n Option.map\n (fun x ->\n let x0, x1 = x in\n (List.map (fun x -> copy_loc (fun x -> x) x) x0, copy_pattern x1))\n x1 )\n | Ast_413.Parsetree.Ppat_variant (x0, x1) ->\n Ast_414.Parsetree.Ppat_variant (copy_label x0, Option.map copy_pattern x1)\n | Ast_413.Parsetree.Ppat_record (x0, x1) ->\n Ast_414.Parsetree.Ppat_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_pattern x1))\n x0,\n copy_closed_flag x1 )\n | Ast_413.Parsetree.Ppat_array x0 ->\n Ast_414.Parsetree.Ppat_array (List.map copy_pattern x0)\n | Ast_413.Parsetree.Ppat_or (x0, x1) ->\n Ast_414.Parsetree.Ppat_or (copy_pattern x0, copy_pattern x1)\n | Ast_413.Parsetree.Ppat_constraint (x0, x1) ->\n Ast_414.Parsetree.Ppat_constraint (copy_pattern x0, copy_core_type x1)\n | Ast_413.Parsetree.Ppat_type x0 ->\n Ast_414.Parsetree.Ppat_type (copy_loc copy_Longident_t x0)\n | Ast_413.Parsetree.Ppat_lazy x0 ->\n Ast_414.Parsetree.Ppat_lazy (copy_pattern x0)\n | Ast_413.Parsetree.Ppat_unpack x0 ->\n Ast_414.Parsetree.Ppat_unpack\n (copy_loc (fun x -> Option.map (fun x -> x) x) x0)\n | Ast_413.Parsetree.Ppat_exception x0 ->\n Ast_414.Parsetree.Ppat_exception (copy_pattern x0)\n | Ast_413.Parsetree.Ppat_extension x0 ->\n Ast_414.Parsetree.Ppat_extension (copy_extension x0)\n | Ast_413.Parsetree.Ppat_open (x0, x1) ->\n Ast_414.Parsetree.Ppat_open (copy_loc copy_Longident_t x0, copy_pattern x1)\n\nand copy_core_type : Ast_413.Parsetree.core_type -> Ast_414.Parsetree.core_type\n =\n fun {\n Ast_413.Parsetree.ptyp_desc;\n Ast_413.Parsetree.ptyp_loc;\n Ast_413.Parsetree.ptyp_loc_stack;\n Ast_413.Parsetree.ptyp_attributes;\n } ->\n {\n Ast_414.Parsetree.ptyp_desc = copy_core_type_desc ptyp_desc;\n Ast_414.Parsetree.ptyp_loc = copy_location ptyp_loc;\n Ast_414.Parsetree.ptyp_loc_stack = copy_location_stack ptyp_loc_stack;\n Ast_414.Parsetree.ptyp_attributes = copy_attributes ptyp_attributes;\n }\n\nand copy_location_stack :\n Ast_413.Parsetree.location_stack -> Ast_414.Parsetree.location_stack =\n fun x -> x\n\nand copy_core_type_desc :\n Ast_413.Parsetree.core_type_desc -> Ast_414.Parsetree.core_type_desc =\n function\n | Ast_413.Parsetree.Ptyp_any -> Ast_414.Parsetree.Ptyp_any\n | Ast_413.Parsetree.Ptyp_var x0 -> Ast_414.Parsetree.Ptyp_var x0\n | Ast_413.Parsetree.Ptyp_arrow (x0, x1, x2) ->\n Ast_414.Parsetree.Ptyp_arrow\n (copy_arg_label x0, copy_core_type x1, copy_core_type x2)\n | Ast_413.Parsetree.Ptyp_tuple x0 ->\n Ast_414.Parsetree.Ptyp_tuple (List.map copy_core_type x0)\n | Ast_413.Parsetree.Ptyp_constr (x0, x1) ->\n Ast_414.Parsetree.Ptyp_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_413.Parsetree.Ptyp_object (x0, x1) ->\n Ast_414.Parsetree.Ptyp_object\n (List.map copy_object_field x0, copy_closed_flag x1)\n | Ast_413.Parsetree.Ptyp_class (x0, x1) ->\n Ast_414.Parsetree.Ptyp_class\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_413.Parsetree.Ptyp_alias (x0, x1) ->\n Ast_414.Parsetree.Ptyp_alias (copy_core_type x0, x1)\n | Ast_413.Parsetree.Ptyp_variant (x0, x1, x2) ->\n Ast_414.Parsetree.Ptyp_variant\n ( List.map copy_row_field x0,\n copy_closed_flag x1,\n Option.map (fun x -> List.map copy_label x) x2 )\n | Ast_413.Parsetree.Ptyp_poly (x0, x1) ->\n Ast_414.Parsetree.Ptyp_poly\n (List.map (fun x -> copy_loc (fun x -> x) x) x0, copy_core_type x1)\n | Ast_413.Parsetree.Ptyp_package x0 ->\n Ast_414.Parsetree.Ptyp_package (copy_package_type x0)\n | Ast_413.Parsetree.Ptyp_extension x0 ->\n Ast_414.Parsetree.Ptyp_extension (copy_extension x0)\n\nand copy_package_type :\n Ast_413.Parsetree.package_type -> Ast_414.Parsetree.package_type =\n fun x ->\n let x0, x1 = x in\n ( copy_loc copy_Longident_t x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_core_type x1))\n x1 )\n\nand copy_row_field : Ast_413.Parsetree.row_field -> Ast_414.Parsetree.row_field\n =\n fun {\n Ast_413.Parsetree.prf_desc;\n Ast_413.Parsetree.prf_loc;\n Ast_413.Parsetree.prf_attributes;\n } ->\n {\n Ast_414.Parsetree.prf_desc = copy_row_field_desc prf_desc;\n Ast_414.Parsetree.prf_loc = copy_location prf_loc;\n Ast_414.Parsetree.prf_attributes = copy_attributes prf_attributes;\n }\n\nand copy_row_field_desc :\n Ast_413.Parsetree.row_field_desc -> Ast_414.Parsetree.row_field_desc =\n function\n | Ast_413.Parsetree.Rtag (x0, x1, x2) ->\n Ast_414.Parsetree.Rtag\n (copy_loc copy_label x0, x1, List.map copy_core_type x2)\n | Ast_413.Parsetree.Rinherit x0 ->\n Ast_414.Parsetree.Rinherit (copy_core_type x0)\n\nand copy_object_field :\n Ast_413.Parsetree.object_field -> Ast_414.Parsetree.object_field =\n fun {\n Ast_413.Parsetree.pof_desc;\n Ast_413.Parsetree.pof_loc;\n Ast_413.Parsetree.pof_attributes;\n } ->\n {\n Ast_414.Parsetree.pof_desc = copy_object_field_desc pof_desc;\n Ast_414.Parsetree.pof_loc = copy_location pof_loc;\n Ast_414.Parsetree.pof_attributes = copy_attributes pof_attributes;\n }\n\nand copy_attributes :\n Ast_413.Parsetree.attributes -> Ast_414.Parsetree.attributes =\n fun x -> List.map copy_attribute x\n\nand copy_attribute : Ast_413.Parsetree.attribute -> Ast_414.Parsetree.attribute\n =\n fun {\n Ast_413.Parsetree.attr_name;\n Ast_413.Parsetree.attr_payload;\n Ast_413.Parsetree.attr_loc;\n } ->\n {\n Ast_414.Parsetree.attr_name = copy_loc (fun x -> x) attr_name;\n Ast_414.Parsetree.attr_payload = copy_payload attr_payload;\n Ast_414.Parsetree.attr_loc = copy_location attr_loc;\n }\n\nand copy_payload : Ast_413.Parsetree.payload -> Ast_414.Parsetree.payload =\n function\n | Ast_413.Parsetree.PStr x0 -> Ast_414.Parsetree.PStr (copy_structure x0)\n | Ast_413.Parsetree.PSig x0 -> Ast_414.Parsetree.PSig (copy_signature x0)\n | Ast_413.Parsetree.PTyp x0 -> Ast_414.Parsetree.PTyp (copy_core_type x0)\n | Ast_413.Parsetree.PPat (x0, x1) ->\n Ast_414.Parsetree.PPat (copy_pattern x0, Option.map copy_expression x1)\n\nand copy_structure : Ast_413.Parsetree.structure -> Ast_414.Parsetree.structure\n =\n fun x -> List.map copy_structure_item x\n\nand copy_structure_item :\n Ast_413.Parsetree.structure_item -> Ast_414.Parsetree.structure_item =\n fun { Ast_413.Parsetree.pstr_desc; Ast_413.Parsetree.pstr_loc } ->\n {\n Ast_414.Parsetree.pstr_desc = copy_structure_item_desc pstr_desc;\n Ast_414.Parsetree.pstr_loc = copy_location pstr_loc;\n }\n\nand copy_structure_item_desc :\n Ast_413.Parsetree.structure_item_desc ->\n Ast_414.Parsetree.structure_item_desc = function\n | Ast_413.Parsetree.Pstr_eval (x0, x1) ->\n Ast_414.Parsetree.Pstr_eval (copy_expression x0, copy_attributes x1)\n | Ast_413.Parsetree.Pstr_value (x0, x1) ->\n Ast_414.Parsetree.Pstr_value\n (copy_rec_flag x0, List.map copy_value_binding x1)\n | Ast_413.Parsetree.Pstr_primitive x0 ->\n Ast_414.Parsetree.Pstr_primitive (copy_value_description x0)\n | Ast_413.Parsetree.Pstr_type (x0, x1) ->\n Ast_414.Parsetree.Pstr_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | Ast_413.Parsetree.Pstr_typext x0 ->\n Ast_414.Parsetree.Pstr_typext (copy_type_extension x0)\n | Ast_413.Parsetree.Pstr_exception x0 ->\n Ast_414.Parsetree.Pstr_exception (copy_type_exception x0)\n | Ast_413.Parsetree.Pstr_module x0 ->\n Ast_414.Parsetree.Pstr_module (copy_module_binding x0)\n | Ast_413.Parsetree.Pstr_recmodule x0 ->\n Ast_414.Parsetree.Pstr_recmodule (List.map copy_module_binding x0)\n | Ast_413.Parsetree.Pstr_modtype x0 ->\n Ast_414.Parsetree.Pstr_modtype (copy_module_type_declaration x0)\n | Ast_413.Parsetree.Pstr_open x0 ->\n Ast_414.Parsetree.Pstr_open (copy_open_declaration x0)\n | Ast_413.Parsetree.Pstr_class x0 ->\n Ast_414.Parsetree.Pstr_class (List.map copy_class_declaration x0)\n | Ast_413.Parsetree.Pstr_class_type x0 ->\n Ast_414.Parsetree.Pstr_class_type\n (List.map copy_class_type_declaration x0)\n | Ast_413.Parsetree.Pstr_include x0 ->\n Ast_414.Parsetree.Pstr_include (copy_include_declaration x0)\n | Ast_413.Parsetree.Pstr_attribute x0 ->\n Ast_414.Parsetree.Pstr_attribute (copy_attribute x0)\n | Ast_413.Parsetree.Pstr_extension (x0, x1) ->\n Ast_414.Parsetree.Pstr_extension (copy_extension x0, copy_attributes x1)\n\nand copy_include_declaration :\n Ast_413.Parsetree.include_declaration ->\n Ast_414.Parsetree.include_declaration =\n fun x -> copy_include_infos copy_module_expr x\n\nand copy_class_declaration :\n Ast_413.Parsetree.class_declaration -> Ast_414.Parsetree.class_declaration =\n fun x -> copy_class_infos copy_class_expr x\n\nand copy_class_expr :\n Ast_413.Parsetree.class_expr -> Ast_414.Parsetree.class_expr =\n fun {\n Ast_413.Parsetree.pcl_desc;\n Ast_413.Parsetree.pcl_loc;\n Ast_413.Parsetree.pcl_attributes;\n } ->\n {\n Ast_414.Parsetree.pcl_desc = copy_class_expr_desc pcl_desc;\n Ast_414.Parsetree.pcl_loc = copy_location pcl_loc;\n Ast_414.Parsetree.pcl_attributes = copy_attributes pcl_attributes;\n }\n\nand copy_class_expr_desc :\n Ast_413.Parsetree.class_expr_desc -> Ast_414.Parsetree.class_expr_desc =\n function\n | Ast_413.Parsetree.Pcl_constr (x0, x1) ->\n Ast_414.Parsetree.Pcl_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_413.Parsetree.Pcl_structure x0 ->\n Ast_414.Parsetree.Pcl_structure (copy_class_structure x0)\n | Ast_413.Parsetree.Pcl_fun (x0, x1, x2, x3) ->\n Ast_414.Parsetree.Pcl_fun\n ( copy_arg_label x0,\n Option.map copy_expression x1,\n copy_pattern x2,\n copy_class_expr x3 )\n | Ast_413.Parsetree.Pcl_apply (x0, x1) ->\n Ast_414.Parsetree.Pcl_apply\n ( copy_class_expr x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | Ast_413.Parsetree.Pcl_let (x0, x1, x2) ->\n Ast_414.Parsetree.Pcl_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_class_expr x2)\n | Ast_413.Parsetree.Pcl_constraint (x0, x1) ->\n Ast_414.Parsetree.Pcl_constraint (copy_class_expr x0, copy_class_type x1)\n | Ast_413.Parsetree.Pcl_extension x0 ->\n Ast_414.Parsetree.Pcl_extension (copy_extension x0)\n | Ast_413.Parsetree.Pcl_open (x0, x1) ->\n Ast_414.Parsetree.Pcl_open (copy_open_description x0, copy_class_expr x1)\n\nand copy_class_structure :\n Ast_413.Parsetree.class_structure -> Ast_414.Parsetree.class_structure =\n fun { Ast_413.Parsetree.pcstr_self; Ast_413.Parsetree.pcstr_fields } ->\n {\n Ast_414.Parsetree.pcstr_self = copy_pattern pcstr_self;\n Ast_414.Parsetree.pcstr_fields = List.map copy_class_field pcstr_fields;\n }\n\nand copy_class_field :\n Ast_413.Parsetree.class_field -> Ast_414.Parsetree.class_field =\n fun {\n Ast_413.Parsetree.pcf_desc;\n Ast_413.Parsetree.pcf_loc;\n Ast_413.Parsetree.pcf_attributes;\n } ->\n {\n Ast_414.Parsetree.pcf_desc = copy_class_field_desc pcf_desc;\n Ast_414.Parsetree.pcf_loc = copy_location pcf_loc;\n Ast_414.Parsetree.pcf_attributes = copy_attributes pcf_attributes;\n }\n\nand copy_class_field_desc :\n Ast_413.Parsetree.class_field_desc -> Ast_414.Parsetree.class_field_desc =\n function\n | Ast_413.Parsetree.Pcf_inherit (x0, x1, x2) ->\n Ast_414.Parsetree.Pcf_inherit\n ( copy_override_flag x0,\n copy_class_expr x1,\n Option.map (fun x -> copy_loc (fun x -> x) x) x2 )\n | Ast_413.Parsetree.Pcf_val x0 ->\n Ast_414.Parsetree.Pcf_val\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_mutable_flag x1, copy_class_field_kind x2))\n | Ast_413.Parsetree.Pcf_method x0 ->\n Ast_414.Parsetree.Pcf_method\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_private_flag x1, copy_class_field_kind x2))\n | Ast_413.Parsetree.Pcf_constraint x0 ->\n Ast_414.Parsetree.Pcf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | Ast_413.Parsetree.Pcf_initializer x0 ->\n Ast_414.Parsetree.Pcf_initializer (copy_expression x0)\n | Ast_413.Parsetree.Pcf_attribute x0 ->\n Ast_414.Parsetree.Pcf_attribute (copy_attribute x0)\n | Ast_413.Parsetree.Pcf_extension x0 ->\n Ast_414.Parsetree.Pcf_extension (copy_extension x0)\n\nand copy_class_field_kind :\n Ast_413.Parsetree.class_field_kind -> Ast_414.Parsetree.class_field_kind =\n function\n | Ast_413.Parsetree.Cfk_virtual x0 ->\n Ast_414.Parsetree.Cfk_virtual (copy_core_type x0)\n | Ast_413.Parsetree.Cfk_concrete (x0, x1) ->\n Ast_414.Parsetree.Cfk_concrete (copy_override_flag x0, copy_expression x1)\n\nand copy_open_declaration :\n Ast_413.Parsetree.open_declaration -> Ast_414.Parsetree.open_declaration =\n fun x -> copy_open_infos copy_module_expr x\n\nand copy_module_binding :\n Ast_413.Parsetree.module_binding -> Ast_414.Parsetree.module_binding =\n fun {\n Ast_413.Parsetree.pmb_name;\n Ast_413.Parsetree.pmb_expr;\n Ast_413.Parsetree.pmb_attributes;\n Ast_413.Parsetree.pmb_loc;\n } ->\n {\n Ast_414.Parsetree.pmb_name =\n copy_loc (fun x -> Option.map (fun x -> x) x) pmb_name;\n Ast_414.Parsetree.pmb_expr = copy_module_expr pmb_expr;\n Ast_414.Parsetree.pmb_attributes = copy_attributes pmb_attributes;\n Ast_414.Parsetree.pmb_loc = copy_location pmb_loc;\n }\n\nand copy_module_expr :\n Ast_413.Parsetree.module_expr -> Ast_414.Parsetree.module_expr =\n fun {\n Ast_413.Parsetree.pmod_desc;\n Ast_413.Parsetree.pmod_loc;\n Ast_413.Parsetree.pmod_attributes;\n } ->\n {\n Ast_414.Parsetree.pmod_desc = copy_module_expr_desc pmod_desc;\n Ast_414.Parsetree.pmod_loc = copy_location pmod_loc;\n Ast_414.Parsetree.pmod_attributes = copy_attributes pmod_attributes;\n }\n\nand copy_module_expr_desc :\n Ast_413.Parsetree.module_expr_desc -> Ast_414.Parsetree.module_expr_desc =\n function\n | Ast_413.Parsetree.Pmod_ident x0 ->\n Ast_414.Parsetree.Pmod_ident (copy_loc copy_Longident_t x0)\n | Ast_413.Parsetree.Pmod_structure x0 ->\n Ast_414.Parsetree.Pmod_structure (copy_structure x0)\n | Ast_413.Parsetree.Pmod_functor (x0, x1) ->\n Ast_414.Parsetree.Pmod_functor\n (copy_functor_parameter x0, copy_module_expr x1)\n | Ast_413.Parsetree.Pmod_apply (x0, x1) ->\n Ast_414.Parsetree.Pmod_apply (copy_module_expr x0, copy_module_expr x1)\n | Ast_413.Parsetree.Pmod_constraint (x0, x1) ->\n Ast_414.Parsetree.Pmod_constraint\n (copy_module_expr x0, copy_module_type x1)\n | Ast_413.Parsetree.Pmod_unpack x0 ->\n Ast_414.Parsetree.Pmod_unpack (copy_expression x0)\n | Ast_413.Parsetree.Pmod_extension x0 ->\n Ast_414.Parsetree.Pmod_extension (copy_extension x0)\n\nand copy_functor_parameter :\n Ast_413.Parsetree.functor_parameter -> Ast_414.Parsetree.functor_parameter =\n function\n | Ast_413.Parsetree.Unit -> Ast_414.Parsetree.Unit\n | Ast_413.Parsetree.Named (x0, x1) ->\n Ast_414.Parsetree.Named\n (copy_loc (fun x -> Option.map (fun x -> x) x) x0, copy_module_type x1)\n\nand copy_module_type :\n Ast_413.Parsetree.module_type -> Ast_414.Parsetree.module_type =\n fun {\n Ast_413.Parsetree.pmty_desc;\n Ast_413.Parsetree.pmty_loc;\n Ast_413.Parsetree.pmty_attributes;\n } ->\n {\n Ast_414.Parsetree.pmty_desc = copy_module_type_desc pmty_desc;\n Ast_414.Parsetree.pmty_loc = copy_location pmty_loc;\n Ast_414.Parsetree.pmty_attributes = copy_attributes pmty_attributes;\n }\n\nand copy_module_type_desc :\n Ast_413.Parsetree.module_type_desc -> Ast_414.Parsetree.module_type_desc =\n function\n | Ast_413.Parsetree.Pmty_ident x0 ->\n Ast_414.Parsetree.Pmty_ident (copy_loc copy_Longident_t x0)\n | Ast_413.Parsetree.Pmty_signature x0 ->\n Ast_414.Parsetree.Pmty_signature (copy_signature x0)\n | Ast_413.Parsetree.Pmty_functor (x0, x1) ->\n Ast_414.Parsetree.Pmty_functor\n (copy_functor_parameter x0, copy_module_type x1)\n | Ast_413.Parsetree.Pmty_with (x0, x1) ->\n Ast_414.Parsetree.Pmty_with\n (copy_module_type x0, List.map copy_with_constraint x1)\n | Ast_413.Parsetree.Pmty_typeof x0 ->\n Ast_414.Parsetree.Pmty_typeof (copy_module_expr x0)\n | Ast_413.Parsetree.Pmty_extension x0 ->\n Ast_414.Parsetree.Pmty_extension (copy_extension x0)\n | Ast_413.Parsetree.Pmty_alias x0 ->\n Ast_414.Parsetree.Pmty_alias (copy_loc copy_Longident_t x0)\n\nand copy_with_constraint :\n Ast_413.Parsetree.with_constraint -> Ast_414.Parsetree.with_constraint =\n function\n | Ast_413.Parsetree.Pwith_type (x0, x1) ->\n Ast_414.Parsetree.Pwith_type\n (copy_loc copy_Longident_t x0, copy_type_declaration x1)\n | Ast_413.Parsetree.Pwith_module (x0, x1) ->\n Ast_414.Parsetree.Pwith_module\n (copy_loc copy_Longident_t x0, copy_loc copy_Longident_t x1)\n | Ast_413.Parsetree.Pwith_modtype (x0, x1) ->\n Ast_414.Parsetree.Pwith_modtype\n (copy_loc copy_Longident_t x0, copy_module_type x1)\n | Ast_413.Parsetree.Pwith_modtypesubst (x0, x1) ->\n Ast_414.Parsetree.Pwith_modtypesubst\n (copy_loc copy_Longident_t x0, copy_module_type x1)\n | Ast_413.Parsetree.Pwith_typesubst (x0, x1) ->\n Ast_414.Parsetree.Pwith_typesubst\n (copy_loc copy_Longident_t x0, copy_type_declaration x1)\n | Ast_413.Parsetree.Pwith_modsubst (x0, x1) ->\n Ast_414.Parsetree.Pwith_modsubst\n (copy_loc copy_Longident_t x0, copy_loc copy_Longident_t x1)\n\nand copy_signature : Ast_413.Parsetree.signature -> Ast_414.Parsetree.signature\n =\n fun x -> List.map copy_signature_item x\n\nand copy_signature_item :\n Ast_413.Parsetree.signature_item -> Ast_414.Parsetree.signature_item =\n fun { Ast_413.Parsetree.psig_desc; Ast_413.Parsetree.psig_loc } ->\n {\n Ast_414.Parsetree.psig_desc = copy_signature_item_desc psig_desc;\n Ast_414.Parsetree.psig_loc = copy_location psig_loc;\n }\n\nand copy_signature_item_desc :\n Ast_413.Parsetree.signature_item_desc ->\n Ast_414.Parsetree.signature_item_desc = function\n | Ast_413.Parsetree.Psig_value x0 ->\n Ast_414.Parsetree.Psig_value (copy_value_description x0)\n | Ast_413.Parsetree.Psig_type (x0, x1) ->\n Ast_414.Parsetree.Psig_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | Ast_413.Parsetree.Psig_typesubst x0 ->\n Ast_414.Parsetree.Psig_typesubst (List.map copy_type_declaration x0)\n | Ast_413.Parsetree.Psig_typext x0 ->\n Ast_414.Parsetree.Psig_typext (copy_type_extension x0)\n | Ast_413.Parsetree.Psig_exception x0 ->\n Ast_414.Parsetree.Psig_exception (copy_type_exception x0)\n | Ast_413.Parsetree.Psig_module x0 ->\n Ast_414.Parsetree.Psig_module (copy_module_declaration x0)\n | Ast_413.Parsetree.Psig_modsubst x0 ->\n Ast_414.Parsetree.Psig_modsubst (copy_module_substitution x0)\n | Ast_413.Parsetree.Psig_recmodule x0 ->\n Ast_414.Parsetree.Psig_recmodule (List.map copy_module_declaration x0)\n | Ast_413.Parsetree.Psig_modtype x0 ->\n Ast_414.Parsetree.Psig_modtype (copy_module_type_declaration x0)\n | Ast_413.Parsetree.Psig_modtypesubst x0 ->\n Ast_414.Parsetree.Psig_modtypesubst (copy_module_type_declaration x0)\n | Ast_413.Parsetree.Psig_open x0 ->\n Ast_414.Parsetree.Psig_open (copy_open_description x0)\n | Ast_413.Parsetree.Psig_include x0 ->\n Ast_414.Parsetree.Psig_include (copy_include_description x0)\n | Ast_413.Parsetree.Psig_class x0 ->\n Ast_414.Parsetree.Psig_class (List.map copy_class_description x0)\n | Ast_413.Parsetree.Psig_class_type x0 ->\n Ast_414.Parsetree.Psig_class_type\n (List.map copy_class_type_declaration x0)\n | Ast_413.Parsetree.Psig_attribute x0 ->\n Ast_414.Parsetree.Psig_attribute (copy_attribute x0)\n | Ast_413.Parsetree.Psig_extension (x0, x1) ->\n Ast_414.Parsetree.Psig_extension (copy_extension x0, copy_attributes x1)\n\nand copy_class_type_declaration :\n Ast_413.Parsetree.class_type_declaration ->\n Ast_414.Parsetree.class_type_declaration =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_description :\n Ast_413.Parsetree.class_description -> Ast_414.Parsetree.class_description =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_type :\n Ast_413.Parsetree.class_type -> Ast_414.Parsetree.class_type =\n fun {\n Ast_413.Parsetree.pcty_desc;\n Ast_413.Parsetree.pcty_loc;\n Ast_413.Parsetree.pcty_attributes;\n } ->\n {\n Ast_414.Parsetree.pcty_desc = copy_class_type_desc pcty_desc;\n Ast_414.Parsetree.pcty_loc = copy_location pcty_loc;\n Ast_414.Parsetree.pcty_attributes = copy_attributes pcty_attributes;\n }\n\nand copy_class_type_desc :\n Ast_413.Parsetree.class_type_desc -> Ast_414.Parsetree.class_type_desc =\n function\n | Ast_413.Parsetree.Pcty_constr (x0, x1) ->\n Ast_414.Parsetree.Pcty_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_413.Parsetree.Pcty_signature x0 ->\n Ast_414.Parsetree.Pcty_signature (copy_class_signature x0)\n | Ast_413.Parsetree.Pcty_arrow (x0, x1, x2) ->\n Ast_414.Parsetree.Pcty_arrow\n (copy_arg_label x0, copy_core_type x1, copy_class_type x2)\n | Ast_413.Parsetree.Pcty_extension x0 ->\n Ast_414.Parsetree.Pcty_extension (copy_extension x0)\n | Ast_413.Parsetree.Pcty_open (x0, x1) ->\n Ast_414.Parsetree.Pcty_open (copy_open_description x0, copy_class_type x1)\n\nand copy_class_signature :\n Ast_413.Parsetree.class_signature -> Ast_414.Parsetree.class_signature =\n fun { Ast_413.Parsetree.pcsig_self; Ast_413.Parsetree.pcsig_fields } ->\n {\n Ast_414.Parsetree.pcsig_self = copy_core_type pcsig_self;\n Ast_414.Parsetree.pcsig_fields = List.map copy_class_type_field pcsig_fields;\n }\n\nand copy_class_type_field :\n Ast_413.Parsetree.class_type_field -> Ast_414.Parsetree.class_type_field =\n fun {\n Ast_413.Parsetree.pctf_desc;\n Ast_413.Parsetree.pctf_loc;\n Ast_413.Parsetree.pctf_attributes;\n } ->\n {\n Ast_414.Parsetree.pctf_desc = copy_class_type_field_desc pctf_desc;\n Ast_414.Parsetree.pctf_loc = copy_location pctf_loc;\n Ast_414.Parsetree.pctf_attributes = copy_attributes pctf_attributes;\n }\n\nand copy_class_type_field_desc :\n Ast_413.Parsetree.class_type_field_desc ->\n Ast_414.Parsetree.class_type_field_desc = function\n | Ast_413.Parsetree.Pctf_inherit x0 ->\n Ast_414.Parsetree.Pctf_inherit (copy_class_type x0)\n | Ast_413.Parsetree.Pctf_val x0 ->\n Ast_414.Parsetree.Pctf_val\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_mutable_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | Ast_413.Parsetree.Pctf_method x0 ->\n Ast_414.Parsetree.Pctf_method\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_private_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | Ast_413.Parsetree.Pctf_constraint x0 ->\n Ast_414.Parsetree.Pctf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | Ast_413.Parsetree.Pctf_attribute x0 ->\n Ast_414.Parsetree.Pctf_attribute (copy_attribute x0)\n | Ast_413.Parsetree.Pctf_extension x0 ->\n Ast_414.Parsetree.Pctf_extension (copy_extension x0)\n\nand copy_extension : Ast_413.Parsetree.extension -> Ast_414.Parsetree.extension\n =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_class_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_413.Parsetree.class_infos ->\n 'g0 Ast_414.Parsetree.class_infos =\n fun f0\n {\n Ast_413.Parsetree.pci_virt;\n Ast_413.Parsetree.pci_params;\n Ast_413.Parsetree.pci_name;\n Ast_413.Parsetree.pci_expr;\n Ast_413.Parsetree.pci_loc;\n Ast_413.Parsetree.pci_attributes;\n } ->\n {\n Ast_414.Parsetree.pci_virt = copy_virtual_flag pci_virt;\n Ast_414.Parsetree.pci_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n ( copy_core_type x0,\n let x0, x1 = x1 in\n (copy_variance x0, copy_injectivity x1) ))\n pci_params;\n Ast_414.Parsetree.pci_name = copy_loc (fun x -> x) pci_name;\n Ast_414.Parsetree.pci_expr = f0 pci_expr;\n Ast_414.Parsetree.pci_loc = copy_location pci_loc;\n Ast_414.Parsetree.pci_attributes = copy_attributes pci_attributes;\n }\n\nand copy_virtual_flag :\n Ast_413.Asttypes.virtual_flag -> Ast_414.Asttypes.virtual_flag = function\n | Ast_413.Asttypes.Virtual -> Ast_414.Asttypes.Virtual\n | Ast_413.Asttypes.Concrete -> Ast_414.Asttypes.Concrete\n\nand copy_include_description :\n Ast_413.Parsetree.include_description ->\n Ast_414.Parsetree.include_description =\n fun x -> copy_include_infos copy_module_type x\n\nand copy_include_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_413.Parsetree.include_infos ->\n 'g0 Ast_414.Parsetree.include_infos =\n fun f0\n {\n Ast_413.Parsetree.pincl_mod;\n Ast_413.Parsetree.pincl_loc;\n Ast_413.Parsetree.pincl_attributes;\n } ->\n {\n Ast_414.Parsetree.pincl_mod = f0 pincl_mod;\n Ast_414.Parsetree.pincl_loc = copy_location pincl_loc;\n Ast_414.Parsetree.pincl_attributes = copy_attributes pincl_attributes;\n }\n\nand copy_open_description :\n Ast_413.Parsetree.open_description -> Ast_414.Parsetree.open_description =\n fun x -> copy_open_infos (fun x -> copy_loc copy_Longident_t x) x\n\nand copy_open_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_413.Parsetree.open_infos ->\n 'g0 Ast_414.Parsetree.open_infos =\n fun f0\n {\n Ast_413.Parsetree.popen_expr;\n Ast_413.Parsetree.popen_override;\n Ast_413.Parsetree.popen_loc;\n Ast_413.Parsetree.popen_attributes;\n } ->\n {\n Ast_414.Parsetree.popen_expr = f0 popen_expr;\n Ast_414.Parsetree.popen_override = copy_override_flag popen_override;\n Ast_414.Parsetree.popen_loc = copy_location popen_loc;\n Ast_414.Parsetree.popen_attributes = copy_attributes popen_attributes;\n }\n\nand copy_override_flag :\n Ast_413.Asttypes.override_flag -> Ast_414.Asttypes.override_flag = function\n | Ast_413.Asttypes.Override -> Ast_414.Asttypes.Override\n | Ast_413.Asttypes.Fresh -> Ast_414.Asttypes.Fresh\n\nand copy_module_type_declaration :\n Ast_413.Parsetree.module_type_declaration ->\n Ast_414.Parsetree.module_type_declaration =\n fun {\n Ast_413.Parsetree.pmtd_name;\n Ast_413.Parsetree.pmtd_type;\n Ast_413.Parsetree.pmtd_attributes;\n Ast_413.Parsetree.pmtd_loc;\n } ->\n {\n Ast_414.Parsetree.pmtd_name = copy_loc (fun x -> x) pmtd_name;\n Ast_414.Parsetree.pmtd_type = Option.map copy_module_type pmtd_type;\n Ast_414.Parsetree.pmtd_attributes = copy_attributes pmtd_attributes;\n Ast_414.Parsetree.pmtd_loc = copy_location pmtd_loc;\n }\n\nand copy_module_substitution :\n Ast_413.Parsetree.module_substitution ->\n Ast_414.Parsetree.module_substitution =\n fun {\n Ast_413.Parsetree.pms_name;\n Ast_413.Parsetree.pms_manifest;\n Ast_413.Parsetree.pms_attributes;\n Ast_413.Parsetree.pms_loc;\n } ->\n {\n Ast_414.Parsetree.pms_name = copy_loc (fun x -> x) pms_name;\n Ast_414.Parsetree.pms_manifest = copy_loc copy_Longident_t pms_manifest;\n Ast_414.Parsetree.pms_attributes = copy_attributes pms_attributes;\n Ast_414.Parsetree.pms_loc = copy_location pms_loc;\n }\n\nand copy_module_declaration :\n Ast_413.Parsetree.module_declaration -> Ast_414.Parsetree.module_declaration\n =\n fun {\n Ast_413.Parsetree.pmd_name;\n Ast_413.Parsetree.pmd_type;\n Ast_413.Parsetree.pmd_attributes;\n Ast_413.Parsetree.pmd_loc;\n } ->\n {\n Ast_414.Parsetree.pmd_name =\n copy_loc (fun x -> Option.map (fun x -> x) x) pmd_name;\n Ast_414.Parsetree.pmd_type = copy_module_type pmd_type;\n Ast_414.Parsetree.pmd_attributes = copy_attributes pmd_attributes;\n Ast_414.Parsetree.pmd_loc = copy_location pmd_loc;\n }\n\nand copy_type_exception :\n Ast_413.Parsetree.type_exception -> Ast_414.Parsetree.type_exception =\n fun {\n Ast_413.Parsetree.ptyexn_constructor;\n Ast_413.Parsetree.ptyexn_loc;\n Ast_413.Parsetree.ptyexn_attributes;\n } ->\n {\n Ast_414.Parsetree.ptyexn_constructor =\n copy_extension_constructor ptyexn_constructor;\n Ast_414.Parsetree.ptyexn_loc = copy_location ptyexn_loc;\n Ast_414.Parsetree.ptyexn_attributes = copy_attributes ptyexn_attributes;\n }\n\nand copy_type_extension :\n Ast_413.Parsetree.type_extension -> Ast_414.Parsetree.type_extension =\n fun {\n Ast_413.Parsetree.ptyext_path;\n Ast_413.Parsetree.ptyext_params;\n Ast_413.Parsetree.ptyext_constructors;\n Ast_413.Parsetree.ptyext_private;\n Ast_413.Parsetree.ptyext_loc;\n Ast_413.Parsetree.ptyext_attributes;\n } ->\n {\n Ast_414.Parsetree.ptyext_path = copy_loc copy_Longident_t ptyext_path;\n Ast_414.Parsetree.ptyext_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n ( copy_core_type x0,\n let x0, x1 = x1 in\n (copy_variance x0, copy_injectivity x1) ))\n ptyext_params;\n Ast_414.Parsetree.ptyext_constructors =\n List.map copy_extension_constructor ptyext_constructors;\n Ast_414.Parsetree.ptyext_private = copy_private_flag ptyext_private;\n Ast_414.Parsetree.ptyext_loc = copy_location ptyext_loc;\n Ast_414.Parsetree.ptyext_attributes = copy_attributes ptyext_attributes;\n }\n\nand copy_extension_constructor :\n Ast_413.Parsetree.extension_constructor ->\n Ast_414.Parsetree.extension_constructor =\n fun {\n Ast_413.Parsetree.pext_name;\n Ast_413.Parsetree.pext_kind;\n Ast_413.Parsetree.pext_loc;\n Ast_413.Parsetree.pext_attributes;\n } ->\n {\n Ast_414.Parsetree.pext_name = copy_loc (fun x -> x) pext_name;\n Ast_414.Parsetree.pext_kind = copy_extension_constructor_kind pext_kind;\n Ast_414.Parsetree.pext_loc = copy_location pext_loc;\n Ast_414.Parsetree.pext_attributes = copy_attributes pext_attributes;\n }\n\nand copy_extension_constructor_kind :\n Ast_413.Parsetree.extension_constructor_kind ->\n Ast_414.Parsetree.extension_constructor_kind = function\n | Ast_413.Parsetree.Pext_decl (x0, x1) ->\n Ast_414.Parsetree.Pext_decl\n ([], copy_constructor_arguments x0, Option.map copy_core_type x1)\n | Ast_413.Parsetree.Pext_rebind x0 ->\n Ast_414.Parsetree.Pext_rebind (copy_loc copy_Longident_t x0)\n\nand copy_type_declaration :\n Ast_413.Parsetree.type_declaration -> Ast_414.Parsetree.type_declaration =\n fun {\n Ast_413.Parsetree.ptype_name;\n Ast_413.Parsetree.ptype_params;\n Ast_413.Parsetree.ptype_cstrs;\n Ast_413.Parsetree.ptype_kind;\n Ast_413.Parsetree.ptype_private;\n Ast_413.Parsetree.ptype_manifest;\n Ast_413.Parsetree.ptype_attributes;\n Ast_413.Parsetree.ptype_loc;\n } ->\n {\n Ast_414.Parsetree.ptype_name = copy_loc (fun x -> x) ptype_name;\n Ast_414.Parsetree.ptype_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n ( copy_core_type x0,\n let x0, x1 = x1 in\n (copy_variance x0, copy_injectivity x1) ))\n ptype_params;\n Ast_414.Parsetree.ptype_cstrs =\n List.map\n (fun x ->\n let x0, x1, x2 = x in\n (copy_core_type x0, copy_core_type x1, copy_location x2))\n ptype_cstrs;\n Ast_414.Parsetree.ptype_kind = copy_type_kind ptype_kind;\n Ast_414.Parsetree.ptype_private = copy_private_flag ptype_private;\n Ast_414.Parsetree.ptype_manifest = Option.map copy_core_type ptype_manifest;\n Ast_414.Parsetree.ptype_attributes = copy_attributes ptype_attributes;\n Ast_414.Parsetree.ptype_loc = copy_location ptype_loc;\n }\n\nand copy_private_flag :\n Ast_413.Asttypes.private_flag -> Ast_414.Asttypes.private_flag = function\n | Ast_413.Asttypes.Private -> Ast_414.Asttypes.Private\n | Ast_413.Asttypes.Public -> Ast_414.Asttypes.Public\n\nand copy_type_kind : Ast_413.Parsetree.type_kind -> Ast_414.Parsetree.type_kind\n = function\n | Ast_413.Parsetree.Ptype_abstract -> Ast_414.Parsetree.Ptype_abstract\n | Ast_413.Parsetree.Ptype_variant x0 ->\n Ast_414.Parsetree.Ptype_variant (List.map copy_constructor_declaration x0)\n | Ast_413.Parsetree.Ptype_record x0 ->\n Ast_414.Parsetree.Ptype_record (List.map copy_label_declaration x0)\n | Ast_413.Parsetree.Ptype_open -> Ast_414.Parsetree.Ptype_open\n\nand copy_constructor_declaration :\n Ast_413.Parsetree.constructor_declaration ->\n Ast_414.Parsetree.constructor_declaration =\n fun {\n Ast_413.Parsetree.pcd_name;\n Ast_413.Parsetree.pcd_args;\n Ast_413.Parsetree.pcd_res;\n Ast_413.Parsetree.pcd_loc;\n Ast_413.Parsetree.pcd_attributes;\n } ->\n {\n Ast_414.Parsetree.pcd_name = copy_loc (fun x -> x) pcd_name;\n Ast_414.Parsetree.pcd_vars = [];\n Ast_414.Parsetree.pcd_args = copy_constructor_arguments pcd_args;\n Ast_414.Parsetree.pcd_res = Option.map copy_core_type pcd_res;\n Ast_414.Parsetree.pcd_loc = copy_location pcd_loc;\n Ast_414.Parsetree.pcd_attributes = copy_attributes pcd_attributes;\n }\n\nand copy_constructor_arguments :\n Ast_413.Parsetree.constructor_arguments ->\n Ast_414.Parsetree.constructor_arguments = function\n | Ast_413.Parsetree.Pcstr_tuple x0 ->\n Ast_414.Parsetree.Pcstr_tuple (List.map copy_core_type x0)\n | Ast_413.Parsetree.Pcstr_record x0 ->\n Ast_414.Parsetree.Pcstr_record (List.map copy_label_declaration x0)\n\nand copy_label_declaration :\n Ast_413.Parsetree.label_declaration -> Ast_414.Parsetree.label_declaration =\n fun {\n Ast_413.Parsetree.pld_name;\n Ast_413.Parsetree.pld_mutable;\n Ast_413.Parsetree.pld_type;\n Ast_413.Parsetree.pld_loc;\n Ast_413.Parsetree.pld_attributes;\n } ->\n {\n Ast_414.Parsetree.pld_name = copy_loc (fun x -> x) pld_name;\n Ast_414.Parsetree.pld_mutable = copy_mutable_flag pld_mutable;\n Ast_414.Parsetree.pld_type = copy_core_type pld_type;\n Ast_414.Parsetree.pld_loc = copy_location pld_loc;\n Ast_414.Parsetree.pld_attributes = copy_attributes pld_attributes;\n }\n\nand copy_mutable_flag :\n Ast_413.Asttypes.mutable_flag -> Ast_414.Asttypes.mutable_flag = function\n | Ast_413.Asttypes.Immutable -> Ast_414.Asttypes.Immutable\n | Ast_413.Asttypes.Mutable -> Ast_414.Asttypes.Mutable\n\nand copy_injectivity :\n Ast_413.Asttypes.injectivity -> Ast_414.Asttypes.injectivity = function\n | Ast_413.Asttypes.Injective -> Ast_414.Asttypes.Injective\n | Ast_413.Asttypes.NoInjectivity -> Ast_414.Asttypes.NoInjectivity\n\nand copy_variance : Ast_413.Asttypes.variance -> Ast_414.Asttypes.variance =\n function\n | Ast_413.Asttypes.Covariant -> Ast_414.Asttypes.Covariant\n | Ast_413.Asttypes.Contravariant -> Ast_414.Asttypes.Contravariant\n | Ast_413.Asttypes.NoVariance -> Ast_414.Asttypes.NoVariance\n\nand copy_value_description :\n Ast_413.Parsetree.value_description -> Ast_414.Parsetree.value_description =\n fun {\n Ast_413.Parsetree.pval_name;\n Ast_413.Parsetree.pval_type;\n Ast_413.Parsetree.pval_prim;\n Ast_413.Parsetree.pval_attributes;\n Ast_413.Parsetree.pval_loc;\n } ->\n {\n Ast_414.Parsetree.pval_name = copy_loc (fun x -> x) pval_name;\n Ast_414.Parsetree.pval_type = copy_core_type pval_type;\n Ast_414.Parsetree.pval_prim = List.map (fun x -> x) pval_prim;\n Ast_414.Parsetree.pval_attributes = copy_attributes pval_attributes;\n Ast_414.Parsetree.pval_loc = copy_location pval_loc;\n }\n\nand copy_object_field_desc :\n Ast_413.Parsetree.object_field_desc -> Ast_414.Parsetree.object_field_desc =\n function\n | Ast_413.Parsetree.Otag (x0, x1) ->\n Ast_414.Parsetree.Otag (copy_loc copy_label x0, copy_core_type x1)\n | Ast_413.Parsetree.Oinherit x0 ->\n Ast_414.Parsetree.Oinherit (copy_core_type x0)\n\nand copy_arg_label : Ast_413.Asttypes.arg_label -> Ast_414.Asttypes.arg_label =\n function\n | Ast_413.Asttypes.Nolabel -> Ast_414.Asttypes.Nolabel\n | Ast_413.Asttypes.Labelled x0 -> Ast_414.Asttypes.Labelled x0\n | Ast_413.Asttypes.Optional x0 -> Ast_414.Asttypes.Optional x0\n\nand copy_closed_flag :\n Ast_413.Asttypes.closed_flag -> Ast_414.Asttypes.closed_flag = function\n | Ast_413.Asttypes.Closed -> Ast_414.Asttypes.Closed\n | Ast_413.Asttypes.Open -> Ast_414.Asttypes.Open\n\nand copy_label : Ast_413.Asttypes.label -> Ast_414.Asttypes.label = fun x -> x\n\nand copy_rec_flag : Ast_413.Asttypes.rec_flag -> Ast_414.Asttypes.rec_flag =\n function\n | Ast_413.Asttypes.Nonrecursive -> Ast_414.Asttypes.Nonrecursive\n | Ast_413.Asttypes.Recursive -> Ast_414.Asttypes.Recursive\n\nand copy_constant : Ast_413.Parsetree.constant -> Ast_414.Parsetree.constant =\n function\n | Ast_413.Parsetree.Pconst_integer (x0, x1) ->\n Ast_414.Parsetree.Pconst_integer (x0, Option.map (fun x -> x) x1)\n | Ast_413.Parsetree.Pconst_char x0 -> Ast_414.Parsetree.Pconst_char x0\n | Ast_413.Parsetree.Pconst_string (x0, x1, x2) ->\n Ast_414.Parsetree.Pconst_string\n (x0, copy_location x1, Option.map (fun x -> x) x2)\n | Ast_413.Parsetree.Pconst_float (x0, x1) ->\n Ast_414.Parsetree.Pconst_float (x0, Option.map (fun x -> x) x1)\n\nand copy_Longident_t : Longident.t -> Longident.t = fun x -> x\n\nand copy_loc :\n 'f0 'g0.\n ('f0 -> 'g0) -> 'f0 Ast_413.Asttypes.loc -> 'g0 Ast_414.Asttypes.loc =\n fun f0 { Ast_413.Asttypes.txt; Ast_413.Asttypes.loc } ->\n { Ast_414.Asttypes.txt = f0 txt; Ast_414.Asttypes.loc = copy_location loc }\n\nand copy_location : Location.t -> Location.t = fun x -> x\n","open Stdlib0\nmodule From = Ast_413\nmodule To = Ast_412\n\nlet migration_error loc missing_feature =\n Location.raise_errorf ~loc\n \"migration error: %s is not supported before OCaml 4.13\" missing_feature\n\nlet rec copy_toplevel_phrase :\n Ast_413.Parsetree.toplevel_phrase -> Ast_412.Parsetree.toplevel_phrase =\n function\n | Ast_413.Parsetree.Ptop_def x0 ->\n Ast_412.Parsetree.Ptop_def (copy_structure x0)\n | Ast_413.Parsetree.Ptop_dir x0 ->\n Ast_412.Parsetree.Ptop_dir (copy_toplevel_directive x0)\n\nand copy_toplevel_directive :\n Ast_413.Parsetree.toplevel_directive -> Ast_412.Parsetree.toplevel_directive\n =\n fun {\n Ast_413.Parsetree.pdir_name;\n Ast_413.Parsetree.pdir_arg;\n Ast_413.Parsetree.pdir_loc;\n } ->\n {\n Ast_412.Parsetree.pdir_name = copy_loc (fun x -> x) pdir_name;\n Ast_412.Parsetree.pdir_arg = Option.map copy_directive_argument pdir_arg;\n Ast_412.Parsetree.pdir_loc = copy_location pdir_loc;\n }\n\nand copy_directive_argument :\n Ast_413.Parsetree.directive_argument -> Ast_412.Parsetree.directive_argument\n =\n fun { Ast_413.Parsetree.pdira_desc; Ast_413.Parsetree.pdira_loc } ->\n {\n Ast_412.Parsetree.pdira_desc = copy_directive_argument_desc pdira_desc;\n Ast_412.Parsetree.pdira_loc = copy_location pdira_loc;\n }\n\nand copy_directive_argument_desc :\n Ast_413.Parsetree.directive_argument_desc ->\n Ast_412.Parsetree.directive_argument_desc = function\n | Ast_413.Parsetree.Pdir_string x0 -> Ast_412.Parsetree.Pdir_string x0\n | Ast_413.Parsetree.Pdir_int (x0, x1) ->\n Ast_412.Parsetree.Pdir_int (x0, Option.map (fun x -> x) x1)\n | Ast_413.Parsetree.Pdir_ident x0 ->\n Ast_412.Parsetree.Pdir_ident (copy_Longident_t x0)\n | Ast_413.Parsetree.Pdir_bool x0 -> Ast_412.Parsetree.Pdir_bool x0\n\nand copy_expression :\n Ast_413.Parsetree.expression -> Ast_412.Parsetree.expression =\n fun {\n Ast_413.Parsetree.pexp_desc;\n Ast_413.Parsetree.pexp_loc;\n Ast_413.Parsetree.pexp_loc_stack;\n Ast_413.Parsetree.pexp_attributes;\n } ->\n {\n Ast_412.Parsetree.pexp_desc = copy_expression_desc pexp_desc;\n Ast_412.Parsetree.pexp_loc = copy_location pexp_loc;\n Ast_412.Parsetree.pexp_loc_stack = copy_location_stack pexp_loc_stack;\n Ast_412.Parsetree.pexp_attributes = copy_attributes pexp_attributes;\n }\n\nand copy_expression_desc :\n Ast_413.Parsetree.expression_desc -> Ast_412.Parsetree.expression_desc =\n function\n | Ast_413.Parsetree.Pexp_ident x0 ->\n Ast_412.Parsetree.Pexp_ident (copy_loc copy_Longident_t x0)\n | Ast_413.Parsetree.Pexp_constant x0 ->\n Ast_412.Parsetree.Pexp_constant (copy_constant x0)\n | Ast_413.Parsetree.Pexp_let (x0, x1, x2) ->\n Ast_412.Parsetree.Pexp_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_expression x2)\n | Ast_413.Parsetree.Pexp_function x0 ->\n Ast_412.Parsetree.Pexp_function (List.map copy_case x0)\n | Ast_413.Parsetree.Pexp_fun (x0, x1, x2, x3) ->\n Ast_412.Parsetree.Pexp_fun\n ( copy_arg_label x0,\n Option.map copy_expression x1,\n copy_pattern x2,\n copy_expression x3 )\n | Ast_413.Parsetree.Pexp_apply (x0, x1) ->\n Ast_412.Parsetree.Pexp_apply\n ( copy_expression x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | Ast_413.Parsetree.Pexp_match (x0, x1) ->\n Ast_412.Parsetree.Pexp_match (copy_expression x0, List.map copy_case x1)\n | Ast_413.Parsetree.Pexp_try (x0, x1) ->\n Ast_412.Parsetree.Pexp_try (copy_expression x0, List.map copy_case x1)\n | Ast_413.Parsetree.Pexp_tuple x0 ->\n Ast_412.Parsetree.Pexp_tuple (List.map copy_expression x0)\n | Ast_413.Parsetree.Pexp_construct (x0, x1) ->\n Ast_412.Parsetree.Pexp_construct\n (copy_loc copy_Longident_t x0, Option.map copy_expression x1)\n | Ast_413.Parsetree.Pexp_variant (x0, x1) ->\n Ast_412.Parsetree.Pexp_variant\n (copy_label x0, Option.map copy_expression x1)\n | Ast_413.Parsetree.Pexp_record (x0, x1) ->\n Ast_412.Parsetree.Pexp_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_expression x1))\n x0,\n Option.map copy_expression x1 )\n | Ast_413.Parsetree.Pexp_field (x0, x1) ->\n Ast_412.Parsetree.Pexp_field\n (copy_expression x0, copy_loc copy_Longident_t x1)\n | Ast_413.Parsetree.Pexp_setfield (x0, x1, x2) ->\n Ast_412.Parsetree.Pexp_setfield\n (copy_expression x0, copy_loc copy_Longident_t x1, copy_expression x2)\n | Ast_413.Parsetree.Pexp_array x0 ->\n Ast_412.Parsetree.Pexp_array (List.map copy_expression x0)\n | Ast_413.Parsetree.Pexp_ifthenelse (x0, x1, x2) ->\n Ast_412.Parsetree.Pexp_ifthenelse\n (copy_expression x0, copy_expression x1, Option.map copy_expression x2)\n | Ast_413.Parsetree.Pexp_sequence (x0, x1) ->\n Ast_412.Parsetree.Pexp_sequence (copy_expression x0, copy_expression x1)\n | Ast_413.Parsetree.Pexp_while (x0, x1) ->\n Ast_412.Parsetree.Pexp_while (copy_expression x0, copy_expression x1)\n | Ast_413.Parsetree.Pexp_for (x0, x1, x2, x3, x4) ->\n Ast_412.Parsetree.Pexp_for\n ( copy_pattern x0,\n copy_expression x1,\n copy_expression x2,\n copy_direction_flag x3,\n copy_expression x4 )\n | Ast_413.Parsetree.Pexp_constraint (x0, x1) ->\n Ast_412.Parsetree.Pexp_constraint (copy_expression x0, copy_core_type x1)\n | Ast_413.Parsetree.Pexp_coerce (x0, x1, x2) ->\n Ast_412.Parsetree.Pexp_coerce\n (copy_expression x0, Option.map copy_core_type x1, copy_core_type x2)\n | Ast_413.Parsetree.Pexp_send (x0, x1) ->\n Ast_412.Parsetree.Pexp_send (copy_expression x0, copy_loc copy_label x1)\n | Ast_413.Parsetree.Pexp_new x0 ->\n Ast_412.Parsetree.Pexp_new (copy_loc copy_Longident_t x0)\n | Ast_413.Parsetree.Pexp_setinstvar (x0, x1) ->\n Ast_412.Parsetree.Pexp_setinstvar\n (copy_loc copy_label x0, copy_expression x1)\n | Ast_413.Parsetree.Pexp_override x0 ->\n Ast_412.Parsetree.Pexp_override\n (List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_label x0, copy_expression x1))\n x0)\n | Ast_413.Parsetree.Pexp_letmodule (x0, x1, x2) ->\n Ast_412.Parsetree.Pexp_letmodule\n ( copy_loc (fun x -> Option.map (fun x -> x) x) x0,\n copy_module_expr x1,\n copy_expression x2 )\n | Ast_413.Parsetree.Pexp_letexception (x0, x1) ->\n Ast_412.Parsetree.Pexp_letexception\n (copy_extension_constructor x0, copy_expression x1)\n | Ast_413.Parsetree.Pexp_assert x0 ->\n Ast_412.Parsetree.Pexp_assert (copy_expression x0)\n | Ast_413.Parsetree.Pexp_lazy x0 ->\n Ast_412.Parsetree.Pexp_lazy (copy_expression x0)\n | Ast_413.Parsetree.Pexp_poly (x0, x1) ->\n Ast_412.Parsetree.Pexp_poly\n (copy_expression x0, Option.map copy_core_type x1)\n | Ast_413.Parsetree.Pexp_object x0 ->\n Ast_412.Parsetree.Pexp_object (copy_class_structure x0)\n | Ast_413.Parsetree.Pexp_newtype (x0, x1) ->\n Ast_412.Parsetree.Pexp_newtype\n (copy_loc (fun x -> x) x0, copy_expression x1)\n | Ast_413.Parsetree.Pexp_pack x0 ->\n Ast_412.Parsetree.Pexp_pack (copy_module_expr x0)\n | Ast_413.Parsetree.Pexp_open (x0, x1) ->\n Ast_412.Parsetree.Pexp_open (copy_open_declaration x0, copy_expression x1)\n | Ast_413.Parsetree.Pexp_letop x0 ->\n Ast_412.Parsetree.Pexp_letop (copy_letop x0)\n | Ast_413.Parsetree.Pexp_extension x0 ->\n Ast_412.Parsetree.Pexp_extension (copy_extension x0)\n | Ast_413.Parsetree.Pexp_unreachable -> Ast_412.Parsetree.Pexp_unreachable\n\nand copy_letop : Ast_413.Parsetree.letop -> Ast_412.Parsetree.letop =\n fun { Ast_413.Parsetree.let_; Ast_413.Parsetree.ands; Ast_413.Parsetree.body } ->\n {\n Ast_412.Parsetree.let_ = copy_binding_op let_;\n Ast_412.Parsetree.ands = List.map copy_binding_op ands;\n Ast_412.Parsetree.body = copy_expression body;\n }\n\nand copy_binding_op :\n Ast_413.Parsetree.binding_op -> Ast_412.Parsetree.binding_op =\n fun {\n Ast_413.Parsetree.pbop_op;\n Ast_413.Parsetree.pbop_pat;\n Ast_413.Parsetree.pbop_exp;\n Ast_413.Parsetree.pbop_loc;\n } ->\n {\n Ast_412.Parsetree.pbop_op = copy_loc (fun x -> x) pbop_op;\n Ast_412.Parsetree.pbop_pat = copy_pattern pbop_pat;\n Ast_412.Parsetree.pbop_exp = copy_expression pbop_exp;\n Ast_412.Parsetree.pbop_loc = copy_location pbop_loc;\n }\n\nand copy_direction_flag :\n Ast_413.Asttypes.direction_flag -> Ast_412.Asttypes.direction_flag =\n function\n | Ast_413.Asttypes.Upto -> Ast_412.Asttypes.Upto\n | Ast_413.Asttypes.Downto -> Ast_412.Asttypes.Downto\n\nand copy_case : Ast_413.Parsetree.case -> Ast_412.Parsetree.case =\n fun {\n Ast_413.Parsetree.pc_lhs;\n Ast_413.Parsetree.pc_guard;\n Ast_413.Parsetree.pc_rhs;\n } ->\n {\n Ast_412.Parsetree.pc_lhs = copy_pattern pc_lhs;\n Ast_412.Parsetree.pc_guard = Option.map copy_expression pc_guard;\n Ast_412.Parsetree.pc_rhs = copy_expression pc_rhs;\n }\n\nand copy_value_binding :\n Ast_413.Parsetree.value_binding -> Ast_412.Parsetree.value_binding =\n fun {\n Ast_413.Parsetree.pvb_pat;\n Ast_413.Parsetree.pvb_expr;\n Ast_413.Parsetree.pvb_attributes;\n Ast_413.Parsetree.pvb_loc;\n } ->\n {\n Ast_412.Parsetree.pvb_pat = copy_pattern pvb_pat;\n Ast_412.Parsetree.pvb_expr = copy_expression pvb_expr;\n Ast_412.Parsetree.pvb_attributes = copy_attributes pvb_attributes;\n Ast_412.Parsetree.pvb_loc = copy_location pvb_loc;\n }\n\nand copy_pattern : Ast_413.Parsetree.pattern -> Ast_412.Parsetree.pattern =\n fun {\n Ast_413.Parsetree.ppat_desc;\n Ast_413.Parsetree.ppat_loc;\n Ast_413.Parsetree.ppat_loc_stack;\n Ast_413.Parsetree.ppat_attributes;\n } ->\n {\n Ast_412.Parsetree.ppat_desc = copy_pattern_desc ppat_desc;\n Ast_412.Parsetree.ppat_loc = copy_location ppat_loc;\n Ast_412.Parsetree.ppat_loc_stack = copy_location_stack ppat_loc_stack;\n Ast_412.Parsetree.ppat_attributes = copy_attributes ppat_attributes;\n }\n\nand copy_pattern_desc :\n Ast_413.Parsetree.pattern_desc -> Ast_412.Parsetree.pattern_desc = function\n | Ast_413.Parsetree.Ppat_any -> Ast_412.Parsetree.Ppat_any\n | Ast_413.Parsetree.Ppat_var x0 ->\n Ast_412.Parsetree.Ppat_var (copy_loc (fun x -> x) x0)\n | Ast_413.Parsetree.Ppat_alias (x0, x1) ->\n Ast_412.Parsetree.Ppat_alias (copy_pattern x0, copy_loc (fun x -> x) x1)\n | Ast_413.Parsetree.Ppat_constant x0 ->\n Ast_412.Parsetree.Ppat_constant (copy_constant x0)\n | Ast_413.Parsetree.Ppat_interval (x0, x1) ->\n Ast_412.Parsetree.Ppat_interval (copy_constant x0, copy_constant x1)\n | Ast_413.Parsetree.Ppat_tuple x0 ->\n Ast_412.Parsetree.Ppat_tuple (List.map copy_pattern x0)\n | Ast_413.Parsetree.Ppat_construct (x0, x1) ->\n Ast_412.Parsetree.Ppat_construct\n ( copy_loc copy_Longident_t x0,\n Option.map\n (fun x ->\n let x0, x1 = x in\n (match x0 with\n | [] -> ()\n | ty :: _ ->\n migration_error ty.Ast_413.Asttypes.loc\n \"existentials in pattern-matching\");\n copy_pattern x1)\n x1 )\n | Ast_413.Parsetree.Ppat_variant (x0, x1) ->\n Ast_412.Parsetree.Ppat_variant (copy_label x0, Option.map copy_pattern x1)\n | Ast_413.Parsetree.Ppat_record (x0, x1) ->\n Ast_412.Parsetree.Ppat_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_pattern x1))\n x0,\n copy_closed_flag x1 )\n | Ast_413.Parsetree.Ppat_array x0 ->\n Ast_412.Parsetree.Ppat_array (List.map copy_pattern x0)\n | Ast_413.Parsetree.Ppat_or (x0, x1) ->\n Ast_412.Parsetree.Ppat_or (copy_pattern x0, copy_pattern x1)\n | Ast_413.Parsetree.Ppat_constraint (x0, x1) ->\n Ast_412.Parsetree.Ppat_constraint (copy_pattern x0, copy_core_type x1)\n | Ast_413.Parsetree.Ppat_type x0 ->\n Ast_412.Parsetree.Ppat_type (copy_loc copy_Longident_t x0)\n | Ast_413.Parsetree.Ppat_lazy x0 ->\n Ast_412.Parsetree.Ppat_lazy (copy_pattern x0)\n | Ast_413.Parsetree.Ppat_unpack x0 ->\n Ast_412.Parsetree.Ppat_unpack\n (copy_loc (fun x -> Option.map (fun x -> x) x) x0)\n | Ast_413.Parsetree.Ppat_exception x0 ->\n Ast_412.Parsetree.Ppat_exception (copy_pattern x0)\n | Ast_413.Parsetree.Ppat_extension x0 ->\n Ast_412.Parsetree.Ppat_extension (copy_extension x0)\n | Ast_413.Parsetree.Ppat_open (x0, x1) ->\n Ast_412.Parsetree.Ppat_open (copy_loc copy_Longident_t x0, copy_pattern x1)\n\nand copy_core_type : Ast_413.Parsetree.core_type -> Ast_412.Parsetree.core_type\n =\n fun {\n Ast_413.Parsetree.ptyp_desc;\n Ast_413.Parsetree.ptyp_loc;\n Ast_413.Parsetree.ptyp_loc_stack;\n Ast_413.Parsetree.ptyp_attributes;\n } ->\n {\n Ast_412.Parsetree.ptyp_desc = copy_core_type_desc ptyp_desc;\n Ast_412.Parsetree.ptyp_loc = copy_location ptyp_loc;\n Ast_412.Parsetree.ptyp_loc_stack = copy_location_stack ptyp_loc_stack;\n Ast_412.Parsetree.ptyp_attributes = copy_attributes ptyp_attributes;\n }\n\nand copy_location_stack :\n Ast_413.Parsetree.location_stack -> Ast_412.Parsetree.location_stack =\n fun x -> List.map copy_location x\n\nand copy_core_type_desc :\n Ast_413.Parsetree.core_type_desc -> Ast_412.Parsetree.core_type_desc =\n function\n | Ast_413.Parsetree.Ptyp_any -> Ast_412.Parsetree.Ptyp_any\n | Ast_413.Parsetree.Ptyp_var x0 -> Ast_412.Parsetree.Ptyp_var x0\n | Ast_413.Parsetree.Ptyp_arrow (x0, x1, x2) ->\n Ast_412.Parsetree.Ptyp_arrow\n (copy_arg_label x0, copy_core_type x1, copy_core_type x2)\n | Ast_413.Parsetree.Ptyp_tuple x0 ->\n Ast_412.Parsetree.Ptyp_tuple (List.map copy_core_type x0)\n | Ast_413.Parsetree.Ptyp_constr (x0, x1) ->\n Ast_412.Parsetree.Ptyp_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_413.Parsetree.Ptyp_object (x0, x1) ->\n Ast_412.Parsetree.Ptyp_object\n (List.map copy_object_field x0, copy_closed_flag x1)\n | Ast_413.Parsetree.Ptyp_class (x0, x1) ->\n Ast_412.Parsetree.Ptyp_class\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_413.Parsetree.Ptyp_alias (x0, x1) ->\n Ast_412.Parsetree.Ptyp_alias (copy_core_type x0, x1)\n | Ast_413.Parsetree.Ptyp_variant (x0, x1, x2) ->\n Ast_412.Parsetree.Ptyp_variant\n ( List.map copy_row_field x0,\n copy_closed_flag x1,\n Option.map (fun x -> List.map copy_label x) x2 )\n | Ast_413.Parsetree.Ptyp_poly (x0, x1) ->\n Ast_412.Parsetree.Ptyp_poly\n (List.map (fun x -> copy_loc (fun x -> x) x) x0, copy_core_type x1)\n | Ast_413.Parsetree.Ptyp_package x0 ->\n Ast_412.Parsetree.Ptyp_package (copy_package_type x0)\n | Ast_413.Parsetree.Ptyp_extension x0 ->\n Ast_412.Parsetree.Ptyp_extension (copy_extension x0)\n\nand copy_package_type :\n Ast_413.Parsetree.package_type -> Ast_412.Parsetree.package_type =\n fun x ->\n let x0, x1 = x in\n ( copy_loc copy_Longident_t x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_core_type x1))\n x1 )\n\nand copy_row_field : Ast_413.Parsetree.row_field -> Ast_412.Parsetree.row_field\n =\n fun {\n Ast_413.Parsetree.prf_desc;\n Ast_413.Parsetree.prf_loc;\n Ast_413.Parsetree.prf_attributes;\n } ->\n {\n Ast_412.Parsetree.prf_desc = copy_row_field_desc prf_desc;\n Ast_412.Parsetree.prf_loc = copy_location prf_loc;\n Ast_412.Parsetree.prf_attributes = copy_attributes prf_attributes;\n }\n\nand copy_row_field_desc :\n Ast_413.Parsetree.row_field_desc -> Ast_412.Parsetree.row_field_desc =\n function\n | Ast_413.Parsetree.Rtag (x0, x1, x2) ->\n Ast_412.Parsetree.Rtag\n (copy_loc copy_label x0, x1, List.map copy_core_type x2)\n | Ast_413.Parsetree.Rinherit x0 ->\n Ast_412.Parsetree.Rinherit (copy_core_type x0)\n\nand copy_object_field :\n Ast_413.Parsetree.object_field -> Ast_412.Parsetree.object_field =\n fun {\n Ast_413.Parsetree.pof_desc;\n Ast_413.Parsetree.pof_loc;\n Ast_413.Parsetree.pof_attributes;\n } ->\n {\n Ast_412.Parsetree.pof_desc = copy_object_field_desc pof_desc;\n Ast_412.Parsetree.pof_loc = copy_location pof_loc;\n Ast_412.Parsetree.pof_attributes = copy_attributes pof_attributes;\n }\n\nand copy_attributes :\n Ast_413.Parsetree.attributes -> Ast_412.Parsetree.attributes =\n fun x -> List.map copy_attribute x\n\nand copy_attribute : Ast_413.Parsetree.attribute -> Ast_412.Parsetree.attribute\n =\n fun {\n Ast_413.Parsetree.attr_name;\n Ast_413.Parsetree.attr_payload;\n Ast_413.Parsetree.attr_loc;\n } ->\n {\n Ast_412.Parsetree.attr_name = copy_loc (fun x -> x) attr_name;\n Ast_412.Parsetree.attr_payload = copy_payload attr_payload;\n Ast_412.Parsetree.attr_loc = copy_location attr_loc;\n }\n\nand copy_payload : Ast_413.Parsetree.payload -> Ast_412.Parsetree.payload =\n function\n | Ast_413.Parsetree.PStr x0 -> Ast_412.Parsetree.PStr (copy_structure x0)\n | Ast_413.Parsetree.PSig x0 -> Ast_412.Parsetree.PSig (copy_signature x0)\n | Ast_413.Parsetree.PTyp x0 -> Ast_412.Parsetree.PTyp (copy_core_type x0)\n | Ast_413.Parsetree.PPat (x0, x1) ->\n Ast_412.Parsetree.PPat (copy_pattern x0, Option.map copy_expression x1)\n\nand copy_structure : Ast_413.Parsetree.structure -> Ast_412.Parsetree.structure\n =\n fun x -> List.map copy_structure_item x\n\nand copy_structure_item :\n Ast_413.Parsetree.structure_item -> Ast_412.Parsetree.structure_item =\n fun { Ast_413.Parsetree.pstr_desc; Ast_413.Parsetree.pstr_loc } ->\n {\n Ast_412.Parsetree.pstr_desc = copy_structure_item_desc pstr_desc;\n Ast_412.Parsetree.pstr_loc = copy_location pstr_loc;\n }\n\nand copy_structure_item_desc :\n Ast_413.Parsetree.structure_item_desc ->\n Ast_412.Parsetree.structure_item_desc = function\n | Ast_413.Parsetree.Pstr_eval (x0, x1) ->\n Ast_412.Parsetree.Pstr_eval (copy_expression x0, copy_attributes x1)\n | Ast_413.Parsetree.Pstr_value (x0, x1) ->\n Ast_412.Parsetree.Pstr_value\n (copy_rec_flag x0, List.map copy_value_binding x1)\n | Ast_413.Parsetree.Pstr_primitive x0 ->\n Ast_412.Parsetree.Pstr_primitive (copy_value_description x0)\n | Ast_413.Parsetree.Pstr_type (x0, x1) ->\n Ast_412.Parsetree.Pstr_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | Ast_413.Parsetree.Pstr_typext x0 ->\n Ast_412.Parsetree.Pstr_typext (copy_type_extension x0)\n | Ast_413.Parsetree.Pstr_exception x0 ->\n Ast_412.Parsetree.Pstr_exception (copy_type_exception x0)\n | Ast_413.Parsetree.Pstr_module x0 ->\n Ast_412.Parsetree.Pstr_module (copy_module_binding x0)\n | Ast_413.Parsetree.Pstr_recmodule x0 ->\n Ast_412.Parsetree.Pstr_recmodule (List.map copy_module_binding x0)\n | Ast_413.Parsetree.Pstr_modtype x0 ->\n Ast_412.Parsetree.Pstr_modtype (copy_module_type_declaration x0)\n | Ast_413.Parsetree.Pstr_open x0 ->\n Ast_412.Parsetree.Pstr_open (copy_open_declaration x0)\n | Ast_413.Parsetree.Pstr_class x0 ->\n Ast_412.Parsetree.Pstr_class (List.map copy_class_declaration x0)\n | Ast_413.Parsetree.Pstr_class_type x0 ->\n Ast_412.Parsetree.Pstr_class_type\n (List.map copy_class_type_declaration x0)\n | Ast_413.Parsetree.Pstr_include x0 ->\n Ast_412.Parsetree.Pstr_include (copy_include_declaration x0)\n | Ast_413.Parsetree.Pstr_attribute x0 ->\n Ast_412.Parsetree.Pstr_attribute (copy_attribute x0)\n | Ast_413.Parsetree.Pstr_extension (x0, x1) ->\n Ast_412.Parsetree.Pstr_extension (copy_extension x0, copy_attributes x1)\n\nand copy_include_declaration :\n Ast_413.Parsetree.include_declaration ->\n Ast_412.Parsetree.include_declaration =\n fun x -> copy_include_infos copy_module_expr x\n\nand copy_class_declaration :\n Ast_413.Parsetree.class_declaration -> Ast_412.Parsetree.class_declaration =\n fun x -> copy_class_infos copy_class_expr x\n\nand copy_class_expr :\n Ast_413.Parsetree.class_expr -> Ast_412.Parsetree.class_expr =\n fun {\n Ast_413.Parsetree.pcl_desc;\n Ast_413.Parsetree.pcl_loc;\n Ast_413.Parsetree.pcl_attributes;\n } ->\n {\n Ast_412.Parsetree.pcl_desc = copy_class_expr_desc pcl_desc;\n Ast_412.Parsetree.pcl_loc = copy_location pcl_loc;\n Ast_412.Parsetree.pcl_attributes = copy_attributes pcl_attributes;\n }\n\nand copy_class_expr_desc :\n Ast_413.Parsetree.class_expr_desc -> Ast_412.Parsetree.class_expr_desc =\n function\n | Ast_413.Parsetree.Pcl_constr (x0, x1) ->\n Ast_412.Parsetree.Pcl_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_413.Parsetree.Pcl_structure x0 ->\n Ast_412.Parsetree.Pcl_structure (copy_class_structure x0)\n | Ast_413.Parsetree.Pcl_fun (x0, x1, x2, x3) ->\n Ast_412.Parsetree.Pcl_fun\n ( copy_arg_label x0,\n Option.map copy_expression x1,\n copy_pattern x2,\n copy_class_expr x3 )\n | Ast_413.Parsetree.Pcl_apply (x0, x1) ->\n Ast_412.Parsetree.Pcl_apply\n ( copy_class_expr x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | Ast_413.Parsetree.Pcl_let (x0, x1, x2) ->\n Ast_412.Parsetree.Pcl_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_class_expr x2)\n | Ast_413.Parsetree.Pcl_constraint (x0, x1) ->\n Ast_412.Parsetree.Pcl_constraint (copy_class_expr x0, copy_class_type x1)\n | Ast_413.Parsetree.Pcl_extension x0 ->\n Ast_412.Parsetree.Pcl_extension (copy_extension x0)\n | Ast_413.Parsetree.Pcl_open (x0, x1) ->\n Ast_412.Parsetree.Pcl_open (copy_open_description x0, copy_class_expr x1)\n\nand copy_class_structure :\n Ast_413.Parsetree.class_structure -> Ast_412.Parsetree.class_structure =\n fun { Ast_413.Parsetree.pcstr_self; Ast_413.Parsetree.pcstr_fields } ->\n {\n Ast_412.Parsetree.pcstr_self = copy_pattern pcstr_self;\n Ast_412.Parsetree.pcstr_fields = List.map copy_class_field pcstr_fields;\n }\n\nand copy_class_field :\n Ast_413.Parsetree.class_field -> Ast_412.Parsetree.class_field =\n fun {\n Ast_413.Parsetree.pcf_desc;\n Ast_413.Parsetree.pcf_loc;\n Ast_413.Parsetree.pcf_attributes;\n } ->\n {\n Ast_412.Parsetree.pcf_desc = copy_class_field_desc pcf_desc;\n Ast_412.Parsetree.pcf_loc = copy_location pcf_loc;\n Ast_412.Parsetree.pcf_attributes = copy_attributes pcf_attributes;\n }\n\nand copy_class_field_desc :\n Ast_413.Parsetree.class_field_desc -> Ast_412.Parsetree.class_field_desc =\n function\n | Ast_413.Parsetree.Pcf_inherit (x0, x1, x2) ->\n Ast_412.Parsetree.Pcf_inherit\n ( copy_override_flag x0,\n copy_class_expr x1,\n Option.map (fun x -> copy_loc (fun x -> x) x) x2 )\n | Ast_413.Parsetree.Pcf_val x0 ->\n Ast_412.Parsetree.Pcf_val\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_mutable_flag x1, copy_class_field_kind x2))\n | Ast_413.Parsetree.Pcf_method x0 ->\n Ast_412.Parsetree.Pcf_method\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_private_flag x1, copy_class_field_kind x2))\n | Ast_413.Parsetree.Pcf_constraint x0 ->\n Ast_412.Parsetree.Pcf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | Ast_413.Parsetree.Pcf_initializer x0 ->\n Ast_412.Parsetree.Pcf_initializer (copy_expression x0)\n | Ast_413.Parsetree.Pcf_attribute x0 ->\n Ast_412.Parsetree.Pcf_attribute (copy_attribute x0)\n | Ast_413.Parsetree.Pcf_extension x0 ->\n Ast_412.Parsetree.Pcf_extension (copy_extension x0)\n\nand copy_class_field_kind :\n Ast_413.Parsetree.class_field_kind -> Ast_412.Parsetree.class_field_kind =\n function\n | Ast_413.Parsetree.Cfk_virtual x0 ->\n Ast_412.Parsetree.Cfk_virtual (copy_core_type x0)\n | Ast_413.Parsetree.Cfk_concrete (x0, x1) ->\n Ast_412.Parsetree.Cfk_concrete (copy_override_flag x0, copy_expression x1)\n\nand copy_open_declaration :\n Ast_413.Parsetree.open_declaration -> Ast_412.Parsetree.open_declaration =\n fun x -> copy_open_infos copy_module_expr x\n\nand copy_module_binding :\n Ast_413.Parsetree.module_binding -> Ast_412.Parsetree.module_binding =\n fun {\n Ast_413.Parsetree.pmb_name;\n Ast_413.Parsetree.pmb_expr;\n Ast_413.Parsetree.pmb_attributes;\n Ast_413.Parsetree.pmb_loc;\n } ->\n {\n Ast_412.Parsetree.pmb_name =\n copy_loc (fun x -> Option.map (fun x -> x) x) pmb_name;\n Ast_412.Parsetree.pmb_expr = copy_module_expr pmb_expr;\n Ast_412.Parsetree.pmb_attributes = copy_attributes pmb_attributes;\n Ast_412.Parsetree.pmb_loc = copy_location pmb_loc;\n }\n\nand copy_module_expr :\n Ast_413.Parsetree.module_expr -> Ast_412.Parsetree.module_expr =\n fun {\n Ast_413.Parsetree.pmod_desc;\n Ast_413.Parsetree.pmod_loc;\n Ast_413.Parsetree.pmod_attributes;\n } ->\n {\n Ast_412.Parsetree.pmod_desc = copy_module_expr_desc pmod_desc;\n Ast_412.Parsetree.pmod_loc = copy_location pmod_loc;\n Ast_412.Parsetree.pmod_attributes = copy_attributes pmod_attributes;\n }\n\nand copy_module_expr_desc :\n Ast_413.Parsetree.module_expr_desc -> Ast_412.Parsetree.module_expr_desc =\n function\n | Ast_413.Parsetree.Pmod_ident x0 ->\n Ast_412.Parsetree.Pmod_ident (copy_loc copy_Longident_t x0)\n | Ast_413.Parsetree.Pmod_structure x0 ->\n Ast_412.Parsetree.Pmod_structure (copy_structure x0)\n | Ast_413.Parsetree.Pmod_functor (x0, x1) ->\n Ast_412.Parsetree.Pmod_functor\n (copy_functor_parameter x0, copy_module_expr x1)\n | Ast_413.Parsetree.Pmod_apply (x0, x1) ->\n Ast_412.Parsetree.Pmod_apply (copy_module_expr x0, copy_module_expr x1)\n | Ast_413.Parsetree.Pmod_constraint (x0, x1) ->\n Ast_412.Parsetree.Pmod_constraint\n (copy_module_expr x0, copy_module_type x1)\n | Ast_413.Parsetree.Pmod_unpack x0 ->\n Ast_412.Parsetree.Pmod_unpack (copy_expression x0)\n | Ast_413.Parsetree.Pmod_extension x0 ->\n Ast_412.Parsetree.Pmod_extension (copy_extension x0)\n\nand copy_functor_parameter :\n Ast_413.Parsetree.functor_parameter -> Ast_412.Parsetree.functor_parameter =\n function\n | Ast_413.Parsetree.Unit -> Ast_412.Parsetree.Unit\n | Ast_413.Parsetree.Named (x0, x1) ->\n Ast_412.Parsetree.Named\n (copy_loc (fun x -> Option.map (fun x -> x) x) x0, copy_module_type x1)\n\nand copy_module_type :\n Ast_413.Parsetree.module_type -> Ast_412.Parsetree.module_type =\n fun {\n Ast_413.Parsetree.pmty_desc;\n Ast_413.Parsetree.pmty_loc;\n Ast_413.Parsetree.pmty_attributes;\n } ->\n {\n Ast_412.Parsetree.pmty_desc = copy_module_type_desc pmty_desc;\n Ast_412.Parsetree.pmty_loc = copy_location pmty_loc;\n Ast_412.Parsetree.pmty_attributes = copy_attributes pmty_attributes;\n }\n\nand copy_module_type_desc :\n Ast_413.Parsetree.module_type_desc -> Ast_412.Parsetree.module_type_desc =\n function\n | Ast_413.Parsetree.Pmty_ident x0 ->\n Ast_412.Parsetree.Pmty_ident (copy_loc copy_Longident_t x0)\n | Ast_413.Parsetree.Pmty_signature x0 ->\n Ast_412.Parsetree.Pmty_signature (copy_signature x0)\n | Ast_413.Parsetree.Pmty_functor (x0, x1) ->\n Ast_412.Parsetree.Pmty_functor\n (copy_functor_parameter x0, copy_module_type x1)\n | Ast_413.Parsetree.Pmty_with (x0, x1) ->\n Ast_412.Parsetree.Pmty_with\n (copy_module_type x0, List.map copy_with_constraint x1)\n | Ast_413.Parsetree.Pmty_typeof x0 ->\n Ast_412.Parsetree.Pmty_typeof (copy_module_expr x0)\n | Ast_413.Parsetree.Pmty_extension x0 ->\n Ast_412.Parsetree.Pmty_extension (copy_extension x0)\n | Ast_413.Parsetree.Pmty_alias x0 ->\n Ast_412.Parsetree.Pmty_alias (copy_loc copy_Longident_t x0)\n\nand copy_with_constraint :\n Ast_413.Parsetree.with_constraint -> Ast_412.Parsetree.with_constraint =\n function\n | Ast_413.Parsetree.Pwith_type (x0, x1) ->\n Ast_412.Parsetree.Pwith_type\n (copy_loc copy_Longident_t x0, copy_type_declaration x1)\n | Ast_413.Parsetree.Pwith_module (x0, x1) ->\n Ast_412.Parsetree.Pwith_module\n (copy_loc copy_Longident_t x0, copy_loc copy_Longident_t x1)\n | Ast_413.Parsetree.Pwith_modtype (_x0, x1) ->\n migration_error x1.Ast_413.Parsetree.pmty_loc \"module type substitution\"\n | Ast_413.Parsetree.Pwith_modtypesubst (_x0, x1) ->\n migration_error x1.Ast_413.Parsetree.pmty_loc\n \"destructive module type substitution\"\n | Ast_413.Parsetree.Pwith_typesubst (x0, x1) ->\n Ast_412.Parsetree.Pwith_typesubst\n (copy_loc copy_Longident_t x0, copy_type_declaration x1)\n | Ast_413.Parsetree.Pwith_modsubst (x0, x1) ->\n Ast_412.Parsetree.Pwith_modsubst\n (copy_loc copy_Longident_t x0, copy_loc copy_Longident_t x1)\n\nand copy_signature : Ast_413.Parsetree.signature -> Ast_412.Parsetree.signature\n =\n fun x -> List.map copy_signature_item x\n\nand copy_signature_item :\n Ast_413.Parsetree.signature_item -> Ast_412.Parsetree.signature_item =\n fun { Ast_413.Parsetree.psig_desc; Ast_413.Parsetree.psig_loc } ->\n {\n Ast_412.Parsetree.psig_desc = copy_signature_item_desc psig_desc;\n Ast_412.Parsetree.psig_loc = copy_location psig_loc;\n }\n\nand copy_signature_item_desc :\n Ast_413.Parsetree.signature_item_desc ->\n Ast_412.Parsetree.signature_item_desc = function\n | Ast_413.Parsetree.Psig_value x0 ->\n Ast_412.Parsetree.Psig_value (copy_value_description x0)\n | Ast_413.Parsetree.Psig_type (x0, x1) ->\n Ast_412.Parsetree.Psig_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | Ast_413.Parsetree.Psig_typesubst x0 ->\n Ast_412.Parsetree.Psig_typesubst (List.map copy_type_declaration x0)\n | Ast_413.Parsetree.Psig_typext x0 ->\n Ast_412.Parsetree.Psig_typext (copy_type_extension x0)\n | Ast_413.Parsetree.Psig_exception x0 ->\n Ast_412.Parsetree.Psig_exception (copy_type_exception x0)\n | Ast_413.Parsetree.Psig_module x0 ->\n Ast_412.Parsetree.Psig_module (copy_module_declaration x0)\n | Ast_413.Parsetree.Psig_modsubst x0 ->\n Ast_412.Parsetree.Psig_modsubst (copy_module_substitution x0)\n | Ast_413.Parsetree.Psig_recmodule x0 ->\n Ast_412.Parsetree.Psig_recmodule (List.map copy_module_declaration x0)\n | Ast_413.Parsetree.Psig_modtype x0 ->\n Ast_412.Parsetree.Psig_modtype (copy_module_type_declaration x0)\n | Ast_413.Parsetree.Psig_modtypesubst x0 ->\n migration_error x0.Ast_413.Parsetree.pmtd_loc\n \"local module type substitution\"\n | Ast_413.Parsetree.Psig_open x0 ->\n Ast_412.Parsetree.Psig_open (copy_open_description x0)\n | Ast_413.Parsetree.Psig_include x0 ->\n Ast_412.Parsetree.Psig_include (copy_include_description x0)\n | Ast_413.Parsetree.Psig_class x0 ->\n Ast_412.Parsetree.Psig_class (List.map copy_class_description x0)\n | Ast_413.Parsetree.Psig_class_type x0 ->\n Ast_412.Parsetree.Psig_class_type\n (List.map copy_class_type_declaration x0)\n | Ast_413.Parsetree.Psig_attribute x0 ->\n Ast_412.Parsetree.Psig_attribute (copy_attribute x0)\n | Ast_413.Parsetree.Psig_extension (x0, x1) ->\n Ast_412.Parsetree.Psig_extension (copy_extension x0, copy_attributes x1)\n\nand copy_class_type_declaration :\n Ast_413.Parsetree.class_type_declaration ->\n Ast_412.Parsetree.class_type_declaration =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_description :\n Ast_413.Parsetree.class_description -> Ast_412.Parsetree.class_description =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_type :\n Ast_413.Parsetree.class_type -> Ast_412.Parsetree.class_type =\n fun {\n Ast_413.Parsetree.pcty_desc;\n Ast_413.Parsetree.pcty_loc;\n Ast_413.Parsetree.pcty_attributes;\n } ->\n {\n Ast_412.Parsetree.pcty_desc = copy_class_type_desc pcty_desc;\n Ast_412.Parsetree.pcty_loc = copy_location pcty_loc;\n Ast_412.Parsetree.pcty_attributes = copy_attributes pcty_attributes;\n }\n\nand copy_class_type_desc :\n Ast_413.Parsetree.class_type_desc -> Ast_412.Parsetree.class_type_desc =\n function\n | Ast_413.Parsetree.Pcty_constr (x0, x1) ->\n Ast_412.Parsetree.Pcty_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_413.Parsetree.Pcty_signature x0 ->\n Ast_412.Parsetree.Pcty_signature (copy_class_signature x0)\n | Ast_413.Parsetree.Pcty_arrow (x0, x1, x2) ->\n Ast_412.Parsetree.Pcty_arrow\n (copy_arg_label x0, copy_core_type x1, copy_class_type x2)\n | Ast_413.Parsetree.Pcty_extension x0 ->\n Ast_412.Parsetree.Pcty_extension (copy_extension x0)\n | Ast_413.Parsetree.Pcty_open (x0, x1) ->\n Ast_412.Parsetree.Pcty_open (copy_open_description x0, copy_class_type x1)\n\nand copy_class_signature :\n Ast_413.Parsetree.class_signature -> Ast_412.Parsetree.class_signature =\n fun { Ast_413.Parsetree.pcsig_self; Ast_413.Parsetree.pcsig_fields } ->\n {\n Ast_412.Parsetree.pcsig_self = copy_core_type pcsig_self;\n Ast_412.Parsetree.pcsig_fields = List.map copy_class_type_field pcsig_fields;\n }\n\nand copy_class_type_field :\n Ast_413.Parsetree.class_type_field -> Ast_412.Parsetree.class_type_field =\n fun {\n Ast_413.Parsetree.pctf_desc;\n Ast_413.Parsetree.pctf_loc;\n Ast_413.Parsetree.pctf_attributes;\n } ->\n {\n Ast_412.Parsetree.pctf_desc = copy_class_type_field_desc pctf_desc;\n Ast_412.Parsetree.pctf_loc = copy_location pctf_loc;\n Ast_412.Parsetree.pctf_attributes = copy_attributes pctf_attributes;\n }\n\nand copy_class_type_field_desc :\n Ast_413.Parsetree.class_type_field_desc ->\n Ast_412.Parsetree.class_type_field_desc = function\n | Ast_413.Parsetree.Pctf_inherit x0 ->\n Ast_412.Parsetree.Pctf_inherit (copy_class_type x0)\n | Ast_413.Parsetree.Pctf_val x0 ->\n Ast_412.Parsetree.Pctf_val\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_mutable_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | Ast_413.Parsetree.Pctf_method x0 ->\n Ast_412.Parsetree.Pctf_method\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_private_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | Ast_413.Parsetree.Pctf_constraint x0 ->\n Ast_412.Parsetree.Pctf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | Ast_413.Parsetree.Pctf_attribute x0 ->\n Ast_412.Parsetree.Pctf_attribute (copy_attribute x0)\n | Ast_413.Parsetree.Pctf_extension x0 ->\n Ast_412.Parsetree.Pctf_extension (copy_extension x0)\n\nand copy_extension : Ast_413.Parsetree.extension -> Ast_412.Parsetree.extension\n =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_class_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_413.Parsetree.class_infos ->\n 'g0 Ast_412.Parsetree.class_infos =\n fun f0\n {\n Ast_413.Parsetree.pci_virt;\n Ast_413.Parsetree.pci_params;\n Ast_413.Parsetree.pci_name;\n Ast_413.Parsetree.pci_expr;\n Ast_413.Parsetree.pci_loc;\n Ast_413.Parsetree.pci_attributes;\n } ->\n {\n Ast_412.Parsetree.pci_virt = copy_virtual_flag pci_virt;\n Ast_412.Parsetree.pci_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n ( copy_core_type x0,\n let x0, x1 = x1 in\n (copy_variance x0, copy_injectivity x1) ))\n pci_params;\n Ast_412.Parsetree.pci_name = copy_loc (fun x -> x) pci_name;\n Ast_412.Parsetree.pci_expr = f0 pci_expr;\n Ast_412.Parsetree.pci_loc = copy_location pci_loc;\n Ast_412.Parsetree.pci_attributes = copy_attributes pci_attributes;\n }\n\nand copy_virtual_flag :\n Ast_413.Asttypes.virtual_flag -> Ast_412.Asttypes.virtual_flag = function\n | Ast_413.Asttypes.Virtual -> Ast_412.Asttypes.Virtual\n | Ast_413.Asttypes.Concrete -> Ast_412.Asttypes.Concrete\n\nand copy_include_description :\n Ast_413.Parsetree.include_description ->\n Ast_412.Parsetree.include_description =\n fun x -> copy_include_infos copy_module_type x\n\nand copy_include_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_413.Parsetree.include_infos ->\n 'g0 Ast_412.Parsetree.include_infos =\n fun f0\n {\n Ast_413.Parsetree.pincl_mod;\n Ast_413.Parsetree.pincl_loc;\n Ast_413.Parsetree.pincl_attributes;\n } ->\n {\n Ast_412.Parsetree.pincl_mod = f0 pincl_mod;\n Ast_412.Parsetree.pincl_loc = copy_location pincl_loc;\n Ast_412.Parsetree.pincl_attributes = copy_attributes pincl_attributes;\n }\n\nand copy_open_description :\n Ast_413.Parsetree.open_description -> Ast_412.Parsetree.open_description =\n fun x -> copy_open_infos (fun x -> copy_loc copy_Longident_t x) x\n\nand copy_open_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_413.Parsetree.open_infos ->\n 'g0 Ast_412.Parsetree.open_infos =\n fun f0\n {\n Ast_413.Parsetree.popen_expr;\n Ast_413.Parsetree.popen_override;\n Ast_413.Parsetree.popen_loc;\n Ast_413.Parsetree.popen_attributes;\n } ->\n {\n Ast_412.Parsetree.popen_expr = f0 popen_expr;\n Ast_412.Parsetree.popen_override = copy_override_flag popen_override;\n Ast_412.Parsetree.popen_loc = copy_location popen_loc;\n Ast_412.Parsetree.popen_attributes = copy_attributes popen_attributes;\n }\n\nand copy_override_flag :\n Ast_413.Asttypes.override_flag -> Ast_412.Asttypes.override_flag = function\n | Ast_413.Asttypes.Override -> Ast_412.Asttypes.Override\n | Ast_413.Asttypes.Fresh -> Ast_412.Asttypes.Fresh\n\nand copy_module_type_declaration :\n Ast_413.Parsetree.module_type_declaration ->\n Ast_412.Parsetree.module_type_declaration =\n fun {\n Ast_413.Parsetree.pmtd_name;\n Ast_413.Parsetree.pmtd_type;\n Ast_413.Parsetree.pmtd_attributes;\n Ast_413.Parsetree.pmtd_loc;\n } ->\n {\n Ast_412.Parsetree.pmtd_name = copy_loc (fun x -> x) pmtd_name;\n Ast_412.Parsetree.pmtd_type = Option.map copy_module_type pmtd_type;\n Ast_412.Parsetree.pmtd_attributes = copy_attributes pmtd_attributes;\n Ast_412.Parsetree.pmtd_loc = copy_location pmtd_loc;\n }\n\nand copy_module_substitution :\n Ast_413.Parsetree.module_substitution ->\n Ast_412.Parsetree.module_substitution =\n fun {\n Ast_413.Parsetree.pms_name;\n Ast_413.Parsetree.pms_manifest;\n Ast_413.Parsetree.pms_attributes;\n Ast_413.Parsetree.pms_loc;\n } ->\n {\n Ast_412.Parsetree.pms_name = copy_loc (fun x -> x) pms_name;\n Ast_412.Parsetree.pms_manifest = copy_loc copy_Longident_t pms_manifest;\n Ast_412.Parsetree.pms_attributes = copy_attributes pms_attributes;\n Ast_412.Parsetree.pms_loc = copy_location pms_loc;\n }\n\nand copy_module_declaration :\n Ast_413.Parsetree.module_declaration -> Ast_412.Parsetree.module_declaration\n =\n fun {\n Ast_413.Parsetree.pmd_name;\n Ast_413.Parsetree.pmd_type;\n Ast_413.Parsetree.pmd_attributes;\n Ast_413.Parsetree.pmd_loc;\n } ->\n {\n Ast_412.Parsetree.pmd_name =\n copy_loc (fun x -> Option.map (fun x -> x) x) pmd_name;\n Ast_412.Parsetree.pmd_type = copy_module_type pmd_type;\n Ast_412.Parsetree.pmd_attributes = copy_attributes pmd_attributes;\n Ast_412.Parsetree.pmd_loc = copy_location pmd_loc;\n }\n\nand copy_type_exception :\n Ast_413.Parsetree.type_exception -> Ast_412.Parsetree.type_exception =\n fun {\n Ast_413.Parsetree.ptyexn_constructor;\n Ast_413.Parsetree.ptyexn_loc;\n Ast_413.Parsetree.ptyexn_attributes;\n } ->\n {\n Ast_412.Parsetree.ptyexn_constructor =\n copy_extension_constructor ptyexn_constructor;\n Ast_412.Parsetree.ptyexn_loc = copy_location ptyexn_loc;\n Ast_412.Parsetree.ptyexn_attributes = copy_attributes ptyexn_attributes;\n }\n\nand copy_type_extension :\n Ast_413.Parsetree.type_extension -> Ast_412.Parsetree.type_extension =\n fun {\n Ast_413.Parsetree.ptyext_path;\n Ast_413.Parsetree.ptyext_params;\n Ast_413.Parsetree.ptyext_constructors;\n Ast_413.Parsetree.ptyext_private;\n Ast_413.Parsetree.ptyext_loc;\n Ast_413.Parsetree.ptyext_attributes;\n } ->\n {\n Ast_412.Parsetree.ptyext_path = copy_loc copy_Longident_t ptyext_path;\n Ast_412.Parsetree.ptyext_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n ( copy_core_type x0,\n let x0, x1 = x1 in\n (copy_variance x0, copy_injectivity x1) ))\n ptyext_params;\n Ast_412.Parsetree.ptyext_constructors =\n List.map copy_extension_constructor ptyext_constructors;\n Ast_412.Parsetree.ptyext_private = copy_private_flag ptyext_private;\n Ast_412.Parsetree.ptyext_loc = copy_location ptyext_loc;\n Ast_412.Parsetree.ptyext_attributes = copy_attributes ptyext_attributes;\n }\n\nand copy_extension_constructor :\n Ast_413.Parsetree.extension_constructor ->\n Ast_412.Parsetree.extension_constructor =\n fun {\n Ast_413.Parsetree.pext_name;\n Ast_413.Parsetree.pext_kind;\n Ast_413.Parsetree.pext_loc;\n Ast_413.Parsetree.pext_attributes;\n } ->\n {\n Ast_412.Parsetree.pext_name = copy_loc (fun x -> x) pext_name;\n Ast_412.Parsetree.pext_kind = copy_extension_constructor_kind pext_kind;\n Ast_412.Parsetree.pext_loc = copy_location pext_loc;\n Ast_412.Parsetree.pext_attributes = copy_attributes pext_attributes;\n }\n\nand copy_extension_constructor_kind :\n Ast_413.Parsetree.extension_constructor_kind ->\n Ast_412.Parsetree.extension_constructor_kind = function\n | Ast_413.Parsetree.Pext_decl (x0, x1) ->\n Ast_412.Parsetree.Pext_decl\n (copy_constructor_arguments x0, Option.map copy_core_type x1)\n | Ast_413.Parsetree.Pext_rebind x0 ->\n Ast_412.Parsetree.Pext_rebind (copy_loc copy_Longident_t x0)\n\nand copy_type_declaration :\n Ast_413.Parsetree.type_declaration -> Ast_412.Parsetree.type_declaration =\n fun {\n Ast_413.Parsetree.ptype_name;\n Ast_413.Parsetree.ptype_params;\n Ast_413.Parsetree.ptype_cstrs;\n Ast_413.Parsetree.ptype_kind;\n Ast_413.Parsetree.ptype_private;\n Ast_413.Parsetree.ptype_manifest;\n Ast_413.Parsetree.ptype_attributes;\n Ast_413.Parsetree.ptype_loc;\n } ->\n {\n Ast_412.Parsetree.ptype_name = copy_loc (fun x -> x) ptype_name;\n Ast_412.Parsetree.ptype_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n ( copy_core_type x0,\n let x0, x1 = x1 in\n (copy_variance x0, copy_injectivity x1) ))\n ptype_params;\n Ast_412.Parsetree.ptype_cstrs =\n List.map\n (fun x ->\n let x0, x1, x2 = x in\n (copy_core_type x0, copy_core_type x1, copy_location x2))\n ptype_cstrs;\n Ast_412.Parsetree.ptype_kind = copy_type_kind ptype_kind;\n Ast_412.Parsetree.ptype_private = copy_private_flag ptype_private;\n Ast_412.Parsetree.ptype_manifest = Option.map copy_core_type ptype_manifest;\n Ast_412.Parsetree.ptype_attributes = copy_attributes ptype_attributes;\n Ast_412.Parsetree.ptype_loc = copy_location ptype_loc;\n }\n\nand copy_private_flag :\n Ast_413.Asttypes.private_flag -> Ast_412.Asttypes.private_flag = function\n | Ast_413.Asttypes.Private -> Ast_412.Asttypes.Private\n | Ast_413.Asttypes.Public -> Ast_412.Asttypes.Public\n\nand copy_type_kind : Ast_413.Parsetree.type_kind -> Ast_412.Parsetree.type_kind\n = function\n | Ast_413.Parsetree.Ptype_abstract -> Ast_412.Parsetree.Ptype_abstract\n | Ast_413.Parsetree.Ptype_variant x0 ->\n Ast_412.Parsetree.Ptype_variant (List.map copy_constructor_declaration x0)\n | Ast_413.Parsetree.Ptype_record x0 ->\n Ast_412.Parsetree.Ptype_record (List.map copy_label_declaration x0)\n | Ast_413.Parsetree.Ptype_open -> Ast_412.Parsetree.Ptype_open\n\nand copy_constructor_declaration :\n Ast_413.Parsetree.constructor_declaration ->\n Ast_412.Parsetree.constructor_declaration =\n fun {\n Ast_413.Parsetree.pcd_name;\n Ast_413.Parsetree.pcd_args;\n Ast_413.Parsetree.pcd_res;\n Ast_413.Parsetree.pcd_loc;\n Ast_413.Parsetree.pcd_attributes;\n } ->\n {\n Ast_412.Parsetree.pcd_name = copy_loc (fun x -> x) pcd_name;\n Ast_412.Parsetree.pcd_args = copy_constructor_arguments pcd_args;\n Ast_412.Parsetree.pcd_res = Option.map copy_core_type pcd_res;\n Ast_412.Parsetree.pcd_loc = copy_location pcd_loc;\n Ast_412.Parsetree.pcd_attributes = copy_attributes pcd_attributes;\n }\n\nand copy_constructor_arguments :\n Ast_413.Parsetree.constructor_arguments ->\n Ast_412.Parsetree.constructor_arguments = function\n | Ast_413.Parsetree.Pcstr_tuple x0 ->\n Ast_412.Parsetree.Pcstr_tuple (List.map copy_core_type x0)\n | Ast_413.Parsetree.Pcstr_record x0 ->\n Ast_412.Parsetree.Pcstr_record (List.map copy_label_declaration x0)\n\nand copy_label_declaration :\n Ast_413.Parsetree.label_declaration -> Ast_412.Parsetree.label_declaration =\n fun {\n Ast_413.Parsetree.pld_name;\n Ast_413.Parsetree.pld_mutable;\n Ast_413.Parsetree.pld_type;\n Ast_413.Parsetree.pld_loc;\n Ast_413.Parsetree.pld_attributes;\n } ->\n {\n Ast_412.Parsetree.pld_name = copy_loc (fun x -> x) pld_name;\n Ast_412.Parsetree.pld_mutable = copy_mutable_flag pld_mutable;\n Ast_412.Parsetree.pld_type = copy_core_type pld_type;\n Ast_412.Parsetree.pld_loc = copy_location pld_loc;\n Ast_412.Parsetree.pld_attributes = copy_attributes pld_attributes;\n }\n\nand copy_mutable_flag :\n Ast_413.Asttypes.mutable_flag -> Ast_412.Asttypes.mutable_flag = function\n | Ast_413.Asttypes.Immutable -> Ast_412.Asttypes.Immutable\n | Ast_413.Asttypes.Mutable -> Ast_412.Asttypes.Mutable\n\nand copy_injectivity :\n Ast_413.Asttypes.injectivity -> Ast_412.Asttypes.injectivity = function\n | Ast_413.Asttypes.Injective -> Ast_412.Asttypes.Injective\n | Ast_413.Asttypes.NoInjectivity -> Ast_412.Asttypes.NoInjectivity\n\nand copy_variance : Ast_413.Asttypes.variance -> Ast_412.Asttypes.variance =\n function\n | Ast_413.Asttypes.Covariant -> Ast_412.Asttypes.Covariant\n | Ast_413.Asttypes.Contravariant -> Ast_412.Asttypes.Contravariant\n | Ast_413.Asttypes.NoVariance -> Ast_412.Asttypes.NoVariance\n\nand copy_value_description :\n Ast_413.Parsetree.value_description -> Ast_412.Parsetree.value_description =\n fun {\n Ast_413.Parsetree.pval_name;\n Ast_413.Parsetree.pval_type;\n Ast_413.Parsetree.pval_prim;\n Ast_413.Parsetree.pval_attributes;\n Ast_413.Parsetree.pval_loc;\n } ->\n {\n Ast_412.Parsetree.pval_name = copy_loc (fun x -> x) pval_name;\n Ast_412.Parsetree.pval_type = copy_core_type pval_type;\n Ast_412.Parsetree.pval_prim = List.map (fun x -> x) pval_prim;\n Ast_412.Parsetree.pval_attributes = copy_attributes pval_attributes;\n Ast_412.Parsetree.pval_loc = copy_location pval_loc;\n }\n\nand copy_object_field_desc :\n Ast_413.Parsetree.object_field_desc -> Ast_412.Parsetree.object_field_desc =\n function\n | Ast_413.Parsetree.Otag (x0, x1) ->\n Ast_412.Parsetree.Otag (copy_loc copy_label x0, copy_core_type x1)\n | Ast_413.Parsetree.Oinherit x0 ->\n Ast_412.Parsetree.Oinherit (copy_core_type x0)\n\nand copy_arg_label : Ast_413.Asttypes.arg_label -> Ast_412.Asttypes.arg_label =\n function\n | Ast_413.Asttypes.Nolabel -> Ast_412.Asttypes.Nolabel\n | Ast_413.Asttypes.Labelled x0 -> Ast_412.Asttypes.Labelled x0\n | Ast_413.Asttypes.Optional x0 -> Ast_412.Asttypes.Optional x0\n\nand copy_closed_flag :\n Ast_413.Asttypes.closed_flag -> Ast_412.Asttypes.closed_flag = function\n | Ast_413.Asttypes.Closed -> Ast_412.Asttypes.Closed\n | Ast_413.Asttypes.Open -> Ast_412.Asttypes.Open\n\nand copy_label : Ast_413.Asttypes.label -> Ast_412.Asttypes.label = fun x -> x\n\nand copy_rec_flag : Ast_413.Asttypes.rec_flag -> Ast_412.Asttypes.rec_flag =\n function\n | Ast_413.Asttypes.Nonrecursive -> Ast_412.Asttypes.Nonrecursive\n | Ast_413.Asttypes.Recursive -> Ast_412.Asttypes.Recursive\n\nand copy_constant : Ast_413.Parsetree.constant -> Ast_412.Parsetree.constant =\n function\n | Ast_413.Parsetree.Pconst_integer (x0, x1) ->\n Ast_412.Parsetree.Pconst_integer (x0, Option.map (fun x -> x) x1)\n | Ast_413.Parsetree.Pconst_char x0 -> Ast_412.Parsetree.Pconst_char x0\n | Ast_413.Parsetree.Pconst_string (x0, x1, x2) ->\n Ast_412.Parsetree.Pconst_string\n (x0, copy_location x1, Option.map (fun x -> x) x2)\n | Ast_413.Parsetree.Pconst_float (x0, x1) ->\n Ast_412.Parsetree.Pconst_float (x0, Option.map (fun x -> x) x1)\n\nand copy_Longident_t : Longident.t -> Longident.t = fun x -> x\n\nand copy_loc :\n 'f0 'g0.\n ('f0 -> 'g0) -> 'f0 Ast_413.Asttypes.loc -> 'g0 Ast_412.Asttypes.loc =\n fun f0 { Ast_413.Asttypes.txt; Ast_413.Asttypes.loc } ->\n { Ast_412.Asttypes.txt = f0 txt; Ast_412.Asttypes.loc = copy_location loc }\n\nand copy_location : Location.t -> Location.t = fun x -> x\n","open Stdlib0\nmodule From = Ast_412\nmodule To = Ast_413\n\nlet rec copy_toplevel_phrase :\n Ast_412.Parsetree.toplevel_phrase -> Ast_413.Parsetree.toplevel_phrase =\n function\n | Ast_412.Parsetree.Ptop_def x0 ->\n Ast_413.Parsetree.Ptop_def (copy_structure x0)\n | Ast_412.Parsetree.Ptop_dir x0 ->\n Ast_413.Parsetree.Ptop_dir (copy_toplevel_directive x0)\n\nand copy_toplevel_directive :\n Ast_412.Parsetree.toplevel_directive -> Ast_413.Parsetree.toplevel_directive\n =\n fun {\n Ast_412.Parsetree.pdir_name;\n Ast_412.Parsetree.pdir_arg;\n Ast_412.Parsetree.pdir_loc;\n } ->\n {\n Ast_413.Parsetree.pdir_name = copy_loc (fun x -> x) pdir_name;\n Ast_413.Parsetree.pdir_arg = Option.map copy_directive_argument pdir_arg;\n Ast_413.Parsetree.pdir_loc = copy_location pdir_loc;\n }\n\nand copy_directive_argument :\n Ast_412.Parsetree.directive_argument -> Ast_413.Parsetree.directive_argument\n =\n fun { Ast_412.Parsetree.pdira_desc; Ast_412.Parsetree.pdira_loc } ->\n {\n Ast_413.Parsetree.pdira_desc = copy_directive_argument_desc pdira_desc;\n Ast_413.Parsetree.pdira_loc = copy_location pdira_loc;\n }\n\nand copy_directive_argument_desc :\n Ast_412.Parsetree.directive_argument_desc ->\n Ast_413.Parsetree.directive_argument_desc = function\n | Ast_412.Parsetree.Pdir_string x0 -> Ast_413.Parsetree.Pdir_string x0\n | Ast_412.Parsetree.Pdir_int (x0, x1) ->\n Ast_413.Parsetree.Pdir_int (x0, Option.map (fun x -> x) x1)\n | Ast_412.Parsetree.Pdir_ident x0 ->\n Ast_413.Parsetree.Pdir_ident (copy_Longident_t x0)\n | Ast_412.Parsetree.Pdir_bool x0 -> Ast_413.Parsetree.Pdir_bool x0\n\nand copy_expression :\n Ast_412.Parsetree.expression -> Ast_413.Parsetree.expression =\n fun {\n Ast_412.Parsetree.pexp_desc;\n Ast_412.Parsetree.pexp_loc;\n Ast_412.Parsetree.pexp_loc_stack;\n Ast_412.Parsetree.pexp_attributes;\n } ->\n {\n Ast_413.Parsetree.pexp_desc = copy_expression_desc pexp_desc;\n Ast_413.Parsetree.pexp_loc = copy_location pexp_loc;\n Ast_413.Parsetree.pexp_loc_stack = copy_location_stack pexp_loc_stack;\n Ast_413.Parsetree.pexp_attributes = copy_attributes pexp_attributes;\n }\n\nand copy_expression_desc :\n Ast_412.Parsetree.expression_desc -> Ast_413.Parsetree.expression_desc =\n function\n | Ast_412.Parsetree.Pexp_ident x0 ->\n Ast_413.Parsetree.Pexp_ident (copy_loc copy_Longident_t x0)\n | Ast_412.Parsetree.Pexp_constant x0 ->\n Ast_413.Parsetree.Pexp_constant (copy_constant x0)\n | Ast_412.Parsetree.Pexp_let (x0, x1, x2) ->\n Ast_413.Parsetree.Pexp_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_expression x2)\n | Ast_412.Parsetree.Pexp_function x0 ->\n Ast_413.Parsetree.Pexp_function (List.map copy_case x0)\n | Ast_412.Parsetree.Pexp_fun (x0, x1, x2, x3) ->\n Ast_413.Parsetree.Pexp_fun\n ( copy_arg_label x0,\n Option.map copy_expression x1,\n copy_pattern x2,\n copy_expression x3 )\n | Ast_412.Parsetree.Pexp_apply (x0, x1) ->\n Ast_413.Parsetree.Pexp_apply\n ( copy_expression x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | Ast_412.Parsetree.Pexp_match (x0, x1) ->\n Ast_413.Parsetree.Pexp_match (copy_expression x0, List.map copy_case x1)\n | Ast_412.Parsetree.Pexp_try (x0, x1) ->\n Ast_413.Parsetree.Pexp_try (copy_expression x0, List.map copy_case x1)\n | Ast_412.Parsetree.Pexp_tuple x0 ->\n Ast_413.Parsetree.Pexp_tuple (List.map copy_expression x0)\n | Ast_412.Parsetree.Pexp_construct (x0, x1) ->\n Ast_413.Parsetree.Pexp_construct\n (copy_loc copy_Longident_t x0, Option.map copy_expression x1)\n | Ast_412.Parsetree.Pexp_variant (x0, x1) ->\n Ast_413.Parsetree.Pexp_variant\n (copy_label x0, Option.map copy_expression x1)\n | Ast_412.Parsetree.Pexp_record (x0, x1) ->\n Ast_413.Parsetree.Pexp_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_expression x1))\n x0,\n Option.map copy_expression x1 )\n | Ast_412.Parsetree.Pexp_field (x0, x1) ->\n Ast_413.Parsetree.Pexp_field\n (copy_expression x0, copy_loc copy_Longident_t x1)\n | Ast_412.Parsetree.Pexp_setfield (x0, x1, x2) ->\n Ast_413.Parsetree.Pexp_setfield\n (copy_expression x0, copy_loc copy_Longident_t x1, copy_expression x2)\n | Ast_412.Parsetree.Pexp_array x0 ->\n Ast_413.Parsetree.Pexp_array (List.map copy_expression x0)\n | Ast_412.Parsetree.Pexp_ifthenelse (x0, x1, x2) ->\n Ast_413.Parsetree.Pexp_ifthenelse\n (copy_expression x0, copy_expression x1, Option.map copy_expression x2)\n | Ast_412.Parsetree.Pexp_sequence (x0, x1) ->\n Ast_413.Parsetree.Pexp_sequence (copy_expression x0, copy_expression x1)\n | Ast_412.Parsetree.Pexp_while (x0, x1) ->\n Ast_413.Parsetree.Pexp_while (copy_expression x0, copy_expression x1)\n | Ast_412.Parsetree.Pexp_for (x0, x1, x2, x3, x4) ->\n Ast_413.Parsetree.Pexp_for\n ( copy_pattern x0,\n copy_expression x1,\n copy_expression x2,\n copy_direction_flag x3,\n copy_expression x4 )\n | Ast_412.Parsetree.Pexp_constraint (x0, x1) ->\n Ast_413.Parsetree.Pexp_constraint (copy_expression x0, copy_core_type x1)\n | Ast_412.Parsetree.Pexp_coerce (x0, x1, x2) ->\n Ast_413.Parsetree.Pexp_coerce\n (copy_expression x0, Option.map copy_core_type x1, copy_core_type x2)\n | Ast_412.Parsetree.Pexp_send (x0, x1) ->\n Ast_413.Parsetree.Pexp_send (copy_expression x0, copy_loc copy_label x1)\n | Ast_412.Parsetree.Pexp_new x0 ->\n Ast_413.Parsetree.Pexp_new (copy_loc copy_Longident_t x0)\n | Ast_412.Parsetree.Pexp_setinstvar (x0, x1) ->\n Ast_413.Parsetree.Pexp_setinstvar\n (copy_loc copy_label x0, copy_expression x1)\n | Ast_412.Parsetree.Pexp_override x0 ->\n Ast_413.Parsetree.Pexp_override\n (List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_label x0, copy_expression x1))\n x0)\n | Ast_412.Parsetree.Pexp_letmodule (x0, x1, x2) ->\n Ast_413.Parsetree.Pexp_letmodule\n ( copy_loc (fun x -> Option.map (fun x -> x) x) x0,\n copy_module_expr x1,\n copy_expression x2 )\n | Ast_412.Parsetree.Pexp_letexception (x0, x1) ->\n Ast_413.Parsetree.Pexp_letexception\n (copy_extension_constructor x0, copy_expression x1)\n | Ast_412.Parsetree.Pexp_assert x0 ->\n Ast_413.Parsetree.Pexp_assert (copy_expression x0)\n | Ast_412.Parsetree.Pexp_lazy x0 ->\n Ast_413.Parsetree.Pexp_lazy (copy_expression x0)\n | Ast_412.Parsetree.Pexp_poly (x0, x1) ->\n Ast_413.Parsetree.Pexp_poly\n (copy_expression x0, Option.map copy_core_type x1)\n | Ast_412.Parsetree.Pexp_object x0 ->\n Ast_413.Parsetree.Pexp_object (copy_class_structure x0)\n | Ast_412.Parsetree.Pexp_newtype (x0, x1) ->\n Ast_413.Parsetree.Pexp_newtype\n (copy_loc (fun x -> x) x0, copy_expression x1)\n | Ast_412.Parsetree.Pexp_pack x0 ->\n Ast_413.Parsetree.Pexp_pack (copy_module_expr x0)\n | Ast_412.Parsetree.Pexp_open (x0, x1) ->\n Ast_413.Parsetree.Pexp_open (copy_open_declaration x0, copy_expression x1)\n | Ast_412.Parsetree.Pexp_letop x0 ->\n Ast_413.Parsetree.Pexp_letop (copy_letop x0)\n | Ast_412.Parsetree.Pexp_extension x0 ->\n Ast_413.Parsetree.Pexp_extension (copy_extension x0)\n | Ast_412.Parsetree.Pexp_unreachable -> Ast_413.Parsetree.Pexp_unreachable\n\nand copy_letop : Ast_412.Parsetree.letop -> Ast_413.Parsetree.letop =\n fun { Ast_412.Parsetree.let_; Ast_412.Parsetree.ands; Ast_412.Parsetree.body } ->\n {\n Ast_413.Parsetree.let_ = copy_binding_op let_;\n Ast_413.Parsetree.ands = List.map copy_binding_op ands;\n Ast_413.Parsetree.body = copy_expression body;\n }\n\nand copy_binding_op :\n Ast_412.Parsetree.binding_op -> Ast_413.Parsetree.binding_op =\n fun {\n Ast_412.Parsetree.pbop_op;\n Ast_412.Parsetree.pbop_pat;\n Ast_412.Parsetree.pbop_exp;\n Ast_412.Parsetree.pbop_loc;\n } ->\n {\n Ast_413.Parsetree.pbop_op = copy_loc (fun x -> x) pbop_op;\n Ast_413.Parsetree.pbop_pat = copy_pattern pbop_pat;\n Ast_413.Parsetree.pbop_exp = copy_expression pbop_exp;\n Ast_413.Parsetree.pbop_loc = copy_location pbop_loc;\n }\n\nand copy_direction_flag :\n Ast_412.Asttypes.direction_flag -> Ast_413.Asttypes.direction_flag =\n function\n | Ast_412.Asttypes.Upto -> Ast_413.Asttypes.Upto\n | Ast_412.Asttypes.Downto -> Ast_413.Asttypes.Downto\n\nand copy_case : Ast_412.Parsetree.case -> Ast_413.Parsetree.case =\n fun {\n Ast_412.Parsetree.pc_lhs;\n Ast_412.Parsetree.pc_guard;\n Ast_412.Parsetree.pc_rhs;\n } ->\n {\n Ast_413.Parsetree.pc_lhs = copy_pattern pc_lhs;\n Ast_413.Parsetree.pc_guard = Option.map copy_expression pc_guard;\n Ast_413.Parsetree.pc_rhs = copy_expression pc_rhs;\n }\n\nand copy_value_binding :\n Ast_412.Parsetree.value_binding -> Ast_413.Parsetree.value_binding =\n fun {\n Ast_412.Parsetree.pvb_pat;\n Ast_412.Parsetree.pvb_expr;\n Ast_412.Parsetree.pvb_attributes;\n Ast_412.Parsetree.pvb_loc;\n } ->\n {\n Ast_413.Parsetree.pvb_pat = copy_pattern pvb_pat;\n Ast_413.Parsetree.pvb_expr = copy_expression pvb_expr;\n Ast_413.Parsetree.pvb_attributes = copy_attributes pvb_attributes;\n Ast_413.Parsetree.pvb_loc = copy_location pvb_loc;\n }\n\nand copy_pattern : Ast_412.Parsetree.pattern -> Ast_413.Parsetree.pattern =\n fun {\n Ast_412.Parsetree.ppat_desc;\n Ast_412.Parsetree.ppat_loc;\n Ast_412.Parsetree.ppat_loc_stack;\n Ast_412.Parsetree.ppat_attributes;\n } ->\n {\n Ast_413.Parsetree.ppat_desc = copy_pattern_desc ppat_desc;\n Ast_413.Parsetree.ppat_loc = copy_location ppat_loc;\n Ast_413.Parsetree.ppat_loc_stack = copy_location_stack ppat_loc_stack;\n Ast_413.Parsetree.ppat_attributes = copy_attributes ppat_attributes;\n }\n\nand copy_pattern_desc :\n Ast_412.Parsetree.pattern_desc -> Ast_413.Parsetree.pattern_desc = function\n | Ast_412.Parsetree.Ppat_any -> Ast_413.Parsetree.Ppat_any\n | Ast_412.Parsetree.Ppat_var x0 ->\n Ast_413.Parsetree.Ppat_var (copy_loc (fun x -> x) x0)\n | Ast_412.Parsetree.Ppat_alias (x0, x1) ->\n Ast_413.Parsetree.Ppat_alias (copy_pattern x0, copy_loc (fun x -> x) x1)\n | Ast_412.Parsetree.Ppat_constant x0 ->\n Ast_413.Parsetree.Ppat_constant (copy_constant x0)\n | Ast_412.Parsetree.Ppat_interval (x0, x1) ->\n Ast_413.Parsetree.Ppat_interval (copy_constant x0, copy_constant x1)\n | Ast_412.Parsetree.Ppat_tuple x0 ->\n Ast_413.Parsetree.Ppat_tuple (List.map copy_pattern x0)\n | Ast_412.Parsetree.Ppat_construct (x0, x1) ->\n Ast_413.Parsetree.Ppat_construct\n ( copy_loc copy_Longident_t x0,\n Option.map (fun x -> ([], copy_pattern x)) x1 )\n | Ast_412.Parsetree.Ppat_variant (x0, x1) ->\n Ast_413.Parsetree.Ppat_variant (copy_label x0, Option.map copy_pattern x1)\n | Ast_412.Parsetree.Ppat_record (x0, x1) ->\n Ast_413.Parsetree.Ppat_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_pattern x1))\n x0,\n copy_closed_flag x1 )\n | Ast_412.Parsetree.Ppat_array x0 ->\n Ast_413.Parsetree.Ppat_array (List.map copy_pattern x0)\n | Ast_412.Parsetree.Ppat_or (x0, x1) ->\n Ast_413.Parsetree.Ppat_or (copy_pattern x0, copy_pattern x1)\n | Ast_412.Parsetree.Ppat_constraint (x0, x1) ->\n Ast_413.Parsetree.Ppat_constraint (copy_pattern x0, copy_core_type x1)\n | Ast_412.Parsetree.Ppat_type x0 ->\n Ast_413.Parsetree.Ppat_type (copy_loc copy_Longident_t x0)\n | Ast_412.Parsetree.Ppat_lazy x0 ->\n Ast_413.Parsetree.Ppat_lazy (copy_pattern x0)\n | Ast_412.Parsetree.Ppat_unpack x0 ->\n Ast_413.Parsetree.Ppat_unpack\n (copy_loc (fun x -> Option.map (fun x -> x) x) x0)\n | Ast_412.Parsetree.Ppat_exception x0 ->\n Ast_413.Parsetree.Ppat_exception (copy_pattern x0)\n | Ast_412.Parsetree.Ppat_extension x0 ->\n Ast_413.Parsetree.Ppat_extension (copy_extension x0)\n | Ast_412.Parsetree.Ppat_open (x0, x1) ->\n Ast_413.Parsetree.Ppat_open (copy_loc copy_Longident_t x0, copy_pattern x1)\n\nand copy_core_type : Ast_412.Parsetree.core_type -> Ast_413.Parsetree.core_type\n =\n fun {\n Ast_412.Parsetree.ptyp_desc;\n Ast_412.Parsetree.ptyp_loc;\n Ast_412.Parsetree.ptyp_loc_stack;\n Ast_412.Parsetree.ptyp_attributes;\n } ->\n {\n Ast_413.Parsetree.ptyp_desc = copy_core_type_desc ptyp_desc;\n Ast_413.Parsetree.ptyp_loc = copy_location ptyp_loc;\n Ast_413.Parsetree.ptyp_loc_stack = copy_location_stack ptyp_loc_stack;\n Ast_413.Parsetree.ptyp_attributes = copy_attributes ptyp_attributes;\n }\n\nand copy_location_stack :\n Ast_412.Parsetree.location_stack -> Ast_413.Parsetree.location_stack =\n fun x -> List.map copy_location x\n\nand copy_core_type_desc :\n Ast_412.Parsetree.core_type_desc -> Ast_413.Parsetree.core_type_desc =\n function\n | Ast_412.Parsetree.Ptyp_any -> Ast_413.Parsetree.Ptyp_any\n | Ast_412.Parsetree.Ptyp_var x0 -> Ast_413.Parsetree.Ptyp_var x0\n | Ast_412.Parsetree.Ptyp_arrow (x0, x1, x2) ->\n Ast_413.Parsetree.Ptyp_arrow\n (copy_arg_label x0, copy_core_type x1, copy_core_type x2)\n | Ast_412.Parsetree.Ptyp_tuple x0 ->\n Ast_413.Parsetree.Ptyp_tuple (List.map copy_core_type x0)\n | Ast_412.Parsetree.Ptyp_constr (x0, x1) ->\n Ast_413.Parsetree.Ptyp_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_412.Parsetree.Ptyp_object (x0, x1) ->\n Ast_413.Parsetree.Ptyp_object\n (List.map copy_object_field x0, copy_closed_flag x1)\n | Ast_412.Parsetree.Ptyp_class (x0, x1) ->\n Ast_413.Parsetree.Ptyp_class\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_412.Parsetree.Ptyp_alias (x0, x1) ->\n Ast_413.Parsetree.Ptyp_alias (copy_core_type x0, x1)\n | Ast_412.Parsetree.Ptyp_variant (x0, x1, x2) ->\n Ast_413.Parsetree.Ptyp_variant\n ( List.map copy_row_field x0,\n copy_closed_flag x1,\n Option.map (fun x -> List.map copy_label x) x2 )\n | Ast_412.Parsetree.Ptyp_poly (x0, x1) ->\n Ast_413.Parsetree.Ptyp_poly\n (List.map (fun x -> copy_loc (fun x -> x) x) x0, copy_core_type x1)\n | Ast_412.Parsetree.Ptyp_package x0 ->\n Ast_413.Parsetree.Ptyp_package (copy_package_type x0)\n | Ast_412.Parsetree.Ptyp_extension x0 ->\n Ast_413.Parsetree.Ptyp_extension (copy_extension x0)\n\nand copy_package_type :\n Ast_412.Parsetree.package_type -> Ast_413.Parsetree.package_type =\n fun x ->\n let x0, x1 = x in\n ( copy_loc copy_Longident_t x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_core_type x1))\n x1 )\n\nand copy_row_field : Ast_412.Parsetree.row_field -> Ast_413.Parsetree.row_field\n =\n fun {\n Ast_412.Parsetree.prf_desc;\n Ast_412.Parsetree.prf_loc;\n Ast_412.Parsetree.prf_attributes;\n } ->\n {\n Ast_413.Parsetree.prf_desc = copy_row_field_desc prf_desc;\n Ast_413.Parsetree.prf_loc = copy_location prf_loc;\n Ast_413.Parsetree.prf_attributes = copy_attributes prf_attributes;\n }\n\nand copy_row_field_desc :\n Ast_412.Parsetree.row_field_desc -> Ast_413.Parsetree.row_field_desc =\n function\n | Ast_412.Parsetree.Rtag (x0, x1, x2) ->\n Ast_413.Parsetree.Rtag\n (copy_loc copy_label x0, x1, List.map copy_core_type x2)\n | Ast_412.Parsetree.Rinherit x0 ->\n Ast_413.Parsetree.Rinherit (copy_core_type x0)\n\nand copy_object_field :\n Ast_412.Parsetree.object_field -> Ast_413.Parsetree.object_field =\n fun {\n Ast_412.Parsetree.pof_desc;\n Ast_412.Parsetree.pof_loc;\n Ast_412.Parsetree.pof_attributes;\n } ->\n {\n Ast_413.Parsetree.pof_desc = copy_object_field_desc pof_desc;\n Ast_413.Parsetree.pof_loc = copy_location pof_loc;\n Ast_413.Parsetree.pof_attributes = copy_attributes pof_attributes;\n }\n\nand copy_attributes :\n Ast_412.Parsetree.attributes -> Ast_413.Parsetree.attributes =\n fun x -> List.map copy_attribute x\n\nand copy_attribute : Ast_412.Parsetree.attribute -> Ast_413.Parsetree.attribute\n =\n fun {\n Ast_412.Parsetree.attr_name;\n Ast_412.Parsetree.attr_payload;\n Ast_412.Parsetree.attr_loc;\n } ->\n {\n Ast_413.Parsetree.attr_name = copy_loc (fun x -> x) attr_name;\n Ast_413.Parsetree.attr_payload = copy_payload attr_payload;\n Ast_413.Parsetree.attr_loc = copy_location attr_loc;\n }\n\nand copy_payload : Ast_412.Parsetree.payload -> Ast_413.Parsetree.payload =\n function\n | Ast_412.Parsetree.PStr x0 -> Ast_413.Parsetree.PStr (copy_structure x0)\n | Ast_412.Parsetree.PSig x0 -> Ast_413.Parsetree.PSig (copy_signature x0)\n | Ast_412.Parsetree.PTyp x0 -> Ast_413.Parsetree.PTyp (copy_core_type x0)\n | Ast_412.Parsetree.PPat (x0, x1) ->\n Ast_413.Parsetree.PPat (copy_pattern x0, Option.map copy_expression x1)\n\nand copy_structure : Ast_412.Parsetree.structure -> Ast_413.Parsetree.structure\n =\n fun x -> List.map copy_structure_item x\n\nand copy_structure_item :\n Ast_412.Parsetree.structure_item -> Ast_413.Parsetree.structure_item =\n fun { Ast_412.Parsetree.pstr_desc; Ast_412.Parsetree.pstr_loc } ->\n {\n Ast_413.Parsetree.pstr_desc = copy_structure_item_desc pstr_desc;\n Ast_413.Parsetree.pstr_loc = copy_location pstr_loc;\n }\n\nand copy_structure_item_desc :\n Ast_412.Parsetree.structure_item_desc ->\n Ast_413.Parsetree.structure_item_desc = function\n | Ast_412.Parsetree.Pstr_eval (x0, x1) ->\n Ast_413.Parsetree.Pstr_eval (copy_expression x0, copy_attributes x1)\n | Ast_412.Parsetree.Pstr_value (x0, x1) ->\n Ast_413.Parsetree.Pstr_value\n (copy_rec_flag x0, List.map copy_value_binding x1)\n | Ast_412.Parsetree.Pstr_primitive x0 ->\n Ast_413.Parsetree.Pstr_primitive (copy_value_description x0)\n | Ast_412.Parsetree.Pstr_type (x0, x1) ->\n Ast_413.Parsetree.Pstr_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | Ast_412.Parsetree.Pstr_typext x0 ->\n Ast_413.Parsetree.Pstr_typext (copy_type_extension x0)\n | Ast_412.Parsetree.Pstr_exception x0 ->\n Ast_413.Parsetree.Pstr_exception (copy_type_exception x0)\n | Ast_412.Parsetree.Pstr_module x0 ->\n Ast_413.Parsetree.Pstr_module (copy_module_binding x0)\n | Ast_412.Parsetree.Pstr_recmodule x0 ->\n Ast_413.Parsetree.Pstr_recmodule (List.map copy_module_binding x0)\n | Ast_412.Parsetree.Pstr_modtype x0 ->\n Ast_413.Parsetree.Pstr_modtype (copy_module_type_declaration x0)\n | Ast_412.Parsetree.Pstr_open x0 ->\n Ast_413.Parsetree.Pstr_open (copy_open_declaration x0)\n | Ast_412.Parsetree.Pstr_class x0 ->\n Ast_413.Parsetree.Pstr_class (List.map copy_class_declaration x0)\n | Ast_412.Parsetree.Pstr_class_type x0 ->\n Ast_413.Parsetree.Pstr_class_type\n (List.map copy_class_type_declaration x0)\n | Ast_412.Parsetree.Pstr_include x0 ->\n Ast_413.Parsetree.Pstr_include (copy_include_declaration x0)\n | Ast_412.Parsetree.Pstr_attribute x0 ->\n Ast_413.Parsetree.Pstr_attribute (copy_attribute x0)\n | Ast_412.Parsetree.Pstr_extension (x0, x1) ->\n Ast_413.Parsetree.Pstr_extension (copy_extension x0, copy_attributes x1)\n\nand copy_include_declaration :\n Ast_412.Parsetree.include_declaration ->\n Ast_413.Parsetree.include_declaration =\n fun x -> copy_include_infos copy_module_expr x\n\nand copy_class_declaration :\n Ast_412.Parsetree.class_declaration -> Ast_413.Parsetree.class_declaration =\n fun x -> copy_class_infos copy_class_expr x\n\nand copy_class_expr :\n Ast_412.Parsetree.class_expr -> Ast_413.Parsetree.class_expr =\n fun {\n Ast_412.Parsetree.pcl_desc;\n Ast_412.Parsetree.pcl_loc;\n Ast_412.Parsetree.pcl_attributes;\n } ->\n {\n Ast_413.Parsetree.pcl_desc = copy_class_expr_desc pcl_desc;\n Ast_413.Parsetree.pcl_loc = copy_location pcl_loc;\n Ast_413.Parsetree.pcl_attributes = copy_attributes pcl_attributes;\n }\n\nand copy_class_expr_desc :\n Ast_412.Parsetree.class_expr_desc -> Ast_413.Parsetree.class_expr_desc =\n function\n | Ast_412.Parsetree.Pcl_constr (x0, x1) ->\n Ast_413.Parsetree.Pcl_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_412.Parsetree.Pcl_structure x0 ->\n Ast_413.Parsetree.Pcl_structure (copy_class_structure x0)\n | Ast_412.Parsetree.Pcl_fun (x0, x1, x2, x3) ->\n Ast_413.Parsetree.Pcl_fun\n ( copy_arg_label x0,\n Option.map copy_expression x1,\n copy_pattern x2,\n copy_class_expr x3 )\n | Ast_412.Parsetree.Pcl_apply (x0, x1) ->\n Ast_413.Parsetree.Pcl_apply\n ( copy_class_expr x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | Ast_412.Parsetree.Pcl_let (x0, x1, x2) ->\n Ast_413.Parsetree.Pcl_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_class_expr x2)\n | Ast_412.Parsetree.Pcl_constraint (x0, x1) ->\n Ast_413.Parsetree.Pcl_constraint (copy_class_expr x0, copy_class_type x1)\n | Ast_412.Parsetree.Pcl_extension x0 ->\n Ast_413.Parsetree.Pcl_extension (copy_extension x0)\n | Ast_412.Parsetree.Pcl_open (x0, x1) ->\n Ast_413.Parsetree.Pcl_open (copy_open_description x0, copy_class_expr x1)\n\nand copy_class_structure :\n Ast_412.Parsetree.class_structure -> Ast_413.Parsetree.class_structure =\n fun { Ast_412.Parsetree.pcstr_self; Ast_412.Parsetree.pcstr_fields } ->\n {\n Ast_413.Parsetree.pcstr_self = copy_pattern pcstr_self;\n Ast_413.Parsetree.pcstr_fields = List.map copy_class_field pcstr_fields;\n }\n\nand copy_class_field :\n Ast_412.Parsetree.class_field -> Ast_413.Parsetree.class_field =\n fun {\n Ast_412.Parsetree.pcf_desc;\n Ast_412.Parsetree.pcf_loc;\n Ast_412.Parsetree.pcf_attributes;\n } ->\n {\n Ast_413.Parsetree.pcf_desc = copy_class_field_desc pcf_desc;\n Ast_413.Parsetree.pcf_loc = copy_location pcf_loc;\n Ast_413.Parsetree.pcf_attributes = copy_attributes pcf_attributes;\n }\n\nand copy_class_field_desc :\n Ast_412.Parsetree.class_field_desc -> Ast_413.Parsetree.class_field_desc =\n function\n | Ast_412.Parsetree.Pcf_inherit (x0, x1, x2) ->\n Ast_413.Parsetree.Pcf_inherit\n ( copy_override_flag x0,\n copy_class_expr x1,\n Option.map (fun x -> copy_loc (fun x -> x) x) x2 )\n | Ast_412.Parsetree.Pcf_val x0 ->\n Ast_413.Parsetree.Pcf_val\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_mutable_flag x1, copy_class_field_kind x2))\n | Ast_412.Parsetree.Pcf_method x0 ->\n Ast_413.Parsetree.Pcf_method\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_private_flag x1, copy_class_field_kind x2))\n | Ast_412.Parsetree.Pcf_constraint x0 ->\n Ast_413.Parsetree.Pcf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | Ast_412.Parsetree.Pcf_initializer x0 ->\n Ast_413.Parsetree.Pcf_initializer (copy_expression x0)\n | Ast_412.Parsetree.Pcf_attribute x0 ->\n Ast_413.Parsetree.Pcf_attribute (copy_attribute x0)\n | Ast_412.Parsetree.Pcf_extension x0 ->\n Ast_413.Parsetree.Pcf_extension (copy_extension x0)\n\nand copy_class_field_kind :\n Ast_412.Parsetree.class_field_kind -> Ast_413.Parsetree.class_field_kind =\n function\n | Ast_412.Parsetree.Cfk_virtual x0 ->\n Ast_413.Parsetree.Cfk_virtual (copy_core_type x0)\n | Ast_412.Parsetree.Cfk_concrete (x0, x1) ->\n Ast_413.Parsetree.Cfk_concrete (copy_override_flag x0, copy_expression x1)\n\nand copy_open_declaration :\n Ast_412.Parsetree.open_declaration -> Ast_413.Parsetree.open_declaration =\n fun x -> copy_open_infos copy_module_expr x\n\nand copy_module_binding :\n Ast_412.Parsetree.module_binding -> Ast_413.Parsetree.module_binding =\n fun {\n Ast_412.Parsetree.pmb_name;\n Ast_412.Parsetree.pmb_expr;\n Ast_412.Parsetree.pmb_attributes;\n Ast_412.Parsetree.pmb_loc;\n } ->\n {\n Ast_413.Parsetree.pmb_name =\n copy_loc (fun x -> Option.map (fun x -> x) x) pmb_name;\n Ast_413.Parsetree.pmb_expr = copy_module_expr pmb_expr;\n Ast_413.Parsetree.pmb_attributes = copy_attributes pmb_attributes;\n Ast_413.Parsetree.pmb_loc = copy_location pmb_loc;\n }\n\nand copy_module_expr :\n Ast_412.Parsetree.module_expr -> Ast_413.Parsetree.module_expr =\n fun {\n Ast_412.Parsetree.pmod_desc;\n Ast_412.Parsetree.pmod_loc;\n Ast_412.Parsetree.pmod_attributes;\n } ->\n {\n Ast_413.Parsetree.pmod_desc = copy_module_expr_desc pmod_desc;\n Ast_413.Parsetree.pmod_loc = copy_location pmod_loc;\n Ast_413.Parsetree.pmod_attributes = copy_attributes pmod_attributes;\n }\n\nand copy_module_expr_desc :\n Ast_412.Parsetree.module_expr_desc -> Ast_413.Parsetree.module_expr_desc =\n function\n | Ast_412.Parsetree.Pmod_ident x0 ->\n Ast_413.Parsetree.Pmod_ident (copy_loc copy_Longident_t x0)\n | Ast_412.Parsetree.Pmod_structure x0 ->\n Ast_413.Parsetree.Pmod_structure (copy_structure x0)\n | Ast_412.Parsetree.Pmod_functor (x0, x1) ->\n Ast_413.Parsetree.Pmod_functor\n (copy_functor_parameter x0, copy_module_expr x1)\n | Ast_412.Parsetree.Pmod_apply (x0, x1) ->\n Ast_413.Parsetree.Pmod_apply (copy_module_expr x0, copy_module_expr x1)\n | Ast_412.Parsetree.Pmod_constraint (x0, x1) ->\n Ast_413.Parsetree.Pmod_constraint\n (copy_module_expr x0, copy_module_type x1)\n | Ast_412.Parsetree.Pmod_unpack x0 ->\n Ast_413.Parsetree.Pmod_unpack (copy_expression x0)\n | Ast_412.Parsetree.Pmod_extension x0 ->\n Ast_413.Parsetree.Pmod_extension (copy_extension x0)\n\nand copy_functor_parameter :\n Ast_412.Parsetree.functor_parameter -> Ast_413.Parsetree.functor_parameter =\n function\n | Ast_412.Parsetree.Unit -> Ast_413.Parsetree.Unit\n | Ast_412.Parsetree.Named (x0, x1) ->\n Ast_413.Parsetree.Named\n (copy_loc (fun x -> Option.map (fun x -> x) x) x0, copy_module_type x1)\n\nand copy_module_type :\n Ast_412.Parsetree.module_type -> Ast_413.Parsetree.module_type =\n fun {\n Ast_412.Parsetree.pmty_desc;\n Ast_412.Parsetree.pmty_loc;\n Ast_412.Parsetree.pmty_attributes;\n } ->\n {\n Ast_413.Parsetree.pmty_desc = copy_module_type_desc pmty_desc;\n Ast_413.Parsetree.pmty_loc = copy_location pmty_loc;\n Ast_413.Parsetree.pmty_attributes = copy_attributes pmty_attributes;\n }\n\nand copy_module_type_desc :\n Ast_412.Parsetree.module_type_desc -> Ast_413.Parsetree.module_type_desc =\n function\n | Ast_412.Parsetree.Pmty_ident x0 ->\n Ast_413.Parsetree.Pmty_ident (copy_loc copy_Longident_t x0)\n | Ast_412.Parsetree.Pmty_signature x0 ->\n Ast_413.Parsetree.Pmty_signature (copy_signature x0)\n | Ast_412.Parsetree.Pmty_functor (x0, x1) ->\n Ast_413.Parsetree.Pmty_functor\n (copy_functor_parameter x0, copy_module_type x1)\n | Ast_412.Parsetree.Pmty_with (x0, x1) ->\n Ast_413.Parsetree.Pmty_with\n (copy_module_type x0, List.map copy_with_constraint x1)\n | Ast_412.Parsetree.Pmty_typeof x0 ->\n Ast_413.Parsetree.Pmty_typeof (copy_module_expr x0)\n | Ast_412.Parsetree.Pmty_extension x0 ->\n Ast_413.Parsetree.Pmty_extension (copy_extension x0)\n | Ast_412.Parsetree.Pmty_alias x0 ->\n Ast_413.Parsetree.Pmty_alias (copy_loc copy_Longident_t x0)\n\nand copy_with_constraint :\n Ast_412.Parsetree.with_constraint -> Ast_413.Parsetree.with_constraint =\n function\n | Ast_412.Parsetree.Pwith_type (x0, x1) ->\n Ast_413.Parsetree.Pwith_type\n (copy_loc copy_Longident_t x0, copy_type_declaration x1)\n | Ast_412.Parsetree.Pwith_module (x0, x1) ->\n Ast_413.Parsetree.Pwith_module\n (copy_loc copy_Longident_t x0, copy_loc copy_Longident_t x1)\n | Ast_412.Parsetree.Pwith_typesubst (x0, x1) ->\n Ast_413.Parsetree.Pwith_typesubst\n (copy_loc copy_Longident_t x0, copy_type_declaration x1)\n | Ast_412.Parsetree.Pwith_modsubst (x0, x1) ->\n Ast_413.Parsetree.Pwith_modsubst\n (copy_loc copy_Longident_t x0, copy_loc copy_Longident_t x1)\n\nand copy_signature : Ast_412.Parsetree.signature -> Ast_413.Parsetree.signature\n =\n fun x -> List.map copy_signature_item x\n\nand copy_signature_item :\n Ast_412.Parsetree.signature_item -> Ast_413.Parsetree.signature_item =\n fun { Ast_412.Parsetree.psig_desc; Ast_412.Parsetree.psig_loc } ->\n {\n Ast_413.Parsetree.psig_desc = copy_signature_item_desc psig_desc;\n Ast_413.Parsetree.psig_loc = copy_location psig_loc;\n }\n\nand copy_signature_item_desc :\n Ast_412.Parsetree.signature_item_desc ->\n Ast_413.Parsetree.signature_item_desc = function\n | Ast_412.Parsetree.Psig_value x0 ->\n Ast_413.Parsetree.Psig_value (copy_value_description x0)\n | Ast_412.Parsetree.Psig_type (x0, x1) ->\n Ast_413.Parsetree.Psig_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | Ast_412.Parsetree.Psig_typesubst x0 ->\n Ast_413.Parsetree.Psig_typesubst (List.map copy_type_declaration x0)\n | Ast_412.Parsetree.Psig_typext x0 ->\n Ast_413.Parsetree.Psig_typext (copy_type_extension x0)\n | Ast_412.Parsetree.Psig_exception x0 ->\n Ast_413.Parsetree.Psig_exception (copy_type_exception x0)\n | Ast_412.Parsetree.Psig_module x0 ->\n Ast_413.Parsetree.Psig_module (copy_module_declaration x0)\n | Ast_412.Parsetree.Psig_modsubst x0 ->\n Ast_413.Parsetree.Psig_modsubst (copy_module_substitution x0)\n | Ast_412.Parsetree.Psig_recmodule x0 ->\n Ast_413.Parsetree.Psig_recmodule (List.map copy_module_declaration x0)\n | Ast_412.Parsetree.Psig_modtype x0 ->\n Ast_413.Parsetree.Psig_modtype (copy_module_type_declaration x0)\n | Ast_412.Parsetree.Psig_open x0 ->\n Ast_413.Parsetree.Psig_open (copy_open_description x0)\n | Ast_412.Parsetree.Psig_include x0 ->\n Ast_413.Parsetree.Psig_include (copy_include_description x0)\n | Ast_412.Parsetree.Psig_class x0 ->\n Ast_413.Parsetree.Psig_class (List.map copy_class_description x0)\n | Ast_412.Parsetree.Psig_class_type x0 ->\n Ast_413.Parsetree.Psig_class_type\n (List.map copy_class_type_declaration x0)\n | Ast_412.Parsetree.Psig_attribute x0 ->\n Ast_413.Parsetree.Psig_attribute (copy_attribute x0)\n | Ast_412.Parsetree.Psig_extension (x0, x1) ->\n Ast_413.Parsetree.Psig_extension (copy_extension x0, copy_attributes x1)\n\nand copy_class_type_declaration :\n Ast_412.Parsetree.class_type_declaration ->\n Ast_413.Parsetree.class_type_declaration =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_description :\n Ast_412.Parsetree.class_description -> Ast_413.Parsetree.class_description =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_type :\n Ast_412.Parsetree.class_type -> Ast_413.Parsetree.class_type =\n fun {\n Ast_412.Parsetree.pcty_desc;\n Ast_412.Parsetree.pcty_loc;\n Ast_412.Parsetree.pcty_attributes;\n } ->\n {\n Ast_413.Parsetree.pcty_desc = copy_class_type_desc pcty_desc;\n Ast_413.Parsetree.pcty_loc = copy_location pcty_loc;\n Ast_413.Parsetree.pcty_attributes = copy_attributes pcty_attributes;\n }\n\nand copy_class_type_desc :\n Ast_412.Parsetree.class_type_desc -> Ast_413.Parsetree.class_type_desc =\n function\n | Ast_412.Parsetree.Pcty_constr (x0, x1) ->\n Ast_413.Parsetree.Pcty_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_412.Parsetree.Pcty_signature x0 ->\n Ast_413.Parsetree.Pcty_signature (copy_class_signature x0)\n | Ast_412.Parsetree.Pcty_arrow (x0, x1, x2) ->\n Ast_413.Parsetree.Pcty_arrow\n (copy_arg_label x0, copy_core_type x1, copy_class_type x2)\n | Ast_412.Parsetree.Pcty_extension x0 ->\n Ast_413.Parsetree.Pcty_extension (copy_extension x0)\n | Ast_412.Parsetree.Pcty_open (x0, x1) ->\n Ast_413.Parsetree.Pcty_open (copy_open_description x0, copy_class_type x1)\n\nand copy_class_signature :\n Ast_412.Parsetree.class_signature -> Ast_413.Parsetree.class_signature =\n fun { Ast_412.Parsetree.pcsig_self; Ast_412.Parsetree.pcsig_fields } ->\n {\n Ast_413.Parsetree.pcsig_self = copy_core_type pcsig_self;\n Ast_413.Parsetree.pcsig_fields = List.map copy_class_type_field pcsig_fields;\n }\n\nand copy_class_type_field :\n Ast_412.Parsetree.class_type_field -> Ast_413.Parsetree.class_type_field =\n fun {\n Ast_412.Parsetree.pctf_desc;\n Ast_412.Parsetree.pctf_loc;\n Ast_412.Parsetree.pctf_attributes;\n } ->\n {\n Ast_413.Parsetree.pctf_desc = copy_class_type_field_desc pctf_desc;\n Ast_413.Parsetree.pctf_loc = copy_location pctf_loc;\n Ast_413.Parsetree.pctf_attributes = copy_attributes pctf_attributes;\n }\n\nand copy_class_type_field_desc :\n Ast_412.Parsetree.class_type_field_desc ->\n Ast_413.Parsetree.class_type_field_desc = function\n | Ast_412.Parsetree.Pctf_inherit x0 ->\n Ast_413.Parsetree.Pctf_inherit (copy_class_type x0)\n | Ast_412.Parsetree.Pctf_val x0 ->\n Ast_413.Parsetree.Pctf_val\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_mutable_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | Ast_412.Parsetree.Pctf_method x0 ->\n Ast_413.Parsetree.Pctf_method\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_private_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | Ast_412.Parsetree.Pctf_constraint x0 ->\n Ast_413.Parsetree.Pctf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | Ast_412.Parsetree.Pctf_attribute x0 ->\n Ast_413.Parsetree.Pctf_attribute (copy_attribute x0)\n | Ast_412.Parsetree.Pctf_extension x0 ->\n Ast_413.Parsetree.Pctf_extension (copy_extension x0)\n\nand copy_extension : Ast_412.Parsetree.extension -> Ast_413.Parsetree.extension\n =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_class_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_412.Parsetree.class_infos ->\n 'g0 Ast_413.Parsetree.class_infos =\n fun f0\n {\n Ast_412.Parsetree.pci_virt;\n Ast_412.Parsetree.pci_params;\n Ast_412.Parsetree.pci_name;\n Ast_412.Parsetree.pci_expr;\n Ast_412.Parsetree.pci_loc;\n Ast_412.Parsetree.pci_attributes;\n } ->\n {\n Ast_413.Parsetree.pci_virt = copy_virtual_flag pci_virt;\n Ast_413.Parsetree.pci_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n ( copy_core_type x0,\n let x0, x1 = x1 in\n (copy_variance x0, copy_injectivity x1) ))\n pci_params;\n Ast_413.Parsetree.pci_name = copy_loc (fun x -> x) pci_name;\n Ast_413.Parsetree.pci_expr = f0 pci_expr;\n Ast_413.Parsetree.pci_loc = copy_location pci_loc;\n Ast_413.Parsetree.pci_attributes = copy_attributes pci_attributes;\n }\n\nand copy_virtual_flag :\n Ast_412.Asttypes.virtual_flag -> Ast_413.Asttypes.virtual_flag = function\n | Ast_412.Asttypes.Virtual -> Ast_413.Asttypes.Virtual\n | Ast_412.Asttypes.Concrete -> Ast_413.Asttypes.Concrete\n\nand copy_include_description :\n Ast_412.Parsetree.include_description ->\n Ast_413.Parsetree.include_description =\n fun x -> copy_include_infos copy_module_type x\n\nand copy_include_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_412.Parsetree.include_infos ->\n 'g0 Ast_413.Parsetree.include_infos =\n fun f0\n {\n Ast_412.Parsetree.pincl_mod;\n Ast_412.Parsetree.pincl_loc;\n Ast_412.Parsetree.pincl_attributes;\n } ->\n {\n Ast_413.Parsetree.pincl_mod = f0 pincl_mod;\n Ast_413.Parsetree.pincl_loc = copy_location pincl_loc;\n Ast_413.Parsetree.pincl_attributes = copy_attributes pincl_attributes;\n }\n\nand copy_open_description :\n Ast_412.Parsetree.open_description -> Ast_413.Parsetree.open_description =\n fun x -> copy_open_infos (fun x -> copy_loc copy_Longident_t x) x\n\nand copy_open_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_412.Parsetree.open_infos ->\n 'g0 Ast_413.Parsetree.open_infos =\n fun f0\n {\n Ast_412.Parsetree.popen_expr;\n Ast_412.Parsetree.popen_override;\n Ast_412.Parsetree.popen_loc;\n Ast_412.Parsetree.popen_attributes;\n } ->\n {\n Ast_413.Parsetree.popen_expr = f0 popen_expr;\n Ast_413.Parsetree.popen_override = copy_override_flag popen_override;\n Ast_413.Parsetree.popen_loc = copy_location popen_loc;\n Ast_413.Parsetree.popen_attributes = copy_attributes popen_attributes;\n }\n\nand copy_override_flag :\n Ast_412.Asttypes.override_flag -> Ast_413.Asttypes.override_flag = function\n | Ast_412.Asttypes.Override -> Ast_413.Asttypes.Override\n | Ast_412.Asttypes.Fresh -> Ast_413.Asttypes.Fresh\n\nand copy_module_type_declaration :\n Ast_412.Parsetree.module_type_declaration ->\n Ast_413.Parsetree.module_type_declaration =\n fun {\n Ast_412.Parsetree.pmtd_name;\n Ast_412.Parsetree.pmtd_type;\n Ast_412.Parsetree.pmtd_attributes;\n Ast_412.Parsetree.pmtd_loc;\n } ->\n {\n Ast_413.Parsetree.pmtd_name = copy_loc (fun x -> x) pmtd_name;\n Ast_413.Parsetree.pmtd_type = Option.map copy_module_type pmtd_type;\n Ast_413.Parsetree.pmtd_attributes = copy_attributes pmtd_attributes;\n Ast_413.Parsetree.pmtd_loc = copy_location pmtd_loc;\n }\n\nand copy_module_substitution :\n Ast_412.Parsetree.module_substitution ->\n Ast_413.Parsetree.module_substitution =\n fun {\n Ast_412.Parsetree.pms_name;\n Ast_412.Parsetree.pms_manifest;\n Ast_412.Parsetree.pms_attributes;\n Ast_412.Parsetree.pms_loc;\n } ->\n {\n Ast_413.Parsetree.pms_name = copy_loc (fun x -> x) pms_name;\n Ast_413.Parsetree.pms_manifest = copy_loc copy_Longident_t pms_manifest;\n Ast_413.Parsetree.pms_attributes = copy_attributes pms_attributes;\n Ast_413.Parsetree.pms_loc = copy_location pms_loc;\n }\n\nand copy_module_declaration :\n Ast_412.Parsetree.module_declaration -> Ast_413.Parsetree.module_declaration\n =\n fun {\n Ast_412.Parsetree.pmd_name;\n Ast_412.Parsetree.pmd_type;\n Ast_412.Parsetree.pmd_attributes;\n Ast_412.Parsetree.pmd_loc;\n } ->\n {\n Ast_413.Parsetree.pmd_name =\n copy_loc (fun x -> Option.map (fun x -> x) x) pmd_name;\n Ast_413.Parsetree.pmd_type = copy_module_type pmd_type;\n Ast_413.Parsetree.pmd_attributes = copy_attributes pmd_attributes;\n Ast_413.Parsetree.pmd_loc = copy_location pmd_loc;\n }\n\nand copy_type_exception :\n Ast_412.Parsetree.type_exception -> Ast_413.Parsetree.type_exception =\n fun {\n Ast_412.Parsetree.ptyexn_constructor;\n Ast_412.Parsetree.ptyexn_loc;\n Ast_412.Parsetree.ptyexn_attributes;\n } ->\n {\n Ast_413.Parsetree.ptyexn_constructor =\n copy_extension_constructor ptyexn_constructor;\n Ast_413.Parsetree.ptyexn_loc = copy_location ptyexn_loc;\n Ast_413.Parsetree.ptyexn_attributes = copy_attributes ptyexn_attributes;\n }\n\nand copy_type_extension :\n Ast_412.Parsetree.type_extension -> Ast_413.Parsetree.type_extension =\n fun {\n Ast_412.Parsetree.ptyext_path;\n Ast_412.Parsetree.ptyext_params;\n Ast_412.Parsetree.ptyext_constructors;\n Ast_412.Parsetree.ptyext_private;\n Ast_412.Parsetree.ptyext_loc;\n Ast_412.Parsetree.ptyext_attributes;\n } ->\n {\n Ast_413.Parsetree.ptyext_path = copy_loc copy_Longident_t ptyext_path;\n Ast_413.Parsetree.ptyext_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n ( copy_core_type x0,\n let x0, x1 = x1 in\n (copy_variance x0, copy_injectivity x1) ))\n ptyext_params;\n Ast_413.Parsetree.ptyext_constructors =\n List.map copy_extension_constructor ptyext_constructors;\n Ast_413.Parsetree.ptyext_private = copy_private_flag ptyext_private;\n Ast_413.Parsetree.ptyext_loc = copy_location ptyext_loc;\n Ast_413.Parsetree.ptyext_attributes = copy_attributes ptyext_attributes;\n }\n\nand copy_extension_constructor :\n Ast_412.Parsetree.extension_constructor ->\n Ast_413.Parsetree.extension_constructor =\n fun {\n Ast_412.Parsetree.pext_name;\n Ast_412.Parsetree.pext_kind;\n Ast_412.Parsetree.pext_loc;\n Ast_412.Parsetree.pext_attributes;\n } ->\n {\n Ast_413.Parsetree.pext_name = copy_loc (fun x -> x) pext_name;\n Ast_413.Parsetree.pext_kind = copy_extension_constructor_kind pext_kind;\n Ast_413.Parsetree.pext_loc = copy_location pext_loc;\n Ast_413.Parsetree.pext_attributes = copy_attributes pext_attributes;\n }\n\nand copy_extension_constructor_kind :\n Ast_412.Parsetree.extension_constructor_kind ->\n Ast_413.Parsetree.extension_constructor_kind = function\n | Ast_412.Parsetree.Pext_decl (x0, x1) ->\n Ast_413.Parsetree.Pext_decl\n (copy_constructor_arguments x0, Option.map copy_core_type x1)\n | Ast_412.Parsetree.Pext_rebind x0 ->\n Ast_413.Parsetree.Pext_rebind (copy_loc copy_Longident_t x0)\n\nand copy_type_declaration :\n Ast_412.Parsetree.type_declaration -> Ast_413.Parsetree.type_declaration =\n fun {\n Ast_412.Parsetree.ptype_name;\n Ast_412.Parsetree.ptype_params;\n Ast_412.Parsetree.ptype_cstrs;\n Ast_412.Parsetree.ptype_kind;\n Ast_412.Parsetree.ptype_private;\n Ast_412.Parsetree.ptype_manifest;\n Ast_412.Parsetree.ptype_attributes;\n Ast_412.Parsetree.ptype_loc;\n } ->\n {\n Ast_413.Parsetree.ptype_name = copy_loc (fun x -> x) ptype_name;\n Ast_413.Parsetree.ptype_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n ( copy_core_type x0,\n let x0, x1 = x1 in\n (copy_variance x0, copy_injectivity x1) ))\n ptype_params;\n Ast_413.Parsetree.ptype_cstrs =\n List.map\n (fun x ->\n let x0, x1, x2 = x in\n (copy_core_type x0, copy_core_type x1, copy_location x2))\n ptype_cstrs;\n Ast_413.Parsetree.ptype_kind = copy_type_kind ptype_kind;\n Ast_413.Parsetree.ptype_private = copy_private_flag ptype_private;\n Ast_413.Parsetree.ptype_manifest = Option.map copy_core_type ptype_manifest;\n Ast_413.Parsetree.ptype_attributes = copy_attributes ptype_attributes;\n Ast_413.Parsetree.ptype_loc = copy_location ptype_loc;\n }\n\nand copy_private_flag :\n Ast_412.Asttypes.private_flag -> Ast_413.Asttypes.private_flag = function\n | Ast_412.Asttypes.Private -> Ast_413.Asttypes.Private\n | Ast_412.Asttypes.Public -> Ast_413.Asttypes.Public\n\nand copy_type_kind : Ast_412.Parsetree.type_kind -> Ast_413.Parsetree.type_kind\n = function\n | Ast_412.Parsetree.Ptype_abstract -> Ast_413.Parsetree.Ptype_abstract\n | Ast_412.Parsetree.Ptype_variant x0 ->\n Ast_413.Parsetree.Ptype_variant (List.map copy_constructor_declaration x0)\n | Ast_412.Parsetree.Ptype_record x0 ->\n Ast_413.Parsetree.Ptype_record (List.map copy_label_declaration x0)\n | Ast_412.Parsetree.Ptype_open -> Ast_413.Parsetree.Ptype_open\n\nand copy_constructor_declaration :\n Ast_412.Parsetree.constructor_declaration ->\n Ast_413.Parsetree.constructor_declaration =\n fun {\n Ast_412.Parsetree.pcd_name;\n Ast_412.Parsetree.pcd_args;\n Ast_412.Parsetree.pcd_res;\n Ast_412.Parsetree.pcd_loc;\n Ast_412.Parsetree.pcd_attributes;\n } ->\n {\n Ast_413.Parsetree.pcd_name = copy_loc (fun x -> x) pcd_name;\n Ast_413.Parsetree.pcd_args = copy_constructor_arguments pcd_args;\n Ast_413.Parsetree.pcd_res = Option.map copy_core_type pcd_res;\n Ast_413.Parsetree.pcd_loc = copy_location pcd_loc;\n Ast_413.Parsetree.pcd_attributes = copy_attributes pcd_attributes;\n }\n\nand copy_constructor_arguments :\n Ast_412.Parsetree.constructor_arguments ->\n Ast_413.Parsetree.constructor_arguments = function\n | Ast_412.Parsetree.Pcstr_tuple x0 ->\n Ast_413.Parsetree.Pcstr_tuple (List.map copy_core_type x0)\n | Ast_412.Parsetree.Pcstr_record x0 ->\n Ast_413.Parsetree.Pcstr_record (List.map copy_label_declaration x0)\n\nand copy_label_declaration :\n Ast_412.Parsetree.label_declaration -> Ast_413.Parsetree.label_declaration =\n fun {\n Ast_412.Parsetree.pld_name;\n Ast_412.Parsetree.pld_mutable;\n Ast_412.Parsetree.pld_type;\n Ast_412.Parsetree.pld_loc;\n Ast_412.Parsetree.pld_attributes;\n } ->\n {\n Ast_413.Parsetree.pld_name = copy_loc (fun x -> x) pld_name;\n Ast_413.Parsetree.pld_mutable = copy_mutable_flag pld_mutable;\n Ast_413.Parsetree.pld_type = copy_core_type pld_type;\n Ast_413.Parsetree.pld_loc = copy_location pld_loc;\n Ast_413.Parsetree.pld_attributes = copy_attributes pld_attributes;\n }\n\nand copy_mutable_flag :\n Ast_412.Asttypes.mutable_flag -> Ast_413.Asttypes.mutable_flag = function\n | Ast_412.Asttypes.Immutable -> Ast_413.Asttypes.Immutable\n | Ast_412.Asttypes.Mutable -> Ast_413.Asttypes.Mutable\n\nand copy_injectivity :\n Ast_412.Asttypes.injectivity -> Ast_413.Asttypes.injectivity = function\n | Ast_412.Asttypes.Injective -> Ast_413.Asttypes.Injective\n | Ast_412.Asttypes.NoInjectivity -> Ast_413.Asttypes.NoInjectivity\n\nand copy_variance : Ast_412.Asttypes.variance -> Ast_413.Asttypes.variance =\n function\n | Ast_412.Asttypes.Covariant -> Ast_413.Asttypes.Covariant\n | Ast_412.Asttypes.Contravariant -> Ast_413.Asttypes.Contravariant\n | Ast_412.Asttypes.NoVariance -> Ast_413.Asttypes.NoVariance\n\nand copy_value_description :\n Ast_412.Parsetree.value_description -> Ast_413.Parsetree.value_description =\n fun {\n Ast_412.Parsetree.pval_name;\n Ast_412.Parsetree.pval_type;\n Ast_412.Parsetree.pval_prim;\n Ast_412.Parsetree.pval_attributes;\n Ast_412.Parsetree.pval_loc;\n } ->\n {\n Ast_413.Parsetree.pval_name = copy_loc (fun x -> x) pval_name;\n Ast_413.Parsetree.pval_type = copy_core_type pval_type;\n Ast_413.Parsetree.pval_prim = List.map (fun x -> x) pval_prim;\n Ast_413.Parsetree.pval_attributes = copy_attributes pval_attributes;\n Ast_413.Parsetree.pval_loc = copy_location pval_loc;\n }\n\nand copy_object_field_desc :\n Ast_412.Parsetree.object_field_desc -> Ast_413.Parsetree.object_field_desc =\n function\n | Ast_412.Parsetree.Otag (x0, x1) ->\n Ast_413.Parsetree.Otag (copy_loc copy_label x0, copy_core_type x1)\n | Ast_412.Parsetree.Oinherit x0 ->\n Ast_413.Parsetree.Oinherit (copy_core_type x0)\n\nand copy_arg_label : Ast_412.Asttypes.arg_label -> Ast_413.Asttypes.arg_label =\n function\n | Ast_412.Asttypes.Nolabel -> Ast_413.Asttypes.Nolabel\n | Ast_412.Asttypes.Labelled x0 -> Ast_413.Asttypes.Labelled x0\n | Ast_412.Asttypes.Optional x0 -> Ast_413.Asttypes.Optional x0\n\nand copy_closed_flag :\n Ast_412.Asttypes.closed_flag -> Ast_413.Asttypes.closed_flag = function\n | Ast_412.Asttypes.Closed -> Ast_413.Asttypes.Closed\n | Ast_412.Asttypes.Open -> Ast_413.Asttypes.Open\n\nand copy_label : Ast_412.Asttypes.label -> Ast_413.Asttypes.label = fun x -> x\n\nand copy_rec_flag : Ast_412.Asttypes.rec_flag -> Ast_413.Asttypes.rec_flag =\n function\n | Ast_412.Asttypes.Nonrecursive -> Ast_413.Asttypes.Nonrecursive\n | Ast_412.Asttypes.Recursive -> Ast_413.Asttypes.Recursive\n\nand copy_constant : Ast_412.Parsetree.constant -> Ast_413.Parsetree.constant =\n function\n | Ast_412.Parsetree.Pconst_integer (x0, x1) ->\n Ast_413.Parsetree.Pconst_integer (x0, Option.map (fun x -> x) x1)\n | Ast_412.Parsetree.Pconst_char x0 -> Ast_413.Parsetree.Pconst_char x0\n | Ast_412.Parsetree.Pconst_string (x0, x1, x2) ->\n Ast_413.Parsetree.Pconst_string\n (x0, copy_location x1, Option.map (fun x -> x) x2)\n | Ast_412.Parsetree.Pconst_float (x0, x1) ->\n Ast_413.Parsetree.Pconst_float (x0, Option.map (fun x -> x) x1)\n\nand copy_Longident_t : Longident.t -> Longident.t = fun x -> x\n\nand copy_loc :\n 'f0 'g0.\n ('f0 -> 'g0) -> 'f0 Ast_412.Asttypes.loc -> 'g0 Ast_413.Asttypes.loc =\n fun f0 { Ast_412.Asttypes.txt; Ast_412.Asttypes.loc } ->\n { Ast_413.Asttypes.txt = f0 txt; Ast_413.Asttypes.loc = copy_location loc }\n\nand copy_location : Location.t -> Location.t = fun x -> x\n","open Stdlib0\nmodule From = Ast_412\nmodule To = Ast_411\n\nlet rec copy_toplevel_phrase :\n Ast_412.Parsetree.toplevel_phrase -> Ast_411.Parsetree.toplevel_phrase =\n function\n | Ast_412.Parsetree.Ptop_def x0 ->\n Ast_411.Parsetree.Ptop_def (copy_structure x0)\n | Ast_412.Parsetree.Ptop_dir x0 ->\n Ast_411.Parsetree.Ptop_dir (copy_toplevel_directive x0)\n\nand copy_toplevel_directive :\n Ast_412.Parsetree.toplevel_directive -> Ast_411.Parsetree.toplevel_directive\n =\n fun {\n Ast_412.Parsetree.pdir_name;\n Ast_412.Parsetree.pdir_arg;\n Ast_412.Parsetree.pdir_loc;\n } ->\n {\n Ast_411.Parsetree.pdir_name = copy_loc (fun x -> x) pdir_name;\n Ast_411.Parsetree.pdir_arg = Option.map copy_directive_argument pdir_arg;\n Ast_411.Parsetree.pdir_loc = copy_location pdir_loc;\n }\n\nand copy_directive_argument :\n Ast_412.Parsetree.directive_argument -> Ast_411.Parsetree.directive_argument\n =\n fun { Ast_412.Parsetree.pdira_desc; Ast_412.Parsetree.pdira_loc } ->\n {\n Ast_411.Parsetree.pdira_desc = copy_directive_argument_desc pdira_desc;\n Ast_411.Parsetree.pdira_loc = copy_location pdira_loc;\n }\n\nand copy_directive_argument_desc :\n Ast_412.Parsetree.directive_argument_desc ->\n Ast_411.Parsetree.directive_argument_desc = function\n | Ast_412.Parsetree.Pdir_string x0 -> Ast_411.Parsetree.Pdir_string x0\n | Ast_412.Parsetree.Pdir_int (x0, x1) ->\n Ast_411.Parsetree.Pdir_int (x0, Option.map (fun x -> x) x1)\n | Ast_412.Parsetree.Pdir_ident x0 ->\n Ast_411.Parsetree.Pdir_ident (copy_Longident_t x0)\n | Ast_412.Parsetree.Pdir_bool x0 -> Ast_411.Parsetree.Pdir_bool x0\n\nand copy_expression :\n Ast_412.Parsetree.expression -> Ast_411.Parsetree.expression =\n fun {\n Ast_412.Parsetree.pexp_desc;\n Ast_412.Parsetree.pexp_loc;\n Ast_412.Parsetree.pexp_loc_stack;\n Ast_412.Parsetree.pexp_attributes;\n } ->\n {\n Ast_411.Parsetree.pexp_desc = copy_expression_desc pexp_desc;\n Ast_411.Parsetree.pexp_loc = copy_location pexp_loc;\n Ast_411.Parsetree.pexp_loc_stack = copy_location_stack pexp_loc_stack;\n Ast_411.Parsetree.pexp_attributes = copy_attributes pexp_attributes;\n }\n\nand copy_expression_desc :\n Ast_412.Parsetree.expression_desc -> Ast_411.Parsetree.expression_desc =\n function\n | Ast_412.Parsetree.Pexp_ident x0 ->\n Ast_411.Parsetree.Pexp_ident (copy_loc copy_Longident_t x0)\n | Ast_412.Parsetree.Pexp_constant x0 ->\n Ast_411.Parsetree.Pexp_constant (copy_constant x0)\n | Ast_412.Parsetree.Pexp_let (x0, x1, x2) ->\n Ast_411.Parsetree.Pexp_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_expression x2)\n | Ast_412.Parsetree.Pexp_function x0 ->\n Ast_411.Parsetree.Pexp_function (List.map copy_case x0)\n | Ast_412.Parsetree.Pexp_fun (x0, x1, x2, x3) ->\n Ast_411.Parsetree.Pexp_fun\n ( copy_arg_label x0,\n Option.map copy_expression x1,\n copy_pattern x2,\n copy_expression x3 )\n | Ast_412.Parsetree.Pexp_apply (x0, x1) ->\n Ast_411.Parsetree.Pexp_apply\n ( copy_expression x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | Ast_412.Parsetree.Pexp_match (x0, x1) ->\n Ast_411.Parsetree.Pexp_match (copy_expression x0, List.map copy_case x1)\n | Ast_412.Parsetree.Pexp_try (x0, x1) ->\n Ast_411.Parsetree.Pexp_try (copy_expression x0, List.map copy_case x1)\n | Ast_412.Parsetree.Pexp_tuple x0 ->\n Ast_411.Parsetree.Pexp_tuple (List.map copy_expression x0)\n | Ast_412.Parsetree.Pexp_construct (x0, x1) ->\n Ast_411.Parsetree.Pexp_construct\n (copy_loc copy_Longident_t x0, Option.map copy_expression x1)\n | Ast_412.Parsetree.Pexp_variant (x0, x1) ->\n Ast_411.Parsetree.Pexp_variant\n (copy_label x0, Option.map copy_expression x1)\n | Ast_412.Parsetree.Pexp_record (x0, x1) ->\n Ast_411.Parsetree.Pexp_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_expression x1))\n x0,\n Option.map copy_expression x1 )\n | Ast_412.Parsetree.Pexp_field (x0, x1) ->\n Ast_411.Parsetree.Pexp_field\n (copy_expression x0, copy_loc copy_Longident_t x1)\n | Ast_412.Parsetree.Pexp_setfield (x0, x1, x2) ->\n Ast_411.Parsetree.Pexp_setfield\n (copy_expression x0, copy_loc copy_Longident_t x1, copy_expression x2)\n | Ast_412.Parsetree.Pexp_array x0 ->\n Ast_411.Parsetree.Pexp_array (List.map copy_expression x0)\n | Ast_412.Parsetree.Pexp_ifthenelse (x0, x1, x2) ->\n Ast_411.Parsetree.Pexp_ifthenelse\n (copy_expression x0, copy_expression x1, Option.map copy_expression x2)\n | Ast_412.Parsetree.Pexp_sequence (x0, x1) ->\n Ast_411.Parsetree.Pexp_sequence (copy_expression x0, copy_expression x1)\n | Ast_412.Parsetree.Pexp_while (x0, x1) ->\n Ast_411.Parsetree.Pexp_while (copy_expression x0, copy_expression x1)\n | Ast_412.Parsetree.Pexp_for (x0, x1, x2, x3, x4) ->\n Ast_411.Parsetree.Pexp_for\n ( copy_pattern x0,\n copy_expression x1,\n copy_expression x2,\n copy_direction_flag x3,\n copy_expression x4 )\n | Ast_412.Parsetree.Pexp_constraint (x0, x1) ->\n Ast_411.Parsetree.Pexp_constraint (copy_expression x0, copy_core_type x1)\n | Ast_412.Parsetree.Pexp_coerce (x0, x1, x2) ->\n Ast_411.Parsetree.Pexp_coerce\n (copy_expression x0, Option.map copy_core_type x1, copy_core_type x2)\n | Ast_412.Parsetree.Pexp_send (x0, x1) ->\n Ast_411.Parsetree.Pexp_send (copy_expression x0, copy_loc copy_label x1)\n | Ast_412.Parsetree.Pexp_new x0 ->\n Ast_411.Parsetree.Pexp_new (copy_loc copy_Longident_t x0)\n | Ast_412.Parsetree.Pexp_setinstvar (x0, x1) ->\n Ast_411.Parsetree.Pexp_setinstvar\n (copy_loc copy_label x0, copy_expression x1)\n | Ast_412.Parsetree.Pexp_override x0 ->\n Ast_411.Parsetree.Pexp_override\n (List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_label x0, copy_expression x1))\n x0)\n | Ast_412.Parsetree.Pexp_letmodule (x0, x1, x2) ->\n Ast_411.Parsetree.Pexp_letmodule\n ( copy_loc (fun x -> Option.map (fun x -> x) x) x0,\n copy_module_expr x1,\n copy_expression x2 )\n | Ast_412.Parsetree.Pexp_letexception (x0, x1) ->\n Ast_411.Parsetree.Pexp_letexception\n (copy_extension_constructor x0, copy_expression x1)\n | Ast_412.Parsetree.Pexp_assert x0 ->\n Ast_411.Parsetree.Pexp_assert (copy_expression x0)\n | Ast_412.Parsetree.Pexp_lazy x0 ->\n Ast_411.Parsetree.Pexp_lazy (copy_expression x0)\n | Ast_412.Parsetree.Pexp_poly (x0, x1) ->\n Ast_411.Parsetree.Pexp_poly\n (copy_expression x0, Option.map copy_core_type x1)\n | Ast_412.Parsetree.Pexp_object x0 ->\n Ast_411.Parsetree.Pexp_object (copy_class_structure x0)\n | Ast_412.Parsetree.Pexp_newtype (x0, x1) ->\n Ast_411.Parsetree.Pexp_newtype\n (copy_loc (fun x -> x) x0, copy_expression x1)\n | Ast_412.Parsetree.Pexp_pack x0 ->\n Ast_411.Parsetree.Pexp_pack (copy_module_expr x0)\n | Ast_412.Parsetree.Pexp_open (x0, x1) ->\n Ast_411.Parsetree.Pexp_open (copy_open_declaration x0, copy_expression x1)\n | Ast_412.Parsetree.Pexp_letop x0 ->\n Ast_411.Parsetree.Pexp_letop (copy_letop x0)\n | Ast_412.Parsetree.Pexp_extension x0 ->\n Ast_411.Parsetree.Pexp_extension (copy_extension x0)\n | Ast_412.Parsetree.Pexp_unreachable -> Ast_411.Parsetree.Pexp_unreachable\n\nand copy_letop : Ast_412.Parsetree.letop -> Ast_411.Parsetree.letop =\n fun { Ast_412.Parsetree.let_; Ast_412.Parsetree.ands; Ast_412.Parsetree.body } ->\n {\n Ast_411.Parsetree.let_ = copy_binding_op let_;\n Ast_411.Parsetree.ands = List.map copy_binding_op ands;\n Ast_411.Parsetree.body = copy_expression body;\n }\n\nand copy_binding_op :\n Ast_412.Parsetree.binding_op -> Ast_411.Parsetree.binding_op =\n fun {\n Ast_412.Parsetree.pbop_op;\n Ast_412.Parsetree.pbop_pat;\n Ast_412.Parsetree.pbop_exp;\n Ast_412.Parsetree.pbop_loc;\n } ->\n {\n Ast_411.Parsetree.pbop_op = copy_loc (fun x -> x) pbop_op;\n Ast_411.Parsetree.pbop_pat = copy_pattern pbop_pat;\n Ast_411.Parsetree.pbop_exp = copy_expression pbop_exp;\n Ast_411.Parsetree.pbop_loc = copy_location pbop_loc;\n }\n\nand copy_direction_flag :\n Ast_412.Asttypes.direction_flag -> Ast_411.Asttypes.direction_flag =\n function\n | Ast_412.Asttypes.Upto -> Ast_411.Asttypes.Upto\n | Ast_412.Asttypes.Downto -> Ast_411.Asttypes.Downto\n\nand copy_case : Ast_412.Parsetree.case -> Ast_411.Parsetree.case =\n fun {\n Ast_412.Parsetree.pc_lhs;\n Ast_412.Parsetree.pc_guard;\n Ast_412.Parsetree.pc_rhs;\n } ->\n {\n Ast_411.Parsetree.pc_lhs = copy_pattern pc_lhs;\n Ast_411.Parsetree.pc_guard = Option.map copy_expression pc_guard;\n Ast_411.Parsetree.pc_rhs = copy_expression pc_rhs;\n }\n\nand copy_value_binding :\n Ast_412.Parsetree.value_binding -> Ast_411.Parsetree.value_binding =\n fun {\n Ast_412.Parsetree.pvb_pat;\n Ast_412.Parsetree.pvb_expr;\n Ast_412.Parsetree.pvb_attributes;\n Ast_412.Parsetree.pvb_loc;\n } ->\n {\n Ast_411.Parsetree.pvb_pat = copy_pattern pvb_pat;\n Ast_411.Parsetree.pvb_expr = copy_expression pvb_expr;\n Ast_411.Parsetree.pvb_attributes = copy_attributes pvb_attributes;\n Ast_411.Parsetree.pvb_loc = copy_location pvb_loc;\n }\n\nand copy_pattern : Ast_412.Parsetree.pattern -> Ast_411.Parsetree.pattern =\n fun {\n Ast_412.Parsetree.ppat_desc;\n Ast_412.Parsetree.ppat_loc;\n Ast_412.Parsetree.ppat_loc_stack;\n Ast_412.Parsetree.ppat_attributes;\n } ->\n {\n Ast_411.Parsetree.ppat_desc = copy_pattern_desc ppat_desc;\n Ast_411.Parsetree.ppat_loc = copy_location ppat_loc;\n Ast_411.Parsetree.ppat_loc_stack = copy_location_stack ppat_loc_stack;\n Ast_411.Parsetree.ppat_attributes = copy_attributes ppat_attributes;\n }\n\nand copy_pattern_desc :\n Ast_412.Parsetree.pattern_desc -> Ast_411.Parsetree.pattern_desc = function\n | Ast_412.Parsetree.Ppat_any -> Ast_411.Parsetree.Ppat_any\n | Ast_412.Parsetree.Ppat_var x0 ->\n Ast_411.Parsetree.Ppat_var (copy_loc (fun x -> x) x0)\n | Ast_412.Parsetree.Ppat_alias (x0, x1) ->\n Ast_411.Parsetree.Ppat_alias (copy_pattern x0, copy_loc (fun x -> x) x1)\n | Ast_412.Parsetree.Ppat_constant x0 ->\n Ast_411.Parsetree.Ppat_constant (copy_constant x0)\n | Ast_412.Parsetree.Ppat_interval (x0, x1) ->\n Ast_411.Parsetree.Ppat_interval (copy_constant x0, copy_constant x1)\n | Ast_412.Parsetree.Ppat_tuple x0 ->\n Ast_411.Parsetree.Ppat_tuple (List.map copy_pattern x0)\n | Ast_412.Parsetree.Ppat_construct (x0, x1) ->\n Ast_411.Parsetree.Ppat_construct\n (copy_loc copy_Longident_t x0, Option.map copy_pattern x1)\n | Ast_412.Parsetree.Ppat_variant (x0, x1) ->\n Ast_411.Parsetree.Ppat_variant (copy_label x0, Option.map copy_pattern x1)\n | Ast_412.Parsetree.Ppat_record (x0, x1) ->\n Ast_411.Parsetree.Ppat_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_pattern x1))\n x0,\n copy_closed_flag x1 )\n | Ast_412.Parsetree.Ppat_array x0 ->\n Ast_411.Parsetree.Ppat_array (List.map copy_pattern x0)\n | Ast_412.Parsetree.Ppat_or (x0, x1) ->\n Ast_411.Parsetree.Ppat_or (copy_pattern x0, copy_pattern x1)\n | Ast_412.Parsetree.Ppat_constraint (x0, x1) ->\n Ast_411.Parsetree.Ppat_constraint (copy_pattern x0, copy_core_type x1)\n | Ast_412.Parsetree.Ppat_type x0 ->\n Ast_411.Parsetree.Ppat_type (copy_loc copy_Longident_t x0)\n | Ast_412.Parsetree.Ppat_lazy x0 ->\n Ast_411.Parsetree.Ppat_lazy (copy_pattern x0)\n | Ast_412.Parsetree.Ppat_unpack x0 ->\n Ast_411.Parsetree.Ppat_unpack\n (copy_loc (fun x -> Option.map (fun x -> x) x) x0)\n | Ast_412.Parsetree.Ppat_exception x0 ->\n Ast_411.Parsetree.Ppat_exception (copy_pattern x0)\n | Ast_412.Parsetree.Ppat_extension x0 ->\n Ast_411.Parsetree.Ppat_extension (copy_extension x0)\n | Ast_412.Parsetree.Ppat_open (x0, x1) ->\n Ast_411.Parsetree.Ppat_open (copy_loc copy_Longident_t x0, copy_pattern x1)\n\nand copy_core_type : Ast_412.Parsetree.core_type -> Ast_411.Parsetree.core_type\n =\n fun {\n Ast_412.Parsetree.ptyp_desc;\n Ast_412.Parsetree.ptyp_loc;\n Ast_412.Parsetree.ptyp_loc_stack;\n Ast_412.Parsetree.ptyp_attributes;\n } ->\n {\n Ast_411.Parsetree.ptyp_desc = copy_core_type_desc ptyp_desc;\n Ast_411.Parsetree.ptyp_loc = copy_location ptyp_loc;\n Ast_411.Parsetree.ptyp_loc_stack = copy_location_stack ptyp_loc_stack;\n Ast_411.Parsetree.ptyp_attributes = copy_attributes ptyp_attributes;\n }\n\nand copy_location_stack :\n Ast_412.Parsetree.location_stack -> Ast_411.Parsetree.location_stack =\n fun x -> x\n\nand copy_core_type_desc :\n Ast_412.Parsetree.core_type_desc -> Ast_411.Parsetree.core_type_desc =\n function\n | Ast_412.Parsetree.Ptyp_any -> Ast_411.Parsetree.Ptyp_any\n | Ast_412.Parsetree.Ptyp_var x0 -> Ast_411.Parsetree.Ptyp_var x0\n | Ast_412.Parsetree.Ptyp_arrow (x0, x1, x2) ->\n Ast_411.Parsetree.Ptyp_arrow\n (copy_arg_label x0, copy_core_type x1, copy_core_type x2)\n | Ast_412.Parsetree.Ptyp_tuple x0 ->\n Ast_411.Parsetree.Ptyp_tuple (List.map copy_core_type x0)\n | Ast_412.Parsetree.Ptyp_constr (x0, x1) ->\n Ast_411.Parsetree.Ptyp_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_412.Parsetree.Ptyp_object (x0, x1) ->\n Ast_411.Parsetree.Ptyp_object\n (List.map copy_object_field x0, copy_closed_flag x1)\n | Ast_412.Parsetree.Ptyp_class (x0, x1) ->\n Ast_411.Parsetree.Ptyp_class\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_412.Parsetree.Ptyp_alias (x0, x1) ->\n Ast_411.Parsetree.Ptyp_alias (copy_core_type x0, x1)\n | Ast_412.Parsetree.Ptyp_variant (x0, x1, x2) ->\n Ast_411.Parsetree.Ptyp_variant\n ( List.map copy_row_field x0,\n copy_closed_flag x1,\n Option.map (fun x -> List.map copy_label x) x2 )\n | Ast_412.Parsetree.Ptyp_poly (x0, x1) ->\n Ast_411.Parsetree.Ptyp_poly\n (List.map (fun x -> copy_loc (fun x -> x) x) x0, copy_core_type x1)\n | Ast_412.Parsetree.Ptyp_package x0 ->\n Ast_411.Parsetree.Ptyp_package (copy_package_type x0)\n | Ast_412.Parsetree.Ptyp_extension x0 ->\n Ast_411.Parsetree.Ptyp_extension (copy_extension x0)\n\nand copy_package_type :\n Ast_412.Parsetree.package_type -> Ast_411.Parsetree.package_type =\n fun x ->\n let x0, x1 = x in\n ( copy_loc copy_Longident_t x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_core_type x1))\n x1 )\n\nand copy_row_field : Ast_412.Parsetree.row_field -> Ast_411.Parsetree.row_field\n =\n fun {\n Ast_412.Parsetree.prf_desc;\n Ast_412.Parsetree.prf_loc;\n Ast_412.Parsetree.prf_attributes;\n } ->\n {\n Ast_411.Parsetree.prf_desc = copy_row_field_desc prf_desc;\n Ast_411.Parsetree.prf_loc = copy_location prf_loc;\n Ast_411.Parsetree.prf_attributes = copy_attributes prf_attributes;\n }\n\nand copy_row_field_desc :\n Ast_412.Parsetree.row_field_desc -> Ast_411.Parsetree.row_field_desc =\n function\n | Ast_412.Parsetree.Rtag (x0, x1, x2) ->\n Ast_411.Parsetree.Rtag\n (copy_loc copy_label x0, x1, List.map copy_core_type x2)\n | Ast_412.Parsetree.Rinherit x0 ->\n Ast_411.Parsetree.Rinherit (copy_core_type x0)\n\nand copy_object_field :\n Ast_412.Parsetree.object_field -> Ast_411.Parsetree.object_field =\n fun {\n Ast_412.Parsetree.pof_desc;\n Ast_412.Parsetree.pof_loc;\n Ast_412.Parsetree.pof_attributes;\n } ->\n {\n Ast_411.Parsetree.pof_desc = copy_object_field_desc pof_desc;\n Ast_411.Parsetree.pof_loc = copy_location pof_loc;\n Ast_411.Parsetree.pof_attributes = copy_attributes pof_attributes;\n }\n\nand copy_attributes :\n Ast_412.Parsetree.attributes -> Ast_411.Parsetree.attributes =\n fun x -> List.map copy_attribute x\n\nand copy_attribute : Ast_412.Parsetree.attribute -> Ast_411.Parsetree.attribute\n =\n fun {\n Ast_412.Parsetree.attr_name;\n Ast_412.Parsetree.attr_payload;\n Ast_412.Parsetree.attr_loc;\n } ->\n {\n Ast_411.Parsetree.attr_name = copy_loc (fun x -> x) attr_name;\n Ast_411.Parsetree.attr_payload = copy_payload attr_payload;\n Ast_411.Parsetree.attr_loc = copy_location attr_loc;\n }\n\nand copy_payload : Ast_412.Parsetree.payload -> Ast_411.Parsetree.payload =\n function\n | Ast_412.Parsetree.PStr x0 -> Ast_411.Parsetree.PStr (copy_structure x0)\n | Ast_412.Parsetree.PSig x0 -> Ast_411.Parsetree.PSig (copy_signature x0)\n | Ast_412.Parsetree.PTyp x0 -> Ast_411.Parsetree.PTyp (copy_core_type x0)\n | Ast_412.Parsetree.PPat (x0, x1) ->\n Ast_411.Parsetree.PPat (copy_pattern x0, Option.map copy_expression x1)\n\nand copy_structure : Ast_412.Parsetree.structure -> Ast_411.Parsetree.structure\n =\n fun x -> List.map copy_structure_item x\n\nand copy_structure_item :\n Ast_412.Parsetree.structure_item -> Ast_411.Parsetree.structure_item =\n fun { Ast_412.Parsetree.pstr_desc; Ast_412.Parsetree.pstr_loc } ->\n {\n Ast_411.Parsetree.pstr_desc = copy_structure_item_desc pstr_desc;\n Ast_411.Parsetree.pstr_loc = copy_location pstr_loc;\n }\n\nand copy_structure_item_desc :\n Ast_412.Parsetree.structure_item_desc ->\n Ast_411.Parsetree.structure_item_desc = function\n | Ast_412.Parsetree.Pstr_eval (x0, x1) ->\n Ast_411.Parsetree.Pstr_eval (copy_expression x0, copy_attributes x1)\n | Ast_412.Parsetree.Pstr_value (x0, x1) ->\n Ast_411.Parsetree.Pstr_value\n (copy_rec_flag x0, List.map copy_value_binding x1)\n | Ast_412.Parsetree.Pstr_primitive x0 ->\n Ast_411.Parsetree.Pstr_primitive (copy_value_description x0)\n | Ast_412.Parsetree.Pstr_type (x0, x1) ->\n Ast_411.Parsetree.Pstr_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | Ast_412.Parsetree.Pstr_typext x0 ->\n Ast_411.Parsetree.Pstr_typext (copy_type_extension x0)\n | Ast_412.Parsetree.Pstr_exception x0 ->\n Ast_411.Parsetree.Pstr_exception (copy_type_exception x0)\n | Ast_412.Parsetree.Pstr_module x0 ->\n Ast_411.Parsetree.Pstr_module (copy_module_binding x0)\n | Ast_412.Parsetree.Pstr_recmodule x0 ->\n Ast_411.Parsetree.Pstr_recmodule (List.map copy_module_binding x0)\n | Ast_412.Parsetree.Pstr_modtype x0 ->\n Ast_411.Parsetree.Pstr_modtype (copy_module_type_declaration x0)\n | Ast_412.Parsetree.Pstr_open x0 ->\n Ast_411.Parsetree.Pstr_open (copy_open_declaration x0)\n | Ast_412.Parsetree.Pstr_class x0 ->\n Ast_411.Parsetree.Pstr_class (List.map copy_class_declaration x0)\n | Ast_412.Parsetree.Pstr_class_type x0 ->\n Ast_411.Parsetree.Pstr_class_type\n (List.map copy_class_type_declaration x0)\n | Ast_412.Parsetree.Pstr_include x0 ->\n Ast_411.Parsetree.Pstr_include (copy_include_declaration x0)\n | Ast_412.Parsetree.Pstr_attribute x0 ->\n Ast_411.Parsetree.Pstr_attribute (copy_attribute x0)\n | Ast_412.Parsetree.Pstr_extension (x0, x1) ->\n Ast_411.Parsetree.Pstr_extension (copy_extension x0, copy_attributes x1)\n\nand copy_include_declaration :\n Ast_412.Parsetree.include_declaration ->\n Ast_411.Parsetree.include_declaration =\n fun x -> copy_include_infos copy_module_expr x\n\nand copy_class_declaration :\n Ast_412.Parsetree.class_declaration -> Ast_411.Parsetree.class_declaration =\n fun x -> copy_class_infos copy_class_expr x\n\nand copy_class_expr :\n Ast_412.Parsetree.class_expr -> Ast_411.Parsetree.class_expr =\n fun {\n Ast_412.Parsetree.pcl_desc;\n Ast_412.Parsetree.pcl_loc;\n Ast_412.Parsetree.pcl_attributes;\n } ->\n {\n Ast_411.Parsetree.pcl_desc = copy_class_expr_desc pcl_desc;\n Ast_411.Parsetree.pcl_loc = copy_location pcl_loc;\n Ast_411.Parsetree.pcl_attributes = copy_attributes pcl_attributes;\n }\n\nand copy_class_expr_desc :\n Ast_412.Parsetree.class_expr_desc -> Ast_411.Parsetree.class_expr_desc =\n function\n | Ast_412.Parsetree.Pcl_constr (x0, x1) ->\n Ast_411.Parsetree.Pcl_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_412.Parsetree.Pcl_structure x0 ->\n Ast_411.Parsetree.Pcl_structure (copy_class_structure x0)\n | Ast_412.Parsetree.Pcl_fun (x0, x1, x2, x3) ->\n Ast_411.Parsetree.Pcl_fun\n ( copy_arg_label x0,\n Option.map copy_expression x1,\n copy_pattern x2,\n copy_class_expr x3 )\n | Ast_412.Parsetree.Pcl_apply (x0, x1) ->\n Ast_411.Parsetree.Pcl_apply\n ( copy_class_expr x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | Ast_412.Parsetree.Pcl_let (x0, x1, x2) ->\n Ast_411.Parsetree.Pcl_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_class_expr x2)\n | Ast_412.Parsetree.Pcl_constraint (x0, x1) ->\n Ast_411.Parsetree.Pcl_constraint (copy_class_expr x0, copy_class_type x1)\n | Ast_412.Parsetree.Pcl_extension x0 ->\n Ast_411.Parsetree.Pcl_extension (copy_extension x0)\n | Ast_412.Parsetree.Pcl_open (x0, x1) ->\n Ast_411.Parsetree.Pcl_open (copy_open_description x0, copy_class_expr x1)\n\nand copy_class_structure :\n Ast_412.Parsetree.class_structure -> Ast_411.Parsetree.class_structure =\n fun { Ast_412.Parsetree.pcstr_self; Ast_412.Parsetree.pcstr_fields } ->\n {\n Ast_411.Parsetree.pcstr_self = copy_pattern pcstr_self;\n Ast_411.Parsetree.pcstr_fields = List.map copy_class_field pcstr_fields;\n }\n\nand copy_class_field :\n Ast_412.Parsetree.class_field -> Ast_411.Parsetree.class_field =\n fun {\n Ast_412.Parsetree.pcf_desc;\n Ast_412.Parsetree.pcf_loc;\n Ast_412.Parsetree.pcf_attributes;\n } ->\n {\n Ast_411.Parsetree.pcf_desc = copy_class_field_desc pcf_desc;\n Ast_411.Parsetree.pcf_loc = copy_location pcf_loc;\n Ast_411.Parsetree.pcf_attributes = copy_attributes pcf_attributes;\n }\n\nand copy_class_field_desc :\n Ast_412.Parsetree.class_field_desc -> Ast_411.Parsetree.class_field_desc =\n function\n | Ast_412.Parsetree.Pcf_inherit (x0, x1, x2) ->\n Ast_411.Parsetree.Pcf_inherit\n ( copy_override_flag x0,\n copy_class_expr x1,\n Option.map (fun x -> copy_loc (fun x -> x) x) x2 )\n | Ast_412.Parsetree.Pcf_val x0 ->\n Ast_411.Parsetree.Pcf_val\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_mutable_flag x1, copy_class_field_kind x2))\n | Ast_412.Parsetree.Pcf_method x0 ->\n Ast_411.Parsetree.Pcf_method\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_private_flag x1, copy_class_field_kind x2))\n | Ast_412.Parsetree.Pcf_constraint x0 ->\n Ast_411.Parsetree.Pcf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | Ast_412.Parsetree.Pcf_initializer x0 ->\n Ast_411.Parsetree.Pcf_initializer (copy_expression x0)\n | Ast_412.Parsetree.Pcf_attribute x0 ->\n Ast_411.Parsetree.Pcf_attribute (copy_attribute x0)\n | Ast_412.Parsetree.Pcf_extension x0 ->\n Ast_411.Parsetree.Pcf_extension (copy_extension x0)\n\nand copy_class_field_kind :\n Ast_412.Parsetree.class_field_kind -> Ast_411.Parsetree.class_field_kind =\n function\n | Ast_412.Parsetree.Cfk_virtual x0 ->\n Ast_411.Parsetree.Cfk_virtual (copy_core_type x0)\n | Ast_412.Parsetree.Cfk_concrete (x0, x1) ->\n Ast_411.Parsetree.Cfk_concrete (copy_override_flag x0, copy_expression x1)\n\nand copy_open_declaration :\n Ast_412.Parsetree.open_declaration -> Ast_411.Parsetree.open_declaration =\n fun x -> copy_open_infos copy_module_expr x\n\nand copy_module_binding :\n Ast_412.Parsetree.module_binding -> Ast_411.Parsetree.module_binding =\n fun {\n Ast_412.Parsetree.pmb_name;\n Ast_412.Parsetree.pmb_expr;\n Ast_412.Parsetree.pmb_attributes;\n Ast_412.Parsetree.pmb_loc;\n } ->\n {\n Ast_411.Parsetree.pmb_name =\n copy_loc (fun x -> Option.map (fun x -> x) x) pmb_name;\n Ast_411.Parsetree.pmb_expr = copy_module_expr pmb_expr;\n Ast_411.Parsetree.pmb_attributes = copy_attributes pmb_attributes;\n Ast_411.Parsetree.pmb_loc = copy_location pmb_loc;\n }\n\nand copy_module_expr :\n Ast_412.Parsetree.module_expr -> Ast_411.Parsetree.module_expr =\n fun {\n Ast_412.Parsetree.pmod_desc;\n Ast_412.Parsetree.pmod_loc;\n Ast_412.Parsetree.pmod_attributes;\n } ->\n {\n Ast_411.Parsetree.pmod_desc = copy_module_expr_desc pmod_desc;\n Ast_411.Parsetree.pmod_loc = copy_location pmod_loc;\n Ast_411.Parsetree.pmod_attributes = copy_attributes pmod_attributes;\n }\n\nand copy_module_expr_desc :\n Ast_412.Parsetree.module_expr_desc -> Ast_411.Parsetree.module_expr_desc =\n function\n | Ast_412.Parsetree.Pmod_ident x0 ->\n Ast_411.Parsetree.Pmod_ident (copy_loc copy_Longident_t x0)\n | Ast_412.Parsetree.Pmod_structure x0 ->\n Ast_411.Parsetree.Pmod_structure (copy_structure x0)\n | Ast_412.Parsetree.Pmod_functor (x0, x1) ->\n Ast_411.Parsetree.Pmod_functor\n (copy_functor_parameter x0, copy_module_expr x1)\n | Ast_412.Parsetree.Pmod_apply (x0, x1) ->\n Ast_411.Parsetree.Pmod_apply (copy_module_expr x0, copy_module_expr x1)\n | Ast_412.Parsetree.Pmod_constraint (x0, x1) ->\n Ast_411.Parsetree.Pmod_constraint\n (copy_module_expr x0, copy_module_type x1)\n | Ast_412.Parsetree.Pmod_unpack x0 ->\n Ast_411.Parsetree.Pmod_unpack (copy_expression x0)\n | Ast_412.Parsetree.Pmod_extension x0 ->\n Ast_411.Parsetree.Pmod_extension (copy_extension x0)\n\nand copy_functor_parameter :\n Ast_412.Parsetree.functor_parameter -> Ast_411.Parsetree.functor_parameter =\n function\n | Ast_412.Parsetree.Unit -> Ast_411.Parsetree.Unit\n | Ast_412.Parsetree.Named (x0, x1) ->\n Ast_411.Parsetree.Named\n (copy_loc (fun x -> Option.map (fun x -> x) x) x0, copy_module_type x1)\n\nand copy_module_type :\n Ast_412.Parsetree.module_type -> Ast_411.Parsetree.module_type =\n fun {\n Ast_412.Parsetree.pmty_desc;\n Ast_412.Parsetree.pmty_loc;\n Ast_412.Parsetree.pmty_attributes;\n } ->\n {\n Ast_411.Parsetree.pmty_desc = copy_module_type_desc pmty_desc;\n Ast_411.Parsetree.pmty_loc = copy_location pmty_loc;\n Ast_411.Parsetree.pmty_attributes = copy_attributes pmty_attributes;\n }\n\nand copy_module_type_desc :\n Ast_412.Parsetree.module_type_desc -> Ast_411.Parsetree.module_type_desc =\n function\n | Ast_412.Parsetree.Pmty_ident x0 ->\n Ast_411.Parsetree.Pmty_ident (copy_loc copy_Longident_t x0)\n | Ast_412.Parsetree.Pmty_signature x0 ->\n Ast_411.Parsetree.Pmty_signature (copy_signature x0)\n | Ast_412.Parsetree.Pmty_functor (x0, x1) ->\n Ast_411.Parsetree.Pmty_functor\n (copy_functor_parameter x0, copy_module_type x1)\n | Ast_412.Parsetree.Pmty_with (x0, x1) ->\n Ast_411.Parsetree.Pmty_with\n (copy_module_type x0, List.map copy_with_constraint x1)\n | Ast_412.Parsetree.Pmty_typeof x0 ->\n Ast_411.Parsetree.Pmty_typeof (copy_module_expr x0)\n | Ast_412.Parsetree.Pmty_extension x0 ->\n Ast_411.Parsetree.Pmty_extension (copy_extension x0)\n | Ast_412.Parsetree.Pmty_alias x0 ->\n Ast_411.Parsetree.Pmty_alias (copy_loc copy_Longident_t x0)\n\nand copy_with_constraint :\n Ast_412.Parsetree.with_constraint -> Ast_411.Parsetree.with_constraint =\n function\n | Ast_412.Parsetree.Pwith_type (x0, x1) ->\n Ast_411.Parsetree.Pwith_type\n (copy_loc copy_Longident_t x0, copy_type_declaration x1)\n | Ast_412.Parsetree.Pwith_module (x0, x1) ->\n Ast_411.Parsetree.Pwith_module\n (copy_loc copy_Longident_t x0, copy_loc copy_Longident_t x1)\n | Ast_412.Parsetree.Pwith_typesubst (x0, x1) ->\n Ast_411.Parsetree.Pwith_typesubst\n (copy_loc copy_Longident_t x0, copy_type_declaration x1)\n | Ast_412.Parsetree.Pwith_modsubst (x0, x1) ->\n Ast_411.Parsetree.Pwith_modsubst\n (copy_loc copy_Longident_t x0, copy_loc copy_Longident_t x1)\n\nand copy_signature : Ast_412.Parsetree.signature -> Ast_411.Parsetree.signature\n =\n fun x -> List.map copy_signature_item x\n\nand copy_signature_item :\n Ast_412.Parsetree.signature_item -> Ast_411.Parsetree.signature_item =\n fun { Ast_412.Parsetree.psig_desc; Ast_412.Parsetree.psig_loc } ->\n {\n Ast_411.Parsetree.psig_desc = copy_signature_item_desc psig_desc;\n Ast_411.Parsetree.psig_loc = copy_location psig_loc;\n }\n\nand copy_signature_item_desc :\n Ast_412.Parsetree.signature_item_desc ->\n Ast_411.Parsetree.signature_item_desc = function\n | Ast_412.Parsetree.Psig_value x0 ->\n Ast_411.Parsetree.Psig_value (copy_value_description x0)\n | Ast_412.Parsetree.Psig_type (x0, x1) ->\n Ast_411.Parsetree.Psig_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | Ast_412.Parsetree.Psig_typesubst x0 ->\n Ast_411.Parsetree.Psig_typesubst (List.map copy_type_declaration x0)\n | Ast_412.Parsetree.Psig_typext x0 ->\n Ast_411.Parsetree.Psig_typext (copy_type_extension x0)\n | Ast_412.Parsetree.Psig_exception x0 ->\n Ast_411.Parsetree.Psig_exception (copy_type_exception x0)\n | Ast_412.Parsetree.Psig_module x0 ->\n Ast_411.Parsetree.Psig_module (copy_module_declaration x0)\n | Ast_412.Parsetree.Psig_modsubst x0 ->\n Ast_411.Parsetree.Psig_modsubst (copy_module_substitution x0)\n | Ast_412.Parsetree.Psig_recmodule x0 ->\n Ast_411.Parsetree.Psig_recmodule (List.map copy_module_declaration x0)\n | Ast_412.Parsetree.Psig_modtype x0 ->\n Ast_411.Parsetree.Psig_modtype (copy_module_type_declaration x0)\n | Ast_412.Parsetree.Psig_open x0 ->\n Ast_411.Parsetree.Psig_open (copy_open_description x0)\n | Ast_412.Parsetree.Psig_include x0 ->\n Ast_411.Parsetree.Psig_include (copy_include_description x0)\n | Ast_412.Parsetree.Psig_class x0 ->\n Ast_411.Parsetree.Psig_class (List.map copy_class_description x0)\n | Ast_412.Parsetree.Psig_class_type x0 ->\n Ast_411.Parsetree.Psig_class_type\n (List.map copy_class_type_declaration x0)\n | Ast_412.Parsetree.Psig_attribute x0 ->\n Ast_411.Parsetree.Psig_attribute (copy_attribute x0)\n | Ast_412.Parsetree.Psig_extension (x0, x1) ->\n Ast_411.Parsetree.Psig_extension (copy_extension x0, copy_attributes x1)\n\nand copy_class_type_declaration :\n Ast_412.Parsetree.class_type_declaration ->\n Ast_411.Parsetree.class_type_declaration =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_description :\n Ast_412.Parsetree.class_description -> Ast_411.Parsetree.class_description =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_type :\n Ast_412.Parsetree.class_type -> Ast_411.Parsetree.class_type =\n fun {\n Ast_412.Parsetree.pcty_desc;\n Ast_412.Parsetree.pcty_loc;\n Ast_412.Parsetree.pcty_attributes;\n } ->\n {\n Ast_411.Parsetree.pcty_desc = copy_class_type_desc pcty_desc;\n Ast_411.Parsetree.pcty_loc = copy_location pcty_loc;\n Ast_411.Parsetree.pcty_attributes = copy_attributes pcty_attributes;\n }\n\nand copy_class_type_desc :\n Ast_412.Parsetree.class_type_desc -> Ast_411.Parsetree.class_type_desc =\n function\n | Ast_412.Parsetree.Pcty_constr (x0, x1) ->\n Ast_411.Parsetree.Pcty_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_412.Parsetree.Pcty_signature x0 ->\n Ast_411.Parsetree.Pcty_signature (copy_class_signature x0)\n | Ast_412.Parsetree.Pcty_arrow (x0, x1, x2) ->\n Ast_411.Parsetree.Pcty_arrow\n (copy_arg_label x0, copy_core_type x1, copy_class_type x2)\n | Ast_412.Parsetree.Pcty_extension x0 ->\n Ast_411.Parsetree.Pcty_extension (copy_extension x0)\n | Ast_412.Parsetree.Pcty_open (x0, x1) ->\n Ast_411.Parsetree.Pcty_open (copy_open_description x0, copy_class_type x1)\n\nand copy_class_signature :\n Ast_412.Parsetree.class_signature -> Ast_411.Parsetree.class_signature =\n fun { Ast_412.Parsetree.pcsig_self; Ast_412.Parsetree.pcsig_fields } ->\n {\n Ast_411.Parsetree.pcsig_self = copy_core_type pcsig_self;\n Ast_411.Parsetree.pcsig_fields = List.map copy_class_type_field pcsig_fields;\n }\n\nand copy_class_type_field :\n Ast_412.Parsetree.class_type_field -> Ast_411.Parsetree.class_type_field =\n fun {\n Ast_412.Parsetree.pctf_desc;\n Ast_412.Parsetree.pctf_loc;\n Ast_412.Parsetree.pctf_attributes;\n } ->\n {\n Ast_411.Parsetree.pctf_desc = copy_class_type_field_desc pctf_desc;\n Ast_411.Parsetree.pctf_loc = copy_location pctf_loc;\n Ast_411.Parsetree.pctf_attributes = copy_attributes pctf_attributes;\n }\n\nand copy_class_type_field_desc :\n Ast_412.Parsetree.class_type_field_desc ->\n Ast_411.Parsetree.class_type_field_desc = function\n | Ast_412.Parsetree.Pctf_inherit x0 ->\n Ast_411.Parsetree.Pctf_inherit (copy_class_type x0)\n | Ast_412.Parsetree.Pctf_val x0 ->\n Ast_411.Parsetree.Pctf_val\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_mutable_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | Ast_412.Parsetree.Pctf_method x0 ->\n Ast_411.Parsetree.Pctf_method\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_private_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | Ast_412.Parsetree.Pctf_constraint x0 ->\n Ast_411.Parsetree.Pctf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | Ast_412.Parsetree.Pctf_attribute x0 ->\n Ast_411.Parsetree.Pctf_attribute (copy_attribute x0)\n | Ast_412.Parsetree.Pctf_extension x0 ->\n Ast_411.Parsetree.Pctf_extension (copy_extension x0)\n\nand copy_extension : Ast_412.Parsetree.extension -> Ast_411.Parsetree.extension\n =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_class_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_412.Parsetree.class_infos ->\n 'g0 Ast_411.Parsetree.class_infos =\n fun f0\n {\n Ast_412.Parsetree.pci_virt;\n Ast_412.Parsetree.pci_params;\n Ast_412.Parsetree.pci_name;\n Ast_412.Parsetree.pci_expr;\n Ast_412.Parsetree.pci_loc;\n Ast_412.Parsetree.pci_attributes;\n } ->\n {\n Ast_411.Parsetree.pci_virt = copy_virtual_flag pci_virt;\n Ast_411.Parsetree.pci_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n ( copy_core_type x0,\n let x0, _ = x1 in\n copy_variance x0 ))\n pci_params;\n Ast_411.Parsetree.pci_name = copy_loc (fun x -> x) pci_name;\n Ast_411.Parsetree.pci_expr = f0 pci_expr;\n Ast_411.Parsetree.pci_loc = copy_location pci_loc;\n Ast_411.Parsetree.pci_attributes = copy_attributes pci_attributes;\n }\n\nand copy_virtual_flag :\n Ast_412.Asttypes.virtual_flag -> Ast_411.Asttypes.virtual_flag = function\n | Ast_412.Asttypes.Virtual -> Ast_411.Asttypes.Virtual\n | Ast_412.Asttypes.Concrete -> Ast_411.Asttypes.Concrete\n\nand copy_include_description :\n Ast_412.Parsetree.include_description ->\n Ast_411.Parsetree.include_description =\n fun x -> copy_include_infos copy_module_type x\n\nand copy_include_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_412.Parsetree.include_infos ->\n 'g0 Ast_411.Parsetree.include_infos =\n fun f0\n {\n Ast_412.Parsetree.pincl_mod;\n Ast_412.Parsetree.pincl_loc;\n Ast_412.Parsetree.pincl_attributes;\n } ->\n {\n Ast_411.Parsetree.pincl_mod = f0 pincl_mod;\n Ast_411.Parsetree.pincl_loc = copy_location pincl_loc;\n Ast_411.Parsetree.pincl_attributes = copy_attributes pincl_attributes;\n }\n\nand copy_open_description :\n Ast_412.Parsetree.open_description -> Ast_411.Parsetree.open_description =\n fun x -> copy_open_infos (fun x -> copy_loc copy_Longident_t x) x\n\nand copy_open_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_412.Parsetree.open_infos ->\n 'g0 Ast_411.Parsetree.open_infos =\n fun f0\n {\n Ast_412.Parsetree.popen_expr;\n Ast_412.Parsetree.popen_override;\n Ast_412.Parsetree.popen_loc;\n Ast_412.Parsetree.popen_attributes;\n } ->\n {\n Ast_411.Parsetree.popen_expr = f0 popen_expr;\n Ast_411.Parsetree.popen_override = copy_override_flag popen_override;\n Ast_411.Parsetree.popen_loc = copy_location popen_loc;\n Ast_411.Parsetree.popen_attributes = copy_attributes popen_attributes;\n }\n\nand copy_override_flag :\n Ast_412.Asttypes.override_flag -> Ast_411.Asttypes.override_flag = function\n | Ast_412.Asttypes.Override -> Ast_411.Asttypes.Override\n | Ast_412.Asttypes.Fresh -> Ast_411.Asttypes.Fresh\n\nand copy_module_type_declaration :\n Ast_412.Parsetree.module_type_declaration ->\n Ast_411.Parsetree.module_type_declaration =\n fun {\n Ast_412.Parsetree.pmtd_name;\n Ast_412.Parsetree.pmtd_type;\n Ast_412.Parsetree.pmtd_attributes;\n Ast_412.Parsetree.pmtd_loc;\n } ->\n {\n Ast_411.Parsetree.pmtd_name = copy_loc (fun x -> x) pmtd_name;\n Ast_411.Parsetree.pmtd_type = Option.map copy_module_type pmtd_type;\n Ast_411.Parsetree.pmtd_attributes = copy_attributes pmtd_attributes;\n Ast_411.Parsetree.pmtd_loc = copy_location pmtd_loc;\n }\n\nand copy_module_substitution :\n Ast_412.Parsetree.module_substitution ->\n Ast_411.Parsetree.module_substitution =\n fun {\n Ast_412.Parsetree.pms_name;\n Ast_412.Parsetree.pms_manifest;\n Ast_412.Parsetree.pms_attributes;\n Ast_412.Parsetree.pms_loc;\n } ->\n {\n Ast_411.Parsetree.pms_name = copy_loc (fun x -> x) pms_name;\n Ast_411.Parsetree.pms_manifest = copy_loc copy_Longident_t pms_manifest;\n Ast_411.Parsetree.pms_attributes = copy_attributes pms_attributes;\n Ast_411.Parsetree.pms_loc = copy_location pms_loc;\n }\n\nand copy_module_declaration :\n Ast_412.Parsetree.module_declaration -> Ast_411.Parsetree.module_declaration\n =\n fun {\n Ast_412.Parsetree.pmd_name;\n Ast_412.Parsetree.pmd_type;\n Ast_412.Parsetree.pmd_attributes;\n Ast_412.Parsetree.pmd_loc;\n } ->\n {\n Ast_411.Parsetree.pmd_name =\n copy_loc (fun x -> Option.map (fun x -> x) x) pmd_name;\n Ast_411.Parsetree.pmd_type = copy_module_type pmd_type;\n Ast_411.Parsetree.pmd_attributes = copy_attributes pmd_attributes;\n Ast_411.Parsetree.pmd_loc = copy_location pmd_loc;\n }\n\nand copy_type_exception :\n Ast_412.Parsetree.type_exception -> Ast_411.Parsetree.type_exception =\n fun {\n Ast_412.Parsetree.ptyexn_constructor;\n Ast_412.Parsetree.ptyexn_loc;\n Ast_412.Parsetree.ptyexn_attributes;\n } ->\n {\n Ast_411.Parsetree.ptyexn_constructor =\n copy_extension_constructor ptyexn_constructor;\n Ast_411.Parsetree.ptyexn_loc = copy_location ptyexn_loc;\n Ast_411.Parsetree.ptyexn_attributes = copy_attributes ptyexn_attributes;\n }\n\nand copy_type_extension :\n Ast_412.Parsetree.type_extension -> Ast_411.Parsetree.type_extension =\n fun {\n Ast_412.Parsetree.ptyext_path;\n Ast_412.Parsetree.ptyext_params;\n Ast_412.Parsetree.ptyext_constructors;\n Ast_412.Parsetree.ptyext_private;\n Ast_412.Parsetree.ptyext_loc;\n Ast_412.Parsetree.ptyext_attributes;\n } ->\n {\n Ast_411.Parsetree.ptyext_path = copy_loc copy_Longident_t ptyext_path;\n Ast_411.Parsetree.ptyext_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n ( copy_core_type x0,\n let x0, _ = x1 in\n copy_variance x0 ))\n ptyext_params;\n Ast_411.Parsetree.ptyext_constructors =\n List.map copy_extension_constructor ptyext_constructors;\n Ast_411.Parsetree.ptyext_private = copy_private_flag ptyext_private;\n Ast_411.Parsetree.ptyext_loc = copy_location ptyext_loc;\n Ast_411.Parsetree.ptyext_attributes = copy_attributes ptyext_attributes;\n }\n\nand copy_extension_constructor :\n Ast_412.Parsetree.extension_constructor ->\n Ast_411.Parsetree.extension_constructor =\n fun {\n Ast_412.Parsetree.pext_name;\n Ast_412.Parsetree.pext_kind;\n Ast_412.Parsetree.pext_loc;\n Ast_412.Parsetree.pext_attributes;\n } ->\n {\n Ast_411.Parsetree.pext_name = copy_loc (fun x -> x) pext_name;\n Ast_411.Parsetree.pext_kind = copy_extension_constructor_kind pext_kind;\n Ast_411.Parsetree.pext_loc = copy_location pext_loc;\n Ast_411.Parsetree.pext_attributes = copy_attributes pext_attributes;\n }\n\nand copy_extension_constructor_kind :\n Ast_412.Parsetree.extension_constructor_kind ->\n Ast_411.Parsetree.extension_constructor_kind = function\n | Ast_412.Parsetree.Pext_decl (x0, x1) ->\n Ast_411.Parsetree.Pext_decl\n (copy_constructor_arguments x0, Option.map copy_core_type x1)\n | Ast_412.Parsetree.Pext_rebind x0 ->\n Ast_411.Parsetree.Pext_rebind (copy_loc copy_Longident_t x0)\n\nand copy_type_declaration :\n Ast_412.Parsetree.type_declaration -> Ast_411.Parsetree.type_declaration =\n fun {\n Ast_412.Parsetree.ptype_name;\n Ast_412.Parsetree.ptype_params;\n Ast_412.Parsetree.ptype_cstrs;\n Ast_412.Parsetree.ptype_kind;\n Ast_412.Parsetree.ptype_private;\n Ast_412.Parsetree.ptype_manifest;\n Ast_412.Parsetree.ptype_attributes;\n Ast_412.Parsetree.ptype_loc;\n } ->\n {\n Ast_411.Parsetree.ptype_name = copy_loc (fun x -> x) ptype_name;\n Ast_411.Parsetree.ptype_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n ( copy_core_type x0,\n let x0, _ = x1 in\n copy_variance x0 ))\n ptype_params;\n Ast_411.Parsetree.ptype_cstrs =\n List.map\n (fun x ->\n let x0, x1, x2 = x in\n (copy_core_type x0, copy_core_type x1, copy_location x2))\n ptype_cstrs;\n Ast_411.Parsetree.ptype_kind = copy_type_kind ptype_kind;\n Ast_411.Parsetree.ptype_private = copy_private_flag ptype_private;\n Ast_411.Parsetree.ptype_manifest = Option.map copy_core_type ptype_manifest;\n Ast_411.Parsetree.ptype_attributes = copy_attributes ptype_attributes;\n Ast_411.Parsetree.ptype_loc = copy_location ptype_loc;\n }\n\nand copy_private_flag :\n Ast_412.Asttypes.private_flag -> Ast_411.Asttypes.private_flag = function\n | Ast_412.Asttypes.Private -> Ast_411.Asttypes.Private\n | Ast_412.Asttypes.Public -> Ast_411.Asttypes.Public\n\nand copy_type_kind : Ast_412.Parsetree.type_kind -> Ast_411.Parsetree.type_kind\n = function\n | Ast_412.Parsetree.Ptype_abstract -> Ast_411.Parsetree.Ptype_abstract\n | Ast_412.Parsetree.Ptype_variant x0 ->\n Ast_411.Parsetree.Ptype_variant (List.map copy_constructor_declaration x0)\n | Ast_412.Parsetree.Ptype_record x0 ->\n Ast_411.Parsetree.Ptype_record (List.map copy_label_declaration x0)\n | Ast_412.Parsetree.Ptype_open -> Ast_411.Parsetree.Ptype_open\n\nand copy_constructor_declaration :\n Ast_412.Parsetree.constructor_declaration ->\n Ast_411.Parsetree.constructor_declaration =\n fun {\n Ast_412.Parsetree.pcd_name;\n Ast_412.Parsetree.pcd_args;\n Ast_412.Parsetree.pcd_res;\n Ast_412.Parsetree.pcd_loc;\n Ast_412.Parsetree.pcd_attributes;\n } ->\n {\n Ast_411.Parsetree.pcd_name = copy_loc (fun x -> x) pcd_name;\n Ast_411.Parsetree.pcd_args = copy_constructor_arguments pcd_args;\n Ast_411.Parsetree.pcd_res = Option.map copy_core_type pcd_res;\n Ast_411.Parsetree.pcd_loc = copy_location pcd_loc;\n Ast_411.Parsetree.pcd_attributes = copy_attributes pcd_attributes;\n }\n\nand copy_constructor_arguments :\n Ast_412.Parsetree.constructor_arguments ->\n Ast_411.Parsetree.constructor_arguments = function\n | Ast_412.Parsetree.Pcstr_tuple x0 ->\n Ast_411.Parsetree.Pcstr_tuple (List.map copy_core_type x0)\n | Ast_412.Parsetree.Pcstr_record x0 ->\n Ast_411.Parsetree.Pcstr_record (List.map copy_label_declaration x0)\n\nand copy_label_declaration :\n Ast_412.Parsetree.label_declaration -> Ast_411.Parsetree.label_declaration =\n fun {\n Ast_412.Parsetree.pld_name;\n Ast_412.Parsetree.pld_mutable;\n Ast_412.Parsetree.pld_type;\n Ast_412.Parsetree.pld_loc;\n Ast_412.Parsetree.pld_attributes;\n } ->\n {\n Ast_411.Parsetree.pld_name = copy_loc (fun x -> x) pld_name;\n Ast_411.Parsetree.pld_mutable = copy_mutable_flag pld_mutable;\n Ast_411.Parsetree.pld_type = copy_core_type pld_type;\n Ast_411.Parsetree.pld_loc = copy_location pld_loc;\n Ast_411.Parsetree.pld_attributes = copy_attributes pld_attributes;\n }\n\nand copy_mutable_flag :\n Ast_412.Asttypes.mutable_flag -> Ast_411.Asttypes.mutable_flag = function\n | Ast_412.Asttypes.Immutable -> Ast_411.Asttypes.Immutable\n | Ast_412.Asttypes.Mutable -> Ast_411.Asttypes.Mutable\n\nand copy_variance : Ast_412.Asttypes.variance -> Ast_411.Asttypes.variance =\n function\n | Ast_412.Asttypes.Covariant -> Ast_411.Asttypes.Covariant\n | Ast_412.Asttypes.Contravariant -> Ast_411.Asttypes.Contravariant\n | Ast_412.Asttypes.NoVariance -> Ast_411.Asttypes.Invariant\n\nand copy_value_description :\n Ast_412.Parsetree.value_description -> Ast_411.Parsetree.value_description =\n fun {\n Ast_412.Parsetree.pval_name;\n Ast_412.Parsetree.pval_type;\n Ast_412.Parsetree.pval_prim;\n Ast_412.Parsetree.pval_attributes;\n Ast_412.Parsetree.pval_loc;\n } ->\n {\n Ast_411.Parsetree.pval_name = copy_loc (fun x -> x) pval_name;\n Ast_411.Parsetree.pval_type = copy_core_type pval_type;\n Ast_411.Parsetree.pval_prim = List.map (fun x -> x) pval_prim;\n Ast_411.Parsetree.pval_attributes = copy_attributes pval_attributes;\n Ast_411.Parsetree.pval_loc = copy_location pval_loc;\n }\n\nand copy_object_field_desc :\n Ast_412.Parsetree.object_field_desc -> Ast_411.Parsetree.object_field_desc =\n function\n | Ast_412.Parsetree.Otag (x0, x1) ->\n Ast_411.Parsetree.Otag (copy_loc copy_label x0, copy_core_type x1)\n | Ast_412.Parsetree.Oinherit x0 ->\n Ast_411.Parsetree.Oinherit (copy_core_type x0)\n\nand copy_arg_label : Ast_412.Asttypes.arg_label -> Ast_411.Asttypes.arg_label =\n function\n | Ast_412.Asttypes.Nolabel -> Ast_411.Asttypes.Nolabel\n | Ast_412.Asttypes.Labelled x0 -> Ast_411.Asttypes.Labelled x0\n | Ast_412.Asttypes.Optional x0 -> Ast_411.Asttypes.Optional x0\n\nand copy_closed_flag :\n Ast_412.Asttypes.closed_flag -> Ast_411.Asttypes.closed_flag = function\n | Ast_412.Asttypes.Closed -> Ast_411.Asttypes.Closed\n | Ast_412.Asttypes.Open -> Ast_411.Asttypes.Open\n\nand copy_label : Ast_412.Asttypes.label -> Ast_411.Asttypes.label = fun x -> x\n\nand copy_rec_flag : Ast_412.Asttypes.rec_flag -> Ast_411.Asttypes.rec_flag =\n function\n | Ast_412.Asttypes.Nonrecursive -> Ast_411.Asttypes.Nonrecursive\n | Ast_412.Asttypes.Recursive -> Ast_411.Asttypes.Recursive\n\nand copy_constant : Ast_412.Parsetree.constant -> Ast_411.Parsetree.constant =\n function\n | Ast_412.Parsetree.Pconst_integer (x0, x1) ->\n Ast_411.Parsetree.Pconst_integer (x0, Option.map (fun x -> x) x1)\n | Ast_412.Parsetree.Pconst_char x0 -> Ast_411.Parsetree.Pconst_char x0\n | Ast_412.Parsetree.Pconst_string (x0, x1, x2) ->\n Ast_411.Parsetree.Pconst_string\n (x0, copy_location x1, Option.map (fun x -> x) x2)\n | Ast_412.Parsetree.Pconst_float (x0, x1) ->\n Ast_411.Parsetree.Pconst_float (x0, Option.map (fun x -> x) x1)\n\nand copy_Longident_t : Longident.t -> Longident.t = fun x -> x\n\nand copy_loc :\n 'f0 'g0.\n ('f0 -> 'g0) -> 'f0 Ast_412.Asttypes.loc -> 'g0 Ast_411.Asttypes.loc =\n fun f0 { Ast_412.Asttypes.txt; Ast_412.Asttypes.loc } ->\n { Ast_411.Asttypes.txt = f0 txt; Ast_411.Asttypes.loc = copy_location loc }\n\nand copy_location : Location.t -> Location.t = fun x -> x\n","open Stdlib0\nmodule From = Ast_411\nmodule To = Ast_412\n\nlet rec copy_toplevel_phrase :\n Ast_411.Parsetree.toplevel_phrase -> Ast_412.Parsetree.toplevel_phrase =\n function\n | Ast_411.Parsetree.Ptop_def x0 ->\n Ast_412.Parsetree.Ptop_def (copy_structure x0)\n | Ast_411.Parsetree.Ptop_dir x0 ->\n Ast_412.Parsetree.Ptop_dir (copy_toplevel_directive x0)\n\nand copy_toplevel_directive :\n Ast_411.Parsetree.toplevel_directive -> Ast_412.Parsetree.toplevel_directive\n =\n fun {\n Ast_411.Parsetree.pdir_name;\n Ast_411.Parsetree.pdir_arg;\n Ast_411.Parsetree.pdir_loc;\n } ->\n {\n Ast_412.Parsetree.pdir_name = copy_loc (fun x -> x) pdir_name;\n Ast_412.Parsetree.pdir_arg = Option.map copy_directive_argument pdir_arg;\n Ast_412.Parsetree.pdir_loc = copy_location pdir_loc;\n }\n\nand copy_directive_argument :\n Ast_411.Parsetree.directive_argument -> Ast_412.Parsetree.directive_argument\n =\n fun { Ast_411.Parsetree.pdira_desc; Ast_411.Parsetree.pdira_loc } ->\n {\n Ast_412.Parsetree.pdira_desc = copy_directive_argument_desc pdira_desc;\n Ast_412.Parsetree.pdira_loc = copy_location pdira_loc;\n }\n\nand copy_directive_argument_desc :\n Ast_411.Parsetree.directive_argument_desc ->\n Ast_412.Parsetree.directive_argument_desc = function\n | Ast_411.Parsetree.Pdir_string x0 -> Ast_412.Parsetree.Pdir_string x0\n | Ast_411.Parsetree.Pdir_int (x0, x1) ->\n Ast_412.Parsetree.Pdir_int (x0, Option.map (fun x -> x) x1)\n | Ast_411.Parsetree.Pdir_ident x0 ->\n Ast_412.Parsetree.Pdir_ident (copy_Longident_t x0)\n | Ast_411.Parsetree.Pdir_bool x0 -> Ast_412.Parsetree.Pdir_bool x0\n\nand copy_expression :\n Ast_411.Parsetree.expression -> Ast_412.Parsetree.expression =\n fun {\n Ast_411.Parsetree.pexp_desc;\n Ast_411.Parsetree.pexp_loc;\n Ast_411.Parsetree.pexp_loc_stack;\n Ast_411.Parsetree.pexp_attributes;\n } ->\n {\n Ast_412.Parsetree.pexp_desc = copy_expression_desc pexp_desc;\n Ast_412.Parsetree.pexp_loc = copy_location pexp_loc;\n Ast_412.Parsetree.pexp_loc_stack = copy_location_stack pexp_loc_stack;\n Ast_412.Parsetree.pexp_attributes = copy_attributes pexp_attributes;\n }\n\nand copy_expression_desc :\n Ast_411.Parsetree.expression_desc -> Ast_412.Parsetree.expression_desc =\n function\n | Ast_411.Parsetree.Pexp_ident x0 ->\n Ast_412.Parsetree.Pexp_ident (copy_loc copy_Longident_t x0)\n | Ast_411.Parsetree.Pexp_constant x0 ->\n Ast_412.Parsetree.Pexp_constant (copy_constant x0)\n | Ast_411.Parsetree.Pexp_let (x0, x1, x2) ->\n Ast_412.Parsetree.Pexp_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_expression x2)\n | Ast_411.Parsetree.Pexp_function x0 ->\n Ast_412.Parsetree.Pexp_function (List.map copy_case x0)\n | Ast_411.Parsetree.Pexp_fun (x0, x1, x2, x3) ->\n Ast_412.Parsetree.Pexp_fun\n ( copy_arg_label x0,\n Option.map copy_expression x1,\n copy_pattern x2,\n copy_expression x3 )\n | Ast_411.Parsetree.Pexp_apply (x0, x1) ->\n Ast_412.Parsetree.Pexp_apply\n ( copy_expression x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | Ast_411.Parsetree.Pexp_match (x0, x1) ->\n Ast_412.Parsetree.Pexp_match (copy_expression x0, List.map copy_case x1)\n | Ast_411.Parsetree.Pexp_try (x0, x1) ->\n Ast_412.Parsetree.Pexp_try (copy_expression x0, List.map copy_case x1)\n | Ast_411.Parsetree.Pexp_tuple x0 ->\n Ast_412.Parsetree.Pexp_tuple (List.map copy_expression x0)\n | Ast_411.Parsetree.Pexp_construct (x0, x1) ->\n Ast_412.Parsetree.Pexp_construct\n (copy_loc copy_Longident_t x0, Option.map copy_expression x1)\n | Ast_411.Parsetree.Pexp_variant (x0, x1) ->\n Ast_412.Parsetree.Pexp_variant\n (copy_label x0, Option.map copy_expression x1)\n | Ast_411.Parsetree.Pexp_record (x0, x1) ->\n Ast_412.Parsetree.Pexp_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_expression x1))\n x0,\n Option.map copy_expression x1 )\n | Ast_411.Parsetree.Pexp_field (x0, x1) ->\n Ast_412.Parsetree.Pexp_field\n (copy_expression x0, copy_loc copy_Longident_t x1)\n | Ast_411.Parsetree.Pexp_setfield (x0, x1, x2) ->\n Ast_412.Parsetree.Pexp_setfield\n (copy_expression x0, copy_loc copy_Longident_t x1, copy_expression x2)\n | Ast_411.Parsetree.Pexp_array x0 ->\n Ast_412.Parsetree.Pexp_array (List.map copy_expression x0)\n | Ast_411.Parsetree.Pexp_ifthenelse (x0, x1, x2) ->\n Ast_412.Parsetree.Pexp_ifthenelse\n (copy_expression x0, copy_expression x1, Option.map copy_expression x2)\n | Ast_411.Parsetree.Pexp_sequence (x0, x1) ->\n Ast_412.Parsetree.Pexp_sequence (copy_expression x0, copy_expression x1)\n | Ast_411.Parsetree.Pexp_while (x0, x1) ->\n Ast_412.Parsetree.Pexp_while (copy_expression x0, copy_expression x1)\n | Ast_411.Parsetree.Pexp_for (x0, x1, x2, x3, x4) ->\n Ast_412.Parsetree.Pexp_for\n ( copy_pattern x0,\n copy_expression x1,\n copy_expression x2,\n copy_direction_flag x3,\n copy_expression x4 )\n | Ast_411.Parsetree.Pexp_constraint (x0, x1) ->\n Ast_412.Parsetree.Pexp_constraint (copy_expression x0, copy_core_type x1)\n | Ast_411.Parsetree.Pexp_coerce (x0, x1, x2) ->\n Ast_412.Parsetree.Pexp_coerce\n (copy_expression x0, Option.map copy_core_type x1, copy_core_type x2)\n | Ast_411.Parsetree.Pexp_send (x0, x1) ->\n Ast_412.Parsetree.Pexp_send (copy_expression x0, copy_loc copy_label x1)\n | Ast_411.Parsetree.Pexp_new x0 ->\n Ast_412.Parsetree.Pexp_new (copy_loc copy_Longident_t x0)\n | Ast_411.Parsetree.Pexp_setinstvar (x0, x1) ->\n Ast_412.Parsetree.Pexp_setinstvar\n (copy_loc copy_label x0, copy_expression x1)\n | Ast_411.Parsetree.Pexp_override x0 ->\n Ast_412.Parsetree.Pexp_override\n (List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_label x0, copy_expression x1))\n x0)\n | Ast_411.Parsetree.Pexp_letmodule (x0, x1, x2) ->\n Ast_412.Parsetree.Pexp_letmodule\n ( copy_loc (fun x -> Option.map (fun x -> x) x) x0,\n copy_module_expr x1,\n copy_expression x2 )\n | Ast_411.Parsetree.Pexp_letexception (x0, x1) ->\n Ast_412.Parsetree.Pexp_letexception\n (copy_extension_constructor x0, copy_expression x1)\n | Ast_411.Parsetree.Pexp_assert x0 ->\n Ast_412.Parsetree.Pexp_assert (copy_expression x0)\n | Ast_411.Parsetree.Pexp_lazy x0 ->\n Ast_412.Parsetree.Pexp_lazy (copy_expression x0)\n | Ast_411.Parsetree.Pexp_poly (x0, x1) ->\n Ast_412.Parsetree.Pexp_poly\n (copy_expression x0, Option.map copy_core_type x1)\n | Ast_411.Parsetree.Pexp_object x0 ->\n Ast_412.Parsetree.Pexp_object (copy_class_structure x0)\n | Ast_411.Parsetree.Pexp_newtype (x0, x1) ->\n Ast_412.Parsetree.Pexp_newtype\n (copy_loc (fun x -> x) x0, copy_expression x1)\n | Ast_411.Parsetree.Pexp_pack x0 ->\n Ast_412.Parsetree.Pexp_pack (copy_module_expr x0)\n | Ast_411.Parsetree.Pexp_open (x0, x1) ->\n Ast_412.Parsetree.Pexp_open (copy_open_declaration x0, copy_expression x1)\n | Ast_411.Parsetree.Pexp_letop x0 ->\n Ast_412.Parsetree.Pexp_letop (copy_letop x0)\n | Ast_411.Parsetree.Pexp_extension x0 ->\n Ast_412.Parsetree.Pexp_extension (copy_extension x0)\n | Ast_411.Parsetree.Pexp_unreachable -> Ast_412.Parsetree.Pexp_unreachable\n\nand copy_letop : Ast_411.Parsetree.letop -> Ast_412.Parsetree.letop =\n fun { Ast_411.Parsetree.let_; Ast_411.Parsetree.ands; Ast_411.Parsetree.body } ->\n {\n Ast_412.Parsetree.let_ = copy_binding_op let_;\n Ast_412.Parsetree.ands = List.map copy_binding_op ands;\n Ast_412.Parsetree.body = copy_expression body;\n }\n\nand copy_binding_op :\n Ast_411.Parsetree.binding_op -> Ast_412.Parsetree.binding_op =\n fun {\n Ast_411.Parsetree.pbop_op;\n Ast_411.Parsetree.pbop_pat;\n Ast_411.Parsetree.pbop_exp;\n Ast_411.Parsetree.pbop_loc;\n } ->\n {\n Ast_412.Parsetree.pbop_op = copy_loc (fun x -> x) pbop_op;\n Ast_412.Parsetree.pbop_pat = copy_pattern pbop_pat;\n Ast_412.Parsetree.pbop_exp = copy_expression pbop_exp;\n Ast_412.Parsetree.pbop_loc = copy_location pbop_loc;\n }\n\nand copy_direction_flag :\n Ast_411.Asttypes.direction_flag -> Ast_412.Asttypes.direction_flag =\n function\n | Ast_411.Asttypes.Upto -> Ast_412.Asttypes.Upto\n | Ast_411.Asttypes.Downto -> Ast_412.Asttypes.Downto\n\nand copy_case : Ast_411.Parsetree.case -> Ast_412.Parsetree.case =\n fun {\n Ast_411.Parsetree.pc_lhs;\n Ast_411.Parsetree.pc_guard;\n Ast_411.Parsetree.pc_rhs;\n } ->\n {\n Ast_412.Parsetree.pc_lhs = copy_pattern pc_lhs;\n Ast_412.Parsetree.pc_guard = Option.map copy_expression pc_guard;\n Ast_412.Parsetree.pc_rhs = copy_expression pc_rhs;\n }\n\nand copy_value_binding :\n Ast_411.Parsetree.value_binding -> Ast_412.Parsetree.value_binding =\n fun {\n Ast_411.Parsetree.pvb_pat;\n Ast_411.Parsetree.pvb_expr;\n Ast_411.Parsetree.pvb_attributes;\n Ast_411.Parsetree.pvb_loc;\n } ->\n {\n Ast_412.Parsetree.pvb_pat = copy_pattern pvb_pat;\n Ast_412.Parsetree.pvb_expr = copy_expression pvb_expr;\n Ast_412.Parsetree.pvb_attributes = copy_attributes pvb_attributes;\n Ast_412.Parsetree.pvb_loc = copy_location pvb_loc;\n }\n\nand copy_pattern : Ast_411.Parsetree.pattern -> Ast_412.Parsetree.pattern =\n fun {\n Ast_411.Parsetree.ppat_desc;\n Ast_411.Parsetree.ppat_loc;\n Ast_411.Parsetree.ppat_loc_stack;\n Ast_411.Parsetree.ppat_attributes;\n } ->\n {\n Ast_412.Parsetree.ppat_desc = copy_pattern_desc ppat_desc;\n Ast_412.Parsetree.ppat_loc = copy_location ppat_loc;\n Ast_412.Parsetree.ppat_loc_stack = copy_location_stack ppat_loc_stack;\n Ast_412.Parsetree.ppat_attributes = copy_attributes ppat_attributes;\n }\n\nand copy_pattern_desc :\n Ast_411.Parsetree.pattern_desc -> Ast_412.Parsetree.pattern_desc = function\n | Ast_411.Parsetree.Ppat_any -> Ast_412.Parsetree.Ppat_any\n | Ast_411.Parsetree.Ppat_var x0 ->\n Ast_412.Parsetree.Ppat_var (copy_loc (fun x -> x) x0)\n | Ast_411.Parsetree.Ppat_alias (x0, x1) ->\n Ast_412.Parsetree.Ppat_alias (copy_pattern x0, copy_loc (fun x -> x) x1)\n | Ast_411.Parsetree.Ppat_constant x0 ->\n Ast_412.Parsetree.Ppat_constant (copy_constant x0)\n | Ast_411.Parsetree.Ppat_interval (x0, x1) ->\n Ast_412.Parsetree.Ppat_interval (copy_constant x0, copy_constant x1)\n | Ast_411.Parsetree.Ppat_tuple x0 ->\n Ast_412.Parsetree.Ppat_tuple (List.map copy_pattern x0)\n | Ast_411.Parsetree.Ppat_construct (x0, x1) ->\n Ast_412.Parsetree.Ppat_construct\n (copy_loc copy_Longident_t x0, Option.map copy_pattern x1)\n | Ast_411.Parsetree.Ppat_variant (x0, x1) ->\n Ast_412.Parsetree.Ppat_variant (copy_label x0, Option.map copy_pattern x1)\n | Ast_411.Parsetree.Ppat_record (x0, x1) ->\n Ast_412.Parsetree.Ppat_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_pattern x1))\n x0,\n copy_closed_flag x1 )\n | Ast_411.Parsetree.Ppat_array x0 ->\n Ast_412.Parsetree.Ppat_array (List.map copy_pattern x0)\n | Ast_411.Parsetree.Ppat_or (x0, x1) ->\n Ast_412.Parsetree.Ppat_or (copy_pattern x0, copy_pattern x1)\n | Ast_411.Parsetree.Ppat_constraint (x0, x1) ->\n Ast_412.Parsetree.Ppat_constraint (copy_pattern x0, copy_core_type x1)\n | Ast_411.Parsetree.Ppat_type x0 ->\n Ast_412.Parsetree.Ppat_type (copy_loc copy_Longident_t x0)\n | Ast_411.Parsetree.Ppat_lazy x0 ->\n Ast_412.Parsetree.Ppat_lazy (copy_pattern x0)\n | Ast_411.Parsetree.Ppat_unpack x0 ->\n Ast_412.Parsetree.Ppat_unpack\n (copy_loc (fun x -> Option.map (fun x -> x) x) x0)\n | Ast_411.Parsetree.Ppat_exception x0 ->\n Ast_412.Parsetree.Ppat_exception (copy_pattern x0)\n | Ast_411.Parsetree.Ppat_extension x0 ->\n Ast_412.Parsetree.Ppat_extension (copy_extension x0)\n | Ast_411.Parsetree.Ppat_open (x0, x1) ->\n Ast_412.Parsetree.Ppat_open (copy_loc copy_Longident_t x0, copy_pattern x1)\n\nand copy_core_type : Ast_411.Parsetree.core_type -> Ast_412.Parsetree.core_type\n =\n fun {\n Ast_411.Parsetree.ptyp_desc;\n Ast_411.Parsetree.ptyp_loc;\n Ast_411.Parsetree.ptyp_loc_stack;\n Ast_411.Parsetree.ptyp_attributes;\n } ->\n {\n Ast_412.Parsetree.ptyp_desc = copy_core_type_desc ptyp_desc;\n Ast_412.Parsetree.ptyp_loc = copy_location ptyp_loc;\n Ast_412.Parsetree.ptyp_loc_stack = copy_location_stack ptyp_loc_stack;\n Ast_412.Parsetree.ptyp_attributes = copy_attributes ptyp_attributes;\n }\n\nand copy_location_stack :\n Ast_411.Parsetree.location_stack -> Ast_412.Parsetree.location_stack =\n fun x -> x\n\nand copy_core_type_desc :\n Ast_411.Parsetree.core_type_desc -> Ast_412.Parsetree.core_type_desc =\n function\n | Ast_411.Parsetree.Ptyp_any -> Ast_412.Parsetree.Ptyp_any\n | Ast_411.Parsetree.Ptyp_var x0 -> Ast_412.Parsetree.Ptyp_var x0\n | Ast_411.Parsetree.Ptyp_arrow (x0, x1, x2) ->\n Ast_412.Parsetree.Ptyp_arrow\n (copy_arg_label x0, copy_core_type x1, copy_core_type x2)\n | Ast_411.Parsetree.Ptyp_tuple x0 ->\n Ast_412.Parsetree.Ptyp_tuple (List.map copy_core_type x0)\n | Ast_411.Parsetree.Ptyp_constr (x0, x1) ->\n Ast_412.Parsetree.Ptyp_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_411.Parsetree.Ptyp_object (x0, x1) ->\n Ast_412.Parsetree.Ptyp_object\n (List.map copy_object_field x0, copy_closed_flag x1)\n | Ast_411.Parsetree.Ptyp_class (x0, x1) ->\n Ast_412.Parsetree.Ptyp_class\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_411.Parsetree.Ptyp_alias (x0, x1) ->\n Ast_412.Parsetree.Ptyp_alias (copy_core_type x0, x1)\n | Ast_411.Parsetree.Ptyp_variant (x0, x1, x2) ->\n Ast_412.Parsetree.Ptyp_variant\n ( List.map copy_row_field x0,\n copy_closed_flag x1,\n Option.map (fun x -> List.map copy_label x) x2 )\n | Ast_411.Parsetree.Ptyp_poly (x0, x1) ->\n Ast_412.Parsetree.Ptyp_poly\n (List.map (fun x -> copy_loc (fun x -> x) x) x0, copy_core_type x1)\n | Ast_411.Parsetree.Ptyp_package x0 ->\n Ast_412.Parsetree.Ptyp_package (copy_package_type x0)\n | Ast_411.Parsetree.Ptyp_extension x0 ->\n Ast_412.Parsetree.Ptyp_extension (copy_extension x0)\n\nand copy_package_type :\n Ast_411.Parsetree.package_type -> Ast_412.Parsetree.package_type =\n fun x ->\n let x0, x1 = x in\n ( copy_loc copy_Longident_t x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_core_type x1))\n x1 )\n\nand copy_row_field : Ast_411.Parsetree.row_field -> Ast_412.Parsetree.row_field\n =\n fun {\n Ast_411.Parsetree.prf_desc;\n Ast_411.Parsetree.prf_loc;\n Ast_411.Parsetree.prf_attributes;\n } ->\n {\n Ast_412.Parsetree.prf_desc = copy_row_field_desc prf_desc;\n Ast_412.Parsetree.prf_loc = copy_location prf_loc;\n Ast_412.Parsetree.prf_attributes = copy_attributes prf_attributes;\n }\n\nand copy_row_field_desc :\n Ast_411.Parsetree.row_field_desc -> Ast_412.Parsetree.row_field_desc =\n function\n | Ast_411.Parsetree.Rtag (x0, x1, x2) ->\n Ast_412.Parsetree.Rtag\n (copy_loc copy_label x0, x1, List.map copy_core_type x2)\n | Ast_411.Parsetree.Rinherit x0 ->\n Ast_412.Parsetree.Rinherit (copy_core_type x0)\n\nand copy_object_field :\n Ast_411.Parsetree.object_field -> Ast_412.Parsetree.object_field =\n fun {\n Ast_411.Parsetree.pof_desc;\n Ast_411.Parsetree.pof_loc;\n Ast_411.Parsetree.pof_attributes;\n } ->\n {\n Ast_412.Parsetree.pof_desc = copy_object_field_desc pof_desc;\n Ast_412.Parsetree.pof_loc = copy_location pof_loc;\n Ast_412.Parsetree.pof_attributes = copy_attributes pof_attributes;\n }\n\nand copy_attributes :\n Ast_411.Parsetree.attributes -> Ast_412.Parsetree.attributes =\n fun x -> List.map copy_attribute x\n\nand copy_attribute : Ast_411.Parsetree.attribute -> Ast_412.Parsetree.attribute\n =\n fun {\n Ast_411.Parsetree.attr_name;\n Ast_411.Parsetree.attr_payload;\n Ast_411.Parsetree.attr_loc;\n } ->\n {\n Ast_412.Parsetree.attr_name = copy_loc (fun x -> x) attr_name;\n Ast_412.Parsetree.attr_payload = copy_payload attr_payload;\n Ast_412.Parsetree.attr_loc = copy_location attr_loc;\n }\n\nand copy_payload : Ast_411.Parsetree.payload -> Ast_412.Parsetree.payload =\n function\n | Ast_411.Parsetree.PStr x0 -> Ast_412.Parsetree.PStr (copy_structure x0)\n | Ast_411.Parsetree.PSig x0 -> Ast_412.Parsetree.PSig (copy_signature x0)\n | Ast_411.Parsetree.PTyp x0 -> Ast_412.Parsetree.PTyp (copy_core_type x0)\n | Ast_411.Parsetree.PPat (x0, x1) ->\n Ast_412.Parsetree.PPat (copy_pattern x0, Option.map copy_expression x1)\n\nand copy_structure : Ast_411.Parsetree.structure -> Ast_412.Parsetree.structure\n =\n fun x -> List.map copy_structure_item x\n\nand copy_structure_item :\n Ast_411.Parsetree.structure_item -> Ast_412.Parsetree.structure_item =\n fun { Ast_411.Parsetree.pstr_desc; Ast_411.Parsetree.pstr_loc } ->\n {\n Ast_412.Parsetree.pstr_desc = copy_structure_item_desc pstr_desc;\n Ast_412.Parsetree.pstr_loc = copy_location pstr_loc;\n }\n\nand copy_structure_item_desc :\n Ast_411.Parsetree.structure_item_desc ->\n Ast_412.Parsetree.structure_item_desc = function\n | Ast_411.Parsetree.Pstr_eval (x0, x1) ->\n Ast_412.Parsetree.Pstr_eval (copy_expression x0, copy_attributes x1)\n | Ast_411.Parsetree.Pstr_value (x0, x1) ->\n Ast_412.Parsetree.Pstr_value\n (copy_rec_flag x0, List.map copy_value_binding x1)\n | Ast_411.Parsetree.Pstr_primitive x0 ->\n Ast_412.Parsetree.Pstr_primitive (copy_value_description x0)\n | Ast_411.Parsetree.Pstr_type (x0, x1) ->\n Ast_412.Parsetree.Pstr_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | Ast_411.Parsetree.Pstr_typext x0 ->\n Ast_412.Parsetree.Pstr_typext (copy_type_extension x0)\n | Ast_411.Parsetree.Pstr_exception x0 ->\n Ast_412.Parsetree.Pstr_exception (copy_type_exception x0)\n | Ast_411.Parsetree.Pstr_module x0 ->\n Ast_412.Parsetree.Pstr_module (copy_module_binding x0)\n | Ast_411.Parsetree.Pstr_recmodule x0 ->\n Ast_412.Parsetree.Pstr_recmodule (List.map copy_module_binding x0)\n | Ast_411.Parsetree.Pstr_modtype x0 ->\n Ast_412.Parsetree.Pstr_modtype (copy_module_type_declaration x0)\n | Ast_411.Parsetree.Pstr_open x0 ->\n Ast_412.Parsetree.Pstr_open (copy_open_declaration x0)\n | Ast_411.Parsetree.Pstr_class x0 ->\n Ast_412.Parsetree.Pstr_class (List.map copy_class_declaration x0)\n | Ast_411.Parsetree.Pstr_class_type x0 ->\n Ast_412.Parsetree.Pstr_class_type\n (List.map copy_class_type_declaration x0)\n | Ast_411.Parsetree.Pstr_include x0 ->\n Ast_412.Parsetree.Pstr_include (copy_include_declaration x0)\n | Ast_411.Parsetree.Pstr_attribute x0 ->\n Ast_412.Parsetree.Pstr_attribute (copy_attribute x0)\n | Ast_411.Parsetree.Pstr_extension (x0, x1) ->\n Ast_412.Parsetree.Pstr_extension (copy_extension x0, copy_attributes x1)\n\nand copy_include_declaration :\n Ast_411.Parsetree.include_declaration ->\n Ast_412.Parsetree.include_declaration =\n fun x -> copy_include_infos copy_module_expr x\n\nand copy_class_declaration :\n Ast_411.Parsetree.class_declaration -> Ast_412.Parsetree.class_declaration =\n fun x -> copy_class_infos copy_class_expr x\n\nand copy_class_expr :\n Ast_411.Parsetree.class_expr -> Ast_412.Parsetree.class_expr =\n fun {\n Ast_411.Parsetree.pcl_desc;\n Ast_411.Parsetree.pcl_loc;\n Ast_411.Parsetree.pcl_attributes;\n } ->\n {\n Ast_412.Parsetree.pcl_desc = copy_class_expr_desc pcl_desc;\n Ast_412.Parsetree.pcl_loc = copy_location pcl_loc;\n Ast_412.Parsetree.pcl_attributes = copy_attributes pcl_attributes;\n }\n\nand copy_class_expr_desc :\n Ast_411.Parsetree.class_expr_desc -> Ast_412.Parsetree.class_expr_desc =\n function\n | Ast_411.Parsetree.Pcl_constr (x0, x1) ->\n Ast_412.Parsetree.Pcl_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_411.Parsetree.Pcl_structure x0 ->\n Ast_412.Parsetree.Pcl_structure (copy_class_structure x0)\n | Ast_411.Parsetree.Pcl_fun (x0, x1, x2, x3) ->\n Ast_412.Parsetree.Pcl_fun\n ( copy_arg_label x0,\n Option.map copy_expression x1,\n copy_pattern x2,\n copy_class_expr x3 )\n | Ast_411.Parsetree.Pcl_apply (x0, x1) ->\n Ast_412.Parsetree.Pcl_apply\n ( copy_class_expr x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | Ast_411.Parsetree.Pcl_let (x0, x1, x2) ->\n Ast_412.Parsetree.Pcl_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_class_expr x2)\n | Ast_411.Parsetree.Pcl_constraint (x0, x1) ->\n Ast_412.Parsetree.Pcl_constraint (copy_class_expr x0, copy_class_type x1)\n | Ast_411.Parsetree.Pcl_extension x0 ->\n Ast_412.Parsetree.Pcl_extension (copy_extension x0)\n | Ast_411.Parsetree.Pcl_open (x0, x1) ->\n Ast_412.Parsetree.Pcl_open (copy_open_description x0, copy_class_expr x1)\n\nand copy_class_structure :\n Ast_411.Parsetree.class_structure -> Ast_412.Parsetree.class_structure =\n fun { Ast_411.Parsetree.pcstr_self; Ast_411.Parsetree.pcstr_fields } ->\n {\n Ast_412.Parsetree.pcstr_self = copy_pattern pcstr_self;\n Ast_412.Parsetree.pcstr_fields = List.map copy_class_field pcstr_fields;\n }\n\nand copy_class_field :\n Ast_411.Parsetree.class_field -> Ast_412.Parsetree.class_field =\n fun {\n Ast_411.Parsetree.pcf_desc;\n Ast_411.Parsetree.pcf_loc;\n Ast_411.Parsetree.pcf_attributes;\n } ->\n {\n Ast_412.Parsetree.pcf_desc = copy_class_field_desc pcf_desc;\n Ast_412.Parsetree.pcf_loc = copy_location pcf_loc;\n Ast_412.Parsetree.pcf_attributes = copy_attributes pcf_attributes;\n }\n\nand copy_class_field_desc :\n Ast_411.Parsetree.class_field_desc -> Ast_412.Parsetree.class_field_desc =\n function\n | Ast_411.Parsetree.Pcf_inherit (x0, x1, x2) ->\n Ast_412.Parsetree.Pcf_inherit\n ( copy_override_flag x0,\n copy_class_expr x1,\n Option.map (fun x -> copy_loc (fun x -> x) x) x2 )\n | Ast_411.Parsetree.Pcf_val x0 ->\n Ast_412.Parsetree.Pcf_val\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_mutable_flag x1, copy_class_field_kind x2))\n | Ast_411.Parsetree.Pcf_method x0 ->\n Ast_412.Parsetree.Pcf_method\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_private_flag x1, copy_class_field_kind x2))\n | Ast_411.Parsetree.Pcf_constraint x0 ->\n Ast_412.Parsetree.Pcf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | Ast_411.Parsetree.Pcf_initializer x0 ->\n Ast_412.Parsetree.Pcf_initializer (copy_expression x0)\n | Ast_411.Parsetree.Pcf_attribute x0 ->\n Ast_412.Parsetree.Pcf_attribute (copy_attribute x0)\n | Ast_411.Parsetree.Pcf_extension x0 ->\n Ast_412.Parsetree.Pcf_extension (copy_extension x0)\n\nand copy_class_field_kind :\n Ast_411.Parsetree.class_field_kind -> Ast_412.Parsetree.class_field_kind =\n function\n | Ast_411.Parsetree.Cfk_virtual x0 ->\n Ast_412.Parsetree.Cfk_virtual (copy_core_type x0)\n | Ast_411.Parsetree.Cfk_concrete (x0, x1) ->\n Ast_412.Parsetree.Cfk_concrete (copy_override_flag x0, copy_expression x1)\n\nand copy_open_declaration :\n Ast_411.Parsetree.open_declaration -> Ast_412.Parsetree.open_declaration =\n fun x -> copy_open_infos copy_module_expr x\n\nand copy_module_binding :\n Ast_411.Parsetree.module_binding -> Ast_412.Parsetree.module_binding =\n fun {\n Ast_411.Parsetree.pmb_name;\n Ast_411.Parsetree.pmb_expr;\n Ast_411.Parsetree.pmb_attributes;\n Ast_411.Parsetree.pmb_loc;\n } ->\n {\n Ast_412.Parsetree.pmb_name =\n copy_loc (fun x -> Option.map (fun x -> x) x) pmb_name;\n Ast_412.Parsetree.pmb_expr = copy_module_expr pmb_expr;\n Ast_412.Parsetree.pmb_attributes = copy_attributes pmb_attributes;\n Ast_412.Parsetree.pmb_loc = copy_location pmb_loc;\n }\n\nand copy_module_expr :\n Ast_411.Parsetree.module_expr -> Ast_412.Parsetree.module_expr =\n fun {\n Ast_411.Parsetree.pmod_desc;\n Ast_411.Parsetree.pmod_loc;\n Ast_411.Parsetree.pmod_attributes;\n } ->\n {\n Ast_412.Parsetree.pmod_desc = copy_module_expr_desc pmod_desc;\n Ast_412.Parsetree.pmod_loc = copy_location pmod_loc;\n Ast_412.Parsetree.pmod_attributes = copy_attributes pmod_attributes;\n }\n\nand copy_module_expr_desc :\n Ast_411.Parsetree.module_expr_desc -> Ast_412.Parsetree.module_expr_desc =\n function\n | Ast_411.Parsetree.Pmod_ident x0 ->\n Ast_412.Parsetree.Pmod_ident (copy_loc copy_Longident_t x0)\n | Ast_411.Parsetree.Pmod_structure x0 ->\n Ast_412.Parsetree.Pmod_structure (copy_structure x0)\n | Ast_411.Parsetree.Pmod_functor (x0, x1) ->\n Ast_412.Parsetree.Pmod_functor\n (copy_functor_parameter x0, copy_module_expr x1)\n | Ast_411.Parsetree.Pmod_apply (x0, x1) ->\n Ast_412.Parsetree.Pmod_apply (copy_module_expr x0, copy_module_expr x1)\n | Ast_411.Parsetree.Pmod_constraint (x0, x1) ->\n Ast_412.Parsetree.Pmod_constraint\n (copy_module_expr x0, copy_module_type x1)\n | Ast_411.Parsetree.Pmod_unpack x0 ->\n Ast_412.Parsetree.Pmod_unpack (copy_expression x0)\n | Ast_411.Parsetree.Pmod_extension x0 ->\n Ast_412.Parsetree.Pmod_extension (copy_extension x0)\n\nand copy_functor_parameter :\n Ast_411.Parsetree.functor_parameter -> Ast_412.Parsetree.functor_parameter =\n function\n | Ast_411.Parsetree.Unit -> Ast_412.Parsetree.Unit\n | Ast_411.Parsetree.Named (x0, x1) ->\n Ast_412.Parsetree.Named\n (copy_loc (fun x -> Option.map (fun x -> x) x) x0, copy_module_type x1)\n\nand copy_module_type :\n Ast_411.Parsetree.module_type -> Ast_412.Parsetree.module_type =\n fun {\n Ast_411.Parsetree.pmty_desc;\n Ast_411.Parsetree.pmty_loc;\n Ast_411.Parsetree.pmty_attributes;\n } ->\n {\n Ast_412.Parsetree.pmty_desc = copy_module_type_desc pmty_desc;\n Ast_412.Parsetree.pmty_loc = copy_location pmty_loc;\n Ast_412.Parsetree.pmty_attributes = copy_attributes pmty_attributes;\n }\n\nand copy_module_type_desc :\n Ast_411.Parsetree.module_type_desc -> Ast_412.Parsetree.module_type_desc =\n function\n | Ast_411.Parsetree.Pmty_ident x0 ->\n Ast_412.Parsetree.Pmty_ident (copy_loc copy_Longident_t x0)\n | Ast_411.Parsetree.Pmty_signature x0 ->\n Ast_412.Parsetree.Pmty_signature (copy_signature x0)\n | Ast_411.Parsetree.Pmty_functor (x0, x1) ->\n Ast_412.Parsetree.Pmty_functor\n (copy_functor_parameter x0, copy_module_type x1)\n | Ast_411.Parsetree.Pmty_with (x0, x1) ->\n Ast_412.Parsetree.Pmty_with\n (copy_module_type x0, List.map copy_with_constraint x1)\n | Ast_411.Parsetree.Pmty_typeof x0 ->\n Ast_412.Parsetree.Pmty_typeof (copy_module_expr x0)\n | Ast_411.Parsetree.Pmty_extension x0 ->\n Ast_412.Parsetree.Pmty_extension (copy_extension x0)\n | Ast_411.Parsetree.Pmty_alias x0 ->\n Ast_412.Parsetree.Pmty_alias (copy_loc copy_Longident_t x0)\n\nand copy_with_constraint :\n Ast_411.Parsetree.with_constraint -> Ast_412.Parsetree.with_constraint =\n function\n | Ast_411.Parsetree.Pwith_type (x0, x1) ->\n Ast_412.Parsetree.Pwith_type\n (copy_loc copy_Longident_t x0, copy_type_declaration x1)\n | Ast_411.Parsetree.Pwith_module (x0, x1) ->\n Ast_412.Parsetree.Pwith_module\n (copy_loc copy_Longident_t x0, copy_loc copy_Longident_t x1)\n | Ast_411.Parsetree.Pwith_typesubst (x0, x1) ->\n Ast_412.Parsetree.Pwith_typesubst\n (copy_loc copy_Longident_t x0, copy_type_declaration x1)\n | Ast_411.Parsetree.Pwith_modsubst (x0, x1) ->\n Ast_412.Parsetree.Pwith_modsubst\n (copy_loc copy_Longident_t x0, copy_loc copy_Longident_t x1)\n\nand copy_signature : Ast_411.Parsetree.signature -> Ast_412.Parsetree.signature\n =\n fun x -> List.map copy_signature_item x\n\nand copy_signature_item :\n Ast_411.Parsetree.signature_item -> Ast_412.Parsetree.signature_item =\n fun { Ast_411.Parsetree.psig_desc; Ast_411.Parsetree.psig_loc } ->\n {\n Ast_412.Parsetree.psig_desc = copy_signature_item_desc psig_desc;\n Ast_412.Parsetree.psig_loc = copy_location psig_loc;\n }\n\nand copy_signature_item_desc :\n Ast_411.Parsetree.signature_item_desc ->\n Ast_412.Parsetree.signature_item_desc = function\n | Ast_411.Parsetree.Psig_value x0 ->\n Ast_412.Parsetree.Psig_value (copy_value_description x0)\n | Ast_411.Parsetree.Psig_type (x0, x1) ->\n Ast_412.Parsetree.Psig_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | Ast_411.Parsetree.Psig_typesubst x0 ->\n Ast_412.Parsetree.Psig_typesubst (List.map copy_type_declaration x0)\n | Ast_411.Parsetree.Psig_typext x0 ->\n Ast_412.Parsetree.Psig_typext (copy_type_extension x0)\n | Ast_411.Parsetree.Psig_exception x0 ->\n Ast_412.Parsetree.Psig_exception (copy_type_exception x0)\n | Ast_411.Parsetree.Psig_module x0 ->\n Ast_412.Parsetree.Psig_module (copy_module_declaration x0)\n | Ast_411.Parsetree.Psig_modsubst x0 ->\n Ast_412.Parsetree.Psig_modsubst (copy_module_substitution x0)\n | Ast_411.Parsetree.Psig_recmodule x0 ->\n Ast_412.Parsetree.Psig_recmodule (List.map copy_module_declaration x0)\n | Ast_411.Parsetree.Psig_modtype x0 ->\n Ast_412.Parsetree.Psig_modtype (copy_module_type_declaration x0)\n | Ast_411.Parsetree.Psig_open x0 ->\n Ast_412.Parsetree.Psig_open (copy_open_description x0)\n | Ast_411.Parsetree.Psig_include x0 ->\n Ast_412.Parsetree.Psig_include (copy_include_description x0)\n | Ast_411.Parsetree.Psig_class x0 ->\n Ast_412.Parsetree.Psig_class (List.map copy_class_description x0)\n | Ast_411.Parsetree.Psig_class_type x0 ->\n Ast_412.Parsetree.Psig_class_type\n (List.map copy_class_type_declaration x0)\n | Ast_411.Parsetree.Psig_attribute x0 ->\n Ast_412.Parsetree.Psig_attribute (copy_attribute x0)\n | Ast_411.Parsetree.Psig_extension (x0, x1) ->\n Ast_412.Parsetree.Psig_extension (copy_extension x0, copy_attributes x1)\n\nand copy_class_type_declaration :\n Ast_411.Parsetree.class_type_declaration ->\n Ast_412.Parsetree.class_type_declaration =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_description :\n Ast_411.Parsetree.class_description -> Ast_412.Parsetree.class_description =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_type :\n Ast_411.Parsetree.class_type -> Ast_412.Parsetree.class_type =\n fun {\n Ast_411.Parsetree.pcty_desc;\n Ast_411.Parsetree.pcty_loc;\n Ast_411.Parsetree.pcty_attributes;\n } ->\n {\n Ast_412.Parsetree.pcty_desc = copy_class_type_desc pcty_desc;\n Ast_412.Parsetree.pcty_loc = copy_location pcty_loc;\n Ast_412.Parsetree.pcty_attributes = copy_attributes pcty_attributes;\n }\n\nand copy_class_type_desc :\n Ast_411.Parsetree.class_type_desc -> Ast_412.Parsetree.class_type_desc =\n function\n | Ast_411.Parsetree.Pcty_constr (x0, x1) ->\n Ast_412.Parsetree.Pcty_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_411.Parsetree.Pcty_signature x0 ->\n Ast_412.Parsetree.Pcty_signature (copy_class_signature x0)\n | Ast_411.Parsetree.Pcty_arrow (x0, x1, x2) ->\n Ast_412.Parsetree.Pcty_arrow\n (copy_arg_label x0, copy_core_type x1, copy_class_type x2)\n | Ast_411.Parsetree.Pcty_extension x0 ->\n Ast_412.Parsetree.Pcty_extension (copy_extension x0)\n | Ast_411.Parsetree.Pcty_open (x0, x1) ->\n Ast_412.Parsetree.Pcty_open (copy_open_description x0, copy_class_type x1)\n\nand copy_class_signature :\n Ast_411.Parsetree.class_signature -> Ast_412.Parsetree.class_signature =\n fun { Ast_411.Parsetree.pcsig_self; Ast_411.Parsetree.pcsig_fields } ->\n {\n Ast_412.Parsetree.pcsig_self = copy_core_type pcsig_self;\n Ast_412.Parsetree.pcsig_fields = List.map copy_class_type_field pcsig_fields;\n }\n\nand copy_class_type_field :\n Ast_411.Parsetree.class_type_field -> Ast_412.Parsetree.class_type_field =\n fun {\n Ast_411.Parsetree.pctf_desc;\n Ast_411.Parsetree.pctf_loc;\n Ast_411.Parsetree.pctf_attributes;\n } ->\n {\n Ast_412.Parsetree.pctf_desc = copy_class_type_field_desc pctf_desc;\n Ast_412.Parsetree.pctf_loc = copy_location pctf_loc;\n Ast_412.Parsetree.pctf_attributes = copy_attributes pctf_attributes;\n }\n\nand copy_class_type_field_desc :\n Ast_411.Parsetree.class_type_field_desc ->\n Ast_412.Parsetree.class_type_field_desc = function\n | Ast_411.Parsetree.Pctf_inherit x0 ->\n Ast_412.Parsetree.Pctf_inherit (copy_class_type x0)\n | Ast_411.Parsetree.Pctf_val x0 ->\n Ast_412.Parsetree.Pctf_val\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_mutable_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | Ast_411.Parsetree.Pctf_method x0 ->\n Ast_412.Parsetree.Pctf_method\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_private_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | Ast_411.Parsetree.Pctf_constraint x0 ->\n Ast_412.Parsetree.Pctf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | Ast_411.Parsetree.Pctf_attribute x0 ->\n Ast_412.Parsetree.Pctf_attribute (copy_attribute x0)\n | Ast_411.Parsetree.Pctf_extension x0 ->\n Ast_412.Parsetree.Pctf_extension (copy_extension x0)\n\nand copy_extension : Ast_411.Parsetree.extension -> Ast_412.Parsetree.extension\n =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_class_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_411.Parsetree.class_infos ->\n 'g0 Ast_412.Parsetree.class_infos =\n fun f0\n {\n Ast_411.Parsetree.pci_virt;\n Ast_411.Parsetree.pci_params;\n Ast_411.Parsetree.pci_name;\n Ast_411.Parsetree.pci_expr;\n Ast_411.Parsetree.pci_loc;\n Ast_411.Parsetree.pci_attributes;\n } ->\n {\n Ast_412.Parsetree.pci_virt = copy_virtual_flag pci_virt;\n Ast_412.Parsetree.pci_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, (copy_variance x1, Ast_412.Asttypes.NoInjectivity)))\n pci_params;\n Ast_412.Parsetree.pci_name = copy_loc (fun x -> x) pci_name;\n Ast_412.Parsetree.pci_expr = f0 pci_expr;\n Ast_412.Parsetree.pci_loc = copy_location pci_loc;\n Ast_412.Parsetree.pci_attributes = copy_attributes pci_attributes;\n }\n\nand copy_virtual_flag :\n Ast_411.Asttypes.virtual_flag -> Ast_412.Asttypes.virtual_flag = function\n | Ast_411.Asttypes.Virtual -> Ast_412.Asttypes.Virtual\n | Ast_411.Asttypes.Concrete -> Ast_412.Asttypes.Concrete\n\nand copy_include_description :\n Ast_411.Parsetree.include_description ->\n Ast_412.Parsetree.include_description =\n fun x -> copy_include_infos copy_module_type x\n\nand copy_include_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_411.Parsetree.include_infos ->\n 'g0 Ast_412.Parsetree.include_infos =\n fun f0\n {\n Ast_411.Parsetree.pincl_mod;\n Ast_411.Parsetree.pincl_loc;\n Ast_411.Parsetree.pincl_attributes;\n } ->\n {\n Ast_412.Parsetree.pincl_mod = f0 pincl_mod;\n Ast_412.Parsetree.pincl_loc = copy_location pincl_loc;\n Ast_412.Parsetree.pincl_attributes = copy_attributes pincl_attributes;\n }\n\nand copy_open_description :\n Ast_411.Parsetree.open_description -> Ast_412.Parsetree.open_description =\n fun x -> copy_open_infos (fun x -> copy_loc copy_Longident_t x) x\n\nand copy_open_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_411.Parsetree.open_infos ->\n 'g0 Ast_412.Parsetree.open_infos =\n fun f0\n {\n Ast_411.Parsetree.popen_expr;\n Ast_411.Parsetree.popen_override;\n Ast_411.Parsetree.popen_loc;\n Ast_411.Parsetree.popen_attributes;\n } ->\n {\n Ast_412.Parsetree.popen_expr = f0 popen_expr;\n Ast_412.Parsetree.popen_override = copy_override_flag popen_override;\n Ast_412.Parsetree.popen_loc = copy_location popen_loc;\n Ast_412.Parsetree.popen_attributes = copy_attributes popen_attributes;\n }\n\nand copy_override_flag :\n Ast_411.Asttypes.override_flag -> Ast_412.Asttypes.override_flag = function\n | Ast_411.Asttypes.Override -> Ast_412.Asttypes.Override\n | Ast_411.Asttypes.Fresh -> Ast_412.Asttypes.Fresh\n\nand copy_module_type_declaration :\n Ast_411.Parsetree.module_type_declaration ->\n Ast_412.Parsetree.module_type_declaration =\n fun {\n Ast_411.Parsetree.pmtd_name;\n Ast_411.Parsetree.pmtd_type;\n Ast_411.Parsetree.pmtd_attributes;\n Ast_411.Parsetree.pmtd_loc;\n } ->\n {\n Ast_412.Parsetree.pmtd_name = copy_loc (fun x -> x) pmtd_name;\n Ast_412.Parsetree.pmtd_type = Option.map copy_module_type pmtd_type;\n Ast_412.Parsetree.pmtd_attributes = copy_attributes pmtd_attributes;\n Ast_412.Parsetree.pmtd_loc = copy_location pmtd_loc;\n }\n\nand copy_module_substitution :\n Ast_411.Parsetree.module_substitution ->\n Ast_412.Parsetree.module_substitution =\n fun {\n Ast_411.Parsetree.pms_name;\n Ast_411.Parsetree.pms_manifest;\n Ast_411.Parsetree.pms_attributes;\n Ast_411.Parsetree.pms_loc;\n } ->\n {\n Ast_412.Parsetree.pms_name = copy_loc (fun x -> x) pms_name;\n Ast_412.Parsetree.pms_manifest = copy_loc copy_Longident_t pms_manifest;\n Ast_412.Parsetree.pms_attributes = copy_attributes pms_attributes;\n Ast_412.Parsetree.pms_loc = copy_location pms_loc;\n }\n\nand copy_module_declaration :\n Ast_411.Parsetree.module_declaration -> Ast_412.Parsetree.module_declaration\n =\n fun {\n Ast_411.Parsetree.pmd_name;\n Ast_411.Parsetree.pmd_type;\n Ast_411.Parsetree.pmd_attributes;\n Ast_411.Parsetree.pmd_loc;\n } ->\n {\n Ast_412.Parsetree.pmd_name =\n copy_loc (fun x -> Option.map (fun x -> x) x) pmd_name;\n Ast_412.Parsetree.pmd_type = copy_module_type pmd_type;\n Ast_412.Parsetree.pmd_attributes = copy_attributes pmd_attributes;\n Ast_412.Parsetree.pmd_loc = copy_location pmd_loc;\n }\n\nand copy_type_exception :\n Ast_411.Parsetree.type_exception -> Ast_412.Parsetree.type_exception =\n fun {\n Ast_411.Parsetree.ptyexn_constructor;\n Ast_411.Parsetree.ptyexn_loc;\n Ast_411.Parsetree.ptyexn_attributes;\n } ->\n {\n Ast_412.Parsetree.ptyexn_constructor =\n copy_extension_constructor ptyexn_constructor;\n Ast_412.Parsetree.ptyexn_loc = copy_location ptyexn_loc;\n Ast_412.Parsetree.ptyexn_attributes = copy_attributes ptyexn_attributes;\n }\n\nand copy_type_extension :\n Ast_411.Parsetree.type_extension -> Ast_412.Parsetree.type_extension =\n fun {\n Ast_411.Parsetree.ptyext_path;\n Ast_411.Parsetree.ptyext_params;\n Ast_411.Parsetree.ptyext_constructors;\n Ast_411.Parsetree.ptyext_private;\n Ast_411.Parsetree.ptyext_loc;\n Ast_411.Parsetree.ptyext_attributes;\n } ->\n {\n Ast_412.Parsetree.ptyext_path = copy_loc copy_Longident_t ptyext_path;\n Ast_412.Parsetree.ptyext_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, (copy_variance x1, Ast_412.Asttypes.NoInjectivity)))\n ptyext_params;\n Ast_412.Parsetree.ptyext_constructors =\n List.map copy_extension_constructor ptyext_constructors;\n Ast_412.Parsetree.ptyext_private = copy_private_flag ptyext_private;\n Ast_412.Parsetree.ptyext_loc = copy_location ptyext_loc;\n Ast_412.Parsetree.ptyext_attributes = copy_attributes ptyext_attributes;\n }\n\nand copy_extension_constructor :\n Ast_411.Parsetree.extension_constructor ->\n Ast_412.Parsetree.extension_constructor =\n fun {\n Ast_411.Parsetree.pext_name;\n Ast_411.Parsetree.pext_kind;\n Ast_411.Parsetree.pext_loc;\n Ast_411.Parsetree.pext_attributes;\n } ->\n {\n Ast_412.Parsetree.pext_name = copy_loc (fun x -> x) pext_name;\n Ast_412.Parsetree.pext_kind = copy_extension_constructor_kind pext_kind;\n Ast_412.Parsetree.pext_loc = copy_location pext_loc;\n Ast_412.Parsetree.pext_attributes = copy_attributes pext_attributes;\n }\n\nand copy_extension_constructor_kind :\n Ast_411.Parsetree.extension_constructor_kind ->\n Ast_412.Parsetree.extension_constructor_kind = function\n | Ast_411.Parsetree.Pext_decl (x0, x1) ->\n Ast_412.Parsetree.Pext_decl\n (copy_constructor_arguments x0, Option.map copy_core_type x1)\n | Ast_411.Parsetree.Pext_rebind x0 ->\n Ast_412.Parsetree.Pext_rebind (copy_loc copy_Longident_t x0)\n\nand copy_type_declaration :\n Ast_411.Parsetree.type_declaration -> Ast_412.Parsetree.type_declaration =\n fun {\n Ast_411.Parsetree.ptype_name;\n Ast_411.Parsetree.ptype_params;\n Ast_411.Parsetree.ptype_cstrs;\n Ast_411.Parsetree.ptype_kind;\n Ast_411.Parsetree.ptype_private;\n Ast_411.Parsetree.ptype_manifest;\n Ast_411.Parsetree.ptype_attributes;\n Ast_411.Parsetree.ptype_loc;\n } ->\n {\n Ast_412.Parsetree.ptype_name = copy_loc (fun x -> x) ptype_name;\n Ast_412.Parsetree.ptype_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, (copy_variance x1, Ast_412.Asttypes.NoInjectivity)))\n ptype_params;\n Ast_412.Parsetree.ptype_cstrs =\n List.map\n (fun x ->\n let x0, x1, x2 = x in\n (copy_core_type x0, copy_core_type x1, copy_location x2))\n ptype_cstrs;\n Ast_412.Parsetree.ptype_kind = copy_type_kind ptype_kind;\n Ast_412.Parsetree.ptype_private = copy_private_flag ptype_private;\n Ast_412.Parsetree.ptype_manifest = Option.map copy_core_type ptype_manifest;\n Ast_412.Parsetree.ptype_attributes = copy_attributes ptype_attributes;\n Ast_412.Parsetree.ptype_loc = copy_location ptype_loc;\n }\n\nand copy_private_flag :\n Ast_411.Asttypes.private_flag -> Ast_412.Asttypes.private_flag = function\n | Ast_411.Asttypes.Private -> Ast_412.Asttypes.Private\n | Ast_411.Asttypes.Public -> Ast_412.Asttypes.Public\n\nand copy_type_kind : Ast_411.Parsetree.type_kind -> Ast_412.Parsetree.type_kind\n = function\n | Ast_411.Parsetree.Ptype_abstract -> Ast_412.Parsetree.Ptype_abstract\n | Ast_411.Parsetree.Ptype_variant x0 ->\n Ast_412.Parsetree.Ptype_variant (List.map copy_constructor_declaration x0)\n | Ast_411.Parsetree.Ptype_record x0 ->\n Ast_412.Parsetree.Ptype_record (List.map copy_label_declaration x0)\n | Ast_411.Parsetree.Ptype_open -> Ast_412.Parsetree.Ptype_open\n\nand copy_constructor_declaration :\n Ast_411.Parsetree.constructor_declaration ->\n Ast_412.Parsetree.constructor_declaration =\n fun {\n Ast_411.Parsetree.pcd_name;\n Ast_411.Parsetree.pcd_args;\n Ast_411.Parsetree.pcd_res;\n Ast_411.Parsetree.pcd_loc;\n Ast_411.Parsetree.pcd_attributes;\n } ->\n {\n Ast_412.Parsetree.pcd_name = copy_loc (fun x -> x) pcd_name;\n Ast_412.Parsetree.pcd_args = copy_constructor_arguments pcd_args;\n Ast_412.Parsetree.pcd_res = Option.map copy_core_type pcd_res;\n Ast_412.Parsetree.pcd_loc = copy_location pcd_loc;\n Ast_412.Parsetree.pcd_attributes = copy_attributes pcd_attributes;\n }\n\nand copy_constructor_arguments :\n Ast_411.Parsetree.constructor_arguments ->\n Ast_412.Parsetree.constructor_arguments = function\n | Ast_411.Parsetree.Pcstr_tuple x0 ->\n Ast_412.Parsetree.Pcstr_tuple (List.map copy_core_type x0)\n | Ast_411.Parsetree.Pcstr_record x0 ->\n Ast_412.Parsetree.Pcstr_record (List.map copy_label_declaration x0)\n\nand copy_label_declaration :\n Ast_411.Parsetree.label_declaration -> Ast_412.Parsetree.label_declaration =\n fun {\n Ast_411.Parsetree.pld_name;\n Ast_411.Parsetree.pld_mutable;\n Ast_411.Parsetree.pld_type;\n Ast_411.Parsetree.pld_loc;\n Ast_411.Parsetree.pld_attributes;\n } ->\n {\n Ast_412.Parsetree.pld_name = copy_loc (fun x -> x) pld_name;\n Ast_412.Parsetree.pld_mutable = copy_mutable_flag pld_mutable;\n Ast_412.Parsetree.pld_type = copy_core_type pld_type;\n Ast_412.Parsetree.pld_loc = copy_location pld_loc;\n Ast_412.Parsetree.pld_attributes = copy_attributes pld_attributes;\n }\n\nand copy_mutable_flag :\n Ast_411.Asttypes.mutable_flag -> Ast_412.Asttypes.mutable_flag = function\n | Ast_411.Asttypes.Immutable -> Ast_412.Asttypes.Immutable\n | Ast_411.Asttypes.Mutable -> Ast_412.Asttypes.Mutable\n\nand copy_variance : Ast_411.Asttypes.variance -> Ast_412.Asttypes.variance =\n function\n | Ast_411.Asttypes.Covariant -> Ast_412.Asttypes.Covariant\n | Ast_411.Asttypes.Contravariant -> Ast_412.Asttypes.Contravariant\n | Ast_411.Asttypes.Invariant -> Ast_412.Asttypes.NoVariance\n\nand copy_value_description :\n Ast_411.Parsetree.value_description -> Ast_412.Parsetree.value_description =\n fun {\n Ast_411.Parsetree.pval_name;\n Ast_411.Parsetree.pval_type;\n Ast_411.Parsetree.pval_prim;\n Ast_411.Parsetree.pval_attributes;\n Ast_411.Parsetree.pval_loc;\n } ->\n {\n Ast_412.Parsetree.pval_name = copy_loc (fun x -> x) pval_name;\n Ast_412.Parsetree.pval_type = copy_core_type pval_type;\n Ast_412.Parsetree.pval_prim = List.map (fun x -> x) pval_prim;\n Ast_412.Parsetree.pval_attributes = copy_attributes pval_attributes;\n Ast_412.Parsetree.pval_loc = copy_location pval_loc;\n }\n\nand copy_object_field_desc :\n Ast_411.Parsetree.object_field_desc -> Ast_412.Parsetree.object_field_desc =\n function\n | Ast_411.Parsetree.Otag (x0, x1) ->\n Ast_412.Parsetree.Otag (copy_loc copy_label x0, copy_core_type x1)\n | Ast_411.Parsetree.Oinherit x0 ->\n Ast_412.Parsetree.Oinherit (copy_core_type x0)\n\nand copy_arg_label : Ast_411.Asttypes.arg_label -> Ast_412.Asttypes.arg_label =\n function\n | Ast_411.Asttypes.Nolabel -> Ast_412.Asttypes.Nolabel\n | Ast_411.Asttypes.Labelled x0 -> Ast_412.Asttypes.Labelled x0\n | Ast_411.Asttypes.Optional x0 -> Ast_412.Asttypes.Optional x0\n\nand copy_closed_flag :\n Ast_411.Asttypes.closed_flag -> Ast_412.Asttypes.closed_flag = function\n | Ast_411.Asttypes.Closed -> Ast_412.Asttypes.Closed\n | Ast_411.Asttypes.Open -> Ast_412.Asttypes.Open\n\nand copy_label : Ast_411.Asttypes.label -> Ast_412.Asttypes.label = fun x -> x\n\nand copy_rec_flag : Ast_411.Asttypes.rec_flag -> Ast_412.Asttypes.rec_flag =\n function\n | Ast_411.Asttypes.Nonrecursive -> Ast_412.Asttypes.Nonrecursive\n | Ast_411.Asttypes.Recursive -> Ast_412.Asttypes.Recursive\n\nand copy_constant : Ast_411.Parsetree.constant -> Ast_412.Parsetree.constant =\n function\n | Ast_411.Parsetree.Pconst_integer (x0, x1) ->\n Ast_412.Parsetree.Pconst_integer (x0, Option.map (fun x -> x) x1)\n | Ast_411.Parsetree.Pconst_char x0 -> Ast_412.Parsetree.Pconst_char x0\n | Ast_411.Parsetree.Pconst_string (x0, x1, x2) ->\n Ast_412.Parsetree.Pconst_string\n (x0, copy_location x1, Option.map (fun x -> x) x2)\n | Ast_411.Parsetree.Pconst_float (x0, x1) ->\n Ast_412.Parsetree.Pconst_float (x0, Option.map (fun x -> x) x1)\n\nand copy_Longident_t : Longident.t -> Longident.t = fun x -> x\n\nand copy_loc :\n 'f0 'g0.\n ('f0 -> 'g0) -> 'f0 Ast_411.Asttypes.loc -> 'g0 Ast_412.Asttypes.loc =\n fun f0 { Ast_411.Asttypes.txt; Ast_411.Asttypes.loc } ->\n { Ast_412.Asttypes.txt = f0 txt; Ast_412.Asttypes.loc = copy_location loc }\n\nand copy_location : Location.t -> Location.t = fun x -> x\n","open Stdlib0\nmodule From = Ast_411\nmodule To = Ast_410\n\nlet rec copy_toplevel_phrase :\n Ast_411.Parsetree.toplevel_phrase -> Ast_410.Parsetree.toplevel_phrase =\n function\n | Ast_411.Parsetree.Ptop_def x0 ->\n Ast_410.Parsetree.Ptop_def (copy_structure x0)\n | Ast_411.Parsetree.Ptop_dir x0 ->\n Ast_410.Parsetree.Ptop_dir (copy_toplevel_directive x0)\n\nand copy_toplevel_directive :\n Ast_411.Parsetree.toplevel_directive -> Ast_410.Parsetree.toplevel_directive\n =\n fun {\n Ast_411.Parsetree.pdir_name;\n Ast_411.Parsetree.pdir_arg;\n Ast_411.Parsetree.pdir_loc;\n } ->\n {\n Ast_410.Parsetree.pdir_name = copy_loc (fun x -> x) pdir_name;\n Ast_410.Parsetree.pdir_arg = Option.map copy_directive_argument pdir_arg;\n Ast_410.Parsetree.pdir_loc = copy_location pdir_loc;\n }\n\nand copy_directive_argument :\n Ast_411.Parsetree.directive_argument -> Ast_410.Parsetree.directive_argument\n =\n fun { Ast_411.Parsetree.pdira_desc; Ast_411.Parsetree.pdira_loc } ->\n {\n Ast_410.Parsetree.pdira_desc = copy_directive_argument_desc pdira_desc;\n Ast_410.Parsetree.pdira_loc = copy_location pdira_loc;\n }\n\nand copy_directive_argument_desc :\n Ast_411.Parsetree.directive_argument_desc ->\n Ast_410.Parsetree.directive_argument_desc = function\n | Ast_411.Parsetree.Pdir_string x0 -> Ast_410.Parsetree.Pdir_string x0\n | Ast_411.Parsetree.Pdir_int (x0, x1) ->\n Ast_410.Parsetree.Pdir_int (x0, Option.map (fun x -> x) x1)\n | Ast_411.Parsetree.Pdir_ident x0 ->\n Ast_410.Parsetree.Pdir_ident (copy_Longident_t x0)\n | Ast_411.Parsetree.Pdir_bool x0 -> Ast_410.Parsetree.Pdir_bool x0\n\nand copy_expression :\n Ast_411.Parsetree.expression -> Ast_410.Parsetree.expression =\n fun {\n Ast_411.Parsetree.pexp_desc;\n Ast_411.Parsetree.pexp_loc;\n Ast_411.Parsetree.pexp_loc_stack;\n Ast_411.Parsetree.pexp_attributes;\n } ->\n {\n Ast_410.Parsetree.pexp_desc = copy_expression_desc pexp_desc;\n Ast_410.Parsetree.pexp_loc = copy_location pexp_loc;\n Ast_410.Parsetree.pexp_loc_stack = copy_location_stack pexp_loc_stack;\n Ast_410.Parsetree.pexp_attributes = copy_attributes pexp_attributes;\n }\n\nand copy_expr x = copy_expression x\n\nand copy_expression_desc :\n Ast_411.Parsetree.expression_desc -> Ast_410.Parsetree.expression_desc =\n function\n | Ast_411.Parsetree.Pexp_ident x0 ->\n Ast_410.Parsetree.Pexp_ident (copy_loc copy_Longident_t x0)\n | Ast_411.Parsetree.Pexp_constant x0 ->\n Ast_410.Parsetree.Pexp_constant (copy_constant x0)\n | Ast_411.Parsetree.Pexp_let (x0, x1, x2) ->\n Ast_410.Parsetree.Pexp_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_expression x2)\n | Ast_411.Parsetree.Pexp_function x0 ->\n Ast_410.Parsetree.Pexp_function (List.map copy_case x0)\n | Ast_411.Parsetree.Pexp_fun (x0, x1, x2, x3) ->\n Ast_410.Parsetree.Pexp_fun\n ( copy_arg_label x0,\n Option.map copy_expression x1,\n copy_pattern x2,\n copy_expression x3 )\n | Ast_411.Parsetree.Pexp_apply (x0, x1) ->\n Ast_410.Parsetree.Pexp_apply\n ( copy_expression x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | Ast_411.Parsetree.Pexp_match (x0, x1) ->\n Ast_410.Parsetree.Pexp_match (copy_expression x0, List.map copy_case x1)\n | Ast_411.Parsetree.Pexp_try (x0, x1) ->\n Ast_410.Parsetree.Pexp_try (copy_expression x0, List.map copy_case x1)\n | Ast_411.Parsetree.Pexp_tuple x0 ->\n Ast_410.Parsetree.Pexp_tuple (List.map copy_expression x0)\n | Ast_411.Parsetree.Pexp_construct (x0, x1) ->\n Ast_410.Parsetree.Pexp_construct\n (copy_loc copy_Longident_t x0, Option.map copy_expression x1)\n | Ast_411.Parsetree.Pexp_variant (x0, x1) ->\n Ast_410.Parsetree.Pexp_variant\n (copy_label x0, Option.map copy_expression x1)\n | Ast_411.Parsetree.Pexp_record (x0, x1) ->\n Ast_410.Parsetree.Pexp_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_expression x1))\n x0,\n Option.map copy_expression x1 )\n | Ast_411.Parsetree.Pexp_field (x0, x1) ->\n Ast_410.Parsetree.Pexp_field\n (copy_expression x0, copy_loc copy_Longident_t x1)\n | Ast_411.Parsetree.Pexp_setfield (x0, x1, x2) ->\n Ast_410.Parsetree.Pexp_setfield\n (copy_expression x0, copy_loc copy_Longident_t x1, copy_expression x2)\n | Ast_411.Parsetree.Pexp_array x0 ->\n Ast_410.Parsetree.Pexp_array (List.map copy_expression x0)\n | Ast_411.Parsetree.Pexp_ifthenelse (x0, x1, x2) ->\n Ast_410.Parsetree.Pexp_ifthenelse\n (copy_expression x0, copy_expression x1, Option.map copy_expression x2)\n | Ast_411.Parsetree.Pexp_sequence (x0, x1) ->\n Ast_410.Parsetree.Pexp_sequence (copy_expression x0, copy_expression x1)\n | Ast_411.Parsetree.Pexp_while (x0, x1) ->\n Ast_410.Parsetree.Pexp_while (copy_expression x0, copy_expression x1)\n | Ast_411.Parsetree.Pexp_for (x0, x1, x2, x3, x4) ->\n Ast_410.Parsetree.Pexp_for\n ( copy_pattern x0,\n copy_expression x1,\n copy_expression x2,\n copy_direction_flag x3,\n copy_expression x4 )\n | Ast_411.Parsetree.Pexp_constraint (x0, x1) ->\n Ast_410.Parsetree.Pexp_constraint (copy_expression x0, copy_core_type x1)\n | Ast_411.Parsetree.Pexp_coerce (x0, x1, x2) ->\n Ast_410.Parsetree.Pexp_coerce\n (copy_expression x0, Option.map copy_core_type x1, copy_core_type x2)\n | Ast_411.Parsetree.Pexp_send (x0, x1) ->\n Ast_410.Parsetree.Pexp_send (copy_expression x0, copy_loc copy_label x1)\n | Ast_411.Parsetree.Pexp_new x0 ->\n Ast_410.Parsetree.Pexp_new (copy_loc copy_Longident_t x0)\n | Ast_411.Parsetree.Pexp_setinstvar (x0, x1) ->\n Ast_410.Parsetree.Pexp_setinstvar\n (copy_loc copy_label x0, copy_expression x1)\n | Ast_411.Parsetree.Pexp_override x0 ->\n Ast_410.Parsetree.Pexp_override\n (List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_label x0, copy_expression x1))\n x0)\n | Ast_411.Parsetree.Pexp_letmodule (x0, x1, x2) ->\n Ast_410.Parsetree.Pexp_letmodule\n ( copy_loc (fun x -> Option.map (fun x -> x) x) x0,\n copy_module_expr x1,\n copy_expression x2 )\n | Ast_411.Parsetree.Pexp_letexception (x0, x1) ->\n Ast_410.Parsetree.Pexp_letexception\n (copy_extension_constructor x0, copy_expression x1)\n | Ast_411.Parsetree.Pexp_assert x0 ->\n Ast_410.Parsetree.Pexp_assert (copy_expression x0)\n | Ast_411.Parsetree.Pexp_lazy x0 ->\n Ast_410.Parsetree.Pexp_lazy (copy_expression x0)\n | Ast_411.Parsetree.Pexp_poly (x0, x1) ->\n Ast_410.Parsetree.Pexp_poly\n (copy_expression x0, Option.map copy_core_type x1)\n | Ast_411.Parsetree.Pexp_object x0 ->\n Ast_410.Parsetree.Pexp_object (copy_class_structure x0)\n | Ast_411.Parsetree.Pexp_newtype (x0, x1) ->\n Ast_410.Parsetree.Pexp_newtype\n (copy_loc (fun x -> x) x0, copy_expression x1)\n | Ast_411.Parsetree.Pexp_pack x0 ->\n Ast_410.Parsetree.Pexp_pack (copy_module_expr x0)\n | Ast_411.Parsetree.Pexp_open (x0, x1) ->\n Ast_410.Parsetree.Pexp_open (copy_open_declaration x0, copy_expression x1)\n | Ast_411.Parsetree.Pexp_letop x0 ->\n Ast_410.Parsetree.Pexp_letop (copy_letop x0)\n | Ast_411.Parsetree.Pexp_extension x0 ->\n Ast_410.Parsetree.Pexp_extension (copy_extension x0)\n | Ast_411.Parsetree.Pexp_unreachable -> Ast_410.Parsetree.Pexp_unreachable\n\nand copy_letop : Ast_411.Parsetree.letop -> Ast_410.Parsetree.letop =\n fun { Ast_411.Parsetree.let_; Ast_411.Parsetree.ands; Ast_411.Parsetree.body } ->\n {\n Ast_410.Parsetree.let_ = copy_binding_op let_;\n Ast_410.Parsetree.ands = List.map copy_binding_op ands;\n Ast_410.Parsetree.body = copy_expression body;\n }\n\nand copy_binding_op :\n Ast_411.Parsetree.binding_op -> Ast_410.Parsetree.binding_op =\n fun {\n Ast_411.Parsetree.pbop_op;\n Ast_411.Parsetree.pbop_pat;\n Ast_411.Parsetree.pbop_exp;\n Ast_411.Parsetree.pbop_loc;\n } ->\n {\n Ast_410.Parsetree.pbop_op = copy_loc (fun x -> x) pbop_op;\n Ast_410.Parsetree.pbop_pat = copy_pattern pbop_pat;\n Ast_410.Parsetree.pbop_exp = copy_expression pbop_exp;\n Ast_410.Parsetree.pbop_loc = copy_location pbop_loc;\n }\n\nand copy_direction_flag :\n Ast_411.Asttypes.direction_flag -> Ast_410.Asttypes.direction_flag =\n function\n | Ast_411.Asttypes.Upto -> Ast_410.Asttypes.Upto\n | Ast_411.Asttypes.Downto -> Ast_410.Asttypes.Downto\n\nand copy_case : Ast_411.Parsetree.case -> Ast_410.Parsetree.case =\n fun {\n Ast_411.Parsetree.pc_lhs;\n Ast_411.Parsetree.pc_guard;\n Ast_411.Parsetree.pc_rhs;\n } ->\n {\n Ast_410.Parsetree.pc_lhs = copy_pattern pc_lhs;\n Ast_410.Parsetree.pc_guard = Option.map copy_expression pc_guard;\n Ast_410.Parsetree.pc_rhs = copy_expression pc_rhs;\n }\n\nand copy_cases : Ast_411.Parsetree.case list -> Ast_410.Parsetree.case list =\n fun x -> List.map copy_case x\n\nand copy_value_binding :\n Ast_411.Parsetree.value_binding -> Ast_410.Parsetree.value_binding =\n fun {\n Ast_411.Parsetree.pvb_pat;\n Ast_411.Parsetree.pvb_expr;\n Ast_411.Parsetree.pvb_attributes;\n Ast_411.Parsetree.pvb_loc;\n } ->\n {\n Ast_410.Parsetree.pvb_pat = copy_pattern pvb_pat;\n Ast_410.Parsetree.pvb_expr = copy_expression pvb_expr;\n Ast_410.Parsetree.pvb_attributes = copy_attributes pvb_attributes;\n Ast_410.Parsetree.pvb_loc = copy_location pvb_loc;\n }\n\nand copy_pattern : Ast_411.Parsetree.pattern -> Ast_410.Parsetree.pattern =\n fun {\n Ast_411.Parsetree.ppat_desc;\n Ast_411.Parsetree.ppat_loc;\n Ast_411.Parsetree.ppat_loc_stack;\n Ast_411.Parsetree.ppat_attributes;\n } ->\n {\n Ast_410.Parsetree.ppat_desc = copy_pattern_desc ppat_desc;\n Ast_410.Parsetree.ppat_loc = copy_location ppat_loc;\n Ast_410.Parsetree.ppat_loc_stack = copy_location_stack ppat_loc_stack;\n Ast_410.Parsetree.ppat_attributes = copy_attributes ppat_attributes;\n }\n\nand copy_pat x = copy_pattern x\n\nand copy_pattern_desc :\n Ast_411.Parsetree.pattern_desc -> Ast_410.Parsetree.pattern_desc = function\n | Ast_411.Parsetree.Ppat_any -> Ast_410.Parsetree.Ppat_any\n | Ast_411.Parsetree.Ppat_var x0 ->\n Ast_410.Parsetree.Ppat_var (copy_loc (fun x -> x) x0)\n | Ast_411.Parsetree.Ppat_alias (x0, x1) ->\n Ast_410.Parsetree.Ppat_alias (copy_pattern x0, copy_loc (fun x -> x) x1)\n | Ast_411.Parsetree.Ppat_constant x0 ->\n Ast_410.Parsetree.Ppat_constant (copy_constant x0)\n | Ast_411.Parsetree.Ppat_interval (x0, x1) ->\n Ast_410.Parsetree.Ppat_interval (copy_constant x0, copy_constant x1)\n | Ast_411.Parsetree.Ppat_tuple x0 ->\n Ast_410.Parsetree.Ppat_tuple (List.map copy_pattern x0)\n | Ast_411.Parsetree.Ppat_construct (x0, x1) ->\n Ast_410.Parsetree.Ppat_construct\n (copy_loc copy_Longident_t x0, Option.map copy_pattern x1)\n | Ast_411.Parsetree.Ppat_variant (x0, x1) ->\n Ast_410.Parsetree.Ppat_variant (copy_label x0, Option.map copy_pattern x1)\n | Ast_411.Parsetree.Ppat_record (x0, x1) ->\n Ast_410.Parsetree.Ppat_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_pattern x1))\n x0,\n copy_closed_flag x1 )\n | Ast_411.Parsetree.Ppat_array x0 ->\n Ast_410.Parsetree.Ppat_array (List.map copy_pattern x0)\n | Ast_411.Parsetree.Ppat_or (x0, x1) ->\n Ast_410.Parsetree.Ppat_or (copy_pattern x0, copy_pattern x1)\n | Ast_411.Parsetree.Ppat_constraint (x0, x1) ->\n Ast_410.Parsetree.Ppat_constraint (copy_pattern x0, copy_core_type x1)\n | Ast_411.Parsetree.Ppat_type x0 ->\n Ast_410.Parsetree.Ppat_type (copy_loc copy_Longident_t x0)\n | Ast_411.Parsetree.Ppat_lazy x0 ->\n Ast_410.Parsetree.Ppat_lazy (copy_pattern x0)\n | Ast_411.Parsetree.Ppat_unpack x0 ->\n Ast_410.Parsetree.Ppat_unpack\n (copy_loc (fun x -> Option.map (fun x -> x) x) x0)\n | Ast_411.Parsetree.Ppat_exception x0 ->\n Ast_410.Parsetree.Ppat_exception (copy_pattern x0)\n | Ast_411.Parsetree.Ppat_extension x0 ->\n Ast_410.Parsetree.Ppat_extension (copy_extension x0)\n | Ast_411.Parsetree.Ppat_open (x0, x1) ->\n Ast_410.Parsetree.Ppat_open (copy_loc copy_Longident_t x0, copy_pattern x1)\n\nand copy_core_type : Ast_411.Parsetree.core_type -> Ast_410.Parsetree.core_type\n =\n fun {\n Ast_411.Parsetree.ptyp_desc;\n Ast_411.Parsetree.ptyp_loc;\n Ast_411.Parsetree.ptyp_loc_stack;\n Ast_411.Parsetree.ptyp_attributes;\n } ->\n {\n Ast_410.Parsetree.ptyp_desc = copy_core_type_desc ptyp_desc;\n Ast_410.Parsetree.ptyp_loc = copy_location ptyp_loc;\n Ast_410.Parsetree.ptyp_loc_stack = copy_location_stack ptyp_loc_stack;\n Ast_410.Parsetree.ptyp_attributes = copy_attributes ptyp_attributes;\n }\n\nand copy_typ x = copy_core_type x\n\nand copy_location_stack :\n Ast_411.Parsetree.location_stack -> Ast_410.Parsetree.location_stack =\n fun x -> List.map copy_location x\n\nand copy_core_type_desc :\n Ast_411.Parsetree.core_type_desc -> Ast_410.Parsetree.core_type_desc =\n function\n | Ast_411.Parsetree.Ptyp_any -> Ast_410.Parsetree.Ptyp_any\n | Ast_411.Parsetree.Ptyp_var x0 -> Ast_410.Parsetree.Ptyp_var x0\n | Ast_411.Parsetree.Ptyp_arrow (x0, x1, x2) ->\n Ast_410.Parsetree.Ptyp_arrow\n (copy_arg_label x0, copy_core_type x1, copy_core_type x2)\n | Ast_411.Parsetree.Ptyp_tuple x0 ->\n Ast_410.Parsetree.Ptyp_tuple (List.map copy_core_type x0)\n | Ast_411.Parsetree.Ptyp_constr (x0, x1) ->\n Ast_410.Parsetree.Ptyp_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_411.Parsetree.Ptyp_object (x0, x1) ->\n Ast_410.Parsetree.Ptyp_object\n (List.map copy_object_field x0, copy_closed_flag x1)\n | Ast_411.Parsetree.Ptyp_class (x0, x1) ->\n Ast_410.Parsetree.Ptyp_class\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_411.Parsetree.Ptyp_alias (x0, x1) ->\n Ast_410.Parsetree.Ptyp_alias (copy_core_type x0, x1)\n | Ast_411.Parsetree.Ptyp_variant (x0, x1, x2) ->\n Ast_410.Parsetree.Ptyp_variant\n ( List.map copy_row_field x0,\n copy_closed_flag x1,\n Option.map (fun x -> List.map copy_label x) x2 )\n | Ast_411.Parsetree.Ptyp_poly (x0, x1) ->\n Ast_410.Parsetree.Ptyp_poly\n (List.map (fun x -> copy_loc (fun x -> x) x) x0, copy_core_type x1)\n | Ast_411.Parsetree.Ptyp_package x0 ->\n Ast_410.Parsetree.Ptyp_package (copy_package_type x0)\n | Ast_411.Parsetree.Ptyp_extension x0 ->\n Ast_410.Parsetree.Ptyp_extension (copy_extension x0)\n\nand copy_package_type :\n Ast_411.Parsetree.package_type -> Ast_410.Parsetree.package_type =\n fun x ->\n let x0, x1 = x in\n ( copy_loc copy_Longident_t x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_core_type x1))\n x1 )\n\nand copy_row_field : Ast_411.Parsetree.row_field -> Ast_410.Parsetree.row_field\n =\n fun {\n Ast_411.Parsetree.prf_desc;\n Ast_411.Parsetree.prf_loc;\n Ast_411.Parsetree.prf_attributes;\n } ->\n {\n Ast_410.Parsetree.prf_desc = copy_row_field_desc prf_desc;\n Ast_410.Parsetree.prf_loc = copy_location prf_loc;\n Ast_410.Parsetree.prf_attributes = copy_attributes prf_attributes;\n }\n\nand copy_row_field_desc :\n Ast_411.Parsetree.row_field_desc -> Ast_410.Parsetree.row_field_desc =\n function\n | Ast_411.Parsetree.Rtag (x0, x1, x2) ->\n Ast_410.Parsetree.Rtag\n (copy_loc copy_label x0, x1, List.map copy_core_type x2)\n | Ast_411.Parsetree.Rinherit x0 ->\n Ast_410.Parsetree.Rinherit (copy_core_type x0)\n\nand copy_object_field :\n Ast_411.Parsetree.object_field -> Ast_410.Parsetree.object_field =\n fun {\n Ast_411.Parsetree.pof_desc;\n Ast_411.Parsetree.pof_loc;\n Ast_411.Parsetree.pof_attributes;\n } ->\n {\n Ast_410.Parsetree.pof_desc = copy_object_field_desc pof_desc;\n Ast_410.Parsetree.pof_loc = copy_location pof_loc;\n Ast_410.Parsetree.pof_attributes = copy_attributes pof_attributes;\n }\n\nand copy_attributes :\n Ast_411.Parsetree.attributes -> Ast_410.Parsetree.attributes =\n fun x -> List.map copy_attribute x\n\nand copy_attribute : Ast_411.Parsetree.attribute -> Ast_410.Parsetree.attribute\n =\n fun {\n Ast_411.Parsetree.attr_name;\n Ast_411.Parsetree.attr_payload;\n Ast_411.Parsetree.attr_loc;\n } ->\n {\n Ast_410.Parsetree.attr_name = copy_loc (fun x -> x) attr_name;\n Ast_410.Parsetree.attr_payload = copy_payload attr_payload;\n Ast_410.Parsetree.attr_loc = copy_location attr_loc;\n }\n\nand copy_payload : Ast_411.Parsetree.payload -> Ast_410.Parsetree.payload =\n function\n | Ast_411.Parsetree.PStr x0 -> Ast_410.Parsetree.PStr (copy_structure x0)\n | Ast_411.Parsetree.PSig x0 -> Ast_410.Parsetree.PSig (copy_signature x0)\n | Ast_411.Parsetree.PTyp x0 -> Ast_410.Parsetree.PTyp (copy_core_type x0)\n | Ast_411.Parsetree.PPat (x0, x1) ->\n Ast_410.Parsetree.PPat (copy_pattern x0, Option.map copy_expression x1)\n\nand copy_structure : Ast_411.Parsetree.structure -> Ast_410.Parsetree.structure\n =\n fun x -> List.map copy_structure_item x\n\nand copy_structure_item :\n Ast_411.Parsetree.structure_item -> Ast_410.Parsetree.structure_item =\n fun { Ast_411.Parsetree.pstr_desc; Ast_411.Parsetree.pstr_loc } ->\n {\n Ast_410.Parsetree.pstr_desc = copy_structure_item_desc pstr_desc;\n Ast_410.Parsetree.pstr_loc = copy_location pstr_loc;\n }\n\nand copy_structure_item_desc :\n Ast_411.Parsetree.structure_item_desc ->\n Ast_410.Parsetree.structure_item_desc = function\n | Ast_411.Parsetree.Pstr_eval (x0, x1) ->\n Ast_410.Parsetree.Pstr_eval (copy_expression x0, copy_attributes x1)\n | Ast_411.Parsetree.Pstr_value (x0, x1) ->\n Ast_410.Parsetree.Pstr_value\n (copy_rec_flag x0, List.map copy_value_binding x1)\n | Ast_411.Parsetree.Pstr_primitive x0 ->\n Ast_410.Parsetree.Pstr_primitive (copy_value_description x0)\n | Ast_411.Parsetree.Pstr_type (x0, x1) ->\n Ast_410.Parsetree.Pstr_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | Ast_411.Parsetree.Pstr_typext x0 ->\n Ast_410.Parsetree.Pstr_typext (copy_type_extension x0)\n | Ast_411.Parsetree.Pstr_exception x0 ->\n Ast_410.Parsetree.Pstr_exception (copy_type_exception x0)\n | Ast_411.Parsetree.Pstr_module x0 ->\n Ast_410.Parsetree.Pstr_module (copy_module_binding x0)\n | Ast_411.Parsetree.Pstr_recmodule x0 ->\n Ast_410.Parsetree.Pstr_recmodule (List.map copy_module_binding x0)\n | Ast_411.Parsetree.Pstr_modtype x0 ->\n Ast_410.Parsetree.Pstr_modtype (copy_module_type_declaration x0)\n | Ast_411.Parsetree.Pstr_open x0 ->\n Ast_410.Parsetree.Pstr_open (copy_open_declaration x0)\n | Ast_411.Parsetree.Pstr_class x0 ->\n Ast_410.Parsetree.Pstr_class (List.map copy_class_declaration x0)\n | Ast_411.Parsetree.Pstr_class_type x0 ->\n Ast_410.Parsetree.Pstr_class_type\n (List.map copy_class_type_declaration x0)\n | Ast_411.Parsetree.Pstr_include x0 ->\n Ast_410.Parsetree.Pstr_include (copy_include_declaration x0)\n | Ast_411.Parsetree.Pstr_attribute x0 ->\n Ast_410.Parsetree.Pstr_attribute (copy_attribute x0)\n | Ast_411.Parsetree.Pstr_extension (x0, x1) ->\n Ast_410.Parsetree.Pstr_extension (copy_extension x0, copy_attributes x1)\n\nand copy_include_declaration :\n Ast_411.Parsetree.include_declaration ->\n Ast_410.Parsetree.include_declaration =\n fun x -> copy_include_infos copy_module_expr x\n\nand copy_class_declaration :\n Ast_411.Parsetree.class_declaration -> Ast_410.Parsetree.class_declaration =\n fun x -> copy_class_infos copy_class_expr x\n\nand copy_class_expr :\n Ast_411.Parsetree.class_expr -> Ast_410.Parsetree.class_expr =\n fun {\n Ast_411.Parsetree.pcl_desc;\n Ast_411.Parsetree.pcl_loc;\n Ast_411.Parsetree.pcl_attributes;\n } ->\n {\n Ast_410.Parsetree.pcl_desc = copy_class_expr_desc pcl_desc;\n Ast_410.Parsetree.pcl_loc = copy_location pcl_loc;\n Ast_410.Parsetree.pcl_attributes = copy_attributes pcl_attributes;\n }\n\nand copy_class_expr_desc :\n Ast_411.Parsetree.class_expr_desc -> Ast_410.Parsetree.class_expr_desc =\n function\n | Ast_411.Parsetree.Pcl_constr (x0, x1) ->\n Ast_410.Parsetree.Pcl_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_411.Parsetree.Pcl_structure x0 ->\n Ast_410.Parsetree.Pcl_structure (copy_class_structure x0)\n | Ast_411.Parsetree.Pcl_fun (x0, x1, x2, x3) ->\n Ast_410.Parsetree.Pcl_fun\n ( copy_arg_label x0,\n Option.map copy_expression x1,\n copy_pattern x2,\n copy_class_expr x3 )\n | Ast_411.Parsetree.Pcl_apply (x0, x1) ->\n Ast_410.Parsetree.Pcl_apply\n ( copy_class_expr x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | Ast_411.Parsetree.Pcl_let (x0, x1, x2) ->\n Ast_410.Parsetree.Pcl_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_class_expr x2)\n | Ast_411.Parsetree.Pcl_constraint (x0, x1) ->\n Ast_410.Parsetree.Pcl_constraint (copy_class_expr x0, copy_class_type x1)\n | Ast_411.Parsetree.Pcl_extension x0 ->\n Ast_410.Parsetree.Pcl_extension (copy_extension x0)\n | Ast_411.Parsetree.Pcl_open (x0, x1) ->\n Ast_410.Parsetree.Pcl_open (copy_open_description x0, copy_class_expr x1)\n\nand copy_class_structure :\n Ast_411.Parsetree.class_structure -> Ast_410.Parsetree.class_structure =\n fun { Ast_411.Parsetree.pcstr_self; Ast_411.Parsetree.pcstr_fields } ->\n {\n Ast_410.Parsetree.pcstr_self = copy_pattern pcstr_self;\n Ast_410.Parsetree.pcstr_fields = List.map copy_class_field pcstr_fields;\n }\n\nand copy_class_field :\n Ast_411.Parsetree.class_field -> Ast_410.Parsetree.class_field =\n fun {\n Ast_411.Parsetree.pcf_desc;\n Ast_411.Parsetree.pcf_loc;\n Ast_411.Parsetree.pcf_attributes;\n } ->\n {\n Ast_410.Parsetree.pcf_desc = copy_class_field_desc pcf_desc;\n Ast_410.Parsetree.pcf_loc = copy_location pcf_loc;\n Ast_410.Parsetree.pcf_attributes = copy_attributes pcf_attributes;\n }\n\nand copy_class_field_desc :\n Ast_411.Parsetree.class_field_desc -> Ast_410.Parsetree.class_field_desc =\n function\n | Ast_411.Parsetree.Pcf_inherit (x0, x1, x2) ->\n Ast_410.Parsetree.Pcf_inherit\n ( copy_override_flag x0,\n copy_class_expr x1,\n Option.map (fun x -> copy_loc (fun x -> x) x) x2 )\n | Ast_411.Parsetree.Pcf_val x0 ->\n Ast_410.Parsetree.Pcf_val\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_mutable_flag x1, copy_class_field_kind x2))\n | Ast_411.Parsetree.Pcf_method x0 ->\n Ast_410.Parsetree.Pcf_method\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_private_flag x1, copy_class_field_kind x2))\n | Ast_411.Parsetree.Pcf_constraint x0 ->\n Ast_410.Parsetree.Pcf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | Ast_411.Parsetree.Pcf_initializer x0 ->\n Ast_410.Parsetree.Pcf_initializer (copy_expression x0)\n | Ast_411.Parsetree.Pcf_attribute x0 ->\n Ast_410.Parsetree.Pcf_attribute (copy_attribute x0)\n | Ast_411.Parsetree.Pcf_extension x0 ->\n Ast_410.Parsetree.Pcf_extension (copy_extension x0)\n\nand copy_class_field_kind :\n Ast_411.Parsetree.class_field_kind -> Ast_410.Parsetree.class_field_kind =\n function\n | Ast_411.Parsetree.Cfk_virtual x0 ->\n Ast_410.Parsetree.Cfk_virtual (copy_core_type x0)\n | Ast_411.Parsetree.Cfk_concrete (x0, x1) ->\n Ast_410.Parsetree.Cfk_concrete (copy_override_flag x0, copy_expression x1)\n\nand copy_open_declaration :\n Ast_411.Parsetree.open_declaration -> Ast_410.Parsetree.open_declaration =\n fun x -> copy_open_infos copy_module_expr x\n\nand copy_module_binding :\n Ast_411.Parsetree.module_binding -> Ast_410.Parsetree.module_binding =\n fun {\n Ast_411.Parsetree.pmb_name;\n Ast_411.Parsetree.pmb_expr;\n Ast_411.Parsetree.pmb_attributes;\n Ast_411.Parsetree.pmb_loc;\n } ->\n {\n Ast_410.Parsetree.pmb_name =\n copy_loc (fun x -> Option.map (fun x -> x) x) pmb_name;\n Ast_410.Parsetree.pmb_expr = copy_module_expr pmb_expr;\n Ast_410.Parsetree.pmb_attributes = copy_attributes pmb_attributes;\n Ast_410.Parsetree.pmb_loc = copy_location pmb_loc;\n }\n\nand copy_module_expr :\n Ast_411.Parsetree.module_expr -> Ast_410.Parsetree.module_expr =\n fun {\n Ast_411.Parsetree.pmod_desc;\n Ast_411.Parsetree.pmod_loc;\n Ast_411.Parsetree.pmod_attributes;\n } ->\n {\n Ast_410.Parsetree.pmod_desc = copy_module_expr_desc pmod_desc;\n Ast_410.Parsetree.pmod_loc = copy_location pmod_loc;\n Ast_410.Parsetree.pmod_attributes = copy_attributes pmod_attributes;\n }\n\nand copy_module_expr_desc :\n Ast_411.Parsetree.module_expr_desc -> Ast_410.Parsetree.module_expr_desc =\n function\n | Ast_411.Parsetree.Pmod_ident x0 ->\n Ast_410.Parsetree.Pmod_ident (copy_loc copy_Longident_t x0)\n | Ast_411.Parsetree.Pmod_structure x0 ->\n Ast_410.Parsetree.Pmod_structure (copy_structure x0)\n | Ast_411.Parsetree.Pmod_functor (x0, x1) ->\n Ast_410.Parsetree.Pmod_functor\n (copy_functor_parameter x0, copy_module_expr x1)\n | Ast_411.Parsetree.Pmod_apply (x0, x1) ->\n Ast_410.Parsetree.Pmod_apply (copy_module_expr x0, copy_module_expr x1)\n | Ast_411.Parsetree.Pmod_constraint (x0, x1) ->\n Ast_410.Parsetree.Pmod_constraint\n (copy_module_expr x0, copy_module_type x1)\n | Ast_411.Parsetree.Pmod_unpack x0 ->\n Ast_410.Parsetree.Pmod_unpack (copy_expression x0)\n | Ast_411.Parsetree.Pmod_extension x0 ->\n Ast_410.Parsetree.Pmod_extension (copy_extension x0)\n\nand copy_functor_parameter :\n Ast_411.Parsetree.functor_parameter -> Ast_410.Parsetree.functor_parameter =\n function\n | Ast_411.Parsetree.Unit -> Ast_410.Parsetree.Unit\n | Ast_411.Parsetree.Named (x0, x1) ->\n Ast_410.Parsetree.Named\n (copy_loc (fun x -> Option.map (fun x -> x) x) x0, copy_module_type x1)\n\nand copy_module_type :\n Ast_411.Parsetree.module_type -> Ast_410.Parsetree.module_type =\n fun {\n Ast_411.Parsetree.pmty_desc;\n Ast_411.Parsetree.pmty_loc;\n Ast_411.Parsetree.pmty_attributes;\n } ->\n {\n Ast_410.Parsetree.pmty_desc = copy_module_type_desc pmty_desc;\n Ast_410.Parsetree.pmty_loc = copy_location pmty_loc;\n Ast_410.Parsetree.pmty_attributes = copy_attributes pmty_attributes;\n }\n\nand copy_module_type_desc :\n Ast_411.Parsetree.module_type_desc -> Ast_410.Parsetree.module_type_desc =\n function\n | Ast_411.Parsetree.Pmty_ident x0 ->\n Ast_410.Parsetree.Pmty_ident (copy_loc copy_Longident_t x0)\n | Ast_411.Parsetree.Pmty_signature x0 ->\n Ast_410.Parsetree.Pmty_signature (copy_signature x0)\n | Ast_411.Parsetree.Pmty_functor (x0, x1) ->\n Ast_410.Parsetree.Pmty_functor\n (copy_functor_parameter x0, copy_module_type x1)\n | Ast_411.Parsetree.Pmty_with (x0, x1) ->\n Ast_410.Parsetree.Pmty_with\n (copy_module_type x0, List.map copy_with_constraint x1)\n | Ast_411.Parsetree.Pmty_typeof x0 ->\n Ast_410.Parsetree.Pmty_typeof (copy_module_expr x0)\n | Ast_411.Parsetree.Pmty_extension x0 ->\n Ast_410.Parsetree.Pmty_extension (copy_extension x0)\n | Ast_411.Parsetree.Pmty_alias x0 ->\n Ast_410.Parsetree.Pmty_alias (copy_loc copy_Longident_t x0)\n\nand copy_with_constraint :\n Ast_411.Parsetree.with_constraint -> Ast_410.Parsetree.with_constraint =\n function\n | Ast_411.Parsetree.Pwith_type (x0, x1) ->\n Ast_410.Parsetree.Pwith_type\n (copy_loc copy_Longident_t x0, copy_type_declaration x1)\n | Ast_411.Parsetree.Pwith_module (x0, x1) ->\n Ast_410.Parsetree.Pwith_module\n (copy_loc copy_Longident_t x0, copy_loc copy_Longident_t x1)\n | Ast_411.Parsetree.Pwith_typesubst (x0, x1) ->\n Ast_410.Parsetree.Pwith_typesubst\n (copy_loc copy_Longident_t x0, copy_type_declaration x1)\n | Ast_411.Parsetree.Pwith_modsubst (x0, x1) ->\n Ast_410.Parsetree.Pwith_modsubst\n (copy_loc copy_Longident_t x0, copy_loc copy_Longident_t x1)\n\nand copy_signature : Ast_411.Parsetree.signature -> Ast_410.Parsetree.signature\n =\n fun x -> List.map copy_signature_item x\n\nand copy_signature_item :\n Ast_411.Parsetree.signature_item -> Ast_410.Parsetree.signature_item =\n fun { Ast_411.Parsetree.psig_desc; Ast_411.Parsetree.psig_loc } ->\n {\n Ast_410.Parsetree.psig_desc = copy_signature_item_desc psig_desc;\n Ast_410.Parsetree.psig_loc = copy_location psig_loc;\n }\n\nand copy_signature_item_desc :\n Ast_411.Parsetree.signature_item_desc ->\n Ast_410.Parsetree.signature_item_desc = function\n | Ast_411.Parsetree.Psig_value x0 ->\n Ast_410.Parsetree.Psig_value (copy_value_description x0)\n | Ast_411.Parsetree.Psig_type (x0, x1) ->\n Ast_410.Parsetree.Psig_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | Ast_411.Parsetree.Psig_typesubst x0 ->\n Ast_410.Parsetree.Psig_typesubst (List.map copy_type_declaration x0)\n | Ast_411.Parsetree.Psig_typext x0 ->\n Ast_410.Parsetree.Psig_typext (copy_type_extension x0)\n | Ast_411.Parsetree.Psig_exception x0 ->\n Ast_410.Parsetree.Psig_exception (copy_type_exception x0)\n | Ast_411.Parsetree.Psig_module x0 ->\n Ast_410.Parsetree.Psig_module (copy_module_declaration x0)\n | Ast_411.Parsetree.Psig_modsubst x0 ->\n Ast_410.Parsetree.Psig_modsubst (copy_module_substitution x0)\n | Ast_411.Parsetree.Psig_recmodule x0 ->\n Ast_410.Parsetree.Psig_recmodule (List.map copy_module_declaration x0)\n | Ast_411.Parsetree.Psig_modtype x0 ->\n Ast_410.Parsetree.Psig_modtype (copy_module_type_declaration x0)\n | Ast_411.Parsetree.Psig_open x0 ->\n Ast_410.Parsetree.Psig_open (copy_open_description x0)\n | Ast_411.Parsetree.Psig_include x0 ->\n Ast_410.Parsetree.Psig_include (copy_include_description x0)\n | Ast_411.Parsetree.Psig_class x0 ->\n Ast_410.Parsetree.Psig_class (List.map copy_class_description x0)\n | Ast_411.Parsetree.Psig_class_type x0 ->\n Ast_410.Parsetree.Psig_class_type\n (List.map copy_class_type_declaration x0)\n | Ast_411.Parsetree.Psig_attribute x0 ->\n Ast_410.Parsetree.Psig_attribute (copy_attribute x0)\n | Ast_411.Parsetree.Psig_extension (x0, x1) ->\n Ast_410.Parsetree.Psig_extension (copy_extension x0, copy_attributes x1)\n\nand copy_class_type_declaration :\n Ast_411.Parsetree.class_type_declaration ->\n Ast_410.Parsetree.class_type_declaration =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_description :\n Ast_411.Parsetree.class_description -> Ast_410.Parsetree.class_description =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_type :\n Ast_411.Parsetree.class_type -> Ast_410.Parsetree.class_type =\n fun {\n Ast_411.Parsetree.pcty_desc;\n Ast_411.Parsetree.pcty_loc;\n Ast_411.Parsetree.pcty_attributes;\n } ->\n {\n Ast_410.Parsetree.pcty_desc = copy_class_type_desc pcty_desc;\n Ast_410.Parsetree.pcty_loc = copy_location pcty_loc;\n Ast_410.Parsetree.pcty_attributes = copy_attributes pcty_attributes;\n }\n\nand copy_class_type_desc :\n Ast_411.Parsetree.class_type_desc -> Ast_410.Parsetree.class_type_desc =\n function\n | Ast_411.Parsetree.Pcty_constr (x0, x1) ->\n Ast_410.Parsetree.Pcty_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_411.Parsetree.Pcty_signature x0 ->\n Ast_410.Parsetree.Pcty_signature (copy_class_signature x0)\n | Ast_411.Parsetree.Pcty_arrow (x0, x1, x2) ->\n Ast_410.Parsetree.Pcty_arrow\n (copy_arg_label x0, copy_core_type x1, copy_class_type x2)\n | Ast_411.Parsetree.Pcty_extension x0 ->\n Ast_410.Parsetree.Pcty_extension (copy_extension x0)\n | Ast_411.Parsetree.Pcty_open (x0, x1) ->\n Ast_410.Parsetree.Pcty_open (copy_open_description x0, copy_class_type x1)\n\nand copy_class_signature :\n Ast_411.Parsetree.class_signature -> Ast_410.Parsetree.class_signature =\n fun { Ast_411.Parsetree.pcsig_self; Ast_411.Parsetree.pcsig_fields } ->\n {\n Ast_410.Parsetree.pcsig_self = copy_core_type pcsig_self;\n Ast_410.Parsetree.pcsig_fields = List.map copy_class_type_field pcsig_fields;\n }\n\nand copy_class_type_field :\n Ast_411.Parsetree.class_type_field -> Ast_410.Parsetree.class_type_field =\n fun {\n Ast_411.Parsetree.pctf_desc;\n Ast_411.Parsetree.pctf_loc;\n Ast_411.Parsetree.pctf_attributes;\n } ->\n {\n Ast_410.Parsetree.pctf_desc = copy_class_type_field_desc pctf_desc;\n Ast_410.Parsetree.pctf_loc = copy_location pctf_loc;\n Ast_410.Parsetree.pctf_attributes = copy_attributes pctf_attributes;\n }\n\nand copy_class_type_field_desc :\n Ast_411.Parsetree.class_type_field_desc ->\n Ast_410.Parsetree.class_type_field_desc = function\n | Ast_411.Parsetree.Pctf_inherit x0 ->\n Ast_410.Parsetree.Pctf_inherit (copy_class_type x0)\n | Ast_411.Parsetree.Pctf_val x0 ->\n Ast_410.Parsetree.Pctf_val\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_mutable_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | Ast_411.Parsetree.Pctf_method x0 ->\n Ast_410.Parsetree.Pctf_method\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_private_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | Ast_411.Parsetree.Pctf_constraint x0 ->\n Ast_410.Parsetree.Pctf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | Ast_411.Parsetree.Pctf_attribute x0 ->\n Ast_410.Parsetree.Pctf_attribute (copy_attribute x0)\n | Ast_411.Parsetree.Pctf_extension x0 ->\n Ast_410.Parsetree.Pctf_extension (copy_extension x0)\n\nand copy_extension : Ast_411.Parsetree.extension -> Ast_410.Parsetree.extension\n =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_class_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_411.Parsetree.class_infos ->\n 'g0 Ast_410.Parsetree.class_infos =\n fun f0\n {\n Ast_411.Parsetree.pci_virt;\n Ast_411.Parsetree.pci_params;\n Ast_411.Parsetree.pci_name;\n Ast_411.Parsetree.pci_expr;\n Ast_411.Parsetree.pci_loc;\n Ast_411.Parsetree.pci_attributes;\n } ->\n {\n Ast_410.Parsetree.pci_virt = copy_virtual_flag pci_virt;\n Ast_410.Parsetree.pci_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n pci_params;\n Ast_410.Parsetree.pci_name = copy_loc (fun x -> x) pci_name;\n Ast_410.Parsetree.pci_expr = f0 pci_expr;\n Ast_410.Parsetree.pci_loc = copy_location pci_loc;\n Ast_410.Parsetree.pci_attributes = copy_attributes pci_attributes;\n }\n\nand copy_virtual_flag :\n Ast_411.Asttypes.virtual_flag -> Ast_410.Asttypes.virtual_flag = function\n | Ast_411.Asttypes.Virtual -> Ast_410.Asttypes.Virtual\n | Ast_411.Asttypes.Concrete -> Ast_410.Asttypes.Concrete\n\nand copy_include_description :\n Ast_411.Parsetree.include_description ->\n Ast_410.Parsetree.include_description =\n fun x -> copy_include_infos copy_module_type x\n\nand copy_include_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_411.Parsetree.include_infos ->\n 'g0 Ast_410.Parsetree.include_infos =\n fun f0\n {\n Ast_411.Parsetree.pincl_mod;\n Ast_411.Parsetree.pincl_loc;\n Ast_411.Parsetree.pincl_attributes;\n } ->\n {\n Ast_410.Parsetree.pincl_mod = f0 pincl_mod;\n Ast_410.Parsetree.pincl_loc = copy_location pincl_loc;\n Ast_410.Parsetree.pincl_attributes = copy_attributes pincl_attributes;\n }\n\nand copy_open_description :\n Ast_411.Parsetree.open_description -> Ast_410.Parsetree.open_description =\n fun x -> copy_open_infos (fun x -> copy_loc copy_Longident_t x) x\n\nand copy_open_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_411.Parsetree.open_infos ->\n 'g0 Ast_410.Parsetree.open_infos =\n fun f0\n {\n Ast_411.Parsetree.popen_expr;\n Ast_411.Parsetree.popen_override;\n Ast_411.Parsetree.popen_loc;\n Ast_411.Parsetree.popen_attributes;\n } ->\n {\n Ast_410.Parsetree.popen_expr = f0 popen_expr;\n Ast_410.Parsetree.popen_override = copy_override_flag popen_override;\n Ast_410.Parsetree.popen_loc = copy_location popen_loc;\n Ast_410.Parsetree.popen_attributes = copy_attributes popen_attributes;\n }\n\nand copy_override_flag :\n Ast_411.Asttypes.override_flag -> Ast_410.Asttypes.override_flag = function\n | Ast_411.Asttypes.Override -> Ast_410.Asttypes.Override\n | Ast_411.Asttypes.Fresh -> Ast_410.Asttypes.Fresh\n\nand copy_module_type_declaration :\n Ast_411.Parsetree.module_type_declaration ->\n Ast_410.Parsetree.module_type_declaration =\n fun {\n Ast_411.Parsetree.pmtd_name;\n Ast_411.Parsetree.pmtd_type;\n Ast_411.Parsetree.pmtd_attributes;\n Ast_411.Parsetree.pmtd_loc;\n } ->\n {\n Ast_410.Parsetree.pmtd_name = copy_loc (fun x -> x) pmtd_name;\n Ast_410.Parsetree.pmtd_type = Option.map copy_module_type pmtd_type;\n Ast_410.Parsetree.pmtd_attributes = copy_attributes pmtd_attributes;\n Ast_410.Parsetree.pmtd_loc = copy_location pmtd_loc;\n }\n\nand copy_module_substitution :\n Ast_411.Parsetree.module_substitution ->\n Ast_410.Parsetree.module_substitution =\n fun {\n Ast_411.Parsetree.pms_name;\n Ast_411.Parsetree.pms_manifest;\n Ast_411.Parsetree.pms_attributes;\n Ast_411.Parsetree.pms_loc;\n } ->\n {\n Ast_410.Parsetree.pms_name = copy_loc (fun x -> x) pms_name;\n Ast_410.Parsetree.pms_manifest = copy_loc copy_Longident_t pms_manifest;\n Ast_410.Parsetree.pms_attributes = copy_attributes pms_attributes;\n Ast_410.Parsetree.pms_loc = copy_location pms_loc;\n }\n\nand copy_module_declaration :\n Ast_411.Parsetree.module_declaration -> Ast_410.Parsetree.module_declaration\n =\n fun {\n Ast_411.Parsetree.pmd_name;\n Ast_411.Parsetree.pmd_type;\n Ast_411.Parsetree.pmd_attributes;\n Ast_411.Parsetree.pmd_loc;\n } ->\n {\n Ast_410.Parsetree.pmd_name =\n copy_loc (fun x -> Option.map (fun x -> x) x) pmd_name;\n Ast_410.Parsetree.pmd_type = copy_module_type pmd_type;\n Ast_410.Parsetree.pmd_attributes = copy_attributes pmd_attributes;\n Ast_410.Parsetree.pmd_loc = copy_location pmd_loc;\n }\n\nand copy_type_exception :\n Ast_411.Parsetree.type_exception -> Ast_410.Parsetree.type_exception =\n fun {\n Ast_411.Parsetree.ptyexn_constructor;\n Ast_411.Parsetree.ptyexn_loc;\n Ast_411.Parsetree.ptyexn_attributes;\n } ->\n {\n Ast_410.Parsetree.ptyexn_constructor =\n copy_extension_constructor ptyexn_constructor;\n Ast_410.Parsetree.ptyexn_loc = copy_location ptyexn_loc;\n Ast_410.Parsetree.ptyexn_attributes = copy_attributes ptyexn_attributes;\n }\n\nand copy_type_extension :\n Ast_411.Parsetree.type_extension -> Ast_410.Parsetree.type_extension =\n fun {\n Ast_411.Parsetree.ptyext_path;\n Ast_411.Parsetree.ptyext_params;\n Ast_411.Parsetree.ptyext_constructors;\n Ast_411.Parsetree.ptyext_private;\n Ast_411.Parsetree.ptyext_loc;\n Ast_411.Parsetree.ptyext_attributes;\n } ->\n {\n Ast_410.Parsetree.ptyext_path = copy_loc copy_Longident_t ptyext_path;\n Ast_410.Parsetree.ptyext_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptyext_params;\n Ast_410.Parsetree.ptyext_constructors =\n List.map copy_extension_constructor ptyext_constructors;\n Ast_410.Parsetree.ptyext_private = copy_private_flag ptyext_private;\n Ast_410.Parsetree.ptyext_loc = copy_location ptyext_loc;\n Ast_410.Parsetree.ptyext_attributes = copy_attributes ptyext_attributes;\n }\n\nand copy_extension_constructor :\n Ast_411.Parsetree.extension_constructor ->\n Ast_410.Parsetree.extension_constructor =\n fun {\n Ast_411.Parsetree.pext_name;\n Ast_411.Parsetree.pext_kind;\n Ast_411.Parsetree.pext_loc;\n Ast_411.Parsetree.pext_attributes;\n } ->\n {\n Ast_410.Parsetree.pext_name = copy_loc (fun x -> x) pext_name;\n Ast_410.Parsetree.pext_kind = copy_extension_constructor_kind pext_kind;\n Ast_410.Parsetree.pext_loc = copy_location pext_loc;\n Ast_410.Parsetree.pext_attributes = copy_attributes pext_attributes;\n }\n\nand copy_extension_constructor_kind :\n Ast_411.Parsetree.extension_constructor_kind ->\n Ast_410.Parsetree.extension_constructor_kind = function\n | Ast_411.Parsetree.Pext_decl (x0, x1) ->\n Ast_410.Parsetree.Pext_decl\n (copy_constructor_arguments x0, Option.map copy_core_type x1)\n | Ast_411.Parsetree.Pext_rebind x0 ->\n Ast_410.Parsetree.Pext_rebind (copy_loc copy_Longident_t x0)\n\nand copy_type_declaration :\n Ast_411.Parsetree.type_declaration -> Ast_410.Parsetree.type_declaration =\n fun {\n Ast_411.Parsetree.ptype_name;\n Ast_411.Parsetree.ptype_params;\n Ast_411.Parsetree.ptype_cstrs;\n Ast_411.Parsetree.ptype_kind;\n Ast_411.Parsetree.ptype_private;\n Ast_411.Parsetree.ptype_manifest;\n Ast_411.Parsetree.ptype_attributes;\n Ast_411.Parsetree.ptype_loc;\n } ->\n {\n Ast_410.Parsetree.ptype_name = copy_loc (fun x -> x) ptype_name;\n Ast_410.Parsetree.ptype_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptype_params;\n Ast_410.Parsetree.ptype_cstrs =\n List.map\n (fun x ->\n let x0, x1, x2 = x in\n (copy_core_type x0, copy_core_type x1, copy_location x2))\n ptype_cstrs;\n Ast_410.Parsetree.ptype_kind = copy_type_kind ptype_kind;\n Ast_410.Parsetree.ptype_private = copy_private_flag ptype_private;\n Ast_410.Parsetree.ptype_manifest = Option.map copy_core_type ptype_manifest;\n Ast_410.Parsetree.ptype_attributes = copy_attributes ptype_attributes;\n Ast_410.Parsetree.ptype_loc = copy_location ptype_loc;\n }\n\nand copy_private_flag :\n Ast_411.Asttypes.private_flag -> Ast_410.Asttypes.private_flag = function\n | Ast_411.Asttypes.Private -> Ast_410.Asttypes.Private\n | Ast_411.Asttypes.Public -> Ast_410.Asttypes.Public\n\nand copy_type_kind : Ast_411.Parsetree.type_kind -> Ast_410.Parsetree.type_kind\n = function\n | Ast_411.Parsetree.Ptype_abstract -> Ast_410.Parsetree.Ptype_abstract\n | Ast_411.Parsetree.Ptype_variant x0 ->\n Ast_410.Parsetree.Ptype_variant (List.map copy_constructor_declaration x0)\n | Ast_411.Parsetree.Ptype_record x0 ->\n Ast_410.Parsetree.Ptype_record (List.map copy_label_declaration x0)\n | Ast_411.Parsetree.Ptype_open -> Ast_410.Parsetree.Ptype_open\n\nand copy_constructor_declaration :\n Ast_411.Parsetree.constructor_declaration ->\n Ast_410.Parsetree.constructor_declaration =\n fun {\n Ast_411.Parsetree.pcd_name;\n Ast_411.Parsetree.pcd_args;\n Ast_411.Parsetree.pcd_res;\n Ast_411.Parsetree.pcd_loc;\n Ast_411.Parsetree.pcd_attributes;\n } ->\n {\n Ast_410.Parsetree.pcd_name = copy_loc (fun x -> x) pcd_name;\n Ast_410.Parsetree.pcd_args = copy_constructor_arguments pcd_args;\n Ast_410.Parsetree.pcd_res = Option.map copy_core_type pcd_res;\n Ast_410.Parsetree.pcd_loc = copy_location pcd_loc;\n Ast_410.Parsetree.pcd_attributes = copy_attributes pcd_attributes;\n }\n\nand copy_constructor_arguments :\n Ast_411.Parsetree.constructor_arguments ->\n Ast_410.Parsetree.constructor_arguments = function\n | Ast_411.Parsetree.Pcstr_tuple x0 ->\n Ast_410.Parsetree.Pcstr_tuple (List.map copy_core_type x0)\n | Ast_411.Parsetree.Pcstr_record x0 ->\n Ast_410.Parsetree.Pcstr_record (List.map copy_label_declaration x0)\n\nand copy_label_declaration :\n Ast_411.Parsetree.label_declaration -> Ast_410.Parsetree.label_declaration =\n fun {\n Ast_411.Parsetree.pld_name;\n Ast_411.Parsetree.pld_mutable;\n Ast_411.Parsetree.pld_type;\n Ast_411.Parsetree.pld_loc;\n Ast_411.Parsetree.pld_attributes;\n } ->\n {\n Ast_410.Parsetree.pld_name = copy_loc (fun x -> x) pld_name;\n Ast_410.Parsetree.pld_mutable = copy_mutable_flag pld_mutable;\n Ast_410.Parsetree.pld_type = copy_core_type pld_type;\n Ast_410.Parsetree.pld_loc = copy_location pld_loc;\n Ast_410.Parsetree.pld_attributes = copy_attributes pld_attributes;\n }\n\nand copy_mutable_flag :\n Ast_411.Asttypes.mutable_flag -> Ast_410.Asttypes.mutable_flag = function\n | Ast_411.Asttypes.Immutable -> Ast_410.Asttypes.Immutable\n | Ast_411.Asttypes.Mutable -> Ast_410.Asttypes.Mutable\n\nand copy_variance : Ast_411.Asttypes.variance -> Ast_410.Asttypes.variance =\n function\n | Ast_411.Asttypes.Covariant -> Ast_410.Asttypes.Covariant\n | Ast_411.Asttypes.Contravariant -> Ast_410.Asttypes.Contravariant\n | Ast_411.Asttypes.Invariant -> Ast_410.Asttypes.Invariant\n\nand copy_value_description :\n Ast_411.Parsetree.value_description -> Ast_410.Parsetree.value_description =\n fun {\n Ast_411.Parsetree.pval_name;\n Ast_411.Parsetree.pval_type;\n Ast_411.Parsetree.pval_prim;\n Ast_411.Parsetree.pval_attributes;\n Ast_411.Parsetree.pval_loc;\n } ->\n {\n Ast_410.Parsetree.pval_name = copy_loc (fun x -> x) pval_name;\n Ast_410.Parsetree.pval_type = copy_core_type pval_type;\n Ast_410.Parsetree.pval_prim = List.map (fun x -> x) pval_prim;\n Ast_410.Parsetree.pval_attributes = copy_attributes pval_attributes;\n Ast_410.Parsetree.pval_loc = copy_location pval_loc;\n }\n\nand copy_object_field_desc :\n Ast_411.Parsetree.object_field_desc -> Ast_410.Parsetree.object_field_desc =\n function\n | Ast_411.Parsetree.Otag (x0, x1) ->\n Ast_410.Parsetree.Otag (copy_loc copy_label x0, copy_core_type x1)\n | Ast_411.Parsetree.Oinherit x0 ->\n Ast_410.Parsetree.Oinherit (copy_core_type x0)\n\nand copy_arg_label : Ast_411.Asttypes.arg_label -> Ast_410.Asttypes.arg_label =\n function\n | Ast_411.Asttypes.Nolabel -> Ast_410.Asttypes.Nolabel\n | Ast_411.Asttypes.Labelled x0 -> Ast_410.Asttypes.Labelled x0\n | Ast_411.Asttypes.Optional x0 -> Ast_410.Asttypes.Optional x0\n\nand copy_closed_flag :\n Ast_411.Asttypes.closed_flag -> Ast_410.Asttypes.closed_flag = function\n | Ast_411.Asttypes.Closed -> Ast_410.Asttypes.Closed\n | Ast_411.Asttypes.Open -> Ast_410.Asttypes.Open\n\nand copy_label : Ast_411.Asttypes.label -> Ast_410.Asttypes.label = fun x -> x\n\nand copy_rec_flag : Ast_411.Asttypes.rec_flag -> Ast_410.Asttypes.rec_flag =\n function\n | Ast_411.Asttypes.Nonrecursive -> Ast_410.Asttypes.Nonrecursive\n | Ast_411.Asttypes.Recursive -> Ast_410.Asttypes.Recursive\n\nand copy_constant : Ast_411.Parsetree.constant -> Ast_410.Parsetree.constant =\n function\n | Ast_411.Parsetree.Pconst_integer (x0, x1) ->\n Ast_410.Parsetree.Pconst_integer (x0, Option.map (fun x -> x) x1)\n | Ast_411.Parsetree.Pconst_char x0 -> Ast_410.Parsetree.Pconst_char x0\n | Ast_411.Parsetree.Pconst_string (x0, _, x2) ->\n Ast_410.Parsetree.Pconst_string (x0, Option.map (fun x -> x) x2)\n | Ast_411.Parsetree.Pconst_float (x0, x1) ->\n Ast_410.Parsetree.Pconst_float (x0, Option.map (fun x -> x) x1)\n\nand copy_Longident_t : Longident.t -> Longident.t = fun x -> x\n\nand copy_loc :\n 'f0 'g0.\n ('f0 -> 'g0) -> 'f0 Ast_411.Asttypes.loc -> 'g0 Ast_410.Asttypes.loc =\n fun f0 { Ast_411.Asttypes.txt; Ast_411.Asttypes.loc } ->\n { Ast_410.Asttypes.txt = f0 txt; Ast_410.Asttypes.loc = copy_location loc }\n\nand copy_location : Location.t -> Location.t = fun x -> x\n","open Stdlib0\nmodule From = Ast_410\nmodule To = Ast_411\n\nlet rec copy_toplevel_phrase :\n Ast_410.Parsetree.toplevel_phrase -> Ast_411.Parsetree.toplevel_phrase =\n function\n | Ast_410.Parsetree.Ptop_def x0 ->\n Ast_411.Parsetree.Ptop_def (copy_structure x0)\n | Ast_410.Parsetree.Ptop_dir x0 ->\n Ast_411.Parsetree.Ptop_dir (copy_toplevel_directive x0)\n\nand copy_toplevel_directive :\n Ast_410.Parsetree.toplevel_directive -> Ast_411.Parsetree.toplevel_directive\n =\n fun {\n Ast_410.Parsetree.pdir_name;\n Ast_410.Parsetree.pdir_arg;\n Ast_410.Parsetree.pdir_loc;\n } ->\n {\n Ast_411.Parsetree.pdir_name = copy_loc (fun x -> x) pdir_name;\n Ast_411.Parsetree.pdir_arg = Option.map copy_directive_argument pdir_arg;\n Ast_411.Parsetree.pdir_loc = copy_location pdir_loc;\n }\n\nand copy_directive_argument :\n Ast_410.Parsetree.directive_argument -> Ast_411.Parsetree.directive_argument\n =\n fun { Ast_410.Parsetree.pdira_desc; Ast_410.Parsetree.pdira_loc } ->\n {\n Ast_411.Parsetree.pdira_desc = copy_directive_argument_desc pdira_desc;\n Ast_411.Parsetree.pdira_loc = copy_location pdira_loc;\n }\n\nand copy_directive_argument_desc :\n Ast_410.Parsetree.directive_argument_desc ->\n Ast_411.Parsetree.directive_argument_desc = function\n | Ast_410.Parsetree.Pdir_string x0 -> Ast_411.Parsetree.Pdir_string x0\n | Ast_410.Parsetree.Pdir_int (x0, x1) ->\n Ast_411.Parsetree.Pdir_int (x0, Option.map (fun x -> x) x1)\n | Ast_410.Parsetree.Pdir_ident x0 ->\n Ast_411.Parsetree.Pdir_ident (copy_Longident_t x0)\n | Ast_410.Parsetree.Pdir_bool x0 -> Ast_411.Parsetree.Pdir_bool x0\n\nand copy_expression :\n Ast_410.Parsetree.expression -> Ast_411.Parsetree.expression =\n fun {\n Ast_410.Parsetree.pexp_desc;\n Ast_410.Parsetree.pexp_loc;\n Ast_410.Parsetree.pexp_loc_stack;\n Ast_410.Parsetree.pexp_attributes;\n } ->\n {\n Ast_411.Parsetree.pexp_desc = copy_expression_desc pexp_desc;\n Ast_411.Parsetree.pexp_loc = copy_location pexp_loc;\n Ast_411.Parsetree.pexp_loc_stack = copy_location_stack pexp_loc_stack;\n Ast_411.Parsetree.pexp_attributes = copy_attributes pexp_attributes;\n }\n\nand copy_expr x = copy_expression x\n\nand copy_expression_desc :\n Ast_410.Parsetree.expression_desc -> Ast_411.Parsetree.expression_desc =\n function\n | Ast_410.Parsetree.Pexp_ident x0 ->\n Ast_411.Parsetree.Pexp_ident (copy_loc copy_Longident_t x0)\n | Ast_410.Parsetree.Pexp_constant x0 ->\n Ast_411.Parsetree.Pexp_constant (copy_constant x0)\n | Ast_410.Parsetree.Pexp_let (x0, x1, x2) ->\n Ast_411.Parsetree.Pexp_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_expression x2)\n | Ast_410.Parsetree.Pexp_function x0 ->\n Ast_411.Parsetree.Pexp_function (List.map copy_case x0)\n | Ast_410.Parsetree.Pexp_fun (x0, x1, x2, x3) ->\n Ast_411.Parsetree.Pexp_fun\n ( copy_arg_label x0,\n Option.map copy_expression x1,\n copy_pattern x2,\n copy_expression x3 )\n | Ast_410.Parsetree.Pexp_apply (x0, x1) ->\n Ast_411.Parsetree.Pexp_apply\n ( copy_expression x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | Ast_410.Parsetree.Pexp_match (x0, x1) ->\n Ast_411.Parsetree.Pexp_match (copy_expression x0, List.map copy_case x1)\n | Ast_410.Parsetree.Pexp_try (x0, x1) ->\n Ast_411.Parsetree.Pexp_try (copy_expression x0, List.map copy_case x1)\n | Ast_410.Parsetree.Pexp_tuple x0 ->\n Ast_411.Parsetree.Pexp_tuple (List.map copy_expression x0)\n | Ast_410.Parsetree.Pexp_construct (x0, x1) ->\n Ast_411.Parsetree.Pexp_construct\n (copy_loc copy_Longident_t x0, Option.map copy_expression x1)\n | Ast_410.Parsetree.Pexp_variant (x0, x1) ->\n Ast_411.Parsetree.Pexp_variant\n (copy_label x0, Option.map copy_expression x1)\n | Ast_410.Parsetree.Pexp_record (x0, x1) ->\n Ast_411.Parsetree.Pexp_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_expression x1))\n x0,\n Option.map copy_expression x1 )\n | Ast_410.Parsetree.Pexp_field (x0, x1) ->\n Ast_411.Parsetree.Pexp_field\n (copy_expression x0, copy_loc copy_Longident_t x1)\n | Ast_410.Parsetree.Pexp_setfield (x0, x1, x2) ->\n Ast_411.Parsetree.Pexp_setfield\n (copy_expression x0, copy_loc copy_Longident_t x1, copy_expression x2)\n | Ast_410.Parsetree.Pexp_array x0 ->\n Ast_411.Parsetree.Pexp_array (List.map copy_expression x0)\n | Ast_410.Parsetree.Pexp_ifthenelse (x0, x1, x2) ->\n Ast_411.Parsetree.Pexp_ifthenelse\n (copy_expression x0, copy_expression x1, Option.map copy_expression x2)\n | Ast_410.Parsetree.Pexp_sequence (x0, x1) ->\n Ast_411.Parsetree.Pexp_sequence (copy_expression x0, copy_expression x1)\n | Ast_410.Parsetree.Pexp_while (x0, x1) ->\n Ast_411.Parsetree.Pexp_while (copy_expression x0, copy_expression x1)\n | Ast_410.Parsetree.Pexp_for (x0, x1, x2, x3, x4) ->\n Ast_411.Parsetree.Pexp_for\n ( copy_pattern x0,\n copy_expression x1,\n copy_expression x2,\n copy_direction_flag x3,\n copy_expression x4 )\n | Ast_410.Parsetree.Pexp_constraint (x0, x1) ->\n Ast_411.Parsetree.Pexp_constraint (copy_expression x0, copy_core_type x1)\n | Ast_410.Parsetree.Pexp_coerce (x0, x1, x2) ->\n Ast_411.Parsetree.Pexp_coerce\n (copy_expression x0, Option.map copy_core_type x1, copy_core_type x2)\n | Ast_410.Parsetree.Pexp_send (x0, x1) ->\n Ast_411.Parsetree.Pexp_send (copy_expression x0, copy_loc copy_label x1)\n | Ast_410.Parsetree.Pexp_new x0 ->\n Ast_411.Parsetree.Pexp_new (copy_loc copy_Longident_t x0)\n | Ast_410.Parsetree.Pexp_setinstvar (x0, x1) ->\n Ast_411.Parsetree.Pexp_setinstvar\n (copy_loc copy_label x0, copy_expression x1)\n | Ast_410.Parsetree.Pexp_override x0 ->\n Ast_411.Parsetree.Pexp_override\n (List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_label x0, copy_expression x1))\n x0)\n | Ast_410.Parsetree.Pexp_letmodule (x0, x1, x2) ->\n Ast_411.Parsetree.Pexp_letmodule\n ( copy_loc (fun x -> Option.map (fun x -> x) x) x0,\n copy_module_expr x1,\n copy_expression x2 )\n | Ast_410.Parsetree.Pexp_letexception (x0, x1) ->\n Ast_411.Parsetree.Pexp_letexception\n (copy_extension_constructor x0, copy_expression x1)\n | Ast_410.Parsetree.Pexp_assert x0 ->\n Ast_411.Parsetree.Pexp_assert (copy_expression x0)\n | Ast_410.Parsetree.Pexp_lazy x0 ->\n Ast_411.Parsetree.Pexp_lazy (copy_expression x0)\n | Ast_410.Parsetree.Pexp_poly (x0, x1) ->\n Ast_411.Parsetree.Pexp_poly\n (copy_expression x0, Option.map copy_core_type x1)\n | Ast_410.Parsetree.Pexp_object x0 ->\n Ast_411.Parsetree.Pexp_object (copy_class_structure x0)\n | Ast_410.Parsetree.Pexp_newtype (x0, x1) ->\n Ast_411.Parsetree.Pexp_newtype\n (copy_loc (fun x -> x) x0, copy_expression x1)\n | Ast_410.Parsetree.Pexp_pack x0 ->\n Ast_411.Parsetree.Pexp_pack (copy_module_expr x0)\n | Ast_410.Parsetree.Pexp_open (x0, x1) ->\n Ast_411.Parsetree.Pexp_open (copy_open_declaration x0, copy_expression x1)\n | Ast_410.Parsetree.Pexp_letop x0 ->\n Ast_411.Parsetree.Pexp_letop (copy_letop x0)\n | Ast_410.Parsetree.Pexp_extension x0 ->\n Ast_411.Parsetree.Pexp_extension (copy_extension x0)\n | Ast_410.Parsetree.Pexp_unreachable -> Ast_411.Parsetree.Pexp_unreachable\n\nand copy_letop : Ast_410.Parsetree.letop -> Ast_411.Parsetree.letop =\n fun { Ast_410.Parsetree.let_; Ast_410.Parsetree.ands; Ast_410.Parsetree.body } ->\n {\n Ast_411.Parsetree.let_ = copy_binding_op let_;\n Ast_411.Parsetree.ands = List.map copy_binding_op ands;\n Ast_411.Parsetree.body = copy_expression body;\n }\n\nand copy_binding_op :\n Ast_410.Parsetree.binding_op -> Ast_411.Parsetree.binding_op =\n fun {\n Ast_410.Parsetree.pbop_op;\n Ast_410.Parsetree.pbop_pat;\n Ast_410.Parsetree.pbop_exp;\n Ast_410.Parsetree.pbop_loc;\n } ->\n {\n Ast_411.Parsetree.pbop_op = copy_loc (fun x -> x) pbop_op;\n Ast_411.Parsetree.pbop_pat = copy_pattern pbop_pat;\n Ast_411.Parsetree.pbop_exp = copy_expression pbop_exp;\n Ast_411.Parsetree.pbop_loc = copy_location pbop_loc;\n }\n\nand copy_direction_flag :\n Ast_410.Asttypes.direction_flag -> Ast_411.Asttypes.direction_flag =\n function\n | Ast_410.Asttypes.Upto -> Ast_411.Asttypes.Upto\n | Ast_410.Asttypes.Downto -> Ast_411.Asttypes.Downto\n\nand copy_case : Ast_410.Parsetree.case -> Ast_411.Parsetree.case =\n fun {\n Ast_410.Parsetree.pc_lhs;\n Ast_410.Parsetree.pc_guard;\n Ast_410.Parsetree.pc_rhs;\n } ->\n {\n Ast_411.Parsetree.pc_lhs = copy_pattern pc_lhs;\n Ast_411.Parsetree.pc_guard = Option.map copy_expression pc_guard;\n Ast_411.Parsetree.pc_rhs = copy_expression pc_rhs;\n }\n\nand copy_cases : Ast_410.Parsetree.case list -> Ast_411.Parsetree.case list =\n fun x -> List.map copy_case x\n\nand copy_value_binding :\n Ast_410.Parsetree.value_binding -> Ast_411.Parsetree.value_binding =\n fun {\n Ast_410.Parsetree.pvb_pat;\n Ast_410.Parsetree.pvb_expr;\n Ast_410.Parsetree.pvb_attributes;\n Ast_410.Parsetree.pvb_loc;\n } ->\n {\n Ast_411.Parsetree.pvb_pat = copy_pattern pvb_pat;\n Ast_411.Parsetree.pvb_expr = copy_expression pvb_expr;\n Ast_411.Parsetree.pvb_attributes = copy_attributes pvb_attributes;\n Ast_411.Parsetree.pvb_loc = copy_location pvb_loc;\n }\n\nand copy_pattern : Ast_410.Parsetree.pattern -> Ast_411.Parsetree.pattern =\n fun {\n Ast_410.Parsetree.ppat_desc;\n Ast_410.Parsetree.ppat_loc;\n Ast_410.Parsetree.ppat_loc_stack;\n Ast_410.Parsetree.ppat_attributes;\n } ->\n {\n Ast_411.Parsetree.ppat_desc = copy_pattern_desc ppat_desc;\n Ast_411.Parsetree.ppat_loc = copy_location ppat_loc;\n Ast_411.Parsetree.ppat_loc_stack = copy_location_stack ppat_loc_stack;\n Ast_411.Parsetree.ppat_attributes = copy_attributes ppat_attributes;\n }\n\nand copy_pat x = copy_pattern x\n\nand copy_pattern_desc :\n Ast_410.Parsetree.pattern_desc -> Ast_411.Parsetree.pattern_desc = function\n | Ast_410.Parsetree.Ppat_any -> Ast_411.Parsetree.Ppat_any\n | Ast_410.Parsetree.Ppat_var x0 ->\n Ast_411.Parsetree.Ppat_var (copy_loc (fun x -> x) x0)\n | Ast_410.Parsetree.Ppat_alias (x0, x1) ->\n Ast_411.Parsetree.Ppat_alias (copy_pattern x0, copy_loc (fun x -> x) x1)\n | Ast_410.Parsetree.Ppat_constant x0 ->\n Ast_411.Parsetree.Ppat_constant (copy_constant x0)\n | Ast_410.Parsetree.Ppat_interval (x0, x1) ->\n Ast_411.Parsetree.Ppat_interval (copy_constant x0, copy_constant x1)\n | Ast_410.Parsetree.Ppat_tuple x0 ->\n Ast_411.Parsetree.Ppat_tuple (List.map copy_pattern x0)\n | Ast_410.Parsetree.Ppat_construct (x0, x1) ->\n Ast_411.Parsetree.Ppat_construct\n (copy_loc copy_Longident_t x0, Option.map copy_pattern x1)\n | Ast_410.Parsetree.Ppat_variant (x0, x1) ->\n Ast_411.Parsetree.Ppat_variant (copy_label x0, Option.map copy_pattern x1)\n | Ast_410.Parsetree.Ppat_record (x0, x1) ->\n Ast_411.Parsetree.Ppat_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_pattern x1))\n x0,\n copy_closed_flag x1 )\n | Ast_410.Parsetree.Ppat_array x0 ->\n Ast_411.Parsetree.Ppat_array (List.map copy_pattern x0)\n | Ast_410.Parsetree.Ppat_or (x0, x1) ->\n Ast_411.Parsetree.Ppat_or (copy_pattern x0, copy_pattern x1)\n | Ast_410.Parsetree.Ppat_constraint (x0, x1) ->\n Ast_411.Parsetree.Ppat_constraint (copy_pattern x0, copy_core_type x1)\n | Ast_410.Parsetree.Ppat_type x0 ->\n Ast_411.Parsetree.Ppat_type (copy_loc copy_Longident_t x0)\n | Ast_410.Parsetree.Ppat_lazy x0 ->\n Ast_411.Parsetree.Ppat_lazy (copy_pattern x0)\n | Ast_410.Parsetree.Ppat_unpack x0 ->\n Ast_411.Parsetree.Ppat_unpack\n (copy_loc (fun x -> Option.map (fun x -> x) x) x0)\n | Ast_410.Parsetree.Ppat_exception x0 ->\n Ast_411.Parsetree.Ppat_exception (copy_pattern x0)\n | Ast_410.Parsetree.Ppat_extension x0 ->\n Ast_411.Parsetree.Ppat_extension (copy_extension x0)\n | Ast_410.Parsetree.Ppat_open (x0, x1) ->\n Ast_411.Parsetree.Ppat_open (copy_loc copy_Longident_t x0, copy_pattern x1)\n\nand copy_core_type : Ast_410.Parsetree.core_type -> Ast_411.Parsetree.core_type\n =\n fun {\n Ast_410.Parsetree.ptyp_desc;\n Ast_410.Parsetree.ptyp_loc;\n Ast_410.Parsetree.ptyp_loc_stack;\n Ast_410.Parsetree.ptyp_attributes;\n } ->\n {\n Ast_411.Parsetree.ptyp_desc = copy_core_type_desc ptyp_desc;\n Ast_411.Parsetree.ptyp_loc = copy_location ptyp_loc;\n Ast_411.Parsetree.ptyp_loc_stack = copy_location_stack ptyp_loc_stack;\n Ast_411.Parsetree.ptyp_attributes = copy_attributes ptyp_attributes;\n }\n\nand copy_typ x = copy_core_type x\n\nand copy_location_stack :\n Ast_410.Parsetree.location_stack -> Ast_411.Parsetree.location_stack =\n fun x -> List.map copy_location x\n\nand copy_core_type_desc :\n Ast_410.Parsetree.core_type_desc -> Ast_411.Parsetree.core_type_desc =\n function\n | Ast_410.Parsetree.Ptyp_any -> Ast_411.Parsetree.Ptyp_any\n | Ast_410.Parsetree.Ptyp_var x0 -> Ast_411.Parsetree.Ptyp_var x0\n | Ast_410.Parsetree.Ptyp_arrow (x0, x1, x2) ->\n Ast_411.Parsetree.Ptyp_arrow\n (copy_arg_label x0, copy_core_type x1, copy_core_type x2)\n | Ast_410.Parsetree.Ptyp_tuple x0 ->\n Ast_411.Parsetree.Ptyp_tuple (List.map copy_core_type x0)\n | Ast_410.Parsetree.Ptyp_constr (x0, x1) ->\n Ast_411.Parsetree.Ptyp_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_410.Parsetree.Ptyp_object (x0, x1) ->\n Ast_411.Parsetree.Ptyp_object\n (List.map copy_object_field x0, copy_closed_flag x1)\n | Ast_410.Parsetree.Ptyp_class (x0, x1) ->\n Ast_411.Parsetree.Ptyp_class\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_410.Parsetree.Ptyp_alias (x0, x1) ->\n Ast_411.Parsetree.Ptyp_alias (copy_core_type x0, x1)\n | Ast_410.Parsetree.Ptyp_variant (x0, x1, x2) ->\n Ast_411.Parsetree.Ptyp_variant\n ( List.map copy_row_field x0,\n copy_closed_flag x1,\n Option.map (fun x -> List.map copy_label x) x2 )\n | Ast_410.Parsetree.Ptyp_poly (x0, x1) ->\n Ast_411.Parsetree.Ptyp_poly\n (List.map (fun x -> copy_loc (fun x -> x) x) x0, copy_core_type x1)\n | Ast_410.Parsetree.Ptyp_package x0 ->\n Ast_411.Parsetree.Ptyp_package (copy_package_type x0)\n | Ast_410.Parsetree.Ptyp_extension x0 ->\n Ast_411.Parsetree.Ptyp_extension (copy_extension x0)\n\nand copy_package_type :\n Ast_410.Parsetree.package_type -> Ast_411.Parsetree.package_type =\n fun x ->\n let x0, x1 = x in\n ( copy_loc copy_Longident_t x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_core_type x1))\n x1 )\n\nand copy_row_field : Ast_410.Parsetree.row_field -> Ast_411.Parsetree.row_field\n =\n fun {\n Ast_410.Parsetree.prf_desc;\n Ast_410.Parsetree.prf_loc;\n Ast_410.Parsetree.prf_attributes;\n } ->\n {\n Ast_411.Parsetree.prf_desc = copy_row_field_desc prf_desc;\n Ast_411.Parsetree.prf_loc = copy_location prf_loc;\n Ast_411.Parsetree.prf_attributes = copy_attributes prf_attributes;\n }\n\nand copy_row_field_desc :\n Ast_410.Parsetree.row_field_desc -> Ast_411.Parsetree.row_field_desc =\n function\n | Ast_410.Parsetree.Rtag (x0, x1, x2) ->\n Ast_411.Parsetree.Rtag\n (copy_loc copy_label x0, x1, List.map copy_core_type x2)\n | Ast_410.Parsetree.Rinherit x0 ->\n Ast_411.Parsetree.Rinherit (copy_core_type x0)\n\nand copy_object_field :\n Ast_410.Parsetree.object_field -> Ast_411.Parsetree.object_field =\n fun {\n Ast_410.Parsetree.pof_desc;\n Ast_410.Parsetree.pof_loc;\n Ast_410.Parsetree.pof_attributes;\n } ->\n {\n Ast_411.Parsetree.pof_desc = copy_object_field_desc pof_desc;\n Ast_411.Parsetree.pof_loc = copy_location pof_loc;\n Ast_411.Parsetree.pof_attributes = copy_attributes pof_attributes;\n }\n\nand copy_attributes :\n Ast_410.Parsetree.attributes -> Ast_411.Parsetree.attributes =\n fun x -> List.map copy_attribute x\n\nand copy_attribute : Ast_410.Parsetree.attribute -> Ast_411.Parsetree.attribute\n =\n fun {\n Ast_410.Parsetree.attr_name;\n Ast_410.Parsetree.attr_payload;\n Ast_410.Parsetree.attr_loc;\n } ->\n {\n Ast_411.Parsetree.attr_name = copy_loc (fun x -> x) attr_name;\n Ast_411.Parsetree.attr_payload = copy_payload attr_payload;\n Ast_411.Parsetree.attr_loc = copy_location attr_loc;\n }\n\nand copy_payload : Ast_410.Parsetree.payload -> Ast_411.Parsetree.payload =\n function\n | Ast_410.Parsetree.PStr x0 -> Ast_411.Parsetree.PStr (copy_structure x0)\n | Ast_410.Parsetree.PSig x0 -> Ast_411.Parsetree.PSig (copy_signature x0)\n | Ast_410.Parsetree.PTyp x0 -> Ast_411.Parsetree.PTyp (copy_core_type x0)\n | Ast_410.Parsetree.PPat (x0, x1) ->\n Ast_411.Parsetree.PPat (copy_pattern x0, Option.map copy_expression x1)\n\nand copy_structure : Ast_410.Parsetree.structure -> Ast_411.Parsetree.structure\n =\n fun x -> List.map copy_structure_item x\n\nand copy_structure_item :\n Ast_410.Parsetree.structure_item -> Ast_411.Parsetree.structure_item =\n fun { Ast_410.Parsetree.pstr_desc; Ast_410.Parsetree.pstr_loc } ->\n {\n Ast_411.Parsetree.pstr_desc = copy_structure_item_desc pstr_desc;\n Ast_411.Parsetree.pstr_loc = copy_location pstr_loc;\n }\n\nand copy_structure_item_desc :\n Ast_410.Parsetree.structure_item_desc ->\n Ast_411.Parsetree.structure_item_desc = function\n | Ast_410.Parsetree.Pstr_eval (x0, x1) ->\n Ast_411.Parsetree.Pstr_eval (copy_expression x0, copy_attributes x1)\n | Ast_410.Parsetree.Pstr_value (x0, x1) ->\n Ast_411.Parsetree.Pstr_value\n (copy_rec_flag x0, List.map copy_value_binding x1)\n | Ast_410.Parsetree.Pstr_primitive x0 ->\n Ast_411.Parsetree.Pstr_primitive (copy_value_description x0)\n | Ast_410.Parsetree.Pstr_type (x0, x1) ->\n Ast_411.Parsetree.Pstr_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | Ast_410.Parsetree.Pstr_typext x0 ->\n Ast_411.Parsetree.Pstr_typext (copy_type_extension x0)\n | Ast_410.Parsetree.Pstr_exception x0 ->\n Ast_411.Parsetree.Pstr_exception (copy_type_exception x0)\n | Ast_410.Parsetree.Pstr_module x0 ->\n Ast_411.Parsetree.Pstr_module (copy_module_binding x0)\n | Ast_410.Parsetree.Pstr_recmodule x0 ->\n Ast_411.Parsetree.Pstr_recmodule (List.map copy_module_binding x0)\n | Ast_410.Parsetree.Pstr_modtype x0 ->\n Ast_411.Parsetree.Pstr_modtype (copy_module_type_declaration x0)\n | Ast_410.Parsetree.Pstr_open x0 ->\n Ast_411.Parsetree.Pstr_open (copy_open_declaration x0)\n | Ast_410.Parsetree.Pstr_class x0 ->\n Ast_411.Parsetree.Pstr_class (List.map copy_class_declaration x0)\n | Ast_410.Parsetree.Pstr_class_type x0 ->\n Ast_411.Parsetree.Pstr_class_type\n (List.map copy_class_type_declaration x0)\n | Ast_410.Parsetree.Pstr_include x0 ->\n Ast_411.Parsetree.Pstr_include (copy_include_declaration x0)\n | Ast_410.Parsetree.Pstr_attribute x0 ->\n Ast_411.Parsetree.Pstr_attribute (copy_attribute x0)\n | Ast_410.Parsetree.Pstr_extension (x0, x1) ->\n Ast_411.Parsetree.Pstr_extension (copy_extension x0, copy_attributes x1)\n\nand copy_include_declaration :\n Ast_410.Parsetree.include_declaration ->\n Ast_411.Parsetree.include_declaration =\n fun x -> copy_include_infos copy_module_expr x\n\nand copy_class_declaration :\n Ast_410.Parsetree.class_declaration -> Ast_411.Parsetree.class_declaration =\n fun x -> copy_class_infos copy_class_expr x\n\nand copy_class_expr :\n Ast_410.Parsetree.class_expr -> Ast_411.Parsetree.class_expr =\n fun {\n Ast_410.Parsetree.pcl_desc;\n Ast_410.Parsetree.pcl_loc;\n Ast_410.Parsetree.pcl_attributes;\n } ->\n {\n Ast_411.Parsetree.pcl_desc = copy_class_expr_desc pcl_desc;\n Ast_411.Parsetree.pcl_loc = copy_location pcl_loc;\n Ast_411.Parsetree.pcl_attributes = copy_attributes pcl_attributes;\n }\n\nand copy_class_expr_desc :\n Ast_410.Parsetree.class_expr_desc -> Ast_411.Parsetree.class_expr_desc =\n function\n | Ast_410.Parsetree.Pcl_constr (x0, x1) ->\n Ast_411.Parsetree.Pcl_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_410.Parsetree.Pcl_structure x0 ->\n Ast_411.Parsetree.Pcl_structure (copy_class_structure x0)\n | Ast_410.Parsetree.Pcl_fun (x0, x1, x2, x3) ->\n Ast_411.Parsetree.Pcl_fun\n ( copy_arg_label x0,\n Option.map copy_expression x1,\n copy_pattern x2,\n copy_class_expr x3 )\n | Ast_410.Parsetree.Pcl_apply (x0, x1) ->\n Ast_411.Parsetree.Pcl_apply\n ( copy_class_expr x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | Ast_410.Parsetree.Pcl_let (x0, x1, x2) ->\n Ast_411.Parsetree.Pcl_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_class_expr x2)\n | Ast_410.Parsetree.Pcl_constraint (x0, x1) ->\n Ast_411.Parsetree.Pcl_constraint (copy_class_expr x0, copy_class_type x1)\n | Ast_410.Parsetree.Pcl_extension x0 ->\n Ast_411.Parsetree.Pcl_extension (copy_extension x0)\n | Ast_410.Parsetree.Pcl_open (x0, x1) ->\n Ast_411.Parsetree.Pcl_open (copy_open_description x0, copy_class_expr x1)\n\nand copy_class_structure :\n Ast_410.Parsetree.class_structure -> Ast_411.Parsetree.class_structure =\n fun { Ast_410.Parsetree.pcstr_self; Ast_410.Parsetree.pcstr_fields } ->\n {\n Ast_411.Parsetree.pcstr_self = copy_pattern pcstr_self;\n Ast_411.Parsetree.pcstr_fields = List.map copy_class_field pcstr_fields;\n }\n\nand copy_class_field :\n Ast_410.Parsetree.class_field -> Ast_411.Parsetree.class_field =\n fun {\n Ast_410.Parsetree.pcf_desc;\n Ast_410.Parsetree.pcf_loc;\n Ast_410.Parsetree.pcf_attributes;\n } ->\n {\n Ast_411.Parsetree.pcf_desc = copy_class_field_desc pcf_desc;\n Ast_411.Parsetree.pcf_loc = copy_location pcf_loc;\n Ast_411.Parsetree.pcf_attributes = copy_attributes pcf_attributes;\n }\n\nand copy_class_field_desc :\n Ast_410.Parsetree.class_field_desc -> Ast_411.Parsetree.class_field_desc =\n function\n | Ast_410.Parsetree.Pcf_inherit (x0, x1, x2) ->\n Ast_411.Parsetree.Pcf_inherit\n ( copy_override_flag x0,\n copy_class_expr x1,\n Option.map (fun x -> copy_loc (fun x -> x) x) x2 )\n | Ast_410.Parsetree.Pcf_val x0 ->\n Ast_411.Parsetree.Pcf_val\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_mutable_flag x1, copy_class_field_kind x2))\n | Ast_410.Parsetree.Pcf_method x0 ->\n Ast_411.Parsetree.Pcf_method\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_private_flag x1, copy_class_field_kind x2))\n | Ast_410.Parsetree.Pcf_constraint x0 ->\n Ast_411.Parsetree.Pcf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | Ast_410.Parsetree.Pcf_initializer x0 ->\n Ast_411.Parsetree.Pcf_initializer (copy_expression x0)\n | Ast_410.Parsetree.Pcf_attribute x0 ->\n Ast_411.Parsetree.Pcf_attribute (copy_attribute x0)\n | Ast_410.Parsetree.Pcf_extension x0 ->\n Ast_411.Parsetree.Pcf_extension (copy_extension x0)\n\nand copy_class_field_kind :\n Ast_410.Parsetree.class_field_kind -> Ast_411.Parsetree.class_field_kind =\n function\n | Ast_410.Parsetree.Cfk_virtual x0 ->\n Ast_411.Parsetree.Cfk_virtual (copy_core_type x0)\n | Ast_410.Parsetree.Cfk_concrete (x0, x1) ->\n Ast_411.Parsetree.Cfk_concrete (copy_override_flag x0, copy_expression x1)\n\nand copy_open_declaration :\n Ast_410.Parsetree.open_declaration -> Ast_411.Parsetree.open_declaration =\n fun x -> copy_open_infos copy_module_expr x\n\nand copy_module_binding :\n Ast_410.Parsetree.module_binding -> Ast_411.Parsetree.module_binding =\n fun {\n Ast_410.Parsetree.pmb_name;\n Ast_410.Parsetree.pmb_expr;\n Ast_410.Parsetree.pmb_attributes;\n Ast_410.Parsetree.pmb_loc;\n } ->\n {\n Ast_411.Parsetree.pmb_name =\n copy_loc (fun x -> Option.map (fun x -> x) x) pmb_name;\n Ast_411.Parsetree.pmb_expr = copy_module_expr pmb_expr;\n Ast_411.Parsetree.pmb_attributes = copy_attributes pmb_attributes;\n Ast_411.Parsetree.pmb_loc = copy_location pmb_loc;\n }\n\nand copy_module_expr :\n Ast_410.Parsetree.module_expr -> Ast_411.Parsetree.module_expr =\n fun {\n Ast_410.Parsetree.pmod_desc;\n Ast_410.Parsetree.pmod_loc;\n Ast_410.Parsetree.pmod_attributes;\n } ->\n {\n Ast_411.Parsetree.pmod_desc = copy_module_expr_desc pmod_desc;\n Ast_411.Parsetree.pmod_loc = copy_location pmod_loc;\n Ast_411.Parsetree.pmod_attributes = copy_attributes pmod_attributes;\n }\n\nand copy_module_expr_desc :\n Ast_410.Parsetree.module_expr_desc -> Ast_411.Parsetree.module_expr_desc =\n function\n | Ast_410.Parsetree.Pmod_ident x0 ->\n Ast_411.Parsetree.Pmod_ident (copy_loc copy_Longident_t x0)\n | Ast_410.Parsetree.Pmod_structure x0 ->\n Ast_411.Parsetree.Pmod_structure (copy_structure x0)\n | Ast_410.Parsetree.Pmod_functor (x0, x1) ->\n Ast_411.Parsetree.Pmod_functor\n (copy_functor_parameter x0, copy_module_expr x1)\n | Ast_410.Parsetree.Pmod_apply (x0, x1) ->\n Ast_411.Parsetree.Pmod_apply (copy_module_expr x0, copy_module_expr x1)\n | Ast_410.Parsetree.Pmod_constraint (x0, x1) ->\n Ast_411.Parsetree.Pmod_constraint\n (copy_module_expr x0, copy_module_type x1)\n | Ast_410.Parsetree.Pmod_unpack x0 ->\n Ast_411.Parsetree.Pmod_unpack (copy_expression x0)\n | Ast_410.Parsetree.Pmod_extension x0 ->\n Ast_411.Parsetree.Pmod_extension (copy_extension x0)\n\nand copy_functor_parameter :\n Ast_410.Parsetree.functor_parameter -> Ast_411.Parsetree.functor_parameter =\n function\n | Ast_410.Parsetree.Unit -> Ast_411.Parsetree.Unit\n | Ast_410.Parsetree.Named (x0, x1) ->\n Ast_411.Parsetree.Named\n (copy_loc (fun x -> Option.map (fun x -> x) x) x0, copy_module_type x1)\n\nand copy_module_type :\n Ast_410.Parsetree.module_type -> Ast_411.Parsetree.module_type =\n fun {\n Ast_410.Parsetree.pmty_desc;\n Ast_410.Parsetree.pmty_loc;\n Ast_410.Parsetree.pmty_attributes;\n } ->\n {\n Ast_411.Parsetree.pmty_desc = copy_module_type_desc pmty_desc;\n Ast_411.Parsetree.pmty_loc = copy_location pmty_loc;\n Ast_411.Parsetree.pmty_attributes = copy_attributes pmty_attributes;\n }\n\nand copy_module_type_desc :\n Ast_410.Parsetree.module_type_desc -> Ast_411.Parsetree.module_type_desc =\n function\n | Ast_410.Parsetree.Pmty_ident x0 ->\n Ast_411.Parsetree.Pmty_ident (copy_loc copy_Longident_t x0)\n | Ast_410.Parsetree.Pmty_signature x0 ->\n Ast_411.Parsetree.Pmty_signature (copy_signature x0)\n | Ast_410.Parsetree.Pmty_functor (x0, x1) ->\n Ast_411.Parsetree.Pmty_functor\n (copy_functor_parameter x0, copy_module_type x1)\n | Ast_410.Parsetree.Pmty_with (x0, x1) ->\n Ast_411.Parsetree.Pmty_with\n (copy_module_type x0, List.map copy_with_constraint x1)\n | Ast_410.Parsetree.Pmty_typeof x0 ->\n Ast_411.Parsetree.Pmty_typeof (copy_module_expr x0)\n | Ast_410.Parsetree.Pmty_extension x0 ->\n Ast_411.Parsetree.Pmty_extension (copy_extension x0)\n | Ast_410.Parsetree.Pmty_alias x0 ->\n Ast_411.Parsetree.Pmty_alias (copy_loc copy_Longident_t x0)\n\nand copy_with_constraint :\n Ast_410.Parsetree.with_constraint -> Ast_411.Parsetree.with_constraint =\n function\n | Ast_410.Parsetree.Pwith_type (x0, x1) ->\n Ast_411.Parsetree.Pwith_type\n (copy_loc copy_Longident_t x0, copy_type_declaration x1)\n | Ast_410.Parsetree.Pwith_module (x0, x1) ->\n Ast_411.Parsetree.Pwith_module\n (copy_loc copy_Longident_t x0, copy_loc copy_Longident_t x1)\n | Ast_410.Parsetree.Pwith_typesubst (x0, x1) ->\n Ast_411.Parsetree.Pwith_typesubst\n (copy_loc copy_Longident_t x0, copy_type_declaration x1)\n | Ast_410.Parsetree.Pwith_modsubst (x0, x1) ->\n Ast_411.Parsetree.Pwith_modsubst\n (copy_loc copy_Longident_t x0, copy_loc copy_Longident_t x1)\n\nand copy_signature : Ast_410.Parsetree.signature -> Ast_411.Parsetree.signature\n =\n fun x -> List.map copy_signature_item x\n\nand copy_signature_item :\n Ast_410.Parsetree.signature_item -> Ast_411.Parsetree.signature_item =\n fun { Ast_410.Parsetree.psig_desc; Ast_410.Parsetree.psig_loc } ->\n {\n Ast_411.Parsetree.psig_desc = copy_signature_item_desc psig_desc;\n Ast_411.Parsetree.psig_loc = copy_location psig_loc;\n }\n\nand copy_signature_item_desc :\n Ast_410.Parsetree.signature_item_desc ->\n Ast_411.Parsetree.signature_item_desc = function\n | Ast_410.Parsetree.Psig_value x0 ->\n Ast_411.Parsetree.Psig_value (copy_value_description x0)\n | Ast_410.Parsetree.Psig_type (x0, x1) ->\n Ast_411.Parsetree.Psig_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | Ast_410.Parsetree.Psig_typesubst x0 ->\n Ast_411.Parsetree.Psig_typesubst (List.map copy_type_declaration x0)\n | Ast_410.Parsetree.Psig_typext x0 ->\n Ast_411.Parsetree.Psig_typext (copy_type_extension x0)\n | Ast_410.Parsetree.Psig_exception x0 ->\n Ast_411.Parsetree.Psig_exception (copy_type_exception x0)\n | Ast_410.Parsetree.Psig_module x0 ->\n Ast_411.Parsetree.Psig_module (copy_module_declaration x0)\n | Ast_410.Parsetree.Psig_modsubst x0 ->\n Ast_411.Parsetree.Psig_modsubst (copy_module_substitution x0)\n | Ast_410.Parsetree.Psig_recmodule x0 ->\n Ast_411.Parsetree.Psig_recmodule (List.map copy_module_declaration x0)\n | Ast_410.Parsetree.Psig_modtype x0 ->\n Ast_411.Parsetree.Psig_modtype (copy_module_type_declaration x0)\n | Ast_410.Parsetree.Psig_open x0 ->\n Ast_411.Parsetree.Psig_open (copy_open_description x0)\n | Ast_410.Parsetree.Psig_include x0 ->\n Ast_411.Parsetree.Psig_include (copy_include_description x0)\n | Ast_410.Parsetree.Psig_class x0 ->\n Ast_411.Parsetree.Psig_class (List.map copy_class_description x0)\n | Ast_410.Parsetree.Psig_class_type x0 ->\n Ast_411.Parsetree.Psig_class_type\n (List.map copy_class_type_declaration x0)\n | Ast_410.Parsetree.Psig_attribute x0 ->\n Ast_411.Parsetree.Psig_attribute (copy_attribute x0)\n | Ast_410.Parsetree.Psig_extension (x0, x1) ->\n Ast_411.Parsetree.Psig_extension (copy_extension x0, copy_attributes x1)\n\nand copy_class_type_declaration :\n Ast_410.Parsetree.class_type_declaration ->\n Ast_411.Parsetree.class_type_declaration =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_description :\n Ast_410.Parsetree.class_description -> Ast_411.Parsetree.class_description =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_type :\n Ast_410.Parsetree.class_type -> Ast_411.Parsetree.class_type =\n fun {\n Ast_410.Parsetree.pcty_desc;\n Ast_410.Parsetree.pcty_loc;\n Ast_410.Parsetree.pcty_attributes;\n } ->\n {\n Ast_411.Parsetree.pcty_desc = copy_class_type_desc pcty_desc;\n Ast_411.Parsetree.pcty_loc = copy_location pcty_loc;\n Ast_411.Parsetree.pcty_attributes = copy_attributes pcty_attributes;\n }\n\nand copy_class_type_desc :\n Ast_410.Parsetree.class_type_desc -> Ast_411.Parsetree.class_type_desc =\n function\n | Ast_410.Parsetree.Pcty_constr (x0, x1) ->\n Ast_411.Parsetree.Pcty_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_410.Parsetree.Pcty_signature x0 ->\n Ast_411.Parsetree.Pcty_signature (copy_class_signature x0)\n | Ast_410.Parsetree.Pcty_arrow (x0, x1, x2) ->\n Ast_411.Parsetree.Pcty_arrow\n (copy_arg_label x0, copy_core_type x1, copy_class_type x2)\n | Ast_410.Parsetree.Pcty_extension x0 ->\n Ast_411.Parsetree.Pcty_extension (copy_extension x0)\n | Ast_410.Parsetree.Pcty_open (x0, x1) ->\n Ast_411.Parsetree.Pcty_open (copy_open_description x0, copy_class_type x1)\n\nand copy_class_signature :\n Ast_410.Parsetree.class_signature -> Ast_411.Parsetree.class_signature =\n fun { Ast_410.Parsetree.pcsig_self; Ast_410.Parsetree.pcsig_fields } ->\n {\n Ast_411.Parsetree.pcsig_self = copy_core_type pcsig_self;\n Ast_411.Parsetree.pcsig_fields = List.map copy_class_type_field pcsig_fields;\n }\n\nand copy_class_type_field :\n Ast_410.Parsetree.class_type_field -> Ast_411.Parsetree.class_type_field =\n fun {\n Ast_410.Parsetree.pctf_desc;\n Ast_410.Parsetree.pctf_loc;\n Ast_410.Parsetree.pctf_attributes;\n } ->\n {\n Ast_411.Parsetree.pctf_desc = copy_class_type_field_desc pctf_desc;\n Ast_411.Parsetree.pctf_loc = copy_location pctf_loc;\n Ast_411.Parsetree.pctf_attributes = copy_attributes pctf_attributes;\n }\n\nand copy_class_type_field_desc :\n Ast_410.Parsetree.class_type_field_desc ->\n Ast_411.Parsetree.class_type_field_desc = function\n | Ast_410.Parsetree.Pctf_inherit x0 ->\n Ast_411.Parsetree.Pctf_inherit (copy_class_type x0)\n | Ast_410.Parsetree.Pctf_val x0 ->\n Ast_411.Parsetree.Pctf_val\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_mutable_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | Ast_410.Parsetree.Pctf_method x0 ->\n Ast_411.Parsetree.Pctf_method\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_private_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | Ast_410.Parsetree.Pctf_constraint x0 ->\n Ast_411.Parsetree.Pctf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | Ast_410.Parsetree.Pctf_attribute x0 ->\n Ast_411.Parsetree.Pctf_attribute (copy_attribute x0)\n | Ast_410.Parsetree.Pctf_extension x0 ->\n Ast_411.Parsetree.Pctf_extension (copy_extension x0)\n\nand copy_extension : Ast_410.Parsetree.extension -> Ast_411.Parsetree.extension\n =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_class_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_410.Parsetree.class_infos ->\n 'g0 Ast_411.Parsetree.class_infos =\n fun f0\n {\n Ast_410.Parsetree.pci_virt;\n Ast_410.Parsetree.pci_params;\n Ast_410.Parsetree.pci_name;\n Ast_410.Parsetree.pci_expr;\n Ast_410.Parsetree.pci_loc;\n Ast_410.Parsetree.pci_attributes;\n } ->\n {\n Ast_411.Parsetree.pci_virt = copy_virtual_flag pci_virt;\n Ast_411.Parsetree.pci_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n pci_params;\n Ast_411.Parsetree.pci_name = copy_loc (fun x -> x) pci_name;\n Ast_411.Parsetree.pci_expr = f0 pci_expr;\n Ast_411.Parsetree.pci_loc = copy_location pci_loc;\n Ast_411.Parsetree.pci_attributes = copy_attributes pci_attributes;\n }\n\nand copy_virtual_flag :\n Ast_410.Asttypes.virtual_flag -> Ast_411.Asttypes.virtual_flag = function\n | Ast_410.Asttypes.Virtual -> Ast_411.Asttypes.Virtual\n | Ast_410.Asttypes.Concrete -> Ast_411.Asttypes.Concrete\n\nand copy_include_description :\n Ast_410.Parsetree.include_description ->\n Ast_411.Parsetree.include_description =\n fun x -> copy_include_infos copy_module_type x\n\nand copy_include_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_410.Parsetree.include_infos ->\n 'g0 Ast_411.Parsetree.include_infos =\n fun f0\n {\n Ast_410.Parsetree.pincl_mod;\n Ast_410.Parsetree.pincl_loc;\n Ast_410.Parsetree.pincl_attributes;\n } ->\n {\n Ast_411.Parsetree.pincl_mod = f0 pincl_mod;\n Ast_411.Parsetree.pincl_loc = copy_location pincl_loc;\n Ast_411.Parsetree.pincl_attributes = copy_attributes pincl_attributes;\n }\n\nand copy_open_description :\n Ast_410.Parsetree.open_description -> Ast_411.Parsetree.open_description =\n fun x -> copy_open_infos (fun x -> copy_loc copy_Longident_t x) x\n\nand copy_open_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_410.Parsetree.open_infos ->\n 'g0 Ast_411.Parsetree.open_infos =\n fun f0\n {\n Ast_410.Parsetree.popen_expr;\n Ast_410.Parsetree.popen_override;\n Ast_410.Parsetree.popen_loc;\n Ast_410.Parsetree.popen_attributes;\n } ->\n {\n Ast_411.Parsetree.popen_expr = f0 popen_expr;\n Ast_411.Parsetree.popen_override = copy_override_flag popen_override;\n Ast_411.Parsetree.popen_loc = copy_location popen_loc;\n Ast_411.Parsetree.popen_attributes = copy_attributes popen_attributes;\n }\n\nand copy_override_flag :\n Ast_410.Asttypes.override_flag -> Ast_411.Asttypes.override_flag = function\n | Ast_410.Asttypes.Override -> Ast_411.Asttypes.Override\n | Ast_410.Asttypes.Fresh -> Ast_411.Asttypes.Fresh\n\nand copy_module_type_declaration :\n Ast_410.Parsetree.module_type_declaration ->\n Ast_411.Parsetree.module_type_declaration =\n fun {\n Ast_410.Parsetree.pmtd_name;\n Ast_410.Parsetree.pmtd_type;\n Ast_410.Parsetree.pmtd_attributes;\n Ast_410.Parsetree.pmtd_loc;\n } ->\n {\n Ast_411.Parsetree.pmtd_name = copy_loc (fun x -> x) pmtd_name;\n Ast_411.Parsetree.pmtd_type = Option.map copy_module_type pmtd_type;\n Ast_411.Parsetree.pmtd_attributes = copy_attributes pmtd_attributes;\n Ast_411.Parsetree.pmtd_loc = copy_location pmtd_loc;\n }\n\nand copy_module_substitution :\n Ast_410.Parsetree.module_substitution ->\n Ast_411.Parsetree.module_substitution =\n fun {\n Ast_410.Parsetree.pms_name;\n Ast_410.Parsetree.pms_manifest;\n Ast_410.Parsetree.pms_attributes;\n Ast_410.Parsetree.pms_loc;\n } ->\n {\n Ast_411.Parsetree.pms_name = copy_loc (fun x -> x) pms_name;\n Ast_411.Parsetree.pms_manifest = copy_loc copy_Longident_t pms_manifest;\n Ast_411.Parsetree.pms_attributes = copy_attributes pms_attributes;\n Ast_411.Parsetree.pms_loc = copy_location pms_loc;\n }\n\nand copy_module_declaration :\n Ast_410.Parsetree.module_declaration -> Ast_411.Parsetree.module_declaration\n =\n fun {\n Ast_410.Parsetree.pmd_name;\n Ast_410.Parsetree.pmd_type;\n Ast_410.Parsetree.pmd_attributes;\n Ast_410.Parsetree.pmd_loc;\n } ->\n {\n Ast_411.Parsetree.pmd_name =\n copy_loc (fun x -> Option.map (fun x -> x) x) pmd_name;\n Ast_411.Parsetree.pmd_type = copy_module_type pmd_type;\n Ast_411.Parsetree.pmd_attributes = copy_attributes pmd_attributes;\n Ast_411.Parsetree.pmd_loc = copy_location pmd_loc;\n }\n\nand copy_type_exception :\n Ast_410.Parsetree.type_exception -> Ast_411.Parsetree.type_exception =\n fun {\n Ast_410.Parsetree.ptyexn_constructor;\n Ast_410.Parsetree.ptyexn_loc;\n Ast_410.Parsetree.ptyexn_attributes;\n } ->\n {\n Ast_411.Parsetree.ptyexn_constructor =\n copy_extension_constructor ptyexn_constructor;\n Ast_411.Parsetree.ptyexn_loc = copy_location ptyexn_loc;\n Ast_411.Parsetree.ptyexn_attributes = copy_attributes ptyexn_attributes;\n }\n\nand copy_type_extension :\n Ast_410.Parsetree.type_extension -> Ast_411.Parsetree.type_extension =\n fun {\n Ast_410.Parsetree.ptyext_path;\n Ast_410.Parsetree.ptyext_params;\n Ast_410.Parsetree.ptyext_constructors;\n Ast_410.Parsetree.ptyext_private;\n Ast_410.Parsetree.ptyext_loc;\n Ast_410.Parsetree.ptyext_attributes;\n } ->\n {\n Ast_411.Parsetree.ptyext_path = copy_loc copy_Longident_t ptyext_path;\n Ast_411.Parsetree.ptyext_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptyext_params;\n Ast_411.Parsetree.ptyext_constructors =\n List.map copy_extension_constructor ptyext_constructors;\n Ast_411.Parsetree.ptyext_private = copy_private_flag ptyext_private;\n Ast_411.Parsetree.ptyext_loc = copy_location ptyext_loc;\n Ast_411.Parsetree.ptyext_attributes = copy_attributes ptyext_attributes;\n }\n\nand copy_extension_constructor :\n Ast_410.Parsetree.extension_constructor ->\n Ast_411.Parsetree.extension_constructor =\n fun {\n Ast_410.Parsetree.pext_name;\n Ast_410.Parsetree.pext_kind;\n Ast_410.Parsetree.pext_loc;\n Ast_410.Parsetree.pext_attributes;\n } ->\n {\n Ast_411.Parsetree.pext_name = copy_loc (fun x -> x) pext_name;\n Ast_411.Parsetree.pext_kind = copy_extension_constructor_kind pext_kind;\n Ast_411.Parsetree.pext_loc = copy_location pext_loc;\n Ast_411.Parsetree.pext_attributes = copy_attributes pext_attributes;\n }\n\nand copy_extension_constructor_kind :\n Ast_410.Parsetree.extension_constructor_kind ->\n Ast_411.Parsetree.extension_constructor_kind = function\n | Ast_410.Parsetree.Pext_decl (x0, x1) ->\n Ast_411.Parsetree.Pext_decl\n (copy_constructor_arguments x0, Option.map copy_core_type x1)\n | Ast_410.Parsetree.Pext_rebind x0 ->\n Ast_411.Parsetree.Pext_rebind (copy_loc copy_Longident_t x0)\n\nand copy_type_declaration :\n Ast_410.Parsetree.type_declaration -> Ast_411.Parsetree.type_declaration =\n fun {\n Ast_410.Parsetree.ptype_name;\n Ast_410.Parsetree.ptype_params;\n Ast_410.Parsetree.ptype_cstrs;\n Ast_410.Parsetree.ptype_kind;\n Ast_410.Parsetree.ptype_private;\n Ast_410.Parsetree.ptype_manifest;\n Ast_410.Parsetree.ptype_attributes;\n Ast_410.Parsetree.ptype_loc;\n } ->\n {\n Ast_411.Parsetree.ptype_name = copy_loc (fun x -> x) ptype_name;\n Ast_411.Parsetree.ptype_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptype_params;\n Ast_411.Parsetree.ptype_cstrs =\n List.map\n (fun x ->\n let x0, x1, x2 = x in\n (copy_core_type x0, copy_core_type x1, copy_location x2))\n ptype_cstrs;\n Ast_411.Parsetree.ptype_kind = copy_type_kind ptype_kind;\n Ast_411.Parsetree.ptype_private = copy_private_flag ptype_private;\n Ast_411.Parsetree.ptype_manifest = Option.map copy_core_type ptype_manifest;\n Ast_411.Parsetree.ptype_attributes = copy_attributes ptype_attributes;\n Ast_411.Parsetree.ptype_loc = copy_location ptype_loc;\n }\n\nand copy_private_flag :\n Ast_410.Asttypes.private_flag -> Ast_411.Asttypes.private_flag = function\n | Ast_410.Asttypes.Private -> Ast_411.Asttypes.Private\n | Ast_410.Asttypes.Public -> Ast_411.Asttypes.Public\n\nand copy_type_kind : Ast_410.Parsetree.type_kind -> Ast_411.Parsetree.type_kind\n = function\n | Ast_410.Parsetree.Ptype_abstract -> Ast_411.Parsetree.Ptype_abstract\n | Ast_410.Parsetree.Ptype_variant x0 ->\n Ast_411.Parsetree.Ptype_variant (List.map copy_constructor_declaration x0)\n | Ast_410.Parsetree.Ptype_record x0 ->\n Ast_411.Parsetree.Ptype_record (List.map copy_label_declaration x0)\n | Ast_410.Parsetree.Ptype_open -> Ast_411.Parsetree.Ptype_open\n\nand copy_constructor_declaration :\n Ast_410.Parsetree.constructor_declaration ->\n Ast_411.Parsetree.constructor_declaration =\n fun {\n Ast_410.Parsetree.pcd_name;\n Ast_410.Parsetree.pcd_args;\n Ast_410.Parsetree.pcd_res;\n Ast_410.Parsetree.pcd_loc;\n Ast_410.Parsetree.pcd_attributes;\n } ->\n {\n Ast_411.Parsetree.pcd_name = copy_loc (fun x -> x) pcd_name;\n Ast_411.Parsetree.pcd_args = copy_constructor_arguments pcd_args;\n Ast_411.Parsetree.pcd_res = Option.map copy_core_type pcd_res;\n Ast_411.Parsetree.pcd_loc = copy_location pcd_loc;\n Ast_411.Parsetree.pcd_attributes = copy_attributes pcd_attributes;\n }\n\nand copy_constructor_arguments :\n Ast_410.Parsetree.constructor_arguments ->\n Ast_411.Parsetree.constructor_arguments = function\n | Ast_410.Parsetree.Pcstr_tuple x0 ->\n Ast_411.Parsetree.Pcstr_tuple (List.map copy_core_type x0)\n | Ast_410.Parsetree.Pcstr_record x0 ->\n Ast_411.Parsetree.Pcstr_record (List.map copy_label_declaration x0)\n\nand copy_label_declaration :\n Ast_410.Parsetree.label_declaration -> Ast_411.Parsetree.label_declaration =\n fun {\n Ast_410.Parsetree.pld_name;\n Ast_410.Parsetree.pld_mutable;\n Ast_410.Parsetree.pld_type;\n Ast_410.Parsetree.pld_loc;\n Ast_410.Parsetree.pld_attributes;\n } ->\n {\n Ast_411.Parsetree.pld_name = copy_loc (fun x -> x) pld_name;\n Ast_411.Parsetree.pld_mutable = copy_mutable_flag pld_mutable;\n Ast_411.Parsetree.pld_type = copy_core_type pld_type;\n Ast_411.Parsetree.pld_loc = copy_location pld_loc;\n Ast_411.Parsetree.pld_attributes = copy_attributes pld_attributes;\n }\n\nand copy_mutable_flag :\n Ast_410.Asttypes.mutable_flag -> Ast_411.Asttypes.mutable_flag = function\n | Ast_410.Asttypes.Immutable -> Ast_411.Asttypes.Immutable\n | Ast_410.Asttypes.Mutable -> Ast_411.Asttypes.Mutable\n\nand copy_variance : Ast_410.Asttypes.variance -> Ast_411.Asttypes.variance =\n function\n | Ast_410.Asttypes.Covariant -> Ast_411.Asttypes.Covariant\n | Ast_410.Asttypes.Contravariant -> Ast_411.Asttypes.Contravariant\n | Ast_410.Asttypes.Invariant -> Ast_411.Asttypes.Invariant\n\nand copy_value_description :\n Ast_410.Parsetree.value_description -> Ast_411.Parsetree.value_description =\n fun {\n Ast_410.Parsetree.pval_name;\n Ast_410.Parsetree.pval_type;\n Ast_410.Parsetree.pval_prim;\n Ast_410.Parsetree.pval_attributes;\n Ast_410.Parsetree.pval_loc;\n } ->\n {\n Ast_411.Parsetree.pval_name = copy_loc (fun x -> x) pval_name;\n Ast_411.Parsetree.pval_type = copy_core_type pval_type;\n Ast_411.Parsetree.pval_prim = List.map (fun x -> x) pval_prim;\n Ast_411.Parsetree.pval_attributes = copy_attributes pval_attributes;\n Ast_411.Parsetree.pval_loc = copy_location pval_loc;\n }\n\nand copy_object_field_desc :\n Ast_410.Parsetree.object_field_desc -> Ast_411.Parsetree.object_field_desc =\n function\n | Ast_410.Parsetree.Otag (x0, x1) ->\n Ast_411.Parsetree.Otag (copy_loc copy_label x0, copy_core_type x1)\n | Ast_410.Parsetree.Oinherit x0 ->\n Ast_411.Parsetree.Oinherit (copy_core_type x0)\n\nand copy_arg_label : Ast_410.Asttypes.arg_label -> Ast_411.Asttypes.arg_label =\n function\n | Ast_410.Asttypes.Nolabel -> Ast_411.Asttypes.Nolabel\n | Ast_410.Asttypes.Labelled x0 -> Ast_411.Asttypes.Labelled x0\n | Ast_410.Asttypes.Optional x0 -> Ast_411.Asttypes.Optional x0\n\nand copy_closed_flag :\n Ast_410.Asttypes.closed_flag -> Ast_411.Asttypes.closed_flag = function\n | Ast_410.Asttypes.Closed -> Ast_411.Asttypes.Closed\n | Ast_410.Asttypes.Open -> Ast_411.Asttypes.Open\n\nand copy_label : Ast_410.Asttypes.label -> Ast_411.Asttypes.label = fun x -> x\n\nand copy_rec_flag : Ast_410.Asttypes.rec_flag -> Ast_411.Asttypes.rec_flag =\n function\n | Ast_410.Asttypes.Nonrecursive -> Ast_411.Asttypes.Nonrecursive\n | Ast_410.Asttypes.Recursive -> Ast_411.Asttypes.Recursive\n\nand copy_constant : Ast_410.Parsetree.constant -> Ast_411.Parsetree.constant =\n function\n | Ast_410.Parsetree.Pconst_integer (x0, x1) ->\n Ast_411.Parsetree.Pconst_integer (x0, Option.map (fun x -> x) x1)\n | Ast_410.Parsetree.Pconst_char x0 -> Ast_411.Parsetree.Pconst_char x0\n | Ast_410.Parsetree.Pconst_string (x0, x1) ->\n Ast_411.Parsetree.Pconst_string\n (x0, Location.none, Option.map (fun x -> x) x1)\n | Ast_410.Parsetree.Pconst_float (x0, x1) ->\n Ast_411.Parsetree.Pconst_float (x0, Option.map (fun x -> x) x1)\n\nand copy_Longident_t : Longident.t -> Longident.t = fun x -> x\n\nand copy_loc :\n 'f0 'g0.\n ('f0 -> 'g0) -> 'f0 Ast_410.Asttypes.loc -> 'g0 Ast_411.Asttypes.loc =\n fun f0 { Ast_410.Asttypes.txt; Ast_410.Asttypes.loc } ->\n { Ast_411.Asttypes.txt = f0 txt; Ast_411.Asttypes.loc = copy_location loc }\n\nand copy_location : Location.t -> Location.t = fun x -> x\n","module From = Ast_410\nmodule To = Ast_409\n\nlet migration_error loc missing_feature =\n Location.raise_errorf ~loc\n \"migration error: %s is not supported before OCaml 4.10\" missing_feature\n\nlet map_option f x = match x with None -> None | Some x -> Some (f x)\n\nlet rec copy_toplevel_phrase :\n Ast_410.Parsetree.toplevel_phrase -> Ast_409.Parsetree.toplevel_phrase =\n function\n | Ast_410.Parsetree.Ptop_def x0 ->\n Ast_409.Parsetree.Ptop_def (copy_structure x0)\n | Ast_410.Parsetree.Ptop_dir x0 ->\n Ast_409.Parsetree.Ptop_dir (copy_toplevel_directive x0)\n\nand copy_toplevel_directive :\n Ast_410.Parsetree.toplevel_directive -> Ast_409.Parsetree.toplevel_directive\n =\n fun {\n Ast_410.Parsetree.pdir_name;\n Ast_410.Parsetree.pdir_arg;\n Ast_410.Parsetree.pdir_loc;\n } ->\n {\n Ast_409.Parsetree.pdir_name = copy_loc (fun x -> x) pdir_name;\n Ast_409.Parsetree.pdir_arg = map_option copy_directive_argument pdir_arg;\n Ast_409.Parsetree.pdir_loc = copy_location pdir_loc;\n }\n\nand copy_directive_argument :\n Ast_410.Parsetree.directive_argument -> Ast_409.Parsetree.directive_argument\n =\n fun { Ast_410.Parsetree.pdira_desc; Ast_410.Parsetree.pdira_loc } ->\n {\n Ast_409.Parsetree.pdira_desc = copy_directive_argument_desc pdira_desc;\n Ast_409.Parsetree.pdira_loc = copy_location pdira_loc;\n }\n\nand copy_directive_argument_desc :\n Ast_410.Parsetree.directive_argument_desc ->\n Ast_409.Parsetree.directive_argument_desc = function\n | Ast_410.Parsetree.Pdir_string x0 -> Ast_409.Parsetree.Pdir_string x0\n | Ast_410.Parsetree.Pdir_int (x0, x1) ->\n Ast_409.Parsetree.Pdir_int (x0, map_option (fun x -> x) x1)\n | Ast_410.Parsetree.Pdir_ident x0 ->\n Ast_409.Parsetree.Pdir_ident (copy_Longident_t x0)\n | Ast_410.Parsetree.Pdir_bool x0 -> Ast_409.Parsetree.Pdir_bool x0\n\nand copy_expression :\n Ast_410.Parsetree.expression -> Ast_409.Parsetree.expression =\n fun {\n Ast_410.Parsetree.pexp_desc;\n Ast_410.Parsetree.pexp_loc;\n Ast_410.Parsetree.pexp_loc_stack;\n Ast_410.Parsetree.pexp_attributes;\n } ->\n {\n Ast_409.Parsetree.pexp_desc = copy_expression_desc pexp_desc;\n Ast_409.Parsetree.pexp_loc = copy_location pexp_loc;\n Ast_409.Parsetree.pexp_loc_stack = copy_location_stack pexp_loc_stack;\n Ast_409.Parsetree.pexp_attributes = copy_attributes pexp_attributes;\n }\n\nand copy_expression_desc :\n Ast_410.Parsetree.expression_desc -> Ast_409.Parsetree.expression_desc =\n function\n | Ast_410.Parsetree.Pexp_ident x0 ->\n Ast_409.Parsetree.Pexp_ident (copy_loc copy_Longident_t x0)\n | Ast_410.Parsetree.Pexp_constant x0 ->\n Ast_409.Parsetree.Pexp_constant (copy_constant x0)\n | Ast_410.Parsetree.Pexp_let (x0, x1, x2) ->\n Ast_409.Parsetree.Pexp_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_expression x2)\n | Ast_410.Parsetree.Pexp_function x0 ->\n Ast_409.Parsetree.Pexp_function (List.map copy_case x0)\n | Ast_410.Parsetree.Pexp_fun (x0, x1, x2, x3) ->\n Ast_409.Parsetree.Pexp_fun\n ( copy_arg_label x0,\n map_option copy_expression x1,\n copy_pattern x2,\n copy_expression x3 )\n | Ast_410.Parsetree.Pexp_apply (x0, x1) ->\n Ast_409.Parsetree.Pexp_apply\n ( copy_expression x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | Ast_410.Parsetree.Pexp_match (x0, x1) ->\n Ast_409.Parsetree.Pexp_match (copy_expression x0, List.map copy_case x1)\n | Ast_410.Parsetree.Pexp_try (x0, x1) ->\n Ast_409.Parsetree.Pexp_try (copy_expression x0, List.map copy_case x1)\n | Ast_410.Parsetree.Pexp_tuple x0 ->\n Ast_409.Parsetree.Pexp_tuple (List.map copy_expression x0)\n | Ast_410.Parsetree.Pexp_construct (x0, x1) ->\n Ast_409.Parsetree.Pexp_construct\n (copy_loc copy_Longident_t x0, map_option copy_expression x1)\n | Ast_410.Parsetree.Pexp_variant (x0, x1) ->\n Ast_409.Parsetree.Pexp_variant\n (copy_label x0, map_option copy_expression x1)\n | Ast_410.Parsetree.Pexp_record (x0, x1) ->\n Ast_409.Parsetree.Pexp_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_expression x1))\n x0,\n map_option copy_expression x1 )\n | Ast_410.Parsetree.Pexp_field (x0, x1) ->\n Ast_409.Parsetree.Pexp_field\n (copy_expression x0, copy_loc copy_Longident_t x1)\n | Ast_410.Parsetree.Pexp_setfield (x0, x1, x2) ->\n Ast_409.Parsetree.Pexp_setfield\n (copy_expression x0, copy_loc copy_Longident_t x1, copy_expression x2)\n | Ast_410.Parsetree.Pexp_array x0 ->\n Ast_409.Parsetree.Pexp_array (List.map copy_expression x0)\n | Ast_410.Parsetree.Pexp_ifthenelse (x0, x1, x2) ->\n Ast_409.Parsetree.Pexp_ifthenelse\n (copy_expression x0, copy_expression x1, map_option copy_expression x2)\n | Ast_410.Parsetree.Pexp_sequence (x0, x1) ->\n Ast_409.Parsetree.Pexp_sequence (copy_expression x0, copy_expression x1)\n | Ast_410.Parsetree.Pexp_while (x0, x1) ->\n Ast_409.Parsetree.Pexp_while (copy_expression x0, copy_expression x1)\n | Ast_410.Parsetree.Pexp_for (x0, x1, x2, x3, x4) ->\n Ast_409.Parsetree.Pexp_for\n ( copy_pattern x0,\n copy_expression x1,\n copy_expression x2,\n copy_direction_flag x3,\n copy_expression x4 )\n | Ast_410.Parsetree.Pexp_constraint (x0, x1) ->\n Ast_409.Parsetree.Pexp_constraint (copy_expression x0, copy_core_type x1)\n | Ast_410.Parsetree.Pexp_coerce (x0, x1, x2) ->\n Ast_409.Parsetree.Pexp_coerce\n (copy_expression x0, map_option copy_core_type x1, copy_core_type x2)\n | Ast_410.Parsetree.Pexp_send (x0, x1) ->\n Ast_409.Parsetree.Pexp_send (copy_expression x0, copy_loc copy_label x1)\n | Ast_410.Parsetree.Pexp_new x0 ->\n Ast_409.Parsetree.Pexp_new (copy_loc copy_Longident_t x0)\n | Ast_410.Parsetree.Pexp_setinstvar (x0, x1) ->\n Ast_409.Parsetree.Pexp_setinstvar\n (copy_loc copy_label x0, copy_expression x1)\n | Ast_410.Parsetree.Pexp_override x0 ->\n Ast_409.Parsetree.Pexp_override\n (List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_label x0, copy_expression x1))\n x0)\n | Ast_410.Parsetree.Pexp_letmodule (x0, x1, x2) ->\n Ast_409.Parsetree.Pexp_letmodule\n ( copy_loc\n (function\n | None -> migration_error x0.loc \"anonymous let module\"\n | Some x -> x)\n x0,\n copy_module_expr x1,\n copy_expression x2 )\n | Ast_410.Parsetree.Pexp_letexception (x0, x1) ->\n Ast_409.Parsetree.Pexp_letexception\n (copy_extension_constructor x0, copy_expression x1)\n | Ast_410.Parsetree.Pexp_assert x0 ->\n Ast_409.Parsetree.Pexp_assert (copy_expression x0)\n | Ast_410.Parsetree.Pexp_lazy x0 ->\n Ast_409.Parsetree.Pexp_lazy (copy_expression x0)\n | Ast_410.Parsetree.Pexp_poly (x0, x1) ->\n Ast_409.Parsetree.Pexp_poly\n (copy_expression x0, map_option copy_core_type x1)\n | Ast_410.Parsetree.Pexp_object x0 ->\n Ast_409.Parsetree.Pexp_object (copy_class_structure x0)\n | Ast_410.Parsetree.Pexp_newtype (x0, x1) ->\n Ast_409.Parsetree.Pexp_newtype\n (copy_loc (fun x -> x) x0, copy_expression x1)\n | Ast_410.Parsetree.Pexp_pack x0 ->\n Ast_409.Parsetree.Pexp_pack (copy_module_expr x0)\n | Ast_410.Parsetree.Pexp_open (x0, x1) ->\n Ast_409.Parsetree.Pexp_open (copy_open_declaration x0, copy_expression x1)\n | Ast_410.Parsetree.Pexp_letop x0 ->\n Ast_409.Parsetree.Pexp_letop (copy_letop x0)\n | Ast_410.Parsetree.Pexp_extension x0 ->\n Ast_409.Parsetree.Pexp_extension (copy_extension x0)\n | Ast_410.Parsetree.Pexp_unreachable -> Ast_409.Parsetree.Pexp_unreachable\n\nand copy_letop : Ast_410.Parsetree.letop -> Ast_409.Parsetree.letop =\n fun { Ast_410.Parsetree.let_; Ast_410.Parsetree.ands; Ast_410.Parsetree.body } ->\n {\n Ast_409.Parsetree.let_ = copy_binding_op let_;\n Ast_409.Parsetree.ands = List.map copy_binding_op ands;\n Ast_409.Parsetree.body = copy_expression body;\n }\n\nand copy_binding_op :\n Ast_410.Parsetree.binding_op -> Ast_409.Parsetree.binding_op =\n fun {\n Ast_410.Parsetree.pbop_op;\n Ast_410.Parsetree.pbop_pat;\n Ast_410.Parsetree.pbop_exp;\n Ast_410.Parsetree.pbop_loc;\n } ->\n {\n Ast_409.Parsetree.pbop_op = copy_loc (fun x -> x) pbop_op;\n Ast_409.Parsetree.pbop_pat = copy_pattern pbop_pat;\n Ast_409.Parsetree.pbop_exp = copy_expression pbop_exp;\n Ast_409.Parsetree.pbop_loc = copy_location pbop_loc;\n }\n\nand copy_direction_flag :\n Ast_410.Asttypes.direction_flag -> Ast_409.Asttypes.direction_flag =\n function\n | Ast_410.Asttypes.Upto -> Ast_409.Asttypes.Upto\n | Ast_410.Asttypes.Downto -> Ast_409.Asttypes.Downto\n\nand copy_case : Ast_410.Parsetree.case -> Ast_409.Parsetree.case =\n fun {\n Ast_410.Parsetree.pc_lhs;\n Ast_410.Parsetree.pc_guard;\n Ast_410.Parsetree.pc_rhs;\n } ->\n {\n Ast_409.Parsetree.pc_lhs = copy_pattern pc_lhs;\n Ast_409.Parsetree.pc_guard = map_option copy_expression pc_guard;\n Ast_409.Parsetree.pc_rhs = copy_expression pc_rhs;\n }\n\nand copy_cases : Ast_410.Parsetree.case list -> Ast_409.Parsetree.cases =\n fun x -> List.map copy_case x\n\nand copy_value_binding :\n Ast_410.Parsetree.value_binding -> Ast_409.Parsetree.value_binding =\n fun {\n Ast_410.Parsetree.pvb_pat;\n Ast_410.Parsetree.pvb_expr;\n Ast_410.Parsetree.pvb_attributes;\n Ast_410.Parsetree.pvb_loc;\n } ->\n {\n Ast_409.Parsetree.pvb_pat = copy_pattern pvb_pat;\n Ast_409.Parsetree.pvb_expr = copy_expression pvb_expr;\n Ast_409.Parsetree.pvb_attributes = copy_attributes pvb_attributes;\n Ast_409.Parsetree.pvb_loc = copy_location pvb_loc;\n }\n\nand copy_pattern : Ast_410.Parsetree.pattern -> Ast_409.Parsetree.pattern =\n fun {\n Ast_410.Parsetree.ppat_desc;\n Ast_410.Parsetree.ppat_loc;\n Ast_410.Parsetree.ppat_loc_stack;\n Ast_410.Parsetree.ppat_attributes;\n } ->\n {\n Ast_409.Parsetree.ppat_desc = copy_pattern_desc ppat_desc;\n Ast_409.Parsetree.ppat_loc = copy_location ppat_loc;\n Ast_409.Parsetree.ppat_loc_stack = copy_location_stack ppat_loc_stack;\n Ast_409.Parsetree.ppat_attributes = copy_attributes ppat_attributes;\n }\n\nand copy_pattern_desc :\n Ast_410.Parsetree.pattern_desc -> Ast_409.Parsetree.pattern_desc = function\n | Ast_410.Parsetree.Ppat_any -> Ast_409.Parsetree.Ppat_any\n | Ast_410.Parsetree.Ppat_var x0 ->\n Ast_409.Parsetree.Ppat_var (copy_loc (fun x -> x) x0)\n | Ast_410.Parsetree.Ppat_alias (x0, x1) ->\n Ast_409.Parsetree.Ppat_alias (copy_pattern x0, copy_loc (fun x -> x) x1)\n | Ast_410.Parsetree.Ppat_constant x0 ->\n Ast_409.Parsetree.Ppat_constant (copy_constant x0)\n | Ast_410.Parsetree.Ppat_interval (x0, x1) ->\n Ast_409.Parsetree.Ppat_interval (copy_constant x0, copy_constant x1)\n | Ast_410.Parsetree.Ppat_tuple x0 ->\n Ast_409.Parsetree.Ppat_tuple (List.map copy_pattern x0)\n | Ast_410.Parsetree.Ppat_construct (x0, x1) ->\n Ast_409.Parsetree.Ppat_construct\n (copy_loc copy_Longident_t x0, map_option copy_pattern x1)\n | Ast_410.Parsetree.Ppat_variant (x0, x1) ->\n Ast_409.Parsetree.Ppat_variant (copy_label x0, map_option copy_pattern x1)\n | Ast_410.Parsetree.Ppat_record (x0, x1) ->\n Ast_409.Parsetree.Ppat_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_pattern x1))\n x0,\n copy_closed_flag x1 )\n | Ast_410.Parsetree.Ppat_array x0 ->\n Ast_409.Parsetree.Ppat_array (List.map copy_pattern x0)\n | Ast_410.Parsetree.Ppat_or (x0, x1) ->\n Ast_409.Parsetree.Ppat_or (copy_pattern x0, copy_pattern x1)\n | Ast_410.Parsetree.Ppat_constraint (x0, x1) ->\n Ast_409.Parsetree.Ppat_constraint (copy_pattern x0, copy_core_type x1)\n | Ast_410.Parsetree.Ppat_type x0 ->\n Ast_409.Parsetree.Ppat_type (copy_loc copy_Longident_t x0)\n | Ast_410.Parsetree.Ppat_lazy x0 ->\n Ast_409.Parsetree.Ppat_lazy (copy_pattern x0)\n | Ast_410.Parsetree.Ppat_unpack x0 ->\n Ast_409.Parsetree.Ppat_unpack\n (copy_loc\n (function\n | None -> migration_error x0.loc \"anynymous unpack\" | Some x -> x)\n x0)\n | Ast_410.Parsetree.Ppat_exception x0 ->\n Ast_409.Parsetree.Ppat_exception (copy_pattern x0)\n | Ast_410.Parsetree.Ppat_extension x0 ->\n Ast_409.Parsetree.Ppat_extension (copy_extension x0)\n | Ast_410.Parsetree.Ppat_open (x0, x1) ->\n Ast_409.Parsetree.Ppat_open (copy_loc copy_Longident_t x0, copy_pattern x1)\n\nand copy_core_type : Ast_410.Parsetree.core_type -> Ast_409.Parsetree.core_type\n =\n fun {\n Ast_410.Parsetree.ptyp_desc;\n Ast_410.Parsetree.ptyp_loc;\n Ast_410.Parsetree.ptyp_loc_stack;\n Ast_410.Parsetree.ptyp_attributes;\n } ->\n {\n Ast_409.Parsetree.ptyp_desc = copy_core_type_desc ptyp_desc;\n Ast_409.Parsetree.ptyp_loc = copy_location ptyp_loc;\n Ast_409.Parsetree.ptyp_loc_stack = copy_location_stack ptyp_loc_stack;\n Ast_409.Parsetree.ptyp_attributes = copy_attributes ptyp_attributes;\n }\n\nand copy_location_stack : Ast_410.Parsetree.location_stack -> Location.t list =\n fun x -> List.map copy_location x\n\nand copy_core_type_desc :\n Ast_410.Parsetree.core_type_desc -> Ast_409.Parsetree.core_type_desc =\n function\n | Ast_410.Parsetree.Ptyp_any -> Ast_409.Parsetree.Ptyp_any\n | Ast_410.Parsetree.Ptyp_var x0 -> Ast_409.Parsetree.Ptyp_var x0\n | Ast_410.Parsetree.Ptyp_arrow (x0, x1, x2) ->\n Ast_409.Parsetree.Ptyp_arrow\n (copy_arg_label x0, copy_core_type x1, copy_core_type x2)\n | Ast_410.Parsetree.Ptyp_tuple x0 ->\n Ast_409.Parsetree.Ptyp_tuple (List.map copy_core_type x0)\n | Ast_410.Parsetree.Ptyp_constr (x0, x1) ->\n Ast_409.Parsetree.Ptyp_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_410.Parsetree.Ptyp_object (x0, x1) ->\n Ast_409.Parsetree.Ptyp_object\n (List.map copy_object_field x0, copy_closed_flag x1)\n | Ast_410.Parsetree.Ptyp_class (x0, x1) ->\n Ast_409.Parsetree.Ptyp_class\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_410.Parsetree.Ptyp_alias (x0, x1) ->\n Ast_409.Parsetree.Ptyp_alias (copy_core_type x0, x1)\n | Ast_410.Parsetree.Ptyp_variant (x0, x1, x2) ->\n Ast_409.Parsetree.Ptyp_variant\n ( List.map copy_row_field x0,\n copy_closed_flag x1,\n map_option (fun x -> List.map copy_label x) x2 )\n | Ast_410.Parsetree.Ptyp_poly (x0, x1) ->\n Ast_409.Parsetree.Ptyp_poly\n (List.map (fun x -> copy_loc (fun x -> x) x) x0, copy_core_type x1)\n | Ast_410.Parsetree.Ptyp_package x0 ->\n Ast_409.Parsetree.Ptyp_package (copy_package_type x0)\n | Ast_410.Parsetree.Ptyp_extension x0 ->\n Ast_409.Parsetree.Ptyp_extension (copy_extension x0)\n\nand copy_package_type :\n Ast_410.Parsetree.package_type -> Ast_409.Parsetree.package_type =\n fun x ->\n let x0, x1 = x in\n ( copy_loc copy_Longident_t x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_core_type x1))\n x1 )\n\nand copy_row_field : Ast_410.Parsetree.row_field -> Ast_409.Parsetree.row_field\n =\n fun {\n Ast_410.Parsetree.prf_desc;\n Ast_410.Parsetree.prf_loc;\n Ast_410.Parsetree.prf_attributes;\n } ->\n {\n Ast_409.Parsetree.prf_desc = copy_row_field_desc prf_desc;\n Ast_409.Parsetree.prf_loc = copy_location prf_loc;\n Ast_409.Parsetree.prf_attributes = copy_attributes prf_attributes;\n }\n\nand copy_row_field_desc :\n Ast_410.Parsetree.row_field_desc -> Ast_409.Parsetree.row_field_desc =\n function\n | Ast_410.Parsetree.Rtag (x0, x1, x2) ->\n Ast_409.Parsetree.Rtag\n (copy_loc copy_label x0, x1, List.map copy_core_type x2)\n | Ast_410.Parsetree.Rinherit x0 ->\n Ast_409.Parsetree.Rinherit (copy_core_type x0)\n\nand copy_object_field :\n Ast_410.Parsetree.object_field -> Ast_409.Parsetree.object_field =\n fun {\n Ast_410.Parsetree.pof_desc;\n Ast_410.Parsetree.pof_loc;\n Ast_410.Parsetree.pof_attributes;\n } ->\n {\n Ast_409.Parsetree.pof_desc = copy_object_field_desc pof_desc;\n Ast_409.Parsetree.pof_loc = copy_location pof_loc;\n Ast_409.Parsetree.pof_attributes = copy_attributes pof_attributes;\n }\n\nand copy_attributes :\n Ast_410.Parsetree.attributes -> Ast_409.Parsetree.attributes =\n fun x -> List.map copy_attribute x\n\nand copy_attribute : Ast_410.Parsetree.attribute -> Ast_409.Parsetree.attribute\n =\n fun {\n Ast_410.Parsetree.attr_name;\n Ast_410.Parsetree.attr_payload;\n Ast_410.Parsetree.attr_loc;\n } ->\n {\n Ast_409.Parsetree.attr_name = copy_loc (fun x -> x) attr_name;\n Ast_409.Parsetree.attr_payload = copy_payload attr_payload;\n Ast_409.Parsetree.attr_loc = copy_location attr_loc;\n }\n\nand copy_payload : Ast_410.Parsetree.payload -> Ast_409.Parsetree.payload =\n function\n | Ast_410.Parsetree.PStr x0 -> Ast_409.Parsetree.PStr (copy_structure x0)\n | Ast_410.Parsetree.PSig x0 -> Ast_409.Parsetree.PSig (copy_signature x0)\n | Ast_410.Parsetree.PTyp x0 -> Ast_409.Parsetree.PTyp (copy_core_type x0)\n | Ast_410.Parsetree.PPat (x0, x1) ->\n Ast_409.Parsetree.PPat (copy_pattern x0, map_option copy_expression x1)\n\nand copy_structure : Ast_410.Parsetree.structure -> Ast_409.Parsetree.structure\n =\n fun x -> List.map copy_structure_item x\n\nand copy_structure_item :\n Ast_410.Parsetree.structure_item -> Ast_409.Parsetree.structure_item =\n fun { Ast_410.Parsetree.pstr_desc; Ast_410.Parsetree.pstr_loc } ->\n {\n Ast_409.Parsetree.pstr_desc = copy_structure_item_desc pstr_desc;\n Ast_409.Parsetree.pstr_loc = copy_location pstr_loc;\n }\n\nand copy_structure_item_desc :\n Ast_410.Parsetree.structure_item_desc ->\n Ast_409.Parsetree.structure_item_desc = function\n | Ast_410.Parsetree.Pstr_eval (x0, x1) ->\n Ast_409.Parsetree.Pstr_eval (copy_expression x0, copy_attributes x1)\n | Ast_410.Parsetree.Pstr_value (x0, x1) ->\n Ast_409.Parsetree.Pstr_value\n (copy_rec_flag x0, List.map copy_value_binding x1)\n | Ast_410.Parsetree.Pstr_primitive x0 ->\n Ast_409.Parsetree.Pstr_primitive (copy_value_description x0)\n | Ast_410.Parsetree.Pstr_type (x0, x1) ->\n Ast_409.Parsetree.Pstr_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | Ast_410.Parsetree.Pstr_typext x0 ->\n Ast_409.Parsetree.Pstr_typext (copy_type_extension x0)\n | Ast_410.Parsetree.Pstr_exception x0 ->\n Ast_409.Parsetree.Pstr_exception (copy_type_exception x0)\n | Ast_410.Parsetree.Pstr_module x0 ->\n Ast_409.Parsetree.Pstr_module (copy_module_binding x0)\n | Ast_410.Parsetree.Pstr_recmodule x0 ->\n Ast_409.Parsetree.Pstr_recmodule (List.map copy_module_binding x0)\n | Ast_410.Parsetree.Pstr_modtype x0 ->\n Ast_409.Parsetree.Pstr_modtype (copy_module_type_declaration x0)\n | Ast_410.Parsetree.Pstr_open x0 ->\n Ast_409.Parsetree.Pstr_open (copy_open_declaration x0)\n | Ast_410.Parsetree.Pstr_class x0 ->\n Ast_409.Parsetree.Pstr_class (List.map copy_class_declaration x0)\n | Ast_410.Parsetree.Pstr_class_type x0 ->\n Ast_409.Parsetree.Pstr_class_type\n (List.map copy_class_type_declaration x0)\n | Ast_410.Parsetree.Pstr_include x0 ->\n Ast_409.Parsetree.Pstr_include (copy_include_declaration x0)\n | Ast_410.Parsetree.Pstr_attribute x0 ->\n Ast_409.Parsetree.Pstr_attribute (copy_attribute x0)\n | Ast_410.Parsetree.Pstr_extension (x0, x1) ->\n Ast_409.Parsetree.Pstr_extension (copy_extension x0, copy_attributes x1)\n\nand copy_include_declaration :\n Ast_410.Parsetree.include_declaration ->\n Ast_409.Parsetree.include_declaration =\n fun x -> copy_include_infos copy_module_expr x\n\nand copy_class_declaration :\n Ast_410.Parsetree.class_declaration -> Ast_409.Parsetree.class_declaration =\n fun x -> copy_class_infos copy_class_expr x\n\nand copy_class_expr :\n Ast_410.Parsetree.class_expr -> Ast_409.Parsetree.class_expr =\n fun {\n Ast_410.Parsetree.pcl_desc;\n Ast_410.Parsetree.pcl_loc;\n Ast_410.Parsetree.pcl_attributes;\n } ->\n {\n Ast_409.Parsetree.pcl_desc = copy_class_expr_desc pcl_desc;\n Ast_409.Parsetree.pcl_loc = copy_location pcl_loc;\n Ast_409.Parsetree.pcl_attributes = copy_attributes pcl_attributes;\n }\n\nand copy_class_expr_desc :\n Ast_410.Parsetree.class_expr_desc -> Ast_409.Parsetree.class_expr_desc =\n function\n | Ast_410.Parsetree.Pcl_constr (x0, x1) ->\n Ast_409.Parsetree.Pcl_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_410.Parsetree.Pcl_structure x0 ->\n Ast_409.Parsetree.Pcl_structure (copy_class_structure x0)\n | Ast_410.Parsetree.Pcl_fun (x0, x1, x2, x3) ->\n Ast_409.Parsetree.Pcl_fun\n ( copy_arg_label x0,\n map_option copy_expression x1,\n copy_pattern x2,\n copy_class_expr x3 )\n | Ast_410.Parsetree.Pcl_apply (x0, x1) ->\n Ast_409.Parsetree.Pcl_apply\n ( copy_class_expr x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | Ast_410.Parsetree.Pcl_let (x0, x1, x2) ->\n Ast_409.Parsetree.Pcl_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_class_expr x2)\n | Ast_410.Parsetree.Pcl_constraint (x0, x1) ->\n Ast_409.Parsetree.Pcl_constraint (copy_class_expr x0, copy_class_type x1)\n | Ast_410.Parsetree.Pcl_extension x0 ->\n Ast_409.Parsetree.Pcl_extension (copy_extension x0)\n | Ast_410.Parsetree.Pcl_open (x0, x1) ->\n Ast_409.Parsetree.Pcl_open (copy_open_description x0, copy_class_expr x1)\n\nand copy_class_structure :\n Ast_410.Parsetree.class_structure -> Ast_409.Parsetree.class_structure =\n fun { Ast_410.Parsetree.pcstr_self; Ast_410.Parsetree.pcstr_fields } ->\n {\n Ast_409.Parsetree.pcstr_self = copy_pattern pcstr_self;\n Ast_409.Parsetree.pcstr_fields = List.map copy_class_field pcstr_fields;\n }\n\nand copy_class_field :\n Ast_410.Parsetree.class_field -> Ast_409.Parsetree.class_field =\n fun {\n Ast_410.Parsetree.pcf_desc;\n Ast_410.Parsetree.pcf_loc;\n Ast_410.Parsetree.pcf_attributes;\n } ->\n {\n Ast_409.Parsetree.pcf_desc = copy_class_field_desc pcf_desc;\n Ast_409.Parsetree.pcf_loc = copy_location pcf_loc;\n Ast_409.Parsetree.pcf_attributes = copy_attributes pcf_attributes;\n }\n\nand copy_class_field_desc :\n Ast_410.Parsetree.class_field_desc -> Ast_409.Parsetree.class_field_desc =\n function\n | Ast_410.Parsetree.Pcf_inherit (x0, x1, x2) ->\n Ast_409.Parsetree.Pcf_inherit\n ( copy_override_flag x0,\n copy_class_expr x1,\n map_option (fun x -> copy_loc (fun x -> x) x) x2 )\n | Ast_410.Parsetree.Pcf_val x0 ->\n Ast_409.Parsetree.Pcf_val\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_mutable_flag x1, copy_class_field_kind x2))\n | Ast_410.Parsetree.Pcf_method x0 ->\n Ast_409.Parsetree.Pcf_method\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_private_flag x1, copy_class_field_kind x2))\n | Ast_410.Parsetree.Pcf_constraint x0 ->\n Ast_409.Parsetree.Pcf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | Ast_410.Parsetree.Pcf_initializer x0 ->\n Ast_409.Parsetree.Pcf_initializer (copy_expression x0)\n | Ast_410.Parsetree.Pcf_attribute x0 ->\n Ast_409.Parsetree.Pcf_attribute (copy_attribute x0)\n | Ast_410.Parsetree.Pcf_extension x0 ->\n Ast_409.Parsetree.Pcf_extension (copy_extension x0)\n\nand copy_class_field_kind :\n Ast_410.Parsetree.class_field_kind -> Ast_409.Parsetree.class_field_kind =\n function\n | Ast_410.Parsetree.Cfk_virtual x0 ->\n Ast_409.Parsetree.Cfk_virtual (copy_core_type x0)\n | Ast_410.Parsetree.Cfk_concrete (x0, x1) ->\n Ast_409.Parsetree.Cfk_concrete (copy_override_flag x0, copy_expression x1)\n\nand copy_open_declaration :\n Ast_410.Parsetree.open_declaration -> Ast_409.Parsetree.open_declaration =\n fun x -> copy_open_infos copy_module_expr x\n\nand copy_module_binding :\n Ast_410.Parsetree.module_binding -> Ast_409.Parsetree.module_binding =\n fun {\n Ast_410.Parsetree.pmb_name;\n Ast_410.Parsetree.pmb_expr;\n Ast_410.Parsetree.pmb_attributes;\n Ast_410.Parsetree.pmb_loc;\n } ->\n {\n Ast_409.Parsetree.pmb_name =\n copy_loc\n (function\n | Some x -> x\n | None -> migration_error pmb_name.loc \"anonymous module binding\")\n pmb_name;\n Ast_409.Parsetree.pmb_expr = copy_module_expr pmb_expr;\n Ast_409.Parsetree.pmb_attributes = copy_attributes pmb_attributes;\n Ast_409.Parsetree.pmb_loc = copy_location pmb_loc;\n }\n\nand copy_module_expr :\n Ast_410.Parsetree.module_expr -> Ast_409.Parsetree.module_expr =\n fun {\n Ast_410.Parsetree.pmod_desc;\n Ast_410.Parsetree.pmod_loc;\n Ast_410.Parsetree.pmod_attributes;\n } ->\n {\n Ast_409.Parsetree.pmod_desc = copy_module_expr_desc pmod_desc;\n Ast_409.Parsetree.pmod_loc = copy_location pmod_loc;\n Ast_409.Parsetree.pmod_attributes = copy_attributes pmod_attributes;\n }\n\nand copy_module_expr_desc :\n Ast_410.Parsetree.module_expr_desc -> Ast_409.Parsetree.module_expr_desc =\n function\n | Ast_410.Parsetree.Pmod_ident x0 ->\n Ast_409.Parsetree.Pmod_ident (copy_loc copy_Longident_t x0)\n | Ast_410.Parsetree.Pmod_structure x0 ->\n Ast_409.Parsetree.Pmod_structure (copy_structure x0)\n | Ast_410.Parsetree.Pmod_functor (x0, x1) ->\n let x, y = copy_functor_parameter x0 in\n Ast_409.Parsetree.Pmod_functor (x, y, copy_module_expr x1)\n | Ast_410.Parsetree.Pmod_apply (x0, x1) ->\n Ast_409.Parsetree.Pmod_apply (copy_module_expr x0, copy_module_expr x1)\n | Ast_410.Parsetree.Pmod_constraint (x0, x1) ->\n Ast_409.Parsetree.Pmod_constraint\n (copy_module_expr x0, copy_module_type x1)\n | Ast_410.Parsetree.Pmod_unpack x0 ->\n Ast_409.Parsetree.Pmod_unpack (copy_expression x0)\n | Ast_410.Parsetree.Pmod_extension x0 ->\n Ast_409.Parsetree.Pmod_extension (copy_extension x0)\n\nand copy_functor_parameter :\n Ast_410.Parsetree.functor_parameter ->\n string Ast_409.Asttypes.loc * Ast_409.Parsetree.module_type option =\n function\n | Ast_410.Parsetree.Unit -> ({ loc = Location.none; txt = \"*\" }, None)\n | Ast_410.Parsetree.Named (x0, x1) ->\n ( copy_loc (function None -> \"_\" | Some x -> x) x0,\n Some (copy_module_type x1) )\n\nand copy_module_type :\n Ast_410.Parsetree.module_type -> Ast_409.Parsetree.module_type =\n fun {\n Ast_410.Parsetree.pmty_desc;\n Ast_410.Parsetree.pmty_loc;\n Ast_410.Parsetree.pmty_attributes;\n } ->\n {\n Ast_409.Parsetree.pmty_desc = copy_module_type_desc pmty_desc;\n Ast_409.Parsetree.pmty_loc = copy_location pmty_loc;\n Ast_409.Parsetree.pmty_attributes = copy_attributes pmty_attributes;\n }\n\nand copy_module_type_desc :\n Ast_410.Parsetree.module_type_desc -> Ast_409.Parsetree.module_type_desc =\n function\n | Ast_410.Parsetree.Pmty_ident x0 ->\n Ast_409.Parsetree.Pmty_ident (copy_loc copy_Longident_t x0)\n | Ast_410.Parsetree.Pmty_signature x0 ->\n Ast_409.Parsetree.Pmty_signature (copy_signature x0)\n | Ast_410.Parsetree.Pmty_functor (x0, x1) ->\n let x, y = copy_functor_parameter x0 in\n Ast_409.Parsetree.Pmty_functor (x, y, copy_module_type x1)\n | Ast_410.Parsetree.Pmty_with (x0, x1) ->\n Ast_409.Parsetree.Pmty_with\n (copy_module_type x0, List.map copy_with_constraint x1)\n | Ast_410.Parsetree.Pmty_typeof x0 ->\n Ast_409.Parsetree.Pmty_typeof (copy_module_expr x0)\n | Ast_410.Parsetree.Pmty_extension x0 ->\n Ast_409.Parsetree.Pmty_extension (copy_extension x0)\n | Ast_410.Parsetree.Pmty_alias x0 ->\n Ast_409.Parsetree.Pmty_alias (copy_loc copy_Longident_t x0)\n\nand copy_with_constraint :\n Ast_410.Parsetree.with_constraint -> Ast_409.Parsetree.with_constraint =\n function\n | Ast_410.Parsetree.Pwith_type (x0, x1) ->\n Ast_409.Parsetree.Pwith_type\n (copy_loc copy_Longident_t x0, copy_type_declaration x1)\n | Ast_410.Parsetree.Pwith_module (x0, x1) ->\n Ast_409.Parsetree.Pwith_module\n (copy_loc copy_Longident_t x0, copy_loc copy_Longident_t x1)\n | Ast_410.Parsetree.Pwith_typesubst (x0, x1) ->\n Ast_409.Parsetree.Pwith_typesubst\n (copy_loc copy_Longident_t x0, copy_type_declaration x1)\n | Ast_410.Parsetree.Pwith_modsubst (x0, x1) ->\n Ast_409.Parsetree.Pwith_modsubst\n (copy_loc copy_Longident_t x0, copy_loc copy_Longident_t x1)\n\nand copy_signature : Ast_410.Parsetree.signature -> Ast_409.Parsetree.signature\n =\n fun x -> List.map copy_signature_item x\n\nand copy_signature_item :\n Ast_410.Parsetree.signature_item -> Ast_409.Parsetree.signature_item =\n fun { Ast_410.Parsetree.psig_desc; Ast_410.Parsetree.psig_loc } ->\n {\n Ast_409.Parsetree.psig_desc = copy_signature_item_desc psig_desc;\n Ast_409.Parsetree.psig_loc = copy_location psig_loc;\n }\n\nand copy_signature_item_desc :\n Ast_410.Parsetree.signature_item_desc ->\n Ast_409.Parsetree.signature_item_desc = function\n | Ast_410.Parsetree.Psig_value x0 ->\n Ast_409.Parsetree.Psig_value (copy_value_description x0)\n | Ast_410.Parsetree.Psig_type (x0, x1) ->\n Ast_409.Parsetree.Psig_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | Ast_410.Parsetree.Psig_typesubst x0 ->\n Ast_409.Parsetree.Psig_typesubst (List.map copy_type_declaration x0)\n | Ast_410.Parsetree.Psig_typext x0 ->\n Ast_409.Parsetree.Psig_typext (copy_type_extension x0)\n | Ast_410.Parsetree.Psig_exception x0 ->\n Ast_409.Parsetree.Psig_exception (copy_type_exception x0)\n | Ast_410.Parsetree.Psig_module x0 ->\n Ast_409.Parsetree.Psig_module (copy_module_declaration x0)\n | Ast_410.Parsetree.Psig_modsubst x0 ->\n Ast_409.Parsetree.Psig_modsubst (copy_module_substitution x0)\n | Ast_410.Parsetree.Psig_recmodule x0 ->\n Ast_409.Parsetree.Psig_recmodule (List.map copy_module_declaration x0)\n | Ast_410.Parsetree.Psig_modtype x0 ->\n Ast_409.Parsetree.Psig_modtype (copy_module_type_declaration x0)\n | Ast_410.Parsetree.Psig_open x0 ->\n Ast_409.Parsetree.Psig_open (copy_open_description x0)\n | Ast_410.Parsetree.Psig_include x0 ->\n Ast_409.Parsetree.Psig_include (copy_include_description x0)\n | Ast_410.Parsetree.Psig_class x0 ->\n Ast_409.Parsetree.Psig_class (List.map copy_class_description x0)\n | Ast_410.Parsetree.Psig_class_type x0 ->\n Ast_409.Parsetree.Psig_class_type\n (List.map copy_class_type_declaration x0)\n | Ast_410.Parsetree.Psig_attribute x0 ->\n Ast_409.Parsetree.Psig_attribute (copy_attribute x0)\n | Ast_410.Parsetree.Psig_extension (x0, x1) ->\n Ast_409.Parsetree.Psig_extension (copy_extension x0, copy_attributes x1)\n\nand copy_class_type_declaration :\n Ast_410.Parsetree.class_type_declaration ->\n Ast_409.Parsetree.class_type_declaration =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_description :\n Ast_410.Parsetree.class_description -> Ast_409.Parsetree.class_description =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_type :\n Ast_410.Parsetree.class_type -> Ast_409.Parsetree.class_type =\n fun {\n Ast_410.Parsetree.pcty_desc;\n Ast_410.Parsetree.pcty_loc;\n Ast_410.Parsetree.pcty_attributes;\n } ->\n {\n Ast_409.Parsetree.pcty_desc = copy_class_type_desc pcty_desc;\n Ast_409.Parsetree.pcty_loc = copy_location pcty_loc;\n Ast_409.Parsetree.pcty_attributes = copy_attributes pcty_attributes;\n }\n\nand copy_class_type_desc :\n Ast_410.Parsetree.class_type_desc -> Ast_409.Parsetree.class_type_desc =\n function\n | Ast_410.Parsetree.Pcty_constr (x0, x1) ->\n Ast_409.Parsetree.Pcty_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_410.Parsetree.Pcty_signature x0 ->\n Ast_409.Parsetree.Pcty_signature (copy_class_signature x0)\n | Ast_410.Parsetree.Pcty_arrow (x0, x1, x2) ->\n Ast_409.Parsetree.Pcty_arrow\n (copy_arg_label x0, copy_core_type x1, copy_class_type x2)\n | Ast_410.Parsetree.Pcty_extension x0 ->\n Ast_409.Parsetree.Pcty_extension (copy_extension x0)\n | Ast_410.Parsetree.Pcty_open (x0, x1) ->\n Ast_409.Parsetree.Pcty_open (copy_open_description x0, copy_class_type x1)\n\nand copy_class_signature :\n Ast_410.Parsetree.class_signature -> Ast_409.Parsetree.class_signature =\n fun { Ast_410.Parsetree.pcsig_self; Ast_410.Parsetree.pcsig_fields } ->\n {\n Ast_409.Parsetree.pcsig_self = copy_core_type pcsig_self;\n Ast_409.Parsetree.pcsig_fields = List.map copy_class_type_field pcsig_fields;\n }\n\nand copy_class_type_field :\n Ast_410.Parsetree.class_type_field -> Ast_409.Parsetree.class_type_field =\n fun {\n Ast_410.Parsetree.pctf_desc;\n Ast_410.Parsetree.pctf_loc;\n Ast_410.Parsetree.pctf_attributes;\n } ->\n {\n Ast_409.Parsetree.pctf_desc = copy_class_type_field_desc pctf_desc;\n Ast_409.Parsetree.pctf_loc = copy_location pctf_loc;\n Ast_409.Parsetree.pctf_attributes = copy_attributes pctf_attributes;\n }\n\nand copy_class_type_field_desc :\n Ast_410.Parsetree.class_type_field_desc ->\n Ast_409.Parsetree.class_type_field_desc = function\n | Ast_410.Parsetree.Pctf_inherit x0 ->\n Ast_409.Parsetree.Pctf_inherit (copy_class_type x0)\n | Ast_410.Parsetree.Pctf_val x0 ->\n Ast_409.Parsetree.Pctf_val\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_mutable_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | Ast_410.Parsetree.Pctf_method x0 ->\n Ast_409.Parsetree.Pctf_method\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_private_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | Ast_410.Parsetree.Pctf_constraint x0 ->\n Ast_409.Parsetree.Pctf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | Ast_410.Parsetree.Pctf_attribute x0 ->\n Ast_409.Parsetree.Pctf_attribute (copy_attribute x0)\n | Ast_410.Parsetree.Pctf_extension x0 ->\n Ast_409.Parsetree.Pctf_extension (copy_extension x0)\n\nand copy_extension : Ast_410.Parsetree.extension -> Ast_409.Parsetree.extension\n =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_class_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_410.Parsetree.class_infos ->\n 'g0 Ast_409.Parsetree.class_infos =\n fun f0\n {\n Ast_410.Parsetree.pci_virt;\n Ast_410.Parsetree.pci_params;\n Ast_410.Parsetree.pci_name;\n Ast_410.Parsetree.pci_expr;\n Ast_410.Parsetree.pci_loc;\n Ast_410.Parsetree.pci_attributes;\n } ->\n {\n Ast_409.Parsetree.pci_virt = copy_virtual_flag pci_virt;\n Ast_409.Parsetree.pci_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n pci_params;\n Ast_409.Parsetree.pci_name = copy_loc (fun x -> x) pci_name;\n Ast_409.Parsetree.pci_expr = f0 pci_expr;\n Ast_409.Parsetree.pci_loc = copy_location pci_loc;\n Ast_409.Parsetree.pci_attributes = copy_attributes pci_attributes;\n }\n\nand copy_virtual_flag :\n Ast_410.Asttypes.virtual_flag -> Ast_409.Asttypes.virtual_flag = function\n | Ast_410.Asttypes.Virtual -> Ast_409.Asttypes.Virtual\n | Ast_410.Asttypes.Concrete -> Ast_409.Asttypes.Concrete\n\nand copy_include_description :\n Ast_410.Parsetree.include_description ->\n Ast_409.Parsetree.include_description =\n fun x -> copy_include_infos copy_module_type x\n\nand copy_include_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_410.Parsetree.include_infos ->\n 'g0 Ast_409.Parsetree.include_infos =\n fun f0\n {\n Ast_410.Parsetree.pincl_mod;\n Ast_410.Parsetree.pincl_loc;\n Ast_410.Parsetree.pincl_attributes;\n } ->\n {\n Ast_409.Parsetree.pincl_mod = f0 pincl_mod;\n Ast_409.Parsetree.pincl_loc = copy_location pincl_loc;\n Ast_409.Parsetree.pincl_attributes = copy_attributes pincl_attributes;\n }\n\nand copy_open_description :\n Ast_410.Parsetree.open_description -> Ast_409.Parsetree.open_description =\n fun x -> copy_open_infos (fun x -> copy_loc copy_Longident_t x) x\n\nand copy_open_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_410.Parsetree.open_infos ->\n 'g0 Ast_409.Parsetree.open_infos =\n fun f0\n {\n Ast_410.Parsetree.popen_expr;\n Ast_410.Parsetree.popen_override;\n Ast_410.Parsetree.popen_loc;\n Ast_410.Parsetree.popen_attributes;\n } ->\n {\n Ast_409.Parsetree.popen_expr = f0 popen_expr;\n Ast_409.Parsetree.popen_override = copy_override_flag popen_override;\n Ast_409.Parsetree.popen_loc = copy_location popen_loc;\n Ast_409.Parsetree.popen_attributes = copy_attributes popen_attributes;\n }\n\nand copy_override_flag :\n Ast_410.Asttypes.override_flag -> Ast_409.Asttypes.override_flag = function\n | Ast_410.Asttypes.Override -> Ast_409.Asttypes.Override\n | Ast_410.Asttypes.Fresh -> Ast_409.Asttypes.Fresh\n\nand copy_module_type_declaration :\n Ast_410.Parsetree.module_type_declaration ->\n Ast_409.Parsetree.module_type_declaration =\n fun {\n Ast_410.Parsetree.pmtd_name;\n Ast_410.Parsetree.pmtd_type;\n Ast_410.Parsetree.pmtd_attributes;\n Ast_410.Parsetree.pmtd_loc;\n } ->\n {\n Ast_409.Parsetree.pmtd_name = copy_loc (fun x -> x) pmtd_name;\n Ast_409.Parsetree.pmtd_type = map_option copy_module_type pmtd_type;\n Ast_409.Parsetree.pmtd_attributes = copy_attributes pmtd_attributes;\n Ast_409.Parsetree.pmtd_loc = copy_location pmtd_loc;\n }\n\nand copy_module_substitution :\n Ast_410.Parsetree.module_substitution ->\n Ast_409.Parsetree.module_substitution =\n fun {\n Ast_410.Parsetree.pms_name;\n Ast_410.Parsetree.pms_manifest;\n Ast_410.Parsetree.pms_attributes;\n Ast_410.Parsetree.pms_loc;\n } ->\n {\n Ast_409.Parsetree.pms_name = copy_loc (fun x -> x) pms_name;\n Ast_409.Parsetree.pms_manifest = copy_loc copy_Longident_t pms_manifest;\n Ast_409.Parsetree.pms_attributes = copy_attributes pms_attributes;\n Ast_409.Parsetree.pms_loc = copy_location pms_loc;\n }\n\nand copy_module_declaration :\n Ast_410.Parsetree.module_declaration -> Ast_409.Parsetree.module_declaration\n =\n fun {\n Ast_410.Parsetree.pmd_name;\n Ast_410.Parsetree.pmd_type;\n Ast_410.Parsetree.pmd_attributes;\n Ast_410.Parsetree.pmd_loc;\n } ->\n {\n Ast_409.Parsetree.pmd_name =\n copy_loc\n (function\n | None -> migration_error pmd_name.loc \"anonymous module declaration\"\n | Some x -> x)\n pmd_name;\n Ast_409.Parsetree.pmd_type = copy_module_type pmd_type;\n Ast_409.Parsetree.pmd_attributes = copy_attributes pmd_attributes;\n Ast_409.Parsetree.pmd_loc = copy_location pmd_loc;\n }\n\nand copy_type_exception :\n Ast_410.Parsetree.type_exception -> Ast_409.Parsetree.type_exception =\n fun {\n Ast_410.Parsetree.ptyexn_constructor;\n Ast_410.Parsetree.ptyexn_loc;\n Ast_410.Parsetree.ptyexn_attributes;\n } ->\n {\n Ast_409.Parsetree.ptyexn_constructor =\n copy_extension_constructor ptyexn_constructor;\n Ast_409.Parsetree.ptyexn_loc = copy_location ptyexn_loc;\n Ast_409.Parsetree.ptyexn_attributes = copy_attributes ptyexn_attributes;\n }\n\nand copy_type_extension :\n Ast_410.Parsetree.type_extension -> Ast_409.Parsetree.type_extension =\n fun {\n Ast_410.Parsetree.ptyext_path;\n Ast_410.Parsetree.ptyext_params;\n Ast_410.Parsetree.ptyext_constructors;\n Ast_410.Parsetree.ptyext_private;\n Ast_410.Parsetree.ptyext_loc;\n Ast_410.Parsetree.ptyext_attributes;\n } ->\n {\n Ast_409.Parsetree.ptyext_path = copy_loc copy_Longident_t ptyext_path;\n Ast_409.Parsetree.ptyext_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptyext_params;\n Ast_409.Parsetree.ptyext_constructors =\n List.map copy_extension_constructor ptyext_constructors;\n Ast_409.Parsetree.ptyext_private = copy_private_flag ptyext_private;\n Ast_409.Parsetree.ptyext_loc = copy_location ptyext_loc;\n Ast_409.Parsetree.ptyext_attributes = copy_attributes ptyext_attributes;\n }\n\nand copy_extension_constructor :\n Ast_410.Parsetree.extension_constructor ->\n Ast_409.Parsetree.extension_constructor =\n fun {\n Ast_410.Parsetree.pext_name;\n Ast_410.Parsetree.pext_kind;\n Ast_410.Parsetree.pext_loc;\n Ast_410.Parsetree.pext_attributes;\n } ->\n {\n Ast_409.Parsetree.pext_name = copy_loc (fun x -> x) pext_name;\n Ast_409.Parsetree.pext_kind = copy_extension_constructor_kind pext_kind;\n Ast_409.Parsetree.pext_loc = copy_location pext_loc;\n Ast_409.Parsetree.pext_attributes = copy_attributes pext_attributes;\n }\n\nand copy_extension_constructor_kind :\n Ast_410.Parsetree.extension_constructor_kind ->\n Ast_409.Parsetree.extension_constructor_kind = function\n | Ast_410.Parsetree.Pext_decl (x0, x1) ->\n Ast_409.Parsetree.Pext_decl\n (copy_constructor_arguments x0, map_option copy_core_type x1)\n | Ast_410.Parsetree.Pext_rebind x0 ->\n Ast_409.Parsetree.Pext_rebind (copy_loc copy_Longident_t x0)\n\nand copy_type_declaration :\n Ast_410.Parsetree.type_declaration -> Ast_409.Parsetree.type_declaration =\n fun {\n Ast_410.Parsetree.ptype_name;\n Ast_410.Parsetree.ptype_params;\n Ast_410.Parsetree.ptype_cstrs;\n Ast_410.Parsetree.ptype_kind;\n Ast_410.Parsetree.ptype_private;\n Ast_410.Parsetree.ptype_manifest;\n Ast_410.Parsetree.ptype_attributes;\n Ast_410.Parsetree.ptype_loc;\n } ->\n {\n Ast_409.Parsetree.ptype_name = copy_loc (fun x -> x) ptype_name;\n Ast_409.Parsetree.ptype_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptype_params;\n Ast_409.Parsetree.ptype_cstrs =\n List.map\n (fun x ->\n let x0, x1, x2 = x in\n (copy_core_type x0, copy_core_type x1, copy_location x2))\n ptype_cstrs;\n Ast_409.Parsetree.ptype_kind = copy_type_kind ptype_kind;\n Ast_409.Parsetree.ptype_private = copy_private_flag ptype_private;\n Ast_409.Parsetree.ptype_manifest = map_option copy_core_type ptype_manifest;\n Ast_409.Parsetree.ptype_attributes = copy_attributes ptype_attributes;\n Ast_409.Parsetree.ptype_loc = copy_location ptype_loc;\n }\n\nand copy_private_flag :\n Ast_410.Asttypes.private_flag -> Ast_409.Asttypes.private_flag = function\n | Ast_410.Asttypes.Private -> Ast_409.Asttypes.Private\n | Ast_410.Asttypes.Public -> Ast_409.Asttypes.Public\n\nand copy_type_kind : Ast_410.Parsetree.type_kind -> Ast_409.Parsetree.type_kind\n = function\n | Ast_410.Parsetree.Ptype_abstract -> Ast_409.Parsetree.Ptype_abstract\n | Ast_410.Parsetree.Ptype_variant x0 ->\n Ast_409.Parsetree.Ptype_variant (List.map copy_constructor_declaration x0)\n | Ast_410.Parsetree.Ptype_record x0 ->\n Ast_409.Parsetree.Ptype_record (List.map copy_label_declaration x0)\n | Ast_410.Parsetree.Ptype_open -> Ast_409.Parsetree.Ptype_open\n\nand copy_constructor_declaration :\n Ast_410.Parsetree.constructor_declaration ->\n Ast_409.Parsetree.constructor_declaration =\n fun {\n Ast_410.Parsetree.pcd_name;\n Ast_410.Parsetree.pcd_args;\n Ast_410.Parsetree.pcd_res;\n Ast_410.Parsetree.pcd_loc;\n Ast_410.Parsetree.pcd_attributes;\n } ->\n {\n Ast_409.Parsetree.pcd_name = copy_loc (fun x -> x) pcd_name;\n Ast_409.Parsetree.pcd_args = copy_constructor_arguments pcd_args;\n Ast_409.Parsetree.pcd_res = map_option copy_core_type pcd_res;\n Ast_409.Parsetree.pcd_loc = copy_location pcd_loc;\n Ast_409.Parsetree.pcd_attributes = copy_attributes pcd_attributes;\n }\n\nand copy_constructor_arguments :\n Ast_410.Parsetree.constructor_arguments ->\n Ast_409.Parsetree.constructor_arguments = function\n | Ast_410.Parsetree.Pcstr_tuple x0 ->\n Ast_409.Parsetree.Pcstr_tuple (List.map copy_core_type x0)\n | Ast_410.Parsetree.Pcstr_record x0 ->\n Ast_409.Parsetree.Pcstr_record (List.map copy_label_declaration x0)\n\nand copy_label_declaration :\n Ast_410.Parsetree.label_declaration -> Ast_409.Parsetree.label_declaration =\n fun {\n Ast_410.Parsetree.pld_name;\n Ast_410.Parsetree.pld_mutable;\n Ast_410.Parsetree.pld_type;\n Ast_410.Parsetree.pld_loc;\n Ast_410.Parsetree.pld_attributes;\n } ->\n {\n Ast_409.Parsetree.pld_name = copy_loc (fun x -> x) pld_name;\n Ast_409.Parsetree.pld_mutable = copy_mutable_flag pld_mutable;\n Ast_409.Parsetree.pld_type = copy_core_type pld_type;\n Ast_409.Parsetree.pld_loc = copy_location pld_loc;\n Ast_409.Parsetree.pld_attributes = copy_attributes pld_attributes;\n }\n\nand copy_mutable_flag :\n Ast_410.Asttypes.mutable_flag -> Ast_409.Asttypes.mutable_flag = function\n | Ast_410.Asttypes.Immutable -> Ast_409.Asttypes.Immutable\n | Ast_410.Asttypes.Mutable -> Ast_409.Asttypes.Mutable\n\nand copy_variance : Ast_410.Asttypes.variance -> Ast_409.Asttypes.variance =\n function\n | Ast_410.Asttypes.Covariant -> Ast_409.Asttypes.Covariant\n | Ast_410.Asttypes.Contravariant -> Ast_409.Asttypes.Contravariant\n | Ast_410.Asttypes.Invariant -> Ast_409.Asttypes.Invariant\n\nand copy_value_description :\n Ast_410.Parsetree.value_description -> Ast_409.Parsetree.value_description =\n fun {\n Ast_410.Parsetree.pval_name;\n Ast_410.Parsetree.pval_type;\n Ast_410.Parsetree.pval_prim;\n Ast_410.Parsetree.pval_attributes;\n Ast_410.Parsetree.pval_loc;\n } ->\n {\n Ast_409.Parsetree.pval_name = copy_loc (fun x -> x) pval_name;\n Ast_409.Parsetree.pval_type = copy_core_type pval_type;\n Ast_409.Parsetree.pval_prim = List.map (fun x -> x) pval_prim;\n Ast_409.Parsetree.pval_attributes = copy_attributes pval_attributes;\n Ast_409.Parsetree.pval_loc = copy_location pval_loc;\n }\n\nand copy_object_field_desc :\n Ast_410.Parsetree.object_field_desc -> Ast_409.Parsetree.object_field_desc =\n function\n | Ast_410.Parsetree.Otag (x0, x1) ->\n Ast_409.Parsetree.Otag (copy_loc copy_label x0, copy_core_type x1)\n | Ast_410.Parsetree.Oinherit x0 ->\n Ast_409.Parsetree.Oinherit (copy_core_type x0)\n\nand copy_arg_label : Ast_410.Asttypes.arg_label -> Ast_409.Asttypes.arg_label =\n function\n | Ast_410.Asttypes.Nolabel -> Ast_409.Asttypes.Nolabel\n | Ast_410.Asttypes.Labelled x0 -> Ast_409.Asttypes.Labelled x0\n | Ast_410.Asttypes.Optional x0 -> Ast_409.Asttypes.Optional x0\n\nand copy_closed_flag :\n Ast_410.Asttypes.closed_flag -> Ast_409.Asttypes.closed_flag = function\n | Ast_410.Asttypes.Closed -> Ast_409.Asttypes.Closed\n | Ast_410.Asttypes.Open -> Ast_409.Asttypes.Open\n\nand copy_label : Ast_410.Asttypes.label -> Ast_409.Asttypes.label = fun x -> x\n\nand copy_rec_flag : Ast_410.Asttypes.rec_flag -> Ast_409.Asttypes.rec_flag =\n function\n | Ast_410.Asttypes.Nonrecursive -> Ast_409.Asttypes.Nonrecursive\n | Ast_410.Asttypes.Recursive -> Ast_409.Asttypes.Recursive\n\nand copy_constant : Ast_410.Parsetree.constant -> Ast_409.Parsetree.constant =\n function\n | Ast_410.Parsetree.Pconst_integer (x0, x1) ->\n Ast_409.Parsetree.Pconst_integer (x0, map_option (fun x -> x) x1)\n | Ast_410.Parsetree.Pconst_char x0 -> Ast_409.Parsetree.Pconst_char x0\n | Ast_410.Parsetree.Pconst_string (x0, x1) ->\n Ast_409.Parsetree.Pconst_string (x0, map_option (fun x -> x) x1)\n | Ast_410.Parsetree.Pconst_float (x0, x1) ->\n Ast_409.Parsetree.Pconst_float (x0, map_option (fun x -> x) x1)\n\nand copy_Longident_t : Longident.t -> Longident.t = fun x -> x\n\nand copy_loc :\n 'f0 'g0.\n ('f0 -> 'g0) -> 'f0 Ast_410.Asttypes.loc -> 'g0 Ast_409.Asttypes.loc =\n fun f0 { Ast_410.Asttypes.txt; Ast_410.Asttypes.loc } ->\n { Ast_409.Asttypes.txt = f0 txt; Ast_409.Asttypes.loc = copy_location loc }\n\nand copy_location : Location.t -> Location.t = fun x -> x\n\nlet copy_expr = copy_expression\nlet copy_pat = copy_pattern\nlet copy_typ = copy_core_type\n","module From = Ast_409\nmodule To = Ast_410\n\nlet map_option f x = match x with None -> None | Some x -> Some (f x)\n\nlet rec copy_toplevel_phrase :\n Ast_409.Parsetree.toplevel_phrase -> Ast_410.Parsetree.toplevel_phrase =\n function\n | Ast_409.Parsetree.Ptop_def x0 ->\n Ast_410.Parsetree.Ptop_def (copy_structure x0)\n | Ast_409.Parsetree.Ptop_dir x0 ->\n Ast_410.Parsetree.Ptop_dir (copy_toplevel_directive x0)\n\nand copy_toplevel_directive :\n Ast_409.Parsetree.toplevel_directive -> Ast_410.Parsetree.toplevel_directive\n =\n fun {\n Ast_409.Parsetree.pdir_name;\n Ast_409.Parsetree.pdir_arg;\n Ast_409.Parsetree.pdir_loc;\n } ->\n {\n Ast_410.Parsetree.pdir_name = copy_loc (fun x -> x) pdir_name;\n Ast_410.Parsetree.pdir_arg = map_option copy_directive_argument pdir_arg;\n Ast_410.Parsetree.pdir_loc = copy_location pdir_loc;\n }\n\nand copy_directive_argument :\n Ast_409.Parsetree.directive_argument -> Ast_410.Parsetree.directive_argument\n =\n fun { Ast_409.Parsetree.pdira_desc; Ast_409.Parsetree.pdira_loc } ->\n {\n Ast_410.Parsetree.pdira_desc = copy_directive_argument_desc pdira_desc;\n Ast_410.Parsetree.pdira_loc = copy_location pdira_loc;\n }\n\nand copy_directive_argument_desc :\n Ast_409.Parsetree.directive_argument_desc ->\n Ast_410.Parsetree.directive_argument_desc = function\n | Ast_409.Parsetree.Pdir_string x0 -> Ast_410.Parsetree.Pdir_string x0\n | Ast_409.Parsetree.Pdir_int (x0, x1) ->\n Ast_410.Parsetree.Pdir_int (x0, map_option (fun x -> x) x1)\n | Ast_409.Parsetree.Pdir_ident x0 ->\n Ast_410.Parsetree.Pdir_ident (copy_Longident_t x0)\n | Ast_409.Parsetree.Pdir_bool x0 -> Ast_410.Parsetree.Pdir_bool x0\n\nand copy_expression :\n Ast_409.Parsetree.expression -> Ast_410.Parsetree.expression =\n fun {\n Ast_409.Parsetree.pexp_desc;\n Ast_409.Parsetree.pexp_loc;\n Ast_409.Parsetree.pexp_loc_stack;\n Ast_409.Parsetree.pexp_attributes;\n } ->\n {\n Ast_410.Parsetree.pexp_desc = copy_expression_desc pexp_desc;\n Ast_410.Parsetree.pexp_loc = copy_location pexp_loc;\n Ast_410.Parsetree.pexp_loc_stack = List.map copy_location pexp_loc_stack;\n Ast_410.Parsetree.pexp_attributes = copy_attributes pexp_attributes;\n }\n\nand copy_expression_desc :\n Ast_409.Parsetree.expression_desc -> Ast_410.Parsetree.expression_desc =\n function\n | Ast_409.Parsetree.Pexp_ident x0 ->\n Ast_410.Parsetree.Pexp_ident (copy_loc copy_Longident_t x0)\n | Ast_409.Parsetree.Pexp_constant x0 ->\n Ast_410.Parsetree.Pexp_constant (copy_constant x0)\n | Ast_409.Parsetree.Pexp_let (x0, x1, x2) ->\n Ast_410.Parsetree.Pexp_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_expression x2)\n | Ast_409.Parsetree.Pexp_function x0 ->\n Ast_410.Parsetree.Pexp_function (copy_cases x0)\n | Ast_409.Parsetree.Pexp_fun (x0, x1, x2, x3) ->\n Ast_410.Parsetree.Pexp_fun\n ( copy_arg_label x0,\n map_option copy_expression x1,\n copy_pattern x2,\n copy_expression x3 )\n | Ast_409.Parsetree.Pexp_apply (x0, x1) ->\n Ast_410.Parsetree.Pexp_apply\n ( copy_expression x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | Ast_409.Parsetree.Pexp_match (x0, x1) ->\n Ast_410.Parsetree.Pexp_match (copy_expression x0, copy_cases x1)\n | Ast_409.Parsetree.Pexp_try (x0, x1) ->\n Ast_410.Parsetree.Pexp_try (copy_expression x0, copy_cases x1)\n | Ast_409.Parsetree.Pexp_tuple x0 ->\n Ast_410.Parsetree.Pexp_tuple (List.map copy_expression x0)\n | Ast_409.Parsetree.Pexp_construct (x0, x1) ->\n Ast_410.Parsetree.Pexp_construct\n (copy_loc copy_Longident_t x0, map_option copy_expression x1)\n | Ast_409.Parsetree.Pexp_variant (x0, x1) ->\n Ast_410.Parsetree.Pexp_variant\n (copy_label x0, map_option copy_expression x1)\n | Ast_409.Parsetree.Pexp_record (x0, x1) ->\n Ast_410.Parsetree.Pexp_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_expression x1))\n x0,\n map_option copy_expression x1 )\n | Ast_409.Parsetree.Pexp_field (x0, x1) ->\n Ast_410.Parsetree.Pexp_field\n (copy_expression x0, copy_loc copy_Longident_t x1)\n | Ast_409.Parsetree.Pexp_setfield (x0, x1, x2) ->\n Ast_410.Parsetree.Pexp_setfield\n (copy_expression x0, copy_loc copy_Longident_t x1, copy_expression x2)\n | Ast_409.Parsetree.Pexp_array x0 ->\n Ast_410.Parsetree.Pexp_array (List.map copy_expression x0)\n | Ast_409.Parsetree.Pexp_ifthenelse (x0, x1, x2) ->\n Ast_410.Parsetree.Pexp_ifthenelse\n (copy_expression x0, copy_expression x1, map_option copy_expression x2)\n | Ast_409.Parsetree.Pexp_sequence (x0, x1) ->\n Ast_410.Parsetree.Pexp_sequence (copy_expression x0, copy_expression x1)\n | Ast_409.Parsetree.Pexp_while (x0, x1) ->\n Ast_410.Parsetree.Pexp_while (copy_expression x0, copy_expression x1)\n | Ast_409.Parsetree.Pexp_for (x0, x1, x2, x3, x4) ->\n Ast_410.Parsetree.Pexp_for\n ( copy_pattern x0,\n copy_expression x1,\n copy_expression x2,\n copy_direction_flag x3,\n copy_expression x4 )\n | Ast_409.Parsetree.Pexp_constraint (x0, x1) ->\n Ast_410.Parsetree.Pexp_constraint (copy_expression x0, copy_core_type x1)\n | Ast_409.Parsetree.Pexp_coerce (x0, x1, x2) ->\n Ast_410.Parsetree.Pexp_coerce\n (copy_expression x0, map_option copy_core_type x1, copy_core_type x2)\n | Ast_409.Parsetree.Pexp_send (x0, x1) ->\n Ast_410.Parsetree.Pexp_send (copy_expression x0, copy_loc copy_label x1)\n | Ast_409.Parsetree.Pexp_new x0 ->\n Ast_410.Parsetree.Pexp_new (copy_loc copy_Longident_t x0)\n | Ast_409.Parsetree.Pexp_setinstvar (x0, x1) ->\n Ast_410.Parsetree.Pexp_setinstvar\n (copy_loc copy_label x0, copy_expression x1)\n | Ast_409.Parsetree.Pexp_override x0 ->\n Ast_410.Parsetree.Pexp_override\n (List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_label x0, copy_expression x1))\n x0)\n | Ast_409.Parsetree.Pexp_letmodule (x0, x1, x2) ->\n Ast_410.Parsetree.Pexp_letmodule\n (copy_loc (fun x -> Some x) x0, copy_module_expr x1, copy_expression x2)\n | Ast_409.Parsetree.Pexp_letexception (x0, x1) ->\n Ast_410.Parsetree.Pexp_letexception\n (copy_extension_constructor x0, copy_expression x1)\n | Ast_409.Parsetree.Pexp_assert x0 ->\n Ast_410.Parsetree.Pexp_assert (copy_expression x0)\n | Ast_409.Parsetree.Pexp_lazy x0 ->\n Ast_410.Parsetree.Pexp_lazy (copy_expression x0)\n | Ast_409.Parsetree.Pexp_poly (x0, x1) ->\n Ast_410.Parsetree.Pexp_poly\n (copy_expression x0, map_option copy_core_type x1)\n | Ast_409.Parsetree.Pexp_object x0 ->\n Ast_410.Parsetree.Pexp_object (copy_class_structure x0)\n | Ast_409.Parsetree.Pexp_newtype (x0, x1) ->\n Ast_410.Parsetree.Pexp_newtype\n (copy_loc (fun x -> x) x0, copy_expression x1)\n | Ast_409.Parsetree.Pexp_pack x0 ->\n Ast_410.Parsetree.Pexp_pack (copy_module_expr x0)\n | Ast_409.Parsetree.Pexp_open (x0, x1) ->\n Ast_410.Parsetree.Pexp_open (copy_open_declaration x0, copy_expression x1)\n | Ast_409.Parsetree.Pexp_letop x0 ->\n Ast_410.Parsetree.Pexp_letop (copy_letop x0)\n | Ast_409.Parsetree.Pexp_extension x0 ->\n Ast_410.Parsetree.Pexp_extension (copy_extension x0)\n | Ast_409.Parsetree.Pexp_unreachable -> Ast_410.Parsetree.Pexp_unreachable\n\nand copy_letop : Ast_409.Parsetree.letop -> Ast_410.Parsetree.letop =\n fun { Ast_409.Parsetree.let_; Ast_409.Parsetree.ands; Ast_409.Parsetree.body } ->\n {\n Ast_410.Parsetree.let_ = copy_binding_op let_;\n Ast_410.Parsetree.ands = List.map copy_binding_op ands;\n Ast_410.Parsetree.body = copy_expression body;\n }\n\nand copy_binding_op :\n Ast_409.Parsetree.binding_op -> Ast_410.Parsetree.binding_op =\n fun {\n Ast_409.Parsetree.pbop_op;\n Ast_409.Parsetree.pbop_pat;\n Ast_409.Parsetree.pbop_exp;\n Ast_409.Parsetree.pbop_loc;\n } ->\n {\n Ast_410.Parsetree.pbop_op = copy_loc (fun x -> x) pbop_op;\n Ast_410.Parsetree.pbop_pat = copy_pattern pbop_pat;\n Ast_410.Parsetree.pbop_exp = copy_expression pbop_exp;\n Ast_410.Parsetree.pbop_loc = copy_location pbop_loc;\n }\n\nand copy_direction_flag :\n Ast_409.Asttypes.direction_flag -> Ast_410.Asttypes.direction_flag =\n function\n | Ast_409.Asttypes.Upto -> Ast_410.Asttypes.Upto\n | Ast_409.Asttypes.Downto -> Ast_410.Asttypes.Downto\n\nand copy_cases : Ast_409.Parsetree.cases -> Ast_410.Parsetree.case list =\n fun x -> List.map copy_case x\n\nand copy_case : Ast_409.Parsetree.case -> Ast_410.Parsetree.case =\n fun {\n Ast_409.Parsetree.pc_lhs;\n Ast_409.Parsetree.pc_guard;\n Ast_409.Parsetree.pc_rhs;\n } ->\n {\n Ast_410.Parsetree.pc_lhs = copy_pattern pc_lhs;\n Ast_410.Parsetree.pc_guard = map_option copy_expression pc_guard;\n Ast_410.Parsetree.pc_rhs = copy_expression pc_rhs;\n }\n\nand copy_value_binding :\n Ast_409.Parsetree.value_binding -> Ast_410.Parsetree.value_binding =\n fun {\n Ast_409.Parsetree.pvb_pat;\n Ast_409.Parsetree.pvb_expr;\n Ast_409.Parsetree.pvb_attributes;\n Ast_409.Parsetree.pvb_loc;\n } ->\n {\n Ast_410.Parsetree.pvb_pat = copy_pattern pvb_pat;\n Ast_410.Parsetree.pvb_expr = copy_expression pvb_expr;\n Ast_410.Parsetree.pvb_attributes = copy_attributes pvb_attributes;\n Ast_410.Parsetree.pvb_loc = copy_location pvb_loc;\n }\n\nand copy_pattern : Ast_409.Parsetree.pattern -> Ast_410.Parsetree.pattern =\n fun {\n Ast_409.Parsetree.ppat_desc;\n Ast_409.Parsetree.ppat_loc;\n Ast_409.Parsetree.ppat_loc_stack;\n Ast_409.Parsetree.ppat_attributes;\n } ->\n {\n Ast_410.Parsetree.ppat_desc = copy_pattern_desc ppat_desc;\n Ast_410.Parsetree.ppat_loc = copy_location ppat_loc;\n Ast_410.Parsetree.ppat_loc_stack = List.map copy_location ppat_loc_stack;\n Ast_410.Parsetree.ppat_attributes = copy_attributes ppat_attributes;\n }\n\nand copy_pattern_desc :\n Ast_409.Parsetree.pattern_desc -> Ast_410.Parsetree.pattern_desc = function\n | Ast_409.Parsetree.Ppat_any -> Ast_410.Parsetree.Ppat_any\n | Ast_409.Parsetree.Ppat_var x0 ->\n Ast_410.Parsetree.Ppat_var (copy_loc (fun x -> x) x0)\n | Ast_409.Parsetree.Ppat_alias (x0, x1) ->\n Ast_410.Parsetree.Ppat_alias (copy_pattern x0, copy_loc (fun x -> x) x1)\n | Ast_409.Parsetree.Ppat_constant x0 ->\n Ast_410.Parsetree.Ppat_constant (copy_constant x0)\n | Ast_409.Parsetree.Ppat_interval (x0, x1) ->\n Ast_410.Parsetree.Ppat_interval (copy_constant x0, copy_constant x1)\n | Ast_409.Parsetree.Ppat_tuple x0 ->\n Ast_410.Parsetree.Ppat_tuple (List.map copy_pattern x0)\n | Ast_409.Parsetree.Ppat_construct (x0, x1) ->\n Ast_410.Parsetree.Ppat_construct\n (copy_loc copy_Longident_t x0, map_option copy_pattern x1)\n | Ast_409.Parsetree.Ppat_variant (x0, x1) ->\n Ast_410.Parsetree.Ppat_variant (copy_label x0, map_option copy_pattern x1)\n | Ast_409.Parsetree.Ppat_record (x0, x1) ->\n Ast_410.Parsetree.Ppat_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_pattern x1))\n x0,\n copy_closed_flag x1 )\n | Ast_409.Parsetree.Ppat_array x0 ->\n Ast_410.Parsetree.Ppat_array (List.map copy_pattern x0)\n | Ast_409.Parsetree.Ppat_or (x0, x1) ->\n Ast_410.Parsetree.Ppat_or (copy_pattern x0, copy_pattern x1)\n | Ast_409.Parsetree.Ppat_constraint (x0, x1) ->\n Ast_410.Parsetree.Ppat_constraint (copy_pattern x0, copy_core_type x1)\n | Ast_409.Parsetree.Ppat_type x0 ->\n Ast_410.Parsetree.Ppat_type (copy_loc copy_Longident_t x0)\n | Ast_409.Parsetree.Ppat_lazy x0 ->\n Ast_410.Parsetree.Ppat_lazy (copy_pattern x0)\n | Ast_409.Parsetree.Ppat_unpack x0 ->\n Ast_410.Parsetree.Ppat_unpack (copy_loc (fun x -> Some x) x0)\n | Ast_409.Parsetree.Ppat_exception x0 ->\n Ast_410.Parsetree.Ppat_exception (copy_pattern x0)\n | Ast_409.Parsetree.Ppat_extension x0 ->\n Ast_410.Parsetree.Ppat_extension (copy_extension x0)\n | Ast_409.Parsetree.Ppat_open (x0, x1) ->\n Ast_410.Parsetree.Ppat_open (copy_loc copy_Longident_t x0, copy_pattern x1)\n\nand copy_core_type : Ast_409.Parsetree.core_type -> Ast_410.Parsetree.core_type\n =\n fun {\n Ast_409.Parsetree.ptyp_desc;\n Ast_409.Parsetree.ptyp_loc;\n Ast_409.Parsetree.ptyp_loc_stack;\n Ast_409.Parsetree.ptyp_attributes;\n } ->\n {\n Ast_410.Parsetree.ptyp_desc = copy_core_type_desc ptyp_desc;\n Ast_410.Parsetree.ptyp_loc = copy_location ptyp_loc;\n Ast_410.Parsetree.ptyp_loc_stack = List.map copy_location ptyp_loc_stack;\n Ast_410.Parsetree.ptyp_attributes = copy_attributes ptyp_attributes;\n }\n\nand copy_core_type_desc :\n Ast_409.Parsetree.core_type_desc -> Ast_410.Parsetree.core_type_desc =\n function\n | Ast_409.Parsetree.Ptyp_any -> Ast_410.Parsetree.Ptyp_any\n | Ast_409.Parsetree.Ptyp_var x0 -> Ast_410.Parsetree.Ptyp_var x0\n | Ast_409.Parsetree.Ptyp_arrow (x0, x1, x2) ->\n Ast_410.Parsetree.Ptyp_arrow\n (copy_arg_label x0, copy_core_type x1, copy_core_type x2)\n | Ast_409.Parsetree.Ptyp_tuple x0 ->\n Ast_410.Parsetree.Ptyp_tuple (List.map copy_core_type x0)\n | Ast_409.Parsetree.Ptyp_constr (x0, x1) ->\n Ast_410.Parsetree.Ptyp_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_409.Parsetree.Ptyp_object (x0, x1) ->\n Ast_410.Parsetree.Ptyp_object\n (List.map copy_object_field x0, copy_closed_flag x1)\n | Ast_409.Parsetree.Ptyp_class (x0, x1) ->\n Ast_410.Parsetree.Ptyp_class\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_409.Parsetree.Ptyp_alias (x0, x1) ->\n Ast_410.Parsetree.Ptyp_alias (copy_core_type x0, x1)\n | Ast_409.Parsetree.Ptyp_variant (x0, x1, x2) ->\n Ast_410.Parsetree.Ptyp_variant\n ( List.map copy_row_field x0,\n copy_closed_flag x1,\n map_option (fun x -> List.map copy_label x) x2 )\n | Ast_409.Parsetree.Ptyp_poly (x0, x1) ->\n Ast_410.Parsetree.Ptyp_poly\n (List.map (fun x -> copy_loc (fun x -> x) x) x0, copy_core_type x1)\n | Ast_409.Parsetree.Ptyp_package x0 ->\n Ast_410.Parsetree.Ptyp_package (copy_package_type x0)\n | Ast_409.Parsetree.Ptyp_extension x0 ->\n Ast_410.Parsetree.Ptyp_extension (copy_extension x0)\n\nand copy_package_type :\n Ast_409.Parsetree.package_type -> Ast_410.Parsetree.package_type =\n fun x ->\n let x0, x1 = x in\n ( copy_loc copy_Longident_t x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_core_type x1))\n x1 )\n\nand copy_row_field : Ast_409.Parsetree.row_field -> Ast_410.Parsetree.row_field\n =\n fun {\n Ast_409.Parsetree.prf_desc;\n Ast_409.Parsetree.prf_loc;\n Ast_409.Parsetree.prf_attributes;\n } ->\n {\n Ast_410.Parsetree.prf_desc = copy_row_field_desc prf_desc;\n Ast_410.Parsetree.prf_loc = copy_location prf_loc;\n Ast_410.Parsetree.prf_attributes = copy_attributes prf_attributes;\n }\n\nand copy_row_field_desc :\n Ast_409.Parsetree.row_field_desc -> Ast_410.Parsetree.row_field_desc =\n function\n | Ast_409.Parsetree.Rtag (x0, x1, x2) ->\n Ast_410.Parsetree.Rtag\n (copy_loc copy_label x0, x1, List.map copy_core_type x2)\n | Ast_409.Parsetree.Rinherit x0 ->\n Ast_410.Parsetree.Rinherit (copy_core_type x0)\n\nand copy_object_field :\n Ast_409.Parsetree.object_field -> Ast_410.Parsetree.object_field =\n fun {\n Ast_409.Parsetree.pof_desc;\n Ast_409.Parsetree.pof_loc;\n Ast_409.Parsetree.pof_attributes;\n } ->\n {\n Ast_410.Parsetree.pof_desc = copy_object_field_desc pof_desc;\n Ast_410.Parsetree.pof_loc = copy_location pof_loc;\n Ast_410.Parsetree.pof_attributes = copy_attributes pof_attributes;\n }\n\nand copy_attributes :\n Ast_409.Parsetree.attributes -> Ast_410.Parsetree.attributes =\n fun x -> List.map copy_attribute x\n\nand copy_attribute : Ast_409.Parsetree.attribute -> Ast_410.Parsetree.attribute\n =\n fun {\n Ast_409.Parsetree.attr_name;\n Ast_409.Parsetree.attr_payload;\n Ast_409.Parsetree.attr_loc;\n } ->\n {\n Ast_410.Parsetree.attr_name = copy_loc (fun x -> x) attr_name;\n Ast_410.Parsetree.attr_payload = copy_payload attr_payload;\n Ast_410.Parsetree.attr_loc = copy_location attr_loc;\n }\n\nand copy_payload : Ast_409.Parsetree.payload -> Ast_410.Parsetree.payload =\n function\n | Ast_409.Parsetree.PStr x0 -> Ast_410.Parsetree.PStr (copy_structure x0)\n | Ast_409.Parsetree.PSig x0 -> Ast_410.Parsetree.PSig (copy_signature x0)\n | Ast_409.Parsetree.PTyp x0 -> Ast_410.Parsetree.PTyp (copy_core_type x0)\n | Ast_409.Parsetree.PPat (x0, x1) ->\n Ast_410.Parsetree.PPat (copy_pattern x0, map_option copy_expression x1)\n\nand copy_structure : Ast_409.Parsetree.structure -> Ast_410.Parsetree.structure\n =\n fun x -> List.map copy_structure_item x\n\nand copy_structure_item :\n Ast_409.Parsetree.structure_item -> Ast_410.Parsetree.structure_item =\n fun { Ast_409.Parsetree.pstr_desc; Ast_409.Parsetree.pstr_loc } ->\n {\n Ast_410.Parsetree.pstr_desc = copy_structure_item_desc pstr_desc;\n Ast_410.Parsetree.pstr_loc = copy_location pstr_loc;\n }\n\nand copy_structure_item_desc :\n Ast_409.Parsetree.structure_item_desc ->\n Ast_410.Parsetree.structure_item_desc = function\n | Ast_409.Parsetree.Pstr_eval (x0, x1) ->\n Ast_410.Parsetree.Pstr_eval (copy_expression x0, copy_attributes x1)\n | Ast_409.Parsetree.Pstr_value (x0, x1) ->\n Ast_410.Parsetree.Pstr_value\n (copy_rec_flag x0, List.map copy_value_binding x1)\n | Ast_409.Parsetree.Pstr_primitive x0 ->\n Ast_410.Parsetree.Pstr_primitive (copy_value_description x0)\n | Ast_409.Parsetree.Pstr_type (x0, x1) ->\n Ast_410.Parsetree.Pstr_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | Ast_409.Parsetree.Pstr_typext x0 ->\n Ast_410.Parsetree.Pstr_typext (copy_type_extension x0)\n | Ast_409.Parsetree.Pstr_exception x0 ->\n Ast_410.Parsetree.Pstr_exception (copy_type_exception x0)\n | Ast_409.Parsetree.Pstr_module x0 ->\n Ast_410.Parsetree.Pstr_module (copy_module_binding x0)\n | Ast_409.Parsetree.Pstr_recmodule x0 ->\n Ast_410.Parsetree.Pstr_recmodule (List.map copy_module_binding x0)\n | Ast_409.Parsetree.Pstr_modtype x0 ->\n Ast_410.Parsetree.Pstr_modtype (copy_module_type_declaration x0)\n | Ast_409.Parsetree.Pstr_open x0 ->\n Ast_410.Parsetree.Pstr_open (copy_open_declaration x0)\n | Ast_409.Parsetree.Pstr_class x0 ->\n Ast_410.Parsetree.Pstr_class (List.map copy_class_declaration x0)\n | Ast_409.Parsetree.Pstr_class_type x0 ->\n Ast_410.Parsetree.Pstr_class_type\n (List.map copy_class_type_declaration x0)\n | Ast_409.Parsetree.Pstr_include x0 ->\n Ast_410.Parsetree.Pstr_include (copy_include_declaration x0)\n | Ast_409.Parsetree.Pstr_attribute x0 ->\n Ast_410.Parsetree.Pstr_attribute (copy_attribute x0)\n | Ast_409.Parsetree.Pstr_extension (x0, x1) ->\n Ast_410.Parsetree.Pstr_extension (copy_extension x0, copy_attributes x1)\n\nand copy_include_declaration :\n Ast_409.Parsetree.include_declaration ->\n Ast_410.Parsetree.include_declaration =\n fun x -> copy_include_infos copy_module_expr x\n\nand copy_class_declaration :\n Ast_409.Parsetree.class_declaration -> Ast_410.Parsetree.class_declaration =\n fun x -> copy_class_infos copy_class_expr x\n\nand copy_class_expr :\n Ast_409.Parsetree.class_expr -> Ast_410.Parsetree.class_expr =\n fun {\n Ast_409.Parsetree.pcl_desc;\n Ast_409.Parsetree.pcl_loc;\n Ast_409.Parsetree.pcl_attributes;\n } ->\n {\n Ast_410.Parsetree.pcl_desc = copy_class_expr_desc pcl_desc;\n Ast_410.Parsetree.pcl_loc = copy_location pcl_loc;\n Ast_410.Parsetree.pcl_attributes = copy_attributes pcl_attributes;\n }\n\nand copy_class_expr_desc :\n Ast_409.Parsetree.class_expr_desc -> Ast_410.Parsetree.class_expr_desc =\n function\n | Ast_409.Parsetree.Pcl_constr (x0, x1) ->\n Ast_410.Parsetree.Pcl_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_409.Parsetree.Pcl_structure x0 ->\n Ast_410.Parsetree.Pcl_structure (copy_class_structure x0)\n | Ast_409.Parsetree.Pcl_fun (x0, x1, x2, x3) ->\n Ast_410.Parsetree.Pcl_fun\n ( copy_arg_label x0,\n map_option copy_expression x1,\n copy_pattern x2,\n copy_class_expr x3 )\n | Ast_409.Parsetree.Pcl_apply (x0, x1) ->\n Ast_410.Parsetree.Pcl_apply\n ( copy_class_expr x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | Ast_409.Parsetree.Pcl_let (x0, x1, x2) ->\n Ast_410.Parsetree.Pcl_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_class_expr x2)\n | Ast_409.Parsetree.Pcl_constraint (x0, x1) ->\n Ast_410.Parsetree.Pcl_constraint (copy_class_expr x0, copy_class_type x1)\n | Ast_409.Parsetree.Pcl_extension x0 ->\n Ast_410.Parsetree.Pcl_extension (copy_extension x0)\n | Ast_409.Parsetree.Pcl_open (x0, x1) ->\n Ast_410.Parsetree.Pcl_open (copy_open_description x0, copy_class_expr x1)\n\nand copy_class_structure :\n Ast_409.Parsetree.class_structure -> Ast_410.Parsetree.class_structure =\n fun { Ast_409.Parsetree.pcstr_self; Ast_409.Parsetree.pcstr_fields } ->\n {\n Ast_410.Parsetree.pcstr_self = copy_pattern pcstr_self;\n Ast_410.Parsetree.pcstr_fields = List.map copy_class_field pcstr_fields;\n }\n\nand copy_class_field :\n Ast_409.Parsetree.class_field -> Ast_410.Parsetree.class_field =\n fun {\n Ast_409.Parsetree.pcf_desc;\n Ast_409.Parsetree.pcf_loc;\n Ast_409.Parsetree.pcf_attributes;\n } ->\n {\n Ast_410.Parsetree.pcf_desc = copy_class_field_desc pcf_desc;\n Ast_410.Parsetree.pcf_loc = copy_location pcf_loc;\n Ast_410.Parsetree.pcf_attributes = copy_attributes pcf_attributes;\n }\n\nand copy_class_field_desc :\n Ast_409.Parsetree.class_field_desc -> Ast_410.Parsetree.class_field_desc =\n function\n | Ast_409.Parsetree.Pcf_inherit (x0, x1, x2) ->\n Ast_410.Parsetree.Pcf_inherit\n ( copy_override_flag x0,\n copy_class_expr x1,\n map_option (fun x -> copy_loc (fun x -> x) x) x2 )\n | Ast_409.Parsetree.Pcf_val x0 ->\n Ast_410.Parsetree.Pcf_val\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_mutable_flag x1, copy_class_field_kind x2))\n | Ast_409.Parsetree.Pcf_method x0 ->\n Ast_410.Parsetree.Pcf_method\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_private_flag x1, copy_class_field_kind x2))\n | Ast_409.Parsetree.Pcf_constraint x0 ->\n Ast_410.Parsetree.Pcf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | Ast_409.Parsetree.Pcf_initializer x0 ->\n Ast_410.Parsetree.Pcf_initializer (copy_expression x0)\n | Ast_409.Parsetree.Pcf_attribute x0 ->\n Ast_410.Parsetree.Pcf_attribute (copy_attribute x0)\n | Ast_409.Parsetree.Pcf_extension x0 ->\n Ast_410.Parsetree.Pcf_extension (copy_extension x0)\n\nand copy_class_field_kind :\n Ast_409.Parsetree.class_field_kind -> Ast_410.Parsetree.class_field_kind =\n function\n | Ast_409.Parsetree.Cfk_virtual x0 ->\n Ast_410.Parsetree.Cfk_virtual (copy_core_type x0)\n | Ast_409.Parsetree.Cfk_concrete (x0, x1) ->\n Ast_410.Parsetree.Cfk_concrete (copy_override_flag x0, copy_expression x1)\n\nand copy_open_declaration :\n Ast_409.Parsetree.open_declaration -> Ast_410.Parsetree.open_declaration =\n fun x -> copy_open_infos copy_module_expr x\n\nand copy_module_binding :\n Ast_409.Parsetree.module_binding -> Ast_410.Parsetree.module_binding =\n fun {\n Ast_409.Parsetree.pmb_name;\n Ast_409.Parsetree.pmb_expr;\n Ast_409.Parsetree.pmb_attributes;\n Ast_409.Parsetree.pmb_loc;\n } ->\n {\n Ast_410.Parsetree.pmb_name = copy_loc (fun x -> Some x) pmb_name;\n Ast_410.Parsetree.pmb_expr = copy_module_expr pmb_expr;\n Ast_410.Parsetree.pmb_attributes = copy_attributes pmb_attributes;\n Ast_410.Parsetree.pmb_loc = copy_location pmb_loc;\n }\n\nand copy_module_expr :\n Ast_409.Parsetree.module_expr -> Ast_410.Parsetree.module_expr =\n fun {\n Ast_409.Parsetree.pmod_desc;\n Ast_409.Parsetree.pmod_loc;\n Ast_409.Parsetree.pmod_attributes;\n } ->\n {\n Ast_410.Parsetree.pmod_desc = copy_module_expr_desc pmod_desc;\n Ast_410.Parsetree.pmod_loc = copy_location pmod_loc;\n Ast_410.Parsetree.pmod_attributes = copy_attributes pmod_attributes;\n }\n\nand copy_module_expr_desc :\n Ast_409.Parsetree.module_expr_desc -> Ast_410.Parsetree.module_expr_desc =\n function\n | Ast_409.Parsetree.Pmod_ident x0 ->\n Ast_410.Parsetree.Pmod_ident (copy_loc copy_Longident_t x0)\n | Ast_409.Parsetree.Pmod_structure x0 ->\n Ast_410.Parsetree.Pmod_structure (copy_structure x0)\n | Ast_409.Parsetree.Pmod_functor (x0, x1, x2) ->\n Ast_410.Parsetree.Pmod_functor\n ( (match (x0.txt, x1) with\n | \"*\", None -> Unit\n | \"_\", Some mt ->\n Named (copy_loc (fun _ -> None) x0, copy_module_type mt)\n | _, Some mt ->\n Named (copy_loc (fun x -> Some x) x0, copy_module_type mt)\n | _ -> assert false),\n copy_module_expr x2 )\n | Ast_409.Parsetree.Pmod_apply (x0, x1) ->\n Ast_410.Parsetree.Pmod_apply (copy_module_expr x0, copy_module_expr x1)\n | Ast_409.Parsetree.Pmod_constraint (x0, x1) ->\n Ast_410.Parsetree.Pmod_constraint\n (copy_module_expr x0, copy_module_type x1)\n | Ast_409.Parsetree.Pmod_unpack x0 ->\n Ast_410.Parsetree.Pmod_unpack (copy_expression x0)\n | Ast_409.Parsetree.Pmod_extension x0 ->\n Ast_410.Parsetree.Pmod_extension (copy_extension x0)\n\nand copy_module_type :\n Ast_409.Parsetree.module_type -> Ast_410.Parsetree.module_type =\n fun {\n Ast_409.Parsetree.pmty_desc;\n Ast_409.Parsetree.pmty_loc;\n Ast_409.Parsetree.pmty_attributes;\n } ->\n {\n Ast_410.Parsetree.pmty_desc = copy_module_type_desc pmty_desc;\n Ast_410.Parsetree.pmty_loc = copy_location pmty_loc;\n Ast_410.Parsetree.pmty_attributes = copy_attributes pmty_attributes;\n }\n\nand copy_module_type_desc :\n Ast_409.Parsetree.module_type_desc -> Ast_410.Parsetree.module_type_desc =\n function\n | Ast_409.Parsetree.Pmty_ident x0 ->\n Ast_410.Parsetree.Pmty_ident (copy_loc copy_Longident_t x0)\n | Ast_409.Parsetree.Pmty_signature x0 ->\n Ast_410.Parsetree.Pmty_signature (copy_signature x0)\n | Ast_409.Parsetree.Pmty_functor (x0, x1, x2) ->\n Ast_410.Parsetree.Pmty_functor\n ( (match (x0.txt, x1) with\n | \"*\", None -> Unit\n | \"_\", Some mt ->\n Named (copy_loc (fun _ -> None) x0, copy_module_type mt)\n | _, Some mt ->\n Named (copy_loc (fun x -> Some x) x0, copy_module_type mt)\n | _ -> assert false),\n copy_module_type x2 )\n | Ast_409.Parsetree.Pmty_with (x0, x1) ->\n Ast_410.Parsetree.Pmty_with\n (copy_module_type x0, List.map copy_with_constraint x1)\n | Ast_409.Parsetree.Pmty_typeof x0 ->\n Ast_410.Parsetree.Pmty_typeof (copy_module_expr x0)\n | Ast_409.Parsetree.Pmty_extension x0 ->\n Ast_410.Parsetree.Pmty_extension (copy_extension x0)\n | Ast_409.Parsetree.Pmty_alias x0 ->\n Ast_410.Parsetree.Pmty_alias (copy_loc copy_Longident_t x0)\n\nand copy_with_constraint :\n Ast_409.Parsetree.with_constraint -> Ast_410.Parsetree.with_constraint =\n function\n | Ast_409.Parsetree.Pwith_type (x0, x1) ->\n Ast_410.Parsetree.Pwith_type\n (copy_loc copy_Longident_t x0, copy_type_declaration x1)\n | Ast_409.Parsetree.Pwith_module (x0, x1) ->\n Ast_410.Parsetree.Pwith_module\n (copy_loc copy_Longident_t x0, copy_loc copy_Longident_t x1)\n | Ast_409.Parsetree.Pwith_typesubst (x0, x1) ->\n Ast_410.Parsetree.Pwith_typesubst\n (copy_loc copy_Longident_t x0, copy_type_declaration x1)\n | Ast_409.Parsetree.Pwith_modsubst (x0, x1) ->\n Ast_410.Parsetree.Pwith_modsubst\n (copy_loc copy_Longident_t x0, copy_loc copy_Longident_t x1)\n\nand copy_signature : Ast_409.Parsetree.signature -> Ast_410.Parsetree.signature\n =\n fun x -> List.map copy_signature_item x\n\nand copy_signature_item :\n Ast_409.Parsetree.signature_item -> Ast_410.Parsetree.signature_item =\n fun { Ast_409.Parsetree.psig_desc; Ast_409.Parsetree.psig_loc } ->\n {\n Ast_410.Parsetree.psig_desc = copy_signature_item_desc psig_desc;\n Ast_410.Parsetree.psig_loc = copy_location psig_loc;\n }\n\nand copy_signature_item_desc :\n Ast_409.Parsetree.signature_item_desc ->\n Ast_410.Parsetree.signature_item_desc = function\n | Ast_409.Parsetree.Psig_value x0 ->\n Ast_410.Parsetree.Psig_value (copy_value_description x0)\n | Ast_409.Parsetree.Psig_type (x0, x1) ->\n Ast_410.Parsetree.Psig_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | Ast_409.Parsetree.Psig_typesubst x0 ->\n Ast_410.Parsetree.Psig_typesubst (List.map copy_type_declaration x0)\n | Ast_409.Parsetree.Psig_typext x0 ->\n Ast_410.Parsetree.Psig_typext (copy_type_extension x0)\n | Ast_409.Parsetree.Psig_exception x0 ->\n Ast_410.Parsetree.Psig_exception (copy_type_exception x0)\n | Ast_409.Parsetree.Psig_module x0 ->\n Ast_410.Parsetree.Psig_module (copy_module_declaration x0)\n | Ast_409.Parsetree.Psig_modsubst x0 ->\n Ast_410.Parsetree.Psig_modsubst (copy_module_substitution x0)\n | Ast_409.Parsetree.Psig_recmodule x0 ->\n Ast_410.Parsetree.Psig_recmodule (List.map copy_module_declaration x0)\n | Ast_409.Parsetree.Psig_modtype x0 ->\n Ast_410.Parsetree.Psig_modtype (copy_module_type_declaration x0)\n | Ast_409.Parsetree.Psig_open x0 ->\n Ast_410.Parsetree.Psig_open (copy_open_description x0)\n | Ast_409.Parsetree.Psig_include x0 ->\n Ast_410.Parsetree.Psig_include (copy_include_description x0)\n | Ast_409.Parsetree.Psig_class x0 ->\n Ast_410.Parsetree.Psig_class (List.map copy_class_description x0)\n | Ast_409.Parsetree.Psig_class_type x0 ->\n Ast_410.Parsetree.Psig_class_type\n (List.map copy_class_type_declaration x0)\n | Ast_409.Parsetree.Psig_attribute x0 ->\n Ast_410.Parsetree.Psig_attribute (copy_attribute x0)\n | Ast_409.Parsetree.Psig_extension (x0, x1) ->\n Ast_410.Parsetree.Psig_extension (copy_extension x0, copy_attributes x1)\n\nand copy_class_type_declaration :\n Ast_409.Parsetree.class_type_declaration ->\n Ast_410.Parsetree.class_type_declaration =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_description :\n Ast_409.Parsetree.class_description -> Ast_410.Parsetree.class_description =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_type :\n Ast_409.Parsetree.class_type -> Ast_410.Parsetree.class_type =\n fun {\n Ast_409.Parsetree.pcty_desc;\n Ast_409.Parsetree.pcty_loc;\n Ast_409.Parsetree.pcty_attributes;\n } ->\n {\n Ast_410.Parsetree.pcty_desc = copy_class_type_desc pcty_desc;\n Ast_410.Parsetree.pcty_loc = copy_location pcty_loc;\n Ast_410.Parsetree.pcty_attributes = copy_attributes pcty_attributes;\n }\n\nand copy_class_type_desc :\n Ast_409.Parsetree.class_type_desc -> Ast_410.Parsetree.class_type_desc =\n function\n | Ast_409.Parsetree.Pcty_constr (x0, x1) ->\n Ast_410.Parsetree.Pcty_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_409.Parsetree.Pcty_signature x0 ->\n Ast_410.Parsetree.Pcty_signature (copy_class_signature x0)\n | Ast_409.Parsetree.Pcty_arrow (x0, x1, x2) ->\n Ast_410.Parsetree.Pcty_arrow\n (copy_arg_label x0, copy_core_type x1, copy_class_type x2)\n | Ast_409.Parsetree.Pcty_extension x0 ->\n Ast_410.Parsetree.Pcty_extension (copy_extension x0)\n | Ast_409.Parsetree.Pcty_open (x0, x1) ->\n Ast_410.Parsetree.Pcty_open (copy_open_description x0, copy_class_type x1)\n\nand copy_class_signature :\n Ast_409.Parsetree.class_signature -> Ast_410.Parsetree.class_signature =\n fun { Ast_409.Parsetree.pcsig_self; Ast_409.Parsetree.pcsig_fields } ->\n {\n Ast_410.Parsetree.pcsig_self = copy_core_type pcsig_self;\n Ast_410.Parsetree.pcsig_fields = List.map copy_class_type_field pcsig_fields;\n }\n\nand copy_class_type_field :\n Ast_409.Parsetree.class_type_field -> Ast_410.Parsetree.class_type_field =\n fun {\n Ast_409.Parsetree.pctf_desc;\n Ast_409.Parsetree.pctf_loc;\n Ast_409.Parsetree.pctf_attributes;\n } ->\n {\n Ast_410.Parsetree.pctf_desc = copy_class_type_field_desc pctf_desc;\n Ast_410.Parsetree.pctf_loc = copy_location pctf_loc;\n Ast_410.Parsetree.pctf_attributes = copy_attributes pctf_attributes;\n }\n\nand copy_class_type_field_desc :\n Ast_409.Parsetree.class_type_field_desc ->\n Ast_410.Parsetree.class_type_field_desc = function\n | Ast_409.Parsetree.Pctf_inherit x0 ->\n Ast_410.Parsetree.Pctf_inherit (copy_class_type x0)\n | Ast_409.Parsetree.Pctf_val x0 ->\n Ast_410.Parsetree.Pctf_val\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_mutable_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | Ast_409.Parsetree.Pctf_method x0 ->\n Ast_410.Parsetree.Pctf_method\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_private_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | Ast_409.Parsetree.Pctf_constraint x0 ->\n Ast_410.Parsetree.Pctf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | Ast_409.Parsetree.Pctf_attribute x0 ->\n Ast_410.Parsetree.Pctf_attribute (copy_attribute x0)\n | Ast_409.Parsetree.Pctf_extension x0 ->\n Ast_410.Parsetree.Pctf_extension (copy_extension x0)\n\nand copy_extension : Ast_409.Parsetree.extension -> Ast_410.Parsetree.extension\n =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_class_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_409.Parsetree.class_infos ->\n 'g0 Ast_410.Parsetree.class_infos =\n fun f0\n {\n Ast_409.Parsetree.pci_virt;\n Ast_409.Parsetree.pci_params;\n Ast_409.Parsetree.pci_name;\n Ast_409.Parsetree.pci_expr;\n Ast_409.Parsetree.pci_loc;\n Ast_409.Parsetree.pci_attributes;\n } ->\n {\n Ast_410.Parsetree.pci_virt = copy_virtual_flag pci_virt;\n Ast_410.Parsetree.pci_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n pci_params;\n Ast_410.Parsetree.pci_name = copy_loc (fun x -> x) pci_name;\n Ast_410.Parsetree.pci_expr = f0 pci_expr;\n Ast_410.Parsetree.pci_loc = copy_location pci_loc;\n Ast_410.Parsetree.pci_attributes = copy_attributes pci_attributes;\n }\n\nand copy_virtual_flag :\n Ast_409.Asttypes.virtual_flag -> Ast_410.Asttypes.virtual_flag = function\n | Ast_409.Asttypes.Virtual -> Ast_410.Asttypes.Virtual\n | Ast_409.Asttypes.Concrete -> Ast_410.Asttypes.Concrete\n\nand copy_include_description :\n Ast_409.Parsetree.include_description ->\n Ast_410.Parsetree.include_description =\n fun x -> copy_include_infos copy_module_type x\n\nand copy_include_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_409.Parsetree.include_infos ->\n 'g0 Ast_410.Parsetree.include_infos =\n fun f0\n {\n Ast_409.Parsetree.pincl_mod;\n Ast_409.Parsetree.pincl_loc;\n Ast_409.Parsetree.pincl_attributes;\n } ->\n {\n Ast_410.Parsetree.pincl_mod = f0 pincl_mod;\n Ast_410.Parsetree.pincl_loc = copy_location pincl_loc;\n Ast_410.Parsetree.pincl_attributes = copy_attributes pincl_attributes;\n }\n\nand copy_open_description :\n Ast_409.Parsetree.open_description -> Ast_410.Parsetree.open_description =\n fun x -> copy_open_infos (fun x -> copy_loc copy_Longident_t x) x\n\nand copy_open_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_409.Parsetree.open_infos ->\n 'g0 Ast_410.Parsetree.open_infos =\n fun f0\n {\n Ast_409.Parsetree.popen_expr;\n Ast_409.Parsetree.popen_override;\n Ast_409.Parsetree.popen_loc;\n Ast_409.Parsetree.popen_attributes;\n } ->\n {\n Ast_410.Parsetree.popen_expr = f0 popen_expr;\n Ast_410.Parsetree.popen_override = copy_override_flag popen_override;\n Ast_410.Parsetree.popen_loc = copy_location popen_loc;\n Ast_410.Parsetree.popen_attributes = copy_attributes popen_attributes;\n }\n\nand copy_override_flag :\n Ast_409.Asttypes.override_flag -> Ast_410.Asttypes.override_flag = function\n | Ast_409.Asttypes.Override -> Ast_410.Asttypes.Override\n | Ast_409.Asttypes.Fresh -> Ast_410.Asttypes.Fresh\n\nand copy_module_type_declaration :\n Ast_409.Parsetree.module_type_declaration ->\n Ast_410.Parsetree.module_type_declaration =\n fun {\n Ast_409.Parsetree.pmtd_name;\n Ast_409.Parsetree.pmtd_type;\n Ast_409.Parsetree.pmtd_attributes;\n Ast_409.Parsetree.pmtd_loc;\n } ->\n {\n Ast_410.Parsetree.pmtd_name = copy_loc (fun x -> x) pmtd_name;\n Ast_410.Parsetree.pmtd_type = map_option copy_module_type pmtd_type;\n Ast_410.Parsetree.pmtd_attributes = copy_attributes pmtd_attributes;\n Ast_410.Parsetree.pmtd_loc = copy_location pmtd_loc;\n }\n\nand copy_module_substitution :\n Ast_409.Parsetree.module_substitution ->\n Ast_410.Parsetree.module_substitution =\n fun {\n Ast_409.Parsetree.pms_name;\n Ast_409.Parsetree.pms_manifest;\n Ast_409.Parsetree.pms_attributes;\n Ast_409.Parsetree.pms_loc;\n } ->\n {\n Ast_410.Parsetree.pms_name = copy_loc (fun x -> x) pms_name;\n Ast_410.Parsetree.pms_manifest = copy_loc copy_Longident_t pms_manifest;\n Ast_410.Parsetree.pms_attributes = copy_attributes pms_attributes;\n Ast_410.Parsetree.pms_loc = copy_location pms_loc;\n }\n\nand copy_module_declaration :\n Ast_409.Parsetree.module_declaration -> Ast_410.Parsetree.module_declaration\n =\n fun {\n Ast_409.Parsetree.pmd_name;\n Ast_409.Parsetree.pmd_type;\n Ast_409.Parsetree.pmd_attributes;\n Ast_409.Parsetree.pmd_loc;\n } ->\n {\n Ast_410.Parsetree.pmd_name = copy_loc (fun x -> Some x) pmd_name;\n Ast_410.Parsetree.pmd_type = copy_module_type pmd_type;\n Ast_410.Parsetree.pmd_attributes = copy_attributes pmd_attributes;\n Ast_410.Parsetree.pmd_loc = copy_location pmd_loc;\n }\n\nand copy_type_exception :\n Ast_409.Parsetree.type_exception -> Ast_410.Parsetree.type_exception =\n fun {\n Ast_409.Parsetree.ptyexn_constructor;\n Ast_409.Parsetree.ptyexn_loc;\n Ast_409.Parsetree.ptyexn_attributes;\n } ->\n {\n Ast_410.Parsetree.ptyexn_constructor =\n copy_extension_constructor ptyexn_constructor;\n Ast_410.Parsetree.ptyexn_loc = copy_location ptyexn_loc;\n Ast_410.Parsetree.ptyexn_attributes = copy_attributes ptyexn_attributes;\n }\n\nand copy_type_extension :\n Ast_409.Parsetree.type_extension -> Ast_410.Parsetree.type_extension =\n fun {\n Ast_409.Parsetree.ptyext_path;\n Ast_409.Parsetree.ptyext_params;\n Ast_409.Parsetree.ptyext_constructors;\n Ast_409.Parsetree.ptyext_private;\n Ast_409.Parsetree.ptyext_loc;\n Ast_409.Parsetree.ptyext_attributes;\n } ->\n {\n Ast_410.Parsetree.ptyext_path = copy_loc copy_Longident_t ptyext_path;\n Ast_410.Parsetree.ptyext_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptyext_params;\n Ast_410.Parsetree.ptyext_constructors =\n List.map copy_extension_constructor ptyext_constructors;\n Ast_410.Parsetree.ptyext_private = copy_private_flag ptyext_private;\n Ast_410.Parsetree.ptyext_loc = copy_location ptyext_loc;\n Ast_410.Parsetree.ptyext_attributes = copy_attributes ptyext_attributes;\n }\n\nand copy_extension_constructor :\n Ast_409.Parsetree.extension_constructor ->\n Ast_410.Parsetree.extension_constructor =\n fun {\n Ast_409.Parsetree.pext_name;\n Ast_409.Parsetree.pext_kind;\n Ast_409.Parsetree.pext_loc;\n Ast_409.Parsetree.pext_attributes;\n } ->\n {\n Ast_410.Parsetree.pext_name = copy_loc (fun x -> x) pext_name;\n Ast_410.Parsetree.pext_kind = copy_extension_constructor_kind pext_kind;\n Ast_410.Parsetree.pext_loc = copy_location pext_loc;\n Ast_410.Parsetree.pext_attributes = copy_attributes pext_attributes;\n }\n\nand copy_extension_constructor_kind :\n Ast_409.Parsetree.extension_constructor_kind ->\n Ast_410.Parsetree.extension_constructor_kind = function\n | Ast_409.Parsetree.Pext_decl (x0, x1) ->\n Ast_410.Parsetree.Pext_decl\n (copy_constructor_arguments x0, map_option copy_core_type x1)\n | Ast_409.Parsetree.Pext_rebind x0 ->\n Ast_410.Parsetree.Pext_rebind (copy_loc copy_Longident_t x0)\n\nand copy_type_declaration :\n Ast_409.Parsetree.type_declaration -> Ast_410.Parsetree.type_declaration =\n fun {\n Ast_409.Parsetree.ptype_name;\n Ast_409.Parsetree.ptype_params;\n Ast_409.Parsetree.ptype_cstrs;\n Ast_409.Parsetree.ptype_kind;\n Ast_409.Parsetree.ptype_private;\n Ast_409.Parsetree.ptype_manifest;\n Ast_409.Parsetree.ptype_attributes;\n Ast_409.Parsetree.ptype_loc;\n } ->\n {\n Ast_410.Parsetree.ptype_name = copy_loc (fun x -> x) ptype_name;\n Ast_410.Parsetree.ptype_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptype_params;\n Ast_410.Parsetree.ptype_cstrs =\n List.map\n (fun x ->\n let x0, x1, x2 = x in\n (copy_core_type x0, copy_core_type x1, copy_location x2))\n ptype_cstrs;\n Ast_410.Parsetree.ptype_kind = copy_type_kind ptype_kind;\n Ast_410.Parsetree.ptype_private = copy_private_flag ptype_private;\n Ast_410.Parsetree.ptype_manifest = map_option copy_core_type ptype_manifest;\n Ast_410.Parsetree.ptype_attributes = copy_attributes ptype_attributes;\n Ast_410.Parsetree.ptype_loc = copy_location ptype_loc;\n }\n\nand copy_private_flag :\n Ast_409.Asttypes.private_flag -> Ast_410.Asttypes.private_flag = function\n | Ast_409.Asttypes.Private -> Ast_410.Asttypes.Private\n | Ast_409.Asttypes.Public -> Ast_410.Asttypes.Public\n\nand copy_type_kind : Ast_409.Parsetree.type_kind -> Ast_410.Parsetree.type_kind\n = function\n | Ast_409.Parsetree.Ptype_abstract -> Ast_410.Parsetree.Ptype_abstract\n | Ast_409.Parsetree.Ptype_variant x0 ->\n Ast_410.Parsetree.Ptype_variant (List.map copy_constructor_declaration x0)\n | Ast_409.Parsetree.Ptype_record x0 ->\n Ast_410.Parsetree.Ptype_record (List.map copy_label_declaration x0)\n | Ast_409.Parsetree.Ptype_open -> Ast_410.Parsetree.Ptype_open\n\nand copy_constructor_declaration :\n Ast_409.Parsetree.constructor_declaration ->\n Ast_410.Parsetree.constructor_declaration =\n fun {\n Ast_409.Parsetree.pcd_name;\n Ast_409.Parsetree.pcd_args;\n Ast_409.Parsetree.pcd_res;\n Ast_409.Parsetree.pcd_loc;\n Ast_409.Parsetree.pcd_attributes;\n } ->\n {\n Ast_410.Parsetree.pcd_name = copy_loc (fun x -> x) pcd_name;\n Ast_410.Parsetree.pcd_args = copy_constructor_arguments pcd_args;\n Ast_410.Parsetree.pcd_res = map_option copy_core_type pcd_res;\n Ast_410.Parsetree.pcd_loc = copy_location pcd_loc;\n Ast_410.Parsetree.pcd_attributes = copy_attributes pcd_attributes;\n }\n\nand copy_constructor_arguments :\n Ast_409.Parsetree.constructor_arguments ->\n Ast_410.Parsetree.constructor_arguments = function\n | Ast_409.Parsetree.Pcstr_tuple x0 ->\n Ast_410.Parsetree.Pcstr_tuple (List.map copy_core_type x0)\n | Ast_409.Parsetree.Pcstr_record x0 ->\n Ast_410.Parsetree.Pcstr_record (List.map copy_label_declaration x0)\n\nand copy_label_declaration :\n Ast_409.Parsetree.label_declaration -> Ast_410.Parsetree.label_declaration =\n fun {\n Ast_409.Parsetree.pld_name;\n Ast_409.Parsetree.pld_mutable;\n Ast_409.Parsetree.pld_type;\n Ast_409.Parsetree.pld_loc;\n Ast_409.Parsetree.pld_attributes;\n } ->\n {\n Ast_410.Parsetree.pld_name = copy_loc (fun x -> x) pld_name;\n Ast_410.Parsetree.pld_mutable = copy_mutable_flag pld_mutable;\n Ast_410.Parsetree.pld_type = copy_core_type pld_type;\n Ast_410.Parsetree.pld_loc = copy_location pld_loc;\n Ast_410.Parsetree.pld_attributes = copy_attributes pld_attributes;\n }\n\nand copy_mutable_flag :\n Ast_409.Asttypes.mutable_flag -> Ast_410.Asttypes.mutable_flag = function\n | Ast_409.Asttypes.Immutable -> Ast_410.Asttypes.Immutable\n | Ast_409.Asttypes.Mutable -> Ast_410.Asttypes.Mutable\n\nand copy_variance : Ast_409.Asttypes.variance -> Ast_410.Asttypes.variance =\n function\n | Ast_409.Asttypes.Covariant -> Ast_410.Asttypes.Covariant\n | Ast_409.Asttypes.Contravariant -> Ast_410.Asttypes.Contravariant\n | Ast_409.Asttypes.Invariant -> Ast_410.Asttypes.Invariant\n\nand copy_value_description :\n Ast_409.Parsetree.value_description -> Ast_410.Parsetree.value_description =\n fun {\n Ast_409.Parsetree.pval_name;\n Ast_409.Parsetree.pval_type;\n Ast_409.Parsetree.pval_prim;\n Ast_409.Parsetree.pval_attributes;\n Ast_409.Parsetree.pval_loc;\n } ->\n {\n Ast_410.Parsetree.pval_name = copy_loc (fun x -> x) pval_name;\n Ast_410.Parsetree.pval_type = copy_core_type pval_type;\n Ast_410.Parsetree.pval_prim = List.map (fun x -> x) pval_prim;\n Ast_410.Parsetree.pval_attributes = copy_attributes pval_attributes;\n Ast_410.Parsetree.pval_loc = copy_location pval_loc;\n }\n\nand copy_object_field_desc :\n Ast_409.Parsetree.object_field_desc -> Ast_410.Parsetree.object_field_desc =\n function\n | Ast_409.Parsetree.Otag (x0, x1) ->\n Ast_410.Parsetree.Otag (copy_loc copy_label x0, copy_core_type x1)\n | Ast_409.Parsetree.Oinherit x0 ->\n Ast_410.Parsetree.Oinherit (copy_core_type x0)\n\nand copy_arg_label : Ast_409.Asttypes.arg_label -> Ast_410.Asttypes.arg_label =\n function\n | Ast_409.Asttypes.Nolabel -> Ast_410.Asttypes.Nolabel\n | Ast_409.Asttypes.Labelled x0 -> Ast_410.Asttypes.Labelled x0\n | Ast_409.Asttypes.Optional x0 -> Ast_410.Asttypes.Optional x0\n\nand copy_closed_flag :\n Ast_409.Asttypes.closed_flag -> Ast_410.Asttypes.closed_flag = function\n | Ast_409.Asttypes.Closed -> Ast_410.Asttypes.Closed\n | Ast_409.Asttypes.Open -> Ast_410.Asttypes.Open\n\nand copy_label : Ast_409.Asttypes.label -> Ast_410.Asttypes.label = fun x -> x\n\nand copy_rec_flag : Ast_409.Asttypes.rec_flag -> Ast_410.Asttypes.rec_flag =\n function\n | Ast_409.Asttypes.Nonrecursive -> Ast_410.Asttypes.Nonrecursive\n | Ast_409.Asttypes.Recursive -> Ast_410.Asttypes.Recursive\n\nand copy_constant : Ast_409.Parsetree.constant -> Ast_410.Parsetree.constant =\n function\n | Ast_409.Parsetree.Pconst_integer (x0, x1) ->\n Ast_410.Parsetree.Pconst_integer (x0, map_option (fun x -> x) x1)\n | Ast_409.Parsetree.Pconst_char x0 -> Ast_410.Parsetree.Pconst_char x0\n | Ast_409.Parsetree.Pconst_string (x0, x1) ->\n Ast_410.Parsetree.Pconst_string (x0, map_option (fun x -> x) x1)\n | Ast_409.Parsetree.Pconst_float (x0, x1) ->\n Ast_410.Parsetree.Pconst_float (x0, map_option (fun x -> x) x1)\n\nand copy_Longident_t : Longident.t -> Longident.t = fun x -> x\n\nand copy_loc :\n 'f0 'g0.\n ('f0 -> 'g0) -> 'f0 Ast_409.Asttypes.loc -> 'g0 Ast_410.Asttypes.loc =\n fun f0 { Ast_409.Asttypes.txt; Ast_409.Asttypes.loc } ->\n { Ast_410.Asttypes.txt = f0 txt; Ast_410.Asttypes.loc = copy_location loc }\n\nand copy_location : Location.t -> Location.t = fun x -> x\n\nlet copy_expr = copy_expression\nlet copy_pat = copy_pattern\nlet copy_typ = copy_core_type\n","open Stdlib0\nmodule From = Ast_409\nmodule To = Ast_408\n\nlet rec copy_toplevel_phrase :\n Ast_409.Parsetree.toplevel_phrase -> Ast_408.Parsetree.toplevel_phrase =\n function\n | Ast_409.Parsetree.Ptop_def x0 ->\n Ast_408.Parsetree.Ptop_def (copy_structure x0)\n | Ast_409.Parsetree.Ptop_dir x0 ->\n Ast_408.Parsetree.Ptop_dir (copy_toplevel_directive x0)\n\nand copy_toplevel_directive :\n Ast_409.Parsetree.toplevel_directive -> Ast_408.Parsetree.toplevel_directive\n =\n fun {\n Ast_409.Parsetree.pdir_name;\n Ast_409.Parsetree.pdir_arg;\n Ast_409.Parsetree.pdir_loc;\n } ->\n {\n Ast_408.Parsetree.pdir_name = copy_loc (fun x -> x) pdir_name;\n Ast_408.Parsetree.pdir_arg = Option.map copy_directive_argument pdir_arg;\n Ast_408.Parsetree.pdir_loc = copy_location pdir_loc;\n }\n\nand copy_directive_argument :\n Ast_409.Parsetree.directive_argument -> Ast_408.Parsetree.directive_argument\n =\n fun { Ast_409.Parsetree.pdira_desc; Ast_409.Parsetree.pdira_loc } ->\n {\n Ast_408.Parsetree.pdira_desc = copy_directive_argument_desc pdira_desc;\n Ast_408.Parsetree.pdira_loc = copy_location pdira_loc;\n }\n\nand copy_directive_argument_desc :\n Ast_409.Parsetree.directive_argument_desc ->\n Ast_408.Parsetree.directive_argument_desc = function\n | Ast_409.Parsetree.Pdir_string x0 -> Ast_408.Parsetree.Pdir_string x0\n | Ast_409.Parsetree.Pdir_int (x0, x1) ->\n Ast_408.Parsetree.Pdir_int (x0, Option.map (fun x -> x) x1)\n | Ast_409.Parsetree.Pdir_ident x0 ->\n Ast_408.Parsetree.Pdir_ident (copy_Longident_t x0)\n | Ast_409.Parsetree.Pdir_bool x0 -> Ast_408.Parsetree.Pdir_bool x0\n\nand copy_typ : Ast_409.Parsetree.typ -> Ast_408.Parsetree.typ =\n fun x -> copy_core_type x\n\nand copy_pat : Ast_409.Parsetree.pat -> Ast_408.Parsetree.pat =\n fun x -> copy_pattern x\n\nand copy_expr : Ast_409.Parsetree.expr -> Ast_408.Parsetree.expr =\n fun x -> copy_expression x\n\nand copy_expression :\n Ast_409.Parsetree.expression -> Ast_408.Parsetree.expression =\n fun {\n Ast_409.Parsetree.pexp_desc;\n Ast_409.Parsetree.pexp_loc;\n Ast_409.Parsetree.pexp_loc_stack;\n Ast_409.Parsetree.pexp_attributes;\n } ->\n {\n Ast_408.Parsetree.pexp_desc = copy_expression_desc pexp_desc;\n Ast_408.Parsetree.pexp_loc = copy_location pexp_loc;\n Ast_408.Parsetree.pexp_loc_stack = List.map copy_location pexp_loc_stack;\n Ast_408.Parsetree.pexp_attributes = copy_attributes pexp_attributes;\n }\n\nand copy_expression_desc :\n Ast_409.Parsetree.expression_desc -> Ast_408.Parsetree.expression_desc =\n function\n | Ast_409.Parsetree.Pexp_ident x0 ->\n Ast_408.Parsetree.Pexp_ident (copy_loc copy_Longident_t x0)\n | Ast_409.Parsetree.Pexp_constant x0 ->\n Ast_408.Parsetree.Pexp_constant (copy_constant x0)\n | Ast_409.Parsetree.Pexp_let (x0, x1, x2) ->\n Ast_408.Parsetree.Pexp_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_expression x2)\n | Ast_409.Parsetree.Pexp_function x0 ->\n Ast_408.Parsetree.Pexp_function (copy_cases x0)\n | Ast_409.Parsetree.Pexp_fun (x0, x1, x2, x3) ->\n Ast_408.Parsetree.Pexp_fun\n ( copy_arg_label x0,\n Option.map copy_expression x1,\n copy_pattern x2,\n copy_expression x3 )\n | Ast_409.Parsetree.Pexp_apply (x0, x1) ->\n Ast_408.Parsetree.Pexp_apply\n ( copy_expression x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | Ast_409.Parsetree.Pexp_match (x0, x1) ->\n Ast_408.Parsetree.Pexp_match (copy_expression x0, copy_cases x1)\n | Ast_409.Parsetree.Pexp_try (x0, x1) ->\n Ast_408.Parsetree.Pexp_try (copy_expression x0, copy_cases x1)\n | Ast_409.Parsetree.Pexp_tuple x0 ->\n Ast_408.Parsetree.Pexp_tuple (List.map copy_expression x0)\n | Ast_409.Parsetree.Pexp_construct (x0, x1) ->\n Ast_408.Parsetree.Pexp_construct\n (copy_loc copy_Longident_t x0, Option.map copy_expression x1)\n | Ast_409.Parsetree.Pexp_variant (x0, x1) ->\n Ast_408.Parsetree.Pexp_variant\n (copy_label x0, Option.map copy_expression x1)\n | Ast_409.Parsetree.Pexp_record (x0, x1) ->\n Ast_408.Parsetree.Pexp_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_expression x1))\n x0,\n Option.map copy_expression x1 )\n | Ast_409.Parsetree.Pexp_field (x0, x1) ->\n Ast_408.Parsetree.Pexp_field\n (copy_expression x0, copy_loc copy_Longident_t x1)\n | Ast_409.Parsetree.Pexp_setfield (x0, x1, x2) ->\n Ast_408.Parsetree.Pexp_setfield\n (copy_expression x0, copy_loc copy_Longident_t x1, copy_expression x2)\n | Ast_409.Parsetree.Pexp_array x0 ->\n Ast_408.Parsetree.Pexp_array (List.map copy_expression x0)\n | Ast_409.Parsetree.Pexp_ifthenelse (x0, x1, x2) ->\n Ast_408.Parsetree.Pexp_ifthenelse\n (copy_expression x0, copy_expression x1, Option.map copy_expression x2)\n | Ast_409.Parsetree.Pexp_sequence (x0, x1) ->\n Ast_408.Parsetree.Pexp_sequence (copy_expression x0, copy_expression x1)\n | Ast_409.Parsetree.Pexp_while (x0, x1) ->\n Ast_408.Parsetree.Pexp_while (copy_expression x0, copy_expression x1)\n | Ast_409.Parsetree.Pexp_for (x0, x1, x2, x3, x4) ->\n Ast_408.Parsetree.Pexp_for\n ( copy_pattern x0,\n copy_expression x1,\n copy_expression x2,\n copy_direction_flag x3,\n copy_expression x4 )\n | Ast_409.Parsetree.Pexp_constraint (x0, x1) ->\n Ast_408.Parsetree.Pexp_constraint (copy_expression x0, copy_core_type x1)\n | Ast_409.Parsetree.Pexp_coerce (x0, x1, x2) ->\n Ast_408.Parsetree.Pexp_coerce\n (copy_expression x0, Option.map copy_core_type x1, copy_core_type x2)\n | Ast_409.Parsetree.Pexp_send (x0, x1) ->\n Ast_408.Parsetree.Pexp_send (copy_expression x0, copy_loc copy_label x1)\n | Ast_409.Parsetree.Pexp_new x0 ->\n Ast_408.Parsetree.Pexp_new (copy_loc copy_Longident_t x0)\n | Ast_409.Parsetree.Pexp_setinstvar (x0, x1) ->\n Ast_408.Parsetree.Pexp_setinstvar\n (copy_loc copy_label x0, copy_expression x1)\n | Ast_409.Parsetree.Pexp_override x0 ->\n Ast_408.Parsetree.Pexp_override\n (List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_label x0, copy_expression x1))\n x0)\n | Ast_409.Parsetree.Pexp_letmodule (x0, x1, x2) ->\n Ast_408.Parsetree.Pexp_letmodule\n (copy_loc (fun x -> x) x0, copy_module_expr x1, copy_expression x2)\n | Ast_409.Parsetree.Pexp_letexception (x0, x1) ->\n Ast_408.Parsetree.Pexp_letexception\n (copy_extension_constructor x0, copy_expression x1)\n | Ast_409.Parsetree.Pexp_assert x0 ->\n Ast_408.Parsetree.Pexp_assert (copy_expression x0)\n | Ast_409.Parsetree.Pexp_lazy x0 ->\n Ast_408.Parsetree.Pexp_lazy (copy_expression x0)\n | Ast_409.Parsetree.Pexp_poly (x0, x1) ->\n Ast_408.Parsetree.Pexp_poly\n (copy_expression x0, Option.map copy_core_type x1)\n | Ast_409.Parsetree.Pexp_object x0 ->\n Ast_408.Parsetree.Pexp_object (copy_class_structure x0)\n | Ast_409.Parsetree.Pexp_newtype (x0, x1) ->\n Ast_408.Parsetree.Pexp_newtype\n (copy_loc (fun x -> x) x0, copy_expression x1)\n | Ast_409.Parsetree.Pexp_pack x0 ->\n Ast_408.Parsetree.Pexp_pack (copy_module_expr x0)\n | Ast_409.Parsetree.Pexp_open (x0, x1) ->\n Ast_408.Parsetree.Pexp_open (copy_open_declaration x0, copy_expression x1)\n | Ast_409.Parsetree.Pexp_letop x0 ->\n Ast_408.Parsetree.Pexp_letop (copy_letop x0)\n | Ast_409.Parsetree.Pexp_extension x0 ->\n Ast_408.Parsetree.Pexp_extension (copy_extension x0)\n | Ast_409.Parsetree.Pexp_unreachable -> Ast_408.Parsetree.Pexp_unreachable\n\nand copy_letop : Ast_409.Parsetree.letop -> Ast_408.Parsetree.letop =\n fun { Ast_409.Parsetree.let_; Ast_409.Parsetree.ands; Ast_409.Parsetree.body } ->\n {\n Ast_408.Parsetree.let_ = copy_binding_op let_;\n Ast_408.Parsetree.ands = List.map copy_binding_op ands;\n Ast_408.Parsetree.body = copy_expression body;\n }\n\nand copy_binding_op :\n Ast_409.Parsetree.binding_op -> Ast_408.Parsetree.binding_op =\n fun {\n Ast_409.Parsetree.pbop_op;\n Ast_409.Parsetree.pbop_pat;\n Ast_409.Parsetree.pbop_exp;\n Ast_409.Parsetree.pbop_loc;\n } ->\n {\n Ast_408.Parsetree.pbop_op = copy_loc (fun x -> x) pbop_op;\n Ast_408.Parsetree.pbop_pat = copy_pattern pbop_pat;\n Ast_408.Parsetree.pbop_exp = copy_expression pbop_exp;\n Ast_408.Parsetree.pbop_loc = copy_location pbop_loc;\n }\n\nand copy_direction_flag :\n Ast_409.Asttypes.direction_flag -> Ast_408.Asttypes.direction_flag =\n function\n | Ast_409.Asttypes.Upto -> Ast_408.Asttypes.Upto\n | Ast_409.Asttypes.Downto -> Ast_408.Asttypes.Downto\n\nand copy_cases : Ast_409.Parsetree.cases -> Ast_408.Parsetree.cases =\n fun x -> List.map copy_case x\n\nand copy_case : Ast_409.Parsetree.case -> Ast_408.Parsetree.case =\n fun {\n Ast_409.Parsetree.pc_lhs;\n Ast_409.Parsetree.pc_guard;\n Ast_409.Parsetree.pc_rhs;\n } ->\n {\n Ast_408.Parsetree.pc_lhs = copy_pattern pc_lhs;\n Ast_408.Parsetree.pc_guard = Option.map copy_expression pc_guard;\n Ast_408.Parsetree.pc_rhs = copy_expression pc_rhs;\n }\n\nand copy_value_binding :\n Ast_409.Parsetree.value_binding -> Ast_408.Parsetree.value_binding =\n fun {\n Ast_409.Parsetree.pvb_pat;\n Ast_409.Parsetree.pvb_expr;\n Ast_409.Parsetree.pvb_attributes;\n Ast_409.Parsetree.pvb_loc;\n } ->\n {\n Ast_408.Parsetree.pvb_pat = copy_pattern pvb_pat;\n Ast_408.Parsetree.pvb_expr = copy_expression pvb_expr;\n Ast_408.Parsetree.pvb_attributes = copy_attributes pvb_attributes;\n Ast_408.Parsetree.pvb_loc = copy_location pvb_loc;\n }\n\nand copy_pattern : Ast_409.Parsetree.pattern -> Ast_408.Parsetree.pattern =\n fun {\n Ast_409.Parsetree.ppat_desc;\n Ast_409.Parsetree.ppat_loc;\n Ast_409.Parsetree.ppat_loc_stack;\n Ast_409.Parsetree.ppat_attributes;\n } ->\n {\n Ast_408.Parsetree.ppat_desc = copy_pattern_desc ppat_desc;\n Ast_408.Parsetree.ppat_loc = copy_location ppat_loc;\n Ast_408.Parsetree.ppat_loc_stack = List.map copy_location ppat_loc_stack;\n Ast_408.Parsetree.ppat_attributes = copy_attributes ppat_attributes;\n }\n\nand copy_pattern_desc :\n Ast_409.Parsetree.pattern_desc -> Ast_408.Parsetree.pattern_desc = function\n | Ast_409.Parsetree.Ppat_any -> Ast_408.Parsetree.Ppat_any\n | Ast_409.Parsetree.Ppat_var x0 ->\n Ast_408.Parsetree.Ppat_var (copy_loc (fun x -> x) x0)\n | Ast_409.Parsetree.Ppat_alias (x0, x1) ->\n Ast_408.Parsetree.Ppat_alias (copy_pattern x0, copy_loc (fun x -> x) x1)\n | Ast_409.Parsetree.Ppat_constant x0 ->\n Ast_408.Parsetree.Ppat_constant (copy_constant x0)\n | Ast_409.Parsetree.Ppat_interval (x0, x1) ->\n Ast_408.Parsetree.Ppat_interval (copy_constant x0, copy_constant x1)\n | Ast_409.Parsetree.Ppat_tuple x0 ->\n Ast_408.Parsetree.Ppat_tuple (List.map copy_pattern x0)\n | Ast_409.Parsetree.Ppat_construct (x0, x1) ->\n Ast_408.Parsetree.Ppat_construct\n (copy_loc copy_Longident_t x0, Option.map copy_pattern x1)\n | Ast_409.Parsetree.Ppat_variant (x0, x1) ->\n Ast_408.Parsetree.Ppat_variant (copy_label x0, Option.map copy_pattern x1)\n | Ast_409.Parsetree.Ppat_record (x0, x1) ->\n Ast_408.Parsetree.Ppat_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_pattern x1))\n x0,\n copy_closed_flag x1 )\n | Ast_409.Parsetree.Ppat_array x0 ->\n Ast_408.Parsetree.Ppat_array (List.map copy_pattern x0)\n | Ast_409.Parsetree.Ppat_or (x0, x1) ->\n Ast_408.Parsetree.Ppat_or (copy_pattern x0, copy_pattern x1)\n | Ast_409.Parsetree.Ppat_constraint (x0, x1) ->\n Ast_408.Parsetree.Ppat_constraint (copy_pattern x0, copy_core_type x1)\n | Ast_409.Parsetree.Ppat_type x0 ->\n Ast_408.Parsetree.Ppat_type (copy_loc copy_Longident_t x0)\n | Ast_409.Parsetree.Ppat_lazy x0 ->\n Ast_408.Parsetree.Ppat_lazy (copy_pattern x0)\n | Ast_409.Parsetree.Ppat_unpack x0 ->\n Ast_408.Parsetree.Ppat_unpack (copy_loc (fun x -> x) x0)\n | Ast_409.Parsetree.Ppat_exception x0 ->\n Ast_408.Parsetree.Ppat_exception (copy_pattern x0)\n | Ast_409.Parsetree.Ppat_extension x0 ->\n Ast_408.Parsetree.Ppat_extension (copy_extension x0)\n | Ast_409.Parsetree.Ppat_open (x0, x1) ->\n Ast_408.Parsetree.Ppat_open (copy_loc copy_Longident_t x0, copy_pattern x1)\n\nand copy_core_type : Ast_409.Parsetree.core_type -> Ast_408.Parsetree.core_type\n =\n fun {\n Ast_409.Parsetree.ptyp_desc;\n Ast_409.Parsetree.ptyp_loc;\n Ast_409.Parsetree.ptyp_loc_stack;\n Ast_409.Parsetree.ptyp_attributes;\n } ->\n {\n Ast_408.Parsetree.ptyp_desc = copy_core_type_desc ptyp_desc;\n Ast_408.Parsetree.ptyp_loc = copy_location ptyp_loc;\n Ast_408.Parsetree.ptyp_loc_stack = List.map copy_location ptyp_loc_stack;\n Ast_408.Parsetree.ptyp_attributes = copy_attributes ptyp_attributes;\n }\n\nand copy_core_type_desc :\n Ast_409.Parsetree.core_type_desc -> Ast_408.Parsetree.core_type_desc =\n function\n | Ast_409.Parsetree.Ptyp_any -> Ast_408.Parsetree.Ptyp_any\n | Ast_409.Parsetree.Ptyp_var x0 -> Ast_408.Parsetree.Ptyp_var x0\n | Ast_409.Parsetree.Ptyp_arrow (x0, x1, x2) ->\n Ast_408.Parsetree.Ptyp_arrow\n (copy_arg_label x0, copy_core_type x1, copy_core_type x2)\n | Ast_409.Parsetree.Ptyp_tuple x0 ->\n Ast_408.Parsetree.Ptyp_tuple (List.map copy_core_type x0)\n | Ast_409.Parsetree.Ptyp_constr (x0, x1) ->\n Ast_408.Parsetree.Ptyp_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_409.Parsetree.Ptyp_object (x0, x1) ->\n Ast_408.Parsetree.Ptyp_object\n (List.map copy_object_field x0, copy_closed_flag x1)\n | Ast_409.Parsetree.Ptyp_class (x0, x1) ->\n Ast_408.Parsetree.Ptyp_class\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_409.Parsetree.Ptyp_alias (x0, x1) ->\n Ast_408.Parsetree.Ptyp_alias (copy_core_type x0, x1)\n | Ast_409.Parsetree.Ptyp_variant (x0, x1, x2) ->\n Ast_408.Parsetree.Ptyp_variant\n ( List.map copy_row_field x0,\n copy_closed_flag x1,\n Option.map (fun x -> List.map copy_label x) x2 )\n | Ast_409.Parsetree.Ptyp_poly (x0, x1) ->\n Ast_408.Parsetree.Ptyp_poly\n (List.map (fun x -> copy_loc (fun x -> x) x) x0, copy_core_type x1)\n | Ast_409.Parsetree.Ptyp_package x0 ->\n Ast_408.Parsetree.Ptyp_package (copy_package_type x0)\n | Ast_409.Parsetree.Ptyp_extension x0 ->\n Ast_408.Parsetree.Ptyp_extension (copy_extension x0)\n\nand copy_package_type :\n Ast_409.Parsetree.package_type -> Ast_408.Parsetree.package_type =\n fun x ->\n let x0, x1 = x in\n ( copy_loc copy_Longident_t x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_core_type x1))\n x1 )\n\nand copy_row_field : Ast_409.Parsetree.row_field -> Ast_408.Parsetree.row_field\n =\n fun {\n Ast_409.Parsetree.prf_desc;\n Ast_409.Parsetree.prf_loc;\n Ast_409.Parsetree.prf_attributes;\n } ->\n {\n Ast_408.Parsetree.prf_desc = copy_row_field_desc prf_desc;\n Ast_408.Parsetree.prf_loc = copy_location prf_loc;\n Ast_408.Parsetree.prf_attributes = copy_attributes prf_attributes;\n }\n\nand copy_row_field_desc :\n Ast_409.Parsetree.row_field_desc -> Ast_408.Parsetree.row_field_desc =\n function\n | Ast_409.Parsetree.Rtag (x0, x1, x2) ->\n Ast_408.Parsetree.Rtag\n (copy_loc copy_label x0, x1, List.map copy_core_type x2)\n | Ast_409.Parsetree.Rinherit x0 ->\n Ast_408.Parsetree.Rinherit (copy_core_type x0)\n\nand copy_object_field :\n Ast_409.Parsetree.object_field -> Ast_408.Parsetree.object_field =\n fun {\n Ast_409.Parsetree.pof_desc;\n Ast_409.Parsetree.pof_loc;\n Ast_409.Parsetree.pof_attributes;\n } ->\n {\n Ast_408.Parsetree.pof_desc = copy_object_field_desc pof_desc;\n Ast_408.Parsetree.pof_loc = copy_location pof_loc;\n Ast_408.Parsetree.pof_attributes = copy_attributes pof_attributes;\n }\n\nand copy_attributes :\n Ast_409.Parsetree.attributes -> Ast_408.Parsetree.attributes =\n fun x -> List.map copy_attribute x\n\nand copy_attribute : Ast_409.Parsetree.attribute -> Ast_408.Parsetree.attribute\n =\n fun {\n Ast_409.Parsetree.attr_name;\n Ast_409.Parsetree.attr_payload;\n Ast_409.Parsetree.attr_loc;\n } ->\n {\n Ast_408.Parsetree.attr_name = copy_loc (fun x -> x) attr_name;\n Ast_408.Parsetree.attr_payload = copy_payload attr_payload;\n Ast_408.Parsetree.attr_loc = copy_location attr_loc;\n }\n\nand copy_payload : Ast_409.Parsetree.payload -> Ast_408.Parsetree.payload =\n function\n | Ast_409.Parsetree.PStr x0 -> Ast_408.Parsetree.PStr (copy_structure x0)\n | Ast_409.Parsetree.PSig x0 -> Ast_408.Parsetree.PSig (copy_signature x0)\n | Ast_409.Parsetree.PTyp x0 -> Ast_408.Parsetree.PTyp (copy_core_type x0)\n | Ast_409.Parsetree.PPat (x0, x1) ->\n Ast_408.Parsetree.PPat (copy_pattern x0, Option.map copy_expression x1)\n\nand copy_structure : Ast_409.Parsetree.structure -> Ast_408.Parsetree.structure\n =\n fun x -> List.map copy_structure_item x\n\nand copy_structure_item :\n Ast_409.Parsetree.structure_item -> Ast_408.Parsetree.structure_item =\n fun { Ast_409.Parsetree.pstr_desc; Ast_409.Parsetree.pstr_loc } ->\n {\n Ast_408.Parsetree.pstr_desc = copy_structure_item_desc pstr_desc;\n Ast_408.Parsetree.pstr_loc = copy_location pstr_loc;\n }\n\nand copy_structure_item_desc :\n Ast_409.Parsetree.structure_item_desc ->\n Ast_408.Parsetree.structure_item_desc = function\n | Ast_409.Parsetree.Pstr_eval (x0, x1) ->\n Ast_408.Parsetree.Pstr_eval (copy_expression x0, copy_attributes x1)\n | Ast_409.Parsetree.Pstr_value (x0, x1) ->\n Ast_408.Parsetree.Pstr_value\n (copy_rec_flag x0, List.map copy_value_binding x1)\n | Ast_409.Parsetree.Pstr_primitive x0 ->\n Ast_408.Parsetree.Pstr_primitive (copy_value_description x0)\n | Ast_409.Parsetree.Pstr_type (x0, x1) ->\n Ast_408.Parsetree.Pstr_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | Ast_409.Parsetree.Pstr_typext x0 ->\n Ast_408.Parsetree.Pstr_typext (copy_type_extension x0)\n | Ast_409.Parsetree.Pstr_exception x0 ->\n Ast_408.Parsetree.Pstr_exception (copy_type_exception x0)\n | Ast_409.Parsetree.Pstr_module x0 ->\n Ast_408.Parsetree.Pstr_module (copy_module_binding x0)\n | Ast_409.Parsetree.Pstr_recmodule x0 ->\n Ast_408.Parsetree.Pstr_recmodule (List.map copy_module_binding x0)\n | Ast_409.Parsetree.Pstr_modtype x0 ->\n Ast_408.Parsetree.Pstr_modtype (copy_module_type_declaration x0)\n | Ast_409.Parsetree.Pstr_open x0 ->\n Ast_408.Parsetree.Pstr_open (copy_open_declaration x0)\n | Ast_409.Parsetree.Pstr_class x0 ->\n Ast_408.Parsetree.Pstr_class (List.map copy_class_declaration x0)\n | Ast_409.Parsetree.Pstr_class_type x0 ->\n Ast_408.Parsetree.Pstr_class_type\n (List.map copy_class_type_declaration x0)\n | Ast_409.Parsetree.Pstr_include x0 ->\n Ast_408.Parsetree.Pstr_include (copy_include_declaration x0)\n | Ast_409.Parsetree.Pstr_attribute x0 ->\n Ast_408.Parsetree.Pstr_attribute (copy_attribute x0)\n | Ast_409.Parsetree.Pstr_extension (x0, x1) ->\n Ast_408.Parsetree.Pstr_extension (copy_extension x0, copy_attributes x1)\n\nand copy_include_declaration :\n Ast_409.Parsetree.include_declaration ->\n Ast_408.Parsetree.include_declaration =\n fun x -> copy_include_infos copy_module_expr x\n\nand copy_class_declaration :\n Ast_409.Parsetree.class_declaration -> Ast_408.Parsetree.class_declaration =\n fun x -> copy_class_infos copy_class_expr x\n\nand copy_class_expr :\n Ast_409.Parsetree.class_expr -> Ast_408.Parsetree.class_expr =\n fun {\n Ast_409.Parsetree.pcl_desc;\n Ast_409.Parsetree.pcl_loc;\n Ast_409.Parsetree.pcl_attributes;\n } ->\n {\n Ast_408.Parsetree.pcl_desc = copy_class_expr_desc pcl_desc;\n Ast_408.Parsetree.pcl_loc = copy_location pcl_loc;\n Ast_408.Parsetree.pcl_attributes = copy_attributes pcl_attributes;\n }\n\nand copy_class_expr_desc :\n Ast_409.Parsetree.class_expr_desc -> Ast_408.Parsetree.class_expr_desc =\n function\n | Ast_409.Parsetree.Pcl_constr (x0, x1) ->\n Ast_408.Parsetree.Pcl_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_409.Parsetree.Pcl_structure x0 ->\n Ast_408.Parsetree.Pcl_structure (copy_class_structure x0)\n | Ast_409.Parsetree.Pcl_fun (x0, x1, x2, x3) ->\n Ast_408.Parsetree.Pcl_fun\n ( copy_arg_label x0,\n Option.map copy_expression x1,\n copy_pattern x2,\n copy_class_expr x3 )\n | Ast_409.Parsetree.Pcl_apply (x0, x1) ->\n Ast_408.Parsetree.Pcl_apply\n ( copy_class_expr x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | Ast_409.Parsetree.Pcl_let (x0, x1, x2) ->\n Ast_408.Parsetree.Pcl_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_class_expr x2)\n | Ast_409.Parsetree.Pcl_constraint (x0, x1) ->\n Ast_408.Parsetree.Pcl_constraint (copy_class_expr x0, copy_class_type x1)\n | Ast_409.Parsetree.Pcl_extension x0 ->\n Ast_408.Parsetree.Pcl_extension (copy_extension x0)\n | Ast_409.Parsetree.Pcl_open (x0, x1) ->\n Ast_408.Parsetree.Pcl_open (copy_open_description x0, copy_class_expr x1)\n\nand copy_class_structure :\n Ast_409.Parsetree.class_structure -> Ast_408.Parsetree.class_structure =\n fun { Ast_409.Parsetree.pcstr_self; Ast_409.Parsetree.pcstr_fields } ->\n {\n Ast_408.Parsetree.pcstr_self = copy_pattern pcstr_self;\n Ast_408.Parsetree.pcstr_fields = List.map copy_class_field pcstr_fields;\n }\n\nand copy_class_field :\n Ast_409.Parsetree.class_field -> Ast_408.Parsetree.class_field =\n fun {\n Ast_409.Parsetree.pcf_desc;\n Ast_409.Parsetree.pcf_loc;\n Ast_409.Parsetree.pcf_attributes;\n } ->\n {\n Ast_408.Parsetree.pcf_desc = copy_class_field_desc pcf_desc;\n Ast_408.Parsetree.pcf_loc = copy_location pcf_loc;\n Ast_408.Parsetree.pcf_attributes = copy_attributes pcf_attributes;\n }\n\nand copy_class_field_desc :\n Ast_409.Parsetree.class_field_desc -> Ast_408.Parsetree.class_field_desc =\n function\n | Ast_409.Parsetree.Pcf_inherit (x0, x1, x2) ->\n Ast_408.Parsetree.Pcf_inherit\n ( copy_override_flag x0,\n copy_class_expr x1,\n Option.map (fun x -> copy_loc (fun x -> x) x) x2 )\n | Ast_409.Parsetree.Pcf_val x0 ->\n Ast_408.Parsetree.Pcf_val\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_mutable_flag x1, copy_class_field_kind x2))\n | Ast_409.Parsetree.Pcf_method x0 ->\n Ast_408.Parsetree.Pcf_method\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_private_flag x1, copy_class_field_kind x2))\n | Ast_409.Parsetree.Pcf_constraint x0 ->\n Ast_408.Parsetree.Pcf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | Ast_409.Parsetree.Pcf_initializer x0 ->\n Ast_408.Parsetree.Pcf_initializer (copy_expression x0)\n | Ast_409.Parsetree.Pcf_attribute x0 ->\n Ast_408.Parsetree.Pcf_attribute (copy_attribute x0)\n | Ast_409.Parsetree.Pcf_extension x0 ->\n Ast_408.Parsetree.Pcf_extension (copy_extension x0)\n\nand copy_class_field_kind :\n Ast_409.Parsetree.class_field_kind -> Ast_408.Parsetree.class_field_kind =\n function\n | Ast_409.Parsetree.Cfk_virtual x0 ->\n Ast_408.Parsetree.Cfk_virtual (copy_core_type x0)\n | Ast_409.Parsetree.Cfk_concrete (x0, x1) ->\n Ast_408.Parsetree.Cfk_concrete (copy_override_flag x0, copy_expression x1)\n\nand copy_open_declaration :\n Ast_409.Parsetree.open_declaration -> Ast_408.Parsetree.open_declaration =\n fun x -> copy_open_infos copy_module_expr x\n\nand copy_module_binding :\n Ast_409.Parsetree.module_binding -> Ast_408.Parsetree.module_binding =\n fun {\n Ast_409.Parsetree.pmb_name;\n Ast_409.Parsetree.pmb_expr;\n Ast_409.Parsetree.pmb_attributes;\n Ast_409.Parsetree.pmb_loc;\n } ->\n {\n Ast_408.Parsetree.pmb_name = copy_loc (fun x -> x) pmb_name;\n Ast_408.Parsetree.pmb_expr = copy_module_expr pmb_expr;\n Ast_408.Parsetree.pmb_attributes = copy_attributes pmb_attributes;\n Ast_408.Parsetree.pmb_loc = copy_location pmb_loc;\n }\n\nand copy_module_expr :\n Ast_409.Parsetree.module_expr -> Ast_408.Parsetree.module_expr =\n fun {\n Ast_409.Parsetree.pmod_desc;\n Ast_409.Parsetree.pmod_loc;\n Ast_409.Parsetree.pmod_attributes;\n } ->\n {\n Ast_408.Parsetree.pmod_desc = copy_module_expr_desc pmod_desc;\n Ast_408.Parsetree.pmod_loc = copy_location pmod_loc;\n Ast_408.Parsetree.pmod_attributes = copy_attributes pmod_attributes;\n }\n\nand copy_module_expr_desc :\n Ast_409.Parsetree.module_expr_desc -> Ast_408.Parsetree.module_expr_desc =\n function\n | Ast_409.Parsetree.Pmod_ident x0 ->\n Ast_408.Parsetree.Pmod_ident (copy_loc copy_Longident_t x0)\n | Ast_409.Parsetree.Pmod_structure x0 ->\n Ast_408.Parsetree.Pmod_structure (copy_structure x0)\n | Ast_409.Parsetree.Pmod_functor (x0, x1, x2) ->\n Ast_408.Parsetree.Pmod_functor\n ( copy_loc (fun x -> x) x0,\n Option.map copy_module_type x1,\n copy_module_expr x2 )\n | Ast_409.Parsetree.Pmod_apply (x0, x1) ->\n Ast_408.Parsetree.Pmod_apply (copy_module_expr x0, copy_module_expr x1)\n | Ast_409.Parsetree.Pmod_constraint (x0, x1) ->\n Ast_408.Parsetree.Pmod_constraint\n (copy_module_expr x0, copy_module_type x1)\n | Ast_409.Parsetree.Pmod_unpack x0 ->\n Ast_408.Parsetree.Pmod_unpack (copy_expression x0)\n | Ast_409.Parsetree.Pmod_extension x0 ->\n Ast_408.Parsetree.Pmod_extension (copy_extension x0)\n\nand copy_module_type :\n Ast_409.Parsetree.module_type -> Ast_408.Parsetree.module_type =\n fun {\n Ast_409.Parsetree.pmty_desc;\n Ast_409.Parsetree.pmty_loc;\n Ast_409.Parsetree.pmty_attributes;\n } ->\n {\n Ast_408.Parsetree.pmty_desc = copy_module_type_desc pmty_desc;\n Ast_408.Parsetree.pmty_loc = copy_location pmty_loc;\n Ast_408.Parsetree.pmty_attributes = copy_attributes pmty_attributes;\n }\n\nand copy_module_type_desc :\n Ast_409.Parsetree.module_type_desc -> Ast_408.Parsetree.module_type_desc =\n function\n | Ast_409.Parsetree.Pmty_ident x0 ->\n Ast_408.Parsetree.Pmty_ident (copy_loc copy_Longident_t x0)\n | Ast_409.Parsetree.Pmty_signature x0 ->\n Ast_408.Parsetree.Pmty_signature (copy_signature x0)\n | Ast_409.Parsetree.Pmty_functor (x0, x1, x2) ->\n Ast_408.Parsetree.Pmty_functor\n ( copy_loc (fun x -> x) x0,\n Option.map copy_module_type x1,\n copy_module_type x2 )\n | Ast_409.Parsetree.Pmty_with (x0, x1) ->\n Ast_408.Parsetree.Pmty_with\n (copy_module_type x0, List.map copy_with_constraint x1)\n | Ast_409.Parsetree.Pmty_typeof x0 ->\n Ast_408.Parsetree.Pmty_typeof (copy_module_expr x0)\n | Ast_409.Parsetree.Pmty_extension x0 ->\n Ast_408.Parsetree.Pmty_extension (copy_extension x0)\n | Ast_409.Parsetree.Pmty_alias x0 ->\n Ast_408.Parsetree.Pmty_alias (copy_loc copy_Longident_t x0)\n\nand copy_with_constraint :\n Ast_409.Parsetree.with_constraint -> Ast_408.Parsetree.with_constraint =\n function\n | Ast_409.Parsetree.Pwith_type (x0, x1) ->\n Ast_408.Parsetree.Pwith_type\n (copy_loc copy_Longident_t x0, copy_type_declaration x1)\n | Ast_409.Parsetree.Pwith_module (x0, x1) ->\n Ast_408.Parsetree.Pwith_module\n (copy_loc copy_Longident_t x0, copy_loc copy_Longident_t x1)\n | Ast_409.Parsetree.Pwith_typesubst (x0, x1) ->\n Ast_408.Parsetree.Pwith_typesubst\n (copy_loc copy_Longident_t x0, copy_type_declaration x1)\n | Ast_409.Parsetree.Pwith_modsubst (x0, x1) ->\n Ast_408.Parsetree.Pwith_modsubst\n (copy_loc copy_Longident_t x0, copy_loc copy_Longident_t x1)\n\nand copy_signature : Ast_409.Parsetree.signature -> Ast_408.Parsetree.signature\n =\n fun x -> List.map copy_signature_item x\n\nand copy_signature_item :\n Ast_409.Parsetree.signature_item -> Ast_408.Parsetree.signature_item =\n fun { Ast_409.Parsetree.psig_desc; Ast_409.Parsetree.psig_loc } ->\n {\n Ast_408.Parsetree.psig_desc = copy_signature_item_desc psig_desc;\n Ast_408.Parsetree.psig_loc = copy_location psig_loc;\n }\n\nand copy_signature_item_desc :\n Ast_409.Parsetree.signature_item_desc ->\n Ast_408.Parsetree.signature_item_desc = function\n | Ast_409.Parsetree.Psig_value x0 ->\n Ast_408.Parsetree.Psig_value (copy_value_description x0)\n | Ast_409.Parsetree.Psig_type (x0, x1) ->\n Ast_408.Parsetree.Psig_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | Ast_409.Parsetree.Psig_typesubst x0 ->\n Ast_408.Parsetree.Psig_typesubst (List.map copy_type_declaration x0)\n | Ast_409.Parsetree.Psig_typext x0 ->\n Ast_408.Parsetree.Psig_typext (copy_type_extension x0)\n | Ast_409.Parsetree.Psig_exception x0 ->\n Ast_408.Parsetree.Psig_exception (copy_type_exception x0)\n | Ast_409.Parsetree.Psig_module x0 ->\n Ast_408.Parsetree.Psig_module (copy_module_declaration x0)\n | Ast_409.Parsetree.Psig_modsubst x0 ->\n Ast_408.Parsetree.Psig_modsubst (copy_module_substitution x0)\n | Ast_409.Parsetree.Psig_recmodule x0 ->\n Ast_408.Parsetree.Psig_recmodule (List.map copy_module_declaration x0)\n | Ast_409.Parsetree.Psig_modtype x0 ->\n Ast_408.Parsetree.Psig_modtype (copy_module_type_declaration x0)\n | Ast_409.Parsetree.Psig_open x0 ->\n Ast_408.Parsetree.Psig_open (copy_open_description x0)\n | Ast_409.Parsetree.Psig_include x0 ->\n Ast_408.Parsetree.Psig_include (copy_include_description x0)\n | Ast_409.Parsetree.Psig_class x0 ->\n Ast_408.Parsetree.Psig_class (List.map copy_class_description x0)\n | Ast_409.Parsetree.Psig_class_type x0 ->\n Ast_408.Parsetree.Psig_class_type\n (List.map copy_class_type_declaration x0)\n | Ast_409.Parsetree.Psig_attribute x0 ->\n Ast_408.Parsetree.Psig_attribute (copy_attribute x0)\n | Ast_409.Parsetree.Psig_extension (x0, x1) ->\n Ast_408.Parsetree.Psig_extension (copy_extension x0, copy_attributes x1)\n\nand copy_class_type_declaration :\n Ast_409.Parsetree.class_type_declaration ->\n Ast_408.Parsetree.class_type_declaration =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_description :\n Ast_409.Parsetree.class_description -> Ast_408.Parsetree.class_description =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_type :\n Ast_409.Parsetree.class_type -> Ast_408.Parsetree.class_type =\n fun {\n Ast_409.Parsetree.pcty_desc;\n Ast_409.Parsetree.pcty_loc;\n Ast_409.Parsetree.pcty_attributes;\n } ->\n {\n Ast_408.Parsetree.pcty_desc = copy_class_type_desc pcty_desc;\n Ast_408.Parsetree.pcty_loc = copy_location pcty_loc;\n Ast_408.Parsetree.pcty_attributes = copy_attributes pcty_attributes;\n }\n\nand copy_class_type_desc :\n Ast_409.Parsetree.class_type_desc -> Ast_408.Parsetree.class_type_desc =\n function\n | Ast_409.Parsetree.Pcty_constr (x0, x1) ->\n Ast_408.Parsetree.Pcty_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_409.Parsetree.Pcty_signature x0 ->\n Ast_408.Parsetree.Pcty_signature (copy_class_signature x0)\n | Ast_409.Parsetree.Pcty_arrow (x0, x1, x2) ->\n Ast_408.Parsetree.Pcty_arrow\n (copy_arg_label x0, copy_core_type x1, copy_class_type x2)\n | Ast_409.Parsetree.Pcty_extension x0 ->\n Ast_408.Parsetree.Pcty_extension (copy_extension x0)\n | Ast_409.Parsetree.Pcty_open (x0, x1) ->\n Ast_408.Parsetree.Pcty_open (copy_open_description x0, copy_class_type x1)\n\nand copy_class_signature :\n Ast_409.Parsetree.class_signature -> Ast_408.Parsetree.class_signature =\n fun { Ast_409.Parsetree.pcsig_self; Ast_409.Parsetree.pcsig_fields } ->\n {\n Ast_408.Parsetree.pcsig_self = copy_core_type pcsig_self;\n Ast_408.Parsetree.pcsig_fields = List.map copy_class_type_field pcsig_fields;\n }\n\nand copy_class_type_field :\n Ast_409.Parsetree.class_type_field -> Ast_408.Parsetree.class_type_field =\n fun {\n Ast_409.Parsetree.pctf_desc;\n Ast_409.Parsetree.pctf_loc;\n Ast_409.Parsetree.pctf_attributes;\n } ->\n {\n Ast_408.Parsetree.pctf_desc = copy_class_type_field_desc pctf_desc;\n Ast_408.Parsetree.pctf_loc = copy_location pctf_loc;\n Ast_408.Parsetree.pctf_attributes = copy_attributes pctf_attributes;\n }\n\nand copy_class_type_field_desc :\n Ast_409.Parsetree.class_type_field_desc ->\n Ast_408.Parsetree.class_type_field_desc = function\n | Ast_409.Parsetree.Pctf_inherit x0 ->\n Ast_408.Parsetree.Pctf_inherit (copy_class_type x0)\n | Ast_409.Parsetree.Pctf_val x0 ->\n Ast_408.Parsetree.Pctf_val\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_mutable_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | Ast_409.Parsetree.Pctf_method x0 ->\n Ast_408.Parsetree.Pctf_method\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_private_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | Ast_409.Parsetree.Pctf_constraint x0 ->\n Ast_408.Parsetree.Pctf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | Ast_409.Parsetree.Pctf_attribute x0 ->\n Ast_408.Parsetree.Pctf_attribute (copy_attribute x0)\n | Ast_409.Parsetree.Pctf_extension x0 ->\n Ast_408.Parsetree.Pctf_extension (copy_extension x0)\n\nand copy_extension : Ast_409.Parsetree.extension -> Ast_408.Parsetree.extension\n =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_class_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_409.Parsetree.class_infos ->\n 'g0 Ast_408.Parsetree.class_infos =\n fun f0\n {\n Ast_409.Parsetree.pci_virt;\n Ast_409.Parsetree.pci_params;\n Ast_409.Parsetree.pci_name;\n Ast_409.Parsetree.pci_expr;\n Ast_409.Parsetree.pci_loc;\n Ast_409.Parsetree.pci_attributes;\n } ->\n {\n Ast_408.Parsetree.pci_virt = copy_virtual_flag pci_virt;\n Ast_408.Parsetree.pci_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n pci_params;\n Ast_408.Parsetree.pci_name = copy_loc (fun x -> x) pci_name;\n Ast_408.Parsetree.pci_expr = f0 pci_expr;\n Ast_408.Parsetree.pci_loc = copy_location pci_loc;\n Ast_408.Parsetree.pci_attributes = copy_attributes pci_attributes;\n }\n\nand copy_virtual_flag :\n Ast_409.Asttypes.virtual_flag -> Ast_408.Asttypes.virtual_flag = function\n | Ast_409.Asttypes.Virtual -> Ast_408.Asttypes.Virtual\n | Ast_409.Asttypes.Concrete -> Ast_408.Asttypes.Concrete\n\nand copy_include_description :\n Ast_409.Parsetree.include_description ->\n Ast_408.Parsetree.include_description =\n fun x -> copy_include_infos copy_module_type x\n\nand copy_include_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_409.Parsetree.include_infos ->\n 'g0 Ast_408.Parsetree.include_infos =\n fun f0\n {\n Ast_409.Parsetree.pincl_mod;\n Ast_409.Parsetree.pincl_loc;\n Ast_409.Parsetree.pincl_attributes;\n } ->\n {\n Ast_408.Parsetree.pincl_mod = f0 pincl_mod;\n Ast_408.Parsetree.pincl_loc = copy_location pincl_loc;\n Ast_408.Parsetree.pincl_attributes = copy_attributes pincl_attributes;\n }\n\nand copy_open_description :\n Ast_409.Parsetree.open_description -> Ast_408.Parsetree.open_description =\n fun x -> copy_open_infos (fun x -> copy_loc copy_Longident_t x) x\n\nand copy_open_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_409.Parsetree.open_infos ->\n 'g0 Ast_408.Parsetree.open_infos =\n fun f0\n {\n Ast_409.Parsetree.popen_expr;\n Ast_409.Parsetree.popen_override;\n Ast_409.Parsetree.popen_loc;\n Ast_409.Parsetree.popen_attributes;\n } ->\n {\n Ast_408.Parsetree.popen_expr = f0 popen_expr;\n Ast_408.Parsetree.popen_override = copy_override_flag popen_override;\n Ast_408.Parsetree.popen_loc = copy_location popen_loc;\n Ast_408.Parsetree.popen_attributes = copy_attributes popen_attributes;\n }\n\nand copy_override_flag :\n Ast_409.Asttypes.override_flag -> Ast_408.Asttypes.override_flag = function\n | Ast_409.Asttypes.Override -> Ast_408.Asttypes.Override\n | Ast_409.Asttypes.Fresh -> Ast_408.Asttypes.Fresh\n\nand copy_module_type_declaration :\n Ast_409.Parsetree.module_type_declaration ->\n Ast_408.Parsetree.module_type_declaration =\n fun {\n Ast_409.Parsetree.pmtd_name;\n Ast_409.Parsetree.pmtd_type;\n Ast_409.Parsetree.pmtd_attributes;\n Ast_409.Parsetree.pmtd_loc;\n } ->\n {\n Ast_408.Parsetree.pmtd_name = copy_loc (fun x -> x) pmtd_name;\n Ast_408.Parsetree.pmtd_type = Option.map copy_module_type pmtd_type;\n Ast_408.Parsetree.pmtd_attributes = copy_attributes pmtd_attributes;\n Ast_408.Parsetree.pmtd_loc = copy_location pmtd_loc;\n }\n\nand copy_module_substitution :\n Ast_409.Parsetree.module_substitution ->\n Ast_408.Parsetree.module_substitution =\n fun {\n Ast_409.Parsetree.pms_name;\n Ast_409.Parsetree.pms_manifest;\n Ast_409.Parsetree.pms_attributes;\n Ast_409.Parsetree.pms_loc;\n } ->\n {\n Ast_408.Parsetree.pms_name = copy_loc (fun x -> x) pms_name;\n Ast_408.Parsetree.pms_manifest = copy_loc copy_Longident_t pms_manifest;\n Ast_408.Parsetree.pms_attributes = copy_attributes pms_attributes;\n Ast_408.Parsetree.pms_loc = copy_location pms_loc;\n }\n\nand copy_module_declaration :\n Ast_409.Parsetree.module_declaration -> Ast_408.Parsetree.module_declaration\n =\n fun {\n Ast_409.Parsetree.pmd_name;\n Ast_409.Parsetree.pmd_type;\n Ast_409.Parsetree.pmd_attributes;\n Ast_409.Parsetree.pmd_loc;\n } ->\n {\n Ast_408.Parsetree.pmd_name = copy_loc (fun x -> x) pmd_name;\n Ast_408.Parsetree.pmd_type = copy_module_type pmd_type;\n Ast_408.Parsetree.pmd_attributes = copy_attributes pmd_attributes;\n Ast_408.Parsetree.pmd_loc = copy_location pmd_loc;\n }\n\nand copy_type_exception :\n Ast_409.Parsetree.type_exception -> Ast_408.Parsetree.type_exception =\n fun {\n Ast_409.Parsetree.ptyexn_constructor;\n Ast_409.Parsetree.ptyexn_loc;\n Ast_409.Parsetree.ptyexn_attributes;\n } ->\n {\n Ast_408.Parsetree.ptyexn_constructor =\n copy_extension_constructor ptyexn_constructor;\n Ast_408.Parsetree.ptyexn_loc = copy_location ptyexn_loc;\n Ast_408.Parsetree.ptyexn_attributes = copy_attributes ptyexn_attributes;\n }\n\nand copy_type_extension :\n Ast_409.Parsetree.type_extension -> Ast_408.Parsetree.type_extension =\n fun {\n Ast_409.Parsetree.ptyext_path;\n Ast_409.Parsetree.ptyext_params;\n Ast_409.Parsetree.ptyext_constructors;\n Ast_409.Parsetree.ptyext_private;\n Ast_409.Parsetree.ptyext_loc;\n Ast_409.Parsetree.ptyext_attributes;\n } ->\n {\n Ast_408.Parsetree.ptyext_path = copy_loc copy_Longident_t ptyext_path;\n Ast_408.Parsetree.ptyext_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptyext_params;\n Ast_408.Parsetree.ptyext_constructors =\n List.map copy_extension_constructor ptyext_constructors;\n Ast_408.Parsetree.ptyext_private = copy_private_flag ptyext_private;\n Ast_408.Parsetree.ptyext_loc = copy_location ptyext_loc;\n Ast_408.Parsetree.ptyext_attributes = copy_attributes ptyext_attributes;\n }\n\nand copy_extension_constructor :\n Ast_409.Parsetree.extension_constructor ->\n Ast_408.Parsetree.extension_constructor =\n fun {\n Ast_409.Parsetree.pext_name;\n Ast_409.Parsetree.pext_kind;\n Ast_409.Parsetree.pext_loc;\n Ast_409.Parsetree.pext_attributes;\n } ->\n {\n Ast_408.Parsetree.pext_name = copy_loc (fun x -> x) pext_name;\n Ast_408.Parsetree.pext_kind = copy_extension_constructor_kind pext_kind;\n Ast_408.Parsetree.pext_loc = copy_location pext_loc;\n Ast_408.Parsetree.pext_attributes = copy_attributes pext_attributes;\n }\n\nand copy_extension_constructor_kind :\n Ast_409.Parsetree.extension_constructor_kind ->\n Ast_408.Parsetree.extension_constructor_kind = function\n | Ast_409.Parsetree.Pext_decl (x0, x1) ->\n Ast_408.Parsetree.Pext_decl\n (copy_constructor_arguments x0, Option.map copy_core_type x1)\n | Ast_409.Parsetree.Pext_rebind x0 ->\n Ast_408.Parsetree.Pext_rebind (copy_loc copy_Longident_t x0)\n\nand copy_type_declaration :\n Ast_409.Parsetree.type_declaration -> Ast_408.Parsetree.type_declaration =\n fun {\n Ast_409.Parsetree.ptype_name;\n Ast_409.Parsetree.ptype_params;\n Ast_409.Parsetree.ptype_cstrs;\n Ast_409.Parsetree.ptype_kind;\n Ast_409.Parsetree.ptype_private;\n Ast_409.Parsetree.ptype_manifest;\n Ast_409.Parsetree.ptype_attributes;\n Ast_409.Parsetree.ptype_loc;\n } ->\n {\n Ast_408.Parsetree.ptype_name = copy_loc (fun x -> x) ptype_name;\n Ast_408.Parsetree.ptype_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptype_params;\n Ast_408.Parsetree.ptype_cstrs =\n List.map\n (fun x ->\n let x0, x1, x2 = x in\n (copy_core_type x0, copy_core_type x1, copy_location x2))\n ptype_cstrs;\n Ast_408.Parsetree.ptype_kind = copy_type_kind ptype_kind;\n Ast_408.Parsetree.ptype_private = copy_private_flag ptype_private;\n Ast_408.Parsetree.ptype_manifest = Option.map copy_core_type ptype_manifest;\n Ast_408.Parsetree.ptype_attributes = copy_attributes ptype_attributes;\n Ast_408.Parsetree.ptype_loc = copy_location ptype_loc;\n }\n\nand copy_private_flag :\n Ast_409.Asttypes.private_flag -> Ast_408.Asttypes.private_flag = function\n | Ast_409.Asttypes.Private -> Ast_408.Asttypes.Private\n | Ast_409.Asttypes.Public -> Ast_408.Asttypes.Public\n\nand copy_type_kind : Ast_409.Parsetree.type_kind -> Ast_408.Parsetree.type_kind\n = function\n | Ast_409.Parsetree.Ptype_abstract -> Ast_408.Parsetree.Ptype_abstract\n | Ast_409.Parsetree.Ptype_variant x0 ->\n Ast_408.Parsetree.Ptype_variant (List.map copy_constructor_declaration x0)\n | Ast_409.Parsetree.Ptype_record x0 ->\n Ast_408.Parsetree.Ptype_record (List.map copy_label_declaration x0)\n | Ast_409.Parsetree.Ptype_open -> Ast_408.Parsetree.Ptype_open\n\nand copy_constructor_declaration :\n Ast_409.Parsetree.constructor_declaration ->\n Ast_408.Parsetree.constructor_declaration =\n fun {\n Ast_409.Parsetree.pcd_name;\n Ast_409.Parsetree.pcd_args;\n Ast_409.Parsetree.pcd_res;\n Ast_409.Parsetree.pcd_loc;\n Ast_409.Parsetree.pcd_attributes;\n } ->\n {\n Ast_408.Parsetree.pcd_name = copy_loc (fun x -> x) pcd_name;\n Ast_408.Parsetree.pcd_args = copy_constructor_arguments pcd_args;\n Ast_408.Parsetree.pcd_res = Option.map copy_core_type pcd_res;\n Ast_408.Parsetree.pcd_loc = copy_location pcd_loc;\n Ast_408.Parsetree.pcd_attributes = copy_attributes pcd_attributes;\n }\n\nand copy_constructor_arguments :\n Ast_409.Parsetree.constructor_arguments ->\n Ast_408.Parsetree.constructor_arguments = function\n | Ast_409.Parsetree.Pcstr_tuple x0 ->\n Ast_408.Parsetree.Pcstr_tuple (List.map copy_core_type x0)\n | Ast_409.Parsetree.Pcstr_record x0 ->\n Ast_408.Parsetree.Pcstr_record (List.map copy_label_declaration x0)\n\nand copy_label_declaration :\n Ast_409.Parsetree.label_declaration -> Ast_408.Parsetree.label_declaration =\n fun {\n Ast_409.Parsetree.pld_name;\n Ast_409.Parsetree.pld_mutable;\n Ast_409.Parsetree.pld_type;\n Ast_409.Parsetree.pld_loc;\n Ast_409.Parsetree.pld_attributes;\n } ->\n {\n Ast_408.Parsetree.pld_name = copy_loc (fun x -> x) pld_name;\n Ast_408.Parsetree.pld_mutable = copy_mutable_flag pld_mutable;\n Ast_408.Parsetree.pld_type = copy_core_type pld_type;\n Ast_408.Parsetree.pld_loc = copy_location pld_loc;\n Ast_408.Parsetree.pld_attributes = copy_attributes pld_attributes;\n }\n\nand copy_mutable_flag :\n Ast_409.Asttypes.mutable_flag -> Ast_408.Asttypes.mutable_flag = function\n | Ast_409.Asttypes.Immutable -> Ast_408.Asttypes.Immutable\n | Ast_409.Asttypes.Mutable -> Ast_408.Asttypes.Mutable\n\nand copy_variance : Ast_409.Asttypes.variance -> Ast_408.Asttypes.variance =\n function\n | Ast_409.Asttypes.Covariant -> Ast_408.Asttypes.Covariant\n | Ast_409.Asttypes.Contravariant -> Ast_408.Asttypes.Contravariant\n | Ast_409.Asttypes.Invariant -> Ast_408.Asttypes.Invariant\n\nand copy_value_description :\n Ast_409.Parsetree.value_description -> Ast_408.Parsetree.value_description =\n fun {\n Ast_409.Parsetree.pval_name;\n Ast_409.Parsetree.pval_type;\n Ast_409.Parsetree.pval_prim;\n Ast_409.Parsetree.pval_attributes;\n Ast_409.Parsetree.pval_loc;\n } ->\n {\n Ast_408.Parsetree.pval_name = copy_loc (fun x -> x) pval_name;\n Ast_408.Parsetree.pval_type = copy_core_type pval_type;\n Ast_408.Parsetree.pval_prim = List.map (fun x -> x) pval_prim;\n Ast_408.Parsetree.pval_attributes = copy_attributes pval_attributes;\n Ast_408.Parsetree.pval_loc = copy_location pval_loc;\n }\n\nand copy_object_field_desc :\n Ast_409.Parsetree.object_field_desc -> Ast_408.Parsetree.object_field_desc =\n function\n | Ast_409.Parsetree.Otag (x0, x1) ->\n Ast_408.Parsetree.Otag (copy_loc copy_label x0, copy_core_type x1)\n | Ast_409.Parsetree.Oinherit x0 ->\n Ast_408.Parsetree.Oinherit (copy_core_type x0)\n\nand copy_arg_label : Ast_409.Asttypes.arg_label -> Ast_408.Asttypes.arg_label =\n function\n | Ast_409.Asttypes.Nolabel -> Ast_408.Asttypes.Nolabel\n | Ast_409.Asttypes.Labelled x0 -> Ast_408.Asttypes.Labelled x0\n | Ast_409.Asttypes.Optional x0 -> Ast_408.Asttypes.Optional x0\n\nand copy_closed_flag :\n Ast_409.Asttypes.closed_flag -> Ast_408.Asttypes.closed_flag = function\n | Ast_409.Asttypes.Closed -> Ast_408.Asttypes.Closed\n | Ast_409.Asttypes.Open -> Ast_408.Asttypes.Open\n\nand copy_label : Ast_409.Asttypes.label -> Ast_408.Asttypes.label = fun x -> x\n\nand copy_rec_flag : Ast_409.Asttypes.rec_flag -> Ast_408.Asttypes.rec_flag =\n function\n | Ast_409.Asttypes.Nonrecursive -> Ast_408.Asttypes.Nonrecursive\n | Ast_409.Asttypes.Recursive -> Ast_408.Asttypes.Recursive\n\nand copy_constant : Ast_409.Parsetree.constant -> Ast_408.Parsetree.constant =\n function\n | Ast_409.Parsetree.Pconst_integer (x0, x1) ->\n Ast_408.Parsetree.Pconst_integer (x0, Option.map (fun x -> x) x1)\n | Ast_409.Parsetree.Pconst_char x0 -> Ast_408.Parsetree.Pconst_char x0\n | Ast_409.Parsetree.Pconst_string (x0, x1) ->\n Ast_408.Parsetree.Pconst_string (x0, Option.map (fun x -> x) x1)\n | Ast_409.Parsetree.Pconst_float (x0, x1) ->\n Ast_408.Parsetree.Pconst_float (x0, Option.map (fun x -> x) x1)\n\nand copy_Longident_t : Longident.t -> Longident.t = fun x -> x\n\nand copy_loc :\n 'f0 'g0.\n ('f0 -> 'g0) -> 'f0 Ast_409.Asttypes.loc -> 'g0 Ast_408.Asttypes.loc =\n fun f0 { Ast_409.Asttypes.txt; Ast_409.Asttypes.loc } ->\n { Ast_408.Asttypes.txt = f0 txt; Ast_408.Asttypes.loc = copy_location loc }\n\nand copy_location : Location.t -> Location.t = fun x -> x\n","open Stdlib0\nmodule From = Ast_408\nmodule To = Ast_409\n\nlet rec copy_toplevel_phrase :\n Ast_408.Parsetree.toplevel_phrase -> Ast_409.Parsetree.toplevel_phrase =\n function\n | Ast_408.Parsetree.Ptop_def x0 ->\n Ast_409.Parsetree.Ptop_def (copy_structure x0)\n | Ast_408.Parsetree.Ptop_dir x0 ->\n Ast_409.Parsetree.Ptop_dir (copy_toplevel_directive x0)\n\nand copy_toplevel_directive :\n Ast_408.Parsetree.toplevel_directive -> Ast_409.Parsetree.toplevel_directive\n =\n fun {\n Ast_408.Parsetree.pdir_name;\n Ast_408.Parsetree.pdir_arg;\n Ast_408.Parsetree.pdir_loc;\n } ->\n {\n Ast_409.Parsetree.pdir_name = copy_loc (fun x -> x) pdir_name;\n Ast_409.Parsetree.pdir_arg = Option.map copy_directive_argument pdir_arg;\n Ast_409.Parsetree.pdir_loc = copy_location pdir_loc;\n }\n\nand copy_directive_argument :\n Ast_408.Parsetree.directive_argument -> Ast_409.Parsetree.directive_argument\n =\n fun { Ast_408.Parsetree.pdira_desc; Ast_408.Parsetree.pdira_loc } ->\n {\n Ast_409.Parsetree.pdira_desc = copy_directive_argument_desc pdira_desc;\n Ast_409.Parsetree.pdira_loc = copy_location pdira_loc;\n }\n\nand copy_directive_argument_desc :\n Ast_408.Parsetree.directive_argument_desc ->\n Ast_409.Parsetree.directive_argument_desc = function\n | Ast_408.Parsetree.Pdir_string x0 -> Ast_409.Parsetree.Pdir_string x0\n | Ast_408.Parsetree.Pdir_int (x0, x1) ->\n Ast_409.Parsetree.Pdir_int (x0, Option.map (fun x -> x) x1)\n | Ast_408.Parsetree.Pdir_ident x0 ->\n Ast_409.Parsetree.Pdir_ident (copy_Longident_t x0)\n | Ast_408.Parsetree.Pdir_bool x0 -> Ast_409.Parsetree.Pdir_bool x0\n\nand copy_typ : Ast_408.Parsetree.typ -> Ast_409.Parsetree.typ =\n fun x -> copy_core_type x\n\nand copy_pat : Ast_408.Parsetree.pat -> Ast_409.Parsetree.pat =\n fun x -> copy_pattern x\n\nand copy_expr : Ast_408.Parsetree.expr -> Ast_409.Parsetree.expr =\n fun x -> copy_expression x\n\nand copy_expression :\n Ast_408.Parsetree.expression -> Ast_409.Parsetree.expression =\n fun {\n Ast_408.Parsetree.pexp_desc;\n Ast_408.Parsetree.pexp_loc;\n Ast_408.Parsetree.pexp_loc_stack;\n Ast_408.Parsetree.pexp_attributes;\n } ->\n {\n Ast_409.Parsetree.pexp_desc = copy_expression_desc pexp_desc;\n Ast_409.Parsetree.pexp_loc = copy_location pexp_loc;\n Ast_409.Parsetree.pexp_loc_stack = List.map copy_location pexp_loc_stack;\n Ast_409.Parsetree.pexp_attributes = copy_attributes pexp_attributes;\n }\n\nand copy_expression_desc :\n Ast_408.Parsetree.expression_desc -> Ast_409.Parsetree.expression_desc =\n function\n | Ast_408.Parsetree.Pexp_ident x0 ->\n Ast_409.Parsetree.Pexp_ident (copy_loc copy_Longident_t x0)\n | Ast_408.Parsetree.Pexp_constant x0 ->\n Ast_409.Parsetree.Pexp_constant (copy_constant x0)\n | Ast_408.Parsetree.Pexp_let (x0, x1, x2) ->\n Ast_409.Parsetree.Pexp_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_expression x2)\n | Ast_408.Parsetree.Pexp_function x0 ->\n Ast_409.Parsetree.Pexp_function (copy_cases x0)\n | Ast_408.Parsetree.Pexp_fun (x0, x1, x2, x3) ->\n Ast_409.Parsetree.Pexp_fun\n ( copy_arg_label x0,\n Option.map copy_expression x1,\n copy_pattern x2,\n copy_expression x3 )\n | Ast_408.Parsetree.Pexp_apply (x0, x1) ->\n Ast_409.Parsetree.Pexp_apply\n ( copy_expression x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | Ast_408.Parsetree.Pexp_match (x0, x1) ->\n Ast_409.Parsetree.Pexp_match (copy_expression x0, copy_cases x1)\n | Ast_408.Parsetree.Pexp_try (x0, x1) ->\n Ast_409.Parsetree.Pexp_try (copy_expression x0, copy_cases x1)\n | Ast_408.Parsetree.Pexp_tuple x0 ->\n Ast_409.Parsetree.Pexp_tuple (List.map copy_expression x0)\n | Ast_408.Parsetree.Pexp_construct (x0, x1) ->\n Ast_409.Parsetree.Pexp_construct\n (copy_loc copy_Longident_t x0, Option.map copy_expression x1)\n | Ast_408.Parsetree.Pexp_variant (x0, x1) ->\n Ast_409.Parsetree.Pexp_variant\n (copy_label x0, Option.map copy_expression x1)\n | Ast_408.Parsetree.Pexp_record (x0, x1) ->\n Ast_409.Parsetree.Pexp_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_expression x1))\n x0,\n Option.map copy_expression x1 )\n | Ast_408.Parsetree.Pexp_field (x0, x1) ->\n Ast_409.Parsetree.Pexp_field\n (copy_expression x0, copy_loc copy_Longident_t x1)\n | Ast_408.Parsetree.Pexp_setfield (x0, x1, x2) ->\n Ast_409.Parsetree.Pexp_setfield\n (copy_expression x0, copy_loc copy_Longident_t x1, copy_expression x2)\n | Ast_408.Parsetree.Pexp_array x0 ->\n Ast_409.Parsetree.Pexp_array (List.map copy_expression x0)\n | Ast_408.Parsetree.Pexp_ifthenelse (x0, x1, x2) ->\n Ast_409.Parsetree.Pexp_ifthenelse\n (copy_expression x0, copy_expression x1, Option.map copy_expression x2)\n | Ast_408.Parsetree.Pexp_sequence (x0, x1) ->\n Ast_409.Parsetree.Pexp_sequence (copy_expression x0, copy_expression x1)\n | Ast_408.Parsetree.Pexp_while (x0, x1) ->\n Ast_409.Parsetree.Pexp_while (copy_expression x0, copy_expression x1)\n | Ast_408.Parsetree.Pexp_for (x0, x1, x2, x3, x4) ->\n Ast_409.Parsetree.Pexp_for\n ( copy_pattern x0,\n copy_expression x1,\n copy_expression x2,\n copy_direction_flag x3,\n copy_expression x4 )\n | Ast_408.Parsetree.Pexp_constraint (x0, x1) ->\n Ast_409.Parsetree.Pexp_constraint (copy_expression x0, copy_core_type x1)\n | Ast_408.Parsetree.Pexp_coerce (x0, x1, x2) ->\n Ast_409.Parsetree.Pexp_coerce\n (copy_expression x0, Option.map copy_core_type x1, copy_core_type x2)\n | Ast_408.Parsetree.Pexp_send (x0, x1) ->\n Ast_409.Parsetree.Pexp_send (copy_expression x0, copy_loc copy_label x1)\n | Ast_408.Parsetree.Pexp_new x0 ->\n Ast_409.Parsetree.Pexp_new (copy_loc copy_Longident_t x0)\n | Ast_408.Parsetree.Pexp_setinstvar (x0, x1) ->\n Ast_409.Parsetree.Pexp_setinstvar\n (copy_loc copy_label x0, copy_expression x1)\n | Ast_408.Parsetree.Pexp_override x0 ->\n Ast_409.Parsetree.Pexp_override\n (List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_label x0, copy_expression x1))\n x0)\n | Ast_408.Parsetree.Pexp_letmodule (x0, x1, x2) ->\n Ast_409.Parsetree.Pexp_letmodule\n (copy_loc (fun x -> x) x0, copy_module_expr x1, copy_expression x2)\n | Ast_408.Parsetree.Pexp_letexception (x0, x1) ->\n Ast_409.Parsetree.Pexp_letexception\n (copy_extension_constructor x0, copy_expression x1)\n | Ast_408.Parsetree.Pexp_assert x0 ->\n Ast_409.Parsetree.Pexp_assert (copy_expression x0)\n | Ast_408.Parsetree.Pexp_lazy x0 ->\n Ast_409.Parsetree.Pexp_lazy (copy_expression x0)\n | Ast_408.Parsetree.Pexp_poly (x0, x1) ->\n Ast_409.Parsetree.Pexp_poly\n (copy_expression x0, Option.map copy_core_type x1)\n | Ast_408.Parsetree.Pexp_object x0 ->\n Ast_409.Parsetree.Pexp_object (copy_class_structure x0)\n | Ast_408.Parsetree.Pexp_newtype (x0, x1) ->\n Ast_409.Parsetree.Pexp_newtype\n (copy_loc (fun x -> x) x0, copy_expression x1)\n | Ast_408.Parsetree.Pexp_pack x0 ->\n Ast_409.Parsetree.Pexp_pack (copy_module_expr x0)\n | Ast_408.Parsetree.Pexp_open (x0, x1) ->\n Ast_409.Parsetree.Pexp_open (copy_open_declaration x0, copy_expression x1)\n | Ast_408.Parsetree.Pexp_letop x0 ->\n Ast_409.Parsetree.Pexp_letop (copy_letop x0)\n | Ast_408.Parsetree.Pexp_extension x0 ->\n Ast_409.Parsetree.Pexp_extension (copy_extension x0)\n | Ast_408.Parsetree.Pexp_unreachable -> Ast_409.Parsetree.Pexp_unreachable\n\nand copy_letop : Ast_408.Parsetree.letop -> Ast_409.Parsetree.letop =\n fun { Ast_408.Parsetree.let_; Ast_408.Parsetree.ands; Ast_408.Parsetree.body } ->\n {\n Ast_409.Parsetree.let_ = copy_binding_op let_;\n Ast_409.Parsetree.ands = List.map copy_binding_op ands;\n Ast_409.Parsetree.body = copy_expression body;\n }\n\nand copy_binding_op :\n Ast_408.Parsetree.binding_op -> Ast_409.Parsetree.binding_op =\n fun {\n Ast_408.Parsetree.pbop_op;\n Ast_408.Parsetree.pbop_pat;\n Ast_408.Parsetree.pbop_exp;\n Ast_408.Parsetree.pbop_loc;\n } ->\n {\n Ast_409.Parsetree.pbop_op = copy_loc (fun x -> x) pbop_op;\n Ast_409.Parsetree.pbop_pat = copy_pattern pbop_pat;\n Ast_409.Parsetree.pbop_exp = copy_expression pbop_exp;\n Ast_409.Parsetree.pbop_loc = copy_location pbop_loc;\n }\n\nand copy_direction_flag :\n Ast_408.Asttypes.direction_flag -> Ast_409.Asttypes.direction_flag =\n function\n | Ast_408.Asttypes.Upto -> Ast_409.Asttypes.Upto\n | Ast_408.Asttypes.Downto -> Ast_409.Asttypes.Downto\n\nand copy_cases : Ast_408.Parsetree.cases -> Ast_409.Parsetree.cases =\n fun x -> List.map copy_case x\n\nand copy_case : Ast_408.Parsetree.case -> Ast_409.Parsetree.case =\n fun {\n Ast_408.Parsetree.pc_lhs;\n Ast_408.Parsetree.pc_guard;\n Ast_408.Parsetree.pc_rhs;\n } ->\n {\n Ast_409.Parsetree.pc_lhs = copy_pattern pc_lhs;\n Ast_409.Parsetree.pc_guard = Option.map copy_expression pc_guard;\n Ast_409.Parsetree.pc_rhs = copy_expression pc_rhs;\n }\n\nand copy_value_binding :\n Ast_408.Parsetree.value_binding -> Ast_409.Parsetree.value_binding =\n fun {\n Ast_408.Parsetree.pvb_pat;\n Ast_408.Parsetree.pvb_expr;\n Ast_408.Parsetree.pvb_attributes;\n Ast_408.Parsetree.pvb_loc;\n } ->\n {\n Ast_409.Parsetree.pvb_pat = copy_pattern pvb_pat;\n Ast_409.Parsetree.pvb_expr = copy_expression pvb_expr;\n Ast_409.Parsetree.pvb_attributes = copy_attributes pvb_attributes;\n Ast_409.Parsetree.pvb_loc = copy_location pvb_loc;\n }\n\nand copy_pattern : Ast_408.Parsetree.pattern -> Ast_409.Parsetree.pattern =\n fun {\n Ast_408.Parsetree.ppat_desc;\n Ast_408.Parsetree.ppat_loc;\n Ast_408.Parsetree.ppat_loc_stack;\n Ast_408.Parsetree.ppat_attributes;\n } ->\n {\n Ast_409.Parsetree.ppat_desc = copy_pattern_desc ppat_desc;\n Ast_409.Parsetree.ppat_loc = copy_location ppat_loc;\n Ast_409.Parsetree.ppat_loc_stack = List.map copy_location ppat_loc_stack;\n Ast_409.Parsetree.ppat_attributes = copy_attributes ppat_attributes;\n }\n\nand copy_pattern_desc :\n Ast_408.Parsetree.pattern_desc -> Ast_409.Parsetree.pattern_desc = function\n | Ast_408.Parsetree.Ppat_any -> Ast_409.Parsetree.Ppat_any\n | Ast_408.Parsetree.Ppat_var x0 ->\n Ast_409.Parsetree.Ppat_var (copy_loc (fun x -> x) x0)\n | Ast_408.Parsetree.Ppat_alias (x0, x1) ->\n Ast_409.Parsetree.Ppat_alias (copy_pattern x0, copy_loc (fun x -> x) x1)\n | Ast_408.Parsetree.Ppat_constant x0 ->\n Ast_409.Parsetree.Ppat_constant (copy_constant x0)\n | Ast_408.Parsetree.Ppat_interval (x0, x1) ->\n Ast_409.Parsetree.Ppat_interval (copy_constant x0, copy_constant x1)\n | Ast_408.Parsetree.Ppat_tuple x0 ->\n Ast_409.Parsetree.Ppat_tuple (List.map copy_pattern x0)\n | Ast_408.Parsetree.Ppat_construct (x0, x1) ->\n Ast_409.Parsetree.Ppat_construct\n (copy_loc copy_Longident_t x0, Option.map copy_pattern x1)\n | Ast_408.Parsetree.Ppat_variant (x0, x1) ->\n Ast_409.Parsetree.Ppat_variant (copy_label x0, Option.map copy_pattern x1)\n | Ast_408.Parsetree.Ppat_record (x0, x1) ->\n Ast_409.Parsetree.Ppat_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_pattern x1))\n x0,\n copy_closed_flag x1 )\n | Ast_408.Parsetree.Ppat_array x0 ->\n Ast_409.Parsetree.Ppat_array (List.map copy_pattern x0)\n | Ast_408.Parsetree.Ppat_or (x0, x1) ->\n Ast_409.Parsetree.Ppat_or (copy_pattern x0, copy_pattern x1)\n | Ast_408.Parsetree.Ppat_constraint (x0, x1) ->\n Ast_409.Parsetree.Ppat_constraint (copy_pattern x0, copy_core_type x1)\n | Ast_408.Parsetree.Ppat_type x0 ->\n Ast_409.Parsetree.Ppat_type (copy_loc copy_Longident_t x0)\n | Ast_408.Parsetree.Ppat_lazy x0 ->\n Ast_409.Parsetree.Ppat_lazy (copy_pattern x0)\n | Ast_408.Parsetree.Ppat_unpack x0 ->\n Ast_409.Parsetree.Ppat_unpack (copy_loc (fun x -> x) x0)\n | Ast_408.Parsetree.Ppat_exception x0 ->\n Ast_409.Parsetree.Ppat_exception (copy_pattern x0)\n | Ast_408.Parsetree.Ppat_extension x0 ->\n Ast_409.Parsetree.Ppat_extension (copy_extension x0)\n | Ast_408.Parsetree.Ppat_open (x0, x1) ->\n Ast_409.Parsetree.Ppat_open (copy_loc copy_Longident_t x0, copy_pattern x1)\n\nand copy_core_type : Ast_408.Parsetree.core_type -> Ast_409.Parsetree.core_type\n =\n fun {\n Ast_408.Parsetree.ptyp_desc;\n Ast_408.Parsetree.ptyp_loc;\n Ast_408.Parsetree.ptyp_loc_stack;\n Ast_408.Parsetree.ptyp_attributes;\n } ->\n {\n Ast_409.Parsetree.ptyp_desc = copy_core_type_desc ptyp_desc;\n Ast_409.Parsetree.ptyp_loc = copy_location ptyp_loc;\n Ast_409.Parsetree.ptyp_loc_stack = List.map copy_location ptyp_loc_stack;\n Ast_409.Parsetree.ptyp_attributes = copy_attributes ptyp_attributes;\n }\n\nand copy_core_type_desc :\n Ast_408.Parsetree.core_type_desc -> Ast_409.Parsetree.core_type_desc =\n function\n | Ast_408.Parsetree.Ptyp_any -> Ast_409.Parsetree.Ptyp_any\n | Ast_408.Parsetree.Ptyp_var x0 -> Ast_409.Parsetree.Ptyp_var x0\n | Ast_408.Parsetree.Ptyp_arrow (x0, x1, x2) ->\n Ast_409.Parsetree.Ptyp_arrow\n (copy_arg_label x0, copy_core_type x1, copy_core_type x2)\n | Ast_408.Parsetree.Ptyp_tuple x0 ->\n Ast_409.Parsetree.Ptyp_tuple (List.map copy_core_type x0)\n | Ast_408.Parsetree.Ptyp_constr (x0, x1) ->\n Ast_409.Parsetree.Ptyp_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_408.Parsetree.Ptyp_object (x0, x1) ->\n Ast_409.Parsetree.Ptyp_object\n (List.map copy_object_field x0, copy_closed_flag x1)\n | Ast_408.Parsetree.Ptyp_class (x0, x1) ->\n Ast_409.Parsetree.Ptyp_class\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_408.Parsetree.Ptyp_alias (x0, x1) ->\n Ast_409.Parsetree.Ptyp_alias (copy_core_type x0, x1)\n | Ast_408.Parsetree.Ptyp_variant (x0, x1, x2) ->\n Ast_409.Parsetree.Ptyp_variant\n ( List.map copy_row_field x0,\n copy_closed_flag x1,\n Option.map (fun x -> List.map copy_label x) x2 )\n | Ast_408.Parsetree.Ptyp_poly (x0, x1) ->\n Ast_409.Parsetree.Ptyp_poly\n (List.map (fun x -> copy_loc (fun x -> x) x) x0, copy_core_type x1)\n | Ast_408.Parsetree.Ptyp_package x0 ->\n Ast_409.Parsetree.Ptyp_package (copy_package_type x0)\n | Ast_408.Parsetree.Ptyp_extension x0 ->\n Ast_409.Parsetree.Ptyp_extension (copy_extension x0)\n\nand copy_package_type :\n Ast_408.Parsetree.package_type -> Ast_409.Parsetree.package_type =\n fun x ->\n let x0, x1 = x in\n ( copy_loc copy_Longident_t x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_core_type x1))\n x1 )\n\nand copy_row_field : Ast_408.Parsetree.row_field -> Ast_409.Parsetree.row_field\n =\n fun {\n Ast_408.Parsetree.prf_desc;\n Ast_408.Parsetree.prf_loc;\n Ast_408.Parsetree.prf_attributes;\n } ->\n {\n Ast_409.Parsetree.prf_desc = copy_row_field_desc prf_desc;\n Ast_409.Parsetree.prf_loc = copy_location prf_loc;\n Ast_409.Parsetree.prf_attributes = copy_attributes prf_attributes;\n }\n\nand copy_row_field_desc :\n Ast_408.Parsetree.row_field_desc -> Ast_409.Parsetree.row_field_desc =\n function\n | Ast_408.Parsetree.Rtag (x0, x1, x2) ->\n Ast_409.Parsetree.Rtag\n (copy_loc copy_label x0, x1, List.map copy_core_type x2)\n | Ast_408.Parsetree.Rinherit x0 ->\n Ast_409.Parsetree.Rinherit (copy_core_type x0)\n\nand copy_object_field :\n Ast_408.Parsetree.object_field -> Ast_409.Parsetree.object_field =\n fun {\n Ast_408.Parsetree.pof_desc;\n Ast_408.Parsetree.pof_loc;\n Ast_408.Parsetree.pof_attributes;\n } ->\n {\n Ast_409.Parsetree.pof_desc = copy_object_field_desc pof_desc;\n Ast_409.Parsetree.pof_loc = copy_location pof_loc;\n Ast_409.Parsetree.pof_attributes = copy_attributes pof_attributes;\n }\n\nand copy_attributes :\n Ast_408.Parsetree.attributes -> Ast_409.Parsetree.attributes =\n fun x -> List.map copy_attribute x\n\nand copy_attribute : Ast_408.Parsetree.attribute -> Ast_409.Parsetree.attribute\n =\n fun {\n Ast_408.Parsetree.attr_name;\n Ast_408.Parsetree.attr_payload;\n Ast_408.Parsetree.attr_loc;\n } ->\n {\n Ast_409.Parsetree.attr_name = copy_loc (fun x -> x) attr_name;\n Ast_409.Parsetree.attr_payload = copy_payload attr_payload;\n Ast_409.Parsetree.attr_loc = copy_location attr_loc;\n }\n\nand copy_payload : Ast_408.Parsetree.payload -> Ast_409.Parsetree.payload =\n function\n | Ast_408.Parsetree.PStr x0 -> Ast_409.Parsetree.PStr (copy_structure x0)\n | Ast_408.Parsetree.PSig x0 -> Ast_409.Parsetree.PSig (copy_signature x0)\n | Ast_408.Parsetree.PTyp x0 -> Ast_409.Parsetree.PTyp (copy_core_type x0)\n | Ast_408.Parsetree.PPat (x0, x1) ->\n Ast_409.Parsetree.PPat (copy_pattern x0, Option.map copy_expression x1)\n\nand copy_structure : Ast_408.Parsetree.structure -> Ast_409.Parsetree.structure\n =\n fun x -> List.map copy_structure_item x\n\nand copy_structure_item :\n Ast_408.Parsetree.structure_item -> Ast_409.Parsetree.structure_item =\n fun { Ast_408.Parsetree.pstr_desc; Ast_408.Parsetree.pstr_loc } ->\n {\n Ast_409.Parsetree.pstr_desc = copy_structure_item_desc pstr_desc;\n Ast_409.Parsetree.pstr_loc = copy_location pstr_loc;\n }\n\nand copy_structure_item_desc :\n Ast_408.Parsetree.structure_item_desc ->\n Ast_409.Parsetree.structure_item_desc = function\n | Ast_408.Parsetree.Pstr_eval (x0, x1) ->\n Ast_409.Parsetree.Pstr_eval (copy_expression x0, copy_attributes x1)\n | Ast_408.Parsetree.Pstr_value (x0, x1) ->\n Ast_409.Parsetree.Pstr_value\n (copy_rec_flag x0, List.map copy_value_binding x1)\n | Ast_408.Parsetree.Pstr_primitive x0 ->\n Ast_409.Parsetree.Pstr_primitive (copy_value_description x0)\n | Ast_408.Parsetree.Pstr_type (x0, x1) ->\n Ast_409.Parsetree.Pstr_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | Ast_408.Parsetree.Pstr_typext x0 ->\n Ast_409.Parsetree.Pstr_typext (copy_type_extension x0)\n | Ast_408.Parsetree.Pstr_exception x0 ->\n Ast_409.Parsetree.Pstr_exception (copy_type_exception x0)\n | Ast_408.Parsetree.Pstr_module x0 ->\n Ast_409.Parsetree.Pstr_module (copy_module_binding x0)\n | Ast_408.Parsetree.Pstr_recmodule x0 ->\n Ast_409.Parsetree.Pstr_recmodule (List.map copy_module_binding x0)\n | Ast_408.Parsetree.Pstr_modtype x0 ->\n Ast_409.Parsetree.Pstr_modtype (copy_module_type_declaration x0)\n | Ast_408.Parsetree.Pstr_open x0 ->\n Ast_409.Parsetree.Pstr_open (copy_open_declaration x0)\n | Ast_408.Parsetree.Pstr_class x0 ->\n Ast_409.Parsetree.Pstr_class (List.map copy_class_declaration x0)\n | Ast_408.Parsetree.Pstr_class_type x0 ->\n Ast_409.Parsetree.Pstr_class_type\n (List.map copy_class_type_declaration x0)\n | Ast_408.Parsetree.Pstr_include x0 ->\n Ast_409.Parsetree.Pstr_include (copy_include_declaration x0)\n | Ast_408.Parsetree.Pstr_attribute x0 ->\n Ast_409.Parsetree.Pstr_attribute (copy_attribute x0)\n | Ast_408.Parsetree.Pstr_extension (x0, x1) ->\n Ast_409.Parsetree.Pstr_extension (copy_extension x0, copy_attributes x1)\n\nand copy_include_declaration :\n Ast_408.Parsetree.include_declaration ->\n Ast_409.Parsetree.include_declaration =\n fun x -> copy_include_infos copy_module_expr x\n\nand copy_class_declaration :\n Ast_408.Parsetree.class_declaration -> Ast_409.Parsetree.class_declaration =\n fun x -> copy_class_infos copy_class_expr x\n\nand copy_class_expr :\n Ast_408.Parsetree.class_expr -> Ast_409.Parsetree.class_expr =\n fun {\n Ast_408.Parsetree.pcl_desc;\n Ast_408.Parsetree.pcl_loc;\n Ast_408.Parsetree.pcl_attributes;\n } ->\n {\n Ast_409.Parsetree.pcl_desc = copy_class_expr_desc pcl_desc;\n Ast_409.Parsetree.pcl_loc = copy_location pcl_loc;\n Ast_409.Parsetree.pcl_attributes = copy_attributes pcl_attributes;\n }\n\nand copy_class_expr_desc :\n Ast_408.Parsetree.class_expr_desc -> Ast_409.Parsetree.class_expr_desc =\n function\n | Ast_408.Parsetree.Pcl_constr (x0, x1) ->\n Ast_409.Parsetree.Pcl_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_408.Parsetree.Pcl_structure x0 ->\n Ast_409.Parsetree.Pcl_structure (copy_class_structure x0)\n | Ast_408.Parsetree.Pcl_fun (x0, x1, x2, x3) ->\n Ast_409.Parsetree.Pcl_fun\n ( copy_arg_label x0,\n Option.map copy_expression x1,\n copy_pattern x2,\n copy_class_expr x3 )\n | Ast_408.Parsetree.Pcl_apply (x0, x1) ->\n Ast_409.Parsetree.Pcl_apply\n ( copy_class_expr x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | Ast_408.Parsetree.Pcl_let (x0, x1, x2) ->\n Ast_409.Parsetree.Pcl_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_class_expr x2)\n | Ast_408.Parsetree.Pcl_constraint (x0, x1) ->\n Ast_409.Parsetree.Pcl_constraint (copy_class_expr x0, copy_class_type x1)\n | Ast_408.Parsetree.Pcl_extension x0 ->\n Ast_409.Parsetree.Pcl_extension (copy_extension x0)\n | Ast_408.Parsetree.Pcl_open (x0, x1) ->\n Ast_409.Parsetree.Pcl_open (copy_open_description x0, copy_class_expr x1)\n\nand copy_class_structure :\n Ast_408.Parsetree.class_structure -> Ast_409.Parsetree.class_structure =\n fun { Ast_408.Parsetree.pcstr_self; Ast_408.Parsetree.pcstr_fields } ->\n {\n Ast_409.Parsetree.pcstr_self = copy_pattern pcstr_self;\n Ast_409.Parsetree.pcstr_fields = List.map copy_class_field pcstr_fields;\n }\n\nand copy_class_field :\n Ast_408.Parsetree.class_field -> Ast_409.Parsetree.class_field =\n fun {\n Ast_408.Parsetree.pcf_desc;\n Ast_408.Parsetree.pcf_loc;\n Ast_408.Parsetree.pcf_attributes;\n } ->\n {\n Ast_409.Parsetree.pcf_desc = copy_class_field_desc pcf_desc;\n Ast_409.Parsetree.pcf_loc = copy_location pcf_loc;\n Ast_409.Parsetree.pcf_attributes = copy_attributes pcf_attributes;\n }\n\nand copy_class_field_desc :\n Ast_408.Parsetree.class_field_desc -> Ast_409.Parsetree.class_field_desc =\n function\n | Ast_408.Parsetree.Pcf_inherit (x0, x1, x2) ->\n Ast_409.Parsetree.Pcf_inherit\n ( copy_override_flag x0,\n copy_class_expr x1,\n Option.map (fun x -> copy_loc (fun x -> x) x) x2 )\n | Ast_408.Parsetree.Pcf_val x0 ->\n Ast_409.Parsetree.Pcf_val\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_mutable_flag x1, copy_class_field_kind x2))\n | Ast_408.Parsetree.Pcf_method x0 ->\n Ast_409.Parsetree.Pcf_method\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_private_flag x1, copy_class_field_kind x2))\n | Ast_408.Parsetree.Pcf_constraint x0 ->\n Ast_409.Parsetree.Pcf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | Ast_408.Parsetree.Pcf_initializer x0 ->\n Ast_409.Parsetree.Pcf_initializer (copy_expression x0)\n | Ast_408.Parsetree.Pcf_attribute x0 ->\n Ast_409.Parsetree.Pcf_attribute (copy_attribute x0)\n | Ast_408.Parsetree.Pcf_extension x0 ->\n Ast_409.Parsetree.Pcf_extension (copy_extension x0)\n\nand copy_class_field_kind :\n Ast_408.Parsetree.class_field_kind -> Ast_409.Parsetree.class_field_kind =\n function\n | Ast_408.Parsetree.Cfk_virtual x0 ->\n Ast_409.Parsetree.Cfk_virtual (copy_core_type x0)\n | Ast_408.Parsetree.Cfk_concrete (x0, x1) ->\n Ast_409.Parsetree.Cfk_concrete (copy_override_flag x0, copy_expression x1)\n\nand copy_open_declaration :\n Ast_408.Parsetree.open_declaration -> Ast_409.Parsetree.open_declaration =\n fun x -> copy_open_infos copy_module_expr x\n\nand copy_module_binding :\n Ast_408.Parsetree.module_binding -> Ast_409.Parsetree.module_binding =\n fun {\n Ast_408.Parsetree.pmb_name;\n Ast_408.Parsetree.pmb_expr;\n Ast_408.Parsetree.pmb_attributes;\n Ast_408.Parsetree.pmb_loc;\n } ->\n {\n Ast_409.Parsetree.pmb_name = copy_loc (fun x -> x) pmb_name;\n Ast_409.Parsetree.pmb_expr = copy_module_expr pmb_expr;\n Ast_409.Parsetree.pmb_attributes = copy_attributes pmb_attributes;\n Ast_409.Parsetree.pmb_loc = copy_location pmb_loc;\n }\n\nand copy_module_expr :\n Ast_408.Parsetree.module_expr -> Ast_409.Parsetree.module_expr =\n fun {\n Ast_408.Parsetree.pmod_desc;\n Ast_408.Parsetree.pmod_loc;\n Ast_408.Parsetree.pmod_attributes;\n } ->\n {\n Ast_409.Parsetree.pmod_desc = copy_module_expr_desc pmod_desc;\n Ast_409.Parsetree.pmod_loc = copy_location pmod_loc;\n Ast_409.Parsetree.pmod_attributes = copy_attributes pmod_attributes;\n }\n\nand copy_module_expr_desc :\n Ast_408.Parsetree.module_expr_desc -> Ast_409.Parsetree.module_expr_desc =\n function\n | Ast_408.Parsetree.Pmod_ident x0 ->\n Ast_409.Parsetree.Pmod_ident (copy_loc copy_Longident_t x0)\n | Ast_408.Parsetree.Pmod_structure x0 ->\n Ast_409.Parsetree.Pmod_structure (copy_structure x0)\n | Ast_408.Parsetree.Pmod_functor (x0, x1, x2) ->\n Ast_409.Parsetree.Pmod_functor\n ( copy_loc (fun x -> x) x0,\n Option.map copy_module_type x1,\n copy_module_expr x2 )\n | Ast_408.Parsetree.Pmod_apply (x0, x1) ->\n Ast_409.Parsetree.Pmod_apply (copy_module_expr x0, copy_module_expr x1)\n | Ast_408.Parsetree.Pmod_constraint (x0, x1) ->\n Ast_409.Parsetree.Pmod_constraint\n (copy_module_expr x0, copy_module_type x1)\n | Ast_408.Parsetree.Pmod_unpack x0 ->\n Ast_409.Parsetree.Pmod_unpack (copy_expression x0)\n | Ast_408.Parsetree.Pmod_extension x0 ->\n Ast_409.Parsetree.Pmod_extension (copy_extension x0)\n\nand copy_module_type :\n Ast_408.Parsetree.module_type -> Ast_409.Parsetree.module_type =\n fun {\n Ast_408.Parsetree.pmty_desc;\n Ast_408.Parsetree.pmty_loc;\n Ast_408.Parsetree.pmty_attributes;\n } ->\n {\n Ast_409.Parsetree.pmty_desc = copy_module_type_desc pmty_desc;\n Ast_409.Parsetree.pmty_loc = copy_location pmty_loc;\n Ast_409.Parsetree.pmty_attributes = copy_attributes pmty_attributes;\n }\n\nand copy_module_type_desc :\n Ast_408.Parsetree.module_type_desc -> Ast_409.Parsetree.module_type_desc =\n function\n | Ast_408.Parsetree.Pmty_ident x0 ->\n Ast_409.Parsetree.Pmty_ident (copy_loc copy_Longident_t x0)\n | Ast_408.Parsetree.Pmty_signature x0 ->\n Ast_409.Parsetree.Pmty_signature (copy_signature x0)\n | Ast_408.Parsetree.Pmty_functor (x0, x1, x2) ->\n Ast_409.Parsetree.Pmty_functor\n ( copy_loc (fun x -> x) x0,\n Option.map copy_module_type x1,\n copy_module_type x2 )\n | Ast_408.Parsetree.Pmty_with (x0, x1) ->\n Ast_409.Parsetree.Pmty_with\n (copy_module_type x0, List.map copy_with_constraint x1)\n | Ast_408.Parsetree.Pmty_typeof x0 ->\n Ast_409.Parsetree.Pmty_typeof (copy_module_expr x0)\n | Ast_408.Parsetree.Pmty_extension x0 ->\n Ast_409.Parsetree.Pmty_extension (copy_extension x0)\n | Ast_408.Parsetree.Pmty_alias x0 ->\n Ast_409.Parsetree.Pmty_alias (copy_loc copy_Longident_t x0)\n\nand copy_with_constraint :\n Ast_408.Parsetree.with_constraint -> Ast_409.Parsetree.with_constraint =\n function\n | Ast_408.Parsetree.Pwith_type (x0, x1) ->\n Ast_409.Parsetree.Pwith_type\n (copy_loc copy_Longident_t x0, copy_type_declaration x1)\n | Ast_408.Parsetree.Pwith_module (x0, x1) ->\n Ast_409.Parsetree.Pwith_module\n (copy_loc copy_Longident_t x0, copy_loc copy_Longident_t x1)\n | Ast_408.Parsetree.Pwith_typesubst (x0, x1) ->\n Ast_409.Parsetree.Pwith_typesubst\n (copy_loc copy_Longident_t x0, copy_type_declaration x1)\n | Ast_408.Parsetree.Pwith_modsubst (x0, x1) ->\n Ast_409.Parsetree.Pwith_modsubst\n (copy_loc copy_Longident_t x0, copy_loc copy_Longident_t x1)\n\nand copy_signature : Ast_408.Parsetree.signature -> Ast_409.Parsetree.signature\n =\n fun x -> List.map copy_signature_item x\n\nand copy_signature_item :\n Ast_408.Parsetree.signature_item -> Ast_409.Parsetree.signature_item =\n fun { Ast_408.Parsetree.psig_desc; Ast_408.Parsetree.psig_loc } ->\n {\n Ast_409.Parsetree.psig_desc = copy_signature_item_desc psig_desc;\n Ast_409.Parsetree.psig_loc = copy_location psig_loc;\n }\n\nand copy_signature_item_desc :\n Ast_408.Parsetree.signature_item_desc ->\n Ast_409.Parsetree.signature_item_desc = function\n | Ast_408.Parsetree.Psig_value x0 ->\n Ast_409.Parsetree.Psig_value (copy_value_description x0)\n | Ast_408.Parsetree.Psig_type (x0, x1) ->\n Ast_409.Parsetree.Psig_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | Ast_408.Parsetree.Psig_typesubst x0 ->\n Ast_409.Parsetree.Psig_typesubst (List.map copy_type_declaration x0)\n | Ast_408.Parsetree.Psig_typext x0 ->\n Ast_409.Parsetree.Psig_typext (copy_type_extension x0)\n | Ast_408.Parsetree.Psig_exception x0 ->\n Ast_409.Parsetree.Psig_exception (copy_type_exception x0)\n | Ast_408.Parsetree.Psig_module x0 ->\n Ast_409.Parsetree.Psig_module (copy_module_declaration x0)\n | Ast_408.Parsetree.Psig_modsubst x0 ->\n Ast_409.Parsetree.Psig_modsubst (copy_module_substitution x0)\n | Ast_408.Parsetree.Psig_recmodule x0 ->\n Ast_409.Parsetree.Psig_recmodule (List.map copy_module_declaration x0)\n | Ast_408.Parsetree.Psig_modtype x0 ->\n Ast_409.Parsetree.Psig_modtype (copy_module_type_declaration x0)\n | Ast_408.Parsetree.Psig_open x0 ->\n Ast_409.Parsetree.Psig_open (copy_open_description x0)\n | Ast_408.Parsetree.Psig_include x0 ->\n Ast_409.Parsetree.Psig_include (copy_include_description x0)\n | Ast_408.Parsetree.Psig_class x0 ->\n Ast_409.Parsetree.Psig_class (List.map copy_class_description x0)\n | Ast_408.Parsetree.Psig_class_type x0 ->\n Ast_409.Parsetree.Psig_class_type\n (List.map copy_class_type_declaration x0)\n | Ast_408.Parsetree.Psig_attribute x0 ->\n Ast_409.Parsetree.Psig_attribute (copy_attribute x0)\n | Ast_408.Parsetree.Psig_extension (x0, x1) ->\n Ast_409.Parsetree.Psig_extension (copy_extension x0, copy_attributes x1)\n\nand copy_class_type_declaration :\n Ast_408.Parsetree.class_type_declaration ->\n Ast_409.Parsetree.class_type_declaration =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_description :\n Ast_408.Parsetree.class_description -> Ast_409.Parsetree.class_description =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_type :\n Ast_408.Parsetree.class_type -> Ast_409.Parsetree.class_type =\n fun {\n Ast_408.Parsetree.pcty_desc;\n Ast_408.Parsetree.pcty_loc;\n Ast_408.Parsetree.pcty_attributes;\n } ->\n {\n Ast_409.Parsetree.pcty_desc = copy_class_type_desc pcty_desc;\n Ast_409.Parsetree.pcty_loc = copy_location pcty_loc;\n Ast_409.Parsetree.pcty_attributes = copy_attributes pcty_attributes;\n }\n\nand copy_class_type_desc :\n Ast_408.Parsetree.class_type_desc -> Ast_409.Parsetree.class_type_desc =\n function\n | Ast_408.Parsetree.Pcty_constr (x0, x1) ->\n Ast_409.Parsetree.Pcty_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_408.Parsetree.Pcty_signature x0 ->\n Ast_409.Parsetree.Pcty_signature (copy_class_signature x0)\n | Ast_408.Parsetree.Pcty_arrow (x0, x1, x2) ->\n Ast_409.Parsetree.Pcty_arrow\n (copy_arg_label x0, copy_core_type x1, copy_class_type x2)\n | Ast_408.Parsetree.Pcty_extension x0 ->\n Ast_409.Parsetree.Pcty_extension (copy_extension x0)\n | Ast_408.Parsetree.Pcty_open (x0, x1) ->\n Ast_409.Parsetree.Pcty_open (copy_open_description x0, copy_class_type x1)\n\nand copy_class_signature :\n Ast_408.Parsetree.class_signature -> Ast_409.Parsetree.class_signature =\n fun { Ast_408.Parsetree.pcsig_self; Ast_408.Parsetree.pcsig_fields } ->\n {\n Ast_409.Parsetree.pcsig_self = copy_core_type pcsig_self;\n Ast_409.Parsetree.pcsig_fields = List.map copy_class_type_field pcsig_fields;\n }\n\nand copy_class_type_field :\n Ast_408.Parsetree.class_type_field -> Ast_409.Parsetree.class_type_field =\n fun {\n Ast_408.Parsetree.pctf_desc;\n Ast_408.Parsetree.pctf_loc;\n Ast_408.Parsetree.pctf_attributes;\n } ->\n {\n Ast_409.Parsetree.pctf_desc = copy_class_type_field_desc pctf_desc;\n Ast_409.Parsetree.pctf_loc = copy_location pctf_loc;\n Ast_409.Parsetree.pctf_attributes = copy_attributes pctf_attributes;\n }\n\nand copy_class_type_field_desc :\n Ast_408.Parsetree.class_type_field_desc ->\n Ast_409.Parsetree.class_type_field_desc = function\n | Ast_408.Parsetree.Pctf_inherit x0 ->\n Ast_409.Parsetree.Pctf_inherit (copy_class_type x0)\n | Ast_408.Parsetree.Pctf_val x0 ->\n Ast_409.Parsetree.Pctf_val\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_mutable_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | Ast_408.Parsetree.Pctf_method x0 ->\n Ast_409.Parsetree.Pctf_method\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_private_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | Ast_408.Parsetree.Pctf_constraint x0 ->\n Ast_409.Parsetree.Pctf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | Ast_408.Parsetree.Pctf_attribute x0 ->\n Ast_409.Parsetree.Pctf_attribute (copy_attribute x0)\n | Ast_408.Parsetree.Pctf_extension x0 ->\n Ast_409.Parsetree.Pctf_extension (copy_extension x0)\n\nand copy_extension : Ast_408.Parsetree.extension -> Ast_409.Parsetree.extension\n =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_class_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_408.Parsetree.class_infos ->\n 'g0 Ast_409.Parsetree.class_infos =\n fun f0\n {\n Ast_408.Parsetree.pci_virt;\n Ast_408.Parsetree.pci_params;\n Ast_408.Parsetree.pci_name;\n Ast_408.Parsetree.pci_expr;\n Ast_408.Parsetree.pci_loc;\n Ast_408.Parsetree.pci_attributes;\n } ->\n {\n Ast_409.Parsetree.pci_virt = copy_virtual_flag pci_virt;\n Ast_409.Parsetree.pci_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n pci_params;\n Ast_409.Parsetree.pci_name = copy_loc (fun x -> x) pci_name;\n Ast_409.Parsetree.pci_expr = f0 pci_expr;\n Ast_409.Parsetree.pci_loc = copy_location pci_loc;\n Ast_409.Parsetree.pci_attributes = copy_attributes pci_attributes;\n }\n\nand copy_virtual_flag :\n Ast_408.Asttypes.virtual_flag -> Ast_409.Asttypes.virtual_flag = function\n | Ast_408.Asttypes.Virtual -> Ast_409.Asttypes.Virtual\n | Ast_408.Asttypes.Concrete -> Ast_409.Asttypes.Concrete\n\nand copy_include_description :\n Ast_408.Parsetree.include_description ->\n Ast_409.Parsetree.include_description =\n fun x -> copy_include_infos copy_module_type x\n\nand copy_include_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_408.Parsetree.include_infos ->\n 'g0 Ast_409.Parsetree.include_infos =\n fun f0\n {\n Ast_408.Parsetree.pincl_mod;\n Ast_408.Parsetree.pincl_loc;\n Ast_408.Parsetree.pincl_attributes;\n } ->\n {\n Ast_409.Parsetree.pincl_mod = f0 pincl_mod;\n Ast_409.Parsetree.pincl_loc = copy_location pincl_loc;\n Ast_409.Parsetree.pincl_attributes = copy_attributes pincl_attributes;\n }\n\nand copy_open_description :\n Ast_408.Parsetree.open_description -> Ast_409.Parsetree.open_description =\n fun x -> copy_open_infos (fun x -> copy_loc copy_Longident_t x) x\n\nand copy_open_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_408.Parsetree.open_infos ->\n 'g0 Ast_409.Parsetree.open_infos =\n fun f0\n {\n Ast_408.Parsetree.popen_expr;\n Ast_408.Parsetree.popen_override;\n Ast_408.Parsetree.popen_loc;\n Ast_408.Parsetree.popen_attributes;\n } ->\n {\n Ast_409.Parsetree.popen_expr = f0 popen_expr;\n Ast_409.Parsetree.popen_override = copy_override_flag popen_override;\n Ast_409.Parsetree.popen_loc = copy_location popen_loc;\n Ast_409.Parsetree.popen_attributes = copy_attributes popen_attributes;\n }\n\nand copy_override_flag :\n Ast_408.Asttypes.override_flag -> Ast_409.Asttypes.override_flag = function\n | Ast_408.Asttypes.Override -> Ast_409.Asttypes.Override\n | Ast_408.Asttypes.Fresh -> Ast_409.Asttypes.Fresh\n\nand copy_module_type_declaration :\n Ast_408.Parsetree.module_type_declaration ->\n Ast_409.Parsetree.module_type_declaration =\n fun {\n Ast_408.Parsetree.pmtd_name;\n Ast_408.Parsetree.pmtd_type;\n Ast_408.Parsetree.pmtd_attributes;\n Ast_408.Parsetree.pmtd_loc;\n } ->\n {\n Ast_409.Parsetree.pmtd_name = copy_loc (fun x -> x) pmtd_name;\n Ast_409.Parsetree.pmtd_type = Option.map copy_module_type pmtd_type;\n Ast_409.Parsetree.pmtd_attributes = copy_attributes pmtd_attributes;\n Ast_409.Parsetree.pmtd_loc = copy_location pmtd_loc;\n }\n\nand copy_module_substitution :\n Ast_408.Parsetree.module_substitution ->\n Ast_409.Parsetree.module_substitution =\n fun {\n Ast_408.Parsetree.pms_name;\n Ast_408.Parsetree.pms_manifest;\n Ast_408.Parsetree.pms_attributes;\n Ast_408.Parsetree.pms_loc;\n } ->\n {\n Ast_409.Parsetree.pms_name = copy_loc (fun x -> x) pms_name;\n Ast_409.Parsetree.pms_manifest = copy_loc copy_Longident_t pms_manifest;\n Ast_409.Parsetree.pms_attributes = copy_attributes pms_attributes;\n Ast_409.Parsetree.pms_loc = copy_location pms_loc;\n }\n\nand copy_module_declaration :\n Ast_408.Parsetree.module_declaration -> Ast_409.Parsetree.module_declaration\n =\n fun {\n Ast_408.Parsetree.pmd_name;\n Ast_408.Parsetree.pmd_type;\n Ast_408.Parsetree.pmd_attributes;\n Ast_408.Parsetree.pmd_loc;\n } ->\n {\n Ast_409.Parsetree.pmd_name = copy_loc (fun x -> x) pmd_name;\n Ast_409.Parsetree.pmd_type = copy_module_type pmd_type;\n Ast_409.Parsetree.pmd_attributes = copy_attributes pmd_attributes;\n Ast_409.Parsetree.pmd_loc = copy_location pmd_loc;\n }\n\nand copy_type_exception :\n Ast_408.Parsetree.type_exception -> Ast_409.Parsetree.type_exception =\n fun {\n Ast_408.Parsetree.ptyexn_constructor;\n Ast_408.Parsetree.ptyexn_loc;\n Ast_408.Parsetree.ptyexn_attributes;\n } ->\n {\n Ast_409.Parsetree.ptyexn_constructor =\n copy_extension_constructor ptyexn_constructor;\n Ast_409.Parsetree.ptyexn_loc = copy_location ptyexn_loc;\n Ast_409.Parsetree.ptyexn_attributes = copy_attributes ptyexn_attributes;\n }\n\nand copy_type_extension :\n Ast_408.Parsetree.type_extension -> Ast_409.Parsetree.type_extension =\n fun {\n Ast_408.Parsetree.ptyext_path;\n Ast_408.Parsetree.ptyext_params;\n Ast_408.Parsetree.ptyext_constructors;\n Ast_408.Parsetree.ptyext_private;\n Ast_408.Parsetree.ptyext_loc;\n Ast_408.Parsetree.ptyext_attributes;\n } ->\n {\n Ast_409.Parsetree.ptyext_path = copy_loc copy_Longident_t ptyext_path;\n Ast_409.Parsetree.ptyext_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptyext_params;\n Ast_409.Parsetree.ptyext_constructors =\n List.map copy_extension_constructor ptyext_constructors;\n Ast_409.Parsetree.ptyext_private = copy_private_flag ptyext_private;\n Ast_409.Parsetree.ptyext_loc = copy_location ptyext_loc;\n Ast_409.Parsetree.ptyext_attributes = copy_attributes ptyext_attributes;\n }\n\nand copy_extension_constructor :\n Ast_408.Parsetree.extension_constructor ->\n Ast_409.Parsetree.extension_constructor =\n fun {\n Ast_408.Parsetree.pext_name;\n Ast_408.Parsetree.pext_kind;\n Ast_408.Parsetree.pext_loc;\n Ast_408.Parsetree.pext_attributes;\n } ->\n {\n Ast_409.Parsetree.pext_name = copy_loc (fun x -> x) pext_name;\n Ast_409.Parsetree.pext_kind = copy_extension_constructor_kind pext_kind;\n Ast_409.Parsetree.pext_loc = copy_location pext_loc;\n Ast_409.Parsetree.pext_attributes = copy_attributes pext_attributes;\n }\n\nand copy_extension_constructor_kind :\n Ast_408.Parsetree.extension_constructor_kind ->\n Ast_409.Parsetree.extension_constructor_kind = function\n | Ast_408.Parsetree.Pext_decl (x0, x1) ->\n Ast_409.Parsetree.Pext_decl\n (copy_constructor_arguments x0, Option.map copy_core_type x1)\n | Ast_408.Parsetree.Pext_rebind x0 ->\n Ast_409.Parsetree.Pext_rebind (copy_loc copy_Longident_t x0)\n\nand copy_type_declaration :\n Ast_408.Parsetree.type_declaration -> Ast_409.Parsetree.type_declaration =\n fun {\n Ast_408.Parsetree.ptype_name;\n Ast_408.Parsetree.ptype_params;\n Ast_408.Parsetree.ptype_cstrs;\n Ast_408.Parsetree.ptype_kind;\n Ast_408.Parsetree.ptype_private;\n Ast_408.Parsetree.ptype_manifest;\n Ast_408.Parsetree.ptype_attributes;\n Ast_408.Parsetree.ptype_loc;\n } ->\n {\n Ast_409.Parsetree.ptype_name = copy_loc (fun x -> x) ptype_name;\n Ast_409.Parsetree.ptype_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptype_params;\n Ast_409.Parsetree.ptype_cstrs =\n List.map\n (fun x ->\n let x0, x1, x2 = x in\n (copy_core_type x0, copy_core_type x1, copy_location x2))\n ptype_cstrs;\n Ast_409.Parsetree.ptype_kind = copy_type_kind ptype_kind;\n Ast_409.Parsetree.ptype_private = copy_private_flag ptype_private;\n Ast_409.Parsetree.ptype_manifest = Option.map copy_core_type ptype_manifest;\n Ast_409.Parsetree.ptype_attributes = copy_attributes ptype_attributes;\n Ast_409.Parsetree.ptype_loc = copy_location ptype_loc;\n }\n\nand copy_private_flag :\n Ast_408.Asttypes.private_flag -> Ast_409.Asttypes.private_flag = function\n | Ast_408.Asttypes.Private -> Ast_409.Asttypes.Private\n | Ast_408.Asttypes.Public -> Ast_409.Asttypes.Public\n\nand copy_type_kind : Ast_408.Parsetree.type_kind -> Ast_409.Parsetree.type_kind\n = function\n | Ast_408.Parsetree.Ptype_abstract -> Ast_409.Parsetree.Ptype_abstract\n | Ast_408.Parsetree.Ptype_variant x0 ->\n Ast_409.Parsetree.Ptype_variant (List.map copy_constructor_declaration x0)\n | Ast_408.Parsetree.Ptype_record x0 ->\n Ast_409.Parsetree.Ptype_record (List.map copy_label_declaration x0)\n | Ast_408.Parsetree.Ptype_open -> Ast_409.Parsetree.Ptype_open\n\nand copy_constructor_declaration :\n Ast_408.Parsetree.constructor_declaration ->\n Ast_409.Parsetree.constructor_declaration =\n fun {\n Ast_408.Parsetree.pcd_name;\n Ast_408.Parsetree.pcd_args;\n Ast_408.Parsetree.pcd_res;\n Ast_408.Parsetree.pcd_loc;\n Ast_408.Parsetree.pcd_attributes;\n } ->\n {\n Ast_409.Parsetree.pcd_name = copy_loc (fun x -> x) pcd_name;\n Ast_409.Parsetree.pcd_args = copy_constructor_arguments pcd_args;\n Ast_409.Parsetree.pcd_res = Option.map copy_core_type pcd_res;\n Ast_409.Parsetree.pcd_loc = copy_location pcd_loc;\n Ast_409.Parsetree.pcd_attributes = copy_attributes pcd_attributes;\n }\n\nand copy_constructor_arguments :\n Ast_408.Parsetree.constructor_arguments ->\n Ast_409.Parsetree.constructor_arguments = function\n | Ast_408.Parsetree.Pcstr_tuple x0 ->\n Ast_409.Parsetree.Pcstr_tuple (List.map copy_core_type x0)\n | Ast_408.Parsetree.Pcstr_record x0 ->\n Ast_409.Parsetree.Pcstr_record (List.map copy_label_declaration x0)\n\nand copy_label_declaration :\n Ast_408.Parsetree.label_declaration -> Ast_409.Parsetree.label_declaration =\n fun {\n Ast_408.Parsetree.pld_name;\n Ast_408.Parsetree.pld_mutable;\n Ast_408.Parsetree.pld_type;\n Ast_408.Parsetree.pld_loc;\n Ast_408.Parsetree.pld_attributes;\n } ->\n {\n Ast_409.Parsetree.pld_name = copy_loc (fun x -> x) pld_name;\n Ast_409.Parsetree.pld_mutable = copy_mutable_flag pld_mutable;\n Ast_409.Parsetree.pld_type = copy_core_type pld_type;\n Ast_409.Parsetree.pld_loc = copy_location pld_loc;\n Ast_409.Parsetree.pld_attributes = copy_attributes pld_attributes;\n }\n\nand copy_mutable_flag :\n Ast_408.Asttypes.mutable_flag -> Ast_409.Asttypes.mutable_flag = function\n | Ast_408.Asttypes.Immutable -> Ast_409.Asttypes.Immutable\n | Ast_408.Asttypes.Mutable -> Ast_409.Asttypes.Mutable\n\nand copy_variance : Ast_408.Asttypes.variance -> Ast_409.Asttypes.variance =\n function\n | Ast_408.Asttypes.Covariant -> Ast_409.Asttypes.Covariant\n | Ast_408.Asttypes.Contravariant -> Ast_409.Asttypes.Contravariant\n | Ast_408.Asttypes.Invariant -> Ast_409.Asttypes.Invariant\n\nand copy_value_description :\n Ast_408.Parsetree.value_description -> Ast_409.Parsetree.value_description =\n fun {\n Ast_408.Parsetree.pval_name;\n Ast_408.Parsetree.pval_type;\n Ast_408.Parsetree.pval_prim;\n Ast_408.Parsetree.pval_attributes;\n Ast_408.Parsetree.pval_loc;\n } ->\n {\n Ast_409.Parsetree.pval_name = copy_loc (fun x -> x) pval_name;\n Ast_409.Parsetree.pval_type = copy_core_type pval_type;\n Ast_409.Parsetree.pval_prim = List.map (fun x -> x) pval_prim;\n Ast_409.Parsetree.pval_attributes = copy_attributes pval_attributes;\n Ast_409.Parsetree.pval_loc = copy_location pval_loc;\n }\n\nand copy_object_field_desc :\n Ast_408.Parsetree.object_field_desc -> Ast_409.Parsetree.object_field_desc =\n function\n | Ast_408.Parsetree.Otag (x0, x1) ->\n Ast_409.Parsetree.Otag (copy_loc copy_label x0, copy_core_type x1)\n | Ast_408.Parsetree.Oinherit x0 ->\n Ast_409.Parsetree.Oinherit (copy_core_type x0)\n\nand copy_arg_label : Ast_408.Asttypes.arg_label -> Ast_409.Asttypes.arg_label =\n function\n | Ast_408.Asttypes.Nolabel -> Ast_409.Asttypes.Nolabel\n | Ast_408.Asttypes.Labelled x0 -> Ast_409.Asttypes.Labelled x0\n | Ast_408.Asttypes.Optional x0 -> Ast_409.Asttypes.Optional x0\n\nand copy_closed_flag :\n Ast_408.Asttypes.closed_flag -> Ast_409.Asttypes.closed_flag = function\n | Ast_408.Asttypes.Closed -> Ast_409.Asttypes.Closed\n | Ast_408.Asttypes.Open -> Ast_409.Asttypes.Open\n\nand copy_label : Ast_408.Asttypes.label -> Ast_409.Asttypes.label = fun x -> x\n\nand copy_rec_flag : Ast_408.Asttypes.rec_flag -> Ast_409.Asttypes.rec_flag =\n function\n | Ast_408.Asttypes.Nonrecursive -> Ast_409.Asttypes.Nonrecursive\n | Ast_408.Asttypes.Recursive -> Ast_409.Asttypes.Recursive\n\nand copy_constant : Ast_408.Parsetree.constant -> Ast_409.Parsetree.constant =\n function\n | Ast_408.Parsetree.Pconst_integer (x0, x1) ->\n Ast_409.Parsetree.Pconst_integer (x0, Option.map (fun x -> x) x1)\n | Ast_408.Parsetree.Pconst_char x0 -> Ast_409.Parsetree.Pconst_char x0\n | Ast_408.Parsetree.Pconst_string (x0, x1) ->\n Ast_409.Parsetree.Pconst_string (x0, Option.map (fun x -> x) x1)\n | Ast_408.Parsetree.Pconst_float (x0, x1) ->\n Ast_409.Parsetree.Pconst_float (x0, Option.map (fun x -> x) x1)\n\nand copy_Longident_t : Longident.t -> Longident.t = fun x -> x\n\nand copy_loc :\n 'f0 'g0.\n ('f0 -> 'g0) -> 'f0 Ast_408.Asttypes.loc -> 'g0 Ast_409.Asttypes.loc =\n fun f0 { Ast_408.Asttypes.txt; Ast_408.Asttypes.loc } ->\n { Ast_409.Asttypes.txt = f0 txt; Ast_409.Asttypes.loc = copy_location loc }\n\nand copy_location : Location.t -> Location.t = fun x -> x\n","module From = Ast_408\nmodule To = Ast_407\n\nlet migration_error loc missing_feature =\n Location.raise_errorf ~loc\n \"migration error: %s is not supported before OCaml 4.08\" missing_feature\n\nlet rec copy_toplevel_phrase :\n From.Parsetree.toplevel_phrase -> To.Parsetree.toplevel_phrase = function\n | From.Parsetree.Ptop_def x0 -> To.Parsetree.Ptop_def (copy_structure x0)\n | From.Parsetree.Ptop_dir\n {\n From.Parsetree.pdir_name;\n From.Parsetree.pdir_arg;\n From.Parsetree.pdir_loc = _;\n } ->\n To.Parsetree.Ptop_dir\n ( pdir_name.Location.txt,\n match pdir_arg with\n | None -> To.Parsetree.Pdir_none\n | Some arg -> copy_directive_argument arg )\n\nand copy_directive_argument :\n From.Parsetree.directive_argument -> To.Parsetree.directive_argument =\n fun { From.Parsetree.pdira_desc; From.Parsetree.pdira_loc = _pdira_loc } ->\n copy_directive_argument_desc pdira_desc\n\nand copy_directive_argument_desc :\n From.Parsetree.directive_argument_desc -> To.Parsetree.directive_argument =\n function\n | From.Parsetree.Pdir_string x0 -> To.Parsetree.Pdir_string x0\n | From.Parsetree.Pdir_int (x0, x1) ->\n To.Parsetree.Pdir_int (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pdir_ident x0 -> To.Parsetree.Pdir_ident (copy_longident x0)\n | From.Parsetree.Pdir_bool x0 -> To.Parsetree.Pdir_bool (copy_bool x0)\n\nand copy_expression : From.Parsetree.expression -> To.Parsetree.expression =\n fun {\n From.Parsetree.pexp_desc;\n From.Parsetree.pexp_loc;\n From.Parsetree.pexp_loc_stack = _;\n From.Parsetree.pexp_attributes;\n } ->\n {\n To.Parsetree.pexp_desc = copy_expression_desc pexp_desc;\n To.Parsetree.pexp_loc = copy_location pexp_loc;\n To.Parsetree.pexp_attributes = copy_attributes pexp_attributes;\n }\n\nand copy_expression_desc :\n From.Parsetree.expression_desc -> To.Parsetree.expression_desc = function\n | From.Parsetree.Pexp_ident x0 ->\n To.Parsetree.Pexp_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pexp_constant x0 ->\n To.Parsetree.Pexp_constant (copy_constant x0)\n | From.Parsetree.Pexp_let (x0, x1, x2) ->\n To.Parsetree.Pexp_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_expression x2)\n | From.Parsetree.Pexp_function x0 ->\n To.Parsetree.Pexp_function (List.map copy_case x0)\n | From.Parsetree.Pexp_fun (x0, x1, x2, x3) ->\n To.Parsetree.Pexp_fun\n ( copy_arg_label x0,\n copy_option copy_expression x1,\n copy_pattern x2,\n copy_expression x3 )\n | From.Parsetree.Pexp_apply (x0, x1) ->\n To.Parsetree.Pexp_apply\n ( copy_expression x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | From.Parsetree.Pexp_match (x0, x1) ->\n To.Parsetree.Pexp_match (copy_expression x0, List.map copy_case x1)\n | From.Parsetree.Pexp_try (x0, x1) ->\n To.Parsetree.Pexp_try (copy_expression x0, List.map copy_case x1)\n | From.Parsetree.Pexp_tuple x0 ->\n To.Parsetree.Pexp_tuple (List.map copy_expression x0)\n | From.Parsetree.Pexp_construct (x0, x1) ->\n To.Parsetree.Pexp_construct\n (copy_loc copy_longident x0, copy_option copy_expression x1)\n | From.Parsetree.Pexp_variant (x0, x1) ->\n To.Parsetree.Pexp_variant (copy_label x0, copy_option copy_expression x1)\n | From.Parsetree.Pexp_record (x0, x1) ->\n To.Parsetree.Pexp_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_expression x1))\n x0,\n copy_option copy_expression x1 )\n | From.Parsetree.Pexp_field (x0, x1) ->\n To.Parsetree.Pexp_field (copy_expression x0, copy_loc copy_longident x1)\n | From.Parsetree.Pexp_setfield (x0, x1, x2) ->\n To.Parsetree.Pexp_setfield\n (copy_expression x0, copy_loc copy_longident x1, copy_expression x2)\n | From.Parsetree.Pexp_array x0 ->\n To.Parsetree.Pexp_array (List.map copy_expression x0)\n | From.Parsetree.Pexp_ifthenelse (x0, x1, x2) ->\n To.Parsetree.Pexp_ifthenelse\n (copy_expression x0, copy_expression x1, copy_option copy_expression x2)\n | From.Parsetree.Pexp_sequence (x0, x1) ->\n To.Parsetree.Pexp_sequence (copy_expression x0, copy_expression x1)\n | From.Parsetree.Pexp_while (x0, x1) ->\n To.Parsetree.Pexp_while (copy_expression x0, copy_expression x1)\n | From.Parsetree.Pexp_for (x0, x1, x2, x3, x4) ->\n To.Parsetree.Pexp_for\n ( copy_pattern x0,\n copy_expression x1,\n copy_expression x2,\n copy_direction_flag x3,\n copy_expression x4 )\n | From.Parsetree.Pexp_constraint (x0, x1) ->\n To.Parsetree.Pexp_constraint (copy_expression x0, copy_core_type x1)\n | From.Parsetree.Pexp_coerce (x0, x1, x2) ->\n To.Parsetree.Pexp_coerce\n (copy_expression x0, copy_option copy_core_type x1, copy_core_type x2)\n | From.Parsetree.Pexp_send (x0, x1) ->\n To.Parsetree.Pexp_send (copy_expression x0, copy_loc copy_label x1)\n | From.Parsetree.Pexp_new x0 ->\n To.Parsetree.Pexp_new (copy_loc copy_longident x0)\n | From.Parsetree.Pexp_setinstvar (x0, x1) ->\n To.Parsetree.Pexp_setinstvar (copy_loc copy_label x0, copy_expression x1)\n | From.Parsetree.Pexp_override x0 ->\n To.Parsetree.Pexp_override\n (List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_label x0, copy_expression x1))\n x0)\n | From.Parsetree.Pexp_letmodule (x0, x1, x2) ->\n To.Parsetree.Pexp_letmodule\n (copy_loc (fun x -> x) x0, copy_module_expr x1, copy_expression x2)\n | From.Parsetree.Pexp_letexception (x0, x1) ->\n To.Parsetree.Pexp_letexception\n (copy_extension_constructor x0, copy_expression x1)\n | From.Parsetree.Pexp_assert x0 ->\n To.Parsetree.Pexp_assert (copy_expression x0)\n | From.Parsetree.Pexp_lazy x0 -> To.Parsetree.Pexp_lazy (copy_expression x0)\n | From.Parsetree.Pexp_poly (x0, x1) ->\n To.Parsetree.Pexp_poly (copy_expression x0, copy_option copy_core_type x1)\n | From.Parsetree.Pexp_object x0 ->\n To.Parsetree.Pexp_object (copy_class_structure x0)\n | From.Parsetree.Pexp_newtype (x0, x1) ->\n To.Parsetree.Pexp_newtype (copy_loc (fun x -> x) x0, copy_expression x1)\n | From.Parsetree.Pexp_pack x0 -> To.Parsetree.Pexp_pack (copy_module_expr x0)\n | From.Parsetree.Pexp_open (x0, x1) -> (\n match x0.From.Parsetree.popen_expr.From.Parsetree.pmod_desc with\n | Pmod_ident lid ->\n To.Parsetree.Pexp_open\n ( copy_override_flag x0.From.Parsetree.popen_override,\n copy_loc copy_longident lid,\n copy_expression x1 )\n | Pmod_structure _ | Pmod_functor _ | Pmod_apply _ | Pmod_constraint _\n | Pmod_unpack _ | Pmod_extension _ ->\n migration_error x0.From.Parsetree.popen_loc \"complex open\")\n | From.Parsetree.Pexp_letop { let_; ands = _; body = _ } ->\n migration_error let_.pbop_op.loc \"let operators\"\n | From.Parsetree.Pexp_extension x0 ->\n To.Parsetree.Pexp_extension (copy_extension x0)\n | From.Parsetree.Pexp_unreachable -> To.Parsetree.Pexp_unreachable\n\nand copy_direction_flag :\n From.Asttypes.direction_flag -> To.Asttypes.direction_flag = function\n | From.Asttypes.Upto -> To.Asttypes.Upto\n | From.Asttypes.Downto -> To.Asttypes.Downto\n\nand copy_case : From.Parsetree.case -> To.Parsetree.case =\n fun { From.Parsetree.pc_lhs; From.Parsetree.pc_guard; From.Parsetree.pc_rhs } ->\n {\n To.Parsetree.pc_lhs = copy_pattern pc_lhs;\n To.Parsetree.pc_guard = copy_option copy_expression pc_guard;\n To.Parsetree.pc_rhs = copy_expression pc_rhs;\n }\n\nand copy_value_binding :\n From.Parsetree.value_binding -> To.Parsetree.value_binding =\n fun {\n From.Parsetree.pvb_pat;\n From.Parsetree.pvb_expr;\n From.Parsetree.pvb_attributes;\n From.Parsetree.pvb_loc;\n } ->\n {\n To.Parsetree.pvb_pat = copy_pattern pvb_pat;\n To.Parsetree.pvb_expr = copy_expression pvb_expr;\n To.Parsetree.pvb_attributes = copy_attributes pvb_attributes;\n To.Parsetree.pvb_loc = copy_location pvb_loc;\n }\n\nand copy_pattern : From.Parsetree.pattern -> To.Parsetree.pattern =\n fun {\n From.Parsetree.ppat_desc;\n From.Parsetree.ppat_loc;\n From.Parsetree.ppat_loc_stack = _;\n From.Parsetree.ppat_attributes;\n } ->\n {\n To.Parsetree.ppat_desc = copy_pattern_desc ppat_desc;\n To.Parsetree.ppat_loc = copy_location ppat_loc;\n To.Parsetree.ppat_attributes = copy_attributes ppat_attributes;\n }\n\nand copy_pattern_desc : From.Parsetree.pattern_desc -> To.Parsetree.pattern_desc\n = function\n | From.Parsetree.Ppat_any -> To.Parsetree.Ppat_any\n | From.Parsetree.Ppat_var x0 ->\n To.Parsetree.Ppat_var (copy_loc (fun x -> x) x0)\n | From.Parsetree.Ppat_alias (x0, x1) ->\n To.Parsetree.Ppat_alias (copy_pattern x0, copy_loc (fun x -> x) x1)\n | From.Parsetree.Ppat_constant x0 ->\n To.Parsetree.Ppat_constant (copy_constant x0)\n | From.Parsetree.Ppat_interval (x0, x1) ->\n To.Parsetree.Ppat_interval (copy_constant x0, copy_constant x1)\n | From.Parsetree.Ppat_tuple x0 ->\n To.Parsetree.Ppat_tuple (List.map copy_pattern x0)\n | From.Parsetree.Ppat_construct (x0, x1) ->\n To.Parsetree.Ppat_construct\n (copy_loc copy_longident x0, copy_option copy_pattern x1)\n | From.Parsetree.Ppat_variant (x0, x1) ->\n To.Parsetree.Ppat_variant (copy_label x0, copy_option copy_pattern x1)\n | From.Parsetree.Ppat_record (x0, x1) ->\n To.Parsetree.Ppat_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_pattern x1))\n x0,\n copy_closed_flag x1 )\n | From.Parsetree.Ppat_array x0 ->\n To.Parsetree.Ppat_array (List.map copy_pattern x0)\n | From.Parsetree.Ppat_or (x0, x1) ->\n To.Parsetree.Ppat_or (copy_pattern x0, copy_pattern x1)\n | From.Parsetree.Ppat_constraint (x0, x1) ->\n To.Parsetree.Ppat_constraint (copy_pattern x0, copy_core_type x1)\n | From.Parsetree.Ppat_type x0 ->\n To.Parsetree.Ppat_type (copy_loc copy_longident x0)\n | From.Parsetree.Ppat_lazy x0 -> To.Parsetree.Ppat_lazy (copy_pattern x0)\n | From.Parsetree.Ppat_unpack x0 ->\n To.Parsetree.Ppat_unpack (copy_loc (fun x -> x) x0)\n | From.Parsetree.Ppat_exception x0 ->\n To.Parsetree.Ppat_exception (copy_pattern x0)\n | From.Parsetree.Ppat_extension x0 ->\n To.Parsetree.Ppat_extension (copy_extension x0)\n | From.Parsetree.Ppat_open (x0, x1) ->\n To.Parsetree.Ppat_open (copy_loc copy_longident x0, copy_pattern x1)\n\nand copy_core_type : From.Parsetree.core_type -> To.Parsetree.core_type =\n fun {\n From.Parsetree.ptyp_desc;\n From.Parsetree.ptyp_loc;\n From.Parsetree.ptyp_loc_stack = _;\n From.Parsetree.ptyp_attributes;\n } ->\n {\n To.Parsetree.ptyp_desc = copy_core_type_desc ptyp_desc;\n To.Parsetree.ptyp_loc = copy_location ptyp_loc;\n To.Parsetree.ptyp_attributes = copy_attributes ptyp_attributes;\n }\n\nand copy_core_type_desc :\n From.Parsetree.core_type_desc -> To.Parsetree.core_type_desc = function\n | From.Parsetree.Ptyp_any -> To.Parsetree.Ptyp_any\n | From.Parsetree.Ptyp_var x0 -> To.Parsetree.Ptyp_var x0\n | From.Parsetree.Ptyp_arrow (x0, x1, x2) ->\n To.Parsetree.Ptyp_arrow\n (copy_arg_label x0, copy_core_type x1, copy_core_type x2)\n | From.Parsetree.Ptyp_tuple x0 ->\n To.Parsetree.Ptyp_tuple (List.map copy_core_type x0)\n | From.Parsetree.Ptyp_constr (x0, x1) ->\n To.Parsetree.Ptyp_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Ptyp_object (x0, x1) ->\n To.Parsetree.Ptyp_object\n (List.map copy_object_field x0, copy_closed_flag x1)\n | From.Parsetree.Ptyp_class (x0, x1) ->\n To.Parsetree.Ptyp_class\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Ptyp_alias (x0, x1) ->\n To.Parsetree.Ptyp_alias (copy_core_type x0, x1)\n | From.Parsetree.Ptyp_variant (x0, x1, x2) ->\n To.Parsetree.Ptyp_variant\n ( List.map copy_row_field x0,\n copy_closed_flag x1,\n copy_option (fun x -> List.map copy_label x) x2 )\n | From.Parsetree.Ptyp_poly (x0, x1) ->\n To.Parsetree.Ptyp_poly\n (List.map (fun x -> copy_loc (fun x -> x) x) x0, copy_core_type x1)\n | From.Parsetree.Ptyp_package x0 ->\n To.Parsetree.Ptyp_package (copy_package_type x0)\n | From.Parsetree.Ptyp_extension x0 ->\n To.Parsetree.Ptyp_extension (copy_extension x0)\n\nand copy_package_type : From.Parsetree.package_type -> To.Parsetree.package_type\n =\n fun x ->\n let x0, x1 = x in\n ( copy_loc copy_longident x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_core_type x1))\n x1 )\n\nand copy_row_field : From.Parsetree.row_field -> To.Parsetree.row_field =\n fun {\n From.Parsetree.prf_desc;\n From.Parsetree.prf_loc = _;\n From.Parsetree.prf_attributes;\n } ->\n match prf_desc with\n | From.Parsetree.Rtag (x0, x1, x2) ->\n To.Parsetree.Rtag\n ( copy_loc copy_label x0,\n copy_attributes prf_attributes,\n copy_bool x1,\n List.map copy_core_type x2 )\n | From.Parsetree.Rinherit x0 -> To.Parsetree.Rinherit (copy_core_type x0)\n\nand copy_object_field : From.Parsetree.object_field -> To.Parsetree.object_field\n =\n fun {\n From.Parsetree.pof_desc;\n From.Parsetree.pof_loc = _;\n From.Parsetree.pof_attributes;\n } ->\n match pof_desc with\n | From.Parsetree.Otag (x0, x1) ->\n To.Parsetree.Otag\n ( copy_loc copy_label x0,\n copy_attributes pof_attributes,\n copy_core_type x1 )\n | From.Parsetree.Oinherit x0 -> To.Parsetree.Oinherit (copy_core_type x0)\n\nand copy_attributes : From.Parsetree.attributes -> To.Parsetree.attributes =\n fun x -> List.map copy_attribute x\n\nand copy_attribute : From.Parsetree.attribute -> To.Parsetree.attribute =\n fun {\n From.Parsetree.attr_name;\n From.Parsetree.attr_payload;\n From.Parsetree.attr_loc = _;\n } ->\n (copy_loc (fun x -> x) attr_name, copy_payload attr_payload)\n\nand copy_payload : From.Parsetree.payload -> To.Parsetree.payload = function\n | From.Parsetree.PStr x0 -> To.Parsetree.PStr (copy_structure x0)\n | From.Parsetree.PSig x0 -> To.Parsetree.PSig (copy_signature x0)\n | From.Parsetree.PTyp x0 -> To.Parsetree.PTyp (copy_core_type x0)\n | From.Parsetree.PPat (x0, x1) ->\n To.Parsetree.PPat (copy_pattern x0, copy_option copy_expression x1)\n\nand copy_structure : From.Parsetree.structure -> To.Parsetree.structure =\n fun x -> List.map copy_structure_item x\n\nand copy_structure_item :\n From.Parsetree.structure_item -> To.Parsetree.structure_item =\n fun { From.Parsetree.pstr_desc; From.Parsetree.pstr_loc } ->\n {\n To.Parsetree.pstr_desc = copy_structure_item_desc pstr_desc;\n To.Parsetree.pstr_loc = copy_location pstr_loc;\n }\n\nand copy_structure_item_desc :\n From.Parsetree.structure_item_desc -> To.Parsetree.structure_item_desc =\n function\n | From.Parsetree.Pstr_eval (x0, x1) ->\n To.Parsetree.Pstr_eval (copy_expression x0, copy_attributes x1)\n | From.Parsetree.Pstr_value (x0, x1) ->\n To.Parsetree.Pstr_value (copy_rec_flag x0, List.map copy_value_binding x1)\n | From.Parsetree.Pstr_primitive x0 ->\n To.Parsetree.Pstr_primitive (copy_value_description x0)\n | From.Parsetree.Pstr_type (x0, x1) ->\n To.Parsetree.Pstr_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | From.Parsetree.Pstr_typext x0 ->\n To.Parsetree.Pstr_typext (copy_type_extension x0)\n | From.Parsetree.Pstr_exception x0 ->\n To.Parsetree.Pstr_exception\n (let e =\n copy_extension_constructor x0.From.Parsetree.ptyexn_constructor\n in\n {\n e with\n pext_attributes =\n e.pext_attributes @ copy_attributes x0.ptyexn_attributes;\n })\n | From.Parsetree.Pstr_module x0 ->\n To.Parsetree.Pstr_module (copy_module_binding x0)\n | From.Parsetree.Pstr_recmodule x0 ->\n To.Parsetree.Pstr_recmodule (List.map copy_module_binding x0)\n | From.Parsetree.Pstr_modtype x0 ->\n To.Parsetree.Pstr_modtype (copy_module_type_declaration x0)\n | From.Parsetree.Pstr_open x0 -> (\n match x0.From.Parsetree.popen_expr.From.Parsetree.pmod_desc with\n | Pmod_ident lid ->\n To.Parsetree.Pstr_open\n {\n To.Parsetree.popen_lid = copy_loc copy_longident lid;\n To.Parsetree.popen_override =\n copy_override_flag x0.From.Parsetree.popen_override;\n To.Parsetree.popen_loc = copy_location x0.From.Parsetree.popen_loc;\n To.Parsetree.popen_attributes =\n copy_attributes x0.From.Parsetree.popen_attributes;\n }\n | Pmod_structure _ | Pmod_functor _ | Pmod_apply _ | Pmod_constraint _\n | Pmod_unpack _ | Pmod_extension _ ->\n migration_error x0.From.Parsetree.popen_loc \"complex open\")\n | From.Parsetree.Pstr_class x0 ->\n To.Parsetree.Pstr_class (List.map copy_class_declaration x0)\n | From.Parsetree.Pstr_class_type x0 ->\n To.Parsetree.Pstr_class_type (List.map copy_class_type_declaration x0)\n | From.Parsetree.Pstr_include x0 ->\n To.Parsetree.Pstr_include (copy_include_declaration x0)\n | From.Parsetree.Pstr_attribute x0 ->\n To.Parsetree.Pstr_attribute (copy_attribute x0)\n | From.Parsetree.Pstr_extension (x0, x1) ->\n To.Parsetree.Pstr_extension (copy_extension x0, copy_attributes x1)\n\nand copy_include_declaration :\n From.Parsetree.include_declaration -> To.Parsetree.include_declaration =\n fun x -> copy_include_infos copy_module_expr x\n\nand copy_class_declaration :\n From.Parsetree.class_declaration -> To.Parsetree.class_declaration =\n fun x -> copy_class_infos copy_class_expr x\n\nand copy_class_expr : From.Parsetree.class_expr -> To.Parsetree.class_expr =\n fun {\n From.Parsetree.pcl_desc;\n From.Parsetree.pcl_loc;\n From.Parsetree.pcl_attributes;\n } ->\n {\n To.Parsetree.pcl_desc = copy_class_expr_desc pcl_desc;\n To.Parsetree.pcl_loc = copy_location pcl_loc;\n To.Parsetree.pcl_attributes = copy_attributes pcl_attributes;\n }\n\nand copy_class_expr_desc :\n From.Parsetree.class_expr_desc -> To.Parsetree.class_expr_desc = function\n | From.Parsetree.Pcl_constr (x0, x1) ->\n To.Parsetree.Pcl_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Pcl_structure x0 ->\n To.Parsetree.Pcl_structure (copy_class_structure x0)\n | From.Parsetree.Pcl_fun (x0, x1, x2, x3) ->\n To.Parsetree.Pcl_fun\n ( copy_arg_label x0,\n copy_option copy_expression x1,\n copy_pattern x2,\n copy_class_expr x3 )\n | From.Parsetree.Pcl_apply (x0, x1) ->\n To.Parsetree.Pcl_apply\n ( copy_class_expr x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | From.Parsetree.Pcl_let (x0, x1, x2) ->\n To.Parsetree.Pcl_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_class_expr x2)\n | From.Parsetree.Pcl_constraint (x0, x1) ->\n To.Parsetree.Pcl_constraint (copy_class_expr x0, copy_class_type x1)\n | From.Parsetree.Pcl_extension x0 ->\n To.Parsetree.Pcl_extension (copy_extension x0)\n | From.Parsetree.Pcl_open (x0, x1) ->\n To.Parsetree.Pcl_open\n ( copy_override_flag x0.From.Parsetree.popen_override,\n copy_loc copy_longident x0.From.Parsetree.popen_expr,\n copy_class_expr x1 )\n\nand copy_class_structure :\n From.Parsetree.class_structure -> To.Parsetree.class_structure =\n fun { From.Parsetree.pcstr_self; From.Parsetree.pcstr_fields } ->\n {\n To.Parsetree.pcstr_self = copy_pattern pcstr_self;\n To.Parsetree.pcstr_fields = List.map copy_class_field pcstr_fields;\n }\n\nand copy_class_field : From.Parsetree.class_field -> To.Parsetree.class_field =\n fun {\n From.Parsetree.pcf_desc;\n From.Parsetree.pcf_loc;\n From.Parsetree.pcf_attributes;\n } ->\n {\n To.Parsetree.pcf_desc = copy_class_field_desc pcf_desc;\n To.Parsetree.pcf_loc = copy_location pcf_loc;\n To.Parsetree.pcf_attributes = copy_attributes pcf_attributes;\n }\n\nand copy_class_field_desc :\n From.Parsetree.class_field_desc -> To.Parsetree.class_field_desc = function\n | From.Parsetree.Pcf_inherit (x0, x1, x2) ->\n To.Parsetree.Pcf_inherit\n ( copy_override_flag x0,\n copy_class_expr x1,\n copy_option (fun x -> copy_loc (fun x -> x) x) x2 )\n | From.Parsetree.Pcf_val x0 ->\n To.Parsetree.Pcf_val\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_mutable_flag x1, copy_class_field_kind x2))\n | From.Parsetree.Pcf_method x0 ->\n To.Parsetree.Pcf_method\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_private_flag x1, copy_class_field_kind x2))\n | From.Parsetree.Pcf_constraint x0 ->\n To.Parsetree.Pcf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | From.Parsetree.Pcf_initializer x0 ->\n To.Parsetree.Pcf_initializer (copy_expression x0)\n | From.Parsetree.Pcf_attribute x0 ->\n To.Parsetree.Pcf_attribute (copy_attribute x0)\n | From.Parsetree.Pcf_extension x0 ->\n To.Parsetree.Pcf_extension (copy_extension x0)\n\nand copy_class_field_kind :\n From.Parsetree.class_field_kind -> To.Parsetree.class_field_kind = function\n | From.Parsetree.Cfk_virtual x0 ->\n To.Parsetree.Cfk_virtual (copy_core_type x0)\n | From.Parsetree.Cfk_concrete (x0, x1) ->\n To.Parsetree.Cfk_concrete (copy_override_flag x0, copy_expression x1)\n\nand copy_module_binding :\n From.Parsetree.module_binding -> To.Parsetree.module_binding =\n fun {\n From.Parsetree.pmb_name;\n From.Parsetree.pmb_expr;\n From.Parsetree.pmb_attributes;\n From.Parsetree.pmb_loc;\n } ->\n {\n To.Parsetree.pmb_name = copy_loc (fun x -> x) pmb_name;\n To.Parsetree.pmb_expr = copy_module_expr pmb_expr;\n To.Parsetree.pmb_attributes = copy_attributes pmb_attributes;\n To.Parsetree.pmb_loc = copy_location pmb_loc;\n }\n\nand copy_module_expr : From.Parsetree.module_expr -> To.Parsetree.module_expr =\n fun {\n From.Parsetree.pmod_desc;\n From.Parsetree.pmod_loc;\n From.Parsetree.pmod_attributes;\n } ->\n {\n To.Parsetree.pmod_desc = copy_module_expr_desc pmod_desc;\n To.Parsetree.pmod_loc = copy_location pmod_loc;\n To.Parsetree.pmod_attributes = copy_attributes pmod_attributes;\n }\n\nand copy_module_expr_desc :\n From.Parsetree.module_expr_desc -> To.Parsetree.module_expr_desc = function\n | From.Parsetree.Pmod_ident x0 ->\n To.Parsetree.Pmod_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pmod_structure x0 ->\n To.Parsetree.Pmod_structure (copy_structure x0)\n | From.Parsetree.Pmod_functor (x0, x1, x2) ->\n To.Parsetree.Pmod_functor\n ( copy_loc (fun x -> x) x0,\n copy_option copy_module_type x1,\n copy_module_expr x2 )\n | From.Parsetree.Pmod_apply (x0, x1) ->\n To.Parsetree.Pmod_apply (copy_module_expr x0, copy_module_expr x1)\n | From.Parsetree.Pmod_constraint (x0, x1) ->\n To.Parsetree.Pmod_constraint (copy_module_expr x0, copy_module_type x1)\n | From.Parsetree.Pmod_unpack x0 ->\n To.Parsetree.Pmod_unpack (copy_expression x0)\n | From.Parsetree.Pmod_extension x0 ->\n To.Parsetree.Pmod_extension (copy_extension x0)\n\nand copy_module_type : From.Parsetree.module_type -> To.Parsetree.module_type =\n fun {\n From.Parsetree.pmty_desc;\n From.Parsetree.pmty_loc;\n From.Parsetree.pmty_attributes;\n } ->\n {\n To.Parsetree.pmty_desc = copy_module_type_desc pmty_desc;\n To.Parsetree.pmty_loc = copy_location pmty_loc;\n To.Parsetree.pmty_attributes = copy_attributes pmty_attributes;\n }\n\nand copy_module_type_desc :\n From.Parsetree.module_type_desc -> To.Parsetree.module_type_desc = function\n | From.Parsetree.Pmty_ident x0 ->\n To.Parsetree.Pmty_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pmty_signature x0 ->\n To.Parsetree.Pmty_signature (copy_signature x0)\n | From.Parsetree.Pmty_functor (x0, x1, x2) ->\n To.Parsetree.Pmty_functor\n ( copy_loc (fun x -> x) x0,\n copy_option copy_module_type x1,\n copy_module_type x2 )\n | From.Parsetree.Pmty_with (x0, x1) ->\n To.Parsetree.Pmty_with\n (copy_module_type x0, List.map copy_with_constraint x1)\n | From.Parsetree.Pmty_typeof x0 ->\n To.Parsetree.Pmty_typeof (copy_module_expr x0)\n | From.Parsetree.Pmty_extension x0 ->\n To.Parsetree.Pmty_extension (copy_extension x0)\n | From.Parsetree.Pmty_alias x0 ->\n To.Parsetree.Pmty_alias (copy_loc copy_longident x0)\n\nand copy_with_constraint :\n From.Parsetree.with_constraint -> To.Parsetree.with_constraint = function\n | From.Parsetree.Pwith_type (x0, x1) ->\n To.Parsetree.Pwith_type\n (copy_loc copy_longident x0, copy_type_declaration x1)\n | From.Parsetree.Pwith_module (x0, x1) ->\n To.Parsetree.Pwith_module\n (copy_loc copy_longident x0, copy_loc copy_longident x1)\n | From.Parsetree.Pwith_typesubst (x0, x1) ->\n To.Parsetree.Pwith_typesubst\n (copy_loc copy_longident x0, copy_type_declaration x1)\n | From.Parsetree.Pwith_modsubst (x0, x1) ->\n To.Parsetree.Pwith_modsubst\n (copy_loc copy_longident x0, copy_loc copy_longident x1)\n\nand copy_signature : From.Parsetree.signature -> To.Parsetree.signature =\n fun x -> List.map copy_signature_item x\n\nand copy_signature_item :\n From.Parsetree.signature_item -> To.Parsetree.signature_item =\n fun { From.Parsetree.psig_desc; From.Parsetree.psig_loc } ->\n {\n To.Parsetree.psig_desc = copy_signature_item_desc psig_desc;\n To.Parsetree.psig_loc = copy_location psig_loc;\n }\n\nand copy_signature_item_desc :\n From.Parsetree.signature_item_desc -> To.Parsetree.signature_item_desc =\n function\n | From.Parsetree.Psig_value x0 ->\n To.Parsetree.Psig_value (copy_value_description x0)\n | From.Parsetree.Psig_type (x0, x1) ->\n To.Parsetree.Psig_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | From.Parsetree.Psig_typesubst x0 ->\n let x0_loc =\n match x0 with\n | [] -> Location.none\n | { From.Parsetree.ptype_loc; _ } :: _ -> ptype_loc\n in\n migration_error x0_loc \"type substitution in signatures\"\n | From.Parsetree.Psig_typext x0 ->\n To.Parsetree.Psig_typext (copy_type_extension x0)\n | From.Parsetree.Psig_exception x0 ->\n To.Parsetree.Psig_exception\n (let e =\n copy_extension_constructor x0.From.Parsetree.ptyexn_constructor\n in\n {\n e with\n pext_attributes =\n e.pext_attributes @ copy_attributes x0.ptyexn_attributes;\n })\n | From.Parsetree.Psig_module x0 ->\n To.Parsetree.Psig_module (copy_module_declaration x0)\n | From.Parsetree.Psig_modsubst x0 ->\n migration_error x0.pms_loc \"module substitution in signatures\"\n | From.Parsetree.Psig_recmodule x0 ->\n To.Parsetree.Psig_recmodule (List.map copy_module_declaration x0)\n | From.Parsetree.Psig_modtype x0 ->\n To.Parsetree.Psig_modtype (copy_module_type_declaration x0)\n | From.Parsetree.Psig_open x0 ->\n To.Parsetree.Psig_open (copy_open_description x0)\n | From.Parsetree.Psig_include x0 ->\n To.Parsetree.Psig_include (copy_include_description x0)\n | From.Parsetree.Psig_class x0 ->\n To.Parsetree.Psig_class (List.map copy_class_description x0)\n | From.Parsetree.Psig_class_type x0 ->\n To.Parsetree.Psig_class_type (List.map copy_class_type_declaration x0)\n | From.Parsetree.Psig_attribute x0 ->\n To.Parsetree.Psig_attribute (copy_attribute x0)\n | From.Parsetree.Psig_extension (x0, x1) ->\n To.Parsetree.Psig_extension (copy_extension x0, copy_attributes x1)\n\nand copy_class_type_declaration :\n From.Parsetree.class_type_declaration -> To.Parsetree.class_type_declaration\n =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_description :\n From.Parsetree.class_description -> To.Parsetree.class_description =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_type : From.Parsetree.class_type -> To.Parsetree.class_type =\n fun {\n From.Parsetree.pcty_desc;\n From.Parsetree.pcty_loc;\n From.Parsetree.pcty_attributes;\n } ->\n {\n To.Parsetree.pcty_desc = copy_class_type_desc pcty_desc;\n To.Parsetree.pcty_loc = copy_location pcty_loc;\n To.Parsetree.pcty_attributes = copy_attributes pcty_attributes;\n }\n\nand copy_class_type_desc :\n From.Parsetree.class_type_desc -> To.Parsetree.class_type_desc = function\n | From.Parsetree.Pcty_constr (x0, x1) ->\n To.Parsetree.Pcty_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Pcty_signature x0 ->\n To.Parsetree.Pcty_signature (copy_class_signature x0)\n | From.Parsetree.Pcty_arrow (x0, x1, x2) ->\n To.Parsetree.Pcty_arrow\n (copy_arg_label x0, copy_core_type x1, copy_class_type x2)\n | From.Parsetree.Pcty_extension x0 ->\n To.Parsetree.Pcty_extension (copy_extension x0)\n | From.Parsetree.Pcty_open (x0, x1) ->\n To.Parsetree.Pcty_open\n ( copy_override_flag x0.From.Parsetree.popen_override,\n copy_loc copy_longident x0.From.Parsetree.popen_expr,\n copy_class_type x1 )\n\nand copy_class_signature :\n From.Parsetree.class_signature -> To.Parsetree.class_signature =\n fun { From.Parsetree.pcsig_self; From.Parsetree.pcsig_fields } ->\n {\n To.Parsetree.pcsig_self = copy_core_type pcsig_self;\n To.Parsetree.pcsig_fields = List.map copy_class_type_field pcsig_fields;\n }\n\nand copy_class_type_field :\n From.Parsetree.class_type_field -> To.Parsetree.class_type_field =\n fun {\n From.Parsetree.pctf_desc;\n From.Parsetree.pctf_loc;\n From.Parsetree.pctf_attributes;\n } ->\n {\n To.Parsetree.pctf_desc = copy_class_type_field_desc pctf_desc;\n To.Parsetree.pctf_loc = copy_location pctf_loc;\n To.Parsetree.pctf_attributes = copy_attributes pctf_attributes;\n }\n\nand copy_class_type_field_desc :\n From.Parsetree.class_type_field_desc -> To.Parsetree.class_type_field_desc =\n function\n | From.Parsetree.Pctf_inherit x0 ->\n To.Parsetree.Pctf_inherit (copy_class_type x0)\n | From.Parsetree.Pctf_val x0 ->\n To.Parsetree.Pctf_val\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_mutable_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | From.Parsetree.Pctf_method x0 ->\n To.Parsetree.Pctf_method\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_private_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | From.Parsetree.Pctf_constraint x0 ->\n To.Parsetree.Pctf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | From.Parsetree.Pctf_attribute x0 ->\n To.Parsetree.Pctf_attribute (copy_attribute x0)\n | From.Parsetree.Pctf_extension x0 ->\n To.Parsetree.Pctf_extension (copy_extension x0)\n\nand copy_extension : From.Parsetree.extension -> To.Parsetree.extension =\n fun x ->\n let x0, x1 = x in\n let x1 =\n match x0.txt with\n | \"ocaml.error\" | \"error\" -> (\n match x1 with\n | PStr (hd :: tl) -> From.Parsetree.PStr (hd :: hd :: tl)\n | _ -> x1)\n | _ -> x1\n in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_class_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 From.Parsetree.class_infos ->\n 'g0 To.Parsetree.class_infos =\n fun f0\n {\n From.Parsetree.pci_virt;\n From.Parsetree.pci_params;\n From.Parsetree.pci_name;\n From.Parsetree.pci_expr;\n From.Parsetree.pci_loc;\n From.Parsetree.pci_attributes;\n } ->\n {\n To.Parsetree.pci_virt = copy_virtual_flag pci_virt;\n To.Parsetree.pci_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n pci_params;\n To.Parsetree.pci_name = copy_loc (fun x -> x) pci_name;\n To.Parsetree.pci_expr = f0 pci_expr;\n To.Parsetree.pci_loc = copy_location pci_loc;\n To.Parsetree.pci_attributes = copy_attributes pci_attributes;\n }\n\nand copy_virtual_flag : From.Asttypes.virtual_flag -> To.Asttypes.virtual_flag =\n function\n | From.Asttypes.Virtual -> To.Asttypes.Virtual\n | From.Asttypes.Concrete -> To.Asttypes.Concrete\n\nand copy_include_description :\n From.Parsetree.include_description -> To.Parsetree.include_description =\n fun x -> copy_include_infos copy_module_type x\n\nand copy_include_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 From.Parsetree.include_infos ->\n 'g0 To.Parsetree.include_infos =\n fun f0\n {\n From.Parsetree.pincl_mod;\n From.Parsetree.pincl_loc;\n From.Parsetree.pincl_attributes;\n } ->\n {\n To.Parsetree.pincl_mod = f0 pincl_mod;\n To.Parsetree.pincl_loc = copy_location pincl_loc;\n To.Parsetree.pincl_attributes = copy_attributes pincl_attributes;\n }\n\nand copy_open_description :\n From.Parsetree.open_description -> To.Parsetree.open_description =\n fun {\n From.Parsetree.popen_expr;\n From.Parsetree.popen_override;\n From.Parsetree.popen_loc;\n From.Parsetree.popen_attributes;\n } ->\n {\n To.Parsetree.popen_lid = copy_loc copy_longident popen_expr;\n To.Parsetree.popen_override = copy_override_flag popen_override;\n To.Parsetree.popen_loc = copy_location popen_loc;\n To.Parsetree.popen_attributes = copy_attributes popen_attributes;\n }\n\nand copy_override_flag :\n From.Asttypes.override_flag -> To.Asttypes.override_flag = function\n | From.Asttypes.Override -> To.Asttypes.Override\n | From.Asttypes.Fresh -> To.Asttypes.Fresh\n\nand copy_module_type_declaration :\n From.Parsetree.module_type_declaration ->\n To.Parsetree.module_type_declaration =\n fun {\n From.Parsetree.pmtd_name;\n From.Parsetree.pmtd_type;\n From.Parsetree.pmtd_attributes;\n From.Parsetree.pmtd_loc;\n } ->\n {\n To.Parsetree.pmtd_name = copy_loc (fun x -> x) pmtd_name;\n To.Parsetree.pmtd_type = copy_option copy_module_type pmtd_type;\n To.Parsetree.pmtd_attributes = copy_attributes pmtd_attributes;\n To.Parsetree.pmtd_loc = copy_location pmtd_loc;\n }\n\nand copy_module_declaration :\n From.Parsetree.module_declaration -> To.Parsetree.module_declaration =\n fun {\n From.Parsetree.pmd_name;\n From.Parsetree.pmd_type;\n From.Parsetree.pmd_attributes;\n From.Parsetree.pmd_loc;\n } ->\n {\n To.Parsetree.pmd_name = copy_loc (fun x -> x) pmd_name;\n To.Parsetree.pmd_type = copy_module_type pmd_type;\n To.Parsetree.pmd_attributes = copy_attributes pmd_attributes;\n To.Parsetree.pmd_loc = copy_location pmd_loc;\n }\n\n(* and copy_type_exception :\n From.Parsetree.type_exception -> To.Parsetree.type_exception =\n fun\n { From.Parsetree.ptyexn_constructor = ptyexn_constructor;\n From.Parsetree.ptyexn_loc = ptyexn_loc;\n From.Parsetree.ptyexn_attributes = ptyexn_attributes }\n ->\n {\n To.Parsetree.ptyexn_constructor =\n (copy_extension_constructor ptyexn_constructor);\n To.Parsetree.ptyexn_loc = (copy_location ptyexn_loc);\n To.Parsetree.ptyexn_attributes =\n (copy_attributes ptyexn_attributes)\n }*)\nand copy_type_extension :\n From.Parsetree.type_extension -> To.Parsetree.type_extension =\n fun {\n From.Parsetree.ptyext_path;\n From.Parsetree.ptyext_params;\n From.Parsetree.ptyext_constructors;\n From.Parsetree.ptyext_private;\n From.Parsetree.ptyext_loc = _;\n From.Parsetree.ptyext_attributes;\n } ->\n {\n To.Parsetree.ptyext_path = copy_loc copy_longident ptyext_path;\n To.Parsetree.ptyext_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptyext_params;\n To.Parsetree.ptyext_constructors =\n List.map copy_extension_constructor ptyext_constructors;\n To.Parsetree.ptyext_private = copy_private_flag ptyext_private;\n To.Parsetree.ptyext_attributes = copy_attributes ptyext_attributes;\n }\n\nand copy_extension_constructor :\n From.Parsetree.extension_constructor -> To.Parsetree.extension_constructor =\n fun {\n From.Parsetree.pext_name;\n From.Parsetree.pext_kind;\n From.Parsetree.pext_loc;\n From.Parsetree.pext_attributes;\n } ->\n {\n To.Parsetree.pext_name = copy_loc (fun x -> x) pext_name;\n To.Parsetree.pext_kind = copy_extension_constructor_kind pext_kind;\n To.Parsetree.pext_loc = copy_location pext_loc;\n To.Parsetree.pext_attributes = copy_attributes pext_attributes;\n }\n\nand copy_extension_constructor_kind :\n From.Parsetree.extension_constructor_kind ->\n To.Parsetree.extension_constructor_kind = function\n | From.Parsetree.Pext_decl (x0, x1) ->\n To.Parsetree.Pext_decl\n (copy_constructor_arguments x0, copy_option copy_core_type x1)\n | From.Parsetree.Pext_rebind x0 ->\n To.Parsetree.Pext_rebind (copy_loc copy_longident x0)\n\nand copy_type_declaration :\n From.Parsetree.type_declaration -> To.Parsetree.type_declaration =\n fun {\n From.Parsetree.ptype_name;\n From.Parsetree.ptype_params;\n From.Parsetree.ptype_cstrs;\n From.Parsetree.ptype_kind;\n From.Parsetree.ptype_private;\n From.Parsetree.ptype_manifest;\n From.Parsetree.ptype_attributes;\n From.Parsetree.ptype_loc;\n } ->\n {\n To.Parsetree.ptype_name = copy_loc (fun x -> x) ptype_name;\n To.Parsetree.ptype_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptype_params;\n To.Parsetree.ptype_cstrs =\n List.map\n (fun x ->\n let x0, x1, x2 = x in\n (copy_core_type x0, copy_core_type x1, copy_location x2))\n ptype_cstrs;\n To.Parsetree.ptype_kind = copy_type_kind ptype_kind;\n To.Parsetree.ptype_private = copy_private_flag ptype_private;\n To.Parsetree.ptype_manifest = copy_option copy_core_type ptype_manifest;\n To.Parsetree.ptype_attributes = copy_attributes ptype_attributes;\n To.Parsetree.ptype_loc = copy_location ptype_loc;\n }\n\nand copy_private_flag : From.Asttypes.private_flag -> To.Asttypes.private_flag =\n function\n | From.Asttypes.Private -> To.Asttypes.Private\n | From.Asttypes.Public -> To.Asttypes.Public\n\nand copy_type_kind : From.Parsetree.type_kind -> To.Parsetree.type_kind =\n function\n | From.Parsetree.Ptype_abstract -> To.Parsetree.Ptype_abstract\n | From.Parsetree.Ptype_variant x0 ->\n To.Parsetree.Ptype_variant (List.map copy_constructor_declaration x0)\n | From.Parsetree.Ptype_record x0 ->\n To.Parsetree.Ptype_record (List.map copy_label_declaration x0)\n | From.Parsetree.Ptype_open -> To.Parsetree.Ptype_open\n\nand copy_constructor_declaration :\n From.Parsetree.constructor_declaration ->\n To.Parsetree.constructor_declaration =\n fun {\n From.Parsetree.pcd_name;\n From.Parsetree.pcd_args;\n From.Parsetree.pcd_res;\n From.Parsetree.pcd_loc;\n From.Parsetree.pcd_attributes;\n } ->\n {\n To.Parsetree.pcd_name = copy_loc (fun x -> x) pcd_name;\n To.Parsetree.pcd_args = copy_constructor_arguments pcd_args;\n To.Parsetree.pcd_res = copy_option copy_core_type pcd_res;\n To.Parsetree.pcd_loc = copy_location pcd_loc;\n To.Parsetree.pcd_attributes = copy_attributes pcd_attributes;\n }\n\nand copy_constructor_arguments :\n From.Parsetree.constructor_arguments -> To.Parsetree.constructor_arguments =\n function\n | From.Parsetree.Pcstr_tuple x0 ->\n To.Parsetree.Pcstr_tuple (List.map copy_core_type x0)\n | From.Parsetree.Pcstr_record x0 ->\n To.Parsetree.Pcstr_record (List.map copy_label_declaration x0)\n\nand copy_label_declaration :\n From.Parsetree.label_declaration -> To.Parsetree.label_declaration =\n fun {\n From.Parsetree.pld_name;\n From.Parsetree.pld_mutable;\n From.Parsetree.pld_type;\n From.Parsetree.pld_loc;\n From.Parsetree.pld_attributes;\n } ->\n {\n To.Parsetree.pld_name = copy_loc (fun x -> x) pld_name;\n To.Parsetree.pld_mutable = copy_mutable_flag pld_mutable;\n To.Parsetree.pld_type = copy_core_type pld_type;\n To.Parsetree.pld_loc = copy_location pld_loc;\n To.Parsetree.pld_attributes = copy_attributes pld_attributes;\n }\n\nand copy_mutable_flag : From.Asttypes.mutable_flag -> To.Asttypes.mutable_flag =\n function\n | From.Asttypes.Immutable -> To.Asttypes.Immutable\n | From.Asttypes.Mutable -> To.Asttypes.Mutable\n\nand copy_variance : From.Asttypes.variance -> To.Asttypes.variance = function\n | From.Asttypes.Covariant -> To.Asttypes.Covariant\n | From.Asttypes.Contravariant -> To.Asttypes.Contravariant\n | From.Asttypes.Invariant -> To.Asttypes.Invariant\n\nand copy_value_description :\n From.Parsetree.value_description -> To.Parsetree.value_description =\n fun {\n From.Parsetree.pval_name;\n From.Parsetree.pval_type;\n From.Parsetree.pval_prim;\n From.Parsetree.pval_attributes;\n From.Parsetree.pval_loc;\n } ->\n {\n To.Parsetree.pval_name = copy_loc (fun x -> x) pval_name;\n To.Parsetree.pval_type = copy_core_type pval_type;\n To.Parsetree.pval_prim = List.map (fun x -> x) pval_prim;\n To.Parsetree.pval_attributes = copy_attributes pval_attributes;\n To.Parsetree.pval_loc = copy_location pval_loc;\n }\n\nand copy_arg_label : From.Asttypes.arg_label -> To.Asttypes.arg_label = function\n | From.Asttypes.Nolabel -> To.Asttypes.Nolabel\n | From.Asttypes.Labelled x0 -> To.Asttypes.Labelled x0\n | From.Asttypes.Optional x0 -> To.Asttypes.Optional x0\n\nand copy_closed_flag : From.Asttypes.closed_flag -> To.Asttypes.closed_flag =\n function\n | From.Asttypes.Closed -> To.Asttypes.Closed\n | From.Asttypes.Open -> To.Asttypes.Open\n\nand copy_label : From.Asttypes.label -> To.Asttypes.label = fun x -> x\n\nand copy_rec_flag : From.Asttypes.rec_flag -> To.Asttypes.rec_flag = function\n | From.Asttypes.Nonrecursive -> To.Asttypes.Nonrecursive\n | From.Asttypes.Recursive -> To.Asttypes.Recursive\n\nand copy_constant : From.Parsetree.constant -> To.Parsetree.constant = function\n | From.Parsetree.Pconst_integer (x0, x1) ->\n To.Parsetree.Pconst_integer (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pconst_char x0 -> To.Parsetree.Pconst_char x0\n | From.Parsetree.Pconst_string (x0, x1) ->\n To.Parsetree.Pconst_string (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pconst_float (x0, x1) ->\n To.Parsetree.Pconst_float (x0, copy_option (fun x -> x) x1)\n\nand copy_option : 'f0 'g0. ('f0 -> 'g0) -> 'f0 option -> 'g0 option =\n fun f0 -> function None -> None | Some x0 -> Some (f0 x0)\n\nand copy_longident : Longident.t -> Longident.t = fun x -> x\n\nand copy_loc :\n 'f0 'g0. ('f0 -> 'g0) -> 'f0 From.Asttypes.loc -> 'g0 To.Asttypes.loc =\n fun f0 { From.Asttypes.txt; From.Asttypes.loc } ->\n { To.Asttypes.txt = f0 txt; To.Asttypes.loc = copy_location loc }\n\nand copy_location : Location.t -> Location.t = fun x -> x\nand copy_bool : bool -> bool = function false -> false | true -> true\n\nlet copy_cases x = List.map copy_case x\nlet copy_pat = copy_pattern\nlet copy_expr = copy_expression\nlet copy_typ = copy_core_type\n","module From = Ast_407\nmodule To = Ast_408\n\nlet rec copy_toplevel_phrase :\n From.Parsetree.toplevel_phrase -> To.Parsetree.toplevel_phrase = function\n | From.Parsetree.Ptop_def x0 -> To.Parsetree.Ptop_def (copy_structure x0)\n | From.Parsetree.Ptop_dir (x0, x1) ->\n To.Parsetree.Ptop_dir\n {\n To.Parsetree.pdir_name =\n { Location.txt = x0; Location.loc = Location.none };\n To.Parsetree.pdir_arg = copy_directive_argument x1;\n To.Parsetree.pdir_loc = Location.none;\n }\n\nand copy_directive_argument :\n From.Parsetree.directive_argument -> To.Parsetree.directive_argument option\n =\n let wrap pdira_desc =\n Some { To.Parsetree.pdira_desc; To.Parsetree.pdira_loc = Location.none }\n in\n function\n | From.Parsetree.Pdir_none -> None\n | From.Parsetree.Pdir_string x0 -> To.Parsetree.Pdir_string x0 |> wrap\n | From.Parsetree.Pdir_int (x0, x1) ->\n To.Parsetree.Pdir_int (x0, copy_option (fun x -> x) x1) |> wrap\n | From.Parsetree.Pdir_ident x0 ->\n To.Parsetree.Pdir_ident (copy_longident x0) |> wrap\n | From.Parsetree.Pdir_bool x0 -> To.Parsetree.Pdir_bool (copy_bool x0) |> wrap\n\nand copy_expression : From.Parsetree.expression -> To.Parsetree.expression =\n fun {\n From.Parsetree.pexp_desc;\n From.Parsetree.pexp_loc;\n From.Parsetree.pexp_attributes;\n } ->\n {\n To.Parsetree.pexp_desc = copy_expression_desc pexp_desc;\n To.Parsetree.pexp_loc = copy_location pexp_loc;\n To.Parsetree.pexp_loc_stack = [];\n To.Parsetree.pexp_attributes = copy_attributes pexp_attributes;\n }\n\nand copy_expression_desc :\n From.Parsetree.expression_desc -> To.Parsetree.expression_desc = function\n | From.Parsetree.Pexp_ident x0 ->\n To.Parsetree.Pexp_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pexp_constant x0 ->\n To.Parsetree.Pexp_constant (copy_constant x0)\n | From.Parsetree.Pexp_let (x0, x1, x2) ->\n To.Parsetree.Pexp_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_expression x2)\n | From.Parsetree.Pexp_function x0 ->\n To.Parsetree.Pexp_function (List.map copy_case x0)\n | From.Parsetree.Pexp_fun (x0, x1, x2, x3) ->\n To.Parsetree.Pexp_fun\n ( copy_arg_label x0,\n copy_option copy_expression x1,\n copy_pattern x2,\n copy_expression x3 )\n | From.Parsetree.Pexp_apply (x0, x1) ->\n To.Parsetree.Pexp_apply\n ( copy_expression x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | From.Parsetree.Pexp_match (x0, x1) ->\n To.Parsetree.Pexp_match (copy_expression x0, List.map copy_case x1)\n | From.Parsetree.Pexp_try (x0, x1) ->\n To.Parsetree.Pexp_try (copy_expression x0, List.map copy_case x1)\n | From.Parsetree.Pexp_tuple x0 ->\n To.Parsetree.Pexp_tuple (List.map copy_expression x0)\n | From.Parsetree.Pexp_construct (x0, x1) ->\n To.Parsetree.Pexp_construct\n (copy_loc copy_longident x0, copy_option copy_expression x1)\n | From.Parsetree.Pexp_variant (x0, x1) ->\n To.Parsetree.Pexp_variant (copy_label x0, copy_option copy_expression x1)\n | From.Parsetree.Pexp_record (x0, x1) ->\n To.Parsetree.Pexp_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_expression x1))\n x0,\n copy_option copy_expression x1 )\n | From.Parsetree.Pexp_field (x0, x1) ->\n To.Parsetree.Pexp_field (copy_expression x0, copy_loc copy_longident x1)\n | From.Parsetree.Pexp_setfield (x0, x1, x2) ->\n To.Parsetree.Pexp_setfield\n (copy_expression x0, copy_loc copy_longident x1, copy_expression x2)\n | From.Parsetree.Pexp_array x0 ->\n To.Parsetree.Pexp_array (List.map copy_expression x0)\n | From.Parsetree.Pexp_ifthenelse (x0, x1, x2) ->\n To.Parsetree.Pexp_ifthenelse\n (copy_expression x0, copy_expression x1, copy_option copy_expression x2)\n | From.Parsetree.Pexp_sequence (x0, x1) ->\n To.Parsetree.Pexp_sequence (copy_expression x0, copy_expression x1)\n | From.Parsetree.Pexp_while (x0, x1) ->\n To.Parsetree.Pexp_while (copy_expression x0, copy_expression x1)\n | From.Parsetree.Pexp_for (x0, x1, x2, x3, x4) ->\n To.Parsetree.Pexp_for\n ( copy_pattern x0,\n copy_expression x1,\n copy_expression x2,\n copy_direction_flag x3,\n copy_expression x4 )\n | From.Parsetree.Pexp_constraint (x0, x1) ->\n To.Parsetree.Pexp_constraint (copy_expression x0, copy_core_type x1)\n | From.Parsetree.Pexp_coerce (x0, x1, x2) ->\n To.Parsetree.Pexp_coerce\n (copy_expression x0, copy_option copy_core_type x1, copy_core_type x2)\n | From.Parsetree.Pexp_send (x0, x1) ->\n To.Parsetree.Pexp_send (copy_expression x0, copy_loc copy_label x1)\n | From.Parsetree.Pexp_new x0 ->\n To.Parsetree.Pexp_new (copy_loc copy_longident x0)\n | From.Parsetree.Pexp_setinstvar (x0, x1) ->\n To.Parsetree.Pexp_setinstvar (copy_loc copy_label x0, copy_expression x1)\n | From.Parsetree.Pexp_override x0 ->\n To.Parsetree.Pexp_override\n (List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_label x0, copy_expression x1))\n x0)\n | From.Parsetree.Pexp_letmodule (x0, x1, x2) ->\n To.Parsetree.Pexp_letmodule\n (copy_loc (fun x -> x) x0, copy_module_expr x1, copy_expression x2)\n | From.Parsetree.Pexp_letexception (x0, x1) ->\n To.Parsetree.Pexp_letexception\n (copy_extension_constructor x0, copy_expression x1)\n | From.Parsetree.Pexp_assert x0 ->\n To.Parsetree.Pexp_assert (copy_expression x0)\n | From.Parsetree.Pexp_lazy x0 -> To.Parsetree.Pexp_lazy (copy_expression x0)\n | From.Parsetree.Pexp_poly (x0, x1) ->\n To.Parsetree.Pexp_poly (copy_expression x0, copy_option copy_core_type x1)\n | From.Parsetree.Pexp_object x0 ->\n To.Parsetree.Pexp_object (copy_class_structure x0)\n | From.Parsetree.Pexp_newtype (x0, x1) ->\n To.Parsetree.Pexp_newtype (copy_loc (fun x -> x) x0, copy_expression x1)\n | From.Parsetree.Pexp_pack x0 -> To.Parsetree.Pexp_pack (copy_module_expr x0)\n | From.Parsetree.Pexp_open (x0, x1, x2) ->\n To.Parsetree.Pexp_open\n ( {\n To.Parsetree.popen_expr =\n {\n To.Parsetree.pmod_desc =\n To.Parsetree.Pmod_ident (copy_loc copy_longident x1);\n To.Parsetree.pmod_loc = x1.Location.loc;\n To.Parsetree.pmod_attributes = [];\n };\n To.Parsetree.popen_override = copy_override_flag x0;\n To.Parsetree.popen_loc = x1.Location.loc;\n To.Parsetree.popen_attributes = [];\n },\n copy_expression x2 )\n | From.Parsetree.Pexp_extension x0 ->\n To.Parsetree.Pexp_extension (copy_extension x0)\n | From.Parsetree.Pexp_unreachable -> To.Parsetree.Pexp_unreachable\n\nand copy_direction_flag :\n From.Asttypes.direction_flag -> To.Asttypes.direction_flag = function\n | From.Asttypes.Upto -> To.Asttypes.Upto\n | From.Asttypes.Downto -> To.Asttypes.Downto\n\nand copy_case : From.Parsetree.case -> To.Parsetree.case =\n fun { From.Parsetree.pc_lhs; From.Parsetree.pc_guard; From.Parsetree.pc_rhs } ->\n {\n To.Parsetree.pc_lhs = copy_pattern pc_lhs;\n To.Parsetree.pc_guard = copy_option copy_expression pc_guard;\n To.Parsetree.pc_rhs = copy_expression pc_rhs;\n }\n\nand copy_value_binding :\n From.Parsetree.value_binding -> To.Parsetree.value_binding =\n fun {\n From.Parsetree.pvb_pat;\n From.Parsetree.pvb_expr;\n From.Parsetree.pvb_attributes;\n From.Parsetree.pvb_loc;\n } ->\n {\n To.Parsetree.pvb_pat = copy_pattern pvb_pat;\n To.Parsetree.pvb_expr = copy_expression pvb_expr;\n To.Parsetree.pvb_attributes = copy_attributes pvb_attributes;\n To.Parsetree.pvb_loc = copy_location pvb_loc;\n }\n\nand copy_pattern : From.Parsetree.pattern -> To.Parsetree.pattern =\n fun {\n From.Parsetree.ppat_desc;\n From.Parsetree.ppat_loc;\n From.Parsetree.ppat_attributes;\n } ->\n {\n To.Parsetree.ppat_desc = copy_pattern_desc ppat_desc;\n To.Parsetree.ppat_loc = copy_location ppat_loc;\n To.Parsetree.ppat_loc_stack = [];\n To.Parsetree.ppat_attributes = copy_attributes ppat_attributes;\n }\n\nand copy_pattern_desc : From.Parsetree.pattern_desc -> To.Parsetree.pattern_desc\n = function\n | From.Parsetree.Ppat_any -> To.Parsetree.Ppat_any\n | From.Parsetree.Ppat_var x0 ->\n To.Parsetree.Ppat_var (copy_loc (fun x -> x) x0)\n | From.Parsetree.Ppat_alias (x0, x1) ->\n To.Parsetree.Ppat_alias (copy_pattern x0, copy_loc (fun x -> x) x1)\n | From.Parsetree.Ppat_constant x0 ->\n To.Parsetree.Ppat_constant (copy_constant x0)\n | From.Parsetree.Ppat_interval (x0, x1) ->\n To.Parsetree.Ppat_interval (copy_constant x0, copy_constant x1)\n | From.Parsetree.Ppat_tuple x0 ->\n To.Parsetree.Ppat_tuple (List.map copy_pattern x0)\n | From.Parsetree.Ppat_construct (x0, x1) ->\n To.Parsetree.Ppat_construct\n (copy_loc copy_longident x0, copy_option copy_pattern x1)\n | From.Parsetree.Ppat_variant (x0, x1) ->\n To.Parsetree.Ppat_variant (copy_label x0, copy_option copy_pattern x1)\n | From.Parsetree.Ppat_record (x0, x1) ->\n To.Parsetree.Ppat_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_pattern x1))\n x0,\n copy_closed_flag x1 )\n | From.Parsetree.Ppat_array x0 ->\n To.Parsetree.Ppat_array (List.map copy_pattern x0)\n | From.Parsetree.Ppat_or (x0, x1) ->\n To.Parsetree.Ppat_or (copy_pattern x0, copy_pattern x1)\n | From.Parsetree.Ppat_constraint (x0, x1) ->\n To.Parsetree.Ppat_constraint (copy_pattern x0, copy_core_type x1)\n | From.Parsetree.Ppat_type x0 ->\n To.Parsetree.Ppat_type (copy_loc copy_longident x0)\n | From.Parsetree.Ppat_lazy x0 -> To.Parsetree.Ppat_lazy (copy_pattern x0)\n | From.Parsetree.Ppat_unpack x0 ->\n To.Parsetree.Ppat_unpack (copy_loc (fun x -> x) x0)\n | From.Parsetree.Ppat_exception x0 ->\n To.Parsetree.Ppat_exception (copy_pattern x0)\n | From.Parsetree.Ppat_extension x0 ->\n To.Parsetree.Ppat_extension (copy_extension x0)\n | From.Parsetree.Ppat_open (x0, x1) ->\n To.Parsetree.Ppat_open (copy_loc copy_longident x0, copy_pattern x1)\n\nand copy_core_type : From.Parsetree.core_type -> To.Parsetree.core_type =\n fun {\n From.Parsetree.ptyp_desc;\n From.Parsetree.ptyp_loc;\n From.Parsetree.ptyp_attributes;\n } ->\n {\n To.Parsetree.ptyp_desc = copy_core_type_desc ptyp_desc;\n To.Parsetree.ptyp_loc = copy_location ptyp_loc;\n To.Parsetree.ptyp_loc_stack = [];\n To.Parsetree.ptyp_attributes = copy_attributes ptyp_attributes;\n }\n\nand copy_core_type_desc :\n From.Parsetree.core_type_desc -> To.Parsetree.core_type_desc = function\n | From.Parsetree.Ptyp_any -> To.Parsetree.Ptyp_any\n | From.Parsetree.Ptyp_var x0 -> To.Parsetree.Ptyp_var x0\n | From.Parsetree.Ptyp_arrow (x0, x1, x2) ->\n To.Parsetree.Ptyp_arrow\n (copy_arg_label x0, copy_core_type x1, copy_core_type x2)\n | From.Parsetree.Ptyp_tuple x0 ->\n To.Parsetree.Ptyp_tuple (List.map copy_core_type x0)\n | From.Parsetree.Ptyp_constr (x0, x1) ->\n To.Parsetree.Ptyp_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Ptyp_object (x0, x1) ->\n To.Parsetree.Ptyp_object\n (List.map copy_object_field x0, copy_closed_flag x1)\n | From.Parsetree.Ptyp_class (x0, x1) ->\n To.Parsetree.Ptyp_class\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Ptyp_alias (x0, x1) ->\n To.Parsetree.Ptyp_alias (copy_core_type x0, x1)\n | From.Parsetree.Ptyp_variant (x0, x1, x2) ->\n To.Parsetree.Ptyp_variant\n ( List.map copy_row_field x0,\n copy_closed_flag x1,\n copy_option (fun x -> List.map copy_label x) x2 )\n | From.Parsetree.Ptyp_poly (x0, x1) ->\n To.Parsetree.Ptyp_poly\n (List.map (fun x -> copy_loc (fun x -> x) x) x0, copy_core_type x1)\n | From.Parsetree.Ptyp_package x0 ->\n To.Parsetree.Ptyp_package (copy_package_type x0)\n | From.Parsetree.Ptyp_extension x0 ->\n To.Parsetree.Ptyp_extension (copy_extension x0)\n\nand copy_package_type : From.Parsetree.package_type -> To.Parsetree.package_type\n =\n fun x ->\n let x0, x1 = x in\n ( copy_loc copy_longident x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_core_type x1))\n x1 )\n\nand copy_row_field : From.Parsetree.row_field -> To.Parsetree.row_field =\n function\n | From.Parsetree.Rtag (x0, x1, x2, x3) ->\n {\n To.Parsetree.prf_desc =\n To.Parsetree.Rtag\n (copy_loc copy_label x0, copy_bool x2, List.map copy_core_type x3);\n To.Parsetree.prf_loc = x0.Location.loc;\n To.Parsetree.prf_attributes = copy_attributes x1;\n }\n | From.Parsetree.Rinherit x0 ->\n {\n To.Parsetree.prf_desc = To.Parsetree.Rinherit (copy_core_type x0);\n To.Parsetree.prf_loc = x0.From.Parsetree.ptyp_loc;\n To.Parsetree.prf_attributes = [];\n }\n\nand copy_object_field : From.Parsetree.object_field -> To.Parsetree.object_field\n = function\n | From.Parsetree.Otag (x0, x1, x2) ->\n {\n To.Parsetree.pof_desc =\n To.Parsetree.Otag (copy_loc copy_label x0, copy_core_type x2);\n To.Parsetree.pof_loc = x0.Location.loc;\n To.Parsetree.pof_attributes = copy_attributes x1;\n }\n | From.Parsetree.Oinherit x0 ->\n {\n To.Parsetree.pof_desc = To.Parsetree.Oinherit (copy_core_type x0);\n To.Parsetree.pof_loc = x0.From.Parsetree.ptyp_loc;\n To.Parsetree.pof_attributes = [];\n }\n\nand copy_attributes : From.Parsetree.attributes -> To.Parsetree.attributes =\n fun x -> List.map copy_attribute x\n\nand copy_attribute : From.Parsetree.attribute -> To.Parsetree.attribute =\n fun x ->\n let x0, x1 = x in\n {\n To.Parsetree.attr_name = copy_loc (fun x -> x) x0;\n To.Parsetree.attr_payload = copy_payload x1;\n To.Parsetree.attr_loc = x0.Location.loc;\n }\n\nand copy_payload : From.Parsetree.payload -> To.Parsetree.payload = function\n | From.Parsetree.PStr x0 -> To.Parsetree.PStr (copy_structure x0)\n | From.Parsetree.PSig x0 -> To.Parsetree.PSig (copy_signature x0)\n | From.Parsetree.PTyp x0 -> To.Parsetree.PTyp (copy_core_type x0)\n | From.Parsetree.PPat (x0, x1) ->\n To.Parsetree.PPat (copy_pattern x0, copy_option copy_expression x1)\n\nand copy_structure : From.Parsetree.structure -> To.Parsetree.structure =\n fun x -> List.map copy_structure_item x\n\nand copy_structure_item :\n From.Parsetree.structure_item -> To.Parsetree.structure_item =\n fun { From.Parsetree.pstr_desc; From.Parsetree.pstr_loc } ->\n {\n To.Parsetree.pstr_desc = copy_structure_item_desc pstr_desc;\n To.Parsetree.pstr_loc = copy_location pstr_loc;\n }\n\nand copy_structure_item_desc :\n From.Parsetree.structure_item_desc -> To.Parsetree.structure_item_desc =\n function\n | From.Parsetree.Pstr_eval (x0, x1) ->\n To.Parsetree.Pstr_eval (copy_expression x0, copy_attributes x1)\n | From.Parsetree.Pstr_value (x0, x1) ->\n To.Parsetree.Pstr_value (copy_rec_flag x0, List.map copy_value_binding x1)\n | From.Parsetree.Pstr_primitive x0 ->\n To.Parsetree.Pstr_primitive (copy_value_description x0)\n | From.Parsetree.Pstr_type (x0, x1) ->\n To.Parsetree.Pstr_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | From.Parsetree.Pstr_typext x0 ->\n To.Parsetree.Pstr_typext (copy_type_extension x0)\n | From.Parsetree.Pstr_exception x0 ->\n let atat, at =\n List.partition\n (function\n | { Location.txt = \"ocaml.deprecated\" | \"deprecated\"; _ }, _ ->\n false\n | _ -> true)\n x0.pext_attributes\n in\n let x0 = { x0 with pext_attributes = at } in\n To.Parsetree.Pstr_exception\n {\n To.Parsetree.ptyexn_constructor = copy_extension_constructor x0;\n To.Parsetree.ptyexn_loc = x0.From.Parsetree.pext_loc;\n To.Parsetree.ptyexn_attributes = copy_attributes atat;\n }\n | From.Parsetree.Pstr_module x0 ->\n To.Parsetree.Pstr_module (copy_module_binding x0)\n | From.Parsetree.Pstr_recmodule x0 ->\n To.Parsetree.Pstr_recmodule (List.map copy_module_binding x0)\n | From.Parsetree.Pstr_modtype x0 ->\n To.Parsetree.Pstr_modtype (copy_module_type_declaration x0)\n | From.Parsetree.Pstr_open\n {\n From.Parsetree.popen_lid;\n From.Parsetree.popen_override;\n From.Parsetree.popen_loc;\n From.Parsetree.popen_attributes;\n } ->\n To.Parsetree.Pstr_open\n {\n To.Parsetree.popen_expr =\n {\n To.Parsetree.pmod_desc =\n To.Parsetree.Pmod_ident (copy_loc copy_longident popen_lid);\n To.Parsetree.pmod_loc = popen_loc;\n To.Parsetree.pmod_attributes = [];\n };\n To.Parsetree.popen_override = copy_override_flag popen_override;\n To.Parsetree.popen_loc = copy_location popen_loc;\n To.Parsetree.popen_attributes = copy_attributes popen_attributes;\n }\n | From.Parsetree.Pstr_class x0 ->\n To.Parsetree.Pstr_class (List.map copy_class_declaration x0)\n | From.Parsetree.Pstr_class_type x0 ->\n To.Parsetree.Pstr_class_type (List.map copy_class_type_declaration x0)\n | From.Parsetree.Pstr_include x0 ->\n To.Parsetree.Pstr_include (copy_include_declaration x0)\n | From.Parsetree.Pstr_attribute x0 ->\n To.Parsetree.Pstr_attribute (copy_attribute x0)\n | From.Parsetree.Pstr_extension (x0, x1) ->\n To.Parsetree.Pstr_extension (copy_extension x0, copy_attributes x1)\n\nand copy_include_declaration :\n From.Parsetree.include_declaration -> To.Parsetree.include_declaration =\n fun x -> copy_include_infos copy_module_expr x\n\nand copy_class_declaration :\n From.Parsetree.class_declaration -> To.Parsetree.class_declaration =\n fun x -> copy_class_infos copy_class_expr x\n\nand copy_class_expr : From.Parsetree.class_expr -> To.Parsetree.class_expr =\n fun {\n From.Parsetree.pcl_desc;\n From.Parsetree.pcl_loc;\n From.Parsetree.pcl_attributes;\n } ->\n {\n To.Parsetree.pcl_desc = copy_class_expr_desc pcl_desc;\n To.Parsetree.pcl_loc = copy_location pcl_loc;\n To.Parsetree.pcl_attributes = copy_attributes pcl_attributes;\n }\n\nand copy_class_expr_desc :\n From.Parsetree.class_expr_desc -> To.Parsetree.class_expr_desc = function\n | From.Parsetree.Pcl_constr (x0, x1) ->\n To.Parsetree.Pcl_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Pcl_structure x0 ->\n To.Parsetree.Pcl_structure (copy_class_structure x0)\n | From.Parsetree.Pcl_fun (x0, x1, x2, x3) ->\n To.Parsetree.Pcl_fun\n ( copy_arg_label x0,\n copy_option copy_expression x1,\n copy_pattern x2,\n copy_class_expr x3 )\n | From.Parsetree.Pcl_apply (x0, x1) ->\n To.Parsetree.Pcl_apply\n ( copy_class_expr x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | From.Parsetree.Pcl_let (x0, x1, x2) ->\n To.Parsetree.Pcl_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_class_expr x2)\n | From.Parsetree.Pcl_constraint (x0, x1) ->\n To.Parsetree.Pcl_constraint (copy_class_expr x0, copy_class_type x1)\n | From.Parsetree.Pcl_extension x0 ->\n To.Parsetree.Pcl_extension (copy_extension x0)\n | From.Parsetree.Pcl_open (x0, x1, x2) ->\n To.Parsetree.Pcl_open\n ( {\n To.Parsetree.popen_expr = copy_loc copy_longident x1;\n To.Parsetree.popen_override = copy_override_flag x0;\n To.Parsetree.popen_loc = x1.Location.loc;\n To.Parsetree.popen_attributes = [];\n },\n copy_class_expr x2 )\n\nand copy_class_structure :\n From.Parsetree.class_structure -> To.Parsetree.class_structure =\n fun { From.Parsetree.pcstr_self; From.Parsetree.pcstr_fields } ->\n let fields =\n List.sort\n (fun (a : From.Parsetree.class_field) (b : From.Parsetree.class_field) ->\n compare a.pcf_loc.loc_start.pos_cnum b.pcf_loc.loc_start.pos_cnum)\n pcstr_fields\n in\n {\n To.Parsetree.pcstr_self = copy_pattern pcstr_self;\n To.Parsetree.pcstr_fields = List.map copy_class_field fields;\n }\n\nand copy_class_field : From.Parsetree.class_field -> To.Parsetree.class_field =\n fun {\n From.Parsetree.pcf_desc;\n From.Parsetree.pcf_loc;\n From.Parsetree.pcf_attributes;\n } ->\n {\n To.Parsetree.pcf_desc = copy_class_field_desc pcf_desc;\n To.Parsetree.pcf_loc = copy_location pcf_loc;\n To.Parsetree.pcf_attributes = copy_attributes pcf_attributes;\n }\n\nand copy_class_field_desc :\n From.Parsetree.class_field_desc -> To.Parsetree.class_field_desc = function\n | From.Parsetree.Pcf_inherit (x0, x1, x2) ->\n To.Parsetree.Pcf_inherit\n ( copy_override_flag x0,\n copy_class_expr x1,\n copy_option (fun x -> copy_loc (fun x -> x) x) x2 )\n | From.Parsetree.Pcf_val x0 ->\n To.Parsetree.Pcf_val\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_mutable_flag x1, copy_class_field_kind x2))\n | From.Parsetree.Pcf_method x0 ->\n To.Parsetree.Pcf_method\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_private_flag x1, copy_class_field_kind x2))\n | From.Parsetree.Pcf_constraint x0 ->\n To.Parsetree.Pcf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | From.Parsetree.Pcf_initializer x0 ->\n To.Parsetree.Pcf_initializer (copy_expression x0)\n | From.Parsetree.Pcf_attribute x0 ->\n To.Parsetree.Pcf_attribute (copy_attribute x0)\n | From.Parsetree.Pcf_extension x0 ->\n To.Parsetree.Pcf_extension (copy_extension x0)\n\nand copy_class_field_kind :\n From.Parsetree.class_field_kind -> To.Parsetree.class_field_kind = function\n | From.Parsetree.Cfk_virtual x0 ->\n To.Parsetree.Cfk_virtual (copy_core_type x0)\n | From.Parsetree.Cfk_concrete (x0, x1) ->\n To.Parsetree.Cfk_concrete (copy_override_flag x0, copy_expression x1)\n\nand copy_module_binding :\n From.Parsetree.module_binding -> To.Parsetree.module_binding =\n fun {\n From.Parsetree.pmb_name;\n From.Parsetree.pmb_expr;\n From.Parsetree.pmb_attributes;\n From.Parsetree.pmb_loc;\n } ->\n {\n To.Parsetree.pmb_name = copy_loc (fun x -> x) pmb_name;\n To.Parsetree.pmb_expr = copy_module_expr pmb_expr;\n To.Parsetree.pmb_attributes = copy_attributes pmb_attributes;\n To.Parsetree.pmb_loc = copy_location pmb_loc;\n }\n\nand copy_module_expr : From.Parsetree.module_expr -> To.Parsetree.module_expr =\n fun {\n From.Parsetree.pmod_desc;\n From.Parsetree.pmod_loc;\n From.Parsetree.pmod_attributes;\n } ->\n {\n To.Parsetree.pmod_desc = copy_module_expr_desc pmod_desc;\n To.Parsetree.pmod_loc = copy_location pmod_loc;\n To.Parsetree.pmod_attributes = copy_attributes pmod_attributes;\n }\n\nand copy_module_expr_desc :\n From.Parsetree.module_expr_desc -> To.Parsetree.module_expr_desc = function\n | From.Parsetree.Pmod_ident x0 ->\n To.Parsetree.Pmod_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pmod_structure x0 ->\n To.Parsetree.Pmod_structure (copy_structure x0)\n | From.Parsetree.Pmod_functor (x0, x1, x2) ->\n To.Parsetree.Pmod_functor\n ( copy_loc (fun x -> x) x0,\n copy_option copy_module_type x1,\n copy_module_expr x2 )\n | From.Parsetree.Pmod_apply (x0, x1) ->\n To.Parsetree.Pmod_apply (copy_module_expr x0, copy_module_expr x1)\n | From.Parsetree.Pmod_constraint (x0, x1) ->\n To.Parsetree.Pmod_constraint (copy_module_expr x0, copy_module_type x1)\n | From.Parsetree.Pmod_unpack x0 ->\n To.Parsetree.Pmod_unpack (copy_expression x0)\n | From.Parsetree.Pmod_extension x0 ->\n To.Parsetree.Pmod_extension (copy_extension x0)\n\nand copy_module_type : From.Parsetree.module_type -> To.Parsetree.module_type =\n fun {\n From.Parsetree.pmty_desc;\n From.Parsetree.pmty_loc;\n From.Parsetree.pmty_attributes;\n } ->\n {\n To.Parsetree.pmty_desc = copy_module_type_desc pmty_desc;\n To.Parsetree.pmty_loc = copy_location pmty_loc;\n To.Parsetree.pmty_attributes = copy_attributes pmty_attributes;\n }\n\nand copy_module_type_desc :\n From.Parsetree.module_type_desc -> To.Parsetree.module_type_desc = function\n | From.Parsetree.Pmty_ident x0 ->\n To.Parsetree.Pmty_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pmty_signature x0 ->\n To.Parsetree.Pmty_signature (copy_signature x0)\n | From.Parsetree.Pmty_functor (x0, x1, x2) ->\n To.Parsetree.Pmty_functor\n ( copy_loc (fun x -> x) x0,\n copy_option copy_module_type x1,\n copy_module_type x2 )\n | From.Parsetree.Pmty_with (x0, x1) ->\n To.Parsetree.Pmty_with\n (copy_module_type x0, List.map copy_with_constraint x1)\n | From.Parsetree.Pmty_typeof x0 ->\n To.Parsetree.Pmty_typeof (copy_module_expr x0)\n | From.Parsetree.Pmty_extension x0 ->\n To.Parsetree.Pmty_extension (copy_extension x0)\n | From.Parsetree.Pmty_alias x0 ->\n To.Parsetree.Pmty_alias (copy_loc copy_longident x0)\n\nand copy_with_constraint :\n From.Parsetree.with_constraint -> To.Parsetree.with_constraint = function\n | From.Parsetree.Pwith_type (x0, x1) ->\n To.Parsetree.Pwith_type\n (copy_loc copy_longident x0, copy_type_declaration x1)\n | From.Parsetree.Pwith_module (x0, x1) ->\n To.Parsetree.Pwith_module\n (copy_loc copy_longident x0, copy_loc copy_longident x1)\n | From.Parsetree.Pwith_typesubst (x0, x1) ->\n To.Parsetree.Pwith_typesubst\n (copy_loc copy_longident x0, copy_type_declaration x1)\n | From.Parsetree.Pwith_modsubst (x0, x1) ->\n To.Parsetree.Pwith_modsubst\n (copy_loc copy_longident x0, copy_loc copy_longident x1)\n\nand copy_signature : From.Parsetree.signature -> To.Parsetree.signature =\n fun x -> List.map copy_signature_item x\n\nand copy_signature_item :\n From.Parsetree.signature_item -> To.Parsetree.signature_item =\n fun { From.Parsetree.psig_desc; From.Parsetree.psig_loc } ->\n {\n To.Parsetree.psig_desc = copy_signature_item_desc psig_desc;\n To.Parsetree.psig_loc = copy_location psig_loc;\n }\n\nand copy_signature_item_desc :\n From.Parsetree.signature_item_desc -> To.Parsetree.signature_item_desc =\n function\n | From.Parsetree.Psig_value x0 ->\n To.Parsetree.Psig_value (copy_value_description x0)\n | From.Parsetree.Psig_type (x0, x1) ->\n To.Parsetree.Psig_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | From.Parsetree.Psig_typext x0 ->\n To.Parsetree.Psig_typext (copy_type_extension x0)\n | From.Parsetree.Psig_exception x0 ->\n let atat, at =\n List.partition\n (function\n | { Location.txt = \"ocaml.deprecated\" | \"deprecated\"; _ }, _ ->\n false\n | _ -> true)\n x0.pext_attributes\n in\n let x0 = { x0 with pext_attributes = at } in\n\n To.Parsetree.Psig_exception\n {\n To.Parsetree.ptyexn_constructor = copy_extension_constructor x0;\n To.Parsetree.ptyexn_loc = x0.From.Parsetree.pext_loc;\n To.Parsetree.ptyexn_attributes = copy_attributes atat;\n }\n | From.Parsetree.Psig_module x0 ->\n To.Parsetree.Psig_module (copy_module_declaration x0)\n | From.Parsetree.Psig_recmodule x0 ->\n To.Parsetree.Psig_recmodule (List.map copy_module_declaration x0)\n | From.Parsetree.Psig_modtype x0 ->\n To.Parsetree.Psig_modtype (copy_module_type_declaration x0)\n | From.Parsetree.Psig_open x0 ->\n To.Parsetree.Psig_open (copy_open_description x0)\n | From.Parsetree.Psig_include x0 ->\n To.Parsetree.Psig_include (copy_include_description x0)\n | From.Parsetree.Psig_class x0 ->\n To.Parsetree.Psig_class (List.map copy_class_description x0)\n | From.Parsetree.Psig_class_type x0 ->\n To.Parsetree.Psig_class_type (List.map copy_class_type_declaration x0)\n | From.Parsetree.Psig_attribute x0 ->\n To.Parsetree.Psig_attribute (copy_attribute x0)\n | From.Parsetree.Psig_extension (x0, x1) ->\n To.Parsetree.Psig_extension (copy_extension x0, copy_attributes x1)\n\nand copy_class_type_declaration :\n From.Parsetree.class_type_declaration -> To.Parsetree.class_type_declaration\n =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_description :\n From.Parsetree.class_description -> To.Parsetree.class_description =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_type : From.Parsetree.class_type -> To.Parsetree.class_type =\n fun {\n From.Parsetree.pcty_desc;\n From.Parsetree.pcty_loc;\n From.Parsetree.pcty_attributes;\n } ->\n {\n To.Parsetree.pcty_desc = copy_class_type_desc pcty_desc;\n To.Parsetree.pcty_loc = copy_location pcty_loc;\n To.Parsetree.pcty_attributes = copy_attributes pcty_attributes;\n }\n\nand copy_class_type_desc :\n From.Parsetree.class_type_desc -> To.Parsetree.class_type_desc = function\n | From.Parsetree.Pcty_constr (x0, x1) ->\n To.Parsetree.Pcty_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Pcty_signature x0 ->\n To.Parsetree.Pcty_signature (copy_class_signature x0)\n | From.Parsetree.Pcty_arrow (x0, x1, x2) ->\n To.Parsetree.Pcty_arrow\n (copy_arg_label x0, copy_core_type x1, copy_class_type x2)\n | From.Parsetree.Pcty_extension x0 ->\n To.Parsetree.Pcty_extension (copy_extension x0)\n | From.Parsetree.Pcty_open (x0, x1, x2) ->\n To.Parsetree.Pcty_open\n ( {\n To.Parsetree.popen_expr = copy_loc copy_longident x1;\n To.Parsetree.popen_override = copy_override_flag x0;\n To.Parsetree.popen_loc = x1.Location.loc;\n To.Parsetree.popen_attributes = [];\n },\n copy_class_type x2 )\n\nand copy_class_signature :\n From.Parsetree.class_signature -> To.Parsetree.class_signature =\n fun { From.Parsetree.pcsig_self; From.Parsetree.pcsig_fields } ->\n let fields =\n List.sort\n (fun (a : From.Parsetree.class_type_field)\n (b : From.Parsetree.class_type_field) ->\n compare a.pctf_loc.loc_start.pos_cnum b.pctf_loc.loc_start.pos_cnum)\n pcsig_fields\n in\n\n {\n To.Parsetree.pcsig_self = copy_core_type pcsig_self;\n To.Parsetree.pcsig_fields = List.map copy_class_type_field fields;\n }\n\nand copy_class_type_field :\n From.Parsetree.class_type_field -> To.Parsetree.class_type_field =\n fun {\n From.Parsetree.pctf_desc;\n From.Parsetree.pctf_loc;\n From.Parsetree.pctf_attributes;\n } ->\n {\n To.Parsetree.pctf_desc = copy_class_type_field_desc pctf_desc;\n To.Parsetree.pctf_loc = copy_location pctf_loc;\n To.Parsetree.pctf_attributes = copy_attributes pctf_attributes;\n }\n\nand copy_class_type_field_desc :\n From.Parsetree.class_type_field_desc -> To.Parsetree.class_type_field_desc =\n function\n | From.Parsetree.Pctf_inherit x0 ->\n To.Parsetree.Pctf_inherit (copy_class_type x0)\n | From.Parsetree.Pctf_val x0 ->\n To.Parsetree.Pctf_val\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_mutable_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | From.Parsetree.Pctf_method x0 ->\n To.Parsetree.Pctf_method\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_private_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | From.Parsetree.Pctf_constraint x0 ->\n To.Parsetree.Pctf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | From.Parsetree.Pctf_attribute x0 ->\n To.Parsetree.Pctf_attribute (copy_attribute x0)\n | From.Parsetree.Pctf_extension x0 ->\n To.Parsetree.Pctf_extension (copy_extension x0)\n\nand copy_extension : From.Parsetree.extension -> To.Parsetree.extension =\n fun x ->\n let x0, x1 = x in\n let x1 =\n match x0.txt with\n | \"ocaml.error\" | \"error\" -> (\n match x1 with\n | PStr (hd :: _ :: tl) -> From.Parsetree.PStr (hd :: tl)\n | _ -> x1)\n | _ -> x1\n in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_class_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 From.Parsetree.class_infos ->\n 'g0 To.Parsetree.class_infos =\n fun f0\n {\n From.Parsetree.pci_virt;\n From.Parsetree.pci_params;\n From.Parsetree.pci_name;\n From.Parsetree.pci_expr;\n From.Parsetree.pci_loc;\n From.Parsetree.pci_attributes;\n } ->\n {\n To.Parsetree.pci_virt = copy_virtual_flag pci_virt;\n To.Parsetree.pci_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n pci_params;\n To.Parsetree.pci_name = copy_loc (fun x -> x) pci_name;\n To.Parsetree.pci_expr = f0 pci_expr;\n To.Parsetree.pci_loc = copy_location pci_loc;\n To.Parsetree.pci_attributes = copy_attributes pci_attributes;\n }\n\nand copy_virtual_flag : From.Asttypes.virtual_flag -> To.Asttypes.virtual_flag =\n function\n | From.Asttypes.Virtual -> To.Asttypes.Virtual\n | From.Asttypes.Concrete -> To.Asttypes.Concrete\n\nand copy_include_description :\n From.Parsetree.include_description -> To.Parsetree.include_description =\n fun x -> copy_include_infos copy_module_type x\n\nand copy_include_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 From.Parsetree.include_infos ->\n 'g0 To.Parsetree.include_infos =\n fun f0\n {\n From.Parsetree.pincl_mod;\n From.Parsetree.pincl_loc;\n From.Parsetree.pincl_attributes;\n } ->\n {\n To.Parsetree.pincl_mod = f0 pincl_mod;\n To.Parsetree.pincl_loc = copy_location pincl_loc;\n To.Parsetree.pincl_attributes = copy_attributes pincl_attributes;\n }\n\nand copy_open_description :\n From.Parsetree.open_description -> To.Parsetree.open_description =\n fun {\n From.Parsetree.popen_lid;\n From.Parsetree.popen_override;\n From.Parsetree.popen_loc;\n From.Parsetree.popen_attributes;\n } ->\n {\n To.Parsetree.popen_expr = copy_loc copy_longident popen_lid;\n To.Parsetree.popen_override = copy_override_flag popen_override;\n To.Parsetree.popen_loc = copy_location popen_loc;\n To.Parsetree.popen_attributes = copy_attributes popen_attributes;\n }\n\nand copy_override_flag :\n From.Asttypes.override_flag -> To.Asttypes.override_flag = function\n | From.Asttypes.Override -> To.Asttypes.Override\n | From.Asttypes.Fresh -> To.Asttypes.Fresh\n\nand copy_module_type_declaration :\n From.Parsetree.module_type_declaration ->\n To.Parsetree.module_type_declaration =\n fun {\n From.Parsetree.pmtd_name;\n From.Parsetree.pmtd_type;\n From.Parsetree.pmtd_attributes;\n From.Parsetree.pmtd_loc;\n } ->\n {\n To.Parsetree.pmtd_name = copy_loc (fun x -> x) pmtd_name;\n To.Parsetree.pmtd_type = copy_option copy_module_type pmtd_type;\n To.Parsetree.pmtd_attributes = copy_attributes pmtd_attributes;\n To.Parsetree.pmtd_loc = copy_location pmtd_loc;\n }\n\nand copy_module_declaration :\n From.Parsetree.module_declaration -> To.Parsetree.module_declaration =\n fun {\n From.Parsetree.pmd_name;\n From.Parsetree.pmd_type;\n From.Parsetree.pmd_attributes;\n From.Parsetree.pmd_loc;\n } ->\n {\n To.Parsetree.pmd_name = copy_loc (fun x -> x) pmd_name;\n To.Parsetree.pmd_type = copy_module_type pmd_type;\n To.Parsetree.pmd_attributes = copy_attributes pmd_attributes;\n To.Parsetree.pmd_loc = copy_location pmd_loc;\n }\n\nand copy_type_extension :\n From.Parsetree.type_extension -> To.Parsetree.type_extension =\n fun {\n From.Parsetree.ptyext_path;\n From.Parsetree.ptyext_params;\n From.Parsetree.ptyext_constructors;\n From.Parsetree.ptyext_private;\n From.Parsetree.ptyext_attributes;\n } ->\n {\n To.Parsetree.ptyext_path = copy_loc copy_longident ptyext_path;\n To.Parsetree.ptyext_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptyext_params;\n To.Parsetree.ptyext_constructors =\n List.map copy_extension_constructor ptyext_constructors;\n To.Parsetree.ptyext_private = copy_private_flag ptyext_private;\n To.Parsetree.ptyext_loc = ptyext_path.Location.loc;\n To.Parsetree.ptyext_attributes = copy_attributes ptyext_attributes;\n }\n\nand copy_extension_constructor :\n From.Parsetree.extension_constructor -> To.Parsetree.extension_constructor =\n fun {\n From.Parsetree.pext_name;\n From.Parsetree.pext_kind;\n From.Parsetree.pext_loc;\n From.Parsetree.pext_attributes;\n } ->\n {\n To.Parsetree.pext_name = copy_loc (fun x -> x) pext_name;\n To.Parsetree.pext_kind = copy_extension_constructor_kind pext_kind;\n To.Parsetree.pext_loc = copy_location pext_loc;\n To.Parsetree.pext_attributes = copy_attributes pext_attributes;\n }\n\nand copy_extension_constructor_kind :\n From.Parsetree.extension_constructor_kind ->\n To.Parsetree.extension_constructor_kind = function\n | From.Parsetree.Pext_decl (x0, x1) ->\n To.Parsetree.Pext_decl\n (copy_constructor_arguments x0, copy_option copy_core_type x1)\n | From.Parsetree.Pext_rebind x0 ->\n To.Parsetree.Pext_rebind (copy_loc copy_longident x0)\n\nand copy_type_declaration :\n From.Parsetree.type_declaration -> To.Parsetree.type_declaration =\n fun {\n From.Parsetree.ptype_name;\n From.Parsetree.ptype_params;\n From.Parsetree.ptype_cstrs;\n From.Parsetree.ptype_kind;\n From.Parsetree.ptype_private;\n From.Parsetree.ptype_manifest;\n From.Parsetree.ptype_attributes;\n From.Parsetree.ptype_loc;\n } ->\n {\n To.Parsetree.ptype_name = copy_loc (fun x -> x) ptype_name;\n To.Parsetree.ptype_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptype_params;\n To.Parsetree.ptype_cstrs =\n List.map\n (fun x ->\n let x0, x1, x2 = x in\n (copy_core_type x0, copy_core_type x1, copy_location x2))\n ptype_cstrs;\n To.Parsetree.ptype_kind = copy_type_kind ptype_kind;\n To.Parsetree.ptype_private = copy_private_flag ptype_private;\n To.Parsetree.ptype_manifest = copy_option copy_core_type ptype_manifest;\n To.Parsetree.ptype_attributes = copy_attributes ptype_attributes;\n To.Parsetree.ptype_loc = copy_location ptype_loc;\n }\n\nand copy_private_flag : From.Asttypes.private_flag -> To.Asttypes.private_flag =\n function\n | From.Asttypes.Private -> To.Asttypes.Private\n | From.Asttypes.Public -> To.Asttypes.Public\n\nand copy_type_kind : From.Parsetree.type_kind -> To.Parsetree.type_kind =\n function\n | From.Parsetree.Ptype_abstract -> To.Parsetree.Ptype_abstract\n | From.Parsetree.Ptype_variant x0 ->\n To.Parsetree.Ptype_variant (List.map copy_constructor_declaration x0)\n | From.Parsetree.Ptype_record x0 ->\n To.Parsetree.Ptype_record (List.map copy_label_declaration x0)\n | From.Parsetree.Ptype_open -> To.Parsetree.Ptype_open\n\nand copy_constructor_declaration :\n From.Parsetree.constructor_declaration ->\n To.Parsetree.constructor_declaration =\n fun {\n From.Parsetree.pcd_name;\n From.Parsetree.pcd_args;\n From.Parsetree.pcd_res;\n From.Parsetree.pcd_loc;\n From.Parsetree.pcd_attributes;\n } ->\n {\n To.Parsetree.pcd_name = copy_loc (fun x -> x) pcd_name;\n To.Parsetree.pcd_args = copy_constructor_arguments pcd_args;\n To.Parsetree.pcd_res = copy_option copy_core_type pcd_res;\n To.Parsetree.pcd_loc = copy_location pcd_loc;\n To.Parsetree.pcd_attributes = copy_attributes pcd_attributes;\n }\n\nand copy_constructor_arguments :\n From.Parsetree.constructor_arguments -> To.Parsetree.constructor_arguments =\n function\n | From.Parsetree.Pcstr_tuple x0 ->\n To.Parsetree.Pcstr_tuple (List.map copy_core_type x0)\n | From.Parsetree.Pcstr_record x0 ->\n To.Parsetree.Pcstr_record (List.map copy_label_declaration x0)\n\nand copy_label_declaration :\n From.Parsetree.label_declaration -> To.Parsetree.label_declaration =\n fun {\n From.Parsetree.pld_name;\n From.Parsetree.pld_mutable;\n From.Parsetree.pld_type;\n From.Parsetree.pld_loc;\n From.Parsetree.pld_attributes;\n } ->\n {\n To.Parsetree.pld_name = copy_loc (fun x -> x) pld_name;\n To.Parsetree.pld_mutable = copy_mutable_flag pld_mutable;\n To.Parsetree.pld_type = copy_core_type pld_type;\n To.Parsetree.pld_loc = copy_location pld_loc;\n To.Parsetree.pld_attributes = copy_attributes pld_attributes;\n }\n\nand copy_mutable_flag : From.Asttypes.mutable_flag -> To.Asttypes.mutable_flag =\n function\n | From.Asttypes.Immutable -> To.Asttypes.Immutable\n | From.Asttypes.Mutable -> To.Asttypes.Mutable\n\nand copy_variance : From.Asttypes.variance -> To.Asttypes.variance = function\n | From.Asttypes.Covariant -> To.Asttypes.Covariant\n | From.Asttypes.Contravariant -> To.Asttypes.Contravariant\n | From.Asttypes.Invariant -> To.Asttypes.Invariant\n\nand copy_value_description :\n From.Parsetree.value_description -> To.Parsetree.value_description =\n fun {\n From.Parsetree.pval_name;\n From.Parsetree.pval_type;\n From.Parsetree.pval_prim;\n From.Parsetree.pval_attributes;\n From.Parsetree.pval_loc;\n } ->\n {\n To.Parsetree.pval_name = copy_loc (fun x -> x) pval_name;\n To.Parsetree.pval_type = copy_core_type pval_type;\n To.Parsetree.pval_prim = List.map (fun x -> x) pval_prim;\n To.Parsetree.pval_attributes = copy_attributes pval_attributes;\n To.Parsetree.pval_loc = copy_location pval_loc;\n }\n\nand copy_arg_label : From.Asttypes.arg_label -> To.Asttypes.arg_label = function\n | From.Asttypes.Nolabel -> To.Asttypes.Nolabel\n | From.Asttypes.Labelled x0 -> To.Asttypes.Labelled x0\n | From.Asttypes.Optional x0 -> To.Asttypes.Optional x0\n\nand copy_closed_flag : From.Asttypes.closed_flag -> To.Asttypes.closed_flag =\n function\n | From.Asttypes.Closed -> To.Asttypes.Closed\n | From.Asttypes.Open -> To.Asttypes.Open\n\nand copy_label : From.Asttypes.label -> To.Asttypes.label = fun x -> x\n\nand copy_rec_flag : From.Asttypes.rec_flag -> To.Asttypes.rec_flag = function\n | From.Asttypes.Nonrecursive -> To.Asttypes.Nonrecursive\n | From.Asttypes.Recursive -> To.Asttypes.Recursive\n\nand copy_constant : From.Parsetree.constant -> To.Parsetree.constant = function\n | From.Parsetree.Pconst_integer (x0, x1) ->\n To.Parsetree.Pconst_integer (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pconst_char x0 -> To.Parsetree.Pconst_char x0\n | From.Parsetree.Pconst_string (x0, x1) ->\n To.Parsetree.Pconst_string (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pconst_float (x0, x1) ->\n To.Parsetree.Pconst_float (x0, copy_option (fun x -> x) x1)\n\nand copy_option : 'f0 'g0. ('f0 -> 'g0) -> 'f0 option -> 'g0 option =\n fun f0 -> function None -> None | Some x0 -> Some (f0 x0)\n\nand copy_longident : Longident.t -> Longident.t = fun x -> x\n\nand copy_loc :\n 'f0 'g0. ('f0 -> 'g0) -> 'f0 From.Asttypes.loc -> 'g0 To.Asttypes.loc =\n fun f0 { From.Asttypes.txt; From.Asttypes.loc } ->\n { To.Asttypes.txt = f0 txt; To.Asttypes.loc = copy_location loc }\n\nand copy_location : Location.t -> Location.t = fun x -> x\nand copy_bool : bool -> bool = function false -> false | true -> true\n\nlet copy_cases x = List.map copy_case x\nlet copy_pat = copy_pattern\nlet copy_expr = copy_expression\nlet copy_typ = copy_core_type\n","(**************************************************************************)\n(* *)\n(* OCaml Migrate Parsetree *)\n(* *)\n(* Frédéric Bour *)\n(* Alain Frisch, LexiFi *)\n(* *)\n(* Copyright 2017 Institut National de Recherche en Informatique et *)\n(* en Automatique (INRIA). *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nmodule From = Ast_407\nmodule To = Ast_406\n\nlet rec copy_expression : From.Parsetree.expression -> To.Parsetree.expression =\n fun {\n From.Parsetree.pexp_desc;\n From.Parsetree.pexp_loc;\n From.Parsetree.pexp_attributes;\n } ->\n {\n To.Parsetree.pexp_desc = copy_expression_desc pexp_desc;\n To.Parsetree.pexp_loc = copy_location pexp_loc;\n To.Parsetree.pexp_attributes = copy_attributes pexp_attributes;\n }\n\nand copy_expression_desc :\n From.Parsetree.expression_desc -> To.Parsetree.expression_desc = function\n | From.Parsetree.Pexp_ident x0 ->\n To.Parsetree.Pexp_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pexp_constant x0 ->\n To.Parsetree.Pexp_constant (copy_constant x0)\n | From.Parsetree.Pexp_let (x0, x1, x2) ->\n To.Parsetree.Pexp_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_expression x2)\n | From.Parsetree.Pexp_function x0 ->\n To.Parsetree.Pexp_function (List.map copy_case x0)\n | From.Parsetree.Pexp_fun (x0, x1, x2, x3) ->\n To.Parsetree.Pexp_fun\n ( copy_arg_label x0,\n copy_option copy_expression x1,\n copy_pattern x2,\n copy_expression x3 )\n | From.Parsetree.Pexp_apply (x0, x1) ->\n To.Parsetree.Pexp_apply\n ( copy_expression x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | From.Parsetree.Pexp_match (x0, x1) ->\n To.Parsetree.Pexp_match (copy_expression x0, List.map copy_case x1)\n | From.Parsetree.Pexp_try (x0, x1) ->\n To.Parsetree.Pexp_try (copy_expression x0, List.map copy_case x1)\n | From.Parsetree.Pexp_tuple x0 ->\n To.Parsetree.Pexp_tuple (List.map copy_expression x0)\n | From.Parsetree.Pexp_construct (x0, x1) ->\n To.Parsetree.Pexp_construct\n (copy_loc copy_longident x0, copy_option copy_expression x1)\n | From.Parsetree.Pexp_variant (x0, x1) ->\n To.Parsetree.Pexp_variant (copy_label x0, copy_option copy_expression x1)\n | From.Parsetree.Pexp_record (x0, x1) ->\n To.Parsetree.Pexp_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_expression x1))\n x0,\n copy_option copy_expression x1 )\n | From.Parsetree.Pexp_field (x0, x1) ->\n To.Parsetree.Pexp_field (copy_expression x0, copy_loc copy_longident x1)\n | From.Parsetree.Pexp_setfield (x0, x1, x2) ->\n To.Parsetree.Pexp_setfield\n (copy_expression x0, copy_loc copy_longident x1, copy_expression x2)\n | From.Parsetree.Pexp_array x0 ->\n To.Parsetree.Pexp_array (List.map copy_expression x0)\n | From.Parsetree.Pexp_ifthenelse (x0, x1, x2) ->\n To.Parsetree.Pexp_ifthenelse\n (copy_expression x0, copy_expression x1, copy_option copy_expression x2)\n | From.Parsetree.Pexp_sequence (x0, x1) ->\n To.Parsetree.Pexp_sequence (copy_expression x0, copy_expression x1)\n | From.Parsetree.Pexp_while (x0, x1) ->\n To.Parsetree.Pexp_while (copy_expression x0, copy_expression x1)\n | From.Parsetree.Pexp_for (x0, x1, x2, x3, x4) ->\n To.Parsetree.Pexp_for\n ( copy_pattern x0,\n copy_expression x1,\n copy_expression x2,\n copy_direction_flag x3,\n copy_expression x4 )\n | From.Parsetree.Pexp_constraint (x0, x1) ->\n To.Parsetree.Pexp_constraint (copy_expression x0, copy_core_type x1)\n | From.Parsetree.Pexp_coerce (x0, x1, x2) ->\n To.Parsetree.Pexp_coerce\n (copy_expression x0, copy_option copy_core_type x1, copy_core_type x2)\n | From.Parsetree.Pexp_send (x0, x1) ->\n To.Parsetree.Pexp_send (copy_expression x0, copy_loc (fun x -> x) x1)\n | From.Parsetree.Pexp_new x0 ->\n To.Parsetree.Pexp_new (copy_loc copy_longident x0)\n | From.Parsetree.Pexp_setinstvar (x0, x1) ->\n To.Parsetree.Pexp_setinstvar (copy_loc (fun x -> x) x0, copy_expression x1)\n | From.Parsetree.Pexp_override x0 ->\n To.Parsetree.Pexp_override\n (List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_expression x1))\n x0)\n | From.Parsetree.Pexp_letmodule (x0, x1, x2) ->\n To.Parsetree.Pexp_letmodule\n (copy_loc (fun x -> x) x0, copy_module_expr x1, copy_expression x2)\n | From.Parsetree.Pexp_letexception (x0, x1) ->\n To.Parsetree.Pexp_letexception\n (copy_extension_constructor x0, copy_expression x1)\n | From.Parsetree.Pexp_assert x0 ->\n To.Parsetree.Pexp_assert (copy_expression x0)\n | From.Parsetree.Pexp_lazy x0 -> To.Parsetree.Pexp_lazy (copy_expression x0)\n | From.Parsetree.Pexp_poly (x0, x1) ->\n To.Parsetree.Pexp_poly (copy_expression x0, copy_option copy_core_type x1)\n | From.Parsetree.Pexp_object x0 ->\n To.Parsetree.Pexp_object (copy_class_structure x0)\n | From.Parsetree.Pexp_newtype (x0, x1) ->\n To.Parsetree.Pexp_newtype (copy_loc (fun x -> x) x0, copy_expression x1)\n | From.Parsetree.Pexp_pack x0 -> To.Parsetree.Pexp_pack (copy_module_expr x0)\n | From.Parsetree.Pexp_open (x0, x1, x2) ->\n To.Parsetree.Pexp_open\n (copy_override_flag x0, copy_loc copy_longident x1, copy_expression x2)\n | From.Parsetree.Pexp_extension x0 ->\n To.Parsetree.Pexp_extension (copy_extension x0)\n | From.Parsetree.Pexp_unreachable -> To.Parsetree.Pexp_unreachable\n\nand copy_direction_flag :\n From.Asttypes.direction_flag -> To.Asttypes.direction_flag = function\n | From.Asttypes.Upto -> To.Asttypes.Upto\n | From.Asttypes.Downto -> To.Asttypes.Downto\n\nand copy_case : From.Parsetree.case -> To.Parsetree.case =\n fun { From.Parsetree.pc_lhs; From.Parsetree.pc_guard; From.Parsetree.pc_rhs } ->\n {\n To.Parsetree.pc_lhs = copy_pattern pc_lhs;\n To.Parsetree.pc_guard = copy_option copy_expression pc_guard;\n To.Parsetree.pc_rhs = copy_expression pc_rhs;\n }\n\nand copy_value_binding :\n From.Parsetree.value_binding -> To.Parsetree.value_binding =\n fun {\n From.Parsetree.pvb_pat;\n From.Parsetree.pvb_expr;\n From.Parsetree.pvb_attributes;\n From.Parsetree.pvb_loc;\n } ->\n {\n To.Parsetree.pvb_pat = copy_pattern pvb_pat;\n To.Parsetree.pvb_expr = copy_expression pvb_expr;\n To.Parsetree.pvb_attributes = copy_attributes pvb_attributes;\n To.Parsetree.pvb_loc = copy_location pvb_loc;\n }\n\nand copy_pattern : From.Parsetree.pattern -> To.Parsetree.pattern =\n fun {\n From.Parsetree.ppat_desc;\n From.Parsetree.ppat_loc;\n From.Parsetree.ppat_attributes;\n } ->\n {\n To.Parsetree.ppat_desc = copy_pattern_desc ppat_desc;\n To.Parsetree.ppat_loc = copy_location ppat_loc;\n To.Parsetree.ppat_attributes = copy_attributes ppat_attributes;\n }\n\nand copy_pattern_desc : From.Parsetree.pattern_desc -> To.Parsetree.pattern_desc\n = function\n | From.Parsetree.Ppat_any -> To.Parsetree.Ppat_any\n | From.Parsetree.Ppat_var x0 ->\n To.Parsetree.Ppat_var (copy_loc (fun x -> x) x0)\n | From.Parsetree.Ppat_alias (x0, x1) ->\n To.Parsetree.Ppat_alias (copy_pattern x0, copy_loc (fun x -> x) x1)\n | From.Parsetree.Ppat_constant x0 ->\n To.Parsetree.Ppat_constant (copy_constant x0)\n | From.Parsetree.Ppat_interval (x0, x1) ->\n To.Parsetree.Ppat_interval (copy_constant x0, copy_constant x1)\n | From.Parsetree.Ppat_tuple x0 ->\n To.Parsetree.Ppat_tuple (List.map copy_pattern x0)\n | From.Parsetree.Ppat_construct (x0, x1) ->\n To.Parsetree.Ppat_construct\n (copy_loc copy_longident x0, copy_option copy_pattern x1)\n | From.Parsetree.Ppat_variant (x0, x1) ->\n To.Parsetree.Ppat_variant (copy_label x0, copy_option copy_pattern x1)\n | From.Parsetree.Ppat_record (x0, x1) ->\n To.Parsetree.Ppat_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_pattern x1))\n x0,\n copy_closed_flag x1 )\n | From.Parsetree.Ppat_array x0 ->\n To.Parsetree.Ppat_array (List.map copy_pattern x0)\n | From.Parsetree.Ppat_or (x0, x1) ->\n To.Parsetree.Ppat_or (copy_pattern x0, copy_pattern x1)\n | From.Parsetree.Ppat_constraint (x0, x1) ->\n To.Parsetree.Ppat_constraint (copy_pattern x0, copy_core_type x1)\n | From.Parsetree.Ppat_type x0 ->\n To.Parsetree.Ppat_type (copy_loc copy_longident x0)\n | From.Parsetree.Ppat_lazy x0 -> To.Parsetree.Ppat_lazy (copy_pattern x0)\n | From.Parsetree.Ppat_unpack x0 ->\n To.Parsetree.Ppat_unpack (copy_loc (fun x -> x) x0)\n | From.Parsetree.Ppat_exception x0 ->\n To.Parsetree.Ppat_exception (copy_pattern x0)\n | From.Parsetree.Ppat_extension x0 ->\n To.Parsetree.Ppat_extension (copy_extension x0)\n | From.Parsetree.Ppat_open (x0, x1) ->\n To.Parsetree.Ppat_open (copy_loc copy_longident x0, copy_pattern x1)\n\nand copy_core_type : From.Parsetree.core_type -> To.Parsetree.core_type =\n fun {\n From.Parsetree.ptyp_desc;\n From.Parsetree.ptyp_loc;\n From.Parsetree.ptyp_attributes;\n } ->\n {\n To.Parsetree.ptyp_desc = copy_core_type_desc ptyp_desc;\n To.Parsetree.ptyp_loc = copy_location ptyp_loc;\n To.Parsetree.ptyp_attributes = copy_attributes ptyp_attributes;\n }\n\nand copy_core_type_desc :\n From.Parsetree.core_type_desc -> To.Parsetree.core_type_desc = function\n | From.Parsetree.Ptyp_any -> To.Parsetree.Ptyp_any\n | From.Parsetree.Ptyp_var x0 -> To.Parsetree.Ptyp_var x0\n | From.Parsetree.Ptyp_arrow (x0, x1, x2) ->\n To.Parsetree.Ptyp_arrow\n (copy_arg_label x0, copy_core_type x1, copy_core_type x2)\n | From.Parsetree.Ptyp_tuple x0 ->\n To.Parsetree.Ptyp_tuple (List.map copy_core_type x0)\n | From.Parsetree.Ptyp_constr (x0, x1) ->\n To.Parsetree.Ptyp_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Ptyp_object (x0, x1) ->\n To.Parsetree.Ptyp_object\n (List.map copy_object_field x0, copy_closed_flag x1)\n | From.Parsetree.Ptyp_class (x0, x1) ->\n To.Parsetree.Ptyp_class\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Ptyp_alias (x0, x1) ->\n To.Parsetree.Ptyp_alias (copy_core_type x0, x1)\n | From.Parsetree.Ptyp_variant (x0, x1, x2) ->\n To.Parsetree.Ptyp_variant\n ( List.map copy_row_field x0,\n copy_closed_flag x1,\n copy_option (fun x -> List.map copy_label x) x2 )\n | From.Parsetree.Ptyp_poly (x0, x1) ->\n To.Parsetree.Ptyp_poly\n (List.map (fun x -> copy_loc (fun x -> x) x) x0, copy_core_type x1)\n | From.Parsetree.Ptyp_package x0 ->\n To.Parsetree.Ptyp_package (copy_package_type x0)\n | From.Parsetree.Ptyp_extension x0 ->\n To.Parsetree.Ptyp_extension (copy_extension x0)\n\nand copy_package_type : From.Parsetree.package_type -> To.Parsetree.package_type\n =\n fun x ->\n let x0, x1 = x in\n ( copy_loc copy_longident x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_core_type x1))\n x1 )\n\nand copy_row_field : From.Parsetree.row_field -> To.Parsetree.row_field =\n function\n | From.Parsetree.Rtag (x0, x1, x2, x3) ->\n To.Parsetree.Rtag\n ( copy_loc copy_label x0,\n copy_attributes x1,\n copy_bool x2,\n List.map copy_core_type x3 )\n | From.Parsetree.Rinherit x0 -> To.Parsetree.Rinherit (copy_core_type x0)\n\nand copy_object_field : From.Parsetree.object_field -> To.Parsetree.object_field\n = function\n | From.Parsetree.Otag (x0, x1, x2) ->\n To.Parsetree.Otag\n (copy_loc (fun x -> x) x0, copy_attributes x1, copy_core_type x2)\n | From.Parsetree.Oinherit x -> To.Parsetree.Oinherit (copy_core_type x)\n\nand copy_attributes : From.Parsetree.attributes -> To.Parsetree.attributes =\n fun x -> List.map copy_attribute x\n\nand copy_attribute : From.Parsetree.attribute -> To.Parsetree.attribute =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_payload : From.Parsetree.payload -> To.Parsetree.payload = function\n | From.Parsetree.PStr x0 -> To.Parsetree.PStr (copy_structure x0)\n | From.Parsetree.PSig x0 -> To.Parsetree.PSig (copy_signature x0)\n | From.Parsetree.PTyp x0 -> To.Parsetree.PTyp (copy_core_type x0)\n | From.Parsetree.PPat (x0, x1) ->\n To.Parsetree.PPat (copy_pattern x0, copy_option copy_expression x1)\n\nand copy_structure : From.Parsetree.structure -> To.Parsetree.structure =\n fun x -> List.map copy_structure_item x\n\nand copy_structure_item :\n From.Parsetree.structure_item -> To.Parsetree.structure_item =\n fun { From.Parsetree.pstr_desc; From.Parsetree.pstr_loc } ->\n {\n To.Parsetree.pstr_desc = copy_structure_item_desc pstr_desc;\n To.Parsetree.pstr_loc = copy_location pstr_loc;\n }\n\nand copy_structure_item_desc :\n From.Parsetree.structure_item_desc -> To.Parsetree.structure_item_desc =\n function\n | From.Parsetree.Pstr_eval (x0, x1) ->\n To.Parsetree.Pstr_eval (copy_expression x0, copy_attributes x1)\n | From.Parsetree.Pstr_value (x0, x1) ->\n To.Parsetree.Pstr_value (copy_rec_flag x0, List.map copy_value_binding x1)\n | From.Parsetree.Pstr_primitive x0 ->\n To.Parsetree.Pstr_primitive (copy_value_description x0)\n | From.Parsetree.Pstr_type (x0, x1) ->\n To.Parsetree.Pstr_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | From.Parsetree.Pstr_typext x0 ->\n To.Parsetree.Pstr_typext (copy_type_extension x0)\n | From.Parsetree.Pstr_exception x0 ->\n To.Parsetree.Pstr_exception (copy_extension_constructor x0)\n | From.Parsetree.Pstr_module x0 ->\n To.Parsetree.Pstr_module (copy_module_binding x0)\n | From.Parsetree.Pstr_recmodule x0 ->\n To.Parsetree.Pstr_recmodule (List.map copy_module_binding x0)\n | From.Parsetree.Pstr_modtype x0 ->\n To.Parsetree.Pstr_modtype (copy_module_type_declaration x0)\n | From.Parsetree.Pstr_open x0 ->\n To.Parsetree.Pstr_open (copy_open_description x0)\n | From.Parsetree.Pstr_class x0 ->\n To.Parsetree.Pstr_class (List.map copy_class_declaration x0)\n | From.Parsetree.Pstr_class_type x0 ->\n To.Parsetree.Pstr_class_type (List.map copy_class_type_declaration x0)\n | From.Parsetree.Pstr_include x0 ->\n To.Parsetree.Pstr_include (copy_include_declaration x0)\n | From.Parsetree.Pstr_attribute x0 ->\n To.Parsetree.Pstr_attribute (copy_attribute x0)\n | From.Parsetree.Pstr_extension (x0, x1) ->\n To.Parsetree.Pstr_extension (copy_extension x0, copy_attributes x1)\n\nand copy_include_declaration :\n From.Parsetree.include_declaration -> To.Parsetree.include_declaration =\n fun x -> copy_include_infos copy_module_expr x\n\nand copy_class_declaration :\n From.Parsetree.class_declaration -> To.Parsetree.class_declaration =\n fun x -> copy_class_infos copy_class_expr x\n\nand copy_class_expr : From.Parsetree.class_expr -> To.Parsetree.class_expr =\n fun {\n From.Parsetree.pcl_desc;\n From.Parsetree.pcl_loc;\n From.Parsetree.pcl_attributes;\n } ->\n {\n To.Parsetree.pcl_desc = copy_class_expr_desc pcl_desc;\n To.Parsetree.pcl_loc = copy_location pcl_loc;\n To.Parsetree.pcl_attributes = copy_attributes pcl_attributes;\n }\n\nand copy_class_expr_desc :\n From.Parsetree.class_expr_desc -> To.Parsetree.class_expr_desc = function\n | From.Parsetree.Pcl_constr (x0, x1) ->\n To.Parsetree.Pcl_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Pcl_structure x0 ->\n To.Parsetree.Pcl_structure (copy_class_structure x0)\n | From.Parsetree.Pcl_fun (x0, x1, x2, x3) ->\n To.Parsetree.Pcl_fun\n ( copy_arg_label x0,\n copy_option copy_expression x1,\n copy_pattern x2,\n copy_class_expr x3 )\n | From.Parsetree.Pcl_apply (x0, x1) ->\n To.Parsetree.Pcl_apply\n ( copy_class_expr x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | From.Parsetree.Pcl_let (x0, x1, x2) ->\n To.Parsetree.Pcl_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_class_expr x2)\n | From.Parsetree.Pcl_constraint (x0, x1) ->\n To.Parsetree.Pcl_constraint (copy_class_expr x0, copy_class_type x1)\n | From.Parsetree.Pcl_extension x0 ->\n To.Parsetree.Pcl_extension (copy_extension x0)\n | From.Parsetree.Pcl_open (ovf, loc, ce) ->\n To.Parsetree.Pcl_open\n (copy_override_flag ovf, copy_loc copy_longident loc, copy_class_expr ce)\n\nand copy_class_structure :\n From.Parsetree.class_structure -> To.Parsetree.class_structure =\n fun { From.Parsetree.pcstr_self; From.Parsetree.pcstr_fields } ->\n {\n To.Parsetree.pcstr_self = copy_pattern pcstr_self;\n To.Parsetree.pcstr_fields = List.map copy_class_field pcstr_fields;\n }\n\nand copy_class_field : From.Parsetree.class_field -> To.Parsetree.class_field =\n fun {\n From.Parsetree.pcf_desc;\n From.Parsetree.pcf_loc;\n From.Parsetree.pcf_attributes;\n } ->\n {\n To.Parsetree.pcf_desc = copy_class_field_desc pcf_desc;\n To.Parsetree.pcf_loc = copy_location pcf_loc;\n To.Parsetree.pcf_attributes = copy_attributes pcf_attributes;\n }\n\nand copy_class_field_desc :\n From.Parsetree.class_field_desc -> To.Parsetree.class_field_desc = function\n | From.Parsetree.Pcf_inherit (x0, x1, x2) ->\n To.Parsetree.Pcf_inherit\n ( copy_override_flag x0,\n copy_class_expr x1,\n copy_option (copy_loc (fun x -> x)) x2 )\n | From.Parsetree.Pcf_val x0 ->\n To.Parsetree.Pcf_val\n (let x0, x1, x2 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_mutable_flag x1,\n copy_class_field_kind x2 ))\n | From.Parsetree.Pcf_method x0 ->\n To.Parsetree.Pcf_method\n (let x0, x1, x2 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_private_flag x1,\n copy_class_field_kind x2 ))\n | From.Parsetree.Pcf_constraint x0 ->\n To.Parsetree.Pcf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | From.Parsetree.Pcf_initializer x0 ->\n To.Parsetree.Pcf_initializer (copy_expression x0)\n | From.Parsetree.Pcf_attribute x0 ->\n To.Parsetree.Pcf_attribute (copy_attribute x0)\n | From.Parsetree.Pcf_extension x0 ->\n To.Parsetree.Pcf_extension (copy_extension x0)\n\nand copy_class_field_kind :\n From.Parsetree.class_field_kind -> To.Parsetree.class_field_kind = function\n | From.Parsetree.Cfk_virtual x0 ->\n To.Parsetree.Cfk_virtual (copy_core_type x0)\n | From.Parsetree.Cfk_concrete (x0, x1) ->\n To.Parsetree.Cfk_concrete (copy_override_flag x0, copy_expression x1)\n\nand copy_module_binding :\n From.Parsetree.module_binding -> To.Parsetree.module_binding =\n fun {\n From.Parsetree.pmb_name;\n From.Parsetree.pmb_expr;\n From.Parsetree.pmb_attributes;\n From.Parsetree.pmb_loc;\n } ->\n {\n To.Parsetree.pmb_name = copy_loc (fun x -> x) pmb_name;\n To.Parsetree.pmb_expr = copy_module_expr pmb_expr;\n To.Parsetree.pmb_attributes = copy_attributes pmb_attributes;\n To.Parsetree.pmb_loc = copy_location pmb_loc;\n }\n\nand copy_module_expr : From.Parsetree.module_expr -> To.Parsetree.module_expr =\n fun {\n From.Parsetree.pmod_desc;\n From.Parsetree.pmod_loc;\n From.Parsetree.pmod_attributes;\n } ->\n {\n To.Parsetree.pmod_desc = copy_module_expr_desc pmod_desc;\n To.Parsetree.pmod_loc = copy_location pmod_loc;\n To.Parsetree.pmod_attributes = copy_attributes pmod_attributes;\n }\n\nand copy_module_expr_desc :\n From.Parsetree.module_expr_desc -> To.Parsetree.module_expr_desc = function\n | From.Parsetree.Pmod_ident x0 ->\n To.Parsetree.Pmod_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pmod_structure x0 ->\n To.Parsetree.Pmod_structure (copy_structure x0)\n | From.Parsetree.Pmod_functor (x0, x1, x2) ->\n To.Parsetree.Pmod_functor\n ( copy_loc (fun x -> x) x0,\n copy_option copy_module_type x1,\n copy_module_expr x2 )\n | From.Parsetree.Pmod_apply (x0, x1) ->\n To.Parsetree.Pmod_apply (copy_module_expr x0, copy_module_expr x1)\n | From.Parsetree.Pmod_constraint (x0, x1) ->\n To.Parsetree.Pmod_constraint (copy_module_expr x0, copy_module_type x1)\n | From.Parsetree.Pmod_unpack x0 ->\n To.Parsetree.Pmod_unpack (copy_expression x0)\n | From.Parsetree.Pmod_extension x0 ->\n To.Parsetree.Pmod_extension (copy_extension x0)\n\nand copy_module_type : From.Parsetree.module_type -> To.Parsetree.module_type =\n fun {\n From.Parsetree.pmty_desc;\n From.Parsetree.pmty_loc;\n From.Parsetree.pmty_attributes;\n } ->\n {\n To.Parsetree.pmty_desc = copy_module_type_desc pmty_desc;\n To.Parsetree.pmty_loc = copy_location pmty_loc;\n To.Parsetree.pmty_attributes = copy_attributes pmty_attributes;\n }\n\nand copy_module_type_desc :\n From.Parsetree.module_type_desc -> To.Parsetree.module_type_desc = function\n | From.Parsetree.Pmty_ident x0 ->\n To.Parsetree.Pmty_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pmty_signature x0 ->\n To.Parsetree.Pmty_signature (copy_signature x0)\n | From.Parsetree.Pmty_functor (x0, x1, x2) ->\n To.Parsetree.Pmty_functor\n ( copy_loc (fun x -> x) x0,\n copy_option copy_module_type x1,\n copy_module_type x2 )\n | From.Parsetree.Pmty_with (x0, x1) ->\n To.Parsetree.Pmty_with\n (copy_module_type x0, List.map copy_with_constraint x1)\n | From.Parsetree.Pmty_typeof x0 ->\n To.Parsetree.Pmty_typeof (copy_module_expr x0)\n | From.Parsetree.Pmty_extension x0 ->\n To.Parsetree.Pmty_extension (copy_extension x0)\n | From.Parsetree.Pmty_alias x0 ->\n To.Parsetree.Pmty_alias (copy_loc copy_longident x0)\n\nand copy_with_constraint :\n From.Parsetree.with_constraint -> To.Parsetree.with_constraint = function\n | From.Parsetree.Pwith_type (x0, x1) ->\n To.Parsetree.Pwith_type\n (copy_loc copy_longident x0, copy_type_declaration x1)\n | From.Parsetree.Pwith_module (x0, x1) ->\n To.Parsetree.Pwith_module\n (copy_loc copy_longident x0, copy_loc copy_longident x1)\n | From.Parsetree.Pwith_typesubst (x0, x1) ->\n To.Parsetree.Pwith_typesubst\n (copy_loc copy_longident x0, copy_type_declaration x1)\n | From.Parsetree.Pwith_modsubst (x0, x1) ->\n To.Parsetree.Pwith_modsubst\n (copy_loc copy_longident x0, copy_loc copy_longident x1)\n\nand copy_signature : From.Parsetree.signature -> To.Parsetree.signature =\n fun x -> List.map copy_signature_item x\n\nand copy_signature_item :\n From.Parsetree.signature_item -> To.Parsetree.signature_item =\n fun { From.Parsetree.psig_desc; From.Parsetree.psig_loc } ->\n {\n To.Parsetree.psig_desc = copy_signature_item_desc psig_desc;\n To.Parsetree.psig_loc = copy_location psig_loc;\n }\n\nand copy_signature_item_desc :\n From.Parsetree.signature_item_desc -> To.Parsetree.signature_item_desc =\n function\n | From.Parsetree.Psig_value x0 ->\n To.Parsetree.Psig_value (copy_value_description x0)\n | From.Parsetree.Psig_type (x0, x1) ->\n To.Parsetree.Psig_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | From.Parsetree.Psig_typext x0 ->\n To.Parsetree.Psig_typext (copy_type_extension x0)\n | From.Parsetree.Psig_exception x0 ->\n To.Parsetree.Psig_exception (copy_extension_constructor x0)\n | From.Parsetree.Psig_module x0 ->\n To.Parsetree.Psig_module (copy_module_declaration x0)\n | From.Parsetree.Psig_recmodule x0 ->\n To.Parsetree.Psig_recmodule (List.map copy_module_declaration x0)\n | From.Parsetree.Psig_modtype x0 ->\n To.Parsetree.Psig_modtype (copy_module_type_declaration x0)\n | From.Parsetree.Psig_open x0 ->\n To.Parsetree.Psig_open (copy_open_description x0)\n | From.Parsetree.Psig_include x0 ->\n To.Parsetree.Psig_include (copy_include_description x0)\n | From.Parsetree.Psig_class x0 ->\n To.Parsetree.Psig_class (List.map copy_class_description x0)\n | From.Parsetree.Psig_class_type x0 ->\n To.Parsetree.Psig_class_type (List.map copy_class_type_declaration x0)\n | From.Parsetree.Psig_attribute x0 ->\n To.Parsetree.Psig_attribute (copy_attribute x0)\n | From.Parsetree.Psig_extension (x0, x1) ->\n To.Parsetree.Psig_extension (copy_extension x0, copy_attributes x1)\n\nand copy_class_type_declaration :\n From.Parsetree.class_type_declaration -> To.Parsetree.class_type_declaration\n =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_description :\n From.Parsetree.class_description -> To.Parsetree.class_description =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_type : From.Parsetree.class_type -> To.Parsetree.class_type =\n fun {\n From.Parsetree.pcty_desc;\n From.Parsetree.pcty_loc;\n From.Parsetree.pcty_attributes;\n } ->\n {\n To.Parsetree.pcty_desc = copy_class_type_desc pcty_desc;\n To.Parsetree.pcty_loc = copy_location pcty_loc;\n To.Parsetree.pcty_attributes = copy_attributes pcty_attributes;\n }\n\nand copy_class_type_desc :\n From.Parsetree.class_type_desc -> To.Parsetree.class_type_desc = function\n | From.Parsetree.Pcty_constr (x0, x1) ->\n To.Parsetree.Pcty_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Pcty_signature x0 ->\n To.Parsetree.Pcty_signature (copy_class_signature x0)\n | From.Parsetree.Pcty_arrow (x0, x1, x2) ->\n To.Parsetree.Pcty_arrow\n (copy_arg_label x0, copy_core_type x1, copy_class_type x2)\n | From.Parsetree.Pcty_extension x0 ->\n To.Parsetree.Pcty_extension (copy_extension x0)\n | From.Parsetree.Pcty_open (ovf, loc, cty) ->\n To.Parsetree.Pcty_open\n ( copy_override_flag ovf,\n copy_loc copy_longident loc,\n copy_class_type cty )\n\nand copy_class_signature :\n From.Parsetree.class_signature -> To.Parsetree.class_signature =\n fun { From.Parsetree.pcsig_self; From.Parsetree.pcsig_fields } ->\n {\n To.Parsetree.pcsig_self = copy_core_type pcsig_self;\n To.Parsetree.pcsig_fields = List.map copy_class_type_field pcsig_fields;\n }\n\nand copy_class_type_field :\n From.Parsetree.class_type_field -> To.Parsetree.class_type_field =\n fun {\n From.Parsetree.pctf_desc;\n From.Parsetree.pctf_loc;\n From.Parsetree.pctf_attributes;\n } ->\n {\n To.Parsetree.pctf_desc = copy_class_type_field_desc pctf_desc;\n To.Parsetree.pctf_loc = copy_location pctf_loc;\n To.Parsetree.pctf_attributes = copy_attributes pctf_attributes;\n }\n\nand copy_class_type_field_desc :\n From.Parsetree.class_type_field_desc -> To.Parsetree.class_type_field_desc =\n function\n | From.Parsetree.Pctf_inherit x0 ->\n To.Parsetree.Pctf_inherit (copy_class_type x0)\n | From.Parsetree.Pctf_val x0 ->\n To.Parsetree.Pctf_val\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_mutable_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | From.Parsetree.Pctf_method x0 ->\n To.Parsetree.Pctf_method\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_private_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | From.Parsetree.Pctf_constraint x0 ->\n To.Parsetree.Pctf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | From.Parsetree.Pctf_attribute x0 ->\n To.Parsetree.Pctf_attribute (copy_attribute x0)\n | From.Parsetree.Pctf_extension x0 ->\n To.Parsetree.Pctf_extension (copy_extension x0)\n\nand copy_extension : From.Parsetree.extension -> To.Parsetree.extension =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_class_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 From.Parsetree.class_infos ->\n 'g0 To.Parsetree.class_infos =\n fun f0\n {\n From.Parsetree.pci_virt;\n From.Parsetree.pci_params;\n From.Parsetree.pci_name;\n From.Parsetree.pci_expr;\n From.Parsetree.pci_loc;\n From.Parsetree.pci_attributes;\n } ->\n {\n To.Parsetree.pci_virt = copy_virtual_flag pci_virt;\n To.Parsetree.pci_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n pci_params;\n To.Parsetree.pci_name = copy_loc (fun x -> x) pci_name;\n To.Parsetree.pci_expr = f0 pci_expr;\n To.Parsetree.pci_loc = copy_location pci_loc;\n To.Parsetree.pci_attributes = copy_attributes pci_attributes;\n }\n\nand copy_virtual_flag : From.Asttypes.virtual_flag -> To.Asttypes.virtual_flag =\n function\n | From.Asttypes.Virtual -> To.Asttypes.Virtual\n | From.Asttypes.Concrete -> To.Asttypes.Concrete\n\nand copy_include_description :\n From.Parsetree.include_description -> To.Parsetree.include_description =\n fun x -> copy_include_infos copy_module_type x\n\nand copy_include_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 From.Parsetree.include_infos ->\n 'g0 To.Parsetree.include_infos =\n fun f0\n {\n From.Parsetree.pincl_mod;\n From.Parsetree.pincl_loc;\n From.Parsetree.pincl_attributes;\n } ->\n {\n To.Parsetree.pincl_mod = f0 pincl_mod;\n To.Parsetree.pincl_loc = copy_location pincl_loc;\n To.Parsetree.pincl_attributes = copy_attributes pincl_attributes;\n }\n\nand copy_open_description :\n From.Parsetree.open_description -> To.Parsetree.open_description =\n fun {\n From.Parsetree.popen_lid;\n From.Parsetree.popen_override;\n From.Parsetree.popen_loc;\n From.Parsetree.popen_attributes;\n } ->\n {\n To.Parsetree.popen_lid = copy_loc copy_longident popen_lid;\n To.Parsetree.popen_override = copy_override_flag popen_override;\n To.Parsetree.popen_loc = copy_location popen_loc;\n To.Parsetree.popen_attributes = copy_attributes popen_attributes;\n }\n\nand copy_override_flag :\n From.Asttypes.override_flag -> To.Asttypes.override_flag = function\n | From.Asttypes.Override -> To.Asttypes.Override\n | From.Asttypes.Fresh -> To.Asttypes.Fresh\n\nand copy_module_type_declaration :\n From.Parsetree.module_type_declaration ->\n To.Parsetree.module_type_declaration =\n fun {\n From.Parsetree.pmtd_name;\n From.Parsetree.pmtd_type;\n From.Parsetree.pmtd_attributes;\n From.Parsetree.pmtd_loc;\n } ->\n {\n To.Parsetree.pmtd_name = copy_loc (fun x -> x) pmtd_name;\n To.Parsetree.pmtd_type = copy_option copy_module_type pmtd_type;\n To.Parsetree.pmtd_attributes = copy_attributes pmtd_attributes;\n To.Parsetree.pmtd_loc = copy_location pmtd_loc;\n }\n\nand copy_module_declaration :\n From.Parsetree.module_declaration -> To.Parsetree.module_declaration =\n fun {\n From.Parsetree.pmd_name;\n From.Parsetree.pmd_type;\n From.Parsetree.pmd_attributes;\n From.Parsetree.pmd_loc;\n } ->\n {\n To.Parsetree.pmd_name = copy_loc (fun x -> x) pmd_name;\n To.Parsetree.pmd_type = copy_module_type pmd_type;\n To.Parsetree.pmd_attributes = copy_attributes pmd_attributes;\n To.Parsetree.pmd_loc = copy_location pmd_loc;\n }\n\nand copy_type_extension :\n From.Parsetree.type_extension -> To.Parsetree.type_extension =\n fun {\n From.Parsetree.ptyext_path;\n From.Parsetree.ptyext_params;\n From.Parsetree.ptyext_constructors;\n From.Parsetree.ptyext_private;\n From.Parsetree.ptyext_attributes;\n } ->\n {\n To.Parsetree.ptyext_path = copy_loc copy_longident ptyext_path;\n To.Parsetree.ptyext_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptyext_params;\n To.Parsetree.ptyext_constructors =\n List.map copy_extension_constructor ptyext_constructors;\n To.Parsetree.ptyext_private = copy_private_flag ptyext_private;\n To.Parsetree.ptyext_attributes = copy_attributes ptyext_attributes;\n }\n\nand copy_extension_constructor :\n From.Parsetree.extension_constructor -> To.Parsetree.extension_constructor =\n fun {\n From.Parsetree.pext_name;\n From.Parsetree.pext_kind;\n From.Parsetree.pext_loc;\n From.Parsetree.pext_attributes;\n } ->\n {\n To.Parsetree.pext_name = copy_loc (fun x -> x) pext_name;\n To.Parsetree.pext_kind = copy_extension_constructor_kind pext_kind;\n To.Parsetree.pext_loc = copy_location pext_loc;\n To.Parsetree.pext_attributes = copy_attributes pext_attributes;\n }\n\nand copy_extension_constructor_kind :\n From.Parsetree.extension_constructor_kind ->\n To.Parsetree.extension_constructor_kind = function\n | From.Parsetree.Pext_decl (x0, x1) ->\n To.Parsetree.Pext_decl\n (copy_constructor_arguments x0, copy_option copy_core_type x1)\n | From.Parsetree.Pext_rebind x0 ->\n To.Parsetree.Pext_rebind (copy_loc copy_longident x0)\n\nand copy_type_declaration :\n From.Parsetree.type_declaration -> To.Parsetree.type_declaration =\n fun {\n From.Parsetree.ptype_name;\n From.Parsetree.ptype_params;\n From.Parsetree.ptype_cstrs;\n From.Parsetree.ptype_kind;\n From.Parsetree.ptype_private;\n From.Parsetree.ptype_manifest;\n From.Parsetree.ptype_attributes;\n From.Parsetree.ptype_loc;\n } ->\n {\n To.Parsetree.ptype_name = copy_loc (fun x -> x) ptype_name;\n To.Parsetree.ptype_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptype_params;\n To.Parsetree.ptype_cstrs =\n List.map\n (fun x ->\n let x0, x1, x2 = x in\n (copy_core_type x0, copy_core_type x1, copy_location x2))\n ptype_cstrs;\n To.Parsetree.ptype_kind = copy_type_kind ptype_kind;\n To.Parsetree.ptype_private = copy_private_flag ptype_private;\n To.Parsetree.ptype_manifest = copy_option copy_core_type ptype_manifest;\n To.Parsetree.ptype_attributes = copy_attributes ptype_attributes;\n To.Parsetree.ptype_loc = copy_location ptype_loc;\n }\n\nand copy_private_flag : From.Asttypes.private_flag -> To.Asttypes.private_flag =\n function\n | From.Asttypes.Private -> To.Asttypes.Private\n | From.Asttypes.Public -> To.Asttypes.Public\n\nand copy_type_kind : From.Parsetree.type_kind -> To.Parsetree.type_kind =\n function\n | From.Parsetree.Ptype_abstract -> To.Parsetree.Ptype_abstract\n | From.Parsetree.Ptype_variant x0 ->\n To.Parsetree.Ptype_variant (List.map copy_constructor_declaration x0)\n | From.Parsetree.Ptype_record x0 ->\n To.Parsetree.Ptype_record (List.map copy_label_declaration x0)\n | From.Parsetree.Ptype_open -> To.Parsetree.Ptype_open\n\nand copy_constructor_declaration :\n From.Parsetree.constructor_declaration ->\n To.Parsetree.constructor_declaration =\n fun {\n From.Parsetree.pcd_name;\n From.Parsetree.pcd_args;\n From.Parsetree.pcd_res;\n From.Parsetree.pcd_loc;\n From.Parsetree.pcd_attributes;\n } ->\n {\n To.Parsetree.pcd_name = copy_loc (fun x -> x) pcd_name;\n To.Parsetree.pcd_args = copy_constructor_arguments pcd_args;\n To.Parsetree.pcd_res = copy_option copy_core_type pcd_res;\n To.Parsetree.pcd_loc = copy_location pcd_loc;\n To.Parsetree.pcd_attributes = copy_attributes pcd_attributes;\n }\n\nand copy_constructor_arguments :\n From.Parsetree.constructor_arguments -> To.Parsetree.constructor_arguments =\n function\n | From.Parsetree.Pcstr_tuple x0 ->\n To.Parsetree.Pcstr_tuple (List.map copy_core_type x0)\n | From.Parsetree.Pcstr_record x0 ->\n To.Parsetree.Pcstr_record (List.map copy_label_declaration x0)\n\nand copy_label_declaration :\n From.Parsetree.label_declaration -> To.Parsetree.label_declaration =\n fun {\n From.Parsetree.pld_name;\n From.Parsetree.pld_mutable;\n From.Parsetree.pld_type;\n From.Parsetree.pld_loc;\n From.Parsetree.pld_attributes;\n } ->\n {\n To.Parsetree.pld_name = copy_loc (fun x -> x) pld_name;\n To.Parsetree.pld_mutable = copy_mutable_flag pld_mutable;\n To.Parsetree.pld_type = copy_core_type pld_type;\n To.Parsetree.pld_loc = copy_location pld_loc;\n To.Parsetree.pld_attributes = copy_attributes pld_attributes;\n }\n\nand copy_mutable_flag : From.Asttypes.mutable_flag -> To.Asttypes.mutable_flag =\n function\n | From.Asttypes.Immutable -> To.Asttypes.Immutable\n | From.Asttypes.Mutable -> To.Asttypes.Mutable\n\nand copy_variance : From.Asttypes.variance -> To.Asttypes.variance = function\n | From.Asttypes.Covariant -> To.Asttypes.Covariant\n | From.Asttypes.Contravariant -> To.Asttypes.Contravariant\n | From.Asttypes.Invariant -> To.Asttypes.Invariant\n\nand copy_value_description :\n From.Parsetree.value_description -> To.Parsetree.value_description =\n fun {\n From.Parsetree.pval_name;\n From.Parsetree.pval_type;\n From.Parsetree.pval_prim;\n From.Parsetree.pval_attributes;\n From.Parsetree.pval_loc;\n } ->\n {\n To.Parsetree.pval_name = copy_loc (fun x -> x) pval_name;\n To.Parsetree.pval_type = copy_core_type pval_type;\n To.Parsetree.pval_prim = List.map (fun x -> x) pval_prim;\n To.Parsetree.pval_attributes = copy_attributes pval_attributes;\n To.Parsetree.pval_loc = copy_location pval_loc;\n }\n\nand copy_arg_label : From.Asttypes.arg_label -> To.Asttypes.arg_label = function\n | From.Asttypes.Nolabel -> To.Asttypes.Nolabel\n | From.Asttypes.Labelled x0 -> To.Asttypes.Labelled x0\n | From.Asttypes.Optional x0 -> To.Asttypes.Optional x0\n\nand copy_closed_flag : From.Asttypes.closed_flag -> To.Asttypes.closed_flag =\n function\n | From.Asttypes.Closed -> To.Asttypes.Closed\n | From.Asttypes.Open -> To.Asttypes.Open\n\nand copy_label : From.Asttypes.label -> To.Asttypes.label = fun x -> x\n\nand copy_rec_flag : From.Asttypes.rec_flag -> To.Asttypes.rec_flag = function\n | From.Asttypes.Nonrecursive -> To.Asttypes.Nonrecursive\n | From.Asttypes.Recursive -> To.Asttypes.Recursive\n\nand copy_constant : From.Parsetree.constant -> To.Parsetree.constant = function\n | From.Parsetree.Pconst_integer (x0, x1) ->\n To.Parsetree.Pconst_integer (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pconst_char x0 -> To.Parsetree.Pconst_char x0\n | From.Parsetree.Pconst_string (x0, x1) ->\n To.Parsetree.Pconst_string (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pconst_float (x0, x1) ->\n To.Parsetree.Pconst_float (x0, copy_option (fun x -> x) x1)\n\nand copy_option : 'f0 'g0. ('f0 -> 'g0) -> 'f0 option -> 'g0 option =\n fun f0 -> function None -> None | Some x0 -> Some (f0 x0)\n\nand copy_longident : Longident.t -> Longident.t = fun x -> x\n\nand copy_loc :\n 'f0 'g0. ('f0 -> 'g0) -> 'f0 From.Asttypes.loc -> 'g0 To.Asttypes.loc =\n fun f0 { From.Asttypes.txt; From.Asttypes.loc } ->\n { To.Asttypes.txt = f0 txt; To.Asttypes.loc = copy_location loc }\n\nand copy_location : Location.t -> Location.t = fun x -> x\nand copy_bool : bool -> bool = function false -> false | true -> true\n\nlet rec copy_toplevel_phrase :\n From.Parsetree.toplevel_phrase -> To.Parsetree.toplevel_phrase = function\n | From.Parsetree.Ptop_def x0 -> To.Parsetree.Ptop_def (copy_structure x0)\n | From.Parsetree.Ptop_dir (x0, x1) ->\n To.Parsetree.Ptop_dir (x0, copy_directive_argument x1)\n\nand copy_directive_argument :\n From.Parsetree.directive_argument -> To.Parsetree.directive_argument =\n function\n | From.Parsetree.Pdir_none -> To.Parsetree.Pdir_none\n | From.Parsetree.Pdir_string x0 -> To.Parsetree.Pdir_string x0\n | From.Parsetree.Pdir_int (x0, x1) ->\n To.Parsetree.Pdir_int (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pdir_ident x0 -> To.Parsetree.Pdir_ident (copy_longident x0)\n | From.Parsetree.Pdir_bool x0 -> To.Parsetree.Pdir_bool (copy_bool x0)\n\nlet copy_cases x = List.map copy_case x\nlet copy_pat = copy_pattern\nlet copy_expr = copy_expression\nlet copy_typ = copy_core_type\n","(**************************************************************************)\n(* *)\n(* OCaml Migrate Parsetree *)\n(* *)\n(* Frédéric Bour *)\n(* Alain Frisch, LexiFi *)\n(* *)\n(* Copyright 2017 Institut National de Recherche en Informatique et *)\n(* en Automatique (INRIA). *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nmodule From = Ast_406\nmodule To = Ast_407\n\nlet rec copy_expression : From.Parsetree.expression -> To.Parsetree.expression =\n fun {\n From.Parsetree.pexp_desc;\n From.Parsetree.pexp_loc;\n From.Parsetree.pexp_attributes;\n } ->\n {\n To.Parsetree.pexp_desc = copy_expression_desc pexp_desc;\n To.Parsetree.pexp_loc = copy_location pexp_loc;\n To.Parsetree.pexp_attributes = copy_attributes pexp_attributes;\n }\n\nand copy_expression_desc :\n From.Parsetree.expression_desc -> To.Parsetree.expression_desc = function\n | From.Parsetree.Pexp_ident x0 ->\n To.Parsetree.Pexp_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pexp_constant x0 ->\n To.Parsetree.Pexp_constant (copy_constant x0)\n | From.Parsetree.Pexp_let (x0, x1, x2) ->\n To.Parsetree.Pexp_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_expression x2)\n | From.Parsetree.Pexp_function x0 ->\n To.Parsetree.Pexp_function (List.map copy_case x0)\n | From.Parsetree.Pexp_fun (x0, x1, x2, x3) ->\n To.Parsetree.Pexp_fun\n ( copy_arg_label x0,\n copy_option copy_expression x1,\n copy_pattern x2,\n copy_expression x3 )\n | From.Parsetree.Pexp_apply (x0, x1) ->\n To.Parsetree.Pexp_apply\n ( copy_expression x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | From.Parsetree.Pexp_match (x0, x1) ->\n To.Parsetree.Pexp_match (copy_expression x0, List.map copy_case x1)\n | From.Parsetree.Pexp_try (x0, x1) ->\n To.Parsetree.Pexp_try (copy_expression x0, List.map copy_case x1)\n | From.Parsetree.Pexp_tuple x0 ->\n To.Parsetree.Pexp_tuple (List.map copy_expression x0)\n | From.Parsetree.Pexp_construct (x0, x1) ->\n To.Parsetree.Pexp_construct\n (copy_loc copy_longident x0, copy_option copy_expression x1)\n | From.Parsetree.Pexp_variant (x0, x1) ->\n To.Parsetree.Pexp_variant (copy_label x0, copy_option copy_expression x1)\n | From.Parsetree.Pexp_record (x0, x1) ->\n To.Parsetree.Pexp_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_expression x1))\n x0,\n copy_option copy_expression x1 )\n | From.Parsetree.Pexp_field (x0, x1) ->\n To.Parsetree.Pexp_field (copy_expression x0, copy_loc copy_longident x1)\n | From.Parsetree.Pexp_setfield (x0, x1, x2) ->\n To.Parsetree.Pexp_setfield\n (copy_expression x0, copy_loc copy_longident x1, copy_expression x2)\n | From.Parsetree.Pexp_array x0 ->\n To.Parsetree.Pexp_array (List.map copy_expression x0)\n | From.Parsetree.Pexp_ifthenelse (x0, x1, x2) ->\n To.Parsetree.Pexp_ifthenelse\n (copy_expression x0, copy_expression x1, copy_option copy_expression x2)\n | From.Parsetree.Pexp_sequence (x0, x1) ->\n To.Parsetree.Pexp_sequence (copy_expression x0, copy_expression x1)\n | From.Parsetree.Pexp_while (x0, x1) ->\n To.Parsetree.Pexp_while (copy_expression x0, copy_expression x1)\n | From.Parsetree.Pexp_for (x0, x1, x2, x3, x4) ->\n To.Parsetree.Pexp_for\n ( copy_pattern x0,\n copy_expression x1,\n copy_expression x2,\n copy_direction_flag x3,\n copy_expression x4 )\n | From.Parsetree.Pexp_constraint (x0, x1) ->\n To.Parsetree.Pexp_constraint (copy_expression x0, copy_core_type x1)\n | From.Parsetree.Pexp_coerce (x0, x1, x2) ->\n To.Parsetree.Pexp_coerce\n (copy_expression x0, copy_option copy_core_type x1, copy_core_type x2)\n | From.Parsetree.Pexp_send (x0, x1) ->\n To.Parsetree.Pexp_send (copy_expression x0, copy_loc (fun x -> x) x1)\n | From.Parsetree.Pexp_new x0 ->\n To.Parsetree.Pexp_new (copy_loc copy_longident x0)\n | From.Parsetree.Pexp_setinstvar (x0, x1) ->\n To.Parsetree.Pexp_setinstvar (copy_loc (fun x -> x) x0, copy_expression x1)\n | From.Parsetree.Pexp_override x0 ->\n To.Parsetree.Pexp_override\n (List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_expression x1))\n x0)\n | From.Parsetree.Pexp_letmodule (x0, x1, x2) ->\n To.Parsetree.Pexp_letmodule\n (copy_loc (fun x -> x) x0, copy_module_expr x1, copy_expression x2)\n | From.Parsetree.Pexp_letexception (x0, x1) ->\n To.Parsetree.Pexp_letexception\n (copy_extension_constructor x0, copy_expression x1)\n | From.Parsetree.Pexp_assert x0 ->\n To.Parsetree.Pexp_assert (copy_expression x0)\n | From.Parsetree.Pexp_lazy x0 -> To.Parsetree.Pexp_lazy (copy_expression x0)\n | From.Parsetree.Pexp_poly (x0, x1) ->\n To.Parsetree.Pexp_poly (copy_expression x0, copy_option copy_core_type x1)\n | From.Parsetree.Pexp_object x0 ->\n To.Parsetree.Pexp_object (copy_class_structure x0)\n | From.Parsetree.Pexp_newtype (x0, x1) ->\n To.Parsetree.Pexp_newtype (copy_loc (fun x -> x) x0, copy_expression x1)\n | From.Parsetree.Pexp_pack x0 -> To.Parsetree.Pexp_pack (copy_module_expr x0)\n | From.Parsetree.Pexp_open (x0, x1, x2) ->\n To.Parsetree.Pexp_open\n (copy_override_flag x0, copy_loc copy_longident x1, copy_expression x2)\n | From.Parsetree.Pexp_extension x0 ->\n To.Parsetree.Pexp_extension (copy_extension x0)\n | From.Parsetree.Pexp_unreachable -> To.Parsetree.Pexp_unreachable\n\nand copy_direction_flag :\n From.Asttypes.direction_flag -> To.Asttypes.direction_flag = function\n | From.Asttypes.Upto -> To.Asttypes.Upto\n | From.Asttypes.Downto -> To.Asttypes.Downto\n\nand copy_case : From.Parsetree.case -> To.Parsetree.case =\n fun { From.Parsetree.pc_lhs; From.Parsetree.pc_guard; From.Parsetree.pc_rhs } ->\n {\n To.Parsetree.pc_lhs = copy_pattern pc_lhs;\n To.Parsetree.pc_guard = copy_option copy_expression pc_guard;\n To.Parsetree.pc_rhs = copy_expression pc_rhs;\n }\n\nand copy_value_binding :\n From.Parsetree.value_binding -> To.Parsetree.value_binding =\n fun {\n From.Parsetree.pvb_pat;\n From.Parsetree.pvb_expr;\n From.Parsetree.pvb_attributes;\n From.Parsetree.pvb_loc;\n } ->\n {\n To.Parsetree.pvb_pat = copy_pattern pvb_pat;\n To.Parsetree.pvb_expr = copy_expression pvb_expr;\n To.Parsetree.pvb_attributes = copy_attributes pvb_attributes;\n To.Parsetree.pvb_loc = copy_location pvb_loc;\n }\n\nand copy_pattern : From.Parsetree.pattern -> To.Parsetree.pattern =\n fun {\n From.Parsetree.ppat_desc;\n From.Parsetree.ppat_loc;\n From.Parsetree.ppat_attributes;\n } ->\n {\n To.Parsetree.ppat_desc = copy_pattern_desc ppat_desc;\n To.Parsetree.ppat_loc = copy_location ppat_loc;\n To.Parsetree.ppat_attributes = copy_attributes ppat_attributes;\n }\n\nand copy_pattern_desc : From.Parsetree.pattern_desc -> To.Parsetree.pattern_desc\n = function\n | From.Parsetree.Ppat_any -> To.Parsetree.Ppat_any\n | From.Parsetree.Ppat_var x0 ->\n To.Parsetree.Ppat_var (copy_loc (fun x -> x) x0)\n | From.Parsetree.Ppat_alias (x0, x1) ->\n To.Parsetree.Ppat_alias (copy_pattern x0, copy_loc (fun x -> x) x1)\n | From.Parsetree.Ppat_constant x0 ->\n To.Parsetree.Ppat_constant (copy_constant x0)\n | From.Parsetree.Ppat_interval (x0, x1) ->\n To.Parsetree.Ppat_interval (copy_constant x0, copy_constant x1)\n | From.Parsetree.Ppat_tuple x0 ->\n To.Parsetree.Ppat_tuple (List.map copy_pattern x0)\n | From.Parsetree.Ppat_construct (x0, x1) ->\n To.Parsetree.Ppat_construct\n (copy_loc copy_longident x0, copy_option copy_pattern x1)\n | From.Parsetree.Ppat_variant (x0, x1) ->\n To.Parsetree.Ppat_variant (copy_label x0, copy_option copy_pattern x1)\n | From.Parsetree.Ppat_record (x0, x1) ->\n To.Parsetree.Ppat_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_pattern x1))\n x0,\n copy_closed_flag x1 )\n | From.Parsetree.Ppat_array x0 ->\n To.Parsetree.Ppat_array (List.map copy_pattern x0)\n | From.Parsetree.Ppat_or (x0, x1) ->\n To.Parsetree.Ppat_or (copy_pattern x0, copy_pattern x1)\n | From.Parsetree.Ppat_constraint (x0, x1) ->\n To.Parsetree.Ppat_constraint (copy_pattern x0, copy_core_type x1)\n | From.Parsetree.Ppat_type x0 ->\n To.Parsetree.Ppat_type (copy_loc copy_longident x0)\n | From.Parsetree.Ppat_lazy x0 -> To.Parsetree.Ppat_lazy (copy_pattern x0)\n | From.Parsetree.Ppat_unpack x0 ->\n To.Parsetree.Ppat_unpack (copy_loc (fun x -> x) x0)\n | From.Parsetree.Ppat_exception x0 ->\n To.Parsetree.Ppat_exception (copy_pattern x0)\n | From.Parsetree.Ppat_extension x0 ->\n To.Parsetree.Ppat_extension (copy_extension x0)\n | From.Parsetree.Ppat_open (x0, x1) ->\n To.Parsetree.Ppat_open (copy_loc copy_longident x0, copy_pattern x1)\n\nand copy_core_type : From.Parsetree.core_type -> To.Parsetree.core_type =\n fun {\n From.Parsetree.ptyp_desc;\n From.Parsetree.ptyp_loc;\n From.Parsetree.ptyp_attributes;\n } ->\n {\n To.Parsetree.ptyp_desc = copy_core_type_desc ptyp_desc;\n To.Parsetree.ptyp_loc = copy_location ptyp_loc;\n To.Parsetree.ptyp_attributes = copy_attributes ptyp_attributes;\n }\n\nand copy_core_type_desc :\n From.Parsetree.core_type_desc -> To.Parsetree.core_type_desc = function\n | From.Parsetree.Ptyp_any -> To.Parsetree.Ptyp_any\n | From.Parsetree.Ptyp_var x0 -> To.Parsetree.Ptyp_var x0\n | From.Parsetree.Ptyp_arrow (x0, x1, x2) ->\n To.Parsetree.Ptyp_arrow\n (copy_arg_label x0, copy_core_type x1, copy_core_type x2)\n | From.Parsetree.Ptyp_tuple x0 ->\n To.Parsetree.Ptyp_tuple (List.map copy_core_type x0)\n | From.Parsetree.Ptyp_constr (x0, x1) ->\n To.Parsetree.Ptyp_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Ptyp_object (x0, x1) ->\n To.Parsetree.Ptyp_object\n (List.map copy_object_field x0, copy_closed_flag x1)\n | From.Parsetree.Ptyp_class (x0, x1) ->\n To.Parsetree.Ptyp_class\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Ptyp_alias (x0, x1) ->\n To.Parsetree.Ptyp_alias (copy_core_type x0, x1)\n | From.Parsetree.Ptyp_variant (x0, x1, x2) ->\n To.Parsetree.Ptyp_variant\n ( List.map copy_row_field x0,\n copy_closed_flag x1,\n copy_option (fun x -> List.map copy_label x) x2 )\n | From.Parsetree.Ptyp_poly (x0, x1) ->\n To.Parsetree.Ptyp_poly\n (List.map (fun x -> copy_loc (fun x -> x) x) x0, copy_core_type x1)\n | From.Parsetree.Ptyp_package x0 ->\n To.Parsetree.Ptyp_package (copy_package_type x0)\n | From.Parsetree.Ptyp_extension x0 ->\n To.Parsetree.Ptyp_extension (copy_extension x0)\n\nand copy_package_type : From.Parsetree.package_type -> To.Parsetree.package_type\n =\n fun x ->\n let x0, x1 = x in\n ( copy_loc copy_longident x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_core_type x1))\n x1 )\n\nand copy_row_field : From.Parsetree.row_field -> To.Parsetree.row_field =\n function\n | From.Parsetree.Rtag (x0, x1, x2, x3) ->\n To.Parsetree.Rtag\n ( copy_loc copy_label x0,\n copy_attributes x1,\n copy_bool x2,\n List.map copy_core_type x3 )\n | From.Parsetree.Rinherit x0 -> To.Parsetree.Rinherit (copy_core_type x0)\n\nand copy_object_field : From.Parsetree.object_field -> To.Parsetree.object_field\n = function\n | From.Parsetree.Otag (x0, x1, x2) ->\n To.Parsetree.Otag\n (copy_loc (fun x -> x) x0, copy_attributes x1, copy_core_type x2)\n | From.Parsetree.Oinherit x -> To.Parsetree.Oinherit (copy_core_type x)\n\nand copy_attributes : From.Parsetree.attributes -> To.Parsetree.attributes =\n fun x -> List.map copy_attribute x\n\nand copy_attribute : From.Parsetree.attribute -> To.Parsetree.attribute =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_payload : From.Parsetree.payload -> To.Parsetree.payload = function\n | From.Parsetree.PStr x0 -> To.Parsetree.PStr (copy_structure x0)\n | From.Parsetree.PSig x0 -> To.Parsetree.PSig (copy_signature x0)\n | From.Parsetree.PTyp x0 -> To.Parsetree.PTyp (copy_core_type x0)\n | From.Parsetree.PPat (x0, x1) ->\n To.Parsetree.PPat (copy_pattern x0, copy_option copy_expression x1)\n\nand copy_structure : From.Parsetree.structure -> To.Parsetree.structure =\n fun x -> List.map copy_structure_item x\n\nand copy_structure_item :\n From.Parsetree.structure_item -> To.Parsetree.structure_item =\n fun { From.Parsetree.pstr_desc; From.Parsetree.pstr_loc } ->\n {\n To.Parsetree.pstr_desc = copy_structure_item_desc pstr_desc;\n To.Parsetree.pstr_loc = copy_location pstr_loc;\n }\n\nand copy_structure_item_desc :\n From.Parsetree.structure_item_desc -> To.Parsetree.structure_item_desc =\n function\n | From.Parsetree.Pstr_eval (x0, x1) ->\n To.Parsetree.Pstr_eval (copy_expression x0, copy_attributes x1)\n | From.Parsetree.Pstr_value (x0, x1) ->\n To.Parsetree.Pstr_value (copy_rec_flag x0, List.map copy_value_binding x1)\n | From.Parsetree.Pstr_primitive x0 ->\n To.Parsetree.Pstr_primitive (copy_value_description x0)\n | From.Parsetree.Pstr_type (x0, x1) ->\n To.Parsetree.Pstr_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | From.Parsetree.Pstr_typext x0 ->\n To.Parsetree.Pstr_typext (copy_type_extension x0)\n | From.Parsetree.Pstr_exception x0 ->\n To.Parsetree.Pstr_exception (copy_extension_constructor x0)\n | From.Parsetree.Pstr_module x0 ->\n To.Parsetree.Pstr_module (copy_module_binding x0)\n | From.Parsetree.Pstr_recmodule x0 ->\n To.Parsetree.Pstr_recmodule (List.map copy_module_binding x0)\n | From.Parsetree.Pstr_modtype x0 ->\n To.Parsetree.Pstr_modtype (copy_module_type_declaration x0)\n | From.Parsetree.Pstr_open x0 ->\n To.Parsetree.Pstr_open (copy_open_description x0)\n | From.Parsetree.Pstr_class x0 ->\n To.Parsetree.Pstr_class (List.map copy_class_declaration x0)\n | From.Parsetree.Pstr_class_type x0 ->\n To.Parsetree.Pstr_class_type (List.map copy_class_type_declaration x0)\n | From.Parsetree.Pstr_include x0 ->\n To.Parsetree.Pstr_include (copy_include_declaration x0)\n | From.Parsetree.Pstr_attribute x0 ->\n To.Parsetree.Pstr_attribute (copy_attribute x0)\n | From.Parsetree.Pstr_extension (x0, x1) ->\n To.Parsetree.Pstr_extension (copy_extension x0, copy_attributes x1)\n\nand copy_include_declaration :\n From.Parsetree.include_declaration -> To.Parsetree.include_declaration =\n fun x -> copy_include_infos copy_module_expr x\n\nand copy_class_declaration :\n From.Parsetree.class_declaration -> To.Parsetree.class_declaration =\n fun x -> copy_class_infos copy_class_expr x\n\nand copy_class_expr : From.Parsetree.class_expr -> To.Parsetree.class_expr =\n fun {\n From.Parsetree.pcl_desc;\n From.Parsetree.pcl_loc;\n From.Parsetree.pcl_attributes;\n } ->\n {\n To.Parsetree.pcl_desc = copy_class_expr_desc pcl_desc;\n To.Parsetree.pcl_loc = copy_location pcl_loc;\n To.Parsetree.pcl_attributes = copy_attributes pcl_attributes;\n }\n\nand copy_class_expr_desc :\n From.Parsetree.class_expr_desc -> To.Parsetree.class_expr_desc = function\n | From.Parsetree.Pcl_constr (x0, x1) ->\n To.Parsetree.Pcl_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Pcl_structure x0 ->\n To.Parsetree.Pcl_structure (copy_class_structure x0)\n | From.Parsetree.Pcl_fun (x0, x1, x2, x3) ->\n To.Parsetree.Pcl_fun\n ( copy_arg_label x0,\n copy_option copy_expression x1,\n copy_pattern x2,\n copy_class_expr x3 )\n | From.Parsetree.Pcl_apply (x0, x1) ->\n To.Parsetree.Pcl_apply\n ( copy_class_expr x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | From.Parsetree.Pcl_let (x0, x1, x2) ->\n To.Parsetree.Pcl_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_class_expr x2)\n | From.Parsetree.Pcl_constraint (x0, x1) ->\n To.Parsetree.Pcl_constraint (copy_class_expr x0, copy_class_type x1)\n | From.Parsetree.Pcl_extension x0 ->\n To.Parsetree.Pcl_extension (copy_extension x0)\n | From.Parsetree.Pcl_open (ovf, loc, ce) ->\n To.Parsetree.Pcl_open\n (copy_override_flag ovf, copy_loc copy_longident loc, copy_class_expr ce)\n\nand copy_class_structure :\n From.Parsetree.class_structure -> To.Parsetree.class_structure =\n fun { From.Parsetree.pcstr_self; From.Parsetree.pcstr_fields } ->\n {\n To.Parsetree.pcstr_self = copy_pattern pcstr_self;\n To.Parsetree.pcstr_fields = List.map copy_class_field pcstr_fields;\n }\n\nand copy_class_field : From.Parsetree.class_field -> To.Parsetree.class_field =\n fun {\n From.Parsetree.pcf_desc;\n From.Parsetree.pcf_loc;\n From.Parsetree.pcf_attributes;\n } ->\n {\n To.Parsetree.pcf_desc = copy_class_field_desc pcf_desc;\n To.Parsetree.pcf_loc = copy_location pcf_loc;\n To.Parsetree.pcf_attributes = copy_attributes pcf_attributes;\n }\n\nand copy_class_field_desc :\n From.Parsetree.class_field_desc -> To.Parsetree.class_field_desc = function\n | From.Parsetree.Pcf_inherit (x0, x1, x2) ->\n To.Parsetree.Pcf_inherit\n ( copy_override_flag x0,\n copy_class_expr x1,\n copy_option (copy_loc (fun x -> x)) x2 )\n | From.Parsetree.Pcf_val x0 ->\n To.Parsetree.Pcf_val\n (let x0, x1, x2 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_mutable_flag x1,\n copy_class_field_kind x2 ))\n | From.Parsetree.Pcf_method x0 ->\n To.Parsetree.Pcf_method\n (let x0, x1, x2 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_private_flag x1,\n copy_class_field_kind x2 ))\n | From.Parsetree.Pcf_constraint x0 ->\n To.Parsetree.Pcf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | From.Parsetree.Pcf_initializer x0 ->\n To.Parsetree.Pcf_initializer (copy_expression x0)\n | From.Parsetree.Pcf_attribute x0 ->\n To.Parsetree.Pcf_attribute (copy_attribute x0)\n | From.Parsetree.Pcf_extension x0 ->\n To.Parsetree.Pcf_extension (copy_extension x0)\n\nand copy_class_field_kind :\n From.Parsetree.class_field_kind -> To.Parsetree.class_field_kind = function\n | From.Parsetree.Cfk_virtual x0 ->\n To.Parsetree.Cfk_virtual (copy_core_type x0)\n | From.Parsetree.Cfk_concrete (x0, x1) ->\n To.Parsetree.Cfk_concrete (copy_override_flag x0, copy_expression x1)\n\nand copy_module_binding :\n From.Parsetree.module_binding -> To.Parsetree.module_binding =\n fun {\n From.Parsetree.pmb_name;\n From.Parsetree.pmb_expr;\n From.Parsetree.pmb_attributes;\n From.Parsetree.pmb_loc;\n } ->\n {\n To.Parsetree.pmb_name = copy_loc (fun x -> x) pmb_name;\n To.Parsetree.pmb_expr = copy_module_expr pmb_expr;\n To.Parsetree.pmb_attributes = copy_attributes pmb_attributes;\n To.Parsetree.pmb_loc = copy_location pmb_loc;\n }\n\nand copy_module_expr : From.Parsetree.module_expr -> To.Parsetree.module_expr =\n fun {\n From.Parsetree.pmod_desc;\n From.Parsetree.pmod_loc;\n From.Parsetree.pmod_attributes;\n } ->\n {\n To.Parsetree.pmod_desc = copy_module_expr_desc pmod_desc;\n To.Parsetree.pmod_loc = copy_location pmod_loc;\n To.Parsetree.pmod_attributes = copy_attributes pmod_attributes;\n }\n\nand copy_module_expr_desc :\n From.Parsetree.module_expr_desc -> To.Parsetree.module_expr_desc = function\n | From.Parsetree.Pmod_ident x0 ->\n To.Parsetree.Pmod_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pmod_structure x0 ->\n To.Parsetree.Pmod_structure (copy_structure x0)\n | From.Parsetree.Pmod_functor (x0, x1, x2) ->\n To.Parsetree.Pmod_functor\n ( copy_loc (fun x -> x) x0,\n copy_option copy_module_type x1,\n copy_module_expr x2 )\n | From.Parsetree.Pmod_apply (x0, x1) ->\n To.Parsetree.Pmod_apply (copy_module_expr x0, copy_module_expr x1)\n | From.Parsetree.Pmod_constraint (x0, x1) ->\n To.Parsetree.Pmod_constraint (copy_module_expr x0, copy_module_type x1)\n | From.Parsetree.Pmod_unpack x0 ->\n To.Parsetree.Pmod_unpack (copy_expression x0)\n | From.Parsetree.Pmod_extension x0 ->\n To.Parsetree.Pmod_extension (copy_extension x0)\n\nand copy_module_type : From.Parsetree.module_type -> To.Parsetree.module_type =\n fun {\n From.Parsetree.pmty_desc;\n From.Parsetree.pmty_loc;\n From.Parsetree.pmty_attributes;\n } ->\n {\n To.Parsetree.pmty_desc = copy_module_type_desc pmty_desc;\n To.Parsetree.pmty_loc = copy_location pmty_loc;\n To.Parsetree.pmty_attributes = copy_attributes pmty_attributes;\n }\n\nand copy_module_type_desc :\n From.Parsetree.module_type_desc -> To.Parsetree.module_type_desc = function\n | From.Parsetree.Pmty_ident x0 ->\n To.Parsetree.Pmty_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pmty_signature x0 ->\n To.Parsetree.Pmty_signature (copy_signature x0)\n | From.Parsetree.Pmty_functor (x0, x1, x2) ->\n To.Parsetree.Pmty_functor\n ( copy_loc (fun x -> x) x0,\n copy_option copy_module_type x1,\n copy_module_type x2 )\n | From.Parsetree.Pmty_with (x0, x1) ->\n To.Parsetree.Pmty_with\n (copy_module_type x0, List.map copy_with_constraint x1)\n | From.Parsetree.Pmty_typeof x0 ->\n To.Parsetree.Pmty_typeof (copy_module_expr x0)\n | From.Parsetree.Pmty_extension x0 ->\n To.Parsetree.Pmty_extension (copy_extension x0)\n | From.Parsetree.Pmty_alias x0 ->\n To.Parsetree.Pmty_alias (copy_loc copy_longident x0)\n\nand copy_with_constraint :\n From.Parsetree.with_constraint -> To.Parsetree.with_constraint = function\n | From.Parsetree.Pwith_type (x0, x1) ->\n To.Parsetree.Pwith_type\n (copy_loc copy_longident x0, copy_type_declaration x1)\n | From.Parsetree.Pwith_module (x0, x1) ->\n To.Parsetree.Pwith_module\n (copy_loc copy_longident x0, copy_loc copy_longident x1)\n | From.Parsetree.Pwith_typesubst (x0, x1) ->\n To.Parsetree.Pwith_typesubst\n (copy_loc copy_longident x0, copy_type_declaration x1)\n | From.Parsetree.Pwith_modsubst (x0, x1) ->\n To.Parsetree.Pwith_modsubst\n (copy_loc copy_longident x0, copy_loc copy_longident x1)\n\nand copy_signature : From.Parsetree.signature -> To.Parsetree.signature =\n fun x -> List.map copy_signature_item x\n\nand copy_signature_item :\n From.Parsetree.signature_item -> To.Parsetree.signature_item =\n fun { From.Parsetree.psig_desc; From.Parsetree.psig_loc } ->\n {\n To.Parsetree.psig_desc = copy_signature_item_desc psig_desc;\n To.Parsetree.psig_loc = copy_location psig_loc;\n }\n\nand copy_signature_item_desc :\n From.Parsetree.signature_item_desc -> To.Parsetree.signature_item_desc =\n function\n | From.Parsetree.Psig_value x0 ->\n To.Parsetree.Psig_value (copy_value_description x0)\n | From.Parsetree.Psig_type (x0, x1) ->\n To.Parsetree.Psig_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | From.Parsetree.Psig_typext x0 ->\n To.Parsetree.Psig_typext (copy_type_extension x0)\n | From.Parsetree.Psig_exception x0 ->\n To.Parsetree.Psig_exception (copy_extension_constructor x0)\n | From.Parsetree.Psig_module x0 ->\n To.Parsetree.Psig_module (copy_module_declaration x0)\n | From.Parsetree.Psig_recmodule x0 ->\n To.Parsetree.Psig_recmodule (List.map copy_module_declaration x0)\n | From.Parsetree.Psig_modtype x0 ->\n To.Parsetree.Psig_modtype (copy_module_type_declaration x0)\n | From.Parsetree.Psig_open x0 ->\n To.Parsetree.Psig_open (copy_open_description x0)\n | From.Parsetree.Psig_include x0 ->\n To.Parsetree.Psig_include (copy_include_description x0)\n | From.Parsetree.Psig_class x0 ->\n To.Parsetree.Psig_class (List.map copy_class_description x0)\n | From.Parsetree.Psig_class_type x0 ->\n To.Parsetree.Psig_class_type (List.map copy_class_type_declaration x0)\n | From.Parsetree.Psig_attribute x0 ->\n To.Parsetree.Psig_attribute (copy_attribute x0)\n | From.Parsetree.Psig_extension (x0, x1) ->\n To.Parsetree.Psig_extension (copy_extension x0, copy_attributes x1)\n\nand copy_class_type_declaration :\n From.Parsetree.class_type_declaration -> To.Parsetree.class_type_declaration\n =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_description :\n From.Parsetree.class_description -> To.Parsetree.class_description =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_type : From.Parsetree.class_type -> To.Parsetree.class_type =\n fun {\n From.Parsetree.pcty_desc;\n From.Parsetree.pcty_loc;\n From.Parsetree.pcty_attributes;\n } ->\n {\n To.Parsetree.pcty_desc = copy_class_type_desc pcty_desc;\n To.Parsetree.pcty_loc = copy_location pcty_loc;\n To.Parsetree.pcty_attributes = copy_attributes pcty_attributes;\n }\n\nand copy_class_type_desc :\n From.Parsetree.class_type_desc -> To.Parsetree.class_type_desc = function\n | From.Parsetree.Pcty_constr (x0, x1) ->\n To.Parsetree.Pcty_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Pcty_signature x0 ->\n To.Parsetree.Pcty_signature (copy_class_signature x0)\n | From.Parsetree.Pcty_arrow (x0, x1, x2) ->\n To.Parsetree.Pcty_arrow\n (copy_arg_label x0, copy_core_type x1, copy_class_type x2)\n | From.Parsetree.Pcty_extension x0 ->\n To.Parsetree.Pcty_extension (copy_extension x0)\n | From.Parsetree.Pcty_open (ovf, loc, cty) ->\n To.Parsetree.Pcty_open\n ( copy_override_flag ovf,\n copy_loc copy_longident loc,\n copy_class_type cty )\n\nand copy_class_signature :\n From.Parsetree.class_signature -> To.Parsetree.class_signature =\n fun { From.Parsetree.pcsig_self; From.Parsetree.pcsig_fields } ->\n {\n To.Parsetree.pcsig_self = copy_core_type pcsig_self;\n To.Parsetree.pcsig_fields = List.map copy_class_type_field pcsig_fields;\n }\n\nand copy_class_type_field :\n From.Parsetree.class_type_field -> To.Parsetree.class_type_field =\n fun {\n From.Parsetree.pctf_desc;\n From.Parsetree.pctf_loc;\n From.Parsetree.pctf_attributes;\n } ->\n {\n To.Parsetree.pctf_desc = copy_class_type_field_desc pctf_desc;\n To.Parsetree.pctf_loc = copy_location pctf_loc;\n To.Parsetree.pctf_attributes = copy_attributes pctf_attributes;\n }\n\nand copy_class_type_field_desc :\n From.Parsetree.class_type_field_desc -> To.Parsetree.class_type_field_desc =\n function\n | From.Parsetree.Pctf_inherit x0 ->\n To.Parsetree.Pctf_inherit (copy_class_type x0)\n | From.Parsetree.Pctf_val x0 ->\n To.Parsetree.Pctf_val\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_mutable_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | From.Parsetree.Pctf_method x0 ->\n To.Parsetree.Pctf_method\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_private_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | From.Parsetree.Pctf_constraint x0 ->\n To.Parsetree.Pctf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | From.Parsetree.Pctf_attribute x0 ->\n To.Parsetree.Pctf_attribute (copy_attribute x0)\n | From.Parsetree.Pctf_extension x0 ->\n To.Parsetree.Pctf_extension (copy_extension x0)\n\nand copy_extension : From.Parsetree.extension -> To.Parsetree.extension =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_class_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 From.Parsetree.class_infos ->\n 'g0 To.Parsetree.class_infos =\n fun f0\n {\n From.Parsetree.pci_virt;\n From.Parsetree.pci_params;\n From.Parsetree.pci_name;\n From.Parsetree.pci_expr;\n From.Parsetree.pci_loc;\n From.Parsetree.pci_attributes;\n } ->\n {\n To.Parsetree.pci_virt = copy_virtual_flag pci_virt;\n To.Parsetree.pci_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n pci_params;\n To.Parsetree.pci_name = copy_loc (fun x -> x) pci_name;\n To.Parsetree.pci_expr = f0 pci_expr;\n To.Parsetree.pci_loc = copy_location pci_loc;\n To.Parsetree.pci_attributes = copy_attributes pci_attributes;\n }\n\nand copy_virtual_flag : From.Asttypes.virtual_flag -> To.Asttypes.virtual_flag =\n function\n | From.Asttypes.Virtual -> To.Asttypes.Virtual\n | From.Asttypes.Concrete -> To.Asttypes.Concrete\n\nand copy_include_description :\n From.Parsetree.include_description -> To.Parsetree.include_description =\n fun x -> copy_include_infos copy_module_type x\n\nand copy_include_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 From.Parsetree.include_infos ->\n 'g0 To.Parsetree.include_infos =\n fun f0\n {\n From.Parsetree.pincl_mod;\n From.Parsetree.pincl_loc;\n From.Parsetree.pincl_attributes;\n } ->\n {\n To.Parsetree.pincl_mod = f0 pincl_mod;\n To.Parsetree.pincl_loc = copy_location pincl_loc;\n To.Parsetree.pincl_attributes = copy_attributes pincl_attributes;\n }\n\nand copy_open_description :\n From.Parsetree.open_description -> To.Parsetree.open_description =\n fun {\n From.Parsetree.popen_lid;\n From.Parsetree.popen_override;\n From.Parsetree.popen_loc;\n From.Parsetree.popen_attributes;\n } ->\n {\n To.Parsetree.popen_lid = copy_loc copy_longident popen_lid;\n To.Parsetree.popen_override = copy_override_flag popen_override;\n To.Parsetree.popen_loc = copy_location popen_loc;\n To.Parsetree.popen_attributes = copy_attributes popen_attributes;\n }\n\nand copy_override_flag :\n From.Asttypes.override_flag -> To.Asttypes.override_flag = function\n | From.Asttypes.Override -> To.Asttypes.Override\n | From.Asttypes.Fresh -> To.Asttypes.Fresh\n\nand copy_module_type_declaration :\n From.Parsetree.module_type_declaration ->\n To.Parsetree.module_type_declaration =\n fun {\n From.Parsetree.pmtd_name;\n From.Parsetree.pmtd_type;\n From.Parsetree.pmtd_attributes;\n From.Parsetree.pmtd_loc;\n } ->\n {\n To.Parsetree.pmtd_name = copy_loc (fun x -> x) pmtd_name;\n To.Parsetree.pmtd_type = copy_option copy_module_type pmtd_type;\n To.Parsetree.pmtd_attributes = copy_attributes pmtd_attributes;\n To.Parsetree.pmtd_loc = copy_location pmtd_loc;\n }\n\nand copy_module_declaration :\n From.Parsetree.module_declaration -> To.Parsetree.module_declaration =\n fun {\n From.Parsetree.pmd_name;\n From.Parsetree.pmd_type;\n From.Parsetree.pmd_attributes;\n From.Parsetree.pmd_loc;\n } ->\n {\n To.Parsetree.pmd_name = copy_loc (fun x -> x) pmd_name;\n To.Parsetree.pmd_type = copy_module_type pmd_type;\n To.Parsetree.pmd_attributes = copy_attributes pmd_attributes;\n To.Parsetree.pmd_loc = copy_location pmd_loc;\n }\n\nand copy_type_extension :\n From.Parsetree.type_extension -> To.Parsetree.type_extension =\n fun {\n From.Parsetree.ptyext_path;\n From.Parsetree.ptyext_params;\n From.Parsetree.ptyext_constructors;\n From.Parsetree.ptyext_private;\n From.Parsetree.ptyext_attributes;\n } ->\n {\n To.Parsetree.ptyext_path = copy_loc copy_longident ptyext_path;\n To.Parsetree.ptyext_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptyext_params;\n To.Parsetree.ptyext_constructors =\n List.map copy_extension_constructor ptyext_constructors;\n To.Parsetree.ptyext_private = copy_private_flag ptyext_private;\n To.Parsetree.ptyext_attributes = copy_attributes ptyext_attributes;\n }\n\nand copy_extension_constructor :\n From.Parsetree.extension_constructor -> To.Parsetree.extension_constructor =\n fun {\n From.Parsetree.pext_name;\n From.Parsetree.pext_kind;\n From.Parsetree.pext_loc;\n From.Parsetree.pext_attributes;\n } ->\n {\n To.Parsetree.pext_name = copy_loc (fun x -> x) pext_name;\n To.Parsetree.pext_kind = copy_extension_constructor_kind pext_kind;\n To.Parsetree.pext_loc = copy_location pext_loc;\n To.Parsetree.pext_attributes = copy_attributes pext_attributes;\n }\n\nand copy_extension_constructor_kind :\n From.Parsetree.extension_constructor_kind ->\n To.Parsetree.extension_constructor_kind = function\n | From.Parsetree.Pext_decl (x0, x1) ->\n To.Parsetree.Pext_decl\n (copy_constructor_arguments x0, copy_option copy_core_type x1)\n | From.Parsetree.Pext_rebind x0 ->\n To.Parsetree.Pext_rebind (copy_loc copy_longident x0)\n\nand copy_type_declaration :\n From.Parsetree.type_declaration -> To.Parsetree.type_declaration =\n fun {\n From.Parsetree.ptype_name;\n From.Parsetree.ptype_params;\n From.Parsetree.ptype_cstrs;\n From.Parsetree.ptype_kind;\n From.Parsetree.ptype_private;\n From.Parsetree.ptype_manifest;\n From.Parsetree.ptype_attributes;\n From.Parsetree.ptype_loc;\n } ->\n {\n To.Parsetree.ptype_name = copy_loc (fun x -> x) ptype_name;\n To.Parsetree.ptype_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptype_params;\n To.Parsetree.ptype_cstrs =\n List.map\n (fun x ->\n let x0, x1, x2 = x in\n (copy_core_type x0, copy_core_type x1, copy_location x2))\n ptype_cstrs;\n To.Parsetree.ptype_kind = copy_type_kind ptype_kind;\n To.Parsetree.ptype_private = copy_private_flag ptype_private;\n To.Parsetree.ptype_manifest = copy_option copy_core_type ptype_manifest;\n To.Parsetree.ptype_attributes = copy_attributes ptype_attributes;\n To.Parsetree.ptype_loc = copy_location ptype_loc;\n }\n\nand copy_private_flag : From.Asttypes.private_flag -> To.Asttypes.private_flag =\n function\n | From.Asttypes.Private -> To.Asttypes.Private\n | From.Asttypes.Public -> To.Asttypes.Public\n\nand copy_type_kind : From.Parsetree.type_kind -> To.Parsetree.type_kind =\n function\n | From.Parsetree.Ptype_abstract -> To.Parsetree.Ptype_abstract\n | From.Parsetree.Ptype_variant x0 ->\n To.Parsetree.Ptype_variant (List.map copy_constructor_declaration x0)\n | From.Parsetree.Ptype_record x0 ->\n To.Parsetree.Ptype_record (List.map copy_label_declaration x0)\n | From.Parsetree.Ptype_open -> To.Parsetree.Ptype_open\n\nand copy_constructor_declaration :\n From.Parsetree.constructor_declaration ->\n To.Parsetree.constructor_declaration =\n fun {\n From.Parsetree.pcd_name;\n From.Parsetree.pcd_args;\n From.Parsetree.pcd_res;\n From.Parsetree.pcd_loc;\n From.Parsetree.pcd_attributes;\n } ->\n {\n To.Parsetree.pcd_name = copy_loc (fun x -> x) pcd_name;\n To.Parsetree.pcd_args = copy_constructor_arguments pcd_args;\n To.Parsetree.pcd_res = copy_option copy_core_type pcd_res;\n To.Parsetree.pcd_loc = copy_location pcd_loc;\n To.Parsetree.pcd_attributes = copy_attributes pcd_attributes;\n }\n\nand copy_constructor_arguments :\n From.Parsetree.constructor_arguments -> To.Parsetree.constructor_arguments =\n function\n | From.Parsetree.Pcstr_tuple x0 ->\n To.Parsetree.Pcstr_tuple (List.map copy_core_type x0)\n | From.Parsetree.Pcstr_record x0 ->\n To.Parsetree.Pcstr_record (List.map copy_label_declaration x0)\n\nand copy_label_declaration :\n From.Parsetree.label_declaration -> To.Parsetree.label_declaration =\n fun {\n From.Parsetree.pld_name;\n From.Parsetree.pld_mutable;\n From.Parsetree.pld_type;\n From.Parsetree.pld_loc;\n From.Parsetree.pld_attributes;\n } ->\n {\n To.Parsetree.pld_name = copy_loc (fun x -> x) pld_name;\n To.Parsetree.pld_mutable = copy_mutable_flag pld_mutable;\n To.Parsetree.pld_type = copy_core_type pld_type;\n To.Parsetree.pld_loc = copy_location pld_loc;\n To.Parsetree.pld_attributes = copy_attributes pld_attributes;\n }\n\nand copy_mutable_flag : From.Asttypes.mutable_flag -> To.Asttypes.mutable_flag =\n function\n | From.Asttypes.Immutable -> To.Asttypes.Immutable\n | From.Asttypes.Mutable -> To.Asttypes.Mutable\n\nand copy_variance : From.Asttypes.variance -> To.Asttypes.variance = function\n | From.Asttypes.Covariant -> To.Asttypes.Covariant\n | From.Asttypes.Contravariant -> To.Asttypes.Contravariant\n | From.Asttypes.Invariant -> To.Asttypes.Invariant\n\nand copy_value_description :\n From.Parsetree.value_description -> To.Parsetree.value_description =\n fun {\n From.Parsetree.pval_name;\n From.Parsetree.pval_type;\n From.Parsetree.pval_prim;\n From.Parsetree.pval_attributes;\n From.Parsetree.pval_loc;\n } ->\n {\n To.Parsetree.pval_name = copy_loc (fun x -> x) pval_name;\n To.Parsetree.pval_type = copy_core_type pval_type;\n To.Parsetree.pval_prim = List.map (fun x -> x) pval_prim;\n To.Parsetree.pval_attributes = copy_attributes pval_attributes;\n To.Parsetree.pval_loc = copy_location pval_loc;\n }\n\nand copy_arg_label : From.Asttypes.arg_label -> To.Asttypes.arg_label = function\n | From.Asttypes.Nolabel -> To.Asttypes.Nolabel\n | From.Asttypes.Labelled x0 -> To.Asttypes.Labelled x0\n | From.Asttypes.Optional x0 -> To.Asttypes.Optional x0\n\nand copy_closed_flag : From.Asttypes.closed_flag -> To.Asttypes.closed_flag =\n function\n | From.Asttypes.Closed -> To.Asttypes.Closed\n | From.Asttypes.Open -> To.Asttypes.Open\n\nand copy_label : From.Asttypes.label -> To.Asttypes.label = fun x -> x\n\nand copy_rec_flag : From.Asttypes.rec_flag -> To.Asttypes.rec_flag = function\n | From.Asttypes.Nonrecursive -> To.Asttypes.Nonrecursive\n | From.Asttypes.Recursive -> To.Asttypes.Recursive\n\nand copy_constant : From.Parsetree.constant -> To.Parsetree.constant = function\n | From.Parsetree.Pconst_integer (x0, x1) ->\n To.Parsetree.Pconst_integer (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pconst_char x0 -> To.Parsetree.Pconst_char x0\n | From.Parsetree.Pconst_string (x0, x1) ->\n To.Parsetree.Pconst_string (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pconst_float (x0, x1) ->\n To.Parsetree.Pconst_float (x0, copy_option (fun x -> x) x1)\n\nand copy_option : 'f0 'g0. ('f0 -> 'g0) -> 'f0 option -> 'g0 option =\n fun f0 -> function None -> None | Some x0 -> Some (f0 x0)\n\nand copy_longident : Longident.t -> Longident.t = fun x -> x\n\nand copy_loc :\n 'f0 'g0. ('f0 -> 'g0) -> 'f0 From.Asttypes.loc -> 'g0 To.Asttypes.loc =\n fun f0 { From.Asttypes.txt; From.Asttypes.loc } ->\n { To.Asttypes.txt = f0 txt; To.Asttypes.loc = copy_location loc }\n\nand copy_location : Location.t -> Location.t = fun x -> x\nand copy_bool : bool -> bool = function false -> false | true -> true\n\nlet rec copy_toplevel_phrase :\n From.Parsetree.toplevel_phrase -> To.Parsetree.toplevel_phrase = function\n | From.Parsetree.Ptop_def x0 -> To.Parsetree.Ptop_def (copy_structure x0)\n | From.Parsetree.Ptop_dir (x0, x1) ->\n To.Parsetree.Ptop_dir (x0, copy_directive_argument x1)\n\nand copy_directive_argument :\n From.Parsetree.directive_argument -> To.Parsetree.directive_argument =\n function\n | From.Parsetree.Pdir_none -> To.Parsetree.Pdir_none\n | From.Parsetree.Pdir_string x0 -> To.Parsetree.Pdir_string x0\n | From.Parsetree.Pdir_int (x0, x1) ->\n To.Parsetree.Pdir_int (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pdir_ident x0 -> To.Parsetree.Pdir_ident (copy_longident x0)\n | From.Parsetree.Pdir_bool x0 -> To.Parsetree.Pdir_bool (copy_bool x0)\n\nlet copy_cases x = List.map copy_case x\nlet copy_pat = copy_pattern\nlet copy_expr = copy_expression\nlet copy_typ = copy_core_type\n","(**************************************************************************)\n(* *)\n(* OCaml Migrate Parsetree *)\n(* *)\n(* Frédéric Bour *)\n(* Alain Frisch, LexiFi *)\n(* *)\n(* Copyright 2017 Institut National de Recherche en Informatique et *)\n(* en Automatique (INRIA). *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nmodule From = Ast_406\nmodule To = Ast_405\n\nlet migration_error loc missing_feature =\n Location.raise_errorf ~loc\n \"migration error: %s is not supported before OCaml 4.06\" missing_feature\n\nlet rec copy_expression : From.Parsetree.expression -> To.Parsetree.expression =\n fun {\n From.Parsetree.pexp_desc;\n From.Parsetree.pexp_loc;\n From.Parsetree.pexp_attributes;\n } ->\n {\n To.Parsetree.pexp_desc = copy_expression_desc pexp_desc;\n To.Parsetree.pexp_loc = copy_location pexp_loc;\n To.Parsetree.pexp_attributes = copy_attributes pexp_attributes;\n }\n\nand copy_expression_desc :\n From.Parsetree.expression_desc -> To.Parsetree.expression_desc = function\n | From.Parsetree.Pexp_ident x0 ->\n To.Parsetree.Pexp_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pexp_constant x0 ->\n To.Parsetree.Pexp_constant (copy_constant x0)\n | From.Parsetree.Pexp_let (x0, x1, x2) ->\n To.Parsetree.Pexp_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_expression x2)\n | From.Parsetree.Pexp_function x0 ->\n To.Parsetree.Pexp_function (List.map copy_case x0)\n | From.Parsetree.Pexp_fun (x0, x1, x2, x3) ->\n To.Parsetree.Pexp_fun\n ( copy_arg_label x0,\n copy_option copy_expression x1,\n copy_pattern x2,\n copy_expression x3 )\n | From.Parsetree.Pexp_apply (x0, x1) ->\n To.Parsetree.Pexp_apply\n ( copy_expression x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | From.Parsetree.Pexp_match (x0, x1) ->\n To.Parsetree.Pexp_match (copy_expression x0, List.map copy_case x1)\n | From.Parsetree.Pexp_try (x0, x1) ->\n To.Parsetree.Pexp_try (copy_expression x0, List.map copy_case x1)\n | From.Parsetree.Pexp_tuple x0 ->\n To.Parsetree.Pexp_tuple (List.map copy_expression x0)\n | From.Parsetree.Pexp_construct (x0, x1) ->\n To.Parsetree.Pexp_construct\n (copy_loc copy_longident x0, copy_option copy_expression x1)\n | From.Parsetree.Pexp_variant (x0, x1) ->\n To.Parsetree.Pexp_variant (copy_label x0, copy_option copy_expression x1)\n | From.Parsetree.Pexp_record (x0, x1) ->\n To.Parsetree.Pexp_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_expression x1))\n x0,\n copy_option copy_expression x1 )\n | From.Parsetree.Pexp_field (x0, x1) ->\n To.Parsetree.Pexp_field (copy_expression x0, copy_loc copy_longident x1)\n | From.Parsetree.Pexp_setfield (x0, x1, x2) ->\n To.Parsetree.Pexp_setfield\n (copy_expression x0, copy_loc copy_longident x1, copy_expression x2)\n | From.Parsetree.Pexp_array x0 ->\n To.Parsetree.Pexp_array (List.map copy_expression x0)\n | From.Parsetree.Pexp_ifthenelse (x0, x1, x2) ->\n To.Parsetree.Pexp_ifthenelse\n (copy_expression x0, copy_expression x1, copy_option copy_expression x2)\n | From.Parsetree.Pexp_sequence (x0, x1) ->\n To.Parsetree.Pexp_sequence (copy_expression x0, copy_expression x1)\n | From.Parsetree.Pexp_while (x0, x1) ->\n To.Parsetree.Pexp_while (copy_expression x0, copy_expression x1)\n | From.Parsetree.Pexp_for (x0, x1, x2, x3, x4) ->\n To.Parsetree.Pexp_for\n ( copy_pattern x0,\n copy_expression x1,\n copy_expression x2,\n copy_direction_flag x3,\n copy_expression x4 )\n | From.Parsetree.Pexp_constraint (x0, x1) ->\n To.Parsetree.Pexp_constraint (copy_expression x0, copy_core_type x1)\n | From.Parsetree.Pexp_coerce (x0, x1, x2) ->\n To.Parsetree.Pexp_coerce\n (copy_expression x0, copy_option copy_core_type x1, copy_core_type x2)\n | From.Parsetree.Pexp_send (x0, x1) ->\n To.Parsetree.Pexp_send (copy_expression x0, copy_loc (fun x -> x) x1)\n | From.Parsetree.Pexp_new x0 ->\n To.Parsetree.Pexp_new (copy_loc copy_longident x0)\n | From.Parsetree.Pexp_setinstvar (x0, x1) ->\n To.Parsetree.Pexp_setinstvar (copy_loc (fun x -> x) x0, copy_expression x1)\n | From.Parsetree.Pexp_override x0 ->\n To.Parsetree.Pexp_override\n (List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_expression x1))\n x0)\n | From.Parsetree.Pexp_letmodule (x0, x1, x2) ->\n To.Parsetree.Pexp_letmodule\n (copy_loc (fun x -> x) x0, copy_module_expr x1, copy_expression x2)\n | From.Parsetree.Pexp_letexception (x0, x1) ->\n To.Parsetree.Pexp_letexception\n (copy_extension_constructor x0, copy_expression x1)\n | From.Parsetree.Pexp_assert x0 ->\n To.Parsetree.Pexp_assert (copy_expression x0)\n | From.Parsetree.Pexp_lazy x0 -> To.Parsetree.Pexp_lazy (copy_expression x0)\n | From.Parsetree.Pexp_poly (x0, x1) ->\n To.Parsetree.Pexp_poly (copy_expression x0, copy_option copy_core_type x1)\n | From.Parsetree.Pexp_object x0 ->\n To.Parsetree.Pexp_object (copy_class_structure x0)\n | From.Parsetree.Pexp_newtype (x0, x1) ->\n To.Parsetree.Pexp_newtype (copy_loc (fun x -> x) x0, copy_expression x1)\n | From.Parsetree.Pexp_pack x0 -> To.Parsetree.Pexp_pack (copy_module_expr x0)\n | From.Parsetree.Pexp_open (x0, x1, x2) ->\n To.Parsetree.Pexp_open\n (copy_override_flag x0, copy_loc copy_longident x1, copy_expression x2)\n | From.Parsetree.Pexp_extension x0 ->\n To.Parsetree.Pexp_extension (copy_extension x0)\n | From.Parsetree.Pexp_unreachable -> To.Parsetree.Pexp_unreachable\n\nand copy_direction_flag :\n From.Asttypes.direction_flag -> To.Asttypes.direction_flag = function\n | From.Asttypes.Upto -> To.Asttypes.Upto\n | From.Asttypes.Downto -> To.Asttypes.Downto\n\nand copy_case : From.Parsetree.case -> To.Parsetree.case =\n fun { From.Parsetree.pc_lhs; From.Parsetree.pc_guard; From.Parsetree.pc_rhs } ->\n {\n To.Parsetree.pc_lhs = copy_pattern pc_lhs;\n To.Parsetree.pc_guard = copy_option copy_expression pc_guard;\n To.Parsetree.pc_rhs = copy_expression pc_rhs;\n }\n\nand copy_value_binding :\n From.Parsetree.value_binding -> To.Parsetree.value_binding =\n fun {\n From.Parsetree.pvb_pat;\n From.Parsetree.pvb_expr;\n From.Parsetree.pvb_attributes;\n From.Parsetree.pvb_loc;\n } ->\n {\n To.Parsetree.pvb_pat = copy_pattern pvb_pat;\n To.Parsetree.pvb_expr = copy_expression pvb_expr;\n To.Parsetree.pvb_attributes = copy_attributes pvb_attributes;\n To.Parsetree.pvb_loc = copy_location pvb_loc;\n }\n\nand copy_pattern : From.Parsetree.pattern -> To.Parsetree.pattern =\n fun {\n From.Parsetree.ppat_desc;\n From.Parsetree.ppat_loc;\n From.Parsetree.ppat_attributes;\n } ->\n {\n To.Parsetree.ppat_desc = copy_pattern_desc ppat_desc;\n To.Parsetree.ppat_loc = copy_location ppat_loc;\n To.Parsetree.ppat_attributes = copy_attributes ppat_attributes;\n }\n\nand copy_pattern_desc : From.Parsetree.pattern_desc -> To.Parsetree.pattern_desc\n = function\n | From.Parsetree.Ppat_any -> To.Parsetree.Ppat_any\n | From.Parsetree.Ppat_var x0 ->\n To.Parsetree.Ppat_var (copy_loc (fun x -> x) x0)\n | From.Parsetree.Ppat_alias (x0, x1) ->\n To.Parsetree.Ppat_alias (copy_pattern x0, copy_loc (fun x -> x) x1)\n | From.Parsetree.Ppat_constant x0 ->\n To.Parsetree.Ppat_constant (copy_constant x0)\n | From.Parsetree.Ppat_interval (x0, x1) ->\n To.Parsetree.Ppat_interval (copy_constant x0, copy_constant x1)\n | From.Parsetree.Ppat_tuple x0 ->\n To.Parsetree.Ppat_tuple (List.map copy_pattern x0)\n | From.Parsetree.Ppat_construct (x0, x1) ->\n To.Parsetree.Ppat_construct\n (copy_loc copy_longident x0, copy_option copy_pattern x1)\n | From.Parsetree.Ppat_variant (x0, x1) ->\n To.Parsetree.Ppat_variant (copy_label x0, copy_option copy_pattern x1)\n | From.Parsetree.Ppat_record (x0, x1) ->\n To.Parsetree.Ppat_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_pattern x1))\n x0,\n copy_closed_flag x1 )\n | From.Parsetree.Ppat_array x0 ->\n To.Parsetree.Ppat_array (List.map copy_pattern x0)\n | From.Parsetree.Ppat_or (x0, x1) ->\n To.Parsetree.Ppat_or (copy_pattern x0, copy_pattern x1)\n | From.Parsetree.Ppat_constraint (x0, x1) ->\n To.Parsetree.Ppat_constraint (copy_pattern x0, copy_core_type x1)\n | From.Parsetree.Ppat_type x0 ->\n To.Parsetree.Ppat_type (copy_loc copy_longident x0)\n | From.Parsetree.Ppat_lazy x0 -> To.Parsetree.Ppat_lazy (copy_pattern x0)\n | From.Parsetree.Ppat_unpack x0 ->\n To.Parsetree.Ppat_unpack (copy_loc (fun x -> x) x0)\n | From.Parsetree.Ppat_exception x0 ->\n To.Parsetree.Ppat_exception (copy_pattern x0)\n | From.Parsetree.Ppat_extension x0 ->\n To.Parsetree.Ppat_extension (copy_extension x0)\n | From.Parsetree.Ppat_open (x0, x1) ->\n To.Parsetree.Ppat_open (copy_loc copy_longident x0, copy_pattern x1)\n\nand copy_core_type : From.Parsetree.core_type -> To.Parsetree.core_type =\n fun {\n From.Parsetree.ptyp_desc;\n From.Parsetree.ptyp_loc;\n From.Parsetree.ptyp_attributes;\n } ->\n {\n To.Parsetree.ptyp_desc = copy_core_type_desc ptyp_desc;\n To.Parsetree.ptyp_loc = copy_location ptyp_loc;\n To.Parsetree.ptyp_attributes = copy_attributes ptyp_attributes;\n }\n\nand copy_core_type_desc :\n From.Parsetree.core_type_desc -> To.Parsetree.core_type_desc = function\n | From.Parsetree.Ptyp_any -> To.Parsetree.Ptyp_any\n | From.Parsetree.Ptyp_var x0 -> To.Parsetree.Ptyp_var x0\n | From.Parsetree.Ptyp_arrow (x0, x1, x2) ->\n To.Parsetree.Ptyp_arrow\n (copy_arg_label x0, copy_core_type x1, copy_core_type x2)\n | From.Parsetree.Ptyp_tuple x0 ->\n To.Parsetree.Ptyp_tuple (List.map copy_core_type x0)\n | From.Parsetree.Ptyp_constr (x0, x1) ->\n To.Parsetree.Ptyp_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Ptyp_object (x0, x1) ->\n To.Parsetree.Ptyp_object\n ( List.map\n (function\n | From.Parsetree.Otag (x0, x1, x2) ->\n ( copy_loc (fun x -> x) x0,\n copy_attributes x1,\n copy_core_type x2 )\n | From.Parsetree.Oinherit _ ->\n migration_error Location.none \"inheritance in object type\")\n x0,\n copy_closed_flag x1 )\n | From.Parsetree.Ptyp_class (x0, x1) ->\n To.Parsetree.Ptyp_class\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Ptyp_alias (x0, x1) ->\n To.Parsetree.Ptyp_alias (copy_core_type x0, x1)\n | From.Parsetree.Ptyp_variant (x0, x1, x2) ->\n To.Parsetree.Ptyp_variant\n ( List.map copy_row_field x0,\n copy_closed_flag x1,\n copy_option (fun x -> List.map copy_label x) x2 )\n | From.Parsetree.Ptyp_poly (x0, x1) ->\n To.Parsetree.Ptyp_poly\n (List.map (fun x -> copy_loc (fun x -> x) x) x0, copy_core_type x1)\n | From.Parsetree.Ptyp_package x0 ->\n To.Parsetree.Ptyp_package (copy_package_type x0)\n | From.Parsetree.Ptyp_extension x0 ->\n To.Parsetree.Ptyp_extension (copy_extension x0)\n\nand copy_package_type : From.Parsetree.package_type -> To.Parsetree.package_type\n =\n fun x ->\n let x0, x1 = x in\n ( copy_loc copy_longident x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_core_type x1))\n x1 )\n\nand copy_row_field : From.Parsetree.row_field -> To.Parsetree.row_field =\n function\n | From.Parsetree.Rtag (x0, x1, x2, x3) ->\n To.Parsetree.Rtag\n ( copy_label x0.txt,\n copy_attributes x1,\n copy_bool x2,\n List.map copy_core_type x3 )\n | From.Parsetree.Rinherit x0 -> To.Parsetree.Rinherit (copy_core_type x0)\n\nand copy_attributes : From.Parsetree.attributes -> To.Parsetree.attributes =\n fun x -> List.map copy_attribute x\n\nand copy_attribute : From.Parsetree.attribute -> To.Parsetree.attribute =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_payload : From.Parsetree.payload -> To.Parsetree.payload = function\n | From.Parsetree.PStr x0 -> To.Parsetree.PStr (copy_structure x0)\n | From.Parsetree.PSig x0 -> To.Parsetree.PSig (copy_signature x0)\n | From.Parsetree.PTyp x0 -> To.Parsetree.PTyp (copy_core_type x0)\n | From.Parsetree.PPat (x0, x1) ->\n To.Parsetree.PPat (copy_pattern x0, copy_option copy_expression x1)\n\nand copy_structure : From.Parsetree.structure -> To.Parsetree.structure =\n fun x -> List.map copy_structure_item x\n\nand copy_structure_item :\n From.Parsetree.structure_item -> To.Parsetree.structure_item =\n fun { From.Parsetree.pstr_desc; From.Parsetree.pstr_loc } ->\n {\n To.Parsetree.pstr_desc = copy_structure_item_desc pstr_desc;\n To.Parsetree.pstr_loc = copy_location pstr_loc;\n }\n\nand copy_structure_item_desc :\n From.Parsetree.structure_item_desc -> To.Parsetree.structure_item_desc =\n function\n | From.Parsetree.Pstr_eval (x0, x1) ->\n To.Parsetree.Pstr_eval (copy_expression x0, copy_attributes x1)\n | From.Parsetree.Pstr_value (x0, x1) ->\n To.Parsetree.Pstr_value (copy_rec_flag x0, List.map copy_value_binding x1)\n | From.Parsetree.Pstr_primitive x0 ->\n To.Parsetree.Pstr_primitive (copy_value_description x0)\n | From.Parsetree.Pstr_type (x0, x1) ->\n To.Parsetree.Pstr_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | From.Parsetree.Pstr_typext x0 ->\n To.Parsetree.Pstr_typext (copy_type_extension x0)\n | From.Parsetree.Pstr_exception x0 ->\n To.Parsetree.Pstr_exception (copy_extension_constructor x0)\n | From.Parsetree.Pstr_module x0 ->\n To.Parsetree.Pstr_module (copy_module_binding x0)\n | From.Parsetree.Pstr_recmodule x0 ->\n To.Parsetree.Pstr_recmodule (List.map copy_module_binding x0)\n | From.Parsetree.Pstr_modtype x0 ->\n To.Parsetree.Pstr_modtype (copy_module_type_declaration x0)\n | From.Parsetree.Pstr_open x0 ->\n To.Parsetree.Pstr_open (copy_open_description x0)\n | From.Parsetree.Pstr_class x0 ->\n To.Parsetree.Pstr_class (List.map copy_class_declaration x0)\n | From.Parsetree.Pstr_class_type x0 ->\n To.Parsetree.Pstr_class_type (List.map copy_class_type_declaration x0)\n | From.Parsetree.Pstr_include x0 ->\n To.Parsetree.Pstr_include (copy_include_declaration x0)\n | From.Parsetree.Pstr_attribute x0 ->\n To.Parsetree.Pstr_attribute (copy_attribute x0)\n | From.Parsetree.Pstr_extension (x0, x1) ->\n To.Parsetree.Pstr_extension (copy_extension x0, copy_attributes x1)\n\nand copy_include_declaration :\n From.Parsetree.include_declaration -> To.Parsetree.include_declaration =\n fun x -> copy_include_infos copy_module_expr x\n\nand copy_class_declaration :\n From.Parsetree.class_declaration -> To.Parsetree.class_declaration =\n fun x -> copy_class_infos copy_class_expr x\n\nand copy_class_expr : From.Parsetree.class_expr -> To.Parsetree.class_expr =\n fun {\n From.Parsetree.pcl_desc;\n From.Parsetree.pcl_loc;\n From.Parsetree.pcl_attributes;\n } ->\n {\n To.Parsetree.pcl_desc = copy_class_expr_desc pcl_desc;\n To.Parsetree.pcl_loc = copy_location pcl_loc;\n To.Parsetree.pcl_attributes = copy_attributes pcl_attributes;\n }\n\nand copy_class_expr_desc :\n From.Parsetree.class_expr_desc -> To.Parsetree.class_expr_desc = function\n | From.Parsetree.Pcl_constr (x0, x1) ->\n To.Parsetree.Pcl_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Pcl_structure x0 ->\n To.Parsetree.Pcl_structure (copy_class_structure x0)\n | From.Parsetree.Pcl_fun (x0, x1, x2, x3) ->\n To.Parsetree.Pcl_fun\n ( copy_arg_label x0,\n copy_option copy_expression x1,\n copy_pattern x2,\n copy_class_expr x3 )\n | From.Parsetree.Pcl_apply (x0, x1) ->\n To.Parsetree.Pcl_apply\n ( copy_class_expr x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | From.Parsetree.Pcl_let (x0, x1, x2) ->\n To.Parsetree.Pcl_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_class_expr x2)\n | From.Parsetree.Pcl_constraint (x0, x1) ->\n To.Parsetree.Pcl_constraint (copy_class_expr x0, copy_class_type x1)\n | From.Parsetree.Pcl_extension x0 ->\n To.Parsetree.Pcl_extension (copy_extension x0)\n | From.Parsetree.Pcl_open (_, loc, _) ->\n migration_error loc.Location.loc \"module open in class expression\"\n\nand copy_class_structure :\n From.Parsetree.class_structure -> To.Parsetree.class_structure =\n fun { From.Parsetree.pcstr_self; From.Parsetree.pcstr_fields } ->\n {\n To.Parsetree.pcstr_self = copy_pattern pcstr_self;\n To.Parsetree.pcstr_fields = List.map copy_class_field pcstr_fields;\n }\n\nand copy_class_field : From.Parsetree.class_field -> To.Parsetree.class_field =\n fun {\n From.Parsetree.pcf_desc;\n From.Parsetree.pcf_loc;\n From.Parsetree.pcf_attributes;\n } ->\n {\n To.Parsetree.pcf_desc = copy_class_field_desc pcf_desc;\n To.Parsetree.pcf_loc = copy_location pcf_loc;\n To.Parsetree.pcf_attributes = copy_attributes pcf_attributes;\n }\n\nand copy_class_field_desc :\n From.Parsetree.class_field_desc -> To.Parsetree.class_field_desc = function\n | From.Parsetree.Pcf_inherit (x0, x1, x2) ->\n To.Parsetree.Pcf_inherit\n ( copy_override_flag x0,\n copy_class_expr x1,\n copy_option (copy_loc (fun x -> x)) x2 )\n | From.Parsetree.Pcf_val x0 ->\n To.Parsetree.Pcf_val\n (let x0, x1, x2 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_mutable_flag x1,\n copy_class_field_kind x2 ))\n | From.Parsetree.Pcf_method x0 ->\n To.Parsetree.Pcf_method\n (let x0, x1, x2 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_private_flag x1,\n copy_class_field_kind x2 ))\n | From.Parsetree.Pcf_constraint x0 ->\n To.Parsetree.Pcf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | From.Parsetree.Pcf_initializer x0 ->\n To.Parsetree.Pcf_initializer (copy_expression x0)\n | From.Parsetree.Pcf_attribute x0 ->\n To.Parsetree.Pcf_attribute (copy_attribute x0)\n | From.Parsetree.Pcf_extension x0 ->\n To.Parsetree.Pcf_extension (copy_extension x0)\n\nand copy_class_field_kind :\n From.Parsetree.class_field_kind -> To.Parsetree.class_field_kind = function\n | From.Parsetree.Cfk_virtual x0 ->\n To.Parsetree.Cfk_virtual (copy_core_type x0)\n | From.Parsetree.Cfk_concrete (x0, x1) ->\n To.Parsetree.Cfk_concrete (copy_override_flag x0, copy_expression x1)\n\nand copy_module_binding :\n From.Parsetree.module_binding -> To.Parsetree.module_binding =\n fun {\n From.Parsetree.pmb_name;\n From.Parsetree.pmb_expr;\n From.Parsetree.pmb_attributes;\n From.Parsetree.pmb_loc;\n } ->\n {\n To.Parsetree.pmb_name = copy_loc (fun x -> x) pmb_name;\n To.Parsetree.pmb_expr = copy_module_expr pmb_expr;\n To.Parsetree.pmb_attributes = copy_attributes pmb_attributes;\n To.Parsetree.pmb_loc = copy_location pmb_loc;\n }\n\nand copy_module_expr : From.Parsetree.module_expr -> To.Parsetree.module_expr =\n fun {\n From.Parsetree.pmod_desc;\n From.Parsetree.pmod_loc;\n From.Parsetree.pmod_attributes;\n } ->\n {\n To.Parsetree.pmod_desc = copy_module_expr_desc pmod_desc;\n To.Parsetree.pmod_loc = copy_location pmod_loc;\n To.Parsetree.pmod_attributes = copy_attributes pmod_attributes;\n }\n\nand copy_module_expr_desc :\n From.Parsetree.module_expr_desc -> To.Parsetree.module_expr_desc = function\n | From.Parsetree.Pmod_ident x0 ->\n To.Parsetree.Pmod_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pmod_structure x0 ->\n To.Parsetree.Pmod_structure (copy_structure x0)\n | From.Parsetree.Pmod_functor (x0, x1, x2) ->\n To.Parsetree.Pmod_functor\n ( copy_loc (fun x -> x) x0,\n copy_option copy_module_type x1,\n copy_module_expr x2 )\n | From.Parsetree.Pmod_apply (x0, x1) ->\n To.Parsetree.Pmod_apply (copy_module_expr x0, copy_module_expr x1)\n | From.Parsetree.Pmod_constraint (x0, x1) ->\n To.Parsetree.Pmod_constraint (copy_module_expr x0, copy_module_type x1)\n | From.Parsetree.Pmod_unpack x0 ->\n To.Parsetree.Pmod_unpack (copy_expression x0)\n | From.Parsetree.Pmod_extension x0 ->\n To.Parsetree.Pmod_extension (copy_extension x0)\n\nand copy_module_type : From.Parsetree.module_type -> To.Parsetree.module_type =\n fun {\n From.Parsetree.pmty_desc;\n From.Parsetree.pmty_loc;\n From.Parsetree.pmty_attributes;\n } ->\n {\n To.Parsetree.pmty_desc = copy_module_type_desc pmty_desc;\n To.Parsetree.pmty_loc = copy_location pmty_loc;\n To.Parsetree.pmty_attributes = copy_attributes pmty_attributes;\n }\n\nand copy_module_type_desc :\n From.Parsetree.module_type_desc -> To.Parsetree.module_type_desc = function\n | From.Parsetree.Pmty_ident x0 ->\n To.Parsetree.Pmty_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pmty_signature x0 ->\n To.Parsetree.Pmty_signature (copy_signature x0)\n | From.Parsetree.Pmty_functor (x0, x1, x2) ->\n To.Parsetree.Pmty_functor\n ( copy_loc (fun x -> x) x0,\n copy_option copy_module_type x1,\n copy_module_type x2 )\n | From.Parsetree.Pmty_with (x0, x1) ->\n To.Parsetree.Pmty_with\n (copy_module_type x0, List.map copy_with_constraint x1)\n | From.Parsetree.Pmty_typeof x0 ->\n To.Parsetree.Pmty_typeof (copy_module_expr x0)\n | From.Parsetree.Pmty_extension x0 ->\n To.Parsetree.Pmty_extension (copy_extension x0)\n | From.Parsetree.Pmty_alias x0 ->\n To.Parsetree.Pmty_alias (copy_loc copy_longident x0)\n\nand copy_with_constraint :\n From.Parsetree.with_constraint -> To.Parsetree.with_constraint = function\n | From.Parsetree.Pwith_type (x0, x1) ->\n To.Parsetree.Pwith_type\n (copy_loc copy_longident x0, copy_type_declaration x1)\n | From.Parsetree.Pwith_module (x0, x1) ->\n To.Parsetree.Pwith_module\n (copy_loc copy_longident x0, copy_loc copy_longident x1)\n | From.Parsetree.Pwith_typesubst ({ txt = Longident.Lident _; _ }, x0) ->\n To.Parsetree.Pwith_typesubst (copy_type_declaration x0)\n | From.Parsetree.Pwith_modsubst ({ txt = Longident.Lident x0; loc }, x1) ->\n To.Parsetree.Pwith_modsubst ({ txt = x0; loc }, copy_loc copy_longident x1)\n | From.Parsetree.Pwith_typesubst ({ loc; _ }, _x0) ->\n migration_error loc \"type substitution inside a submodule\"\n | From.Parsetree.Pwith_modsubst ({ loc; _ }, _x1) ->\n migration_error loc \"module substitution inside a submodule\"\n\nand copy_signature : From.Parsetree.signature -> To.Parsetree.signature =\n fun x -> List.map copy_signature_item x\n\nand copy_signature_item :\n From.Parsetree.signature_item -> To.Parsetree.signature_item =\n fun { From.Parsetree.psig_desc; From.Parsetree.psig_loc } ->\n {\n To.Parsetree.psig_desc = copy_signature_item_desc psig_desc;\n To.Parsetree.psig_loc = copy_location psig_loc;\n }\n\nand copy_signature_item_desc :\n From.Parsetree.signature_item_desc -> To.Parsetree.signature_item_desc =\n function\n | From.Parsetree.Psig_value x0 ->\n To.Parsetree.Psig_value (copy_value_description x0)\n | From.Parsetree.Psig_type (x0, x1) ->\n To.Parsetree.Psig_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | From.Parsetree.Psig_typext x0 ->\n To.Parsetree.Psig_typext (copy_type_extension x0)\n | From.Parsetree.Psig_exception x0 ->\n To.Parsetree.Psig_exception (copy_extension_constructor x0)\n | From.Parsetree.Psig_module x0 ->\n To.Parsetree.Psig_module (copy_module_declaration x0)\n | From.Parsetree.Psig_recmodule x0 ->\n To.Parsetree.Psig_recmodule (List.map copy_module_declaration x0)\n | From.Parsetree.Psig_modtype x0 ->\n To.Parsetree.Psig_modtype (copy_module_type_declaration x0)\n | From.Parsetree.Psig_open x0 ->\n To.Parsetree.Psig_open (copy_open_description x0)\n | From.Parsetree.Psig_include x0 ->\n To.Parsetree.Psig_include (copy_include_description x0)\n | From.Parsetree.Psig_class x0 ->\n To.Parsetree.Psig_class (List.map copy_class_description x0)\n | From.Parsetree.Psig_class_type x0 ->\n To.Parsetree.Psig_class_type (List.map copy_class_type_declaration x0)\n | From.Parsetree.Psig_attribute x0 ->\n To.Parsetree.Psig_attribute (copy_attribute x0)\n | From.Parsetree.Psig_extension (x0, x1) ->\n To.Parsetree.Psig_extension (copy_extension x0, copy_attributes x1)\n\nand copy_class_type_declaration :\n From.Parsetree.class_type_declaration -> To.Parsetree.class_type_declaration\n =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_description :\n From.Parsetree.class_description -> To.Parsetree.class_description =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_type : From.Parsetree.class_type -> To.Parsetree.class_type =\n fun {\n From.Parsetree.pcty_desc;\n From.Parsetree.pcty_loc;\n From.Parsetree.pcty_attributes;\n } ->\n {\n To.Parsetree.pcty_desc = copy_class_type_desc pcty_desc;\n To.Parsetree.pcty_loc = copy_location pcty_loc;\n To.Parsetree.pcty_attributes = copy_attributes pcty_attributes;\n }\n\nand copy_class_type_desc :\n From.Parsetree.class_type_desc -> To.Parsetree.class_type_desc = function\n | From.Parsetree.Pcty_constr (x0, x1) ->\n To.Parsetree.Pcty_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Pcty_signature x0 ->\n To.Parsetree.Pcty_signature (copy_class_signature x0)\n | From.Parsetree.Pcty_arrow (x0, x1, x2) ->\n To.Parsetree.Pcty_arrow\n (copy_arg_label x0, copy_core_type x1, copy_class_type x2)\n | From.Parsetree.Pcty_extension x0 ->\n To.Parsetree.Pcty_extension (copy_extension x0)\n | From.Parsetree.Pcty_open (_, loc, _) ->\n migration_error loc.Location.loc \"module open in class type\"\n\nand copy_class_signature :\n From.Parsetree.class_signature -> To.Parsetree.class_signature =\n fun { From.Parsetree.pcsig_self; From.Parsetree.pcsig_fields } ->\n {\n To.Parsetree.pcsig_self = copy_core_type pcsig_self;\n To.Parsetree.pcsig_fields = List.map copy_class_type_field pcsig_fields;\n }\n\nand copy_class_type_field :\n From.Parsetree.class_type_field -> To.Parsetree.class_type_field =\n fun {\n From.Parsetree.pctf_desc;\n From.Parsetree.pctf_loc;\n From.Parsetree.pctf_attributes;\n } ->\n {\n To.Parsetree.pctf_desc = copy_class_type_field_desc pctf_desc;\n To.Parsetree.pctf_loc = copy_location pctf_loc;\n To.Parsetree.pctf_attributes = copy_attributes pctf_attributes;\n }\n\nand copy_class_type_field_desc :\n From.Parsetree.class_type_field_desc -> To.Parsetree.class_type_field_desc =\n function\n | From.Parsetree.Pctf_inherit x0 ->\n To.Parsetree.Pctf_inherit (copy_class_type x0)\n | From.Parsetree.Pctf_val x0 ->\n To.Parsetree.Pctf_val\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_mutable_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | From.Parsetree.Pctf_method x0 ->\n To.Parsetree.Pctf_method\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_private_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | From.Parsetree.Pctf_constraint x0 ->\n To.Parsetree.Pctf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | From.Parsetree.Pctf_attribute x0 ->\n To.Parsetree.Pctf_attribute (copy_attribute x0)\n | From.Parsetree.Pctf_extension x0 ->\n To.Parsetree.Pctf_extension (copy_extension x0)\n\nand copy_extension : From.Parsetree.extension -> To.Parsetree.extension =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_class_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 From.Parsetree.class_infos ->\n 'g0 To.Parsetree.class_infos =\n fun f0\n {\n From.Parsetree.pci_virt;\n From.Parsetree.pci_params;\n From.Parsetree.pci_name;\n From.Parsetree.pci_expr;\n From.Parsetree.pci_loc;\n From.Parsetree.pci_attributes;\n } ->\n {\n To.Parsetree.pci_virt = copy_virtual_flag pci_virt;\n To.Parsetree.pci_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n pci_params;\n To.Parsetree.pci_name = copy_loc (fun x -> x) pci_name;\n To.Parsetree.pci_expr = f0 pci_expr;\n To.Parsetree.pci_loc = copy_location pci_loc;\n To.Parsetree.pci_attributes = copy_attributes pci_attributes;\n }\n\nand copy_virtual_flag : From.Asttypes.virtual_flag -> To.Asttypes.virtual_flag =\n function\n | From.Asttypes.Virtual -> To.Asttypes.Virtual\n | From.Asttypes.Concrete -> To.Asttypes.Concrete\n\nand copy_include_description :\n From.Parsetree.include_description -> To.Parsetree.include_description =\n fun x -> copy_include_infos copy_module_type x\n\nand copy_include_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 From.Parsetree.include_infos ->\n 'g0 To.Parsetree.include_infos =\n fun f0\n {\n From.Parsetree.pincl_mod;\n From.Parsetree.pincl_loc;\n From.Parsetree.pincl_attributes;\n } ->\n {\n To.Parsetree.pincl_mod = f0 pincl_mod;\n To.Parsetree.pincl_loc = copy_location pincl_loc;\n To.Parsetree.pincl_attributes = copy_attributes pincl_attributes;\n }\n\nand copy_open_description :\n From.Parsetree.open_description -> To.Parsetree.open_description =\n fun {\n From.Parsetree.popen_lid;\n From.Parsetree.popen_override;\n From.Parsetree.popen_loc;\n From.Parsetree.popen_attributes;\n } ->\n {\n To.Parsetree.popen_lid = copy_loc copy_longident popen_lid;\n To.Parsetree.popen_override = copy_override_flag popen_override;\n To.Parsetree.popen_loc = copy_location popen_loc;\n To.Parsetree.popen_attributes = copy_attributes popen_attributes;\n }\n\nand copy_override_flag :\n From.Asttypes.override_flag -> To.Asttypes.override_flag = function\n | From.Asttypes.Override -> To.Asttypes.Override\n | From.Asttypes.Fresh -> To.Asttypes.Fresh\n\nand copy_module_type_declaration :\n From.Parsetree.module_type_declaration ->\n To.Parsetree.module_type_declaration =\n fun {\n From.Parsetree.pmtd_name;\n From.Parsetree.pmtd_type;\n From.Parsetree.pmtd_attributes;\n From.Parsetree.pmtd_loc;\n } ->\n {\n To.Parsetree.pmtd_name = copy_loc (fun x -> x) pmtd_name;\n To.Parsetree.pmtd_type = copy_option copy_module_type pmtd_type;\n To.Parsetree.pmtd_attributes = copy_attributes pmtd_attributes;\n To.Parsetree.pmtd_loc = copy_location pmtd_loc;\n }\n\nand copy_module_declaration :\n From.Parsetree.module_declaration -> To.Parsetree.module_declaration =\n fun {\n From.Parsetree.pmd_name;\n From.Parsetree.pmd_type;\n From.Parsetree.pmd_attributes;\n From.Parsetree.pmd_loc;\n } ->\n {\n To.Parsetree.pmd_name = copy_loc (fun x -> x) pmd_name;\n To.Parsetree.pmd_type = copy_module_type pmd_type;\n To.Parsetree.pmd_attributes = copy_attributes pmd_attributes;\n To.Parsetree.pmd_loc = copy_location pmd_loc;\n }\n\nand copy_type_extension :\n From.Parsetree.type_extension -> To.Parsetree.type_extension =\n fun {\n From.Parsetree.ptyext_path;\n From.Parsetree.ptyext_params;\n From.Parsetree.ptyext_constructors;\n From.Parsetree.ptyext_private;\n From.Parsetree.ptyext_attributes;\n } ->\n {\n To.Parsetree.ptyext_path = copy_loc copy_longident ptyext_path;\n To.Parsetree.ptyext_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptyext_params;\n To.Parsetree.ptyext_constructors =\n List.map copy_extension_constructor ptyext_constructors;\n To.Parsetree.ptyext_private = copy_private_flag ptyext_private;\n To.Parsetree.ptyext_attributes = copy_attributes ptyext_attributes;\n }\n\nand copy_extension_constructor :\n From.Parsetree.extension_constructor -> To.Parsetree.extension_constructor =\n fun {\n From.Parsetree.pext_name;\n From.Parsetree.pext_kind;\n From.Parsetree.pext_loc;\n From.Parsetree.pext_attributes;\n } ->\n {\n To.Parsetree.pext_name = copy_loc (fun x -> x) pext_name;\n To.Parsetree.pext_kind = copy_extension_constructor_kind pext_kind;\n To.Parsetree.pext_loc = copy_location pext_loc;\n To.Parsetree.pext_attributes = copy_attributes pext_attributes;\n }\n\nand copy_extension_constructor_kind :\n From.Parsetree.extension_constructor_kind ->\n To.Parsetree.extension_constructor_kind = function\n | From.Parsetree.Pext_decl (x0, x1) ->\n To.Parsetree.Pext_decl\n (copy_constructor_arguments x0, copy_option copy_core_type x1)\n | From.Parsetree.Pext_rebind x0 ->\n To.Parsetree.Pext_rebind (copy_loc copy_longident x0)\n\nand copy_type_declaration :\n From.Parsetree.type_declaration -> To.Parsetree.type_declaration =\n fun {\n From.Parsetree.ptype_name;\n From.Parsetree.ptype_params;\n From.Parsetree.ptype_cstrs;\n From.Parsetree.ptype_kind;\n From.Parsetree.ptype_private;\n From.Parsetree.ptype_manifest;\n From.Parsetree.ptype_attributes;\n From.Parsetree.ptype_loc;\n } ->\n {\n To.Parsetree.ptype_name = copy_loc (fun x -> x) ptype_name;\n To.Parsetree.ptype_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptype_params;\n To.Parsetree.ptype_cstrs =\n List.map\n (fun x ->\n let x0, x1, x2 = x in\n (copy_core_type x0, copy_core_type x1, copy_location x2))\n ptype_cstrs;\n To.Parsetree.ptype_kind = copy_type_kind ptype_kind;\n To.Parsetree.ptype_private = copy_private_flag ptype_private;\n To.Parsetree.ptype_manifest = copy_option copy_core_type ptype_manifest;\n To.Parsetree.ptype_attributes = copy_attributes ptype_attributes;\n To.Parsetree.ptype_loc = copy_location ptype_loc;\n }\n\nand copy_private_flag : From.Asttypes.private_flag -> To.Asttypes.private_flag =\n function\n | From.Asttypes.Private -> To.Asttypes.Private\n | From.Asttypes.Public -> To.Asttypes.Public\n\nand copy_type_kind : From.Parsetree.type_kind -> To.Parsetree.type_kind =\n function\n | From.Parsetree.Ptype_abstract -> To.Parsetree.Ptype_abstract\n | From.Parsetree.Ptype_variant x0 ->\n To.Parsetree.Ptype_variant (List.map copy_constructor_declaration x0)\n | From.Parsetree.Ptype_record x0 ->\n To.Parsetree.Ptype_record (List.map copy_label_declaration x0)\n | From.Parsetree.Ptype_open -> To.Parsetree.Ptype_open\n\nand copy_constructor_declaration :\n From.Parsetree.constructor_declaration ->\n To.Parsetree.constructor_declaration =\n fun {\n From.Parsetree.pcd_name;\n From.Parsetree.pcd_args;\n From.Parsetree.pcd_res;\n From.Parsetree.pcd_loc;\n From.Parsetree.pcd_attributes;\n } ->\n {\n To.Parsetree.pcd_name = copy_loc (fun x -> x) pcd_name;\n To.Parsetree.pcd_args = copy_constructor_arguments pcd_args;\n To.Parsetree.pcd_res = copy_option copy_core_type pcd_res;\n To.Parsetree.pcd_loc = copy_location pcd_loc;\n To.Parsetree.pcd_attributes = copy_attributes pcd_attributes;\n }\n\nand copy_constructor_arguments :\n From.Parsetree.constructor_arguments -> To.Parsetree.constructor_arguments =\n function\n | From.Parsetree.Pcstr_tuple x0 ->\n To.Parsetree.Pcstr_tuple (List.map copy_core_type x0)\n | From.Parsetree.Pcstr_record x0 ->\n To.Parsetree.Pcstr_record (List.map copy_label_declaration x0)\n\nand copy_label_declaration :\n From.Parsetree.label_declaration -> To.Parsetree.label_declaration =\n fun {\n From.Parsetree.pld_name;\n From.Parsetree.pld_mutable;\n From.Parsetree.pld_type;\n From.Parsetree.pld_loc;\n From.Parsetree.pld_attributes;\n } ->\n {\n To.Parsetree.pld_name = copy_loc (fun x -> x) pld_name;\n To.Parsetree.pld_mutable = copy_mutable_flag pld_mutable;\n To.Parsetree.pld_type = copy_core_type pld_type;\n To.Parsetree.pld_loc = copy_location pld_loc;\n To.Parsetree.pld_attributes = copy_attributes pld_attributes;\n }\n\nand copy_mutable_flag : From.Asttypes.mutable_flag -> To.Asttypes.mutable_flag =\n function\n | From.Asttypes.Immutable -> To.Asttypes.Immutable\n | From.Asttypes.Mutable -> To.Asttypes.Mutable\n\nand copy_variance : From.Asttypes.variance -> To.Asttypes.variance = function\n | From.Asttypes.Covariant -> To.Asttypes.Covariant\n | From.Asttypes.Contravariant -> To.Asttypes.Contravariant\n | From.Asttypes.Invariant -> To.Asttypes.Invariant\n\nand copy_value_description :\n From.Parsetree.value_description -> To.Parsetree.value_description =\n fun {\n From.Parsetree.pval_name;\n From.Parsetree.pval_type;\n From.Parsetree.pval_prim;\n From.Parsetree.pval_attributes;\n From.Parsetree.pval_loc;\n } ->\n {\n To.Parsetree.pval_name = copy_loc (fun x -> x) pval_name;\n To.Parsetree.pval_type = copy_core_type pval_type;\n To.Parsetree.pval_prim = List.map (fun x -> x) pval_prim;\n To.Parsetree.pval_attributes = copy_attributes pval_attributes;\n To.Parsetree.pval_loc = copy_location pval_loc;\n }\n\nand copy_arg_label : From.Asttypes.arg_label -> To.Asttypes.arg_label = function\n | From.Asttypes.Nolabel -> To.Asttypes.Nolabel\n | From.Asttypes.Labelled x0 -> To.Asttypes.Labelled x0\n | From.Asttypes.Optional x0 -> To.Asttypes.Optional x0\n\nand copy_closed_flag : From.Asttypes.closed_flag -> To.Asttypes.closed_flag =\n function\n | From.Asttypes.Closed -> To.Asttypes.Closed\n | From.Asttypes.Open -> To.Asttypes.Open\n\nand copy_label : From.Asttypes.label -> To.Asttypes.label = fun x -> x\n\nand copy_rec_flag : From.Asttypes.rec_flag -> To.Asttypes.rec_flag = function\n | From.Asttypes.Nonrecursive -> To.Asttypes.Nonrecursive\n | From.Asttypes.Recursive -> To.Asttypes.Recursive\n\nand copy_constant : From.Parsetree.constant -> To.Parsetree.constant = function\n | From.Parsetree.Pconst_integer (x0, x1) ->\n To.Parsetree.Pconst_integer (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pconst_char x0 -> To.Parsetree.Pconst_char x0\n | From.Parsetree.Pconst_string (x0, x1) ->\n To.Parsetree.Pconst_string (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pconst_float (x0, x1) ->\n To.Parsetree.Pconst_float (x0, copy_option (fun x -> x) x1)\n\nand copy_option : 'f0 'g0. ('f0 -> 'g0) -> 'f0 option -> 'g0 option =\n fun f0 -> function None -> None | Some x0 -> Some (f0 x0)\n\nand copy_longident : Longident.t -> Longident.t = fun x -> x\n\nand copy_loc :\n 'f0 'g0. ('f0 -> 'g0) -> 'f0 From.Asttypes.loc -> 'g0 To.Asttypes.loc =\n fun f0 { From.Asttypes.txt; From.Asttypes.loc } ->\n { To.Asttypes.txt = f0 txt; To.Asttypes.loc = copy_location loc }\n\nand copy_location : Location.t -> Location.t = fun x -> x\nand copy_bool : bool -> bool = function false -> false | true -> true\n\nlet rec copy_toplevel_phrase :\n From.Parsetree.toplevel_phrase -> To.Parsetree.toplevel_phrase = function\n | From.Parsetree.Ptop_def x0 -> To.Parsetree.Ptop_def (copy_structure x0)\n | From.Parsetree.Ptop_dir (x0, x1) ->\n To.Parsetree.Ptop_dir (x0, copy_directive_argument x1)\n\nand copy_directive_argument :\n From.Parsetree.directive_argument -> To.Parsetree.directive_argument =\n function\n | From.Parsetree.Pdir_none -> To.Parsetree.Pdir_none\n | From.Parsetree.Pdir_string x0 -> To.Parsetree.Pdir_string x0\n | From.Parsetree.Pdir_int (x0, x1) ->\n To.Parsetree.Pdir_int (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pdir_ident x0 -> To.Parsetree.Pdir_ident (copy_longident x0)\n | From.Parsetree.Pdir_bool x0 -> To.Parsetree.Pdir_bool (copy_bool x0)\n\nlet copy_cases x = List.map copy_case x\nlet copy_pat = copy_pattern\nlet copy_expr = copy_expression\nlet copy_typ = copy_core_type\n","(**************************************************************************)\n(* *)\n(* OCaml Migrate Parsetree *)\n(* *)\n(* Frédéric Bour *)\n(* Alain Frisch, LexiFi *)\n(* *)\n(* Copyright 2017 Institut National de Recherche en Informatique et *)\n(* en Automatique (INRIA). *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nmodule From = Ast_405\nmodule To = Ast_406\n\nlet rec copy_expression : From.Parsetree.expression -> To.Parsetree.expression =\n fun {\n From.Parsetree.pexp_desc;\n From.Parsetree.pexp_loc;\n From.Parsetree.pexp_attributes;\n } ->\n {\n To.Parsetree.pexp_desc = copy_expression_desc pexp_desc;\n To.Parsetree.pexp_loc = copy_location pexp_loc;\n To.Parsetree.pexp_attributes = copy_attributes pexp_attributes;\n }\n\nand copy_expression_desc :\n From.Parsetree.expression_desc -> To.Parsetree.expression_desc = function\n | From.Parsetree.Pexp_ident x0 ->\n To.Parsetree.Pexp_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pexp_constant x0 ->\n To.Parsetree.Pexp_constant (copy_constant x0)\n | From.Parsetree.Pexp_let (x0, x1, x2) ->\n To.Parsetree.Pexp_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_expression x2)\n | From.Parsetree.Pexp_function x0 ->\n To.Parsetree.Pexp_function (List.map copy_case x0)\n | From.Parsetree.Pexp_fun (x0, x1, x2, x3) ->\n To.Parsetree.Pexp_fun\n ( copy_arg_label x0,\n copy_option copy_expression x1,\n copy_pattern x2,\n copy_expression x3 )\n | From.Parsetree.Pexp_apply (x0, x1) ->\n To.Parsetree.Pexp_apply\n ( copy_expression x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | From.Parsetree.Pexp_match (x0, x1) ->\n To.Parsetree.Pexp_match (copy_expression x0, List.map copy_case x1)\n | From.Parsetree.Pexp_try (x0, x1) ->\n To.Parsetree.Pexp_try (copy_expression x0, List.map copy_case x1)\n | From.Parsetree.Pexp_tuple x0 ->\n To.Parsetree.Pexp_tuple (List.map copy_expression x0)\n | From.Parsetree.Pexp_construct (x0, x1) ->\n To.Parsetree.Pexp_construct\n (copy_loc copy_longident x0, copy_option copy_expression x1)\n | From.Parsetree.Pexp_variant (x0, x1) ->\n To.Parsetree.Pexp_variant (copy_label x0, copy_option copy_expression x1)\n | From.Parsetree.Pexp_record (x0, x1) ->\n To.Parsetree.Pexp_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_expression x1))\n x0,\n copy_option copy_expression x1 )\n | From.Parsetree.Pexp_field (x0, x1) ->\n To.Parsetree.Pexp_field (copy_expression x0, copy_loc copy_longident x1)\n | From.Parsetree.Pexp_setfield (x0, x1, x2) ->\n To.Parsetree.Pexp_setfield\n (copy_expression x0, copy_loc copy_longident x1, copy_expression x2)\n | From.Parsetree.Pexp_array x0 ->\n To.Parsetree.Pexp_array (List.map copy_expression x0)\n | From.Parsetree.Pexp_ifthenelse (x0, x1, x2) ->\n To.Parsetree.Pexp_ifthenelse\n (copy_expression x0, copy_expression x1, copy_option copy_expression x2)\n | From.Parsetree.Pexp_sequence (x0, x1) ->\n To.Parsetree.Pexp_sequence (copy_expression x0, copy_expression x1)\n | From.Parsetree.Pexp_while (x0, x1) ->\n To.Parsetree.Pexp_while (copy_expression x0, copy_expression x1)\n | From.Parsetree.Pexp_for (x0, x1, x2, x3, x4) ->\n To.Parsetree.Pexp_for\n ( copy_pattern x0,\n copy_expression x1,\n copy_expression x2,\n copy_direction_flag x3,\n copy_expression x4 )\n | From.Parsetree.Pexp_constraint (x0, x1) ->\n To.Parsetree.Pexp_constraint (copy_expression x0, copy_core_type x1)\n | From.Parsetree.Pexp_coerce (x0, x1, x2) ->\n To.Parsetree.Pexp_coerce\n (copy_expression x0, copy_option copy_core_type x1, copy_core_type x2)\n | From.Parsetree.Pexp_send (x0, x1) ->\n To.Parsetree.Pexp_send (copy_expression x0, copy_loc (fun x -> x) x1)\n | From.Parsetree.Pexp_new x0 ->\n To.Parsetree.Pexp_new (copy_loc copy_longident x0)\n | From.Parsetree.Pexp_setinstvar (x0, x1) ->\n To.Parsetree.Pexp_setinstvar (copy_loc (fun x -> x) x0, copy_expression x1)\n | From.Parsetree.Pexp_override x0 ->\n To.Parsetree.Pexp_override\n (List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_expression x1))\n x0)\n | From.Parsetree.Pexp_letmodule (x0, x1, x2) ->\n To.Parsetree.Pexp_letmodule\n (copy_loc (fun x -> x) x0, copy_module_expr x1, copy_expression x2)\n | From.Parsetree.Pexp_letexception (x0, x1) ->\n To.Parsetree.Pexp_letexception\n (copy_extension_constructor x0, copy_expression x1)\n | From.Parsetree.Pexp_assert x0 ->\n To.Parsetree.Pexp_assert (copy_expression x0)\n | From.Parsetree.Pexp_lazy x0 -> To.Parsetree.Pexp_lazy (copy_expression x0)\n | From.Parsetree.Pexp_poly (x0, x1) ->\n To.Parsetree.Pexp_poly (copy_expression x0, copy_option copy_core_type x1)\n | From.Parsetree.Pexp_object x0 ->\n To.Parsetree.Pexp_object (copy_class_structure x0)\n | From.Parsetree.Pexp_newtype (x0, x1) ->\n To.Parsetree.Pexp_newtype (copy_loc (fun x -> x) x0, copy_expression x1)\n | From.Parsetree.Pexp_pack x0 -> To.Parsetree.Pexp_pack (copy_module_expr x0)\n | From.Parsetree.Pexp_open (x0, x1, x2) ->\n To.Parsetree.Pexp_open\n (copy_override_flag x0, copy_loc copy_longident x1, copy_expression x2)\n | From.Parsetree.Pexp_extension x0 ->\n To.Parsetree.Pexp_extension (copy_extension x0)\n | From.Parsetree.Pexp_unreachable -> To.Parsetree.Pexp_unreachable\n\nand copy_direction_flag :\n From.Asttypes.direction_flag -> To.Asttypes.direction_flag = function\n | From.Asttypes.Upto -> To.Asttypes.Upto\n | From.Asttypes.Downto -> To.Asttypes.Downto\n\nand copy_case : From.Parsetree.case -> To.Parsetree.case =\n fun { From.Parsetree.pc_lhs; From.Parsetree.pc_guard; From.Parsetree.pc_rhs } ->\n {\n To.Parsetree.pc_lhs = copy_pattern pc_lhs;\n To.Parsetree.pc_guard = copy_option copy_expression pc_guard;\n To.Parsetree.pc_rhs = copy_expression pc_rhs;\n }\n\nand copy_value_binding :\n From.Parsetree.value_binding -> To.Parsetree.value_binding =\n fun {\n From.Parsetree.pvb_pat;\n From.Parsetree.pvb_expr;\n From.Parsetree.pvb_attributes;\n From.Parsetree.pvb_loc;\n } ->\n {\n To.Parsetree.pvb_pat = copy_pattern pvb_pat;\n To.Parsetree.pvb_expr = copy_expression pvb_expr;\n To.Parsetree.pvb_attributes = copy_attributes pvb_attributes;\n To.Parsetree.pvb_loc = copy_location pvb_loc;\n }\n\nand copy_pattern : From.Parsetree.pattern -> To.Parsetree.pattern =\n fun {\n From.Parsetree.ppat_desc;\n From.Parsetree.ppat_loc;\n From.Parsetree.ppat_attributes;\n } ->\n {\n To.Parsetree.ppat_desc = copy_pattern_desc ppat_desc;\n To.Parsetree.ppat_loc = copy_location ppat_loc;\n To.Parsetree.ppat_attributes = copy_attributes ppat_attributes;\n }\n\nand copy_pattern_desc : From.Parsetree.pattern_desc -> To.Parsetree.pattern_desc\n = function\n | From.Parsetree.Ppat_any -> To.Parsetree.Ppat_any\n | From.Parsetree.Ppat_var x0 ->\n To.Parsetree.Ppat_var (copy_loc (fun x -> x) x0)\n | From.Parsetree.Ppat_alias (x0, x1) ->\n To.Parsetree.Ppat_alias (copy_pattern x0, copy_loc (fun x -> x) x1)\n | From.Parsetree.Ppat_constant x0 ->\n To.Parsetree.Ppat_constant (copy_constant x0)\n | From.Parsetree.Ppat_interval (x0, x1) ->\n To.Parsetree.Ppat_interval (copy_constant x0, copy_constant x1)\n | From.Parsetree.Ppat_tuple x0 ->\n To.Parsetree.Ppat_tuple (List.map copy_pattern x0)\n | From.Parsetree.Ppat_construct (x0, x1) ->\n To.Parsetree.Ppat_construct\n (copy_loc copy_longident x0, copy_option copy_pattern x1)\n | From.Parsetree.Ppat_variant (x0, x1) ->\n To.Parsetree.Ppat_variant (copy_label x0, copy_option copy_pattern x1)\n | From.Parsetree.Ppat_record (x0, x1) ->\n To.Parsetree.Ppat_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_pattern x1))\n x0,\n copy_closed_flag x1 )\n | From.Parsetree.Ppat_array x0 ->\n To.Parsetree.Ppat_array (List.map copy_pattern x0)\n | From.Parsetree.Ppat_or (x0, x1) ->\n To.Parsetree.Ppat_or (copy_pattern x0, copy_pattern x1)\n | From.Parsetree.Ppat_constraint (x0, x1) ->\n To.Parsetree.Ppat_constraint (copy_pattern x0, copy_core_type x1)\n | From.Parsetree.Ppat_type x0 ->\n To.Parsetree.Ppat_type (copy_loc copy_longident x0)\n | From.Parsetree.Ppat_lazy x0 -> To.Parsetree.Ppat_lazy (copy_pattern x0)\n | From.Parsetree.Ppat_unpack x0 ->\n To.Parsetree.Ppat_unpack (copy_loc (fun x -> x) x0)\n | From.Parsetree.Ppat_exception x0 ->\n To.Parsetree.Ppat_exception (copy_pattern x0)\n | From.Parsetree.Ppat_extension x0 ->\n To.Parsetree.Ppat_extension (copy_extension x0)\n | From.Parsetree.Ppat_open (x0, x1) ->\n To.Parsetree.Ppat_open (copy_loc copy_longident x0, copy_pattern x1)\n\nand copy_core_type : From.Parsetree.core_type -> To.Parsetree.core_type =\n fun {\n From.Parsetree.ptyp_desc;\n From.Parsetree.ptyp_loc;\n From.Parsetree.ptyp_attributes;\n } ->\n {\n To.Parsetree.ptyp_desc = copy_core_type_desc ptyp_desc;\n To.Parsetree.ptyp_loc = copy_location ptyp_loc;\n To.Parsetree.ptyp_attributes = copy_attributes ptyp_attributes;\n }\n\nand copy_core_type_desc :\n From.Parsetree.core_type_desc -> To.Parsetree.core_type_desc = function\n | From.Parsetree.Ptyp_any -> To.Parsetree.Ptyp_any\n | From.Parsetree.Ptyp_var x0 -> To.Parsetree.Ptyp_var x0\n | From.Parsetree.Ptyp_arrow (x0, x1, x2) ->\n To.Parsetree.Ptyp_arrow\n (copy_arg_label x0, copy_core_type x1, copy_core_type x2)\n | From.Parsetree.Ptyp_tuple x0 ->\n To.Parsetree.Ptyp_tuple (List.map copy_core_type x0)\n | From.Parsetree.Ptyp_constr (x0, x1) ->\n To.Parsetree.Ptyp_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Ptyp_object (x0, x1) ->\n To.Parsetree.Ptyp_object\n ( List.map\n (fun x ->\n let x0, x1, x2 = x in\n To.Parsetree.Otag\n (copy_loc (fun x -> x) x0, copy_attributes x1, copy_core_type x2))\n x0,\n copy_closed_flag x1 )\n | From.Parsetree.Ptyp_class (x0, x1) ->\n To.Parsetree.Ptyp_class\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Ptyp_alias (x0, x1) ->\n To.Parsetree.Ptyp_alias (copy_core_type x0, x1)\n | From.Parsetree.Ptyp_variant (x0, x1, x2) ->\n To.Parsetree.Ptyp_variant\n ( List.map copy_row_field x0,\n copy_closed_flag x1,\n copy_option (fun x -> List.map copy_label x) x2 )\n | From.Parsetree.Ptyp_poly (x0, x1) ->\n To.Parsetree.Ptyp_poly\n (List.map (fun x -> copy_loc (fun x -> x) x) x0, copy_core_type x1)\n | From.Parsetree.Ptyp_package x0 ->\n To.Parsetree.Ptyp_package (copy_package_type x0)\n | From.Parsetree.Ptyp_extension x0 ->\n To.Parsetree.Ptyp_extension (copy_extension x0)\n\nand copy_package_type : From.Parsetree.package_type -> To.Parsetree.package_type\n =\n fun x ->\n let x0, x1 = x in\n ( copy_loc copy_longident x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_core_type x1))\n x1 )\n\nand copy_row_field : From.Parsetree.row_field -> To.Parsetree.row_field =\n function\n | From.Parsetree.Rtag (x0, x1, x2, x3) ->\n To.Parsetree.Rtag\n ( { txt = copy_label x0; loc = Location.none },\n copy_attributes x1,\n copy_bool x2,\n List.map copy_core_type x3 )\n | From.Parsetree.Rinherit x0 -> To.Parsetree.Rinherit (copy_core_type x0)\n\nand copy_attributes : From.Parsetree.attributes -> To.Parsetree.attributes =\n fun x -> List.map copy_attribute x\n\nand copy_attribute : From.Parsetree.attribute -> To.Parsetree.attribute =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_payload : From.Parsetree.payload -> To.Parsetree.payload = function\n | From.Parsetree.PStr x0 -> To.Parsetree.PStr (copy_structure x0)\n | From.Parsetree.PSig x0 -> To.Parsetree.PSig (copy_signature x0)\n | From.Parsetree.PTyp x0 -> To.Parsetree.PTyp (copy_core_type x0)\n | From.Parsetree.PPat (x0, x1) ->\n To.Parsetree.PPat (copy_pattern x0, copy_option copy_expression x1)\n\nand copy_structure : From.Parsetree.structure -> To.Parsetree.structure =\n fun x -> List.map copy_structure_item x\n\nand copy_structure_item :\n From.Parsetree.structure_item -> To.Parsetree.structure_item =\n fun { From.Parsetree.pstr_desc; From.Parsetree.pstr_loc } ->\n {\n To.Parsetree.pstr_desc = copy_structure_item_desc pstr_desc;\n To.Parsetree.pstr_loc = copy_location pstr_loc;\n }\n\nand copy_structure_item_desc :\n From.Parsetree.structure_item_desc -> To.Parsetree.structure_item_desc =\n function\n | From.Parsetree.Pstr_eval (x0, x1) ->\n To.Parsetree.Pstr_eval (copy_expression x0, copy_attributes x1)\n | From.Parsetree.Pstr_value (x0, x1) ->\n To.Parsetree.Pstr_value (copy_rec_flag x0, List.map copy_value_binding x1)\n | From.Parsetree.Pstr_primitive x0 ->\n To.Parsetree.Pstr_primitive (copy_value_description x0)\n | From.Parsetree.Pstr_type (x0, x1) ->\n To.Parsetree.Pstr_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | From.Parsetree.Pstr_typext x0 ->\n To.Parsetree.Pstr_typext (copy_type_extension x0)\n | From.Parsetree.Pstr_exception x0 ->\n To.Parsetree.Pstr_exception (copy_extension_constructor x0)\n | From.Parsetree.Pstr_module x0 ->\n To.Parsetree.Pstr_module (copy_module_binding x0)\n | From.Parsetree.Pstr_recmodule x0 ->\n To.Parsetree.Pstr_recmodule (List.map copy_module_binding x0)\n | From.Parsetree.Pstr_modtype x0 ->\n To.Parsetree.Pstr_modtype (copy_module_type_declaration x0)\n | From.Parsetree.Pstr_open x0 ->\n To.Parsetree.Pstr_open (copy_open_description x0)\n | From.Parsetree.Pstr_class x0 ->\n To.Parsetree.Pstr_class (List.map copy_class_declaration x0)\n | From.Parsetree.Pstr_class_type x0 ->\n To.Parsetree.Pstr_class_type (List.map copy_class_type_declaration x0)\n | From.Parsetree.Pstr_include x0 ->\n To.Parsetree.Pstr_include (copy_include_declaration x0)\n | From.Parsetree.Pstr_attribute x0 ->\n To.Parsetree.Pstr_attribute (copy_attribute x0)\n | From.Parsetree.Pstr_extension (x0, x1) ->\n To.Parsetree.Pstr_extension (copy_extension x0, copy_attributes x1)\n\nand copy_include_declaration :\n From.Parsetree.include_declaration -> To.Parsetree.include_declaration =\n fun x -> copy_include_infos copy_module_expr x\n\nand copy_class_declaration :\n From.Parsetree.class_declaration -> To.Parsetree.class_declaration =\n fun x -> copy_class_infos copy_class_expr x\n\nand copy_class_expr : From.Parsetree.class_expr -> To.Parsetree.class_expr =\n fun {\n From.Parsetree.pcl_desc;\n From.Parsetree.pcl_loc;\n From.Parsetree.pcl_attributes;\n } ->\n {\n To.Parsetree.pcl_desc = copy_class_expr_desc pcl_desc;\n To.Parsetree.pcl_loc = copy_location pcl_loc;\n To.Parsetree.pcl_attributes = copy_attributes pcl_attributes;\n }\n\nand copy_class_expr_desc :\n From.Parsetree.class_expr_desc -> To.Parsetree.class_expr_desc = function\n | From.Parsetree.Pcl_constr (x0, x1) ->\n To.Parsetree.Pcl_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Pcl_structure x0 ->\n To.Parsetree.Pcl_structure (copy_class_structure x0)\n | From.Parsetree.Pcl_fun (x0, x1, x2, x3) ->\n To.Parsetree.Pcl_fun\n ( copy_arg_label x0,\n copy_option copy_expression x1,\n copy_pattern x2,\n copy_class_expr x3 )\n | From.Parsetree.Pcl_apply (x0, x1) ->\n To.Parsetree.Pcl_apply\n ( copy_class_expr x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | From.Parsetree.Pcl_let (x0, x1, x2) ->\n To.Parsetree.Pcl_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_class_expr x2)\n | From.Parsetree.Pcl_constraint (x0, x1) ->\n To.Parsetree.Pcl_constraint (copy_class_expr x0, copy_class_type x1)\n | From.Parsetree.Pcl_extension x0 ->\n To.Parsetree.Pcl_extension (copy_extension x0)\n\nand copy_class_structure :\n From.Parsetree.class_structure -> To.Parsetree.class_structure =\n fun { From.Parsetree.pcstr_self; From.Parsetree.pcstr_fields } ->\n {\n To.Parsetree.pcstr_self = copy_pattern pcstr_self;\n To.Parsetree.pcstr_fields = List.map copy_class_field pcstr_fields;\n }\n\nand copy_class_field : From.Parsetree.class_field -> To.Parsetree.class_field =\n fun {\n From.Parsetree.pcf_desc;\n From.Parsetree.pcf_loc;\n From.Parsetree.pcf_attributes;\n } ->\n {\n To.Parsetree.pcf_desc = copy_class_field_desc pcf_desc;\n To.Parsetree.pcf_loc = copy_location pcf_loc;\n To.Parsetree.pcf_attributes = copy_attributes pcf_attributes;\n }\n\nand copy_class_field_desc :\n From.Parsetree.class_field_desc -> To.Parsetree.class_field_desc = function\n | From.Parsetree.Pcf_inherit (x0, x1, x2) ->\n To.Parsetree.Pcf_inherit\n ( copy_override_flag x0,\n copy_class_expr x1,\n copy_option (copy_loc (fun x -> x)) x2 )\n | From.Parsetree.Pcf_val x0 ->\n To.Parsetree.Pcf_val\n (let x0, x1, x2 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_mutable_flag x1,\n copy_class_field_kind x2 ))\n | From.Parsetree.Pcf_method x0 ->\n To.Parsetree.Pcf_method\n (let x0, x1, x2 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_private_flag x1,\n copy_class_field_kind x2 ))\n | From.Parsetree.Pcf_constraint x0 ->\n To.Parsetree.Pcf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | From.Parsetree.Pcf_initializer x0 ->\n To.Parsetree.Pcf_initializer (copy_expression x0)\n | From.Parsetree.Pcf_attribute x0 ->\n To.Parsetree.Pcf_attribute (copy_attribute x0)\n | From.Parsetree.Pcf_extension x0 ->\n To.Parsetree.Pcf_extension (copy_extension x0)\n\nand copy_class_field_kind :\n From.Parsetree.class_field_kind -> To.Parsetree.class_field_kind = function\n | From.Parsetree.Cfk_virtual x0 ->\n To.Parsetree.Cfk_virtual (copy_core_type x0)\n | From.Parsetree.Cfk_concrete (x0, x1) ->\n To.Parsetree.Cfk_concrete (copy_override_flag x0, copy_expression x1)\n\nand copy_module_binding :\n From.Parsetree.module_binding -> To.Parsetree.module_binding =\n fun {\n From.Parsetree.pmb_name;\n From.Parsetree.pmb_expr;\n From.Parsetree.pmb_attributes;\n From.Parsetree.pmb_loc;\n } ->\n {\n To.Parsetree.pmb_name = copy_loc (fun x -> x) pmb_name;\n To.Parsetree.pmb_expr = copy_module_expr pmb_expr;\n To.Parsetree.pmb_attributes = copy_attributes pmb_attributes;\n To.Parsetree.pmb_loc = copy_location pmb_loc;\n }\n\nand copy_module_expr : From.Parsetree.module_expr -> To.Parsetree.module_expr =\n fun {\n From.Parsetree.pmod_desc;\n From.Parsetree.pmod_loc;\n From.Parsetree.pmod_attributes;\n } ->\n {\n To.Parsetree.pmod_desc = copy_module_expr_desc pmod_desc;\n To.Parsetree.pmod_loc = copy_location pmod_loc;\n To.Parsetree.pmod_attributes = copy_attributes pmod_attributes;\n }\n\nand copy_module_expr_desc :\n From.Parsetree.module_expr_desc -> To.Parsetree.module_expr_desc = function\n | From.Parsetree.Pmod_ident x0 ->\n To.Parsetree.Pmod_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pmod_structure x0 ->\n To.Parsetree.Pmod_structure (copy_structure x0)\n | From.Parsetree.Pmod_functor (x0, x1, x2) ->\n To.Parsetree.Pmod_functor\n ( copy_loc (fun x -> x) x0,\n copy_option copy_module_type x1,\n copy_module_expr x2 )\n | From.Parsetree.Pmod_apply (x0, x1) ->\n To.Parsetree.Pmod_apply (copy_module_expr x0, copy_module_expr x1)\n | From.Parsetree.Pmod_constraint (x0, x1) ->\n To.Parsetree.Pmod_constraint (copy_module_expr x0, copy_module_type x1)\n | From.Parsetree.Pmod_unpack x0 ->\n To.Parsetree.Pmod_unpack (copy_expression x0)\n | From.Parsetree.Pmod_extension x0 ->\n To.Parsetree.Pmod_extension (copy_extension x0)\n\nand copy_module_type : From.Parsetree.module_type -> To.Parsetree.module_type =\n fun {\n From.Parsetree.pmty_desc;\n From.Parsetree.pmty_loc;\n From.Parsetree.pmty_attributes;\n } ->\n {\n To.Parsetree.pmty_desc = copy_module_type_desc pmty_desc;\n To.Parsetree.pmty_loc = copy_location pmty_loc;\n To.Parsetree.pmty_attributes = copy_attributes pmty_attributes;\n }\n\nand copy_module_type_desc :\n From.Parsetree.module_type_desc -> To.Parsetree.module_type_desc = function\n | From.Parsetree.Pmty_ident x0 ->\n To.Parsetree.Pmty_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pmty_signature x0 ->\n To.Parsetree.Pmty_signature (copy_signature x0)\n | From.Parsetree.Pmty_functor (x0, x1, x2) ->\n To.Parsetree.Pmty_functor\n ( copy_loc (fun x -> x) x0,\n copy_option copy_module_type x1,\n copy_module_type x2 )\n | From.Parsetree.Pmty_with (x0, x1) ->\n To.Parsetree.Pmty_with\n (copy_module_type x0, List.map copy_with_constraint x1)\n | From.Parsetree.Pmty_typeof x0 ->\n To.Parsetree.Pmty_typeof (copy_module_expr x0)\n | From.Parsetree.Pmty_extension x0 ->\n To.Parsetree.Pmty_extension (copy_extension x0)\n | From.Parsetree.Pmty_alias x0 ->\n To.Parsetree.Pmty_alias (copy_loc copy_longident x0)\n\nand copy_with_constraint :\n From.Parsetree.with_constraint -> To.Parsetree.with_constraint = function\n | From.Parsetree.Pwith_type (x0, x1) ->\n To.Parsetree.Pwith_type\n (copy_loc copy_longident x0, copy_type_declaration x1)\n | From.Parsetree.Pwith_module (x0, x1) ->\n To.Parsetree.Pwith_module\n (copy_loc copy_longident x0, copy_loc copy_longident x1)\n | From.Parsetree.Pwith_typesubst x0 ->\n To.Parsetree.Pwith_typesubst\n ( copy_loc (fun x -> Longident.Lident x) x0.From.Parsetree.ptype_name,\n copy_type_declaration x0 )\n | From.Parsetree.Pwith_modsubst (x0, x1) ->\n To.Parsetree.Pwith_modsubst\n (copy_loc (fun x -> Longident.Lident x) x0, copy_loc copy_longident x1)\n\nand copy_signature : From.Parsetree.signature -> To.Parsetree.signature =\n fun x -> List.map copy_signature_item x\n\nand copy_signature_item :\n From.Parsetree.signature_item -> To.Parsetree.signature_item =\n fun { From.Parsetree.psig_desc; From.Parsetree.psig_loc } ->\n {\n To.Parsetree.psig_desc = copy_signature_item_desc psig_desc;\n To.Parsetree.psig_loc = copy_location psig_loc;\n }\n\nand copy_signature_item_desc :\n From.Parsetree.signature_item_desc -> To.Parsetree.signature_item_desc =\n function\n | From.Parsetree.Psig_value x0 ->\n To.Parsetree.Psig_value (copy_value_description x0)\n | From.Parsetree.Psig_type (x0, x1) ->\n To.Parsetree.Psig_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | From.Parsetree.Psig_typext x0 ->\n To.Parsetree.Psig_typext (copy_type_extension x0)\n | From.Parsetree.Psig_exception x0 ->\n To.Parsetree.Psig_exception (copy_extension_constructor x0)\n | From.Parsetree.Psig_module x0 ->\n To.Parsetree.Psig_module (copy_module_declaration x0)\n | From.Parsetree.Psig_recmodule x0 ->\n To.Parsetree.Psig_recmodule (List.map copy_module_declaration x0)\n | From.Parsetree.Psig_modtype x0 ->\n To.Parsetree.Psig_modtype (copy_module_type_declaration x0)\n | From.Parsetree.Psig_open x0 ->\n To.Parsetree.Psig_open (copy_open_description x0)\n | From.Parsetree.Psig_include x0 ->\n To.Parsetree.Psig_include (copy_include_description x0)\n | From.Parsetree.Psig_class x0 ->\n To.Parsetree.Psig_class (List.map copy_class_description x0)\n | From.Parsetree.Psig_class_type x0 ->\n To.Parsetree.Psig_class_type (List.map copy_class_type_declaration x0)\n | From.Parsetree.Psig_attribute x0 ->\n To.Parsetree.Psig_attribute (copy_attribute x0)\n | From.Parsetree.Psig_extension (x0, x1) ->\n To.Parsetree.Psig_extension (copy_extension x0, copy_attributes x1)\n\nand copy_class_type_declaration :\n From.Parsetree.class_type_declaration -> To.Parsetree.class_type_declaration\n =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_description :\n From.Parsetree.class_description -> To.Parsetree.class_description =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_type : From.Parsetree.class_type -> To.Parsetree.class_type =\n fun {\n From.Parsetree.pcty_desc;\n From.Parsetree.pcty_loc;\n From.Parsetree.pcty_attributes;\n } ->\n {\n To.Parsetree.pcty_desc = copy_class_type_desc pcty_desc;\n To.Parsetree.pcty_loc = copy_location pcty_loc;\n To.Parsetree.pcty_attributes = copy_attributes pcty_attributes;\n }\n\nand copy_class_type_desc :\n From.Parsetree.class_type_desc -> To.Parsetree.class_type_desc = function\n | From.Parsetree.Pcty_constr (x0, x1) ->\n To.Parsetree.Pcty_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Pcty_signature x0 ->\n To.Parsetree.Pcty_signature (copy_class_signature x0)\n | From.Parsetree.Pcty_arrow (x0, x1, x2) ->\n To.Parsetree.Pcty_arrow\n (copy_arg_label x0, copy_core_type x1, copy_class_type x2)\n | From.Parsetree.Pcty_extension x0 ->\n To.Parsetree.Pcty_extension (copy_extension x0)\n\nand copy_class_signature :\n From.Parsetree.class_signature -> To.Parsetree.class_signature =\n fun { From.Parsetree.pcsig_self; From.Parsetree.pcsig_fields } ->\n {\n To.Parsetree.pcsig_self = copy_core_type pcsig_self;\n To.Parsetree.pcsig_fields = List.map copy_class_type_field pcsig_fields;\n }\n\nand copy_class_type_field :\n From.Parsetree.class_type_field -> To.Parsetree.class_type_field =\n fun {\n From.Parsetree.pctf_desc;\n From.Parsetree.pctf_loc;\n From.Parsetree.pctf_attributes;\n } ->\n {\n To.Parsetree.pctf_desc = copy_class_type_field_desc pctf_desc;\n To.Parsetree.pctf_loc = copy_location pctf_loc;\n To.Parsetree.pctf_attributes = copy_attributes pctf_attributes;\n }\n\nand copy_class_type_field_desc :\n From.Parsetree.class_type_field_desc -> To.Parsetree.class_type_field_desc =\n function\n | From.Parsetree.Pctf_inherit x0 ->\n To.Parsetree.Pctf_inherit (copy_class_type x0)\n | From.Parsetree.Pctf_val x0 ->\n To.Parsetree.Pctf_val\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_mutable_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | From.Parsetree.Pctf_method x0 ->\n To.Parsetree.Pctf_method\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_private_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | From.Parsetree.Pctf_constraint x0 ->\n To.Parsetree.Pctf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | From.Parsetree.Pctf_attribute x0 ->\n To.Parsetree.Pctf_attribute (copy_attribute x0)\n | From.Parsetree.Pctf_extension x0 ->\n To.Parsetree.Pctf_extension (copy_extension x0)\n\nand copy_extension : From.Parsetree.extension -> To.Parsetree.extension =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_class_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 From.Parsetree.class_infos ->\n 'g0 To.Parsetree.class_infos =\n fun f0\n {\n From.Parsetree.pci_virt;\n From.Parsetree.pci_params;\n From.Parsetree.pci_name;\n From.Parsetree.pci_expr;\n From.Parsetree.pci_loc;\n From.Parsetree.pci_attributes;\n } ->\n {\n To.Parsetree.pci_virt = copy_virtual_flag pci_virt;\n To.Parsetree.pci_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n pci_params;\n To.Parsetree.pci_name = copy_loc (fun x -> x) pci_name;\n To.Parsetree.pci_expr = f0 pci_expr;\n To.Parsetree.pci_loc = copy_location pci_loc;\n To.Parsetree.pci_attributes = copy_attributes pci_attributes;\n }\n\nand copy_virtual_flag : From.Asttypes.virtual_flag -> To.Asttypes.virtual_flag =\n function\n | From.Asttypes.Virtual -> To.Asttypes.Virtual\n | From.Asttypes.Concrete -> To.Asttypes.Concrete\n\nand copy_include_description :\n From.Parsetree.include_description -> To.Parsetree.include_description =\n fun x -> copy_include_infos copy_module_type x\n\nand copy_include_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 From.Parsetree.include_infos ->\n 'g0 To.Parsetree.include_infos =\n fun f0\n {\n From.Parsetree.pincl_mod;\n From.Parsetree.pincl_loc;\n From.Parsetree.pincl_attributes;\n } ->\n {\n To.Parsetree.pincl_mod = f0 pincl_mod;\n To.Parsetree.pincl_loc = copy_location pincl_loc;\n To.Parsetree.pincl_attributes = copy_attributes pincl_attributes;\n }\n\nand copy_open_description :\n From.Parsetree.open_description -> To.Parsetree.open_description =\n fun {\n From.Parsetree.popen_lid;\n From.Parsetree.popen_override;\n From.Parsetree.popen_loc;\n From.Parsetree.popen_attributes;\n } ->\n {\n To.Parsetree.popen_lid = copy_loc copy_longident popen_lid;\n To.Parsetree.popen_override = copy_override_flag popen_override;\n To.Parsetree.popen_loc = copy_location popen_loc;\n To.Parsetree.popen_attributes = copy_attributes popen_attributes;\n }\n\nand copy_override_flag :\n From.Asttypes.override_flag -> To.Asttypes.override_flag = function\n | From.Asttypes.Override -> To.Asttypes.Override\n | From.Asttypes.Fresh -> To.Asttypes.Fresh\n\nand copy_module_type_declaration :\n From.Parsetree.module_type_declaration ->\n To.Parsetree.module_type_declaration =\n fun {\n From.Parsetree.pmtd_name;\n From.Parsetree.pmtd_type;\n From.Parsetree.pmtd_attributes;\n From.Parsetree.pmtd_loc;\n } ->\n {\n To.Parsetree.pmtd_name = copy_loc (fun x -> x) pmtd_name;\n To.Parsetree.pmtd_type = copy_option copy_module_type pmtd_type;\n To.Parsetree.pmtd_attributes = copy_attributes pmtd_attributes;\n To.Parsetree.pmtd_loc = copy_location pmtd_loc;\n }\n\nand copy_module_declaration :\n From.Parsetree.module_declaration -> To.Parsetree.module_declaration =\n fun {\n From.Parsetree.pmd_name;\n From.Parsetree.pmd_type;\n From.Parsetree.pmd_attributes;\n From.Parsetree.pmd_loc;\n } ->\n {\n To.Parsetree.pmd_name = copy_loc (fun x -> x) pmd_name;\n To.Parsetree.pmd_type = copy_module_type pmd_type;\n To.Parsetree.pmd_attributes = copy_attributes pmd_attributes;\n To.Parsetree.pmd_loc = copy_location pmd_loc;\n }\n\nand copy_type_extension :\n From.Parsetree.type_extension -> To.Parsetree.type_extension =\n fun {\n From.Parsetree.ptyext_path;\n From.Parsetree.ptyext_params;\n From.Parsetree.ptyext_constructors;\n From.Parsetree.ptyext_private;\n From.Parsetree.ptyext_attributes;\n } ->\n {\n To.Parsetree.ptyext_path = copy_loc copy_longident ptyext_path;\n To.Parsetree.ptyext_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptyext_params;\n To.Parsetree.ptyext_constructors =\n List.map copy_extension_constructor ptyext_constructors;\n To.Parsetree.ptyext_private = copy_private_flag ptyext_private;\n To.Parsetree.ptyext_attributes = copy_attributes ptyext_attributes;\n }\n\nand copy_extension_constructor :\n From.Parsetree.extension_constructor -> To.Parsetree.extension_constructor =\n fun {\n From.Parsetree.pext_name;\n From.Parsetree.pext_kind;\n From.Parsetree.pext_loc;\n From.Parsetree.pext_attributes;\n } ->\n {\n To.Parsetree.pext_name = copy_loc (fun x -> x) pext_name;\n To.Parsetree.pext_kind = copy_extension_constructor_kind pext_kind;\n To.Parsetree.pext_loc = copy_location pext_loc;\n To.Parsetree.pext_attributes = copy_attributes pext_attributes;\n }\n\nand copy_extension_constructor_kind :\n From.Parsetree.extension_constructor_kind ->\n To.Parsetree.extension_constructor_kind = function\n | From.Parsetree.Pext_decl (x0, x1) ->\n To.Parsetree.Pext_decl\n (copy_constructor_arguments x0, copy_option copy_core_type x1)\n | From.Parsetree.Pext_rebind x0 ->\n To.Parsetree.Pext_rebind (copy_loc copy_longident x0)\n\nand copy_type_declaration :\n From.Parsetree.type_declaration -> To.Parsetree.type_declaration =\n fun {\n From.Parsetree.ptype_name;\n From.Parsetree.ptype_params;\n From.Parsetree.ptype_cstrs;\n From.Parsetree.ptype_kind;\n From.Parsetree.ptype_private;\n From.Parsetree.ptype_manifest;\n From.Parsetree.ptype_attributes;\n From.Parsetree.ptype_loc;\n } ->\n {\n To.Parsetree.ptype_name = copy_loc (fun x -> x) ptype_name;\n To.Parsetree.ptype_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptype_params;\n To.Parsetree.ptype_cstrs =\n List.map\n (fun x ->\n let x0, x1, x2 = x in\n (copy_core_type x0, copy_core_type x1, copy_location x2))\n ptype_cstrs;\n To.Parsetree.ptype_kind = copy_type_kind ptype_kind;\n To.Parsetree.ptype_private = copy_private_flag ptype_private;\n To.Parsetree.ptype_manifest = copy_option copy_core_type ptype_manifest;\n To.Parsetree.ptype_attributes = copy_attributes ptype_attributes;\n To.Parsetree.ptype_loc = copy_location ptype_loc;\n }\n\nand copy_private_flag : From.Asttypes.private_flag -> To.Asttypes.private_flag =\n function\n | From.Asttypes.Private -> To.Asttypes.Private\n | From.Asttypes.Public -> To.Asttypes.Public\n\nand copy_type_kind : From.Parsetree.type_kind -> To.Parsetree.type_kind =\n function\n | From.Parsetree.Ptype_abstract -> To.Parsetree.Ptype_abstract\n | From.Parsetree.Ptype_variant x0 ->\n To.Parsetree.Ptype_variant (List.map copy_constructor_declaration x0)\n | From.Parsetree.Ptype_record x0 ->\n To.Parsetree.Ptype_record (List.map copy_label_declaration x0)\n | From.Parsetree.Ptype_open -> To.Parsetree.Ptype_open\n\nand copy_constructor_declaration :\n From.Parsetree.constructor_declaration ->\n To.Parsetree.constructor_declaration =\n fun {\n From.Parsetree.pcd_name;\n From.Parsetree.pcd_args;\n From.Parsetree.pcd_res;\n From.Parsetree.pcd_loc;\n From.Parsetree.pcd_attributes;\n } ->\n {\n To.Parsetree.pcd_name = copy_loc (fun x -> x) pcd_name;\n To.Parsetree.pcd_args = copy_constructor_arguments pcd_args;\n To.Parsetree.pcd_res = copy_option copy_core_type pcd_res;\n To.Parsetree.pcd_loc = copy_location pcd_loc;\n To.Parsetree.pcd_attributes = copy_attributes pcd_attributes;\n }\n\nand copy_constructor_arguments :\n From.Parsetree.constructor_arguments -> To.Parsetree.constructor_arguments =\n function\n | From.Parsetree.Pcstr_tuple x0 ->\n To.Parsetree.Pcstr_tuple (List.map copy_core_type x0)\n | From.Parsetree.Pcstr_record x0 ->\n To.Parsetree.Pcstr_record (List.map copy_label_declaration x0)\n\nand copy_label_declaration :\n From.Parsetree.label_declaration -> To.Parsetree.label_declaration =\n fun {\n From.Parsetree.pld_name;\n From.Parsetree.pld_mutable;\n From.Parsetree.pld_type;\n From.Parsetree.pld_loc;\n From.Parsetree.pld_attributes;\n } ->\n {\n To.Parsetree.pld_name = copy_loc (fun x -> x) pld_name;\n To.Parsetree.pld_mutable = copy_mutable_flag pld_mutable;\n To.Parsetree.pld_type = copy_core_type pld_type;\n To.Parsetree.pld_loc = copy_location pld_loc;\n To.Parsetree.pld_attributes = copy_attributes pld_attributes;\n }\n\nand copy_mutable_flag : From.Asttypes.mutable_flag -> To.Asttypes.mutable_flag =\n function\n | From.Asttypes.Immutable -> To.Asttypes.Immutable\n | From.Asttypes.Mutable -> To.Asttypes.Mutable\n\nand copy_variance : From.Asttypes.variance -> To.Asttypes.variance = function\n | From.Asttypes.Covariant -> To.Asttypes.Covariant\n | From.Asttypes.Contravariant -> To.Asttypes.Contravariant\n | From.Asttypes.Invariant -> To.Asttypes.Invariant\n\nand copy_value_description :\n From.Parsetree.value_description -> To.Parsetree.value_description =\n fun {\n From.Parsetree.pval_name;\n From.Parsetree.pval_type;\n From.Parsetree.pval_prim;\n From.Parsetree.pval_attributes;\n From.Parsetree.pval_loc;\n } ->\n {\n To.Parsetree.pval_name = copy_loc (fun x -> x) pval_name;\n To.Parsetree.pval_type = copy_core_type pval_type;\n To.Parsetree.pval_prim = List.map (fun x -> x) pval_prim;\n To.Parsetree.pval_attributes = copy_attributes pval_attributes;\n To.Parsetree.pval_loc = copy_location pval_loc;\n }\n\nand copy_arg_label : From.Asttypes.arg_label -> To.Asttypes.arg_label = function\n | From.Asttypes.Nolabel -> To.Asttypes.Nolabel\n | From.Asttypes.Labelled x0 -> To.Asttypes.Labelled x0\n | From.Asttypes.Optional x0 -> To.Asttypes.Optional x0\n\nand copy_closed_flag : From.Asttypes.closed_flag -> To.Asttypes.closed_flag =\n function\n | From.Asttypes.Closed -> To.Asttypes.Closed\n | From.Asttypes.Open -> To.Asttypes.Open\n\nand copy_label : From.Asttypes.label -> To.Asttypes.label = fun x -> x\n\nand copy_rec_flag : From.Asttypes.rec_flag -> To.Asttypes.rec_flag = function\n | From.Asttypes.Nonrecursive -> To.Asttypes.Nonrecursive\n | From.Asttypes.Recursive -> To.Asttypes.Recursive\n\nand copy_constant : From.Parsetree.constant -> To.Parsetree.constant = function\n | From.Parsetree.Pconst_integer (x0, x1) ->\n To.Parsetree.Pconst_integer (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pconst_char x0 -> To.Parsetree.Pconst_char x0\n | From.Parsetree.Pconst_string (x0, x1) ->\n To.Parsetree.Pconst_string (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pconst_float (x0, x1) ->\n To.Parsetree.Pconst_float (x0, copy_option (fun x -> x) x1)\n\nand copy_option : 'f0 'g0. ('f0 -> 'g0) -> 'f0 option -> 'g0 option =\n fun f0 -> function None -> None | Some x0 -> Some (f0 x0)\n\nand copy_longident : Longident.t -> Longident.t = fun x -> x\n\nand copy_loc :\n 'f0 'g0. ('f0 -> 'g0) -> 'f0 From.Asttypes.loc -> 'g0 To.Asttypes.loc =\n fun f0 { From.Asttypes.txt; From.Asttypes.loc } ->\n { To.Asttypes.txt = f0 txt; To.Asttypes.loc = copy_location loc }\n\nand copy_location : Location.t -> Location.t = fun x -> x\nand copy_bool : bool -> bool = function false -> false | true -> true\n\nlet rec copy_toplevel_phrase :\n From.Parsetree.toplevel_phrase -> To.Parsetree.toplevel_phrase = function\n | From.Parsetree.Ptop_def x0 -> To.Parsetree.Ptop_def (copy_structure x0)\n | From.Parsetree.Ptop_dir (x0, x1) ->\n To.Parsetree.Ptop_dir (x0, copy_directive_argument x1)\n\nand copy_directive_argument :\n From.Parsetree.directive_argument -> To.Parsetree.directive_argument =\n function\n | From.Parsetree.Pdir_none -> To.Parsetree.Pdir_none\n | From.Parsetree.Pdir_string x0 -> To.Parsetree.Pdir_string x0\n | From.Parsetree.Pdir_int (x0, x1) ->\n To.Parsetree.Pdir_int (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pdir_ident x0 -> To.Parsetree.Pdir_ident (copy_longident x0)\n | From.Parsetree.Pdir_bool x0 -> To.Parsetree.Pdir_bool (copy_bool x0)\n\nlet copy_cases x = List.map copy_case x\nlet copy_pat = copy_pattern\nlet copy_expr = copy_expression\nlet copy_typ = copy_core_type\n","(**************************************************************************)\n(* *)\n(* OCaml Migrate Parsetree *)\n(* *)\n(* Frédéric Bour *)\n(* Alain Frisch, LexiFi *)\n(* *)\n(* Copyright 2017 Institut National de Recherche en Informatique et *)\n(* en Automatique (INRIA). *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nmodule From = Ast_405\nmodule To = Ast_404\n\nlet rec copy_expression : From.Parsetree.expression -> To.Parsetree.expression =\n fun {\n From.Parsetree.pexp_desc;\n From.Parsetree.pexp_loc;\n From.Parsetree.pexp_attributes;\n } ->\n {\n To.Parsetree.pexp_desc = copy_expression_desc pexp_desc;\n To.Parsetree.pexp_loc = copy_location pexp_loc;\n To.Parsetree.pexp_attributes = copy_attributes pexp_attributes;\n }\n\nand copy_expression_desc :\n From.Parsetree.expression_desc -> To.Parsetree.expression_desc = function\n | From.Parsetree.Pexp_ident x0 ->\n To.Parsetree.Pexp_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pexp_constant x0 ->\n To.Parsetree.Pexp_constant (copy_constant x0)\n | From.Parsetree.Pexp_let (x0, x1, x2) ->\n To.Parsetree.Pexp_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_expression x2)\n | From.Parsetree.Pexp_function x0 ->\n To.Parsetree.Pexp_function (List.map copy_case x0)\n | From.Parsetree.Pexp_fun (x0, x1, x2, x3) ->\n To.Parsetree.Pexp_fun\n ( copy_arg_label x0,\n copy_option copy_expression x1,\n copy_pattern x2,\n copy_expression x3 )\n | From.Parsetree.Pexp_apply (x0, x1) ->\n To.Parsetree.Pexp_apply\n ( copy_expression x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | From.Parsetree.Pexp_match (x0, x1) ->\n To.Parsetree.Pexp_match (copy_expression x0, List.map copy_case x1)\n | From.Parsetree.Pexp_try (x0, x1) ->\n To.Parsetree.Pexp_try (copy_expression x0, List.map copy_case x1)\n | From.Parsetree.Pexp_tuple x0 ->\n To.Parsetree.Pexp_tuple (List.map copy_expression x0)\n | From.Parsetree.Pexp_construct (x0, x1) ->\n To.Parsetree.Pexp_construct\n (copy_loc copy_longident x0, copy_option copy_expression x1)\n | From.Parsetree.Pexp_variant (x0, x1) ->\n To.Parsetree.Pexp_variant (copy_label x0, copy_option copy_expression x1)\n | From.Parsetree.Pexp_record (x0, x1) ->\n To.Parsetree.Pexp_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_expression x1))\n x0,\n copy_option copy_expression x1 )\n | From.Parsetree.Pexp_field (x0, x1) ->\n To.Parsetree.Pexp_field (copy_expression x0, copy_loc copy_longident x1)\n | From.Parsetree.Pexp_setfield (x0, x1, x2) ->\n To.Parsetree.Pexp_setfield\n (copy_expression x0, copy_loc copy_longident x1, copy_expression x2)\n | From.Parsetree.Pexp_array x0 ->\n To.Parsetree.Pexp_array (List.map copy_expression x0)\n | From.Parsetree.Pexp_ifthenelse (x0, x1, x2) ->\n To.Parsetree.Pexp_ifthenelse\n (copy_expression x0, copy_expression x1, copy_option copy_expression x2)\n | From.Parsetree.Pexp_sequence (x0, x1) ->\n To.Parsetree.Pexp_sequence (copy_expression x0, copy_expression x1)\n | From.Parsetree.Pexp_while (x0, x1) ->\n To.Parsetree.Pexp_while (copy_expression x0, copy_expression x1)\n | From.Parsetree.Pexp_for (x0, x1, x2, x3, x4) ->\n To.Parsetree.Pexp_for\n ( copy_pattern x0,\n copy_expression x1,\n copy_expression x2,\n copy_direction_flag x3,\n copy_expression x4 )\n | From.Parsetree.Pexp_constraint (x0, x1) ->\n To.Parsetree.Pexp_constraint (copy_expression x0, copy_core_type x1)\n | From.Parsetree.Pexp_coerce (x0, x1, x2) ->\n To.Parsetree.Pexp_coerce\n (copy_expression x0, copy_option copy_core_type x1, copy_core_type x2)\n | From.Parsetree.Pexp_send (x0, x1) ->\n To.Parsetree.Pexp_send (copy_expression x0, x1.From.Asttypes.txt)\n | From.Parsetree.Pexp_new x0 ->\n To.Parsetree.Pexp_new (copy_loc copy_longident x0)\n | From.Parsetree.Pexp_setinstvar (x0, x1) ->\n To.Parsetree.Pexp_setinstvar (copy_loc (fun x -> x) x0, copy_expression x1)\n | From.Parsetree.Pexp_override x0 ->\n To.Parsetree.Pexp_override\n (List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_expression x1))\n x0)\n | From.Parsetree.Pexp_letmodule (x0, x1, x2) ->\n To.Parsetree.Pexp_letmodule\n (copy_loc (fun x -> x) x0, copy_module_expr x1, copy_expression x2)\n | From.Parsetree.Pexp_letexception (x0, x1) ->\n To.Parsetree.Pexp_letexception\n (copy_extension_constructor x0, copy_expression x1)\n | From.Parsetree.Pexp_assert x0 ->\n To.Parsetree.Pexp_assert (copy_expression x0)\n | From.Parsetree.Pexp_lazy x0 -> To.Parsetree.Pexp_lazy (copy_expression x0)\n | From.Parsetree.Pexp_poly (x0, x1) ->\n To.Parsetree.Pexp_poly (copy_expression x0, copy_option copy_core_type x1)\n | From.Parsetree.Pexp_object x0 ->\n To.Parsetree.Pexp_object (copy_class_structure x0)\n | From.Parsetree.Pexp_newtype (x0, x1) ->\n To.Parsetree.Pexp_newtype (x0.From.Asttypes.txt, copy_expression x1)\n | From.Parsetree.Pexp_pack x0 -> To.Parsetree.Pexp_pack (copy_module_expr x0)\n | From.Parsetree.Pexp_open (x0, x1, x2) ->\n To.Parsetree.Pexp_open\n (copy_override_flag x0, copy_loc copy_longident x1, copy_expression x2)\n | From.Parsetree.Pexp_extension x0 ->\n To.Parsetree.Pexp_extension (copy_extension x0)\n | From.Parsetree.Pexp_unreachable -> To.Parsetree.Pexp_unreachable\n\nand copy_direction_flag :\n From.Asttypes.direction_flag -> To.Asttypes.direction_flag = function\n | From.Asttypes.Upto -> To.Asttypes.Upto\n | From.Asttypes.Downto -> To.Asttypes.Downto\n\nand copy_case : From.Parsetree.case -> To.Parsetree.case =\n fun { From.Parsetree.pc_lhs; From.Parsetree.pc_guard; From.Parsetree.pc_rhs } ->\n {\n To.Parsetree.pc_lhs = copy_pattern pc_lhs;\n To.Parsetree.pc_guard = copy_option copy_expression pc_guard;\n To.Parsetree.pc_rhs = copy_expression pc_rhs;\n }\n\nand copy_value_binding :\n From.Parsetree.value_binding -> To.Parsetree.value_binding =\n fun {\n From.Parsetree.pvb_pat;\n From.Parsetree.pvb_expr;\n From.Parsetree.pvb_attributes;\n From.Parsetree.pvb_loc;\n } ->\n {\n To.Parsetree.pvb_pat = copy_pattern pvb_pat;\n To.Parsetree.pvb_expr = copy_expression pvb_expr;\n To.Parsetree.pvb_attributes = copy_attributes pvb_attributes;\n To.Parsetree.pvb_loc = copy_location pvb_loc;\n }\n\nand copy_pattern : From.Parsetree.pattern -> To.Parsetree.pattern =\n fun {\n From.Parsetree.ppat_desc;\n From.Parsetree.ppat_loc;\n From.Parsetree.ppat_attributes;\n } ->\n {\n To.Parsetree.ppat_desc = copy_pattern_desc ppat_desc;\n To.Parsetree.ppat_loc = copy_location ppat_loc;\n To.Parsetree.ppat_attributes = copy_attributes ppat_attributes;\n }\n\nand copy_pattern_desc : From.Parsetree.pattern_desc -> To.Parsetree.pattern_desc\n = function\n | From.Parsetree.Ppat_any -> To.Parsetree.Ppat_any\n | From.Parsetree.Ppat_var x0 ->\n To.Parsetree.Ppat_var (copy_loc (fun x -> x) x0)\n | From.Parsetree.Ppat_alias (x0, x1) ->\n To.Parsetree.Ppat_alias (copy_pattern x0, copy_loc (fun x -> x) x1)\n | From.Parsetree.Ppat_constant x0 ->\n To.Parsetree.Ppat_constant (copy_constant x0)\n | From.Parsetree.Ppat_interval (x0, x1) ->\n To.Parsetree.Ppat_interval (copy_constant x0, copy_constant x1)\n | From.Parsetree.Ppat_tuple x0 ->\n To.Parsetree.Ppat_tuple (List.map copy_pattern x0)\n | From.Parsetree.Ppat_construct (x0, x1) ->\n To.Parsetree.Ppat_construct\n (copy_loc copy_longident x0, copy_option copy_pattern x1)\n | From.Parsetree.Ppat_variant (x0, x1) ->\n To.Parsetree.Ppat_variant (copy_label x0, copy_option copy_pattern x1)\n | From.Parsetree.Ppat_record (x0, x1) ->\n To.Parsetree.Ppat_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_pattern x1))\n x0,\n copy_closed_flag x1 )\n | From.Parsetree.Ppat_array x0 ->\n To.Parsetree.Ppat_array (List.map copy_pattern x0)\n | From.Parsetree.Ppat_or (x0, x1) ->\n To.Parsetree.Ppat_or (copy_pattern x0, copy_pattern x1)\n | From.Parsetree.Ppat_constraint (x0, x1) ->\n To.Parsetree.Ppat_constraint (copy_pattern x0, copy_core_type x1)\n | From.Parsetree.Ppat_type x0 ->\n To.Parsetree.Ppat_type (copy_loc copy_longident x0)\n | From.Parsetree.Ppat_lazy x0 -> To.Parsetree.Ppat_lazy (copy_pattern x0)\n | From.Parsetree.Ppat_unpack x0 ->\n To.Parsetree.Ppat_unpack (copy_loc (fun x -> x) x0)\n | From.Parsetree.Ppat_exception x0 ->\n To.Parsetree.Ppat_exception (copy_pattern x0)\n | From.Parsetree.Ppat_extension x0 ->\n To.Parsetree.Ppat_extension (copy_extension x0)\n | From.Parsetree.Ppat_open (x0, x1) ->\n To.Parsetree.Ppat_open (copy_loc copy_longident x0, copy_pattern x1)\n\nand copy_core_type : From.Parsetree.core_type -> To.Parsetree.core_type =\n fun {\n From.Parsetree.ptyp_desc;\n From.Parsetree.ptyp_loc;\n From.Parsetree.ptyp_attributes;\n } ->\n {\n To.Parsetree.ptyp_desc = copy_core_type_desc ptyp_desc;\n To.Parsetree.ptyp_loc = copy_location ptyp_loc;\n To.Parsetree.ptyp_attributes = copy_attributes ptyp_attributes;\n }\n\nand copy_core_type_desc :\n From.Parsetree.core_type_desc -> To.Parsetree.core_type_desc = function\n | From.Parsetree.Ptyp_any -> To.Parsetree.Ptyp_any\n | From.Parsetree.Ptyp_var x0 -> To.Parsetree.Ptyp_var x0\n | From.Parsetree.Ptyp_arrow (x0, x1, x2) ->\n To.Parsetree.Ptyp_arrow\n (copy_arg_label x0, copy_core_type x1, copy_core_type x2)\n | From.Parsetree.Ptyp_tuple x0 ->\n To.Parsetree.Ptyp_tuple (List.map copy_core_type x0)\n | From.Parsetree.Ptyp_constr (x0, x1) ->\n To.Parsetree.Ptyp_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Ptyp_object (x0, x1) ->\n To.Parsetree.Ptyp_object\n ( List.map\n (fun x ->\n let x0, x1, x2 = x in\n (x0.From.Asttypes.txt, copy_attributes x1, copy_core_type x2))\n x0,\n copy_closed_flag x1 )\n | From.Parsetree.Ptyp_class (x0, x1) ->\n To.Parsetree.Ptyp_class\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Ptyp_alias (x0, x1) ->\n To.Parsetree.Ptyp_alias (copy_core_type x0, x1)\n | From.Parsetree.Ptyp_variant (x0, x1, x2) ->\n To.Parsetree.Ptyp_variant\n ( List.map copy_row_field x0,\n copy_closed_flag x1,\n copy_option (fun x -> List.map copy_label x) x2 )\n | From.Parsetree.Ptyp_poly (x0, x1) ->\n To.Parsetree.Ptyp_poly\n (List.map (fun x -> x.From.Asttypes.txt) x0, copy_core_type x1)\n | From.Parsetree.Ptyp_package x0 ->\n To.Parsetree.Ptyp_package (copy_package_type x0)\n | From.Parsetree.Ptyp_extension x0 ->\n To.Parsetree.Ptyp_extension (copy_extension x0)\n\nand copy_package_type : From.Parsetree.package_type -> To.Parsetree.package_type\n =\n fun x ->\n let x0, x1 = x in\n ( copy_loc copy_longident x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_core_type x1))\n x1 )\n\nand copy_row_field : From.Parsetree.row_field -> To.Parsetree.row_field =\n function\n | From.Parsetree.Rtag (x0, x1, x2, x3) ->\n To.Parsetree.Rtag\n ( copy_label x0,\n copy_attributes x1,\n copy_bool x2,\n List.map copy_core_type x3 )\n | From.Parsetree.Rinherit x0 -> To.Parsetree.Rinherit (copy_core_type x0)\n\nand copy_attributes : From.Parsetree.attributes -> To.Parsetree.attributes =\n fun x -> List.map copy_attribute x\n\nand copy_attribute : From.Parsetree.attribute -> To.Parsetree.attribute =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_payload : From.Parsetree.payload -> To.Parsetree.payload = function\n | From.Parsetree.PStr x0 -> To.Parsetree.PStr (copy_structure x0)\n | From.Parsetree.PSig x0 -> To.Parsetree.PSig (copy_signature x0)\n | From.Parsetree.PTyp x0 -> To.Parsetree.PTyp (copy_core_type x0)\n | From.Parsetree.PPat (x0, x1) ->\n To.Parsetree.PPat (copy_pattern x0, copy_option copy_expression x1)\n\nand copy_structure : From.Parsetree.structure -> To.Parsetree.structure =\n fun x -> List.map copy_structure_item x\n\nand copy_structure_item :\n From.Parsetree.structure_item -> To.Parsetree.structure_item =\n fun { From.Parsetree.pstr_desc; From.Parsetree.pstr_loc } ->\n {\n To.Parsetree.pstr_desc = copy_structure_item_desc pstr_desc;\n To.Parsetree.pstr_loc = copy_location pstr_loc;\n }\n\nand copy_structure_item_desc :\n From.Parsetree.structure_item_desc -> To.Parsetree.structure_item_desc =\n function\n | From.Parsetree.Pstr_eval (x0, x1) ->\n To.Parsetree.Pstr_eval (copy_expression x0, copy_attributes x1)\n | From.Parsetree.Pstr_value (x0, x1) ->\n To.Parsetree.Pstr_value (copy_rec_flag x0, List.map copy_value_binding x1)\n | From.Parsetree.Pstr_primitive x0 ->\n To.Parsetree.Pstr_primitive (copy_value_description x0)\n | From.Parsetree.Pstr_type (x0, x1) ->\n To.Parsetree.Pstr_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | From.Parsetree.Pstr_typext x0 ->\n To.Parsetree.Pstr_typext (copy_type_extension x0)\n | From.Parsetree.Pstr_exception x0 ->\n To.Parsetree.Pstr_exception (copy_extension_constructor x0)\n | From.Parsetree.Pstr_module x0 ->\n To.Parsetree.Pstr_module (copy_module_binding x0)\n | From.Parsetree.Pstr_recmodule x0 ->\n To.Parsetree.Pstr_recmodule (List.map copy_module_binding x0)\n | From.Parsetree.Pstr_modtype x0 ->\n To.Parsetree.Pstr_modtype (copy_module_type_declaration x0)\n | From.Parsetree.Pstr_open x0 ->\n To.Parsetree.Pstr_open (copy_open_description x0)\n | From.Parsetree.Pstr_class x0 ->\n To.Parsetree.Pstr_class (List.map copy_class_declaration x0)\n | From.Parsetree.Pstr_class_type x0 ->\n To.Parsetree.Pstr_class_type (List.map copy_class_type_declaration x0)\n | From.Parsetree.Pstr_include x0 ->\n To.Parsetree.Pstr_include (copy_include_declaration x0)\n | From.Parsetree.Pstr_attribute x0 ->\n To.Parsetree.Pstr_attribute (copy_attribute x0)\n | From.Parsetree.Pstr_extension (x0, x1) ->\n To.Parsetree.Pstr_extension (copy_extension x0, copy_attributes x1)\n\nand copy_include_declaration :\n From.Parsetree.include_declaration -> To.Parsetree.include_declaration =\n fun x -> copy_include_infos copy_module_expr x\n\nand copy_class_declaration :\n From.Parsetree.class_declaration -> To.Parsetree.class_declaration =\n fun x -> copy_class_infos copy_class_expr x\n\nand copy_class_expr : From.Parsetree.class_expr -> To.Parsetree.class_expr =\n fun {\n From.Parsetree.pcl_desc;\n From.Parsetree.pcl_loc;\n From.Parsetree.pcl_attributes;\n } ->\n {\n To.Parsetree.pcl_desc = copy_class_expr_desc pcl_desc;\n To.Parsetree.pcl_loc = copy_location pcl_loc;\n To.Parsetree.pcl_attributes = copy_attributes pcl_attributes;\n }\n\nand copy_class_expr_desc :\n From.Parsetree.class_expr_desc -> To.Parsetree.class_expr_desc = function\n | From.Parsetree.Pcl_constr (x0, x1) ->\n To.Parsetree.Pcl_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Pcl_structure x0 ->\n To.Parsetree.Pcl_structure (copy_class_structure x0)\n | From.Parsetree.Pcl_fun (x0, x1, x2, x3) ->\n To.Parsetree.Pcl_fun\n ( copy_arg_label x0,\n copy_option copy_expression x1,\n copy_pattern x2,\n copy_class_expr x3 )\n | From.Parsetree.Pcl_apply (x0, x1) ->\n To.Parsetree.Pcl_apply\n ( copy_class_expr x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | From.Parsetree.Pcl_let (x0, x1, x2) ->\n To.Parsetree.Pcl_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_class_expr x2)\n | From.Parsetree.Pcl_constraint (x0, x1) ->\n To.Parsetree.Pcl_constraint (copy_class_expr x0, copy_class_type x1)\n | From.Parsetree.Pcl_extension x0 ->\n To.Parsetree.Pcl_extension (copy_extension x0)\n\nand copy_class_structure :\n From.Parsetree.class_structure -> To.Parsetree.class_structure =\n fun { From.Parsetree.pcstr_self; From.Parsetree.pcstr_fields } ->\n {\n To.Parsetree.pcstr_self = copy_pattern pcstr_self;\n To.Parsetree.pcstr_fields = List.map copy_class_field pcstr_fields;\n }\n\nand copy_class_field : From.Parsetree.class_field -> To.Parsetree.class_field =\n fun {\n From.Parsetree.pcf_desc;\n From.Parsetree.pcf_loc;\n From.Parsetree.pcf_attributes;\n } ->\n {\n To.Parsetree.pcf_desc = copy_class_field_desc pcf_desc;\n To.Parsetree.pcf_loc = copy_location pcf_loc;\n To.Parsetree.pcf_attributes = copy_attributes pcf_attributes;\n }\n\nand copy_class_field_desc :\n From.Parsetree.class_field_desc -> To.Parsetree.class_field_desc = function\n | From.Parsetree.Pcf_inherit (x0, x1, x2) ->\n To.Parsetree.Pcf_inherit\n ( copy_override_flag x0,\n copy_class_expr x1,\n copy_option (fun x -> x.From.Asttypes.txt) x2 )\n | From.Parsetree.Pcf_val x0 ->\n To.Parsetree.Pcf_val\n (let x0, x1, x2 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_mutable_flag x1,\n copy_class_field_kind x2 ))\n | From.Parsetree.Pcf_method x0 ->\n To.Parsetree.Pcf_method\n (let x0, x1, x2 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_private_flag x1,\n copy_class_field_kind x2 ))\n | From.Parsetree.Pcf_constraint x0 ->\n To.Parsetree.Pcf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | From.Parsetree.Pcf_initializer x0 ->\n To.Parsetree.Pcf_initializer (copy_expression x0)\n | From.Parsetree.Pcf_attribute x0 ->\n To.Parsetree.Pcf_attribute (copy_attribute x0)\n | From.Parsetree.Pcf_extension x0 ->\n To.Parsetree.Pcf_extension (copy_extension x0)\n\nand copy_class_field_kind :\n From.Parsetree.class_field_kind -> To.Parsetree.class_field_kind = function\n | From.Parsetree.Cfk_virtual x0 ->\n To.Parsetree.Cfk_virtual (copy_core_type x0)\n | From.Parsetree.Cfk_concrete (x0, x1) ->\n To.Parsetree.Cfk_concrete (copy_override_flag x0, copy_expression x1)\n\nand copy_module_binding :\n From.Parsetree.module_binding -> To.Parsetree.module_binding =\n fun {\n From.Parsetree.pmb_name;\n From.Parsetree.pmb_expr;\n From.Parsetree.pmb_attributes;\n From.Parsetree.pmb_loc;\n } ->\n {\n To.Parsetree.pmb_name = copy_loc (fun x -> x) pmb_name;\n To.Parsetree.pmb_expr = copy_module_expr pmb_expr;\n To.Parsetree.pmb_attributes = copy_attributes pmb_attributes;\n To.Parsetree.pmb_loc = copy_location pmb_loc;\n }\n\nand copy_module_expr : From.Parsetree.module_expr -> To.Parsetree.module_expr =\n fun {\n From.Parsetree.pmod_desc;\n From.Parsetree.pmod_loc;\n From.Parsetree.pmod_attributes;\n } ->\n {\n To.Parsetree.pmod_desc = copy_module_expr_desc pmod_desc;\n To.Parsetree.pmod_loc = copy_location pmod_loc;\n To.Parsetree.pmod_attributes = copy_attributes pmod_attributes;\n }\n\nand copy_module_expr_desc :\n From.Parsetree.module_expr_desc -> To.Parsetree.module_expr_desc = function\n | From.Parsetree.Pmod_ident x0 ->\n To.Parsetree.Pmod_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pmod_structure x0 ->\n To.Parsetree.Pmod_structure (copy_structure x0)\n | From.Parsetree.Pmod_functor (x0, x1, x2) ->\n To.Parsetree.Pmod_functor\n ( copy_loc (fun x -> x) x0,\n copy_option copy_module_type x1,\n copy_module_expr x2 )\n | From.Parsetree.Pmod_apply (x0, x1) ->\n To.Parsetree.Pmod_apply (copy_module_expr x0, copy_module_expr x1)\n | From.Parsetree.Pmod_constraint (x0, x1) ->\n To.Parsetree.Pmod_constraint (copy_module_expr x0, copy_module_type x1)\n | From.Parsetree.Pmod_unpack x0 ->\n To.Parsetree.Pmod_unpack (copy_expression x0)\n | From.Parsetree.Pmod_extension x0 ->\n To.Parsetree.Pmod_extension (copy_extension x0)\n\nand copy_module_type : From.Parsetree.module_type -> To.Parsetree.module_type =\n fun {\n From.Parsetree.pmty_desc;\n From.Parsetree.pmty_loc;\n From.Parsetree.pmty_attributes;\n } ->\n {\n To.Parsetree.pmty_desc = copy_module_type_desc pmty_desc;\n To.Parsetree.pmty_loc = copy_location pmty_loc;\n To.Parsetree.pmty_attributes = copy_attributes pmty_attributes;\n }\n\nand copy_module_type_desc :\n From.Parsetree.module_type_desc -> To.Parsetree.module_type_desc = function\n | From.Parsetree.Pmty_ident x0 ->\n To.Parsetree.Pmty_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pmty_signature x0 ->\n To.Parsetree.Pmty_signature (copy_signature x0)\n | From.Parsetree.Pmty_functor (x0, x1, x2) ->\n To.Parsetree.Pmty_functor\n ( copy_loc (fun x -> x) x0,\n copy_option copy_module_type x1,\n copy_module_type x2 )\n | From.Parsetree.Pmty_with (x0, x1) ->\n To.Parsetree.Pmty_with\n (copy_module_type x0, List.map copy_with_constraint x1)\n | From.Parsetree.Pmty_typeof x0 ->\n To.Parsetree.Pmty_typeof (copy_module_expr x0)\n | From.Parsetree.Pmty_extension x0 ->\n To.Parsetree.Pmty_extension (copy_extension x0)\n | From.Parsetree.Pmty_alias x0 ->\n To.Parsetree.Pmty_alias (copy_loc copy_longident x0)\n\nand copy_with_constraint :\n From.Parsetree.with_constraint -> To.Parsetree.with_constraint = function\n | From.Parsetree.Pwith_type (x0, x1) ->\n To.Parsetree.Pwith_type\n (copy_loc copy_longident x0, copy_type_declaration x1)\n | From.Parsetree.Pwith_module (x0, x1) ->\n To.Parsetree.Pwith_module\n (copy_loc copy_longident x0, copy_loc copy_longident x1)\n | From.Parsetree.Pwith_typesubst x0 ->\n To.Parsetree.Pwith_typesubst (copy_type_declaration x0)\n | From.Parsetree.Pwith_modsubst (x0, x1) ->\n To.Parsetree.Pwith_modsubst\n (copy_loc (fun x -> x) x0, copy_loc copy_longident x1)\n\nand copy_signature : From.Parsetree.signature -> To.Parsetree.signature =\n fun x -> List.map copy_signature_item x\n\nand copy_signature_item :\n From.Parsetree.signature_item -> To.Parsetree.signature_item =\n fun { From.Parsetree.psig_desc; From.Parsetree.psig_loc } ->\n {\n To.Parsetree.psig_desc = copy_signature_item_desc psig_desc;\n To.Parsetree.psig_loc = copy_location psig_loc;\n }\n\nand copy_signature_item_desc :\n From.Parsetree.signature_item_desc -> To.Parsetree.signature_item_desc =\n function\n | From.Parsetree.Psig_value x0 ->\n To.Parsetree.Psig_value (copy_value_description x0)\n | From.Parsetree.Psig_type (x0, x1) ->\n To.Parsetree.Psig_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | From.Parsetree.Psig_typext x0 ->\n To.Parsetree.Psig_typext (copy_type_extension x0)\n | From.Parsetree.Psig_exception x0 ->\n To.Parsetree.Psig_exception (copy_extension_constructor x0)\n | From.Parsetree.Psig_module x0 ->\n To.Parsetree.Psig_module (copy_module_declaration x0)\n | From.Parsetree.Psig_recmodule x0 ->\n To.Parsetree.Psig_recmodule (List.map copy_module_declaration x0)\n | From.Parsetree.Psig_modtype x0 ->\n To.Parsetree.Psig_modtype (copy_module_type_declaration x0)\n | From.Parsetree.Psig_open x0 ->\n To.Parsetree.Psig_open (copy_open_description x0)\n | From.Parsetree.Psig_include x0 ->\n To.Parsetree.Psig_include (copy_include_description x0)\n | From.Parsetree.Psig_class x0 ->\n To.Parsetree.Psig_class (List.map copy_class_description x0)\n | From.Parsetree.Psig_class_type x0 ->\n To.Parsetree.Psig_class_type (List.map copy_class_type_declaration x0)\n | From.Parsetree.Psig_attribute x0 ->\n To.Parsetree.Psig_attribute (copy_attribute x0)\n | From.Parsetree.Psig_extension (x0, x1) ->\n To.Parsetree.Psig_extension (copy_extension x0, copy_attributes x1)\n\nand copy_class_type_declaration :\n From.Parsetree.class_type_declaration -> To.Parsetree.class_type_declaration\n =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_description :\n From.Parsetree.class_description -> To.Parsetree.class_description =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_type : From.Parsetree.class_type -> To.Parsetree.class_type =\n fun {\n From.Parsetree.pcty_desc;\n From.Parsetree.pcty_loc;\n From.Parsetree.pcty_attributes;\n } ->\n {\n To.Parsetree.pcty_desc = copy_class_type_desc pcty_desc;\n To.Parsetree.pcty_loc = copy_location pcty_loc;\n To.Parsetree.pcty_attributes = copy_attributes pcty_attributes;\n }\n\nand copy_class_type_desc :\n From.Parsetree.class_type_desc -> To.Parsetree.class_type_desc = function\n | From.Parsetree.Pcty_constr (x0, x1) ->\n To.Parsetree.Pcty_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Pcty_signature x0 ->\n To.Parsetree.Pcty_signature (copy_class_signature x0)\n | From.Parsetree.Pcty_arrow (x0, x1, x2) ->\n To.Parsetree.Pcty_arrow\n (copy_arg_label x0, copy_core_type x1, copy_class_type x2)\n | From.Parsetree.Pcty_extension x0 ->\n To.Parsetree.Pcty_extension (copy_extension x0)\n\nand copy_class_signature :\n From.Parsetree.class_signature -> To.Parsetree.class_signature =\n fun { From.Parsetree.pcsig_self; From.Parsetree.pcsig_fields } ->\n {\n To.Parsetree.pcsig_self = copy_core_type pcsig_self;\n To.Parsetree.pcsig_fields = List.map copy_class_type_field pcsig_fields;\n }\n\nand copy_class_type_field :\n From.Parsetree.class_type_field -> To.Parsetree.class_type_field =\n fun {\n From.Parsetree.pctf_desc;\n From.Parsetree.pctf_loc;\n From.Parsetree.pctf_attributes;\n } ->\n {\n To.Parsetree.pctf_desc = copy_class_type_field_desc pctf_desc;\n To.Parsetree.pctf_loc = copy_location pctf_loc;\n To.Parsetree.pctf_attributes = copy_attributes pctf_attributes;\n }\n\nand copy_class_type_field_desc :\n From.Parsetree.class_type_field_desc -> To.Parsetree.class_type_field_desc =\n function\n | From.Parsetree.Pctf_inherit x0 ->\n To.Parsetree.Pctf_inherit (copy_class_type x0)\n | From.Parsetree.Pctf_val x0 ->\n To.Parsetree.Pctf_val\n (let x0, x1, x2, x3 = x0 in\n ( x0.From.Asttypes.txt,\n copy_mutable_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | From.Parsetree.Pctf_method x0 ->\n To.Parsetree.Pctf_method\n (let x0, x1, x2, x3 = x0 in\n ( x0.From.Asttypes.txt,\n copy_private_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | From.Parsetree.Pctf_constraint x0 ->\n To.Parsetree.Pctf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | From.Parsetree.Pctf_attribute x0 ->\n To.Parsetree.Pctf_attribute (copy_attribute x0)\n | From.Parsetree.Pctf_extension x0 ->\n To.Parsetree.Pctf_extension (copy_extension x0)\n\nand copy_extension : From.Parsetree.extension -> To.Parsetree.extension =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_class_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 From.Parsetree.class_infos ->\n 'g0 To.Parsetree.class_infos =\n fun f0\n {\n From.Parsetree.pci_virt;\n From.Parsetree.pci_params;\n From.Parsetree.pci_name;\n From.Parsetree.pci_expr;\n From.Parsetree.pci_loc;\n From.Parsetree.pci_attributes;\n } ->\n {\n To.Parsetree.pci_virt = copy_virtual_flag pci_virt;\n To.Parsetree.pci_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n pci_params;\n To.Parsetree.pci_name = copy_loc (fun x -> x) pci_name;\n To.Parsetree.pci_expr = f0 pci_expr;\n To.Parsetree.pci_loc = copy_location pci_loc;\n To.Parsetree.pci_attributes = copy_attributes pci_attributes;\n }\n\nand copy_virtual_flag : From.Asttypes.virtual_flag -> To.Asttypes.virtual_flag =\n function\n | From.Asttypes.Virtual -> To.Asttypes.Virtual\n | From.Asttypes.Concrete -> To.Asttypes.Concrete\n\nand copy_include_description :\n From.Parsetree.include_description -> To.Parsetree.include_description =\n fun x -> copy_include_infos copy_module_type x\n\nand copy_include_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 From.Parsetree.include_infos ->\n 'g0 To.Parsetree.include_infos =\n fun f0\n {\n From.Parsetree.pincl_mod;\n From.Parsetree.pincl_loc;\n From.Parsetree.pincl_attributes;\n } ->\n {\n To.Parsetree.pincl_mod = f0 pincl_mod;\n To.Parsetree.pincl_loc = copy_location pincl_loc;\n To.Parsetree.pincl_attributes = copy_attributes pincl_attributes;\n }\n\nand copy_open_description :\n From.Parsetree.open_description -> To.Parsetree.open_description =\n fun {\n From.Parsetree.popen_lid;\n From.Parsetree.popen_override;\n From.Parsetree.popen_loc;\n From.Parsetree.popen_attributes;\n } ->\n {\n To.Parsetree.popen_lid = copy_loc copy_longident popen_lid;\n To.Parsetree.popen_override = copy_override_flag popen_override;\n To.Parsetree.popen_loc = copy_location popen_loc;\n To.Parsetree.popen_attributes = copy_attributes popen_attributes;\n }\n\nand copy_override_flag :\n From.Asttypes.override_flag -> To.Asttypes.override_flag = function\n | From.Asttypes.Override -> To.Asttypes.Override\n | From.Asttypes.Fresh -> To.Asttypes.Fresh\n\nand copy_module_type_declaration :\n From.Parsetree.module_type_declaration ->\n To.Parsetree.module_type_declaration =\n fun {\n From.Parsetree.pmtd_name;\n From.Parsetree.pmtd_type;\n From.Parsetree.pmtd_attributes;\n From.Parsetree.pmtd_loc;\n } ->\n {\n To.Parsetree.pmtd_name = copy_loc (fun x -> x) pmtd_name;\n To.Parsetree.pmtd_type = copy_option copy_module_type pmtd_type;\n To.Parsetree.pmtd_attributes = copy_attributes pmtd_attributes;\n To.Parsetree.pmtd_loc = copy_location pmtd_loc;\n }\n\nand copy_module_declaration :\n From.Parsetree.module_declaration -> To.Parsetree.module_declaration =\n fun {\n From.Parsetree.pmd_name;\n From.Parsetree.pmd_type;\n From.Parsetree.pmd_attributes;\n From.Parsetree.pmd_loc;\n } ->\n {\n To.Parsetree.pmd_name = copy_loc (fun x -> x) pmd_name;\n To.Parsetree.pmd_type = copy_module_type pmd_type;\n To.Parsetree.pmd_attributes = copy_attributes pmd_attributes;\n To.Parsetree.pmd_loc = copy_location pmd_loc;\n }\n\nand copy_type_extension :\n From.Parsetree.type_extension -> To.Parsetree.type_extension =\n fun {\n From.Parsetree.ptyext_path;\n From.Parsetree.ptyext_params;\n From.Parsetree.ptyext_constructors;\n From.Parsetree.ptyext_private;\n From.Parsetree.ptyext_attributes;\n } ->\n {\n To.Parsetree.ptyext_path = copy_loc copy_longident ptyext_path;\n To.Parsetree.ptyext_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptyext_params;\n To.Parsetree.ptyext_constructors =\n List.map copy_extension_constructor ptyext_constructors;\n To.Parsetree.ptyext_private = copy_private_flag ptyext_private;\n To.Parsetree.ptyext_attributes = copy_attributes ptyext_attributes;\n }\n\nand copy_extension_constructor :\n From.Parsetree.extension_constructor -> To.Parsetree.extension_constructor =\n fun {\n From.Parsetree.pext_name;\n From.Parsetree.pext_kind;\n From.Parsetree.pext_loc;\n From.Parsetree.pext_attributes;\n } ->\n {\n To.Parsetree.pext_name = copy_loc (fun x -> x) pext_name;\n To.Parsetree.pext_kind = copy_extension_constructor_kind pext_kind;\n To.Parsetree.pext_loc = copy_location pext_loc;\n To.Parsetree.pext_attributes = copy_attributes pext_attributes;\n }\n\nand copy_extension_constructor_kind :\n From.Parsetree.extension_constructor_kind ->\n To.Parsetree.extension_constructor_kind = function\n | From.Parsetree.Pext_decl (x0, x1) ->\n To.Parsetree.Pext_decl\n (copy_constructor_arguments x0, copy_option copy_core_type x1)\n | From.Parsetree.Pext_rebind x0 ->\n To.Parsetree.Pext_rebind (copy_loc copy_longident x0)\n\nand copy_type_declaration :\n From.Parsetree.type_declaration -> To.Parsetree.type_declaration =\n fun {\n From.Parsetree.ptype_name;\n From.Parsetree.ptype_params;\n From.Parsetree.ptype_cstrs;\n From.Parsetree.ptype_kind;\n From.Parsetree.ptype_private;\n From.Parsetree.ptype_manifest;\n From.Parsetree.ptype_attributes;\n From.Parsetree.ptype_loc;\n } ->\n {\n To.Parsetree.ptype_name = copy_loc (fun x -> x) ptype_name;\n To.Parsetree.ptype_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptype_params;\n To.Parsetree.ptype_cstrs =\n List.map\n (fun x ->\n let x0, x1, x2 = x in\n (copy_core_type x0, copy_core_type x1, copy_location x2))\n ptype_cstrs;\n To.Parsetree.ptype_kind = copy_type_kind ptype_kind;\n To.Parsetree.ptype_private = copy_private_flag ptype_private;\n To.Parsetree.ptype_manifest = copy_option copy_core_type ptype_manifest;\n To.Parsetree.ptype_attributes = copy_attributes ptype_attributes;\n To.Parsetree.ptype_loc = copy_location ptype_loc;\n }\n\nand copy_private_flag : From.Asttypes.private_flag -> To.Asttypes.private_flag =\n function\n | From.Asttypes.Private -> To.Asttypes.Private\n | From.Asttypes.Public -> To.Asttypes.Public\n\nand copy_type_kind : From.Parsetree.type_kind -> To.Parsetree.type_kind =\n function\n | From.Parsetree.Ptype_abstract -> To.Parsetree.Ptype_abstract\n | From.Parsetree.Ptype_variant x0 ->\n To.Parsetree.Ptype_variant (List.map copy_constructor_declaration x0)\n | From.Parsetree.Ptype_record x0 ->\n To.Parsetree.Ptype_record (List.map copy_label_declaration x0)\n | From.Parsetree.Ptype_open -> To.Parsetree.Ptype_open\n\nand copy_constructor_declaration :\n From.Parsetree.constructor_declaration ->\n To.Parsetree.constructor_declaration =\n fun {\n From.Parsetree.pcd_name;\n From.Parsetree.pcd_args;\n From.Parsetree.pcd_res;\n From.Parsetree.pcd_loc;\n From.Parsetree.pcd_attributes;\n } ->\n {\n To.Parsetree.pcd_name = copy_loc (fun x -> x) pcd_name;\n To.Parsetree.pcd_args = copy_constructor_arguments pcd_args;\n To.Parsetree.pcd_res = copy_option copy_core_type pcd_res;\n To.Parsetree.pcd_loc = copy_location pcd_loc;\n To.Parsetree.pcd_attributes = copy_attributes pcd_attributes;\n }\n\nand copy_constructor_arguments :\n From.Parsetree.constructor_arguments -> To.Parsetree.constructor_arguments =\n function\n | From.Parsetree.Pcstr_tuple x0 ->\n To.Parsetree.Pcstr_tuple (List.map copy_core_type x0)\n | From.Parsetree.Pcstr_record x0 ->\n To.Parsetree.Pcstr_record (List.map copy_label_declaration x0)\n\nand copy_label_declaration :\n From.Parsetree.label_declaration -> To.Parsetree.label_declaration =\n fun {\n From.Parsetree.pld_name;\n From.Parsetree.pld_mutable;\n From.Parsetree.pld_type;\n From.Parsetree.pld_loc;\n From.Parsetree.pld_attributes;\n } ->\n {\n To.Parsetree.pld_name = copy_loc (fun x -> x) pld_name;\n To.Parsetree.pld_mutable = copy_mutable_flag pld_mutable;\n To.Parsetree.pld_type = copy_core_type pld_type;\n To.Parsetree.pld_loc = copy_location pld_loc;\n To.Parsetree.pld_attributes = copy_attributes pld_attributes;\n }\n\nand copy_mutable_flag : From.Asttypes.mutable_flag -> To.Asttypes.mutable_flag =\n function\n | From.Asttypes.Immutable -> To.Asttypes.Immutable\n | From.Asttypes.Mutable -> To.Asttypes.Mutable\n\nand copy_variance : From.Asttypes.variance -> To.Asttypes.variance = function\n | From.Asttypes.Covariant -> To.Asttypes.Covariant\n | From.Asttypes.Contravariant -> To.Asttypes.Contravariant\n | From.Asttypes.Invariant -> To.Asttypes.Invariant\n\nand copy_value_description :\n From.Parsetree.value_description -> To.Parsetree.value_description =\n fun {\n From.Parsetree.pval_name;\n From.Parsetree.pval_type;\n From.Parsetree.pval_prim;\n From.Parsetree.pval_attributes;\n From.Parsetree.pval_loc;\n } ->\n {\n To.Parsetree.pval_name = copy_loc (fun x -> x) pval_name;\n To.Parsetree.pval_type = copy_core_type pval_type;\n To.Parsetree.pval_prim = List.map (fun x -> x) pval_prim;\n To.Parsetree.pval_attributes = copy_attributes pval_attributes;\n To.Parsetree.pval_loc = copy_location pval_loc;\n }\n\nand copy_arg_label : From.Asttypes.arg_label -> To.Asttypes.arg_label = function\n | From.Asttypes.Nolabel -> To.Asttypes.Nolabel\n | From.Asttypes.Labelled x0 -> To.Asttypes.Labelled x0\n | From.Asttypes.Optional x0 -> To.Asttypes.Optional x0\n\nand copy_closed_flag : From.Asttypes.closed_flag -> To.Asttypes.closed_flag =\n function\n | From.Asttypes.Closed -> To.Asttypes.Closed\n | From.Asttypes.Open -> To.Asttypes.Open\n\nand copy_label : From.Asttypes.label -> To.Asttypes.label = fun x -> x\n\nand copy_rec_flag : From.Asttypes.rec_flag -> To.Asttypes.rec_flag = function\n | From.Asttypes.Nonrecursive -> To.Asttypes.Nonrecursive\n | From.Asttypes.Recursive -> To.Asttypes.Recursive\n\nand copy_constant : From.Parsetree.constant -> To.Parsetree.constant = function\n | From.Parsetree.Pconst_integer (x0, x1) ->\n To.Parsetree.Pconst_integer (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pconst_char x0 -> To.Parsetree.Pconst_char x0\n | From.Parsetree.Pconst_string (x0, x1) ->\n To.Parsetree.Pconst_string (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pconst_float (x0, x1) ->\n To.Parsetree.Pconst_float (x0, copy_option (fun x -> x) x1)\n\nand copy_option : 'f0 'g0. ('f0 -> 'g0) -> 'f0 option -> 'g0 option =\n fun f0 -> function None -> None | Some x0 -> Some (f0 x0)\n\nand copy_longident : Longident.t -> Longident.t = fun x -> x\n\nand copy_loc :\n 'f0 'g0. ('f0 -> 'g0) -> 'f0 From.Asttypes.loc -> 'g0 To.Asttypes.loc =\n fun f0 { From.Asttypes.txt; From.Asttypes.loc } ->\n { To.Asttypes.txt = f0 txt; To.Asttypes.loc = copy_location loc }\n\nand copy_location : Location.t -> Location.t = fun x -> x\nand copy_bool : bool -> bool = function false -> false | true -> true\n\nlet rec copy_toplevel_phrase :\n From.Parsetree.toplevel_phrase -> To.Parsetree.toplevel_phrase = function\n | From.Parsetree.Ptop_def x0 -> To.Parsetree.Ptop_def (copy_structure x0)\n | From.Parsetree.Ptop_dir (x0, x1) ->\n To.Parsetree.Ptop_dir (x0, copy_directive_argument x1)\n\nand copy_directive_argument :\n From.Parsetree.directive_argument -> To.Parsetree.directive_argument =\n function\n | From.Parsetree.Pdir_none -> To.Parsetree.Pdir_none\n | From.Parsetree.Pdir_string x0 -> To.Parsetree.Pdir_string x0\n | From.Parsetree.Pdir_int (x0, x1) ->\n To.Parsetree.Pdir_int (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pdir_ident x0 -> To.Parsetree.Pdir_ident (copy_longident x0)\n | From.Parsetree.Pdir_bool x0 -> To.Parsetree.Pdir_bool (copy_bool x0)\n\nlet copy_cases x = List.map copy_case x\nlet copy_pat = copy_pattern\nlet copy_expr = copy_expression\nlet copy_typ = copy_core_type\n","(**************************************************************************)\n(* *)\n(* OCaml Migrate Parsetree *)\n(* *)\n(* Frédéric Bour *)\n(* Alain Frisch, LexiFi *)\n(* *)\n(* Copyright 2017 Institut National de Recherche en Informatique et *)\n(* en Automatique (INRIA). *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nmodule From = Ast_404\nmodule To = Ast_405\n\nlet noloc x = { Location.txt = x; loc = Location.none }\n\nlet rec copy_expression : From.Parsetree.expression -> To.Parsetree.expression =\n fun {\n From.Parsetree.pexp_desc;\n From.Parsetree.pexp_loc;\n From.Parsetree.pexp_attributes;\n } ->\n {\n To.Parsetree.pexp_desc = copy_expression_desc pexp_desc;\n To.Parsetree.pexp_loc = copy_location pexp_loc;\n To.Parsetree.pexp_attributes = copy_attributes pexp_attributes;\n }\n\nand copy_expression_desc :\n From.Parsetree.expression_desc -> To.Parsetree.expression_desc = function\n | From.Parsetree.Pexp_ident x0 ->\n To.Parsetree.Pexp_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pexp_constant x0 ->\n To.Parsetree.Pexp_constant (copy_constant x0)\n | From.Parsetree.Pexp_let (x0, x1, x2) ->\n To.Parsetree.Pexp_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_expression x2)\n | From.Parsetree.Pexp_function x0 ->\n To.Parsetree.Pexp_function (List.map copy_case x0)\n | From.Parsetree.Pexp_fun (x0, x1, x2, x3) ->\n To.Parsetree.Pexp_fun\n ( copy_arg_label x0,\n copy_option copy_expression x1,\n copy_pattern x2,\n copy_expression x3 )\n | From.Parsetree.Pexp_apply (x0, x1) ->\n To.Parsetree.Pexp_apply\n ( copy_expression x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | From.Parsetree.Pexp_match (x0, x1) ->\n To.Parsetree.Pexp_match (copy_expression x0, List.map copy_case x1)\n | From.Parsetree.Pexp_try (x0, x1) ->\n To.Parsetree.Pexp_try (copy_expression x0, List.map copy_case x1)\n | From.Parsetree.Pexp_tuple x0 ->\n To.Parsetree.Pexp_tuple (List.map copy_expression x0)\n | From.Parsetree.Pexp_construct (x0, x1) ->\n To.Parsetree.Pexp_construct\n (copy_loc copy_longident x0, copy_option copy_expression x1)\n | From.Parsetree.Pexp_variant (x0, x1) ->\n To.Parsetree.Pexp_variant (copy_label x0, copy_option copy_expression x1)\n | From.Parsetree.Pexp_record (x0, x1) ->\n To.Parsetree.Pexp_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_expression x1))\n x0,\n copy_option copy_expression x1 )\n | From.Parsetree.Pexp_field (x0, x1) ->\n To.Parsetree.Pexp_field (copy_expression x0, copy_loc copy_longident x1)\n | From.Parsetree.Pexp_setfield (x0, x1, x2) ->\n To.Parsetree.Pexp_setfield\n (copy_expression x0, copy_loc copy_longident x1, copy_expression x2)\n | From.Parsetree.Pexp_array x0 ->\n To.Parsetree.Pexp_array (List.map copy_expression x0)\n | From.Parsetree.Pexp_ifthenelse (x0, x1, x2) ->\n To.Parsetree.Pexp_ifthenelse\n (copy_expression x0, copy_expression x1, copy_option copy_expression x2)\n | From.Parsetree.Pexp_sequence (x0, x1) ->\n To.Parsetree.Pexp_sequence (copy_expression x0, copy_expression x1)\n | From.Parsetree.Pexp_while (x0, x1) ->\n To.Parsetree.Pexp_while (copy_expression x0, copy_expression x1)\n | From.Parsetree.Pexp_for (x0, x1, x2, x3, x4) ->\n To.Parsetree.Pexp_for\n ( copy_pattern x0,\n copy_expression x1,\n copy_expression x2,\n copy_direction_flag x3,\n copy_expression x4 )\n | From.Parsetree.Pexp_constraint (x0, x1) ->\n To.Parsetree.Pexp_constraint (copy_expression x0, copy_core_type x1)\n | From.Parsetree.Pexp_coerce (x0, x1, x2) ->\n To.Parsetree.Pexp_coerce\n (copy_expression x0, copy_option copy_core_type x1, copy_core_type x2)\n | From.Parsetree.Pexp_send (x0, x1) ->\n To.Parsetree.Pexp_send (copy_expression x0, noloc x1)\n | From.Parsetree.Pexp_new x0 ->\n To.Parsetree.Pexp_new (copy_loc copy_longident x0)\n | From.Parsetree.Pexp_setinstvar (x0, x1) ->\n To.Parsetree.Pexp_setinstvar (copy_loc (fun x -> x) x0, copy_expression x1)\n | From.Parsetree.Pexp_override x0 ->\n To.Parsetree.Pexp_override\n (List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_expression x1))\n x0)\n | From.Parsetree.Pexp_letmodule (x0, x1, x2) ->\n To.Parsetree.Pexp_letmodule\n (copy_loc (fun x -> x) x0, copy_module_expr x1, copy_expression x2)\n | From.Parsetree.Pexp_letexception (x0, x1) ->\n To.Parsetree.Pexp_letexception\n (copy_extension_constructor x0, copy_expression x1)\n | From.Parsetree.Pexp_assert x0 ->\n To.Parsetree.Pexp_assert (copy_expression x0)\n | From.Parsetree.Pexp_lazy x0 -> To.Parsetree.Pexp_lazy (copy_expression x0)\n | From.Parsetree.Pexp_poly (x0, x1) ->\n To.Parsetree.Pexp_poly (copy_expression x0, copy_option copy_core_type x1)\n | From.Parsetree.Pexp_object x0 ->\n To.Parsetree.Pexp_object (copy_class_structure x0)\n | From.Parsetree.Pexp_newtype (x0, x1) ->\n To.Parsetree.Pexp_newtype (noloc x0, copy_expression x1)\n | From.Parsetree.Pexp_pack x0 -> To.Parsetree.Pexp_pack (copy_module_expr x0)\n | From.Parsetree.Pexp_open (x0, x1, x2) ->\n To.Parsetree.Pexp_open\n (copy_override_flag x0, copy_loc copy_longident x1, copy_expression x2)\n | From.Parsetree.Pexp_extension x0 ->\n To.Parsetree.Pexp_extension (copy_extension x0)\n | From.Parsetree.Pexp_unreachable -> To.Parsetree.Pexp_unreachable\n\nand copy_direction_flag :\n From.Asttypes.direction_flag -> To.Asttypes.direction_flag = function\n | From.Asttypes.Upto -> To.Asttypes.Upto\n | From.Asttypes.Downto -> To.Asttypes.Downto\n\nand copy_case : From.Parsetree.case -> To.Parsetree.case =\n fun { From.Parsetree.pc_lhs; From.Parsetree.pc_guard; From.Parsetree.pc_rhs } ->\n {\n To.Parsetree.pc_lhs = copy_pattern pc_lhs;\n To.Parsetree.pc_guard = copy_option copy_expression pc_guard;\n To.Parsetree.pc_rhs = copy_expression pc_rhs;\n }\n\nand copy_value_binding :\n From.Parsetree.value_binding -> To.Parsetree.value_binding =\n fun {\n From.Parsetree.pvb_pat;\n From.Parsetree.pvb_expr;\n From.Parsetree.pvb_attributes;\n From.Parsetree.pvb_loc;\n } ->\n {\n To.Parsetree.pvb_pat = copy_pattern pvb_pat;\n To.Parsetree.pvb_expr = copy_expression pvb_expr;\n To.Parsetree.pvb_attributes = copy_attributes pvb_attributes;\n To.Parsetree.pvb_loc = copy_location pvb_loc;\n }\n\nand copy_pattern : From.Parsetree.pattern -> To.Parsetree.pattern =\n fun {\n From.Parsetree.ppat_desc;\n From.Parsetree.ppat_loc;\n From.Parsetree.ppat_attributes;\n } ->\n {\n To.Parsetree.ppat_desc = copy_pattern_desc ppat_desc;\n To.Parsetree.ppat_loc = copy_location ppat_loc;\n To.Parsetree.ppat_attributes = copy_attributes ppat_attributes;\n }\n\nand copy_pattern_desc : From.Parsetree.pattern_desc -> To.Parsetree.pattern_desc\n = function\n | From.Parsetree.Ppat_any -> To.Parsetree.Ppat_any\n | From.Parsetree.Ppat_var x0 ->\n To.Parsetree.Ppat_var (copy_loc (fun x -> x) x0)\n | From.Parsetree.Ppat_alias (x0, x1) ->\n To.Parsetree.Ppat_alias (copy_pattern x0, copy_loc (fun x -> x) x1)\n | From.Parsetree.Ppat_constant x0 ->\n To.Parsetree.Ppat_constant (copy_constant x0)\n | From.Parsetree.Ppat_interval (x0, x1) ->\n To.Parsetree.Ppat_interval (copy_constant x0, copy_constant x1)\n | From.Parsetree.Ppat_tuple x0 ->\n To.Parsetree.Ppat_tuple (List.map copy_pattern x0)\n | From.Parsetree.Ppat_construct (x0, x1) ->\n To.Parsetree.Ppat_construct\n (copy_loc copy_longident x0, copy_option copy_pattern x1)\n | From.Parsetree.Ppat_variant (x0, x1) ->\n To.Parsetree.Ppat_variant (copy_label x0, copy_option copy_pattern x1)\n | From.Parsetree.Ppat_record (x0, x1) ->\n To.Parsetree.Ppat_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_pattern x1))\n x0,\n copy_closed_flag x1 )\n | From.Parsetree.Ppat_array x0 ->\n To.Parsetree.Ppat_array (List.map copy_pattern x0)\n | From.Parsetree.Ppat_or (x0, x1) ->\n To.Parsetree.Ppat_or (copy_pattern x0, copy_pattern x1)\n | From.Parsetree.Ppat_constraint (x0, x1) ->\n To.Parsetree.Ppat_constraint (copy_pattern x0, copy_core_type x1)\n | From.Parsetree.Ppat_type x0 ->\n To.Parsetree.Ppat_type (copy_loc copy_longident x0)\n | From.Parsetree.Ppat_lazy x0 -> To.Parsetree.Ppat_lazy (copy_pattern x0)\n | From.Parsetree.Ppat_unpack x0 ->\n To.Parsetree.Ppat_unpack (copy_loc (fun x -> x) x0)\n | From.Parsetree.Ppat_exception x0 ->\n To.Parsetree.Ppat_exception (copy_pattern x0)\n | From.Parsetree.Ppat_extension x0 ->\n To.Parsetree.Ppat_extension (copy_extension x0)\n | From.Parsetree.Ppat_open (x0, x1) ->\n To.Parsetree.Ppat_open (copy_loc copy_longident x0, copy_pattern x1)\n\nand copy_core_type : From.Parsetree.core_type -> To.Parsetree.core_type =\n fun {\n From.Parsetree.ptyp_desc;\n From.Parsetree.ptyp_loc;\n From.Parsetree.ptyp_attributes;\n } ->\n {\n To.Parsetree.ptyp_desc = copy_core_type_desc ptyp_desc;\n To.Parsetree.ptyp_loc = copy_location ptyp_loc;\n To.Parsetree.ptyp_attributes = copy_attributes ptyp_attributes;\n }\n\nand copy_core_type_desc :\n From.Parsetree.core_type_desc -> To.Parsetree.core_type_desc = function\n | From.Parsetree.Ptyp_any -> To.Parsetree.Ptyp_any\n | From.Parsetree.Ptyp_var x0 -> To.Parsetree.Ptyp_var x0\n | From.Parsetree.Ptyp_arrow (x0, x1, x2) ->\n To.Parsetree.Ptyp_arrow\n (copy_arg_label x0, copy_core_type x1, copy_core_type x2)\n | From.Parsetree.Ptyp_tuple x0 ->\n To.Parsetree.Ptyp_tuple (List.map copy_core_type x0)\n | From.Parsetree.Ptyp_constr (x0, x1) ->\n To.Parsetree.Ptyp_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Ptyp_object (x0, x1) ->\n To.Parsetree.Ptyp_object\n ( List.map\n (fun x ->\n let x0, x1, x2 = x in\n (noloc x0, copy_attributes x1, copy_core_type x2))\n x0,\n copy_closed_flag x1 )\n | From.Parsetree.Ptyp_class (x0, x1) ->\n To.Parsetree.Ptyp_class\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Ptyp_alias (x0, x1) ->\n To.Parsetree.Ptyp_alias (copy_core_type x0, x1)\n | From.Parsetree.Ptyp_variant (x0, x1, x2) ->\n To.Parsetree.Ptyp_variant\n ( List.map copy_row_field x0,\n copy_closed_flag x1,\n copy_option (fun x -> List.map copy_label x) x2 )\n | From.Parsetree.Ptyp_poly (x0, x1) ->\n To.Parsetree.Ptyp_poly (List.map (fun x -> noloc x) x0, copy_core_type x1)\n | From.Parsetree.Ptyp_package x0 ->\n To.Parsetree.Ptyp_package (copy_package_type x0)\n | From.Parsetree.Ptyp_extension x0 ->\n To.Parsetree.Ptyp_extension (copy_extension x0)\n\nand copy_package_type : From.Parsetree.package_type -> To.Parsetree.package_type\n =\n fun x ->\n let x0, x1 = x in\n ( copy_loc copy_longident x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_core_type x1))\n x1 )\n\nand copy_row_field : From.Parsetree.row_field -> To.Parsetree.row_field =\n function\n | From.Parsetree.Rtag (x0, x1, x2, x3) ->\n To.Parsetree.Rtag\n ( copy_label x0,\n copy_attributes x1,\n copy_bool x2,\n List.map copy_core_type x3 )\n | From.Parsetree.Rinherit x0 -> To.Parsetree.Rinherit (copy_core_type x0)\n\nand copy_attributes : From.Parsetree.attributes -> To.Parsetree.attributes =\n fun x -> List.map copy_attribute x\n\nand copy_attribute : From.Parsetree.attribute -> To.Parsetree.attribute =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_payload : From.Parsetree.payload -> To.Parsetree.payload = function\n | From.Parsetree.PStr x0 -> To.Parsetree.PStr (copy_structure x0)\n | From.Parsetree.PSig x0 -> To.Parsetree.PSig (copy_signature x0)\n | From.Parsetree.PTyp x0 -> To.Parsetree.PTyp (copy_core_type x0)\n | From.Parsetree.PPat (x0, x1) ->\n To.Parsetree.PPat (copy_pattern x0, copy_option copy_expression x1)\n\nand copy_structure : From.Parsetree.structure -> To.Parsetree.structure =\n fun x -> List.map copy_structure_item x\n\nand copy_structure_item :\n From.Parsetree.structure_item -> To.Parsetree.structure_item =\n fun { From.Parsetree.pstr_desc; From.Parsetree.pstr_loc } ->\n {\n To.Parsetree.pstr_desc = copy_structure_item_desc pstr_desc;\n To.Parsetree.pstr_loc = copy_location pstr_loc;\n }\n\nand copy_structure_item_desc :\n From.Parsetree.structure_item_desc -> To.Parsetree.structure_item_desc =\n function\n | From.Parsetree.Pstr_eval (x0, x1) ->\n To.Parsetree.Pstr_eval (copy_expression x0, copy_attributes x1)\n | From.Parsetree.Pstr_value (x0, x1) ->\n To.Parsetree.Pstr_value (copy_rec_flag x0, List.map copy_value_binding x1)\n | From.Parsetree.Pstr_primitive x0 ->\n To.Parsetree.Pstr_primitive (copy_value_description x0)\n | From.Parsetree.Pstr_type (x0, x1) ->\n To.Parsetree.Pstr_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | From.Parsetree.Pstr_typext x0 ->\n To.Parsetree.Pstr_typext (copy_type_extension x0)\n | From.Parsetree.Pstr_exception x0 ->\n To.Parsetree.Pstr_exception (copy_extension_constructor x0)\n | From.Parsetree.Pstr_module x0 ->\n To.Parsetree.Pstr_module (copy_module_binding x0)\n | From.Parsetree.Pstr_recmodule x0 ->\n To.Parsetree.Pstr_recmodule (List.map copy_module_binding x0)\n | From.Parsetree.Pstr_modtype x0 ->\n To.Parsetree.Pstr_modtype (copy_module_type_declaration x0)\n | From.Parsetree.Pstr_open x0 ->\n To.Parsetree.Pstr_open (copy_open_description x0)\n | From.Parsetree.Pstr_class x0 ->\n To.Parsetree.Pstr_class (List.map copy_class_declaration x0)\n | From.Parsetree.Pstr_class_type x0 ->\n To.Parsetree.Pstr_class_type (List.map copy_class_type_declaration x0)\n | From.Parsetree.Pstr_include x0 ->\n To.Parsetree.Pstr_include (copy_include_declaration x0)\n | From.Parsetree.Pstr_attribute x0 ->\n To.Parsetree.Pstr_attribute (copy_attribute x0)\n | From.Parsetree.Pstr_extension (x0, x1) ->\n To.Parsetree.Pstr_extension (copy_extension x0, copy_attributes x1)\n\nand copy_include_declaration :\n From.Parsetree.include_declaration -> To.Parsetree.include_declaration =\n fun x -> copy_include_infos copy_module_expr x\n\nand copy_class_declaration :\n From.Parsetree.class_declaration -> To.Parsetree.class_declaration =\n fun x -> copy_class_infos copy_class_expr x\n\nand copy_class_expr : From.Parsetree.class_expr -> To.Parsetree.class_expr =\n fun {\n From.Parsetree.pcl_desc;\n From.Parsetree.pcl_loc;\n From.Parsetree.pcl_attributes;\n } ->\n {\n To.Parsetree.pcl_desc = copy_class_expr_desc pcl_desc;\n To.Parsetree.pcl_loc = copy_location pcl_loc;\n To.Parsetree.pcl_attributes = copy_attributes pcl_attributes;\n }\n\nand copy_class_expr_desc :\n From.Parsetree.class_expr_desc -> To.Parsetree.class_expr_desc = function\n | From.Parsetree.Pcl_constr (x0, x1) ->\n To.Parsetree.Pcl_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Pcl_structure x0 ->\n To.Parsetree.Pcl_structure (copy_class_structure x0)\n | From.Parsetree.Pcl_fun (x0, x1, x2, x3) ->\n To.Parsetree.Pcl_fun\n ( copy_arg_label x0,\n copy_option copy_expression x1,\n copy_pattern x2,\n copy_class_expr x3 )\n | From.Parsetree.Pcl_apply (x0, x1) ->\n To.Parsetree.Pcl_apply\n ( copy_class_expr x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | From.Parsetree.Pcl_let (x0, x1, x2) ->\n To.Parsetree.Pcl_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_class_expr x2)\n | From.Parsetree.Pcl_constraint (x0, x1) ->\n To.Parsetree.Pcl_constraint (copy_class_expr x0, copy_class_type x1)\n | From.Parsetree.Pcl_extension x0 ->\n To.Parsetree.Pcl_extension (copy_extension x0)\n\nand copy_class_structure :\n From.Parsetree.class_structure -> To.Parsetree.class_structure =\n fun { From.Parsetree.pcstr_self; From.Parsetree.pcstr_fields } ->\n {\n To.Parsetree.pcstr_self = copy_pattern pcstr_self;\n To.Parsetree.pcstr_fields = List.map copy_class_field pcstr_fields;\n }\n\nand copy_class_field : From.Parsetree.class_field -> To.Parsetree.class_field =\n fun {\n From.Parsetree.pcf_desc;\n From.Parsetree.pcf_loc;\n From.Parsetree.pcf_attributes;\n } ->\n {\n To.Parsetree.pcf_desc = copy_class_field_desc pcf_desc;\n To.Parsetree.pcf_loc = copy_location pcf_loc;\n To.Parsetree.pcf_attributes = copy_attributes pcf_attributes;\n }\n\nand copy_class_field_desc :\n From.Parsetree.class_field_desc -> To.Parsetree.class_field_desc = function\n | From.Parsetree.Pcf_inherit (x0, x1, x2) ->\n To.Parsetree.Pcf_inherit\n ( copy_override_flag x0,\n copy_class_expr x1,\n copy_option (fun x -> noloc x) x2 )\n | From.Parsetree.Pcf_val x0 ->\n To.Parsetree.Pcf_val\n (let x0, x1, x2 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_mutable_flag x1,\n copy_class_field_kind x2 ))\n | From.Parsetree.Pcf_method x0 ->\n To.Parsetree.Pcf_method\n (let x0, x1, x2 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_private_flag x1,\n copy_class_field_kind x2 ))\n | From.Parsetree.Pcf_constraint x0 ->\n To.Parsetree.Pcf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | From.Parsetree.Pcf_initializer x0 ->\n To.Parsetree.Pcf_initializer (copy_expression x0)\n | From.Parsetree.Pcf_attribute x0 ->\n To.Parsetree.Pcf_attribute (copy_attribute x0)\n | From.Parsetree.Pcf_extension x0 ->\n To.Parsetree.Pcf_extension (copy_extension x0)\n\nand copy_class_field_kind :\n From.Parsetree.class_field_kind -> To.Parsetree.class_field_kind = function\n | From.Parsetree.Cfk_virtual x0 ->\n To.Parsetree.Cfk_virtual (copy_core_type x0)\n | From.Parsetree.Cfk_concrete (x0, x1) ->\n To.Parsetree.Cfk_concrete (copy_override_flag x0, copy_expression x1)\n\nand copy_module_binding :\n From.Parsetree.module_binding -> To.Parsetree.module_binding =\n fun {\n From.Parsetree.pmb_name;\n From.Parsetree.pmb_expr;\n From.Parsetree.pmb_attributes;\n From.Parsetree.pmb_loc;\n } ->\n {\n To.Parsetree.pmb_name = copy_loc (fun x -> x) pmb_name;\n To.Parsetree.pmb_expr = copy_module_expr pmb_expr;\n To.Parsetree.pmb_attributes = copy_attributes pmb_attributes;\n To.Parsetree.pmb_loc = copy_location pmb_loc;\n }\n\nand copy_module_expr : From.Parsetree.module_expr -> To.Parsetree.module_expr =\n fun {\n From.Parsetree.pmod_desc;\n From.Parsetree.pmod_loc;\n From.Parsetree.pmod_attributes;\n } ->\n {\n To.Parsetree.pmod_desc = copy_module_expr_desc pmod_desc;\n To.Parsetree.pmod_loc = copy_location pmod_loc;\n To.Parsetree.pmod_attributes = copy_attributes pmod_attributes;\n }\n\nand copy_module_expr_desc :\n From.Parsetree.module_expr_desc -> To.Parsetree.module_expr_desc = function\n | From.Parsetree.Pmod_ident x0 ->\n To.Parsetree.Pmod_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pmod_structure x0 ->\n To.Parsetree.Pmod_structure (copy_structure x0)\n | From.Parsetree.Pmod_functor (x0, x1, x2) ->\n To.Parsetree.Pmod_functor\n ( copy_loc (fun x -> x) x0,\n copy_option copy_module_type x1,\n copy_module_expr x2 )\n | From.Parsetree.Pmod_apply (x0, x1) ->\n To.Parsetree.Pmod_apply (copy_module_expr x0, copy_module_expr x1)\n | From.Parsetree.Pmod_constraint (x0, x1) ->\n To.Parsetree.Pmod_constraint (copy_module_expr x0, copy_module_type x1)\n | From.Parsetree.Pmod_unpack x0 ->\n To.Parsetree.Pmod_unpack (copy_expression x0)\n | From.Parsetree.Pmod_extension x0 ->\n To.Parsetree.Pmod_extension (copy_extension x0)\n\nand copy_module_type : From.Parsetree.module_type -> To.Parsetree.module_type =\n fun {\n From.Parsetree.pmty_desc;\n From.Parsetree.pmty_loc;\n From.Parsetree.pmty_attributes;\n } ->\n {\n To.Parsetree.pmty_desc = copy_module_type_desc pmty_desc;\n To.Parsetree.pmty_loc = copy_location pmty_loc;\n To.Parsetree.pmty_attributes = copy_attributes pmty_attributes;\n }\n\nand copy_module_type_desc :\n From.Parsetree.module_type_desc -> To.Parsetree.module_type_desc = function\n | From.Parsetree.Pmty_ident x0 ->\n To.Parsetree.Pmty_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pmty_signature x0 ->\n To.Parsetree.Pmty_signature (copy_signature x0)\n | From.Parsetree.Pmty_functor (x0, x1, x2) ->\n To.Parsetree.Pmty_functor\n ( copy_loc (fun x -> x) x0,\n copy_option copy_module_type x1,\n copy_module_type x2 )\n | From.Parsetree.Pmty_with (x0, x1) ->\n To.Parsetree.Pmty_with\n (copy_module_type x0, List.map copy_with_constraint x1)\n | From.Parsetree.Pmty_typeof x0 ->\n To.Parsetree.Pmty_typeof (copy_module_expr x0)\n | From.Parsetree.Pmty_extension x0 ->\n To.Parsetree.Pmty_extension (copy_extension x0)\n | From.Parsetree.Pmty_alias x0 ->\n To.Parsetree.Pmty_alias (copy_loc copy_longident x0)\n\nand copy_with_constraint :\n From.Parsetree.with_constraint -> To.Parsetree.with_constraint = function\n | From.Parsetree.Pwith_type (x0, x1) ->\n To.Parsetree.Pwith_type\n (copy_loc copy_longident x0, copy_type_declaration x1)\n | From.Parsetree.Pwith_module (x0, x1) ->\n To.Parsetree.Pwith_module\n (copy_loc copy_longident x0, copy_loc copy_longident x1)\n | From.Parsetree.Pwith_typesubst x0 ->\n To.Parsetree.Pwith_typesubst (copy_type_declaration x0)\n | From.Parsetree.Pwith_modsubst (x0, x1) ->\n To.Parsetree.Pwith_modsubst\n (copy_loc (fun x -> x) x0, copy_loc copy_longident x1)\n\nand copy_signature : From.Parsetree.signature -> To.Parsetree.signature =\n fun x -> List.map copy_signature_item x\n\nand copy_signature_item :\n From.Parsetree.signature_item -> To.Parsetree.signature_item =\n fun { From.Parsetree.psig_desc; From.Parsetree.psig_loc } ->\n {\n To.Parsetree.psig_desc = copy_signature_item_desc psig_desc;\n To.Parsetree.psig_loc = copy_location psig_loc;\n }\n\nand copy_signature_item_desc :\n From.Parsetree.signature_item_desc -> To.Parsetree.signature_item_desc =\n function\n | From.Parsetree.Psig_value x0 ->\n To.Parsetree.Psig_value (copy_value_description x0)\n | From.Parsetree.Psig_type (x0, x1) ->\n To.Parsetree.Psig_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | From.Parsetree.Psig_typext x0 ->\n To.Parsetree.Psig_typext (copy_type_extension x0)\n | From.Parsetree.Psig_exception x0 ->\n To.Parsetree.Psig_exception (copy_extension_constructor x0)\n | From.Parsetree.Psig_module x0 ->\n To.Parsetree.Psig_module (copy_module_declaration x0)\n | From.Parsetree.Psig_recmodule x0 ->\n To.Parsetree.Psig_recmodule (List.map copy_module_declaration x0)\n | From.Parsetree.Psig_modtype x0 ->\n To.Parsetree.Psig_modtype (copy_module_type_declaration x0)\n | From.Parsetree.Psig_open x0 ->\n To.Parsetree.Psig_open (copy_open_description x0)\n | From.Parsetree.Psig_include x0 ->\n To.Parsetree.Psig_include (copy_include_description x0)\n | From.Parsetree.Psig_class x0 ->\n To.Parsetree.Psig_class (List.map copy_class_description x0)\n | From.Parsetree.Psig_class_type x0 ->\n To.Parsetree.Psig_class_type (List.map copy_class_type_declaration x0)\n | From.Parsetree.Psig_attribute x0 ->\n To.Parsetree.Psig_attribute (copy_attribute x0)\n | From.Parsetree.Psig_extension (x0, x1) ->\n To.Parsetree.Psig_extension (copy_extension x0, copy_attributes x1)\n\nand copy_class_type_declaration :\n From.Parsetree.class_type_declaration -> To.Parsetree.class_type_declaration\n =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_description :\n From.Parsetree.class_description -> To.Parsetree.class_description =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_type : From.Parsetree.class_type -> To.Parsetree.class_type =\n fun {\n From.Parsetree.pcty_desc;\n From.Parsetree.pcty_loc;\n From.Parsetree.pcty_attributes;\n } ->\n {\n To.Parsetree.pcty_desc = copy_class_type_desc pcty_desc;\n To.Parsetree.pcty_loc = copy_location pcty_loc;\n To.Parsetree.pcty_attributes = copy_attributes pcty_attributes;\n }\n\nand copy_class_type_desc :\n From.Parsetree.class_type_desc -> To.Parsetree.class_type_desc = function\n | From.Parsetree.Pcty_constr (x0, x1) ->\n To.Parsetree.Pcty_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Pcty_signature x0 ->\n To.Parsetree.Pcty_signature (copy_class_signature x0)\n | From.Parsetree.Pcty_arrow (x0, x1, x2) ->\n To.Parsetree.Pcty_arrow\n (copy_arg_label x0, copy_core_type x1, copy_class_type x2)\n | From.Parsetree.Pcty_extension x0 ->\n To.Parsetree.Pcty_extension (copy_extension x0)\n\nand copy_class_signature :\n From.Parsetree.class_signature -> To.Parsetree.class_signature =\n fun { From.Parsetree.pcsig_self; From.Parsetree.pcsig_fields } ->\n {\n To.Parsetree.pcsig_self = copy_core_type pcsig_self;\n To.Parsetree.pcsig_fields = List.map copy_class_type_field pcsig_fields;\n }\n\nand copy_class_type_field :\n From.Parsetree.class_type_field -> To.Parsetree.class_type_field =\n fun {\n From.Parsetree.pctf_desc;\n From.Parsetree.pctf_loc;\n From.Parsetree.pctf_attributes;\n } ->\n {\n To.Parsetree.pctf_desc = copy_class_type_field_desc pctf_desc;\n To.Parsetree.pctf_loc = copy_location pctf_loc;\n To.Parsetree.pctf_attributes = copy_attributes pctf_attributes;\n }\n\nand copy_class_type_field_desc :\n From.Parsetree.class_type_field_desc -> To.Parsetree.class_type_field_desc =\n function\n | From.Parsetree.Pctf_inherit x0 ->\n To.Parsetree.Pctf_inherit (copy_class_type x0)\n | From.Parsetree.Pctf_val x0 ->\n To.Parsetree.Pctf_val\n (let x0, x1, x2, x3 = x0 in\n ( noloc x0,\n copy_mutable_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | From.Parsetree.Pctf_method x0 ->\n To.Parsetree.Pctf_method\n (let x0, x1, x2, x3 = x0 in\n ( noloc x0,\n copy_private_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | From.Parsetree.Pctf_constraint x0 ->\n To.Parsetree.Pctf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | From.Parsetree.Pctf_attribute x0 ->\n To.Parsetree.Pctf_attribute (copy_attribute x0)\n | From.Parsetree.Pctf_extension x0 ->\n To.Parsetree.Pctf_extension (copy_extension x0)\n\nand copy_extension : From.Parsetree.extension -> To.Parsetree.extension =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_class_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 From.Parsetree.class_infos ->\n 'g0 To.Parsetree.class_infos =\n fun f0\n {\n From.Parsetree.pci_virt;\n From.Parsetree.pci_params;\n From.Parsetree.pci_name;\n From.Parsetree.pci_expr;\n From.Parsetree.pci_loc;\n From.Parsetree.pci_attributes;\n } ->\n {\n To.Parsetree.pci_virt = copy_virtual_flag pci_virt;\n To.Parsetree.pci_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n pci_params;\n To.Parsetree.pci_name = copy_loc (fun x -> x) pci_name;\n To.Parsetree.pci_expr = f0 pci_expr;\n To.Parsetree.pci_loc = copy_location pci_loc;\n To.Parsetree.pci_attributes = copy_attributes pci_attributes;\n }\n\nand copy_virtual_flag : From.Asttypes.virtual_flag -> To.Asttypes.virtual_flag =\n function\n | From.Asttypes.Virtual -> To.Asttypes.Virtual\n | From.Asttypes.Concrete -> To.Asttypes.Concrete\n\nand copy_include_description :\n From.Parsetree.include_description -> To.Parsetree.include_description =\n fun x -> copy_include_infos copy_module_type x\n\nand copy_include_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 From.Parsetree.include_infos ->\n 'g0 To.Parsetree.include_infos =\n fun f0\n {\n From.Parsetree.pincl_mod;\n From.Parsetree.pincl_loc;\n From.Parsetree.pincl_attributes;\n } ->\n {\n To.Parsetree.pincl_mod = f0 pincl_mod;\n To.Parsetree.pincl_loc = copy_location pincl_loc;\n To.Parsetree.pincl_attributes = copy_attributes pincl_attributes;\n }\n\nand copy_open_description :\n From.Parsetree.open_description -> To.Parsetree.open_description =\n fun {\n From.Parsetree.popen_lid;\n From.Parsetree.popen_override;\n From.Parsetree.popen_loc;\n From.Parsetree.popen_attributes;\n } ->\n {\n To.Parsetree.popen_lid = copy_loc copy_longident popen_lid;\n To.Parsetree.popen_override = copy_override_flag popen_override;\n To.Parsetree.popen_loc = copy_location popen_loc;\n To.Parsetree.popen_attributes = copy_attributes popen_attributes;\n }\n\nand copy_override_flag :\n From.Asttypes.override_flag -> To.Asttypes.override_flag = function\n | From.Asttypes.Override -> To.Asttypes.Override\n | From.Asttypes.Fresh -> To.Asttypes.Fresh\n\nand copy_module_type_declaration :\n From.Parsetree.module_type_declaration ->\n To.Parsetree.module_type_declaration =\n fun {\n From.Parsetree.pmtd_name;\n From.Parsetree.pmtd_type;\n From.Parsetree.pmtd_attributes;\n From.Parsetree.pmtd_loc;\n } ->\n {\n To.Parsetree.pmtd_name = copy_loc (fun x -> x) pmtd_name;\n To.Parsetree.pmtd_type = copy_option copy_module_type pmtd_type;\n To.Parsetree.pmtd_attributes = copy_attributes pmtd_attributes;\n To.Parsetree.pmtd_loc = copy_location pmtd_loc;\n }\n\nand copy_module_declaration :\n From.Parsetree.module_declaration -> To.Parsetree.module_declaration =\n fun {\n From.Parsetree.pmd_name;\n From.Parsetree.pmd_type;\n From.Parsetree.pmd_attributes;\n From.Parsetree.pmd_loc;\n } ->\n {\n To.Parsetree.pmd_name = copy_loc (fun x -> x) pmd_name;\n To.Parsetree.pmd_type = copy_module_type pmd_type;\n To.Parsetree.pmd_attributes = copy_attributes pmd_attributes;\n To.Parsetree.pmd_loc = copy_location pmd_loc;\n }\n\nand copy_type_extension :\n From.Parsetree.type_extension -> To.Parsetree.type_extension =\n fun {\n From.Parsetree.ptyext_path;\n From.Parsetree.ptyext_params;\n From.Parsetree.ptyext_constructors;\n From.Parsetree.ptyext_private;\n From.Parsetree.ptyext_attributes;\n } ->\n {\n To.Parsetree.ptyext_path = copy_loc copy_longident ptyext_path;\n To.Parsetree.ptyext_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptyext_params;\n To.Parsetree.ptyext_constructors =\n List.map copy_extension_constructor ptyext_constructors;\n To.Parsetree.ptyext_private = copy_private_flag ptyext_private;\n To.Parsetree.ptyext_attributes = copy_attributes ptyext_attributes;\n }\n\nand copy_extension_constructor :\n From.Parsetree.extension_constructor -> To.Parsetree.extension_constructor =\n fun {\n From.Parsetree.pext_name;\n From.Parsetree.pext_kind;\n From.Parsetree.pext_loc;\n From.Parsetree.pext_attributes;\n } ->\n {\n To.Parsetree.pext_name = copy_loc (fun x -> x) pext_name;\n To.Parsetree.pext_kind = copy_extension_constructor_kind pext_kind;\n To.Parsetree.pext_loc = copy_location pext_loc;\n To.Parsetree.pext_attributes = copy_attributes pext_attributes;\n }\n\nand copy_extension_constructor_kind :\n From.Parsetree.extension_constructor_kind ->\n To.Parsetree.extension_constructor_kind = function\n | From.Parsetree.Pext_decl (x0, x1) ->\n To.Parsetree.Pext_decl\n (copy_constructor_arguments x0, copy_option copy_core_type x1)\n | From.Parsetree.Pext_rebind x0 ->\n To.Parsetree.Pext_rebind (copy_loc copy_longident x0)\n\nand copy_type_declaration :\n From.Parsetree.type_declaration -> To.Parsetree.type_declaration =\n fun {\n From.Parsetree.ptype_name;\n From.Parsetree.ptype_params;\n From.Parsetree.ptype_cstrs;\n From.Parsetree.ptype_kind;\n From.Parsetree.ptype_private;\n From.Parsetree.ptype_manifest;\n From.Parsetree.ptype_attributes;\n From.Parsetree.ptype_loc;\n } ->\n {\n To.Parsetree.ptype_name = copy_loc (fun x -> x) ptype_name;\n To.Parsetree.ptype_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptype_params;\n To.Parsetree.ptype_cstrs =\n List.map\n (fun x ->\n let x0, x1, x2 = x in\n (copy_core_type x0, copy_core_type x1, copy_location x2))\n ptype_cstrs;\n To.Parsetree.ptype_kind = copy_type_kind ptype_kind;\n To.Parsetree.ptype_private = copy_private_flag ptype_private;\n To.Parsetree.ptype_manifest = copy_option copy_core_type ptype_manifest;\n To.Parsetree.ptype_attributes = copy_attributes ptype_attributes;\n To.Parsetree.ptype_loc = copy_location ptype_loc;\n }\n\nand copy_private_flag : From.Asttypes.private_flag -> To.Asttypes.private_flag =\n function\n | From.Asttypes.Private -> To.Asttypes.Private\n | From.Asttypes.Public -> To.Asttypes.Public\n\nand copy_type_kind : From.Parsetree.type_kind -> To.Parsetree.type_kind =\n function\n | From.Parsetree.Ptype_abstract -> To.Parsetree.Ptype_abstract\n | From.Parsetree.Ptype_variant x0 ->\n To.Parsetree.Ptype_variant (List.map copy_constructor_declaration x0)\n | From.Parsetree.Ptype_record x0 ->\n To.Parsetree.Ptype_record (List.map copy_label_declaration x0)\n | From.Parsetree.Ptype_open -> To.Parsetree.Ptype_open\n\nand copy_constructor_declaration :\n From.Parsetree.constructor_declaration ->\n To.Parsetree.constructor_declaration =\n fun {\n From.Parsetree.pcd_name;\n From.Parsetree.pcd_args;\n From.Parsetree.pcd_res;\n From.Parsetree.pcd_loc;\n From.Parsetree.pcd_attributes;\n } ->\n {\n To.Parsetree.pcd_name = copy_loc (fun x -> x) pcd_name;\n To.Parsetree.pcd_args = copy_constructor_arguments pcd_args;\n To.Parsetree.pcd_res = copy_option copy_core_type pcd_res;\n To.Parsetree.pcd_loc = copy_location pcd_loc;\n To.Parsetree.pcd_attributes = copy_attributes pcd_attributes;\n }\n\nand copy_constructor_arguments :\n From.Parsetree.constructor_arguments -> To.Parsetree.constructor_arguments =\n function\n | From.Parsetree.Pcstr_tuple x0 ->\n To.Parsetree.Pcstr_tuple (List.map copy_core_type x0)\n | From.Parsetree.Pcstr_record x0 ->\n To.Parsetree.Pcstr_record (List.map copy_label_declaration x0)\n\nand copy_label_declaration :\n From.Parsetree.label_declaration -> To.Parsetree.label_declaration =\n fun {\n From.Parsetree.pld_name;\n From.Parsetree.pld_mutable;\n From.Parsetree.pld_type;\n From.Parsetree.pld_loc;\n From.Parsetree.pld_attributes;\n } ->\n {\n To.Parsetree.pld_name = copy_loc (fun x -> x) pld_name;\n To.Parsetree.pld_mutable = copy_mutable_flag pld_mutable;\n To.Parsetree.pld_type = copy_core_type pld_type;\n To.Parsetree.pld_loc = copy_location pld_loc;\n To.Parsetree.pld_attributes = copy_attributes pld_attributes;\n }\n\nand copy_mutable_flag : From.Asttypes.mutable_flag -> To.Asttypes.mutable_flag =\n function\n | From.Asttypes.Immutable -> To.Asttypes.Immutable\n | From.Asttypes.Mutable -> To.Asttypes.Mutable\n\nand copy_variance : From.Asttypes.variance -> To.Asttypes.variance = function\n | From.Asttypes.Covariant -> To.Asttypes.Covariant\n | From.Asttypes.Contravariant -> To.Asttypes.Contravariant\n | From.Asttypes.Invariant -> To.Asttypes.Invariant\n\nand copy_value_description :\n From.Parsetree.value_description -> To.Parsetree.value_description =\n fun {\n From.Parsetree.pval_name;\n From.Parsetree.pval_type;\n From.Parsetree.pval_prim;\n From.Parsetree.pval_attributes;\n From.Parsetree.pval_loc;\n } ->\n {\n To.Parsetree.pval_name = copy_loc (fun x -> x) pval_name;\n To.Parsetree.pval_type = copy_core_type pval_type;\n To.Parsetree.pval_prim = List.map (fun x -> x) pval_prim;\n To.Parsetree.pval_attributes = copy_attributes pval_attributes;\n To.Parsetree.pval_loc = copy_location pval_loc;\n }\n\nand copy_arg_label : From.Asttypes.arg_label -> To.Asttypes.arg_label = function\n | From.Asttypes.Nolabel -> To.Asttypes.Nolabel\n | From.Asttypes.Labelled x0 -> To.Asttypes.Labelled x0\n | From.Asttypes.Optional x0 -> To.Asttypes.Optional x0\n\nand copy_closed_flag : From.Asttypes.closed_flag -> To.Asttypes.closed_flag =\n function\n | From.Asttypes.Closed -> To.Asttypes.Closed\n | From.Asttypes.Open -> To.Asttypes.Open\n\nand copy_label : From.Asttypes.label -> To.Asttypes.label = fun x -> x\n\nand copy_rec_flag : From.Asttypes.rec_flag -> To.Asttypes.rec_flag = function\n | From.Asttypes.Nonrecursive -> To.Asttypes.Nonrecursive\n | From.Asttypes.Recursive -> To.Asttypes.Recursive\n\nand copy_constant : From.Parsetree.constant -> To.Parsetree.constant = function\n | From.Parsetree.Pconst_integer (x0, x1) ->\n To.Parsetree.Pconst_integer (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pconst_char x0 -> To.Parsetree.Pconst_char x0\n | From.Parsetree.Pconst_string (x0, x1) ->\n To.Parsetree.Pconst_string (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pconst_float (x0, x1) ->\n To.Parsetree.Pconst_float (x0, copy_option (fun x -> x) x1)\n\nand copy_option : 'f0 'g0. ('f0 -> 'g0) -> 'f0 option -> 'g0 option =\n fun f0 -> function None -> None | Some x0 -> Some (f0 x0)\n\nand copy_longident : Longident.t -> Longident.t = fun x -> x\n\nand copy_loc :\n 'f0 'g0. ('f0 -> 'g0) -> 'f0 From.Asttypes.loc -> 'g0 To.Asttypes.loc =\n fun f0 { From.Asttypes.txt; From.Asttypes.loc } ->\n { To.Asttypes.txt = f0 txt; To.Asttypes.loc = copy_location loc }\n\nand copy_location : Location.t -> Location.t = fun x -> x\nand copy_bool : bool -> bool = function false -> false | true -> true\n\nlet rec copy_toplevel_phrase :\n From.Parsetree.toplevel_phrase -> To.Parsetree.toplevel_phrase = function\n | From.Parsetree.Ptop_def x0 -> To.Parsetree.Ptop_def (copy_structure x0)\n | From.Parsetree.Ptop_dir (x0, x1) ->\n To.Parsetree.Ptop_dir (x0, copy_directive_argument x1)\n\nand copy_directive_argument :\n From.Parsetree.directive_argument -> To.Parsetree.directive_argument =\n function\n | From.Parsetree.Pdir_none -> To.Parsetree.Pdir_none\n | From.Parsetree.Pdir_string x0 -> To.Parsetree.Pdir_string x0\n | From.Parsetree.Pdir_int (x0, x1) ->\n To.Parsetree.Pdir_int (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pdir_ident x0 -> To.Parsetree.Pdir_ident (copy_longident x0)\n | From.Parsetree.Pdir_bool x0 -> To.Parsetree.Pdir_bool (copy_bool x0)\n\nlet copy_cases x = List.map copy_case x\nlet copy_pat = copy_pattern\nlet copy_expr = copy_expression\nlet copy_typ = copy_core_type\n","(**************************************************************************)\n(* *)\n(* OCaml Migrate Parsetree *)\n(* *)\n(* Frédéric Bour *)\n(* Alain Frisch, LexiFi *)\n(* *)\n(* Copyright 2017 Institut National de Recherche en Informatique et *)\n(* en Automatique (INRIA). *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nmodule From = Ast_404\nmodule To = Ast_403\n\nlet from_loc { Location.txt = _; loc } = loc\n\nlet migration_error loc missing_feature =\n Location.raise_errorf ~loc\n \"migration error: %s is not supported before OCaml 4.04\" missing_feature\n\nlet rec copy_expression : From.Parsetree.expression -> To.Parsetree.expression =\n fun {\n From.Parsetree.pexp_desc;\n From.Parsetree.pexp_loc;\n From.Parsetree.pexp_attributes;\n } ->\n {\n To.Parsetree.pexp_desc = copy_expression_desc pexp_loc pexp_desc;\n To.Parsetree.pexp_loc = copy_location pexp_loc;\n To.Parsetree.pexp_attributes = copy_attributes pexp_attributes;\n }\n\nand copy_expression_desc loc :\n From.Parsetree.expression_desc -> To.Parsetree.expression_desc = function\n | From.Parsetree.Pexp_ident x0 ->\n To.Parsetree.Pexp_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pexp_constant x0 ->\n To.Parsetree.Pexp_constant (copy_constant x0)\n | From.Parsetree.Pexp_let (x0, x1, x2) ->\n To.Parsetree.Pexp_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_expression x2)\n | From.Parsetree.Pexp_function x0 ->\n To.Parsetree.Pexp_function (List.map copy_case x0)\n | From.Parsetree.Pexp_fun (x0, x1, x2, x3) ->\n To.Parsetree.Pexp_fun\n ( copy_arg_label x0,\n copy_option copy_expression x1,\n copy_pattern x2,\n copy_expression x3 )\n | From.Parsetree.Pexp_apply (x0, x1) ->\n To.Parsetree.Pexp_apply\n ( copy_expression x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | From.Parsetree.Pexp_match (x0, x1) ->\n To.Parsetree.Pexp_match (copy_expression x0, List.map copy_case x1)\n | From.Parsetree.Pexp_try (x0, x1) ->\n To.Parsetree.Pexp_try (copy_expression x0, List.map copy_case x1)\n | From.Parsetree.Pexp_tuple x0 ->\n To.Parsetree.Pexp_tuple (List.map copy_expression x0)\n | From.Parsetree.Pexp_construct (x0, x1) ->\n To.Parsetree.Pexp_construct\n (copy_loc copy_longident x0, copy_option copy_expression x1)\n | From.Parsetree.Pexp_variant (x0, x1) ->\n To.Parsetree.Pexp_variant (copy_label x0, copy_option copy_expression x1)\n | From.Parsetree.Pexp_record (x0, x1) ->\n To.Parsetree.Pexp_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_expression x1))\n x0,\n copy_option copy_expression x1 )\n | From.Parsetree.Pexp_field (x0, x1) ->\n To.Parsetree.Pexp_field (copy_expression x0, copy_loc copy_longident x1)\n | From.Parsetree.Pexp_setfield (x0, x1, x2) ->\n To.Parsetree.Pexp_setfield\n (copy_expression x0, copy_loc copy_longident x1, copy_expression x2)\n | From.Parsetree.Pexp_array x0 ->\n To.Parsetree.Pexp_array (List.map copy_expression x0)\n | From.Parsetree.Pexp_ifthenelse (x0, x1, x2) ->\n To.Parsetree.Pexp_ifthenelse\n (copy_expression x0, copy_expression x1, copy_option copy_expression x2)\n | From.Parsetree.Pexp_sequence (x0, x1) ->\n To.Parsetree.Pexp_sequence (copy_expression x0, copy_expression x1)\n | From.Parsetree.Pexp_while (x0, x1) ->\n To.Parsetree.Pexp_while (copy_expression x0, copy_expression x1)\n | From.Parsetree.Pexp_for (x0, x1, x2, x3, x4) ->\n To.Parsetree.Pexp_for\n ( copy_pattern x0,\n copy_expression x1,\n copy_expression x2,\n copy_direction_flag x3,\n copy_expression x4 )\n | From.Parsetree.Pexp_constraint (x0, x1) ->\n To.Parsetree.Pexp_constraint (copy_expression x0, copy_core_type x1)\n | From.Parsetree.Pexp_coerce (x0, x1, x2) ->\n To.Parsetree.Pexp_coerce\n (copy_expression x0, copy_option copy_core_type x1, copy_core_type x2)\n | From.Parsetree.Pexp_send (x0, x1) ->\n To.Parsetree.Pexp_send (copy_expression x0, x1)\n | From.Parsetree.Pexp_new x0 ->\n To.Parsetree.Pexp_new (copy_loc copy_longident x0)\n | From.Parsetree.Pexp_setinstvar (x0, x1) ->\n To.Parsetree.Pexp_setinstvar (copy_loc (fun x -> x) x0, copy_expression x1)\n | From.Parsetree.Pexp_override x0 ->\n To.Parsetree.Pexp_override\n (List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_expression x1))\n x0)\n | From.Parsetree.Pexp_letmodule (x0, x1, x2) ->\n To.Parsetree.Pexp_letmodule\n (copy_loc (fun x -> x) x0, copy_module_expr x1, copy_expression x2)\n | From.Parsetree.Pexp_letexception _ -> migration_error loc \"local exceptions\"\n | From.Parsetree.Pexp_assert x0 ->\n To.Parsetree.Pexp_assert (copy_expression x0)\n | From.Parsetree.Pexp_lazy x0 -> To.Parsetree.Pexp_lazy (copy_expression x0)\n | From.Parsetree.Pexp_poly (x0, x1) ->\n To.Parsetree.Pexp_poly (copy_expression x0, copy_option copy_core_type x1)\n | From.Parsetree.Pexp_object x0 ->\n To.Parsetree.Pexp_object (copy_class_structure x0)\n | From.Parsetree.Pexp_newtype (x0, x1) ->\n To.Parsetree.Pexp_newtype (x0, copy_expression x1)\n | From.Parsetree.Pexp_pack x0 -> To.Parsetree.Pexp_pack (copy_module_expr x0)\n | From.Parsetree.Pexp_open (x0, x1, x2) ->\n To.Parsetree.Pexp_open\n (copy_override_flag x0, copy_loc copy_longident x1, copy_expression x2)\n | From.Parsetree.Pexp_extension x0 ->\n To.Parsetree.Pexp_extension (copy_extension x0)\n | From.Parsetree.Pexp_unreachable -> To.Parsetree.Pexp_unreachable\n\nand copy_direction_flag :\n From.Asttypes.direction_flag -> To.Asttypes.direction_flag = function\n | From.Asttypes.Upto -> To.Asttypes.Upto\n | From.Asttypes.Downto -> To.Asttypes.Downto\n\nand copy_case : From.Parsetree.case -> To.Parsetree.case =\n fun { From.Parsetree.pc_lhs; From.Parsetree.pc_guard; From.Parsetree.pc_rhs } ->\n {\n To.Parsetree.pc_lhs = copy_pattern pc_lhs;\n To.Parsetree.pc_guard = copy_option copy_expression pc_guard;\n To.Parsetree.pc_rhs = copy_expression pc_rhs;\n }\n\nand copy_value_binding :\n From.Parsetree.value_binding -> To.Parsetree.value_binding =\n fun {\n From.Parsetree.pvb_pat;\n From.Parsetree.pvb_expr;\n From.Parsetree.pvb_attributes;\n From.Parsetree.pvb_loc;\n } ->\n {\n To.Parsetree.pvb_pat = copy_pattern pvb_pat;\n To.Parsetree.pvb_expr = copy_expression pvb_expr;\n To.Parsetree.pvb_attributes = copy_attributes pvb_attributes;\n To.Parsetree.pvb_loc = copy_location pvb_loc;\n }\n\nand copy_pattern : From.Parsetree.pattern -> To.Parsetree.pattern =\n fun {\n From.Parsetree.ppat_desc;\n From.Parsetree.ppat_loc;\n From.Parsetree.ppat_attributes;\n } ->\n {\n To.Parsetree.ppat_desc = copy_pattern_desc ppat_loc ppat_desc;\n To.Parsetree.ppat_loc = copy_location ppat_loc;\n To.Parsetree.ppat_attributes = copy_attributes ppat_attributes;\n }\n\nand copy_pattern_desc loc :\n From.Parsetree.pattern_desc -> To.Parsetree.pattern_desc = function\n | From.Parsetree.Ppat_any -> To.Parsetree.Ppat_any\n | From.Parsetree.Ppat_var x0 ->\n To.Parsetree.Ppat_var (copy_loc (fun x -> x) x0)\n | From.Parsetree.Ppat_alias (x0, x1) ->\n To.Parsetree.Ppat_alias (copy_pattern x0, copy_loc (fun x -> x) x1)\n | From.Parsetree.Ppat_constant x0 ->\n To.Parsetree.Ppat_constant (copy_constant x0)\n | From.Parsetree.Ppat_interval (x0, x1) ->\n To.Parsetree.Ppat_interval (copy_constant x0, copy_constant x1)\n | From.Parsetree.Ppat_tuple x0 ->\n To.Parsetree.Ppat_tuple (List.map copy_pattern x0)\n | From.Parsetree.Ppat_construct (x0, x1) ->\n To.Parsetree.Ppat_construct\n (copy_loc copy_longident x0, copy_option copy_pattern x1)\n | From.Parsetree.Ppat_variant (x0, x1) ->\n To.Parsetree.Ppat_variant (copy_label x0, copy_option copy_pattern x1)\n | From.Parsetree.Ppat_record (x0, x1) ->\n To.Parsetree.Ppat_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_pattern x1))\n x0,\n copy_closed_flag x1 )\n | From.Parsetree.Ppat_array x0 ->\n To.Parsetree.Ppat_array (List.map copy_pattern x0)\n | From.Parsetree.Ppat_or (x0, x1) ->\n To.Parsetree.Ppat_or (copy_pattern x0, copy_pattern x1)\n | From.Parsetree.Ppat_constraint (x0, x1) ->\n To.Parsetree.Ppat_constraint (copy_pattern x0, copy_core_type x1)\n | From.Parsetree.Ppat_type x0 ->\n To.Parsetree.Ppat_type (copy_loc copy_longident x0)\n | From.Parsetree.Ppat_lazy x0 -> To.Parsetree.Ppat_lazy (copy_pattern x0)\n | From.Parsetree.Ppat_unpack x0 ->\n To.Parsetree.Ppat_unpack (copy_loc (fun x -> x) x0)\n | From.Parsetree.Ppat_exception x0 ->\n To.Parsetree.Ppat_exception (copy_pattern x0)\n | From.Parsetree.Ppat_extension x0 ->\n To.Parsetree.Ppat_extension (copy_extension x0)\n | From.Parsetree.Ppat_open _ -> migration_error loc \"module open in patterns\"\n\nand copy_core_type : From.Parsetree.core_type -> To.Parsetree.core_type =\n fun {\n From.Parsetree.ptyp_desc;\n From.Parsetree.ptyp_loc;\n From.Parsetree.ptyp_attributes;\n } ->\n {\n To.Parsetree.ptyp_desc = copy_core_type_desc ptyp_desc;\n To.Parsetree.ptyp_loc = copy_location ptyp_loc;\n To.Parsetree.ptyp_attributes = copy_attributes ptyp_attributes;\n }\n\nand copy_core_type_desc :\n From.Parsetree.core_type_desc -> To.Parsetree.core_type_desc = function\n | From.Parsetree.Ptyp_any -> To.Parsetree.Ptyp_any\n | From.Parsetree.Ptyp_var x0 -> To.Parsetree.Ptyp_var x0\n | From.Parsetree.Ptyp_arrow (x0, x1, x2) ->\n To.Parsetree.Ptyp_arrow\n (copy_arg_label x0, copy_core_type x1, copy_core_type x2)\n | From.Parsetree.Ptyp_tuple x0 ->\n To.Parsetree.Ptyp_tuple (List.map copy_core_type x0)\n | From.Parsetree.Ptyp_constr (x0, x1) ->\n To.Parsetree.Ptyp_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Ptyp_object (x0, x1) ->\n To.Parsetree.Ptyp_object\n ( List.map\n (fun x ->\n let x0, x1, x2 = x in\n (x0, copy_attributes x1, copy_core_type x2))\n x0,\n copy_closed_flag x1 )\n | From.Parsetree.Ptyp_class (x0, x1) ->\n To.Parsetree.Ptyp_class\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Ptyp_alias (x0, x1) ->\n To.Parsetree.Ptyp_alias (copy_core_type x0, x1)\n | From.Parsetree.Ptyp_variant (x0, x1, x2) ->\n To.Parsetree.Ptyp_variant\n ( List.map copy_row_field x0,\n copy_closed_flag x1,\n copy_option (fun x -> List.map copy_label x) x2 )\n | From.Parsetree.Ptyp_poly (x0, x1) ->\n To.Parsetree.Ptyp_poly (List.map (fun x -> x) x0, copy_core_type x1)\n | From.Parsetree.Ptyp_package x0 ->\n To.Parsetree.Ptyp_package (copy_package_type x0)\n | From.Parsetree.Ptyp_extension x0 ->\n To.Parsetree.Ptyp_extension (copy_extension x0)\n\nand copy_package_type : From.Parsetree.package_type -> To.Parsetree.package_type\n =\n fun x ->\n let x0, x1 = x in\n ( copy_loc copy_longident x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_core_type x1))\n x1 )\n\nand copy_row_field : From.Parsetree.row_field -> To.Parsetree.row_field =\n function\n | From.Parsetree.Rtag (x0, x1, x2, x3) ->\n To.Parsetree.Rtag\n ( copy_label x0,\n copy_attributes x1,\n copy_bool x2,\n List.map copy_core_type x3 )\n | From.Parsetree.Rinherit x0 -> To.Parsetree.Rinherit (copy_core_type x0)\n\nand copy_attributes : From.Parsetree.attributes -> To.Parsetree.attributes =\n fun x -> List.map copy_attribute x\n\nand copy_attribute : From.Parsetree.attribute -> To.Parsetree.attribute =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_payload : From.Parsetree.payload -> To.Parsetree.payload = function\n | From.Parsetree.PStr x0 -> To.Parsetree.PStr (copy_structure x0)\n | From.Parsetree.PSig x0 -> To.Parsetree.PSig (copy_signature x0)\n | From.Parsetree.PTyp x0 -> To.Parsetree.PTyp (copy_core_type x0)\n | From.Parsetree.PPat (x0, x1) ->\n To.Parsetree.PPat (copy_pattern x0, copy_option copy_expression x1)\n\nand copy_structure : From.Parsetree.structure -> To.Parsetree.structure =\n fun x -> List.map copy_structure_item x\n\nand copy_structure_item :\n From.Parsetree.structure_item -> To.Parsetree.structure_item =\n fun { From.Parsetree.pstr_desc; From.Parsetree.pstr_loc } ->\n {\n To.Parsetree.pstr_desc = copy_structure_item_desc pstr_desc;\n To.Parsetree.pstr_loc = copy_location pstr_loc;\n }\n\nand copy_structure_item_desc :\n From.Parsetree.structure_item_desc -> To.Parsetree.structure_item_desc =\n function\n | From.Parsetree.Pstr_eval (x0, x1) ->\n To.Parsetree.Pstr_eval (copy_expression x0, copy_attributes x1)\n | From.Parsetree.Pstr_value (x0, x1) ->\n To.Parsetree.Pstr_value (copy_rec_flag x0, List.map copy_value_binding x1)\n | From.Parsetree.Pstr_primitive x0 ->\n To.Parsetree.Pstr_primitive (copy_value_description x0)\n | From.Parsetree.Pstr_type (x0, x1) ->\n To.Parsetree.Pstr_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | From.Parsetree.Pstr_typext x0 ->\n To.Parsetree.Pstr_typext (copy_type_extension x0)\n | From.Parsetree.Pstr_exception x0 ->\n To.Parsetree.Pstr_exception (copy_extension_constructor x0)\n | From.Parsetree.Pstr_module x0 ->\n To.Parsetree.Pstr_module (copy_module_binding x0)\n | From.Parsetree.Pstr_recmodule x0 ->\n To.Parsetree.Pstr_recmodule (List.map copy_module_binding x0)\n | From.Parsetree.Pstr_modtype x0 ->\n To.Parsetree.Pstr_modtype (copy_module_type_declaration x0)\n | From.Parsetree.Pstr_open x0 ->\n To.Parsetree.Pstr_open (copy_open_description x0)\n | From.Parsetree.Pstr_class x0 ->\n To.Parsetree.Pstr_class (List.map copy_class_declaration x0)\n | From.Parsetree.Pstr_class_type x0 ->\n To.Parsetree.Pstr_class_type (List.map copy_class_type_declaration x0)\n | From.Parsetree.Pstr_include x0 ->\n To.Parsetree.Pstr_include (copy_include_declaration x0)\n | From.Parsetree.Pstr_attribute x0 ->\n To.Parsetree.Pstr_attribute (copy_attribute x0)\n | From.Parsetree.Pstr_extension (x0, x1) ->\n To.Parsetree.Pstr_extension (copy_extension x0, copy_attributes x1)\n\nand copy_include_declaration :\n From.Parsetree.include_declaration -> To.Parsetree.include_declaration =\n fun x -> copy_include_infos copy_module_expr x\n\nand copy_class_declaration :\n From.Parsetree.class_declaration -> To.Parsetree.class_declaration =\n fun x -> copy_class_infos copy_class_expr x\n\nand copy_class_expr : From.Parsetree.class_expr -> To.Parsetree.class_expr =\n fun {\n From.Parsetree.pcl_desc;\n From.Parsetree.pcl_loc;\n From.Parsetree.pcl_attributes;\n } ->\n {\n To.Parsetree.pcl_desc = copy_class_expr_desc pcl_desc;\n To.Parsetree.pcl_loc = copy_location pcl_loc;\n To.Parsetree.pcl_attributes = copy_attributes pcl_attributes;\n }\n\nand copy_class_expr_desc :\n From.Parsetree.class_expr_desc -> To.Parsetree.class_expr_desc = function\n | From.Parsetree.Pcl_constr (x0, x1) ->\n To.Parsetree.Pcl_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Pcl_structure x0 ->\n To.Parsetree.Pcl_structure (copy_class_structure x0)\n | From.Parsetree.Pcl_fun (x0, x1, x2, x3) ->\n To.Parsetree.Pcl_fun\n ( copy_arg_label x0,\n copy_option copy_expression x1,\n copy_pattern x2,\n copy_class_expr x3 )\n | From.Parsetree.Pcl_apply (x0, x1) ->\n To.Parsetree.Pcl_apply\n ( copy_class_expr x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | From.Parsetree.Pcl_let (x0, x1, x2) ->\n To.Parsetree.Pcl_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_class_expr x2)\n | From.Parsetree.Pcl_constraint (x0, x1) ->\n To.Parsetree.Pcl_constraint (copy_class_expr x0, copy_class_type x1)\n | From.Parsetree.Pcl_extension x0 ->\n To.Parsetree.Pcl_extension (copy_extension x0)\n\nand copy_class_structure :\n From.Parsetree.class_structure -> To.Parsetree.class_structure =\n fun { From.Parsetree.pcstr_self; From.Parsetree.pcstr_fields } ->\n {\n To.Parsetree.pcstr_self = copy_pattern pcstr_self;\n To.Parsetree.pcstr_fields = List.map copy_class_field pcstr_fields;\n }\n\nand copy_class_field : From.Parsetree.class_field -> To.Parsetree.class_field =\n fun {\n From.Parsetree.pcf_desc;\n From.Parsetree.pcf_loc;\n From.Parsetree.pcf_attributes;\n } ->\n {\n To.Parsetree.pcf_desc = copy_class_field_desc pcf_desc;\n To.Parsetree.pcf_loc = copy_location pcf_loc;\n To.Parsetree.pcf_attributes = copy_attributes pcf_attributes;\n }\n\nand copy_class_field_desc :\n From.Parsetree.class_field_desc -> To.Parsetree.class_field_desc = function\n | From.Parsetree.Pcf_inherit (x0, x1, x2) ->\n To.Parsetree.Pcf_inherit\n (copy_override_flag x0, copy_class_expr x1, copy_option (fun x -> x) x2)\n | From.Parsetree.Pcf_val x0 ->\n To.Parsetree.Pcf_val\n (let x0, x1, x2 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_mutable_flag x1,\n copy_class_field_kind x2 ))\n | From.Parsetree.Pcf_method x0 ->\n To.Parsetree.Pcf_method\n (let x0, x1, x2 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_private_flag x1,\n copy_class_field_kind x2 ))\n | From.Parsetree.Pcf_constraint x0 ->\n To.Parsetree.Pcf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | From.Parsetree.Pcf_initializer x0 ->\n To.Parsetree.Pcf_initializer (copy_expression x0)\n | From.Parsetree.Pcf_attribute x0 ->\n To.Parsetree.Pcf_attribute (copy_attribute x0)\n | From.Parsetree.Pcf_extension x0 ->\n To.Parsetree.Pcf_extension (copy_extension x0)\n\nand copy_class_field_kind :\n From.Parsetree.class_field_kind -> To.Parsetree.class_field_kind = function\n | From.Parsetree.Cfk_virtual x0 ->\n To.Parsetree.Cfk_virtual (copy_core_type x0)\n | From.Parsetree.Cfk_concrete (x0, x1) ->\n To.Parsetree.Cfk_concrete (copy_override_flag x0, copy_expression x1)\n\nand copy_module_binding :\n From.Parsetree.module_binding -> To.Parsetree.module_binding =\n fun {\n From.Parsetree.pmb_name;\n From.Parsetree.pmb_expr;\n From.Parsetree.pmb_attributes;\n From.Parsetree.pmb_loc;\n } ->\n {\n To.Parsetree.pmb_name = copy_loc (fun x -> x) pmb_name;\n To.Parsetree.pmb_expr = copy_module_expr pmb_expr;\n To.Parsetree.pmb_attributes = copy_attributes pmb_attributes;\n To.Parsetree.pmb_loc = copy_location pmb_loc;\n }\n\nand copy_module_expr : From.Parsetree.module_expr -> To.Parsetree.module_expr =\n fun {\n From.Parsetree.pmod_desc;\n From.Parsetree.pmod_loc;\n From.Parsetree.pmod_attributes;\n } ->\n {\n To.Parsetree.pmod_desc = copy_module_expr_desc pmod_desc;\n To.Parsetree.pmod_loc = copy_location pmod_loc;\n To.Parsetree.pmod_attributes = copy_attributes pmod_attributes;\n }\n\nand copy_module_expr_desc :\n From.Parsetree.module_expr_desc -> To.Parsetree.module_expr_desc = function\n | From.Parsetree.Pmod_ident x0 ->\n To.Parsetree.Pmod_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pmod_structure x0 ->\n To.Parsetree.Pmod_structure (copy_structure x0)\n | From.Parsetree.Pmod_functor (x0, x1, x2) ->\n To.Parsetree.Pmod_functor\n ( copy_loc (fun x -> x) x0,\n copy_option copy_module_type x1,\n copy_module_expr x2 )\n | From.Parsetree.Pmod_apply (x0, x1) ->\n To.Parsetree.Pmod_apply (copy_module_expr x0, copy_module_expr x1)\n | From.Parsetree.Pmod_constraint (x0, x1) ->\n To.Parsetree.Pmod_constraint (copy_module_expr x0, copy_module_type x1)\n | From.Parsetree.Pmod_unpack x0 ->\n To.Parsetree.Pmod_unpack (copy_expression x0)\n | From.Parsetree.Pmod_extension x0 ->\n To.Parsetree.Pmod_extension (copy_extension x0)\n\nand copy_module_type : From.Parsetree.module_type -> To.Parsetree.module_type =\n fun {\n From.Parsetree.pmty_desc;\n From.Parsetree.pmty_loc;\n From.Parsetree.pmty_attributes;\n } ->\n {\n To.Parsetree.pmty_desc = copy_module_type_desc pmty_desc;\n To.Parsetree.pmty_loc = copy_location pmty_loc;\n To.Parsetree.pmty_attributes = copy_attributes pmty_attributes;\n }\n\nand copy_module_type_desc :\n From.Parsetree.module_type_desc -> To.Parsetree.module_type_desc = function\n | From.Parsetree.Pmty_ident x0 ->\n To.Parsetree.Pmty_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pmty_signature x0 ->\n To.Parsetree.Pmty_signature (copy_signature x0)\n | From.Parsetree.Pmty_functor (x0, x1, x2) ->\n To.Parsetree.Pmty_functor\n ( copy_loc (fun x -> x) x0,\n copy_option copy_module_type x1,\n copy_module_type x2 )\n | From.Parsetree.Pmty_with (x0, x1) ->\n To.Parsetree.Pmty_with\n (copy_module_type x0, List.map copy_with_constraint x1)\n | From.Parsetree.Pmty_typeof x0 ->\n To.Parsetree.Pmty_typeof (copy_module_expr x0)\n | From.Parsetree.Pmty_extension x0 ->\n To.Parsetree.Pmty_extension (copy_extension x0)\n | From.Parsetree.Pmty_alias x0 ->\n To.Parsetree.Pmty_alias (copy_loc copy_longident x0)\n\nand copy_with_constraint :\n From.Parsetree.with_constraint -> To.Parsetree.with_constraint = function\n | From.Parsetree.Pwith_type (x0, x1) ->\n To.Parsetree.Pwith_type\n (copy_loc copy_longident x0, copy_type_declaration x1)\n | From.Parsetree.Pwith_module (x0, x1) ->\n To.Parsetree.Pwith_module\n (copy_loc copy_longident x0, copy_loc copy_longident x1)\n | From.Parsetree.Pwith_typesubst x0 ->\n To.Parsetree.Pwith_typesubst (copy_type_declaration x0)\n | From.Parsetree.Pwith_modsubst (x0, x1) ->\n To.Parsetree.Pwith_modsubst\n (copy_loc (fun x -> x) x0, copy_loc copy_longident x1)\n\nand copy_signature : From.Parsetree.signature -> To.Parsetree.signature =\n fun x -> List.map copy_signature_item x\n\nand copy_signature_item :\n From.Parsetree.signature_item -> To.Parsetree.signature_item =\n fun { From.Parsetree.psig_desc; From.Parsetree.psig_loc } ->\n {\n To.Parsetree.psig_desc = copy_signature_item_desc psig_desc;\n To.Parsetree.psig_loc = copy_location psig_loc;\n }\n\nand copy_signature_item_desc :\n From.Parsetree.signature_item_desc -> To.Parsetree.signature_item_desc =\n function\n | From.Parsetree.Psig_value x0 ->\n To.Parsetree.Psig_value (copy_value_description x0)\n | From.Parsetree.Psig_type (x0, x1) ->\n To.Parsetree.Psig_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | From.Parsetree.Psig_typext x0 ->\n To.Parsetree.Psig_typext (copy_type_extension x0)\n | From.Parsetree.Psig_exception x0 ->\n To.Parsetree.Psig_exception (copy_extension_constructor x0)\n | From.Parsetree.Psig_module x0 ->\n To.Parsetree.Psig_module (copy_module_declaration x0)\n | From.Parsetree.Psig_recmodule x0 ->\n To.Parsetree.Psig_recmodule (List.map copy_module_declaration x0)\n | From.Parsetree.Psig_modtype x0 ->\n To.Parsetree.Psig_modtype (copy_module_type_declaration x0)\n | From.Parsetree.Psig_open x0 ->\n To.Parsetree.Psig_open (copy_open_description x0)\n | From.Parsetree.Psig_include x0 ->\n To.Parsetree.Psig_include (copy_include_description x0)\n | From.Parsetree.Psig_class x0 ->\n To.Parsetree.Psig_class (List.map copy_class_description x0)\n | From.Parsetree.Psig_class_type x0 ->\n To.Parsetree.Psig_class_type (List.map copy_class_type_declaration x0)\n | From.Parsetree.Psig_attribute x0 ->\n To.Parsetree.Psig_attribute (copy_attribute x0)\n | From.Parsetree.Psig_extension (x0, x1) ->\n To.Parsetree.Psig_extension (copy_extension x0, copy_attributes x1)\n\nand copy_class_type_declaration :\n From.Parsetree.class_type_declaration -> To.Parsetree.class_type_declaration\n =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_description :\n From.Parsetree.class_description -> To.Parsetree.class_description =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_type : From.Parsetree.class_type -> To.Parsetree.class_type =\n fun {\n From.Parsetree.pcty_desc;\n From.Parsetree.pcty_loc;\n From.Parsetree.pcty_attributes;\n } ->\n {\n To.Parsetree.pcty_desc = copy_class_type_desc pcty_desc;\n To.Parsetree.pcty_loc = copy_location pcty_loc;\n To.Parsetree.pcty_attributes = copy_attributes pcty_attributes;\n }\n\nand copy_class_type_desc :\n From.Parsetree.class_type_desc -> To.Parsetree.class_type_desc = function\n | From.Parsetree.Pcty_constr (x0, x1) ->\n To.Parsetree.Pcty_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Pcty_signature x0 ->\n To.Parsetree.Pcty_signature (copy_class_signature x0)\n | From.Parsetree.Pcty_arrow (x0, x1, x2) ->\n To.Parsetree.Pcty_arrow\n (copy_arg_label x0, copy_core_type x1, copy_class_type x2)\n | From.Parsetree.Pcty_extension x0 ->\n To.Parsetree.Pcty_extension (copy_extension x0)\n\nand copy_class_signature :\n From.Parsetree.class_signature -> To.Parsetree.class_signature =\n fun { From.Parsetree.pcsig_self; From.Parsetree.pcsig_fields } ->\n {\n To.Parsetree.pcsig_self = copy_core_type pcsig_self;\n To.Parsetree.pcsig_fields = List.map copy_class_type_field pcsig_fields;\n }\n\nand copy_class_type_field :\n From.Parsetree.class_type_field -> To.Parsetree.class_type_field =\n fun {\n From.Parsetree.pctf_desc;\n From.Parsetree.pctf_loc;\n From.Parsetree.pctf_attributes;\n } ->\n {\n To.Parsetree.pctf_desc = copy_class_type_field_desc pctf_desc;\n To.Parsetree.pctf_loc = copy_location pctf_loc;\n To.Parsetree.pctf_attributes = copy_attributes pctf_attributes;\n }\n\nand copy_class_type_field_desc :\n From.Parsetree.class_type_field_desc -> To.Parsetree.class_type_field_desc =\n function\n | From.Parsetree.Pctf_inherit x0 ->\n To.Parsetree.Pctf_inherit (copy_class_type x0)\n | From.Parsetree.Pctf_val x0 ->\n To.Parsetree.Pctf_val\n (let x0, x1, x2, x3 = x0 in\n (x0, copy_mutable_flag x1, copy_virtual_flag x2, copy_core_type x3))\n | From.Parsetree.Pctf_method x0 ->\n To.Parsetree.Pctf_method\n (let x0, x1, x2, x3 = x0 in\n (x0, copy_private_flag x1, copy_virtual_flag x2, copy_core_type x3))\n | From.Parsetree.Pctf_constraint x0 ->\n To.Parsetree.Pctf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | From.Parsetree.Pctf_attribute x0 ->\n To.Parsetree.Pctf_attribute (copy_attribute x0)\n | From.Parsetree.Pctf_extension x0 ->\n To.Parsetree.Pctf_extension (copy_extension x0)\n\nand copy_extension : From.Parsetree.extension -> To.Parsetree.extension =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_class_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 From.Parsetree.class_infos ->\n 'g0 To.Parsetree.class_infos =\n fun f0\n {\n From.Parsetree.pci_virt;\n From.Parsetree.pci_params;\n From.Parsetree.pci_name;\n From.Parsetree.pci_expr;\n From.Parsetree.pci_loc;\n From.Parsetree.pci_attributes;\n } ->\n {\n To.Parsetree.pci_virt = copy_virtual_flag pci_virt;\n To.Parsetree.pci_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n pci_params;\n To.Parsetree.pci_name = copy_loc (fun x -> x) pci_name;\n To.Parsetree.pci_expr = f0 pci_expr;\n To.Parsetree.pci_loc = copy_location pci_loc;\n To.Parsetree.pci_attributes = copy_attributes pci_attributes;\n }\n\nand copy_virtual_flag : From.Asttypes.virtual_flag -> To.Asttypes.virtual_flag =\n function\n | From.Asttypes.Virtual -> To.Asttypes.Virtual\n | From.Asttypes.Concrete -> To.Asttypes.Concrete\n\nand copy_include_description :\n From.Parsetree.include_description -> To.Parsetree.include_description =\n fun x -> copy_include_infos copy_module_type x\n\nand copy_include_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 From.Parsetree.include_infos ->\n 'g0 To.Parsetree.include_infos =\n fun f0\n {\n From.Parsetree.pincl_mod;\n From.Parsetree.pincl_loc;\n From.Parsetree.pincl_attributes;\n } ->\n {\n To.Parsetree.pincl_mod = f0 pincl_mod;\n To.Parsetree.pincl_loc = copy_location pincl_loc;\n To.Parsetree.pincl_attributes = copy_attributes pincl_attributes;\n }\n\nand copy_open_description :\n From.Parsetree.open_description -> To.Parsetree.open_description =\n fun {\n From.Parsetree.popen_lid;\n From.Parsetree.popen_override;\n From.Parsetree.popen_loc;\n From.Parsetree.popen_attributes;\n } ->\n {\n To.Parsetree.popen_lid = copy_loc copy_longident popen_lid;\n To.Parsetree.popen_override = copy_override_flag popen_override;\n To.Parsetree.popen_loc = copy_location popen_loc;\n To.Parsetree.popen_attributes = copy_attributes popen_attributes;\n }\n\nand copy_override_flag :\n From.Asttypes.override_flag -> To.Asttypes.override_flag = function\n | From.Asttypes.Override -> To.Asttypes.Override\n | From.Asttypes.Fresh -> To.Asttypes.Fresh\n\nand copy_module_type_declaration :\n From.Parsetree.module_type_declaration ->\n To.Parsetree.module_type_declaration =\n fun {\n From.Parsetree.pmtd_name;\n From.Parsetree.pmtd_type;\n From.Parsetree.pmtd_attributes;\n From.Parsetree.pmtd_loc;\n } ->\n {\n To.Parsetree.pmtd_name = copy_loc (fun x -> x) pmtd_name;\n To.Parsetree.pmtd_type = copy_option copy_module_type pmtd_type;\n To.Parsetree.pmtd_attributes = copy_attributes pmtd_attributes;\n To.Parsetree.pmtd_loc = copy_location pmtd_loc;\n }\n\nand copy_module_declaration :\n From.Parsetree.module_declaration -> To.Parsetree.module_declaration =\n fun {\n From.Parsetree.pmd_name;\n From.Parsetree.pmd_type;\n From.Parsetree.pmd_attributes;\n From.Parsetree.pmd_loc;\n } ->\n {\n To.Parsetree.pmd_name = copy_loc (fun x -> x) pmd_name;\n To.Parsetree.pmd_type = copy_module_type pmd_type;\n To.Parsetree.pmd_attributes = copy_attributes pmd_attributes;\n To.Parsetree.pmd_loc = copy_location pmd_loc;\n }\n\nand copy_type_extension :\n From.Parsetree.type_extension -> To.Parsetree.type_extension =\n fun {\n From.Parsetree.ptyext_path;\n From.Parsetree.ptyext_params;\n From.Parsetree.ptyext_constructors;\n From.Parsetree.ptyext_private;\n From.Parsetree.ptyext_attributes;\n } ->\n {\n To.Parsetree.ptyext_path = copy_loc copy_longident ptyext_path;\n To.Parsetree.ptyext_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptyext_params;\n To.Parsetree.ptyext_constructors =\n List.map copy_extension_constructor ptyext_constructors;\n To.Parsetree.ptyext_private = copy_private_flag ptyext_private;\n To.Parsetree.ptyext_attributes = copy_attributes ptyext_attributes;\n }\n\nand copy_extension_constructor :\n From.Parsetree.extension_constructor -> To.Parsetree.extension_constructor =\n fun {\n From.Parsetree.pext_name;\n From.Parsetree.pext_kind;\n From.Parsetree.pext_loc;\n From.Parsetree.pext_attributes;\n } ->\n {\n To.Parsetree.pext_name = copy_loc (fun x -> x) pext_name;\n To.Parsetree.pext_kind = copy_extension_constructor_kind pext_kind;\n To.Parsetree.pext_loc = copy_location pext_loc;\n To.Parsetree.pext_attributes = copy_attributes pext_attributes;\n }\n\nand copy_extension_constructor_kind :\n From.Parsetree.extension_constructor_kind ->\n To.Parsetree.extension_constructor_kind = function\n | From.Parsetree.Pext_decl (x0, x1) ->\n To.Parsetree.Pext_decl\n (copy_constructor_arguments x0, copy_option copy_core_type x1)\n | From.Parsetree.Pext_rebind x0 ->\n To.Parsetree.Pext_rebind (copy_loc copy_longident x0)\n\nand copy_type_declaration :\n From.Parsetree.type_declaration -> To.Parsetree.type_declaration =\n fun {\n From.Parsetree.ptype_name;\n From.Parsetree.ptype_params;\n From.Parsetree.ptype_cstrs;\n From.Parsetree.ptype_kind;\n From.Parsetree.ptype_private;\n From.Parsetree.ptype_manifest;\n From.Parsetree.ptype_attributes;\n From.Parsetree.ptype_loc;\n } ->\n {\n To.Parsetree.ptype_name = copy_loc (fun x -> x) ptype_name;\n To.Parsetree.ptype_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptype_params;\n To.Parsetree.ptype_cstrs =\n List.map\n (fun x ->\n let x0, x1, x2 = x in\n (copy_core_type x0, copy_core_type x1, copy_location x2))\n ptype_cstrs;\n To.Parsetree.ptype_kind = copy_type_kind ptype_kind;\n To.Parsetree.ptype_private = copy_private_flag ptype_private;\n To.Parsetree.ptype_manifest = copy_option copy_core_type ptype_manifest;\n To.Parsetree.ptype_attributes = copy_attributes ptype_attributes;\n To.Parsetree.ptype_loc = copy_location ptype_loc;\n }\n\nand copy_private_flag : From.Asttypes.private_flag -> To.Asttypes.private_flag =\n function\n | From.Asttypes.Private -> To.Asttypes.Private\n | From.Asttypes.Public -> To.Asttypes.Public\n\nand copy_type_kind : From.Parsetree.type_kind -> To.Parsetree.type_kind =\n function\n | From.Parsetree.Ptype_abstract -> To.Parsetree.Ptype_abstract\n | From.Parsetree.Ptype_variant x0 ->\n To.Parsetree.Ptype_variant (List.map copy_constructor_declaration x0)\n | From.Parsetree.Ptype_record x0 ->\n To.Parsetree.Ptype_record (List.map copy_label_declaration x0)\n | From.Parsetree.Ptype_open -> To.Parsetree.Ptype_open\n\nand copy_constructor_declaration :\n From.Parsetree.constructor_declaration ->\n To.Parsetree.constructor_declaration =\n fun {\n From.Parsetree.pcd_name;\n From.Parsetree.pcd_args;\n From.Parsetree.pcd_res;\n From.Parsetree.pcd_loc;\n From.Parsetree.pcd_attributes;\n } ->\n {\n To.Parsetree.pcd_name = copy_loc (fun x -> x) pcd_name;\n To.Parsetree.pcd_args = copy_constructor_arguments pcd_args;\n To.Parsetree.pcd_res = copy_option copy_core_type pcd_res;\n To.Parsetree.pcd_loc = copy_location pcd_loc;\n To.Parsetree.pcd_attributes = copy_attributes pcd_attributes;\n }\n\nand copy_constructor_arguments :\n From.Parsetree.constructor_arguments -> To.Parsetree.constructor_arguments =\n function\n | From.Parsetree.Pcstr_tuple x0 ->\n To.Parsetree.Pcstr_tuple (List.map copy_core_type x0)\n | From.Parsetree.Pcstr_record x0 ->\n To.Parsetree.Pcstr_record (List.map copy_label_declaration x0)\n\nand copy_label_declaration :\n From.Parsetree.label_declaration -> To.Parsetree.label_declaration =\n fun {\n From.Parsetree.pld_name;\n From.Parsetree.pld_mutable;\n From.Parsetree.pld_type;\n From.Parsetree.pld_loc;\n From.Parsetree.pld_attributes;\n } ->\n {\n To.Parsetree.pld_name = copy_loc (fun x -> x) pld_name;\n To.Parsetree.pld_mutable = copy_mutable_flag pld_mutable;\n To.Parsetree.pld_type = copy_core_type pld_type;\n To.Parsetree.pld_loc = copy_location pld_loc;\n To.Parsetree.pld_attributes = copy_attributes pld_attributes;\n }\n\nand copy_mutable_flag : From.Asttypes.mutable_flag -> To.Asttypes.mutable_flag =\n function\n | From.Asttypes.Immutable -> To.Asttypes.Immutable\n | From.Asttypes.Mutable -> To.Asttypes.Mutable\n\nand copy_variance : From.Asttypes.variance -> To.Asttypes.variance = function\n | From.Asttypes.Covariant -> To.Asttypes.Covariant\n | From.Asttypes.Contravariant -> To.Asttypes.Contravariant\n | From.Asttypes.Invariant -> To.Asttypes.Invariant\n\nand copy_value_description :\n From.Parsetree.value_description -> To.Parsetree.value_description =\n fun {\n From.Parsetree.pval_name;\n From.Parsetree.pval_type;\n From.Parsetree.pval_prim;\n From.Parsetree.pval_attributes;\n From.Parsetree.pval_loc;\n } ->\n {\n To.Parsetree.pval_name = copy_loc (fun x -> x) pval_name;\n To.Parsetree.pval_type = copy_core_type pval_type;\n To.Parsetree.pval_prim = List.map (fun x -> x) pval_prim;\n To.Parsetree.pval_attributes = copy_attributes pval_attributes;\n To.Parsetree.pval_loc = copy_location pval_loc;\n }\n\nand copy_arg_label : From.Asttypes.arg_label -> To.Asttypes.arg_label = function\n | From.Asttypes.Nolabel -> To.Asttypes.Nolabel\n | From.Asttypes.Labelled x0 -> To.Asttypes.Labelled x0\n | From.Asttypes.Optional x0 -> To.Asttypes.Optional x0\n\nand copy_closed_flag : From.Asttypes.closed_flag -> To.Asttypes.closed_flag =\n function\n | From.Asttypes.Closed -> To.Asttypes.Closed\n | From.Asttypes.Open -> To.Asttypes.Open\n\nand copy_label : From.Asttypes.label -> To.Asttypes.label = fun x -> x\n\nand copy_rec_flag : From.Asttypes.rec_flag -> To.Asttypes.rec_flag = function\n | From.Asttypes.Nonrecursive -> To.Asttypes.Nonrecursive\n | From.Asttypes.Recursive -> To.Asttypes.Recursive\n\nand copy_constant : From.Parsetree.constant -> To.Parsetree.constant = function\n | From.Parsetree.Pconst_integer (x0, x1) ->\n To.Parsetree.Pconst_integer (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pconst_char x0 -> To.Parsetree.Pconst_char x0\n | From.Parsetree.Pconst_string (x0, x1) ->\n To.Parsetree.Pconst_string (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pconst_float (x0, x1) ->\n To.Parsetree.Pconst_float (x0, copy_option (fun x -> x) x1)\n\nand copy_option : 'f0 'g0. ('f0 -> 'g0) -> 'f0 option -> 'g0 option =\n fun f0 -> function None -> None | Some x0 -> Some (f0 x0)\n\nand copy_longident : Longident.t -> Longident.t = fun x -> x\n\nand copy_loc :\n 'f0 'g0. ('f0 -> 'g0) -> 'f0 From.Asttypes.loc -> 'g0 To.Asttypes.loc =\n fun f0 { From.Asttypes.txt; From.Asttypes.loc } ->\n { To.Asttypes.txt = f0 txt; To.Asttypes.loc = copy_location loc }\n\nand copy_location : Location.t -> Location.t = fun x -> x\nand copy_bool : bool -> bool = function false -> false | true -> true\n\nlet rec copy_toplevel_phrase :\n From.Parsetree.toplevel_phrase -> To.Parsetree.toplevel_phrase = function\n | From.Parsetree.Ptop_def x0 -> To.Parsetree.Ptop_def (copy_structure x0)\n | From.Parsetree.Ptop_dir (x0, x1) ->\n To.Parsetree.Ptop_dir (x0, copy_directive_argument x1)\n\nand copy_directive_argument :\n From.Parsetree.directive_argument -> To.Parsetree.directive_argument =\n function\n | From.Parsetree.Pdir_none -> To.Parsetree.Pdir_none\n | From.Parsetree.Pdir_string x0 -> To.Parsetree.Pdir_string x0\n | From.Parsetree.Pdir_int (x0, x1) ->\n To.Parsetree.Pdir_int (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pdir_ident x0 -> To.Parsetree.Pdir_ident (copy_longident x0)\n | From.Parsetree.Pdir_bool x0 -> To.Parsetree.Pdir_bool (copy_bool x0)\n\nlet copy_cases x = List.map copy_case x\nlet copy_pat = copy_pattern\nlet copy_expr = copy_expression\nlet copy_typ = copy_core_type\n","(**************************************************************************)\n(* *)\n(* OCaml Migrate Parsetree *)\n(* *)\n(* Frédéric Bour *)\n(* Alain Frisch, LexiFi *)\n(* *)\n(* Copyright 2017 Institut National de Recherche en Informatique et *)\n(* en Automatique (INRIA). *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nmodule From = Ast_403\nmodule To = Ast_404\n\nlet rec copy_expression : From.Parsetree.expression -> To.Parsetree.expression =\n fun {\n From.Parsetree.pexp_desc;\n From.Parsetree.pexp_loc;\n From.Parsetree.pexp_attributes;\n } ->\n {\n To.Parsetree.pexp_desc = copy_expression_desc pexp_desc;\n To.Parsetree.pexp_loc = copy_location pexp_loc;\n To.Parsetree.pexp_attributes = copy_attributes pexp_attributes;\n }\n\nand copy_expression_desc :\n From.Parsetree.expression_desc -> To.Parsetree.expression_desc = function\n | From.Parsetree.Pexp_ident x0 ->\n To.Parsetree.Pexp_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pexp_constant x0 ->\n To.Parsetree.Pexp_constant (copy_constant x0)\n | From.Parsetree.Pexp_let (x0, x1, x2) ->\n To.Parsetree.Pexp_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_expression x2)\n | From.Parsetree.Pexp_function x0 ->\n To.Parsetree.Pexp_function (List.map copy_case x0)\n | From.Parsetree.Pexp_fun (x0, x1, x2, x3) ->\n To.Parsetree.Pexp_fun\n ( copy_arg_label x0,\n copy_option copy_expression x1,\n copy_pattern x2,\n copy_expression x3 )\n | From.Parsetree.Pexp_apply (x0, x1) ->\n To.Parsetree.Pexp_apply\n ( copy_expression x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | From.Parsetree.Pexp_match (x0, x1) ->\n To.Parsetree.Pexp_match (copy_expression x0, List.map copy_case x1)\n | From.Parsetree.Pexp_try (x0, x1) ->\n To.Parsetree.Pexp_try (copy_expression x0, List.map copy_case x1)\n | From.Parsetree.Pexp_tuple x0 ->\n To.Parsetree.Pexp_tuple (List.map copy_expression x0)\n | From.Parsetree.Pexp_construct (x0, x1) ->\n To.Parsetree.Pexp_construct\n (copy_loc copy_longident x0, copy_option copy_expression x1)\n | From.Parsetree.Pexp_variant (x0, x1) ->\n To.Parsetree.Pexp_variant (copy_label x0, copy_option copy_expression x1)\n | From.Parsetree.Pexp_record (x0, x1) ->\n To.Parsetree.Pexp_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_expression x1))\n x0,\n copy_option copy_expression x1 )\n | From.Parsetree.Pexp_field (x0, x1) ->\n To.Parsetree.Pexp_field (copy_expression x0, copy_loc copy_longident x1)\n | From.Parsetree.Pexp_setfield (x0, x1, x2) ->\n To.Parsetree.Pexp_setfield\n (copy_expression x0, copy_loc copy_longident x1, copy_expression x2)\n | From.Parsetree.Pexp_array x0 ->\n To.Parsetree.Pexp_array (List.map copy_expression x0)\n | From.Parsetree.Pexp_ifthenelse (x0, x1, x2) ->\n To.Parsetree.Pexp_ifthenelse\n (copy_expression x0, copy_expression x1, copy_option copy_expression x2)\n | From.Parsetree.Pexp_sequence (x0, x1) ->\n To.Parsetree.Pexp_sequence (copy_expression x0, copy_expression x1)\n | From.Parsetree.Pexp_while (x0, x1) ->\n To.Parsetree.Pexp_while (copy_expression x0, copy_expression x1)\n | From.Parsetree.Pexp_for (x0, x1, x2, x3, x4) ->\n To.Parsetree.Pexp_for\n ( copy_pattern x0,\n copy_expression x1,\n copy_expression x2,\n copy_direction_flag x3,\n copy_expression x4 )\n | From.Parsetree.Pexp_constraint (x0, x1) ->\n To.Parsetree.Pexp_constraint (copy_expression x0, copy_core_type x1)\n | From.Parsetree.Pexp_coerce (x0, x1, x2) ->\n To.Parsetree.Pexp_coerce\n (copy_expression x0, copy_option copy_core_type x1, copy_core_type x2)\n | From.Parsetree.Pexp_send (x0, x1) ->\n To.Parsetree.Pexp_send (copy_expression x0, x1)\n | From.Parsetree.Pexp_new x0 ->\n To.Parsetree.Pexp_new (copy_loc copy_longident x0)\n | From.Parsetree.Pexp_setinstvar (x0, x1) ->\n To.Parsetree.Pexp_setinstvar (copy_loc (fun x -> x) x0, copy_expression x1)\n | From.Parsetree.Pexp_override x0 ->\n To.Parsetree.Pexp_override\n (List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_expression x1))\n x0)\n | From.Parsetree.Pexp_letmodule (x0, x1, x2) ->\n To.Parsetree.Pexp_letmodule\n (copy_loc (fun x -> x) x0, copy_module_expr x1, copy_expression x2)\n | From.Parsetree.Pexp_assert x0 ->\n To.Parsetree.Pexp_assert (copy_expression x0)\n | From.Parsetree.Pexp_lazy x0 -> To.Parsetree.Pexp_lazy (copy_expression x0)\n | From.Parsetree.Pexp_poly (x0, x1) ->\n To.Parsetree.Pexp_poly (copy_expression x0, copy_option copy_core_type x1)\n | From.Parsetree.Pexp_object x0 ->\n To.Parsetree.Pexp_object (copy_class_structure x0)\n | From.Parsetree.Pexp_newtype (x0, x1) ->\n To.Parsetree.Pexp_newtype (x0, copy_expression x1)\n | From.Parsetree.Pexp_pack x0 -> To.Parsetree.Pexp_pack (copy_module_expr x0)\n | From.Parsetree.Pexp_open (x0, x1, x2) ->\n To.Parsetree.Pexp_open\n (copy_override_flag x0, copy_loc copy_longident x1, copy_expression x2)\n | From.Parsetree.Pexp_extension x0 ->\n To.Parsetree.Pexp_extension (copy_extension x0)\n | From.Parsetree.Pexp_unreachable -> To.Parsetree.Pexp_unreachable\n\nand copy_direction_flag :\n From.Asttypes.direction_flag -> To.Asttypes.direction_flag = function\n | From.Asttypes.Upto -> To.Asttypes.Upto\n | From.Asttypes.Downto -> To.Asttypes.Downto\n\nand copy_case : From.Parsetree.case -> To.Parsetree.case =\n fun { From.Parsetree.pc_lhs; From.Parsetree.pc_guard; From.Parsetree.pc_rhs } ->\n {\n To.Parsetree.pc_lhs = copy_pattern pc_lhs;\n To.Parsetree.pc_guard = copy_option copy_expression pc_guard;\n To.Parsetree.pc_rhs = copy_expression pc_rhs;\n }\n\nand copy_value_binding :\n From.Parsetree.value_binding -> To.Parsetree.value_binding =\n fun {\n From.Parsetree.pvb_pat;\n From.Parsetree.pvb_expr;\n From.Parsetree.pvb_attributes;\n From.Parsetree.pvb_loc;\n } ->\n {\n To.Parsetree.pvb_pat = copy_pattern pvb_pat;\n To.Parsetree.pvb_expr = copy_expression pvb_expr;\n To.Parsetree.pvb_attributes = copy_attributes pvb_attributes;\n To.Parsetree.pvb_loc = copy_location pvb_loc;\n }\n\nand copy_pattern : From.Parsetree.pattern -> To.Parsetree.pattern =\n fun {\n From.Parsetree.ppat_desc;\n From.Parsetree.ppat_loc;\n From.Parsetree.ppat_attributes;\n } ->\n {\n To.Parsetree.ppat_desc = copy_pattern_desc ppat_desc;\n To.Parsetree.ppat_loc = copy_location ppat_loc;\n To.Parsetree.ppat_attributes = copy_attributes ppat_attributes;\n }\n\nand copy_pattern_desc : From.Parsetree.pattern_desc -> To.Parsetree.pattern_desc\n = function\n | From.Parsetree.Ppat_any -> To.Parsetree.Ppat_any\n | From.Parsetree.Ppat_var x0 ->\n To.Parsetree.Ppat_var (copy_loc (fun x -> x) x0)\n | From.Parsetree.Ppat_alias (x0, x1) ->\n To.Parsetree.Ppat_alias (copy_pattern x0, copy_loc (fun x -> x) x1)\n | From.Parsetree.Ppat_constant x0 ->\n To.Parsetree.Ppat_constant (copy_constant x0)\n | From.Parsetree.Ppat_interval (x0, x1) ->\n To.Parsetree.Ppat_interval (copy_constant x0, copy_constant x1)\n | From.Parsetree.Ppat_tuple x0 ->\n To.Parsetree.Ppat_tuple (List.map copy_pattern x0)\n | From.Parsetree.Ppat_construct (x0, x1) ->\n To.Parsetree.Ppat_construct\n (copy_loc copy_longident x0, copy_option copy_pattern x1)\n | From.Parsetree.Ppat_variant (x0, x1) ->\n To.Parsetree.Ppat_variant (copy_label x0, copy_option copy_pattern x1)\n | From.Parsetree.Ppat_record (x0, x1) ->\n To.Parsetree.Ppat_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_pattern x1))\n x0,\n copy_closed_flag x1 )\n | From.Parsetree.Ppat_array x0 ->\n To.Parsetree.Ppat_array (List.map copy_pattern x0)\n | From.Parsetree.Ppat_or (x0, x1) ->\n To.Parsetree.Ppat_or (copy_pattern x0, copy_pattern x1)\n | From.Parsetree.Ppat_constraint (x0, x1) ->\n To.Parsetree.Ppat_constraint (copy_pattern x0, copy_core_type x1)\n | From.Parsetree.Ppat_type x0 ->\n To.Parsetree.Ppat_type (copy_loc copy_longident x0)\n | From.Parsetree.Ppat_lazy x0 -> To.Parsetree.Ppat_lazy (copy_pattern x0)\n | From.Parsetree.Ppat_unpack x0 ->\n To.Parsetree.Ppat_unpack (copy_loc (fun x -> x) x0)\n | From.Parsetree.Ppat_exception x0 ->\n To.Parsetree.Ppat_exception (copy_pattern x0)\n | From.Parsetree.Ppat_extension x0 ->\n To.Parsetree.Ppat_extension (copy_extension x0)\n\nand copy_core_type : From.Parsetree.core_type -> To.Parsetree.core_type =\n fun {\n From.Parsetree.ptyp_desc;\n From.Parsetree.ptyp_loc;\n From.Parsetree.ptyp_attributes;\n } ->\n {\n To.Parsetree.ptyp_desc = copy_core_type_desc ptyp_desc;\n To.Parsetree.ptyp_loc = copy_location ptyp_loc;\n To.Parsetree.ptyp_attributes = copy_attributes ptyp_attributes;\n }\n\nand copy_core_type_desc :\n From.Parsetree.core_type_desc -> To.Parsetree.core_type_desc = function\n | From.Parsetree.Ptyp_any -> To.Parsetree.Ptyp_any\n | From.Parsetree.Ptyp_var x0 -> To.Parsetree.Ptyp_var x0\n | From.Parsetree.Ptyp_arrow (x0, x1, x2) ->\n To.Parsetree.Ptyp_arrow\n (copy_arg_label x0, copy_core_type x1, copy_core_type x2)\n | From.Parsetree.Ptyp_tuple x0 ->\n To.Parsetree.Ptyp_tuple (List.map copy_core_type x0)\n | From.Parsetree.Ptyp_constr (x0, x1) ->\n To.Parsetree.Ptyp_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Ptyp_object (x0, x1) ->\n To.Parsetree.Ptyp_object\n ( List.map\n (fun x ->\n let x0, x1, x2 = x in\n (x0, copy_attributes x1, copy_core_type x2))\n x0,\n copy_closed_flag x1 )\n | From.Parsetree.Ptyp_class (x0, x1) ->\n To.Parsetree.Ptyp_class\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Ptyp_alias (x0, x1) ->\n To.Parsetree.Ptyp_alias (copy_core_type x0, x1)\n | From.Parsetree.Ptyp_variant (x0, x1, x2) ->\n To.Parsetree.Ptyp_variant\n ( List.map copy_row_field x0,\n copy_closed_flag x1,\n copy_option (fun x -> List.map copy_label x) x2 )\n | From.Parsetree.Ptyp_poly (x0, x1) ->\n To.Parsetree.Ptyp_poly (List.map (fun x -> x) x0, copy_core_type x1)\n | From.Parsetree.Ptyp_package x0 ->\n To.Parsetree.Ptyp_package (copy_package_type x0)\n | From.Parsetree.Ptyp_extension x0 ->\n To.Parsetree.Ptyp_extension (copy_extension x0)\n\nand copy_package_type : From.Parsetree.package_type -> To.Parsetree.package_type\n =\n fun x ->\n let x0, x1 = x in\n ( copy_loc copy_longident x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_core_type x1))\n x1 )\n\nand copy_row_field : From.Parsetree.row_field -> To.Parsetree.row_field =\n function\n | From.Parsetree.Rtag (x0, x1, x2, x3) ->\n To.Parsetree.Rtag\n ( copy_label x0,\n copy_attributes x1,\n copy_bool x2,\n List.map copy_core_type x3 )\n | From.Parsetree.Rinherit x0 -> To.Parsetree.Rinherit (copy_core_type x0)\n\nand copy_attributes : From.Parsetree.attributes -> To.Parsetree.attributes =\n fun x -> List.map copy_attribute x\n\nand copy_attribute : From.Parsetree.attribute -> To.Parsetree.attribute =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_payload : From.Parsetree.payload -> To.Parsetree.payload = function\n | From.Parsetree.PStr x0 -> To.Parsetree.PStr (copy_structure x0)\n | From.Parsetree.PSig x0 -> To.Parsetree.PSig (copy_signature x0)\n | From.Parsetree.PTyp x0 -> To.Parsetree.PTyp (copy_core_type x0)\n | From.Parsetree.PPat (x0, x1) ->\n To.Parsetree.PPat (copy_pattern x0, copy_option copy_expression x1)\n\nand copy_structure : From.Parsetree.structure -> To.Parsetree.structure =\n fun x -> List.map copy_structure_item x\n\nand copy_structure_item :\n From.Parsetree.structure_item -> To.Parsetree.structure_item =\n fun { From.Parsetree.pstr_desc; From.Parsetree.pstr_loc } ->\n {\n To.Parsetree.pstr_desc = copy_structure_item_desc pstr_desc;\n To.Parsetree.pstr_loc = copy_location pstr_loc;\n }\n\nand copy_structure_item_desc :\n From.Parsetree.structure_item_desc -> To.Parsetree.structure_item_desc =\n function\n | From.Parsetree.Pstr_eval (x0, x1) ->\n To.Parsetree.Pstr_eval (copy_expression x0, copy_attributes x1)\n | From.Parsetree.Pstr_value (x0, x1) ->\n To.Parsetree.Pstr_value (copy_rec_flag x0, List.map copy_value_binding x1)\n | From.Parsetree.Pstr_primitive x0 ->\n To.Parsetree.Pstr_primitive (copy_value_description x0)\n | From.Parsetree.Pstr_type (x0, x1) ->\n To.Parsetree.Pstr_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | From.Parsetree.Pstr_typext x0 ->\n To.Parsetree.Pstr_typext (copy_type_extension x0)\n | From.Parsetree.Pstr_exception x0 ->\n To.Parsetree.Pstr_exception (copy_extension_constructor x0)\n | From.Parsetree.Pstr_module x0 ->\n To.Parsetree.Pstr_module (copy_module_binding x0)\n | From.Parsetree.Pstr_recmodule x0 ->\n To.Parsetree.Pstr_recmodule (List.map copy_module_binding x0)\n | From.Parsetree.Pstr_modtype x0 ->\n To.Parsetree.Pstr_modtype (copy_module_type_declaration x0)\n | From.Parsetree.Pstr_open x0 ->\n To.Parsetree.Pstr_open (copy_open_description x0)\n | From.Parsetree.Pstr_class x0 ->\n To.Parsetree.Pstr_class (List.map copy_class_declaration x0)\n | From.Parsetree.Pstr_class_type x0 ->\n To.Parsetree.Pstr_class_type (List.map copy_class_type_declaration x0)\n | From.Parsetree.Pstr_include x0 ->\n To.Parsetree.Pstr_include (copy_include_declaration x0)\n | From.Parsetree.Pstr_attribute x0 ->\n To.Parsetree.Pstr_attribute (copy_attribute x0)\n | From.Parsetree.Pstr_extension (x0, x1) ->\n To.Parsetree.Pstr_extension (copy_extension x0, copy_attributes x1)\n\nand copy_include_declaration :\n From.Parsetree.include_declaration -> To.Parsetree.include_declaration =\n fun x -> copy_include_infos copy_module_expr x\n\nand copy_class_declaration :\n From.Parsetree.class_declaration -> To.Parsetree.class_declaration =\n fun x -> copy_class_infos copy_class_expr x\n\nand copy_class_expr : From.Parsetree.class_expr -> To.Parsetree.class_expr =\n fun {\n From.Parsetree.pcl_desc;\n From.Parsetree.pcl_loc;\n From.Parsetree.pcl_attributes;\n } ->\n {\n To.Parsetree.pcl_desc = copy_class_expr_desc pcl_desc;\n To.Parsetree.pcl_loc = copy_location pcl_loc;\n To.Parsetree.pcl_attributes = copy_attributes pcl_attributes;\n }\n\nand copy_class_expr_desc :\n From.Parsetree.class_expr_desc -> To.Parsetree.class_expr_desc = function\n | From.Parsetree.Pcl_constr (x0, x1) ->\n To.Parsetree.Pcl_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Pcl_structure x0 ->\n To.Parsetree.Pcl_structure (copy_class_structure x0)\n | From.Parsetree.Pcl_fun (x0, x1, x2, x3) ->\n To.Parsetree.Pcl_fun\n ( copy_arg_label x0,\n copy_option copy_expression x1,\n copy_pattern x2,\n copy_class_expr x3 )\n | From.Parsetree.Pcl_apply (x0, x1) ->\n To.Parsetree.Pcl_apply\n ( copy_class_expr x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | From.Parsetree.Pcl_let (x0, x1, x2) ->\n To.Parsetree.Pcl_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_class_expr x2)\n | From.Parsetree.Pcl_constraint (x0, x1) ->\n To.Parsetree.Pcl_constraint (copy_class_expr x0, copy_class_type x1)\n | From.Parsetree.Pcl_extension x0 ->\n To.Parsetree.Pcl_extension (copy_extension x0)\n\nand copy_class_structure :\n From.Parsetree.class_structure -> To.Parsetree.class_structure =\n fun { From.Parsetree.pcstr_self; From.Parsetree.pcstr_fields } ->\n {\n To.Parsetree.pcstr_self = copy_pattern pcstr_self;\n To.Parsetree.pcstr_fields = List.map copy_class_field pcstr_fields;\n }\n\nand copy_class_field : From.Parsetree.class_field -> To.Parsetree.class_field =\n fun {\n From.Parsetree.pcf_desc;\n From.Parsetree.pcf_loc;\n From.Parsetree.pcf_attributes;\n } ->\n {\n To.Parsetree.pcf_desc = copy_class_field_desc pcf_desc;\n To.Parsetree.pcf_loc = copy_location pcf_loc;\n To.Parsetree.pcf_attributes = copy_attributes pcf_attributes;\n }\n\nand copy_class_field_desc :\n From.Parsetree.class_field_desc -> To.Parsetree.class_field_desc = function\n | From.Parsetree.Pcf_inherit (x0, x1, x2) ->\n To.Parsetree.Pcf_inherit\n (copy_override_flag x0, copy_class_expr x1, copy_option (fun x -> x) x2)\n | From.Parsetree.Pcf_val x0 ->\n To.Parsetree.Pcf_val\n (let x0, x1, x2 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_mutable_flag x1,\n copy_class_field_kind x2 ))\n | From.Parsetree.Pcf_method x0 ->\n To.Parsetree.Pcf_method\n (let x0, x1, x2 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_private_flag x1,\n copy_class_field_kind x2 ))\n | From.Parsetree.Pcf_constraint x0 ->\n To.Parsetree.Pcf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | From.Parsetree.Pcf_initializer x0 ->\n To.Parsetree.Pcf_initializer (copy_expression x0)\n | From.Parsetree.Pcf_attribute x0 ->\n To.Parsetree.Pcf_attribute (copy_attribute x0)\n | From.Parsetree.Pcf_extension x0 ->\n To.Parsetree.Pcf_extension (copy_extension x0)\n\nand copy_class_field_kind :\n From.Parsetree.class_field_kind -> To.Parsetree.class_field_kind = function\n | From.Parsetree.Cfk_virtual x0 ->\n To.Parsetree.Cfk_virtual (copy_core_type x0)\n | From.Parsetree.Cfk_concrete (x0, x1) ->\n To.Parsetree.Cfk_concrete (copy_override_flag x0, copy_expression x1)\n\nand copy_module_binding :\n From.Parsetree.module_binding -> To.Parsetree.module_binding =\n fun {\n From.Parsetree.pmb_name;\n From.Parsetree.pmb_expr;\n From.Parsetree.pmb_attributes;\n From.Parsetree.pmb_loc;\n } ->\n {\n To.Parsetree.pmb_name = copy_loc (fun x -> x) pmb_name;\n To.Parsetree.pmb_expr = copy_module_expr pmb_expr;\n To.Parsetree.pmb_attributes = copy_attributes pmb_attributes;\n To.Parsetree.pmb_loc = copy_location pmb_loc;\n }\n\nand copy_module_expr : From.Parsetree.module_expr -> To.Parsetree.module_expr =\n fun {\n From.Parsetree.pmod_desc;\n From.Parsetree.pmod_loc;\n From.Parsetree.pmod_attributes;\n } ->\n {\n To.Parsetree.pmod_desc = copy_module_expr_desc pmod_desc;\n To.Parsetree.pmod_loc = copy_location pmod_loc;\n To.Parsetree.pmod_attributes = copy_attributes pmod_attributes;\n }\n\nand copy_module_expr_desc :\n From.Parsetree.module_expr_desc -> To.Parsetree.module_expr_desc = function\n | From.Parsetree.Pmod_ident x0 ->\n To.Parsetree.Pmod_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pmod_structure x0 ->\n To.Parsetree.Pmod_structure (copy_structure x0)\n | From.Parsetree.Pmod_functor (x0, x1, x2) ->\n To.Parsetree.Pmod_functor\n ( copy_loc (fun x -> x) x0,\n copy_option copy_module_type x1,\n copy_module_expr x2 )\n | From.Parsetree.Pmod_apply (x0, x1) ->\n To.Parsetree.Pmod_apply (copy_module_expr x0, copy_module_expr x1)\n | From.Parsetree.Pmod_constraint (x0, x1) ->\n To.Parsetree.Pmod_constraint (copy_module_expr x0, copy_module_type x1)\n | From.Parsetree.Pmod_unpack x0 ->\n To.Parsetree.Pmod_unpack (copy_expression x0)\n | From.Parsetree.Pmod_extension x0 ->\n To.Parsetree.Pmod_extension (copy_extension x0)\n\nand copy_module_type : From.Parsetree.module_type -> To.Parsetree.module_type =\n fun {\n From.Parsetree.pmty_desc;\n From.Parsetree.pmty_loc;\n From.Parsetree.pmty_attributes;\n } ->\n {\n To.Parsetree.pmty_desc = copy_module_type_desc pmty_desc;\n To.Parsetree.pmty_loc = copy_location pmty_loc;\n To.Parsetree.pmty_attributes = copy_attributes pmty_attributes;\n }\n\nand copy_module_type_desc :\n From.Parsetree.module_type_desc -> To.Parsetree.module_type_desc = function\n | From.Parsetree.Pmty_ident x0 ->\n To.Parsetree.Pmty_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pmty_signature x0 ->\n To.Parsetree.Pmty_signature (copy_signature x0)\n | From.Parsetree.Pmty_functor (x0, x1, x2) ->\n To.Parsetree.Pmty_functor\n ( copy_loc (fun x -> x) x0,\n copy_option copy_module_type x1,\n copy_module_type x2 )\n | From.Parsetree.Pmty_with (x0, x1) ->\n To.Parsetree.Pmty_with\n (copy_module_type x0, List.map copy_with_constraint x1)\n | From.Parsetree.Pmty_typeof x0 ->\n To.Parsetree.Pmty_typeof (copy_module_expr x0)\n | From.Parsetree.Pmty_extension x0 ->\n To.Parsetree.Pmty_extension (copy_extension x0)\n | From.Parsetree.Pmty_alias x0 ->\n To.Parsetree.Pmty_alias (copy_loc copy_longident x0)\n\nand copy_with_constraint :\n From.Parsetree.with_constraint -> To.Parsetree.with_constraint = function\n | From.Parsetree.Pwith_type (x0, x1) ->\n To.Parsetree.Pwith_type\n (copy_loc copy_longident x0, copy_type_declaration x1)\n | From.Parsetree.Pwith_module (x0, x1) ->\n To.Parsetree.Pwith_module\n (copy_loc copy_longident x0, copy_loc copy_longident x1)\n | From.Parsetree.Pwith_typesubst x0 ->\n To.Parsetree.Pwith_typesubst (copy_type_declaration x0)\n | From.Parsetree.Pwith_modsubst (x0, x1) ->\n To.Parsetree.Pwith_modsubst\n (copy_loc (fun x -> x) x0, copy_loc copy_longident x1)\n\nand copy_signature : From.Parsetree.signature -> To.Parsetree.signature =\n fun x -> List.map copy_signature_item x\n\nand copy_signature_item :\n From.Parsetree.signature_item -> To.Parsetree.signature_item =\n fun { From.Parsetree.psig_desc; From.Parsetree.psig_loc } ->\n {\n To.Parsetree.psig_desc = copy_signature_item_desc psig_desc;\n To.Parsetree.psig_loc = copy_location psig_loc;\n }\n\nand copy_signature_item_desc :\n From.Parsetree.signature_item_desc -> To.Parsetree.signature_item_desc =\n function\n | From.Parsetree.Psig_value x0 ->\n To.Parsetree.Psig_value (copy_value_description x0)\n | From.Parsetree.Psig_type (x0, x1) ->\n To.Parsetree.Psig_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | From.Parsetree.Psig_typext x0 ->\n To.Parsetree.Psig_typext (copy_type_extension x0)\n | From.Parsetree.Psig_exception x0 ->\n To.Parsetree.Psig_exception (copy_extension_constructor x0)\n | From.Parsetree.Psig_module x0 ->\n To.Parsetree.Psig_module (copy_module_declaration x0)\n | From.Parsetree.Psig_recmodule x0 ->\n To.Parsetree.Psig_recmodule (List.map copy_module_declaration x0)\n | From.Parsetree.Psig_modtype x0 ->\n To.Parsetree.Psig_modtype (copy_module_type_declaration x0)\n | From.Parsetree.Psig_open x0 ->\n To.Parsetree.Psig_open (copy_open_description x0)\n | From.Parsetree.Psig_include x0 ->\n To.Parsetree.Psig_include (copy_include_description x0)\n | From.Parsetree.Psig_class x0 ->\n To.Parsetree.Psig_class (List.map copy_class_description x0)\n | From.Parsetree.Psig_class_type x0 ->\n To.Parsetree.Psig_class_type (List.map copy_class_type_declaration x0)\n | From.Parsetree.Psig_attribute x0 ->\n To.Parsetree.Psig_attribute (copy_attribute x0)\n | From.Parsetree.Psig_extension (x0, x1) ->\n To.Parsetree.Psig_extension (copy_extension x0, copy_attributes x1)\n\nand copy_class_type_declaration :\n From.Parsetree.class_type_declaration -> To.Parsetree.class_type_declaration\n =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_description :\n From.Parsetree.class_description -> To.Parsetree.class_description =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_type : From.Parsetree.class_type -> To.Parsetree.class_type =\n fun {\n From.Parsetree.pcty_desc;\n From.Parsetree.pcty_loc;\n From.Parsetree.pcty_attributes;\n } ->\n {\n To.Parsetree.pcty_desc = copy_class_type_desc pcty_desc;\n To.Parsetree.pcty_loc = copy_location pcty_loc;\n To.Parsetree.pcty_attributes = copy_attributes pcty_attributes;\n }\n\nand copy_class_type_desc :\n From.Parsetree.class_type_desc -> To.Parsetree.class_type_desc = function\n | From.Parsetree.Pcty_constr (x0, x1) ->\n To.Parsetree.Pcty_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Pcty_signature x0 ->\n To.Parsetree.Pcty_signature (copy_class_signature x0)\n | From.Parsetree.Pcty_arrow (x0, x1, x2) ->\n To.Parsetree.Pcty_arrow\n (copy_arg_label x0, copy_core_type x1, copy_class_type x2)\n | From.Parsetree.Pcty_extension x0 ->\n To.Parsetree.Pcty_extension (copy_extension x0)\n\nand copy_class_signature :\n From.Parsetree.class_signature -> To.Parsetree.class_signature =\n fun { From.Parsetree.pcsig_self; From.Parsetree.pcsig_fields } ->\n {\n To.Parsetree.pcsig_self = copy_core_type pcsig_self;\n To.Parsetree.pcsig_fields = List.map copy_class_type_field pcsig_fields;\n }\n\nand copy_class_type_field :\n From.Parsetree.class_type_field -> To.Parsetree.class_type_field =\n fun {\n From.Parsetree.pctf_desc;\n From.Parsetree.pctf_loc;\n From.Parsetree.pctf_attributes;\n } ->\n {\n To.Parsetree.pctf_desc = copy_class_type_field_desc pctf_desc;\n To.Parsetree.pctf_loc = copy_location pctf_loc;\n To.Parsetree.pctf_attributes = copy_attributes pctf_attributes;\n }\n\nand copy_class_type_field_desc :\n From.Parsetree.class_type_field_desc -> To.Parsetree.class_type_field_desc =\n function\n | From.Parsetree.Pctf_inherit x0 ->\n To.Parsetree.Pctf_inherit (copy_class_type x0)\n | From.Parsetree.Pctf_val x0 ->\n To.Parsetree.Pctf_val\n (let x0, x1, x2, x3 = x0 in\n (x0, copy_mutable_flag x1, copy_virtual_flag x2, copy_core_type x3))\n | From.Parsetree.Pctf_method x0 ->\n To.Parsetree.Pctf_method\n (let x0, x1, x2, x3 = x0 in\n (x0, copy_private_flag x1, copy_virtual_flag x2, copy_core_type x3))\n | From.Parsetree.Pctf_constraint x0 ->\n To.Parsetree.Pctf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | From.Parsetree.Pctf_attribute x0 ->\n To.Parsetree.Pctf_attribute (copy_attribute x0)\n | From.Parsetree.Pctf_extension x0 ->\n To.Parsetree.Pctf_extension (copy_extension x0)\n\nand copy_extension : From.Parsetree.extension -> To.Parsetree.extension =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_class_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 From.Parsetree.class_infos ->\n 'g0 To.Parsetree.class_infos =\n fun f0\n {\n From.Parsetree.pci_virt;\n From.Parsetree.pci_params;\n From.Parsetree.pci_name;\n From.Parsetree.pci_expr;\n From.Parsetree.pci_loc;\n From.Parsetree.pci_attributes;\n } ->\n {\n To.Parsetree.pci_virt = copy_virtual_flag pci_virt;\n To.Parsetree.pci_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n pci_params;\n To.Parsetree.pci_name = copy_loc (fun x -> x) pci_name;\n To.Parsetree.pci_expr = f0 pci_expr;\n To.Parsetree.pci_loc = copy_location pci_loc;\n To.Parsetree.pci_attributes = copy_attributes pci_attributes;\n }\n\nand copy_virtual_flag : From.Asttypes.virtual_flag -> To.Asttypes.virtual_flag =\n function\n | From.Asttypes.Virtual -> To.Asttypes.Virtual\n | From.Asttypes.Concrete -> To.Asttypes.Concrete\n\nand copy_include_description :\n From.Parsetree.include_description -> To.Parsetree.include_description =\n fun x -> copy_include_infos copy_module_type x\n\nand copy_include_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 From.Parsetree.include_infos ->\n 'g0 To.Parsetree.include_infos =\n fun f0\n {\n From.Parsetree.pincl_mod;\n From.Parsetree.pincl_loc;\n From.Parsetree.pincl_attributes;\n } ->\n {\n To.Parsetree.pincl_mod = f0 pincl_mod;\n To.Parsetree.pincl_loc = copy_location pincl_loc;\n To.Parsetree.pincl_attributes = copy_attributes pincl_attributes;\n }\n\nand copy_open_description :\n From.Parsetree.open_description -> To.Parsetree.open_description =\n fun {\n From.Parsetree.popen_lid;\n From.Parsetree.popen_override;\n From.Parsetree.popen_loc;\n From.Parsetree.popen_attributes;\n } ->\n {\n To.Parsetree.popen_lid = copy_loc copy_longident popen_lid;\n To.Parsetree.popen_override = copy_override_flag popen_override;\n To.Parsetree.popen_loc = copy_location popen_loc;\n To.Parsetree.popen_attributes = copy_attributes popen_attributes;\n }\n\nand copy_override_flag :\n From.Asttypes.override_flag -> To.Asttypes.override_flag = function\n | From.Asttypes.Override -> To.Asttypes.Override\n | From.Asttypes.Fresh -> To.Asttypes.Fresh\n\nand copy_module_type_declaration :\n From.Parsetree.module_type_declaration ->\n To.Parsetree.module_type_declaration =\n fun {\n From.Parsetree.pmtd_name;\n From.Parsetree.pmtd_type;\n From.Parsetree.pmtd_attributes;\n From.Parsetree.pmtd_loc;\n } ->\n {\n To.Parsetree.pmtd_name = copy_loc (fun x -> x) pmtd_name;\n To.Parsetree.pmtd_type = copy_option copy_module_type pmtd_type;\n To.Parsetree.pmtd_attributes = copy_attributes pmtd_attributes;\n To.Parsetree.pmtd_loc = copy_location pmtd_loc;\n }\n\nand copy_module_declaration :\n From.Parsetree.module_declaration -> To.Parsetree.module_declaration =\n fun {\n From.Parsetree.pmd_name;\n From.Parsetree.pmd_type;\n From.Parsetree.pmd_attributes;\n From.Parsetree.pmd_loc;\n } ->\n {\n To.Parsetree.pmd_name = copy_loc (fun x -> x) pmd_name;\n To.Parsetree.pmd_type = copy_module_type pmd_type;\n To.Parsetree.pmd_attributes = copy_attributes pmd_attributes;\n To.Parsetree.pmd_loc = copy_location pmd_loc;\n }\n\nand copy_type_extension :\n From.Parsetree.type_extension -> To.Parsetree.type_extension =\n fun {\n From.Parsetree.ptyext_path;\n From.Parsetree.ptyext_params;\n From.Parsetree.ptyext_constructors;\n From.Parsetree.ptyext_private;\n From.Parsetree.ptyext_attributes;\n } ->\n {\n To.Parsetree.ptyext_path = copy_loc copy_longident ptyext_path;\n To.Parsetree.ptyext_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptyext_params;\n To.Parsetree.ptyext_constructors =\n List.map copy_extension_constructor ptyext_constructors;\n To.Parsetree.ptyext_private = copy_private_flag ptyext_private;\n To.Parsetree.ptyext_attributes = copy_attributes ptyext_attributes;\n }\n\nand copy_extension_constructor :\n From.Parsetree.extension_constructor -> To.Parsetree.extension_constructor =\n fun {\n From.Parsetree.pext_name;\n From.Parsetree.pext_kind;\n From.Parsetree.pext_loc;\n From.Parsetree.pext_attributes;\n } ->\n {\n To.Parsetree.pext_name = copy_loc (fun x -> x) pext_name;\n To.Parsetree.pext_kind = copy_extension_constructor_kind pext_kind;\n To.Parsetree.pext_loc = copy_location pext_loc;\n To.Parsetree.pext_attributes = copy_attributes pext_attributes;\n }\n\nand copy_extension_constructor_kind :\n From.Parsetree.extension_constructor_kind ->\n To.Parsetree.extension_constructor_kind = function\n | From.Parsetree.Pext_decl (x0, x1) ->\n To.Parsetree.Pext_decl\n (copy_constructor_arguments x0, copy_option copy_core_type x1)\n | From.Parsetree.Pext_rebind x0 ->\n To.Parsetree.Pext_rebind (copy_loc copy_longident x0)\n\nand copy_type_declaration :\n From.Parsetree.type_declaration -> To.Parsetree.type_declaration =\n fun {\n From.Parsetree.ptype_name;\n From.Parsetree.ptype_params;\n From.Parsetree.ptype_cstrs;\n From.Parsetree.ptype_kind;\n From.Parsetree.ptype_private;\n From.Parsetree.ptype_manifest;\n From.Parsetree.ptype_attributes;\n From.Parsetree.ptype_loc;\n } ->\n {\n To.Parsetree.ptype_name = copy_loc (fun x -> x) ptype_name;\n To.Parsetree.ptype_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptype_params;\n To.Parsetree.ptype_cstrs =\n List.map\n (fun x ->\n let x0, x1, x2 = x in\n (copy_core_type x0, copy_core_type x1, copy_location x2))\n ptype_cstrs;\n To.Parsetree.ptype_kind = copy_type_kind ptype_kind;\n To.Parsetree.ptype_private = copy_private_flag ptype_private;\n To.Parsetree.ptype_manifest = copy_option copy_core_type ptype_manifest;\n To.Parsetree.ptype_attributes = copy_attributes ptype_attributes;\n To.Parsetree.ptype_loc = copy_location ptype_loc;\n }\n\nand copy_private_flag : From.Asttypes.private_flag -> To.Asttypes.private_flag =\n function\n | From.Asttypes.Private -> To.Asttypes.Private\n | From.Asttypes.Public -> To.Asttypes.Public\n\nand copy_type_kind : From.Parsetree.type_kind -> To.Parsetree.type_kind =\n function\n | From.Parsetree.Ptype_abstract -> To.Parsetree.Ptype_abstract\n | From.Parsetree.Ptype_variant x0 ->\n To.Parsetree.Ptype_variant (List.map copy_constructor_declaration x0)\n | From.Parsetree.Ptype_record x0 ->\n To.Parsetree.Ptype_record (List.map copy_label_declaration x0)\n | From.Parsetree.Ptype_open -> To.Parsetree.Ptype_open\n\nand copy_constructor_declaration :\n From.Parsetree.constructor_declaration ->\n To.Parsetree.constructor_declaration =\n fun {\n From.Parsetree.pcd_name;\n From.Parsetree.pcd_args;\n From.Parsetree.pcd_res;\n From.Parsetree.pcd_loc;\n From.Parsetree.pcd_attributes;\n } ->\n {\n To.Parsetree.pcd_name = copy_loc (fun x -> x) pcd_name;\n To.Parsetree.pcd_args = copy_constructor_arguments pcd_args;\n To.Parsetree.pcd_res = copy_option copy_core_type pcd_res;\n To.Parsetree.pcd_loc = copy_location pcd_loc;\n To.Parsetree.pcd_attributes = copy_attributes pcd_attributes;\n }\n\nand copy_constructor_arguments :\n From.Parsetree.constructor_arguments -> To.Parsetree.constructor_arguments =\n function\n | From.Parsetree.Pcstr_tuple x0 ->\n To.Parsetree.Pcstr_tuple (List.map copy_core_type x0)\n | From.Parsetree.Pcstr_record x0 ->\n To.Parsetree.Pcstr_record (List.map copy_label_declaration x0)\n\nand copy_label_declaration :\n From.Parsetree.label_declaration -> To.Parsetree.label_declaration =\n fun {\n From.Parsetree.pld_name;\n From.Parsetree.pld_mutable;\n From.Parsetree.pld_type;\n From.Parsetree.pld_loc;\n From.Parsetree.pld_attributes;\n } ->\n {\n To.Parsetree.pld_name = copy_loc (fun x -> x) pld_name;\n To.Parsetree.pld_mutable = copy_mutable_flag pld_mutable;\n To.Parsetree.pld_type = copy_core_type pld_type;\n To.Parsetree.pld_loc = copy_location pld_loc;\n To.Parsetree.pld_attributes = copy_attributes pld_attributes;\n }\n\nand copy_mutable_flag : From.Asttypes.mutable_flag -> To.Asttypes.mutable_flag =\n function\n | From.Asttypes.Immutable -> To.Asttypes.Immutable\n | From.Asttypes.Mutable -> To.Asttypes.Mutable\n\nand copy_variance : From.Asttypes.variance -> To.Asttypes.variance = function\n | From.Asttypes.Covariant -> To.Asttypes.Covariant\n | From.Asttypes.Contravariant -> To.Asttypes.Contravariant\n | From.Asttypes.Invariant -> To.Asttypes.Invariant\n\nand copy_value_description :\n From.Parsetree.value_description -> To.Parsetree.value_description =\n fun {\n From.Parsetree.pval_name;\n From.Parsetree.pval_type;\n From.Parsetree.pval_prim;\n From.Parsetree.pval_attributes;\n From.Parsetree.pval_loc;\n } ->\n {\n To.Parsetree.pval_name = copy_loc (fun x -> x) pval_name;\n To.Parsetree.pval_type = copy_core_type pval_type;\n To.Parsetree.pval_prim = List.map (fun x -> x) pval_prim;\n To.Parsetree.pval_attributes = copy_attributes pval_attributes;\n To.Parsetree.pval_loc = copy_location pval_loc;\n }\n\nand copy_arg_label : From.Asttypes.arg_label -> To.Asttypes.arg_label = function\n | From.Asttypes.Nolabel -> To.Asttypes.Nolabel\n | From.Asttypes.Labelled x0 -> To.Asttypes.Labelled x0\n | From.Asttypes.Optional x0 -> To.Asttypes.Optional x0\n\nand copy_closed_flag : From.Asttypes.closed_flag -> To.Asttypes.closed_flag =\n function\n | From.Asttypes.Closed -> To.Asttypes.Closed\n | From.Asttypes.Open -> To.Asttypes.Open\n\nand copy_label : From.Asttypes.label -> To.Asttypes.label = fun x -> x\n\nand copy_rec_flag : From.Asttypes.rec_flag -> To.Asttypes.rec_flag = function\n | From.Asttypes.Nonrecursive -> To.Asttypes.Nonrecursive\n | From.Asttypes.Recursive -> To.Asttypes.Recursive\n\nand copy_constant : From.Parsetree.constant -> To.Parsetree.constant = function\n | From.Parsetree.Pconst_integer (x0, x1) ->\n To.Parsetree.Pconst_integer (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pconst_char x0 -> To.Parsetree.Pconst_char x0\n | From.Parsetree.Pconst_string (x0, x1) ->\n To.Parsetree.Pconst_string (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pconst_float (x0, x1) ->\n To.Parsetree.Pconst_float (x0, copy_option (fun x -> x) x1)\n\nand copy_option : 'f0 'g0. ('f0 -> 'g0) -> 'f0 option -> 'g0 option =\n fun f0 -> function None -> None | Some x0 -> Some (f0 x0)\n\nand copy_longident : Longident.t -> Longident.t = fun x -> x\n\nand copy_loc :\n 'f0 'g0. ('f0 -> 'g0) -> 'f0 From.Asttypes.loc -> 'g0 To.Asttypes.loc =\n fun f0 { From.Asttypes.txt; From.Asttypes.loc } ->\n { To.Asttypes.txt = f0 txt; To.Asttypes.loc = copy_location loc }\n\nand copy_location : Location.t -> Location.t = fun x -> x\nand copy_bool : bool -> bool = function false -> false | true -> true\n\nlet rec copy_toplevel_phrase :\n From.Parsetree.toplevel_phrase -> To.Parsetree.toplevel_phrase = function\n | From.Parsetree.Ptop_def x0 -> To.Parsetree.Ptop_def (copy_structure x0)\n | From.Parsetree.Ptop_dir (x0, x1) ->\n To.Parsetree.Ptop_dir (x0, copy_directive_argument x1)\n\nand copy_directive_argument :\n From.Parsetree.directive_argument -> To.Parsetree.directive_argument =\n function\n | From.Parsetree.Pdir_none -> To.Parsetree.Pdir_none\n | From.Parsetree.Pdir_string x0 -> To.Parsetree.Pdir_string x0\n | From.Parsetree.Pdir_int (x0, x1) ->\n To.Parsetree.Pdir_int (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pdir_ident x0 -> To.Parsetree.Pdir_ident (copy_longident x0)\n | From.Parsetree.Pdir_bool x0 -> To.Parsetree.Pdir_bool (copy_bool x0)\n\nlet copy_cases x = List.map copy_case x\nlet copy_pat = copy_pattern\nlet copy_expr = copy_expression\nlet copy_typ = copy_core_type\n","(**************************************************************************)\n(* *)\n(* OCaml Migrate Parsetree *)\n(* *)\n(* Frédéric Bour *)\n(* Alain Frisch, LexiFi *)\n(* *)\n(* Copyright 2017 Institut National de Recherche en Informatique et *)\n(* en Automatique (INRIA). *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nmodule From = Ast_402\nmodule To = Ast_403\n\nlet extract_predef_option label typ =\n let open From in\n let open Longident in\n match (label, typ.Parsetree.ptyp_desc) with\n | ( To.Asttypes.Optional _,\n From.Parsetree.Ptyp_constr\n ({ Location.txt = Ldot (Lident \"*predef*\", \"option\"); _ }, [ d ]) ) ->\n d\n | _ -> typ\n\nlet rec copy_expression : From.Parsetree.expression -> To.Parsetree.expression =\n fun {\n From.Parsetree.pexp_desc;\n From.Parsetree.pexp_loc;\n From.Parsetree.pexp_attributes;\n } ->\n {\n To.Parsetree.pexp_desc = copy_expression_desc pexp_desc;\n To.Parsetree.pexp_loc = copy_location pexp_loc;\n To.Parsetree.pexp_attributes = copy_attributes pexp_attributes;\n }\n\nand copy_expression_desc :\n From.Parsetree.expression_desc -> To.Parsetree.expression_desc = function\n | From.Parsetree.Pexp_ident x0 ->\n To.Parsetree.Pexp_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pexp_constant x0 ->\n To.Parsetree.Pexp_constant (copy_constant x0)\n | From.Parsetree.Pexp_let (x0, x1, x2) ->\n To.Parsetree.Pexp_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_expression x2)\n | From.Parsetree.Pexp_function x0 ->\n To.Parsetree.Pexp_function (List.map copy_case x0)\n | From.Parsetree.Pexp_fun (x0, x1, x2, x3) ->\n To.Parsetree.Pexp_fun\n ( copy_arg_label x0,\n copy_option copy_expression x1,\n copy_pattern x2,\n copy_expression x3 )\n | From.Parsetree.Pexp_apply (x0, x1) ->\n To.Parsetree.Pexp_apply\n ( copy_expression x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | From.Parsetree.Pexp_match (x0, x1) ->\n To.Parsetree.Pexp_match (copy_expression x0, List.map copy_case x1)\n | From.Parsetree.Pexp_try (x0, x1) ->\n To.Parsetree.Pexp_try (copy_expression x0, List.map copy_case x1)\n | From.Parsetree.Pexp_tuple x0 ->\n To.Parsetree.Pexp_tuple (List.map copy_expression x0)\n | From.Parsetree.Pexp_construct (x0, x1) ->\n To.Parsetree.Pexp_construct\n (copy_loc copy_longident x0, copy_option copy_expression x1)\n | From.Parsetree.Pexp_variant (x0, x1) ->\n To.Parsetree.Pexp_variant (copy_label x0, copy_option copy_expression x1)\n | From.Parsetree.Pexp_record (x0, x1) ->\n To.Parsetree.Pexp_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_expression x1))\n x0,\n copy_option copy_expression x1 )\n | From.Parsetree.Pexp_field (x0, x1) ->\n To.Parsetree.Pexp_field (copy_expression x0, copy_loc copy_longident x1)\n | From.Parsetree.Pexp_setfield (x0, x1, x2) ->\n To.Parsetree.Pexp_setfield\n (copy_expression x0, copy_loc copy_longident x1, copy_expression x2)\n | From.Parsetree.Pexp_array x0 ->\n To.Parsetree.Pexp_array (List.map copy_expression x0)\n | From.Parsetree.Pexp_ifthenelse (x0, x1, x2) ->\n To.Parsetree.Pexp_ifthenelse\n (copy_expression x0, copy_expression x1, copy_option copy_expression x2)\n | From.Parsetree.Pexp_sequence (x0, x1) ->\n To.Parsetree.Pexp_sequence (copy_expression x0, copy_expression x1)\n | From.Parsetree.Pexp_while (x0, x1) ->\n To.Parsetree.Pexp_while (copy_expression x0, copy_expression x1)\n | From.Parsetree.Pexp_for (x0, x1, x2, x3, x4) ->\n To.Parsetree.Pexp_for\n ( copy_pattern x0,\n copy_expression x1,\n copy_expression x2,\n copy_direction_flag x3,\n copy_expression x4 )\n | From.Parsetree.Pexp_constraint (x0, x1) ->\n To.Parsetree.Pexp_constraint (copy_expression x0, copy_core_type x1)\n | From.Parsetree.Pexp_coerce (x0, x1, x2) ->\n To.Parsetree.Pexp_coerce\n (copy_expression x0, copy_option copy_core_type x1, copy_core_type x2)\n | From.Parsetree.Pexp_send (x0, x1) ->\n To.Parsetree.Pexp_send (copy_expression x0, x1)\n | From.Parsetree.Pexp_new x0 ->\n To.Parsetree.Pexp_new (copy_loc copy_longident x0)\n | From.Parsetree.Pexp_setinstvar (x0, x1) ->\n To.Parsetree.Pexp_setinstvar (copy_loc (fun x -> x) x0, copy_expression x1)\n | From.Parsetree.Pexp_override x0 ->\n To.Parsetree.Pexp_override\n (List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_expression x1))\n x0)\n | From.Parsetree.Pexp_letmodule (x0, x1, x2) ->\n To.Parsetree.Pexp_letmodule\n (copy_loc (fun x -> x) x0, copy_module_expr x1, copy_expression x2)\n | From.Parsetree.Pexp_assert x0 ->\n To.Parsetree.Pexp_assert (copy_expression x0)\n | From.Parsetree.Pexp_lazy x0 -> To.Parsetree.Pexp_lazy (copy_expression x0)\n | From.Parsetree.Pexp_poly (x0, x1) ->\n To.Parsetree.Pexp_poly (copy_expression x0, copy_option copy_core_type x1)\n | From.Parsetree.Pexp_object x0 ->\n To.Parsetree.Pexp_object (copy_class_structure x0)\n | From.Parsetree.Pexp_newtype (x0, x1) ->\n To.Parsetree.Pexp_newtype (x0, copy_expression x1)\n | From.Parsetree.Pexp_pack x0 -> To.Parsetree.Pexp_pack (copy_module_expr x0)\n | From.Parsetree.Pexp_open (x0, x1, x2) ->\n To.Parsetree.Pexp_open\n (copy_override_flag x0, copy_loc copy_longident x1, copy_expression x2)\n | From.Parsetree.Pexp_extension x0 ->\n To.Parsetree.Pexp_extension (copy_extension x0)\n\nand copy_direction_flag :\n From.Asttypes.direction_flag -> To.Asttypes.direction_flag = function\n | From.Asttypes.Upto -> To.Asttypes.Upto\n | From.Asttypes.Downto -> To.Asttypes.Downto\n\nand copy_case : From.Parsetree.case -> To.Parsetree.case =\n fun { From.Parsetree.pc_lhs; From.Parsetree.pc_guard; From.Parsetree.pc_rhs } ->\n {\n To.Parsetree.pc_lhs = copy_pattern pc_lhs;\n To.Parsetree.pc_guard = copy_option copy_expression pc_guard;\n To.Parsetree.pc_rhs = copy_expression pc_rhs;\n }\n\nand copy_value_binding :\n From.Parsetree.value_binding -> To.Parsetree.value_binding =\n fun {\n From.Parsetree.pvb_pat;\n From.Parsetree.pvb_expr;\n From.Parsetree.pvb_attributes;\n From.Parsetree.pvb_loc;\n } ->\n {\n To.Parsetree.pvb_pat = copy_pattern pvb_pat;\n To.Parsetree.pvb_expr = copy_expression pvb_expr;\n To.Parsetree.pvb_attributes = copy_attributes pvb_attributes;\n To.Parsetree.pvb_loc = copy_location pvb_loc;\n }\n\nand copy_pattern : From.Parsetree.pattern -> To.Parsetree.pattern =\n fun {\n From.Parsetree.ppat_desc;\n From.Parsetree.ppat_loc;\n From.Parsetree.ppat_attributes;\n } ->\n {\n To.Parsetree.ppat_desc = copy_pattern_desc ppat_desc;\n To.Parsetree.ppat_loc = copy_location ppat_loc;\n To.Parsetree.ppat_attributes = copy_attributes ppat_attributes;\n }\n\nand copy_pattern_desc : From.Parsetree.pattern_desc -> To.Parsetree.pattern_desc\n = function\n | From.Parsetree.Ppat_any -> To.Parsetree.Ppat_any\n | From.Parsetree.Ppat_var x0 ->\n To.Parsetree.Ppat_var (copy_loc (fun x -> x) x0)\n | From.Parsetree.Ppat_alias (x0, x1) ->\n To.Parsetree.Ppat_alias (copy_pattern x0, copy_loc (fun x -> x) x1)\n | From.Parsetree.Ppat_constant x0 ->\n To.Parsetree.Ppat_constant (copy_constant x0)\n | From.Parsetree.Ppat_interval (x0, x1) ->\n To.Parsetree.Ppat_interval (copy_constant x0, copy_constant x1)\n | From.Parsetree.Ppat_tuple x0 ->\n To.Parsetree.Ppat_tuple (List.map copy_pattern x0)\n | From.Parsetree.Ppat_construct (x0, x1) ->\n To.Parsetree.Ppat_construct\n (copy_loc copy_longident x0, copy_option copy_pattern x1)\n | From.Parsetree.Ppat_variant (x0, x1) ->\n To.Parsetree.Ppat_variant (copy_label x0, copy_option copy_pattern x1)\n | From.Parsetree.Ppat_record (x0, x1) ->\n To.Parsetree.Ppat_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_pattern x1))\n x0,\n copy_closed_flag x1 )\n | From.Parsetree.Ppat_array x0 ->\n To.Parsetree.Ppat_array (List.map copy_pattern x0)\n | From.Parsetree.Ppat_or (x0, x1) ->\n To.Parsetree.Ppat_or (copy_pattern x0, copy_pattern x1)\n | From.Parsetree.Ppat_constraint (x0, x1) ->\n To.Parsetree.Ppat_constraint (copy_pattern x0, copy_core_type x1)\n | From.Parsetree.Ppat_type x0 ->\n To.Parsetree.Ppat_type (copy_loc copy_longident x0)\n | From.Parsetree.Ppat_lazy x0 -> To.Parsetree.Ppat_lazy (copy_pattern x0)\n | From.Parsetree.Ppat_unpack x0 ->\n To.Parsetree.Ppat_unpack (copy_loc (fun x -> x) x0)\n | From.Parsetree.Ppat_exception x0 ->\n To.Parsetree.Ppat_exception (copy_pattern x0)\n | From.Parsetree.Ppat_extension x0 ->\n To.Parsetree.Ppat_extension (copy_extension x0)\n\nand copy_core_type : From.Parsetree.core_type -> To.Parsetree.core_type =\n fun {\n From.Parsetree.ptyp_desc;\n From.Parsetree.ptyp_loc;\n From.Parsetree.ptyp_attributes;\n } ->\n {\n To.Parsetree.ptyp_desc = copy_core_type_desc ptyp_desc;\n To.Parsetree.ptyp_loc = copy_location ptyp_loc;\n To.Parsetree.ptyp_attributes = copy_attributes ptyp_attributes;\n }\n\nand copy_core_type_desc :\n From.Parsetree.core_type_desc -> To.Parsetree.core_type_desc = function\n | From.Parsetree.Ptyp_any -> To.Parsetree.Ptyp_any\n | From.Parsetree.Ptyp_var x0 -> To.Parsetree.Ptyp_var x0\n | From.Parsetree.Ptyp_arrow (x0, x1, x2) ->\n let label = copy_arg_label x0 in\n To.Parsetree.Ptyp_arrow\n ( label,\n copy_core_type (extract_predef_option label x1),\n copy_core_type x2 )\n | From.Parsetree.Ptyp_tuple x0 ->\n To.Parsetree.Ptyp_tuple (List.map copy_core_type x0)\n | From.Parsetree.Ptyp_constr (x0, x1) ->\n To.Parsetree.Ptyp_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Ptyp_object (x0, x1) ->\n To.Parsetree.Ptyp_object\n ( List.map\n (fun x ->\n let x0, x1, x2 = x in\n (x0, copy_attributes x1, copy_core_type x2))\n x0,\n copy_closed_flag x1 )\n | From.Parsetree.Ptyp_class (x0, x1) ->\n To.Parsetree.Ptyp_class\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Ptyp_alias (x0, x1) ->\n To.Parsetree.Ptyp_alias (copy_core_type x0, x1)\n | From.Parsetree.Ptyp_variant (x0, x1, x2) ->\n To.Parsetree.Ptyp_variant\n ( List.map copy_row_field x0,\n copy_closed_flag x1,\n copy_option (fun x -> List.map copy_label x) x2 )\n | From.Parsetree.Ptyp_poly (x0, x1) ->\n To.Parsetree.Ptyp_poly (List.map (fun x -> x) x0, copy_core_type x1)\n | From.Parsetree.Ptyp_package x0 ->\n To.Parsetree.Ptyp_package (copy_package_type x0)\n | From.Parsetree.Ptyp_extension x0 ->\n To.Parsetree.Ptyp_extension (copy_extension x0)\n\nand copy_package_type : From.Parsetree.package_type -> To.Parsetree.package_type\n =\n fun x ->\n let x0, x1 = x in\n ( copy_loc copy_longident x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_core_type x1))\n x1 )\n\nand copy_row_field : From.Parsetree.row_field -> To.Parsetree.row_field =\n function\n | From.Parsetree.Rtag (x0, x1, x2, x3) ->\n To.Parsetree.Rtag\n ( copy_label x0,\n copy_attributes x1,\n copy_bool x2,\n List.map copy_core_type x3 )\n | From.Parsetree.Rinherit x0 -> To.Parsetree.Rinherit (copy_core_type x0)\n\nand copy_attributes : From.Parsetree.attributes -> To.Parsetree.attributes =\n fun x -> List.map copy_attribute x\n\nand copy_attribute : From.Parsetree.attribute -> To.Parsetree.attribute =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_payload : From.Parsetree.payload -> To.Parsetree.payload = function\n | From.Parsetree.PStr x0 -> To.Parsetree.PStr (copy_structure x0)\n | From.Parsetree.PTyp x0 -> To.Parsetree.PTyp (copy_core_type x0)\n | From.Parsetree.PPat (x0, x1) ->\n To.Parsetree.PPat (copy_pattern x0, copy_option copy_expression x1)\n\nand copy_structure : From.Parsetree.structure -> To.Parsetree.structure =\n fun x -> List.map copy_structure_item x\n\nand copy_structure_item :\n From.Parsetree.structure_item -> To.Parsetree.structure_item =\n fun { From.Parsetree.pstr_desc; From.Parsetree.pstr_loc } ->\n {\n To.Parsetree.pstr_desc = copy_structure_item_desc pstr_desc;\n To.Parsetree.pstr_loc = copy_location pstr_loc;\n }\n\nand copy_structure_item_desc :\n From.Parsetree.structure_item_desc -> To.Parsetree.structure_item_desc =\n function\n | From.Parsetree.Pstr_eval (x0, x1) ->\n To.Parsetree.Pstr_eval (copy_expression x0, copy_attributes x1)\n | From.Parsetree.Pstr_value (x0, x1) ->\n To.Parsetree.Pstr_value (copy_rec_flag x0, List.map copy_value_binding x1)\n | From.Parsetree.Pstr_primitive x0 ->\n To.Parsetree.Pstr_primitive (copy_value_description x0)\n | From.Parsetree.Pstr_type x0 ->\n let recflag, types = type_declarations x0 in\n To.Parsetree.Pstr_type (recflag, types)\n | From.Parsetree.Pstr_typext x0 ->\n To.Parsetree.Pstr_typext (copy_type_extension x0)\n | From.Parsetree.Pstr_exception x0 ->\n To.Parsetree.Pstr_exception (copy_extension_constructor x0)\n | From.Parsetree.Pstr_module x0 ->\n To.Parsetree.Pstr_module (copy_module_binding x0)\n | From.Parsetree.Pstr_recmodule x0 ->\n To.Parsetree.Pstr_recmodule (List.map copy_module_binding x0)\n | From.Parsetree.Pstr_modtype x0 ->\n To.Parsetree.Pstr_modtype (copy_module_type_declaration x0)\n | From.Parsetree.Pstr_open x0 ->\n To.Parsetree.Pstr_open (copy_open_description x0)\n | From.Parsetree.Pstr_class x0 ->\n To.Parsetree.Pstr_class (List.map copy_class_declaration x0)\n | From.Parsetree.Pstr_class_type x0 ->\n To.Parsetree.Pstr_class_type (List.map copy_class_type_declaration x0)\n | From.Parsetree.Pstr_include x0 ->\n To.Parsetree.Pstr_include (copy_include_declaration x0)\n | From.Parsetree.Pstr_attribute x0 ->\n To.Parsetree.Pstr_attribute (copy_attribute x0)\n | From.Parsetree.Pstr_extension (x0, x1) ->\n To.Parsetree.Pstr_extension (copy_extension x0, copy_attributes x1)\n\nand copy_include_declaration :\n From.Parsetree.include_declaration -> To.Parsetree.include_declaration =\n fun x -> copy_include_infos copy_module_expr x\n\nand copy_class_declaration :\n From.Parsetree.class_declaration -> To.Parsetree.class_declaration =\n fun x -> copy_class_infos copy_class_expr x\n\nand copy_class_expr : From.Parsetree.class_expr -> To.Parsetree.class_expr =\n fun {\n From.Parsetree.pcl_desc;\n From.Parsetree.pcl_loc;\n From.Parsetree.pcl_attributes;\n } ->\n {\n To.Parsetree.pcl_desc = copy_class_expr_desc pcl_desc;\n To.Parsetree.pcl_loc = copy_location pcl_loc;\n To.Parsetree.pcl_attributes = copy_attributes pcl_attributes;\n }\n\nand copy_class_expr_desc :\n From.Parsetree.class_expr_desc -> To.Parsetree.class_expr_desc = function\n | From.Parsetree.Pcl_constr (x0, x1) ->\n To.Parsetree.Pcl_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Pcl_structure x0 ->\n To.Parsetree.Pcl_structure (copy_class_structure x0)\n | From.Parsetree.Pcl_fun (x0, x1, x2, x3) ->\n To.Parsetree.Pcl_fun\n ( copy_arg_label x0,\n copy_option copy_expression x1,\n copy_pattern x2,\n copy_class_expr x3 )\n | From.Parsetree.Pcl_apply (x0, x1) ->\n To.Parsetree.Pcl_apply\n ( copy_class_expr x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | From.Parsetree.Pcl_let (x0, x1, x2) ->\n To.Parsetree.Pcl_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_class_expr x2)\n | From.Parsetree.Pcl_constraint (x0, x1) ->\n To.Parsetree.Pcl_constraint (copy_class_expr x0, copy_class_type x1)\n | From.Parsetree.Pcl_extension x0 ->\n To.Parsetree.Pcl_extension (copy_extension x0)\n\nand copy_class_structure :\n From.Parsetree.class_structure -> To.Parsetree.class_structure =\n fun { From.Parsetree.pcstr_self; From.Parsetree.pcstr_fields } ->\n {\n To.Parsetree.pcstr_self = copy_pattern pcstr_self;\n To.Parsetree.pcstr_fields = List.map copy_class_field pcstr_fields;\n }\n\nand copy_class_field : From.Parsetree.class_field -> To.Parsetree.class_field =\n fun {\n From.Parsetree.pcf_desc;\n From.Parsetree.pcf_loc;\n From.Parsetree.pcf_attributes;\n } ->\n {\n To.Parsetree.pcf_desc = copy_class_field_desc pcf_desc;\n To.Parsetree.pcf_loc = copy_location pcf_loc;\n To.Parsetree.pcf_attributes = copy_attributes pcf_attributes;\n }\n\nand copy_class_field_desc :\n From.Parsetree.class_field_desc -> To.Parsetree.class_field_desc = function\n | From.Parsetree.Pcf_inherit (x0, x1, x2) ->\n To.Parsetree.Pcf_inherit\n (copy_override_flag x0, copy_class_expr x1, copy_option (fun x -> x) x2)\n | From.Parsetree.Pcf_val x0 ->\n To.Parsetree.Pcf_val\n (let x0, x1, x2 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_mutable_flag x1,\n copy_class_field_kind x2 ))\n | From.Parsetree.Pcf_method x0 ->\n To.Parsetree.Pcf_method\n (let x0, x1, x2 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_private_flag x1,\n copy_class_field_kind x2 ))\n | From.Parsetree.Pcf_constraint x0 ->\n To.Parsetree.Pcf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | From.Parsetree.Pcf_initializer x0 ->\n To.Parsetree.Pcf_initializer (copy_expression x0)\n | From.Parsetree.Pcf_attribute x0 ->\n To.Parsetree.Pcf_attribute (copy_attribute x0)\n | From.Parsetree.Pcf_extension x0 ->\n To.Parsetree.Pcf_extension (copy_extension x0)\n\nand copy_class_field_kind :\n From.Parsetree.class_field_kind -> To.Parsetree.class_field_kind = function\n | From.Parsetree.Cfk_virtual x0 ->\n To.Parsetree.Cfk_virtual (copy_core_type x0)\n | From.Parsetree.Cfk_concrete (x0, x1) ->\n To.Parsetree.Cfk_concrete (copy_override_flag x0, copy_expression x1)\n\nand copy_module_binding :\n From.Parsetree.module_binding -> To.Parsetree.module_binding =\n fun {\n From.Parsetree.pmb_name;\n From.Parsetree.pmb_expr;\n From.Parsetree.pmb_attributes;\n From.Parsetree.pmb_loc;\n } ->\n {\n To.Parsetree.pmb_name = copy_loc (fun x -> x) pmb_name;\n To.Parsetree.pmb_expr = copy_module_expr pmb_expr;\n To.Parsetree.pmb_attributes = copy_attributes pmb_attributes;\n To.Parsetree.pmb_loc = copy_location pmb_loc;\n }\n\nand copy_module_expr : From.Parsetree.module_expr -> To.Parsetree.module_expr =\n fun {\n From.Parsetree.pmod_desc;\n From.Parsetree.pmod_loc;\n From.Parsetree.pmod_attributes;\n } ->\n {\n To.Parsetree.pmod_desc = copy_module_expr_desc pmod_desc;\n To.Parsetree.pmod_loc = copy_location pmod_loc;\n To.Parsetree.pmod_attributes = copy_attributes pmod_attributes;\n }\n\nand copy_module_expr_desc :\n From.Parsetree.module_expr_desc -> To.Parsetree.module_expr_desc = function\n | From.Parsetree.Pmod_ident x0 ->\n To.Parsetree.Pmod_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pmod_structure x0 ->\n To.Parsetree.Pmod_structure (copy_structure x0)\n | From.Parsetree.Pmod_functor (x0, x1, x2) ->\n To.Parsetree.Pmod_functor\n ( copy_loc (fun x -> x) x0,\n copy_option copy_module_type x1,\n copy_module_expr x2 )\n | From.Parsetree.Pmod_apply (x0, x1) ->\n To.Parsetree.Pmod_apply (copy_module_expr x0, copy_module_expr x1)\n | From.Parsetree.Pmod_constraint (x0, x1) ->\n To.Parsetree.Pmod_constraint (copy_module_expr x0, copy_module_type x1)\n | From.Parsetree.Pmod_unpack x0 ->\n To.Parsetree.Pmod_unpack (copy_expression x0)\n | From.Parsetree.Pmod_extension x0 ->\n To.Parsetree.Pmod_extension (copy_extension x0)\n\nand copy_module_type : From.Parsetree.module_type -> To.Parsetree.module_type =\n fun {\n From.Parsetree.pmty_desc;\n From.Parsetree.pmty_loc;\n From.Parsetree.pmty_attributes;\n } ->\n {\n To.Parsetree.pmty_desc = copy_module_type_desc pmty_desc;\n To.Parsetree.pmty_loc = copy_location pmty_loc;\n To.Parsetree.pmty_attributes = copy_attributes pmty_attributes;\n }\n\nand copy_module_type_desc :\n From.Parsetree.module_type_desc -> To.Parsetree.module_type_desc = function\n | From.Parsetree.Pmty_ident x0 ->\n To.Parsetree.Pmty_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pmty_signature x0 ->\n To.Parsetree.Pmty_signature (copy_signature x0)\n | From.Parsetree.Pmty_functor (x0, x1, x2) ->\n To.Parsetree.Pmty_functor\n ( copy_loc (fun x -> x) x0,\n copy_option copy_module_type x1,\n copy_module_type x2 )\n | From.Parsetree.Pmty_with (x0, x1) ->\n To.Parsetree.Pmty_with\n (copy_module_type x0, List.map copy_with_constraint x1)\n | From.Parsetree.Pmty_typeof x0 ->\n To.Parsetree.Pmty_typeof (copy_module_expr x0)\n | From.Parsetree.Pmty_extension x0 ->\n To.Parsetree.Pmty_extension (copy_extension x0)\n | From.Parsetree.Pmty_alias x0 ->\n To.Parsetree.Pmty_alias (copy_loc copy_longident x0)\n\nand copy_with_constraint :\n From.Parsetree.with_constraint -> To.Parsetree.with_constraint = function\n | From.Parsetree.Pwith_type (x0, x1) ->\n To.Parsetree.Pwith_type\n (copy_loc copy_longident x0, copy_type_declaration x1)\n | From.Parsetree.Pwith_module (x0, x1) ->\n To.Parsetree.Pwith_module\n (copy_loc copy_longident x0, copy_loc copy_longident x1)\n | From.Parsetree.Pwith_typesubst x0 ->\n To.Parsetree.Pwith_typesubst (copy_type_declaration x0)\n | From.Parsetree.Pwith_modsubst (x0, x1) ->\n To.Parsetree.Pwith_modsubst\n (copy_loc (fun x -> x) x0, copy_loc copy_longident x1)\n\nand copy_signature : From.Parsetree.signature -> To.Parsetree.signature =\n fun x -> List.map copy_signature_item x\n\nand copy_signature_item :\n From.Parsetree.signature_item -> To.Parsetree.signature_item =\n fun { From.Parsetree.psig_desc; From.Parsetree.psig_loc } ->\n {\n To.Parsetree.psig_desc = copy_signature_item_desc psig_desc;\n To.Parsetree.psig_loc = copy_location psig_loc;\n }\n\nand copy_signature_item_desc :\n From.Parsetree.signature_item_desc -> To.Parsetree.signature_item_desc =\n function\n | From.Parsetree.Psig_value x0 ->\n To.Parsetree.Psig_value (copy_value_description x0)\n | From.Parsetree.Psig_type x0 ->\n let recflag, types = type_declarations x0 in\n To.Parsetree.Psig_type (recflag, types)\n | From.Parsetree.Psig_typext x0 ->\n To.Parsetree.Psig_typext (copy_type_extension x0)\n | From.Parsetree.Psig_exception x0 ->\n To.Parsetree.Psig_exception (copy_extension_constructor x0)\n | From.Parsetree.Psig_module x0 ->\n To.Parsetree.Psig_module (copy_module_declaration x0)\n | From.Parsetree.Psig_recmodule x0 ->\n To.Parsetree.Psig_recmodule (List.map copy_module_declaration x0)\n | From.Parsetree.Psig_modtype x0 ->\n To.Parsetree.Psig_modtype (copy_module_type_declaration x0)\n | From.Parsetree.Psig_open x0 ->\n To.Parsetree.Psig_open (copy_open_description x0)\n | From.Parsetree.Psig_include x0 ->\n To.Parsetree.Psig_include (copy_include_description x0)\n | From.Parsetree.Psig_class x0 ->\n To.Parsetree.Psig_class (List.map copy_class_description x0)\n | From.Parsetree.Psig_class_type x0 ->\n To.Parsetree.Psig_class_type (List.map copy_class_type_declaration x0)\n | From.Parsetree.Psig_attribute x0 ->\n To.Parsetree.Psig_attribute (copy_attribute x0)\n | From.Parsetree.Psig_extension (x0, x1) ->\n To.Parsetree.Psig_extension (copy_extension x0, copy_attributes x1)\n\nand copy_class_type_declaration :\n From.Parsetree.class_type_declaration -> To.Parsetree.class_type_declaration\n =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_description :\n From.Parsetree.class_description -> To.Parsetree.class_description =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_type : From.Parsetree.class_type -> To.Parsetree.class_type =\n fun {\n From.Parsetree.pcty_desc;\n From.Parsetree.pcty_loc;\n From.Parsetree.pcty_attributes;\n } ->\n {\n To.Parsetree.pcty_desc = copy_class_type_desc pcty_desc;\n To.Parsetree.pcty_loc = copy_location pcty_loc;\n To.Parsetree.pcty_attributes = copy_attributes pcty_attributes;\n }\n\nand copy_class_type_desc :\n From.Parsetree.class_type_desc -> To.Parsetree.class_type_desc = function\n | From.Parsetree.Pcty_constr (x0, x1) ->\n To.Parsetree.Pcty_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Pcty_signature x0 ->\n To.Parsetree.Pcty_signature (copy_class_signature x0)\n | From.Parsetree.Pcty_arrow (x0, x1, x2) ->\n let label = copy_arg_label x0 in\n To.Parsetree.Pcty_arrow\n ( label,\n copy_core_type (extract_predef_option label x1),\n copy_class_type x2 )\n | From.Parsetree.Pcty_extension x0 ->\n To.Parsetree.Pcty_extension (copy_extension x0)\n\nand copy_class_signature :\n From.Parsetree.class_signature -> To.Parsetree.class_signature =\n fun { From.Parsetree.pcsig_self; From.Parsetree.pcsig_fields } ->\n {\n To.Parsetree.pcsig_self = copy_core_type pcsig_self;\n To.Parsetree.pcsig_fields = List.map copy_class_type_field pcsig_fields;\n }\n\nand copy_class_type_field :\n From.Parsetree.class_type_field -> To.Parsetree.class_type_field =\n fun {\n From.Parsetree.pctf_desc;\n From.Parsetree.pctf_loc;\n From.Parsetree.pctf_attributes;\n } ->\n {\n To.Parsetree.pctf_desc = copy_class_type_field_desc pctf_desc;\n To.Parsetree.pctf_loc = copy_location pctf_loc;\n To.Parsetree.pctf_attributes = copy_attributes pctf_attributes;\n }\n\nand copy_class_type_field_desc :\n From.Parsetree.class_type_field_desc -> To.Parsetree.class_type_field_desc =\n function\n | From.Parsetree.Pctf_inherit x0 ->\n To.Parsetree.Pctf_inherit (copy_class_type x0)\n | From.Parsetree.Pctf_val x0 ->\n To.Parsetree.Pctf_val\n (let x0, x1, x2, x3 = x0 in\n (x0, copy_mutable_flag x1, copy_virtual_flag x2, copy_core_type x3))\n | From.Parsetree.Pctf_method x0 ->\n To.Parsetree.Pctf_method\n (let x0, x1, x2, x3 = x0 in\n (x0, copy_private_flag x1, copy_virtual_flag x2, copy_core_type x3))\n | From.Parsetree.Pctf_constraint x0 ->\n To.Parsetree.Pctf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | From.Parsetree.Pctf_attribute x0 ->\n To.Parsetree.Pctf_attribute (copy_attribute x0)\n | From.Parsetree.Pctf_extension x0 ->\n To.Parsetree.Pctf_extension (copy_extension x0)\n\nand copy_extension : From.Parsetree.extension -> To.Parsetree.extension =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_class_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 From.Parsetree.class_infos ->\n 'g0 To.Parsetree.class_infos =\n fun f0\n {\n From.Parsetree.pci_virt;\n From.Parsetree.pci_params;\n From.Parsetree.pci_name;\n From.Parsetree.pci_expr;\n From.Parsetree.pci_loc;\n From.Parsetree.pci_attributes;\n } ->\n {\n To.Parsetree.pci_virt = copy_virtual_flag pci_virt;\n To.Parsetree.pci_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n pci_params;\n To.Parsetree.pci_name = copy_loc (fun x -> x) pci_name;\n To.Parsetree.pci_expr = f0 pci_expr;\n To.Parsetree.pci_loc = copy_location pci_loc;\n To.Parsetree.pci_attributes = copy_attributes pci_attributes;\n }\n\nand copy_virtual_flag : From.Asttypes.virtual_flag -> To.Asttypes.virtual_flag =\n function\n | From.Asttypes.Virtual -> To.Asttypes.Virtual\n | From.Asttypes.Concrete -> To.Asttypes.Concrete\n\nand copy_include_description :\n From.Parsetree.include_description -> To.Parsetree.include_description =\n fun x -> copy_include_infos copy_module_type x\n\nand copy_include_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 From.Parsetree.include_infos ->\n 'g0 To.Parsetree.include_infos =\n fun f0\n {\n From.Parsetree.pincl_mod;\n From.Parsetree.pincl_loc;\n From.Parsetree.pincl_attributes;\n } ->\n {\n To.Parsetree.pincl_mod = f0 pincl_mod;\n To.Parsetree.pincl_loc = copy_location pincl_loc;\n To.Parsetree.pincl_attributes = copy_attributes pincl_attributes;\n }\n\nand copy_open_description :\n From.Parsetree.open_description -> To.Parsetree.open_description =\n fun {\n From.Parsetree.popen_lid;\n From.Parsetree.popen_override;\n From.Parsetree.popen_loc;\n From.Parsetree.popen_attributes;\n } ->\n {\n To.Parsetree.popen_lid = copy_loc copy_longident popen_lid;\n To.Parsetree.popen_override = copy_override_flag popen_override;\n To.Parsetree.popen_loc = copy_location popen_loc;\n To.Parsetree.popen_attributes = copy_attributes popen_attributes;\n }\n\nand copy_override_flag :\n From.Asttypes.override_flag -> To.Asttypes.override_flag = function\n | From.Asttypes.Override -> To.Asttypes.Override\n | From.Asttypes.Fresh -> To.Asttypes.Fresh\n\nand copy_module_type_declaration :\n From.Parsetree.module_type_declaration ->\n To.Parsetree.module_type_declaration =\n fun {\n From.Parsetree.pmtd_name;\n From.Parsetree.pmtd_type;\n From.Parsetree.pmtd_attributes;\n From.Parsetree.pmtd_loc;\n } ->\n {\n To.Parsetree.pmtd_name = copy_loc (fun x -> x) pmtd_name;\n To.Parsetree.pmtd_type = copy_option copy_module_type pmtd_type;\n To.Parsetree.pmtd_attributes = copy_attributes pmtd_attributes;\n To.Parsetree.pmtd_loc = copy_location pmtd_loc;\n }\n\nand copy_module_declaration :\n From.Parsetree.module_declaration -> To.Parsetree.module_declaration =\n fun {\n From.Parsetree.pmd_name;\n From.Parsetree.pmd_type;\n From.Parsetree.pmd_attributes;\n From.Parsetree.pmd_loc;\n } ->\n {\n To.Parsetree.pmd_name = copy_loc (fun x -> x) pmd_name;\n To.Parsetree.pmd_type = copy_module_type pmd_type;\n To.Parsetree.pmd_attributes = copy_attributes pmd_attributes;\n To.Parsetree.pmd_loc = copy_location pmd_loc;\n }\n\nand copy_type_extension :\n From.Parsetree.type_extension -> To.Parsetree.type_extension =\n fun {\n From.Parsetree.ptyext_path;\n From.Parsetree.ptyext_params;\n From.Parsetree.ptyext_constructors;\n From.Parsetree.ptyext_private;\n From.Parsetree.ptyext_attributes;\n } ->\n {\n To.Parsetree.ptyext_path = copy_loc copy_longident ptyext_path;\n To.Parsetree.ptyext_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptyext_params;\n To.Parsetree.ptyext_constructors =\n List.map copy_extension_constructor ptyext_constructors;\n To.Parsetree.ptyext_private = copy_private_flag ptyext_private;\n To.Parsetree.ptyext_attributes = copy_attributes ptyext_attributes;\n }\n\nand copy_extension_constructor :\n From.Parsetree.extension_constructor -> To.Parsetree.extension_constructor =\n fun {\n From.Parsetree.pext_name;\n From.Parsetree.pext_kind;\n From.Parsetree.pext_loc;\n From.Parsetree.pext_attributes;\n } ->\n {\n To.Parsetree.pext_name = copy_loc (fun x -> x) pext_name;\n To.Parsetree.pext_kind = copy_extension_constructor_kind pext_kind;\n To.Parsetree.pext_loc = copy_location pext_loc;\n To.Parsetree.pext_attributes = copy_attributes pext_attributes;\n }\n\nand copy_extension_constructor_kind :\n From.Parsetree.extension_constructor_kind ->\n To.Parsetree.extension_constructor_kind = function\n | From.Parsetree.Pext_decl (x0, x1) ->\n To.Parsetree.Pext_decl\n ( To.Parsetree.Pcstr_tuple (List.map copy_core_type x0),\n copy_option copy_core_type x1 )\n | From.Parsetree.Pext_rebind x0 ->\n To.Parsetree.Pext_rebind (copy_loc copy_longident x0)\n\nand copy_type_declaration :\n From.Parsetree.type_declaration -> To.Parsetree.type_declaration =\n fun {\n From.Parsetree.ptype_name;\n From.Parsetree.ptype_params;\n From.Parsetree.ptype_cstrs;\n From.Parsetree.ptype_kind;\n From.Parsetree.ptype_private;\n From.Parsetree.ptype_manifest;\n From.Parsetree.ptype_attributes;\n From.Parsetree.ptype_loc;\n } ->\n {\n To.Parsetree.ptype_name = copy_loc (fun x -> x) ptype_name;\n To.Parsetree.ptype_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptype_params;\n To.Parsetree.ptype_cstrs =\n List.map\n (fun x ->\n let x0, x1, x2 = x in\n (copy_core_type x0, copy_core_type x1, copy_location x2))\n ptype_cstrs;\n To.Parsetree.ptype_kind = copy_type_kind ptype_kind;\n To.Parsetree.ptype_private = copy_private_flag ptype_private;\n To.Parsetree.ptype_manifest = copy_option copy_core_type ptype_manifest;\n To.Parsetree.ptype_attributes = copy_attributes ptype_attributes;\n To.Parsetree.ptype_loc = copy_location ptype_loc;\n }\n\nand copy_private_flag : From.Asttypes.private_flag -> To.Asttypes.private_flag =\n function\n | From.Asttypes.Private -> To.Asttypes.Private\n | From.Asttypes.Public -> To.Asttypes.Public\n\nand copy_type_kind : From.Parsetree.type_kind -> To.Parsetree.type_kind =\n function\n | From.Parsetree.Ptype_abstract -> To.Parsetree.Ptype_abstract\n | From.Parsetree.Ptype_variant x0 ->\n To.Parsetree.Ptype_variant (List.map copy_constructor_declaration x0)\n | From.Parsetree.Ptype_record x0 ->\n To.Parsetree.Ptype_record (List.map copy_label_declaration x0)\n | From.Parsetree.Ptype_open -> To.Parsetree.Ptype_open\n\nand copy_label_declaration :\n From.Parsetree.label_declaration -> To.Parsetree.label_declaration =\n fun {\n From.Parsetree.pld_name;\n From.Parsetree.pld_mutable;\n From.Parsetree.pld_type;\n From.Parsetree.pld_loc;\n From.Parsetree.pld_attributes;\n } ->\n {\n To.Parsetree.pld_name = copy_loc (fun x -> x) pld_name;\n To.Parsetree.pld_mutable = copy_mutable_flag pld_mutable;\n To.Parsetree.pld_type = copy_core_type pld_type;\n To.Parsetree.pld_loc = copy_location pld_loc;\n To.Parsetree.pld_attributes = copy_attributes pld_attributes;\n }\n\nand copy_mutable_flag : From.Asttypes.mutable_flag -> To.Asttypes.mutable_flag =\n function\n | From.Asttypes.Immutable -> To.Asttypes.Immutable\n | From.Asttypes.Mutable -> To.Asttypes.Mutable\n\nand copy_constructor_declaration :\n From.Parsetree.constructor_declaration ->\n To.Parsetree.constructor_declaration =\n fun {\n From.Parsetree.pcd_name;\n From.Parsetree.pcd_args;\n From.Parsetree.pcd_res;\n From.Parsetree.pcd_loc;\n From.Parsetree.pcd_attributes;\n } ->\n {\n To.Parsetree.pcd_name = copy_loc (fun x -> x) pcd_name;\n To.Parsetree.pcd_args =\n To.Parsetree.Pcstr_tuple (List.map copy_core_type pcd_args);\n To.Parsetree.pcd_res = copy_option copy_core_type pcd_res;\n To.Parsetree.pcd_loc = copy_location pcd_loc;\n To.Parsetree.pcd_attributes = copy_attributes pcd_attributes;\n }\n\nand copy_variance : From.Asttypes.variance -> To.Asttypes.variance = function\n | From.Asttypes.Covariant -> To.Asttypes.Covariant\n | From.Asttypes.Contravariant -> To.Asttypes.Contravariant\n | From.Asttypes.Invariant -> To.Asttypes.Invariant\n\nand copy_value_description :\n From.Parsetree.value_description -> To.Parsetree.value_description =\n fun {\n From.Parsetree.pval_name;\n From.Parsetree.pval_type;\n From.Parsetree.pval_prim;\n From.Parsetree.pval_attributes;\n From.Parsetree.pval_loc;\n } ->\n {\n To.Parsetree.pval_name = copy_loc (fun x -> x) pval_name;\n To.Parsetree.pval_type = copy_core_type pval_type;\n To.Parsetree.pval_prim = List.map (fun x -> x) pval_prim;\n To.Parsetree.pval_attributes = copy_attributes pval_attributes;\n To.Parsetree.pval_loc = copy_location pval_loc;\n }\n\nand copy_closed_flag : From.Asttypes.closed_flag -> To.Asttypes.closed_flag =\n function\n | From.Asttypes.Closed -> To.Asttypes.Closed\n | From.Asttypes.Open -> To.Asttypes.Open\n\nand copy_label : From.Asttypes.label -> To.Asttypes.label = fun x -> x\n\nand copy_arg_label : From.Asttypes.label -> To.Asttypes.arg_label =\n fun x ->\n if x <> \"\" then\n if x.[0] = '?' then\n To.Asttypes.Optional (String.sub x 1 (String.length x - 1))\n else To.Asttypes.Labelled x\n else To.Asttypes.Nolabel\n\nand copy_rec_flag : From.Asttypes.rec_flag -> To.Asttypes.rec_flag = function\n | From.Asttypes.Nonrecursive -> To.Asttypes.Nonrecursive\n | From.Asttypes.Recursive -> To.Asttypes.Recursive\n\nand copy_constant : From.Asttypes.constant -> To.Parsetree.constant = function\n | From.Asttypes.Const_int x0 ->\n To.Parsetree.Pconst_integer (string_of_int x0, None)\n | From.Asttypes.Const_char x0 -> To.Parsetree.Pconst_char x0\n | From.Asttypes.Const_string (x0, x1) ->\n To.Parsetree.Pconst_string (x0, copy_option (fun x -> x) x1)\n | From.Asttypes.Const_float x0 -> To.Parsetree.Pconst_float (x0, None)\n | From.Asttypes.Const_int32 x0 ->\n To.Parsetree.Pconst_integer (Int32.to_string x0, Some 'l')\n | From.Asttypes.Const_int64 x0 ->\n To.Parsetree.Pconst_integer (Int64.to_string x0, Some 'L')\n | From.Asttypes.Const_nativeint x0 ->\n To.Parsetree.Pconst_integer (Nativeint.to_string x0, Some 'n')\n\nand copy_option : 'f0 'g0. ('f0 -> 'g0) -> 'f0 option -> 'g0 option =\n fun f0 -> function None -> None | Some x0 -> Some (f0 x0)\n\nand copy_longident : Longident.t -> Longident.t = fun x -> x\n\nand copy_loc :\n 'f0 'g0. ('f0 -> 'g0) -> 'f0 From.Asttypes.loc -> 'g0 To.Asttypes.loc =\n fun f0 { From.Asttypes.txt; From.Asttypes.loc } ->\n { To.Asttypes.txt = f0 txt; To.Asttypes.loc = copy_location loc }\n\nand copy_location : Location.t -> Location.t = fun x -> x\nand copy_bool : bool -> bool = function false -> false | true -> true\n\nand type_declarations types =\n let is_nonrec (attr, _) = attr.Location.txt = \"nonrec\" in\n match List.map copy_type_declaration types with\n | x :: xs when List.exists is_nonrec x.To.Parsetree.ptype_attributes ->\n let ptype_attributes =\n List.filter (fun x -> not (is_nonrec x)) x.To.Parsetree.ptype_attributes\n in\n (To.Asttypes.Nonrecursive, { x with To.Parsetree.ptype_attributes } :: xs)\n | types -> (To.Asttypes.Recursive, types)\n\nlet rec copy_toplevel_phrase :\n From.Parsetree.toplevel_phrase -> To.Parsetree.toplevel_phrase = function\n | From.Parsetree.Ptop_def x0 -> To.Parsetree.Ptop_def (copy_structure x0)\n | From.Parsetree.Ptop_dir (x0, x1) ->\n To.Parsetree.Ptop_dir (x0, copy_directive_argument x1)\n\nand copy_directive_argument :\n From.Parsetree.directive_argument -> To.Parsetree.directive_argument =\n function\n | From.Parsetree.Pdir_none -> To.Parsetree.Pdir_none\n | From.Parsetree.Pdir_string x0 -> To.Parsetree.Pdir_string x0\n | From.Parsetree.Pdir_int x0 -> To.Parsetree.Pdir_int (string_of_int x0, None)\n | From.Parsetree.Pdir_ident x0 -> To.Parsetree.Pdir_ident (copy_longident x0)\n | From.Parsetree.Pdir_bool x0 -> To.Parsetree.Pdir_bool (copy_bool x0)\n\nlet copy_cases x = List.map copy_case x\nlet copy_pat = copy_pattern\nlet copy_expr = copy_expression\nlet copy_typ = copy_core_type\n","(* This file is used to control what we use from the current compiler and what is embed in\n this library.\n\n It must be opened in all modules, especially the ones coming from the compiler.\n*)\n\nmodule Js = Versions.OCaml_412\nmodule Ocaml = Versions.OCaml_current\n\nmodule Select_ast (Ocaml : Versions.OCaml_version) = struct\n include Js\n\n module Type = struct\n type ('js, 'ocaml) t =\n | Signature\n : (Js.Ast.Parsetree.signature, Ocaml.Ast.Parsetree.signature) t\n | Structure\n : (Js.Ast.Parsetree.structure, Ocaml.Ast.Parsetree.structure) t\n | Toplevel_phrase\n : ( Js.Ast.Parsetree.toplevel_phrase,\n Ocaml.Ast.Parsetree.toplevel_phrase )\n t\n | Expression\n : (Js.Ast.Parsetree.expression, Ocaml.Ast.Parsetree.expression) t\n | Core_type\n : (Js.Ast.Parsetree.core_type, Ocaml.Ast.Parsetree.core_type) t\n | Type_declaration\n : ( Js.Ast.Parsetree.type_declaration,\n Ocaml.Ast.Parsetree.type_declaration )\n t\n | Type_extension\n : ( Js.Ast.Parsetree.type_extension,\n Ocaml.Ast.Parsetree.type_extension )\n t\n | Extension_constructor\n : ( Js.Ast.Parsetree.extension_constructor,\n Ocaml.Ast.Parsetree.extension_constructor )\n t\n | List : ('a, 'b) t -> ('a list, 'b list) t\n | Pair : ('a, 'b) t * ('c, 'd) t -> ('a * 'c, 'b * 'd) t\n end\n\n open Type\n module Of_ocaml = Versions.Convert (Ocaml) (Js)\n module To_ocaml = Versions.Convert (Js) (Ocaml)\n\n let rec of_ocaml : type ocaml js. (js, ocaml) Type.t -> ocaml -> js =\n let open Of_ocaml in\n fun node ->\n match node with\n | Signature -> copy_signature\n | Structure -> copy_structure\n | Toplevel_phrase -> copy_toplevel_phrase\n | Expression -> copy_expression\n | Core_type -> copy_core_type\n | Type_declaration -> copy_type_declaration\n | Type_extension -> copy_type_extension\n | Extension_constructor -> copy_extension_constructor\n | List t -> List.map (of_ocaml t)\n | Pair (a, b) ->\n let f = of_ocaml a in\n let g = of_ocaml b in\n fun (x, y) -> (f x, g y)\n\n let rec to_ocaml : type ocaml js. (js, ocaml) Type.t -> js -> ocaml =\n let open To_ocaml in\n fun node ->\n match node with\n | Signature -> copy_signature\n | Structure -> copy_structure\n | Toplevel_phrase -> copy_toplevel_phrase\n | Expression -> copy_expression\n | Core_type -> copy_core_type\n | Type_declaration -> copy_type_declaration\n | Type_extension -> copy_type_extension\n | Extension_constructor -> copy_extension_constructor\n | List t -> List.map (to_ocaml t)\n | Pair (a, b) ->\n let f = to_ocaml a in\n let g = to_ocaml b in\n fun (x, y) -> (f x, g y)\n\n let of_ocaml_mapper item f ctxt x = to_ocaml item x |> f ctxt |> of_ocaml item\n let to_ocaml_mapper item f ctxt x = of_ocaml item x |> f ctxt |> to_ocaml item\nend\n\nmodule Selected_ast = Select_ast (Ocaml)\nmodule Ast_helper = Ast_helper_lite\n\n(* Modules from Ast_ of Astlib, where is the compiler version the ppxlib driver is compiled with *)\nmodule Parsetree = Selected_ast.Ast.Parsetree\nmodule Asttypes = Selected_ast.Ast.Asttypes\n\n(* Other Astlib modules *)\nmodule Location = Astlib.Location\nmodule Longident = Astlib.Longident\n\nmodule Parse = struct\n include Astlib.Parse\n module Of_ocaml = Versions.Convert (Ocaml) (Js)\n\n let implementation lexbuf = implementation lexbuf |> Of_ocaml.copy_structure\n let interface lexbuf = interface lexbuf |> Of_ocaml.copy_signature\n\n let toplevel_phrase lexbuf =\n toplevel_phrase lexbuf |> Of_ocaml.copy_toplevel_phrase\n\n let use_file lexbuf =\n use_file lexbuf |> List.map Of_ocaml.copy_toplevel_phrase\n\n let core_type lexbuf = core_type lexbuf |> Of_ocaml.copy_core_type\n let expression lexbuf = expression lexbuf |> Of_ocaml.copy_expression\n let pattern lexbuf = pattern lexbuf |> Of_ocaml.copy_pattern\nend\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(** Definition of the OCaml AST *)\n\nopen Import\n\n(* This file is obtained by:\n\n - copying a subset of the corresponding ast_xxx.ml file from Astlib\n (sub-modules Asttypes and Parsetree)\n - adding the type definitions for position, location, loc and longident\n - flattening all the modules\n - removing Asttypes.constant (unused and conflicts with Parsetree.constant)\n - renaming a few types:\n - - Location.t -> location\n - - Longident.t -> longident\n - adding a type longident_loc = longident loc and replacing all the occurrences of the\n latter by the former. This is so that we can override iteration an the level of a\n longident loc\n - adding a type cases = case list\n - replacing all the (*IF_CURRENT = Foo.bar*) by: = Foo.bar\n - removing the extra values at the end of the file\n - replacing app [type ...] by [and ...] to make everything one recursive block\n - adding [@@deriving_inline traverse][@@@end] at the end\n\n To update it to a newer OCaml version, create a new module with the above from the\n latest compiler and add the following module definitions and opens to get it to\n compile:\n [{\n module Ast = Versions.OCaml_4xx\n open Ast.Ast\n module Location = Ocaml_common.Location\n module Longident = Ocaml_common.Longident\n }]\n\n Once you have generated the inlined derived traversal classes by running\n [{ dune build @lint }] you can replace the above mentioned module definitions by a\n [open Import] and update [Import] so that the [Js] module points to\n [Versions.OCaml_4xx].\n*)\n\n(* Source code locations (ranges of positions), used in parsetree. *)\n\ntype position = Lexing.position = {\n pos_fname : string;\n pos_lnum : int;\n pos_bol : int;\n pos_cnum : int;\n}\n\nand location = Location.t = {\n loc_start : position;\n loc_end : position;\n loc_ghost : bool;\n}\n\nand location_stack = location list\n\n(* Note on the use of Lexing.position in this module.\n If [pos_fname = \"\"], then use [!input_name] instead.\n If [pos_lnum = -1], then [pos_bol = 0]. Use [pos_cnum] and\n re-parse the file to get the line and character numbers.\n Else all fields are correct.\n*)\nand 'a loc = 'a Location.loc = { txt : 'a; loc : location }\n\n(* Long identifiers, used in parsetree. *)\nand longident = Longident.t =\n | Lident of string\n | Ldot of longident * string\n | Lapply of longident * longident\n\nand longident_loc = longident loc\n\n(** Auxiliary AST types used by parsetree and typedtree. *)\n\nand rec_flag = Asttypes.rec_flag = Nonrecursive | Recursive\n\nand direction_flag = Asttypes.direction_flag = Upto | Downto\n\n(* Order matters, used in polymorphic comparison *)\nand private_flag = Asttypes.private_flag = Private | Public\nand mutable_flag = Asttypes.mutable_flag = Immutable | Mutable\nand virtual_flag = Asttypes.virtual_flag = Virtual | Concrete\nand override_flag = Asttypes.override_flag = Override | Fresh\nand closed_flag = Asttypes.closed_flag = Closed | Open\nand label = string\n\nand arg_label = Asttypes.arg_label =\n | Nolabel\n | Labelled of string (* label:T -> ... *)\n | Optional of string\n(* ?label:T -> ... *)\n\nand variance = Asttypes.variance = Covariant | Contravariant | NoVariance\nand injectivity = Asttypes.injectivity = Injective | NoInjectivity\n\n(** Abstract syntax tree produced by parsing *)\n\nand constant = Parsetree.constant =\n | Pconst_integer of string * char option\n (* 3 3l 3L 3n\n\n Suffixes [g-z][G-Z] are accepted by the parser.\n Suffixes except 'l', 'L' and 'n' are rejected by the typechecker\n *)\n | Pconst_char of char\n (* 'c' *)\n | Pconst_string of string * location * string option\n (* \"constant\"\n {delim|other constant|delim}\n\n The location span the content of the string, without the delimiters.\n *)\n | Pconst_float of string * char option\n(* 3.4 2e5 1.4e-4\n\n Suffixes [g-z][G-Z] are accepted by the parser.\n Suffixes are rejected by the typechecker.\n*)\n\n(** {1 Extension points} *)\n\nand attribute = Parsetree.attribute = {\n attr_name : string loc;\n attr_payload : payload;\n attr_loc : location;\n}\n(* [@id ARG]\n [@@id ARG]\n\n Metadata containers passed around within the AST.\n The compiler ignores unknown attributes.\n*)\n\nand extension = string loc * payload\n(* [%id ARG]\n [%%id ARG]\n\n Sub-language placeholder -- rejected by the typechecker.\n*)\n\nand attributes = attribute list\n\nand payload = Parsetree.payload =\n | PStr of structure\n | PSig of signature (* : SIG *)\n | PTyp of core_type (* : T *)\n | PPat of pattern * expression option\n(* ? P or ? P when E *)\n\n(* Type expressions *)\n\n(** {1 Core language} *)\n\nand core_type = Parsetree.core_type = {\n ptyp_desc : core_type_desc;\n ptyp_loc : location;\n ptyp_loc_stack : location_stack;\n ptyp_attributes : attributes; (* ... [@id1] [@id2] *)\n}\n\nand core_type_desc = Parsetree.core_type_desc =\n | Ptyp_any\n (* _ *)\n | Ptyp_var of string\n (* 'a *)\n | Ptyp_arrow of arg_label * core_type * core_type\n (* T1 -> T2 Simple\n ~l:T1 -> T2 Labelled\n ?l:T1 -> T2 Optional\n *)\n | Ptyp_tuple of core_type list\n (* T1 * ... * Tn\n\n Invariant: n >= 2\n *)\n | Ptyp_constr of longident_loc * core_type list\n (* tconstr\n T tconstr\n (T1, ..., Tn) tconstr\n *)\n | Ptyp_object of object_field list * closed_flag\n (* < l1:T1; ...; ln:Tn > (flag = Closed)\n < l1:T1; ...; ln:Tn; .. > (flag = Open)\n *)\n | Ptyp_class of longident_loc * core_type list\n (* #tconstr\n T #tconstr\n (T1, ..., Tn) #tconstr\n *)\n | Ptyp_alias of core_type * string\n (* T as 'a *)\n | Ptyp_variant of row_field list * closed_flag * label list option\n (* [ `A|`B ] (flag = Closed; labels = None)\n [> `A|`B ] (flag = Open; labels = None)\n [< `A|`B ] (flag = Closed; labels = Some [])\n [< `A|`B > `X `Y ](flag = Closed; labels = Some [\"X\";\"Y\"])\n *)\n | Ptyp_poly of string loc list * core_type (* 'a1 ... 'an. T\n\n Can only appear in the following context:\n\n - As the core_type of a Ppat_constraint node corresponding\n to a constraint on a let-binding: let x : 'a1 ... 'an. T\n = e ...\n\n - Under Cfk_virtual for methods (not values).\n\n - As the core_type of a Pctf_method node.\n\n - As the core_type of a Pexp_poly node.\n\n - As the pld_type field of a label_declaration.\n\n - As a core_type of a Ptyp_object node.\n *)\n | Ptyp_package of package_type\n (* (module S) *)\n | Ptyp_extension of extension\n(* [%id] *)\n\nand package_type = longident_loc * (longident_loc * core_type) list\n(*\n (module S)\n (module S with type t1 = T1 and ... and tn = Tn)\n*)\n\nand row_field = Parsetree.row_field = {\n prf_desc : row_field_desc;\n prf_loc : location;\n prf_attributes : attributes;\n}\n\nand row_field_desc = Parsetree.row_field_desc =\n | Rtag of label loc * bool * core_type list\n (* [`A] ( true, [] )\n [`A of T] ( false, [T] )\n [`A of T1 & .. & Tn] ( false, [T1;...Tn] )\n [`A of & T1 & .. & Tn] ( true, [T1;...Tn] )\n\n - The 2nd field is true if the tag contains a\n constant (empty) constructor.\n - '&' occurs when several types are used for the same constructor\n (see 4.2 in the manual)\n\n - TODO: switch to a record representation, and keep location\n *)\n | Rinherit of core_type\n(* [ | t ] *)\n\nand object_field = Parsetree.object_field = {\n pof_desc : object_field_desc;\n pof_loc : location;\n pof_attributes : attributes;\n}\n\nand object_field_desc = Parsetree.object_field_desc =\n | Otag of label loc * core_type\n | Oinherit of core_type\n\n(* Patterns *)\nand pattern = Parsetree.pattern = {\n ppat_desc : pattern_desc;\n ppat_loc : location;\n ppat_loc_stack : location_stack;\n ppat_attributes : attributes; (* ... [@id1] [@id2] *)\n}\n\nand pattern_desc = Parsetree.pattern_desc =\n | Ppat_any\n (* _ *)\n | Ppat_var of string loc\n (* x *)\n | Ppat_alias of pattern * string loc\n (* P as 'a *)\n | Ppat_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Ppat_interval of constant * constant\n (* 'a'..'z'\n\n Other forms of interval are recognized by the parser\n but rejected by the type-checker. *)\n | Ppat_tuple of pattern list\n (* (P1, ..., Pn)\n\n Invariant: n >= 2\n *)\n | Ppat_construct of longident_loc * pattern option\n (* C None\n C P Some P\n C (P1, ..., Pn) Some (Ppat_tuple [P1; ...; Pn])\n *)\n | Ppat_variant of label * pattern option\n (* `A (None)\n `A P (Some P)\n *)\n | Ppat_record of (longident_loc * pattern) list * closed_flag\n (* { l1=P1; ...; ln=Pn } (flag = Closed)\n { l1=P1; ...; ln=Pn; _} (flag = Open)\n\n Invariant: n > 0\n *)\n | Ppat_array of pattern list\n (* [| P1; ...; Pn |] *)\n | Ppat_or of pattern * pattern\n (* P1 | P2 *)\n | Ppat_constraint of pattern * core_type\n (* (P : T) *)\n | Ppat_type of longident_loc\n (* #tconst *)\n | Ppat_lazy of pattern\n (* lazy P *)\n | Ppat_unpack of string option loc\n (* (module P)\n Note: (module P : S) is represented as\n Ppat_constraint(Ppat_unpack, Ptyp_package)\n *)\n | Ppat_exception of pattern\n (* exception P *)\n | Ppat_extension of extension\n (* [%id] *)\n | Ppat_open of longident_loc * pattern\n(* M.(P) *)\n\n(* Value expressions *)\nand expression = Parsetree.expression = {\n pexp_desc : expression_desc;\n pexp_loc : location;\n pexp_loc_stack : location_stack;\n pexp_attributes : attributes; (* ... [@id1] [@id2] *)\n}\n\nand expression_desc = Parsetree.expression_desc =\n | Pexp_ident of longident_loc\n (* x\n M.x\n *)\n | Pexp_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Pexp_let of rec_flag * value_binding list * expression\n (* let P1 = E1 and ... and Pn = EN in E (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in E (flag = Recursive)\n *)\n | Pexp_function of cases\n (* function P1 -> E1 | ... | Pn -> En *)\n | Pexp_fun of arg_label * expression option * pattern * expression\n (* fun P -> E1 (Simple, None)\n fun ~l:P -> E1 (Labelled l, None)\n fun ?l:P -> E1 (Optional l, None)\n fun ?l:(P = E0) -> E1 (Optional l, Some E0)\n\n Notes:\n - If E0 is provided, only Optional is allowed.\n - \"fun P1 P2 .. Pn -> E1\" is represented as nested Pexp_fun.\n - \"let f P = E\" is represented using Pexp_fun.\n *)\n | Pexp_apply of expression * (arg_label * expression) list\n (* E0 ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pexp_match of expression * cases\n (* match E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_try of expression * cases\n (* try E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_tuple of expression list\n (* (E1, ..., En)\n\n Invariant: n >= 2\n *)\n | Pexp_construct of longident_loc * expression option\n (* C None\n C E Some E\n C (E1, ..., En) Some (Pexp_tuple[E1;...;En])\n *)\n | Pexp_variant of label * expression option\n (* `A (None)\n `A E (Some E)\n *)\n | Pexp_record of (longident_loc * expression) list * expression option\n (* { l1=P1; ...; ln=Pn } (None)\n { E0 with l1=P1; ...; ln=Pn } (Some E0)\n\n Invariant: n > 0\n *)\n | Pexp_field of expression * longident_loc\n (* E.l *)\n | Pexp_setfield of expression * longident_loc * expression\n (* E1.l <- E2 *)\n | Pexp_array of expression list\n (* [| E1; ...; En |] *)\n | Pexp_ifthenelse of expression * expression * expression option\n (* if E1 then E2 else E3 *)\n | Pexp_sequence of expression * expression\n (* E1; E2 *)\n | Pexp_while of expression * expression\n (* while E1 do E2 done *)\n | Pexp_for of pattern * expression * expression * direction_flag * expression\n (* for i = E1 to E2 do E3 done (flag = Upto)\n for i = E1 downto E2 do E3 done (flag = Downto)\n *)\n | Pexp_constraint of expression * core_type\n (* (E : T) *)\n | Pexp_coerce of expression * core_type option * core_type\n (* (E :> T) (None, T)\n (E : T0 :> T) (Some T0, T)\n *)\n | Pexp_send of expression * label loc\n (* E # m *)\n | Pexp_new of longident_loc\n (* new M.c *)\n | Pexp_setinstvar of label loc * expression\n (* x <- 2 *)\n | Pexp_override of (label loc * expression) list\n (* {< x1 = E1; ...; Xn = En >} *)\n | Pexp_letmodule of string option loc * module_expr * expression\n (* let module M = ME in E *)\n | Pexp_letexception of extension_constructor * expression\n (* let exception C in E *)\n | Pexp_assert of expression\n (* assert E\n Note: \"assert false\" is treated in a special way by the\n type-checker. *)\n | Pexp_lazy of expression\n (* lazy E *)\n | Pexp_poly of expression * core_type option\n (* Used for method bodies.\n\n Can only be used as the expression under Cfk_concrete\n for methods (not values). *)\n | Pexp_object of class_structure\n (* object ... end *)\n | Pexp_newtype of string loc * expression\n (* fun (type t) -> E *)\n | Pexp_pack of module_expr\n (* (module ME)\n\n (module ME : S) is represented as\n Pexp_constraint(Pexp_pack, Ptyp_package S) *)\n | Pexp_open of open_declaration * expression\n (* M.(E)\n let open M in E\n let! open M in E *)\n | Pexp_letop of letop\n (* let* P = E in E\n let* P = E and* P = E in E *)\n | Pexp_extension of extension\n (* [%id] *)\n | Pexp_unreachable\n(* . *)\n\nand case = Parsetree.case = {\n (* (P -> E) or (P when E0 -> E) *)\n pc_lhs : pattern;\n pc_guard : expression option;\n pc_rhs : expression;\n}\n\nand letop = Parsetree.letop = {\n let_ : binding_op;\n ands : binding_op list;\n body : expression;\n}\n\nand binding_op = Parsetree.binding_op = {\n pbop_op : string loc;\n pbop_pat : pattern;\n pbop_exp : expression;\n pbop_loc : location;\n}\n\n(* Value descriptions *)\nand value_description = Parsetree.value_description = {\n pval_name : string loc;\n pval_type : core_type;\n pval_prim : string list;\n pval_attributes : attributes;\n (* ... [@@id1] [@@id2] *)\n pval_loc : location;\n}\n\n(*\n val x: T (prim = [])\n external x: T = \"s1\" ... \"sn\" (prim = [\"s1\";...\"sn\"])\n*)\n\n(* Type declarations *)\nand type_declaration = Parsetree.type_declaration = {\n ptype_name : string loc;\n ptype_params : (core_type * (variance * injectivity)) list;\n (* ('a1,...'an) t; None represents _*)\n ptype_cstrs : (core_type * core_type * location) list;\n (* ... constraint T1=T1' ... constraint Tn=Tn' *)\n ptype_kind : type_kind;\n ptype_private : private_flag;\n (* = private ... *)\n ptype_manifest : core_type option;\n (* = T *)\n ptype_attributes : attributes;\n (* ... [@@id1] [@@id2] *)\n ptype_loc : location;\n}\n\n(*\n type t (abstract, no manifest)\n type t = T0 (abstract, manifest=T0)\n type t = C of T | ... (variant, no manifest)\n type t = T0 = C of T | ... (variant, manifest=T0)\n type t = {l: T; ...} (record, no manifest)\n type t = T0 = {l : T; ...} (record, manifest=T0)\n type t = .. (open, no manifest)\n*)\nand type_kind = Parsetree.type_kind =\n | Ptype_abstract\n | Ptype_variant of constructor_declaration list\n | Ptype_record of label_declaration list\n (* Invariant: non-empty list *)\n | Ptype_open\n\nand label_declaration = Parsetree.label_declaration = {\n pld_name : string loc;\n pld_mutable : mutable_flag;\n pld_type : core_type;\n pld_loc : location;\n pld_attributes : attributes; (* l : T [@id1] [@id2] *)\n}\n\n(* { ...; l: T; ... } (mutable=Immutable)\n { ...; mutable l: T; ... } (mutable=Mutable)\n\n Note: T can be a Ptyp_poly.\n*)\nand constructor_declaration = Parsetree.constructor_declaration = {\n pcd_name : string loc;\n pcd_args : constructor_arguments;\n pcd_res : core_type option;\n pcd_loc : location;\n pcd_attributes : attributes; (* C of ... [@id1] [@id2] *)\n}\n\nand constructor_arguments = Parsetree.constructor_arguments =\n | Pcstr_tuple of core_type list\n | Pcstr_record of label_declaration list\n\n(*\n | C of T1 * ... * Tn (res = None, args = Pcstr_tuple [])\n | C: T0 (res = Some T0, args = [])\n | C: T1 * ... * Tn -> T0 (res = Some T0, args = Pcstr_tuple)\n | C of {...} (res = None, args = Pcstr_record)\n | C: {...} -> T0 (res = Some T0, args = Pcstr_record)\n | C of {...} as t (res = None, args = Pcstr_record)\n*)\nand type_extension = Parsetree.type_extension = {\n ptyext_path : longident_loc;\n ptyext_params : (core_type * (variance * injectivity)) list;\n ptyext_constructors : extension_constructor list;\n ptyext_private : private_flag;\n ptyext_loc : location;\n ptyext_attributes : attributes; (* ... [@@id1] [@@id2] *)\n}\n(*\n type t += ...\n*)\n\nand extension_constructor = Parsetree.extension_constructor = {\n pext_name : string loc;\n pext_kind : extension_constructor_kind;\n pext_loc : location;\n pext_attributes : attributes; (* C of ... [@id1] [@id2] *)\n}\n\nand type_exception = Parsetree.type_exception = {\n ptyexn_constructor : extension_constructor;\n ptyexn_loc : location;\n ptyexn_attributes : attributes;\n}\n\nand extension_constructor_kind = Parsetree.extension_constructor_kind =\n | Pext_decl of constructor_arguments * core_type option\n (*\n | C of T1 * ... * Tn ([T1; ...; Tn], None)\n | C: T0 ([], Some T0)\n | C: T1 * ... * Tn -> T0 ([T1; ...; Tn], Some T0)\n *)\n | Pext_rebind of longident_loc\n(*\n | C = D\n *)\n\n(* Type expressions for the class language *)\n\n(** {1 Class language} *)\n\nand class_type = Parsetree.class_type = {\n pcty_desc : class_type_desc;\n pcty_loc : location;\n pcty_attributes : attributes; (* ... [@id1] [@id2] *)\n}\n\nand class_type_desc = Parsetree.class_type_desc =\n | Pcty_constr of longident_loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcty_signature of class_signature\n (* object ... end *)\n | Pcty_arrow of arg_label * core_type * class_type\n (* T -> CT Simple\n ~l:T -> CT Labelled l\n ?l:T -> CT Optional l\n *)\n | Pcty_extension of extension\n (* [%id] *)\n | Pcty_open of open_description * class_type\n(* let open M in CT *)\n\nand class_signature = Parsetree.class_signature = {\n pcsig_self : core_type;\n pcsig_fields : class_type_field list;\n}\n(* object('selfpat) ... end\n object ... end (self = Ptyp_any)\n*)\n\nand class_type_field = Parsetree.class_type_field = {\n pctf_desc : class_type_field_desc;\n pctf_loc : location;\n pctf_attributes : attributes; (* ... [@@id1] [@@id2] *)\n}\n\nand class_type_field_desc = Parsetree.class_type_field_desc =\n | Pctf_inherit of class_type\n (* inherit CT *)\n | Pctf_val of (label loc * mutable_flag * virtual_flag * core_type)\n (* val x: T *)\n | Pctf_method of (label loc * private_flag * virtual_flag * core_type)\n (* method x: T\n\n Note: T can be a Ptyp_poly.\n *)\n | Pctf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pctf_attribute of attribute\n (* [@@@id] *)\n | Pctf_extension of extension\n(* [%%id] *)\n\nand 'a class_infos = 'a Parsetree.class_infos = {\n pci_virt : virtual_flag;\n pci_params : (core_type * (variance * injectivity)) list;\n pci_name : string loc;\n pci_expr : 'a;\n pci_loc : location;\n pci_attributes : attributes; (* ... [@@id1] [@@id2] *)\n}\n(* class c = ...\n class ['a1,...,'an] c = ...\n class virtual c = ...\n\n Also used for \"class type\" declaration.\n*)\n\nand class_description = class_type class_infos\nand class_type_declaration = class_type class_infos\n\n(* Value expressions for the class language *)\nand class_expr = Parsetree.class_expr = {\n pcl_desc : class_expr_desc;\n pcl_loc : location;\n pcl_attributes : attributes; (* ... [@id1] [@id2] *)\n}\n\nand class_expr_desc = Parsetree.class_expr_desc =\n | Pcl_constr of longident_loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcl_structure of class_structure\n (* object ... end *)\n | Pcl_fun of arg_label * expression option * pattern * class_expr\n (* fun P -> CE (Simple, None)\n fun ~l:P -> CE (Labelled l, None)\n fun ?l:P -> CE (Optional l, None)\n fun ?l:(P = E0) -> CE (Optional l, Some E0)\n *)\n | Pcl_apply of class_expr * (arg_label * expression) list\n (* CE ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pcl_let of rec_flag * value_binding list * class_expr\n (* let P1 = E1 and ... and Pn = EN in CE (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in CE (flag = Recursive)\n *)\n | Pcl_constraint of class_expr * class_type\n (* (CE : CT) *)\n | Pcl_extension of extension\n (* [%id] *)\n | Pcl_open of open_description * class_expr\n(* let open M in CE *)\n\nand class_structure = Parsetree.class_structure = {\n pcstr_self : pattern;\n pcstr_fields : class_field list;\n}\n(* object(selfpat) ... end\n object ... end (self = Ppat_any)\n*)\n\nand class_field = Parsetree.class_field = {\n pcf_desc : class_field_desc;\n pcf_loc : location;\n pcf_attributes : attributes; (* ... [@@id1] [@@id2] *)\n}\n\nand class_field_desc = Parsetree.class_field_desc =\n | Pcf_inherit of override_flag * class_expr * string loc option\n (* inherit CE\n inherit CE as x\n inherit! CE\n inherit! CE as x\n *)\n | Pcf_val of (label loc * mutable_flag * class_field_kind)\n (* val x = E\n val virtual x: T\n *)\n | Pcf_method of (label loc * private_flag * class_field_kind)\n (* method x = E (E can be a Pexp_poly)\n method virtual x: T (T can be a Ptyp_poly)\n *)\n | Pcf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pcf_initializer of expression\n (* initializer E *)\n | Pcf_attribute of attribute\n (* [@@@id] *)\n | Pcf_extension of extension\n(* [%%id] *)\n\nand class_field_kind = Parsetree.class_field_kind =\n | Cfk_virtual of core_type\n | Cfk_concrete of override_flag * expression\n\nand class_declaration = class_expr class_infos\n(* Type expressions for the module language *)\n\n(** {1 Module language} *)\n\nand module_type = Parsetree.module_type = {\n pmty_desc : module_type_desc;\n pmty_loc : location;\n pmty_attributes : attributes; (* ... [@id1] [@id2] *)\n}\n\nand module_type_desc = Parsetree.module_type_desc =\n | Pmty_ident of longident_loc\n (* S *)\n | Pmty_signature of signature\n (* sig ... end *)\n | Pmty_functor of functor_parameter * module_type\n (* functor(X : MT1) -> MT2 *)\n | Pmty_with of module_type * with_constraint list\n (* MT with ... *)\n | Pmty_typeof of module_expr\n (* module type of ME *)\n | Pmty_extension of extension\n (* [%id] *)\n | Pmty_alias of longident_loc\n(* (module M) *)\n\nand functor_parameter = Parsetree.functor_parameter =\n | Unit\n (* () *)\n | Named of string option loc * module_type\n(* (X : MT) Some X, MT\n (_ : MT) None, MT *)\n\nand signature = signature_item list\n\nand signature_item = Parsetree.signature_item = {\n psig_desc : signature_item_desc;\n psig_loc : location;\n}\n\nand signature_item_desc = Parsetree.signature_item_desc =\n | Psig_value of value_description\n (*\n val x: T\n external x: T = \"s1\" ... \"sn\"\n *)\n | Psig_type of rec_flag * type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Psig_typesubst of type_declaration list\n (* type t1 := ... and ... and tn := ... *)\n | Psig_typext of type_extension\n (* type t1 += ... *)\n | Psig_exception of type_exception\n (* exception C of T *)\n | Psig_module of module_declaration\n (* module X : MT *)\n | Psig_modsubst of module_substitution\n (* module X := M *)\n | Psig_recmodule of module_declaration list\n (* module rec X1 : MT1 and ... and Xn : MTn *)\n | Psig_modtype of module_type_declaration\n (* module type S = MT\n module type S *)\n | Psig_open of open_description\n (* open X *)\n | Psig_include of include_description\n (* include MT *)\n | Psig_class of class_description list\n (* class c1 : ... and ... and cn : ... *)\n | Psig_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Psig_attribute of attribute\n (* [@@@id] *)\n | Psig_extension of extension * attributes\n(* [%%id] *)\n\nand module_declaration = Parsetree.module_declaration = {\n pmd_name : string option loc;\n pmd_type : module_type;\n pmd_attributes : attributes;\n (* ... [@@id1] [@@id2] *)\n pmd_loc : location;\n}\n(* S : MT *)\n\nand module_substitution = Parsetree.module_substitution = {\n pms_name : string loc;\n pms_manifest : longident_loc;\n pms_attributes : attributes;\n pms_loc : location;\n}\n\nand module_type_declaration = Parsetree.module_type_declaration = {\n pmtd_name : string loc;\n pmtd_type : module_type option;\n pmtd_attributes : attributes;\n (* ... [@@id1] [@@id2] *)\n pmtd_loc : location;\n}\n(* S = MT\n S (abstract module type declaration, pmtd_type = None)\n*)\n\nand 'a open_infos = 'a Parsetree.open_infos = {\n popen_expr : 'a;\n popen_override : override_flag;\n popen_loc : location;\n popen_attributes : attributes;\n}\n\nand open_description = longident_loc open_infos\n(* open! X - popen_override = Override (silences the 'used identifier\n shadowing' warning)\n open X - popen_override = Fresh\n*)\n\nand open_declaration = module_expr open_infos\n\nand 'a include_infos = 'a Parsetree.include_infos = {\n pincl_mod : 'a;\n pincl_loc : location;\n pincl_attributes : attributes;\n}\n\nand include_description = module_type include_infos\n(* include MT *)\n\nand include_declaration = module_expr include_infos\n(* include ME *)\n\nand with_constraint = Parsetree.with_constraint =\n | Pwith_type of longident_loc * type_declaration\n (* with type X.t = ...\n\n Note: the last component of the longident must match\n the name of the type_declaration. *)\n | Pwith_module of longident_loc * longident_loc\n (* with module X.Y = Z *)\n | Pwith_typesubst of longident_loc * type_declaration\n (* with type X.t := ..., same format as [Pwith_type] *)\n | Pwith_modsubst of longident_loc * longident_loc\n(* with module X.Y := Z *)\n\n(* Value expressions for the module language *)\nand module_expr = Parsetree.module_expr = {\n pmod_desc : module_expr_desc;\n pmod_loc : location;\n pmod_attributes : attributes; (* ... [@id1] [@id2] *)\n}\n\nand module_expr_desc = Parsetree.module_expr_desc =\n | Pmod_ident of longident_loc\n (* X *)\n | Pmod_structure of structure\n (* struct ... end *)\n | Pmod_functor of functor_parameter * module_expr\n (* functor(X : MT1) -> ME *)\n | Pmod_apply of module_expr * module_expr\n (* ME1(ME2) *)\n | Pmod_constraint of module_expr * module_type\n (* (ME : MT) *)\n | Pmod_unpack of expression\n (* (val E) *)\n | Pmod_extension of extension\n(* [%id] *)\n\nand structure = structure_item list\n\nand structure_item = Parsetree.structure_item = {\n pstr_desc : structure_item_desc;\n pstr_loc : location;\n}\n\nand structure_item_desc = Parsetree.structure_item_desc =\n | Pstr_eval of expression * attributes\n (* E *)\n | Pstr_value of rec_flag * value_binding list\n (* let P1 = E1 and ... and Pn = EN (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN (flag = Recursive)\n *)\n | Pstr_primitive of value_description\n (* val x: T\n external x: T = \"s1\" ... \"sn\" *)\n | Pstr_type of rec_flag * type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Pstr_typext of type_extension\n (* type t1 += ... *)\n | Pstr_exception of type_exception\n (* exception C of T\n exception C = M.X *)\n | Pstr_module of module_binding\n (* module X = ME *)\n | Pstr_recmodule of module_binding list\n (* module rec X1 = ME1 and ... and Xn = MEn *)\n | Pstr_modtype of module_type_declaration\n (* module type S = MT *)\n | Pstr_open of open_declaration\n (* open X *)\n | Pstr_class of class_declaration list\n (* class c1 = ... and ... and cn = ... *)\n | Pstr_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Pstr_include of include_declaration\n (* include ME *)\n | Pstr_attribute of attribute\n (* [@@@id] *)\n | Pstr_extension of extension * attributes\n(* [%%id] *)\n\nand value_binding = Parsetree.value_binding = {\n pvb_pat : pattern;\n pvb_expr : expression;\n pvb_attributes : attributes;\n pvb_loc : location;\n}\n\nand module_binding = Parsetree.module_binding = {\n pmb_name : string option loc;\n pmb_expr : module_expr;\n pmb_attributes : attributes;\n pmb_loc : location;\n}\n(* X = ME *)\n\n(* Toplevel phrases *)\n\n(** {1 Toplevel} *)\n\nand toplevel_phrase = Parsetree.toplevel_phrase =\n | Ptop_def of structure\n | Ptop_dir of toplevel_directive\n(* #use, #load ... *)\n\nand toplevel_directive = Parsetree.toplevel_directive = {\n pdir_name : string loc;\n pdir_arg : directive_argument option;\n pdir_loc : location;\n}\n\nand directive_argument = Parsetree.directive_argument = {\n pdira_desc : directive_argument_desc;\n pdira_loc : location;\n}\n\nand directive_argument_desc = Parsetree.directive_argument_desc =\n | Pdir_string of string\n | Pdir_int of string * char option\n | Pdir_ident of longident\n | Pdir_bool of bool\n\nand cases = case list [@@deriving_inline traverse]\n\nclass virtual map =\n object (self)\n method virtual bool : bool -> bool\n method virtual char : char -> char\n method virtual int : int -> int\n method virtual list : 'a. ('a -> 'a) -> 'a list -> 'a list\n method virtual option : 'a. ('a -> 'a) -> 'a option -> 'a option\n method virtual string : string -> string\n\n method position : position -> position =\n fun { pos_fname; pos_lnum; pos_bol; pos_cnum } ->\n let pos_fname = self#string pos_fname in\n let pos_lnum = self#int pos_lnum in\n let pos_bol = self#int pos_bol in\n let pos_cnum = self#int pos_cnum in\n { pos_fname; pos_lnum; pos_bol; pos_cnum }\n\n method location : location -> location =\n fun { loc_start; loc_end; loc_ghost } ->\n let loc_start = self#position loc_start in\n let loc_end = self#position loc_end in\n let loc_ghost = self#bool loc_ghost in\n { loc_start; loc_end; loc_ghost }\n\n method location_stack : location_stack -> location_stack =\n self#list self#location\n\n method loc : 'a. ('a -> 'a) -> 'a loc -> 'a loc =\n fun _a { txt; loc } ->\n let txt = _a txt in\n let loc = self#location loc in\n { txt; loc }\n\n method longident : longident -> longident =\n fun x ->\n match x with\n | Lident a ->\n let a = self#string a in\n Lident a\n | Ldot (a, b) ->\n let a = self#longident a in\n let b = self#string b in\n Ldot (a, b)\n | Lapply (a, b) ->\n let a = self#longident a in\n let b = self#longident b in\n Lapply (a, b)\n\n method longident_loc : longident_loc -> longident_loc =\n self#loc self#longident\n\n method rec_flag : rec_flag -> rec_flag = fun x -> x\n method direction_flag : direction_flag -> direction_flag = fun x -> x\n method private_flag : private_flag -> private_flag = fun x -> x\n method mutable_flag : mutable_flag -> mutable_flag = fun x -> x\n method virtual_flag : virtual_flag -> virtual_flag = fun x -> x\n method override_flag : override_flag -> override_flag = fun x -> x\n method closed_flag : closed_flag -> closed_flag = fun x -> x\n method label : label -> label = self#string\n\n method arg_label : arg_label -> arg_label =\n fun x ->\n match x with\n | Nolabel -> Nolabel\n | Labelled a ->\n let a = self#string a in\n Labelled a\n | Optional a ->\n let a = self#string a in\n Optional a\n\n method variance : variance -> variance = fun x -> x\n method injectivity : injectivity -> injectivity = fun x -> x\n\n method constant : constant -> constant =\n fun x ->\n match x with\n | Pconst_integer (a, b) ->\n let a = self#string a in\n let b = self#option self#char b in\n Pconst_integer (a, b)\n | Pconst_char a ->\n let a = self#char a in\n Pconst_char a\n | Pconst_string (a, b, c) ->\n let a = self#string a in\n let b = self#location b in\n let c = self#option self#string c in\n Pconst_string (a, b, c)\n | Pconst_float (a, b) ->\n let a = self#string a in\n let b = self#option self#char b in\n Pconst_float (a, b)\n\n method attribute : attribute -> attribute =\n fun { attr_name; attr_payload; attr_loc } ->\n let attr_name = self#loc self#string attr_name in\n let attr_payload = self#payload attr_payload in\n let attr_loc = self#location attr_loc in\n { attr_name; attr_payload; attr_loc }\n\n method extension : extension -> extension =\n fun (a, b) ->\n let a = self#loc self#string a in\n let b = self#payload b in\n (a, b)\n\n method attributes : attributes -> attributes = self#list self#attribute\n\n method payload : payload -> payload =\n fun x ->\n match x with\n | PStr a ->\n let a = self#structure a in\n PStr a\n | PSig a ->\n let a = self#signature a in\n PSig a\n | PTyp a ->\n let a = self#core_type a in\n PTyp a\n | PPat (a, b) ->\n let a = self#pattern a in\n let b = self#option self#expression b in\n PPat (a, b)\n\n method core_type : core_type -> core_type =\n fun { ptyp_desc; ptyp_loc; ptyp_loc_stack; ptyp_attributes } ->\n let ptyp_desc = self#core_type_desc ptyp_desc in\n let ptyp_loc = self#location ptyp_loc in\n let ptyp_loc_stack = self#location_stack ptyp_loc_stack in\n let ptyp_attributes = self#attributes ptyp_attributes in\n { ptyp_desc; ptyp_loc; ptyp_loc_stack; ptyp_attributes }\n\n method core_type_desc : core_type_desc -> core_type_desc =\n fun x ->\n match x with\n | Ptyp_any -> Ptyp_any\n | Ptyp_var a ->\n let a = self#string a in\n Ptyp_var a\n | Ptyp_arrow (a, b, c) ->\n let a = self#arg_label a in\n let b = self#core_type b in\n let c = self#core_type c in\n Ptyp_arrow (a, b, c)\n | Ptyp_tuple a ->\n let a = self#list self#core_type a in\n Ptyp_tuple a\n | Ptyp_constr (a, b) ->\n let a = self#longident_loc a in\n let b = self#list self#core_type b in\n Ptyp_constr (a, b)\n | Ptyp_object (a, b) ->\n let a = self#list self#object_field a in\n let b = self#closed_flag b in\n Ptyp_object (a, b)\n | Ptyp_class (a, b) ->\n let a = self#longident_loc a in\n let b = self#list self#core_type b in\n Ptyp_class (a, b)\n | Ptyp_alias (a, b) ->\n let a = self#core_type a in\n let b = self#string b in\n Ptyp_alias (a, b)\n | Ptyp_variant (a, b, c) ->\n let a = self#list self#row_field a in\n let b = self#closed_flag b in\n let c = self#option (self#list self#label) c in\n Ptyp_variant (a, b, c)\n | Ptyp_poly (a, b) ->\n let a = self#list (self#loc self#string) a in\n let b = self#core_type b in\n Ptyp_poly (a, b)\n | Ptyp_package a ->\n let a = self#package_type a in\n Ptyp_package a\n | Ptyp_extension a ->\n let a = self#extension a in\n Ptyp_extension a\n\n method package_type : package_type -> package_type =\n fun (a, b) ->\n let a = self#longident_loc a in\n let b =\n self#list\n (fun (a, b) ->\n let a = self#longident_loc a in\n let b = self#core_type b in\n (a, b))\n b\n in\n (a, b)\n\n method row_field : row_field -> row_field =\n fun { prf_desc; prf_loc; prf_attributes } ->\n let prf_desc = self#row_field_desc prf_desc in\n let prf_loc = self#location prf_loc in\n let prf_attributes = self#attributes prf_attributes in\n { prf_desc; prf_loc; prf_attributes }\n\n method row_field_desc : row_field_desc -> row_field_desc =\n fun x ->\n match x with\n | Rtag (a, b, c) ->\n let a = self#loc self#label a in\n let b = self#bool b in\n let c = self#list self#core_type c in\n Rtag (a, b, c)\n | Rinherit a ->\n let a = self#core_type a in\n Rinherit a\n\n method object_field : object_field -> object_field =\n fun { pof_desc; pof_loc; pof_attributes } ->\n let pof_desc = self#object_field_desc pof_desc in\n let pof_loc = self#location pof_loc in\n let pof_attributes = self#attributes pof_attributes in\n { pof_desc; pof_loc; pof_attributes }\n\n method object_field_desc : object_field_desc -> object_field_desc =\n fun x ->\n match x with\n | Otag (a, b) ->\n let a = self#loc self#label a in\n let b = self#core_type b in\n Otag (a, b)\n | Oinherit a ->\n let a = self#core_type a in\n Oinherit a\n\n method pattern : pattern -> pattern =\n fun { ppat_desc; ppat_loc; ppat_loc_stack; ppat_attributes } ->\n let ppat_desc = self#pattern_desc ppat_desc in\n let ppat_loc = self#location ppat_loc in\n let ppat_loc_stack = self#location_stack ppat_loc_stack in\n let ppat_attributes = self#attributes ppat_attributes in\n { ppat_desc; ppat_loc; ppat_loc_stack; ppat_attributes }\n\n method pattern_desc : pattern_desc -> pattern_desc =\n fun x ->\n match x with\n | Ppat_any -> Ppat_any\n | Ppat_var a ->\n let a = self#loc self#string a in\n Ppat_var a\n | Ppat_alias (a, b) ->\n let a = self#pattern a in\n let b = self#loc self#string b in\n Ppat_alias (a, b)\n | Ppat_constant a ->\n let a = self#constant a in\n Ppat_constant a\n | Ppat_interval (a, b) ->\n let a = self#constant a in\n let b = self#constant b in\n Ppat_interval (a, b)\n | Ppat_tuple a ->\n let a = self#list self#pattern a in\n Ppat_tuple a\n | Ppat_construct (a, b) ->\n let a = self#longident_loc a in\n let b = self#option self#pattern b in\n Ppat_construct (a, b)\n | Ppat_variant (a, b) ->\n let a = self#label a in\n let b = self#option self#pattern b in\n Ppat_variant (a, b)\n | Ppat_record (a, b) ->\n let a =\n self#list\n (fun (a, b) ->\n let a = self#longident_loc a in\n let b = self#pattern b in\n (a, b))\n a\n in\n let b = self#closed_flag b in\n Ppat_record (a, b)\n | Ppat_array a ->\n let a = self#list self#pattern a in\n Ppat_array a\n | Ppat_or (a, b) ->\n let a = self#pattern a in\n let b = self#pattern b in\n Ppat_or (a, b)\n | Ppat_constraint (a, b) ->\n let a = self#pattern a in\n let b = self#core_type b in\n Ppat_constraint (a, b)\n | Ppat_type a ->\n let a = self#longident_loc a in\n Ppat_type a\n | Ppat_lazy a ->\n let a = self#pattern a in\n Ppat_lazy a\n | Ppat_unpack a ->\n let a = self#loc (self#option self#string) a in\n Ppat_unpack a\n | Ppat_exception a ->\n let a = self#pattern a in\n Ppat_exception a\n | Ppat_extension a ->\n let a = self#extension a in\n Ppat_extension a\n | Ppat_open (a, b) ->\n let a = self#longident_loc a in\n let b = self#pattern b in\n Ppat_open (a, b)\n\n method expression : expression -> expression =\n fun { pexp_desc; pexp_loc; pexp_loc_stack; pexp_attributes } ->\n let pexp_desc = self#expression_desc pexp_desc in\n let pexp_loc = self#location pexp_loc in\n let pexp_loc_stack = self#location_stack pexp_loc_stack in\n let pexp_attributes = self#attributes pexp_attributes in\n { pexp_desc; pexp_loc; pexp_loc_stack; pexp_attributes }\n\n method expression_desc : expression_desc -> expression_desc =\n fun x ->\n match x with\n | Pexp_ident a ->\n let a = self#longident_loc a in\n Pexp_ident a\n | Pexp_constant a ->\n let a = self#constant a in\n Pexp_constant a\n | Pexp_let (a, b, c) ->\n let a = self#rec_flag a in\n let b = self#list self#value_binding b in\n let c = self#expression c in\n Pexp_let (a, b, c)\n | Pexp_function a ->\n let a = self#cases a in\n Pexp_function a\n | Pexp_fun (a, b, c, d) ->\n let a = self#arg_label a in\n let b = self#option self#expression b in\n let c = self#pattern c in\n let d = self#expression d in\n Pexp_fun (a, b, c, d)\n | Pexp_apply (a, b) ->\n let a = self#expression a in\n let b =\n self#list\n (fun (a, b) ->\n let a = self#arg_label a in\n let b = self#expression b in\n (a, b))\n b\n in\n Pexp_apply (a, b)\n | Pexp_match (a, b) ->\n let a = self#expression a in\n let b = self#cases b in\n Pexp_match (a, b)\n | Pexp_try (a, b) ->\n let a = self#expression a in\n let b = self#cases b in\n Pexp_try (a, b)\n | Pexp_tuple a ->\n let a = self#list self#expression a in\n Pexp_tuple a\n | Pexp_construct (a, b) ->\n let a = self#longident_loc a in\n let b = self#option self#expression b in\n Pexp_construct (a, b)\n | Pexp_variant (a, b) ->\n let a = self#label a in\n let b = self#option self#expression b in\n Pexp_variant (a, b)\n | Pexp_record (a, b) ->\n let a =\n self#list\n (fun (a, b) ->\n let a = self#longident_loc a in\n let b = self#expression b in\n (a, b))\n a\n in\n let b = self#option self#expression b in\n Pexp_record (a, b)\n | Pexp_field (a, b) ->\n let a = self#expression a in\n let b = self#longident_loc b in\n Pexp_field (a, b)\n | Pexp_setfield (a, b, c) ->\n let a = self#expression a in\n let b = self#longident_loc b in\n let c = self#expression c in\n Pexp_setfield (a, b, c)\n | Pexp_array a ->\n let a = self#list self#expression a in\n Pexp_array a\n | Pexp_ifthenelse (a, b, c) ->\n let a = self#expression a in\n let b = self#expression b in\n let c = self#option self#expression c in\n Pexp_ifthenelse (a, b, c)\n | Pexp_sequence (a, b) ->\n let a = self#expression a in\n let b = self#expression b in\n Pexp_sequence (a, b)\n | Pexp_while (a, b) ->\n let a = self#expression a in\n let b = self#expression b in\n Pexp_while (a, b)\n | Pexp_for (a, b, c, d, e) ->\n let a = self#pattern a in\n let b = self#expression b in\n let c = self#expression c in\n let d = self#direction_flag d in\n let e = self#expression e in\n Pexp_for (a, b, c, d, e)\n | Pexp_constraint (a, b) ->\n let a = self#expression a in\n let b = self#core_type b in\n Pexp_constraint (a, b)\n | Pexp_coerce (a, b, c) ->\n let a = self#expression a in\n let b = self#option self#core_type b in\n let c = self#core_type c in\n Pexp_coerce (a, b, c)\n | Pexp_send (a, b) ->\n let a = self#expression a in\n let b = self#loc self#label b in\n Pexp_send (a, b)\n | Pexp_new a ->\n let a = self#longident_loc a in\n Pexp_new a\n | Pexp_setinstvar (a, b) ->\n let a = self#loc self#label a in\n let b = self#expression b in\n Pexp_setinstvar (a, b)\n | Pexp_override a ->\n let a =\n self#list\n (fun (a, b) ->\n let a = self#loc self#label a in\n let b = self#expression b in\n (a, b))\n a\n in\n Pexp_override a\n | Pexp_letmodule (a, b, c) ->\n let a = self#loc (self#option self#string) a in\n let b = self#module_expr b in\n let c = self#expression c in\n Pexp_letmodule (a, b, c)\n | Pexp_letexception (a, b) ->\n let a = self#extension_constructor a in\n let b = self#expression b in\n Pexp_letexception (a, b)\n | Pexp_assert a ->\n let a = self#expression a in\n Pexp_assert a\n | Pexp_lazy a ->\n let a = self#expression a in\n Pexp_lazy a\n | Pexp_poly (a, b) ->\n let a = self#expression a in\n let b = self#option self#core_type b in\n Pexp_poly (a, b)\n | Pexp_object a ->\n let a = self#class_structure a in\n Pexp_object a\n | Pexp_newtype (a, b) ->\n let a = self#loc self#string a in\n let b = self#expression b in\n Pexp_newtype (a, b)\n | Pexp_pack a ->\n let a = self#module_expr a in\n Pexp_pack a\n | Pexp_open (a, b) ->\n let a = self#open_declaration a in\n let b = self#expression b in\n Pexp_open (a, b)\n | Pexp_letop a ->\n let a = self#letop a in\n Pexp_letop a\n | Pexp_extension a ->\n let a = self#extension a in\n Pexp_extension a\n | Pexp_unreachable -> Pexp_unreachable\n\n method case : case -> case =\n fun { pc_lhs; pc_guard; pc_rhs } ->\n let pc_lhs = self#pattern pc_lhs in\n let pc_guard = self#option self#expression pc_guard in\n let pc_rhs = self#expression pc_rhs in\n { pc_lhs; pc_guard; pc_rhs }\n\n method letop : letop -> letop =\n fun { let_; ands; body } ->\n let let_ = self#binding_op let_ in\n let ands = self#list self#binding_op ands in\n let body = self#expression body in\n { let_; ands; body }\n\n method binding_op : binding_op -> binding_op =\n fun { pbop_op; pbop_pat; pbop_exp; pbop_loc } ->\n let pbop_op = self#loc self#string pbop_op in\n let pbop_pat = self#pattern pbop_pat in\n let pbop_exp = self#expression pbop_exp in\n let pbop_loc = self#location pbop_loc in\n { pbop_op; pbop_pat; pbop_exp; pbop_loc }\n\n method value_description : value_description -> value_description =\n fun { pval_name; pval_type; pval_prim; pval_attributes; pval_loc } ->\n let pval_name = self#loc self#string pval_name in\n let pval_type = self#core_type pval_type in\n let pval_prim = self#list self#string pval_prim in\n let pval_attributes = self#attributes pval_attributes in\n let pval_loc = self#location pval_loc in\n { pval_name; pval_type; pval_prim; pval_attributes; pval_loc }\n\n method type_declaration : type_declaration -> type_declaration =\n fun {\n ptype_name;\n ptype_params;\n ptype_cstrs;\n ptype_kind;\n ptype_private;\n ptype_manifest;\n ptype_attributes;\n ptype_loc;\n } ->\n let ptype_name = self#loc self#string ptype_name in\n let ptype_params =\n self#list\n (fun (a, b) ->\n let a = self#core_type a in\n let b =\n (fun (a, b) ->\n let a = self#variance a in\n let b = self#injectivity b in\n (a, b))\n b\n in\n (a, b))\n ptype_params\n in\n let ptype_cstrs =\n self#list\n (fun (a, b, c) ->\n let a = self#core_type a in\n let b = self#core_type b in\n let c = self#location c in\n (a, b, c))\n ptype_cstrs\n in\n let ptype_kind = self#type_kind ptype_kind in\n let ptype_private = self#private_flag ptype_private in\n let ptype_manifest = self#option self#core_type ptype_manifest in\n let ptype_attributes = self#attributes ptype_attributes in\n let ptype_loc = self#location ptype_loc in\n {\n ptype_name;\n ptype_params;\n ptype_cstrs;\n ptype_kind;\n ptype_private;\n ptype_manifest;\n ptype_attributes;\n ptype_loc;\n }\n\n method type_kind : type_kind -> type_kind =\n fun x ->\n match x with\n | Ptype_abstract -> Ptype_abstract\n | Ptype_variant a ->\n let a = self#list self#constructor_declaration a in\n Ptype_variant a\n | Ptype_record a ->\n let a = self#list self#label_declaration a in\n Ptype_record a\n | Ptype_open -> Ptype_open\n\n method label_declaration : label_declaration -> label_declaration =\n fun { pld_name; pld_mutable; pld_type; pld_loc; pld_attributes } ->\n let pld_name = self#loc self#string pld_name in\n let pld_mutable = self#mutable_flag pld_mutable in\n let pld_type = self#core_type pld_type in\n let pld_loc = self#location pld_loc in\n let pld_attributes = self#attributes pld_attributes in\n { pld_name; pld_mutable; pld_type; pld_loc; pld_attributes }\n\n method constructor_declaration\n : constructor_declaration -> constructor_declaration =\n fun { pcd_name; pcd_args; pcd_res; pcd_loc; pcd_attributes } ->\n let pcd_name = self#loc self#string pcd_name in\n let pcd_args = self#constructor_arguments pcd_args in\n let pcd_res = self#option self#core_type pcd_res in\n let pcd_loc = self#location pcd_loc in\n let pcd_attributes = self#attributes pcd_attributes in\n { pcd_name; pcd_args; pcd_res; pcd_loc; pcd_attributes }\n\n method constructor_arguments\n : constructor_arguments -> constructor_arguments =\n fun x ->\n match x with\n | Pcstr_tuple a ->\n let a = self#list self#core_type a in\n Pcstr_tuple a\n | Pcstr_record a ->\n let a = self#list self#label_declaration a in\n Pcstr_record a\n\n method type_extension : type_extension -> type_extension =\n fun {\n ptyext_path;\n ptyext_params;\n ptyext_constructors;\n ptyext_private;\n ptyext_loc;\n ptyext_attributes;\n } ->\n let ptyext_path = self#longident_loc ptyext_path in\n let ptyext_params =\n self#list\n (fun (a, b) ->\n let a = self#core_type a in\n let b =\n (fun (a, b) ->\n let a = self#variance a in\n let b = self#injectivity b in\n (a, b))\n b\n in\n (a, b))\n ptyext_params\n in\n let ptyext_constructors =\n self#list self#extension_constructor ptyext_constructors\n in\n let ptyext_private = self#private_flag ptyext_private in\n let ptyext_loc = self#location ptyext_loc in\n let ptyext_attributes = self#attributes ptyext_attributes in\n {\n ptyext_path;\n ptyext_params;\n ptyext_constructors;\n ptyext_private;\n ptyext_loc;\n ptyext_attributes;\n }\n\n method extension_constructor\n : extension_constructor -> extension_constructor =\n fun { pext_name; pext_kind; pext_loc; pext_attributes } ->\n let pext_name = self#loc self#string pext_name in\n let pext_kind = self#extension_constructor_kind pext_kind in\n let pext_loc = self#location pext_loc in\n let pext_attributes = self#attributes pext_attributes in\n { pext_name; pext_kind; pext_loc; pext_attributes }\n\n method type_exception : type_exception -> type_exception =\n fun { ptyexn_constructor; ptyexn_loc; ptyexn_attributes } ->\n let ptyexn_constructor =\n self#extension_constructor ptyexn_constructor\n in\n let ptyexn_loc = self#location ptyexn_loc in\n let ptyexn_attributes = self#attributes ptyexn_attributes in\n { ptyexn_constructor; ptyexn_loc; ptyexn_attributes }\n\n method extension_constructor_kind\n : extension_constructor_kind -> extension_constructor_kind =\n fun x ->\n match x with\n | Pext_decl (a, b) ->\n let a = self#constructor_arguments a in\n let b = self#option self#core_type b in\n Pext_decl (a, b)\n | Pext_rebind a ->\n let a = self#longident_loc a in\n Pext_rebind a\n\n method class_type : class_type -> class_type =\n fun { pcty_desc; pcty_loc; pcty_attributes } ->\n let pcty_desc = self#class_type_desc pcty_desc in\n let pcty_loc = self#location pcty_loc in\n let pcty_attributes = self#attributes pcty_attributes in\n { pcty_desc; pcty_loc; pcty_attributes }\n\n method class_type_desc : class_type_desc -> class_type_desc =\n fun x ->\n match x with\n | Pcty_constr (a, b) ->\n let a = self#longident_loc a in\n let b = self#list self#core_type b in\n Pcty_constr (a, b)\n | Pcty_signature a ->\n let a = self#class_signature a in\n Pcty_signature a\n | Pcty_arrow (a, b, c) ->\n let a = self#arg_label a in\n let b = self#core_type b in\n let c = self#class_type c in\n Pcty_arrow (a, b, c)\n | Pcty_extension a ->\n let a = self#extension a in\n Pcty_extension a\n | Pcty_open (a, b) ->\n let a = self#open_description a in\n let b = self#class_type b in\n Pcty_open (a, b)\n\n method class_signature : class_signature -> class_signature =\n fun { pcsig_self; pcsig_fields } ->\n let pcsig_self = self#core_type pcsig_self in\n let pcsig_fields = self#list self#class_type_field pcsig_fields in\n { pcsig_self; pcsig_fields }\n\n method class_type_field : class_type_field -> class_type_field =\n fun { pctf_desc; pctf_loc; pctf_attributes } ->\n let pctf_desc = self#class_type_field_desc pctf_desc in\n let pctf_loc = self#location pctf_loc in\n let pctf_attributes = self#attributes pctf_attributes in\n { pctf_desc; pctf_loc; pctf_attributes }\n\n method class_type_field_desc\n : class_type_field_desc -> class_type_field_desc =\n fun x ->\n match x with\n | Pctf_inherit a ->\n let a = self#class_type a in\n Pctf_inherit a\n | Pctf_val a ->\n let a =\n (fun (a, b, c, d) ->\n let a = self#loc self#label a in\n let b = self#mutable_flag b in\n let c = self#virtual_flag c in\n let d = self#core_type d in\n (a, b, c, d))\n a\n in\n Pctf_val a\n | Pctf_method a ->\n let a =\n (fun (a, b, c, d) ->\n let a = self#loc self#label a in\n let b = self#private_flag b in\n let c = self#virtual_flag c in\n let d = self#core_type d in\n (a, b, c, d))\n a\n in\n Pctf_method a\n | Pctf_constraint a ->\n let a =\n (fun (a, b) ->\n let a = self#core_type a in\n let b = self#core_type b in\n (a, b))\n a\n in\n Pctf_constraint a\n | Pctf_attribute a ->\n let a = self#attribute a in\n Pctf_attribute a\n | Pctf_extension a ->\n let a = self#extension a in\n Pctf_extension a\n\n method class_infos : 'a. ('a -> 'a) -> 'a class_infos -> 'a class_infos =\n fun _a\n { pci_virt; pci_params; pci_name; pci_expr; pci_loc; pci_attributes } ->\n let pci_virt = self#virtual_flag pci_virt in\n let pci_params =\n self#list\n (fun (a, b) ->\n let a = self#core_type a in\n let b =\n (fun (a, b) ->\n let a = self#variance a in\n let b = self#injectivity b in\n (a, b))\n b\n in\n (a, b))\n pci_params\n in\n let pci_name = self#loc self#string pci_name in\n let pci_expr = _a pci_expr in\n let pci_loc = self#location pci_loc in\n let pci_attributes = self#attributes pci_attributes in\n { pci_virt; pci_params; pci_name; pci_expr; pci_loc; pci_attributes }\n\n method class_description : class_description -> class_description =\n self#class_infos self#class_type\n\n method class_type_declaration\n : class_type_declaration -> class_type_declaration =\n self#class_infos self#class_type\n\n method class_expr : class_expr -> class_expr =\n fun { pcl_desc; pcl_loc; pcl_attributes } ->\n let pcl_desc = self#class_expr_desc pcl_desc in\n let pcl_loc = self#location pcl_loc in\n let pcl_attributes = self#attributes pcl_attributes in\n { pcl_desc; pcl_loc; pcl_attributes }\n\n method class_expr_desc : class_expr_desc -> class_expr_desc =\n fun x ->\n match x with\n | Pcl_constr (a, b) ->\n let a = self#longident_loc a in\n let b = self#list self#core_type b in\n Pcl_constr (a, b)\n | Pcl_structure a ->\n let a = self#class_structure a in\n Pcl_structure a\n | Pcl_fun (a, b, c, d) ->\n let a = self#arg_label a in\n let b = self#option self#expression b in\n let c = self#pattern c in\n let d = self#class_expr d in\n Pcl_fun (a, b, c, d)\n | Pcl_apply (a, b) ->\n let a = self#class_expr a in\n let b =\n self#list\n (fun (a, b) ->\n let a = self#arg_label a in\n let b = self#expression b in\n (a, b))\n b\n in\n Pcl_apply (a, b)\n | Pcl_let (a, b, c) ->\n let a = self#rec_flag a in\n let b = self#list self#value_binding b in\n let c = self#class_expr c in\n Pcl_let (a, b, c)\n | Pcl_constraint (a, b) ->\n let a = self#class_expr a in\n let b = self#class_type b in\n Pcl_constraint (a, b)\n | Pcl_extension a ->\n let a = self#extension a in\n Pcl_extension a\n | Pcl_open (a, b) ->\n let a = self#open_description a in\n let b = self#class_expr b in\n Pcl_open (a, b)\n\n method class_structure : class_structure -> class_structure =\n fun { pcstr_self; pcstr_fields } ->\n let pcstr_self = self#pattern pcstr_self in\n let pcstr_fields = self#list self#class_field pcstr_fields in\n { pcstr_self; pcstr_fields }\n\n method class_field : class_field -> class_field =\n fun { pcf_desc; pcf_loc; pcf_attributes } ->\n let pcf_desc = self#class_field_desc pcf_desc in\n let pcf_loc = self#location pcf_loc in\n let pcf_attributes = self#attributes pcf_attributes in\n { pcf_desc; pcf_loc; pcf_attributes }\n\n method class_field_desc : class_field_desc -> class_field_desc =\n fun x ->\n match x with\n | Pcf_inherit (a, b, c) ->\n let a = self#override_flag a in\n let b = self#class_expr b in\n let c = self#option (self#loc self#string) c in\n Pcf_inherit (a, b, c)\n | Pcf_val a ->\n let a =\n (fun (a, b, c) ->\n let a = self#loc self#label a in\n let b = self#mutable_flag b in\n let c = self#class_field_kind c in\n (a, b, c))\n a\n in\n Pcf_val a\n | Pcf_method a ->\n let a =\n (fun (a, b, c) ->\n let a = self#loc self#label a in\n let b = self#private_flag b in\n let c = self#class_field_kind c in\n (a, b, c))\n a\n in\n Pcf_method a\n | Pcf_constraint a ->\n let a =\n (fun (a, b) ->\n let a = self#core_type a in\n let b = self#core_type b in\n (a, b))\n a\n in\n Pcf_constraint a\n | Pcf_initializer a ->\n let a = self#expression a in\n Pcf_initializer a\n | Pcf_attribute a ->\n let a = self#attribute a in\n Pcf_attribute a\n | Pcf_extension a ->\n let a = self#extension a in\n Pcf_extension a\n\n method class_field_kind : class_field_kind -> class_field_kind =\n fun x ->\n match x with\n | Cfk_virtual a ->\n let a = self#core_type a in\n Cfk_virtual a\n | Cfk_concrete (a, b) ->\n let a = self#override_flag a in\n let b = self#expression b in\n Cfk_concrete (a, b)\n\n method class_declaration : class_declaration -> class_declaration =\n self#class_infos self#class_expr\n\n method module_type : module_type -> module_type =\n fun { pmty_desc; pmty_loc; pmty_attributes } ->\n let pmty_desc = self#module_type_desc pmty_desc in\n let pmty_loc = self#location pmty_loc in\n let pmty_attributes = self#attributes pmty_attributes in\n { pmty_desc; pmty_loc; pmty_attributes }\n\n method module_type_desc : module_type_desc -> module_type_desc =\n fun x ->\n match x with\n | Pmty_ident a ->\n let a = self#longident_loc a in\n Pmty_ident a\n | Pmty_signature a ->\n let a = self#signature a in\n Pmty_signature a\n | Pmty_functor (a, b) ->\n let a = self#functor_parameter a in\n let b = self#module_type b in\n Pmty_functor (a, b)\n | Pmty_with (a, b) ->\n let a = self#module_type a in\n let b = self#list self#with_constraint b in\n Pmty_with (a, b)\n | Pmty_typeof a ->\n let a = self#module_expr a in\n Pmty_typeof a\n | Pmty_extension a ->\n let a = self#extension a in\n Pmty_extension a\n | Pmty_alias a ->\n let a = self#longident_loc a in\n Pmty_alias a\n\n method functor_parameter : functor_parameter -> functor_parameter =\n fun x ->\n match x with\n | Unit -> Unit\n | Named (a, b) ->\n let a = self#loc (self#option self#string) a in\n let b = self#module_type b in\n Named (a, b)\n\n method signature : signature -> signature = self#list self#signature_item\n\n method signature_item : signature_item -> signature_item =\n fun { psig_desc; psig_loc } ->\n let psig_desc = self#signature_item_desc psig_desc in\n let psig_loc = self#location psig_loc in\n { psig_desc; psig_loc }\n\n method signature_item_desc : signature_item_desc -> signature_item_desc =\n fun x ->\n match x with\n | Psig_value a ->\n let a = self#value_description a in\n Psig_value a\n | Psig_type (a, b) ->\n let a = self#rec_flag a in\n let b = self#list self#type_declaration b in\n Psig_type (a, b)\n | Psig_typesubst a ->\n let a = self#list self#type_declaration a in\n Psig_typesubst a\n | Psig_typext a ->\n let a = self#type_extension a in\n Psig_typext a\n | Psig_exception a ->\n let a = self#type_exception a in\n Psig_exception a\n | Psig_module a ->\n let a = self#module_declaration a in\n Psig_module a\n | Psig_modsubst a ->\n let a = self#module_substitution a in\n Psig_modsubst a\n | Psig_recmodule a ->\n let a = self#list self#module_declaration a in\n Psig_recmodule a\n | Psig_modtype a ->\n let a = self#module_type_declaration a in\n Psig_modtype a\n | Psig_open a ->\n let a = self#open_description a in\n Psig_open a\n | Psig_include a ->\n let a = self#include_description a in\n Psig_include a\n | Psig_class a ->\n let a = self#list self#class_description a in\n Psig_class a\n | Psig_class_type a ->\n let a = self#list self#class_type_declaration a in\n Psig_class_type a\n | Psig_attribute a ->\n let a = self#attribute a in\n Psig_attribute a\n | Psig_extension (a, b) ->\n let a = self#extension a in\n let b = self#attributes b in\n Psig_extension (a, b)\n\n method module_declaration : module_declaration -> module_declaration =\n fun { pmd_name; pmd_type; pmd_attributes; pmd_loc } ->\n let pmd_name = self#loc (self#option self#string) pmd_name in\n let pmd_type = self#module_type pmd_type in\n let pmd_attributes = self#attributes pmd_attributes in\n let pmd_loc = self#location pmd_loc in\n { pmd_name; pmd_type; pmd_attributes; pmd_loc }\n\n method module_substitution : module_substitution -> module_substitution =\n fun { pms_name; pms_manifest; pms_attributes; pms_loc } ->\n let pms_name = self#loc self#string pms_name in\n let pms_manifest = self#longident_loc pms_manifest in\n let pms_attributes = self#attributes pms_attributes in\n let pms_loc = self#location pms_loc in\n { pms_name; pms_manifest; pms_attributes; pms_loc }\n\n method module_type_declaration\n : module_type_declaration -> module_type_declaration =\n fun { pmtd_name; pmtd_type; pmtd_attributes; pmtd_loc } ->\n let pmtd_name = self#loc self#string pmtd_name in\n let pmtd_type = self#option self#module_type pmtd_type in\n let pmtd_attributes = self#attributes pmtd_attributes in\n let pmtd_loc = self#location pmtd_loc in\n { pmtd_name; pmtd_type; pmtd_attributes; pmtd_loc }\n\n method open_infos : 'a. ('a -> 'a) -> 'a open_infos -> 'a open_infos =\n fun _a { popen_expr; popen_override; popen_loc; popen_attributes } ->\n let popen_expr = _a popen_expr in\n let popen_override = self#override_flag popen_override in\n let popen_loc = self#location popen_loc in\n let popen_attributes = self#attributes popen_attributes in\n { popen_expr; popen_override; popen_loc; popen_attributes }\n\n method open_description : open_description -> open_description =\n self#open_infos self#longident_loc\n\n method open_declaration : open_declaration -> open_declaration =\n self#open_infos self#module_expr\n\n method include_infos\n : 'a. ('a -> 'a) -> 'a include_infos -> 'a include_infos =\n fun _a { pincl_mod; pincl_loc; pincl_attributes } ->\n let pincl_mod = _a pincl_mod in\n let pincl_loc = self#location pincl_loc in\n let pincl_attributes = self#attributes pincl_attributes in\n { pincl_mod; pincl_loc; pincl_attributes }\n\n method include_description : include_description -> include_description =\n self#include_infos self#module_type\n\n method include_declaration : include_declaration -> include_declaration =\n self#include_infos self#module_expr\n\n method with_constraint : with_constraint -> with_constraint =\n fun x ->\n match x with\n | Pwith_type (a, b) ->\n let a = self#longident_loc a in\n let b = self#type_declaration b in\n Pwith_type (a, b)\n | Pwith_module (a, b) ->\n let a = self#longident_loc a in\n let b = self#longident_loc b in\n Pwith_module (a, b)\n | Pwith_typesubst (a, b) ->\n let a = self#longident_loc a in\n let b = self#type_declaration b in\n Pwith_typesubst (a, b)\n | Pwith_modsubst (a, b) ->\n let a = self#longident_loc a in\n let b = self#longident_loc b in\n Pwith_modsubst (a, b)\n\n method module_expr : module_expr -> module_expr =\n fun { pmod_desc; pmod_loc; pmod_attributes } ->\n let pmod_desc = self#module_expr_desc pmod_desc in\n let pmod_loc = self#location pmod_loc in\n let pmod_attributes = self#attributes pmod_attributes in\n { pmod_desc; pmod_loc; pmod_attributes }\n\n method module_expr_desc : module_expr_desc -> module_expr_desc =\n fun x ->\n match x with\n | Pmod_ident a ->\n let a = self#longident_loc a in\n Pmod_ident a\n | Pmod_structure a ->\n let a = self#structure a in\n Pmod_structure a\n | Pmod_functor (a, b) ->\n let a = self#functor_parameter a in\n let b = self#module_expr b in\n Pmod_functor (a, b)\n | Pmod_apply (a, b) ->\n let a = self#module_expr a in\n let b = self#module_expr b in\n Pmod_apply (a, b)\n | Pmod_constraint (a, b) ->\n let a = self#module_expr a in\n let b = self#module_type b in\n Pmod_constraint (a, b)\n | Pmod_unpack a ->\n let a = self#expression a in\n Pmod_unpack a\n | Pmod_extension a ->\n let a = self#extension a in\n Pmod_extension a\n\n method structure : structure -> structure = self#list self#structure_item\n\n method structure_item : structure_item -> structure_item =\n fun { pstr_desc; pstr_loc } ->\n let pstr_desc = self#structure_item_desc pstr_desc in\n let pstr_loc = self#location pstr_loc in\n { pstr_desc; pstr_loc }\n\n method structure_item_desc : structure_item_desc -> structure_item_desc =\n fun x ->\n match x with\n | Pstr_eval (a, b) ->\n let a = self#expression a in\n let b = self#attributes b in\n Pstr_eval (a, b)\n | Pstr_value (a, b) ->\n let a = self#rec_flag a in\n let b = self#list self#value_binding b in\n Pstr_value (a, b)\n | Pstr_primitive a ->\n let a = self#value_description a in\n Pstr_primitive a\n | Pstr_type (a, b) ->\n let a = self#rec_flag a in\n let b = self#list self#type_declaration b in\n Pstr_type (a, b)\n | Pstr_typext a ->\n let a = self#type_extension a in\n Pstr_typext a\n | Pstr_exception a ->\n let a = self#type_exception a in\n Pstr_exception a\n | Pstr_module a ->\n let a = self#module_binding a in\n Pstr_module a\n | Pstr_recmodule a ->\n let a = self#list self#module_binding a in\n Pstr_recmodule a\n | Pstr_modtype a ->\n let a = self#module_type_declaration a in\n Pstr_modtype a\n | Pstr_open a ->\n let a = self#open_declaration a in\n Pstr_open a\n | Pstr_class a ->\n let a = self#list self#class_declaration a in\n Pstr_class a\n | Pstr_class_type a ->\n let a = self#list self#class_type_declaration a in\n Pstr_class_type a\n | Pstr_include a ->\n let a = self#include_declaration a in\n Pstr_include a\n | Pstr_attribute a ->\n let a = self#attribute a in\n Pstr_attribute a\n | Pstr_extension (a, b) ->\n let a = self#extension a in\n let b = self#attributes b in\n Pstr_extension (a, b)\n\n method value_binding : value_binding -> value_binding =\n fun { pvb_pat; pvb_expr; pvb_attributes; pvb_loc } ->\n let pvb_pat = self#pattern pvb_pat in\n let pvb_expr = self#expression pvb_expr in\n let pvb_attributes = self#attributes pvb_attributes in\n let pvb_loc = self#location pvb_loc in\n { pvb_pat; pvb_expr; pvb_attributes; pvb_loc }\n\n method module_binding : module_binding -> module_binding =\n fun { pmb_name; pmb_expr; pmb_attributes; pmb_loc } ->\n let pmb_name = self#loc (self#option self#string) pmb_name in\n let pmb_expr = self#module_expr pmb_expr in\n let pmb_attributes = self#attributes pmb_attributes in\n let pmb_loc = self#location pmb_loc in\n { pmb_name; pmb_expr; pmb_attributes; pmb_loc }\n\n method toplevel_phrase : toplevel_phrase -> toplevel_phrase =\n fun x ->\n match x with\n | Ptop_def a ->\n let a = self#structure a in\n Ptop_def a\n | Ptop_dir a ->\n let a = self#toplevel_directive a in\n Ptop_dir a\n\n method toplevel_directive : toplevel_directive -> toplevel_directive =\n fun { pdir_name; pdir_arg; pdir_loc } ->\n let pdir_name = self#loc self#string pdir_name in\n let pdir_arg = self#option self#directive_argument pdir_arg in\n let pdir_loc = self#location pdir_loc in\n { pdir_name; pdir_arg; pdir_loc }\n\n method directive_argument : directive_argument -> directive_argument =\n fun { pdira_desc; pdira_loc } ->\n let pdira_desc = self#directive_argument_desc pdira_desc in\n let pdira_loc = self#location pdira_loc in\n { pdira_desc; pdira_loc }\n\n method directive_argument_desc\n : directive_argument_desc -> directive_argument_desc =\n fun x ->\n match x with\n | Pdir_string a ->\n let a = self#string a in\n Pdir_string a\n | Pdir_int (a, b) ->\n let a = self#string a in\n let b = self#option self#char b in\n Pdir_int (a, b)\n | Pdir_ident a ->\n let a = self#longident a in\n Pdir_ident a\n | Pdir_bool a ->\n let a = self#bool a in\n Pdir_bool a\n\n method cases : cases -> cases = self#list self#case\n end\n\nclass virtual iter =\n object (self)\n method virtual bool : bool -> unit\n method virtual char : char -> unit\n method virtual int : int -> unit\n method virtual list : 'a. ('a -> unit) -> 'a list -> unit\n method virtual option : 'a. ('a -> unit) -> 'a option -> unit\n method virtual string : string -> unit\n\n method position : position -> unit =\n fun { pos_fname; pos_lnum; pos_bol; pos_cnum } ->\n self#string pos_fname;\n self#int pos_lnum;\n self#int pos_bol;\n self#int pos_cnum\n\n method location : location -> unit =\n fun { loc_start; loc_end; loc_ghost } ->\n self#position loc_start;\n self#position loc_end;\n self#bool loc_ghost\n\n method location_stack : location_stack -> unit = self#list self#location\n\n method loc : 'a. ('a -> unit) -> 'a loc -> unit =\n fun _a { txt; loc } ->\n _a txt;\n self#location loc\n\n method longident : longident -> unit =\n fun x ->\n match x with\n | Lident a -> self#string a\n | Ldot (a, b) ->\n self#longident a;\n self#string b\n | Lapply (a, b) ->\n self#longident a;\n self#longident b\n\n method longident_loc : longident_loc -> unit = self#loc self#longident\n method rec_flag : rec_flag -> unit = fun _ -> ()\n method direction_flag : direction_flag -> unit = fun _ -> ()\n method private_flag : private_flag -> unit = fun _ -> ()\n method mutable_flag : mutable_flag -> unit = fun _ -> ()\n method virtual_flag : virtual_flag -> unit = fun _ -> ()\n method override_flag : override_flag -> unit = fun _ -> ()\n method closed_flag : closed_flag -> unit = fun _ -> ()\n method label : label -> unit = self#string\n\n method arg_label : arg_label -> unit =\n fun x ->\n match x with\n | Nolabel -> ()\n | Labelled a -> self#string a\n | Optional a -> self#string a\n\n method variance : variance -> unit = fun _ -> ()\n method injectivity : injectivity -> unit = fun _ -> ()\n\n method constant : constant -> unit =\n fun x ->\n match x with\n | Pconst_integer (a, b) ->\n self#string a;\n self#option self#char b\n | Pconst_char a -> self#char a\n | Pconst_string (a, b, c) ->\n self#string a;\n self#location b;\n self#option self#string c\n | Pconst_float (a, b) ->\n self#string a;\n self#option self#char b\n\n method attribute : attribute -> unit =\n fun { attr_name; attr_payload; attr_loc } ->\n self#loc self#string attr_name;\n self#payload attr_payload;\n self#location attr_loc\n\n method extension : extension -> unit =\n fun (a, b) ->\n self#loc self#string a;\n self#payload b\n\n method attributes : attributes -> unit = self#list self#attribute\n\n method payload : payload -> unit =\n fun x ->\n match x with\n | PStr a -> self#structure a\n | PSig a -> self#signature a\n | PTyp a -> self#core_type a\n | PPat (a, b) ->\n self#pattern a;\n self#option self#expression b\n\n method core_type : core_type -> unit =\n fun { ptyp_desc; ptyp_loc; ptyp_loc_stack; ptyp_attributes } ->\n self#core_type_desc ptyp_desc;\n self#location ptyp_loc;\n self#location_stack ptyp_loc_stack;\n self#attributes ptyp_attributes\n\n method core_type_desc : core_type_desc -> unit =\n fun x ->\n match x with\n | Ptyp_any -> ()\n | Ptyp_var a -> self#string a\n | Ptyp_arrow (a, b, c) ->\n self#arg_label a;\n self#core_type b;\n self#core_type c\n | Ptyp_tuple a -> self#list self#core_type a\n | Ptyp_constr (a, b) ->\n self#longident_loc a;\n self#list self#core_type b\n | Ptyp_object (a, b) ->\n self#list self#object_field a;\n self#closed_flag b\n | Ptyp_class (a, b) ->\n self#longident_loc a;\n self#list self#core_type b\n | Ptyp_alias (a, b) ->\n self#core_type a;\n self#string b\n | Ptyp_variant (a, b, c) ->\n self#list self#row_field a;\n self#closed_flag b;\n self#option (self#list self#label) c\n | Ptyp_poly (a, b) ->\n self#list (self#loc self#string) a;\n self#core_type b\n | Ptyp_package a -> self#package_type a\n | Ptyp_extension a -> self#extension a\n\n method package_type : package_type -> unit =\n fun (a, b) ->\n self#longident_loc a;\n self#list\n (fun (a, b) ->\n self#longident_loc a;\n self#core_type b)\n b\n\n method row_field : row_field -> unit =\n fun { prf_desc; prf_loc; prf_attributes } ->\n self#row_field_desc prf_desc;\n self#location prf_loc;\n self#attributes prf_attributes\n\n method row_field_desc : row_field_desc -> unit =\n fun x ->\n match x with\n | Rtag (a, b, c) ->\n self#loc self#label a;\n self#bool b;\n self#list self#core_type c\n | Rinherit a -> self#core_type a\n\n method object_field : object_field -> unit =\n fun { pof_desc; pof_loc; pof_attributes } ->\n self#object_field_desc pof_desc;\n self#location pof_loc;\n self#attributes pof_attributes\n\n method object_field_desc : object_field_desc -> unit =\n fun x ->\n match x with\n | Otag (a, b) ->\n self#loc self#label a;\n self#core_type b\n | Oinherit a -> self#core_type a\n\n method pattern : pattern -> unit =\n fun { ppat_desc; ppat_loc; ppat_loc_stack; ppat_attributes } ->\n self#pattern_desc ppat_desc;\n self#location ppat_loc;\n self#location_stack ppat_loc_stack;\n self#attributes ppat_attributes\n\n method pattern_desc : pattern_desc -> unit =\n fun x ->\n match x with\n | Ppat_any -> ()\n | Ppat_var a -> self#loc self#string a\n | Ppat_alias (a, b) ->\n self#pattern a;\n self#loc self#string b\n | Ppat_constant a -> self#constant a\n | Ppat_interval (a, b) ->\n self#constant a;\n self#constant b\n | Ppat_tuple a -> self#list self#pattern a\n | Ppat_construct (a, b) ->\n self#longident_loc a;\n self#option self#pattern b\n | Ppat_variant (a, b) ->\n self#label a;\n self#option self#pattern b\n | Ppat_record (a, b) ->\n self#list\n (fun (a, b) ->\n self#longident_loc a;\n self#pattern b)\n a;\n self#closed_flag b\n | Ppat_array a -> self#list self#pattern a\n | Ppat_or (a, b) ->\n self#pattern a;\n self#pattern b\n | Ppat_constraint (a, b) ->\n self#pattern a;\n self#core_type b\n | Ppat_type a -> self#longident_loc a\n | Ppat_lazy a -> self#pattern a\n | Ppat_unpack a -> self#loc (self#option self#string) a\n | Ppat_exception a -> self#pattern a\n | Ppat_extension a -> self#extension a\n | Ppat_open (a, b) ->\n self#longident_loc a;\n self#pattern b\n\n method expression : expression -> unit =\n fun { pexp_desc; pexp_loc; pexp_loc_stack; pexp_attributes } ->\n self#expression_desc pexp_desc;\n self#location pexp_loc;\n self#location_stack pexp_loc_stack;\n self#attributes pexp_attributes\n\n method expression_desc : expression_desc -> unit =\n fun x ->\n match x with\n | Pexp_ident a -> self#longident_loc a\n | Pexp_constant a -> self#constant a\n | Pexp_let (a, b, c) ->\n self#rec_flag a;\n self#list self#value_binding b;\n self#expression c\n | Pexp_function a -> self#cases a\n | Pexp_fun (a, b, c, d) ->\n self#arg_label a;\n self#option self#expression b;\n self#pattern c;\n self#expression d\n | Pexp_apply (a, b) ->\n self#expression a;\n self#list\n (fun (a, b) ->\n self#arg_label a;\n self#expression b)\n b\n | Pexp_match (a, b) ->\n self#expression a;\n self#cases b\n | Pexp_try (a, b) ->\n self#expression a;\n self#cases b\n | Pexp_tuple a -> self#list self#expression a\n | Pexp_construct (a, b) ->\n self#longident_loc a;\n self#option self#expression b\n | Pexp_variant (a, b) ->\n self#label a;\n self#option self#expression b\n | Pexp_record (a, b) ->\n self#list\n (fun (a, b) ->\n self#longident_loc a;\n self#expression b)\n a;\n self#option self#expression b\n | Pexp_field (a, b) ->\n self#expression a;\n self#longident_loc b\n | Pexp_setfield (a, b, c) ->\n self#expression a;\n self#longident_loc b;\n self#expression c\n | Pexp_array a -> self#list self#expression a\n | Pexp_ifthenelse (a, b, c) ->\n self#expression a;\n self#expression b;\n self#option self#expression c\n | Pexp_sequence (a, b) ->\n self#expression a;\n self#expression b\n | Pexp_while (a, b) ->\n self#expression a;\n self#expression b\n | Pexp_for (a, b, c, d, e) ->\n self#pattern a;\n self#expression b;\n self#expression c;\n self#direction_flag d;\n self#expression e\n | Pexp_constraint (a, b) ->\n self#expression a;\n self#core_type b\n | Pexp_coerce (a, b, c) ->\n self#expression a;\n self#option self#core_type b;\n self#core_type c\n | Pexp_send (a, b) ->\n self#expression a;\n self#loc self#label b\n | Pexp_new a -> self#longident_loc a\n | Pexp_setinstvar (a, b) ->\n self#loc self#label a;\n self#expression b\n | Pexp_override a ->\n self#list\n (fun (a, b) ->\n self#loc self#label a;\n self#expression b)\n a\n | Pexp_letmodule (a, b, c) ->\n self#loc (self#option self#string) a;\n self#module_expr b;\n self#expression c\n | Pexp_letexception (a, b) ->\n self#extension_constructor a;\n self#expression b\n | Pexp_assert a -> self#expression a\n | Pexp_lazy a -> self#expression a\n | Pexp_poly (a, b) ->\n self#expression a;\n self#option self#core_type b\n | Pexp_object a -> self#class_structure a\n | Pexp_newtype (a, b) ->\n self#loc self#string a;\n self#expression b\n | Pexp_pack a -> self#module_expr a\n | Pexp_open (a, b) ->\n self#open_declaration a;\n self#expression b\n | Pexp_letop a -> self#letop a\n | Pexp_extension a -> self#extension a\n | Pexp_unreachable -> ()\n\n method case : case -> unit =\n fun { pc_lhs; pc_guard; pc_rhs } ->\n self#pattern pc_lhs;\n self#option self#expression pc_guard;\n self#expression pc_rhs\n\n method letop : letop -> unit =\n fun { let_; ands; body } ->\n self#binding_op let_;\n self#list self#binding_op ands;\n self#expression body\n\n method binding_op : binding_op -> unit =\n fun { pbop_op; pbop_pat; pbop_exp; pbop_loc } ->\n self#loc self#string pbop_op;\n self#pattern pbop_pat;\n self#expression pbop_exp;\n self#location pbop_loc\n\n method value_description : value_description -> unit =\n fun { pval_name; pval_type; pval_prim; pval_attributes; pval_loc } ->\n self#loc self#string pval_name;\n self#core_type pval_type;\n self#list self#string pval_prim;\n self#attributes pval_attributes;\n self#location pval_loc\n\n method type_declaration : type_declaration -> unit =\n fun {\n ptype_name;\n ptype_params;\n ptype_cstrs;\n ptype_kind;\n ptype_private;\n ptype_manifest;\n ptype_attributes;\n ptype_loc;\n } ->\n self#loc self#string ptype_name;\n self#list\n (fun (a, b) ->\n self#core_type a;\n (fun (a, b) ->\n self#variance a;\n self#injectivity b)\n b)\n ptype_params;\n self#list\n (fun (a, b, c) ->\n self#core_type a;\n self#core_type b;\n self#location c)\n ptype_cstrs;\n self#type_kind ptype_kind;\n self#private_flag ptype_private;\n self#option self#core_type ptype_manifest;\n self#attributes ptype_attributes;\n self#location ptype_loc\n\n method type_kind : type_kind -> unit =\n fun x ->\n match x with\n | Ptype_abstract -> ()\n | Ptype_variant a -> self#list self#constructor_declaration a\n | Ptype_record a -> self#list self#label_declaration a\n | Ptype_open -> ()\n\n method label_declaration : label_declaration -> unit =\n fun { pld_name; pld_mutable; pld_type; pld_loc; pld_attributes } ->\n self#loc self#string pld_name;\n self#mutable_flag pld_mutable;\n self#core_type pld_type;\n self#location pld_loc;\n self#attributes pld_attributes\n\n method constructor_declaration : constructor_declaration -> unit =\n fun { pcd_name; pcd_args; pcd_res; pcd_loc; pcd_attributes } ->\n self#loc self#string pcd_name;\n self#constructor_arguments pcd_args;\n self#option self#core_type pcd_res;\n self#location pcd_loc;\n self#attributes pcd_attributes\n\n method constructor_arguments : constructor_arguments -> unit =\n fun x ->\n match x with\n | Pcstr_tuple a -> self#list self#core_type a\n | Pcstr_record a -> self#list self#label_declaration a\n\n method type_extension : type_extension -> unit =\n fun {\n ptyext_path;\n ptyext_params;\n ptyext_constructors;\n ptyext_private;\n ptyext_loc;\n ptyext_attributes;\n } ->\n self#longident_loc ptyext_path;\n self#list\n (fun (a, b) ->\n self#core_type a;\n (fun (a, b) ->\n self#variance a;\n self#injectivity b)\n b)\n ptyext_params;\n self#list self#extension_constructor ptyext_constructors;\n self#private_flag ptyext_private;\n self#location ptyext_loc;\n self#attributes ptyext_attributes\n\n method extension_constructor : extension_constructor -> unit =\n fun { pext_name; pext_kind; pext_loc; pext_attributes } ->\n self#loc self#string pext_name;\n self#extension_constructor_kind pext_kind;\n self#location pext_loc;\n self#attributes pext_attributes\n\n method type_exception : type_exception -> unit =\n fun { ptyexn_constructor; ptyexn_loc; ptyexn_attributes } ->\n self#extension_constructor ptyexn_constructor;\n self#location ptyexn_loc;\n self#attributes ptyexn_attributes\n\n method extension_constructor_kind : extension_constructor_kind -> unit =\n fun x ->\n match x with\n | Pext_decl (a, b) ->\n self#constructor_arguments a;\n self#option self#core_type b\n | Pext_rebind a -> self#longident_loc a\n\n method class_type : class_type -> unit =\n fun { pcty_desc; pcty_loc; pcty_attributes } ->\n self#class_type_desc pcty_desc;\n self#location pcty_loc;\n self#attributes pcty_attributes\n\n method class_type_desc : class_type_desc -> unit =\n fun x ->\n match x with\n | Pcty_constr (a, b) ->\n self#longident_loc a;\n self#list self#core_type b\n | Pcty_signature a -> self#class_signature a\n | Pcty_arrow (a, b, c) ->\n self#arg_label a;\n self#core_type b;\n self#class_type c\n | Pcty_extension a -> self#extension a\n | Pcty_open (a, b) ->\n self#open_description a;\n self#class_type b\n\n method class_signature : class_signature -> unit =\n fun { pcsig_self; pcsig_fields } ->\n self#core_type pcsig_self;\n self#list self#class_type_field pcsig_fields\n\n method class_type_field : class_type_field -> unit =\n fun { pctf_desc; pctf_loc; pctf_attributes } ->\n self#class_type_field_desc pctf_desc;\n self#location pctf_loc;\n self#attributes pctf_attributes\n\n method class_type_field_desc : class_type_field_desc -> unit =\n fun x ->\n match x with\n | Pctf_inherit a -> self#class_type a\n | Pctf_val a ->\n (fun (a, b, c, d) ->\n self#loc self#label a;\n self#mutable_flag b;\n self#virtual_flag c;\n self#core_type d)\n a\n | Pctf_method a ->\n (fun (a, b, c, d) ->\n self#loc self#label a;\n self#private_flag b;\n self#virtual_flag c;\n self#core_type d)\n a\n | Pctf_constraint a ->\n (fun (a, b) ->\n self#core_type a;\n self#core_type b)\n a\n | Pctf_attribute a -> self#attribute a\n | Pctf_extension a -> self#extension a\n\n method class_infos : 'a. ('a -> unit) -> 'a class_infos -> unit =\n fun _a\n { pci_virt; pci_params; pci_name; pci_expr; pci_loc; pci_attributes } ->\n self#virtual_flag pci_virt;\n self#list\n (fun (a, b) ->\n self#core_type a;\n (fun (a, b) ->\n self#variance a;\n self#injectivity b)\n b)\n pci_params;\n self#loc self#string pci_name;\n _a pci_expr;\n self#location pci_loc;\n self#attributes pci_attributes\n\n method class_description : class_description -> unit =\n self#class_infos self#class_type\n\n method class_type_declaration : class_type_declaration -> unit =\n self#class_infos self#class_type\n\n method class_expr : class_expr -> unit =\n fun { pcl_desc; pcl_loc; pcl_attributes } ->\n self#class_expr_desc pcl_desc;\n self#location pcl_loc;\n self#attributes pcl_attributes\n\n method class_expr_desc : class_expr_desc -> unit =\n fun x ->\n match x with\n | Pcl_constr (a, b) ->\n self#longident_loc a;\n self#list self#core_type b\n | Pcl_structure a -> self#class_structure a\n | Pcl_fun (a, b, c, d) ->\n self#arg_label a;\n self#option self#expression b;\n self#pattern c;\n self#class_expr d\n | Pcl_apply (a, b) ->\n self#class_expr a;\n self#list\n (fun (a, b) ->\n self#arg_label a;\n self#expression b)\n b\n | Pcl_let (a, b, c) ->\n self#rec_flag a;\n self#list self#value_binding b;\n self#class_expr c\n | Pcl_constraint (a, b) ->\n self#class_expr a;\n self#class_type b\n | Pcl_extension a -> self#extension a\n | Pcl_open (a, b) ->\n self#open_description a;\n self#class_expr b\n\n method class_structure : class_structure -> unit =\n fun { pcstr_self; pcstr_fields } ->\n self#pattern pcstr_self;\n self#list self#class_field pcstr_fields\n\n method class_field : class_field -> unit =\n fun { pcf_desc; pcf_loc; pcf_attributes } ->\n self#class_field_desc pcf_desc;\n self#location pcf_loc;\n self#attributes pcf_attributes\n\n method class_field_desc : class_field_desc -> unit =\n fun x ->\n match x with\n | Pcf_inherit (a, b, c) ->\n self#override_flag a;\n self#class_expr b;\n self#option (self#loc self#string) c\n | Pcf_val a ->\n (fun (a, b, c) ->\n self#loc self#label a;\n self#mutable_flag b;\n self#class_field_kind c)\n a\n | Pcf_method a ->\n (fun (a, b, c) ->\n self#loc self#label a;\n self#private_flag b;\n self#class_field_kind c)\n a\n | Pcf_constraint a ->\n (fun (a, b) ->\n self#core_type a;\n self#core_type b)\n a\n | Pcf_initializer a -> self#expression a\n | Pcf_attribute a -> self#attribute a\n | Pcf_extension a -> self#extension a\n\n method class_field_kind : class_field_kind -> unit =\n fun x ->\n match x with\n | Cfk_virtual a -> self#core_type a\n | Cfk_concrete (a, b) ->\n self#override_flag a;\n self#expression b\n\n method class_declaration : class_declaration -> unit =\n self#class_infos self#class_expr\n\n method module_type : module_type -> unit =\n fun { pmty_desc; pmty_loc; pmty_attributes } ->\n self#module_type_desc pmty_desc;\n self#location pmty_loc;\n self#attributes pmty_attributes\n\n method module_type_desc : module_type_desc -> unit =\n fun x ->\n match x with\n | Pmty_ident a -> self#longident_loc a\n | Pmty_signature a -> self#signature a\n | Pmty_functor (a, b) ->\n self#functor_parameter a;\n self#module_type b\n | Pmty_with (a, b) ->\n self#module_type a;\n self#list self#with_constraint b\n | Pmty_typeof a -> self#module_expr a\n | Pmty_extension a -> self#extension a\n | Pmty_alias a -> self#longident_loc a\n\n method functor_parameter : functor_parameter -> unit =\n fun x ->\n match x with\n | Unit -> ()\n | Named (a, b) ->\n self#loc (self#option self#string) a;\n self#module_type b\n\n method signature : signature -> unit = self#list self#signature_item\n\n method signature_item : signature_item -> unit =\n fun { psig_desc; psig_loc } ->\n self#signature_item_desc psig_desc;\n self#location psig_loc\n\n method signature_item_desc : signature_item_desc -> unit =\n fun x ->\n match x with\n | Psig_value a -> self#value_description a\n | Psig_type (a, b) ->\n self#rec_flag a;\n self#list self#type_declaration b\n | Psig_typesubst a -> self#list self#type_declaration a\n | Psig_typext a -> self#type_extension a\n | Psig_exception a -> self#type_exception a\n | Psig_module a -> self#module_declaration a\n | Psig_modsubst a -> self#module_substitution a\n | Psig_recmodule a -> self#list self#module_declaration a\n | Psig_modtype a -> self#module_type_declaration a\n | Psig_open a -> self#open_description a\n | Psig_include a -> self#include_description a\n | Psig_class a -> self#list self#class_description a\n | Psig_class_type a -> self#list self#class_type_declaration a\n | Psig_attribute a -> self#attribute a\n | Psig_extension (a, b) ->\n self#extension a;\n self#attributes b\n\n method module_declaration : module_declaration -> unit =\n fun { pmd_name; pmd_type; pmd_attributes; pmd_loc } ->\n self#loc (self#option self#string) pmd_name;\n self#module_type pmd_type;\n self#attributes pmd_attributes;\n self#location pmd_loc\n\n method module_substitution : module_substitution -> unit =\n fun { pms_name; pms_manifest; pms_attributes; pms_loc } ->\n self#loc self#string pms_name;\n self#longident_loc pms_manifest;\n self#attributes pms_attributes;\n self#location pms_loc\n\n method module_type_declaration : module_type_declaration -> unit =\n fun { pmtd_name; pmtd_type; pmtd_attributes; pmtd_loc } ->\n self#loc self#string pmtd_name;\n self#option self#module_type pmtd_type;\n self#attributes pmtd_attributes;\n self#location pmtd_loc\n\n method open_infos : 'a. ('a -> unit) -> 'a open_infos -> unit =\n fun _a { popen_expr; popen_override; popen_loc; popen_attributes } ->\n _a popen_expr;\n self#override_flag popen_override;\n self#location popen_loc;\n self#attributes popen_attributes\n\n method open_description : open_description -> unit =\n self#open_infos self#longident_loc\n\n method open_declaration : open_declaration -> unit =\n self#open_infos self#module_expr\n\n method include_infos : 'a. ('a -> unit) -> 'a include_infos -> unit =\n fun _a { pincl_mod; pincl_loc; pincl_attributes } ->\n _a pincl_mod;\n self#location pincl_loc;\n self#attributes pincl_attributes\n\n method include_description : include_description -> unit =\n self#include_infos self#module_type\n\n method include_declaration : include_declaration -> unit =\n self#include_infos self#module_expr\n\n method with_constraint : with_constraint -> unit =\n fun x ->\n match x with\n | Pwith_type (a, b) ->\n self#longident_loc a;\n self#type_declaration b\n | Pwith_module (a, b) ->\n self#longident_loc a;\n self#longident_loc b\n | Pwith_typesubst (a, b) ->\n self#longident_loc a;\n self#type_declaration b\n | Pwith_modsubst (a, b) ->\n self#longident_loc a;\n self#longident_loc b\n\n method module_expr : module_expr -> unit =\n fun { pmod_desc; pmod_loc; pmod_attributes } ->\n self#module_expr_desc pmod_desc;\n self#location pmod_loc;\n self#attributes pmod_attributes\n\n method module_expr_desc : module_expr_desc -> unit =\n fun x ->\n match x with\n | Pmod_ident a -> self#longident_loc a\n | Pmod_structure a -> self#structure a\n | Pmod_functor (a, b) ->\n self#functor_parameter a;\n self#module_expr b\n | Pmod_apply (a, b) ->\n self#module_expr a;\n self#module_expr b\n | Pmod_constraint (a, b) ->\n self#module_expr a;\n self#module_type b\n | Pmod_unpack a -> self#expression a\n | Pmod_extension a -> self#extension a\n\n method structure : structure -> unit = self#list self#structure_item\n\n method structure_item : structure_item -> unit =\n fun { pstr_desc; pstr_loc } ->\n self#structure_item_desc pstr_desc;\n self#location pstr_loc\n\n method structure_item_desc : structure_item_desc -> unit =\n fun x ->\n match x with\n | Pstr_eval (a, b) ->\n self#expression a;\n self#attributes b\n | Pstr_value (a, b) ->\n self#rec_flag a;\n self#list self#value_binding b\n | Pstr_primitive a -> self#value_description a\n | Pstr_type (a, b) ->\n self#rec_flag a;\n self#list self#type_declaration b\n | Pstr_typext a -> self#type_extension a\n | Pstr_exception a -> self#type_exception a\n | Pstr_module a -> self#module_binding a\n | Pstr_recmodule a -> self#list self#module_binding a\n | Pstr_modtype a -> self#module_type_declaration a\n | Pstr_open a -> self#open_declaration a\n | Pstr_class a -> self#list self#class_declaration a\n | Pstr_class_type a -> self#list self#class_type_declaration a\n | Pstr_include a -> self#include_declaration a\n | Pstr_attribute a -> self#attribute a\n | Pstr_extension (a, b) ->\n self#extension a;\n self#attributes b\n\n method value_binding : value_binding -> unit =\n fun { pvb_pat; pvb_expr; pvb_attributes; pvb_loc } ->\n self#pattern pvb_pat;\n self#expression pvb_expr;\n self#attributes pvb_attributes;\n self#location pvb_loc\n\n method module_binding : module_binding -> unit =\n fun { pmb_name; pmb_expr; pmb_attributes; pmb_loc } ->\n self#loc (self#option self#string) pmb_name;\n self#module_expr pmb_expr;\n self#attributes pmb_attributes;\n self#location pmb_loc\n\n method toplevel_phrase : toplevel_phrase -> unit =\n fun x ->\n match x with\n | Ptop_def a -> self#structure a\n | Ptop_dir a -> self#toplevel_directive a\n\n method toplevel_directive : toplevel_directive -> unit =\n fun { pdir_name; pdir_arg; pdir_loc } ->\n self#loc self#string pdir_name;\n self#option self#directive_argument pdir_arg;\n self#location pdir_loc\n\n method directive_argument : directive_argument -> unit =\n fun { pdira_desc; pdira_loc } ->\n self#directive_argument_desc pdira_desc;\n self#location pdira_loc\n\n method directive_argument_desc : directive_argument_desc -> unit =\n fun x ->\n match x with\n | Pdir_string a -> self#string a\n | Pdir_int (a, b) ->\n self#string a;\n self#option self#char b\n | Pdir_ident a -> self#longident a\n | Pdir_bool a -> self#bool a\n\n method cases : cases -> unit = self#list self#case\n end\n\nclass virtual ['acc] fold =\n object (self)\n method virtual bool : bool -> 'acc -> 'acc\n method virtual char : char -> 'acc -> 'acc\n method virtual int : int -> 'acc -> 'acc\n method virtual list : 'a. ('a -> 'acc -> 'acc) -> 'a list -> 'acc -> 'acc\n\n method virtual option\n : 'a. ('a -> 'acc -> 'acc) -> 'a option -> 'acc -> 'acc\n\n method virtual string : string -> 'acc -> 'acc\n\n method position : position -> 'acc -> 'acc =\n fun { pos_fname; pos_lnum; pos_bol; pos_cnum } acc ->\n let acc = self#string pos_fname acc in\n let acc = self#int pos_lnum acc in\n let acc = self#int pos_bol acc in\n let acc = self#int pos_cnum acc in\n acc\n\n method location : location -> 'acc -> 'acc =\n fun { loc_start; loc_end; loc_ghost } acc ->\n let acc = self#position loc_start acc in\n let acc = self#position loc_end acc in\n let acc = self#bool loc_ghost acc in\n acc\n\n method location_stack : location_stack -> 'acc -> 'acc =\n self#list self#location\n\n method loc : 'a. ('a -> 'acc -> 'acc) -> 'a loc -> 'acc -> 'acc =\n fun _a { txt; loc } acc ->\n let acc = _a txt acc in\n let acc = self#location loc acc in\n acc\n\n method longident : longident -> 'acc -> 'acc =\n fun x acc ->\n match x with\n | Lident a -> self#string a acc\n | Ldot (a, b) ->\n let acc = self#longident a acc in\n let acc = self#string b acc in\n acc\n | Lapply (a, b) ->\n let acc = self#longident a acc in\n let acc = self#longident b acc in\n acc\n\n method longident_loc : longident_loc -> 'acc -> 'acc =\n self#loc self#longident\n\n method rec_flag : rec_flag -> 'acc -> 'acc = fun _ acc -> acc\n method direction_flag : direction_flag -> 'acc -> 'acc = fun _ acc -> acc\n method private_flag : private_flag -> 'acc -> 'acc = fun _ acc -> acc\n method mutable_flag : mutable_flag -> 'acc -> 'acc = fun _ acc -> acc\n method virtual_flag : virtual_flag -> 'acc -> 'acc = fun _ acc -> acc\n method override_flag : override_flag -> 'acc -> 'acc = fun _ acc -> acc\n method closed_flag : closed_flag -> 'acc -> 'acc = fun _ acc -> acc\n method label : label -> 'acc -> 'acc = self#string\n\n method arg_label : arg_label -> 'acc -> 'acc =\n fun x acc ->\n match x with\n | Nolabel -> acc\n | Labelled a -> self#string a acc\n | Optional a -> self#string a acc\n\n method variance : variance -> 'acc -> 'acc = fun _ acc -> acc\n method injectivity : injectivity -> 'acc -> 'acc = fun _ acc -> acc\n\n method constant : constant -> 'acc -> 'acc =\n fun x acc ->\n match x with\n | Pconst_integer (a, b) ->\n let acc = self#string a acc in\n let acc = self#option self#char b acc in\n acc\n | Pconst_char a -> self#char a acc\n | Pconst_string (a, b, c) ->\n let acc = self#string a acc in\n let acc = self#location b acc in\n let acc = self#option self#string c acc in\n acc\n | Pconst_float (a, b) ->\n let acc = self#string a acc in\n let acc = self#option self#char b acc in\n acc\n\n method attribute : attribute -> 'acc -> 'acc =\n fun { attr_name; attr_payload; attr_loc } acc ->\n let acc = self#loc self#string attr_name acc in\n let acc = self#payload attr_payload acc in\n let acc = self#location attr_loc acc in\n acc\n\n method extension : extension -> 'acc -> 'acc =\n fun (a, b) acc ->\n let acc = self#loc self#string a acc in\n let acc = self#payload b acc in\n acc\n\n method attributes : attributes -> 'acc -> 'acc = self#list self#attribute\n\n method payload : payload -> 'acc -> 'acc =\n fun x acc ->\n match x with\n | PStr a -> self#structure a acc\n | PSig a -> self#signature a acc\n | PTyp a -> self#core_type a acc\n | PPat (a, b) ->\n let acc = self#pattern a acc in\n let acc = self#option self#expression b acc in\n acc\n\n method core_type : core_type -> 'acc -> 'acc =\n fun { ptyp_desc; ptyp_loc; ptyp_loc_stack; ptyp_attributes } acc ->\n let acc = self#core_type_desc ptyp_desc acc in\n let acc = self#location ptyp_loc acc in\n let acc = self#location_stack ptyp_loc_stack acc in\n let acc = self#attributes ptyp_attributes acc in\n acc\n\n method core_type_desc : core_type_desc -> 'acc -> 'acc =\n fun x acc ->\n match x with\n | Ptyp_any -> acc\n | Ptyp_var a -> self#string a acc\n | Ptyp_arrow (a, b, c) ->\n let acc = self#arg_label a acc in\n let acc = self#core_type b acc in\n let acc = self#core_type c acc in\n acc\n | Ptyp_tuple a -> self#list self#core_type a acc\n | Ptyp_constr (a, b) ->\n let acc = self#longident_loc a acc in\n let acc = self#list self#core_type b acc in\n acc\n | Ptyp_object (a, b) ->\n let acc = self#list self#object_field a acc in\n let acc = self#closed_flag b acc in\n acc\n | Ptyp_class (a, b) ->\n let acc = self#longident_loc a acc in\n let acc = self#list self#core_type b acc in\n acc\n | Ptyp_alias (a, b) ->\n let acc = self#core_type a acc in\n let acc = self#string b acc in\n acc\n | Ptyp_variant (a, b, c) ->\n let acc = self#list self#row_field a acc in\n let acc = self#closed_flag b acc in\n let acc = self#option (self#list self#label) c acc in\n acc\n | Ptyp_poly (a, b) ->\n let acc = self#list (self#loc self#string) a acc in\n let acc = self#core_type b acc in\n acc\n | Ptyp_package a -> self#package_type a acc\n | Ptyp_extension a -> self#extension a acc\n\n method package_type : package_type -> 'acc -> 'acc =\n fun (a, b) acc ->\n let acc = self#longident_loc a acc in\n let acc =\n self#list\n (fun (a, b) acc ->\n let acc = self#longident_loc a acc in\n let acc = self#core_type b acc in\n acc)\n b acc\n in\n acc\n\n method row_field : row_field -> 'acc -> 'acc =\n fun { prf_desc; prf_loc; prf_attributes } acc ->\n let acc = self#row_field_desc prf_desc acc in\n let acc = self#location prf_loc acc in\n let acc = self#attributes prf_attributes acc in\n acc\n\n method row_field_desc : row_field_desc -> 'acc -> 'acc =\n fun x acc ->\n match x with\n | Rtag (a, b, c) ->\n let acc = self#loc self#label a acc in\n let acc = self#bool b acc in\n let acc = self#list self#core_type c acc in\n acc\n | Rinherit a -> self#core_type a acc\n\n method object_field : object_field -> 'acc -> 'acc =\n fun { pof_desc; pof_loc; pof_attributes } acc ->\n let acc = self#object_field_desc pof_desc acc in\n let acc = self#location pof_loc acc in\n let acc = self#attributes pof_attributes acc in\n acc\n\n method object_field_desc : object_field_desc -> 'acc -> 'acc =\n fun x acc ->\n match x with\n | Otag (a, b) ->\n let acc = self#loc self#label a acc in\n let acc = self#core_type b acc in\n acc\n | Oinherit a -> self#core_type a acc\n\n method pattern : pattern -> 'acc -> 'acc =\n fun { ppat_desc; ppat_loc; ppat_loc_stack; ppat_attributes } acc ->\n let acc = self#pattern_desc ppat_desc acc in\n let acc = self#location ppat_loc acc in\n let acc = self#location_stack ppat_loc_stack acc in\n let acc = self#attributes ppat_attributes acc in\n acc\n\n method pattern_desc : pattern_desc -> 'acc -> 'acc =\n fun x acc ->\n match x with\n | Ppat_any -> acc\n | Ppat_var a -> self#loc self#string a acc\n | Ppat_alias (a, b) ->\n let acc = self#pattern a acc in\n let acc = self#loc self#string b acc in\n acc\n | Ppat_constant a -> self#constant a acc\n | Ppat_interval (a, b) ->\n let acc = self#constant a acc in\n let acc = self#constant b acc in\n acc\n | Ppat_tuple a -> self#list self#pattern a acc\n | Ppat_construct (a, b) ->\n let acc = self#longident_loc a acc in\n let acc = self#option self#pattern b acc in\n acc\n | Ppat_variant (a, b) ->\n let acc = self#label a acc in\n let acc = self#option self#pattern b acc in\n acc\n | Ppat_record (a, b) ->\n let acc =\n self#list\n (fun (a, b) acc ->\n let acc = self#longident_loc a acc in\n let acc = self#pattern b acc in\n acc)\n a acc\n in\n let acc = self#closed_flag b acc in\n acc\n | Ppat_array a -> self#list self#pattern a acc\n | Ppat_or (a, b) ->\n let acc = self#pattern a acc in\n let acc = self#pattern b acc in\n acc\n | Ppat_constraint (a, b) ->\n let acc = self#pattern a acc in\n let acc = self#core_type b acc in\n acc\n | Ppat_type a -> self#longident_loc a acc\n | Ppat_lazy a -> self#pattern a acc\n | Ppat_unpack a -> self#loc (self#option self#string) a acc\n | Ppat_exception a -> self#pattern a acc\n | Ppat_extension a -> self#extension a acc\n | Ppat_open (a, b) ->\n let acc = self#longident_loc a acc in\n let acc = self#pattern b acc in\n acc\n\n method expression : expression -> 'acc -> 'acc =\n fun { pexp_desc; pexp_loc; pexp_loc_stack; pexp_attributes } acc ->\n let acc = self#expression_desc pexp_desc acc in\n let acc = self#location pexp_loc acc in\n let acc = self#location_stack pexp_loc_stack acc in\n let acc = self#attributes pexp_attributes acc in\n acc\n\n method expression_desc : expression_desc -> 'acc -> 'acc =\n fun x acc ->\n match x with\n | Pexp_ident a -> self#longident_loc a acc\n | Pexp_constant a -> self#constant a acc\n | Pexp_let (a, b, c) ->\n let acc = self#rec_flag a acc in\n let acc = self#list self#value_binding b acc in\n let acc = self#expression c acc in\n acc\n | Pexp_function a -> self#cases a acc\n | Pexp_fun (a, b, c, d) ->\n let acc = self#arg_label a acc in\n let acc = self#option self#expression b acc in\n let acc = self#pattern c acc in\n let acc = self#expression d acc in\n acc\n | Pexp_apply (a, b) ->\n let acc = self#expression a acc in\n let acc =\n self#list\n (fun (a, b) acc ->\n let acc = self#arg_label a acc in\n let acc = self#expression b acc in\n acc)\n b acc\n in\n acc\n | Pexp_match (a, b) ->\n let acc = self#expression a acc in\n let acc = self#cases b acc in\n acc\n | Pexp_try (a, b) ->\n let acc = self#expression a acc in\n let acc = self#cases b acc in\n acc\n | Pexp_tuple a -> self#list self#expression a acc\n | Pexp_construct (a, b) ->\n let acc = self#longident_loc a acc in\n let acc = self#option self#expression b acc in\n acc\n | Pexp_variant (a, b) ->\n let acc = self#label a acc in\n let acc = self#option self#expression b acc in\n acc\n | Pexp_record (a, b) ->\n let acc =\n self#list\n (fun (a, b) acc ->\n let acc = self#longident_loc a acc in\n let acc = self#expression b acc in\n acc)\n a acc\n in\n let acc = self#option self#expression b acc in\n acc\n | Pexp_field (a, b) ->\n let acc = self#expression a acc in\n let acc = self#longident_loc b acc in\n acc\n | Pexp_setfield (a, b, c) ->\n let acc = self#expression a acc in\n let acc = self#longident_loc b acc in\n let acc = self#expression c acc in\n acc\n | Pexp_array a -> self#list self#expression a acc\n | Pexp_ifthenelse (a, b, c) ->\n let acc = self#expression a acc in\n let acc = self#expression b acc in\n let acc = self#option self#expression c acc in\n acc\n | Pexp_sequence (a, b) ->\n let acc = self#expression a acc in\n let acc = self#expression b acc in\n acc\n | Pexp_while (a, b) ->\n let acc = self#expression a acc in\n let acc = self#expression b acc in\n acc\n | Pexp_for (a, b, c, d, e) ->\n let acc = self#pattern a acc in\n let acc = self#expression b acc in\n let acc = self#expression c acc in\n let acc = self#direction_flag d acc in\n let acc = self#expression e acc in\n acc\n | Pexp_constraint (a, b) ->\n let acc = self#expression a acc in\n let acc = self#core_type b acc in\n acc\n | Pexp_coerce (a, b, c) ->\n let acc = self#expression a acc in\n let acc = self#option self#core_type b acc in\n let acc = self#core_type c acc in\n acc\n | Pexp_send (a, b) ->\n let acc = self#expression a acc in\n let acc = self#loc self#label b acc in\n acc\n | Pexp_new a -> self#longident_loc a acc\n | Pexp_setinstvar (a, b) ->\n let acc = self#loc self#label a acc in\n let acc = self#expression b acc in\n acc\n | Pexp_override a ->\n self#list\n (fun (a, b) acc ->\n let acc = self#loc self#label a acc in\n let acc = self#expression b acc in\n acc)\n a acc\n | Pexp_letmodule (a, b, c) ->\n let acc = self#loc (self#option self#string) a acc in\n let acc = self#module_expr b acc in\n let acc = self#expression c acc in\n acc\n | Pexp_letexception (a, b) ->\n let acc = self#extension_constructor a acc in\n let acc = self#expression b acc in\n acc\n | Pexp_assert a -> self#expression a acc\n | Pexp_lazy a -> self#expression a acc\n | Pexp_poly (a, b) ->\n let acc = self#expression a acc in\n let acc = self#option self#core_type b acc in\n acc\n | Pexp_object a -> self#class_structure a acc\n | Pexp_newtype (a, b) ->\n let acc = self#loc self#string a acc in\n let acc = self#expression b acc in\n acc\n | Pexp_pack a -> self#module_expr a acc\n | Pexp_open (a, b) ->\n let acc = self#open_declaration a acc in\n let acc = self#expression b acc in\n acc\n | Pexp_letop a -> self#letop a acc\n | Pexp_extension a -> self#extension a acc\n | Pexp_unreachable -> acc\n\n method case : case -> 'acc -> 'acc =\n fun { pc_lhs; pc_guard; pc_rhs } acc ->\n let acc = self#pattern pc_lhs acc in\n let acc = self#option self#expression pc_guard acc in\n let acc = self#expression pc_rhs acc in\n acc\n\n method letop : letop -> 'acc -> 'acc =\n fun { let_; ands; body } acc ->\n let acc = self#binding_op let_ acc in\n let acc = self#list self#binding_op ands acc in\n let acc = self#expression body acc in\n acc\n\n method binding_op : binding_op -> 'acc -> 'acc =\n fun { pbop_op; pbop_pat; pbop_exp; pbop_loc } acc ->\n let acc = self#loc self#string pbop_op acc in\n let acc = self#pattern pbop_pat acc in\n let acc = self#expression pbop_exp acc in\n let acc = self#location pbop_loc acc in\n acc\n\n method value_description : value_description -> 'acc -> 'acc =\n fun { pval_name; pval_type; pval_prim; pval_attributes; pval_loc } acc ->\n let acc = self#loc self#string pval_name acc in\n let acc = self#core_type pval_type acc in\n let acc = self#list self#string pval_prim acc in\n let acc = self#attributes pval_attributes acc in\n let acc = self#location pval_loc acc in\n acc\n\n method type_declaration : type_declaration -> 'acc -> 'acc =\n fun {\n ptype_name;\n ptype_params;\n ptype_cstrs;\n ptype_kind;\n ptype_private;\n ptype_manifest;\n ptype_attributes;\n ptype_loc;\n } acc ->\n let acc = self#loc self#string ptype_name acc in\n let acc =\n self#list\n (fun (a, b) acc ->\n let acc = self#core_type a acc in\n let acc =\n (fun (a, b) acc ->\n let acc = self#variance a acc in\n let acc = self#injectivity b acc in\n acc)\n b acc\n in\n acc)\n ptype_params acc\n in\n let acc =\n self#list\n (fun (a, b, c) acc ->\n let acc = self#core_type a acc in\n let acc = self#core_type b acc in\n let acc = self#location c acc in\n acc)\n ptype_cstrs acc\n in\n let acc = self#type_kind ptype_kind acc in\n let acc = self#private_flag ptype_private acc in\n let acc = self#option self#core_type ptype_manifest acc in\n let acc = self#attributes ptype_attributes acc in\n let acc = self#location ptype_loc acc in\n acc\n\n method type_kind : type_kind -> 'acc -> 'acc =\n fun x acc ->\n match x with\n | Ptype_abstract -> acc\n | Ptype_variant a -> self#list self#constructor_declaration a acc\n | Ptype_record a -> self#list self#label_declaration a acc\n | Ptype_open -> acc\n\n method label_declaration : label_declaration -> 'acc -> 'acc =\n fun { pld_name; pld_mutable; pld_type; pld_loc; pld_attributes } acc ->\n let acc = self#loc self#string pld_name acc in\n let acc = self#mutable_flag pld_mutable acc in\n let acc = self#core_type pld_type acc in\n let acc = self#location pld_loc acc in\n let acc = self#attributes pld_attributes acc in\n acc\n\n method constructor_declaration : constructor_declaration -> 'acc -> 'acc =\n fun { pcd_name; pcd_args; pcd_res; pcd_loc; pcd_attributes } acc ->\n let acc = self#loc self#string pcd_name acc in\n let acc = self#constructor_arguments pcd_args acc in\n let acc = self#option self#core_type pcd_res acc in\n let acc = self#location pcd_loc acc in\n let acc = self#attributes pcd_attributes acc in\n acc\n\n method constructor_arguments : constructor_arguments -> 'acc -> 'acc =\n fun x acc ->\n match x with\n | Pcstr_tuple a -> self#list self#core_type a acc\n | Pcstr_record a -> self#list self#label_declaration a acc\n\n method type_extension : type_extension -> 'acc -> 'acc =\n fun {\n ptyext_path;\n ptyext_params;\n ptyext_constructors;\n ptyext_private;\n ptyext_loc;\n ptyext_attributes;\n } acc ->\n let acc = self#longident_loc ptyext_path acc in\n let acc =\n self#list\n (fun (a, b) acc ->\n let acc = self#core_type a acc in\n let acc =\n (fun (a, b) acc ->\n let acc = self#variance a acc in\n let acc = self#injectivity b acc in\n acc)\n b acc\n in\n acc)\n ptyext_params acc\n in\n let acc =\n self#list self#extension_constructor ptyext_constructors acc\n in\n let acc = self#private_flag ptyext_private acc in\n let acc = self#location ptyext_loc acc in\n let acc = self#attributes ptyext_attributes acc in\n acc\n\n method extension_constructor : extension_constructor -> 'acc -> 'acc =\n fun { pext_name; pext_kind; pext_loc; pext_attributes } acc ->\n let acc = self#loc self#string pext_name acc in\n let acc = self#extension_constructor_kind pext_kind acc in\n let acc = self#location pext_loc acc in\n let acc = self#attributes pext_attributes acc in\n acc\n\n method type_exception : type_exception -> 'acc -> 'acc =\n fun { ptyexn_constructor; ptyexn_loc; ptyexn_attributes } acc ->\n let acc = self#extension_constructor ptyexn_constructor acc in\n let acc = self#location ptyexn_loc acc in\n let acc = self#attributes ptyexn_attributes acc in\n acc\n\n method extension_constructor_kind\n : extension_constructor_kind -> 'acc -> 'acc =\n fun x acc ->\n match x with\n | Pext_decl (a, b) ->\n let acc = self#constructor_arguments a acc in\n let acc = self#option self#core_type b acc in\n acc\n | Pext_rebind a -> self#longident_loc a acc\n\n method class_type : class_type -> 'acc -> 'acc =\n fun { pcty_desc; pcty_loc; pcty_attributes } acc ->\n let acc = self#class_type_desc pcty_desc acc in\n let acc = self#location pcty_loc acc in\n let acc = self#attributes pcty_attributes acc in\n acc\n\n method class_type_desc : class_type_desc -> 'acc -> 'acc =\n fun x acc ->\n match x with\n | Pcty_constr (a, b) ->\n let acc = self#longident_loc a acc in\n let acc = self#list self#core_type b acc in\n acc\n | Pcty_signature a -> self#class_signature a acc\n | Pcty_arrow (a, b, c) ->\n let acc = self#arg_label a acc in\n let acc = self#core_type b acc in\n let acc = self#class_type c acc in\n acc\n | Pcty_extension a -> self#extension a acc\n | Pcty_open (a, b) ->\n let acc = self#open_description a acc in\n let acc = self#class_type b acc in\n acc\n\n method class_signature : class_signature -> 'acc -> 'acc =\n fun { pcsig_self; pcsig_fields } acc ->\n let acc = self#core_type pcsig_self acc in\n let acc = self#list self#class_type_field pcsig_fields acc in\n acc\n\n method class_type_field : class_type_field -> 'acc -> 'acc =\n fun { pctf_desc; pctf_loc; pctf_attributes } acc ->\n let acc = self#class_type_field_desc pctf_desc acc in\n let acc = self#location pctf_loc acc in\n let acc = self#attributes pctf_attributes acc in\n acc\n\n method class_type_field_desc : class_type_field_desc -> 'acc -> 'acc =\n fun x acc ->\n match x with\n | Pctf_inherit a -> self#class_type a acc\n | Pctf_val a ->\n (fun (a, b, c, d) acc ->\n let acc = self#loc self#label a acc in\n let acc = self#mutable_flag b acc in\n let acc = self#virtual_flag c acc in\n let acc = self#core_type d acc in\n acc)\n a acc\n | Pctf_method a ->\n (fun (a, b, c, d) acc ->\n let acc = self#loc self#label a acc in\n let acc = self#private_flag b acc in\n let acc = self#virtual_flag c acc in\n let acc = self#core_type d acc in\n acc)\n a acc\n | Pctf_constraint a ->\n (fun (a, b) acc ->\n let acc = self#core_type a acc in\n let acc = self#core_type b acc in\n acc)\n a acc\n | Pctf_attribute a -> self#attribute a acc\n | Pctf_extension a -> self#extension a acc\n\n method class_infos\n : 'a. ('a -> 'acc -> 'acc) -> 'a class_infos -> 'acc -> 'acc =\n fun _a\n { pci_virt; pci_params; pci_name; pci_expr; pci_loc; pci_attributes }\n acc ->\n let acc = self#virtual_flag pci_virt acc in\n let acc =\n self#list\n (fun (a, b) acc ->\n let acc = self#core_type a acc in\n let acc =\n (fun (a, b) acc ->\n let acc = self#variance a acc in\n let acc = self#injectivity b acc in\n acc)\n b acc\n in\n acc)\n pci_params acc\n in\n let acc = self#loc self#string pci_name acc in\n let acc = _a pci_expr acc in\n let acc = self#location pci_loc acc in\n let acc = self#attributes pci_attributes acc in\n acc\n\n method class_description : class_description -> 'acc -> 'acc =\n self#class_infos self#class_type\n\n method class_type_declaration : class_type_declaration -> 'acc -> 'acc =\n self#class_infos self#class_type\n\n method class_expr : class_expr -> 'acc -> 'acc =\n fun { pcl_desc; pcl_loc; pcl_attributes } acc ->\n let acc = self#class_expr_desc pcl_desc acc in\n let acc = self#location pcl_loc acc in\n let acc = self#attributes pcl_attributes acc in\n acc\n\n method class_expr_desc : class_expr_desc -> 'acc -> 'acc =\n fun x acc ->\n match x with\n | Pcl_constr (a, b) ->\n let acc = self#longident_loc a acc in\n let acc = self#list self#core_type b acc in\n acc\n | Pcl_structure a -> self#class_structure a acc\n | Pcl_fun (a, b, c, d) ->\n let acc = self#arg_label a acc in\n let acc = self#option self#expression b acc in\n let acc = self#pattern c acc in\n let acc = self#class_expr d acc in\n acc\n | Pcl_apply (a, b) ->\n let acc = self#class_expr a acc in\n let acc =\n self#list\n (fun (a, b) acc ->\n let acc = self#arg_label a acc in\n let acc = self#expression b acc in\n acc)\n b acc\n in\n acc\n | Pcl_let (a, b, c) ->\n let acc = self#rec_flag a acc in\n let acc = self#list self#value_binding b acc in\n let acc = self#class_expr c acc in\n acc\n | Pcl_constraint (a, b) ->\n let acc = self#class_expr a acc in\n let acc = self#class_type b acc in\n acc\n | Pcl_extension a -> self#extension a acc\n | Pcl_open (a, b) ->\n let acc = self#open_description a acc in\n let acc = self#class_expr b acc in\n acc\n\n method class_structure : class_structure -> 'acc -> 'acc =\n fun { pcstr_self; pcstr_fields } acc ->\n let acc = self#pattern pcstr_self acc in\n let acc = self#list self#class_field pcstr_fields acc in\n acc\n\n method class_field : class_field -> 'acc -> 'acc =\n fun { pcf_desc; pcf_loc; pcf_attributes } acc ->\n let acc = self#class_field_desc pcf_desc acc in\n let acc = self#location pcf_loc acc in\n let acc = self#attributes pcf_attributes acc in\n acc\n\n method class_field_desc : class_field_desc -> 'acc -> 'acc =\n fun x acc ->\n match x with\n | Pcf_inherit (a, b, c) ->\n let acc = self#override_flag a acc in\n let acc = self#class_expr b acc in\n let acc = self#option (self#loc self#string) c acc in\n acc\n | Pcf_val a ->\n (fun (a, b, c) acc ->\n let acc = self#loc self#label a acc in\n let acc = self#mutable_flag b acc in\n let acc = self#class_field_kind c acc in\n acc)\n a acc\n | Pcf_method a ->\n (fun (a, b, c) acc ->\n let acc = self#loc self#label a acc in\n let acc = self#private_flag b acc in\n let acc = self#class_field_kind c acc in\n acc)\n a acc\n | Pcf_constraint a ->\n (fun (a, b) acc ->\n let acc = self#core_type a acc in\n let acc = self#core_type b acc in\n acc)\n a acc\n | Pcf_initializer a -> self#expression a acc\n | Pcf_attribute a -> self#attribute a acc\n | Pcf_extension a -> self#extension a acc\n\n method class_field_kind : class_field_kind -> 'acc -> 'acc =\n fun x acc ->\n match x with\n | Cfk_virtual a -> self#core_type a acc\n | Cfk_concrete (a, b) ->\n let acc = self#override_flag a acc in\n let acc = self#expression b acc in\n acc\n\n method class_declaration : class_declaration -> 'acc -> 'acc =\n self#class_infos self#class_expr\n\n method module_type : module_type -> 'acc -> 'acc =\n fun { pmty_desc; pmty_loc; pmty_attributes } acc ->\n let acc = self#module_type_desc pmty_desc acc in\n let acc = self#location pmty_loc acc in\n let acc = self#attributes pmty_attributes acc in\n acc\n\n method module_type_desc : module_type_desc -> 'acc -> 'acc =\n fun x acc ->\n match x with\n | Pmty_ident a -> self#longident_loc a acc\n | Pmty_signature a -> self#signature a acc\n | Pmty_functor (a, b) ->\n let acc = self#functor_parameter a acc in\n let acc = self#module_type b acc in\n acc\n | Pmty_with (a, b) ->\n let acc = self#module_type a acc in\n let acc = self#list self#with_constraint b acc in\n acc\n | Pmty_typeof a -> self#module_expr a acc\n | Pmty_extension a -> self#extension a acc\n | Pmty_alias a -> self#longident_loc a acc\n\n method functor_parameter : functor_parameter -> 'acc -> 'acc =\n fun x acc ->\n match x with\n | Unit -> acc\n | Named (a, b) ->\n let acc = self#loc (self#option self#string) a acc in\n let acc = self#module_type b acc in\n acc\n\n method signature : signature -> 'acc -> 'acc = self#list self#signature_item\n\n method signature_item : signature_item -> 'acc -> 'acc =\n fun { psig_desc; psig_loc } acc ->\n let acc = self#signature_item_desc psig_desc acc in\n let acc = self#location psig_loc acc in\n acc\n\n method signature_item_desc : signature_item_desc -> 'acc -> 'acc =\n fun x acc ->\n match x with\n | Psig_value a -> self#value_description a acc\n | Psig_type (a, b) ->\n let acc = self#rec_flag a acc in\n let acc = self#list self#type_declaration b acc in\n acc\n | Psig_typesubst a -> self#list self#type_declaration a acc\n | Psig_typext a -> self#type_extension a acc\n | Psig_exception a -> self#type_exception a acc\n | Psig_module a -> self#module_declaration a acc\n | Psig_modsubst a -> self#module_substitution a acc\n | Psig_recmodule a -> self#list self#module_declaration a acc\n | Psig_modtype a -> self#module_type_declaration a acc\n | Psig_open a -> self#open_description a acc\n | Psig_include a -> self#include_description a acc\n | Psig_class a -> self#list self#class_description a acc\n | Psig_class_type a -> self#list self#class_type_declaration a acc\n | Psig_attribute a -> self#attribute a acc\n | Psig_extension (a, b) ->\n let acc = self#extension a acc in\n let acc = self#attributes b acc in\n acc\n\n method module_declaration : module_declaration -> 'acc -> 'acc =\n fun { pmd_name; pmd_type; pmd_attributes; pmd_loc } acc ->\n let acc = self#loc (self#option self#string) pmd_name acc in\n let acc = self#module_type pmd_type acc in\n let acc = self#attributes pmd_attributes acc in\n let acc = self#location pmd_loc acc in\n acc\n\n method module_substitution : module_substitution -> 'acc -> 'acc =\n fun { pms_name; pms_manifest; pms_attributes; pms_loc } acc ->\n let acc = self#loc self#string pms_name acc in\n let acc = self#longident_loc pms_manifest acc in\n let acc = self#attributes pms_attributes acc in\n let acc = self#location pms_loc acc in\n acc\n\n method module_type_declaration : module_type_declaration -> 'acc -> 'acc =\n fun { pmtd_name; pmtd_type; pmtd_attributes; pmtd_loc } acc ->\n let acc = self#loc self#string pmtd_name acc in\n let acc = self#option self#module_type pmtd_type acc in\n let acc = self#attributes pmtd_attributes acc in\n let acc = self#location pmtd_loc acc in\n acc\n\n method open_infos\n : 'a. ('a -> 'acc -> 'acc) -> 'a open_infos -> 'acc -> 'acc =\n fun _a { popen_expr; popen_override; popen_loc; popen_attributes } acc ->\n let acc = _a popen_expr acc in\n let acc = self#override_flag popen_override acc in\n let acc = self#location popen_loc acc in\n let acc = self#attributes popen_attributes acc in\n acc\n\n method open_description : open_description -> 'acc -> 'acc =\n self#open_infos self#longident_loc\n\n method open_declaration : open_declaration -> 'acc -> 'acc =\n self#open_infos self#module_expr\n\n method include_infos\n : 'a. ('a -> 'acc -> 'acc) -> 'a include_infos -> 'acc -> 'acc =\n fun _a { pincl_mod; pincl_loc; pincl_attributes } acc ->\n let acc = _a pincl_mod acc in\n let acc = self#location pincl_loc acc in\n let acc = self#attributes pincl_attributes acc in\n acc\n\n method include_description : include_description -> 'acc -> 'acc =\n self#include_infos self#module_type\n\n method include_declaration : include_declaration -> 'acc -> 'acc =\n self#include_infos self#module_expr\n\n method with_constraint : with_constraint -> 'acc -> 'acc =\n fun x acc ->\n match x with\n | Pwith_type (a, b) ->\n let acc = self#longident_loc a acc in\n let acc = self#type_declaration b acc in\n acc\n | Pwith_module (a, b) ->\n let acc = self#longident_loc a acc in\n let acc = self#longident_loc b acc in\n acc\n | Pwith_typesubst (a, b) ->\n let acc = self#longident_loc a acc in\n let acc = self#type_declaration b acc in\n acc\n | Pwith_modsubst (a, b) ->\n let acc = self#longident_loc a acc in\n let acc = self#longident_loc b acc in\n acc\n\n method module_expr : module_expr -> 'acc -> 'acc =\n fun { pmod_desc; pmod_loc; pmod_attributes } acc ->\n let acc = self#module_expr_desc pmod_desc acc in\n let acc = self#location pmod_loc acc in\n let acc = self#attributes pmod_attributes acc in\n acc\n\n method module_expr_desc : module_expr_desc -> 'acc -> 'acc =\n fun x acc ->\n match x with\n | Pmod_ident a -> self#longident_loc a acc\n | Pmod_structure a -> self#structure a acc\n | Pmod_functor (a, b) ->\n let acc = self#functor_parameter a acc in\n let acc = self#module_expr b acc in\n acc\n | Pmod_apply (a, b) ->\n let acc = self#module_expr a acc in\n let acc = self#module_expr b acc in\n acc\n | Pmod_constraint (a, b) ->\n let acc = self#module_expr a acc in\n let acc = self#module_type b acc in\n acc\n | Pmod_unpack a -> self#expression a acc\n | Pmod_extension a -> self#extension a acc\n\n method structure : structure -> 'acc -> 'acc = self#list self#structure_item\n\n method structure_item : structure_item -> 'acc -> 'acc =\n fun { pstr_desc; pstr_loc } acc ->\n let acc = self#structure_item_desc pstr_desc acc in\n let acc = self#location pstr_loc acc in\n acc\n\n method structure_item_desc : structure_item_desc -> 'acc -> 'acc =\n fun x acc ->\n match x with\n | Pstr_eval (a, b) ->\n let acc = self#expression a acc in\n let acc = self#attributes b acc in\n acc\n | Pstr_value (a, b) ->\n let acc = self#rec_flag a acc in\n let acc = self#list self#value_binding b acc in\n acc\n | Pstr_primitive a -> self#value_description a acc\n | Pstr_type (a, b) ->\n let acc = self#rec_flag a acc in\n let acc = self#list self#type_declaration b acc in\n acc\n | Pstr_typext a -> self#type_extension a acc\n | Pstr_exception a -> self#type_exception a acc\n | Pstr_module a -> self#module_binding a acc\n | Pstr_recmodule a -> self#list self#module_binding a acc\n | Pstr_modtype a -> self#module_type_declaration a acc\n | Pstr_open a -> self#open_declaration a acc\n | Pstr_class a -> self#list self#class_declaration a acc\n | Pstr_class_type a -> self#list self#class_type_declaration a acc\n | Pstr_include a -> self#include_declaration a acc\n | Pstr_attribute a -> self#attribute a acc\n | Pstr_extension (a, b) ->\n let acc = self#extension a acc in\n let acc = self#attributes b acc in\n acc\n\n method value_binding : value_binding -> 'acc -> 'acc =\n fun { pvb_pat; pvb_expr; pvb_attributes; pvb_loc } acc ->\n let acc = self#pattern pvb_pat acc in\n let acc = self#expression pvb_expr acc in\n let acc = self#attributes pvb_attributes acc in\n let acc = self#location pvb_loc acc in\n acc\n\n method module_binding : module_binding -> 'acc -> 'acc =\n fun { pmb_name; pmb_expr; pmb_attributes; pmb_loc } acc ->\n let acc = self#loc (self#option self#string) pmb_name acc in\n let acc = self#module_expr pmb_expr acc in\n let acc = self#attributes pmb_attributes acc in\n let acc = self#location pmb_loc acc in\n acc\n\n method toplevel_phrase : toplevel_phrase -> 'acc -> 'acc =\n fun x acc ->\n match x with\n | Ptop_def a -> self#structure a acc\n | Ptop_dir a -> self#toplevel_directive a acc\n\n method toplevel_directive : toplevel_directive -> 'acc -> 'acc =\n fun { pdir_name; pdir_arg; pdir_loc } acc ->\n let acc = self#loc self#string pdir_name acc in\n let acc = self#option self#directive_argument pdir_arg acc in\n let acc = self#location pdir_loc acc in\n acc\n\n method directive_argument : directive_argument -> 'acc -> 'acc =\n fun { pdira_desc; pdira_loc } acc ->\n let acc = self#directive_argument_desc pdira_desc acc in\n let acc = self#location pdira_loc acc in\n acc\n\n method directive_argument_desc : directive_argument_desc -> 'acc -> 'acc =\n fun x acc ->\n match x with\n | Pdir_string a -> self#string a acc\n | Pdir_int (a, b) ->\n let acc = self#string a acc in\n let acc = self#option self#char b acc in\n acc\n | Pdir_ident a -> self#longident a acc\n | Pdir_bool a -> self#bool a acc\n\n method cases : cases -> 'acc -> 'acc = self#list self#case\n end\n\nclass virtual ['acc] fold_map =\n object (self)\n method virtual bool : bool -> 'acc -> bool * 'acc\n method virtual char : char -> 'acc -> char * 'acc\n method virtual int : int -> 'acc -> int * 'acc\n\n method virtual list\n : 'a. ('a -> 'acc -> 'a * 'acc) -> 'a list -> 'acc -> 'a list * 'acc\n\n method virtual option\n : 'a. ('a -> 'acc -> 'a * 'acc) -> 'a option -> 'acc -> 'a option * 'acc\n\n method virtual string : string -> 'acc -> string * 'acc\n\n method position : position -> 'acc -> position * 'acc =\n fun { pos_fname; pos_lnum; pos_bol; pos_cnum } acc ->\n let pos_fname, acc = self#string pos_fname acc in\n let pos_lnum, acc = self#int pos_lnum acc in\n let pos_bol, acc = self#int pos_bol acc in\n let pos_cnum, acc = self#int pos_cnum acc in\n ({ pos_fname; pos_lnum; pos_bol; pos_cnum }, acc)\n\n method location : location -> 'acc -> location * 'acc =\n fun { loc_start; loc_end; loc_ghost } acc ->\n let loc_start, acc = self#position loc_start acc in\n let loc_end, acc = self#position loc_end acc in\n let loc_ghost, acc = self#bool loc_ghost acc in\n ({ loc_start; loc_end; loc_ghost }, acc)\n\n method location_stack : location_stack -> 'acc -> location_stack * 'acc =\n self#list self#location\n\n method loc\n : 'a. ('a -> 'acc -> 'a * 'acc) -> 'a loc -> 'acc -> 'a loc * 'acc =\n fun _a { txt; loc } acc ->\n let txt, acc = _a txt acc in\n let loc, acc = self#location loc acc in\n ({ txt; loc }, acc)\n\n method longident : longident -> 'acc -> longident * 'acc =\n fun x acc ->\n match x with\n | Lident a ->\n let a, acc = self#string a acc in\n (Lident a, acc)\n | Ldot (a, b) ->\n let a, acc = self#longident a acc in\n let b, acc = self#string b acc in\n (Ldot (a, b), acc)\n | Lapply (a, b) ->\n let a, acc = self#longident a acc in\n let b, acc = self#longident b acc in\n (Lapply (a, b), acc)\n\n method longident_loc : longident_loc -> 'acc -> longident_loc * 'acc =\n self#loc self#longident\n\n method rec_flag : rec_flag -> 'acc -> rec_flag * 'acc = fun x acc -> (x, acc)\n\n method direction_flag : direction_flag -> 'acc -> direction_flag * 'acc =\n fun x acc -> (x, acc)\n\n method private_flag : private_flag -> 'acc -> private_flag * 'acc =\n fun x acc -> (x, acc)\n\n method mutable_flag : mutable_flag -> 'acc -> mutable_flag * 'acc =\n fun x acc -> (x, acc)\n\n method virtual_flag : virtual_flag -> 'acc -> virtual_flag * 'acc =\n fun x acc -> (x, acc)\n\n method override_flag : override_flag -> 'acc -> override_flag * 'acc =\n fun x acc -> (x, acc)\n\n method closed_flag : closed_flag -> 'acc -> closed_flag * 'acc =\n fun x acc -> (x, acc)\n\n method label : label -> 'acc -> label * 'acc = self#string\n\n method arg_label : arg_label -> 'acc -> arg_label * 'acc =\n fun x acc ->\n match x with\n | Nolabel -> (Nolabel, acc)\n | Labelled a ->\n let a, acc = self#string a acc in\n (Labelled a, acc)\n | Optional a ->\n let a, acc = self#string a acc in\n (Optional a, acc)\n\n method variance : variance -> 'acc -> variance * 'acc = fun x acc -> (x, acc)\n\n method injectivity : injectivity -> 'acc -> injectivity * 'acc =\n fun x acc -> (x, acc)\n\n method constant : constant -> 'acc -> constant * 'acc =\n fun x acc ->\n match x with\n | Pconst_integer (a, b) ->\n let a, acc = self#string a acc in\n let b, acc = self#option self#char b acc in\n (Pconst_integer (a, b), acc)\n | Pconst_char a ->\n let a, acc = self#char a acc in\n (Pconst_char a, acc)\n | Pconst_string (a, b, c) ->\n let a, acc = self#string a acc in\n let b, acc = self#location b acc in\n let c, acc = self#option self#string c acc in\n (Pconst_string (a, b, c), acc)\n | Pconst_float (a, b) ->\n let a, acc = self#string a acc in\n let b, acc = self#option self#char b acc in\n (Pconst_float (a, b), acc)\n\n method attribute : attribute -> 'acc -> attribute * 'acc =\n fun { attr_name; attr_payload; attr_loc } acc ->\n let attr_name, acc = self#loc self#string attr_name acc in\n let attr_payload, acc = self#payload attr_payload acc in\n let attr_loc, acc = self#location attr_loc acc in\n ({ attr_name; attr_payload; attr_loc }, acc)\n\n method extension : extension -> 'acc -> extension * 'acc =\n fun (a, b) acc ->\n let a, acc = self#loc self#string a acc in\n let b, acc = self#payload b acc in\n ((a, b), acc)\n\n method attributes : attributes -> 'acc -> attributes * 'acc =\n self#list self#attribute\n\n method payload : payload -> 'acc -> payload * 'acc =\n fun x acc ->\n match x with\n | PStr a ->\n let a, acc = self#structure a acc in\n (PStr a, acc)\n | PSig a ->\n let a, acc = self#signature a acc in\n (PSig a, acc)\n | PTyp a ->\n let a, acc = self#core_type a acc in\n (PTyp a, acc)\n | PPat (a, b) ->\n let a, acc = self#pattern a acc in\n let b, acc = self#option self#expression b acc in\n (PPat (a, b), acc)\n\n method core_type : core_type -> 'acc -> core_type * 'acc =\n fun { ptyp_desc; ptyp_loc; ptyp_loc_stack; ptyp_attributes } acc ->\n let ptyp_desc, acc = self#core_type_desc ptyp_desc acc in\n let ptyp_loc, acc = self#location ptyp_loc acc in\n let ptyp_loc_stack, acc = self#location_stack ptyp_loc_stack acc in\n let ptyp_attributes, acc = self#attributes ptyp_attributes acc in\n ({ ptyp_desc; ptyp_loc; ptyp_loc_stack; ptyp_attributes }, acc)\n\n method core_type_desc : core_type_desc -> 'acc -> core_type_desc * 'acc =\n fun x acc ->\n match x with\n | Ptyp_any -> (Ptyp_any, acc)\n | Ptyp_var a ->\n let a, acc = self#string a acc in\n (Ptyp_var a, acc)\n | Ptyp_arrow (a, b, c) ->\n let a, acc = self#arg_label a acc in\n let b, acc = self#core_type b acc in\n let c, acc = self#core_type c acc in\n (Ptyp_arrow (a, b, c), acc)\n | Ptyp_tuple a ->\n let a, acc = self#list self#core_type a acc in\n (Ptyp_tuple a, acc)\n | Ptyp_constr (a, b) ->\n let a, acc = self#longident_loc a acc in\n let b, acc = self#list self#core_type b acc in\n (Ptyp_constr (a, b), acc)\n | Ptyp_object (a, b) ->\n let a, acc = self#list self#object_field a acc in\n let b, acc = self#closed_flag b acc in\n (Ptyp_object (a, b), acc)\n | Ptyp_class (a, b) ->\n let a, acc = self#longident_loc a acc in\n let b, acc = self#list self#core_type b acc in\n (Ptyp_class (a, b), acc)\n | Ptyp_alias (a, b) ->\n let a, acc = self#core_type a acc in\n let b, acc = self#string b acc in\n (Ptyp_alias (a, b), acc)\n | Ptyp_variant (a, b, c) ->\n let a, acc = self#list self#row_field a acc in\n let b, acc = self#closed_flag b acc in\n let c, acc = self#option (self#list self#label) c acc in\n (Ptyp_variant (a, b, c), acc)\n | Ptyp_poly (a, b) ->\n let a, acc = self#list (self#loc self#string) a acc in\n let b, acc = self#core_type b acc in\n (Ptyp_poly (a, b), acc)\n | Ptyp_package a ->\n let a, acc = self#package_type a acc in\n (Ptyp_package a, acc)\n | Ptyp_extension a ->\n let a, acc = self#extension a acc in\n (Ptyp_extension a, acc)\n\n method package_type : package_type -> 'acc -> package_type * 'acc =\n fun (a, b) acc ->\n let a, acc = self#longident_loc a acc in\n let b, acc =\n self#list\n (fun (a, b) acc ->\n let a, acc = self#longident_loc a acc in\n let b, acc = self#core_type b acc in\n ((a, b), acc))\n b acc\n in\n ((a, b), acc)\n\n method row_field : row_field -> 'acc -> row_field * 'acc =\n fun { prf_desc; prf_loc; prf_attributes } acc ->\n let prf_desc, acc = self#row_field_desc prf_desc acc in\n let prf_loc, acc = self#location prf_loc acc in\n let prf_attributes, acc = self#attributes prf_attributes acc in\n ({ prf_desc; prf_loc; prf_attributes }, acc)\n\n method row_field_desc : row_field_desc -> 'acc -> row_field_desc * 'acc =\n fun x acc ->\n match x with\n | Rtag (a, b, c) ->\n let a, acc = self#loc self#label a acc in\n let b, acc = self#bool b acc in\n let c, acc = self#list self#core_type c acc in\n (Rtag (a, b, c), acc)\n | Rinherit a ->\n let a, acc = self#core_type a acc in\n (Rinherit a, acc)\n\n method object_field : object_field -> 'acc -> object_field * 'acc =\n fun { pof_desc; pof_loc; pof_attributes } acc ->\n let pof_desc, acc = self#object_field_desc pof_desc acc in\n let pof_loc, acc = self#location pof_loc acc in\n let pof_attributes, acc = self#attributes pof_attributes acc in\n ({ pof_desc; pof_loc; pof_attributes }, acc)\n\n method object_field_desc\n : object_field_desc -> 'acc -> object_field_desc * 'acc =\n fun x acc ->\n match x with\n | Otag (a, b) ->\n let a, acc = self#loc self#label a acc in\n let b, acc = self#core_type b acc in\n (Otag (a, b), acc)\n | Oinherit a ->\n let a, acc = self#core_type a acc in\n (Oinherit a, acc)\n\n method pattern : pattern -> 'acc -> pattern * 'acc =\n fun { ppat_desc; ppat_loc; ppat_loc_stack; ppat_attributes } acc ->\n let ppat_desc, acc = self#pattern_desc ppat_desc acc in\n let ppat_loc, acc = self#location ppat_loc acc in\n let ppat_loc_stack, acc = self#location_stack ppat_loc_stack acc in\n let ppat_attributes, acc = self#attributes ppat_attributes acc in\n ({ ppat_desc; ppat_loc; ppat_loc_stack; ppat_attributes }, acc)\n\n method pattern_desc : pattern_desc -> 'acc -> pattern_desc * 'acc =\n fun x acc ->\n match x with\n | Ppat_any -> (Ppat_any, acc)\n | Ppat_var a ->\n let a, acc = self#loc self#string a acc in\n (Ppat_var a, acc)\n | Ppat_alias (a, b) ->\n let a, acc = self#pattern a acc in\n let b, acc = self#loc self#string b acc in\n (Ppat_alias (a, b), acc)\n | Ppat_constant a ->\n let a, acc = self#constant a acc in\n (Ppat_constant a, acc)\n | Ppat_interval (a, b) ->\n let a, acc = self#constant a acc in\n let b, acc = self#constant b acc in\n (Ppat_interval (a, b), acc)\n | Ppat_tuple a ->\n let a, acc = self#list self#pattern a acc in\n (Ppat_tuple a, acc)\n | Ppat_construct (a, b) ->\n let a, acc = self#longident_loc a acc in\n let b, acc = self#option self#pattern b acc in\n (Ppat_construct (a, b), acc)\n | Ppat_variant (a, b) ->\n let a, acc = self#label a acc in\n let b, acc = self#option self#pattern b acc in\n (Ppat_variant (a, b), acc)\n | Ppat_record (a, b) ->\n let a, acc =\n self#list\n (fun (a, b) acc ->\n let a, acc = self#longident_loc a acc in\n let b, acc = self#pattern b acc in\n ((a, b), acc))\n a acc\n in\n let b, acc = self#closed_flag b acc in\n (Ppat_record (a, b), acc)\n | Ppat_array a ->\n let a, acc = self#list self#pattern a acc in\n (Ppat_array a, acc)\n | Ppat_or (a, b) ->\n let a, acc = self#pattern a acc in\n let b, acc = self#pattern b acc in\n (Ppat_or (a, b), acc)\n | Ppat_constraint (a, b) ->\n let a, acc = self#pattern a acc in\n let b, acc = self#core_type b acc in\n (Ppat_constraint (a, b), acc)\n | Ppat_type a ->\n let a, acc = self#longident_loc a acc in\n (Ppat_type a, acc)\n | Ppat_lazy a ->\n let a, acc = self#pattern a acc in\n (Ppat_lazy a, acc)\n | Ppat_unpack a ->\n let a, acc = self#loc (self#option self#string) a acc in\n (Ppat_unpack a, acc)\n | Ppat_exception a ->\n let a, acc = self#pattern a acc in\n (Ppat_exception a, acc)\n | Ppat_extension a ->\n let a, acc = self#extension a acc in\n (Ppat_extension a, acc)\n | Ppat_open (a, b) ->\n let a, acc = self#longident_loc a acc in\n let b, acc = self#pattern b acc in\n (Ppat_open (a, b), acc)\n\n method expression : expression -> 'acc -> expression * 'acc =\n fun { pexp_desc; pexp_loc; pexp_loc_stack; pexp_attributes } acc ->\n let pexp_desc, acc = self#expression_desc pexp_desc acc in\n let pexp_loc, acc = self#location pexp_loc acc in\n let pexp_loc_stack, acc = self#location_stack pexp_loc_stack acc in\n let pexp_attributes, acc = self#attributes pexp_attributes acc in\n ({ pexp_desc; pexp_loc; pexp_loc_stack; pexp_attributes }, acc)\n\n method expression_desc : expression_desc -> 'acc -> expression_desc * 'acc =\n fun x acc ->\n match x with\n | Pexp_ident a ->\n let a, acc = self#longident_loc a acc in\n (Pexp_ident a, acc)\n | Pexp_constant a ->\n let a, acc = self#constant a acc in\n (Pexp_constant a, acc)\n | Pexp_let (a, b, c) ->\n let a, acc = self#rec_flag a acc in\n let b, acc = self#list self#value_binding b acc in\n let c, acc = self#expression c acc in\n (Pexp_let (a, b, c), acc)\n | Pexp_function a ->\n let a, acc = self#cases a acc in\n (Pexp_function a, acc)\n | Pexp_fun (a, b, c, d) ->\n let a, acc = self#arg_label a acc in\n let b, acc = self#option self#expression b acc in\n let c, acc = self#pattern c acc in\n let d, acc = self#expression d acc in\n (Pexp_fun (a, b, c, d), acc)\n | Pexp_apply (a, b) ->\n let a, acc = self#expression a acc in\n let b, acc =\n self#list\n (fun (a, b) acc ->\n let a, acc = self#arg_label a acc in\n let b, acc = self#expression b acc in\n ((a, b), acc))\n b acc\n in\n (Pexp_apply (a, b), acc)\n | Pexp_match (a, b) ->\n let a, acc = self#expression a acc in\n let b, acc = self#cases b acc in\n (Pexp_match (a, b), acc)\n | Pexp_try (a, b) ->\n let a, acc = self#expression a acc in\n let b, acc = self#cases b acc in\n (Pexp_try (a, b), acc)\n | Pexp_tuple a ->\n let a, acc = self#list self#expression a acc in\n (Pexp_tuple a, acc)\n | Pexp_construct (a, b) ->\n let a, acc = self#longident_loc a acc in\n let b, acc = self#option self#expression b acc in\n (Pexp_construct (a, b), acc)\n | Pexp_variant (a, b) ->\n let a, acc = self#label a acc in\n let b, acc = self#option self#expression b acc in\n (Pexp_variant (a, b), acc)\n | Pexp_record (a, b) ->\n let a, acc =\n self#list\n (fun (a, b) acc ->\n let a, acc = self#longident_loc a acc in\n let b, acc = self#expression b acc in\n ((a, b), acc))\n a acc\n in\n let b, acc = self#option self#expression b acc in\n (Pexp_record (a, b), acc)\n | Pexp_field (a, b) ->\n let a, acc = self#expression a acc in\n let b, acc = self#longident_loc b acc in\n (Pexp_field (a, b), acc)\n | Pexp_setfield (a, b, c) ->\n let a, acc = self#expression a acc in\n let b, acc = self#longident_loc b acc in\n let c, acc = self#expression c acc in\n (Pexp_setfield (a, b, c), acc)\n | Pexp_array a ->\n let a, acc = self#list self#expression a acc in\n (Pexp_array a, acc)\n | Pexp_ifthenelse (a, b, c) ->\n let a, acc = self#expression a acc in\n let b, acc = self#expression b acc in\n let c, acc = self#option self#expression c acc in\n (Pexp_ifthenelse (a, b, c), acc)\n | Pexp_sequence (a, b) ->\n let a, acc = self#expression a acc in\n let b, acc = self#expression b acc in\n (Pexp_sequence (a, b), acc)\n | Pexp_while (a, b) ->\n let a, acc = self#expression a acc in\n let b, acc = self#expression b acc in\n (Pexp_while (a, b), acc)\n | Pexp_for (a, b, c, d, e) ->\n let a, acc = self#pattern a acc in\n let b, acc = self#expression b acc in\n let c, acc = self#expression c acc in\n let d, acc = self#direction_flag d acc in\n let e, acc = self#expression e acc in\n (Pexp_for (a, b, c, d, e), acc)\n | Pexp_constraint (a, b) ->\n let a, acc = self#expression a acc in\n let b, acc = self#core_type b acc in\n (Pexp_constraint (a, b), acc)\n | Pexp_coerce (a, b, c) ->\n let a, acc = self#expression a acc in\n let b, acc = self#option self#core_type b acc in\n let c, acc = self#core_type c acc in\n (Pexp_coerce (a, b, c), acc)\n | Pexp_send (a, b) ->\n let a, acc = self#expression a acc in\n let b, acc = self#loc self#label b acc in\n (Pexp_send (a, b), acc)\n | Pexp_new a ->\n let a, acc = self#longident_loc a acc in\n (Pexp_new a, acc)\n | Pexp_setinstvar (a, b) ->\n let a, acc = self#loc self#label a acc in\n let b, acc = self#expression b acc in\n (Pexp_setinstvar (a, b), acc)\n | Pexp_override a ->\n let a, acc =\n self#list\n (fun (a, b) acc ->\n let a, acc = self#loc self#label a acc in\n let b, acc = self#expression b acc in\n ((a, b), acc))\n a acc\n in\n (Pexp_override a, acc)\n | Pexp_letmodule (a, b, c) ->\n let a, acc = self#loc (self#option self#string) a acc in\n let b, acc = self#module_expr b acc in\n let c, acc = self#expression c acc in\n (Pexp_letmodule (a, b, c), acc)\n | Pexp_letexception (a, b) ->\n let a, acc = self#extension_constructor a acc in\n let b, acc = self#expression b acc in\n (Pexp_letexception (a, b), acc)\n | Pexp_assert a ->\n let a, acc = self#expression a acc in\n (Pexp_assert a, acc)\n | Pexp_lazy a ->\n let a, acc = self#expression a acc in\n (Pexp_lazy a, acc)\n | Pexp_poly (a, b) ->\n let a, acc = self#expression a acc in\n let b, acc = self#option self#core_type b acc in\n (Pexp_poly (a, b), acc)\n | Pexp_object a ->\n let a, acc = self#class_structure a acc in\n (Pexp_object a, acc)\n | Pexp_newtype (a, b) ->\n let a, acc = self#loc self#string a acc in\n let b, acc = self#expression b acc in\n (Pexp_newtype (a, b), acc)\n | Pexp_pack a ->\n let a, acc = self#module_expr a acc in\n (Pexp_pack a, acc)\n | Pexp_open (a, b) ->\n let a, acc = self#open_declaration a acc in\n let b, acc = self#expression b acc in\n (Pexp_open (a, b), acc)\n | Pexp_letop a ->\n let a, acc = self#letop a acc in\n (Pexp_letop a, acc)\n | Pexp_extension a ->\n let a, acc = self#extension a acc in\n (Pexp_extension a, acc)\n | Pexp_unreachable -> (Pexp_unreachable, acc)\n\n method case : case -> 'acc -> case * 'acc =\n fun { pc_lhs; pc_guard; pc_rhs } acc ->\n let pc_lhs, acc = self#pattern pc_lhs acc in\n let pc_guard, acc = self#option self#expression pc_guard acc in\n let pc_rhs, acc = self#expression pc_rhs acc in\n ({ pc_lhs; pc_guard; pc_rhs }, acc)\n\n method letop : letop -> 'acc -> letop * 'acc =\n fun { let_; ands; body } acc ->\n let let_, acc = self#binding_op let_ acc in\n let ands, acc = self#list self#binding_op ands acc in\n let body, acc = self#expression body acc in\n ({ let_; ands; body }, acc)\n\n method binding_op : binding_op -> 'acc -> binding_op * 'acc =\n fun { pbop_op; pbop_pat; pbop_exp; pbop_loc } acc ->\n let pbop_op, acc = self#loc self#string pbop_op acc in\n let pbop_pat, acc = self#pattern pbop_pat acc in\n let pbop_exp, acc = self#expression pbop_exp acc in\n let pbop_loc, acc = self#location pbop_loc acc in\n ({ pbop_op; pbop_pat; pbop_exp; pbop_loc }, acc)\n\n method value_description\n : value_description -> 'acc -> value_description * 'acc =\n fun { pval_name; pval_type; pval_prim; pval_attributes; pval_loc } acc ->\n let pval_name, acc = self#loc self#string pval_name acc in\n let pval_type, acc = self#core_type pval_type acc in\n let pval_prim, acc = self#list self#string pval_prim acc in\n let pval_attributes, acc = self#attributes pval_attributes acc in\n let pval_loc, acc = self#location pval_loc acc in\n ({ pval_name; pval_type; pval_prim; pval_attributes; pval_loc }, acc)\n\n method type_declaration\n : type_declaration -> 'acc -> type_declaration * 'acc =\n fun {\n ptype_name;\n ptype_params;\n ptype_cstrs;\n ptype_kind;\n ptype_private;\n ptype_manifest;\n ptype_attributes;\n ptype_loc;\n } acc ->\n let ptype_name, acc = self#loc self#string ptype_name acc in\n let ptype_params, acc =\n self#list\n (fun (a, b) acc ->\n let a, acc = self#core_type a acc in\n let b, acc =\n (fun (a, b) acc ->\n let a, acc = self#variance a acc in\n let b, acc = self#injectivity b acc in\n ((a, b), acc))\n b acc\n in\n ((a, b), acc))\n ptype_params acc\n in\n let ptype_cstrs, acc =\n self#list\n (fun (a, b, c) acc ->\n let a, acc = self#core_type a acc in\n let b, acc = self#core_type b acc in\n let c, acc = self#location c acc in\n ((a, b, c), acc))\n ptype_cstrs acc\n in\n let ptype_kind, acc = self#type_kind ptype_kind acc in\n let ptype_private, acc = self#private_flag ptype_private acc in\n let ptype_manifest, acc =\n self#option self#core_type ptype_manifest acc\n in\n let ptype_attributes, acc = self#attributes ptype_attributes acc in\n let ptype_loc, acc = self#location ptype_loc acc in\n ( {\n ptype_name;\n ptype_params;\n ptype_cstrs;\n ptype_kind;\n ptype_private;\n ptype_manifest;\n ptype_attributes;\n ptype_loc;\n },\n acc )\n\n method type_kind : type_kind -> 'acc -> type_kind * 'acc =\n fun x acc ->\n match x with\n | Ptype_abstract -> (Ptype_abstract, acc)\n | Ptype_variant a ->\n let a, acc = self#list self#constructor_declaration a acc in\n (Ptype_variant a, acc)\n | Ptype_record a ->\n let a, acc = self#list self#label_declaration a acc in\n (Ptype_record a, acc)\n | Ptype_open -> (Ptype_open, acc)\n\n method label_declaration\n : label_declaration -> 'acc -> label_declaration * 'acc =\n fun { pld_name; pld_mutable; pld_type; pld_loc; pld_attributes } acc ->\n let pld_name, acc = self#loc self#string pld_name acc in\n let pld_mutable, acc = self#mutable_flag pld_mutable acc in\n let pld_type, acc = self#core_type pld_type acc in\n let pld_loc, acc = self#location pld_loc acc in\n let pld_attributes, acc = self#attributes pld_attributes acc in\n ({ pld_name; pld_mutable; pld_type; pld_loc; pld_attributes }, acc)\n\n method constructor_declaration\n : constructor_declaration -> 'acc -> constructor_declaration * 'acc =\n fun { pcd_name; pcd_args; pcd_res; pcd_loc; pcd_attributes } acc ->\n let pcd_name, acc = self#loc self#string pcd_name acc in\n let pcd_args, acc = self#constructor_arguments pcd_args acc in\n let pcd_res, acc = self#option self#core_type pcd_res acc in\n let pcd_loc, acc = self#location pcd_loc acc in\n let pcd_attributes, acc = self#attributes pcd_attributes acc in\n ({ pcd_name; pcd_args; pcd_res; pcd_loc; pcd_attributes }, acc)\n\n method constructor_arguments\n : constructor_arguments -> 'acc -> constructor_arguments * 'acc =\n fun x acc ->\n match x with\n | Pcstr_tuple a ->\n let a, acc = self#list self#core_type a acc in\n (Pcstr_tuple a, acc)\n | Pcstr_record a ->\n let a, acc = self#list self#label_declaration a acc in\n (Pcstr_record a, acc)\n\n method type_extension : type_extension -> 'acc -> type_extension * 'acc =\n fun {\n ptyext_path;\n ptyext_params;\n ptyext_constructors;\n ptyext_private;\n ptyext_loc;\n ptyext_attributes;\n } acc ->\n let ptyext_path, acc = self#longident_loc ptyext_path acc in\n let ptyext_params, acc =\n self#list\n (fun (a, b) acc ->\n let a, acc = self#core_type a acc in\n let b, acc =\n (fun (a, b) acc ->\n let a, acc = self#variance a acc in\n let b, acc = self#injectivity b acc in\n ((a, b), acc))\n b acc\n in\n ((a, b), acc))\n ptyext_params acc\n in\n let ptyext_constructors, acc =\n self#list self#extension_constructor ptyext_constructors acc\n in\n let ptyext_private, acc = self#private_flag ptyext_private acc in\n let ptyext_loc, acc = self#location ptyext_loc acc in\n let ptyext_attributes, acc = self#attributes ptyext_attributes acc in\n ( {\n ptyext_path;\n ptyext_params;\n ptyext_constructors;\n ptyext_private;\n ptyext_loc;\n ptyext_attributes;\n },\n acc )\n\n method extension_constructor\n : extension_constructor -> 'acc -> extension_constructor * 'acc =\n fun { pext_name; pext_kind; pext_loc; pext_attributes } acc ->\n let pext_name, acc = self#loc self#string pext_name acc in\n let pext_kind, acc = self#extension_constructor_kind pext_kind acc in\n let pext_loc, acc = self#location pext_loc acc in\n let pext_attributes, acc = self#attributes pext_attributes acc in\n ({ pext_name; pext_kind; pext_loc; pext_attributes }, acc)\n\n method type_exception : type_exception -> 'acc -> type_exception * 'acc =\n fun { ptyexn_constructor; ptyexn_loc; ptyexn_attributes } acc ->\n let ptyexn_constructor, acc =\n self#extension_constructor ptyexn_constructor acc\n in\n let ptyexn_loc, acc = self#location ptyexn_loc acc in\n let ptyexn_attributes, acc = self#attributes ptyexn_attributes acc in\n ({ ptyexn_constructor; ptyexn_loc; ptyexn_attributes }, acc)\n\n method extension_constructor_kind\n : extension_constructor_kind ->\n 'acc ->\n extension_constructor_kind * 'acc =\n fun x acc ->\n match x with\n | Pext_decl (a, b) ->\n let a, acc = self#constructor_arguments a acc in\n let b, acc = self#option self#core_type b acc in\n (Pext_decl (a, b), acc)\n | Pext_rebind a ->\n let a, acc = self#longident_loc a acc in\n (Pext_rebind a, acc)\n\n method class_type : class_type -> 'acc -> class_type * 'acc =\n fun { pcty_desc; pcty_loc; pcty_attributes } acc ->\n let pcty_desc, acc = self#class_type_desc pcty_desc acc in\n let pcty_loc, acc = self#location pcty_loc acc in\n let pcty_attributes, acc = self#attributes pcty_attributes acc in\n ({ pcty_desc; pcty_loc; pcty_attributes }, acc)\n\n method class_type_desc : class_type_desc -> 'acc -> class_type_desc * 'acc =\n fun x acc ->\n match x with\n | Pcty_constr (a, b) ->\n let a, acc = self#longident_loc a acc in\n let b, acc = self#list self#core_type b acc in\n (Pcty_constr (a, b), acc)\n | Pcty_signature a ->\n let a, acc = self#class_signature a acc in\n (Pcty_signature a, acc)\n | Pcty_arrow (a, b, c) ->\n let a, acc = self#arg_label a acc in\n let b, acc = self#core_type b acc in\n let c, acc = self#class_type c acc in\n (Pcty_arrow (a, b, c), acc)\n | Pcty_extension a ->\n let a, acc = self#extension a acc in\n (Pcty_extension a, acc)\n | Pcty_open (a, b) ->\n let a, acc = self#open_description a acc in\n let b, acc = self#class_type b acc in\n (Pcty_open (a, b), acc)\n\n method class_signature : class_signature -> 'acc -> class_signature * 'acc =\n fun { pcsig_self; pcsig_fields } acc ->\n let pcsig_self, acc = self#core_type pcsig_self acc in\n let pcsig_fields, acc =\n self#list self#class_type_field pcsig_fields acc\n in\n ({ pcsig_self; pcsig_fields }, acc)\n\n method class_type_field\n : class_type_field -> 'acc -> class_type_field * 'acc =\n fun { pctf_desc; pctf_loc; pctf_attributes } acc ->\n let pctf_desc, acc = self#class_type_field_desc pctf_desc acc in\n let pctf_loc, acc = self#location pctf_loc acc in\n let pctf_attributes, acc = self#attributes pctf_attributes acc in\n ({ pctf_desc; pctf_loc; pctf_attributes }, acc)\n\n method class_type_field_desc\n : class_type_field_desc -> 'acc -> class_type_field_desc * 'acc =\n fun x acc ->\n match x with\n | Pctf_inherit a ->\n let a, acc = self#class_type a acc in\n (Pctf_inherit a, acc)\n | Pctf_val a ->\n let a, acc =\n (fun (a, b, c, d) acc ->\n let a, acc = self#loc self#label a acc in\n let b, acc = self#mutable_flag b acc in\n let c, acc = self#virtual_flag c acc in\n let d, acc = self#core_type d acc in\n ((a, b, c, d), acc))\n a acc\n in\n (Pctf_val a, acc)\n | Pctf_method a ->\n let a, acc =\n (fun (a, b, c, d) acc ->\n let a, acc = self#loc self#label a acc in\n let b, acc = self#private_flag b acc in\n let c, acc = self#virtual_flag c acc in\n let d, acc = self#core_type d acc in\n ((a, b, c, d), acc))\n a acc\n in\n (Pctf_method a, acc)\n | Pctf_constraint a ->\n let a, acc =\n (fun (a, b) acc ->\n let a, acc = self#core_type a acc in\n let b, acc = self#core_type b acc in\n ((a, b), acc))\n a acc\n in\n (Pctf_constraint a, acc)\n | Pctf_attribute a ->\n let a, acc = self#attribute a acc in\n (Pctf_attribute a, acc)\n | Pctf_extension a ->\n let a, acc = self#extension a acc in\n (Pctf_extension a, acc)\n\n method class_infos\n : 'a.\n ('a -> 'acc -> 'a * 'acc) ->\n 'a class_infos ->\n 'acc ->\n 'a class_infos * 'acc =\n fun _a\n { pci_virt; pci_params; pci_name; pci_expr; pci_loc; pci_attributes }\n acc ->\n let pci_virt, acc = self#virtual_flag pci_virt acc in\n let pci_params, acc =\n self#list\n (fun (a, b) acc ->\n let a, acc = self#core_type a acc in\n let b, acc =\n (fun (a, b) acc ->\n let a, acc = self#variance a acc in\n let b, acc = self#injectivity b acc in\n ((a, b), acc))\n b acc\n in\n ((a, b), acc))\n pci_params acc\n in\n let pci_name, acc = self#loc self#string pci_name acc in\n let pci_expr, acc = _a pci_expr acc in\n let pci_loc, acc = self#location pci_loc acc in\n let pci_attributes, acc = self#attributes pci_attributes acc in\n ( { pci_virt; pci_params; pci_name; pci_expr; pci_loc; pci_attributes },\n acc )\n\n method class_description\n : class_description -> 'acc -> class_description * 'acc =\n self#class_infos self#class_type\n\n method class_type_declaration\n : class_type_declaration -> 'acc -> class_type_declaration * 'acc =\n self#class_infos self#class_type\n\n method class_expr : class_expr -> 'acc -> class_expr * 'acc =\n fun { pcl_desc; pcl_loc; pcl_attributes } acc ->\n let pcl_desc, acc = self#class_expr_desc pcl_desc acc in\n let pcl_loc, acc = self#location pcl_loc acc in\n let pcl_attributes, acc = self#attributes pcl_attributes acc in\n ({ pcl_desc; pcl_loc; pcl_attributes }, acc)\n\n method class_expr_desc : class_expr_desc -> 'acc -> class_expr_desc * 'acc =\n fun x acc ->\n match x with\n | Pcl_constr (a, b) ->\n let a, acc = self#longident_loc a acc in\n let b, acc = self#list self#core_type b acc in\n (Pcl_constr (a, b), acc)\n | Pcl_structure a ->\n let a, acc = self#class_structure a acc in\n (Pcl_structure a, acc)\n | Pcl_fun (a, b, c, d) ->\n let a, acc = self#arg_label a acc in\n let b, acc = self#option self#expression b acc in\n let c, acc = self#pattern c acc in\n let d, acc = self#class_expr d acc in\n (Pcl_fun (a, b, c, d), acc)\n | Pcl_apply (a, b) ->\n let a, acc = self#class_expr a acc in\n let b, acc =\n self#list\n (fun (a, b) acc ->\n let a, acc = self#arg_label a acc in\n let b, acc = self#expression b acc in\n ((a, b), acc))\n b acc\n in\n (Pcl_apply (a, b), acc)\n | Pcl_let (a, b, c) ->\n let a, acc = self#rec_flag a acc in\n let b, acc = self#list self#value_binding b acc in\n let c, acc = self#class_expr c acc in\n (Pcl_let (a, b, c), acc)\n | Pcl_constraint (a, b) ->\n let a, acc = self#class_expr a acc in\n let b, acc = self#class_type b acc in\n (Pcl_constraint (a, b), acc)\n | Pcl_extension a ->\n let a, acc = self#extension a acc in\n (Pcl_extension a, acc)\n | Pcl_open (a, b) ->\n let a, acc = self#open_description a acc in\n let b, acc = self#class_expr b acc in\n (Pcl_open (a, b), acc)\n\n method class_structure : class_structure -> 'acc -> class_structure * 'acc =\n fun { pcstr_self; pcstr_fields } acc ->\n let pcstr_self, acc = self#pattern pcstr_self acc in\n let pcstr_fields, acc = self#list self#class_field pcstr_fields acc in\n ({ pcstr_self; pcstr_fields }, acc)\n\n method class_field : class_field -> 'acc -> class_field * 'acc =\n fun { pcf_desc; pcf_loc; pcf_attributes } acc ->\n let pcf_desc, acc = self#class_field_desc pcf_desc acc in\n let pcf_loc, acc = self#location pcf_loc acc in\n let pcf_attributes, acc = self#attributes pcf_attributes acc in\n ({ pcf_desc; pcf_loc; pcf_attributes }, acc)\n\n method class_field_desc\n : class_field_desc -> 'acc -> class_field_desc * 'acc =\n fun x acc ->\n match x with\n | Pcf_inherit (a, b, c) ->\n let a, acc = self#override_flag a acc in\n let b, acc = self#class_expr b acc in\n let c, acc = self#option (self#loc self#string) c acc in\n (Pcf_inherit (a, b, c), acc)\n | Pcf_val a ->\n let a, acc =\n (fun (a, b, c) acc ->\n let a, acc = self#loc self#label a acc in\n let b, acc = self#mutable_flag b acc in\n let c, acc = self#class_field_kind c acc in\n ((a, b, c), acc))\n a acc\n in\n (Pcf_val a, acc)\n | Pcf_method a ->\n let a, acc =\n (fun (a, b, c) acc ->\n let a, acc = self#loc self#label a acc in\n let b, acc = self#private_flag b acc in\n let c, acc = self#class_field_kind c acc in\n ((a, b, c), acc))\n a acc\n in\n (Pcf_method a, acc)\n | Pcf_constraint a ->\n let a, acc =\n (fun (a, b) acc ->\n let a, acc = self#core_type a acc in\n let b, acc = self#core_type b acc in\n ((a, b), acc))\n a acc\n in\n (Pcf_constraint a, acc)\n | Pcf_initializer a ->\n let a, acc = self#expression a acc in\n (Pcf_initializer a, acc)\n | Pcf_attribute a ->\n let a, acc = self#attribute a acc in\n (Pcf_attribute a, acc)\n | Pcf_extension a ->\n let a, acc = self#extension a acc in\n (Pcf_extension a, acc)\n\n method class_field_kind\n : class_field_kind -> 'acc -> class_field_kind * 'acc =\n fun x acc ->\n match x with\n | Cfk_virtual a ->\n let a, acc = self#core_type a acc in\n (Cfk_virtual a, acc)\n | Cfk_concrete (a, b) ->\n let a, acc = self#override_flag a acc in\n let b, acc = self#expression b acc in\n (Cfk_concrete (a, b), acc)\n\n method class_declaration\n : class_declaration -> 'acc -> class_declaration * 'acc =\n self#class_infos self#class_expr\n\n method module_type : module_type -> 'acc -> module_type * 'acc =\n fun { pmty_desc; pmty_loc; pmty_attributes } acc ->\n let pmty_desc, acc = self#module_type_desc pmty_desc acc in\n let pmty_loc, acc = self#location pmty_loc acc in\n let pmty_attributes, acc = self#attributes pmty_attributes acc in\n ({ pmty_desc; pmty_loc; pmty_attributes }, acc)\n\n method module_type_desc\n : module_type_desc -> 'acc -> module_type_desc * 'acc =\n fun x acc ->\n match x with\n | Pmty_ident a ->\n let a, acc = self#longident_loc a acc in\n (Pmty_ident a, acc)\n | Pmty_signature a ->\n let a, acc = self#signature a acc in\n (Pmty_signature a, acc)\n | Pmty_functor (a, b) ->\n let a, acc = self#functor_parameter a acc in\n let b, acc = self#module_type b acc in\n (Pmty_functor (a, b), acc)\n | Pmty_with (a, b) ->\n let a, acc = self#module_type a acc in\n let b, acc = self#list self#with_constraint b acc in\n (Pmty_with (a, b), acc)\n | Pmty_typeof a ->\n let a, acc = self#module_expr a acc in\n (Pmty_typeof a, acc)\n | Pmty_extension a ->\n let a, acc = self#extension a acc in\n (Pmty_extension a, acc)\n | Pmty_alias a ->\n let a, acc = self#longident_loc a acc in\n (Pmty_alias a, acc)\n\n method functor_parameter\n : functor_parameter -> 'acc -> functor_parameter * 'acc =\n fun x acc ->\n match x with\n | Unit -> (Unit, acc)\n | Named (a, b) ->\n let a, acc = self#loc (self#option self#string) a acc in\n let b, acc = self#module_type b acc in\n (Named (a, b), acc)\n\n method signature : signature -> 'acc -> signature * 'acc =\n self#list self#signature_item\n\n method signature_item : signature_item -> 'acc -> signature_item * 'acc =\n fun { psig_desc; psig_loc } acc ->\n let psig_desc, acc = self#signature_item_desc psig_desc acc in\n let psig_loc, acc = self#location psig_loc acc in\n ({ psig_desc; psig_loc }, acc)\n\n method signature_item_desc\n : signature_item_desc -> 'acc -> signature_item_desc * 'acc =\n fun x acc ->\n match x with\n | Psig_value a ->\n let a, acc = self#value_description a acc in\n (Psig_value a, acc)\n | Psig_type (a, b) ->\n let a, acc = self#rec_flag a acc in\n let b, acc = self#list self#type_declaration b acc in\n (Psig_type (a, b), acc)\n | Psig_typesubst a ->\n let a, acc = self#list self#type_declaration a acc in\n (Psig_typesubst a, acc)\n | Psig_typext a ->\n let a, acc = self#type_extension a acc in\n (Psig_typext a, acc)\n | Psig_exception a ->\n let a, acc = self#type_exception a acc in\n (Psig_exception a, acc)\n | Psig_module a ->\n let a, acc = self#module_declaration a acc in\n (Psig_module a, acc)\n | Psig_modsubst a ->\n let a, acc = self#module_substitution a acc in\n (Psig_modsubst a, acc)\n | Psig_recmodule a ->\n let a, acc = self#list self#module_declaration a acc in\n (Psig_recmodule a, acc)\n | Psig_modtype a ->\n let a, acc = self#module_type_declaration a acc in\n (Psig_modtype a, acc)\n | Psig_open a ->\n let a, acc = self#open_description a acc in\n (Psig_open a, acc)\n | Psig_include a ->\n let a, acc = self#include_description a acc in\n (Psig_include a, acc)\n | Psig_class a ->\n let a, acc = self#list self#class_description a acc in\n (Psig_class a, acc)\n | Psig_class_type a ->\n let a, acc = self#list self#class_type_declaration a acc in\n (Psig_class_type a, acc)\n | Psig_attribute a ->\n let a, acc = self#attribute a acc in\n (Psig_attribute a, acc)\n | Psig_extension (a, b) ->\n let a, acc = self#extension a acc in\n let b, acc = self#attributes b acc in\n (Psig_extension (a, b), acc)\n\n method module_declaration\n : module_declaration -> 'acc -> module_declaration * 'acc =\n fun { pmd_name; pmd_type; pmd_attributes; pmd_loc } acc ->\n let pmd_name, acc = self#loc (self#option self#string) pmd_name acc in\n let pmd_type, acc = self#module_type pmd_type acc in\n let pmd_attributes, acc = self#attributes pmd_attributes acc in\n let pmd_loc, acc = self#location pmd_loc acc in\n ({ pmd_name; pmd_type; pmd_attributes; pmd_loc }, acc)\n\n method module_substitution\n : module_substitution -> 'acc -> module_substitution * 'acc =\n fun { pms_name; pms_manifest; pms_attributes; pms_loc } acc ->\n let pms_name, acc = self#loc self#string pms_name acc in\n let pms_manifest, acc = self#longident_loc pms_manifest acc in\n let pms_attributes, acc = self#attributes pms_attributes acc in\n let pms_loc, acc = self#location pms_loc acc in\n ({ pms_name; pms_manifest; pms_attributes; pms_loc }, acc)\n\n method module_type_declaration\n : module_type_declaration -> 'acc -> module_type_declaration * 'acc =\n fun { pmtd_name; pmtd_type; pmtd_attributes; pmtd_loc } acc ->\n let pmtd_name, acc = self#loc self#string pmtd_name acc in\n let pmtd_type, acc = self#option self#module_type pmtd_type acc in\n let pmtd_attributes, acc = self#attributes pmtd_attributes acc in\n let pmtd_loc, acc = self#location pmtd_loc acc in\n ({ pmtd_name; pmtd_type; pmtd_attributes; pmtd_loc }, acc)\n\n method open_infos\n : 'a.\n ('a -> 'acc -> 'a * 'acc) ->\n 'a open_infos ->\n 'acc ->\n 'a open_infos * 'acc =\n fun _a { popen_expr; popen_override; popen_loc; popen_attributes } acc ->\n let popen_expr, acc = _a popen_expr acc in\n let popen_override, acc = self#override_flag popen_override acc in\n let popen_loc, acc = self#location popen_loc acc in\n let popen_attributes, acc = self#attributes popen_attributes acc in\n ({ popen_expr; popen_override; popen_loc; popen_attributes }, acc)\n\n method open_description\n : open_description -> 'acc -> open_description * 'acc =\n self#open_infos self#longident_loc\n\n method open_declaration\n : open_declaration -> 'acc -> open_declaration * 'acc =\n self#open_infos self#module_expr\n\n method include_infos\n : 'a.\n ('a -> 'acc -> 'a * 'acc) ->\n 'a include_infos ->\n 'acc ->\n 'a include_infos * 'acc =\n fun _a { pincl_mod; pincl_loc; pincl_attributes } acc ->\n let pincl_mod, acc = _a pincl_mod acc in\n let pincl_loc, acc = self#location pincl_loc acc in\n let pincl_attributes, acc = self#attributes pincl_attributes acc in\n ({ pincl_mod; pincl_loc; pincl_attributes }, acc)\n\n method include_description\n : include_description -> 'acc -> include_description * 'acc =\n self#include_infos self#module_type\n\n method include_declaration\n : include_declaration -> 'acc -> include_declaration * 'acc =\n self#include_infos self#module_expr\n\n method with_constraint : with_constraint -> 'acc -> with_constraint * 'acc =\n fun x acc ->\n match x with\n | Pwith_type (a, b) ->\n let a, acc = self#longident_loc a acc in\n let b, acc = self#type_declaration b acc in\n (Pwith_type (a, b), acc)\n | Pwith_module (a, b) ->\n let a, acc = self#longident_loc a acc in\n let b, acc = self#longident_loc b acc in\n (Pwith_module (a, b), acc)\n | Pwith_typesubst (a, b) ->\n let a, acc = self#longident_loc a acc in\n let b, acc = self#type_declaration b acc in\n (Pwith_typesubst (a, b), acc)\n | Pwith_modsubst (a, b) ->\n let a, acc = self#longident_loc a acc in\n let b, acc = self#longident_loc b acc in\n (Pwith_modsubst (a, b), acc)\n\n method module_expr : module_expr -> 'acc -> module_expr * 'acc =\n fun { pmod_desc; pmod_loc; pmod_attributes } acc ->\n let pmod_desc, acc = self#module_expr_desc pmod_desc acc in\n let pmod_loc, acc = self#location pmod_loc acc in\n let pmod_attributes, acc = self#attributes pmod_attributes acc in\n ({ pmod_desc; pmod_loc; pmod_attributes }, acc)\n\n method module_expr_desc\n : module_expr_desc -> 'acc -> module_expr_desc * 'acc =\n fun x acc ->\n match x with\n | Pmod_ident a ->\n let a, acc = self#longident_loc a acc in\n (Pmod_ident a, acc)\n | Pmod_structure a ->\n let a, acc = self#structure a acc in\n (Pmod_structure a, acc)\n | Pmod_functor (a, b) ->\n let a, acc = self#functor_parameter a acc in\n let b, acc = self#module_expr b acc in\n (Pmod_functor (a, b), acc)\n | Pmod_apply (a, b) ->\n let a, acc = self#module_expr a acc in\n let b, acc = self#module_expr b acc in\n (Pmod_apply (a, b), acc)\n | Pmod_constraint (a, b) ->\n let a, acc = self#module_expr a acc in\n let b, acc = self#module_type b acc in\n (Pmod_constraint (a, b), acc)\n | Pmod_unpack a ->\n let a, acc = self#expression a acc in\n (Pmod_unpack a, acc)\n | Pmod_extension a ->\n let a, acc = self#extension a acc in\n (Pmod_extension a, acc)\n\n method structure : structure -> 'acc -> structure * 'acc =\n self#list self#structure_item\n\n method structure_item : structure_item -> 'acc -> structure_item * 'acc =\n fun { pstr_desc; pstr_loc } acc ->\n let pstr_desc, acc = self#structure_item_desc pstr_desc acc in\n let pstr_loc, acc = self#location pstr_loc acc in\n ({ pstr_desc; pstr_loc }, acc)\n\n method structure_item_desc\n : structure_item_desc -> 'acc -> structure_item_desc * 'acc =\n fun x acc ->\n match x with\n | Pstr_eval (a, b) ->\n let a, acc = self#expression a acc in\n let b, acc = self#attributes b acc in\n (Pstr_eval (a, b), acc)\n | Pstr_value (a, b) ->\n let a, acc = self#rec_flag a acc in\n let b, acc = self#list self#value_binding b acc in\n (Pstr_value (a, b), acc)\n | Pstr_primitive a ->\n let a, acc = self#value_description a acc in\n (Pstr_primitive a, acc)\n | Pstr_type (a, b) ->\n let a, acc = self#rec_flag a acc in\n let b, acc = self#list self#type_declaration b acc in\n (Pstr_type (a, b), acc)\n | Pstr_typext a ->\n let a, acc = self#type_extension a acc in\n (Pstr_typext a, acc)\n | Pstr_exception a ->\n let a, acc = self#type_exception a acc in\n (Pstr_exception a, acc)\n | Pstr_module a ->\n let a, acc = self#module_binding a acc in\n (Pstr_module a, acc)\n | Pstr_recmodule a ->\n let a, acc = self#list self#module_binding a acc in\n (Pstr_recmodule a, acc)\n | Pstr_modtype a ->\n let a, acc = self#module_type_declaration a acc in\n (Pstr_modtype a, acc)\n | Pstr_open a ->\n let a, acc = self#open_declaration a acc in\n (Pstr_open a, acc)\n | Pstr_class a ->\n let a, acc = self#list self#class_declaration a acc in\n (Pstr_class a, acc)\n | Pstr_class_type a ->\n let a, acc = self#list self#class_type_declaration a acc in\n (Pstr_class_type a, acc)\n | Pstr_include a ->\n let a, acc = self#include_declaration a acc in\n (Pstr_include a, acc)\n | Pstr_attribute a ->\n let a, acc = self#attribute a acc in\n (Pstr_attribute a, acc)\n | Pstr_extension (a, b) ->\n let a, acc = self#extension a acc in\n let b, acc = self#attributes b acc in\n (Pstr_extension (a, b), acc)\n\n method value_binding : value_binding -> 'acc -> value_binding * 'acc =\n fun { pvb_pat; pvb_expr; pvb_attributes; pvb_loc } acc ->\n let pvb_pat, acc = self#pattern pvb_pat acc in\n let pvb_expr, acc = self#expression pvb_expr acc in\n let pvb_attributes, acc = self#attributes pvb_attributes acc in\n let pvb_loc, acc = self#location pvb_loc acc in\n ({ pvb_pat; pvb_expr; pvb_attributes; pvb_loc }, acc)\n\n method module_binding : module_binding -> 'acc -> module_binding * 'acc =\n fun { pmb_name; pmb_expr; pmb_attributes; pmb_loc } acc ->\n let pmb_name, acc = self#loc (self#option self#string) pmb_name acc in\n let pmb_expr, acc = self#module_expr pmb_expr acc in\n let pmb_attributes, acc = self#attributes pmb_attributes acc in\n let pmb_loc, acc = self#location pmb_loc acc in\n ({ pmb_name; pmb_expr; pmb_attributes; pmb_loc }, acc)\n\n method toplevel_phrase : toplevel_phrase -> 'acc -> toplevel_phrase * 'acc =\n fun x acc ->\n match x with\n | Ptop_def a ->\n let a, acc = self#structure a acc in\n (Ptop_def a, acc)\n | Ptop_dir a ->\n let a, acc = self#toplevel_directive a acc in\n (Ptop_dir a, acc)\n\n method toplevel_directive\n : toplevel_directive -> 'acc -> toplevel_directive * 'acc =\n fun { pdir_name; pdir_arg; pdir_loc } acc ->\n let pdir_name, acc = self#loc self#string pdir_name acc in\n let pdir_arg, acc = self#option self#directive_argument pdir_arg acc in\n let pdir_loc, acc = self#location pdir_loc acc in\n ({ pdir_name; pdir_arg; pdir_loc }, acc)\n\n method directive_argument\n : directive_argument -> 'acc -> directive_argument * 'acc =\n fun { pdira_desc; pdira_loc } acc ->\n let pdira_desc, acc = self#directive_argument_desc pdira_desc acc in\n let pdira_loc, acc = self#location pdira_loc acc in\n ({ pdira_desc; pdira_loc }, acc)\n\n method directive_argument_desc\n : directive_argument_desc -> 'acc -> directive_argument_desc * 'acc =\n fun x acc ->\n match x with\n | Pdir_string a ->\n let a, acc = self#string a acc in\n (Pdir_string a, acc)\n | Pdir_int (a, b) ->\n let a, acc = self#string a acc in\n let b, acc = self#option self#char b acc in\n (Pdir_int (a, b), acc)\n | Pdir_ident a ->\n let a, acc = self#longident a acc in\n (Pdir_ident a, acc)\n | Pdir_bool a ->\n let a, acc = self#bool a acc in\n (Pdir_bool a, acc)\n\n method cases : cases -> 'acc -> cases * 'acc = self#list self#case\n end\n\nclass virtual ['ctx] map_with_context =\n object (self)\n method virtual bool : 'ctx -> bool -> bool\n method virtual char : 'ctx -> char -> char\n method virtual int : 'ctx -> int -> int\n method virtual list : 'a. ('ctx -> 'a -> 'a) -> 'ctx -> 'a list -> 'a list\n\n method virtual option\n : 'a. ('ctx -> 'a -> 'a) -> 'ctx -> 'a option -> 'a option\n\n method virtual string : 'ctx -> string -> string\n\n method position : 'ctx -> position -> position =\n fun ctx { pos_fname; pos_lnum; pos_bol; pos_cnum } ->\n let pos_fname = self#string ctx pos_fname in\n let pos_lnum = self#int ctx pos_lnum in\n let pos_bol = self#int ctx pos_bol in\n let pos_cnum = self#int ctx pos_cnum in\n { pos_fname; pos_lnum; pos_bol; pos_cnum }\n\n method location : 'ctx -> location -> location =\n fun ctx { loc_start; loc_end; loc_ghost } ->\n let loc_start = self#position ctx loc_start in\n let loc_end = self#position ctx loc_end in\n let loc_ghost = self#bool ctx loc_ghost in\n { loc_start; loc_end; loc_ghost }\n\n method location_stack : 'ctx -> location_stack -> location_stack =\n self#list self#location\n\n method loc : 'a. ('ctx -> 'a -> 'a) -> 'ctx -> 'a loc -> 'a loc =\n fun _a ctx { txt; loc } ->\n let txt = _a ctx txt in\n let loc = self#location ctx loc in\n { txt; loc }\n\n method longident : 'ctx -> longident -> longident =\n fun ctx x ->\n match x with\n | Lident a ->\n let a = self#string ctx a in\n Lident a\n | Ldot (a, b) ->\n let a = self#longident ctx a in\n let b = self#string ctx b in\n Ldot (a, b)\n | Lapply (a, b) ->\n let a = self#longident ctx a in\n let b = self#longident ctx b in\n Lapply (a, b)\n\n method longident_loc : 'ctx -> longident_loc -> longident_loc =\n self#loc self#longident\n\n method rec_flag : 'ctx -> rec_flag -> rec_flag = fun _ctx x -> x\n\n method direction_flag : 'ctx -> direction_flag -> direction_flag =\n fun _ctx x -> x\n\n method private_flag : 'ctx -> private_flag -> private_flag = fun _ctx x -> x\n method mutable_flag : 'ctx -> mutable_flag -> mutable_flag = fun _ctx x -> x\n method virtual_flag : 'ctx -> virtual_flag -> virtual_flag = fun _ctx x -> x\n\n method override_flag : 'ctx -> override_flag -> override_flag =\n fun _ctx x -> x\n\n method closed_flag : 'ctx -> closed_flag -> closed_flag = fun _ctx x -> x\n method label : 'ctx -> label -> label = self#string\n\n method arg_label : 'ctx -> arg_label -> arg_label =\n fun ctx x ->\n match x with\n | Nolabel -> Nolabel\n | Labelled a ->\n let a = self#string ctx a in\n Labelled a\n | Optional a ->\n let a = self#string ctx a in\n Optional a\n\n method variance : 'ctx -> variance -> variance = fun _ctx x -> x\n method injectivity : 'ctx -> injectivity -> injectivity = fun _ctx x -> x\n\n method constant : 'ctx -> constant -> constant =\n fun ctx x ->\n match x with\n | Pconst_integer (a, b) ->\n let a = self#string ctx a in\n let b = self#option self#char ctx b in\n Pconst_integer (a, b)\n | Pconst_char a ->\n let a = self#char ctx a in\n Pconst_char a\n | Pconst_string (a, b, c) ->\n let a = self#string ctx a in\n let b = self#location ctx b in\n let c = self#option self#string ctx c in\n Pconst_string (a, b, c)\n | Pconst_float (a, b) ->\n let a = self#string ctx a in\n let b = self#option self#char ctx b in\n Pconst_float (a, b)\n\n method attribute : 'ctx -> attribute -> attribute =\n fun ctx { attr_name; attr_payload; attr_loc } ->\n let attr_name = self#loc self#string ctx attr_name in\n let attr_payload = self#payload ctx attr_payload in\n let attr_loc = self#location ctx attr_loc in\n { attr_name; attr_payload; attr_loc }\n\n method extension : 'ctx -> extension -> extension =\n fun ctx (a, b) ->\n let a = self#loc self#string ctx a in\n let b = self#payload ctx b in\n (a, b)\n\n method attributes : 'ctx -> attributes -> attributes =\n self#list self#attribute\n\n method payload : 'ctx -> payload -> payload =\n fun ctx x ->\n match x with\n | PStr a ->\n let a = self#structure ctx a in\n PStr a\n | PSig a ->\n let a = self#signature ctx a in\n PSig a\n | PTyp a ->\n let a = self#core_type ctx a in\n PTyp a\n | PPat (a, b) ->\n let a = self#pattern ctx a in\n let b = self#option self#expression ctx b in\n PPat (a, b)\n\n method core_type : 'ctx -> core_type -> core_type =\n fun ctx { ptyp_desc; ptyp_loc; ptyp_loc_stack; ptyp_attributes } ->\n let ptyp_desc = self#core_type_desc ctx ptyp_desc in\n let ptyp_loc = self#location ctx ptyp_loc in\n let ptyp_loc_stack = self#location_stack ctx ptyp_loc_stack in\n let ptyp_attributes = self#attributes ctx ptyp_attributes in\n { ptyp_desc; ptyp_loc; ptyp_loc_stack; ptyp_attributes }\n\n method core_type_desc : 'ctx -> core_type_desc -> core_type_desc =\n fun ctx x ->\n match x with\n | Ptyp_any -> Ptyp_any\n | Ptyp_var a ->\n let a = self#string ctx a in\n Ptyp_var a\n | Ptyp_arrow (a, b, c) ->\n let a = self#arg_label ctx a in\n let b = self#core_type ctx b in\n let c = self#core_type ctx c in\n Ptyp_arrow (a, b, c)\n | Ptyp_tuple a ->\n let a = self#list self#core_type ctx a in\n Ptyp_tuple a\n | Ptyp_constr (a, b) ->\n let a = self#longident_loc ctx a in\n let b = self#list self#core_type ctx b in\n Ptyp_constr (a, b)\n | Ptyp_object (a, b) ->\n let a = self#list self#object_field ctx a in\n let b = self#closed_flag ctx b in\n Ptyp_object (a, b)\n | Ptyp_class (a, b) ->\n let a = self#longident_loc ctx a in\n let b = self#list self#core_type ctx b in\n Ptyp_class (a, b)\n | Ptyp_alias (a, b) ->\n let a = self#core_type ctx a in\n let b = self#string ctx b in\n Ptyp_alias (a, b)\n | Ptyp_variant (a, b, c) ->\n let a = self#list self#row_field ctx a in\n let b = self#closed_flag ctx b in\n let c = self#option (self#list self#label) ctx c in\n Ptyp_variant (a, b, c)\n | Ptyp_poly (a, b) ->\n let a = self#list (self#loc self#string) ctx a in\n let b = self#core_type ctx b in\n Ptyp_poly (a, b)\n | Ptyp_package a ->\n let a = self#package_type ctx a in\n Ptyp_package a\n | Ptyp_extension a ->\n let a = self#extension ctx a in\n Ptyp_extension a\n\n method package_type : 'ctx -> package_type -> package_type =\n fun ctx (a, b) ->\n let a = self#longident_loc ctx a in\n let b =\n self#list\n (fun ctx (a, b) ->\n let a = self#longident_loc ctx a in\n let b = self#core_type ctx b in\n (a, b))\n ctx b\n in\n (a, b)\n\n method row_field : 'ctx -> row_field -> row_field =\n fun ctx { prf_desc; prf_loc; prf_attributes } ->\n let prf_desc = self#row_field_desc ctx prf_desc in\n let prf_loc = self#location ctx prf_loc in\n let prf_attributes = self#attributes ctx prf_attributes in\n { prf_desc; prf_loc; prf_attributes }\n\n method row_field_desc : 'ctx -> row_field_desc -> row_field_desc =\n fun ctx x ->\n match x with\n | Rtag (a, b, c) ->\n let a = self#loc self#label ctx a in\n let b = self#bool ctx b in\n let c = self#list self#core_type ctx c in\n Rtag (a, b, c)\n | Rinherit a ->\n let a = self#core_type ctx a in\n Rinherit a\n\n method object_field : 'ctx -> object_field -> object_field =\n fun ctx { pof_desc; pof_loc; pof_attributes } ->\n let pof_desc = self#object_field_desc ctx pof_desc in\n let pof_loc = self#location ctx pof_loc in\n let pof_attributes = self#attributes ctx pof_attributes in\n { pof_desc; pof_loc; pof_attributes }\n\n method object_field_desc : 'ctx -> object_field_desc -> object_field_desc =\n fun ctx x ->\n match x with\n | Otag (a, b) ->\n let a = self#loc self#label ctx a in\n let b = self#core_type ctx b in\n Otag (a, b)\n | Oinherit a ->\n let a = self#core_type ctx a in\n Oinherit a\n\n method pattern : 'ctx -> pattern -> pattern =\n fun ctx { ppat_desc; ppat_loc; ppat_loc_stack; ppat_attributes } ->\n let ppat_desc = self#pattern_desc ctx ppat_desc in\n let ppat_loc = self#location ctx ppat_loc in\n let ppat_loc_stack = self#location_stack ctx ppat_loc_stack in\n let ppat_attributes = self#attributes ctx ppat_attributes in\n { ppat_desc; ppat_loc; ppat_loc_stack; ppat_attributes }\n\n method pattern_desc : 'ctx -> pattern_desc -> pattern_desc =\n fun ctx x ->\n match x with\n | Ppat_any -> Ppat_any\n | Ppat_var a ->\n let a = self#loc self#string ctx a in\n Ppat_var a\n | Ppat_alias (a, b) ->\n let a = self#pattern ctx a in\n let b = self#loc self#string ctx b in\n Ppat_alias (a, b)\n | Ppat_constant a ->\n let a = self#constant ctx a in\n Ppat_constant a\n | Ppat_interval (a, b) ->\n let a = self#constant ctx a in\n let b = self#constant ctx b in\n Ppat_interval (a, b)\n | Ppat_tuple a ->\n let a = self#list self#pattern ctx a in\n Ppat_tuple a\n | Ppat_construct (a, b) ->\n let a = self#longident_loc ctx a in\n let b = self#option self#pattern ctx b in\n Ppat_construct (a, b)\n | Ppat_variant (a, b) ->\n let a = self#label ctx a in\n let b = self#option self#pattern ctx b in\n Ppat_variant (a, b)\n | Ppat_record (a, b) ->\n let a =\n self#list\n (fun ctx (a, b) ->\n let a = self#longident_loc ctx a in\n let b = self#pattern ctx b in\n (a, b))\n ctx a\n in\n let b = self#closed_flag ctx b in\n Ppat_record (a, b)\n | Ppat_array a ->\n let a = self#list self#pattern ctx a in\n Ppat_array a\n | Ppat_or (a, b) ->\n let a = self#pattern ctx a in\n let b = self#pattern ctx b in\n Ppat_or (a, b)\n | Ppat_constraint (a, b) ->\n let a = self#pattern ctx a in\n let b = self#core_type ctx b in\n Ppat_constraint (a, b)\n | Ppat_type a ->\n let a = self#longident_loc ctx a in\n Ppat_type a\n | Ppat_lazy a ->\n let a = self#pattern ctx a in\n Ppat_lazy a\n | Ppat_unpack a ->\n let a = self#loc (self#option self#string) ctx a in\n Ppat_unpack a\n | Ppat_exception a ->\n let a = self#pattern ctx a in\n Ppat_exception a\n | Ppat_extension a ->\n let a = self#extension ctx a in\n Ppat_extension a\n | Ppat_open (a, b) ->\n let a = self#longident_loc ctx a in\n let b = self#pattern ctx b in\n Ppat_open (a, b)\n\n method expression : 'ctx -> expression -> expression =\n fun ctx { pexp_desc; pexp_loc; pexp_loc_stack; pexp_attributes } ->\n let pexp_desc = self#expression_desc ctx pexp_desc in\n let pexp_loc = self#location ctx pexp_loc in\n let pexp_loc_stack = self#location_stack ctx pexp_loc_stack in\n let pexp_attributes = self#attributes ctx pexp_attributes in\n { pexp_desc; pexp_loc; pexp_loc_stack; pexp_attributes }\n\n method expression_desc : 'ctx -> expression_desc -> expression_desc =\n fun ctx x ->\n match x with\n | Pexp_ident a ->\n let a = self#longident_loc ctx a in\n Pexp_ident a\n | Pexp_constant a ->\n let a = self#constant ctx a in\n Pexp_constant a\n | Pexp_let (a, b, c) ->\n let a = self#rec_flag ctx a in\n let b = self#list self#value_binding ctx b in\n let c = self#expression ctx c in\n Pexp_let (a, b, c)\n | Pexp_function a ->\n let a = self#cases ctx a in\n Pexp_function a\n | Pexp_fun (a, b, c, d) ->\n let a = self#arg_label ctx a in\n let b = self#option self#expression ctx b in\n let c = self#pattern ctx c in\n let d = self#expression ctx d in\n Pexp_fun (a, b, c, d)\n | Pexp_apply (a, b) ->\n let a = self#expression ctx a in\n let b =\n self#list\n (fun ctx (a, b) ->\n let a = self#arg_label ctx a in\n let b = self#expression ctx b in\n (a, b))\n ctx b\n in\n Pexp_apply (a, b)\n | Pexp_match (a, b) ->\n let a = self#expression ctx a in\n let b = self#cases ctx b in\n Pexp_match (a, b)\n | Pexp_try (a, b) ->\n let a = self#expression ctx a in\n let b = self#cases ctx b in\n Pexp_try (a, b)\n | Pexp_tuple a ->\n let a = self#list self#expression ctx a in\n Pexp_tuple a\n | Pexp_construct (a, b) ->\n let a = self#longident_loc ctx a in\n let b = self#option self#expression ctx b in\n Pexp_construct (a, b)\n | Pexp_variant (a, b) ->\n let a = self#label ctx a in\n let b = self#option self#expression ctx b in\n Pexp_variant (a, b)\n | Pexp_record (a, b) ->\n let a =\n self#list\n (fun ctx (a, b) ->\n let a = self#longident_loc ctx a in\n let b = self#expression ctx b in\n (a, b))\n ctx a\n in\n let b = self#option self#expression ctx b in\n Pexp_record (a, b)\n | Pexp_field (a, b) ->\n let a = self#expression ctx a in\n let b = self#longident_loc ctx b in\n Pexp_field (a, b)\n | Pexp_setfield (a, b, c) ->\n let a = self#expression ctx a in\n let b = self#longident_loc ctx b in\n let c = self#expression ctx c in\n Pexp_setfield (a, b, c)\n | Pexp_array a ->\n let a = self#list self#expression ctx a in\n Pexp_array a\n | Pexp_ifthenelse (a, b, c) ->\n let a = self#expression ctx a in\n let b = self#expression ctx b in\n let c = self#option self#expression ctx c in\n Pexp_ifthenelse (a, b, c)\n | Pexp_sequence (a, b) ->\n let a = self#expression ctx a in\n let b = self#expression ctx b in\n Pexp_sequence (a, b)\n | Pexp_while (a, b) ->\n let a = self#expression ctx a in\n let b = self#expression ctx b in\n Pexp_while (a, b)\n | Pexp_for (a, b, c, d, e) ->\n let a = self#pattern ctx a in\n let b = self#expression ctx b in\n let c = self#expression ctx c in\n let d = self#direction_flag ctx d in\n let e = self#expression ctx e in\n Pexp_for (a, b, c, d, e)\n | Pexp_constraint (a, b) ->\n let a = self#expression ctx a in\n let b = self#core_type ctx b in\n Pexp_constraint (a, b)\n | Pexp_coerce (a, b, c) ->\n let a = self#expression ctx a in\n let b = self#option self#core_type ctx b in\n let c = self#core_type ctx c in\n Pexp_coerce (a, b, c)\n | Pexp_send (a, b) ->\n let a = self#expression ctx a in\n let b = self#loc self#label ctx b in\n Pexp_send (a, b)\n | Pexp_new a ->\n let a = self#longident_loc ctx a in\n Pexp_new a\n | Pexp_setinstvar (a, b) ->\n let a = self#loc self#label ctx a in\n let b = self#expression ctx b in\n Pexp_setinstvar (a, b)\n | Pexp_override a ->\n let a =\n self#list\n (fun ctx (a, b) ->\n let a = self#loc self#label ctx a in\n let b = self#expression ctx b in\n (a, b))\n ctx a\n in\n Pexp_override a\n | Pexp_letmodule (a, b, c) ->\n let a = self#loc (self#option self#string) ctx a in\n let b = self#module_expr ctx b in\n let c = self#expression ctx c in\n Pexp_letmodule (a, b, c)\n | Pexp_letexception (a, b) ->\n let a = self#extension_constructor ctx a in\n let b = self#expression ctx b in\n Pexp_letexception (a, b)\n | Pexp_assert a ->\n let a = self#expression ctx a in\n Pexp_assert a\n | Pexp_lazy a ->\n let a = self#expression ctx a in\n Pexp_lazy a\n | Pexp_poly (a, b) ->\n let a = self#expression ctx a in\n let b = self#option self#core_type ctx b in\n Pexp_poly (a, b)\n | Pexp_object a ->\n let a = self#class_structure ctx a in\n Pexp_object a\n | Pexp_newtype (a, b) ->\n let a = self#loc self#string ctx a in\n let b = self#expression ctx b in\n Pexp_newtype (a, b)\n | Pexp_pack a ->\n let a = self#module_expr ctx a in\n Pexp_pack a\n | Pexp_open (a, b) ->\n let a = self#open_declaration ctx a in\n let b = self#expression ctx b in\n Pexp_open (a, b)\n | Pexp_letop a ->\n let a = self#letop ctx a in\n Pexp_letop a\n | Pexp_extension a ->\n let a = self#extension ctx a in\n Pexp_extension a\n | Pexp_unreachable -> Pexp_unreachable\n\n method case : 'ctx -> case -> case =\n fun ctx { pc_lhs; pc_guard; pc_rhs } ->\n let pc_lhs = self#pattern ctx pc_lhs in\n let pc_guard = self#option self#expression ctx pc_guard in\n let pc_rhs = self#expression ctx pc_rhs in\n { pc_lhs; pc_guard; pc_rhs }\n\n method letop : 'ctx -> letop -> letop =\n fun ctx { let_; ands; body } ->\n let let_ = self#binding_op ctx let_ in\n let ands = self#list self#binding_op ctx ands in\n let body = self#expression ctx body in\n { let_; ands; body }\n\n method binding_op : 'ctx -> binding_op -> binding_op =\n fun ctx { pbop_op; pbop_pat; pbop_exp; pbop_loc } ->\n let pbop_op = self#loc self#string ctx pbop_op in\n let pbop_pat = self#pattern ctx pbop_pat in\n let pbop_exp = self#expression ctx pbop_exp in\n let pbop_loc = self#location ctx pbop_loc in\n { pbop_op; pbop_pat; pbop_exp; pbop_loc }\n\n method value_description : 'ctx -> value_description -> value_description =\n fun ctx { pval_name; pval_type; pval_prim; pval_attributes; pval_loc } ->\n let pval_name = self#loc self#string ctx pval_name in\n let pval_type = self#core_type ctx pval_type in\n let pval_prim = self#list self#string ctx pval_prim in\n let pval_attributes = self#attributes ctx pval_attributes in\n let pval_loc = self#location ctx pval_loc in\n { pval_name; pval_type; pval_prim; pval_attributes; pval_loc }\n\n method type_declaration : 'ctx -> type_declaration -> type_declaration =\n fun ctx\n {\n ptype_name;\n ptype_params;\n ptype_cstrs;\n ptype_kind;\n ptype_private;\n ptype_manifest;\n ptype_attributes;\n ptype_loc;\n } ->\n let ptype_name = self#loc self#string ctx ptype_name in\n let ptype_params =\n self#list\n (fun ctx (a, b) ->\n let a = self#core_type ctx a in\n let b =\n (fun ctx (a, b) ->\n let a = self#variance ctx a in\n let b = self#injectivity ctx b in\n (a, b))\n ctx b\n in\n (a, b))\n ctx ptype_params\n in\n let ptype_cstrs =\n self#list\n (fun ctx (a, b, c) ->\n let a = self#core_type ctx a in\n let b = self#core_type ctx b in\n let c = self#location ctx c in\n (a, b, c))\n ctx ptype_cstrs\n in\n let ptype_kind = self#type_kind ctx ptype_kind in\n let ptype_private = self#private_flag ctx ptype_private in\n let ptype_manifest = self#option self#core_type ctx ptype_manifest in\n let ptype_attributes = self#attributes ctx ptype_attributes in\n let ptype_loc = self#location ctx ptype_loc in\n {\n ptype_name;\n ptype_params;\n ptype_cstrs;\n ptype_kind;\n ptype_private;\n ptype_manifest;\n ptype_attributes;\n ptype_loc;\n }\n\n method type_kind : 'ctx -> type_kind -> type_kind =\n fun ctx x ->\n match x with\n | Ptype_abstract -> Ptype_abstract\n | Ptype_variant a ->\n let a = self#list self#constructor_declaration ctx a in\n Ptype_variant a\n | Ptype_record a ->\n let a = self#list self#label_declaration ctx a in\n Ptype_record a\n | Ptype_open -> Ptype_open\n\n method label_declaration : 'ctx -> label_declaration -> label_declaration =\n fun ctx { pld_name; pld_mutable; pld_type; pld_loc; pld_attributes } ->\n let pld_name = self#loc self#string ctx pld_name in\n let pld_mutable = self#mutable_flag ctx pld_mutable in\n let pld_type = self#core_type ctx pld_type in\n let pld_loc = self#location ctx pld_loc in\n let pld_attributes = self#attributes ctx pld_attributes in\n { pld_name; pld_mutable; pld_type; pld_loc; pld_attributes }\n\n method constructor_declaration\n : 'ctx -> constructor_declaration -> constructor_declaration =\n fun ctx { pcd_name; pcd_args; pcd_res; pcd_loc; pcd_attributes } ->\n let pcd_name = self#loc self#string ctx pcd_name in\n let pcd_args = self#constructor_arguments ctx pcd_args in\n let pcd_res = self#option self#core_type ctx pcd_res in\n let pcd_loc = self#location ctx pcd_loc in\n let pcd_attributes = self#attributes ctx pcd_attributes in\n { pcd_name; pcd_args; pcd_res; pcd_loc; pcd_attributes }\n\n method constructor_arguments\n : 'ctx -> constructor_arguments -> constructor_arguments =\n fun ctx x ->\n match x with\n | Pcstr_tuple a ->\n let a = self#list self#core_type ctx a in\n Pcstr_tuple a\n | Pcstr_record a ->\n let a = self#list self#label_declaration ctx a in\n Pcstr_record a\n\n method type_extension : 'ctx -> type_extension -> type_extension =\n fun ctx\n {\n ptyext_path;\n ptyext_params;\n ptyext_constructors;\n ptyext_private;\n ptyext_loc;\n ptyext_attributes;\n } ->\n let ptyext_path = self#longident_loc ctx ptyext_path in\n let ptyext_params =\n self#list\n (fun ctx (a, b) ->\n let a = self#core_type ctx a in\n let b =\n (fun ctx (a, b) ->\n let a = self#variance ctx a in\n let b = self#injectivity ctx b in\n (a, b))\n ctx b\n in\n (a, b))\n ctx ptyext_params\n in\n let ptyext_constructors =\n self#list self#extension_constructor ctx ptyext_constructors\n in\n let ptyext_private = self#private_flag ctx ptyext_private in\n let ptyext_loc = self#location ctx ptyext_loc in\n let ptyext_attributes = self#attributes ctx ptyext_attributes in\n {\n ptyext_path;\n ptyext_params;\n ptyext_constructors;\n ptyext_private;\n ptyext_loc;\n ptyext_attributes;\n }\n\n method extension_constructor\n : 'ctx -> extension_constructor -> extension_constructor =\n fun ctx { pext_name; pext_kind; pext_loc; pext_attributes } ->\n let pext_name = self#loc self#string ctx pext_name in\n let pext_kind = self#extension_constructor_kind ctx pext_kind in\n let pext_loc = self#location ctx pext_loc in\n let pext_attributes = self#attributes ctx pext_attributes in\n { pext_name; pext_kind; pext_loc; pext_attributes }\n\n method type_exception : 'ctx -> type_exception -> type_exception =\n fun ctx { ptyexn_constructor; ptyexn_loc; ptyexn_attributes } ->\n let ptyexn_constructor =\n self#extension_constructor ctx ptyexn_constructor\n in\n let ptyexn_loc = self#location ctx ptyexn_loc in\n let ptyexn_attributes = self#attributes ctx ptyexn_attributes in\n { ptyexn_constructor; ptyexn_loc; ptyexn_attributes }\n\n method extension_constructor_kind\n : 'ctx -> extension_constructor_kind -> extension_constructor_kind =\n fun ctx x ->\n match x with\n | Pext_decl (a, b) ->\n let a = self#constructor_arguments ctx a in\n let b = self#option self#core_type ctx b in\n Pext_decl (a, b)\n | Pext_rebind a ->\n let a = self#longident_loc ctx a in\n Pext_rebind a\n\n method class_type : 'ctx -> class_type -> class_type =\n fun ctx { pcty_desc; pcty_loc; pcty_attributes } ->\n let pcty_desc = self#class_type_desc ctx pcty_desc in\n let pcty_loc = self#location ctx pcty_loc in\n let pcty_attributes = self#attributes ctx pcty_attributes in\n { pcty_desc; pcty_loc; pcty_attributes }\n\n method class_type_desc : 'ctx -> class_type_desc -> class_type_desc =\n fun ctx x ->\n match x with\n | Pcty_constr (a, b) ->\n let a = self#longident_loc ctx a in\n let b = self#list self#core_type ctx b in\n Pcty_constr (a, b)\n | Pcty_signature a ->\n let a = self#class_signature ctx a in\n Pcty_signature a\n | Pcty_arrow (a, b, c) ->\n let a = self#arg_label ctx a in\n let b = self#core_type ctx b in\n let c = self#class_type ctx c in\n Pcty_arrow (a, b, c)\n | Pcty_extension a ->\n let a = self#extension ctx a in\n Pcty_extension a\n | Pcty_open (a, b) ->\n let a = self#open_description ctx a in\n let b = self#class_type ctx b in\n Pcty_open (a, b)\n\n method class_signature : 'ctx -> class_signature -> class_signature =\n fun ctx { pcsig_self; pcsig_fields } ->\n let pcsig_self = self#core_type ctx pcsig_self in\n let pcsig_fields = self#list self#class_type_field ctx pcsig_fields in\n { pcsig_self; pcsig_fields }\n\n method class_type_field : 'ctx -> class_type_field -> class_type_field =\n fun ctx { pctf_desc; pctf_loc; pctf_attributes } ->\n let pctf_desc = self#class_type_field_desc ctx pctf_desc in\n let pctf_loc = self#location ctx pctf_loc in\n let pctf_attributes = self#attributes ctx pctf_attributes in\n { pctf_desc; pctf_loc; pctf_attributes }\n\n method class_type_field_desc\n : 'ctx -> class_type_field_desc -> class_type_field_desc =\n fun ctx x ->\n match x with\n | Pctf_inherit a ->\n let a = self#class_type ctx a in\n Pctf_inherit a\n | Pctf_val a ->\n let a =\n (fun ctx (a, b, c, d) ->\n let a = self#loc self#label ctx a in\n let b = self#mutable_flag ctx b in\n let c = self#virtual_flag ctx c in\n let d = self#core_type ctx d in\n (a, b, c, d))\n ctx a\n in\n Pctf_val a\n | Pctf_method a ->\n let a =\n (fun ctx (a, b, c, d) ->\n let a = self#loc self#label ctx a in\n let b = self#private_flag ctx b in\n let c = self#virtual_flag ctx c in\n let d = self#core_type ctx d in\n (a, b, c, d))\n ctx a\n in\n Pctf_method a\n | Pctf_constraint a ->\n let a =\n (fun ctx (a, b) ->\n let a = self#core_type ctx a in\n let b = self#core_type ctx b in\n (a, b))\n ctx a\n in\n Pctf_constraint a\n | Pctf_attribute a ->\n let a = self#attribute ctx a in\n Pctf_attribute a\n | Pctf_extension a ->\n let a = self#extension ctx a in\n Pctf_extension a\n\n method class_infos\n : 'a. ('ctx -> 'a -> 'a) -> 'ctx -> 'a class_infos -> 'a class_infos =\n fun _a ctx\n { pci_virt; pci_params; pci_name; pci_expr; pci_loc; pci_attributes } ->\n let pci_virt = self#virtual_flag ctx pci_virt in\n let pci_params =\n self#list\n (fun ctx (a, b) ->\n let a = self#core_type ctx a in\n let b =\n (fun ctx (a, b) ->\n let a = self#variance ctx a in\n let b = self#injectivity ctx b in\n (a, b))\n ctx b\n in\n (a, b))\n ctx pci_params\n in\n let pci_name = self#loc self#string ctx pci_name in\n let pci_expr = _a ctx pci_expr in\n let pci_loc = self#location ctx pci_loc in\n let pci_attributes = self#attributes ctx pci_attributes in\n { pci_virt; pci_params; pci_name; pci_expr; pci_loc; pci_attributes }\n\n method class_description : 'ctx -> class_description -> class_description =\n self#class_infos self#class_type\n\n method class_type_declaration\n : 'ctx -> class_type_declaration -> class_type_declaration =\n self#class_infos self#class_type\n\n method class_expr : 'ctx -> class_expr -> class_expr =\n fun ctx { pcl_desc; pcl_loc; pcl_attributes } ->\n let pcl_desc = self#class_expr_desc ctx pcl_desc in\n let pcl_loc = self#location ctx pcl_loc in\n let pcl_attributes = self#attributes ctx pcl_attributes in\n { pcl_desc; pcl_loc; pcl_attributes }\n\n method class_expr_desc : 'ctx -> class_expr_desc -> class_expr_desc =\n fun ctx x ->\n match x with\n | Pcl_constr (a, b) ->\n let a = self#longident_loc ctx a in\n let b = self#list self#core_type ctx b in\n Pcl_constr (a, b)\n | Pcl_structure a ->\n let a = self#class_structure ctx a in\n Pcl_structure a\n | Pcl_fun (a, b, c, d) ->\n let a = self#arg_label ctx a in\n let b = self#option self#expression ctx b in\n let c = self#pattern ctx c in\n let d = self#class_expr ctx d in\n Pcl_fun (a, b, c, d)\n | Pcl_apply (a, b) ->\n let a = self#class_expr ctx a in\n let b =\n self#list\n (fun ctx (a, b) ->\n let a = self#arg_label ctx a in\n let b = self#expression ctx b in\n (a, b))\n ctx b\n in\n Pcl_apply (a, b)\n | Pcl_let (a, b, c) ->\n let a = self#rec_flag ctx a in\n let b = self#list self#value_binding ctx b in\n let c = self#class_expr ctx c in\n Pcl_let (a, b, c)\n | Pcl_constraint (a, b) ->\n let a = self#class_expr ctx a in\n let b = self#class_type ctx b in\n Pcl_constraint (a, b)\n | Pcl_extension a ->\n let a = self#extension ctx a in\n Pcl_extension a\n | Pcl_open (a, b) ->\n let a = self#open_description ctx a in\n let b = self#class_expr ctx b in\n Pcl_open (a, b)\n\n method class_structure : 'ctx -> class_structure -> class_structure =\n fun ctx { pcstr_self; pcstr_fields } ->\n let pcstr_self = self#pattern ctx pcstr_self in\n let pcstr_fields = self#list self#class_field ctx pcstr_fields in\n { pcstr_self; pcstr_fields }\n\n method class_field : 'ctx -> class_field -> class_field =\n fun ctx { pcf_desc; pcf_loc; pcf_attributes } ->\n let pcf_desc = self#class_field_desc ctx pcf_desc in\n let pcf_loc = self#location ctx pcf_loc in\n let pcf_attributes = self#attributes ctx pcf_attributes in\n { pcf_desc; pcf_loc; pcf_attributes }\n\n method class_field_desc : 'ctx -> class_field_desc -> class_field_desc =\n fun ctx x ->\n match x with\n | Pcf_inherit (a, b, c) ->\n let a = self#override_flag ctx a in\n let b = self#class_expr ctx b in\n let c = self#option (self#loc self#string) ctx c in\n Pcf_inherit (a, b, c)\n | Pcf_val a ->\n let a =\n (fun ctx (a, b, c) ->\n let a = self#loc self#label ctx a in\n let b = self#mutable_flag ctx b in\n let c = self#class_field_kind ctx c in\n (a, b, c))\n ctx a\n in\n Pcf_val a\n | Pcf_method a ->\n let a =\n (fun ctx (a, b, c) ->\n let a = self#loc self#label ctx a in\n let b = self#private_flag ctx b in\n let c = self#class_field_kind ctx c in\n (a, b, c))\n ctx a\n in\n Pcf_method a\n | Pcf_constraint a ->\n let a =\n (fun ctx (a, b) ->\n let a = self#core_type ctx a in\n let b = self#core_type ctx b in\n (a, b))\n ctx a\n in\n Pcf_constraint a\n | Pcf_initializer a ->\n let a = self#expression ctx a in\n Pcf_initializer a\n | Pcf_attribute a ->\n let a = self#attribute ctx a in\n Pcf_attribute a\n | Pcf_extension a ->\n let a = self#extension ctx a in\n Pcf_extension a\n\n method class_field_kind : 'ctx -> class_field_kind -> class_field_kind =\n fun ctx x ->\n match x with\n | Cfk_virtual a ->\n let a = self#core_type ctx a in\n Cfk_virtual a\n | Cfk_concrete (a, b) ->\n let a = self#override_flag ctx a in\n let b = self#expression ctx b in\n Cfk_concrete (a, b)\n\n method class_declaration : 'ctx -> class_declaration -> class_declaration =\n self#class_infos self#class_expr\n\n method module_type : 'ctx -> module_type -> module_type =\n fun ctx { pmty_desc; pmty_loc; pmty_attributes } ->\n let pmty_desc = self#module_type_desc ctx pmty_desc in\n let pmty_loc = self#location ctx pmty_loc in\n let pmty_attributes = self#attributes ctx pmty_attributes in\n { pmty_desc; pmty_loc; pmty_attributes }\n\n method module_type_desc : 'ctx -> module_type_desc -> module_type_desc =\n fun ctx x ->\n match x with\n | Pmty_ident a ->\n let a = self#longident_loc ctx a in\n Pmty_ident a\n | Pmty_signature a ->\n let a = self#signature ctx a in\n Pmty_signature a\n | Pmty_functor (a, b) ->\n let a = self#functor_parameter ctx a in\n let b = self#module_type ctx b in\n Pmty_functor (a, b)\n | Pmty_with (a, b) ->\n let a = self#module_type ctx a in\n let b = self#list self#with_constraint ctx b in\n Pmty_with (a, b)\n | Pmty_typeof a ->\n let a = self#module_expr ctx a in\n Pmty_typeof a\n | Pmty_extension a ->\n let a = self#extension ctx a in\n Pmty_extension a\n | Pmty_alias a ->\n let a = self#longident_loc ctx a in\n Pmty_alias a\n\n method functor_parameter : 'ctx -> functor_parameter -> functor_parameter =\n fun ctx x ->\n match x with\n | Unit -> Unit\n | Named (a, b) ->\n let a = self#loc (self#option self#string) ctx a in\n let b = self#module_type ctx b in\n Named (a, b)\n\n method signature : 'ctx -> signature -> signature =\n self#list self#signature_item\n\n method signature_item : 'ctx -> signature_item -> signature_item =\n fun ctx { psig_desc; psig_loc } ->\n let psig_desc = self#signature_item_desc ctx psig_desc in\n let psig_loc = self#location ctx psig_loc in\n { psig_desc; psig_loc }\n\n method signature_item_desc\n : 'ctx -> signature_item_desc -> signature_item_desc =\n fun ctx x ->\n match x with\n | Psig_value a ->\n let a = self#value_description ctx a in\n Psig_value a\n | Psig_type (a, b) ->\n let a = self#rec_flag ctx a in\n let b = self#list self#type_declaration ctx b in\n Psig_type (a, b)\n | Psig_typesubst a ->\n let a = self#list self#type_declaration ctx a in\n Psig_typesubst a\n | Psig_typext a ->\n let a = self#type_extension ctx a in\n Psig_typext a\n | Psig_exception a ->\n let a = self#type_exception ctx a in\n Psig_exception a\n | Psig_module a ->\n let a = self#module_declaration ctx a in\n Psig_module a\n | Psig_modsubst a ->\n let a = self#module_substitution ctx a in\n Psig_modsubst a\n | Psig_recmodule a ->\n let a = self#list self#module_declaration ctx a in\n Psig_recmodule a\n | Psig_modtype a ->\n let a = self#module_type_declaration ctx a in\n Psig_modtype a\n | Psig_open a ->\n let a = self#open_description ctx a in\n Psig_open a\n | Psig_include a ->\n let a = self#include_description ctx a in\n Psig_include a\n | Psig_class a ->\n let a = self#list self#class_description ctx a in\n Psig_class a\n | Psig_class_type a ->\n let a = self#list self#class_type_declaration ctx a in\n Psig_class_type a\n | Psig_attribute a ->\n let a = self#attribute ctx a in\n Psig_attribute a\n | Psig_extension (a, b) ->\n let a = self#extension ctx a in\n let b = self#attributes ctx b in\n Psig_extension (a, b)\n\n method module_declaration : 'ctx -> module_declaration -> module_declaration\n =\n fun ctx { pmd_name; pmd_type; pmd_attributes; pmd_loc } ->\n let pmd_name = self#loc (self#option self#string) ctx pmd_name in\n let pmd_type = self#module_type ctx pmd_type in\n let pmd_attributes = self#attributes ctx pmd_attributes in\n let pmd_loc = self#location ctx pmd_loc in\n { pmd_name; pmd_type; pmd_attributes; pmd_loc }\n\n method module_substitution\n : 'ctx -> module_substitution -> module_substitution =\n fun ctx { pms_name; pms_manifest; pms_attributes; pms_loc } ->\n let pms_name = self#loc self#string ctx pms_name in\n let pms_manifest = self#longident_loc ctx pms_manifest in\n let pms_attributes = self#attributes ctx pms_attributes in\n let pms_loc = self#location ctx pms_loc in\n { pms_name; pms_manifest; pms_attributes; pms_loc }\n\n method module_type_declaration\n : 'ctx -> module_type_declaration -> module_type_declaration =\n fun ctx { pmtd_name; pmtd_type; pmtd_attributes; pmtd_loc } ->\n let pmtd_name = self#loc self#string ctx pmtd_name in\n let pmtd_type = self#option self#module_type ctx pmtd_type in\n let pmtd_attributes = self#attributes ctx pmtd_attributes in\n let pmtd_loc = self#location ctx pmtd_loc in\n { pmtd_name; pmtd_type; pmtd_attributes; pmtd_loc }\n\n method open_infos\n : 'a. ('ctx -> 'a -> 'a) -> 'ctx -> 'a open_infos -> 'a open_infos =\n fun _a ctx { popen_expr; popen_override; popen_loc; popen_attributes } ->\n let popen_expr = _a ctx popen_expr in\n let popen_override = self#override_flag ctx popen_override in\n let popen_loc = self#location ctx popen_loc in\n let popen_attributes = self#attributes ctx popen_attributes in\n { popen_expr; popen_override; popen_loc; popen_attributes }\n\n method open_description : 'ctx -> open_description -> open_description =\n self#open_infos self#longident_loc\n\n method open_declaration : 'ctx -> open_declaration -> open_declaration =\n self#open_infos self#module_expr\n\n method include_infos\n : 'a. ('ctx -> 'a -> 'a) -> 'ctx -> 'a include_infos -> 'a include_infos\n =\n fun _a ctx { pincl_mod; pincl_loc; pincl_attributes } ->\n let pincl_mod = _a ctx pincl_mod in\n let pincl_loc = self#location ctx pincl_loc in\n let pincl_attributes = self#attributes ctx pincl_attributes in\n { pincl_mod; pincl_loc; pincl_attributes }\n\n method include_description\n : 'ctx -> include_description -> include_description =\n self#include_infos self#module_type\n\n method include_declaration\n : 'ctx -> include_declaration -> include_declaration =\n self#include_infos self#module_expr\n\n method with_constraint : 'ctx -> with_constraint -> with_constraint =\n fun ctx x ->\n match x with\n | Pwith_type (a, b) ->\n let a = self#longident_loc ctx a in\n let b = self#type_declaration ctx b in\n Pwith_type (a, b)\n | Pwith_module (a, b) ->\n let a = self#longident_loc ctx a in\n let b = self#longident_loc ctx b in\n Pwith_module (a, b)\n | Pwith_typesubst (a, b) ->\n let a = self#longident_loc ctx a in\n let b = self#type_declaration ctx b in\n Pwith_typesubst (a, b)\n | Pwith_modsubst (a, b) ->\n let a = self#longident_loc ctx a in\n let b = self#longident_loc ctx b in\n Pwith_modsubst (a, b)\n\n method module_expr : 'ctx -> module_expr -> module_expr =\n fun ctx { pmod_desc; pmod_loc; pmod_attributes } ->\n let pmod_desc = self#module_expr_desc ctx pmod_desc in\n let pmod_loc = self#location ctx pmod_loc in\n let pmod_attributes = self#attributes ctx pmod_attributes in\n { pmod_desc; pmod_loc; pmod_attributes }\n\n method module_expr_desc : 'ctx -> module_expr_desc -> module_expr_desc =\n fun ctx x ->\n match x with\n | Pmod_ident a ->\n let a = self#longident_loc ctx a in\n Pmod_ident a\n | Pmod_structure a ->\n let a = self#structure ctx a in\n Pmod_structure a\n | Pmod_functor (a, b) ->\n let a = self#functor_parameter ctx a in\n let b = self#module_expr ctx b in\n Pmod_functor (a, b)\n | Pmod_apply (a, b) ->\n let a = self#module_expr ctx a in\n let b = self#module_expr ctx b in\n Pmod_apply (a, b)\n | Pmod_constraint (a, b) ->\n let a = self#module_expr ctx a in\n let b = self#module_type ctx b in\n Pmod_constraint (a, b)\n | Pmod_unpack a ->\n let a = self#expression ctx a in\n Pmod_unpack a\n | Pmod_extension a ->\n let a = self#extension ctx a in\n Pmod_extension a\n\n method structure : 'ctx -> structure -> structure =\n self#list self#structure_item\n\n method structure_item : 'ctx -> structure_item -> structure_item =\n fun ctx { pstr_desc; pstr_loc } ->\n let pstr_desc = self#structure_item_desc ctx pstr_desc in\n let pstr_loc = self#location ctx pstr_loc in\n { pstr_desc; pstr_loc }\n\n method structure_item_desc\n : 'ctx -> structure_item_desc -> structure_item_desc =\n fun ctx x ->\n match x with\n | Pstr_eval (a, b) ->\n let a = self#expression ctx a in\n let b = self#attributes ctx b in\n Pstr_eval (a, b)\n | Pstr_value (a, b) ->\n let a = self#rec_flag ctx a in\n let b = self#list self#value_binding ctx b in\n Pstr_value (a, b)\n | Pstr_primitive a ->\n let a = self#value_description ctx a in\n Pstr_primitive a\n | Pstr_type (a, b) ->\n let a = self#rec_flag ctx a in\n let b = self#list self#type_declaration ctx b in\n Pstr_type (a, b)\n | Pstr_typext a ->\n let a = self#type_extension ctx a in\n Pstr_typext a\n | Pstr_exception a ->\n let a = self#type_exception ctx a in\n Pstr_exception a\n | Pstr_module a ->\n let a = self#module_binding ctx a in\n Pstr_module a\n | Pstr_recmodule a ->\n let a = self#list self#module_binding ctx a in\n Pstr_recmodule a\n | Pstr_modtype a ->\n let a = self#module_type_declaration ctx a in\n Pstr_modtype a\n | Pstr_open a ->\n let a = self#open_declaration ctx a in\n Pstr_open a\n | Pstr_class a ->\n let a = self#list self#class_declaration ctx a in\n Pstr_class a\n | Pstr_class_type a ->\n let a = self#list self#class_type_declaration ctx a in\n Pstr_class_type a\n | Pstr_include a ->\n let a = self#include_declaration ctx a in\n Pstr_include a\n | Pstr_attribute a ->\n let a = self#attribute ctx a in\n Pstr_attribute a\n | Pstr_extension (a, b) ->\n let a = self#extension ctx a in\n let b = self#attributes ctx b in\n Pstr_extension (a, b)\n\n method value_binding : 'ctx -> value_binding -> value_binding =\n fun ctx { pvb_pat; pvb_expr; pvb_attributes; pvb_loc } ->\n let pvb_pat = self#pattern ctx pvb_pat in\n let pvb_expr = self#expression ctx pvb_expr in\n let pvb_attributes = self#attributes ctx pvb_attributes in\n let pvb_loc = self#location ctx pvb_loc in\n { pvb_pat; pvb_expr; pvb_attributes; pvb_loc }\n\n method module_binding : 'ctx -> module_binding -> module_binding =\n fun ctx { pmb_name; pmb_expr; pmb_attributes; pmb_loc } ->\n let pmb_name = self#loc (self#option self#string) ctx pmb_name in\n let pmb_expr = self#module_expr ctx pmb_expr in\n let pmb_attributes = self#attributes ctx pmb_attributes in\n let pmb_loc = self#location ctx pmb_loc in\n { pmb_name; pmb_expr; pmb_attributes; pmb_loc }\n\n method toplevel_phrase : 'ctx -> toplevel_phrase -> toplevel_phrase =\n fun ctx x ->\n match x with\n | Ptop_def a ->\n let a = self#structure ctx a in\n Ptop_def a\n | Ptop_dir a ->\n let a = self#toplevel_directive ctx a in\n Ptop_dir a\n\n method toplevel_directive : 'ctx -> toplevel_directive -> toplevel_directive\n =\n fun ctx { pdir_name; pdir_arg; pdir_loc } ->\n let pdir_name = self#loc self#string ctx pdir_name in\n let pdir_arg = self#option self#directive_argument ctx pdir_arg in\n let pdir_loc = self#location ctx pdir_loc in\n { pdir_name; pdir_arg; pdir_loc }\n\n method directive_argument : 'ctx -> directive_argument -> directive_argument\n =\n fun ctx { pdira_desc; pdira_loc } ->\n let pdira_desc = self#directive_argument_desc ctx pdira_desc in\n let pdira_loc = self#location ctx pdira_loc in\n { pdira_desc; pdira_loc }\n\n method directive_argument_desc\n : 'ctx -> directive_argument_desc -> directive_argument_desc =\n fun ctx x ->\n match x with\n | Pdir_string a ->\n let a = self#string ctx a in\n Pdir_string a\n | Pdir_int (a, b) ->\n let a = self#string ctx a in\n let b = self#option self#char ctx b in\n Pdir_int (a, b)\n | Pdir_ident a ->\n let a = self#longident ctx a in\n Pdir_ident a\n | Pdir_bool a ->\n let a = self#bool ctx a in\n Pdir_bool a\n\n method cases : 'ctx -> cases -> cases = self#list self#case\n end\n\nclass virtual ['res] lift =\n object (self)\n method virtual record : (string * 'res) list -> 'res\n method virtual constr : string -> 'res list -> 'res\n method virtual tuple : 'res list -> 'res\n method virtual bool : bool -> 'res\n method virtual char : char -> 'res\n method virtual int : int -> 'res\n method virtual list : 'a. ('a -> 'res) -> 'a list -> 'res\n method virtual option : 'a. ('a -> 'res) -> 'a option -> 'res\n method virtual string : string -> 'res\n\n method position : position -> 'res =\n fun { pos_fname; pos_lnum; pos_bol; pos_cnum } ->\n let pos_fname = self#string pos_fname in\n let pos_lnum = self#int pos_lnum in\n let pos_bol = self#int pos_bol in\n let pos_cnum = self#int pos_cnum in\n self#record\n [\n (\"pos_fname\", pos_fname);\n (\"pos_lnum\", pos_lnum);\n (\"pos_bol\", pos_bol);\n (\"pos_cnum\", pos_cnum);\n ]\n\n method location : location -> 'res =\n fun { loc_start; loc_end; loc_ghost } ->\n let loc_start = self#position loc_start in\n let loc_end = self#position loc_end in\n let loc_ghost = self#bool loc_ghost in\n self#record\n [\n (\"loc_start\", loc_start);\n (\"loc_end\", loc_end);\n (\"loc_ghost\", loc_ghost);\n ]\n\n method location_stack : location_stack -> 'res = self#list self#location\n\n method loc : 'a. ('a -> 'res) -> 'a loc -> 'res =\n fun _a { txt; loc } ->\n let txt = _a txt in\n let loc = self#location loc in\n self#record [ (\"txt\", txt); (\"loc\", loc) ]\n\n method longident : longident -> 'res =\n fun x ->\n match x with\n | Lident a ->\n let a = self#string a in\n self#constr \"Lident\" [ a ]\n | Ldot (a, b) ->\n let a = self#longident a in\n let b = self#string b in\n self#constr \"Ldot\" [ a; b ]\n | Lapply (a, b) ->\n let a = self#longident a in\n let b = self#longident b in\n self#constr \"Lapply\" [ a; b ]\n\n method longident_loc : longident_loc -> 'res = self#loc self#longident\n\n method rec_flag : rec_flag -> 'res =\n fun x ->\n match x with\n | Nonrecursive -> self#constr \"Nonrecursive\" []\n | Recursive -> self#constr \"Recursive\" []\n\n method direction_flag : direction_flag -> 'res =\n fun x ->\n match x with\n | Upto -> self#constr \"Upto\" []\n | Downto -> self#constr \"Downto\" []\n\n method private_flag : private_flag -> 'res =\n fun x ->\n match x with\n | Private -> self#constr \"Private\" []\n | Public -> self#constr \"Public\" []\n\n method mutable_flag : mutable_flag -> 'res =\n fun x ->\n match x with\n | Immutable -> self#constr \"Immutable\" []\n | Mutable -> self#constr \"Mutable\" []\n\n method virtual_flag : virtual_flag -> 'res =\n fun x ->\n match x with\n | Virtual -> self#constr \"Virtual\" []\n | Concrete -> self#constr \"Concrete\" []\n\n method override_flag : override_flag -> 'res =\n fun x ->\n match x with\n | Override -> self#constr \"Override\" []\n | Fresh -> self#constr \"Fresh\" []\n\n method closed_flag : closed_flag -> 'res =\n fun x ->\n match x with\n | Closed -> self#constr \"Closed\" []\n | Open -> self#constr \"Open\" []\n\n method label : label -> 'res = self#string\n\n method arg_label : arg_label -> 'res =\n fun x ->\n match x with\n | Nolabel -> self#constr \"Nolabel\" []\n | Labelled a ->\n let a = self#string a in\n self#constr \"Labelled\" [ a ]\n | Optional a ->\n let a = self#string a in\n self#constr \"Optional\" [ a ]\n\n method variance : variance -> 'res =\n fun x ->\n match x with\n | Covariant -> self#constr \"Covariant\" []\n | Contravariant -> self#constr \"Contravariant\" []\n | NoVariance -> self#constr \"NoVariance\" []\n\n method injectivity : injectivity -> 'res =\n fun x ->\n match x with\n | Injective -> self#constr \"Injective\" []\n | NoInjectivity -> self#constr \"NoInjectivity\" []\n\n method constant : constant -> 'res =\n fun x ->\n match x with\n | Pconst_integer (a, b) ->\n let a = self#string a in\n let b = self#option self#char b in\n self#constr \"Pconst_integer\" [ a; b ]\n | Pconst_char a ->\n let a = self#char a in\n self#constr \"Pconst_char\" [ a ]\n | Pconst_string (a, b, c) ->\n let a = self#string a in\n let b = self#location b in\n let c = self#option self#string c in\n self#constr \"Pconst_string\" [ a; b; c ]\n | Pconst_float (a, b) ->\n let a = self#string a in\n let b = self#option self#char b in\n self#constr \"Pconst_float\" [ a; b ]\n\n method attribute : attribute -> 'res =\n fun { attr_name; attr_payload; attr_loc } ->\n let attr_name = self#loc self#string attr_name in\n let attr_payload = self#payload attr_payload in\n let attr_loc = self#location attr_loc in\n self#record\n [\n (\"attr_name\", attr_name);\n (\"attr_payload\", attr_payload);\n (\"attr_loc\", attr_loc);\n ]\n\n method extension : extension -> 'res =\n fun (a, b) ->\n let a = self#loc self#string a in\n let b = self#payload b in\n self#tuple [ a; b ]\n\n method attributes : attributes -> 'res = self#list self#attribute\n\n method payload : payload -> 'res =\n fun x ->\n match x with\n | PStr a ->\n let a = self#structure a in\n self#constr \"PStr\" [ a ]\n | PSig a ->\n let a = self#signature a in\n self#constr \"PSig\" [ a ]\n | PTyp a ->\n let a = self#core_type a in\n self#constr \"PTyp\" [ a ]\n | PPat (a, b) ->\n let a = self#pattern a in\n let b = self#option self#expression b in\n self#constr \"PPat\" [ a; b ]\n\n method core_type : core_type -> 'res =\n fun { ptyp_desc; ptyp_loc; ptyp_loc_stack; ptyp_attributes } ->\n let ptyp_desc = self#core_type_desc ptyp_desc in\n let ptyp_loc = self#location ptyp_loc in\n let ptyp_loc_stack = self#location_stack ptyp_loc_stack in\n let ptyp_attributes = self#attributes ptyp_attributes in\n self#record\n [\n (\"ptyp_desc\", ptyp_desc);\n (\"ptyp_loc\", ptyp_loc);\n (\"ptyp_loc_stack\", ptyp_loc_stack);\n (\"ptyp_attributes\", ptyp_attributes);\n ]\n\n method core_type_desc : core_type_desc -> 'res =\n fun x ->\n match x with\n | Ptyp_any -> self#constr \"Ptyp_any\" []\n | Ptyp_var a ->\n let a = self#string a in\n self#constr \"Ptyp_var\" [ a ]\n | Ptyp_arrow (a, b, c) ->\n let a = self#arg_label a in\n let b = self#core_type b in\n let c = self#core_type c in\n self#constr \"Ptyp_arrow\" [ a; b; c ]\n | Ptyp_tuple a ->\n let a = self#list self#core_type a in\n self#constr \"Ptyp_tuple\" [ a ]\n | Ptyp_constr (a, b) ->\n let a = self#longident_loc a in\n let b = self#list self#core_type b in\n self#constr \"Ptyp_constr\" [ a; b ]\n | Ptyp_object (a, b) ->\n let a = self#list self#object_field a in\n let b = self#closed_flag b in\n self#constr \"Ptyp_object\" [ a; b ]\n | Ptyp_class (a, b) ->\n let a = self#longident_loc a in\n let b = self#list self#core_type b in\n self#constr \"Ptyp_class\" [ a; b ]\n | Ptyp_alias (a, b) ->\n let a = self#core_type a in\n let b = self#string b in\n self#constr \"Ptyp_alias\" [ a; b ]\n | Ptyp_variant (a, b, c) ->\n let a = self#list self#row_field a in\n let b = self#closed_flag b in\n let c = self#option (self#list self#label) c in\n self#constr \"Ptyp_variant\" [ a; b; c ]\n | Ptyp_poly (a, b) ->\n let a = self#list (self#loc self#string) a in\n let b = self#core_type b in\n self#constr \"Ptyp_poly\" [ a; b ]\n | Ptyp_package a ->\n let a = self#package_type a in\n self#constr \"Ptyp_package\" [ a ]\n | Ptyp_extension a ->\n let a = self#extension a in\n self#constr \"Ptyp_extension\" [ a ]\n\n method package_type : package_type -> 'res =\n fun (a, b) ->\n let a = self#longident_loc a in\n let b =\n self#list\n (fun (a, b) ->\n let a = self#longident_loc a in\n let b = self#core_type b in\n self#tuple [ a; b ])\n b\n in\n self#tuple [ a; b ]\n\n method row_field : row_field -> 'res =\n fun { prf_desc; prf_loc; prf_attributes } ->\n let prf_desc = self#row_field_desc prf_desc in\n let prf_loc = self#location prf_loc in\n let prf_attributes = self#attributes prf_attributes in\n self#record\n [\n (\"prf_desc\", prf_desc);\n (\"prf_loc\", prf_loc);\n (\"prf_attributes\", prf_attributes);\n ]\n\n method row_field_desc : row_field_desc -> 'res =\n fun x ->\n match x with\n | Rtag (a, b, c) ->\n let a = self#loc self#label a in\n let b = self#bool b in\n let c = self#list self#core_type c in\n self#constr \"Rtag\" [ a; b; c ]\n | Rinherit a ->\n let a = self#core_type a in\n self#constr \"Rinherit\" [ a ]\n\n method object_field : object_field -> 'res =\n fun { pof_desc; pof_loc; pof_attributes } ->\n let pof_desc = self#object_field_desc pof_desc in\n let pof_loc = self#location pof_loc in\n let pof_attributes = self#attributes pof_attributes in\n self#record\n [\n (\"pof_desc\", pof_desc);\n (\"pof_loc\", pof_loc);\n (\"pof_attributes\", pof_attributes);\n ]\n\n method object_field_desc : object_field_desc -> 'res =\n fun x ->\n match x with\n | Otag (a, b) ->\n let a = self#loc self#label a in\n let b = self#core_type b in\n self#constr \"Otag\" [ a; b ]\n | Oinherit a ->\n let a = self#core_type a in\n self#constr \"Oinherit\" [ a ]\n\n method pattern : pattern -> 'res =\n fun { ppat_desc; ppat_loc; ppat_loc_stack; ppat_attributes } ->\n let ppat_desc = self#pattern_desc ppat_desc in\n let ppat_loc = self#location ppat_loc in\n let ppat_loc_stack = self#location_stack ppat_loc_stack in\n let ppat_attributes = self#attributes ppat_attributes in\n self#record\n [\n (\"ppat_desc\", ppat_desc);\n (\"ppat_loc\", ppat_loc);\n (\"ppat_loc_stack\", ppat_loc_stack);\n (\"ppat_attributes\", ppat_attributes);\n ]\n\n method pattern_desc : pattern_desc -> 'res =\n fun x ->\n match x with\n | Ppat_any -> self#constr \"Ppat_any\" []\n | Ppat_var a ->\n let a = self#loc self#string a in\n self#constr \"Ppat_var\" [ a ]\n | Ppat_alias (a, b) ->\n let a = self#pattern a in\n let b = self#loc self#string b in\n self#constr \"Ppat_alias\" [ a; b ]\n | Ppat_constant a ->\n let a = self#constant a in\n self#constr \"Ppat_constant\" [ a ]\n | Ppat_interval (a, b) ->\n let a = self#constant a in\n let b = self#constant b in\n self#constr \"Ppat_interval\" [ a; b ]\n | Ppat_tuple a ->\n let a = self#list self#pattern a in\n self#constr \"Ppat_tuple\" [ a ]\n | Ppat_construct (a, b) ->\n let a = self#longident_loc a in\n let b = self#option self#pattern b in\n self#constr \"Ppat_construct\" [ a; b ]\n | Ppat_variant (a, b) ->\n let a = self#label a in\n let b = self#option self#pattern b in\n self#constr \"Ppat_variant\" [ a; b ]\n | Ppat_record (a, b) ->\n let a =\n self#list\n (fun (a, b) ->\n let a = self#longident_loc a in\n let b = self#pattern b in\n self#tuple [ a; b ])\n a\n in\n let b = self#closed_flag b in\n self#constr \"Ppat_record\" [ a; b ]\n | Ppat_array a ->\n let a = self#list self#pattern a in\n self#constr \"Ppat_array\" [ a ]\n | Ppat_or (a, b) ->\n let a = self#pattern a in\n let b = self#pattern b in\n self#constr \"Ppat_or\" [ a; b ]\n | Ppat_constraint (a, b) ->\n let a = self#pattern a in\n let b = self#core_type b in\n self#constr \"Ppat_constraint\" [ a; b ]\n | Ppat_type a ->\n let a = self#longident_loc a in\n self#constr \"Ppat_type\" [ a ]\n | Ppat_lazy a ->\n let a = self#pattern a in\n self#constr \"Ppat_lazy\" [ a ]\n | Ppat_unpack a ->\n let a = self#loc (self#option self#string) a in\n self#constr \"Ppat_unpack\" [ a ]\n | Ppat_exception a ->\n let a = self#pattern a in\n self#constr \"Ppat_exception\" [ a ]\n | Ppat_extension a ->\n let a = self#extension a in\n self#constr \"Ppat_extension\" [ a ]\n | Ppat_open (a, b) ->\n let a = self#longident_loc a in\n let b = self#pattern b in\n self#constr \"Ppat_open\" [ a; b ]\n\n method expression : expression -> 'res =\n fun { pexp_desc; pexp_loc; pexp_loc_stack; pexp_attributes } ->\n let pexp_desc = self#expression_desc pexp_desc in\n let pexp_loc = self#location pexp_loc in\n let pexp_loc_stack = self#location_stack pexp_loc_stack in\n let pexp_attributes = self#attributes pexp_attributes in\n self#record\n [\n (\"pexp_desc\", pexp_desc);\n (\"pexp_loc\", pexp_loc);\n (\"pexp_loc_stack\", pexp_loc_stack);\n (\"pexp_attributes\", pexp_attributes);\n ]\n\n method expression_desc : expression_desc -> 'res =\n fun x ->\n match x with\n | Pexp_ident a ->\n let a = self#longident_loc a in\n self#constr \"Pexp_ident\" [ a ]\n | Pexp_constant a ->\n let a = self#constant a in\n self#constr \"Pexp_constant\" [ a ]\n | Pexp_let (a, b, c) ->\n let a = self#rec_flag a in\n let b = self#list self#value_binding b in\n let c = self#expression c in\n self#constr \"Pexp_let\" [ a; b; c ]\n | Pexp_function a ->\n let a = self#cases a in\n self#constr \"Pexp_function\" [ a ]\n | Pexp_fun (a, b, c, d) ->\n let a = self#arg_label a in\n let b = self#option self#expression b in\n let c = self#pattern c in\n let d = self#expression d in\n self#constr \"Pexp_fun\" [ a; b; c; d ]\n | Pexp_apply (a, b) ->\n let a = self#expression a in\n let b =\n self#list\n (fun (a, b) ->\n let a = self#arg_label a in\n let b = self#expression b in\n self#tuple [ a; b ])\n b\n in\n self#constr \"Pexp_apply\" [ a; b ]\n | Pexp_match (a, b) ->\n let a = self#expression a in\n let b = self#cases b in\n self#constr \"Pexp_match\" [ a; b ]\n | Pexp_try (a, b) ->\n let a = self#expression a in\n let b = self#cases b in\n self#constr \"Pexp_try\" [ a; b ]\n | Pexp_tuple a ->\n let a = self#list self#expression a in\n self#constr \"Pexp_tuple\" [ a ]\n | Pexp_construct (a, b) ->\n let a = self#longident_loc a in\n let b = self#option self#expression b in\n self#constr \"Pexp_construct\" [ a; b ]\n | Pexp_variant (a, b) ->\n let a = self#label a in\n let b = self#option self#expression b in\n self#constr \"Pexp_variant\" [ a; b ]\n | Pexp_record (a, b) ->\n let a =\n self#list\n (fun (a, b) ->\n let a = self#longident_loc a in\n let b = self#expression b in\n self#tuple [ a; b ])\n a\n in\n let b = self#option self#expression b in\n self#constr \"Pexp_record\" [ a; b ]\n | Pexp_field (a, b) ->\n let a = self#expression a in\n let b = self#longident_loc b in\n self#constr \"Pexp_field\" [ a; b ]\n | Pexp_setfield (a, b, c) ->\n let a = self#expression a in\n let b = self#longident_loc b in\n let c = self#expression c in\n self#constr \"Pexp_setfield\" [ a; b; c ]\n | Pexp_array a ->\n let a = self#list self#expression a in\n self#constr \"Pexp_array\" [ a ]\n | Pexp_ifthenelse (a, b, c) ->\n let a = self#expression a in\n let b = self#expression b in\n let c = self#option self#expression c in\n self#constr \"Pexp_ifthenelse\" [ a; b; c ]\n | Pexp_sequence (a, b) ->\n let a = self#expression a in\n let b = self#expression b in\n self#constr \"Pexp_sequence\" [ a; b ]\n | Pexp_while (a, b) ->\n let a = self#expression a in\n let b = self#expression b in\n self#constr \"Pexp_while\" [ a; b ]\n | Pexp_for (a, b, c, d, e) ->\n let a = self#pattern a in\n let b = self#expression b in\n let c = self#expression c in\n let d = self#direction_flag d in\n let e = self#expression e in\n self#constr \"Pexp_for\" [ a; b; c; d; e ]\n | Pexp_constraint (a, b) ->\n let a = self#expression a in\n let b = self#core_type b in\n self#constr \"Pexp_constraint\" [ a; b ]\n | Pexp_coerce (a, b, c) ->\n let a = self#expression a in\n let b = self#option self#core_type b in\n let c = self#core_type c in\n self#constr \"Pexp_coerce\" [ a; b; c ]\n | Pexp_send (a, b) ->\n let a = self#expression a in\n let b = self#loc self#label b in\n self#constr \"Pexp_send\" [ a; b ]\n | Pexp_new a ->\n let a = self#longident_loc a in\n self#constr \"Pexp_new\" [ a ]\n | Pexp_setinstvar (a, b) ->\n let a = self#loc self#label a in\n let b = self#expression b in\n self#constr \"Pexp_setinstvar\" [ a; b ]\n | Pexp_override a ->\n let a =\n self#list\n (fun (a, b) ->\n let a = self#loc self#label a in\n let b = self#expression b in\n self#tuple [ a; b ])\n a\n in\n self#constr \"Pexp_override\" [ a ]\n | Pexp_letmodule (a, b, c) ->\n let a = self#loc (self#option self#string) a in\n let b = self#module_expr b in\n let c = self#expression c in\n self#constr \"Pexp_letmodule\" [ a; b; c ]\n | Pexp_letexception (a, b) ->\n let a = self#extension_constructor a in\n let b = self#expression b in\n self#constr \"Pexp_letexception\" [ a; b ]\n | Pexp_assert a ->\n let a = self#expression a in\n self#constr \"Pexp_assert\" [ a ]\n | Pexp_lazy a ->\n let a = self#expression a in\n self#constr \"Pexp_lazy\" [ a ]\n | Pexp_poly (a, b) ->\n let a = self#expression a in\n let b = self#option self#core_type b in\n self#constr \"Pexp_poly\" [ a; b ]\n | Pexp_object a ->\n let a = self#class_structure a in\n self#constr \"Pexp_object\" [ a ]\n | Pexp_newtype (a, b) ->\n let a = self#loc self#string a in\n let b = self#expression b in\n self#constr \"Pexp_newtype\" [ a; b ]\n | Pexp_pack a ->\n let a = self#module_expr a in\n self#constr \"Pexp_pack\" [ a ]\n | Pexp_open (a, b) ->\n let a = self#open_declaration a in\n let b = self#expression b in\n self#constr \"Pexp_open\" [ a; b ]\n | Pexp_letop a ->\n let a = self#letop a in\n self#constr \"Pexp_letop\" [ a ]\n | Pexp_extension a ->\n let a = self#extension a in\n self#constr \"Pexp_extension\" [ a ]\n | Pexp_unreachable -> self#constr \"Pexp_unreachable\" []\n\n method case : case -> 'res =\n fun { pc_lhs; pc_guard; pc_rhs } ->\n let pc_lhs = self#pattern pc_lhs in\n let pc_guard = self#option self#expression pc_guard in\n let pc_rhs = self#expression pc_rhs in\n self#record\n [ (\"pc_lhs\", pc_lhs); (\"pc_guard\", pc_guard); (\"pc_rhs\", pc_rhs) ]\n\n method letop : letop -> 'res =\n fun { let_; ands; body } ->\n let let_ = self#binding_op let_ in\n let ands = self#list self#binding_op ands in\n let body = self#expression body in\n self#record [ (\"let_\", let_); (\"ands\", ands); (\"body\", body) ]\n\n method binding_op : binding_op -> 'res =\n fun { pbop_op; pbop_pat; pbop_exp; pbop_loc } ->\n let pbop_op = self#loc self#string pbop_op in\n let pbop_pat = self#pattern pbop_pat in\n let pbop_exp = self#expression pbop_exp in\n let pbop_loc = self#location pbop_loc in\n self#record\n [\n (\"pbop_op\", pbop_op);\n (\"pbop_pat\", pbop_pat);\n (\"pbop_exp\", pbop_exp);\n (\"pbop_loc\", pbop_loc);\n ]\n\n method value_description : value_description -> 'res =\n fun { pval_name; pval_type; pval_prim; pval_attributes; pval_loc } ->\n let pval_name = self#loc self#string pval_name in\n let pval_type = self#core_type pval_type in\n let pval_prim = self#list self#string pval_prim in\n let pval_attributes = self#attributes pval_attributes in\n let pval_loc = self#location pval_loc in\n self#record\n [\n (\"pval_name\", pval_name);\n (\"pval_type\", pval_type);\n (\"pval_prim\", pval_prim);\n (\"pval_attributes\", pval_attributes);\n (\"pval_loc\", pval_loc);\n ]\n\n method type_declaration : type_declaration -> 'res =\n fun {\n ptype_name;\n ptype_params;\n ptype_cstrs;\n ptype_kind;\n ptype_private;\n ptype_manifest;\n ptype_attributes;\n ptype_loc;\n } ->\n let ptype_name = self#loc self#string ptype_name in\n let ptype_params =\n self#list\n (fun (a, b) ->\n let a = self#core_type a in\n let b =\n (fun (a, b) ->\n let a = self#variance a in\n let b = self#injectivity b in\n self#tuple [ a; b ])\n b\n in\n self#tuple [ a; b ])\n ptype_params\n in\n let ptype_cstrs =\n self#list\n (fun (a, b, c) ->\n let a = self#core_type a in\n let b = self#core_type b in\n let c = self#location c in\n self#tuple [ a; b; c ])\n ptype_cstrs\n in\n let ptype_kind = self#type_kind ptype_kind in\n let ptype_private = self#private_flag ptype_private in\n let ptype_manifest = self#option self#core_type ptype_manifest in\n let ptype_attributes = self#attributes ptype_attributes in\n let ptype_loc = self#location ptype_loc in\n self#record\n [\n (\"ptype_name\", ptype_name);\n (\"ptype_params\", ptype_params);\n (\"ptype_cstrs\", ptype_cstrs);\n (\"ptype_kind\", ptype_kind);\n (\"ptype_private\", ptype_private);\n (\"ptype_manifest\", ptype_manifest);\n (\"ptype_attributes\", ptype_attributes);\n (\"ptype_loc\", ptype_loc);\n ]\n\n method type_kind : type_kind -> 'res =\n fun x ->\n match x with\n | Ptype_abstract -> self#constr \"Ptype_abstract\" []\n | Ptype_variant a ->\n let a = self#list self#constructor_declaration a in\n self#constr \"Ptype_variant\" [ a ]\n | Ptype_record a ->\n let a = self#list self#label_declaration a in\n self#constr \"Ptype_record\" [ a ]\n | Ptype_open -> self#constr \"Ptype_open\" []\n\n method label_declaration : label_declaration -> 'res =\n fun { pld_name; pld_mutable; pld_type; pld_loc; pld_attributes } ->\n let pld_name = self#loc self#string pld_name in\n let pld_mutable = self#mutable_flag pld_mutable in\n let pld_type = self#core_type pld_type in\n let pld_loc = self#location pld_loc in\n let pld_attributes = self#attributes pld_attributes in\n self#record\n [\n (\"pld_name\", pld_name);\n (\"pld_mutable\", pld_mutable);\n (\"pld_type\", pld_type);\n (\"pld_loc\", pld_loc);\n (\"pld_attributes\", pld_attributes);\n ]\n\n method constructor_declaration : constructor_declaration -> 'res =\n fun { pcd_name; pcd_args; pcd_res; pcd_loc; pcd_attributes } ->\n let pcd_name = self#loc self#string pcd_name in\n let pcd_args = self#constructor_arguments pcd_args in\n let pcd_res = self#option self#core_type pcd_res in\n let pcd_loc = self#location pcd_loc in\n let pcd_attributes = self#attributes pcd_attributes in\n self#record\n [\n (\"pcd_name\", pcd_name);\n (\"pcd_args\", pcd_args);\n (\"pcd_res\", pcd_res);\n (\"pcd_loc\", pcd_loc);\n (\"pcd_attributes\", pcd_attributes);\n ]\n\n method constructor_arguments : constructor_arguments -> 'res =\n fun x ->\n match x with\n | Pcstr_tuple a ->\n let a = self#list self#core_type a in\n self#constr \"Pcstr_tuple\" [ a ]\n | Pcstr_record a ->\n let a = self#list self#label_declaration a in\n self#constr \"Pcstr_record\" [ a ]\n\n method type_extension : type_extension -> 'res =\n fun {\n ptyext_path;\n ptyext_params;\n ptyext_constructors;\n ptyext_private;\n ptyext_loc;\n ptyext_attributes;\n } ->\n let ptyext_path = self#longident_loc ptyext_path in\n let ptyext_params =\n self#list\n (fun (a, b) ->\n let a = self#core_type a in\n let b =\n (fun (a, b) ->\n let a = self#variance a in\n let b = self#injectivity b in\n self#tuple [ a; b ])\n b\n in\n self#tuple [ a; b ])\n ptyext_params\n in\n let ptyext_constructors =\n self#list self#extension_constructor ptyext_constructors\n in\n let ptyext_private = self#private_flag ptyext_private in\n let ptyext_loc = self#location ptyext_loc in\n let ptyext_attributes = self#attributes ptyext_attributes in\n self#record\n [\n (\"ptyext_path\", ptyext_path);\n (\"ptyext_params\", ptyext_params);\n (\"ptyext_constructors\", ptyext_constructors);\n (\"ptyext_private\", ptyext_private);\n (\"ptyext_loc\", ptyext_loc);\n (\"ptyext_attributes\", ptyext_attributes);\n ]\n\n method extension_constructor : extension_constructor -> 'res =\n fun { pext_name; pext_kind; pext_loc; pext_attributes } ->\n let pext_name = self#loc self#string pext_name in\n let pext_kind = self#extension_constructor_kind pext_kind in\n let pext_loc = self#location pext_loc in\n let pext_attributes = self#attributes pext_attributes in\n self#record\n [\n (\"pext_name\", pext_name);\n (\"pext_kind\", pext_kind);\n (\"pext_loc\", pext_loc);\n (\"pext_attributes\", pext_attributes);\n ]\n\n method type_exception : type_exception -> 'res =\n fun { ptyexn_constructor; ptyexn_loc; ptyexn_attributes } ->\n let ptyexn_constructor =\n self#extension_constructor ptyexn_constructor\n in\n let ptyexn_loc = self#location ptyexn_loc in\n let ptyexn_attributes = self#attributes ptyexn_attributes in\n self#record\n [\n (\"ptyexn_constructor\", ptyexn_constructor);\n (\"ptyexn_loc\", ptyexn_loc);\n (\"ptyexn_attributes\", ptyexn_attributes);\n ]\n\n method extension_constructor_kind : extension_constructor_kind -> 'res =\n fun x ->\n match x with\n | Pext_decl (a, b) ->\n let a = self#constructor_arguments a in\n let b = self#option self#core_type b in\n self#constr \"Pext_decl\" [ a; b ]\n | Pext_rebind a ->\n let a = self#longident_loc a in\n self#constr \"Pext_rebind\" [ a ]\n\n method class_type : class_type -> 'res =\n fun { pcty_desc; pcty_loc; pcty_attributes } ->\n let pcty_desc = self#class_type_desc pcty_desc in\n let pcty_loc = self#location pcty_loc in\n let pcty_attributes = self#attributes pcty_attributes in\n self#record\n [\n (\"pcty_desc\", pcty_desc);\n (\"pcty_loc\", pcty_loc);\n (\"pcty_attributes\", pcty_attributes);\n ]\n\n method class_type_desc : class_type_desc -> 'res =\n fun x ->\n match x with\n | Pcty_constr (a, b) ->\n let a = self#longident_loc a in\n let b = self#list self#core_type b in\n self#constr \"Pcty_constr\" [ a; b ]\n | Pcty_signature a ->\n let a = self#class_signature a in\n self#constr \"Pcty_signature\" [ a ]\n | Pcty_arrow (a, b, c) ->\n let a = self#arg_label a in\n let b = self#core_type b in\n let c = self#class_type c in\n self#constr \"Pcty_arrow\" [ a; b; c ]\n | Pcty_extension a ->\n let a = self#extension a in\n self#constr \"Pcty_extension\" [ a ]\n | Pcty_open (a, b) ->\n let a = self#open_description a in\n let b = self#class_type b in\n self#constr \"Pcty_open\" [ a; b ]\n\n method class_signature : class_signature -> 'res =\n fun { pcsig_self; pcsig_fields } ->\n let pcsig_self = self#core_type pcsig_self in\n let pcsig_fields = self#list self#class_type_field pcsig_fields in\n self#record\n [ (\"pcsig_self\", pcsig_self); (\"pcsig_fields\", pcsig_fields) ]\n\n method class_type_field : class_type_field -> 'res =\n fun { pctf_desc; pctf_loc; pctf_attributes } ->\n let pctf_desc = self#class_type_field_desc pctf_desc in\n let pctf_loc = self#location pctf_loc in\n let pctf_attributes = self#attributes pctf_attributes in\n self#record\n [\n (\"pctf_desc\", pctf_desc);\n (\"pctf_loc\", pctf_loc);\n (\"pctf_attributes\", pctf_attributes);\n ]\n\n method class_type_field_desc : class_type_field_desc -> 'res =\n fun x ->\n match x with\n | Pctf_inherit a ->\n let a = self#class_type a in\n self#constr \"Pctf_inherit\" [ a ]\n | Pctf_val a ->\n let a =\n (fun (a, b, c, d) ->\n let a = self#loc self#label a in\n let b = self#mutable_flag b in\n let c = self#virtual_flag c in\n let d = self#core_type d in\n self#tuple [ a; b; c; d ])\n a\n in\n self#constr \"Pctf_val\" [ a ]\n | Pctf_method a ->\n let a =\n (fun (a, b, c, d) ->\n let a = self#loc self#label a in\n let b = self#private_flag b in\n let c = self#virtual_flag c in\n let d = self#core_type d in\n self#tuple [ a; b; c; d ])\n a\n in\n self#constr \"Pctf_method\" [ a ]\n | Pctf_constraint a ->\n let a =\n (fun (a, b) ->\n let a = self#core_type a in\n let b = self#core_type b in\n self#tuple [ a; b ])\n a\n in\n self#constr \"Pctf_constraint\" [ a ]\n | Pctf_attribute a ->\n let a = self#attribute a in\n self#constr \"Pctf_attribute\" [ a ]\n | Pctf_extension a ->\n let a = self#extension a in\n self#constr \"Pctf_extension\" [ a ]\n\n method class_infos : 'a. ('a -> 'res) -> 'a class_infos -> 'res =\n fun _a\n { pci_virt; pci_params; pci_name; pci_expr; pci_loc; pci_attributes } ->\n let pci_virt = self#virtual_flag pci_virt in\n let pci_params =\n self#list\n (fun (a, b) ->\n let a = self#core_type a in\n let b =\n (fun (a, b) ->\n let a = self#variance a in\n let b = self#injectivity b in\n self#tuple [ a; b ])\n b\n in\n self#tuple [ a; b ])\n pci_params\n in\n let pci_name = self#loc self#string pci_name in\n let pci_expr = _a pci_expr in\n let pci_loc = self#location pci_loc in\n let pci_attributes = self#attributes pci_attributes in\n self#record\n [\n (\"pci_virt\", pci_virt);\n (\"pci_params\", pci_params);\n (\"pci_name\", pci_name);\n (\"pci_expr\", pci_expr);\n (\"pci_loc\", pci_loc);\n (\"pci_attributes\", pci_attributes);\n ]\n\n method class_description : class_description -> 'res =\n self#class_infos self#class_type\n\n method class_type_declaration : class_type_declaration -> 'res =\n self#class_infos self#class_type\n\n method class_expr : class_expr -> 'res =\n fun { pcl_desc; pcl_loc; pcl_attributes } ->\n let pcl_desc = self#class_expr_desc pcl_desc in\n let pcl_loc = self#location pcl_loc in\n let pcl_attributes = self#attributes pcl_attributes in\n self#record\n [\n (\"pcl_desc\", pcl_desc);\n (\"pcl_loc\", pcl_loc);\n (\"pcl_attributes\", pcl_attributes);\n ]\n\n method class_expr_desc : class_expr_desc -> 'res =\n fun x ->\n match x with\n | Pcl_constr (a, b) ->\n let a = self#longident_loc a in\n let b = self#list self#core_type b in\n self#constr \"Pcl_constr\" [ a; b ]\n | Pcl_structure a ->\n let a = self#class_structure a in\n self#constr \"Pcl_structure\" [ a ]\n | Pcl_fun (a, b, c, d) ->\n let a = self#arg_label a in\n let b = self#option self#expression b in\n let c = self#pattern c in\n let d = self#class_expr d in\n self#constr \"Pcl_fun\" [ a; b; c; d ]\n | Pcl_apply (a, b) ->\n let a = self#class_expr a in\n let b =\n self#list\n (fun (a, b) ->\n let a = self#arg_label a in\n let b = self#expression b in\n self#tuple [ a; b ])\n b\n in\n self#constr \"Pcl_apply\" [ a; b ]\n | Pcl_let (a, b, c) ->\n let a = self#rec_flag a in\n let b = self#list self#value_binding b in\n let c = self#class_expr c in\n self#constr \"Pcl_let\" [ a; b; c ]\n | Pcl_constraint (a, b) ->\n let a = self#class_expr a in\n let b = self#class_type b in\n self#constr \"Pcl_constraint\" [ a; b ]\n | Pcl_extension a ->\n let a = self#extension a in\n self#constr \"Pcl_extension\" [ a ]\n | Pcl_open (a, b) ->\n let a = self#open_description a in\n let b = self#class_expr b in\n self#constr \"Pcl_open\" [ a; b ]\n\n method class_structure : class_structure -> 'res =\n fun { pcstr_self; pcstr_fields } ->\n let pcstr_self = self#pattern pcstr_self in\n let pcstr_fields = self#list self#class_field pcstr_fields in\n self#record\n [ (\"pcstr_self\", pcstr_self); (\"pcstr_fields\", pcstr_fields) ]\n\n method class_field : class_field -> 'res =\n fun { pcf_desc; pcf_loc; pcf_attributes } ->\n let pcf_desc = self#class_field_desc pcf_desc in\n let pcf_loc = self#location pcf_loc in\n let pcf_attributes = self#attributes pcf_attributes in\n self#record\n [\n (\"pcf_desc\", pcf_desc);\n (\"pcf_loc\", pcf_loc);\n (\"pcf_attributes\", pcf_attributes);\n ]\n\n method class_field_desc : class_field_desc -> 'res =\n fun x ->\n match x with\n | Pcf_inherit (a, b, c) ->\n let a = self#override_flag a in\n let b = self#class_expr b in\n let c = self#option (self#loc self#string) c in\n self#constr \"Pcf_inherit\" [ a; b; c ]\n | Pcf_val a ->\n let a =\n (fun (a, b, c) ->\n let a = self#loc self#label a in\n let b = self#mutable_flag b in\n let c = self#class_field_kind c in\n self#tuple [ a; b; c ])\n a\n in\n self#constr \"Pcf_val\" [ a ]\n | Pcf_method a ->\n let a =\n (fun (a, b, c) ->\n let a = self#loc self#label a in\n let b = self#private_flag b in\n let c = self#class_field_kind c in\n self#tuple [ a; b; c ])\n a\n in\n self#constr \"Pcf_method\" [ a ]\n | Pcf_constraint a ->\n let a =\n (fun (a, b) ->\n let a = self#core_type a in\n let b = self#core_type b in\n self#tuple [ a; b ])\n a\n in\n self#constr \"Pcf_constraint\" [ a ]\n | Pcf_initializer a ->\n let a = self#expression a in\n self#constr \"Pcf_initializer\" [ a ]\n | Pcf_attribute a ->\n let a = self#attribute a in\n self#constr \"Pcf_attribute\" [ a ]\n | Pcf_extension a ->\n let a = self#extension a in\n self#constr \"Pcf_extension\" [ a ]\n\n method class_field_kind : class_field_kind -> 'res =\n fun x ->\n match x with\n | Cfk_virtual a ->\n let a = self#core_type a in\n self#constr \"Cfk_virtual\" [ a ]\n | Cfk_concrete (a, b) ->\n let a = self#override_flag a in\n let b = self#expression b in\n self#constr \"Cfk_concrete\" [ a; b ]\n\n method class_declaration : class_declaration -> 'res =\n self#class_infos self#class_expr\n\n method module_type : module_type -> 'res =\n fun { pmty_desc; pmty_loc; pmty_attributes } ->\n let pmty_desc = self#module_type_desc pmty_desc in\n let pmty_loc = self#location pmty_loc in\n let pmty_attributes = self#attributes pmty_attributes in\n self#record\n [\n (\"pmty_desc\", pmty_desc);\n (\"pmty_loc\", pmty_loc);\n (\"pmty_attributes\", pmty_attributes);\n ]\n\n method module_type_desc : module_type_desc -> 'res =\n fun x ->\n match x with\n | Pmty_ident a ->\n let a = self#longident_loc a in\n self#constr \"Pmty_ident\" [ a ]\n | Pmty_signature a ->\n let a = self#signature a in\n self#constr \"Pmty_signature\" [ a ]\n | Pmty_functor (a, b) ->\n let a = self#functor_parameter a in\n let b = self#module_type b in\n self#constr \"Pmty_functor\" [ a; b ]\n | Pmty_with (a, b) ->\n let a = self#module_type a in\n let b = self#list self#with_constraint b in\n self#constr \"Pmty_with\" [ a; b ]\n | Pmty_typeof a ->\n let a = self#module_expr a in\n self#constr \"Pmty_typeof\" [ a ]\n | Pmty_extension a ->\n let a = self#extension a in\n self#constr \"Pmty_extension\" [ a ]\n | Pmty_alias a ->\n let a = self#longident_loc a in\n self#constr \"Pmty_alias\" [ a ]\n\n method functor_parameter : functor_parameter -> 'res =\n fun x ->\n match x with\n | Unit -> self#constr \"Unit\" []\n | Named (a, b) ->\n let a = self#loc (self#option self#string) a in\n let b = self#module_type b in\n self#constr \"Named\" [ a; b ]\n\n method signature : signature -> 'res = self#list self#signature_item\n\n method signature_item : signature_item -> 'res =\n fun { psig_desc; psig_loc } ->\n let psig_desc = self#signature_item_desc psig_desc in\n let psig_loc = self#location psig_loc in\n self#record [ (\"psig_desc\", psig_desc); (\"psig_loc\", psig_loc) ]\n\n method signature_item_desc : signature_item_desc -> 'res =\n fun x ->\n match x with\n | Psig_value a ->\n let a = self#value_description a in\n self#constr \"Psig_value\" [ a ]\n | Psig_type (a, b) ->\n let a = self#rec_flag a in\n let b = self#list self#type_declaration b in\n self#constr \"Psig_type\" [ a; b ]\n | Psig_typesubst a ->\n let a = self#list self#type_declaration a in\n self#constr \"Psig_typesubst\" [ a ]\n | Psig_typext a ->\n let a = self#type_extension a in\n self#constr \"Psig_typext\" [ a ]\n | Psig_exception a ->\n let a = self#type_exception a in\n self#constr \"Psig_exception\" [ a ]\n | Psig_module a ->\n let a = self#module_declaration a in\n self#constr \"Psig_module\" [ a ]\n | Psig_modsubst a ->\n let a = self#module_substitution a in\n self#constr \"Psig_modsubst\" [ a ]\n | Psig_recmodule a ->\n let a = self#list self#module_declaration a in\n self#constr \"Psig_recmodule\" [ a ]\n | Psig_modtype a ->\n let a = self#module_type_declaration a in\n self#constr \"Psig_modtype\" [ a ]\n | Psig_open a ->\n let a = self#open_description a in\n self#constr \"Psig_open\" [ a ]\n | Psig_include a ->\n let a = self#include_description a in\n self#constr \"Psig_include\" [ a ]\n | Psig_class a ->\n let a = self#list self#class_description a in\n self#constr \"Psig_class\" [ a ]\n | Psig_class_type a ->\n let a = self#list self#class_type_declaration a in\n self#constr \"Psig_class_type\" [ a ]\n | Psig_attribute a ->\n let a = self#attribute a in\n self#constr \"Psig_attribute\" [ a ]\n | Psig_extension (a, b) ->\n let a = self#extension a in\n let b = self#attributes b in\n self#constr \"Psig_extension\" [ a; b ]\n\n method module_declaration : module_declaration -> 'res =\n fun { pmd_name; pmd_type; pmd_attributes; pmd_loc } ->\n let pmd_name = self#loc (self#option self#string) pmd_name in\n let pmd_type = self#module_type pmd_type in\n let pmd_attributes = self#attributes pmd_attributes in\n let pmd_loc = self#location pmd_loc in\n self#record\n [\n (\"pmd_name\", pmd_name);\n (\"pmd_type\", pmd_type);\n (\"pmd_attributes\", pmd_attributes);\n (\"pmd_loc\", pmd_loc);\n ]\n\n method module_substitution : module_substitution -> 'res =\n fun { pms_name; pms_manifest; pms_attributes; pms_loc } ->\n let pms_name = self#loc self#string pms_name in\n let pms_manifest = self#longident_loc pms_manifest in\n let pms_attributes = self#attributes pms_attributes in\n let pms_loc = self#location pms_loc in\n self#record\n [\n (\"pms_name\", pms_name);\n (\"pms_manifest\", pms_manifest);\n (\"pms_attributes\", pms_attributes);\n (\"pms_loc\", pms_loc);\n ]\n\n method module_type_declaration : module_type_declaration -> 'res =\n fun { pmtd_name; pmtd_type; pmtd_attributes; pmtd_loc } ->\n let pmtd_name = self#loc self#string pmtd_name in\n let pmtd_type = self#option self#module_type pmtd_type in\n let pmtd_attributes = self#attributes pmtd_attributes in\n let pmtd_loc = self#location pmtd_loc in\n self#record\n [\n (\"pmtd_name\", pmtd_name);\n (\"pmtd_type\", pmtd_type);\n (\"pmtd_attributes\", pmtd_attributes);\n (\"pmtd_loc\", pmtd_loc);\n ]\n\n method open_infos : 'a. ('a -> 'res) -> 'a open_infos -> 'res =\n fun _a { popen_expr; popen_override; popen_loc; popen_attributes } ->\n let popen_expr = _a popen_expr in\n let popen_override = self#override_flag popen_override in\n let popen_loc = self#location popen_loc in\n let popen_attributes = self#attributes popen_attributes in\n self#record\n [\n (\"popen_expr\", popen_expr);\n (\"popen_override\", popen_override);\n (\"popen_loc\", popen_loc);\n (\"popen_attributes\", popen_attributes);\n ]\n\n method open_description : open_description -> 'res =\n self#open_infos self#longident_loc\n\n method open_declaration : open_declaration -> 'res =\n self#open_infos self#module_expr\n\n method include_infos : 'a. ('a -> 'res) -> 'a include_infos -> 'res =\n fun _a { pincl_mod; pincl_loc; pincl_attributes } ->\n let pincl_mod = _a pincl_mod in\n let pincl_loc = self#location pincl_loc in\n let pincl_attributes = self#attributes pincl_attributes in\n self#record\n [\n (\"pincl_mod\", pincl_mod);\n (\"pincl_loc\", pincl_loc);\n (\"pincl_attributes\", pincl_attributes);\n ]\n\n method include_description : include_description -> 'res =\n self#include_infos self#module_type\n\n method include_declaration : include_declaration -> 'res =\n self#include_infos self#module_expr\n\n method with_constraint : with_constraint -> 'res =\n fun x ->\n match x with\n | Pwith_type (a, b) ->\n let a = self#longident_loc a in\n let b = self#type_declaration b in\n self#constr \"Pwith_type\" [ a; b ]\n | Pwith_module (a, b) ->\n let a = self#longident_loc a in\n let b = self#longident_loc b in\n self#constr \"Pwith_module\" [ a; b ]\n | Pwith_typesubst (a, b) ->\n let a = self#longident_loc a in\n let b = self#type_declaration b in\n self#constr \"Pwith_typesubst\" [ a; b ]\n | Pwith_modsubst (a, b) ->\n let a = self#longident_loc a in\n let b = self#longident_loc b in\n self#constr \"Pwith_modsubst\" [ a; b ]\n\n method module_expr : module_expr -> 'res =\n fun { pmod_desc; pmod_loc; pmod_attributes } ->\n let pmod_desc = self#module_expr_desc pmod_desc in\n let pmod_loc = self#location pmod_loc in\n let pmod_attributes = self#attributes pmod_attributes in\n self#record\n [\n (\"pmod_desc\", pmod_desc);\n (\"pmod_loc\", pmod_loc);\n (\"pmod_attributes\", pmod_attributes);\n ]\n\n method module_expr_desc : module_expr_desc -> 'res =\n fun x ->\n match x with\n | Pmod_ident a ->\n let a = self#longident_loc a in\n self#constr \"Pmod_ident\" [ a ]\n | Pmod_structure a ->\n let a = self#structure a in\n self#constr \"Pmod_structure\" [ a ]\n | Pmod_functor (a, b) ->\n let a = self#functor_parameter a in\n let b = self#module_expr b in\n self#constr \"Pmod_functor\" [ a; b ]\n | Pmod_apply (a, b) ->\n let a = self#module_expr a in\n let b = self#module_expr b in\n self#constr \"Pmod_apply\" [ a; b ]\n | Pmod_constraint (a, b) ->\n let a = self#module_expr a in\n let b = self#module_type b in\n self#constr \"Pmod_constraint\" [ a; b ]\n | Pmod_unpack a ->\n let a = self#expression a in\n self#constr \"Pmod_unpack\" [ a ]\n | Pmod_extension a ->\n let a = self#extension a in\n self#constr \"Pmod_extension\" [ a ]\n\n method structure : structure -> 'res = self#list self#structure_item\n\n method structure_item : structure_item -> 'res =\n fun { pstr_desc; pstr_loc } ->\n let pstr_desc = self#structure_item_desc pstr_desc in\n let pstr_loc = self#location pstr_loc in\n self#record [ (\"pstr_desc\", pstr_desc); (\"pstr_loc\", pstr_loc) ]\n\n method structure_item_desc : structure_item_desc -> 'res =\n fun x ->\n match x with\n | Pstr_eval (a, b) ->\n let a = self#expression a in\n let b = self#attributes b in\n self#constr \"Pstr_eval\" [ a; b ]\n | Pstr_value (a, b) ->\n let a = self#rec_flag a in\n let b = self#list self#value_binding b in\n self#constr \"Pstr_value\" [ a; b ]\n | Pstr_primitive a ->\n let a = self#value_description a in\n self#constr \"Pstr_primitive\" [ a ]\n | Pstr_type (a, b) ->\n let a = self#rec_flag a in\n let b = self#list self#type_declaration b in\n self#constr \"Pstr_type\" [ a; b ]\n | Pstr_typext a ->\n let a = self#type_extension a in\n self#constr \"Pstr_typext\" [ a ]\n | Pstr_exception a ->\n let a = self#type_exception a in\n self#constr \"Pstr_exception\" [ a ]\n | Pstr_module a ->\n let a = self#module_binding a in\n self#constr \"Pstr_module\" [ a ]\n | Pstr_recmodule a ->\n let a = self#list self#module_binding a in\n self#constr \"Pstr_recmodule\" [ a ]\n | Pstr_modtype a ->\n let a = self#module_type_declaration a in\n self#constr \"Pstr_modtype\" [ a ]\n | Pstr_open a ->\n let a = self#open_declaration a in\n self#constr \"Pstr_open\" [ a ]\n | Pstr_class a ->\n let a = self#list self#class_declaration a in\n self#constr \"Pstr_class\" [ a ]\n | Pstr_class_type a ->\n let a = self#list self#class_type_declaration a in\n self#constr \"Pstr_class_type\" [ a ]\n | Pstr_include a ->\n let a = self#include_declaration a in\n self#constr \"Pstr_include\" [ a ]\n | Pstr_attribute a ->\n let a = self#attribute a in\n self#constr \"Pstr_attribute\" [ a ]\n | Pstr_extension (a, b) ->\n let a = self#extension a in\n let b = self#attributes b in\n self#constr \"Pstr_extension\" [ a; b ]\n\n method value_binding : value_binding -> 'res =\n fun { pvb_pat; pvb_expr; pvb_attributes; pvb_loc } ->\n let pvb_pat = self#pattern pvb_pat in\n let pvb_expr = self#expression pvb_expr in\n let pvb_attributes = self#attributes pvb_attributes in\n let pvb_loc = self#location pvb_loc in\n self#record\n [\n (\"pvb_pat\", pvb_pat);\n (\"pvb_expr\", pvb_expr);\n (\"pvb_attributes\", pvb_attributes);\n (\"pvb_loc\", pvb_loc);\n ]\n\n method module_binding : module_binding -> 'res =\n fun { pmb_name; pmb_expr; pmb_attributes; pmb_loc } ->\n let pmb_name = self#loc (self#option self#string) pmb_name in\n let pmb_expr = self#module_expr pmb_expr in\n let pmb_attributes = self#attributes pmb_attributes in\n let pmb_loc = self#location pmb_loc in\n self#record\n [\n (\"pmb_name\", pmb_name);\n (\"pmb_expr\", pmb_expr);\n (\"pmb_attributes\", pmb_attributes);\n (\"pmb_loc\", pmb_loc);\n ]\n\n method toplevel_phrase : toplevel_phrase -> 'res =\n fun x ->\n match x with\n | Ptop_def a ->\n let a = self#structure a in\n self#constr \"Ptop_def\" [ a ]\n | Ptop_dir a ->\n let a = self#toplevel_directive a in\n self#constr \"Ptop_dir\" [ a ]\n\n method toplevel_directive : toplevel_directive -> 'res =\n fun { pdir_name; pdir_arg; pdir_loc } ->\n let pdir_name = self#loc self#string pdir_name in\n let pdir_arg = self#option self#directive_argument pdir_arg in\n let pdir_loc = self#location pdir_loc in\n self#record\n [\n (\"pdir_name\", pdir_name);\n (\"pdir_arg\", pdir_arg);\n (\"pdir_loc\", pdir_loc);\n ]\n\n method directive_argument : directive_argument -> 'res =\n fun { pdira_desc; pdira_loc } ->\n let pdira_desc = self#directive_argument_desc pdira_desc in\n let pdira_loc = self#location pdira_loc in\n self#record [ (\"pdira_desc\", pdira_desc); (\"pdira_loc\", pdira_loc) ]\n\n method directive_argument_desc : directive_argument_desc -> 'res =\n fun x ->\n match x with\n | Pdir_string a ->\n let a = self#string a in\n self#constr \"Pdir_string\" [ a ]\n | Pdir_int (a, b) ->\n let a = self#string a in\n let b = self#option self#char b in\n self#constr \"Pdir_int\" [ a; b ]\n | Pdir_ident a ->\n let a = self#longident a in\n self#constr \"Pdir_ident\" [ a ]\n | Pdir_bool a ->\n let a = self#bool a in\n self#constr \"Pdir_bool\" [ a ]\n\n method cases : cases -> 'res = self#list self#case\n end\n\n[@@@end]\n","type deriver = ..\n\nlet all = Hashtbl.create 42\n\nlet register name deriver =\n if Hashtbl.mem all name then\n Printf.ksprintf failwith\n \"Ppx_deriviers.register: %S is already registered\" name;\n Hashtbl.add all name deriver\n\nlet lookup name =\n match Hashtbl.find all name with\n | drv -> Some drv\n | exception Not_found -> None\n\nlet derivers () =\n Hashtbl.fold (fun name drv acc -> (name, drv) :: acc) all []\n","module T = struct\n type 'a map = 'a -> 'a\n type 'a iter = 'a -> unit\n type ('a, 'acc) fold = 'a -> 'acc -> 'acc\n type ('a, 'acc) fold_map = 'a -> 'acc -> 'a * 'acc\n type ('ctx, 'a) map_with_context = 'ctx -> 'a -> 'a\n type ('a, 'res) lift = 'a -> 'res\nend\n\nclass map =\n let any x = x in\n object\n method int : int T.map = any\n method string : string T.map = any\n method bool : bool T.map = any\n method char : char T.map = any\n\n method option : 'a. 'a T.map -> 'a option T.map =\n fun f x -> match x with None -> None | Some x -> Some (f x)\n\n method list : 'a. 'a T.map -> 'a list T.map = List.map\n method array : 'a. 'a T.map -> 'a array T.map = Array.map\n end\n\nclass iter =\n let any = ignore in\n object\n method int : int T.iter = any\n method string : string T.iter = any\n method bool : bool T.iter = any\n method char : char T.iter = any\n\n method option : 'a. 'a T.iter -> 'a option T.iter =\n fun f x -> match x with None -> () | Some x -> f x\n\n method list : 'a. 'a T.iter -> 'a list T.iter = List.iter\n method array : 'a. 'a T.iter -> 'a array T.iter = Array.iter\n end\n\nclass ['acc] fold =\n let any _ acc = acc in\n object\n method int : (int, 'acc) T.fold = any\n method string : (string, 'acc) T.fold = any\n method bool : (bool, 'acc) T.fold = any\n method char : (char, 'acc) T.fold = any\n\n method option : 'a. ('a, 'acc) T.fold -> ('a option, 'acc) T.fold =\n fun f x acc -> match x with None -> acc | Some x -> f x acc\n\n method list : 'a. ('a, 'acc) T.fold -> ('a list, 'acc) T.fold =\n let rec loop f l acc =\n match l with [] -> acc | x :: l -> loop f l (f x acc)\n in\n loop\n\n method array : 'a. ('a, 'acc) T.fold -> ('a array, 'acc) T.fold =\n fun f a acc ->\n let r = ref acc in\n for i = 0 to Array.length a - 1 do\n r := f (Array.unsafe_get a i) !r\n done;\n !r\n end\n\nclass ['acc] fold_map =\n let any x acc = (x, acc) in\n object\n method int : (int, 'acc) T.fold_map = any\n method string : (string, 'acc) T.fold_map = any\n method bool : (bool, 'acc) T.fold_map = any\n method char : (char, 'acc) T.fold_map = any\n\n method option : 'a. ('a, 'acc) T.fold_map -> ('a option, 'acc) T.fold_map =\n fun f x acc ->\n match x with\n | None -> (None, acc)\n | Some x ->\n let x, acc = f x acc in\n (Some x, acc)\n\n method list : 'a. ('a, 'acc) T.fold_map -> ('a list, 'acc) T.fold_map =\n let rec loop f l acc =\n match l with\n | [] -> ([], acc)\n | x :: l ->\n let x, acc = f x acc in\n let l, acc = loop f l acc in\n (x :: l, acc)\n in\n loop\n\n method array : 'a. ('a, 'acc) T.fold_map -> ('a array, 'acc) T.fold_map =\n fun f a acc ->\n let len = Array.length a in\n if len = 0 then (a, acc)\n else\n let x, acc = f (Array.unsafe_get a 0) acc in\n let a' = Array.make len x in\n let r = ref acc in\n for i = 1 to len - 1 do\n let x, acc = f (Array.unsafe_get a i) !r in\n Array.unsafe_set a' i x;\n r := acc\n done;\n (a', !r)\n end\n\nclass ['ctx] map_with_context =\n let any _ x = x in\n object\n method int : ('ctx, int) T.map_with_context = any\n method string : ('ctx, string) T.map_with_context = any\n method bool : ('ctx, bool) T.map_with_context = any\n method char : ('ctx, char) T.map_with_context = any\n\n method option\n : 'a.\n ('ctx, 'a) T.map_with_context -> ('ctx, 'a option) T.map_with_context\n =\n fun f ctx x -> match x with None -> None | Some x -> Some (f ctx x)\n\n method list\n : 'a.\n ('ctx, 'a) T.map_with_context -> ('ctx, 'a list) T.map_with_context =\n fun f ctx l -> List.map (f ctx) l\n\n method array\n : 'a.\n ('ctx, 'a) T.map_with_context -> ('ctx, 'a array) T.map_with_context =\n fun f ctx a -> Array.map (f ctx) a\n end\n\nclass virtual ['res] lift =\n object (self)\n method virtual other : 'a. ('a, 'res) T.lift\n method virtual int : (int, 'res) T.lift\n method virtual string : (string, 'res) T.lift\n method virtual bool : (bool, 'res) T.lift\n method virtual char : (char, 'res) T.lift\n method virtual array : 'a. ('a, 'res) T.lift -> ('a array, 'res) T.lift\n method virtual float : (float, 'res) T.lift\n method virtual int32 : (int32, 'res) T.lift\n method virtual int64 : (int64, 'res) T.lift\n method virtual nativeint : (nativeint, 'res) T.lift\n method virtual unit : (unit, 'res) T.lift\n method virtual record : (string * 'res) list -> 'res\n method virtual constr : string -> 'res list -> 'res\n method virtual tuple : 'res list -> 'res\n\n method option : 'a. ('a, 'res) T.lift -> ('a option, 'res) T.lift =\n fun f x ->\n match x with\n | None -> self#constr \"None\" []\n | Some x -> self#constr \"Some\" [ f x ]\n\n method list : 'a. ('a, 'res) T.lift -> ('a list, 'res) T.lift =\n fun f l ->\n match l with\n | [] -> self#constr \"[]\" []\n | x :: l -> self#constr \"::\" [ f x; self#list f l ]\n end\n\nclass type ['res] std_lifters =\n object\n method other : 'a. ('a, 'res) T.lift\n method int : (int, 'res) T.lift\n method string : (string, 'res) T.lift\n method bool : (bool, 'res) T.lift\n method char : (char, 'res) T.lift\n method array : 'a. ('a, 'res) T.lift -> ('a array, 'res) T.lift\n method record : (string * 'res) list -> 'res\n method constr : string -> 'res list -> 'res\n method tuple : 'res list -> 'res\n method float : (float, 'res) T.lift\n method int32 : (int32, 'res) T.lift\n method int64 : (int64, 'res) T.lift\n method nativeint : (nativeint, 'res) T.lift\n method unit : (unit, 'res) T.lift\n method option : 'a. ('a, 'res) T.lift -> ('a option, 'res) T.lift\n method list : 'a. ('a, 'res) T.lift -> ('a list, 'res) T.lift\n end\n","open! Import\n\nmodule T = struct\n type t = longident = Lident of string | Ldot of t * string | Lapply of t * t\n\n let compare : t -> t -> int = Poly.compare\n\n let is_normal_ident_char = function\n | 'A' .. 'Z' | 'a' .. 'z' | '0' .. '9' | '_' | '\\'' -> true\n | _ -> false\n\n let is_normal_ident = function\n | \"asr\" | \"land\" | \"lor\" | \"lsl\" | \"lsr\" | \"lxor\" | \"mod\" | \"or\" -> false\n | string -> String.for_all string ~f:is_normal_ident_char\n\n let short_name string =\n if is_normal_ident string then string else \"( \" ^ string ^ \" )\"\n\n let rec name = function\n | Lident s -> short_name s\n | Ldot (a, b) -> name a ^ \".\" ^ short_name b\n | Lapply (a, b) -> Printf.sprintf \"%s(%s)\" (name a) (name b)\n\n let sexp_of_t t = Sexp.Atom (name t)\nend\n\ninclude T\n\nlet rec flat accu = function\n | Lident s -> s :: accu\n | Ldot (lid, s) -> flat (s :: accu) lid\n | Lapply (_, _) -> invalid_arg \"Ppxlib.Longident.flatten\"\n\nlet flatten_exn lid = flat [] lid\n\nlet last_exn = function\n | Lident s -> s\n | Ldot (_, s) -> s\n | Lapply (_, _) -> invalid_arg \"Ppxlib.Longident.flatten\"\n\nlet unflatten ~init l = List.fold_left l ~init ~f:(fun acc s -> Ldot (acc, s))\n\n(* for cases without dotted operators (e.g. [parse \"A.B.C\"]) *)\nlet parse_simple s =\n match String.split_on_char s ~sep:'.' with\n | [] -> assert false\n | s :: l -> unflatten ~init:(Lident s) l\n\n(* handle [\"A.B.(+.+)\"] or [\"Vec.(.%.()<-)\"] *)\nlet parse s =\n let invalid () =\n invalid_arg (Printf.sprintf \"Ppxlib.Longident.parse: %S\" s)\n in\n match (String.index_opt s '(', String.rindex_opt s ')') with\n | None, None -> parse_simple s\n | None, _ | _, None -> invalid ()\n | Some l, Some r -> (\n if Int.(r <> String.length s - 1) then invalid ();\n let group =\n if Int.(r = l + 1) then \"()\"\n else String.trim (String.sub s ~pos:(l + 1) ~len:(r - l - 1))\n in\n if Int.(l = 0) then Lident group\n else if Char.(s.[l - 1] <> '.') then invalid ()\n else\n let before = String.sub s ~pos:0 ~len:(l - 1) in\n match String.split_on_char before ~sep:'.' with\n | [] -> assert false\n | s :: l -> Ldot (unflatten ~init:(Lident s) l, group))\n\nmodule Map = Map.Make (T)\nmodule Set = Set.Make (T)\n","open! Import\n\ntype t = {\n file_path : string;\n main_module_name : string;\n submodule_path : string loc list;\n value : string loc option;\n in_expr : bool;\n}\n\nlet top_level ~file_path =\n let main_module_name =\n file_path |> Caml.Filename.basename |> Caml.Filename.remove_extension\n |> String.capitalize_ascii\n in\n {\n file_path;\n main_module_name;\n submodule_path = [];\n value = None;\n in_expr = false;\n }\n\nlet file_path t = t.file_path\nlet main_module_name t = t.main_module_name\n\nlet submodule_path t =\n List.rev_map ~f:(fun located -> located.txt) t.submodule_path\n\nlet value t = Option.map ~f:(fun located -> located.txt) t.value\n\nlet fully_qualified_path t =\n let value = value t in\n let submodule_path =\n List.rev_map ~f:(fun located -> Some located.txt) t.submodule_path\n in\n let names = (Some t.main_module_name :: submodule_path) @ [ value ] in\n String.concat ~sep:\".\" @@ List.filter_opt names\n\nlet enter_expr t = { t with in_expr = true }\n\nlet enter_module ~loc module_name t =\n if t.in_expr then t\n else\n { t with submodule_path = { txt = module_name; loc } :: t.submodule_path }\n\nlet enter_value ~loc value_name t =\n if t.in_expr then t else { t with value = Some { txt = value_name; loc } }\n\nlet to_string_path t = String.concat ~sep:\".\" (t.file_path :: submodule_path t)\nlet with_string_path f ~loc ~path = f ~loc ~path:(to_string_path path);;\n\nlet module M = struct\n let a = \"lol\"\nend in\nM.a\n","open Import\nmodule L = Astlib.Location\n\ntype t = location = {\n loc_start : Lexing.position;\n loc_end : Lexing.position;\n loc_ghost : bool;\n}\n\nlet in_file name =\n let loc = { pos_fname = name; pos_lnum = 1; pos_bol = 0; pos_cnum = -1 } in\n { loc_start = loc; loc_end = loc; loc_ghost = true }\n\nlet set_filename loc fn =\n let loc_start = { loc.loc_start with pos_fname = fn } in\n let loc_end = { loc.loc_end with pos_fname = fn } in\n { loc with loc_start; loc_end }\n\nlet none = in_file \"_none_\"\n\nlet init lexbuf fname =\n let open Lexing in\n lexbuf.lex_curr_p <-\n { pos_fname = fname; pos_lnum = 1; pos_bol = 0; pos_cnum = 0 }\n\nlet raise_errorf ?loc fmt = L.raise_errorf ?loc fmt\nlet report_exception = L.report_exception\n\nlet of_lexbuf (lexbuf : Lexing.lexbuf) =\n {\n loc_start = lexbuf.lex_start_p;\n loc_end = lexbuf.lex_curr_p;\n loc_ghost = false;\n }\n\nlet print ppf t =\n Caml.Format.fprintf ppf \"File \\\"%s\\\", line %d, characters %d-%d:\"\n t.loc_start.pos_fname t.loc_start.pos_lnum\n (t.loc_start.pos_cnum - t.loc_start.pos_bol)\n (t.loc_end.pos_cnum - t.loc_start.pos_bol)\n\ntype nonrec 'a loc = 'a loc = { txt : 'a; loc : t }\n\nlet compare_pos p1 p2 =\n let open Lexing in\n let column p =\n (* Manual extract:\n The difference between pos_cnum and pos_bol is the character offset\n within the line (i.e. the column number, assuming each character is\n one column wide). *)\n p.pos_cnum - p.pos_bol\n in\n match Int.compare p1.pos_lnum p2.pos_lnum with\n | 0 -> Int.compare (column p1) (column p2)\n | n -> n\n\nlet min_pos p1 p2 = if compare_pos p1 p2 <= 0 then p1 else p2\nlet max_pos p1 p2 = if compare_pos p1 p2 >= 0 then p1 else p2\n\nlet compare loc1 loc2 =\n match compare_pos loc1.loc_start loc2.loc_start with\n | 0 -> compare_pos loc1.loc_end loc2.loc_end\n | n -> n\n\nmodule Error = struct\n include Ppxlib_ast.Location_error\n\n let createf ~loc fmt = Format.kasprintf (fun str -> make ~loc ~sub:[] str) fmt\nend\n\nlet error_extensionf ~loc fmt =\n Format.kasprintf\n (fun str -> Error.to_extension @@ Error.make ~loc ~sub:[] str)\n fmt\n\nexception Error = L.Error\n\nlet () =\n Caml.Printexc.register_printer (function\n | Error e -> Some (Error.message e)\n | _ -> None)\n","open Import\n\ntype t = Astlib.Location.Error.t\n\nlet to_extension (error : Astlib.Location.Error.t) =\n let open Astlib.Location.Error in\n let open Ast_helper in\n if not (is_well_formed error) then\n raise (Invalid_argument \"to_extension: expected kind Report_error\");\n let sub_msgs = sub_msgs error in\n let main_msg = main_msg error in\n let err_extension_name loc = { Location.loc; txt = \"ocaml.error\" } in\n let mk_string_constant x = Str.eval (Exp.constant (Const.string x)) in\n let extension_of_sub_msg (sub_msg : string Location.loc) =\n Str.extension\n (err_extension_name sub_msg.loc, PStr [ mk_string_constant sub_msg.txt ])\n in\n ( err_extension_name main_msg.loc,\n Parsetree.PStr\n (mk_string_constant main_msg.txt :: List.map extension_of_sub_msg sub_msgs)\n )\n\nlet register_error_of_exn = Astlib.Location.register_error_of_exn\n\nlet message error =\n let { Astlib.Location.txt; _ } = Astlib.Location.Error.main_msg error in\n txt\n\nlet set_message = Astlib.Location.Error.set_main_msg\n\nlet make ~loc txt ~sub =\n let sub = List.map (fun (loc, txt) -> { Astlib.Location.loc; txt }) sub in\n Astlib.Location.Error.make ~sub { loc; txt }\n\nlet update_loc = Astlib.Location.Error.set_main_loc\n\nlet get_location error =\n let { Astlib.Location.loc; _ } = Astlib.Location.Error.main_msg error in\n loc\n\nlet of_exn = Astlib.Location.Error.of_exn\nlet raise error = raise (Astlib.Location.Error error)\n","module Base = struct\n type t = { tool_name : string; code_path : Code_path.t; input_name : string }\n\n let top_level ~tool_name ~file_path ~input_name =\n let code_path = Code_path.top_level ~file_path in\n { tool_name; code_path; input_name }\n\n let code_path t = t.code_path\n let input_name t = t.input_name\n let tool_name t = t.tool_name\n let enter_expr t = { t with code_path = Code_path.enter_expr t.code_path }\n\n let enter_module ~loc name t =\n { t with code_path = Code_path.enter_module ~loc name t.code_path }\n\n let enter_value ~loc name t =\n { t with code_path = Code_path.enter_value ~loc name t.code_path }\nend\n\nmodule Extension = struct\n type t = { extension_point_loc : Location.t; base : Base.t }\n\n let make ~extension_point_loc ~base () = { extension_point_loc; base }\n let extension_point_loc t = t.extension_point_loc\n let code_path t = t.base.code_path\n let input_name t = t.base.input_name\n let tool_name t = t.base.tool_name\n\n let with_loc_and_path f ~ctxt =\n f ~loc:ctxt.extension_point_loc\n ~path:(Code_path.to_string_path ctxt.base.code_path)\nend\n\nmodule Deriver = struct\n type t = { derived_item_loc : Location.t; inline : bool; base : Base.t }\n\n let make ~derived_item_loc ~inline ~base () =\n { derived_item_loc; base; inline }\n\n let derived_item_loc t = t.derived_item_loc\n let code_path t = t.base.code_path\n let input_name t = t.base.input_name\n let tool_name t = t.base.tool_name\n let inline t = t.inline\n\n let with_loc_and_path f ~ctxt =\n f ~loc:ctxt.derived_item_loc\n ~path:(Code_path.to_string_path ctxt.base.code_path)\nend\n","open! Import\n\nclass map =\n object\n inherit Ppxlib_traverse_builtins.map\n inherit Ast.map\n end\n\nclass iter =\n object\n inherit Ppxlib_traverse_builtins.iter\n inherit Ast.iter\n end\n\nclass ['acc] fold =\n object\n inherit ['acc] Ppxlib_traverse_builtins.fold\n inherit ['acc] Ast.fold\n end\n\nclass ['acc] fold_map =\n object\n inherit ['acc] Ppxlib_traverse_builtins.fold_map\n inherit ['acc] Ast.fold_map\n end\n\nclass ['ctx] map_with_context =\n object\n inherit ['ctx] Ppxlib_traverse_builtins.map_with_context\n inherit ['ctx] Ast.map_with_context\n end\n\nclass virtual ['res] lift =\n object\n inherit ['res] Ppxlib_traverse_builtins.lift\n inherit ['res] Ast.lift\n end\n\nlet module_name = function None -> \"_\" | Some name -> name\nlet enter name path = if String.is_empty path then name else path ^ \".\" ^ name\nlet enter_opt name_opt path = enter (module_name name_opt) path\n\nclass map_with_path =\n object\n inherit [string] map_with_context as super\n\n (* WAS:\n method! structure_item_desc path x =\n match x with\n | Pstr_module mb -> super#structure_item_desc (enter mb.pmb_name.txt path) x\n | _ -> super#structure_item_desc path x\n\n Overriding [module_binding] seems to be OK because it does not catch\n local module bindings because at the moment the parsetree doesn't make\n use of [module_binding] for local modules, but that might change in the\n future, so this might be something to keep in mind.\n\n The following:\n\n module A = struct .. end\n module A = struct .. end\n\n is disallowed, but\n\n let _ = .. let module A = struct .. end in ..\n module A = struct .. end\n let _ = .. let module A = struct .. end in ..\n\n isn't, and the \"path\" constructed here would be able to differentiate\n between them. *)\n method! module_binding path mb =\n super#module_binding (enter_opt mb.pmb_name.txt path) mb\n\n method! module_declaration path md =\n super#module_declaration (enter_opt md.pmd_name.txt path) md\n\n method! module_type_declaration path mtd =\n super#module_type_declaration (enter mtd.pmtd_name.txt path) mtd\n end\n\nlet var_names_of =\n object\n inherit [string list] fold as super\n\n method! pattern p acc =\n let acc = super#pattern p acc in\n match p.ppat_desc with Ppat_var { txt; _ } -> txt :: acc | _ -> acc\n end\n\nlet ec_enter_module_opt ~loc name_opt ctxt =\n Expansion_context.Base.enter_module ~loc (module_name name_opt) ctxt\n\nclass map_with_expansion_context =\n object (self)\n inherit [Expansion_context.Base.t] map_with_context as super\n\n method! expression ctxt expr =\n super#expression (Expansion_context.Base.enter_expr ctxt) expr\n\n method! module_binding ctxt mb =\n super#module_binding\n (ec_enter_module_opt ~loc:mb.pmb_loc mb.pmb_name.txt ctxt)\n mb\n\n method! module_declaration ctxt md =\n super#module_declaration\n (ec_enter_module_opt ~loc:md.pmd_loc md.pmd_name.txt ctxt)\n md\n\n method! module_type_declaration ctxt mtd =\n super#module_type_declaration\n (Expansion_context.Base.enter_module ~loc:mtd.pmtd_loc mtd.pmtd_name.txt\n ctxt)\n mtd\n\n method! value_description ctxt vd =\n super#value_description\n (Expansion_context.Base.enter_value ~loc:vd.pval_loc vd.pval_name.txt\n ctxt)\n vd\n\n method! value_binding ctxt { pvb_pat; pvb_expr; pvb_attributes; pvb_loc } =\n let all_var_names = var_names_of#pattern pvb_pat [] in\n let var_name = Stdppx.List.last all_var_names in\n let in_binding_ctxt =\n match var_name with\n | None -> ctxt\n | Some var_name ->\n Expansion_context.Base.enter_value ~loc:pvb_loc var_name ctxt\n in\n let pvb_pat = self#pattern ctxt pvb_pat in\n let pvb_expr = self#expression in_binding_ctxt pvb_expr in\n let pvb_attributes = self#attributes in_binding_ctxt pvb_attributes in\n let pvb_loc = self#location ctxt pvb_loc in\n { pvb_pat; pvb_expr; pvb_attributes; pvb_loc }\n end\n\nclass sexp_of =\n object\n inherit [Sexp.t] Ast.lift\n method int = sexp_of_int\n method string = sexp_of_string\n method bool = sexp_of_bool\n method char = sexp_of_char\n method float = sexp_of_float\n method int32 = sexp_of_int32\n method int64 = sexp_of_int64\n method nativeint = sexp_of_nativeint\n method unit = sexp_of_unit\n method option = sexp_of_option\n method list = sexp_of_list\n method array : 'a. ('a -> Sexp.t) -> 'a array -> Sexp.t = sexp_of_array\n method other : 'a. 'a -> Sexp.t = fun _ -> Sexp.Atom \"_\"\n\n method record fields =\n List\n (List.map fields ~f:(fun (label, sexp) ->\n Sexp.List [ Atom label; sexp ]))\n\n method constr tag args =\n match args with [] -> Atom tag | _ -> List (Atom tag :: args)\n\n method tuple l = List l\n end\n\nlet sexp_of = new sexp_of\n","open! Import\n\nexception Cutoff_met\n\n(* As found here http://rosettacode.org/wiki/Levenshtein_distance#OCaml *)\nlet levenshtein_distance s t cutoff =\n let m = String.length s and n = String.length t in\n if cutoff = 0 || abs (m - n) >= cutoff then None\n else\n (* for all i and j, d.(i).(j) will hold the Levenshtein distance between the\n first i characters of s and the first j characters of t *)\n let d = Array.make_matrix ~dimx:(m + 1) ~dimy:(n + 1) 0 in\n for i = 0 to m do\n (* the distance of any first string to an empty second string *)\n d.(i).(0) <- i\n done;\n for j = 0 to n do\n (* the distance of any second string to an empty first string *)\n d.(0).(j) <- j\n done;\n (* the minimum of each line together with the column index will be used\n to notice cutoff exceeding and return early in that case *)\n let line_min = ref 0 in\n let distance =\n try\n for j = 1 to n do\n if !line_min >= cutoff - 1 && j >= cutoff - 1 then raise Cutoff_met;\n line_min := max m n;\n for i = 1 to m do\n let value =\n if Char.equal s.[i - 1] t.[j - 1] then d.(i - 1).(j - 1)\n (* no operation required *)\n else\n min\n (d.(i - 1).(j) + 1) (* a deletion *)\n (min\n (d.(i).(j - 1) + 1) (* an insertion *)\n (d.(i - 1).(j - 1) + 1) (* a substitution *))\n in\n d.(i).(j) <- value;\n line_min := min !line_min value\n done\n done;\n if d.(m).(n) < cutoff then Some d.(m).(n) else None\n with Cutoff_met -> None\n in\n distance\n\nlet spellcheck names name =\n let cutoff =\n match String.length name with\n | 1 | 2 -> 0\n | 3 | 4 -> 1\n | 5 | 6 -> 2\n | _ -> 3\n in\n let _, suggestions =\n List.fold_left names ~init:(Int.max_int, [])\n ~f:(fun ((best_distance, names_at_best_distance) as acc) registered_name\n ->\n match levenshtein_distance name registered_name cutoff with\n | None -> acc\n | Some dist ->\n if dist < best_distance then (dist, [ registered_name ])\n else if dist > best_distance then acc\n else (dist, registered_name :: names_at_best_distance))\n in\n match List.rev suggestions |> List.filter ~f:(String.( <> ) name) with\n | [] -> None\n | last :: rev_rest ->\n Some\n (Printf.sprintf \"Hint: Did you mean %s%s%s?\"\n (String.concat ~sep:\", \" (List.rev rev_rest))\n (if List.is_empty rev_rest then \"\" else \" or \")\n last)\n","open! Import\n\nexception Expected of Location.t * string\n\nlet fail loc expected = raise (Expected (loc, expected))\n\ntype context = {\n (* [matched] counts how many constructors have been matched. This is used to find what\n pattern matches the most some piece of ast in [Ast_pattern.alt]. In the case where\n all branches fail to match, we report the error from the one that matches the\n most.\n\n This is only incremented by combinators that can fail. *)\n mutable matched : int;\n}\n\ntype ('matched_value, 'k, 'k_result) t =\n | T of (context -> Location.t -> 'matched_value -> 'k -> 'k_result)\n","open Import\nmodule M =\n struct\n let attribute ~loc ~name ~payload =\n { attr_name = name; attr_payload = payload; attr_loc = loc }\n let binding_op ~loc ~op ~pat ~exp =\n { pbop_op = op; pbop_pat = pat; pbop_exp = exp; pbop_loc = loc }\n let case ~lhs ~guard ~rhs =\n { pc_lhs = lhs; pc_guard = guard; pc_rhs = rhs }\n let pcl_constr ~loc x0 x1 =\n { pcl_attributes = []; pcl_loc = loc; pcl_desc = (Pcl_constr (x0, x1))\n }\n let pcl_structure ~loc x0 =\n { pcl_attributes = []; pcl_loc = loc; pcl_desc = (Pcl_structure x0) }\n let pcl_fun ~loc x0 x1 x2 x3 =\n {\n pcl_attributes = [];\n pcl_loc = loc;\n pcl_desc = (Pcl_fun (x0, x1, x2, x3))\n }\n let pcl_apply ~loc x0 x1 =\n { pcl_attributes = []; pcl_loc = loc; pcl_desc = (Pcl_apply (x0, x1)) }\n let pcl_let ~loc x0 x1 x2 =\n { pcl_attributes = []; pcl_loc = loc; pcl_desc = (Pcl_let (x0, x1, x2))\n }\n let pcl_constraint ~loc x0 x1 =\n {\n pcl_attributes = [];\n pcl_loc = loc;\n pcl_desc = (Pcl_constraint (x0, x1))\n }\n let pcl_extension ~loc x0 =\n { pcl_attributes = []; pcl_loc = loc; pcl_desc = (Pcl_extension x0) }\n let pcl_open ~loc x0 x1 =\n { pcl_attributes = []; pcl_loc = loc; pcl_desc = (Pcl_open (x0, x1)) }\n let pcf_inherit ~loc x0 x1 x2 =\n {\n pcf_attributes = [];\n pcf_loc = loc;\n pcf_desc = (Pcf_inherit (x0, x1, x2))\n }\n let pcf_val ~loc x0 =\n { pcf_attributes = []; pcf_loc = loc; pcf_desc = (Pcf_val x0) }\n let pcf_method ~loc x0 =\n { pcf_attributes = []; pcf_loc = loc; pcf_desc = (Pcf_method x0) }\n let pcf_constraint ~loc x0 =\n { pcf_attributes = []; pcf_loc = loc; pcf_desc = (Pcf_constraint x0) }\n let pcf_initializer ~loc x0 =\n { pcf_attributes = []; pcf_loc = loc; pcf_desc = (Pcf_initializer x0) }\n let pcf_attribute ~loc x0 =\n { pcf_attributes = []; pcf_loc = loc; pcf_desc = (Pcf_attribute x0) }\n let pcf_extension ~loc x0 =\n { pcf_attributes = []; pcf_loc = loc; pcf_desc = (Pcf_extension x0) }\n let class_infos ~loc ~virt ~params ~name ~expr =\n {\n pci_virt = virt;\n pci_params = params;\n pci_name = name;\n pci_expr = expr;\n pci_loc = loc;\n pci_attributes = []\n }\n let class_signature ~self ~fields =\n { pcsig_self = self; pcsig_fields = fields }\n let class_structure ~self ~fields =\n { pcstr_self = self; pcstr_fields = fields }\n let pcty_constr ~loc x0 x1 =\n {\n pcty_attributes = [];\n pcty_loc = loc;\n pcty_desc = (Pcty_constr (x0, x1))\n }\n let pcty_signature ~loc x0 =\n { pcty_attributes = []; pcty_loc = loc; pcty_desc = (Pcty_signature x0)\n }\n let pcty_arrow ~loc x0 x1 x2 =\n {\n pcty_attributes = [];\n pcty_loc = loc;\n pcty_desc = (Pcty_arrow (x0, x1, x2))\n }\n let pcty_extension ~loc x0 =\n { pcty_attributes = []; pcty_loc = loc; pcty_desc = (Pcty_extension x0)\n }\n let pcty_open ~loc x0 x1 =\n {\n pcty_attributes = [];\n pcty_loc = loc;\n pcty_desc = (Pcty_open (x0, x1))\n }\n let pctf_inherit ~loc x0 =\n { pctf_attributes = []; pctf_loc = loc; pctf_desc = (Pctf_inherit x0) }\n let pctf_val ~loc x0 =\n { pctf_attributes = []; pctf_loc = loc; pctf_desc = (Pctf_val x0) }\n let pctf_method ~loc x0 =\n { pctf_attributes = []; pctf_loc = loc; pctf_desc = (Pctf_method x0) }\n let pctf_constraint ~loc x0 =\n {\n pctf_attributes = [];\n pctf_loc = loc;\n pctf_desc = (Pctf_constraint x0)\n }\n let pctf_attribute ~loc x0 =\n { pctf_attributes = []; pctf_loc = loc; pctf_desc = (Pctf_attribute x0)\n }\n let pctf_extension ~loc x0 =\n { pctf_attributes = []; pctf_loc = loc; pctf_desc = (Pctf_extension x0)\n }\n let constructor_declaration ~loc ~name ~args ~res =\n {\n pcd_name = name;\n pcd_args = args;\n pcd_res = res;\n pcd_loc = loc;\n pcd_attributes = []\n }\n let ptyp_any ~loc =\n {\n ptyp_loc_stack = [];\n ptyp_attributes = [];\n ptyp_loc = loc;\n ptyp_desc = Ptyp_any\n }\n let ptyp_var ~loc x0 =\n {\n ptyp_loc_stack = [];\n ptyp_attributes = [];\n ptyp_loc = loc;\n ptyp_desc = (Ptyp_var x0)\n }\n let ptyp_arrow ~loc x0 x1 x2 =\n {\n ptyp_loc_stack = [];\n ptyp_attributes = [];\n ptyp_loc = loc;\n ptyp_desc = (Ptyp_arrow (x0, x1, x2))\n }\n let ptyp_tuple ~loc x0 =\n {\n ptyp_loc_stack = [];\n ptyp_attributes = [];\n ptyp_loc = loc;\n ptyp_desc = (Ptyp_tuple x0)\n }\n let ptyp_constr ~loc x0 x1 =\n {\n ptyp_loc_stack = [];\n ptyp_attributes = [];\n ptyp_loc = loc;\n ptyp_desc = (Ptyp_constr (x0, x1))\n }\n let ptyp_object ~loc x0 x1 =\n {\n ptyp_loc_stack = [];\n ptyp_attributes = [];\n ptyp_loc = loc;\n ptyp_desc = (Ptyp_object (x0, x1))\n }\n let ptyp_class ~loc x0 x1 =\n {\n ptyp_loc_stack = [];\n ptyp_attributes = [];\n ptyp_loc = loc;\n ptyp_desc = (Ptyp_class (x0, x1))\n }\n let ptyp_alias ~loc x0 x1 =\n {\n ptyp_loc_stack = [];\n ptyp_attributes = [];\n ptyp_loc = loc;\n ptyp_desc = (Ptyp_alias (x0, x1))\n }\n let ptyp_variant ~loc x0 x1 x2 =\n {\n ptyp_loc_stack = [];\n ptyp_attributes = [];\n ptyp_loc = loc;\n ptyp_desc = (Ptyp_variant (x0, x1, x2))\n }\n let ptyp_poly ~loc x0 x1 =\n {\n ptyp_loc_stack = [];\n ptyp_attributes = [];\n ptyp_loc = loc;\n ptyp_desc = (Ptyp_poly (x0, x1))\n }\n let ptyp_package ~loc x0 =\n {\n ptyp_loc_stack = [];\n ptyp_attributes = [];\n ptyp_loc = loc;\n ptyp_desc = (Ptyp_package x0)\n }\n let ptyp_extension ~loc x0 =\n {\n ptyp_loc_stack = [];\n ptyp_attributes = [];\n ptyp_loc = loc;\n ptyp_desc = (Ptyp_extension x0)\n }\n let pdir_string ~loc x0 =\n { pdira_loc = loc; pdira_desc = (Pdir_string x0) }\n let pdir_int ~loc x0 x1 =\n { pdira_loc = loc; pdira_desc = (Pdir_int (x0, x1)) }\n let pdir_ident ~loc x0 =\n { pdira_loc = loc; pdira_desc = (Pdir_ident x0) }\n let pdir_bool ~loc x0 = { pdira_loc = loc; pdira_desc = (Pdir_bool x0) }\n let pexp_ident ~loc x0 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_ident x0)\n }\n let pexp_constant ~loc x0 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_constant x0)\n }\n let pexp_let ~loc x0 x1 x2 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_let (x0, x1, x2))\n }\n let pexp_function ~loc x0 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_function x0)\n }\n let pexp_fun ~loc x0 x1 x2 x3 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_fun (x0, x1, x2, x3))\n }\n let pexp_apply ~loc x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_apply (x0, x1))\n }\n let pexp_match ~loc x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_match (x0, x1))\n }\n let pexp_try ~loc x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_try (x0, x1))\n }\n let pexp_tuple ~loc x0 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_tuple x0)\n }\n let pexp_construct ~loc x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_construct (x0, x1))\n }\n let pexp_variant ~loc x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_variant (x0, x1))\n }\n let pexp_record ~loc x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_record (x0, x1))\n }\n let pexp_field ~loc x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_field (x0, x1))\n }\n let pexp_setfield ~loc x0 x1 x2 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_setfield (x0, x1, x2))\n }\n let pexp_array ~loc x0 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_array x0)\n }\n let pexp_ifthenelse ~loc x0 x1 x2 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_ifthenelse (x0, x1, x2))\n }\n let pexp_sequence ~loc x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_sequence (x0, x1))\n }\n let pexp_while ~loc x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_while (x0, x1))\n }\n let pexp_for ~loc x0 x1 x2 x3 x4 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_for (x0, x1, x2, x3, x4))\n }\n let pexp_constraint ~loc x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_constraint (x0, x1))\n }\n let pexp_coerce ~loc x0 x1 x2 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_coerce (x0, x1, x2))\n }\n let pexp_send ~loc x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_send (x0, x1))\n }\n let pexp_new ~loc x0 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_new x0)\n }\n let pexp_setinstvar ~loc x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_setinstvar (x0, x1))\n }\n let pexp_override ~loc x0 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_override x0)\n }\n let pexp_letmodule ~loc x0 x1 x2 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_letmodule (x0, x1, x2))\n }\n let pexp_letexception ~loc x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_letexception (x0, x1))\n }\n let pexp_assert ~loc x0 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_assert x0)\n }\n let pexp_lazy ~loc x0 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_lazy x0)\n }\n let pexp_poly ~loc x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_poly (x0, x1))\n }\n let pexp_object ~loc x0 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_object x0)\n }\n let pexp_newtype ~loc x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_newtype (x0, x1))\n }\n let pexp_pack ~loc x0 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_pack x0)\n }\n let pexp_open ~loc x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_open (x0, x1))\n }\n let pexp_letop ~loc x0 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_letop x0)\n }\n let pexp_extension ~loc x0 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_extension x0)\n }\n let pexp_unreachable ~loc =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = Pexp_unreachable\n }\n let extension_constructor ~loc ~name ~kind =\n {\n pext_name = name;\n pext_kind = kind;\n pext_loc = loc;\n pext_attributes = []\n }\n let include_infos ~loc mod_ =\n { pincl_mod = mod_; pincl_loc = loc; pincl_attributes = [] }\n let label_declaration ~loc ~name ~mutable_ ~type_ =\n {\n pld_name = name;\n pld_mutable = mutable_;\n pld_type = type_;\n pld_loc = loc;\n pld_attributes = []\n }\n let letop ~let_ ~ands ~body = { let_; ands; body }\n let location ~start ~end_ ~ghost =\n { loc_start = start; loc_end = end_; loc_ghost = ghost }\n let module_binding ~loc ~name ~expr =\n { pmb_name = name; pmb_expr = expr; pmb_attributes = []; pmb_loc = loc\n }\n let module_declaration ~loc ~name ~type_ =\n { pmd_name = name; pmd_type = type_; pmd_attributes = []; pmd_loc = loc\n }\n let pmod_ident ~loc x0 =\n { pmod_attributes = []; pmod_loc = loc; pmod_desc = (Pmod_ident x0) }\n let pmod_structure ~loc x0 =\n { pmod_attributes = []; pmod_loc = loc; pmod_desc = (Pmod_structure x0)\n }\n let pmod_functor ~loc x0 x1 =\n {\n pmod_attributes = [];\n pmod_loc = loc;\n pmod_desc = (Pmod_functor (x0, x1))\n }\n let pmod_apply ~loc x0 x1 =\n {\n pmod_attributes = [];\n pmod_loc = loc;\n pmod_desc = (Pmod_apply (x0, x1))\n }\n let pmod_constraint ~loc x0 x1 =\n {\n pmod_attributes = [];\n pmod_loc = loc;\n pmod_desc = (Pmod_constraint (x0, x1))\n }\n let pmod_unpack ~loc x0 =\n { pmod_attributes = []; pmod_loc = loc; pmod_desc = (Pmod_unpack x0) }\n let pmod_extension ~loc x0 =\n { pmod_attributes = []; pmod_loc = loc; pmod_desc = (Pmod_extension x0)\n }\n let module_substitution ~loc ~name ~manifest =\n {\n pms_name = name;\n pms_manifest = manifest;\n pms_attributes = [];\n pms_loc = loc\n }\n let pmty_ident ~loc x0 =\n { pmty_attributes = []; pmty_loc = loc; pmty_desc = (Pmty_ident x0) }\n let pmty_signature ~loc x0 =\n { pmty_attributes = []; pmty_loc = loc; pmty_desc = (Pmty_signature x0)\n }\n let pmty_functor ~loc x0 x1 =\n {\n pmty_attributes = [];\n pmty_loc = loc;\n pmty_desc = (Pmty_functor (x0, x1))\n }\n let pmty_with ~loc x0 x1 =\n {\n pmty_attributes = [];\n pmty_loc = loc;\n pmty_desc = (Pmty_with (x0, x1))\n }\n let pmty_typeof ~loc x0 =\n { pmty_attributes = []; pmty_loc = loc; pmty_desc = (Pmty_typeof x0) }\n let pmty_extension ~loc x0 =\n { pmty_attributes = []; pmty_loc = loc; pmty_desc = (Pmty_extension x0)\n }\n let pmty_alias ~loc x0 =\n { pmty_attributes = []; pmty_loc = loc; pmty_desc = (Pmty_alias x0) }\n let module_type_declaration ~loc ~name ~type_ =\n {\n pmtd_name = name;\n pmtd_type = type_;\n pmtd_attributes = [];\n pmtd_loc = loc\n }\n let otag ~loc x0 x1 =\n { pof_attributes = []; pof_loc = loc; pof_desc = (Otag (x0, x1)) }\n let oinherit ~loc x0 =\n { pof_attributes = []; pof_loc = loc; pof_desc = (Oinherit x0) }\n let open_infos ~loc ~expr ~override =\n {\n popen_expr = expr;\n popen_override = override;\n popen_loc = loc;\n popen_attributes = []\n }\n let ppat_any ~loc =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = Ppat_any\n }\n let ppat_var ~loc x0 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_var x0)\n }\n let ppat_alias ~loc x0 x1 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_alias (x0, x1))\n }\n let ppat_constant ~loc x0 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_constant x0)\n }\n let ppat_interval ~loc x0 x1 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_interval (x0, x1))\n }\n let ppat_tuple ~loc x0 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_tuple x0)\n }\n let ppat_construct ~loc x0 x1 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_construct (x0, x1))\n }\n let ppat_variant ~loc x0 x1 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_variant (x0, x1))\n }\n let ppat_record ~loc x0 x1 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_record (x0, x1))\n }\n let ppat_array ~loc x0 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_array x0)\n }\n let ppat_or ~loc x0 x1 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_or (x0, x1))\n }\n let ppat_constraint ~loc x0 x1 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_constraint (x0, x1))\n }\n let ppat_type ~loc x0 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_type x0)\n }\n let ppat_lazy ~loc x0 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_lazy x0)\n }\n let ppat_unpack ~loc x0 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_unpack x0)\n }\n let ppat_exception ~loc x0 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_exception x0)\n }\n let ppat_extension ~loc x0 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_extension x0)\n }\n let ppat_open ~loc x0 x1 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_open (x0, x1))\n }\n let position ~fname ~lnum ~bol ~cnum =\n { pos_fname = fname; pos_lnum = lnum; pos_bol = bol; pos_cnum = cnum }\n let rtag ~loc x0 x1 x2 =\n { prf_attributes = []; prf_loc = loc; prf_desc = (Rtag (x0, x1, x2)) }\n let rinherit ~loc x0 =\n { prf_attributes = []; prf_loc = loc; prf_desc = (Rinherit x0) }\n let psig_value ~loc x0 = { psig_loc = loc; psig_desc = (Psig_value x0) }\n let psig_type ~loc x0 x1 =\n { psig_loc = loc; psig_desc = (Psig_type (x0, x1)) }\n let psig_typesubst ~loc x0 =\n { psig_loc = loc; psig_desc = (Psig_typesubst x0) }\n let psig_typext ~loc x0 =\n { psig_loc = loc; psig_desc = (Psig_typext x0) }\n let psig_exception ~loc x0 =\n { psig_loc = loc; psig_desc = (Psig_exception x0) }\n let psig_module ~loc x0 =\n { psig_loc = loc; psig_desc = (Psig_module x0) }\n let psig_modsubst ~loc x0 =\n { psig_loc = loc; psig_desc = (Psig_modsubst x0) }\n let psig_recmodule ~loc x0 =\n { psig_loc = loc; psig_desc = (Psig_recmodule x0) }\n let psig_modtype ~loc x0 =\n { psig_loc = loc; psig_desc = (Psig_modtype x0) }\n let psig_open ~loc x0 = { psig_loc = loc; psig_desc = (Psig_open x0) }\n let psig_include ~loc x0 =\n { psig_loc = loc; psig_desc = (Psig_include x0) }\n let psig_class ~loc x0 = { psig_loc = loc; psig_desc = (Psig_class x0) }\n let psig_class_type ~loc x0 =\n { psig_loc = loc; psig_desc = (Psig_class_type x0) }\n let psig_attribute ~loc x0 =\n { psig_loc = loc; psig_desc = (Psig_attribute x0) }\n let psig_extension ~loc x0 x1 =\n { psig_loc = loc; psig_desc = (Psig_extension (x0, x1)) }\n let pstr_eval ~loc x0 x1 =\n { pstr_loc = loc; pstr_desc = (Pstr_eval (x0, x1)) }\n let pstr_value ~loc x0 x1 =\n { pstr_loc = loc; pstr_desc = (Pstr_value (x0, x1)) }\n let pstr_primitive ~loc x0 =\n { pstr_loc = loc; pstr_desc = (Pstr_primitive x0) }\n let pstr_type ~loc x0 x1 =\n { pstr_loc = loc; pstr_desc = (Pstr_type (x0, x1)) }\n let pstr_typext ~loc x0 =\n { pstr_loc = loc; pstr_desc = (Pstr_typext x0) }\n let pstr_exception ~loc x0 =\n { pstr_loc = loc; pstr_desc = (Pstr_exception x0) }\n let pstr_module ~loc x0 =\n { pstr_loc = loc; pstr_desc = (Pstr_module x0) }\n let pstr_recmodule ~loc x0 =\n { pstr_loc = loc; pstr_desc = (Pstr_recmodule x0) }\n let pstr_modtype ~loc x0 =\n { pstr_loc = loc; pstr_desc = (Pstr_modtype x0) }\n let pstr_open ~loc x0 = { pstr_loc = loc; pstr_desc = (Pstr_open x0) }\n let pstr_class ~loc x0 = { pstr_loc = loc; pstr_desc = (Pstr_class x0) }\n let pstr_class_type ~loc x0 =\n { pstr_loc = loc; pstr_desc = (Pstr_class_type x0) }\n let pstr_include ~loc x0 =\n { pstr_loc = loc; pstr_desc = (Pstr_include x0) }\n let pstr_attribute ~loc x0 =\n { pstr_loc = loc; pstr_desc = (Pstr_attribute x0) }\n let pstr_extension ~loc x0 x1 =\n { pstr_loc = loc; pstr_desc = (Pstr_extension (x0, x1)) }\n let toplevel_directive ~loc ~name ~arg =\n { pdir_name = name; pdir_arg = arg; pdir_loc = loc }\n let type_declaration ~loc ~name ~params ~cstrs ~kind ~private_ \n ~manifest =\n {\n ptype_name = name;\n ptype_params = params;\n ptype_cstrs = cstrs;\n ptype_kind = kind;\n ptype_private = private_;\n ptype_manifest = manifest;\n ptype_attributes = [];\n ptype_loc = loc\n }\n let type_exception ~loc constructor =\n {\n ptyexn_constructor = constructor;\n ptyexn_loc = loc;\n ptyexn_attributes = []\n }\n let type_extension ~loc ~path ~params ~constructors ~private_ =\n {\n ptyext_path = path;\n ptyext_params = params;\n ptyext_constructors = constructors;\n ptyext_private = private_;\n ptyext_loc = loc;\n ptyext_attributes = []\n }\n let value_binding ~loc ~pat ~expr =\n { pvb_pat = pat; pvb_expr = expr; pvb_attributes = []; pvb_loc = loc }\n let value_description ~loc ~name ~type_ ~prim =\n {\n pval_name = name;\n pval_type = type_;\n pval_prim = prim;\n pval_attributes = [];\n pval_loc = loc\n }\n end\nmodule Make(Loc:sig val loc : Location.t end) =\n struct\n let loc = Loc.loc\n let attribute ~name ~payload =\n { attr_name = name; attr_payload = payload; attr_loc = loc }\n let binding_op ~op ~pat ~exp =\n { pbop_op = op; pbop_pat = pat; pbop_exp = exp; pbop_loc = loc }\n let case ~lhs ~guard ~rhs =\n { pc_lhs = lhs; pc_guard = guard; pc_rhs = rhs }\n let pcl_constr x0 x1 =\n { pcl_attributes = []; pcl_loc = loc; pcl_desc = (Pcl_constr (x0, x1))\n }\n let pcl_structure x0 =\n { pcl_attributes = []; pcl_loc = loc; pcl_desc = (Pcl_structure x0) }\n let pcl_fun x0 x1 x2 x3 =\n {\n pcl_attributes = [];\n pcl_loc = loc;\n pcl_desc = (Pcl_fun (x0, x1, x2, x3))\n }\n let pcl_apply x0 x1 =\n { pcl_attributes = []; pcl_loc = loc; pcl_desc = (Pcl_apply (x0, x1)) }\n let pcl_let x0 x1 x2 =\n { pcl_attributes = []; pcl_loc = loc; pcl_desc = (Pcl_let (x0, x1, x2))\n }\n let pcl_constraint x0 x1 =\n {\n pcl_attributes = [];\n pcl_loc = loc;\n pcl_desc = (Pcl_constraint (x0, x1))\n }\n let pcl_extension x0 =\n { pcl_attributes = []; pcl_loc = loc; pcl_desc = (Pcl_extension x0) }\n let pcl_open x0 x1 =\n { pcl_attributes = []; pcl_loc = loc; pcl_desc = (Pcl_open (x0, x1)) }\n let pcf_inherit x0 x1 x2 =\n {\n pcf_attributes = [];\n pcf_loc = loc;\n pcf_desc = (Pcf_inherit (x0, x1, x2))\n }\n let pcf_val x0 =\n { pcf_attributes = []; pcf_loc = loc; pcf_desc = (Pcf_val x0) }\n let pcf_method x0 =\n { pcf_attributes = []; pcf_loc = loc; pcf_desc = (Pcf_method x0) }\n let pcf_constraint x0 =\n { pcf_attributes = []; pcf_loc = loc; pcf_desc = (Pcf_constraint x0) }\n let pcf_initializer x0 =\n { pcf_attributes = []; pcf_loc = loc; pcf_desc = (Pcf_initializer x0) }\n let pcf_attribute x0 =\n { pcf_attributes = []; pcf_loc = loc; pcf_desc = (Pcf_attribute x0) }\n let pcf_extension x0 =\n { pcf_attributes = []; pcf_loc = loc; pcf_desc = (Pcf_extension x0) }\n let class_infos ~virt ~params ~name ~expr =\n {\n pci_virt = virt;\n pci_params = params;\n pci_name = name;\n pci_expr = expr;\n pci_loc = loc;\n pci_attributes = []\n }\n let class_signature ~self ~fields =\n { pcsig_self = self; pcsig_fields = fields }\n let class_structure ~self ~fields =\n { pcstr_self = self; pcstr_fields = fields }\n let pcty_constr x0 x1 =\n {\n pcty_attributes = [];\n pcty_loc = loc;\n pcty_desc = (Pcty_constr (x0, x1))\n }\n let pcty_signature x0 =\n { pcty_attributes = []; pcty_loc = loc; pcty_desc = (Pcty_signature x0)\n }\n let pcty_arrow x0 x1 x2 =\n {\n pcty_attributes = [];\n pcty_loc = loc;\n pcty_desc = (Pcty_arrow (x0, x1, x2))\n }\n let pcty_extension x0 =\n { pcty_attributes = []; pcty_loc = loc; pcty_desc = (Pcty_extension x0)\n }\n let pcty_open x0 x1 =\n {\n pcty_attributes = [];\n pcty_loc = loc;\n pcty_desc = (Pcty_open (x0, x1))\n }\n let pctf_inherit x0 =\n { pctf_attributes = []; pctf_loc = loc; pctf_desc = (Pctf_inherit x0) }\n let pctf_val x0 =\n { pctf_attributes = []; pctf_loc = loc; pctf_desc = (Pctf_val x0) }\n let pctf_method x0 =\n { pctf_attributes = []; pctf_loc = loc; pctf_desc = (Pctf_method x0) }\n let pctf_constraint x0 =\n {\n pctf_attributes = [];\n pctf_loc = loc;\n pctf_desc = (Pctf_constraint x0)\n }\n let pctf_attribute x0 =\n { pctf_attributes = []; pctf_loc = loc; pctf_desc = (Pctf_attribute x0)\n }\n let pctf_extension x0 =\n { pctf_attributes = []; pctf_loc = loc; pctf_desc = (Pctf_extension x0)\n }\n let constructor_declaration ~name ~args ~res =\n {\n pcd_name = name;\n pcd_args = args;\n pcd_res = res;\n pcd_loc = loc;\n pcd_attributes = []\n }\n let ptyp_any =\n {\n ptyp_loc_stack = [];\n ptyp_attributes = [];\n ptyp_loc = loc;\n ptyp_desc = Ptyp_any\n }\n let ptyp_var x0 =\n {\n ptyp_loc_stack = [];\n ptyp_attributes = [];\n ptyp_loc = loc;\n ptyp_desc = (Ptyp_var x0)\n }\n let ptyp_arrow x0 x1 x2 =\n {\n ptyp_loc_stack = [];\n ptyp_attributes = [];\n ptyp_loc = loc;\n ptyp_desc = (Ptyp_arrow (x0, x1, x2))\n }\n let ptyp_tuple x0 =\n {\n ptyp_loc_stack = [];\n ptyp_attributes = [];\n ptyp_loc = loc;\n ptyp_desc = (Ptyp_tuple x0)\n }\n let ptyp_constr x0 x1 =\n {\n ptyp_loc_stack = [];\n ptyp_attributes = [];\n ptyp_loc = loc;\n ptyp_desc = (Ptyp_constr (x0, x1))\n }\n let ptyp_object x0 x1 =\n {\n ptyp_loc_stack = [];\n ptyp_attributes = [];\n ptyp_loc = loc;\n ptyp_desc = (Ptyp_object (x0, x1))\n }\n let ptyp_class x0 x1 =\n {\n ptyp_loc_stack = [];\n ptyp_attributes = [];\n ptyp_loc = loc;\n ptyp_desc = (Ptyp_class (x0, x1))\n }\n let ptyp_alias x0 x1 =\n {\n ptyp_loc_stack = [];\n ptyp_attributes = [];\n ptyp_loc = loc;\n ptyp_desc = (Ptyp_alias (x0, x1))\n }\n let ptyp_variant x0 x1 x2 =\n {\n ptyp_loc_stack = [];\n ptyp_attributes = [];\n ptyp_loc = loc;\n ptyp_desc = (Ptyp_variant (x0, x1, x2))\n }\n let ptyp_poly x0 x1 =\n {\n ptyp_loc_stack = [];\n ptyp_attributes = [];\n ptyp_loc = loc;\n ptyp_desc = (Ptyp_poly (x0, x1))\n }\n let ptyp_package x0 =\n {\n ptyp_loc_stack = [];\n ptyp_attributes = [];\n ptyp_loc = loc;\n ptyp_desc = (Ptyp_package x0)\n }\n let ptyp_extension x0 =\n {\n ptyp_loc_stack = [];\n ptyp_attributes = [];\n ptyp_loc = loc;\n ptyp_desc = (Ptyp_extension x0)\n }\n let pdir_string x0 = { pdira_loc = loc; pdira_desc = (Pdir_string x0) }\n let pdir_int x0 x1 =\n { pdira_loc = loc; pdira_desc = (Pdir_int (x0, x1)) }\n let pdir_ident x0 = { pdira_loc = loc; pdira_desc = (Pdir_ident x0) }\n let pdir_bool x0 = { pdira_loc = loc; pdira_desc = (Pdir_bool x0) }\n let pexp_ident x0 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_ident x0)\n }\n let pexp_constant x0 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_constant x0)\n }\n let pexp_let x0 x1 x2 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_let (x0, x1, x2))\n }\n let pexp_function x0 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_function x0)\n }\n let pexp_fun x0 x1 x2 x3 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_fun (x0, x1, x2, x3))\n }\n let pexp_apply x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_apply (x0, x1))\n }\n let pexp_match x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_match (x0, x1))\n }\n let pexp_try x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_try (x0, x1))\n }\n let pexp_tuple x0 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_tuple x0)\n }\n let pexp_construct x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_construct (x0, x1))\n }\n let pexp_variant x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_variant (x0, x1))\n }\n let pexp_record x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_record (x0, x1))\n }\n let pexp_field x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_field (x0, x1))\n }\n let pexp_setfield x0 x1 x2 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_setfield (x0, x1, x2))\n }\n let pexp_array x0 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_array x0)\n }\n let pexp_ifthenelse x0 x1 x2 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_ifthenelse (x0, x1, x2))\n }\n let pexp_sequence x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_sequence (x0, x1))\n }\n let pexp_while x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_while (x0, x1))\n }\n let pexp_for x0 x1 x2 x3 x4 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_for (x0, x1, x2, x3, x4))\n }\n let pexp_constraint x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_constraint (x0, x1))\n }\n let pexp_coerce x0 x1 x2 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_coerce (x0, x1, x2))\n }\n let pexp_send x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_send (x0, x1))\n }\n let pexp_new x0 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_new x0)\n }\n let pexp_setinstvar x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_setinstvar (x0, x1))\n }\n let pexp_override x0 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_override x0)\n }\n let pexp_letmodule x0 x1 x2 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_letmodule (x0, x1, x2))\n }\n let pexp_letexception x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_letexception (x0, x1))\n }\n let pexp_assert x0 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_assert x0)\n }\n let pexp_lazy x0 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_lazy x0)\n }\n let pexp_poly x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_poly (x0, x1))\n }\n let pexp_object x0 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_object x0)\n }\n let pexp_newtype x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_newtype (x0, x1))\n }\n let pexp_pack x0 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_pack x0)\n }\n let pexp_open x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_open (x0, x1))\n }\n let pexp_letop x0 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_letop x0)\n }\n let pexp_extension x0 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_extension x0)\n }\n let pexp_unreachable =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = Pexp_unreachable\n }\n let extension_constructor ~name ~kind =\n {\n pext_name = name;\n pext_kind = kind;\n pext_loc = loc;\n pext_attributes = []\n }\n let include_infos mod_ =\n { pincl_mod = mod_; pincl_loc = loc; pincl_attributes = [] }\n let label_declaration ~name ~mutable_ ~type_ =\n {\n pld_name = name;\n pld_mutable = mutable_;\n pld_type = type_;\n pld_loc = loc;\n pld_attributes = []\n }\n let letop ~let_ ~ands ~body = { let_; ands; body }\n let location ~start ~end_ ~ghost =\n { loc_start = start; loc_end = end_; loc_ghost = ghost }\n let module_binding ~name ~expr =\n { pmb_name = name; pmb_expr = expr; pmb_attributes = []; pmb_loc = loc\n }\n let module_declaration ~name ~type_ =\n { pmd_name = name; pmd_type = type_; pmd_attributes = []; pmd_loc = loc\n }\n let pmod_ident x0 =\n { pmod_attributes = []; pmod_loc = loc; pmod_desc = (Pmod_ident x0) }\n let pmod_structure x0 =\n { pmod_attributes = []; pmod_loc = loc; pmod_desc = (Pmod_structure x0)\n }\n let pmod_functor x0 x1 =\n {\n pmod_attributes = [];\n pmod_loc = loc;\n pmod_desc = (Pmod_functor (x0, x1))\n }\n let pmod_apply x0 x1 =\n {\n pmod_attributes = [];\n pmod_loc = loc;\n pmod_desc = (Pmod_apply (x0, x1))\n }\n let pmod_constraint x0 x1 =\n {\n pmod_attributes = [];\n pmod_loc = loc;\n pmod_desc = (Pmod_constraint (x0, x1))\n }\n let pmod_unpack x0 =\n { pmod_attributes = []; pmod_loc = loc; pmod_desc = (Pmod_unpack x0) }\n let pmod_extension x0 =\n { pmod_attributes = []; pmod_loc = loc; pmod_desc = (Pmod_extension x0)\n }\n let module_substitution ~name ~manifest =\n {\n pms_name = name;\n pms_manifest = manifest;\n pms_attributes = [];\n pms_loc = loc\n }\n let pmty_ident x0 =\n { pmty_attributes = []; pmty_loc = loc; pmty_desc = (Pmty_ident x0) }\n let pmty_signature x0 =\n { pmty_attributes = []; pmty_loc = loc; pmty_desc = (Pmty_signature x0)\n }\n let pmty_functor x0 x1 =\n {\n pmty_attributes = [];\n pmty_loc = loc;\n pmty_desc = (Pmty_functor (x0, x1))\n }\n let pmty_with x0 x1 =\n {\n pmty_attributes = [];\n pmty_loc = loc;\n pmty_desc = (Pmty_with (x0, x1))\n }\n let pmty_typeof x0 =\n { pmty_attributes = []; pmty_loc = loc; pmty_desc = (Pmty_typeof x0) }\n let pmty_extension x0 =\n { pmty_attributes = []; pmty_loc = loc; pmty_desc = (Pmty_extension x0)\n }\n let pmty_alias x0 =\n { pmty_attributes = []; pmty_loc = loc; pmty_desc = (Pmty_alias x0) }\n let module_type_declaration ~name ~type_ =\n {\n pmtd_name = name;\n pmtd_type = type_;\n pmtd_attributes = [];\n pmtd_loc = loc\n }\n let otag x0 x1 =\n { pof_attributes = []; pof_loc = loc; pof_desc = (Otag (x0, x1)) }\n let oinherit x0 =\n { pof_attributes = []; pof_loc = loc; pof_desc = (Oinherit x0) }\n let open_infos ~expr ~override =\n {\n popen_expr = expr;\n popen_override = override;\n popen_loc = loc;\n popen_attributes = []\n }\n let ppat_any =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = Ppat_any\n }\n let ppat_var x0 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_var x0)\n }\n let ppat_alias x0 x1 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_alias (x0, x1))\n }\n let ppat_constant x0 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_constant x0)\n }\n let ppat_interval x0 x1 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_interval (x0, x1))\n }\n let ppat_tuple x0 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_tuple x0)\n }\n let ppat_construct x0 x1 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_construct (x0, x1))\n }\n let ppat_variant x0 x1 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_variant (x0, x1))\n }\n let ppat_record x0 x1 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_record (x0, x1))\n }\n let ppat_array x0 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_array x0)\n }\n let ppat_or x0 x1 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_or (x0, x1))\n }\n let ppat_constraint x0 x1 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_constraint (x0, x1))\n }\n let ppat_type x0 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_type x0)\n }\n let ppat_lazy x0 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_lazy x0)\n }\n let ppat_unpack x0 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_unpack x0)\n }\n let ppat_exception x0 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_exception x0)\n }\n let ppat_extension x0 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_extension x0)\n }\n let ppat_open x0 x1 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_open (x0, x1))\n }\n let position ~fname ~lnum ~bol ~cnum =\n { pos_fname = fname; pos_lnum = lnum; pos_bol = bol; pos_cnum = cnum }\n let rtag x0 x1 x2 =\n { prf_attributes = []; prf_loc = loc; prf_desc = (Rtag (x0, x1, x2)) }\n let rinherit x0 =\n { prf_attributes = []; prf_loc = loc; prf_desc = (Rinherit x0) }\n let psig_value x0 = { psig_loc = loc; psig_desc = (Psig_value x0) }\n let psig_type x0 x1 =\n { psig_loc = loc; psig_desc = (Psig_type (x0, x1)) }\n let psig_typesubst x0 =\n { psig_loc = loc; psig_desc = (Psig_typesubst x0) }\n let psig_typext x0 = { psig_loc = loc; psig_desc = (Psig_typext x0) }\n let psig_exception x0 =\n { psig_loc = loc; psig_desc = (Psig_exception x0) }\n let psig_module x0 = { psig_loc = loc; psig_desc = (Psig_module x0) }\n let psig_modsubst x0 = { psig_loc = loc; psig_desc = (Psig_modsubst x0) }\n let psig_recmodule x0 =\n { psig_loc = loc; psig_desc = (Psig_recmodule x0) }\n let psig_modtype x0 = { psig_loc = loc; psig_desc = (Psig_modtype x0) }\n let psig_open x0 = { psig_loc = loc; psig_desc = (Psig_open x0) }\n let psig_include x0 = { psig_loc = loc; psig_desc = (Psig_include x0) }\n let psig_class x0 = { psig_loc = loc; psig_desc = (Psig_class x0) }\n let psig_class_type x0 =\n { psig_loc = loc; psig_desc = (Psig_class_type x0) }\n let psig_attribute x0 =\n { psig_loc = loc; psig_desc = (Psig_attribute x0) }\n let psig_extension x0 x1 =\n { psig_loc = loc; psig_desc = (Psig_extension (x0, x1)) }\n let pstr_eval x0 x1 =\n { pstr_loc = loc; pstr_desc = (Pstr_eval (x0, x1)) }\n let pstr_value x0 x1 =\n { pstr_loc = loc; pstr_desc = (Pstr_value (x0, x1)) }\n let pstr_primitive x0 =\n { pstr_loc = loc; pstr_desc = (Pstr_primitive x0) }\n let pstr_type x0 x1 =\n { pstr_loc = loc; pstr_desc = (Pstr_type (x0, x1)) }\n let pstr_typext x0 = { pstr_loc = loc; pstr_desc = (Pstr_typext x0) }\n let pstr_exception x0 =\n { pstr_loc = loc; pstr_desc = (Pstr_exception x0) }\n let pstr_module x0 = { pstr_loc = loc; pstr_desc = (Pstr_module x0) }\n let pstr_recmodule x0 =\n { pstr_loc = loc; pstr_desc = (Pstr_recmodule x0) }\n let pstr_modtype x0 = { pstr_loc = loc; pstr_desc = (Pstr_modtype x0) }\n let pstr_open x0 = { pstr_loc = loc; pstr_desc = (Pstr_open x0) }\n let pstr_class x0 = { pstr_loc = loc; pstr_desc = (Pstr_class x0) }\n let pstr_class_type x0 =\n { pstr_loc = loc; pstr_desc = (Pstr_class_type x0) }\n let pstr_include x0 = { pstr_loc = loc; pstr_desc = (Pstr_include x0) }\n let pstr_attribute x0 =\n { pstr_loc = loc; pstr_desc = (Pstr_attribute x0) }\n let pstr_extension x0 x1 =\n { pstr_loc = loc; pstr_desc = (Pstr_extension (x0, x1)) }\n let toplevel_directive ~name ~arg =\n { pdir_name = name; pdir_arg = arg; pdir_loc = loc }\n let type_declaration ~name ~params ~cstrs ~kind ~private_ ~manifest \n =\n {\n ptype_name = name;\n ptype_params = params;\n ptype_cstrs = cstrs;\n ptype_kind = kind;\n ptype_private = private_;\n ptype_manifest = manifest;\n ptype_attributes = [];\n ptype_loc = loc\n }\n let type_exception constructor =\n {\n ptyexn_constructor = constructor;\n ptyexn_loc = loc;\n ptyexn_attributes = []\n }\n let type_extension ~path ~params ~constructors ~private_ =\n {\n ptyext_path = path;\n ptyext_params = params;\n ptyext_constructors = constructors;\n ptyext_private = private_;\n ptyext_loc = loc;\n ptyext_attributes = []\n }\n let value_binding ~pat ~expr =\n { pvb_pat = pat; pvb_expr = expr; pvb_attributes = []; pvb_loc = loc }\n let value_description ~name ~type_ ~prim =\n {\n pval_name = name;\n pval_type = type_;\n pval_prim = prim;\n pval_attributes = [];\n pval_loc = loc\n }\n end\n","open! Import\n\nmodule Default = struct\n module Located = struct\n type 'a t = 'a Loc.t\n\n let loc (x : _ t) = x.loc\n let mk ~loc x = { loc; txt = x }\n let map f t = { t with txt = f t.txt }\n let map_lident x = map (fun x -> Longident.Lident x) x\n let lident ~loc x = mk ~loc (Longident.parse x)\n end\n\n include Ast_builder_generated.M\n\n let pstr_value_list ~loc rec_flag = function\n | [] -> []\n | vbs -> [ pstr_value ~loc rec_flag vbs ]\n\n let nonrec_type_declaration ~loc:_ ~name:_ ~params:_ ~cstrs:_ ~kind:_\n ~private_:_ ~manifest:_ =\n failwith\n \"Ppxlib.Ast_builder.nonrec_type_declaration: don't use this function\"\n\n let eint ~loc t = pexp_constant ~loc (Pconst_integer (Int.to_string t, None))\n let echar ~loc t = pexp_constant ~loc (Pconst_char t)\n let estring ~loc t = pexp_constant ~loc (Pconst_string (t, loc, None))\n let efloat ~loc t = pexp_constant ~loc (Pconst_float (t, None))\n\n let eint32 ~loc t =\n pexp_constant ~loc (Pconst_integer (Int32.to_string t, Some 'l'))\n\n let eint64 ~loc t =\n pexp_constant ~loc (Pconst_integer (Int64.to_string t, Some 'L'))\n\n let enativeint ~loc t =\n pexp_constant ~loc (Pconst_integer (Nativeint.to_string t, Some 'n'))\n\n let pint ~loc t = ppat_constant ~loc (Pconst_integer (Int.to_string t, None))\n let pchar ~loc t = ppat_constant ~loc (Pconst_char t)\n let pstring ~loc t = ppat_constant ~loc (Pconst_string (t, loc, None))\n let pfloat ~loc t = ppat_constant ~loc (Pconst_float (t, None))\n\n let pint32 ~loc t =\n ppat_constant ~loc (Pconst_integer (Int32.to_string t, Some 'l'))\n\n let pint64 ~loc t =\n ppat_constant ~loc (Pconst_integer (Int64.to_string t, Some 'L'))\n\n let pnativeint ~loc t =\n ppat_constant ~loc (Pconst_integer (Nativeint.to_string t, Some 'n'))\n\n let ebool ~loc t =\n pexp_construct ~loc (Located.lident ~loc (Bool.to_string t)) None\n\n let pbool ~loc t =\n ppat_construct ~loc (Located.lident ~loc (Bool.to_string t)) None\n\n let evar ~loc v = pexp_ident ~loc (Located.mk ~loc (Longident.parse v))\n let pvar ~loc v = ppat_var ~loc (Located.mk ~loc v)\n let eunit ~loc = pexp_construct ~loc (Located.lident ~loc \"()\") None\n let punit ~loc = ppat_construct ~loc (Located.lident ~loc \"()\") None\n let pexp_tuple ~loc l = match l with [ x ] -> x | _ -> pexp_tuple ~loc l\n let ppat_tuple ~loc l = match l with [ x ] -> x | _ -> ppat_tuple ~loc l\n let ptyp_tuple ~loc l = match l with [ x ] -> x | _ -> ptyp_tuple ~loc l\n\n let pexp_tuple_opt ~loc l =\n match l with [] -> None | _ :: _ -> Some (pexp_tuple ~loc l)\n\n let ppat_tuple_opt ~loc l =\n match l with [] -> None | _ :: _ -> Some (ppat_tuple ~loc l)\n\n let ptyp_poly ~loc vars ty =\n match vars with [] -> ty | _ -> ptyp_poly ~loc vars ty\n\n let pexp_apply ~loc e el =\n match (e, el) with\n | _, [] -> e\n | { pexp_desc = Pexp_apply (e, args); pexp_attributes = []; _ }, _ ->\n { e with pexp_desc = Pexp_apply (e, args @ el) }\n | _ -> pexp_apply ~loc e el\n\n let eapply ~loc e el =\n pexp_apply ~loc e (List.map el ~f:(fun e -> (Asttypes.Nolabel, e)))\n\n let eabstract ~loc ps e =\n List.fold_right ps ~init:e ~f:(fun p e ->\n pexp_fun ~loc Asttypes.Nolabel None p e)\n\n let esequence ~loc el =\n match el with\n | [] -> eunit ~loc\n | hd :: tl ->\n List.fold_left tl ~init:hd ~f:(fun acc e -> pexp_sequence ~loc acc e)\n\n let pconstruct cd arg =\n ppat_construct ~loc:cd.pcd_loc (Located.map_lident cd.pcd_name) arg\n\n let econstruct cd arg =\n pexp_construct ~loc:cd.pcd_loc (Located.map_lident cd.pcd_name) arg\n\n let rec elist ~loc l =\n match l with\n | [] -> pexp_construct ~loc (Located.mk ~loc (Longident.Lident \"[]\")) None\n | x :: l ->\n pexp_construct ~loc\n (Located.mk ~loc (Longident.Lident \"::\"))\n (Some (pexp_tuple ~loc [ x; elist ~loc l ]))\n\n let rec plist ~loc l =\n match l with\n | [] -> ppat_construct ~loc (Located.mk ~loc (Longident.Lident \"[]\")) None\n | x :: l ->\n ppat_construct ~loc\n (Located.mk ~loc (Longident.Lident \"::\"))\n (Some (ppat_tuple ~loc [ x; plist ~loc l ]))\n\n let unapplied_type_constr_conv_without_apply ~loc (ident : Longident.t) ~f =\n match ident with\n | Lident n -> pexp_ident ~loc { txt = Lident (f n); loc }\n | Ldot (path, n) -> pexp_ident ~loc { txt = Ldot (path, f n); loc }\n | Lapply _ ->\n Location.raise_errorf ~loc \"unexpected applicative functor type\"\n\n let type_constr_conv ~loc:apply_loc { Loc.loc; txt = longident } ~f args =\n let loc = { loc with loc_ghost = true } in\n match (longident : Longident.t) with\n | Lident _ | Ldot ((Lident _ | Ldot _), _) | Lapply _ -> (\n let ident =\n unapplied_type_constr_conv_without_apply longident ~loc ~f\n in\n match args with\n | [] -> ident\n | _ :: _ -> eapply ~loc:apply_loc ident args)\n | Ldot ((Lapply _ as module_path), n) ->\n let suffix_n functor_ = String.uncapitalize_ascii functor_ ^ \"__\" ^ n in\n let rec gather_lapply functor_args : Longident.t -> Longident.t * _ =\n function\n | Lapply (rest, arg) -> gather_lapply (arg :: functor_args) rest\n | Lident functor_ -> (Lident (suffix_n functor_), functor_args)\n | Ldot (functor_path, functor_) ->\n (Ldot (functor_path, suffix_n functor_), functor_args)\n in\n let ident, functor_args = gather_lapply [] module_path in\n eapply ~loc:apply_loc\n (unapplied_type_constr_conv_without_apply ident ~loc ~f)\n (List.map functor_args ~f:(fun path ->\n pexp_pack ~loc (pmod_ident ~loc { txt = path; loc }))\n @ args)\n\n let unapplied_type_constr_conv ~loc longident ~f =\n type_constr_conv longident ~loc ~f []\n\n let eta_reduce =\n let rec gather_params acc expr =\n match expr with\n | {\n pexp_desc =\n Pexp_fun (label, None (* no default expression *), subpat, body);\n pexp_attributes = [];\n pexp_loc = _;\n pexp_loc_stack = _;\n } -> (\n match subpat with\n | {\n ppat_desc = Ppat_var name;\n ppat_attributes = [];\n ppat_loc = _;\n ppat_loc_stack = _;\n } ->\n gather_params ((label, name, None) :: acc) body\n | {\n ppat_desc =\n Ppat_constraint\n ( {\n ppat_desc = Ppat_var name;\n ppat_attributes = [];\n ppat_loc = _;\n ppat_loc_stack = _;\n },\n ty );\n ppat_attributes = [];\n ppat_loc = _;\n ppat_loc_stack = _;\n } ->\n (* We reduce [fun (x : ty) -> f x] by rewriting it [(f : ty -> _)]. *)\n gather_params ((label, name, Some ty) :: acc) body\n | _ -> (List.rev acc, expr))\n | _ -> (List.rev acc, expr)\n in\n let annotate ~loc expr params =\n if List.exists params ~f:(fun (_, _, ty) -> Option.is_some ty) then\n let ty =\n List.fold_right params ~init:(ptyp_any ~loc)\n ~f:(fun (param_label, param, ty_opt) acc ->\n let loc = param.loc in\n let ty =\n match ty_opt with None -> ptyp_any ~loc | Some ty -> ty\n in\n ptyp_arrow ~loc param_label ty acc)\n in\n pexp_constraint ~loc expr ty\n else expr\n in\n let rec gather_args n x =\n if n = 0 then Some (x, [])\n else\n match x with\n | {\n pexp_desc = Pexp_apply (body, args);\n pexp_attributes = [];\n pexp_loc = _;\n pexp_loc_stack = _;\n } ->\n if List.length args <= n then\n match gather_args (n - List.length args) body with\n | None -> None\n | Some (body, args') -> Some (body, args' @ args)\n else None\n | _ -> None\n in\n fun expr ->\n let params, body = gather_params [] expr in\n match gather_args (List.length params) body with\n | None -> None\n | Some (({ pexp_desc = Pexp_ident _; _ } as f_ident), args) -> (\n match\n List.for_all2 args params\n ~f:(fun (arg_label, arg) (param_label, param, _) ->\n Poly.( = ) (arg_label : arg_label) param_label\n &&\n match arg with\n | {\n pexp_desc = Pexp_ident { txt = Lident name'; _ };\n pexp_attributes = [];\n pexp_loc = _;\n pexp_loc_stack = _;\n } ->\n String.( = ) name' param.txt\n | _ -> false)\n with\n | false -> None\n | true -> Some (annotate ~loc:expr.pexp_loc f_ident params))\n | _ -> None\n\n let eta_reduce_if_possible expr = Option.value (eta_reduce expr) ~default:expr\n\n let eta_reduce_if_possible_and_nonrec expr ~rec_flag =\n match rec_flag with\n | Recursive -> expr\n | Nonrecursive -> eta_reduce_if_possible expr\nend\n\nmodule type Loc = Ast_builder_intf.Loc\nmodule type S = Ast_builder_intf.S\n\nmodule Make (Loc : sig\n val loc : Location.t\nend) : S = struct\n include Ast_builder_generated.Make (Loc)\n\n let pstr_value_list = Default.pstr_value_list\n\n let nonrec_type_declaration ~name ~params ~cstrs ~kind ~private_ ~manifest =\n Default.nonrec_type_declaration ~loc ~name ~params ~cstrs ~kind ~private_\n ~manifest\n\n module Located = struct\n include Default.Located\n\n let loc _ = Loc.loc\n let mk x = mk ~loc:Loc.loc x\n let lident x = lident ~loc:Loc.loc x\n end\n\n let pexp_tuple l = Default.pexp_tuple ~loc l\n let ppat_tuple l = Default.ppat_tuple ~loc l\n let ptyp_tuple l = Default.ptyp_tuple ~loc l\n let pexp_tuple_opt l = Default.pexp_tuple_opt ~loc l\n let ppat_tuple_opt l = Default.ppat_tuple_opt ~loc l\n let ptyp_poly vars ty = Default.ptyp_poly ~loc vars ty\n let pexp_apply e el = Default.pexp_apply ~loc e el\n let eint t = Default.eint ~loc t\n let echar t = Default.echar ~loc t\n let estring t = Default.estring ~loc t\n let efloat t = Default.efloat ~loc t\n let eint32 t = Default.eint32 ~loc t\n let eint64 t = Default.eint64 ~loc t\n let enativeint t = Default.enativeint ~loc t\n let ebool t = Default.ebool ~loc t\n let evar t = Default.evar ~loc t\n let pint t = Default.pint ~loc t\n let pchar t = Default.pchar ~loc t\n let pstring t = Default.pstring ~loc t\n let pfloat t = Default.pfloat ~loc t\n let pint32 t = Default.pint32 ~loc t\n let pint64 t = Default.pint64 ~loc t\n let pnativeint t = Default.pnativeint ~loc t\n let pbool t = Default.pbool ~loc t\n let pvar t = Default.pvar ~loc t\n let eunit = Default.eunit ~loc\n let punit = Default.punit ~loc\n let econstruct = Default.econstruct\n let pconstruct = Default.pconstruct\n let eapply e el = Default.eapply ~loc e el\n let eabstract ps e = Default.eabstract ~loc ps e\n let esequence el = Default.esequence ~loc el\n let elist l = Default.elist ~loc l\n let plist l = Default.plist ~loc l\n\n let type_constr_conv ident ~f args =\n Default.type_constr_conv ~loc ident ~f args\n\n let unapplied_type_constr_conv ident ~f =\n Default.unapplied_type_constr_conv ~loc ident ~f\n\n let eta_reduce = Default.eta_reduce\n let eta_reduce_if_possible = Default.eta_reduce_if_possible\n\n let eta_reduce_if_possible_and_nonrec =\n Default.eta_reduce_if_possible_and_nonrec\nend\n\nlet make loc =\n (module Make (struct\n let loc = loc\n end) : S)\n","open! Import\nmodule Printexc = Caml.Printexc\n\n(* Small helper to find out who is the caller of a function *)\n\ntype t = Printexc.location option\n\nlet get ~skip =\n let skip = __FILE__ :: skip in\n let stack = Printexc.get_callstack 16 in\n let len = Printexc.raw_backtrace_length stack in\n let rec loop pos =\n if pos = len then None\n else\n match\n Printexc.get_raw_backtrace_slot stack pos\n |> Printexc.convert_raw_backtrace_slot |> Printexc.Slot.location\n with\n | None -> None\n | Some loc ->\n if List.mem ~set:skip loc.filename then loop (pos + 1) else Some loc\n in\n loop 0\n","open! Import\nopen Ast_builder.Default\nmodule Buffer = Caml.Buffer\nmodule Format = Caml.Format\n\nlet lident x = Longident.Lident x\n\nlet core_type_of_type_declaration td =\n let loc = td.ptype_name.loc in\n ptyp_constr ~loc\n (Located.map lident td.ptype_name)\n (List.map td.ptype_params ~f:fst)\n\nlet strip_gen_symbol_suffix =\n let chop n ~or_more string pos f =\n let target = !pos - n in\n while !pos > 0 && (or_more || !pos > target) && f string.[!pos - 1] do\n pos := !pos - 1\n done;\n !pos <= target\n in\n fun string ->\n let pos = ref (String.length string) in\n if\n chop 1 ~or_more:false string pos (Char.equal '_')\n && chop 3 ~or_more:true string pos (function\n | '0' .. '9' -> true\n | _ -> false)\n && chop 2 ~or_more:false string pos (Char.equal '_')\n then String.prefix string !pos\n else string\n\nlet gen_symbol =\n let cnt = ref 0 in\n fun ?(prefix = \"_x\") () ->\n cnt := !cnt + 1;\n let prefix = strip_gen_symbol_suffix prefix in\n Printf.sprintf \"%s__%03i_\" prefix !cnt\n\nlet name_type_params_in_td (td : type_declaration) : type_declaration =\n let prefix_string i =\n (* a, b, ..., y, z, aa, bb, ... *)\n String.make ((i / 26) + 1) (Char.chr (Char.code 'a' + (i mod 26)))\n in\n let name_param i (tp, variance) =\n let ptyp_desc =\n match tp.ptyp_desc with\n | Ptyp_any -> Ptyp_var (gen_symbol ~prefix:(prefix_string i) ())\n | Ptyp_var _ as v -> v\n | _ -> Location.raise_errorf ~loc:tp.ptyp_loc \"not a type parameter\"\n in\n ({ tp with ptyp_desc }, variance)\n in\n { td with ptype_params = List.mapi td.ptype_params ~f:name_param }\n\nlet combinator_type_of_type_declaration td ~f =\n let td = name_type_params_in_td td in\n let result_type =\n f ~loc:td.ptype_name.loc (core_type_of_type_declaration td)\n in\n List.fold_right td.ptype_params ~init:result_type\n ~f:(fun (tp, _variance) acc ->\n let loc = tp.ptyp_loc in\n ptyp_arrow ~loc Nolabel (f ~loc tp) acc)\n\nlet string_of_core_type ct =\n let buf = Buffer.create 128 in\n let ppf = Format.formatter_of_buffer buf in\n Pprintast.core_type ppf ct;\n Format.pp_print_flush ppf ();\n Buffer.contents buf\n\nlet get_type_param_name (ty, _) =\n let loc = ty.ptyp_loc in\n match ty.ptyp_desc with\n | Ptyp_var name -> Located.mk ~loc name\n | _ -> Location.raise_errorf ~loc \"not a type parameter\"\n\nexception Type_is_recursive\n\nclass type_is_recursive rec_flag tds =\n object (self)\n inherit Ast_traverse.iter as super\n val type_names : string list = List.map tds ~f:(fun td -> td.ptype_name.txt)\n method return_true () = raise_notrace Type_is_recursive\n\n method! core_type ctype =\n match ctype.ptyp_desc with\n | Ptyp_arrow _ -> ()\n | Ptyp_constr ({ txt = Longident.Lident id; _ }, _)\n when List.mem ~set:type_names id ->\n self#return_true ()\n | _ -> super#core_type ctype\n\n method! constructor_declaration cd =\n (* Don't recurse through cd.pcd_res *)\n match cd.pcd_args with\n | Pcstr_tuple args -> List.iter args ~f:self#core_type\n | Pcstr_record fields -> List.iter fields ~f:self#label_declaration\n\n method! attributes _ = (* Don't recurse through attributes *)\n ()\n\n method go () =\n match rec_flag with\n | Nonrecursive -> Nonrecursive\n | Recursive -> (\n match List.iter tds ~f:self#type_declaration with\n | exception Type_is_recursive -> Recursive\n | () -> Nonrecursive)\n end\n\nlet really_recursive rec_flag tds = (new type_is_recursive rec_flag tds)#go ()\nlet rec last x l = match l with [] -> x | x :: l -> last x l\n\nlet loc_of_name_and_payload name payload =\n match payload with\n | PStr [] -> name.loc\n | PStr (x :: l) -> { x.pstr_loc with loc_end = (last x l).pstr_loc.loc_end }\n | PSig [] -> name.loc\n | PSig (x :: l) -> { x.psig_loc with loc_end = (last x l).psig_loc.loc_end }\n | PTyp t -> t.ptyp_loc\n | PPat (x, None) -> x.ppat_loc\n | PPat (x, Some e) -> { x.ppat_loc with loc_end = e.pexp_loc.loc_end }\n\nlet loc_of_payload { attr_name; attr_payload; attr_loc = _ } =\n loc_of_name_and_payload attr_name attr_payload\n\nlet loc_of_attribute { attr_name; attr_payload; attr_loc = _ } =\n (* TODO: fix this in the compiler, and move the logic to omp when converting\n from older asts. *)\n (* \"ocaml.doc\" attributes are generated with [Location.none], which is not helpful for\n error messages. *)\n if Poly.( = ) attr_name.loc Location.none then\n loc_of_name_and_payload attr_name attr_payload\n else\n {\n attr_name.loc with\n loc_end = (loc_of_name_and_payload attr_name attr_payload).loc_end;\n }\n\nlet loc_of_extension (name, payload) =\n if Poly.( = ) name.loc Location.none then loc_of_name_and_payload name payload\n else\n { name.loc with loc_end = (loc_of_name_and_payload name payload).loc_end }\n\nlet curry_applications expr =\n let open Ast_builder_generated.M in\n match expr.pexp_desc with\n | Pexp_apply (f, orig_forward_args) ->\n let loc = expr.pexp_loc in\n let rec loop = function\n | [] -> f\n | last_arg :: rev_front_args ->\n pexp_apply ~loc (loop rev_front_args) [ last_arg ]\n in\n loop (List.rev orig_forward_args)\n | _ -> expr\n\nlet rec assert_no_attributes = function\n | [] -> ()\n | { attr_name = name; attr_loc = _; attr_payload = _ } :: rest\n when Name.ignore_checks name.Location.txt ->\n assert_no_attributes rest\n | attr :: _ ->\n let loc = loc_of_attribute attr in\n Location.raise_errorf ~loc \"Attributes not allowed here\"\n\nlet assert_no_attributes_in =\n object\n inherit Ast_traverse.iter\n method! attribute a = assert_no_attributes [ a ]\n end\n\nlet attribute_of_warning loc s =\n {\n attr_name = { loc; txt = \"ocaml.ppwarning\" };\n attr_payload = PStr [ pstr_eval ~loc (estring ~loc s) [] ];\n attr_loc = loc;\n }\n\nlet is_polymorphic_variant =\n let rec check = function\n | { ptyp_desc = Ptyp_variant _; _ } -> `Definitely\n | { ptyp_desc = Ptyp_alias (typ, _); _ } -> check typ\n | { ptyp_desc = Ptyp_constr _; _ } -> `Maybe\n | _ -> `Surely_not\n (* Type vars go here even though they could be polymorphic\n variants, however we don't handle it if they get substituted\n by a polymorphic variant that is then included. *)\n in\n fun td ~sig_ ->\n match td.ptype_kind with\n | Ptype_variant _ | Ptype_record _ | Ptype_open -> `Surely_not\n | Ptype_abstract -> (\n match td.ptype_manifest with\n | None -> if sig_ then `Maybe else `Surely_not\n | Some typ -> check typ)\n\nlet mk_named_sig ~loc ~sg_name ~handle_polymorphic_variant = function\n | [ td ]\n when String.equal td.ptype_name.txt \"t\" && List.is_empty td.ptype_cstrs ->\n if\n (not handle_polymorphic_variant)\n && Poly.( = ) (is_polymorphic_variant td ~sig_:true) `Definitely\n then None\n else\n let arity = List.length td.ptype_params in\n if arity >= 4 then None\n else\n let mty =\n if arity = 0 then sg_name else Printf.sprintf \"%s%d\" sg_name arity\n in\n let td = name_type_params_in_td td in\n let for_subst =\n Ast_helper.Type.mk ~loc td.ptype_name ~params:td.ptype_params\n ~manifest:\n (ptyp_constr ~loc\n (Located.map_lident td.ptype_name)\n (List.map ~f:fst td.ptype_params))\n in\n Some\n (include_infos ~loc\n (pmty_with ~loc\n (pmty_ident ~loc (Located.lident mty ~loc))\n [ Pwith_typesubst (Located.lident ~loc \"t\", for_subst) ]))\n | _ -> None\n","open Import\nopen Ast_pattern0\nlet nolabel =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Nolabel -> (ctx.matched <- (ctx.matched + 1); k)\n | _ -> fail loc \"Nolabel\")\nlet labelled (T f0) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Labelled x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"Labelled\")\nlet optional (T f0) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Optional x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"Optional\")\nlet attribute ~name:(T name) ~payload:(T payload) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n let k = name ctx (x.attr_name).loc (x.attr_name).txt k in\n let k = payload ctx loc x.attr_payload k in k)\nlet binding_op ~op:(T op) ~pat:(T pat) ~exp:(T exp) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n let k = op ctx (x.pbop_op).loc (x.pbop_op).txt k in\n let k = pat ctx loc x.pbop_pat k in\n let k = exp ctx loc x.pbop_exp k in k)\nlet case ~lhs:(T lhs) ~guard:(T guard) ~rhs:(T rhs) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n let k = lhs ctx loc x.pc_lhs k in\n let k = guard ctx loc x.pc_guard k in\n let k = rhs ctx loc x.pc_rhs k in k)\nlet pcl_loc (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pcl_loc in\n let k = f1 ctx loc loc k in let k = f2 ctx loc x k in k)\nlet pcl_attributes (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pcl_loc in\n let k = f1 ctx loc x.pcl_attributes k in\n let x = { x with pcl_attributes = [] } in\n let k = f2 ctx loc x k in k)\nlet pcl_constr (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pcl_attributes;\n (let loc = x.pcl_loc in\n let x = x.pcl_desc in\n match x with\n | Pcl_constr (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx x0.loc x0.txt k in\n let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"constr\"))\nlet pcl_structure (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pcl_attributes;\n (let loc = x.pcl_loc in\n let x = x.pcl_desc in\n match x with\n | Pcl_structure x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"structure\"))\nlet pcl_fun (T f0) (T f1) (T f2) (T f3) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pcl_attributes;\n (let loc = x.pcl_loc in\n let x = x.pcl_desc in\n match x with\n | Pcl_fun (x0, x1, x2, x3) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in\n let k = f1 ctx loc x1 k in\n let k = f2 ctx loc x2 k in let k = f3 ctx loc x3 k in k))\n | _ -> fail loc \"fun\"))\nlet pcl_apply (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pcl_attributes;\n (let loc = x.pcl_loc in\n let x = x.pcl_desc in\n match x with\n | Pcl_apply (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"apply\"))\nlet pcl_let (T f0) (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pcl_attributes;\n (let loc = x.pcl_loc in\n let x = x.pcl_desc in\n match x with\n | Pcl_let (x0, x1, x2) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in\n let k = f1 ctx loc x1 k in let k = f2 ctx loc x2 k in k))\n | _ -> fail loc \"let\"))\nlet pcl_constraint (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pcl_attributes;\n (let loc = x.pcl_loc in\n let x = x.pcl_desc in\n match x with\n | Pcl_constraint (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"constraint\"))\nlet pcl_extension (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pcl_attributes;\n (let loc = x.pcl_loc in\n let x = x.pcl_desc in\n match x with\n | Pcl_extension x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"extension\"))\nlet pcl_open (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pcl_attributes;\n (let loc = x.pcl_loc in\n let x = x.pcl_desc in\n match x with\n | Pcl_open (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"open\"))\nlet pcf_loc (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pcf_loc in\n let k = f1 ctx loc loc k in let k = f2 ctx loc x k in k)\nlet pcf_attributes (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pcf_loc in\n let k = f1 ctx loc x.pcf_attributes k in\n let x = { x with pcf_attributes = [] } in\n let k = f2 ctx loc x k in k)\nlet pcf_inherit (T f0) (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pcf_attributes;\n (let loc = x.pcf_loc in\n let x = x.pcf_desc in\n match x with\n | Pcf_inherit (x0, x1, x2) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in\n let k = f1 ctx loc x1 k in let k = f2 ctx loc x2 k in k))\n | _ -> fail loc \"inherit\"))\nlet pcf_val (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pcf_attributes;\n (let loc = x.pcf_loc in\n let x = x.pcf_desc in\n match x with\n | Pcf_val x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"val\"))\nlet pcf_method (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pcf_attributes;\n (let loc = x.pcf_loc in\n let x = x.pcf_desc in\n match x with\n | Pcf_method x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"method\"))\nlet pcf_constraint (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pcf_attributes;\n (let loc = x.pcf_loc in\n let x = x.pcf_desc in\n match x with\n | Pcf_constraint x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"constraint\"))\nlet pcf_initializer (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pcf_attributes;\n (let loc = x.pcf_loc in\n let x = x.pcf_desc in\n match x with\n | Pcf_initializer x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"initializer\"))\nlet pcf_attribute (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pcf_attributes;\n (let loc = x.pcf_loc in\n let x = x.pcf_desc in\n match x with\n | Pcf_attribute x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"attribute\"))\nlet pcf_extension (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pcf_attributes;\n (let loc = x.pcf_loc in\n let x = x.pcf_desc in\n match x with\n | Pcf_extension x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"extension\"))\nlet cfk_virtual (T f0) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Cfk_virtual x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"virtual\")\nlet cfk_concrete (T f0) (T f1) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Cfk_concrete (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"concrete\")\nlet class_infos_attributes (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pci_loc in\n let k = f1 ctx loc x.pci_attributes k in\n let x = { x with pci_attributes = [] } in\n let k = f2 ctx loc x k in k)\nlet class_infos ~virt:(T virt) ~params:(T params) ~name:(T name) ~expr:(T\n expr) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pci_attributes;\n (let k = virt ctx loc x.pci_virt k in\n let k = params ctx loc x.pci_params k in\n let k = name ctx (x.pci_name).loc (x.pci_name).txt k in\n let k = expr ctx loc x.pci_expr k in k))\nlet class_signature ~self:(T self) ~fields:(T fields) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n let k = self ctx loc x.pcsig_self k in\n let k = fields ctx loc x.pcsig_fields k in k)\nlet class_structure ~self:(T self) ~fields:(T fields) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n let k = self ctx loc x.pcstr_self k in\n let k = fields ctx loc x.pcstr_fields k in k)\nlet pcty_loc (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pcty_loc in\n let k = f1 ctx loc loc k in let k = f2 ctx loc x k in k)\nlet pcty_attributes (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pcty_loc in\n let k = f1 ctx loc x.pcty_attributes k in\n let x = { x with pcty_attributes = [] } in\n let k = f2 ctx loc x k in k)\nlet pcty_constr (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pcty_attributes;\n (let loc = x.pcty_loc in\n let x = x.pcty_desc in\n match x with\n | Pcty_constr (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx x0.loc x0.txt k in\n let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"constr\"))\nlet pcty_signature (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pcty_attributes;\n (let loc = x.pcty_loc in\n let x = x.pcty_desc in\n match x with\n | Pcty_signature x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"signature\"))\nlet pcty_arrow (T f0) (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pcty_attributes;\n (let loc = x.pcty_loc in\n let x = x.pcty_desc in\n match x with\n | Pcty_arrow (x0, x1, x2) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in\n let k = f1 ctx loc x1 k in let k = f2 ctx loc x2 k in k))\n | _ -> fail loc \"arrow\"))\nlet pcty_extension (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pcty_attributes;\n (let loc = x.pcty_loc in\n let x = x.pcty_desc in\n match x with\n | Pcty_extension x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"extension\"))\nlet pcty_open (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pcty_attributes;\n (let loc = x.pcty_loc in\n let x = x.pcty_desc in\n match x with\n | Pcty_open (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"open\"))\nlet pctf_loc (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pctf_loc in\n let k = f1 ctx loc loc k in let k = f2 ctx loc x k in k)\nlet pctf_attributes (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pctf_loc in\n let k = f1 ctx loc x.pctf_attributes k in\n let x = { x with pctf_attributes = [] } in\n let k = f2 ctx loc x k in k)\nlet pctf_inherit (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pctf_attributes;\n (let loc = x.pctf_loc in\n let x = x.pctf_desc in\n match x with\n | Pctf_inherit x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"inherit\"))\nlet pctf_val (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pctf_attributes;\n (let loc = x.pctf_loc in\n let x = x.pctf_desc in\n match x with\n | Pctf_val x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"val\"))\nlet pctf_method (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pctf_attributes;\n (let loc = x.pctf_loc in\n let x = x.pctf_desc in\n match x with\n | Pctf_method x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"method\"))\nlet pctf_constraint (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pctf_attributes;\n (let loc = x.pctf_loc in\n let x = x.pctf_desc in\n match x with\n | Pctf_constraint x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"constraint\"))\nlet pctf_attribute (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pctf_attributes;\n (let loc = x.pctf_loc in\n let x = x.pctf_desc in\n match x with\n | Pctf_attribute x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"attribute\"))\nlet pctf_extension (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pctf_attributes;\n (let loc = x.pctf_loc in\n let x = x.pctf_desc in\n match x with\n | Pctf_extension x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"extension\"))\nlet closed =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Closed -> (ctx.matched <- (ctx.matched + 1); k)\n | _ -> fail loc \"Closed\")\nlet open_ =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Open -> (ctx.matched <- (ctx.matched + 1); k)\n | _ -> fail loc \"Open\")\nlet pconst_integer (T f0) (T f1) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Pconst_integer (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"integer\")\nlet pconst_char (T f0) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Pconst_char x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"char\")\nlet pconst_string (T f0) (T f1) (T f2) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Pconst_string (x0, x1, x2) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in\n let k = f1 ctx loc x1 k in let k = f2 ctx loc x2 k in k))\n | _ -> fail loc \"string\")\nlet pconst_float (T f0) (T f1) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Pconst_float (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"float\")\nlet pcstr_tuple (T f0) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Pcstr_tuple x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"tuple\")\nlet pcstr_record (T f0) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Pcstr_record x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"record\")\nlet constructor_declaration_attributes (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pcd_loc in\n let k = f1 ctx loc x.pcd_attributes k in\n let x = { x with pcd_attributes = [] } in\n let k = f2 ctx loc x k in k)\nlet constructor_declaration ~name:(T name) ~args:(T args) ~res:(T res) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pcd_attributes;\n (let k = name ctx (x.pcd_name).loc (x.pcd_name).txt k in\n let k = args ctx loc x.pcd_args k in\n let k = res ctx loc x.pcd_res k in k))\nlet ptyp_loc (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.ptyp_loc in\n let k = f1 ctx loc loc k in let k = f2 ctx loc x k in k)\nlet ptyp_attributes (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.ptyp_loc in\n let k = f1 ctx loc x.ptyp_attributes k in\n let x = { x with ptyp_attributes = [] } in\n let k = f2 ctx loc x k in k)\nlet ptyp_any =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ptyp_attributes;\n (let loc = x.ptyp_loc in\n let x = x.ptyp_desc in\n match x with\n | Ptyp_any -> (ctx.matched <- (ctx.matched + 1); k)\n | _ -> fail loc \"any\"))\nlet ptyp_var (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ptyp_attributes;\n (let loc = x.ptyp_loc in\n let x = x.ptyp_desc in\n match x with\n | Ptyp_var x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"var\"))\nlet ptyp_arrow (T f0) (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ptyp_attributes;\n (let loc = x.ptyp_loc in\n let x = x.ptyp_desc in\n match x with\n | Ptyp_arrow (x0, x1, x2) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in\n let k = f1 ctx loc x1 k in let k = f2 ctx loc x2 k in k))\n | _ -> fail loc \"arrow\"))\nlet ptyp_tuple (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ptyp_attributes;\n (let loc = x.ptyp_loc in\n let x = x.ptyp_desc in\n match x with\n | Ptyp_tuple x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"tuple\"))\nlet ptyp_constr (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ptyp_attributes;\n (let loc = x.ptyp_loc in\n let x = x.ptyp_desc in\n match x with\n | Ptyp_constr (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx x0.loc x0.txt k in\n let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"constr\"))\nlet ptyp_object (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ptyp_attributes;\n (let loc = x.ptyp_loc in\n let x = x.ptyp_desc in\n match x with\n | Ptyp_object (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"object\"))\nlet ptyp_class (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ptyp_attributes;\n (let loc = x.ptyp_loc in\n let x = x.ptyp_desc in\n match x with\n | Ptyp_class (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx x0.loc x0.txt k in\n let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"class\"))\nlet ptyp_alias (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ptyp_attributes;\n (let loc = x.ptyp_loc in\n let x = x.ptyp_desc in\n match x with\n | Ptyp_alias (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"alias\"))\nlet ptyp_variant (T f0) (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ptyp_attributes;\n (let loc = x.ptyp_loc in\n let x = x.ptyp_desc in\n match x with\n | Ptyp_variant (x0, x1, x2) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in\n let k = f1 ctx loc x1 k in let k = f2 ctx loc x2 k in k))\n | _ -> fail loc \"variant\"))\nlet ptyp_poly (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ptyp_attributes;\n (let loc = x.ptyp_loc in\n let x = x.ptyp_desc in\n match x with\n | Ptyp_poly (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"poly\"))\nlet ptyp_package (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ptyp_attributes;\n (let loc = x.ptyp_loc in\n let x = x.ptyp_desc in\n match x with\n | Ptyp_package x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"package\"))\nlet ptyp_extension (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ptyp_attributes;\n (let loc = x.ptyp_loc in\n let x = x.ptyp_desc in\n match x with\n | Ptyp_extension x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"extension\"))\nlet upto =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Upto -> (ctx.matched <- (ctx.matched + 1); k)\n | _ -> fail loc \"Upto\")\nlet downto_ =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Downto -> (ctx.matched <- (ctx.matched + 1); k)\n | _ -> fail loc \"Downto\")\nlet pdira_loc (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pdira_loc in\n let k = f1 ctx loc loc k in let k = f2 ctx loc x k in k)\nlet pdir_string (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pdira_loc in\n let x = x.pdira_desc in\n match x with\n | Pdir_string x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"string\")\nlet pdir_int (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pdira_loc in\n let x = x.pdira_desc in\n match x with\n | Pdir_int (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"int\")\nlet pdir_ident (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pdira_loc in\n let x = x.pdira_desc in\n match x with\n | Pdir_ident x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"ident\")\nlet pdir_bool (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pdira_loc in\n let x = x.pdira_desc in\n match x with\n | Pdir_bool x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"bool\")\nlet pexp_loc (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pexp_loc in\n let k = f1 ctx loc loc k in let k = f2 ctx loc x k in k)\nlet pexp_attributes (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pexp_loc in\n let k = f1 ctx loc x.pexp_attributes k in\n let x = { x with pexp_attributes = [] } in\n let k = f2 ctx loc x k in k)\nlet pexp_ident (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_ident x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx x0.loc x0.txt k in k))\n | _ -> fail loc \"ident\"))\nlet pexp_constant (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_constant x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"constant\"))\nlet pexp_let (T f0) (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_let (x0, x1, x2) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in\n let k = f1 ctx loc x1 k in let k = f2 ctx loc x2 k in k))\n | _ -> fail loc \"let\"))\nlet pexp_function (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_function x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"function\"))\nlet pexp_fun (T f0) (T f1) (T f2) (T f3) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_fun (x0, x1, x2, x3) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in\n let k = f1 ctx loc x1 k in\n let k = f2 ctx loc x2 k in let k = f3 ctx loc x3 k in k))\n | _ -> fail loc \"fun\"))\nlet pexp_apply (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_apply (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"apply\"))\nlet pexp_match (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_match (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"match\"))\nlet pexp_try (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_try (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"try\"))\nlet pexp_tuple (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_tuple x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"tuple\"))\nlet pexp_construct (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_construct (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx x0.loc x0.txt k in\n let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"construct\"))\nlet pexp_variant (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_variant (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"variant\"))\nlet pexp_record (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_record (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"record\"))\nlet pexp_field (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_field (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in\n let k = f1 ctx x1.loc x1.txt k in k))\n | _ -> fail loc \"field\"))\nlet pexp_setfield (T f0) (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_setfield (x0, x1, x2) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in\n let k = f1 ctx x1.loc x1.txt k in\n let k = f2 ctx loc x2 k in k))\n | _ -> fail loc \"setfield\"))\nlet pexp_array (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_array x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"array\"))\nlet pexp_ifthenelse (T f0) (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_ifthenelse (x0, x1, x2) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in\n let k = f1 ctx loc x1 k in let k = f2 ctx loc x2 k in k))\n | _ -> fail loc \"ifthenelse\"))\nlet pexp_sequence (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_sequence (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"sequence\"))\nlet pexp_while (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_while (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"while\"))\nlet pexp_for (T f0) (T f1) (T f2) (T f3) (T f4) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_for (x0, x1, x2, x3, x4) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in\n let k = f1 ctx loc x1 k in\n let k = f2 ctx loc x2 k in\n let k = f3 ctx loc x3 k in let k = f4 ctx loc x4 k in k))\n | _ -> fail loc \"for\"))\nlet pexp_constraint (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_constraint (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"constraint\"))\nlet pexp_coerce (T f0) (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_coerce (x0, x1, x2) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in\n let k = f1 ctx loc x1 k in let k = f2 ctx loc x2 k in k))\n | _ -> fail loc \"coerce\"))\nlet pexp_send (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_send (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in\n let k = f1 ctx x1.loc x1.txt k in k))\n | _ -> fail loc \"send\"))\nlet pexp_new (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_new x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx x0.loc x0.txt k in k))\n | _ -> fail loc \"new\"))\nlet pexp_setinstvar (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_setinstvar (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx x0.loc x0.txt k in\n let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"setinstvar\"))\nlet pexp_override (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_override x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"override\"))\nlet pexp_letmodule (T f0) (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_letmodule (x0, x1, x2) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx x0.loc x0.txt k in\n let k = f1 ctx loc x1 k in let k = f2 ctx loc x2 k in k))\n | _ -> fail loc \"letmodule\"))\nlet pexp_letexception (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_letexception (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"letexception\"))\nlet pexp_assert (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_assert x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"assert\"))\nlet pexp_lazy (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_lazy x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"lazy\"))\nlet pexp_poly (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_poly (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"poly\"))\nlet pexp_object (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_object x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"object\"))\nlet pexp_newtype (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_newtype (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx x0.loc x0.txt k in\n let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"newtype\"))\nlet pexp_pack (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_pack x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"pack\"))\nlet pexp_open (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_open (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"open\"))\nlet pexp_letop (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_letop x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"letop\"))\nlet pexp_extension (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_extension x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"extension\"))\nlet pexp_unreachable =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_unreachable -> (ctx.matched <- (ctx.matched + 1); k)\n | _ -> fail loc \"unreachable\"))\nlet extension_constructor_attributes (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pext_loc in\n let k = f1 ctx loc x.pext_attributes k in\n let x = { x with pext_attributes = [] } in\n let k = f2 ctx loc x k in k)\nlet extension_constructor ~name:(T name) ~kind:(T kind) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pext_attributes;\n (let k = name ctx (x.pext_name).loc (x.pext_name).txt k in\n let k = kind ctx loc x.pext_kind k in k))\nlet pext_decl (T f0) (T f1) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Pext_decl (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"decl\")\nlet pext_rebind (T f0) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Pext_rebind x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx x0.loc x0.txt k in k))\n | _ -> fail loc \"rebind\")\nlet unit =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Unit -> (ctx.matched <- (ctx.matched + 1); k)\n | _ -> fail loc \"Unit\")\nlet named (T f0) (T f1) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Named (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx x0.loc x0.txt k in\n let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"Named\")\nlet include_infos_attributes (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pincl_loc in\n let k = f1 ctx loc x.pincl_attributes k in\n let x = { x with pincl_attributes = [] } in\n let k = f2 ctx loc x k in k)\nlet include_infos ~mod_:(T mod_) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pincl_attributes;\n (let k = mod_ ctx loc x.pincl_mod k in k))\nlet injective =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Injective -> (ctx.matched <- (ctx.matched + 1); k)\n | _ -> fail loc \"Injective\")\nlet noinjectivity =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | NoInjectivity -> (ctx.matched <- (ctx.matched + 1); k)\n | _ -> fail loc \"NoInjectivity\")\nlet label_declaration_attributes (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pld_loc in\n let k = f1 ctx loc x.pld_attributes k in\n let x = { x with pld_attributes = [] } in\n let k = f2 ctx loc x k in k)\nlet label_declaration ~name:(T name) ~mutable_:(T mutable_) ~type_:(T\n type_) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pld_attributes;\n (let k = name ctx (x.pld_name).loc (x.pld_name).txt k in\n let k = mutable_ ctx loc x.pld_mutable k in\n let k = type_ ctx loc x.pld_type k in k))\nlet letop ~let_:(T let_) ~ands:(T ands) ~body:(T body) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n let k = let_ ctx loc x.let_ k in\n let k = ands ctx loc x.ands k in\n let k = body ctx loc x.body k in k)\nlet location ~start:(T start) ~end_:(T end_) ~ghost:(T ghost) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n let k = start ctx loc x.loc_start k in\n let k = end_ ctx loc x.loc_end k in\n let k = ghost ctx loc x.loc_ghost k in k)\nlet lident (T f0) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Lident x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"Lident\")\nlet ldot (T f0) (T f1) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Ldot (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"Ldot\")\nlet lapply (T f0) (T f1) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Lapply (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"Lapply\")\nlet module_binding_attributes (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pmb_loc in\n let k = f1 ctx loc x.pmb_attributes k in\n let x = { x with pmb_attributes = [] } in\n let k = f2 ctx loc x k in k)\nlet module_binding ~name:(T name) ~expr:(T expr) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pmb_attributes;\n (let k = name ctx (x.pmb_name).loc (x.pmb_name).txt k in\n let k = expr ctx loc x.pmb_expr k in k))\nlet module_declaration_attributes (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pmd_loc in\n let k = f1 ctx loc x.pmd_attributes k in\n let x = { x with pmd_attributes = [] } in\n let k = f2 ctx loc x k in k)\nlet module_declaration ~name:(T name) ~type_:(T type_) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pmd_attributes;\n (let k = name ctx (x.pmd_name).loc (x.pmd_name).txt k in\n let k = type_ ctx loc x.pmd_type k in k))\nlet pmod_loc (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pmod_loc in\n let k = f1 ctx loc loc k in let k = f2 ctx loc x k in k)\nlet pmod_attributes (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pmod_loc in\n let k = f1 ctx loc x.pmod_attributes k in\n let x = { x with pmod_attributes = [] } in\n let k = f2 ctx loc x k in k)\nlet pmod_ident (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pmod_attributes;\n (let loc = x.pmod_loc in\n let x = x.pmod_desc in\n match x with\n | Pmod_ident x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx x0.loc x0.txt k in k))\n | _ -> fail loc \"ident\"))\nlet pmod_structure (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pmod_attributes;\n (let loc = x.pmod_loc in\n let x = x.pmod_desc in\n match x with\n | Pmod_structure x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"structure\"))\nlet pmod_functor (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pmod_attributes;\n (let loc = x.pmod_loc in\n let x = x.pmod_desc in\n match x with\n | Pmod_functor (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"functor\"))\nlet pmod_apply (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pmod_attributes;\n (let loc = x.pmod_loc in\n let x = x.pmod_desc in\n match x with\n | Pmod_apply (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"apply\"))\nlet pmod_constraint (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pmod_attributes;\n (let loc = x.pmod_loc in\n let x = x.pmod_desc in\n match x with\n | Pmod_constraint (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"constraint\"))\nlet pmod_unpack (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pmod_attributes;\n (let loc = x.pmod_loc in\n let x = x.pmod_desc in\n match x with\n | Pmod_unpack x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"unpack\"))\nlet pmod_extension (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pmod_attributes;\n (let loc = x.pmod_loc in\n let x = x.pmod_desc in\n match x with\n | Pmod_extension x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"extension\"))\nlet module_substitution_attributes (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pms_loc in\n let k = f1 ctx loc x.pms_attributes k in\n let x = { x with pms_attributes = [] } in\n let k = f2 ctx loc x k in k)\nlet module_substitution ~name:(T name) ~manifest:(T manifest) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pms_attributes;\n (let k = name ctx (x.pms_name).loc (x.pms_name).txt k in\n let k =\n manifest ctx (x.pms_manifest).loc (x.pms_manifest).txt k in\n k))\nlet pmty_loc (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pmty_loc in\n let k = f1 ctx loc loc k in let k = f2 ctx loc x k in k)\nlet pmty_attributes (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pmty_loc in\n let k = f1 ctx loc x.pmty_attributes k in\n let x = { x with pmty_attributes = [] } in\n let k = f2 ctx loc x k in k)\nlet pmty_ident (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pmty_attributes;\n (let loc = x.pmty_loc in\n let x = x.pmty_desc in\n match x with\n | Pmty_ident x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx x0.loc x0.txt k in k))\n | _ -> fail loc \"ident\"))\nlet pmty_signature (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pmty_attributes;\n (let loc = x.pmty_loc in\n let x = x.pmty_desc in\n match x with\n | Pmty_signature x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"signature\"))\nlet pmty_functor (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pmty_attributes;\n (let loc = x.pmty_loc in\n let x = x.pmty_desc in\n match x with\n | Pmty_functor (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"functor\"))\nlet pmty_with (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pmty_attributes;\n (let loc = x.pmty_loc in\n let x = x.pmty_desc in\n match x with\n | Pmty_with (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"with\"))\nlet pmty_typeof (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pmty_attributes;\n (let loc = x.pmty_loc in\n let x = x.pmty_desc in\n match x with\n | Pmty_typeof x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"typeof\"))\nlet pmty_extension (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pmty_attributes;\n (let loc = x.pmty_loc in\n let x = x.pmty_desc in\n match x with\n | Pmty_extension x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"extension\"))\nlet pmty_alias (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pmty_attributes;\n (let loc = x.pmty_loc in\n let x = x.pmty_desc in\n match x with\n | Pmty_alias x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx x0.loc x0.txt k in k))\n | _ -> fail loc \"alias\"))\nlet module_type_declaration_attributes (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pmtd_loc in\n let k = f1 ctx loc x.pmtd_attributes k in\n let x = { x with pmtd_attributes = [] } in\n let k = f2 ctx loc x k in k)\nlet module_type_declaration ~name:(T name) ~type_:(T type_) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pmtd_attributes;\n (let k = name ctx (x.pmtd_name).loc (x.pmtd_name).txt k in\n let k = type_ ctx loc x.pmtd_type k in k))\nlet immutable =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Immutable -> (ctx.matched <- (ctx.matched + 1); k)\n | _ -> fail loc \"Immutable\")\nlet mutable_ =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Mutable -> (ctx.matched <- (ctx.matched + 1); k)\n | _ -> fail loc \"Mutable\")\nlet pof_loc (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pof_loc in\n let k = f1 ctx loc loc k in let k = f2 ctx loc x k in k)\nlet pof_attributes (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pof_loc in\n let k = f1 ctx loc x.pof_attributes k in\n let x = { x with pof_attributes = [] } in\n let k = f2 ctx loc x k in k)\nlet otag (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pof_attributes;\n (let loc = x.pof_loc in\n let x = x.pof_desc in\n match x with\n | Otag (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx x0.loc x0.txt k in\n let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"Otag\"))\nlet oinherit (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pof_attributes;\n (let loc = x.pof_loc in\n let x = x.pof_desc in\n match x with\n | Oinherit x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"Oinherit\"))\nlet open_infos_attributes (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.popen_loc in\n let k = f1 ctx loc x.popen_attributes k in\n let x = { x with popen_attributes = [] } in\n let k = f2 ctx loc x k in k)\nlet open_infos ~expr:(T expr) ~override:(T override) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.popen_attributes;\n (let k = expr ctx loc x.popen_expr k in\n let k = override ctx loc x.popen_override k in k))\nlet override =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Override -> (ctx.matched <- (ctx.matched + 1); k)\n | _ -> fail loc \"Override\")\nlet fresh =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Fresh -> (ctx.matched <- (ctx.matched + 1); k)\n | _ -> fail loc \"Fresh\")\nlet ppat_loc (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.ppat_loc in\n let k = f1 ctx loc loc k in let k = f2 ctx loc x k in k)\nlet ppat_attributes (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.ppat_loc in\n let k = f1 ctx loc x.ppat_attributes k in\n let x = { x with ppat_attributes = [] } in\n let k = f2 ctx loc x k in k)\nlet ppat_any =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ppat_attributes;\n (let loc = x.ppat_loc in\n let x = x.ppat_desc in\n match x with\n | Ppat_any -> (ctx.matched <- (ctx.matched + 1); k)\n | _ -> fail loc \"any\"))\nlet ppat_var (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ppat_attributes;\n (let loc = x.ppat_loc in\n let x = x.ppat_desc in\n match x with\n | Ppat_var x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx x0.loc x0.txt k in k))\n | _ -> fail loc \"var\"))\nlet ppat_alias (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ppat_attributes;\n (let loc = x.ppat_loc in\n let x = x.ppat_desc in\n match x with\n | Ppat_alias (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in\n let k = f1 ctx x1.loc x1.txt k in k))\n | _ -> fail loc \"alias\"))\nlet ppat_constant (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ppat_attributes;\n (let loc = x.ppat_loc in\n let x = x.ppat_desc in\n match x with\n | Ppat_constant x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"constant\"))\nlet ppat_interval (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ppat_attributes;\n (let loc = x.ppat_loc in\n let x = x.ppat_desc in\n match x with\n | Ppat_interval (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"interval\"))\nlet ppat_tuple (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ppat_attributes;\n (let loc = x.ppat_loc in\n let x = x.ppat_desc in\n match x with\n | Ppat_tuple x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"tuple\"))\nlet ppat_construct (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ppat_attributes;\n (let loc = x.ppat_loc in\n let x = x.ppat_desc in\n match x with\n | Ppat_construct (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx x0.loc x0.txt k in\n let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"construct\"))\nlet ppat_variant (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ppat_attributes;\n (let loc = x.ppat_loc in\n let x = x.ppat_desc in\n match x with\n | Ppat_variant (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"variant\"))\nlet ppat_record (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ppat_attributes;\n (let loc = x.ppat_loc in\n let x = x.ppat_desc in\n match x with\n | Ppat_record (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"record\"))\nlet ppat_array (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ppat_attributes;\n (let loc = x.ppat_loc in\n let x = x.ppat_desc in\n match x with\n | Ppat_array x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"array\"))\nlet ppat_or (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ppat_attributes;\n (let loc = x.ppat_loc in\n let x = x.ppat_desc in\n match x with\n | Ppat_or (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"or\"))\nlet ppat_constraint (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ppat_attributes;\n (let loc = x.ppat_loc in\n let x = x.ppat_desc in\n match x with\n | Ppat_constraint (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"constraint\"))\nlet ppat_type (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ppat_attributes;\n (let loc = x.ppat_loc in\n let x = x.ppat_desc in\n match x with\n | Ppat_type x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx x0.loc x0.txt k in k))\n | _ -> fail loc \"type\"))\nlet ppat_lazy (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ppat_attributes;\n (let loc = x.ppat_loc in\n let x = x.ppat_desc in\n match x with\n | Ppat_lazy x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"lazy\"))\nlet ppat_unpack (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ppat_attributes;\n (let loc = x.ppat_loc in\n let x = x.ppat_desc in\n match x with\n | Ppat_unpack x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx x0.loc x0.txt k in k))\n | _ -> fail loc \"unpack\"))\nlet ppat_exception (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ppat_attributes;\n (let loc = x.ppat_loc in\n let x = x.ppat_desc in\n match x with\n | Ppat_exception x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"exception\"))\nlet ppat_extension (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ppat_attributes;\n (let loc = x.ppat_loc in\n let x = x.ppat_desc in\n match x with\n | Ppat_extension x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"extension\"))\nlet ppat_open (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ppat_attributes;\n (let loc = x.ppat_loc in\n let x = x.ppat_desc in\n match x with\n | Ppat_open (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx x0.loc x0.txt k in\n let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"open\"))\nlet pstr (T f0) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | PStr x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"PStr\")\nlet psig (T f0) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | PSig x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"PSig\")\nlet ptyp (T f0) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | PTyp x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"PTyp\")\nlet ppat (T f0) (T f1) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | PPat (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"PPat\")\nlet position ~fname:(T fname) ~lnum:(T lnum) ~bol:(T bol) ~cnum:(T cnum) \n =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n let k = fname ctx loc x.pos_fname k in\n let k = lnum ctx loc x.pos_lnum k in\n let k = bol ctx loc x.pos_bol k in\n let k = cnum ctx loc x.pos_cnum k in k)\nlet private_ =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Private -> (ctx.matched <- (ctx.matched + 1); k)\n | _ -> fail loc \"Private\")\nlet public =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Public -> (ctx.matched <- (ctx.matched + 1); k)\n | _ -> fail loc \"Public\")\nlet nonrecursive =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Nonrecursive -> (ctx.matched <- (ctx.matched + 1); k)\n | _ -> fail loc \"Nonrecursive\")\nlet recursive =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Recursive -> (ctx.matched <- (ctx.matched + 1); k)\n | _ -> fail loc \"Recursive\")\nlet prf_loc (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.prf_loc in\n let k = f1 ctx loc loc k in let k = f2 ctx loc x k in k)\nlet prf_attributes (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.prf_loc in\n let k = f1 ctx loc x.prf_attributes k in\n let x = { x with prf_attributes = [] } in\n let k = f2 ctx loc x k in k)\nlet rtag (T f0) (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.prf_attributes;\n (let loc = x.prf_loc in\n let x = x.prf_desc in\n match x with\n | Rtag (x0, x1, x2) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx x0.loc x0.txt k in\n let k = f1 ctx loc x1 k in let k = f2 ctx loc x2 k in k))\n | _ -> fail loc \"Rtag\"))\nlet rinherit (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.prf_attributes;\n (let loc = x.prf_loc in\n let x = x.prf_desc in\n match x with\n | Rinherit x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"Rinherit\"))\nlet psig_loc (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.psig_loc in\n let k = f1 ctx loc loc k in let k = f2 ctx loc x k in k)\nlet psig_value (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.psig_loc in\n let x = x.psig_desc in\n match x with\n | Psig_value x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"value\")\nlet psig_type (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.psig_loc in\n let x = x.psig_desc in\n match x with\n | Psig_type (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"type\")\nlet psig_typesubst (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.psig_loc in\n let x = x.psig_desc in\n match x with\n | Psig_typesubst x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"typesubst\")\nlet psig_typext (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.psig_loc in\n let x = x.psig_desc in\n match x with\n | Psig_typext x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"typext\")\nlet psig_exception (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.psig_loc in\n let x = x.psig_desc in\n match x with\n | Psig_exception x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"exception\")\nlet psig_module (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.psig_loc in\n let x = x.psig_desc in\n match x with\n | Psig_module x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"module\")\nlet psig_modsubst (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.psig_loc in\n let x = x.psig_desc in\n match x with\n | Psig_modsubst x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"modsubst\")\nlet psig_recmodule (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.psig_loc in\n let x = x.psig_desc in\n match x with\n | Psig_recmodule x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"recmodule\")\nlet psig_modtype (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.psig_loc in\n let x = x.psig_desc in\n match x with\n | Psig_modtype x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"modtype\")\nlet psig_open (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.psig_loc in\n let x = x.psig_desc in\n match x with\n | Psig_open x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"open\")\nlet psig_include (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.psig_loc in\n let x = x.psig_desc in\n match x with\n | Psig_include x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"include\")\nlet psig_class (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.psig_loc in\n let x = x.psig_desc in\n match x with\n | Psig_class x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"class\")\nlet psig_class_type (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.psig_loc in\n let x = x.psig_desc in\n match x with\n | Psig_class_type x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"class_type\")\nlet psig_attribute (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.psig_loc in\n let x = x.psig_desc in\n match x with\n | Psig_attribute x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"attribute\")\nlet psig_extension (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.psig_loc in\n let x = x.psig_desc in\n match x with\n | Psig_extension (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"extension\")\nlet pstr_loc (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pstr_loc in\n let k = f1 ctx loc loc k in let k = f2 ctx loc x k in k)\nlet pstr_eval (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pstr_loc in\n let x = x.pstr_desc in\n match x with\n | Pstr_eval (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"eval\")\nlet pstr_value (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pstr_loc in\n let x = x.pstr_desc in\n match x with\n | Pstr_value (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"value\")\nlet pstr_primitive (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pstr_loc in\n let x = x.pstr_desc in\n match x with\n | Pstr_primitive x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"primitive\")\nlet pstr_type (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pstr_loc in\n let x = x.pstr_desc in\n match x with\n | Pstr_type (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"type\")\nlet pstr_typext (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pstr_loc in\n let x = x.pstr_desc in\n match x with\n | Pstr_typext x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"typext\")\nlet pstr_exception (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pstr_loc in\n let x = x.pstr_desc in\n match x with\n | Pstr_exception x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"exception\")\nlet pstr_module (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pstr_loc in\n let x = x.pstr_desc in\n match x with\n | Pstr_module x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"module\")\nlet pstr_recmodule (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pstr_loc in\n let x = x.pstr_desc in\n match x with\n | Pstr_recmodule x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"recmodule\")\nlet pstr_modtype (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pstr_loc in\n let x = x.pstr_desc in\n match x with\n | Pstr_modtype x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"modtype\")\nlet pstr_open (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pstr_loc in\n let x = x.pstr_desc in\n match x with\n | Pstr_open x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"open\")\nlet pstr_class (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pstr_loc in\n let x = x.pstr_desc in\n match x with\n | Pstr_class x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"class\")\nlet pstr_class_type (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pstr_loc in\n let x = x.pstr_desc in\n match x with\n | Pstr_class_type x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"class_type\")\nlet pstr_include (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pstr_loc in\n let x = x.pstr_desc in\n match x with\n | Pstr_include x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"include\")\nlet pstr_attribute (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pstr_loc in\n let x = x.pstr_desc in\n match x with\n | Pstr_attribute x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"attribute\")\nlet pstr_extension (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pstr_loc in\n let x = x.pstr_desc in\n match x with\n | Pstr_extension (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"extension\")\nlet toplevel_directive ~name:(T name) ~arg:(T arg) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n let k = name ctx (x.pdir_name).loc (x.pdir_name).txt k in\n let k = arg ctx loc x.pdir_arg k in k)\nlet ptop_def (T f0) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Ptop_def x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"def\")\nlet ptop_dir (T f0) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Ptop_dir x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"dir\")\nlet type_declaration_attributes (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.ptype_loc in\n let k = f1 ctx loc x.ptype_attributes k in\n let x = { x with ptype_attributes = [] } in\n let k = f2 ctx loc x k in k)\nlet type_declaration ~name:(T name) ~params:(T params) ~cstrs:(T cstrs) \n ~kind:(T kind) ~private_:(T private_) ~manifest:(T manifest) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ptype_attributes;\n (let k = name ctx (x.ptype_name).loc (x.ptype_name).txt k in\n let k = params ctx loc x.ptype_params k in\n let k = cstrs ctx loc x.ptype_cstrs k in\n let k = kind ctx loc x.ptype_kind k in\n let k = private_ ctx loc x.ptype_private k in\n let k = manifest ctx loc x.ptype_manifest k in k))\nlet type_exception_attributes (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.ptyexn_loc in\n let k = f1 ctx loc x.ptyexn_attributes k in\n let x = { x with ptyexn_attributes = [] } in\n let k = f2 ctx loc x k in k)\nlet type_exception ~constructor:(T constructor) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ptyexn_attributes;\n (let k = constructor ctx loc x.ptyexn_constructor k in k))\nlet type_extension_attributes (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.ptyext_loc in\n let k = f1 ctx loc x.ptyext_attributes k in\n let x = { x with ptyext_attributes = [] } in\n let k = f2 ctx loc x k in k)\nlet type_extension ~path:(T path) ~params:(T params) ~constructors:(T\n constructors) ~private_:(T private_) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ptyext_attributes;\n (let k = path ctx (x.ptyext_path).loc (x.ptyext_path).txt k in\n let k = params ctx loc x.ptyext_params k in\n let k = constructors ctx loc x.ptyext_constructors k in\n let k = private_ ctx loc x.ptyext_private k in k))\nlet ptype_abstract =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Ptype_abstract -> (ctx.matched <- (ctx.matched + 1); k)\n | _ -> fail loc \"abstract\")\nlet ptype_variant (T f0) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Ptype_variant x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"variant\")\nlet ptype_record (T f0) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Ptype_record x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"record\")\nlet ptype_open =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Ptype_open -> (ctx.matched <- (ctx.matched + 1); k)\n | _ -> fail loc \"open\")\nlet value_binding_attributes (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pvb_loc in\n let k = f1 ctx loc x.pvb_attributes k in\n let x = { x with pvb_attributes = [] } in\n let k = f2 ctx loc x k in k)\nlet value_binding ~pat:(T pat) ~expr:(T expr) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pvb_attributes;\n (let k = pat ctx loc x.pvb_pat k in\n let k = expr ctx loc x.pvb_expr k in k))\nlet value_description_attributes (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pval_loc in\n let k = f1 ctx loc x.pval_attributes k in\n let x = { x with pval_attributes = [] } in\n let k = f2 ctx loc x k in k)\nlet value_description ~name:(T name) ~type_:(T type_) ~prim:(T prim) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pval_attributes;\n (let k = name ctx (x.pval_name).loc (x.pval_name).txt k in\n let k = type_ ctx loc x.pval_type k in\n let k = prim ctx loc x.pval_prim k in k))\nlet covariant =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Covariant -> (ctx.matched <- (ctx.matched + 1); k)\n | _ -> fail loc \"Covariant\")\nlet contravariant =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Contravariant -> (ctx.matched <- (ctx.matched + 1); k)\n | _ -> fail loc \"Contravariant\")\nlet novariance =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | NoVariance -> (ctx.matched <- (ctx.matched + 1); k)\n | _ -> fail loc \"NoVariance\")\nlet virtual_ =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Virtual -> (ctx.matched <- (ctx.matched + 1); k)\n | _ -> fail loc \"Virtual\")\nlet concrete =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Concrete -> (ctx.matched <- (ctx.matched + 1); k)\n | _ -> fail loc \"Concrete\")\nlet pwith_type (T f0) (T f1) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Pwith_type (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx x0.loc x0.txt k in\n let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"type\")\nlet pwith_module (T f0) (T f1) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Pwith_module (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx x0.loc x0.txt k in\n let k = f1 ctx x1.loc x1.txt k in k))\n | _ -> fail loc \"module\")\nlet pwith_typesubst (T f0) (T f1) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Pwith_typesubst (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx x0.loc x0.txt k in\n let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"typesubst\")\nlet pwith_modsubst (T f0) (T f1) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Pwith_modsubst (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx x0.loc x0.txt k in\n let k = f1 ctx x1.loc x1.txt k in k))\n | _ -> fail loc \"modsubst\")\n","open! Import\ninclude Ast_pattern0\n\nlet save_context ctx = ctx.matched\nlet restore_context ctx backup = ctx.matched <- backup\nlet incr_matched c = c.matched <- c.matched + 1\n\nlet parse (T f) loc ?on_error x k =\n try f { matched = 0 } loc x k\n with Expected (loc, expected) -> (\n match on_error with\n | None -> Location.raise_errorf ~loc \"%s expected\" expected\n | Some f -> f ())\n\nmodule Packed = struct\n type ('a, 'b) t = T : ('a, 'b, 'c) Ast_pattern0.t * 'b -> ('a, 'c) t\n\n let create t f = T (t, f)\n let parse (T (t, f)) loc x = parse t loc x f\nend\n\nlet __ =\n T\n (fun ctx _loc x k ->\n incr_matched ctx;\n k x)\n\nlet __' =\n T\n (fun ctx loc x k ->\n incr_matched ctx;\n k { loc; txt = x })\n\nlet drop =\n T\n (fun ctx _loc _ k ->\n incr_matched ctx;\n k)\n\nlet as__ (T f1) =\n T\n (fun ctx loc x k ->\n let k = f1 ctx loc x (k x) in\n k)\n\nlet cst ~to_string ?(equal = Poly.equal) v =\n T\n (fun ctx loc x k ->\n if equal x v then (\n incr_matched ctx;\n k)\n else fail loc (to_string v))\n\nlet int v = cst ~to_string:Int.to_string v\nlet char v = cst ~to_string:(Printf.sprintf \"%C\") v\nlet string v = cst ~to_string:(Printf.sprintf \"%S\") v\nlet float v = cst ~to_string:Float.to_string v\nlet int32 v = cst ~to_string:Int32.to_string v\nlet int64 v = cst ~to_string:Int64.to_string v\nlet nativeint v = cst ~to_string:Nativeint.to_string v\nlet bool v = cst ~to_string:Bool.to_string v\n\nlet false_ =\n T\n (fun ctx loc x k ->\n match x with\n | false ->\n ctx.matched <- ctx.matched + 1;\n k\n | _ -> fail loc \"false\")\n\nlet true_ =\n T\n (fun ctx loc x k ->\n match x with\n | true ->\n ctx.matched <- ctx.matched + 1;\n k\n | _ -> fail loc \"true\")\n\nlet nil =\n T\n (fun ctx loc x k ->\n match x with\n | [] ->\n ctx.matched <- ctx.matched + 1;\n k\n | _ -> fail loc \"[]\")\n\nlet ( ^:: ) (T f0) (T f1) =\n T\n (fun ctx loc x k ->\n match x with\n | x0 :: x1 ->\n ctx.matched <- ctx.matched + 1;\n let k = f0 ctx loc x0 k in\n let k = f1 ctx loc x1 k in\n k\n | _ -> fail loc \"::\")\n\nlet none =\n T\n (fun ctx loc x k ->\n match x with\n | None ->\n ctx.matched <- ctx.matched + 1;\n k\n | _ -> fail loc \"None\")\n\nlet some (T f0) =\n T\n (fun ctx loc x k ->\n match x with\n | Some x0 ->\n ctx.matched <- ctx.matched + 1;\n let k = f0 ctx loc x0 k in\n k\n | _ -> fail loc \"Some\")\n\nlet pair (T f1) (T f2) =\n T\n (fun ctx loc (x1, x2) k ->\n let k = f1 ctx loc x1 k in\n let k = f2 ctx loc x2 k in\n k)\n\nlet ( ** ) = pair\n\nlet triple (T f1) (T f2) (T f3) =\n T\n (fun ctx loc (x1, x2, x3) k ->\n let k = f1 ctx loc x1 k in\n let k = f2 ctx loc x2 k in\n let k = f3 ctx loc x3 k in\n k)\n\nlet alt (T f1) (T f2) =\n T\n (fun ctx loc x k ->\n let backup = save_context ctx in\n try f1 ctx loc x k\n with e1 -> (\n let m1 = save_context ctx in\n restore_context ctx backup;\n try f2 ctx loc x k\n with e2 ->\n let m2 = save_context ctx in\n if m1 >= m2 then (\n restore_context ctx m1;\n raise e1)\n else raise e2))\n\nlet ( ||| ) = alt\nlet map (T func) ~f = T (fun ctx loc x k -> func ctx loc x (f k))\nlet map' (T func) ~f = T (fun ctx loc x k -> func ctx loc x (f loc k))\nlet map_result (T func) ~f = T (fun ctx loc x k -> f (func ctx loc x k))\nlet ( >>| ) t f = map t ~f\nlet map0 (T func) ~f = T (fun ctx loc x k -> func ctx loc x (k f))\nlet map1 (T func) ~f = T (fun ctx loc x k -> func ctx loc x (fun a -> k (f a)))\n\nlet map2 (T func) ~f =\n T (fun ctx loc x k -> func ctx loc x (fun a b -> k (f a b)))\n\nlet map0' (T func) ~f = T (fun ctx loc x k -> func ctx loc x (k (f loc)))\n\nlet map1' (T func) ~f =\n T (fun ctx loc x k -> func ctx loc x (fun a -> k (f loc a)))\n\nlet map2' (T func) ~f =\n T (fun ctx loc x k -> func ctx loc x (fun a b -> k (f loc a b)))\n\nlet alt_option some none =\n alt (map1 some ~f:(fun x -> Some x)) (map0 none ~f:None)\n\nlet many (T f) =\n T (fun ctx loc l k -> k (List.map l ~f:(fun x -> f ctx loc x (fun x -> x))))\n\nlet loc (T f) = T (fun ctx _loc (x : _ Loc.t) k -> f ctx x.loc x.txt k)\nlet pack0 t = map t ~f:(fun f -> f ())\nlet pack2 t = map t ~f:(fun f x y -> f (x, y))\nlet pack3 t = map t ~f:(fun f x y z -> f (x, y, z))\n\ninclude Ast_pattern_generated\n\nlet echar t = pexp_constant (pconst_char t)\nlet estring t = pexp_constant (pconst_string t drop drop)\nlet efloat t = pexp_constant (pconst_float t drop)\nlet pchar t = ppat_constant (pconst_char t)\nlet pstring t = ppat_constant (pconst_string t drop drop)\nlet pfloat t = ppat_constant (pconst_float t drop)\nlet int' (T f) = T (fun ctx loc x k -> f ctx loc (int_of_string x) k)\nlet int32' (T f) = T (fun ctx loc x k -> f ctx loc (Int32.of_string x) k)\nlet int64' (T f) = T (fun ctx loc x k -> f ctx loc (Int64.of_string x) k)\n\nlet nativeint' (T f) =\n T (fun ctx loc x k -> f ctx loc (Nativeint.of_string x) k)\n\nlet const_int t = pconst_integer (int' t) none\nlet const_int32 t = pconst_integer (int32' t) (some (char 'l'))\nlet const_int64 t = pconst_integer (int64' t) (some (char 'L'))\nlet const_nativeint t = pconst_integer (nativeint' t) (some (char 'n'))\nlet eint t = pexp_constant (const_int t)\nlet eint32 t = pexp_constant (const_int32 t)\nlet eint64 t = pexp_constant (const_int64 t)\nlet enativeint t = pexp_constant (const_nativeint t)\nlet pint t = ppat_constant (const_int t)\nlet pint32 t = ppat_constant (const_int32 t)\nlet pint64 t = ppat_constant (const_int64 t)\nlet pnativeint t = ppat_constant (const_nativeint t)\nlet single_expr_payload t = pstr (pstr_eval t nil ^:: nil)\nlet no_label t = cst Asttypes.Nolabel ~to_string:(fun _ -> \"Nolabel\") ** t\n\nlet extension (T f1) (T f2) =\n T\n (fun ctx loc ((name : _ Loc.t), payload) k ->\n let k = f1 ctx name.loc name.txt k in\n let k = f2 ctx loc payload k in\n k)\n\nlet rec parse_elist (e : Parsetree.expression) acc =\n Common.assert_no_attributes e.pexp_attributes;\n match e.pexp_desc with\n | Pexp_construct ({ txt = Lident \"[]\"; _ }, None) -> List.rev acc\n | Pexp_construct ({ txt = Lident \"::\"; _ }, Some arg) -> (\n Common.assert_no_attributes arg.pexp_attributes;\n match arg.pexp_desc with\n | Pexp_tuple [ hd; tl ] -> parse_elist tl (hd :: acc)\n | _ -> fail arg.pexp_loc \"list\")\n | _ -> fail e.pexp_loc \"list\"\n\nlet elist (T f) =\n T\n (fun ctx _loc e k ->\n let l = parse_elist e [] in\n incr_matched ctx;\n k (List.map l ~f:(fun x -> f ctx x.Parsetree.pexp_loc x (fun x -> x))))\n\nlet esequence (T f) =\n T\n (fun ctx _loc e k ->\n let rec parse_seq expr acc =\n match expr.pexp_desc with\n | Pexp_sequence (expr, next) -> parse_seq next (expr :: acc)\n | _ -> expr :: acc\n in\n k\n (List.rev_map (parse_seq e []) ~f:(fun expr ->\n f ctx expr.pexp_loc expr (fun x -> x))))\n\nlet of_func f = T f\nlet to_func (T f) = f\n","open! Import\nopen Common\n\ntype (_, _) equality = Eq : ('a, 'a) equality | Ne : (_, _) equality\n\nmodule Context = struct\n type 'a t =\n | Class_expr : class_expr t\n | Class_field : class_field t\n | Class_type : class_type t\n | Class_type_field : class_type_field t\n | Core_type : core_type t\n | Expression : expression t\n | Module_expr : module_expr t\n | Module_type : module_type t\n | Pattern : pattern t\n | Signature_item : signature_item t\n | Structure_item : structure_item t\n | Ppx_import : type_declaration t\n\n type packed = T : _ t -> packed\n\n let class_expr = Class_expr\n let class_field = Class_field\n let class_type = Class_type\n let class_type_field = Class_type_field\n let core_type = Core_type\n let expression = Expression\n let module_expr = Module_expr\n let module_type = Module_type\n let pattern = Pattern\n let signature_item = Signature_item\n let structure_item = Structure_item\n\n let desc : type a. a t -> string = function\n | Class_expr -> \"class expression\"\n | Class_field -> \"class field\"\n | Class_type -> \"class type\"\n | Class_type_field -> \"class type field\"\n | Core_type -> \"core type\"\n | Expression -> \"expression\"\n | Module_expr -> \"module expression\"\n | Module_type -> \"module type\"\n | Pattern -> \"pattern\"\n | Signature_item -> \"signature item\"\n | Structure_item -> \"structure item\"\n | Ppx_import -> \"type declaration\"\n\n let eq : type a b. a t -> b t -> (a, b) equality =\n fun a b ->\n match (a, b) with\n | Class_expr, Class_expr -> Eq\n | Class_field, Class_field -> Eq\n | Class_type, Class_type -> Eq\n | Class_type_field, Class_type_field -> Eq\n | Core_type, Core_type -> Eq\n | Expression, Expression -> Eq\n | Module_expr, Module_expr -> Eq\n | Module_type, Module_type -> Eq\n | Pattern, Pattern -> Eq\n | Signature_item, Signature_item -> Eq\n | Structure_item, Structure_item -> Eq\n | Ppx_import, Ppx_import -> Eq\n | _ ->\n assert (Poly.( <> ) (T a) (T b));\n Ne\n\n let get_ppx_import_extension type_decl =\n match type_decl with\n | { ptype_manifest = Some { ptyp_desc = Ptyp_extension (name, _); _ }; _ }\n ->\n let virtual_payload =\n Ast_builder.Default.pstr_type ~loc:type_decl.ptype_loc Recursive\n [ type_decl ]\n in\n let attr = [] in\n Some ((name, PStr [ virtual_payload ]), attr)\n | _ -> None\n\n let get_extension : type a. a t -> a -> (extension * attributes) option =\n fun t x ->\n match (t, x) with\n | Class_expr, { pcl_desc = Pcl_extension e; pcl_attributes = a; _ } ->\n Some (e, a)\n | Class_field, { pcf_desc = Pcf_extension e; pcf_attributes = a; _ } ->\n Some (e, a)\n | Class_type, { pcty_desc = Pcty_extension e; pcty_attributes = a; _ } ->\n Some (e, a)\n | Class_type_field, { pctf_desc = Pctf_extension e; pctf_attributes = a; _ }\n ->\n Some (e, a)\n | Core_type, { ptyp_desc = Ptyp_extension e; ptyp_attributes = a; _ } ->\n Some (e, a)\n | Expression, { pexp_desc = Pexp_extension e; pexp_attributes = a; _ } ->\n Some (e, a)\n | Module_expr, { pmod_desc = Pmod_extension e; pmod_attributes = a; _ } ->\n Some (e, a)\n | Module_type, { pmty_desc = Pmty_extension e; pmty_attributes = a; _ } ->\n Some (e, a)\n | Pattern, { ppat_desc = Ppat_extension e; ppat_attributes = a; _ } ->\n Some (e, a)\n | Signature_item, { psig_desc = Psig_extension (e, a); _ } -> Some (e, a)\n | Structure_item, { pstr_desc = Pstr_extension (e, a); _ } -> Some (e, a)\n | Ppx_import, type_decl -> get_ppx_import_extension type_decl\n | _ -> None\n\n let merge_attributes : type a. a t -> a -> attributes -> a =\n fun t x attrs ->\n match t with\n | Class_expr -> { x with pcl_attributes = x.pcl_attributes @ attrs }\n | Class_field -> { x with pcf_attributes = x.pcf_attributes @ attrs }\n | Class_type -> { x with pcty_attributes = x.pcty_attributes @ attrs }\n | Class_type_field -> { x with pctf_attributes = x.pctf_attributes @ attrs }\n | Core_type -> { x with ptyp_attributes = x.ptyp_attributes @ attrs }\n | Expression -> { x with pexp_attributes = x.pexp_attributes @ attrs }\n | Module_expr -> { x with pmod_attributes = x.pmod_attributes @ attrs }\n | Module_type -> { x with pmty_attributes = x.pmty_attributes @ attrs }\n | Pattern -> { x with ppat_attributes = x.ppat_attributes @ attrs }\n | Signature_item ->\n assert_no_attributes attrs;\n x\n | Structure_item ->\n assert_no_attributes attrs;\n x\n | Ppx_import ->\n assert_no_attributes attrs;\n x\nend\n\nlet registrar =\n Name.Registrar.create ~kind:\"extension\" ~current_file:__FILE__\n ~string_of_context:(fun (Context.T ctx) -> Some (Context.desc ctx))\n\nmodule Make (Callback : sig\n type 'a t\nend) =\nstruct\n type ('a, 'b) payload_parser =\n | Payload_parser :\n ('a, 'b, 'c) Ast_pattern.t * 'b Callback.t\n -> ('a, 'c) payload_parser\n\n type ('context, 'payload) t = {\n name : Name.Pattern.t;\n context : 'context Context.t;\n payload : (payload, 'payload) payload_parser;\n with_arg : bool;\n }\n\n let declare :\n type a.\n with_arg:bool ->\n string ->\n a Context.t ->\n (payload, 'b, 'payload) Ast_pattern.t ->\n 'b Callback.t ->\n (a, 'payload) t =\n fun ~with_arg name context pattern k ->\n (* Check that there is no collisions between ppx_import and core_type\n extensions *)\n (match context with\n | Context.Ppx_import ->\n Name.Registrar.check_collisions registrar (Context.T Core_type) name\n | Context.Core_type ->\n Name.Registrar.check_collisions registrar (Context.T Ppx_import) name\n | _ -> ());\n Name.Registrar.register ~kind:`Extension registrar (Context.T context) name;\n {\n name = Name.Pattern.make name;\n context;\n payload = Payload_parser (pattern, k);\n with_arg;\n }\n\n let find ts (ext : extension) =\n let { txt = name; loc } = fst ext in\n let name, arg = Name.split_path name in\n match List.filter ts ~f:(fun t -> Name.Pattern.matches t.name name) with\n | [] -> None\n | _ :: _ :: _ as l ->\n Location.raise_errorf ~loc \"Multiple match for extensions: %s\"\n (String.concat ~sep:\", \"\n (List.map l ~f:(fun t -> Name.Pattern.name t.name)))\n | [ t ] ->\n if (not t.with_arg) && Option.is_some arg then\n Location.raise_errorf ~loc\n \"Extension %s doesn't expect a path argument\" name;\n let arg =\n Option.map arg ~f:(fun s ->\n let shift = String.length name + 1 in\n let start = loc.loc_start in\n {\n txt = Longident.parse s;\n loc =\n {\n loc with\n loc_start = { start with pos_cnum = start.pos_cnum + shift };\n };\n })\n in\n Some (t, arg)\nend\n\nmodule Expert = struct\n include Make (struct\n type 'a t = arg:Longident.t Loc.t option -> 'a\n end)\n\n let declare_with_path_arg name ctx patt f =\n declare ~with_arg:true name ctx patt f\n\n let declare name ctx patt f =\n declare ~with_arg:false name ctx patt (fun ~arg:_ -> f)\n\n let convert ts ~loc ext =\n match find ts ext with\n | None -> None\n | Some ({ payload = Payload_parser (pattern, f); _ }, arg) ->\n Some (Ast_pattern.parse pattern loc (snd ext) (f ~arg))\nend\n\nmodule M = Make (struct\n type 'a t =\n ctxt:Expansion_context.Extension.t -> arg:Longident.t Loc.t option -> 'a\nend)\n\ntype 'a expander_result = Simple of 'a | Inline of 'a list\n\nmodule For_context = struct\n type 'a t = ('a, 'a expander_result) M.t\n\n let convert ts ~ctxt ext =\n let loc = Expansion_context.Extension.extension_point_loc ctxt in\n match M.find ts ext with\n | None -> None\n | Some ({ payload = M.Payload_parser (pattern, f); _ }, arg) -> (\n match Ast_pattern.parse pattern loc (snd ext) (f ~ctxt ~arg) with\n | Simple x -> Some x\n | Inline _ -> failwith \"Extension.convert\")\n\n let convert_inline ts ~ctxt ext =\n let loc = Expansion_context.Extension.extension_point_loc ctxt in\n match M.find ts ext with\n | None -> None\n | Some ({ payload = M.Payload_parser (pattern, f); _ }, arg) -> (\n match Ast_pattern.parse pattern loc (snd ext) (f ~ctxt ~arg) with\n | Simple x -> Some [ x ]\n | Inline l -> Some l)\nend\n\ntype t = T : _ For_context.t -> t\n\nlet check_context_for_inline : type a. func:string -> a Context.t -> unit =\n fun ~func ctx ->\n match ctx with\n | Context.Class_field -> ()\n | Context.Class_type_field -> ()\n | Context.Signature_item -> ()\n | Context.Structure_item -> ()\n | context ->\n Printf.ksprintf invalid_arg \"%s: %s can't be inlined\" func\n (Context.desc context)\n\nlet rec filter_by_context :\n type a. a Context.t -> t list -> a For_context.t list =\n fun context expanders ->\n match expanders with\n | [] -> []\n | T t :: rest -> (\n match Context.eq context t.context with\n | Eq -> t :: filter_by_context context rest\n | Ne -> filter_by_context context rest)\n\nlet fail ctx (name, _) =\n if\n not\n (Name.Whitelisted.is_whitelisted ~kind:`Extension name.txt\n || Name.ignore_checks name.txt)\n then\n Name.Registrar.raise_errorf registrar (Context.T ctx)\n \"Extension `%s' was not translated\" name\n\nlet check_unused =\n object\n inherit Ast_traverse.iter as super\n\n method! extension (name, _) =\n Location.raise_errorf ~loc:name.loc\n \"extension not expected here, Ppxlib.Extension needs updating!\"\n\n method! core_type_desc =\n function\n | Ptyp_extension ext -> fail Core_type ext | x -> super#core_type_desc x\n\n method! pattern_desc =\n function\n | Ppat_extension ext -> fail Pattern ext | x -> super#pattern_desc x\n\n method! expression_desc =\n function\n | Pexp_extension ext -> fail Expression ext | x -> super#expression_desc x\n\n method! class_type_desc =\n function\n | Pcty_extension ext -> fail Class_type ext | x -> super#class_type_desc x\n\n method! class_type_field_desc =\n function\n | Pctf_extension ext -> fail Class_type_field ext\n | x -> super#class_type_field_desc x\n\n method! class_expr_desc =\n function\n | Pcl_extension ext -> fail Class_expr ext | x -> super#class_expr_desc x\n\n method! class_field_desc =\n function\n | Pcf_extension ext -> fail Class_field ext\n | x -> super#class_field_desc x\n\n method! module_type_desc =\n function\n | Pmty_extension ext -> fail Module_type ext\n | x -> super#module_type_desc x\n\n method! signature_item_desc =\n function\n | Psig_extension (ext, _) -> fail Signature_item ext\n | x -> super#signature_item_desc x\n\n method! module_expr_desc =\n function\n | Pmod_extension ext -> fail Module_expr ext\n | x -> super#module_expr_desc x\n\n method! structure_item_desc =\n function\n | Pstr_extension (ext, _) -> fail Structure_item ext\n | x -> super#structure_item_desc x\n end\n\nmodule V3 = struct\n type nonrec t = t\n\n let declare name context pattern k =\n let pattern = Ast_pattern.map_result pattern ~f:(fun x -> Simple x) in\n T\n (M.declare ~with_arg:false name context pattern (fun ~ctxt ~arg:_ ->\n k ~ctxt))\n\n let declare_inline name context pattern k =\n check_context_for_inline context ~func:\"Extension.declare_inline\";\n let pattern = Ast_pattern.map_result pattern ~f:(fun x -> Inline x) in\n T\n (M.declare ~with_arg:false name context pattern (fun ~ctxt ~arg:_ ->\n k ~ctxt))\nend\n\nlet declare name context pattern f =\n V3.declare name context pattern\n (Expansion_context.Extension.with_loc_and_path f)\n\nlet declare_inline name context pattern f =\n V3.declare_inline name context pattern\n (Expansion_context.Extension.with_loc_and_path f)\n\nlet declare_with_path_arg name context pattern k =\n let k' = Expansion_context.Extension.with_loc_and_path k in\n let pattern = Ast_pattern.map_result pattern ~f:(fun x -> Simple x) in\n T (M.declare ~with_arg:true name context pattern k')\n\nlet declare_inline_with_path_arg name context pattern k =\n let k' = Expansion_context.Extension.with_loc_and_path k in\n check_context_for_inline context\n ~func:\"Extension.declare_inline_with_path_arg\";\n let pattern = Ast_pattern.map_result pattern ~f:(fun x -> Inline x) in\n T (M.declare ~with_arg:true name context pattern k')\n\nlet __declare_ppx_import name expand =\n (* This pattern is used to unwrap the type declaration from the payload\n assembled by [Context.get_ppx_import_extension] *)\n let pattern = Ast_pattern.(pstr (pstr_type recursive (__ ^:: nil) ^:: nil)) in\n V3.declare name Context.Ppx_import pattern expand\n\nmodule V2 = struct\n type nonrec t = t\n\n let declare = declare\n let declare_inline = declare_inline\nend\n","(*$ open Ppxlib_cinaps_helpers $*)\nopen! Import\nopen Common\nmodule E = Extension\nmodule EC = Extension.Context\nmodule A = Attribute\nmodule AC = Attribute.Context\n\nmodule Rule = struct\n module Attr_group_inline = struct\n type ('a, 'b, 'c) unpacked = {\n attribute : ('b, 'c) Attribute.t;\n expect : bool;\n expand :\n ctxt:Expansion_context.Deriver.t ->\n Asttypes.rec_flag ->\n 'b list ->\n 'c option list ->\n 'a list;\n }\n\n type ('a, 'b) t = T : ('a, 'b, _) unpacked -> ('a, 'b) t\n\n let attr_name (T t) = Attribute.name t.attribute\n\n let split_normal_and_expect l =\n List.partition l ~f:(fun (T t) -> not t.expect)\n end\n\n module Attr_inline = struct\n type ('a, 'b, 'c) unpacked = {\n attribute : ('b, 'c) Attribute.t;\n expect : bool;\n expand : ctxt:Expansion_context.Deriver.t -> 'b -> 'c -> 'a list;\n }\n\n type ('a, 'b) t = T : ('a, 'b, _) unpacked -> ('a, 'b) t\n\n let attr_name (T t) = Attribute.name t.attribute\n\n let split_normal_and_expect l =\n List.partition l ~f:(fun (T t) -> not t.expect)\n end\n\n module Special_function = struct\n type t = {\n name : string;\n ident : Longident.t;\n expand : Parsetree.expression -> Parsetree.expression option;\n }\n end\n\n module Constant_kind = struct\n type t = Float | Integer\n end\n\n module Constant = struct\n type t = {\n suffix : char;\n kind : Constant_kind.t;\n expand : Location.t -> string -> Parsetree.expression;\n }\n end\n\n module Field = struct\n type 'a t =\n | Extension : Extension.t t\n | Special_function : Special_function.t t\n | Constant : Constant.t t\n | Attr_str_type_decl\n : (structure_item, type_declaration) Attr_group_inline.t t\n | Attr_sig_type_decl\n : (signature_item, type_declaration) Attr_group_inline.t t\n | Attr_str_module_type_decl\n : (structure_item, module_type_declaration) Attr_inline.t t\n | Attr_sig_module_type_decl\n : (signature_item, module_type_declaration) Attr_inline.t t\n | Attr_str_type_ext : (structure_item, type_extension) Attr_inline.t t\n | Attr_sig_type_ext : (signature_item, type_extension) Attr_inline.t t\n | Attr_str_exception : (structure_item, type_exception) Attr_inline.t t\n | Attr_sig_exception : (signature_item, type_exception) Attr_inline.t t\n\n type (_, _) equality = Eq : ('a, 'a) equality | Ne : (_, _) equality\n\n let eq : type a b. a t -> b t -> (a, b) equality =\n fun a b ->\n match (a, b) with\n | Extension, Extension -> Eq\n | Special_function, Special_function -> Eq\n | Constant, Constant -> Eq\n | Attr_str_type_decl, Attr_str_type_decl -> Eq\n | Attr_sig_type_decl, Attr_sig_type_decl -> Eq\n | Attr_str_type_ext, Attr_str_type_ext -> Eq\n | Attr_sig_type_ext, Attr_sig_type_ext -> Eq\n | Attr_str_exception, Attr_str_exception -> Eq\n | Attr_sig_exception, Attr_sig_exception -> Eq\n | Attr_str_module_type_decl, Attr_str_module_type_decl -> Eq\n | Attr_sig_module_type_decl, Attr_sig_module_type_decl -> Eq\n | _ -> Ne\n end\n\n type t = T : 'a Field.t * 'a -> t\n\n type ('a, 'b, 'c) attr_group_inline =\n ('b, 'c) Attribute.t ->\n (ctxt:Expansion_context.Deriver.t ->\n Asttypes.rec_flag ->\n 'b list ->\n 'c option list ->\n 'a list) ->\n t\n\n type ('a, 'b, 'c) attr_inline =\n ('b, 'c) Attribute.t ->\n (ctxt:Expansion_context.Deriver.t -> 'b -> 'c -> 'a list) ->\n t\n\n let rec filter : type a. a Field.t -> t list -> a list =\n fun field l ->\n match l with\n | [] -> []\n | T (field', x) :: l -> (\n match Field.eq field field' with\n | Field.Eq -> x :: filter field l\n | Field.Ne -> filter field l)\n\n let extension ext = T (Extension, ext)\n\n let special_function id f =\n T (Special_function, { name = id; ident = Longident.parse id; expand = f })\n\n let constant kind suffix expand = T (Constant, { suffix; kind; expand })\n\n let attr_str_type_decl attribute expand =\n T (Attr_str_type_decl, T { attribute; expand; expect = false })\n\n let attr_sig_type_decl attribute expand =\n T (Attr_sig_type_decl, T { attribute; expand; expect = false })\n\n let attr_str_module_type_decl attribute expand =\n T (Attr_str_module_type_decl, T { attribute; expand; expect = false })\n\n let attr_sig_module_type_decl attribute expand =\n T (Attr_sig_module_type_decl, T { attribute; expand; expect = false })\n\n let attr_str_type_ext attribute expand =\n T (Attr_str_type_ext, T { attribute; expand; expect = false })\n\n let attr_sig_type_ext attribute expand =\n T (Attr_sig_type_ext, T { attribute; expand; expect = false })\n\n let attr_str_exception attribute expand =\n T (Attr_str_exception, T { attribute; expand; expect = false })\n\n let attr_sig_exception attribute expand =\n T (Attr_sig_exception, T { attribute; expand; expect = false })\n\n let attr_str_type_decl_expect attribute expand =\n T (Attr_str_type_decl, T { attribute; expand; expect = true })\n\n let attr_sig_type_decl_expect attribute expand =\n T (Attr_sig_type_decl, T { attribute; expand; expect = true })\n\n let attr_str_module_type_decl_expect attribute expand =\n T (Attr_str_module_type_decl, T { attribute; expand; expect = true })\n\n let attr_sig_module_type_decl_expect attribute expand =\n T (Attr_sig_module_type_decl, T { attribute; expand; expect = true })\n\n let attr_str_type_ext_expect attribute expand =\n T (Attr_str_type_ext, T { attribute; expand; expect = true })\n\n let attr_sig_type_ext_expect attribute expand =\n T (Attr_sig_type_ext, T { attribute; expand; expect = true })\n\n let attr_str_exception_expect attribute expand =\n T (Attr_str_exception, T { attribute; expand; expect = true })\n\n let attr_sig_exception_expect attribute expand =\n T (Attr_sig_exception, T { attribute; expand; expect = true })\nend\n\nmodule Generated_code_hook = struct\n type 'a single_or_many = Single of 'a | Many of 'a list\n\n type t = {\n f : 'a. 'a Extension.Context.t -> Location.t -> 'a single_or_many -> unit;\n }\n\n let nop = { f = (fun _ _ _ -> ()) }\n let replace t context loc x = t.f context loc x\n\n let insert_after t context (loc : Location.t) x =\n match x with\n | Many [] -> ()\n | _ -> t.f context { loc with loc_start = loc.loc_end } x\nend\n\nlet rec map_node_rec context ts super_call loc base_ctxt x =\n let ctxt =\n Expansion_context.Extension.make ~extension_point_loc:loc ~base:base_ctxt ()\n in\n match EC.get_extension context x with\n | None -> super_call base_ctxt x\n | Some (ext, attrs) -> (\n match E.For_context.convert ts ~ctxt ext with\n | None -> super_call base_ctxt x\n | Some x ->\n map_node_rec context ts super_call loc base_ctxt\n (EC.merge_attributes context x attrs))\n\nlet map_node context ts super_call loc base_ctxt x ~hook =\n let ctxt =\n Expansion_context.Extension.make ~extension_point_loc:loc ~base:base_ctxt ()\n in\n match EC.get_extension context x with\n | None -> super_call base_ctxt x\n | Some (ext, attrs) -> (\n match E.For_context.convert ts ~ctxt ext with\n | None -> super_call base_ctxt x\n | Some x ->\n let generated_code =\n map_node_rec context ts super_call loc base_ctxt\n (EC.merge_attributes context x attrs)\n in\n Generated_code_hook.replace hook context loc (Single generated_code);\n generated_code)\n\nlet rec map_nodes context ts super_call get_loc base_ctxt l ~hook\n ~in_generated_code =\n match l with\n | [] -> []\n | x :: l -> (\n match EC.get_extension context x with\n | None ->\n (* These two lets force the evaluation order, so that errors are reported in the\n same order as they appear in the source file. *)\n let x = super_call base_ctxt x in\n let l =\n map_nodes context ts super_call get_loc base_ctxt l ~hook\n ~in_generated_code\n in\n x :: l\n | Some (ext, attrs) -> (\n let extension_point_loc = get_loc x in\n let ctxt =\n Expansion_context.Extension.make ~extension_point_loc\n ~base:base_ctxt ()\n in\n match E.For_context.convert_inline ts ~ctxt ext with\n | None ->\n let x = super_call base_ctxt x in\n let l =\n map_nodes context ts super_call get_loc base_ctxt l ~hook\n ~in_generated_code\n in\n x :: l\n | Some x ->\n assert_no_attributes attrs;\n let generated_code =\n map_nodes context ts super_call get_loc base_ctxt x ~hook\n ~in_generated_code:true\n in\n if not in_generated_code then\n Generated_code_hook.replace hook context extension_point_loc\n (Many generated_code);\n generated_code\n @ map_nodes context ts super_call get_loc base_ctxt l ~hook\n ~in_generated_code))\n\nlet map_nodes = map_nodes ~in_generated_code:false\n\nlet table_of_special_functions special_functions =\n match\n List.map special_functions\n ~f:(fun { Rule.Special_function.ident; expand; _ } -> (ident, expand))\n (* We expect the lookup to fail most of the time, by making the table big (and\n sparse), we make it more likely to fail quickly *)\n |> Hashtbl.of_alist ~size:(max 1024 (List.length special_functions * 2))\n with\n | Ok table -> table\n | Error ident ->\n Printf.ksprintf invalid_arg\n \"Context_free.V1.map_top_down: %s present twice in list of special \\\n functions\"\n (List.find_map_exn special_functions ~f:(fun r ->\n if Poly.equal r.ident ident then Some r.name else None))\n\n(* [get_group attr l] returns the list of the attributes for each\n node in [l].\n If [l] is empty or if none of the nodes in [l] have an attribute attached,\n [get_group] returns [None].\n If [l] is not empty and at least one of the nodes in [l] has an attribue\n attached, [get_group] returns the equivalent of\n [Some (List.map ~f:(Attribute.get attr) l)]. *)\nlet rec get_group attr l =\n match l with\n | [] -> None\n | x :: l -> (\n match (Attribute.get attr x, get_group attr l) with\n | None, None -> None\n | None, Some vals -> Some (None :: vals)\n | Some value, None -> Some (Some value :: List.map l ~f:(fun _ -> None))\n | Some value, Some vals -> Some (Some value :: vals))\n\n(* Same as [List.rev] then [List.concat] but expecting the input to be of length <= 2 *)\nlet rev_concat = function\n | [] -> []\n | [ x ] -> x\n | [ x; y ] -> y @ x\n | l -> List.concat (List.rev l)\n\nlet sort_attr_group_inline l =\n List.sort l ~cmp:(fun a b ->\n String.compare\n (Rule.Attr_group_inline.attr_name a)\n (Rule.Attr_group_inline.attr_name b))\n\nlet sort_attr_inline l =\n List.sort l ~cmp:(fun a b ->\n String.compare\n (Rule.Attr_inline.attr_name a)\n (Rule.Attr_inline.attr_name b))\n\nlet context_free_attribute_modification ~loc =\n Location.raise_errorf ~loc\n \"A context-free rule deleted or added attribues of a str/sig item\"\n\n(* Returns the code generated by attribute handlers. We don't remove these attributes, as\n another pass might interpret them later. For instance both ppx_deriving and\n ppxlib_deriving interprets [@@deriving] attributes.\n\n This complexity is horrible, but in practice we don't care as [attrs] is always a list\n of one element; it only has [@@deriving].\n*)\nlet handle_attr_group_inline attrs rf ~items ~expanded_items ~loc ~base_ctxt =\n List.fold_left attrs ~init:[] ~f:(fun acc (Rule.Attr_group_inline.T group) ->\n match\n ( get_group group.attribute items,\n get_group group.attribute expanded_items )\n with\n | None, None -> acc\n | None, Some _ | Some _, None -> context_free_attribute_modification ~loc\n | Some values, Some _ ->\n let ctxt =\n Expansion_context.Deriver.make ~derived_item_loc:loc\n ~inline:group.expect ~base:base_ctxt ()\n in\n let expect_items = group.expand ~ctxt rf expanded_items values in\n expect_items :: acc)\n\nlet handle_attr_inline attrs ~item ~expanded_item ~loc ~base_ctxt =\n List.fold_left attrs ~init:[] ~f:(fun acc (Rule.Attr_inline.T a) ->\n match\n (Attribute.get a.attribute item, Attribute.get a.attribute expanded_item)\n with\n | None, None -> acc\n | None, Some _ | Some _, None -> context_free_attribute_modification ~loc\n | Some value, Some _ ->\n let ctxt =\n Expansion_context.Deriver.make ~derived_item_loc:loc\n ~inline:a.expect ~base:base_ctxt ()\n in\n let expect_items = a.expand ~ctxt expanded_item value in\n expect_items :: acc)\n\nmodule Expect_mismatch_handler = struct\n type t = {\n f : 'a. 'a Attribute.Floating.Context.t -> Location.t -> 'a list -> unit;\n }\n\n let nop = { f = (fun _ _ _ -> ()) }\nend\n\nclass map_top_down ?(expect_mismatch_handler = Expect_mismatch_handler.nop)\n ?(generated_code_hook = Generated_code_hook.nop) rules =\n let hook = generated_code_hook in\n\n let special_functions =\n Rule.filter Special_function rules |> table_of_special_functions\n in\n let constants =\n Rule.filter Constant rules\n |> List.map ~f:(fun (c : Rule.Constant.t) -> ((c.suffix, c.kind), c.expand))\n |> Hashtbl.of_alist_exn\n in\n let extensions = Rule.filter Extension rules in\n let class_expr = E.filter_by_context EC.class_expr extensions\n and class_field = E.filter_by_context EC.class_field extensions\n and class_type = E.filter_by_context EC.class_type extensions\n and class_type_field = E.filter_by_context EC.class_type_field extensions\n and core_type = E.filter_by_context EC.core_type extensions\n and expression = E.filter_by_context EC.expression extensions\n and module_expr = E.filter_by_context EC.module_expr extensions\n and module_type = E.filter_by_context EC.module_type extensions\n and pattern = E.filter_by_context EC.pattern extensions\n and signature_item = E.filter_by_context EC.signature_item extensions\n and structure_item = E.filter_by_context EC.structure_item extensions\n and ppx_import = E.filter_by_context EC.Ppx_import extensions in\n\n let attr_str_type_decls, attr_str_type_decls_expect =\n Rule.filter Attr_str_type_decl rules\n |> sort_attr_group_inline |> Rule.Attr_group_inline.split_normal_and_expect\n in\n let attr_sig_type_decls, attr_sig_type_decls_expect =\n Rule.filter Attr_sig_type_decl rules\n |> sort_attr_group_inline |> Rule.Attr_group_inline.split_normal_and_expect\n in\n\n let attr_str_module_type_decls, attr_str_module_type_decls_expect =\n Rule.filter Attr_str_module_type_decl rules\n |> sort_attr_inline |> Rule.Attr_inline.split_normal_and_expect\n in\n let attr_sig_module_type_decls, attr_sig_module_type_decls_expect =\n Rule.filter Attr_sig_module_type_decl rules\n |> sort_attr_inline |> Rule.Attr_inline.split_normal_and_expect\n in\n\n let attr_str_type_exts, attr_str_type_exts_expect =\n Rule.filter Attr_str_type_ext rules\n |> sort_attr_inline |> Rule.Attr_inline.split_normal_and_expect\n in\n let attr_sig_type_exts, attr_sig_type_exts_expect =\n Rule.filter Attr_sig_type_ext rules\n |> sort_attr_inline |> Rule.Attr_inline.split_normal_and_expect\n in\n\n let attr_str_exceptions, attr_str_exceptions_expect =\n Rule.filter Attr_str_exception rules\n |> sort_attr_inline |> Rule.Attr_inline.split_normal_and_expect\n in\n let attr_sig_exceptions, attr_sig_exceptions_expect =\n Rule.filter Attr_sig_exception rules\n |> sort_attr_inline |> Rule.Attr_inline.split_normal_and_expect\n in\n\n let map_node = map_node ~hook in\n let map_nodes = map_nodes ~hook in\n\n object (self)\n inherit Ast_traverse.map_with_expansion_context as super\n\n (* No point recursing into every location *)\n method! location _ x = x\n\n method! core_type base_ctxt x =\n map_node EC.core_type core_type super#core_type x.ptyp_loc base_ctxt x\n\n method! pattern base_ctxt x =\n map_node EC.pattern pattern super#pattern x.ppat_loc base_ctxt x\n\n method! expression base_ctxt e =\n let e =\n match e.pexp_desc with\n | Pexp_extension _ ->\n map_node EC.expression expression\n (fun _ e -> e)\n e.pexp_loc base_ctxt e\n | _ -> e\n in\n let expand_constant kind char text =\n match Hashtbl.find_opt constants (char, kind) with\n | None -> super#expression base_ctxt e\n | Some expand -> self#expression base_ctxt (expand e.pexp_loc text)\n in\n match e.pexp_desc with\n | Pexp_apply (({ pexp_desc = Pexp_ident id; _ } as func), args) -> (\n match Hashtbl.find_opt special_functions id.txt with\n | None ->\n self#pexp_apply_without_traversing_function base_ctxt e func args\n | Some pattern -> (\n match pattern e with\n | None ->\n self#pexp_apply_without_traversing_function base_ctxt e func\n args\n | Some e -> self#expression base_ctxt e))\n | Pexp_ident id -> (\n match Hashtbl.find_opt special_functions id.txt with\n | None -> super#expression base_ctxt e\n | Some pattern -> (\n match pattern e with\n | None -> super#expression base_ctxt e\n | Some e -> self#expression base_ctxt e))\n | Pexp_constant (Pconst_integer (s, Some c)) ->\n expand_constant Integer c s\n | Pexp_constant (Pconst_float (s, Some c)) -> expand_constant Float c s\n | _ -> super#expression base_ctxt e\n\n (* Pre-conditions:\n - e.pexp_desc = Pexp_apply(func, args)\n - func.pexp_desc = Pexp_ident _\n *)\n method private pexp_apply_without_traversing_function base_ctxt e func args\n =\n let { pexp_desc = _; pexp_loc; pexp_attributes; pexp_loc_stack } = e in\n let func =\n let { pexp_desc; pexp_loc; pexp_attributes; pexp_loc_stack } = func in\n let pexp_attributes = self#attributes base_ctxt pexp_attributes in\n {\n pexp_desc;\n pexp_loc (* location doesn't need to be traversed *);\n pexp_attributes;\n pexp_loc_stack;\n }\n in\n let args =\n List.map args ~f:(fun (lab, exp) ->\n (lab, self#expression base_ctxt exp))\n in\n let pexp_attributes = self#attributes base_ctxt pexp_attributes in\n {\n pexp_loc;\n pexp_attributes;\n pexp_desc = Pexp_apply (func, args);\n pexp_loc_stack;\n }\n\n method! class_type base_ctxt x =\n map_node EC.class_type class_type super#class_type x.pcty_loc base_ctxt x\n\n method! class_type_field base_ctxt x =\n map_node EC.class_type_field class_type_field super#class_type_field\n x.pctf_loc base_ctxt x\n\n method! class_expr base_ctxt x =\n map_node EC.class_expr class_expr super#class_expr x.pcl_loc base_ctxt x\n\n method! class_field base_ctxt x =\n map_node EC.class_field class_field super#class_field x.pcf_loc base_ctxt\n x\n\n method! module_type base_ctxt x =\n map_node EC.module_type module_type super#module_type x.pmty_loc base_ctxt\n x\n\n method! module_expr base_ctxt x =\n map_node EC.module_expr module_expr super#module_expr x.pmod_loc base_ctxt\n x\n\n method! structure_item base_ctxt x =\n map_node EC.structure_item structure_item super#structure_item x.pstr_loc\n base_ctxt x\n\n method! signature_item base_ctxt x =\n map_node EC.signature_item signature_item super#signature_item x.psig_loc\n base_ctxt x\n\n method! class_structure base_ctxt { pcstr_self; pcstr_fields } =\n let pcstr_self = self#pattern base_ctxt pcstr_self in\n let pcstr_fields =\n map_nodes EC.class_field class_field super#class_field\n (fun x -> x.pcf_loc)\n base_ctxt pcstr_fields\n in\n { pcstr_self; pcstr_fields }\n\n method! type_declaration base_ctxt x =\n map_node EC.Ppx_import ppx_import super#type_declaration x.ptype_loc\n base_ctxt x\n\n method! class_signature base_ctxt { pcsig_self; pcsig_fields } =\n let pcsig_self = self#core_type base_ctxt pcsig_self in\n let pcsig_fields =\n map_nodes EC.class_type_field class_type_field super#class_type_field\n (fun x -> x.pctf_loc)\n base_ctxt pcsig_fields\n in\n { pcsig_self; pcsig_fields }\n\n (* TODO: try to factorize #structure and #signature without meta-programming *)\n (*$*)\n method! structure base_ctxt st =\n let rec with_extra_items item ~extra_items ~expect_items ~rest\n ~in_generated_code =\n let extra_items =\n loop (rev_concat extra_items) ~in_generated_code:true\n in\n if not in_generated_code then\n Generated_code_hook.insert_after hook Structure_item item.pstr_loc\n (Many extra_items);\n let original_rest = rest in\n let rest = loop rest ~in_generated_code in\n (match expect_items with\n | [] -> ()\n | _ ->\n let expected = rev_concat expect_items in\n let pos = item.pstr_loc.loc_end in\n Code_matcher.match_structure original_rest ~pos ~expected\n ~mismatch_handler:(fun loc repl ->\n expect_mismatch_handler.f Structure_item loc repl));\n item :: (extra_items @ rest)\n and loop st ~in_generated_code =\n match st with\n | [] -> []\n | item :: rest -> (\n let loc = item.pstr_loc in\n match item.pstr_desc with\n | Pstr_extension (ext, attrs) -> (\n let extension_point_loc = item.pstr_loc in\n let ctxt =\n Expansion_context.Extension.make ~extension_point_loc\n ~base:base_ctxt ()\n in\n match E.For_context.convert_inline structure_item ~ctxt ext with\n | None ->\n let item = super#structure_item base_ctxt item in\n let rest = self#structure base_ctxt rest in\n item :: rest\n | Some items ->\n assert_no_attributes attrs;\n let items = loop items ~in_generated_code:true in\n if not in_generated_code then\n Generated_code_hook.replace hook Structure_item\n item.pstr_loc (Many items);\n items @ loop rest ~in_generated_code)\n | _ -> (\n let expanded_item = super#structure_item base_ctxt item in\n match (item.pstr_desc, expanded_item.pstr_desc) with\n | Pstr_type (rf, tds), Pstr_type (exp_rf, exp_tds) ->\n (* No context-free rule can rewrite rec flags atm, this\n assert acts as a failsafe in case it ever changes *)\n assert (Poly.(rf = exp_rf));\n let extra_items =\n handle_attr_group_inline attr_str_type_decls rf ~items:tds\n ~expanded_items:exp_tds ~loc ~base_ctxt\n in\n let expect_items =\n handle_attr_group_inline attr_str_type_decls_expect rf\n ~items:tds ~expanded_items:exp_tds ~loc ~base_ctxt\n in\n with_extra_items expanded_item ~extra_items ~expect_items\n ~rest ~in_generated_code\n | Pstr_modtype mtd, Pstr_modtype exp_mtd ->\n let extra_items =\n handle_attr_inline attr_str_module_type_decls ~item:mtd\n ~expanded_item:exp_mtd ~loc ~base_ctxt\n in\n let expect_items =\n handle_attr_inline attr_str_module_type_decls_expect\n ~item:mtd ~expanded_item:exp_mtd ~loc ~base_ctxt\n in\n with_extra_items expanded_item ~extra_items ~expect_items\n ~rest ~in_generated_code\n | Pstr_typext te, Pstr_typext exp_te ->\n let extra_items =\n handle_attr_inline attr_str_type_exts ~item:te\n ~expanded_item:exp_te ~loc ~base_ctxt\n in\n let expect_items =\n handle_attr_inline attr_str_type_exts_expect ~item:te\n ~expanded_item:exp_te ~loc ~base_ctxt\n in\n with_extra_items expanded_item ~extra_items ~expect_items\n ~rest ~in_generated_code\n | Pstr_exception ec, Pstr_exception exp_ec ->\n let extra_items =\n handle_attr_inline attr_str_exceptions ~item:ec\n ~expanded_item:exp_ec ~loc ~base_ctxt\n in\n let expect_items =\n handle_attr_inline attr_str_exceptions_expect ~item:ec\n ~expanded_item:exp_ec ~loc ~base_ctxt\n in\n with_extra_items expanded_item ~extra_items ~expect_items\n ~rest ~in_generated_code\n | _, _ ->\n let rest = self#structure base_ctxt rest in\n expanded_item :: rest))\n in\n loop st ~in_generated_code:false\n\n (*$ str_to_sig _last_text_block *)\n method! signature base_ctxt sg =\n let rec with_extra_items item ~extra_items ~expect_items ~rest\n ~in_generated_code =\n let extra_items =\n loop (rev_concat extra_items) ~in_generated_code:true\n in\n if not in_generated_code then\n Generated_code_hook.insert_after hook Signature_item item.psig_loc\n (Many extra_items);\n let original_rest = rest in\n let rest = loop rest ~in_generated_code in\n (match expect_items with\n | [] -> ()\n | _ ->\n let expected = rev_concat expect_items in\n let pos = item.psig_loc.loc_end in\n Code_matcher.match_signature original_rest ~pos ~expected\n ~mismatch_handler:(fun loc repl ->\n expect_mismatch_handler.f Signature_item loc repl));\n item :: (extra_items @ rest)\n and loop sg ~in_generated_code =\n match sg with\n | [] -> []\n | item :: rest -> (\n let loc = item.psig_loc in\n match item.psig_desc with\n | Psig_extension (ext, attrs) -> (\n let extension_point_loc = item.psig_loc in\n let ctxt =\n Expansion_context.Extension.make ~extension_point_loc\n ~base:base_ctxt ()\n in\n match E.For_context.convert_inline signature_item ~ctxt ext with\n | None ->\n let item = super#signature_item base_ctxt item in\n let rest = self#signature base_ctxt rest in\n item :: rest\n | Some items ->\n assert_no_attributes attrs;\n let items = loop items ~in_generated_code:true in\n if not in_generated_code then\n Generated_code_hook.replace hook Signature_item\n item.psig_loc (Many items);\n items @ loop rest ~in_generated_code)\n | _ -> (\n let expanded_item = super#signature_item base_ctxt item in\n match (item.psig_desc, expanded_item.psig_desc) with\n | Psig_type (rf, tds), Psig_type (exp_rf, exp_tds) ->\n (* No context-free rule can rewrite rec flags atm, this\n assert acts as a failsafe in case it ever changes *)\n assert (Poly.(rf = exp_rf));\n let extra_items =\n handle_attr_group_inline attr_sig_type_decls rf ~items:tds\n ~expanded_items:exp_tds ~loc ~base_ctxt\n in\n let expect_items =\n handle_attr_group_inline attr_sig_type_decls_expect rf\n ~items:tds ~expanded_items:exp_tds ~loc ~base_ctxt\n in\n with_extra_items expanded_item ~extra_items ~expect_items\n ~rest ~in_generated_code\n | Psig_modtype mtd, Psig_modtype exp_mtd ->\n let extra_items =\n handle_attr_inline attr_sig_module_type_decls ~item:mtd\n ~expanded_item:exp_mtd ~loc ~base_ctxt\n in\n let expect_items =\n handle_attr_inline attr_sig_module_type_decls_expect\n ~item:mtd ~expanded_item:exp_mtd ~loc ~base_ctxt\n in\n with_extra_items expanded_item ~extra_items ~expect_items\n ~rest ~in_generated_code\n | Psig_typext te, Psig_typext exp_te ->\n let extra_items =\n handle_attr_inline attr_sig_type_exts ~item:te\n ~expanded_item:exp_te ~loc ~base_ctxt\n in\n let expect_items =\n handle_attr_inline attr_sig_type_exts_expect ~item:te\n ~expanded_item:exp_te ~loc ~base_ctxt\n in\n with_extra_items expanded_item ~extra_items ~expect_items\n ~rest ~in_generated_code\n | Psig_exception ec, Psig_exception exp_ec ->\n let extra_items =\n handle_attr_inline attr_sig_exceptions ~item:ec\n ~expanded_item:exp_ec ~loc ~base_ctxt\n in\n let expect_items =\n handle_attr_inline attr_sig_exceptions_expect ~item:ec\n ~expanded_item:exp_ec ~loc ~base_ctxt\n in\n with_extra_items expanded_item ~extra_items ~expect_items\n ~rest ~in_generated_code\n | _, _ ->\n let rest = self#signature base_ctxt rest in\n expanded_item :: rest))\n in\n loop sg ~in_generated_code:false\n\n (*$*)\n end\n","(*$ open Ppxlib_cinaps_helpers $*)\nopen Import\nopen Utils\nmodule Arg = Caml.Arg\n\nlet exe_name = Caml.Filename.basename Caml.Sys.executable_name\nlet args = ref []\nlet add_arg key spec ~doc = args := (key, spec, doc) :: !args\nlet loc_fname = ref None\nlet perform_checks = ref Options.perform_checks\nlet perform_checks_on_extensions = ref Options.perform_checks_on_extensions\nlet perform_locations_check = ref Options.perform_locations_check\nlet debug_attribute_drop = ref false\nlet apply_list = ref None\nlet preprocessor = ref None\nlet no_merge = ref false\nlet request_print_passes = ref false\nlet request_print_transformations = ref false\nlet use_color = ref true\nlet diff_command = ref Options.diff_command\nlet pretty = ref false\nlet styler = ref None\nlet output_metadata_filename = ref None\nlet corrected_suffix = ref \".ppx-corrected\"\n\nmodule Lint_error = struct\n type t = Location.t * string\n\n let of_string loc s = (loc, s)\nend\n\nmodule Cookies = struct\n type t = T\n\n let given_through_cli = ref []\n\n let get T name pattern =\n Option.map (Astlib.Ast_metadata.get_cookie name) ~f:(fun e ->\n let e = Selected_ast.of_ocaml Expression e in\n Ast_pattern.parse pattern e.pexp_loc e Fn.id)\n\n let set T name expr =\n Astlib.Ast_metadata.set_cookie name (Selected_ast.to_ocaml Expression expr)\n\n let handlers = ref []\n let add_handler f = handlers := !handlers @ [ f ]\n\n let add_simple_handler name pattern ~f =\n add_handler (fun T -> f (get T name pattern))\n\n let acknowledge_cookies T = List.iter !handlers ~f:(fun f -> f T)\n let post_handlers = ref []\n let add_post_handler f = post_handlers := !post_handlers @ [ f ]\n let call_post_handlers T = List.iter !post_handlers ~f:(fun f -> f T)\nend\n\nmodule Instrument = struct\n type pos = Before | After\n\n type t = {\n transformation :\n Expansion_context.Base.t -> Parsetree.structure -> Parsetree.structure;\n position : pos;\n }\n\n module V2 = struct\n let make transformation ~position = { transformation; position }\n end\n\n let make transformation ~position =\n let transformation _ st = transformation st in\n V2.make transformation ~position\nend\n\nmodule Transform = struct\n type t = {\n name : string;\n aliases : string list;\n impl :\n (Expansion_context.Base.t -> Parsetree.structure -> Parsetree.structure)\n option;\n intf :\n (Expansion_context.Base.t -> Parsetree.signature -> Parsetree.signature)\n option;\n lint_impl :\n (Expansion_context.Base.t -> Parsetree.structure -> Lint_error.t list)\n option;\n lint_intf :\n (Expansion_context.Base.t -> Parsetree.signature -> Lint_error.t list)\n option;\n preprocess_impl :\n (Expansion_context.Base.t -> Parsetree.structure -> Parsetree.structure)\n option;\n preprocess_intf :\n (Expansion_context.Base.t -> Parsetree.signature -> Parsetree.signature)\n option;\n enclose_impl :\n (Expansion_context.Base.t ->\n Location.t option ->\n Parsetree.structure * Parsetree.structure)\n option;\n enclose_intf :\n (Expansion_context.Base.t ->\n Location.t option ->\n Parsetree.signature * Parsetree.signature)\n option;\n instrument : Instrument.t option;\n rules : Context_free.Rule.t list;\n registered_at : Caller_id.t;\n }\n\n let has_name t name =\n String.equal name t.name || List.exists ~f:(String.equal name) t.aliases\n\n let all : t list ref = ref []\n\n let print_caller_id oc (caller_id : Caller_id.t) =\n match caller_id with\n | None -> output_string oc \"\"\n | Some loc -> Printf.fprintf oc \"%s:%d\" loc.filename loc.line_number\n\n let register ?(extensions = []) ?(rules = []) ?enclose_impl ?enclose_intf\n ?impl ?intf ?lint_impl ?lint_intf ?preprocess_impl ?preprocess_intf\n ?instrument ?(aliases = []) name =\n let rules = List.map extensions ~f:Context_free.Rule.extension @ rules in\n let caller_id = Caller_id.get ~skip:[ Caml.__FILE__ ] in\n (match List.filter !all ~f:(fun ct -> has_name ct name) with\n | [] -> ()\n | ct :: _ ->\n Printf.eprintf \"Warning: code transformation %s registered twice.\\n\"\n name;\n Printf.eprintf \" - first time was at %a\\n\" print_caller_id\n ct.registered_at;\n Printf.eprintf \" - second time is at %a\\n\" print_caller_id caller_id);\n let ct =\n {\n name;\n aliases;\n rules;\n enclose_impl;\n enclose_intf;\n impl;\n intf;\n lint_impl;\n preprocess_impl;\n preprocess_intf;\n lint_intf;\n instrument;\n registered_at = caller_id;\n }\n in\n all := ct :: !all\n\n let rec last prev l = match l with [] -> prev | x :: l -> last x l\n\n let loc_of_list ~get_loc l =\n match l with\n | [] -> None\n | x :: l ->\n let first : Location.t = get_loc x in\n let last = get_loc (last x l) in\n Some { first with loc_end = last.loc_end }\n\n let merge_into_generic_mappers t ~hook ~expect_mismatch_handler ~tool_name\n ~input_name =\n let { rules; enclose_impl; enclose_intf; impl; intf; _ } = t in\n let map =\n new Context_free.map_top_down\n rules ~generated_code_hook:hook ~expect_mismatch_handler\n in\n let gen_header_and_footer context whole_loc f =\n let header, footer = f whole_loc in\n (match whole_loc with\n | Some (loc : Location.t) -> (\n let loc_header = { loc with loc_end = loc.loc_start } in\n let loc_footer = { loc with loc_start = loc.loc_end } in\n (match header with\n | [] -> ()\n | _ -> hook.f context loc_header (Many header));\n match footer with\n | [] -> ()\n | _ -> hook.f context loc_footer (Many footer))\n | None -> (\n match header @ footer with\n | [] -> ()\n | l ->\n let pos =\n {\n Lexing.pos_fname = \"\";\n pos_lnum = 1;\n pos_bol = 0;\n pos_cnum = 0;\n }\n in\n let loc =\n { Location.loc_start = pos; loc_end = pos; loc_ghost = false }\n in\n hook.f context loc (Many l)));\n (header, footer)\n in\n let input_name =\n match input_name with Some input_name -> input_name | None -> \"_none_\"\n in\n let map_impl ctxt st_with_attrs =\n let st =\n let attrs, st =\n List.split_while st_with_attrs ~f:(function\n | { pstr_desc = Pstr_attribute _; _ } -> true\n | _ -> false)\n in\n let file_path = File_path.get_default_path_str st in\n let base_ctxt =\n Expansion_context.Base.top_level ~tool_name ~file_path ~input_name\n in\n let header, footer =\n match enclose_impl with\n | None -> ([], [])\n | Some f ->\n let whole_loc =\n loc_of_list st ~get_loc:(fun st -> st.Parsetree.pstr_loc)\n in\n gen_header_and_footer Structure_item whole_loc (f base_ctxt)\n in\n let attrs = map#structure base_ctxt attrs in\n let st = map#structure base_ctxt st in\n List.concat [ attrs; header; st; footer ]\n in\n match impl with None -> st | Some f -> f ctxt st\n in\n let map_intf ctxt sg_with_attrs =\n let sg =\n let attrs, sg =\n List.split_while sg_with_attrs ~f:(function\n | { psig_desc = Psig_attribute _; _ } -> true\n | _ -> false)\n in\n let file_path = File_path.get_default_path_sig sg in\n let base_ctxt =\n Expansion_context.Base.top_level ~tool_name ~file_path ~input_name\n in\n let header, footer =\n match enclose_intf with\n | None -> ([], [])\n | Some f ->\n let whole_loc =\n loc_of_list sg ~get_loc:(fun sg -> sg.Parsetree.psig_loc)\n in\n gen_header_and_footer Signature_item whole_loc (f base_ctxt)\n in\n let attrs = map#signature base_ctxt attrs in\n let sg = map#signature base_ctxt sg in\n List.concat [ attrs; header; sg; footer ]\n in\n match intf with None -> sg | Some f -> f ctxt sg\n in\n { t with impl = Some map_impl; intf = Some map_intf }\n\n let builtin_of_context_free_rewriters ~hook ~rules ~enclose_impl ~enclose_intf\n ~input_name =\n merge_into_generic_mappers ~hook ~input_name\n {\n name = \"\";\n aliases = [];\n impl = None;\n intf = None;\n lint_impl = None;\n lint_intf = None;\n preprocess_impl = None;\n preprocess_intf = None;\n enclose_impl;\n enclose_intf;\n instrument = None;\n rules;\n registered_at = Caller_id.get ~skip:[];\n }\n\n let partition_transformations ts =\n let before_instrs, after_instrs, rest =\n List.fold_left ts ~init:([], [], []) ~f:(fun (bef_i, aft_i, rest) t ->\n let reduced_t =\n {\n t with\n lint_impl = None;\n lint_intf = None;\n preprocess_impl = None;\n preprocess_intf = None;\n }\n in\n let f instr =\n (instr.Instrument.position, instr.Instrument.transformation)\n in\n match Option.map t.instrument ~f with\n | Some (Before, transf) ->\n ( { reduced_t with impl = Some transf; rules = [] } :: bef_i,\n aft_i,\n reduced_t :: rest )\n | Some (After, transf) ->\n ( bef_i,\n { reduced_t with impl = Some transf; rules = [] } :: aft_i,\n reduced_t :: rest )\n | None -> (bef_i, aft_i, reduced_t :: rest))\n in\n ( `Linters\n (List.filter_map ts ~f:(fun t ->\n if Option.is_some t.lint_impl || Option.is_some t.lint_intf then\n Some\n {\n name = Printf.sprintf \"\" t.name;\n aliases = [];\n impl = None;\n intf = None;\n lint_impl = t.lint_impl;\n lint_intf = t.lint_intf;\n enclose_impl = None;\n enclose_intf = None;\n preprocess_impl = None;\n preprocess_intf = None;\n instrument = None;\n rules = [];\n registered_at = t.registered_at;\n }\n else None)),\n `Preprocess\n (List.filter_map ts ~f:(fun t ->\n if\n Option.is_some t.preprocess_impl\n || Option.is_some t.preprocess_intf\n then\n Some\n {\n name = Printf.sprintf \"\" t.name;\n aliases = [];\n impl = t.preprocess_impl;\n intf = t.preprocess_intf;\n lint_impl = None;\n lint_intf = None;\n enclose_impl = None;\n enclose_intf = None;\n preprocess_impl = None;\n preprocess_intf = None;\n instrument = None;\n rules = [];\n registered_at = t.registered_at;\n }\n else None)),\n `Before_instrs before_instrs,\n `After_instrs after_instrs,\n `Rest rest )\nend\n\nmodule V2 = struct\n let register_transformation = Transform.register\n\n let register_transformation_using_ocaml_current_ast ?impl ?intf ?aliases name\n =\n let impl =\n Option.map impl ~f:(Ppxlib_ast.Selected_ast.of_ocaml_mapper Structure)\n in\n let intf =\n Option.map intf ~f:(Ppxlib_ast.Selected_ast.of_ocaml_mapper Signature)\n in\n register_transformation ?impl ?intf ?aliases name\nend\n\nlet add_ctxt_arg (f : 'a -> 'b) : Expansion_context.Base.t -> 'a -> 'b =\n fun _ x -> f x\n\nlet register_transformation ?extensions ?rules ?enclose_impl ?enclose_intf ?impl\n ?intf ?lint_impl ?lint_intf ?preprocess_impl ?preprocess_intf =\n let impl = Option.map impl ~f:add_ctxt_arg in\n let intf = Option.map intf ~f:add_ctxt_arg in\n let preprocess_impl = Option.map preprocess_impl ~f:add_ctxt_arg in\n let preprocess_intf = Option.map preprocess_intf ~f:add_ctxt_arg in\n let lint_impl = Option.map lint_impl ~f:add_ctxt_arg in\n let lint_intf = Option.map lint_intf ~f:add_ctxt_arg in\n let enclose_impl = Option.map enclose_impl ~f:add_ctxt_arg in\n let enclose_intf = Option.map enclose_intf ~f:add_ctxt_arg in\n V2.register_transformation ?extensions ?rules ?enclose_impl ?enclose_intf\n ?impl ?intf ?lint_impl ?lint_intf ?preprocess_impl ?preprocess_intf\n\nlet register_code_transformation ~name ?(aliases = []) ~impl ~intf =\n register_transformation name ~impl ~intf ~aliases\n [@@warning \"-16\"]\n(* This function triggers a warning 16 as of ocaml 4.12 *)\n\nlet register_transformation_using_ocaml_current_ast ?impl ?intf =\n let impl = Option.map impl ~f:add_ctxt_arg in\n let intf = Option.map intf ~f:add_ctxt_arg in\n V2.register_transformation_using_ocaml_current_ast ?impl ?intf\n\nlet debug_dropped_attribute name ~old_dropped ~new_dropped =\n let print_diff what a b =\n let diff =\n List.filter a ~f:(fun (name : _ Loc.t) ->\n not\n (List.exists b ~f:(fun (name' : _ Location.loc) ->\n name.txt == name'.txt)))\n in\n if not (List.is_empty diff) then (\n Printf.eprintf \"The following attributes %s after applying %s:\\n\" what\n name;\n List.iter diff ~f:(fun { Location.txt; loc } ->\n Caml.Format.eprintf \"- %a: %s\\n\" Location.print loc txt);\n Caml.Format.eprintf \"@.\")\n in\n print_diff \"disappeared\" new_dropped old_dropped;\n print_diff \"reappeared\" old_dropped new_dropped\n\nlet get_whole_ast_passes ~hook ~expect_mismatch_handler ~tool_name ~input_name =\n let cts =\n match !apply_list with\n | None -> List.rev !Transform.all\n | Some names ->\n List.map names ~f:(fun name ->\n List.find !Transform.all ~f:(fun (ct : Transform.t) ->\n Transform.has_name ct name))\n in\n let ( `Linters linters,\n `Preprocess preprocess,\n `Before_instrs before_instrs,\n `After_instrs after_instrs,\n `Rest cts ) =\n Transform.partition_transformations cts\n in\n (* Allow only one preprocessor to assure deterministic order *)\n (if List.length preprocess > 1 then\n let pp =\n String.concat ~sep:\", \" (List.map preprocess ~f:(fun t -> t.name))\n in\n let err =\n Printf.sprintf \"At most one preprocessor is allowed, while got: %s\" pp\n in\n failwith err);\n let make_generic transforms =\n if !no_merge then\n List.map transforms\n ~f:\n (Transform.merge_into_generic_mappers ~hook ~tool_name\n ~expect_mismatch_handler ~input_name)\n else\n (let get_enclosers ~f =\n List.filter_map transforms ~f:(fun (ct : Transform.t) ->\n match f ct with None -> None | Some x -> Some (ct.name, x))\n (* Sort them to ensure deterministic ordering *)\n |> List.sort ~cmp:(fun (a, _) (b, _) -> String.compare a b)\n |> List.map ~f:snd\n in\n\n let rules =\n List.map transforms ~f:(fun (ct : Transform.t) -> ct.rules)\n |> List.concat\n and impl_enclosers = get_enclosers ~f:(fun ct -> ct.enclose_impl)\n and intf_enclosers = get_enclosers ~f:(fun ct -> ct.enclose_intf) in\n match (rules, impl_enclosers, intf_enclosers) with\n | [], [], [] -> transforms\n | _ ->\n let merge_encloser = function\n | [] -> None\n | enclosers ->\n Some\n (fun ctxt loc ->\n let headers, footers =\n List.map enclosers ~f:(fun f -> f ctxt loc) |> List.split\n in\n let headers = List.concat headers in\n let footers = List.concat (List.rev footers) in\n (headers, footers))\n in\n Transform.builtin_of_context_free_rewriters ~rules ~hook\n ~expect_mismatch_handler\n ~enclose_impl:(merge_encloser impl_enclosers)\n ~enclose_intf:(merge_encloser intf_enclosers)\n ~tool_name ~input_name\n :: transforms)\n |> List.filter ~f:(fun (ct : Transform.t) ->\n match (ct.impl, ct.intf) with None, None -> false | _ -> true)\n in\n linters @ preprocess @ before_instrs @ make_generic cts @ after_instrs\n\nlet apply_transforms (type t) ~tool_name ~file_path ~field ~lint_field\n ~dropped_so_far ~hook ~expect_mismatch_handler ~input_name ~f_exception\n ~embed_errors x =\n let exception\n Wrapper of t list * label loc list * (location * label) list * exn\n in\n let cts =\n get_whole_ast_passes ~tool_name ~hook ~expect_mismatch_handler ~input_name\n in\n let return (x, _dropped, lint_errors) =\n ( x,\n List.map lint_errors ~f:(fun (loc, s) ->\n Common.attribute_of_warning loc s) )\n in\n try\n let acc =\n List.fold_left cts ~init:(x, [], [])\n ~f:(fun (x, dropped, (lint_errors : _ list)) (ct : Transform.t) ->\n let input_name =\n match input_name with\n | Some input_name -> input_name\n | None -> \"_none_\"\n in\n let ctxt =\n Expansion_context.Base.top_level ~tool_name ~file_path ~input_name\n in\n let lint_errors =\n match lint_field ct with\n | None -> lint_errors\n | Some f -> (\n try lint_errors @ f ctxt x\n with exn when embed_errors ->\n raise @@ Wrapper (x, dropped, lint_errors, exn))\n in\n match field ct with\n | None -> (x, dropped, lint_errors)\n | Some f ->\n let x =\n try f ctxt x\n with exn when embed_errors ->\n raise @@ Wrapper (x, dropped, lint_errors, exn)\n in\n let dropped =\n if !debug_attribute_drop then (\n let new_dropped = dropped_so_far x in\n debug_dropped_attribute ct.name ~old_dropped:dropped\n ~new_dropped;\n new_dropped)\n else []\n in\n (x, dropped, lint_errors))\n in\n Ok (return acc)\n with Wrapper (x, dropped, lint_errors, exn) ->\n Error (return (f_exception exn :: x, dropped, lint_errors))\n\n(*$*)\n\nlet error_to_str_extension error =\n let loc = Location.none in\n let ext = Location.Error.to_extension error in\n Ast_builder.Default.pstr_extension ~loc ext []\n\nlet exn_to_str_extension exn =\n match Location.Error.of_exn exn with\n | None -> raise exn\n | Some error -> error_to_str_extension error\n\n(*$ str_to_sig _last_text_block *)\n\nlet error_to_sig_extension error =\n let loc = Location.none in\n let ext = Location.Error.to_extension error in\n Ast_builder.Default.psig_extension ~loc ext []\n\nlet exn_to_sig_extension exn =\n match Location.Error.of_exn exn with\n | None -> raise exn\n | Some error -> error_to_sig_extension error\n\n(*$*)\n\nlet error_to_extension error ~(kind : Kind.t) =\n match kind with\n | Intf -> Intf_or_impl.Intf [ error_to_sig_extension error ]\n | Impl -> Intf_or_impl.Impl [ error_to_str_extension error ]\n\nlet exn_to_extension exn ~(kind : Kind.t) =\n match Location.Error.of_exn exn with\n | None -> raise exn\n | Some error -> error_to_extension error ~kind\n\n(* +-----------------------------------------------------------------+\n | Actual rewriting of structure/signatures |\n +-----------------------------------------------------------------+ *)\n\nlet print_passes () =\n let tool_name = \"ppxlib_driver\" in\n let hook = Context_free.Generated_code_hook.nop in\n let expect_mismatch_handler = Context_free.Expect_mismatch_handler.nop in\n let cts =\n get_whole_ast_passes ~hook ~expect_mismatch_handler ~tool_name\n ~input_name:None\n in\n if !perform_checks then\n Printf.printf \"\\n\";\n List.iter cts ~f:(fun ct -> Printf.printf \"%s\\n\" ct.Transform.name);\n if !perform_checks then (\n Printf.printf \"\\n\";\n if !perform_checks_on_extensions then\n Printf.printf \"\\n\")\n\n(*$*)\n\nlet map_structure_gen st ~tool_name ~hook ~expect_mismatch_handler ~input_name\n ~embed_errors =\n Cookies.acknowledge_cookies T;\n if !perform_checks then (\n Attribute.reset_checks ();\n Attribute.collect#structure st);\n let lint lint_errors st =\n let st =\n match lint_errors with\n | [] -> st\n | _ ->\n List.map lint_errors\n ~f:(fun ({ attr_name = { loc; _ }; _ } as attr) ->\n Ast_builder.Default.pstr_attribute ~loc attr)\n @ st\n in\n st\n in\n let cookies_and_check st =\n Cookies.call_post_handlers T;\n if !perform_checks then (\n (* TODO: these two passes could be merged, we now have more passes for\n checks than for actual rewriting. *)\n Attribute.check_unused#structure st;\n if !perform_checks_on_extensions then Extension.check_unused#structure st;\n Attribute.check_all_seen ();\n if !perform_locations_check then\n let open Location_check in\n ignore\n ((enforce_invariants !loc_fname)#structure st\n Non_intersecting_ranges.empty\n : Non_intersecting_ranges.t));\n st\n in\n let file_path = File_path.get_default_path_str st in\n match\n apply_transforms st ~tool_name ~file_path\n ~field:(fun (ct : Transform.t) -> ct.impl)\n ~lint_field:(fun (ct : Transform.t) -> ct.lint_impl)\n ~dropped_so_far:Attribute.dropped_so_far_structure ~hook\n ~expect_mismatch_handler ~input_name\n ~f_exception:(fun exn -> exn_to_str_extension exn)\n ~embed_errors\n with\n | Error (st, lint_errors) -> Error (lint lint_errors st)\n | Ok (st, lint_errors) -> Ok (st |> lint lint_errors |> cookies_and_check)\n\nlet map_structure st =\n match\n map_structure_gen st\n ~tool_name:(Astlib.Ast_metadata.tool_name ())\n ~hook:Context_free.Generated_code_hook.nop\n ~expect_mismatch_handler:Context_free.Expect_mismatch_handler.nop\n ~input_name:None ~embed_errors:false\n with\n | Ok ast | Error ast -> ast\n\n(*$ str_to_sig _last_text_block *)\n\nlet map_signature_gen sg ~tool_name ~hook ~expect_mismatch_handler ~input_name\n ~embed_errors =\n Cookies.acknowledge_cookies T;\n if !perform_checks then (\n Attribute.reset_checks ();\n Attribute.collect#signature sg);\n let lint lint_errors sg =\n let sg =\n match lint_errors with\n | [] -> sg\n | _ ->\n List.map lint_errors\n ~f:(fun ({ attr_name = { loc; _ }; _ } as attr) ->\n Ast_builder.Default.psig_attribute ~loc attr)\n @ sg\n in\n sg\n in\n let cookies_and_check sg =\n Cookies.call_post_handlers T;\n if !perform_checks then (\n (* TODO: these two passes could be merged, we now have more passes for\n checks than for actual rewriting. *)\n Attribute.check_unused#signature sg;\n if !perform_checks_on_extensions then Extension.check_unused#signature sg;\n Attribute.check_all_seen ();\n if !perform_locations_check then\n let open Location_check in\n ignore\n ((enforce_invariants !loc_fname)#signature sg\n Non_intersecting_ranges.empty\n : Non_intersecting_ranges.t));\n sg\n in\n let file_path = File_path.get_default_path_sig sg in\n match\n apply_transforms sg ~tool_name ~file_path\n ~field:(fun (ct : Transform.t) -> ct.intf)\n ~lint_field:(fun (ct : Transform.t) -> ct.lint_intf)\n ~dropped_so_far:Attribute.dropped_so_far_signature ~hook\n ~expect_mismatch_handler ~input_name\n ~f_exception:(fun exn -> exn_to_sig_extension exn)\n ~embed_errors\n with\n | Error (sg, lint_errors) -> Error (lint lint_errors sg)\n | Ok (sg, lint_errors) -> Ok (sg |> lint lint_errors |> cookies_and_check)\n\nlet map_signature sg =\n match\n map_signature_gen sg\n ~tool_name:(Astlib.Ast_metadata.tool_name ())\n ~hook:Context_free.Generated_code_hook.nop\n ~expect_mismatch_handler:Context_free.Expect_mismatch_handler.nop\n ~input_name:None ~embed_errors:false\n with\n | Ok ast | Error ast -> ast\n\n(*$*)\n\n(* +-----------------------------------------------------------------+\n | Entry points |\n +-----------------------------------------------------------------+ *)\n\nlet string_contains_binary_ast s =\n let test magic_number =\n String.is_prefix s ~prefix:(String.sub magic_number ~pos:0 ~len:9)\n in\n test Ast_magic.ast_intf_magic_number || test Ast_magic.ast_impl_magic_number\n\nlet versioned_errorf input_version input_file_name =\n Printf.ksprintf (fun msg ->\n let err =\n Location.Error.make ~loc:(Location.in_file input_file_name) msg ~sub:[]\n in\n Error (err, input_version))\n\nlet remove_no_error fn = try Caml.Sys.remove fn with Sys_error _ -> ()\n\nlet protectx x ~f ~finally =\n match f x with\n | v ->\n finally x;\n v\n | exception e ->\n finally x;\n raise e\n\nlet with_preprocessed_file fn ~f =\n match !preprocessor with\n | None -> f fn\n | Some pp ->\n protectx (Caml.Filename.temp_file \"ocamlpp\" \"\") ~finally:remove_no_error\n ~f:(fun tmpfile ->\n match System.run_preprocessor ~pp ~input:fn ~output:tmpfile with\n | Ok () -> f tmpfile\n | Error (failed_command, fall_back_version) ->\n versioned_errorf fall_back_version fn\n \"Error while running external preprocessor\\nCommand line: %s\\n\"\n failed_command)\n\nlet relocate_mapper =\n object\n inherit [string * string] Ast_traverse.map_with_context\n\n method! position (old_fn, new_fn) pos =\n if String.equal pos.pos_fname old_fn then { pos with pos_fname = new_fn }\n else pos\n end\n\n(* Set the input name globally. This is used by some ppx rewriters\n such as bisect_ppx. *)\nlet set_input_name = Astlib.Location.set_input_name\n\nlet load_input ~(kind : Kind.t) ~input_name ~relocate fn =\n set_input_name input_name;\n let input_source = if String.equal fn \"-\" then Ast_io.Stdin else File fn in\n let input_kind = Ast_io.Possibly_source (kind, input_name) in\n match Ast_io.read input_source ~input_kind with\n | Ok { input_name = ast_input_name; input_version; ast } ->\n let ast_kind = Intf_or_impl.kind ast in\n if not (Kind.equal kind ast_kind) then\n versioned_errorf input_version fn\n \"File contains a binary %s AST but an %s was expected\"\n (Kind.describe ast_kind) (Kind.describe kind)\n else if String.equal ast_input_name input_name || not relocate then (\n set_input_name ast_input_name;\n Ok (ast_input_name, input_version, ast))\n else\n Ok\n ( input_name,\n input_version,\n Intf_or_impl.map_with_context ast relocate_mapper\n (ast_input_name, input_name) )\n | Error (Unknown_version (unknown_magic, fall_back_version)) ->\n versioned_errorf fall_back_version fn\n \"File is a binary ast for an unknown version of OCaml with magic \\\n number '%s'\"\n unknown_magic\n | Error (System_error (error, fall_back_version))\n | Error (Source_parse_error (error, fall_back_version)) ->\n Error (error, fall_back_version)\n | Error Not_a_binary_ast -> assert false\n\nlet load_input_run_as_ppx fn =\n (* If there's an error while loading in run_as_ppx mode, the kind of AST (impl/intf) is still unknown.\n That's why, as opposed to load_input, this function raises errors instead of returning a result:\n handling an error by returning an AST with the error packed as extension node wouldn't be possible. *)\n match Ast_io.read (File fn) ~input_kind:Ast_io.Necessarily_binary with\n | Ok { input_name = ast_input_name; input_version; ast } ->\n let ast =\n match !loc_fname with\n | None ->\n set_input_name ast_input_name;\n ast\n | Some input_name ->\n set_input_name input_name;\n if String.equal ast_input_name input_name then ast\n else\n Intf_or_impl.map_with_context ast relocate_mapper\n (ast_input_name, input_name)\n in\n (* With `--as-ppx`, ocaml calls the standalone separately for every structure/signature item\n with the filename as metadata that it gets from the previous call. relocate_mapper only\n relocates positions whose position filename coincides with that metadata filename.\n So always return the metadata filename itself, even if `-loc-filename` is provided. *)\n (ast_input_name, input_version, ast)\n | Error (Unknown_version (unknown_magic, _)) ->\n Location.raise_errorf ~loc:(Location.in_file fn)\n \"The input is a binary ast for an unknown version of OCaml with magic \\\n number '%s'\"\n unknown_magic\n | Error Not_a_binary_ast ->\n Location.raise_errorf ~loc:(Location.in_file fn)\n \"Expected a binary AST as input\"\n | Error (System_error (error, _)) | Error (Source_parse_error (error, _)) ->\n let open Location.Error in\n Location.set_filename (get_location error) fn |> update_loc error |> raise\n\nlet load_source_file fn =\n let s = In_channel.read_all fn in\n if string_contains_binary_ast s then\n Location.raise_errorf ~loc:(Location.in_file fn)\n \"ppxlib_driver: cannot use -reconcile with binary AST files\";\n s\n\ntype output_mode =\n | Pretty_print\n | Dump_ast\n | Dparsetree\n | Reconcile of Reconcile.mode\n | Null\n\n(*$*)\nlet extract_cookies_str st =\n let st =\n match st with\n | ({\n pstr_desc =\n Pstr_attribute { attr_name = { txt = \"ocaml.ppx.context\"; _ }; _ };\n _;\n } as prefix)\n :: st ->\n let prefix = Ppxlib_ast.Selected_ast.to_ocaml Structure [ prefix ] in\n assert (\n List.is_empty\n (Astlib.Ast_metadata.drop_ppx_context_str ~restore:true prefix));\n st\n | _ -> st\n in\n (* The cli cookies have to be set after restoring the ppx context,\n since restoring the ppx context resets the cookies *)\n List.iter !Cookies.given_through_cli ~f:(fun (name, expr) ->\n Cookies.set T name expr);\n st\n\nlet add_cookies_str st =\n let prefix =\n Astlib.Ast_metadata.add_ppx_context_str ~tool_name:\"ppxlib_driver\" []\n |> Ppxlib_ast.Selected_ast.of_ocaml Structure\n in\n prefix @ st\n\n(*$ str_to_sig _last_text_block *)\nlet extract_cookies_sig sg =\n let sg =\n match sg with\n | ({\n psig_desc =\n Psig_attribute { attr_name = { txt = \"ocaml.ppx.context\"; _ }; _ };\n _;\n } as prefix)\n :: sg ->\n let prefix = Ppxlib_ast.Selected_ast.to_ocaml Signature [ prefix ] in\n assert (\n List.is_empty\n (Astlib.Ast_metadata.drop_ppx_context_sig ~restore:true prefix));\n sg\n | _ -> sg\n in\n (* The cli cookies have to be set after restoring the ppx context,\n since restoring the ppx context resets the cookies *)\n List.iter !Cookies.given_through_cli ~f:(fun (name, expr) ->\n Cookies.set T name expr);\n sg\n\nlet add_cookies_sig sg =\n let prefix =\n Astlib.Ast_metadata.add_ppx_context_sig ~tool_name:\"ppxlib_driver\" []\n |> Ppxlib_ast.Selected_ast.of_ocaml Signature\n in\n prefix @ sg\n\n(*$*)\n\nlet extract_cookies (ast : Intf_or_impl.t) : Intf_or_impl.t =\n match ast with\n | Intf x -> Intf (extract_cookies_sig x)\n | Impl x -> Impl (extract_cookies_str x)\n\nlet add_cookies (ast : Intf_or_impl.t) : Intf_or_impl.t =\n match ast with\n | Intf x -> Intf (add_cookies_sig x)\n | Impl x -> Impl (add_cookies_str x)\n\nlet corrections = ref []\nlet add_to_list r x = r := x :: !r\n\nlet register_correction ~loc ~repl =\n add_to_list corrections\n (Reconcile.Replacement.make_text () ~start:loc.loc_start ~stop:loc.loc_end\n ~repl)\n\nlet process_file_hooks = ref []\nlet register_process_file_hook f = add_to_list process_file_hooks f\n\nmodule File_property = struct\n type 'a t = {\n name : string;\n mutable data : 'a option;\n sexp_of_t : 'a -> Sexp.t;\n }\n\n type packed = T : _ t -> packed\n\n let all = ref []\n let register t = add_to_list all (T t)\n let reset_all () = List.iter !all ~f:(fun (T t) -> t.data <- None)\n\n let dump_and_reset_all () =\n List.filter_map (List.rev !all) ~f:(fun (T t) ->\n match t.data with\n | None -> None\n | Some v ->\n t.data <- None;\n Some (t.name, t.sexp_of_t v))\nend\n\nmodule Create_file_property (Name : sig\n val name : string\nend)\n(T : Sexpable.S) =\nstruct\n let t : _ File_property.t =\n { name = Name.name; data = None; sexp_of_t = T.sexp_of_t }\n\n let () = File_property.register t\n let set x = t.data <- Some x\nend\n\nlet process_ast (ast : Intf_or_impl.t) ~input_name ~tool_name ~hook\n ~expect_mismatch_handler ~embed_errors =\n match ast with\n | Intf x ->\n let ast =\n match\n map_signature_gen x ~tool_name ~hook ~expect_mismatch_handler\n ~input_name:(Some input_name) ~embed_errors\n with\n | Error ast | Ok ast -> ast\n in\n Intf_or_impl.Intf ast\n | Impl x ->\n let ast =\n match\n map_structure_gen x ~tool_name ~hook ~expect_mismatch_handler\n ~input_name:(Some input_name) ~embed_errors\n with\n | Error ast | Ok ast -> ast\n in\n Intf_or_impl.Impl ast\n\nlet process_file (kind : Kind.t) fn ~input_name ~relocate ~output_mode\n ~embed_errors ~output =\n File_property.reset_all ();\n List.iter (List.rev !process_file_hooks) ~f:(fun f -> f ());\n corrections := [];\n let replacements = ref [] in\n let tool_name = \"ppx_driver\" in\n let hook : Context_free.Generated_code_hook.t =\n match output_mode with\n | Reconcile (Using_line_directives | Delimiting_generated_blocks) ->\n {\n f =\n (fun context (loc : Location.t) generated ->\n add_to_list replacements\n (Reconcile.Replacement.make () ~context:(Extension context)\n ~start:loc.loc_start ~stop:loc.loc_end ~repl:generated));\n }\n | _ -> Context_free.Generated_code_hook.nop\n in\n let expect_mismatch_handler : Context_free.Expect_mismatch_handler.t =\n {\n f =\n (fun context (loc : Location.t) generated ->\n add_to_list corrections\n (Reconcile.Replacement.make () ~context:(Floating_attribute context)\n ~start:loc.loc_start ~stop:loc.loc_end ~repl:(Many generated)));\n }\n in\n\n let input_name, input_version, ast =\n let preprocessed_and_loaded =\n with_preprocessed_file fn ~f:(load_input ~kind ~input_name ~relocate)\n in\n match preprocessed_and_loaded with\n | Ok (input_fname, input_version, ast) -> (\n try\n let ast =\n extract_cookies ast\n |> process_ast ~input_name ~tool_name ~hook ~expect_mismatch_handler\n ~embed_errors\n in\n (input_fname, input_version, ast)\n with exn when embed_errors ->\n (input_fname, input_version, exn_to_extension exn ~kind))\n | Error (error, input_version) when embed_errors ->\n (input_name, input_version, error_to_extension error ~kind)\n | Error (error, _) ->\n let open Location.Error in\n Location.set_filename (get_location error) fn\n |> update_loc error |> raise\n in\n Option.iter !output_metadata_filename ~f:(fun fn ->\n let metadata = File_property.dump_and_reset_all () in\n Out_channel.write_all fn\n ~data:\n (List.map metadata ~f:(fun (s, sexp) ->\n Sexp.to_string_hum (Sexp.List [ Atom s; sexp ]) ^ \"\\n\")\n |> String.concat ~sep:\"\"));\n\n let input_contents = lazy (load_source_file fn) in\n let corrected = fn ^ !corrected_suffix in\n let mismatches_found =\n match !corrections with\n | [] ->\n if Caml.Sys.file_exists corrected then Caml.Sys.remove corrected;\n false\n | corrections ->\n Reconcile.reconcile corrections\n ~contents:(Lazy.force input_contents)\n ~output:(Some corrected) ~input_filename:fn ~input_name\n ~target:Corrected ?styler:!styler ~kind;\n true\n in\n\n (match output_mode with\n | Null -> ()\n | Pretty_print ->\n with_output output ~binary:false ~f:(fun oc ->\n let ppf = Caml.Format.formatter_of_out_channel oc in\n (match ast with\n | Intf ast -> Pprintast.signature ppf ast\n | Impl ast -> Pprintast.structure ppf ast);\n let null_ast =\n match ast with Intf [] | Impl [] -> true | _ -> false\n in\n if not null_ast then Caml.Format.pp_print_newline ppf ())\n | Dump_ast ->\n with_output output ~binary:true ~f:(fun oc ->\n Ast_io.write oc\n { input_name; input_version; ast }\n ~add_ppx_context:true)\n | Dparsetree ->\n with_output output ~binary:false ~f:(fun oc ->\n let ppf = Caml.Format.formatter_of_out_channel oc in\n let ast = add_cookies ast in\n (match ast with\n | Intf ast -> Sexp.pp_hum ppf (Ast_traverse.sexp_of#signature ast)\n | Impl ast -> Sexp.pp_hum ppf (Ast_traverse.sexp_of#structure ast));\n Caml.Format.pp_print_newline ppf ())\n | Reconcile mode ->\n Reconcile.reconcile !replacements\n ~contents:(Lazy.force input_contents)\n ~output ~input_filename:fn ~input_name ~target:(Output mode)\n ?styler:!styler ~kind);\n\n if\n mismatches_found && match !diff_command with Some \"-\" -> false | _ -> true\n then (\n Ppxlib_print_diff.print () ~file1:fn ~file2:corrected ~use_color:!use_color\n ?diff_command:!diff_command;\n Caml.exit 1)\n\nlet output_mode = ref Pretty_print\nlet output = ref None\nlet kind = ref None\nlet input = ref None\nlet embed_errors = ref false\n\nlet set_input fn =\n match !input with\n | None -> input := Some fn\n | Some _ -> raise (Arg.Bad \"too many input files\")\n\nlet set_kind k =\n match !kind with\n | Some k' when not (Kind.equal k k') ->\n raise (Arg.Bad \"must specify at most one of -impl or -intf\")\n | _ -> kind := Some k\n\nlet set_output_mode mode =\n match (!output_mode, mode) with\n | Pretty_print, _ -> output_mode := mode\n | _, Pretty_print -> assert false\n | Dump_ast, Dump_ast | Dparsetree, Dparsetree -> ()\n | Reconcile a, Reconcile b when Poly.equal a b -> ()\n | x, y ->\n let arg_of_output_mode = function\n | Pretty_print -> assert false\n | Dump_ast -> \"-dump-ast\"\n | Dparsetree -> \"-dparsetree\"\n | Reconcile Using_line_directives -> \"-reconcile\"\n | Reconcile Delimiting_generated_blocks -> \"-reconcile-with-comments\"\n | Null -> \"-null\"\n in\n raise\n (Arg.Bad\n (Printf.sprintf \"%s and %s are incompatible\" (arg_of_output_mode x)\n (arg_of_output_mode y)))\n\nlet print_transformations () =\n List.iter !Transform.all ~f:(fun (ct : Transform.t) ->\n Printf.printf \"%s\\n\" ct.name)\n\nlet parse_apply_list s =\n let names =\n if String.equal s \"\" then [] else String.split_on_char s ~sep:','\n in\n List.iter names ~f:(fun name ->\n if\n not\n (List.exists !Transform.all ~f:(fun (ct : Transform.t) ->\n Transform.has_name ct name))\n then\n raise\n (Caml.Arg.Bad\n (Printf.sprintf \"code transformation '%s' does not exist\" name)));\n names\n\ntype mask = {\n mutable apply : string list option;\n mutable dont_apply : string list option;\n}\n\nlet mask = { apply = None; dont_apply = None }\n\nlet handle_apply s =\n if Option.is_some mask.apply then\n raise (Arg.Bad \"-apply called too many times\");\n (* This is not strictly necessary but it's more intuitive *)\n if Option.is_some mask.dont_apply then\n raise (Arg.Bad \"-apply must be called before -dont-apply\");\n mask.apply <- Some (parse_apply_list s)\n\nlet handle_dont_apply s =\n if Option.is_some mask.dont_apply then\n raise (Arg.Bad \"-apply called too many times\");\n mask.dont_apply <- Some (parse_apply_list s)\n\nlet interpret_mask () =\n if Option.is_some mask.apply || Option.is_some mask.dont_apply then\n let selected_transform_name ct =\n let is_candidate =\n match mask.apply with\n | None -> true\n | Some names -> List.exists names ~f:(Transform.has_name ct)\n in\n let is_selected =\n match mask.dont_apply with\n | None -> is_candidate\n | Some names ->\n is_candidate && not (List.exists names ~f:(Transform.has_name ct))\n in\n if is_selected then Some ct.name else None\n in\n apply_list :=\n Some (List.filter_map !Transform.all ~f:selected_transform_name)\n\nlet set_cookie s =\n match String.lsplit2 s ~on:'=' with\n | None ->\n raise (Arg.Bad \"invalid cookie, must be of the form \\\"=\\\"\")\n | Some (name, value) ->\n let lexbuf = Lexing.from_string value in\n lexbuf.Lexing.lex_curr_p <-\n {\n Lexing.pos_fname = \"\";\n pos_lnum = 1;\n pos_bol = 0;\n pos_cnum = 0;\n };\n let expr = Parse.expression lexbuf in\n Cookies.given_through_cli := (name, expr) :: !Cookies.given_through_cli\n\nlet shared_args =\n [\n ( \"-loc-filename\",\n Arg.String (fun s -> loc_fname := Some s),\n \" File name to use in locations\" );\n ( \"-reserve-namespace\",\n Arg.String Name.Reserved_namespaces.reserve,\n \" Mark the given namespace as reserved\" );\n (\"-no-check\", Arg.Clear perform_checks, \" Disable checks (unsafe)\");\n (\"-check\", Arg.Set perform_checks, \" Enable checks\");\n ( \"-no-check-on-extensions\",\n Arg.Clear perform_checks_on_extensions,\n \" Disable checks on extension point only\" );\n ( \"-check-on-extensions\",\n Arg.Set perform_checks_on_extensions,\n \" Enable checks on extension point only\" );\n ( \"-no-locations-check\",\n Arg.Clear perform_locations_check,\n \" Disable locations check only\" );\n ( \"-locations-check\",\n Arg.Set perform_locations_check,\n \" Enable locations check only\" );\n ( \"-apply\",\n Arg.String handle_apply,\n \" Apply these transformations in order (comma-separated list)\" );\n ( \"-dont-apply\",\n Arg.String handle_dont_apply,\n \" Exclude these transformations\" );\n ( \"-no-merge\",\n Arg.Set no_merge,\n \" Do not merge context free transformations (better for debugging \\\n rewriters). As a result, the context-free transformations are not all \\\n applied before all impl and intf.\" );\n (\"-cookie\", Arg.String set_cookie, \"NAME=EXPR Set the cookie NAME to EXPR\");\n (\"--cookie\", Arg.String set_cookie, \" Same as -cookie\");\n ]\n\nlet () =\n List.iter shared_args ~f:(fun (key, spec, doc) -> add_arg key spec ~doc)\n\nlet as_pp () =\n set_output_mode Dump_ast;\n embed_errors := true\n\nlet standalone_args =\n [\n ( \"-as-ppx\",\n Arg.Unit (fun () -> raise (Arg.Bad \"-as-ppx must be the first argument\")),\n \" Run as a -ppx rewriter (must be the first argument)\" );\n ( \"--as-ppx\",\n Arg.Unit (fun () -> raise (Arg.Bad \"--as-ppx must be the first argument\")),\n \" Same as -as-ppx\" );\n (\"-as-pp\", Arg.Unit as_pp, \" Shorthand for: -dump-ast -embed-errors\");\n (\"--as-pp\", Arg.Unit as_pp, \" Same as -as-pp\");\n ( \"-o\",\n Arg.String (fun s -> output := Some s),\n \" Output file (use '-' for stdout)\" );\n (\"-\", Arg.Unit (fun () -> set_input \"-\"), \" Read input from stdin\");\n ( \"-dump-ast\",\n Arg.Unit (fun () -> set_output_mode Dump_ast),\n \" Dump the marshaled ast to the output file instead of pretty-printing it\"\n );\n ( \"--dump-ast\",\n Arg.Unit (fun () -> set_output_mode Dump_ast),\n \" Same as -dump-ast\" );\n ( \"-dparsetree\",\n Arg.Unit (fun () -> set_output_mode Dparsetree),\n \" Print the parsetree (same as ocamlc -dparsetree)\" );\n ( \"-embed-errors\",\n Arg.Set embed_errors,\n \" Embed errors in the output AST (default: true when -dump-ast, false \\\n otherwise)\" );\n ( \"-null\",\n Arg.Unit (fun () -> set_output_mode Null),\n \" Produce no output, except for errors\" );\n ( \"-impl\",\n Arg.Unit (fun () -> set_kind Impl),\n \" Treat the input as a .ml file\" );\n (\"--impl\", Arg.Unit (fun () -> set_kind Impl), \" Same as -impl\");\n ( \"-intf\",\n Arg.Unit (fun () -> set_kind Intf),\n \" Treat the input as a .mli file\" );\n (\"--intf\", Arg.Unit (fun () -> set_kind Intf), \" Same as -intf\");\n ( \"-debug-attribute-drop\",\n Arg.Set debug_attribute_drop,\n \" Debug attribute dropping\" );\n ( \"-print-transformations\",\n Arg.Set request_print_transformations,\n \" Print linked-in code transformations, in the order they are applied\" );\n ( \"-print-passes\",\n Arg.Set request_print_passes,\n \" Print the actual passes over the whole AST in the order they are \\\n applied\" );\n ( \"-ite-check\",\n Arg.Unit\n (fun () ->\n Printf.eprintf\n \"Warning: the -ite-check flag is deprecated and has no effect.\\n%!\";\n Extra_warnings.care_about_ite_branch := true),\n \" (no effect -- kept for compatibility)\" );\n ( \"-pp\",\n Arg.String (fun s -> preprocessor := Some s),\n \" Pipe sources through preprocessor (incompatible \\\n with -as-ppx)\" );\n ( \"-reconcile\",\n Arg.Unit (fun () -> set_output_mode (Reconcile Using_line_directives)),\n \" (WIP) Pretty print the output using a mix of the input source and the \\\n generated code\" );\n ( \"-reconcile-with-comments\",\n Arg.Unit\n (fun () -> set_output_mode (Reconcile Delimiting_generated_blocks)),\n \" (WIP) same as -reconcile but uses comments to enclose the generated \\\n code\" );\n (\"-no-color\", Arg.Clear use_color, \" Don't use colors when printing errors\");\n ( \"-diff-cmd\",\n Arg.String (fun s -> diff_command := Some s),\n \" Diff command when using code expectations (use - to disable diffing)\" );\n ( \"-pretty\",\n Arg.Set pretty,\n \" Instruct code generators to improve the prettiness of the generated \\\n code\" );\n (\"-styler\", Arg.String (fun s -> styler := Some s), \" Code styler\");\n ( \"-output-metadata\",\n Arg.String (fun s -> output_metadata_filename := Some s),\n \"FILE Where to store the output metadata\" );\n ( \"-corrected-suffix\",\n Arg.Set_string corrected_suffix,\n \"SUFFIX Suffix to append to corrected files\" );\n ]\n\nlet get_args ?(standalone_args = standalone_args) () =\n standalone_args @ List.rev !args\n\nlet standalone_main () =\n let usage = Printf.sprintf \"%s [extra_args] []\" exe_name in\n let args = get_args () in\n Arg.parse (Arg.align args) set_input usage;\n interpret_mask ();\n if !request_print_transformations then (\n print_transformations ();\n Caml.exit 0);\n if !request_print_passes then (\n print_passes ();\n Caml.exit 0);\n match !input with\n | None ->\n Printf.eprintf \"%s: no input file given\\n%!\" exe_name;\n Caml.exit 2\n | Some fn ->\n let kind =\n match !kind with\n | Some k -> k\n | None -> (\n match Kind.of_filename fn with\n | Some k -> k\n | None ->\n Printf.eprintf\n \"%s: don't know what to do with '%s', use -impl or -intf.\\n\"\n exe_name fn;\n Caml.exit 2)\n in\n let input_name, relocate =\n match !loc_fname with None -> (fn, false) | Some fn -> (fn, true)\n in\n process_file kind fn ~input_name ~relocate ~output_mode:!output_mode\n ~output:!output ~embed_errors:!embed_errors\n\nlet rewrite_binary_ast_file input_fn output_fn =\n let input_name, input_version, ast = load_input_run_as_ppx input_fn in\n let ast =\n try\n let ast = extract_cookies ast in\n let tool_name = Astlib.Ast_metadata.tool_name () in\n let hook = Context_free.Generated_code_hook.nop in\n let expect_mismatch_handler = Context_free.Expect_mismatch_handler.nop in\n process_ast ast ~input_name ~tool_name ~hook ~expect_mismatch_handler\n ~embed_errors:true\n with exn -> exn_to_extension exn ~kind:(Intf_or_impl.kind ast)\n in\n with_output (Some output_fn) ~binary:true ~f:(fun oc ->\n Ast_io.write oc { input_name; input_version; ast } ~add_ppx_context:true)\n\nlet parse_input passed_in_args ~valid_args ~incorrect_input_msg =\n try\n Arg.parse_argv passed_in_args (Arg.align valid_args)\n (fun _ -> raise (Arg.Bad \"anonymous arguments not accepted\"))\n incorrect_input_msg\n with\n | Arg.Bad msg ->\n Printf.eprintf \"%s\" msg;\n Caml.exit 2\n | Arg.Help msg ->\n Printf.eprintf \"%s\" msg;\n Caml.exit 0\n\nlet run_as_ppx_rewriter_main ~standalone_args ~usage input =\n let valid_args = get_args ~standalone_args () in\n match List.rev @@ Array.to_list @@ input with\n | output_fn :: input_fn :: flags_and_prog_name\n when List.length flags_and_prog_name > 0 ->\n let prog_name_and_flags = List.rev flags_and_prog_name |> Array.of_list in\n parse_input prog_name_and_flags ~valid_args ~incorrect_input_msg:usage;\n interpret_mask ();\n rewrite_binary_ast_file input_fn output_fn;\n Caml.exit 0\n | [ help; _ ] when String.equal help \"-help\" || String.equal help \"--help\" ->\n parse_input input ~valid_args ~incorrect_input_msg:usage;\n assert false\n | _ ->\n Printf.eprintf \"Usage: %s\\n%!\" usage;\n Caml.exit 2\n\nlet standalone_run_as_ppx_rewriter () =\n let n = Array.length Caml.Sys.argv in\n let usage =\n Printf.sprintf \"%s -as-ppx [extra_args] \" exe_name\n in\n let argv = Array.make (n - 1) \"\" in\n argv.(0) <- Caml.Sys.argv.(0);\n for i = 1 to n - 2 do\n argv.(i) <- Caml.Sys.argv.(i + 1)\n done;\n let standalone_args =\n List.map standalone_args ~f:(fun (arg, spec, _doc) ->\n (arg, spec, \" Unused with -as-ppx\"))\n in\n run_as_ppx_rewriter_main ~standalone_args ~usage argv\n\nlet standalone () =\n Astlib.init_error_reporting_style_using_env_vars ();\n try\n if\n Array.length Caml.Sys.argv >= 2\n &&\n match Caml.Sys.argv.(1) with \"-as-ppx\" | \"--as-ppx\" -> true | _ -> false\n then standalone_run_as_ppx_rewriter ()\n else standalone_main ();\n Caml.exit 0\n with exn ->\n Location.report_exception Caml.Format.err_formatter exn;\n Caml.exit 1\n\nlet run_as_ppx_rewriter () =\n let usage = Printf.sprintf \"%s [extra_args] \" exe_name in\n let input = Caml.Sys.argv in\n try run_as_ppx_rewriter_main ~standalone_args:[] ~usage input\n with exn ->\n Location.report_exception Caml.Format.err_formatter exn;\n Caml.exit 1\n\nlet pretty () = !pretty\n\nlet enable_checks () =\n (* We do not enable the locations check here, we currently require that one\n to be specifically enabled. *)\n perform_checks := true;\n perform_checks_on_extensions := true\n\nlet enable_location_check () = perform_locations_check := true\nlet disable_location_check () = perform_locations_check := false\nlet map_structure st = map_structure st\n","open! Import\n\nlet mk_attr_noloc txt = Ast_helper.Attr.mk Location.{ txt; loc = none }\nlet hide_attribute : attribute = mk_attr_noloc \"merlin.hide\" (PStr [])\nlet focus_attribute : attribute = mk_attr_noloc \"merlin.focus\" (PStr [])\n\nlet hide_pattern ({ ppat_attributes; _ } as p) =\n { p with ppat_attributes = hide_attribute :: ppat_attributes }\n\nlet focus_pattern ({ ppat_attributes; _ } as p) =\n { p with ppat_attributes = focus_attribute :: ppat_attributes }\n\nlet hide_expression ({ pexp_attributes; _ } as e) =\n { e with pexp_attributes = hide_attribute :: pexp_attributes }\n\nlet focus_expression ({ pexp_attributes; _ } as e) =\n { e with pexp_attributes = focus_attribute :: pexp_attributes }\n","open Import\nopen Ast_builder.Default\n\nlet underscore_binding exp =\n let loc = exp.pexp_loc in\n value_binding ~loc ~pat:(ppat_any ~loc) ~expr:exp\n\nlet vars_of =\n object\n inherit [Longident.t Located.t list] Ast_traverse.fold as super\n\n method! pattern patt acc =\n match patt.ppat_desc with\n | Ppat_var v -> Located.map (fun var -> Longident.Lident var) v :: acc\n | _ -> super#pattern patt acc\n end\n\n(* For every [let x = ...] structure item, add a [let _ = x] *)\nlet add_dummy_user_for_values =\n object\n inherit Ast_traverse.map as super\n\n method! structure st =\n let rec loop st acc =\n match st with\n | [] -> List.rev acc\n | ({ pstr_desc = Pstr_value (_, vbs); pstr_loc = loc } as item) :: rest\n ->\n let vars =\n List.fold_left vbs ~init:[] ~f:(fun acc vb ->\n vars_of#pattern vb.pvb_pat acc)\n in\n let ign =\n pstr_value_list ~loc Nonrecursive\n (List.rev_map vars ~f:(fun v ->\n underscore_binding (pexp_ident ~loc:v.loc v)))\n in\n loop rest (ign @ (item :: acc))\n | item :: rest -> loop rest (item :: acc)\n in\n loop (super#structure st) []\n end\n\nlet binds_module_names =\n object\n inherit [bool] Ast_traverse.fold as super\n\n method! module_binding mb acc =\n match mb.pmb_name.txt with\n | Some (_ : string) -> true\n | None -> super#module_binding mb acc\n\n method! module_declaration md acc =\n match md.pmd_name.txt with\n | Some (_ : string) -> true\n | None -> super#module_declaration md acc\n\n method! module_substitution ms _ =\n match ms.pms_name.txt with (_ : string) -> true\n\n method! functor_parameter fp acc =\n match fp with\n | Unit -> acc\n | Named (name, _) -> (\n match name.txt with\n | Some (_ : string) -> true\n | None -> super#functor_parameter fp acc)\n\n method! pattern pat acc =\n match pat.ppat_desc with\n | Ppat_unpack name -> (\n match name.txt with Some (_ : string) -> true | None -> acc)\n | _ -> super#pattern pat acc\n\n method! expression expr acc =\n match expr.pexp_desc with\n | Pexp_letmodule (name, _, _) -> (\n match name.txt with\n | Some (_ : string) -> true\n | None -> super#expression expr acc)\n | _ -> super#expression expr acc\n end\n","open! Import\ninclude Clause_syntax_intf\n\nmodule Variant = struct\n type ast = constructor_declaration\n\n type t =\n { ast : ast\n ; position : int\n }\n\n let create_list list =\n List.mapi list ~f:(fun position ast ->\n let loc = ast.pcd_loc in\n match ast.pcd_res with\n | Some _ -> unsupported ~loc \"GADT\"\n | None -> { ast; position })\n ;;\n\n let salt t = Some t.position\n let location t = t.ast.pcd_loc\n\n let weight_attribute =\n Attribute.declare\n \"quickcheck.weight\"\n Attribute.Context.constructor_declaration\n Ast_pattern.(pstr (pstr_eval __ nil ^:: nil))\n (fun x -> x)\n ;;\n\n let weight t =\n match Attribute.get weight_attribute t.ast with\n | Some expr -> expr\n | None -> efloat ~loc:{ (location t) with loc_ghost = true } \"1.\"\n ;;\n\n let core_type_list t =\n match t.ast.pcd_args with\n | Pcstr_tuple list -> list\n | Pcstr_record label_decl_list ->\n List.map label_decl_list ~f:(fun label_decl -> label_decl.pld_type)\n ;;\n\n let pattern t ~loc pat_list =\n let arg =\n match t.ast.pcd_args with\n | Pcstr_tuple _ ->\n (match pat_list with\n | [] -> None\n | [ pat ] -> Some pat\n | _ -> Some (ppat_tuple ~loc pat_list))\n | Pcstr_record label_decl_list ->\n let alist =\n List.map2_exn label_decl_list pat_list ~f:(fun label_decl pat ->\n lident_loc label_decl.pld_name, pat)\n in\n Some (ppat_record ~loc alist Closed)\n in\n ppat_construct ~loc (lident_loc t.ast.pcd_name) arg\n ;;\n\n let expression t ~loc _ expr_list =\n let arg =\n match t.ast.pcd_args with\n | Pcstr_tuple _ ->\n (match expr_list with\n | [] -> None\n | [ expr ] -> Some expr\n | _ -> Some (pexp_tuple ~loc expr_list))\n | Pcstr_record label_decl_list ->\n let alist =\n List.map2_exn label_decl_list expr_list ~f:(fun label_decl expr ->\n lident_loc label_decl.pld_name, expr)\n in\n Some (pexp_record ~loc alist None)\n in\n pexp_construct ~loc (lident_loc t.ast.pcd_name) arg\n ;;\nend\n\nmodule Polymorphic_variant = struct\n type ast = row_field\n type t = ast\n\n let create_list = Fn.id\n\n let salt t =\n match t.prf_desc with\n | Rtag (label, _, _) -> Some (Ocaml_common.Btype.hash_variant label.txt)\n | Rinherit _ -> None\n ;;\n\n let location t = t.prf_loc\n\n let weight_attribute =\n Attribute.declare\n \"quickcheck.weight\"\n Attribute.Context.rtag\n Ast_pattern.(pstr (pstr_eval __ nil ^:: nil))\n (fun x -> x)\n ;;\n\n let weight t =\n match Attribute.get weight_attribute t with\n | Some expr -> expr\n | None -> efloat ~loc:{ (location t) with loc_ghost = true } \"1.\"\n ;;\n\n let core_type_list t =\n match t.prf_desc with\n | Rtag (_, _, core_type_list) -> core_type_list\n | Rinherit core_type -> [ core_type ]\n ;;\n\n let pattern t ~loc pat_list =\n match t.prf_desc, pat_list with\n | Rtag (label, true, []), [] -> ppat_variant ~loc label.txt None\n | Rtag (label, false, [ _ ]), [ pat ] -> ppat_variant ~loc label.txt (Some pat)\n | Rtag (label, false, [ _ ]), _ :: _ :: _ ->\n ppat_variant ~loc label.txt (Some (ppat_tuple ~loc pat_list))\n | Rinherit { ptyp_desc; _ }, [ { ppat_desc; _ } ] ->\n (match ptyp_desc with\n | Ptyp_constr (id, []) ->\n (match ppat_desc with\n | Ppat_var var -> ppat_alias ~loc (ppat_type ~loc id) var\n | _ ->\n internal_error\n ~loc\n \"cannot bind a # pattern to anything other than a variable\")\n | _ ->\n unsupported ~loc \"inherited polymorphic variant type that is not a type name\")\n | Rtag (_, true, _ :: _), _ | Rtag (_, false, ([] | _ :: _ :: _)), _ ->\n unsupported ~loc \"intersection type\"\n | Rtag (_, true, []), _ :: _\n | Rtag (_, false, [ _ ]), []\n | Rinherit _, ([] | _ :: _ :: _) ->\n internal_error ~loc \"wrong number of arguments for variant clause\"\n ;;\n\n let expression t ~loc core_type expr_list =\n match t.prf_desc, expr_list with\n | Rtag (label, true, []), [] -> pexp_variant ~loc label.txt None\n | Rtag (label, false, [ _ ]), [ expr ] -> pexp_variant ~loc label.txt (Some expr)\n | Rtag (label, false, [ _ ]), _ :: _ :: _ ->\n pexp_variant ~loc label.txt (Some (pexp_tuple ~loc expr_list))\n | Rinherit inherited_type, [ expr ] ->\n pexp_coerce ~loc expr (Some inherited_type) core_type\n | Rtag (_, true, _ :: _), _ | Rtag (_, false, ([] | _ :: _ :: _)), _ ->\n unsupported ~loc \"intersection type\"\n | Rtag (_, true, []), _ :: _\n | Rtag (_, false, [ _ ]), []\n | Rinherit _, ([] | _ :: _ :: _) ->\n internal_error ~loc \"wrong number of arguments for variant clause\"\n ;;\nend\n","open! Import\ninclude Field_syntax_intf\n\nmodule Tuple = struct\n type ast = core_type\n type t = ast\n\n let create = Fn.id\n let location t = t.ptyp_loc\n let core_type t = t\n let pattern _ ~loc pat_list = ppat_tuple ~loc pat_list\n let expression _ ~loc expr_list = pexp_tuple ~loc expr_list\nend\n\nmodule Record = struct\n type ast = label_declaration\n type t = ast\n\n let create ast =\n match ast.pld_mutable with\n | Immutable -> ast\n | Mutable ->\n (* We intend to support mutable fields and values shortly, but we leave it to a\n separate feature. Integrating mutable values with replayability and shrinking is\n tricky, and we at least have to figure out what caveats to document. *)\n unsupported ~loc:ast.pld_loc \"mutable record field\"\n ;;\n\n let location t = t.pld_loc\n let core_type t = t.pld_type\n\n let pattern list ~loc pat_list =\n let alist =\n List.map2_exn list pat_list ~f:(fun t pat -> lident_loc t.pld_name, pat)\n in\n ppat_record ~loc alist Closed\n ;;\n\n let expression list ~loc expr_list =\n let alist =\n List.map2_exn list expr_list ~f:(fun t expr -> lident_loc t.pld_name, expr)\n in\n pexp_record ~loc alist None\n ;;\nend\n","open! Import\n\nlet any ~loc = [%expr Base_quickcheck.Shrinker.atomic]\nlet arrow ~loc = [%expr Base_quickcheck.Shrinker.atomic]\n\nlet compound_sequence ~loc ~make_compound_expr ~field_pats ~field_exprs ~shrinker_exprs =\n [%expr\n Base.Sequence.round_robin\n [%e\n elist\n ~loc\n (List.map3_exn\n field_pats\n field_exprs\n shrinker_exprs\n ~f:(fun field_pat field_expr shrinker ->\n let loc = { shrinker.pexp_loc with loc_ghost = true } in\n [%expr\n Base.Sequence.map\n (Base_quickcheck.Shrinker.shrink [%e shrinker] [%e field_expr])\n ~f:(fun [%p field_pat] -> [%e make_compound_expr ~loc field_exprs])]))]]\n;;\n\nlet compound\n (type field)\n ~shrinker_of_core_type\n ~loc\n ~fields\n (module Field : Field_syntax.S with type ast = field)\n =\n let fields = List.map fields ~f:Field.create in\n let field_pats, field_exprs = gensyms \"x\" (List.map fields ~f:Field.location) in\n let shrinker_exprs =\n List.map fields ~f:(fun field -> shrinker_of_core_type (Field.core_type field))\n in\n [%expr\n Base_quickcheck.Shrinker.create (fun [%p Field.pattern fields ~loc field_pats] ->\n [%e\n compound_sequence\n ~loc\n ~make_compound_expr:(Field.expression fields)\n ~field_pats\n ~field_exprs\n ~shrinker_exprs])]\n;;\n\nlet variant\n (type clause)\n ~shrinker_of_core_type\n ~loc\n ~variant_type\n ~clauses\n (module Clause : Clause_syntax.S with type ast = clause)\n =\n let clauses = Clause.create_list clauses in\n [%expr\n Base_quickcheck.Shrinker.create\n [%e\n pexp_function\n ~loc\n (List.map clauses ~f:(fun clause ->\n let loc = { (Clause.location clause) with loc_ghost = true } in\n let core_type_list = Clause.core_type_list clause in\n let field_pats, field_exprs =\n gensyms\n \"x\"\n (List.map core_type_list ~f:(fun core_type -> core_type.ptyp_loc))\n in\n let shrinker_exprs = List.map core_type_list ~f:shrinker_of_core_type in\n let lhs = Clause.pattern clause ~loc field_pats in\n let rhs =\n compound_sequence\n ~loc\n ~make_compound_expr:(Clause.expression clause variant_type)\n ~field_pats\n ~field_exprs\n ~shrinker_exprs\n in\n case ~lhs ~guard:None ~rhs))]]\n;;\n","open! Import\n\nlet arrow\n ~generator_of_core_type\n ~observer_of_core_type\n ~loc\n ~arg_label\n ~input_type\n ~output_type\n =\n let input_observer =\n match arg_label with\n | Nolabel | Labelled _ -> observer_of_core_type input_type\n | Optional _ ->\n [%expr Base_quickcheck.Observer.option [%e observer_of_core_type input_type]]\n in\n let output_generator = generator_of_core_type output_type in\n let unlabelled =\n [%expr Base_quickcheck.Generator.fn [%e input_observer] [%e output_generator]]\n in\n match arg_label with\n | Nolabel -> unlabelled\n | Labelled _ | Optional _ ->\n [%expr\n Base_quickcheck.Generator.map\n ~f:[%e fn_map_label ~loc ~from:Nolabel ~to_:arg_label]\n [%e unlabelled]]\n;;\n\nlet compound_generator ~loc ~make_compound_expr generator_list =\n let loc = { loc with loc_ghost = true } in\n let size_pat, size_expr = gensym \"size\" loc in\n let random_pat, random_expr = gensym \"random\" loc in\n [%expr\n Base_quickcheck.Generator.create (fun ~size:[%p size_pat] ~random:[%p random_pat] ->\n [%e\n make_compound_expr\n ~loc\n (List.map generator_list ~f:(fun generator ->\n let loc = { generator.pexp_loc with loc_ghost = true } in\n [%expr\n Base_quickcheck.Generator.generate\n [%e generator]\n ~size:[%e size_expr]\n ~random:[%e random_expr]]))])]\n;;\n\nlet compound\n (type field)\n ~generator_of_core_type\n ~loc\n ~fields\n (module Field : Field_syntax.S with type ast = field)\n =\n let fields = List.map fields ~f:Field.create in\n compound_generator\n ~loc\n ~make_compound_expr:(Field.expression fields)\n (List.map fields ~f:(fun field -> generator_of_core_type (Field.core_type field)))\n;;\n\nlet does_refer_to name_set =\n object (self)\n inherit [bool] Ast_traverse.fold as super\n\n method! core_type ty acc =\n match ty.ptyp_desc with\n | Ptyp_constr (name, args) ->\n acc\n || Set.mem name_set (Longident.name name.txt)\n || List.exists args ~f:(fun arg -> self#core_type arg false)\n | _ -> super#core_type ty acc\n end\n;;\n\nlet clause_is_recursive\n (type clause)\n ~clause\n ~rec_names\n (module Clause : Clause_syntax.S with type t = clause)\n =\n List.exists (Clause.core_type_list clause) ~f:(fun ty ->\n (does_refer_to rec_names)#core_type ty false)\n;;\n\nlet variant\n (type clause)\n ~generator_of_core_type\n ~loc\n ~variant_type\n ~clauses\n ~rec_names\n (module Clause : Clause_syntax.S with type ast = clause)\n =\n let clauses = Clause.create_list clauses in\n let make_generator clause =\n compound_generator\n ~loc:(Clause.location clause)\n ~make_compound_expr:(Clause.expression clause variant_type)\n (List.map (Clause.core_type_list clause) ~f:generator_of_core_type)\n in\n let make_pair clause =\n pexp_tuple\n ~loc:{ (Clause.location clause) with loc_ghost = true }\n [ Clause.weight clause; make_generator clause ]\n in\n match\n List.partition_tf clauses ~f:(fun clause ->\n clause_is_recursive ~clause ~rec_names (module Clause))\n with\n | [], clauses | clauses, [] ->\n let pairs = List.map clauses ~f:make_pair in\n [%expr Base_quickcheck.Generator.weighted_union [%e elist ~loc pairs]]\n | recursive_clauses, nonrecursive_clauses ->\n let size_pat, size_expr = gensym \"size\" loc in\n let nonrec_pat, nonrec_expr = gensym \"gen\" loc in\n let rec_pat, rec_expr = gensym \"gen\" loc in\n let nonrec_pats, nonrec_exprs =\n gensyms \"pair\" (List.map nonrecursive_clauses ~f:Clause.location)\n in\n let rec_pats, rec_exprs =\n gensyms \"pair\" (List.map recursive_clauses ~f:Clause.location)\n in\n let bindings =\n List.map2_exn nonrec_pats nonrecursive_clauses ~f:(fun pat clause ->\n let loc = { (Clause.location clause) with loc_ghost = true } in\n let expr = make_pair clause in\n value_binding ~loc ~pat ~expr)\n @ List.map2_exn rec_pats recursive_clauses ~f:(fun pat clause ->\n let loc = { (Clause.location clause) with loc_ghost = true } in\n let weight_expr = Clause.weight clause in\n let gen_expr =\n [%expr\n Base_quickcheck.Generator.bind\n Base_quickcheck.Generator.size\n ~f:(fun [%p size_pat] ->\n Base_quickcheck.Generator.with_size\n ~size:(Base.Int.pred [%e size_expr])\n [%e make_generator clause])]\n in\n let expr = pexp_tuple ~loc [ weight_expr; gen_expr ] in\n value_binding ~loc ~pat ~expr)\n in\n let body =\n [%expr\n let [%p nonrec_pat] =\n Base_quickcheck.Generator.weighted_union [%e elist ~loc nonrec_exprs]\n and [%p rec_pat] =\n Base_quickcheck.Generator.weighted_union\n [%e elist ~loc (nonrec_exprs @ rec_exprs)]\n in\n Base_quickcheck.Generator.bind Base_quickcheck.Generator.size ~f:(function\n | 0 -> [%e nonrec_expr]\n | _ -> [%e rec_expr])]\n in\n pexp_let ~loc Nonrecursive bindings body\n;;\n","open! Import\n\nlet any ~loc = [%expr Base_quickcheck.Observer.opaque]\n\nlet arrow\n ~observer_of_core_type\n ~generator_of_core_type\n ~loc\n ~arg_label\n ~input_type\n ~output_type\n =\n let input_generator =\n match arg_label with\n | Nolabel | Labelled _ -> generator_of_core_type input_type\n | Optional _ ->\n [%expr Base_quickcheck.Generator.option [%e generator_of_core_type input_type]]\n in\n let output_observer = observer_of_core_type output_type in\n let unlabelled =\n [%expr Base_quickcheck.Observer.fn [%e input_generator] [%e output_observer]]\n in\n match arg_label with\n | Nolabel -> unlabelled\n | Labelled _ | Optional _ ->\n [%expr\n Base_quickcheck.Observer.unmap\n ~f:[%e fn_map_label ~loc ~from:arg_label ~to_:Nolabel]\n [%e unlabelled]]\n;;\n\nlet compound_hash ~loc ~size_expr ~hash_expr ~hash_pat ~observer_exprs ~field_exprs =\n let alist = List.zip_exn observer_exprs field_exprs in\n List.fold_right alist ~init:hash_expr ~f:(fun (observer_expr, field_expr) body_expr ->\n [%expr\n let [%p hash_pat] =\n Base_quickcheck.Observer.observe\n [%e observer_expr]\n [%e field_expr]\n ~size:[%e size_expr]\n ~hash:[%e hash_expr]\n in\n [%e body_expr]])\n;;\n\nlet compound\n (type field)\n ~observer_of_core_type\n ~loc\n ~fields\n (module Field : Field_syntax.S with type ast = field)\n =\n let fields = List.map fields ~f:Field.create in\n let field_pats, field_exprs = gensyms \"x\" (List.map fields ~f:Field.location) in\n let pat = Field.pattern fields ~loc field_pats in\n let observer_exprs =\n List.map fields ~f:(fun field -> observer_of_core_type (Field.core_type field))\n in\n let size_pat, size_expr = gensym \"size\" loc in\n let hash_pat, hash_expr = gensym \"hash\" loc in\n [%expr\n Base_quickcheck.Observer.create\n (fun [%p pat] ~size:[%p size_pat] ~hash:[%p hash_pat] ->\n [%e\n compound_hash ~loc ~size_expr ~hash_expr ~hash_pat ~observer_exprs ~field_exprs])]\n;;\n\nlet variant\n (type clause)\n ~observer_of_core_type\n ~loc\n ~clauses\n (module Clause : Clause_syntax.S with type ast = clause)\n =\n let clauses = Clause.create_list clauses in\n let pat, expr = gensym \"x\" loc in\n let size_pat, size_expr = gensym \"size\" loc in\n let hash_pat, hash_expr = gensym \"hash\" loc in\n [%expr\n Base_quickcheck.Observer.create\n (fun [%p pat] ~size:[%p size_pat] ~hash:[%p hash_pat] ->\n [%e\n pexp_match\n ~loc\n expr\n (List.map clauses ~f:(fun clause ->\n let core_type_list = Clause.core_type_list clause in\n let observer_exprs = List.map core_type_list ~f:observer_of_core_type in\n let field_pats, field_exprs =\n gensyms\n \"x\"\n (List.map core_type_list ~f:(fun core_type -> core_type.ptyp_loc))\n in\n let lhs = Clause.pattern clause ~loc field_pats in\n let body =\n compound_hash\n ~loc\n ~size_expr\n ~hash_expr\n ~hash_pat\n ~observer_exprs\n ~field_exprs\n in\n let rhs =\n match Clause.salt clause with\n | None -> body\n | Some salt ->\n pexp_let\n ~loc\n Nonrecursive\n [ value_binding\n ~loc\n ~pat:hash_pat\n ~expr:\n [%expr\n Base.hash_fold_int [%e hash_expr] [%e eint ~loc salt]]\n ]\n body\n in\n case ~lhs ~guard:None ~rhs))])]\n;;\n","open! Import\n\nlet custom_extension ~loc tag payload =\n match String.equal tag.txt \"custom\" with\n | false -> unsupported ~loc \"uknown extension: %s\" tag.txt\n | true ->\n (match payload with\n | PStr [ { pstr_desc = Pstr_eval (expr, attributes); _ } ] ->\n assert_no_attributes attributes;\n expr\n | _ -> invalid ~loc \"[%%custom] extension expects a single expression as its payload\")\n;;\n\nlet generator_attribute =\n Attribute.declare\n \"quickcheck.generator\"\n Attribute.Context.core_type\n Ast_pattern.(pstr (pstr_eval __ nil ^:: nil))\n (fun x -> x)\n;;\n\nlet rec generator_of_core_type core_type ~gen_env ~obs_env =\n let loc = { core_type.ptyp_loc with loc_ghost = true } in\n match Attribute.get generator_attribute core_type with\n | Some expr -> expr\n | None ->\n (match core_type.ptyp_desc with\n | Ptyp_constr (constr, args) ->\n type_constr_conv\n ~loc\n ~f:generator_name\n constr\n (List.map args ~f:(generator_of_core_type ~gen_env ~obs_env))\n | Ptyp_var tyvar -> Environment.lookup gen_env ~loc ~tyvar\n | Ptyp_arrow (arg_label, input_type, output_type) ->\n Ppx_generator_expander.arrow\n ~generator_of_core_type:(generator_of_core_type ~gen_env ~obs_env)\n ~observer_of_core_type:(observer_of_core_type ~gen_env ~obs_env)\n ~loc\n ~arg_label\n ~input_type\n ~output_type\n | Ptyp_tuple fields ->\n Ppx_generator_expander.compound\n ~generator_of_core_type:(generator_of_core_type ~gen_env ~obs_env)\n ~loc\n ~fields\n (module Field_syntax.Tuple)\n | Ptyp_variant (clauses, Closed, None) ->\n Ppx_generator_expander.variant\n ~generator_of_core_type:(generator_of_core_type ~gen_env ~obs_env)\n ~loc\n ~variant_type:core_type\n ~clauses\n ~rec_names:(Set.empty (module String))\n (module Clause_syntax.Polymorphic_variant)\n | Ptyp_variant (_, Open, _) -> unsupported ~loc \"polymorphic variant type with [>]\"\n | Ptyp_variant (_, _, Some _) -> unsupported ~loc \"polymorphic variant type with [<]\"\n | Ptyp_extension (tag, payload) -> custom_extension ~loc tag payload\n | Ptyp_any\n | Ptyp_object _\n | Ptyp_class _\n | Ptyp_alias _\n | Ptyp_poly _\n | Ptyp_package _ -> unsupported ~loc \"%s\" (short_string_of_core_type core_type))\n\nand observer_of_core_type core_type ~obs_env ~gen_env =\n let loc = { core_type.ptyp_loc with loc_ghost = true } in\n match core_type.ptyp_desc with\n | Ptyp_constr (constr, args) ->\n type_constr_conv\n ~loc\n ~f:observer_name\n constr\n (List.map args ~f:(observer_of_core_type ~obs_env ~gen_env))\n | Ptyp_var tyvar -> Environment.lookup obs_env ~loc ~tyvar\n | Ptyp_arrow (arg_label, input_type, output_type) ->\n Ppx_observer_expander.arrow\n ~observer_of_core_type:(observer_of_core_type ~obs_env ~gen_env)\n ~generator_of_core_type:(generator_of_core_type ~obs_env ~gen_env)\n ~loc\n ~arg_label\n ~input_type\n ~output_type\n | Ptyp_tuple fields ->\n Ppx_observer_expander.compound\n ~observer_of_core_type:(observer_of_core_type ~obs_env ~gen_env)\n ~loc\n ~fields\n (module Field_syntax.Tuple)\n | Ptyp_variant (clauses, Closed, None) ->\n Ppx_observer_expander.variant\n ~observer_of_core_type:(observer_of_core_type ~obs_env ~gen_env)\n ~loc\n ~clauses\n (module Clause_syntax.Polymorphic_variant)\n | Ptyp_variant (_, Open, _) -> unsupported ~loc \"polymorphic variant type with [>]\"\n | Ptyp_variant (_, _, Some _) -> unsupported ~loc \"polymorphic variant type with [<]\"\n | Ptyp_extension (tag, payload) -> custom_extension ~loc tag payload\n | Ptyp_any -> Ppx_observer_expander.any ~loc\n | Ptyp_object _ | Ptyp_class _ | Ptyp_alias _ | Ptyp_poly _ | Ptyp_package _ ->\n unsupported ~loc \"%s\" (short_string_of_core_type core_type)\n;;\n\nlet rec shrinker_of_core_type core_type ~env =\n let loc = { core_type.ptyp_loc with loc_ghost = true } in\n match core_type.ptyp_desc with\n | Ptyp_constr (constr, args) ->\n type_constr_conv\n ~loc\n ~f:shrinker_name\n constr\n (List.map args ~f:(shrinker_of_core_type ~env))\n | Ptyp_var tyvar -> Environment.lookup env ~loc ~tyvar\n | Ptyp_arrow _ -> Ppx_shrinker_expander.arrow ~loc\n | Ptyp_tuple fields ->\n Ppx_shrinker_expander.compound\n ~shrinker_of_core_type:(shrinker_of_core_type ~env)\n ~loc\n ~fields\n (module Field_syntax.Tuple)\n | Ptyp_variant (clauses, Closed, None) ->\n Ppx_shrinker_expander.variant\n ~shrinker_of_core_type:(shrinker_of_core_type ~env)\n ~loc\n ~variant_type:core_type\n ~clauses\n (module Clause_syntax.Polymorphic_variant)\n | Ptyp_variant (_, Open, _) -> unsupported ~loc \"polymorphic variant type with [>]\"\n | Ptyp_variant (_, _, Some _) -> unsupported ~loc \"polymorphic variant type with [<]\"\n | Ptyp_extension (tag, payload) -> custom_extension ~loc tag payload\n | Ptyp_any -> Ppx_shrinker_expander.any ~loc\n | Ptyp_object _ | Ptyp_class _ | Ptyp_alias _ | Ptyp_poly _ | Ptyp_package _ ->\n unsupported ~loc \"%s\" (short_string_of_core_type core_type)\n;;\n\ntype impl =\n { loc : location\n ; pat : pattern\n ; var : expression\n ; exp : expression\n }\n\nlet generator_impl type_decl ~rec_names =\n let loc = type_decl.ptype_loc in\n let pat = pgenerator type_decl.ptype_name in\n let var = egenerator type_decl.ptype_name in\n let exp =\n let pat_list, `Covariant gen_env, `Contravariant obs_env =\n Environment.create_with_variance\n ~loc\n ~covariant:\"generator\"\n ~contravariant:\"observer\"\n type_decl.ptype_params\n in\n let body =\n match type_decl.ptype_kind with\n | Ptype_open -> unsupported ~loc \"open type\"\n | Ptype_variant clauses ->\n Ppx_generator_expander.variant\n ~generator_of_core_type:(generator_of_core_type ~gen_env ~obs_env)\n ~loc\n ~variant_type:[%type: _]\n ~clauses\n ~rec_names\n (module Clause_syntax.Variant)\n | Ptype_record fields ->\n Ppx_generator_expander.compound\n ~generator_of_core_type:(generator_of_core_type ~gen_env ~obs_env)\n ~loc\n ~fields\n (module Field_syntax.Record)\n | Ptype_abstract ->\n (match type_decl.ptype_manifest with\n | Some core_type -> generator_of_core_type core_type ~gen_env ~obs_env\n | None -> unsupported ~loc \"abstract type\")\n in\n List.fold_right pat_list ~init:body ~f:(fun pat body ->\n [%expr fun [%p pat] -> [%e body]])\n in\n { loc; pat; var; exp }\n;;\n\nlet observer_impl type_decl ~rec_names:_ =\n let loc = type_decl.ptype_loc in\n let pat = pobserver type_decl.ptype_name in\n let var = eobserver type_decl.ptype_name in\n let exp =\n let pat_list, `Covariant obs_env, `Contravariant gen_env =\n Environment.create_with_variance\n ~loc\n ~covariant:\"observer\"\n ~contravariant:\"generator\"\n type_decl.ptype_params\n in\n let body =\n match type_decl.ptype_kind with\n | Ptype_open -> unsupported ~loc \"open type\"\n | Ptype_variant clauses ->\n Ppx_observer_expander.variant\n ~observer_of_core_type:(observer_of_core_type ~obs_env ~gen_env)\n ~loc\n ~clauses\n (module Clause_syntax.Variant)\n | Ptype_record fields ->\n Ppx_observer_expander.compound\n ~observer_of_core_type:(observer_of_core_type ~obs_env ~gen_env)\n ~loc\n ~fields\n (module Field_syntax.Record)\n | Ptype_abstract ->\n (match type_decl.ptype_manifest with\n | Some core_type -> observer_of_core_type core_type ~obs_env ~gen_env\n | None -> unsupported ~loc \"abstract type\")\n in\n List.fold_right pat_list ~init:body ~f:(fun pat body ->\n [%expr fun [%p pat] -> [%e body]])\n in\n { loc; pat; var; exp }\n;;\n\nlet shrinker_impl type_decl ~rec_names:_ =\n let loc = type_decl.ptype_loc in\n let pat = pshrinker type_decl.ptype_name in\n let var = eshrinker type_decl.ptype_name in\n let exp =\n let pat_list, env =\n Environment.create ~loc ~prefix:\"shrinker\" type_decl.ptype_params\n in\n let body =\n match type_decl.ptype_kind with\n | Ptype_open -> unsupported ~loc \"open type\"\n | Ptype_variant clauses ->\n Ppx_shrinker_expander.variant\n ~shrinker_of_core_type:(shrinker_of_core_type ~env)\n ~loc\n ~variant_type:[%type: _]\n ~clauses\n (module Clause_syntax.Variant)\n | Ptype_record fields ->\n Ppx_shrinker_expander.compound\n ~shrinker_of_core_type:(shrinker_of_core_type ~env)\n ~loc\n ~fields\n (module Field_syntax.Record)\n | Ptype_abstract ->\n (match type_decl.ptype_manifest with\n | Some core_type -> shrinker_of_core_type core_type ~env\n | None -> unsupported ~loc \"abstract type\")\n in\n List.fold_right pat_list ~init:body ~f:(fun pat body ->\n [%expr fun [%p pat] -> [%e body]])\n in\n { loc; pat; var; exp }\n;;\n\nlet maybe_mutually_recursive decls ~loc ~rec_flag ~of_lazy ~impl =\n let decls = List.map decls ~f:name_type_params_in_td in\n let rec_names =\n match rec_flag with\n | Nonrecursive -> Set.empty (module String)\n | Recursive ->\n Set.of_list (module String) (List.map decls ~f:(fun decl -> decl.ptype_name.txt))\n in\n let impls = List.map decls ~f:(fun decl -> impl decl ~rec_names) in\n match rec_flag with\n | Nonrecursive ->\n pstr_value_list\n ~loc\n Nonrecursive\n (List.map impls ~f:(fun impl ->\n value_binding ~loc:impl.loc ~pat:impl.pat ~expr:impl.exp))\n | Recursive ->\n let pats = List.map impls ~f:(fun impl -> impl.pat) in\n let bindings =\n let inner_bindings =\n List.map impls ~f:(fun inner ->\n value_binding\n ~loc:inner.loc\n ~pat:inner.pat\n ~expr:[%expr [%e of_lazy] [%e inner.var]])\n in\n List.map impls ~f:(fun impl ->\n let body = pexp_let ~loc:impl.loc Nonrecursive inner_bindings impl.exp in\n let lazy_expr = [%expr lazy [%e body]] in\n value_binding ~loc:impl.loc ~pat:impl.pat ~expr:lazy_expr)\n in\n let body =\n pexp_tuple\n ~loc\n (List.map impls ~f:(fun impl -> [%expr [%e of_lazy] [%e impl.var]]))\n in\n pstr_value_list\n ~loc\n Nonrecursive\n [ value_binding\n ~loc\n ~pat:(ppat_tuple ~loc pats)\n ~expr:(pexp_let ~loc Recursive bindings body)\n ]\n;;\n\nlet generator_impl_list decls ~loc ~rec_flag =\n maybe_mutually_recursive\n decls\n ~loc\n ~rec_flag\n ~of_lazy:[%expr Base_quickcheck.Generator.of_lazy]\n ~impl:generator_impl\n;;\n\nlet observer_impl_list decls ~loc ~rec_flag =\n maybe_mutually_recursive\n decls\n ~loc\n ~rec_flag\n ~of_lazy:[%expr Base_quickcheck.Observer.of_lazy]\n ~impl:observer_impl\n;;\n\nlet shrinker_impl_list decls ~loc ~rec_flag =\n maybe_mutually_recursive\n decls\n ~loc\n ~rec_flag\n ~of_lazy:[%expr Base_quickcheck.Shrinker.of_lazy]\n ~impl:shrinker_impl\n;;\n\nlet intf type_decl ~f ~covar ~contravar =\n let covar = Longident.parse (\"Base_quickcheck.\" ^ covar ^ \".t\") in\n let contravar = Longident.parse (\"Base_quickcheck.\" ^ contravar ^ \".t\") in\n let type_decl = name_type_params_in_td type_decl in\n let loc = type_decl.ptype_loc in\n let name = loc_map type_decl.ptype_name ~f in\n let result =\n ptyp_constr\n ~loc\n { loc; txt = covar }\n [ ptyp_constr\n ~loc\n (lident_loc type_decl.ptype_name)\n (List.map type_decl.ptype_params ~f:fst)\n ]\n in\n let type_ =\n List.fold_right\n type_decl.ptype_params\n ~init:result\n ~f:(fun (core_type, (variance, injectivity)) result ->\n let id =\n match (variance, injectivity) with\n | ((NoVariance | Covariant), NoInjectivity) -> covar\n | (Contravariant, NoInjectivity) -> contravar\n | (_, Injective) -> Location.raise_errorf ~loc \"Injective type parameters aren't supported.\"\n in\n let arg = ptyp_constr ~loc { loc; txt = id } [ core_type ] in\n [%type: [%t arg] -> [%t result]])\n in\n psig_value ~loc (value_description ~loc ~name ~type_ ~prim:[])\n;;\n\nlet shrinker_intf = intf ~f:shrinker_name ~covar:\"Shrinker\" ~contravar:\"Shrinker\"\nlet generator_intf = intf ~f:generator_name ~covar:\"Generator\" ~contravar:\"Observer\"\nlet observer_intf = intf ~f:observer_name ~covar:\"Observer\" ~contravar:\"Generator\"\nlet generator_intf_list type_decl_list = List.map type_decl_list ~f:generator_intf\nlet observer_intf_list type_decl_list = List.map type_decl_list ~f:observer_intf\nlet shrinker_intf_list type_decl_list = List.map type_decl_list ~f:shrinker_intf\n\nlet sig_type_decl =\n Deriving.Generator.make_noarg (fun ~loc:_ ~path:_ (_, decls) ->\n generator_intf_list decls @ observer_intf_list decls @ shrinker_intf_list decls)\n;;\n\nlet str_type_decl =\n Deriving.Generator.make_noarg (fun ~loc ~path:_ (rec_flag, decls) ->\n let rec_flag = really_recursive rec_flag decls in\n generator_impl_list ~loc ~rec_flag decls\n @ observer_impl_list ~loc ~rec_flag decls\n @ shrinker_impl_list ~loc ~rec_flag decls)\n;;\n\nlet generator_extension ~loc:_ ~path:_ core_type =\n generator_of_core_type core_type ~gen_env:Environment.empty ~obs_env:Environment.empty\n;;\n\nlet observer_extension ~loc:_ ~path:_ core_type =\n observer_of_core_type core_type ~obs_env:Environment.empty ~gen_env:Environment.empty\n;;\n\nlet shrinker_extension ~loc:_ ~path:_ core_type =\n shrinker_of_core_type core_type ~env:Environment.empty\n;;\n","open! Base\nopen Ppxlib\nopen Ppx_quickcheck_expander\n\nlet (_ : Deriving.t) = Deriving.add \"quickcheck\" ~sig_type_decl ~str_type_decl\nlet (_ : Deriving.t) = Deriving.add \"quickcheck.generator\" ~extension:generator_extension\nlet (_ : Deriving.t) = Deriving.add \"quickcheck.observer\" ~extension:observer_extension\nlet (_ : Deriving.t) = Deriving.add \"quickcheck.shrinker\" ~extension:shrinker_extension\n","module Kimchi_backend_common = struct\n module Field = Kimchi_backend_common.Field\n module Scalar_challenge = Kimchi_backend_common.Scalar_challenge\nend\n\nmodule Field = Kimchi_backend_common.Field\n\nmodule Pasta = struct\n module Basic = Kimchi_pasta.Basic\n module Pallas_based_plonk = Kimchi_pasta.Pallas_based_plonk\n module Pasta = Kimchi_pasta.Pasta\n module Vesta_based_plonk = Kimchi_pasta.Vesta_based_plonk\nend\n","module Tick = struct\n include Kimchi_backend.Pasta.Vesta_based_plonk\n module Inner_curve = Kimchi_backend.Pasta.Pasta.Pallas\nend\n\nmodule Tock = struct\n include Kimchi_backend.Pasta.Pallas_based_plonk\n module Inner_curve = Kimchi_backend.Pasta.Pasta.Vesta\nend\n","(* Based on this paper. https://eprint.iacr.org/2019/403 *)\n\nopen Core_kernel\n\nmodule Spec = struct\n type 'f t = { b : 'f } [@@deriving bin_io]\nend\n\nmodule Params = struct\n type 'f t =\n { u : 'f\n ; fu : 'f\n ; sqrt_neg_three_u_squared_minus_u_over_2 : 'f\n ; sqrt_neg_three_u_squared : 'f\n ; inv_three_u_squared : 'f\n ; b : 'f\n }\n [@@deriving fields, bin_io]\n\n let spec { b; _ } = { Spec.b }\n\n let map\n { u\n ; fu\n ; sqrt_neg_three_u_squared_minus_u_over_2\n ; sqrt_neg_three_u_squared\n ; inv_three_u_squared\n ; b\n } ~f =\n { u = f u\n ; fu = f fu\n ; sqrt_neg_three_u_squared_minus_u_over_2 =\n f sqrt_neg_three_u_squared_minus_u_over_2\n ; sqrt_neg_three_u_squared = f sqrt_neg_three_u_squared\n ; inv_three_u_squared = f inv_three_u_squared\n ; b = f b\n }\n\n (* A deterministic function for constructing a valid choice of parameters for a\n given field. *)\n let create (type t) (module F : Field_intf.S_unchecked with type t = t)\n { Spec.b } =\n let open F in\n let first_map f =\n let rec go i = match f i with Some x -> x | None -> go (i + one) in\n go zero\n in\n let curve_eqn u = (u * u * u) + b in\n let u, fu =\n first_map (fun u ->\n let fu = curve_eqn u in\n if equal u zero || equal fu zero then None else Some (u, fu) )\n in\n let three_u_squared = u * u * of_int 3 in\n let sqrt_neg_three_u_squared = sqrt (negate three_u_squared) in\n { u\n ; fu\n ; sqrt_neg_three_u_squared_minus_u_over_2 =\n (sqrt_neg_three_u_squared - u) / of_int 2\n ; sqrt_neg_three_u_squared\n ; inv_three_u_squared = one / three_u_squared\n ; b\n }\nend\n\nmodule Make\n (Constant : Field_intf.S) (F : sig\n include Field_intf.S\n\n val constant : Constant.t -> t\n end) (P : sig\n val params : Constant.t Params.t\n end) =\nstruct\n open F\n open P\n\n let square x = x * x\n\n let potential_xs t =\n let t2 = t * t in\n let alpha =\n let alpha_inv = (t2 + constant params.fu) * t2 in\n one / alpha_inv\n in\n let x1 =\n let temp = square t2 * alpha * constant params.sqrt_neg_three_u_squared in\n constant params.sqrt_neg_three_u_squared_minus_u_over_2 - temp\n in\n let x2 = negate (constant params.u) - x1 in\n let x3 =\n let t2_plus_fu = t2 + constant params.fu in\n let t2_inv = alpha * t2_plus_fu in\n let temp =\n square t2_plus_fu * t2_inv * constant params.inv_three_u_squared\n in\n constant params.u - temp\n in\n (x1, x2, x3)\nend\n\nlet to_group (type t) (module F : Field_intf.S_unchecked with type t = t)\n ~params t =\n let module M =\n Make\n (F)\n (struct\n include F\n\n let constant = Fn.id\n end)\n (struct\n let params = params\n end)\n in\n let b = params.b in\n let try_decode x =\n let f x = F.((x * x * x) + b) in\n let y = f x in\n if F.is_square y then Some (x, F.sqrt y) else None\n in\n let x1, x2, x3 = M.potential_xs t in\n List.find_map [ x1; x2; x3 ] ~f:try_decode |> Option.value_exn\n\nlet%test_module \"test\" =\n ( module struct\n module Fp = struct\n include\n Snarkette.Fields.Make_fp\n (Snarkette.Nat)\n (struct\n let order =\n Snarkette.Nat.of_string\n \"5543634365110765627805495722742127385843376434033820803590214255538854698464778703795540858859767700241957783601153\"\n end)\n\n let b = of_int 7\n end\n\n module Make_tests (F : sig\n include Field_intf.S_unchecked\n\n val gen : t Quickcheck.Generator.t\n\n val b : t\n end) =\n struct\n module F = struct\n include F\n\n let constant = Fn.id\n end\n\n open F\n\n let params = Params.create (module F) { b }\n\n let curve_eqn u = (u * u * u) + params.b\n\n (* Filter the two points which cause the group-map to blow up. This\n is not an issue in practice because the points we feed into this function\n will be the output of poseidon, and thus (modeling poseidon as a random oracle)\n will not be either of those two points. *)\n let gen =\n Quickcheck.Generator.filter F.gen ~f:(fun t ->\n let t2 = t * t in\n let alpha_inv = (t2 + constant params.fu) * t2 in\n not (equal alpha_inv zero) )\n\n module M =\n Make (F) (F)\n (struct\n let params = params\n end)\n\n let%test_unit \"full map works\" =\n Quickcheck.test ~sexp_of:F.sexp_of_t gen ~f:(fun t ->\n let x, y = to_group (module F) ~params t in\n assert (equal (curve_eqn x) (y * y)) )\n end\n\n module T0 = Make_tests (Fp)\n end )\n","open Core_kernel\nopen Async_kernel\n\nlet autogen_path = \"/tmp/coda_cache_dir\"\n\nlet s3_install_path = \"/tmp/s3_cache_dir\"\n\nlet s3_keys_bucket_prefix =\n \"https://s3-us-west-2.amazonaws.com/snark-keys.o1test.net\"\n\nlet manual_install_path = \"/var/lib/coda\"\n\nlet brew_install_path = \"/usr/local/var/coda\"\n\nlet cache = []\n\nlet env_path = manual_install_path\n\nlet possible_paths base =\n List.map\n [ env_path\n ; brew_install_path\n ; s3_install_path\n ; autogen_path\n ; manual_install_path\n ] ~f:(fun d -> d ^ \"/\" ^ base)\n\nlet load_from_s3 _s3_bucket_prefix _s3_install_path ~logger:_ =\n Deferred.Or_error.fail (Error.createf \"Cannot load files from S3\")\n","(*\n\n This follows the approach of SvdW06 to construct a \"near injection\" from\n a field into an elliptic curve defined over that field. WB19 is also a useful\n reference that details several constructions which are more appropriate in other\n contexts.\n\n Fix an elliptic curve E given by y^2 = x^3 + ax + b over a field \"F\"\n Let f(x) = x^3 + ax + b.\n\n Define the variety V to be\n (x1, x2, x3, x4) : f(x1) f(x2) f(x3) = x4^2.\n\n By a not-too-hard we have a map `V -> E`. Thus, a map of type `F -> V` yields a\n map of type `F -> E` by composing.\n\n Our goal is to construct such a map of type `F -> V`. The paper SvdW06 constructs\n a family of such maps, defined by a collection of values which we'll term `params`.\n\n Define `params` to be the type of records of the form\n { u: F\n ; u_over_2: F\n ; projection_point: { z : F; y : F }\n ; conic_c: F\n ; a: F\n ; b: F }\n such that\n - a and b are the coefficients of our curve's defining equation.\n - u satisfies\n i. 0 <> 3/4 u^2 + a\n ii. 0 <> f(u)\n iii. -f(u) is not a square.\n - conic_c = 3/4 u^2 + a\n - {z; y} satisfy\n i. z^2 + conic_c * y^2 = -f(u)\n\n We will define a map of type `params -> (F -> V)`. Thus, fixing a choice of\n a value of type params, we obtain a map `F -> V` as desired.\n\nSvdW06: Shallue and van de Woestijne, \"Construction of rational points on elliptic curves over finite fields.\" Proc. ANTS 2006. https://works.bepress.com/andrew_shallue/1/download/\nWB19: Riad S. Wahby and Dan Boneh, Fast and simple constant-time hashing to the BLS12-381 elliptic curve. https://eprint.iacr.org/2019/403\n*)\n\n(* we have φ(t) : F -> S\n and φ1(λ) : S -> V with\n V(F) : f(x1)f(x2)f(x3) = x4^2,\n (f is y^2 = x^3 + Bx + C)) (note choice of constant names\n -- A is coeff of x^2 so A = 0 for us)\n\n To construct a rational point on V(F), the authors define\n the surface S(F) and the rational map φ1:S(F)→ V(F), which\n is invertible on its image [SvdW06, Lemma 6]:\n S(F) : y^2(u^2 + uv + v^2 + a) = −f(u)\n\n φ(t) : t → ( u, α(t)/β(t) - u/2, β(t) )\n φ1: (u, v, y) → ( v, −u − v, u + y^2,\n f(u + y^2)·(y^2 + uv + v^2 + ay)/y )\n*)\n\nopen Core_kernel\nmodule Field_intf = Field_intf\nmodule Bw19 = Bw19\n\nlet ( = ) = `Don't_use_polymorphic_compare\n\nlet _ = ( = )\n\nmodule Intf (F : sig\n type t\nend) =\nstruct\n module type S = sig\n val to_group : F.t -> F.t * F.t\n end\nend\n\nmodule type S = sig\n module Spec : sig\n type _ t [@@deriving bin_io]\n end\n\n module Params : sig\n type 'f t [@@deriving bin_io]\n\n val map : 'a t -> f:('a -> 'b) -> 'b t\n\n val spec : 'f t -> 'f Spec.t\n\n val create :\n (module Field_intf.S_unchecked with type t = 'f) -> 'f Spec.t -> 'f t\n end\n\n module Make\n (Constant : Field_intf.S) (F : sig\n include Field_intf.S\n\n val constant : Constant.t -> t\n end) (Params : sig\n val params : Constant.t Params.t\n end) : sig\n val potential_xs : F.t -> F.t * F.t * F.t\n end\n\n val to_group :\n (module Field_intf.S_unchecked with type t = 'f)\n -> params:'f Params.t\n -> 'f\n -> 'f * 'f\nend\n\nmodule Conic = struct\n type 'f t = { z : 'f; y : 'f } [@@deriving bin_io]\n\n let map { z; y } ~f = { z = f z; y = f y }\nend\n\nmodule S = struct\n (* S = S(u, v, y) : y^2(u^2 + uv + v^2 + a) = −f(u)\n from (12)\n *)\n type 'f t = { u : 'f; v : 'f; y : 'f }\nend\n\nmodule V = struct\n (* V = V(x1, x2, x3, x4) : f(x1)f(x2)f(x3) = x4^2\n from (8)\n *)\n type 'f t = 'f * 'f * 'f * 'f\nend\n\nmodule Spec = struct\n type 'f t = { a : 'f; b : 'f } [@@deriving fields, bin_io]\nend\n\nmodule Params = struct\n type 'f t =\n { u : 'f\n ; u_over_2 : 'f\n ; projection_point : 'f Conic.t\n ; conic_c : 'f\n ; spec : 'f Spec.t\n }\n [@@deriving fields, bin_io]\n\n let map { u; u_over_2; projection_point; conic_c; spec = { a; b } } ~f =\n { u = f u\n ; u_over_2 = f u_over_2\n ; projection_point = Conic.map ~f projection_point\n ; conic_c = f conic_c\n ; spec = { a = f a; b = f b }\n }\n\n (* A deterministic function for constructing a valid choice of parameters for a\n given field.\n\n We start by finding the first `u` satisfying the constraints described above,\n then find the first `y` satisyfing the condition described above. The other\n values are derived from these two choices*.\n\n *Actually we have one bit of freedom in choosing `z` as z = sqrt(conic_c y^2 - conic_d),\n since there are two square roots.\n *)\n\n let create (type t) (module F : Field_intf.S_unchecked with type t = t)\n ({ Spec.a; b } as spec) =\n let open F in\n let first_map f =\n let rec go i = match f i with Some x -> x | None -> go (i + one) in\n go zero\n in\n let first f = first_map (fun x -> Option.some_if (f x) x) in\n let three_fourths = of_int 3 / of_int 4 in\n let curve_eqn u = (u * u * u) + (a * u) + b in\n let u =\n first (fun u ->\n (* from (15), A = 0, B = Params.a *)\n let check = (three_fourths * u * u) + a in\n let fu = curve_eqn u in\n (not (equal check zero))\n && (not (equal fu zero))\n && not (is_square (negate fu))\n (* imeckler: I added this condition. It prevents the possibility of having\n a point (z, 0) on the conic, which is useful because in the map from the\n conic to S we divide by the \"y\" coordinate of the conic. It's not strictly\n necessary when we have a random input in a large field, but it is still nice to avoid the\n bad case in theory (and for the tests below with a small field). *) )\n in\n (* The coefficients defining the conic z^2 + c y^2 = d\n in (15). *)\n let conic_c = (three_fourths * u * u) + a in\n let conic_d = negate (curve_eqn u) in\n let projection_point =\n first_map (fun y ->\n let z2 = conic_d - (conic_c * y * y) in\n if F.is_square z2 then Some { Conic.z = F.sqrt z2; y } else None )\n in\n { u; u_over_2 = u / of_int 2; conic_c; projection_point; spec }\nend\n\nmodule Make\n (Constant : Field_intf.S) (F : sig\n include Field_intf.S\n\n val constant : Constant.t -> t\n end) (P : sig\n val params : Constant.t Params.t\n end) =\nstruct\n open F\n\n (* For a curve z^2 + c y^2 = d and a point (z0, y0) on the curve, there\n is one other point on the curve which is also on the line through (z0, y0)\n with slope t. This function returns that point. *)\n let field_to_conic t =\n let z0, y0 =\n ( constant P.params.projection_point.z\n , constant P.params.projection_point.y )\n in\n let ct = constant P.params.conic_c * t in\n let s = of_int 2 * ((ct * y0) + z0) / ((ct * t) + one) in\n { Conic.z = z0 - s; y = y0 - (s * t) }\n\n (* From (16) : φ(λ) : F → S : λ → ( u, α(λ)/β(λ) - u/2, β(λ) ) *)\n let conic_to_s { Conic.z; y } =\n { S.u = constant P.params.u\n ; v = (z / y) - constant P.params.u_over_2 (* From (16) *)\n ; y\n }\n\n (* This is here for explanatory purposes. See s_to_v_truncated. *)\n let _s_to_v { S.u; v; y } : _ V.t =\n let curve_eqn x =\n (x * x * x) + (constant P.params.spec.a * x) + constant P.params.spec.b\n in\n let h = (u * u) + (u * v) + (v * v) + constant P.params.spec.a in\n (v, negate (u + v), u + (y * y), curve_eqn (u + (y * y)) * h / y)\n\n (* from (13) *)\n\n (* We don't actually need to compute the final coordinate in V *)\n let s_to_v_truncated { S.u; v; y } = (v, negate (u + v), u + (y * y))\n\n let potential_xs =\n let ( @ ) = Fn.compose in\n s_to_v_truncated @ conic_to_s @ field_to_conic\nend\n\nlet to_group (type t) (module F : Field_intf.S_unchecked with type t = t)\n ~params t =\n let module M =\n Make\n (F)\n (struct\n include F\n\n let constant = Fn.id\n end)\n (struct\n let params = params\n end)\n in\n let { Spec.a; b } = params.spec in\n let try_decode x =\n let f x = F.((x * x * x) + (a * x) + b) in\n let y = f x in\n if F.is_square y then Some (x, F.sqrt y) else None\n in\n let x1, x2, x3 = M.potential_xs t in\n List.find_map [ x1; x2; x3 ] ~f:try_decode |> Option.value_exn\n\nlet%test_module \"test\" =\n ( module struct\n module Fp = struct\n include\n Snarkette.Fields.Make_fp\n (Snarkette.Nat)\n (struct\n let order = Snarkette.Nat.of_int 100003\n end)\n\n let a = of_int 1\n\n let b = of_int 3\n end\n\n module F13 = struct\n type t = int [@@deriving sexp]\n\n let p = 13\n\n let ( + ) x y = (x + y) mod p\n\n let ( * ) x y = x * y mod p\n\n let negate x = (p - x) mod p\n\n let ( - ) x y = (x - y + p) mod p\n\n let equal = Int.equal\n\n let ( / ) x y =\n let rec go i = if equal x (i * y) then i else go (i + 1) in\n if equal y 0 then failwith \"Divide by 0\" else go 1\n\n let sqrt' x =\n let rec go i =\n if Int.equal i p then None\n else if equal (i * i) x then Some i\n else go Int.(i + 1)\n in\n go 0\n\n let sqrt x = Option.value_exn (sqrt' x)\n\n let is_square x = Option.is_some (sqrt' x)\n\n let zero = 0\n\n let one = 1\n\n let of_int = Fn.id\n\n let gen = Int.gen_incl 0 Int.(p - 1)\n\n let a = 1\n\n let b = 3\n end\n\n module Make_tests (F : sig\n include Field_intf.S_unchecked\n\n val gen : t Quickcheck.Generator.t\n\n val a : t\n\n val b : t\n end) =\n struct\n module F = struct\n include F\n\n let constant = Fn.id\n end\n\n open F\n\n let params = Params.create (module F) { a; b }\n\n let curve_eqn u = (u * u * u) + (params.spec.a * u) + params.spec.b\n\n let conic_d =\n let open F in\n negate (curve_eqn params.u)\n\n let on_conic { Conic.z; y } =\n F.(equal ((z * z) + (params.conic_c * y * y)) conic_d)\n\n let on_s { S.u; v; y } =\n F.(equal conic_d (y * y * ((u * u) + (u * v) + (v * v) + a)))\n\n let on_v (x1, x2, x3, x4) =\n F.(equal (curve_eqn x1 * curve_eqn x2 * curve_eqn x3) (x4 * x4))\n\n (* Filter the two points which cause the group-map to blow up. This\n is not an issue in practice because the points we feed into this function\n will be the output of blake2s, and thus (modeling blake2s as a random oracle)\n will not be either of those two points. *)\n let gen =\n Quickcheck.Generator.filter F.gen ~f:(fun t ->\n not F.(equal ((params.conic_c * t * t) + one) zero) )\n\n module M =\n Make (F) (F)\n (struct\n let params = params\n end)\n\n let%test \"projection point well-formed\" = on_conic params.projection_point\n\n let%test_unit \"field-to-conic\" =\n Quickcheck.test ~sexp_of:F.sexp_of_t gen ~f:(fun t ->\n assert (on_conic (M.field_to_conic t)) )\n\n let%test_unit \"conic-to-S\" =\n let conic_gen =\n Quickcheck.Generator.filter_map F.gen ~f:(fun y ->\n let z2 = conic_d - (params.conic_c * y * y) in\n if is_square z2 then Some { Conic.z = sqrt z2; y } else None )\n in\n Quickcheck.test conic_gen ~f:(fun p -> assert (on_s (M.conic_to_s p)))\n\n let%test_unit \"field-to-S\" =\n Quickcheck.test ~sexp_of:F.sexp_of_t gen ~f:(fun t ->\n assert (on_s (Fn.compose M.conic_to_s M.field_to_conic t)) )\n\n (* Schwarz-zippel says if this tests succeeds once, then the probability that\n the implementation is correct is at least 1 - (D / field-size), where D is\n the total degree of the polynomial defining_equation_of_V(s_to_v(t)) which should\n be less than, say, 10. So, this test succeeding gives good evidence of the\n correctness of the implementation (assuming that the implementation is just a\n polynomial, which it is by parametricity!) *)\n let%test_unit \"field-to-V\" =\n Quickcheck.test ~sexp_of:F.sexp_of_t gen ~f:(fun t ->\n let s = M.conic_to_s (M.field_to_conic t) in\n assert (on_v (M._s_to_v s)) )\n\n let%test_unit \"full map works\" =\n Quickcheck.test ~sexp_of:F.sexp_of_t gen ~f:(fun t ->\n let x, y = to_group (module F) ~params t in\n assert (equal (curve_eqn x) (y * y)) )\n end\n\n module T0 = Make_tests (F13)\n module T1 = Make_tests (Fp)\n end )\n","(*\n * Copyright (c) 2006-2009 Citrix Systems Inc.\n * Copyright (c) 2010 Thomas Gazagnaire \n * Copyright (c) 2014-2016 Anil Madhavapeddy \n * Copyright (c) 2016 David Kaloper Meršinjak\n * Copyright (c) 2018 Romain Calascibetta \n *\n * Permission to use, copy, modify, and distribute this software for any\n * purpose with or without fee is hereby granted, provided that the above\n * copyright notice and this permission notice appear in all copies.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES\n * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF\n * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR\n * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES\n * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN\n * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF\n * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.\n *\n *)\n\ntype alphabet =\n { emap : int array\n ; dmap : int array }\n\ntype sub = string * int * int\n\nlet (//) x y =\n if y < 1 then raise Division_by_zero ;\n if x > 0 then 1 + ((x - 1) / y) else 0\n[@@inline]\n\nlet unsafe_get_uint8 t off = Char.code (String.unsafe_get t off)\nlet unsafe_set_uint8 t off v = Bytes.unsafe_set t off (Char.chr v)\nlet unsafe_set_uint16 = Unsafe.unsafe_set_uint16\n\nexternal unsafe_get_uint16 : string -> int -> int = \"%caml_string_get16u\" [@@noalloc]\nexternal swap16 : int -> int = \"%bswap16\" [@@noalloc]\n\nlet none = (-1)\n\n(* We mostly want to have an optional array for [dmap] (e.g. [int option\n array]). So we consider the [none] value as [-1]. *)\n\nlet make_alphabet alphabet =\n if String.length alphabet <> 64 then invalid_arg \"Length of alphabet must be 64\" ;\n if String.contains alphabet '=' then invalid_arg \"Alphabet can not contain padding character\" ;\n let emap = Array.init (String.length alphabet) (fun i -> Char.code (String.get alphabet i)) in\n let dmap = Array.make 256 none in\n String.iteri (fun idx chr -> Array.set dmap (Char.code chr) idx) alphabet ;\n { emap; dmap; }\n\nlet length_alphabet { emap; _ } = Array.length emap\nlet alphabet { emap; _ } = emap\n\nlet default_alphabet = make_alphabet \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\"\nlet uri_safe_alphabet = make_alphabet \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_\"\n\nlet unsafe_set_be_uint16 =\n if Sys.big_endian\n then fun t off v -> unsafe_set_uint16 t off v\n else fun t off v -> unsafe_set_uint16 t off (swap16 v)\n\n(* We make this exception to ensure to keep a control about which exception we\n can raise and avoid appearance of unknown exceptions like an ex-nihilo\n magic rabbit (or magic money?). *)\nexception Out_of_bounds\nexception Too_much_input\n\nlet get_uint8 t off =\n if off < 0 || off >= String.length t then raise Out_of_bounds ;\n unsafe_get_uint8 t off\n\nlet padding = int_of_char '='\n\nlet error_msgf fmt = Format.ksprintf (fun err -> Error (`Msg err)) fmt\n\nlet encode_sub pad { emap; _ } ?(off = 0) ?len input =\n let len = match len with\n | Some len -> len\n | None -> String.length input - off in\n\n if len < 0 || off < 0 || off > String.length input - len\n then error_msgf \"Invalid bounds\"\n else\n let n = len in\n let n' = n // 3 * 4 in\n let res = Bytes.create n' in\n\n let emap i = Array.unsafe_get emap i in\n\n let emit b1 b2 b3 i =\n unsafe_set_be_uint16 res i\n ((emap (b1 lsr 2 land 0x3f) lsl 8)\n lor (emap ((b1 lsl 4) lor (b2 lsr 4) land 0x3f))) ;\n unsafe_set_be_uint16 res (i + 2)\n ((emap ((b2 lsl 2) lor (b3 lsr 6) land 0x3f) lsl 8)\n lor (emap (b3 land 0x3f))) in\n\n let rec enc j i =\n if i = n then ()\n else if i = n - 1\n then emit (unsafe_get_uint8 input (off + i)) 0 0 j\n else if i = n - 2\n then emit (unsafe_get_uint8 input (off + i)) (unsafe_get_uint8 input (off + i + 1)) 0 j\n else\n (emit\n (unsafe_get_uint8 input (off + i))\n (unsafe_get_uint8 input (off + i + 1))\n (unsafe_get_uint8 input (off + i + 2))\n j ;\n enc (j + 4) (i + 3)) in\n\n let rec unsafe_fix = function\n | 0 -> ()\n | i -> unsafe_set_uint8 res (n' - i) padding ; unsafe_fix (i - 1) in\n\n enc 0 0 ;\n\n let pad_to_write = ((3 - n mod 3) mod 3) in\n\n if pad\n then begin unsafe_fix pad_to_write ; Ok (Bytes.unsafe_to_string res, 0, n') end\n else Ok (Bytes.unsafe_to_string res, 0, (n' - pad_to_write))\n(* [pad = false], we don't want to write them. *)\n\nlet encode ?(pad = true) ?(alphabet = default_alphabet) ?off ?len input =\n match encode_sub pad alphabet ?off ?len input with\n | Ok (res, off, len) -> Ok (String.sub res off len)\n | Error _ as err -> err\n\nlet encode_string ?pad ?alphabet input =\n match encode ?pad ?alphabet input with\n | Ok res -> res\n | Error _ -> assert false\n\nlet encode_sub ?(pad = true) ?(alphabet = default_alphabet) ?off ?len input =\n encode_sub pad alphabet ?off ?len input\n\nlet encode_exn ?pad ?alphabet ?off ?len input =\n match encode ?pad ?alphabet ?off ?len input with\n | Ok v -> v\n | Error (`Msg err) -> invalid_arg err\n\nlet decode_sub ?(pad = true) { dmap; _ } ?(off = 0) ?len input =\n let len = match len with\n | Some len -> len\n | None -> String.length input - off in\n\n if len < 0 || off < 0 || off > String.length input - len\n then error_msgf \"Invalid bounds\"\n else\n\n let n = (len // 4) * 4 in\n let n' = (n // 4) * 3 in\n let res = Bytes.create n' in\n let invalid_pad_overflow = pad in\n\n let get_uint8_or_padding =\n if pad then (fun t i -> if i >= len then raise Out_of_bounds ; get_uint8 t (off + i) )\n else (fun t i -> try if i < len then get_uint8 t (off + i) else padding with Out_of_bounds -> padding ) in\n\n let set_be_uint16 t off v =\n (* can not write 2 bytes. *)\n if off < 0 || off + 1 > Bytes.length t then ()\n (* can not write 1 byte but can write 1 byte *)\n else if off < 0 || off + 2 > Bytes.length t then unsafe_set_uint8 t off (v lsr 8)\n (* can write 2 bytes. *)\n else unsafe_set_be_uint16 t off v in\n\n let set_uint8 t off v =\n if off < 0 || off >= Bytes.length t then ()\n else unsafe_set_uint8 t off v in\n\n let emit a b c d j =\n let x = (a lsl 18) lor (b lsl 12) lor (c lsl 6) lor d in\n set_be_uint16 res j (x lsr 8) ;\n set_uint8 res (j + 2) (x land 0xff) in\n\n let dmap i =\n let x = Array.unsafe_get dmap i in\n if x = none then raise Not_found ; x in\n\n let only_padding pad idx =\n\n (* because we round length of [res] to the upper bound of how many\n characters we should have from [input], we got at this stage only padding\n characters and we need to delete them, so for each [====], we delete 3\n bytes. *)\n\n let pad = ref (pad + 3) in\n let idx = ref idx in\n\n while !idx + 4 < len do\n (* use [unsafe_get_uint16] instead [unsafe_get_uint32] to avoid allocation\n of [int32]. Of course, [3d3d3d3d] is [====]. *)\n if unsafe_get_uint16 input (off + !idx) <> 0x3d3d\n || unsafe_get_uint16 input (off + !idx + 2) <> 0x3d3d\n then raise Not_found ;\n (* We got something bad, should be a valid character according to\n [alphabet] but outside the scope. *)\n\n idx := !idx + 4 ;\n pad := !pad + 3 ;\n done ;\n while !idx < len do\n if unsafe_get_uint8 input (off + !idx) <> padding\n then raise Not_found ;\n\n incr idx ;\n done ; !pad in\n\n let rec dec j i =\n if i = n then 0\n else begin\n let (d, pad) =\n let x = get_uint8_or_padding input (i + 3) in\n try (dmap x, 0) with Not_found when x = padding -> (0, 1) in\n (* [Not_found] iff [x ∉ alphabet and x <> '='] can leak. *)\n let (c, pad) =\n let x = get_uint8_or_padding input (i + 2) in\n try (dmap x, pad) with Not_found when x = padding && pad = 1 -> (0, 2) in\n (* [Not_found] iff [x ∉ alphabet and x <> '='] can leak. *)\n let (b, pad) =\n let x = get_uint8_or_padding input (i + 1) in\n try (dmap x, pad) with Not_found when x = padding && pad = 2 -> (0, 3) in\n (* [Not_found] iff [x ∉ alphabet and x <> '='] can leak. *)\n let (a, pad) =\n let x = get_uint8_or_padding input i in\n try (dmap x, pad) with Not_found when x = padding && pad = 3 -> (0, 4) in\n (* [Not_found] iff [x ∉ alphabet and x <> '='] can leak. *)\n\n emit a b c d j ;\n\n if i + 4 = n\n (* end of input in anyway *)\n then match pad with\n | 0 ->\n 0\n | 4 ->\n (* assert (invalid_pad_overflow = false) ; *)\n 3\n (* [get_uint8] lies and if we get [4], that mean we got one or more (at\n most 4) padding character. In this situation, because we round length\n of [res] (see [n // 4]), we need to delete 3 bytes. *)\n | pad ->\n pad\n else match pad with\n | 0 -> dec (j + 3) (i + 4)\n | 4 ->\n (* assert (invalid_pad_overflow = false) ; *)\n only_padding 3 (i + 4)\n (* Same situation than above but we should get only more padding\n characters then. *)\n | pad ->\n if invalid_pad_overflow = true then raise Too_much_input ;\n only_padding pad (i + 4) end in\n\n match dec 0 0 with\n | 0 -> Ok (Bytes.unsafe_to_string res, 0, n')\n | pad -> Ok (Bytes.unsafe_to_string res, 0, (n' - pad))\n | exception Out_of_bounds -> error_msgf \"Wrong padding\"\n (* appear only when [pad = true] and when length of input is not a multiple of 4. *)\n | exception Not_found ->\n (* appear when one character of [input] ∉ [alphabet] and this character <> '=' *)\n error_msgf \"Malformed input\"\n | exception Too_much_input ->\n error_msgf \"Too much input\"\n\nlet decode ?pad ?(alphabet = default_alphabet) ?off ?len input =\n match decode_sub ?pad alphabet ?off ?len input with\n | Ok (res, off, len) -> Ok (String.sub res off len)\n | Error _ as err -> err\n\nlet decode_sub ?pad ?(alphabet = default_alphabet) ?off ?len input =\n decode_sub ?pad alphabet ?off ?len input\n\nlet decode_exn ?pad ?alphabet ?off ?len input =\n match decode ?pad ?alphabet ?off ?len input with\n | Ok res -> res\n | Error (`Msg err) -> invalid_arg err\n","open Core_kernel\n\nmodule Aux (Impl : Snarky_backendless.Snark_intf.Run) = struct\n open Impl\n\n let non_residue : Field.Constant.t Lazy.t =\n let open Field.Constant in\n let rec go i = if not (is_square i) then i else go (i + one) in\n lazy (go (of_int 2))\n\n let sqrt_exn x =\n let y =\n exists Field.typ ~compute:(fun () ->\n Field.Constant.sqrt (As_prover.read_var x) )\n in\n assert_square y x ; y\n\n (* let sqrt_flagged : Field.t -> Field.t * Boolean.var = *)\n let sqrt_flagged x =\n (*\n imeckler: I learned this trick from Dan Boneh\n\n m a known non residue\n\n exists is_square : bool, y.\n if is_square then assert y*y = x else assert y*y = m * x\n\n <=>\n\n assert (y*y = if is_square then x else m * x)\n *)\n let is_square =\n exists Boolean.typ ~compute:(fun () ->\n Field.Constant.is_square (As_prover.read_var x) )\n in\n let m = Lazy.force non_residue in\n (sqrt_exn (Field.if_ is_square ~then_:x ~else_:(Field.scale x m)), is_square)\nend\n\nlet wrap (type f) ((module Impl) : f Snarky_backendless.Snark0.m) ~potential_xs\n ~y_squared =\n let open Impl in\n let module A = Aux (Impl) in\n let open A in\n stage (fun x ->\n let x1, x2, x3 = potential_xs x in\n let y1, b1 = sqrt_flagged (y_squared ~x:x1)\n and y2, b2 = sqrt_flagged (y_squared ~x:x2)\n and y3, b3 = sqrt_flagged (y_squared ~x:x3) in\n Boolean.Assert.any [ b1; b2; b3 ] ;\n let x1_is_first = (b1 :> Field.t)\n and x2_is_first = (Boolean.((not b1) && b2) :> Field.t)\n and x3_is_first = (Boolean.((not b1) && (not b2) && b3) :> Field.t) in\n ( Field.((x1_is_first * x1) + (x2_is_first * x2) + (x3_is_first * x3))\n , Field.((x1_is_first * y1) + (x2_is_first * y2) + (x3_is_first * y3)) ) )\n\nmodule Make\n (M : Snarky_backendless.Snark_intf.Run) (P : sig\n val params : M.field Group_map.Params.t\n end) =\nstruct\n open P\n include Group_map.Make (M.Field.Constant) (M.Field) (P)\n open M\n\n let to_group =\n let { Group_map.Spec.a; b } = Group_map.Params.spec params in\n unstage\n (wrap\n (module M)\n ~potential_xs\n ~y_squared:Field.(fun ~x -> (x * x * x) + scale x a + constant b) )\nend\n","open Core_kernel\nmodule Params = Group_map.Params\n\nlet to_group (type t)\n (module F : Group_map.Field_intf.S_unchecked with type t = t) ~params t =\n let module M =\n Group_map.Make\n (F)\n (struct\n include F\n\n let constant = Fn.id\n end)\n (struct\n let params = params\n end)\n in\n let { Group_map.Spec.a; b } = Params.spec params in\n let try_decode x =\n let f x = F.((x * x * x) + (a * x) + b) in\n let y = f x in\n if F.is_square y then Some (x, F.sqrt y) else None\n in\n let x1, x2, x3 = M.potential_xs t in\n List.find_map [ x1; x2; x3 ] ~f:try_decode |> Option.value_exn\n\nmodule Checked = struct\n open Snarky_backendless\n\n let wrap = Checked_map.wrap\n\n let to_group (type f) (module M : Snark_intf.Run with type field = f) ~params\n t =\n let module G =\n Checked_map.Make\n (M)\n (struct\n let params = params\n end)\n in\n G.to_group t\nend\n","open Core_kernel\nopen Pickles_types\n\nmodule Constant = struct\n type t = int\nend\n\n(* TODO: Optimization(?) Have this have length n - 1 since the last one is\n determined by the remaining ones. *)\ntype ('f, 'n) t =\n ('f Snarky_backendless.Cvar.t Snarky_backendless.Boolean.t, 'n) Vector.t\n\nmodule T (Impl : Snarky_backendless.Snark_intf.Run) = struct\n type nonrec 'n t = (Impl.field, 'n) t\nend\n\nmodule Make (Impl : Snarky_backendless.Snark_intf.Run) = struct\n module Constant = Constant\n open Impl\n include T (Impl)\n\n let of_index i ~length =\n let v = Vector.init length ~f:(fun j -> Field.equal (Field.of_int j) i) in\n Boolean.Assert.any (Vector.to_list v) ;\n v\n\n let of_vector_unsafe = Fn.id\n\n let typ (n : 'n Nat.t) : ('n t, Constant.t) Typ.t =\n let (Typ typ) = Vector.typ Boolean.typ n in\n let typ : _ Typ.t =\n Typ\n { typ with\n check =\n (fun x ->\n Impl.Internal_Basic.Checked.bind (typ.check x) ~f:(fun () ->\n make_checked (fun () ->\n Boolean.Assert.exactly_one (Vector.to_list x) ) ) )\n }\n in\n Typ.transport typ\n ~there:(fun i -> Vector.init n ~f:(( = ) i))\n ~back:(fun v ->\n let i, _ =\n List.findi (Vector.to_list v) ~f:(fun _ b -> b) |> Option.value_exn\n in\n i )\nend\n","open Core_kernel\n\n[%%versioned\nmodule Stable = struct\n module V2 = struct\n type t = { h : Domain.Stable.V1.t }\n [@@deriving fields, sexp, compare, yojson]\n\n let to_latest = Fn.id\n end\nend]\n","open Core_kernel\nopen Pickles_types\n\nmodule T (Impl : Snarky_backendless.Snark_intf.Run) (N : Vector.Nat_intf) =\nstruct\n open Impl\n\n type t = Field.t\n\n let length = 64 * Nat.to_int N.n\n\n module Constant = Constant.Make (N)\n\n let typ : (Field.t, Constant.t) Typ.t =\n Typ.field\n |> Typ.transport\n ~there:(fun x -> Field.Constant.project (Constant.to_bits x))\n ~back:(fun x ->\n Constant.of_bits (List.take (Field.Constant.unpack x) length) )\nend\n","open Pickles_types\n\ntype 'f t = 'f Snarky_backendless.Cvar.t\n\nmodule Constant = Constant.Make (Nat.N2)\n\nmodule type S = sig\n module Impl : Snarky_backendless.Snark_intf.Run\n\n open Impl\n\n type nonrec t = field t\n\n module Constant : sig\n type t = Constant.t [@@deriving sexp_of]\n\n val to_bits : t -> bool list\n\n val of_bits : bool list -> t\n\n val dummy : t\n end\n\n val typ : (t, Constant.t) Typ.t\n\n val length : int\nend\n\nmodule Make (Impl : Snarky_backendless.Snark_intf.Run) :\n S with module Impl := Impl =\n Make.T (Impl) (Nat.N2)\n","open Pickles_types\nopen Core_kernel\nmodule Limbs = Nat.N4\n\nmodule Constant = struct\n include Limb_vector.Constant.Make (Limbs)\n\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n type t =\n Limb_vector.Constant.Hex64.Stable.V1.t Vector.Vector_4.Stable.V1.t\n [@@deriving compare, sexp, yojson, hash, equal]\n\n let to_latest = Fn.id\n end\n end]\n\n (* Force the typechecker to verify that these types are equal. *)\n let (_ : (t, Stable.Latest.t) Type_equal.t) = Type_equal.T\n\n open Backend\n\n let to_tick_field x = Tick.Field.of_bits (to_bits x)\n\n let to_tock_field x = Tock.Field.of_bits (to_bits x)\n\n let of_tick_field x = of_bits (Tick.Field.to_bits x)\nend\n\nmodule Make (Impl : Snarky_backendless.Snark_intf.Run) = struct\n open Impl\n\n type t = Field.t\n\n let to_bits = Field.choose_preimage_var ~length:Field.size_in_bits\n\n module Unsafe = struct\n let to_bits_unboolean x =\n with_label __LOC__ (fun () ->\n let length = Field.size_in_bits in\n let res =\n exists\n (Typ.list Boolean.typ_unchecked ~length)\n ~compute:As_prover.(fun () -> Field.Constant.unpack (read_var x))\n in\n Field.Assert.equal x (Field.project res) ;\n res )\n end\n\n let () = assert (Field.size_in_bits < 64 * Nat.to_int Limbs.n)\n\n module Constant = struct\n include Constant\n\n let to_bits x = List.take (to_bits x) Field.size_in_bits\n end\n\n let typ =\n Typ.transport Field.typ\n ~there:(Fn.compose Field.Constant.project Constant.to_bits)\n ~back:(Fn.compose Constant.of_bits Field.Constant.unpack)\nend\n","module D = Digest\nopen Core_kernel\nopen Pickles_types\nopen Hlist\nmodule Sc = Kimchi_backend_common.Scalar_challenge\n\ntype 'f impl = (module Snarky_backendless.Snark_intf.Run with type field = 'f)\n\ntype ('a, 'b, 'c) basic =\n | Unit : (unit, unit, < .. >) basic\n | Field\n : ('field1, 'field2, < field1 : 'field1 ; field2 : 'field2 ; .. >) basic\n | Bool : ('bool1, 'bool2, < bool1 : 'bool1 ; bool2 : 'bool2 ; .. >) basic\n | Digest\n : ( 'digest1\n , 'digest2\n , < digest1 : 'digest1 ; digest2 : 'digest2 ; .. > )\n basic\n | Challenge\n : ( 'challenge1\n , 'challenge2\n , < challenge1 : 'challenge1 ; challenge2 : 'challenge2 ; .. > )\n basic\n | Bulletproof_challenge\n : ( 'bp_chal1\n , 'bp_chal2\n , < bulletproof_challenge1 : 'bp_chal1\n ; bulletproof_challenge2 : 'bp_chal2\n ; .. > )\n basic\n | Branch_data\n : ( 'branch_data1\n , 'branch_data2\n , < branch_data1 : 'branch_data1 ; branch_data2 : 'branch_data2 ; .. >\n )\n basic\n\nmodule type Bool_intf = sig\n type var\n\n val true_ : var\n\n val false_ : var\nend\n\nmodule rec T : sig\n type (_, _, _) t =\n | B : ('a, 'b, 'env) basic -> ('a, 'b, 'env) t\n | Scalar :\n ('a, 'b, (< challenge1 : 'a ; challenge2 : 'b ; .. > as 'env)) basic\n -> ('a Sc.t, 'b Sc.t, 'env) t\n | Vector :\n ('t1, 't2, 'env) t * 'n Nat.t\n -> (('t1, 'n) Vector.t, ('t2, 'n) Vector.t, 'env) t\n | Array : ('t1, 't2, 'env) t * int -> ('t1 array, 't2 array, 'env) t\n | Struct :\n ('xs1, 'xs2, 'env) H2_1.T(T).t\n -> ('xs1 Hlist.HlistId.t, 'xs2 Hlist.HlistId.t, 'env) t\n | Opt :\n { inner : ('a1, 'a2, (< bool1 : bool ; bool2 : 'bool ; .. > as 'env)) t\n ; flag : Plonk_types.Opt.Flag.t\n ; dummy1 : 'a1\n ; dummy2 : 'a2\n ; bool : (module Bool_intf with type var = 'bool)\n }\n -> ('a1 option, ('a2, 'bool) Plonk_types.Opt.t, 'env) t\n | Opt_unflagged :\n { inner : ('a1, 'a2, (< bool1 : bool ; bool2 : 'bool ; .. > as 'env)) t\n ; flag : Plonk_types.Opt.Flag.t\n ; dummy1 : 'a1\n ; dummy2 : 'a2\n }\n -> ('a1 option, 'a2 option, 'env) t\n | Constant : 'a * ('a -> 'a -> unit) * ('a, 'b, 'env) t -> ('a, 'b, 'env) t\nend =\n T\n\ntype ('scalar, 'env) pack =\n { pack : 'a 'b. ('a, 'b, 'env) basic -> 'a option -> 'b -> 'scalar array }\n\nlet rec pack :\n type t v env.\n zero:'scalar\n -> one:'scalar\n -> ('scalar, env) pack\n -> (t, v, env) T.t\n -> t option\n -> v\n -> 'scalar array =\n fun ~zero ~one p spec t_constant_opt t ->\n match spec with\n | B spec ->\n p.pack spec t_constant_opt t\n | Scalar chal ->\n let t_constant_opt =\n Option.map t_constant_opt ~f:(fun { Sc.inner = x } -> x)\n in\n let { Sc.inner = t } = t in\n p.pack chal t_constant_opt t\n | Vector (spec, _) ->\n let t_constant_opt = Option.map ~f:Vector.to_array t_constant_opt in\n let t = Vector.to_array t in\n pack ~zero ~one p (Array (spec, Array.length t)) t_constant_opt t\n | Struct [] ->\n [||]\n | Struct (spec :: specs) ->\n let (hd :: tl) = t in\n let hd_constant_opt, tl_constant_opt =\n match t_constant_opt with\n | None ->\n (None, None)\n | Some (hd :: tl) ->\n (Some hd, Some tl)\n in\n let hd = pack ~zero ~one p spec hd_constant_opt hd in\n Array.append hd (pack ~zero ~one p (Struct specs) tl_constant_opt tl)\n | Array (spec, _) ->\n Array.concat_mapi t ~f:(fun i t ->\n let t_constant_opt =\n Option.map t_constant_opt ~f:(fun t_const -> t_const.(i))\n in\n pack ~zero ~one p spec t_constant_opt t )\n | Opt { inner; dummy1; dummy2; flag = _; bool = _ } -> (\n match t with\n | None ->\n let t_constant_opt = Option.map t_constant_opt ~f:(fun _ -> dummy1) in\n Array.append [| zero |]\n (pack ~zero ~one p inner t_constant_opt dummy2)\n | Some x ->\n let t_constant_opt =\n Option.map ~f:(fun x -> Option.value_exn x) t_constant_opt\n in\n Array.append [| one |] (pack ~zero ~one p inner t_constant_opt x)\n | Maybe (b, x) ->\n let b_constant_opt = Option.map ~f:Option.is_some t_constant_opt in\n let x_constant_opt =\n Option.map ~f:(Option.value ~default:dummy1) t_constant_opt\n in\n Array.append\n (p.pack Bool b_constant_opt b)\n (pack ~zero ~one p inner x_constant_opt x) )\n | Opt_unflagged { inner; dummy1; dummy2; flag = _ } -> (\n match t with\n | None ->\n let t_constant_opt = Option.map t_constant_opt ~f:(fun _ -> dummy1) in\n pack ~zero ~one p inner t_constant_opt dummy2\n | Some x ->\n let t_constant_opt =\n Option.map ~f:(fun x -> Option.value_exn x) t_constant_opt\n in\n pack ~zero ~one p inner t_constant_opt x )\n | Constant (x, _, inner) ->\n pack ~zero ~one p inner (Some x) t\n\ntype ('f, 'env) typ =\n { typ :\n 'var 'value.\n ('value, 'var, 'env) basic -> ('var, 'value, 'f) Snarky_backendless.Typ.t\n }\n\nlet rec typ :\n type f var value env.\n (f, env) typ\n -> (value, var, env) T.t\n -> (var, value, f) Snarky_backendless.Typ.t =\n let open Snarky_backendless.Typ in\n fun t spec ->\n match[@warning \"-45\"] spec with\n | B spec ->\n t.typ spec\n | Scalar chal ->\n Sc.typ (t.typ chal)\n | Vector (spec, n) ->\n Vector.typ (typ t spec) n\n | Array (spec, n) ->\n array ~length:n (typ t spec)\n | Struct [] ->\n let open Hlist.HlistId in\n transport (unit ()) ~there:(fun [] -> ()) ~back:(fun () -> [])\n |> transport_var ~there:(fun [] -> ()) ~back:(fun () -> [])\n | Struct (spec :: specs) ->\n let open Hlist.HlistId in\n tuple2 (typ t spec) (typ t (Struct specs))\n |> transport\n ~there:(fun (x :: xs) -> (x, xs))\n ~back:(fun (x, xs) -> x :: xs)\n |> transport_var\n ~there:(fun (x :: xs) -> (x, xs))\n ~back:(fun (x, xs) -> x :: xs)\n | Opt { inner; flag; dummy1; dummy2; bool = (module B) } ->\n let bool = typ t (B Bool) in\n let open B in\n (* Always use the same \"maybe\" layout which is a boolean and then the value *)\n Plonk_types.Opt.constant_layout_typ bool flag ~dummy:dummy1\n ~dummy_var:dummy2 ~true_ ~false_ (typ t inner)\n | Opt_unflagged { inner; flag; dummy1; dummy2 } -> (\n match flag with\n | Plonk_types.Opt.Flag.No ->\n let open Snarky_backendless.Typ in\n unit ()\n |> Snarky_backendless.Typ.transport\n ~there:(function Some _ -> assert false | None -> ())\n ~back:(fun () -> None)\n |> Snarky_backendless.Typ.transport_var\n ~there:(function Some _ -> assert false | None -> ())\n ~back:(fun _ -> None)\n | Plonk_types.Opt.Flag.(Yes | Maybe) ->\n typ t inner\n |> Snarky_backendless.Typ.transport\n ~there:(function Some x -> x | None -> dummy1)\n ~back:(fun x -> Some x)\n |> Snarky_backendless.Typ.transport_var\n ~there:(function Some x -> x | None -> dummy2)\n ~back:(fun x -> Some x) )\n | Constant (x, assert_eq, spec) ->\n let (Typ typ) = typ t spec in\n let constant_var =\n let fields, aux = typ.value_to_fields x in\n let fields =\n Array.map fields ~f:(fun x -> Snarky_backendless.Cvar.Constant x)\n in\n typ.var_of_fields (fields, aux)\n in\n let open Snarky_backendless.Typ in\n unit ()\n |> transport ~there:(fun y -> assert_eq x y) ~back:(fun () -> x)\n |> transport_var ~there:(fun _ -> ()) ~back:(fun () -> constant_var)\n\nmodule ETyp = struct\n type ('var, 'value, 'f) t =\n | T :\n ('inner, 'value, 'f) Snarky_backendless.Typ.t\n * ('inner -> 'var)\n * ('var -> 'inner)\n -> ('var, 'value, 'f) t\nend\n\ntype ('f, 'env) etyp =\n { etyp : 'var 'value. ('value, 'var, 'env) basic -> ('var, 'value, 'f) ETyp.t\n }\n\nlet rec etyp :\n type f var value env.\n (f, env) etyp -> (value, var, env) T.t -> (var, value, f) ETyp.t =\n let open Snarky_backendless.Typ in\n fun e spec ->\n match[@warning \"-45\"] spec with\n | B spec ->\n e.etyp spec\n | Scalar chal ->\n let (T (typ, f, f_inv)) = e.etyp chal in\n T (Sc.typ typ, Sc.map ~f, Sc.map ~f:f_inv)\n | Vector (spec, n) ->\n let (T (typ, f, f_inv)) = etyp e spec in\n T (Vector.typ typ n, Vector.map ~f, Vector.map ~f:f_inv)\n | Array (spec, n) ->\n let (T (typ, f, f_inv)) = etyp e spec in\n T (array ~length:n typ, Array.map ~f, Array.map ~f:f_inv)\n | Struct [] ->\n let open Hlist.HlistId in\n let there [] = () in\n let back () = [] in\n T\n ( transport (unit ()) ~there ~back |> transport_var ~there ~back\n , Fn.id\n , Fn.id )\n | Struct (spec :: specs) ->\n let open Hlist.HlistId in\n let (T (t1, f1, f1_inv)) = etyp e spec in\n let (T (t2, f2, f2_inv)) = etyp e (Struct specs) in\n T\n ( tuple2 t1 t2\n |> transport\n ~there:(fun (x :: xs) -> (x, xs))\n ~back:(fun (x, xs) -> x :: xs)\n , (fun (x, xs) -> f1 x :: f2 xs)\n , fun (x :: xs) -> (f1_inv x, f2_inv xs) )\n | Opt { inner; flag; dummy1; dummy2; bool = (module B) } ->\n let (T (bool, f_bool, f_bool')) = etyp e (B Bool) in\n let (T (a, f_a, f_a')) = etyp e inner in\n let opt_map ~f1 ~f2 (x : _ Plonk_types.Opt.t) : _ Plonk_types.Opt.t =\n match x with\n | None ->\n None\n | Some x ->\n Some (f1 x)\n | Maybe (b, x) ->\n Maybe (f2 b, f1 x)\n in\n let f = opt_map ~f1:f_a ~f2:f_bool in\n let f' = opt_map ~f1:f_a' ~f2:f_bool' in\n T\n ( Plonk_types.Opt.constant_layout_typ ~dummy:dummy1\n ~dummy_var:(f_a' dummy2) ~true_:(f_bool' B.true_)\n ~false_:(f_bool' B.false_) bool flag a\n , f\n , f' )\n | Opt_unflagged { inner; dummy1; dummy2; flag = _ } ->\n let (T (typ, f, f_inv)) = etyp e inner in\n let f x = Some (f x) in\n let f_inv = function None -> f_inv dummy2 | Some x -> f_inv x in\n let typ =\n typ\n |> Snarky_backendless.Typ.transport\n ~there:(Option.value ~default:dummy1) ~back:(fun x -> Some x)\n in\n T (typ, f, f_inv)\n | Constant (x, _assert_eq, spec) ->\n let (T (Typ typ, f, f')) = etyp e spec in\n let constant_var =\n let fields, aux = typ.value_to_fields x in\n let fields =\n Array.map fields ~f:(fun x -> Snarky_backendless.Cvar.Constant x)\n in\n typ.var_of_fields (fields, aux)\n in\n (* We skip any constraints that would be added here, but we *do* use\n the underlying [Typ.t] to make sure that we allocate public inputs\n correctly.\n *)\n T\n ( Typ\n { typ with\n check =\n (fun _ -> Snarky_backendless.Checked_runner.Simple.return ())\n }\n , (fun _ -> f constant_var)\n , f' )\n\nmodule Common (Impl : Snarky_backendless.Snark_intf.Run) = struct\n module Digest = D.Make (Impl)\n module Challenge = Limb_vector.Challenge.Make (Impl)\n open Impl\n\n module Env = struct\n type ('other_field, 'other_field_var, 'a) t =\n < field1 : 'other_field\n ; field2 : 'other_field_var\n ; bool1 : bool\n ; bool2 : Boolean.var\n ; digest1 : Digest.Constant.t\n ; digest2 : Digest.t\n ; challenge1 : Challenge.Constant.t\n ; challenge2 : Challenge.t\n ; bulletproof_challenge1 :\n Challenge.Constant.t Sc.t Bulletproof_challenge.t\n ; bulletproof_challenge2 : Challenge.t Sc.t Bulletproof_challenge.t\n ; branch_data1 : Branch_data.t\n ; branch_data2 : Impl.field Branch_data.Checked.t\n ; .. >\n as\n 'a\n end\nend\n\nlet pack_basic (type field other_field other_field_var)\n ((module Impl) : field impl) =\n let open Impl in\n let module C = Common (Impl) in\n let open C in\n let pack :\n type a b.\n (a, b, ((other_field, other_field_var, 'e) Env.t as 'e)) basic\n -> a option\n -> b\n -> [ `Field of other_field_var | `Packed_bits of Field.t * int ] array =\n fun basic x_constant_opt x ->\n (* TODO *)\n ignore x_constant_opt ;\n match basic with\n | Unit ->\n [||]\n | Field ->\n [| `Field x |]\n | Bool ->\n [| `Packed_bits ((x :> Field.t), 1) |]\n | Digest ->\n [| `Packed_bits (x, Field.size_in_bits) |]\n | Challenge ->\n [| `Packed_bits (x, Challenge.length) |]\n | Branch_data ->\n [| `Packed_bits\n ( Branch_data.Checked.pack (module Impl) x\n , Branch_data.length_in_bits )\n |]\n | Bulletproof_challenge ->\n let { Sc.inner = pre } = Bulletproof_challenge.pack x in\n [| `Packed_bits (pre, Challenge.length) |]\n in\n { pack }\n\nlet pack (type f) ((module Impl) as impl : f impl) t =\n let open Impl in\n pack (pack_basic impl) t\n ~zero:(`Packed_bits (Field.zero, 1))\n ~one:(`Packed_bits (Field.one, 1))\n None\n\nlet typ_basic (type field other_field other_field_var)\n (module Impl : Snarky_backendless.Snark_intf.Run with type field = field)\n ~assert_16_bits (field : (other_field_var, other_field) Impl.Typ.t) =\n let open Impl in\n let module C = Common (Impl) in\n let open C in\n let typ :\n type a b.\n (a, b, ((other_field, other_field_var, 'e) Env.t as 'e)) basic\n -> (b, a) Impl.Typ.t =\n fun basic ->\n match basic with\n | Unit ->\n Typ.unit\n | Field ->\n field\n | Bool ->\n Boolean.typ\n | Branch_data ->\n Branch_data.typ (module Impl) ~assert_16_bits\n | Digest ->\n Digest.typ\n | Challenge ->\n Challenge.typ\n | Bulletproof_challenge ->\n Bulletproof_challenge.typ Challenge.typ\n in\n { typ }\n\nlet typ ~assert_16_bits impl field t =\n typ (typ_basic ~assert_16_bits impl field) t\n\nlet packed_typ_basic (type field other_field other_field_var)\n (module Impl : Snarky_backendless.Snark_intf.Run with type field = field)\n (field : (other_field_var, other_field, field) ETyp.t) =\n let open Impl in\n let module Digest = D.Make (Impl) in\n let module Challenge = Limb_vector.Challenge.Make (Impl) in\n let module Env = struct\n type ('other_field, 'other_field_var, 'a) t =\n < field1 : 'other_field\n ; field2 : 'other_field_var\n ; bool1 : bool\n ; bool2 : Boolean.var\n ; digest1 : Digest.Constant.t\n ; digest2 : Field.t\n ; challenge1 : Challenge.Constant.t\n ; challenge2 : (* Challenge.t *) Field.t\n ; bulletproof_challenge1 :\n Challenge.Constant.t Sc.t Bulletproof_challenge.t\n ; bulletproof_challenge2 : Field.t Sc.t Bulletproof_challenge.t\n ; branch_data1 : Branch_data.t\n ; branch_data2 : Field.t\n ; .. >\n as\n 'a\n end in\n let etyp :\n type a b.\n (a, b, ((other_field, other_field_var, 'e) Env.t as 'e)) basic\n -> (b, a, field) ETyp.t = function\n | Unit ->\n T (Typ.unit, Fn.id, Fn.id)\n | Field ->\n field\n | Bool ->\n T (Boolean.typ, Fn.id, Fn.id)\n | Digest ->\n T (Digest.typ, Fn.id, Fn.id)\n | Challenge ->\n T (Challenge.typ, Fn.id, Fn.id)\n | Branch_data ->\n T (Branch_data.packed_typ (module Impl), Fn.id, Fn.id)\n | Bulletproof_challenge ->\n let typ =\n let there bp_challenge =\n let { Sc.inner = pre } = Bulletproof_challenge.pack bp_challenge in\n pre\n in\n let back pre = Bulletproof_challenge.unpack { Sc.inner = pre } in\n Typ.transport Challenge.typ ~there ~back\n |> Typ.transport_var ~there ~back\n in\n T (typ, Fn.id, Fn.id)\n in\n { etyp }\n\nlet packed_typ impl field t = etyp (packed_typ_basic impl field) t\n","open Core_kernel\nopen Pickles_types\nmodule Domain = Plonk_checks.Domain\n\nmodule Make (Impl : Snarky_backendless.Snark_intf.Run) = struct\n open Impl\n\n type ('a, 'n) t = 'n One_hot_vector.T(Impl).t * ('a, 'n) Vector.t\n\n (* TODO: Use version in common. *)\n let seal (x : Impl.Field.t) : Impl.Field.t =\n let open Impl in\n match Field.to_constant_and_terms x with\n | None, [ (x, i) ] when Field.Constant.(equal x one) ->\n Snarky_backendless.Cvar.Var i\n | Some c, [] ->\n Field.constant c\n | _ ->\n let y = exists Field.typ ~compute:As_prover.(fun () -> read_var x) in\n Field.Assert.equal x y ; y\n\n let mask (type n) (bits : n One_hot_vector.T(Impl).t) xs =\n with_label __LOC__ (fun () ->\n Vector.map\n (Vector.zip (bits :> (Boolean.var, n) Vector.t) xs)\n ~f:(fun (b, x) -> Field.((b :> t) * x))\n |> Vector.fold ~init:Field.zero ~f:Field.( + ) )\n\n let choose : type a n. (a, n) t -> f:(a -> Field.t) -> Field.t =\n fun (bits, xs) ~f -> mask bits (Vector.map xs ~f)\n\n module Degree_bound = struct\n type nonrec 'n t = (int, 'n) t\n\n let shifted_pow ~crs_max_degree t x =\n let pow = Field.(Pcs_batch.pow ~one ~mul) in\n choose t ~f:(fun deg ->\n let d = deg mod crs_max_degree in\n pow x (crs_max_degree - d) )\n end\n\n module Domain = struct\n let num_shifts = Nat.to_int Pickles_types.Plonk_types.Permuts.n\n\n (** Compute the 'shifts' used by the kimchi permutation argument.\n\n These values are selected deterministically-randomly to appear outside\n of the domain, so that every choice of [i] and [shift] results in a\n distinct value for [shift * domain_generator ^ i].\n\n Note that, for each different domain size, we attempt to use the same\n [shifts], and only sample different ones if the shifts are already a\n member of the domain (ie. there exists some [i] such that\n [shift = domain_generator ^ i]). This ensures that the invariant above\n is satisfied.\n Optimisation: since the shifts for the domains that we use in practise\n are all the same -- none of them have 2-adic order < largest domain\n size -- we can hard-code the shifts instead of using a one-hot mask,\n and this function adds no constraints to the circuit.\n *)\n let shifts (type n) ((which, log2s) : (int, n) t)\n ~(shifts : log2_size:int -> Field.Constant.t array) :\n Field.t Pickles_types.Plonk_types.Shifts.t =\n let all_shifts = Vector.map log2s ~f:(fun d -> shifts ~log2_size:d) in\n match all_shifts with\n | [] ->\n failwith \"Pseudo.Domain.shifts: no domains were given\"\n | shifts :: other_shiftss ->\n (* Runtime check that the shifts across all domains are consistent.\n The optimisation below will not work if this is not true; if the\n domain size or the shifts are modified such that this becomes\n false, [disabled_not_the_same] can be set to true to enable\n dynamic selection within the circuit.\n *)\n let all_the_same =\n Vector.for_all other_shiftss\n ~f:(Array.for_all2_exn ~f:Field.Constant.equal shifts)\n in\n (* Set to true if we do not want to allow dynamic selection of the\n shifts at runtime.\n This is possible because of the optimisation outlined in the\n doc-comment above, but this option and the original code is left\n here in case we transition to a larger domain size that uses\n different shifts than those for smaller domains.\n *)\n let disabled_not_the_same = true in\n if all_the_same then Array.map ~f:Field.constant shifts\n else if disabled_not_the_same then\n failwith \"Pseudo.Domain.shifts: found variable shifts\"\n else\n let get_ith_shift i =\n mask which\n (Vector.map all_shifts ~f:(fun a -> Field.constant a.(i)))\n in\n Array.init num_shifts ~f:get_ith_shift\n\n let generator (type n) ((which, log2s) : (int, n) t) ~domain_generator =\n mask which (Vector.map log2s ~f:(fun d -> domain_generator ~log2_size:d))\n\n type nonrec 'n t = (Domain.t, 'n) t\n\n let to_domain ~shifts:s ~domain_generator (type n) (t : n t) :\n Field.t Plonk_checks.plonk_domain =\n let log2_sizes = Vector.map (snd t) ~f:Domain.log2_size in\n let shifts = shifts (fst t, log2_sizes) ~shifts:s in\n let generator = generator (fst t, log2_sizes) ~domain_generator in\n let max_log2 =\n let _, ds = t in\n List.fold (Vector.to_list ds) ~init:0 ~f:(fun acc d ->\n Int.max acc (Domain.log2_size d) )\n in\n object\n method shifts = shifts\n\n method generator = generator\n\n method vanishing_polynomial x =\n let pow2_pows =\n let res = Array.create ~len:(max_log2 + 1) x in\n for i = 1 to max_log2 do\n res.(i) <- Field.square res.(i - 1)\n done ;\n res\n in\n let open Field in\n seal (choose t ~f:(fun d -> pow2_pows.(Domain.log2_size d)) - one)\n end\n end\nend\n","(* version_bytes.ml -- version bytes for Base58Check encodings *)\n\ntype t = char\n\n(** Base58Check version bytes for individual types\n Each of the following values should be distinct\n*)\n\nlet coinbase : t = '\\x01'\n\nlet secret_box_byteswr : t = '\\x02'\n\nlet fee_transfer_single : t = '\\x03'\n\nlet frontier_hash : t = '\\x04'\n\nlet ledger_hash : t = '\\x05'\n\nlet lite_precomputed : t = '\\x06'\n\nlet proof : t = '\\x0A'\n\nlet random_oracle_base : t = '\\x0B'\n\nlet receipt_chain_hash : t = '\\x0C'\n\nlet epoch_seed : t = '\\x0D'\n\nlet staged_ledger_hash_aux_hash : t = '\\x0E'\n\nlet staged_ledger_hash_pending_coinbase_aux : t = '\\x0F'\n\nlet state_hash : t = '\\x10'\n\nlet state_body_hash : t = '\\x11'\n\n(* don't use \\x12, which was for pre-Berkeley hard fork transaction hashes *)\n\n(* used only to deserialize transaction ids, pre-Berkeley hard fork *)\nlet signed_command_v1 : t = '\\x13'\n\nlet user_command_memo : t = '\\x14'\n\nlet vrf_truncated_output : t = '\\x15'\n\nlet web_pipe : t = '\\x16'\n\nlet coinbase_stack_data : t = '\\x17'\n\nlet coinbase_stack_hash : t = '\\x18'\n\nlet pending_coinbase_hash_builder : t = '\\x19'\n\nlet zkapp_command : t = '\\x1A'\n\nlet verification_key : t = '\\x1B'\n\nlet token_id_key : t = '\\x1C'\n\nlet transaction_hash : t = '\\x1D'\n\n(** used for testing only *)\n\nlet ledger_test_hash : t = '\\x30'\n\n(** The following version bytes are non-sequential; existing\n user key infrastructure depends on them. don't change them!\n*)\n\nlet private_key : t = '\\x5A'\n\nlet non_zero_curve_point_compressed : t = '\\xCB'\n\nlet signature : t = '\\x9A'\n","open Core_kernel\n\nmodule type Iso_intf = sig\n type original\n\n type standardized [@@deriving yojson]\n\n val encode : original -> standardized\n\n val decode : standardized -> original\nend\n\nmodule type S = sig\n type t\n\n val to_yojson : t -> Yojson.Safe.t\n\n val of_yojson : Yojson.Safe.t -> t Ppx_deriving_yojson_runtime.error_or\nend\n\nmodule Make (Iso : Iso_intf) = struct\n let to_yojson t = Iso.encode t |> Iso.standardized_to_yojson\n\n let of_yojson json =\n Result.map ~f:Iso.decode (Iso.standardized_of_yojson json)\n\n module For_tests = struct\n let check_encoding t ~equal =\n match of_yojson (to_yojson t) with\n | Ok result ->\n equal t result\n | Error e ->\n failwithf !\"%s\" e ()\n end\nend\n\nmodule For_tests = struct\n let check_encoding (type t) (module M : S with type t = t) t ~equal =\n match M.of_yojson (M.to_yojson t) with\n | Ok result ->\n equal t result\n | Error e ->\n failwithf !\"%s\" e ()\nend\n\nmodule Make_of_int (Iso : sig\n type t\n\n val to_int : t -> int\n\n val of_int : int -> t\nend) =\nMake (struct\n type original = Iso.t\n\n type standardized = int [@@deriving yojson]\n\n let encode = Iso.to_int\n\n let decode = Iso.of_int\nend)\n\nmodule Make_of_string (Iso : sig\n type t\n\n val to_string : t -> string\n\n val of_string : string -> t\nend) =\nMake (struct\n type original = Iso.t\n\n type standardized = string [@@deriving yojson]\n\n let encode = Iso.to_string\n\n let decode = Iso.of_string\nend)\n\nmodule Make_base58_check (T : sig\n type t [@@deriving bin_io]\n\n val description : string\n\n val version_byte : char\nend) =\nstruct\n module Base58_check = Base58_check.Make (T)\n\n let to_base58_check t = Base58_check.encode (Binable.to_string (module T) t)\n\n let of_base58_check s =\n let open Or_error.Let_syntax in\n let%bind decoded = Base58_check.decode s in\n Or_error.try_with (fun () -> Binable.of_string (module T) decoded)\n\n let of_base58_check_exn s = of_base58_check s |> Or_error.ok_exn\n\n let to_yojson t = `String (to_base58_check t)\n\n let of_yojson = function\n | `String s ->\n Result.map_error (of_base58_check s) ~f:Error.to_string_hum\n | json ->\n failwithf \"of_yojson: expect JSON string, got %s\"\n (Yojson.Safe.to_string json)\n ()\nend\n\nmodule type Base58_check_base_intf = sig\n type t\n\n (** Base58Check decoding *)\n val of_base58_check : string -> t Base.Or_error.t\n\n (** Base58Check decoding *)\n val of_base58_check_exn : string -> t\nend\n\nmodule type Base58_check_intf = sig\n type t\n\n (** explicit Base58Check encoding *)\n val to_base58_check : t -> string\n\n include Base58_check_base_intf with type t := t\nend\n\nmodule Make_base64 (T : sig\n type t [@@deriving bin_io]\nend) =\nstruct\n let to_base64 (t : T.t) : string =\n Binable.to_string (module T) t\n |> (* raises only on errors from invalid optional arguments *)\n Base64.encode_exn\n\n let of_base64 b64 : T.t Or_error.t =\n match Base64.decode b64 with\n | Ok s -> (\n try Ok (Binable.of_string (module T) s)\n with Bin_prot.Common.Read_error _ as e ->\n Error (Error.of_exn ~backtrace:`Get e) )\n | Error (`Msg msg) ->\n Error (Error.of_string msg)\nend\n\nmodule type Base64_intf = sig\n type t\n\n val to_base64 : t -> string\n\n val of_base64 : string -> t Or_error.t\nend\n","open Snarky_backendless\nopen Webkit_trace_event\nopen Webkit_trace_event.Output.JSON\nopen Yojson\n\nlet to_string ?buf ?len ?std events =\n to_string ?buf ?len ?std @@ json_of_events events\n\nlet to_channel ?buf ?len ?std out_channel events =\n to_channel ?buf ?len ?std out_channel @@ json_of_events events\n\nlet to_file ?buf ?len ?std filename events =\n let oc = open_out filename in\n to_channel ?buf ?len ?std oc events ;\n close_out oc\n\nmodule Constraints (Snarky_backendless : Snark_intf.Basic) = struct\n (** Create flamechart events for Snarky_backendless constraints.\n\n This creates a chart of labels, associating each label with a 'timestamp'\n equal to the number of constraints at its start and end. *)\n open Snarky_backendless\n\n (** Generate a flamechart for the labels of a checked computation. *)\n let log ?weight (t : unit -> _ Checked.t) : events =\n let rev_events = ref [] in\n let _total =\n constraint_count ?weight t ~log:(fun ?(start = false) label count ->\n rev_events :=\n create_event label\n ~phase:(if start then Measure_start else Measure_end)\n ~timestamp:count\n :: !rev_events )\n in\n List.rev !rev_events\n\n (** Same as [log], but for functions which take [Var.t] arguments.\n Use [apply_args] to apply the corresponding OCaml-typed arguments.\n For example: {[\nopen Snarky_backendless\nmodule Snark = Snark.Make (Backends.Bn128.Default)\nopen Snark\nmodule Constraints = Snarky_log.Constraints (Snark)\n\nlet () = Snarky_log.to_file \"output.json\" @@\n Constraints.log_func ~input:Data_spec.[Field.typ; Field.typ] Field.Checked.mul\n ~apply_args:(fun mul -> mul Field.one Field.one)\n }] *)\n let log_func ~input_typ ~return_typ ~(apply_args : 'k_value -> _ Checked.t)\n (f : 'k_var) : events =\n let f' = conv (fun c -> c) input_typ return_typ f in\n log (fun () -> apply_args f')\nend\n","module B = Bigint\nmodule H_list = Snarky_backendless.H_list\nmodule Challenge = Limb_vector.Challenge\nmodule Types = Composition_types\nmodule Digest = Types.Digest\nmodule Spec = Types.Spec\nmodule Branch_data = Composition_types.Branch_data\nmodule Step_bp_vec = Types.Step_bp_vec\nmodule Nvector = Types.Nvector\nmodule Bulletproof_challenge = Types.Bulletproof_challenge\nmodule Domain = Pickles_base.Domain\nmodule Domains = Pickles_base.Domains\nmodule Scalar_challenge = Kimchi_backend_common.Scalar_challenge\n\nlet debug = false\n","open Core_kernel\nopen Pickles_types\n\nlet rec absorb :\n type a g1 g1_opt f scalar.\n absorb_field:(f -> unit)\n -> absorb_scalar:(scalar -> unit)\n -> g1_to_field_elements:(g1 -> f list)\n -> mask_g1_opt:(g1_opt -> g1)\n -> ( a\n , < scalar : scalar ; g1 : g1 ; g1_opt : g1_opt ; base_field : f > )\n Type.t\n -> a\n -> unit =\n fun ~absorb_field ~absorb_scalar ~g1_to_field_elements ~mask_g1_opt ty t ->\n match ty with\n | Type.PC ->\n List.iter ~f:absorb_field (g1_to_field_elements t)\n | Type.Field ->\n absorb_field t\n | Type.Scalar ->\n absorb_scalar t\n | Type.Without_degree_bound ->\n Array.iter\n ~f:(Fn.compose (List.iter ~f:absorb_field) g1_to_field_elements)\n t\n | Type.With_degree_bound ->\n let Pickles_types.Plonk_types.Poly_comm.With_degree_bound.\n { unshifted; shifted } =\n t\n in\n let absorb x =\n absorb ~absorb_field ~absorb_scalar ~g1_to_field_elements ~mask_g1_opt\n Type.PC (mask_g1_opt x)\n in\n Array.iter unshifted ~f:absorb ;\n absorb shifted\n | ty1 :: ty2 ->\n let absorb t =\n absorb t ~absorb_field ~absorb_scalar ~g1_to_field_elements ~mask_g1_opt\n in\n let t1, t2 = t in\n absorb ty1 t1 ; absorb ty2 t2\n\n(** [ones_vector (module I) ~first_zero n] returns a vector of booleans of\n length n which is all ones until position [first_zero], at which it is zero,\n and zero thereafter. *)\nlet ones_vector :\n type f n.\n first_zero:f Snarky_backendless.Cvar.t\n -> (module Snarky_backendless.Snark_intf.Run with type field = f)\n -> n Nat.t\n -> (f Snarky_backendless.Cvar.t Snarky_backendless.Boolean.t, n) Vector.t =\n fun ~first_zero (module Impl) n ->\n let open Impl in\n let rec go :\n type m. Boolean.var -> int -> m Nat.t -> (Boolean.var, m) Vector.t =\n fun value i m ->\n match[@warning \"-45\"] m with\n | Pickles_types.Nat.Z ->\n Pickles_types.Vector.[]\n | Pickles_types.Nat.S m ->\n let value =\n Boolean.(value && not (Field.equal first_zero (Field.of_int i)))\n in\n Pickles_types.Vector.(value :: go value (i + 1) m)\n in\n go Boolean.true_ 0 n\n\nlet seal (type f)\n (module Impl : Snarky_backendless.Snark_intf.Run with type field = f)\n (x : Impl.Field.t) : Impl.Field.t =\n let open Impl in\n match Field.to_constant_and_terms x with\n | None, [ (x, i) ] when Field.Constant.(equal x one) ->\n Snarky_backendless.Cvar.Var i\n | Some c, [] ->\n Field.constant c\n | _ ->\n let y = exists Field.typ ~compute:As_prover.(fun () -> read_var x) in\n Field.Assert.equal x y ; y\n\nlet lowest_128_bits (type f) ~constrain_low_bits ~assert_128_bits\n (module Impl : Snarky_backendless.Snark_intf.Run with type field = f) x =\n let open Impl in\n let pow2 =\n (* 2 ^ n *)\n let rec pow2 x i =\n if i = 0 then x else pow2 Field.Constant.(x + x) (i - 1)\n in\n fun n -> pow2 Field.Constant.one n\n in\n let lo, hi =\n exists\n Typ.(field * field)\n ~compute:(fun () ->\n let lo, hi =\n Field.Constant.unpack (As_prover.read_var x)\n |> Fn.flip List.split_n 128\n in\n (Field.Constant.project lo, Field.Constant.project hi) )\n in\n assert_128_bits hi ;\n if constrain_low_bits then assert_128_bits lo ;\n Field.Assert.equal x Field.(lo + scale hi (pow2 128)) ;\n lo\n","module SC = Scalar_challenge\n\ntype t = Import.Challenge.Constant.t Import.Scalar_challenge.t\n\nmodule Wrap_inner_curve = struct\n let base : Backend.Tock.Field.t = Pasta_bindings.Vesta.endo_base ()\n\n let scalar : Backend.Tick.Field.t = Pasta_bindings.Vesta.endo_scalar ()\n\n let to_field (t : t) : Backend.Tick.Field.t =\n SC.to_field_constant (module Backend.Tick.Field) ~endo:scalar t\nend\n\nmodule Step_inner_curve = struct\n let base : Backend.Tick.Field.t = Pasta_bindings.Pallas.endo_base ()\n\n let scalar : Backend.Tock.Field.t = Pasta_bindings.Pallas.endo_scalar ()\n\n let to_field (t : t) : Backend.Tock.Field.t =\n SC.to_field_constant (module Backend.Tock.Field) ~endo:scalar t\nend\n","open Core_kernel\nopen Pickles_types\nopen Import\nopen Backend\n\nmodule Max_degree = struct\n let step_log2 = Nat.to_int Backend.Tick.Rounds.n\n\n let step = 1 lsl step_log2\n\n let wrap_log2 = Nat.to_int Backend.Tock.Rounds.n\n\n let _wrap = 1 lsl wrap_log2\nend\n\nlet tick_shifts, tock_shifts =\n let mk g =\n let f =\n Memo.general ~cache_size_bound:20 ~hashable:Int.hashable (fun log2_size ->\n g log2_size )\n in\n fun ~log2_size -> f log2_size\n in\n ( mk Kimchi_bindings.Protocol.VerifierIndex.Fp.shifts\n , mk Kimchi_bindings.Protocol.VerifierIndex.Fq.shifts )\n\nlet wrap_domains ~proofs_verified =\n let h =\n match proofs_verified with 0 -> 13 | 1 -> 14 | 2 -> 15 | _ -> assert false\n in\n { Domains.h = Domain.Pow_2_roots_of_unity h }\n\nlet actual_wrap_domain_size ~log_2_domain_size =\n let d =\n match log_2_domain_size with\n | 13 ->\n 0\n | 14 ->\n 1\n | 15 ->\n 2\n | _ ->\n assert false\n in\n Pickles_base.Proofs_verified.of_int d\n\nlet hash_messages_for_next_step_proof ~app_state\n (t : _ Types.Step.Proof_state.Messages_for_next_step_proof.t) =\n let g (x, y) = [ x; y ] in\n Tick_field_sponge.digest Tick_field_sponge.params\n (Types.Step.Proof_state.Messages_for_next_step_proof.to_field_elements t ~g\n ~comm:(fun (x : Tock.Curve.Affine.t) -> Array.of_list (g x))\n ~app_state )\n\nlet dlog_pcs_batch (type nat proofs_verified total)\n ((without_degree_bound, _pi) :\n total Nat.t * (proofs_verified, nat, total) Nat.Adds.t ) =\n Pcs_batch.create ~without_degree_bound ~with_degree_bound:[]\n\nlet when_profiling profiling default =\n match Option.map (Sys.getenv_opt \"PICKLES_PROFILING\") ~f:String.lowercase with\n | None | Some (\"0\" | \"false\") ->\n default\n | Some _ ->\n profiling\n\nlet time lab f =\n when_profiling\n (fun () ->\n let start = Time.now () in\n let x = f () in\n let stop = Time.now () in\n printf \"%s: %s\\n%!\" lab (Time.Span.to_string_hum (Time.diff stop start)) ;\n x )\n f ()\n\nlet bits_to_bytes bits =\n let byte_of_bits bs =\n List.foldi bs ~init:0 ~f:(fun i acc b ->\n if b then acc lor (1 lsl i) else acc )\n |> Char.of_int_exn\n in\n List.map (List.groupi bits ~break:(fun i _ _ -> i mod 8 = 0)) ~f:byte_of_bits\n |> String.of_char_list\n\nlet group_map m ~a ~b =\n let params = Group_map.Params.create m { a; b } in\n stage (fun x -> Group_map.to_group m ~params x)\n\nmodule Shifts = struct\n let tock2 : Backend.Tock.Field.t Shifted_value.Type2.Shift.t =\n Shifted_value.Type2.Shift.create (module Backend.Tock.Field)\n\n let tick1 : Backend.Tick.Field.t Shifted_value.Type1.Shift.t =\n Shifted_value.Type1.Shift.create (module Backend.Tick.Field)\nend\n\nmodule Lookup_parameters = struct\n let tick_zero : _ Composition_types.Zero_values.t =\n Composition_types.Zero_values.\n { value =\n { challenge = Challenge.Constant.zero\n ; scalar =\n Shifted_value.Type2.Shifted_value Impls.Wrap.Field.Constant.zero\n }\n ; var =\n { challenge = Impls.Step.Field.zero\n ; scalar =\n Shifted_value.Type2.Shifted_value\n (Impls.Step.Field.zero, Impls.Step.Boolean.false_)\n }\n }\n\n let tock_zero : _ Composition_types.Zero_values.t =\n Composition_types.Zero_values.\n { value =\n { challenge = Challenge.Constant.zero\n ; scalar =\n Shifted_value.Type2.Shifted_value Impls.Wrap.Field.Constant.zero\n }\n ; var =\n { challenge = Impls.Wrap.Field.zero\n ; scalar = Shifted_value.Type2.Shifted_value Impls.Wrap.Field.zero\n }\n }\nend\n\nlet finite_exn : 'a Kimchi_types.or_infinity -> 'a * 'a = function\n | Kimchi_types.Finite (x, y) ->\n (x, y)\n | Kimchi_types.Infinity ->\n invalid_arg \"finite_exn\"\n\nlet or_infinite_conv : ('a * 'a) Or_infinity.t -> 'a Kimchi_types.or_infinity =\n function\n | Finite (x, y) ->\n Finite (x, y)\n | Infinity ->\n Infinity\n\nmodule Ipa = struct\n open Backend\n\n (* TODO: Make all this completely generic over backend *)\n\n let compute_challenge ~endo_to_field _ c = endo_to_field c\n\n let compute_challenges ~endo_to_field field chals =\n Vector.map chals ~f:(fun prechallenge ->\n Bulletproof_challenge.pack prechallenge\n |> compute_challenge field ~endo_to_field )\n\n module Wrap = struct\n let field =\n (module Tock.Field : Kimchi_backend.Field.S with type t = Tock.Field.t)\n\n let endo_to_field = Endo.Step_inner_curve.to_field\n\n let compute_challenge c = compute_challenge field ~endo_to_field c\n\n let compute_challenges cs = compute_challenges field ~endo_to_field cs\n\n let compute_sg chals =\n let comm =\n Kimchi_bindings.Protocol.SRS.Fq.b_poly_commitment\n (Backend.Tock.Keypair.load_urs ())\n (Pickles_types.Vector.to_array (compute_challenges chals))\n in\n comm.unshifted.(0) |> finite_exn\n end\n\n module Step = struct\n let field =\n (module Tick.Field : Kimchi_backend.Field.S with type t = Tick.Field.t)\n\n let endo_to_field = Endo.Wrap_inner_curve.to_field\n\n let compute_challenge c = compute_challenge field ~endo_to_field c\n\n let compute_challenges cs = compute_challenges field ~endo_to_field cs\n\n let compute_sg chals =\n let comm =\n Kimchi_bindings.Protocol.SRS.Fp.b_poly_commitment\n (Backend.Tick.Keypair.load_urs ())\n (Pickles_types.Vector.to_array (compute_challenges chals))\n in\n comm.unshifted.(0) |> finite_exn\n\n let accumulator_check comm_chals =\n let chals =\n Array.concat\n @@ List.map comm_chals ~f:(fun (_, chals) -> Vector.to_array chals)\n in\n let comms =\n Array.of_list_map comm_chals ~f:(fun (comm, _) ->\n Or_infinity.Finite comm )\n in\n let urs = Backend.Tick.Keypair.load_urs () in\n Promise.run_in_thread (fun () ->\n Kimchi_bindings.Protocol.SRS.Fp.batch_accumulator_check urs\n (Array.map comms ~f:or_infinite_conv)\n chals )\n end\nend\n\nlet tock_unpadded_public_input_of_statement prev_statement =\n let input =\n let (T (typ, _conv, _conv_inv)) = Impls.Wrap.input () in\n Impls.Wrap.generate_public_input typ prev_statement\n in\n List.init\n (Backend.Tock.Field.Vector.length input)\n ~f:(Backend.Tock.Field.Vector.get input)\n\nlet tock_public_input_of_statement s = tock_unpadded_public_input_of_statement s\n\nlet tick_public_input_of_statement ~max_proofs_verified ~feature_flags\n (prev_statement : _ Types.Step.Statement.t) =\n let input =\n let (T (input, _conv, _conv_inv)) =\n Impls.Step.input ~proofs_verified:max_proofs_verified\n ~wrap_rounds:Tock.Rounds.n ~feature_flags\n in\n Impls.Step.generate_public_input input prev_statement\n in\n List.init\n (Backend.Tick.Field.Vector.length input)\n ~f:(Backend.Tick.Field.Vector.get input)\n\nlet ft_comm ~add:( + ) ~scale ~endoscale:_ ~negate\n ~verification_key:(m : _ Plonk_verification_key_evals.t) ~alpha:_\n ~(plonk : _ Types.Wrap.Proof_state.Deferred_values.Plonk.In_circuit.t)\n ~t_comm =\n let ( * ) x g = scale g x in\n let _, [ sigma_comm_last ] =\n Vector.split m.sigma_comm (snd (Plonk_types.Permuts_minus_1.add Nat.N1.n))\n in\n let f_comm = List.reduce_exn ~f:( + ) [ plonk.perm * sigma_comm_last ] in\n let chunked_t_comm =\n let n = Array.length t_comm in\n let res = ref t_comm.(n - 1) in\n for i = n - 2 downto 0 do\n res := t_comm.(i) + scale !res plonk.zeta_to_srs_length\n done ;\n !res\n in\n f_comm + chunked_t_comm\n + negate (scale chunked_t_comm plonk.zeta_to_domain_size)\n\nlet combined_evaluation (type f)\n (module Impl : Snarky_backendless.Snark_intf.Run with type field = f)\n ~(xi : Impl.Field.t) (without_degree_bound : _ list) =\n let open Impl in\n let open Field in\n let mul_and_add ~(acc : Field.t) ~(xi : Field.t)\n (fx : (Field.t, Boolean.var) Plonk_types.Opt.t) : Field.t =\n match fx with\n | None ->\n acc\n | Some fx ->\n fx + (xi * acc)\n | Maybe (b, fx) ->\n Field.if_ b ~then_:(fx + (xi * acc)) ~else_:acc\n in\n with_label __LOC__ (fun () ->\n Pcs_batch.combine_split_evaluations ~mul_and_add\n ~init:(function\n | Some x ->\n x\n | None ->\n Field.zero\n | Maybe (b, x) ->\n (b :> Field.t) * x )\n ~xi without_degree_bound )\n","open Core_kernel\nmodule Js = Js_of_ocaml.Js\nmodule Backend = Kimchi_backend.Pasta.Vesta_based_plonk\nmodule Impl = Pickles.Impls.Step\nmodule Field = Impl.Field\nmodule Boolean = Impl.Boolean\nmodule As_prover = Impl.As_prover\nmodule Typ = Impl.Typ\n\n(* light-weight wrapper around snarky-ml core *)\n\nlet typ (size_in_fields : int) = Typ.array ~length:size_in_fields Field.typ\n\nlet exists (size_in_fields : int) (compute : unit -> Field.Constant.t array) =\n Impl.exists (typ size_in_fields) ~compute\n\nlet exists_var (compute : unit -> Field.Constant.t) =\n Impl.exists Field.typ ~compute\n\nmodule Run = struct\n let as_prover = Impl.as_prover\n\n let in_prover_block () = As_prover.in_prover_block () |> Js.bool\n\n let run_and_check (f : unit -> unit) =\n try\n Impl.run_and_check_exn (fun () ->\n f () ;\n fun () -> () )\n with exn -> Util.raise_exn exn\n\n let run_unchecked (f : unit -> unit) =\n try\n Impl.run_and_check_exn (fun () ->\n Snarky_backendless.Snark0.set_eval_constraints false ;\n f () ;\n Snarky_backendless.Snark0.set_eval_constraints true ;\n fun () -> () )\n with exn -> Util.raise_exn exn\n\n let constraint_system (main : unit -> unit) =\n let cs =\n Impl.constraint_system ~input_typ:Impl.Typ.unit ~return_typ:Impl.Typ.unit\n (fun () -> main)\n in\n object%js\n val rows = Backend.R1CS_constraint_system.get_rows_len cs\n\n val digest =\n Backend.R1CS_constraint_system.digest cs |> Md5.to_hex |> Js.string\n\n val json =\n Backend.R1CS_constraint_system.to_json cs\n |> Js.string |> Util.json_parse\n end\nend\n\nmodule Field' = struct\n (** add x, y to get a new AST node Add(x, y); handles if x, y are constants *)\n let add x y = Field.add x y\n\n (** scale x by a constant to get a new AST node Scale(c, x); handles if x is a constant; handles c=0,1 *)\n let scale c x = Field.scale x c\n\n (** witnesses z = x*y and constrains it with [assert_r1cs]; handles constants *)\n let mul x y = Field.mul x y\n\n (** evaluates a CVar by unfolding the AST and reading Vars from a list of public input + aux values *)\n let read_var (x : Field.t) = As_prover.read_var x\n\n (** x === y without handling of constants *)\n let assert_equal x y = Impl.assert_ (Impl.Constraint.equal x y)\n\n (** x*y === z without handling of constants *)\n let assert_mul x y z = Impl.assert_ (Impl.Constraint.r1cs x y z)\n\n (** x*x === y without handling of constants *)\n let assert_square x y = Impl.assert_ (Impl.Constraint.square x y)\n\n (** x*x === x without handling of constants *)\n let assert_boolean x = Impl.assert_ (Impl.Constraint.boolean x)\n\n (** check x < y and x <= y.\n this is used in all comparisons, including with assert *)\n let compare (bit_length : int) x y =\n let ({ less; less_or_equal } : Field.comparison_result) =\n Field.compare ~bit_length x y\n in\n (less, less_or_equal)\n\n let to_bits (length : int) x =\n Field.choose_preimage_var ~length x |> Array.of_list\n\n let from_bits bits = Array.to_list bits |> Field.project\n\n (** returns x truncated to the lowest [16 * length_div_16] bits\n => can be used to assert that x fits in [16 * length_div_16] bits.\n\n more efficient than [to_bits] because it uses the [EC_endoscalar] gate;\n does 16 bits per row (vs 1 bits per row that you can do with generic gates).\n *)\n let truncate_to_bits16 (length_div_16 : int) x =\n let _a, _b, x0 =\n Pickles.Scalar_challenge.to_field_checked' ~num_bits:(length_div_16 * 16)\n (module Impl)\n { inner = x }\n in\n x0\n\n (* can be implemented with Field.to_constant_and_terms *)\n let seal x = Pickles.Util.seal (module Impl) x\n\n let to_constant_and_terms x = Field.to_constant_and_terms x\nend\n\nmodule Bool = struct\n let not x = Boolean.not x\n\n let and_ x y = Boolean.(x &&& y)\n\n let or_ x y = Boolean.(x ||| y)\n\n let assert_equal x y = Boolean.Assert.(x = y)\n\n let equals x y = Boolean.equal x y\nend\n\nmodule Group = struct\n let ec_add p1 p2 p3 inf same_x slope inf_z x21_inv =\n let open Impl in\n with_label \"Elliptic Curve Addition\" (fun () ->\n assert_\n { annotation = Some __LOC__\n ; basic =\n Kimchi_backend_common.Plonk_constraint_system.Plonk_constraint.T\n (EC_add_complete\n { p1; p2; p3; inf; same_x; slope; inf_z; x21_inv } )\n } ;\n p3 )\n\n let scale p (scalar_bits : Boolean.var array) =\n Pickles.Step_main_inputs.Ops.scale_fast_msb_bits p\n (Shifted_value scalar_bits)\nend\n\nmodule Circuit = struct\n module Main = struct\n let of_js (main : Field.t array -> unit) =\n let main' public_input () = main public_input in\n main'\n end\n\n let compile main public_input_size =\n let input_typ = typ public_input_size in\n let return_typ = Impl.Typ.unit in\n let cs = Impl.constraint_system ~input_typ ~return_typ (Main.of_js main) in\n Impl.Keypair.generate ~prev_challenges:0 cs\n\n let prove main public_input_size public_input keypair =\n let pk = Impl.Keypair.pk keypair in\n let input_typ = typ public_input_size in\n let return_typ = Impl.Typ.unit in\n Impl.generate_witness_conv ~input_typ ~return_typ\n ~f:(fun { Impl.Proof_inputs.auxiliary_inputs; public_inputs } () ->\n Backend.Proof.create pk ~auxiliary:auxiliary_inputs\n ~primary:public_inputs )\n (Main.of_js main) public_input\n\n let verify public_input proof vk =\n let public_input_vec = Backend.Field.Vector.create () in\n Array.iter public_input ~f:(fun x ->\n Backend.Field.Vector.emplace_back public_input_vec x ) ;\n Backend.Proof.verify proof vk public_input_vec |> Js.bool\n\n module Keypair = struct\n let get_vk t = Impl.Keypair.vk t\n\n external prover_to_json :\n Kimchi_bindings.Protocol.Index.Fp.t -> Js.js_string Js.t\n = \"prover_to_json\"\n\n let get_cs_json t =\n (Impl.Keypair.pk t).index |> prover_to_json |> Util.json_parse\n end\nend\n\nmodule Poseidon = struct\n let update (state : Field.t Random_oracle.State.t) (input : Field.t array) :\n Field.t Random_oracle.State.t =\n Random_oracle.Checked.update ~state input\n\n let hash_to_group (xs : Field.t array) =\n let input = Random_oracle.Checked.hash xs in\n Snark_params.Group_map.Checked.to_group input\n\n (* sponge *)\n\n let to_unchecked (x : Field.t) =\n match x with Constant y -> y | y -> As_prover.read_var y\n\n module Poseidon_sponge_checked =\n Sponge.Make_sponge (Pickles.Step_main_inputs.Sponge.Permutation)\n module Poseidon_sponge =\n Sponge.Make_sponge (Sponge.Poseidon (Pickles.Tick_field_sponge.Inputs))\n\n let sponge_params_checked =\n Sponge.Params.(\n map pasta_p_kimchi\n ~f:(Fn.compose Impl.Field.constant Impl.Field.Constant.of_string))\n\n let sponge_params =\n Sponge.Params.(map pasta_p_kimchi ~f:Impl.Field.Constant.of_string)\n\n type sponge =\n | Checked of Poseidon_sponge_checked.t\n | Unchecked of Poseidon_sponge.t\n\n (* returns a \"sponge\" that stays opaque to JS *)\n let sponge_create (is_checked : bool Js.t) : sponge =\n if Js.to_bool is_checked then\n Checked (Poseidon_sponge_checked.create ?init:None sponge_params_checked)\n else Unchecked (Poseidon_sponge.create ?init:None sponge_params)\n\n let sponge_absorb (sponge : sponge) (field : Field.t) : unit =\n match sponge with\n | Checked s ->\n Poseidon_sponge_checked.absorb s field\n | Unchecked s ->\n Poseidon_sponge.absorb s (to_unchecked @@ field)\n\n let sponge_squeeze (sponge : sponge) : Field.t =\n match sponge with\n | Checked s ->\n Poseidon_sponge_checked.squeeze s\n | Unchecked s ->\n Poseidon_sponge.squeeze s |> Impl.Field.constant\nend\n\nlet snarky =\n object%js\n method exists = exists\n\n method existsVar = exists_var\n\n val run =\n let open Run in\n object%js\n method asProver = as_prover\n\n val inProverBlock = in_prover_block\n\n method runAndCheck = run_and_check\n\n method runUnchecked = run_unchecked\n\n method constraintSystem = constraint_system\n end\n\n val field =\n let open Field' in\n object%js\n method add = add\n\n method scale = scale\n\n method mul = mul\n\n method readVar = read_var\n\n method assertEqual = assert_equal\n\n method assertMul = assert_mul\n\n method assertSquare = assert_square\n\n method assertBoolean = assert_boolean\n\n method compare = compare\n\n method toBits = to_bits\n\n method fromBits = from_bits\n\n method truncateToBits16 = truncate_to_bits16\n\n method seal = seal\n\n method toConstantAndTerms = to_constant_and_terms\n end\n\n val bool =\n object%js\n method not = Bool.not\n\n method and_ = Bool.and_\n\n method or_ = Bool.or_\n\n method assertEqual = Bool.assert_equal\n\n method equals = Bool.equals\n end\n\n val group =\n object%js\n method ecadd = Group.ec_add\n\n method scale = Group.scale\n end\n\n val circuit =\n object%js\n method compile = Circuit.compile\n\n method prove = Circuit.prove\n\n method verify = Circuit.verify\n\n val keypair =\n object%js\n method getVerificationKey = Circuit.Keypair.get_vk\n\n method getConstraintSystemJSON = Circuit.Keypair.get_cs_json\n end\n end\n\n val poseidon =\n object%js\n method update = Poseidon.update\n\n method hashToGroup = Poseidon.hash_to_group\n\n val sponge =\n object%js\n method create = Poseidon.sponge_create\n\n method absorb = Poseidon.sponge_absorb\n\n method squeeze = Poseidon.sponge_squeeze\n end\n end\n end\n","module D = Composition_types.Digest\nopen Core_kernel\n\nmodule Rounds = struct\n let rounds_full = 55\n\n let initial_ark = false\n\n let rounds_partial = 0\nend\n\nlet high_entropy_bits = 128\n\nmodule type S = sig\n module Inputs : sig\n include module type of Rounds\n\n module Field : Kimchi_backend_common.Field.S\n\n type field := Field.t\n\n val to_the_alpha : field -> field\n\n val alpha : int\n\n module Operations : Sponge.Intf.Operations with type Field.t = field\n end\n\n type field := Inputs.Field.t\n\n (* The name does not really reflect the behavior *and* is somewhat confusing w.r.t\n Inputs.Field. This is almost Sponge.Intf.Sponge *)\n module Field : sig\n type f := Sponge.Poseidon(Inputs).Field.t\n\n type params := f Sponge.Params.t\n\n type state := f Sponge.State.t\n\n type t = f Sponge.t (* TODO: Make this type abstract *)\n\n val create : ?init:state -> params -> t\n\n val make :\n state:state -> params:params -> sponge_state:Sponge.sponge_state -> t\n\n val absorb : t -> f -> unit\n\n val squeeze : t -> f\n\n val copy : t -> t\n\n val state : t -> state\n end\n\n (* TODO: Resuce module types of Sponge.Intf.Sponge *)\n module Bits : sig\n type t\n\n val create : ?init:field Sponge.State.t -> field Sponge.Params.t -> t\n\n val absorb : t -> field -> unit\n\n val squeeze : t -> length:int -> bool list\n\n val copy : t -> t\n\n val state : t -> field Sponge.State.t\n\n val squeeze_field : t -> field\n end\n\n val digest :\n field Sponge.Params.t\n -> Inputs.Field.t Core_kernel.Array.t\n -> (int64, Composition_types.Digest.Limbs.n) Pickles_types.Vector.t\nend\n\nmodule Make (Field : Kimchi_backend.Field.S) :\n S with module Inputs.Field = Field = struct\n module Inputs = struct\n include Rounds\n module Field = Field\n\n let alpha = 7\n\n (* x^7 *)\n let to_the_alpha x =\n (* square |> mul x |> square |> mul x *)\n (* 7 = 1 + 2 (1 + 2) *)\n let open Field in\n let res = square x in\n res *= x ;\n (* x^3 *)\n Mutable.square res ;\n (* x^6 *)\n res *= x ;\n (* x^7 *)\n res\n\n module Operations = struct\n module Field = Field\n\n let add_assign ~state i x = Field.(state.(i) += x)\n\n let apply_affine_map (matrix, constants) v =\n let dotv row =\n Array.reduce_exn (Array.map2_exn row v ~f:Field.( * )) ~f:Field.( + )\n in\n let res = Array.map matrix ~f:dotv in\n for i = 0 to Array.length res - 1 do\n Field.(res.(i) += constants.(i))\n done ;\n res\n\n let copy a = Array.map a ~f:(fun x -> Field.(x + zero))\n end\n end\n\n module Field = Sponge.Make_sponge (Sponge.Poseidon (Inputs))\n\n module Bits =\n Sponge.Bit_sponge.Make\n (Bool)\n (struct\n include Inputs.Field\n\n let high_entropy_bits = high_entropy_bits\n\n let finalize_discarded = ignore\n end)\n (Inputs.Field)\n (Field)\n\n let digest params elts =\n let sponge = Bits.create params in\n Array.iter elts ~f:(Bits.absorb sponge) ;\n Bits.squeeze_field sponge |> Inputs.Field.to_bits |> D.Constant.of_bits\nend\n\nmodule Test\n (Impl : Snarky_backendless.Snark_intf.Run)\n (S_constant : Sponge.Intf.Sponge\n with module Field := Impl.Field.Constant\n and module State := Sponge.State\n and type input := Impl.field\n and type digest := Impl.field)\n (S_checked : Sponge.Intf.Sponge\n with module Field := Impl.Field\n and module State := Sponge.State\n and type input := Impl.Field.t\n and type digest := Impl.Field.t) =\nstruct\n open Impl\n\n let test params : unit =\n let n = 10 in\n let a = Array.init n ~f:(fun _ -> Field.Constant.random ()) in\n Impl.Internal_Basic.Test.test_equal ~sexp_of_t:Field.Constant.sexp_of_t\n ~equal:Field.Constant.equal\n (Typ.array ~length:n Field.typ)\n Field.typ\n (fun a ->\n make_checked (fun () ->\n let s =\n S_checked.create (Sponge.Params.map ~f:Field.constant params)\n in\n Array.iter a ~f:(S_checked.absorb s) ;\n S_checked.squeeze s ) )\n (fun a ->\n let s = S_constant.create params in\n Array.iter a ~f:(S_constant.absorb s) ;\n S_constant.squeeze s )\n a\nend\n","include Make_sponge.Make (Backend.Tick.Field)\n\nlet params =\n (* HACK *)\n Sponge.Params.(\n let testbit n i = Bigint.(equal (shift_right n i land one) one) in\n map pasta_p_kimchi ~f:(fun s ->\n Backend.Tick.Field.of_bits\n (List.init Backend.Tick.Field.size_in_bits\n ~f:(testbit (Bigint.of_string s)) ) ))\n","open Core_kernel\nopen Pickles_types\nopen Backend\nopen Composition_types\nopen Common\n\nlet _wrap_domains = Common.wrap_domains\n\nlet evals =\n let open Plonk_types in\n let e =\n Evals.map (Evaluation_lengths.create ~of_int:Fn.id) ~f:(fun n ->\n let a () = Array.create ~len:n (Ro.tock ()) in\n (a (), a ()) )\n in\n let ex =\n { All_evals.With_public_input.evals = e\n ; public_input = (Ro.tock (), Ro.tock ())\n }\n in\n { All_evals.ft_eval1 = Ro.tock (); evals = ex }\n\nlet evals_combined =\n Plonk_types.All_evals.map evals ~f1:Fn.id\n ~f2:(Array.reduce_exn ~f:Backend.Tock.Field.( + ))\n\nmodule Ipa = struct\n module Wrap = struct\n let challenges =\n Vector.init Tock.Rounds.n ~f:(fun _ ->\n let prechallenge = Ro.scalar_chal () in\n { Bulletproof_challenge.prechallenge } )\n\n let challenges_computed =\n Vector.map challenges ~f:(fun { prechallenge } : Tock.Field.t ->\n Ipa.Wrap.compute_challenge prechallenge )\n\n let sg =\n lazy (time \"dummy wrap sg\" (fun () -> Ipa.Wrap.compute_sg challenges))\n end\n\n module Step = struct\n let challenges =\n Vector.init Tick.Rounds.n ~f:(fun _ ->\n let prechallenge = Ro.scalar_chal () in\n { Bulletproof_challenge.prechallenge } )\n\n let challenges_computed =\n Vector.map challenges ~f:(fun { prechallenge } : Tick.Field.t ->\n Ipa.Step.compute_challenge prechallenge )\n\n let sg =\n lazy (time \"dummy wrap sg\" (fun () -> Ipa.Step.compute_sg challenges))\n end\nend\n","open Core_kernel\nopen Pickles_types\nopen Hlist\nopen Common\nopen Import\nopen Types\nopen Wrap_main_inputs\nopen Impl\nmodule SC = Scalar_challenge\n\n(* Let's define an OCaml encoding for inductive NP sets. Let A be an inductive NP set.\n\n To encode A, we require types [var(A)] and [value(A)] corresponding to\n \\mathcal{U}(A) the underlying set of A.\n\n Let r_1, ..., r_n be the inductive rules of A.\n For each i, let (A_{i, 1}, ..., A_{i, k_i}) be the predecessor inductive sets for rule i.\n\n We define a few type level lists.\n\n - For each rule r_i,\n [prev_vars(r_i) := var(A_{i, 1}) * (var(A_{i, 2}) * (... * var(A_{i, k_i})))]\n [prev_values(r_i) := value(A_{i, 1}) * (value(A_{i, 2}) * (... * value(A_{i, k_i})))]\n\n - [prev_varss(A) := map prev_vars (r_1, ..., r_n)]\n - [prev_valuess(A) := map prev_values (r_1, ..., r_n)]\n\n We use corresponding type variable names throughout this file.\n*)\n\nmodule Old_bulletproof_chals = struct\n type t =\n | T :\n 'max_local_max_proofs_verified Nat.t\n * 'max_local_max_proofs_verified Challenges_vector.t\n -> t\nend\n\nlet pack_statement max_proofs_verified t =\n let open Types.Step in\n Spec.pack\n (module Impl)\n (Statement.spec max_proofs_verified Backend.Tock.Rounds.n)\n (Statement.to_data t)\n\nlet shifts ~log2_size = Common.tock_shifts ~log2_size\n\nlet domain_generator ~log2_size =\n Backend.Tock.Field.domain_generator ~log2_size |> Impl.Field.constant\n\nlet _split_field_typ : (Field.t * Boolean.var, Field.Constant.t) Typ.t =\n Typ.transport\n Typ.(field * Boolean.typ)\n ~there:(fun (x : Field.Constant.t) ->\n let n = Bigint.of_field x in\n let is_odd = Bigint.test_bit n 0 in\n let y = Field.Constant.((if is_odd then x - one else x) / of_int 2) in\n (y, is_odd) )\n ~back:(fun (hi, is_odd) ->\n let open Field.Constant in\n let x = hi + hi in\n if is_odd then x + one else x )\n\n(* Split a field element into its high bits (packed) and the low bit.\n\n It does not check that the \"high bits\" actually fit into n - 1 bits,\n this is deferred to a call to scale_fast2, which performs this check.\n*)\nlet split_field (x : Field.t) : Field.t * Boolean.var =\n let ((y, is_odd) as res) =\n exists\n Typ.(field * Boolean.typ)\n ~compute:(fun () ->\n let x = As_prover.read_var x in\n let n = Bigint.of_field x in\n let is_odd = Bigint.test_bit n 0 in\n let y = Field.Constant.((if is_odd then x - one else x) / of_int 2) in\n (y, is_odd) )\n in\n Field.(Assert.equal ((of_int 2 * y) + (is_odd :> t)) x) ;\n res\n\n(* The SNARK function for wrapping any proof coming from the given set of keys *)\nlet wrap_main\n (type max_proofs_verified branches prev_varss max_local_max_proofs_verifieds)\n ~feature_flags\n (full_signature :\n ( max_proofs_verified\n , branches\n , max_local_max_proofs_verifieds )\n Full_signature.t ) (pi_branches : (prev_varss, branches) Hlist.Length.t)\n (step_keys :\n ( Wrap_main_inputs.Inner_curve.Constant.t Wrap_verifier.index'\n , branches )\n Vector.t\n Lazy.t ) (step_widths : (int, branches) Vector.t)\n (step_domains : (Domains.t, branches) Vector.t) ~srs\n (max_proofs_verified :\n (module Nat.Add.Intf with type n = max_proofs_verified) ) :\n (max_proofs_verified, max_local_max_proofs_verifieds) Requests.Wrap.t\n * ( ( _\n , _\n , _ Shifted_value.Type1.t\n , _\n , _\n , _\n , _\n , _\n , _\n , _\n , _ )\n Types.Wrap.Statement.In_circuit.t\n -> unit ) =\n Timer.clock __LOC__ ;\n let module Max_proofs_verified = ( val max_proofs_verified : Nat.Add.Intf\n with type n = max_proofs_verified )\n in\n let T = Max_proofs_verified.eq in\n let branches = Hlist.Length.to_nat pi_branches in\n Timer.clock __LOC__ ;\n let (module Req) =\n Requests.Wrap.(\n (create () : (max_proofs_verified, max_local_max_proofs_verifieds) t))\n in\n Timer.clock __LOC__ ;\n let { Full_signature.padded = _; maxes = (module Max_widths_by_slot) } =\n full_signature\n in\n Timer.clock __LOC__ ;\n let main\n ({ proof_state =\n { deferred_values =\n { plonk\n ; xi\n ; combined_inner_product\n ; b\n ; branch_data\n ; bulletproof_challenges\n }\n ; sponge_digest_before_evaluations\n ; messages_for_next_wrap_proof = messages_for_next_wrap_proof_digest\n }\n ; messages_for_next_step_proof = _\n } :\n ( _\n , _\n , _ Shifted_value.Type1.t\n , _\n , _\n , _\n , _\n , _\n , _\n , _\n , Field.t )\n Types.Wrap.Statement.In_circuit.t ) =\n let logger = Internal_tracing_context_logger.get () in\n with_label __LOC__ (fun () ->\n let which_branch' =\n exists\n (Typ.transport Field.typ ~there:Field.Constant.of_int\n ~back:(fun _ -> failwith \"unimplemented\") )\n ~request:(fun () -> Req.Which_branch)\n in\n let which_branch =\n Wrap_verifier.One_hot_vector.of_index which_branch' ~length:branches\n in\n let actual_proofs_verified_mask =\n Util.ones_vector\n (module Impl)\n ~first_zero:\n (Wrap_verifier.Pseudo.choose\n (which_branch, step_widths)\n ~f:Field.of_int )\n Max_proofs_verified.n\n |> Vector.rev\n in\n let domain_log2 =\n Wrap_verifier.Pseudo.choose\n ( which_branch\n , Vector.map ~f:(fun ds -> Domain.log2_size ds.h) step_domains )\n ~f:Field.of_int\n in\n let () =\n with_label __LOC__ (fun () ->\n (* Check that the branch_data public-input is correct *)\n Branch_data.Checked.pack\n (module Impl)\n { proofs_verified_mask =\n Vector.extend_front_exn actual_proofs_verified_mask Nat.N2.n\n Boolean.false_\n ; domain_log2\n }\n |> Field.Assert.equal branch_data )\n in\n let prev_proof_state =\n with_label __LOC__ (fun () ->\n let open Types.Step.Proof_state in\n let typ =\n typ\n (module Impl)\n Common.Lookup_parameters.tock_zero\n ~assert_16_bits:(Wrap_verifier.assert_n_bits ~n:16)\n (Vector.init Max_proofs_verified.n ~f:(fun _ ->\n Plonk_types.Features.none ) )\n (Shifted_value.Type2.typ Field.typ)\n in\n exists typ ~request:(fun () -> Req.Proof_state) )\n in\n let step_plonk_index =\n with_label __LOC__ (fun () ->\n Wrap_verifier.choose_key which_branch\n (Vector.map (Lazy.force step_keys)\n ~f:(Plonk_verification_key_evals.map ~f:Inner_curve.constant) ) )\n in\n let prev_step_accs =\n with_label __LOC__ (fun () ->\n exists (Vector.typ Inner_curve.typ Max_proofs_verified.n)\n ~request:(fun () -> Req.Step_accs) )\n in\n let old_bp_chals =\n with_label __LOC__ (fun () ->\n let typ =\n let module T =\n H1.Typ (Impls.Wrap) (Nat) (Challenges_vector)\n (Challenges_vector.Constant)\n (struct\n let f (type n) (n : n Nat.t) =\n Vector.typ\n (Vector.typ Field.typ Backend.Tock.Rounds.n)\n n\n end)\n in\n T.f Max_widths_by_slot.maxes\n in\n let module Z = H1.Zip (Nat) (Challenges_vector) in\n let module M =\n H1.Map\n (H1.Tuple2 (Nat) (Challenges_vector))\n (E01 (Old_bulletproof_chals))\n (struct\n let f (type n)\n ((n, v) : n H1.Tuple2(Nat)(Challenges_vector).t) =\n Old_bulletproof_chals.T (n, v)\n end)\n in\n let module V = H1.To_vector (Old_bulletproof_chals) in\n Z.f Max_widths_by_slot.maxes\n (exists typ ~request:(fun () -> Req.Old_bulletproof_challenges))\n |> M.f\n |> V.f Max_widths_by_slot.length )\n in\n let new_bulletproof_challenges =\n with_label __LOC__ (fun () ->\n let evals =\n let ty =\n let ty =\n Plonk_types.All_evals.typ (module Impl) feature_flags\n in\n Vector.typ ty Max_proofs_verified.n\n in\n exists ty ~request:(fun () -> Req.Evals)\n in\n let chals =\n let wrap_domains =\n let all_possible_domains =\n Wrap_verifier.all_possible_domains ()\n in\n let wrap_domain_indices =\n exists (Vector.typ Field.typ Max_proofs_verified.n)\n ~request:(fun () -> Req.Wrap_domain_indices)\n in\n Vector.map wrap_domain_indices ~f:(fun index ->\n let which_branch =\n Wrap_verifier.One_hot_vector.of_index index\n ~length:Wrap_verifier.num_possible_domains\n in\n Wrap_verifier.Pseudo.Domain.to_domain ~shifts\n ~domain_generator\n (which_branch, all_possible_domains) )\n in\n Vector.mapn\n [ (* This is padded to max_proofs_verified for the benefit of wrapping with dummy unfinalized proofs *)\n prev_proof_state.unfinalized_proofs\n ; old_bp_chals\n ; evals\n ; wrap_domains\n ]\n ~f:(fun\n [ { deferred_values\n ; sponge_digest_before_evaluations\n ; should_finalize\n }\n ; old_bulletproof_challenges\n ; evals\n ; wrap_domain\n ]\n ->\n let sponge =\n let s = Sponge.create sponge_params in\n Sponge.absorb s sponge_digest_before_evaluations ;\n s\n in\n\n (* the type of the local max proofs-verified depends on\n which kind of step proof we are wrapping. *)\n (* For each i in [0..max_proofs_verified-1], we have\n max_local_max_proofs_verified, which is the largest\n Local_max_proofs_verified which is the i^th inner proof of a step proof.\n\n Need to compute this value from the which_branch.\n *)\n let (T\n ( _max_local_max_proofs_verified\n , old_bulletproof_challenges ) ) =\n old_bulletproof_challenges\n in\n let old_bulletproof_challenges =\n Wrap_hack.Checked.pad_challenges\n old_bulletproof_challenges\n in\n let finalized, chals =\n with_label __LOC__ (fun () ->\n Wrap_verifier.finalize_other_proof\n (module Wrap_hack.Padded_length)\n ~domain:(wrap_domain :> _ Plonk_checks.plonk_domain)\n ~sponge ~old_bulletproof_challenges deferred_values\n evals )\n in\n Boolean.(Assert.any [ finalized; not should_finalize ]) ;\n chals )\n in\n chals )\n in\n let prev_statement =\n let prev_messages_for_next_wrap_proof =\n Vector.map2 prev_step_accs old_bp_chals\n ~f:(fun sacc (T (max_local_max_proofs_verified, chals)) ->\n Wrap_hack.Checked.hash_messages_for_next_wrap_proof\n max_local_max_proofs_verified\n { challenge_polynomial_commitment = sacc\n ; old_bulletproof_challenges = chals\n } )\n in\n { Types.Step.Statement.messages_for_next_wrap_proof =\n prev_messages_for_next_wrap_proof\n ; proof_state = prev_proof_state\n }\n in\n let openings_proof =\n let shift = Shifts.tick1 in\n exists\n (Plonk_types.Openings.Bulletproof.typ\n ( Typ.transport Wrap_verifier.Other_field.Packed.typ\n ~there:(fun x ->\n (* When storing, make it a shifted value *)\n match\n Shifted_value.Type1.of_field\n (module Backend.Tick.Field)\n ~shift x\n with\n | Shifted_value x ->\n x )\n ~back:(fun x ->\n Shifted_value.Type1.to_field\n (module Backend.Tick.Field)\n ~shift (Shifted_value x) )\n (* When reading, unshift *)\n |> Typ.transport_var\n (* For the var, we just wrap the now shifted underlying value. *)\n ~there:(fun (Shifted_value.Type1.Shifted_value x) -> x)\n ~back:(fun x -> Shifted_value x) )\n Inner_curve.typ\n ~length:(Nat.to_int Backend.Tick.Rounds.n) )\n ~request:(fun () -> Req.Openings_proof)\n in\n let ( sponge_digest_before_evaluations_actual\n , (`Success bulletproof_success, bulletproof_challenges_actual) ) =\n let messages =\n with_label __LOC__ (fun () ->\n exists\n (Plonk_types.Messages.typ\n (module Impl)\n Inner_curve.typ ~bool:Boolean.typ feature_flags\n ~dummy:Inner_curve.Params.one\n ~commitment_lengths:\n (Commitment_lengths.create ~of_int:Fn.id) )\n ~request:(fun () -> Req.Messages) )\n in\n let sponge = Wrap_verifier.Opt.create sponge_params in\n with_label __LOC__ (fun () ->\n [%log internal] \"Wrap_verifier_incrementally_verify_proof\" ;\n let res =\n Wrap_verifier.incrementally_verify_proof max_proofs_verified\n ~actual_proofs_verified_mask ~step_domains\n ~verification_key:step_plonk_index ~srs ~xi ~sponge\n ~public_input:\n (Array.map\n (pack_statement Max_proofs_verified.n prev_statement)\n ~f:(function\n | `Field (Shifted_value x) ->\n `Field (split_field x)\n | `Packed_bits (x, n) ->\n `Packed_bits (x, n) ) )\n ~sg_old:prev_step_accs\n ~advice:{ b; combined_inner_product }\n ~messages ~which_branch ~openings_proof ~plonk\n in\n [%log internal] \"Wrap_verifier_incrementally_verify_proof_done\" ;\n res )\n in\n with_label __LOC__ (fun () ->\n Boolean.Assert.is_true bulletproof_success ) ;\n with_label __LOC__ (fun () ->\n Field.Assert.equal messages_for_next_wrap_proof_digest\n (Wrap_hack.Checked.hash_messages_for_next_wrap_proof\n Max_proofs_verified.n\n { Types.Wrap.Proof_state.Messages_for_next_wrap_proof\n .challenge_polynomial_commitment =\n openings_proof.challenge_polynomial_commitment\n ; old_bulletproof_challenges = new_bulletproof_challenges\n } ) ) ;\n with_label __LOC__ (fun () ->\n Field.Assert.equal sponge_digest_before_evaluations\n sponge_digest_before_evaluations_actual ) ;\n Array.iter2_exn bulletproof_challenges_actual\n (Vector.to_array bulletproof_challenges)\n ~f:(fun\n { prechallenge = { inner = x1 } }\n ({ prechallenge = { inner = x2 } } :\n _ SC.t Bulletproof_challenge.t )\n -> with_label __LOC__ (fun () -> Field.Assert.equal x1 x2) ) ;\n () )\n in\n Timer.clock __LOC__ ;\n ((module Req), main)\n","open Pickles_types\nopen Plonk_types\n\nlet create (type a) ~(of_int : int -> a) :\n (a Columns_vec.t, a, a) Messages.Poly.t =\n let one = of_int 1 in\n { w = Vector.init Plonk_types.Columns.n ~f:(fun _ -> one)\n ; z = one\n ; t = of_int 7\n }\n","let create ~of_int =\n let one = of_int 1 in\n let open Pickles_types in\n let open Plonk_types in\n Evals.\n { w = Vector.init Columns.n ~f:(fun _ -> one)\n ; coefficients = Vector.init Columns.n ~f:(fun _ -> one)\n ; z = one\n ; s = Vector.init Permuts_minus_1.n ~f:(fun _ -> one)\n ; generic_selector = one\n ; poseidon_selector = one\n ; complete_add_selector = one\n ; mul_selector = one\n ; emul_selector = one\n ; endomul_scalar_selector = one\n ; (* FIXME *)\n range_check0_selector = None\n ; range_check1_selector = None\n ; foreign_field_add_selector = None\n ; foreign_field_mul_selector = None\n ; xor_selector = None\n ; rot_selector = None\n ; lookup_aggregation = None\n ; lookup_table = None\n ; lookup_sorted = Vector.init Nat.N5.n ~f:(fun _ -> None)\n ; runtime_lookup_table = None\n ; runtime_lookup_table_selector = None\n ; xor_lookup_selector = None\n ; lookup_gate_lookup_selector = None\n ; range_check_lookup_selector = None\n ; foreign_field_mul_lookup_selector = None\n }\n","open Core_kernel\nopen Backend\nopen Import\n\nlet bits_random_oracle =\n let h = Digestif.blake2s 32 in\n fun ~length s ->\n Digestif.digest_string h s |> Digestif.to_raw_string h |> String.to_list\n |> List.concat_map ~f:(fun c ->\n let c = Char.to_int c in\n List.init 8 ~f:(fun i -> (c lsr i) land 1 = 1) )\n |> fun a -> List.take a length\n\nlet ro lab length f =\n let r = ref 0 in\n fun () ->\n incr r ;\n f (bits_random_oracle ~length (sprintf \"%s_%d\" lab !r))\n\nlet tock = ro \"fq\" Tock.Field.size_in_bits Tock.Field.of_bits\n\nlet tick = ro \"fp\" Tick.Field.size_in_bits Tick.Field.of_bits\n\nlet chal = ro \"chal\" Challenge.Constant.length Challenge.Constant.of_bits\n\nlet scalar_chal () = Scalar_challenge.create (chal ())\n","module P = Proof\n\nmodule type Statement_intf = Intf.Statement\n\nmodule type Statement_var_intf = Intf.Statement_var\n\nmodule type Statement_value_intf = Intf.Statement_value\n\nmodule SC = Scalar_challenge\nopen Core_kernel\nopen Async_kernel\nopen Import\nopen Pickles_types\nopen Poly_types\nopen Hlist\nopen Backend\n\nexception Return_digest of Md5.t\n\nlet profile_constraints = false\n\nlet verify_promise = Verify.verify\n\nopen Kimchi_backend\nmodule Proof_ = P.Base\nmodule Proof = P\n\nlet pad_messages_for_next_wrap_proof\n (type local_max_proofs_verifieds max_local_max_proofs_verifieds\n max_proofs_verified )\n (module M : Hlist.Maxes.S\n with type ns = max_local_max_proofs_verifieds\n and type length = max_proofs_verified )\n (messages_for_next_wrap_proofs :\n local_max_proofs_verifieds\n H1.T(Proof_.Messages_for_next_proof_over_same_field.Wrap).t ) =\n let dummy_chals = Dummy.Ipa.Wrap.challenges in\n let module Messages =\n H1.T (Proof_.Messages_for_next_proof_over_same_field.Wrap) in\n let module Maxes = H1.T (Nat) in\n let (T (messages_len, _)) = Messages.length messages_for_next_wrap_proofs in\n let (T (maxes_len, _)) = Maxes.length M.maxes in\n let (T difference) =\n let rec sub : type n m. n Nat.t -> m Nat.t -> Nat.e =\n fun x y ->\n let open Nat in\n match (x, y) with\n | _, Z ->\n T x\n | Z, S _ ->\n assert false\n | S x, S y ->\n sub x y\n in\n sub maxes_len messages_len\n in\n let rec go :\n type len ms ns. len Nat.t -> ms Maxes.t -> ns Messages.t -> ms Messages.t\n =\n fun pad maxes messages_for_next_wrap_proofs ->\n match (pad, maxes, messages_for_next_wrap_proofs) with\n | S pad, m :: maxes, _ ->\n { challenge_polynomial_commitment = Lazy.force Dummy.Ipa.Step.sg\n ; old_bulletproof_challenges = Vector.init m ~f:(fun _ -> dummy_chals)\n }\n :: go pad maxes messages_for_next_wrap_proofs\n | S _, [], _ ->\n assert false\n | Z, [], [] ->\n []\n | ( Z\n , m :: maxes\n , messages_for_next_wrap_proof :: messages_for_next_wrap_proofs ) ->\n let messages_for_next_wrap_proof =\n { messages_for_next_wrap_proof with\n old_bulletproof_challenges =\n Vector.extend_exn\n messages_for_next_wrap_proof.old_bulletproof_challenges m\n dummy_chals\n }\n in\n messages_for_next_wrap_proof :: go Z maxes messages_for_next_wrap_proofs\n | Z, [], _ :: _ | Z, _ :: _, [] ->\n assert false\n in\n go difference M.maxes messages_for_next_wrap_proofs\n\nmodule type Proof_intf = sig\n type statement\n\n type t\n\n val verification_key : Verification_key.t Lazy.t\n\n val id : Cache.Wrap.Key.Verification.t Lazy.t\n\n val verify : (statement * t) list -> unit Or_error.t Deferred.t\n\n val verify_promise : (statement * t) list -> unit Or_error.t Promise.t\nend\n\nmodule Prover = struct\n type ('prev_values, 'local_widths, 'local_heights, 'a_value, 'proof) t =\n ?handler:\n ( Snarky_backendless.Request.request\n -> Snarky_backendless.Request.response )\n -> 'a_value\n -> 'proof\nend\n\ntype ('max_proofs_verified, 'branches, 'prev_varss) wrap_main_generic =\n { wrap_main :\n 'max_local_max_proofs_verifieds.\n Domains.t\n -> ( 'max_proofs_verified\n , 'branches\n , 'max_local_max_proofs_verifieds )\n Full_signature.t\n -> ('prev_varss, 'branches) Hlist.Length.t\n -> ( Wrap_main_inputs.Inner_curve.Constant.t Wrap_verifier.index'\n , 'branches )\n Vector.t\n Lazy.t\n -> (int, 'branches) Pickles_types.Vector.t\n -> (Import.Domains.t, 'branches) Pickles_types.Vector.t\n -> (module Pickles_types.Nat.Add.Intf with type n = 'max_proofs_verified)\n -> ('max_proofs_verified, 'max_local_max_proofs_verifieds) Requests.Wrap.t\n * ( ( ( Impls.Wrap.Field.t\n , Wrap_verifier.Challenge.t Kimchi_types.scalar_challenge\n , Wrap_verifier.Other_field.Packed.t Shifted_value.Type1.t\n , ( Wrap_verifier.Other_field.Packed.t Shifted_value.Type1.t\n , Impls.Wrap.Boolean.var )\n Plonk_types.Opt.t\n , ( Impls.Wrap.Impl.Field.t Composition_types.Scalar_challenge.t\n Composition_types.Wrap.Proof_state.Deferred_values.Plonk\n .In_circuit\n .Lookup\n .t\n , Impls.Wrap.Boolean.var )\n Pickles_types__Plonk_types.Opt.t\n , Impls.Wrap.Boolean.var )\n Composition_types.Wrap.Proof_state.Deferred_values.Plonk\n .In_circuit\n .t\n , Wrap_verifier.Challenge.t Kimchi_types.scalar_challenge\n , Wrap_verifier.Other_field.Packed.t\n Pickles_types__Shifted_value.Type1.t\n , Impls.Wrap.Field.t\n , Impls.Wrap.Field.t\n , Impls.Wrap.Field.t\n , ( Impls.Wrap.Field.t Import.Scalar_challenge.t\n Import.Types.Bulletproof_challenge.t\n , Backend.Tick.Rounds.n )\n Vector.T.t\n , Impls.Wrap.Field.t )\n Composition_types.Wrap.Statement.t\n -> unit )\n (** An override for wrap_main, which allows for adversarial testing\n with an 'invalid' pickles statement by passing a dummy proof.\n *)\n ; tweak_statement :\n 'actual_proofs_verified 'b 'e.\n ( Import.Challenge.Constant.t\n , Import.Challenge.Constant.t Import.Types.Scalar_challenge.t\n , Backend.Tick.Field.t Pickles_types.Shifted_value.Type1.t\n , ( Backend.Tick.Field.t Pickles_types.Shifted_value.Type1.t\n , bool )\n Import.Types.Opt.t\n , ( Import.Challenge.Constant.t Import.Types.Scalar_challenge.t\n Composition_types.Wrap.Proof_state.Deferred_values.Plonk.In_circuit\n .Lookup\n .t\n , bool )\n Import.Types.Opt.t\n , bool\n , 'max_proofs_verified\n Proof.Base.Messages_for_next_proof_over_same_field.Wrap.t\n , (int64, Composition_types.Digest.Limbs.n) Pickles_types.Vector.vec\n , ( 'b\n , ( Kimchi_pasta.Pallas_based_plonk.Proof.G.Affine.t\n , 'actual_proofs_verified )\n Pickles_types.Vector.t\n , ( ( Import.Challenge.Constant.t Import.Scalar_challenge.t\n Import.Bulletproof_challenge.t\n , 'e )\n Pickles_types.Vector.t\n , 'actual_proofs_verified )\n Pickles_types.Vector.t )\n Proof.Base.Messages_for_next_proof_over_same_field.Step.t\n , Import.Challenge.Constant.t Import.Types.Scalar_challenge.t\n Import.Types.Bulletproof_challenge.t\n Import.Types.Step_bp_vec.t\n , Import.Types.Branch_data.t )\n Import.Types.Wrap.Statement.In_circuit.t\n -> ( Import.Challenge.Constant.t\n , Import.Challenge.Constant.t Import.Types.Scalar_challenge.t\n , Backend.Tick.Field.t Pickles_types.Shifted_value.Type1.t\n , ( Backend.Tick.Field.t Pickles_types.Shifted_value.Type1.t\n , bool )\n Import.Types.Opt.t\n , ( Import.Challenge.Constant.t Import.Types.Scalar_challenge.t\n Composition_types.Wrap.Proof_state.Deferred_values.Plonk.In_circuit\n .Lookup\n .t\n , bool )\n Import.Types.Opt.t\n , bool\n , 'max_proofs_verified\n Proof.Base.Messages_for_next_proof_over_same_field.Wrap.t\n , ( Limb_vector.Constant.Hex64.t\n , Composition_types.Digest.Limbs.n )\n Pickles_types.Vector.vec\n , ( 'b\n , ( Kimchi_pasta.Pallas_based_plonk.Proof.G.Affine.t\n , 'actual_proofs_verified )\n Pickles_types.Vector.t\n , ( ( Import.Challenge.Constant.t Import.Scalar_challenge.t\n Import.Bulletproof_challenge.t\n , 'e )\n Pickles_types.Vector.t\n , 'actual_proofs_verified )\n Pickles_types.Vector.t )\n Proof.Base.Messages_for_next_proof_over_same_field.Step.t\n , Import.Challenge.Constant.t Import.Types.Scalar_challenge.t\n Import.Types.Bulletproof_challenge.t\n Import.Types.Step_bp_vec.t\n , Import.Types.Branch_data.t )\n Import.Types.Wrap.Statement.In_circuit.t\n (** A function to modify the statement passed into the wrap proof,\n which will be later passed to recursion pickles rules.\n\n This function can be used to modify the pickles statement in an\n adversarial way, along with [wrap_main] above that allows that\n statement to be accepted.\n *)\n }\n\nmodule Make\n (Arg_var : Statement_var_intf)\n (Arg_value : Statement_value_intf)\n (Ret_var : T0)\n (Ret_value : T0)\n (Auxiliary_var : T0)\n (Auxiliary_value : T0) =\nstruct\n module IR =\n Inductive_rule.T (Arg_var) (Arg_value) (Ret_var) (Ret_value) (Auxiliary_var)\n (Auxiliary_value)\n module HIR = H4.T (IR)\n\n let max_local_max_proofs_verifieds ~self (type n)\n (module Max_proofs_verified : Nat.Intf with type n = n) branches choices =\n let module Local_max_proofs_verifieds = struct\n type t = (int, Max_proofs_verified.n) Vector.t\n end in\n let module M =\n H4.Map (IR) (E04 (Local_max_proofs_verifieds))\n (struct\n module V = H4.To_vector (Int)\n module HT = H4.T (Tag)\n\n module M =\n H4.Map (Tag) (E04 (Int))\n (struct\n let f (type a b c d) (t : (a, b, c, d) Tag.t) : int =\n if Type_equal.Id.same t.id self then\n Nat.to_int Max_proofs_verified.n\n else\n let (module M) = Types_map.max_proofs_verified t in\n Nat.to_int M.n\n end)\n\n let f :\n type a b c d. (a, b, c, d) IR.t -> Local_max_proofs_verifieds.t =\n fun rule ->\n let (T (_, l)) = HT.length rule.prevs in\n Vector.extend_front_exn\n (V.f l (M.f rule.prevs))\n Max_proofs_verified.n 0\n end)\n in\n let module V = H4.To_vector (Local_max_proofs_verifieds) in\n let padded = V.f branches (M.f choices) |> Vector.transpose in\n (padded, Maxes.m padded)\n\n module Lazy_keys = struct\n type t =\n (Impls.Step.Keypair.t * Dirty.t) Lazy.t\n * (Kimchi_bindings.Protocol.VerifierIndex.Fp.t * Dirty.t) Lazy.t\n\n (* TODO Think this is right.. *)\n end\n\n let log_step main _typ name index =\n let module Constraints = Snarky_log.Constraints (Impls.Step.Internal_Basic) in\n let log =\n let weight =\n let sys = Backend.Tick.R1CS_constraint_system.create () in\n fun ({ annotation; basic } : Impls.Step.Constraint.t) ->\n let prev =\n Kimchi_pasta_constraint_system.Vesta_constraint_system.next_row sys\n in\n Backend.Tick.R1CS_constraint_system.add_constraint sys\n ?label:annotation basic ;\n let next =\n Kimchi_pasta_constraint_system.Vesta_constraint_system.next_row sys\n in\n next - prev\n in\n Constraints.log ~weight (fun () -> Impls.Step.make_checked main)\n in\n if profile_constraints then\n Snarky_log.to_file (sprintf \"step-snark-%s-%d.json\" name index) log\n\n let log_wrap main typ name id =\n let module Constraints = Snarky_log.Constraints (Impls.Wrap.Internal_Basic) in\n let log =\n let sys = Backend.Tock.R1CS_constraint_system.create () in\n let weight ({ annotation; basic } : Impls.Wrap.Constraint.t) =\n let prev =\n Kimchi_pasta_constraint_system.Pallas_constraint_system.next_row sys\n in\n Backend.Tock.R1CS_constraint_system.add_constraint sys ?label:annotation\n basic ;\n let next =\n Kimchi_pasta_constraint_system.Pallas_constraint_system.next_row sys\n in\n next - prev\n in\n let log =\n Constraints.log ~weight\n Impls.Wrap.(\n fun () ->\n make_checked (fun () : unit ->\n let x = with_label __LOC__ (fun () -> exists typ) in\n main x () ))\n in\n log\n in\n if profile_constraints then\n Snarky_log.to_file\n (sprintf\n !\"wrap-%s-%{sexp:Type_equal.Id.Uid.t}.json\"\n name (Type_equal.Id.uid id) )\n log\n\n let compile :\n type var value prev_varss prev_valuess widthss heightss max_proofs_verified branches.\n self:(var, value, max_proofs_verified, branches) Tag.t\n -> cache:Key_cache.Spec.t list\n -> ?disk_keys:\n (Cache.Step.Key.Verification.t, branches) Vector.t\n * Cache.Wrap.Key.Verification.t\n -> ?return_early_digest_exception:bool\n -> ?override_wrap_domain:Pickles_base.Proofs_verified.t\n -> ?override_wrap_main:\n (max_proofs_verified, branches, prev_varss) wrap_main_generic\n -> branches:(module Nat.Intf with type n = branches)\n -> max_proofs_verified:\n (module Nat.Add.Intf with type n = max_proofs_verified)\n -> name:string\n -> constraint_constants:Snark_keys_header.Constraint_constants.t\n -> public_input:\n ( var\n , value\n , Arg_var.t\n , Arg_value.t\n , Ret_var.t\n , Ret_value.t )\n Inductive_rule.public_input\n -> auxiliary_typ:(Auxiliary_var.t, Auxiliary_value.t) Impls.Step.Typ.t\n -> choices:\n ( self:(var, value, max_proofs_verified, branches) Tag.t\n -> (prev_varss, prev_valuess, widthss, heightss) H4.T(IR).t )\n -> unit\n -> ( prev_valuess\n , widthss\n , heightss\n , Arg_value.t\n , ( Ret_value.t\n * Auxiliary_value.t\n * (max_proofs_verified, max_proofs_verified) Proof.t )\n Promise.t )\n H3_2.T(Prover).t\n * _\n * _\n * _ =\n fun ~self ~cache ?disk_keys ?(return_early_digest_exception = false)\n ?override_wrap_domain ?override_wrap_main ~branches:(module Branches)\n ~max_proofs_verified ~name ~constraint_constants ~public_input\n ~auxiliary_typ ~choices () ->\n let snark_keys_header kind constraint_system_hash =\n { Snark_keys_header.header_version = Snark_keys_header.header_version\n ; kind\n ; constraint_constants\n ; commits =\n { mina = Mina_version.commit_id\n ; marlin = Mina_version.marlin_commit_id\n }\n ; length = (* This is a dummy, it gets filled in on read/write. *) 0\n ; commit_date = Mina_version.commit_date\n ; constraint_system_hash\n ; identifying_hash =\n (* TODO: Proper identifying hash. *)\n constraint_system_hash\n }\n in\n Timer.start __LOC__ ;\n let module Max_proofs_verified = ( val max_proofs_verified : Nat.Add.Intf\n with type n = max_proofs_verified )\n in\n let T = Max_proofs_verified.eq in\n let choices = choices ~self in\n let (T (prev_varss_n, prev_varss_length)) = HIR.length choices in\n let T = Nat.eq_exn prev_varss_n Branches.n in\n let padded, (module Maxes) =\n max_local_max_proofs_verifieds\n ( module struct\n include Max_proofs_verified\n end )\n prev_varss_length choices ~self:self.id\n in\n let full_signature = { Full_signature.padded; maxes = (module Maxes) } in\n Timer.clock __LOC__ ;\n let feature_flags =\n let rec go :\n type a b c d.\n (a, b, c, d) H4.T(IR).t\n -> Plonk_types.Opt.Flag.t Plonk_types.Features.t =\n fun rules ->\n match rules with\n | [] ->\n Plonk_types.Features.none\n | [ r ] ->\n Plonk_types.Features.map r.feature_flags ~f:(function\n | true ->\n Plonk_types.Opt.Flag.Yes\n | false ->\n Plonk_types.Opt.Flag.No )\n | r :: rules ->\n let feature_flags = go rules in\n Plonk_types.Features.map2 r.feature_flags feature_flags\n ~f:(fun enabled flag ->\n match (enabled, flag) with\n | true, Yes ->\n Plonk_types.Opt.Flag.Yes\n | false, No ->\n No\n | _, Maybe | true, No | false, Yes ->\n Maybe )\n in\n go choices\n in\n let wrap_domains =\n match override_wrap_domain with\n | None ->\n let module M =\n Wrap_domains.Make (Arg_var) (Arg_value) (Ret_var) (Ret_value)\n (Auxiliary_var)\n (Auxiliary_value)\n in\n M.f full_signature prev_varss_n prev_varss_length ~max_proofs_verified\n ~feature_flags\n | Some override ->\n Common.wrap_domains\n ~proofs_verified:(Pickles_base.Proofs_verified.to_int override)\n in\n Timer.clock __LOC__ ;\n let module Branch_data = struct\n type ('vars, 'vals, 'n, 'm) t =\n ( Arg_var.t\n , Arg_value.t\n , Ret_var.t\n , Ret_value.t\n , Auxiliary_var.t\n , Auxiliary_value.t\n , Max_proofs_verified.n\n , Branches.n\n , 'vars\n , 'vals\n , 'n\n , 'm )\n Step_branch_data.t\n end in\n let proofs_verifieds =\n let module M =\n H4.Map (IR) (E04 (Int))\n (struct\n module M = H4.T (Tag)\n\n let f : type a b c d. (a, b, c, d) IR.t -> int =\n fun r ->\n let (T (n, _)) = M.length r.prevs in\n Nat.to_int n\n end)\n in\n let module V = H4.To_vector (Int) in\n V.f prev_varss_length (M.f choices)\n in\n let step_data =\n let i = ref 0 in\n Timer.clock __LOC__ ;\n let rec f :\n type a b c d.\n (a, b, c, d) H4.T(IR).t -> (a, b, c, d) H4.T(Branch_data).t = function\n | [] ->\n []\n | rule :: rules ->\n let first =\n Timer.clock __LOC__ ;\n let res =\n Common.time \"make step data\" (fun () ->\n Step_branch_data.create ~index:!i ~feature_flags\n ~actual_feature_flags:rule.feature_flags\n ~max_proofs_verified:Max_proofs_verified.n\n ~branches:Branches.n ~self ~public_input ~auxiliary_typ\n Arg_var.to_field_elements Arg_value.to_field_elements rule\n ~wrap_domains ~proofs_verifieds )\n in\n Timer.clock __LOC__ ; incr i ; res\n in\n first :: f rules\n in\n f choices\n in\n Timer.clock __LOC__ ;\n let step_domains =\n let module M =\n H4.Map (Branch_data) (E04 (Domains))\n (struct\n let f (T b : _ Branch_data.t) = b.domains\n end)\n in\n let module V = H4.To_vector (Domains) in\n V.f prev_varss_length (M.f step_data)\n in\n let cache_handle = ref (Lazy.return `Cache_hit) in\n let accum_dirty t = cache_handle := Cache_handle.(!cache_handle + t) in\n Timer.clock __LOC__ ;\n let step_keypairs =\n let disk_keys =\n Option.map disk_keys ~f:(fun (xs, _) -> Vector.to_array xs)\n in\n let module M =\n H4.Map (Branch_data) (E04 (Lazy_keys))\n (struct\n let etyp =\n Impls.Step.input ~proofs_verified:Max_proofs_verified.n\n ~wrap_rounds:Tock.Rounds.n ~feature_flags\n\n let f (T b : _ Branch_data.t) =\n let (T (typ, _conv, conv_inv)) = etyp in\n let main () () =\n let res = b.main ~step_domains () in\n Impls.Step.with_label \"conv_inv\" (fun () -> conv_inv res)\n in\n let () = if true then log_step main typ name b.index in\n let open Impls.Step in\n (* HACK: TODO docs *)\n if return_early_digest_exception then\n raise\n (Return_digest\n ( constraint_system ~input_typ:Typ.unit ~return_typ:typ main\n |> R1CS_constraint_system.digest ) ) ;\n\n let k_p =\n lazy\n (let cs =\n constraint_system ~input_typ:Typ.unit ~return_typ:typ main\n in\n let cs_hash =\n Md5.to_hex (R1CS_constraint_system.digest cs)\n in\n ( Type_equal.Id.uid self.id\n , snark_keys_header\n { type_ = \"step-proving-key\"\n ; identifier = name ^ \"-\" ^ b.rule.identifier\n }\n cs_hash\n , b.index\n , cs ) )\n in\n let k_v =\n match disk_keys with\n | Some ks ->\n Lazy.return ks.(b.index)\n | None ->\n lazy\n (let id, _header, index, cs = Lazy.force k_p in\n let digest = R1CS_constraint_system.digest cs in\n ( id\n , snark_keys_header\n { type_ = \"step-verification-key\"\n ; identifier = name ^ \"-\" ^ b.rule.identifier\n }\n (Md5.to_hex digest)\n , index\n , digest ) )\n in\n let ((pk, vk) as res) =\n Common.time \"step read or generate\" (fun () ->\n Cache.Step.read_or_generate\n ~prev_challenges:(Nat.to_int (fst b.proofs_verified))\n cache k_p k_v\n (Snarky_backendless.Typ.unit ())\n typ main )\n in\n accum_dirty (Lazy.map pk ~f:snd) ;\n accum_dirty (Lazy.map vk ~f:snd) ;\n res\n end)\n in\n M.f step_data\n in\n Timer.clock __LOC__ ;\n let step_vks =\n let module V = H4.To_vector (Lazy_keys) in\n lazy\n (Vector.map (V.f prev_varss_length step_keypairs) ~f:(fun (_, vk) ->\n Tick.Keypair.vk_commitments (fst (Lazy.force vk)) ) )\n in\n Timer.clock __LOC__ ;\n let wrap_requests, wrap_main =\n match override_wrap_main with\n | None ->\n let srs = Tick.Keypair.load_urs () in\n Wrap_main.wrap_main ~feature_flags ~srs full_signature\n prev_varss_length step_vks proofs_verifieds step_domains\n max_proofs_verified\n | Some { wrap_main; tweak_statement = _ } ->\n (* Instead of creating a proof using the pickles wrap circuit, we\n have been asked to create proof in an 'adversarial' way, where\n the wrap circuit is some other circuit.\n The [wrap_main] value passed in as part of [override_wrap_main]\n defines the alternative circuit to run; this will usually be a\n dummy circuit that verifies any public input for the purposes of\n testing.\n *)\n wrap_main wrap_domains full_signature prev_varss_length step_vks\n proofs_verifieds step_domains max_proofs_verified\n in\n Timer.clock __LOC__ ;\n let (wrap_pk, wrap_vk), disk_key =\n let open Impls.Wrap in\n let (T (typ, conv, _conv_inv)) = input () in\n let main x () : unit = wrap_main (conv x) in\n let () = if true then log_wrap main typ name self.id in\n let self_id = Type_equal.Id.uid self.id in\n let disk_key_prover =\n lazy\n (let cs =\n constraint_system ~input_typ:typ\n ~return_typ:(Snarky_backendless.Typ.unit ())\n main\n in\n let cs_hash = Md5.to_hex (R1CS_constraint_system.digest cs) in\n ( self_id\n , snark_keys_header\n { type_ = \"wrap-proving-key\"; identifier = name }\n cs_hash\n , cs ) )\n in\n let disk_key_verifier =\n match disk_keys with\n | None ->\n lazy\n (let id, _header, cs = Lazy.force disk_key_prover in\n let digest = R1CS_constraint_system.digest cs in\n ( id\n , snark_keys_header\n { type_ = \"wrap-verification-key\"; identifier = name }\n (Md5.to_hex digest)\n , digest ) )\n | Some (_, (_id, header, digest)) ->\n Lazy.return (self_id, header, digest)\n in\n let r =\n Common.time \"wrap read or generate \" (fun () ->\n Cache.Wrap.read_or_generate (* Due to Wrap_hack *)\n ~prev_challenges:2 cache disk_key_prover disk_key_verifier typ\n (Snarky_backendless.Typ.unit ())\n main )\n in\n (r, disk_key_verifier)\n in\n Timer.clock __LOC__ ;\n let wrap_vk =\n Lazy.map wrap_vk ~f:(fun ((wrap_vk, _) as res) ->\n let computed_domain_size = wrap_vk.index.domain.log_size_of_group in\n let (Pow_2_roots_of_unity proposed_domain_size) = wrap_domains.h in\n if computed_domain_size <> proposed_domain_size then\n failwithf\n \"This circuit was compiled for proofs using the wrap domain of \\\n size %d, but the actual wrap domain size for the circuit has \\\n size %d. You should pass the ~override_wrap_domain argument to \\\n set the correct domain size.\"\n proposed_domain_size computed_domain_size () ;\n res )\n in\n accum_dirty (Lazy.map wrap_pk ~f:snd) ;\n accum_dirty (Lazy.map wrap_vk ~f:snd) ;\n let wrap_vk = Lazy.map wrap_vk ~f:fst in\n let module S =\n Step.Make (Arg_var) (Arg_value)\n (struct\n include Max_proofs_verified\n end)\n in\n let (typ : (var, value) Impls.Step.Typ.t) =\n match public_input with\n | Input typ ->\n typ\n | Output typ ->\n typ\n | Input_and_output (input_typ, output_typ) ->\n Impls.Step.Typ.(input_typ * output_typ)\n in\n let provers =\n let f :\n type prev_vars prev_values local_widths local_heights.\n (prev_vars, prev_values, local_widths, local_heights) Branch_data.t\n -> Lazy_keys.t\n -> ?handler:\n ( Snarky_backendless.Request.request\n -> Snarky_backendless.Request.response )\n -> Arg_value.t\n -> ( Ret_value.t\n * Auxiliary_value.t\n * (Max_proofs_verified.n, Max_proofs_verified.n) Proof.t )\n Promise.t =\n fun (T b as branch_data) (step_pk, step_vk) ->\n let _, prev_vars_length = b.proofs_verified in\n let step handler next_state =\n let wrap_vk = Lazy.force wrap_vk in\n S.f ?handler branch_data next_state ~prevs_length:prev_vars_length\n ~self ~step_domains ~self_dlog_plonk_index:wrap_vk.commitments\n ~public_input ~auxiliary_typ ~feature_flags\n (Impls.Step.Keypair.pk (fst (Lazy.force step_pk)))\n wrap_vk.index\n in\n let step_vk = fst (Lazy.force step_vk) in\n let wrap ?handler next_state =\n let wrap_vk = Lazy.force wrap_vk in\n let%bind.Promise ( proof\n , return_value\n , auxiliary_value\n , actual_wrap_domains ) =\n step handler ~maxes:(module Maxes) next_state\n in\n let proof =\n { proof with\n statement =\n { proof.statement with\n messages_for_next_wrap_proof =\n pad_messages_for_next_wrap_proof\n (module Maxes)\n proof.statement.messages_for_next_wrap_proof\n }\n }\n in\n let%map.Promise proof =\n let tweak_statement =\n match override_wrap_main with\n | None ->\n None\n | Some { tweak_statement; wrap_main = _ } ->\n (* Extract the [tweak_statement] part of the\n [override_wrap_main], so that we can run an adversarial\n test.\n\n This function modifies the statement that will be proved\n over, and which gets passed to later recursive pickles\n rules.\n *)\n Some tweak_statement\n in\n Wrap.wrap ~max_proofs_verified:Max_proofs_verified.n ~feature_flags\n ~actual_feature_flags:b.feature_flags full_signature.maxes\n wrap_requests ?tweak_statement\n ~dlog_plonk_index:wrap_vk.commitments wrap_main ~typ ~step_vk\n ~step_plonk_indices:(Lazy.force step_vks) ~actual_wrap_domains\n (Impls.Wrap.Keypair.pk (fst (Lazy.force wrap_pk)))\n proof\n in\n ( return_value\n , auxiliary_value\n , Proof.T\n { proof with\n statement =\n { proof.statement with\n messages_for_next_step_proof =\n { proof.statement.messages_for_next_step_proof with\n app_state = ()\n }\n }\n } )\n in\n wrap\n in\n let rec go :\n type xs1 xs2 xs3 xs4.\n (xs1, xs2, xs3, xs4) H4.T(Branch_data).t\n -> (xs1, xs2, xs3, xs4) H4.T(E04(Lazy_keys)).t\n -> ( xs2\n , xs3\n , xs4\n , Arg_value.t\n , ( Ret_value.t\n * Auxiliary_value.t\n * (max_proofs_verified, max_proofs_verified) Proof.t )\n Promise.t )\n H3_2.T(Prover).t =\n fun bs ks ->\n match (bs, ks) with\n | [], [] ->\n []\n | b :: bs, k :: ks ->\n f b k :: go bs ks\n in\n go step_data step_keypairs\n in\n Timer.clock __LOC__ ;\n let data : _ Types_map.Compiled.t =\n { branches = Branches.n\n ; proofs_verifieds\n ; max_proofs_verified\n ; public_input = typ\n ; wrap_key = Lazy.map wrap_vk ~f:Verification_key.commitments\n ; wrap_vk = Lazy.map wrap_vk ~f:Verification_key.index\n ; wrap_domains\n ; step_domains\n ; feature_flags\n }\n in\n Timer.clock __LOC__ ;\n Types_map.add_exn self data ;\n (provers, wrap_vk, disk_key, !cache_handle)\nend\n\nmodule Side_loaded = struct\n module V = Verification_key\n\n module Verification_key = struct\n include Side_loaded_verification_key\n\n let to_input (t : t) =\n to_input ~field_of_int:Impls.Step.Field.Constant.of_int t\n\n let of_compiled tag : t =\n let d = Types_map.lookup_compiled tag.Tag.id in\n let actual_wrap_domain_size =\n Common.actual_wrap_domain_size\n ~log_2_domain_size:(Lazy.force d.wrap_vk).domain.log_size_of_group\n in\n { wrap_vk = Some (Lazy.force d.wrap_vk)\n ; wrap_index = Lazy.force d.wrap_key\n ; max_proofs_verified =\n Pickles_base.Proofs_verified.of_nat (Nat.Add.n d.max_proofs_verified)\n ; actual_wrap_domain_size\n }\n\n module Max_width = Width.Max\n end\n\n let in_circuit tag vk = Types_map.set_ephemeral tag { index = `In_circuit vk }\n\n let in_prover tag vk = Types_map.set_ephemeral tag { index = `In_prover vk }\n\n let create ~name ~max_proofs_verified ~feature_flags ~typ =\n Types_map.add_side_loaded ~name\n { max_proofs_verified\n ; public_input = typ\n ; branches = Verification_key.Max_branches.n\n ; feature_flags\n }\n\n module Proof = struct\n include Proof.Proofs_verified_max\n\n let of_proof : _ Proof.t -> t = Wrap_hack.pad_proof\n end\n\n let verify_promise (type t) ~(typ : (_, t) Impls.Step.Typ.t)\n (ts : (Verification_key.t * t * Proof.t) list) =\n let m =\n ( module struct\n type nonrec t = t\n\n let to_field_elements =\n let (Typ typ) = typ in\n fun x -> fst (typ.value_to_fields x)\n end : Intf.Statement_value\n with type t = t )\n in\n (* TODO: This should be the actual max width on a per proof basis *)\n let max_proofs_verified =\n (module Verification_key.Max_width : Nat.Intf\n with type n = Verification_key.Max_width.n )\n in\n with_return (fun { return } ->\n List.map ts ~f:(fun (vk, x, p) ->\n let vk : V.t =\n { commitments = vk.wrap_index\n ; index =\n ( match vk.wrap_vk with\n | None ->\n return\n (Promise.return\n (Or_error.errorf \"Pickles.verify: wrap_vk not found\") )\n | Some x ->\n x )\n ; data =\n (* This isn't used in verify_heterogeneous, so we can leave this dummy *)\n { constraints = 0 }\n }\n in\n Verify.Instance.T (max_proofs_verified, m, vk, x, p) )\n |> Verify.verify_heterogenous )\n\n let verify ~typ ts = verify_promise ~typ ts |> Promise.to_deferred\n\n let srs_precomputation () : unit =\n let srs = Tock.Keypair.load_urs () in\n List.iter [ 0; 1; 2 ] ~f:(fun i ->\n Kimchi_bindings.Protocol.SRS.Fq.add_lagrange_basis srs\n (Domain.log2_size (Common.wrap_domains ~proofs_verified:i).h) )\nend\n\nlet compile_with_wrap_main_override_promise :\n type var value a_var a_value ret_var ret_value auxiliary_var auxiliary_value prev_varss prev_valuess widthss heightss max_proofs_verified branches.\n ?self:(var, value, max_proofs_verified, branches) Tag.t\n -> ?cache:Key_cache.Spec.t list\n -> ?disk_keys:\n (Cache.Step.Key.Verification.t, branches) Vector.t\n * Cache.Wrap.Key.Verification.t\n -> ?return_early_digest_exception:bool\n -> ?override_wrap_domain:Pickles_base.Proofs_verified.t\n -> ?override_wrap_main:\n (max_proofs_verified, branches, prev_varss) wrap_main_generic\n -> public_input:\n ( var\n , value\n , a_var\n , a_value\n , ret_var\n , ret_value )\n Inductive_rule.public_input\n -> auxiliary_typ:(auxiliary_var, auxiliary_value) Impls.Step.Typ.t\n -> branches:(module Nat.Intf with type n = branches)\n -> max_proofs_verified:\n (module Nat.Add.Intf with type n = max_proofs_verified)\n -> name:string\n -> constraint_constants:Snark_keys_header.Constraint_constants.t\n -> choices:\n ( self:(var, value, max_proofs_verified, branches) Tag.t\n -> ( prev_varss\n , prev_valuess\n , widthss\n , heightss\n , a_var\n , a_value\n , ret_var\n , ret_value\n , auxiliary_var\n , auxiliary_value )\n H4_6.T(Inductive_rule).t )\n -> unit\n -> (var, value, max_proofs_verified, branches) Tag.t\n * Cache_handle.t\n * (module Proof_intf\n with type t = (max_proofs_verified, max_proofs_verified) Proof.t\n and type statement = value )\n * ( prev_valuess\n , widthss\n , heightss\n , a_value\n , ( ret_value\n * auxiliary_value\n * (max_proofs_verified, max_proofs_verified) Proof.t )\n Promise.t )\n H3_2.T(Prover).t =\n (* This function is an adapter between the user-facing Pickles.compile API\n and the underlying Make(_).compile function which builds the circuits.\n *)\n fun ?self ?(cache = []) ?disk_keys ?(return_early_digest_exception = false)\n ?override_wrap_domain ?override_wrap_main ~public_input ~auxiliary_typ\n ~branches ~max_proofs_verified ~name ~constraint_constants ~choices () ->\n let self =\n match self with\n | None ->\n Tag.(create ~kind:Compiled name)\n | Some self ->\n self\n in\n (* Extract to_fields methods from the public input declaration. *)\n let (a_var_to_fields : a_var -> _), (a_value_to_fields : a_value -> _) =\n match public_input with\n | Input (Typ typ) ->\n ( (fun x -> fst (typ.var_to_fields x))\n , fun x -> fst (typ.value_to_fields x) )\n | Output _ ->\n ((fun () -> [||]), fun () -> [||])\n | Input_and_output (Typ typ, _) ->\n ( (fun x -> fst (typ.var_to_fields x))\n , fun x -> fst (typ.value_to_fields x) )\n in\n let module A_var = struct\n type t = a_var\n\n let to_field_elements = a_var_to_fields\n end in\n let module A_value = struct\n type t = a_value\n\n let to_field_elements = a_value_to_fields\n end in\n let module Ret_var = struct\n type t = ret_var\n end in\n let module Ret_value = struct\n type t = ret_value\n end in\n let module Auxiliary_var = struct\n type t = auxiliary_var\n end in\n let module Auxiliary_value = struct\n type t = auxiliary_value\n end in\n let module M =\n Make (A_var) (A_value) (Ret_var) (Ret_value) (Auxiliary_var)\n (Auxiliary_value)\n in\n let rec conv_irs :\n type v1ss v2ss wss hss.\n ( v1ss\n , v2ss\n , wss\n , hss\n , a_var\n , a_value\n , ret_var\n , ret_value\n , auxiliary_var\n , auxiliary_value )\n H4_6.T(Inductive_rule).t\n -> (v1ss, v2ss, wss, hss) H4.T(M.IR).t = function\n | [] ->\n []\n | r :: rs ->\n r :: conv_irs rs\n in\n let provers, wrap_vk, wrap_disk_key, cache_handle =\n M.compile ~return_early_digest_exception ~self ~cache ?disk_keys\n ?override_wrap_domain ?override_wrap_main ~branches ~max_proofs_verified\n ~name ~public_input ~auxiliary_typ ~constraint_constants\n ~choices:(fun ~self -> conv_irs (choices ~self))\n ()\n in\n let (module Max_proofs_verified) = max_proofs_verified in\n let T = Max_proofs_verified.eq in\n let module Value = struct\n type t = value\n\n let typ : (var, value) Impls.Step.Typ.t =\n match public_input with\n | Input typ ->\n typ\n | Output typ ->\n typ\n | Input_and_output (input_typ, output_typ) ->\n Impls.Step.Typ.(input_typ * output_typ)\n\n let to_field_elements =\n let (Typ typ) = typ in\n fun x -> fst (typ.value_to_fields x)\n end in\n let module P = struct\n type statement = value\n\n module Max_local_max_proofs_verified = Max_proofs_verified\n\n include\n Proof.Make\n (struct\n include Max_proofs_verified\n end)\n (struct\n include Max_local_max_proofs_verified\n end)\n\n let id = wrap_disk_key\n\n let verification_key = wrap_vk\n\n let verify_promise ts =\n verify_promise\n ( module struct\n include Max_proofs_verified\n end )\n (module Value)\n (Lazy.force verification_key)\n ts\n\n let verify ts = verify_promise ts |> Promise.to_deferred\n end in\n (self, cache_handle, (module P), provers)\n\nlet wrap_main_dummy_override _ _ _ _ _ _ _ =\n let requests =\n (* The requests that the logic in [Wrap.wrap] use to pass\n values into and out of the wrap proof circuit.\n Since these are unnecessary for the dummy circuit below, we\n generate them without using them.\n *)\n Requests.Wrap.create ()\n in\n (* A replacement for the 'wrap' circuit, which makes no\n assertions about the statement that it receives as its first\n argument.\n *)\n let wrap_main _ =\n let module SC' = SC in\n let open Impls.Wrap in\n let open Wrap_main_inputs in\n (* Create some variables to be used in constraints below. *)\n let x = exists Field.typ ~compute:(fun () -> Field.Constant.of_int 3) in\n let y = exists Field.typ ~compute:(fun () -> Field.Constant.of_int 0) in\n let z = exists Field.typ ~compute:(fun () -> Field.Constant.of_int 0) in\n (* Every circuit must use at least 1 of each constraint; we\n use them here.\n *)\n let () =\n let g = Inner_curve.one in\n let sponge = Sponge.create sponge_params in\n Sponge.absorb sponge x ;\n ignore (Sponge.squeeze_field sponge : Field.t) ;\n ignore\n ( SC'.to_field_checked'\n (module Impl)\n ~num_bits:16\n (Kimchi_backend_common.Scalar_challenge.create x)\n : Field.t * Field.t * Field.t ) ;\n ignore (Ops.scale_fast g ~num_bits:5 (Shifted_value x) : Inner_curve.t) ;\n ignore\n ( Wrap_verifier.Scalar_challenge.endo g ~num_bits:4\n (Kimchi_backend_common.Scalar_challenge.create x)\n : Field.t * Field.t )\n in\n (* Pad the circuit so that its domain size matches the one\n that would have been used by the true wrap_main.\n *)\n for _ = 0 to 64000 do\n assert_r1cs x y z\n done\n in\n (requests, wrap_main)\n\nmodule Make_adversarial_test (M : sig\n val tweak_statement :\n ( Import.Challenge.Constant.t\n , Import.Challenge.Constant.t Import.Types.Scalar_challenge.t\n , Backend.Tick.Field.t Pickles_types.Shifted_value.Type1.t\n , ( Backend.Tick.Field.t Pickles_types.Shifted_value.Type1.t\n , bool )\n Import.Types.Opt.t\n , ( Import.Challenge.Constant.t Import.Types.Scalar_challenge.t\n Composition_types.Wrap.Proof_state.Deferred_values.Plonk.In_circuit\n .Lookup\n .t\n , bool )\n Import.Types.Opt.t\n , bool\n , 'max_proofs_verified\n Proof.Base.Messages_for_next_proof_over_same_field.Wrap.t\n , (int64, Composition_types.Digest.Limbs.n) Pickles_types.Vector.vec\n , ( 'b\n , ( Kimchi_pasta.Pallas_based_plonk.Proof.G.Affine.t\n , 'actual_proofs_verified )\n Pickles_types.Vector.t\n , ( ( Import.Challenge.Constant.t Import.Scalar_challenge.t\n Import.Bulletproof_challenge.t\n , 'e )\n Pickles_types.Vector.t\n , 'actual_proofs_verified )\n Pickles_types.Vector.t )\n Proof.Base.Messages_for_next_proof_over_same_field.Step.t\n , Import.Challenge.Constant.t Import.Types.Scalar_challenge.t\n Import.Types.Bulletproof_challenge.t\n Import.Types.Step_bp_vec.t\n , Import.Types.Branch_data.t )\n Import.Types.Wrap.Statement.In_circuit.t\n -> ( Import.Challenge.Constant.t\n , Import.Challenge.Constant.t Import.Types.Scalar_challenge.t\n , Backend.Tick.Field.t Pickles_types.Shifted_value.Type1.t\n , ( Backend.Tick.Field.t Pickles_types.Shifted_value.Type1.t\n , bool )\n Import.Types.Opt.t\n , ( Import.Challenge.Constant.t Import.Types.Scalar_challenge.t\n Composition_types.Wrap.Proof_state.Deferred_values.Plonk.In_circuit\n .Lookup\n .t\n , bool )\n Import.Types.Opt.t\n , bool\n , 'max_proofs_verified\n Proof.Base.Messages_for_next_proof_over_same_field.Wrap.t\n , ( Limb_vector.Constant.Hex64.t\n , Composition_types.Digest.Limbs.n )\n Pickles_types.Vector.vec\n , ( 'b\n , ( Kimchi_pasta.Pallas_based_plonk.Proof.G.Affine.t\n , 'actual_proofs_verified )\n Pickles_types.Vector.t\n , ( ( Import.Challenge.Constant.t Import.Scalar_challenge.t\n Import.Bulletproof_challenge.t\n , 'e )\n Pickles_types.Vector.t\n , 'actual_proofs_verified )\n Pickles_types.Vector.t )\n Proof.Base.Messages_for_next_proof_over_same_field.Step.t\n , Import.Challenge.Constant.t Import.Types.Scalar_challenge.t\n Import.Types.Bulletproof_challenge.t\n Import.Types.Step_bp_vec.t\n , Import.Types.Branch_data.t )\n Import.Types.Wrap.Statement.In_circuit.t\n\n val check_verifier_error : Error.t -> unit\nend) =\nstruct\n open Impls.Step\n\n let constraint_constants : Snark_keys_header.Constraint_constants.t =\n { sub_windows_per_window = 0\n ; ledger_depth = 0\n ; work_delay = 0\n ; block_window_duration_ms = 0\n ; transaction_capacity = Log_2 0\n ; pending_coinbase_depth = 0\n ; coinbase_amount = Unsigned.UInt64.of_int 0\n ; supercharged_coinbase_factor = 0\n ; account_creation_fee = Unsigned.UInt64.of_int 0\n ; fork = None\n }\n\n let rule self : _ Inductive_rule.t =\n { identifier = \"main\"\n ; prevs = [ self; self ]\n ; main =\n (fun { public_input = () } ->\n let dummy_proof =\n As_prover.Ref.create (fun () ->\n Proof.dummy Nat.N2.n Nat.N2.n Nat.N2.n ~domain_log2:15 )\n in\n { previous_proof_statements =\n [ { public_input = ()\n ; proof = dummy_proof\n ; proof_must_verify = Boolean.false_\n }\n ; { public_input = ()\n ; proof = dummy_proof\n ; proof_must_verify = Boolean.false_\n }\n ]\n ; public_output = ()\n ; auxiliary_output = ()\n } )\n ; feature_flags = Plonk_types.Features.none_bool\n }\n\n let override_wrap_main =\n { wrap_main = wrap_main_dummy_override\n ; tweak_statement = M.tweak_statement\n }\n\n let tag, _, p, ([ step ] : _ H3_2.T(Prover).t) =\n compile_with_wrap_main_override_promise () ~override_wrap_main\n ~public_input:(Input Typ.unit) ~auxiliary_typ:Typ.unit\n ~branches:(module Nat.N1)\n ~max_proofs_verified:(module Nat.N2)\n ~name:\"blockchain-snark\"\n ~constraint_constants:\n (* Dummy values *)\n { sub_windows_per_window = 0\n ; ledger_depth = 0\n ; work_delay = 0\n ; block_window_duration_ms = 0\n ; transaction_capacity = Log_2 0\n ; pending_coinbase_depth = 0\n ; coinbase_amount = Unsigned.UInt64.of_int 0\n ; supercharged_coinbase_factor = 0\n ; account_creation_fee = Unsigned.UInt64.of_int 0\n ; fork = None\n }\n ~choices:(fun ~self -> [ rule self ])\n\n module Proof = (val p)\n\n let proof_with_stmt =\n let (), (), p = Promise.block_on_async_exn (fun () -> step ()) in\n ((), p)\n\n let%test \"should not be able to verify invalid proof\" =\n match\n Promise.block_on_async_exn (fun () ->\n Proof.verify_promise [ proof_with_stmt ] )\n with\n | Ok () ->\n false\n | Error err ->\n M.check_verifier_error err ; true\n\n module Recurse_on_bad_proof = struct\n open Impls.Step\n\n type _ Snarky_backendless.Request.t +=\n | Proof : Proof.t Snarky_backendless.Request.t\n\n let handler (proof : Proof.t)\n (Snarky_backendless.Request.With { request; respond }) =\n match request with\n | Proof ->\n respond (Provide proof)\n | _ ->\n respond Unhandled\n\n let _tag, _, p, ([ step ] : _ H3_2.T(Prover).t) =\n Common.time \"compile\" (fun () ->\n compile_with_wrap_main_override_promise ()\n ~public_input:(Input Typ.unit) ~auxiliary_typ:Typ.unit\n ~branches:(module Nat.N1)\n ~max_proofs_verified:(module Nat.N2)\n ~name:\"recurse-on-bad\" ~constraint_constants\n ~choices:(fun ~self:_ ->\n [ { identifier = \"main\"\n ; feature_flags = Plonk_types.Features.none_bool\n ; prevs = [ tag; tag ]\n ; main =\n (fun { public_input = () } ->\n let proof =\n exists (Typ.Internal.ref ()) ~request:(fun () -> Proof)\n in\n { previous_proof_statements =\n [ { public_input = ()\n ; proof\n ; proof_must_verify = Boolean.true_\n }\n ; { public_input = ()\n ; proof\n ; proof_must_verify = Boolean.true_\n }\n ]\n ; public_output = ()\n ; auxiliary_output = ()\n } )\n }\n ] ) )\n\n module Proof = (val p)\n end\n\n let%test \"should not be able to create a recursive proof from an invalid \\\n proof\" =\n try\n let (), (), proof =\n Promise.block_on_async_exn (fun () ->\n Recurse_on_bad_proof.step\n ~handler:(Recurse_on_bad_proof.handler (snd proof_with_stmt))\n () )\n in\n Or_error.is_error\n @@ Promise.block_on_async_exn (fun () ->\n Recurse_on_bad_proof.Proof.verify_promise [ ((), proof) ] )\n with _ -> true\nend\n","module Make\n (Impl : Snarky_backendless.Snark_intf.Run) (B : sig\n open Impl\n\n val params : field Sponge.Params.t\n\n val to_the_alpha : field -> field\n\n module Operations : sig\n val apply_affine_map :\n field array array * field array -> field array -> field array\n end\n end) =\nstruct\n include Make_sponge.Rounds\n\n let round_table start =\n let ({ round_constants; mds } : _ Sponge.Params.t) = B.params in\n (* sbox -> mds -> ark *)\n let apply_round i s =\n let s' = Array.map s ~f:B.to_the_alpha in\n B.Operations.apply_affine_map (mds, round_constants.(i)) s'\n in\n let res =\n Array.init (rounds_full + 1) ~f:(fun _ ->\n Array.create ~len:3 Impl.Field.Constant.zero )\n in\n res.(0) <- start ;\n for i = 0 to rounds_full - 1 do\n res.(i + 1) <- apply_round i res.(i)\n done ;\n res\n\n module Field = Impl.Field\n\n let block_cipher (_params : _ Sponge.Params.t) init =\n let open Impl in\n Impl.with_label __LOC__ (fun () ->\n let t =\n exists\n (Typ.array\n ~length:Int.(rounds_full + 1)\n (Typ.array ~length:3 Field.typ) )\n ~compute:\n As_prover.(fun () -> round_table (Array.map init ~f:read_var))\n in\n t.(0) <- init ;\n (let open Kimchi_backend_common.Plonk_constraint_system.Plonk_constraint in\n with_label __LOC__ (fun () ->\n Impl.assert_\n { basic = T (Poseidon { state = t })\n ; annotation = Some \"plonk-poseidon\"\n } )) ;\n t.(Int.(Array.length t - 1)) )\n\n let add_assign ~state i x =\n state.(i) <- Util.seal (module Impl) Field.(state.(i) + x)\n\n let copy = Array.copy\nend\n","include Make_sponge.Make (Backend.Tock.Field)\n\nlet params =\n (* HACK *)\n Sponge.Params.(\n let testbit n i = Bigint.(equal (shift_right n i land one) one) in\n map pasta_q_kimchi ~f:(fun s ->\n Backend.Tock.Field.of_bits\n (List.init Backend.Tock.Field.size_in_bits\n ~f:(testbit (Bigint.of_string s)) ) ))\n","open Core_kernel\nopen Backend\nopen Pickles_types\n\n(* The actual \"accumulator\" for the wrap proof contains a vector of elements,\n each of which is a vector of bulletproof challenges.\n\n The number of such vectors is equal to the maximum proofs-verified\n amongst all the step branches that that proof is wrapping.\n\n To simplify the implementation when the number of proofs-verified\n varies across proof systems (being either 0, 1, or 2) we secretly\n pad the accumulator so that it always has exactly 2 vectors, padding\n with dummy vectors.\n\n We also then pad with the corresponding dummy commitments when proving\n wrap statements, as in `pad_accumulator` which is used in wrap.ml.\n\n We add them to the **front**, not the back, of the vector of the actual\n \"real\" accumulator values so that we can precompute the sponge states\n resulting from absorbing the padding challenges\n*)\n\nmodule Padded_length = Nat.N2\n\n(* Pad up to length 2 by preprending dummy values. *)\nlet pad_vector (type a) ~dummy (v : (a, _) Vector.t) =\n Vector.extend_front_exn v Padded_length.n dummy\n\n(* Specialized padding function. *)\nlet pad_challenges (chalss : (_ Vector.t, _) Vector.t) =\n pad_vector ~dummy:Dummy.Ipa.Wrap.challenges_computed chalss\n\n(* Specialized padding function. *)\nlet pad_accumulator (xs : (Tock.Proof.Challenge_polynomial.t, _) Vector.t) =\n pad_vector xs\n ~dummy:\n { Tock.Proof.Challenge_polynomial.commitment =\n Lazy.force Dummy.Ipa.Wrap.sg\n ; challenges = Vector.to_array Dummy.Ipa.Wrap.challenges_computed\n }\n |> Vector.to_list\n\n(* Hash the me only, padding first. *)\nlet hash_messages_for_next_wrap_proof (type n) (_max_proofs_verified : n Nat.t)\n (t :\n ( Tick.Curve.Affine.t\n , (_, n) Vector.t )\n Composition_types.Wrap.Proof_state.Messages_for_next_wrap_proof.t ) =\n let t =\n { t with\n old_bulletproof_challenges = pad_challenges t.old_bulletproof_challenges\n }\n in\n Tock_field_sponge.digest Tock_field_sponge.params\n (Composition_types.Wrap.Proof_state.Messages_for_next_wrap_proof\n .to_field_elements t ~g1:(fun ((x, y) : Tick.Curve.Affine.t) -> [ x; y ])\n )\n\n(* Pad the messages_for_next_wrap_proof of a proof *)\nlet pad_proof (type mlmb) (T p : (mlmb, _) Proof.t) :\n Proof.Proofs_verified_max.t =\n T\n { p with\n statement =\n { p.statement with\n proof_state =\n { p.statement.proof_state with\n messages_for_next_wrap_proof =\n { p.statement.proof_state.messages_for_next_wrap_proof with\n old_bulletproof_challenges =\n pad_vector\n p.statement.proof_state.messages_for_next_wrap_proof\n .old_bulletproof_challenges\n ~dummy:Dummy.Ipa.Wrap.challenges\n }\n }\n }\n }\n\nmodule Checked = struct\n let pad_challenges (chalss : (_ Vector.t, _) Vector.t) =\n pad_vector\n ~dummy:\n (Vector.map ~f:Impls.Wrap.Field.constant\n Dummy.Ipa.Wrap.challenges_computed )\n chalss\n\n let pad_commitments (commitments : _ Vector.t) =\n pad_vector\n ~dummy:\n (Tuple_lib.Double.map ~f:Impls.Step.Field.constant\n (Lazy.force Dummy.Ipa.Wrap.sg) )\n commitments\n\n (* We precompute the sponge states that would result from absorbing\n 0, 1, or 2 dummy challenge vectors. This is used to speed up hashing\n inside the circuit. *)\n let dummy_messages_for_next_wrap_proof_sponge_states =\n lazy\n (let module S = Tock_field_sponge.Field in\n let full_state s = (S.state s, s.sponge_state) in\n let sponge = S.create Tock_field_sponge.params in\n let s0 = full_state sponge in\n Vector.iter ~f:(S.absorb sponge) Dummy.Ipa.Wrap.challenges_computed ;\n let s1 = full_state sponge in\n Vector.iter ~f:(S.absorb sponge) Dummy.Ipa.Wrap.challenges_computed ;\n let s2 = full_state sponge in\n [| s0; s1; s2 |] )\n\n let hash_constant_messages_for_next_wrap_proof =\n hash_messages_for_next_wrap_proof\n\n (* TODO: No need to hash the entire bulletproof challenges. Could\n just hash the segment of the public input LDE corresponding to them\n that we compute when verifying the previous proof. That is a commitment\n to them. *)\n let hash_messages_for_next_wrap_proof (type n) (max_proofs_verified : n Nat.t)\n (t :\n ( Wrap_main_inputs.Inner_curve.t\n , ((Impls.Wrap.Field.t, Backend.Tock.Rounds.n) Vector.t, n) Vector.t )\n Composition_types.Wrap.Proof_state.Messages_for_next_wrap_proof.t ) =\n let open Wrap_main_inputs in\n let sponge =\n (* The sponge states we would reach if we absorbed the padding challenges *)\n let s = Sponge.create sponge_params in\n let state, sponge_state =\n (Lazy.force dummy_messages_for_next_wrap_proof_sponge_states).(2\n - Nat\n .to_int\n max_proofs_verified)\n in\n { s with\n state = Array.map state ~f:Impls.Wrap.Field.constant\n ; sponge_state\n }\n in\n Array.iter ~f:(Sponge.absorb sponge)\n (Composition_types.Wrap.Proof_state.Messages_for_next_wrap_proof\n .to_field_elements ~g1:Inner_curve.to_field_elements t ) ;\n Sponge.squeeze_field sponge\n\n (* Check that the pre-absorbing technique works. I.e., that it's consistent with\n the actual definition of hash_messages_for_next_wrap_proof. *)\n let%test_unit \"hash_messages_for_next_wrap_proof correct\" =\n let open Impls.Wrap in\n let test (type n) (n : n Nat.t) =\n let messages_for_next_wrap_proof :\n _ Composition_types.Wrap.Proof_state.Messages_for_next_wrap_proof.t =\n let g = Wrap_main_inputs.Inner_curve.Constant.random () in\n { Composition_types.Wrap.Proof_state.Messages_for_next_wrap_proof\n .challenge_polynomial_commitment = g\n ; old_bulletproof_challenges =\n Vector.init n ~f:(fun _ ->\n Vector.init Tock.Rounds.n ~f:(fun _ -> Tock.Field.random ()) )\n }\n in\n Internal_Basic.Test.test_equal ~sexp_of_t:Field.Constant.sexp_of_t\n ~equal:Field.Constant.equal\n (Composition_types.Wrap.Proof_state.Messages_for_next_wrap_proof.typ\n Wrap_main_inputs.Inner_curve.typ\n (Vector.typ Field.typ Backend.Tock.Rounds.n)\n ~length:n )\n Field.typ\n (fun t -> make_checked (fun () -> hash_messages_for_next_wrap_proof n t))\n (fun t ->\n hash_constant_messages_for_next_wrap_proof n t\n |> Digest.Constant.to_bits |> Impls.Wrap.Field.Constant.project )\n messages_for_next_wrap_proof\n in\n test Nat.N0.n ; test Nat.N1.n ; test Nat.N2.n\nend\n","open Pickles_types\nopen Import\nopen Backend\n\ntype dlog_opening = (Tock.Curve.Affine.t, Tock.Field.t) Types.Step.Bulletproof.t\n\nmodule Constant = struct\n (* Out-of-circuit type for wrap proofs *)\n type t =\n { messages : Tock.Curve.Affine.t Plonk_types.Messages.t\n ; opening : dlog_opening\n }\n [@@deriving hlist]\nend\n\nopen Step_main_inputs\n\nmodule Checked = struct\n (* In-circuit type for wrap proofs *)\n type t =\n { messages :\n (Inner_curve.t, Impl.Boolean.var) Plonk_types.Messages.In_circuit.t\n ; opening :\n ( Inner_curve.t\n , Impls.Step.Other_field.t Shifted_value.Type2.t )\n Types.Step.Bulletproof.t\n }\n [@@deriving hlist]\nend\n\nopen Impls.Step\n\nlet typ : (Checked.t, Constant.t) Typ.t =\n let shift = Shifted_value.Type2.Shift.create (module Tock.Field) in\n Typ.of_hlistable ~var_to_hlist:Checked.to_hlist ~var_of_hlist:Checked.of_hlist\n ~value_to_hlist:Constant.to_hlist ~value_of_hlist:Constant.of_hlist\n [ Plonk_types.Messages.typ\n (module Impl)\n Inner_curve.typ Plonk_types.Features.none ~bool:Boolean.typ\n ~dummy:Inner_curve.Params.one\n ~commitment_lengths:(Commitment_lengths.create ~of_int:(fun x -> x))\n ; Types.Step.Bulletproof.typ ~length:(Nat.to_int Tock.Rounds.n)\n ( Typ.transport Other_field.typ\n ~there:(fun x ->\n (* When storing, make it a shifted value *)\n match\n Shifted_value.Type2.of_field (module Tock.Field) ~shift x\n with\n | Shifted_value x ->\n x )\n ~back:(fun x ->\n Shifted_value.Type2.to_field\n (module Tock.Field)\n ~shift (Shifted_value x) )\n (* When reading, unshift *)\n |> Typ.transport_var\n (* For the var, we just wrap the now shifted underlying value. *)\n ~there:(fun (Shifted_value.Type2.Shifted_value x) -> x)\n ~back:(fun x -> Shifted_value x) )\n Inner_curve.typ\n ]\n","open Core_kernel\n\ntype ('var, 'value, 'n1, 'n2) id = ('var * 'value * 'n1 * 'n2) Type_equal.Id.t\n\ntype kind = Side_loaded | Compiled\n\ntype ('var, 'value, 'n1, 'n2) t =\n { kind : kind; id : ('var, 'value, 'n1, 'n2) id }\n[@@deriving fields]\n\nlet create ?(kind = Compiled) name =\n { kind; id = Type_equal.Id.create ~name sexp_of_opaque }\n","open Pickles_types.Poly_types\nopen Pickles_types.Hlist\n\nmodule B = struct\n type t = Impls.Step.Boolean.var\nend\n\nmodule Previous_proof_statement = struct\n type ('prev_var, 'width) t =\n { public_input : 'prev_var\n ; proof : ('width, 'width) Proof.t Impls.Step.As_prover.Ref.t\n ; proof_must_verify : B.t\n }\n\n module Constant = struct\n type ('prev_value, 'width) t =\n { public_input : 'prev_value\n ; proof : ('width, 'width) Proof.t\n ; proof_must_verify : bool\n }\n end\nend\n\n(** This type relates the types of the input and output types of an inductive\n rule's [main] function to the type of the public input to the resulting\n circuit.\n*)\ntype ('var, 'value, 'input_var, 'input_value, 'ret_var, 'ret_value) public_input =\n | Input :\n ('var, 'value) Impls.Step.Typ.t\n -> ('var, 'value, 'var, 'value, unit, unit) public_input\n | Output :\n ('ret_var, 'ret_value) Impls.Step.Typ.t\n -> ('ret_var, 'ret_value, unit, unit, 'ret_var, 'ret_value) public_input\n | Input_and_output :\n ('var, 'value) Impls.Step.Typ.t * ('ret_var, 'ret_value) Impls.Step.Typ.t\n -> ( 'var * 'ret_var\n , 'value * 'ret_value\n , 'var\n , 'value\n , 'ret_var\n , 'ret_value )\n public_input\n\n(** The input type of an inductive rule's main function. *)\ntype 'public_input main_input =\n { public_input : 'public_input\n (** The publicly-exposed input to the circuit's main function. *)\n }\n\n(** The return type of an inductive rule's main function. *)\ntype ('prev_vars, 'widths, 'public_output, 'auxiliary_output) main_return =\n { previous_proof_statements :\n ('prev_vars, 'widths) H2.T(Previous_proof_statement).t\n (** A list of booleans, determining whether each previous proof must\n verify.\n *)\n ; public_output : 'public_output\n (** The publicly-exposed output from the circuit's main function. *)\n ; auxiliary_output : 'auxiliary_output\n (** The auxiliary output from the circuit's main function. This value\n is returned to the prover, but not exposed to or used by verifiers.\n *)\n }\n\n(** This type models an \"inductive rule\". It includes\n - the list of previous statements which this one assumes\n - the snarky main function\n\n The types parameters are:\n - ['prev_vars] the tuple-list of public input circuit types to the previous\n proofs.\n - For example, [Boolean.var * (Boolean.var * unit)] represents 2 previous\n proofs whose public inputs are booleans\n - ['prev_values] the tuple-list of public input non-circuit types to the\n previous proofs.\n - For example, [bool * (bool * unit)] represents 2 previous proofs whose\n public inputs are booleans.\n - ['widths] is a tuple list of the maximum number of previous proofs each\n previous proof itself had.\n - For example, [Nat.z Nat.s * (Nat.z * unit)] represents 2 previous\n proofs where the first has at most 1 previous proof and the second had\n zero previous proofs.\n - ['heights] is a tuple list of the number of inductive rules in each of\n the previous proofs\n - For example, [Nat.z Nat.s Nat.s * (Nat.z Nat.s * unit)] represents 2\n previous proofs where the first had 2 inductive rules and the second\n had 1.\n - ['a_var] is the in-circuit type of the [main] function's public input.\n - ['a_value] is the out-of-circuit type of the [main] function's public\n input.\n - ['ret_var] is the in-circuit type of the [main] function's public output.\n - ['ret_value] is the out-of-circuit type of the [main] function's public\n output.\n - ['auxiliary_var] is the in-circuit type of the [main] function's\n auxiliary data, to be returned to the prover but not exposed in the\n public input.\n - ['auxiliary_value] is the out-of-circuit type of the [main] function's\n auxiliary data, to be returned to the prover but not exposed in the\n public input.\n*)\ntype ( 'prev_vars\n , 'prev_values\n , 'widths\n , 'heights\n , 'a_var\n , 'a_value\n , 'ret_var\n , 'ret_value\n , 'auxiliary_var\n , 'auxiliary_value )\n t =\n { identifier : string\n ; prevs : ('prev_vars, 'prev_values, 'widths, 'heights) H4.T(Tag).t\n ; main :\n 'a_var main_input\n -> ('prev_vars, 'widths, 'ret_var, 'auxiliary_var) main_return\n ; feature_flags : bool Pickles_types.Plonk_types.Features.t\n }\n\nmodule T\n (Statement : T0)\n (Statement_value : T0)\n (Return_var : T0)\n (Return_value : T0)\n (Auxiliary_var : T0)\n (Auxiliary_value : T0) =\nstruct\n type nonrec ('prev_vars, 'prev_values, 'widths, 'heights) t =\n ( 'prev_vars\n , 'prev_values\n , 'widths\n , 'heights\n , Statement.t\n , Statement_value.t\n , Return_var.t\n , Return_value.t\n , Auxiliary_var.t\n , Auxiliary_value.t )\n t\nend\n","open Core_kernel\nopen Pickles_types\nopen Import\nopen Backend\n\n(* We maintain a global hash table which stores for each inductive proof system some\n data.\n*)\ntype inner_curve_var =\n Tick.Field.t Snarky_backendless.Cvar.t\n * Tick.Field.t Snarky_backendless.Cvar.t\n\nmodule Basic = struct\n type ('var, 'value, 'n1, 'n2) t =\n { max_proofs_verified : (module Nat.Add.Intf with type n = 'n1)\n ; public_input : ('var, 'value) Impls.Step.Typ.t\n ; branches : 'n2 Nat.t\n ; wrap_domains : Domains.t\n ; wrap_key : Tick.Inner_curve.Affine.t Plonk_verification_key_evals.t\n ; wrap_vk : Impls.Wrap.Verification_key.t\n ; feature_flags : Plonk_types.Opt.Flag.t Plonk_types.Features.t\n }\nend\n\nmodule Side_loaded = struct\n module Ephemeral = struct\n type t =\n { index :\n [ `In_circuit of Side_loaded_verification_key.Checked.t\n | `In_prover of Side_loaded_verification_key.t\n | `In_both of\n Side_loaded_verification_key.t\n * Side_loaded_verification_key.Checked.t ]\n }\n end\n\n module Permanent = struct\n type ('var, 'value, 'n1, 'n2) t =\n { max_proofs_verified : (module Nat.Add.Intf with type n = 'n1)\n ; public_input : ('var, 'value) Impls.Step.Typ.t\n ; feature_flags : Plonk_types.Opt.Flag.t Plonk_types.Features.t\n ; branches : 'n2 Nat.t\n }\n end\n\n type ('var, 'value, 'n1, 'n2) t =\n { ephemeral : Ephemeral.t option\n ; permanent : ('var, 'value, 'n1, 'n2) Permanent.t\n }\n\n type packed =\n | T : ('var, 'value, 'n1, 'n2) Tag.id * ('var, 'value, 'n1, 'n2) t -> packed\n\n let to_basic\n { permanent =\n { max_proofs_verified; public_input; branches; feature_flags }\n ; ephemeral\n } =\n let wrap_key, wrap_vk =\n match ephemeral with\n | Some { index = `In_prover i | `In_both (i, _) } ->\n (i.wrap_index, i.wrap_vk)\n | _ ->\n failwithf \"Side_loaded.to_basic: Expected `In_prover (%s)\" __LOC__ ()\n in\n let proofs_verified = Nat.to_int (Nat.Add.n max_proofs_verified) in\n let wrap_vk = Option.value_exn ~here:[%here] wrap_vk in\n { Basic.max_proofs_verified\n ; wrap_vk\n ; public_input\n ; branches\n ; wrap_domains = Common.wrap_domains ~proofs_verified\n ; wrap_key\n ; feature_flags\n }\nend\n\nmodule Compiled = struct\n type ('a_var, 'a_value, 'max_proofs_verified, 'branches) basic =\n { public_input : ('a_var, 'a_value) Impls.Step.Typ.t\n ; proofs_verifieds : (int, 'branches) Vector.t\n (* For each branch in this rule, how many predecessor proofs does it have? *)\n ; wrap_domains : Domains.t\n ; step_domains : (Domains.t, 'branches) Vector.t\n ; feature_flags : Plonk_types.Opt.Flag.t Plonk_types.Features.t\n }\n\n (* This is the data associated to an inductive proof system with statement type\n ['a_var], which has ['branches] many \"variants\" each of which depends on at most\n ['max_proofs_verified] many previous statements. *)\n type ('a_var, 'a_value, 'max_proofs_verified, 'branches) t =\n { branches : 'branches Nat.t\n ; max_proofs_verified :\n (module Nat.Add.Intf with type n = 'max_proofs_verified)\n ; proofs_verifieds : (int, 'branches) Vector.t\n (* For each branch in this rule, how many predecessor proofs does it have? *)\n ; public_input : ('a_var, 'a_value) Impls.Step.Typ.t\n ; wrap_key : Tick.Inner_curve.Affine.t Plonk_verification_key_evals.t Lazy.t\n ; wrap_vk : Impls.Wrap.Verification_key.t Lazy.t\n ; wrap_domains : Domains.t\n ; step_domains : (Domains.t, 'branches) Vector.t\n ; feature_flags : Plonk_types.Opt.Flag.t Plonk_types.Features.t\n }\n\n type packed =\n | T : ('var, 'value, 'n1, 'n2) Tag.id * ('var, 'value, 'n1, 'n2) t -> packed\n\n let to_basic\n { branches = _\n ; max_proofs_verified\n ; proofs_verifieds = _\n ; public_input\n ; wrap_vk\n ; wrap_domains\n ; step_domains\n ; wrap_key\n ; feature_flags\n } =\n { Basic.max_proofs_verified\n ; wrap_domains\n ; public_input\n ; branches = Vector.length step_domains\n ; wrap_key = Lazy.force wrap_key\n ; wrap_vk = Lazy.force wrap_vk\n ; feature_flags\n }\nend\n\nmodule For_step = struct\n type ('a_var, 'a_value, 'max_proofs_verified, 'branches) t =\n { branches : 'branches Nat.t\n ; max_proofs_verified :\n (module Nat.Add.Intf with type n = 'max_proofs_verified)\n ; proofs_verifieds :\n [ `Known of (Impls.Step.Field.t, 'branches) Vector.t | `Side_loaded ]\n ; public_input : ('a_var, 'a_value) Impls.Step.Typ.t\n ; wrap_key : inner_curve_var Plonk_verification_key_evals.t\n ; wrap_domain :\n [ `Known of Domain.t\n | `Side_loaded of\n Impls.Step.field Pickles_base.Proofs_verified.One_hot.Checked.t ]\n ; step_domains : [ `Known of (Domains.t, 'branches) Vector.t | `Side_loaded ]\n ; feature_flags : Plonk_types.Opt.Flag.t Plonk_types.Features.t\n }\n\n let of_side_loaded (type a b c d)\n ({ ephemeral\n ; permanent =\n { branches; max_proofs_verified; public_input; feature_flags }\n } :\n (a, b, c, d) Side_loaded.t ) : (a, b, c, d) t =\n let index =\n match ephemeral with\n | Some { index = `In_circuit i | `In_both (_, i) } ->\n i\n | _ ->\n failwithf \"For_step.side_loaded: Expected `In_circuit (%s)\" __LOC__ ()\n in\n let T = Nat.eq_exn branches Side_loaded_verification_key.Max_branches.n in\n { branches\n ; max_proofs_verified\n ; public_input\n ; proofs_verifieds = `Side_loaded\n ; wrap_key = index.wrap_index\n ; wrap_domain = `Side_loaded index.actual_wrap_domain_size\n ; step_domains = `Side_loaded\n ; feature_flags\n }\n\n let of_compiled\n ({ branches\n ; max_proofs_verified\n ; proofs_verifieds\n ; public_input\n ; wrap_key\n ; wrap_domains\n ; step_domains\n ; feature_flags\n ; wrap_vk = _\n } :\n _ Compiled.t ) =\n { branches\n ; max_proofs_verified\n ; proofs_verifieds =\n `Known (Vector.map proofs_verifieds ~f:Impls.Step.Field.of_int)\n ; public_input\n ; wrap_key =\n Plonk_verification_key_evals.map (Lazy.force wrap_key)\n ~f:Step_main_inputs.Inner_curve.constant\n ; wrap_domain = `Known wrap_domains.h\n ; step_domains = `Known step_domains\n ; feature_flags\n }\nend\n\ntype t =\n { compiled : Compiled.packed Type_equal.Id.Uid.Table.t\n ; side_loaded : Side_loaded.packed Type_equal.Id.Uid.Table.t\n }\n\nlet univ : t =\n { compiled = Type_equal.Id.Uid.Table.create ()\n ; side_loaded = Type_equal.Id.Uid.Table.create ()\n }\n\nlet find t k =\n match Hashtbl.find t k with None -> failwith \"key not found\" | Some x -> x\n\nlet lookup_compiled :\n type var value n m.\n (var, value, n, m) Tag.id -> (var, value, n, m) Compiled.t =\n fun t ->\n let (T (other_id, d)) = find univ.compiled (Type_equal.Id.uid t) in\n let T = Type_equal.Id.same_witness_exn t other_id in\n d\n\nlet lookup_side_loaded :\n type var value n m.\n (var, value, n, m) Tag.id -> (var, value, n, m) Side_loaded.t =\n fun t ->\n let (T (other_id, d)) = find univ.side_loaded (Type_equal.Id.uid t) in\n let T = Type_equal.Id.same_witness_exn t other_id in\n d\n\nlet lookup_basic :\n type var value n m. (var, value, n, m) Tag.t -> (var, value, n, m) Basic.t =\n fun t ->\n match t.kind with\n | Compiled ->\n Compiled.to_basic (lookup_compiled t.id)\n | Side_loaded ->\n Side_loaded.to_basic (lookup_side_loaded t.id)\n\nlet max_proofs_verified :\n type n1. (_, _, n1, _) Tag.t -> (module Nat.Add.Intf with type n = n1) =\n fun tag ->\n match tag.kind with\n | Compiled ->\n (lookup_compiled tag.id).max_proofs_verified\n | Side_loaded ->\n (lookup_side_loaded tag.id).permanent.max_proofs_verified\n\nlet public_input :\n type var value. (var, value, _, _) Tag.t -> (var, value) Impls.Step.Typ.t =\n fun tag ->\n match tag.kind with\n | Compiled ->\n (lookup_compiled tag.id).public_input\n | Side_loaded ->\n (lookup_side_loaded tag.id).permanent.public_input\n\nlet feature_flags :\n type var value.\n (var, value, _, _) Tag.t -> Plonk_types.Opt.Flag.t Plonk_types.Features.t =\n fun tag ->\n match tag.kind with\n | Compiled ->\n (lookup_compiled tag.id).feature_flags\n | Side_loaded ->\n (lookup_side_loaded tag.id).permanent.feature_flags\n\nlet _value_to_field_elements :\n type a. (_, a, _, _) Tag.t -> a -> Backend.Tick.Field.t array =\n fun t ->\n let (Typ typ) = public_input t in\n fun x -> fst (typ.value_to_fields x)\n\nlet _lookup_map (type var value c d) (t : (var, value, c, d) Tag.t) ~self\n ~default\n ~(f :\n [ `Compiled of (var, value, c, d) Compiled.t\n | `Side_loaded of (var, value, c, d) Side_loaded.t ]\n -> _ ) =\n match Type_equal.Id.same_witness t.id self with\n | Some _ ->\n default\n | None -> (\n match t.kind with\n | Compiled ->\n let (T (other_id, d)) = find univ.compiled (Type_equal.Id.uid t.id) in\n let T = Type_equal.Id.same_witness_exn t.id other_id in\n f (`Compiled d)\n | Side_loaded ->\n let (T (other_id, d)) =\n find univ.side_loaded (Type_equal.Id.uid t.id)\n in\n let T = Type_equal.Id.same_witness_exn t.id other_id in\n f (`Side_loaded d) )\n\nlet add_side_loaded ~name permanent =\n let (Tag.{ id; _ } as tag) = Tag.(create ~kind:Side_loaded name) in\n Hashtbl.add_exn univ.side_loaded ~key:(Type_equal.Id.uid id)\n ~data:(T (id, { ephemeral = None; permanent })) ;\n tag\n\nlet set_ephemeral { Tag.kind; id } (eph : Side_loaded.Ephemeral.t) =\n assert (match kind with Side_loaded -> true | Compiled -> false) ;\n Hashtbl.update univ.side_loaded (Type_equal.Id.uid id) ~f:(function\n | None ->\n assert false\n | Some (T (id, d)) ->\n let ephemeral =\n match (d.ephemeral, eph.index) with\n | None, _ | Some _, `In_prover _ ->\n (* Giving prover only always resets. *)\n Some eph\n | Some { index = `In_prover prover }, `In_circuit circuit\n | Some { index = `In_both (prover, _) }, `In_circuit circuit ->\n (* In-circuit extends prover if one was given. *)\n Some { index = `In_both (prover, circuit) }\n | _ ->\n (* Otherwise, just use the given value. *)\n Some eph\n in\n T (id, { d with ephemeral }) )\n\nlet add_exn (type var value c d) (tag : (var, value, c, d) Tag.t)\n (data : (var, value, c, d) Compiled.t) =\n Hashtbl.add_exn univ.compiled ~key:(Type_equal.Id.uid tag.id)\n ~data:(Compiled.T (tag.id, data))\n","open Backend\nopen Pickles_types\nopen Import\nmodule Impl = Impls.Step\nmodule One_hot_vector = One_hot_vector.Make (Impl)\n\n(* Let F, K be the two fields (either (Fp, Fq) or (Fq, Fp)).\n Each proof over F has an accumulator state which contains\n - a set of IPA challenges c_0, ..., c_{k-1}, which can be interpreted as F elements.\n - a polynomial commitment challenge_polynomial_commitment, which has coordinates in K.\n\n This part of the accumulator state is finalized by checking that challenge_polynomial_commitment\n is a commitment to the polynomial\n\n f_c := prod_{i = 0}^{k-1} (1 + c_i x^{2^{k-1 - i}})\n\n When incrementally-verifying such a proof in a K-circuit (since we need K-arithmetic to perform\n the group operations on the F-polynomial-commitments that constitute the proof),\n instead of checking this, we get an evaluation E_c at a random point zeta and check\n that challenge_polynomial_commitment opens to E_c at zeta. Then we will need to check that\n E_c = f_c(zeta) = prod_{i = 0}^{k-1} (1 + c_i zeta^{2^{k-1 - i}}).\n\n However, because we are then in a K-circuit, we cannot actually compute f_c(zeta), which requires\n F-arithmetic.\n\n Therefore, after incrementally verifying the F-proof, the challenges (c_0, ..., c_{k-1}) which are\n part of the accumulator of the F-proof we just incrementally verified, must remain part of\n the accumulator of the K-proof, along with E_c (or at least some kind of commitment to it, which is\n what we actually do).\n\n Then, when we incrementally verify that K-proof in an F-circuit, we will check that E_c was\n computed correctly using c_0, ..., c_{k-1} and they along with E_c can be discarded.\n\n So, to summarize, the accumulator state for each proof P (corresponding to an F-circuit)\n contains\n - a set of IPA challenges (thought of as K-elements) for every proof that it incrementally verified inside its circuit\n - a challenge_polynomial_commitment (coordinates in F) for every proof that it incrementally verified inside its circuit\n - a challenge_polynomial_commitment (coordinates in K) corresponding to P's own inner-product argument\n - a set of IPA challenges (thought of as F-elements) corresponding to P's own inner-product argument\n*)\n\ntype challenge = Challenge.Make(Impl).t\n\ntype scalar_challenge = challenge Scalar_challenge.t\n\n(** Represents a proof (along with its accumulation state) which wraps a\n \"step\" proof S on the other curve.\n\n To have some notation, the proof S itself comes from a circuit that verified\n up to 'max_proofs_verified many wrap proofs W_0, ..., W_max_proofs_verified.\n*)\ntype ('app_state, 'max_proofs_verified, 'num_branches) t =\n { app_state : 'app_state\n (** The user-level statement corresponding to this proof. *)\n ; wrap_proof : Wrap_proof.Checked.t\n (** The polynomial commitments, polynomial evaluations, and opening proof corresponding to\n this latest wrap proof.\n *)\n ; proof_state :\n ( challenge\n , scalar_challenge\n , Impl.Field.t Shifted_value.Type1.t\n , ( Impl.Field.t Pickles_types.Shifted_value.Type1.t\n , Impl.Boolean.var )\n Plonk_types.Opt.t\n , ( scalar_challenge\n Types.Wrap.Proof_state.Deferred_values.Plonk.In_circuit.Lookup.t\n , Impl.Boolean.var )\n Plonk_types.Opt.t\n , Impl.Boolean.var\n , unit\n , Digest.Make(Impl).t\n , scalar_challenge Types.Bulletproof_challenge.t Types.Step_bp_vec.t\n , Impl.field Branch_data.Checked.t )\n Types.Wrap.Proof_state.In_circuit.t\n (** The accumulator state corresponding to the above proof. Contains\n - `deferred_values`: The values necessary for finishing the deferred \"scalar field\" computations.\n That is, computations which are over the \"step\" circuit's internal field that the\n previous \"wrap\" circuit was unable to verify directly, due to its internal field\n being different.\n - `sponge_digest_before_evaluations`: the sponge state: TODO\n - `messages_for_next_wrap_proof`\n *)\n ; prev_proof_evals :\n ( Impl.Field.t\n , Impl.Field.t array\n , Impl.Boolean.var )\n Plonk_types.All_evals.In_circuit.t\n (** The evaluations from the step proof that this proof wraps *)\n ; prev_challenges :\n ((Impl.Field.t, Tick.Rounds.n) Vector.t, 'max_proofs_verified) Vector.t\n (** The challenges c_0, ... c_{k - 1} corresponding to each W_i. *)\n ; prev_challenge_polynomial_commitments :\n (Step_main_inputs.Inner_curve.t, 'max_proofs_verified) Vector.t\n (** The commitments to the \"challenge polynomials\" \\prod_{i = 0}^k (1 + c_{k - 1 - i} x^{2^i})\n corresponding to each of the \"prev_challenges\".\n *)\n }\n[@@deriving hlist]\n\nmodule No_app_state = struct\n type nonrec (_, 'max_proofs_verified, 'num_branches) t =\n (unit, 'max_proofs_verified, 'num_branches) t\nend\n\nmodule Constant = struct\n type challenge = Challenge.Constant.t\n\n type scalar_challenge = challenge Scalar_challenge.t\n\n type ('statement, 'max_proofs_verified) t =\n { app_state : 'statement\n ; wrap_proof : Wrap_proof.Constant.t\n ; proof_state :\n ( challenge\n , scalar_challenge\n , Tick.Field.t Shifted_value.Type1.t\n , Tick.Field.t Shifted_value.Type1.t option\n , scalar_challenge\n Types.Wrap.Proof_state.Deferred_values.Plonk.In_circuit.Lookup.t\n option\n , bool\n , unit\n , Digest.Constant.t\n , scalar_challenge Types.Bulletproof_challenge.t Types.Step_bp_vec.t\n , Branch_data.t )\n Types.Wrap.Proof_state.In_circuit.t\n ; prev_proof_evals :\n (Tick.Field.t, Tick.Field.t array) Plonk_types.All_evals.t\n ; prev_challenges :\n ((Tick.Field.t, Tick.Rounds.n) Vector.t, 'max_proofs_verified) Vector.t\n ; prev_challenge_polynomial_commitments :\n (Tick.Inner_curve.Affine.t, 'max_proofs_verified) Vector.t\n }\n [@@deriving hlist]\n\n module No_app_state = struct\n type nonrec (_, 'max_proofs_verified, _) t = (unit, 'max_proofs_verified) t\n end\nend\n\nlet typ (type n avar aval) ~feature_flags\n (statement : (avar, aval) Impls.Step.Typ.t) (max_proofs_verified : n Nat.t)\n =\n let module Sc = Scalar_challenge in\n let open Impls.Step in\n let open Step_main_inputs in\n let open Step_verifier in\n Snarky_backendless.Typ.of_hlistable ~var_to_hlist:to_hlist\n ~var_of_hlist:of_hlist ~value_to_hlist:Constant.to_hlist\n ~value_of_hlist:Constant.of_hlist\n [ statement\n ; Wrap_proof.typ\n ; Types.Wrap.Proof_state.In_circuit.typ\n (module Impl)\n ~challenge:Challenge.typ ~scalar_challenge:Challenge.typ ~feature_flags\n ~dummy_scalar:(Shifted_value.Type1.Shifted_value Field.Constant.zero)\n ~dummy_scalar_challenge:(Sc.create Limb_vector.Challenge.Constant.zero)\n (Shifted_value.Type1.typ Field.typ)\n (Snarky_backendless.Typ.unit ())\n Digest.typ\n (Branch_data.typ\n (module Impl)\n ~assert_16_bits:(Step_verifier.assert_n_bits ~n:16) )\n ; Plonk_types.All_evals.typ\n (module Impl)\n (* Assume we have lookup iff we have runtime tables *)\n feature_flags\n ; Vector.typ (Vector.typ Field.typ Tick.Rounds.n) max_proofs_verified\n ; Vector.typ Inner_curve.typ max_proofs_verified\n ]\n","open Core_kernel\nopen Backend\nopen Impls.Step\nopen Pickles_types\nopen Common\nopen Import\nmodule Shifted_value = Shifted_value.Type2\n\n(* Unfinalized dlog-based proof, along with a flag which is true iff it\n is expected to verify. This allows for situations like the blockchain\n SNARK where we let the previous proof fail in the base case.\n*)\ntype t =\n ( Field.t\n , Field.t Scalar_challenge.t\n , Other_field.t Shifted_value.t\n , ( Field.t Scalar_challenge.t Bulletproof_challenge.t\n , Tock.Rounds.n )\n Pickles_types.Vector.t\n , Field.t\n , Boolean.var )\n Types.Step.Proof_state.Per_proof.In_circuit.t\n\nmodule Plonk_checks = struct\n include Plonk_checks\n include Plonk_checks.Make (Shifted_value) (Plonk_checks.Scalars.Tock)\nend\n\nmodule Constant = struct\n type t =\n ( Challenge.Constant.t\n , Challenge.Constant.t Scalar_challenge.t\n , Tock.Field.t Shifted_value.t\n , ( Challenge.Constant.t Scalar_challenge.t Bulletproof_challenge.t\n , Tock.Rounds.n )\n Vector.t\n , Digest.Constant.t\n , bool )\n Types.Step.Proof_state.Per_proof.In_circuit.t\n\n let shift = Shifted_value.Shift.create (module Tock.Field)\n\n let dummy : t Lazy.t =\n lazy\n (let one_chal = Challenge.Constant.dummy in\n let open Ro in\n let alpha = scalar_chal () in\n let beta = chal () in\n let gamma = chal () in\n let zeta = scalar_chal () in\n let chals :\n _ Composition_types.Wrap.Proof_state.Deferred_values.Plonk.Minimal.t\n =\n { alpha = Common.Ipa.Wrap.endo_to_field alpha\n ; beta = Challenge.Constant.to_tock_field beta\n ; gamma = Challenge.Constant.to_tock_field gamma\n ; zeta = Common.Ipa.Wrap.endo_to_field zeta\n ; joint_combiner = None\n ; feature_flags = Plonk_types.Features.none_bool\n }\n in\n let evals =\n Plonk_types.Evals.to_in_circuit Dummy.evals_combined.evals.evals\n in\n let env =\n let module Env_bool = struct\n type t = bool\n\n let true_ = true\n\n let false_ = false\n\n let ( &&& ) = ( && )\n\n let ( ||| ) = ( || )\n\n let any = List.exists ~f:Fn.id\n end in\n let module Env_field = struct\n include Tock.Field\n\n type bool = Env_bool.t\n\n let if_ (b : bool) ~then_ ~else_ = if b then then_ () else else_ ()\n end in\n Plonk_checks.scalars_env\n (module Env_bool)\n (module Env_field)\n ~srs_length_log2:Common.Max_degree.wrap_log2\n ~endo:Endo.Wrap_inner_curve.base ~mds:Tock_field_sponge.params.mds\n ~field_of_hex:\n (Core_kernel.Fn.compose Tock.Field.of_bigint (fun x ->\n Kimchi_pasta.Pasta.Bigint256.of_hex_string x ) )\n ~domain:\n (Plonk_checks.domain\n (module Tock.Field)\n (wrap_domains ~proofs_verified:2).h ~shifts:Common.tock_shifts\n ~domain_generator:Tock.Field.domain_generator )\n chals evals\n in\n let plonk =\n let module Field = struct\n include Tock.Field\n end in\n Plonk_checks.derive_plonk (module Field) ~env ~shift chals evals\n |> Composition_types.Step.Proof_state.Deferred_values.Plonk.In_circuit\n .of_wrap\n ~assert_none:(fun x ->\n assert (Option.is_none (Plonk_types.Opt.to_option x)) )\n ~assert_false:(fun x -> assert (not x))\n in\n { deferred_values =\n { plonk = { plonk with alpha; beta; gamma; zeta }\n ; combined_inner_product = Shifted_value (tock ())\n ; xi = Scalar_challenge.create one_chal\n ; bulletproof_challenges = Dummy.Ipa.Wrap.challenges\n ; b = Shifted_value (tock ())\n }\n ; should_finalize = false\n ; sponge_digest_before_evaluations = Digest.Constant.dummy\n } )\nend\n\nlet typ ~wrap_rounds:_ : (t, Constant.t) Typ.t =\n Types.Step.Proof_state.Per_proof.typ\n (module Impl)\n (Shifted_value.typ Other_field.typ)\n ~assert_16_bits:(Step_verifier.assert_n_bits ~n:16)\n ~zero:Common.Lookup_parameters.tick_zero\n\nlet dummy : unit -> t =\n Memo.unit (fun () ->\n let (Typ { var_of_fields; value_to_fields; _ }) =\n typ ~wrap_rounds:Backend.Tock.Rounds.n\n in\n let xs, aux = value_to_fields (Lazy.force Constant.dummy) in\n var_of_fields (Array.map ~f:Field.constant xs, aux) )\n","open Import\nopen Types\nopen Pickles_types\nopen Hlist\nopen Snarky_backendless.Request\nopen Backend\n\nmodule Wrap = struct\n module type S = sig\n type max_proofs_verified\n\n type max_local_max_proofs_verifieds\n\n open Impls.Wrap\n open Snarky_backendless.Request\n\n type _ t +=\n | Evals :\n ( (Field.Constant.t, Field.Constant.t array) Plonk_types.All_evals.t\n , max_proofs_verified )\n Vector.t\n t\n | Which_branch : int t\n | Step_accs : (Tock.Inner_curve.Affine.t, max_proofs_verified) Vector.t t\n | Old_bulletproof_challenges :\n max_local_max_proofs_verifieds H1.T(Challenges_vector.Constant).t t\n | Proof_state :\n ( ( ( Challenge.Constant.t\n , Challenge.Constant.t Scalar_challenge.t\n , Field.Constant.t Shifted_value.Type2.t\n , ( Challenge.Constant.t Scalar_challenge.t Bulletproof_challenge.t\n , Tock.Rounds.n )\n Vector.t\n , Digest.Constant.t\n , bool )\n Types.Step.Proof_state.Per_proof.In_circuit.t\n , max_proofs_verified )\n Vector.t\n , Digest.Constant.t )\n Types.Step.Proof_state.t\n t\n | Messages : Tock.Inner_curve.Affine.t Plonk_types.Messages.t t\n | Openings_proof :\n ( Tock.Inner_curve.Affine.t\n , Tick.Field.t )\n Plonk_types.Openings.Bulletproof.t\n t\n | Wrap_domain_indices : (Field.Constant.t, max_proofs_verified) Vector.t t\n end\n\n type ('mb, 'ml) t =\n (module S\n with type max_proofs_verified = 'mb\n and type max_local_max_proofs_verifieds = 'ml )\n\n let create : type mb ml. unit -> (mb, ml) t =\n fun () ->\n let module R = struct\n type nonrec max_proofs_verified = mb\n\n type nonrec max_local_max_proofs_verifieds = ml\n\n open Snarky_backendless.Request\n\n type 'a vec = ('a, max_proofs_verified) Vector.t\n\n type _ t +=\n | Evals :\n (Tock.Field.t, Tock.Field.t array) Plonk_types.All_evals.t vec t\n | Which_branch : int t\n | Step_accs : Tock.Inner_curve.Affine.t vec t\n | Old_bulletproof_challenges :\n max_local_max_proofs_verifieds H1.T(Challenges_vector.Constant).t t\n | Proof_state :\n ( ( ( Challenge.Constant.t\n , Challenge.Constant.t Scalar_challenge.t\n , Tock.Field.t Shifted_value.Type2.t\n , ( Challenge.Constant.t Scalar_challenge.t\n Bulletproof_challenge.t\n , Tock.Rounds.n )\n Vector.t\n , Digest.Constant.t\n , bool )\n Types.Step.Proof_state.Per_proof.In_circuit.t\n , max_proofs_verified )\n Vector.t\n , Digest.Constant.t )\n Types.Step.Proof_state.t\n t\n | Messages : Tock.Inner_curve.Affine.t Plonk_types.Messages.t t\n | Openings_proof :\n ( Tock.Inner_curve.Affine.t\n , Tick.Field.t )\n Plonk_types.Openings.Bulletproof.t\n t\n | Wrap_domain_indices : (Tock.Field.t, max_proofs_verified) Vector.t t\n end in\n (module R)\nend\n\nmodule Step = struct\n module type S = sig\n type statement\n\n type return_value\n\n type prev_values\n\n type proofs_verified\n\n (* TODO: As an optimization this can be the local proofs-verified size *)\n type max_proofs_verified\n\n type local_signature\n\n type local_branches\n\n type auxiliary_value\n\n type _ t +=\n | Compute_prev_proof_parts :\n ( prev_values\n , local_signature )\n H2.T(Inductive_rule.Previous_proof_statement.Constant).t\n -> unit t\n | Proof_with_datas :\n ( prev_values\n , local_signature\n , local_branches )\n H3.T(Per_proof_witness.Constant.No_app_state).t\n t\n | Wrap_index : Tock.Curve.Affine.t Plonk_verification_key_evals.t t\n | App_state : statement t\n | Return_value : return_value -> unit t\n | Auxiliary_value : auxiliary_value -> unit t\n | Unfinalized_proofs :\n (Unfinalized.Constant.t, proofs_verified) Vector.t t\n | Messages_for_next_wrap_proof :\n (Digest.Constant.t, max_proofs_verified) Vector.t t\n | Wrap_domain_indices :\n (Pickles_base.Proofs_verified.t, proofs_verified) Vector.t t\n end\n\n let create :\n type proofs_verified local_signature local_branches statement return_value auxiliary_value prev_values max_proofs_verified.\n unit\n -> (module S\n with type local_signature = local_signature\n and type local_branches = local_branches\n and type statement = statement\n and type return_value = return_value\n and type auxiliary_value = auxiliary_value\n and type prev_values = prev_values\n and type proofs_verified = proofs_verified\n and type max_proofs_verified = max_proofs_verified ) =\n fun () ->\n let module R = struct\n type nonrec max_proofs_verified = max_proofs_verified\n\n type nonrec proofs_verified = proofs_verified\n\n type nonrec statement = statement\n\n type nonrec return_value = return_value\n\n type nonrec auxiliary_value = auxiliary_value\n\n type nonrec prev_values = prev_values\n\n type nonrec local_signature = local_signature\n\n type nonrec local_branches = local_branches\n\n type _ t +=\n | Compute_prev_proof_parts :\n ( prev_values\n , local_signature )\n H2.T(Inductive_rule.Previous_proof_statement.Constant).t\n -> unit t\n | Proof_with_datas :\n ( prev_values\n , local_signature\n , local_branches )\n H3.T(Per_proof_witness.Constant.No_app_state).t\n t\n | Wrap_index : Tock.Curve.Affine.t Plonk_verification_key_evals.t t\n | App_state : statement t\n | Return_value : return_value -> unit t\n | Auxiliary_value : auxiliary_value -> unit t\n | Unfinalized_proofs :\n (Unfinalized.Constant.t, proofs_verified) Vector.t t\n | Messages_for_next_wrap_proof :\n (Digest.Constant.t, max_proofs_verified) Vector.t t\n | Wrap_domain_indices :\n (Pickles_base.Proofs_verified.t, proofs_verified) Vector.t t\n end in\n (module R)\nend\n","open Core_kernel\n\nlet l = ref \"\"\n\nlet r = ref (Time.now ())\n\nlet start =\n Common.when_profiling\n (fun loc ->\n r := Time.now () ;\n l := loc )\n ignore\n\nlet clock =\n Common.when_profiling\n (fun loc ->\n let t = Time.now () in\n printf \"%s -> %s: %s\\n%!\" !l loc\n (Time.Span.to_string_hum (Time.diff t !r)) ;\n r := t ;\n l := loc )\n ignore\n","open Core_kernel\nopen Import\n\nlet zk_rows = 3\n\nlet rough_domains =\n let d = Domain.Pow_2_roots_of_unity 20 in\n { Domains.h = d }\n\nlet domains (type field)\n (module Impl : Snarky_backendless.Snark_intf.Run with type field = field)\n (Spec.ETyp.T (typ, conv, _conv_inv))\n (Spec.ETyp.T (return_typ, _ret_conv, ret_conv_inv)) main =\n let main x () = ret_conv_inv (main (conv x)) in\n\n let domains2 sys =\n let open Domain in\n let public_input_size =\n Set_once.get_exn\n (Impl.R1CS_constraint_system.get_public_input_size sys)\n [%here]\n in\n let rows =\n zk_rows + public_input_size + Impl.R1CS_constraint_system.get_rows_len sys\n in\n { Domains.h = Pow_2_roots_of_unity Int.(ceil_log2 rows) }\n in\n domains2 (Impl.constraint_system ~input_typ:typ ~return_typ main)\n","open Core_kernel\nopen Pickles_types\nopen Import\nopen Kimchi_pasta.Pasta\n\nmodule Verifier_index_json = struct\n module Lookup = struct\n type 't lookup_selectors =\n 't Kimchi_types.VerifierIndex.Lookup.lookup_selectors =\n { lookup : 't option\n ; xor : 't option\n ; range_check : 't option\n ; ffmul : 't option\n }\n [@@deriving yojson]\n\n type lookup_pattern = Kimchi_types.lookup_pattern =\n | Xor\n | Lookup\n | RangeCheck\n | ForeignFieldMul\n [@@deriving yojson]\n\n type lookup_patterns = Kimchi_types.lookup_patterns =\n { xor : bool\n ; lookup : bool\n ; range_check : bool\n ; foreign_field_mul : bool\n }\n [@@deriving yojson]\n\n type lookup_features = Kimchi_types.lookup_features =\n { patterns : lookup_patterns\n ; joint_lookup_used : bool\n ; uses_runtime_tables : bool\n }\n [@@deriving yojson]\n\n type lookup_info = Kimchi_types.VerifierIndex.Lookup.lookup_info =\n { max_per_row : int; max_joint_size : int; features : lookup_features }\n [@@deriving yojson]\n\n type 'polyComm t = 'polyComm Kimchi_types.VerifierIndex.Lookup.t =\n { joint_lookup_used : bool\n ; lookup_table : 'polyComm array\n ; lookup_selectors : 'polyComm lookup_selectors\n ; table_ids : 'polyComm option\n ; lookup_info : lookup_info\n ; runtime_tables_selector : 'polyComm option\n }\n [@@deriving yojson]\n end\n\n type 'fr domain = 'fr Kimchi_types.VerifierIndex.domain =\n { log_size_of_group : int; group_gen : 'fr }\n [@@deriving yojson]\n\n type 'polyComm verification_evals =\n 'polyComm Kimchi_types.VerifierIndex.verification_evals =\n { sigma_comm : 'polyComm array\n ; coefficients_comm : 'polyComm array\n ; generic_comm : 'polyComm\n ; psm_comm : 'polyComm\n ; complete_add_comm : 'polyComm\n ; mul_comm : 'polyComm\n ; emul_comm : 'polyComm\n ; endomul_scalar_comm : 'polyComm\n }\n [@@deriving yojson]\n\n type ('fr, 'sRS, 'polyComm) verifier_index =\n ('fr, 'sRS, 'polyComm) Kimchi_types.VerifierIndex.verifier_index =\n { domain : 'fr domain\n ; max_poly_size : int\n ; public : int\n ; prev_challenges : int\n ; srs : 'sRS\n ; evals : 'polyComm verification_evals\n ; shifts : 'fr array\n ; lookup_index : 'polyComm Lookup.t option\n }\n [@@deriving yojson]\n\n type 'f or_infinity = 'f Kimchi_types.or_infinity =\n | Infinity\n | Finite of ('f * 'f)\n [@@deriving yojson]\n\n type 'g polycomm = 'g Kimchi_types.poly_comm =\n { unshifted : 'g array; shifted : 'g option }\n [@@deriving yojson]\n\n let to_yojson fp fq =\n verifier_index_to_yojson fp\n (fun _ -> `Null)\n (polycomm_to_yojson (or_infinity_to_yojson fq))\nend\n\nmodule Data = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = { constraints : int } [@@deriving yojson]\n\n let to_latest = Fn.id\n end\n end]\nend\n\nmodule Repr = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t =\n { commitments :\n Backend.Tock.Curve.Affine.Stable.V1.t\n Plonk_verification_key_evals.Stable.V2.t\n ; data : Data.Stable.V1.t\n }\n [@@deriving to_yojson]\n\n let to_latest = Fn.id\n end\n end]\nend\n\n[%%versioned_binable\nmodule Stable = struct\n module V2 = struct\n type t =\n { commitments : Backend.Tock.Curve.Affine.t Plonk_verification_key_evals.t\n ; index :\n (Impls.Wrap.Verification_key.t\n [@to_yojson\n Verifier_index_json.to_yojson Backend.Tock.Field.to_yojson\n Backend.Tick.Field.to_yojson] )\n ; data : Data.t\n }\n [@@deriving fields, to_yojson]\n\n let to_latest = Fn.id\n\n let of_repr srs { Repr.commitments = c; data = d } =\n let t : Impls.Wrap.Verification_key.t =\n let log2_size = Int.ceil_log2 d.constraints in\n let public =\n let (T (input, _conv, _conv_inv)) = Impls.Wrap.input () in\n let (Typ typ) = input in\n typ.size_in_field_elements\n in\n { domain =\n { log_size_of_group = log2_size\n ; group_gen = Backend.Tock.Field.domain_generator ~log2_size\n }\n ; max_poly_size = 1 lsl Nat.to_int Rounds.Wrap.n\n ; public\n ; prev_challenges = 2 (* Due to Wrap_hack *)\n ; srs\n ; evals =\n (let g (x, y) =\n { Kimchi_types.unshifted = [| Kimchi_types.Finite (x, y) |]\n ; shifted = None\n }\n in\n { sigma_comm = Array.map ~f:g (Vector.to_array c.sigma_comm)\n ; coefficients_comm =\n Array.map ~f:g (Vector.to_array c.coefficients_comm)\n ; generic_comm = g c.generic_comm\n ; mul_comm = g c.mul_comm\n ; psm_comm = g c.psm_comm\n ; emul_comm = g c.emul_comm\n ; complete_add_comm = g c.complete_add_comm\n ; endomul_scalar_comm = g c.endomul_scalar_comm\n } )\n ; shifts = Common.tock_shifts ~log2_size\n ; lookup_index = None\n }\n in\n { commitments = c; data = d; index = t }\n\n include\n Binable.Of_binable\n (Repr.Stable.V2)\n (struct\n type nonrec t = t\n\n let to_binable { commitments; data; index = _ } =\n { Repr.commitments; data }\n\n let of_binable r = of_repr (Backend.Tock.Keypair.load_urs ()) r\n end)\n end\nend]\n\nlet to_yojson = Stable.Latest.to_yojson\n\nlet dummy_commitments g =\n let open Plonk_types in\n { Plonk_verification_key_evals.sigma_comm =\n Vector.init Permuts.n ~f:(fun _ -> g)\n ; coefficients_comm = Vector.init Columns.n ~f:(fun _ -> g)\n ; generic_comm = g\n ; psm_comm = g\n ; complete_add_comm = g\n ; mul_comm = g\n ; emul_comm = g\n ; endomul_scalar_comm = g\n }\n\nlet dummy =\n lazy\n (let rows = Domain.size (Common.wrap_domains ~proofs_verified:2).h in\n let g = Backend.Tock.Curve.(to_affine_exn one) in\n { Repr.commitments = dummy_commitments g; data = { constraints = rows } }\n |> Stable.Latest.of_repr (Kimchi_bindings.Protocol.SRS.Fq.create 1) )\n","open Core_kernel\nopen Pickles_types\nopen Import\nopen Poly_types\n\n(* Compute the domains corresponding to wrap_main *)\n\n(* TODO: this functor does not depend on any of its argument why? *)\n\nmodule Make\n (A : T0)\n (A_value : T0)\n (Ret_var : T0)\n (Ret_value : T0)\n (Auxiliary_var : T0)\n (Auxiliary_value : T0) =\nstruct\n let f_debug full_signature _num_choices choices_length ~feature_flags\n ~max_proofs_verified =\n let num_choices = Hlist.Length.to_nat choices_length in\n let dummy_step_domains =\n Vector.init num_choices ~f:(fun _ -> Fix_domains.rough_domains)\n in\n let dummy_step_widths =\n Vector.init num_choices ~f:(fun _ ->\n Nat.to_int (Nat.Add.n max_proofs_verified) )\n in\n let dummy_step_keys =\n lazy\n (Vector.init num_choices ~f:(fun _ ->\n let g = Backend.Tock.Inner_curve.(to_affine_exn one) in\n Verification_key.dummy_commitments g ) )\n in\n Timer.clock __LOC__ ;\n let srs = Backend.Tick.Keypair.load_urs () in\n let _, main =\n Wrap_main.wrap_main ~feature_flags ~srs full_signature choices_length\n dummy_step_keys dummy_step_widths dummy_step_domains max_proofs_verified\n in\n Timer.clock __LOC__ ;\n let t =\n Fix_domains.domains\n (module Impls.Wrap)\n (Impls.Wrap.input ())\n (T (Snarky_backendless.Typ.unit (), Fn.id, Fn.id))\n main\n in\n Timer.clock __LOC__ ; t\n\n let f full_signature num_choices choices_length ~feature_flags\n ~max_proofs_verified =\n let res =\n Common.wrap_domains\n ~proofs_verified:(Nat.to_int (Nat.Add.n max_proofs_verified))\n in\n ( if debug then\n let res' =\n f_debug full_signature num_choices choices_length ~feature_flags\n ~max_proofs_verified\n in\n [%test_eq: Domains.t] res res' ) ;\n res\nend\n[@@warning \"-60\"]\n","module SC = Scalar_challenge\nmodule P = Proof\nopen Pickles_types\nopen Hlist\nopen Common\nopen Import\nopen Types\nopen Backend\n\n(* This contains the \"wrap\" prover *)\n\nlet challenge_polynomial =\n Wrap_verifier.challenge_polynomial (module Backend.Tick.Field)\n\nmodule Type1 =\n Plonk_checks.Make\n (Shifted_value.Type1)\n (struct\n let constant_term = Plonk_checks.Scalars.Tick.constant_term\n\n let index_terms = Plonk_checks.Scalars.Tick.index_terms\n end)\n\nlet _vector_of_list (type a t)\n (module V : Snarky_intf.Vector.S with type elt = a and type t = t)\n (xs : a list) : t =\n let r = V.create () in\n List.iter xs ~f:(V.emplace_back r) ;\n r\n\nlet tick_rounds = Nat.to_int Tick.Rounds.n\n\nlet combined_inner_product (type actual_proofs_verified) ~env ~domain ~ft_eval1\n ~actual_proofs_verified:\n (module AB : Nat.Add.Intf with type n = actual_proofs_verified)\n (e : _ Plonk_types.All_evals.With_public_input.t)\n ~(old_bulletproof_challenges : (_, actual_proofs_verified) Vector.t) ~r\n ~plonk ~xi ~zeta ~zetaw =\n let combined_evals =\n Plonk_checks.evals_of_split_evals ~zeta ~zetaw\n (module Tick.Field)\n ~rounds:tick_rounds e.evals\n in\n let ft_eval0 : Tick.Field.t =\n Type1.ft_eval0\n (module Tick.Field)\n plonk ~env ~domain\n (Plonk_types.Evals.to_in_circuit combined_evals)\n (fst e.public_input)\n in\n let T = AB.eq in\n let challenge_polys =\n Vector.map\n ~f:(fun chals -> unstage (challenge_polynomial (Vector.to_array chals)))\n old_bulletproof_challenges\n in\n let a = Plonk_types.Evals.to_list e.evals in\n let combine ~which_eval ~ft pt =\n let f (x, y) = match which_eval with `Fst -> x | `Snd -> y in\n let a = List.map ~f a in\n let v : Tick.Field.t array list =\n List.append\n (List.map (Vector.to_list challenge_polys) ~f:(fun f -> [| f pt |]))\n ([| f e.public_input |] :: [| ft |] :: a)\n in\n let open Tick.Field in\n Pcs_batch.combine_split_evaluations ~xi ~init:Fn.id\n ~mul_and_add:(fun ~acc ~xi fx -> fx + (xi * acc))\n v\n in\n let open Tick.Field in\n combine ~which_eval:`Fst ~ft:ft_eval0 zeta\n + (r * combine ~which_eval:`Snd ~ft:ft_eval1 zetaw)\n\nmodule Deferred_values = Types.Wrap.Proof_state.Deferred_values\n\ntype scalar_challenge_constant = Challenge.Constant.t Scalar_challenge.t\n\ntype deferred_values_and_hints =\n { x_hat_evals : Backend.Tick.Field.t * Backend.Tick.Field.t\n ; sponge_digest_before_evaluations : Tick.Field.t\n ; deferred_values :\n ( ( Challenge.Constant.t\n , scalar_challenge_constant\n , Backend.Tick.Field.t Pickles_types.Shifted_value.Type1.t\n , (Tick.Field.t Shifted_value.Type1.t, bool) Opt.t\n , ( scalar_challenge_constant Deferred_values.Plonk.In_circuit.Lookup.t\n , bool )\n Opt.t\n , bool )\n Deferred_values.Plonk.In_circuit.t\n , scalar_challenge_constant\n , Tick.Field.t Shifted_value.Type1.t\n , Challenge.Constant.t Scalar_challenge.t Bulletproof_challenge.t\n Step_bp_vec.t\n , Branch_data.t )\n Deferred_values.t\n }\n\nlet deferred_values (type n) ~(sgs : (Backend.Tick.Curve.Affine.t, n) Vector.t)\n ~actual_feature_flags\n ~(prev_challenges : ((Backend.Tick.Field.t, _) Vector.t, n) Vector.t)\n ~(step_vk : Kimchi_bindings.Protocol.VerifierIndex.Fp.t)\n ~(public_input : Backend.Tick.Field.t list) ~(proof : Backend.Tick.Proof.t)\n ~(actual_proofs_verified : n Nat.t) : deferred_values_and_hints =\n let module O = Tick.Oracles in\n let o =\n O.create step_vk\n Vector.(\n map2 sgs prev_challenges ~f:(fun commitment cs ->\n { Tick.Proof.Challenge_polynomial.commitment\n ; challenges = Vector.to_array cs\n } )\n |> to_list)\n public_input proof\n in\n let x_hat = O.(p_eval_1 o, p_eval_2 o) in\n let scalar_chal f =\n Scalar_challenge.map ~f:Challenge.Constant.of_tick_field (f o)\n in\n let plonk0 =\n { Types.Wrap.Proof_state.Deferred_values.Plonk.Minimal.alpha =\n scalar_chal O.alpha\n ; beta = O.beta o\n ; gamma = O.gamma o\n ; zeta = scalar_chal O.zeta\n ; joint_combiner =\n (* TODO: Needs to be changed when lookups are fully implemented *)\n Option.map (O.joint_combiner_chal o)\n ~f:(Scalar_challenge.map ~f:Challenge.Constant.of_tick_field)\n ; feature_flags = actual_feature_flags\n }\n in\n let r = scalar_chal O.u in\n let xi = scalar_chal O.v in\n let module As_field = struct\n let to_field =\n SC.to_field_constant\n (module Tick.Field)\n ~endo:Endo.Wrap_inner_curve.scalar\n\n let r = to_field r\n\n let xi = to_field xi\n\n let zeta = to_field plonk0.zeta\n\n let alpha = to_field plonk0.alpha\n\n let joint_combiner = Option.map ~f:to_field plonk0.joint_combiner\n end in\n let domain = Domain.Pow_2_roots_of_unity step_vk.domain.log_size_of_group in\n let zetaw = Tick.Field.mul As_field.zeta step_vk.domain.group_gen in\n let tick_plonk_minimal =\n { plonk0 with\n zeta = As_field.zeta\n ; alpha = As_field.alpha\n ; joint_combiner = As_field.joint_combiner\n }\n in\n let tick_combined_evals =\n Plonk_checks.evals_of_split_evals\n (module Tick.Field)\n proof.openings.evals ~rounds:(Nat.to_int Tick.Rounds.n)\n ~zeta:As_field.zeta ~zetaw\n |> Plonk_types.Evals.to_in_circuit\n in\n let tick_domain =\n Plonk_checks.domain\n (module Tick.Field)\n domain ~shifts:Common.tick_shifts\n ~domain_generator:Backend.Tick.Field.domain_generator\n in\n let tick_env =\n let module Env_bool = struct\n type t = bool\n\n let true_ = true\n\n let false_ = false\n\n let ( &&& ) = ( && )\n\n let ( ||| ) = ( || )\n\n let any = List.exists ~f:Fn.id\n end in\n let module Env_field = struct\n include Tick.Field\n\n type bool = Env_bool.t\n\n let if_ (b : bool) ~then_ ~else_ = if b then then_ () else else_ ()\n end in\n Plonk_checks.scalars_env\n (module Env_bool)\n (module Env_field)\n ~endo:Endo.Step_inner_curve.base ~mds:Tick_field_sponge.params.mds\n ~srs_length_log2:Common.Max_degree.step_log2\n ~field_of_hex:(fun s ->\n Kimchi_pasta.Pasta.Bigint256.of_hex_string s\n |> Kimchi_pasta.Pasta.Fp.of_bigint )\n ~domain:tick_domain tick_plonk_minimal tick_combined_evals\n in\n let plonk =\n let module Field = struct\n include Tick.Field\n end in\n Type1.derive_plonk\n (module Field)\n ~shift:Shifts.tick1 ~env:tick_env tick_plonk_minimal tick_combined_evals\n and new_bulletproof_challenges, b =\n let prechals =\n Array.map (O.opening_prechallenges o) ~f:(fun x ->\n Scalar_challenge.map ~f:Challenge.Constant.of_tick_field x )\n in\n let chals = Array.map prechals ~f:(fun x -> Ipa.Step.compute_challenge x) in\n let challenge_poly = unstage (challenge_polynomial chals) in\n let open As_field in\n let b =\n let open Tick.Field in\n challenge_poly zeta + (r * challenge_poly zetaw)\n in\n let prechals = Array.map prechals ~f:Bulletproof_challenge.unpack in\n (prechals, b)\n in\n let shift_value =\n Shifted_value.Type1.of_field (module Tick.Field) ~shift:Shifts.tick1\n and chal = Challenge.Constant.of_tick_field in\n { deferred_values =\n { Types.Wrap.Proof_state.Deferred_values.xi\n ; b = shift_value b\n ; bulletproof_challenges =\n Vector.of_array_and_length_exn new_bulletproof_challenges\n Tick.Rounds.n\n ; combined_inner_product =\n shift_value\n As_field.(\n combined_inner_product (* Note: We do not pad here. *)\n ~actual_proofs_verified:(Nat.Add.create actual_proofs_verified)\n { evals = proof.openings.evals; public_input = x_hat }\n ~r ~xi ~zeta ~zetaw ~old_bulletproof_challenges:prev_challenges\n ~env:tick_env ~domain:tick_domain\n ~ft_eval1:proof.openings.ft_eval1 ~plonk:tick_plonk_minimal)\n ; branch_data =\n { proofs_verified =\n ( match actual_proofs_verified with\n | Z ->\n Branch_data.Proofs_verified.N0\n | S Z ->\n N1\n | S (S Z) ->\n N2\n | S _ ->\n assert false )\n ; domain_log2 =\n Branch_data.Domain_log2.of_int_exn\n step_vk.domain.log_size_of_group\n }\n ; plonk =\n { plonk with\n zeta = plonk0.zeta\n ; alpha = plonk0.alpha\n ; beta = chal plonk0.beta\n ; gamma = chal plonk0.gamma\n ; lookup =\n Opt.map plonk.lookup ~f:(fun _ ->\n { Composition_types.Wrap.Proof_state.Deferred_values.Plonk\n .In_circuit\n .Lookup\n .joint_combiner = Option.value_exn plonk0.joint_combiner\n } )\n }\n }\n ; x_hat_evals = x_hat\n ; sponge_digest_before_evaluations = O.digest_before_evaluations o\n }\n\n(* Testing\n -------\n\n Invocation:\n dune exec src/lib/pickles/.pickles.inline-tests/inline_test_runner_pickles.exe \\\n --profile=dev --display short -- inline-test-runner pickles -only-test wrap.ml\n*)\nlet%test_module \"gate finalization\" =\n ( module struct\n type test_options =\n { true_is_yes : Plonk_types.Features.options\n ; true_is_maybe : Plonk_types.Features.options\n ; all_maybes : Plonk_types.Features.options\n }\n\n (* Helper function to convert actual feature flags into 3 test configurations of feature flags\n @param actual_feature_flags The actual feature flags in terms of true/false\n\n @return Corresponding feature flags configs composed of Yes/No/Maybe options\n - one where true is mapped to Yes and false is mapped to No\n - one where true is mapped to Maybe and false is mapped to No\n - one where true and false are both mapped to Maybe *)\n let generate_test_feature_flag_configs\n (actual_feature_flags : Plonk_types.Features.flags) : test_options =\n (* Set up a helper to convert actual feature flags composed of booleans into\n feature flags composed of Yes/No/Maybe options.\n @param actual_feature_flags The actual feature flags in terms of true/false\n @param true_opt Plonk_types.Opt type to use for true/enabled features\n @param false_opt Plonk_types.Opt type to use for false/disabled features\n @return Corresponding feature flags composed of Yes/No/Maybe values *)\n let compute_feature_flags\n (actual_feature_flags : Plonk_types.Features.flags)\n (true_opt : Plonk_types.Opt.Flag.t)\n (false_opt : Plonk_types.Opt.Flag.t) : Plonk_types.Features.options =\n Plonk_types.Features.map actual_feature_flags ~f:(function\n | true ->\n true_opt\n | false ->\n false_opt )\n in\n\n (* Generate the 3 configurations of the actual feature flags using\n helper *)\n let open Plonk_types.Opt.Flag in\n { true_is_yes = compute_feature_flags actual_feature_flags Yes No\n ; true_is_maybe = compute_feature_flags actual_feature_flags Maybe No\n ; all_maybes = compute_feature_flags actual_feature_flags Maybe Maybe\n }\n\n (* Run the recursive proof tests on the supplied inputs.\n\n @param actual_feature_flags User-specified feature flags, matching those\n required by the backend circuit\n @param public_input list of public inputs (can be empty)\n @param vk Verifier index for backend circuit\n @param proof Backend proof\n\n @return true or throws and exception\n *)\n let run_recursive_proof_test\n (actual_feature_flags : Plonk_types.Features.flags)\n (feature_flags : Plonk_types.Features.options)\n (public_input : Pasta_bindings.Fp.t list)\n (vk : Kimchi_bindings.Protocol.VerifierIndex.Fp.t)\n (proof : Backend.Tick.Proof.t) : Impls.Step.Boolean.value =\n (* Constants helper - takes an OCaml value and converts it to a snarky value, where\n all values here are constant literals. N.b. this should be\n encapsulated as Snarky internals, but it never got merged. *)\n let constant (Typ typ : _ Snarky_backendless.Typ.t) x =\n let xs, aux = typ.value_to_fields x in\n typ.var_of_fields (Array.map xs ~f:Impls.Step.Field.constant, aux)\n in\n\n (* Compute deferred values - in the Pickles recursive proof system, deferred values\n are values from 2 proofs earlier in the recursion hierarchy. Every recursion\n goes through a two-phase process of step and wrap, like so\n\n step <- wrap <- step <- ... <- wrap <- step,\n `<-----------'\n deferred\n\n where there may be multiple children at each level (but let's ignore that!).\n Deferred values are values (part of the public input) that must be passed between\n the two phases in order to be verified correctly-- it works like this.\n\n - The wrap proof is passed the deferred values for its step proof as part of its public input.\n - The wrap proof starts verifying the step proof. As part of this verification it must\n perform all of the group element checks (since it's over the Vesta base field); however,\n at this stage it just assumes that the deferred values of its public input are correct\n (i.e. it defers checking them).\n - The next step proof verifies the wrap proof with a similar process, but using the other\n curve (e.g. Pallas). There are two important things to note:\n - Since it is using the other curve, it can compute the commitments to the public inputs\n of the previous wrap circuit that were passed into it. In other words, the next step\n proof receives data from the previous wrap proof about the previous step proof. Yeah,\n from two proofs back! (e.g. the deferred values)\n - The next step proof also computes the deferred values inside the circuit and verifies\n that they match those used by the previous wrap proof.\n\n The code below generates the deferred values so that we can verifiy that we can actually\n compute those values correctly inside the circuit. Special thanks to Matthew Ryan for\n explaining this in detail. *)\n let { deferred_values; x_hat_evals; sponge_digest_before_evaluations } =\n deferred_values ~actual_feature_flags ~sgs:[] ~prev_challenges:[]\n ~step_vk:vk ~public_input ~proof ~actual_proofs_verified:Nat.N0.n\n in\n\n (* Define Typ.t for Deferred_values.t -- A Type.t defines how to convert a value of some type\n in OCaml into a var in circuit/Snarky.\n\n This complex function is called with two sets of inputs: once for the step circuit and\n once for the wrap circuit. It was decided not to use a functor for this. *)\n let deferred_values_typ =\n let open Impls.Step in\n let open Step_main_inputs in\n let open Step_verifier in\n Wrap.Proof_state.Deferred_values.In_circuit.typ\n (module Impls.Step)\n ~feature_flags ~challenge:Challenge.typ\n ~scalar_challenge:Challenge.typ\n ~dummy_scalar:(Shifted_value.Type1.Shifted_value Field.Constant.zero)\n ~dummy_scalar_challenge:\n (Kimchi_backend_common.Scalar_challenge.create\n Limb_vector.Challenge.Constant.zero )\n (Shifted_value.Type1.typ Field.typ)\n (Branch_data.typ\n (module Impl)\n ~assert_16_bits:(Step_verifier.assert_n_bits ~n:16) )\n in\n\n (* Use deferred_values_typ and the constant helper to prepare deferred_values\n for use in the circuit. We change some [Opt.t] to [Option.t] because that is\n what Type.t is configured to accept. *)\n let deferred_values =\n constant deferred_values_typ\n { deferred_values with\n plonk =\n { deferred_values.plonk with\n lookup = Opt.to_option_unsafe deferred_values.plonk.lookup\n }\n }\n (* Prepare all of the evaluations (i.e. all of the columns in the proof that we open)\n for use in the circuit *)\n and evals =\n constant\n (Plonk_types.All_evals.typ (module Impls.Step) feature_flags)\n { evals = { public_input = x_hat_evals; evals = proof.openings.evals }\n ; ft_eval1 = proof.openings.ft_eval1\n }\n in\n\n (* Run the circuit without generating a proof using run_and_check *)\n Impls.Step.run_and_check (fun () ->\n (* Set up the step sponge from the wrap sponge -- we cannot use the same poseidon\n sponge in both step and wrap because they have different fields.\n\n In order to continue the Fiat-Shamir heuristic across field boundaries we use\n the wrap sponge for everything in the wrap proof, squeeze it one final time and\n expose the squoze value in the public input to the step proof, which absorbs\n said squoze value into the step sponge. :-) This means the step sponge has absorbed\n everything from the proof so far by proxy and that is also over the native field! *)\n let res, _chals =\n let sponge =\n let open Step_main_inputs in\n let sponge = Sponge.create sponge_params in\n Sponge.absorb sponge\n (`Field (Impl.Field.constant sponge_digest_before_evaluations)) ;\n sponge\n in\n\n (* Call finalisation with all of the required details *)\n Step_verifier.finalize_other_proof\n (module Nat.N0)\n ~feature_flags\n ~step_domains:\n (`Known\n [ { h = Pow_2_roots_of_unity vk.domain.log_size_of_group } ]\n )\n ~sponge ~prev_challenges:[] deferred_values evals\n in\n\n (* Read the boolean result from the circuit and make it available\n to the OCaml world. *)\n Impls.Step.(As_prover.(fun () -> read Boolean.typ res)) )\n |> Or_error.ok_exn\n\n (* Common srs value for all tests *)\n let srs =\n Kimchi_bindings.Protocol.SRS.Fp.create (1 lsl Common.Max_degree.step_log2)\n\n type example =\n Kimchi_bindings.Protocol.SRS.Fp.t\n -> Kimchi_bindings.Protocol.Index.Fp.t\n * Pasta_bindings.Fp.t list\n * ( Pasta_bindings.Fq.t Kimchi_types.or_infinity\n , Pasta_bindings.Fp.t )\n Kimchi_types.prover_proof\n\n module type SETUP = sig\n val example : example\n\n (* Feature flags tused for backend proof *)\n val actual_feature_flags : bool Plonk_types.Features.t\n end\n\n (* [Make] is the test functor.\n\n Given a test setup, compute different test configurations and define 3\n test for said configurations. *)\n module Make (S : SETUP) = struct\n (* Generate foreign field multiplication test backend proof using Kimchi,\n obtaining the proof and corresponding prover index.\n\n Note: we only want to pay the cost of generating this proof once and\n then reuse it many times for the different recursive proof tests. *)\n let index, public_input, proof = S.example srs\n\n (* Obtain verifier key from prover index and convert backend proof to\n snarky proof *)\n let vk = Kimchi_bindings.Protocol.VerifierIndex.Fp.create index\n\n let proof = Backend.Tick.Proof.of_backend proof\n\n let test_feature_flags_configs =\n generate_test_feature_flag_configs S.actual_feature_flags\n\n let runtest feature_flags =\n run_recursive_proof_test S.actual_feature_flags feature_flags\n public_input vk proof\n\n let%test \"true -> yes\" = runtest test_feature_flags_configs.true_is_yes\n\n let%test \"true -> maybe\" =\n runtest test_feature_flags_configs.true_is_maybe\n\n let%test \"all maybes\" = runtest test_feature_flags_configs.all_maybes\n end\n\n (* Small combinators to lift gate example signatures to the expected\n signatures for the tests. This amounts to generating the list of public\n inputs from either no public inputs, a single one or a pair of inputs\n returned by the gate example. *)\n\n let no_public_input gate_example srs =\n let index, proof = gate_example srs in\n (index, [], proof)\n\n let public_input_1 gate_example srs =\n let index, public_input, proof = gate_example srs in\n (index, [ public_input ], proof)\n\n let public_input_2 gate_example srs =\n let index, (public_input1, public_input2), proof = gate_example srs in\n (index, [ public_input1; public_input2 ], proof)\n\n let%test_module \"lookup\" =\n ( module Make (struct\n let example =\n public_input_1 (fun srs ->\n Kimchi_bindings.Protocol.Proof.Fp.example_with_lookup srs )\n\n let actual_feature_flags =\n { Plonk_types.Features.none_bool with\n lookup = true\n ; runtime_tables = true\n }\n end) )\n\n (*\n let%test_module \"foreign field multiplication\" =\n ( module Make (struct\n let example =\n no_public_input\n Kimchi_bindings.Protocol.Proof.Fp.example_with_foreign_field_mul\n\n let actual_feature_flags =\n { Plonk_types.Features.none_bool with\n range_check0 = true\n ; range_check1 = true\n ; foreign_field_add = true\n ; foreign_field_mul = true\n }\n end) )\n *)\n\n let%test_module \"range check\" =\n ( module Make (struct\n let example =\n no_public_input\n Kimchi_bindings.Protocol.Proof.Fp.example_with_range_check\n\n let actual_feature_flags =\n { Plonk_types.Features.none_bool with\n range_check0 = true\n ; range_check1 = true\n }\n end) )\n\n let%test_module \"range check 64 bits\" =\n ( module Make (struct\n let example =\n no_public_input\n Kimchi_bindings.Protocol.Proof.Fp.example_with_range_check0\n\n let actual_feature_flags =\n { Plonk_types.Features.none_bool with range_check0 = true }\n end) )\n\n let%test_module \"xor\" =\n ( module Make (struct\n let example =\n public_input_2 Kimchi_bindings.Protocol.Proof.Fp.example_with_xor\n\n let actual_feature_flags =\n { Plonk_types.Features.none_bool with xor = true }\n end) )\n\n let%test_module \"rot\" =\n ( module Make (struct\n let example =\n public_input_2 Kimchi_bindings.Protocol.Proof.Fp.example_with_rot\n\n let actual_feature_flags =\n { Plonk_types.Features.none_bool with\n range_check0 = true\n ; rot = true\n }\n end) )\n\n let%test_module \"foreign field addition\" =\n ( module Make (struct\n let example =\n public_input_1 Kimchi_bindings.Protocol.Proof.Fp.example_with_ffadd\n\n let actual_feature_flags =\n { Plonk_types.Features.none_bool with\n range_check0 = true\n ; range_check1 = true\n ; foreign_field_add = true\n }\n end) )\n end )\n\nmodule Step_acc = Tock.Inner_curve.Affine\n\n(* The prover for wrapping a proof *)\nlet wrap\n (type actual_proofs_verified max_proofs_verified\n max_local_max_proofs_verifieds )\n ~(max_proofs_verified : max_proofs_verified Nat.t)\n (module Max_local_max_proof_verifieds : Hlist.Maxes.S\n with type ns = max_local_max_proofs_verifieds\n and type length = max_proofs_verified )\n (( module\n Req ) :\n (max_proofs_verified, max_local_max_proofs_verifieds) Requests.Wrap.t )\n ~dlog_plonk_index wrap_main ~(typ : _ Impls.Step.Typ.t) ~step_vk\n ~actual_wrap_domains ~step_plonk_indices:_ ~feature_flags\n ~actual_feature_flags ?tweak_statement pk\n ({ statement = prev_statement; prev_evals; proof; index = which_index } :\n ( _\n , _\n , (_, actual_proofs_verified) Vector.t\n , (_, actual_proofs_verified) Vector.t\n , max_local_max_proofs_verifieds\n H1.T(P.Base.Messages_for_next_proof_over_same_field.Wrap).t\n , ( (Tock.Field.t, Tock.Field.t array) Plonk_types.All_evals.t\n , max_proofs_verified )\n Vector.t )\n P.Base.Step.t ) =\n let logger = Internal_tracing_context_logger.get () in\n [%log internal] \"Pickles_wrap_proof\" ;\n let messages_for_next_wrap_proof =\n let module M =\n H1.Map\n (P.Base.Messages_for_next_proof_over_same_field.Wrap)\n (P.Base.Messages_for_next_proof_over_same_field.Wrap.Prepared)\n (struct\n let f = P.Base.Messages_for_next_proof_over_same_field.Wrap.prepare\n end)\n in\n M.f prev_statement.messages_for_next_wrap_proof\n in\n let prev_statement_with_hashes : _ Types.Step.Statement.t =\n { proof_state =\n { prev_statement.proof_state with\n messages_for_next_step_proof =\n (let to_field_elements =\n let (Typ typ) = typ in\n fun x -> fst (typ.value_to_fields x)\n in\n (* TODO: Careful here... the length of\n old_buletproof_challenges inside the messages_for_next_step_proof\n might not be correct *)\n Common.hash_messages_for_next_step_proof\n ~app_state:to_field_elements\n (P.Base.Messages_for_next_proof_over_same_field.Step.prepare\n ~dlog_plonk_index\n prev_statement.proof_state.messages_for_next_step_proof ) )\n }\n ; messages_for_next_wrap_proof =\n (let module M =\n H1.Map\n (P.Base.Messages_for_next_proof_over_same_field.Wrap.Prepared)\n (E01 (Digest.Constant))\n (struct\n let f (type n)\n (m :\n n\n P.Base.Messages_for_next_proof_over_same_field.Wrap\n .Prepared\n .t ) =\n Wrap_hack.hash_messages_for_next_wrap_proof\n (Vector.length m.old_bulletproof_challenges)\n m\n end)\n in\n let module V = H1.To_vector (Digest.Constant) in\n V.f Max_local_max_proof_verifieds.length\n (M.f messages_for_next_wrap_proof) )\n }\n in\n let handler (Snarky_backendless.Request.With { request; respond }) =\n let open Req in\n let k x = respond (Provide x) in\n match request with\n | Evals ->\n k prev_evals\n | Step_accs ->\n let module M =\n H1.Map\n (P.Base.Messages_for_next_proof_over_same_field.Wrap.Prepared)\n (E01 (Step_acc))\n (struct\n let f :\n type a.\n a\n P.Base.Messages_for_next_proof_over_same_field.Wrap.Prepared\n .t\n -> Step_acc.t =\n fun t -> t.challenge_polynomial_commitment\n end)\n in\n let module V = H1.To_vector (Step_acc) in\n k\n (V.f Max_local_max_proof_verifieds.length\n (M.f messages_for_next_wrap_proof) )\n | Old_bulletproof_challenges ->\n let module M =\n H1.Map\n (P.Base.Messages_for_next_proof_over_same_field.Wrap.Prepared)\n (Challenges_vector.Constant)\n (struct\n let f\n (t :\n _\n P.Base.Messages_for_next_proof_over_same_field.Wrap.Prepared\n .t ) =\n t.old_bulletproof_challenges\n end)\n in\n k (M.f messages_for_next_wrap_proof)\n | Messages ->\n k proof.messages\n | Openings_proof ->\n k proof.openings.proof\n | Proof_state ->\n k prev_statement_with_hashes.proof_state\n | Which_branch ->\n k which_index\n | Wrap_domain_indices ->\n let all_possible_domains = Wrap_verifier.all_possible_domains () in\n let wrap_domain_indices =\n Vector.map actual_wrap_domains ~f:(fun domain_size ->\n let domain_index =\n Vector.foldi ~init:0 all_possible_domains\n ~f:(fun j acc (Pow_2_roots_of_unity domain) ->\n if Int.equal domain domain_size then j else acc )\n in\n Tock.Field.of_int domain_index )\n in\n k\n (Vector.extend_front_exn wrap_domain_indices max_proofs_verified\n Tock.Field.one )\n | _ ->\n Snarky_backendless.Request.unhandled\n in\n\n let public_input =\n tick_public_input_of_statement ~max_proofs_verified\n prev_statement_with_hashes ~feature_flags\n in\n let prev_challenges =\n Vector.map ~f:Ipa.Step.compute_challenges\n prev_statement.proof_state.messages_for_next_step_proof\n .old_bulletproof_challenges\n in\n let actual_proofs_verified = Vector.length prev_challenges in\n let lte =\n Nat.lte_exn actual_proofs_verified\n (Length.to_nat Max_local_max_proof_verifieds.length)\n in\n let sgs =\n let module M =\n H1.Map\n (P.Base.Messages_for_next_proof_over_same_field.Wrap.Prepared)\n (E01 (Tick.Curve.Affine))\n (struct\n let f :\n type n.\n n P.Base.Messages_for_next_proof_over_same_field.Wrap.Prepared.t\n -> _ =\n fun t -> t.challenge_polynomial_commitment\n end)\n in\n let module V = H1.To_vector (Tick.Curve.Affine) in\n Vector.trim_front\n (V.f Max_local_max_proof_verifieds.length\n (M.f messages_for_next_wrap_proof) )\n lte\n in\n [%log internal] \"Wrap_compute_deferred_values\" ;\n let { deferred_values; x_hat_evals; sponge_digest_before_evaluations } =\n deferred_values ~sgs ~prev_challenges ~step_vk ~public_input ~proof\n ~actual_proofs_verified ~actual_feature_flags\n in\n [%log internal] \"Wrap_compute_deferred_values_done\" ;\n let next_statement : _ Types.Wrap.Statement.In_circuit.t =\n let messages_for_next_wrap_proof :\n _ P.Base.Messages_for_next_proof_over_same_field.Wrap.t =\n { challenge_polynomial_commitment =\n proof.openings.proof.challenge_polynomial_commitment\n ; old_bulletproof_challenges =\n Vector.map prev_statement.proof_state.unfinalized_proofs ~f:(fun t ->\n t.deferred_values.bulletproof_challenges )\n }\n in\n { proof_state =\n { deferred_values\n ; sponge_digest_before_evaluations =\n Digest.Constant.of_tick_field sponge_digest_before_evaluations\n ; messages_for_next_wrap_proof\n }\n ; messages_for_next_step_proof =\n prev_statement.proof_state.messages_for_next_step_proof\n }\n in\n let next_statement =\n match tweak_statement with\n | None ->\n next_statement\n | Some f ->\n (* For adversarial tests, we want to simulate an adversary creating a\n proof that doesn't match the pickles protocol.\n In order to do this, we pass a function [tweak_statement] that takes\n the valid statement that we computed above and 'tweaks' it so that\n the statement is no longer valid. This modified statement is then\n propagated as part of any later recursion.\n *)\n f next_statement\n in\n let messages_for_next_wrap_proof_prepared =\n P.Base.Messages_for_next_proof_over_same_field.Wrap.prepare\n next_statement.proof_state.messages_for_next_wrap_proof\n in\n let next_accumulator =\n Vector.map2\n (Vector.extend_front_exn\n prev_statement.proof_state.messages_for_next_step_proof\n .challenge_polynomial_commitments max_proofs_verified\n (Lazy.force Dummy.Ipa.Wrap.sg) )\n messages_for_next_wrap_proof_prepared.old_bulletproof_challenges\n ~f:(fun sg chals ->\n { Tock.Proof.Challenge_polynomial.commitment = sg\n ; challenges = Vector.to_array chals\n } )\n |> Wrap_hack.pad_accumulator\n in\n let%map.Promise next_proof =\n let (T (input, conv, _conv_inv)) = Impls.Wrap.input () in\n Common.time \"wrap proof\" (fun () ->\n [%log internal] \"Wrap_generate_witness_conv\" ;\n Impls.Wrap.generate_witness_conv\n ~f:(fun { Impls.Wrap.Proof_inputs.auxiliary_inputs; public_inputs } () ->\n [%log internal] \"Backend_tock_proof_create_async\" ;\n let%map.Promise proof =\n Backend.Tock.Proof.create_async ~primary:public_inputs\n ~auxiliary:auxiliary_inputs pk ~message:next_accumulator\n in\n [%log internal] \"Backend_tock_proof_create_async_done\" ;\n proof )\n ~input_typ:input\n ~return_typ:(Snarky_backendless.Typ.unit ())\n (fun x () : unit ->\n Impls.Wrap.handle (fun () : unit -> wrap_main (conv x)) handler )\n { messages_for_next_step_proof =\n prev_statement_with_hashes.proof_state\n .messages_for_next_step_proof\n ; proof_state =\n { next_statement.proof_state with\n messages_for_next_wrap_proof =\n Wrap_hack.hash_messages_for_next_wrap_proof\n max_proofs_verified messages_for_next_wrap_proof_prepared\n ; deferred_values =\n { next_statement.proof_state.deferred_values with\n plonk =\n { next_statement.proof_state.deferred_values.plonk with\n lookup =\n (* TODO: This assumes wrap circuits do not use lookup *)\n None\n }\n }\n }\n } )\n in\n [%log internal] \"Pickles_wrap_proof_done\" ;\n ( { proof = Wrap_wire_proof.of_kimchi_proof next_proof\n ; statement =\n Types.Wrap.Statement.to_minimal next_statement\n ~to_option:Opt.to_option_unsafe\n ; prev_evals =\n { Plonk_types.All_evals.evals =\n { public_input = x_hat_evals; evals = proof.openings.evals }\n ; ft_eval1 = proof.openings.ft_eval1\n }\n }\n : _ P.Base.Wrap.t )\n","module SC = Scalar_challenge\nopen Core_kernel\nopen Pickles_types\nopen Common\nopen Import\nopen Backend\n\n(* TODO: Just stick this in plonk_checks.ml *)\nmodule Plonk_checks = struct\n include Plonk_checks\n module Type1 =\n Plonk_checks.Make (Shifted_value.Type1) (Plonk_checks.Scalars.Tick)\nend\n\nlet expand_deferred (type n most_recent_width)\n ~(evals :\n ( Backend.Tick.Field.t\n , Backend.Tick.Field.t array )\n Pickles_types.Plonk_types.All_evals.t )\n ~(old_bulletproof_challenges :\n ( Challenge.Constant.t Scalar_challenge.Stable.Latest.t\n Bulletproof_challenge.t\n Step_bp_vec.t\n , most_recent_width )\n Pickles_types.Vector.t )\n ~(proof_state :\n ( Challenge.Constant.t\n , Challenge.Constant.t Scalar_challenge.t\n , Backend.Tick.Field.t Pickles_types.Shifted_value.Type1.t\n , bool\n , n Pickles__.Proof.Base.Messages_for_next_proof_over_same_field.Wrap.t\n , Digest.Constant.t\n , Challenge.Constant.t Scalar_challenge.t Bulletproof_challenge.t\n Step_bp_vec.t\n , Branch_data.t )\n Composition_types.Wrap.Proof_state.Minimal.Stable.V1.t ) :\n _ Types.Wrap.Proof_state.Deferred_values.t =\n let module Tick_field = Backend.Tick.Field in\n let tick_field : _ Plonk_checks.field = (module Tick_field) in\n Timer.start __LOC__ ;\n let open Types.Wrap.Proof_state in\n let sc = SC.to_field_constant tick_field ~endo:Endo.Wrap_inner_curve.scalar in\n Timer.clock __LOC__ ;\n let plonk0 = proof_state.deferred_values.plonk in\n let { Deferred_values.Minimal.branch_data; bulletproof_challenges; _ } =\n Deferred_values.Minimal.map_challenges ~f:Challenge.Constant.to_tick_field\n ~scalar:sc proof_state.deferred_values\n in\n let zeta = sc plonk0.zeta in\n let alpha = sc plonk0.alpha in\n let step_domain = Branch_data.domain branch_data in\n let w =\n Tick.Field.domain_generator ~log2_size:(Domain.log2_size step_domain)\n in\n let zetaw = Tick.Field.mul zeta w in\n let tick_plonk_minimal :\n _ Composition_types.Wrap.Proof_state.Deferred_values.Plonk.Minimal.t =\n let chal = Challenge.Constant.to_tick_field in\n { zeta\n ; alpha\n ; beta = chal plonk0.beta\n ; gamma = chal plonk0.gamma\n ; joint_combiner = Option.map ~f:sc plonk0.joint_combiner\n ; feature_flags = plonk0.feature_flags\n }\n in\n let tick_combined_evals =\n Plonk_checks.evals_of_split_evals\n (module Tick.Field)\n evals.evals.evals ~rounds:(Nat.to_int Tick.Rounds.n) ~zeta ~zetaw\n |> Plonk_types.Evals.to_in_circuit\n in\n let tick_domain =\n Plonk_checks.domain\n (module Tick.Field)\n step_domain ~shifts:Common.tick_shifts\n ~domain_generator:Backend.Tick.Field.domain_generator\n in\n let tick_env =\n let module Env_bool = struct\n type t = bool\n\n let true_ = true\n\n let false_ = false\n\n let ( &&& ) = ( && )\n\n let ( ||| ) = ( || )\n\n let any = List.exists ~f:Fn.id\n end in\n let module Env_field = struct\n include Tick.Field\n\n type bool = Env_bool.t\n\n let if_ (b : bool) ~then_ ~else_ = if b then then_ () else else_ ()\n end in\n Plonk_checks.scalars_env\n (module Env_bool)\n (module Env_field)\n ~endo:Endo.Step_inner_curve.base ~mds:Tick_field_sponge.params.mds\n ~srs_length_log2:Common.Max_degree.step_log2\n ~field_of_hex:(fun s ->\n Kimchi_pasta.Pasta.Bigint256.of_hex_string s\n |> Kimchi_pasta.Pasta.Fp.of_bigint )\n ~domain:tick_domain tick_plonk_minimal tick_combined_evals\n in\n let plonk =\n let p =\n let module Field = struct\n include Tick.Field\n end in\n Plonk_checks.Type1.derive_plonk\n (module Field)\n ~shift:Shifts.tick1 ~env:tick_env tick_plonk_minimal tick_combined_evals\n in\n { p with\n zeta = plonk0.zeta\n ; alpha = plonk0.alpha\n ; beta = plonk0.beta\n ; gamma = plonk0.gamma\n ; lookup =\n Option.map (Plonk_types.Opt.to_option_unsafe p.lookup) ~f:(fun _ ->\n { Types.Wrap.Proof_state.Deferred_values.Plonk.In_circuit.Lookup\n .joint_combiner = Option.value_exn plonk0.joint_combiner\n } )\n }\n in\n Timer.clock __LOC__ ;\n let absorb, squeeze =\n let open Tick_field_sponge.Bits in\n let sponge =\n let s = create Tick_field_sponge.params in\n absorb s\n (Digest.Constant.to_tick_field\n proof_state.sponge_digest_before_evaluations ) ;\n s\n in\n let squeeze () =\n let underlying =\n Challenge.Constant.of_bits\n (squeeze sponge ~length:Challenge.Constant.length)\n in\n Scalar_challenge.create underlying\n in\n (absorb sponge, squeeze)\n in\n let old_bulletproof_challenges =\n Vector.map ~f:Ipa.Step.compute_challenges old_bulletproof_challenges\n in\n (let challenges_digest =\n let open Tick_field_sponge.Field in\n let sponge = create Tick_field_sponge.params in\n Vector.iter old_bulletproof_challenges ~f:(Vector.iter ~f:(absorb sponge)) ;\n squeeze sponge\n in\n absorb challenges_digest ;\n absorb evals.ft_eval1 ;\n let xs = Plonk_types.Evals.to_absorption_sequence evals.evals.evals in\n let x1, x2 = evals.evals.public_input in\n absorb x1 ;\n absorb x2 ;\n List.iter xs ~f:(fun (x1, x2) ->\n Array.iter ~f:absorb x1 ; Array.iter ~f:absorb x2 ) ) ;\n let xi_chal = squeeze () in\n let xi = sc xi_chal in\n let r_chal = squeeze () in\n let r = sc r_chal in\n Timer.clock __LOC__ ;\n (* TODO: The deferred values \"bulletproof_challenges\" should get routed\n into a \"batch dlog Tick acc verifier\" *)\n let actual_proofs_verified = Vector.length old_bulletproof_challenges in\n Timer.clock __LOC__ ;\n let combined_inner_product_actual =\n Wrap.combined_inner_product ~env:tick_env ~plonk:tick_plonk_minimal\n ~domain:tick_domain ~ft_eval1:evals.ft_eval1\n ~actual_proofs_verified:(Nat.Add.create actual_proofs_verified)\n evals.evals ~old_bulletproof_challenges ~r ~xi ~zeta ~zetaw\n in\n Timer.clock __LOC__ ;\n let bulletproof_challenges =\n Ipa.Step.compute_challenges bulletproof_challenges\n in\n Timer.clock __LOC__ ;\n let b_actual =\n let challenge_poly =\n unstage\n (Wrap.challenge_polynomial (Vector.to_array bulletproof_challenges))\n in\n Tick.Field.(challenge_poly zeta + (r * challenge_poly zetaw))\n in\n let to_shifted =\n Shifted_value.Type1.of_field (module Tick.Field) ~shift:Shifts.tick1\n in\n { xi = xi_chal\n ; plonk\n ; combined_inner_product = to_shifted combined_inner_product_actual\n ; branch_data\n ; bulletproof_challenges\n ; b = to_shifted b_actual\n }\n","module SC = Scalar_challenge\nopen Pickles_types\nopen Common\nopen Import\n\nmodule Instance = struct\n type t =\n | T :\n (module Nat.Intf with type n = 'n)\n * (module Intf.Statement_value with type t = 'a)\n * Verification_key.t\n * 'a\n * ('n, 'n) Proof.t\n -> t\nend\n\nlet verify_heterogenous (ts : Instance.t list) =\n let module Tick_field = Backend.Tick.Field in\n let logger = Internal_tracing_context_logger.get () in\n [%log internal] \"Verify_heterogenous\"\n ~metadata:[ (\"count\", `Int (List.length ts)) ] ;\n let tick_field : _ Plonk_checks.field = (module Tick_field) in\n let check, result =\n let r = ref [] in\n let result () =\n match !r with\n | [] ->\n Ok ()\n | _ ->\n Error\n ( Error.tag ~tag:\"Pickles.verify\"\n @@ Error.of_list\n @@ List.map !r ~f:(fun lab -> Error.of_string (Lazy.force lab)) )\n in\n ((fun (lab, b) -> if not b then r := lab :: !r), result)\n in\n [%log internal] \"Compute_plonks_and_chals\" ;\n let _computed_bp_chals, deferred_values =\n List.map ts\n ~f:(fun\n (T\n ( _max_proofs_verified\n , _statement\n , key\n , _app_state\n , T\n { statement =\n { proof_state\n ; messages_for_next_step_proof =\n { old_bulletproof_challenges; _ }\n }\n ; prev_evals = evals\n ; proof = _\n } ) )\n ->\n Timer.start __LOC__ ;\n let non_chunking =\n let exception Is_chunked in\n match\n Pickles_types.Plonk_types.Evals.map evals.evals.evals\n ~f:(fun (x, y) ->\n if Array.length x > 1 || Array.length y > 1 then\n raise Is_chunked )\n with\n | exception Is_chunked ->\n false\n | _unit_evals ->\n (* we do not care about _unit_evals, if we reached this point, we\n know all evals have length 1 for they cannot have length 0 *)\n true\n in\n check (lazy \"only uses single chunks\", non_chunking) ;\n check\n ( lazy \"feature flags are consistent with evaluations\"\n , Pickles_types.Plonk_types.Evals.validate_feature_flags\n ~feature_flags:proof_state.deferred_values.plonk.feature_flags\n evals.evals.evals ) ;\n Timer.start __LOC__ ;\n let open Types.Wrap.Proof_state in\n let step_domain =\n Branch_data.domain proof_state.deferred_values.branch_data\n in\n check\n ( lazy \"domain size is small enough\"\n , Domain.log2_size step_domain <= Nat.to_int Backend.Tick.Rounds.n ) ;\n let sc =\n SC.to_field_constant tick_field ~endo:Endo.Wrap_inner_curve.scalar\n in\n Timer.clock __LOC__ ;\n let { Deferred_values.Minimal.plonk = _\n ; branch_data = _\n ; bulletproof_challenges\n } =\n Deferred_values.Minimal.map_challenges\n ~f:Challenge.Constant.to_tick_field ~scalar:sc\n proof_state.deferred_values\n in\n Timer.clock __LOC__ ;\n let deferred_values =\n Wrap_deferred_values.expand_deferred ~evals\n ~old_bulletproof_challenges ~proof_state\n in\n Timer.clock __LOC__ ;\n let deferred_values = { deferred_values with bulletproof_challenges } in\n let () =\n let [ Pow_2_roots_of_unity greatest_wrap_domain\n ; _\n ; Pow_2_roots_of_unity least_wrap_domain\n ] =\n Wrap_verifier.all_possible_domains ()\n in\n let actual_wrap_domain = key.index.domain.log_size_of_group in\n check\n ( lazy\n (sprintf !\"wrap_domain: %i > %i\" actual_wrap_domain\n least_wrap_domain )\n , Int.( <= ) actual_wrap_domain least_wrap_domain ) ;\n check\n ( lazy\n (sprintf !\"wrap_domain: %i < %i\" actual_wrap_domain\n greatest_wrap_domain )\n , Int.( >= ) actual_wrap_domain greatest_wrap_domain )\n in\n (bulletproof_challenges, deferred_values) )\n |> List.unzip\n in\n [%log internal] \"Compute_plonks_and_chals_done\" ;\n let open Backend.Tock.Proof in\n let open Promise.Let_syntax in\n [%log internal] \"Accumulator_check\" ;\n let%bind accumulator_check =\n Ipa.Step.accumulator_check\n (List.map ts ~f:(fun (T (_, _, _, _, T t)) ->\n ( t.statement.proof_state.messages_for_next_wrap_proof\n .challenge_polynomial_commitment\n , Ipa.Step.compute_challenges\n t.statement.proof_state.deferred_values.bulletproof_challenges ) )\n )\n in\n [%log internal] \"Accumulator_check_done\" ;\n Common.time \"batch_step_dlog_check\" (fun () ->\n check (lazy \"batch_step_dlog_check\", accumulator_check) ) ;\n [%log internal] \"Compute_batch_verify_inputs\" ;\n let batch_verify_inputs =\n List.map2_exn ts deferred_values\n ~f:(fun\n (T\n ( (module Max_proofs_verified)\n , (module A_value)\n , key\n , app_state\n , T t ) )\n deferred_values\n ->\n let prepared_statement : _ Types.Wrap.Statement.In_circuit.t =\n { messages_for_next_step_proof =\n Common.hash_messages_for_next_step_proof\n ~app_state:A_value.to_field_elements\n (Reduced_messages_for_next_proof_over_same_field.Step.prepare\n ~dlog_plonk_index:key.commitments\n { t.statement.messages_for_next_step_proof with app_state } )\n ; proof_state =\n { deferred_values =\n { plonk = deferred_values.plonk\n ; combined_inner_product =\n deferred_values.combined_inner_product\n ; b = deferred_values.b\n ; xi = deferred_values.xi\n ; bulletproof_challenges =\n deferred_values.bulletproof_challenges\n ; branch_data = deferred_values.branch_data\n }\n ; sponge_digest_before_evaluations =\n t.statement.proof_state.sponge_digest_before_evaluations\n ; messages_for_next_wrap_proof =\n Wrap_hack.hash_messages_for_next_wrap_proof\n Max_proofs_verified.n\n (Reduced_messages_for_next_proof_over_same_field.Wrap\n .prepare\n t.statement.proof_state.messages_for_next_wrap_proof )\n }\n }\n in\n let input =\n tock_unpadded_public_input_of_statement prepared_statement\n in\n let message =\n Wrap_hack.pad_accumulator\n (Vector.map2\n ~f:(fun g cs ->\n { Challenge_polynomial.challenges =\n Vector.to_array (Ipa.Wrap.compute_challenges cs)\n ; commitment = g\n } )\n (Vector.extend_front_exn\n t.statement.messages_for_next_step_proof\n .challenge_polynomial_commitments Max_proofs_verified.n\n (Lazy.force Dummy.Ipa.Wrap.sg) )\n t.statement.proof_state.messages_for_next_wrap_proof\n .old_bulletproof_challenges )\n in\n (key.index, Wrap_wire_proof.to_kimchi_proof t.proof, input, Some message) )\n in\n [%log internal] \"Compute_batch_verify_inputs_done\" ;\n [%log internal] \"Dlog_check_batch_verify\" ;\n let%map dlog_check = batch_verify batch_verify_inputs in\n [%log internal] \"Dlog_check_batch_verify_done\" ;\n Common.time \"dlog_check\" (fun () -> check (lazy \"dlog_check\", dlog_check)) ;\n result ()\n\nlet verify (type a n) (max_proofs_verified : (module Nat.Intf with type n = n))\n (a_value : (module Intf.Statement_value with type t = a))\n (key : Verification_key.t) (ts : (a * (n, n) Proof.t) list) =\n verify_heterogenous\n (List.map ts ~f:(fun (x, p) ->\n Instance.T (max_proofs_verified, a_value, key, x, p) ) )\n","open Pickles_types\nopen Hlist\nopen Import\nopen Impls.Step\nopen Step_verifier\nmodule B = Inductive_rule.B\n\n(* Converts from the one hot vector representation of a number\n 0 <= i < n\n\n 0 1 ... i-1 i i+1 n-1\n [ 0; 0; ... 0; 1; 0; ...; 0 ]\n\n to the numeric representation i. *)\n\nlet _one_hot_vector_to_num (type n) (v : n Per_proof_witness.One_hot_vector.t) :\n Field.t =\n let n = Vector.length (v :> (Boolean.var, n) Vector.t) in\n Pseudo.choose (v, Vector.init n ~f:Field.of_int) ~f:Fn.id\n\nlet verify_one ~srs\n ({ app_state\n ; wrap_proof\n ; proof_state\n ; prev_proof_evals\n ; prev_challenges\n ; prev_challenge_polynomial_commitments\n } :\n _ Per_proof_witness.t ) (d : _ Types_map.For_step.t)\n (messages_for_next_wrap_proof : Digest.t) (unfinalized : Unfinalized.t)\n (should_verify : B.t) : _ Vector.t * B.t =\n Boolean.Assert.( = ) unfinalized.should_finalize should_verify ;\n let deferred_values = proof_state.deferred_values in\n let finalized, chals =\n with_label __LOC__ (fun () ->\n let sponge_digest = proof_state.sponge_digest_before_evaluations in\n let sponge =\n let open Step_main_inputs in\n let sponge = Sponge.create sponge_params in\n Sponge.absorb sponge (`Field sponge_digest) ;\n sponge\n in\n (* TODO: Refactor args into an \"unfinalized proof\" struct *)\n finalize_other_proof d.max_proofs_verified ~step_domains:d.step_domains\n ~feature_flags:d.feature_flags ~sponge ~prev_challenges\n deferred_values prev_proof_evals )\n in\n let branch_data = deferred_values.branch_data in\n let sponge_after_index, hash_messages_for_next_step_proof =\n let to_field_elements =\n let (Typ typ) = d.public_input in\n fun x -> fst (typ.var_to_fields x)\n in\n let sponge_after_index, hash_messages_for_next_step_proof =\n (* TODO: Don't rehash when it's not necessary *)\n hash_messages_for_next_step_proof_opt ~index:d.wrap_key to_field_elements\n in\n (sponge_after_index, unstage hash_messages_for_next_step_proof)\n in\n let statement =\n let prev_messages_for_next_step_proof =\n with_label __LOC__ (fun () ->\n hash_messages_for_next_step_proof ~widths:d.proofs_verifieds\n ~max_width:(Nat.Add.n d.max_proofs_verified)\n ~proofs_verified_mask:\n (Vector.trim_front branch_data.proofs_verified_mask\n (Nat.lte_exn\n (Vector.length prev_challenge_polynomial_commitments)\n Nat.N2.n ) )\n (* Use opt sponge for cutting off the bulletproof challenges early *)\n { app_state\n ; dlog_plonk_index = d.wrap_key\n ; challenge_polynomial_commitments =\n prev_challenge_polynomial_commitments\n ; old_bulletproof_challenges = prev_challenges\n } )\n in\n { Types.Wrap.Statement.messages_for_next_step_proof =\n prev_messages_for_next_step_proof\n ; proof_state = { proof_state with messages_for_next_wrap_proof }\n }\n in\n let verified =\n with_label __LOC__ (fun () ->\n verify ~srs ~feature_flags:d.feature_flags\n ~lookup_parameters:\n { use = Plonk_checks.lookup_tables_used d.feature_flags\n ; zero =\n { var =\n { challenge = Field.zero\n ; scalar = Shifted_value Field.zero\n }\n ; value =\n { challenge = Limb_vector.Challenge.Constant.zero\n ; scalar =\n Shifted_value.Type1.Shifted_value Field.Constant.zero\n }\n }\n }\n ~proofs_verified:d.max_proofs_verified ~wrap_domain:d.wrap_domain\n ~is_base_case:(Boolean.not should_verify)\n ~sponge_after_index ~sg_old:prev_challenge_polynomial_commitments\n ~proof:wrap_proof ~wrap_verification_key:d.wrap_key statement\n unfinalized )\n in\n if debug then\n as_prover\n As_prover.(\n fun () ->\n let finalized = read Boolean.typ finalized in\n let verified = read Boolean.typ verified in\n let should_verify = read Boolean.typ should_verify in\n printf \"finalized: %b\\n%!\" finalized ;\n printf \"verified: %b\\n%!\" verified ;\n printf \"should_verify: %b\\n\\n%!\" should_verify) ;\n (chals, Boolean.(verified &&& finalized ||| not should_verify))\n\n(* The SNARK function corresponding to the input inductive rule. *)\nlet step_main :\n type proofs_verified self_branches prev_vars prev_values var value a_var a_value ret_var ret_value auxiliary_var auxiliary_value max_proofs_verified local_branches local_signature.\n (module Requests.Step.S\n with type local_signature = local_signature\n and type local_branches = local_branches\n and type statement = a_value\n and type prev_values = prev_values\n and type max_proofs_verified = max_proofs_verified\n and type proofs_verified = proofs_verified\n and type return_value = ret_value\n and type auxiliary_value = auxiliary_value )\n -> (module Nat.Add.Intf with type n = max_proofs_verified)\n -> self_branches:self_branches Nat.t\n (* How many branches does this proof system have *)\n -> local_signature:local_signature H1.T(Nat).t\n (* The specification, for each proof that this step circuit verifies, of the maximum width used\n by that proof system. *)\n -> local_signature_length:(local_signature, proofs_verified) Hlist.Length.t\n -> local_branches:\n (* For each inner proof of type T , the number of branches that type T has. *)\n local_branches H1.T(Nat).t\n -> local_branches_length:(local_branches, proofs_verified) Hlist.Length.t\n -> proofs_verified:(prev_vars, proofs_verified) Hlist.Length.t\n -> lte:(proofs_verified, max_proofs_verified) Nat.Lte.t\n -> public_input:\n ( var\n , value\n , a_var\n , a_value\n , ret_var\n , ret_value )\n Inductive_rule.public_input\n -> auxiliary_typ:(auxiliary_var, auxiliary_value) Typ.t\n -> basic:\n ( var\n , value\n , max_proofs_verified\n , self_branches )\n Types_map.Compiled.basic\n -> self:(var, value, max_proofs_verified, self_branches) Tag.t\n -> ( prev_vars\n , prev_values\n , local_signature\n , local_branches\n , a_var\n , a_value\n , ret_var\n , ret_value\n , auxiliary_var\n , auxiliary_value )\n Inductive_rule.t\n -> ( unit\n -> ( (Unfinalized.t, max_proofs_verified) Vector.t\n , Field.t\n , (Field.t, max_proofs_verified) Vector.t )\n Types.Step.Statement.t )\n Staged.t =\n fun (module Req) max_proofs_verified ~self_branches ~local_signature\n ~local_signature_length ~local_branches ~local_branches_length\n ~proofs_verified ~lte ~public_input ~auxiliary_typ ~basic ~self rule ->\n let module Typ_with_max_proofs_verified = struct\n type ('var, 'value, 'local_max_proofs_verified, 'local_branches) t =\n ( ( 'var\n , 'local_max_proofs_verified\n , 'local_branches )\n Per_proof_witness.No_app_state.t\n , ( 'value\n , 'local_max_proofs_verified\n , 'local_branches )\n Per_proof_witness.Constant.No_app_state.t )\n Typ.t\n end in\n let feature_flags (d : _ Tag.t) =\n if Type_equal.Id.same self.id d.id then basic.feature_flags\n else Types_map.feature_flags d\n in\n let feature_flags =\n let rec go :\n type pvars pvals ns1 ns2 br.\n (pvars, pvals, ns1, ns2) H4.T(Tag).t\n -> (pvars, br) Length.t\n -> (Plonk_types.Opt.Flag.t Plonk_types.Features.t, br) Vector.t =\n fun ds ld ->\n match[@warning \"-4\"] (ds, ld) with\n | [], Z ->\n []\n | d :: ds, S ld ->\n feature_flags d :: go ds ld\n | [], _ ->\n .\n | _ :: _, _ ->\n .\n in\n go rule.prevs proofs_verified\n in\n let prev_proof_typs =\n let rec join :\n type pvars pvals ns1 ns2 br.\n (pvars, pvals, ns1, ns2) H4.T(Tag).t\n -> ns1 H1.T(Nat).t\n -> ns2 H1.T(Nat).t\n -> (pvars, br) Length.t\n -> (ns1, br) Length.t\n -> (ns2, br) Length.t\n -> (Plonk_types.Opt.Flag.t Plonk_types.Features.t, br) Vector.t\n -> (pvars, pvals, ns1, ns2) H4.T(Typ_with_max_proofs_verified).t =\n fun ds ns1 ns2 ld ln1 ln2 feature_flagss ->\n match[@warning \"-4\"] (ds, ns1, ns2, ld, ln1, ln2, feature_flagss) with\n | [], [], [], Z, Z, Z, [] ->\n []\n | ( _d :: ds\n , n1 :: ns1\n , _n2 :: ns2\n , S ld\n , S ln1\n , S ln2\n , feature_flags :: feature_flagss ) ->\n let t = Per_proof_witness.typ Typ.unit n1 ~feature_flags in\n t :: join ds ns1 ns2 ld ln1 ln2 feature_flagss\n | [], _, _, _, _, _, _ ->\n .\n | _ :: _, _, _, _, _, _, _ ->\n .\n in\n join rule.prevs local_signature local_branches proofs_verified\n local_signature_length local_branches_length feature_flags\n in\n let module Prev_typ =\n H4.Typ (Impls.Step) (Typ_with_max_proofs_verified)\n (Per_proof_witness.No_app_state)\n (Per_proof_witness.Constant.No_app_state)\n (struct\n let f = Fn.id\n end)\n in\n let (input_typ, output_typ)\n : (a_var, a_value) Typ.t * (ret_var, ret_value) Typ.t =\n match public_input with\n | Input typ ->\n (typ, Typ.unit)\n | Output typ ->\n (Typ.unit, typ)\n | Input_and_output (input_typ, output_typ) ->\n (input_typ, output_typ)\n in\n let main () : _ Types.Step.Statement.t =\n let open Impls.Step in\n let logger = Internal_tracing_context_logger.get () in\n with_label \"step_main\" (fun () ->\n let module Max_proofs_verified = ( val max_proofs_verified : Nat.Add.Intf\n with type n = max_proofs_verified\n )\n in\n let T = Max_proofs_verified.eq in\n let app_state = exists input_typ ~request:(fun () -> Req.App_state) in\n let { Inductive_rule.previous_proof_statements\n ; public_output = ret_var\n ; auxiliary_output = auxiliary_var\n } =\n (* Run the application logic of the rule on the predecessor statements *)\n with_label \"rule_main\" (fun () ->\n rule.main { public_input = app_state } )\n in\n let () =\n exists Typ.unit ~request:(fun () ->\n let ret_value = As_prover.read output_typ ret_var in\n Req.Return_value ret_value )\n in\n let () =\n exists Typ.unit ~request:(fun () ->\n let auxiliary_value =\n As_prover.read auxiliary_typ auxiliary_var\n in\n Req.Auxiliary_value auxiliary_value )\n in\n (* Compute proof parts outside of the prover before requesting values.\n *)\n exists Typ.unit ~request:(fun () ->\n let previous_proof_statements =\n let rec go :\n type prev_vars prev_values ns1 ns2.\n ( prev_vars\n , ns1 )\n H2.T(Inductive_rule.Previous_proof_statement).t\n -> (prev_vars, prev_values, ns1, ns2) H4.T(Tag).t\n -> ( prev_values\n , ns1 )\n H2.T(Inductive_rule.Previous_proof_statement.Constant).t =\n fun previous_proof_statement tags ->\n match (previous_proof_statement, tags) with\n | [], [] ->\n []\n | ( { public_input; proof; proof_must_verify } :: stmts\n , tag :: tags ) ->\n let public_input =\n (fun (type var value n m) (tag : (var, value, n, m) Tag.t)\n (var : var) : value ->\n let typ : (var, value) Typ.t =\n match Type_equal.Id.same_witness self.id tag.id with\n | Some T ->\n basic.public_input\n | None ->\n Types_map.public_input tag\n in\n As_prover.read typ var )\n tag public_input\n in\n { public_input\n ; proof = As_prover.Ref.get proof\n ; proof_must_verify =\n As_prover.read Boolean.typ proof_must_verify\n }\n :: go stmts tags\n in\n go previous_proof_statements rule.prevs\n in\n Req.Compute_prev_proof_parts previous_proof_statements ) ;\n let dlog_plonk_index =\n exists\n ~request:(fun () -> Req.Wrap_index)\n (Plonk_verification_key_evals.typ Inner_curve.typ)\n and prevs =\n exists (Prev_typ.f prev_proof_typs) ~request:(fun () ->\n Req.Proof_with_datas )\n and unfinalized_proofs_unextended =\n exists\n (Vector.typ'\n (Vector.map\n ~f:(fun _feature_flags ->\n Unfinalized.typ ~wrap_rounds:Backend.Tock.Rounds.n )\n feature_flags ) )\n ~request:(fun () -> Req.Unfinalized_proofs)\n and messages_for_next_wrap_proof =\n exists (Vector.typ Digest.typ Max_proofs_verified.n)\n ~request:(fun () -> Req.Messages_for_next_wrap_proof)\n and actual_wrap_domains =\n exists\n (Vector.typ (Typ.Internal.ref ()) (Length.to_nat proofs_verified))\n ~request:(fun () -> Req.Wrap_domain_indices)\n in\n let prevs =\n (* Inject the app-state values into the per-proof witnesses. *)\n let rec go :\n type vars ns1 ns2.\n (vars, ns1, ns2) H3.T(Per_proof_witness.No_app_state).t\n -> (vars, ns1) H2.T(Inductive_rule.Previous_proof_statement).t\n -> (vars, ns1, ns2) H3.T(Per_proof_witness).t =\n fun proofs stmts ->\n match (proofs, stmts) with\n | [], [] ->\n []\n | proof :: proofs, stmt :: stmts ->\n { proof with app_state = stmt.public_input } :: go proofs stmts\n in\n go prevs previous_proof_statements\n in\n let srs = Backend.Tock.Keypair.load_urs () in\n [%log internal] \"Step_compute_bulletproof_challenges\" ;\n let bulletproof_challenges =\n with_label \"prevs_verified\" (fun () ->\n let rec go :\n type vars vals ns1 ns2 n.\n (vars, ns1, ns2) H3.T(Per_proof_witness).t\n -> (vars, vals, ns1, ns2) H4.T(Types_map.For_step).t\n -> vars H1.T(E01(Digest)).t\n -> vars H1.T(E01(Unfinalized)).t\n -> (vars, ns1) H2.T(Inductive_rule.Previous_proof_statement).t\n -> (vars, n) Length.t\n -> actual_wrap_domains:\n ( Pickles_base.Proofs_verified.t As_prover.Ref.t\n , n )\n Vector.t\n -> (_, n) Vector.t * B.t list =\n fun proofs datas messages_for_next_wrap_proofs unfinalizeds stmts\n pi ~actual_wrap_domains ->\n match\n ( proofs\n , datas\n , messages_for_next_wrap_proofs\n , unfinalizeds\n , stmts\n , pi\n , actual_wrap_domains )\n with\n | [], [], [], [], [], Z, [] ->\n ([], [])\n | ( p :: proofs\n , d :: datas\n , messages_for_next_wrap_proof\n :: messages_for_next_wrap_proofs\n , unfinalized :: unfinalizeds\n , { proof_must_verify = should_verify; _ } :: stmts\n , S pi\n , actual_wrap_domain :: actual_wrap_domains ) ->\n let () =\n (* Fail with an error if the proof's domain differs from\n the hard-coded one otherwise.\n *)\n match d.wrap_domain with\n | `Known wrap_domain ->\n as_prover (fun () ->\n let actual_wrap_domain =\n As_prover.Ref.get actual_wrap_domain\n |> Pickles_base.Proofs_verified.to_int\n in\n let actual_wrap_domain =\n Common.wrap_domains\n ~proofs_verified:actual_wrap_domain\n in\n match (wrap_domain, actual_wrap_domain.h) with\n | ( Pow_2_roots_of_unity expected\n , Pow_2_roots_of_unity actual )\n when expected <> actual ->\n failwithf\n \"This circuit was compiled for proofs \\\n using the wrap domain of size %d, but a \\\n proof was given with size %d. You should \\\n pass the ~override_wrap_domain argument \\\n to set the correct domain size.\"\n expected actual ()\n | Pow_2_roots_of_unity _, Pow_2_roots_of_unity _\n ->\n () )\n | `Side_loaded _ ->\n ()\n in\n let chals, v =\n verify_one ~srs p d messages_for_next_wrap_proof\n unfinalized should_verify\n in\n let chalss, vs =\n go proofs datas messages_for_next_wrap_proofs unfinalizeds\n stmts pi ~actual_wrap_domains\n in\n (chals :: chalss, v :: vs)\n in\n let chalss, vs =\n let messages_for_next_wrap_proofs =\n with_label \"messages_for_next_wrap_proofs\" (fun () ->\n let module V = H1.Of_vector (Digest) in\n V.f proofs_verified\n (Vector.trim_front messages_for_next_wrap_proof lte) )\n and unfinalized_proofs =\n let module H = H1.Of_vector (Unfinalized) in\n H.f proofs_verified unfinalized_proofs_unextended\n and datas =\n let self_data :\n ( var\n , value\n , max_proofs_verified\n , self_branches )\n Types_map.For_step.t =\n { branches = self_branches\n ; proofs_verifieds =\n `Known\n (Vector.map basic.proofs_verifieds ~f:Field.of_int)\n ; max_proofs_verified\n ; public_input = basic.public_input\n ; wrap_domain = `Known basic.wrap_domains.h\n ; step_domains = `Known basic.step_domains\n ; wrap_key = dlog_plonk_index\n ; feature_flags = basic.feature_flags\n }\n in\n let module M =\n H4.Map (Tag) (Types_map.For_step)\n (struct\n let f :\n type a1 a2 n m.\n (a1, a2, n, m) Tag.t\n -> (a1, a2, n, m) Types_map.For_step.t =\n fun tag ->\n match Type_equal.Id.same_witness self.id tag.id with\n | Some T ->\n self_data\n | None -> (\n match tag.kind with\n | Compiled ->\n Types_map.For_step.of_compiled\n (Types_map.lookup_compiled tag.id)\n | Side_loaded ->\n Types_map.For_step.of_side_loaded\n (Types_map.lookup_side_loaded tag.id) )\n end)\n in\n M.f rule.prevs\n in\n go prevs datas messages_for_next_wrap_proofs unfinalized_proofs\n previous_proof_statements proofs_verified ~actual_wrap_domains\n in\n Boolean.Assert.all vs ; chalss )\n in\n [%log internal] \"Step_compute_bulletproof_challenges_done\" ;\n let messages_for_next_step_proof =\n let challenge_polynomial_commitments =\n let module M =\n H3.Map (Per_proof_witness) (E03 (Inner_curve))\n (struct\n let f :\n type a b c. (a, b, c) Per_proof_witness.t -> Inner_curve.t\n =\n fun acc ->\n acc.wrap_proof.opening.challenge_polynomial_commitment\n end)\n in\n let module V = H3.To_vector (Inner_curve) in\n V.f proofs_verified (M.f prevs)\n in\n with_label \"hash_messages_for_next_step_proof\" (fun () ->\n let hash_messages_for_next_step_proof =\n let to_field_elements =\n let (Typ typ) = basic.public_input in\n fun x -> fst (typ.var_to_fields x)\n in\n unstage\n (hash_messages_for_next_step_proof ~index:dlog_plonk_index\n to_field_elements )\n in\n let (app_state : var) =\n match public_input with\n | Input _ ->\n app_state\n | Output _ ->\n ret_var\n | Input_and_output _ ->\n (app_state, ret_var)\n in\n hash_messages_for_next_step_proof\n { app_state\n ; dlog_plonk_index\n ; challenge_polynomial_commitments\n ; old_bulletproof_challenges =\n (* Note: the bulletproof_challenges here are unpadded! *)\n bulletproof_challenges\n } )\n in\n let unfinalized_proofs =\n Vector.extend_front unfinalized_proofs_unextended lte\n Max_proofs_verified.n (Unfinalized.dummy ())\n in\n ( { Types.Step.Statement.proof_state =\n { unfinalized_proofs; messages_for_next_step_proof }\n ; messages_for_next_wrap_proof\n }\n : ( (Unfinalized.t, max_proofs_verified) Vector.t\n , Field.t\n , (Field.t, max_proofs_verified) Vector.t )\n Types.Step.Statement.t ) )\n in\n stage main\n","open Core_kernel\nopen Pickles_types\nopen Hlist\nopen Import\n\n(* The data obtained from \"compiling\" an inductive rule into a circuit. *)\ntype ( 'a_var\n , 'a_value\n , 'ret_var\n , 'ret_value\n , 'auxiliary_var\n , 'auxiliary_value\n , 'max_proofs_verified\n , 'branches\n , 'prev_vars\n , 'prev_values\n , 'local_widths\n , 'local_heights )\n t =\n | T :\n { proofs_verified :\n 'proofs_verified Nat.t * ('prev_vars, 'proofs_verified) Hlist.Length.t\n ; index : int\n ; lte : ('proofs_verified, 'max_proofs_verified) Nat.Lte.t\n ; domains : Domains.t\n ; rule :\n ( 'prev_vars\n , 'prev_values\n , 'local_widths\n , 'local_heights\n , 'a_var\n , 'a_value\n , 'ret_var\n , 'ret_value\n , 'auxiliary_var\n , 'auxiliary_value )\n Inductive_rule.t\n ; main :\n step_domains:(Domains.t, 'branches) Vector.t\n -> unit\n -> ( (Unfinalized.t, 'max_proofs_verified) Vector.t\n , Impls.Step.Field.t\n , (Impls.Step.Field.t, 'max_proofs_verified) Vector.t )\n Types.Step.Statement.t\n ; requests :\n (module Requests.Step.S\n with type statement = 'a_value\n and type max_proofs_verified = 'max_proofs_verified\n and type proofs_verified = 'proofs_verified\n and type prev_values = 'prev_values\n and type local_signature = 'local_widths\n and type local_branches = 'local_heights\n and type return_value = 'ret_value\n and type auxiliary_value = 'auxiliary_value )\n ; feature_flags : bool Plonk_types.Features.t\n }\n -> ( 'a_var\n , 'a_value\n , 'ret_var\n , 'ret_value\n , 'auxiliary_var\n , 'auxiliary_value\n , 'max_proofs_verified\n , 'branches\n , 'prev_vars\n , 'prev_values\n , 'local_widths\n , 'local_heights )\n t\n\n(* Compile an inductive rule. *)\nlet create\n (type branches max_proofs_verified var value a_var a_value ret_var ret_value)\n ~index ~(self : (var, value, max_proofs_verified, branches) Tag.t)\n ~wrap_domains\n ~(feature_flags : Plonk_types.Opt.Flag.t Plonk_types.Features.t)\n ~(actual_feature_flags : bool Plonk_types.Features.t)\n ~(max_proofs_verified : max_proofs_verified Nat.t)\n ~(proofs_verifieds : (int, branches) Vector.t) ~(branches : branches Nat.t)\n ~(public_input :\n ( var\n , value\n , a_var\n , a_value\n , ret_var\n , ret_value )\n Inductive_rule.public_input ) ~auxiliary_typ _var_to_field_elements\n _value_to_field_elements (rule : _ Inductive_rule.t) =\n Timer.clock __LOC__ ;\n let module HT = H4.T (Tag) in\n let (T (self_width, proofs_verified)) = HT.length rule.prevs in\n let rec extract_lengths :\n type a b n m k.\n (a, b, n, m) HT.t\n -> (a, k) Length.t\n -> n H1.T(Nat).t * m H1.T(Nat).t * (n, k) Length.t * (m, k) Length.t =\n fun ts len ->\n match (ts, len) with\n | [], Z ->\n ([], [], Z, Z)\n | t :: ts, S len -> (\n let ns, ms, len_ns, len_ms = extract_lengths ts len in\n match Type_equal.Id.same_witness self.id t.id with\n | Some T ->\n (max_proofs_verified :: ns, branches :: ms, S len_ns, S len_ms)\n | None ->\n let (module M), branches =\n match t.kind with\n | Compiled ->\n let d = Types_map.lookup_compiled t.id in\n (d.max_proofs_verified, d.branches)\n | Side_loaded ->\n let d = Types_map.lookup_side_loaded t.id in\n (d.permanent.max_proofs_verified, d.permanent.branches)\n in\n let T = M.eq in\n (M.n :: ns, branches :: ms, S len_ns, S len_ms) )\n in\n Timer.clock __LOC__ ;\n let widths, heights, local_signature_length, local_branches_length =\n extract_lengths rule.prevs proofs_verified\n in\n let lte = Nat.lte_exn self_width max_proofs_verified in\n let requests = Requests.Step.create () in\n let (typ : (var, value) Impls.Step.Typ.t) =\n match public_input with\n | Input typ ->\n typ\n | Output typ ->\n typ\n | Input_and_output (input_typ, output_typ) ->\n Impls.Step.Typ.(input_typ * output_typ)\n in\n Timer.clock __LOC__ ;\n let step ~step_domains =\n Step_main.step_main requests\n (Nat.Add.create max_proofs_verified)\n rule\n ~basic:\n { public_input = typ\n ; proofs_verifieds\n ; wrap_domains\n ; step_domains\n ; feature_flags\n }\n ~public_input ~auxiliary_typ ~self_branches:branches ~proofs_verified\n ~local_signature:widths ~local_signature_length ~local_branches:heights\n ~local_branches_length ~lte ~self\n |> unstage\n in\n Timer.clock __LOC__ ;\n let own_domains =\n let main =\n step\n ~step_domains:\n (Vector.init branches ~f:(fun _ -> Fix_domains.rough_domains))\n in\n let etyp =\n Impls.Step.input ~proofs_verified:max_proofs_verified\n ~wrap_rounds:Backend.Tock.Rounds.n ~feature_flags\n (* TODO *)\n in\n Fix_domains.domains\n (module Impls.Step)\n (T (Snarky_backendless.Typ.unit (), Fn.id, Fn.id))\n etyp main\n in\n Timer.clock __LOC__ ;\n T\n { proofs_verified = (self_width, proofs_verified)\n ; index\n ; lte\n ; rule\n ; domains = own_domains\n ; main = step\n ; requests\n ; feature_flags = actual_feature_flags\n }\n","module SC = Scalar_challenge\nopen Pickles_types\nopen Poly_types\nopen Hlist\nopen Backend\nopen Tuple_lib\nopen Import\nopen Types\nopen Common\n\n(* This contains the \"step\" prover *)\n\nmodule Make\n (A : T0) (A_value : sig\n type t\n end)\n (Max_proofs_verified : Nat.Add.Intf_transparent) =\nstruct\n let _double_zip = Double.map2 ~f:Core_kernel.Tuple2.create\n\n module E = struct\n type t = Tock.Field.t array Double.t Plonk_types.Evals.t * Tock.Field.t\n end\n\n module Plonk_checks = struct\n include Plonk_checks\n module Type1 = Plonk_checks.Make (Shifted_value.Type1) (Scalars.Tick)\n module Type2 = Plonk_checks.Make (Shifted_value.Type2) (Scalars.Tock)\n end\n\n (* The prover corresponding to the given inductive rule. *)\n let f\n (type (* The maximum number of proofs verified by one of the proof systems verified by this rule :)\n\n In other words: each of the proofs verified by this rule comes from some pickles proof system.\n\n The ith one of those proof systems has a maximum number of proofs N_i that is verified by\n a rule in proof system i. max_local_max_proof_verifieds is the max of the N_i.\n *)\n max_local_max_proof_verifieds self_branches prev_vars prev_values\n local_widths local_heights prevs_length var value ret_var ret_value\n auxiliary_var auxiliary_value ) ?handler\n (T branch_data :\n ( A.t\n , A_value.t\n , ret_var\n , ret_value\n , auxiliary_var\n , auxiliary_value\n , Max_proofs_verified.n\n , self_branches\n , prev_vars\n , prev_values\n , local_widths\n , local_heights )\n Step_branch_data.t ) (next_state : A_value.t)\n ~maxes:\n (module Maxes : Pickles_types.Hlist.Maxes.S\n with type length = Max_proofs_verified.n\n and type ns = max_local_max_proof_verifieds )\n ~(prevs_length : (prev_vars, prevs_length) Length.t) ~self ~step_domains\n ~feature_flags ~self_dlog_plonk_index\n ~(public_input :\n ( var\n , value\n , A.t\n , A_value.t\n , ret_var\n , ret_value )\n Inductive_rule.public_input )\n ~(auxiliary_typ : (auxiliary_var, auxiliary_value) Impls.Step.Typ.t) pk\n self_dlog_vk :\n ( ( value\n , (_, Max_proofs_verified.n) Vector.t\n , (_, prevs_length) Vector.t\n , (_, prevs_length) Vector.t\n , _\n , (_, Max_proofs_verified.n) Vector.t )\n Proof.Base.Step.t\n * ret_value\n * auxiliary_value\n * (int, prevs_length) Vector.t )\n Promise.t =\n let logger = Internal_tracing_context_logger.get () in\n [%log internal] \"Pickles_step_proof\" ;\n let _ = auxiliary_typ in\n (* unused *)\n let _, prev_vars_length = branch_data.proofs_verified in\n let T = Length.contr prev_vars_length prevs_length in\n let (module Req) = branch_data.requests in\n let T =\n Hlist.Length.contr (snd branch_data.proofs_verified) prev_vars_length\n in\n let prev_values_length =\n let module L12 = H4.Length_1_to_2 (Tag) in\n L12.f branch_data.rule.prevs prev_vars_length\n in\n let lte = branch_data.lte in\n let module X_hat = struct\n type t = Tock.Field.t Double.t\n end in\n let module Statement_with_hashes = struct\n type t =\n ( Challenge.Constant.t\n , Challenge.Constant.t Scalar_challenge.t\n , Tick.Field.t Shifted_value.Type1.t\n , Tick.Field.t Shifted_value.Type1.t option\n , Challenge.Constant.t Scalar_challenge.t\n Types.Wrap.Proof_state.Deferred_values.Plonk.In_circuit.Lookup.t\n option\n , bool\n , Digest.Constant.t\n , Digest.Constant.t\n , Digest.Constant.t\n , Challenge.Constant.t Scalar_challenge.t Bulletproof_challenge.t\n Step_bp_vec.t\n , Branch_data.t )\n Wrap.Statement.In_circuit.t\n end in\n let challenge_polynomial =\n Wrap_verifier.challenge_polynomial (module Backend.Tock.Field)\n in\n let expand_proof :\n type var value local_max_proofs_verified m.\n Impls.Wrap.Verification_key.t\n -> 'a\n -> value\n -> (local_max_proofs_verified, local_max_proofs_verified) Proof.t\n -> (var, value, local_max_proofs_verified, m) Tag.t\n -> must_verify:bool\n -> [ `Sg of Tock.Curve.Affine.t ]\n * Unfinalized.Constant.t\n * Statement_with_hashes.t\n * X_hat.t\n * ( value\n , local_max_proofs_verified\n , m )\n Per_proof_witness.Constant.No_app_state.t\n * [ `Actual_wrap_domain of int ] =\n fun dlog_vk dlog_index app_state (T t) tag ~must_verify ->\n let t =\n { t with\n statement =\n { t.statement with\n messages_for_next_step_proof =\n { t.statement.messages_for_next_step_proof with app_state }\n }\n }\n in\n let proof = Wrap_wire_proof.to_kimchi_proof t.proof in\n let data = Types_map.lookup_basic tag in\n let plonk0 = t.statement.proof_state.deferred_values.plonk in\n let plonk =\n let domain =\n Branch_data.domain t.statement.proof_state.deferred_values.branch_data\n in\n let to_field =\n SC.to_field_constant\n (module Tick.Field)\n ~endo:Endo.Wrap_inner_curve.scalar\n in\n let alpha = to_field plonk0.alpha in\n let zeta = to_field plonk0.zeta in\n let zetaw =\n Tick.Field.(\n zeta * domain_generator ~log2_size:(Domain.log2_size domain))\n in\n let combined_evals =\n Plonk_checks.evals_of_split_evals\n (module Tick.Field)\n t.prev_evals.evals.evals ~rounds:(Nat.to_int Tick.Rounds.n) ~zeta\n ~zetaw\n |> Plonk_types.Evals.to_in_circuit\n in\n let plonk_minimal =\n { Composition_types.Wrap.Proof_state.Deferred_values.Plonk.Minimal\n .zeta\n ; alpha\n ; beta = Challenge.Constant.to_tick_field plonk0.beta\n ; gamma = Challenge.Constant.to_tick_field plonk0.gamma\n ; joint_combiner = Option.map ~f:to_field plonk0.joint_combiner\n ; feature_flags = plonk0.feature_flags\n }\n in\n let env =\n let module Env_bool = struct\n type t = bool\n\n let true_ = true\n\n let false_ = false\n\n let ( &&& ) = ( && )\n\n let ( ||| ) = ( || )\n\n let any = List.exists ~f:Fn.id\n end in\n let module Env_field = struct\n include Tick.Field\n\n type bool = Env_bool.t\n\n let if_ (b : bool) ~then_ ~else_ = if b then then_ () else else_ ()\n end in\n Plonk_checks.scalars_env\n (module Env_bool)\n (module Env_field)\n ~srs_length_log2:Common.Max_degree.step_log2\n ~endo:Endo.Step_inner_curve.base ~mds:Tick_field_sponge.params.mds\n ~field_of_hex:(fun s ->\n Kimchi_pasta.Pasta.Bigint256.of_hex_string s\n |> Kimchi_pasta.Pasta.Fp.of_bigint )\n ~domain:\n (Plonk_checks.domain\n (module Tick.Field)\n domain ~shifts:Common.tick_shifts\n ~domain_generator:Backend.Tick.Field.domain_generator )\n plonk_minimal combined_evals\n in\n time \"plonk_checks\" (fun () ->\n let module Field = struct\n include Tick.Field\n end in\n Plonk_checks.Type1.derive_plonk\n (module Field)\n ~env ~shift:Shifts.tick1 plonk_minimal combined_evals )\n in\n let (module Local_max_proofs_verified) = data.max_proofs_verified in\n let T = Local_max_proofs_verified.eq in\n let statement = t.statement in\n let prev_challenges =\n (* TODO: This is redone in the call to Reduced_messages_for_next_proof_over_same_field.Wrap.prepare *)\n Vector.map ~f:Ipa.Wrap.compute_challenges\n statement.proof_state.messages_for_next_wrap_proof\n .old_bulletproof_challenges\n in\n let deferred_values_computed =\n Wrap_deferred_values.expand_deferred ~evals:t.prev_evals\n ~old_bulletproof_challenges:\n statement.messages_for_next_step_proof.old_bulletproof_challenges\n ~proof_state:statement.proof_state\n in\n let prev_statement_with_hashes :\n ( _\n , _\n , _ Shifted_value.Type1.t\n , _\n , _\n , _\n , _\n , _\n , _\n , _\n , _ )\n Wrap.Statement.In_circuit.t =\n { messages_for_next_step_proof =\n (let to_field_elements =\n let (Typ typ) = data.public_input in\n fun x -> fst (typ.value_to_fields x)\n in\n (* TODO: Only do this hashing when necessary *)\n Common.hash_messages_for_next_step_proof\n (Reduced_messages_for_next_proof_over_same_field.Step.prepare\n ~dlog_plonk_index:dlog_index\n statement.messages_for_next_step_proof )\n ~app_state:to_field_elements )\n ; proof_state =\n { deferred_values =\n (let deferred_values = deferred_values_computed in\n { plonk =\n { plonk with\n zeta = plonk0.zeta\n ; alpha = plonk0.alpha\n ; beta = plonk0.beta\n ; gamma = plonk0.gamma\n ; lookup =\n Option.map (Opt.to_option_unsafe plonk.lookup)\n ~f:(fun _ ->\n { Composition_types.Wrap.Proof_state\n .Deferred_values\n .Plonk\n .In_circuit\n .Lookup\n .joint_combiner =\n Option.value_exn plonk0.joint_combiner\n } )\n }\n ; combined_inner_product =\n deferred_values.combined_inner_product\n ; b = deferred_values.b\n ; xi = deferred_values.xi\n ; bulletproof_challenges =\n statement.proof_state.deferred_values\n .bulletproof_challenges\n ; branch_data = deferred_values.branch_data\n } )\n ; sponge_digest_before_evaluations =\n statement.proof_state.sponge_digest_before_evaluations\n ; messages_for_next_wrap_proof =\n Wrap_hack.hash_messages_for_next_wrap_proof\n Local_max_proofs_verified.n\n { old_bulletproof_challenges = prev_challenges\n ; challenge_polynomial_commitment =\n statement.proof_state.messages_for_next_wrap_proof\n .challenge_polynomial_commitment\n }\n }\n }\n in\n let module O = Tock.Oracles in\n let o =\n let public_input =\n tock_public_input_of_statement prev_statement_with_hashes\n in\n O.create dlog_vk\n ( Vector.map2\n (Vector.extend_front_exn\n statement.messages_for_next_step_proof\n .challenge_polynomial_commitments Local_max_proofs_verified.n\n (Lazy.force Dummy.Ipa.Wrap.sg) )\n (* This should indeed have length Max_proofs_verified... No! It should have type Max_proofs_verified_a. That is, the max_proofs_verified specific to a proof of this type...*)\n prev_challenges\n ~f:(fun commitment chals ->\n { Tock.Proof.Challenge_polynomial.commitment\n ; challenges = Vector.to_array chals\n } )\n |> Wrap_hack.pad_accumulator )\n public_input proof\n in\n let ((x_hat_1, _x_hat_2) as x_hat) = O.(p_eval_1 o, p_eval_2 o) in\n let scalar_chal f =\n Scalar_challenge.map ~f:Challenge.Constant.of_tock_field (f o)\n in\n let plonk0 =\n { Types.Wrap.Proof_state.Deferred_values.Plonk.Minimal.alpha =\n scalar_chal O.alpha\n ; beta = O.beta o\n ; gamma = O.gamma o\n ; zeta = scalar_chal O.zeta\n ; joint_combiner =\n Option.map\n ~f:(Scalar_challenge.map ~f:Challenge.Constant.of_tock_field)\n (O.joint_combiner_chal o)\n ; feature_flags =\n t.statement.proof_state.deferred_values.plonk.feature_flags\n }\n in\n let xi = scalar_chal O.v in\n let r = scalar_chal O.u in\n let sponge_digest_before_evaluations = O.digest_before_evaluations o in\n let to_field =\n SC.to_field_constant\n (module Tock.Field)\n ~endo:Endo.Step_inner_curve.scalar\n in\n let module As_field = struct\n let r = to_field r\n\n let xi = to_field xi\n\n let zeta = to_field plonk0.zeta\n\n let alpha = to_field plonk0.alpha\n\n let joint_combiner = O.joint_combiner o\n end in\n let w =\n Tock.Field.domain_generator ~log2_size:dlog_vk.domain.log_size_of_group\n in\n let zetaw = Tock.Field.mul As_field.zeta w in\n let new_bulletproof_challenges, b =\n let prechals =\n Array.map (O.opening_prechallenges o) ~f:(fun x ->\n Scalar_challenge.map ~f:Challenge.Constant.of_tock_field x )\n in\n let chals =\n Array.map prechals ~f:(fun x -> Ipa.Wrap.compute_challenge x)\n in\n let challenge_polynomial = unstage (challenge_polynomial chals) in\n let open As_field in\n let b =\n let open Tock.Field in\n challenge_polynomial zeta + (r * challenge_polynomial zetaw)\n in\n let prechals =\n Vector.of_list_and_length_exn\n (Array.map prechals ~f:Bulletproof_challenge.unpack |> Array.to_list)\n Tock.Rounds.n\n in\n (prechals, b)\n in\n let challenge_polynomial_commitment =\n if not must_verify then Ipa.Wrap.compute_sg new_bulletproof_challenges\n else proof.openings.proof.challenge_polynomial_commitment\n in\n let witness : _ Per_proof_witness.Constant.No_app_state.t =\n { app_state = ()\n ; proof_state =\n { prev_statement_with_hashes.proof_state with\n messages_for_next_wrap_proof = ()\n }\n ; prev_proof_evals = t.prev_evals\n ; prev_challenge_polynomial_commitments =\n Vector.extend_front_exn\n t.statement.messages_for_next_step_proof\n .challenge_polynomial_commitments Local_max_proofs_verified.n\n (Lazy.force Dummy.Ipa.Wrap.sg)\n (* TODO: This computation is also redone elsewhere. *)\n ; prev_challenges =\n Vector.extend_front_exn\n (Vector.map\n t.statement.messages_for_next_step_proof\n .old_bulletproof_challenges ~f:Ipa.Step.compute_challenges )\n Local_max_proofs_verified.n Dummy.Ipa.Step.challenges_computed\n ; wrap_proof =\n { opening =\n { proof.openings.proof with challenge_polynomial_commitment }\n ; messages = proof.messages\n }\n }\n in\n let tock_domain =\n Plonk_checks.domain\n (module Tock.Field)\n (Pow_2_roots_of_unity dlog_vk.domain.log_size_of_group)\n ~shifts:Common.tock_shifts\n ~domain_generator:Backend.Tock.Field.domain_generator\n in\n let tock_combined_evals =\n Plonk_checks.evals_of_split_evals\n (module Tock.Field)\n proof.openings.evals ~rounds:(Nat.to_int Tock.Rounds.n)\n ~zeta:As_field.zeta ~zetaw\n |> Plonk_types.Evals.to_in_circuit\n in\n let tock_plonk_minimal =\n { plonk0 with\n zeta = As_field.zeta\n ; alpha = As_field.alpha\n ; joint_combiner = As_field.joint_combiner\n }\n in\n let tock_env =\n let module Env_bool = struct\n type t = bool\n\n let true_ = true\n\n let false_ = false\n\n let ( &&& ) = ( && )\n\n let ( ||| ) = ( || )\n\n let any = List.exists ~f:Fn.id\n end in\n let module Env_field = struct\n include Tock.Field\n\n type bool = Env_bool.t\n\n let if_ (b : bool) ~then_ ~else_ = if b then then_ () else else_ ()\n end in\n Plonk_checks.scalars_env\n (module Env_bool)\n (module Env_field)\n ~domain:tock_domain ~srs_length_log2:Common.Max_degree.wrap_log2\n ~field_of_hex:(fun s ->\n Kimchi_pasta.Pasta.Bigint256.of_hex_string s\n |> Kimchi_pasta.Pasta.Fq.of_bigint )\n ~endo:Endo.Wrap_inner_curve.base ~mds:Tock_field_sponge.params.mds\n tock_plonk_minimal tock_combined_evals\n in\n let combined_inner_product =\n let e = proof.openings.evals in\n let b_polys =\n Vector.map\n ~f:(fun chals ->\n unstage (challenge_polynomial (Vector.to_array chals)) )\n (Wrap_hack.pad_challenges prev_challenges)\n in\n let a = Plonk_types.Evals.to_list e in\n let open As_field in\n let combine ~which_eval ~ft_eval pt =\n let f (x, y) = match which_eval with `Fst -> x | `Snd -> y in\n let v : Tock.Field.t array list =\n let a = List.map ~f a in\n List.append\n (Vector.to_list (Vector.map b_polys ~f:(fun f -> [| f pt |])))\n ([| f x_hat |] :: [| ft_eval |] :: a)\n in\n let open Tock.Field in\n Pcs_batch.combine_split_evaluations ~xi ~init:Fn.id\n ~mul_and_add:(fun ~acc ~xi fx -> fx + (xi * acc))\n v\n in\n let ft_eval0 =\n Plonk_checks.Type2.ft_eval0\n (module Tock.Field)\n ~domain:tock_domain ~env:tock_env tock_plonk_minimal\n tock_combined_evals x_hat_1\n in\n let open Tock.Field in\n combine ~which_eval:`Fst ~ft_eval:ft_eval0 As_field.zeta\n + (r * combine ~which_eval:`Snd ~ft_eval:proof.openings.ft_eval1 zetaw)\n in\n let chal = Challenge.Constant.of_tock_field in\n let plonk =\n let module Field = struct\n include Tock.Field\n end in\n (* Wrap proof, no features *)\n Plonk_checks.Type2.derive_plonk\n (module Field)\n ~env:tock_env ~shift:Shifts.tock2 tock_plonk_minimal\n tock_combined_evals\n |> Composition_types.Step.Proof_state.Deferred_values.Plonk.In_circuit\n .of_wrap\n ~assert_none:(fun x -> assert (Option.is_none (Opt.to_option x)))\n ~assert_false:(fun x -> assert (not x))\n in\n let shifted_value =\n Shifted_value.Type2.of_field (module Tock.Field) ~shift:Shifts.tock2\n in\n ( `Sg challenge_polynomial_commitment\n , { Types.Step.Proof_state.Per_proof.deferred_values =\n { plonk =\n { plonk with\n zeta = plonk0.zeta\n ; alpha = plonk0.alpha\n ; beta = chal plonk0.beta\n ; gamma = chal plonk0.gamma\n }\n ; combined_inner_product = shifted_value combined_inner_product\n ; xi\n ; bulletproof_challenges = new_bulletproof_challenges\n ; b = shifted_value b\n }\n ; should_finalize = must_verify\n ; sponge_digest_before_evaluations =\n Digest.Constant.of_tock_field sponge_digest_before_evaluations\n }\n , prev_statement_with_hashes\n , x_hat\n , witness\n , `Actual_wrap_domain dlog_vk.domain.log_size_of_group )\n in\n let challenge_polynomial_commitments = ref None in\n let unfinalized_proofs = ref None in\n let statements_with_hashes = ref None in\n let x_hats = ref None in\n let witnesses = ref None in\n let prev_proofs = ref None in\n let return_value = ref None in\n let auxiliary_value = ref None in\n let actual_wrap_domains = ref None in\n let compute_prev_proof_parts prev_proof_requests =\n let ( challenge_polynomial_commitments'\n , unfinalized_proofs'\n , statements_with_hashes'\n , x_hats'\n , witnesses'\n , prev_proofs'\n , actual_wrap_domains' ) =\n let[@warning \"-4\"] rec go :\n type vars values ns ms k.\n (vars, values, ns, ms) H4.T(Tag).t\n -> ( values\n , ns )\n H2.T(Inductive_rule.Previous_proof_statement.Constant).t\n -> (vars, k) Length.t\n -> (Tock.Curve.Affine.t, k) Vector.t\n * (Unfinalized.Constant.t, k) Vector.t\n * (Statement_with_hashes.t, k) Vector.t\n * (X_hat.t, k) Vector.t\n * ( values\n , ns\n , ms )\n H3.T(Per_proof_witness.Constant.No_app_state).t\n * (ns, ns) H2.T(Proof).t\n * (int, k) Vector.t =\n fun ts prev_proof_stmts l ->\n match (ts, prev_proof_stmts, l) with\n | [], [], Z ->\n ([], [], [], [], [], [], [])\n | ( t :: ts\n , { public_input = app_state\n ; proof = p\n ; proof_must_verify = must_verify\n }\n :: prev_proof_stmts\n , S l ) ->\n let dlog_vk, dlog_index =\n if Type_equal.Id.same self.Tag.id t.id then\n (self_dlog_vk, self_dlog_plonk_index)\n else\n let d = Types_map.lookup_basic t in\n (d.wrap_vk, d.wrap_key)\n in\n let `Sg sg, u, s, x, w, `Actual_wrap_domain domain =\n expand_proof dlog_vk dlog_index app_state p t ~must_verify\n and sgs, us, ss, xs, ws, ps, domains = go ts prev_proof_stmts l in\n ( sg :: sgs\n , u :: us\n , s :: ss\n , x :: xs\n , w :: ws\n , p :: ps\n , domain :: domains )\n | _, _ :: _, _ ->\n .\n | _, [], _ ->\n .\n in\n go branch_data.rule.prevs prev_proof_requests prev_vars_length\n in\n challenge_polynomial_commitments := Some challenge_polynomial_commitments' ;\n unfinalized_proofs := Some unfinalized_proofs' ;\n statements_with_hashes := Some statements_with_hashes' ;\n x_hats := Some x_hats' ;\n witnesses := Some witnesses' ;\n prev_proofs := Some prev_proofs' ;\n actual_wrap_domains := Some actual_wrap_domains'\n in\n let unfinalized_proofs = lazy (Option.value_exn !unfinalized_proofs) in\n let unfinalized_proofs_extended =\n lazy\n (Vector.extend_front\n (Lazy.force unfinalized_proofs)\n lte Max_proofs_verified.n\n (Lazy.force Unfinalized.Constant.dummy) )\n in\n let module Extract = struct\n module type S = sig\n type res\n\n val f : _ Proof.t -> res\n end\n end in\n let extract_from_proofs (type res)\n (module Extract : Extract.S with type res = res) =\n let rec go :\n type vars values ns ms len.\n (ns, ns) H2.T(Proof).t\n -> (values, vars, ns, ms) H4.T(Tag).t\n -> (vars, len) Length.t\n -> (res, len) Vector.t =\n fun prevs tags len ->\n match (prevs, tags, len) with\n | [], [], Z ->\n []\n | t :: prevs, _ :: tags, S len ->\n Extract.f t :: go prevs tags len\n in\n go\n (Option.value_exn !prev_proofs)\n branch_data.rule.prevs prev_values_length\n in\n let messages_for_next_step_proof :\n _ Reduced_messages_for_next_proof_over_same_field.Step.t Lazy.t =\n lazy\n (let old_bulletproof_challenges =\n extract_from_proofs\n ( module struct\n type res =\n Challenge.Constant.t Scalar_challenge.t Bulletproof_challenge.t\n Step_bp_vec.t\n\n let f (T t : _ Proof.t) =\n t.statement.proof_state.deferred_values.bulletproof_challenges\n end )\n in\n let (return_value : ret_value) = Option.value_exn !return_value in\n let (app_state : value) =\n match public_input with\n | Input _ ->\n next_state\n | Output _ ->\n return_value\n | Input_and_output _ ->\n (next_state, return_value)\n in\n (* Have the sg be available in the opening proof and verify it. *)\n { app_state\n ; challenge_polynomial_commitments =\n Option.value_exn !challenge_polynomial_commitments\n ; old_bulletproof_challenges\n } )\n in\n let messages_for_next_step_proof_prepared =\n lazy\n (Reduced_messages_for_next_proof_over_same_field.Step.prepare\n ~dlog_plonk_index:self_dlog_plonk_index\n (Lazy.force messages_for_next_step_proof) )\n in\n let messages_for_next_wrap_proof_padded =\n let rec pad :\n type n k maxes.\n (Digest.Constant.t, k) Vector.t\n -> maxes H1.T(Nat).t\n -> (maxes, n) Hlist.Length.t\n -> (Digest.Constant.t, n) Vector.t =\n fun xs maxes l ->\n match (xs, maxes, l) with\n | [], [], Z ->\n []\n | _x :: _xs, [], Z ->\n assert false\n | x :: xs, _ :: ms, S n ->\n x :: pad xs ms n\n | [], _m :: ms, S n ->\n let t : _ Types.Wrap.Proof_state.Messages_for_next_wrap_proof.t =\n { challenge_polynomial_commitment = Lazy.force Dummy.Ipa.Step.sg\n ; old_bulletproof_challenges =\n Vector.init Max_proofs_verified.n ~f:(fun _ ->\n Dummy.Ipa.Wrap.challenges_computed )\n }\n in\n Wrap_hack.hash_messages_for_next_wrap_proof Max_proofs_verified.n t\n :: pad [] ms n\n in\n lazy\n (Vector.rev\n (pad\n (Vector.map\n (Vector.rev (Option.value_exn !statements_with_hashes))\n ~f:(fun s -> s.proof_state.messages_for_next_wrap_proof) )\n Maxes.maxes Maxes.length ) )\n in\n let handler (Snarky_backendless.Request.With { request; respond } as r) =\n let k x = respond (Provide x) in\n match request with\n | Req.Compute_prev_proof_parts prev_proof_requests ->\n [%log internal] \"Step_compute_prev_proof_parts\" ;\n compute_prev_proof_parts prev_proof_requests ;\n [%log internal] \"Step_compute_prev_proof_parts_done\" ;\n k ()\n | Req.Proof_with_datas ->\n k (Option.value_exn !witnesses)\n | Req.Wrap_index ->\n k self_dlog_plonk_index\n | Req.App_state ->\n k next_state\n | Req.Return_value res ->\n return_value := Some res ;\n k ()\n | Req.Auxiliary_value res ->\n auxiliary_value := Some res ;\n k ()\n | Req.Unfinalized_proofs ->\n k (Lazy.force unfinalized_proofs)\n | Req.Messages_for_next_wrap_proof ->\n k (Lazy.force messages_for_next_wrap_proof_padded)\n | Req.Wrap_domain_indices ->\n let all_possible_domains = Wrap_verifier.all_possible_domains () in\n let wrap_domain_indices =\n Vector.map (Option.value_exn !actual_wrap_domains)\n ~f:(fun domain_size ->\n let domain_index =\n Vector.foldi ~init:0 all_possible_domains\n ~f:(fun j acc (Pow_2_roots_of_unity domain) ->\n if Int.equal domain domain_size then j else acc )\n in\n Pickles_base.Proofs_verified.of_int domain_index )\n in\n k wrap_domain_indices\n | _ -> (\n match handler with\n | Some f ->\n f r\n | None ->\n Snarky_backendless.Request.unhandled )\n in\n let prev_challenge_polynomial_commitments =\n lazy\n (let to_fold_in =\n extract_from_proofs\n ( module struct\n type res = Tick.Curve.Affine.t\n\n let f (T t : _ Proof.t) =\n t.statement.proof_state.messages_for_next_wrap_proof\n .challenge_polynomial_commitment\n end )\n in\n (* emphatically NOT padded with dummies *)\n Vector.(\n map2 to_fold_in\n (Lazy.force messages_for_next_step_proof_prepared)\n .old_bulletproof_challenges ~f:(fun commitment chals ->\n { Tick.Proof.Challenge_polynomial.commitment\n ; challenges = Vector.to_array chals\n } )\n |> to_list) )\n in\n let%map.Promise (next_proof : Tick.Proof.t), _next_statement_hashed =\n let (T (input, _conv, conv_inv)) =\n Impls.Step.input ~proofs_verified:Max_proofs_verified.n\n ~wrap_rounds:Tock.Rounds.n ~feature_flags\n in\n let { Domains.h } = Vector.nth_exn step_domains branch_data.index in\n ksprintf Common.time \"step-prover %d (%d)\" branch_data.index\n (Domain.size h)\n (fun () ->\n let promise_or_error =\n (* Use a try_with to give an informative backtrace.\n If we don't do this, the backtrace will be obfuscated by the\n Promise, and it's significantly harder to track down errors.\n This only applies to errors in the 'witness generation' stage;\n proving errors are emitted inside the promise, and are therefore\n unaffected.\n *)\n Or_error.try_with ~backtrace:true (fun () ->\n [%log internal] \"Step_generate_witness_conv\" ;\n Impls.Step.generate_witness_conv\n ~f:(fun { Impls.Step.Proof_inputs.auxiliary_inputs\n ; public_inputs\n } next_statement_hashed ->\n [%log internal] \"Backend_tick_proof_create_async\" ;\n let%map.Promise proof =\n Backend.Tick.Proof.create_async ~primary:public_inputs\n ~auxiliary:auxiliary_inputs\n ~message:\n (Lazy.force prev_challenge_polynomial_commitments)\n pk\n in\n [%log internal] \"Backend_tick_proof_create_async_done\" ;\n (proof, next_statement_hashed) )\n ~input_typ:Impls.Step.Typ.unit ~return_typ:input\n (fun () () ->\n Impls.Step.handle\n (fun () -> conv_inv (branch_data.main ~step_domains ()))\n handler ) )\n in\n (* Re-raise any captured errors, complete with their backtrace. *)\n Or_error.ok_exn promise_or_error )\n ()\n in\n let prev_evals =\n extract_from_proofs\n ( module struct\n type res = E.t\n\n let f (T t : _ Proof.t) =\n let proof = Wrap_wire_proof.to_kimchi_proof t.proof in\n (proof.openings.evals, proof.openings.ft_eval1)\n end )\n in\n let messages_for_next_wrap_proof =\n let rec go :\n type a.\n (a, a) H2.T(Proof).t\n -> a H1.T(Proof.Base.Messages_for_next_proof_over_same_field.Wrap).t =\n function\n | [] ->\n []\n | T t :: tl ->\n t.statement.proof_state.messages_for_next_wrap_proof :: go tl\n in\n go (Option.value_exn !prev_proofs)\n in\n let next_statement : _ Types.Step.Statement.t =\n { proof_state =\n { unfinalized_proofs = Lazy.force unfinalized_proofs_extended\n ; messages_for_next_step_proof =\n Lazy.force messages_for_next_step_proof\n }\n ; messages_for_next_wrap_proof\n }\n in\n [%log internal] \"Pickles_step_proof_done\" ;\n ( { Proof.Base.Step.proof = next_proof\n ; statement = next_statement\n ; index = branch_data.index\n ; prev_evals =\n Vector.extend_front\n (Vector.map2 prev_evals (Option.value_exn !x_hats)\n ~f:(fun (es, ft_eval1) x_hat ->\n Plonk_types.All_evals.\n { ft_eval1\n ; evals =\n { With_public_input.evals = es; public_input = x_hat }\n } ) )\n lte Max_proofs_verified.n Dummy.evals\n }\n , Option.value_exn !return_value\n , Option.value_exn !auxiliary_value\n , Option.value_exn !actual_wrap_domains )\nend\n","type t = [ `Cache_hit | `Generated_something | `Locally_generated ]\n\nlet ( + ) x y =\n match (x, y) with\n | `Generated_something, _ | _, `Generated_something ->\n `Generated_something\n | `Locally_generated, _ | _, `Locally_generated ->\n `Locally_generated\n | `Cache_hit, `Cache_hit ->\n `Cache_hit\n","type t = Dirty.t Lazy.t\n\nlet generate_or_load (t : t) = Lazy.force t\n\nlet ( + ) (t1 : t) (t2 : t) : t = lazy Dirty.(Lazy.force t1 + Lazy.force t2)\n","\nlet params =\n lazy\n (let module T =\n struct\n type t =\n Pickles.Backend.Tick.Field.Stable.Latest.t Group_map.Params.t\n [@@deriving bin_io_unversioned]\n end in\n Core_kernel.Binable.of_string (module T)\n \"\\002\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000i\\2196c[?\\152\\181p\\196\\252\\251\\244\\181\\140\\151w\\n\\154\\140\\220>\\209\\197|\\215\\162<\\2361\\247\\026\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\003\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\005\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\");;\n","let () = Pickles.Backend.Tock.Keypair.set_urs_info Cache_dir.cache\n\nlet () = Pickles.Backend.Tick.Keypair.set_urs_info Cache_dir.cache\n\nmodule Tock = struct\n module Full = Pickles.Impls.Wrap\n module Run = Pickles.Impls.Wrap\n\n let group_map_params () = Lazy.force Group_map_params.params\n\n include Full.Internal_Basic\n module Number = Snarky_backendless.Number.Make (Full.Internal_Basic)\n module Enumerable = Snarky_backendless.Enumerable.Make (Full.Internal_Basic)\n module Inner_curve = Pickles.Backend.Tock.Inner_curve\nend\n\nmodule Tick = struct\n module Full = Pickles.Impls.Step\n module Run = Pickles.Impls.Step\n\n let group_map_params =\n Group_map.Params.create\n (module Pickles.Backend.Tock.Field)\n Pickles.Backend.Tock.Inner_curve.Params.{ a; b }\n\n include Full.Internal_Basic\n module Number = Snarky_backendless.Number.Make (Full.Internal_Basic)\n module Enumerable = Snarky_backendless.Enumerable.Make (Full.Internal_Basic)\n module Inner_curve = Pickles.Backend.Tick.Inner_curve\nend\n","open Core_kernel\ninclude Bigint\n\nlet of_bool (b : bool) : t = if b then one else zero\n\nlet of_bit_fold_lsb ({ fold } : bool Fold_lib.Fold.t) : t =\n fold ~init:(0, zero) ~f:(fun (i, acc) b ->\n (Int.(i + 1), bit_or (shift_left (of_bool b) i) acc) )\n |> snd\n\nlet of_bits_lsb : bool list -> t =\n List.foldi ~init:zero ~f:(fun i acc b ->\n bit_or (shift_left (of_bool b) i) acc )\n","open Core_kernel\n\nmodule Make_test (F : Intf.Basic) = struct\n let test arg_typ gen_arg sexp_of_arg label unchecked checked =\n let open F.Impl in\n let converted x =\n let r =\n run_and_check\n (let open Checked.Let_syntax in\n let%bind x = exists arg_typ ~compute:(As_prover.return x) in\n checked x >>| As_prover.read F.typ)\n |> Or_error.ok_exn\n in\n r\n in\n let open Quickcheck in\n test ~trials:50 gen_arg ~f:(fun x ->\n let r1 = unchecked x in\n let r2 = converted x in\n if not (F.Unchecked.equal r1 r2) then\n failwithf\n !\"%s test failure: %{sexp:arg} -> %{sexp:F.Unchecked.t} vs \\\n %{sexp:F.Unchecked.t}\"\n label x r1 r2 ()\n else () )\n\n let test1 l f g = test F.typ F.Unchecked.gen F.Unchecked.sexp_of_t l f g\n\n let test2 l f g =\n let open F in\n test (Impl.Typ.( * ) typ typ)\n (Quickcheck.Generator.tuple2 Unchecked.gen Unchecked.gen)\n [%sexp_of: Unchecked.t * Unchecked.t] l (Tuple2.uncurry f)\n (Tuple2.uncurry g)\nend\n\nmodule Make (F : Intf.Basic) = struct\n open F.Impl\n open Let_syntax\n open F\n\n let typ = F.typ\n\n let constant = F.constant\n\n let scale = F.scale\n\n let assert_r1cs = F.assert_r1cs\n\n let equal x y =\n Checked.all\n (List.map2_exn (F.to_list x) (F.to_list y) ~f:Field.Checked.equal)\n >>= Boolean.all\n\n let assert_equal x y =\n assert_all\n (List.map2_exn\n ~f:(fun x y -> Constraint.equal x y)\n (F.to_list x) (F.to_list y) )\n\n let ( + ) = F.( + )\n\n let%test_unit \"add\" =\n let module M = Make_test (F) in\n M.test2 \"add\" Unchecked.( + ) (fun x y -> return (x + y))\n\n let ( - ) = F.( - )\n\n let negate = F.negate\n\n let zero = constant Unchecked.zero\n\n let one = constant Unchecked.one\n\n let div_unsafe x y =\n match (to_constant x, to_constant y) with\n | Some x, Some y ->\n return (constant Unchecked.(x / y))\n | _, _ ->\n let%bind x_over_y =\n exists typ\n ~compute:\n As_prover.(map2 (read typ x) (read typ y) ~f:Unchecked.( / ))\n in\n let%map () = assert_r1cs y x_over_y x in\n x_over_y\n\n let assert_square =\n match assert_square with\n | `Custom f ->\n f\n | `Define ->\n fun a a2 -> assert_r1cs a a a2\n\n let ( * ) =\n match ( * ) with\n | `Custom f ->\n f\n | `Define -> (\n fun x y ->\n match (to_constant x, to_constant y) with\n | Some x, Some y ->\n return (constant Unchecked.(x * y))\n | _, _ ->\n let%bind res =\n exists typ\n ~compute:\n As_prover.(\n map2 (read typ x) (read typ y) ~f:Unchecked.( * ))\n in\n let%map () = assert_r1cs x y res in\n res )\n\n let%test_unit \"mul\" =\n let module M = Make_test (F) in\n M.test2 \"mul\" Unchecked.( * ) ( * )\n\n let square =\n match square with\n | `Custom f ->\n f\n | `Define -> (\n fun x ->\n match to_constant x with\n | Some x ->\n return (constant (Unchecked.square x))\n | None ->\n let%bind res =\n exists typ\n ~compute:As_prover.(map (read typ x) ~f:Unchecked.square)\n in\n let%map () = assert_square x res in\n res )\n\n let%test_unit \"square\" =\n let module M = Make_test (F) in\n M.test1 \"square\" Unchecked.square square\n\n let inv_exn =\n match inv_exn with\n | `Custom f ->\n f\n | `Define -> (\n fun t ->\n match to_constant t with\n | Some x ->\n return (constant (Unchecked.inv x))\n | None ->\n let%bind res =\n exists typ\n ~compute:As_prover.(map (read typ t) ~f:Unchecked.inv)\n in\n let%map () = assert_r1cs t res one in\n res )\nend\n\nmodule Make_applicative\n (F : Intf.S)\n (A : Intf.Traversable_applicative with module Impl := F.Impl) =\nstruct\n type t = F.t A.t\n\n type 'a t_ = 'a F.t_ A.t\n\n let constant = A.map ~f:F.constant\n\n let to_constant =\n let exception None_exn in\n fun t ->\n try\n Some\n (A.map t ~f:(fun x ->\n match F.to_constant x with Some x -> x | None -> raise None_exn )\n )\n with None_exn -> None\n\n let if_ b ~then_ ~else_ =\n A.sequence (A.map2 then_ else_ ~f:(fun t e -> F.if_ b ~then_:t ~else_:e))\n\n let scale t x = A.map t ~f:(fun a -> F.scale a x)\n\n let scale' t x = A.map t ~f:(fun a -> F.scale x a)\n\n let negate t = A.map t ~f:F.negate\n\n let ( + ) = A.map2 ~f:F.( + )\n\n let ( - ) = A.map2 ~f:F.( - )\n\n let map_ t ~f = A.map t ~f:(F.map_ ~f)\n\n let map2_ t1 t2 ~f = A.map2 t1 t2 ~f:(fun x1 x2 -> F.map2_ x1 x2 ~f)\nend\n\nmodule F (Impl : Snarky_backendless.Snark_intf.S) :\n Intf.S with type 'a Base.t_ = 'a and type 'a A.t = 'a and module Impl = Impl =\nstruct\n module T = struct\n module Unchecked = struct\n include Impl.Field\n module Nat = Snarkette.Nat\n\n let order = Snarkette.Nat.of_string (Bigint.to_string Impl.Field.size)\n\n let to_yojson x = `String (to_string x)\n\n let of_yojson = function\n | `String s ->\n Ok (of_string s)\n | _ ->\n Error \"Field.of_yojson: expected string\"\n end\n\n module Impl = Impl\n open Impl\n\n let map_ t ~f = f t\n\n let map2_ t1 t2 ~f = f t1 t2\n\n module Base = struct\n type 'a t_ = 'a\n\n module Unchecked = struct\n type t = Field.t t_\n\n let to_yojson x = `String (Field.to_string x)\n\n let of_yojson = function\n | `String s ->\n Ok (Field.of_string s)\n | _ ->\n Error \"Field.of_yojson: expected string\"\n end\n\n type t = Field.Var.t t_\n\n let map_ = map_\n end\n\n module A = struct\n type 'a t = 'a\n\n let map = map_\n\n let map2 = map2_\n\n let sequence = Fn.id\n end\n\n type 'a t_ = 'a\n\n let to_list x = [ x ]\n\n type t = Field.Var.t\n\n let if_ = Field.Checked.if_\n\n let typ = Field.typ\n\n let constant = Field.Var.constant\n\n let to_constant = Field.Var.to_constant\n\n let scale = Field.Var.scale\n\n let mul_field = Field.Checked.mul\n\n let assert_r1cs a b c = assert_r1cs a b c\n\n let ( + ) = Field.Checked.( + )\n\n let ( - ) = Field.Checked.( - )\n\n let negate t = Field.Var.scale t Unchecked.(negate one)\n\n let assert_square = `Custom (fun a c -> assert_square a c)\n\n let ( * ) = `Custom Field.Checked.mul\n\n let square = `Custom Field.Checked.square\n\n let inv_exn = `Custom Field.Checked.inv\n\n let real_part = Fn.id\n end\n\n include T\n include Make (T)\nend\n\n(* Given a field F and s : F (called [non_residue] below)\n such that x^2 - s does not have a root in F, construct\n the field F(sqrt(s)) = F[x] / (x^2 - s) *)\nmodule E2\n (F : Intf.S) (Params : sig\n val non_residue : F.Unchecked.t\n\n val mul_by_non_residue : F.t -> F.t\n end) : sig\n include\n Intf.S_with_primitive_element\n with module Impl = F.Impl\n and module Base = F\n and type 'a A.t = 'a * 'a\n\n val unitary_inverse : t -> t\nend = struct\n open Params\n\n module T = struct\n module Base = F\n module Impl = F.Impl\n open Impl\n module Unchecked = Snarkette.Fields.Make_fp2 (F.Unchecked) (Params)\n\n module A = struct\n type 'a t = 'a * 'a\n\n let map (x, y) ~f = (f x, f y)\n\n let map2 (x1, y1) (x2, y2) ~f = (f x1 x2, f y1 y2)\n\n let sequence (x, y) =\n let%map x = x and y = y in\n (x, y)\n end\n\n let to_list (x, y) = F.to_list x @ F.to_list y\n\n (* A value [(a, b) : t] should be thought of as the field element\n a + b sqrt(s). Then all operations are just what follow algebraically. *)\n\n include Make_applicative (Base) (A)\n\n let mul_field (a, b) x =\n let%map a = Base.mul_field a x and b = Base.mul_field b x in\n (a, b)\n\n let typ = Typ.tuple2 F.typ F.typ\n\n (*\n (a + b sqrt(s))^2\n = a^2 + b^2 s + 2 a b sqrt(s)\n\n So it is clear that the second coordinate of the below definition is correct. Let's\n examine the first coordinate.\n\n t - ab - ab sqrt(s)\n = (a + b) (a + s b) - ab - s a b\n = a^2 + a b + s a b + s b^2 - a b - s a b\n = a^2 + s b^2\n\n so this is correct as well.\n *)\n let square (a, b) =\n let open F in\n let%map ab = a * b and t = (a + b) * (a + mul_by_non_residue b) in\n (t - ab - mul_by_non_residue ab, ab + ab)\n\n let assert_square (a, b) (a2, b2) =\n let open F in\n let ab = scale b2 Field.(one / of_int 2) in\n let%map () = assert_r1cs a b ab\n and () =\n assert_r1cs (a + b)\n (a + mul_by_non_residue b)\n (a2 + ab + mul_by_non_residue ab)\n in\n ()\n\n (*\n (a1 + b1 sqrt(s)) (a2 + b2 sqrt(s))\n = (a1 a2 + b1 b2 s) + (a2 b1 + a1 b2) sqrt(s)\n\n So it is clear that the first coordinate is correct. Let's examine the second\n coordinate.\n\n t - a1 a2 - b1 b2\n = (a1 + b1) (a2 + b2) - a1 a2 - b1 b2\n = a1 a2 + b2 b2 + a1 b2 + a2 b1 - a1 a2 - b1 b2\n = a1 b2 + a2 b1\n\n So this is correct as well.\n *)\n let ( * ) (a1, b1) (a2, b2) =\n let open F in\n let%map a = a1 * a2 and b = b1 * b2 and t = (a1 + b1) * (a2 + b2) in\n (a + mul_by_non_residue b, t - a - b)\n\n let mul_by_primitive_element (a, b) = (mul_by_non_residue b, a)\n\n let assert_r1cs (a1, b1) (a2, b2) (a3, b3) =\n let open F in\n let%bind b = b1 * b2 in\n let a = a3 - mul_by_non_residue b in\n let%map () = assert_r1cs a1 a2 a\n and () = assert_r1cs (a1 + b1) (a2 + b2) (b3 + a + b) in\n ()\n\n let square = `Custom square\n\n let ( * ) = `Custom ( * )\n\n let inv_exn = `Define\n\n let assert_square = `Custom assert_square\n\n let real_part (x, _) = Base.real_part x\n end\n\n include T\n include Make (T)\n\n let unitary_inverse (a, b) = (a, Base.negate b)\nend\n\n(* Given a prime order field F and s : F (called [non_residue] below)\n such that x^3 - s is irreducible, construct\n the field F(cube_root(s)) = F[x] / (x^3 - s).\n\n Let S = cube_root(s) in the following.\n*)\n\nmodule T3 = struct\n type 'a t = 'a * 'a * 'a\n\n let map (x, y, z) ~f = (f x, f y, f z)\n\n let map2 (x1, y1, z1) (x2, y2, z2) ~f = (f x1 x2, f y1 y2, f z1 z2)\nend\n\nmodule E3\n (F : Intf.S) (Params : sig\n val non_residue : F.Unchecked.t\n\n val frobenius_coeffs_c1 : F.Unchecked.t array\n\n val frobenius_coeffs_c2 : F.Unchecked.t array\n\n val mul_by_non_residue : F.t -> F.t\n end) :\n Intf.S_with_primitive_element\n with module Impl = F.Impl\n and module Base = F\n and type 'a A.t = 'a * 'a * 'a = struct\n module T = struct\n module Base = F\n module Unchecked = Snarkette.Fields.Make_fp3 (F.Unchecked) (Params)\n module Impl = F.Impl\n open Impl\n\n module A = struct\n include T3\n\n let sequence (x, y, z) =\n let%map x = x and y = y and z = z in\n (x, y, z)\n end\n\n let to_list (x, y, z) = F.to_list x @ F.to_list y @ F.to_list z\n\n include Make_applicative (Base) (A)\n\n let typ = Typ.tuple3 F.typ F.typ F.typ\n\n let mul_field (a, b, c) x =\n let%map a = Base.mul_field a x\n and b = Base.mul_field b x\n and c = Base.mul_field c x in\n (a, b, c)\n\n (*\n (a1 + S b1 + S^2 c1) (a2 + S b2 + S^2 c2)\n = a1 a2 + S a1 b2 + S^2 a1 c2\n + S b1 a2 + S^2 b1 b2 + S^3 b1 c2\n + S^2 c1 a2 + S^3 c1 b2 + S^4 c1 c2\n = a1 a2 + S a1 b2 + S^2 a1 c2\n + S b1 a2 + S^2 b1 b2 + s b1 c2\n + S^2 c1 a2 + s c1 b2 + s S c1 c2\n = (a1 a2 + s b1 c2 + s c1 b2)\n + S (a1 b2 + b1 a2 + s c1 c2)\n + S^2 (a1 c2 + c1 a2 + b1 b2)\n\n Let us examine the three coordinates in turn.\n\n First coordinate:\n a + s (t1 - b - c)\n = a1 a2 + s ( (b1 + c1) (b2 + c2) - b - c)\n = a1 a2 + s (b1 c2 + b2 c1)\n which is evidently correct.\n\n Second coordinate:\n t2 - a - b + s c\n (a1 + b1) (a2 + b2) - a - b + s c\n a1 b2 + b1 a2 + s c\n which is evidently correct.\n\n Third coordinate:\n t3 - a + b - c\n = (a1 + c1) (a2 + c2) - a + b - c\n = a1 c2 + c1 a2 + b\n which is evidently correct.\n *)\n let ( * ) (a1, b1, c1) (a2, b2, c2) =\n with_label __LOC__ (fun () ->\n let open F in\n let%map a = a1 * a2\n and b = b1 * b2\n and c = c1 * c2\n and t1 = (b1 + c1) * (b2 + c2)\n and t2 = (a1 + b1) * (a2 + b2)\n and t3 = (a1 + c1) * (a2 + c2) in\n ( a + Params.mul_by_non_residue (t1 - b - c)\n , t2 - a - b + Params.mul_by_non_residue c\n , t3 - a + b - c ) )\n\n (*\n (a + S b + S^2 c)^2\n = a^2 + S a b + S^2 a c\n + S a b + S^2 b^2 + S^3 b c\n + S^2 a c + S^3 b c + S^4 c^2\n = a^2 + S a b + S^2 a c\n + S a b + S^2 b^2 + s b c\n + S^2 a c + s b c + S s c^2\n = (a^2 + 2 s b c)\n + S (2 a b + s c^2)\n + S^2 (b^2 + 2 a c)\n\n Let us examine the three coordinates in turn.\n\n First coordinate:\n s0 + s s3\n = a^2 + 2 s b c\n which is evidently correct.\n\n Second coordinate:\n s1 + s s4\n = 2 a b + s c^2\n which is evidently correct.\n\n Third coordinate:\n s1 + s2 + s3 - s0 - s4\n = 2 a b + (a - b + c)^2 + 2 b c - a^2 - c^2\n = 2 a b + a^2 - 2 a b + 2 a c - 2 b c + b^2 + c^2 + 2 b c - a^2 - c^2\n = 2 a c + b^2\n which is evidently correct.\n *)\n let square (a, b, c) =\n let open F in\n let%map s0 = square a\n and ab = a * b\n and bc = b * c\n and s2 = square (a - b + c)\n and s4 = square c in\n let s1 = ab + ab in\n let s3 = bc + bc in\n ( s0 + Params.mul_by_non_residue s3\n , s1 + Params.mul_by_non_residue s4\n , s1 + s2 + s3 - s0 - s4 )\n\n let mul_by_primitive_element (a, b, c) = (Params.mul_by_non_residue c, a, b)\n\n let assert_r1cs (a1, b1, c1) (a2, b2, c2) (a3, b3, c3) =\n with_label __LOC__ (fun () ->\n let open F in\n let%bind b = b1 * b2 and c = c1 * c2 and t1 = (b1 + c1) * (b2 + c2) in\n let a = a3 - Params.mul_by_non_residue (t1 - b - c) in\n let%map () = assert_r1cs a1 a2 a\n and () =\n assert_r1cs (a1 + b1) (a2 + b2)\n (b3 + a + b - Params.mul_by_non_residue c)\n and () = assert_r1cs (a1 + c1) (a2 + c2) (c3 + a - b + c) in\n () )\n\n let square = `Custom square\n\n let ( * ) = `Custom ( * )\n\n let inv_exn = `Define\n\n let assert_square = `Define\n\n let real_part (a, _, _) = F.real_part a\n end\n\n include T\n include Make (T)\nend\n\nmodule F3\n (F : Intf.S with type 'a A.t = 'a and type 'a Base.t_ = 'a) (Params : sig\n val non_residue : F.Unchecked.t\n\n val frobenius_coeffs_c1 : F.Unchecked.t array\n\n val frobenius_coeffs_c2 : F.Unchecked.t array\n end) :\n Intf.S_with_primitive_element\n with module Impl = F.Impl\n and module Base = F\n and type 'a A.t = 'a * 'a * 'a = struct\n module T = struct\n module Base = F\n module Unchecked = Snarkette.Fields.Make_fp3 (F.Unchecked) (Params)\n module Impl = F.Impl\n open Impl\n\n let mul_by_primitive_element (a, b, c) = (F.scale c Params.non_residue, a, b)\n\n module A = struct\n include T3\n\n let sequence (x, y, z) =\n let%map x = x and y = y and z = z in\n (x, y, z)\n end\n\n let to_list (x, y, z) = [ x; y; z ]\n\n include Make_applicative (Base) (A)\n\n let typ = Typ.tuple3 F.typ F.typ F.typ\n\n let mul_field (a, b, c) x =\n let%map a = Base.mul_field a x\n and b = Base.mul_field b x\n and c = Base.mul_field c x in\n (a, b, c)\n\n let assert_r1cs (a0, a1, a2) (b0, b1, b2) (c0, c1, c2) =\n let open F in\n let%bind v0 = a0 * b0 and v4 = a2 * b2 in\n let beta = Params.non_residue in\n let beta_inv = F.Unchecked.inv beta in\n let%map () =\n assert_r1cs\n (a0 + a1 + a2)\n (b0 + b1 + b2)\n ( c1 + c2 + F.scale c0 beta_inv\n + F.(scale v0 Unchecked.(one - beta_inv))\n + F.(scale v4 Unchecked.(one - beta)) )\n and () =\n assert_r1cs\n (a0 - a1 + a2)\n (b0 - b1 + b2)\n ( c2 - c1\n + F.(scale v0 Unchecked.(one + beta_inv))\n - F.scale c0 beta_inv\n + F.(scale v4 Unchecked.(one + beta)) )\n and () =\n let two = Impl.Field.of_int 2 in\n let four = Impl.Field.of_int 4 in\n let sixteen = Impl.Field.of_int 16 in\n let eight_beta_inv = Impl.Field.(mul (of_int 8) beta_inv) in\n assert_r1cs\n (a0 + F.scale a1 two + F.scale a2 four)\n (b0 + F.scale b1 two + F.scale b2 four)\n ( F.scale c1 two + F.scale c2 four + F.scale c0 eight_beta_inv\n + F.(scale v0 Unchecked.(one - eight_beta_inv))\n + F.(scale v4 Unchecked.(sixteen - (beta + beta))) )\n in\n ()\n\n let ( * ) = `Define\n\n let inv_exn = `Define\n\n let square = `Define\n\n let assert_square = `Define\n\n let real_part (a, _, _) = F.real_part a\n end\n\n include T\n include Make (T)\nend\n\nmodule Cyclotomic_square = struct\n module Make_F4 (F2 : Intf.S_with_primitive_element) = struct\n let cyclotomic_square (c0, c1) =\n let open F2 in\n let open Impl in\n let%map b_squared = square (c0 + c1) and a = square c1 in\n let c = b_squared - a in\n let d = mul_by_primitive_element a in\n let e = c - d in\n let f = scale d (Field.of_int 2) + one in\n let g = e - one in\n (f, g)\n end\n\n module Make_F6\n (F2 : Intf.S_with_primitive_element\n with type 'a A.t = 'a * 'a\n and type 'a Base.t_ = 'a)\n (Params : sig\n val cubic_non_residue : F2.Impl.Field.t\n end) =\n struct\n let cyclotomic_square ((x00, x01, x02), (x10, x11, x12)) =\n let open F2.Impl in\n let ((a0, a1) as a) = (x00, x11) in\n let ((b0, b1) as b) = (x10, x02) in\n let ((c0, c1) as c) = (x01, x12) in\n let%map asq0, asq1 = F2.square a\n and bsq0, bsq1 = F2.square b\n and csq0, csq1 = F2.square c in\n let fpos x y =\n Field.(Var.(add (scale x (of_int 3)) (scale y (of_int 2))))\n in\n let fneg x y =\n Field.(Var.(sub (scale x (of_int 3)) (scale y (of_int 2))))\n in\n ( (fneg asq0 a0, fneg bsq0 c0, fneg csq0 b1)\n , ( fpos (Field.Var.scale csq1 Params.cubic_non_residue) b0\n , fpos asq1 a1\n , fpos bsq1 c1 ) )\n end\nend\n\nmodule F6\n (Fq : Intf.S with type 'a A.t = 'a and type 'a Base.t_ = 'a)\n (Fq2 : Intf.S_with_primitive_element\n with module Impl = Fq.Impl\n and type 'a A.t = 'a * 'a\n and type 'a Base.t_ = 'a Fq.t_)\n (Fq3 : sig\n include\n Intf.S_with_primitive_element\n with module Impl = Fq.Impl\n and type 'a A.t = 'a * 'a * 'a\n and type 'a Base.t_ = 'a Fq.t_\n\n module Params : sig\n val non_residue : Fq.Unchecked.t\n\n val frobenius_coeffs_c1 : Fq.Unchecked.t array\n\n val frobenius_coeffs_c2 : Fq.Unchecked.t array\n end\n end) (Params : sig\n val frobenius_coeffs_c1 : Fq.Unchecked.t array\n end) =\nstruct\n include\n E2\n (Fq3)\n (struct\n let non_residue : Fq3.Unchecked.t = Fq.Unchecked.(zero, one, zero)\n\n let mul_by_non_residue = Fq3.mul_by_primitive_element\n end)\n\n let fq_mul_by_non_residue x = Fq.scale x Fq3.Params.non_residue\n\n let special_mul (a0, a1) (b0, b1) =\n let open Impl in\n let%bind v1 = Fq3.(a1 * b1) in\n let%bind v0 =\n let a00, a01, a02 = a0 in\n let _, _, b02 = b0 in\n let%map a00b02 = Fq.(a00 * b02)\n and a01b02 = Fq.(a01 * b02)\n and a02b02 = Fq.(a02 * b02) in\n (fq_mul_by_non_residue a01b02, fq_mul_by_non_residue a02b02, a00b02)\n in\n let beta_v1 = Fq3.mul_by_primitive_element v1 in\n let%map t = Fq3.((a0 + a1) * (b0 + b1)) in\n Fq3.(v0 + beta_v1, t - v0 - v1)\n\n let assert_special_mul ((((a00, a01, a02) as a0), a1) : t)\n ((((_, _, b02) as b0), b1) : t) ((c00, c01, c02), c1) =\n let open Impl in\n let%bind ((v10, v11, v12) as v1) = Fq3.(a1 * b1) in\n let%bind v0 =\n exists Fq3.typ\n ~compute:\n As_prover.(\n map2 ~f:Fq3.Unchecked.( * ) (read Fq3.typ a0) (read Fq3.typ b0))\n (* v0\n = (a00 + s a01 s^2 a02) (s^2 b02)\n = non_residue a01 b02 + non_residue s a02 b02 + s^2 a00 b02 *)\n in\n let%map () =\n let%map () =\n Fq.assert_r1cs a01\n (Fq.scale b02 Fq3.Params.non_residue)\n (Field.Var.linear_combination\n [ (Field.one, c00); (Field.negate Fq3.Params.non_residue, v12) ] )\n and () =\n Fq.assert_r1cs a02 (Fq.scale b02 Fq3.Params.non_residue) Fq.(c01 - v10)\n and () = Fq.assert_r1cs a00 b02 Fq.(c02 - v11) in\n ()\n and () = Fq3.assert_r1cs Fq3.(a0 + a1) Fq3.(b0 + b1) Fq3.(c1 + v0 + v1) in\n ()\n\n let special_div_unsafe a b =\n let open Impl in\n let%bind result =\n exists typ\n ~compute:As_prover.(map2 ~f:Unchecked.( / ) (read typ a) (read typ b))\n in\n (* result * b = a *)\n let%map () = assert_special_mul result b a in\n result\n\n (* TODO: Make sure this is ok *)\n let special_div = special_div_unsafe\n\n include\n Cyclotomic_square.Make_F6\n (Fq2)\n (struct\n let cubic_non_residue = Fq3.Params.non_residue\n end)\n\n let frobenius ((c00, c01, c02), (c10, c11, c12)) power =\n let module Field = Impl.Field in\n let p3 = power mod 3 in\n let p6 = power mod 6 in\n let ( * ) s x = Field.Var.scale x s in\n ( ( c00\n , Fq3.Params.frobenius_coeffs_c1.(p3) * c01\n , Fq3.Params.frobenius_coeffs_c2.(p3) * c02 )\n , ( Params.frobenius_coeffs_c1.(p6) * c10\n , Field.mul\n Params.frobenius_coeffs_c1.(p6)\n Fq3.Params.frobenius_coeffs_c1.(p3)\n * c11\n , Field.mul\n Params.frobenius_coeffs_c1.(p6)\n Fq3.Params.frobenius_coeffs_c2.(p3)\n * c12 ) )\nend\n\nmodule F4\n (Fq2 : Intf.S_with_primitive_element\n with type 'a A.t = 'a * 'a\n and type 'a Base.t_ = 'a)\n (Params : sig\n val frobenius_coeffs_c1 : Fq2.Impl.Field.t array\n end) =\nstruct\n include\n E2\n (Fq2)\n (struct\n let non_residue = Fq2.Impl.Field.(zero, one)\n\n let mul_by_non_residue = Fq2.mul_by_primitive_element\n end)\n\n let special_mul = ( * )\n\n (* TODO: Make sure this is ok *)\n let special_div = div_unsafe\n\n include Cyclotomic_square.Make_F4 (Fq2)\n\n let frobenius ((c00, c01), (c10, c11)) power =\n let module Field = Impl.Field in\n let p2 = Params.frobenius_coeffs_c1.(Int.( * ) (power mod 2) 2) in\n let p4 = Params.frobenius_coeffs_c1.(power mod 4) in\n let ( * ) s x = Field.Var.scale x s in\n ((c00, p2 * c01), (p4 * c10, Field.(p4 * p2) * c11))\nend\n","module Bignum_bigint = Bigint\nopen Core_kernel\n\nmodule type Params_intf = sig\n type field\n\n val a : field\n\n val b : field\nend\n\nmodule type Scalar_intf = sig\n type (_, _) typ\n\n type (_, _) checked\n\n type boolean_var\n\n type var\n\n type t [@@deriving equal, sexp]\n\n val typ : (var, t) typ\n\n val length_in_bits : int\n\n val test_bit : t -> int -> bool\n\n module Checked : sig\n val equal : var -> var -> (boolean_var, _) checked\n\n module Assert : sig\n val equal : var -> var -> (unit, _) checked\n end\n end\nend\n\nmodule type Shifted_intf = sig\n type _ checked\n\n type boolean_var\n\n type curve_var\n\n type t\n\n val zero : t\n\n val add : t -> curve_var -> t checked\n\n (* This is only safe if the result is guaranteed to not be zero. *)\n\n val unshift_nonzero : t -> curve_var checked\n\n val if_ : boolean_var -> then_:t -> else_:t -> t checked\n\n module Assert : sig\n val equal : t -> t -> unit checked\n end\nend\n\nmodule type Weierstrass_checked_intf = sig\n module Impl : Snarky_backendless.Snark_intf.S\n\n open Impl\n\n type unchecked\n\n type t\n\n val typ : (t, unchecked) Typ.t\n\n module Shifted : sig\n module type S =\n Shifted_intf\n with type 'a checked := 'a Checked.t\n and type curve_var := t\n and type boolean_var := Boolean.var\n\n type 'a m = (module S with type t = 'a)\n\n val create : unit -> (module S) Checked.t\n end\n\n val negate : t -> t\n\n val constant : unchecked -> t\n\n val add_unsafe :\n t -> t -> [ `I_thought_about_this_very_carefully of t ] Checked.t\n\n val if_ : Boolean.var -> then_:t -> else_:t -> t Checked.t\n\n val double : t -> t Checked.t\n\n val if_value : Boolean.var -> then_:unchecked -> else_:unchecked -> t\n\n val scale :\n 's Shifted.m\n -> t\n -> Boolean.var Bitstring_lib.Bitstring.Lsb_first.t\n -> init:'s\n -> 's Checked.t\n\n val scale_known :\n 's Shifted.m\n -> unchecked\n -> Boolean.var Bitstring_lib.Bitstring.Lsb_first.t\n -> init:'s\n -> 's Checked.t\n\n val sum : 's Shifted.m -> t list -> init:'s -> 's Checked.t\n\n module Assert : sig\n val on_curve : t -> unit Checked.t\n\n val equal : t -> t -> unit Checked.t\n end\nend\n\nmodule Make_weierstrass_checked\n (F : Snarky_field_extensions.Intf.S) (Scalar : sig\n type t\n\n val of_int : int -> t\n end) (Curve : sig\n type t\n\n val random : unit -> t\n\n val to_affine_exn : t -> F.Unchecked.t * F.Unchecked.t\n\n val of_affine : F.Unchecked.t * F.Unchecked.t -> t\n\n val double : t -> t\n\n val ( + ) : t -> t -> t\n\n val negate : t -> t\n\n val scale : t -> Scalar.t -> t\n end)\n (Params : Params_intf with type field := F.Unchecked.t) (Override : sig\n val add : (F.t * F.t -> F.t * F.t -> (F.t * F.t) F.Impl.Checked.t) option\n end) :\n Weierstrass_checked_intf\n with module Impl := F.Impl\n and type unchecked := Curve.t\n and type t = F.t * F.t = struct\n open F.Impl\n\n type t = F.t * F.t\n\n let assert_on_curve (x, y) =\n let open F in\n let%bind x2 = square x in\n let%bind x3 = x2 * x in\n let%bind ax = constant Params.a * x in\n assert_square y (x3 + ax + constant Params.b)\n\n let typ : (t, Curve.t) Typ.t =\n let (Typ unchecked) =\n Typ.transport\n Typ.(tuple2 F.typ F.typ)\n ~there:Curve.to_affine_exn ~back:Curve.of_affine\n in\n Typ { unchecked with check = assert_on_curve }\n\n let negate ((x, y) : t) : t = (x, F.negate y)\n\n let constant (t : Curve.t) : t =\n let x, y = Curve.to_affine_exn t in\n F.(constant x, constant y)\n\n let assert_equal (x1, y1) (x2, y2) =\n let%map () = F.assert_equal x1 x2 and () = F.assert_equal y1 y2 in\n ()\n\n module Assert = struct\n let on_curve = assert_on_curve\n\n let equal = assert_equal\n end\n\n open Let_syntax\n\n let%snarkydef_ add' ~div (ax, ay) (bx, by) =\n let open F in\n let%bind lambda = div (by - ay) (bx - ax) in\n let%bind cx =\n exists typ\n ~compute:\n (let open As_prover in\n let open Let_syntax in\n let%map ax = read typ ax\n and bx = read typ bx\n and lambda = read typ lambda in\n Unchecked.(square lambda - (ax + bx)))\n in\n let%bind () =\n (* lambda^2 = cx + ax + bx\n cx = lambda^2 - (ax + bc)\n *)\n assert_square lambda F.(cx + ax + bx)\n in\n let%bind cy =\n exists typ\n ~compute:\n (let open As_prover in\n let open Let_syntax in\n let%map ax = read typ ax\n and ay = read typ ay\n and cx = read typ cx\n and lambda = read typ lambda in\n Unchecked.((lambda * (ax - cx)) - ay))\n in\n let%map () = assert_r1cs lambda (ax - cx) (cy + ay) in\n (cx, cy)\n\n let add' ~div p1 p2 =\n match Override.add with Some add -> add p1 p2 | None -> add' ~div p1 p2\n\n (* This function MUST NOT be called UNLESS you are certain the two points\n on which it is called are not equal. If it is called on equal points,\n the prover can return almost any curve point they want to from this function. *)\n let add_unsafe p q =\n let%map r = add' ~div:F.div_unsafe p q in\n `I_thought_about_this_very_carefully r\n\n let add_exn p q = add' ~div:(fun x y -> F.inv_exn y >>= F.(( * ) x)) p q\n\n (* TODO-someday: Make it so this doesn't have to compute both branches *)\n let if_ b ~then_:(tx, ty) ~else_:(ex, ey) =\n let%map x = F.if_ b ~then_:tx ~else_:ex\n and y = F.if_ b ~then_:ty ~else_:ey in\n (x, y)\n\n module Shifted = struct\n module type S =\n Shifted_intf\n with type 'a checked := 'a Checked.t\n and type curve_var := t\n and type boolean_var := Boolean.var\n\n type 'a m = (module S with type t = 'a)\n\n module Make (M : sig\n val shift : t\n end) : S = struct\n open M\n\n type nonrec t = t\n\n let zero = shift\n\n let if_ = if_\n\n let unshift_nonzero shifted = add_exn (negate shift) shifted\n\n let add shifted x = add_exn shifted x\n\n module Assert = struct\n let equal = assert_equal\n end\n end\n\n let create () : (module S) Checked.t =\n let%map shift =\n exists typ ~compute:As_prover.(map (return ()) ~f:Curve.random)\n in\n let module M = Make (struct\n let shift = shift\n end) in\n (module M : S)\n end\n\n let%snarkydef_ double (ax, ay) =\n let open F in\n let%bind x_squared = square ax in\n let%bind lambda =\n exists typ\n ~compute:\n As_prover.(\n map2 (read typ x_squared) (read typ ay) ~f:(fun x_squared ay ->\n let open F.Unchecked in\n (x_squared + x_squared + x_squared + Params.a) * inv (ay + ay) ))\n in\n let%bind bx =\n exists typ\n ~compute:\n As_prover.(\n map2 (read typ lambda) (read typ ax) ~f:(fun lambda ax ->\n let open F.Unchecked in\n square lambda - (ax + ax) ))\n in\n let%bind by =\n exists typ\n ~compute:\n (let open As_prover in\n let open Let_syntax in\n let%map lambda = read typ lambda\n and ax = read typ ax\n and ay = read typ ay\n and bx = read typ bx in\n F.Unchecked.((lambda * (ax - bx)) - ay))\n in\n let two = Field.of_int 2 in\n let%map () =\n assert_r1cs (F.scale lambda two) ay\n (F.scale x_squared (Field.of_int 3) + F.constant Params.a)\n and () = assert_square lambda (bx + F.scale ax two)\n and () = assert_r1cs lambda (ax - bx) (by + ay) in\n (bx, by)\n\n let if_value (cond : Boolean.var) ~then_ ~else_ =\n let x1, y1 = Curve.to_affine_exn then_ in\n let x2, y2 = Curve.to_affine_exn else_ in\n let cond = (cond :> Field.Var.t) in\n let choose a1 a2 =\n let open Field.Checked in\n F.map2_ a1 a2 ~f:(fun a1 a2 ->\n (a1 * cond) + (a2 * (Field.Var.constant Field.one - cond)) )\n in\n (choose x1 x2, choose y1 y2)\n\n let%snarkydef_ scale (type shifted)\n (module Shifted : Shifted.S with type t = shifted) t\n (c : Boolean.var Bitstring_lib.Bitstring.Lsb_first.t) ~(init : shifted) :\n shifted Checked.t =\n let c = Bitstring_lib.Bitstring.Lsb_first.to_list c in\n let open Let_syntax in\n let rec go i bs0 acc pt =\n match bs0 with\n | [] ->\n return acc\n | b :: bs ->\n let%bind acc' =\n with_label (sprintf \"acc_%d\" i) (fun () ->\n let%bind add_pt = Shifted.add acc pt in\n let don't_add_pt = acc in\n Shifted.if_ b ~then_:add_pt ~else_:don't_add_pt )\n and pt' = double pt in\n go (i + 1) bs acc' pt'\n in\n go 0 c init t\n\n (* This 'looks up' a field element from a lookup table of size 2^2 = 4 with\n a 2 bit index. See https://github.com/zcash/zcash/issues/2234#issuecomment-383736266 for\n a discussion of this trick.\n *)\n let lookup_point (b0, b1) (t1, t2, t3, t4) =\n let%map b0_and_b1 = Boolean.( && ) b0 b1 in\n let lookup_one (a1, a2, a3, a4) =\n let open F.Unchecked in\n let ( * ) x b = F.map_ x ~f:(fun x -> Field.Var.scale b x) in\n let ( +^ ) = F.( + ) in\n F.constant a1\n +^ ((a2 - a1) * (b0 :> Field.Var.t))\n +^ ((a3 - a1) * (b1 :> Field.Var.t))\n +^ ((a4 + a1 - a2 - a3) * (b0_and_b1 :> Field.Var.t))\n in\n let x1, y1 = Curve.to_affine_exn t1\n and x2, y2 = Curve.to_affine_exn t2\n and x3, y3 = Curve.to_affine_exn t3\n and x4, y4 = Curve.to_affine_exn t4 in\n (lookup_one (x1, x2, x3, x4), lookup_one (y1, y2, y3, y4))\n\n (* Similar to the above, but doing lookup in a size 1 table *)\n let lookup_single_bit (b : Boolean.var) (t1, t2) =\n let lookup_one (a1, a2) =\n let open F in\n constant a1\n + map_ Unchecked.(a2 - a1) ~f:(Field.Var.scale (b :> Field.Var.t))\n in\n let x1, y1 = Curve.to_affine_exn t1 and x2, y2 = Curve.to_affine_exn t2 in\n (lookup_one (x1, x2), lookup_one (y1, y2))\n\n let scale_known (type shifted)\n (module Shifted : Shifted.S with type t = shifted) (t : Curve.t)\n (b : Boolean.var Bitstring_lib.Bitstring.Lsb_first.t) ~init =\n let b = Bitstring_lib.Bitstring.Lsb_first.to_list b in\n let sigma = t in\n let n = List.length b in\n let sigma_count = (n + 1) / 2 in\n\n (* = ceil (n / 2.0) *)\n (* We implement a complicated optimzation so that in total\n this costs roughly (1 + 3) * (n / 2) constraints, rather than\n the naive 4*n + 3*n. If scalars were represented with some\n kind of signed digit representation we could probably get it\n down to 2 * (n / 3) + 3 * (n / 3).\n *)\n (* Assume n is even *)\n (* Define\n to_term_unshifted i (b0, b1) =\n match b0, b1 with\n | false, false -> oo\n | true, false -> 2^i * t\n | false, true -> 2^{i+1} * t\n | true, true -> 2^i * t + 2^{i + 1} t\n\n to_term i (b0, b1) =\n sigma + to_term_unshifted i (b0, b1) =\n match b0, b1 with\n | false, false -> sigma\n | true, false -> sigma + 2^i * t\n | false, true -> sigma + 2^{i+1} * t\n | true, true -> sigma + 2^i * t + 2^{i + 1} t\n *)\n let to_term ~two_to_the_i ~two_to_the_i_plus_1 bits =\n lookup_point bits\n ( sigma\n , Curve.(sigma + two_to_the_i)\n , Curve.(sigma + two_to_the_i_plus_1)\n , Curve.(sigma + two_to_the_i + two_to_the_i_plus_1) )\n in\n\n (*\n Say b = b0, b1, .., b_{n-1}.\n We compute\n\n (to_term 0 (b0, b1)\n + to_term 2 (b2, b3)\n + to_term 4 (b4, b5)\n + ...\n + to_term (n-2) (b_{n-2}, b_{n-1}))\n - (n/2) * sigma\n =\n (n/2)*sigma + (b0*2^0 + b1*21 + ... + b_{n-1}*2^{n-1}) t - (n/2) * sigma\n =\n (n/2)*sigma + b * t - (n/2)*sigma\n = b * t\n *)\n let open Let_syntax in\n (* TODO #1152\n Can get away with using an unsafe add if we modify this a bit. *)\n let rec go acc two_to_the_i bits =\n match bits with\n | [] ->\n return acc\n | [ b_i ] ->\n let term =\n lookup_single_bit b_i (sigma, Curve.(sigma + two_to_the_i))\n in\n Shifted.add acc term\n | b_i :: b_i_plus_1 :: rest ->\n let two_to_the_i_plus_1 = Curve.double two_to_the_i in\n let%bind term =\n to_term ~two_to_the_i ~two_to_the_i_plus_1 (b_i, b_i_plus_1)\n in\n let%bind acc = Shifted.add acc term in\n go acc (Curve.double two_to_the_i_plus_1) rest\n in\n let%bind result_with_shift = go init t b in\n let unshift =\n Curve.scale (Curve.negate sigma) (Scalar.of_int sigma_count)\n in\n Shifted.add result_with_shift (constant unshift)\n\n let to_constant (x, y) =\n let open Option.Let_syntax in\n let%map x = F.to_constant x and y = F.to_constant y in\n Curve.of_affine (x, y)\n\n let scale m t c ~init =\n match to_constant t with\n | Some t ->\n scale_known m t c ~init\n | None ->\n scale m t c ~init\n\n let sum (type shifted) (module Shifted : Shifted.S with type t = shifted) xs\n ~init =\n let open Let_syntax in\n let rec go acc = function\n | [] ->\n return acc\n | t :: ts ->\n let%bind acc' = Shifted.add acc t in\n go acc' ts\n in\n go init xs\nend\n","module Length = struct\n type 'a t = ('a list, int) Sigs.predicate2\n\n let equal l len = Caml.List.compare_length_with l len = 0\n\n let unequal l len = Caml.List.compare_length_with l len <> 0\n\n let gte l len = Caml.List.compare_length_with l len >= 0\n\n let gt l len = Caml.List.compare_length_with l len > 0\n\n let lte l len = Caml.List.compare_length_with l len <= 0\n\n let lt l len = Caml.List.compare_length_with l len < 0\n\n module Compare = struct\n let ( = ) = equal\n\n let ( <> ) = unequal\n\n let ( >= ) = gte\n\n let ( > ) = gt\n\n let ( <= ) = lte\n\n let ( < ) = lt\n end\nend\n","open Core_kernel\ninclude Result\nopen Let_syntax\n\nmodule List = struct\n let map ls ~f =\n let%map r =\n List.fold_result ls ~init:[] ~f:(fun t el ->\n let%map h = f el in\n h :: t )\n in\n List.rev r\nend\n","(* bits_intf.ml *)\n\n[%%import \"/src/config.mlh\"]\n\nopen Fold_lib\n\nmodule type Basic = sig\n type t\n\n val fold : t -> bool Fold.t\n\n val size_in_bits : int\nend\n\nmodule type S = sig\n include Basic\n\n val iter : t -> f:(bool -> unit) -> unit\n\n val to_bits : t -> bool list\nend\n\nmodule type Convertible_bits = sig\n include S\n\n val of_bits : bool list -> t\nend\n\n[%%ifdef consensus_mechanism]\n\nopen Tuple_lib\n\nmodule Snarkable = struct\n module type Basic = sig\n type (_, _) typ\n\n type _ checked\n\n type boolean_var\n\n val size_in_bits : int\n\n module Packed : sig\n type var\n\n type value\n\n val typ : (var, value) typ\n\n val size_in_bits : int\n end\n\n module Unpacked : sig\n type var\n\n type value\n\n val typ : (var, value) typ\n\n val var_to_bits : var -> boolean_var Bitstring_lib.Bitstring.Lsb_first.t\n\n val var_of_bits : boolean_var Bitstring_lib.Bitstring.Lsb_first.t -> var\n\n val var_to_triples : var -> boolean_var Triple.t list\n\n val var_of_value : value -> var\n\n val size_in_bits : int\n end\n end\n\n module type Lossy = sig\n include Basic\n\n val project_value : Unpacked.value -> Packed.value\n\n val unpack_value : Packed.value -> Unpacked.value\n\n val project_var : Unpacked.var -> Packed.var\n\n val choose_preimage_var : Packed.var -> Unpacked.var checked\n end\n\n module type Faithful = sig\n include Basic\n\n val pack_value : Unpacked.value -> Packed.value\n\n val unpack_value : Packed.value -> Unpacked.value\n\n val pack_var : Unpacked.var -> Packed.var\n\n val unpack_var : Packed.var -> Unpacked.var checked\n end\n\n module type Small = sig\n type comparison_result\n\n type field_var\n\n include Faithful with type Packed.var = private field_var\n\n val compare_var : Unpacked.var -> Unpacked.var -> comparison_result checked\n\n val increment_var : Unpacked.var -> Unpacked.var checked\n\n val increment_if_var : Unpacked.var -> boolean_var -> Unpacked.var checked\n\n val assert_equal_var : Unpacked.var -> Unpacked.var -> unit checked\n\n val equal_var : Unpacked.var -> Unpacked.var -> boolean_var checked\n\n val var_of_field : field_var -> Unpacked.var checked\n\n val var_of_field_unsafe : field_var -> Packed.var\n\n val if_ :\n boolean_var\n -> then_:Unpacked.var\n -> else_:Unpacked.var\n -> Unpacked.var checked\n end\nend\n\n[%%endif]\n","open Core_kernel\n\nmodule Make (Impl : Snarky_backendless.Snark_intf.S) = struct\n open Impl\n open Let_syntax\n\n let pack_int bs =\n assert (List.length bs < 62) ;\n let rec go pt acc = function\n | [] ->\n acc\n | b :: bs ->\n if b then go (2 * pt) (pt + acc) bs else go (2 * pt) acc bs\n in\n go 1 0 bs\n\n let boolean_assert_lte (x : Boolean.var) (y : Boolean.var) =\n (*\n x <= y\n y == 1 or x = 0\n (y - 1) * x = 0\n *)\n assert_r1cs\n Field.Var.(sub (y :> Field.Var.t) (constant Field.one))\n (x :> Field.Var.t)\n (Field.Var.constant Field.zero)\n\n let assert_decreasing : Boolean.var list -> unit Checked.t =\n let rec go prev (bs0 : Boolean.var list) =\n match bs0 with\n | [] ->\n return ()\n | b :: bs ->\n let%bind () = boolean_assert_lte b prev in\n go b bs\n in\n function [] -> return () | b :: bs -> go b bs\n\n let nth_bit x ~n = (x lsr n) land 1 = 1\n\n let apply_mask mask bs = Checked.all (List.map2_exn mask bs ~f:Boolean.( && ))\n\n let pack_unsafe (bs0 : Boolean.var list) =\n let n = List.length bs0 in\n assert (n <= Field.size_in_bits) ;\n let rec go acc two_to_the_i = function\n | b :: bs ->\n go\n (Field.Var.add acc (Field.Var.scale b two_to_the_i))\n (Field.add two_to_the_i two_to_the_i)\n bs\n | [] ->\n acc\n in\n go (Field.Var.constant Field.zero) Field.one (bs0 :> Field.Var.t list)\n\n type _ Snarky_backendless.Request.t +=\n | N_ones : bool list Snarky_backendless.Request.t\n\n let n_ones ~total_length n =\n let%bind bs =\n exists\n (Typ.list ~length:total_length Boolean.typ)\n ~request:(As_prover.return N_ones)\n ~compute:\n As_prover.(\n map (read_var n) ~f:(fun n ->\n List.init total_length ~f:(fun i ->\n Bigint.(\n compare (of_field (Field.of_int i)) (of_field n) < 0) ) ))\n in\n let%map () =\n Field.Checked.Assert.equal\n (Field.Var.sum (bs :> Field.Var.t list))\n (* This can't overflow since the field is huge *)\n n\n and () = assert_decreasing bs in\n bs\n\n let assert_num_bits_upper_bound bs u =\n let total_length = List.length bs in\n assert (total_length < Field.size_in_bits) ;\n let%bind mask = n_ones ~total_length u in\n let%bind masked = apply_mask mask bs in\n with_label __LOC__ (fun () ->\n Field.Checked.Assert.equal (pack_unsafe masked) (pack_unsafe bs) )\n\n let num_bits_int =\n let rec go acc n = if n = 0 then acc else go (1 + acc) (n lsr 1) in\n go 0\n\n let size_in_bits_size_in_bits = num_bits_int Field.size_in_bits\n\n type _ Snarky_backendless.Request.t +=\n | Num_bits_upper_bound : Field.t Snarky_backendless.Request.t\n\n let num_bits_upper_bound_unchecked x =\n let num_bits =\n match\n List.find_mapi\n (List.rev (Field.unpack x))\n ~f:(fun i x -> if x then Some i else None)\n with\n | Some leading_zeroes ->\n Field.size_in_bits - leading_zeroes\n | None ->\n 0\n in\n num_bits\n\n (* Someday: this could definitely be made more efficient *)\n let num_bits_upper_bound_unpacked : Boolean.var list -> Field.Var.t Checked.t\n =\n fun x_unpacked ->\n let%bind res =\n exists Typ.field\n ~request:(As_prover.return Num_bits_upper_bound)\n ~compute:\n As_prover.(\n map\n (read_var (Field.Var.project x_unpacked))\n ~f:(fun x -> Field.of_int (num_bits_upper_bound_unchecked x)))\n in\n let%map () = assert_num_bits_upper_bound x_unpacked res in\n res\n\n let num_bits_upper_bound ~max_length (x : Field.Var.t) : Field.Var.t Checked.t\n =\n Field.Checked.unpack x ~length:max_length >>= num_bits_upper_bound_unpacked\n\n let%test_module \"Snark_util\" =\n ( module struct\n let () = Random.init 123456789\n\n let random_bitstring length =\n List.init length ~f:(fun _ -> Random.bool ())\n\n let random_n_bit_field_elt n = Field.project (random_bitstring n)\n\n let%test_unit \"compare\" =\n let bit_length = Field.size_in_bits - 2 in\n let random () = random_n_bit_field_elt bit_length in\n let test () =\n let x = random () in\n let y = random () in\n let less, less_or_equal =\n run_and_check\n (let%map { less; less_or_equal } =\n Field.Checked.compare ~bit_length (Field.Var.constant x)\n (Field.Var.constant y)\n in\n As_prover.(\n map2 (read Boolean.typ less)\n (read Boolean.typ less_or_equal)\n ~f:Tuple2.create) )\n |> Or_error.ok_exn\n in\n let r = Bigint.(compare (of_field x) (of_field y)) in\n assert (Bool.equal less (r < 0)) ;\n assert (Bool.equal less_or_equal (r <= 0))\n in\n for _i = 0 to 100 do\n test ()\n done\n\n let%test_unit \"boolean_assert_lte\" =\n Or_error.ok_exn\n (check\n (Checked.all_unit\n [ boolean_assert_lte Boolean.false_ Boolean.false_\n ; boolean_assert_lte Boolean.false_ Boolean.true_\n ; boolean_assert_lte Boolean.true_ Boolean.true_\n ] ) ) ;\n assert (\n Or_error.is_error\n (check (boolean_assert_lte Boolean.true_ Boolean.false_)) )\n\n let%test_unit \"assert_decreasing\" =\n let decreasing bs =\n check (assert_decreasing (List.map ~f:Boolean.var_of_value bs))\n in\n Or_error.ok_exn (decreasing [ true; true; true; false ]) ;\n Or_error.ok_exn (decreasing [ true; true; false; false ]) ;\n assert (Or_error.is_error (decreasing [ true; true; false; true ]))\n\n let%test_unit \"n_ones\" =\n let total_length = 6 in\n let test n =\n let t () =\n n_ones ~total_length (Field.Var.constant (Field.of_int n))\n in\n let handle_with (resp : bool list) =\n handle t (fun (With { request; respond }) ->\n match request with\n | N_ones ->\n respond (Provide resp)\n | _ ->\n unhandled )\n in\n let correct = Int.pow 2 n - 1 in\n let to_bits k =\n List.init total_length ~f:(fun i -> (k lsr i) land 1 = 1)\n in\n for i = 0 to Int.pow 2 total_length - 1 do\n if i = correct then\n Or_error.ok_exn (check (handle_with (to_bits i)))\n else assert (Or_error.is_error (check (handle_with (to_bits i))))\n done\n in\n for n = 0 to total_length do\n test n\n done\n\n let%test_unit \"num_bits_int\" =\n assert (num_bits_int 1 = 1) ;\n assert (num_bits_int 5 = 3) ;\n assert (num_bits_int 17 = 5)\n\n let%test_unit \"num_bits_upper_bound_unchecked\" =\n let f k bs =\n assert (num_bits_upper_bound_unchecked (Field.project bs) = k)\n in\n f 3 [ true; true; true; false; false ] ;\n f 4 [ true; true; true; true; false ] ;\n f 3 [ true; false; true; false; false ] ;\n f 5 [ true; false; true; false; true ]\n\n (*let%test_unit \"num_bits_upper_bound\" =\n let max_length = Field.size_in_bits - 1 in\n let test x =\n let handle_with resp =\n handle\n (num_bits_upper_bound ~max_length (Field.Var.constant x))\n (fun (With {request; respond}) ->\n match request with\n | Num_bits_upper_bound -> respond (Field.of_int resp)\n | _ -> unhandled)\n in\n let true_answer = num_bits_upper_bound_unchecked x in\n for i = 0 to true_answer - 1 do\n if check (handle_with i) ()\n then begin\n let n = Bigint.of_field x in\n failwithf !\"Shouldn't have passed: x=%s, i=%d\"\n (String.init max_length ~f:(fun j -> if Bigint.test_bit n j then '1' else '0'))\n i ();\n end;\n done;\n assert (check (handle_with true_answer) ())\n in\n test (random_n_bit_field_elt max_length)*)\n end )\nend\n","open Snark_bits\n\nmodule type S = sig\n include Snarky_backendless.Snark_intf.S\n\n module Snarkable : sig\n module type S = sig\n type var\n\n type value\n\n val typ : (var, value) Typ.t\n end\n\n module Bits : sig\n module type Faithful =\n Bits_intf.Snarkable.Faithful\n with type ('a, 'b) typ := ('a, 'b) Typ.t\n and type 'a checked := 'a Checked.t\n and type boolean_var := Boolean.var\n\n module type Lossy =\n Bits_intf.Snarkable.Lossy\n with type ('a, 'b) typ := ('a, 'b) Typ.t\n and type 'a checked := 'a Checked.t\n and type boolean_var := Boolean.var\n end\n end\nend\n","(* data_hash.ml *)\n\n[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Snark_params.Tick\n\n[%%ifdef consensus_mechanism]\n\nopen Bitstring_lib\n\n[%%endif]\n\nmodule type Full_size = Data_hash_intf.Full_size\n\nmodule Make_basic (M : sig\n val length_in_bits : int\nend) =\nstruct\n type t = Field.t [@@deriving sexp, compare, hash]\n\n let to_decimal_string (t : Field.t) = Field.to_string t\n\n let of_decimal_string (s : string) = Field.of_string s\n\n let to_bytes t =\n Fold_lib.(Fold.bool_t_to_string (Fold.of_list (Field.unpack t)))\n\n let length_in_bits = M.length_in_bits\n\n let () = assert (Int.(length_in_bits <= Field.size_in_bits))\n\n let to_input t = Random_oracle.Input.Chunked.field t\n\n [%%ifdef consensus_mechanism]\n\n (* this is in consensus code, because Bigint comes\n from snarky functors\n *)\n let gen : t Quickcheck.Generator.t =\n let m =\n if Int.(length_in_bits = Field.size_in_bits) then\n Bignum_bigint.(Field.size - one)\n else Bignum_bigint.(pow (of_int 2) (of_int length_in_bits) - one)\n in\n Quickcheck.Generator.map\n Bignum_bigint.(gen_incl zero m)\n ~f:(fun x -> Bigint.(to_field (of_bignum_bigint x)))\n\n type var =\n { digest : Random_oracle.Checked.Digest.t\n ; mutable bits : Boolean.var Bitstring.Lsb_first.t option\n }\n\n let var_of_t t =\n let n = Bigint.of_field t in\n { digest = Field.Var.constant t\n ; bits =\n Some\n (Bitstring.Lsb_first.of_list\n (List.init M.length_in_bits ~f:(fun i ->\n Boolean.var_of_value (Bigint.test_bit n i) ) ) )\n }\n\n open Let_syntax\n\n let var_to_hash_packed { digest; _ } = digest\n\n (* TODO: Audit this usage of choose_preimage *)\n let unpack =\n if Int.( = ) length_in_bits Field.size_in_bits then fun x ->\n Field.Checked.choose_preimage_var x ~length:length_in_bits\n >>| fun x -> (x :> Boolean.var list)\n else Field.Checked.unpack ~length:length_in_bits\n\n let%snarkydef_ var_to_bits t =\n match t.bits with\n | Some bits ->\n return (bits :> Boolean.var list)\n | None ->\n let%map bits = unpack t.digest in\n t.bits <- Some (Bitstring.Lsb_first.of_list bits) ;\n bits\n\n let var_to_input (t : var) = Random_oracle.Input.Chunked.field t.digest\n\n (* TODO : use Random oracle.Digest to satisfy Bits_intf.S, move out of\n consensus_mechanism guard\n *)\n module Bs =\n Snark_bits.Bits.Make_field\n (Snark_params.Tick.Field)\n (Snark_params.Tick.Bigint)\n\n include (Bs : module type of Bs with type t := t)\n\n let assert_equal x y = Field.Checked.Assert.equal x.digest y.digest\n\n let equal_var x y = Field.Checked.equal x.digest y.digest\n\n let typ : (var, t) Typ.t =\n Typ.transport_var Typ.field\n ~there:(fun { digest; bits = _ } -> digest)\n ~back:(fun digest -> { digest; bits = None })\n\n [%%endif]\nend\n\nmodule T0 = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n [@@@with_all_version_tags]\n\n type t = (Field.t[@version_asserted]) [@@deriving sexp, compare, hash]\n\n let to_latest = Fn.id\n end\n end]\nend\n\nmodule Make_full_size (B58_data : Data_hash_intf.Data_hash_descriptor) = struct\n module Basic = Make_basic (struct\n let length_in_bits = Field.size_in_bits\n end)\n\n include Basic\n\n module Base58_check = Codable.Make_base58_check (struct\n (* for compatibility with legacy Base58Check serializations *)\n include T0.Stable.Latest.With_all_version_tags\n\n (* the serialization here is only used for the hash impl which is only\n used for hashtbl, it's ok to disagree with the \"real\" serialization *)\n include Hashable.Make_binable (T0.Stable.Latest)\n include B58_data\n end)\n\n [%%define_locally\n Base58_check.\n (to_base58_check, of_base58_check, of_base58_check_exn, to_yojson, of_yojson)]\n\n module T = struct\n type t = Field.t [@@deriving sexp, compare, hash]\n end\n\n include Comparable.Make (T)\n include Hashable.Make (T)\n\n let of_hash = Fn.id\n\n let to_field = Fn.id\n\n [%%ifdef consensus_mechanism]\n\n let var_of_hash_packed digest = { digest; bits = None }\n\n let var_to_field { digest; _ } = digest\n\n let if_ cond ~then_ ~else_ =\n let%map digest =\n Field.Checked.if_ cond ~then_:then_.digest ~else_:else_.digest\n in\n { digest; bits = None }\n\n [%%endif]\nend\n","type t\n\nexternal create : unit -> t = \"caml_pasta_fp_poseidon_params_create\"\n\nexternal block_cipher : t -> Kimchi_bindings.FieldVectors.Fp.t -> unit\n = \"caml_pasta_fp_poseidon_block_cipher\"\n","let length_in_bytes = 20\n\nmodule T : sig\n type t = private string\n\n val create : string -> t\nend = struct\n type t = string\n\n let padding_char = '*'\n\n let create s : t =\n let string_length = String.length s in\n assert (string_length <= length_in_bytes) ;\n let diff = length_in_bytes - string_length in\n let r = s ^ String.init diff (fun _ -> padding_char) in\n assert (String.length r = length_in_bytes) ;\n r\nend\n\ninclude T\n\nlet protocol_state = create \"MinaProtoState\"\n\nlet protocol_state_body = create \"MinaProtoStateBody\"\n\nlet account = create \"MinaAccount\"\n\nlet side_loaded_vk = create \"MinaSideLoadedVk\"\n\nlet zkapp_account = create \"MinaZkappAccount\"\n\nlet zkapp_payload = create \"MinaZkappPayload\"\n\nlet zkapp_body = create \"MinaZkappBody\"\n\nlet merkle_tree i = create (Printf.sprintf \"MinaMklTree%03d\" i)\n\nlet coinbase_merkle_tree i = create (Printf.sprintf \"MinaCbMklTree%03d\" i)\n\nlet merge_snark = create \"MinaMergeSnark\"\n\nlet base_snark = create \"MinaBaseSnark\"\n\nlet transition_system_snark = create \"MinaTransitionSnark\"\n\nlet signature_testnet = create \"CodaSignature\"\n\nlet signature_mainnet = create \"MinaSignatureMainnet\"\n\nlet signature_other chain_name = create (chain_name ^ \"Signature\")\n\nlet receipt_chain_user_command = create \"MinaReceiptUC\"\n\n(* leaving this one with \"Coda\", to preserve the existing hashes *)\nlet receipt_chain_zkapp = create \"CodaReceiptZkapp\"\n\nlet epoch_seed = create \"MinaEpochSeed\"\n\nlet vrf_message = create \"MinaVrfMessage\"\n\nlet vrf_output = create \"MinaVrfOutput\"\n\nlet vrf_evaluation = create \"MinaVrfEvaluation\"\n\nlet pending_coinbases = create \"PendingCoinbases\"\n\nlet coinbase_stack_data = create \"CoinbaseStackData\"\n\n(* length is limited, so we drop some characters here *)\nlet coinbase_stack_state_hash = create \"CoinbaseStackStaHash\"\n\nlet coinbase_stack = create \"CoinbaseStack\"\n\nlet coinbase = create \"Coinbase\"\n\nlet checkpoint_list = create \"MinaCheckpoints\"\n\nlet bowe_gabizon_hash = create \"MinaTockBGHash\"\n\nlet zkapp_precondition = create \"MinaZkappPred\"\n\n(*for Zkapp_precondition.Account.t*)\nlet zkapp_precondition_account = create \"MinaZkappPredAcct\"\n\nlet zkapp_precondition_protocol_state = create \"MinaZkappPredPS\"\n\n(*for Account_update.Account_precondition.t*)\nlet account_update_account_precondition = create \"MinaAcctUpdAcctPred\"\n\nlet account_update = create \"MinaAcctUpdate\"\n\nlet account_update_cons = create \"MinaAcctUpdateCons\"\n\nlet account_update_node = create \"MinaAcctUpdateNode\"\n\nlet account_update_stack_frame = create \"MinaAcctUpdStckFrm\"\n\nlet account_update_stack_frame_cons = create \"MinaActUpStckFrmCons\"\n\nlet zkapp_uri = create \"MinaZkappUri\"\n\nlet zkapp_event = create \"MinaZkappEvent\"\n\nlet zkapp_events = create \"MinaZkappEvents\"\n\nlet zkapp_actions = create \"MinaZkappSeqEvents\"\n\nlet zkapp_memo = create \"MinaZkappMemo\"\n\nlet zkapp_test = create \"MinaZkappTest\"\n\nlet derive_token_id = create \"MinaDeriveTokenId\"\n","open Core_kernel\nopen Hash_prefixes\n\nlet salt (s : Hash_prefixes.t) = Random_oracle.salt (s :> string)\n\nlet salt_legacy (s : Hash_prefixes.t) = Random_oracle.Legacy.salt (s :> string)\n\nlet receipt_chain_signed_command = salt_legacy receipt_chain_user_command\n\nlet receipt_chain_zkapp_command = salt receipt_chain_user_command\n\nlet receipt_chain_zkapp = salt receipt_chain_zkapp\n\nlet coinbase = salt coinbase\n\nlet pending_coinbases = salt pending_coinbases\n\nlet coinbase_stack_data = salt coinbase_stack_data\n\nlet coinbase_stack_state_hash = salt coinbase_stack_state_hash\n\nlet coinbase_stack = salt coinbase_stack\n\nlet checkpoint_list = salt checkpoint_list\n\nlet merge_snark = salt merge_snark\n\nlet base_snark = salt base_snark\n\nlet protocol_state = salt protocol_state\n\nlet protocol_state_body = salt protocol_state_body\n\nlet merkle_tree =\n let f i = salt (merkle_tree i) in\n (* Cache up to the compiled ledger depth. *)\n let cached = ref [||] in\n fun i ->\n let len = Array.length !cached in\n if i >= len then\n cached :=\n Array.append !cached\n (Array.init (i + 1 - len) ~f:(fun i -> f (i + len))) ;\n !cached.(i)\n\nlet coinbase_merkle_tree =\n let f i = salt (coinbase_merkle_tree i) in\n let cached = ref [||] in\n fun i ->\n let len = Array.length !cached in\n if i >= len then\n cached :=\n Array.append !cached\n (Array.init (i + 1 - len) ~f:(fun i -> f (i + len))) ;\n !cached.(i)\n\nlet vrf_message = salt vrf_message\n\nlet signature_for_mainnet = salt signature_mainnet\n\nlet signature_for_testnet = salt signature_testnet\n\nlet signature_for_other chain_name = salt @@ signature_other chain_name\n\nlet signature ?(signature_kind = Mina_signature_kind.t) =\n match signature_kind with\n | Mainnet ->\n signature_for_mainnet\n | Testnet ->\n signature_for_testnet\n | Other_network chain_name ->\n signature_for_other chain_name\n\nlet signature_for_mainnet_legacy = salt_legacy signature_mainnet\n\nlet signature_for_testnet_legacy = salt_legacy signature_testnet\n\nlet signature_for_other_legacy chain_name =\n salt_legacy @@ signature_other chain_name\n\nlet signature_legacy ?(signature_kind = Mina_signature_kind.t) =\n match signature_kind with\n | Mainnet ->\n signature_for_mainnet_legacy\n | Testnet ->\n signature_for_testnet_legacy\n | Other_network chain_name ->\n signature_for_other_legacy chain_name\n\nlet vrf_output = salt vrf_output\n\nlet vrf_evaluation = salt vrf_evaluation\n\nlet epoch_seed = salt epoch_seed\n\nlet transition_system_snark = salt transition_system_snark\n\nlet account = salt account\n\nlet side_loaded_vk = salt side_loaded_vk\n\nlet zkapp_account = salt zkapp_account\n\nlet zkapp_payload = salt zkapp_payload\n\nlet zkapp_body = salt zkapp_body\n\nlet zkapp_precondition = salt zkapp_precondition\n\nlet zkapp_precondition_account = salt zkapp_precondition_account\n\nlet zkapp_precondition_protocol_state = salt zkapp_precondition_protocol_state\n\nlet account_update = salt account_update\n\nlet account_update_account_precondition =\n salt account_update_account_precondition\n\nlet account_update_cons = salt account_update_cons\n\nlet account_update_node = salt account_update_node\n\nlet account_update_stack_frame = salt account_update_stack_frame\n\nlet account_update_stack_frame_cons = salt account_update_stack_frame_cons\n\nlet zkapp_uri = salt zkapp_uri\n\nlet zkapp_event = salt zkapp_event\n\nlet zkapp_events = salt zkapp_events\n\nlet zkapp_actions = salt zkapp_actions\n\nlet zkapp_memo = salt zkapp_memo\n\nlet zkapp_test = salt zkapp_test\n\nlet derive_token_id = salt derive_token_id\n","open Core_kernel\nopen Fold_lib\n\nmodule Make (Impl : Snarky_backendless.Snark_intf.S) = struct\n let triple_string trips =\n let to_string b = if b then \"1\" else \"0\" in\n String.concat ~sep:\" \"\n (List.map trips ~f:(fun (b1, b2, b3) ->\n to_string b1 ^ to_string b2 ^ to_string b3 ) )\n\n let checked_to_unchecked typ1 typ2 checked input =\n let open Impl in\n let checked_result =\n run_and_check\n (let%bind input = exists typ1 ~compute:(As_prover.return input) in\n let%map result = checked input in\n As_prover.read typ2 result )\n |> Or_error.ok_exn\n in\n checked_result\n\n let test_to_triples typ fold var_to_triples input =\n let open Impl in\n let checked =\n run_and_check\n (let%bind input = exists typ ~compute:(As_prover.return input) in\n let%map result = var_to_triples input in\n As_prover.all\n (List.map result\n ~f:\n (As_prover.read\n (Typ.tuple3 Boolean.typ Boolean.typ Boolean.typ) ) ) )\n |> Or_error.ok_exn\n in\n let unchecked = Fold.to_list (fold input) in\n if not ([%equal: (bool * bool * bool) list] checked unchecked) then\n failwithf\n !\"Got %s (%d)\\nexpected %s (%d)\"\n (triple_string checked) (List.length checked) (triple_string unchecked)\n (List.length unchecked) ()\n\n let test_equal ?(equal = Poly.( = )) typ1 typ2 checked unchecked input =\n let checked_result = checked_to_unchecked typ1 typ2 checked input in\n assert (equal checked_result (unchecked input))\n\n let arbitrary_string ~len =\n String.init (Random.int len) ~f:(fun _ ->\n Char.of_int_exn (Random.int_incl 0 255) )\n\n let with_randomness r f =\n let s = Caml.Random.get_state () in\n Random.init r ;\n try\n let x = f () in\n Caml.Random.set_state s ; x\n with e -> Caml.Random.set_state s ; raise e\n\n (** utility function to print digests to put in tests, see `check_serialization' below *)\n let print_digest digest = printf \"\\\"\" ; printf \"%s\" digest ; printf \"\\\"\\n%!\"\n\n (** use this function to test Bin_prot serialization of types *)\n let check_serialization (type t) (module M : Binable.S with type t = t)\n (t : t) known_good_digest =\n (* serialize value *)\n let sz = M.bin_size_t t in\n let buf = Bin_prot.Common.create_buf sz in\n ignore (M.bin_write_t buf ~pos:0 t : int) ;\n let bytes = Bytes.create sz in\n Bin_prot.Common.blit_buf_bytes buf bytes ~len:sz ;\n (* compute MD5 digest of serialization *)\n let digest = Md5.digest_bytes bytes |> Md5.to_hex in\n let result = String.equal digest known_good_digest in\n if not result then (\n printf \"Expected digest: \" ;\n print_digest known_good_digest ;\n printf \"Got digest: \" ;\n print_digest digest ) ;\n result\nend\n\ninclude Make (Snark_params.Tick)\n","(* compressed_poly.ml -- versioned type with parameters for compressed curve point *)\n\n[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\n\nmodule Poly = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n [@@@with_all_version_tags]\n\n type ('field, 'boolean) t =\n ('field, 'boolean) Mina_wire_types.Public_key.Compressed.Poly.V1.t =\n { x : 'field; is_odd : 'boolean }\n [@@deriving compare, equal, hash, hlist]\n end\n end]\nend\n","open Core_kernel\nmodule Js = Js_of_ocaml.Js\nmodule Impl = Pickles.Impls.Step\nmodule Field = Impl.Field\n\n(* Ledger - local mina transaction logic for prototyping and testing zkapps *)\n\ntype public_key = Signature_lib.Public_key.Compressed.t\n\nmodule Account_update = Mina_base.Account_update\nmodule Zkapp_command = Mina_base.Zkapp_command\n\nlet ledger_class : < .. > Js.t =\n Js.Unsafe.eval_string {js|(function(v) { this.value = v; return this })|js}\n\nmodule Ledger : Mina_base.Ledger_intf.S = struct\n module Account = Mina_base.Account\n module Account_id = Mina_base.Account_id\n module Ledger_hash = Mina_base.Ledger_hash\n module Token_id = Mina_base.Token_id\n\n type t_ =\n { next_location : int\n ; accounts : Account.t Int.Map.t\n ; locations : int Account_id.Map.t\n }\n\n type t = t_ ref\n\n type location = int\n\n let get (t : t) (loc : location) : Account.t option = Map.find !t.accounts loc\n\n let location_of_account (t : t) (a : Account_id.t) : location option =\n Map.find !t.locations a\n\n let set (t : t) (loc : location) (a : Account.t) : unit =\n t := { !t with accounts = Map.set !t.accounts ~key:loc ~data:a }\n\n let next_location (t : t) : int =\n let loc = !t.next_location in\n t := { !t with next_location = loc + 1 } ;\n loc\n\n let get_or_create (t : t) (id : Account_id.t) :\n (Mina_base.Ledger_intf.account_state * Account.t * location) Or_error.t =\n let loc = location_of_account t id in\n let res =\n match loc with\n | None ->\n let loc = next_location t in\n let a = Account.create id Currency.Balance.zero in\n t := { !t with locations = Map.set !t.locations ~key:id ~data:loc } ;\n set t loc a ;\n (`Added, a, loc)\n | Some loc ->\n (`Existed, Option.value_exn (get t loc), loc)\n in\n Ok res\n\n let create_new_account (t : t) (id : Account_id.t) (a : Account.t) :\n unit Or_error.t =\n match location_of_account t id with\n | Some _ ->\n Or_error.errorf !\"account %{sexp: Account_id.t} already present\" id\n | None ->\n let loc = next_location t in\n t := { !t with locations = Map.set !t.locations ~key:id ~data:loc } ;\n set t loc a ;\n Ok ()\n\n let remove_accounts_exn (t : t) (ids : Account_id.t list) : unit =\n let locs = List.filter_map ids ~f:(fun id -> Map.find !t.locations id) in\n t :=\n { !t with\n locations = List.fold ids ~init:!t.locations ~f:Map.remove\n ; accounts = List.fold locs ~init:!t.accounts ~f:Map.remove\n }\n\n (* TODO *)\n let merkle_root (_ : t) : Ledger_hash.t = Field.Constant.zero\n\n let empty ~depth:_ () : t =\n ref\n { next_location = 0\n ; accounts = Int.Map.empty\n ; locations = Account_id.Map.empty\n }\n\n let with_ledger (type a) ~depth ~(f : t -> a) : a = f (empty ~depth ())\n\n let create_masked (t : t) : t = ref !t\n\n let apply_mask (t : t) ~(masked : t) = t := !masked\nend\n\nmodule Transaction_logic = Mina_transaction_logic.Make (Ledger)\n\ntype ledger_class = < value : Ledger.t Js.prop >\n\nlet ledger_constr : (Ledger.t -> ledger_class Js.t) Js.constr =\n Obj.magic ledger_class\n\nlet create_new_account_exn (t : Ledger.t) account_id account =\n Ledger.create_new_account t account_id account |> Or_error.ok_exn\n\nlet default_token_id =\n Mina_base.Token_id.default |> Mina_base.Token_id.to_field_unsafe\n\nlet account_id (pk : public_key) token =\n Mina_base.Account_id.create pk (Mina_base.Token_id.of_field token)\n\nmodule To_js = struct\n let option (transform : 'a -> 'b) (x : 'a option) =\n Js.Optdef.option (Option.map x ~f:transform)\nend\n\nlet check_account_update_signatures zkapp_command =\n let ({ fee_payer; account_updates; memo } : Zkapp_command.t) =\n zkapp_command\n in\n let tx_commitment = Zkapp_command.commitment zkapp_command in\n let full_tx_commitment =\n Zkapp_command.Transaction_commitment.create_complete tx_commitment\n ~memo_hash:(Mina_base.Signed_command_memo.hash memo)\n ~fee_payer_hash:\n (Zkapp_command.Digest.Account_update.create\n (Account_update.of_fee_payer fee_payer) )\n in\n let key_to_string = Signature_lib.Public_key.Compressed.to_base58_check in\n let check_signature who s pk msg =\n match Signature_lib.Public_key.decompress pk with\n | None ->\n failwith\n (sprintf \"Check signature: Invalid key on %s: %s\" who\n (key_to_string pk) )\n | Some pk_ ->\n if\n not\n (Signature_lib.Schnorr.Chunked.verify s\n (Kimchi_pasta.Pasta.Pallas.of_affine pk_)\n (Random_oracle_input.Chunked.field msg) )\n then\n failwith\n (sprintf \"Check signature: Invalid signature on %s for key %s\" who\n (key_to_string pk) )\n else ()\n in\n\n check_signature \"fee payer\" fee_payer.authorization fee_payer.body.public_key\n full_tx_commitment ;\n List.iteri (Zkapp_command.Call_forest.to_account_updates account_updates)\n ~f:(fun i p ->\n let commitment =\n if p.body.use_full_commitment then full_tx_commitment else tx_commitment\n in\n match p.authorization with\n | Signature s ->\n check_signature\n (sprintf \"account_update %d\" i)\n s p.body.public_key commitment\n | Proof _ | None_given ->\n () )\n\nlet add_account_exn (l : Ledger.t) pk (balance : string) =\n let account_id = account_id pk default_token_id in\n let bal_u64 = Unsigned.UInt64.of_string balance in\n let balance = Currency.Balance.of_uint64 bal_u64 in\n let a : Mina_base.Account.t = Mina_base.Account.create account_id balance in\n create_new_account_exn l account_id a\n\nlet create () : ledger_class Js.t =\n let l = Ledger.empty ~depth:20 () in\n new%js ledger_constr l\n\nlet account_to_json =\n let deriver = Mina_base.Account.deriver @@ Fields_derivers_zkapps.o () in\n let to_json' = Fields_derivers_zkapps.to_json deriver in\n let to_json (account : Mina_base.Account.t) : Js.Unsafe.any =\n account |> to_json' |> Yojson.Safe.to_string |> Js.string |> Util.json_parse\n in\n to_json\n\nlet get_account l (pk : public_key) (token : Impl.field) :\n Js.Unsafe.any Js.optdef =\n let loc = Ledger.location_of_account l##.value (account_id pk token) in\n let account = Option.bind loc ~f:(Ledger.get l##.value) in\n To_js.option account_to_json account\n\nlet add_account l (pk : public_key) (balance : Js.js_string Js.t) =\n add_account_exn l##.value pk (Js.to_string balance)\n\nlet protocol_state_of_json =\n let deriver =\n Mina_base.Zkapp_precondition.Protocol_state.View.deriver\n @@ Fields_derivers_zkapps.o ()\n in\n let of_json = Fields_derivers_zkapps.of_json deriver in\n fun (json : Js.js_string Js.t) :\n Mina_base.Zkapp_precondition.Protocol_state.View.t ->\n json |> Js.to_string |> Yojson.Safe.from_string |> of_json\n\nlet apply_zkapp_command_transaction l (txn : Zkapp_command.t)\n (account_creation_fee : string)\n (network_state : Mina_base.Zkapp_precondition.Protocol_state.View.t) =\n check_account_update_signatures txn ;\n let ledger = l##.value in\n let application_result =\n Transaction_logic.apply_zkapp_command_unchecked\n ~global_slot:network_state.global_slot_since_genesis\n ~state_view:network_state\n ~constraint_constants:\n { Genesis_constants.Constraint_constants.compiled with\n account_creation_fee = Currency.Fee.of_string account_creation_fee\n }\n ledger txn\n in\n let applied, _ =\n match application_result with\n | Ok res ->\n res\n | Error err ->\n Util.raise_error (Error.to_string_hum err)\n in\n match applied.command.status with\n | Applied ->\n ()\n | Failed failures ->\n Util.raise_error\n ( Mina_base.Transaction_status.Failure.Collection.to_yojson failures\n |> Yojson.Safe.to_string )\n\nlet apply_json_transaction l (tx_json : Js.js_string Js.t)\n (account_creation_fee : Js.js_string Js.t) (network_json : Js.js_string Js.t)\n =\n let txn =\n Zkapp_command.of_json @@ Yojson.Safe.from_string @@ Js.to_string tx_json\n in\n let network_state = protocol_state_of_json network_json in\n apply_zkapp_command_transaction l txn\n (Js.to_string account_creation_fee)\n network_state\n\nlet method_ class_ (name : string) (f : _ Js.t -> _) =\n let prototype = Js.Unsafe.get class_ (Js.string \"prototype\") in\n Js.Unsafe.set prototype (Js.string name) (Js.wrap_meth_callback f)\n\nlet () =\n let static_method name f =\n Js.Unsafe.set ledger_class (Js.string name) (Js.wrap_callback f)\n in\n let method_ name (f : ledger_class Js.t -> _) = method_ ledger_class name f in\n static_method \"create\" create ;\n\n method_ \"getAccount\" get_account ;\n method_ \"addAccount\" add_account ;\n method_ \"applyJsonTransaction\" apply_json_transaction\n","(* public_key.ml *)\n\ninclude Non_zero_curve_point\nmodule Inner_curve = Snark_params.Tick.Inner_curve\n\nlet of_private_key_exn p = of_inner_curve_exn Inner_curve.(scale one p)\n","module type S = sig\n type t [@@deriving equal, sexp]\n\n module Stable : sig\n module V1 : sig\n type nonrec t = t [@@deriving bin_io, equal, sexp]\n end\n\n module Latest : module type of V1\n end\nend\n\nmodule type Hash = sig\n type t [@@deriving compare]\n\n include S with type t := t\n\n val merge : height:int -> t -> t -> t\nend\n\nmodule type Key = S\n\nmodule type Account = sig\n type hash\n\n include S\n\n val data_hash : t -> hash\nend\n","\nlet (blockchain_proof, transaction_proof) =\n ((Core_kernel.Binable.of_string (module\n Pickles.Proof.Proofs_verified_2.Stable.Latest)\n \"\\252\\012\\197i\\202m3\\161\\b\\252\\139\\134\\018}\\250\\015\\240\\195\\000\\252\\137\\000\\179\\254\\154\\214\\139{\\252\\017(\\185j\\141\\210\\243\\179\\000\\252\\193\\0075\\134p\\184\\207s\\252\\156\\231\\235\\195%\\236\\155r\\000\\252%O\\171W(\\182[\\n\\252\\242\\128\\235:\\131\\152\\175\\177\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\252\\185*\\167V\\180ps\\173\\252\\252\\158\\241\\213#\\249O6\\000\\252\\000|/\\142b\\028\\135Y\\252\\135\\204&\\162s\\246\\199\\156\\000\\252\\175\\242\\182\\158\\029\\130T#\\252~\\245}\\246\\209k\\185\\213\\000\\252\\246\\134\\144\\160\\208\\247{\\020\\252h*$@\\206b^b\\000\\252\\014\\173V2c\\027\\198\\175\\252\\251\\225\\031\\161\\016r\\128\\t\\000\\252\\145A\\172\\202\\190\\030X\\249\\252\\166\\201\\183>\\153\\213\\030W\\000\\252\\189\\195d\\205\\163PN\\170\\252h\\197\\254\\193\\n\\231\\020\\216\\000\\252m\\222^\\130\\223\\172\\029\\178\\252\\165\\007\\219\\197\\023\\162\\b\\254\\000\\252\\127\\170\\230\\233\\214\\015N\\130\\252,\\127\\185N\\152:\\246\\252\\000\\252\\202\\004\\027q+\\1361\\195\\252)&\\174\\182\\199\\1729\\145\\000\\252\\239Q\\129\\253G\\143\\015\\220\\252\\135\\149;\\196Cz\\169\\000\\000\\252\\1912\\134\\209\\030\\2168`\\252\\171\\005\\170\\162p\\188\\179\\249\\000\\252ZG\\175\\229\\224\\210u\\148\\252\\246\\210\\195\\174\\002\\167\\203\\209\\000\\252\\004|-\\249\\246\\015x\\190\\252T\\226\\2512\\145X=\\225\\000\\252\\019u1\\184\\018\\183p\\198\\252\\b>H\\1543\\204u\\022\\000\\252\\209\\184\\202\\177\\162\\176\\193H\\252\\206\\177q\\192\\227\\004f\\027\\000\\000\\002\\016\\000\\000\\000\\000\\000b\\153TI\\021\\240\\155\\231\\193y\\017D-%H@S\\180Y\\005\\219\\159AV0a\\253}\\1882\\211\\015\\172\\215R\\133\\247\\193\\162O\\199\\177\\230\\226|<\\022:U\\166\\177\\23169\\003\\029\\004\\235\\165^P\\004\\005\\022\\252o\\191\\230\\172\\201\\179\\1303\\252c\\024v\\249XC\\151y\\000\\252\\151\\135\\136\\233\\006+:\\221\\252\\199\\161D)@\\230z\\221\\000\\252\\203\\159\\156\\2440\\229\\232\\198\\252\\221\\156\\160\\205e\\187\\221\\007\\000\\252\\019\\026i\\135\\162Y,S\\252{oe*\\176\\188!\\169\\000\\252\\139\\007\\016\\143\\177w\\156\\226\\252\\238\\012k\\223\\000_\\\\\\248\\000\\252\\135\\156\\176\\007-\\167\\189\\029\\252\\160&_\\233\\226\\151\\027M\\000\\252\\017_\\128V|tu\\156\\252\\232\\241\\206\\250ic\\254\\161\\000\\252M`\\233\\219\\223\\138+\\\\\\252\\155\\247\\016\\242\\140q\\140Z\\000\\252Hk\\224Q\\\\\\179\\192\\\"\\252\\237m\\169@s\\139\\136\\166\\000\\252ndv^\\181\\215\\007\\144\\252\\018\\142N\\2199\\139\\198\\193\\000\\252\\201+?7^\\227ED\\252\\229\\205\\140\\252\\021\\199@\\157\\000\\252N\\170\\188K\\132\\130\\152B\\252\\188\\183\\175\\208\\215'\\169\\151\\000\\252wn\\253\\255[=\\202\\153\\252\\148B\\\\\\021Uj\\230\\239\\000\\252T\\153\\151!q\\178}K\\252@\\200\\147a\\224\\162\\031\\149\\000\\252\\179G\\007\\178\\190\\204\\209,\\252\\029\\002d\\242<\\222\\209[\\000\\000\\252o\\191\\230\\172\\201\\179\\1303\\252c\\024v\\249XC\\151y\\000\\252\\151\\135\\136\\233\\006+:\\221\\252\\199\\161D)@\\230z\\221\\000\\252\\203\\159\\156\\2440\\229\\232\\198\\252\\221\\156\\160\\205e\\187\\221\\007\\000\\252\\019\\026i\\135\\162Y,S\\252{oe*\\176\\188!\\169\\000\\252\\139\\007\\016\\143\\177w\\156\\226\\252\\238\\012k\\223\\000_\\\\\\248\\000\\252\\135\\156\\176\\007-\\167\\189\\029\\252\\160&_\\233\\226\\151\\027M\\000\\252\\017_\\128V|tu\\156\\252\\232\\241\\206\\250ic\\254\\161\\000\\252M`\\233\\219\\223\\138+\\\\\\252\\155\\247\\016\\242\\140q\\140Z\\000\\252Hk\\224Q\\\\\\179\\192\\\"\\252\\237m\\169@s\\139\\136\\166\\000\\252ndv^\\181\\215\\007\\144\\252\\018\\142N\\2199\\139\\198\\193\\000\\252\\201+?7^\\227ED\\252\\229\\205\\140\\252\\021\\199@\\157\\000\\252N\\170\\188K\\132\\130\\152B\\252\\188\\183\\175\\208\\215'\\169\\151\\000\\252wn\\253\\255[=\\202\\153\\252\\148B\\\\\\021Uj\\230\\239\\000\\252T\\153\\151!q\\178}K\\252@\\200\\147a\\224\\162\\031\\149\\000\\252\\179G\\007\\178\\190\\204\\209,\\252\\029\\002d\\242<\\222\\209[\\000\\000\\000\\000\\002H\\1816\\232FT\\165_O\\253\\255\\253\\245\\145\\189\\157<\\161pK\\206\\240\\\\\\165\\157\\194dH\\222\\223\\211\\017k\\026,D\\221!\\199\\205YU\\239\\025\\195\\243\\171\\184B\\014\\027z\\229\\023\\020\\222\\215\\138\\132M\\\"\\007\\245\\005H\\1816\\232FT\\165_O\\253\\255\\253\\245\\145\\189\\157<\\161pK\\206\\240\\\\\\165\\157\\194dH\\222\\223\\211\\017k\\026,D\\221!\\199\\205YU\\239\\025\\195\\243\\171\\184B\\014\\027z\\229\\023\\020\\222\\215\\138\\132M\\\"\\007\\245\\005\\002\\252\\185*\\167V\\180ps\\173\\252\\252\\158\\241\\213#\\249O6\\000\\252\\000|/\\142b\\028\\135Y\\252\\135\\204&\\162s\\246\\199\\156\\000\\252\\175\\242\\182\\158\\029\\130T#\\252~\\245}\\246\\209k\\185\\213\\000\\252\\246\\134\\144\\160\\208\\247{\\020\\252h*$@\\206b^b\\000\\252\\014\\173V2c\\027\\198\\175\\252\\251\\225\\031\\161\\016r\\128\\t\\000\\252\\145A\\172\\202\\190\\030X\\249\\252\\166\\201\\183>\\153\\213\\030W\\000\\252\\189\\195d\\205\\163PN\\170\\252h\\197\\254\\193\\n\\231\\020\\216\\000\\252m\\222^\\130\\223\\172\\029\\178\\252\\165\\007\\219\\197\\023\\162\\b\\254\\000\\252\\127\\170\\230\\233\\214\\015N\\130\\252,\\127\\185N\\152:\\246\\252\\000\\252\\202\\004\\027q+\\1361\\195\\252)&\\174\\182\\199\\1729\\145\\000\\252\\239Q\\129\\253G\\143\\015\\220\\252\\135\\149;\\196Cz\\169\\000\\000\\252\\1912\\134\\209\\030\\2168`\\252\\171\\005\\170\\162p\\188\\179\\249\\000\\252ZG\\175\\229\\224\\210u\\148\\252\\246\\210\\195\\174\\002\\167\\203\\209\\000\\252\\004|-\\249\\246\\015x\\190\\252T\\226\\2512\\145X=\\225\\000\\252\\019u1\\184\\018\\183p\\198\\252\\b>H\\1543\\204u\\022\\000\\252\\209\\184\\202\\177\\162\\176\\193H\\252\\206\\177q\\192\\227\\004f\\027\\000\\000\\252\\185*\\167V\\180ps\\173\\252\\252\\158\\241\\213#\\249O6\\000\\252\\000|/\\142b\\028\\135Y\\252\\135\\204&\\162s\\246\\199\\156\\000\\252\\175\\242\\182\\158\\029\\130T#\\252~\\245}\\246\\209k\\185\\213\\000\\252\\246\\134\\144\\160\\208\\247{\\020\\252h*$@\\206b^b\\000\\252\\014\\173V2c\\027\\198\\175\\252\\251\\225\\031\\161\\016r\\128\\t\\000\\252\\145A\\172\\202\\190\\030X\\249\\252\\166\\201\\183>\\153\\213\\030W\\000\\252\\189\\195d\\205\\163PN\\170\\252h\\197\\254\\193\\n\\231\\020\\216\\000\\252m\\222^\\130\\223\\172\\029\\178\\252\\165\\007\\219\\197\\023\\162\\b\\254\\000\\252\\127\\170\\230\\233\\214\\015N\\130\\252,\\127\\185N\\152:\\246\\252\\000\\252\\202\\004\\027q+\\1361\\195\\252)&\\174\\182\\199\\1729\\145\\000\\252\\239Q\\129\\253G\\143\\015\\220\\252\\135\\149;\\196Cz\\169\\000\\000\\252\\1912\\134\\209\\030\\2168`\\252\\171\\005\\170\\162p\\188\\179\\249\\000\\252ZG\\175\\229\\224\\210u\\148\\252\\246\\210\\195\\174\\002\\167\\203\\209\\000\\252\\004|-\\249\\246\\015x\\190\\252T\\226\\2512\\145X=\\225\\000\\252\\019u1\\184\\018\\183p\\198\\252\\b>H\\1543\\204u\\022\\000\\252\\209\\184\\202\\177\\162\\176\\193H\\252\\206\\177q\\192\\227\\004f\\027\\000\\000:{\\221-N#sE\\216t.\\146\\191u'\\001f@\\238\\128u\\005\\150fI\\237\\246\\129\\015\\128\\21106\\004j\\2083\\133\\221\\031i\\128%\\012\\175\\253p\\b\\001\\136(\\0201\\130L\\169\\1533\\135\\n\\202O\\\\\\131e;\\183=D\\236o\\189M\\132\\028\\133u!\\158\\199\\015\\001\\021JS\\128h\\141\\012~\\202;\\222\\216\\131\\245\\128\\135\\239\\247\\143~\\191\\222\\131\\007qF\\128\\191~\\151\\198\\014\\001\\025\\170\\164\\1530\\233\\178\\162D\\027h\\209\\157c\\215\\019\\160V\\151\\242\\128s\\01739R\\148\\246d\\187b\\017\\001\\197\\021\\245\\023\\014\\220?\\tqX\\248\\217\\137H\\230\\178E\\192x\\222H\\020\\241Qx\\158\\243I\\249\\020\\004\\002\\001C\\193@,\\255\\146\\128\\005\\251d\\017B\\n\\208V\\246r\\176\\002uU},\\214\\237E\\235UI\\252\\191:\\001\\225U\\015BBE\\198\\181\\209\\021\\187\\255Mt\\157:8\\206\\176U\\210\\011\\255;&\\196\\226\\129(\\177\\251-\\001\\170}C.F\\236\\b<\\238\\233\\210M\\251C\\131q:B\\134\\164\\169\\247kL\\153\\216\\217\\\\\\152\\206\\2161\\001I\\183\\002\\137\\241\\162\\241\\191\\219\\021u\\157\\158n\\155Zmz\\237\\175\\134\\027%\\235Y\\145\\161\\243;\\208\\152\\015\\001\\b\\219\\140\\\"\\230\\2379\\250\\166Z\\159\\179\\218\\232\\136{\\027s\\155\\172u\\219R3\\157\\142M\\238\\250\\190o8\\001\\232\\017\\152\\1737?\\255\\211\\156\\229\\158\\154\\137l\\220\\007DE\\\"\\194_=\\020yJ\\210\\173\\235j44$\\001$P\\132\\011V\\2425^o\\198\\165\\208\\203-;\\023\\1607=K\\248\\025\\180\\026c\\028\\182-\\128q\\t\\020\\001\\179\\1366`=\\179Wo\\247\\018\\141E\\144h\\150\\195\\173V\\251\\025 \\001\\001\\173\\011\\219y\\178\\241oM\\020'\\224\\218\\254p\\192c\\016\\250F\\006\\185>\\180B\\130S\\143\\131\\218(\\241?\\001\\149\\209b,\\192\\167\\242\\219\\138\\153\\216\\021e4\\213r\\007\\170\\243\\187\\198\\165\\166\\161\\163\\021\\205\\146Bh\\130\\031\\001R\\210\\183\\129\\190\\0280\\012\\029\\203@ _`$\\007Z\\153\\011>\\214@h^\\164\\134/e\\233F\\233\\026\\0016\\137\\142\\0005\\254\\190\\022\\238\\149\\216\\1441\\223Z\\016\\213a\\217\\152\\174\\208f/]x\\187\\012\\023\\203\\216\\012\\001q#\\154.\\129wF\\242\\151\\015\\170\\222\\241\\174CQ\\\\\\138\\223\\252 \\177o\\025F\\183\\194\\231@\\178\\1902\\001!\\018\\186\\127\\215IgAV;\\148\\136xa*_\\234\\017\\254\\225\\127H\\187\\176\\011\\174\\207{\\223x\\228#\\001\\238\\220$)\\001\\238\\171\\172\\203\\182]%q\\255\\194h\\255\\245\\187f\\247T%\\165\\167\\183Y\\255\\226\\179(\\015\\001{\\r<\\248\\148\\003s\\150\\2073\\2122\\198\\017\\255\\2116\\249\\134ZJ\\143\\210\\031M\\184\\211Gn`h;\\001]\\2030\\190\\252\\242\\243\\217\\150.N.L\\162\\n\\214Lzr\\1990p\\148r\\026GQw\\159\\202\\\"#\\001\\196n\\176;\\144j\\254\\004=\\\"P\\198\\231\\028\\248Pwv\\193\\188\\\"F\\\"y\\128\\252Bw\\004\\254*\\005\\001\\n\\204+o\\253\\166\\002\\250\\226\\0075\\235\\224\\134\\198\\144\\255\\248\\139[\\011\\240\\221\\237\\177\\159\\003:\\190m\\240&\\0017\\140\\201R\\023\\239\\223\\136H\\228l\\219\\2397\\236L\\160\\239#\\169\\185$\\158\\226H\\029\\185\\025S\\144\\130\\011\\001\\225\\\\\\224\\1936\\218c\\206_9\\161\\134-\\155\\005\\004\\184~\\198\\179\\004\\224\\136\\007\\153}\\134K*\\229\\231\\003\\001\\rV!7\\211\\241qk\\016[2\\227\\140\\b\\027\\207\\250 x\\190\\162\\136\\141'o5IJE\\029\\1530\\001\\187\\193\\218H\\155\\205ze\\027\\162Q\\026^\\177\\187\\132\\197@\\014w\\130+UZ\\238\\223\\240Z\\172Z\\153\\024\\001W\\205\\189J{iYG\\001\\127\\241\\0124\\209\\239\\t\\228\\t\\178\\213k\\230\\199\\\\\\188\\194t\\172\\031(\\019\\011\\001\\230|F\\210\\155\\188\\243\\244\\152s\\002p?c\\1406\\012\\000c\\152\\140L\\252\\242\\250-\\004\\235\\249\\201a\\002\\0016Q\\227\\152o^$\\133s\\209W\\185\\141\\132\\028\\217]\\t\\190\\204\\228\\006J\\bQ+\\255i8\\129_\\017\\001\\145\\023\\209\\237E\\027\\137\\203\\187Cu1\\210@\\192\\181Fj\\214Q\\031\\205\\025\\190\\000\\026\\188\\244a\\180~\\011\\001l\\195g\\015\\236\\199\\203@\\rF\\236\\199\\143? \\007\\160\\206\\162^:\\204v0i\\222|1K\\247\\191,\\001\\165c\\201\\149\\241\\255\\143\\199\\234\\160\\027\\019\\178\\193m\\244\\2136B\\161\\155\\168o\\007\\206\\225\\237\\239\\2512-\\030\\001\\139\\159r\\164\\172\\2037\\225A\\027\\148*\\\\y\\190\\247\\191\\021\\182t\\164\\178\\186\\174\\161\\173#5'x\\021\\022\\001y=Q\\211\\206\\254\\164\\247C\\200n\\150,\\n\\195\\023\\235~\\002\\193\\146\\b\\020h\\t\\150}(\\004\\144^;\\001\\249\\166\\162\\185\\201\\nF\\183C\\144\\1632\\024\\2457\\205aW\\238m\\026l\\187\\155yrn9r\\159\\1879\\001\\000\\012Fi\\180\\220\\175\\1870\\186TB\\150,\\0145(\\024\\179\\151\\021j\\165\\156\\000~\\031*\\249\\137\\1858\\001@_\\183\\017\\234\\233\\252\\167\\136u\\219\\141\\182a\\137\\197mBo\\234\\006\\143(&\\254\\\\\\176\\176\\175\\224j\\014\\000\\001\\014P\\025\\239Y[yo\\135.\\218\\232t\\223>k\\209\\233D$\\174\\215\\186Mz\\197\\254Z\\226%$\\021\\001\\206\\206\\146J\\241(\\155\\\"o\\187l\\190\\248\\t\\185D\\\"\\169\\217\\031\\007\\130\\173\\160\\216~\\252\\131\\208\\025\\185\\027\\001JN\\233\\216\\206\\243~pMW\\131n+\\212,idf\\226q\\151\\225f\\229\\164\\172\\135\\175o\\023\\169$\\001\\222~W\\237\\0025\\237\\019\\021\\238|vX/\\232^\\2414\\016W\\026u7\\188\\215\\1899\\025\\242f\\236\\030\\001~\\168\\192\\251%~Q\\024\\229H\\217\\199\\213\\159XX\\202\\021;\\159xPb1=%\\014$\\226\\003)\\020\\001\\157S\\200[\\219\\200\\185\\248\\149\\253<\\242\\133@\\154\\222$\\208w\\198\\177\\251\\136K\\232\\237\\003\\166\\t z\\021\\001\\153\\132\\222Z\\211\\t\\028R?\\144\\219g\\146Rk6\\179\\208\\147k\\218\\138\\168\\170\\130\\017'H\\225\\170\\251-\\001\\210=DU\\\\V\\147$\\006}\\130\\129v2\\164\\180\\139\\227\\020&q\\001\\160\\152s\\025ru\\208(O\\005\\001\\141\\030\\248\\226J\\2075\\230\\143@D\\1282CR\\233!d[\\195T\\176VD\\231\\189N\\179\\168\\014\\157\\019\\001\\173\\177\\175\\207\\175\\254uiekT\\213\\2069\\247\\193\\026U\\149\\143c\\2442\\239\\186\\154\\169c4\\227\\240\\019\\001\\r\\025\\237\\186\\203\\156\\240+\\191\\\\\\028\\016S\\212\\\"G\\149&\\133P8\\192rw*\\n\\151\\015:T\\213%\\001\\137\\172pR\\195oP\\168\\155\\205\\006\\011\\166\\127\\169Dm\\254\\176\\182\\216\\nt\\239a}\\212\\175f\\204 9\\001\\172]\\016U\\230\\220\\133\\230\\150\\205\\226\\228\\205X\\228\\017uVb-\\230\\022\\192K4'\\235\\207Ny!9\\001\\162\\224T\\198[\\145K.\\204\\163\\169\\186\\1635\\160\\214\\165\\001\\156\\251\\177\\156\\224s\\234\\213.\\031\\015\\150?0\\000\\001\\222d\\191\\243\\0223\\131\\175\\\"hwM)\\249s\\130ei%\\163\\132n\\b\\209\\185\\219\\253\\129\\007\\tP\\b\\001\\026y\\201 g\\175:\\147\\227\\142;z\\181Q\\2370\\203%\\152\\190=S\\026\\252\\179\\022\\031\\244dRy\\012\\001\\195\\024\\029\\135\\208\\171J\\153\\206\\200\\133\\179\\212\\222Q\\176\\188\\163+0n\\190\\206\\141\\202\\026\\135+\\192\\239\\196\\029\\001(\\136\\194qd\\185\\0114\\026\\151\\168\\130\\197EOXh\\168\\214\\135\\150\\179\\241\\142\\245B\\128\\238?\\150(:\\001\\207\\230\\245\\252\\199R9=\\203\\252\\148\\018V\\194\\186\\132\\153\\211\\\"(\\174\\026\\221\\018\\r\\015\\190\\204\\2178\\1463\\001\\023\\230\\252\\218\\000c!\\210oh\\226\\150\\139\\bHv6\\007\\2482\\249\\173\\176\\186\\167\\026\\021\\185/y\\136%\\001\\255\\219N\\144\\157w)eu\\239\\022-\\1831X\\022\\147\\168\\174\\026&(\\233\\215\\177\\020\\246\\230H20\\n\\001@\\018\\138\\2202<\\236\\210K_M\\239\\2484\\190\\150\\012\\144\\165\\201}\\022\\206m\\018>\\222\\140\\149\\178\\191<\\001\\146\\245\\252\\220\\012L\\211\\246\\222ByH\\176x1.\\0117D\\182I2\\181Z\\246\\020\\028\\232\\254n\\216,\\001L\\177\\225\\188\\236\\132?\\171~7x\\015D\\136\\rX\\235\\250<(\\180\\192\\201\\019\\174AIZ[\\207[\\025\\001\\192\\200M\\254\\161S\\006\\187\\150'\\021\\185!\\192\\017\\127\\222\\159?\\157\\255\\169sO\\202\\151|\\174\\134T\\1447\\001\\173l\\242Y\\255\\234\\209\\141:\\2538/A\\014w\\026=]\\015&\\020T\\250i\\150\\147\\216\\028E\\204\\128<\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\223\\020\\139\\015&\\240\\031\\139Vn\\220\\030Ql\\169!J\\017\\026\\218\\152\\250\\212J\\199\\014.\\164I\\tW;\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\000\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\000_\\237f\\144(\\136\\155\\028\\146\\165\\241Ac3\\249pC\\228\\027rG\\148\\190z\\212\\148\\177\\t\\235F0\\b\\164\\027o\\160\\129\\149\\020\\157\\254pe\\136\\211o\\168M\\025v\\137\\174\\247\\138\\192t\\153tvYg\\134\\129\\003iyJ\\160\\136\\n=\\235\\242\\019\\1967\\\"\\206\\160\\246J\\151hZz\\179\\147\\218\\244\\137\\146\\240\\0222\\172\\021vgd%\\232v7\\005\\196\\167,N\\160\\197\\169\\028\\029\\238\\1686d\\015Fr.r\\\"O\\232\\249D2LE\\131\\222\\171Jw\\025\\234R;OV&_Y\\027\\245D\\223c\\203H\\018\\162\\213\\236\\031\\025\\127\\028\\020\\169\\n:(\\131\\225u\\236\\213\\219\\164\\213(I\\002\\181k\\170\\162\\209\\029\\238fw\\004u\\015\\144_ V \\188\\131\\199\\226s\\196\\017[F_\\160,\\205\\011\\011\\155\\158vH\\221\\133\\229\\215\\200\\158\\146\\243\\005\\176\\162\\001/\\158\\001J\\154S\\148\\r\\\"1v\\231\\\\+\\n\\015|fS~\\175mR\\192\\192\\244\\r]\\143\\198n\\2295\\212K\\\"96N\\007\\137A\\250\\184G\\182\\140\\028m\\175L\\211<\\239'\\239\\160\\133@R\\225\\018j\\135\\014\\003\\2516\\164nx\\133T\\152_\\019\\240h\\199J\\226J7\\232N\\156\\006l\\215!\\0005\\170\\2109\\225\\150\\006\\031\\030\\235\\243AH\\194e\\132\\002\\019=P\\007\\0167f\\138\\2182\\186q\\2514*\\224\\001\\151\\255\\249A':\\190\\159\\180\\187EGm\\192\\235\\162\\229\\206\\030\\253\\219\\153\\208\\002`\\213b\\190\\185\\172\\154\\030~\\221\\139\\182\\127\\171\\248H\\210\\007\\152\\221\\196K\\243\\179\\227C4\\203\\128`\\250\\2107\\172\\171\\193R\\1330\\209\\194\\129\\219\\026\\029p\\031R\\152o\\238\\174\\154G6eE\\184\\011\\217<%\\1734\\193\\021\\150\\011i\\237Oe\\142^\\202Y\\180\\148w\\170\\249\\127c\\023[\\247\\235\\130d\\0249\\166\\214d&#\\175{\\153bo\\168\\223j\\138\\137\\177\\138?-\\014\\192S#\\245\\179\\127i\\227z`\\\"+9m*\\133\\tp\\196\\183e\\154\\249\\207\\005\\r\\212\\0209:Z%\\017V\\t\\236U\\151x\\129|\\191\\230\\006_\\141EI\\003p\\175\\158\\156e\\217.\\253\\147\\150\\215\\177\\022$+9\\181\\209p@\\006#\\015\\166\\227\\253\\028\\022>\\217\\242\\246\\209\\247\\019?\\141^M\\238\\249H\\027j\\153\\220\\151\\167\\020\\228z(?DJ\\172\\233\\224'\\21178\\018\\214T\\228\\253\\246#:d\\182J\\223\\211\\173F'\\205\\230\\165\\214\\215\\027\\137\\131\\246?fL)L\\197K1\\232\\197\\149\\207\\216\\155d|\\207\\011\\249T#\\182\\021\\005\\201\\161$\\249\\165\\001\\183\\248R\\000\\0052\\204\\tj\\025\\213\\227h)\\174\\\\wo\\2448\\019Kk\\169}\\012\\133\\235\\022\\154\\005\\219t \\214\\028=\\026\\134{\\254\\132g _0?$\\185L\\151\\020;\\182\\b\\143#\\026\\137\\203q\\146\\195\\206\\185hGQ\\127\\r\\139\\204K\\131\\145\\017\\027\\143\\214'P\\244\\219/\\005\\004\\154-\\001\\145tg\\242\\200\\\"\\026\\217\\244\\225\\184\\177\\000|O\\246;\\006zDmw\\158\\031\\185\\206\\0056z\\230\\244\\028\\255\\230\\253\\137g\\019\\011\\161gH\\199<\\003i\\252sOj\\175\\243.\\224 +\\146ng\\209\\003\\202\\136\\208\\2323\\190\\006x\\244\\247R\\145\\166\\152\\2392\\226/\\204\\011\\231\\224\\244v\\205\\238\\\"\\196\\tV\\231 \\188\\186\\143{\\149i\\147B\\185\\t\\135\\198\\207\\220q0!\\234&b\\250\\019~R\\027\\016\\231\\rG\\128Y\\024\\2476\\190\\159\\161\\234P\\192i)^\\128\\145S\\211\\0145_\\n\\nGB\\237\\1294Q\\166\\249wh\\132\\r\\145zV\\249\\182g\\023\\004\\0258\\207\\217S\\n\\2127en\\021\\006\\236!Qz\\128\\137\\2258\\218~\\209M\\180^\\216\\161\\177\\232\\240\\241\\163\\174E\\175*\\174\\201*\\000\\132\\150|2pt\\003\\168hs\\237\\2032S\\218\\rB\\245\\178I\\018\\025\\230\\152\\189\\191Y\\147\\205:\\028:%S\\150\\252l\\194\\022)\\206\\246\\163\\141\\156\\152nP1k\\180.\\031(\\163\\225\\175\\135\\031ui\\250\\203\\rF\\207\\235u\\213?\\170\\219\\220`UL\\153\\188\\221j\\133%\\242\\166\\244\\231\\176\\168#\\237@\\221P\\252\\r\\000i\\n\\152\\217K!p\\237\\251?V\\155\\214\\222\\239\\169\\204\\161;\\t=\\149\\155\\019n\\224\\029/\\152k\\r$n\\142\\134\\243\\219QJ=\\253\\172\\247u\\006h\\011\\2340\\208\\232E\\195\\192\\214W\\250Ld\\201Z\\027%(\\018\\246\\168\\135\\249\\155\\197\\0213\\230Q\\152\\016\\199\\157\\215\\254|\\216\\015\\141\\140\\180\\131\\164\\246Rdg\\202s\\030;\\215wf\\000\\135\\168\\214\\165\\168?d\\000\\006\\188\\167\\1936\\223\\2045\\147\\b\\235\\196D\\254\\000\\230\\130k\\024s\\023k\\187\\196\\195Z@\\203\\002\\248\\217r\\024\\202\\205\\152\\242c\\221X\\181\\174\\143\\193\\184\\021\\242\\201\\197\\221)?\\199\\162\\232\\019p`P5\\249`\\203\\136T\\251\\1315\\025\\134\\204\\1363\\253\\223z\\255:\\252\\176\\021SI\\175P\\145\\227\\205\\024\\192\\146\\237\\149{\\227q\\215\\155\\202>\\0263\\191\\015\\131\\136\\172\\024\\145%\\148A\\004\\231\\\"\\191\\0118O\\193H;\\165\\r\\137F\\004\\220UF\\2284\\196\\202\\182\\000\\028\\194\\188Y\\250\\199\\152Z*zJ\\132\\167V_\\021\\242\\181\\202L\\r\\205\\241\\159\\153\\147q\\t\\185k!\\231\\165A\\209B\\001$\\022Q6\\232\\t?V\\196\\142T\\000\\254\\213\\194\\168j\\232\\2193\\133c\\245\\167\\2341\\166k-\\b3\\226\\183:\\214\\012\\166ac>\\212\\151\\030\\195\\165\\0018\\219\\182|}HB\\191\\254\\239\\177\\003\\229\\141\\147@\\026\\247\\004\\244\\204\\029\\246\\129>q\\241!\\251\\170f\\029\\203\\128\\148^\\241\\024>\\195\\207\\016\\183\\1987\\024JP;\\026\\174\\145\\b\\011R\\190\\155\\240\\240\\187\\017\\145\\157Pm\\240;\\184\\159\\246\\181:\\146\\214\\248\\015\\001\\150\\029\\197@%\\\\\\152T ~X\\178O\\210)\\239\\177n\\018\\005\\166K\\\\\\187\\152ef\\175\\132\\026\\236jM\\141\\165B\\000]9v\\021\\151\\154\\248&\\011\\204\\233'\\149\\244\\0188\\2074\\215{C`\\225\\228\\020\\209\\199\\147}\\172ky\\231M\\2299\\243r\\141\\022\\128\\225\\th\\027Ko\\128\\017\\254\\166\\167X\\248\\233'\\220.\\022\\236\\243\\196\\025\\190o\\149v\\022xd\\2555\\157j {r?\\024\\127w\\134\\021\\210\\240s+7\\175\\022\\153w\\148\\207\\131Id\\216y9'\\166u><\\022\\185\\137!\\213=\\024T\\002\\232t\\243\\024\\168\\025\\253\\242\\243\\172fg& E\\170\\138&fN|\\166\\254\\147\\241Q\\240iP\\139\\130j\\213\\208lqT\\147\\024\\203\\201\\017\\218kt\\208n\\254(\\006\\000.S`[\\128\\026\\215\\254\\167E\\233vj\\221\\141\\169\\2373X\\157u\\143\\1799\\254\\212\\0122\\156Y\\170'\\183z\\135\\136\\176\\127|\\209\\201\\198\\022\\024u\\\\\\202=\\r0:{\\ta$\\206\\012\\002\\220_E\\026\\015\\003.\\030hs\\029\\000\\184G \\003\\136#w~\\198R-\\154\\030\\1586Y \\195\\231\\206\\006J\\222\\012.\\030\\217mb\\229J\\nI\\211\\164L\\145\\158\\180\\176\\1373=d\\1626\\237\\205\\161\\146\\018t\\172i\\003\\186\\2177\\204\\227\\167\\141\\250$-\\140S\\232\\148g\\204\\152m\\2533-\\185\\135\\215lf\\231sZG\\2394\\233\\015(\\195}i,\\132s\\170\\154$k\\184^\\\\C#\\205\\012Zi\\228\\185\\206\\026\\225`\\249aD|1\\174.\\216-8qxB\\189\\227\\023\\021~\\223\\024j[*Z\\194\\1605\\160i\\177\\138\\027\\183\\144\\216\\161\\182\\014&i\\148\\226p\\242\\132\\165W\\196\\024\\175\\235\\250\\172\\162yL\\138\\246\\164v\\203\\027\\148x\\194\\005\\232\\169\\001\\023\\015qq\\021\\229\\151\\019\\200O\\136\\186\\190.\\192)%\\024\\006\\r,\\200+T\\233\\169\\201\\162\\210\\168|\\233\\030\\021]\\217<\\155,?\\206\\227\\015\\163I`\\242G/\\205\\004\\217\\222\\132\\134\\2465\\201\\185mwo\\1741\\\"\\031\\168O\\148\\160\\214\\214K\\224\\185pI\\185*\\226\\197\\138\\140\\185>y!y\\250\\181\\127\\163,F\\149\\171\\231$,|j\\165\\018;A\\170\\142\\172\\232Z~\\238\\184\\235\\178\\\"\\025\\2015;\\146vq\\017\\153\\170\\168\\001\\130\\023\\022\\235\\162\\235\\218\\159\\234\\196B\\226\\158\\249)?\\\\Ev\\147=S\\026n<\\007Q\\1425\\\"A\\005_=\\220\\245\\178\\225$S\\1846\\156B\\014v\\173\\160\\251ln\\023?\\\"q\\170\\025\\236m\\184\\001\\001\\018a\\022\\005\\00056-\\152o \\197\\152\\229<=\\224\\184\\252A0\\004\\132$1r\\175\\137<\\201\\156\\161\\153\\170\\022\\022<\\240\\149\\030j8_\\180\\234\\139^,\\240\\232\\158T\\128z\\153\\147\\139\\n\\182\\156w\\241\\185\\178\\016\\160]\\021.7\\190\\250\\157\\128\\198(\\251\\139?\\127S\\022\\145,\\023T&\\160\\173\\154\\131\\219x\\bG\\2146\\241\\204\\171\\t\\224\\r6\\204+`v\\1941\\132\\004l\\n*\\006 \\133!VD\\254)T\\154bR\\002PU\\189\\251\\028k\\223#\\014\\192z\\145S\\025\\198\\006\\173\\147\\012A\\221\\127\\tr\\\"\\173\\162wjHNu_\\235-I\\028\\238\\128+\\234\\244\\221\\186\\243\\182\\150\\152h\\157~v\\182p\\202\\166]\\219\\217!\\151\\\"z\\176\\200\\223\\1866$\\181\\201\\141:\\136\\030\\170\\213`\\r\\137\\146\\r\\255\\131\\002Py\\210{\\222<\\234\\221\\020B[\\252\\138@\\211\\016\\192D\\022(\\001%\\025\\215o\\239\\001\\007CM\\197k\\177t\\231\\209a\\012\\222/\\200mj\\167+u\\173\\026\\205q\\200\\175\\225\\167\\025\\242\\229\\232?\\206yA\\251\\1541>+\\146bH\\n\\250hg]\\207\\171d\\178\\n\\229\\128\\t=$\\004\\006\\246hK1<\\228\\006i\\189[\\161\\200\\223>\\213<\\237/G<\\003z\\241\\154\\b\\154\\204\\148\\217\\195\\231\\189\\223f\\163#\\216+\\245E\\025\\187\\143/[\\221H\\254\\206\\180Z\\139\\222\\n\\167\\1609\\150\\161\\006B\\017\\181+\\195M&Xxu\\007$\\232\\213R\\174\\156\\232\\250\\229I,}\\020\\169\\230nu\\023\\206*\\018\\131\\\"j\\156\\211\\011\\147\\130\\151\\180{\\233\\154\\000\\252\\192\\190k\\t\\167?\\024'\\252\\012b\\130\\240o\\142W\\253\\000\\252\\213\\243:\\146\\006x\\177\\001\\252\\012\\169\\223\\006\\143(kw\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\252\\185*\\167V\\180ps\\173\\252\\252\\158\\241\\213#\\249O6\\000\\252\\000|/\\142b\\028\\135Y\\252\\135\\204&\\162s\\246\\199\\156\\000\\252\\175\\242\\182\\158\\029\\130T#\\252~\\245}\\246\\209k\\185\\213\\000\\252\\246\\134\\144\\160\\208\\247{\\020\\252h*$@\\206b^b\\000\\252\\014\\173V2c\\027\\198\\175\\252\\251\\225\\031\\161\\016r\\128\\t\\000\\252\\145A\\172\\202\\190\\030X\\249\\252\\166\\201\\183>\\153\\213\\030W\\000\\252\\189\\195d\\205\\163PN\\170\\252h\\197\\254\\193\\n\\231\\020\\216\\000\\252m\\222^\\130\\223\\172\\029\\178\\252\\165\\007\\219\\197\\023\\162\\b\\254\\000\\252\\127\\170\\230\\233\\214\\015N\\130\\252,\\127\\185N\\152:\\246\\252\\000\\252\\202\\004\\027q+\\1361\\195\\252)&\\174\\182\\199\\1729\\145\\000\\252\\239Q\\129\\253G\\143\\015\\220\\252\\135\\149;\\196Cz\\169\\000\\000\\252\\1912\\134\\209\\030\\2168`\\252\\171\\005\\170\\162p\\188\\179\\249\\000\\252ZG\\175\\229\\224\\210u\\148\\252\\246\\210\\195\\174\\002\\167\\203\\209\\000\\252\\004|-\\249\\246\\015x\\190\\252T\\226\\2512\\145X=\\225\\000\\252\\019u1\\184\\018\\183p\\198\\252\\b>H\\1543\\204u\\022\\000\\252\\209\\184\\202\\177\\162\\176\\193H\\252\\206\\177q\\192\\227\\004f\\027\\000\\000\\000\\014\\000\\000\\000\\000\\000b\\153TI\\021\\240\\155\\231\\193y\\017D-%H@S\\180Y\\005\\219\\159AV0a\\253}\\1882\\211\\015\\172\\215R\\133\\247\\193\\162O\\199\\177\\230\\226|<\\022:U\\166\\177\\23169\\003\\029\\004\\235\\165^P\\004\\005\\022\\252o\\191\\230\\172\\201\\179\\1303\\252c\\024v\\249XC\\151y\\000\\252\\151\\135\\136\\233\\006+:\\221\\252\\199\\161D)@\\230z\\221\\000\\252\\203\\159\\156\\2440\\229\\232\\198\\252\\221\\156\\160\\205e\\187\\221\\007\\000\\252\\019\\026i\\135\\162Y,S\\252{oe*\\176\\188!\\169\\000\\252\\139\\007\\016\\143\\177w\\156\\226\\252\\238\\012k\\223\\000_\\\\\\248\\000\\252\\135\\156\\176\\007-\\167\\189\\029\\252\\160&_\\233\\226\\151\\027M\\000\\252\\017_\\128V|tu\\156\\252\\232\\241\\206\\250ic\\254\\161\\000\\252M`\\233\\219\\223\\138+\\\\\\252\\155\\247\\016\\242\\140q\\140Z\\000\\252Hk\\224Q\\\\\\179\\192\\\"\\252\\237m\\169@s\\139\\136\\166\\000\\252ndv^\\181\\215\\007\\144\\252\\018\\142N\\2199\\139\\198\\193\\000\\252\\201+?7^\\227ED\\252\\229\\205\\140\\252\\021\\199@\\157\\000\\252N\\170\\188K\\132\\130\\152B\\252\\188\\183\\175\\208\\215'\\169\\151\\000\\252wn\\253\\255[=\\202\\153\\252\\148B\\\\\\021Uj\\230\\239\\000\\252T\\153\\151!q\\178}K\\252@\\200\\147a\\224\\162\\031\\149\\000\\252\\179G\\007\\178\\190\\204\\209,\\252\\029\\002d\\242<\\222\\209[\\000\\000\\252o\\191\\230\\172\\201\\179\\1303\\252c\\024v\\249XC\\151y\\000\\252\\151\\135\\136\\233\\006+:\\221\\252\\199\\161D)@\\230z\\221\\000\\252\\203\\159\\156\\2440\\229\\232\\198\\252\\221\\156\\160\\205e\\187\\221\\007\\000\\252\\019\\026i\\135\\162Y,S\\252{oe*\\176\\188!\\169\\000\\252\\139\\007\\016\\143\\177w\\156\\226\\252\\238\\012k\\223\\000_\\\\\\248\\000\\252\\135\\156\\176\\007-\\167\\189\\029\\252\\160&_\\233\\226\\151\\027M\\000\\252\\017_\\128V|tu\\156\\252\\232\\241\\206\\250ic\\254\\161\\000\\252M`\\233\\219\\223\\138+\\\\\\252\\155\\247\\016\\242\\140q\\140Z\\000\\252Hk\\224Q\\\\\\179\\192\\\"\\252\\237m\\169@s\\139\\136\\166\\000\\252ndv^\\181\\215\\007\\144\\252\\018\\142N\\2199\\139\\198\\193\\000\\252\\201+?7^\\227ED\\252\\229\\205\\140\\252\\021\\199@\\157\\000\\252N\\170\\188K\\132\\130\\152B\\252\\188\\183\\175\\208\\215'\\169\\151\\000\\252wn\\253\\255[=\\202\\153\\252\\148B\\\\\\021Uj\\230\\239\\000\\252T\\153\\151!q\\178}K\\252@\\200\\147a\\224\\162\\031\\149\\000\\252\\179G\\007\\178\\190\\204\\209,\\252\\029\\002d\\242<\\222\\209[\\000\\000\\000\\000\\000\\000\\001+\\178z\\189\\247\\143\\2441kS\\153\\134\\228\\129.A\\145\\194\\241\\n\\242\\157v\\230\\254R~\\231=!\\028yl\\212\\198\\242\\150\\168\\251\\127\\131#\\239X\\007\\\\zs\\0160C\\178B\\029\\208)\\143\\162\\135]A\\t\\007\\001\\232\\236M\\246\\175l\\000\\155x\\165[\\244t(\\230\\019h\\002\\022w\\232\\189?\\205\\030\\231\\189\\135\\244\\194\\179\\007\\001\\171\\127\\188\\169\\169\\025\\150?7\\222\\003\\216\\141\\161&\\160\\205\\230\\147\\214\\003l\\004\\147xZa\\210\\217|+\\021\\001\\230\\134'\\178\\191Y\\0017\\206(\\161\\160\\185\\131m^\\1274U]Pz\\190\\235B\\022n\\209w\\0182\\019\\001\\202\\255\\136td\\134E\\219\\019a\\176lK\\1963\\255\\243\\153\\1332\\245?\\220\\222\\1769\\1510\\217\\028!.\\001\\031\\250V\\151\\255/)\\b\\214\\187\\140\\195\\139\\006%\\214\\255-\\223\\b\\131M]\\252#S(\\015\\137\\000\\254\\007\\001|\\226\\192\\159]\\201g\\171\\027^\\014\\145\\242\\206Fp\\177\\135\\157a\\020tfM\\012(\\207?\\232\\173\\158$\\001\\239|%z\\143U\\142i\\012\\022\\230U3jT\\150\\205I)-C\\253]Q\\198\\138\\n\\001\\199\\1712\\\"\\001\\245*\\234Y\\196\\237\\148z\\127B\\016\\135\\176\\031\\184\\175\\225\\031`\\135`\\025\\019\\146\\185\\156= Hr'$\\001\\252\\245\\213\\132?Tn\\194\\025\\248\\233LIj\\175\\225\\003\\212x\\148\\181.V\\003\\248\\145\\161W\\184s\\203/\\001\\216\\161\\018p\\254B\\018\\129\\245Ap4\\191\\1863\\149\\251 /\\1654t\\012\\r,I\\175_l\\246\\133&\\001\\168\\215\\239\\213}\\244\\207\\213\\138\\198B=\\189\\144k\\003\\022KRT\\219\\151\\215\\228\\138\\006\\244\\235z\\b\\217#\\0016\\002\\\"\\186\\135\\255W&\\208\\185h\\235|_d\\173\\181\\215\\1512{-\\221Mr\\219\\b6J>\\028\\006\\001\\027\\014\\230\\015\\235\\209Y\\014\\025D\\176\\168\\001\\176\\143\\231&\\204\\2397\\163R\\031\\161`\\005%tp\\015\\003,\\0016/\\136m\\132\\216\\205\\022\\183\\146q;\\002\\bR@\\162\\132d\\000\\254\\167Dt\\252W\\155\\193\\144\\246\\179#\\001\\127nv'\\218\\003\\201\\206\\241\\176\\232F\\219\\146u\\192J\\028\\018\\148=\\180\\247\\\\\\128w\\197n\\151\\rI\\003\\001q\\152\\173\\221\\1574D\\148\\r\\175\\007=\\130g\\185\\226\\153\\180\\243\\181\\1843\\011d\\154\\132\\197\\222\\014\\189&\\014\\001I\\205\\143\\176\\142\\148\\234\\158\\149\\225\\165\\250H\\156\\023\\011\\240\\b\\197\\146\\144!\\224\\248\\185\\173;\\2229j\\254\\031\\001\\170\\\\[\\166\\023HT;Z!\\227\\233?\\158k|x\\252:\\219\\211\\194\\2485]\\135k-\\176\\020\\220*\\001\\208\\018Gy\\165\\174\\157&\\2271H\\t\\003%XFE\\159\\194\\025\\179\\015{S\\178\\246\\146\\235jMa,\\001\\217\\201\\179H\\176\\229~y\\178\\246Zy\\020vn\\238\\254\\154\\165|<\\b\\177{\\176\\\"z\\243!\\131|$\\001h\\215\\b\\021\\197\\241k\\191|\\191\\205\\176\\0024\\255J*\\157H#ss\\184\\211\\243\\127v\\248\\154\\011 \\n\\001\\240\\157?\\185\\133\\198\\149\\159L\\156$Bb\\176z\\140<\\161\\248#\\239\\238\\144\\134\\007Z-\\1301*\\172-\\001cK\\156\\138\\169\\182\\188\\131E\\130\\026\\232s~O\\202\\132{\\204\\2303\\025\\154\\162\\129\\029\\170Z\\245f\\0069\\001\\031\\001*yV\\176\\143\\242\\166]k\\250\\203\\r\\158\\131x\\007]\\134\\196\\177\\235\\127 %\\012\\206\\254a\\242\\17061\\000\\001\\219\\185N\\182+\\183\\223\\190U\\151'#\\173+D\\234i\\183Kx\\029\\132f\\030\\219\\015\\130a\\196\\210b\\007\\001\\b\\233\\155\\220\\240\\133\\201(\\245\\025[\\185\\214x\\156\\206&ls\\248\\241s\\231~%\\140\\192\\145q%\\222?\\001\\216\\162\\189\\210\\028\\162\\025\\221|\\r\\161q\\240\\127\\205l\\196\\031a\\253w\\239v\\176\\136:\\025.\\150i\\137\\004\\001\\1931\\003\\169g8)\\185\\199\\234\\255R\\221d\\215\\243\\149\\006te\\129@\\026\\025\\135\\166\\151]\\180\\178\\139\\012\\001,\\029\\146\\141\\252\\\"\\227\\005\\194\\205\\192F5\\226\\252\\228\\145\\148\\241\\246\\1766!\\187a\\181\\233\\240F\\248\\028\\\"\\001\\245\\169\\182\\166\\249\\031\\031}Cl[8\\148 \\153[\\154\\130\\128\\160\\171\\203\\131\\255\\195\\153\\211\\224\\232\\195\\181\\025\\001\\254\\167\\017\\239!=:D\\020\\175D '\\012\\021U\\180\\216,,\\249]A\\252C\\016\\183\\164\\203\\b\\128\\022\\001\\220k\\224\\182$\\178\\255\\169\\218\\181\\155}\\212\\143\\019L\\130\\192\\205\\225\\136\\162\\248\\199y\\174\\244\\162N\\207%\\n\\001&7bQ\\224\\155\\248m:\\238@\\194\\244\\250\\027\\232Hq?'\\13104\\2247JMY\\017o\\195\\028\\001\\026\\249A\\180a\\187\\007\\231,i\\131\\130\\200V\\252\\006\\235\\207\\223>\\158\\183\\200x\\194\\b\\148F\\1751R\\020\\001Cs\\203R\\152\\181\\132eim=\\181\\2134\\162j\\217\\024\\238\\162Ru}\\187.\\030\\139\\157\\132\\020'\\020\\001g\\233\\236\\138\\198v;\\145u\\235\\133\\212}\\170@\\247 \\018\\166=~\\248-\\138p\\230\\145i+oE\\022\\001\\016\\233\\238\\174\\016\\200s\\194\\141\\015\\020\\192\\158R\\215\\1310\\254w\\229\\002C\\198kM\\153'\\251\\247r\\143\\015\\001\\210\\146S\\003p\\017\\200\\198\\139iDT\\005%6~n\\142ea\\144\\188n\\165>fA\\b\\132\\184\\215=\\001l$ \\220\\001\\025\\tA!\\176so\\133X\\005\\141\\148;\\183\\138\\192\\251tF\\153\\139_x#6\\161\\142\\138)\\208PM\\154j\\223,;t+\\001\\183!\\131]\\179p\\131j\\220\\021\\197\\134\\023\\133u\\019\\028\\231\\166\\134\\255\\029\\184\\1716\\216\\127\\212\\156\\228\\2102\\001\\140e\\254\\2535\\031 \\029\\019\\131\\142\\192\\031\\208\\172\\1714\\204\\171\\132\\\"\\024\\144\\230\\001Ca-\\199\\160n\\020\\001+\\173q\\005e\\000\\011\\029aH\\159\\191(sj_T\\164\\250]\\215\\141&\\001\\248\\144\\162\\192\\153\\133G+\\001r\\025\\005\\193m\\005B7\\011A\\142\\162K\\017\\031\\000E\\200`~\\207r\\178\\240\\206]\\145\\026\\199\\021\\133<\\001\\024\\218F;3z\\187\\187\\224\\133\\b@\\238\\179\\140\\191{\\180\\183v\\021I*\\196\\238\\186F~\\207y\\011\\002\\001`T[\\018\\161@S\\129\\177\\225x\\222m\\177\\233#\\026\\253\\151\\011+v\\177\\209\\222\\018\\179\\b]\\027\\153=\\001bT\\171\\173\\207\\223\\172\\131\\219\\156\\211\\029\\183\\195\\2518`\\004\\200\\152\\005\\227\\253\\227\\236\\003\\250OEt\\225\\018\\001#\\007Q\\194\\241\\172\\027\\014\\2238\\210\\145~\\012Q\\207\\241\\189k\\188\\229b\\149\\170\\244*I\\154#\\141{9\\001\\250Q\\246\\242.P\\174\\210j\\230\\189\\190\\212-\\172a\\178;]aA\\132\\014B\\148\\249\\131\\020\\196?\\r\\b\\001nd\\197\\029\\213\\018E\\1845l\\234Q\\251[\\016t\\028Z\\144yw^\\r\\242\\166\\169\\028%\\185\\131+%\\001\\203\\189\\209J%\\231\\167\\007\\236\\158k\\164\\235\\230\\236\\246\\184\\\\q\\n^\\t\\172\\150\\221R\\024{\\175'\\224\\016\\001\\027\\237%-\\246\\160L\\141\\225\\202\\237\\173O\\173\\137`h:B\\022\\198\\208-w+y\\021m\\218\\020\\234>\\001\\190\\242\\182\\160\\247\\149\\187\\216\\020\\006\\131\\023n\\000%\\201e}W$\\224\\237Tmr\\204\\000c\\159g\\007\\020\\001]\\213\\212@\\213_0f\\236\\137\\175\\005\\242\\026\\228\\145\\201{\\189\\230\\025\\250\\152\\252rQ\\225\\234\\249\\b;\\025\\000\\001\\217a\\003\\155P\\239\\232\\176\\r\\019\\133\\185|\\000\\185\\200\\237\\012;H\\0051&vP\\221\\229q\\017\\172t\\017\\001k\\132?\\218K\\028\\019n\\155\\187\\245I=\\147\\145\\012`\\247\\160\\1684\\233\\237\\240\\003\\023Wr\\247\\182\\170\\019\\001\\148\\151\\018\\200-Zi\\1799\\191Q\\1314n\\198\\237\\163\\190\\207={D&\\248\\227\\bY5Ht\\130\\b\\001\\220L\\245o\\181\\179~O\\005\\253\\205\\021\\198Z\\175G\\002K\\127\\188\\246\\253\\204\\028Z\\2155\\203>V_\\007\\001~el\\158y\\174 \\207\\153\\143\\176#\\167\\018\\001\\224\\243\\151\\213[\\\"\\019DDF\\162\\150\\1355\\000\\003\\\"\\001\\183\\181\\192\\0140\\252\\1361\\194\\004\\t\\158\\154Fmt\\216\\251\\183\\236\\209\\235\\247\\183jD\\221\\203;\\163\\1892\\001*]\\217A\\168\\207\\b,\\160Tg\\158.\\169\\005\\150\\005(;\\nV\\239)\\027)\\003\\209?\\218\\141\\2303\\001\\027\\162z\\209\\210\\021\\209\\239\\144\\007/ !\\143\\154\\237\\189\\247\\197\\\"\\134\\130rGE\\001\\225\\182\\227T\\1462\\001\\223X\\1939\\179\\012vG\\128q.\\140\\209ib\\021\\2546\\134~\\1476\\157p\\187D\\226\\190\\128gB\\024\\001\\139\\225\\168\\152\\238n\\130\\177\\031\\223r\\232\\251\\017\\247&D\\t\\142\\140\\183\\015\\006\\176\\233\\227\\192\\246\\161Z\\253>\\001\\245\\244\\\"\\151\\227\\222\\253\\228\\235\\031\\224\\011_b]R\\029>g\\201\\014\\169d\\184\\129Ui\\182\\238o\\0215\\001\\244\\144h}D\\172:\\007\\254Y\\006%\\240b\\236NW\\003ZhX\\168\\164\\216\\130;\\029\\1417\\150\\2248\\0017\\243\\145\\130\\204\\246\\\\LX\\135\\020\\024\\194\\147{\\211\\159\\023z86\\241)\\167|\\193~rD~W\\004\\001\\023\\022\\153Cf\\029\\180\\023\\128\\158\\135\\130]\\214\\018Q\\156\\018ga~\\165\\147\\153\\217 \\001\\225\\234\\234\\181\\162&\\135DV\\210\\004\\244\\018T(c~\\203\\018\\180]\\206o\\031+\\181CpW\\167],\\0019\\024\\244\\030\\168\\138^\\213^\\176\\020\\242\\025\\214\\132\\143\\251\\235\\\"\\149F#z \\0231\\246\\216Wd,<\\001(\\129\\219\\244kx\\215l\\028\\131\\2286\\189\\160\\133\\012E\\168\\167\\023\\174~\\153(\\130\\170\\241\\207/\\137\\242\\019\\001\\133dZ[\\181jE\\195\\196Md\\221\\227\\172\\240\\020f\\028\\136+\\129\\147T\\\"\\201'u\\027!\\137\\2275\\001\\175\\156\\238U\\220\\131\\172\\011\\175\\169\\024\\166\\181\\1661\\005\\178)\\006N\\162\\\"\\142\\185\\194\\163\\130\\211\\215\\179\\253$\\001\\241\\134r\\239<\\134M\\249\\199U\\200ad\\\\&\\167\\020\\212\\187\\207\\030`l)r\\249\\023\\149\\224\\017\\203\\031\\001A\\222\\168$\\183\\168)M\\247\\228U'\\202\\220\\143\\185^O\\187\\230\\235\\230z\\194ko\\197\\146Kr\\179!\\001\\220-\\145\\200\\201\\141\\151\\243\\193\\172\\201%\\229bry\\238\\186\\158\\179\\224\\2557\\203\\031\\223\\015N4\\171\\1613\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\250_\\130\\146A-\\205\\129F\\016m\\136D\\248\\159\\231\\138\\242\\187Nc\\162\\193,\\239v>K\\202\\n\\192,\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\000\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\000_\\237f\\144(\\136\\155\\028\\146\\165\\241Ac3\\249pC\\228\\027rG\\148\\190z\\212\\148\\177\\t\\235F0\\b\\164\\027o\\160\\129\\149\\020\\157\\254pe\\136\\211o\\168M\\025v\\137\\174\\247\\138\\192t\\153tvYg\\134\\129\\003iyJ\\160\\136\\n=\\235\\242\\019\\1967\\\"\\206\\160\\246J\\151hZz\\179\\147\\218\\244\\137\\146\\240\\0222\\172\\021vgd%\\232v7\\005\\196\\167,N\\160\\197\\169\\028\\029\\238\\1686d\\015Fr.r\\\"O\\232\\249D2LE\\131\\222\\171Jw\\025\\234R;OV&_Y\\027\\245D\\223c\\203H\\018\\162\\213\\236\\031\\025\\127\\028\\020\\169\\n:(\\131\\225u\\236\\213\\219\\164\\213(I\\002\\181k\\170\\162\\209\\029\\238fw\\004u\\015\\144_ V \\188\\131\\199\\226s\\196\\017[F_\\160,\\205\\011\\011\\155\\158vH\\221\\133\\229\\215\\200\\158\\146\\243\\005\\176\\162\\001/\\158\\001J\\154S\\148\\r\\\"1v\\231\\\\+\\n\\015|fS~\\175mR\\192\\192\\244\\r]\\143\\198n\\2295\\212K\\\"96N\\007\\137A\\250\\184G\\182\\140\\028m\\175L\\211<\\239'\\239\\160\\133@R\\225\\018j\\135\\014\\003\\2516\\164nx\\133T\\152_\\019\\240h\\199J\\226J7\\232N\\156\\006l\\215!\\0005\\170\\2109\\225\\150\\006\\031\\030\\235\\243AH\\194e\\132\\002\\019=P\\007\\0167f\\138\\2182\\186q\\2514*\\224\\001\\151\\255\\249A':\\190\\159\\180\\187EGm\\192\\235\\162\\229\\206\\030\\253\\219\\153\\208\\002`\\213b\\190\\185\\172\\154\\030~\\221\\139\\182\\127\\171\\248H\\210\\007\\152\\221\\196K\\243\\179\\227C4\\203\\128`\\250\\2107\\172\\171\\193R\\1330\\209\\194\\129\\219\\026\\029p\\031R\\152o\\238\\174\\154G6eE\\184\\011\\217<%\\1734\\193\\021\\150\\011i\\237Oe\\142^\\202Y\\180\\148w\\170\\249\\127c\\023[\\247\\235\\130d\\0249\\166\\214d&#\\175{\\153bo\\168\\223j\\138\\137\\177\\138?-\\014\\192S#\\245\\179\\127i\\227z`\\\"+9m*\\133\\tp\\196\\183e\\154\\249\\207\\005\\r\\212\\0209:Z%\\017V\\t\\236U\\151x\\129|\\191\\230\\006_\\141EI\\003p\\175\\158\\156e\\217.\\253\\147\\150\\215\\177\\022$+9\\181\\209p@\\006#\\015\\166\\227\\253\\028\\022>\\217\\242\\246\\209\\247\\019?\\141^M\\238\\249H\\027j\\153\\220\\151\\167\\020\\228z(?DJ\\172\\233\\224'\\21178\\018\\214T\\228\\253\\246#:d\\182J\\223\\211\\173F'\\205\\230\\165\\214\\215\\027\\137\\131\\246?fL)L\\197K1\\232\\197\\149\\207\\216\\155d|\\207\\011\\249T#\\182\\021\\005\\201\\161$\\249\\165\\001\\183\\248R\\000\\0052\\204\\tj\\025\\213\\227h)\\174\\\\wo\\2448\\019Kk\\169}\\012\\133\\235\\022\\154\\005\\219t \\214\\028=\\026\\134{\\254\\132g _0?$\\185L\\151\\020;\\182\\b\\143#\\026\\137\\203q\\146\\195\\206\\185hGQ\\127\\r\\139\\204K\\131\\145\\017\\027\\143\\214'P\\244\\219/\\005\\004\\154-\\001\\145tg\\242\\200\\\"\\026\\217\\244\\225\\184\\177\\000|O\\246;\\006zDmw\\158\\031\\185\\206\\0056z\\230\\244\\028\\255\\230\\253\\137g\\019\\011\\161gH\\199<\\003i\\252sOj\\175\\243.\\224 +\\146ng\\209\\003\\202\\136\\208\\2323\\190\\006x\\244\\247R\\145\\166\\152\\2392\\226/\\204\\011\\231\\224\\244v\\205\\238\\\"\\196\\tV\\231 \\188\\186\\143{\\149i\\147B\\185\\t\\135\\198\\207\\220q0!\\234&b\\250\\019~R\\027\\016\\231\\rG\\128Y\\024\\2476\\190\\159\\161\\234P\\192i)^\\128\\145S\\211\\0145_\\n\\nGB\\237\\1294Q\\166\\249wh\\132\\r\\145zV\\249\\182g\\023\\004\\0258\\207\\217S\\n\\2127en\\021\\006\\236!Qz\\128\\137\\2258\\218~\\209M\\180^\\216\\161\\177\\232\\240\\241\\163\\174E\\175*\\174\\201*\\000\\132\\150|2pt\\003\\168hs\\237\\2032S\\218\\rB\\245\\178I\\018\\025\\230\\152\\189\\191Y\\147\\205:\\028:%S\\150\\252l\\194\\022)\\206\\246\\163\\141\\156\\152nP1k\\180.\\031(\\163\\225\\175\\135\\031ui\\250\\203\\rF\\207\\235u\\213?\\170\\219\\220`UL\\153\\188\\221j\\133%\\242\\166\\244\\231\\176\\168#\\237@\\221P\\252\\r\\000i\\n\\152\\217K!p\\237\\251?V\\155\\214\\222\\239\\169\\204\\161;\\t=\\149\\155\\019n\\224\\029/\\152k\\r$n\\142\\134\\243\\219QJ=\\253\\172\\247u\\006h\\011\\2340\\208\\232E\\195\\192\\214W\\250Ld\\201Z\\027%(\\018\\246\\168\\135\\249\\155\\197\\0213\\230Q\\152\\016\\199\\157\\215\\254|\\216\\015\\141\\140\\180\\131\\164\\246Rdg\\202s\\030;\\215wf\\000\\135\\168\\214\\165\\168?d\\000\\006\\188\\167\\1936\\223\\2045\\147\\b\\235\\196D\\254\\000\\230\\130k\\024s\\023k\\187\\196\\195Z@\\203\\002\\248\\217r\\024\\202\\205\\152\\242c\\221X\\181\\174\\143\\193\\184\\021\\242\\201\\197\\221)?\\199\\162\\232\\019p`P5\\249`\\203\\136T\\251\\1315\\025\\134\\204\\1363\\253\\223z\\255:\\252\\176\\021SI\\175P\\145\\227\\205\\024\\192\\146\\237\\149{\\227q\\215\\155\\202>\\0263\\191\\015\\131\\136\\172\\024\\145%\\148A\\004\\231\\\"\\191\\0118O\\193H;\\165\\r\\137F\\004\\220UF\\2284\\196\\202\\182\\000\\028\\194\\188Y\\250\\199\\152Z*zJ\\132\\167V_\\021\\242\\181\\202L\\r\\205\\241\\159\\153\\147q\\t\\185k!\\231\\165A\\209B\\001$\\022Q6\\232\\t?V\\196\\142T\\000\\254\\213\\194\\168j\\232\\2193\\133c\\245\\167\\2341\\166k-\\b3\\226\\183:\\214\\012\\166ac>\\212\\151\\030\\195\\165\\0018\\219\\182|}HB\\191\\254\\239\\177\\003\\229\\141\\147@\\026\\247\\004\\244\\204\\029\\246\\129>q\\241!\\251\\170f\\029\\203\\128\\148^\\241\\024>\\195\\207\\016\\183\\1987\\024JP;\\026\\174\\145\\b\\011R\\190\\155\\240\\240\\187\\017\\145\\157Pm\\240;\\184\\159\\246\\181:\\146\\214\\248\\015\\001\\150\\029\\197@%\\\\\\152T ~X\\178O\\210)\\239\\177n\\018\\005\\166K\\\\\\187\\152ef\\175\\132\\026\\236jM\\141\\165B\\000]9v\\021\\151\\154\\248&\\011\\204\\233'\\149\\244\\0188\\2074\\215{C`\\225\\228\\020\\209\\199\\147}\\172ky\\231M\\2299\\243r\\141\\022\\128\\225\\th\\027Ko\\128\\017\\254\\166\\167X\\248\\233'\\220.\\022\\236\\243\\196\\025\\190o\\149v\\022xd\\2555\\157j {r?\\024\\127w\\134\\021\\210\\240s+7\\175\\022\\153w\\148\\207\\131Id\\216y9'\\166u><\\022\\185\\137!\\213=\\024T\\002\\232t\\243\\024\\168\\025\\253\\242\\243\\172fg& E\\170\\138&fN|\\166\\254\\147\\241Q\\240iP\\139\\130j\\213\\208lqT\\147\\024\\203\\201\\017\\218kt\\208n\\254(\\006\\000.S`[\\128\\026\\215\\254\\167E\\233vj\\221\\141\\169\\2373X\\157u\\143\\1799\\254\\212\\0122\\156Y\\170'\\183z\\135\\136\\176\\127|\\209\\201\\198\\022\\024u\\\\\\202=\\r0:{\\ta$\\206\\012\\002\\220_E\\026\\015\\003.\\030hs\\029\\000\\184G \\003\\136#w~\\198R-\\154\\030\\1586Y \\195\\231\\206\\006J\\222\\012.\\030\\217mb\\229J\\nI\\211\\164L\\145\\158\\180\\176\\1373=d\\1626\\237\\205\\161\\146\\018t\\172i\\003\\186\\2177\\204\\227\\167\\141\\250$-\\140S\\232\\148g\\204\\152m\\2533-\\185\\135\\215lf\\231sZG\\2394\\233\\015(\\195}i,\\132s\\170\\154$k\\184^\\\\C#\\205\\012Zi\\228\\185\\206\\026\\225`\\249aD|1\\174.\\216-8qxB\\189\\227\\023\\021~\\223\\024j[*Z\\194\\1605\\160i\\177\\138\\027\\183\\144\\216\\161\\182\\014&i\\148\\226p\\242\\132\\165W\\196\\024\\175\\235\\250\\172\\162yL\\138\\246\\164v\\203\\027\\148x\\194\\005\\232\\169\\001\\023\\015qq\\021\\229\\151\\019\\200O\\136\\186\\190.\\192)%\\024\\006\\r,\\200+T\\233\\169\\201\\162\\210\\168|\\233\\030\\021]\\217<\\155,?\\206\\227\\015\\163I`\\242G/\\205\\004\\217\\222\\132\\134\\2465\\201\\185mwo\\1741\\\"\\031\\168O\\148\\160\\214\\214K\\224\\185pI\\185*\\226\\197\\138\\140\\185>y!y\\250\\181\\127\\163,F\\149\\171\\231$,|j\\165\\018;A\\170\\142\\172\\232Z~\\238\\184\\235\\178\\\"\\025\\2015;\\146vq\\017\\153\\170\\168\\001\\130\\023\\022\\235\\162\\235\\218\\159\\234\\196B\\226\\158\\249)?\\\\Ev\\147=S\\026n<\\007Q\\1425\\\"A\\005_=\\220\\245\\178\\225$S\\1846\\156B\\014v\\173\\160\\251ln\\023?\\\"q\\170\\025\\236m\\184\\001\\001\\018a\\022\\005\\00056-\\152o \\197\\152\\229<=\\224\\184\\252A0\\004\\132$1r\\175\\137<\\201\\156\\161\\153\\170\\022\\022<\\240\\149\\030j8_\\180\\234\\139^,\\240\\232\\158T\\128z\\153\\147\\139\\n\\182\\156w\\241\\185\\178\\016\\160]\\021.7\\190\\250\\157\\128\\198(\\251\\139?\\127S\\022\\145,\\023T&\\160\\173\\154\\131\\219x\\bG\\2146\\241\\204\\171\\t\\224\\r6\\204+`v\\1941\\132\\004l\\n*\\006 \\133!VD\\254)T\\154bR\\002PU\\189\\251\\028k\\223#\\014\\192z\\145S\\025\\198\\006\\173\\147\\012A\\221\\127\\tr\\\"\\173\\162wjHNu_\\235-I\\028\\238\\128+\\234\\244\\221\\186\\243\\182\\150\\152h\\157~v\\182p\\202\\166]\\219\\217!\\151\\\"z\\176\\200\\223\\1866$\\181\\201\\141:\\136\\030\\170\\213`\\r\\137\\146\\r\\255\\131\\002Py\\210{\\222<\\234\\221\\020B[\\252\\138@\\211\\016\\192D\\022(\\001%\\025\\215o\\239\\001\\007CM\\197k\\177t\\231\\209a\\012\\222/\\200mj\\167+u\\173\\026\\205q\\200\\175\\225\\167\\025\\242\\229\\232?\\206yA\\251\\1541>+\\146bH\\n\\250hg]\\207\\171d\\178\\n\\229\\128\\t=$\\004\\006\\246hK1<\\228\\006i\\189[\\161\\200\\223>\\213<\\237/G<\\003z\\241\\154\\b\\154\\204\\148\\217\\195\\231\\189\\223f\\163#\\216+\\245E\\025\\187\\143/[\\221H\\254\\206\\180Z\\139\\222\\n\\167\\1609\\150\\161\\006B\\017\\181+\\195M&Xxu\\007$\\232\\213R\\174\\156\\232\\250\\229I,}\\020\\169\\230nu\\023\\206*\\018\\131\\\"j\\156\\211\\011\\147\\130\\151\\180\\001\\1770K \\166yd\\132<\\236\\003\\224\\226FW.\\\\\\137>\\220\\201\\145:\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\"));;\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\n\nlet blockchain_dummy = Dummy_values.blockchain_proof\n\nlet transaction_dummy = Dummy_values.transaction_proof\n\n[%%versioned\nmodule Stable = struct\n module V2 = struct\n type t = Pickles.Proof.Proofs_verified_2.Stable.V2.t\n [@@deriving sexp, yojson, compare]\n\n let to_latest = Fn.id\n\n let to_yojson_full = Pickles.Proof.Proofs_verified_2.to_yojson_full\n end\nend]\n\n[%%define_locally Stable.Latest.(to_yojson, of_yojson, to_yojson_full)]\n","open Core_kernel\n\ntype uint64 = Unsigned.uint64\n\ntype uint32 = Unsigned.uint32\n\nmodule type S = sig\n type t [@@deriving sexp, hash, compare, yojson]\n\n val length_in_bits : int\n\n include Hashable.S with type t := t\n\n include Unsigned.S with type t := t\n\n val ( < ) : t -> t -> bool\n\n val ( > ) : t -> t -> bool\n\n val ( = ) : t -> t -> bool\n\n val ( <= ) : t -> t -> bool\n\n val ( >= ) : t -> t -> bool\n\n val to_bigint : t -> Bigint.t\nend\n\nmodule type F = functor\n (Unsigned : Unsigned.S)\n (M : sig\n val length : int\n end)\n -> S with type t = Unsigned.t\n[@@warning \"-67\"]\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Fold_lib\ninclude Intf\nmodule Intf = Intf\nopen Snark_bits\n\n[%%ifdef consensus_mechanism]\n\nmodule Make_checked\n (N : Unsigned_extended.S)\n (Bits : Bits_intf.Convertible_bits with type t := N.t) =\nstruct\n open Snark_params.Tick\n\n type var = Field.Var.t\n\n let () = assert (Int.(N.length_in_bits < Field.size_in_bits))\n\n let to_input (t : var) =\n Random_oracle.Input.Chunked.packed (t, N.length_in_bits)\n\n let to_input_legacy (t : var) =\n let to_bits (t : var) =\n with_label (sprintf \"to_bits: %s\" __LOC__) (fun () ->\n Field.Checked.choose_preimage_var t ~length:N.length_in_bits )\n in\n Checked.map (to_bits t) ~f:(fun bits ->\n Random_oracle.Input.Legacy.bitstring bits )\n\n let constant n =\n Field.Var.constant\n (Bigint.to_field (Bigint.of_bignum_bigint (N.to_bigint n)))\n\n let () = assert (Int.(N.length_in_bits mod 16 = 0))\n\n let range_check' (t : var) =\n let _, _, actual_packed =\n Pickles.Scalar_challenge.to_field_checked' ~num_bits:N.length_in_bits m\n (Kimchi_backend_common.Scalar_challenge.create t)\n in\n actual_packed\n\n let range_check t =\n let%bind actual = make_checked (fun () -> range_check' t) in\n Field.Checked.Assert.equal actual t\n\n let range_check_flag t =\n let open Pickles.Impls.Step in\n let actual = range_check' t in\n Field.equal actual t\n\n let of_field (x : Field.t) : N.t =\n let of_bits bs =\n (* TODO: Make this efficient *)\n List.foldi bs ~init:N.zero ~f:(fun i acc b ->\n if b then N.(logor (shift_left one i) acc) else acc )\n in\n of_bits (List.take (Field.unpack x) N.length_in_bits)\n\n let to_field (x : N.t) : Field.t = Field.project (Fold.to_list (Bits.fold x))\n\n let typ : (var, N.t) Typ.t =\n let (Typ field_typ) = Field.typ in\n Typ.transport\n (Typ { field_typ with check = range_check })\n ~there:to_field ~back:of_field\n\n let () = assert (N.length_in_bits * 2 < Field.size_in_bits + 1)\n\n let div_mod (x : var) (y : var) =\n let%bind q, r =\n exists (Typ.tuple2 typ typ)\n ~compute:\n As_prover.(\n let%map x = read typ x and y = read typ y in\n (N.div x y, N.rem x y))\n in\n\n (* q * y + r = x\n\n q * y = x - r\n *)\n let%map () = assert_r1cs q y (Field.Var.sub x r) in\n (q, r)\n\n type t = var\n\n let is_succ ~pred ~succ =\n let open Snark_params.Tick in\n let open Field in\n Checked.(equal (pred + Var.constant one) succ)\n\n let gte x y =\n let open Pickles.Impls.Step in\n let xy = Pickles.Util.seal m Field.(x - y) in\n let yx = Pickles.Util.seal m (Field.negate xy) in\n let x_gte_y = range_check_flag xy in\n let y_gte_x = range_check_flag yx in\n Boolean.Assert.any [ x_gte_y; y_gte_x ] ;\n x_gte_y\n\n let op op a b = make_checked (fun () -> op a b)\n\n let ( >= ) a b = op gte a b\n\n let ( <= ) a b = b >= a\n\n let ( < ) a b =\n make_checked (fun () ->\n let open Pickles.Impls.Step in\n Boolean.( &&& ) (gte b a) (Boolean.not (Field.equal b a)) )\n\n let ( > ) a b = b < a\n\n module Assert = struct\n let equal = Field.Checked.Assert.equal\n end\n\n let to_field = Fn.id\n\n module Unsafe = struct\n let of_field = Fn.id\n end\n\n let min a b =\n let%bind a_lte_b = a <= b in\n Field.Checked.if_ a_lte_b ~then_:a ~else_:b\n\n let if_ = Field.Checked.if_\n\n let succ_if (t : var) (c : Boolean.var) =\n Checked.return (Field.Var.add t (c :> Field.Var.t))\n\n let succ (t : var) =\n Checked.return (Field.Var.add t (Field.Var.constant Field.one))\n\n let seal x = make_checked (fun () -> Pickles.Util.seal m x)\n\n let add (x : var) (y : var) =\n let%bind res = seal (Field.Var.add x y) in\n let%map () = range_check res in\n res\n\n let mul (x : var) (y : var) =\n let%bind res = Field.Checked.mul x y in\n let%map () = range_check res in\n res\n\n let subtract_unpacking_or_zero x y =\n let open Pickles.Impls.Step in\n let res = Pickles.Util.seal m Field.(x - y) in\n let neg_res = Pickles.Util.seal m (Field.negate res) in\n let x_gte_y = range_check_flag res in\n let y_gte_x = range_check_flag neg_res in\n Boolean.Assert.any [ x_gte_y; y_gte_x ] ;\n (* If y_gte_x is false, then x_gte_y is true, so x >= y and\n thus there was no underflow.\n\n If y_gte_x is true, then y >= x, which means there was underflow\n iff y != x.\n\n Thus, underflow = (neg_res_good && y != x)\n *)\n let underflow = Boolean.( &&& ) y_gte_x (Boolean.not (Field.equal x y)) in\n (`Underflow underflow, Field.if_ underflow ~then_:Field.zero ~else_:res)\n\n let sub_or_zero a b = make_checked (fun () -> subtract_unpacking_or_zero a b)\n\n (* Unpacking protects against underflow *)\n let sub (x : var) (y : var) =\n let%bind res = seal (Field.Var.sub x y) in\n let%map () = range_check res in\n res\n\n let equal a b = Field.Checked.equal a b\n\n let ( = ) = equal\n\n let zero = Field.Var.constant Field.zero\nend\n\n[%%endif]\n\nopen Snark_params.Tick\n\nmodule Make (N : sig\n type t [@@deriving sexp, compare, hash]\n\n include Unsigned_extended.S with type t := t\n\n val random : unit -> t\nend)\n(Bits : Bits_intf.Convertible_bits with type t := N.t) =\nstruct\n type t = N.t [@@deriving sexp, compare, hash, yojson]\n\n (* can't be automatically derived *)\n let dhall_type = Ppx_dhall_type.Dhall_type.Text\n\n let max_value = N.max_int\n\n include Comparable.Make (N)\n\n include (N : module type of N with type t := t)\n\n let sub x y = if x < y then None else Some (N.sub x y)\n\n let to_field n = Bigint.to_field (Bigint.of_bignum_bigint (N.to_bigint n))\n\n [%%ifdef consensus_mechanism]\n\n module Checked = Make_checked (N) (Bits)\n\n (* warning: this typ does not work correctly with the generic if_ *)\n let typ = Checked.typ\n\n [%%endif]\n\n module Bits = Bits\n\n let to_bits = Bits.to_bits\n\n let of_bits = Bits.of_bits\n\n let to_input (t : t) =\n Random_oracle.Input.Chunked.packed (to_field t, N.length_in_bits)\n\n let to_input_legacy t = Random_oracle.Input.Legacy.bitstring (to_bits t)\n\n let fold t = Fold.group3 ~default:false (Bits.fold t)\n\n let gen =\n Quickcheck.Generator.map\n ~f:(fun n -> N.of_string (Bignum_bigint.to_string n))\n (Bignum_bigint.gen_incl Bignum_bigint.zero\n (Bignum_bigint.of_string N.(to_string max_int)) )\n\n let gen_incl min max =\n let open Quickcheck.Let_syntax in\n let%map n =\n Bignum_bigint.gen_incl\n (Bignum_bigint.of_string (N.to_string min))\n (Bignum_bigint.of_string (N.to_string max))\n in\n N.of_string (Bignum_bigint.to_string n)\nend\n\nmodule Make32 () : UInt32 = struct\n open Unsigned_extended\n\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n [@@@with_all_version_tags]\n\n type t = UInt32.Stable.V1.t\n [@@deriving sexp, equal, compare, hash, yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n include\n Make\n (struct\n include UInt32\n\n let random () =\n let mask = if Random.bool () then one else zero in\n let open UInt32.Infix in\n logor (mask lsl 31)\n ( Int32.max_value |> Random.int32 |> Int64.of_int32\n |> UInt32.of_int64 )\n end)\n (Bits.UInt32)\n\n let to_uint32 = Unsigned_extended.UInt32.to_uint32\n\n let of_uint32 = Unsigned_extended.UInt32.of_uint32\nend\n\nmodule Make64 () : UInt64 = struct\n open Unsigned_extended\n\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n [@@@with_all_version_tags]\n\n type t = UInt64.Stable.V1.t\n [@@deriving sexp, equal, compare, hash, yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n include\n Make\n (struct\n include UInt64\n\n let random () =\n let mask = if Random.bool () then one else zero in\n let open UInt64.Infix in\n logor (mask lsl 63)\n (Int64.max_value |> Random.int64 |> UInt64.of_int64)\n end)\n (Bits.UInt64)\n\n let to_uint64 = Unsigned_extended.UInt64.to_uint64\n\n let of_uint64 = Unsigned_extended.UInt64.of_uint64\nend\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Fold_lib\nopen Tuple_lib\nopen Unsigned\nopen Snark_bits\nopen Snark_params.Tick\n\nmodule type S_unchecked = sig\n type t [@@deriving sexp, compare, hash, yojson]\n\n include Comparable.S with type t := t\n\n include Hashable.S with type t := t\n\n (* not automatically derived *)\n val dhall_type : Ppx_dhall_type.Dhall_type.t\n\n val max_value : t\n\n val length_in_bits : int\n\n val gen : t Quickcheck.Generator.t\n\n val gen_incl : t -> t -> t Quickcheck.Generator.t\n\n val zero : t\n\n val one : t\n\n val succ : t -> t\n\n val add : t -> t -> t\n\n val sub : t -> t -> t option\n\n val of_int : int -> t\n\n val to_int : t -> int\n\n (* Someday: I think this only does ones greater than zero, but it doesn't really matter for\n selecting the nonce *)\n\n val random : unit -> t\n\n val of_string : string -> t\n\n val to_string : t -> string\n\n module Bits : Bits_intf.Convertible_bits with type t := t\n\n val to_bits : t -> bool list\n\n val of_bits : bool list -> t\n\n val to_field : t -> Field.t\n\n val to_input : t -> Field.t Random_oracle.Input.Chunked.t\n\n val to_input_legacy : t -> (_, bool) Random_oracle.Legacy.Input.t\n\n val fold : t -> bool Triple.t Fold.t\nend\n\n[%%ifdef consensus_mechanism]\n\nmodule type S_checked = sig\n type unchecked\n\n type var\n\n val constant : unchecked -> var\n\n type t = var\n\n val zero : t\n\n val succ : t -> t Checked.t\n\n val add : t -> t -> t Checked.t\n\n val mul : t -> t -> t Checked.t\n\n (** [sub_or_zero x y] computes [x - y].\n\n - If the argument to [`Underflow] is true, [x < y] and the returned integer\n value is pinned to [zero].\n - If the argument to [`Underflow] is false, [x >= y] and the returned\n integer value is equal to [x - y]\n *)\n val sub_or_zero : t -> t -> ([ `Underflow of Boolean.var ] * t) Checked.t\n\n (** [sub ~m x y] computes [x - y] and ensures that [0 <= x - y] *)\n val sub : t -> t -> t Checked.t\n\n val is_succ : pred:t -> succ:t -> Boolean.var Checked.t\n\n val min : t -> t -> t Checked.t\n\n val to_input : t -> Field.Var.t Random_oracle.Input.Chunked.t\n\n val to_input_legacy :\n t -> (_, Boolean.var) Random_oracle.Legacy.Input.t Checked.t\n\n val succ_if : t -> Boolean.var -> t Checked.t\n\n val if_ : Boolean.var -> then_:t -> else_:t -> t Checked.t\n\n (** warning: this typ does not work correctly with the generic if_ *)\n val typ : (t, unchecked) Snark_params.Tick.Typ.t\n\n val equal : t -> t -> Boolean.var Checked.t\n\n val div_mod : t -> t -> (t * t) Checked.t\n\n val ( = ) : t -> t -> Boolean.var Checked.t\n\n val ( < ) : t -> t -> Boolean.var Checked.t\n\n val ( > ) : t -> t -> Boolean.var Checked.t\n\n val ( <= ) : t -> t -> Boolean.var Checked.t\n\n val ( >= ) : t -> t -> Boolean.var Checked.t\n\n module Assert : sig\n val equal : t -> t -> unit Checked.t\n end\n\n val to_field : t -> Field.Var.t\n\n module Unsafe : sig\n val of_field : Field.Var.t -> t\n end\nend\n\n[%%endif]\n\nmodule type S = sig\n include S_unchecked\n\n [%%ifdef consensus_mechanism]\n\n module Checked : S_checked with type unchecked := t\n\n (** warning: this typ does not work correctly with the generic if_ *)\n val typ : (Checked.t, t) Snark_params.Tick.Typ.t\n\n [%%endif]\nend\n\nmodule type UInt32_A = sig\n [%%versioned:\n module Stable : sig\n module V1 : sig\n [@@@with_all_version_tags]\n\n type t [@@deriving sexp, equal, compare, hash, yojson]\n end\n end]\n\n include S with type t := t\n\n val to_uint32 : t -> uint32\n\n val of_uint32 : uint32 -> t\nend\n[@@warning \"-32\"]\n\nmodule type UInt32 = UInt32_A with type Stable.V1.t = Unsigned_extended.UInt32.t\n\nmodule type UInt64_A = sig\n [%%versioned:\n module Stable : sig\n module V1 : sig\n [@@@with_all_version_tags]\n\n type t [@@deriving sexp, equal, compare, hash, yojson]\n end\n end]\n\n include S with type t := Stable.Latest.t\n\n val to_uint64 : t -> uint64\n\n val of_uint64 : uint64 -> t\nend\n[@@warning \"-32\"]\n\nmodule type UInt64 = UInt64_A with type Stable.V1.t = Unsigned_extended.UInt64.t\n\nmodule type F = functor\n (N : sig\n type t [@@deriving bin_io, sexp, compare, hash]\n\n include Unsigned_extended.S with type t := t\n\n val random : unit -> t\n end)\n (Bits : Bits_intf.Convertible_bits with type t := N.t)\n -> S with type t := N.t and module Bits := Bits\n\n[%%ifdef consensus_mechanism]\n\nmodule type F_checked = functor\n (N : Unsigned_extended.S)\n (Bits : Bits_intf.Convertible_bits with type t := N.t)\n -> S_checked with type unchecked := N.t\n[@@warning \"-67\"]\n\n[%%endif]\n","include Nat.Make32 ()\n","module T = Nat.Make32 ()\n\n(** See documentation of the {!Mina_wire_types} library *)\nmodule Wire_types = Mina_wire_types.Mina_numbers.Account_nonce\n\nmodule Make_sig (A : Wire_types.Types.S) = struct\n module type S = sig\n include Nat.Intf.UInt32_A with type Stable.V1.t = A.V1.t\n\n include Codable.S with type t := t\n end\nend\n\nmodule Make_str (_ : Wire_types.Concrete) = struct\n include T\n\n (* while we could use an int encoding for yojson (an OCaml int is 63-bits)\n we've committed to a string encoding\n *)\n include Codable.Make_of_string (T)\nend\n\ninclude Wire_types.Make (Make_sig) (Make_str)\n","module type S_base = sig\n [%%versioned:\n module Stable : sig\n module V1 : sig\n type t [@@deriving hash, sexp, compare, equal, yojson]\n end\n end]\n\n val to_uint32 : t -> Unsigned.uint32\n\n val of_uint32 : Unsigned.uint32 -> t\n\n val to_string : t -> string\n\n val of_string : string -> t\n\n val gen : t Core_kernel.Quickcheck.Generator.t\n\n val gen_incl : t -> t -> t Core_kernel.Quickcheck.Generator.t\n\n val dhall_type : Ppx_dhall_type.Dhall_type.t\n\n val zero : t\n\n val one : t\n\n val succ : t -> t\n\n val of_int : int -> t\n\n val to_int : t -> int\n\n val max_value : t\n\n val to_input : t -> Snark_params.Tick.Field.t Random_oracle.Input.Chunked.t\n\n val to_input_legacy : t -> ('a, bool) Random_oracle.Legacy.Input.t\n\n val to_field : t -> Snark_params.Tick.Field.t\n\n val random : unit -> t\n\n include Core_kernel.Comparable.S with type t := t\nend\n\nmodule type S = sig\n include S_base\n\n type global_slot_span\n\n module Checked : sig\n include Intf.S_checked with type unchecked := t\n\n type global_slot_span_checked\n\n open Snark_params.Tick\n\n val add : t -> global_slot_span_checked -> t Checked.t\n\n val sub : t -> global_slot_span_checked -> t Checked.t\n\n val diff : t -> t -> global_slot_span_checked Checked.t\n\n val diff_or_zero :\n t\n -> t\n -> ([ `Underflow of Boolean.var ] * global_slot_span_checked) Checked.t\n end\n\n val typ : (Checked.t, t) Snark_params.Tick.Typ.t\n\n val add : t -> global_slot_span -> t\n\n val sub : t -> global_slot_span -> t option\n\n val diff : t -> t -> global_slot_span option\nend\n\nmodule type S_span = sig\n include S_base\n\n module Checked : Intf.S_checked with type unchecked := t\n\n val typ : (Checked.t, t) Snark_params.Tick.Typ.t\n\n val add : t -> t -> t\n\n val sub : t -> t -> t option\nend\n","(** Legacy global slot implementation *)\n\n(* Used *only* for V1 payments, delegation valid_until field *)\n\n(** See documentation of the {!Mina_wire_types} library *)\nmodule Wire_types = Mina_wire_types.Mina_numbers.Global_slot_legacy\n\nmodule Make_sig (A : Wire_types.Types.S) = struct\n module type S = Nat.Intf.UInt32_A with type Stable.V1.t = A.V1.t\nend\n\nmodule T = Nat.Make32 ()\n\nmodule Make_str (_ : Wire_types.Concrete) = struct\n include T\nend\n\ninclude Wire_types.Make (Make_sig) (Make_str)\n","open Core_kernel\n\ntype uint32 = Unsigned.uint32\n\nmodule type S = sig\n [%%versioned:\n module Stable : sig\n module V1 : sig\n type t [@@deriving sexp, compare]\n end\n end]\n\n module T : Intf.UInt32\n\n val to_uint32 : t -> uint32\n\n val of_uint32 : uint32 -> t\nend\n\nmodule Make (M : S) = struct\n type global_slot_span = Global_slot_span.t\n\n module T = M.T\n\n let to_uint32 = M.to_uint32\n\n let of_uint32 = M.of_uint32\n\n module Checked = struct\n include T.Checked\n\n type global_slot_span_checked = Global_slot_span.Checked.t\n\n let constant t = constant (to_uint32 t)\n\n open Snark_params.Tick\n\n let add t (span : global_slot_span_checked) =\n let t' = Global_slot_span.Checked.to_field span |> Unsafe.of_field in\n add t t'\n\n let sub t (span : global_slot_span_checked) =\n let t' = Global_slot_span.Checked.to_field span |> Unsafe.of_field in\n sub t t'\n\n let diff t1 t2 : global_slot_span_checked Checked.t =\n let%map diff = T.Checked.sub t1 t2 in\n let field = T.Checked.to_field diff in\n (* `of_field` is the identity function, here applied to a checked field *)\n Global_slot_span.Checked.Unsafe.of_field field\n\n let typ = Typ.transport T.Checked.typ ~there:to_uint32 ~back:of_uint32\n\n let diff_or_zero t1 t2 =\n let%map underflow, diff = T.Checked.sub_or_zero t1 t2 in\n let field = T.Checked.to_field diff in\n (* `of_field` is the identity function, here applied to a checked field *)\n let span = Global_slot_span.Checked.Unsafe.of_field field in\n (underflow, span)\n end\n\n let to_string t = Unsigned.UInt32.to_string @@ to_uint32 t\n\n let of_string s = of_uint32 @@ Unsigned.UInt32.of_string s\n\n let typ = Checked.typ\n\n let gen =\n let%map.Quickcheck u32 = T.gen in\n of_uint32 u32\n\n let gen_incl t1 t2 =\n let u32_1 = to_uint32 t1 in\n let u32_2 = to_uint32 t2 in\n let%map.Quickcheck u32 = T.gen_incl u32_1 u32_2 in\n of_uint32 u32\n\n let dhall_type = Ppx_dhall_type.Dhall_type.Text\n\n let zero = of_uint32 T.zero\n\n let one = of_uint32 T.one\n\n let succ t =\n let u32 = to_uint32 t in\n of_uint32 (T.succ u32)\n\n let max_value = of_uint32 Unsigned.UInt32.max_int\n\n let to_field t = T.to_field (to_uint32 t)\n\n let to_input t = T.to_input (to_uint32 t)\n\n let to_input_legacy t = T.to_input_legacy (to_uint32 t)\n\n include Comparable.Make (M.Stable.Latest)\n\n let add t span =\n let u32_slot = to_uint32 t in\n let u32_span = Global_slot_span.to_uint32 span in\n let u32_sum = T.add u32_slot u32_span in\n of_uint32 u32_sum\n\n let sub t span =\n let u32_slot = to_uint32 t in\n let u32_span = Global_slot_span.to_uint32 span in\n Option.map (T.sub u32_slot u32_span) ~f:of_uint32\n\n let diff t1 t2 =\n let u32_1 = to_uint32 t1 in\n let u32_2 = to_uint32 t2 in\n Option.map (T.sub u32_1 u32_2) ~f:Global_slot_span.of_uint32\n\n let of_int n = of_uint32 (T.of_int n)\n\n let to_int t = T.to_int (to_uint32 t)\n\n let random () = of_uint32 (T.random ())\nend\n","module T = Nat.Make32 ()\n\ninclude T\ninclude Codable.Make_of_string (T)\n","module T = Nat.Make32 ()\n\nmodule Wire_types = Mina_wire_types.Mina_numbers.Index\n\nmodule Make_sig (A : Wire_types.Types.S) = struct\n module type S = sig\n include Nat.Intf.UInt32_A with type Stable.V1.t = A.V1.t\n end\nend\n\nmodule Make_str (_ : Wire_types.Concrete) = struct\n include T\n\n let to_bits = Bits.to_bits\n\n let of_bits = Bits.of_bits\nend\n\ninclude Wire_types.Make (Make_sig) (Make_str)\n","module T = Nat.Make32 ()\n\n(** See documentation of the {!Mina_wire_types} library *)\nmodule Wire_types = Mina_wire_types.Mina_numbers.Length\n\nmodule Make_sig (A : Wire_types.Types.S) = struct\n module type S = sig\n include Nat.Intf.UInt32_A with type Stable.V1.t = A.V1.t\n end\nend\n\nmodule Make_str (_ : Wire_types.Concrete) = struct\n include T\n\n let to_bits = Bits.to_bits\n\n let of_bits = Bits.of_bits\nend\n\ninclude Wire_types.Make (Make_sig) (Make_str)\n","module Account_nonce = Account_nonce\nmodule Length = Length\nmodule Index = Index\nmodule Nat = Nat\nmodule Global_slot_legacy = Global_slot_legacy\nmodule Global_slot_since_genesis = Global_slot_since_genesis\nmodule Global_slot_since_hard_fork = Global_slot_since_hard_fork\nmodule Global_slot_span = Global_slot_span\nmodule Hd_index = Hd_index\nmodule Zkapp_version = Zkapp_version\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Snark_bits\nopen Snark_params.Tick\n\ntype uint64 = Unsigned.uint64\n\nmodule type Basic = sig\n type t [@@deriving sexp, compare, hash, yojson]\n\n type magnitude = t [@@deriving sexp, compare]\n\n (* not automatically derived *)\n val dhall_type : Ppx_dhall_type.Dhall_type.t\n\n val max_int : t\n\n val length_in_bits : int\n\n include Comparable.S with type t := t\n\n val gen_incl : t -> t -> t Quickcheck.Generator.t\n\n val gen : t Quickcheck.Generator.t\n\n include Bits_intf.Convertible_bits with type t := t\n\n val to_input : t -> Field.t Random_oracle.Input.Chunked.t\n\n val to_input_legacy : t -> (_, bool) Random_oracle.Legacy.Input.t\n\n val zero : t\n\n val one : t\n\n val of_string : string -> t\n\n val to_string : t -> string\n\n val of_mina_string_exn : string -> t\n\n val to_mina_string : t -> string\n\n val to_uint64 : t -> uint64\n\n val of_uint64 : uint64 -> t\n\n (* The functions below are unsafe, because they could overflow or\n underflow. They perform appropriate checks to guard against this\n and either raise Currency_overflow exception or return None\n depending on the error-handling strategy.\n\n It is advisable to use nanomina and mina wherever possible and\n limit the use of _exn veriants to places where a fixed value is\n being converted and hence overflow cannot happen. *)\n val of_mina_int_exn : int -> t\n\n val of_nanomina_int_exn : int -> t\n\n val of_mina_int : int -> t option\n\n val of_nanomina_int : int -> t option\n\n val to_mina_int : t -> int\n\n val to_nanomina_int : t -> int\n\n [%%ifdef consensus_mechanism]\n\n type var\n\n val typ : (var, t) Typ.t\n\n val var_of_t : t -> var\n\n val var_to_bits :\n var -> Boolean.var Bitstring_lib.Bitstring.Lsb_first.t Checked.t\n\n val var_to_input : var -> Field.Var.t Random_oracle.Input.Chunked.t\n\n val var_to_input_legacy :\n var -> (Field.Var.t, Boolean.var) Random_oracle.Input.Legacy.t Checked.t\n\n val equal_var : var -> var -> Boolean.var Checked.t\n\n val pack_var : var -> Field.Var.t\n\n [%%endif]\nend\n\nmodule type Arithmetic_intf = sig\n type t\n\n val add : t -> t -> t option\n\n val add_flagged : t -> t -> t * [ `Overflow of bool ]\n\n val sub : t -> t -> t option\n\n val sub_flagged : t -> t -> t * [ `Underflow of bool ]\n\n val ( + ) : t -> t -> t option\n\n val ( - ) : t -> t -> t option\n\n val scale : t -> int -> t option\nend\n\nmodule type Signed_intf = sig\n type magnitude\n\n type signed_fee\n\n [%%ifdef consensus_mechanism]\n\n type magnitude_var\n\n [%%endif]\n\n type t = (magnitude, Sgn.t) Signed_poly.t\n [@@deriving sexp, hash, compare, equal, yojson]\n\n val gen : t Quickcheck.Generator.t\n\n val create : magnitude:magnitude -> sgn:Sgn.t -> t\n\n val sgn : t -> Sgn.t\n\n val magnitude : t -> magnitude\n\n val zero : t\n\n val is_zero : t -> bool\n\n val is_positive : t -> bool\n\n val is_negative : t -> bool\n\n val to_input : t -> Field.t Random_oracle.Input.Chunked.t\n\n val to_input_legacy : t -> (_, bool) Random_oracle.Legacy.Input.t\n\n val add : t -> t -> t option\n\n val add_flagged : t -> t -> t * [ `Overflow of bool ]\n\n val ( + ) : t -> t -> t option\n\n val negate : t -> t\n\n val of_unsigned : magnitude -> t\n\n val to_fee : t -> signed_fee\n\n val of_fee : signed_fee -> t\n\n [%%ifdef consensus_mechanism]\n\n type var (* = (magnitude_var, Sgn.var) Signed_poly.t *)\n\n val create_var : magnitude:magnitude_var -> sgn:Sgn.var -> var\n\n val typ : (var, t) Typ.t\n\n module Checked : sig\n type signed_fee_var\n\n val constant : t -> var\n\n val of_unsigned : magnitude_var -> var\n\n val sgn : var -> Sgn.var Checked.t\n\n val magnitude : var -> magnitude_var Checked.t\n\n val negate : var -> var\n\n val if_ : Boolean.var -> then_:var -> else_:var -> var Checked.t\n\n val to_input : var -> Field.Var.t Random_oracle.Input.Chunked.t Checked.t\n\n val to_input_legacy :\n var -> (_, Boolean.var) Random_oracle.Legacy.Input.t Checked.t\n\n val add : var -> var -> var Checked.t\n\n val add_flagged :\n var -> var -> (var * [ `Overflow of Boolean.var ]) Checked.t\n\n val assert_equal : var -> var -> unit Checked.t\n\n val equal : var -> var -> Boolean.var Checked.t\n\n val ( + ) : var -> var -> var Checked.t\n\n val to_field_var : var -> Field.Var.t Checked.t\n\n val to_fee : var -> signed_fee_var\n\n val of_fee : signed_fee_var -> var\n\n type t = var\n end\n\n [%%endif]\nend\n\n[%%ifdef consensus_mechanism]\n\nmodule type Checked_arithmetic_intf = sig\n type value\n\n type var\n\n type t = var\n\n type signed_var\n\n val if_ : Boolean.var -> then_:var -> else_:var -> var Checked.t\n\n val add : var -> var -> var Checked.t\n\n val sub : var -> var -> var Checked.t\n\n val sub_flagged :\n var -> var -> (var * [ `Underflow of Boolean.var ]) Checked.t\n\n val sub_or_zero : var -> var -> var Checked.t\n\n val add_flagged : var -> var -> (var * [ `Overflow of Boolean.var ]) Checked.t\n\n val ( + ) : var -> var -> var Checked.t\n\n val ( - ) : var -> var -> var Checked.t\n\n val add_signed : var -> signed_var -> var Checked.t\n\n val add_signed_flagged :\n var -> signed_var -> (var * [ `Overflow of Boolean.var ]) Checked.t\n\n val assert_equal : var -> var -> unit Checked.t\n\n val equal : var -> var -> Boolean.var Checked.t\n\n val ( = ) : t -> t -> Boolean.var Checked.t\n\n val ( < ) : t -> t -> Boolean.var Checked.t\n\n val ( > ) : t -> t -> Boolean.var Checked.t\n\n val ( <= ) : t -> t -> Boolean.var Checked.t\n\n val ( >= ) : t -> t -> Boolean.var Checked.t\n\n val scale : Field.Var.t -> var -> var Checked.t\nend\n\n[%%endif]\n\nmodule type S = sig\n include Basic\n\n include Arithmetic_intf with type t := t\n\n [%%ifdef consensus_mechanism]\n\n module Signed :\n Signed_intf with type magnitude := t and type magnitude_var := var\n\n module Checked :\n Checked_arithmetic_intf\n with type var := var\n and type signed_var := Signed.var\n and type value := t\n\n [%%else]\n\n module Signed : Signed_intf with type magnitude := t\n\n [%%endif]\n\n val add_signed_flagged : t -> Signed.t -> t * [ `Overflow of bool ]\nend\n\nmodule type Full = sig\n [%%ifdef consensus_mechanism]\n\n open Snark_params.Tick\n\n module Signed_var : sig\n type 'mag repr = ('mag, Sgn.var) Signed_poly.t\n\n (* Invariant: At least one of these is Some *)\n type nonrec 'mag t =\n { repr : 'mag repr; mutable value : Field.Var.t option }\n end\n\n [%%endif]\n\n module Signed_poly = Signed_poly\n\n module Fee : sig\n [%%versioned:\n module Stable : sig\n module V1 : sig\n [@@@with_all_version_tags]\n\n type t [@@deriving sexp, compare, hash, yojson, equal]\n\n (* not automatically derived *)\n val dhall_type : Ppx_dhall_type.Dhall_type.t\n end\n end]\n\n include Basic with type t := Stable.Latest.t\n\n include Arithmetic_intf with type t := t\n\n include Codable.S with type t := t\n\n val minimum_user_command_fee : t\n\n val default_transaction_fee : t\n\n val default_snark_worker_fee : t\n\n (* TODO: Get rid of signed fee, use signed amount *)\n [%%ifdef consensus_mechanism]\n\n module Signed :\n Signed_intf\n with type magnitude := t\n and type magnitude_var := var\n and type signed_fee := (t, Sgn.t) Signed_poly.t\n and type Checked.signed_fee_var := Field.Var.t Signed_var.t\n\n [%%else]\n\n module Signed :\n Signed_intf\n with type magnitude := t\n and type signed_fee := (t, Sgn.t) Signed_poly.t\n\n [%%endif]\n\n [%%ifdef consensus_mechanism]\n\n module Checked : sig\n include\n Checked_arithmetic_intf\n with type var := var\n and type signed_var := Signed.var\n and type value := t\n\n val add_signed : var -> Signed.var -> var Checked.t\n end\n\n [%%endif]\n end\n [@@warning \"-32\"]\n\n module Amount : sig\n [%%versioned:\n module Stable : sig\n module V1 : sig\n [@@@with_all_version_tags]\n\n type t [@@deriving sexp, compare, hash, equal, yojson]\n\n (* not automatically derived *)\n val dhall_type : Ppx_dhall_type.Dhall_type.t\n end\n end]\n\n include Basic with type t := Stable.Latest.t\n\n include Arithmetic_intf with type t := t\n\n include Codable.S with type t := t\n\n [%%ifdef consensus_mechanism]\n\n module Signed :\n Signed_intf\n with type magnitude := t\n and type magnitude_var := var\n and type signed_fee := Fee.Signed.t\n and type Checked.signed_fee_var := Fee.Signed.Checked.t\n\n [%%else]\n\n module Signed :\n Signed_intf with type magnitude := t and type signed_fee := Fee.Signed.t\n\n [%%endif]\n\n (* TODO: Delete these functions *)\n\n val of_fee : Fee.t -> t\n\n val to_fee : t -> Fee.t\n\n val add_fee : t -> Fee.t -> t option\n\n val add_signed_flagged : t -> Signed.t -> t * [ `Overflow of bool ]\n\n [%%ifdef consensus_mechanism]\n\n module Checked : sig\n include\n Checked_arithmetic_intf\n with type var := var\n and type signed_var := Signed.var\n and type value := t\n\n val add_signed : var -> Signed.var -> var Checked.t\n\n val add_signed_flagged :\n var -> Signed.var -> (var * [ `Overflow of Boolean.var ]) Checked.t\n\n val of_fee : Fee.var -> var\n\n val to_fee : var -> Fee.var\n\n val to_field : var -> Field.Var.t\n\n module Unsafe : sig\n val of_field : Field.Var.t -> t\n end\n end\n\n [%%endif]\n end\n [@@warning \"-32\"]\n\n module Balance : sig\n [%%versioned:\n module Stable : sig\n module V1 : sig\n type t [@@deriving sexp, compare, hash, yojson, equal]\n\n (* not automatically derived *)\n val dhall_type : Ppx_dhall_type.Dhall_type.t\n end\n end]\n\n include Basic with type t := Stable.Latest.t\n\n val to_amount : t -> Amount.t\n\n val add_amount : t -> Amount.t -> t option\n\n val add_amount_flagged : t -> Amount.t -> t * [ `Overflow of bool ]\n\n val sub_amount : t -> Amount.t -> t option\n\n val sub_amount_flagged : t -> Amount.t -> t * [ `Underflow of bool ]\n\n val add_signed_amount_flagged :\n t -> Amount.Signed.t -> t * [ `Overflow of bool ]\n\n val ( + ) : t -> Amount.t -> t option\n\n val ( - ) : t -> Amount.t -> t option\n\n [%%ifdef consensus_mechanism]\n\n module Checked : sig\n type t = var\n\n val to_amount : t -> Amount.var\n\n val add_signed_amount : var -> Amount.Signed.var -> var Checked.t\n\n val add_amount : var -> Amount.var -> var Checked.t\n\n val sub_amount : var -> Amount.var -> var Checked.t\n\n val sub_amount_flagged :\n var -> Amount.var -> (var * [ `Underflow of Boolean.var ]) Checked.t\n\n val add_amount_flagged :\n var -> Amount.var -> (var * [ `Overflow of Boolean.var ]) Checked.t\n\n val add_signed_amount_flagged :\n var\n -> Amount.Signed.var\n -> (var * [ `Overflow of Boolean.var ]) Checked.t\n\n val sub_or_zero : var -> var -> var Checked.t\n\n val sub_amount_or_zero : var -> Amount.var -> var Checked.t\n\n val ( + ) : var -> Amount.var -> var Checked.t\n\n val ( - ) : var -> Amount.var -> var Checked.t\n\n val equal : var -> var -> Boolean.var Checked.t\n\n val ( = ) : var -> var -> Boolean.var Checked.t\n\n val ( < ) : var -> var -> Boolean.var Checked.t\n\n val ( > ) : var -> var -> Boolean.var Checked.t\n\n val ( <= ) : var -> var -> Boolean.var Checked.t\n\n val ( >= ) : var -> var -> Boolean.var Checked.t\n\n val if_ : Boolean.var -> then_:var -> else_:var -> var Checked.t\n\n val to_field : var -> Field.Var.t\n\n module Unsafe : sig\n val of_field : Field.Var.t -> var\n end\n end\n\n [%%endif]\n end\n [@@warning \"-32\"]\n\n module Fee_rate : sig\n type t\n\n include Arithmetic_intf with type t := t\n\n include Comparable.S with type t := t\n\n include Sexpable.S with type t := t\n\n val of_q : Q.t -> t option\n\n val of_q_exn : Q.t -> t\n\n val to_q : t -> Q.t\n\n (** construct a fee rate from a fee and a weight *)\n val make : Fee.t -> int -> t option\n\n (** construct a fee rate from a fee and a weight *)\n val make_exn : Fee.t -> int -> t\n\n (** convert to uint64, if the fee rate is equivalent to an integer. *)\n val to_uint64 : t -> uint64 option\n\n (** convert to uint64, if the fee rate is equivalent to an integer. *)\n val to_uint64_exn : t -> uint64\n\n val mul : t -> t -> t option\n\n val scale_exn : t -> int -> t\n\n val div : t -> t -> t option\n\n val ( * ) : t -> t -> t option\n end\nend\n","(*\n RE - A regular expression library\n\n Copyright (C) 2001 Jerome Vouillon\n email: Jerome.Vouillon@pps.jussieu.fr\n\n This library is free software; you can redistribute it and/or\n modify it under the terms of the GNU Lesser General Public\n License as published by the Free Software Foundation, with\n linking exception; either version 2.1 of the License, or (at\n your option) any later version.\n\n This library is distributed in the hope that it will be useful,\n but WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n Lesser General Public License for more details.\n\n You should have received a copy of the GNU Lesser General Public\n License along with this library; if not, write to the Free Software\n Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n*)\n\nlet rec iter n f v = if n = 0 then v else iter (n - 1) f (f v)\n\n(****)\n\nlet unknown = -2\nlet break = -3\n\ntype match_info =\n | Match of Group.t\n | Failed\n | Running\n\ntype state =\n { idx : int;\n (* Index of the current position in the position table.\n Not yet computed transitions point to a dummy state where\n [idx] is set to [unknown];\n If [idx] is set to [break] for states that either always\n succeed or always fail. *)\n real_idx : int;\n (* The real index, in case [idx] is set to [break] *)\n next : state array;\n (* Transition table, indexed by color *)\n mutable final :\n (Category.t *\n (Automata.idx * Automata.status)) list;\n (* Mapping from the category of the next character to\n - the index where the next position should be saved\n - possibly, the list of marks (and the corresponding indices)\n corresponding to the best match *)\n desc : Automata.State.t\n (* Description of this state of the automata *) }\n\n(* Automata (compiled regular expression) *)\ntype re =\n { initial : Automata.expr;\n (* The whole regular expression *)\n mutable initial_states : (Category.t * state) list;\n (* Initial states, indexed by initial category *)\n colors : Bytes.t;\n (* Color table *)\n color_repr : Bytes.t;\n (* Table from colors to one character of this color *)\n ncolor : int;\n (* Number of colors. *)\n lnl : int;\n (* Color of the last newline. -1 if unnecessary *)\n tbl : Automata.working_area;\n (* Temporary table used to compute the first available index\n when computing a new state *)\n states : state Automata.State.Table.t;\n (* States of the deterministic automata *)\n group_count : int\n (* Number of groups in the regular expression *) }\n\nlet pp_re ch re = Automata.pp ch re.initial\n\nlet print_re = pp_re\n\n(* Information used during matching *)\ntype info =\n { re : re;\n (* The automata *)\n colors : Bytes.t;\n (* Color table ([x.colors = x.re.colors])\n Shortcut used for performance reasons *)\n mutable positions : int array;\n (* Array of mark positions\n The mark are off by one for performance reasons *)\n pos : int;\n (* Position where the match is started *)\n last : int\n (* Position where the match should stop *) }\n\n\n(****)\n\nlet category re ~color =\n if color = -1 then\n Category.inexistant\n (* Special category for the last newline *)\n else if color = re.lnl then\n Category.(lastnewline ++ newline ++ not_letter)\n else\n Category.from_char (Bytes.get re.color_repr color)\n\n(****)\n\nlet dummy_next = [||]\n\nlet unknown_state =\n { idx = unknown; real_idx = 0;\n next = dummy_next; final = [];\n desc = Automata.State.dummy }\n\nlet mk_state ncol desc =\n let break_state =\n match Automata.status desc with\n | Automata.Running -> false\n | Automata.Failed\n | Automata.Match _ -> true\n in\n { idx = if break_state then break else desc.Automata.State.idx;\n real_idx = desc.Automata.State.idx;\n next = if break_state then dummy_next else Array.make ncol unknown_state;\n final = [];\n desc }\n\nlet find_state re desc =\n try\n Automata.State.Table.find re.states desc\n with Not_found ->\n let st = mk_state re.ncolor desc in\n Automata.State.Table.add re.states desc st;\n st\n\n(**** Match with marks ****)\n\nlet delta info cat ~color st =\n let desc = Automata.delta info.re.tbl cat color st.desc in\n let len = Array.length info.positions in\n if desc.Automata.State.idx = len && len > 0 then begin\n let pos = info.positions in\n info.positions <- Array.make (2 * len) 0;\n Array.blit pos 0 info.positions 0 len\n end;\n desc\n\nlet validate info (s:string) ~pos st =\n let color = Char.code (Bytes.get info.colors (Char.code s.[pos])) in\n let cat = category info.re ~color in\n let desc' = delta info cat ~color st in\n let st' = find_state info.re desc' in\n st.next.(color) <- st'\n\n(*\nlet rec loop info s pos st =\n if pos < info.last then\n let st' = st.next.(Char.code info.cols.[Char.code s.[pos]]) in\n let idx = st'.idx in\n if idx >= 0 then begin\n info.positions.(idx) <- pos;\n loop info s (pos + 1) st'\n end else if idx = break then begin\n info.positions.(st'.real_idx) <- pos;\n st'\n end else begin (* Unknown *)\n validate info s pos st;\n loop info s pos st\n end\n else\n st\n*)\n\nlet rec loop info (s:string) ~pos st =\n if pos < info.last then\n let st' = st.next.(Char.code (Bytes.get info.colors (Char.code s.[pos]))) in\n loop2 info s ~pos st st'\n else\n st\n\nand loop2 info s ~pos st st' =\n if st'.idx >= 0 then begin\n let pos = pos + 1 in\n if pos < info.last then begin\n (* It is important to place these reads before the write *)\n (* But then, we don't have enough registers left to store the\n right position. So, we store the position plus one. *)\n let st'' =\n st'.next.(Char.code (Bytes.get info.colors (Char.code s.[pos]))) in\n info.positions.(st'.idx) <- pos;\n loop2 info s ~pos st' st''\n end else begin\n info.positions.(st'.idx) <- pos;\n st'\n end\n end else if st'.idx = break then begin\n info.positions.(st'.real_idx) <- pos + 1;\n st'\n end else begin (* Unknown *)\n validate info s ~pos st;\n loop info s ~pos st\n end\n\nlet rec loop_no_mark info s ~pos ~last st =\n if pos < last then\n let st' = st.next.(Char.code (Bytes.get info.colors (Char.code s.[pos]))) in\n if st'.idx >= 0 then\n loop_no_mark info s ~pos:(pos + 1) ~last st'\n else if st'.idx = break then\n st'\n else begin (* Unknown *)\n validate info s ~pos st;\n loop_no_mark info s ~pos ~last st\n end\n else\n st\n\nlet final info st cat =\n try\n List.assq cat st.final\n with Not_found ->\n let st' = delta info cat ~color:(-1) st in\n let res = (st'.Automata.State.idx, Automata.status st') in\n st.final <- (cat, res) :: st.final;\n res\n\nlet find_initial_state re cat =\n try\n List.assq cat re.initial_states\n with Not_found ->\n let st = find_state re (Automata.State.create cat re.initial) in\n re.initial_states <- (cat, st) :: re.initial_states;\n st\n\nlet get_color re (s:string) pos =\n if pos < 0 then\n -1\n else\n let slen = String.length s in\n if pos >= slen then\n -1\n else if pos = slen - 1 && re.lnl <> -1 && s.[pos] = '\\n' then\n (* Special case for the last newline *)\n re.lnl\n else\n Char.code (Bytes.get re.colors (Char.code s.[pos]))\n\nlet rec handle_last_newline info ~pos st ~groups =\n let st' = st.next.(info.re.lnl) in\n if st'.idx >= 0 then begin\n if groups then info.positions.(st'.idx) <- pos + 1;\n st'\n end else if st'.idx = break then begin\n if groups then info.positions.(st'.real_idx) <- pos + 1;\n st'\n end else begin (* Unknown *)\n let color = info.re.lnl in\n let real_c = Char.code (Bytes.get info.colors (Char.code '\\n')) in\n let cat = category info.re ~color in\n let desc' = delta info cat ~color:real_c st in\n let st' = find_state info.re desc' in\n st.next.(color) <- st';\n handle_last_newline info ~pos st ~groups\n end\n\nlet rec scan_str info (s:string) initial_state ~groups =\n let pos = info.pos in\n let last = info.last in\n if (last = String.length s\n && info.re.lnl <> -1\n && last > pos\n && String.get s (last - 1) = '\\n')\n then begin\n let info = { info with last = last - 1 } in\n let st = scan_str info s initial_state ~groups in\n if st.idx = break then\n st\n else\n handle_last_newline info ~pos:(last - 1) st ~groups\n end else if groups then\n loop info s ~pos initial_state\n else\n loop_no_mark info s ~pos ~last initial_state\n\nlet match_str ~groups ~partial re s ~pos ~len =\n let slen = String.length s in\n let last = if len = -1 then slen else pos + len in\n let info =\n { re ; colors = re.colors; pos ; last\n ; positions =\n if groups then begin\n let n = Automata.index_count re.tbl + 1 in\n if n <= 10 then\n [|0;0;0;0;0;0;0;0;0;0|]\n else\n Array.make n 0\n end else\n [||] }\n in\n let initial_cat =\n if pos = 0 then\n Category.(search_boundary ++ inexistant)\n else\n Category.(search_boundary\n ++ category re ~color:(get_color re s (pos - 1)))\n in\n let initial_state = find_initial_state re initial_cat in\n let st = scan_str info s initial_state ~groups in\n let res =\n if st.idx = break || partial then\n Automata.status st.desc\n else\n let final_cat =\n if last = slen then\n Category.(search_boundary ++ inexistant)\n else\n Category.(search_boundary ++ category re ~color:(get_color re s last))\n in\n let (idx, res) = final info st final_cat in\n if groups then info.positions.(idx) <- last + 1;\n res\n in\n match res with\n Automata.Match (marks, pmarks) ->\n Match { s ; marks; pmarks ; gpos = info.positions; gcount = re.group_count}\n | Automata.Failed -> Failed\n | Automata.Running -> Running\n\nlet mk_re ~initial ~colors ~color_repr ~ncolor ~lnl ~group_count =\n { initial ;\n initial_states = [];\n colors;\n color_repr;\n ncolor;\n lnl;\n tbl = Automata.create_working_area ();\n states = Automata.State.Table.create 97;\n group_count }\n\n(**** Character sets ****)\n\nlet cseq c c' = Cset.seq (Char.code c) (Char.code c')\nlet cadd c s = Cset.add (Char.code c) s\n\nlet trans_set cache cm s =\n match Cset.one_char s with\n | Some i -> Cset.csingle (Bytes.get cm i)\n | None ->\n let v = (Cset.hash_rec s, s) in\n try\n Cset.CSetMap.find v !cache\n with Not_found ->\n let l =\n Cset.fold_right\n s\n ~f:(fun (i, j) l -> Cset.union (cseq (Bytes.get cm i)\n (Bytes.get cm j)) l)\n ~init:Cset.empty\n in\n cache := Cset.CSetMap.add v l !cache;\n l\n\n(****)\n\ntype regexp =\n Set of Cset.t\n | Sequence of regexp list\n | Alternative of regexp list\n | Repeat of regexp * int * int option\n | Beg_of_line | End_of_line\n | Beg_of_word | End_of_word | Not_bound\n | Beg_of_str | End_of_str\n | Last_end_of_line | Start | Stop\n | Sem of Automata.sem * regexp\n | Sem_greedy of Automata.rep_kind * regexp\n | Group of regexp | No_group of regexp | Nest of regexp\n | Case of regexp | No_case of regexp\n | Intersection of regexp list\n | Complement of regexp list\n | Difference of regexp * regexp\n | Pmark of Pmark.t * regexp\n\nmodule View = struct\n type t = regexp =\n Set of Cset.t\n | Sequence of regexp list\n | Alternative of regexp list\n | Repeat of regexp * int * int option\n | Beg_of_line | End_of_line\n | Beg_of_word | End_of_word | Not_bound\n | Beg_of_str | End_of_str\n | Last_end_of_line | Start | Stop\n | Sem of Automata.sem * regexp\n | Sem_greedy of Automata.rep_kind * regexp\n | Group of regexp | No_group of regexp | Nest of regexp\n | Case of regexp | No_case of regexp\n | Intersection of regexp list\n | Complement of regexp list\n | Difference of regexp * regexp\n | Pmark of Pmark.t * regexp\n\n let view t = t\nend\n\nlet rec pp fmt t =\n let open Fmt in\n let var s re = sexp fmt s pp re in\n let seq s rel = sexp fmt s (list pp) rel in\n match t with\n | Set s -> sexp fmt \"Set\" Cset.pp s\n | Sequence sq -> seq \"Sequence\" sq\n | Alternative alt -> seq \"Alternative\" alt\n | Repeat (re, start, stop) ->\n let pp' fmt () = fprintf fmt \"%a@ %d%a\" pp re start optint stop in\n sexp fmt \"Repeat\" pp' ()\n | Beg_of_line -> str fmt \"Beg_of_line\"\n | End_of_line -> str fmt \"End_of_line\"\n | Beg_of_word -> str fmt \"Beg_of_word\"\n | End_of_word -> str fmt \"End_of_word\"\n | Not_bound -> str fmt \"Not_bound\"\n | Beg_of_str -> str fmt \"Beg_of_str\"\n | End_of_str -> str fmt \"End_of_str\"\n | Last_end_of_line -> str fmt \"Last_end_of_line\"\n | Start -> str fmt \"Start\"\n | Stop -> str fmt \"Stop\"\n | Sem (sem, re) ->\n sexp fmt \"Sem\" (pair Automata.pp_sem pp) (sem, re)\n | Sem_greedy (k, re) ->\n sexp fmt \"Sem_greedy\" (pair Automata.pp_rep_kind pp) (k, re)\n | Group c -> var \"Group\" c\n | No_group c -> var \"No_group\" c\n | Nest c -> var \"Nest\" c\n | Case c -> var \"Case\" c\n | No_case c -> var \"No_case\" c\n | Intersection c -> seq \"Intersection\" c\n | Complement c -> seq \"Complement\" c\n | Difference (a, b) -> sexp fmt \"Difference\" (pair pp pp) (a, b)\n | Pmark (m, r) -> sexp fmt \"Pmark\" (pair Pmark.pp pp) (m, r)\n\nlet rec is_charset = function\n | Set _ ->\n true\n | Alternative l | Intersection l | Complement l ->\n List.for_all is_charset l\n | Difference (r, r') ->\n is_charset r && is_charset r'\n | Sem (_, r) | Sem_greedy (_, r)\n | No_group r | Case r | No_case r ->\n is_charset r\n | Sequence _ | Repeat _ | Beg_of_line | End_of_line\n | Beg_of_word | End_of_word | Beg_of_str | End_of_str\n | Not_bound | Last_end_of_line | Start | Stop\n | Group _ | Nest _ | Pmark (_,_)->\n false\n\n(*XXX Use a better algorithm allowing non-contiguous regions? *)\n\nlet cupper =\n Cset.union (cseq 'A' 'Z')\n (Cset.union (cseq '\\192' '\\214') (cseq '\\216' '\\222'))\nlet clower = Cset.offset 32 cupper\nlet calpha =\n List.fold_right cadd ['\\170'; '\\181'; '\\186'; '\\223'; '\\255']\n (Cset.union clower cupper)\nlet cdigit = cseq '0' '9'\nlet calnum = Cset.union calpha cdigit\nlet cword = cadd '_' calnum\n\nlet colorize c regexp =\n let lnl = ref false in\n let rec colorize regexp =\n match regexp with\n Set s -> Color_map.split s c\n | Sequence l -> List.iter colorize l\n | Alternative l -> List.iter colorize l\n | Repeat (r, _, _) -> colorize r\n | Beg_of_line | End_of_line -> Color_map.split (Cset.csingle '\\n') c\n | Beg_of_word | End_of_word\n | Not_bound -> Color_map.split cword c\n | Beg_of_str | End_of_str\n | Start | Stop -> ()\n | Last_end_of_line -> lnl := true\n | Sem (_, r)\n | Sem_greedy (_, r)\n | Group r | No_group r\n | Nest r | Pmark (_,r) -> colorize r\n | Case _ | No_case _\n | Intersection _\n | Complement _\n | Difference _ -> assert false\n in\n colorize regexp;\n !lnl\n\n(**** Compilation ****)\n\nlet rec equal x1 x2 =\n match x1, x2 with\n Set s1, Set s2 ->\n s1 = s2\n | Sequence l1, Sequence l2 ->\n eq_list l1 l2\n | Alternative l1, Alternative l2 ->\n eq_list l1 l2\n | Repeat (x1', i1, j1), Repeat (x2', i2, j2) ->\n i1 = i2 && j1 = j2 && equal x1' x2'\n | Beg_of_line, Beg_of_line\n | End_of_line, End_of_line\n | Beg_of_word, Beg_of_word\n | End_of_word, End_of_word\n | Not_bound, Not_bound\n | Beg_of_str, Beg_of_str\n | End_of_str, End_of_str\n | Last_end_of_line, Last_end_of_line\n | Start, Start\n | Stop, Stop ->\n true\n | Sem (sem1, x1'), Sem (sem2, x2') ->\n sem1 = sem2 && equal x1' x2'\n | Sem_greedy (k1, x1'), Sem_greedy (k2, x2') ->\n k1 = k2 && equal x1' x2'\n | Group _, Group _ -> (* Do not merge groups! *)\n false\n | No_group x1', No_group x2' ->\n equal x1' x2'\n | Nest x1', Nest x2' ->\n equal x1' x2'\n | Case x1', Case x2' ->\n equal x1' x2'\n | No_case x1', No_case x2' ->\n equal x1' x2'\n | Intersection l1, Intersection l2 ->\n eq_list l1 l2\n | Complement l1, Complement l2 ->\n eq_list l1 l2\n | Difference (x1', x1''), Difference (x2', x2'') ->\n equal x1' x2' && equal x1'' x2''\n | Pmark (m1, r1), Pmark (m2, r2) ->\n Pmark.equal m1 m2 && equal r1 r2\n | _ ->\n false\n\nand eq_list l1 l2 =\n match l1, l2 with\n [], [] ->\n true\n | x1 :: r1, x2 :: r2 ->\n equal x1 x2 && eq_list r1 r2\n | _ ->\n false\n\nlet sequence = function\n | [x] -> x\n | l -> Sequence l\n\nlet rec merge_sequences = function\n | [] ->\n []\n | Alternative l' :: r ->\n merge_sequences (l' @ r)\n | Sequence (x :: y) :: r ->\n begin match merge_sequences r with\n Sequence (x' :: y') :: r' when equal x x' ->\n Sequence [x; Alternative [sequence y; sequence y']] :: r'\n | r' ->\n Sequence (x :: y) :: r'\n end\n | x :: r ->\n x :: merge_sequences r\n\nmodule A = Automata\n\nlet enforce_kind ids kind kind' cr =\n match kind, kind' with\n `First, `First -> cr\n | `First, k -> A.seq ids k cr (A.eps ids)\n | _ -> cr\n\n(* XXX should probably compute a category mask *)\nlet rec translate ids kind ign_group ign_case greedy pos cache c = function\n | Set s ->\n (A.cst ids (trans_set cache c s), kind)\n | Sequence l ->\n (trans_seq ids kind ign_group ign_case greedy pos cache c l, kind)\n | Alternative l ->\n begin match merge_sequences l with\n [r'] ->\n let (cr, kind') =\n translate ids kind ign_group ign_case greedy pos cache c r' in\n (enforce_kind ids kind kind' cr, kind)\n | merged_sequences ->\n (A.alt ids\n (List.map\n (fun r' ->\n let (cr, kind') =\n translate ids kind ign_group ign_case greedy\n pos cache c r' in\n enforce_kind ids kind kind' cr)\n merged_sequences),\n kind)\n end\n | Repeat (r', i, j) ->\n let (cr, kind') =\n translate ids kind ign_group ign_case greedy pos cache c r' in\n let rem =\n match j with\n None ->\n A.rep ids greedy kind' cr\n | Some j ->\n let f =\n match greedy with\n `Greedy ->\n fun rem ->\n A.alt ids\n [A.seq ids kind' (A.rename ids cr) rem; A.eps ids]\n | `Non_greedy ->\n fun rem ->\n A.alt ids\n [A.eps ids; A.seq ids kind' (A.rename ids cr) rem]\n in\n iter (j - i) f (A.eps ids)\n in\n (iter i (fun rem -> A.seq ids kind' (A.rename ids cr) rem) rem, kind)\n | Beg_of_line ->\n (A.after ids Category.(inexistant ++ newline), kind)\n | End_of_line ->\n (A.before ids Category.(inexistant ++ newline), kind)\n | Beg_of_word ->\n (A.seq ids `First\n (A.after ids Category.(inexistant ++ not_letter))\n (A.before ids Category.(inexistant ++ letter)),\n kind)\n | End_of_word ->\n (A.seq ids `First\n (A.after ids Category.(inexistant ++ letter))\n (A.before ids Category.(inexistant ++ not_letter)),\n kind)\n | Not_bound ->\n (A.alt ids [A.seq ids `First\n (A.after ids Category.letter)\n (A.before ids Category.letter);\n A.seq ids `First\n (A.after ids Category.letter)\n (A.before ids Category.letter)],\n kind)\n | Beg_of_str ->\n (A.after ids Category.inexistant, kind)\n | End_of_str ->\n (A.before ids Category.inexistant, kind)\n | Last_end_of_line ->\n (A.before ids Category.(inexistant ++ lastnewline), kind)\n | Start ->\n (A.after ids Category.search_boundary, kind)\n | Stop ->\n (A.before ids Category.search_boundary, kind)\n | Sem (kind', r') ->\n let (cr, kind'') =\n translate ids kind' ign_group ign_case greedy pos cache c r' in\n (enforce_kind ids kind' kind'' cr,\n kind')\n | Sem_greedy (greedy', r') ->\n translate ids kind ign_group ign_case greedy' pos cache c r'\n | Group r' ->\n if ign_group then\n translate ids kind ign_group ign_case greedy pos cache c r'\n else\n let p = !pos in\n pos := !pos + 2;\n let (cr, kind') =\n translate ids kind ign_group ign_case greedy pos cache c r' in\n (A.seq ids `First (A.mark ids p) (\n A.seq ids `First cr (A.mark ids (p + 1))),\n kind')\n | No_group r' ->\n translate ids kind true ign_case greedy pos cache c r'\n | Nest r' ->\n let b = !pos in\n let (cr, kind') =\n translate ids kind ign_group ign_case greedy pos cache c r'\n in\n let e = !pos - 1 in\n if e < b then\n (cr, kind')\n else\n (A.seq ids `First (A.erase ids b e) cr, kind')\n | Difference _ | Complement _ | Intersection _ | No_case _ | Case _ ->\n assert false\n | Pmark (i, r') ->\n let (cr, kind') =\n translate ids kind ign_group ign_case greedy pos cache c r' in\n (A.seq ids `First (A.pmark ids i) cr, kind')\n\nand trans_seq ids kind ign_group ign_case greedy pos cache c = function\n | [] ->\n A.eps ids\n | [r] ->\n let (cr', kind') =\n translate ids kind ign_group ign_case greedy pos cache c r in\n enforce_kind ids kind kind' cr'\n | r :: rem ->\n let (cr', kind') =\n translate ids kind ign_group ign_case greedy pos cache c r in\n let cr'' =\n trans_seq ids kind ign_group ign_case greedy pos cache c rem in\n if A.is_eps cr'' then\n cr'\n else if A.is_eps cr' then\n cr''\n else\n A.seq ids kind' cr' cr''\n\n(**** Case ****)\n\nlet case_insens s =\n Cset.union s (Cset.union (Cset.offset 32 (Cset.inter s cupper))\n (Cset.offset (-32) (Cset.inter s clower)))\n\nlet as_set = function\n | Set s -> s\n | _ -> assert false\n\n(* XXX Should split alternatives into (1) charsets and (2) more\n complex regular expressions; alternative should therefore probably\n be flatten here *)\nlet rec handle_case ign_case = function\n | Set s ->\n Set (if ign_case then case_insens s else s)\n | Sequence l ->\n Sequence (List.map (handle_case ign_case) l)\n | Alternative l ->\n let l' = List.map (handle_case ign_case) l in\n if is_charset (Alternative l') then\n Set (List.fold_left (fun s r -> Cset.union s (as_set r)) Cset.empty l')\n else\n Alternative l'\n | Repeat (r, i, j) ->\n Repeat (handle_case ign_case r, i, j)\n | Beg_of_line | End_of_line | Beg_of_word | End_of_word | Not_bound\n | Beg_of_str | End_of_str | Last_end_of_line | Start | Stop as r ->\n r\n | Sem (k, r) ->\n let r' = handle_case ign_case r in\n if is_charset r' then r' else Sem (k, r')\n | Sem_greedy (k, r) ->\n let r' = handle_case ign_case r in\n if is_charset r' then r' else Sem_greedy (k, r')\n | Group r ->\n Group (handle_case ign_case r)\n | No_group r ->\n let r' = handle_case ign_case r in\n if is_charset r' then r' else No_group r'\n | Nest r ->\n let r' = handle_case ign_case r in\n if is_charset r' then r' else Nest r'\n | Case r ->\n handle_case false r\n | No_case r ->\n handle_case true r\n | Intersection l ->\n let l' = List.map (fun r -> handle_case ign_case r) l in\n Set (List.fold_left (fun s r -> Cset.inter s (as_set r)) Cset.cany l')\n | Complement l ->\n let l' = List.map (fun r -> handle_case ign_case r) l in\n Set (Cset.diff Cset.cany\n (List.fold_left (fun s r -> Cset.union s (as_set r))\n Cset.empty l'))\n | Difference (r, r') ->\n Set (Cset.inter (as_set (handle_case ign_case r))\n (Cset.diff Cset.cany (as_set (handle_case ign_case r'))))\n | Pmark (i,r) -> Pmark (i,handle_case ign_case r)\n\n(****)\n\nlet compile_1 regexp =\n let regexp = handle_case false regexp in\n let c = Color_map.make () in\n let need_lnl = colorize c regexp in\n let (colors, color_repr, ncolor) = Color_map.flatten c in\n let lnl = if need_lnl then ncolor else -1 in\n let ncolor = if need_lnl then ncolor + 1 else ncolor in\n let ids = A.create_ids () in\n let pos = ref 0 in\n let (r, kind) =\n translate ids\n `First false false `Greedy pos (ref Cset.CSetMap.empty) colors regexp in\n let r = enforce_kind ids `First kind r in\n (*Format.eprintf \"<%d %d>@.\" !ids ncol;*)\n mk_re ~initial:r ~colors ~color_repr ~ncolor ~lnl ~group_count:(!pos / 2)\n\n(****)\n\nlet rec anchored = function\n | Sequence l ->\n List.exists anchored l\n | Alternative l ->\n List.for_all anchored l\n | Repeat (r, i, _) ->\n i > 0 && anchored r\n | Set _ | Beg_of_line | End_of_line | Beg_of_word | End_of_word\n | Not_bound | End_of_str | Last_end_of_line | Stop\n | Intersection _ | Complement _ | Difference _ ->\n false\n | Beg_of_str | Start ->\n true\n | Sem (_, r) | Sem_greedy (_, r) | Group r | No_group r | Nest r\n | Case r | No_case r | Pmark (_, r) ->\n anchored r\n\n(****)\n\ntype t = regexp\n\nlet str s =\n let l = ref [] in\n for i = String.length s - 1 downto 0 do\n l := Set (Cset.csingle s.[i]) :: !l\n done;\n Sequence !l\nlet char c = Set (Cset.csingle c)\n\nlet alt = function\n | [r] -> r\n | l -> Alternative l\nlet seq = function\n | [r] -> r\n | l -> Sequence l\n\nlet empty = alt []\nlet epsilon = seq []\nlet repn r i j =\n if i < 0 then invalid_arg \"Re.repn\";\n begin match j with\n | Some j when j < i -> invalid_arg \"Re.repn\"\n | _ -> ()\n end;\n Repeat (r, i, j)\nlet rep r = repn r 0 None\nlet rep1 r = repn r 1 None\nlet opt r = repn r 0 (Some 1)\nlet bol = Beg_of_line\nlet eol = End_of_line\nlet bow = Beg_of_word\nlet eow = End_of_word\nlet word r = seq [bow; r; eow]\nlet not_boundary = Not_bound\nlet bos = Beg_of_str\nlet eos = End_of_str\nlet whole_string r = seq [bos; r; eos]\nlet leol = Last_end_of_line\nlet start = Start\nlet stop = Stop\nlet longest r = Sem (`Longest, r)\nlet shortest r = Sem (`Shortest, r)\nlet first r = Sem (`First, r)\nlet greedy r = Sem_greedy (`Greedy, r)\nlet non_greedy r = Sem_greedy (`Non_greedy, r)\nlet group r = Group r\nlet no_group r = No_group r\nlet nest r = Nest r\nlet mark r = let i = Pmark.gen () in (i,Pmark (i,r))\n\nlet set str =\n let s = ref Cset.empty in\n for i = 0 to String.length str - 1 do\n s := Cset.union (Cset.csingle str.[i]) !s\n done;\n Set !s\n\nlet rg c c' = Set (cseq c c')\n\nlet inter l =\n let r = Intersection l in\n if is_charset r then\n r\n else\n invalid_arg \"Re.inter\"\n\nlet compl l =\n let r = Complement l in\n if is_charset r then\n r\n else\n invalid_arg \"Re.compl\"\n\nlet diff r r' =\n let r'' = Difference (r, r') in\n if is_charset r'' then\n r''\n else\n invalid_arg \"Re.diff\"\n\nlet any = Set Cset.cany\nlet notnl = Set (Cset.diff Cset.cany (Cset.csingle '\\n'))\n\nlet lower = alt [rg 'a' 'z'; char '\\181'; rg '\\223' '\\246'; rg '\\248' '\\255']\nlet upper = alt [rg 'A' 'Z'; rg '\\192' '\\214'; rg '\\216' '\\222']\nlet alpha = alt [lower; upper; char '\\170'; char '\\186']\nlet digit = rg '0' '9'\nlet alnum = alt [alpha; digit]\nlet wordc = alt [alnum; char '_']\nlet ascii = rg '\\000' '\\127'\nlet blank = set \"\\t \"\nlet cntrl = alt [rg '\\000' '\\031'; rg '\\127' '\\159']\nlet graph = alt [rg '\\033' '\\126'; rg '\\160' '\\255']\nlet print = alt [rg '\\032' '\\126'; rg '\\160' '\\255']\nlet punct =\n alt [rg '\\033' '\\047'; rg '\\058' '\\064'; rg '\\091' '\\096';\n rg '\\123' '\\126'; rg '\\160' '\\169'; rg '\\171' '\\180';\n rg '\\182' '\\185'; rg '\\187' '\\191'; char '\\215'; char '\\247']\nlet space = alt [char ' '; rg '\\009' '\\013']\nlet xdigit = alt [digit; rg 'a' 'f'; rg 'A' 'F']\n\nlet case r = Case r\nlet no_case r = No_case r\n\n(****)\n\nlet compile r =\n compile_1 (\n if anchored r then\n group r\n else\n seq [shortest (rep any); group r]\n )\n\nlet exec_internal name ?(pos=0) ?(len = -1) ~partial ~groups re s =\n if pos < 0 || len < -1 || pos + len > String.length s then\n invalid_arg name;\n match_str ~groups ~partial re s ~pos ~len\n\nlet exec ?pos ?len re s =\n match exec_internal \"Re.exec\" ?pos ?len ~groups:true ~partial:false re s with\n Match substr -> substr\n | _ -> raise Not_found\n\nlet exec_opt ?pos ?len re s =\n match exec_internal \"Re.exec_opt\" ?pos ?len ~groups:true ~partial:false\n re s with\n Match substr -> Some substr\n | _ -> None\n\nlet execp ?pos ?len re s =\n match exec_internal ~groups:false ~partial:false \"Re.execp\" ?pos ?len re s with\n Match _substr -> true\n | _ -> false\n\nlet exec_partial ?pos ?len re s =\n match exec_internal ~groups:false ~partial:true \"Re.exec_partial\"\n ?pos ?len re s with\n Match _ -> `Full\n | Running -> `Partial\n | Failed -> `Mismatch\n\nmodule Mark = struct\n\n type t = Pmark.t\n\n let test (g : Group.t) p =\n Pmark.Set.mem p g.pmarks\n\n let all (g : Group.t) = g.pmarks\n\n module Set = Pmark.Set\n\n let equal = Pmark.equal\n\n let compare = Pmark.compare\n\nend\n\ntype split_token =\n [ `Text of string\n | `Delim of Group.t\n ]\n\nmodule Rseq = struct\n let all ?(pos=0) ?len re s : _ Seq.t =\n if pos < 0 then invalid_arg \"Re.all\";\n (* index of the first position we do not consider.\n !pos < limit is an invariant *)\n let limit = match len with\n | None -> String.length s\n | Some l ->\n if l<0 || pos+l > String.length s then invalid_arg \"Re.all\";\n pos+l\n in\n (* iterate on matches. When a match is found, search for the next\n one just after its end *)\n let rec aux pos () =\n if pos >= limit\n then Seq.Nil (* no more matches *)\n else\n match match_str ~groups:true ~partial:false re s\n ~pos ~len:(limit - pos) with\n | Match substr ->\n let p1, p2 = Group.offset substr 0 in\n let pos = if p1=p2 then p2+1 else p2 in\n Seq.Cons (substr, aux pos)\n | Running\n | Failed -> Seq.Nil\n in\n aux pos\n\n let matches ?pos ?len re s : _ Seq.t =\n all ?pos ?len re s\n |> Seq.map (fun sub -> Group.get sub 0)\n\n let split_full ?(pos=0) ?len re s : _ Seq.t =\n if pos < 0 then invalid_arg \"Re.split\";\n let limit = match len with\n | None -> String.length s\n | Some l ->\n if l<0 || pos+l > String.length s then invalid_arg \"Re.split\";\n pos+l\n in\n (* i: start of delimited string\n pos: first position after last match of [re]\n limit: first index we ignore (!pos < limit is an invariant) *)\n let pos0 = pos in\n let rec aux state i pos () = match state with\n | `Idle when pos >= limit ->\n if i < limit then (\n let sub = String.sub s i (limit - i) in\n Seq.Cons (`Text sub, aux state (i+1) pos)\n ) else Seq.Nil\n | `Idle ->\n begin match match_str ~groups:true ~partial:false re s ~pos\n ~len:(limit - pos) with\n | Match substr ->\n let p1, p2 = Group.offset substr 0 in\n let pos = if p1=p2 then p2+1 else p2 in\n let old_i = i in\n let i = p2 in\n if p1 > pos0 then (\n (* string does not start by a delimiter *)\n let text = String.sub s old_i (p1 - old_i) in\n let state = `Yield (`Delim substr) in\n Seq.Cons (`Text text, aux state i pos)\n ) else Seq.Cons (`Delim substr, aux state i pos)\n | Running -> Seq.Nil\n | Failed ->\n if i < limit\n then (\n let text = String.sub s i (limit - i) in\n (* yield last string *)\n Seq.Cons (`Text text, aux state limit pos)\n ) else\n Seq.Nil\n end\n | `Yield x ->\n Seq.Cons (x, aux `Idle i pos)\n in\n aux `Idle pos pos\n\n let split ?pos ?len re s : _ Seq.t =\n let seq = split_full ?pos ?len re s in\n let rec filter seq () = match seq () with\n | Seq.Nil -> Seq.Nil\n | Seq.Cons (`Delim _, tl) -> filter tl ()\n | Seq.Cons (`Text s,tl) -> Seq.Cons (s, filter tl)\n in filter seq\nend\n\nmodule Rlist = struct\n let list_of_seq (s:'a Seq.t) : 'a list =\n Seq.fold_left (fun l x -> x :: l) [] s |> List.rev\n\n let all ?pos ?len re s = Rseq.all ?pos ?len re s |> list_of_seq\n\n let matches ?pos ?len re s = Rseq.matches ?pos ?len re s |> list_of_seq\n\n let split_full ?pos ?len re s = Rseq.split_full ?pos ?len re s |> list_of_seq\n\n let split ?pos ?len re s = Rseq.split ?pos ?len re s |> list_of_seq\nend\n\nmodule Gen = struct\n type 'a gen = unit -> 'a option\n let gen_of_seq (s:'a Seq.t) : 'a gen =\n let r = ref s in\n fun () -> match !r () with\n | Seq.Nil -> None\n | Seq.Cons (x, tl) ->\n r := tl;\n Some x\n\n let split ?pos ?len re s : _ gen =\n Rseq.split ?pos ?len re s |> gen_of_seq\n\n let split_full ?pos ?len re s : _ gen =\n Rseq.split_full ?pos ?len re s |> gen_of_seq\n\n let all ?pos ?len re s = Rseq.all ?pos ?len re s |> gen_of_seq\n\n let matches ?pos ?len re s = Rseq.matches ?pos ?len re s |> gen_of_seq\nend\n\nlet replace ?(pos=0) ?len ?(all=true) re ~f s =\n if pos < 0 then invalid_arg \"Re.replace\";\n let limit = match len with\n | None -> String.length s\n | Some l ->\n if l<0 || pos+l > String.length s then invalid_arg \"Re.replace\";\n pos+l\n in\n (* buffer into which we write the result *)\n let buf = Buffer.create (String.length s) in\n (* iterate on matched substrings. *)\n let rec iter pos =\n if pos < limit\n then\n match match_str ~groups:true ~partial:false re s ~pos ~len:(limit-pos) with\n | Match substr ->\n let p1, p2 = Group.offset substr 0 in\n (* add string between previous match and current match *)\n Buffer.add_substring buf s pos (p1-pos);\n (* what should we replace the matched group with? *)\n let replacing = f substr in\n Buffer.add_string buf replacing;\n if all then\n (* if we matched a non-char e.g. ^ we must manually advance by 1 *)\n iter (\n if p1=p2 then (\n (* a non char could be past the end of string. e.g. $ *)\n if p2 < limit then Buffer.add_char buf s.[p2];\n p2+1\n ) else\n p2)\n else\n Buffer.add_substring buf s p2 (limit-p2)\n | Running -> ()\n | Failed ->\n Buffer.add_substring buf s pos (limit-pos)\n in\n iter pos;\n Buffer.contents buf\n\nlet replace_string ?pos ?len ?all re ~by s =\n replace ?pos ?len ?all re s ~f:(fun _ -> by)\n\nlet witness t =\n let rec witness = function\n | Set c -> String.make 1 (Char.chr (Cset.pick c))\n | Sequence xs -> String.concat \"\" (List.map witness xs)\n | Alternative (x :: _) -> witness x\n | Alternative [] -> assert false\n | Repeat (r, from, _to) ->\n let w = witness r in\n let b = Buffer.create (String.length w * from) in\n for _i=1 to from do\n Buffer.add_string b w\n done;\n Buffer.contents b\n | No_case r -> witness r\n | Intersection _\n | Complement _\n | Difference (_, _) -> assert false\n | Group r\n | No_group r\n | Nest r\n | Sem (_, r)\n | Pmark (_, r)\n | Case r\n | Sem_greedy (_, r) -> witness r\n | Beg_of_line\n | End_of_line\n | Beg_of_word\n | End_of_word\n | Not_bound\n | Beg_of_str\n | Last_end_of_line\n | Start\n | Stop\n | End_of_str -> \"\" in\n witness (handle_case false t)\n\ntype 'a seq = 'a Seq.t\nmodule Seq = Rseq\nmodule List = Rlist\nmodule Group = Group\n\n(** {2 Deprecated functions} *)\n\ntype 'a gen = 'a Gen.gen\nlet all_gen = Gen.all\nlet matches_gen = Gen.matches\nlet split_gen = Gen.split\nlet split_full_gen = Gen.split_full\n\nlet all_seq = Seq.all\nlet matches_seq = Seq.matches\nlet split_seq = Seq.split\nlet split_full_seq = Seq.split_full\n\n\ntype substrings = Group.t\n\nlet get = Group.get\nlet get_ofs = Group.offset\nlet get_all = Group.all\nlet get_all_ofs = Group.all_offset\nlet test = Group.test\n\ntype markid = Mark.t\n\nlet marked = Mark.test\nlet mark_set = Mark.all\n\n(**********************************)\n\n(*\nInformation about the previous character:\n- does not exists\n- is a letter\n- is not a letter\n- is a newline\n- is last newline\n\nBeginning of word:\n- previous is not a letter or does not exist\n- current is a letter or does not exist\n\nEnd of word:\n- previous is a letter or does not exist\n- current is not a letter or does not exist\n\nBeginning of line:\n- previous is a newline or does not exist\n\nBeginning of buffer:\n- previous does not exist\n\nEnd of buffer\n- current does not exist\n\nEnd of line\n- current is a newline or does not exist\n*)\n\n(*\nRep: e = T,e | ()\n - semantics of the comma (shortest/longest/first)\n - semantics of the union (greedy/non-greedy)\n\nBounded repetition\n a{0,3} = (a,(a,a?)?)?\n*)\n\ntype groups = Group.t\n\ninclude Rlist\n","include Ast\n\nlet string_of_pos (pos : Lexing.position) =\n Format.sprintf \"Line %d col %d\" pos.pos_lnum (pos.pos_cnum - pos.pos_bol + 1)\n\nlet parse s =\n let lexbuf = Lexing.from_string s in\n try Ok (Parser.doc Lexer.token lexbuf) with\n | Parser.Error ->\n let pos = lexbuf.lex_start_p in\n Error (Format.sprintf \"%s: Syntax error\" (string_of_pos pos))\n | Lexer.Error msg ->\n let pos = lexbuf.lex_curr_p in\n Error (Format.sprintf \"%s: %s\" (string_of_pos pos) msg)\n","open Core_kernel\nopen Fieldslib\n\nmodule Js_layout = struct\n module Input = struct\n type 'a t =\n < js_layout : [> `Assoc of (string * Yojson.Safe.t) list ] ref ; .. >\n as\n 'a\n end\n\n module Accumulator = struct\n type field = { key : string; value : Yojson.Safe.t; docs : Yojson.Safe.t }\n\n let to_key ({ key; _ } : field) = `String key\n\n let to_entry ({ key; value; _ } : field) : string * Yojson.Safe.t =\n (key, value)\n\n let to_doc_entry ({ key; docs; _ } : field) : string * Yojson.Safe.t =\n (key, docs)\n\n type 'a t = < js_layout_accumulator : field option list ref ; .. > as 'a\n constraint 'a t = 'a Input.t\n end\n\n let docs (s : Fields_derivers.Annotations.Fields.T.t) : Yojson.Safe.t =\n match s.doc with Some t -> `String t | None -> `Null\n\n let add_field ~t_fields_annots t_field field (acc : _ Accumulator.t) :\n _ * _ Accumulator.t =\n let annotations =\n Fields_derivers.Annotations.Fields.of_annots t_fields_annots\n (Field.name field)\n in\n let rest = !(acc#js_layout_accumulator) in\n let key =\n Option.value annotations.name\n ~default:(Fields_derivers.name_under_to_camel field)\n in\n let value = !(t_field#js_layout) in\n let new_field =\n if annotations.skip || !(t_field#skip) then None\n else Some Accumulator.{ key; value; docs = docs annotations }\n in\n acc#js_layout_accumulator := new_field :: rest ;\n ((fun _ -> failwith \"Unused\"), acc)\n\n let finish name ~t_toplevel_annots (_creator, obj) =\n let annotations =\n Fields_derivers.Annotations.Top.of_annots ~name t_toplevel_annots\n in\n let accumulator =\n List.filter_map ~f:Fn.id !(obj#js_layout_accumulator) |> List.rev\n in\n obj#js_layout :=\n `Assoc\n [ (\"type\", `String \"object\")\n ; (\"name\", `String annotations.name)\n ; ( \"docs\"\n , match annotations.doc with Some s -> `String s | None -> `Null )\n ; (\"keys\", `List (List.map ~f:Accumulator.to_key accumulator))\n ; (\"entries\", `Assoc (List.map ~f:Accumulator.to_entry accumulator))\n ; ( \"docEntries\"\n , `Assoc (List.map ~f:Accumulator.to_doc_entry accumulator) )\n ] ;\n obj\n\n type leaf_type =\n | String\n | Number\n | Null\n | Field\n | Bool\n | UInt32\n | UInt64\n | PublicKey\n | Sign\n | Custom of string\n\n let leaf_type_to_string = function\n | String ->\n \"string\"\n | Number ->\n \"number\"\n | Null ->\n \"null\"\n | Field ->\n \"Field\"\n | Bool ->\n \"Bool\"\n | UInt32 ->\n \"UInt32\"\n | UInt64 ->\n \"UInt64\"\n | PublicKey ->\n \"PublicKey\"\n | Sign ->\n \"Sign\"\n | Custom s ->\n s\n\n type option_type =\n | Flagged_option\n | Closed_interval of (string * string)\n | Or_undefined\n\n let leaf_type (s : leaf_type) =\n `Assoc [ (\"type\", `String (leaf_type_to_string s)) ]\n\n let of_layout layout obj =\n obj#js_layout := layout ;\n obj\n\n let skip obj =\n obj#skip := true ;\n obj#js_layout := leaf_type Null ;\n obj\n\n let int obj =\n obj#js_layout := leaf_type Number ;\n obj\n\n let string obj =\n obj#js_layout := leaf_type String ;\n obj\n\n let bool obj =\n obj#js_layout := leaf_type Bool ;\n obj\n\n let list ?static_length x obj : _ Input.t =\n let inner = !(x#js_layout) in\n let static_length =\n match static_length with Some length -> `Int length | None -> `Null\n in\n obj#js_layout :=\n `Assoc\n [ (\"type\", `String \"array\")\n ; (\"inner\", inner)\n ; (\"staticLength\", static_length)\n ] ;\n obj\n\n let record (entries : (string * 'a) list) (obj : _ Input.t) : _ Input.t =\n obj#js_layout :=\n `Assoc\n [ (\"type\", `String \"object\")\n ; (\"name\", `String \"Anonymous\")\n ; (\"docs\", `Null)\n ; (\"keys\", `List (List.map ~f:(fun (key, _) -> `String key) entries))\n ; ( \"entries\"\n , `Assoc (List.map ~f:(fun (key, inner) -> (key, inner)) entries) )\n ; ( \"docEntries\"\n , `Assoc (List.map ~f:(fun (key, _) -> (key, `String \"\")) entries) )\n ] ;\n obj\n\n let option x obj ~(js_type : option_type) : _ Input.t =\n let inner = !(x#js_layout) in\n let layout =\n match js_type with\n | Flagged_option ->\n `Assoc\n [ (\"type\", `String \"option\")\n ; (\"optionType\", `String \"flaggedOption\")\n ; (\"inner\", inner)\n ]\n | Closed_interval (min, max) ->\n `Assoc\n [ (\"type\", `String \"option\")\n ; (\"optionType\", `String \"closedInterval\")\n ; (\"rangeMin\", `String min)\n ; (\"rangeMax\", `String max)\n ; (\"inner\", inner)\n ]\n | Or_undefined ->\n `Assoc\n [ (\"type\", `String \"option\")\n ; (\"optionType\", `String \"orUndefined\")\n ; (\"inner\", inner)\n ]\n in\n obj#js_layout := layout ;\n obj\n\n let wrapped x obj =\n obj#js_layout := !(x#js_layout) ;\n obj\n\n let needs_custom_js ~name (x : _ Input.t) (obj : _ Input.t) =\n match !(obj#js_layout) with\n | `Assoc layout ->\n obj#js_layout :=\n `Assoc\n ( layout\n @ [ (\"checkedType\", !(x#js_layout))\n ; (\"checkedTypeName\", `String name)\n ] ) ;\n obj\n | _ ->\n failwith \"impossible\"\nend\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Snark_params.Tick\n\n[%%ifdef consensus_mechanism]\n\nopen Snark_bits\n\n[%%endif]\n\nmodule type Data_hash_descriptor = sig\n val version_byte : char\n\n val description : string\nend\n\nmodule type Basic = sig\n type t = Field.t [@@deriving sexp, yojson]\n\n val to_decimal_string : t -> string\n\n val of_decimal_string : string -> t\n\n val to_bytes : t -> string\n\n [%%ifdef consensus_mechanism]\n\n val gen : t Quickcheck.Generator.t\n\n type var\n\n val var_to_hash_packed : var -> Random_oracle.Checked.Digest.t\n\n val var_to_input : var -> Field.Var.t Random_oracle.Input.Chunked.t\n\n val var_to_bits : var -> Boolean.var list Checked.t\n\n val typ : (var, t) Typ.t\n\n val assert_equal : var -> var -> unit Checked.t\n\n val equal_var : var -> var -> Boolean.var Checked.t\n\n val var_of_t : t -> var\n\n (* TODO : define bit ops using Random_oracle instead of Pedersen.Digest,\n move this outside of consensus_mechanism guard\n *)\n include Bits_intf.S with type t := t\n\n [%%endif]\n\n val to_base58_check : t -> string\n\n val of_base58_check : string -> t Base.Or_error.t\n\n val of_base58_check_exn : string -> t\n\n val to_input : t -> Field.t Random_oracle.Input.Chunked.t\nend\n\nmodule type Full_size = sig\n include Basic\n\n include Comparable.S with type t := t\n\n include Hashable with type t := t\n\n [%%ifdef consensus_mechanism]\n\n val if_ : Boolean.var -> then_:var -> else_:var -> var Checked.t\n\n val var_of_hash_packed : Random_oracle.Checked.Digest.t -> var\n\n val var_to_field : var -> Random_oracle.Checked.Digest.t\n\n [%%endif]\n\n val of_hash : Field.t -> t\n\n val to_field : t -> Field.t\nend\n","module type S = sig\n open Async_kernel\n open Core_kernel\n open Snark_params\n open Snark_bits\n\n module Time : sig\n type t [@@deriving sexp, compare, yojson]\n\n val zero : t\n\n val max_value : t\n\n include Comparable.S with type t := t\n\n include Hashable.S with type t := t\n\n module Controller : sig\n type t [@@deriving sexp, equal, compare]\n\n val create : t -> t\n\n val basic : logger:Logger.t -> t\n\n (** Override the time offset set by the [MINA_TIME_OFFSET] environment\n variable for all block time controllers.\n [enable_setting_offset] must have been called first, and\n [disable_setting_offset] must not have been called, otherwise this\n raises a [Failure].\n *)\n val set_time_offset : Time.Span.t -> unit\n\n (** Get the current time offset, either from the [MINA_TIME_OFFSET]\n environment variable, or as last set by [set_time_offset].\n *)\n val get_time_offset : logger:Logger.t -> Time.Span.t\n\n (** Disallow setting the time offset. This should be run at every\n entrypoint which does not explicitly need to update the time offset.\n *)\n val disable_setting_offset : unit -> unit\n\n (** Allow setting the time offset. This may only be run if\n [disable_setting_offset] has not already been called, otherwise it will\n raise a [Failure].\n *)\n val enable_setting_offset : unit -> unit\n end\n\n [%%versioned:\n module Stable : sig\n [@@@no_toplevel_latest_type]\n\n module V1 : sig\n type nonrec t = t [@@deriving sexp, compare, equal, hash, yojson]\n\n include Hashable.S with type t := t\n end\n end]\n\n module Bits : Bits_intf.Convertible_bits with type t := t\n\n include\n Tick.Snarkable.Bits.Faithful\n with type Unpacked.value = t\n and type Packed.value = t\n and type Packed.var = private Tick.Field.Var.t\n\n val to_input : t -> Tick.Field.t Random_oracle_input.Chunked.t\n\n module Checked : sig\n open Snark_params.Tick\n\n type t\n\n val typ : (t, Stable.Latest.t) Typ.t\n\n val to_input : t -> Field.Var.t Random_oracle_input.Chunked.t\n\n val ( = ) : t -> t -> Boolean.var Checked.t\n\n val ( < ) : t -> t -> Boolean.var Checked.t\n\n val ( > ) : t -> t -> Boolean.var Checked.t\n\n val ( <= ) : t -> t -> Boolean.var Checked.t\n\n val ( >= ) : t -> t -> Boolean.var Checked.t\n\n val to_field : t -> Field.Var.t\n\n module Unsafe : sig\n val of_field : Field.Var.t -> t\n end\n end\n\n module Span : sig\n type t [@@deriving sexp, compare, equal, yojson]\n\n module Stable : sig\n module V1 : sig\n type nonrec t = t\n [@@deriving bin_io, equal, sexp, compare, hash, yojson, version]\n end\n end\n\n val of_time_span : Time.Span.t -> t\n\n val to_time_span : t -> Time.Span.t\n\n module Bits : Bits_intf.Convertible_bits with type t := t\n\n include\n Tick.Snarkable.Bits.Faithful\n with type Unpacked.value = t\n and type Packed.value = t\n\n val to_time_ns_span : t -> Core_kernel.Time_ns.Span.t\n\n val of_time_ns_span : Core_kernel.Time_ns.Span.t -> t\n\n val to_string_hum : t -> string\n\n val to_ms : t -> Int64.t\n\n val of_ms : Int64.t -> t\n\n val ( + ) : t -> t -> t\n\n val ( - ) : t -> t -> t\n\n val ( * ) : t -> t -> t\n\n val ( < ) : t -> t -> bool\n\n val ( > ) : t -> t -> bool\n\n val ( = ) : t -> t -> bool\n\n val ( <= ) : t -> t -> bool\n\n val ( >= ) : t -> t -> bool\n\n val min : t -> t -> t\n\n val zero : t\n\n val to_input : t -> Tick.Field.t Random_oracle_input.Chunked.t\n\n module Checked : sig\n type t\n\n val typ : (t, Stable.V1.t) Snark_params.Tick.Typ.t\n\n open Snark_params.Tick\n\n val to_input : t -> Tick.Field.Var.t Random_oracle_input.Chunked.t\n\n val to_field : t -> Field.Var.t\n\n module Unsafe : sig\n val of_field : Field.Var.t -> t\n end\n end\n end\n\n val field_var_to_unpacked : Tick.Field.Var.t -> Unpacked.var Tick.Checked.t\n\n val diff_checked :\n Unpacked.var -> Unpacked.var -> Span.Unpacked.var Tick.Checked.t\n\n val unpacked_to_number : Span.Unpacked.var -> Tick.Number.t\n\n val add : t -> Span.t -> t\n\n val diff : t -> t -> Span.t\n\n val sub : t -> Span.t -> t\n\n val to_span_since_epoch : t -> Span.t\n\n val of_span_since_epoch : Span.t -> t\n\n val modulus : t -> Span.t -> Span.t\n\n val of_time : Time.t -> t\n\n val to_time_exn : t -> Time.t\n\n val now : Controller.t -> t\n\n val to_int64 : t -> Int64.t\n\n val of_int64 : Int64.t -> t\n\n val of_uint64 : Unsigned.UInt64.t -> t\n\n val to_uint64 : t -> Unsigned.UInt64.t\n\n val of_time_ns : Time_ns.t -> t\n\n val to_string_exn : t -> string\n\n (** Strip time offset *)\n val to_string_system_time_exn : Controller.t -> t -> string\n\n (** Strip time offset *)\n val to_system_time : Controller.t -> t -> t\n\n val of_string_exn : string -> t\n\n val gen_incl : t -> t -> t Quickcheck.Generator.t\n\n val gen : t Quickcheck.Generator.t\n end\n\n include module type of Time with type t = Time.t\n\n module Timeout : sig\n type 'a t\n\n type time\n\n val create : Controller.t -> Span.t -> f:(time -> 'a) -> 'a t\n\n val to_deferred : 'a t -> 'a Async_kernel.Deferred.t\n\n val peek : 'a t -> 'a option\n\n val cancel : Controller.t -> 'a t -> 'a -> unit\n\n val remaining_time : 'a t -> Span.t\n\n val await :\n timeout_duration:Span.t\n -> Controller.t\n -> 'a Deferred.t\n -> [ `Ok of 'a | `Timeout ] Deferred.t\n\n val await_exn :\n timeout_duration:Span.t -> Controller.t -> 'a Deferred.t -> 'a Deferred.t\n end\n with type time := t\nend\n","(* quickcheck_lib.ml *)\n\nopen Core_kernel\nopen Quickcheck.Generator\nopen Quickcheck.Let_syntax\n\nlet of_array array = Quickcheck.Generator.of_list @@ Array.to_list array\n\nlet rec map_gens ls ~f =\n match ls with\n | [] ->\n return []\n | h :: t ->\n let%bind h' = f h in\n let%map t' = map_gens t ~f in\n h' :: t'\n\nlet replicate_gen g n = map_gens (List.init n ~f:Fn.id) ~f:(Fn.const g)\n\nlet init_gen ~f n =\n let rec go : 'a list -> int -> 'a list Quickcheck.Generator.t =\n fun xs n' ->\n if n' < n then f n' >>= fun x -> go (x :: xs) (n' + 1)\n else return @@ List.rev xs\n in\n go [] 0\n\nlet init_gen_array ~f n = map ~f:Array.of_list @@ init_gen ~f n\n\nlet gen_pair g =\n let%map a = g and b = g in\n (a, b)\n\nlet shuffle_arr_inplace arr =\n (* Fisher-Yates shuffle, you need fast swaps for decent performance, so we\n want an array if we're not getting unnecessarily fancy. *)\n let rec go n =\n if n < Array.length arr then (\n let%bind swap_idx = Int.gen_uniform_incl n (Array.length arr - 1) in\n Array.swap arr n swap_idx ;\n go (n + 1) )\n else return arr\n in\n go 0\n\nlet shuffle_arr arr = shuffle_arr_inplace @@ Array.copy arr\n\nlet shuffle list =\n Array.of_list list |> shuffle_arr_inplace |> map ~f:Array.to_list\n\n(* Generate a list with a Dirichlet distribution, used for coming up with random\n splits of a quantity. Symmetric Dirichlet distribution with alpha = 1.\n*)\nlet gen_symm_dirichlet : int -> float list Quickcheck.Generator.t =\n fun n ->\n let open Quickcheck.Generator.Let_syntax in\n let%map gammas =\n map_gens\n (List.init n ~f:(Fn.const ()))\n ~f:(fun _ ->\n let open Quickcheck.Generator.Let_syntax in\n (* technically this should be (0, 1] and not (0, 1) but I expect it\n doesn't matter for our purposes. *)\n let%map uniform = Float.gen_uniform_excl 0. 1. in\n Float.log uniform )\n in\n let sum = List.fold gammas ~init:0. ~f:(fun x y -> x +. y) in\n List.map gammas ~f:(fun gamma -> gamma /. sum)\n\nmodule type Int_s = sig\n type t\n\n val zero : t\n\n val ( + ) : t -> t -> t\n\n val ( - ) : t -> t -> t\n\n val ( > ) : t -> t -> bool\n\n val of_int : int -> t\n\n val to_int : t -> int\nend\n\nlet gen_division_generic (type t) (module M : Int_s with type t = t) (n : t)\n (k : int) : M.t list Quickcheck.Generator.t =\n if k = 0 then Quickcheck.Generator.return []\n else\n let open Quickcheck.Generator.Let_syntax in\n (* Using a symmetric Dirichlet distribution with concentration parameter 1\n defined above gives a distribution with uniform probability density over\n all possible splits of the quantity. See the Wikipedia article for some\n more detail: https://en.wikipedia.org/wiki/Dirichlet_distribution,\n particularly the sections about the flat Dirichlet distribution and\n string cutting.\n *)\n let%bind dirichlet = gen_symm_dirichlet k in\n let n_float = Float.of_int @@ M.to_int n in\n let float_to_mt : float -> t =\n fun fl ->\n match Float.iround_down fl with\n | Some int ->\n M.of_int int\n | None ->\n failwith \"gen_division_generic: out of range\"\n in\n let res = List.map dirichlet ~f:(fun x -> float_to_mt @@ (x *. n_float)) in\n let total = List.fold res ~f:M.( + ) ~init:M.zero in\n return\n ( match res with\n | [] ->\n failwith\n \"empty result list in gen_symm_dirichlet, this should be \\\n impossible. \"\n | head :: rest ->\n (* Going through floating point land may have caused some rounding error. We\n tack it onto the first result so that the sum of the output is equal to n.\n *)\n if M.( > ) n total then M.(head + (n - total)) :: rest\n else M.(head - (total - n)) :: rest )\n\nlet gen_division = gen_division_generic (module Int)\n\nlet gen_division_currency =\n gen_division_generic\n ( module struct\n include Currency.Amount\n\n let ( + ) a b = Option.value_exn (a + b)\n\n let ( - ) a b = Option.value_exn (a - b)\n\n let of_int = of_nanomina_int_exn\n\n let to_int = to_nanomina_int\n end )\n\nlet imperative_fixed_point root ~f =\n let%map f' = fixed_point f in\n f' root\n\nlet gen_imperative_rose_tree ?(p = 0.75) (root_gen : 'a t)\n (node_gen : ('a -> 'a) t) =\n let%bind root = root_gen in\n imperative_fixed_point root ~f:(fun self ->\n match%bind size with\n | 0 ->\n return (fun parent -> Rose_tree.T (parent, []))\n | n ->\n let%bind fork_count = geometric ~p 1 >>| Int.max n in\n let%bind fork_sizes = gen_division n fork_count in\n let positive_fork_sizes =\n List.filter fork_sizes ~f:(fun s -> s > 0)\n in\n let%map forks =\n map_gens positive_fork_sizes ~f:(fun s ->\n tuple2 node_gen (with_size ~size:(s - 1) self) )\n in\n fun parent ->\n Rose_tree.T\n (parent, List.map forks ~f:(fun (this, f) -> f (this parent))) )\n\nlet gen_imperative_ktree ?(p = 0.75) (root_gen : 'a t) (node_gen : ('a -> 'a) t)\n =\n let%bind root = root_gen in\n imperative_fixed_point root ~f:(fun self ->\n match%bind size with\n | 0 ->\n return (fun _ -> [])\n (* this case is optional but more effecient *)\n | 1 ->\n let%map this = node_gen in\n fun parent -> [ this parent ]\n | n ->\n let%bind this = node_gen in\n let%bind fork_count = geometric ~p 1 >>| Int.max n in\n let%bind fork_sizes = gen_division (n - 1) fork_count in\n let%map forks =\n map_gens fork_sizes ~f:(fun s -> with_size ~size:s self)\n in\n fun parent ->\n let x = this parent in\n x :: List.bind forks ~f:(fun f -> f x) )\n\nlet gen_imperative_list (root_gen : 'a t) (node_gen : ('a -> 'a) t) =\n let%bind root = root_gen in\n imperative_fixed_point root ~f:(fun self ->\n match%bind size with\n | 0 ->\n return (fun _ -> [])\n | n ->\n let%bind this = node_gen in\n let%map f = with_size ~size:(n - 1) self in\n fun parent -> parent :: f (this parent) )\n\nlet%test_module \"Quickcheck lib tests\" =\n ( module struct\n let%test_unit \"gen_imperative_list\" =\n let increment = ( + ) 2 in\n let root = 1 in\n let root_gen = return root in\n let gen =\n Int.gen_incl 2 100\n >>= fun size ->\n Quickcheck.Generator.with_size ~size\n (gen_imperative_list root_gen (return increment))\n in\n Quickcheck.test gen ~f:(fun list ->\n match list with\n | [] ->\n failwith \"We assume that our list has at least one element\"\n | x :: xs ->\n assert (x = root) ;\n let result =\n List.fold_result xs ~init:x ~f:(fun elem next_elem ->\n if next_elem = increment elem then Result.return next_elem\n else\n Or_error.errorf\n !\"elements do not add up correctly %d %d\"\n elem next_elem )\n in\n assert (Result.is_ok result) )\n end )\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\n\nlet field_of_bool =\n Snark_params.Tick.(fun b -> if b then Field.one else Field.zero)\n\nlet bit_length_to_triple_length n =\n let r = n mod 3 in\n let k = n / 3 in\n if r = 0 then k else k + 1\n\nlet split_last_exn =\n let rec go acc x xs =\n match xs with [] -> (List.rev acc, x) | x' :: xs -> go (x :: acc) x' xs\n in\n function [] -> failwith \"split_last: Empty list\" | x :: xs -> go [] x xs\n\nlet two_to_the i = Bignum_bigint.(pow (of_int 2) (of_int i))\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Mina_base_import\n\nmodule type S = sig\n module Digest : sig\n [%%versioned:\n module Stable : sig\n module V1 : sig\n type t [@@deriving sexp, equal, compare, hash, yojson]\n end\n end]\n\n val of_field : Snark_params.Tick.Field.t -> t\n\n val to_field_unsafe : t -> Snark_params.Tick.Field.t\n\n include Stringable.S with type t := t\n\n (* so we can easily import these into Token_id *)\n module Binables : sig\n include Comparable_binable with type t := t\n\n include Hashable_binable with type t := t\n end\n\n include module type of Binables\n\n val to_input : t -> Snark_params.Tick.Field.t Random_oracle.Input.Chunked.t\n\n val default : t\n\n val gen : t Quickcheck.Generator.t\n\n val gen_non_default : t Quickcheck.Generator.t\n\n [%%ifdef consensus_mechanism]\n\n module Checked : sig\n open Pickles.Impls.Step\n\n type t\n\n val to_input : t -> Field.t Random_oracle.Input.Chunked.t\n\n val constant : Stable.Latest.t -> t\n\n val equal : t -> t -> Boolean.var\n\n val if_ : Boolean.var -> then_:t -> else_:t -> t\n\n val of_field : Pickles.Impls.Step.Field.t -> t\n\n val to_field_unsafe : t -> Pickles.Impls.Step.Field.t\n\n module Assert : sig\n val equal : t -> t -> unit\n end\n end\n\n val typ : (Checked.t, t) Snark_params.Tick.Typ.t\n\n [%%endif]\n end\n\n [%%versioned:\n module Stable : sig\n module V2 : sig\n type t [@@deriving sexp, equal, compare, hash, yojson]\n end\n end]\n\n val create : Public_key.Compressed.t -> Digest.t -> t\n\n val derive_token_id : owner:t -> Digest.t\n\n val empty : t\n\n val invalid : t\n\n val public_key : t -> Public_key.Compressed.t\n\n val of_public_key : Public_key.t -> t\n\n val token_id : t -> Digest.t\n\n val to_input : t -> Snark_params.Tick.Field.t Random_oracle.Input.Chunked.t\n\n val gen : t Quickcheck.Generator.t\n\n include Comparable.S with type t := t\n\n include Hashable.S_binable with type t := t\n\n [%%ifdef consensus_mechanism]\n\n type var\n\n val typ : (var, t) Snark_params.Tick.Typ.t\n\n val var_of_t : t -> var\n\n module Checked : sig\n open Snark_params\n open Tick\n\n val create : Public_key.Compressed.var -> Digest.Checked.t -> var\n\n val public_key : var -> Public_key.Compressed.var\n\n val token_id : var -> Digest.Checked.t\n\n val to_input :\n var -> Snark_params.Tick.Field.Var.t Random_oracle.Input.Chunked.t\n\n val equal : var -> var -> Boolean.var Checked.t\n\n val if_ : Boolean.var -> then_:var -> else_:var -> var Checked.t\n\n val derive_token_id : owner:var -> Digest.Checked.t\n end\n\n [%%endif]\nend\n","(* hash_prefix.ml *)\n\ninclude Hash_prefix_states\n","(* data_hash.ml *)\n\ninclude Data_hash_lib.Data_hash\n","open Core_kernel\n\nmodule Legacy_token = Mina_numbers.Nat.Make64 ()\n\n[%%versioned\nmodule Stable = struct\n module V2 = struct\n type t = Account_id.Digest.Stable.V1.t\n [@@deriving sexp, yojson, equal, compare, hash]\n\n let to_latest = Fn.id\n end\n\n (* for transactions in pre-Berkeley hard fork *)\n module V1 = struct\n [@@@with_all_version_tags]\n\n type t = Legacy_token.Stable.V1.t\n [@@deriving sexp, equal, compare, hash, yojson]\n\n let to_latest _ = failwith \"Not implemented\"\n end\nend]\n\n[%%define_locally\nAccount_id.Digest.\n ( default\n , typ\n , to_input\n , gen\n , gen_non_default\n , to_field_unsafe\n , of_field\n , to_string\n , of_string\n , comparator\n , ( <> ) )]\n\ninclude Account_id.Digest.Binables\n\n(* someday, allow this in %%define_locally *)\nmodule Checked = Account_id.Digest.Checked\n\nlet deriver obj =\n (* this doesn't use js_type:Field because it is converted to JSON differently than a normal Field *)\n Fields_derivers_zkapps.iso_string obj ~name:\"TokenId\"\n ~js_type:(Custom \"TokenId\") ~doc:\"String representing a token ID\" ~to_string\n ~of_string:(Fields_derivers_zkapps.except ~f:of_string `Token_id)\n","(** Fee excesses associated with transactions or transitions.\n\n These are represented as a 'left' and 'right' excess, which describe the\n unresolved fee excesses in the fee tokens of the first (or leftmost) and\n last (or rightmost) transactions in the transition.\n\n Assumptions:\n * Transactions are grouped by their fee token.\n * The 'fee transfer' transaction to dispense those fees is part of this\n group.\n * The fee excess for each token is 0 across the group.\n * No transactions with fees paid in another token are executed while the\n previous fee token's excess is non-zero.\n\n By maintaining these assumptions, we can ensure that the un-settled fee\n excesses can be represented by excesses in (at most) 2 tokens.\n Consider, for example, any consecutive subsequence of the transactions\n\n ..[txn@2][ft@2][txn@3][txn@3][ft@3][txn@4][ft@4][txn@5][txn@5][ft@5][txn@6][ft@6]..\n\n where [txn@i] and [ft@i] are transactions and fee transfers respectively\n paid in token i.\n The only groups which may have non-zero fee excesses are those which\n contain the start and end of the subsequence.\n\n The code below also defines a canonical representation where fewer than 2\n tokens have non-zero excesses. See [rebalance] below for details and the\n implementation.\n*)\n\n[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\n\n[%%ifndef consensus_mechanism]\n\nopen Mina_base_import\n\n[%%endif]\n\nopen Currency\n\n[%%ifdef consensus_mechanism]\n\nopen Snark_params\nopen Tick\n\n[%%endif]\n\nmodule Poly = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type ('token, 'fee) t =\n ('token, 'fee) Mina_wire_types.Mina_base.Fee_excess.Poly.V1.t =\n { fee_token_l : 'token\n ; fee_excess_l : 'fee\n ; fee_token_r : 'token\n ; fee_excess_r : 'fee\n }\n [@@deriving compare, equal, hash, sexp, hlist]\n\n let to_yojson token_to_yojson fee_to_yojson\n { fee_token_l; fee_excess_l; fee_token_r; fee_excess_r } =\n `List\n [ `Assoc\n [ (\"token\", token_to_yojson fee_token_l)\n ; (\"amount\", fee_to_yojson fee_excess_l)\n ]\n ; `Assoc\n [ (\"token\", token_to_yojson fee_token_r)\n ; (\"amount\", fee_to_yojson fee_excess_r)\n ]\n ]\n\n let of_yojson token_of_yojson fee_of_yojson = function\n | `List [ `Assoc [ left0; left1 ]; `Assoc [ right0; right1 ] ] -> (\n (* allow for reversed field order: \"be liberal in what you accept\" *)\n let token_and_excess pair0 pair1 =\n match (pair0, pair1) with\n | (\"token\", token), (\"amount\", excess) ->\n Some (token, excess)\n | (\"amount\", excess), (\"token\", token) ->\n Some (token, excess)\n | _ ->\n None\n in\n let left = token_and_excess left0 left1 in\n let right = token_and_excess right0 right1 in\n match (left, right) with\n | Some (fee_token_l, fee_excess_l), Some (fee_token_r, fee_excess_r)\n ->\n let open Result.Let_syntax in\n let%map fee_token_l = token_of_yojson fee_token_l\n and fee_excess_l = fee_of_yojson fee_excess_l\n and fee_token_r = token_of_yojson fee_token_r\n and fee_excess_r = fee_of_yojson fee_excess_r in\n { fee_token_l; fee_excess_l; fee_token_r; fee_excess_r }\n | _ ->\n Error \"Fee_excess.Poly.Stable.V1.t, unexpected JSON field\" )\n | _ ->\n Error \"Fee_excess.Poly.Stable.V1.t\"\n end\n end]\n\n [%%define_locally Stable.Latest.(to_yojson, of_yojson)]\n\n [%%ifdef consensus_mechanism]\n\n let typ (token_typ : ('token_var, 'token) Typ.t)\n (fee_typ : ('fee_var, 'fee) Typ.t) :\n (('token_var, 'fee_var) t, ('token, 'fee) t) Typ.t =\n Typ.of_hlistable\n [ token_typ; fee_typ; token_typ; fee_typ ]\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist\n\n [%%endif]\nend\n\n[%%versioned\nmodule Stable = struct\n module V1 = struct\n type t =\n ( Token_id.Stable.V2.t\n , (Fee.Stable.V1.t, Sgn.Stable.V1.t) Signed_poly.Stable.V1.t )\n Poly.Stable.V1.t\n [@@deriving compare, equal, hash, sexp, yojson]\n\n let to_latest = Fn.id\n end\nend]\n\ntype ('token, 'fee) poly = ('token, 'fee) Poly.t =\n { fee_token_l : 'token\n ; fee_excess_l : 'fee\n ; fee_token_r : 'token\n ; fee_excess_r : 'fee\n }\n[@@deriving compare, equal, hash, sexp]\n\nlet poly_to_yojson = Poly.to_yojson\n\nlet poly_of_yojson = Poly.of_yojson\n\n[%%ifdef consensus_mechanism]\n\ntype var = (Token_id.Checked.t, Fee.Signed.var) poly\n\nlet typ : (var, t) Typ.t = Poly.typ Token_id.typ Fee.Signed.typ\n\nlet var_of_t ({ fee_token_l; fee_excess_l; fee_token_r; fee_excess_r } : t) :\n var =\n { fee_token_l = Token_id.Checked.constant fee_token_l\n ; fee_excess_l = Fee.Signed.Checked.constant fee_excess_l\n ; fee_token_r = Token_id.Checked.constant fee_token_r\n ; fee_excess_r = Fee.Signed.Checked.constant fee_excess_r\n }\n\n[%%endif]\n\nlet to_input { fee_token_l; fee_excess_l; fee_token_r; fee_excess_r } =\n let open Random_oracle.Input.Chunked in\n List.reduce_exn ~f:append\n [ Token_id.to_input fee_token_l\n ; Fee.Signed.to_input fee_excess_l\n ; Token_id.to_input fee_token_r\n ; Fee.Signed.to_input fee_excess_r\n ]\n\n[%%ifdef consensus_mechanism]\n\nlet to_input_checked { fee_token_l; fee_excess_l; fee_token_r; fee_excess_r } =\n let fee_token_l = Token_id.Checked.to_input fee_token_l\n and fee_token_r = Token_id.Checked.to_input fee_token_r in\n let%map fee_excess_l = Fee.Signed.Checked.to_input fee_excess_l\n and fee_excess_r = Fee.Signed.Checked.to_input fee_excess_r in\n List.reduce_exn ~f:Random_oracle.Input.Chunked.append\n [ fee_token_l; fee_excess_l; fee_token_r; fee_excess_r ]\n\nlet assert_equal_checked (t1 : var) (t2 : var) =\n Checked.all_unit\n [ [%with_label_ \"fee_token_l\"] (fun () ->\n make_checked (fun () ->\n Token_id.Checked.Assert.equal t1.fee_token_l t2.fee_token_l ) )\n ; [%with_label_ \"fee_excess_l\"] (fun () ->\n Fee.Signed.Checked.assert_equal t1.fee_excess_l t2.fee_excess_l )\n ; [%with_label_ \"fee_token_r\"] (fun () ->\n make_checked (fun () ->\n Token_id.Checked.Assert.equal t1.fee_token_r t2.fee_token_r ) )\n ; [%with_label_ \"fee_excess_r\"] (fun () ->\n Fee.Signed.Checked.assert_equal t1.fee_excess_r t2.fee_excess_r )\n ]\n\n[%%endif]\n\n(** Eliminate a fee excess, either by combining it with one to the left/right,\n or by checking that it is zero.\n*)\nlet eliminate_fee_excess (fee_token_l, fee_excess_l) (fee_token_m, fee_excess_m)\n (fee_token_r, fee_excess_r) =\n let add_err x y =\n match Fee.Signed.add x y with\n | Some z ->\n Or_error.return z\n | None ->\n Or_error.errorf \"Error adding fees: overflow.\"\n in\n let open Or_error.Let_syntax in\n if\n Token_id.equal fee_token_l fee_token_m\n || Fee.(equal zero) fee_excess_l.Signed_poly.magnitude\n then\n let%map fee_excess_l = add_err fee_excess_l fee_excess_m in\n ((fee_token_m, fee_excess_l), (fee_token_r, fee_excess_r))\n else if\n Token_id.equal fee_token_r fee_token_m\n || Fee.(equal zero fee_excess_r.Signed_poly.magnitude)\n then\n let%map fee_excess_r = add_err fee_excess_r fee_excess_m in\n ((fee_token_l, fee_excess_l), (fee_token_m, fee_excess_r))\n else if Fee.(equal zero) fee_excess_m.Signed_poly.magnitude then\n return ((fee_token_l, fee_excess_l), (fee_token_r, fee_excess_r))\n else\n Or_error.errorf\n !\"Error eliminating fee excess: Excess for token %{sexp: Token_id.t} \\\n %{sexp: Fee.Signed.t} was nonzero\"\n fee_token_m fee_excess_m\n\n[%%ifdef consensus_mechanism]\n\n(* We use field elements instead of a currency type here, under the following\n assumptions:\n * the additions and subtractions performed upon members of the currency\n type do not overflow the field size\n - The currency type is currently 64-bit, which is much smaller than the\n field size.\n * it is acceptable for the currency type to overflow/underflow, as long as\n a subsequent subtraction/addition brings it back into the range for the\n currency type.\n - These situations will be rejected by the unchecked code that checks\n each addition/subtraction, but this superset of that behaviour seems\n well-defined, and is still 'correct' in the sense that currency is\n preserved.\n\n This optimisation saves serveral hundred constraints in the proof by not\n unpacking the result of each arithmetic operation.\n*)\nlet%snarkydef_ eliminate_fee_excess_checked (fee_token_l, fee_excess_l)\n (fee_token_m, fee_excess_m) (fee_token_r, fee_excess_r) =\n let open Tick in\n let open Checked.Let_syntax in\n let combine (fee_token, fee_excess) fee_excess_m =\n let%bind fee_token_equal =\n make_checked (fun () -> Token_id.Checked.equal fee_token fee_token_m)\n in\n let%bind fee_excess_zero =\n Field.(Checked.equal (Var.constant zero)) fee_excess\n in\n let%bind may_move = Boolean.(fee_token_equal ||| fee_excess_zero) in\n let%bind fee_token =\n make_checked (fun () ->\n Token_id.Checked.if_ fee_excess_zero ~then_:fee_token_m\n ~else_:fee_token )\n in\n let%map fee_excess_to_move =\n Field.Checked.if_ may_move ~then_:fee_excess_m\n ~else_:Field.(Var.constant zero)\n in\n ( (fee_token, Field.Var.add fee_excess fee_excess_to_move)\n , Field.Var.sub fee_excess_m fee_excess_to_move )\n in\n (* NOTE: Below, we may update the tokens on both sides, even though we only\n promote the excess to one of them. This differs from the unchecked\n version, but\n * the token may only be changed if it is associated with 0 fee excess\n * any intermediate 0 fee excesses can always be either combined or erased\n in later eliminations\n * a fee excess of 0 on the left or right will have its token erased to the\n default\n *)\n let%bind (fee_token_l, fee_excess_l), fee_excess_m =\n combine (fee_token_l, fee_excess_l) fee_excess_m\n in\n let%bind (fee_token_r, fee_excess_r), fee_excess_m =\n combine (fee_token_r, fee_excess_r) fee_excess_m\n in\n let%map () =\n [%with_label_ \"Fee excess is eliminated\"]\n Field.(fun () -> Checked.Assert.equal (Var.constant zero) fee_excess_m)\n in\n ((fee_token_l, fee_excess_l), (fee_token_r, fee_excess_r))\n\n[%%endif]\n\n(* 'Rebalance' to a canonical form, where\n - if there is only 1 nonzero excess, it is to the left\n - any zero fee excess has the default token\n - if the fee tokens are the same, the excesses are combined\n*)\nlet rebalance ({ fee_token_l; fee_excess_l; fee_token_r; fee_excess_r } : t) =\n let open Or_error.Let_syntax in\n (* Use the same token for both if [fee_excess_l] is zero. *)\n let fee_token_l =\n if Fee.(equal zero) fee_excess_l.magnitude then fee_token_r else fee_token_l\n in\n (* Rebalancing. *)\n let%map fee_excess_l, fee_excess_r =\n if Token_id.equal fee_token_l fee_token_r then\n match Fee.Signed.add fee_excess_l fee_excess_r with\n | Some fee_excess_l ->\n return (fee_excess_l, Fee.Signed.zero)\n | None ->\n Or_error.errorf !\"Error adding fees: overflow\"\n else return (fee_excess_l, fee_excess_r)\n in\n (* Use the default token if the excess is zero.\n This allows [verify_complete_merge] to verify a proof without knowledge of\n the particular fee tokens used.\n *)\n let fee_token_l =\n if Fee.(equal zero) fee_excess_l.magnitude then Token_id.default\n else fee_token_l\n in\n let fee_token_r =\n if Fee.(equal zero) fee_excess_r.magnitude then Token_id.default\n else fee_token_r\n in\n { fee_token_l; fee_excess_l; fee_token_r; fee_excess_r }\n\n[%%ifdef consensus_mechanism]\n\nlet rebalance_checked { fee_token_l; fee_excess_l; fee_token_r; fee_excess_r } =\n let open Checked.Let_syntax in\n (* Use the same token for both if [fee_excess_l] is zero. *)\n let%bind fee_token_l =\n let%bind excess_is_zero =\n Field.(Checked.equal (Var.constant zero) fee_excess_l)\n in\n make_checked (fun () ->\n Token_id.Checked.if_ excess_is_zero ~then_:fee_token_r\n ~else_:fee_token_l )\n in\n (* Rebalancing. *)\n let%bind fee_excess_l, fee_excess_r =\n let%bind tokens_equal =\n make_checked (fun () -> Token_id.Checked.equal fee_token_l fee_token_r)\n in\n let%map amount_to_move =\n Field.Checked.if_ tokens_equal ~then_:fee_excess_r\n ~else_:Field.(Var.constant zero)\n in\n ( Field.Var.add fee_excess_l amount_to_move\n , Field.Var.sub fee_excess_r amount_to_move )\n in\n (* Use the default token if the excess is zero. *)\n let%bind fee_token_l =\n let%bind excess_is_zero =\n Field.(Checked.equal (Var.constant zero) fee_excess_l)\n in\n make_checked (fun () ->\n Token_id.Checked.if_ excess_is_zero\n ~then_:Token_id.(Checked.constant default)\n ~else_:fee_token_l )\n in\n let%map fee_token_r =\n let%bind excess_is_zero =\n Field.(Checked.equal (Var.constant zero) fee_excess_r)\n in\n make_checked (fun () ->\n Token_id.Checked.if_ excess_is_zero\n ~then_:Token_id.(Checked.constant default)\n ~else_:fee_token_r )\n in\n { fee_token_l; fee_excess_l; fee_token_r; fee_excess_r }\n\n[%%endif]\n\n(** Combine the fee excesses from two transitions. *)\nlet combine\n ({ fee_token_l = fee_token1_l\n ; fee_excess_l = fee_excess1_l\n ; fee_token_r = fee_token1_r\n ; fee_excess_r = fee_excess1_r\n } :\n t )\n ({ fee_token_l = fee_token2_l\n ; fee_excess_l = fee_excess2_l\n ; fee_token_r = fee_token2_r\n ; fee_excess_r = fee_excess2_r\n } :\n t ) : t Or_error.t =\n let open Or_error.Let_syntax in\n (* Eliminate fee_excess1_r. *)\n let%bind (fee_token1_l, fee_excess1_l), (fee_token2_l, fee_excess2_l) =\n (* [1l; 1r; 2l; 2r] -> [1l; 2l; 2r] *)\n eliminate_fee_excess\n (fee_token1_l, fee_excess1_l)\n (fee_token1_r, fee_excess1_r)\n (fee_token2_l, fee_excess2_l)\n in\n (* Eliminate fee_excess2_l. *)\n let%bind (fee_token1_l, fee_excess1_l), (fee_token2_r, fee_excess2_r) =\n (* [1l; 2l; 2r] -> [1l; 2r] *)\n eliminate_fee_excess\n (fee_token1_l, fee_excess1_l)\n (fee_token2_l, fee_excess2_l)\n (fee_token2_r, fee_excess2_r)\n in\n rebalance\n { fee_token_l = fee_token1_l\n ; fee_excess_l = fee_excess1_l\n ; fee_token_r = fee_token2_r\n ; fee_excess_r = fee_excess2_r\n }\n\n[%%ifdef consensus_mechanism]\n\nlet%snarkydef_ combine_checked\n { fee_token_l = fee_token1_l\n ; fee_excess_l = fee_excess1_l\n ; fee_token_r = fee_token1_r\n ; fee_excess_r = fee_excess1_r\n }\n { fee_token_l = fee_token2_l\n ; fee_excess_l = fee_excess2_l\n ; fee_token_r = fee_token2_r\n ; fee_excess_r = fee_excess2_r\n } =\n let open Checked.Let_syntax in\n (* Represent amounts as field elements. *)\n let%bind fee_excess1_l = Fee.Signed.Checked.to_field_var fee_excess1_l in\n let%bind fee_excess1_r = Fee.Signed.Checked.to_field_var fee_excess1_r in\n let%bind fee_excess2_l = Fee.Signed.Checked.to_field_var fee_excess2_l in\n let%bind fee_excess2_r = Fee.Signed.Checked.to_field_var fee_excess2_r in\n (* Eliminations. *)\n let%bind (fee_token1_l, fee_excess1_l), (fee_token2_l, fee_excess2_l) =\n (* [1l; 1r; 2l; 2r] -> [1l; 2l; 2r] *)\n [%with_label_ \"Eliminate fee_excess1_r\"] (fun () ->\n eliminate_fee_excess_checked\n (fee_token1_l, fee_excess1_l)\n (fee_token1_r, fee_excess1_r)\n (fee_token2_l, fee_excess2_l) )\n in\n let%bind (fee_token1_l, fee_excess1_l), (fee_token2_r, fee_excess2_r) =\n (* [1l; 2l; 2r] -> [1l; 2r] *)\n [%with_label_ \"Eliminate fee_excess2_l\"] (fun () ->\n eliminate_fee_excess_checked\n (fee_token1_l, fee_excess1_l)\n (fee_token2_l, fee_excess2_l)\n (fee_token2_r, fee_excess2_r) )\n in\n let%bind { fee_token_l; fee_excess_l; fee_token_r; fee_excess_r } =\n rebalance_checked\n { fee_token_l = fee_token1_l\n ; fee_excess_l = fee_excess1_l\n ; fee_token_r = fee_token2_r\n ; fee_excess_r = fee_excess2_r\n }\n in\n let convert_to_currency excess =\n let%bind currency_excess =\n exists Fee.Signed.typ\n ~compute:\n As_prover.(\n let%map excess = read Field.typ excess in\n let is_neg =\n Bigint.test_bit (Bigint.of_field excess) (Field.size_in_bits - 1)\n in\n let sgn = if is_neg then Sgn.Neg else Sgn.Pos in\n let excess =\n if is_neg then Field.(mul (negate one) excess) else excess\n in\n let magnitude =\n (* TODO: Add a native coercion [Bigint -> UInt64] in Snarky's FFI\n bindings, use it here.\n *)\n let n = Bigint.of_field excess in\n let total = ref Unsigned_extended.UInt64.zero in\n for i = 0 to Unsigned_extended.UInt64.length_in_bits - 1 do\n if Bigint.test_bit n i then\n total :=\n Unsigned_extended.UInt64.(add !total (shift_left one i))\n done ;\n Fee.of_uint64 !total\n in\n Fee.Signed.create ~magnitude ~sgn)\n in\n let%bind excess_from_currency =\n Fee.Signed.Checked.to_field_var currency_excess\n in\n let%map () =\n [%with_label_ \"Fee excess does not overflow\"] (fun () ->\n Field.Checked.Assert.equal excess excess_from_currency )\n in\n currency_excess\n in\n (* Convert to currency. *)\n let%bind fee_excess_l =\n [%with_label_ \"Check for overflow in fee_excess_l\"] (fun () ->\n convert_to_currency fee_excess_l )\n in\n let%map fee_excess_r =\n [%with_label_ \"Check for overflow in fee_excess_r\"] (fun () ->\n convert_to_currency fee_excess_r )\n in\n { fee_token_l; fee_excess_l; fee_token_r; fee_excess_r }\n\n[%%endif]\n\nlet empty =\n { fee_token_l = Token_id.default\n ; fee_excess_l = Fee.Signed.zero\n ; fee_token_r = Token_id.default\n ; fee_excess_r = Fee.Signed.zero\n }\n\nlet is_empty { fee_token_l; fee_excess_l; fee_token_r; fee_excess_r } =\n Fee.Signed.(equal zero) fee_excess_l\n && Fee.Signed.(equal zero) fee_excess_r\n && Token_id.(equal default) fee_token_l\n && Token_id.(equal default) fee_token_r\n\nlet zero = empty\n\nlet is_zero = is_empty\n\nlet of_single (fee_token_l, fee_excess_l) =\n (* This is safe, we know that we will not hit overflow above. *)\n Or_error.ok_exn\n @@ rebalance\n { fee_token_l\n ; fee_excess_l\n ; fee_token_r = Token_id.default\n ; fee_excess_r = Fee.Signed.zero\n }\n\nlet of_one_or_two excesses =\n let unreduced =\n match excesses with\n | `One (fee_token_l, fee_excess_l) ->\n { fee_token_l\n ; fee_excess_l\n ; fee_token_r = Token_id.default\n ; fee_excess_r = Fee.Signed.zero\n }\n | `Two ((fee_token_l, fee_excess_l), (fee_token_r, fee_excess_r)) ->\n { fee_token_l; fee_excess_l; fee_token_r; fee_excess_r }\n in\n rebalance unreduced\n\nlet to_one_or_two ({ fee_token_l; fee_excess_l; fee_token_r; fee_excess_r } : t)\n =\n if Fee.(equal zero) fee_excess_r.magnitude then\n `One (fee_token_l, fee_excess_l)\n else `Two ((fee_token_l, fee_excess_l), (fee_token_r, fee_excess_r))\n\n[%%ifdef consensus_mechanism]\n\nlet gen_single ?(token_id = Token_id.gen) ?(excess = Fee.Signed.gen) () :\n (Token_id.t * Fee.Signed.t) Quickcheck.Generator.t =\n Quickcheck.Generator.tuple2 token_id excess\n\nlet gen : t Quickcheck.Generator.t =\n let open Quickcheck.Generator.Let_syntax in\n let%map excesses = One_or_two.gen @@ gen_single () in\n match of_one_or_two excesses with\n | Ok ret ->\n ret\n | Error _ -> (\n (* There is an overflow, just choose the first excess. *)\n match excesses with\n | `One (fee_token_l, fee_excess_l) | `Two ((fee_token_l, fee_excess_l), _)\n ->\n { fee_token_l\n ; fee_excess_l\n ; fee_token_r = Token_id.default\n ; fee_excess_r = Fee.Signed.zero\n } )\n\n[%%endif]\n","open Core_kernel\nopen Snark_params.Tick\n\nmodule type S = sig\n include Data_hash.Full_size\n\n [%%versioned:\n module Stable : sig\n [@@@no_toplevel_latest_type]\n\n module V1 : sig\n type t = Field.t [@@deriving sexp, compare, hash, yojson]\n\n val to_latest : t -> t\n\n include Comparable.S with type t := t\n\n include Hashable_binable with type t := t\n end\n end]\nend\n","include Ledger_hash0\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Snark_params.Tick\n\nmodule type S = sig\n exception Too_long_user_memo_input\n\n exception Too_long_digestible_string\n\n type t [@@deriving sexp, equal, compare, hash, yojson]\n\n module Stable : sig\n module V1 : sig\n type nonrec t = t\n [@@deriving bin_io, sexp, equal, compare, hash, yojson, version]\n\n module With_all_version_tags : Bin_prot.Binable.S with type t = t\n end\n\n module Latest = V1\n end\n\n [%%ifdef consensus_mechanism]\n\n module Checked : sig\n type unchecked = t\n\n type t = private Boolean.var array\n\n val constant : unchecked -> t\n end\n\n (** typ representation *)\n val typ : (Checked.t, t) Typ.t\n\n [%%endif]\n\n val dummy : t\n\n val empty : t\n\n val to_base58_check : t -> string\n\n val of_base58_check : string -> t Or_error.t\n\n val of_base58_check_exn : string -> t\n\n (** for a memo of bytes, return a plaintext string\n for a memo of a digest, return a hex-encoded string, prefixed by '0x'\n *)\n val to_string_hum : t -> string\n\n (** is the memo a digest *)\n val is_digest : t -> bool\n\n (** is the memo well-formed *)\n val is_valid : t -> bool\n\n (** bound on length of strings to digest *)\n val max_digestible_string_length : int\n\n (** bound on length of strings or bytes in memo *)\n val max_input_length : int\n\n (** create a memo by digesting a string; raises [Too_long_digestible_string] if\n length exceeds [max_digestible_string_length]\n *)\n val create_by_digesting_string_exn : string -> t\n\n (** create a memo by digesting a string; returns error if\n length exceeds [max_digestible_string_length]\n *)\n val create_by_digesting_string : string -> t Or_error.t\n\n (** create a memo from bytes of length up to max_input_length;\n raise [Too_long_user_memo_input] if length is greater\n *)\n val create_from_bytes_exn : bytes -> t\n\n (** create a memo from bytes of length up to max_input_length; returns\n error is length is greater\n *)\n val create_from_bytes : bytes -> t Or_error.t\n\n (** create a memo from a string of length up to max_input_length;\n raise [Too_long_user_memo_input] if length is greater\n *)\n val create_from_string_exn : string -> t\n\n (** create a memo from a string of length up to max_input_length;\n returns error if length is greater\n *)\n val create_from_string : string -> t Or_error.t\n\n (** convert a memo to a list of bools\n *)\n val to_bits : t -> bool list\n\n (** Quickcheck generator for memos. *)\n val gen : t Quickcheck.Generator.t\n\n (** Compute a standalone hash of the current memo. *)\n val hash : t -> Field.t\n\n (* This type definition was generated by hovering over `deriver` in signed_command_memo.ml and copying the type *)\n val deriver :\n (< contramap : (t -> Yojson.Safe.t) ref\n ; graphql_arg :\n (unit -> Yojson.Safe.t Fields_derivers_graphql.Schema.Arg.arg_typ)\n ref\n ; graphql_fields :\n Yojson.Safe.t Fields_derivers_zkapps.Graphql.Fields.Input.T.t ref\n ; graphql_query : string option ref\n ; graphql_query_accumulator : (string * string option) list ref\n ; map : (Yojson.Safe.t -> t) ref\n ; nullable_graphql_arg :\n ( unit\n -> Yojson.Safe.t option Fields_derivers_graphql.Schema.Arg.arg_typ\n )\n ref\n ; nullable_graphql_fields :\n Yojson.Safe.t option Fields_derivers_zkapps.Graphql.Fields.Input.T.t\n ref\n ; of_json : (Yojson.Safe.t -> Yojson.Safe.t) ref\n ; to_json : (Yojson.Safe.t -> Yojson.Safe.t) ref\n ; js_layout : Yojson.Safe.t ref\n ; .. >\n as\n 'a )\n Fields_derivers_zkapps.Unified_input.t\n Fields_derivers_zkapps.Unified_input.t\n Fields_derivers_zkapps.Unified_input.t\n -> 'a Fields_derivers_zkapps.Unified_input.t\n\n type raw =\n | Digest of string (** The digest of the string, encoded by base58-check *)\n | Bytes of string (** A string containing the raw bytes in the memo. *)\n\n (** Convert into a raw representation.\n\n Raises if the tag or length are invalid.\n *)\n val to_raw_exn : t -> raw\n\n (** Convert back into the raw input bytes.\n\n Raises if the tag or length are invalid, or if the memo was a digest.\n Equivalent to [to_raw_exn] and then a match on [Bytes].\n *)\n val to_raw_bytes_exn : t -> string\n\n (** Convert from a raw representation.\n\n Raises if the digest is not a valid base58-check string, or if the bytes\n string is too long.\n *)\n val of_raw_exn : raw -> t\nend\n","(* transaction_union_payload.ml *)\n\n[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Currency\n\n[%%ifdef consensus_mechanism]\n\nopen Snark_params.Tick\n\n[%%endif]\n\nopen Signature_lib\nmodule Tag = Transaction_union_tag\n\nmodule Body = struct\n type ('tag, 'public_key, 'token_id, 'amount, 'bool) t_ =\n { tag : 'tag\n ; source_pk : 'public_key\n ; receiver_pk : 'public_key\n ; token_id : 'token_id\n ; amount : 'amount\n }\n [@@deriving sexp, hlist]\n\n type t =\n (Tag.t, Public_key.Compressed.t, Token_id.t, Currency.Amount.t, bool) t_\n [@@deriving sexp]\n\n let of_user_command_payload_body ~fee_payer_pk = function\n | Signed_command_payload.Body.Payment { receiver_pk; amount } ->\n { tag = Tag.Payment\n ; source_pk = fee_payer_pk\n ; receiver_pk\n ; token_id = Token_id.default\n ; amount\n }\n | Stake_delegation (Set_delegate { new_delegate }) ->\n { tag = Tag.Stake_delegation\n ; source_pk = fee_payer_pk\n ; receiver_pk = new_delegate\n ; token_id = Token_id.default\n ; amount = Currency.Amount.zero\n }\n\n let gen ~fee =\n let open Quickcheck.Generator.Let_syntax in\n let%bind tag = Tag.gen in\n let%map amount =\n let min, max =\n let max_amount_without_overflow =\n Amount.(sub max_int (of_fee fee))\n |> Option.value_exn ?here:None ?message:None ?error:None\n in\n match tag with\n | Payment ->\n (Amount.zero, max_amount_without_overflow)\n | Stake_delegation ->\n (Amount.zero, Amount.zero)\n | Fee_transfer ->\n (Amount.zero, max_amount_without_overflow)\n | Coinbase ->\n (* In this case,\n amount - fee should be defined. In other words,\n amount >= fee *)\n (Amount.of_fee fee, Amount.max_int)\n in\n Amount.gen_incl min max\n and source_pk = Public_key.Compressed.gen\n and receiver_pk = Public_key.Compressed.gen\n and token_id =\n match tag with\n | Payment ->\n Token_id.gen\n | Stake_delegation ->\n return Token_id.default\n | Fee_transfer ->\n return Token_id.default\n | Coinbase ->\n return Token_id.default\n in\n { tag; source_pk; receiver_pk; token_id; amount }\n\n [%%ifdef consensus_mechanism]\n\n type var =\n ( Tag.Unpacked.var\n , Public_key.Compressed.var\n , Token_id.Checked.t\n , Currency.Amount.var\n , Boolean.var )\n t_\n\n let typ =\n Typ.of_hlistable\n [ Tag.unpacked_typ\n ; Public_key.Compressed.typ\n ; Public_key.Compressed.typ\n ; Token_id.typ\n ; Currency.Amount.typ\n ]\n ~var_to_hlist:t__to_hlist ~value_to_hlist:t__to_hlist\n ~var_of_hlist:t__of_hlist ~value_of_hlist:t__of_hlist\n\n module Checked = struct\n let constant ({ tag; source_pk; receiver_pk; token_id; amount } : t) : var =\n { tag = Tag.unpacked_of_t tag\n ; source_pk = Public_key.Compressed.var_of_t source_pk\n ; receiver_pk = Public_key.Compressed.var_of_t receiver_pk\n ; token_id = Token_id.Checked.constant token_id\n ; amount = Currency.Amount.var_of_t amount\n }\n\n let to_input_legacy { tag; source_pk; receiver_pk; token_id; amount } =\n let%map amount = Currency.Amount.var_to_input_legacy amount\n and () =\n make_checked (fun () ->\n Token_id.Checked.Assert.equal token_id\n (Token_id.Checked.constant Token_id.default) )\n in\n let token_id = Signed_command_payload.Legacy_token_id.default_checked in\n Array.reduce_exn ~f:Random_oracle.Input.Legacy.append\n [| Tag.Unpacked.to_input_legacy tag\n ; Public_key.Compressed.Checked.to_input_legacy source_pk\n ; Public_key.Compressed.Checked.to_input_legacy receiver_pk\n ; token_id\n ; amount\n ; Random_oracle.Input.Legacy.bitstring [ Boolean.false_ ]\n |]\n end\n\n [%%endif]\n\n let to_input_legacy { tag; source_pk; receiver_pk; token_id; amount } =\n assert (Token_id.equal token_id Token_id.default) ;\n Array.reduce_exn ~f:Random_oracle.Input.Legacy.append\n [| Tag.to_input_legacy tag\n ; Public_key.Compressed.to_input_legacy source_pk\n ; Public_key.Compressed.to_input_legacy receiver_pk\n ; Signed_command_payload.Legacy_token_id.default\n ; Currency.Amount.to_input_legacy amount\n ; Random_oracle.Input.Legacy.bitstring [ false ]\n |]\nend\n\nmodule Payload_common = struct\n module Poly = struct\n type ('fee, 'public_key, 'token_id, 'nonce, 'global_slot, 'memo) t =\n { fee : 'fee\n ; fee_token : 'token_id\n ; fee_payer_pk : 'public_key\n ; nonce : 'nonce\n ; valid_until : 'global_slot\n ; memo : 'memo\n }\n [@@deriving sexp, hlist]\n end\n\n let to_signed_command_payload_common\n { Poly.fee; fee_payer_pk; nonce; valid_until; memo; fee_token = _ } =\n { Signed_command_payload.Common.Poly.fee\n ; fee_payer_pk\n ; nonce\n ; valid_until\n ; memo\n }\n\n type t =\n ( Currency.Fee.t\n , Public_key.Compressed.t\n , Token_id.t\n , Mina_numbers.Account_nonce.t\n , Mina_numbers.Global_slot_since_genesis.t\n , Signed_command_memo.t )\n Poly.t\n [@@deriving sexp]\n\n [%%ifdef consensus_mechanism]\n\n module Checked = struct\n type value = t\n\n type t =\n ( Currency.Fee.Checked.t\n , Public_key.Compressed.var\n , Token_id.Checked.t\n , Mina_numbers.Account_nonce.Checked.t\n , Mina_numbers.Global_slot_since_genesis.Checked.t\n , Signed_command_memo.Checked.t )\n Poly.t\n\n let constant\n ({ fee; fee_payer_pk; nonce; valid_until; memo; fee_token } : value) : t\n =\n { fee = Currency.Fee.var_of_t fee\n ; fee_payer_pk = Public_key.Compressed.var_of_t fee_payer_pk\n ; fee_token = Token_id.Checked.constant fee_token\n ; nonce = Mina_numbers.Account_nonce.Checked.constant nonce\n ; memo = Signed_command_memo.Checked.constant memo\n ; valid_until =\n Mina_numbers.Global_slot_since_genesis.Checked.constant valid_until\n }\n end\n\n let typ : (Checked.t, t) Typ.t =\n let open Poly in\n Typ.of_hlistable\n [ Currency.Fee.typ\n ; Token_id.typ\n ; Public_key.Compressed.typ\n ; Mina_numbers.Account_nonce.typ\n ; Mina_numbers.Global_slot_since_genesis.typ\n ; Signed_command_memo.typ\n ]\n ~var_to_hlist:to_hlist ~value_to_hlist:to_hlist ~var_of_hlist:of_hlist\n ~value_of_hlist:of_hlist\n\n [%%endif]\nend\n\ntype t = (Payload_common.t, Body.t) Signed_command_payload.Poly.t\n[@@deriving sexp]\n\ntype payload = t [@@deriving sexp]\n\nlet of_user_command_payload\n ({ common = { memo; fee; fee_payer_pk; nonce; valid_until }; body } :\n Signed_command_payload.t ) : t =\n { common =\n { fee\n ; fee_token = Token_id.default\n ; fee_payer_pk\n ; nonce\n ; valid_until\n ; memo\n }\n ; body = Body.of_user_command_payload_body ~fee_payer_pk body\n }\n\nlet gen =\n let open Quickcheck.Generator.Let_syntax in\n let%bind common = Signed_command_payload.Common.gen in\n let%map body = Body.gen ~fee:common.fee in\n Signed_command_payload.Poly.{ common; body }\n\n[%%ifdef consensus_mechanism]\n\ntype var = (Payload_common.Checked.t, Body.var) Signed_command_payload.Poly.t\n\ntype payload_var = var\n\nlet typ : (var, t) Typ.t =\n let to_hlist = Signed_command_payload.Poly.to_hlist in\n let of_hlist = Signed_command_payload.Poly.of_hlist in\n Typ.of_hlistable\n [ Payload_common.typ; Body.typ ]\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist\n\nlet payload_typ = typ\n\nmodule Checked = struct\n let to_input_legacy ({ common; body } : var) =\n let%map common =\n Signed_command_payload.Common.Checked.to_input_legacy\n (Payload_common.to_signed_command_payload_common common)\n and body = Body.Checked.to_input_legacy body in\n Random_oracle.Input.Legacy.append common body\n\n let constant ({ common; body } : t) : var =\n { common = Payload_common.Checked.constant common\n ; body = Body.Checked.constant body\n }\nend\n\n[%%endif]\n\nlet to_input_legacy ({ common; body } : t) =\n Random_oracle.Input.Legacy.append\n (Signed_command_payload.Common.to_input_legacy\n (Payload_common.to_signed_command_payload_common common) )\n (Body.to_input_legacy body)\n\nlet excess (payload : t) : Amount.Signed.t =\n let tag = payload.body.tag in\n let fee = payload.common.fee in\n let amount = payload.body.amount in\n match tag with\n | Payment | Stake_delegation ->\n (* For all user commands, the fee excess is just the fee. *)\n Amount.Signed.of_unsigned (Amount.of_fee fee)\n | Fee_transfer ->\n Option.value_exn (Amount.add_fee amount fee)\n |> Amount.Signed.of_unsigned |> Amount.Signed.negate\n | Coinbase ->\n Amount.Signed.zero\n\nlet fee_excess ({ body = { tag; amount; _ }; common = { fee; _ } } : t) =\n match tag with\n | Payment | Stake_delegation ->\n (* For all user commands, the fee excess is just the fee. *)\n Fee_excess.of_single (Token_id.default, Fee.Signed.of_unsigned fee)\n | Fee_transfer ->\n let excess =\n Option.value_exn (Amount.add_fee amount fee)\n |> Amount.to_fee |> Fee.Signed.of_unsigned |> Fee.Signed.negate\n in\n Fee_excess.of_single (Token_id.default, excess)\n | Coinbase ->\n Fee_excess.of_single (Token_id.default, Fee.Signed.zero)\n\nlet expected_supply_increase (payload : payload) =\n let tag = payload.body.tag in\n match tag with\n | Coinbase ->\n payload.body.amount\n | Payment | Stake_delegation | Fee_transfer ->\n Amount.zero\n","(* user_command_intf.ml *)\n\n[%%import \"/src/config.mlh\"]\n\nopen Mina_base_import\nopen Core_kernel\nopen Snark_params.Tick\nopen Mina_numbers\n\nmodule type Gen_intf = sig\n type t\n\n module Gen : sig\n (** Generate a single transaction between\n * Generate random keys for sender and receiver\n * for fee $\\in [Currency.Fee.minimum_user_command_fee,\n * Currency.Fee.minimum_user_command_fee+fee_range]$\n * and an amount $\\in [1,max_amount]$\n *)\n val payment :\n ?sign_type:[ `Fake | `Real ]\n -> key_gen:\n (Signature_keypair.t * Signature_keypair.t) Quickcheck.Generator.t\n -> ?nonce:Account_nonce.t\n -> ?min_amount:int\n -> max_amount:int\n -> fee_range:int\n -> unit\n -> t Quickcheck.Generator.t\n\n (** Generate a single transaction between\n * $a, b \\in keys$\n * for fee $\\in [Currency.Fee.minimum_user_command_fee,\n * Currency.Fee.minimum_user_command_fee+fee_range]$\n * and an amount $\\in [1,max_amount]$\n *)\n val payment_with_random_participants :\n ?sign_type:[ `Fake | `Real ]\n -> keys:Signature_keypair.t array\n -> ?nonce:Account_nonce.t\n -> ?min_amount:int\n -> max_amount:int\n -> fee_range:int\n -> unit\n -> t Quickcheck.Generator.t\n\n val stake_delegation :\n key_gen:\n (Signature_keypair.t * Signature_keypair.t) Quickcheck.Generator.t\n -> ?nonce:Account_nonce.t\n -> fee_range:int\n -> unit\n -> t Quickcheck.Generator.t\n\n val stake_delegation_with_random_participants :\n keys:Signature_keypair.t array\n -> ?nonce:Account_nonce.t\n -> fee_range:int\n -> unit\n -> t Quickcheck.Generator.t\n\n (** Generate a valid sequence of payments based on the initial state of a\n ledger. Use this together with Ledger.gen_initial_ledger_state.\n *)\n val sequence :\n ?length:int\n -> ?sign_type:[ `Fake | `Real ]\n -> ( Signature_lib.Keypair.t\n * Currency.Amount.t\n * Mina_numbers.Account_nonce.t\n * Account_timing.t )\n array\n -> t list Quickcheck.Generator.t\n end\nend\n\nmodule type S = sig\n type t [@@deriving sexp, yojson, hash]\n\n (* type of signed commands, pre-Berkeley hard fork *)\n type t_v1\n\n include Comparable.S with type t := t\n\n include Hashable.S with type t := t\n\n val payload : t -> Signed_command_payload.t\n\n val fee : t -> Currency.Fee.t\n\n val nonce : t -> Account_nonce.t\n\n val signer : t -> Public_key.t\n\n val fee_token : t -> Token_id.t\n\n val fee_payer_pk : t -> Public_key.Compressed.t\n\n val fee_payer : t -> Account_id.t\n\n val fee_excess : t -> Fee_excess.t\n\n val token : t -> Token_id.t\n\n val receiver_pk : t -> Public_key.Compressed.t\n\n val receiver : t -> Account_id.t\n\n val public_keys : t -> Public_key.Compressed.t list\n\n val amount : t -> Currency.Amount.t option\n\n val memo : t -> Signed_command_memo.t\n\n val valid_until : t -> Global_slot_since_genesis.t\n\n (* for filtering *)\n val minimum_fee : Currency.Fee.t\n\n val has_insufficient_fee : t -> bool\n\n val tag : t -> Transaction_union_tag.t\n\n val tag_string : t -> string\n\n val to_input_legacy :\n Signed_command_payload.t -> (Field.t, bool) Random_oracle_input.Legacy.t\n\n include Gen_intf with type t := t\n\n module With_valid_signature : sig\n module Stable : sig\n module Latest : sig\n type nonrec t\n [@@deriving sexp, equal, bin_io, yojson, version, compare, hash]\n\n include Gen_intf with type t := t\n end\n\n module V2 = Latest\n end\n\n type t = Stable.Latest.t [@@deriving sexp, yojson, compare, hash]\n\n include Gen_intf with type t := t\n\n include Comparable.S with type t := t\n end\n\n val sign_payload :\n ?signature_kind:Mina_signature_kind.t\n -> Signature_lib.Private_key.t\n -> Signed_command_payload.t\n -> Signature.t\n\n val sign :\n ?signature_kind:Mina_signature_kind.t\n -> Signature_keypair.t\n -> Signed_command_payload.t\n -> With_valid_signature.t\n\n val check_signature : ?signature_kind:Mina_signature_kind.t -> t -> bool\n\n val create_with_signature_checked :\n ?signature_kind:Mina_signature_kind.t\n -> Signature.t\n -> Public_key.Compressed.t\n -> Signed_command_payload.t\n -> With_valid_signature.t option\n\n val check_valid_keys : t -> bool\n\n module For_tests : sig\n (** the signature kind is an argument, to match `sign`, but ignored *)\n val fake_sign :\n ?signature_kind:Mina_signature_kind.t\n -> Signature_keypair.t\n -> Signed_command_payload.t\n -> With_valid_signature.t\n end\n\n (** checks signature and keys *)\n val check : t -> With_valid_signature.t option\n\n val check_only_for_signature : t -> With_valid_signature.t option\n\n val to_valid_unsafe :\n t\n -> [ `If_this_is_used_it_should_have_a_comment_justifying_it of\n With_valid_signature.t ]\n\n (** Forget the signature check. *)\n val forget_check : With_valid_signature.t -> t\n\n (** returned status always `Accessed for fee payer *)\n val account_access_statuses :\n t\n -> Transaction_status.t\n -> (Account_id.t * [ `Accessed | `Not_accessed ]) list\n\n (** all account ids mentioned in a command *)\n val accounts_referenced : t -> Account_id.t list\n\n val filter_by_participant : t list -> Public_key.Compressed.t -> t list\n\n val of_base58_check_exn_v1 : string -> t_v1 Or_error.t\n\n val to_base58_check_v1 : t_v1 -> string\n\n include Codable.Base64_intf with type t := t\nend\n\nmodule type Full = sig\n module Payload = Signed_command_payload\n\n module Poly : sig\n [%%versioned:\n module Stable : sig\n module V1 : sig\n type ('payload, 'pk, 'signature) t =\n ( 'payload\n , 'pk\n , 'signature )\n Mina_wire_types.Mina_base.Signed_command.Poly.V1.t =\n { payload : 'payload; signer : 'pk; signature : 'signature }\n [@@deriving sexp, hash, yojson, equal, compare]\n end\n end]\n end\n\n [%%versioned:\n module Stable : sig\n [@@@with_top_version_tag]\n\n module V2 : sig\n type t =\n ( Payload.Stable.V2.t\n , Public_key.Stable.V1.t\n , Signature.Stable.V1.t )\n Poly.Stable.V1.t\n [@@deriving sexp, hash, yojson, version]\n\n include Comparable.S with type t := t\n\n include Hashable.S with type t := t\n\n val account_access_statuses :\n t\n -> Transaction_status.t\n -> (Account_id.t * [ `Accessed | `Not_accessed ]) list\n\n val accounts_referenced : t -> Account_id.t list\n end\n\n module V1 : sig\n type t =\n ( Payload.Stable.V1.t\n , Public_key.Stable.V1.t\n , Signature.Stable.V1.t )\n Poly.Stable.V1.t\n [@@deriving compare, sexp, hash, yojson]\n\n val to_latest : t -> Latest.t\n end\n end]\n\n include S with type t = Stable.V2.t and type t_v1 = Stable.V1.t\nend\n","[%%import \"/src/config.mlh\"]\n\n[%%ifdef consensus_mechanism]\n\ninclude Pickles.Side_loaded.Verification_key\n\n[%%else]\n\nopen Core_kernel\n\nmodule G = struct\n open Snark_params.Tick\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Field.Stable.V1.t * Field.Stable.V1.t\n [@@deriving sexp, equal, compare, hash, yojson]\n\n let to_latest = Fn.id\n end\n end]\nend\n\nmodule R = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t =\n G.Stable.V1.t Pickles_base.Side_loaded_verification_key.Repr.Stable.V2.t\n [@@deriving sexp, compare, equal, yojson]\n\n let to_latest = Fn.id\n end\n end]\nend\n\n[%%versioned_binable\nmodule Stable = struct\n module V2 = struct\n type t =\n ( G.Stable.V1.t\n , unit )\n Pickles_base.Side_loaded_verification_key.Poly.Stable.V2.t\n [@@deriving hash]\n\n open Pickles_base.Side_loaded_verification_key\n\n let to_latest = Fn.id\n\n let to_repr { Poly.step_data; max_width; wrap_index; wrap_vk = _ } =\n { Repr.Stable.V2.step_data; max_width; wrap_index }\n\n let of_repr { Repr.Stable.V2.step_data; max_width; wrap_index = c } =\n { Poly.step_data; max_width; wrap_index = c; wrap_vk = Some () }\n\n include\n Binable.Of_binable\n (R.Stable.V2)\n (struct\n type nonrec t = t\n\n let to_binable = to_repr\n\n let of_binable = of_repr\n end)\n\n let sexp_of_t t = R.sexp_of_t (to_repr t)\n\n let t_of_sexp sexp = of_repr (R.t_of_sexp sexp)\n\n let to_yojson t = R.to_yojson (to_repr t)\n\n let of_yojson json = Result.map ~f:of_repr (R.of_yojson json)\n\n let equal x y = R.equal (to_repr x) (to_repr y)\n\n let compare x y = R.compare (to_repr x) (to_repr y)\n end\nend]\n\nlet to_input x =\n Pickles_base.Side_loaded_verification_key.to_input\n ~field_of_int:Snark_params.Tick.Field.of_int x\n\nlet dummy : t =\n let open Pickles_types in\n { step_data = At_most.[]\n ; max_width = Pickles_base.Side_loaded_verification_key.Width.zero\n ; wrap_index =\n (let g = Snarkette.Pasta.Pallas.(to_affine_exn one) in\n { sigma_comm = Vector.init Dlog_plonk_types.Permuts.n ~f:(fun _ -> g)\n ; coefficients_comm =\n Vector.init Dlog_plonk_types.Columns.n ~f:(fun _ -> g)\n ; generic_comm = g\n ; psm_comm = g\n ; complete_add_comm = g\n ; mul_comm = g\n ; emul_comm = g\n ; endomul_scalar_comm = g\n } )\n ; wrap_vk = None\n }\n\n[%%endif]\n","(* state_hash.ml *)\nopen Core_kernel\nmodule T = Data_hash_lib.State_hash\ninclude T\n\nmodule State_hashes = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t =\n { mutable state_body_hash : State_body_hash.Stable.V1.t option\n ; state_hash : T.Stable.V1.t\n }\n [@@deriving equal, sexp, to_yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n let state_hash { state_hash; _ } = state_hash\n\n let state_body_hash t ~compute_hashes =\n match t.state_body_hash with\n | Some state_body_hash ->\n state_body_hash\n | None ->\n let { state_hash; state_body_hash } = compute_hashes () in\n assert (T.equal state_hash t.state_hash) ;\n assert (Option.is_some state_body_hash) ;\n t.state_body_hash <- state_body_hash ;\n Option.value_exn state_body_hash\nend\n\nmodule With_state_hashes = struct\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n type 'a t = ('a, State_hashes.Stable.V1.t) With_hash.Stable.V1.t\n [@@deriving equal, sexp, to_yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n type 'a t = ('a, State_hashes.t) With_hash.t\n [@@deriving equal, sexp, to_yojson]\n\n open With_hash\n open State_hashes.Stable.Latest\n\n let data { data; _ } = data\n\n let hashes { hash = hashes; _ } = hashes\n\n let state_hash { hash = { state_hash; _ }; _ } = state_hash\n\n let state_body_hash { hash; data } ~compute_hashes =\n State_hashes.state_body_hash hash ~compute_hashes:(fun () ->\n compute_hashes data )\nend\n","(* verification_key_wire.ml *)\n\nopen Core_kernel\nopen Zkapp_basic\n\n(* the digest functions are declared locally in Zkapp_account, which depends on\n this module; the definitions here avoid a cyclic dependency\n*)\n\nlet digest_vk (t : Side_loaded_verification_key.t) =\n Random_oracle.(\n hash ~init:Hash_prefix_states.side_loaded_vk\n (pack_input (Side_loaded_verification_key.to_input t)))\n\nlet dummy_vk_hash =\n Memo.unit (fun () -> digest_vk Side_loaded_verification_key.dummy)\n\n[%%versioned_binable\nmodule Stable = struct\n module V1 = struct\n module T = struct\n type t = (Side_loaded_verification_key.t, F.t) With_hash.t\n [@@deriving sexp, yojson, equal, compare, hash]\n end\n\n include T\n\n let to_latest = Fn.id\n\n module M = struct\n type nonrec t = t\n\n (* don't send hash over the wire; restore hash on receipt *)\n\n let to_binable (t : t) = t.data\n\n let of_binable vk : t =\n let data = vk in\n let hash = digest_vk vk in\n { data; hash }\n end\n\n include\n Binable.Of_binable_without_uuid\n (Side_loaded_verification_key.Stable.V2)\n (M)\n end\nend]\n","open Core_kernel\nopen Mina_base_import\nopen Snark_params\nopen Snarky_backendless\nopen Tick\nopen Let_syntax\n\nlet merge_var ~height h1 h2 =\n Random_oracle.Checked.hash ~init:(Hash_prefix.merkle_tree height) [| h1; h2 |]\n\nmodule Merkle_tree =\n Snarky_backendless.Merkle_tree.Checked\n (Tick)\n (struct\n type value = Field.t\n\n type var = Field.Var.t\n\n let typ = Field.typ\n\n let merge ~height h1 h2 =\n Tick.make_checked (fun () -> merge_var ~height h1 h2)\n\n let assert_equal h1 h2 = Field.Checked.Assert.equal h1 h2\n\n let if_ = Field.Checked.if_\n end)\n (struct\n include Account\n\n let hash = Checked.digest\n end)\n\ninclude Ledger_hash0\n\n(* End boilerplate *)\nlet merge ~height (h1 : t) (h2 : t) =\n Random_oracle.hash\n ~init:(Hash_prefix.merkle_tree height)\n [| (h1 :> field); (h2 :> field) |]\n |> of_hash\n\nlet empty_hash = of_hash Outside_hash_image.t\n\nlet%bench \"Ledger_hash.merge ~height:1 empty_hash empty_hash\" =\n merge ~height:1 empty_hash empty_hash\n\nlet of_digest = Fn.compose Fn.id of_hash\n\ntype path = Random_oracle.Digest.t list\n\ntype _ Request.t +=\n | Get_path : Account.Index.t -> path Request.t\n | Get_element : Account.Index.t -> (Account.t * path) Request.t\n | Set : Account.Index.t * Account.t -> unit Request.t\n | Find_index : Account_id.t -> Account.Index.t Request.t\n\nlet reraise_merkle_requests (With { request; respond }) =\n match request with\n | Merkle_tree.Get_path addr ->\n respond (Delegate (Get_path addr))\n | Merkle_tree.Set (addr, account) ->\n respond (Delegate (Set (addr, account)))\n | Merkle_tree.Get_element addr ->\n respond (Delegate (Get_element addr))\n | _ ->\n unhandled\n\nlet get ~depth t addr =\n handle\n (fun () -> Merkle_tree.get_req ~depth (var_to_hash_packed t) addr)\n reraise_merkle_requests\n\n(*\n [modify_account t aid ~filter ~f] implements the following spec:\n\n - finds an account [account] in [t] for [aid] at path [addr] where [filter\n account] holds.\n note that the account is not guaranteed to have identifier [aid]; it might\n be a new account created to satisfy this request.\n - returns a root [t'] of a tree of depth [depth] which is [t] but with the\n account [f account] at path [addr].\n*)\nlet%snarkydef_ modify_account ~depth t aid\n ~(filter : Account.var -> 'a Checked.t) ~f =\n let%bind addr =\n request_witness\n (Account.Index.Unpacked.typ ~ledger_depth:depth)\n As_prover.(map (read Account_id.typ aid) ~f:(fun s -> Find_index s))\n in\n handle\n (fun () ->\n Merkle_tree.modify_req ~depth (var_to_hash_packed t) addr\n ~f:(fun account ->\n let%bind x = filter account in\n f x account ) )\n reraise_merkle_requests\n >>| var_of_hash_packed\n\n(*\n [modify_account_send t aid ~f] implements the following spec:\n\n - finds an account [account] in [t] at path [addr] whose account id is [aid]\n OR it is a fee transfer and is an empty account\n - returns a root [t'] of a tree of depth [depth] which is [t] but with the\n account [f account] at path [addr].\n*)\nlet%snarkydef_ modify_account_send ~depth t aid ~is_writeable ~f =\n modify_account ~depth t aid\n ~filter:(fun account ->\n [%with_label_ \"modify_account_send filter\"] (fun () ->\n let%bind account_already_there =\n Account_id.Checked.equal (Account.identifier_of_var account) aid\n in\n let%bind account_not_there =\n Public_key.Compressed.Checked.equal account.public_key\n Public_key.Compressed.(var_of_t empty)\n in\n let%bind not_there_but_writeable =\n Boolean.(account_not_there && is_writeable)\n in\n let%bind () =\n [%with_label_ \"account is either present or empty and writeable\"]\n (fun () ->\n Boolean.Assert.any\n [ account_already_there; not_there_but_writeable ] )\n in\n return not_there_but_writeable ) )\n ~f:(fun is_empty_and_writeable x -> f ~is_empty_and_writeable x)\n\n(*\n [modify_account_recv t aid ~f] implements the following spec:\n\n - finds an account [account] in [t] at path [addr] whose account id is [aid]\n OR which is an empty account\n - returns a root [t'] of a tree of depth [depth] which is [t] but with the\n account [f account] at path [addr].\n*)\nlet%snarkydef_ modify_account_recv ~depth t aid ~f =\n modify_account ~depth t aid\n ~filter:(fun account ->\n [%with_label_ \"modify_account_recv filter\"] (fun () ->\n let%bind account_already_there =\n Account_id.Checked.equal (Account.identifier_of_var account) aid\n in\n let%bind account_not_there =\n Public_key.Compressed.Checked.equal account.public_key\n Public_key.Compressed.(var_of_t empty)\n in\n let%bind () =\n [%with_label_ \"account is either present or empty\"] (fun () ->\n Boolean.Assert.any [ account_already_there; account_not_there ] )\n in\n return account_not_there ) )\n ~f:(fun is_empty_and_writeable x -> f ~is_empty_and_writeable x)\n","open Snark_params\nopen Snarky_backendless\nopen Tick\n\nmodule type S = sig\n include Ledger_hash_intf0.S\n\n type path = Random_oracle.Digest.t list\n\n type _ Request.t +=\n | Get_path : Account.Index.t -> path Request.t\n | Get_element : Account.Index.t -> (Account.t * path) Request.t\n | Set : Account.Index.t * Account.t -> unit Request.t\n | Find_index : Account_id.t -> Account.Index.t Request.t\n\n val get :\n depth:int -> var -> Account.Index.Unpacked.var -> Account.var Checked.t\n\n val merge : height:int -> t -> t -> t\n\n (** string representation of hash is Base58Check of bin_io representation *)\n val to_base58_check : t -> string\n\n val of_base58_check : string -> t Base.Or_error.t\n\n val empty_hash : t\n\n val of_digest : Random_oracle.Digest.t -> t\n\n val modify_account :\n depth:int\n -> var\n -> Account_id.var\n -> filter:(Account.var -> 'a Checked.t)\n -> f:('a -> Account.var -> Account.var Checked.t)\n -> var Checked.t\n\n val modify_account_send :\n depth:int\n -> var\n -> Account_id.var\n -> is_writeable:Boolean.var\n -> f:\n ( is_empty_and_writeable:Boolean.var\n -> Account.var\n -> Account.var Checked.t )\n -> var Checked.t\n\n val modify_account_recv :\n depth:int\n -> var\n -> Account_id.var\n -> f:\n ( is_empty_and_writeable:Boolean.var\n -> Account.var\n -> Account.var Checked.t )\n -> var Checked.t\nend\n","include Ledger_hash\n\nlet of_ledger_hash (h : Ledger_hash.t) : t = h\n\nlet to_ledger_hash (t : t) : Ledger_hash.t = t\n","open Core_kernel\n\nmodule type S = sig\n module Stable : sig\n module V1 : sig\n type t = private Zkapp_basic.F.t\n\n val to_yojson : t -> Yojson.Safe.t\n\n val of_yojson : Yojson.Safe.t -> t Ppx_deriving_yojson_runtime.error_or\n\n val bin_size_t : t Bin_prot.Size.sizer\n\n val bin_write_t : t Bin_prot.Write.writer\n\n val bin_read_t : t Bin_prot.Read.reader\n\n val __bin_read_t__ : (int -> t) Bin_prot.Read.reader\n\n val bin_shape_t : Bin_prot.Shape.t\n\n val bin_writer_t : t Bin_prot.Type_class.writer\n\n val bin_reader_t : t Bin_prot.Type_class.reader\n\n val bin_t : t Bin_prot.Type_class.t\n\n val __versioned__ : unit\n\n val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t\n\n val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t\n\n val compare : t -> t -> int\n\n val equal : t -> t -> bool\n\n val hash_fold_t :\n Base_internalhash_types.state -> t -> Base_internalhash_types.state\n\n val hash : t -> int\n end\n\n module Latest = V1\n end\n\n type t = Stable.V1.t\n\n val to_yojson : t -> Yojson.Safe.t\n\n val of_yojson : Yojson.Safe.t -> t Ppx_deriving_yojson_runtime.error_or\n\n val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t\n\n val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t\n\n val compare : t -> t -> int\n\n val equal : t -> t -> bool\n\n val hash_fold_t :\n Base_internalhash_types.state -> t -> Base_internalhash_types.state\n\n val hash : t -> int\nend\n\nmodule type S_checked = sig\n open Pickles.Impls.Step\n\n type t = private Field.t\n\n val if_ : Boolean.var -> then_:t -> else_:t -> t\n\n val equal : t -> t -> Boolean.var\n\n module Assert : sig\n val equal : t -> t -> unit\n end\nend\n\nmodule type S_aux = sig\n type t\n\n type checked\n\n val typ : (checked, t) Pickles.Impls.Step.Typ.t\n\n val constant : t -> checked\nend\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\n\n[%%ifdef consensus_mechanism]\n\nopen Snark_params.Tick\n\n[%%endif]\n\nmodule Poly = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type 'comm t = { account_update : 'comm; calls : 'comm }\n [@@deriving hlist, sexp, yojson]\n end\n end]\n\n let to_field_elements (t : 'c t) : 'c array =\n let [ x0; x1 ] = to_hlist t in\n [| x0; x1 |]\nend\n\n[%%versioned\nmodule Stable = struct\n module V2 = struct\n type t = Zkapp_command.Transaction_commitment.Stable.V1.t Poly.Stable.V1.t\n [@@deriving sexp, yojson]\n\n let to_latest = Fn.id\n end\nend]\n\nlet to_field_elements : t -> _ = Poly.to_field_elements\n\nlet of_tree (type account_update)\n ({ account_update = _; account_update_digest; calls } :\n ( account_update\n , Zkapp_command.Digest.Account_update.t\n , Zkapp_command.Digest.Forest.t )\n Zkapp_command.Call_forest.Tree.t ) : t =\n { account_update =\n (account_update_digest :> Zkapp_command.Transaction_commitment.t)\n ; calls =\n ( Zkapp_command.Call_forest.hash calls\n :> Zkapp_command.Transaction_commitment.t )\n }\n\nlet zkapp_statements_of_forest' (type data)\n (forest : data Zkapp_command.Call_forest.With_hashes_and_data.t) :\n (data * t) Zkapp_command.Call_forest.With_hashes_and_data.t =\n Zkapp_command.Call_forest.mapi_with_trees forest\n ~f:(fun _i (account_update, data) tree ->\n (account_update, (data, of_tree tree)) )\n\nlet zkapp_statements_of_forest (type account_update)\n (forest : (account_update, _, _) Zkapp_command.Call_forest.t) :\n (account_update * t, _, _) Zkapp_command.Call_forest.t =\n Zkapp_command.Call_forest.mapi_with_trees forest\n ~f:(fun _i account_update tree -> (account_update, of_tree tree))\n\n[%%ifdef consensus_mechanism]\n\nmodule Checked = struct\n type t = Zkapp_command.Transaction_commitment.Checked.t Poly.t\n\n let to_field_elements : t -> _ = Poly.to_field_elements\n\n open Pickles.Impls.Step\n\n module Assert = struct\n let equal (t1 : t) (t2 : t) =\n Array.iter2_exn ~f:Field.Assert.equal (to_field_elements t1)\n (to_field_elements t2)\n end\nend\n\nlet typ =\n let open Poly in\n Typ.of_hlistable\n Zkapp_command.Transaction_commitment.[ typ; typ ]\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist\n\n[%%endif]\n","open Snark_params.Tick.Run\n\ntype 'a t = 'a As_prover.Ref.t\n\nlet get = As_prover.Ref.get\n\nlet create = As_prover.Ref.create\n\nlet if_ b ~then_ ~else_ =\n create (fun () ->\n get (if Impl.As_prover.read Boolean.typ b then then_ else else_) )\n\nlet map t ~f = create (fun () -> f (get t))\n\nlet typ = Typ.Internal.ref\n","open Core_kernel\n\n(* Same as the type of the field account_updates in Mina_base.Zkapp_command.t *)\ntype t =\n ( Account_update.t\n , Zkapp_command.Digest.Account_update.t\n , Zkapp_command.Digest.Forest.t )\n Zkapp_command.Call_forest.t\n\ntype account_update =\n (Account_update.t, Zkapp_command.Digest.Account_update.t) With_hash.t\n\nlet empty () = []\n\nlet if_ = Zkapp_command.value_if\n\nlet is_empty = List.is_empty\n\nlet pop_exn : t -> (Account_update.t * t) * t = function\n | { stack_hash = _\n ; elt = { account_update; calls; account_update_digest = _ }\n }\n :: xs ->\n ((account_update, calls), xs)\n | _ ->\n failwith \"pop_exn\"\n\nlet push ~account_update ~calls t =\n Zkapp_command.Call_forest.cons ~calls account_update t\n\nlet hash (t : t) = Zkapp_command.Call_forest.hash t\n\nopen Snark_params.Tick.Run\n\nmodule Checked = struct\n module F = Zkapp_command.Digest.Forest.Checked\n module V = Prover_value\n\n type account_update =\n { account_update :\n ( Account_update.Body.Checked.t\n , Zkapp_command.Digest.Account_update.Checked.t )\n With_hash.t\n ; control : Control.t Prover_value.t\n }\n\n let account_update_typ () :\n ( account_update\n , (Account_update.t, Zkapp_command.Digest.Account_update.t) With_hash.t\n )\n Typ.t =\n let (Typ typ) =\n Typ.(\n Account_update.Body.typ () * Prover_value.typ ()\n * Zkapp_command.Digest.Account_update.typ)\n |> Typ.transport\n ~back:(fun ((body, authorization), hash) ->\n { With_hash.data = { Account_update.body; authorization }; hash }\n )\n ~there:(fun { With_hash.data = { Account_update.body; authorization }\n ; hash\n } -> ((body, authorization), hash) )\n |> Typ.transport_var\n ~back:(fun ((account_update, control), hash) ->\n { account_update = { hash; data = account_update }; control } )\n ~there:(fun { account_update = { hash; data = account_update }\n ; control\n } -> ((account_update, control), hash) )\n in\n Typ\n { typ with\n check =\n (fun ( { account_update = { hash; data = account_update }\n ; control = _\n } as x ) ->\n Impl.make_checked (fun () ->\n Impl.run_checked (typ.check x) ;\n Field.Assert.equal\n (hash :> Field.t)\n ( Zkapp_command.Call_forest.Digest.Account_update.Checked\n .create account_update\n :> Field.t ) ) )\n }\n\n type t =\n ( ( Account_update.t\n , Zkapp_command.Digest.Account_update.t\n , Zkapp_command.Digest.Forest.t )\n Zkapp_command.Call_forest.t\n V.t\n , F.t )\n With_hash.t\n\n let if_ b ~then_:(t : t) ~else_:(e : t) : t =\n { hash = F.if_ b ~then_:t.hash ~else_:e.hash\n ; data = V.if_ b ~then_:t.data ~else_:e.data\n }\n\n let empty =\n Zkapp_command.Digest.Forest.constant\n Zkapp_command.Call_forest.With_hashes.empty\n\n let is_empty ({ hash = x; _ } : t) = F.equal empty x\n\n let empty () : t = { hash = empty; data = V.create (fun () -> []) }\n\n let pop_exn ({ hash = h; data = r } : t) : (account_update * t) * t =\n with_label \"Zkapp_call_forest.pop_exn\" (fun () ->\n let hd_r =\n V.create (fun () -> V.get r |> List.hd_exn |> With_stack_hash.elt)\n in\n let account_update = V.create (fun () -> (V.get hd_r).account_update) in\n let auth =\n V.(create (fun () -> (V.get account_update).authorization))\n in\n let account_update =\n exists (Account_update.Body.typ ()) ~compute:(fun () ->\n (V.get account_update).body )\n in\n let account_update =\n With_hash.of_data account_update\n ~hash_data:Zkapp_command.Digest.Account_update.Checked.create\n in\n let subforest : t =\n let subforest = V.create (fun () -> (V.get hd_r).calls) in\n let subforest_hash =\n exists Zkapp_command.Digest.Forest.typ ~compute:(fun () ->\n Zkapp_command.Call_forest.hash (V.get subforest) )\n in\n { hash = subforest_hash; data = subforest }\n in\n let tl_hash =\n exists Zkapp_command.Digest.Forest.typ ~compute:(fun () ->\n V.get r |> List.tl_exn |> Zkapp_command.Call_forest.hash )\n in\n let tree_hash =\n Zkapp_command.Digest.Tree.Checked.create\n ~account_update:account_update.hash ~calls:subforest.hash\n in\n let hash_cons =\n Zkapp_command.Digest.Forest.Checked.cons tree_hash tl_hash\n in\n F.Assert.equal hash_cons h ;\n ( ( ({ account_update; control = auth }, subforest)\n , { hash = tl_hash\n ; data = V.(create (fun () -> List.tl_exn (get r)))\n } )\n : (account_update * t) * t ) )\n\n let pop ~dummy ~dummy_tree_hash ({ hash = h; data = r } : t) :\n (account_update * t) * t =\n with_label \"Zkapp_call_forest.pop\" (fun () ->\n let hd_r =\n V.create (fun () ->\n match V.get r with\n | hd :: _ ->\n With_stack_hash.elt hd\n | [] ->\n dummy )\n in\n let account_update = V.create (fun () -> (V.get hd_r).account_update) in\n let auth =\n V.(create (fun () -> (V.get account_update).authorization))\n in\n let account_update =\n exists (Account_update.Body.typ ()) ~compute:(fun () ->\n (V.get account_update).body )\n in\n let account_update =\n With_hash.of_data account_update\n ~hash_data:Zkapp_command.Digest.Account_update.Checked.create\n in\n let subforest : t =\n let subforest = V.create (fun () -> (V.get hd_r).calls) in\n let subforest_hash =\n exists Zkapp_command.Digest.Forest.typ ~compute:(fun () ->\n Zkapp_command.Call_forest.hash (V.get subforest) )\n in\n { hash = subforest_hash; data = subforest }\n in\n let tl_hash =\n exists Zkapp_command.Digest.Forest.typ ~compute:(fun () ->\n match V.get r with\n | _ :: tl ->\n Zkapp_command.Call_forest.hash tl\n | [] ->\n Zkapp_command.Digest.Forest.empty )\n in\n let tree_hash =\n Zkapp_command.Digest.Tree.Checked.create\n ~account_update:account_update.hash ~calls:subforest.hash\n in\n let hash_cons =\n Zkapp_command.Digest.Forest.Checked.cons tree_hash tl_hash\n in\n let () =\n let correct = F.equal hash_cons h in\n let empty = F.equal F.empty h in\n let is_dummy =\n Zkapp_command.Digest.Tree.Checked.equal tree_hash dummy_tree_hash\n in\n Boolean.(Assert.any [ correct; empty &&& is_dummy ])\n in\n ( ( ({ account_update; control = auth }, subforest)\n , { hash = tl_hash\n ; data =\n V.(\n create (fun () ->\n match get r with _ :: tl -> tl | [] -> [] ))\n } )\n : (account_update * t) * t ) )\n\n let push\n ~account_update:\n { account_update = { hash = account_update_hash; data = account_update }\n ; control = auth\n } ~calls:({ hash = calls_hash; data = calls } : t)\n ({ hash = tl_hash; data = tl_data } : t) : t =\n with_label \"Zkapp_call_forest.push\" (fun () ->\n let tree_hash =\n Zkapp_command.Digest.Tree.Checked.create\n ~account_update:account_update_hash ~calls:calls_hash\n in\n let hash_cons =\n Zkapp_command.Digest.Forest.Checked.cons tree_hash tl_hash\n in\n let data =\n V.create (fun () ->\n let body =\n As_prover.read (Account_update.Body.typ ()) account_update\n in\n let authorization = V.get auth in\n let tl = V.get tl_data in\n let account_update : Account_update.t = { body; authorization } in\n let calls = V.get calls in\n let res =\n Zkapp_command.Call_forest.cons ~calls account_update tl\n in\n (* Sanity check; we're re-hashing anyway, might as well make sure it's\n consistent.\n *)\n assert (\n Zkapp_command.Digest.Forest.(\n equal\n (As_prover.read typ hash_cons)\n (Zkapp_command.Call_forest.hash res)) ) ;\n res )\n in\n ({ hash = hash_cons; data } : t) )\n\n let hash ({ hash; _ } : t) = hash\nend\n\nlet typ : (Checked.t, t) Typ.t =\n Typ.(Zkapp_command.Digest.Forest.typ * Prover_value.typ ())\n |> Typ.transport\n ~back:(fun (_digest, forest) ->\n Zkapp_command.Call_forest.map\n ~f:(fun account_update -> account_update)\n forest )\n ~there:(fun forest ->\n ( Zkapp_command.Call_forest.hash forest\n , Zkapp_command.Call_forest.map\n ~f:(fun account_update -> account_update)\n forest ) )\n |> Typ.transport_var\n ~back:(fun (digest, forest) -> { With_hash.hash = digest; data = forest })\n ~there:(fun { With_hash.hash = digest; data = forest } ->\n (digest, forest) )\n","open Core_kernel\nopen Mina_base_import\n\nmodule type Full = sig\n module Single : sig\n module Stable : sig\n module V2 : sig\n type t = private\n { receiver_pk : Public_key.Compressed.Stable.V1.t\n ; fee : Currency.Fee.Stable.V1.t\n ; fee_token : Token_id.Stable.V2.t\n }\n [@@deriving bin_io, sexp, compare, equal, yojson, version, hash]\n end\n\n module Latest = V2\n end\n\n type t = Stable.Latest.t = private\n { receiver_pk : Public_key.Compressed.t\n ; fee : Currency.Fee.t\n ; fee_token : Token_id.t\n }\n [@@deriving sexp, compare, yojson, hash]\n\n include Comparable.S with type t := t\n\n include Codable.Base58_check_intf with type t := t\n\n val create :\n receiver_pk:Public_key.Compressed.t\n -> fee:Currency.Fee.t\n -> fee_token:Token_id.t\n -> t\n\n val receiver_pk : t -> Public_key.Compressed.t\n\n val receiver : t -> Account_id.t\n\n val fee : t -> Currency.Fee.t\n\n val fee_token : t -> Token_id.t\n\n module Gen : sig\n val with_random_receivers :\n ?min_fee:int\n -> max_fee:int\n -> token:Token_id.t Quickcheck.Generator.t\n -> Signature_keypair.t array\n -> t Quickcheck.Generator.t\n end\n end\n\n module Stable : sig\n module V2 : sig\n type t = private Single.Stable.V2.t One_or_two.Stable.V1.t\n [@@deriving bin_io, sexp, compare, equal, yojson, version, hash]\n end\n\n module Latest = V2\n end\n\n type t = Stable.Latest.t [@@deriving sexp, compare, yojson, hash]\n\n type single = Single.t = private\n { receiver_pk : Public_key.Compressed.t\n ; fee : Currency.Fee.t\n ; fee_token : Token_id.t\n }\n [@@deriving sexp, compare, yojson, hash]\n\n include Comparable.S with type t := t\n\n val create : Single.t -> Single.t option -> t Or_error.t\n\n val create_single :\n receiver_pk:Public_key.Compressed.t\n -> fee:Currency.Fee.t\n -> fee_token:Token_id.t\n -> t\n\n val to_singles : t -> Single.t One_or_two.t\n\n val of_singles : Single.t One_or_two.t -> t Or_error.t\n\n val fee_excess : t -> Fee_excess.t Or_error.t\n\n val fee_token : single -> Token_id.t\n\n val fee_tokens : t -> Token_id.t One_or_two.t\n\n val receiver_pks : t -> Public_key.Compressed.t list\n\n val receivers : t -> Account_id.t list\n\n val fee_payer_pk : t -> Public_key.Compressed.t\n\n val map : t -> f:(Single.t -> 'b) -> 'b One_or_two.t\n\n val fold : t -> init:'acc -> f:('acc -> Single.t -> 'acc) -> 'acc\n\n val to_list : t -> Single.t list\n\n val to_numbered_list : t -> (int * Single.t) list\nend\n","open Core_kernel\nopen Mina_base_import\n\nmodule type Full = sig\n [%%versioned:\n module Stable : sig\n module V1 : sig\n type t = private\n { receiver_pk : Public_key.Compressed.Stable.V1.t\n ; fee : Currency.Fee.Stable.V1.t\n }\n [@@deriving sexp, compare, equal, yojson, hash]\n end\n end]\n\n val create : receiver_pk:Public_key.Compressed.t -> fee:Currency.Fee.t -> t\n\n include Comparable.S with type t := t\n\n include Codable.Base58_check_intf with type t := t\n\n val receiver_pk : t -> Public_key.Compressed.t\n\n val receiver : t -> Account_id.t\n\n val fee : t -> Currency.Fee.t\n\n val to_fee_transfer : t -> Fee_transfer.Single.t\n\n module Gen : sig\n (** [gen ?min_fee max_fee] generates fee transfers between [min_fee] and\n [max_fee].\n\n @param min_fee defaults to zero *)\n val gen :\n ?min_fee:Currency.Fee.t -> Currency.Fee.t -> t Quickcheck.Generator.t\n\n (** [with_random_receivers ~key ?min_fee coinbase_amount] creates coinbase\n fee transfers with fees between [min_fee] and [coinbase_amount]\n\n @param min_fee defaults to {!val:Currency.Fee.zero}\n *)\n val with_random_receivers :\n keys:Signature_keypair.t array\n -> ?min_fee:Currency.Fee.t\n -> Currency.Amount.t\n -> t Quickcheck.Generator.t\n end\nend\n","open Core_kernel\nopen Mina_base_import\n\nmodule type Full = sig\n module Fee_transfer = Coinbase_fee_transfer\n\n module Stable : sig\n module V1 : sig\n type t = private\n { receiver : Public_key.Compressed.Stable.V1.t\n ; amount : Currency.Amount.Stable.V1.t\n ; fee_transfer : Fee_transfer.Stable.V1.t option\n }\n [@@deriving sexp, bin_io, compare, equal, version, hash, yojson]\n end\n\n module Latest = V1\n end\n\n (* bin_io intentionally omitted in deriving list *)\n type t = Stable.Latest.t = private\n { receiver : Public_key.Compressed.t\n ; amount : Currency.Amount.t\n ; fee_transfer : Fee_transfer.t option\n }\n [@@deriving sexp, compare, equal, hash, yojson]\n\n include Codable.Base58_check_intf with type t := t\n\n val receiver_pk : t -> Public_key.Compressed.t\n\n val receiver : t -> Account_id.t\n\n val fee_payer_pk : t -> Public_key.Compressed.t\n\n val amount : t -> Currency.Amount.t\n\n val fee_transfer : t -> Fee_transfer.t option\n\n val account_access_statuses :\n t\n -> Transaction_status.t\n -> (Account_id.t * [ `Accessed | `Not_accessed ]) list\n\n val accounts_referenced : t -> Account_id.t list\n\n val create :\n amount:Currency.Amount.t\n -> receiver:Public_key.Compressed.t\n -> fee_transfer:Fee_transfer.t option\n -> t Or_error.t\n\n val expected_supply_increase : t -> Currency.Amount.t Or_error.t\n\n val fee_excess : t -> Fee_excess.t Or_error.t\n\n module Gen : sig\n val gen :\n constraint_constants:Genesis_constants.Constraint_constants.t\n -> (t * [ `Supercharged_coinbase of bool ]) Quickcheck.Generator.t\n\n (** Creates coinbase with reward between [min_amount] and [max_amount]. The generated amount[coinbase_amount] is then used as the upper bound for the fee transfer. *)\n val with_random_receivers :\n keys:Signature_keypair.t array\n -> min_amount:int\n -> max_amount:int\n -> fee_transfer:\n ( coinbase_amount:Currency.Amount.t\n -> Fee_transfer.t Quickcheck.Generator.t )\n -> t Quickcheck.Generator.t\n end\nend\n","(** Pending_coinbase is to keep track of all the coinbase transactions that have been applied to the ledger but for which there is no ledger proof yet. Every ledger proof corresponds to a sequence of coinbase transactions which is part of all the transactions it proves. Each of these sequences[Stack] are stored using the merkle tree representation. The stacks are operated in a FIFO manner by keeping track of its positions in the merkle tree. Whenever a ledger proof is emitted, the oldest stack is removed from the tree and when a new coinbase is applied, the latest stack is updated with the new coinbase.\n The operations on the merkle tree of coinbase stacks include:\n 1) adding a new singleton stack\n 2) updating the latest stack when a new coinbase is added to it\n 2) deleting the oldest stack\n\n A stack can be either be created or modified by pushing a coinbase on to it.\n\n This module also provides an interface for the checked computations required required to prove it in snark\n\n Stack operations are done for transaction snarks and tree operations are done for the blockchain snark*)\n\nopen Core_kernel\nopen Snark_params\nopen Snarky_backendless\nopen Tick\nopen Signature_lib\nopen Currency\n\nmodule type S = sig\n type t [@@deriving sexp, to_yojson]\n\n module Stable : sig\n module V2 : sig\n type nonrec t = t [@@deriving bin_io, sexp, to_yojson, version]\n end\n\n module Latest = V2\n end\n\n module Coinbase_data : sig\n module Stable : sig\n module V1 : sig\n type t = Public_key.Compressed.Stable.V1.t * Amount.Stable.V1.t\n [@@deriving sexp, bin_io, to_yojson]\n end\n\n module Latest = V1\n end\n\n type t = Stable.Latest.t [@@deriving sexp, to_yojson]\n\n type var = Public_key.Compressed.var * Amount.var\n\n val typ : (var, t) Typ.t\n\n val empty : t\n\n val of_coinbase : Coinbase.t -> t\n\n val genesis : t\n\n val var_of_t : t -> var\n end\n\n module type Data_hash_intf = sig\n type t = private Field.t [@@deriving sexp, compare, equal, yojson, hash]\n\n type var\n\n val var_of_t : t -> var\n\n val typ : (var, t) Typ.t\n\n val var_to_hash_packed : var -> Field.Var.t\n\n val equal_var : var -> var -> Boolean.var Tick.Checked.t\n\n val to_bytes : t -> string\n\n val to_bits : t -> bool list\n\n val to_base58_check : t -> string\n\n val of_base58_check_exn : string -> t\n\n val gen : t Quickcheck.Generator.t\n end\n\n module rec Hash : sig\n include Data_hash_intf\n\n val merge : height:int -> t -> t -> t\n\n val empty_hash : t\n\n val of_digest : Random_oracle.Digest.t -> t\n end\n\n module Hash_versioned : sig\n [%%versioned:\n module Stable : sig\n module V1 : sig\n type nonrec t = Hash.t [@@deriving sexp, compare, equal, yojson, hash]\n end\n end]\n end\n\n module Stack_versioned : sig\n [%%versioned:\n module Stable : sig\n module V1 : sig\n type nonrec t [@@deriving sexp, compare, equal, yojson, hash]\n end\n end]\n end\n\n module Stack : sig\n type t = Stack_versioned.t [@@deriving sexp, compare, equal, yojson, hash]\n\n type var\n\n val data_hash : t -> Hash.t\n\n val var_of_t : t -> var\n\n val typ : (var, t) Typ.t\n\n val gen : t Quickcheck.Generator.t\n\n val to_input : t -> Field.t Random_oracle.Input.Chunked.t\n\n val to_bits : t -> bool list\n\n val to_bytes : t -> string\n\n val equal_var : var -> var -> Boolean.var Tick.Checked.t\n\n val var_to_input : var -> Field.Var.t Random_oracle.Input.Chunked.t\n\n val empty : t\n\n (** Creates a new stack with the state stack from an existing stack*)\n val create_with : t -> t\n\n val equal_data : t -> t -> bool\n\n val equal_state_hash : t -> t -> bool\n\n (** The two stacks are connected. This should be used instead of `equal` to\n check one transaction snark statement follow the other.*)\n val connected : ?prev:t option -> first:t -> second:t -> unit -> bool\n\n val push_coinbase : Coinbase.t -> t -> t\n\n val push_state :\n State_body_hash.t -> Mina_numbers.Global_slot_since_genesis.t -> t -> t\n\n module Checked : sig\n type t = var\n\n val push_coinbase : Coinbase_data.var -> t -> t Tick.Checked.t\n\n val push_state :\n State_body_hash.var\n -> Mina_numbers.Global_slot_since_genesis.Checked.var\n -> t\n -> t Tick.Checked.t\n\n val if_ : Boolean.var -> then_:t -> else_:t -> t Tick.Checked.t\n\n val check_merge :\n transition1:t * t -> transition2:t * t -> Boolean.var Tick.Checked.t\n\n val empty : t\n\n val create_with : t -> t\n end\n end\n\n module State_stack : sig\n [%%versioned:\n module Stable : sig\n module V1 : sig\n type t\n end\n end]\n end\n\n module Update : sig\n module Action : sig\n [%%versioned:\n module Stable : sig\n module V1 : sig\n type t =\n | Update_none\n | Update_one\n | Update_two_coinbase_in_first\n | Update_two_coinbase_in_second\n [@@deriving sexp, to_yojson]\n end\n end]\n\n type var = Boolean.var * Boolean.var\n\n val typ : (var, t) Typ.t\n\n val var_of_t : t -> var\n end\n\n module Poly : sig\n [%%versioned:\n module Stable : sig\n module V1 : sig\n type ('action, 'coinbase_amount) t =\n { action : 'action; coinbase_amount : 'coinbase_amount }\n [@@deriving sexp]\n end\n end]\n end\n\n [%%versioned:\n module Stable : sig\n module V1 : sig\n type t = (Action.Stable.V1.t, Amount.Stable.V1.t) Poly.Stable.V1.t\n [@@deriving sexp, to_yojson]\n end\n end]\n\n type var = (Action.var, Amount.var) Poly.t\n\n val genesis : t\n\n val typ : (var, t) Typ.t\n\n val var_of_t : t -> var\n end\n\n val create : depth:int -> unit -> t Or_error.t\n\n (** Delete the oldest stack*)\n val remove_coinbase_stack : depth:int -> t -> (Stack.t * t) Or_error.t\n\n (** Root of the merkle tree that has stacks as leaves*)\n val merkle_root : t -> Hash.t\n\n val handler :\n depth:int -> t -> is_new_stack:bool -> (request -> response) Staged.t\n\n (** Update the current working stack or if [is_new_stack] add as the new working stack*)\n val update_coinbase_stack :\n depth:int -> t -> Stack.t -> is_new_stack:bool -> t Or_error.t\n\n (** Stack that is currently being updated. if [is_new_stack] then a new stack is returned*)\n val latest_stack : t -> is_new_stack:bool -> Stack.t Or_error.t\n\n (** The stack that corresponds to the next ledger proof that is to be generated*)\n val oldest_stack : t -> Stack.t Or_error.t\n\n (** Hash of the auxiliary data (everything except the merkle root (Hash.t))*)\n val hash_extra : t -> string\n\n module Checked : sig\n type var = Hash.var\n\n type path\n\n module Address : sig\n type value\n\n type var\n\n val typ : depth:int -> (var, value) Typ.t\n end\n\n type _ Request.t +=\n | Coinbase_stack_path : Address.value -> path Request.t\n | Get_coinbase_stack : Address.value -> (Stack.t * path) Request.t\n | Set_coinbase_stack : Address.value * Stack.t -> unit Request.t\n | Set_oldest_coinbase_stack : Address.value * Stack.t -> unit Request.t\n | Find_index_of_newest_stacks :\n Update.Action.t\n -> (Address.value * Address.value) Request.t\n | Find_index_of_oldest_stack : Address.value Request.t\n | Get_previous_stack : State_stack.t Request.t\n\n val get : depth:int -> var -> Address.var -> Stack.var Tick.Checked.t\n\n (**\n [update_stack t ~is_new_stack updated_stack] implements the following spec:\n - gets the address[addr] of the latest stack or a new stack\n - finds a coinbase stack in [t] at path [addr] and pushes the coinbase_data on to the stack\n - returns a root [t'] of the tree\n *)\n val add_coinbase :\n constraint_constants:Genesis_constants.Constraint_constants.t\n -> var\n -> Update.var\n -> coinbase_receiver:Public_key.Compressed.var\n -> supercharge_coinbase:Boolean.var\n -> State_body_hash.var\n -> Mina_numbers.Global_slot_since_genesis.Checked.t\n -> var Tick.Checked.t\n\n (**\n [pop_coinbases t pk updated_stack] implements the following spec:\n\n - gets the address[addr] of the oldest stack.\n - finds a coinbase stack in [t] at path [addr] and replaces it with empty stack if a [proof_emitted] is true\n - returns a root [t'] of the tree\n *)\n val pop_coinbases :\n constraint_constants:Genesis_constants.Constraint_constants.t\n -> var\n -> proof_emitted:Boolean.var\n -> (var * Stack.var) Tick.Checked.t\n end\nend\n","open Async_kernel\n\nlet run_in_thread f = Deferred.return (f ())\n\nlet block_on_async_exn f =\n let res = f () in\n match Async_kernel.Deferred.peek res with\n | Some res ->\n res\n | None ->\n failwith\n \"block_on_async_exn: Cannot block thread, and the deferred computation \\\n did not resolve immediately.\"\n","module type Full = sig\n open Core_kernel\n open Snark_params.Tick\n\n type t [@@deriving sexp, equal, compare, hash, yojson]\n\n include Hashable with type t := t\n\n type value [@@deriving sexp, equal, compare, hash]\n\n type var\n\n val var_of_t : t -> var\n\n val typ : (var, t) Typ.t\n\n val var_to_input : var -> Field.Var.t Random_oracle.Input.Chunked.t\n\n val to_input : t -> Field.t Random_oracle.Input.Chunked.t\n\n val genesis :\n constraint_constants:Genesis_constants.Constraint_constants.t\n -> genesis_ledger_hash:Ledger_hash.t\n -> t\n\n module Stable : sig\n module V1 : sig\n type nonrec t = t\n [@@deriving bin_io, sexp, equal, compare, hash, yojson, version]\n end\n\n module Latest : module type of V1\n end\n\n module Aux_hash : sig\n type t\n\n module Stable : sig\n module V1 : sig\n type nonrec t = t\n [@@deriving bin_io, sexp, equal, compare, hash, yojson, version]\n end\n\n module Latest : module type of V1\n end\n\n val of_bytes : string -> t\n\n val to_bytes : t -> string\n\n val to_base58_check : t -> string\n\n val of_base58_check_exn : string -> t\n\n val compare : t -> t -> int\n\n val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t\n\n val dummy : t\n\n val of_sha256 : Digestif.SHA256.t -> t\n\n val gen : t Quickcheck.Generator.t\n end\n\n module Pending_coinbase_aux : sig\n type t\n\n module Stable : sig\n module V1 : sig\n type nonrec t = t\n [@@deriving bin_io, sexp, equal, compare, hash, yojson, version]\n end\n\n module Latest : module type of V1\n end\n\n val to_base58_check : t -> string\n\n val of_base58_check_exn : string -> t\n\n val dummy : t\n end\n\n val ledger_hash : t -> Ledger_hash.t\n\n val aux_hash : t -> Aux_hash.t\n\n val pending_coinbase_aux : t -> Pending_coinbase_aux.t\n\n val pending_coinbase_hash : t -> Pending_coinbase.Hash.t\n\n val pending_coinbase_hash_var : var -> Pending_coinbase.Hash.var\n\n val of_aux_ledger_and_coinbase_hash :\n Aux_hash.t -> Ledger_hash.t -> Pending_coinbase.t -> t\nend\n","open Core_kernel\n\n[%%versioned\nmodule Stable = struct\n module V1 = struct\n type ('caller, 'zkapp_command) t =\n { caller : 'caller; caller_caller : 'caller; calls : 'zkapp_command }\n [@@deriving make, fields, sexp, yojson]\n end\nend]\n\ntype value =\n ( Token_id.t\n , ( Account_update.t\n , Zkapp_command.Digest.Account_update.t\n , Zkapp_command.Digest.Forest.t )\n Zkapp_command.Call_forest.t )\n t\n\ntype ('caller, 'zkapp_command) frame = ('caller, 'zkapp_command) t\n\nlet empty : value =\n { caller = Token_id.default; caller_caller = Token_id.default; calls = [] }\n\nmodule type Stack_frame_digest_intf = sig\n include Digest_intf.S\n\n val create :\n ( Token_id.t\n , ( 'p\n , Zkapp_command.Digest.Account_update.t\n , Zkapp_command.Digest.Forest.t )\n Zkapp_command.Call_forest.t )\n frame\n -> t\n\n val gen : t Quickcheck.Generator.t\n\n open Pickles.Impls.Step\n\n module Checked : sig\n include Digest_intf.S_checked\n\n val create :\n hash_zkapp_command:\n ('zkapp_command -> Zkapp_command.Digest.Forest.Checked.t)\n -> (Token_id.Checked.t, 'zkapp_command) frame\n -> t\n end\n\n val typ : (Checked.t, t) Typ.t\nend\n\nmodule Wire_types = Mina_wire_types.Mina_base.Stack_frame.Digest\n\nmodule Make_sig (A : Wire_types.Types.S) = struct\n module type S = Stack_frame_digest_intf with type Stable.V1.t = A.V1.t\nend\n\nmodule Make_str (A : Wire_types.Concrete) = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Kimchi_backend.Pasta.Basic.Fp.Stable.V1.t\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n open Pickles.Impls.Step\n\n let gen = Field.Constant.gen\n\n let to_input (type p)\n ({ caller; caller_caller; calls } :\n ( Token_id.t\n , ( p\n , Zkapp_command.Digest.Account_update.t\n , Zkapp_command.Digest.Forest.t )\n Zkapp_command.Call_forest.t )\n frame ) =\n List.reduce_exn ~f:Random_oracle.Input.Chunked.append\n [ Token_id.to_input caller\n ; Token_id.to_input caller_caller\n ; Random_oracle.Input.Chunked.field\n (Zkapp_command.Call_forest.hash calls :> Field.Constant.t)\n ]\n\n let create frame =\n Random_oracle.hash ~init:Hash_prefix_states.account_update_stack_frame\n (Random_oracle.pack_input (to_input frame))\n\n module Checked = struct\n include Field\n\n let to_input (type zkapp_command)\n ~(hash_zkapp_command :\n zkapp_command -> Zkapp_command.Digest.Forest.Checked.t )\n ({ caller; caller_caller; calls } : _ frame) =\n List.reduce_exn ~f:Random_oracle.Input.Chunked.append\n [ Token_id.Checked.to_input caller\n ; Token_id.Checked.to_input caller_caller\n ; Random_oracle.Input.Chunked.field (hash_zkapp_command calls :> Field.t)\n ]\n\n let create ~hash_zkapp_command frame =\n Random_oracle.Checked.hash\n ~init:Hash_prefix_states.account_update_stack_frame\n (Random_oracle.Checked.pack_input (to_input ~hash_zkapp_command frame))\n end\n\n let typ = Field.typ\nend\n\nmodule Digest = Wire_types.Make (Make_sig) (Make_str)\n\nmodule Checked = struct\n type nonrec 'zkapp_command t = (Token_id.Checked.t, 'zkapp_command) t\n\n let if_ f b ~then_ ~else_ : _ t =\n { caller = Token_id.Checked.if_ b ~then_:then_.caller ~else_:else_.caller\n ; caller_caller =\n Token_id.Checked.if_ b ~then_:then_.caller_caller\n ~else_:else_.caller_caller\n ; calls = f b ~then_:then_.calls ~else_:else_.calls\n }\nend\n","open Core_kernel\nopen Mina_base_import\nopen Snark_params.Tick\n\n[%%versioned\nmodule Stable = struct\n module V2 = struct\n type t =\n ( Ledger_hash.Stable.V1.t\n , Account_id.Stable.V2.t\n , Account.Stable.V2.t )\n Sparse_ledger_lib.Sparse_ledger.T.Stable.V2.t\n [@@deriving yojson, sexp]\n\n let to_latest = Fn.id\n end\nend]\n\ntype sparse_ledger = t [@@deriving sexp, to_yojson]\n\nmodule Hash = struct\n include Ledger_hash\n\n let merge = Ledger_hash.merge\nend\n\nmodule Account = struct\n include Account\n\n let data_hash = Fn.compose Ledger_hash.of_digest Account.digest\nend\n\nmodule Global_state = struct\n type t =\n { first_pass_ledger : sparse_ledger\n ; second_pass_ledger : sparse_ledger\n ; fee_excess : Currency.Amount.Signed.t\n ; supply_increase : Currency.Amount.Signed.t\n ; protocol_state : Zkapp_precondition.Protocol_state.View.t\n ; block_global_slot : Mina_numbers.Global_slot_since_genesis.t\n }\n [@@deriving sexp, to_yojson]\nend\n\nmodule M = Sparse_ledger_lib.Sparse_ledger.Make (Hash) (Account_id) (Account)\n\ntype account_state = [ `Added | `Existed ] [@@deriving equal]\n\n(** Create a new 'empty' ledger.\n This ledger has an invalid root hash, and cannot be used except as a\n placeholder.\n*)\nlet empty ~depth () = M.of_hash ~depth Outside_hash_image.t\n\nmodule L = struct\n type t = M.t ref\n\n type location = int\n\n let get : t -> location -> Account.t option =\n fun t loc ->\n Option.try_with (fun () ->\n let account = M.get_exn !t loc in\n if Public_key.Compressed.(equal empty account.public_key) then None\n else Some account )\n |> Option.bind ~f:Fn.id\n\n let location_of_account : t -> Account_id.t -> location option =\n fun t id ->\n try\n let loc = M.find_index_exn !t id in\n let account = M.get_exn !t loc in\n if Public_key.Compressed.(equal empty account.public_key) then None\n else Some loc\n with _ -> None\n\n let set : t -> location -> Account.t -> unit =\n fun t loc a -> t := M.set_exn !t loc a\n\n let get_or_create_exn :\n t -> Account_id.t -> account_state * Account.t * location =\n fun t id ->\n let loc = M.find_index_exn !t id in\n let account = M.get_exn !t loc in\n if Public_key.Compressed.(equal empty account.public_key) then (\n let public_key = Account_id.public_key id in\n let account' : Account.t =\n { account with\n delegate = Some public_key\n ; public_key\n ; token_id = Account_id.token_id id\n }\n in\n set t loc account' ;\n (`Added, account', loc) )\n else (`Existed, account, loc)\n\n let get_or_create t id = Or_error.try_with (fun () -> get_or_create_exn t id)\n\n let get_or_create_account :\n t -> Account_id.t -> Account.t -> (account_state * location) Or_error.t =\n fun t id to_set ->\n Or_error.try_with (fun () ->\n let loc = M.find_index_exn !t id in\n let a = M.get_exn !t loc in\n if Public_key.Compressed.(equal empty a.public_key) then (\n set t loc to_set ;\n (`Added, loc) )\n else (`Existed, loc) )\n\n let create_new_account t id to_set =\n get_or_create_account t id to_set |> Or_error.map ~f:ignore\n\n let remove_accounts_exn : t -> Account_id.t list -> unit =\n fun _t _xs -> failwith \"remove_accounts_exn: not implemented\"\n\n let merkle_root : t -> Ledger_hash.t = fun t -> M.merkle_root !t\n\n let with_ledger : depth:int -> f:(t -> 'a) -> 'a =\n fun ~depth:_ ~f:_ -> failwith \"with_ledger: not implemented\"\n\n (** Create a new ledger mask 'on top of' the given ledger.\n\n Warning: For technical reasons, this mask cannot be applied directly to\n the parent ledger; instead, use\n [apply_mask parent_ledger ~masked:this_ledger] to update the parent\n ledger as necessary.\n *)\n let create_masked t = ref !t\n\n (** [apply_mask ledger ~masked] applies any updates in [masked] to the ledger\n [ledger]. [masked] should be created by calling [create_masked ledger].\n\n Warning: This function may behave unexpectedly if [ledger] was modified\n after calling [create_masked], or the given [ledger] was not used to\n create [masked].\n *)\n let apply_mask t ~masked = t := !masked\n\n (** Create a new 'empty' ledger.\n This ledger has an invalid root hash, and cannot be used except as a\n placeholder.\n *)\n let empty ~depth () = ref (empty ~depth ())\nend\n\n[%%define_locally\nM.\n ( of_hash\n , to_yojson\n , get_exn\n , path_exn\n , set_exn\n , find_index_exn\n , add_path\n , merkle_root\n , iteri )]\n\nlet of_root ~depth (h : Ledger_hash.t) =\n of_hash ~depth (Ledger_hash.of_digest (h :> Random_oracle.Digest.t))\n\nlet get_or_initialize_exn account_id t idx =\n let account = get_exn t idx in\n if Public_key.Compressed.(equal empty account.public_key) then\n let public_key = Account_id.public_key account_id in\n let token_id = Account_id.token_id account_id in\n let delegate =\n (* Only allow delegation if this account is for the default token. *)\n if Token_id.(equal default) token_id then Some public_key else None\n in\n ( `Added\n , { account with\n delegate\n ; public_key\n ; token_id = Account_id.token_id account_id\n } )\n else (`Existed, account)\n\nlet has_locked_tokens_exn ~global_slot ~account_id t =\n let idx = find_index_exn t account_id in\n let _, account = get_or_initialize_exn account_id t idx in\n Account.has_locked_tokens ~global_slot account\n\nlet merkle_root t = Ledger_hash.of_hash (merkle_root t :> Random_oracle.Digest.t)\n\nlet depth t = M.depth t\n\nlet handler t =\n let ledger = ref t in\n let path_exn idx =\n List.map (path_exn !ledger idx) ~f:(function `Left h -> h | `Right h -> h)\n in\n stage (fun (With { request; respond }) ->\n match request with\n | Ledger_hash.Get_element idx ->\n let elt = get_exn !ledger idx in\n let path = (path_exn idx :> Random_oracle.Digest.t list) in\n respond (Provide (elt, path))\n | Ledger_hash.Get_path idx ->\n let path = (path_exn idx :> Random_oracle.Digest.t list) in\n respond (Provide path)\n | Ledger_hash.Set (idx, account) ->\n ledger := set_exn !ledger idx account ;\n respond (Provide ())\n | Ledger_hash.Find_index pk ->\n let index = find_index_exn !ledger pk in\n respond (Provide index)\n | _ ->\n unhandled )\n","module type Full = sig\n open Core_kernel\n open Snark_params\n open Tick\n open Mina_base_import\n\n [@@@warning \"-32\"]\n\n [%%versioned:\n module Stable : sig\n module V1 : sig\n type t =\n { fee : Currency.Fee.Stable.V1.t\n ; prover : Public_key.Compressed.Stable.V1.t\n }\n [@@deriving sexp, yojson, equal, compare]\n end\n end]\n\n [@@@warning \"+32\"]\n\n type t = Stable.Latest.t =\n { fee : Currency.Fee.Stable.V1.t\n ; prover : Public_key.Compressed.Stable.V1.t\n }\n [@@deriving sexp, yojson, equal, compare]\n\n val create : fee:Currency.Fee.t -> prover:Public_key.Compressed.t -> t\n\n module Digest : sig\n type t [@@deriving sexp, equal, yojson, hash, compare]\n\n module Stable : sig\n module V1 : sig\n type nonrec t = t\n [@@deriving sexp, bin_io, hash, compare, equal, yojson, version]\n end\n\n module Latest = V1\n end\n\n module Checked : sig\n type t\n\n val to_input : t -> Field.Var.t Random_oracle.Input.Chunked.t\n end\n\n val to_input : t -> Field.t Random_oracle.Input.Chunked.t\n\n val typ : (Checked.t, t) Typ.t\n\n val default : t\n end\n\n val digest : t -> Digest.t\nend\n","open Core_kernel\n\n[%%versioned\nmodule Stable = struct\n module V2 = struct\n type t =\n { pending_coinbases : Pending_coinbase.Stable.V2.t; is_new_stack : bool }\n [@@deriving sexp, to_yojson]\n\n let to_latest = Fn.id\n end\nend]\n","open Core_kernel\n\nmodule type Full = sig\n include Digest_intf.S\n\n val cons : Stack_frame.Digest.t -> t -> t\n\n val empty : t\n\n val gen : t Quickcheck.Generator.t\n\n module Checked : sig\n include Digest_intf.S_checked\n\n val cons : Stack_frame.Digest.Checked.t -> t -> t\n end\n\n include Digest_intf.S_aux with type t := t and type checked := Checked.t\nend\n","open Core_kernel\nmodule Wire_types = Mina_wire_types.Mina_base.Call_stack_digest\n\nmodule Make_sig (A : Wire_types.Types.S) = struct\n module type S = Call_stack_digest_intf.Full with type Stable.V1.t = A.V1.t\nend\n\nmodule Make_str (A : Wire_types.Concrete) = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Kimchi_backend.Pasta.Basic.Fp.Stable.V1.t\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n open Pickles.Impls.Step\n\n let cons (h : Stack_frame.Digest.t) (t : t) : t =\n Random_oracle.hash ~init:Hash_prefix_states.account_update_stack_frame_cons\n [| (h :> Field.Constant.t); t |]\n\n let empty = Field.Constant.zero\n\n let gen = Field.Constant.gen\n\n module Checked = struct\n include Field\n\n let cons (h : Stack_frame.Digest.Checked.t) (t : t) : t =\n Random_oracle.Checked.hash\n ~init:Hash_prefix_states.account_update_stack_frame_cons\n [| (h :> Field.t); t |]\n end\n\n let constant = Field.constant\n\n let typ = Field.typ\nend\n\ninclude Wire_types.Make (Make_sig) (Make_str)\n","open Core_kernel\n\ntype account_state = [ `Added | `Existed ] [@@deriving equal]\n\nmodule type S = sig\n type t\n\n type location\n\n val get : t -> location -> Account.t option\n\n val location_of_account : t -> Account_id.t -> location option\n\n val set : t -> location -> Account.t -> unit\n\n val get_or_create :\n t -> Account_id.t -> (account_state * Account.t * location) Or_error.t\n\n val create_new_account : t -> Account_id.t -> Account.t -> unit Or_error.t\n\n val remove_accounts_exn : t -> Account_id.t list -> unit\n\n val merkle_root : t -> Ledger_hash.t\n\n val with_ledger : depth:int -> f:(t -> 'a) -> 'a\n\n val empty : depth:int -> unit -> t\n\n val create_masked : t -> t\n\n val apply_mask : t -> masked:t -> unit\nend\n","module Import = Mina_base_import\nmodule Util = Mina_base_util\nmodule Account = Account\nmodule Account_id = Account_id\nmodule Account_timing = Account_timing\nmodule Call_stack_digest = Call_stack_digest\nmodule Coinbase = Coinbase\nmodule Coinbase_fee_transfer = Coinbase_fee_transfer\nmodule Control = Control\nmodule Data_as_hash = Data_as_hash\nmodule Data_hash = Data_hash\nmodule Epoch_data = Epoch_data\nmodule Epoch_ledger = Epoch_ledger\nmodule Epoch_seed = Epoch_seed\nmodule Fee_excess = Fee_excess\nmodule Fee_transfer = Fee_transfer\nmodule Fee_with_prover = Fee_with_prover\nmodule Frozen_ledger_hash = Frozen_ledger_hash\nmodule Frozen_ledger_hash0 = Frozen_ledger_hash0\nmodule Hash_prefix = Hash_prefix\nmodule Ledger_hash = Ledger_hash\nmodule Ledger_hash0 = Ledger_hash0\nmodule Ledger_hash_intf = Ledger_hash_intf\nmodule Ledger_hash_intf0 = Ledger_hash_intf0\nmodule Ledger_intf = Ledger_intf\nmodule Account_update = Account_update\nmodule Payment_payload = Payment_payload\nmodule Pending_coinbase = Pending_coinbase\nmodule Pending_coinbase_intf = Pending_coinbase_intf\nmodule Pending_coinbase_witness = Pending_coinbase_witness\nmodule Permissions = Permissions\nmodule Proof = Proof\nmodule Protocol_constants_checked = Protocol_constants_checked\nmodule Prover_value = Prover_value\nmodule Receipt = Receipt\nmodule Side_loaded_verification_key = Side_loaded_verification_key\nmodule Signature = Signature\nmodule Signed_command = Signed_command\nmodule Signed_command_intf = Signed_command_intf\nmodule Signed_command_memo = Signed_command_memo\nmodule Signed_command_payload = Signed_command_payload\nmodule Zkapp_account = Zkapp_account\nmodule Zkapp_basic = Zkapp_basic\nmodule Zkapp_call_forest = Zkapp_call_forest\nmodule Zkapp_command = Zkapp_command\nmodule Zkapp_precondition = Zkapp_precondition\nmodule Zkapp_state = Zkapp_state\nmodule Zkapp_statement = Zkapp_statement\nmodule Sok_message = Sok_message\nmodule Sparse_ledger_base = Sparse_ledger_base\nmodule Stack_frame = Stack_frame\nmodule Staged_ledger_hash = Staged_ledger_hash\nmodule Stake_delegation = Stake_delegation\nmodule State_body_hash = State_body_hash\nmodule State_hash = State_hash\nmodule Token_id = Token_id\nmodule Transaction_status = Transaction_status\nmodule Transaction_union_payload = Transaction_union_payload\nmodule Transaction_union_tag = Transaction_union_tag\nmodule User_command = User_command\nmodule Verification_key_wire = Verification_key_wire\nmodule With_stack_hash = With_stack_hash\nmodule With_status = With_status\n","module Js = struct\n type t\n\n type 'a js_array = t\n\n type ('a, 'b) meth_callback = t\n\n external string : string -> t = \"caml_jsstring_of_string\"\n\n external to_string : t -> string = \"caml_string_of_jsstring\"\n\n external bytestring : string -> t = \"caml_jsbytes_of_string\"\n\n external to_bytestring : t -> string = \"caml_string_of_jsbytes\"\n\n external bool : bool -> t = \"caml_js_from_bool\"\n\n external to_bool : t -> bool = \"caml_js_to_bool\"\n\n external array : 'a array -> t = \"caml_js_from_array\"\n\n external to_array : t -> 'a array = \"caml_js_to_array\"\n\n external number_of_float : float -> t = \"caml_js_from_float\"\n\n external float_of_number : t -> float = \"caml_js_to_float\"\n\n external typeof : t -> t = \"caml_js_typeof\"\n\n external instanceof : t -> t -> bool = \"caml_js_instanceof\"\n\n external debugger : unit -> unit = \"debugger\"\n\n external get : t -> t -> t = \"caml_js_get\"\n\n external set : t -> t -> t -> unit = \"caml_js_set\"\n\n external delete : t -> t -> unit = \"caml_js_delete\"\n\n external call : t -> t -> t array -> t = \"caml_js_call\"\n\n external fun_call : t -> t array -> t = \"caml_js_fun_call\"\n\n external meth_call : t -> string -> t array -> t = \"caml_js_meth_call\"\n\n external new_obj : t -> t array -> t = \"caml_js_new\"\n\n external new_obj_arr : t -> t js_array -> t = \"caml_ojs_new_arr\"\n\n external obj : (string * t) array -> t = \"caml_js_object\"\n\n external equals : t -> t -> bool = \"caml_js_equals\"\n\n external pure_expr : (unit -> 'a) -> 'a = \"caml_js_pure_expr\"\n\n external eval_string : string -> 'a = \"caml_js_eval_string\"\n\n external js_expr : string -> 'a = \"caml_js_expr\"\n\n external pure_js_expr : string -> 'a = \"caml_pure_js_expr\"\n\n external callback_with_arguments :\n (t js_array -> 'b) -> ('c, t js_array -> 'b) meth_callback\n = \"caml_js_wrap_callback_arguments\"\n\n external callback_with_arity : int -> ('a -> 'b) -> ('c, 'a -> 'b) meth_callback\n = \"caml_js_wrap_callback_strict\"\n\n external meth_callback : ('b -> 'a) -> ('b, 'a) meth_callback\n = \"caml_js_wrap_meth_callback_unsafe\"\n\n external meth_callback_with_arity : int -> ('b -> 'a) -> ('b, 'a) meth_callback\n = \"caml_js_wrap_meth_callback_strict\"\n\n external meth_callback_with_arguments :\n ('b -> t js_array -> 'a) -> ('b, t js_array -> 'a) meth_callback\n = \"caml_js_wrap_meth_callback_arguments\"\n\n external wrap_callback : ('a -> 'b) -> ('c, 'a -> 'b) meth_callback\n = \"caml_js_wrap_callback\"\n\n external wrap_meth_callback : ('a -> 'b) -> ('a, 'b) meth_callback\n = \"caml_js_wrap_meth_callback\"\nend\n\nmodule Sys = struct\n type 'a callback = 'a\n\n external create_file : name:string -> content:string -> unit = \"caml_create_file\"\n\n external read_file : name:string -> string = \"caml_read_file_content\"\n\n external set_channel_output' : out_channel -> (js_string:Js.t -> unit) callback -> unit\n = \"caml_ml_set_channel_output\"\n\n external set_channel_input' : in_channel -> (unit -> string) callback -> unit\n = \"caml_ml_set_channel_refill\"\n\n external mount_point : unit -> string list = \"caml_list_mount_point\"\n\n external mount_autoload : string -> (string -> string -> string option) callback -> unit\n = \"caml_mount_autoload\"\n\n external unmount : string -> unit = \"caml_unmount\"\nend\n\nmodule Error : sig\n type t\n\n val raise_ : t -> 'a\n\n val attach_js_backtrace : exn -> force:bool -> exn\n (** Attach a JavasScript error to an OCaml exception. if [force = false] and a\n JavasScript error is already attached, it will do nothing. This function is useful to\n store and retrieve information about JavaScript stack traces.\n\n Attaching JavasScript errors will happen automatically when compiling with\n [--enable with-js-error]. *)\n\n val of_exn : exn -> t option\n (** Extract a JavaScript error attached to an OCaml exception, if any. This is useful to\n inspect an eventual stack strace, especially when sourcemap is enabled. *)\n\n exception Exn of t\n (** The [Error] exception wrap javascript exceptions when caught by OCaml code.\n In case the javascript exception is not an instance of javascript [Error],\n it will be serialized and wrapped into a [Failure] exception.\n *)\nend = struct\n type t\n\n exception Exn of t\n\n let _ = Callback.register_exception \"jsError\" (Exn (Obj.magic [||]))\n\n let raise_ : t -> 'a = Js.js_expr \"(function (exn) { throw exn })\"\n\n external of_exn : exn -> t option = \"caml_js_error_option_of_exception\"\n\n external attach_js_backtrace : exn -> force:bool -> exn = \"caml_exn_with_js_backtrace\"\nend\n\n[@@@ocaml.warning \"-32-60\"]\n\nmodule For_compatibility_only = struct\n (* Add primitives for compatibility reasons. Existing users might\n depend on it (e.g. gen_js_api), we dont want the ocaml compiler\n to complain about theses missing primitives. *)\n\n external caml_js_from_string : string -> Js.t = \"caml_js_from_string\"\n\n external caml_js_to_byte_string : Js.t -> string = \"caml_js_to_byte_string\"\n\n external caml_js_to_string : Js.t -> string = \"caml_js_to_string\"\n\n external caml_list_of_js_array : 'a Js.js_array -> 'a list = \"caml_list_of_js_array\"\n\n external caml_list_to_js_array : 'a list -> 'a Js.js_array = \"caml_list_to_js_array\"\n\n external variable : string -> 'a = \"caml_js_var\"\nend\n\nmodule Typed_array = struct\n type ('a, 'b) typedArray = Js.t\n\n type arrayBuffer = Js.t\n\n type uint8Array = Js.t\n\n external kind : ('a, 'b) typedArray -> ('a, 'b) Bigarray.kind\n = \"caml_ba_kind_of_typed_array\"\n\n external from_genarray :\n ('a, 'b, Bigarray.c_layout) Bigarray.Genarray.t -> ('a, 'b) typedArray\n = \"caml_ba_to_typed_array\"\n\n external to_genarray :\n ('a, 'b) typedArray -> ('a, 'b, Bigarray.c_layout) Bigarray.Genarray.t\n = \"caml_ba_from_typed_array\"\n\n module Bigstring = struct\n type t = (char, Bigarray.int8_unsigned_elt, Bigarray.c_layout) Bigarray.Array1.t\n\n external to_arrayBuffer : t -> arrayBuffer = \"bigstring_to_array_buffer\"\n\n external to_uint8Array : t -> uint8Array = \"bigstring_to_typed_array\"\n\n external of_arrayBuffer : arrayBuffer -> t = \"bigstring_of_array_buffer\"\n\n external of_uint8Array : uint8Array -> t = \"bigstring_of_typed_array\"\n end\n\n external of_uint8Array : uint8Array -> string = \"caml_string_of_array\"\nend\n\nmodule Int64 = struct\n external create_int64_lo_mi_hi : int -> int -> int -> Int64.t\n = \"caml_int64_create_lo_mi_hi\"\nend\n","(* Js_of_ocaml library\n * http://www.ocsigen.org/js_of_ocaml/\n * Copyright (C) 2010 Jérôme Vouillon\n * Laboratoire PPS - CNRS Université Paris Diderot\n *\n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, with linking exception;\n * either version 2.1 of the License, or (at your option) any later version.\n *\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n *)\nopen! Import\n\n(* This local module [Js] is needed so that the ppx_js extension work within that file. *)\nmodule Js = struct\n type +'a t\n\n type (-'a, +'b) meth_callback\n\n module Unsafe = struct\n type top\n\n type any = top t\n\n type any_js_array = any\n\n external inject : 'a -> any = \"%identity\"\n\n external coerce : _ t -> _ t = \"%identity\"\n\n external get : 'a -> 'b -> 'c = \"caml_js_get\"\n\n external set : 'a -> 'b -> 'c -> unit = \"caml_js_set\"\n\n external delete : 'a -> 'b -> unit = \"caml_js_delete\"\n\n external call : 'a -> 'b -> any array -> 'c = \"caml_js_call\"\n\n external fun_call : 'a -> any array -> 'b = \"caml_js_fun_call\"\n\n external meth_call : 'a -> string -> any array -> 'b = \"caml_js_meth_call\"\n\n external new_obj : 'a -> any array -> 'b = \"caml_js_new\"\n\n external new_obj_arr : 'a -> any_js_array -> 'b = \"caml_ojs_new_arr\"\n\n external obj : (string * any) array -> 'a = \"caml_js_object\"\n\n external equals : 'a -> 'b -> bool = \"caml_js_equals\"\n\n external pure_expr : (unit -> 'a) -> 'a = \"caml_js_pure_expr\"\n\n external eval_string : string -> 'a = \"caml_js_eval_string\"\n\n external js_expr : string -> 'a = \"caml_js_expr\"\n\n external pure_js_expr : string -> 'a = \"caml_pure_js_expr\"\n\n let global = pure_js_expr \"globalThis\"\n\n external callback : ('a -> 'b) -> ('c, 'a -> 'b) meth_callback = \"%identity\"\n\n external callback_with_arguments :\n (any_js_array -> 'b) -> ('c, any_js_array -> 'b) meth_callback\n = \"caml_js_wrap_callback_arguments\"\n\n external callback_with_arity : int -> ('a -> 'b) -> ('c, 'a -> 'b) meth_callback\n = \"caml_js_wrap_callback_strict\"\n\n external meth_callback : ('b -> 'a) -> ('b, 'a) meth_callback\n = \"caml_js_wrap_meth_callback_unsafe\"\n\n external meth_callback_with_arity : int -> ('b -> 'a) -> ('b, 'a) meth_callback\n = \"caml_js_wrap_meth_callback_strict\"\n\n external meth_callback_with_arguments :\n ('b -> any_js_array -> 'a) -> ('b, any_js_array -> 'a) meth_callback\n = \"caml_js_wrap_meth_callback_arguments\"\n\n (* DEPRECATED *)\n external variable : string -> 'a = \"caml_js_var\"\n end\n\n (****)\n\n type 'a opt = 'a\n\n type 'a optdef = 'a\n\n external debugger : unit -> unit = \"debugger\"\n\n let null : 'a opt = Unsafe.pure_js_expr \"null\"\n\n external some : 'a -> 'a opt = \"%identity\"\n\n let undefined : 'a optdef = Unsafe.pure_js_expr \"undefined\"\n\n external def : 'a -> 'a optdef = \"%identity\"\n\n module type OPT = sig\n type 'a t\n\n val empty : 'a t\n\n val return : 'a -> 'a t\n\n val map : 'a t -> ('a -> 'b) -> 'b t\n\n val bind : 'a t -> ('a -> 'b t) -> 'b t\n\n val test : 'a t -> bool\n\n val iter : 'a t -> ('a -> unit) -> unit\n\n val case : 'a t -> (unit -> 'b) -> ('a -> 'b) -> 'b\n\n val get : 'a t -> (unit -> 'a) -> 'a\n\n val option : 'a option -> 'a t\n\n val to_option : 'a t -> 'a option\n end\n\n module Opt : OPT with type 'a t = 'a opt = struct\n type 'a t = 'a opt\n\n let empty = null\n\n let return = some\n\n let map x f = if Unsafe.equals x null then null else return (f x)\n\n let bind x f = if Unsafe.equals x null then null else f x\n\n let test x = not (Unsafe.equals x null)\n\n let iter x f = if not (Unsafe.equals x null) then f x\n\n let case x f g = if Unsafe.equals x null then f () else g x\n\n let get x f = if Unsafe.equals x null then f () else x\n\n let option x =\n match x with\n | None -> empty\n | Some x -> return x\n\n let to_option x = case x (fun () -> None) (fun x -> Some x)\n end\n\n module Optdef : OPT with type 'a t = 'a optdef = struct\n type 'a t = 'a optdef\n\n let empty = undefined\n\n let return = def\n\n let map x f = if x == undefined then undefined else return (f x)\n\n let bind x f = if x == undefined then undefined else f x\n\n let test x = x != undefined\n\n let iter x f = if x != undefined then f x\n\n let case x f g = if x == undefined then f () else g x\n\n let get x f = if x == undefined then f () else x\n\n let option x =\n match x with\n | None -> empty\n | Some x -> return x\n\n let to_option x = case x (fun () -> None) (fun x -> Some x)\n end\n\n (****)\n\n let coerce x f g = Opt.get (f x) (fun () -> g x)\n\n let coerce_opt x f g = Opt.get (Opt.bind x f) (fun () -> g x)\n\n (****)\n\n type +'a meth\n\n type +'a gen_prop\n\n type 'a readonly_prop = < get : 'a > gen_prop\n\n type 'a writeonly_prop = < set : 'a -> unit > gen_prop\n\n type 'a prop = < get : 'a ; set : 'a -> unit > gen_prop\n\n type 'a optdef_prop = < get : 'a optdef ; set : 'a -> unit > gen_prop\n\n type +'a constr\n\n (****)\n\n type 'a callback = (unit, 'a) meth_callback\n\n external wrap_callback : ('a -> 'b) -> ('c, 'a -> 'b) meth_callback\n = \"caml_js_wrap_callback\"\n\n external wrap_meth_callback : ('a -> 'b) -> ('a, 'b) meth_callback\n = \"caml_js_wrap_meth_callback\"\n\n (****)\n\n let _true = Unsafe.pure_js_expr \"true\"\n\n let _false = Unsafe.pure_js_expr \"false\"\n\n type match_result_handle\n\n type string_array\n\n class type js_string =\n object\n method toString : js_string t meth\n\n method valueOf : js_string t meth\n\n method charAt : int -> js_string t meth\n\n method charCodeAt : int -> float meth\n\n (* This may return NaN... *)\n method concat : js_string t -> js_string t meth\n\n method concat_2 : js_string t -> js_string t -> js_string t meth\n\n method concat_3 : js_string t -> js_string t -> js_string t -> js_string t meth\n\n method concat_4 :\n js_string t -> js_string t -> js_string t -> js_string t -> js_string t meth\n\n method indexOf : js_string t -> int meth\n\n method indexOf_from : js_string t -> int -> int meth\n\n method lastIndexOf : js_string t -> int meth\n\n method lastIndexOf_from : js_string t -> int -> int meth\n\n method localeCompare : js_string t -> float meth\n\n method _match : regExp t -> match_result_handle t opt meth\n\n method replace : regExp t -> js_string t -> js_string t meth\n\n method replace_string : js_string t -> js_string t -> js_string t meth\n\n method search : regExp t -> int meth\n\n method slice : int -> int -> js_string t meth\n\n method slice_end : int -> js_string t meth\n\n method split : js_string t -> string_array t meth\n\n method split_limited : js_string t -> int -> string_array t meth\n\n method split_regExp : regExp t -> string_array t meth\n\n method split_regExpLimited : regExp t -> int -> string_array t meth\n\n method substring : int -> int -> js_string t meth\n\n method substring_toEnd : int -> js_string t meth\n\n method toLowerCase : js_string t meth\n\n method toLocaleLowerCase : js_string t meth\n\n method toUpperCase : js_string t meth\n\n method toLocaleUpperCase : js_string t meth\n\n method trim : js_string t meth\n\n method length : int readonly_prop\n end\n\n and regExp =\n object\n method exec : js_string t -> match_result_handle t opt meth\n\n method test : js_string t -> bool t meth\n\n method toString : js_string t meth\n\n method source : js_string t readonly_prop\n\n method global : bool t readonly_prop\n\n method ignoreCase : bool t readonly_prop\n\n method multiline : bool t readonly_prop\n\n method lastIndex : int prop\n end\n\n (* string is used by ppx_js, it needs to come before any use of the\n new syntax in this file *)\n external string : string -> js_string t = \"caml_jsstring_of_string\"\n\n external to_string : js_string t -> string = \"caml_string_of_jsstring\"\nend\n\ninclude Js\n\nclass type string_constr =\n object\n method fromCharCode : int -> js_string t meth\n end\n\nlet string_constr = Unsafe.global##._String\n\nlet regExp = Unsafe.global##._RegExp\n\nlet regExp_copy = regExp\n\nlet regExp_withFlags = regExp\n\nclass type ['a] js_array =\n object\n method toString : js_string t meth\n\n method toLocaleString : js_string t meth\n\n method concat : 'a js_array t -> 'a js_array t meth\n\n method join : js_string t -> js_string t meth\n\n method pop : 'a optdef meth\n\n method push : 'a -> int meth\n\n method push_2 : 'a -> 'a -> int meth\n\n method push_3 : 'a -> 'a -> 'a -> int meth\n\n method push_4 : 'a -> 'a -> 'a -> 'a -> int meth\n\n method reverse : 'a js_array t meth\n\n method shift : 'a optdef meth\n\n method slice : int -> int -> 'a js_array t meth\n\n method slice_end : int -> 'a js_array t meth\n\n method sort : ('a -> 'a -> float) callback -> 'a js_array t meth\n\n method sort_asStrings : 'a js_array t meth\n\n method splice : int -> int -> 'a js_array t meth\n\n method splice_1 : int -> int -> 'a -> 'a js_array t meth\n\n method splice_2 : int -> int -> 'a -> 'a -> 'a js_array t meth\n\n method splice_3 : int -> int -> 'a -> 'a -> 'a -> 'a js_array t meth\n\n method splice_4 : int -> int -> 'a -> 'a -> 'a -> 'a -> 'a js_array t meth\n\n method unshift : 'a -> int meth\n\n method unshift_2 : 'a -> 'a -> int meth\n\n method unshift_3 : 'a -> 'a -> 'a -> int meth\n\n method unshift_4 : 'a -> 'a -> 'a -> 'a -> int meth\n\n method some : ('a -> int -> 'a js_array t -> bool t) callback -> bool t meth\n\n method every : ('a -> int -> 'a js_array t -> bool t) callback -> bool t meth\n\n method forEach : ('a -> int -> 'a js_array t -> unit) callback -> unit meth\n\n method map : ('a -> int -> 'a js_array t -> 'b) callback -> 'b js_array t meth\n\n method filter : ('a -> int -> 'a js_array t -> bool t) callback -> 'a js_array t meth\n\n method reduce_init :\n ('b -> 'a -> int -> 'a js_array t -> 'b) callback -> 'b -> 'b meth\n\n method reduce : ('a -> 'a -> int -> 'a js_array t -> 'a) callback -> 'a meth\n\n method reduceRight_init :\n ('b -> 'a -> int -> 'a js_array t -> 'b) callback -> 'b -> 'b meth\n\n method reduceRight : ('a -> 'a -> int -> 'a js_array t -> 'a) callback -> 'a meth\n\n method length : int prop\n end\n\nlet object_constructor = Unsafe.global##._Object\n\nlet object_keys o : js_string t js_array t = object_constructor##keys o\n\nlet array_constructor = Unsafe.global##._Array\n\nlet array_empty = array_constructor\n\nlet array_length = array_constructor\n\nlet array_get : 'a #js_array t -> int -> 'a optdef = Unsafe.get\n\nlet array_set : 'a #js_array t -> int -> 'a -> unit = Unsafe.set\n\nlet array_map_poly :\n 'a #js_array t -> ('a -> int -> 'a #js_array t -> 'b) callback -> 'b #js_array t =\n fun a cb -> (Unsafe.coerce a)##map cb\n\nlet array_map f a = array_map_poly a (wrap_callback (fun x _idx _ -> f x))\n\nlet array_mapi f a = array_map_poly a (wrap_callback (fun x idx _ -> f idx x))\n\nclass type match_result =\n object\n inherit [js_string t] js_array\n\n method index : int readonly_prop\n\n method input : js_string t readonly_prop\n end\n\nlet str_array : string_array t -> js_string t js_array t = Unsafe.coerce\n\nlet match_result : match_result_handle t -> match_result t = Unsafe.coerce\n\nclass type number =\n object\n method toString : js_string t meth\n\n method toString_radix : int -> js_string t meth\n\n method toLocaleString : js_string t meth\n\n method toFixed : int -> js_string t meth\n\n method toExponential : js_string t meth\n\n method toExponential_digits : int -> js_string t meth\n\n method toPrecision : int -> js_string t meth\n end\n\nexternal number_of_float : float -> number t = \"caml_js_from_float\"\n\nexternal float_of_number : number t -> float = \"caml_js_to_float\"\n\nclass type date =\n object\n method toString : js_string t meth\n\n method toDateString : js_string t meth\n\n method toTimeString : js_string t meth\n\n method toLocaleString : js_string t meth\n\n method toLocaleDateString : js_string t meth\n\n method toLocaleTimeString : js_string t meth\n\n method valueOf : float meth\n\n method getTime : float meth\n\n method getFullYear : int meth\n\n method getUTCFullYear : int meth\n\n method getMonth : int meth\n\n method getUTCMonth : int meth\n\n method getDate : int meth\n\n method getUTCDate : int meth\n\n method getDay : int meth\n\n method getUTCDay : int meth\n\n method getHours : int meth\n\n method getUTCHours : int meth\n\n method getMinutes : int meth\n\n method getUTCMinutes : int meth\n\n method getSeconds : int meth\n\n method getUTCSeconds : int meth\n\n method getMilliseconds : int meth\n\n method getUTCMilliseconds : int meth\n\n method getTimezoneOffset : int meth\n\n method setTime : float -> float meth\n\n method setFullYear : int -> float meth\n\n method setUTCFullYear : int -> float meth\n\n method setMonth : int -> float meth\n\n method setUTCMonth : int -> float meth\n\n method setDate : int -> float meth\n\n method setUTCDate : int -> float meth\n\n method setDay : int -> float meth\n\n method setUTCDay : int -> float meth\n\n method setHours : int -> float meth\n\n method setUTCHours : int -> float meth\n\n method setMinutes : int -> float meth\n\n method setUTCMinutes : int -> float meth\n\n method setSeconds : int -> float meth\n\n method setUTCSeconds : int -> float meth\n\n method setMilliseconds : int -> float meth\n\n method setUTCMilliseconds : int -> float meth\n\n method toUTCString : js_string t meth\n\n method toISOString : js_string t meth\n\n method toJSON : 'a -> js_string t meth\n end\n\nclass type date_constr =\n object\n method parse : js_string t -> float meth\n\n method _UTC_month : int -> int -> float meth\n\n method _UTC_day : int -> int -> float meth\n\n method _UTC_hour : int -> int -> int -> int -> float meth\n\n method _UTC_min : int -> int -> int -> int -> int -> float meth\n\n method _UTC_sec : int -> int -> int -> int -> int -> int -> float meth\n\n method _UTC_ms : int -> int -> int -> int -> int -> int -> int -> float meth\n\n method now : float meth\n end\n\nlet date_constr = Unsafe.global##._Date\n\nlet date : date_constr t = date_constr\n\nlet date_now : date t constr = date_constr\n\nlet date_fromTimeValue : (float -> date t) constr = date_constr\n\nlet date_month : (int -> int -> date t) constr = date_constr\n\nlet date_day : (int -> int -> int -> date t) constr = date_constr\n\nlet date_hour : (int -> int -> int -> int -> date t) constr = date_constr\n\nlet date_min : (int -> int -> int -> int -> int -> date t) constr = date_constr\n\nlet date_sec : (int -> int -> int -> int -> int -> int -> date t) constr = date_constr\n\nlet date_ms : (int -> int -> int -> int -> int -> int -> int -> date t) constr =\n date_constr\n\nclass type math =\n object\n method _E : float readonly_prop\n\n method _LN2 : float readonly_prop\n\n method _LN10 : float readonly_prop\n\n method _LOG2E : float readonly_prop\n\n method _LOG10E : float readonly_prop\n\n method _PI : float readonly_prop\n\n method _SQRT1_2_ : float readonly_prop\n\n method _SQRT2 : float readonly_prop\n\n method abs : float -> float meth\n\n method acos : float -> float meth\n\n method asin : float -> float meth\n\n method atan : float -> float meth\n\n method atan2 : float -> float -> float meth\n\n method ceil : float -> float meth\n\n method cos : float -> float meth\n\n method exp : float -> float meth\n\n method floor : float -> float meth\n\n method log : float -> float meth\n\n method max : float -> float -> float meth\n\n method max_3 : float -> float -> float -> float meth\n\n method max_4 : float -> float -> float -> float -> float meth\n\n method min : float -> float -> float meth\n\n method min_3 : float -> float -> float -> float meth\n\n method min_4 : float -> float -> float -> float -> float meth\n\n method pow : float -> float -> float meth\n\n method random : float meth\n\n method round : float -> float meth\n\n method sin : float -> float meth\n\n method sqrt : float -> float meth\n\n method tan : float -> float meth\n end\n\nlet math = Unsafe.global##._Math\n\nclass type error =\n object\n method name : js_string t prop\n\n method message : js_string t prop\n\n method stack : js_string t optdef prop\n\n method toString : js_string t meth\n end\n\nlet error_constr = Unsafe.global##._Error\n\nmodule Js_error = struct\n type error_t = error t\n\n include Jsoo_runtime.Error\n\n external of_error : error_t -> t = \"%identity\"\n\n external to_error : t -> error_t = \"%identity\"\n\n let name e = to_string (to_error e)##.name\n\n let message e = to_string (to_error e)##.message\n\n let stack (e : t) : string option =\n Opt.to_option (Opt.map (to_error e)##.stack to_string)\n\n let to_string e = to_string (to_error e)##toString\nend\n\nmodule Magic = struct\n module type T = sig\n exception Error of error t\n end\n\n type ('a, 'b) eq = Eq : ('a, 'a) eq\n\n let (eq : (error t, Js_error.t) eq) = Obj.magic Eq\n\n let m =\n match eq with\n | Eq ->\n (module struct\n exception Error = Js_error.Exn\n end : T)\n\n module Error = (val m : T)\nend\n\ninclude Magic.Error\n\nlet raise_js_error e = Js_error.raise_ (Js_error.of_error e)\n\nlet string_of_error e = Js_error.to_string (Js_error.of_error e)\n\nlet exn_with_js_backtrace = Js_error.attach_js_backtrace\n\nexternal js_error_of_exn : exn -> error t opt = \"caml_js_error_of_exception\"\n\nclass type json =\n object\n method parse : js_string t -> 'a meth\n\n method stringify : 'a -> js_string t meth\n end\n\nlet _JSON : json t = Unsafe.global##._JSON\n\nlet decodeURI (s : js_string t) : js_string t =\n Unsafe.fun_call Unsafe.global##.decodeURI [| Unsafe.inject s |]\n\nlet decodeURIComponent (s : js_string t) : js_string t =\n Unsafe.fun_call Unsafe.global##.decodeURIComponent [| Unsafe.inject s |]\n\nlet encodeURI (s : js_string t) : js_string t =\n Unsafe.fun_call Unsafe.global##.encodeURI [| Unsafe.inject s |]\n\nlet encodeURIComponent (s : js_string t) : js_string t =\n Unsafe.fun_call Unsafe.global##.encodeURIComponent [| Unsafe.inject s |]\n\nlet escape (s : js_string t) : js_string t =\n Unsafe.fun_call Unsafe.global##.escape [| Unsafe.inject s |]\n\nlet unescape (s : js_string t) : js_string t =\n Unsafe.fun_call Unsafe.global##.unescape [| Unsafe.inject s |]\n\nexternal bool : bool -> bool t = \"caml_js_from_bool\"\n\nexternal to_bool : bool t -> bool = \"caml_js_to_bool\"\n\nexternal array : 'a array -> 'a js_array t = \"caml_js_from_array\"\n\nexternal to_array : 'a js_array t -> 'a array = \"caml_js_to_array\"\n\nexternal bytestring : string -> js_string t = \"caml_jsbytes_of_string\"\n\nexternal to_bytestring : js_string t -> string = \"caml_string_of_jsbytes\"\n\nexternal typeof : _ t -> js_string t = \"caml_js_typeof\"\n\nexternal instanceof : _ t -> _ constr -> bool = \"caml_js_instanceof\"\n\nlet isNaN (i : 'a) : bool =\n to_bool (Unsafe.fun_call Unsafe.global##.isNaN [| Unsafe.inject i |])\n\nlet parseInt (s : js_string t) : int =\n let s = Unsafe.fun_call Unsafe.global##.parseInt [| Unsafe.inject s |] in\n if isNaN s then failwith \"parseInt\" else s\n\nlet parseFloat (s : js_string t) : float =\n let s = Unsafe.fun_call Unsafe.global##.parseFloat [| Unsafe.inject s |] in\n if isNaN s then failwith \"parseFloat\" else s\n\nlet _ =\n Printexc.register_printer (function\n | Js_error.Exn e -> Some (Js_error.to_string e)\n | _ -> None)\n\nlet _ =\n Printexc.register_printer (fun e ->\n let e : < .. > t = Obj.magic e in\n if instanceof e array_constructor then None else Some (to_string e##toString))\n\nlet export_js (field : js_string t) x =\n Unsafe.set (Unsafe.pure_js_expr \"jsoo_exports\") field x\n\nlet export field x = export_js (string field) x\n\nlet export_all obj =\n let keys = object_keys obj in\n keys##forEach\n (wrap_callback (fun (key : js_string t) _ _ -> export_js key (Unsafe.get obj key)))\n\n(****)\n\n(* DEPRECATED *)\n\ntype float_prop = float prop\n\nexternal float : float -> float = \"%identity\"\n\nexternal to_float : float -> float = \"%identity\"\n","open Core_kernel\nmodule Js = Js_of_ocaml.Js\n\nlet _console_log_string s = Js_of_ocaml.Firebug.console##log (Js.string s)\n\nlet _console_log s = Js_of_ocaml.Firebug.console##log s\n\nlet _console_dir s : unit =\n let f =\n Js.Unsafe.eval_string {js|(function(s) { console.dir(s, {depth: 5}); })|js}\n in\n Js.Unsafe.(fun_call f [| inject s |])\n\nlet raise_error s =\n Js.Js_error.(raise_ @@ of_error (new%js Js.error_constr (Js.string s)))\n\nexternal raise_exn_js : exn -> Js.js_string Js.t -> 'a = \"custom_reraise_exn\"\n\nlet raise_exn exn = raise_exn_js exn (Js.string (Exn.to_string exn))\n\nlet json_parse (str : Js.js_string Js.t) =\n Js.Unsafe.(fun_call global ##. JSON##.parse [| inject str |])\n","module Js = Js_of_ocaml.Js\n\nlet export () =\n Js.export \"Snarky\" Snarky_bindings.snarky ;\n Js.export \"Ledger\" Local_ledger.ledger_class ;\n Js.export \"Pickles\" Pickles_bindings.pickles ;\n Js.export \"Test\" Consistency_test.test\n\nlet export_global () =\n let snarky_obj =\n Js.Unsafe.(\n let i = inject in\n obj\n [| (\"Snarky\", i Snarky_bindings.snarky)\n ; (\"Ledger\", i Local_ledger.ledger_class)\n ; (\"Pickles\", i Pickles_bindings.pickles)\n ; (\"Test\", i Consistency_test.test)\n |])\n in\n Js.Unsafe.(set global (Js.string \"__snarky\") snarky_obj)\n","let () = Snarky_js_bindings_lib.export_global ()\n\nlet () = Snarky_js_bindings_lib.export ()\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* Ensure that [at_exit] functions are called at the end of every program *)\n\nlet _ = do_at_exit()\n"]} \ No newline at end of file +{"version":3.0,"file":"snarky_js_node.bc.js","sourceRoot":"","names":["Object","globalThis","this","get","_T_","global","self","DefaultLocale","defaultStrftime","Strftime","isCommonJS","module","namespace","adaptedStrftime","deprecatedStrftime","joo_global_object","eval","_require","_deprecationWarnings","deprecationWarning","name","instead","console","deprecatedStrftimeTZ","deprecatedStrftimeUTC","deprecatedStrftimeLocalized","adaptForwards","fn","fmt","d","locale","undefined","strftime","timezone","null","utcStrftime","Date","customTimezoneOffset","useUtcTimezone","_locale","_customTimezoneOffset","_useUtcBasedDate","_cachedDateTimestamp","_cachedDate","_strftime","format","date","timestamp","currentTimestamp","getTimestampToUtcOffsetFor","_processFormat","resultString","padding","isInScope","length","extendedTZ","i","currentCharCode","padTill2","Math","hours12","padTill3","weekNumber","tzString","y","day","String","ordinal","off","sign","sep","hours","mins","useUtcBasedDate","timezoneType","parseInt","minutes","numberToPad","paddingChar","hour","firstWeekday","weekday","firstDayOfYearUtc","dateUtc","yday","weekNum","number","ii","Base_am_testing","x","caml_mul","a","b","caml_hash_mix_int","h","caml_hash_mix_jsbytes","s","len","w","log2_ok","jsoo_floor_log2","Infinity","caml_int64_offset","caml_raise_constant","tag","caml_global_data","caml_raise_zero_divide","MlInt64","lo","mi","hi","xhi","offset","modulus","divisor","quotient","q","r","caml_int64_create_lo_mi_hi","caml_int64_bits_of_float","isFinite","isNaN","exp","k","r3","r2","r1","caml_int64_lo32","v","caml_int64_hi32","caml_hash_mix_int64","caml_hash_mix_float","v0","caml_str_repeat","n","l","caml_subarray_to_jsbytes","f","caml_convert_string_to_bytes","caml_jsbytes_of_string","caml_hash_mix_string","caml_hash_mix_bytes_arr","jsoo_is_ascii","caml_utf16_of_utf8","t","c","c1","c2","j","MlBytes","contents","content","caml_ml_bytes_content","caml_hash_mix_bytes","caml_int32_bits_of_float","float32a","int32a","caml_int64_to_bytes","caml_ba_serialize","writer","ba","sz","complex","caml_raise_with_string","msg","caml_invalid_argument","caml_ba_get_size_per_element","kind","caml_ba_create_buffer","size","g","view","data","caml_int32_float_of_bits","caml_int64_of_bytes","caml_int64_float_of_bits","NaN","res","caml_ba_get_size","dims","n_dims","caml_int64_create_lo_hi","caml_array_bound_error","caml_ba_custom_name","Ml_Bigarray","layout","buffer","arg","ofs","Array","im","re","total","k1","k2","Ml_Bigarray_c_1_1","caml_ba_create_unsafe","size_per_element","caml_bytes_of_jsbytes","caml_string_of_jsbytes","caml_failwith","caml_ba_deserialize","reader","num_dims","size_dim","size_dim_hi","size_dim_lo","sixty","int64","caml_ba_compare","caml_ba_hash","num_elts","caml_int32_unmarshal","caml_nativeint_unmarshal","caml_int64_unmarshal","caml_int64_marshal","sizes","caml_int64_compare","caml_int64_hash","caml_custom_ops","caml_hash_mix_final","caml_is_ml_bytes","caml_is_ml_string","caml_hash","count","limit","seed","obj","queue","rd","wr","num","hh","Base_hash_double","Base_hash_string","Base_int_math_int32_clz","Base_int_math_int32_ctz","caml_int64_shift_right_unsigned","caml_int64_is_zero","caml_int64_to_int32","Base_int_math_int64_clz","caml_int64_and","caml_int64_of_int32","Base_int_math_int64_ctz","is_zero","land","small_int64","caml_int64_mul","Base_int_math_int64_pow_stub","base","exponent","one","mul","Base_int_math_int_clz","Base_int_math_int_ctz","Base_int_math_int_popcount","Base_int_math_int_pow_stub","Base_int_math_nativeint_clz","Base_int_math_nativeint_ctz","Base_internalhash_fold_float","Base_internalhash_fold_int","Base_internalhash_fold_int64","Base_internalhash_fold_string","Base_internalhash_get_hash_value","incr_nat","nat","carry_in","carry","add_nat","nat1","ofs1","len1","nat2","ofs2","len2","caml_js_from_array","caml_ba_create","dims_ml","bigstring_alloc","_","caml_ml_bytes_length","caml_convert_bytes_to_array","caml_blit_bytes","s1","i1","s2","i2","caml_bytes_of_array","caml_bigstring_blit_ba_to_bytes","ba1","pos1","bytes2","pos2","slice","bigstring_blit_bigstring_bytes_stub","src","src_pos","dst","dst_pos","caml_array_of_bytes","caml_bigstring_blit_bytes_to_ba","str1","ba2","bigstring_blit_bytes_bigstring_stub","caml_ml_string_length","caml_bytes_unsafe_get","caml_string_unsafe_get","caml_array_of_string","caml_bigstring_blit_string_to_ba","bigstring_blit_string_bigstring_stub","caml_bigstring_blit_ba_to_ba","bigstring_blit_stub","caml_bytes_unsafe_set","caml_string_unsafe_set","caml_ba_get_1","i0","bigstringaf_blit_to_bytes","src_off","dst_off","bin_prot_blit_buf_bytes_stub","caml_check_bound","array","index","caml_check_bound_bigstring","bigstring","bin_prot_blit_buf_float_array_stub","bin_prot_blit_float_array_buf_stub","float64","float64_uint8","bin_prot_blit_string_buf_stub","blit_nat","caml_array_append","a1","a2","l1","l2","caml_array_blit","caml_array_concat","caml_array_fill","caml_array_set","newval","caml_array_sub","caml_ba_blit","caml_ba_dim","caml_ba_dim_1","caml_ba_dim_2","caml_ba_get_2","caml_ba_layout","caml_ba_set_1","caml_ba_set_2","caml_ba_sub","changed_dim","new_dims","new_data","caml_ba_uint8_get16","b1","b2","caml_ba_uint8_get32","b3","b4","caml_ba_uint8_get64","b5","b6","b7","b8","caml_ba_uint8_set16","caml_ba_uint8_set32","caml_ba_uint8_set64","caml_backtrace_status","plonk_wasm","require","caml_bigint_256_bytes_per_limb","caml_bigint_256_compare","caml_bigint_256_div","caml_bigint_256_num_limbs","caml_bytes_to_uint8array","ocaml_bytes","bytes","caml_bigint_256_of_bytes","caml_jsstring_of_string","caml_bigint_256_of_decimal_string","caml_bigint_256_of_numeral","caml_bigint_256_print","caml_js_to_bool","caml_bigint_256_test_bit","caml_create_bytes","caml_bytes_of_uint8array","uint8array","caml_bigint_256_to_bytes","caml_utf8_of_utf16","caml_bytes_of_utf16_jsstring","caml_string_of_jsstring","caml_bigint_256_to_string","caml_bytes_of_string","caml_blit_string","e","caml_bswap16","caml_bytes_bound_error","caml_bytes_get","caml_bytes_get16","caml_bytes_set","caml_bytes_set16","i16","caml_bytes_set32","i32","caml_bytes_set64","i64","caml_call_gen","args","argsLen","extra_args","arguments","nargs","caml_classify_float","caml_compare_val_get_custom","caml_compare_val_number_custom","custom","swap","comp","caml_compare_val_tag","Number","caml_int_compare","caml_bytes_compare","caml_string_compare","caml_compare_val","stack","tag_a","tag_b","caml_compare","caml_convert_raw_backtrace","caml_convert_raw_backtrace_slot","caml_div","caml_ephe_key_offset","caml_weak_create","caml_ephe_create","caml_ephe_data_offset","caml_ephe_get_data","caml_ephe_set_data","caml_weak_set","caml_ephe_set_key","caml_equal","caml_fill_bytes","caml_final_register","caml_float_compare","caml_float_of_string","m","m3","mantissa","caml_parse_format","caml_finish_formatting","rawbuffer","caml_format_float","toFixed","dp","prec","p","caml_format_int","rust_affine_to_caml_affine","pt","infinity","js_class_vector_of_rust_vector","klass","pos","caml_array_of_rust_vector","convert","should_free","rust_val","caml_poly_comm_of_rust_poly_comm","poly_comm","rust_shifted","rust_unshifted","caml_shifted","caml_unshifted","caml_vesta_poly_comm_of_rust","caml_u8array_vector_to_rust_flat_vector","inner_len","caml_fp_srs_b_poly_commitment","srs","chals","rust_affine_of_caml_affine","js_class_vector_to_rust_vector","free_finalization_registry","instance_representative","caml_array_to_rust_vector","mk_new","class_val","caml_fp_vector_to_rust","caml_fp_srs_batch_accumulator_check","comms","rust_comms","rust_chals","ok","caml_fp_srs_batch_accumulator_generate","free_on_finalize","caml_fp_srs_create","caml_fp_srs_h","caml_fp_srs_lagrange_commitment","domain_size","caml_fp_srs_read","path","caml_fp_srs_write","append","caml_fp_vector_create","caml_fp_vector_emplace_back","caml_fp_vector_get","value","Error","caml_fp_vector_length","caml_fq_srs_add_lagrange_basis","log2_size","caml_pallas_poly_comm_of_rust","caml_fq_srs_b_poly_commitment","caml_fq_srs_create","caml_fq_srs_h","caml_fq_srs_lagrange_commitment","caml_fq_srs_read","caml_fq_srs_write","caml_fq_vector_create","caml_fq_vector_emplace_back","caml_fq_vector_get","caml_fq_vector_length","caml_oo_last_id","caml_fresh_oo_id","caml_frexp_float","neg","fs_node_supported","make_path_is_absolute","posix","win32","splitDeviceRe","result","device","isUnc","Boolean","root","path_is_absolute","caml_trailing_slash","caml_current_dir","caml_make_path","comp0","ncomp","unix_error","make_unix_err_args","code","syscall","errno","variant","caml_named_values","caml_named_value","nm","caml_raise_with_args","caml_raise_sys_error","caml_raise_no_such_file","MlFile","MlFakeFile","old","buf","clen","new_str","old_data","MlFakeDevice","Symbol","name_slash","mode","raise_unix","parent","RegExp","seen","file","MlNodeFile","fd","err","buf_offset","MlNodeDevice","consts","key","o","js_stats","to_dir","target","link","file_kind","caml_get_root","caml_root","jsoo_mount_point","resolve_fs_device","caml_create_file","jsoo_create_file","caml_fs_init","tmp","caml_gc_quick_stat","caml_get_current_callstack","caml_get_exception_raw_backtrace","caml_method_cache","caml_get_public_method","cacheid","meths","li","caml_greaterequal","caml_greaterthan","caml_hexstring_of_float","style","exp_sign","sign_str","cst","x_str","idx","caml_marshal_data_size","get32","MlStringReader","caml_float_of_bytes","caml_input_value_from_reader","_magic","_block_len","num_objects","_size_32","_size_64","intern_obj_table","obj_counter","intern_rec","header","ops","expected_size","old_pos","caml_string_of_bytes","caml_input_value_from_bytes","caml_ml_channels","caml_input_value","chanid","chan","caml_int32_bswap","caml_int64_add","caml_int64_bswap","caml_int64_div","caml_int64_is_negative","caml_int64_neg","caml_int64_format","wbase","cvtbl","caml_int64_mod","caml_int64_of_float","caml_int64_ult","caml_parse_sign_and_base","caml_parse_digit","caml_int64_of_string","base64","threshold","caml_int64_or","caml_int64_shift_left","caml_int64_shift_right","caml_int64_sub","caml_int64_to_float","caml_int64_xor","caml_int_of_string","caml_js_eval_string","caml_js_wrap_callback","caml_js_wrap_meth_callback","caml_lazy_make_forward","caml_ldexp_float","caml_lessequal","caml_lessthan","caml_lex_array","caml_lex_engine","tbl","start_state","lexbuf","lex_buffer","lex_buffer_len","lex_start_pos","lex_curr_pos","lex_last_pos","lex_last_action","lex_eof_reached","lex_base","lex_backtrk","lex_default","lex_trans","lex_check","state","backtrk","caml_list_of_js_array","caml_log10_float","caml_make_float_vect","caml_make_vect","init","caml_string_of_array","caml_md5_bytes","add","xx","ff","gg","md5","caml_md5_string","caml_ml_channel_size","caml_ml_channel_size_64","caml_sys_close","caml_ml_flush","output","caml_ml_close_channel","caml_ml_debug_info_status","caml_ml_refill_input","str","str_len","caml_ml_input","caml_ml_may_refill_input","caml_raise_end_of_file","caml_ml_input_char","caml_ml_input_int","caml_std_output","slen","js_print_stderr","js_print_stdout","caml_sys_open_internal","flags","info","caml_sys_open","_perms","caml_ml_open_descriptor_in","refill","fs","channel","caml_ml_open_descriptor_out","caml_ml_out_channels_list","caml_ml_output_bytes","string","jsstring","id","caml_ml_output","caml_ml_output_char","caml_ml_output_int","arr","caml_ml_pos_in","caml_ml_pos_in_64","caml_ml_pos_out","caml_ml_pos_out_64","caml_ml_seek_in","caml_ml_seek_in_64","caml_ml_seek_out","caml_ml_seek_out_64","caml_ml_set_binary_mode","caml_ml_set_channel_name","caml_mod","caml_modf_float","caml_lex_run_mem","mem","curr_pos","caml_lex_run_tag","caml_new_lex_engine","lex_mem","lex_base_code","lex_backtrk_code","lex_default_code","lex_trans_code","lex_check_code","lex_code","pc_off","pstate","base_code","caml_notequal","caml_obj_block","caml_obj_make_forward","caml_obj_tag","Function","caml_out_channel_pos_fd","MlObjectTable","NaiveLookup","objs","caml_list_to_js_array","caml_legacy_custom_code","caml_output_val","Writer","no_sharing","closures","memo","existing_offset","extern_rec","sz_32_64","header_pos","type_of_v","caml_output_value_to_buffer","caml_pallas_add","caml_pallas_double","caml_pallas_endo_base","caml_pallas_endo_scalar","caml_pallas_negate","caml_pallas_of_affine_coordinates","caml_pallas_one","caml_pallas_random","caml_pallas_scale","caml_pallas_sub","caml_pallas_to_affine","caml_pasta_fp_add","caml_pasta_fp_copy","caml_pasta_fp_div","caml_pasta_fp_domain_generator","caml_pasta_fp_equal","caml_option_of_maybe_undefined","caml_pasta_fp_inv","caml_pasta_fp_is_square","caml_pasta_fp_mul","caml_pasta_fp_mut_add","caml_pasta_fp_mut_mul","caml_pasta_fp_square","caml_pasta_fp_mut_square","caml_pasta_fp_sub","caml_pasta_fp_mut_sub","caml_pasta_fp_negate","caml_pasta_fp_of_bigint","caml_pasta_fp_of_bytes","caml_pasta_fp_of_int","caml_pasta_fp_of_string","caml_pasta_fp_plonk_circuit_serialize","public_input_size","gate_vector","caml_plonk_wire_to_rust","wire","caml_plonk_wires_to_rust","wires","caml_fp_plonk_gate_to_rust","gate","caml_pasta_fp_plonk_gate_vector_add","caml_pasta_fp_plonk_gate_vector_create","caml_pasta_fp_plonk_gate_vector_digest","caml_plonk_wire_of_rust","caml_plonk_wires_of_rust","caml_u8array_vector_of_rust_flat_vector","output_len","inner_res","caml_plonk_gate_of_rust","caml_pasta_fp_plonk_gate_vector_get","caml_pasta_fp_plonk_gate_vector_len","caml_pasta_fp_plonk_gate_vector_wrap","caml_get_field_of_caml_record","caml_record","caml_fp_runtime_table_cfg_to_rust","caml_runtime_table_cfg","mk_class","caml_runtime_table_cfg_id","caml_runtime_table_cfg_first_column","caml_create_rust_empty_vector","caml_is_empty_caml_array","caml_array","caml_pasta_fp_plonk_index_create","gates","public_inputs","caml_runtime_table_cfgs","prev_challenges","urs","wasm_runtime_table_cfgs","caml_pasta_fp_plonk_index_read","caml_pasta_fp_plonk_index_write","caml_poly_comm_to_rust_poly_comm","poly_comm_class","mk_affine","caml_vesta_poly_comm_to_rust","caml_plonk_domain_to_rust","caml_plonk_verification_evals_to_rust","convertArray","sigma_comm","coefficients_comm","generic_comm","psm_comm","complete_add_comm","mul_comm","emul_comm","endomul_scalar_comm","caml_plonk_verification_shifts_to_rust","caml_plonk_verifier_index_to_rust","domain_class","verification_evals_class","verification_shifts_class","domain","max_poly_size","public_","evals","shifts","caml_pasta_fp_plonk_verifier_index_to_rust","caml_pasta_fp_commitments_to_rust","w_comm","z_comm","t_comm","caml_pasta_fp_opening_proof_to_rust","convert_affines","affines","lr","delta","z1","z2","sg","l_ocaml","r_ocaml","PERMUTS_MINUS_1","COLUMNS","caml_pasta_fp_proof_evaluations_to_rust","caml_pasta_fp_proof_to_rust","commitments","proof","ft_eval1","chals_len","prev_challenges_scalars","prev_challenges_comms","caml_pasta_fp_plonk_proof_batch_verify","indexes","proofs","caml_pasta_fp_commitments_of_rust","caml_pasta_fp_opening_proof_of_rust","tuple","caml_fp_vector_of_rust","caml_pasta_fp_proof_evaluations_of_rust","caml_pasta_fp_proof_of_rust","messages","caml_pasta_fp_plonk_proof_create","witness_cols","prev_sgs","caml_pasta_fp_plonk_proof_create_and_verify","caml_pasta_fp_plonk_proof_example_with_ffadd","caml_pasta_fp_plonk_proof_example_with_lookup","caml_pasta_fp_plonk_proof_example_with_range_check","caml_pasta_fp_plonk_proof_example_with_range_check0","caml_pasta_fp_plonk_proof_example_with_rot","caml_pasta_fp_plonk_proof_example_with_xor","caml_pasta_fp_plonk_proof_verify","column_of_rust","col","gate_type","variable_of_rust","variable","row","polish_token_of_rust","token","wrap","ptr","index_term_of_rust","term","token_class","column","coefficient","linearization_of_rust","linearization","affine_class","F","WasmPolishToken","WasmIndexTerm","constant_term","index_terms","wasmIndexTerm","caml_plonk_domain_of_rust","log_size_of_group","group_gen","caml_plonk_verification_evals_of_rust","affine_klass","caml_plonk_verification_shifts_of_rust","None","caml_plonk_verifier_index_of_rust","lookup_index","caml_pasta_fp_plonk_verifier_index_of_rust","caml_pasta_fp_plonk_verifier_index_create","vk","vk_caml","caml_pasta_fp_plonk_verifier_index_read","caml_pasta_fp_plonk_verifier_index_shifts","caml_pasta_fp_plonk_verifier_index_write","caml_pasta_fp_poseidon_block_cipher","_fake_params","fp_vector","wasm_flat_vector","new_fp_vector","caml_pasta_fp_poseidon_params_create","caml_pasta_fp_print","caml_pasta_fp_random","caml_pasta_fp_rng","caml_pasta_fp_size","caml_pasta_fp_size_in_bits","caml_pasta_fp_sqrt","caml_pasta_fp_to_bigint","caml_pasta_fp_to_bytes","caml_pasta_fp_to_string","caml_pasta_fp_two_adic_root_of_unity","caml_pasta_fq_add","caml_pasta_fq_copy","caml_pasta_fq_div","caml_pasta_fq_domain_generator","caml_pasta_fq_equal","caml_pasta_fq_inv","caml_pasta_fq_is_square","caml_pasta_fq_mul","caml_pasta_fq_mut_add","caml_pasta_fq_mut_mul","caml_pasta_fq_square","caml_pasta_fq_mut_square","caml_pasta_fq_sub","caml_pasta_fq_mut_sub","caml_pasta_fq_negate","caml_pasta_fq_of_bigint","caml_pasta_fq_of_bytes","caml_pasta_fq_of_int","caml_pasta_fq_of_string","caml_pasta_fq_plonk_circuit_serialize","caml_fq_plonk_gate_to_rust","caml_pasta_fq_plonk_gate_vector_add","caml_pasta_fq_plonk_gate_vector_create","caml_pasta_fq_plonk_gate_vector_digest","caml_pasta_fq_plonk_gate_vector_get","caml_pasta_fq_plonk_gate_vector_len","caml_pasta_fq_plonk_gate_vector_wrap","caml_fq_vector_to_rust","caml_fq_runtime_table_cfg_to_rust","caml_pasta_fq_plonk_index_create","caml_pasta_fq_plonk_index_domain_d1_size","caml_pasta_fq_plonk_index_read","caml_pasta_fq_plonk_index_write","caml_pallas_poly_comm_to_rust","caml_pasta_fq_plonk_verifier_index_to_rust","caml_pasta_fq_commitments_to_rust","caml_pasta_fq_opening_proof_to_rust","caml_pasta_fq_proof_evaluations_to_rust","caml_pasta_fq_proof_to_rust","caml_pasta_fq_plonk_proof_batch_verify","caml_pasta_fq_commitments_of_rust","caml_pasta_fq_opening_proof_of_rust","caml_fq_vector_of_rust","caml_pasta_fq_proof_evaluations_of_rust","caml_pasta_fq_proof_of_rust","evals1","caml_pasta_fq_plonk_proof_create","caml_pasta_fq_plonk_proof_verify","caml_pasta_fq_plonk_verifier_index_of_rust","caml_pasta_fq_plonk_verifier_index_create","caml_pasta_fq_plonk_verifier_index_shifts","caml_pasta_fq_print","caml_pasta_fq_random","caml_pasta_fq_rng","caml_pasta_fq_size","caml_pasta_fq_size_in_bits","caml_pasta_fq_sqrt","caml_pasta_fq_to_bigint","caml_pasta_fq_to_bytes","caml_pasta_fq_to_string","caml_pasta_fq_two_adic_root_of_unity","caml_raw_backtrace_slot","caml_record_backtrace","caml_register_global","name_opt","caml_register_named_value","caml_restore_raw_backtrace","exn","bt","caml_set_oo_id","caml_bytes_equal","caml_string_equal","caml_string_bound_error","caml_string_get","caml_string_get16","caml_string_get32","caml_string_get64","caml_bytes_lessequal","caml_string_lessequal","caml_string_greaterequal","caml_bytes_lessthan","caml_string_lessthan","caml_string_greaterthan","caml_string_notequal","caml_argv","main","argv","args2","caml_sys_argv","caml_sys_const_max_wosize","os_type","caml_sys_const_ostype_cygwin","caml_sys_const_ostype_win32","caml_executable_name","caml_sys_executable_name","caml_sys_exit","caml_sys_file_exists","caml_sys_get_config","caml_sys_getcwd","caml_raise_not_found","caml_sys_getenv","caml_sys_isatty","_chan","caml_sys_random_seed","buff","now","caml_sys_remove","caml_sys_system_command","cmd","caml_trampoline","caml_trampoline_return","caml_update_dummy","caml_vesta_add","caml_vesta_double","caml_vesta_endo_base","caml_vesta_endo_scalar","caml_vesta_negate","caml_vesta_of_affine_coordinates","caml_vesta_one","caml_vesta_random","caml_vesta_scale","caml_vesta_sub","caml_vesta_to_affine","caml_return_exn_constant","caml_wrap_exception","num_digits_nat","compare_nat","core_array_unsafe_float_blit","core_array_unsafe_int_blit","core_kernel_gc_minor_words","core_kernel_time_ns_format","time","formatjs","jstring","caml_md5_chan","chan_len","core_md5_fd","ic","MlNat","create_nat","custom_reraise_exn","fallbackMessage","decr_nat","borrow","deferred_bind","deferred","func","newDeferred","anotherDeferred","deferred_map","deferred_return","Promise","deferred_run","deferred_to_promise","deferred_upon_exn","div_helper","z","div_digit_nat","natq","ofsq","natr","ofsr","rem","num_leading_zero_bits_in_digit","shift_left_nat","nbits","shift_right_nat","set_to_zero_nat","nat_of_array","mult_digit_nat","nat3","ofs3","x1","x2","x3","sub_nat","div_nat","quo","expect_test_collector_saved_stderr","expect_test_collector_saved_stdout","expect_test_collector_after_test","vstdout","vstderr","expect_test_collector_before_test","voutput","caml_random_oracles_of_rust","joint_combiner_chal","joint_combiner","joint_combiner_ocaml","caml_oracles_of_rust","fp_oracles_create","lgr_comm","verifier_index","fq_oracles_create","serialize_nat","deserialize_nat","caml_hash_nat","initialize_nat","integers_int32_of_uint32","integers_size_t_size","unit","integers_uint_of_string","max_val","negative","no_digits","ten","max_base_10","UInt32","integers_uint32_of_int64","integers_uint32_of_string","integers_uint16_of_string","integers_uint32_add","integers_uint32_div","integers_uint32_logand","integers_uint32_logor","integers_uint32_logxor","integers_uint32_max","integers_uint32_to_int64","integers_uint32_mul","x_64","y_64","integers_uint32_of_int","integers_uint32_of_int32","integers_uint32_rem","integers_uint32_shift_left","integers_uint32_shift_right","integers_uint32_sub","integers_uint32_to_int","caml_new_string","integers_uint32_to_string","UInt64","integers_uint64_add","integers_uint64_div","integers_uint64_logand","integers_uint64_logor","integers_uint64_logxor","integers_uint64_max","integers_uint64_mul","integers_uint64_of_int","integers_uint64_of_int64","integers_uint64_of_string","integers_uint64_of_uint32","integers_uint64_rem","integers_uint64_shift_left","integers_uint64_shift_right","integers_uint64_sub","integers_uint64_to_int","integers_uint64_to_int64","integers_uint64_to_string","integers_uint8_of_string","integers_uint_size","integers_ulong_size","integers_ulonglong_size","integers_uint8_deserialize","integers_uint16_deserialize","integers_uint32_serialize","integers_uint32_deserialize","integers_uint32_hash","integers_uint32_compare","integers_uint64_compare","integers_uint64_hash","integers_uint64_marshal","integers_uint64_unmarshal","integers_unsigned_init","integers_ushort_size","is_digit_int","is_digit_zero","land_digit_nat","lor_digit_nat","bigInt","BASE","LOG_BASE","MAX_INT","MAX_INT_ARR","smallToArray","DEFAULT_ALPHABET","BigInt","supportsNativeBigInt","Integer","radix","alphabet","caseSensitive","parseValue","parseBase","BigInteger","SmallInteger","NativeBigInt","isPrecise","arrayToSmall","trim","compareAbs","createArray","truncate","l_a","l_b","sum","addAny","addSmall","subtract","a_l","b_l","difference","subtractAny","subtractSmall","small","multiplyLong","product","a_i","b_j","multiplySmall","shiftLeft","multiplyKaratsuba","ac","bd","abcd","useKaratsuba","abs","multiplySmallAndArray","square","a_j","divMod1","divisorMostSignificantDigit","lambda","remainder","quotientDigit","shift","divModSmall","divMod2","part","guess","xlen","highx","highy","check","divModAny","comparison","qSign","mod","mSign","_0","_1","_2","isBasicPrime","millerRabinTest","nPrev","strict","isPrime","bits","logN","iterations","newT","newR","lastT","lastR","powersOfTwo","powers2Length","highestPower2","shift_isSmall","remQuo","bitwise","xSign","ySign","xRem","yRem","xDigit","yDigit","xDivMod","yDivMod","LOBMASK_I","LOBMASK_BI","roughLOB","integerLogarithm","max","min","gcd","lcm","randBetween","low","high","range","digits","toBase","restricted","top","digit","text","absBase","alphabetValues","isNegative","start","parseBaseFromArray","val","pow","stringify","out","left","divmod","toBaseString","zeros","parseStringValue","split","decimalPlace","isValid","parseNumberValue","ml_z_normalize","ml_z_abs","ml_z_add","ml_z_compare","ml_z_div","ml_z_divexact","ml_z_equal","ml_z_fits_int","ml_z_fits_int32","ml_z_format","cas","width","alt","dir","pad","prefix","pre","ml_z_gcd","ml_z_hash","acc","caml_zarith_marshal","block","caml_zarith_unmarshal","negate","ml_z_init","ml_z_logand","ml_z_logor","ml_z_mul","ml_z_neg","ml_z_numbits","upperBound","ml_z_of_bits","base1","ml_z_of_float","f1","ml_z_of_int","ml_z_of_int64","jsoo_z_of_js_string_base","bc","ml_z_of_substring_base","ml_z_pow","ml_z_pred","ml_z_rem","ml_z_shift_left","amt","ml_z_shift_right","ml_z_sign","ml_z_sub","ml_z_succ","ml_z_testbit","ml_z_to_bits","ml_z_to_int","ml_z_fits_int64","ml_z_to_int64","mask","mult_nat","len3","nth_digit_nat","prover_to_json","set_digit_nat","set_digit_nat_native","ms_to_nano","time_now_nanoseconds_since_unix_epoch_or_zero","ms","ms_i63","unix_inet_addr_of_string","caml_fatal_uncaught_exception","throw_errors","collect_strings","caml_setup_uncaught_exception_handler","origin","event","zero$0","y$0","minus_one$0","zero_pos","sub_format","formatting_lit","opt","locfmt","null$0","current_dir_name","parent_dir_name","dir_sep","quotequote","null$1","current_dir_name$0","parent_dir_name$0","dir_sep$0","null$2","current_dir_name$1","parent_dir_name$1","dir_sep$1","module_name","tp_loc","module_name$2","ocaml_lex_tables","m1","m2","m4","h01","the_generic_group$2","mask$0","the_generic_group$3","module_name$13","module_name$14","elided_message","null$3","tp_loc$0","tp_loc$1","tp_loc$2","flags$0","am_recording_environment_varia","name$3","name$4","name$5","name$6","name$7","name$8","name$9","name$10","name$11","name$12","name$13","name$14","name$15","name$16","name$17","name$18","name$19","name$20","name$21","name$22","name$23","ocaml_lex_tables$0","int64$1","golden_gamma","beginning_of_file","err$2","err$1","err$0","tp_loc$3","name$26","tp_loc$4","name$27","loc$2","tp_loc$5","name$28","tp_loc$6","tp_loc$7","name$29","tp_loc$8","tp_loc$9","name$30","tp_loc$10","name$31","name$32","default_seed","default_shrink_attempts","name$55","name$56","name$57","name$58","name$59","name$60","name$61","name$62","name$63","name$64","name$65","name$66","name$67","name$68","name$69","name$70","name$71","name$72","name$73","name$74","name$75","unit_of_time_list","name$77","name$78","name$81","name$80","name$79","module_name$24","tp_loc$13","all$2","name$82","tp_loc$14","name$83","module_name$25","name$84","name$85","suffix$6","suffix","tp_loc$15","module_name$26","module_name$27","suffix$13","module_name$28","name$86","name$87","module_name$29","tp_loc$16","tp_loc$17","atom","record$1","label","ocaml_lex_tables$1","ocaml_lex_tables$2","ocaml_lex_tables$3","name$89","module_name$30","name$90","tp_loc$18","tp_loc$19","tp_loc$20","label$0","pos$0","tp_loc$21","tp_loc$22","tp_loc$23","pos$1","op","tp_loc$24","tp_loc$25","tp_loc$26","tp_loc$27","state$7","state$6","state$5","state$4","state$3","state$2","state$1","state$0","tp_loc$28","feature_flags","actual_feature_flags","tp_loc$29","tp_loc$30","tp_loc$31","tp_loc$32","tp_loc$33","tp_loc$34","tp_loc$35","tp_loc$36","tp_loc$37","tp_loc$38","tp_loc$39","pos$2","tp_loc$40","pos$4","pos$3","slots","slots$0","name$91","n$0","here","tp_loc$41","none$1","arg$0","tp_loc$42","level_bits$0","here$0","here$1","here$2","here$3","here$4","here$5","tp_loc$43","tp_loc$44","tp_loc$45","tp_loc$46","list$1","tp_loc$47","list$2","tp_loc$48","empty$15","v_print_debug_messages_for","environment_variable","job_queue","deferred0","deferred1","monitor","import0","error$0","pos$5","fmt$0","fmt$1","start$0","expected","id$2","pos$10","pos$9","pos$8","pos$7","pos$6","tp_loc$49","state$8","tp_loc$50","tp_loc$51","state$9","tp_loc$52","pos$11","tp_loc$53","tp_loc$54","pos$13","pos$12","tp_loc$55","tp_loc$56","tp_loc$57","tp_loc$58","tp_loc$59","pos$14","pos$17","pos$16","pos$15","name$92","id$3","name$93","id$4","pos$19","pos$18","ast_impl_magic_number","ast_intf_magic_number","right","fmt$4","fmt$5","fmt$6","opt$1","cs","infix_symbols","special_infix_strings","reset_ctxt","ast_impl_magic_number$0","ast_intf_magic_number$0","ast_impl_magic_number$1","ast_intf_magic_number$1","ast_impl_magic_number$2","ast_intf_magic_number$2","ast_impl_magic_number$3","ast_intf_magic_number$3","ast_impl_magic_number$4","ast_intf_magic_number$4","ast_impl_magic_number$5","ast_intf_magic_number$5","ast_impl_magic_number$6","ast_intf_magic_number$6","ast_impl_magic_number$7","ast_intf_magic_number$7","ast_impl_magic_number$8","ast_intf_magic_number$8","ast_impl_magic_number$9","ast_intf_magic_number$9","ast_impl_magic_number$10","ast_intf_magic_number$10","ast_impl_magic_number$11","ast_intf_magic_number$11","pos$20","txt","string_version","string_version$0","string_version$1","string_version$2","string_version$3","string_version$4","string_version$5","string_version$6","string_version$7","string_version$8","string_version$10","string_version$11","flags$2","flags$1","prefix$3","kind$2","vals","prefix$4","warnings","prefix$5","pos$25","pos$24","pos$23","pos$22","pos$21","tp_loc$60","tp_loc$61","tp_loc$62","tp_loc$63","state$11","state$10","tp_loc$64","tp_loc$65","state$12","tp_loc$66","state$17","state$16","state$15","state$14","state$13","tp_loc$67","tp_loc$68","tp_loc$69","tp_loc$70","tp_loc$71","tp_loc$72","tp_loc$73","tp_loc$74","commit_id","commit_date","marlin_commit_id","description$0","pos$32","pos$31","pos$30","pos$29","pos$28","pos$27","pos$26","state$21","initial_prefix","prefix$7","state$20","state$19","state$18","tp_loc$75","tp_loc$76","tp_loc$77","tp_loc$78","tp_loc$79","tp_loc$80","prefix$6","acc$0","state$23","state$22","tp_loc$81","tp_loc$82","tp_loc$83","pos$33","b_010","b_002","pos$35","pos$34","state$24","tp_loc$84","sponge_name","pos$36","description$1","state$26","tp_loc$85","sponge_name$0","pos$40","pos$39","pos$38","pos$37","t2$0","t1$0","t2$1","t1$1","t$7","pos$45","pos$44","pos$43","pos$42","t2$2","t1$2","t2$3","t1$3","pos$41","domains","t$8","pos$61","pos$60","pos$59","pos$58","pos$57","pos$56","pos$55","pos$54","pos$53","pos$52","pos$51","pos$50","pos$49","pos$48","pos$47","pos$46","tp_loc$86","pos$62","tagname","branches","pos$64","pos$63","tp_loc$87","tp_loc$88","pos$65","pos$66","description$2","description$3","tp_loc$89","tp_loc$90","tp_loc$91","tp_loc$92","tp_loc$93","pos$69","message$2","state$29","tp_loc$98","pos$68","message$1","state$28","tp_loc$94","tp_loc$95","tp_loc$96","tp_loc$97","hex_key_odd","hex_key_even","deriver","tp_loc$99","tp_loc$100","tp_loc$101","tp_loc$102","tp_loc$103","tp_loc$104","state$30","tp_loc$105","tp_loc$106","pos$70","cany","v$99","v$100","v$101","v$102","v$103","v$104","ocaml_lex_tables$5","type_kind$0","directive_location","pos$77","pos$76","pos$75","t1$4","t1$5","t1$6","pos$74","pos$73","pos$72","t2$5","t2$6","t2$7","key$1","pos$71","t2$4","introspection_query_raw","pos$81","prefix$8","suffix$14","pos$80","pos$79","pos$78","doc$0","v1","v2","manual","pos$85","pos$84","pos$83","pos$82","state$31","v$105","state$32","tp_loc$107","tp_loc$108","pos$91","pos$90","t2$9","pos$89","pos$88","t2$8","pos$87","pos$86","description$4","compiled","coinbase_amount_string","account_creation_fee_string","genesis_state_timestamp_string","env$1","tp_loc$110","err$3","tp_loc$109","description$5","tp_loc$111","state$33","tp_loc$112","tp_loc$113","description$6","pos$92","tp_loc$114","tp_loc$115","state$35","state$34","tp_loc$116","tp_loc$117","description$7","pos$95","pos$94","state$36","pos$93","tp_loc$118","tp_loc$119","t1$7","empty$35","pos$96","s$2","s$1","s$0","description$8","state$38","state$37","tp_loc$120","tp_loc$121","pos$97","tp_loc$122","tp_loc$123","empty$37","state$41","state$40","state$39","tp_loc$124","tp_loc$125","tp_loc$126","tp_loc$127","tp_loc$128","state$43","state$42","tp_loc$129","tp_loc$130","description$9","description$10","description$11","tp_loc$131","tp_loc$132","tp_loc$133","tp_loc$134","five","state$44","empty_stack_msg","salt_phrase","deriver_name","salt_phrase$0","deriver_name$0","salt_phrase$1","tp_loc$135","state$45","default$9","tp_loc$136","tp_loc$137","description$12","tp_loc$138","pos$102","pos$101","pos$100","pos$99","t2$11","pos$98","t2$10","tp_loc$139","tp_loc$140","tp_loc$141","tp_loc$142","epoch_data$0","dummy_value","tp_loc$143","tp_loc$144","tp_loc$145","tp_loc$146","tp_loc$147","tp_loc$148","tp_loc$149","tp_loc$150","tp_loc$151","tp_loc$152","tp_loc$153","tp_loc$154","tp_loc$155","tp_loc$156","tp_loc$157","tp_loc$158","tp_loc$159","tp_loc$160","tp_loc$161","tp_loc$162","tp_loc$163","tp_loc$164","tp_loc$165","tp_loc$166","tp_loc$167","tp_loc$168","tp_loc$169","tp_loc$170","tp_loc$171","state$50","state$49","state$48","tp_loc$172","description$13","tp_loc$173","tp_loc$174","state$52","state$51","tp_loc$175","description$14","tp_loc$176","state$54","state$53","tp_loc$177","description$15","tp_loc$178","state$59","state$58","state$57","state$56","state$55","tp_loc$179","description$16","description$17","tp_loc$180","tp_loc$181","description$18","tp_loc$182","tp_loc$183","tp_loc$184","tp_loc$185","tp_loc$186","tp_loc$187","tp_loc$188","tp_loc$189","tp_loc$190","tp_loc$191","state$63","state$62","state$61","state$60","description$19","description$20","tp_loc$192","names$1","tp_loc$193","names$2","tp_loc$194","tp_loc$195","state$65","state$64","tp_loc$196","tp_loc$197","pos$104","pos$103","tp_loc$198","tp_loc$199","transaction_id$1","expected_hash$1","transaction_id$0","expected_hash$0","transaction_id","expected_hash","description$21","pos$105","update_failed","kind$3","tp_loc$200","tp_loc$201","tp_loc$202","tp_loc$203","tp_loc$204","tp_loc$205","tp_loc$206","tp_loc$207","tp_loc$208","nsf_tag","min_balance_tag","description$23","description$22","name$99","erase_rel","rest","rest$0","rest$1","rest$2","rest$3","rest$4","rest$5","rest$6","rest$7","ty","rest$8","ty1","rest$9","rest$10","rest$11","rest$12","rest$13","concat_fmtty","fmtty1","fmtty2","ty2","concat_fmt","fmt1","fmt2","pad$0","pad$1","iconv","prec$0","pad$2","iconv$0","prec$1","pad$3","iconv$1","prec$2","pad$4","iconv$2","prec$3","pad$5","fconv","pad$6","chr","fmtty","pad$7","fmtty$0","pad$8","rest$14","rest$15","rest$16","fmting_lit","rest$17","fmting_gen","rest$18","rest$19","char_set","width_opt","rest$20","counter","rest$21","rest$22","ign","rest$23","arity","cur","failwith","invalid_arg","lnot","nan","max_finite_value","max_queue_length","min$0","symbol","char_of_int","bool_of_string","int_to_string","valid_float_lexem","i$0","string_of_float","tl","hd","open_out_gen","perm","open_out","open_out_bin","flush_all","iter","output_string","oc","output_substring","close_out","open_in_gen","open_in_bin","input","unsafe_really_input","ofs$0","len$0","len$1","ofs$1","really_input","really_input_string","prerr_string","symbol$0","str2","exit_function","at_exit","f_yet_to_run","old_exit","new_exit$0","new_exit","success","do_at_exit","exit","retcode","close_in","os_type$0","cygwin","arch_big_endian","num_bits_int","is_block","lazy_tag","object_tag","forward_tag","slot","extension_name","max_ephe_length","raise_undefined","force_lazy_block","blk","closure","empty","append$0","seq1","seq2","next","map","seq","filter_map","seq$0","flat_map","fold_left","acc$1","unfold","u","u$0","some","default$0","map$0","fold","none","iter$0","is_none","map$1","map_error","equal","param$0","nth","l$0","l$1","n$1","rev_append","l1$0","l2$0","l1$1","l2$1","rev","param","accu","accu$0","accu$1","assoc_exn","find_exn","xs","ry","rx","cmp","rev_sort","tl$1","x2$0","x1$0","n1","n2","sort","tl$0","t2","h2","t1","h1","c$0","c$1","c$2","c$3","c$4","c$5","c$6","accu$2","aux","tail","min$1","max$0","to_string$0","is_space","apply1","seplen","is_space$0","i$1","i$2","index_rec","lim","lowercase_ascii$0","capitalize_ascii","uncapitalize_ascii","to_buffer","sx","sy","la","lb","res$0","hd$0","zero","minus_one","succ","pred","abs$0","min$2","max$1","lognot","int32_to_string","succ$0","pred$0","abs$1","bit_not","int64_to_string","y$1","min_nativeint","max_nativeint","nativeint_to_string","engine","sth","with_positions","aux_buffer","read","newlen","newbuf","env","clear_parser","height","create","hl","h$0","hr","bal","lv","ll","lrr","lrv","lrl","rr","rv","rl","rlr","rlv","rll","singleton","add_min_element","add_max_element","join","rh","lh","min_elt","min_elt_opt","max_elt","param$1","max_elt_opt","remove_min_elt","r$0","concat","pres","pres$0","is_empty","remove","union","r2$0","r1$0","inter","split_bis","disjoint","s1$0","s2$0","s2$1","diff","cons_enum","e$0","e$1","compare","e2$2","e1$2","e1","e2","e2$0","e1$0","e2$1","e1$1","subset","for_all","exists","filter","pv","partition","lf","lt","rf","rt","cardinal","elements_aux","elements","find","find_first","v$0","find_first_opt","find_last","find_last_opt","find_opt","try_join","v$1","of_list","sub","l$3","x0","l$4","x0$0","l$5","x0$1","nl","mid","l$2","x4","add_seq","of_seq","seq_of_enum","to_seq","snoc_enum","rev_seq_of_enum","to_rev_seq","to_seq_from","ld","lrd","rld","d$0","min_binding","min_binding_opt","max_binding","max_binding_opt","remove_min_binding","update","data$0","mapi","m$0","add_min_binding","add_max_binding","concat_or_join","merge","d1","d2","d2$0","d1$0","d2$1","d1$1","pvd","fvd","m$1","bindings_aux","bindings","clear","push","pop_opt","top_opt","clear$0","cell","resize","more","old_len","new_len","new_buffer","uchar_utf_8_byte_length_max","new_position","create_char_set","add_in_char_set","str_ind","pad_of_pad_opt","pad_opt","param_format_of_ignored_format","pad_opt$0","pad_opt$1","pad_opt$2","pad_opt$3","pad_opt$4","prec_opt","pad_opt$5","ndec","pad_opt$6","pad_opt$7","pad_opt$8","default_float_precision","buffer_create","init_size","buffer_check_size","overhead","min_len","buffer_add_char","buffer_add_string","buffer_contents","char_of_iconv","string_of_formatting_lit","str$0","bprint_fmtty","sub_fmtty","sub_fmtty$0","symm","trans","rest2","rest2$0","rest2$1","rest2$2","rest2$3","rest2$4","rest2$5","rest2$6","rest2$7","ty2$0","rest2$8","ty22","ty21","fmtty_rel_det","f4","f2","rest2$9","rest2$10","rest2$11","rest2$12","rest2$13","de","ed","af","fa","de$0","ed$0","af$0","fa$0","de$1","ed$1","af$1","fa$1","de$2","ed$2","af$2","fa$2","de$3","ed$3","af$3","fa$3","de$4","ed$4","af$4","fa$4","de$5","ed$5","af$5","fa$5","de$6","ed$6","af$6","fa$6","de$7","ed$7","af$7","fa$7","de$8","ed$8","af$8","fa$8","jd","dj","ga","ag","de$9","ed$9","af$9","fa$9","de$10","ed$10","af$10","fa$10","de$11","ed$11","af$11","fa$11","de$12","ed$12","af$12","fa$12","de$13","ed$13","af$13","fa$13","fmtty_of_precision_fmtty","fmtty_of_padding_fmtty","fmtty_of_custom","arity$0","fmtty_of_fmt","ty_rest","prec_ty","ty_rest$0","prec_ty$0","ty_rest$1","prec_ty$1","ty_rest$2","prec_ty$2","ty_rest$3","prec_ty$3","fmtty$1","fmtty$2","fmtty$3","ty$0","fmtty$4","fmtty$5","type_padding","padty","padty$0","type_padprec","type_ignored_format_substituti","type_format_gen","fmtty_rest","sub_fmtty_rest","sub_fmtty_rest$0","fmtty_rest$0","sub_fmtty_rest$1","sub_fmtty_rest$2","fmtty_rest$1","sub_fmtty_rest$3","fmt$2","sub_fmtty_rest$4","fmtty_rest$2","sub_fmtty_rest$5","fmt$3","sub_fmtty_rest$6","fmtty_rest$3","sub_fmtty_rest$7","sub_fmtty_rest$8","fmtty_rest$4","sub_fmtty_rest$9","sub_fmtty_rest$10","fmtty_rest$5","sub_fmtty_rest$11","sub_fmtty_rest$12","fmtty_rest$6","sub_fmtty_rest$13","fmt$7","sub_fmtty_rest$14","fmtty_rest$7","sub2_fmtty","sub_fmtty_rest$15","sub2_fmtty$0","fmt$8","sub_fmtty_rest$16","fmtty_rest$8","sub2_fmtty$1","sub1_fmtty","sub_fmtty_rest$17","sub2_fmtty$2","sub1_fmtty$0","fmt$9","sub_fmtty_rest$18","fmtty_rest$9","sub_fmtty_rest$19","fmt$10","sub_fmtty_rest$20","fmtty_rest$10","sub_fmtty_rest$21","fmt$11","sub_fmtty_rest$22","fmtty_rest$11","sub_fmtty_rest$23","fmt$12","sub_fmtty_rest$24","fmtty_rest$12","sub_fmtty_rest$25","fmt$13","sub_fmtty_rest$26","fmt_rest","fmt_rest$0","fmt_rest$1","fmt_rest$2","fmt_rest$3","fmt_rest$4","fmt_rest$5","prec$4","fmtty$6","fmt_rest$6","prec$5","prec$6","fmtty$7","fmt_rest$7","prec$7","prec$8","fmtty$8","fmt_rest$8","fmtty$9","fmt_rest$9","fmtty$10","fmt_rest$10","fmtty$11","fmt_rest$11","fmtty$12","fmt_rest$12","fmtty$13","sub_fmtty1","fmt_rest$13","sub_fmtty$1","fmtty$14","fmt$14","fmt_rest$14","fmtty$15","fmt$15","fmt_rest$15","fmtty$16","fmt$16","fmt_rest$16","fmtty$17","fmt$17","fmt_rest$17","formatting_gen","fmtty3","fmt3","str$1","fmt1$0","fmtty2$0","fmt2$0","fmtty3$0","fmt3$0","fmtty_rest$13","fmt_rest$18","fmtty$18","fmt$18","fmtty_rest$14","fmt_rest$19","fmtty$19","fmt$19","fmtty_rest$15","fmt_rest$20","fmtty$20","fmt$20","type_ignored_param_one","fmtty_rest$16","fmtty$21","fmt$21","sub_fmtty$2","sub_fmtty$3","fmtty$22","fmt$22","sub_fmtty$4","type_format","recast","fix_padding","width$0","fix_int_precision","res$1","string_to_caml_string","format_of_fconv","symb","transform_int_alt","put","convert_int","convert_int32","convert_nativeint","convert_int64","convert_float","hex","caml_special_val","string_of_fmtty","make_printf$0","k$0","new_acc","make_printf","make_padding","make_int_padding_precision","p$0","p$1","acc$2","acc$3","acc$4","k$3","kacc","k$1","k$4","k$2","make_ignored_param","make_custom$0","make_invalid_arg","make_from_fmtty$0","make_from_fmtty","make_custom","output_acc","p$2","p$3","p$4","bufput_acc","strput_acc","failwith_message","open_box_of_string","invalid_box","parse_spaces","parse_lword","j$0","j$1","parse_int","wstart","wend","box_name","nstart","nend","indent","exp_end","box_type","make_padding_fmt_ebb","make_padprec_fmt_ebb","fmt_ebb_of_string","legacy_behavior","flag","legacy_behavior$0","invalid_format_message","unexpected_end_of_format","end_ind","invalid_format_without","expected_character","add_literal","lit_start","parse_positive","str_ind$0","str_ind$1","parse_integer","next_ind","incompatible_flag","pct_ind","option","subfmt","compute_int_conv","plus","hash","space","plus$0","hash$0","space$0","search_subformat_end","sub_end","str_ind$2","sub_end$0","str_ind$3","sub_end$1","str_ind$4","str_ind$5","sub_end$2","str_ind$6","str_ind$7","parse_magic_size","str_ind_1","str_ind_2","str_ind_3","parse","parse_good_break","formatting_lit$0","str_ind_4","str_ind_5","parse_tag","is_open_tag","ind","sub_str","sub_fmt","sub_format$0","formatting$0","formatting","parse_flags","minus","set_flag","new_ind","parse_after_padding","parse_literal","parse_after_precision","symb$0","minus$0","parse_conversion","parse_conv","padprec","plus_used","hash_used","space_used","ign_used","pad_used","prec_used","get_plus","get_hash","get_space","get_ign","get_pad","get_prec","get_padprec","get_int_pad","check_no_0","opt_of_pad","width$1","get_pad_opt","get_padprec_opt","fmt_result","ignored$2","counter$0","ignored$6","ignored$7","char_set$1","add_char","add_range","fail_single_percent","parse_char_set_content","parse_char_set_after_char$0","parse_char_set_after_char","reverse","char_set$0","char_set$2","ignored$9","char_format","fmt_rest$21","fmt_rest$22","pad$9","fmt_rest$23","ignored$10","fmt_rest$24","pad$10","fmt_rest$25","sub_fmt$0","fmt_rest$26","ignored$11","ignored$3","ignored$5","ignored$8","space$1","hash$1","plus$2","ignored$4","ignored","ignored$0","ignored$1","plus$1","ign$0","fprintf","bprintf","ksprintf","sprintf","assoc3","y2","y1","split$0","make_symlist","help_action","add_help","speclist","add2","current","bool_of_string_opt","int_of_string_opt","float_of_string_opt","parse_and_expand_argv_dynamic_","allow_expand","anonfun","errmsg","initpos","convert_error","error","progname","doc","spec","follow$0","action","keyword","no_arg$0","follow","no_arg","get_arg$0","get_arg","consume_arg$0","consume_arg","treat_action$0","treat_action","f$0","f$1","r$1","f$2","arg$1","r$2","arg$2","x$0","f$3","arg$3","x$1","r$3","arg$4","x$2","specs","f$4","arg$5","f$5","f$6","f$7","arg$6","newarg","before","after","parse_argv","sth$0","speclist$0","second_word","loop","max_arg_len","kwd","replace_leading_tab","align","completed","ksd","msg$0","cutcol$0","spaces$0","cutcol","kwd_len","spaces","printers","field","other_fields","to_string$1","conv","char$0","line","char$1","line$0","file$0","char$2","line$1","file$1","constructor","convert_raw_backtrace","format_backtrace_slot","is_raise","print_raw_backtrace","outchan","raw_backtrace","backtrace","raw_backtrace_to_string","get_backtrace","register_printer","old_printers","new_printers","errors","default_uncaught_exception_han","status","uncaught_exception_handler","empty_backtrace","handle_uncaught_exception","debugger_in_use","exn$0","raw_backtrace$0","protect","finally$0","work","finally_no_exn","work_exn","work_bt","char_hex","new_state","assign","st1","st2","full_init","seed$0","make$1","make_self_init","copy$1","curval","newval30","init$2","get_state","set_state","ongoing_traversal","flip_ongoing_traversal","params","randomized_default","prng","initial_size","random","clear$2","reset$0","copy_bucketlist","key$0","next$0","copy$2","length$1","resize$0","indexfun","odata","osize","nsize$0","ndata","inplace","indexfun$0","nsize","ndata_tail","cell$0","nidx","match","match$0","iter$4","do_bucket","old_trav","filter_map_inplace_bucket","filter_map_inplace","fold$0","b$0","bucket_length","stats","mbl","histo","to_seq$0","tbl_data","buck","buck$0","buck$1","to_seq_keys","to_seq_values","key_index","bucket","next1","next2","k3","d3","next3","find_all","find_in_bucket","replace","replace_seq","id$0","unknown","pp_enqueue","pp_infinity","pp_output_string","pp_output_newline","format_pp_text","format_string","break_new_line","real_indent","break_line","break_same_line","format_pp_token","size$0","tabs","add_tab","ls","tag_name","marker","breaks","fits","box_type$0","off$0","insertion_point","tabs$0","first","head","tab","off$1","insertion_point$0","width$2","box_type$1","tbox","tag_name$0","marker$0","advance_left","pending_count","enqueue_advance","tok","enqueue_string_as","initialize_scan_stack","queue_elem","set_size","left_total","scan_push","elem","pp_open_box_gen","br_ty","pp_flush_queue","pp_print_as_size","isize","pp","blank_line","display_indent","default_pp_mark_open_tag","default_pp_mark_close_tag","default_pp_print_open_tag","default_pp_print_close_tag","flush","pp_queue","sys_tok","scan_stack","ppf","pp_buffer_size","pp_make_buffer","flush_buffer_formatter","pp_print_list","pp_v","opt$0","pp_sep","vs","compute_tag","tag_acc","output_formatting_lit","output_acc$0","bty","p$5","p$6","strput_acc$0","size$1","flush_standard_formatters","null_char","next_char","ib","peek_char","checked_peek_char","end_of_input","char_count","reset_token","invalidate_current_char","token_string","token_buffer","skip_char","ignore_char","store_char","default_token_buffer_size","create$2","iname","scan_raise_at_end","from_ic","scan_close_ic","eof","bad_input","bad_input_escape","bad_token_length","message","bad_float","bad_hex_float","character_mismatch","ci","check_this_char","check_char","token_char","token_bool","integer_conversion_of_char","token_int_literal","token_float","scan_decimal_digit_star","scan_unsigned_decimal_int","scan_digit_plus","basis","digitp","width$3","is_binary_digit","scan_binary_int","is_octal_digit","scan_octal_int","is_hexa_digit","scan_hexadecimal_int","scan_sign","scan_optionally_signed_decimal","scan_int_conversion","scan_fractional_part","scan_exponent_part","scan_float","precision","precision$0","check_case_insensitive_string","lowercase","scan_hex_float","width$4","width$5","width$6","width$10","width$7","width$8","width$9","scan_caml_float_rest","width_precision","frac_width","scan_caml_float","scan_string","stp","scan_char","hexadecimal_value_of_char","check_next_char","check_next_char_for_char","check_next_char_for_string","scan_backslash_char","c0","get_digit","get_digit$0","c1$0","c2$0","scan_caml_char","find_stop","scan_caml_string","find_stop$0","skip_spaces","scan_chars_in_char_set","scan_indic","scan_chars","ef","get_counter","width_of_pad_opt","stopper_of_formatting_lit","fmting","take_format_readers$0","take_fmtty_format_readers$0","new_k","readers_rest","take_format_readers","fmt$23","fmt$24","fmt$25","take_fmtty_format_readers","make_scanf","readers","scan$0","str_rest","pad_prec_scanf","scan$1","scan$2","scan","scan$3","scan$4","conv$0","scan$5","conv$1","scan$6","conv$2","scan$7","scan$8","fmting_lit$0","str$2","stp$0","str_rest$0","rest$24","rest$25","rest$26","arg_rest","sscanf","apply","args$0","exc","register_exception","initial_object_size","public_method_label","compare$0","compare$1","compare$2","table_count","dummy_met","fit_size","new_table","pub_labels","methods","resize$1","new_size","old_size","new_buck","method_count","inst_var_count","new_method","table","get_method_label","get_method_labels","names","set_method","element","get_method","to_list$0","new_slot","new_variable","to_array","get_variable","create_table","public_methods","tags","met","lab","init_class","inherits","cla","virt_meths$1","concr_meths$0","super$0","vars","virt_meths","concr_meths","virt_meth_labs","concr_meth_labs","tvars","by_name","by_label","hm","vars$0","virt_meths$0","saved_vars","saved_hidden_meths","by_label$0","by_name$0","make_class","pub_meths","class_init","env_init","create_object_opt","obj_0","run_initializers_opt","inits","new_cache","set_methods","clo","clo$0","n$2","n$3","n$4","n$5","n$6","x$3","n$7","x$4","n$8","n$9","x$5","f$8","e$2","n$10","x$6","f$9","n$11","x$7","n$12","x$8","n$13","n$14","e$3","n$15","m$2","x$9","m$3","n$16","m$4","e$4","n$17","m$5","n$18","init_mod_block","loc","comps$0","modu","shape","fn$0","undef","comps","init_mod","update_mod_block","cl","update_mod","generic_basename","is_dir_sep","generic_dirname","is_relative","is_implicit","check_suffix","suff","len_s","len_suf","chop_suffix_opt","filename","len_f","quote","quote_command","stdin","stdout","stderr","basename","dirname","is_dir_sep$0","is_relative$0","is_implicit$0","check_suffix$0","chop_suffix_opt$0","temp_dir_name","quote$0","add_bs","loop$0","loop_bs","quote_cmd_filename","quote_command$0","drive_and_path","dirname$0","drive","basename$0","basename$1","dirname$1","dir_sep$2","is_dir_sep$1","is_relative$1","temp_dir_name$0","quote$1","basename$2","concat$0","prng$0","temp_file_name","temp_dir","rnd","temp_file","try_name","counter$1","create$3","dim","create$4","dim1","dim2","create$5","of_bool","sexp_of_string","sexp_of_ref","sexp_of_a","sexp_of_option","sexp_of_b","sexp_of_list","lst","sexp_of_array","ar","lst_ref","compare$4","exn_id_map","clean_up_handler","old_exn_id_map","new_exn_id_map","add$1","sexp_of_exn","finalise","ephe","find_auto","sexp","exn_to_string","what","of_bool$0","string_of_sexp","int_of_sexp","int32_of_sexp","int64_of_sexp","nativeint_of_sexp","ref_of_sexp","a_of_sexp","option_of_sexp","el","b_of_sexp","b_sexp","a_sexp","list_of_sexp","rev_lst","array_of_sexp","t$0","t_of_sexp$1","get_flc_error","handler","extension_constructor","tuple_of_size_n_expected","stag_no_args","stag_incorrect_n_args","stag_takes_args","nested_list_invalid_sum","empty_list_invalid_sum","unexpected_stag","record_only_pairs_expected","record_superfluous_fields","rev_fld_names","fld_names_str","record_duplicate_fields","record_extra_fields","record_undefined_elements","undefined$0","record_list_instead_atom","no_variant_match","no_matching_variant_found","ptag_incorrect_n_args","cnstr","ptag_takes_args","nested_list_invalid_poly_var","empty_list_invalid_poly_var","empty_type","scale","symbol$1","symbol$2","symbol$3","symbol$4","symbol$5","symbol$6","ascending","descending","equal$1","max$2","min$3","symbol$7","symbol$8","symbol$9","symbol$10","symbol$11","symbol$12","ascending$0","descending$0","compare_int64","equal_int64","max$3","min$4","symbol$13","symbol$14","symbol$15","symbol$16","symbol$17","symbol$18","ascending$1","descending$1","compare_nativeint","equal_nativeint","max$4","min$5","compare_bool","equal_bool","compare$6","compare_float","equal_float","compare_string","equal_string","asr","lor","lsl","lsr","lxor","decr","incr","am_testing","failwithf","getenv","var$0","of_int_exn","of_msb_first","hash_fold_unit","as_int","hash_fold_int32","hash_fold_char","hash_fold_bool","hash_fold_nativeint","hash_fold_option","hash_fold_elem","hash_fold_list","list$0","list","hash_fold_lazy_t","hash_fold_ref_frozen","hash_fold_array_frozen","hash_nativeint","hash_int64","hash_int32","hash_char","hash_int","hash_bool","hash_string","hash_float","hash_unit","compare_state","state_to_string","create$6","run","folder","of_fold","hash_fold_t","hash_fold_t$4","hash_fold_t$7","func$0","t$1","t$2","t$3","t$4","t$5","type_name","compare$11","compare_option","compare_elt","concat$1","ys","num_bits","word_size","formatter","v0$0","v1$0","reraise","to_string$3","protectx","final_exn","protect$0","does_raise","pp$0","raise_without_backtrace","initialize_module","is_alive","return$0","a$0","map_via_bind","ma","symbol_bind","symbol_map","symbol_bind$0","symbol_map$0","symbol_bind$1","symbol_map$1","both","ignore_m","ts","all","all_unit","bind","map$6","bind$0","return$1","map$7","get$0","fst","snd","fst$0","snd$0","fold_result","fold_until","iter$1","return$5","join$1","bits$0","int32","bound","make$3","make_self_init$0","allow_in_tests","assign$0","int$0","bits$1","full_range_int64","bits$2","full_range_int_on_64bits","raise_crossed_bounds","lower_bound","upper_bound","string_of_bound","int$1","bool","init$3","set_state$0","const$0","symbol$43","compare_list","equal_list","derived_map","map2","ta","tb","map3","tc","invariant$1","sexp_of_t","bounds_crossed","lower","upper","lower$0","upper$0","try_with$0","ok_exn","error_s","pass","fail","fail_s","name$0","protect$2","extract_name","alist","first_failure","t_of_sexp$4","sexp_of_t$8","compare$18","hash_fold_t$12","hsv","symbol$45","symbol$46","symbol$47","symbol$48","symbol$49","symbol$50","ascending$6","descending$6","compare$19","equal$4","max$8","min$9","of_string$1","to_string$5","incl","excl","incl$0","excl$0","incl$1","excl$1","incl$2","excl$2","between","clamp_exn","clamp","comparator","validate_lbound","validate_ubound","validate_bound","find_first_satisfying","hi$0","lo$1","lo$0","lo$2","find_last_satisfying","binary_search","how","binary_search_segmented","segment_of","is_left","is_right","unsafe_blit","blit","blito","src_len","sth$1","subo","create_like","length$0","unsafe_blit$0","is_none$0","is_some","equal_option","symbol_bind$2","bind$6","return$9","map$16","join$3","second","other","either","combine","other_loop","return_loop","combine_all","other_loop$0","return_loop$0","combine_all_unit","to_option","with_return$0","ret","combine$1","bind$7","either$0","combine$2","bind$8","iteri","foldi","foldi$0","counti","existsi","for_alli","find_mapi","findi","bind$10","return$11","map$18","create_zero","create$9","get$2","unsafe_set_with_caml_modify","unsafe_set_int_assuming_curren","unsafe_set","old_obj","abs_float","one_ulp","upper_bound_for_int","is_x_minus_one_exact","lower_bound_for_int","min_int_as_float","clamp_unchecked","hash_fold_t$14","t_of_sexp$6","sexp_of_t$11","equal$6","compare$23","comparator$2","compare$25","comparator$4","init$6","convert_failure","to_string","num_bits_nativeint","int_to_int32_trunc","int_to_int32","int_to_int32_exn","int32_to_int_exn","int_to_int64","int64_to_int_trunc","min$11","max$10","int64_is_representable_as_int","int64_to_int","int64_to_int_exn","int_to_nativeint","nativeint_to_int_trunc","nativeint_to_int","nativeint_to_int_exn","int32_to_int64","min$12","max$11","int64_is_representable_as_int3","int64_to_int32_exn","int32_to_nativeint","nativeint_to_int32_exn","nativeint_to_int64","min$28","max$29","to_nativeint_exn","min$13","max$12","int64_is_representable_as_int6","insert_delimiter_every","delimiter","chars_per_delimiter","input_length","has_sign","num_digits","num_delimiters","output_length","input_pos","output_pos","num_chars_until_delimiter","first_digit_pos","insert_delimiter","delimiter$0","make_suffix","to_string_hum","invalid","of_string_with_delimiter","of_string","ocaml_lex_state","ocaml_lex_state$0","body","body$0","int32_positive_overflow_bounds","int_positive_overflow_bounds","int63_on_int64_positive_overfl","int64_positive_overflow_bounds","int64_negative_overflow_bounds","negative_exponent","overflow","pow$0","rval","round_down","round_up","round_towards_zero","to_multiple_of","round_nearest","modulus_minus_remainder","round","int64_popcount","int32_popcount","popcount","popcount$0","t_sexp_grammar","of_float_unchecked","comparator$6","validate_lbound$2","validate_ubound$2","validate_bound$2","validate_positive","validate_non_negative","validate_negative","validate_non_positive","is_positive","is_non_negative","is_negative","is_non_positive","to_string_hum$2","sexp_of_t$13","zero$2","minus_one$2","pp$9","invariant$2","pred$2","succ$2","to_int$2","of_int$0","max_value_30_bits","abs$3","symbol$57","symbol$58","symbol$59","symbol$60","symbol$61","incr$0","decr$0","shift_right","shift_right_logical","shift_left","bit_not$0","bit_or","bit_and","bit_xor","symbol$62","ceil_pow2","floor_pow2","is_pow2","floor_log2","ceil_log2","symbol$63","symbol$64","symbol$65","bswap16","ctz","clz","sexp_of_t$14","symbol$66","symbol$67","symbol$68","symbol$69","symbol$70","symbol$71","equal$7","compare$27","min$14","max$13","ascending$8","descending$8","between$3","clamp_exn$3","clamp$3","comparator$7","validate_lbound$3","validate_ubound$3","validate_bound$3","t_of_sexp_direct","empty$4","to_list$5","mem$4","add$5","remove$2","of_list$3","never_returns","func$4","t_sexp_grammar$0","of_string$11","validate_lbound$6","validate_ubound$6","validate_bound$6","validate_positive$0","validate_non_negative$0","validate_negative$0","validate_non_positive$0","is_positive$0","is_non_negative$0","is_negative$0","is_non_positive$0","sign$0","invariant$3","num_bits$0","shift_right_logical$0","shift_right$0","shift_left$0","bit_xor$0","bit_or$0","bit_and$0","rem$0","symbol$84","to_float","of_float_unchecked$0","of_float","ceil_pow2$0","floor_pow2$0","is_pow2$0","floor_log2$0","ceil_log2$0","between$6","clamp_exn$6","clamp$6","symbol$85","symbol$86","symbol$87","symbol$88","incr$1","decr$1","pow$1","symbol$89","symbol$90","symbol$91","symbol$92","round$0","round_towards_zero$0","round_down$0","round_up$0","round_nearest$0","ctz$0","clz$0","is_empty$5","of_alist_exn$0","set$3","add_exn$1","add$7","change$1","remove$5","nth$5","of_tree$1","of_sorted_array_unchecked$2","of_alist$0","of_iteri$0","of_increasing_iterator_uncheck$2","hash$13","t_sexp_grammar$1","of_string$13","shift_right_logical$1","shift_right$1","shift_left$1","bit_xor$1","bit_or$1","bit_and$1","rem$1","symbol$93","to_float$0","of_float_unchecked$1","num_bits$1","of_float$0","symbol$94","bswap32","bswap48","validate_lbound$7","validate_ubound$7","validate_bound$7","validate_positive$1","validate_non_negative$1","validate_negative$1","validate_non_positive$1","is_positive$1","is_non_negative$1","is_negative$1","is_non_positive$1","sign$1","invariant$4","between$7","clamp_exn$7","clamp$7","symbol$95","symbol$96","symbol$97","symbol$98","incr$2","decr$2","of_int64","to_int64","ceil_pow2$1","floor_pow2$1","is_pow2$1","floor_log2$1","ceil_log2$1","to_string_hum$4","sexp_of_t$21","pp$11","symbol$99","symbol$100","symbol$101","round$1","round_towards_zero$1","round_down$1","round_up$1","round_nearest$1","ctz$1","clz$1","the_group$2","t_sexp_grammar$2","comparator$11","wrap_modulo","invariant$5","symbol$102","symbol$103","neg$2","abs$4","one$0","succ$3","pred$3","min_value$1","max_value$1","lnot$0","land$0","lxor$0","lor$0","lsl$0","asr$0","lsr$0","pow$2","symbol$104","symbol$105","rem$2","popcount$1","to_int64$0","of_int64$0","of_int64_exn","of_int64_trunc","t_of_sexp$10","sexp_of_t$22","compare$33","is_pow2$2","clz$2","ctz$2","floor_pow2$2","ceil_pow2$2","floor_log2$2","ceil_log2$2","the_group$3","t_sexp_grammar$3","func$5","invalid_str","sign_and_signedness","to_string$15","of_string$15","signedness","pos_str","int63","int63$0","bswap16$0","bswap32$0","bswap48$0","float_lower_bound$2","float_upper_bound$2","minus_one$3","one$1","zero$3","num_bits$2","to_float$1","of_float_unchecked$2","of_float$1","validate_lbound$8","validate_ubound$8","validate_bound$8","validate_positive$2","validate_non_negative$2","validate_negative$2","validate_non_positive$2","is_positive$2","is_non_negative$2","is_negative$2","is_non_positive$2","sign$2","between$8","clamp_unchecked$4","clamp_exn$8","clamp$8","symbol$106","incr$3","decr$3","of_int$1","of_int_exn$0","to_int$3","to_int_exn","to_int_trunc","of_int32","of_int32_exn","to_int32","to_int32_exn","to_int32_trunc","of_nativeint$0","of_nativeint_exn","of_nativeint_trunc","to_nativeint$0","to_nativeint_exn$0","to_nativeint_trunc","hash$15","to_string$16","of_string$16","to_string$17","repr","validate_lbound$9","validate_ubound$9","validate_bound$9","func$6","t_sexp_grammar$4","compare_int32","of_string$18","num_bits$3","shift_right_logical$2","shift_right$2","shift_left$2","bit_xor$2","bit_or$2","bit_and$2","rem$3","symbol$110","to_float$2","of_float_unchecked$3","of_float$2","validate_lbound$10","validate_ubound$10","validate_bound$10","validate_positive$3","validate_non_negative$3","validate_negative$3","validate_non_positive$3","is_positive$3","is_non_negative$3","is_negative$3","is_non_positive$3","sign$3","symbol$111","symbol$112","symbol$113","symbol$114","symbol$115","symbol$116","descending$11","min$17","max$16","equal_int32","between$10","clamp_exn$10","clamp$10","invariant$6","symbol$117","symbol$118","symbol$119","symbol$120","incr$4","decr$4","pow$3","symbol$121","ceil_pow2$3","floor_pow2$3","is_pow2$3","floor_log2$3","ceil_log2$3","to_string_hum$6","sexp_of_t$24","pp$14","symbol$122","symbol$123","symbol$124","round$3","round_towards_zero$3","round_down$3","round_up$3","round_nearest$3","ctz$3","clz$3","hash_fold_t$20","hashable","of_key","Key","to_key","max$18","empty$9","height$1","update_height","old_height","new_height","balance","tree","left_node_left","left_node_right","lr_left","lr_right","right_node_left","right_node_right","rl_left","rl_right","set_left","tree$0","set_right","add$8","added","findi_and_call_impl","arg1","arg2","call_if_found","call_if_not_found","if_found","if_not_found","find_and_call","call_if_found$0","call_if_not_found$0","call_if_found$1","call_if_not_found$1","call_if_found$2","call_if_not_found$2","call_if_found$3","call_if_not_found$3","call_if_found$4","call_if_not_found$4","if_not_found$0","remove_min_elt$1","remove$6","removed","fold$11","init$0","rkey","rdata","rkey$0","rdata$0","rkey$1","rdata$1","lkey","ldata","right$0","init$1","data$1","iter$16","mapi_inplace","value$0","clear$4","mem$7","remove$7","length$15","inv$0","inv","left_key","right_key","to_list$7","add$10","iter$18","magnitude","round$5","sexp_of_float","validate$2","validate_positive$5","validate_non_negative$5","validate_negative$5","validate_non_positive$5","create$23","unsafe_blit$4","elide","to_string_list","sexp_of_t$27","initialize_module$0","ocamlrunparam_mentions_backtra","symbol$140","symbol$141","symbol$142","symbol$143","libname_ref","set$5","unset","add_environment_var","libs_to_entries","lookup_rev_lib","libname","force_drop","add_bench","type_conv_path","startpos","endpos","test_spec","entry","empty$10","eval_fail","custom_printf_001","equal_option$0","create$24","eq","xs$1","xs$0","sorted","map$24","uuid","int$2","pair","t_of_sexp$14","of_a","sexp_args$7","v1$5","v0$15","v0$16","v1$6","sexp_args$5","v1$1","v0$11","v0$12","v1$2","sexp_args$1","v0$3","v0$4","sexp_args$2","v0$5","v0$6","sexp_args","sexp_args$4","v0$9","v0$10","field_sexps","sorted_field","duplicates","extra","field_sexp","fvalue","sorted_value","sexp_args$6","v1$3","v0$13","v0$14","v1$4","sexp_args$3","v0$7","v0$8","sexp_args$0","v0$1","v0$2","map$25","to_string$21","v_sorted","bnds","bnds$0","digest_layer","to_digest","to_digest$0","equal$16","opaque","create$25","desc","apply$0","def","recurse","tid","get_poly_variant","annotate","basetype","poly_variant","var$1","apply$1","recurse$0","define","record","create$26","compare$36","a_064","b_065","b_067","a_066","cmp_a","a_068","b_069","b_015","b_013","a_014","b_019","b_017","a_020","b_021","b_023","a_024","b_025","b_027","a_028","b_029","t_031","t_030","t_033","t_032","b_035","a_036","b_037","t_039","t_038","t_041","t_040","a_042","b_043","b_045","a_004","b_005","t_007","t_006","t_009","t_008","a_048","b_049","b_053","b_051","a_054","b_055","b_059","b_057","a_060","b_061","b_063","t_of_sexp$15","equal_t0","var$2","apply$2","recurse$1","get_poly_variant$0","opaque$0","to_digest$1","to_digest$2","annotate$0","basetype$0","tuple$0","poly_variant$0","var$3","recurse$2","apply$3","define$0","record$0","variant$0","create$27","trips","members","lookup","scheme","custom_printf_108","v0$17","v1$7","v0$18","v0$19","v1$8","v1$9","v0$20","v_members","v_loc","v_gid","bnds$1","bnds$2","v1$10","v2$0","is_cyclic_0","via_VR","group","set","visited","trav_tid","trav","ts$0","lookup$0","a_109","b_110","t_112","t_111","t_114","t_113","extend","tenv","depth","look_env","extend_new_tid","def_t","tenv$0","exec","sequence_defining","acc_ys","eval_app","gid","formals","record_or_normal_variant","cyclic","cyclic_no_VR","venv","eval_definition","eval_poly_constr","eval_list","binds","alts","xss","vid","loc$0","custom_printf_115","tid$0","in_group","eval$0","bin_write_unit","bin_write_bool","all_bin_write_small_int","all_bin_write_int16","all_bin_write_int32","bin_write_char","bin_write_int","bin_write_nat0","bin_write_string","new_pos","bin_write_float","bin_write_el","pair$0","bin_write_a","bin_write_b","els_pos$1","els_pos$0","els_pos","els_pos_ref","bin_write_variant_int","bin_write_int_8bit","bin_read_unit","pos_ref","bin_read_bool","safe_bin_read_neg_int8","safe_bin_read_int16","bin_read_nat0","ch","bin_read_bytes","start_pos","bin_read_string","bin_read_char","bin_read_int","bin_read_float","bin_read_int32","bin_read_int64","bin_read_nativeint","bin_read_ref","bin_read_el","bin_read_option","bin_read_pair","bin_read_a","bin_read_b","bin_read_list","dummy_float_buf","max_float_array_length","el$1","maybe_float","el$0","bin_read_variant_int","bin_read_int_8bit","bin_shape_array","pair$1","bin_size_unit","bin_size_bool","bin_size_char","bin_size_int","bin_size_nat0","bin_size_string_or_bytes","size_len","bin_size_string","bin_size_float","bin_size_int32","bin_size_int64","bin_size_el","bin_size_a","bin_size_b","len$2","bin_size_len","total_len","total_len_ref","variant_wrong_type","pair$2","bin_writer_el1","bin_writer_el2","pair$3","bin_reader_el1","bin_reader_el2","pair$4","bin_el1","bin_el2","cnv_writer","cnv","tp_class","cnv_reader","vtag","pre_test_hook","nanoseconds_since_unix_epoch","create$28","binary","may_eof","really_input_exn","input_byte","input_char","already_read","to_read","already_read$0","to_read$0","mach","with_file","binary$0","fail_if_exists$0","perm$0","fail_if_exists","sth$2","value$1","am_recording_value","am_recording","of_string$22","to_string$22","nanos","to_string_with_same_unit","of_string$23","Format","create$29","nested_timer","definition_timer","record_start","record_until","until","gc_stats_after","gc_stats_before","runtime","gc_events","nested$0","nested_timing_events","timing_event","nested","timing_events_to_strings","duration_strings","duration_string","description","compactions","major_collections","minor_collections","to_list","strings","left_column_width","fake_timing_events","print_recorded_timing_events","timing_events","notify_of_overriding","override","timing_events$0","nested_timing_event","uid$0","witness","next$1","cmp$0","same_witness$0","nm1","nm2","uid","typename_of_t","args_labels","ocaml_repr","tyid","traverse","internal_use_only","is_polymorphic","internal_use_only$0","index$0","is_mutable","tyid$0","traverse$0","internal_use_only$1","typename_of_t$0","has_double_array_tag","create$0","internal_use_only$2","typename_of_int","typename_of_int32","typename_of_int64","typename_of_nativeint","typename_of_char","typename_of_float","typename_of_string","typename_of_bytes","typename_of_bool","typename_of_unit","typename_of_option","typename_of_list","typename_of_array","typename_of_lazy_t","typename_of_ref","typename_of_function","typename_of_tuple2","typename_of_tuple3","typename_of_tuple4","typename_of_tuple5","rep","rep$0","rep$1","rep$2","rep$3","rep$4","name$24","b$1","a$1","b$2","a$2","typename_of_t$1","rng","dom","rep$5","rep$6","same_witness$1","r2$1","r2$2","r2$3","r2$4","rng2","dom2","b2$0","a2$0","b1$0","a1$0","b2$1","a2$1","b1$1","a1$1","c2$1","b2$2","a2$2","c1$1","b1$2","a1$2","r2$5","r2$6","r2$7","name2","same$0","same_witness_exn$0","typerep_and_typename_of_int63_","repr_of_poly_variant","hash_variant","double_array_value","double$0","simple","named","of_p1","of_p2","of_p3","typename_of_named","typerep_of_t","v$106","dir_or_error","sexp_of_t$28","v_end_pos","v_start_pos","v_line_start","v_line_number","v_filename","bnds$3","compare$37","of_string$24","expected_length","tests_run","protect$3","current$2","set$7","absolute_filename","unset$0","flushed","upon_unreleasable_issue","get_position","extract_output","ocaml_lex_state$1","ocaml_lex_state$2","relative_filename","with_ic","fname","get_outputs_and_cleanup","last_ofs","next_ofs","outputs","trailing_output","current_test","get_current","save_output","location","save_and_return_output","prev_pos","prev_pos$0","trailing","blocks","final_flush","max_attempts","file_digest","expectations","uncaught_exn_expectation","uncaught_exn","saved_output","run$0","defined_in","inline_test_config","registering_tests_for","return$12","bind$11","to_run","of_int$3","mix_bits","mix64","z$0","z$1","random_int64","create$30","random_state","gamma","odd_gamma","next_int64","bool$0","int64$0","maximum","draw$0","draw","int$3","int32$0","nativeint","unit_float_from_int64","float$0","bits_to_represent","log_uniform","min_bits","max_bits","log_uniform$0","log_uniform$1","log_uniform$2","log_uniform$3","return$13","tf","tx","map$27","map$28","values","weights","value_array","weight","cumulative","choice","lazy_t","of_generator","min_length","max_length","max_length$0","remaining","max_index","let_syntax_267","value_t","list_generic","elt_gen","list_with_length","char_print_uniform","char_uniform","small_int","allow_zero","weighted_low","weighted_high","small_non_negative_int","let_syntax_002","uniform_inclusive","log_uniform_inclusive","non_uniform","inclusive","log_inclusive","uniform_all","quickcheck_generator$0","float_zero_exponent","float_zero_mantissa","float_max_positive_subnormal_v","float_subnormal_exponent","float_min_subnormal_mantissa","float_max_subnormal_mantissa","float_min_normal_exponent","float_max_normal_exponent","float_max_nan_mantissa","float_inf_exponent","float_inf_mantissa","float_nan_exponent","float_min_nan_mantissa","float_num_mantissa_bits","float_normal_mantissa","float_exponent_weighted_low","float_exponent_weighted_high","midpoint","float_exponent","float_zero","let_syntax_004","let_syntax_005","float_subnormal","float_normal","float_infinite","let_syntax_010","let_syntax_011","float_nan","float_matching_classes","quickcheck_generator$1","float_finite_non_zero","lower_inclusive","upper_inclusive","char_gen","let_syntax_033","key_gen","data_gen","keys","keys$0","bigarray1","elts","elts$0","offset$1","offset$0","max_total_size","max_b","b_weighted_low","bigarray2_dim","bigarray2","quickcheck_shrinker","f_inverse","of_shrinker","elt_t","list_t","shrinker","shrink_list","shrink_tree","key_t","data_t","drop_keys","shrink_keys","smaller_key","shrink_data","smaller_data","elt","drop_elts","shrink_elts","smaller_elt","default_config","lazy_nondeterministic_state","with_sample","generator","config","examples","number_of_size_values","remaining_sizes","sequence","run$1","config$0","examples$0","M","error$1","error$2","input$0","shrink_count$1","alternates$2","shrink_count","alternates","shrink_count$0","alternates$0","alternate","alternates$1","with_sample_exn","quickcheck_observer","sizes$0","key_obs","data_obs","elt_obs","length$16","create$31","max_mem_waiting_gc_in_bytes","create$32","unsafe_blit$5","length$17","to_string$23","of_string$25","sexp_of_pos","v_offset","v_col","v_line","sexp_of_range","make_range_incl","last_pos","create$33","initial_pos","reset$2","add_uint16","add_bits","int_buf","add_gen","instr","instr_bits","add_newline","create$34","chunks","chunk","no_more","next_instruction_bits","added_bits","advance","skip","offset_shift","offset_shift_num_bits","skip$0","offset_shift$0","offset_shift_num_bits$0","skip$1","offset_shift$1","offset_shift_num_bits$1","offset_shift$2","skip$2","advance_exn","find$7","sub_sexp_count","loop_list","sexps","loop$1","finalize","find$8","find$9","empty$11","get_many","empty$12","get_single","get_many$0","v_location","v_sub_sexp","v_user_exn","position","initial_state","error_state","rev_chunks","chunk_pos","extra_bits","is_ignoring","is_not_ignoring","raise$0","at_eof","reason","old_parser_exn","current_pos","set_automaton_state","advance$0","advance_eol","newline_offset","add_token_char","add_atom_char","add_quoted_atom_char","check_new_sexp_allowed","is_single","add_pos","add_first_char","eps_add_first_char_hash","start_quoted_string","eps_add_escaped_cr","hex_val","add_dec_escape_char","opening","do_reset_positions","reset_positions","toplevel_sexp_or_comment_added","saved_offset","saved_full_sexps","stack$0","is_top_level","comment_added_assuming_cst","sexp_added","inner_comment_depth","is_comment","make_list","add_comment_to_stack_cst","comment","add_sexp_to_stack_cst","rev_comments","hash_semi_pos","closing","stack$1","end_pos","make_loc","add_non_quoted_atom_pos","eps_push_atom","push_quoted_atom","start_line_comment","end_line_comment","eps_eoi_check","create$35","Stack","tr_00","tr_01","tr_02","tr_03","tr_04","tr_05","tr_06","tr_07","tr_08","tr_09","tr_10","tr_11","tr_12","tr_13","tr_14","tr_15","tr_16","tr_17","tr_18","tr_19","tr_20","tr_21","tr_22","tr_23","tr_24","tr_25","tr_26","tr_27","tr_28","tr_29","tr_30","stack$2","tr_31","tr_32","tr_33","tr_34","tr_35","tr_36","tr_37","tr_38","tr_39","tr_40","tr_41","tr_42","tr_43","tr_44","tr_45","tr_46","tr_47","tr_48","tr_49","tr_50","tr_51","tr_52","tr_53","tr_54","tr_55","tr_56","tr_57","tr_58","tr_59","tr_60","tr_61","tr_62","tr_63","tr_64","tr_65","tr_66","tr_67","tr_68","tr_69","tr_70","tr_71","tr_72","tr_73","tr_74","tr_75","tr_76","tr_77","tr_78","tr_eoi_00","tr_eoi_01","tr_eoi_02","tr_eoi_03","tr_eoi_04","tr_eoi_05","tr_eoi_06","tr_eoi_07","transitions","transitions_eoi","old_parser_approx_cont_states","feed_eoi","feed_substring_unsafe","stop","feed_subbytes_unsafe","match$1","make_value","mode$0","make_value$0","make_value$1","mode$1","make_value$2","mode$2","make_value$3","make_value$4","mode$3","make_value$5","mode$4","make_value$6","make_value$7","mode$5","make_value$8","make_value$9","apply_f","apply_f$0","apply_f$1","to_binable","of_binable","bin_shape_t","of_bigstring","to_bigstring","prefix_with_length","bigstring_length","group$3","bin_shape_t$0","bin_size_t","bin_write_t","bin_writer_t","bin_read_t","vint","bin_read_t$0","bin_reader_t","bin_t","compare$38","a_001","hash_fold_t$21","hash$20","t_of_sexp$16","sexp_of_t$29","group$4","bin_shape_t$1","bin_size_t$0","bin_write_t$0","bin_writer_t$0","bin_read_t$1","bin_read_t$2","bin_reader_t$0","bin_t$0","compare$39","a_003","b_004","hash_fold_t$22","hash$21","t_of_sexp$17","sexp_of_t$30","group$5","bin_shape_t$2","bin_size_t$1","bin_write_t$1","bin_writer_t$1","bin_read_t$3","bin_read_t$4","bin_reader_t$1","bin_t$1","compare$40","a_005","b_006","hash_fold_t$23","hash$22","t_of_sexp$18","atom$0","t_of_sexp$19","sexp_of_t$31","group$6","bin_shape_t$3","bin_size_t$2","size_args","bin_write_t$2","bin_writer_t$2","bin_read_t$5","arg_1","bin_read_t$6","bin_reader_t$2","bin_t$2","compare$41","a_007","b_008","right_010","left_009","hash_fold_t$24","hsv$0","hash$23","t_of_sexp$20","t_of_sexp$21","sexp_of_t$32","group$7","bin_shape_t$4","bin_size_t$3","bin_write_t$3","bin_writer_t$3","bin_read_t$7","bin_read_t$8","bin_reader_t$3","bin_t$3","compare$42","a_011","b_012","right_016","left_015","hash_fold_t$25","hash$24","t_of_sexp$22","sexp_of_t$33","group$8","bin_shape_t$5","bin_size_t$4","bin_write_t$4","bin_writer_t$4","bin_read_t$9","bin_read_t$10","bin_reader_t$4","bin_t$4","compare$43","a_017","b_018","hash_fold_t$26","hash$25","t_of_sexp$23","sexp_of_t$34","group$9","bin_shape_t$6","t_of_sexp","size_of_a","write_a","a_029","b_030","a_031","b_032","group$10","bin_shape_t$7","bin_size_t$8","bin_write_t$8","bin_read_t$17","bin_shape_t$14","failwiths","of_alist","of_alist_report_all_dups","of_alist_or_error","of_alist_exn","of_alist_multi","create_mapped","create_with_key","create_with_key_or_error","create_with_key_exn","variant3","generator_033","generator_034","generator_035","size_040","random_041","size_038","random_039","size_036","random_037","tuple2","generator_166","generator_167","size_168","random_169","tuple3","generator_184","generator_185","generator_186","size_187","random_188","of_hash","list_with_length$0","empty$13","nondeterministic_state","random_state_of_seed","make_seed","make_shrink_count","make_config","trials","shrink_attempts","make_test_m","quickcheck_generator","sexp_of","quickcheck_shrinker$0","random_value","gen","random_sequence","test","testable","test_or_error","test_m","test_distinct_values","distinct_values","actual_count","sexp_of_elt","test_can_generate","sexp_of_value","default_sizes","map_t","set_t","create$39","representative","inner_node","inner","descendants","descendants$0","get$8","union$2","create$40","equal$17","union_find_get_check_no_pendin","check_no_pending_iterations","incr_length","incr_pending_iters","decr_pending_iters","with_iteration_2","with_iteration_3","with_iteration_4","create_aux","is_singleton","value$2","unsafe_split_or_splice","unsafe_split_or_splice_after","unsafe_split_or_splice_before","check_two_nodes_no_pending_ite","split_or_splice_before","insert_before","node","dummy_header","unlink","create$41","iter$20","length$19","fold$13","elt$0","iter$21","length$20","to_list$8","sexp_of_t$35","first$0","insert_empty","new_elt","add$11","remove_one","remove$8","move_to_front","first$1","after_elt","move_to_back","last","sexp_of_key","sexp_of_data","invariant","kv","growth_allowed","ensure_can_modify","lookup_exn","find_map","enqueue","back_or_front","enqueue_back","enqueue_front","enqueue_exn","enqueue_back_exn","enqueue_front_exn","lookup_and_move_to_back_exn","lookup_and_move_to_back","lookup_and_move_to_front_exn","lookup_and_move_to_front","dequeue_with_key","maybe_kv","dequeue_with_key_exn","dequeue_back_with_key","dequeue_back_with_key_exn","dequeue_front_with_key","dequeue_front_with_key_exn","dequeue","dequeue_back","dequeue_front","first_with_key","dequeue_exn","dequeue_back_exn","dequeue_front_exn","count$0","sum$0","min_elt$0","max_elt$0","fold_result$0","fold_until$0","dequeue_all","remove_exn","lookup_and_remove","replace_exn","drop","drop_back","drop_front","sexp_of_t$0","of_data","hash_fold_t$0","bin_size_t$13","bin_write_t$13","bin_read_t$26","bin_read_t$27","t_of_sexp$25","sexp_of_t$36","equal$18","compare$45","hash_fold_t$30","bin_size_t$14","bin_write_t$14","bin_read_t$28","bin_read_t$29","typename_of_t$2","hash_fold_t$31","hash$30","comparator$14","bin_size_t$16","bin_write_t$16","bin_read_t$32","bin_read_t$33","bin_size_t$17","bin_write_t$17","bin_read_t$34","bin_read_t$35","bin_size_t$18","bin_write_t$18","bin_read_t$36","bin_read_t$37","of_string$27","bin_size_t$19","bin_write_t$19","bin_read_t$38","bin_read_t$39","bin_shape_t$38","bin_writer_t$19","bin_reader_t$19","bin_t$19","to_q","group$44","bin_shape_array$1","bin_size_array$0","bin_write_array$0","bin_read_array$1","compare_array","len_a","len_b","equal_array","group$45","bool$1","group$46","bin_shape_char$0","func$7","group$47","bin_shape_float$0","group$48","bin_shape_int","func$8","group$49","bin_shape_list$0","bin_size_list$0","bin_write_list$0","bin_read_list$0","compare_list$0","a_037","b_038","a_039","b_040","equal_list$0","a_041","b_042","a_043","b_044","group$50","bin_shape_option$0","bin_size_option$0","bin_write_option$0","bin_read_option$0","compare_option$0","a_049","b_050","a_051","b_052","equal_option$1","a_053","b_054","a_055","b_056","group$51","bin_shape_string","func$9","group$52","bin_shape_unit$0","group$53","bin_shape_sexp_list","group$54","bin_shape_sexp_option","group$55","bin_shape_t$48","sexp_of_t$37","t_of_sexp$26","compare$46","before_first_transition","to_external","of_external","bin_shape_t$50","group$56","bin_shape_t$51","group$57","bin_shape_t$52","group$58","bin_shape_t$53","compare$47","original_filename","zone","digest","bool_of_int","long$0","int32_of_char","input_long_as_int32","sb1","sb2","sb3","sb4","input_long_as_int","input_long_as_int63","input_long_long_as_int63","int63_of_char","long_long","result$0","result$1","result$2","result$3","result$4","result$5","result$6","input_list","lst$0","input_array","input_regime","utc_offset_in_seconds","is_dst","abbrv_index","abbrv","input_tz_file_gen","input_transition","input_leap_second","utc_local_count","std_wall_count","leap_count","transition_count","type_count","transition_times","transition_indices","regimes","raw_abbrvs","abbrvs","next_index","abbrvs$0","indexed_abbrvs","leap_seconds","regime","new_regime","start_time_in_seconds_since_ep","ltt","default_local_time_type","input_leap_second_gen","time_in_seconds_since_epoch","seconds","read_header","magic","input_tz_file_v1","input_tz_file","zonename","version","x_001","make_zone","of_utc_offset","sexp_of_t$39","likely_machine_zones","utc","name$76","reset_transition_cache","get_regime_exn","effective_start_time","index_lower_bound_contains_sec","index_upper_bound_contains_sec","binary_search_index_of_seconds","transition","index_of_seconds_since_epoch","index$1","index$2","index$3","index$4","index_has_prev_clock_shift","index_has_next_clock_shift","index_prev_clock_shift_time_ex","index_prev_clock_shift_amount_","index_abbreviation_exn","validation_failed","create_exn","raw","to_type_id","sexp_of_t$40","sexp_of_type_id","type_id","type_id1","type_id2","name_of_key","uid_of_key","type_id_name","type_id_uid","sexp_of_t$1","mem_by_id","remove_by_id","add_exn","change_exn","change","orig","to_alist","sexp_of_t$2","invariant$0","empty$0","set$0","mem$0","mem_by_id$0","find$0","find_exn$0","add$0","add_exn$0","change$0","change_exn$0","update$0","remove$0","remove_by_id$0","to_alist$0","find$10","empty$14","race_free_create_loop","make","new_x","create$42","uncurry","group$59","bin_shape_t$54","bin_size_t$23","bin_write_t$24","bin_writer_t$25","bin_read_t$48","bin_read_t$49","bin_reader_t$25","bin_t$25","compare$48","hash_fold_t$33","hash$32","size_018","random_019","size_016","random_017","size_014","random_015","size_012","random_013","size_010","random_011","size_008","random_009","size_006","random_007","to_string$26","of_string_internal","of_int_exn$2","of_string$29","compare$49","comparator$15","hash$33","int63_ten","int63_twenty","int63_billion","digits_of_positive_int63","digits_of_int63_max_value","max_int63_with","billions","digit_of_char","write_1_digit_int","return_tens_and_write_ones","tens","ones","write_2_digit_int","write_3_digit_int","write_4_digit_int","write_5_digit_int","write_6_digit_int","write_7_digit_int","write_8_digit_int","write_9_digit_int","read_1_digit_int","read_2_digit_int","max_scale","check_pos$0","check_write","write_2_digit_int$0","write_3_digit_int$0","write_int63","digits$1","int63$1","custom_printf_003","custom_printf_004","digits$0","check_read","read_1_digit_int$0","read_2_digit_int$0","t_of_sexp$29","sexp_of_t$42","compare$50","hash_fold_t$34","of_int_exn$3","to_int$5","to_binable$1","of_binable$1","bin_size_t$24","bin_write_t$25","bin_read_t$50","bin_read_t$51","bin_shape_t$55","bin_writer_t$26","bin_reader_t$26","bin_t$26","num_months","t_of_sexp$30","all_strings","hash$34","bin_shape_t$56","create0","year","month","all_strings$0","days_in_month","bin_read_t$52","bin_read_t$53","bin_reader_t$27","bin_size_t$25","bin_write_t$26","bin_writer_t$27","bin_t$27","unchecked_value","none$0","to_string$27","parse_year4","parse_day","ensure","month_num","month_abrv","year$0","of_string$30","y_field","m_field","d_field","field_sexp$3","field_sexp$0","field_sexp$1","fvalue$0","field_sexp$2","fvalue$1","d_value","m_value","y_value","t_of_sexp$31","sexp_of_t$43","compare$52","sexp_of_t$44","compare$54","unix_epoch","of_year","of_date","c_10_000","c_14_780","c_3_652_425","to_date","days","ddd","ddd$0","y$2","unix_epoch$0","add_days","gen_incl","quickcheck_generator$3","hash$35","suffixes","am_suffixes","pm_suffixes","find_suffix","suffixes$0","suffixes$1","has_colon","decrement_length_if_ends_in_sp","invalid_string","parse$0","am_or_pm","expect_minutes_and_seconds","hr$1","expect_seconds","subsec_nonzero","subsec_len","subsec_pos","sec","sec$1","nonzero","hr$0","sec$0","subsec_len$0","parse_iso8601_extended","verify","of_binable$2","to_binable$2","t_of_sexp$32","to_string$28","x_abs","of_string$31","float_of_string","group$60","bin_shape_t$57","bin_writer_t$28","bin_reader_t$28","bin_t$28","t_of_sexp$33","format_decimal","tenths","units","compare$55","t_of_sexp$34","sign_field","hr_field","min_field","sec_field","ms_field","us_field","ns_field","field_sexp$7","fvalue$2","field_sexp$4","fvalue$3","field_sexp$5","fvalue$4","field_sexp$6","fvalue$5","ns_value","us_value","ms_value","sec_value","min_value","hr_value","sign_value","sexp_of_t$45","v_ns","v_us","v_ms","v_sec","v_min","v_hr","v_sign","bnds$4","bnds$5","robust_comparison_tolerance","symbol$145","symbol$146","symbol$147","symbol$148","symbol$149","symbol$150","robustly_compare","integral","fractional","nanoseconds","nanoseconds$0","seconds$0","ns","microseconds","us","milliseconds","to_span_since_epoch","divide_by_unit_of_time","unit_of_time","scale_by_unit_of_time","sth$3","sth$4","sth$5","sth$6","span","percent","factor","abs_t","suffix_of_unit_of_time","invalid_string$0","state_is_final","invalid_string$1","magnitude$0","suffix_index","unit_of_time_list$0","unit_of_time$0","float_string","magnitude$1","string_of_float_without_traili","sum$3","sum_t","to_float_string","fixup_unit_of_time","sum_t$0","rem_t","fixup_magnitude","to_int_string_and_sum","unit_span","new_sum_t","new_rem_t","next_magnitude","next_sum_t","next_rem_t","new_sum_t$0","symbol$153","magnitude_string","day_string","hour_string","sum_t$1","minute_string","order_of_magnitude_of_first_di","half_ulp","order_of_magnitude_of_final_di","number_of_digits","decimals","align_decimal","float$1","suffix$7","group$61","bin_shape_t$58","bin_writer_t$29","bin_reader_t$29","bin_t$29","hash$36","t_of_sexp$36","group$62","bin_shape_t$59","bin_writer_t$30","bin_reader_t$30","bin_t$30","t_of_sexp$37","symbol$154","symbol$155","symbol$156","symbol$157","symbol$158","symbol$159","robustly_compare$0","to_span_since_start_of_day","is_valid","of_span_since_start_of_day_unc","span_since_start_of_day_is_val","of_span_since_start_of_day","start_of_next_day","start_of_day","add$12","sub$4","next$3","candidate","prev$0","diff$1","approximate_end_of_day","create$44","ns$0","us$0","ms$0","to_parts$0","to_string_gen","drop_ms","drop_us","drop_us$0","dont_print_us","dont_print_ms","dont_print_s","to_string_trimmed","to_sec_string","to_millisec_string","small_diff","ofday1","ofday2","to_string$30","create_from_parsed","subsec","of_string$33","t_of_sexp$38","sexp_of_t$47","of_string_iso8601_extended","gen_incl$1","gen_uniform_incl$0","quickcheck_generator$4","quickcheck_observer$4","quickcheck_shrinker$3","group$63","bin_shape_t$60","bin_writer_t$31","bin_reader_t$31","bin_t$31","hash$37","t_of_sexp$39","group$64","bin_shape_t$61","bin_writer_t$32","bin_reader_t$32","bin_t$32","t_of_sexp$40","epoch","is_earlier","is_later","of_span_in_seconds","span_in_seconds","of_time_in_seconds","time_in_seconds","time$0","index_of_date_and_ofday","relative","index_offset_from_utc_exn","index_prev_clock_shift_time_ex$0","index_next_clock_shift_time_ex","index_prev_clock_shift_amount_$0","index_next_clock_shift_amount_","abbreviation","index_prev_clock_shift","prev_clock_shift","next_clock_shift","date_and_ofday_of_absolute_tim","offset_from_utc","absolute_time_of_date_and_ofda","abs_diff","of_date_ofday","ofday","of_date_ofday_precise","proposed_time","shift_amount","shift_start","shift_backwards","date_cache","reset_date_cache","set_date_cache","rel","effective_day_start","effective_day_until","cache_start_incl","cache_until_excl","to_ofday","to_date_ofday","to_date_ofday_precise","clock_shift_after","clock_shift_before_or_at","amount","ofday$0","ambiguity","amount$0","from_tz","to_tz","start_time","utc_offset$0","utc_epoch","offset_string","utc_offset","is_utc","to_string_abs_parts","offset_string$0","to_string_abs_trimmed","to_string_abs","to_string_iso8601_basic","to_filename_string","of_filename_string","date$0","ofday$1","of_localized_string","occurrence","before_or_after","first_guess_date","first_guess","increment","ensure_colon_in_offset","offset_length","of_string_gen","default_zone","find_zone","ofday$2","tz","ofday$3","date$1","ofday_to_sec","od","tz$0","utc_offset$1","utc_t","zone_name","gen_uniform_incl","of_synthetic_span_since_epoch","to_synthetic_span_since_epoch","to_absolute","of_absolute","absolute","sec_per_day","to_days_from_epoch","days_from_epoch_approx","ofday_of_days_from_epoch","days_from_epoch","days_from_epoch_in_sec","date_of_days_from_epoch","to_date$0","next_multiple_internal","can_equal_after","interval","base_to_after","can_equal_before","float_ns","group$65","bin_shape_t$62","nanosecond$0","microsecond$0","millisecond$0","second$1","minute$0","hour$0","max_value_for_1us_rounding","min_value_for_1us_rounding","of_int_sec$0","of_sec","to_sec$0","to_int_sec","group$66","bin_shape_t$63","bin_writer_t$33","bin_reader_t$33","bin_t$33","compare$56","number_of_digits_to_write","span_part_magnitude","write_char","write_2_chars","char1","char2","write_digits","write_if_non_empty","nanos_of_millisecond","nanos_of_microsecond","int63_60","int63_24","digits_of_d","digits_of_h","digits_of_m","decimal_unit","decimal_unit_integer","decimal_unit_billionths","decimals_of_decimal_unit","sign_len","d_len","h_len","m_len","digits_len","decimals_len","decimal_unit_len","string_length","int63_10","min_mult10_without_underflow","invalid_string$2","add_without_underflow","min_factor_of","min_days_without_underflow","min_hours_without_underflow","min_minutes_without_underflow","min_seconds_without_underflow","min_milliseconds_without_under","min_microseconds_without_under","min_nanoseconds_without_underf","neg_ns","round_ties_before_negating","has_digit","end_of_digits","digit$0","neg_integer","decimal_pos","end_of_decimals","scale$0","min_without_underflow","neg_integer_ns","neg_nanos_of_part","divisor$0","round_at","numerator","denominator","comparator$17","compare$57","float$2","suffix$0","group$67","bin_shape_t$64","bin_writer_t$34","bin_reader_t$34","bin_t$34","compare$58","hash$38","group$68","bin_shape_t$65","bin_writer_t$35","bin_reader_t$35","bin_t$35","group$69","bin_shape_t$66","create_from_parsed$0","of_string$35","t_of_sexp$42","to_string$32","thousand","sexp_of_t$49","group$70","bin_shape_t$67","bin_writer_t$36","bin_reader_t$36","bin_t$36","group$72","bin_shape_t$69","bin_size_t$26","bin_write_t$27","bin_read_t$54","bin_read_t$55","t_of_sexp$43","sexp_of_t$51","of_format","to_format","create$45","set_exn","get_exn","compare$60","t_of_sexp$44","minor_words_field","promoted_words_field","major_words_field","minor_collections_field","major_collections_field","heap_words_field","heap_chunks_field","live_words_field","live_blocks_field","free_words_field","free_blocks_field","largest_free_field","fragments_field","compactions_field","top_heap_words_field","stack_size_field","forced_major_collections_field","field_sexp$17","fvalue$6","field_sexp$8","fvalue$7","field_sexp$9","fvalue$8","field_sexp$10","fvalue$9","field_sexp$11","fvalue$10","field_sexp$12","fvalue$11","field_sexp$13","fvalue$12","field_sexp$14","fvalue$13","field_sexp$15","fvalue$14","field_sexp$16","fvalue$15","forced_major_collections_value","stack_size_value","top_heap_words_value","compactions_value","fragments_value","largest_free_value","free_blocks_value","free_words_value","live_blocks_value","live_words_value","heap_chunks_value","heap_words_value","major_collections_value","minor_collections_value","major_words_value","promoted_words_value","minor_words_value","sexp_of_t$52","v_forced_major_collections","v_stack_size","v_top_heap_words","v_compactions","v_fragments","v_largest_free","v_free_blocks","v_free_words","v_live_blocks","v_live_words","v_heap_chunks","v_heap_words","v_major_collections","v_minor_collections","v_major_words","v_promoted_words","v_minor_words","bnds$6","arg$7","bnds$7","arg$8","bnds$8","arg$9","bnds$9","arg$10","bnds$10","arg$11","bnds$11","arg$12","bnds$12","arg$13","bnds$13","arg$14","bnds$14","arg$15","bnds$15","compare$61","t_of_sexp$45","minor_heap_size_field","major_heap_increment_field","space_overhead_field","verbose_field","max_overhead_field","stack_limit_field","allocation_policy_field","window_size_field","custom_major_ratio_field","custom_minor_ratio_field","custom_minor_max_size_field","custom_minor_max_size_value","custom_minor_ratio_value","custom_major_ratio_value","window_size_value","allocation_policy_value","stack_limit_value","max_overhead_value","verbose_value","space_overhead_value","major_heap_increment_value","minor_heap_size_value","sexp_of_t$53","v_minor_heap_size","v_major_heap_increment","v_space_overhead","v_verbose","v_max_overhead","v_stack_limit","v_allocation_policy","v_custom_minor_max_size","v_custom_minor_ratio","v_custom_major_ratio","v_window_size","return$14","capture","general","hashable$2","cache_size_bound","hashable$1","cache$0","hashable$0","cache","really_call_f","create$46","initial_length","never_shrink","never_shrink$0","initial_length$0","arr_length","length$21","is_empty$7","assert_not_empty","of_array$3","new_arr","actual_front","actual_back","old_arr","break_pos","get$9","i_from_zero","apparent_front","apparent_back","true_i","max_int","add$15","sub$6","div","rem$5","logand","logor","logxor","shift_left$4","shift_right$4","of_int$4","of_int64$1","to_int64$2","zero$5","one$3","lognot$1","succ$5","pred$5","compare$62","equal$20","max$20","min$20","pp$17","max_int$0","add$16","sub$7","mul$0","div$0","rem$6","logand$0","logor$0","logxor$0","shift_left$5","shift_right$5","of_int$5","of_int64$2","to_int64$3","zero$6","one$4","lognot$2","succ$6","pred$6","compare$63","equal$21","max$21","min$21","pp$18","max_int$1","zero$7","one$5","lognot$3","succ$7","pred$7","compare$64","equal$22","max$22","min$22","pp$19","max_int$2","succ$8","pred$8","compare$65","max$23","min$23","pp$20","of_byte_size","to_binable$3","of_binable$3","to_binable$4","of_binable$4","pp_open_xbox","extra_box","open_tag","close_tag","tag_string","fprint_opt_label","lp","fprint_t","fprint_list_body_stick_left","fprint_list","indent$0","cl$0","sep$0","op$0","base_indent","sep_indent","close_extra$0","open_extra$0","close_extra","open_extra","equal$25","create$47","really_extend","slen0","reqlen","create$48","make_room","shrlen","alloc$0","add_sub","add_substring","write_stringlit","add$17","clear$5","contents$0","json_error","utf8_of_code","maxbits","is_object_or_array","init_lexer","lnum","buf$0","buf$1","write_special","ob","finish_string","json_string_of_string","float_needs_period","tuple$1","variant$1","std","ob$0","s$3","hex$0","write_special$0","finish_string$0","write_string","write_null","write_bool","max_digits","write_digits$0","write_int","float_needs_period$0","iter2$4","f_elt","f_sep","write_t","write_std_json","to_string$34","std$0","read_junk","junk","to_basic","hex$1","write_special$1","finish_string$1","write_string$0","write_null$0","write_bool$0","max_digits$0","write_digits$1","write_int$0","float_needs_period$1","iter2$5","f_sep$0","write_t$0","write_std_json$0","to_string$35","hex$2","custom_error","descr","offs","bol","file_line","read_junk$0","long_error","extra_junk","extract_positive_int","extract_negative_int","newline","read_colon","read_object_sep","read_object_end","read_tuple_sep","read_tuple_end","read_array_sep","read_array_end","finish_string$2","ocaml_lex_state$3","ocaml_lex_state$4","high10","low10","read_ident","finish_comment","read_space","read_json$0","ocaml_lex_read_json_rec","field_name","read_json","field_name$0","cons","finish_variant","read_eof","junk$0","from_lexbuf","stream","from_string$0","typerr","js","assoc","member","to_string$36","read_junk$1","junk$1","symbol_bind$5","symbol$169","map_bind","safe_map","func$10","func$11","var_to_bits","gen$0","equal$26","rhs1","rhs0","lhs1","lhs0","of_interval","canonicalize","a4","a3","disjoint_union_exn","of_intervals_exn","is","is$0","invariant$9","gen_from","min_size","go","gen$1","gen_disjoint_pair","y0","y3","num_bits$5","compare$66","equal$27","symbol$170","symbol$171","of_int$6","symbol$172","symbol$173","symbol$174","symbol$175","to_int_exn$1","to_string$37","of_string$38","shift_left$6","shift_right$6","log_and","log_or","two_to_the_i","compare$67","is_integer_string","char_is_digit","of_string_base","of_string_no_underscores","group$74","bin_shape_t$71","bin_size_t$28","bin_write_t$29","bin_read_t$58","bin_read_t$59","arg_1$0","to_binable$5","of_binable$5","t_of_sexp$46","sexp_of_t$54","bin_size_t$29","bin_write_t$30","bin_read_t$60","bin_read_t$61","bin_shape_t$72","bin_writer_t$37","bin_reader_t$37","bin_t$37","to_string_hum$11","range_at_depth","random_bigint_at_depth","prev_depth","range$0","tolerance_factor","depth$0","int$4","bits$3","extra_bytes","num_bytes","hash$40","to_string$39","char_is_hex_digit","of_hex_string_no_underscores","of_string$40","module_name$31","cvar_of_sexp","of_f","sexp_of_cvar","of_index","var$5","bind$1","return$2","unhandled","fail$0","run$2","label_stack","req","hs","handle","req$1","create_single","request","bind$13","return$15","run$3","map2$4","read_var","value_of_fields","var_to_fields","field_vars","fields","map$30","symbol_bind$6","bind$14","return$16","map$31","join$8","ignore_m$0","all$3","all_unit$0","run$4","rc","rc$0","value$3","cases","add_case","case$0","sexp_of_basic","of_basic","unhandled$0","sexp_of_t$55","t_of_sexp$47","to_basic$0","map$32","v3","Field","get_value","override_label","label_opt","basic","equal$28","boolean$0","r1cs","annotation","unit$0","create$49","get$10","emplace_back","length$22","dummy_vector","get$11","T","make$4","num_inputs","next_auxiliary","system","eval_constraints","log_constraint","with_witness","is_running","eval_constraints$0","as_prover","set_as_prover","set_stack","set_handler","constraint_count","direct","assert_equal","assert_all","assert_square","assert_r1cs","assert","with_label","handle_as_prover","exists_handle","request_witness","mk_lazy","create$50","stack_to_string","eval_constraints_ref","run$5","return$17","map$33","bind$15","symbol_bind$7","symbol_map$2","bind$16","return$18","map$34","join$9","ignore_m$1","all$4","all_unit$1","field_vec_id","pack_field_vec","field_vec","auxiliary_input","t0","handlers","return_typ","auxiliary_output_data","output$0","true_output","auxiliary_input_size","run_and_check_exn","get_one","run_and_check","run_and_check_deferred_exn","run_and_check_deferred","run_unchecked","run_and_check_exn$0","run_and_check$0","check_exn","alloc_var","next_input","store_field_elt","primary_input","collect_input_constraints","input_typ","alloc_input","constraint_system_auxiliary","size_in_field_elements","var_of_fields","retval","circuit","r1cs_h","return_typ$0","checked","checked$0","constraint_system","generate_public_input","value_to_fields","store_field_elt$0","cont0","k0","fields$0","generate_auxiliary_input","primary","generate_witness_conv","auxiliary","read_cvar","output$1","inputs","generate_witness","generate_witness$0","generate_witness_conv$0","constraint_system$0","generate_auxiliary_input$0","generate_public_input$0","generate_witness$1","generate_witness_conv$1","constraint_system$1","run_unchecked$0","run_and_check$1","run_and_check_exn$1","check$0","check_exn$0","snarkless","typ","ref","transport","there","back","transport_var","auxes","num_fields","end_pos$0","fieldss","hlist","spec0","spec0$0","typ1","typ2","typ3","tuple4","typ4","tuple5","typ5","tuple6","typ6","of_hlistable","var_to_hlist","var_of_hlist","value_to_hlist","value_of_hlist","field$0","transport$0","transport_var$0","array$0","hlist$0","tuple2$0","tuple3$0","tuple4$0","tuple5$0","tuple6$0","of_hlistable$0","field_to_int","bs","to_field","of_field","typ$0","to_bits","ith_bit","if$0","then","else$0","t_of_sexp$48","non_empty_tree_of_sexp","tree_of_sexp","implied_root","entry_hash","addr0","path0","addr","let_syntax_001","fetch_and_update_req","prev_path","prev","next_entry_hash","new_root","let_syntax_003","prev_entry_hash","modify_req","get_req","update_req","let_syntax_006","let_syntax_007","let_syntax_008","let_syntax_009","pow2","bigint_num_bits","two_to_the","of_bits","mul_pow_2","multiplied","div_pow_2","divided","divided_of_bits","clamp_to_n_bits","bs$0","bit_length","less","less_or_equal","to_var","constant","tick_n","of_pow_2","ceil_div_pow_2","floor_div","m_divides_n","mod_pow_2","x_div_n","n_x_div_n","set_constraint_logger","clear_constraint_logger","constant$0","all$5","assert$0","exists$1","all$6","join$0","map$2","perform","z_inv","x_inv","y_inv","then$0","true$0","false$0","not","if$1","and_for_square_constraint_syst","x_plus_y","both_false","any","all_zero","to_constant","var_of_value","typ$1","typ_unchecked","num_true","any$0","all$0","any$1","all$1","equal$0","of_cvar","is_true","any$2","exactly_one","not$0","any$3","choose_preimage_unchecked","packing_sum","choose_preimage","lc","choose_preimage_flagged","all_unit$2","all$8","fold_map","any$5","all$9","foldi$1","iteri$0","mapi$0","fold_map$0","existsi$0","exists$0","for_alli$0","for_all$1","two","project","pack","unpack","unpack_flagged","lo_bigint","hi_bigint","gen_uniform","parity","square$0","sqrt","quadratic_nonresidue","sqrt_check","is_square","typf","answer","alpha_packed","alpha","not_all_zeros","lte","gt","gte","non_zero","not_equal","of_binary","eval$1","lt_binary","ys$0","ys$1","lt_bitstring_value","field_size_bits","unpack_full","parity$0","unpack_full$0","unpack_full$1","lt_value","chunk_for_equality","chunk_size","t1_b","t1_a","t2_a","equal$2","equal_expect_true","equal$3","correct_answer","if$2","then_aux","else_aux","else$1","res_aux","res_aux$0","checked_to_unchecked","checked_result","test_equal","unchecked","add_constraint","set_primary_input_size","set_auxiliary_input_size","get_public_input_size","get_rows_len","of_bignum_bigint","to_bignum_bigint","two_to_the_i$0","two_to_the_i$1","negate$0","to_bignum_bigint$0","of_bignum_bigint$0","of_f$0","scratch","context","terms$1","constant$1","to_constant_and_terms","neg_one","linear_combination","terms","var_indices","t_of_sexp$0","basic_field","annotation_field","annotation_value","basic_value","v_annotation","v_basic","fm","constraint_logger","run_as_prover","as_prover$0","old_stack","var2","var1","var2$0","var1$0","var3","var2$1","var1$1","system$0","C","with_handler","store_value","log","at_label_boundary","run_as_prover$0","get_value$0","constraint_count$0","direct$0","next_auxiliary$0","with_handler$0","with_label$0","mk_lazy$0","as_prover$1","add_constraint$0","fake_state","log_constraint$0","sys","constraint_count$1","direct$1","next_auxiliary$1","with_handler$1","with_label$1","mk_lazy$1","as_prover$2","add_constraint$1","ignore_m$2","such_that","such_that$0","compute","request$0","provider","custom_printf_002","symbol_map$3","bind$2","return$3","map$3","join$2","ignore_m$3","all_unit$3","as_prover$3","mk_lazy$2","request_witness$0","exists_handle$0","exists$2","handle$0","handle_as_prover$0","next_auxiliary$2","with_label$2","assert_r1cs$0","assert_square$0","assert_all$0","assert_equal$0","direct$2","constraint_count$2","set_constraint_logger$0","clear_constraint_logger$0","symbol_bind$4","symbol_map$4","bind$3","return$4","map$4","ignore_m$4","all_unit$4","as_prover$4","mk_lazy$3","request_witness$1","request$1","exists_handle$1","exists$3","unhandled$1","handle$1","handle_as_prover$1","next_auxiliary$3","with_label$3","assert$1","assert_r1cs$1","assert_square$1","assert_all$1","assert_equal$1","direct$3","constraint_count$3","functor_counter","active_counters","is_active_functor_id","active","dump","in_prover","in_checked_computation","as_stateful","make_checked","size_in_bits","of_int","print","sub$0","sqrt$0","is_square$0","size_in_bits$0","print$0","random$0","symbol$19","symbol$20","of_string$0","unpack$0","project$0","zero$1","mul$1","square$1","inv$1","is_square$1","sqrt$1","unpack$1","parity$1","choose_preimage_var","symbol$21","symbol$22","equal$5","eval_as_prover","in_prover_block","of_int$2","one$2","sub$1","mul$2","inv$2","square$2","sqrt$2","is_square$2","size_in_bits$1","print$1","random$1","symbol$23","symbol$24","symbol$25","negate$1","symbol$26","symbol$27","symbol$28","symbol$29","unpack$2","project$1","parity$2","run_prover","mark_active","counters","mark_active_deferred","compute$0","lbl","inject_wrapper","finalize_is_running","cached_state","prover_block","this_functor_id","run_checked","shape_tbl","register","path_to_type","ty_decl","shape$0","canonical1","canonical2","create$51","substring","buffer_len","length$23","bytes_for_client_to_commit","offset_in_buffer","apply$5","unsafe_get_char","count_while","lift2","succ1","input1","more1","succ2","input2","more2","symbol$188","symbol$189","more$0","marks","prompt","parser_uncommitted_bytes","parser_committed_bytes","continue$0","demand_input","ensure_suspended","commit","peek_char_fail","satisfy","count_while$0","with_buffer","input_len","count_while1","succ$1","fail$1","string$2","take_while","take_while1","ps","failure_msg","cons$2","many1","steps","max_steps","interpolation","to_int$6","of_int$8","add$18","create$52","N","eq$0","pi","t_plus_n","compare$68","lte_exn","eq_exn","num_commitments_without_degree","to_nat","contr","singleton$0","func$12","length$24","func$13","hhead_off","xss$0","tls","hds","mapn","zip","to_list$9","to_array$4","init$9","map$35","of_list$7","of_list_and_length_exn","of_array_and_length_exn","fold$14","for_all$9","foldi$4","reduce_exn$1","to_yojson","poly_a","of_yojson","for_reader","cnv$0","cnv$1","a_to_b","b_to_a","b_sizer","cnv$2","b_writer","cnv$3","cnv$4","b_reader","cnv$5","sh","to_yojson$0","of_yojson$0","of_list_exn","there$0","back$0","append$5","adds","adds$0","rev$0","split$6","transpose","tails","heads","trim_front","extend_front_exn","dummy","extend_exn","extended","extend_front","bin_shape_t$73","bin_size_t$30","bin_write_t$31","bin_read_t$62","bin_shape_t$74","bin_size_t$31","bin_write_t$32","bin_read_t$63","bin_read_t$64","compare$69","hash_fold_t$37","equal$29","t_of_sexp$49","sexp_of_t$56","bin_shape_t$75","bin_size_t$32","bin_write_t$33","bin_read_t$65","compare$70","hash_fold_t$38","equal$30","to_yojson$1","of_yojson$1","t_of_sexp$50","sexp_of_t$57","compare$71","hash_fold_t$39","equal$31","to_yojson$2","of_yojson$2","t_of_sexp$51","sexp_of_t$58","to_list$10","bin_shape_t$76","bin_size_t$33","bin_write_t$34","bin_read_t$66","compare$72","hash_fold_t$40","equal$32","to_yojson$3","of_yojson$3","t_of_sexp$52","sexp_of_t$59","compare$73","hash_fold_t$41","equal$33","to_yojson$4","of_yojson$4","t_of_sexp$53","sexp_of_t$60","bin_shape_t$77","bin_size_t$34","bin_write_t$35","bin_read_t$67","compare$74","hash_fold_t$42","equal$34","t_of_sexp$54","sexp_of_t$61","compare$75","hash_fold_t$43","equal$35","to_yojson$5","of_yojson$5","t_of_sexp$55","sexp_of_t$62","bin_shape_t$78","bin_size_t$35","bin_write_t$36","bin_read_t$68","compare$76","hash_fold_t$44","equal$36","to_yojson$6","of_yojson$6","t_of_sexp$56","sexp_of_t$63","compare$77","equal$37","t_of_sexp$57","sexp_of_t$64","of_list_exn$0","bin_shape_t$79","bin_size_t$36","bin_write_t$37","bin_read_t$69","compare$78","hash_fold_t$45","equal$38","to_yojson$7","of_yojson$7","t_of_sexp$58","sexp_of_t$65","compare$79","hash_fold_t$46","equal$39","to_yojson$8","of_yojson$8","t_of_sexp$59","sexp_of_t$66","bin_shape_t$80","bin_size_t$37","bin_write_t$38","bin_read_t$70","compare$80","hash_fold_t$47","equal$40","to_yojson$9","of_yojson$9","t_of_sexp$60","sexp_of_t$67","to_yojson$10","poly_f","arg0","symbol$190","group$75","bin_shape_t$81","bin_size_t$38","size_of_f","bin_write_t$39","write_f","bin_writer_t$38","bin_writer_f","bin_read_t$71","bin_read_t$72","bin_reader_t$38","bin_reader_f","bin_t$38","bin_f","versioned","t_of_sexp$61","sexp_of_t$68","compare$81","cmp_f","equal$41","hash_fold_t$48","hash_fold_f","a0","to_yojson$11","symbol$191","t_of_sexp$62","sexp_of_t$69","compare$82","a_009","hash_fold_t$49","map$36","map$37","create$53","equal$42","to_yojson$12","symbol$192","group$76","bin_shape_t$82","bin_size_t$39","bin_write_t$40","bin_writer_t$39","bin_read_t$73","bin_read_t$74","bin_reader_t$39","bin_t$39","versioned$0","t_of_sexp$63","sexp_of_t$70","compare$83","b_020","a_019","equal$43","a_021","b_022","b_024","a_023","hash_fold_t$50","to_yojson$13","symbol$193","t_of_sexp$64","sexp_of_t$71","compare$84","a_025","b_026","b_028","a_027","hash_fold_t$51","typ$2","func$14","map$38","create$54","of_field$0","to_field$0","equal$44","maxes","hash_fold_array","to_option_unsafe","value_exn$1","of_option","symbol$194","map$39","constant_layout_typ","bool_typ","a_typ","dummy_var","bool_typ$0","bool_typ$1","typ$3","group$77","bin_shape_t$83","t_of_sexp$65","range_check0_field","range_check1_field","foreign_field_add_field","foreign_field_mul_field","xor_field","rot_field","lookup_field","runtime_tables_field","runtime_tables_value","lookup_value","rot_value","xor_value","foreign_field_mul_value","foreign_field_add_value","range_check1_value","range_check0_value","to_hlist","runtime_tables","rot","xor","foreign_field_mul","foreign_field_add","range_check1","range_check0","of_hlist","to_data","map$40","group$78","bin_shape_t$84","bin_size_t$40","v25","v24","v23","v22","v21","v20","v19","v18","v17","v16","v15","v14","v13","v12","v11","v10","v9","v8","v7","v6","v5","v4","size$2","size$3","size$4","size$5","size$6","size$7","size$8","size$9","size$10","size$11","size$12","size$13","size$14","size$15","size$16","size$17","size$18","size$19","size$20","size$21","size$22","bin_write_t$41","bin_read_t$75","v_w","v_coefficients","v_z","v_s","v_generic_selector","v_poseidon_selector","v_complete_add_selector","v_mul_selector","v_emul_selector","v_endomul_scalar_selector","v_range_check0_selector","v_range_check1_selector","v_foreign_field_add_selector","v_foreign_field_mul_selector","v_xor_selector","v_rot_selector","v_lookup_aggregation","v_lookup_table","v_lookup_sorted","v_runtime_lookup_table","v_runtime_lookup_table_selecto","v_xor_lookup_selector","v_lookup_gate_lookup_selector","v_range_check_lookup_selector","v_foreign_field_mul_lookup_sel","t_of_sexp$66","w_field","coefficients_field","z_field","s_field","generic_selector_field","poseidon_selector_field","complete_add_selector_field","mul_selector_field","emul_selector_field","endomul_scalar_selector_field","range_check0_selector_field","range_check1_selector_field","foreign_field_add_selector_fie","foreign_field_mul_selector_fie","xor_selector_field","rot_selector_field","lookup_aggregation_field","lookup_table_field","lookup_sorted_field","runtime_lookup_table_field","runtime_lookup_table_selector_","xor_lookup_selector_field","lookup_gate_lookup_selector_fi","range_check_lookup_selector_fi","foreign_field_mul_lookup_selec","field_sexp$25","fvalue$16","field_sexp$18","fvalue$17","field_sexp$19","fvalue$18","field_sexp$20","fvalue$19","field_sexp$21","fvalue$20","field_sexp$22","fvalue$21","field_sexp$23","fvalue$22","field_sexp$24","fvalue$23","foreign_field_mul_lookup_selec$0","range_check_lookup_selector_va","lookup_gate_lookup_selector_va","xor_lookup_selector_value","runtime_lookup_table_selector_$0","runtime_lookup_table_value","lookup_sorted_value","lookup_table_value","lookup_aggregation_value","rot_selector_value","xor_selector_value","foreign_field_mul_selector_val","foreign_field_add_selector_val","range_check1_selector_value","range_check0_selector_value","endomul_scalar_selector_value","emul_selector_value","mul_selector_value","complete_add_selector_value","poseidon_selector_value","generic_selector_value","s_value","z_value","coefficients_value","w_value","t_of_sexp$67","to_hlist$0","range_check_lookup_selector","lookup_gate_lookup_selector","xor_lookup_selector","runtime_lookup_table_selector","runtime_lookup_table","lookup_sorted","lookup_table","lookup_aggregation","rot_selector","xor_selector","foreign_field_mul_selector","foreign_field_add_selector","range_check1_selector","range_check0_selector","endomul_scalar_selector","emul_selector","mul_selector","complete_add_selector","poseidon_selector","generic_selector","coefficients","of_hlist$0","validate_feature_flags","enable_if","range_check_lookup","lookups_per_row_4","lookups_per_row_3","lookups_per_row_2","to_hlist$1","of_hlist$1","map$41","to_list$11","always_present","optional_gates","to_absorption_sequence","to_in_circuit","map$42","to_list$12","group$79","to_hlist$2","public_input","of_hlist$2","to_hlist$3","of_hlist$3","p2","p1","group$80","f_multi","sexp_of_t$72","of_f_multi","v_ft_eval1","v_evals$0","arg$26","bnds$27","of_f_multi$0","v_evals","v_public_input","bnds$24","arg$16","bnds$16","arg$17","bnds$17","arg$18","bnds$18","arg$19","bnds$19","arg$20","bnds$20","arg$21","bnds$21","arg$22","bnds$22","arg$23","bnds$23","arg$24","bnds$25","arg$27","bnds$26","arg$25","bnds$28","to_hlist$4","of_hlist$4","to_hlist$5","of_hlist$5","map$43","f2$0","typ$4","Impl","single","uses_lookup","evals$0","group$81","bin_shape_t$85","fq","bin_size_t$41","size_of_g","size_of_fq","bin_write_t$42","write_g","write_fq","bin_read_t$76","of_g","of_fq","v_lr","v_z_1","v_z_2","v_delta","v_challenge_polynomial_commitm","to_hlist$6","challenge_polynomial_commitmen","z_2","z_1","of_hlist$6","group$82","to_yojson$14","poly_g","symbol$195","group$83","bin_shape_t$86","bin_size_t$42","bin_write_t$43","bin_read_t$77","compare$85","cmp_g","a_357","b_358","a_359","b_360","equal$45","a_361","b_362","a_363","b_364","group$84","bin_shape_t$87","to_hlist$7","aggreg","of_hlist$7","to_hlist$8","of_hlist$8","group$85","sorted_length","bin_shape_t$88","to_hlist$9","of_hlist$9","to_hlist$10","of_hlist$10","typ$6","commitment_lengths","runtime_tables$0","w_lens","wo","fqv","group$86","t_of_sexp$68","of_g$0","of_fqv","sexp$0","field_sexps$2","messages_field","openings_field","duplicates$2","extra$2","tail$2","sexp$1","field_sexps$0","proof_field","evals_field","ft_eval1_field","duplicates$0","extra$0","tail$0","lr_field","z_1_field","z_2_field","delta_field","challenge_polynomial_commitmen$0","delta_value","z_2_value","z_1_value","lr_value","ft_eval1_value","evals_value","proof_value","sexp$2","field_sexps$1","w_comm_field","z_comm_field","t_comm_field","duplicates$1","extra$1","tail$1","aggreg_field","runtime_field","runtime_value","aggreg_value","t_comm_value","z_comm_value","w_comm_value","openings_value","messages_value","group$87","bin_shape_t$89","comm","bin_size_t$43","size_of_comm","bin_write_t$44","write_comm","bin_read_t$78","of_comm","v_sigma_comm","v_coefficients_comm","v_generic_comm","v_psm_comm","v_complete_add_comm","v_mul_comm","v_emul_comm","v_endomul_scalar_comm","t_of_sexp$69","sigma_comm_field","coefficients_comm_field","generic_comm_field","psm_comm_field","complete_add_comm_field","mul_comm_field","emul_comm_field","endomul_scalar_comm_field","endomul_scalar_comm_value","emul_comm_value","mul_comm_value","complete_add_comm_value","psm_comm_value","generic_comm_value","coefficients_comm_value","sigma_comm_value","to_hlist$11","of_hlist$11","map$44","typ$7","num_bits$6","n_lt_2k","pow$6","combine_split_commitments","scale_and_add","xi","without_degree_bound","with_degree_bound","shifted","unshifted","flat","combine_split_evaluations","mul_and_add","evals0","es","fx","to_list$13","to_vector","of_vector","of_list_and_length_exn$0","of_sexpable","of_binable$6","bin_shape_t$90","bin_size_t$44","bin_write_t$45","bin_read_t$79","of_binable$7","map$45","round_constants","mds","pasta_p_legacy","pasta_p_kimchi","pasta_q_kimchi","id$1","make$5","sponge_state","capacity","sponge_state_of_sexp","sexp_of_sponge_state","copy","rate","absorb","squeeze","debug","operation","sponge","fe","to_blocks","field_elems","num_blocks","create_block","global_pos","sexpifier","first_half_rounds_full","block_cipher","sbox","constant_offset","second_half_rounds_full","slots_per_tuple","arch_sixtyfour$0","max_slot","t3","t4","t5","t13","masked_tuple_id_num_bits","max_array_length","tuple_id_mask","init$10","create$55","header_index","tuple_id","header_index_mask","invariant$10","slot_index","first_slot_index","null$4","is_null","is_used","metadata_index","start_of_tuples_index","max_capacity","array_indices_per_tuple","tuple_num_to_header_index","tuple_num","sexp_of_t$73","sexp_of_ty","v_capacity","v_slots_per_tuple","v_length","v_next_id","v_first_free","v_dummy","unsafe_set_header","pointer_is_valid","pointer","header_index$1","header_index$0","is_full","unsafe_add_to_free_list","metadata","set_metadata","create_array","unsafe_init_range","tuple_num$0","create_with_dummy","slots_per_tuple$0","max_capacity$0","grow","capacity$0","old_capacity","next_id","dummy$0","capacity$1","metadata$1","metadata$0","malloc","first_free","get$12","set$9","bin_writer_a","bin_reader_a","bin_a","group$0","t_of_sexp$70","sexp_of_t$74","validate$3","sexp_of_t$76","max_num_bits","invariant$11","of_int$9","symbol$196","symbol$197","pow2$0","num_bits_internal","create_exn$1","ints","extend_to_max_num_bits","ints$0","level_bits_default","to_sexpable$0","alarm_precision","of_sexpable$0","sexp_of_t$78","v_level_bits","v_alarm_precision","bnd","create$56","level_bits","max_num_bits$0","num_keys","add_clamp_to_max","min_key_in_same_slot","min_key_in_same_slot_mask","value$4","next$5","pool","slot$0","min_key_in_same_slot$0","num_levels","min_allowed_key","max_allowed_key","add_elt","pool$1","pool$0","levels","level_index","level","v_elts","v_max_allowed_key$0","v_min_allowed_key$0","v_key","level_index$0","level_index$1","level$0","v_diff_max_min_allowed_key","v_min_key_in_same_slot_mask","v_keys_per_slot","v_bits_per_slot","v_slots_mask","v_bits","v_index","v_min_allowed_key","v_max_allowed_key","v_slots","interval_num_internal","interval_num_unchecked","interval_num_start_unchecked","interval_num","default$1","sexp_of_t$79","v_how_to_dump","v_dump_if_delayed_by","t_of_sexp$73","sexp_of_t$80","equal$46","x_003","x_004","t_of_sexp$74","sexp_of_t$81","t_of_sexp$75","sexp_of_t$82","timing_wheel_config","thread_pool_cpu_affinity","report_thread_pool_stuck_for","record_backtraces","print_debug_messages_for","min_inter_cycle_timeout","max_num_jobs_per_priority_per_","max_num_threads","max_num_open_file_descrs","max_inter_cycle_timeout","file_descr_watcher","epoll_max_ready_events","dump_core_on_job_delay","detect_invalid_access_from_thr","check_invariants","abort_after_thread_pool_stuck_","timing_wheel_config$0","thread_pool_cpu_affinity$0","report_thread_pool_stuck_for$0","record_backtraces$0","print_debug_messages_for$0","min_inter_cycle_timeout$0","max_num_jobs_per_priority_per_$0","max_num_threads$0","max_num_open_file_descrs$0","max_inter_cycle_timeout$0","file_descr_watcher$0","epoll_max_ready_events$0","dump_core_on_job_delay$0","detect_invalid_access_from_thr$0","check_invariants$0","abort_after_thread_pool_stuck_$0","default_timing_wheel_config_fo","level_bits$1","alarm_precision$0","default_timing_wheel_config","default$2","v_timing_wheel_config","v_report_thread_pool_stuck_for","v_record_backtraces","v_min_inter_cycle_timeout","v_max_num_jobs_per_priority_pe","v_max_num_threads","v_max_num_open_file_descrs","v_max_inter_cycle_timeout","v_file_descr_watcher","v_epoll_max_ready_events","v_dump_core_on_job_delay","v_detect_invalid_access_from_t","v_check_invariants","v_abort_after_thread_pool_stuc","usage","to_sexp","name1","bnd$0","bnd$1","v$2","bnd$2","v$3","bnd$3","v$4","bnd$4","v$5","bnd$5","v$6","bnd$6","v$7","bnd$7","v$8","bnd$8","v$9","bnd$9","v$10","bnd$10","v$11","bnd$11","v$12","bnd$12","v$13","bnd$13","v$14","bnd$14","check_invariants_field","dump_core_on_job_delay_field","epoll_max_ready_events_field","file_descr_watcher_field","max_inter_cycle_timeout_field","max_num_open_file_descrs_field","max_num_threads_field","min_inter_cycle_timeout_field","print_debug_messages_for_field","record_backtraces_field","report_thread_pool_stuck_for_f","thread_pool_cpu_affinity_field","timing_wheel_config_field","alarm_precision_field","level_bits_field","capacity_field","num_key_bits","alarm_precision_value","sexp$3","sexp$4","dump_if_delayed_by_field","how_to_dump_field","how_to_dump_value","dump_if_delayed_by_value","timing_wheel_config_value","thread_pool_cpu_affinity_value","report_thread_pool_stuck_for_v","record_backtraces_value","print_debug_messages_for_value","min_inter_cycle_timeout_value","max_num_threads_value","max_num_open_file_descrs_value","max_inter_cycle_timeout_value","file_descr_watcher_value","epoll_max_ready_events_value","dump_core_on_job_delay_value","check_invariants_value","print_debug_messages_for$1","debug$0","symbol$198","check_invariants$1","max_num_jobs_per_priority_per_$1","record_backtraces$1","normal","sexp_of_one","v_is_detached","v_has_seen_error","v_id","v_here","v_name","loop$2","has_seen_error","is_detached","ac$0","sexp_of_t$83","create_with_parent","dummy_e","dummy_f","dummy_a","create_array$0","create$57","none$2","is_none$1","is_some$1","create$59","enqueue$0","execution_context","priority","new_capacity","old_jobs","old_front","new_jobs","create$60","time_source","max_level_min_allowed_key","bits_per_slot","keys_per_slot","diff_max_min_allowed_key","levels$0","tw","prev_level_max_allowed_key","num_levels$0","min_allowed_key_before","desired_min_allowed_key","level_min_allowed_key","level_min_allowed_key$0","slots$1","max_allowed_key$0","alarm","job_pool","from","to","at","current_execution_context","set_prev","set_next","create$61","create2","run1","execution_context1","run2","execution_context2","enqueue$1","scheduler","schedule_jobs","add$19","squash","indir","execution_context$0","bind_result","bind_rhs","bind_result$0","ivar","ivar$0","last1","last2","handler1","execution_context2$0","run2$0","handler1$0","fill_if_empty","to_binable$6","of_binable$8","map$46","bind$18","map$47","bind$19","map$48","both$0","symbol_map$5","choices","unregisters","choices$0","choices$1","handler$0","handler$1","monitor$0","backtrace_history","monitor$1","name$1","backtrace$0","backtrace$1","traces","backtrace$2","list_if_not_empty","return$20","bind$20","map$49","return$21","apply$6","map$50","return$22","equal$47","combine$3","sexp_of_t$85","v_pipe_id","v_values_read","values_sent_downstream","values_sent_downstream_and_flu","when_sent_downstream","fill_with_eof","sexp_of_t$86","v_ready","v_fill_when_num_values_read","fill$2","sexp_of_pipe","of_phantom","v_info","v_buffer","v_size_budget","v_pushback","v_num_values_read","v_read_closed","v_closed","v_blocked_reads","v_blocked_flushes","v_consumers","v_upstream_flusheds","v_consumer","v_wants","is_closed","length$25","is_empty$9","sexp_of_phantom","id_ref","update_pushback","close","close$0","values_were_read","consumer","consumer$0","flush_result","consume_one","consume","ensure_consumer_matches","start_read","gen_read_now","values_available","downstream_flushed","ready","expect","got","create$63","length$26","sub$8","copy$4","init$11","be32_to_cpu","le32_to_cpu","be64_to_cpu","le64_to_cpu","benat_to_cpu","cpu_to_benat","blit_from_bigstring","cpu_to_be32","cpu_to_be64","be32_to_cpu$0","le32_to_cpu$0","be64_to_cpu$0","le64_to_cpu$0","benat_to_cpu$0","cpu_to_benat$0","imin","size_of_long","xor_into","invalid_arg$0","ror64","dup","ctx","param_to_bytes","iv","max_outlen","increment_counter","inc","sigma","compress","a_idx","b_idx","c_idx","d_idx","feed$0","in_off","in_len","fill","unsafe_feed_bytes","unsafe_feed_bigstring","with_outlen_and_key","outlen","param_bytes","with_outlen_and_bytes_key","with_outlen_and_bigstring_key","unsafe_get$0","ror32","dup$0","iv$0","max_outlen$0","increment_counter$0","sigma$0","compress$0","feed$1","unsafe_feed_bytes$0","unsafe_feed_bigstring$0","with_outlen_and_key$0","with_outlen_and_bytes_key$0","with_outlen_and_bigstring_key$0","unsafe_get$1","dup$1","init$12","f3","md5_do_chunk","feed$2","to_fill","unsafe_feed_bytes$1","unsafe_feed_bigstring$1","unsafe_get$2","padlen","rol32","dup$2","init$13","g$0","jj","fff","ggg","hhh","iii","jjj","rmd160_do_chunk","eee","ccc","bbb","aaa","ee","dd","cc","bb","aa","feed$3","unsafe_feed_bytes$2","unsafe_feed_bigstring$2","unsafe_get$3","rol32$0","dup$3","init$14","f1$0","f4$0","f3$0","k4","sha1_do_chunk","feed$4","unsafe_feed_bytes$3","unsafe_feed_bigstring$3","unsafe_get$4","ror32$0","dup$4","init$15","sha256_do_chunk","feed$5","unsafe_feed_bytes$4","unsafe_feed_bigstring$4","unsafe_get$5","init$16","unsafe_get$6","dup$5","unsafe_feed_bytes$5","unsafe_feed_bigstring$5","rol64","dup$6","init$17","mdlen","rsize","keccaft_rndc","keccaft_rotc","keccakf_piln","sha3_keccakf","rotc","bc$0","masks","feed$6","get_uint8","unsafe_feed_bytes$6","unsafe_feed_bigstring$6","unsafe_get$7","ror64$0","dup$7","init$18","sha512_do_chunk","feed$7","unsafe_feed_bytes$7","unsafe_feed_bigstring$7","unsafe_get$8","init$19","unsafe_get$9","dup$8","unsafe_feed_bytes$8","unsafe_feed_bigstring$8","init$20","init$21","init$22","init$23","dup$9","init$24","whirlpool_do_chunk","i$3","wp_op","get_k","m0","feed$8","unsafe_feed_bytes$9","unsafe_feed_bigstring$9","unsafe_get$10","digest_size","block_size","len$3","unsafe_feed_string","unsafe_get","chr$0","chr1","chr2","have_first","ln","bl","feed_bytes","feed_string","feed_bigstring","feedi_bytes","feed","feedi_string","feedi_bigstring","digest_bytes","digest_string","digest_bigstring","digesti_bytes","digesti_string","digesti_bigstring","digestv_bytes","digestv_string","digestv_bigstring","bytes_opad","bytes_ipad","norm_bytes","bigstring_opad","bigstring_ipad","norm_bigstring","hmaci_bytes","outer","hmaci_string","ctx$0","hmaci_bigstring","hmac_bytes","hmac_string","hmac_bigstring","hmacv_bytes","bufs","hmacv_string","hmacv_bigstring","maci_bytes","maci_string","maci_bigstring","mac_bytes","mac_string","mac_bigstring","macv_bytes","macv_string","macv_bigstring","digest_size$0","module_of","b2b","b2s","read$0","ds","of_char_exn","to_int$7","decode","encode","byte$0","to_hex$0","charify","hexified","to_u4","actual","not_implemented","to_binable$7","of_binable$9","empty$16","group$88","bin_shape_t$91","path$0","log$1","internal","empty_quartiles","allocation_times","now$0","get_lifetime_ms","mean","indices","lifetimes","q1","q2","q3_offset","q3","q4","compute_statistics","run_test","time_offsets","expected_quartiles","message$0","comparator$0","comparator$1","message$3","comparator$3","table$0","attach_finalizer","object_id","info_opt","data_opt","statistics","block_on_async_exn","to_deferred","promise","map$51","bind$21","return$23","return$24","map$52","get$13","t_of_sexp$76","accs_field","bits_field","ss_field","base_field","n_prev_field","n_next_field","n_next_value","n_prev_value","base_value","ss_value","bits_value","accs_value","map$53","n_next","n_prev","ss","accs","group$89","bin_shape_t$92","bin_size_t$45","bin_write_t$46","bin_read_t$80","v_inner","to_yojson$15","of_yojson$10","t_of_sexp$77","inner_field","inner_value","sexp_of_t$87","compare$86","equal$48","hash_fold_t$52","typ$8","map$54","y_squared","t_004","t_003","t_005","t_010","t_012","t_011","e0","hsv$1","hash_fold_t$1","to_backend","of_backend","to_affine_or_infinity","to_affine_exn","of_affine","find_y","point_near_x","g_vec","or_infinity_to_backend","or_infinity_of_backend","with_degree_bound_to_backend","commitment","without_degree_bound_to_backen","of_backend_with_degree_bound","shifted$0","of_backend_without_degree_boun","tuple15_to_vec","w14","w13","w12","w11","w10","w9","w8","w7","w6","w5","w4","w3","w2","w1","w0","tuple15_of_vec","group$90","poly_fq","xs$2","xs$3","v_challenges","v_commitment","challenges_field","commitment_field","commitment_value","challenges_value","a_013","b_014","to_latest","hash_fold_array$0","poly_fqv","poly_g$0","fields$11","fields$1","fields$2","fields$3","fields$4","fields$5","fields$6","fields$7","fields$8","fields$9","fields$10","x$10","x$11","fields$12","x$12","fields$13","x$13","fields$14","fields$15","fields$16","fields$17","fields$18","fields$19","fields$20","fields$21","fields$22","fields$23","fields$24","xs$16","xs$17","arg1$2","arg0$2","xs$18","arg24","arg23","arg22","arg21","arg20","arg19","arg18","arg17","arg16","arg15","arg14","arg13","arg12","arg11","arg10","arg9","arg8","arg7","arg6","arg5","arg4","arg3","xs$13","xs$6","xs$5","xs$4","xs$12","xs$11","xs$10","xs$9","xs$8","xs$7","xs$19","x$17","x$16","x$15","x$14","xs$15","xs$14","xs$25","x$23","state$25","xs$24","x$22","xs$23","x$21","xs$22","x$20","xs$21","x$19","xs$20","x$18","arg2$1","arg1$1","arg0$1","arg2$0","arg1$0","arg0$0","size_of_fqv","v2$1","v3$0","write_fqv","v_w_comm","v_z_comm","v_t_comm","v_lookup","v_aggreg","v_runtime","v_messages","v_proof","v_openings","version$0","cmp_g$1","cmp_g$0","a_467","b_468","n$32","n$29","a_403","b_404","a_405","b_406","n$30","a_407","b_408","n$31","a_409","b_410","a_411","b_412","a_413","b_414","a_415","b_416","a_379","b_380","a_381","b_382","cmp_fqv","cmp_fq$0","cmp_fq","a_297","b_298","a_469","b_470","n$27","n$23","a_263","b_264","t_266","t_265","t_268","t_267","n$24","n$25","n$26","a_299","b_300","t_302","t_301","t_304","t_303","n$28","a_033","b_034","a_035","b_036","a_045","b_046","a_047","b_048","a_057","b_058","n$19","a_059","b_060","n$20","a_061","b_062","n$21","a_063","b_064","n$22","a_065","b_066","a_067","b_068","t_of_sexp$2","arg$31","bnds$29","bnds$37","bnds$30","arg$28","arg$29","arg$30","bnds$31","arg$32","bnds$38","bnds$32","arg$33","bnds$33","arg$34","bnds$34","arg$35","bnds$35","arg$36","bnds$36","arg$37","bnds$39","hsv$33","hash_fold_fqv","hsv$29","hsv$30","hsv$31","hsv$32","hash_fold_g","hsv$24","hsv$25","hsv$26","hsv$27","hsv$28","hash_fold_a","hsv$2","hsv$3","hsv$4","hsv$5","hsv$6","hsv$7","hsv$8","hsv$9","hsv$10","hsv$11","hsv$12","hsv$13","hsv$14","hsv$15","hsv$16","hsv$17","hsv$18","hsv$19","hsv$20","hsv$21","hsv$22","hsv$23","a_477","b_478","a_419","b_420","a_421","b_422","a_423","b_424","a_425","b_426","a_427","b_428","a_429","b_430","a_431","b_432","a_385","b_386","a_387","b_388","a_309","b_310","a_479","b_480","a_271","b_272","t_274","t_273","t_276","t_275","a_311","b_312","t_314","t_313","t_316","t_315","a_071","b_072","a_073","b_074","a_075","b_076","a_077","b_078","a_079","b_080","a_081","b_082","a_083","b_084","a_085","b_086","a_087","b_088","a_089","b_090","a_091","b_092","a_093","b_094","a_095","b_096","a_097","b_098","a_099","b_100","a_101","b_102","a_103","b_104","a_105","b_106","a_107","b_108","map_creator","openings","json","to_latest$0","fq_array_to_vec","vec","opening_proof_of_backend_exn","gpair","g2","g1","eval_of_backend","evals_to_tuple","zeta_omega","zeta","gs","eval_to_backend","vec_to_array","V","chal_polys","pcwo","lr$0","evals_of_tuple","challenges","to_backend$0","create$1","pk","create_async","create_and_verify_async","batch_verify","logger","vks_and_v","batch_verify$0","prev_challenge","pi$0","scalar_challenge","beta","digest_before_evaluations","p_eval_1","p_eval_2","opening_prechallenges","columns","permutation_cols","map$55","s3","yr","xr","n_acc","yp","xp","yt","xt","map$56","x7","x6","x5","a8","b0","n8","n0","bin_shape_t_tagged","read_version","all_tag_versions","bin_read_all_tagged_to_latest","saved_pos","pos_ref$0","domain_generator","over","t_of_sexp$78","compare$87","compare$88","cmp_row","to_rust_wire","t_of_sexp$79","of_v","field_sexps$12","l_field","r_field","o_field","c_field","duplicates$12","extra$12","tail$7","field_sexp$52","field_sexp$41","field_sexp$42","fvalue$36","field_sexp$43","fvalue$37","field_sexp$44","fvalue$38","field_sexp$45","fvalue$39","field_sexp$46","fvalue$40","c_value","o_value","r_value","l_value","field_sexps$4","state_field","duplicates$4","extra$4","state_value","field_sexps$11","p1_field","p2_field","p3_field","inf_field","same_x_field","slope_field","inf_z_field","x21_inv_field","duplicates$11","extra$11","tail$6","field_sexp$51","field_sexp$32","field_sexp$33","fvalue$28","field_sexp$34","fvalue$29","field_sexp$35","fvalue$30","field_sexp$36","fvalue$31","field_sexp$37","fvalue$32","field_sexp$38","fvalue$33","field_sexp$39","fvalue$34","field_sexp$40","fvalue$35","x21_inv_value","inf_z_value","slope_value","same_x_value","inf_value","p3_value","p2_value","p1_value","field_sexps$8","state_field$0","duplicates$8","extra$8","tail$3","state_value$0","field_sexps$9","state_field$1","xs_field","ys_field","n_acc_field","duplicates$9","extra$9","tail$4","field_sexp$50","field_sexp$26","field_sexp$27","field_sexp$28","fvalue$24","field_sexp$29","fvalue$25","xt_field","yt_field","xp_field","yp_field","xr_field","yr_field","s1_field","s3_field","b1_field","b2_field","b3_field","b4_field","b4_value","b3_value","b2_value","b1_value","s3_value","s1_value","yr_value","xr_value","n_acc_value","yp_value","xp_value","yt_value","xt_value","field_sexp$30","fvalue$26","ys_value","xs_value","state_value$1","field_sexps$10","state_field$2","duplicates$10","extra$10","tail$5","field_sexp$31","fvalue$27","n0_field","n8_field","a0_field","b0_field","a8_field","b8_field","x0_field","x1_field","x2_field","x3_field","x4_field","x5_field","x6_field","x7_field","x7_value","x6_value","x5_value","x4_value","x3_value","x2_value","x1_value","x0_value","b8_value","a8_value","b0_value","a0_value","n8_value","n0_value","state_value$2","field_sexps$5","w0_field","w1_field","w2_field","w3_field","w4_field","w5_field","w6_field","duplicates$5","extra$5","field_sexp$49","w6_value","w5_value","w4_value","w3_value","w2_value","w1_value","w0_value","field_sexps$3","v0_field","v0p0_field$0","v0p1_field$0","v0p2_field","v0p3_field","v0p4_field","v0p5_field","v0c0_field","v0c1_field","v0c2_field","v0c3_field","v0c4_field","v0c5_field","v0c6_field","v0c7_field","compact_field","duplicates$3","extra$3","iter$2","compact_value","v0c7_value","v0c6_value","v0c5_value","v0c4_value","v0c3_value","v0c2_value","v0c1_value","v0c0_value","v0p5_value","v0p4_value","v0p3_value","v0p2_value","v0p1_value$0","v0p0_value$0","v0_value","v2_field","v12_field","v2c0_field","v2p0_field","v2p1_field","v2p2_field","v2p3_field","v2c1_field","v2c2_field","v2c3_field","v2c4_field","v2c5_field","v2c6_field","v2c7_field","v2c8_field","v2c9_field","v2c10_field","v2c11_field","v0p0_field","v0p1_field","v1p0_field","v1p1_field","v2c12_field","v2c13_field","v2c14_field","v2c15_field","v2c16_field","v2c17_field","v2c18_field","v2c19_field","v2c19_value","v2c18_value","v2c17_value","v2c16_value","v2c15_value","v2c14_value","v2c13_value","v2c12_value","v1p1_value","v1p0_value","v0p1_value","v0p0_value","v2c11_value","v2c10_value","v2c9_value","v2c8_value","v2c7_value","v2c6_value","v2c5_value","v2c4_value","v2c3_value","v2c2_value","v2c1_value","v2p3_value","v2p2_value","v2p1_value","v2p0_value","v2c0_value","v12_value","v2_value","in1_field","in2_field","out_field","in1_0_field","in1_1_field","in1_2_field","in1_3_field","in2_0_field","in2_1_field","in2_2_field","in2_3_field","out_0_field","out_1_field","out_2_field","out_3_field","out_3_value","out_2_value","out_1_value","out_0_value","in2_3_value","in2_2_value","in2_1_value","in2_0_value","in1_3_value","in1_2_value","in1_1_value","in1_0_value","out_value","in2_value","in1_value","field_sexps$7","left_input_lo_field","left_input_mi_field","left_input_hi_field","right_input_lo_field","right_input_mi_field","right_input_hi_field","field_overflow_field","carry_field","foreign_field_modulus0_field","foreign_field_modulus1_field","foreign_field_modulus2_field$0","duplicates$7","extra$7","field_sexp$48","foreign_field_modulus2_value$0","foreign_field_modulus1_value","foreign_field_modulus0_value","carry_value","field_overflow_value","right_input_hi_value","right_input_mi_value","right_input_lo_value","left_input_hi_value","left_input_mi_value","left_input_lo_value","field_sexps$6","left_input0_field","left_input1_field","left_input2_field","right_input0_field","right_input1_field","right_input2_field","remainder01_field","remainder2_field","quotient0_field","quotient1_field","quotient2_field","quotient_hi_bound_field","product1_lo_field","product1_hi_0_field","product1_hi_1_field","carry0_field","carry1_0_field","carry1_12_field","carry1_24_field","carry1_36_field","carry1_48_field","carry1_60_field","carry1_72_field","carry1_84_field","carry1_86_field","carry1_88_field","carry1_90_field","foreign_field_modulus2_field","neg_foreign_field_modulus0_fie","neg_foreign_field_modulus1_fie","neg_foreign_field_modulus2_fie","duplicates$6","extra$6","iter$3","neg_foreign_field_modulus2_val","neg_foreign_field_modulus1_val","neg_foreign_field_modulus0_val","foreign_field_modulus2_value","carry1_90_value","carry1_88_value","carry1_86_value","carry1_84_value","carry1_72_value","carry1_60_value","carry1_48_value","carry1_36_value","carry1_24_value","carry1_12_value","carry1_0_value","carry0_value","product1_hi_1_value","product1_hi_0_value","product1_lo_value","quotient_hi_bound_value","quotient2_value","quotient1_value","quotient0_value","remainder2_value","remainder01_value","right_input2_value","right_input1_value","right_input0_value","left_input2_value","left_input1_value","left_input0_value","word_field","rotated_field","excess_field","bound_limb0_field","bound_limb1_field","bound_limb2_field","bound_limb3_field","bound_crumb0_field","bound_crumb1_field","bound_crumb2_field","bound_crumb3_field","bound_crumb4_field","bound_crumb5_field","bound_crumb6_field","bound_crumb7_field","two_to_rot_field","two_to_rot_value","bound_crumb7_value","bound_crumb6_value","bound_crumb5_value","bound_crumb4_value","bound_crumb3_value","bound_crumb2_value","bound_crumb1_value","bound_crumb0_value","bound_limb3_value","bound_limb2_value","bound_limb1_value","bound_limb0_value","excess_value","rotated_value","word_value","kind_field","values_field","coeffs_field","field_sexp$47","coeffs_value","values_value","kind_value","sexp_of_t$88","v_c","v_m","v_o","v_r","v_l","v_state","v_x21_inv","v_inf_z","v_slope","v_same_x","v_inf","v_p3","v_p2","v_p1","v_state$0","v_n_next","v_n_prev","v_base","v_ss","v_accs","v_n_acc","v_ys","v_xs","v_state$1","v_b4","v_b3","v_b2","v_b1","v_s3","v_s1","v_yr","v_xr","v_yp","v_xp","v_yt","v_xt","v_state$2","v_x7","v_x6","v_x5","v_x4","v_x3","v_x2","v_x1","v_x0","v_b8","v_a8","v_b0","v_a0","v_n8","v_n0","v_w6","v_w5","v_w4","v_w3","v_w2","v_w1","v_w0","v_compact","v_v0c7","v_v0c6","v_v0c5","v_v0c4","v_v0c3","v_v0c2","v_v0c1","v_v0c0","v_v0p5","v_v0p4","v_v0p3","v_v0p2","v_v0p1","v_v0p0","v_v0","bnds$40","arg$38","bnds$41","arg$39","bnds$42","arg$40","bnds$43","arg$41","bnds$44","v_v2c19","v_v2c18","v_v2c17","v_v2c16","v_v2c15","v_v2c14","v_v2c13","v_v2c12","v_v1p1","v_v1p0","v_v0p1$0","v_v0p0$0","v_v2c11","v_v2c10","v_v2c9","v_v2c8","v_v2c7","v_v2c6","v_v2c5","v_v2c4","v_v2c3","v_v2c2","v_v2c1","v_v2p3","v_v2p2","v_v2p1","v_v2p0","v_v2c0","v_v12","v_v2","arg$42","bnds$45","arg$43","bnds$46","arg$44","bnds$47","arg$45","bnds$48","arg$46","bnds$49","arg$47","bnds$50","arg$48","bnds$51","arg$49","bnds$52","arg$50","bnds$53","arg$51","bnds$54","arg$52","bnds$55","arg$53","bnds$56","arg$54","bnds$57","arg$55","bnds$58","arg$56","bnds$59","arg$57","bnds$60","arg$58","bnds$61","arg$59","bnds$62","arg$60","bnds$63","arg$61","bnds$64","arg$62","bnds$65","arg$63","bnds$66","arg$64","bnds$67","arg$65","bnds$68","arg$66","bnds$69","arg$67","bnds$70","arg$68","bnds$71","arg$69","bnds$72","arg$70","bnds$73","arg$71","bnds$74","v_out_3","v_out_2","v_out_1","v_out_0","v_in2_3","v_in2_2","v_in2_1","v_in2_0","v_in1_3","v_in1_2","v_in1_1","v_in1_0","v_out","v_in2","v_in1","arg$72","bnds$75","arg$73","bnds$76","arg$74","bnds$77","arg$75","bnds$78","arg$76","bnds$79","arg$77","bnds$80","arg$78","bnds$81","arg$79","bnds$82","arg$80","bnds$83","arg$81","bnds$84","arg$82","bnds$85","arg$83","bnds$86","arg$84","bnds$87","arg$85","bnds$88","arg$86","bnds$89","v_foreign_field_modulus2","v_foreign_field_modulus1","v_foreign_field_modulus0","v_carry","v_field_overflow","v_right_input_hi","v_right_input_mi","v_right_input_lo","v_left_input_hi","v_left_input_mi","v_left_input_lo","arg$87","bnds$90","arg$88","bnds$91","arg$89","bnds$92","arg$90","bnds$93","arg$91","bnds$94","arg$92","bnds$95","arg$93","bnds$96","arg$94","bnds$97","arg$95","bnds$98","arg$96","bnds$99","arg$97","bnds$100","arg$98","bnds$101","v_neg_foreign_field_modulus2","v_neg_foreign_field_modulus1","v_neg_foreign_field_modulus0","v_foreign_field_modulus2$0","v_carry1_90","v_carry1_88","v_carry1_86","v_carry1_84","v_carry1_72","v_carry1_60","v_carry1_48","v_carry1_36","v_carry1_24","v_carry1_12","v_carry1_0","v_carry0","v_product1_hi_1","v_product1_hi_0","v_product1_lo","v_quotient_hi_bound","v_quotient2","v_quotient1","v_quotient0","v_remainder2","v_remainder01","v_right_input2","v_right_input1","v_right_input0","v_left_input2","v_left_input1","v_left_input0","arg$99","bnds$102","arg$100","bnds$103","arg$101","bnds$104","arg$102","bnds$105","arg$103","bnds$106","arg$104","bnds$107","arg$105","bnds$108","arg$106","bnds$109","arg$107","bnds$110","arg$108","bnds$111","arg$109","bnds$112","arg$110","bnds$113","arg$111","bnds$114","arg$112","bnds$115","arg$113","bnds$116","arg$114","bnds$117","arg$115","bnds$118","arg$116","bnds$119","arg$117","bnds$120","arg$118","bnds$121","arg$119","bnds$122","arg$120","bnds$123","arg$121","bnds$124","arg$122","bnds$125","arg$123","bnds$126","arg$124","bnds$127","arg$125","bnds$128","arg$126","bnds$129","arg$127","bnds$130","arg$128","bnds$131","arg$129","bnds$132","v_two_to_rot","v_bound_crumb7","v_bound_crumb6","v_bound_crumb5","v_bound_crumb4","v_bound_crumb3","v_bound_crumb2","v_bound_crumb1","v_bound_crumb0","v_bound_limb3","v_bound_limb2","v_bound_limb1","v_bound_limb0","v_excess","v_rotated","v_word","arg$130","bnds$133","arg$131","bnds$134","arg$132","bnds$135","arg$133","bnds$136","arg$134","bnds$137","arg$135","bnds$138","arg$136","bnds$139","arg$137","bnds$140","arg$138","bnds$141","arg$139","bnds$142","arg$140","bnds$143","arg$141","bnds$144","arg$142","bnds$145","arg$143","bnds$146","arg$144","bnds$147","arg$145","bnds$148","v_coeffs","v_values","v_kind","arg$146","bnds$149","arg$147","bnds$150","arg$148","bnds$151","map$57","fp","x21_inv","inf_z","slope","same_x","inf","p3","compact","v0c7","v0c6","v0c5","v0c4","v0c3","v0c2","v0c1","v0c0","v0p5","v0p4","v0p3","v0p2","v0p1","v0p0","v2c19","v2c18","v2c17","v2c16","v2c15","v2c14","v2c13","v2c12","v1p1","v1p0","v0p1$0","v0p0$0","v2c11","v2c10","v2c9","v2c8","v2c7","v2c6","v2c5","v2c4","v2c3","v2c2","v2c1","v2p3","v2p2","v2p1","v2p0","v2c0","out_3","out_2","out_1","out_0","in2_3","in2_2","in2_1","in2_0","in1_3","in1_2","in1_1","in1_0","in2","in1","foreign_field_modulus2","foreign_field_modulus1","foreign_field_modulus0","field_overflow","right_input_hi","right_input_mi","right_input_lo","left_input_hi","left_input_mi","left_input_lo","neg_foreign_field_modulus2","neg_foreign_field_modulus1","neg_foreign_field_modulus0","foreign_field_modulus2$0","carry1_90","carry1_88","carry1_86","carry1_84","carry1_72","carry1_60","carry1_48","carry1_36","carry1_24","carry1_12","carry1_0","carry0","product1_hi_1","product1_hi_0","product1_lo","quotient_hi_bound","quotient2","quotient1","quotient0","remainder2","remainder01","right_input2","right_input1","right_input0","left_input2","left_input1","left_input0","two_to_rot","bound_crumb7","bound_crumb6","bound_crumb5","bound_crumb4","bound_crumb3","bound_crumb2","bound_crumb1","bound_crumb0","bound_limb3","bound_limb2","bound_limb1","bound_limb0","excess","rotated","word","coeffs","eval_one","vo","co","vr","cr","vl","vl$0","vr$0","vo$0","custom_printf_009","custom_printf_010","custom_printf_011","custom_printf_012","custom_printf_013","custom_printf_014","custom_printf_015","custom_printf_016","custom_printf_017","custom_printf_018","compare$89","hash_fold_t$53","a0$0","hash$41","t_of_sexp$80","sexp_of_t$89","compute_witness","external_values","internal_values","num_rows","custom_printf_033","i_after_input","cols","row_idx","col_idx","union_find","create_internal","get_auxiliary_input_size","get_primary_input_size","get_prev_challenges","num_pub_inputs","set_prev_challenges","num_prev_challenges","next_row","add_row","vars_for_perm","finalize_and_get_gates","gates_rev","rust_gates","pub_selectors","pub_input_gate_specs_rev","public_var","row_field","col_field","col_value","row_value","v_row","equivalence_classes","pos_map","update_gate_with_permutation_i","public_gates","public_gates$0","absolute_row","gates$0","relative_row","add_gates","wired_to","wired_to$0","md5_digest","gates$1","num_constraints","to_json","add_generic_constraint","coeffs2","o2","coeffs$0","constr","red","terms$0","terms_list","lx","go$0","lx$0","rs","s1x1_plus_s2x2","reduce_to_v","xo","xo$0","x3$0","x3$1","x3$2","ratio","ratio$0","x2$1","red_pr","l_s","r_s","o$0","coeff","add_round_state","s5","s4","reduce_curve_point","x1$1","x2$2","x3$3","curr_row","add_endoscale_round","vars$1","add_endoscale_scalar_round","vars$2","vars$3","coeff$0","v2$2","vars_curr","vars_next","vars$4","vars_curr$0","vars_next$0","vars_curr$1","values$0","urs_info","degree","set_urs_info","load","urs$0","store","urs$1","prev_challenges$0","prev_challenges$1","runtime_table_cfg","array_to_vector","vk_commitments","to_list$14","of_list$8","group3","pt$0","tuples","string_bits","test_bit","to_bytes$0","bit","of_bytes$0","hash$42","hash_fold_t$54","to_yojson$16","of_yojson$11","length_in_bits","order","length_in_bytes","remaining_bytes","extended_euclidean","inv_no_mod","euler","while$0","t_minus_1_over_2","b2m","of_bigint","to_bigint","make_gen","t_of_bignum_bigint","make_gen_full","bignum_bigint_of_t","fold_bits","group$91","bin_shape_t$93","group$92","bin_shape_t$94","bin_size_t$46","bin_write_t$47","bin_read_t$81","to_yojson$17","of_yojson$12","compare$90","equal$49","of_bytes$1","to_bytes$1","of_decimal_string","to_string$42","test_bit$0","div$1","compare$91","num_limbs","bytes_per_limb","to_hex","to_hex_string","of_hex_string","of_numeral","double$1","one$8","symbol$203","double$2","scale$1","one$9","to_affine_exn$0","of_affine$0","symbol$204","make$6","unshifted$0","make$7","params$0","params$1","to_field$1","of_field$1","vks","create_aux$0","prev_chals","prev_comms","computed_witness","create$64","to_binable$8","of_binable$10","create$65","of_data$0","to_field$2","of_field$2","create_aux$1","create_async$0","create_and_verify_async$0","create$66","to_binable$9","of_binable$11","create$67","digest_size_in_bits","digest_size_in_bytes","char_generator","of_hex$0","digest_bigstring$0","digest_string$0","to_raw_string$0","of_raw_string$0","hash_fold_t$2","hash$2","bits_to_string","finished","string_to_bits","pct","pot","mct","mot","loc$3","last$0","last$1","map$62","raise_errorf","fixity_of_string","first_is","last_is","needs_parens","needs_spaces","protect_ident","view_expr","exp$0","is_simple_construct","under_semi","ctxt","list$4","fu","option$0","paren","print_longident$0","longident_loc","delim","mutable_flag","virtual_flag","rec_flag","nonrec_flag","direction_flag","private_flag","constant_string","tyvar","tyvar_loc","f$11","module_type$5","mt2","mt1","module_type$2","module_type1","mt2$0","with_constraint","td","ls$0","type_declaration$2","core_type","li2","li$0","td$0","ls$1","li$1","ls$2","li2$0","li$2","module_type1$0","attributes","signature_item$1","me","module_expr$0","extension","e$6","sugar_expr","label_x_expression_param","simple_expr","s$4","expression2","eo$0","eo$1","l$6","e$7","s$5","l$7","string_x_expression","e$8","e$9","ct","e$10","case_list","label_exp","cd","extension_constructor$4","e$5","ands","let$0","binding_op$1","eo","expression_under_ifthenelse","class_structure$2","expression2$0","simple_expr$0","longident_x_expression","e3","df","expression","pattern$0","ct$0","cto1","lid","pattern$6","pattern1$0","pattern_list_helper","pat2","pat1","simple_pattern","pattern1","simple_pattern$0","po","closed","longident_x_pattern","with_paren","simple_name","pc_rhs","pc_guard","pc_lhs","constructor_declaration","attrs","core_type1","record_declaration","priv","manifest","constructor_declaration$0","pcd","intro","variants","constraints","ct2","ct1","lbls","type_record_field","pld","type_param","structure_item$0","item_attributes","vd","value_description$2","type_def_list","te","type_extension$0","exception_declaration","me$1","me$0","arg_opt","mt","decls","pmb","expr","attrs$0","md","class_constraint","class_type$3","class_declaration","cl$2","cl$1","class_expr$2","class_params_def","class_type_declaration_list","floating_attribute","item_extension","binding$0","binding","pp_print_pexp_function","tyvars_str","tyvars","args_tyvars","gadt_pattern","gadt_exp","tyvars$0","e_ct","e_tyvars","pt_ct","pt_tyvars","check_variable","var_names","core_type$0","lst$1","loop_object_field","lst$2","longident","core_type$1","lbl_lst_option","row_field_list","loop_row_field","core_type$2","string_lst","lst$3","longident$0","prf_desc","pof_desc","ety","tyvars$1","ct$1","payload","me2","me1","mt$0","alias","pms","pmd","s$6","s$7","class_description","exported","type_decl","ce","ce$0","ce$1","so","ovf","ovf$0","ovf$1","class_type_declaration","vf","mf","vf$0","pf","type_with_label","print_indexop","path_prefix","print_index","rem_args","print_path","other_args","i3","i2$0","i1$0","i1$1","left$0","txt$0","core_field_type","field_var","first_is_inherit","type_variant_helper","ctl","cstrs","pp$26","pp$27","migration_error","missing_feature","copy_loc","f0","copy_structure","copy_structure_item","copy_toplevel_phrase","pdir_loc","pdir_arg","pdir_name","copy_directive_argument","pdira_loc","pdira_desc","x0$2","copy_attributes","copy_attribute","copy_constant","copy_rec_flag","copy_arg_label","copy_constructor_arguments","copy_core_type","copy_label_declaration","copy_extension_constructor","pext_attributes","pext_loc","pext_kind","pext_name","copy_Longident_t","copy_extension","copy_payload","copy_signature","copy_signature_item","copy_functor_parameter","copy_module_type","copy_override_flag","copy_open_infos","popen_attributes","popen_loc","popen_override","popen_expr","copy_open_declaration","copy_module_expr","copy_closed_flag","ptyp_attributes","ptyp_loc_stack","ptyp_loc","ptyp_desc","x0$3","copy_object_field","x1$2","x0$4","x1$3","x0$5","x1$4","x0$6","copy_label","copy_row_field","x1$5","x0$7","x0$8","x1$6","x0$10","x0$9","copy_pattern","ppat_attributes","ppat_loc_stack","ppat_loc","ppat_desc","x0$11","x0$12","x0$13","x0$14","x0$15","copy_class_structure","pcstr_fields","pcstr_self","copy_class_field","pmty_attributes","pmty_loc","pmty_desc","copy_with_constraint","pmod_attributes","pmod_loc","pmod_desc","copy_expression","copy_binding_op","pbop_loc","pbop_exp","pbop_pat","pbop_op","copy_expression_desc","copy_value_binding","copy_case","x1$7","x1$8","x1$9","x1$10","x1$11","x0$16","x2$3","x1$12","x0$17","x1$13","x0$18","x2$4","x1$14","x0$19","x1$15","x0$20","x0$21","x1$16","x0$22","x0$23","x2$5","x1$17","x0$24","x1$18","x0$25","x0$26","x0$27","x1$19","x0$28","x0$29","x1$20","x0$30","x0$31","x1$21","x0$32","x0$33","x0$34","pexp_attributes","pexp_loc_stack","pexp_loc","pexp_desc","pvb_loc","pvb_attributes","pvb_expr","pvb_pat","prf_attributes","prf_loc","pof_attributes","pof_loc","attr_loc","attr_payload","attr_name","copy_value_description","pval_loc","pval_attributes","pval_prim","pval_type","pval_name","copy_variance","copy_injectivity","copy_private_flag","copy_type_extension","ptyext_attributes","ptyext_loc","ptyext_private","ptyext_constructors","ptyext_params","ptyext_path","copy_type_exception","ptyexn_attributes","ptyexn_loc","ptyexn_constructor","copy_module_type_declaration","pmtd_loc","pmtd_attributes","pmtd_type","pmtd_name","copy_include_infos","pincl_attributes","pincl_loc","pincl_mod","copy_module_binding","pmb_loc","pmb_attributes","pmb_expr","pmb_name","pstr_loc","pstr_desc","copy_type_declaration","copy_class_declaration","copy_class_type_declaration","copy_virtual_flag","copy_class_infos","pci_attributes","pci_loc","pci_expr","pci_name","pci_params","pci_virt","copy_class_expr","copy_open_description","copy_class_type","pcty_attributes","pcty_loc","pcty_desc","pcsig_fields","pcsig_self","copy_class_type_field","pcl_attributes","pcl_loc","pcl_desc","copy_mutable_flag","copy_class_field_kind","pcf_attributes","pcf_loc","pcf_desc","ptype_loc","ptype_attributes","ptype_manifest","ptype_private","ptype_kind","ptype_cstrs","ptype_params","ptype_name","copy_constructor_declaration","copy_module_declaration","pmd_loc","pmd_attributes","pmd_type","pmd_name","psig_loc","psig_desc","pms_loc","pms_attributes","pms_manifest","pms_name","copy_class_description","pctf_attributes","pctf_loc","pctf_desc","pcd_attributes","pcd_loc","pcd_res","pcd_args","pcd_vars","pcd_name","pld_attributes","pld_loc","pld_type","pld_mutable","pld_name","copy_loc$0","copy_structure$0","copy_structure_item$0","copy_toplevel_phrase$0","copy_directive_argument$0","copy_attributes$0","copy_attribute$0","copy_constant$0","copy_rec_flag$0","copy_arg_label$0","copy_constructor_arguments$0","copy_core_type$0","copy_label_declaration$0","copy_extension_constructor$0","copy_Longident_t$0","copy_extension$0","copy_payload$0","copy_signature$0","copy_signature_item$0","copy_functor_parameter$0","copy_module_type$0","copy_override_flag$0","copy_open_infos$0","copy_open_declaration$0","copy_module_expr$0","copy_closed_flag$0","copy_object_field$0","copy_label$0","copy_row_field$0","copy_pattern$0","copy_class_structure$0","copy_class_field$0","copy_with_constraint$0","copy_expression$0","copy_binding_op$0","copy_expression_desc$0","copy_value_binding$0","copy_case$0","copy_value_description$0","copy_variance$0","copy_injectivity$0","copy_private_flag$0","copy_type_extension$0","copy_type_exception$0","copy_module_type_declaration$0","copy_include_infos$0","copy_module_binding$0","copy_type_declaration$0","copy_class_declaration$0","copy_class_type_declaration$0","copy_virtual_flag$0","copy_class_infos$0","copy_class_expr$0","copy_open_description$0","copy_class_type$0","copy_class_type_field$0","copy_mutable_flag$0","copy_class_field_kind$0","copy_constructor_declaration$0","copy_module_declaration$0","copy_class_description$0","migration_error$0","copy_loc$1","copy_structure$1","copy_structure_item$1","copy_toplevel_phrase$1","copy_directive_argument$1","copy_attributes$1","copy_attribute$1","copy_location_stack","copy_location","copy_constant$1","copy_rec_flag$1","copy_arg_label$1","copy_constructor_arguments$1","copy_core_type$1","copy_label_declaration$1","copy_extension_constructor$1","copy_Longident_t$1","copy_extension$1","copy_payload$1","copy_signature$1","copy_signature_item$1","copy_functor_parameter$1","copy_module_type$1","copy_override_flag$1","copy_open_infos$1","copy_open_declaration$1","copy_module_expr$1","copy_closed_flag$1","copy_object_field$1","copy_label$1","copy_row_field$1","copy_pattern$1","copy_class_structure$1","copy_class_field$1","copy_with_constraint$1","copy_expression$1","copy_binding_op$1","copy_expression_desc$1","copy_value_binding$1","copy_case$1","copy_value_description$1","copy_variance$1","copy_injectivity$1","copy_private_flag$1","copy_type_extension$1","copy_type_exception$1","copy_module_type_declaration$1","copy_include_infos$1","copy_module_binding$1","copy_type_declaration$1","copy_class_declaration$1","copy_class_type_declaration$1","copy_virtual_flag$1","copy_class_infos$1","copy_class_expr$1","copy_open_description$1","copy_class_type$1","copy_class_type_field$1","copy_mutable_flag$1","copy_class_field_kind$1","copy_constructor_declaration$1","copy_module_declaration$1","copy_class_description$1","copy_loc$2","copy_structure$2","copy_structure_item$2","copy_toplevel_phrase$2","copy_directive_argument$2","copy_attributes$2","copy_attribute$2","copy_location_stack$0","copy_location$0","copy_constant$2","copy_rec_flag$2","copy_arg_label$2","copy_constructor_arguments$2","copy_core_type$2","copy_label_declaration$2","copy_extension_constructor$2","copy_Longident_t$2","copy_extension$2","copy_payload$2","copy_signature$2","copy_signature_item$2","copy_functor_parameter$2","copy_module_type$2","copy_override_flag$2","copy_open_infos$2","copy_open_declaration$2","copy_module_expr$2","copy_closed_flag$2","copy_object_field$2","copy_label$2","copy_row_field$2","copy_pattern$2","copy_class_structure$2","copy_class_field$2","copy_with_constraint$2","copy_expression$2","copy_binding_op$2","copy_expression_desc$2","copy_value_binding$2","copy_case$2","copy_value_description$2","copy_variance$2","copy_injectivity$2","copy_private_flag$2","copy_type_extension$2","copy_type_exception$2","copy_module_type_declaration$2","copy_include_infos$2","copy_module_binding$2","copy_type_declaration$2","copy_class_declaration$2","copy_class_type_declaration$2","copy_virtual_flag$2","copy_class_infos$2","copy_class_expr$2","copy_open_description$2","copy_class_type$2","copy_class_type_field$2","copy_mutable_flag$2","copy_class_field_kind$2","copy_constructor_declaration$2","copy_module_declaration$2","copy_class_description$2","copy_loc$3","copy_structure$3","copy_structure_item$3","copy_toplevel_phrase$3","copy_directive_argument$3","copy_attributes$3","copy_attribute$3","copy_constant$3","copy_rec_flag$3","copy_arg_label$3","copy_constructor_arguments$3","copy_core_type$3","copy_label_declaration$3","copy_extension_constructor$3","copy_Longident_t$3","copy_extension$3","copy_payload$3","copy_signature$3","copy_signature_item$3","copy_functor_parameter$3","copy_module_type$3","copy_override_flag$3","copy_open_infos$3","copy_open_declaration$3","copy_module_expr$3","copy_closed_flag$3","copy_object_field$3","copy_label$3","copy_row_field$3","copy_pattern$3","copy_class_structure$3","copy_class_field$3","copy_with_constraint$3","copy_expression$3","copy_binding_op$3","copy_expression_desc$3","copy_value_binding$3","copy_case$3","copy_value_description$3","copy_variance$3","copy_private_flag$3","copy_type_extension$3","copy_type_exception$3","copy_module_type_declaration$3","copy_include_infos$3","copy_module_binding$3","copy_type_declaration$3","copy_class_declaration$3","copy_class_type_declaration$3","copy_virtual_flag$3","copy_class_infos$3","copy_class_expr$3","copy_open_description$3","copy_class_type$3","copy_class_type_field$3","copy_mutable_flag$3","copy_class_field_kind$3","copy_constructor_declaration$3","copy_module_declaration$3","copy_class_description$3","copy_loc$4","copy_structure$4","copy_structure_item$4","copy_toplevel_phrase$4","copy_directive_argument$4","copy_attributes$4","copy_attribute$4","copy_constant$4","copy_rec_flag$4","copy_arg_label$4","copy_constructor_arguments$4","copy_core_type$4","copy_label_declaration$4","copy_extension_constructor$4","copy_Longident_t$4","copy_extension$4","copy_payload$4","copy_signature$4","copy_signature_item$4","copy_functor_parameter$4","copy_module_type$4","copy_override_flag$4","copy_open_infos$4","copy_open_declaration$4","copy_module_expr$4","copy_closed_flag$4","copy_object_field$4","copy_label$4","copy_row_field$4","copy_pattern$4","copy_class_structure$4","copy_class_field$4","copy_with_constraint$4","copy_expression$4","copy_binding_op$4","copy_expression_desc$4","copy_value_binding$4","copy_case$4","copy_value_description$4","copy_variance$4","copy_private_flag$4","copy_type_extension$4","copy_type_exception$4","copy_module_type_declaration$4","copy_include_infos$4","copy_module_binding$4","copy_type_declaration$4","copy_class_declaration$4","copy_class_type_declaration$4","copy_virtual_flag$4","copy_class_infos$4","copy_class_expr$4","copy_open_description$4","copy_class_type$4","copy_class_type_field$4","copy_mutable_flag$4","copy_class_field_kind$4","copy_constructor_declaration$4","copy_module_declaration$4","copy_class_description$4","copy_loc$5","copy_structure$5","copy_structure_item$5","copy_toplevel_phrase$5","copy_directive_argument$5","copy_attributes$5","copy_attribute$5","copy_location_stack$1","copy_location$1","copy_constant$5","copy_rec_flag$5","copy_arg_label$5","copy_constructor_arguments$5","copy_core_type$5","copy_label_declaration$5","copy_extension_constructor$5","copy_Longident_t$5","copy_extension$5","copy_payload$5","copy_signature$5","copy_signature_item$5","copy_functor_parameter$5","copy_module_type$5","copy_override_flag$5","copy_open_infos$5","copy_open_declaration$5","copy_module_expr$5","copy_closed_flag$5","copy_object_field$5","copy_label$5","copy_row_field$5","copy_pattern$5","copy_class_structure$5","copy_class_field$5","copy_with_constraint$5","copy_expression$5","copy_binding_op$5","copy_expression_desc$5","copy_value_binding$5","copy_case$5","copy_value_description$5","copy_variance$5","copy_private_flag$5","copy_type_extension$5","copy_type_exception$5","copy_module_type_declaration$5","copy_include_infos$5","copy_module_binding$5","copy_type_declaration$5","copy_class_declaration$5","copy_class_type_declaration$5","copy_virtual_flag$5","copy_class_infos$5","copy_class_expr$5","copy_open_description$5","copy_class_type$5","copy_class_type_field$5","copy_mutable_flag$5","copy_class_field_kind$5","copy_constructor_declaration$5","copy_module_declaration$5","copy_class_description$5","copy_loc$6","copy_structure$6","copy_structure_item$6","copy_toplevel_phrase$6","copy_directive_argument$6","copy_attributes$6","copy_attribute$6","copy_location_stack$2","copy_location$2","copy_constant$6","copy_rec_flag$6","copy_arg_label$6","copy_constructor_arguments$6","copy_core_type$6","copy_label_declaration$6","copy_extension_constructor$6","copy_Longident_t$6","copy_extension$6","copy_payload$6","copy_signature$6","copy_signature_item$6","copy_functor_parameter$6","copy_module_type$6","copy_override_flag$6","copy_open_infos$6","copy_open_declaration$6","copy_module_expr$6","copy_closed_flag$6","copy_object_field$6","copy_label$6","copy_row_field$6","copy_pattern$6","copy_class_structure$6","copy_class_field$6","copy_with_constraint$6","copy_expression$6","copy_binding_op$6","copy_expression_desc$6","copy_value_binding$6","copy_case$6","copy_value_description$6","copy_variance$6","copy_private_flag$6","copy_type_extension$6","copy_type_exception$6","copy_module_type_declaration$6","copy_include_infos$6","copy_module_binding$6","copy_type_declaration$6","copy_class_declaration$6","copy_class_type_declaration$6","copy_virtual_flag$6","copy_class_infos$6","copy_class_expr$6","copy_open_description$6","copy_class_type$6","copy_class_type_field$6","copy_mutable_flag$6","copy_class_field_kind$6","copy_constructor_declaration$6","copy_module_declaration$6","copy_class_description$6","migration_error$1","map_option","copy_loc$7","copy_structure$7","copy_structure_item$7","copy_toplevel_phrase$7","copy_directive_argument$7","copy_attributes$7","copy_attribute$7","copy_location_stack$3","copy_location$3","copy_constant$7","copy_rec_flag$7","copy_arg_label$7","copy_constructor_arguments$7","copy_core_type$7","copy_label_declaration$7","copy_extension_constructor$7","copy_Longident_t$7","copy_extension$7","copy_payload$7","copy_signature$7","copy_signature_item$7","copy_functor_parameter$7","copy_module_type$7","copy_override_flag$7","copy_open_infos$7","copy_open_declaration$7","copy_module_expr$7","copy_closed_flag$7","copy_object_field$7","copy_label$7","copy_row_field$7","copy_pattern$7","copy_class_structure$7","copy_class_field$7","copy_with_constraint$7","copy_expression$7","copy_binding_op$7","copy_expression_desc$7","copy_value_binding$7","copy_case$7","copy_value_description$7","copy_variance$7","copy_private_flag$7","copy_type_extension$7","copy_type_exception$7","copy_module_type_declaration$7","copy_include_infos$7","copy_module_binding$7","copy_type_declaration$7","copy_class_declaration$7","copy_class_type_declaration$7","copy_virtual_flag$7","copy_class_infos$7","copy_class_expr$7","copy_open_description$7","copy_class_type$7","copy_class_type_field$7","copy_mutable_flag$7","copy_class_field_kind$7","copy_constructor_declaration$7","copy_module_declaration$7","copy_class_description$7","map_option$0","copy_loc$8","copy_structure$8","copy_structure_item$8","copy_toplevel_phrase$8","copy_directive_argument$8","copy_attributes$8","copy_attribute$8","copy_constant$8","copy_rec_flag$8","copy_arg_label$8","copy_constructor_arguments$8","copy_core_type$8","copy_label_declaration$8","copy_extension_constructor$8","copy_Longident_t$8","copy_extension$8","copy_payload$8","copy_signature$8","copy_signature_item$8","copy_override_flag$8","copy_open_infos$8","copy_open_declaration$8","copy_module_expr$8","copy_closed_flag$8","copy_location$4","copy_object_field$8","copy_label$8","copy_row_field$8","copy_pattern$8","copy_class_structure$8","copy_class_field$8","copy_cases","copy_case$8","copy_module_type$8","copy_with_constraint$8","copy_expression$8","copy_binding_op$8","copy_expression_desc$8","copy_value_binding$8","copy_value_description$8","copy_variance$8","copy_private_flag$8","copy_type_extension$8","copy_type_exception$8","copy_module_type_declaration$8","copy_include_infos$8","copy_module_binding$8","copy_type_declaration$8","copy_class_declaration$8","copy_class_type_declaration$8","copy_virtual_flag$8","copy_class_infos$8","copy_class_expr$8","copy_open_description$8","copy_class_type$8","copy_class_type_field$8","copy_mutable_flag$8","copy_class_field_kind$8","copy_constructor_declaration$8","copy_module_declaration$8","copy_class_description$8","copy_loc$9","copy_structure$9","copy_structure_item$9","copy_toplevel_phrase$9","copy_directive_argument$9","copy_attributes$9","copy_attribute$9","copy_constant$9","copy_rec_flag$9","copy_arg_label$9","copy_constructor_arguments$9","copy_core_type$9","copy_label_declaration$9","copy_extension_constructor$9","copy_Longident_t$9","copy_extension$9","copy_payload$9","copy_signature$9","copy_signature_item$9","copy_override_flag$9","copy_open_infos$9","copy_open_declaration$9","copy_module_expr$9","copy_closed_flag$9","copy_location$5","copy_object_field$9","copy_label$9","copy_row_field$9","copy_pattern$9","copy_class_structure$9","copy_class_field$9","copy_cases$0","copy_case$9","copy_module_type$9","copy_with_constraint$9","copy_expression$9","copy_binding_op$9","copy_expression_desc$9","copy_value_binding$9","copy_value_description$9","copy_variance$9","copy_private_flag$9","copy_type_extension$9","copy_type_exception$9","copy_module_type_declaration$9","copy_include_infos$9","copy_module_binding$9","copy_type_declaration$9","copy_class_declaration$9","copy_class_type_declaration$9","copy_virtual_flag$9","copy_class_infos$9","copy_class_expr$9","copy_open_description$9","copy_class_type$9","copy_class_type_field$9","copy_mutable_flag$9","copy_class_field_kind$9","copy_constructor_declaration$9","copy_module_declaration$9","copy_class_description$9","copy_loc$10","copy_structure$10","copy_structure_item$10","copy_toplevel_phrase$10","copy_directive_argument$10","copy_attributes$10","copy_attribute$10","copy_constant$10","copy_rec_flag$10","copy_arg_label$10","copy_constructor_arguments$10","copy_core_type$10","copy_label_declaration$10","copy_extension_constructor$10","copy_Longident_t$10","copy_extension$10","copy_payload$10","copy_signature$10","copy_signature_item$10","copy_override_flag$10","copy_open_infos$10","copy_open_declaration$10","copy_module_expr$10","copy_closed_flag$10","copy_location$6","copy_object_field$10","copy_label$10","copy_row_field$10","copy_pattern$10","copy_class_structure$10","copy_class_field$10","copy_cases$1","copy_case$10","copy_module_type$10","copy_with_constraint$10","copy_expression$10","copy_binding_op$10","copy_expression_desc$10","copy_value_binding$10","copy_value_description$10","copy_variance$10","copy_private_flag$10","copy_type_extension$10","copy_type_exception$10","copy_module_type_declaration$10","copy_include_infos$10","copy_module_binding$10","copy_type_declaration$10","copy_class_declaration$10","copy_class_type_declaration$10","copy_virtual_flag$10","copy_class_infos$10","copy_class_expr$10","copy_open_description$10","copy_class_type$10","copy_class_type_field$10","copy_mutable_flag$10","copy_class_field_kind$10","copy_constructor_declaration$10","copy_module_declaration$10","copy_class_description$10","migration_error$2","copy_bool","copy_option","copy_structure$11","copy_structure_item$11","copy_toplevel_phrase$11","copy_attributes$11","copy_attribute$11","copy_loc$11","copy_constant$11","copy_rec_flag$11","copy_arg_label$11","copy_constructor_arguments$11","copy_core_type$11","copy_label_declaration$11","copy_extension_constructor$11","copy_longident","copy_override_flag$11","copy_extension$11","copy_payload$11","copy_signature$11","copy_signature_item$11","copy_closed_flag$11","copy_object_field$11","copy_label$11","copy_row_field$11","copy_pattern$11","copy_class_structure$11","copy_class_field$11","copy_module_type$11","copy_with_constraint$11","copy_module_expr$11","copy_expression$11","copy_expression_desc$11","copy_value_binding$11","copy_case$11","copy_value_description$11","copy_variance$11","copy_private_flag$11","copy_type_extension$11","copy_module_type_declaration$11","copy_include_infos$11","copy_module_binding$11","copy_type_declaration$11","copy_class_declaration$11","copy_class_type_declaration$11","copy_virtual_flag$11","copy_class_infos$11","copy_class_expr$11","copy_class_type$11","copy_class_type_field$11","copy_mutable_flag$11","copy_class_field_kind$11","copy_constructor_declaration$11","copy_module_declaration$11","x0_loc","copy_class_description$11","copy_toplevel_phrase$12","copy_directive_argument$11","copy_expression$12","copy_expression_desc$12","copy_direction_flag","copy_case$12","copy_value_binding$12","copy_pattern$12","copy_pattern_desc","copy_core_type$12","copy_core_type_desc","copy_package_type","copy_row_field$12","copy_object_field$12","copy_attributes$12","copy_attribute$12","copy_payload$12","copy_structure$12","copy_structure_item$12","copy_structure_item_desc","copy_include_declaration","copy_class_declaration$12","copy_class_expr$12","copy_class_expr_desc","copy_class_structure$12","copy_class_field$12","copy_class_field_desc","copy_class_field_kind$12","copy_module_binding$12","copy_module_expr$12","copy_module_expr_desc","copy_module_type$12","copy_module_type_desc","copy_with_constraint$12","copy_signature$12","copy_signature_item$12","copy_signature_item_desc","copy_class_type_declaration$12","copy_class_description$12","copy_class_type$12","copy_class_type_desc","copy_class_signature","copy_class_type_field$12","copy_class_type_field_desc","copy_extension$12","copy_class_infos$12","copy_virtual_flag$12","copy_include_description","copy_include_infos$12","copy_open_description$11","copy_override_flag$12","copy_module_type_declaration$12","copy_module_declaration$12","copy_type_extension$12","copy_extension_constructor$12","copy_extension_constructor_kin","copy_type_declaration$12","copy_private_flag$12","copy_type_kind","copy_constructor_declaration$12","copy_constructor_arguments$12","copy_label_declaration$12","copy_mutable_flag$12","copy_variance$12","copy_value_description$12","copy_arg_label$12","copy_closed_flag$12","copy_label$12","copy_rec_flag$12","copy_constant$12","copy_option$0","copy_longident$0","copy_loc$12","copy_location$7","copy_bool$0","wrap$2","x2$6","atat","popen_lid","copy_attributes$13","copy_attribute$13","copy_loc$13","copy_option$1","copy_constant$13","copy_rec_flag$13","copy_arg_label$13","copy_constructor_arguments$13","copy_core_type$13","copy_label_declaration$13","copy_extension_constructor$13","copy_longident$1","copy_override_flag$13","copy_extension$13","copy_payload$13","copy_signature$13","copy_signature_item$13","copy_structure$13","copy_structure_item$13","copy_closed_flag$13","copy_object_field$13","copy_label$13","copy_row_field$13","copy_pattern$13","copy_class_structure$13","copy_class_field$13","copy_module_type$13","copy_with_constraint$13","copy_module_expr$13","copy_expression$13","copy_expression_desc$13","copy_value_binding$13","copy_case$13","copy_bool$1","copy_value_description$13","copy_variance$13","copy_private_flag$13","copy_type_extension$13","copy_module_type_declaration$13","copy_open_description$12","copy_include_infos$13","copy_module_binding$13","copy_type_declaration$13","copy_class_declaration$13","copy_class_type_declaration$13","copy_virtual_flag$13","copy_class_infos$13","copy_class_expr$13","copy_class_type$13","copy_class_type_field$13","cty","copy_class_field_kind$13","copy_mutable_flag$13","copy_constructor_declaration$13","copy_module_declaration$13","copy_class_description$13","copy_toplevel_phrase$13","copy_attributes$14","copy_attribute$14","copy_loc$14","copy_option$2","copy_constant$14","copy_rec_flag$14","copy_arg_label$14","copy_constructor_arguments$14","copy_core_type$14","copy_label_declaration$14","copy_extension_constructor$14","copy_longident$2","copy_override_flag$14","copy_extension$14","copy_payload$14","copy_signature$14","copy_signature_item$14","copy_structure$14","copy_structure_item$14","copy_closed_flag$14","copy_object_field$14","copy_label$14","copy_row_field$14","copy_pattern$14","copy_class_structure$14","copy_class_field$14","copy_module_type$14","copy_with_constraint$14","copy_module_expr$14","copy_expression$14","copy_expression_desc$14","copy_value_binding$14","copy_case$14","copy_bool$2","copy_value_description$14","copy_variance$14","copy_private_flag$14","copy_type_extension$14","copy_module_type_declaration$14","copy_open_description$13","copy_include_infos$14","copy_module_binding$14","copy_type_declaration$14","copy_class_declaration$14","copy_class_type_declaration$14","copy_virtual_flag$14","copy_class_infos$14","copy_class_expr$14","copy_class_type$14","copy_class_type_field$14","copy_class_field_kind$14","copy_mutable_flag$14","copy_constructor_declaration$14","copy_module_declaration$14","copy_class_description$14","copy_toplevel_phrase$14","migration_error$3","copy_attributes$15","copy_attribute$15","copy_loc$15","copy_option$3","copy_constant$15","copy_rec_flag$15","copy_arg_label$15","copy_constructor_arguments$15","copy_core_type$15","copy_label_declaration$15","copy_extension_constructor$15","copy_longident$3","copy_override_flag$15","copy_extension$15","copy_payload$15","copy_signature$15","copy_signature_item$15","copy_structure$15","copy_structure_item$15","copy_closed_flag$15","copy_label$15","copy_row_field$15","copy_pattern$15","copy_class_structure$15","copy_class_field$15","copy_module_type$15","copy_with_constraint$15","copy_module_expr$15","copy_expression$15","copy_expression_desc$15","copy_value_binding$15","copy_case$15","copy_bool$3","copy_value_description$15","copy_variance$15","copy_private_flag$15","copy_type_extension$15","copy_module_type_declaration$15","copy_open_description$14","copy_include_infos$15","copy_module_binding$15","copy_type_declaration$15","copy_class_declaration$15","copy_class_type_declaration$15","copy_virtual_flag$15","copy_class_infos$15","copy_class_expr$15","copy_class_type$15","copy_class_type_field$15","copy_class_field_kind$15","copy_mutable_flag$15","copy_constructor_declaration$15","loc$1","copy_module_declaration$15","copy_class_description$15","copy_toplevel_phrase$15","copy_attributes$16","copy_attribute$16","copy_loc$16","copy_option$4","copy_constant$16","copy_rec_flag$16","copy_arg_label$16","copy_constructor_arguments$16","copy_core_type$16","copy_label_declaration$16","copy_extension_constructor$16","copy_longident$4","copy_override_flag$16","copy_extension$16","copy_payload$16","copy_signature$16","copy_signature_item$16","copy_structure$16","copy_structure_item$16","copy_closed_flag$16","copy_label$16","copy_row_field$16","copy_pattern$16","copy_class_structure$16","copy_class_field$16","copy_module_type$16","copy_with_constraint$16","copy_module_expr$16","copy_expression$16","copy_expression_desc$16","copy_value_binding$16","copy_case$16","copy_bool$4","copy_value_description$16","copy_variance$16","copy_private_flag$16","copy_type_extension$16","copy_module_type_declaration$16","copy_open_description$15","copy_include_infos$16","copy_module_binding$16","copy_type_declaration$16","copy_class_declaration$16","copy_class_type_declaration$16","copy_virtual_flag$16","copy_class_infos$16","copy_class_expr$16","copy_class_type$16","copy_class_type_field$16","copy_class_field_kind$16","copy_mutable_flag$16","copy_constructor_declaration$16","copy_module_declaration$16","copy_class_description$16","copy_toplevel_phrase$16","copy_attributes$17","copy_attribute$17","copy_loc$17","copy_option$5","copy_constant$17","copy_rec_flag$17","copy_arg_label$17","copy_constructor_arguments$17","copy_core_type$17","copy_label_declaration$17","copy_extension_constructor$17","copy_longident$5","copy_override_flag$17","copy_extension$17","copy_payload$17","copy_signature$17","copy_signature_item$17","copy_structure$17","copy_structure_item$17","copy_closed_flag$17","copy_label$17","copy_row_field$17","copy_pattern$17","copy_class_structure$17","copy_class_field$17","copy_module_type$17","copy_with_constraint$17","copy_module_expr$17","copy_expression$17","copy_expression_desc$17","copy_value_binding$17","copy_case$17","copy_bool$5","copy_value_description$17","copy_variance$17","copy_private_flag$17","copy_type_extension$17","copy_module_type_declaration$17","copy_open_description$16","copy_include_infos$17","copy_module_binding$17","copy_type_declaration$17","copy_class_declaration$17","copy_class_type_declaration$17","copy_virtual_flag$17","copy_class_infos$17","copy_class_expr$17","copy_class_type$17","copy_class_type_field$17","copy_class_field_kind$17","copy_mutable_flag$17","copy_constructor_declaration$17","copy_module_declaration$17","copy_class_description$17","copy_toplevel_phrase$17","noloc","copy_attributes$18","copy_attribute$18","copy_loc$18","copy_option$6","copy_constant$18","copy_rec_flag$18","copy_arg_label$18","copy_constructor_arguments$18","copy_core_type$18","copy_label_declaration$18","copy_extension_constructor$18","copy_longident$6","copy_override_flag$18","copy_extension$18","copy_payload$18","copy_signature$18","copy_signature_item$18","copy_structure$18","copy_structure_item$18","copy_closed_flag$18","copy_label$18","copy_row_field$18","copy_pattern$18","copy_class_structure$18","copy_class_field$18","copy_module_type$18","copy_with_constraint$18","copy_module_expr$18","copy_expression$18","copy_expression_desc$18","copy_value_binding$18","copy_case$18","copy_bool$6","copy_value_description$18","copy_variance$18","copy_private_flag$18","copy_type_extension$18","copy_module_type_declaration$18","copy_open_description$17","copy_include_infos$18","copy_module_binding$18","copy_type_declaration$18","copy_class_declaration$18","copy_class_type_declaration$18","copy_virtual_flag$18","copy_class_infos$18","copy_class_expr$18","copy_class_type$18","copy_class_type_field$18","copy_class_field_kind$18","copy_mutable_flag$18","copy_constructor_declaration$18","copy_module_declaration$18","copy_class_description$18","copy_toplevel_phrase$18","migration_error$4","copy_attributes$19","copy_attribute$19","copy_loc$19","copy_option$7","copy_constant$19","copy_rec_flag$19","copy_arg_label$19","copy_override_flag$19","copy_extension$19","copy_payload$19","copy_signature$19","copy_signature_item$19","copy_structure$19","copy_structure_item$19","copy_closed_flag$19","copy_core_type$19","copy_longident$7","copy_label$19","copy_row_field$19","copy_pattern$19","copy_class_structure$19","copy_class_field$19","copy_module_type$19","copy_with_constraint$19","copy_module_expr$19","copy_expression$19","copy_expression_desc$19","copy_value_binding$19","copy_case$19","copy_bool$7","copy_value_description$19","copy_constructor_arguments$19","copy_label_declaration$19","copy_extension_constructor$19","copy_variance$19","copy_private_flag$19","copy_type_extension$19","copy_module_type_declaration$19","copy_open_description$18","copy_include_infos$19","copy_module_binding$19","copy_type_declaration$19","copy_class_declaration$19","copy_class_type_declaration$19","copy_virtual_flag$19","copy_class_infos$19","copy_class_expr$19","copy_class_type$19","copy_class_type_field$19","copy_class_field_kind$19","copy_mutable_flag$19","copy_constructor_declaration$19","copy_module_declaration$19","copy_class_description$19","copy_toplevel_phrase$19","copy_attributes$20","copy_attribute$20","copy_loc$20","copy_option$8","copy_constant$20","copy_rec_flag$20","copy_arg_label$20","copy_override_flag$20","copy_extension$20","copy_payload$20","copy_signature$20","copy_signature_item$20","copy_structure$20","copy_structure_item$20","copy_closed_flag$20","copy_core_type$20","copy_longident$8","copy_label$20","copy_row_field$20","copy_pattern$20","copy_class_structure$20","copy_class_field$20","copy_module_type$20","copy_with_constraint$20","copy_module_expr$20","copy_expression$20","copy_expression_desc$20","copy_value_binding$20","copy_case$20","copy_bool$8","copy_value_description$20","copy_constructor_arguments$20","copy_label_declaration$20","copy_extension_constructor$20","copy_variance$20","copy_private_flag$20","copy_type_extension$20","copy_module_type_declaration$20","copy_open_description$19","copy_include_infos$20","copy_module_binding$20","copy_type_declaration$20","copy_class_declaration$20","copy_class_type_declaration$20","copy_virtual_flag$20","copy_class_infos$20","copy_class_expr$20","copy_class_type$20","copy_class_type_field$20","copy_class_field_kind$20","copy_mutable_flag$20","copy_constructor_declaration$20","copy_module_declaration$20","copy_class_description$20","copy_toplevel_phrase$20","inject_predef_option","ident","migration_error$5","copy_attributes$21","copy_attribute$21","copy_loc$21","copy_option$9","copy_constant$21","copy_rec_flag$21","copy_arg_label$21","copy_override_flag$21","copy_extension$21","copy_payload$21","copy_signature$21","copy_signature_item$21","copy_structure$21","copy_structure_item$21","copy_closed_flag$21","copy_core_type$21","copy_longident$9","copy_label$21","copy_row_field$21","copy_pattern$21","copy_class_structure$21","copy_class_field$21","copy_module_type$21","copy_with_constraint$21","copy_module_expr$21","copy_expression$21","copy_expression_desc$21","copy_value_binding$21","copy_case$21","copy_bool$9","type_declarations$3","recflag","types","copy_type_declaration$21","copy_value_description$21","copy_constructor_arguments$21","copy_extension_constructor$21","copy_variance$21","copy_private_flag$21","copy_type_extension$21","copy_module_type_declaration$21","copy_open_description$20","copy_include_infos$21","copy_module_binding$21","copy_class_declaration$21","copy_class_type_declaration$21","copy_virtual_flag$21","copy_class_infos$21","copy_class_expr$21","copy_class_type$21","copy_class_type_field$21","copy_class_field_kind$21","copy_mutable_flag$21","copy_constructor_declaration$21","copy_label_declaration$21","copy_module_declaration$21","copy_class_description$21","copy_toplevel_phrase$21","extract_predef_option","copy_attributes$22","copy_attribute$22","copy_loc$22","copy_option$10","copy_constant$22","copy_rec_flag$22","copy_arg_label$22","copy_override_flag$22","copy_extension$22","copy_payload$22","copy_signature$22","copy_signature_item$22","copy_structure$22","copy_structure_item$22","copy_closed_flag$22","copy_core_type$22","copy_longident$10","copy_label$22","copy_row_field$22","copy_pattern$22","copy_class_structure$22","copy_class_field$22","copy_module_type$22","copy_with_constraint$22","copy_module_expr$22","copy_expression$22","copy_expression_desc$22","copy_value_binding$22","copy_case$22","copy_bool$10","type_declarations$4","is_nonrec","attr","types$0","copy_type_declaration$22","copy_value_description$22","copy_extension_constructor$22","copy_variance$22","copy_private_flag$22","copy_type_extension$22","copy_module_type_declaration$22","copy_open_description$21","copy_include_infos$22","copy_module_binding$22","copy_class_declaration$22","copy_class_type_declaration$22","copy_virtual_flag$22","copy_class_infos$22","copy_class_expr$22","copy_class_type$22","copy_class_type_field$22","copy_class_field_kind$22","copy_mutable_flag$22","copy_constructor_declaration$22","copy_label_declaration$22","copy_module_declaration$22","copy_class_description$22","copy_toplevel_phrase$22","migration_info","id$7","migration_identity","compose$2","migration_functions","is_undefined","immediate_migration","A","direction","funs","B","To","to2","migration_info$0","migration_info$1","migration_info$2","migration_info$3","migration_info$4","migration_info$5","migration_info$6","migration_info$7","migration_info$8","migration_info$10","migration_info$11","version$1","version$2","version$3","version$4","version$5","version$6","version$7","version$9","version$10","of_ocaml","to_ocaml","of_ocaml_mapper","item","to_ocaml_mapper","parse$1","parse$2","self_1","a$3","a$4","a$5","a$6","pdira_desc$0","pdira_loc$0","pdir_name$0","pdir_arg$0","pdir_loc$0","pmb_name$0","pmb_expr$0","pmb_attributes$0","pmb_loc$0","pvb_pat$0","pvb_expr$0","pvb_attributes$0","pvb_loc$0","b$3","b$4","a$7","a$8","a$9","a$10","a$11","a$12","a$13","a$14","a$15","a$16","a$17","a$18","a$19","a$20","a$21","a$22","a$23","a$24","a$25","a$26","b$5","a$27","a$28","b$6","pstr_desc$0","pstr_loc$0","pmod_desc$0","pmod_loc$0","pmod_attributes$0","pincl_mod$0","pincl_loc$0","pincl_attributes$0","popen_expr$0","popen_override$0","popen_loc$0","popen_attributes$0","pmtd_name$0","pmtd_type$0","pmtd_attributes$0","pmtd_loc$0","pms_name$0","pms_manifest$0","pms_attributes$0","pms_loc$0","pmd_name$0","pmd_type$0","pmd_attributes$0","pmd_loc$0","psig_desc$0","psig_loc$0","pmty_desc$0","pmty_loc$0","pmty_attributes$0","pcf_desc$0","pcf_loc$0","pcf_attributes$0","pcstr_self$0","pcstr_fields$0","b$7","b$8","b$9","b$10","pcl_desc$0","pcl_loc$0","pcl_attributes$0","pci_virt$0","pci_params$0","pci_name$0","pci_expr$0","pci_loc$0","pci_attributes$0","d$1","d$2","pctf_desc$0","pctf_loc$0","pctf_attributes$0","pcsig_self$0","pcsig_fields$0","pcty_desc$0","pcty_loc$0","pcty_attributes$0","ptyexn_constructor$0","ptyexn_loc$0","ptyexn_attributes$0","pext_name$0","pext_kind$0","pext_loc$0","pext_attributes$0","ptyext_path$0","ptyext_params$0","ptyext_constructors$0","ptyext_private$0","ptyext_loc$0","ptyext_attributes$0","pcd_name$0","pcd_args$0","pcd_res$0","pcd_loc$0","pcd_attributes$0","pld_name$0","pld_mutable$0","pld_type$0","pld_loc$0","pld_attributes$0","ptype_name$0","ptype_params$0","ptype_cstrs$0","ptype_kind$0","ptype_private$0","ptype_manifest$0","ptype_attributes$0","ptype_loc$0","pval_name$0","pval_type$0","pval_prim$0","pval_attributes$0","pval_loc$0","pbop_op$0","pbop_pat$0","pbop_exp$0","pbop_loc$0","let$1","ands$0","pc_lhs$0","pc_guard$0","pc_rhs$0","b$11","b$12","b$13","b$14","b$15","b$16","b$17","b$18","b$19","a$29","a$30","b$20","b$21","a$31","a$32","b$22","b$23","a$33","a$34","b$24","c$7","b$25","a$35","a$36","b$26","c$8","b$27","a$37","a$38","b$28","c$9","b$29","a$39","a$40","b$30","c$10","b$31","a$41","a$42","b$32","a$43","a$44","b$33","a$45","a$46","b$34","a$47","a$48","c$11","b$35","a$49","a$50","b$36","c$12","b$37","a$51","a$52","b$38","a$53","a$54","a$55","a$56","b$39","a$57","a$58","b$40","a$59","a$60","b$41","a$61","a$62","b$42","a$63","a$64","b$43","a$65","a$66","b$44","a$67","a$68","a$69","a$70","pexp_desc$0","pexp_loc$0","pexp_loc_stack$0","pexp_attributes$0","ppat_desc$0","ppat_loc$0","ppat_loc_stack$0","ppat_attributes$0","pof_desc$0","pof_loc$0","pof_attributes$0","prf_desc$0","prf_loc$0","prf_attributes$0","ptyp_desc$0","ptyp_loc$0","ptyp_loc_stack$0","ptyp_attributes$0","attr_name$0","attr_payload$0","attr_loc$0","loc_ghost","loc_end","loc_start","loc_start$0","loc_end$0","loc_ghost$0","pos_cnum","pos_bol","pos_lnum","pos_fname","pos_fname$0","pos_lnum$0","pos_bol$0","pos_cnum$0","self_2","self_3","acc$5","acc$6","acc$7","acc$8","acc$9","acc$10","acc$11","acc$12","acc$13","acc$14","acc$15","acc$16","acc$17","acc$18","acc$19","acc$20","acc$21","acc$22","acc$23","acc$24","acc$25","acc$26","acc$27","acc$28","acc$29","acc$30","acc$31","acc$32","acc$33","acc$34","acc$35","acc$36","acc$37","acc$38","acc$39","acc$40","acc$41","acc$42","acc$43","acc$44","acc$45","acc$46","acc$47","acc$48","acc$49","acc$50","acc$51","acc$52","acc$53","acc$54","acc$55","self_4","acc$56","acc$57","acc$58","acc$59","acc$60","acc$61","acc$62","acc$63","acc$64","acc$65","acc$66","acc$67","acc$68","self_5","self_6","lookup$1","drv","compare$108","equal$61","protectx$0","add$27","add_exn$3","find_opt$1","of_alist$5","alist$0","f$12","read_all_into","map$65","fold_right$6","symbol$208","concat$4","is_empty$12","filter_map$8","concat_map$2","assoc_opt","iter$32","is_some$2","map$66","is_empty$13","prefix$2","drop_prefix$0","index_opt","rindex_opt","split_on_char$0","find_opt$2","to_string_path","located","in_file$0","loc$5","raise_errorf$0","enter_module","enter_value$0","module_name$32","enter","enter_opt","self_7","mtd","mb","self_8","var_names_of","ec_enter_module_opt","self_9","var_name","var_name$0","in_binding_ctxt","sexp_of$0","self_10","levenshtein_distance","cutoff","line_min","distance","spellcheck$2","registered_name","names_at_best_distance","best_distance","dist","suggestions","rev_rest","ptyp_any","ptyp_constr","pexp_ident","pexp_constant","pexp_let","pexp_fun","pexp_construct","pexp_variant","pexp_record","include_infos$0","ppat_any","ppat_constant","ppat_construct","ppat_variant","ppat_record","pstr_eval","pstr_value","value_binding$0","pat","short_name","name$96","flatten_exn","unflatten","parse$3","map$68","map_lident","lident","vbs","pexp_tuple","ppat_tuple","pexp_apply","unapplied_type_constr_conv_wit","apply_loc","suffix_n","functor","functor_args","functor$0","functor_path","ident$0","gather_args","subpat","param_label","arg_label","ty_opt","attribute","binding_op","lhs","guard","rhs","pcl_constr","pcl_structure","pcl_fun","pcl_apply","pcl_let","pcl_constraint","pcl_extension","pcl_open","pcf_inherit","pcf_val","pcf_method","pcf_constraint","pcf_initializer","pcf_attribute","pcf_extension","class_infos","virt","class_signature","class_structure","pcty_constr","pcty_signature","pcty_arrow","pcty_extension","pcty_open","pctf_inherit","pctf_val","pctf_method","pctf_constraint","pctf_attribute","pctf_extension","ptyp_var","ptyp_arrow","ptyp_object","ptyp_class","ptyp_alias","ptyp_variant","ptyp_package","ptyp_extension","pdir_string","pdir_int","pdir_ident","pdir_bool","pexp_constant$0","pexp_function","pexp_fun$0","pexp_match","pexp_try","pexp_construct$0","pexp_field","pexp_setfield","pexp_array","pexp_ifthenelse","pexp_sequence","pexp_while","pexp_for","pexp_constraint","pexp_coerce","pexp_send","pexp_new","pexp_setinstvar","pexp_override","pexp_letmodule","pexp_letexception","pexp_assert","pexp_lazy","pexp_poly","pexp_object","pexp_newtype","pexp_pack","pexp_open","pexp_letop","pexp_extension","pexp_unreachable","include_infos","label_declaration","mutable","type","letop","end","ghost","module_binding","module_declaration","pmod_ident","pmod_structure","pmod_functor","pmod_apply","pmod_constraint","pmod_unpack","pmod_extension","module_substitution","pmty_ident","pmty_signature","pmty_functor","pmty_with","pmty_typeof","pmty_extension","pmty_alias","module_type_declaration","otag","oinherit","open_infos","ppat_var","ppat_alias","ppat_constant$0","ppat_interval","ppat_construct$0","ppat_array","ppat_or","ppat_constraint","ppat_type","ppat_lazy","ppat_unpack","ppat_exception","ppat_extension","ppat_open","cnum","rtag","rinherit","psig_value","psig_type","psig_typesubst","psig_typext","psig_exception","psig_module","psig_modsubst","psig_recmodule","psig_modtype","psig_open","psig_include","psig_class","psig_class_type","psig_attribute","psig_extension","pstr_primitive","pstr_type","pstr_typext","pstr_exception","pstr_module","pstr_recmodule","pstr_modtype","pstr_open","pstr_class","pstr_class_type","pstr_include","pstr_attribute","pstr_extension","toplevel_directive","type_declaration","private$0","type_exception","type_extension","constructors","value_binding","value_description","prim","nonrec_type_declaration","mk","lident$0","pexp_tuple$0","ppat_tuple$0","ptyp_tuple","pexp_tuple_opt","ppat_tuple_opt","ptyp_poly","pexp_apply$0","eint$0","echar","estring$0","efloat$0","eint32","eint64","enativeint","ebool","evar$0","pint","pchar","pstring","pfloat","pint32","pint64","pnativeint","pbool","pvar$0","eunit$0","punit","eapply$0","eabstract","esequence","elist$0","plist$0","type_constr_conv$0","unapplied_type_constr_conv","make$9","get$15","fold_dot_suffixes","collapse_after_at","parts","parts$1","parts$0","make$10","matches","matched","create_set","fully_qualified_names","attributes$0","list$5","is_whitelisted","reserve","is_in_reserved_namespaces","ignore_checks","create$74","current_file","string_of_context","get_all_for_context","check_collisions_local","caller","all_for_context","declared_at","context$0","check_collisions","register$1","kind$0","raise_errorf$1","white_list","white_list$0","other_contexts","current_context","a_or_an","rev_others","others","meths$0","nmeths","nvals","pstr","pstr_eval$0","restore_context","backup","incr_matched","parse$4","on_error","param$2","nil","symbol$209","symbol$210","map$69","many","single_expr_payload","get_pstr_eval","st","get_pstr_extension","get_psig_extension","get_attributes","get_attribute_if_is_floating_n","dummy_ext","name$97","registrar","declare","pattern","not_seen","mark_as_seen","do_mark_as_seen","get$16","longest_match","longest_match$1","longest_match$0","attr$0","name$98","declare$0","convert$0","check_attribute","item$0","item$1","closed_flag","end_marker","end_marker_str","extract_prefix","remove_loc","remove_loc$0","prev$1","diff_asts","generated","round_trip","with_temp_file","fn1","fn2","ast","cmd$0","parse_string","match_loop","mismatch_handler","source","expected$0","source$0","source$1","expected$1","do_match","get_loc","get_loc$0","to_sexp$0","match_structure","match_signature","class_expr$3","class_field$1","class_type$4","class_type_field$0","expression$0","module_expr$1","module_type$3","pattern$1","signature_item$2","structure_item$1","get_extension","virtual_payload","merge_attributes","registrar$0","with_arg","ext","i$4","convert$1","convert_inline","filter_by_context","expanders","expanders$0","fail$2","split_normal_and_expect","split_normal_and_expect$0","filter$7","extension$0","attr_str_type_decl","expand","attr_sig_type_decl","attr_str_module_type_decl","attr_sig_module_type_decl","attr_str_type_ext","attr_sig_type_ext","attr_str_exception","attr_sig_exception","attr_str_type_decl_expect","attr_sig_type_decl_expect","attr_str_module_type_decl_expe","attr_sig_module_type_decl_expe","attr_str_type_ext_expect","attr_sig_type_ext_expect","attr_str_exception_expect","attr_sig_exception_expect","hook","replace$0","insert_after","map_nodes","super_call","base_ctxt","in_generated_code","extension_point_loc","generated_code","get_group","vals$0","rev_concat","sort_attr_group_inline","sort_attr_inline","context_free_attribute_modific","handle_attr_group_inline","items","expanded_items","expect_items","handle_attr_inline","expanded_item","expect_mismatch_handler","items$0","exp_tds","exp_rf","tds","extra_items","with_extra_items","exp_te","extra_items$0","expect_items$0","exp_ec","ec","extra_items$1","expect_items$1","exp_mtd","extra_items$2","expect_items$2","original_rest","repl","pexp_attributes$1","pexp_attributes$2","expand_constant","rules","special_functions","special_functions$0","extensions","class_expr","class_field","class_type","class_type_field","module_expr","module_type","signature_item","structure_item","ppx_import","attr_sig_exceptions_expect","attr_sig_exceptions","map_node","ctxt$0","ext$0","mk_attr_noloc","hide_attribute","add_arg","loc_fname","perform_checks$0","perform_checks_on_extensions$0","perform_locations_check$0","no_merge","given_through_cli","has_name","all$7","print_caller_id","caller_id","add_ctxt_arg","register_transformation","enclose_impl","enclose_intf","impl","intf","lint_impl","lint_intf","preprocess_impl","preprocess_intf","impl$0","intf$0","preprocess_impl$0","preprocess_intf$0","lint_impl$0","lint_intf$0","enclose_impl$0","enclose_intf$0","instrument","extensions$0","rules$0","aliases","rules$1","new_fn","old_fn","parse_apply_list","mask$1","handle_apply","handle_dont_apply","set_cookie","shared_args","pretty","patt","vars_of","st$2","st$0","vb","st$1","add_dummy_user_for_values","binds_module_names","do_insert_unused_warning_attri","keep_w32_impl","keep_w32_intf","keep_w32_spec","conv_w32_spec","keep_w32_impl$0","keep_w60_impl","keep_w60_intf","keep_w60_spec","names$0","create$75","apply$8","make_noarg","deps$0","deps","arg_names","apply_all","generators","spellcheck_msg","str_type_decl","str_type_ext","str_exception","str_module_type_decl","sig_type_decl","sig_type_ext","sig_exception","sig_module_type_decl","resolve_actual_derivers","collected","resolve_internal","not_supported","spellcheck","resolve","resolve_all","derivers","derivers_and_args","named_generators","actual_deriver_name","dep","dep_name","add$29","extension$1","actual_deriver","invalid_with","generator_name_of_id","f$13","mk_deriving_attr","generator_name","disable_warnings_attribute","warning","inline_doc_attr","wrap_str","hide","warnings$0","warnings$2","warnings$1","wrap_sig","sg$0","sg$1","merge_generators","expand_str_type_decls","expand_sig_type_decls","expand_str_module_type_decl","generators$0","expand_sig_module_type_decl","expand_str_exception","expand_sig_exception","expand_str_type_ext","expand_sig_type_ext","expand_sig","expand_str","rule_str","rule_sig","rule_str_expect","rule_sig_expect","deriving_attr","deriving_attr_expect","rules_type_decl","rules_type_ext","rules_exception","rules_module_type_decl","error$6","unsupported","internal_error","short_string_of_core_type","loc_map$0","lident_loc","prefixed_type_name","observer_name","shrinker_name","pname","ename","gensym","sym","gensyms","loc_list","fn_map_label","f_expr","f_pat","x_expr","x_pat","create_list","salt","location$0","weight_attribute","weight$3","core_type_list","label_decl_list","label_decl","pattern$2","pat_list","expression$1","expr_list","create_list$0","salt$0","location$1","weight_attribute$0","weight$4","core_type_list$0","pattern$3","expression$2","create$76","location$2","pattern$4","expression$3","create$77","location$3","core_type$3","pattern$5","expression$4","compound_sequence","make_compound_expr","field_pats","field_exprs","shrinker_exprs","compound","shrinker_of_core_type","variant$2","variant_type","clauses","Clause","clauses$0","clause","empty$31","lookup$2","of_alist$6","variance_error","create_with_variance","covariant","contravariant","param_list","injectivity","variance","expr$0","pat$0","by_variance_list","covariant_t","tyvar$0","contravariant_t","compound_generator","generator_list","size_expr","size_pat","random_expr","random_pat","compound$0","generator_of_core_type","variant$3","rec_names","make_generator","make_pair","nonrecursive_clauses","nonrec_expr","nonrec_pat","rec_expr","rec_pat","nonrec_exprs","nonrec_pats","rec_exprs","rec_pats","weight_expr","gen_expr","pairs","compound_hash","hash_expr","hash_pat","observer_exprs","body_expr","field_expr","observer_expr","compound$1","observer_of_core_type","variant$4","custom_extension","generator_attribute","obs_env","gen_env","output_type","input_type","generator_of_core_type$0","input_generator","output_observer","unlabelled","observer_of_core_type$0","input_observer","output_generator","generator_impl","observer_impl","shrinker_impl","maybe_mutually_recursive","of_lazy","decls$0","decl","impls","pats","inner_bindings","lazy_expr","covar","contravar","covar$0","contravar$0","type_decl$0","shrinker_intf","generator_intf","observer_intf","sig_type_decl$0","str_type_decl$0","rec_flag$0","generator_extension","observer_extension","shrinker_extension","create$78","fu$0","three_u_squared","sqrt_neg_three_u_squared","potential_xs","alpha_inv","temp","t2_plus_fu","t2_inv","temp$0","try_decode","group$93","bin_shape_t$97","group$94","bin_shape_t$98","group$95","create$79","first_map","three_fourths","curve_eqn","conic_c","conic_d","projection_point","field_to_conic","z0","conic_to_s","s_to_v","s_to_v_truncated","to_group","include","on_conic","on_s","on_v","conic_gen","symbol$211","unsafe_set_uint8","make_alphabet","emap","dmap","default_alphabet","unsafe_set_be_uint16","error_msgf","encode_exn","alphabet$0","emap$0","emit","decode$0","invalid_pad_overflow","get_uint8_or_padding","dmap$0","only_padding","idx$0","wrap$3","non_residue","sqrt_flagged","x2_is_first","x3_is_first","to_group$0","append$6","field_elements","to_input","packeds","packed","xn","pack_to_fields","acc_n","packed_bits","append$7","field_elements$0","bitstring","pack_bits","max_size","bitstrings","field_bits","rev_fields","remaining_length","remaining_bits","packed_field_elements","pack_to_fields$0","return$25","bind$24","map$70","run$6","u8","u32","many$0","exactly","t_036","t_035","t_037","bits_of_byte","string_of_field","field_of_string","gen_field","gen_input","middle","serialized","len_to_string","u8x32","parser","normalized","v_bitstrings","v_field_elements","a_069","b_070","a_015","b_016","bools_equal","bitstring_bits","input_field","packed_fields","final_field_idx","input_bitstrings$3","input_bitstrings","packed_fields$0","packed_fields$1","packed_field","bp","input_bitstrings$0","input_bitstring","bi","packed_fields$2","input_bitstrings$1","packed_fields$3","input_bitstrings$2","of_vector_unsafe","group$96","bin_shape_t$99","bin_write_t$50","bin_read_t$86","t_of_sexp$82","sexp_of_t$91","hash_fold_proofs_verified","path$4","to_int$8","of_int$10","to_input$0","to_input$1","one_hot","typ$10","group$97","bin_shape_t$100","path$5","group$98","bin_shape_t$101","bin_read_t$87","group$99","bin_shape_t$102","bin_size_t$49","bin_write_t$51","bin_read_t$88","group$100","bin_shape_t$103","group$101","bin_shape_t$104","t_of_sexp$83","sexp_of_t$92","compare$109","hash_fold_t$55","hash$49","path$6","equal$62","group$102","bin_shape_t$105","path$7","h$1","to_bits$0","to_yojson$18","symbol$212","of_yojson$13","yojson","to_hex$3","of_hex","sexp_of_t$93","t_of_sexp$84","group$103","bin_shape_t$106","path$8","n_expected","of_tick_field","of_tock_field","to_tick_field","to_tock_field","of_bits_msb","v_proofs_verified","v_domain_log2","domain_log2","proofs_verified","proofs_verified_field","domain_log2_field","domain_log2_value","proofs_verified_value","proofs_verified_mask","four","packed_typ","y7","y6","y5","y4","assert_16_bits","group$104","bin_shape_t$107","challenge","bin_size_t$50","size_of_challenge","bin_write_t$52","write_challenge","bin_read_t$89","of_challenge","v_prechallenge","to_yojson$19","poly_challenge","of_yojson$14","t_of_sexp$85","prechallenge_field","prechallenge_value","sexp_of_t$94","compare$110","cmp_challenge","hash_fold_t$56","hash_fold_challenge","equal$63","prechallenge","typ$11","chal","to_yojson$20","symbol$213","group$105","digest$0","size_of_digest","write_digest","bin_writer_t$42","bin_read_t$90","of_digest","bin_reader_t$42","bin_t$42","version$11","versioned$1","compare$111","of_digest$0","of_digest$1","hash_fold_digest","hash$50","equal$64","path$9","to_bits_unboolean","pack$0","t_constant_opt","spec$0","t_constant_opt$0","spec$1","t_constant_opt$1","spec$2","t_constant_opt$2","spec$3","spec$4","t_const","spec$5","tl_constant_opt","hd_constant_opt","hd$1","dummy2","dummy1","t_constant_opt$3","t_constant_opt$4","b_constant_opt","x_constant_opt","dummy2$0","dummy1$0","inner$0","t_constant_opt$5","t_constant_opt$6","spec$6","t_constant_opt$7","typ$12","flag$0","assert_eq","constant_var","etyp","f_inv","f_inv$0","f_inv$1","f1_inv","f2_inv","f_bool","f_bool$0","f_a","f_a$0","opt_map","f_inv$2","f_inv$3","typ$5","pack$1","typ$13","etyp$0","bp_challenge","group$106","to_hlist$13","of_hlist$13","to_struct","of_struct","to_hlist$14","zeta_to_domain_size","zeta_to_srs_length","of_hlist$14","to_minimal","group$107","to_hlist$15","branch_data","bulletproof_challenges","combined_inner_product","plonk","of_hlist$15","group$108","map_challenges","scalar","typ$14","dummy_scalar","dummy_scalar_challenge","scalar_challenge$0","rot$0","xor$0","foreign_field_mul$0","range_check1$0","range_check0$0","constant_typ","bool_typ_of_flag","group$109","bin_shape_t$108","bin_size_t$51","size_of_g1","size_of_bulletproof_challenges","bin_write_t$53","write_g1","write_bulletproof_challenges","bin_read_t$91","of_g1","of_bulletproof_challenges","v_old_bulletproof_challenges","to_hlist$16","old_bulletproof_challenges","of_hlist$16","to_field_elements","g1_to_field_elements","group$110","to_hlist$17","messages_for_next_wrap_proof","sponge_digest_before_evaluatio","deferred_values","of_hlist$17","bulletproof_challenges$0","bool$2","fp$0","scalar_challenge$1","challenge$0","group$111","to_field_elements_without_inde","app_state_to_field_elements","app_state","bp_chals","digest$1","fp$1","scalar_challenge$2","plonk$0","bp_chals$0","digest$2","messages_for_next_wrap_proof$0","bool$3","fp$2","scalar_challenge$3","challenge$1","group$112","f8","f7","f6","f5","maybe_constant","feature_flags_spec","use","to_data$0","option_map","to_opt","messages_for_next_step_proof","of_data$1","of_opt","feature_flags$0","to_minimal$0","proof_state","to_wrap","opt_none","of_wrap","assert_none","assert_false","map_challenges$0","bp_log2","to_data$1","should_finalize","of_data$2","typ$15","to_hlist$18","unfinalized_proofs","of_hlist$18","to_data$2","of_data$3","per_proof","hash_fold_t$57","hash$51","compare$112","t_of_sexp$86","sexp_of_t$95","hash_fold_t$58","hash$52","compare$113","t_of_sexp$87","sexp_of_t$96","equal$65","rhs0$0","lhs0$0","rhs0$1","lhs0$1","rhs0$2","lhs0$2","rhs0$3","lhs0$3","hash_fold_t$59","a0$1","a0$2","a0$3","hash$53","compare$114","t_of_sexp$88","sexp_of_t$97","if_feature","unnormalized_lagrange_basis","vanishes_on_last_4_rows","endo_coefficient","alpha_pow","x_0","x_1","x_2","x_3","x_4","x_5","x_6","x_7","x_8","x_9","x_10","x_11","x_12","x_13","x_14","x_15","x_15$0","x_16","x_15$1","x_16$0","x_17","x_18","x_18$0","x_19","x_18$1","x_19$0","x_20","x_21","x_21$0","x_22","x_21$1","x_22$0","x_23","x_24","x_24$0","x_25","x_24$1","x_25$0","x_26","x_27","x_27$0","x_28","x_27$1","x_28$0","x_29","x_30","x_31","x_32","x_33","x_34","x_35","x_36","x_37","x_38","x_39","x_40","x_41","x_42","x_43","x_44","x_45","x_46","x_47","x_48","constant_term$0","index_terms$0","pow2pow","shifts$0","zetaw","rounds","expand_feature_flags","features","lookup_pattern_range_check","lookup_pattern_xor","table_width_at_least_2","table_width_at_least_1","all_feature_flags","endo","field_of_hex","srs_length_log2","get_eval","zk_polynomial","zeta_to_n_minus_1","feature","w_to_i","perm_alpha0","ft_eval0","p_eval0","e0_s","zkp","zeta1m1","w_n","ft_eval0$0","ft_eval0$1","nominator","ft_eval0$2","derive_plonk","w0$0","joint_combiner$0","seal","choose","shifted_pow","crs_max_degree","deg","num_shifts","log2s","all_shifts","other_shiftss","all_the_same","which","to_domain","log2_sizes","generator$0","max_log2","mina_alphabet","version_byte","version_byte$0","version_byte$1","version_byte$2","version_byte$3","version_byte$4","version_byte$5","version_byte$6","version_byte$7","version_byte$8","version_byte$9","version_byte$10","version_byte$11","version_byte$12","version_byte$13","version_byte$14","version_byte$15","version_byte$16","version_byte$17","checksum_len","version_string","compute_checksum","ctx0","ctx1","ctx2","first_hash","ctx3","second_hash","checksum","decode_exn","decoded","error_str","test_roundtrip","encoded","payload$0","last_ch","new_last_ch","encoded_bad_checksum","check_encoding","to_base58_check","of_base58_check","of_base58_check_exn","to_base64","of_base64","b64","rev_events","log_func","apply_args","ay","ax","x_squared","x_squared$0","ay$0","lambda$0","ax$0","bx","bx$0","by","cx","cx$0","cy","assert_on_curve","typ_unchecked$0","ey","ex","unshift_nonzero","bs0","S","bs0$0","add_pt","windows","g3","pow2s","group_map","unrelated_base","div_unsafe","add_unsafe","lookup_point","b0_and_b1","lookup_one","pc","bs$1","windows_required","bit_pair","with_shifts","unshift","multiscale_known","scale_known","conditional_negation","p_plus_q_plus_p","lambda_1","lambda_2","scale_fast","scale_constant","bs$2","message$4","message$5","comparator$5","compare$115","to_yojson$21","of_yojson$15","sexp_of_t$98","t_of_sexp$89","compare$116","sexpifier$0","v_identifier","v_type","compare$117","to_int","compare$118","t_of_sexp$90","previous_state_hash_field","previous_length_field","previous_global_slot_field","previous_global_slot_value","previous_length_value","previous_state_hash_value","sexp_of_t$99","v_previous_global_slot","v_previous_length","v_previous_state_hash","compare$119","sexpifier$1","v_fork","v_account_creation_fee","v_supercharged_coinbase_factor","v_coinbase_amount","v_pending_coinbase_depth","v_transaction_capacity","v_block_window_duration_ms","v_work_delay","v_ledger_depth","v_sub_windows_per_window","compare$120","header_version","to_yojson$22","compare$121","prefix_len","parse_lexbuf","yojson_parsebuffer","read_prefix","valid_header","valid_header_string","valid_header_with_prefix","fake_prefix","partial_prefix","from_string","initial_prefix_len","write_with_header","expected_max_size_log2","append_data","header_string","length_offset","length_string","length_data_offset","out_channel","true_length","true_length_string","true_length_padding","read_with_header","read_data","file_length","header_json","sexp_to_yojson","info_internal_repr_to_yojson","info$5","info$0","tag$0","info$1","tag$1","infos","trunc_after$0","acc_len","infos$0","rev_json_infos","infos$2","info$3","json_info$0","acc_infos$0","acc_len$1","infos$1","info$2","json_info","acc_infos","acc_len$0","length$2","trunc_after$1","json_infos","info$4","base_pairs","trunc_after","json$0","tag_to_json","jsons","jsons$0","group$113","bin_shape_t$109","path$10","group$114","bin_shape_t$110","path$11","group$115","bin_shape_t$111","path$12","compare$122","a_285","b_286","t_042","t_044","t_043","t_046","t_045","t_048","t_047","t_052","t_051","t_054","t_053","a_171","b_172","t_174","t_173","t_176","t_175","a_177","b_178","t_180","t_179","t_182","t_181","t_184","t_183","t_186","t_185","a_187","b_188","t_190","t_189","t_192","t_191","t_194","t_193","t_196","t_195","t_198","t_197","t_200","t_199","t_202","t_201","t_204","t_203","t_206","t_205","t_208","t_207","t_210","t_209","t_212","t_211","t_214","t_213","t_216","t_215","a_293","b_294","a_287","b_288","t_290","t_289","t_292","t_291","a_279","b_280","t_282","t_281","t_284","t_283","sexp_of_t$100","v_bulletproof","v_evaluations","v_commitments","v1$11","v1$12","v1$13","v1$14","to_kimchi_proof","bulletproof","evaluations","of_kimchi_proof","debug$1","absorb_field","absorb_scalar","mask_g1_opt","absorb$0","absorb$1","ones_vector","first_zero","lowest_128_bits","constrain_low_bits","assert_128_bits","num_bits$7","to_field_checked","bits_msb","nybbles_per_row","rows","nybbles_by_row","to_field_checked$0","to_field_constant","r_2i1","test$0","seal$0","rounds_rev","n_acc_prev","xq1","yq1","s1_squared","xq2","yq2","s3_squared","random_point","endo_inv","gy","gx","endo_to_field","base$0","scalar$0","endo_to_field$0","forbidden_shifted_values","two_to_n","neg_two_to_n","representatives","generate$0","keypair","other_mod","f$14","forbidden_shifted_values$0","high$0","check$5","x_eq","b_eq","typ$16","wrap_rounds","other_mod$0","f$15","forbidden_shifted_values$1","typ$17","t0$0","check$7","typ_unchecked$1","typ$18","input$1","high_entropy_bits","to_the_alpha","add_assign","apply_affine_map","constants","matrix","dotv","copy$0","underlying","last_squeezed","squeeze_field","params$3","step_log2","step","mk$24","tock_shifts","tick_shifts","wrap_domains","hash_messages_for_next_step_pr","app_state$0","dlog_plonk_index","dlog_pcs_batch","when_profiling","profiling","tock2","tick_zero","zero$10","finite_exn","or_infinite_conv","compute_challenge","compute_challenges","field$2","compute_challenge$0","compute_challenges$0","compute_sg","field$3","compute_challenge$1","compute_challenges$1","tock_unpadded_public_input_of_","prev_statement","tick_public_input_of_statement","max_proofs_verified","ft_comm","sigma_comm_last","f_comm","chunked_t_comm","combined_evaluation","fx$0","fx$1","of_sponge","add_in","i_equals_0","i_equals_j","cond_permute","permute","permuted","add_in_y_after_perm","add_in_y_before_perm","empty_imput","should_permute","n_pre","filtered","pre$0","filtered_res","opt_res","custom_printf_006","custom_printf_007","custom_printf_008","add_fast","check_finite","p1$0","p2$0","same_x_bool","x1_squared","y1$0","add_fast$0","bits_per_chunk","chunks_needed","scale_fast_msb_bits","y_base","x_base","y_acc","x_acc","x_res","y_res","slopes","accs$0","scale_fast_unpack","scale_fast2","s_odd","s_div_2","s_div_2_bits","chunks_needed$0","actual_bits_used","bits_lsb","scale_fast2$0","Scalar_field","s_parts","custom_printf_005","create$80","create$81","hash$54","ro","tock","tick","scalar_chal","evals_combined","dummy_chals","challenges_computed","challenges_computed$0","group$116","bin_shape_t$112","bpcs","bin_size_t$52","size_of_s","size_of_challenge_polynomial_c","size_of_bpcs","bin_write_t$54","write_s","write_challenge_polynomial_com","write_bpcs","bin_read_t$92","of_s","of_challenge_polynomial_commit","of_bpcs","v_app_state","prepare","group$117","bin_shape_t$113","bin_read_t$93","path$13","t_of_sexp$91","sexp_of_t$101","hash_fold_t$60","f$16","sponge_params_constant","read_step_circuit_field_elemen","prover_fe","sponge_params","one$10","group_size_in_bits","constant$4","typ$19","scale$2","inv_exn","symbol$214","symbol$215","symbol$216","negate$2","inv_exn$0","symbol$217","symbol$218","symbol$219","equal$66","t_of_sexp$92","sexp_of_t$102","scale$3","zero$11","symbol$220","negate$3","to_affine_exn$1","of_affine$1","typ$20","typ_unchecked$2","constant$5","symbol$221","double$3","scale$4","to_field_elements$0","scale_inv","negate$4","one$11","if$3","h$2","max$25","hash_fold_vk","group$118","bin_shape_t$114","bin_size_t$53","bin_write_t$55","bin_read_t$94","bin_read_t$95","v_max_proofs_verified","v_actual_wrap_domain_size","v_wrap_index","path$14","versioned$2","func$15","to_repr","wrap_index","actual_wrap_domain_size","of_repr","public$0","wrap_vk","max_proofs_verified_field","actual_wrap_domain_size_field","wrap_index_field","wrap_index_value","actual_wrap_domain_size_value","max_proofs_verified_value","cmp_comm","to_binable$10","of_binable$12","bin_size_t$54","bin_write_t$56","bin_read_t$96","bin_read_t$97","bin_shape_t$115","bin_writer_t$43","bin_reader_t$43","bin_t$43","path$15","g$1","to_hlist$19","of_hlist$19","to_input$2","max_proofs_verified$0","actual_wrap_domain_size$0","bp_chals$1","messages_for_next_wrap_proof$1","fp$3","scalar_challenge$4","challenge$2","group$119","bin_shape_t$116","bin_size_t$55","size_of_messages_for_next_wrap","size_of_messages_for_next_step","v3$6","v2$18","v1$18","size$45","size_of_scalar_challenge","v2$6","v3$2","v2$5","v3$1","v2$4","v6$0","v5$0","v4$0","v2$3","size$46","size_of_f_multi$0","size_of_f_multi","size$47","v4$2","v3$5","v2$17","v1$17","v3$3","v2$7","size$41","v2$8","size$23","size$42","v8$0","v7$0","v6$1","v5$1","v4$1","v3$4","v2$9","size$24","size$25","size$26","v2$10","size$27","size$28","size$29","v2$11","size$30","size$31","v2$12","size$32","size$33","v2$13","size$34","size$35","v2$14","size$36","size$37","v2$15","v1$15","size$38","size$39","v2$16","v1$16","size$40","size$43","size$44","bin_write_t$57","write_messages_for_next_wrap_p","write_messages_for_next_step_p","write_scalar_challenge","write_f_multi$0","write_f_multi","bin_read_t$98","of_messages_for_next_wrap_proo","of_messages_for_next_step_proo","bin_read_t$99","of_scalar_challenge","v_alpha","v_beta","v_gamma","v_zeta","v_joint_combiner","v_range_check0","v_range_check1","v_foreign_field_add","v_foreign_field_mul","v_xor","v_rot","v_runtime_tables","v_feature_flags","v_plonk","v_bulletproof_challenges","v_branch_data","v_deferred_values","v_sponge_digest_before_evaluat","v_messages_for_next_wrap_proof","v_proof_state","v_messages_for_next_step_proof","v_statement","v_prev_evals","v_ft_eval1$0","most_recent_width","g0","tick_arr","lengths","fields$85","fields$76","fields$38","fields$39","fields$40","fields$41","fields$42","fields$77","fields$78","fields$66","fields$67","arg1$3","arg0$3","fields$68","arg1$4","arg0$4","fields$69","arg1$5","arg0$5","fields$70","arg1$6","arg0$6","fields$71","fields$72","arg1$7","arg0$7","fields$73","fields$74","fields$75","fields$79","fields$62","fields$63","fields$64","fields$65","fields$80","fields$86","poly_f_multi$0","fields$36","poly_f_multi","fields$33","fields$25","fields$26","fields$27","fields$28","fields$29","fields$30","fields$31","fields$32","fields$34","fields$35","fields$37","fields$87","poly_bool","poly_scalar_challenge","fields$59","fields$81","fields$82","fields$83","fields$84","fields$60","fields$55","fields$52","fields$53","fields$54","fields$56","fields$57","fields$49","fields$50","fields$43","fields$44","fields$45","fields$46","fields$47","fields$48","fields$51","fields$58","fields$61","fields$88","xs$69","xs$70","state$67","arg2$7","arg1$13","arg0$13","xs$71","x$42","xs$48","xs$49","arg1$8","arg0$8","xs$51","x$31","xs$64","xs$65","arg2$6","arg1$12","arg0$12","xs$68","x$41","state$66","xs$67","x$40","xs$66","x$39","xs$50","x$30","xs$43","xs$44","state$47","arg2$3","xs$47","x$29","xs$34","xs$35","arg2$2","xs$38","x$24","xs$37","xs$36","xs$26","xs$27","arg5$0","arg4$1","arg3$1","xs$33","xs$32","xs$31","xs$30","xs$29","xs$28","xs$46","x$28","xs$39","xs$40","xs$42","x$26","state$46","xs$41","x$25","xs$45","x$27","state$68","xs$72","x$43","xs$58","xs$59","arg3$2","arg2$5","arg1$11","arg0$11","xs$63","x$38","state$27","arg4$0","arg3$0","xs$62","x$37","xs$52","xs$53","arg2$4","arg1$9","arg0$9","xs$56","x$34","xs$55","x$33","xs$54","x$32","arg1$10","arg0$10","xs$61","x$36","xs$57","xs$60","x$35","state$69","xs$73","x$44","poly_f_multi$1","state$70","a_157","b_158","n$43","n$40","n$39","cmp_scalar_challenge","n$38","n$33","n$34","n$35","n$36","n$37","n$41","a_111","b_112","n$42","n$47","n$46","a_173","b_174","n$45","a_179","b_180","a_181","b_182","a_183","b_184","cmp_f_multi","a_117","b_118","a_119","b_120","a_115","b_116","n$44","t_238","t_237","t_240","t_239","a_241","b_242","t_244","t_243","t_246","t_245","a_113","b_114","a_121","b_122","a_123","b_124","a_125","b_126","a_127","b_128","a_129","b_130","a_131","b_132","a_133","b_134","a_135","b_136","a_137","b_138","a_139","b_140","a_141","b_142","a_143","b_144","a_145","b_146","a_147","b_148","statement_field","prev_evals_field","sexp$6","of_bp_chals","of_scalar_challenge$0","proof_state_field","messages_for_next_step_proof_f","deferred_values_field","messages_for_next_wrap_proof_f","old_bulletproof_challenges_fie","old_bulletproof_challenges_val","plonk_field","bulletproof_challenges_field","branch_data_field","alpha_field","beta_field","gamma_field","zeta_field","joint_combiner_field","feature_flags_field","feature_flags_value","joint_combiner_value","zeta_value","gamma_value","beta_value","alpha_value","branch_data_value","bulletproof_challenges_value","plonk_value","messages_for_next_wrap_proof_v","sponge_digest_before_evaluatio$0","deferred_values_value","sexp$5","app_state_field","challenge_polynomial_commitmen$1","old_bulletproof_challenges_fie$0","old_bulletproof_challenges_val$0","challenge_polynomial_commitmen$2","app_state_value","messages_for_next_step_proof_v","proof_state_value","sexp$7","commitments_field","evaluations_field","ft_eval1_field$0","bulletproof_field","bulletproof_value","ft_eval1_value$0","evaluations_value","commitments_value","sexp$8","of_f_multi$2","evals_field$0","of_f_multi$1","public_input_field","public_input_value","evals_value$0","prev_evals_value","statement_value","v_old_bulletproof_challenges$0","v_challenge_polynomial_commitm$0","hsv$71","hash_fold_scalar_challenge","hsv$39","hsv$40","hsv$41","hsv$42","hsv$43","hsv$70","hsv$44","hsv$46","hsv$45","hsv$74","hsv$69","hsv$73","hsv$72","hash_fold_f_multi$0","hash_fold_f_multi","hsv$34","hsv$47","e0$0","hsv$48","hsv$49","hsv$50","hsv$51","hsv$52","e0$1","hsv$53","hsv$54","hsv$55","e0$2","hsv$56","hsv$57","e1$3","e0$3","hsv$58","hsv$59","e1$4","e0$4","hsv$60","hsv$61","e1$5","e0$5","hsv$62","hsv$63","e1$6","e0$6","hsv$64","hsv$65","e1$7","e0$7","hsv$66","hsv$67","hsv$68","hsv$35","hsv$36","hsv$37","hsv$38","a_185","b_186","a_201","b_202","a_205","b_206","a_207","b_208","a_209","b_210","a_211","b_212","a_153","b_154","a_155","b_156","a_151","b_152","t_252","t_251","t_254","t_253","a_255","b_256","t_258","t_257","t_260","t_259","a_159","b_160","a_161","b_162","a_163","b_164","a_165","b_166","a_167","b_168","a_169","b_170","a_175","b_176","t_060","t_059","t_062","t_061","t_064","t_063","t_066","t_065","t_070","t_069","t_072","t_071","a_219","b_220","t_222","t_221","t_224","t_223","a_225","b_226","t_228","t_227","t_230","t_229","t_232","t_231","t_234","t_233","a_235","b_236","t_242","t_241","t_248","t_247","t_250","t_249","t_252$0","t_251$0","t_254$0","t_253$0","t_256","t_255","t_262","t_261","t_264","t_263","a_303","b_304","t_300","t_299","to_yojson_full","group$120","bin_shape_t$117","bin_size_t$56","bin_write_t$58","bin_read_t$100","bin_read_t$101","path$16","of_yojson$16","to_yojson$23","sexp_of_t$104","t_of_sexp$94","hash$56","hash_fold_t$62","equal$68","compare$124","of_repr$0","to_repr$0","versioned$3","path$17","of_yojson$17","to_yojson$24","to_yojson_full$0","sexp_of_t$105","t_of_sexp$95","hash$57","hash_fold_t$63","equal$69","compare$125","group$121","bin_shape_t$118","bin_size_t$57","bin_write_t$59","bin_read_t$102","bin_read_t$103","path$18","of_yojson$18","to_yojson$25","sexp_of_t$106","t_of_sexp$96","hash$58","hash_fold_t$64","equal$70","compare$126","of_repr$1","to_repr$1","versioned$4","path$19","params$4","sponge_params_constant$0","read_wrap_circuit_field_elemen","sponge_params$0","squeeze_field$0","one$12","group_size_in_bits$0","constant$6","typ$22","if$4","scale$5","inv_exn$1","symbol$222","symbol$223","symbol$224","negate$5","negate$6","square$3","inv_exn$2","symbol$225","symbol$226","symbol$227","assert_square$2","assert_r1cs$2","equal$72","t_of_sexp$98","sexp_of_t$108","scale$6","random$2","zero$12","symbol$228","negate$7","to_affine_exn$2","of_affine$2","multiscale_known$0","typ$23","typ_unchecked$3","constant$7","symbol$229","double$4","scale$7","to_field_elements$1","scale_inv$0","negate$8","g$2","if$5","h$3","pad_vector","pad_challenges","chalss","pad_accumulator","hash_messages_for_next_wrap_pr","of_proof","dummy_messages_for_next_wrap_p","full_state","s0","hash_messages_for_next_wrap_pr$0","challenge_polynomial","num_possible_domains","all_possible_domains","to_bits_unsafe","absorb_shifted","absorb_shifted$0","print_g","print_w","print_chal","print_bool","scalar_to_field","assert_n_bits","lowest_128_bits$0","squeeze_challenge","squeeze_scalar","bullet_reduce","gammas","prechallenges","gammas_i","term_and_challenge","left_term","right_term","equal_g","choose_key","lagrange","which_branch","scaled_lagrange","lagrange_with_correction","base_and_correction","pr","h_precomp","finite","batch","without_bound","with_bound","keep","point","check_bulletproof","pcs_batch","advice","combined_polynomial","scale_fast$0","lr_prod","uc","p_prime","cq","b_u","z_1_g_plus_b_u","z2_h","absorb$2","iter2","zeta_1","gamma_1","beta_1","alpha_1","zeta_0","gamma_0","beta_0","alpha_0","assert_eq_plonk","incrementally_verify_proof","Max_proofs_verified","actual_proofs_verified_mask","step_domains","sg_old","openings_proof","sg_old$0","sample","sample_scalar","index_sponge","index_digest","without","absorb_g","public_input$0","non_constant_part","constant_part","corr","correction","x_hat","x_hat$0","sponge$0","sponge_before_evaluations","sigma_comm_init","ft_comm$0","mask_evals","challenge_polynomial$0","actual_evaluation","pt_to_n","pt_n_acc","shift1","shift2","map_plonk_to_field","finalize_other_proof","Proofs_verified","sg_olds","sg_evals","sg_evals2","sg_evals1","challenge_digest","sponge_state_before","state_before","xi_actual","r_actual","xi_actual$0","xi$0","xi_correct","plonk_minimal","zeta_n","zetaw_n","combined_evals","evals2","ft","sg_evals$0","actual_combined_inner_product","combined_inner_product_correct","challenge_poly","b_actual","b_correct","plonk_checks_passed","to_hlist$20","of_hlist$20","to_hlist$21","of_hlist$21","shift$0","typ$24","create$84","find$17","lookup_compiled","other_id","lookup_side_loaded","lookup_basic","wrap_domains$0","wrap_vk$1","wrap_key$0","ephemeral","wrap_key","wrap_vk$0","set_ephemeral","eph","prover","add_exn$4","print_fp","add_opt","constant_part$0","rr$0","xi_acc","p_is_finite","acc_is_finite","xi_acc$0","p_is_finite$0","is_finite","xi_acc$1","assert_eq_deferred_values","lagrange_commitment","public_input_commitment_dynami","lagrange_commitment$0","select_curve_points","points_for_domain","points","sponge_after_index","receive","domain$0","z_comm$0","t_comm$0","vanishing_polynomial","should_square","side_loaded_domain","max_n","vanishing_polynomial$0","d_unchecked","a_002","b_003","pow2_pow","squeeze_challenge$0","domain_for_compiled","unique_domains","which_log2","actual_width_mask","opt_sponge","a_008","b_009","a_010","b_011","a_006","b_007","xi$1","b_used","state_to_field_elements","after_index","hash_messages_for_next_step_pr$0","not_opt","hash_inputs","sponge$1","accumulation_verifier","accumulator_verification_key","prev_accumulators","new_accumulator","is_base_case","lookup_parameters","wrap_domain","wrap_verification_key","statement","unfinalized","bulletproof_challenges_actual","bulletproof_success","to_hlist$22","prev_challenge_polynomial_comm","prev_proof_evals","wrap_proof","of_hlist$22","to_hlist$23","of_hlist$23","shift$1","dummy$1","one_chal","typ$25","dummy$2","create$85","r$4","start$3","clock","is_odd","wrap_main","full_signature","pi_branches","step_keys","step_widths","Req","Max_widths_by_slot","messages_for_next_wrap_proof_d","which_branch$0","prev_proof_state","step_plonk_index","prev_step_accs","old_bp_chals","new_bulletproof_challenges","wrap_domain_indices","old_bulletproof_challenges$0","old_bulletproof_challenges$1","finalized","prev_messages_for_next_wrap_pr","sacc","max_local_max_proofs_verified","rough_domains","domains$0","ret_conv_inv","main$0","group$122","bin_shape_t$119","path$20","group$123","bin_shape_t$120","bin_size_t$58","bin_write_t$60","bin_read_t$104","bin_read_t$105","v_constraints","v_data","path$21","poly_polyComm","versioned$5","of_repr$2","to_binable$11","of_binable$13","path$22","f_debug","num_choices","choices_length","num_choices$0","dummy_step_domains","dummy_step_widths","dummy_step_keys","constant_term$1","index_terms$1","tick_rounds","AB","challenge_polys","which_eval","sgs","step_vk","actual_proofs_verified","tick_plonk_minimal","tick_combined_evals","tick_domain","tick_env","prechals","shift_value","compute_feature_flags","true_opt","false_opt","test_feature_flags_configs","runtest","deferred_values$0","x_hat_evals","deferred_values_typ","deferred_values$1","no_public_input","gate_example","public_input_1","public_input_2","public_input2","public_input1","example","actual_feature_flags$0","expand_deferred","tick_field","sc","plonk0","step_domain","w$0","challenges_digest","lookup_final_terms","xi_chal","r_chal","combined_inner_product_actual","to_shifted","verify_heterogenous","non_chunking","least_wrap_domain","actual_wrap_domain","accumulator_check","batch_verify_inputs","A_value","prepared_statement","dlog_check","comm_chals","verify_promise","a_value","create$86","proofs_verifieds","auxiliary_typ","var_to_field_elements","value_to_field_elements","rule","self_width","extract_lengths","len_ms","len_ns","branches$0","local_branches_length","local_signature_length","heights","widths","requests","output_typ","ld$0","ds$0","ns1","ns2","ln1","ln2","feature_flagss","feature_flagss$0","ln2$0","ln1$0","ns2$0","ns1$0","prev_proof_typs","output_typ$0","input_typ$0","auxiliary_var","ret_var","previous_proof_statements","ret_value","auxiliary_value","previous_proof_statement","tags$0","stmts","proof_must_verify","public_input$1","previous_proof_statements$0","prevs","unfinalized_proofs_unextended","actual_wrap_domains","stmts$0","stmt","proofs$0","prevs$0","datas","messages_for_next_wrap_proofs","unfinalizeds","actual_wrap_domains$0","should_verify","unfinalizeds$0","messages_for_next_wrap_proofs$0","datas$0","actual_wrap_domain$0","actual_wrap_domain$1","sponge_digest","prev_messages_for_next_step_pr","verified","self_data","own_domains","next_state","Maxes","prevs_length","self_dlog_plonk_index","self_dlog_vk","prev_vars_length","prev_values_length","expand_proof","dlog_vk","dlog_index","must_verify","Local_max_proofs_verified","deferred_values_computed","x_hat_1","zeta$0","alpha$0","zetaw$0","tock_domain","tock_combined_evals","tock_plonk_minimal","true$1","false$1","tock_env","b_polys","ft_eval","shifted_value","statements_with_hashes","x_hats","witnesses","prev_proofs","return_value","unfinalized_proofs$0","unfinalized_proofs_extended","extract_from_proofs","Extract","return_value$0","messages_for_next_step_proof_p","messages_for_next_wrap_proof_p","respond","prev_proof_requests","prev_proof_stmts","prev_proof_stmts$0","ws","prev_proofs$0","witnesses$0","x_hats$0","statements_with_hashes$0","unfinalized_proofs$1","domain_index","to_fold_in","next_proof","prev_evals","next_statement","conv_inv","promise_or_error","next_statement_hashed","auxiliary_inputs","to_string$44","to_string$45","s_p","header_read","s_v","read_or_generate","k_p","k_v","dirty","k_v$0","pk$0","vk$0","header_version_field","constraint_constants_field","commits_field","length_field","commit_date_field","constraint_system_hash_field","identifying_hash_field","type_field","identifier_field","identifier_value","type_value","sub_windows_per_window_field","ledger_depth_field","work_delay_field","block_window_duration_ms_field","transaction_capacity_field","pending_coinbase_depth_field","coinbase_amount_field","supercharged_coinbase_factor_f","account_creation_fee_field","fork_field","fork_value","account_creation_fee_value","supercharged_coinbase_factor_v","coinbase_amount_value","pending_coinbase_depth_value","transaction_capacity_value","block_window_duration_ms_value","work_delay_value","ledger_depth_value","sub_windows_per_window_value","mina_field","marlin_field","marlin_value","mina_value","identifying_hash_value","constraint_system_hash_value","commit_date_value","length_value","commits_value","constraint_constants_value","header_version_value","v_identifying_hash","v_constraint_system_hash","v_commit_date","v_commits","v_constraint_constants","v_header_version","v_marlin","v_mina","t_022","t_020","to_string$46","to_string$47","s_p$0","read_or_generate$0","kp","vk$1","symbol$230","generate_or_load","pad_messages_for_next_wrap_pro","messages_len","maxes_len","maxes$0","maxes$1","compile_with_wrap_main_overrid","disk_keys$0","override_wrap_domain","override_wrap_main","Branches","constraint_constants","self$0","self$1","a_value_to_fields","a_var_to_fields","a_value_to_fields$0","a_var_to_fields$0","conv_irs","snark_keys_header","constraint_system_hash","prev_varss_length","prev_varss_n","padded","enabled","step_data","cache_handle","accum_dirty","disk_keys","cs_hash","ks","step_keypairs","step_vks","wrap_main$0","wrap_main$1","wrap_requests","self_id","disk_key_prover","wrap_disk_key","wrap_pk","computed_domain_size","ks$0","step_pk","step_vk$0","proof$0","which_index","tweak_statement","tweak_statement$0","prev_statement_with_hashes","next_statement$0","next_accumulator","provers","cache_handle$0","verify_promise$0","wrap_main_dummy_override","dummy_id","write","of_compiled","in_circuit","permanent","verify$0","srs_precomputation","compile_promise","return_early_digest_exception","compile","proof_module","adjust_provers","dummy_constraints","b0$0","example$0","prev_input","self_correct","s_neg_one","b_neg_one","b0$1","recursion_proof","recursion_input","no_recursion_proof","no_recursion_input","no_recursive_input","no_recursive_proof","prev_proof","s_neg_one$0","b_neg_one$0","b0$2","example2","example1","s_neg_one$1","b_neg_one$1","b0$3","example2$0","example1$0","b0$4","blinding_value","b0$5","dummy_proof","pairing_vk","tick_combined_evals$0","combined_inner_product$0","overwritten_prechals","chals$0","sg_new","proof_with_stmt","assocs","example_proof","example_input","example_proof$0","example_input$0","example_proof$1","example_input$1","side_loaded_tag","maybe_features","params$5","v_u","v_u_over_2","v_y","v_projection_point","v_conic_c","v_a","v_b","v_spec","group_map_params","arg_typ","gen_arg","sexp_of_arg","test1","test2","mul_field","real_part","x_over_y","let_syntax_016","let_syntax_017","let_syntax_018","let_syntax_012","let_syntax_013","let_syntax_014","let_syntax_015","if_value","cond","Shifted","sigma_count","two_to_the_i_plus_1","result_with_shift","let_syntax_021","let_syntax_022","let_syntax_019","let_syntax_020","func$16","length$27","get$17","set$13","length$28","get$18","set$14","bools","v_of_list","pack_value","var_of_bits","var_to_triples","unpack_var","var_of_field_unsafe","unpack_value","compare_var","increment_if_var","increment_var","equal_var","assert_equal_var","pack_int","boolean_assert_lte","assert_decreasing","nth_bit","apply_mask","pack_unsafe","n_ones","total_length","assert_num_bits_upper_bound","masked","size_in_bits_size_in_bits","num_bits_upper_bound_unchecked","leading_zeroes","num_bits_upper_bound_unpacked","x_unpacked","num_bits_upper_bound","decreasing","handle_with$0","handle_with","resp","correct","t_of_sexp$100","sexp_of_t$110","hash_fold_t$66","compare$128","t_of_sexp$101","sexp_of_t$111","bin_size_t$59","bin_write_t$61","bin_read_t$106","bin_read_t$107","empty$32","equal$74","typ$26","t_of_sexp$102","sexp_of_t$112","add$30","typ$27","negate$9","constant$10","if$8","double$5","scale$8","sum$4","make_checked$1","params$6","block_cipher$1","params$7","add_assign$1","copy$10","to_bits$1","update$5","hash$60","pow2$1","to_bits$2","params$8","hash$61","pack_input","pack_input$0","prefix_to_field","salt$1","params$9","rounds_full$0","initial_ark$0","rounds_partial$0","to_the_alpha$1","hash$62","pack_input$1","to_the_alpha$2","seal$1","add_assign$2","apply_affine_map$0","copy$11","params$10","padding_char","create$87","protocol_state","protocol_state_body","account","side_loaded_vk","zkapp_account","zkapp_payload","zkapp_body","merge_snark","base_snark","transition_system_snark","signature_testnet","signature_mainnet","signature_other","chain_name","receipt_chain_user_command","receipt_chain_zkapp","epoch_seed","vrf_message","vrf_output","vrf_evaluation","pending_coinbases","coinbase_stack_data","coinbase_stack_state_hash","coinbase_stack","coinbase","checkpoint_list","zkapp_precondition","zkapp_precondition_account","zkapp_precondition_protocol_st","account_update_account_precond","account_update","account_update_cons","account_update_node","account_update_stack_frame","account_update_stack_frame_con","zkapp_uri","zkapp_event","zkapp_events","zkapp_actions","zkapp_memo","zkapp_test","derive_token_id","salt$2","salt_legacy","cached","cached$0","signature_kind","crypto_hash_prefix","hash_prefix","hash_prefix$0","triple_string","test_to_triples","arbitrary_string","with_randomness","print_digest","check_serialization","known_good_digest","group$124","bin_shape_t$121","group$125","field$4","group$126","create$88","bin_read_t$108","v_x","v_is_odd","bin_size_t$60","bin_write_t$62","to_hlist$24","of_hlist$24","gen$2","group$127","bin_shape_t$122","path$23","version$12","group$128","bin_shape_typ","group$129","bin_shape_t$123","create$89","bin_read_t$109","bin_read_t$110","bin_reader_t$44","bin_size_t$61","bin_write_t$63","bin_writer_t$44","bin_t$44","group$130","size_of_pk","write_pk","bin_writer_t$45","bin_read_t$111","of_pk","bin_reader_t$45","bin_t$45","version$13","equal_key","compare_key$2","hash_fold_t$67","hash$63","to_yojson$28","of_yojson$20","of_pk$0","of_public_key","hash_fold_t$68","uncompressed","path$24","group$131","bin_shape_typ$0","group$132","public_key","create$90","bin_read_t$112","key_to_string","compress$1","empty$33","to_input$3","to_input_legacy","typ$28","var_of_t","equal$75","odd_eq","to_input$4","decompress","y_parity","decompress_exn","compare$129","t_026","t_025","t_028","t_027","hash_fold_t$69","of_yojson$21","compressed","to_yojson$29","sexp_of_t$114","t_of_sexp$104","path$25","group$133","bin_shape_t_tagged$0","create$91","bin_read_t$113","bin_size_t$62","bin_write_t$64","group$134","bin_shape_t$124","bin_size_t$63","bin_write_t$65","bin_writer_t$46","bin_read_t$114","bin_read_t$115","bin_reader_t$46","bin_t$46","compare$130","version$14","t_of_sexp$105","upperbound","path$26","group$135","bin_shape_typ$1","bin_size_typ","bin_write_typ","bin_read_typ","group$136","bin_shape_t_tagged$1","create$92","bin_read_t$116","bin_read_t$117","bin_reader_t$47","bin_size_t$64","bin_write_t$66","bin_writer_t$47","bin_t$47","is_even","derive","k_prime","r_pt","verifier","final_check","e_pk","s_g_e_pk","y_even","r_correct","verifies","assert_verifies","ry_even","network_id_mainnet","network_id_testnet","make_derive","network_id","private_key","network_id_mainnet$0","derive_for_mainnet","derive_for_testnet","make_hash","py","px","hash$64","hash_for_mainnet","hash_for_testnet","hash_checked","make_derive$0","derive$0","derive_for_mainnet$0","derive_for_testnet$0","make_hash$0","hash$65","hash_for_mainnet$0","hash_for_testnet$0","hash_checked$0","gen_legacy","gen_chunked","pubkey","const_typ","group$137","bin_shape_t$125","path$27","t_of_sexp$106","public_key_field","private_key_field","private_key_value","public_key_value","sexp_of_t$115","v_private_key","v_public_key","compare$131","pk2","pk1","of_private_key_exn","gen$3","t_of_sexp$107","sexp_of_t$116","compare$132","group$138","bin_shape_t$126","path$28","t_of_sexp$108","sexp_of_t$117","gen$4","to_field$3","typ$29","one_half","is_pos","constant$11","pos$67","if$9","to_yojson$30","poly_hash","poly_account","group$139","bin_size_t$65","size_of_hash","size_of_account","bin_write_t$67","write_hash","write_account","bin_read_t$118","of_account","arg_1$1","arg_2","arg_3","t_of_sexp$109","sexp_of_t$118","to_yojson$31","of_yojson$22","equal$76","cmp_hash","cmp_account","cmp_hash$0","cmp_account$0","a_021$0","b_022$0","cmp_account$2","cmp_account$1","cmp_hash$2","cmp_hash$1","t_of_sexp$110","sexp_of_t$119","hash$66","group$140","bin_shape_t$127","indexes_field","depth_field","tree_field","tree_value","depth_value","indexes_value","v_tree","v_depth","v_indexes","merkle_root","add_path","account_id","build_tree","h_r","h_l","path$1","find_index_exn","aid","custom_printf_043","custom_printf_044","acct","go_right","expected_kind","custom_printf_045","path_exn","v_favorite_number","name_field","favorite_number_field","favorite_number_value","name_value","data_hash","favorite_number","prune_hash_branches","let_syntax_055","hex_char_to_bits4","bits4_to_hex_char","bits_by_n","bitsn","bits_by_8s","of_unpackable","padding_bit","bytes$0","of_field$3","pack$2","bytes_rev","of_public_key_compressed","to_public_key_compressed","pk_compressed_roundtrip_test","hex_key","field0","transaction_dummy","field_key_attr","make_lident_cmp","dhall_type_of_core_type","Ast_builder","dhall_type_fun","mod_path","dhall_type_fun$0","nm$0","mod_path$0","dhall_variant_from_constructor","ctor_decl","tys_expr","dhall_field_from_label_declara","generate_dhall_type","dhall_type","ctor_decls","label_decls","ty_name","generate_dhall_types","type_decls","attributes$1","str_type_decl$1","group$141","bin_shape_t$128","group$142","bin_shape_typ$2","group$143","bin_shape_t$129","path$29","of_yojson$23","to_yojson$32","t_of_sexp$111","sexp_of_t$120","hash_fold_t$70","func$17","compare$133","equal$77","version$15","bin_size_t$66","bin_write_t$68","bin_read_t$119","bin_read_t$120","path$30","group$144","bin_shape_t_tagged$2","create$93","bin_read_typ$0","bin_read_typ$1","bin_size_typ$0","bin_write_typ$0","to_yojson$33","of_yojson$24","t_of_sexp$112","sexp_of_t$121","hash_fold_t$71","hash$67","hashable$3","add$31","sub$9","div$2","rem$8","max_value$3","logand$1","logor$1","logxor$1","shift_left$7","shift_right$7","of_int$11","to_int$9","of_ms$0","to_ms$0","of_string$45","to_string$48","zero$13","one$13","lognot$6","succ$9","pred$9","compare$134","equal$78","max$26","min$25","pp$28","symbol$231","symbol$232","symbol$233","symbol$234","symbol$235","to_uint64","of_uint64","group$145","bin_shape_t$130","group$146","bin_shape_typ$3","group$147","bin_shape_t$131","path$31","of_yojson$25","to_yojson$34","t_of_sexp$113","sexp_of_t$122","hash_fold_t$72","func$18","compare$135","equal$79","bin_size_t$67","bin_write_t$69","bin_read_t$121","bin_read_t$122","path$32","group$148","bin_shape_t_tagged$3","create$94","to_yojson$35","of_yojson$26","t_of_sexp$114","sexp_of_t$123","length_in_bits$0","hash_fold_t$73","hash$68","hashable$4","add$32","sub$10","div$3","rem$9","max_int$3","logand$2","logor$2","logxor$2","shift_left$8","shift_right$8","of_int$12","to_int$10","of_int64$3","to_int64$4","of_string$46","to_string$49","zero$14","one$14","lognot$7","succ$10","pred$10","compare$136","equal$80","max$27","min$26","pp$29","symbol$236","symbol$237","symbol$238","symbol$239","symbol$240","to_bigint$0","to_uint32","of_uint32","range_check","actual_packed","range_check$0","range_check_flag","field_typ","div_mod","is_succ","xy","yx","x_gte_y","y_gte_x","a_lte_b","succ_if","subtract_unpacking_or_zero","neg_res","underflow","sub_or_zero","group$1","read_version$0","max_value","u32_1","u32_2","zero$15","symbol$241","diff_or_zero","u32_slot","u32_span","u32_sum","diff$0","to_uint32$0","of_uint32$0","zero$16","equal$81","zero$17","succ$11","group$149","bin_shape_t$132","sgn","t_fields_annots","t_toplevel_annots","t_of_sexp$115","of_magnitude","of_sgn","magnitude_field","sgn_field","sgn_value","magnitude_value","sexp_of_t$124","v_sgn","v_magnitude","sgn$0","precision_exp","to_mina_string","whole","num$1","num_stripped_zeros","num$0","num_stripped_zeros$0","of_mina_string_exn","decimal","decimal_length","pack_var","var_to_bits$0","var_to_bits$1","var_to_input","var_to_input_legacy","modulus_as_field","double_modulus_as_field","range_check_flagged","adjustment_factor","out_of_range","t_adjusted","unit_to_nano","to_mina_int","sub_flagged","add_flagged","add_signed_flagged","u64","of_nanomina_int","of_mina_int","of_nanomina_int_exn","of_mina_int_exn","typ_to_hlist","typ_of_hlist","compare_magnitude","sgn_to_bool","to_input_legacy$0","add_flagged$0","of_unsigned","to_fee","of_fee","repr_typ","create_var","mag","to_input_legacy$1","of_unsigned$0","let_syntax_025","let_syntax_026","add_flagged$1","let_syntax_027","let_syntax_028","yv","xv","res_magnitude","res_value","let_syntax_029","let_syntax_030","let_syntax_031","let_syntax_032","let_syntax_034","let_syntax_035","let_syntax_036","let_syntax_037","let_syntax_038","to_fee$0","of_fee$0","sub_flagged$0","y_lt_x","add_flagged$2","add_signed","add_signed_flagged$0","expect_failure","expect_success","qc_test_fast","custom_printf_039","custom_printf_040","custom_printf_041","custom_printf_042","custom_printf_046","after_format","custom_printf_050","custom_printf_047","custom_printf_048","custom_printf_049","formatted","has_decimal","trailing_zero","trailing_zero$0","custom_printf_051","custom_printf_052","currency_length","bin_writer_typ","bin_reader_typ","bin_typ","bin_size_t_tagged","bin_write_t_tagged","bin_writer_t_tagged","bin_read_t_tagged","bin_read_t_tagged$0","v_version","v_t","bin_reader_t_tagged","bin_t_tagged","minimum_user_command_fee","default_transaction_fee","default_snark_worker_fee","fee","add_fee","sexp_of_magnitude","magnitude_of_sexp","to_uint64$0","of_uint64$0","to_nanomina_int","pack_var$0","equal_var$0","var_to_input_legacy$0","var_to_input$0","var_of_t$0","to_nanomina_int$0","to_mina_int$0","of_nanomina_int$0","of_mina_int$0","of_nanomina_int_exn$0","of_mina_int_exn$0","of_uint64$1","to_uint64$1","to_mina_string$0","of_mina_string_exn$0","of_bits$0","gen_incl$0","validate_bound$0","validate_ubound$0","validate_lbound$0","clamp$0","clamp_exn$0","between$0","length_in_bits$1","dhall_type$0","compare_magnitude$0","magnitude_of_sexp$0","sexp_of_magnitude$0","to_amount","add_amount","add_amount_flagged","sub_amount","sub_amount_flagged","add_signed_amount_flagged","to_amount$0","uint64_to_z","uint64_of_z","max_uint64_z","fits_uint64","check_q","den","of_q","of_q_exn","make_exn","to_uint64$2","to_uint64_exn","fr","sub_flagged$1","scale_exn","sexp_of_fee","sexp_of_weight","sub_flagged_checked","u_checked","m_checked","union$6","diff$4","single$0","empty$34","csingle","cseq","cadd","cupper","clower","calpha","cdigit","calnum","eRR","menhir_discard","menhir_env","lexer","menhir_errorcase","menhir_stack","menhir_s","menhir_stack$0","menhir_s$0","menhir_s$1","menhir_stack$1","menhir_s$2","menhir_stack$2","menhir_s$3","menhir_stack$3","menhir_s$4","menhir_stack$4","menhir_s$5","menhir_stack$5","menhir_s$6","menhir_stack$6","menhir_s$7","menhir_stack$7","menhir_s$8","menhir_stack$8","menhir_s$9","menhir_stack$9","menhir_s$10","menhir_stack$10","menhir_s$11","menhir_stack$11","menhir_s$12","menhir_stack$12","menhir_s$13","menhir_stack$13","menhir_s$14","menhir_stack$14","menhir_s$15","menhir_stack$15","menhir_s$16","menhir_stack$16","menhir_s$17","menhir_stack$17","menhir_s$18","menhir_stack$18","menhir_s$19","menhir_stack$19","menhir_s$20","menhir_stack$20","menhir_s$21","menhir_stack$21","menhir_s$22","menhir_stack$22","menhir_s$23","menhir_stack$23","menhir_s$24","menhir_stack$24","menhir_s$25","menhir_stack$25","menhir_s$26","menhir_stack$26","menhir_s$27","menhir_stack$27","menhir_s$28","menhir_stack$28","menhir_s$29","menhir_stack$29","menhir_s$30","menhir_stack$30","menhir_s$31","menhir_stack$31","menhir_s$32","menhir_stack$32","menhir_s$33","menhir_stack$33","menhir_s$34","menhir_stack$34","menhir_s$35","menhir_stack$35","menhir_s$36","menhir_stack$36","menhir_s$37","menhir_stack$37","menhir_s$38","menhir_stack$38","menhir_s$39","menhir_stack$39","menhir_s$40","menhir_stack$40","menhir_s$41","menhir_stack$41","menhir_s$42","menhir_stack$42","menhir_s$43","menhir_stack$43","menhir_fail","menhir_goto_field","menhir_goto_selection","menhir_goto_operation","menhir_goto_definition","tok$0","menhir_run1$0","menhir_run2$0","menhir_run3$0","menhir_run4$0","menhir_run78$0","menhir_goto_loption_selection_","_6","_3","_5","_4","_3$0","_1$0","menhir_reduce40","menhir_env$0","menhir_env$1","menhir_run5","_2$0","_4$0","_2$1","_3$1","_2$2","menhir_run6","menhir_run7","menhir_run8","menhir_run10","menhir_run11","menhir_run12","menhir_run9","menhir_run14","menhir_reduce30","menhir_goto_value_parser_const","menhir_reduce24","menhir_goto_option_default_val","menhir_reduce36","menhir_run87","menhir_run93","menhir_goto_typ","menhir_reduce34","menhir_goto_value_parser_value","menhir_reduce26","menhir_goto_loption_arguments","menhir_run20","menhir_reduce32","tok$1","menhir_reduce28","menhir_run98","menhir_run99","menhir_run100","menhir_run97","menhir_run27","menhir_run103","menhir_run104","menhir_run105","menhir_goto_value","menhir_goto_list_directive","tok$2","tok$3","menhir_goto_loption_variable_d","menhir_env$2","menhir_run26","menhir_run28","menhir_run29","menhir_run34","menhir_run25","menhir_run32","menhir_run33","menhir_run36","menhir_goto_enum_value","menhir_reduce38","menhir_run22","menhir_goto_option_name","menhir_goto_name","menhir_env$3","tok$4","v$23","tok$11","tok$12","v$24","menhir_goto_option_type_condit","tok$7","menhir_env$5","tok$8","v$15","v$16","v$17","tok$9","menhir_env$6","tok$10","v$18","v$19","v$20","v$21","v$22","tok$5","menhir_env$4","tok$6","menhir_run13","menhir_goto_keyword_name","menhir_goto_fragment_name","menhir_goto_optype","menhir_run1","menhir_run2","menhir_run3","menhir_run4","menhir_run78","token$0","lcp","string_of_pos","parse$5","find$18","map$72","map_s","map_p","enum_value","deprecated","coerce","enum$0","string_of_const_value","string_of_arg_typ","eval_arg_error","arg_name","field_type","found_str","guid","non_null","value_to_const_value","variable_map","props","props$0","eval_arg","coerced","eval_arglist","arglist","key_values","arglist$0","arglist$1","const_value","arglist$2","arglist$3","schema","mutations","subscriptions","mutation_name","subscription_name","query_name","obj$0","io_field","abstract_field","subscription_field","enum$1","non_null$0","union$0","interface$0","add_type","abstract_typ","obj_of_subscription_obj","string$0","guid$0","skip_directive","include_directive","unless_visited","arg_list_types","memo$0","memo$1","arg_types","argtyp","argtyp$0","argtyp$1","argtyp$2","visited$0","reducer","opt$2","types_of_schema","args_to_list","no_abstracts","enum_value$0","input_value","interfaces","arg_list","directive","schema$0","subs","mut","add_built_in_fields","schema_field","matches_type_condition","type_condition","abstract$0","should_include_field","directives","arguments$0","eval_directive","arguments$1","alias_or_name","merge_selections","matching","selection_sets","selection_set","collect_fields","include_field","spread","fragment","condition","matches_type_condition$0","field_from_object","field_from_subscription_object","coerce_or_null","src$0","map_fields_with_order","error_to_json","extension_props","error_response","resolve_fields","execution_order","query_field","resolve_field","resolve_info","resolver","unlifted_value","resolved","present","lifted_value","src$1","data_to_json","errors$0","field_error","to_response","msg$1","subscribe","subs_field","source_stream","execute_operation","query","data_errs","collect_fragments","validate_fragment_selection","fragment_map","selection","fragment_spread","validate_fragment","inline_fragment","validate_fragments","fragment_names","cycle","collect_and_validate_fragments","fragments","collect_operations","select_operation","operation_name","operations","execute","variables","default_variables","default_value","variables$0","execution_ctx","find$19","find_string","t_toplevel_annots$0","sexp_of_t$125","v_doc","of_annots","t_fields_annots$0","sexpifier$2","v_deprecated","v_skip","compare$137","of_annots$0","annots","under_to_camel","prefix_us","ws$0","name_under_to_camel","add_field","skip_data","f_input","annotations","ref_as_pipe","inner_acc","graphql_arg_coerce","graphql_arg_fields","creator_input","finish","creator","add_field$0","t_field","finish$0","graphql_fields_accumulator","graphql_fields","nullable_graphql_fields","contramap","arg_to_yojson_rec","arg_to_yojson","acc_obj","graphql_query_accumulator","scalar$1","int$6","string$4","wrapped","option$1","list$6","inner_query","bind$25","map$73","initial_buffer","upstream_flushed","downstream_flushed$0","output_closed","blocked_read","ivar$1","iter$34","message_of_field_error","extensions_of_field_error","parse_query","introspection_query","graphql_arg","nullable_graphql_arg","graphql_arg_accumulator","graphql_creator","graphql_query","raw_server","init_acc","merge_acc","force_breaks1","force_breaks2","force_breaks1$0","force_breaks","children","new_children","param$3","acc0","acc1","new_x1","acc2","new_x2","query_schema","query_for_all","hit_server","hit_server_query","hit_server_args","bar","skipped","foo_hello","bar$0","skipped$0","foo_hello$0","make_creator","foo_hello_fun","skipped_fun","bar_fun","compile_acc","compile_acc$0","foo_hello_gen","compile_acc$1","skipped_gen","compile_acc$2","bar_gen","manual_typ","manual_typ$0","foo","foo$0","make_creator$0","foo_fun","foo_gen","manual_typ$1","derived","manual_typ$2","typ_input","generated_typ","generated_arg_typ","generated_query","to_json_accumulator","int$7","string$5","list$7","add_field$1","finished_obj","finish$1","of_json","int$8","string$6","list$8","of_json_creator","full_derivers","group$150","bin_shape_t$133","t_fields_annots$1","t_toplevel_annots$1","t_of_sexp$116","of_h","data_field","hash_field","hash_value","data_value","sexp_of_t$126","v_hash","hash$69","data$3","hash$70","data$4","sexp_of_t$127","compare$138","cmp_h","hash$71","map$74","to_key$0","to_entry","to_doc_entry","docs","leaf_type","js_layout","js_layout_accumulator","js_type","invalid_scalar_to_string","raise_invalid_scalar","except","iso_string","uint64","uint32","js_only","js_leaf","leaf","js_record","entries","global_slot_since_genesis","global_slot_since_hard_fork","global_slot_span","a_opt","static_length$0","static_length","iso","iso_record","of_record","to_record","record_deriver","add_field$2","new_field","finish$2","accumulator","needs_custom_js","balance_change","sign_to_string","sign_of_string","sgn_fun","magnitude_fun","magnitude_gen","sgn_gen","inner_query$0","json_to_safe","print_schema","full","query_top_level","json_to_string_gql","arg_query","out_query","in_schema","out_schema","run_query","unwrap","verification_key_with_hash","verification_key","hash_fun","data_fun","hash_gen","baz","foo1","baz$0","foo1$0","baz_fun","foo1_fun","foo1_gen","baz_gen","v_nothing","v_field","nothing","nothing$0","nothing_fun","field_fun","compile_acc$3","field_gen","compile_acc$4","nothing_gen","public_key$0","obj$1","compile_acc$5","public_key_gen","group$151","bin_shape_t$134","bin_writer_t$48","bin_reader_t$48","bin_t$48","version$16","func$19","path$33","group$152","bin_shape_typ$4","group$153","bin_shape_t$135","create$95","bin_read_t$123","bin_read_t$124","bin_reader_t$49","bin_size_t$68","bin_write_t$70","bin_writer_t$49","bin_t$49","to_decimal_string","to_bytes","curr","curr$0","var_to_hash_packed","var_of_hash_packed","var_to_field","group$154","state_hash","bin_writer_t$50","bin_reader_t$50","bin_t$50","hash$72","path$34","of_string$47","group$155","bin_shape_t$136","pending_coinbase_depth","init$28","genesis_timestamp_of_string","of_time","compare$139","poly_length","poly_delta","poly_genesis_state_timestamp","group$156","bin_shape_t$137","genesis_state_timestamp","to_hlist$25","slots_per_sub_window","slots_per_epoch","of_hlist$25","compare$140","group$157","bin_shape_t$138","path$35","compare$141","compiled$0","max_epoch_length","hash_typ","time_offset","setting_enabled","disable_setting_offset","enable_setting_offset","set_time_offset","tm","env_offset","get_time_offset","var_of_field","pack_value$0","unpack_value$0","unpack_var$0","compare_var$0","increment_var$0","increment_if_var$0","assert_equal_var$0","var_of_field$0","var_of_field_unsafe$0","of_time_span","to_time_span","to_time_ns_span","of_time_ns_span","int64_ns","to_time_exn","t_int64","now$1","field_var_to_unpacked","diff_checked","unpacked_to_number","to_string_exn","of_time_ns","to_system_time","to_string_system_time_exn","of_string_exn","time_beginning","time_end","time_beginning_int64","time_end_int64","int64_time_span","pack_value$1","unpack_value$1","pack_var$1","unpack_var$1","compare_var$1","increment_var$1","increment_if_var$1","assert_equal_var$1","equal_var$1","var_of_field$1","var_of_field_unsafe$1","of_time$0","to_time_exn$0","now$2","field_var_to_unpacked$0","epoch$0","of_span_since_epoch","diff_checked$0","modulus$0","unpacked_to_number$0","to_string_exn$0","of_time_ns$0","to_system_time$0","to_string_system_time_exn$0","of_string_exn$0","ctrl","cancel_ivar","span$0","timeout","cancel","peek","remaining_time","current_time","time_elapsed","await$0","timeout_duration","time_controller","await_exn","group$158","bin_read_t$125","bin_read_t$126","t_of_sexp$117","to_list$15","to_numbered_list","def2","def1","map$75","fold$19","gen$5","inner_gen","of_array$4","map_gens","gen_division_generic","dirichlet","n_float","uniform","gen_division","symbol$242","zero$19","symbol$243","symbol$244","gen_division_currency","root_gen","node_gen","this$0","next_elem","field_of_bool","of_bigstring_exn","to_bigstring$0","to_field_unsafe","gen_non_default","to_field_unsafe$0","t_014","t_013","t_018","t_017","t_019","of_public_key$0","token_id","owner","token_id$0","derive_token_id$1","tid2","tid1","pk_equal","tid_equal","tid_else","pk_else","tid_then","pk_then","create$96","equal$82","group$159","t_of_sexp$118","of_slot","of_slot_span","of_balance","of_amount","initial_minimum_balance_field","cliff_time_field","cliff_amount_field","vesting_period_field","vesting_increment_field","vesting_increment_value","vesting_period_value","cliff_amount_value","cliff_time_value","initial_minimum_balance_value","group$160","timing","t_of_sexp$119","path$36","vesting_increment","vesting_period","cliff_amount","cliff_time","initial_minimum_balance","is_timed","vesting_increment$0","vesting_period$0","cliff_amount$0","cliff_time$0","initial_minimum_balance$0","is_timed$0","t_fields_annots$2","t_toplevel_annots$2","deriver$1","vesting_increment_fun","vesting_period_fun","cliff_amount_fun","cliff_time_fun","initial_minimum_balance_fun","is_timed_fun","is_timed_gen","initial_minimum_balance_gen","cliff_time_gen","cliff_amount_gen","vesting_period_gen","vesting_increment_gen","slot_span_one","balance_unused","amount_unused","to_input$5","typ$30","deriver$2","group$161","group$162","field$5","version$17","group$163","bin_shape_t_tagged$4","create$97","bin_read_t$127","bin_size_t$69","bin_write_t$71","group$164","bin_shape_t$139","bin_size_t$70","bin_write_t$72","bin_read_t$128","t_of_sexp$120","sexp_of_t$128","compare$142","hash_fold_t$74","group$165","bin_shape_t$140","bin_read_t$129","bin_read_t$130","bin_reader_t$51","bin_size_t$71","bin_write_t$73","bin_writer_t$51","bin_t$51","path$37","group$166","bin_shape_typ$5","group$167","bin_shape_t_tagged$5","create$98","bin_read_t$131","bin_size_t$72","bin_write_t$74","authorization","group$168","bin_shape_t$141","path$38","sexp_of_t$129","gen$6","dummy_signature","let_syntax_297","dummy_of_tag","signature_deriver","t_fields_annots$3","t_toplevel_annots$3","signature$3","signature$4","deriver$3","signature_fun","proof_fun","proof_gen","signature_gen","signature","to_record$0","of_record$0","deriver$4","typ$31","to_input$6","t_fields_annots$4","t_toplevel_annots$4","hash$73","data$5","hash$74","data$6","deriver$5","to_yojson$36","symbol$245","group$169","id$8","bin_size_t$73","bin_write_t$75","bin_read_t$132","t_of_sexp$121","sexp_of_t$130","equal$83","compare$143","hash_fold_t$75","path$39","to_yojson$37","symbol$246","group$170","bin_size_t$74","bin_write_t$76","bin_read_t$133","t_of_sexp$122","sexp_of_t$131","compare$144","hash_fold_t$76","path$40","group$171","bin_shape_typ$6","bin_size_typ$1","bin_write_typ$1","bin_read_typ$2","group$172","create$99","to_yojson$38","symbol$247","default_caller","equal$84","deriver$6","group$173","to_hlist$26","fee_excess_r","fee_token_r","fee_excess_l","fee_token_l","of_hlist$26","typ$32","token_typ","fee_typ","group$174","bin_shape_t$142","path$41","rebalance","fee_token_l$0","fee_token_r$0","fee_excess_l$0","zero$20","of_one_or_two","excesses","unreduced","gen_single","group$175","group$176","group$177","token_id$1","group$178","create$100","group$179","bin_shape_t$143","path$42","group$180","bin_shape_t$144","path$43","group$181","bin_shape_typ$7","group$182","bin_shape_t_tagged$6","create$101","dummy$4","to_yojson$39","of_yojson$27","t_of_sexp$123","sexp_of_t$132","equal$85","compare$145","group$183","ledger","bin_writer_t$52","bin_reader_t$52","bin_t$52","hash$75","path$44","group$184","bin_shape_t$145","write_controller","of_controller","of_controller$0","of_controller$1","hash_fold_controller","path$45","sexp_of_t$133","gen_for_proof_authorization","gen_for_signature_authorizatio","gen_for_none_given_authorizati","to_string$50","of_string$48","to_hlist$27","signature_sufficient","signature_necessary","of_hlist$27","to_input$7","encode$0","decode$1","to_input$8","t$9","typ$33","to_input$9","check$10","group$185","bin_shape_t$146","controller","to_hlist$28","set_timing","set_voting_for","increment_nonce","set_token_symbol","edit_action_state","set_zkapp_uri","set_verification_key","set_permissions","set_delegate","send","access","edit_state","of_hlist$28","set_timing$0","set_voting_for$0","increment_nonce$0","set_token_symbol$0","edit_action_state$0","set_zkapp_uri$0","set_verification_key$0","set_permissions$0","set_delegate$0","receive$0","send$0","access$0","edit_state$0","t_fields_annots$5","t_toplevel_annots$5","set_timing$1","set_voting_for$1","increment_nonce$1","set_token_symbol$1","edit_action_state$1","set_zkapp_uri$1","set_verification_key$1","set_permissions$1","set_delegate$1","receive$1","send$1","access$1","edit_state$1","set_timing$2","set_voting_for$2","increment_nonce$2","set_token_symbol$2","edit_action_state$2","set_zkapp_uri$2","set_verification_key$2","set_permissions$2","set_delegate$2","receive$2","send$2","access$2","edit_state$2","to_input$10","group$186","permissions","size_of_permissions","write_permissions","of_permissions","v_edit_state","v_access","v_send","v_receive","v_set_delegate","v_set_permissions","v_set_verification_key","v_set_zkapp_uri","v_edit_action_state","v_set_token_symbol","v_increment_nonce","v_set_voting_for","v_set_timing","t_of_sexp$124","edit_state_field","access_field","send_field","receive_field","set_delegate_field","set_permissions_field","set_verification_key_field","set_zkapp_uri_field","edit_action_state_field","set_token_symbol_field","increment_nonce_field","set_voting_for_field","set_timing_field","set_timing_value","set_voting_for_value","increment_nonce_value","set_token_symbol_value","edit_action_state_value","set_zkapp_uri_value","set_verification_key_value","set_permissions_value","set_delegate_value","receive_value","send_value","access_value","edit_state_value","of_permissions$0","compare$146","hash_fold_t$77","path$46","to_input$11","typ$34","to_input$12","auth_required","deriver$7","set_timing_fun","set_voting_for_fun","increment_nonce_fun","set_token_symbol_fun","edit_action_state_fun","set_zkapp_uri_fun","set_verification_key_fun","set_permissions_fun","set_delegate_fun","receive_fun","send_fun","access_fun","edit_state_fun","edit_state_gen","access_gen","send_gen","receive_gen","set_delegate_gen","set_permissions_gen","set_verification_key_gen","compile_acc$6","set_zkapp_uri_gen","compile_acc$7","edit_action_state_gen","compile_acc$8","set_token_symbol_gen","compile_acc$9","increment_nonce_gen","compile_acc$10","set_voting_for_gen","compile_acc$11","set_timing_gen","digest_length_byte","memo_length","max_digestible_string_length","digest_tag","bytes_tag","is_digest","create_by_digesting_string_exn","ndx","create_by_digesting_string","create_from_value_exn","create_from_bytes_exn","create_from_bytes","create_from_string_exn","create_from_string","to_raw_exn","to_raw_bytes_exn","of_raw_exn","base58_check","memo_var","aux$0","arr$0","group$187","bin_shape_t$147","path$47","group$188","bin_shape_typ$8","group$189","bin_shape_t$148","path$48","group$190","bin_shape_typ$9","group$191","bin_shape_t_tagged$7","create$102","generator_013","to_yojson$40","group$192","bin_shape_t$149","t_of_sexp$125","sexp_of_t$134","path$49","sexp_of_t$135","compare$147","predicate","source_not_present","receiver_not_present","amount_insufficient_to_create_","cannot_pay_creation_fee_in_tok","source_insufficient_balance","source_minimum_balance_violati","receiver_already_exists","token_owner_not_caller","overflow$0","global_excess_overflow","local_excess_overflow","local_supply_increase_overflow","global_supply_increase_overflo","signed_command_on_zkapp_accoun","zkapp_account_not_present","update_not_permitted_balance","update_not_permitted_access","update_not_permitted_timing","update_not_permitted_delegate","update_not_permitted_app_state","update_not_permitted_verificat","update_not_permitted_action_st","update_not_permitted_zkapp_uri","update_not_permitted_token_sym","update_not_permitted_permissio","update_not_permitted_nonce","update_not_permitted_voting_fo","zkapp_command_replay_check_fai","fee_payer_nonce_must_increase","fee_payer_must_be_signed","account_balance_precondition_u","account_nonce_precondition_uns","account_receipt_chain_hash_pre","account_delegate_precondition_","account_action_state_precondit","account_app_state_precondition","predicate$0","source_not_present$0","receiver_not_present$0","amount_insufficient_to_create_$0","cannot_pay_creation_fee_in_tok$0","source_insufficient_balance$0","source_minimum_balance_violati$0","receiver_already_exists$0","token_owner_not_caller$0","overflow$1","global_excess_overflow$0","local_excess_overflow$0","local_supply_increase_overflow$0","global_supply_increase_overflo$0","signed_command_on_zkapp_accoun$0","zkapp_account_not_present$0","update_not_permitted_balance$0","update_not_permitted_access$0","update_not_permitted_timing$0","update_not_permitted_delegate$0","update_not_permitted_app_state$0","update_not_permitted_verificat$0","update_not_permitted_action_st$0","update_not_permitted_zkapp_uri$0","update_not_permitted_token_sym$0","update_not_permitted_permissio$0","update_not_permitted_nonce$0","update_not_permitted_voting_fo$0","zkapp_command_replay_check_fai$0","fee_payer_nonce_must_increase$0","fee_payer_must_be_signed$0","account_balance_precondition_u$0","account_nonce_precondition_uns$0","account_receipt_chain_hash_pre$0","account_delegate_precondition_$0","account_action_state_precondit$0","account_app_state_precondition$0","account_proved_state_precondit","account_is_new_precondition_un","protocol_state_precondition_un","unexpected_verification_key_ha","valid_while_precondition_unsat","incorrect_nonce","invalid_fee_excess","cancelled","fold$20","predicate_fun","source_not_present_fun","receiver_not_present_fun","source_insufficient_balance_fu","receiver_already_exists_fun","token_owner_not_caller_fun","overflow_fun","global_excess_overflow_fun","local_excess_overflow_fun","zkapp_account_not_present_fun","update_not_permitted_balance_f","update_not_permitted_access_fu","update_not_permitted_timing_fu","update_not_permitted_delegate_","update_not_permitted_nonce_fun","fee_payer_nonce_must_increase_","fee_payer_must_be_signed_fun","account_proved_state_precondit$0","account_is_new_precondition_un$0","protocol_state_precondition_un$0","unexpected_verification_key_ha$0","valid_while_precondition_unsat$0","incorrect_nonce_fun","invalid_fee_excess_fun","cancelled_fun","group$193","bin_shape_t$150","path$50","to_yojson$41","group$194","bin_shape_t$151","path$51","to_display","display","empty$36","of_single_failure","is_empty$14","add$33","failure","describe","group$195","bin_shape_t$152","path$52","min$27","max$28","of_enum","equal$86","gen$7","equal$87","of_t","test_mask","payment","stake_delegation","fee_transfer","coinbase$0","typ$35","to_hlist$29","is_user_command","is_coinbase","is_fee_transfer","is_stake_delegation","is_payment","of_hlist$29","typ$36","equal$88","payment$0","stake_delegation$0","fee_transfer$0","coinbase$1","to_bits_t","to_bits_var","bool_var","bit3","bit2","bit1","acc3","add_if_true","base_typ","typ$37","unpacked_t_of_t","t_of_unpacked_t","unpacked","bits_t_of_t","t_of_bits_t","unpacked_typ","test_predicate","one_of","one$15","default$8","group$196","group$197","group$198","global_slot","nonce","token_id$2","public_key$1","group$199","create$103","to_hlist$30","valid_until","fee_payer_pk","of_hlist$30","symbol$248","group$200","bin_shape_t$153","bin_size_t$75","bin_write_t$77","bin_writer_t$53","bin_read_t$134","bin_read_t$135","v_fee","v_fee_payer_pk","v_nonce","v_valid_until","v_memo","bin_reader_t$53","bin_t$53","t_of_sexp$126","fee_field","fee_payer_pk_field","nonce_field","valid_until_field","memo_field","memo_value","valid_until_value","nonce_value","fee_payer_pk_value","fee_value","sexp_of_t$136","hash_fold_t$78","path$53","group$201","bin_shape_t$154","bin_size_t$76","bin_write_t$78","bin_read_t$136","v_fee_token","t_of_sexp$127","fee_token_field","fee_token_value","sexp_of_t$137","hash_fold_t$79","path$54","group$202","bin_shape_typ$10","group$203","common","create$104","let_syntax_073","gen$8","group$204","bin_shape_t$155","bin_size_t$77","bin_write_t$79","bin_read_t$137","v_receiver_pk","v_amount","v_new_delegate","t_of_sexp$128","new_delegate_field","new_delegate_value","receiver_pk_field","amount_field","amount_value","receiver_pk_value","sexp_of_t$138","hash_fold_t$80","path$55","group$205","bin_shape_t$156","bin_size_t$78","bin_write_t$80","bin_read_t$138","v_source_pk","v_token_id","v_delegator","t_of_sexp$129","delegator_field","delegator_value","source_pk_field","token_id_field","token_id_value","source_pk_value","sexp_of_t$139","hash_fold_t$81","path$56","group$206","bin_shape_typ$11","group$207","bin_shape_t_tagged$8","create$105","to_yojson$42","poly_common","poly_body","symbol$249","group$208","bin_shape_t$157","bin_size_t$79","size_of_common","size_of_body","bin_write_t$81","write_common","write_body","bin_read_t$139","of_common","of_body","v_common","v_body","t_of_sexp$130","common_field","body_field","body_value","common_value","sexp_of_t$140","hash_fold_t$82","hash_fold_common","hash_fold_body","compare$148","cmp_common","cmp_body","group$209","common$0","group$210","create$106","to_hlist$31","of_hlist$31","group$211","bin_shape_t$158","bin_size_t$80","bin_write_t$82","bin_read_t$140","t_of_sexp$131","sexp_of_t$141","hash_fold_t$83","path$57","group$212","bin_shape_t$159","bin_size_t$81","bin_write_t$83","bin_read_t$141","t_of_sexp$132","sexp_of_t$142","hash_fold_t$84","path$58","group$213","bin_shape_typ$12","group$214","bin_shape_t_tagged$9","create$107","bin_read_t$142","read_version$6","read_version$5","read_version$3","read_version$2","read_version$4","read_version$1","bin_size_t$82","bin_write_t$84","create$108","fee$0","fee_payer","nonce$0","receiver","new_delegate","max_amount","receiver_pk","generator_012","t_to_hlist","source_pk","t_of_hlist","typ$38","to_hlist$32","fee_token","of_hlist$32","typ$39","of_user_command_payload","max_amount_without_overflow","poly_payload","poly_pk","poly_signature","size_of_payload","size_of_signature","write_payload","write_signature","bin_writer_payload","bin_writer_pk","bin_writer_signature","of_payload","of_signature","v_payload","v_signer","v_signature","bin_reader_payload","bin_reader_pk","bin_reader_signature","bin_payload","bin_pk","bin_signature","cmp_payload","cmp_pk","cmp_signature","payload_field","signer_field","signature_field","signature_value","signer_value","payload_value","hash_fold_payload","hash_fold_pk","hash_fold_signature","account_access_statuses","acct_id","accounts_referenced","bin_writer_typ$0","bin_reader_typ$0","bin_typ$0","bin_size_t_tagged$0","bin_write_t_tagged$0","bin_writer_t_tagged$0","bin_read_t_tagged$1","bin_read_t_tagged$2","bin_reader_t_tagged$0","bin_t_tagged$0","poly_public_key","bin_read_typ$3","bin_read_typ$4","cmp_public_key","signer","payment_payload","stake_delegation_payload","payload$1","bin_size_typ$2","bin_write_typ$2","bin_writer_typ$1","bin_read_typ$5","bin_read_typ$6","bin_reader_typ$1","bin_typ$1","bin_size_t_tagged$1","bin_write_t_tagged$1","bin_writer_t_tagged$1","bin_read_t_tagged$3","bin_read_t_tagged$4","bin_reader_t_tagged$1","bin_t_tagged$1","bin_writer_typ$2","bin_reader_typ$2","bin_typ$2","bin_size_t_tagged$2","bin_write_t_tagged$2","bin_writer_t_tagged$2","bin_read_t_tagged$5","bin_read_t_tagged$6","bin_reader_t_tagged$2","bin_t_tagged$2","bin_reader_t$5","bin_writer_t$5","bin_t$5","top_tag_versions","bin_read_top_tagged_to_latest","has_insufficient_fee","fee_payer$0","fee_excess","receiver$0","valid_until$0","sign_payload","fake_sign","gen_inner","fee_range","create_body","min_fee","max_fee","with_random_participants","gen_inner$0","min_amount","sign_type","gen_with_random_participants","gen_with_random_participants$0","payment_with_random_participan","stake_delegation_with_random_p","account_info","n_commands","currency_splits","command_senders","account_nonces","sender","rest_splits","this_split","sender_pk","sender_pk$0","splits","command_splits","command_splits$0","spend_all","amount_to_spend","swap_idx","group$11","bin_writer_t$6","bin_reader_t$6","bin_t$6","t_of_sexp$3","sexp_of_t$3","hash_fold_t$3","sexp_of_t$4","to_valid_unsafe","bin_size_typ$3","bin_write_typ$3","bin_writer_typ$3","bin_read_typ$7","bin_read_typ$8","bin_reader_typ$3","bin_typ$3","bin_size_t_tagged$3","bin_write_t_tagged$3","bin_writer_t_tagged$3","bin_read_t_tagged$7","bin_read_t_tagged$8","bin_reader_t_tagged$3","bin_t_tagged$3","bin_read_t$11","bin_read_t$12","bin_reader_t$7","bin_size_t$5","bin_write_t$5","bin_writer_t$7","bin_t$7","check_signature","public_keys","check_valid_keys","create_with_signature_checked","gen_test","check_only_for_signature","forget_check","filter_by_participant","user_commands","user_command","group$215","receipt_chain_hash","bin_writer_t$54","bin_reader_t$54","bin_t$54","hash$76","path$59","empty$38","group$216","bin_shape_t$160","bin_writer_t$55","bin_reader_t$55","bin_t$55","hash$77","path$60","group$217","bin_shape_t$161","path$61","group$218","bin_shape_t$162","to_hlist$33","of_hlist$33","to_input$13","of_option$0","to_option$0","map$76","typ$40","option_typ","group$219","bin_shape_t$163","bin_size_t$83","bin_write_t$85","bin_read_t$143","t_of_sexp$133","sexp_of_t$143","compare$149","hash_fold_t$85","t_of_sexp$134","sexp_of_t$144","map$77","to_option$1","of_option$1","is_set","is_keep","deriver$8","gen$9","gen_a","typ$41","optional_typ","to_input$14","to_input$15","group$220","bin_shape_t$164","bin_size_t$84","bin_write_t$86","bin_read_t$144","t_of_sexp$135","sexp_of_t$145","compare$150","hash_fold_t$86","t_of_sexp$136","sexp_of_t$146","equal$89","compare$151","gen$10","to_option$2","of_option$2","deriver_base","deriver$9","to_input$16","typ$42","ignore","group$221","bin_shape_t$165","path$62","to_hlist$34","of_hlist$34","encode$1","decode$2","invalid_public_key","digest_vk","dummy_vk_hash","t_of_sexp$137","sexp_of_t$147","equal$90","hash_fold_t$87","to_binable$12","of_binable$14","path$63","group$222","bin_shape_t$166","bin_size_t$85","bin_write_t$87","bin_read_t$145","equal$91","typ$43","group$223","t_of_sexp$138","path$64","to_input$17","deriver$10","t_of_sexp$139","sexp_of_t$148","hash$78","empty_hash","push_hash","push_event","push_to_data_as_hash","events","pop_from_data_as_hash","events$0","typ$44","to_input$18","deriver$11","hash$79","typ$45","var_to_input$1","to_input$19","deriver$12","empty$39","max_length$1","check$11","t_of_sexp$140","to_binable$13","of_binable$15","path$65","group$224","t_of_sexp$141","of_app_state","of_vk","of_zkapp_version","of_zkapp_uri","verification_key_field","zkapp_version_field","action_state_field","last_action_slot_field","proved_state_field","zkapp_uri_field","zkapp_uri_value","proved_state_value","last_action_slot_value","action_state_value","zkapp_version_value","verification_key_value","to_hlist$35","proved_state","last_action_slot","action_state","zkapp_version","of_hlist$35","zkapp_uri$1","zkapp_uri$2","proved_state$0","last_action_slot$0","action_state$0","zkapp_version$0","verification_key$0","app_state$1","t_fields_annots$6","t_toplevel_annots$6","group$225","bin_shape_t$167","bin_size_t$86","bin_write_t$88","bin_read_t$146","v_verification_key","v_zkapp_version","v_action_state","v_last_action_slot","v_proved_state","v_zkapp_uri","t_of_sexp$142","sexp_of_t$149","path$66","zkapp_uri_non_preimage","hash_zkapp_uri_opt","zkapp_uri_opt","hash$80","typ$46","zkapp_uri_to_input","digest$6","default_digest","action_state_deriver","list_5","gen_uri","app_state$2","seq_state","last_sequence_slot","group$226","bin_shape_t$168","bin_writer_t$56","bin_reader_t$56","bin_t$56","hash$81","path$67","max_length$2","check$12","t_of_sexp$143","to_binable$14","of_binable$16","path$68","num_bits$8","to_field$4","byte_index","to_input$20","of_field$4","chars","typ$47","typ$48","var_to_input$2","group$227","t_of_sexp$144","of_id","of_token_symbol","of_nonce","of_receipt_chain_hash","of_delegate","of_state_hash","of_timing","of_zkapp_opt","token_symbol_field","balance_field","receipt_chain_hash_field","delegate_field","voting_for_field","timing_field","permissions_field","zkapp_field","zkapp_value","permissions_value","timing_value","voting_for_value","delegate_value","receipt_chain_hash_value","balance_value","token_symbol_value","zkapp","permissions$0","timing$0","voting_for","delegate","receipt_chain_hash$0","nonce$1","balance$1","token_symbol","token$1","public_key$2","zkapp$0","permissions$1","timing$1","voting_for$0","delegate$0","receipt_chain_hash$1","nonce$2","balance$2","token_symbol$0","token_id$3","public_key$3","fold$21","public_key_fun","token_id_fun","token_symbol_fun","balance_fun","nonce_fun","receipt_chain_hash_fun","delegate_fun","voting_for_fun","timing_fun","permissions_fun","zkapp_fun","to_hlist$36","of_hlist$36","t_fields_annots$7","t_toplevel_annots$7","group$228","bin_shape_t$169","path$69","delegate$1","group$229","zkapp_opt","bin_shape_t$170","bin_size_t$87","bin_write_t$89","bin_read_t$147","bin_read_t$148","v_token_symbol","v_balance","v_receipt_chain_hash","v_delegate","v_voting_for","v_timing","v_initial_minimum_balance","v_cliff_time","v_cliff_amount","v_vesting_period","v_vesting_increment","v_permissions","v_zkapp","t_of_sexp$145","sexp_of_t$150","equal$92","cmp_amount","path$70","check$13","path$71","to_yojson$43","poly_field","poly_controller","poly_amount","symbol$250","arg10$0","arg9$0","arg8$0","arg7$0","arg6$1","arg5$1","arg4$2","arg6$0","hash_zkapp_account_opt","delegate_opt","digest$7","typ$49","account$0","zkapp$1","typ$50","hash$82","empty$40","create$109","min_balance_at_slot","min_balance_past_cliff","global_slot_u32","cliff_time_u32","vesting_period_u32","num_periods","vesting_decrement","has_permission","control","has_permission_to_send","has_permission_to_receive","gen_with_constrained_balance","vesting_end","gen_any_vesting_range","let_syntax_102","vesting_slots","vesting_periods_count","max_cliff_amt","to_vest","vi","deriver$13","zkapp_uri_fun","proved_state_fun","last_action_slot_fun","action_state_fun","zkapp_version_fun","verification_key_fun","app_state_fun","app_state_gen","verification_key_gen","zkapp_version_gen","action_state_gen","last_action_slot_gen","proved_state_gen","zkapp_uri_gen","token_id_gen","token_symbol_gen","balance_gen","nonce_gen","receipt_chain_hash_gen","compile_acc$12","delegate_gen","compile_acc$13","voting_for_gen","compile_acc$14","timing_gen","compile_acc$15","permissions_gen","compile_acc$16","zkapp_gen","group$230","bin_shape_t$171","ledger_hash","t_fields_annots$8","t_toplevel_annots$8","to_hlist$37","total_currency","of_hlist$37","hash$83","total_currency$0","hash$84","total_currency_fun","total_currency_gen","group$231","bin_shape_t$172","path$72","group$232","bin_shape_t$173","bin_writer_t$57","bin_reader_t$57","bin_t$57","hash$85","path$73","group$233","bin_shape_t$174","epoch_ledger","start_checkpoint","lock_checkpoint","t_fields_annots$9","t_toplevel_annots$9","to_hlist$38","epoch_length","of_hlist$38","ledger$0","epoch_length$0","lock_checkpoint$0","start_checkpoint$0","ledger$1","ledger_fun","seed_fun","start_checkpoint_fun","lock_checkpoint_fun","epoch_length_fun","ledger_gen","seed_gen","start_checkpoint_gen","lock_checkpoint_gen","epoch_length_gen","group$234","bin_shape_t$175","path$74","merge$10","if$10","merge$11","f$17","of_digest$2","group$235","bin_shape_t$176","t_fields_annots$10","t_toplevel_annots$10","to_hlist$39","of_hlist$39","to_input$21","deriver$14","upper_fun","lower_fun","lower_gen","upper_gen","v_upper","v_lower","run$7","length$29","balance$3","global_slot$0","group$236","bin_shape_t$177","bin_size_t$88","bin_write_t$90","bin_read_t$149","t_of_sexp$146","lower_field","upper_field","upper_value","lower_value","sexp_of_t$151","hash_fold_t$88","compare$152","cmp_a$0","equal$93","compare$153","deriver$15","range_max","range_uint32","range_uint64","nonce$3","balance$4","amount$1","length$30","deriver$16","v_foo","gen$11","compare_a","to_input$22","to_input$23","to_input_checked","typ$51","check$14","run$8","init$29","action_state$1","boolean$1","receipt_chain_hash$2","frozen_ledger_hash","state_hash$0","token_id$4","epoch_seed$0","public_key$4","to_input$24","check$15","typ$52","receipt_chain_hash$3","balance$5","nonce$4","group$237","account$1","t_of_sexp$147","is_new_field","is_new_value","path$75","t_fields_annots$11","t_toplevel_annots$11","to_hlist$40","is_new","of_hlist$40","t_of_sexp$148","sexp_of_t$152","v_is_new","equal$94","compare$154","proved_state$1","action_state$2","delegate$2","receipt_chain_hash$4","nonce$5","balance$6","is_new$0","proved_state$2","action_state$3","delegate$3","receipt_chain_hash$5","nonce$6","balance$7","gen$12","accept","deriver$17","is_new_fun","state_fun","state_gen","is_new_gen","to_input$25","to_hlist$41","of_hlist$41","group$238","bin_shape_t$178","size_of_epoch_data","write_epoch_data","of_epoch_data","v_total_currency","v_ledger","v_seed","v_start_checkpoint","v_lock_checkpoint","v_epoch_length","t_of_sexp$149","ledger_field","seed_field","start_checkpoint_field","lock_checkpoint_field","epoch_length_field","total_currency_field","total_currency_value","epoch_length_value","lock_checkpoint_value","start_checkpoint_value","seed_value","ledger_value","of_epoch_data$0","hash_fold_epoch_data","compare$155","a_189","b_190","a_193","b_194","a_197","b_198","path$76","deriver$18","a_203","b_204","min_epoch_length","gen$13","to_input$26","to_input$27","group$239","bin_shape_t$179","snarked_ledger_hash","epoch_data","to_hlist$42","next_epoch_data","staking_epoch_data","min_window_density","blockchain_length","of_hlist$42","t_of_sexp$150","of_snarked_ledger_hash","of_length","of_global_slot","snarked_ledger_hash_field","blockchain_length_field","min_window_density_field","global_slot_since_genesis_fiel","staking_epoch_data_field","next_epoch_data_field","next_epoch_data_value","staking_epoch_data_value","global_slot_since_genesis_valu","min_window_density_value","blockchain_length_value","snarked_ledger_hash_value","t_fields_annots$12","t_toplevel_annots$12","total_currency$1","next_epoch_data$0","staking_epoch_data$0","global_slot_since_genesis$0","total_currency$2","min_window_density$0","blockchain_length$0","snarked_ledger_hash$0","make_creator$1","snarked_ledger_hash_fun","blockchain_length_fun","min_window_density_fun","global_slot_since_genesis_fun","staking_epoch_data_fun","next_epoch_data_fun","snarked_ledger_hash_gen","blockchain_length_gen","min_window_density_gen","global_slot_since_genesis_gen","staking_epoch_data_gen","next_epoch_data_gen","group$240","protocol_state$1","t_of_sexp$151","sexp_of_t$153","v_next_epoch_data","v_staking_epoch_data","v_global_slot_since_genesis","v_min_window_density","v_blockchain_length","v_snarked_ledger_hash","compare$156","a_233","b_234","cmp_epoch_data","a_251","b_252","cmp_length","a_239","b_240","a_237","b_238","a_249","b_250","a_245","b_246","path$77","deriver$19","snarked_ledger_hash$1","max_min_window_density","gen$14","to_input$28","group$241","bin_shape_t$180","path$78","epoch_data_deriver","deriver$20","frozen_ledger_hash$0","state_hash$1","epoch_seed$1","length$31","amount$2","global_slot$1","typ$53","t1$8","a_313","b_314","group$242","bin_shape_t$181","path$79","gen$15","typ$54","group$243","bin_shape_t$182","path$80","to_hlist$43","user","of_hlist$43","group$244","account_transition","group$245","path$81","group$246","group$247","bin_shape_t$183","path$82","group$248","bin_shape_t$184","path$83","to_hlist$44","verification_key_hash","is_proved","is_signed","of_hlist$44","t_fields_annots$13","t_toplevel_annots$13","verification_key_hash$0","is_proved$0","is_signed$0","to_hlist$45","of_hlist$45","typ$55","deriver$21","verification_key_hash_fun","is_proved_fun","is_signed_fun","is_signed_gen","is_proved_gen","verification_key_hash_gen","to_structured","of_structured_exn","let_syntax_269","vk_hash","deriver$22","typ$56","group$249","bin_shape_t$185","path$84","let_syntax_268","t_fields_annots$14","t_toplevel_annots$14","to_hlist$46","inherit_from_parent","parents_own_token","of_hlist$46","inherit_from_parent$0","parents_own_token$0","typ$57","sum_squared","typ$58","to_input$29","to_variant","of_variant","deriver$23","inherit_from_parent_fun","parents_own_token_fun","parents_own_token_gen","inherit_from_parent_gen","deriver$24","typ$59","group$250","bin_shape_t$186","bin_size_t$89","bin_write_t$91","bin_read_t$150","t_of_sexp$152","sexp_of_t$154","hash_fold_t$89","path$85","t_fields_annots$15","t_toplevel_annots$15","t_of_sexp$153","sexp_of_t$155","to_hlist$47","of_hlist$47","vesting_increment$1","vesting_period$1","cliff_amount$1","cliff_time$1","initial_minimum_balance$1","vesting_increment$2","vesting_period$2","cliff_amount$2","cliff_time$2","initial_minimum_balance$2","to_input$30","dummy$5","to_account_timing","of_account_timing","to_hlist$48","of_hlist$48","to_input$31","typ$60","deriver$25","group$251","bin_shape_t$187","path$86","t_fields_annots$16","t_toplevel_annots$16","voting_for$1","timing$2","token_symbol$1","zkapp_uri$3","permissions$2","verification_key$1","delegate$4","app_state$3","voting_for$2","timing$3","token_symbol$2","zkapp_uri$4","permissions$3","verification_key$2","delegate$5","app_state$4","to_hlist$49","of_hlist$49","gen$16","permissions_auth","token_account","token_gen","uri_gen","auth_tag","auth_required_gen","to_hlist$50","of_hlist$50","noop","to_input$32","deriver$26","group$252","bin_shape_t$188","to_full","path$87","gen$17","of_full","deriver$27","group$253","bin_shape_t$189","path$88","t_fields_annots$17","t_toplevel_annots$17","to_hlist$51","valid_while","network","of_hlist$51","account$2","valid_while$0","account$3","network$0","deriver$28","valid_while_fun","account_fun","network_fun","network_gen","account_gen","valid_while_gen","let_syntax_265","to_hlist$52","of_hlist$52","accept$0","group$254","bin_shape_t$190","bin_size_t$90","bin_write_t$92","bin_read_t$151","t_of_sexp$154","sexp_of_t$156","hash_fold_t$90","compare$157","a_142","b_143","a_144","b_145","a_146","b_147","path$89","group$255","bin_shape_t$191","path$90","t_fields_annots$18","t_toplevel_annots$18","authorization_kind","may_use_token","implicit_account_creation_fee","use_full_commitment","preconditions","call_depth","call_data","actions","increment_nonce$3","update$6","token_id$5","public_key$5","authorization_kind$0","may_use_token$0","implicit_account_creation_fee$0","use_full_commitment$0","preconditions$0","call_depth$0","call_data$0","actions$0","increment_nonce$4","balance_change$0","update$7","token_id$6","public_key$6","deriver$29","authorization_kind_fun","may_use_token_fun","implicit_account_creation_fee_$0","use_full_commitment_fun","preconditions_fun","call_depth_fun","call_data_fun","actions_fun","events_fun","balance_change_fun","update_fun","update_gen","balance_change_gen","events_gen","actions_gen","call_data_gen","call_depth_gen","preconditions_gen","use_full_commitment_gen","implicit_account_creation_fee_","may_use_token_gen","authorization_kind_gen","group$256","bin_shape_t$192","path$91","group$257","bin_shape_t$193","sexp_of_t$157","v_authorization_kind","v_may_use_token","v_implicit_account_creation_fe","v_use_full_commitment","v_preconditions","v_call_data","v_actions","v_events","v_balance_change","v_update","v_valid_while","v_account","v_network","v_delegate$0","compare$158","a_206","b_207","path$92","sexp_of_t$158","to_hlist$53","of_hlist$53","of_graphql_repr","group$258","bin_shape_t$194","path$93","t_fields_annots$19","t_toplevel_annots$19","nonce$7","fee$1","public_key$7","nonce$8","valid_until$1","fee$2","public_key$8","let_syntax_242","gen$18","deriver$30","valid_until_fun","fee_fun","fee_gen","valid_until_gen","of_fee_payer","to_hlist$54","of_hlist$54","typ$61","non_preimage","dummy$6","to_input$33","create_body$0","let_syntax_246","let_syntax_249","let_syntax_250","let_syntax_294","let_syntax_259","let_syntax_262","let_syntax_263","let_syntax_296","group$259","bin_shape_t$195","path$94","t_fields_annots$20","t_toplevel_annots$20","authorization$0","authorization$1","deriver$31","authorization_fun","body_fun","body_gen","authorization_gen","group$260","bin_shape_t$196","path$95","group$261","bin_shape_t$197","size_of_account_update","v8$1","v7$2","v6$2","v5$2","v7$1","size_of_length","write_account_update","write_length","of_account_update","arg_1$3","arg_1$2","v_authorization","t_of_sexp$155","authorization_field","update_field","balance_change_field","events_field","actions_field","call_data_field","preconditions_field","use_full_commitment_field","may_use_token_field","authorization_kind_field","network_field","account_field","valid_while_field","valid_while_value","account_value","network_value","authorization_kind_value","may_use_token_value","use_full_commitment_value","preconditions_value","call_data_value","actions_value","events_value","balance_change_value","update_value","authorization_value","sexp_of_t$159","hash_fold_account_update","hash_fold_length","hash$86","path$96","t_of_sexp$156","sexp_of_t$160","of_graphql_repr$0","quickcheck_generator$5","digest$8","create$110","group$262","bin_shape_t$198","hash_fold_t$91","hash$87","path$97","t_fields_annots$21","t_toplevel_annots$21","authorization$2","body$1","authorization$3","body$2","let_syntax_274","deriver$32","of_fee_payer$0","balance_change$1","public_key$9","token_id$7","increment_nonce$5","group$263","bin_shape_t$199","bin_size_t$91","size_of_field","bin_write_t$93","write_field","bin_read_t$152","v_elt","v_stack_hash","t_of_sexp$157","elt_field","stack_hash_field","stack_hash_value","elt_value","sexp_of_t$161","compare$159","cmp_field","hash_fold_t$92","hash_fold_field","group$264","bin_shape_t$200","t_of_sexp$158","status_field","status_value","sexp_of_t$162","v_status","map$78","group$265","bin_size_t$92","size_of_account_update_digest","bin_write_t$94","write_account_update_digest","bin_read_t$153","of_account_update_digest","v_account_update","v_account_update_digest","v_calls","t_of_sexp$159","account_update_field","account_update_digest_field","calls_field","calls_value","account_update_digest_value","account_update_value","sexp_of_t$163","compare$160","cmp_account_update","cmp_account_update_digest","cmp_digest","hash_fold_t$93","hash_fold_account_update_diges","t_of_sexp$160","fold$22","calls","mapi_forest_with_trees","map$79","func$1","func$2","h_tl","cons$0","func$3","account_update_digest","stack_hash","account_update$0","group$266","bin_shape_t$201","t_of_sexp$161","sexp_of_t$164","quickcheck_shrinker$4","quickcheck_generator$6","size_138","random_139","size_136","random_137","quickcheck_observer$0","x_128","size_129","hash_130","x_135","hash_130$0","hash_130$1","size_133","hash_134","x_132","x_131","hash_134$0","hash_134$1","quickcheck_shrinker$5","x_125","x_127","x_126","of_account_updates_map","account_update_depth","account_updates","siblings","to_account_updates_map","collect","hash$88","cons$5","calls$0","accumulate_hashes","hash_account_update","node_hash","group$267","bin_shape_t$202","group$268","bin_shape_t$203","path$98","empty$41","group$269","bin_shape_t$204","path$99","group$270","bin_shape_t$205","path$100","version$18","t_of_sexp$162","fee_payer_field","account_updates_field","account_updates_value","fee_payer_value","sexp_of_t$165","v_account_updates","v_fee_payer","compare$161","a_224","b_225","a_230","b_231","a_228","b_229","a_226","b_227","hash_fold_t$94","group$271","bin_shape_t$206","bin_size_t$93","bin_write_t$95","bin_read_t$154","bin_read_t$155","path$101","let_syntax_275","let_syntax_273","calls_length","to_wire","forget_hashes","forget_hash","of_binable$17","path$102","group$272","bin_shape_typ$13","t_fields_annots$22","t_toplevel_annots$22","t_of_sexp$163","sexp_of_t$166","memo$2","account_updates$0","fee_payer$1","fee_payer$2","status_sym","if$11","group$273","bin_shape_t$207","path$103","create_complete","memo_hash","fee_payer_hash","group$274","bin_shape_t$208","path$104","group$275","bin_shape_t$209","t_of_sexp$164","zkapp_command_field","zkapp_command_value","sexp_of_t$167","v_zkapp_command","hash_fold_t$95","path$105","account_updates_deriver","of_zkapp_command_with_depth","to_zkapp_command_with_depth","memo_fun","account_updates_fun","fee_payer_fun","fee_payer_gen","account_updates_gen","memo_gen","account_update$1","group$276","bin_shape_t$210","to_hlist$55","of_hlist$55","group$277","bin_shape_t$211","path$106","forest","group$278","bin_shape_t$212","t_of_sexp$165","of_u","sexp_of_t$168","compare$162","cmp_u","cmp_s","hash_fold_t$96","hash_fold_u","hash_fold_s","to_signed_command","gen_signed","group$279","bin_shape_t$213","t_of_sexp$166","sexp_of_t$169","hash_fold_t$97","path$107","group$280","bin_shape_t$214","path$108","group$281","bin_shape_t$215","t_of_sexp$167","sexp_of_t$170","hash_fold_t$98","path$109","with_random_receivers","size_args$0","a_012","right_014","left_013","a_016","a_018","right_006","left_005","right_004","left_003","single_to_yojson","single_of_yojson","single_of_sexp","sexp_of_single","compare_single","hash_fold_single","hash_single","to_singles","of_singles","custom_printf_026","custom_printf_027","two$0","singles","receiver_pks","receivers","ft$0","ft$1","fee_tokens","to_fee_transfer","coinbase_amount","v_receiver","v_fee_transfer","receiver_field","fee_transfer_field","fee_transfer_value","receiver_value","cb","access_status","account_ids","adjusted_fee_transfer","expected_supply_increase","increase","supercharged_coinbase","of_coinbase","incr_by_one","push$0","check_merge","to_latest$1","path$2","poly_stack_hash","size_of_stack_hash","write_stack_hash","bin_writer_stack_hash","of_stack_hash","v_init","v_curr","bin_reader_stack_hash","bin_stack_hash","init_field","curr_field","curr_value","init_value","cmp_stack_hash","hash_fold_stack_hash","to_latest$2","path$3","var_of_t$1","push$1","state_body_hash","empty$1","push$2","check_merge$0","correct_transition","eq_target","eq_src","same_update","bin_shape_t$8","hash$3","to_latest$3","bin_shape_t$9","versioned$6","t_of_sexp$5","sexp_of_t$5","to_latest$4","sexp_of_t$6","var_of_t$2","no_update","update_two_stacks_coinbase_in_","update_two_stacks_coinbase_in_$0","poly_action","poly_coinbase_amount","size_of_action","size_of_coinbase_amount","write_action","write_coinbase_amount","bin_writer_action","bin_writer_coinbase_amount","of_action","of_coinbase_amount","v_action","bin_reader_action","bin_reader_coinbase_amount","bin_action","bin_coinbase_amount","versioned$7","t_of_sexp$7","action_field","action_value","sexp_of_t$7","t_of_sexp$8","bin_shape_t$10","bin_writer_t$8","bin_reader_t$8","bin_t$8","versioned$8","t_of_sexp$9","sexp_of_t$9","to_latest$5","sexp_of_t$10","genesis","var_of_t$3","poly_data_stack","poly_state_stack","data_stack","state_stack","size_of_data_stack","size_of_state_stack","write_data_stack","write_state_stack","bin_writer_t$9","bin_writer_data_stack","bin_writer_state_stack","of_data_stack","of_state_stack","bin_reader_t$9","bin_reader_data_stack","bin_reader_state_stack","bin_t$9","bin_data_stack","bin_state_stack","version$8","versioned$9","hash_fold_data_stack","hash_fold_state_stack","t_of_sexp$11","cmp_data_stack","cmp_state_stack","compare$3","a_044","t_of_sexp$12","sexp_of_t$12","a_046","b_047","bin_shape_t$11","bin_size_t$6","bin_write_t$6","bin_writer_t$10","bin_read_t$13","bin_read_t$14","bin_reader_t$10","bin_t$10","versioned$10","equal$8","a_050","a_052","hash_fold_t$5","hash$4","t_of_sexp$13","a_056","a_058","to_latest$6","equal$9","hash_fold_t$6","hash$5","sexp_of_t$15","compare$7","group$12","bin_shape_t$12","bin_size_t$7","bin_write_t$7","bin_writer_t$11","bin_read_t$15","bin_read_t$16","bin_reader_t$11","bin_t$11","equal$10","compare$8","sexp_of_t$16","versioned$11","hash$6","to_latest$7","equal$11","compare$9","sexp_of_t$17","hash_fold_t$8","hash$7","group$13","bin_shape_t$13","bin_writer_t$12","bin_read_t$18","bin_reader_t$12","bin_t$12","versioned$12","sexp_of_t$18","to_latest$8","sexp_of_t$19","max_coinbase_stack_count","chain","hash_fold_t$9","sexp_of_t$20","compare$10","a_076","b_077","equal$12","hash_fold_t$10","hash$8","hash_var","var_of_t$4","num_pad_bits","pad_bits","empty$2","create_with","equal_state_hash","equal_data","connected","coinbase_stack_connected","state_stack_connected","state_stack_connected$0","push_coinbase","push_state","push_coinbase$0","push_state$0","check_merge$1","valid_coinbase_stacks","valid_state_stacks","create_with$0","equal$13","a_082","b_083","compare$12","a_084","b_085","hash_fold_t$11","hash$9","var_of_t$5","empty_hash$0","merge$0","sexp_of_t$23","hash_var$0","hash$10","merge$1","reraise_merkle_requests","addr$0","addr$1","add_coinbase","coinbase_receiver","supercharge_coinbase","addr2","addr1","equal_to_zero","update_stack1","total_coinbase_amount","rem_amount","no_coinbase_in_this_stack","amount1_equal_to_zero","amount2_equal_to_zero","no_coinbase","stack_with_amount1","stack_with_amount2","previous_state_stack","stack_initialized","stack_with_state_hash","update_state","stack_with_coinbase","stack_with_state","update_second_stack","act","pop_coinbases","proof_emitted","let_syntax_086","let_syntax_087","poly_tree","poly_stack_id","of_tree","of_stack_id","pos_list_field","new_pos_field","new_pos_value","pos_list_value","v_new_pos","v_pos_list","t_of_sexp$24","sexp_of_t$25","init_hash","hash_at_level","cur_hash","root_hash","key$2","key$3","height$0","merkle_root$0","get_stack","find_index","next_stack_id","is_new_stack","incr_index","latest_stack_id","curr_stack_id","current_stack","prev_stack_id","latest_stack","prev_stack","oldest_stack_id","remove_oldest_stack_id","oldest_stack","update_stack","stack_index","stack_before","stack_after","add_coinbase$0","add_state","update_coinbase_stack","remove_coinbase_stack","hash_extra","pos_list","pending_coinbase","coinbase_stack_path_exn","stack_id","stack_id$0","index1","stack_id$1","index2","idx$1","idx$2","prev_state","group$14","bin_size_t$9","size_of_tree","size_of_stack_id","bin_write_t$9","write_tree","write_stack_id","bin_writer_t$13","bin_writer_tree","bin_writer_stack_id","bin_read_t$19","bin_read_t$20","bin_reader_t$13","bin_reader_tree","bin_reader_stack_id","bin_t$13","bin_tree","bin_stack_id","versioned$13","sexp_of_t$26","group$15","bin_size_t$10","bin_write_t$10","bin_writer_t$14","bin_read_t$21","bin_read_t$22","bin_reader_t$14","bin_t$14","versioned$14","t_of_sexp$27","to_latest$9","coinbases_gen","cbs","after_adding","after_del","add_coinbase_with_zero_checks","max_coinbase_amount","t_with_state","interim_tree","coinbase_data","cb_var","f_add_coinbase","amount_var","action_var","coinbase_receiver_var","supercharge_coinbase_var","state_body_hash_var","global_slot_var","checked_merkle_root","f_pop_coinbase","unchecked_after_pop","comp$0","checked_merkle_root_after_pop","add_remove_check","coinbase_lists","coinbase_lists$0","pc$0","coinbase_lists$1","coinbases$0","stacks","coinbases","initial_coinbase","updated","new_stack","new_stack$0","pending_coinbases_updated","added_stacks","expected_stack","updated_pending_coinbases","popped_stack","pc$1","coinbase_lists$2","coinbase_lists_gen","of_bytes","of_sha256","length_in_bytes$0","to_base58_check$0","of_base58_check_exn$0","v_ledger_hash","v_aux_hash","v_pending_coinbase_aux","ledger_hash_field","aux_hash_field","pending_coinbase_aux_field","pending_coinbase_aux_value","aux_hash_value","ledger_hash_value","pending_coinbase_aux","aux_hash","pending_coinbase_aux$0","aux_hash$0","ledger_hash$0","ledger_hash_fun","aux_hash_fun","pending_coinbase_aux_fun","ledger_hash_gen","aux_hash_gen","pending_coinbase_aux_gen","map_poly","for_all$0","set_all_mutable_fields","value_of_sexp","compare_value","hash_fold_value","pending_coinbase_aux$1","aux_hash$1","ledger_hash$1","pending_coinbase_aux$2","aux_hash$2","ledger_hash$2","fold$1","map_poly$0","to_list$1","fold$2","for_all$2","to_list$2","set_all_mutable_fields$0","value_to_yojson","genesis_ledger_hash","fold$3","ledger_hash$3","aux_hash$3","of_ledger_aux_coinbase_hash","warn_improper_transport","poly_non_snark","poly_pending_coinbase_hash","non_snark","pending_coinbase_hash","size_of_non_snark","size_of_pending_coinbase_hash","write_non_snark","write_pending_coinbase_hash","bin_writer_non_snark","bin_writer_pending_coinbase_ha","of_non_snark","of_pending_coinbase_hash","v_non_snark","v_pending_coinbase_hash","bin_reader_non_snark","bin_reader_pending_coinbase_ha","bin_non_snark","bin_pending_coinbase_hash","non_snark_field","pending_coinbase_hash_field","pending_coinbase_hash_value","non_snark_value","cmp_non_snark","cmp_pending_coinbase_hash","hash_fold_non_snark","hash_fold_pending_coinbase_has","hash_value$0","ledger_hash$4","aux_hash$4","pending_coinbase_aux$3","pending_coinbase_hash_var","of_aux_ledger_and_coinbase_has","genesis$0","non_snark$0","pending_coinbase_hash$0","caller_caller","hash_zkapp_command","group$282","bin_shape_t$216","path$110","v_prover","prover_field","prover_value","compare$163","group$283","bin_shape_t$217","sexpifier$3","v_genesis_state_timestamp","v_slots_per_sub_window","v_slots_per_epoch","v_k","path$111","compare$164","end_time","gen$19","value_of_t","typ$62","p_var","group$284","bin_shape_t$218","path$112","group$285","bin_shape_t$219","path$113","group$286","bin_shape_t$220","t_of_sexp$168","sexp_of_t$171","compare$165","path$114","equal_account_state","group$287","bin_shape_t$221","command","t_of_sexp$169","of_command","sexp_of_t$172","compare$166","cmp_command","hash_fold_t$99","hash_fold_command","group$288","bin_shape_t$222","t_of_sexp$170","sexp_of_t$173","compare$167","hash_fold_t$100","func$20","path$115","group$289","bin_shape_t$223","t_of_sexp$171","sexp_of_t$174","compare$168","hash_fold_t$101","func$21","path$116","compare_hash","group$290","bin_shape_t$224","bin_read_t$156","bin_read_t$157","bin_reader_t$58","bin_size_t$94","bin_write_t$96","bin_writer_t$58","bin_t$58","mk_hasher","bin_size_t$95","bin_write_t$97","bin_read_t$158","bin_read_t$159","bin_shape_t$225","bin_writer_t$59","bin_reader_t$59","bin_t$59","signed_cmd_hasher_v1","signed_cmd_hasher","zkapp_cmd_hasher","hash_signed_command_v1","cmd_dummy_signature","hash_signed_command_v2","acct_update","dummy_auth","cmd_dummy_signatures_and_proof","hash_of_transaction_id","cmd_v1","group$291","bin_shape_t$226","t_of_sexp$172","sexp_of_t$175","compare$169","path$117","group$292","bin_shape_t$227","t_of_sexp$173","sexp_of_t$176","compare$170","path$118","group$293","signed_amount","group$294","failure_status_tbl","bin_shape_t$228","path$119","group$295","bin_shape_t$229","path$120","t_of_sexp$174","user_command_field","user_command_value","sexp_of_t$177","v_user_command","group$296","bin_shape_t$230","path$121","t_of_sexp$175","previous_delegate_field","previous_delegate_value","new_accounts_field","new_accounts_value","sexp_of_t$178","v_new_accounts","v_previous_delegate","group$297","bin_shape_t$231","path$122","t_of_sexp$176","sexp_of_t$179","group$298","bin_shape_t$232","path$123","t_of_sexp$177","accounts_field","command_field","command_value","accounts_value","sexp_of_t$180","v_command","v_accounts","group$299","bin_shape_t$233","path$124","t_of_sexp$178","sexp_of_t$181","group$300","bin_shape_t$234","path$125","t_of_sexp$179","burned_tokens_field","burned_tokens_value","sexp_of_t$182","v_burned_tokens","group$301","bin_shape_t$235","path$126","t_of_sexp$180","coinbase_field","coinbase_value","sexp_of_t$183","v_coinbase","group$302","bin_shape_t$236","path$127","t_of_sexp$181","sexp_of_t$184","group$303","bin_shape_t$237","path$128","t_of_sexp$182","previous_hash_field","varying_field","varying_value","previous_hash_value","sexp_of_t$185","v_varying","v_previous_hash","burned_tokens","varying","supply_increase","burned_tokens$0","account_creation_fee_int","new_accounts","zc","num_accounts_created","account_creation_fees","txn","process_decreases","amts","timing_error_to_user_command_s","validate_timing_with_min_balan","txn_amount","txn_global_slot","account_balance","proposed_new_balance","curr_min_balance","curr_min_balance$0","invalid_timing","invalid_balance","possibly_error","validate_timing_with_min_balan$0","min_balance","validate_timing","error_opt","get_with_location","set_with_location","sub_account_creation_fee","transaction","transaction_status","get_new_accounts","has_locked_tokens","apply_user_command_unchecked","signer_pk","fee_payer_account","fee_payer_location","ok_or_reject","compute_updates","receiver_account","receiver_location","receiver_amount","updated_accounts","previous_delegate","applied_body","located_accounts","applied_common","apply_user_command","second_pass_ledger","value_if","is_empty$0","assert_with_failure_status_tbl","ecol","proof_verifies","signature_verifies","get_zkapp","set_zkapp","is_non_neg","of_constant_fee","set_or_keep","or_default","add_check","eff","global_state","local_state","new_account","precondition_account","local_state$0","nonce_matches","global_state$0","or_err","pop_call_stack","next_call_stack","next_frame","update_action_state","s1_updated","is_this_slot","is_empty_or_this_slot","s5$0","s4$0","s3$0","is_start","is_empty_call_forest","is_start$0","will_succeed","start_data$2","start_data$3","first_pass_ledger","call_stack","to_pop","start_data$0","start_data$1","call_stack$1","to_pop$0","next_forest","current_is_empty","call_stack$0","current_forest","remainder_of_current_forest","account_update_forest","may_use_parents_own_token","may_use_token_inherited_from_p","account_update_forest_empty","remainder_of_current_forest_em","popped_call_stack","newly_popped_frame","remainder_of_current_forest_fr","new_call_stack","new_frame","local_state$1","account_update_token_id","default_token_or_token_owner_w","full_transaction_commitment","transaction_commitment","start_data","full_tx_commitment_on_start","tx_commitment","full_tx_commitment","local_state$35","account_is_new","self_delegate","zkapp$2","matching_verification_key_hash","local_state$2","local_state$3","protocol_state_predicate_satis","local_state$4","valid_while_satisfied","local_state$5","local_state$6","local_state$7","precondition_has_constant_nonc","increments_nonce_and_constrain","depends_on_the_fee_payers_nonc","does_not_use_a_signature","local_state$8","account_update_token","account_update_token_is_defaul","account_is_untimed","local_state$9","account_creation_fee","local_state$10","neg_creation_fee","creation_overflow","balance_change_for_creation","pay_creation_fee","creation_overflow$0","local_state$11","pay_creation_fee_from_excess","failed1","local_state$12","account_creation_fee$0","excess_update_failed","excess_minus_creation_fee","local_state$13","supply_increase_update_failed","supply_increase_minus_creation","local_state$14","is_receiver","has_permission$0","local_state$15","invalid_timing$1","invalid_timing$0","local_state$16","has_permission$1","local_state$17","keeping_app_state","changing_entire_app_state","has_permission$2","local_state$18","has_permission$3","local_state$19","has_permission$4","local_state$20","has_permission$5","local_state$21","has_permission$6","local_state$22","base_delegate","has_permission$7","local_state$23","has_permission$8","local_state$24","old_hash","has_permission$9","local_state$25","index_input","has_permission$10","local_state$26","local_delta","new_local_fee_excess","overflowed","new_local_fee_excess$0","local_state$27","local_state$28","is_last_account_update","local_state$29","delta_settled","valid_fee_excess","local_state$30","is_start_or_last","update_global_state_fee_excess","global_excess_update_failed","local_state$31","local_state$32","local_state$33","should_update","local_state$34","update_action_state$0","apply_zkapp_command_first_pass","state_view","previous_hash","original_first_pass_account_st","perform$0","user_acc","apply_zkapp_command_first_pass$0","partial_stmt","apply_zkapp_command_second_pas","account_states","acc_opt","original_account_states","step_all","l_state","g_state","states","reversed_failure_status_tbl","account_ids_originally_not_in_","loc_and_acct","successfully_applied","failure_status_tbl$0","valid_result","loc_opt","other_account_update_accounts_","apply_zkapp_command_unchecked_","apply_zkapp_command_unchecked","state_res","account_update_applied","update_timing_when_no_deductio","has_permission_to_receive$0","receiver_account_id","init_account","single_failure","no_failure","append_entry","apply_fee_transfer","transfer","failures","ft_with_status","modify_timing","modify_balance","ft2","ft1","account_id1","can_receive1","action1","account_id2","new_accounts1","can_receive2","action2","balance1","timing2","balance2","burned_tokens1","burned_tokens2","new_accounts2","can_receive","apply_coinbase","failures1","transferee_timing_prev","transferee_update","receiver_reward","receiver_id","coinbase_receiver_timing","receiver_balance","coinbase_with_status","new_receiver_timing","transferee","transferee_id","transferee_account","transferee_location","apply_transaction_first_pass","txn_state_view","applied","txn$0","partially_applied","apply_transaction_second_pass","applied$0","previous_hash$0","applied$1","previous_hash$1","apply_transactions","txns","min_init_balance","max_init_balance","num_accounts","num_transactions","mk_gen","num_transactions$0","init_ledger","nonces","receiver_is_new","gen_index","receiver_index","nonces$0","let_syntax_041","let_syntax_042","raise$1","array_length","export$0","jsoo_exports","raise_error","raise_exn","json_parse","binary_string_to_base58_check","bin_string","binary_string_of_base58_check","base58","public_key_to_base58","public_key_of_base58","pk_base58","private_key_to_base58","sk","private_key_of_base58","sk_base58","token_id_to_base58","token_id_of_base58","memo_to_base58","memo_hash_base58","memo_base58","derive$1","derive_checked","deriver$33","body_deriver","of_json$0","hash_to_group","sign_field_element","is_mainnet","typ$63","account_update$2","account_update$3","transaction_commitments","tx_json","zkapp_public_input","account_update_index","pack_input$2","timing_input","permissions_input","update_input","account_precondition_input","network_precondition_input","body_input","ok_exn$0","hash_payment","command$0","hash_payment_v1","b58","serialize_common","serialize_payment","serialize_payment_v1","payment$1","example_payment","hashPayment","hashPaymentV1","serializeCommon","serializePayment","serializePaymentV1","examplePayment","accountUpdate","transactionCommitments","zkappPublicInput","signFieldElement","dummySignature","deriveChecked","toBase58","ofBase58","publicKeyToBase58","publicKeyOfBase58","privateKeyToBase58","privateKeyOfBase58","tokenIdToBase58","tokenIdOfBase58","memoToBase58","memoHashBase58","test$1","class$1","get$19","location_of_account","set$16","next_location","get_or_create","create_new_account","remove_accounts_exn","ids","locs","empty$42","with_ledger","create_masked","default_token_id","account_id$0","create$111","deriver$34","transform","get_account","add_account","balance$0","bal_u64","deriver$35","of_json$1","apply_json_transaction","network_json","network_state","who","application_result","static_method","method","prototype","public_input_typ","statement_typ","input_size","output_size","inner_curve_typ","should_verifys_js","js_bool","should_verifys","public_output_size","statements","nat_modules_list","nat_add_modules_list","pickles_compile","max_proofs","to_js_provers","prove","js_prevs","public_output","previous_proofs_should_verify","previous_public_inputs","should_verifys$0","public_inputs$0","prevs$1","proof_to_base64","proof$1","proof_of_base64","dummy_base64_proof","dummy_verification_key","pickles","typ$64","size_in_fields","exists$12","exists_var","run_and_check$3","run_unchecked$3","constraint_system$3","add$34","scale$9","mul$3","read_var$0","assert_mul","assert_square$5","assert_boolean","compare$171","to_bits$3","from_bits","truncate_to_bits16","length_div_16","seal$2","and","or","equals","ec_add","scale$10","scalar_bits","of_js","verify$1","public_input_vec","get_vk","get_cs_json","update$8","hash_to_group$0","sponge_params_checked","sponge_params$1","sponge_create","is_checked","sponge_absorb","sponge_squeeze","existsVar","poseidon","hashToGroup","getVerificationKey","getConstraintSystemJSON","ecadd","assertEqual","readVar","assertMul","assertSquare","assertBoolean","toBits","fromBits","truncateToBits16","toConstantAndTerms","asProver","inProverBlock","runAndCheck","runUnchecked","constraintSystem","snarky","export$1","export_global","snarky_obj"],"sources":["","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/strftime.js","/home/fok/codes/o1-labs/mina/_opam/lib/base/runtime.js","/builtin/+ints.js","/builtin/+hash.js","/builtin/+ieee_754.js","/builtin/+int64.js","/builtin/+fail.js","/builtin/+stdlib.js","/builtin/+mlBytes.js","/builtin/+bigarray.js","/workspace_root/src/lib/snarkyjs/src/bindings/ocaml/overrides.js","/builtin/+marshal.js","/home/fok/codes/o1-labs/mina/_opam/lib/base/base_internalhash_types/runtime.js","/builtin/+nat.js","/builtin/+jslib.js","/home/fok/codes/o1-labs/mina/_opam/lib/base_bigstring/runtime.js","/builtin/+bigstring.js","/home/fok/codes/o1-labs/mina/_opam/lib/bigstringaf/runtime.js","/home/fok/codes/o1-labs/mina/_opam/lib/bin_prot/runtime.js","/builtin/+array.js","/builtin/+backtrace.js","/workspace_root/src/lib/snarkyjs/src/bindings/kimchi/js/node_js/node_backend.js","/workspace_root/src/lib/snarkyjs/src/bindings/kimchi/js/bindings.js","/builtin/+compare.js","/builtin/+weak.js","/builtin/+gc.js","/builtin/+format.js","/builtin/+obj.js","/builtin/+fs_node.js","/builtin/+fs.js","/builtin/+unix.js","/builtin/+sys.js","/builtin/+fs_fake.js","/builtin/+io.js","/builtin/+lexing.js","/builtin/+md5.js","/home/fok/codes/o1-labs/mina/_opam/lib/ppx_expect/collector/runtime.js","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/runtime.js","/workspace_root/src/lib/promise/js/promise.js","/workspace_root/src/lib/integers_stubs_js/runtime.js","/home/fok/codes/o1-labs/mina/_opam/lib/zarith_stubs_js/biginteger.js","/home/fok/codes/o1-labs/mina/_opam/lib/zarith_stubs_js/runtime.js","/home/fok/codes/o1-labs/mina/_opam/lib/time_now/runtime.js","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/obj.ml","/workspace_root/src/lib/pickles/limb_vector/constant.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/int64.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/random.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/lexing.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/camlinternalFormat.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/printexc.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/filename.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/exn.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/sign0.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/hex_lexer.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/popcount.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/int63_emul.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/backtrace.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppx_bench/runtime-lib/benchmark_accumulator.ml","/home/fok/codes/o1-labs/mina/_opam/lib/bin_prot/shape/bin_shape.ml","/home/fok/codes/o1-labs/mina/_opam/lib/stdio/in_channel.ml","/home/fok/codes/o1-labs/mina/_opam/lib/stdio/out_channel.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppx_module_timer/runtime/ppx_module_timer_runtime.ml","/home/fok/codes/o1-labs/mina/_opam/lib/typerep/std_internal.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppx_expect/collector/check_backtraces.ml","/home/fok/codes/o1-labs/mina/_opam/lib/splittable_random/splittable_random.ml","/home/fok/codes/o1-labs/mina/_opam/lib/parsexp/positions.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/perms.ml","/home/fok/codes/o1-labs/mina/_opam/lib/sexplib0/sexp_conv_error.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/quickcheck.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/std_internal.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/span_float.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/tuple.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/digit_string_helpers.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/month.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/date0.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/percent.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/ofday_float.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/span_ns.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/ofday_ns.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/gc.ml","/home/fok/codes/o1-labs/mina/_opam/lib/easy-format/easy_format.ml","/home/fok/codes/o1-labs/mina/_opam/lib/yojson/yojson.ml","/home/fok/codes/o1-labs/mina/_opam/lib/bignum/bigint/bigint.ml","/workspace_root/src/lib/snarky/src/base/cvar.ml","/workspace_root/src/lib/snarky/src/base/constraint.ml","/workspace_root/src/lib/snarky/src/base/backend_extended.ml","/workspace_root/src/lib/snarky/src/base/checked_runner.ml","/workspace_root/src/lib/snarky/src/base/utils.ml","/workspace_root/src/lib/snarky/src/base/merkle_tree.ml","/workspace_root/src/lib/snarky/src/base/snark0.ml","/home/fok/codes/o1-labs/mina/_opam/lib/bigstringaf/bigstringaf.ml","/workspace_root/src/lib/pickles_types/shifted_value.ml","/workspace_root/src/lib/pickles_types/plonk_types.ml","/workspace_root/src/lib/pickles/pickles.ml","/workspace_root/src/lib/pickles_types/plonk_verification_key_evals.ml","/workspace_root/src/lib/pickles_types/pcs_batch.ml","/workspace_root/src/lib/snarky/sponge/sponge.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/tuple_pool/tuple_pool.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/validate.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/thread_pool_cpu_affinity/thread_pool_cpu_affinity.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/uopt/uopt.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/timing_wheel/timing_wheel.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/async_kernel_config.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/monitor.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/async_kernel.ml","/home/fok/codes/o1-labs/mina/_opam/lib/digestif/ocaml/baijiu_blake2b.ml","/home/fok/codes/o1-labs/mina/_opam/lib/digestif/ocaml/baijiu_blake2s.ml","/home/fok/codes/o1-labs/mina/_opam/lib/digestif/ocaml/digestif.ml","/workspace_root/src/lib/hex/hex.ml","/workspace_root/src/lib/logger/fake/logger.ml","/workspace_root/src/lib/allocation_functor/table.ml","/workspace_root/src/lib/crypto/kimchi_backend/common/scale_round.ml","/workspace_root/src/lib/crypto/kimchi_backend/common/scalar_challenge.ml","/workspace_root/src/lib/crypto/kimchi_backend/common/curve.ml","/workspace_root/src/lib/crypto/kimchi_backend/common/plonk_dlog_proof.ml","/workspace_root/src/lib/crypto/kimchi_backend/common/bigint.ml","/workspace_root/src/lib/crypto/kimchi_backend/common/endoscale_round.ml","/workspace_root/src/lib/crypto/kimchi_backend/common/endoscale_scalar_round.ml","/workspace_root/src/lib/crypto/kimchi_backend/common/field.ml","/workspace_root/src/lib/crypto/kimchi_backend/common/plonk_constraint_system.ml","/workspace_root/src/lib/snarky/fold_lib/fold.ml","/workspace_root/src/lib/snarky/snarkette/fields.ml","/workspace_root/src/lib/crypto/kimchi_backend/pasta/vesta_based_plonk.ml","/workspace_root/src/lib/crypto/kimchi_backend/pasta/pallas_based_plonk.ml","/workspace_root/src/lib/blake2/blake2.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/ast_412.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/pprintast.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/ast_413.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/ast_414.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/ast_411.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/ast_410.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/ast_409.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/ast_408.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/ast_407.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/ast_406.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/ast_405.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/ast_404.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/ast_403.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/ast_402.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/migrate_403_402.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/ast/versions.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/stdppx/stdppx.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/name.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/camlinternalOO.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/deriving.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base_quickcheck/ppx_quickcheck/expander/environment.ml","/workspace_root/src/lib/random_oracle_input/random_oracle_input.ml","/workspace_root/src/lib/pickles_base/proofs_verified.ml","/workspace_root/src/lib/pickles_base/side_loaded_verification_key.ml","/workspace_root/src/lib/pickles_base/domain.ml","/workspace_root/src/lib/pickles/composition_types/branch_data.ml","/workspace_root/src/lib/pickles/composition_types/bulletproof_challenge.ml","/workspace_root/src/lib/pickles/composition_types/composition_types.ml","/workspace_root/src/lib/pickles/plonk_checks/scalars.ml","/workspace_root/src/lib/mina_version/normal/mina_version.ml","/workspace_root/src/lib/base58_check/base58_check.ml","/workspace_root/src/lib/snarky/snarky_curve/snarky_curve.ml","/workspace_root/src/lib/snark_keys_header/snark_keys_header.ml","/workspace_root/src/lib/error_json/error_json.ml","/workspace_root/src/lib/pickles/wrap_wire_proof.ml","/workspace_root/src/lib/pickles/scalar_challenge.ml","/workspace_root/src/lib/pickles/impls.ml","/workspace_root/src/lib/pickles/plonk_curve_ops.ml","/workspace_root/src/lib/pickles/reduced_messages_for_next_proof_over_same_field.ml","/workspace_root/src/lib/pickles/step_main_inputs.ml","/workspace_root/src/lib/pickles/side_loaded_verification_key.ml","/workspace_root/src/lib/pickles/proof.ml","/workspace_root/src/lib/pickles/wrap_main_inputs.ml","/workspace_root/src/lib/pickles/wrap_verifier.ml","/workspace_root/src/lib/pickles/step_verifier.ml","/workspace_root/src/lib/pickles/cache.ml","/workspace_root/src/lib/snark_params/snark_params.ml","/workspace_root/src/lib/random_oracle/permutation/external/random_oracle_permutation.ml","/workspace_root/src/lib/random_oracle/random_oracle.ml","/workspace_root/src/lib/non_zero_curve_point/non_zero_curve_point.ml","/workspace_root/src/lib/signature_lib/private_key.ml","/workspace_root/src/lib/signature_lib/schnorr.ml","/workspace_root/src/lib/signature_lib/keypair.ml","/workspace_root/src/lib/sgn/sgn.ml","/workspace_root/src/lib/sparse_ledger_lib/sparse_ledger.ml","/workspace_root/src/lib/rosetta_coding/coding.ml","/workspace_root/src/lib/ppx_dhall_type/deriving.ml","/workspace_root/src/lib/mina_numbers/global_slot_span.ml","/workspace_root/src/lib/mina_numbers/global_slot_since_genesis.ml","/workspace_root/src/lib/mina_numbers/global_slot_since_hard_fork.ml","/workspace_root/src/lib/currency/signed_poly.ml","/workspace_root/src/lib/currency/currency.ml","/home/fok/codes/o1-labs/mina/_opam/lib/re/cset.ml","/home/fok/codes/o1-labs/mina/_opam/lib/graphql_parser/parser.ml","/home/fok/codes/o1-labs/mina/_opam/lib/graphql_parser/lexer.ml","/home/fok/codes/o1-labs/mina/_opam/lib/graphql/graphql_schema.ml","/workspace_root/src/lib/fields_derivers/fields_derivers.ml","/workspace_root/src/lib/fields_derivers_graphql/fields_derivers_graphql.ml","/workspace_root/src/lib/fields_derivers_json/fields_derivers_json.ml","/workspace_root/src/lib/with_hash/with_hash.ml","/workspace_root/src/lib/fields_derivers_zkapps/fields_derivers_zkapps.ml","/workspace_root/src/lib/data_hash_lib/state_hash.ml","/workspace_root/src/lib/genesis_constants/genesis_constants.ml","/workspace_root/src/lib/block_time/block_time.ml","/workspace_root/src/lib/one_or_two/one_or_two.ml","/workspace_root/src/lib/mina_base/account_id.ml","/workspace_root/src/lib/mina_base/account_timing.ml","/workspace_root/src/lib/mina_base/signature.ml","/workspace_root/src/lib/mina_base/control.ml","/workspace_root/src/lib/mina_base/payment_payload.ml","/workspace_root/src/lib/mina_base/ledger_hash0.ml","/workspace_root/src/lib/mina_base/permissions.ml","/workspace_root/src/lib/mina_base/signed_command_memo.ml","/workspace_root/src/lib/mina_base/stake_delegation.ml","/workspace_root/src/lib/mina_base/transaction_status.ml","/workspace_root/src/lib/mina_base/transaction_union_tag.ml","/workspace_root/src/lib/mina_base/signed_command_payload.ml","/workspace_root/src/lib/mina_base/signed_command.ml","/workspace_root/src/lib/mina_base/receipt.ml","/workspace_root/src/lib/mina_base/state_body_hash.ml","/workspace_root/src/lib/mina_base/zkapp_basic.ml","/workspace_root/src/lib/mina_base/zkapp_account.ml","/workspace_root/src/lib/mina_base/account.ml","/workspace_root/src/lib/mina_base/epoch_ledger.ml","/workspace_root/src/lib/mina_base/epoch_seed.ml","/workspace_root/src/lib/mina_base/epoch_data.ml","/workspace_root/src/lib/mina_base/zkapp_precondition.ml","/workspace_root/src/lib/mina_base/data_as_hash.ml","/workspace_root/src/lib/mina_base/account_update.ml","/workspace_root/src/lib/mina_base/with_stack_hash.ml","/workspace_root/src/lib/mina_base/with_status.ml","/workspace_root/src/lib/mina_base/zkapp_command.ml","/workspace_root/src/lib/mina_base/user_command.ml","/workspace_root/src/lib/mina_base/fee_transfer.ml","/workspace_root/src/lib/mina_base/coinbase_fee_transfer.ml","/workspace_root/src/lib/mina_base/coinbase.ml","/workspace_root/src/lib/mina_base/pending_coinbase.ml","/workspace_root/src/lib/mina_base/staged_ledger_hash.ml","/workspace_root/src/lib/mina_base/sok_message.ml","/workspace_root/src/lib/mina_base/protocol_constants_checked.ml","/workspace_root/src/lib/mina_base/fee_with_prover.ml","/workspace_root/src/lib/transaction/transaction.ml","/workspace_root/src/lib/transaction/transaction_hash.ml","/workspace_root/src/lib/transaction_logic/mina_transaction_logic.ml","/workspace_root/src/lib/snarkyjs/src/bindings/ocaml/lib/consistency_test.ml","/workspace_root/src/lib/snarkyjs/src/bindings/ocaml/lib/pickles_bindings.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/camlinternalFormatBasics.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/camlinternalAtomic.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/stdlib.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/base.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/stdlib.mli","/home/fok/codes/o1-labs/mina/_opam/lib/base/int_intf.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/float0.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/pipe.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/int_conversions.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/list.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base_quickcheck/ppx_quickcheck/expander/import.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/sys0.ml","/home/fok/codes/o1-labs/mina/_opam/lib/bin_prot/write.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/camlinternalLazy.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/lazy.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/seq.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/option.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/result.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/char.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/int.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/bytes.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/string.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/marshal.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/array.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/int32.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/nativeint.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/parsing.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/set.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/map.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/stack.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/queue.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/buffer.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/printf.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base_bigstring/base_bigstring.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/arg.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/fun.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/digest.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/random.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/hashtbl.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/attribute.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/format.ml","/home/fok/codes/o1-labs/mina/_opam/lib/re/fmt.ml","/home/fok/codes/o1-labs/mina/_opam/lib/re/pmark.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/scanf.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/callback.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/camlinternalMod.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/bigarray.ml","/home/fok/codes/o1-labs/mina/_opam/lib/sexplib0/lazy_group_id.ml","/home/fok/codes/o1-labs/mina/_opam/lib/sexplib0/sexp.ml","/home/fok/codes/o1-labs/mina/_opam/lib/sexplib0/sexp_conv.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/ephemeron.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/span_helpers.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/import0.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/printf.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/array0.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/char0.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/list0.ml","/workspace_root/src/lib/snarky/bitstring_lib/bitstring.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/hash.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/ppx_compare_lib.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/string0.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/sexp.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/sexpable.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/word_size.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/pretty_printer.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/core_kernel.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/with_return.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/monad.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/comparator.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/field.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/source_code_position0.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/list1.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/result.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/container_intf.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/container.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/lazy.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/monad_intf.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/fn.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/list.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/ordering.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/applicative.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/info.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/error.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/invariant.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/maybe_bound.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/or_error.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/comparable.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/identifiable.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/comparable_intf.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/unit.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/ordered_collection_common.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/binary_search.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/binary_searchable.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/bytes0.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/blit.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/option.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/either.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/indexed_container.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/sequence.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/array.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/obj_array.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/uniform_array.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/char.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/string.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/bytes.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/pow_overflow_bounds.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/int_math.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/int.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/type_equal.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/univ_map.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/option_array.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/stack.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/set.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/set_intf.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/queue.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/nothing.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/never_returns.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/nativeint.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/map.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/map_intf.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/int64.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/bool.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/int32.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/int63.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/hashtbl.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/hashtbl_intf.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/hashable_intf.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/avltree.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/hash_set_intf.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/hash_set.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/float.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/buffer.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppx_assert/runtime-lib/runtime.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base/md5/md5_lib.ml","/home/fok/codes/o1-labs/mina/_opam/lib/bin_prot/common.ml","/workspace_root/src/lib/pickles_types/vector.ml","/home/fok/codes/o1-labs/mina/_opam/lib/bin_prot/read.ml","/home/fok/codes/o1-labs/mina/_opam/lib/bin_prot/shape.ml","/home/fok/codes/o1-labs/mina/_opam/lib/bin_prot/size.ml","/home/fok/codes/o1-labs/mina/_opam/lib/bin_prot/type_class.ml","/home/fok/codes/o1-labs/mina/_opam/lib/bin_prot/utils.ml","/home/fok/codes/o1-labs/mina/_opam/lib/bin_prot/std.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppx_inline_test/config/inline_test_config.ml","/home/fok/codes/o1-labs/mina/_opam/lib/time_now/time_now.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppx_inline_test/runtime-lib/runtime.ml","/home/fok/codes/o1-labs/mina/_opam/lib/typerep/typename.ml","/home/fok/codes/o1-labs/mina/_opam/lib/typerep/make_typename.ml","/home/fok/codes/o1-labs/mina/_opam/lib/typerep/variant_and_record_intf.ml","/home/fok/codes/o1-labs/mina/_opam/lib/typerep/typerep_obj.ml","/home/fok/codes/o1-labs/mina/_opam/lib/typerep/type_abstract.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppx_expect/common/file.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppx_expect/collector/expect_test_collector.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppx_expect/config_types/expect_test_config_types_intf.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppx_expect/config_types/expect_test_config_types.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppx_expect/config/expect_test_config.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base_quickcheck/generator.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base_quickcheck/bigarray_helpers.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base_quickcheck/observer0.ml","/workspace_root/src/lib/pickles/opt_sponge.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base_quickcheck/shrinker.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base_quickcheck/test.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base_quickcheck/observer.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/base_for_tests/test_blit.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/base_for_tests/test_binary_searchable.ml","/home/fok/codes/o1-labs/mina/_opam/lib/parsexp/parsexp.ml","/home/fok/codes/o1-labs/mina/_opam/lib/parsexp/automaton_stack.ml","/home/fok/codes/o1-labs/mina/_opam/lib/parsexp/of_sexp_error.ml","/home/fok/codes/o1-labs/mina/_opam/lib/parsexp/parse_error.ml","/home/fok/codes/o1-labs/mina/_opam/lib/parsexp/parser_automaton_internal.ml","/home/fok/codes/o1-labs/mina/_opam/lib/parsexp/parser_automaton.ml","/home/fok/codes/o1-labs/mina/_opam/lib/parsexp/kind.ml","/home/fok/codes/o1-labs/mina/_opam/lib/parsexp/automaton_helpers.ml","/home/fok/codes/o1-labs/mina/_opam/lib/parsexp/parser.ml","/home/fok/codes/o1-labs/mina/_opam/lib/parsexp/conv.ml","/home/fok/codes/o1-labs/mina/_opam/lib/sexplib/pre_sexp.ml","/home/fok/codes/o1-labs/mina/_opam/lib/parsexp/old_parser_cont_state.ml","/home/fok/codes/o1-labs/mina/_opam/lib/sexplib/conv.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/import.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/sexpable.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/binable_intf.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/binable0.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/printf.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/comparator.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/result.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/container.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/deprecate_pipe_bang.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/fn.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/ordered_collection_common.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/sequence.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/array.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/source_code_position0.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/info.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/error.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/t.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/list0.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/hashtbl.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/hash_set.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/or_error.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/map.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/set.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/comparable.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/doubly_linked_intf.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/list.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/option.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/union_find.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/doubly_linked.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/bag.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/sexp.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/hash_queue.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/hashable.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/identifiable.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/bool.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/hexdump_intf.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/hexdump.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/string.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/bytes.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/char.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/core_pervasives.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/sign.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/float.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/int.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/int32.ml","/workspace_root/src/lib/unsigned_extended/unsigned_extended.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/int64.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/int63.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/unit.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/interfaces.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/lazy.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/nativeint.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/nothing.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/ordering.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/ref.ml","/workspace_root/src/lib/transaction_logic/zkapp_command_logic.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/byte_units0.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/bigstring.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/core_bin_prot.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/md5.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/zone_intf.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/binable.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/zone.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/source_code_position.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/validated.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/type_equal.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/univ_map_intf.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/unit_of_time.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/unique_id.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/uniform_array.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/day_of_week.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/ofday_helpers.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/stable_internal.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/float_with_finite_only_serialization.ml","/workspace_root/src/lib/timeout_lib/timeout_lib.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/time_intf.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/time.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/time_float0.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/time_float.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/time_ns.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/time_ns_alternate_sexp.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/set_once.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/heap_block.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/queue.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/option_array.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/memo.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/deque.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/debug.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/bag_intf.ml","/home/fok/codes/o1-labs/mina/_opam/lib/integers/unsigned.ml","/home/fok/codes/o1-labs/mina/_opam/lib/biniou/bi_util.ml","/home/fok/codes/o1-labs/mina/_opam/lib/biniou/bi_outbuf.ml","/home/fok/codes/o1-labs/mina/_opam/lib/biniou/bi_share.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppx_deriving_yojson/runtime/ppx_deriving_yojson_runtime.ml","/workspace_root/src/lib/crypto/kimchi_bindings/stubs/pasta_bindings.ml","/workspace_root/src/lib/snarky/tuple_lib/double.ml","/workspace_root/src/lib/snarky/tuple_lib/intf.ml","/workspace_root/src/lib/snarky/tuple_lib/four.ml","/workspace_root/src/lib/snarky/tuple_lib/quadruple.ml","/workspace_root/src/lib/snarky/tuple_lib/triple.ml","/workspace_root/src/lib/snarky/tuple_lib/tuple_lib.ml","/workspace_root/src/lib/snark_bits/bits.ml","/workspace_root/src/lib/snarky/interval_union/interval_union.ml","/workspace_root/src/lib/snarky/snarkette/nat.ml","/workspace_root/src/lib/snarky/src/base/handle.ml","/workspace_root/src/lib/snarky/src/base/monad_let.ml","/workspace_root/src/lib/snarky/src/base/request.ml","/workspace_root/src/lib/snarky/src/base/checked.ml","/workspace_root/src/lib/snarky/src/base/types.ml","/workspace_root/src/lib/snarky/src/base/as_prover0.ml","/workspace_root/src/lib/snarky/src/base/run_state.ml","/workspace_root/src/lib/snarky/src/base/checked_intf.ml","/workspace_root/src/lib/snarky/src/base/as_prover_ref.ml","/workspace_root/src/lib/snarky/src/base/boolean.ml","/workspace_root/src/lib/snarky/src/base/runners.ml","/workspace_root/src/lib/snarky/src/base/typ.ml","/workspace_root/src/lib/snarky/src/base/monad_sequence.ml","/workspace_root/src/lib/snarky/src/base/enumerable.ml","/workspace_root/src/lib/snarky/src/base/number.ml","/workspace_root/src/lib/snarky/src/base/snark.ml","/workspace_root/src/lib/ppx_version/runtime/shapes.ml","/home/fok/codes/o1-labs/mina/_opam/lib/angstrom/input.ml","/home/fok/codes/o1-labs/mina/_opam/lib/angstrom/parser.ml","/home/fok/codes/o1-labs/mina/_opam/lib/angstrom/angstrom.ml","/workspace_root/src/lib/logproc_lib/interpolator.ml","/workspace_root/src/lib/structured_log_events/structured_log_events.ml","/workspace_root/src/lib/pickles_types/nat.ml","/workspace_root/src/lib/pickles_types/hlist0.ml","/workspace_root/src/lib/mina_base/zkapp_state.ml","/workspace_root/src/lib/crypto/kimchi_backend/pasta/basic/kimchi_pasta_basic.ml","/workspace_root/src/lib/pickles_types/hlist.ml","/workspace_root/src/lib/pickles_types/or_infinity.ml","/workspace_root/src/lib/pickles/plonk_checks/plonk_checks.ml","/workspace_root/src/lib/pickles_types/at_most.ml","/workspace_root/src/lib/crypto/kimchi_bindings/stubs/kimchi_bindings.ml","/workspace_root/src/lib/snarky/sponge/params.ml","/workspace_root/src/lib/snarky/sponge/constants.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/tuple_pool/tuple_type_intf.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/tuple_pool/tuple_type.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/pairing_heap/pairing_heap.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/sexp_hidden_in_test/sexp_hidden_in_test.ml","/home/fok/codes/o1-labs/mina/_opam/lib/core_kernel/thread_safe_queue/thread_safe_queue.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/time_ns.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/monitor0.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/debug.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/import.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/priority.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/types.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/execution_context.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/job_queue.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/tracing.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/external_job.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/job_pool.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/job_or_event.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/scheduler0.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/synchronous_time_source0.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/scheduler1.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/scheduler.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/ivar0.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/deferred0.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/ivar.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/monad_sequence.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/deferred1.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/deferred_std.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/ivar_filler.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/tail.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/async_stream.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/synchronous_time_source.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/bvar.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/time_source.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/stack_or_counter.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/throttle.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/async_kernel_scheduler.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/clock_ns.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/deferred_list.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/deferred_result.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/deferred_or_error.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/deferred_queue.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/deferred.ml","/home/fok/codes/o1-labs/mina/_opam/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/async_gc.ml","/home/fok/codes/o1-labs/mina/_opam/lib/digestif/ocaml/digestif_bi.ml","/home/fok/codes/o1-labs/mina/_opam/lib/digestif/ocaml/digestif_by.ml","/home/fok/codes/o1-labs/mina/_opam/lib/digestif/ocaml/xor.ml","/home/fok/codes/o1-labs/mina/_opam/lib/digestif/ocaml/digestif_conv.ml","/home/fok/codes/o1-labs/mina/_opam/lib/digestif/ocaml/baijiu_md5.ml","/home/fok/codes/o1-labs/mina/_opam/lib/digestif/ocaml/baijiu_rmd160.ml","/home/fok/codes/o1-labs/mina/_opam/lib/digestif/ocaml/baijiu_sha1.ml","/home/fok/codes/o1-labs/mina/_opam/lib/digestif/ocaml/baijiu_sha256.ml","/home/fok/codes/o1-labs/mina/_opam/lib/digestif/ocaml/baijiu_sha224.ml","/home/fok/codes/o1-labs/mina/_opam/lib/digestif/ocaml/baijiu_sha3.ml","/home/fok/codes/o1-labs/mina/_opam/lib/digestif/ocaml/baijiu_sha3_512.ml","/home/fok/codes/o1-labs/mina/_opam/lib/digestif/ocaml/baijiu_sha512.ml","/home/fok/codes/o1-labs/mina/_opam/lib/digestif/ocaml/baijiu_sha384.ml","/home/fok/codes/o1-labs/mina/_opam/lib/digestif/ocaml/baijiu_sha3_224.ml","/home/fok/codes/o1-labs/mina/_opam/lib/digestif/ocaml/baijiu_sha3_256.ml","/home/fok/codes/o1-labs/mina/_opam/lib/digestif/ocaml/baijiu_sha3_384.ml","/home/fok/codes/o1-labs/mina/_opam/lib/digestif/ocaml/baijiu_whirlpool.ml","/home/fok/codes/o1-labs/mina/_opam/lib/digestif/ocaml/digestif_eq.ml","/home/fok/codes/o1-labs/mina/_opam/lib/eqaf/eqaf.ml","/workspace_root/src/lib/key_cache/key_cache.ml","/workspace_root/src/lib/allocation_functor/make.ml","/workspace_root/src/lib/promise/js/promise.ml","/workspace_root/src/lib/internal_tracing/context_logger/internal_tracing_context_logger.ml","/workspace_root/src/lib/crypto/kimchi_backend/common/poly_comm.ml","/workspace_root/src/lib/crypto/kimchi_backend/common/plonk_dlog_oracles.ml","/workspace_root/src/lib/crypto/kimchi_backend/common/constants.ml","/workspace_root/src/lib/crypto/kimchi_backend/common/dlog_plonk_based_keypair.ml","/workspace_root/src/lib/crypto/kimchi_backend/common/kimchi_backend_common.ml","/workspace_root/src/lib/crypto/kimchi_backend/pasta/constraint_system/caml/vesta_constraint_system.ml","/workspace_root/src/lib/crypto/kimchi_backend/pasta/constraint_system/caml/pallas_constraint_system.ml","/workspace_root/src/lib/crypto/kimchi_backend/pasta/kimchi_pasta.ml","/workspace_root/src/lib/mina_wire_types/block_time.ml","/workspace_root/src/lib/mina_wire_types/currency.ml","/workspace_root/src/lib/mina_wire_types/pickles/pickles_composition_types.ml","/workspace_root/src/lib/mina_wire_types/pickles/pickles.ml","/workspace_root/src/lib/mina_wire_types/mina_base/mina_base_account_id.ml","/workspace_root/src/lib/mina_wire_types/mina_numbers.ml","/workspace_root/src/lib/mina_wire_types/mina_base/mina_base_call_stack_digest.ml","/workspace_root/src/lib/mina_wire_types/mina_base/mina_base_coinbase_fee_transfer.ml","/workspace_root/src/lib/mina_wire_types/mina_base/mina_base_coinbase.ml","/workspace_root/src/lib/mina_wire_types/mina_base/mina_base_fee_transfer.ml","/workspace_root/src/lib/mina_wire_types/mina_base/mina_base_pending_coinbase.ml","/workspace_root/src/lib/mina_wire_types/mina_base/mina_base_signed_command_memo.ml","/workspace_root/src/lib/mina_wire_types/mina_base/mina_base_signed_command.ml","/workspace_root/src/lib/mina_wire_types/mina_base/mina_base_sok_message.ml","/workspace_root/src/lib/mina_wire_types/mina_base/mina_base_stack_frame.ml","/workspace_root/src/lib/mina_wire_types/mina_base/mina_base_staged_ledger_hash.ml","/workspace_root/src/lib/mina_wire_types/mina_base/mina_base_zkapp_command.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/ast/ast_helper_lite.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/uchar.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/stdlib0.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/location.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/code_matcher.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/migrate_414_413.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/migrate_413_414.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/migrate_413_412.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/migrate_412_413.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/migrate_412_411.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/migrate_411_412.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/migrate_411_410.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/migrate_410_411.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/migrate_410_409.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/migrate_409_410.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/migrate_409_408.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/migrate_408_409.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/migrate_408_407.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/migrate_407_408.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/migrate_407_406.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/migrate_406_407.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/migrate_406_405.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/migrate_405_406.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/migrate_405_404.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/migrate_404_405.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/migrate_404_403.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/migrate_403_404.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/astlib/migrate_402_403.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/ast/import.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/ast/ast.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppx_derivers/ppx_derivers.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/traverse_builtins/ppxlib_traverse_builtins.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/longident.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/code_path.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/location.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/ast/location_error.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/expansion_context.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/ast_traverse.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/spellcheck.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/ast_pattern0.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/ast_builder_generated.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/ast_builder.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/caller_id.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/common.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/ast_pattern_generated.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/ast_pattern.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/extension.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/context_free.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/driver.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/merlin_helpers.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ppxlib/ignore_unused_warning.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base_quickcheck/ppx_quickcheck/expander/clause_syntax.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base_quickcheck/ppx_quickcheck/expander/field_syntax.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base_quickcheck/ppx_quickcheck/expander/ppx_shrinker_expander.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base_quickcheck/ppx_quickcheck/expander/ppx_generator_expander.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base_quickcheck/ppx_quickcheck/expander/ppx_observer_expander.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base_quickcheck/ppx_quickcheck/expander/ppx_quickcheck_expander.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base_quickcheck/ppx_quickcheck/ppx_quickcheck.ml","/workspace_root/src/lib/crypto/kimchi_backend/kimchi_backend.ml","/workspace_root/src/lib/pickles/backend/backend.ml","/workspace_root/src/lib/snarky/group_map/bw19.ml","/workspace_root/src/lib/cache_dir/fake/cache_dir.ml","/workspace_root/src/lib/snarky/group_map/group_map.ml","/home/fok/codes/o1-labs/mina/_opam/lib/base64/base64.ml","/workspace_root/src/lib/snarky_group_map/checked_map.ml","/workspace_root/src/lib/snarky_group_map/snarky_group_map.ml","/workspace_root/src/lib/pickles/one_hot_vector/one_hot_vector.ml","/workspace_root/src/lib/pickles_base/domains.ml","/workspace_root/src/lib/pickles/limb_vector/make.ml","/workspace_root/src/lib/pickles/limb_vector/challenge.ml","/workspace_root/src/lib/pickles/composition_types/digest.ml","/workspace_root/src/lib/pickles/composition_types/spec.ml","/workspace_root/src/lib/pickles/pseudo/pseudo.ml","/workspace_root/src/lib/base58_check/version_bytes.ml","/workspace_root/src/lib/codable/codable.ml","/workspace_root/src/lib/snarky_log/snarky_log.ml","/workspace_root/src/lib/pickles/import.ml","/workspace_root/src/lib/pickles/util.ml","/workspace_root/src/lib/pickles/endo.ml","/workspace_root/src/lib/pickles/common.ml","/workspace_root/src/lib/snarkyjs/src/bindings/ocaml/lib/snarky_bindings.ml","/workspace_root/src/lib/pickles/make_sponge.ml","/workspace_root/src/lib/pickles/tick_field_sponge.ml","/workspace_root/src/lib/pickles/dummy.ml","/workspace_root/src/lib/pickles/wrap_main.ml","/workspace_root/src/lib/pickles/commitment_lengths.ml","/workspace_root/src/lib/pickles/evaluation_lengths.ml","/workspace_root/src/lib/pickles/ro.ml","/workspace_root/src/lib/pickles/compile.ml","/workspace_root/src/lib/pickles/sponge_inputs.ml","/workspace_root/src/lib/pickles/tock_field_sponge.ml","/workspace_root/src/lib/pickles/wrap_hack.ml","/workspace_root/src/lib/pickles/wrap_proof.ml","/workspace_root/src/lib/pickles/tag.ml","/workspace_root/src/lib/pickles/inductive_rule.ml","/workspace_root/src/lib/pickles/types_map.ml","/workspace_root/src/lib/pickles/per_proof_witness.ml","/workspace_root/src/lib/pickles/unfinalized.ml","/workspace_root/src/lib/pickles/requests.ml","/workspace_root/src/lib/pickles/timer.ml","/workspace_root/src/lib/pickles/fix_domains.ml","/workspace_root/src/lib/pickles/verification_key.ml","/workspace_root/src/lib/pickles/wrap_domains.ml","/workspace_root/src/lib/pickles/wrap.ml","/workspace_root/src/lib/pickles/wrap_deferred_values.ml","/workspace_root/src/lib/pickles/verify.ml","/workspace_root/src/lib/pickles/step_main.ml","/workspace_root/src/lib/pickles/step_branch_data.ml","/workspace_root/src/lib/pickles/step.ml","/workspace_root/src/lib/pickles/dirty.ml","/workspace_root/src/lib/pickles/cache_handle.ml","/workspace_root/src/lib/crypto_params/group_map_params.ml","/workspace_root/src/lib/crypto_params/crypto_params.ml","/workspace_root/src/lib/bignum_bigint/bignum_bigint.ml","/workspace_root/src/lib/snarky_field_extensions/field_extensions.ml","/workspace_root/src/lib/snarky_curves/snarky_curves.ml","/workspace_root/src/lib/mina_stdlib/list.ml","/workspace_root/src/lib/mina_stdlib/result.ml","/workspace_root/src/lib/snark_bits/bits_intf.ml","/workspace_root/src/lib/snark_params/snark_util.ml","/workspace_root/src/lib/snark_params/snark_intf.ml","/workspace_root/src/lib/data_hash_lib/data_hash.ml","/workspace_root/src/lib/crypto/kimchi_bindings/pasta_fp_poseidon/kimchi_pasta_fp_poseidon.ml","/workspace_root/src/lib/hash_prefixes/hash_prefixes.ml","/workspace_root/src/lib/hash_prefix_states/hash_prefix_states.ml","/workspace_root/src/lib/test_util/test_util.ml","/workspace_root/src/lib/non_zero_curve_point/compressed_poly.ml","/workspace_root/src/lib/snarkyjs/src/bindings/ocaml/lib/local_ledger.ml","/workspace_root/src/lib/signature_lib/public_key.ml","/workspace_root/src/lib/sparse_ledger_lib/inputs.ml","/workspace_root/src/lib/dummy_values/dummy_values.ml","/workspace_root/src/lib/mina_base/proof.ml","/workspace_root/src/lib/unsigned_extended/intf.ml","/workspace_root/src/lib/mina_numbers/nat.ml","/workspace_root/src/lib/mina_numbers/intf.ml","/workspace_root/src/lib/mina_numbers/zkapp_version.ml","/workspace_root/src/lib/mina_numbers/account_nonce.ml","/workspace_root/src/lib/mina_numbers/global_slot_intf.ml","/workspace_root/src/lib/mina_numbers/global_slot_legacy.ml","/workspace_root/src/lib/mina_numbers/global_slot.ml","/workspace_root/src/lib/mina_numbers/hd_index.ml","/workspace_root/src/lib/mina_numbers/index.ml","/workspace_root/src/lib/mina_numbers/length.ml","/workspace_root/src/lib/mina_numbers/mina_numbers.ml","/workspace_root/src/lib/currency/intf.ml","/home/fok/codes/o1-labs/mina/_opam/lib/re/core.ml","/home/fok/codes/o1-labs/mina/_opam/lib/graphql_parser/graphql_parser.ml","/workspace_root/src/lib/fields_derivers_zkapps/fields_derivers_js.ml","/workspace_root/src/lib/data_hash_lib/data_hash_intf.ml","/workspace_root/src/lib/block_time/intf.ml","/workspace_root/src/lib/quickcheck_lib/quickcheck_lib.ml","/workspace_root/src/lib/mina_base/util/mina_base_util.ml","/workspace_root/src/lib/mina_base/account_id_intf.ml","/workspace_root/src/lib/mina_base/hash_prefix.ml","/workspace_root/src/lib/mina_base/data_hash.ml","/workspace_root/src/lib/mina_base/token_id.ml","/workspace_root/src/lib/mina_base/fee_excess.ml","/workspace_root/src/lib/mina_base/ledger_hash_intf0.ml","/workspace_root/src/lib/mina_base/frozen_ledger_hash0.ml","/workspace_root/src/lib/mina_base/signed_command_memo_intf.ml","/workspace_root/src/lib/mina_base/transaction_union_payload.ml","/workspace_root/src/lib/mina_base/signed_command_intf.ml","/workspace_root/src/lib/mina_base/side_loaded_verification_key.ml","/workspace_root/src/lib/mina_base/state_hash.ml","/workspace_root/src/lib/mina_base/verification_key_wire.ml","/workspace_root/src/lib/mina_base/ledger_hash.ml","/workspace_root/src/lib/mina_base/ledger_hash_intf.ml","/workspace_root/src/lib/mina_base/frozen_ledger_hash.ml","/workspace_root/src/lib/mina_base/digest_intf.ml","/workspace_root/src/lib/mina_base/zkapp_statement.ml","/workspace_root/src/lib/mina_base/prover_value.ml","/workspace_root/src/lib/mina_base/zkapp_call_forest.ml","/workspace_root/src/lib/mina_base/fee_transfer_intf.ml","/workspace_root/src/lib/mina_base/coinbase_fee_transfer_intf.ml","/workspace_root/src/lib/mina_base/coinbase_intf.ml","/workspace_root/src/lib/mina_base/pending_coinbase_intf.ml","/workspace_root/src/lib/run_in_thread/fake/run_in_thread.ml","/workspace_root/src/lib/mina_base/staged_ledger_hash_intf.ml","/workspace_root/src/lib/mina_base/stack_frame.ml","/workspace_root/src/lib/mina_base/sparse_ledger_base.ml","/workspace_root/src/lib/mina_base/sok_message_intf.ml","/workspace_root/src/lib/mina_base/pending_coinbase_witness.ml","/workspace_root/src/lib/mina_base/call_stack_digest_intf.ml","/workspace_root/src/lib/mina_base/call_stack_digest.ml","/workspace_root/src/lib/mina_base/ledger_intf.ml","/workspace_root/src/lib/mina_base/mina_base.ml","/home/fok/codes/o1-labs/mina/_opam/lib/js_of_ocaml-compiler/runtime/jsoo_runtime.ml","/home/fok/codes/o1-labs/mina/_opam/lib/js_of_ocaml/js.ml","/workspace_root/src/lib/snarkyjs/src/bindings/ocaml/lib/util.ml","/workspace_root/src/lib/snarkyjs/src/bindings/ocaml/lib/snarky_js_bindings_lib.ml","/workspace_root/src/lib/snarkyjs/src/bindings/ocaml/snarky_js_node.ml","/home/fok/codes/o1-labs/mina/_opam/lib/ocaml/std_exit.ml"],"mappings":"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cAC;KC4DWC;KANJC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KCg4BPC;KACAC;;KC/WgBC;;;;;;;;;;;;;;KA0GVC;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA+HAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAGAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAoUgCC;;;;;;;;;;;;;;;;;;;;;;;;KAtjC5BC;KA9CZC;;KAIAC;;;;;;;;;;;;;KA+HAC;KCsyBEC;KACAC;KCGAC;KACAC;KCfAC;KACAC;KCDAC;KACAC;KCFAC;KACAC;KCUAC;KACAC;KCxFAC;KACAC;KCCAC;KACAC;KCpBAC;KACAC;KCHAC;KACAC;KCJAC;KACAC;KCrCAC;KACAC;KCmIIC;KA39BAC;;;;KCqYJC;KAOAC;KAOAC;KAOAC;KAOAC;KAOAC;KAOAC;KAOAC;KAOAC;KAOAC;;KAcAC;KAOAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KC/NEC;KAhJAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAuKWC;KC1KXC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KC2I8BC;KAAN7oC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;qBAGAD;qBAMAe;qBAMAD;;qBtL1GEioB;qB4U6LIQ;kBTvXK;mBSmUqB;;;;;;;;uB/T9I1BvoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBbiBJ7H;uB4U+LIqwB;mBAlE0B;;;;uBhWvSbj3B;;;uB6MiDjBxN;uBAaAM;uB7MjCE1O;uBA7Be2b;uBwMyaf3jB;uBEjYI2mB;uB1MxCW9C;uB6MHjBxwD;uB7MGiBqwC;;;;;;uBwM6ZfI;uBADAD;uBxM5ZeG;;;;;;;;uB0MwCX6gB;;;;uBACAG;;;;;;;;;uB1MzCWS;;uB0M8CnBiB;uB1M9CmBtuF;uBCoDHC;uBDpDGC;;;;;;;uB0MqFnBwuF;uBACAD;uB1MtFmBhB;;uB0M2FnBkB;uB1M3FmB5C;;;;;;uB0MiHX6C;;;;;uB1MjHW7zD;;;;;;;;uBUtBjBinD;uBVsBiB4J;;;;uB6MkGjBjN;uBAaAI;uB7M/GiBgP;;uB6MyJjB7O;uB7MzJiBG;;;uBE6LJrzH;uBAAHF;uBF7LO4/H;;;;;;;;;;uBoB0HjBi2B;uB4U6PIe;mBAhF0B;;;;qBtJrQhCr7B;qBAIQ0B;;qBGkCNxK;qBAgBAG;;qBpLeF0I;qB+K0ZIvf;;qBEzdIyf;qBG1CNjsD;qBH0CM6wC;;;;;;qBF6cJI;qBADAD;qBE5cIG;;;;;;;;qBmF+KE+a;;;;qBACAG;;;;;;;;;qBnF9KFS;;;;qBoBAQjtD;;qBpBWhByuD;qBACAD;qBACAD;qBAGAM;qBAKAnB;;qBAsBAqB;qBACAD;qBACAR;qBACAb;qBAGAuB;qBA2CAxB;qBAEAD;qBACAD;;qBAWAD;qBAGAD;qBAtCQ6B;;;;;;;;qBAeRL;qBAMApB;qBAEAD;qBACAD;;qBAIAtG;qBAOAqG;qBAGAD;qBAIAuB;qBACAD;qBGhCE5K;qBAkBAC;qB7M9IiBI;qB6MyJjBH;;;qBHkBF4J;qBAmDAV;qBGpOEhtD;qBADAD;qBHkPFktD;;qBAIAW;qBAIAC;qBAGAG;qBAGAD;qBAGAD;qBAMAuB;qBAMAD;;qBtLpGEy3B;qB4UiOIU;kBTjaK;m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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAwBAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAIAC;;;;;;;;;;qBAJAD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAWAE;;;;;;;;;;qBAXAF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAkBAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAIAC;;;;;;;;;;qBAJAD;;;;;;;qBAIAC;;;;;;qBAJAD;;;;;;;;;;;;;;;;;;;;;;;;;;qBAIAC;;;;;;qBAJAD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAWAE;;;;;;;;;;qBAXAF;;;;;;;qBAWAE;;;;;;qBAXAF;;;;;;;;;;;;;;;;;;;;;;;;;;qBAWAE;;;;;;qBAXAF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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lDyB;wBADhB;;qEqCnlDTA;uC2C1bgF;;wBhFkhE7D;iCqCxlDnBA,WrCwlDmB,+BqCxlDnBA,Y2CzbsE;;wBhFuhEtE;iCqC9lDAA,WrC8lDA,sBqC9lDAA,e2Cxb0E;;wBhF4hE1E;iCqCpmDAA;iCrComDA,uCqCpmDAA,e2CrbwD;;wBhF+hExD;iCqC1mDAA;iCrC0mDA,oCqC1mDAA,e2ClbkF;;wBACjE,kB3CibjBA,iB2Cjb4D;;wBhFm9D9D,qBACE,gBqCniDAA,gBrCmiDyB;wBADhB;0EqCliDTA,kB2Chb8E;;wBhFu9D3D;iCqCviDnBA,WrCuiDmB,8BqCviDnBA,Y2C/aoE;;wBAC3C,sB3C8azBA,mB2C9a4E;;wBhF29D5E;iCqC7iDAA,WrC6iDA,qBqC7iDAA,e2C7awE;;wBhFg+DxE;iCqCnjDAA;iCrCmjDA,sCqCnjDAA,e2C1auD;;wBhFm+DvD;iCqCzjDAA;iCrCyjDA,mCqCzjDAA,e2CvagF;;wBAC9D,kB3CsalBA,iB2Cta8D;;wBhFohE3C;iCqC9mDnBA;iCrC8mDmB,4CqC9mDnBA,Y2CnaoE;qDAG5C,wBAAsC;oD3C+ZtDivC,QAAQC;wBAEpB;;oDADIlvC,WADQivC,QAAQC;;uD,OpCk3DhBp8B,UoCj3DA9S,mB2C7Z2D;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA8J3D;;;;;kBpDzZO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBoDqec,mCAAyB;;wBhFq1CV,0CgFl1C4B;;;0BASnC,oDAAsC;;;;0BhF21CrE,egFt1CE;0BhF0rBF;4BAG6C;qFAA8B;0BADnE;;8C9IlqCJzI,oB8IkqCyB;yCgF5rB8C;;;wBAlD3E;;;;;;;;;;;;;;;iD,6BAA2C;wBAA3C;;;;;qFAA2C;wBAA3C;;;;;iEAA2C;wBAA3C;;;;;;0BAUgB;wDAA8B,iCAAa,EAAC;;0BAG1D,kBAAoC,yBAAO;0BAnFrC;0BACP,qBACE;0BAFK;;4BAKF;yD;0BAAA,sBACO;0BACY,qBA4EgD;;;;;;;;;;;;;;wBhFwrDrE,8CgFr4DkD;6CAErC,WAAI;;wBACL,uB,mBAAuB;;wBhFqlDrC,sDgFplDqE;;wB;uChFwlDvE,2CgFvlDmD;;wBhF0nDnD,8CgFvnDoD;;wBhF6nDlD;yFgF1nDmE;;wBhF8nD/D;;;wBACqB,QgF9nDgB;;wB;;iChFmoD3C;yCgFloD6D;;wBhFqoDrB,kDgFpoDW;;wBhFuoD/C,4CgFtoDmD;;wBhF0oDnD;mCgFzoDmE;;wBhF6oDnE,0DgF5oD2D;;wBhFglDzD;;;wBACqB,QgFhlDU;;wB;uChFqlDrC,mDgFplDuD;;wBACpC,mCAA0B;;wBAxLrC,sCAyL+D;;wBhFwlDnE,yCgFvlD6C;;wBhF2lD7C,0DgF1lD6D;;wBhF8lD7D,uDgF7lDqD;;wBhFimDnD;;;wBAEqB,QgFlmDoB;0CAEjC,QAAC;6ChFwoDf,oCgFvoDyC;2ChF0oD1B,oBgFzoDU;yChF0oDZ,mBgFzoDQ;;wBACA,mCAA4B;;wBAC5B,mCAA4B;;wBACxB,uCAAgC;;wBhF6pDzD,+CgF5pD6D;;wBhFiqD7D,2CgFhqDiD;;wBhFoqDjD,oCgFnqD6C;6CAC3B,iCAAyB;;wBhF0qD3C;;;;gDAA8C,6BAAQ,EgFzqDX;;wBhF6qD3C,kDgF5qDyC;yChForDzC,gCgFnrDiC;2CAClB,+BAAsB;wChFyrDX,+BgFxrDK;4ChF+rD/B,mCgF1rDyC;;wBhFmsDzC,wCgF9rDqD;;wBhFksDjD,wCgFjsD6C;2ChFqsD7C,qCgFpsDmC;;wBhFwsDnC,oCgFvsDqC;;wBhF2sDrC,yCgF1sD2C;;wBhF8sD3C,wCgF7sD6C;;wBhFktD/C;;;;;sCgFjtDqD;;wBhFwtDrD;;;;;sCgFvtDmD;;wBhF8tDnD;;;;;sCgF7tDmD;;wBhFouDnD;;;;;sCgFnuDiD;;wBhF2uDjD;;;yCgF1uD+C;;wBhFivDjD,sCgFhvDyD;4ChFovDzD,oCgFnvDuC;;wBhF6vDvC,qDgFvvD6E;;wBhF2vD7E;qEgFxvDwD;;wBhFkwDpD,sCgF/vDqC;0ChF4wDf,iCgFjwDS;;wBhFowDnC,oDgFnwD6E;;wBhFwwD3E;;;kCgFrwD8C;;wBhF+wDhD,2DgF3wDqD;;wBhFqxDrD,8CgFlxDqE;;wBhFsxDrE,uCgFrxDmD;;wBACzC,uB,O/EopENsb,0B+EppEuB;;wBACb;0BhFuxD+B,8CgFvxDV;2ChF0xDnC,8BgFzxDiC;;;wBhFmyDjC;;;;;mCgFhyDiF;;wBhFwyDhC,uCgFryD4B;;wBhFwyD7E,kDgFryDqD;;wBA1QC,kDA6QM;;wBAxT5D,gDAyToE;wDAlT3C,oBAmT8B;;wBAhTvD,kDAiTmE;;wBhF6wD7B,uCgF7nDuC;;;0BAQ5C,qCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BzF7bnEP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kByF0lBH;;kB9XrqBGuV;kBI4HFwV;kBsUrIS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBtUoITD;kBJ5HExV;kB+XVN;;kBrDEa;mBqDFb;sCtC0F0B,uCsC5DgD;mBA9B1E;;sBxC2NE,gBAAY2lC;wBACO,IAAbvtD,WADMutD;wBAKH,sB,UAJHvtD;wBAEF;yBADElqH;0BACF;4BACE,4BAHAkqH;;;0CACAlqH,EAFMy3K,MAQI,CwCnMwD;mBAhC1E,0BAkDmD,wBAAe;mBAlDlE;;sBAqD6B;sBtEFL;;;mDsEEwC,4BtEFmB,EsEEC;mBArDpF;;sBAyDI,0BACE,4BAAmB;sBADM;qEACL;mBA1D1B;;sB,I5CgqBMvtD;6C4Clfe,U5CkffA,gB4ClfuC;;wBACL,mC5CiflCA,iB4Cjf6E;;wBAG/E,wC5C8eEA,iB4C9ekD;;wBvF0rCpD,qBAEkB,U2C9sBhBA,gB3C8sBoC;wBADpC,gC2C7sBAA;wB3C6sBA,+CuFxrCyD;;4CvFqqCV,U2C1rB/CA,iB4CteqC;;wBvFmqCnB,U2C7rBlBA,W3C6rBkB,W2C7rBlBA,sB4CreuC;0CAC3B,iB5CoeZA,a4CpeiC;;wBAzDf,U5C6hBlBA,W4C7hBkB,Y5C6hBlBA,c4CneyC;;wBAtDvB,U5CyhBlBA,W4CzhBkB,gB5CyhBlBA,c4CleiD;;wBvFwrC9B,U2CttBnBA,W3CstBmB,a2CttBnBA,e4CjemC;;wBvF2rCrC,4B2C1tBEA,c4CheuD;;wBvF8rCpC,U2C9tBnBA,W3C8tBmB,c2C9tBnBA,e4C/d+B;;wBvFksCxB,U2CnuBPA,W3CmuBO,oB2CnuBPA,e4C9d6C;;wBAGvC,gC5C2dNA,2B4C3dwD;oD5C0dhD6rC;wBAEZ,oCADI7rC,WADQ6rC;;uD,UACR7rC,mB4Cvd+D;;;;;;;;;;;;;;;;;;;mBAzMrE;kBAmUM;kBrDjUO;;;;;;;;;;;;;;;;;;;;;;;8CqDyYS,4BAAoB;4CvFwxBV,gCuFvxB2B;;;0BAQlC,wCAA4B;;;;0BvFsyBjD,euFlyB0B;0BvFsab;;8CxI5yBTzI,oBwI4yB8B;yCuFtaiD;;0BAI/E;+CAAa,iBAAoC;;;wBAlDrD;;;;;;;;;0BAUgB,+BAAoB,wBAAK,EAAG;;0BAG1C,kBAAoC,yBAAO;0BA9ErC;0BACP,qBACE;0BAEH;4BAGQ;qCACE;qCACA,yBAA4B;0BAHpC,gCAAgB,2BAwEuD;;;;;;;;;;;;;4CAxKzD,YAA4B;+CvFggCiB,kCuF//Bf;yCvF8/BjC,kBuF7/Ba;2CvF+/BX,oBuF9/Be;6CvF+/Bf,kBuF9/Be;0CvF+/BhB,mBuF9/Bc;gDvF+/BV,qBuF9/BkB;0CvF+/BtB,mBuF9/Bc;gDvF+/BV,qBuF9/BkB;2CvF+/BvB,gBuF9/Ba;+CvF+/BT,oBuF9/BiB;0CACpB,mBAAc;2CvF+/Bb,oBuF9/Be;yCvF+/BhB,kBuF9/Bc;;wBvFihCiC,+CuFhhCf;2CvF8/B9B,oBuF7/BgB;4CvF8/Bf,qBuF7/BiB;0CvF8/BnB,mBuF7/Be;0CvF8/Bf,mBuF7/Be;yCvF8/BhB,kBuF7/Bc;6CvF8/BV,sBuF7/BkB;6CvF8/BlB,sBuF7/BkB;8CvF8/BhB,uBuF7/BoB;;wBvF8/Bd,uB,oCuF7/B0B;oDvF8/B1B,6BuF7/B0B;;wBACzB,iCAAsC;wCvF6/BZ,gCuF5/Bf;2CvF6/BqB,kCuF5/Bf;;wBvF6/BuB,sCuF5/Bf;;wBvF+/Bf,sCuF9/BmB;wCAC5C,4BAAwB;wCACxB,4BAAwB;2CACrB,+BAA2B;8CvFkgCiB,iCuFjgCf;8CvFkgCe,iCuFjgCf;6CvFkgCa,gCuFjgCf;;wBvFogCF,0CuFngCsB;;wBvFsgCX,sCuFrgCW;4CvFsgCH,mCuFrgCf;;wBvFsgCyB,oCuFrgCf;;wBvFwgChB,wCuFvgCoB;0CAC5C,8BAA0B;gDACtB,gCAA8B;;wBAC1B,oCAAkC;2CvFwgCC,kCuFvgCf;;wBvF0gCK,iDuFzgC6B;;wBvF6gC5E,4CuF1gCyD;;wBvF8gCpB,uCuF3gCmB;;wBvF8gC3B;4D,gBuF7gCiB;;wBvFghCN,0CuF/gCsB;;wBvFmhCzB,sCuFlhCmB;0CvFqhCD,iCuFphCf;wCvFqhC5B,iBuFphCY;;wBvFqhC6C,sCuFphCf;4CACxC,QAAC;0CACD,QAAC;;;wBvFwhCf;yFuFrhC4E;;wBvFwhC3B,uCuFrhCiC;;wBvFwhClF,kDuFrhC0D;;;wBvFyhC1D;;;;;;mCuFrhCqF;6C,iCAIzC;;wBvF6hC3B,oDuF1hC6C;;wBvFkiC7C;;;yBA5QX;wBADA;0EuFpxB8C;;;wBApQpD,gDAuQoE;wDAnQ/C,oBAoQkC;;wBAhQvD,kDAiQmE;gDA4I/C,8BAAoB;8CvF62BZ,6BuF52BkC;;;0BAS1D,2CAAoE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA+IzE;;kB/X9jBGswB;kBI4HFwV;kBsUrIS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBtUoITD;kBJ5HExV;kBgRVN;;kBAkEG;;kBhRvDGC;kBI4HFwV;kBADAD;kBJ5HExV;kBgYVN;;kBtDEa;mBsDFb;oC;mBAAA;;;;;;;;uBhH2MW/uE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBgH3MX;;;;;;;;;uBhH2MWA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBgH3MX;;;;;;;;;;;;;;uBhH2MWA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBgH3MX;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA4MG;;kBhYjMGgvE;kBI4HFwV;kBsUrIS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uB1DmCX7qC;uBAEAC;uBAGAoN;uBAMAC;uBAEAC;uBAEQC;uBACAC;;;;;;;uDADAD;;;;;;;;;;;;;8BAfRxN;8BAEAC;8BA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KADxBuqI,SACuE;wBAD5D;gCA9Vf1xI;;;;;;;;;;;;;;;;;gCA+VImwJ;gCA/VJ70E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCA4VA8nG;sBAtVa;8BANbv2D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCAWK;mBAnBT;;kBA6W8B;;kBxYlWxB4qB;kBI4HFwV;kBADAD;kBJ5HExV;kByYRN;;kB/DAa;mB+DAb;;;uBA4CItwB;uBAEQ3wC;;;;;;;uBAONm7D;;8BAPMn7D;8BAFR2wC;8BAEQr0B;8BAON6+C;;;;mBArDN;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBA0EIxqB;uBAEQr0B;uBAON6+C;;8BATFxqB;8BAEQr0B;8BAON6+C;;;;mBAnFN;;;;;;;;;;;;;;;;;;;;;;;;;;kBAgIG;;kBzYvHG+F;kBI4HFwV;kBADAD;kBJ5HExV;kB0YVN;;kBAiHG;;kB1YtGGC;kBI4HFwV;kBsUrIS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uB+D6EJq2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBrYuDLt2B;kBJ5HExV;kB2YVN;;kBjEEa;mBiEAb;;mBAA0C;oC;kBAAA;kBjEA7B;mBiEKP;;mBAAqC;oC;mBAAA,kBzE8EvCyR,c9HPArD;mBuMvEuC,kB3EwGvCsB;mB2ExGuC;;;qBzE8EvC+B;qB9HPArD;qB4HiCAsB;;;;;;mB2ExGuC;;;;qB5SmsBjCloC;qBgE1gBJxB;;;;;;;;;qB4B8CA0G;qBADAD;;;;;;;;;qBqFjBKipB;;;;mB2HrNgC,qB;mBAAA;;;;kBAkBvC;kBAED;;kB3YhBGuK;kBI4HFwV;kBADAD;kBJ5HExV;kB4YKN;;kBAsHG;;kB5Y1HGC;kBI4HFwV;kBADAD;kBJ5HExV;kB6YVN;;kBAW4B,sBAAC,WhN8RhBH;kBgNzIV;;kB7YrJGI;kBI4HFwV;kBADAD;kBJ5HExV;kB8YVN;;kBpEEa;mBoEWP;;mBAAmC;oC;mBAAA,kB5EkHrC+R,gB9HqCApD;mB0MvJqC,kB9E4QrCsB;mB8E5QqC;;;qB5EkHrC8B;qB9HqCApD;qB4HqHAsB;;;;;;qBrI+XEnjC;qBAaArF;qBACAxB;;kBmNzpBmC;;qB5EkHrC8rC;qB9HqCApD;qB4HqHAsB;;;;;;qBrI4YExoC;qBAbAqF;qBAcA7G;;kB+IpqBO;mBoE4BT;;mBAAmC;oC;mBAAA,kB5EiGnC8rC,gB9HqCApD;mB0MtImC,kB9E2PnCsB;mB8E3PmC;;;qB5EiGnC8B;qB9HqCApD;qB4HqHAsB;;;;;;qBrI4YExoC;qBACAxB;qBqFreKsX;kB8HnK4B;;;qB5EiGnCw0B;qB9HqCApD;qB4HqHAsB;;;;;;qBrI4YExoC;qBqFpeK6V;qBrFqeLrX;;kBmNxoBiC;kBpE5B1B;mBoEyCP;;mBAAmC;oC;mBAAA,kB5EoFrC8rC,gB9HqCApD;mB0MzHqC,kB9E8OrCsB;mB8E9OqC;;;qB5EoFrC8B;qB9HqCApD;qB4HqHAsB;;;;;;mB8E9OqC;;;;qBnN0nBnCxoC;qBACAxB;;;;;;;;;qBAbA8G;qBADAD;;;;;;;;;;;;qBsCroBF/7F;mB6KwBqC,2B;mBAAA;;;;;;;;;;;;;;;;sBAkBvC,0CAA6D;mBAlBtB;;sBAqCvC,sDAA4E;kBAK3D;;kB9Y1EbkvH;kBI4HFwV;kBADAD;kBJ5HExV;kB+YVN;;kBrEEa;mBqEIT;;mBAA2C;oC;kBAAA;kBA4B+B;;kB/YvBxEC;kBI4HFwV;kBADAD;kBJ5HExV;kBgZVN;;;kBtEEa;mBsEKP;;mBAAiC;oC;mBAAA,mB9EoGnC0R,c9HkBAlD;mB4MtHmC,mBhFuRnC0B;mBgFvRmC;;;qB9EoGnCwB;qB9HkBAlD;qB4HiKA0B;;;;;;mBgFvRmC;;qBnTa/BlzB;;;;;;;;;;;;;;;;;;;;;;;;;;mBmTb+B,qB;mBAAA;;;;;mBAgBnC;;mBAAiC;oC;mBAAA,mB9EoFjC00B,c9HkBAlD;mB4MtGiC,mBhFuQjC0B;mBgFvQiC;;;qB9EoFjCwB;qB9HkBAlD;qB4HiKA0B;;;;;;;;qBhD7FO7yB;kBgI1K0B;;;qB9EoFjCq0B;qB9HkBAlD;qB4HiKA0B;;;;;;;qBhD7FO9yB;;;kBgItJiE;;kBhZhCtE6iB;kBI4HFwV;kBADAD;kBJ5HExV;kBiZVN;;kBAauC;;kBjZFjCC;kBI4HFwV;kBADAD;kBJ5HExV;kBkZVN;;kBxEEa;mBwEGT;;mBAI4D;oC;mBAAA,8BAJ5D,QAI4D;;;sBAJ5D;;;qEAI4D;;;;sBAJ5D,gDAI4D;;;sBAJ5D;;;+BACE,gBACA,iBACA,SAC0D;;;;kBxEPnD;mBwEOmD;;;;;;;;;;;;;;;;;;qBvZ2D1DhpB;qBAJAJ;qBAEAE;qBACAC;qBAJAJ;qBAEAE;qBAOAO;qBADAD;qBAGAG;qBADAD;qBAJAJ;qBACAC;;;;;;;;;mBuZ7D0D,2B;mBAAA;;;kBAMlB;;kBlZJxC+oB;kBI4HFwV;kBADAD;kBJ5HExV;kBmZVN;;kBzEEa;mByEuBX;;mBAA2C;oC;mBAAA,mBjF0GzCgS,e9HuDAnD;mB+MjKyC,mBnFkSzCuB;mBmFlSyC;;;;;;;;;uBjF0GzC4B;uB9HuDAnD;uB4HiIAuB;;;;;;;uBrIQExjC;uBAcAkyB;;mBwNxTuC;;;;;uBjF0GzCkT;uB9HuDAnD;uB4HiIAuB;;;;;;uBrIQExjC;;uBAcAkyB;;mBwNxTuC;;;;;;;;;qBxN2SvCjyB;qBADAD;;;mBwN1SuC;;sB;;wBA4BlB,+CAAyC;6CAC9C,kBAAO;;wBACR,oDAAkB;;wBACd,8CAAyC;6CAC7C,oBAAM;6CACD,wBAAQ;;wBAGpB;wBACR;;oEAIM;;;;;;;;;;kBAiBV;kBAmCkE;;kBnZ3G9DqzB;kBI4HFwV;kBADAD;kBJ5HExV;kBoZVN;;kB1EEa;mB0EKP;;mBAA4C;oC;mBAAA,mBlFqG9C2R,a9HwBAlD;mBgN7H8C,mBpF8R9C0B;mBoF9R8C;;;qBlFqG9CwB;qB9HwBAlD;qB4HiKA0B;;;;;;;qBrIkFEzoC;qBb9QEyb;qBenCEb;kB6IpEG;mB0EgBP;;mBAAgC;oC;mBAAA,mBlF0FlCqvB,a9HwBAlD;mBgNlHkC,mBpFmRlC0B;mBoFnRkC;;;qBlF0FlCwB;qB9HwBAlD;qB4HiKA0B;;;;;;mBoFnRkC;;qBpPA9BxgC;;qB2BqWFjI;qBb9QEyb;;qBkBhFJ/xD;qB4CsIEu5C;qBAJAJ;qBAEAE;qBACAC;qBAJAJ;qBAEAE;qBAOAM;;qBAEAE;qBADAD;qBAHAH;qBACAC;;;;qB/C5FIyX;;;;;mBuNpD4B,qB;mBAAA;;;;;;;;;;;;;;;;;;;kBAWpC;kBAS4E;;kBpZ3BxE2d;kBI4HFwV;kBsUrIS;;;qB9F6JP9qC;qBAJAJ;qBAEAE;qBACAC;qBAJAJ;qBAEAE;qBAOAM;;qBAEAE;qBADAD;kBxO9BFyqC;kBJ5HExV;kBqZVN;;kB3EEa;mB2EGP;;mBAAkC;oC;mBAAA,mBnFwIpCiS;mBmFxIoC,mBrFgUpC5B;mBqFhUoC;;;qBnFwIpC4B;;qBFwLA5B;;;;;;mBqFhUoC;;;qBzYoHtCxa;qB+KsSIluB;qBEzVI0xB;;qBG5CNz+D;qBH4CM68D;;;;;;qBF6UJS;qBADAnC;qBE5UIiC;;qBF4UJjC;qBE5UIgC;;;;;;;;;mBwNjE8B,qB;mBAAA;;;;;;;kBAUtC;kBAS8E;;kBrZb1EkI;kBI4HFwV;kBADAD;kBJ5HExV;kBuZVN;;kB7EEa;mB6EGP;;mBAAkC;oC;mBAAA,mBrFgJpCkS;mBqFhJoC,mBvFiVpC5B;mBuFjVoC;;;qBrFgJpC4B;;qBFiMA5B;;;;;;mBuFjVoC;;qBpasDlC1gC;qBA7Be2b;qBwMyaf3jB;qBEjYI2mB;qB1MxCW9C;qB6MHjBxwD;qB7MGiBqwC;;;;;;qBwM6ZfI;qBADAD;qBxM5ZeG;;;;;;;;qB0MwCX6gB;;;;mB0NjE8B,qB;mBAAA;;;;;;kB7EH3B,I7IuEHmhD;kB0NpE8B;kBAUtC;kBAS8E;;kBvZb1E3tC;kBI4HFwV;kBADAD;kBJ5HExV;kBwZVN;;kB9EEa;mB8EFb;;;;qBFuFUwtC;;;;mBEvFV,2B;mBAAA;;;;;;;;;;qB5CUiEK;;;;;;;;mB4CVjE;;sBAkBM;;;gC1OuFEb;;;;;;;yC0OpFsD;mBAGvB;;;;;;;;;;;;;;;;;;;;;;kB9EtB1B;mB8EsB0B;;;;;;;;;;;;qBpY+J/B/yC;;;;;;;;;;;;;;;;;;;;;;;;;;mBoY/J+B,qB;mBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAmDrC;kBAS8E;;kBxZzE1EgG;kBI4HFwV;kBADAD;kBJ5HExV;kByZVN;;kB/EEa;mB+EIP;;mBAAgD;oC;mBAAA;;;sBAOhD;;kFACgD;wB3EqRhDke;;;;;;;;;;;;;;;;;;kBJjSO;mB+EsBP;;mBAAiC;oC;mBAAA,mBvF4DnC1M,c9HbArD;mBqN/CmC,mBzF+EnCqB;mByF/EmC;;;qBvF4DnCgC;qB9HbArD;qB4HgCAqB;;;;;;mByF/EmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;wC;mBAAA;;;;;;kBAapB;;kBzZ1BbvP;kBI4HFwV;kBADAD;kBJ5HExV;kB0ZRN;;kBAwByB;;kB1ZfnBC;kBI4HFwV;kBADAD;kBJ5HExV;kB2ZVN;;kBjFEa;mBiFIT;;8C,gCAAwD;kBAAxD;kBAW2B;;kB3ZNzBC;kBI4HFwV;kBADAD;kBJ5HExV;kB4ZVN;;kBlFEa;mBkFGP;;mBAAsC;oC;mBAAA;sC5FoWxCuQ;mB4FpWwC;;;;;qB5FoWxCA;;;;;;mB4FpWwC;;;qBhZgI1CnpB;qB+K0ZIvf;;qBEzdIyf;qBG1CNjsD;qBH0CM6wC;;;;;;qBF6cJI;qBADAD;qBE5cIG;;;;;;;;qBmF+KE+a;;;;mB4IhPgC;oC;kBAAA;;kBAU1C;kBASkF;;kB5Zb9E0Y;kBI4HFwV;kBADAD;kBJ5HExV;kB6ZVN;;kBnFEa;mBmFKP;;mBAA6B;oC;mBAKlB;;0CAMmB,uBAAkB;mBANrC,mBjHFb7Y;mBiHEa;;sBAUX,qDAAwD;mBAV7C;;sBAcX,iDAA6D;mBAdlD;;;;qBjHFbA;;;;;;;;mBiHEa;;;;;;;;;;;;;;;;;;;;;;;;;;;;mC;kBAmCqC;;kB7ZpChD8Y;kBI4HFwV;kBADAD;kBJ5HExV;kB4SJN;;kBAI4C;;kB5SCtCC;kBI4HFwV;kBADAD;kBJ5HExV;kB8ZVN;;kBAEA;kBAQmC;;kB9ZC7BC;kBI4HFwV;kBADAD;kBJ5HExV;kB+ZVN;;kBrFEa;mBqFKT;;;;8C,gCAA+C;k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2E;;;gDvBvMN5mE,kBuBuMWvP,UAALk2E;;;gDvBvMN3mE,kBuBuMWvP,UAALi2E;;;iDvBvMN1mE,kBuBuMWvP,UAALg2E;;;iDvBvMNzmE,kBuBuMWvP,UAAL+1E;;;iDvBvMNxmE,kBuBuMWvP,UAAL81E;;;iDvBvMNvmE,kBuBuMWvP,UAAL61E;;;iDvBvMNtmE,kBuBuMWvP,UAAL41E;;;iDvBvMNrmE,kBuBuMWvP,UAAL21E;;;;;;gC4R5G4BrO;gD,OnT3FlC/3D,kBuBuMWvP;gCAAL01E;;;iDvBvMNnmE,kBuBuMWvP,UAALy1E;;;iDvBvMNlmE,kBuBuMWvP,UAALw1E;;;iDvBvMNjmE,kBuBuMWvP,UAALu1E;;;iDvBvMNhmE,kBuBuMWvP,UAALs1E;;;iDvBvMN/lE,kBuBuMWvP,UAALq1E;;sDvBvMN9lE,kBuBuMWvP,UAALo1E,KA2B8D;uBA3B9D;iCAAKn1E,QAALt5J;;;;;;;;;;;;;;;;;;;;;;;;;;;;kD4R5G4BilO,e5R4GvB3rE,SAALt5J;;kD4R5G4BilO,e5R4GvB3rE,SAALt5J;4CAAKs5J,QAALt5J;;kD4R5G4B+hO,e5R4GvBzoE,SAALt5J;4CAAKs5J,QAALt5J;4CAAKs5J,QAALt5J;4CAAKs5J,QAALt5J;4CAAKs5J,QAALt5J;4CAAKs5J,QAALt5J;4CAAKs5J,QAALt5J;kCvBvMN6oK,mBuBuMWvP,QAALt5J;kCvBvMN6oK,mBuBuMWvP,QAALt5J;kCvBvMN6oK,mBuBuMWvP,QAALt5J;kCvBvMN6oK,mBuBuMWvP,QAALt5J;kCvBvMN6oK,mBuBuMWvP,QAALt5J;kCvBvMN6oK,mBuBuMWvP,QAALt5J;kCvBvMN6oK,mBuBuMWvP,QAALt5J;kCvBvMN6oK,mBuBuMWvP,QAALt5J;;;;gC4R5G4B4gO;;kC,OnT3FlC/3D,mBuBuMWvP;8BAALt5J;;;kCvBvMN6oK,mBuBuMWvP,QAALt5J;kCvBvMN6oK,mBuBuMWvP,QAALt5J;kCvBvMN6oK,mBuBuMWvP,QAALt5J;kCvBvMN6oK,mBuBuMWvP,QAALt5J;kCvBvMN6oK,mBuBuMWvP,QAALt5J;iCvBvMN6oK,mBu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jCEJ;6BAiCF,2BAIE96Q,GAFoB,OAEpBA,SAAqB;6BAItB,0BAdCm7Q;6BAgBC,wBA5CyBN;6BA4CzB;;;8BAHHp7Q;;iD6IkUAo5G,a5LjeFk5B,a+C+JEtyI;;;;;;uC6IkUAo5G,aXndE8lE,alIiJF7rG;;;4BAtCQ,IAiDW8mC,W6IkInBJ,Y7ItLY1gF;qCAoDO8gF;;;;;0BAGnB,8BAAa;sBAuR6D;;sB9C1c1E44B;sBI4HFwV;sBADAD;sBJ5HExV;sB+gBVN;;sBAwQiB;;sB/gB7PXC;sBI4HFwV;sBADAD;sBJ5HExV;sBghBVN;;sBAGsC;;sBhhBQhCC;sBI4HFwV;sBADAD;sBJ5HExV;sBihBVN;;sBAkDsB;;sBjhBvChBC;sBI4HFwV;sBADAD;sBJ5HExV;sBkhBVN;;sB9E+EoB,I8EqEO76C,aAahB/+E,QAAS,cAATA,SAA4B;sBA4Xf;;sBlhBlhBlB65H;sBI4HFwV;sBADAD;sBJ5HExV;sBmhBVN;;sBAiDQ;;sBnhBtCFC;sBI4HFwV;sBADAD;sBJ5HExV;sBohBVN;;sBA4U8E;;sBphBjUxEC;sBI4HFwV;sBADAD;sBJ5HExV;sBsgBVN;;sBAsB6B;sBlEyDT;;iCkE5BOx3B;0BQnBF,0BCwBf,ETJW1vC;0BACjB,SAxByBnrE;4BAyBrB,eQXK4yE;8BACA,sBARErzE,KAOFqzE,IACPxL;iCAVyB,URkBV+D;;;+BQfsD,ORetDA,QQhBN5rE;8BRgBM4rE,UQRf/D;sCRUsE;4BAApE,OAHmByzC;4BAGnB;oCAAoG;0BAzB3E,aAAJ76G,EAsBF66G;iCSKrBt6G,CTFyG;sBA4Q5G;;sBtgBvTG+xI;sBI4HFwV;sBADAD;sBJ5HExV;sBqhBVN;;sBAmB6B,uBAAuB;sBAmC1B;;sBrhB3CpBC;sBI4HFwV;sBADAD;sBJ5HExV;sBshBVN;;sBA4DG;;sBthBjDGC;sBI4HFwV;sBADAD;sBJ5HExV;sBuhBVN;;sBAoGuD;;sBvhBzFjDC;sBI4HFwV;sBADAD;sBJ5HExV;sBwhBVN;;sBpF+EoB;uBoF/EpB,mBAmBen1I,GAAI,oBAAJA,GAA0B;uBAnBzC;iCAqBaqD,EAAGP;0BACV;mCpR0UsB85Q;mCoR3Ufv5Q;4CAGHk1F;qCAFe,SAEfA,UADQ,IAALv4F,EACHu4F,SADQ,kBAFFz1F,EAEH9C;qCACiB,iBAApBu4F,MAA0C;uBAxBpD;;;kCA2BYl1F,EAAGP;2BAAI;oCpRqUS+5Q,OoRrUhBx5Q,WAA8B3B,GAAK,wBAALA,EAA3BoB,EAA+C,EAAC;uBA3B/D,qBAqBQo7Q,QAOAC,OATAF;uBAnBR;;sBAiCuE;;sBxhBtBjE7oI;sBI4HFwV;sBADAD;sBJ5HExV;sByhBVN;;sBrF+EoB;uBqF/EpB;iCDUY7nE,GAAGF;0BCUT,SDViBpvD,ICcLq2D,GAAGC;4BAAM,2BAATD,MAAGC,OAA8B;0BAJ7C,SDVat7D,GCaFlW,EAAEhD,GAAK,kBAAPgD,EAAEhD,EAAQ;;gCDXrBstE,YADIE,gCACJF,GAFap0D,GAAIgF;4CpRsVK++P,yBoRtVhBzvM,GAAGF,UCcqC;uBAxBpD;6CAiBQgxM,UAEAC,QAQAC;uBA3BR;sBAmFc,WApDRC;sBA0K6B;;sBzhB9L7BnpI;sBI4HFwV;sBADAD;sBJ5HExV;sB0hBVN;;sBA2CoD;;sB1hBhC9CC;sBI4HFwV;sBADAD;sBJ5HExV;sB2hBVN;;sBASmC;;sB3hBE7BC;sBI4HFwV;sBADAD;sBJ5HExV;sB+LVN;;sBqQ+EoB;uBrQ/EpB;iCAe+Bq6H;0BAN7B,GAM6BA;;;;4BAN7B,YAM6BA;;;;4BPggBvB,sBOtgBN,iBAM6BA;;uBAf/B;iC4UuLSnsQ;yC5UrKGT;4BACF,gBADEA,aAHN47Q;4BAII,6BAEQ;0B4U4KA,SAVA17Q,EAUwB07N,GAAGx+N;4B;qCvQ+JjBi9Q,auQ/JiBj9Q,WAAiBC,GAAK,UAALA,EAApBu+N,GAAgC;0BAAxD,IAVNv5M;;mCvQyKgB83P;;;qCuQxK1B;gDAAYxhQ;yCACV,SAAQ4/E,KAAK93F,EAAEpD;2CACb,GADWoD;iDAGJmpE,GAHInpE,KAGTvD,EAHSuD,oBAGgBpD,GAAK,YAAzBusE,GAAoBvsE,EAAc;6CAA5B,cAHAA,EAGXH;2CADM,cAHAyb,OACKtb,EAG4B;yCAH3C,YAFKoD,EAAG4hB,KAOG;qC1R5JT89F;;uBlDlCN;;0BA0DE;;;;2BAQI/8G,gC;2BAAAyzI,kCARJD;oCAIYolI;;;;4BACNn8Q,GADMm8Q;0EACNn8Q;0BALN;2BAIY,oCAIRg3I;2BAPA,iBjB8CEnhB,aiB9CFqmJ;+DAGQr+H;0BAHR,iBASwB;uBApE9B;iCAyFYj9I;0BACR,cADQA;yDAI0C;oCAAgB;uBA7FtE;iCAgG6BA;0BACzB,UADyBA;0BACzB,6BACgC;0BADhC,IAEiC24Q;0BAC/B,OAD+BA;0BAC/B;kCAC2C;uBArGjD;iCAwGyC34Q;0BACrC,UADqCA;0BACrC,6BACgC,kBAFKA;0BACrC,IAEiC07Q;;mCqEqPTjC;mCrErPSiC;mDAE/B,kBALmC17Q,OAKZ;uBA7G7B;iCA+JoBA;0BAChB,UADgBA;0BAChB;uCACOxF;uCACD4oE;wCACQgI,wCAAsB;uBAnKxC;;0BAkLE;;;;2BAEIzoE;;8C,mCAAAk5Q;6DAFJ1lI;2BACI,iBjB1EElhB,aiB0EF6mJ;+DACA1lI;0BADA,iBAGwB;uBAtL9B,gBAwLWp2I,EAAEhB,GAAI,cAANgB,KAAEhB,EAAuB;uBAxLpC;iCA2LAy0I;;;;;;;;;;;;;;;2BAgDI9wI;4BkMlMFq3K;uClMkMuBv6K,G;8BAArBm9Q;6DAhDJzmI;2BA2CYt4F,MJ4QNu6D,aIxbJijK,aA4KUsB;+DAKRvmI;2BARA9/C;+DAGQ2mD;2BALRzmD;+DAEA0mD;2BAJAvmD;;;gCAhGF;;;iCAEIh0F,IJ+cAu1G,eIthBJmjK,aAuEIwB;;gCARJ,OAOIC;;mCANF;uCAMEA;oCANFp6J;;uD,qCAAAtjH;oCAMEy+C,qBANF6kE;;;mCACA;yCAKEo6J;oCALF/mI;;;yC;6CAAS32I;0EAgEbq0I,KAhEar0I;uCAAT02I;oCAKEj4F,qBALFk4F;;;mCACA;uCAIE+mI;oCAJFzoI,KAIEyoI;oCAJF,gBjBnBI7nJ,aiBmBJof;;;;yC;6CAAmBj1I;4EA+DvBq0I,KA/DuBr0I;uCAAnBsxD;oCAIE7S,qBAJFy2F;gCAGF,IACI8B,oCACAD;0CADAC;8BA+FFqmI;+DAEA3sH;2BAJAh5D,mBA3CF8kL,aA2CEc;+DAEAhiF;2BAZQ,iBjB1GJzlE,aiB0GIqnJ;+DAUR3hF;2BAfQrjG;+DAKAg/G;2BARA,iBjBlGJrhF,aiBkGImnJ;+DAGA5lE;2BAbAC,mBANZhjE,KAMY0oI;+DAUAzlE;6BAZAwlE;;;;2CAEAtlE;;+BAFAE,QAEAF;0BANZ;2BAEID,uBjBpFI1hF,aiBoFJy/I;gEAEQ59D;oCAFRE,QAgDwB;uBA7O5B,mBAoPch3M,GAAI,iBAAJA,KAAyB;uBApPvC,mBAwPWA,GAAI,OAAJA,OAAyB;uBAxPpC;iCAyPaA,GAAI,uCAAJA,KAAgB;uBAzP7B,yBA4SEhB,iCAAiC;uBA5SnC;;iCAwVoBgB;0BAClB,UADkBA;0BACc;;4BAA7B,gCADeA;;;4BACc,UADdA;4BAGV;6CAHUA;6BAGV,aAHUA,OAIC;;0BAFd,qBAFaA,OAIe;uBA5VnC;iCA+VUA;0BAGD,wBAHCA;0BAGD;4BAEL,OALMA;4BAMH,cANGA,IAQJ,QARIA,KAhMJ27Q,eAyMA,QATI37Q;4BASuB,uBATvBA;0BANR,YAgBoB;uBAzWtB;iCA4WeA;0B,cAvHQ,UAuHRA;;4BAKX,OALWA;4BAKX,mBACqCsjG,OACnC,cADmCA,iBACI;4BADzC,QANWtjG;4BAQX,QARWA;4BASX,QATWA;4BAUX,gBAVWA;4BAUX,aAVWA;sCAYH;uBAxXZ;iCA0ZqBA,EAAEw9Q;0BACrB,OADqBA,SAjUjBjxO;0BAoUF;;mCAHiBvsC;6B2G9KL;;;mCAFO;;8B3GsLjB;;+BAAG,4BANYA,KAKVsjG;8BACF;gCAEO,YARKtjG;gCAQL,GAROw9Q;;mCAWPC,WAXOD;;6CAKZl6K;uC,gBASOo6K;yCAAgB,cATvBp6K,MASOo6K,aAAqD;sCAT5Dp6K;kCAOA,KACE,+BAFGm6K;;iCADG,OALRn6K;;8BADG;qCAaL;uBA3aT;iCAwbgBtjG,EAAEw9Q;0BACT,yBAAC,UADMx9Q;4BAED,IAATkY,OAAS,YAFClY;4BAED,OAFCA;4BAId,iBAJcA,EAAEw9Q;4BAKhB,gBALcx9Q;4BAKd,OAHIkY;wDAIE;uBA9bR;iCAicYlY,EAAG6iE,iBAAiB26M;0BACvB,yBADM36M;4BAEV,yBAFUA,iBAEU,UAFb7iE;8BAjBV,IAAIkY,OAiBMlY;8BAhBE;8BAC6B,OAe/BA,OAjBNkY;8BAGJ,iBAcUlY,EAAoBw9Q;8BAb9B,gBAaUx9Q;8BAbV,OAJIkY;4BAqBC,OAJKlY,OAAG6iE;4BAMX,iBANQ7iE,EAAoBw9Q;4BAOf,IAAT13F,SAAS,aAPFjjH;4BAQX,cARQ7iE,KAOJ8lL,YAPOjjH;4BASX,gBATQ7iE;4BASR,OAFI8lL;wDAGG;uBA3cX;iCAuhB6B03F,SAASx9Q;0BACpC,GAD2Bw9Q;4BAIzB;wCAJyBA;6BAItB,4BAJ+Bx9Q,KAG7By9Q;4BACF;8BAED;;;oD;;;gDA9SNzB,aA8DEvoI,KADAypI,gBA2OoCl9Q;;;;;;2DA7dpCq7Q,aAgeOoC;4BADG;kCAQuB;uBAjiBnC;iCAoiBgBD,SAASx9Q,EAAEu6C;0BAEW,+BAFtBijO,SAASx9Q,EAGY;uBAviBrC;iCA0iBkBw9Q,SAASx9Q,EAAE49Q;0BAC3B,WADgBJ,SAASx9Q;0BAEtB,cAFsBA,GAGjB,iBAHiBA;0BAKhB,cALgBA;2BAOnB,2BAPqB49Q,QAAF59Q,EAATw9Q;wDAOW;uBAjjB7B;iCAomBqBx9Q;0BACnB,aADmBA;0BAEZ,cAFYA;4BAIX,aAJWA,GAKd;4BACA;mCANcA;6B2GtXL;qDAHmB;;;;gC3GqY7B,IAJqC24Q,cAIrC,OAJqCA;4BAMrC;8CAAqBA,M,eAdN34Q,WAcM24Q,SACmD;0BAZvE,uBAYyE;uBAnnBhF;iCA4pBuB34Q;0BAClB,kBADkBA;mCAGhB,SAHgBA;qCAId;qCAGD,iBAPeA,MApjBjBy7Q;mCAgkBF;8CAAqByC;uCAGiC,oBAfnCl+Q;uCAemC,eAfnCA,yBAYEk+Q,OAGkD,EAAC;sBAglBhC;;sB/LhvCtCnsI;sBI4HFwV;sBADAD;sBJ5HExV;sB4hBVN;;sBAwBG;;sB5hBbGC;sBI4HFwV;sBADAD;sBJ5HExV;sB+CJN;;;;;;;;;;;0BAgFW,IAMMqsI,OANN;0BACmB;0BACA;0BACA;0BACA;0BAJnB;2BAKA;;;2BACMzgO;;yDAAG;;mCAAH6B;mC+HaT01E;mC/HbS/K;;;;;uCAAkB;;;sB/CjF7B6nB;sBI4HFwV;sBgcxDgB;uByF3EhB82H,mBAAO/+Q,GAAI,4BAAJA,EAAiC;uBAExCg/Q;uBAEAC;sBAEQ;sBzFqEQ;uByFrER;iCAIHv+Q;0BACC,IAAJ3B,EAAI,UAAO,cADR2B;0BAEP,aAFOA,EACH3B;0BACJ,OADIA,CAEH;uBAPS;iCASHkB,EAAEE;0BACD,2BADDF,GACC,MADDA,UACC;;gCACR/E;4BACE;4CAFEwE,EACJxE,EACiB,WAHRiF,EAETjF;8BACE,UADFA;;;0BAGA,OAJIwE,CAIH;uBAdS;iCA6DIhC,EAAExC;0BACyD,wBAAjB,oBAD1CwC,EAAExC,GACyD;uBA9D/D,qBAgEIwC,EAAExC,GACwC,2BAD1CwC,EAAExC,EACyD;uBAjE/D;iCAmEIwC,EAAExC;0BACyD,wBAAjB,oBAD1CwC,EAAExC,GACyD;uBApE/D,qBAsEIwC,EAAExC,GACwC,2BAD1CwC,EAAExC,EACyD;uBAvE/D;iCAyEKwC,EAAExC;0BAC2D,wBAAlB,oBAD3CwC,EAAExC,GAC2D;uBA1ElE;iCA4EKwC,EAAExC,EAAEwE;0BAGK,2BAHThC,EAAExC,EAGO,iBAHLwE,GAGgB;uBCnEjCggR;iCAAoBz1Q,IAAIsB,QAAQpB,IAAIqB,QAAQ7N;0BAC9C,UAD8CA,YAC9C;;;4BACE;;gCAFgCwM,IAAIqB,UACtCtQ,MACwB,cAFF+O,IAAIsB,UAC1BrQ;8BACE,UADFA;;;kCAEI;uBAeFykR;iCAAYjiR,EAAExC,EAAEwE;0BAC8B,wBADlChC,EAAExC,EACkD,iBADhDwE,GAC0D;uBAK1EkgR;iCAAYliR,EAAExC,EAAEwE;0BAC8B,wBADlChC,EAAExC,EACkD,iBADhDwE,GAC0D;uBAK1EmgR;iCAAYniR,EAAExC;0BACyD,wBAAjB,kBAD1CwC,EAAExC,GACyD;uBAEvE4kR,uBAAYpiR,EAAExC,GACwC,yBAD1CwC,EAAExC,EACyD;uBAEvE6kR;iCAAYriR,EAAExC;0BACyD,wBAAjB,kBAD1CwC,EAAExC,GACyD;uBAEvE8kR,uBAAYtiR,EAAExC,GACwC,yBAD1CwC,EAAExC,EACyD;uBAEvE+kR;iCAAaviR,EAAExC;0BAC2D,wBAAlB,kBAD3CwC,EAAExC,GAC2D;uBAE1EglR;iCAAaxiR,EAAExC,EAAEwE;0BAGK,wBAHThC,EAAExC,EAGO,iBAHLwE,GAGgB;uBClDjCygR,cAAM9iR,EAAUC,GAAW,OAArBD,IAAUC,EAAVD,EAAUC,CAAiC;;;0B,IAG/C8iR;mCAwBAC,SAAShjR,EAAEC,EAAE6gD;4BACU,0BADZ7gD;4BACN,QAAK,gBADDD,YAAI8gD;6BAEV;4BADoB,IApBzB,KAmBeA,KAnBf;;sCAAIn+C;gCAMO;uDAaA3C,EAlBPnC;iCAIE,sBAcOoC,EAlBTpC;gCAEF,gBAgBWoC,EAlBTpC;gCAEF,OAHE8E;gCAGF,OAFE9E;;;uCADA8E;kCAcO;yDAKE1C,EAlBTpC;mCAYE,sBAMKmC,EAlBPnC;kCAUF,gBAQWoC,EAlBTpC;kCAUF;;;0CAWqB;mCAErBktP,IAAI/qP,EAAEC;4BACkB;mDADlBA;6BACA,OAAK,gBADPD;6BAES,sBAFPC,IACJ2C;6BACI;4BACR,SAHM5C,EAEF0B,EADAkB;4BAEJ,OADIlB,CAEH;oCAjCCqhR,aAwBAC,SAKAj4B;;;;;;;2BDYF63B;2BAGAC;;;6BD7DAlB,UAEAC,MAMAC,OAqEAM,aAGAC;uBGtFAa;iCAAYhnR;0BAAM,wBAAqBoE,GAAK,mBAALA,EAAkB,EAA7CpE,IAAkD;uBhfgD5DinR;iCAAMljR,EAAE2C;0BAAI;mEAAN3C,EAAE2C;mCAAkB,sBAApB3C,OAAE2C,OAAkC;uBAqD1CwgR;iCAAIC;0BAQA;wCARAA;2BAOA,aAPAA;2BAMA,aANAA;2BAKE,WALFA;0BAKE,UALFA,6CASL;uBAECC;iCAAen3M;0BAoEb;kDApEaA;2BAmEb,uBAnEaA;2BAkEb,uBAlEaA;2BAiEb,uBAjEaA;2BAgEb,uBAhEaA;2BA+Db,uBA/DaA;2BA8Db,uBA9DaA;2BA6Db,uBA7DaA;2BA4Db,uBA5DaA;2BA2Db,uBA3DaA;2BA0Db,uBA1DaA;2BAyDb,uBAzDaA;2BAwDb,uBAxDaA;2BAuDb,uBAvDaA;2BAsDb,uBAtDaA;2BAqDb,uBArDaA;2BAoDb,uBApDaA;2BAmDb,uBAnDaA;2BAkDb,uBAlDaA;2BAiDb,uBAjDaA;2BAgDb,uBAhDaA;2BA+Cb,uBA/CaA;2BA8Cb,uBA9CaA;2BA6Cb,uBA7CaA;2BA4Cb,uBA5CaA;2BA2Cb,uBA3CaA;2BA0Cb,uBA1CaA;2BAyCb,uBAzCaA;2BAwCb,uBAxCaA;2BAuCb,uBAvCaA;2BAsCb,uBAtCaA;2BAqCb,uBArCaA;2BAoCb,uBApCaA;2BAmCb,uBAnCaA;2BAkCb,uBAlCaA;2BAiCb,uBAjCaA;2BAgCb,uBAhCaA;2BA+Bb,uBA/BaA;2BA8Bb,uBA9BaA;2BA6Bb,uBA7BaA;2BA4Bb,uBA5BaA;2BA2Bb,uBA3BaA;2BA0Bb,uBA1BaA;2BAyBb,uBAzBaA;2BAwBb,uBAxBaA;2BAuBb,uBAvBaA;2BAOC;;6BAPDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAOC;+CA+DFruE,GAAqB,wBArEjCkqB,IAqEYlqB,SAA4B,EAAC;uBAoB3CylR;uBAlBAC;;;;;;;;;;;uBA8BAC;iCAAkBJ,IAAIK;0BAEX;;4DAFOL,aAAIK;0BAExB,iBAFoBL;0BAEP;2BACyB;0CAAT,iBAHTA,aAAIK;2BAGX,qBAAC,iBAHML;0BAGpB,iBAHoBA;0BAGpB,QAA6D;uBA2B3DM;;;;;;;;;;;;;;uBAgBAC;iCAEEzB,YAAYkB,IAAIpxO,MAAMvzC;0BAClB,+BACA;mCACJsG,EAAErD,EAAE7D,EAAE+lR,MAAMC,MAAMC,MAAMC;4BAGyB;uCAH7ClmR;6BAG2C;+CAAT,iBAxBxC6lR,MAqBIhiR;;6BAGiC,uBAJnCwU;6BAIuB,uBALvB7T,EAEYwhR;6BAGD;;gEALXxhR,EAEMuhR;;4BAGR,iBALEvhR,EAEMuhR;4BAG2C;6BAChB,uBANjCvhR,EAEMuhR;6BAIK;;gCAAM,eAAC,iBANlBvhR,EAEwB0hR;;4BAI1B,iBANE1hR,EAEwB0hR;4BAGyB;6BAE1B,uBAPvB1hR,EAEwB0hR;6BAKb;8DAPX1hR,EAEkByhR;4BAKpB,iBAPEzhR,EAEkByhR;4BAG+B;6BAGhB,uBARjCzhR,EAEkByhR;6BAMP;;gCAAM,eAAC,iBARlBzhR,EAEYwhR;;4BAMd,iBARExhR,EAEYwhR;4BAGqC;6BAIA,WAP7ChmR;6BAO2C;+CAAT,iBA5BxC6lR,MAqBIhiR;;6BAOiC,uBARnCwU;6BAQuB,uBATvB7T,EAEYwhR;6BAOD;;gEATXxhR,EAEMuhR;;4BAOR,iBATEvhR,EAEMuhR;4BAG2C;6BAKhB,uBAVjCvhR,EAEMuhR;6BAQK;;gCAAM,eAAC,iBAVlBvhR,EAEwB0hR;;4BAQ1B,iBAVE1hR,EAEwB0hR;4BAGyB;6BAM1B,uBAXvB1hR,EAEwB0hR;6BASb;8DAXX1hR,EAEkByhR;4BASpB,iBAXEzhR,EAEkByhR;4BAG+B;6BAOhB,uBAZjCzhR,EAEkByhR;6BAUP;;gCAAM,eAAC,iBAZlBzhR,EAEYwhR;;4BAUd,iBAZExhR,EAEYwhR;4BAUd,QAAgD;0BAX1C,SAYJniR,EAAEA;4BACJ,EADIA;4BAEJ,EAFIA;4BAGJ,EAHIA;4BAIJ,EAJIA;4BAKJ,EALIA;4BAMJ,EANIA;4BAOJ,EAPIA;4BAOJ,SAPIA,aAQU;8BAChB+sE;0BACE;4BAAS;;yCAxBPyzM,YAAgBlwO,MAAMvzC,OAuB1BgwE;4BACE,iBAtBEv4D,EAqBJu4D;4BACW,UADXA;;4BACW,IAEXhI;4BACE;8BAAS,2BA3BK28M,OA0BhB38M;8BACE,iBA1BEpkE,EAyBJokE;8BACW,UADXA;;8BACW,UAEF,iBAzFP68M;8BAyFF,iBA5BIjhR;8BA0BO,UAGF,iBA1FPihR;8BA0FF,iBA7BIjhR;8BA0BO,UAID,iBA3FRihR;8BA2FF,iBA9BIjhR;8BA0BO,UAKD,iBA5FRihR;8BA4FF,iBA/BIjhR;8BA0BO;+BAMkB,uBAjCb+gR;+BAiCC,sCA7FfE;8BA6FF,iBAhCIjhR;8BA0BO;+BAOkB,uBAlCb+gR;+BAkCC,sCA9FfE;8BA8FF,iBAjCIjhR;8BA0BO;+BAQkB,uBAnCb+gR;+BAmCC,sCA/FfE;8BA+FF,iBAlCIjhR;8BA0BO;+BASkB,uBApCb+gR;+BAoCC,sCAhGfE;8BAgGF,iBAnCIjhR;8BAoCJ;8BACA;8BACA;8BACA;8BACA;8BACA;8BACA;8BACA;8BACA;8BACA;8BACA;8BACA;8BArBW,IAuBXxE;8BACE;gCAAiD;uCADnDA;iCACgD,uBAlD5CwE;iCAkDiC,uBAlDjCA,EAiDJxE;iCACsB;;oEAnDNulR,OAkDhBvlR;;gCACE,iBAnDculR,OAkDhBvlR;gCACmD,UADnDA;;gCAGA,WAAE;uBAEAmmR;iCASEx1J,KAAM0zJ,YAAYkB,IAAInmQ,IAAIxe,IAAI6B;0BAClC,cAD8B7B,KAC9B,UADkC6B;0BAClC,OACI4jR;4BAEC,SAJiBd,OAIjB,WACClzO;4BADD,GAECi0O,OAJFD;8BAMG;8BAEH,WAVA11J,KAAsBvxG,IACtBgnQ,UADkBb,OAKhBlzO,KACAi0O;8BAKF,kBAXkBf;8BAYlB,S8erRJT,c9eyQsBS;8BAYlB,YAXAa,YAKEE;8BAMF,YAVAD,YAIEC;;yCAJFD;kCAcE,kBAhBgBd;kCAiBhB,SAjBIlB,YAAYkB,IAAInmQ,IACtBgnQ;kCAgBE,YAhBFA;kCAgBE,YAfFC;;;4BAmBF,WArBE11J,KAAsBvxG,IACtBgnQ,UADkBb,cAElBc;4BAmBF,SArBoBd,SAElBc;0BAqBJ,QAAE;uBAEoB;;0B,OAlCpBF,Y8ehQFrB;uB9eqSA;;0B,OArCEqB;mC8evSF3B,oBD0DAH;uB7ekRA;iCAEuB1zJ,KAAK+1J,OAAOnmQ,IAAI3f,IAAI6B;0BAC3C,QAD4BikR;sCAjWb,U2Iq1Bb1+M,S3Ir1BO5pE,KAqLPsnR,WA4K0BgB;0BAKlB;;2BAOF;;;6BAZoBA;;6BAKxBtnQ;6BAOI;6BACA;6BACA;2BAGN;;;+BAjB0BsnQ;+BAAejkR;;;;;;;;;;;2BAmB3CzC;0BACE;4BAAgC;qDAJ9B2mR,YAGJ3mR;6BACsB,sCA9KpBylR,GA6KFzlR;4BACE,iBAdEulR,OAaJvlR;4BACkC,UADlCA;;4BAGA,OAtB2CyC;8BAwB7B,IAAR0xC,MAAQ;8BACZ,WAzBqBw8E,KAAYpwG,IAAI3f,IAwBjCuzC,QAxBqC1xC;8BA0BzC,kBApBE8iR,IAkBEpxO;4BAGN,OArBIoxO,IAqBD;uBA7BH;iCA+B4BmB,OAAOnmQ,IAAI3f,IAAI6B;0BAC3C,gCAD4BikR,OAAOnmQ,IAAI3f,IAAI6B,IACS;uBAhCpD;iCAkCgCikR,OAAOnmQ,IAAI3f,IAAI6B;0BAC/C;mC8e/WA+hR,oB9e8WgCkC,OAAOnmQ,IAAI3f,IAAI6B,IACoB;uBAnCnE;iCAqCa8iR;0BACH,IAAN99Q,IAAM,KAhNRi+Q;0BAiNF,kBAFaH,IAES,oBAFTA;0BAzKb,SAyKaA,OA5KQ,iBA4KRA,e7DzWI/tO;0B6DiMjB,iBAwKa+tO,e7DzWI/tO;0B6D6WjB,KAJa+tO;0BAKb,S8e/UAT,c9e0UaS;0BACH,IAKVvlR;0BACE;;8BANEyH,IAKJzH,UAC6B,iBAPhBulR,OAMbvlR;4BACE,UADFA;;4BAGA,GATaulR,YAUR,WATD99Q,MADS89Q;4BAWR,QAXQA,OAaX;4BAEG,OAdD99Q,IAcI;uBC5XNs/Q,eAAM5kR,EAAE2C,GAAI,OAAN3C,MAAE2C,QAAF3C,WAAE2C,MAAkC;uBA0E1CkiR;iCAAIzB;0BAQA;wCARAA;2BAOA,aAPAA;2BAMA,aANAA;2BAKE,WALFA;0BAKE,UALFA,6CASL;;;uBA2DC0B;uBAjBAC;uBA6BAC;iCAAkB5B,IAAIK;0BAEX,2BAFOL,eAAIK;0BAExB,iBAFoBL;0BAEP;2BACyB,oBAAT,iBAHTA,aAAIK;2BAGX,MAAC,iBAHML;0BAGpB,iBAHoBA;0BAGpB,QAA6D;uBA0B3D6B;;;;;;;;;;;;uBAcAC;iCAEElD,YAAYoB,IAAIpxO,MAAMvzC;0BAClB,2BACA;mCACJsG,EAAErD,EAAE7D,EAAE+lR,MAAMC,MAAMC,MAAMC;4BAGyB;uCAH7ClmR;6BAG2C;+CAAT,iBAtBxConR,QAmBIvjR;;6BAGiC,uBAJnCwU;6BAIuB,uBALvB7T,EAEYwhR;6BAGD;gDALXxhR,EAEMuhR;;;;;4BAGR,iBALEvhR,EAEMuhR;4BAG2C;6BAChB,uBANjCvhR,EAEMuhR;6BAIK,YAAO,iBANlBvhR,EAEwB0hR;4BAI1B,iBANE1hR,EAEwB0hR;4BAGyB;6BAE1B,uBAPvB1hR,EAEwB0hR;6BAKb,uBAPX1hR,EAEkByhR;4BAKpB,iBAPEzhR,EAEkByhR;4BAG+B;6BAGhB,uBARjCzhR,EAEkByhR;6BAMP,YAAO,iBARlBzhR,EAEYwhR;4BAMd,iBARExhR,EAEYwhR;4BAGqC;6BAIA,WAP7ChmR;6BAO2C;+CAAT,iBA1BxConR,QAmBIvjR;;6BAOiC,uBARnCwU;6BAQuB,uBATvB7T,EAEYwhR;6BAOD;gDATXxhR,EAEMuhR;;;;;4BAOR,iBATEvhR,EAEMuhR;4BAG2C;6BAKhB,uBAVjCvhR,EAEMuhR;6BAQK,YAAO,iBAVlBvhR,EAEwB0hR;4BAQ1B,iBAVE1hR,EAEwB0hR;4BAGyB;6BAM1B,uBAXvB1hR,EAEwB0hR;6BASb,uBAXX1hR,EAEkByhR;4BASpB,iBAXEzhR,EAEkByhR;4BAG+B;6BAOhB,uBAZjCzhR,EAEkByhR;6BAUP,YAAO,iBAZlBzhR,EAEYwhR;4BAUd,iBAZExhR,EAEYwhR;4BAUd,QAA+C;0BAXzC,SAYJniR,EAAEA;4BACJ,EADIA;4BAEJ,EAFIA;4BAGJ,EAHIA;4BAIJ,EAJIA;4BAKJ,EALIA;4BAMJ,EANIA;4BAOJ,EAPIA;4BAOJ,SAPIA,aAQU;8BAChB+sE;0BACE;4BAAS;;yCAxBPuzM,YAAgBhwO,MAAMvzC,OAuB1BgwE;4BACE,iBAtBEv4D,EAqBJu4D;4BACW,UADXA;;4BACW,IAEXhI;4BACE;8BAAS,2BA3BK28M,OA0BhB38M;8BACE,iBA1BEpkE,EAyBJokE;8BACW,UADXA;;8BACW,UAEF,iBAtFPq+M;8BAsFF,iBA5BIziR;8BA0BO,UAGF,iBAvFPyiR;8BAuFF,iBA7BIziR;8BA0BO,UAID,iBAxFRyiR;8BAwFF,iBA9BIziR;8BA0BO,UAKD,iBAzFRyiR;8BAyFF,iBA/BIziR;8BA0BO;+BAMkB,uBAjCb+gR;+BAiCC,uBA1Ff0B;8BA0FF,iBAhCIziR;8BA0BO;+BAOkB,uBAlCb+gR;+BAkCC,uBA3Ff0B;8BA2FF,iBAjCIziR;8BA0BO;+BAQkB,uBAnCb+gR;+BAmCC,uBA5Ff0B;8BA4FF,iBAlCIziR;8BA0BO;+BASkB,uBApCb+gR;+BAoCC,uBA7Ff0B;8BA6FF,iBAnCIziR;8BAoCJ;8BACA;8BACA;8BACA;8BACA;8BACA;8BACA;8BACA;8BACA;8BACA;8BAnBW,IAqBXxE;8BACE;gCAAiD;uCADnDA;iCACgD,uBAhD5CwE;iCAgDiC,uBAhDjCA,EA+CJxE;iCACsB,uBAjDNulR,OAgDhBvlR;gCACE,iBAjDculR,OAgDhBvlR;gCACmD,UADnDA;;gCAGA,WAAE;uBAEAsnR;iCASE32J,KAAMwzJ,YAAYoB,IAAInmQ,IAAIxe,IAAI6B;0BAClC,cAD8B7B,KAC9B,UADkC6B;0BAClC,OACI4jR;4BAEC,SAJiBd,OAIjB,UACClzO;4BADD,GAECi0O,OAJFD;8BAMG;8BAEH,WAVA11J,KAAsBvxG,IACtBgnQ,UADkBb,OAKhBlzO,KACAi0O;8BAKF,oBAXkBf;8BAYlB,W6epPJX,c7ewOsBW;8BAYlB,YAXAa,YAKEE;8BAMF,YAVAD,YAIEC;;wCAJFD;kCAcE,oBAhBgBd;kCAiBhB,WAjBIpB,YAAYoB,IAAInmQ,IACtBgnQ;kCAgBE,YAhBFA;kCAgBE,YAfFC;;;4BAmBF,WArBE11J,KAAsBvxG,IACtBgnQ,UADkBb,cAElBc;4BAmBF,SArBoBd,SAElBc;0BAqBJ,QAAE;uBAEoB;;0B,OAlCpBiB,Y6e/NF1C;uB7eoQA;;0B,OArCE0C;mC6ehQF9C,oBDoDAL;uB5eiPA;iCAEuBxzJ,KAAK+1J,OAAOnmQ,IAAI3f,IAAI6B;0BAC3C,QAD4BikR;sCA1Tb,U0Iq1Bb1+M,S1Ir1BOhjB,OAoJPkiO,aAsK0BR;0BAKlB;;2BAOF;;;6BAZoBA;;6BAKxBtnQ;6BAOI;6BACA;6BACA;2BAxLJ;2BADA;2BADA;2BADA;2BADA;2BADA;2BADA;2BADA;2BADA;2BADA;2BADA;2BADA;2BADA;2BADA;2BADA;2BAfc;;6BAuMUsnQ;6BAAejkR;;;;;;;;;;;;;;;6BAzLvC;;;;;;;;;;;;;;;;2BAdc;6CA+BFzC,GAAqB,wBArCjCkqB,IAqCYlqB,SAA4B;2BA2L5CA;0BACE;4BAAgC;qDAJ9B2mR,YAGJ3mR;6BACsB,uBAzKpBinR,KAwKFjnR;4BACE,iBAdEulR,OAaJvlR;4BACkC,UADlCA;;4BAGA,OAtB2CyC;8BAwB7B,IAAR0xC,MAAQ;8BACZ,WAzBqBw8E,KAAYpwG,IAAI3f,IAwBjCuzC,QAxBqC1xC;8BA0BzC,oBApBE8iR,IAkBEpxO;4BAGN,OArBIoxO,IAqBD;uBA7BH;iCA+B4BmB,OAAOnmQ,IAAI3f,IAAI6B;0BAC3C,kCAD4BikR,OAAOnmQ,IAAI3f,IAAI6B,IACS;uBAhCpD;iCAkCgCikR,OAAOnmQ,IAAI3f,IAAI6B;0BAC/C;mC6exUA+hR,oB7euUgCkC,OAAOnmQ,IAAI3f,IAAI6B,IACoB;uBAnCnE;iCAqCa8iR;0BACH,IAAN99Q,IAAM,KA1MRy/Q;0BA2MF,oBAFa3B;0BApKb,SAoKaA,OAvKQ,iBAuKRA,e+JlTb5zM;0B/J+IA,iBAmKa4zM,e+JlTb5zM;0B/JsTA,KAJa4zM;0BAKb,W6e9SAX,c7eySaW;0BACH,IAKVvlR;0BACE;;8BANEyH,IAKJzH,UAC6B,iBAPhBulR,OAMbvlR;4BACE,UADFA;;4BAGA,GATaulR,YAUR,WATD99Q,MADS89Q;4BAWR,QAXQA,OAaX;4BAEG,OAdD99Q,IAcI;uBgfvTNogR;iCAAItC;0BAAgD,iBAAhDA,QAA6B,WAA7BA;0BAA6B,UAA7BA,mBAAkE;uBAEtEuC;;0BACM,IAAJ1lR,EAAI;;;kCAAJA;kFAKH;uBAEC4yC,YAAG/yC,EAAEzB,EAAE8iC,GAAkB,OAAlBA,IAAJrhC,KAAEzB,IAAE8iC,EAAsC;uBAE7C47C,YAAGj9E,EAAEzB,EAAE8iC,GAAI,UAAJA,EAAJrhC,EAAEzB,EAAc;uBAEnBunR,YAAG9lR,EAAEzB,EAAE8iC,GAAW,OAAfrhC,IAAEzB,IAAE8iC,CAA2B;uBAElC27C,YAAGh9E,EAAEzB,EAAE8iC,GAAkB,OAApB9iC,KAAFyB,IAAIqhC,OAAiC;uBAExC0kP;iCAEE7D,YAAYoB,IAAInmQ,IAAIxe;0BAE4B;iDAFpC2kR;2BAEqB,sBAFrBA;2BAEM,sBAFNA;2BAET,sBAFSA;2BAGR;2BACRvlR;0BACE;4BAAS;;yCALPmkR,YAAgB/kQ,IAAIxe,OAIxBZ;4BACE,iBAFE0C,EACJ1C;4BACW,UADXA;;4BACW;6BAEPq5H;uCAAMp0H,EAAE9C,EAAEC,EAAEqD,EAAEpH,EAAE2B,EAAEmE,EAAE3B;gCAEC;wDANrBE,EAIgB1C;iCAER,iBAFFiF,EAAI7C,KAAEqD,KAAEpH;gCAEX,SAFK8D,iCAAUgC;gCAEG,UAFbhC;gDAAYK;gCAIjB,OAJKL,OAAEC;gCAIP,QAAO;4BACd,MAtBE4yC,GAWE7yC,EAAGC,EAAGqD,EAAGpH;4BAYb,MAvBE22C,GAWW32C,EAAT8D,EAAGC,EAAGqD;4BAaV,MAxBEuvC,GAWQvvC,EAAGpH,EAAT8D,EAAGC;4BAcP,MAzBE4yC,GAWK5yC,EAAGqD,EAAGpH,EAAT8D;4BAeJ,MA1BE6yC,GAWE7yC,EAAGC,EAAGqD,EAAGpH;4BAgBb,MA3BE22C,GAWW32C,EAAT8D,EAAGC,EAAGqD;4BAiBV,MA5BEuvC,GAWQvvC,EAAGpH,EAAT8D,EAAGC;4BAkBP,MA7BE4yC,GAWK5yC,EAAGqD,EAAGpH,EAAT8D;4BAmBJ,MA9BE6yC,GAWE7yC,EAAGC,EAAGqD,EAAGpH;4BAoBb,MA/BE22C,GAWW32C,EAAT8D,EAAGC,EAAGqD;4BAqBV,MAhCEuvC,GAWQvvC,EAAGpH,EAAT8D,EAAGC;4BAsBP,MAjCE4yC,GAWK5yC,EAAGqD,EAAGpH,EAAT8D;4BAuBJ,MAlCE6yC,GAWE7yC,EAAGC,EAAGqD,EAAGpH;4BAwBb,MAnCE22C,GAWW32C,EAAT8D,EAAGC,EAAGqD;4BAyBV,MApCEuvC,GAWQvvC,EAAGpH,EAAT8D,EAAGC;4BA0BP,MArCE4yC,GAWK5yC,EAAGqD,EAAGpH,EAAT8D;4BA2BJ,MApCE+8E,GASE/8E,EAAGC,EAAGqD,EAAGpH;4BA4Bb,MArCE6gF,GASW7gF,EAAT8D,EAAGC,EAAGqD;4BA6BV,MAtCEy5E,GASQz5E,EAAGpH,EAAT8D,EAAGC;4BA8BP,MAvCE88E,GASK98E,EAAGqD,EAAGpH,EAAT8D;4BA+BJ,MAxCE+8E,GASE/8E,EAAGC,EAAGqD,EAAGpH;4BAgCb,MAzCE6gF,GASW7gF,EAAT8D,EAAGC,EAAGqD;4BAiCV,MA1CEy5E,GASQz5E,EAAGpH,EAAT8D,EAAGC;4BAkCP,MA3CE88E,GASK98E,EAAGqD,EAAGpH,EAAT8D;4BAmCJ,MA5CE+8E,GASE/8E,EAAGC,EAAGqD,EAAGpH;4BAoCb,MA7CE6gF,GASW7gF,EAAT8D,EAAGC,EAAGqD;4BAqCV,MA9CEy5E,GASQz5E,EAAGpH,EAAT8D,EAAGC;4BAsCP,MA/CE88E,GASK98E,EAAGqD,EAAGpH,EAAT8D;4BAuCJ,MAhDE+8E,GASE/8E,EAAGC,EAAGqD,EAAGpH;4BAwCb,MAjDE6gF,GASW7gF,EAAT8D,EAAGC,EAAGqD;4BAyCV,MAlDEy5E,GASQz5E,EAAGpH,EAAT8D,EAAGC;4BA0CP,MAnDE88E,GASK98E,EAAGqD,EAAGpH,EAAT8D;4BA2CJ,MAlDE4lR,GAOE5lR,EAAGC,EAAGqD,EAAGpH;4BA4Cb,MAnDE0pR,GAOW1pR,EAAT8D,EAAGC,EAAGqD;4BA6CV,MApDEsiR,GAOQtiR,EAAGpH,EAAT8D,EAAGC;4BA8CP,MArDE2lR,GAOK3lR,EAAGqD,EAAGpH,EAAT8D;4BA+CJ,MAtDE4lR,GAOE5lR,EAAGC,EAAGqD,EAAGpH;4BAgDb,MAvDE0pR,GAOW1pR,EAAT8D,EAAGC,EAAGqD;4BAiDV,MAxDEsiR,GAOQtiR,EAAGpH,EAAT8D,EAAGC;4BAkDP,MAzDE2lR,GAOK3lR,EAAGqD,EAAGpH,EAAT8D;4BAmDJ,MA1DE4lR,GAOE5lR,EAAGC,EAAGqD,EAAGpH;4BAoDb,MA3DE0pR,GAOW1pR,EAAT8D,EAAGC,EAAGqD;4BAqDV,MA5DEsiR,GAOQtiR,EAAGpH,EAAT8D,EAAGC;4BAsDP,MA7DE2lR,GAOK3lR,EAAGqD,EAAGpH,EAAT8D;4BAuDJ,MA9DE4lR,GAOE5lR,EAAGC,EAAGqD,EAAGpH;4BAwDb,MA/DE0pR,GAOW1pR,EAAT8D,EAAGC,EAAGqD;4BAyDV,MAhEEsiR,GAOQtiR,EAAGpH,EAAT8D,EAAGC;4BA0DP,MAjEE2lR,GAOK3lR,EAAGqD,EAAGpH,EAAT8D;4BA2DJ,MAhEE88E,GAKE98E,EAAGC,EAAGqD,EAAGpH;4BA4Db,MAjEE4gF,GAKW5gF,EAAT8D,EAAGC,EAAGqD;4BA6DV,MAlEEw5E,GAKQx5E,EAAGpH,EAAT8D,EAAGC;4BA8DP,MAnEE68E,GAKK78E,EAAGqD,EAAGpH,EAAT8D;4BA+DJ,MApEE88E,GAKE98E,EAAGC,EAAGqD,EAAGpH;4BAgEb,MArEE4gF,GAKW5gF,EAAT8D,EAAGC,EAAGqD;4BAiEV,MAtEEw5E,GAKQx5E,EAAGpH,EAAT8D,EAAGC;4BAkEP,MAvEE68E,GAKK78E,EAAGqD,EAAGpH,EAAT8D;4BAmEJ,MAxEE88E,GAKE98E,EAAGC,EAAGqD,EAAGpH;4BAoEb,MAzEE4gF,GAKW5gF,EAAT8D,EAAGC,EAAGqD;4BAqEV,MA1EEw5E,GAKQx5E,EAAGpH,EAAT8D,EAAGC;4BAsEP,MA3EE68E,GAKK78E,EAAGqD,EAAGpH,EAAT8D;4BAuEJ,MA5EE88E,GAKE98E,EAAGC,EAAGqD,EAAGpH;4BAwEb,MA7EE4gF,GAKW5gF,EAAT8D,EAAGC,EAAGqD;4BAyEV,MA9EEw5E,GAKQx5E,EAAGpH,EAAT8D,EAAGC;4BA0EP,MA/EE68E,GAKK78E,EAAGqD,EAAGpH,EAAT8D;4BAIO;6BAsEX,MA1EIA;6BA4ES,uBA7EGojR;4BA6EhB,iBA7EgBA;4BAKL;6BAwEX,MA5EOnjR;6BA6EM,uBA9EGmjR;4BA8EhB,iBA9EgBA;4BAKL;6BAyEX,MA7EU9/Q;6BA8EG,uBA/EG8/Q;4BA+EhB,iBA/EgBA;4BAKL;6BA0EX,MA9EalnR;6BA+EA,uBAhFGknR;4BAgFhB,iBAhFgBA;4BAgFhB,SACE;uBAEA0C;iCASEt3J,KAAMwzJ,YAAYoB,IAAInmQ,IAAIxe,IAAI6B;0BACN;qEADN8iR;2BACM,SADM9iR;2BACN,SADE7B;2BACF,aAAxB0hB;0BAIQ;;yCALUijQ,OAKS,oBAH3Bx7M;0BADwB;2BAIhB,YAJRznD;2BAIQ,YADR4lQ,WAFAn+M;0BAKC;4BACH,WARE4mD,KAAsBvxG,IAGtBsnF,SAHkB6+K,OAClBjjQ,OAGA4lQ;4BAKF,aH1HFtD,cGiHsBW;4BASpB,WAPEx7M,WAEAm+M;4BAKF,WANExhL,WACAwhL;4BAKF;;qCAPEn+M;8BAYF,aAdQo6M,YAAYoB,IAAInmQ,IAGtBsnF;8BAWF,WAZE38B;8BAYF,WAXE28B;;4BAeJ,SAhBI38B;6BAgBc,WAlBd4mD,KAAsBvxG,IAGtBsnF,SAHkB6+K,OAClBjjQ,OACAynD;4BAgB2C,SAC7C;uBAEoB;;0B,OA9BpBk+M,YHxGFrD;uBGyIA;;0B,OAjCEqD;mCHzIFzD,oBDoDAL;uBIsHA;iCAEaoB;0BACa;oEADbA;2BACa,aAAtB70Q;2BAEU;iCADV43Q,uBACyB,wBAAoC;2BACjE;0BACA,iBADIj5O,OACyB,sBALhBk2O;0BAMb,oBANaA,IAGT3lR,UADA0oR;0BAKJ,oBAPa/C,IAITl2O;0BAHsB,IAOhB,0BACVrvC;0BACE;;8BAFEyH,IACJzH,UAC6B,iBAVhBulR,OASbvlR;4BACE,UADFA;;4BAGA,OAJIyH,IAID;uBAdH;;yBAtIEqgR;yBAmIAK;yBAEAC;yBAGAC;yBA1IAR;uBClBAU,eAAMpmR,EAAE2C,GAAI,OAAN3C,KAAE2C,IAAF3C,YAAE2C,UAAkC;uBAkB1C0jR;iCAAIjD;0BACuD,eADvDA,QACiC,aADjCA,QACiC,MADjCA;0BACA,iBADAA,0BACsE;uBAE1EkD;;0BACM,IAAJrmR,EAAI,6CAAJA,EAMH;uBAECu6F,aAAE16F,EAAEzB,EAAE8iC,GAAW,OAAfrhC,IAAEzB,IAAE8iC,CAA2B;uBAEjColP,aAAEzmR,EAAEzB,EAAE8iC,GAAW,OAAfrhC,IAAEzB,KAAFyB,UAAIqhC,CAAwC;uBAE9ChhC,WAAEL,EAAEzB,EAAE8iC,GAAW,QAAfrhC,IAAEzB,UAAE8iC,CAA+B;uBAErCtjC,WAAEiC,EAAEzB,EAAE8iC,GAAW,OAAfrhC,IAAIqhC,IAAF9iC,KAAE8iC,OAAwC;uBAE9C19B,WAAE3D,EAAEzB,EAAE8iC,GAAkB,OAAtBrhC,KAAEzB,IAAE8iC,OAAiC;uBAEvC7b;iCAAGtlB,EAAEC,EAAEqD,EAAEpH,EAAE8W,EAAElT,EAAEO;0BAEP,cAFHJ,KAAEqD,KAAEpH;0BAEN,QAFA8D,oBAAUF;0BAEL,UAFGkT;0BAGR,aAHAhT,KAAYK;0BAIZ,aAJIiD;0BAIJ,QAAW;uBAEdiiB;iCAAGvlB,EAAEC,EAAEqD,EAAEpH,EAAE8W,EAAElT,EAAEO;0BAEP,cAFHJ,KAAEqD,KAAEpH;0BAEN,SAFA8D,oBAAUF;0BAEL,UAFGkT;0BAGR,aAHAhT,KAAYK;0BAIZ,aAJIiD;0BAIJ,QAAW;uBAEduF;iCAAG7I,EAAEC,EAAEqD,EAAEpH,EAAE8W,EAAElT,EAAEO;0BAEP,YAFHJ,KAAEqD,KAAEpH;0BAEN,SAFA8D,oBAAUF;0BAEL,UAFGkT;0BAGR,aAHAhT,KAAYK;0BAIZ,aAJIiD;0BAIJ,QAAW;uBAEd1D;iCAAGI,EAAEC,EAAEqD,EAAEpH,EAAE8W,EAAElT,EAAEO;0BAEP,YAFHJ,KAAEqD,KAAEpH;0BAEN,SAFA8D,oBAAUF;0BAEL,UAFGkT;0BAGR,aAHAhT,KAAYK;0BAIZ,aAJIiD;0BAIJ,QAAW;uBAEdkjR;iCAAGxmR,EAAEC,EAAEqD,EAAEpH,EAAE8W,EAAElT,EAAEO;0BAEP,YAFHJ,KAAEqD,KAAEpH;0BAEN,SAFA8D,oBAAUF;0BAEL,UAFGkT;0BAGR,aAHAhT,KAAYK;0BAIZ,aAJIiD;0BAIJ,QAAW;uBAEdmjR;iCAAIzmR,EAAEC,EAAEqD,EAAEpH,EAAE8W,EAAElT,EAAEO;0BAER,cAFFJ,KAAEqD,KAAEpH;0BAEP,QAFC8D,oBAAUF;0BAEN,UAFIkT;0BAGT,aAHChT,KAAYK;0BAIb,aAJKiD;0BAIL,QAAW;uBAEdojR;iCAAI1mR,EAAEC,EAAEqD,EAAEpH,EAAE8W,EAAElT,EAAEO;0BAER,cAFFJ,KAAEqD,KAAEpH;0BAEP,SAFC8D,oBAAUF;0BAEN,UAFIkT;0BAGT,aAHChT,KAAYK;0BAIb,aAJKiD;0BAIL,QAAW;uBAEdqjR;iCAAI3mR,EAAEC,EAAEqD,EAAEpH,EAAE8W,EAAElT,EAAEO;0BAER,YAFFJ,KAAEqD,KAAEpH;0BAEP,SAFC8D,oBAAUF;0BAEN,UAFIkT;0BAGT,aAHChT,KAAYK;0BAIb,aAJKiD;0BAIL,QAAW;uBAEdsjR;iCAAI5mR,EAAEC,EAAEqD,EAAEpH,EAAE8W,EAAElT,EAAEO;0BAER,YAFFJ,KAAEqD,KAAEpH;0BAEP,SAFC8D,oBAAUF;0BAEN,UAFIkT;0BAGT,aAHChT,KAAYK;0BAIb,aAJKiD;0BAIL,QAAW;uBAEdujR;iCAAI7mR,EAAEC,EAAEqD,EAAEpH,EAAE8W,EAAElT,EAAEO;0BAER,YAFFJ,KAAEqD,KAAEpH;0BAEP,SAFC8D,oBAAUF;0BAEN,UAFIkT;0BAGT,aAHChT,KAAYK;0BAIb,aAJKiD;0BAIL,QAAW;uBAEdwjR;iCAEE9E,YAAYoB,IAAIrlP,KAAKt/B;0BAWjB;mDAXQ2kR;2BAUR,wBAVQA;2BASR,wBATQA;2BAQR,wBARQA;2BAOR,wBAPQA;2BAMR,uBANQA;2BAKR,uBALQA;2BAIR,uBAJQA;2BAGR,uBAHQA;2BAER,uBAFQA;2BAYR;2BACRvlR;0BACE;4BAAS;;yCAdPmkR,YAAgBjkP,KAAKt/B,OAazBZ;4BACE,iBAFE0C,EACJ1C;4BACW,UADXA;;4BAGA,GAfI0pR,GAAID,GAAID,GAAID,GAAID,GAeF,iBAJd5mR;4BAKJ,GAhBoB4mR,GAAhBI,GAAID,GAAID,GAAID,GAgBE,iBALd7mR;4BAMJ,GAjBgB6mR,GAAID,GAAhBI,GAAID,GAAID,GAiBM,iBANd9mR;4BAOJ,GAlBY8mR,GAAID,GAAID,GAAhBI,GAAID,GAkBU,iBAPd/mR;4BAQJ,GAnBQ+mR,GAAID,GAAID,GAAID,GAAhBI,GAmBc,iBARdhnR;4BASJ,GApBIgnR,GAAID,GAAID,GAAID,GAAID,GAoBF,iBATd5mR;4BAUJ,GArBoB4mR,GAAhBI,GAAID,GAAID,GAAID,GAqBE,iBAVd7mR;4BAWJ,GAtBgB6mR,GAAID,GAAhBI,GAAID,GAAID,GAsBM,iBAXd9mR;4BAYJ,GAvBY8mR,GAAID,GAAID,GAAhBI,GAAID,GAuBU,iBAZd/mR;4BAaJ,GAxBQ+mR,GAAID,GAAID,GAAID,GAAhBI,GAwBc,iBAbdhnR;4BAcJ,GAzBIgnR,GAAID,GAAID,GAAID,GAAID,GAyBF,iBAdd5mR;4BAeJ,GA1BoB4mR,GAAhBI,GAAID,GAAID,GAAID,GA0BE,iBAfd7mR;4BAgBJ,GA3BgB6mR,GAAID,GAAhBI,GAAID,GAAID,GA2BM,iBAhBd9mR;4BAiBJ,GA5BY8mR,GAAID,GAAID,GAAhBI,GAAID,GA4BU,iBAjBd/mR;4BAkBJ,GA7BQ+mR,GAAID,GAAID,GAAID,GAAhBI,GA6Bc,iBAlBdhnR;4BAmBJ,GA9BIgnR,GAAID,GAAID,GAAID,GAAID,GA8BF,iBAnBd5mR;4BAoBJ,GA/BoB4mR,GAAhBI,GAAID,GAAID,GAAID,GA+BE,iBApBd7mR;4BAqBJ,GAhCgB6mR,GAAID,GAAhBI,GAAID,GAAID,GAgCM,iBArBd9mR;4BAsBJ,GAjCY8mR,GAAID,GAAID,GAAhBI,GAAID,GAiCU,iBAtBd/mR;4BAuBJ,GAlCQ+mR,GAAID,GAAID,GAAID,GAAhBI,GAkCc,iBAvBdhnR;4BAwBJ,GAnCIgnR,GAAID,GAAID,GAAID,GAAID,GAmCF,iBAxBd5mR;4BAyBJ,GApCoB4mR,GAAhBI,GAAID,GAAID,GAAID,GAoCE,iBAzBd7mR;4BA0BJ,GArCgB6mR,GAAID,GAAhBI,GAAID,GAAID,GAqCM,iBA1Bd9mR;4BA2BJ,GAtCY8mR,GAAID,GAAID,GAAhBI,GAAID,GAsCU,iBA3Bd/mR;4BA4BJ,GAvCQ+mR,GAAID,GAAID,GAAID,GAAhBI,GAuCc,iBA5BdhnR;4BA6BJ,GAxCIgnR,GAAID,GAAID,GAAID,GAAID,GAwCF,iBA7Bd5mR;4BA8BJ,GAzCoB4mR,GAAhBI,GAAID,GAAID,GAAID,GAyCE,iBA9Bd7mR;4BA+BJ,GA1CgB6mR,GAAID,GAAhBI,GAAID,GAAID,GA0CM,iBA/Bd9mR;4BAgCJ,GA3CY8mR,GAAID,GAAID,GAAhBI,GAAID,GA2CU,iBAhCd/mR;4BAiCJ,GA5CQ+mR,GAAID,GAAID,GAAID,GAAhBI,GA4Cc,iBAjCdhnR;4BAkCJ,GA7CIgnR,GAAID,GAAID,GAAID,GAAID,GA6CF,iBAlCd5mR;4BAmCJ,GA9CoB4mR,GAAhBI,GAAID,GAAID,GAAID,GA8CE,iBAnCd7mR;4BAoCJ,GA/CgB6mR,GAAID,GAAhBI,GAAID,GAAID,GA+CM,iBApCd9mR;4BAqCJ,GAhDY8mR,GAAID,GAAID,GAAhBI,GAAID,GAgDU,iBArCd/mR;4BAsCJ,GAjDQ+mR,GAAID,GAAID,GAAID,GAAhBI,GAiDc,iBAtCdhnR;4BAuCJ,GAlDIgnR,GAAID,GAAID,GAAID,GAAID,GAkDF,iBAvCd5mR;4BAwCJ,GAnDoB4mR,GAAhBI,GAAID,GAAID,GAAID,GAmDE,iBAxCd7mR;4BAyCJ,GApDgB6mR,GAAID,GAAhBI,GAAID,GAAID,GAoDM,iBAzCd9mR;4BA0CJ,GArDY8mR,GAAID,GAAID,GAAhBI,GAAID,GAqDU,iBA1Cd/mR;4BA2CJ,GAtDQ+mR,GAAID,GAAID,GAAID,GAAhBI,GAsDc,iBA3CdhnR;4BA4CJ,GAvDIgnR,GAAID,GAAID,GAAID,GAAID,GAuDF,iBA5Cd5mR;4BA6CJ,GAxDoB4mR,GAAhBI,GAAID,GAAID,GAAID,GAwDE,iBA7Cd7mR;4BA8CJ,GAzDgB6mR,GAAID,GAAhBI,GAAID,GAAID,GAyDM,iBA9Cd9mR;4BA+CJ,GA1DY8mR,GAAID,GAAID,GAAhBI,GAAID,GA0DU,iBA/Cd/mR;4BAgDJ,GA3DQ+mR,GAAID,GAAID,GAAID,GAAhBI,GA2Dc,iBAhDdhnR;4BAiDJ,GA5DIgnR,GAAID,GAAID,GAAID,GAAID,GA4DF,iBAjDd5mR;4BAkDJ,GA7DoB4mR,GAAhBI,GAAID,GAAID,GAAID,GA6DE,iBAlDd7mR;4BAmDJ,GA9DgB6mR,GAAID,GAAhBI,GAAID,GAAID,GA8DM,iBAnDd9mR;4BAoDJ,GA/DY8mR,GAAID,GAAID,GAAhBI,GAAID,GA+DU,iBApDd/mR;4BAqDJ,GAhEQ+mR,GAAID,GAAID,GAAID,GAAhBI,GAgEc,iBArDdhnR;4BAsDJ,GAjEIgnR,GAAID,GAAID,GAAID,GAAID,GAiEF,iBAtDd5mR;4BAuDJ,GAlEoB4mR,GAAhBI,GAAID,GAAID,GAAID,GAkEE,iBAvDd7mR;4BAwDJ,GAnEgB6mR,GAAID,GAAhBI,GAAID,GAAID,GAmEM,iBAxDd9mR;4BAyDJ,GApEY8mR,GAAID,GAAID,GAAhBI,GAAID,GAoEU,iBAzDd/mR;4BA0DJ,GArEQ+mR,GAAID,GAAID,GAAID,GAAhBI,GAqEc,iBA1DdhnR;4BA2DJ,GAtEIgnR,GAAID,GAAID,GAAID,GAAID,GAsEF,iBA3Dd5mR;4BA4DJ,GAvEoB4mR,GAAhBI,GAAID,GAAID,GAAID,GAuEE,iBA5Dd7mR;4BA6DJ,GAxEgB6mR,GAAID,GAAhBI,GAAID,GAAID,GAwEM,iBA7Dd9mR;4BA8DJ,GAzEY8mR,GAAID,GAAID,GAAhBI,GAAID,GAyEU,iBA9Dd/mR;4BA+DJ,GA1EQ+mR,GAAID,GAAID,GAAID,GAAhBI,GA0Ec,iBA/DdhnR;4BAgEJ,GA3EIgnR,GAAID,GAAID,GAAID,GAAID,GA2EF,iBAhEd5mR;4BAiEJ,GA5EoB4mR,GAAhBI,GAAID,GAAID,GAAID,GA4EE,iBAjEd7mR;4BAkEJ,GA7EgB6mR,GAAID,GAAhBI,GAAID,GAAID,GA6EM,iBAlEd9mR;4BAmEJ,GA9EY8mR,GAAID,GAAID,GAAhBI,GAAID,GA8EU,iBAnEd/mR;4BAoEJ,GA/EQ+mR,GAAID,GAAID,GAAID,GAAhBI,GA+Ec,iBApEdhnR;4BAqEJ,GAhFIgnR,GAAID,GAAID,GAAID,GAAID,GAgFF,iBArEd5mR;4BAsEJ,GAjFoB4mR,GAAhBI,GAAID,GAAID,GAAID,GAiFE,iBAtEd7mR;4BAuEJ,GAlFgB6mR,GAAID,GAAhBI,GAAID,GAAID,GAkFM,iBAvEd9mR;4BAwEJ,GAnFY8mR,GAAID,GAAID,GAAhBI,GAAID,GAmFU,iBAxEd/mR;4BAyEJ,GApFQ+mR,GAAID,GAAID,GAAID,GAAhBI,GAoFc,iBAzEdhnR;4BA0EJ,GArFIgnR,GAAID,GAAID,GAAID,GAAID,GAqFF,iBA1Ed5mR;4BA2EJ,GAtFoB4mR,GAAhBI,GAAID,GAAID,GAAID,GAsFE,iBA3Ed7mR;4BA4EJ,GAvFgB6mR,GAAID,GAAhBI,GAAID,GAAID,GAuFM,iBA5Ed9mR;4BA6EJ,GAxFY8mR,GAAID,GAAID,GAAhBI,GAAID,GAwFU,iBA7Ed/mR;4BA8EJ,GAzFQ+mR,GAAID,GAAID,GAAID,GAAhBI,GAyFc,iBA9EdhnR;4BA+EJ,GA1FIgnR,GAAID,GAAID,GAAID,GAAID,GA0FF,iBA/Ed5mR;4BAgFJ,GA3FoB4mR,GAAhBI,GAAID,GAAID,GAAID,GA2FE,iBAhFd7mR;4BAiFJ,GA5FgB6mR,GAAID,GAAhBI,GAAID,GAAID,GA4FM,iBAjFd9mR;4BAkFJ,GA7FY8mR,GAAID,GAAID,GAAhBI,GAAID,GA6FU,iBAlFd/mR;4BAmFJ,GA9FQ+mR,GAAID,GAAID,GAAID,GAAhBI,GA8Fc,iBAnFdhnR;4BAoFJ,IA/FwB2mR,IAAKD,IAAKD,IAAKluF,IAAKiuF,IA+FpB,iBApFpBxmR;4BAqFJ,IAhG4CwmR,IAApBG,IAAKD,IAAKD,IAAKluF,IAgGf,iBArFpBv4L;4BAsFJ,IAjGuCu4L,IAAKiuF,IAApBG,IAAKD,IAAKD,IAiGV,iBAtFpBzmR;4BAuFJ,IAlGkCymR,IAAKluF,IAAKiuF,IAApBG,IAAKD,IAkGL,iBAvFpB1mR;4BAwFJ,IAnG6B0mR,IAAKD,IAAKluF,IAAKiuF,IAApBG,IAmGA,iBAxFpB3mR;4BAyFJ,IApGwB2mR,IAAKD,IAAKD,IAAKluF,IAAKiuF,IAoGpB,iBAzFpBxmR;4BA0FJ,IArG4CwmR,IAApBG,IAAKD,IAAKD,IAAKluF,IAqGf,iBA1FpBv4L;4BA2FJ,IAtGuCu4L,IAAKiuF,IAApBG,IAAKD,IAAKD,IAsGV,iBA3FpBzmR;4BA4FJ,IAvGkCymR,IAAKluF,IAAKiuF,IAApBG,IAAKD,IAuGL,iBA5FpB1mR;4BA6FJ,IAxG6B0mR,IAAKD,IAAKluF,IAAKiuF,IAApBG,IAwGA,iBA7FpB3mR;4BA8FJ,IAzGwB2mR,IAAKD,IAAKD,IAAKluF,IAAKiuF,IAyGpB,iBA9FpBxmR;4BA+FJ,IA1G4CwmR,IAApBG,IAAKD,IAAKD,IAAKluF,IA0Gf,iBA/FpBv4L;4BAgGJ,IA3GuCu4L,IAAKiuF,IAApBG,IAAKD,IAAKD,IA2GV,iBAhGpBzmR;4BAiGJ,IA5GkCymR,IAAKluF,IAAKiuF,IAApBG,IAAKD,IA4GL,iBAjGpB1mR;4BAkGJ,IA7G6B0mR,IAAKD,IAAKluF,IAAKiuF,IAApBG,IA6GA,iBAlGpB3mR;4BAmGJ,IA9GwB2mR,IAAKD,IAAKD,IAAKluF,IAAKiuF,IA8GpB,iBAnGpBxmR;4BAoGJ,IA/G4CwmR,IAApBG,IAAKD,IAAKD,IAAKluF,IA+Gf,iBApGpBv4L;4BAqGJ,IAhHuCu4L,IAAKiuF,IAApBG,IAAKD,IAAKD,IAgHV,iBArGpBzmR;4BAsGJ,IAjHkCymR,IAAKluF,IAAKiuF,IAApBG,IAAKD,IAiHL,iBAtGpB1mR;4BAuGJ,IAlH6B0mR,IAAKD,IAAKluF,IAAKiuF,IAApBG,IAkHA,iBAvGpB3mR;4BAwGJ,IAnHwB2mR,IAAKD,IAAKD,IAAKluF,IAAKiuF,IAmHpB,iBAxGpBxmR;4BAyGJ,IApH4CwmR,IAApBG,IAAKD,IAAKD,IAAKluF,IAoHf,iBAzGpBv4L;4BA0GJ,IArHuCu4L,IAAKiuF,IAApBG,IAAKD,IAAKD,IAqHV,iBA1GpBzmR;4BA2GJ,IAtHkCymR,IAAKluF,IAAKiuF,IAApBG,IAAKD,IAsHL,iBA3GpB1mR;4BA4GJ,IAvH6B0mR,IAAKD,IAAKluF,IAAKiuF,IAApBG,IAuHA,iBA5GpB3mR;4BA6GJ,IAxHwB2mR,IAAKD,IAAKD,IAAKluF,IAAKiuF,IAwHpB,iBA7GpBxmR;4BA8GJ,IAzH4CwmR,IAApBG,IAAKD,IAAKD,IAAKluF,IAyHf,iBA9GpBv4L;4BA+GJ,IA1HuCu4L,IAAKiuF,IAApBG,IAAKD,IAAKD,IA0HV,iBA/GpBzmR;4BAgHJ,IA3HkCymR,IAAKluF,IAAKiuF,IAApBG,IAAKD,IA2HL,iBAhHpB1mR;4BAiHJ,IA5H6B0mR,IAAKD,IAAKluF,IAAKiuF,IAApBG,IA4HA,iBAjHpB3mR;4BAkHJ,IA7HwB2mR,IAAKD,IAAKD,IAAKluF,IAAKiuF,IA6HpB,iBAlHpBxmR;4BAmHJ,IA9H4CwmR,IAApBG,IAAKD,IAAKD,IAAKluF,IA8Hf,iBAnHpBv4L;4BAoHJ,IA/HuCu4L,IAAKiuF,IAApBG,IAAKD,IAAKD,IA+HV,iBApHpBzmR;4BAqHJ,IAhIkCymR,IAAKluF,IAAKiuF,IAApBG,IAAKD,IAgIL,iBArHpB1mR;4BAsHJ,IAjI6B0mR,IAAKD,IAAKluF,IAAKiuF,IAApBG,IAiIA,iBAtHpB3mR;4BAuHJ,IAlIwB2mR,IAAKD,IAAKD,IAAKluF,IAAKiuF,IAkIpB,iBAvHpBxmR;4BAwHJ,IAnI4CwmR,IAApBG,IAAKD,IAAKD,IAAKluF,IAmIf,iBAxHpBv4L;4BAyHJ,IApIuCu4L,IAAKiuF,IAApBG,IAAKD,IAAKD,IAoIV,iBAzHpBzmR;4BA0HJ,IArIkCymR,IAAKluF,IAAKiuF,IAApBG,IAAKD,IAqIL,iBA1HpB1mR;4BA2HJ,IAtI6B0mR,IAAKD,IAAKluF,IAAKiuF,IAApBG,IAsIA,iBA3HpB3mR;4BA4HJ,IAvIwB2mR,IAAKD,IAAKD,IAAKluF,IAAKiuF,IAuIpB,iBA5HpBxmR;4BA6HJ,IAxI4CwmR,IAApBG,IAAKD,IAAKD,IAAKluF,IAwIf,iBA7HpBv4L;4BA8HJ,IAzIuCu4L,IAAKiuF,IAApBG,IAAKD,IAAKD,IAyIV,iBA9HpBzmR;4BA+HJ,IA1IkCymR,IAAKluF,IAAKiuF,IAApBG,IAAKD,IA0IL,iBA/HpB1mR;4BAgIJ,IA3I6B0mR,IAAKD,IAAKluF,IAAKiuF,IAApBG,IA2IA,iBAhIpB3mR;4BAiIJ,IA5IwB2mR,IAAKD,IAAKD,IAAKluF,IAAKiuF,IA4IpB,iBAjIpBxmR;4BAkIJ,IA7I4CwmR,IAApBG,IAAKD,IAAKD,IAAKluF,IA6If,iBAlIpBv4L;4BAmIJ,IA9IuCu4L,IAAKiuF,IAApBG,IAAKD,IAAKD,IA8IV,iBAnIpBzmR;4BAoIJ,IA/IkCymR,IAAKluF,IAAKiuF,IAApBG,IAAKD,IA+IL,iBApIpB1mR;4BAqIJ,IAhJ6B0mR,IAAKD,IAAKluF,IAAKiuF,IAApBG,IAgJA,iBArIpB3mR;4BAsIJ,IAjJwB2mR,IAAKD,IAAKD,IAAKluF,IAAKiuF,IAiJpB,iBAtIpBxmR;4BAuIJ,IAlJ4CwmR,IAApBG,IAAKD,IAAKD,IAAKluF,IAkJf,iBAvIpBv4L;4BAwIJ,IAnJuCu4L,IAAKiuF,IAApBG,IAAKD,IAAKD,IAmJV,iBAxIpBzmR;4BAyIJ,IApJkCymR,IAAKluF,IAAKiuF,IAApBG,IAAKD,IAoJL,iBAzIpB1mR;4BA0IJ,IArJ6B0mR,IAAKD,IAAKluF,IAAKiuF,IAApBG,IAqJA,iBA1IpB3mR;4BA2IJ,IAtJwB2mR,IAAKD,IAAKD,IAAKluF,IAAKiuF,IAsJpB,iBA3IpBxmR;4BA4IJ,IAvJ4CwmR,IAApBG,IAAKD,IAAKD,IAAKluF,IAuJf,iBA5IpBv4L;4BA6IJ,IAxJuCu4L,IAAKiuF,IAApBG,IAAKD,IAAKD,IAwJV,iBA7IpBzmR;4BA8IJ,IAzJkCymR,IAAKluF,IAAKiuF,IAApBG,IAAKD,IAyJL,iBA9IpB1mR;4BA+IJ,IA1J6B0mR,IAAKD,IAAKluF,IAAKiuF,IAApBG,IA0JA,iBA/IpB3mR;4BAgJJ,IA3JwB2mR,IAAKD,IAAKD,IAAKluF,IAAKiuF,IA2JpB,iBAhJpBxmR;4BAiJJ,IA5J4CwmR,IAApBG,IAAKD,IAAKD,IAAKluF,IA4Jf,iBAjJpBv4L;4BAkJJ,IA7JuCu4L,IAAKiuF,IAApBG,IAAKD,IAAKD,IA6JV,iBAlJpBzmR;4BAmJJ,IA9JkCymR,IAAKluF,IAAKiuF,IAApBG,IAAKD,IA8JL,iBAnJpB1mR;4BAoJJ,IA/J6B0mR,IAAKD,IAAKluF,IAAKiuF,IAApBG,IA+JA,iBApJpB3mR;4BAqJJ,IAhKwB2mR,IAAKD,IAAKD,IAAKluF,IAAKiuF,IAgKpB,iBArJpBxmR;4BAsJJ,IAjK4CwmR,IAApBG,IAAKD,IAAKD,IAAKluF,IAiKf,iBAtJpBv4L;4BAuJJ,IAlKuCu4L,IAAKiuF,IAApBG,IAAKD,IAAKD,IAkKV,iBAvJpBzmR;4BAwJJ,IAnKkCymR,IAAKluF,IAAKiuF,IAApBG,IAAKD,IAmKL,iBAxJpB1mR;4BAyJJ,IApK6B0mR,IAAKD,IAAKluF,IAAKiuF,IAApBG,IAoKA,iBAzJpB3mR;4BA0JJ,IArKwB2mR,IAAKD,IAAKD,IAAKluF,IAAKiuF,IAqKpB,iBA1JpBxmR;4BA2JJ,IAtK4CwmR,IAApBG,IAAKD,IAAKD,IAAKluF,IAsKf,iBA3JpBv4L;4BA4JJ,IAvKuCu4L,IAAKiuF,IAApBG,IAAKD,IAAKD,IAuKV,iBA5JpBzmR;4BA6JJ,IAxKkCymR,IAAKluF,IAAKiuF,IAApBG,IAAKD,IAwKL,iBA7JpB1mR;4BA8JJ,IAzK6B0mR,IAAKD,IAAKluF,IAAKiuF,IAApBG,IAyKA,iBA9JpB3mR;4BA+JJ,IA1KwB2mR,IAAKD,IAAKD,IAAKluF,IAAKiuF,IA0KpB,iBA/JpBxmR;4BAgKJ,IA3K4CwmR,IAApBG,IAAKD,IAAKD,IAAKluF,IA2Kf,iBAhKpBv4L;4BAiKJ,IA5KuCu4L,IAAKiuF,IAApBG,IAAKD,IAAKD,IA4KV,iBAjKpBzmR;4BAkKJ,IA7KkCymR,IAAKluF,IAAKiuF,IAApBG,IAAKD,IA6KL,iBAlKpB1mR;4BAmKJ,IA9K6B0mR,IAAKD,IAAKluF,IAAKiuF,IAApBG,IA8KA,iBAnKpB3mR;4BAEO,UAmKS,iBAjLJ6iR;4BAiLT,UAhLgCtqF,SAA3BuuF;4BAaD;6BAmKJ,MAhLqCN;6BAgLrC,MAhLSK;6BAkLH;gDAnLGhE;;;;;4BAmLhB,iBAnLgBA;4BAcL;6BAqKX,MAlLwB8D;6BAkLxB,MAlLoBC;6BAmLP;gDApLG/D;;;;;4BAoLhB,iBApLgBA;4BAcL;6BAsKX,MAnL6B6D;6BAmL7B,MAnLIM;6BAoLS;gDArLGnE;;;;;4BAqLhB,iBArLgBA;4BAcL;6BAuKX,MApLkC4D;6BAoLlC,MApLQM;6BAqLK;gDAtLGlE;;;;;4BAsLhB,iBAtLgBA;4BAcL,UAb4BtqF;4BAsLvC,iBAvLgBsqF;4BAuLhB,SACE;;uBAIAoE;iCASExF,YAAaxzJ,KAAK40J,IAAInmQ,IAAIxe,IAAI6B;0BACtB;kDADU8iR;2BACV,SADkB3kR;2BAClB,SADsB6B;2BAIrB,eADTsnE;0BACJ,iBAJsBw7M;0BAKV,iBAAT,iBALmBA;4BAKqB,2BALrBA;4BAKC,iBALDA;0BACV;2BAI8C,MAFtDx7M;2BAG4B,MAAT,iBANDw7M;0BAMtB,iBANsBA;0BAMtB;qCANsBA;8BASf,IACC//Q,OAVc+/Q;8BASf,GANHx7M,WAOIvkE;gCAGF,WAbWmrH,KAASvxG,IAEtBsnF,SAFkB6+K,cAGlBx7M;gCAUE,SAbgBw7M,SAGlBx7M;gCAUE;8BAGF,WAhBa4mD,KAASvxG,IAEtBsnF,SAFkB6+K,cAUd//Q;8BAOJ,gBJ3SJo/Q,cI0RsBW;8BAiBlB,WAfA7+K,WAQIlhG;8BAOJ,WAdAukE,WAOIvkE;;uCAPJukE;gCAkBA,gBArBAo6M,YAAkBoB,IAAInmQ,IAEtBsnF;gCAmBA,WAnBAA;gCAmBA,WAlBA38B;;8BAsBF,WAzBe4mD,KAASvxG,IAEtBsnF,SAFkB6+K,SAGlBx7M;8BAsBF,SAtBEA;8BAsBF;;;;+CAEY;wCAAE;uBAEd6/M;iCAAkBrE,IAAInmQ,IAAIxe,IAAI6B;0BAChC,cJxTAmiR,mBIuToBW,IAAInmQ,IAAIxe,IAAI6B,IAC8B;uBAE5DonR;iCAAsBtE,IAAInmQ,IAAIxe,IAAI6B;0BACpC;mCLxSA0hR,YCpDAK,oBI2VwBe,IAAInmQ,IAAIxe,IAAI6B,IAE/B;uBAEHqnR;iCAAWvE;0BACb,SADaA,gBAEH;0BACV,eAHaA;0BAGb,QAFIvlR;4BAKF,KANWulR,OACTvlR;4BAMF,gBJrUF4kR,cI8TaW;4BAOX;0BAEF,KATaA,OACTvlR;0BAAJ,UASwB,iBAVXulR;0BAUb,iBAVaA;0BACb,UAUwB,iBAXXA;0BAWb,iBAXaA;0BAYb,gBJ1UAX,cI8TaW;0BACb,IAYA38M;0BACE;;8BAZEnhE,IAWJmhE,YAC6B,iBAdhB28M,OAab38M;4BACE,UADFA;;4BAGA,OAdInhE,IAcD;;;yBA1UDghR;yBAmTAmB;yBAGAC;yBAIAC;yBA7TAtB;uBCpCAuB;iCAAM5nR,EAAE2C,GAAI,OAAN3C,KAAE2C,IAAF3C,YAAE2C,UAAkC;uBAgC1CklR;iCAAIzE;0BAAgD,iBAAhDA,QAA6B,WAA7BA;0BAA6B,UAA7BA,mBAAkE;uBAEtE0E;;0BACM,IAAJ7nR,EAAI,2BAAJA,EAAI,cAKP;uBAEC8nR,cAAGjoR,EAAEzB,EAAE8iC,GAAkB,OAAlBA,IAAJrhC,KAAEzB,IAAE8iC,EAAsC;uBAM7C6mP,cAJGloR,EAAEzB,EAAE8iC,GAAW,OAAfrhC,IAAEzB,IAAE8iC,CAA2B;uBAElC8mP,cAAGnoR,EAAEzB,EAAE8iC,GAAW,QAAfrhC,IAAEzB,MAAE8iC,KAAJrhC,IAAEzB,OAA8C;uBAInDiI;uBAEAC;uBAEAm8F;uBAEAwlL;uBAEAC;iCAEEpG,YAAYqB,IAAInmQ,IAAIxe;0BACZ;iDADI2kR;2BAEJ,sBAFIA;2BAGJ,sBAHIA;2BAIJ,sBAJIA;2BAKJ,sBALIA;2BAMR;mCACJltQ,EAAErY;4BASU;oCATVA;6BAQU,OARVA;6BASO,uBAVT0C;6BAQY,OAPV1C;6BAQO,uBATT0C;6BAOQ,MANN1C;6BAOO,uBART0C;6BAME;;gCACG,iBAPLA;;;;;;;;6BAME,MALA1C;4BAWJ,iBAZE0C,sBAIE8B;4BAMU,UATVxE;4BAYJ,wBAbE0C,mBAaa;0BAbT,SAcJ22H,MAAMl3H,EAAEC,EAAEqD,EAAEpH,EAAE8W,EAAElQ,EAAEd,EAAEzB;4BACS;8CADbuC,EAAR7C,KAAEqD,KAAEpH;6BACI,cADV8D;4BACK,UADGgT,iCAAIhR,SAAEzB;4BAEV,eAFFN;4BAEE,QAAY;8BAC1BpC;0BACE;4BAAS;;yCAxBPkkR,YAAgB9kQ,IAAIxe,OAuBxBZ;4BACE,iBAlBE0C,EAiBJ1C;4BACW,UADXA;;4BAGA,MAzBImC,EACAC,EACAqD,EACApH,EACA8W,EAvBF+0Q,KAQAzhR,GAoCoB,iBApBlB/F;4BAqBJ,MAtBIyS,EAJAhT,EACAC,EACAqD,EACApH,EAtBF6rR,KAQAzhR,GAqCoB,iBArBlB/F;4BAsBJ,MAxBIrE,EACA8W,EAJAhT,EACAC,EACAqD,EArBFykR,KAQAzhR,GAsCoB,iBAtBlB/F;4BAuBJ,MA1BI+C,EACApH,EACA8W,EAJAhT,EACAC,EApBF8nR,KAQAzhR,GAuCoB,iBAvBlB/F;4BAwBJ,MA5BIN,EACAqD,EACApH,EACA8W,EAJAhT,EAnBF+nR,KAQAzhR,GAwCoB,iBAxBlB/F;4BAyBJ,MA9BIP,EACAC,EACAqD,EACApH,EACA8W,EAvBF+0Q,KAQAzhR,GAyCoB,iBAzBlB/F;4BA0BJ,MA3BIyS,EAJAhT,EACAC,EACAqD,EACApH,EAtBF6rR,KAQAzhR,GA0CoB,iBA1BlB/F;4BA2BJ,MA7BIrE,EACA8W,EAJAhT,EACAC,EACAqD,EArBFykR,KAQAzhR,GA2CoB,iBA3BlB/F;4BA4BJ,MA/BI+C,EACApH,EACA8W,EAJAhT,EACAC,EApBF8nR,KAQAzhR,GA4CoB,iBA5BlB/F;4BA6BJ,MAjCIN,EACAqD,EACApH,EACA8W,EAJAhT,EAnBF+nR,KAQAzhR,GA6CoB,iBA7BlB/F;4BA8BJ,MAnCIP,EACAC,EACAqD,EACApH,EACA8W,EAvBF+0Q,KAQAzhR,GA8CoB,iBA9BlB/F;4BA+BJ,MAhCIyS,EAJAhT,EACAC,EACAqD,EACApH,EAtBF6rR,KAQAzhR,GA+CoB,iBA/BlB/F;4BAgCJ,MAlCIrE,EACA8W,EAJAhT,EACAC,EACAqD,EArBFykR,KAQAzhR,GAgDoB,iBAhClB/F;4BAiCJ,MApCI+C,EACApH,EACA8W,EAJAhT,EACAC,EApBF8nR,KAQAzhR,GAiDoB,iBAjClB/F;4BAkCJ,MAtCIN,EACAqD,EACApH,EACA8W,EAJAhT,EAnBF+nR,KAQAzhR,GAkDoB,iBAlClB/F;4BAmCJ,MAxCIP,EACAC,EACAqD,EACApH,EACA8W,EAvBF+0Q,KAQAzhR,GAmDoB,iBAnClB/F;4BAoCJ,MArCIyS,EAJAhT,EACAC,EACAqD,EACApH,EAtBF6rR,KAQAzhR,GAoDoB;4BACtB,MAvCIpK,EACA8W,EAJAhT,EACAC,EACAqD,EArBFykR,KAQAzhR,GAqDoB;4BACtB,MAzCIhD,EACApH,EACA8W,EAJAhT,EACAC,EApBF8nR,KAQAzhR,GAsDoB;4BACtB,MA3CIrG,EACAqD,EACApH,EACA8W,EAJAhT,EAnBF+nR,KAQAzhR,GAuDoB;4BACtB,MA7CItG,EACAC,EACAqD,EACApH,EACA8W,EAjBFg1Q,KAIAzhR,GAsDoB;4BACtB,MA1CIyM,EAJAhT,EACAC,EACAqD,EACApH,EAhBF8rR,KAIAzhR,GAuDoB;4BACtB,MA5CIrK,EACA8W,EAJAhT,EACAC,EACAqD,EAfF0kR,KAIAzhR,GAwDoB;4BACtB,MA9CIjD,EACApH,EACA8W,EAJAhT,EACAC,EAdF+nR,KAIAzhR,GAyDoB;4BACtB,MAhDItG,EACAqD,EACApH,EACA8W,EAJAhT,EAbFgoR,KAIAzhR,GA0DoB;4BACtB,MAlDIvG,EACAC,EACAqD,EACApH,EACA8W,EAjBFg1Q,KAIAzhR,GA2DoB;4BACtB,MA/CIyM,EAJAhT,EACAC,EACAqD,EACApH,EAhBF8rR,KAIAzhR,GA4DoB;4BACtB,MAjDIrK,EACA8W,EAJAhT,EACAC,EACAqD,EAfF0kR,KAIAzhR,GA6DoB;4BACtB,MAnDIjD,EACApH,EACA8W,EAJAhT,EACAC,EAdF+nR,KAIAzhR,GA8DoB;4BACtB,MArDItG,EACAqD,EACApH,EACA8W,EAJAhT,EAbFgoR,KAIAzhR,GA+DoB;4BACtB,MAvDIvG,EACAC,EACAqD,EACApH,EACA8W,EAjBFg1Q,KAIAzhR,GAgEoB;4BACtB,MApDIyM,EAJAhT,EACAC,EACAqD,EACApH,EAhBF8rR,KAIAzhR,GAiEoB;4BACtB,MAtDIrK,EACA8W,EAJAhT,EACAC,EACAqD,EAfF0kR,KAIAzhR,GAkEoB;4BACtB,MAxDIjD,EACApH,EACA8W,EAJAhT,EACAC,EAdF+nR,KAIAzhR,GAmEoB;4BACtB,MA1DItG,EACAqD,EACApH,EACA8W,EAJAhT,EAbFgoR,KAIAzhR,GAoEoB;4BACtB,MA5DIvG,EACAC,EACAqD,EACApH,EACA8W,EAjBFg1Q,KAIAzhR,GAqEoB;4BACtB,MAzDIyM,EAJAhT,EACAC,EACAqD,EACApH,EAhBF8rR,KAIAzhR,GAsEoB;4BACtB,MA3DIrK,EACA8W,EAJAhT,EACAC,EACAqD,EAfF0kR,KAIAzhR,GAuEoB;4BACtB,MA7DIjD,EACApH,EACA8W,EAJAhT,EACAC,EAdF+nR,KAIAzhR,GAwEoB;4BACtB,MA/DItG,EACAqD,EACApH,EACA8W,EAJAhT,EAbFgoR,KAIAzhR,GAyEoB;4BACtB,MAjEIvG,EACAC,EACAqD,EACApH,EACA8W,EAnBFi1Q,KAQAvlL,GAwEoB;4BACtB,MA9DI1vF,EAJAhT,EACAC,EACAqD,EACApH,EAlBF+rR,KAQAvlL,GAyEoB;4BACtB,MAhEIxmG,EACA8W,EAJAhT,EACAC,EACAqD,EAjBF2kR,KAQAvlL,GA0EoB;4BACtB,MAlEIp/F,EACApH,EACA8W,EAJAhT,EACAC,EAhBFgoR,KAQAvlL,GA2EoB;4BACtB,MApEIziG,EACAqD,EACApH,EACA8W,EAJAhT,EAfFioR,KAQAvlL,GA4EoB;4BACtB,MAtEI1iG,EACAC,EACAqD,EACApH,EACA8W,EAnBFi1Q,KAQAvlL,GA6EoB;4BACtB,MAnEI1vF,EAJAhT,EACAC,EACAqD,EACApH,EAlBF+rR,KAQAvlL,GA8EoB;4BACtB,MArEIxmG,EACA8W,EAJAhT,EACAC,EACAqD,EAjBF2kR,KAQAvlL,GA+EoB;4BACtB,MAvEIp/F,EACApH,EACA8W,EAJAhT,EACAC,EAhBFgoR,KAQAvlL,GAgFoB;4BACtB,MAzEIziG,EACAqD,EACApH,EACA8W,EAJAhT,EAfFioR,KAQAvlL,GAiFoB;4BACtB,MA3EI1iG,EACAC,EACAqD,EACApH,EACA8W,EAnBFi1Q,KAQAvlL,GAkFoB;4BACtB,MAxEI1vF,EAJAhT,EACAC,EACAqD,EACApH,EAlBF+rR,KAQAvlL,GAmFoB;4BACtB,MA1EIxmG,EACA8W,EAJAhT,EACAC,EACAqD,EAjBF2kR,KAQAvlL,GAoFoB;4BACtB,MA5EIp/F,EACApH,EACA8W,EAJAhT,EACAC,EAhBFgoR,KAQAvlL,GAqFoB;4BACtB,MA9EIziG,EACAqD,EACApH,EACA8W,EAJAhT,EAfFioR,KAQAvlL,GAsFoB;4BACtB,MAhFI1iG,EACAC,EACAqD,EACApH,EACA8W,EAnBFi1Q,KAQAvlL,GAuFoB;4BACtB,MA7EI1vF,EAJAhT,EACAC,EACAqD,EACApH,EAlBF+rR,KAQAvlL,GAwFoB;4BACtB,MA/EIxmG,EACA8W,EAJAhT,EACAC,EACAqD,EAjBF2kR,KAQAvlL,GAyFoB;4BACtB,MAjFIp/F,EACApH,EACA8W,EAJAhT,EACAC,EAhBFgoR,KAQAvlL,GA0FoB;4BACtB,MAnFIziG,EACAqD,EACApH,EACA8W,EAJAhT,EAfFioR,KAQAvlL,GA2FoB;4BACtB,MArFI1iG,EACAC,EACAqD,EACApH,EACA8W,EAjBFg1Q,KAQAE,GA0FoB;4BACtB,MAlFIl1Q,EAJAhT,EACAC,EACAqD,EACApH,EAhBF8rR,KAQAE,GA2FoB;4BACtB,MApFIhsR,EACA8W,EAJAhT,EACAC,EACAqD,EAfF0kR,KAQAE,GA4FoB;4BACtB,MAtFI5kR,EACApH,EACA8W,EAJAhT,EACAC,EAdF+nR,KAQAE,GA6FoB;4BACtB,MAxFIjoR,EACAqD,EACApH,EACA8W,EAJAhT,EAbFgoR,KAQAE,GA8FoB;4BACtB,MA1FIloR,EACAC,EACAqD,EACApH,EACA8W,EAjBFg1Q,KAQAE,GA+FoB;4BACtB,MAvFIl1Q,EAJAhT,EACAC,EACAqD,EACApH,EAhBF8rR,KAQAE,GAgGoB;4BACtB,MAzFIhsR,EACA8W,EAJAhT,EACAC,EACAqD,EAfF0kR,KAQAE,GAiGoB;4BACtB,MA3FI5kR,EACApH,EACA8W,EAJAhT,EACAC,EAdF+nR,KAQAE,GAkGoB;4BACtB,MA7FIjoR,EACAqD,EACApH,EACA8W,EAJAhT,EAbFgoR,KAQAE,GAmGoB;4BACtB,MA/FIloR,EACAC,EACAqD,EACApH,EACA8W,EAjBFg1Q,KAQAE,GAoGoB;4BACtB,MA5FIl1Q,EAJAhT,EACAC,EACAqD,EACApH,EAhBF8rR,KAQAE,GAqGoB;4BACtB,MA9FIhsR,EACA8W,EAJAhT,EACAC,EACAqD,EAfF0kR,KAQAE,GAsGoB;4BACtB,MAhGI5kR,EACApH,EACA8W,EAJAhT,EACAC,EAdF+nR,KAQAE,GAuGoB;4BACtB,MAlGIjoR,EACAqD,EACApH,EACA8W,EAJAhT,EAbFgoR,KAQAE,GAwGoB;4BACtB,MApGIloR,EACAC,EACAqD,EACApH,EACA8W,EAjBFg1Q,KAQAE,GAyGoB;4BACtB,MAjGIl1Q,EAJAhT,EACAC,EACAqD,EACApH,EAhBF8rR,KAQAE,GA0GoB;4BACtB,MAnGIhsR,EACA8W,EAJAhT,EACAC,EACAqD,EAfF0kR,KAQAE,GA2GoB;4BACtB,MArGI5kR,EACApH,EACA8W,EAJAhT,EACAC,EAdF+nR,KAQAE,GA4GoB;4BACtB,MAvGIjoR,EACAqD,EACApH,EACA8W,EAJAhT,EAbFgoR,KAQAE,GA6GoB;4BAjFX;6BAiFX,MAxGIloR;6BAyG4B,MAAT,iBA1GPojR;4BA0GhB,iBA1GgBA;4BAwBL;6BAkFX,MAxGInjR;6BAyG4B,MAAT,iBA3GPmjR;4BA2GhB,iBA3GgBA;4BAwBL;6BAmFX,MAxGI9/Q;6BAyG4B,MAAT,iBA5GP8/Q;4BA4GhB,iBA5GgBA;4BAwBL;6BAoFX,MAxGIlnR;6BAyG4B,MAAT,iBA7GPknR;4BA6GhB,iBA7GgBA;4BAwBL;6BAqFX,MAxGIpwQ;6BAyG4B,MAAT,iBA9GPowQ;4BA8GhB,iBA9GgBA;4BA8GhB,SACE;uBAEAgF;iCASE55J,KAAMuzJ,YAAYqB,IAAInmQ,IAAIxe,IAAI6B;0BACN;qEADN8iR;2BACM,SADM9iR;2BACN,SADE7B;2BACF,aAAxB0hB;0BAIQ;;yCALUijQ,OAKS,oBAH3Bx7M;0BADwB;2BAIhB,YAJRznD;2BAIQ,YADR4lQ,WAFAn+M;0BAKC;4BACH,WARE4mD,KAAsBvxG,IAGtBsnF,SAHkB6+K,OAClBjjQ,OAGA4lQ;4BAKF,cL/JFvD,cKsJsBY;4BASpB,WAPEx7M,WAEAm+M;4BAKF,WANExhL,WACAwhL;4BAKF;;qCAPEn+M;8BAYF,cAdQm6M,YAAYqB,IAAInmQ,IAGtBsnF;8BAWF,WAZE38B;8BAYF,WAXE28B;;4BAeJ,SAhBI38B;6BAgBc,WAlBd4mD,KAAsBvxG,IAGtBsnF,SAHkB6+K,OAClBjjQ,OACAynD;4BAgB2C,SAC7C;uBAEoB;;0B,OA9BpBwgN,YL7IF5F;uBK8KA;;0B,OAjCE4F;mCL3KF/F,oBDiDAN;uBM2JA;iCAEaqB;0BACa;oEADbA;2BACa,aAAtB70Q;2BAEU;iCADV43Q,uBACyB,wBAAoC;2BACjE;0BACA,YADIj5O,OACyB,sBALhBk2O;0BAMb,oBANaA,IAGT3lR,UADA0oR;0BAKJ,oBAPa/C,IAITl2O;0BAHsB,IAOhB,0BACVrvC;0BACE;;8BAFEyH,IACJzH,UAC6B,iBAVhBulR,OASbvlR;4BACE,UADFA;;4BAGA,OAJIyH,IAID;uBAdH;;yBA5KEwiR;yBAyKAO;yBAEAC;yBAGAC;yBAhLAV;uBC9BAW;iCAAMxoR,EAAE2C,GAAI,OAAN3C,MAAE2C,QAAF3C,WAAE2C,MAAkC;uBAgC1C8lR;iCAAIrF;0BAAgD,iBAAhDA,QAA6B,WAA7BA;0BAA6B,UAA7BA,mBAAkE;uBAEtEsF;;0BACM,IAAJzoR,EAAI,4BAAJA,EAAI,cAeP;uBAECosF;uBA4EAs8L;iCAEE5G,YAAYqB,IAAInmQ,IAAIxe;0BACxB;;;2BAQQ,sBATQ2kR;2BAQR,sBARQA;2BAOR,sBAPQA;2BAMR,sBANQA;2BAKR,sBALQA;2BAIR,sBAJQA;2BAGR,sBAHQA;2BAER,sBAFQA;2BAYR;2BACR30M;0BACE;4BAAS;;yCAdPszM,YAAgB9kQ,IAAIxe,OAaxBgwE;4BACE,iBAFEluE,EACJkuE;4BACW,UADXA;;4BACW,IAGXhI;4BACE;8BAAiE;qCADnEA;+BACqD,MADrDA;+BACgE,uBAN5DlmE;+BAM8C,mBAN9CA;+BAlB2B,cAA1BT;+BAwBgC,MADrC2mE;+BAvBgB,cAAX3mE;+BAwBmB,MADxB2mE;+BACkC,uBAN9BlmE;+BAMiB,qBANjBA;+BAhB4B,cAA3Bu5F;+BAsBa;mCAtBF,QAAXA;;;;;;;;;8BAsBH,iBANEv5F,EAKJkmE;8BACmE,UADnEA;;8BACmE;+BAEnE;yCAAUzmE,EAAEC,EAAEqD,EAAEpH,EAAE8W,EAAElQ,EAAEiC,EAAE5E,EAAE6B,EAAEzB;kCAEP;yCAFHyS;mCAEG,MAFCjO,OAAJiO,QAAElQ,OAAEiC;mCA5ByB;mCAAhB;mCAAf;kCA8BR,WAFgB5E,iCAAE6B,SAAEzB;kCAEP;mCACL,MAHNP;mCAGM,MAHNA,OAAEC,OAAEqD,QAAJtD,OAAEC;mCA9BmC;mCAAhB;kCAiCvB,SAjCQ;kCAkCT,OAJS/D,OAnBYoxE;kCAwBrB,OAxBqBA,QAAIF;kCAwBzB,QAAS;+BAChBvvE;8BACE;;uCADFA;iCACwC,MADxCA;iCACwC,uBAfpC0C;gCAeF;kCA1BEP;kCAAGC;kCAAGqD;kCAAGpH;kCAAG8W;kCAAGlQ;kCAAGiC;kCAAG5E;kCA0BD,iBAzGtBksF;;gCAyGA;wCADFxuF;iCAEwC,OAFxCA;iCAEwC,uBAhBpC0C;gCAgBF;kCA3BuBJ;kCAArBH;kCAAGC;kCAAGqD;kCAAGpH;kCAAG8W;kCAAGlQ;kCAAGiC;kCA2BE,iBA1GtBsnF;;gCAyGA;iCACA,OAFFxuF;iCAGwC,OAHxCA;iCAGwC,uBAjBpC0C;gCAiBF;kCA5BoBwE;kCAAG5E;kCAArBH;kCAAGC;kCAAGqD;kCAAGpH;kCAAG8W;kCAAGlQ;kCA4BK,iBA3GtBupF;;gCAyGA;iCAEA,OAHFxuF;iCAIwC,OAJxCA;iCAIwC,uBAlBpC0C;gCAkBF;kCA7BiBuC;kCAAGiC;kCAAG5E;kCAArBH;kCAAGC;kCAAGqD;kCAAGpH;kCAAG8W;kCA6BQ,iBA5GtBq5E;;gCAyGA;iCAGA,OAJFxuF;iCAKwC,OALxCA;iCAKwC,uBAnBpC0C;gCAmBF;kCA9BcyS;kCAAGlQ;kCAAGiC;kCAAG5E;kCAArBH;kCAAGC;kCAAGqD;kCAAGpH;kCA8BW,iBA7GtBmwF;;gCAyGA;iCAIA,OALFxuF;iCAMwC,OANxCA;iCAMwC,uBApBpC0C;gCAoBF;kCA/BWrE;kCAAG8W;kCAAGlQ;kCAAGiC;kCAAG5E;kCAArBH;kCAAGC;kCAAGqD;kCA+Bc,iBA9GtB+oF;;gCAyGA;iCAKA,OANFxuF;iCAOwC,OAPxCA;iCAOwC,uBArBpC0C;gCAqBF;kCAhCQ+C;kCAAGpH;kCAAG8W;kCAAGlQ;kCAAGiC;kCAAG5E;kCAArBH;kCAAGC;kCAgCiB,iBA/GtBosF;;gCAyGA;iCAMA,OAPFxuF;iCAQwC,OARxCA;iCAQwC,uBAtBpC0C;gCAsBF;kCAjCKN;kCAAGqD;kCAAGpH;kCAAG8W;kCAAGlQ;kCAAGiC;kCAAG5E;kCAArBH;kCAiCoB,iBAhHtBqsF;;gCAyGA,UADFxuF;;gCACE;iCASF,MAnCImC;iCAoCS,uBArCGojR;gCAqChB,iBArCgBA;gCA2Bd;iCAUF,MApCOnjR;iCAqCM,uBAtCGmjR;gCAsChB,iBAtCgBA;gCA2Bd;iCAWF,MArCU9/Q;iCAsCG,uBAvCG8/Q;gCAuChB,iBAvCgBA;gCA2Bd;iCAYF,MAtCalnR;iCAuCA,uBAxCGknR;gCAwChB,iBAxCgBA;gCA2Bd;iCAaF,MAvCgBpwQ;iCAwCH,uBAzCGowQ;gCAyChB,iBAzCgBA;gCA2Bd;iCAcF,MAxCmBtgR;iCAyCN,uBA1CGsgR;gCA0ChB,iBA1CgBA;gCA2Bd;iCAeF,MAzCsBr+Q;iCA0CT,uBA3CGq+Q;gCA2ChB,iBA3CgBA;gCA2Bd;iCAgBF,MA1CyBjjR;iCA2CZ,uBA5CGijR;gCA4ChB,iBA5CgBA;gCA4ChB,WACE;uBAEAwF;iCASEp6J,KAAMuzJ,YAAYqB,IAAInmQ,IAAIxe,IAAI6B;0BACN;qEADN8iR;2BACM,SADM9iR;2BACN,SADE7B;2BACF,aAAxB0hB;0BAIQ;;yCALUijQ,OAKS,oBAH3Bx7M;0BADwB;2BAIhB,YAJRznD;2BAIQ,YADR4lQ,WAFAn+M;0BAKC;4BACH,WARE4mD,KAAsBvxG,IAGtBsnF,SAHkB6+K,OAClBjjQ,OAGA4lQ;4BAKF,gBNrKFvD,cM4JsBY;4BASpB,WAPEx7M,WAEAm+M;4BAKF,WANExhL,WACAwhL;4BAKF;;qCAPEn+M;8BAYF,gBAdQm6M,YAAYqB,IAAInmQ,IAGtBsnF;8BAWF,WAZE38B;8BAYF,WAXE28B;;4BAeJ,SAhBI38B;6BAgBc,WAlBd4mD,KAAsBvxG,IAGtBsnF,SAHkB6+K,OAClBjjQ,OACAynD;4BAgB2C,SAC7C;uBAEoB;;0B,OA9BpBghN,YNnJFpG;uBMoLA;;0B,OAjCEoG;mCNjLFvG,oBDiDAN;uBOiKA;iCAEaqB;0BACa;oEADbA;2BACa,aAAtB70Q;2BAEU;iCADV43Q,uBACyB,wBAAoC;2BACjE;0BACA,YADIj5O,OACyB,sBALhBk2O;0BAMb,oBANaA,IAGT3lR,UADA0oR;0BAKJ,oBAPa/C,IAITl2O;0BAHsB,IAOhB,0BACVrvC;0BACE;;8BAFEyH,IACJzH,UAC6B,iBAVhBulR,OASbvlR;4BACE,UADFA;;4BAGA,OAJIyH,IAID;uBAdH;;yBAhLEojR;yBA6KAG;yBAEAC;yBAGAC;yBApLAN;uBC5BAO;;0BACM,IAAJ/oR,EAAI,4BAAJA,EAAI,cAeP;uBAECgpR;iCAAW7F;0BACH,IAAN99Q,IAAM,uBADG89Q,KACH,WAAN99Q,SACW;uBAEb4jR;uBAEAC;uBAEAC;;;yBA1BAJ;yBAwBAG;yBAEAC;yBARAH;yBAIAC;uBC1BAG;iCAAMrpR,EAAE2C;0BAAI;yDAAN3C,EAAE2C;mCAAkB,gCAApB3C,OAAE2C,OAAkC;uBAa1C2mR;iCAAIlG;0BACN,UADMA,OACN,MADMA,OACN,MADMA;0BACA,iBADAA,0BACqE;uBAEzEmG;iCAAKC;0BACP,IAAIC,iBADGD;0BAED,mCADFC,MADGD,QAEuC;uBAI5CE;uBA4BAC;uBA4BAC;uBA4B+C;iCAEjCnoR;0B,IAGhBC;;0BACE;4BAKE;;;;yCAAkB7D;kCACd;yCADcA;mCAC4C,MAD5CA;mCAC4C,uBAVlD4D;mCAUkC,MAD5B5D;mCAC4B,uBAVlC4D;mCAUkB,MADZ5D;mCACY,uBAVlB4D;mCAUG,uBAVHA;kCAUR;;;+EAVQA,EASM5D;;iDACsD;6BAE1E4oE;;4BACE;;sCADFA;+BACkC,OADlCA;+BACkC,YAAY,iBAL1CxzB;+BAKM;gEALNA;+BAMFo5C;8BACE;;qCADFA;iCACE,MAAIgC,MAHR5nB;iCAIiB,MADT4nB,MAHR5nB;iCAIiB;kEAhBHhlE,oBAaRk8G;gCAGF,iBAhBUl8G;gCAeV,UADF4qF;;gCACE,UAHJ5lB;;gCAGI,IAMApjE,KAAQ,iBArBE5B;gCAuBZ;kCAFU,SAbRwxC,GAaA5vC;qC,gBAGKxF,EAAEisR;uCACG;2DAvDdF,aAsDS/rR;wCAEO,uBA1BF4D,EAyBJgC;uCACJ,iBAlBFwvC;uCAiBU,UAEC,MANX5vC,KAGOymR;uCAGL,iBA3BQroR,EAyBJgC;uCAGC,wBApBPwvC;uCAoBO,QAAM;oCApBbA,GAaA5vC;kCA/EJsmR;gCAyEI,IAiBJ3nR;;gCACE;;qCADFA;mCAEW;;;sCADT,SAAIyB;yC,gBACuB5F;2CAAK,UAD5B4F,IACuB5F;2CAAK,wBAlCpB4D,mBAkC6B;wCADrCgC;mCAEJ5F;kCACE;;4CADFA;qCAEiD,OAFjDA;qCAEiD,uBAH7CksR;qCAGe,MAJftmR,IAEJ5F;qCAEmB;;wCAAC,QAAK,iBAHrBksR;qCAGA,MAJAtmR,IAEJ5F;qCAEI;sEArCQ4D;oCAoCV,iBApCUA;oCAoCV,UADF5D;;oCACE,UAJJmE;;oCAII;qCAMgB,uBAhIpB0nR,aAyFFhoR;qCAuCW,sCA1CKD;oCA0Cd,iBA1CcA;oCAoCV,UAjCNC;;oCAL0D,OlW/F1DunE,oBkW8IuE;uBA/CtB;;iCA+D7CihN,UAAU9G,IAAInmQ,IAAIxe,IAAI6B;0BAC1B,SADc8iR,QACd,MAD0B9iR,YAC1B;;gCAUAzC;4BACE;8BACuB;qCAJrB4F;+BAIyD,OAJzDA;+BAIqB,mCAJrBA;+BAIA;;;oCAAC,iBAbS2/Q;;+BAeJ;;kCAHJ/gR;kCAGiD,oBAAzB,WAf1B6nR,UAAcjtQ,IAAIxe,MAWtBZ;+BAM+B,MAR3B4F;+BAQ0C,4BAFxCiyE,KANFjyE;+BAQoB,uBA/BtBumR;+BA+BsB,MARpBvmR;+BAQA;;;qDAjBU2/Q;;+BAiBV,MARA3/Q;8BAOF,iBAhBY2/Q;8BAgBZ;iCAhBYA,UASV3/Q,MAYA,aArBU2/Q,QAqBV;8BARqB,UAFzBvlR;;;0BAcA,SAhBI4F;0BAgBJ,QAAY;uBAxFqC;iCA0F7B2/Q,IAAInmQ,IAAIxe,IAAI6B;0BAChC,SAAI4pR,UAAUjtQ,IAAIxe,KAAgB,sBAApBwe,IAAIxe,IAAgC;0BAAlD,cAAIyrR,UADgB9G,IAAInmQ,IAAIxe,IAAI6B,IAED;uBA5FkB;iCA+F9C8iR,IAAInmQ,IAAIxe,IAAI6B;0BACf,IAAI4pR;0BAAJ,cAAIA,UADD9G,IAAInmQ,IAAIxe,IAAI6B,IAEgB;uBAjGkB;iCAmGpC8iR;0BACb;iCADaA;2BAML,mBANKA;2BAOL;;8BADJ/gR,EACW,6BAPF+gR;2BAOL,MAPKA;0BAQb,iBARaA,2BAOT1tM;0BANJ;2BAOA,OARa0tM;2BAUL,qBAVKA;2BAWL;;8BADJptM;8BACW,8BAXFotM;2BAWL,OAXKA;0BAYb,iBAZaA,2BAWT9P;0BAGJ,aAda8P;0BACb;2BAaA,EAdaA;2BAcb,YAQM1hR;2BADFiB,EArBSygR;2BAyBb,uBAJIzgR;2BAIJ,OAJIA;2BAIJ;;gCACA9E;4BACE;;gCAFE2yF,KACJ3yF,UACgC,iBA3BnBulR,OA0BbvlR;8BACE,UADFA;;;0BAIA,WALI2yF,OAzBS4yL,OA8BU;uBE7OrBkH;iCAAMtqR,EAAE2C;0BAAI;mEAAN3C,EAAE2C;mCAAkB,sBAApB3C,OAAE2C,OAAkC;uBA0B1C4nR;iCAAInH;0BAC+C,iBAD/CA,QAC4B,WAD5BA;0BACG,iBADHA,oBACiE;uBAErEoH;;0BACM,IAAJvqR,EAAI;oDAAJA,EAAI,cAeP;uBAECgtF;uBA4FAw9L;iCAEExI,YAAYmB,IAAInmQ,IAAIxe;0BACxB;;;2BAQQ,sBATQ2kR;2BAQR,sBARQA;2BAOR,sBAPQA;2BAMR,sBANQA;2BAKR,sBALQA;2BAIR,sBAJQA;2BAGR,sBAHQA;2BAER,sBAFQA;2BAYR;2BACR30M;0BACE;4BAAS;;yCAdPwzM,YAAgBhlQ,IAAIxe,OAaxBgwE;4BACE,iBAFEluE,EACJkuE;4BACW,UADXA;;4BACW,IAGXhI;4BACE;8BAAiE;qCADnEA;+BACqD,MADrDA;+BACgE,uBAN5DlmE;+BAM8C,mBAN9CA;+BAlB2B,cAA1BT;+BAwBgC,MADrC2mE;+BAvBgB;;yDAAX3mE;kCAAyC,gCAAzCA;+BAwBmB,MADxB2mE;+BACkC,uBAN9BlmE;+BAMiB,qBANjBA;+BAhB4B,cAA3Bu5F;+BAsBa;;;;sCAtBF;+DAAXA;wCAA2C,gCAA3CA;;;;8BAsBH,iBANEv5F,EAKJkmE;8BACmE,UADnEA;;8BACmE;+BAEnE;yCAAUzmE,EAAEC,EAAEqD,EAAEpH,EAAE8W,EAAElQ,EAAEiC,EAAE5E,EAAE6B,EAAEzB;kCAEP;yCAFHyS;mCAEG;;sCAFCjO,KAEQ,eAFZiO,KAEqB,eAFnBlQ,KAAEiC;mCA5B0B;mCAAhB;mCAAhB;;;kCA8BR;;;;oEAFgB5E,mBAAE6B;oCAAEzB;kCAEP;mCACL,MAHNP;mCAGM;;sCAAC,eAHPA,KAAEC;sCAGoB,eAHlBqD,KAG2B,cAH/BtD,KAAEC;mCA9BoC;mCAAhB;kCAiCxB;;;oCAjCQ;;;kCAkCT,sBAJS/D,KAnBYoxE;kCAwBrB,sBAxBqBA,MAAIF;kCAwBzB,QAAS;+BAChBvvE;8BACE;;uCADFA;iCACwC,MADxCA;iCACwC,uBAfpC0C;gCAeF;kCA1BEP;kCAAGC;kCAAGqD;kCAAGpH;kCAAG8W;kCAAGlQ;kCAAGiC;kCAAG5E;kCA0BD,iBAzHtB8sF;;gCAyHA;wCADFpvF;iCAEwC,OAFxCA;iCAEwC,uBAhBpC0C;gCAgBF;kCA3BuBJ;kCAArBH;kCAAGC;kCAAGqD;kCAAGpH;kCAAG8W;kCAAGlQ;kCAAGiC;kCA2BE,iBA1HtBkoF;;gCAyHA;iCACA,OAFFpvF;iCAGwC,OAHxCA;iCAGwC,uBAjBpC0C;gCAiBF;kCA5BoBwE;kCAAG5E;kCAArBH;kCAAGC;kCAAGqD;kCAAGpH;kCAAG8W;kCAAGlQ;kCA4BK,iBA3HtBmqF;;gCAyHA;iCAEA,OAHFpvF;iCAIwC,OAJxCA;iCAIwC,uBAlBpC0C;gCAkBF;kCA7BiBuC;kCAAGiC;kCAAG5E;kCAArBH;kCAAGC;kCAAGqD;kCAAGpH;kCAAG8W;kCA6BQ,iBA5HtBi6E;;gCAyHA;iCAGA,OAJFpvF;iCAKwC,OALxCA;iCAKwC,uBAnBpC0C;gCAmBF;kCA9BcyS;kCAAGlQ;kCAAGiC;kCAAG5E;kCAArBH;kCAAGC;kCAAGqD;kCAAGpH;kCA8BW,iBA7HtB+wF;;gCAyHA;iCAIA,OALFpvF;iCAMwC,OANxCA;iCAMwC,uBApBpC0C;gCAoBF;kCA/BWrE;kCAAG8W;kCAAGlQ;kCAAGiC;kCAAG5E;kCAArBH;kCAAGC;kCAAGqD;kCA+Bc,iBA9HtB2pF;;gCAyHA;iCAKA,OANFpvF;iCAOwC,OAPxCA;iCAOwC,uBArBpC0C;gCAqBF;kCAhCQ+C;kCAAGpH;kCAAG8W;kCAAGlQ;kCAAGiC;kCAAG5E;kCAArBH;kCAAGC;kCAgCiB,iBA/HtBgtF;;gCAyHA;iCAMA,OAPFpvF;iCAQwC,OARxCA;iCAQwC,uBAtBpC0C;gCAsBF;kCAjCKN;kCAAGqD;kCAAGpH;kCAAG8W;kCAAGlQ;kCAAGiC;kCAAG5E;kCAArBH;kCAiCoB,iBAhItBitF;;gCAyHA,UADFpvF;;gCACE;iCASF,MAnCImC;iCAoCS,sCArCGojR;gCAqChB,iBArCgBA;gCA2Bd;iCAUF,MApCOnjR;iCAqCM,sCAtCGmjR;gCAsChB,iBAtCgBA;gCA2Bd;iCAWF,MArCU9/Q;iCAsCG,sCAvCG8/Q;gCAuChB,iBAvCgBA;gCA2Bd;iCAYF,MAtCalnR;iCAuCA,sCAxCGknR;gCAwChB,iBAxCgBA;gCA2Bd;iCAaF,MAvCgBpwQ;iCAwCH,sCAzCGowQ;gCAyChB,iBAzCgBA;gCA2Bd;iCAcF,MAxCmBtgR;iCAyCN,sCA1CGsgR;gCA0ChB,iBA1CgBA;gCA2Bd;iCAeF,MAzCsBr+Q;iCA0CT,sCA3CGq+Q;gCA2ChB,iBA3CgBA;gCA2Bd;iCAgBF,MA1CyBjjR;iCA2CZ,sCA5CGijR;gCA4ChB,iBA5CgBA;gCA4ChB,WACE;uBAEAsH;iCASEl8J,KAAMyzJ,YAAYmB,IAAInmQ,IAAIxe,IAAI6B;0BACN;;;;8CAAC,iBADP8iR;2BACM,SADM9iR;2BACN,SADE7B;2BACF,cAAxB0hB;2BAImC,0BAHnCynD;2BAGkC,qBAAZ,iBALJw7M;0BAKtB,iBALsBA;0BACM,UAKV,oBAJdx7M;0BAIW,iBAAZ,iBANmBw7M;4BAOD,iBAAW,iBAPVA;4BAOjB,iBAPiBA;0BACM;2BAMgB,YANxCjjQ;2BAMwC,YAHxC4lQ,WAFAn+M;0BAOC;4BACH,WAVE4mD,KAAsBvxG,IAGtBsnF,SAHkB6+K,OAClBjjQ,OAGA4lQ;4BAOF,gBV1KFrD,cU+JsBU;4BAWpB,WATEx7M,WAEAm+M;4BAOF,WARExhL,WACAwhL;4BAOF;;sCATEn+M;8BAcF,gBAhBQq6M,YAAYmB,IAAInmQ,IAGtBsnF;8BAaF,WAdE38B;8BAcF,WAbE28B;;4BAiBJ,SAlBI38B;6BAkBc,WApBd4mD,KAAsBvxG,IAGtBsnF,SAHkB6+K,OAClBjjQ,OACAynD;4BAkB2C,SAC7C;uBAEoB;;0B,OAhCpB8iN,YVtJFhI;uBUyLA;;0B,OAnCEgI;mCV1LFrI,oBDuDAJ;uBWsKA;iCAEamB;0BACa;;;6CAAC,iBADdA;2BACa,cAAtB70Q;2BAEU;iCADV43Q,uBACyB,wBAAoC;2BACjE;2BACsD;;8BAAC,iBAL1C/C;0BAKb;4BADIl2O;;4BACyB;oDAAC,iBALjBk2O;;0BAMb;4BAFIl2O;;4BAEyB,uCANhBk2O;0BAOb,oBAPaA,IAGT3lR,UADA0oR;0BAMJ,oBARa/C,IAITl2O;0BAHsB,IAQhB,0BACVrvC;0BACE;;8BAFEyH,IACJzH,UAC6B,iBAXhBulR,OAUbvlR;4BACE,UADFA;;4BAGA,OAJIyH,IAID;uBAfH;;yBAlMEklR;yBA+LAG;yBAEAC;yBAGAC;yBAvMAN;uBCpBAO;;0BACM,IAAJ7qR,EAAI;oDAAJA,EAAI,cAeP;uBAEC8qR;iCAAW3H;0BACH,IAAN99Q,IAAM,uBADG89Q,KACH,WAAN99Q,SACW;uBAEb0lR;uBAEAC;uBAEAC;;;yBA1BAJ;yBAwBAG;yBAEAC;yBARAH;yBAIAC;uBCtBAG,wBAAU,kBAA0B;;;yBAApCA;yBHMAhB;yBAEAC;yBANAC;yBDOAf;uBKTA8B,wBAAU,kBAA0B;;;yBAApCA;yBJMAjB;yBAEAC;yBANAC;yBDOAf;uBMTA+B,wBAAU,kBAA0B;;;yBAApCA;yBLMAlB;yBAEAC;yBANAC;yBDOAf;uBCTAgC,wBAAU,kBAA0B;;;yBAApCA;yBAMAnB;yBAEAC;yBANAC;yBDOAf;uBOWAiC;iCAAInI;0BAAgD,iBAAhDA,QAA6B,WAA7BA;0BAA6B,UAA7BA,mBAAkE;uBAEtEoI;;0BACM,IAAJvrR,EAAI;0BACY,gBADhBA,EACgB,iB1jBpBHk1C,Q0jBoB4B;uBAE3Cg4C;;;;;;;;;;uBAohEAs+L;iCAEExJ,YAAYmB,IAAInmQ,IAAIxe;0BACd;;qDAAuB,wB1jB7iEhB02C,O0jB6iEuC;2BAC5C;qDAAuB,wB1jB9iElBA,O0jB8iEyC;2BAA9C;;2BAeZu2O;0BACE;4BAAe,2BAlBDtI,OAiBhBsI;4BACS,iBAAP,iBAjBEttQ,UAgBJstQ;;;4BACiB;6BAAR,MAlBejtR,OAiBxBitR;6BAGmD,uBApBnCtI,OAiBhBsI;6BAG0B;wDApBtBzJ,YAAgBhlQ,IAmBdsnF;4BACK,iBAAT,iBAlBE5/E,YAeJ+mQ;;;4BACiB;;8BAGO,iBAAT,iBAnBX/mQ,YAeJ+mQ;4BAIE,iBArBctI,OAiBhBsI;4BACiB,UADjBA;;4BACiB;6BAKjB;uCAAU9+Q,IAAIg/B;gCACZ,SACIggP,MAAM/tR;kCACR;2CAHU+tC,iBAEF/tC;mCAEgD;;sCAA5B,iBAJtB+O;gDAEE/O;mCADiB,yCAAlBwE;kCAEF;4CAAL,iBAhjEF8qF,IA+iEUtvF;qDAEiE;gCAEnC,kC1jBzkEzBs3C,O0jBykEyB,SAJpCy2O,OAIwD;6BAC9DnlN;;4BACE;qCA5BEvwD,SA4BF,GA5BEA,KAgCFw4D;8BACE;gCAJ8B,gBAAM,iBA/BpCtwD,IA8BEytQ,YAIJn9M;gCAHwB,iBAAR,iBA/BdtwD,IA8BMw4B,YAIR83B;;;;gCAHgC,UAGhCA;;gCAHgC;iCAMS,uBAlCvC8kJ,GA0BJ/sJ;iCAQyB;;oCAAQ,iBAAR,iBArCrBroD,IA8BMw4B;;gCAOA,iBAAR,iBArCEx4B,IA8BMw4B;;;gCACwB,IAOhC63B;gCACE;kCANyD;;qDAAR,iBAjCjDrwD,IA8BMw4B,YAQR63B;;mCAL2B;;4CAAM,iBAhC/B9pD,MA6BEknQ,YAQJp9M;kCALY,iBAAV,iBAhCA9pD,MA6BMiyB,YAQR63B;;;;kCAL2D,UAK3DA;;kCAGA,OAvCEv4D;kCA+ByD,UAJ7DuwD;;kCAI6D,IAW7D5oE;kCACE;oCAF2D;;uDAAT,iBA1ChD8mB,YA2CJ9mB;qCADqC;sEA5CrBulR,OA6ChBvlR;oCADwB,iBA5CRulR,OA6ChBvlR;oCAD6D,UAC7DA;;oCAGA,aAAE;uBAEAiuR;iCASEt9J,KAAMyzJ,YAAYmB,IAAInmQ,IAAIxe,IAAI6B;0BACN;qEADN8iR;2BACM,SADM9iR;2BACN,SADE7B;2BACF,aAAxB0hB;0BAIQ;;yCALUijQ,OAKS,oBAH3Bx7M;0BADwB;2BAIhB,YAJRznD;2BAIQ,YADR4lQ,WAFAn+M;0BAKC;4BACH,WARE4mD,KAAsBvxG,IAGtBsnF,SAHkB6+K,OAClBjjQ,OAGA4lQ;4BAKF,mBfplEFrD,ce2kEsBU;4BASpB,WAPEx7M,WAEAm+M;4BAKF,WANExhL,WACAwhL;4BAKF;;qCAPEn+M;8BAYF,mBAdQq6M,YAAYmB,IAAInmQ,IAGtBsnF;8BAWF,WAZE38B;8BAYF,WAXE28B;;4BAeJ,SAhBI38B;6BAgBc,WAlBd4mD,KAAsBvxG,IAGtBsnF,SAHkB6+K,OAClBjjQ,OACAynD;4BAgB2C,SAC7C;uBAEoB;;0B,OA9BpBkkN,YflkEFpJ;uBemmEA;;0B,OAjCEoJ;mCftmEFzJ,oBDuDAJ;uBgBglEA;iCAEamB;0BACa;2BAAtB70Q;4BAAsB,mCADb60Q;0BAEb,eAFaA,OACT70Q;0BACJ,QADIA;4BAIF,KALW60Q,OACT70Q;4BAKF,mBf3mEFm0Q,ceqmEaU;4BAOX,KAPWA;;2BAQR,KARQA,OACT70Q;0BAQJ,YATa60Q,UASkB,sBATlBA;0BAUb,mBf/mEAV,ceqmEaU;0BACa,IAUhB,0BACVvlR;0BACE;;8BAFEyH,IACJzH,UAC6B,iBAbhBulR,OAYbvlR;4BACE,UADFA;;4BAGA,OAJIyH,IAID;uBAjBH;;yBA7mEEkmR;yBA0mEAO;yBAEAC;yBAGAC;yBAjnEAV;;;0B3fuHQ;2BAJRW;2BAEAC;2BAEQ;;mCAIR/H,kBAAkBhB,IAAK3kR,IAAK6B,IAAI2c;4BAClC,GADyBxe;;iCAAK6B;+BAGJ,UAHIA,OACrBunE,MAEUD,MAFf28B;;mCAAK18B,MAGa,qBAJY5qD,iBAC9BsnF;;gCAD0BjkG;8BAKR,UALQA,OACrBunE,MAIM4/E,MAJXljD;;8BAKc,+BANgBtnF,KACzB4qD,YAAL08B;;;;;;;;8BAAK18B;;;qDADyB5qD,OACzB4qD,aAAL08B;6BAQC,0BATe6+K,IAAcnmQ,IAC9BsnF,MAAK18B;4BAOJ,yBACiC;0BAb5B,SAeRwkN,mBAAmBjJ,IAAK3kR,IAAK6B,IAAI2c;4BACH;qCADXmmQ,IAAK3kR,IAAK6B,IACC,qBADG2c,KACsB;0BAhB/C,SAkBRonQ,sBAAsBjB,IAAK3kR,IAAK6B,IAAI2c;4BACtC,GAD6Bxe;;iCAAK6B;+BAGR,UAHQA,OACzBunE,MAEUD,MAFf28B;;mCAAK18B,MAGmB,cAJU5qD,iBAClCsnF;;gCAD8BjkG;8BAKZ,UALYA,OACzBunE,MAIM4/E,MAJXljD;;8BAKkB,wBANgBtnF,KAC7B4qD,YAAL08B;4BAM2B;;;8BAN3BA;;;;8BAAK18B;;;gCAMsB,cAPO5qD,OAC7B4qD,aAAL08B;6BAQC,0BATmB6+K,IAAcnmQ,IAClCsnF,MAAK18B;4BAOJ,yBACqC;0BA3BhC;0C8e/JD2oB;4BACC,IAANlrF,IAAM;qCACNinR,MAAIzsR;8BACN,WADMA;uCAGC,UAHDA;uCAEqC,SAFrCA,MAGyB;4BAJvB;;kCAKVjC;8BACE;gCAAkB,IAAdwE,EAAc,gBAPXmuF,KAMT3yF;gCAE+B,sBAP3ByH,IAKJzH,UAE+B,MADzBwE;gCAE+B,sBARjCiD,KAKJzH,mBAGqC,MAF/BwE;gCAAc,UADpBxE;;;4BAKA,4BAVIyH,IAUsB;wCAEnBxF;4BACP,SADOA;;gDAIS,QAJTA;;8CAGS,QAHTA;;qDAES,OAFTA;4BAKA,uCALAA,EAKwC;0CAEtC0sR,KAAKC;4BAAuC,eAAvCA,MAAkB,gBAAvBD,mBAAsD;0CAEtDvgM;4BACT,IAAI5qF;4BAAJ,SACQ+rN,GAAGs/D,WAAWvsQ;8BACpB;yDAHO8rE,SACL5qF,YACkB8e;iCAEf;gCAEG;sDAND8rE,IACL5qF,YACkB8e;iCAIZ,MAKJqsQ;;gCALI;;;;gCxW6eN,awW3eI;gCAEQ,GARLE,WAQmB,OACxBF;gCACE;gCANE,IAOEC,KAAO,KAXGtsQ;gCAWH,aAAPssQ,KAGC,qBADA,OAJPD,KAEMC,MAGmD;4BAf/D;4BAgB0B,oC,OAflBr/D,iBAe4B;8CAEvBnhI;4BACb;8BAAM,IACJo8F,OADI,OADOp8F;;;+DAGqB;8BADtB;sCAAVo8F,OACoC;qDAElBniK;4BACpB,IAAI7kB;4BAAJ,SACQ+rN,GAAGs/D,WAAWvsQ;8BACpB;yDAHkB+F,SAChB7kB,YACkB8e;iCAEf;gCAEG;sDANU+F,IAChB7kB,YACkB8e;iCAIZ,MAKJqsQ;;gCALI;;;;gCxWqdN,awWndI;gCAEQ,GARLE,WAQmB,OACxBF;gCACE;gCANE,IAOEC,KAAO,KAXGtsQ;gCAWH,cAFbqsQ,KAEMC,MACY;4BAbxB;;6BAcU,iC,OAbFr/D;;0CADJ/rN,uCADgB6kB;gCAmBR;uDAnBQA,IAChB7kB;iCAeS;;;;;;gCAGD;0CAEV;8BAEF,IAtBIA,2BAsBJ,sBAvBoB6kB;+BAwBf,OATD5gB;8BAWF,UAzBEjE;8BAyBF;wFA1BkB6kB,MA4BG;yDAEC+lE;4BACxB;8BAAM,IACJo8F,OADI,kBADkBp8F;;;+DAGU;8BADtB;sCAAVo8F,OACoC;sCAEjCthF,IAAIvW;4BACT;;;8BACE;gCAAqC,0BAF9BA,KACT3yF;gCACE,qBAFGkpG;gCAEkC,UADvClpG;;;4BALA,QAOI;iDAEYiC;4BAChB,6BADgBA;qCAEX;qCAFWA,CAGV;qDAEcA;4BACpB;8BAAM,IACJuoL,OADI,cADcvoL;;;+DAGc;8BADtB;sCAAVuoL,OACoC;iDAEtBvoL,GAAI,OAAJA,CAAK;yCchGbE,EAAEC;4BCuGZ;sDDvGUD;6BCuGV,yBDvGYC;4BCuGZ,GAnFS0sR,OAoFLC,GAEC;4BAHL,IAlFA,GADSD,QACT,cAAIx9Q,WAAJ;;kCAaAtR;8BAAwB;gCAAkC;yDDlC9CoC,ECkCZpC;iCAAqC,wBDlC3BmC,ECkCVnC;gCAAqC,OANjC6D;gCAMsD,UAA1D7D;;;4BAqEA,IAzCA,MA1CS8uR,OA0CT;;;8BAA0B;gCAAa;;gCAlCnCjrR;;gCAkCmC,uBD9D7B1B,ECoBD2sR;;gCA0CkD,uBD9D/C1sR,ECoBH0sR;gCA0C8B;;;4BA8BvC,aAhEIjrR,QD5B0B;iE5f0M1BkD;mCAEApK,IAAI6I;4BACE,IAAJs6G,IAAI,mBADFt6G;4BAEN,uCAlBEipR,WAiBE3uK,KAC+B;mCAEjCkvK,WAAWxpR,EAAG5E,IAAK6B,IAAI2c;4BACjB,IAAJ0gG,IAAI,mBADKt6G;4BAEb,kBADIs6G,IADYl/G,IAAK6B,IAAI2c;4BAEzB,OADI0gG,GAEH;mCAECmvK,YAAYzpR,EAAG5E,IAAK6B,IAAI2c;4BAClB,IAAJ0gG,IAAI,mBADMt6G;4BAEd,mBADIs6G,IADal/G,IAAK6B,IAAI2c;4BAE1B,OADI0gG,GAEH;mCAECovK,eAAe1pR,EAAG5E,IAAK6B,IAAI2c;4BACrB,IAAJ0gG,IAAI,mBADSt6G;4BAEjB,sBADIs6G,IADgBl/G,IAAK6B,IAAI2c;4BAE7B,OADI0gG,GAEH;mCAECqvK,YAAY3pR,EAAE6jE;4BACR,IAAJy2C,IAAI,mBADMt6G;4BACN,SACJ4pR,KAAKhwQ,KAAM,yBADX0gG,QACK1gG,IAA6B;4BACtC,WAHgBiqD,KAEZ+lN;4BACJ,OAFItvK,GAGH;mCAECuvK,aAAa7pR,EAAE6jE;4BACT,IAAJy2C,IAAI,mBADOt6G;4BACP,SACJ4pR,KAAKhwQ,KAAM,0BADX0gG,QACK1gG,IAA8B;4BACvC,WAHiBiqD,KAEb+lN;4BACJ,OAFItvK,GAGH;mCAECwvK,gBAAgB9pR,EAAE6jE;4BACZ,IAAJy2C,IAAI,mBADUt6G;4BACV,SACJ4pR,KAAKhwQ;8BAAM,6BADX0gG,QACK1gG,IAAiC;4BAC1C,WAHoBiqD,KAEhB+lN;4BACJ,OAFItvK,GAGH;mCAECyvK,aAAc3uR,IAAK6B,IAAI2c;4BAAM,sBAlF7B6sD,MAkFcrrE,IAAK6B,IAAI2c,KAA2C;mCAElEowQ,cAAe5uR,IAAK6B,IAAI2c;4BAAM,uBApF9B6sD,MAoFerrE,IAAK6B,IAAI2c,KAA4C;mCAEpEqwQ,iBAAkB7uR,IAAK6B,IAAI2c;4BAAM,0BAtFjC6sD,MAsFkBrrE,IAAK6B,IAAI2c,KAA+C;mCAE1EswQ,cAAcrmN;4BAAO,uBAxFrB4C,MAwFc5C,MAAoC;mCAElDsmN,eAAetmN;4BAAO,wBA1FtB4C,MA0Fe5C,MAAqC;mCAEpDumN,kBAAkBvmN;4BAAO,2BA5FzB4C,MA4FkB5C,MAAwC;mCAE1DwmN,cAAchyK;4BAAM,8BAAmB54G,GAAK,cAALA,EAAzB44G,IAA6C,EAAC;mCAE5DiyK,eAAejyK;4BAAM,+BAAoB54G,GAAK,cAALA,EAA1B44G,IAA8C,EAAC;mCAE9DkyK,kBAAkBlyK;4BAAM,kCAAuB54G,GAAK,cAALA,EAA7B44G,IAAiD,EAAC;0BAMvD;2CA1GbywK,2BA0G0C,SAAM;2BAEnC,gBA5GbA,2BA4G0C,SAAM;0BAAnC,SAET4B,WAAW3vQ;4B,IAAA8hF;4BACjB;;;sEADiBA,OA9GfisL;+BA+GF;;;;kC4etPF;0D5eqPmBjsL;mC4epPnB,oB5esIIisL;kC4erIJ,K5emPmBjsL,Q4epPfjgG,IADA2C;kCAGJ,KAFI3C,EADA2C,E5euIAupR,a4evIAvpR;kCAGJ,OAFI3C;;;kC5esPgB;8DAAqB,iBAFtBigG;;;8BAIV,OAJUA,MAIP;0BAES;;oCApHjBisL,2BAoH8C,SAAM;2BAEnC;oCAtHjBA,2BAsH8C,SAAM;0BAAnC,SAEjB+B,eAAehuL;4B2e7OqB,sB,qB3e6OrBA;4B2e7OS;sD3e6OTA;6BAEN,eAAW,qBADlB9hF;6BAEO,cADA,qB2e7OKxR;6B3e8OL,yB2e9OKA;6BAClB,MAD0CtM;6BAC1C;;;8BACE;8CAF4BwM,IAC9BjP,MAC+B,eAFb+O,IAClB/O;gCACE,UADFA;;;mCAD8BiP,G3egPxB;0BAPe,SASjBqhR,YAAa/vQ,IAAI8oD;4BACT;8CADK9oD;6BAEH,0BADR8hF,MAtBF2tL;6BAwBU,0BAFR3tL,MApBF4tL;6BAwBA;;yCAAmBhrR,GACf,WADeA,EAFjBo4K,OAGE,kBANah0G,KAKEpkE,EAET;4BAFV;8CAGiBA;uCACf,WADeA,EANfsrR;uCAQE,kBAFatrR,EAEb,qBANFwC,KAM2B,EAAC;0BAnBb,SAqBjB+oR,aAAcjwQ,IAAI8oD;4BACV;8CAAW,qBADL9oD;6BAGJ,0BAFR8hF,MAlCF2tL;6BAqCU,0BAHR3tL,MAhCF4tL;6BAoCQ,eA9IRhkN,UA6IEoxG;6BAEM,qBADNkoG,IALgBl8M;6BAOV,iBAhJR4C,UA4IEskN;4BAKJ,uBADIE,UADAhpR,KAEkC;0BA7BnB,SA+BjBipR,gBAAiBnwQ,IAAI8oD;4BACb;kDADS9oD;6BAEP,8BADR8hF,MAlCF8tL;6BAoCU,8BAFR9tL,MAhCF+tL;6BAoCA;;yCAAuBnrR,GACnB,WADmBA,EAFrBo4K,OAGE,kBANiBh0G,KAKEpkE,EAEb;6BACF,mBA3JRgnE,UAqJEskN;4BAOJ,uBADIhL,QAJA99Q,KAKkC;0BAxCnB,SA0CjBkpR,WAAYpwQ,IAAK3f,IAAK6B,IAAI2c;4BAC5B,GADmBxe;;iCAAK6B;+BAGE,UAHFA,aAGE,IAHE2c,UAGT2qD;;;;iCACG,IAJM3qD,UAIN,qBAJMA;kCACxB8oM;;gCADoBzlN;8BAKF,UALEA,OACpBylN,MAIkB,IALM9oM,MAKb4qD;;kCAJXk+I,MADwB9oM;4BAO5B;qCAPcmB,aAOQtb,GAAK,kBAALA,EANlBijN,MAM4B,EAAC;0BAjDd,SAmDjB0oE,YAAarwQ,IAAK3f,IAAK6B,IAAI2c;4BAC7B,GADoBxe;;iCAAK6B;+BAGC,UAHDA,aAGC,QAHG2c,UAGV2qD;;;;iCACG,QAJO3qD,UAIP,sBAJOA;kCACzB8oM;;gCADqBzlN;8BAKH,UALGA,OACrBylN,MAIkB,QALO9oM,MAKd4qD;;kCAJXk+I,MADyB9oM;4BAO7B;qCAPemB,aAOQtb,GAAK,kBAALA,EANnBijN,MAM6B,EAAC;0BA1Df,SA4DjB2oE,eAAgBtwQ,IAAK3f,IAAK6B,IAAI2c;4BAChC,GADuBxe;;iCAAK6B;+BAGF,UAHEA,aAGF,YAHM2c,UAGb2qD;;;;iCACG,YAJU3qD,UAIM,cAJNA;kCAC5B8oM;;gCADwBzlN;8BAKN,UALMA,OACxBylN,MAIkB,YALU9oM,MAKjB4qD;;kCAJXk+I,MAD4B9oM;4BAOhC;qCAPkBmB,aAOQtb,GAAK,kBAALA,EANtBijN,MAMgC,EAAC;0BAnElB,SAqEjB4oE,YAAavwQ,IAAIwwQ;4BAAO,mBAAXxwQ,aAAiCtb,GAAK,cAALA,EAA7B8rR,KAAkD,EAAC;0BArEnD,SAuEjBC,aAAczwQ,IAAIwwQ;4BAAO,oBAAXxwQ,aAAkCtb,GAAK,cAALA,EAA9B8rR,KAAmD,EAAC;0BAvErD,SAyEjBE,gBAAiB1wQ,IAAIwwQ;4BACvB;qCADmBxwQ,aACOtb,GAAK,cAALA,EADH8rR,KACwB,EAAC;0BA1E7B;kCAxHjB1C;kCAEAC;kCAEAriN;kCAEAipE;kCAEAqxI;kCAWAiI;kCAGAhI;kCAWAiI;;;;;;;;;;;;;;kCAcA1nR;kCAEApK;kCAIAqyR;kCAKAC;kCAKAC;kCAKAC;kCAMAE;kCAMAC;kCAMAC;kCAEAC;kCAEAC;kCAEAC;kCAEAC;kCAEAC;kCAEAC;kCAEAC;kCAEAC;kCAMAC;kCAEAC;kCAEIC;kCAMJC;kCAEAC;kCAEAC;kCAOAC;kCAYAE;kCAUAE;kCAWAC;kCASAC;kCASAC;kCASAC;kCAEAE;kCAEAC;;;0B;4BA4BA,0BA1Wa,QyIo0BbjpN,SzIp0BO/iB;0BA2WQ,SAQH79B;4BACF,wCAAsD;0BATjD;;;;;;;;+BAQHA;+BAGAm/P;+BAEAC;+BAEAiI;+BAEAnJ;;2BA/OZ+I;2BAEAC;2BAEAriN;2BAEAuoE;2BAEA+yI;2BAWAiH;2BAGAhH;2BAWAV;;;;;;;;;;;;;;2BAcA//Q;2BAEApK;2BAIAqyR;2BAKAC;2BAKAC;2BAKAC;2BAMAE;2BAMAC;2BAMAC;2BAEAC;2BAEAC;2BAEAC;2BAEAC;2BAEAC;2BAEAC;2BAEAC;2BAEAC;2BAMAC;2BAEAC;2BAEIC;2BAMJC;2BAEAC;2BAEAC;2BAOAC;2BAYAE;2BAUAE;2BAWAC;2BASAC;2BASAC;2BASAC;2BAEAE;2BAEAC;mCAuDEC,WAAY3wQ,IAAI8oD;4BACR;6BAANk8M;8BAAM,gBAzPV8I,YAwPc9tQ,MACd,qBADcA;4BAEd,kBAzMA5jB,IAyMA,WAtLAwyR,YAqLI5J,IADcl8M,MAES;mCAEzB8nN,YAAa5wQ,IAAI8oD;4BAEjB;6BADEk8M;8BACF;;gCA9PF8I;gCA8P0C,qBAF3B9tQ;;gCACf,sBADeA;4BAIf,kBA/MA5jB,IA+MA,WAtLA0yR,aAmLI9J,IADel8M,MAIS;mCAE1B+nN,eAAgB7wQ,IAAI8oD;4BAE8B;iDAFlC9oD;6BAEhB,oBApQF8tQ,YAkQkB9tQ;4BAGlB,kBApNA5jB,IAoNA,WArLA2yR,gBAmLI/J,IADkBl8M,MAGS;mCAE7BgoN,UAAW9wQ,IAAK3f,IAAK6B,IAAI2c;4BAC3B,GADkBxe;;iCAAK6B;+BAGG,UAHHA,aAGG,IAHC2c,UAGR2qD;;;;iCACG,IAJK3qD,UAIL,qBAJKA;kCACvB8oM;;gCADmBzlN;8BAKD,UALCA,OACnBylN,MAIkB,IALK9oM,MAKZ4qD;;kCAJXk+I,MADuB9oM;4BAO3B;qCAPamB,aAOQtb,GAAK,kBAALA,EANjBijN,MAM2B,EAAC;mCAE9BopE,WAAY/wQ,IAAK3f,IAAK6B,IAAI2c;4BAC5B,GADmBxe;;iCAAK6B;+BAGE,UAHFA,aAGE,QAHE2c,UAGT2qD;;;;iCACG,QAJM3qD,UAIN,sBAJMA;kCACxB8oM;;gCADoBzlN;8BAKF,UALEA,OACpBylN,MAIkB,QALM9oM,MAKb4qD;;kCAJXk+I,MADwB9oM;4BAO5B;qCAPcmB,aAOQtb,GAAK,kBAALA,EANlBijN,MAM4B,EAAC;mCAE/BqpE,cAAehxQ,IAAK3f,IAAK6B,IAAI2c;4BAC/B,GADsBxe;;iCAAK6B;+BAGD,UAHCA,aAGD,YAHK2c,UAGZ2qD;;;;iCACG,YAJS3qD,UAIO,cAJPA;kCAC3B8oM;;gCADuBzlN;8BAKL,UALKA,OACvBylN,MAIkB,YALS9oM,MAKhB4qD;;kCAJXk+I,MAD2B9oM;4BAO/B;qCAPiBmB,aAOQtb,GAAK,kBAALA,EANrBijN,MAM+B,EAAC;mCAElCspE,WAAYjxQ,IAAIwwQ;4BAAO,kBAAXxwQ,aAAgCtb,GAAK,cAALA,EAA5B8rR,KAAiD,EAAC;mCAElEU,YAAalxQ,IAAIwwQ;4BAAO,mBAAXxwQ,aAAiCtb,GAAK,cAALA,EAA7B8rR,KAAkD,EAAC;mCAEpEW,eAAgBnxQ,IAAIwwQ;4BACtB;qCADkBxwQ,aACOtb,GAAK,cAALA,EADH8rR,KACwB,EAAC;;;;6BA/C7CG;6BAIAC;6BAMAC;6BAKAC;6BASAC;6BASAC;6BASAC;6BAEAC;6BAEAC;;kCAtSFrD;kCAEAC;kCAEAriN;kCAEAuoE;kCAEA+yI;kCAWAiH;kCAGAhH;kCAWAV;;;;;;;;;;;;;;kCAcA//Q;kCAEApK;kCAIAqyR;kCAKAC;kCAKAC;kCAKAC;kCAMAE;kCAMAC;kCAMAC;kCAEAC;kCAEAC;kCAEAC;kCAEAC;kCAEAC;kCAEAC;kCAEAC;kCAEAC;kCAMAC;kCAEAC;kCAEIC;kCAMJC;kCAEAC;kCAEAC;kCAOAC;kCAYAE;kCAUAE;kCAWAC;kCASAC;kCASAC;kCASAC;kCAEAE;kCAEAC;;;6C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBF+BArK;yBAGAC;yBArCAN;yBAEAC;yBAsCAM;yBAlSAxB;yBAmFAI;uC;sBoZzGc;;;;yBnZ2QdgC;yBAGAC;yBArCAJ;yBAEAC;yBAsCAI;yBA5PAZ;yBAmDAE;;wC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BC6dYmH;;;;+BFnPZzH;+BAGAC;+BArCAN;+BAEAC;+BAsCAM;+BAlSAxB;+BAmFAI;iCE4bY2I;2BAndZsD;2BAIA1lN;2BAEA7kD;;;;;;;;;;;;2BAyCArgB;2BAEApK;2BAIAqyR;2BAKAC;2BAKAC;2BAKAC;2BAMAE;2BAMAC;2BAMAC;2BAEAC;2BAEAC;2BAEAC;2BAEAC;2BAEAC;2BAEAC;2BAEAC;2BAEAC;2BA2BAO;2BAYAE;2BAUAE;2BAWAC;2BASAC;2BASAC;2BASAC;2BAEAE;2BAEAC;;kCAjMAU;kCA+CA5qR;kCA3CAklE;kCAEA7kD;kCA+CA4nQ;kCAKAC;kCAKAC;kCAKAC;kCAMAE;kCAMAC;kCA/BA3yR;kCAqCA4yR;kCAEAC;kCAEAC;kCAEAC;kCAEAC;kCAEAC;kCAEAC;kCAEAC;kCAEAC;kCA4DAY;kCASAC;kCASAC;kCAnDAP;kCAYAE;kCAUAE;kCAsCAI;kCAEAE;kCAEAC;;;;;;;;;;;;;;;2BAgSY5C;;;;+BDxSZ3G;+BAGAC;+BArCAJ;+BAEAC;+BAsCAI;+BA5PAZ;+BAmDAE;iCC2eYmH;2BAjeZsD;2BAIA1lN;2BAEA7kD;;;;;;;;;;;;2BAyCArgB;2BAEApK;2BAIAqyR;2BAKAC;2BAKAC;2BAKAC;2BAMAE;2BAMAC;2BAMAC;2BAEAC;2BAEAC;2BAEAC;2BAEAC;2BAEAC;2BAEAC;2BAEAC;2BAEAC;2BA2BAO;2BAYAE;2BAUAE;2BAWAC;2BASAC;2BASAC;2BASAC;2BAEAE;2BAEAC;;kCAjMAU;kCA+CA5qR;kCA3CAklE;kCAEA7kD;kCA+CA4nQ;kCAKAC;kCAKAC;kCAKAC;kCAMAE;kCAMAC;kCA/BA3yR;kCAqCA4yR;kCAEAC;kCAEAC;kCAEAC;kCAEAC;kCAEAC;kCAEAC;kCAEAC;kCAEAC;kCA4DAY;kCASAC;kCASAC;kCAnDAP;kCAYAE;kCAUAE;kCAsCAI;kCAEAE;kCAEAC;;;;;;;;;;;;uBA8SFW;iCACCj/L;0BACkC,uBACA;oCAFlCA;2BAEkC,OAFlCA;oCAIM;oCACC;oCACE;oCACA;oCACA;oCACA;oCACA;oCACE;oCACA;oCACA;qCACA;qCACC;;4BAbsB,SAFlCA;8BAgBsB,IAAf07L,YAhBP17L;8BAgBsB;gCACf,IASJvY,IATI,KAhBNy3M,IAeMxD,aAUC,OAALj0M;;;;kCAPE,IAAI/hE,EAAJ,gBAHEg2Q;kCAQF,QAvBJwD,IAeMxD,YAGEh2Q;kCAKJ,OALIA;gCAOD;4BAEX,IADUs5Q,cA3BPh/L;4BA4BH;8BAAM,IASJ6lB,IATI,KA1BFs5K,IAyBMH,eAUH,OAALn5K;;;;gCAPE,IAAIv9B,IAAJ,gBAHM02M;gCAQN,QAjCAG,IAyBMH,cAGF12M;gCAKJ,OALIA;8BAOD,aAAC;uB8fjrBI,gBA2IH4f,KAAKm3L,GAAG7tR,GApDf,0BAsDgB;sB5iBZhB2oJ;sBJ5HExV;sBmDVN;;sBiZ+EoB;uBjZ/EpB;iCAsBkB7xI;0BACR,0BADQA;0BACR;;;;sCAsBF;sCAEA;sCAEA;sCAEA;sCAEA;uCAEA;;;;qCA9BA;qCAEA;qCAEA;qCAEA;qCAEA;qCAEA;qCAEA;qCAEA;qCAEA;sCAEA;0BAcA,mCAnCUA,IAmCuB;uBAzDzC;;0BA2De;mCAEP;mCAEA;mCAEA;mCAEA;mCAEA;mCAEA;mCAEA;mCAEA;mCAEA;mCAEA;oCAEA;oCAEA;oCAEA;oCAEA;oCAEA;oCAEA,UAAE;uBA0DW;iCAGRmyC,UAA6BxwB,KAAK5hB;0BAC7C,GADWoyC,IAAU,QAAVA,eAAUi7B,aAAV0kB;0BACX,SADoC,mBAANj+E,IAAM6jF,eAAN7jF;0BAC9B,4BAD6C9T,KAAf8T,QAC9B,EAAIxU;0BAEG,mBAFHA,EACAX;4BAEJ;6BAAI7B;uCAAEsD;gCAAkB;qDAAa,gBAJQJ,EAAf8T,MAIxB1T,QAA4C;4BAAlD;qCAJwCwhB;qCAEpCjjB;8CAGWnE;uCACX;4CANOu3F,SAEPpzF,aAGWnE;wCAEyB,aADhC4oE;uCACmB,8BADnBA,0BACgD;wDAAE;uBAVvC;iCAYRhxB,IAAiBpyC;0BAC5B,GADWoyC,IAAU,QAAVA,eAAUi7B,aAAV0kB;0BACX,IAAIzyF,EAAJ,sBAD4BU;0BAC5B;uCAAIV;4CACwB9E;qCACxB;6CADwBA;sCACxB,MAHOu3F,SACPzyF,aAGMutR;sCACQ,kBALU7sR;sCAOb,oBALaxF,aACpByF;sCAOJ,EAHIkqE;qCA1EgB,QAiCtBtxE,QACE,mCADFA;;8CA/BE;8CAEA;8CAEA;8CAEA;8CAEA;8CAEA;8CAEA;8CAEA;8CAEA;8CAEA;+CAEA;+CAEA;+CAEA;+CAEA;+CAEA;+CAEA,WA6C+B,EAAE;;;;;;;;;;0BAG7B;;uDAA6C,6BAAgB;2BAC7D,WADJyhH;0BAEG,c6HjJD6jE,S7H+IF7jE,IAEmB,WAvCJgV,OAJGtyH;4BA4Cf;;gC6HlJDmhL,S7H+IF7jE,IAKA,eA1CegV,OA0CyB,aALxChV;8BAxCF;uDADoBt9G;+BACpB;;kCAAIsC;2CACiB9E,GAAuB,mCAFxBwC,EAECxC,OAAkC;+BAG/C,IADewF;+BACf,EAAJy9C;8BAEG,mBAFHA,IACA9+C;gCAyCC;;oC6HrJDw/K;oC7H+IF7jE;oCAjCF;sCAFI37G;+CAEWnE;wCACX;oDADWA;yCAEwB,UAFxBA;yCAEwB,eAAa,iBAN7BwF;wCAMV;gEAAa,iBANHA;;;;mDAM6C;;;;;wDAqCZ;sBiZrGxC;uBjZ0Gd8sR;iCAAQlrR;0BACV,eACoB3B;4BACb,SAAI8sR,QAIAtwR;8BAFiB,GAAV,gBAEPA,QAFiB,gBAEjBA;sC0CtKPgjH,W1CsKOhjH;8BAAkB,GAAX,gBAAPA,SAAkB,gBAAlBA;sC0CtKPgjH,Y1CsKOhjH;8BAGE,sBAAsD;4BAEjD,kBAVEwD,oBAWJ,WAXIA;4BAWJ,uBADL2rC,QACAhuC,OAC4B;0BAbvC,mCADUgE,aAeM;;;;;;;;;;0BAID,IAAXorR,SAAW,SADXttO;0BAGD,kB6H/KCy+H,S7H8KAx+H,SADAqtO;;mCAIF,4BALEttO,QACAstO,SACArtO,WAIW;;;;;;;;;;0BA2Bf,eAKQA;4BAFW,IA3BTipC,IA2BS,SAEXjpC;4BA5BR,SAAIstO,MAAMpkN;8BAED,eAFCA;gCAIC,YAJDA;gC2O5IK,e3O4ILA;;;;4DASsB;4BAWf;8B,OiHlDX49C,uB6ErJJ/G;4B9LuMe,eARoBjxE,IAAIowH;8BAClC,GADkCA;;;sCAE3BjiK,WAAHD,EAF8BkiK;kCAEI,GAAtB,YAAZliK,MAAkC,YAA/BC;oCAE2B,gBAF3BA;oCAEO;oEAAC,MAFXD,iBAF0B8xC;8BAM1B,0BAAmC;4BAS7B;6BAATy+O;8BAAS;;;;gCAhBjB;kCiNgIwBjhK;kCjNhIxB,uCAZUrjC;;4BA8BH,kB6HnNHu1F,S7HiNI+uG,OACAvtO;;qCAGF,4BAHEA,SA7BEipC,IA4BFskM,SAM2B;0BATX;;;;;;;sC6H9MpBhvG;;mC7H8MoB;qCAAI;;yCASS;sBACtC;;sBnD5OGnsC;sBI4HFwV;sBADAD;sBJ5HExV;sBoDRN;;sBgZ6EoB;uBhZ7EpB,gCAEyB,sBAA0B;uBAFnD,6BAgE+B,yBAAkB;uBAhEjD,6BAkE+B,yBAAkB;uBAlEjD,SAgEgBs7I,aAEAC;uBAlEhB;;;yB8Q6HIxpI;yB9HqCApD;yB4HqHAsB;;uB5QvRJ,4B;uBAAA;uBAkDM;;sBgZ2Bc;uBhZ3Bd;uBAmFF;;;;;;;;;uC4WoEO++B;6DpZxCXwC;;uBwC5BI;uBAAsE;wC,UAAtEiqG;;sCAAKC;sBgZxDW;uBhZwDhB;iCAmBIxtR,gCAA2DpH;0BACjE,SAAI6G,EAAE4mG,SAAW,QAAE,CAAnB,gBAAI5mG,EAD6D7G,IAEnD;uBArBZ;;0B;;mCAmBA80R;sBA4ED;;sBpD3NG37I;sBI4HFwV;sBADAD;sBJ5HExV;sBqDVN;;sB+Y+EoB;uB/YrEI;;;0BA6CV;2BADa+7I;2BACb;2BACE,MAFWA;0BAEX,SAERE,gBAAgBvzR;4BAD2B,QAF3CszR,QAI0B,MALPD,iBAIHrzR,cACuC;0BAH/C,SASRwzR,KAAKhwR,OAAOytH;4BAHd,IAAI54G,EAGU44G;4BACd,eAC6ChvH,GAAK,uBAALA,EAX3CuI,MAWyD;4BAJxD;;8CADC6N;;;6BAKF;6BAGA;;gCAJEo7Q;;yCAIuCx/O,IAAIj0C;kCACzC,OADqCi0C;;yCAC9B,iBAfXzpC,kBAc6CxK,IALxCwD,gBAMgD;4BAEvD,OAJIyoC,MAIgB,OAPhBwnP,QAOqC;0BAjB/B,SAARjpR;+BAmBAkpR,UAjEFN;;oCA8CE5oR;4BAwBuC;;6BALvCkpR;;4BAOW;uCA1BXlpR;6BA2BW,UA3BXA;6BA4BqB,0BA5BrBA;6BA6BW,SA7BXA,iBA4BMqpR,cA5BNrpR;6BA8BW;6BAXXkpR,eAOMC,GACAC,GAEAE,GACAC;0BAGV,UAjCIvpR,MAmBAkpR;uBAjEgB;iCAiFCluR;0BACrB;4BAAI,gBADiBA;uCAIQ,+BAAyC;;;;;;;;;;;mCAehEyuR,SAASC,aAAaC;4BACd;2CAKwC3wR,QACjC,YANb8vR,QAK8C9vR,eACK;4BAFjD;;;yCACG,OAAS,aANP0wR;;6BAWC,yBARR9sR;6BASwB,UAZjB8sR;6BAYiB,MADxBnwL;6BACwB;;6BAAjB7gD;;2DAAG;;8BAAHuC,MyHjBXg1E,azHiBW/K;;mCAZaykK;mCAWpBpwL;6BAEOoiI;;;;kEAAY;;8BAAZ3gL;8BsIsNb4wF;8BtItNai+I;;;;;;;mCAbaF;mCAWpBpwL;6BAGOqe;;;;kEAAY;;8BAAZ78D;8BsIqNb6wF;8BtIrNak+I;;;;;;;mCAdaH;mCAWpBpwL;6BAIOsmI;;;;kEAAY;;8BAAZ/kL;8BsIoNb8wF;8BtIpNazhB;;;;;;;mCAfaw/J;mCAWpBpwL;6BAKOwmI;;;;kEAAY;;qCAAZllL;qCsImNb+wF;qCtInNao+I;;;;;2CAAsD;;;;;;;;;4CAGjE,wBAAsD;;;;;;;;;4CAGtD,4BAA2D;;;;;;;;;4CAG3D,4BAAgE;;;;;;;;;4CAGhE,4BAAqE;;;;;;;;;4CAGrE,4BAE4C;;;;;;;;;4CAG5C,4BAE4C;;;;;;;;;4CAG5C,4BAE4C;;sB+Y1EhC;uB/YmFR;;iCAgCSG,UAAUhqR;0BA5Bd;yDAJb8pR,QAgCiBE;2BA3BJ;;8B+MyLWljK;8B/M1LtBmjK;8CACkC,IAAOxtR,cAAP,OAAOA,IAAkB;2BAIxD;;8BAJHytR;mDA/HmB,yB2IUjBvsN;8BoE8SoBoiD;2B/MrLnB;;;;4CgJjJL5+C;2BhJmBA,GA2HE1kE;2BA1HuC,SADrC0iB,GACqC;0BAAzC,QA0HE1iB;0BA1HF,UA0HEA;0BAFW,IAUX0tR,WAAa,mBARb1tR;0BASJ,qBAfEqtR,QAgCiBE,aAlBfG,WARA1tR;0BA4BJ,OAF6BuD,GAG1B;sBASW;;sBrDnMV4sI;sBI4HFwV;sBADAD;sBJ5HExV;sBijBVN;;sBA4RG;;sBjjBjRGC;sBI4HFwV;sBgcxDgB;uB8G3EhBgoI,mCACF,sBAAmD;uBAoBjDC;iCAAYC;0BAEH,IAAP9W,KAAO;0BACX;4BAHc8W,iBAGQhzR,GAAK,cADvBk8Q,KACkBl8Q,EAAqB;0BAA3C,OADIk8Q,IAEU;uBAKV+W;uBAEAC;uBAEAC;6CAFAD,QAEAC,UAJAF;uB9S8TsBG;;;sBhQ1NxBvoI;sBJ5HExV;sBmjBVN;;sB/G+EoB;uB+G7EV;;;0B7CUwC,ITsBnC9xI,EStBmC,0BAA2B;;mCTsBtD,WxN0MnBysL,QwN1MWzsL,KStBA68F,Yld+DTywL,gB+flE0D;;;sBnjBE1Dv7I;sBI4HFwV;sBADAD;sBJ5HExV;sBsDVN;;sB8Y+EoB;;;;;;oCxboFpBuuC;;;;sB0C9JI;;;;;;;;;;6B1C8JJA;;;sBwbpFoB;uB9Y1EhB;;;;;;;;;;;;;;;;;;;;;;;;;oCkI0gBI;sClI1gBJ;;;;;;;;;6FAQgC;iDARhCnrC;;;;;;;;;;4CAGI;sEAHJF;;8CAGI;;sDqIgMF36B,crInMFo5B,KAGI2gD;;;2CAEA;qEALJp/C;;6CAKI;;kEALJvB,KAKI4gD;;;0CACA;oEANJr/C;;4CAMI;;iEANJvB,KAMI8gD;;;yCAJA;mEAFJv/C;;2CAEI;;qDqIiMF36B,crInMFo5B,KAEI0gD;;;wCAEA;kEAJJn/C;;0CAII;;;;;;gDAAO;;;iEAJXvB,KAIWr0I;iEAJXq0I,KAIW/iF;iDAAP4oI,YAAO52E;;;;4CAAP42E;6CAAO,yBAJXp5I,YAIIm5I;;;uCAHA;iEADJrkD;;yCACI;;;2CqIkMF36B;sDrIlMUlB;+CAAD,SAACA;;;;;;;;sEADZs6B,KACYr0I;sEADZq0I,KACY/iF;;+EADZxQ,YACYi5D,KAAc;6CAAtBogF;;sCADJ;;;;;;;;mCACI02F;6BADJ,MAEIC;6BAFJ,MAGIC;6BAHJ,MAIIC;6BAJJ,MAKIC;6BALJ,MAMIC;;;;+BADAE;+BADAC;+BADAC;+BADAC;+BADAC;;;sCACAD;sCACAD;sCACAD;sCACAD;sCACAD;4BANJ;;;;+CACIN;;gDACAC;;iDACAC;;kDACAC;;mDACAC;sDACAC,oCAE4B;uBARhC;uCAY8C7wR;0BAMrC;2BAN2BqxR;2BAARC;2BAANtqR;2BAAJuqR;2BAANnnP;2BAANonP;2BAMG,iBANqCxxR,EAAVqxR;2BAK3B,iBALqCrxR,EAAlBsxR;2BAIN,iBAJwBtxR,EAAxBgH;2BAId,oBAJsChH,EAAxBgH;2BAGjB,YAHauqR,GAA4BvxR;2BAEvC,YAFKoqC,KAAkCpqC;0BACvC;;oCADDwxR;;sCACmB,0BAAqB,iBADAxxR,EACZzE;sCAAO,qBADKyE,EACfhD,SAAoB;;;;;;sBA2BpD;;sBtDlCGs1I;sBI4HFwV;sBADAD;sBJ5HExV;sBuDVN;;sB6Y+EoB;uB7Y1EhB;;;;;;;iCAAQryI,G,UAARyxR,kBAAQzxR,KACuC;uBAD/C;iCAAKshP;0BAAL;oEAAKA,UAALrwL,IAC+C;uBAD/C;iCAAKuwL,QAALrnO;4DAAKqnO,QAALrnO,WAC+C;uBAD/C;iCAAKo0M,KAALp0M;0BAAiD,uBAA5Co0M,KAALp0M;0BAAiD,kBACF;uBAD/C;;;4BAAiD,IAAjD41M,mBAAiD,WAAjDixB;4BAAiD,oBAAjDjxB,OAC+C;uBAD/C;;;4B;8BAAA;;;;;;mCAAiDv8E,KAAjDC;mCAAiDz2I;mCAAjD,0BAAiDA;mCAAjDy2I,KAAiDD;mCAAjD3xH;;;iFAC+C;4BAD/C,YAC+C;uBAD/C;;;;;;;;;;;;;;;;;;;;oCiI0gBI;sCjI1gBJ;;;;uCAAiD;iEAAjD0zH;;;;0DAAiDE,WAAjDz4I;;8CAAiDy4I,WAAjD;yCAAiD,sBAAjD84E,KAAiD94E;;sCAAjD;;;;;;;sCAAiDy8I;4BAAjD,cAAiDC,qBAAjD,UAAiDA;4BAAjD;gEAAiDD,8BACF;uBAD/C;;;;2BAAiD,eAAjD3jE,KAAiDujE;;yCACF;uBAD/C;;0BAAyD,OAAzDziH;;mCAAyD,WAAzDgzE,wBAA2D;uBAA3D;;0BAAyD,OAAzD5xE;;mCAAyD,WAAzD4xE,wBAA2D;uBAA3D;;0B,kBAAAG;;iCAOIxiP;0BACN,SAAIs5N,a,IAAgBt8N;0BAApB,SACIu8N,KAAKv8N,GAAI,UAAJA,EAAY;0BACiB;0DAHhCgD,EACFs5N,MACAC,MADAD,MACAC,KAC0E;uBAV5E;uCAYmBv5N,G,IAALhD,WAAgB,qBAAXgD,EAALhD;sBAAqB;;sBvDNjCs1I;sBI4HFwV;sBADAD;sBJ5HExV;sBwDVN;;sB4Y+EoB;;;0B5YFR;;;;;;;;;;2BAGC,sBAHPnrI;0BAGO,SAEPwrR,UAAU11R;4BAEgB;4DAFhBA;6BAEI;6BAAL,+BAFCA;4BAED,gDAA2B;0BAJ7B,SAUHq1C,cAAU,QAAqB;0BAV5B,SAYHg8B,OAAOrxE,EAAEzB,GAAI,aAANyB,EAAEzB,GAA8B;0BAZpC,eAUH82C,OAEAg8B;0BAZG,SAkBHupK;4BAAS;;;sCAA4B,+BAArC3pG;;;uCAAS,+BAATgzG,aAA8D;0BAlB3D,SAkBH39K;4B;;;;;;mCAAA2qE;;;;sCAAS,eAATgzG,MAAS,aAATA,WAA8D;6C8YhGpEn4B;+C9YgGe,+BAATm4B,YAA8D;yC8YhGpEn4B;2C9YgG2C,+BAArC76E;4BAAS,YAC8C;0BAnBpD,SAkBHzlE;4BAAS;mCAAT8kG;6BAAS,MAATA;6BAAS,MAAT9jH;6BAAS,MAATA;6BAAS;;;0CAAqD;0BAA9D;;;;;;;;;;2BAAKolH,iBAAL9wB;;;;;6BAAS97I;;;wFAC8C;mCADvD8qK;;;;6BAASrxH,qCAATthC,QAAS82C;kEAAT92C,IAASshC,SAC8C;8BADvDsxH;;6EACuD;mCADvDG;;6BAASj8G,kCAAT92C;6BAAS+2C,kCAAT/2C;sCAAS82C;;2BAATk8G;oCAAKyB,cAAL7B;6CAASrzD;4BAAT,SAASA;;;;;;;;;;;4DAAT94D,YAAS84D,KAC8C;mCADvDgO;;;;6BAASzE;;0DAC8C;mCADvD7xC;4BAAS;mCAATq/F;6BAAS,MAATA;6BAAS,MAATC;6BAAS,MAATA;6BAAS;;qCAA4B,gCAA5BoiH;sCAAqD;mCAA9D/wK;;6BAASxwC,GAATruE;6BAAS+vR,GAAT/vR;6BAAS4tK,sCAAT/nD,IAASkqK;;;mCAATvlM;4B,IAAAq7B,I0LgFJpH;oE1LhFII,mBACuD;;;;6BADvD61H;;;;6BAAKhpE;6BAAL/B;;;;;;;;;;;;;;;;;;;;;;2BAOEo1E;mCAeM71E,kB;mCAEAC,WAAW9rK;4BAN+B;6BAD7BhF,EAOFgF;6BAPDvD,EAOCuD;6BAN+B,+BAD7BhF;6BACe,gBADlByB;mCACkB;6BAOL,6BADZuD;4BAEb,OAFaA,CAEZ;;;;+DAJC6rK,WAEAC;2BmTO6CwB;;;;;;;;;;;6BnTxBnDo0E;6BAPFrJ;;;;;;;;;;6BmT+BqD/qE;;;;;;;;;;;;;;;;;;8BnTgB/C;;+BACC,4BADLrtK;+BAEC,WADDE,GACC,yBADDA,GADAF;8BAEC;gCAGL;;;;;;;;;;;;;oCAPEsyH;iCAOF;;;;;;;;;;;;;;8DAIE;gCAEA;sCAAK;;;;2BAnDHkxH;2BAPF5I;;;;;;;;;;2BmT+BqDvsE;;;;;;;;mCnT+BvDukH;4BAEF;iDAGa73R,WAAHyB;6CAAGzB;4BADT,QAEa;mCAEf83R;4BAEF;iDAGa93R,WAAHyB;6CAAGzB;4BADT,QAEa;;;;;;;6BArEXyoP;6BAPF5I;;;;;;;;;;6BmT+BqDvsE;;;;;;;;6BnT+BvDukH;6BAQAC;2BASFC;mCAEAC,cAAchzR;4BACV,0BADUA;4BACV;mDAGOhF,aAAHyB;0CAAGzB;4BADT,sBAEM;mCAERi4R;gCAAcj4R,WAAHyB,oCAAGzB;;;;;iCAPdg4R,cAOAC;2BmTzDyDzjH;;;;;;;;mCnTwEzDnzD,SAAMr/G,EAAEgD,GAAI,wBAAJA,EAAFhD,EAAe;mCAErBk2R,OAAOz2R;4BAEA,IAALu3F,GAAK,UAFAv3F;4BAGN,gCADCu3F;wCACsB,yBADtBA;sCACyC;mCAE3Cm/L,aAAc12R;4BAQX,mBARWA;;wCAGV,IADGzB,WACH,wBADGA;8BAGiB;;+BACd,eADF47F;;;uCAGK;;;;;;;;;;;kCA3IbjwF;kCAGAulE;kCAEAimN;;kCA+FAY;kCAEAC;kCAOAC;kCmTzDyDzjH;;;;;;;;;kCnTwEzDnzD;kCAEA62K;kCAKAC;sBASH;;sBxD9MGphJ;sBI4HFwV;sBADAD;sBJ5HExV;sBojBVN;;sBhH+EoB;;;;mCgH3BdpwI;gCAAM9E,WAAHD;4DAAGC;mCAENw2R,MAAM1uQ,KAAM,aAANA,IAFNhjB,EAE8B;mCAE9B2xR;4BAEF;iDAGar4R,WAAHyB;6CAAGzB;4BADT,QAEa;mCAEfs4R;4BAEF;iDAGat4R,WAAHyB;6CAAGzB;4BADT,QAEa;mCAEfu4R,6BACCC;4BAKK;6DALLA;6BAID,YAJCA,cAjBDH;4BAqBA,yCACkD;mCAElDI,+BACCD;4BAIH;;6BACE;oCALCA,oBAKkB/2R,GAAK,aAALA,WAAuC;4BAA1D,yCACI;mCAEJo2R,WAAY7yR;4BACd,gBADcA;8BAGV,IADiBs6G,IAFPt6G,KAGV,oCADiBs6G;4BAGjB,IADoBsH,IAJV5hH;4BAKV,sCADoB4hH,IACa;mCAEnCkxK,WAAa9yR;4BACf;;6BACE,iBhT8PsBisH,OgT9PX,sBAFEjsH;4BACb,gCADaA,SAE8C;mCAE3D0zR,6BAA8B1zR;4BAE1B,gCAF0BA;4BAE1B;8BAIF;;+BAAc,iCADXugQ;+BAGD;4DAR0BvgQ,GApC9BszR;8BA4CI,uBADE9yB,UADAmzB;4BAFJ,8BAMyC;mCAY3CC,+BAAiC5zR;4BAEnB;6DAFmBA;6BAG7B,4BAH6BA;4BAG7B,SASF;4BANE;;;sCAJFwgQ;;wCAI0B;6DAGTxlQ,WAAHyB,uBAAGzB;wCADT,8BAEQ,GAEJ;;;;kCAlFd0G;kCAEA0xR;kCAEAC;kCAQAC;kCAQAC;kCAQAE;kCASAZ;kCAOAC;kCAIAY;kCAsBAE;sBAaH;;sBpjB5HG7hJ;sBI4HFwV;sBADAD;sBJ5HExV;sByDVN;;sB2Y+EoB;uB3Y/EpB;;;2BAKiEgiJ;2BAALC;2BAALC;2BAALC;2BAALC;2BAAJC;2BAAJC;2BAAJC;2BAAJC;2BAAJC;2BAAJC;2BAAJC;2BAAJC;2BAAJC;2BAAJC;;;;mCAAID;;oCAAID;;qCAAID;;sCAAID;;uCAAID;;wCAAID;;yCAAID;4CAAID,MAAID,MAAID,OAAKD,OAAKD,OAAKD,OAAKD;uBALjE;;;;;;;;;;;;;;;;;2BASyEA;2BAALC;2BAALC;2BAALC;2BAALC;2BAAJC;2BAAJC;2BAAJC;2BAAJC;2BAAJC;2BAAJC;2BAAJC;2BAAJC;2BAAJC;2BAAJC;uCAAID,GAAID,GAAID,GAAID,GAAID,GAAID,GAAID,GAAID,GAAID,GAAID,IAAKD,IAAKD,IAAKD,IAAKD;;sBAuHnE;;;;;;;uC7CmCNzzG;;sBwbpFoB;;uB3YiDd;;;;;;;;yC7CmCNA;;uB6CnCM;;;mCAkBEg3D,UAlBF56O;4BAmBI,SAnBJs4R,QAoBMt4R,sCAAc;;6BApBpB+yN,mBAmBM,6BAnBN/yN;;;qDAAkC,cAAlCs4R;;yDAqBoC;mCAHlClwN,SACEgE;qCAnBJksN,QAoBMt4R,sCAAc;sCADhBosE;8BAnBJ,OAmBIA,SAnBJqqE;;;;;;;;qCAA6CD,KAA7CC;qCAA6Cz2I;qCAA7C0/C,gBAmBM,6BAnBuC1/C;qCAA7Cy2I,KAA6CD;qCAA7C3xH;;sCAAqB0zQ,KAArB9hJ,QAAqBz8C;;;qCAAaw+L,KAAbx+L;2CAAa,oBAAlCs+L,UAAkCE;;kC+H+YhC;sC/H/YF/4O,4BAAqB84O,KAArB1zQ;;;;;;gGACmD;4BADnD,YAqBoC;0BAHlC;;;;;;;;;iCAlBFwzQ;;;;2BAkBOzoH,iBAAL9uB;;4BAlBF;gCAkBEv+I;6BAlBF,GAkBEA;;6BAlBF;sD7CmCNshL,gC6CnCM5vH;;mCAkBE67G;4BAlBF;gCAkBEvtK;6BAlBF,GAkBEA;;6BAlBFk8C,M7CmCNqlI,iC6CjBQ3mK,QAlBF82C;oDAkBE92C,IAlBFshC,SAsBoC;8BAJlCsxH;gDAGE5yJ;4BArBJ,sCAqBI2nI;mCAHFmsB;;;6BAlBmBwnH,a7CmC3B10G,gC6CjBQ5mK;6BAlB2C,8BAkB3CA;4BAlB2C,UAAxBs7Q,aAAwBC,aAsBT;;2BAJlCxnH;sCAAKtB,cAALG;;;;;4BAlBF,SAkBExsK,KAlBF,0CAkBEA;4BAlBF;yCAkBEA;6BAlBF;;;;;;;;;;;;;;;sC+H+YE;wC/H/YF;;;;;;;;;0FAkBEA,EAjBiD;mDADnDk1I;;;;;;0CAA6C;oEAA7CF;;4CAA6C;;;;;yCAAxB;mEAArBA;;2CAAqB;;qDkIwErB36B,oBlIxEqBg6E;;wCAArB;;;;sFAkBEr0L;8BAlBF;6EAkBEA;8BAlBF,UAAqBo1R,oBAArB,MAA6CC;;8DAAxBE;2DAAwBD;8BAA7C;;uCAkBEt1R;;iDAlBmBo1R;oDAAwBC;mCAkB3CluK;4BAlBF;0CAkBEnoH;6BAlBF,aAkBEA;;6BAlB2C;;6BAAxB6+C,MkI8ErBy6D,oBlI9EqB48K;iEAAwB/+I;sCAAxBC;mCAkBnBvlE;4BAlBoC,GAkBpC2xK,gBAlBoC;;mCAkBpCx5L;6BAlBoC,MAkBpCw5L;6BAlBoC;;yCAoBhCgzC;gFApB+B;;;4BAAC;qCAmBhC,8BADJhzC;qCAlBoCljP,CAqBF;mCAG9Bo2R,iB;0BANJ;wCAAKrpH;0BAAL;;;;;;6BAAKA;6BAALC;;;;;;;;;;;;6BAMIopH;2BANJ;mFAIkC;0BAJlC,sDAIkC;0BAJlC;;;;;;;;;;;;;mCAgBFC,kBAAgBl2R,EAAEzC,EAAEP;4BAAuB,8BAA3BgD,EAAEzC,EAAyB,QAAvBP,GAAwC;0BAhB1D,SAqBF2+O,YtBynCAxkJ;4BsBvnCI,StBunCJg/L,SsBrnCMn5R;;;;6FAAc,EAAdA,IAAoB;4BAFtB,StBy8BFs4R,QsBx8BIt4R,sCAAc;4BADhB,StBy8BFo5R,SsBz8BIp5R,yCAAoB;4BtBunC1B;;6BArJI;6BAqJJ;6BArJI;4BADQ,SAhyBZ66O;8BAgyBa,gCAFb;2EAEwB;4BAqGxB;6BAvGAjgB;;;;yCA9xBA56N;;mCAyBwC;;;;mCAzBxC;mCAwBkC;;;;mCAxBlC;mCAuBkC;;;;mCAvBlC;mCAsB0B;;;;mCAtB1B;mCAqBoC;;;;mCArBpC;mCAoB2B;;;;mCApB3B;;;;;;;;;2C4RqNao+O;;6C5RlMO,0DAAS;;sCAnB7Bs7C;;mCAkBmB;;;;mCAlBnB;mCAiByB;;;;mCAjBzB;mCAgBmB;;;;mCAhBnB;mCAemB;;;;mCAfnB;mCAciC;;;;mCAdjC;mCAaiC;;;;mCAbjC;mCAY4B;;;;mCAZ5B;mCAW4B;;;;mCAX5B;;oCAUI,6BAVJ15R;oCASI,6BATJA;oCAQI,6BARJA;oCAOI,6BAPJA;oCAMI,6BANJA;oCAKI,6BALJA;oCAKI,MALJA;;;qE4R0Oau/O,Y5R1Ob1E;;oCAGI,6BAHJ76O;oCAGI,MAHJA;;;qE4RySayiP,Y5RzSb5H;;;;;qE4RySa4H,Y5RzSb5H;;iEA2B8D;;+BAmwB9D9nB;;;;;;yCAtBE/yN;mCAKI;gEALJA;oCAII,8BAJJA;oCAGI,6BAHJA;oCAEI,6BAFJA;oCAEI,MAFJA;;;;;;;wCACS;;;8CAAC,gCADV;2FACiB;;sCADjBu5R;gEAOsD;;+BAexD3+D;6BAwJAs/D,mCAxJAZ,WAwJAD;;6BAjDA;;4BAIa;;;;4CAJb,+BA7HED,UAiIWp5R,EAAmC;+BA3C9C,MA2CWg6F;+BA3CX;8BAAwD;;;;8BA2C7C;+BA3CXw/L;+BAAiC,4BA2CtBx/L,SA3CXw/L;;;uDAAuB,cAAvB99B,OA2CW1hK;iCA3CXy/L;;;;4BAuCF;;;;;gEA7HEL;+BA6HFQ;;;;gEA7HER;+BA6HFS;;;;;;;;oC4R5lBap3C;6C5R6lBAziP,GADb,+BA7HEo5R,UA8HWp5R,EAAmC;;+BADhD85R;6BAiDAM,mCAjDAL,YAiDAG;0DsBpnC+C;0BA1B7C,SAqBFt6K,SAEIxzC;qCtBunCJ+sN;8B;oCsBrnCMzsN;;;0FAAc,QAAdA;;0CAoBH;4BAtBC,StBy8BF4rN,QsBx8BIt4R,sCAAc;4BADhB,StBy8BFo5R,SsBz8BIp5R,yCAAoB;sCAAtBosE;kCtBunCJ6uN,MsBvnCI7uN,StBunCJ8uN;;;;;;;wCAEIG,MAFJH,SAEI1kL;;;;0CA1JJ9pC,GA0JI8pC,OA1JJigC;;;;;;4CAEY;6CAAR+hJ,KAFJ/hJ;6CAEIt8C;6CAAQ;;gD;;;;;;uDAFZ82C;;;;0DAEa,eAFbgzG,MAEa,aAFbA,WAEwB;0DAFxB,0CAEwB;sDAFxB;gDAEa,YAGyC;6CALtD1kM;;;+CA9xBA;mD;;uDAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oEAQIq9O,MARJnmJ;oEAQIwjJ;oEARJ;;;;;;;;;6EAQIA;sEARJqC;;;;;;;;;;;;;;;;;yEAQIM;oEARJl9O;;;;;yEAqBIm9O,KArBJpmJ,QAqBInhC;qEAAgC,iBAAhCA;;;sEAAgC;yGAAS;6EAAT,qBAAhCA;;sEArBJl2D;;;;;;;;;;;;;;;;;;;;;;;;;;;2EAqBIy9O;sEArBJn9O;;;;sEAIIo9O,KAJJrmJ;sEAIIrhC;sEAJJ/1D;;;;;8F4R0OamgM,Y5R1Ob3E,QAIIzlI;wEAJJsnL;;;;;;;;;;;;;;;;;;;;;2EAIII;sEAJJp9O;;;;sEACIq9O,KADJtmJ;sEACIn8C;sEADJh7C;;8F4RySaojM,Y5RzSb7H,QACIvgJ;wEADJ22C;;;;;;;;;;;;;;;;;;;;;;;;2EACI8rJ;sEADJr9O;;;yEAsBI84O,KAtBJ/hJ,QAsBIt8C;qEAAsB,iBAAtBA;;;sEAAsB;yGAAS;6EAAT,qBAAtBA;;sEAtBJ56C;;;;;;;;;;;;;;;;;;;;;;;;;;;2EAsBIi5O;sEAtBJ94O;;;yEAeI64O,KAfJ9hJ,QAeIz8C;qEAAe,iBAAfA;;;sEAAe;yGAAS;6EAAT,qBAAfA;;sEAfJx6C;;;;;;;;;;;;;;;;;;;;;;;;;;;2EAeI+4O;sEAfJ74O;;;;sEAGI82F,KAHJC;sEAGIz2I;sEAHJ;;;;+EAGIA;wEAHJ28R;;;;;;;;;;;;;;;;;;;;;;2EAGInmJ;sEAHJ92F;;;;;sEAMIs9O,MANJvmJ;sEAMIujJ;sEANJ;;;;;;;+EAMIA;wEANJwC;;;;;;;;;;;;;;;;;;;2EAMIQ;sEANJt9O;;;yEAWIu9O,MAXJxmJ,QAWIjgC;qEAAwB,iBAAxBA;;;sEAAwB;yGAAS;6EAAT,qBAAxBA;;sEAXJntD;;;;;;;;;;;;;;;;;;;;;;;;;;;2EAWI4zO;sEAXJv9O;;;yEAYIw9O,MAZJzmJ,QAYIvgC;qEAAwB,iBAAxBA;;;sEAAwB;yGAAS;6EAAT,qBAAxBA;;sEAZJ5sD;;;;;;;;;;;;;;;;;;;;;;;;;;;2EAYI4zO;sEAZJx9O;;;yEAwBIy9O,KAxBJ1mJ,QAwBIzgC;qEAA8B,iBAA9BA;;;sEAA8B;yGAAS;6EAAT,qBAA9BA;;sEAxBJnyD;;;;;;;;;;;;;;;;;;;;;;;;;;;2EAwBIs5O;sEAxBJz9O;;;yEAgBI09O,KAhBJ3mJ,QAgBI5gC;qEAAe,iBAAfA;;;sEAAe;yGAAS;6EAAT,qBAAfA;;sEAhBJnyD;;;;;;;;;;;;;;;;;;;;;;;;;;;2EAgBI05O;sEAhBJ19O;;;yEAoBI29O,KApBJ5mJ,QAoBIhhC;qEAAuB,iBAAvBA;;;sEAAuB;yGAAS;6EAAT,qBAAvBA;;sEApBJt2D;;;;;;;;;;;;;;;;;;;;;;;;;;;2EAoBIk+O;sEApBJ39O;;;;;;yEAcI49O,MAdJ7mJ,QAcI8mJ;qEAA6B,iBAA7BA;;;sEAA6B;yGAAS;6EAAT,qBAA7BA;;sEAdJhyO;;;;;;;;;;;;;;;;;;;;;;;;;;;2EAcI+xO;sEAdJ59O;;;;sEAKI27O,MALJ5kJ;sEAKI+mJ;sEALJ;;;;;;+EAKIA;wEALJf;;;;;;;;;;;;;;;;;;;;2EAKIpB;sEALJ37O;;;yEAiBIw7O,MAjBJzkJ,QAiBIgnJ;qEAAqB,iBAArBA;;;sEAAqB;yGAAS;6EAAT,qBAArBA;;sEAjBJ9zO;;;;;;;;;;;;;;;;;;;;;;;;;;;2EAiBIuxO;sEAjBJx7O;;;yEAuBIu7O,MAvBJxkJ,QAuBIinJ;qEAA8B,iBAA9BA;;;sEAA8B;yGAAS;6EAAT,qBAA9BA;;sEAvBJ9zO;;;;;;;;;;;;;;;;;;;;;;;;;;;2EAuBIqxO;sEAvBJv7O;;;;sEAmBIi+O,MAnBJlnJ;sEAmBI4jJ;sEAnBJxwO;;;;;;;;;;;;;;;;;;;;;;4E4RqNaw0L;qF5RlMOr+O;;gHAAS;8EAAT,qCAAS;0EAAzBq6R;wEAnBJsB;;;;;;2EAmBIgC;sEAnBJj+O;;;yEAkBIk+O,MAlBJnnJ,QAkBI0jJ;qEAAe,iBAAfA;;;sEAAe;yGAAS;6EAAT,qBAAfA;;sEAlBJrwO;;;;;;;;;;;;;;;;;;;;;;;;;;;2EAkBI8zO;sEAlBJl+O;;;;;sEAEIm+O,MAFJpnJ;sEAEIqnJ;sEAFJC;;;8F4RySar7C,Y5RzSb7H,QAEIijD;wEAFJ5sJ;;;;;;;;;;;;;;;;;;;;;;;2EAEI2sJ;sEAFJn+O;;;;sEAOIs+O,MAPJvnJ;sEAOIwnJ;sEAPJ;;;;;;;;+EAOIA;wEAPJ1B;;;;;;;;;;;;;;;;;;2EAOIyB;sEAPJt+O;;;;sEASIw+O,MATJznJ;sEASI0nJ;sEATJ;;;;;;;;;;+EASIA;wEATJ9B;;;;;;;;;;;;;;;;2EASI6B;sEATJx+O;;;;sEAUI0+O,MAVJ3nJ;sEAUI4nJ;sEAVJ;;;;;;;;;;;+EAUIA;wEAVJjC;;;;;;;;;;;;;;;2EAUIgC;sEAVJ1+O;;;yEAaI4+O,MAbJ7nJ,QAaI8nJ;qEAA6B,iBAA7BA;;;sEAA6B;yGAAS;6EAAT,qBAA7BA;;sEAbJpzO;;;;;;;;;;;;;;;;;;;;;;;;;;;2EAaImzO;sEAbJ5+O;;;yEAyBI8+O,MAzBJ/nJ,QAyBIgoJ;qEAAoC,iBAApCA;;;sEAAoC;yGAAS;6EAAT,qBAApCA;;sEAzBJnzO;;;;;;;;;;;;;;;;;;;;;;;;;;;2EAyBIkzO;sEAzBJ9+O;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gWA2B8D;uDA3B9D;iEA2B8D;kDA3B9Dm7L;iDAgyBI1gJ;+CAFJ+2C;kDAEIsnJ;6CAFJ3zQ;;;;6CAGI0zQ,KAHJ9hJ;6CAGIz8C;6CAHJ,6BAGIA;6CAHJy8C,KAGI8hJ;6CAHJ1zQ;;;;6CACI2xH,KADJC;6CACIz2I;6CADJ0/C;;;kD;oDAtBE;;;;;;;;;;;;;;;;iEAGI82F,KAHJC;iEAGIz2I;iEAHJ,6BAGIA,GAHJ28R;sEAGInmJ;iEAHJ3xH;;;+DAEI0zQ,KAFJ9hJ;+DAEIz8C;+DAFJ,wBAEIA,KAFJk3C;oEAEIqnJ;+DAFJ1zQ;;gEACI2zQ,KADJ/hJ,QACIt8C;;;+DAAK4iM,KAAL5iM;;;gEAAK;;;sE;;;;;;6EADT82C;;;;gFACU,eADVgzG,MACU,aADVA,WACiB;gFADjB,0CACiB;4EADjB;sEACU,YAM4C;;oEAN7C84C;;;4DqJpmBT;;6DrJmmBAx9O;kEACIi5O;6DADJ3zQ;;;2DAIIi4Q,KAJJrmJ;2DAIIn8C;2DAJJ,mCAIIA,KAJJoiM;gEAIII;2DAJJj4Q;;;yDAKIg4Q,KALJpmJ;yDAKIrhC;yDALJ,wCAKIA;yDALJqhC,KAKIomJ;yDALJh4Q;;;;;;;;;;;;;;;;iKAOsD;kDAPtD,YAOsD;iDAgBpD7kB;+CADJixI;;kDACIuF;6CADJ3xH;;;;;;;;;gD,gBAAAqsH;;;;;uHAKsD;+CALtDD;;oCqJznBE;wCrJixBFzlF,gCAEI6vO,MAFJ1xO;;sCACI2zO,MADJpC,SACIlB;;;;wCAlDJkD,MAkDIlD,QAlDJiD;;;;;;;;;;8CAIIU,MAJJV,SAII/mL;0CAAS,iBAATA;;;4CAAS;+EAA6D;6CAA7D;0DAJb,6BA7HEkjL,UAiIWp5R,EAAmC;;sDAA5Ck2G;;;8CA3CF,SA2CEA,OA3CF4mL;;;;;;;qDAAiCK,KAAjCL;qDAAiCxnL;qDAAjC,0BAAiCA,KAAjCupL;0DAAiC1B;qDAAjCz5O;;;wDAA8C05O,KAA9CN,QAA8C1nL;oDAAU,iBAAVA;;;qDAAU;wFAAS;4DAAT,qBAAVA;;qDAA9C9rD;0DAA8C8zO;qDAA9C15O;;;wDAAcm5O,KAAdC,QAAcxiM;;;uDAAS+iM,KAAT/iM;6DAAS,oBAAvBohK,SAAuB2hC;;;;qDAAvBx5O;0DAAcg5O;qDAAdn5O;;;;;;;;;wD,gBAAAwtF;;;;;+HAC8D;uDAD9D4tJ;;;4CA2CW,UmajvCfhzE;;2Cna6uCEliK;iDAII+zO;2CAJJl0O;;;;2CAGIm0O,MAHJX;2CAGIjnL;2CAHJnsD;mFA7HEuvO,UAgIEpjL,KAHJ2mL;iDAGIiB;2CAHJn0O;;;;2CACImzO,MADJK;2CACIpnL;2CADJ/rD;;;;iD4R5lBa44L;0D5R6lBA1iP,GADb,6BA7HEo5R,UA8HWp5R,EAAmC;+CAA5C61G;6CADJ8oL;;;iDACI/B;2CADJnzO;;;;2CAEIuzO,MAFJC;2CAEIxnL;2CAFJ1rD;4EA7HEqvO,UA+HE3jL,KAFJipL;iDAEI1B;2CAFJvzO;;;;;;;;;8C,gBAAAkzO;;;;;;;;qIAM8D;6CAN9D+B;;;sCAiDAnzO,gCACI+xO,MADJ3zO;;;;;;kGAI+C;4BAJ/C,YsBpnC+C;0BAL/C;2BtBynCqBo0M,IvB7nC3Bn6E;2B6CIM;;;;;;;;iCtBynCAo6E;;2EAAqBD;;2BsBxnCdntF,iBADPq6F;gDACE1oQ;4B;qCtBwnCay8R;8B,OvB7nCrBn7G;4BuB6nCM;;;kCsBxnCEthL;6BtBwnCF,KsBxnCEA;6BtBukCF,GAiDAg1I;6BAjDA,KAiDAA;6BAjDA,KAiDAA;6BAjDA,KAiDAA;;6BAjDA;;;;;;kC4Rj/B4B4qG;kD,O5Rw7B1B2Z;kCAyDF51I;;2DAzDE41I,oBAyDFn7G;;2DAzDEm7G,oBAyDFojC;qCAvCO5kC,iB,OAlBLwB;4BA0GF;;;;;;;kCAjDA1O;kCvB5kCNrnE;;sCuBqiCQ;;;;oEvBriCRlC,iBuBqiCay2E,UAALrmM;;;iEvBriCR8xH,kBuBqiCau0E,UAAL/lC;oCAuCF04B;6BAvGA,GAwJAgyC;6BAxJA,GAwJAA;6BAxJA,GAwJAA;6BAxJA,6BAtBE5kC,0BAsBFpmM;;;;;gCA9xBA03L;;;qCAgyBaz3L;;kEAsJE8qO,YAtJF/qO;sEAsJE+qO,YAtJF9qO;kCAFbA;;;qCAwJAo5L;qCAxJA;mCsBj+BAx8E,cACE3zJ;;qCtBwnCagiR;8B,OvB7nCrBr7G;4BuB6nCM;;;kCsBxnCEvhL;6BtBwnCF,KsBxnCEA;6BtBukCF,GAiDAg1I;6BAjDA,KAiDAA;6BAjDA,KAiDAA;6BAjDA,KAiDAA;6BAjDAlgI;;;kC4Rj/B4B+qO;;oC,O5Rw7B1B2Z;gCsB9gCA5+O;;gCtBukCF+oG;mCAzDE61I,qBsB9gCA5+O,ItBukCF9F;mCAzDE0kP,qBsB9gCA5+O,ItBukCF0hC;qCAvCO47M;8B,OAlBLsB;4BA9CF;6BAwJAn7M;8BvB7nCNolI;yCuBqiCQ7oK;;;;;yCvBriCR2mK,kBuBqiCa22E,QAALt9O;;yCvBriCR6oK,mBuBqiCay0E,QAALt9O;gCsBhiCAA;gCtBukCFsjC;;6BAvGA,GAwJAw+O;6BAxJA,GAwJAA;6BAxJA,GAwJAA;6BAxJAt+O,MAtBE65M,2BsB18BAr9O,ItBwnCFyjC,MAxJAqT;;8BA9xBAs6L;yCAgyBYpxO;sCAAC+2C,8BAsJEirO,UAtJHhiR,QAAC82C;yCAsJEkrO,UAtJHhiR,IAACshC;gCsBl+BXthC;gCtBg+BFwjC;;oDsBh+BExjC,ItBg+BF2lC,SsB39BiD;8BANjDiuH;mCACEiB,aAIE70J;4BtBonCJ,sCsBpnCI2nI;mCAJFmtB;;qCtBwnCaksF;8B,OvB7nCrBp6E;;;;6BuB6kCUq7G;;;kC4Rl/BwB/8C;;oC,O5Rw7B1B2Z;gCsB9gCA7+O;;6BtBykCEkiR,SA3DFrjC,oBsB9gCA7+O;6BtB0kCEmiR,SA5DFtjC,oBsB9gCA7+O;qCtBgiCKy9O;8B,OAlBLoB;4BA3CE;6BAwGAujC;8BvBhlCVt5G;yCuBqiCQ9oK;kCAAiC;mCAAnBs8H,SvBriCtBsqC,iBuBqiCa62E,KAALz9O;mCAAiC,cAAjCA;mCAA8CsiR,UvBriCtDx5G,kBuBqiCa20E,KAALz9O;4CAAcs8H,SAAmB+lJ,SAAaC;gCsBhiC9CtiR;;6BtBynCEuiR,cAjDAN,SACAC,SACAC,SACAC;6BA1GAI,QAvBFhlC,0BsB18BAx9O;6BtBk+BE26O;8BAhyBJtJ;yCAgyBIrxO;sCAAS82C,GAsJEkqM,OAtJXhhP,aAAS+2C,GAsJEiqM,OAtJXhhP;4CAAS82C;gCsBl+BX92C;;6BtBm+BE,4BsBn+BFA;6BtBm+BE,cAFAwiR,QACA7nC,QACAL;sCAsJAioC,WACAE,WsBrnC6C;;2BAL/C1tH;sCAAKtB,cADPG,eACEmB;2BADF2tH;2BACE74C;;4BAIE,StBonCJ84C,QsBvnCMz4C;+EAAoB;4BtBwnCR,GsBznChBtxE,gBtBynCgB;sCsBznChBC,StBynCgB,MsBznChBD;4BtBynCgB,SAlDlBgqH,QAkDeC,wCAAE;4BAjDgC;iCAiD/BE;;8BAjD+B;;;;;kC4R7lBpC59C;2C5R6lBA89C;oCAAG;sDAAHE,wCAAE;6CAAFF;mDAAmC;;;8BAAC;gCACjC;;;;;6CAAHK,wCAAE;;;gCAAC;kCACA;;;;;+CAAHG,wCAAE;;;kCAAC;mCACoD;;;oCA8ClDV;qCA9CkD;gDAAvDY;yCAAoC,SA3C/C5kC,MA2CW8kC;2CAAG;6DAAHE,wCAAE;oDAAFF;0DAAmC;yCA3CpB,GA2CfF,gBA3Ce;;gDA2CfC;0CA3Ce,MA2CfD;0CA3Ce;;sDAAHM,sCAAE;;;yCAAC;2CAAgB,cA2C/BN;2CA3C+B;6CAAiB,UA2ChDC,SA3CgD,MA2ChDD;6CA3CgD;+DAAHQ,sCAAE;;;2CAAhB;yCAAhB,QA2CuC;;;;uCA8CjDpB,KA/CFS;;qCA+CET,KAhDFM;;mCAgDEN,KAjD+BC;qCAiD/BD;8BACa;qCsB1nC7BlqH;+BtB0nC6B,MsB1nC7BD;+BtB0nC6B;yCsBvnCzB2xE;kCAAe;oDAAfO;2FAAc;2CAAdP;iDtBunCuB;+BAAE;yCsBxnCzBH;gFtBwnCiB;8BAzJD;8BAyJS;+BAzJT;;+CAALo6C,yCAAG;+BAAE,eAyJNE,wCAzJD;8BAtBM;mCAsBCE;;gCAtBD;;;;;6CAATE;;;;;;;qDAAK,MAALE,cAAO;;;gCAAE;kCACT;;oCACA;;qCACE;;sDAC0B,yBAD1BM;;yCAmBQV,KApBVS;;uCAoBUT,KArBVQ;;qCAqBUR,KAtBDC;uCAsBCD;gCACI;;;;2CAAbW;;;;;;;mDAAO,QAAPE,cAAW;gCA/xBb;qCA+xBeI;;kCA/xBf;;;;;sC4RwSE1gD;+C5RxSL1rE,sCAAE;;;kCAAC;oCACW;;;;;wC4RuST0rE;iD5RvSM2gD,sCAAE;;;oCAAC;sCACd;;wCACG;;;;;4C4RsOE7jD;qD5RtOL+jD,sCAAE;;;wCAAC;0CACY;;4CACC;;8CACI;;gDACT;;kDACC;;oDACU;;sDACC;;;;;mEAAH/9G,sCAAE;;;sDAAC;wDACA;;;;;qEAAHE,sCAAE;;;wDAAC;0DACK;;;;;uEAAHG,sCAAE;;;0DAAC;4DACA;;;;;yEAAHE,sCAAE;;;4DAAC;8DACd;;;;;2EAAH09G,sCAAE;;;8DAAC;gEACA;;;;;6EAAHE,sCAAE;;;gEAAC;kEACM;;;;;+EAAHp9G,sCAAE;;;kEAAC;oEACN;;;;;iFAAHE,sCAAE;;;oEAAC;sEACQ;;;;;0E4RkMjB43D;mF5RlMOz3D;4EAAG;8FAAHE,sCAAE;qFAAFF;2FAAS;;;sEAAC;wEACA;;;;;qFAAHi9G,sCAAE;;;wEAAC;0EACS;;;;;uFAAHG,sCAAE;;;0EAAC;4EACV;;;;;yFAAHG,sCAAE;;;4EAAC;8EACQ;;;;;2FAAHG,sCAAE;;;8EAAC;gFACA;;;;;6FAAHG,sCAAE;;;gFAAC;iFACM;;;kFAuwBjBrB;mFAvwBiB;8FAAHuB,sCAAE;;;;qFAuwBhBvB,KAxwBWoB;;mFAwwBXpB,KAzwBWiB;;iFAywBXjB,KA1wBGc;;+EA0wBHd,KA3wBaW;;6EA2wBbX,KA5wBIjsL;;2EA4wBJisL,KA7wBInsL;;yEA6wBJmsL,KA9wBJtsL;;uEA8wBIssL,KA/wBE1sL;;qEA+wBF0sL,KAhxBJ5sL;;mEAgxBI4sL,KAjxBJ7sL;;iEAixBI6sL,KAlxBU/sL;;+DAkxBV+sL,KAnxBUjtL;;6DAmxBVitL,KApxBKptL;;2DAoxBLotL,KArxBKxtL;;yDAqxBLwtL,KAtxBIztL;;uDAsxBJytL,KAvxBN3tL;;qDAuxBM2tL,KAxxBP7tL;;mDAwxBO6tL,KAzxBE9tL;;iDAyxBF8tL,KA1xBF/tL;;+CA0xBE+tL,KA3xBHhuL;;6CA2xBGguL,KA5xBfjuL;;2CA4xBeiuL,KA7xBlBn3N;;yCA6xBkBm3N,KA9xBJhiP;;uCA8xBIgiP,KA/xBfngS;6CA+xBemgS,KACX,4BADWA;8BADJ;4BAwJJ,WsBrnC6B;mCAJ7CyB;4B;4BAGI,sB,OkI6BN7mL;4BlI7BM;8EAHJr6G;;4B;qCtBwnCF46P,c,OwJllCAtiJ;4BxJklCA;;;wCsBxnCEt5G;6BtBwnCF,WsBxnCEA;6BtBg+BF,WA0JIq9R;6BA1JJ,QA0JIA;6BA1JJ,QA0JIA;6BAvJA;;6BAqJJ;4BArJI,SAjyBJ5oJ;;+BAgyBa/iF;;oCAsJbkqM,OAtJax7P;oCAsJbw7P,OAtJalqM;;4BAhyBb;4DAgyBI6jM;6BAhyBJ,8BAgyBIA;6BAhyBJ,8BAgyBIA;6BAhyBJ,sBAgyBIA;6BAhyBJ,+BAgyBIA;6BAhyBJ,uBAgyBIA;6BAhyBJ,gBAgyBIA;6BAhyBJ,eAgyBIA;6BAhyBJ,qBAgyBIA;6BAhyBJ,eAgyBIA;6BAhyBJ,eAgyBIA;6BAhyBJ,6BAgyBIA;6BAhyBJ,6BAgyBIA;6BAhyBJ,wBAgyBIA;6BAhyBJ,wBAgyBIA;6BAhyBJ,0BAgyBIA;6BAhyBJ,gBAgyBIA;6BAhyBJ,eAgyBIA;6BAhyBJ,wBAgyBIA;6BAhyBJ,oBAgyBIA;6BAhyBJ,mBAgyBIA;6BAhyBJ,IAgyBIA;6BAhyBJ,IAgyBIA;6BAhyBJ,eAgyBIA;6BAhyBJ,IAgyBIA;6BAvwBA5xP,IwJ6MJu1G,exJtOAu7B,KAyBIi5G;;6BADA7uM,MwJ8MJq6D,exJtOAu7B,KAwBIg5G;iEACAt2G;6BAFA7/C,MwJ+MJ4hB,exJtOAu7B,KAuBI+4G;iEACAp2G;6BAFA5/C,MwJgNJ0hB,exJtOAu7B,KAsBI84G;iEACAtvG;6BAFAtmD,MwJiNJuhB,exJtOAu7B,KAqBI64G;iEACApvG;6BAFApmD,MwJkNJohB,exJtOAu7B,KAoBI44G;iEACAv8F;6BAFA54D;;gC4RkMS8jJ;gD,OpIiBb9iI,exJtOAu7B;gCAmBI24G;iEACA1xD;6BAFApjG,MwJoNJ4gB,exJtOAu7B,KAkBI04G;iEACAxxD;6BAFA4b,MwJqNJr+F,exJtOAu7B,KAiBIy4G;iEACA51C;6BAFAG,MwJsNJv+F,exJtOAu7B,KAgBIw4G;iEACAz1C;6BAFAG,MwJuNJz+F,exJtOAu7B,KAeIu4G;iEACAt1C;6BAFAG,OwJwNJ3+F,exJtOAu7B,KAcIs4G;mEACAn1C;6BAFAG,OwJyNJ7+F,exJtOAu7B,KAaIq4G;mEACAh1C;6BAFAG,OwJ0NJ/+F,exJtOAu7B,KAYIo4G;mEACA70C;6BAFAG,OwJ2NJj/F,exJtOAu7B,KAWIm4G;mEACA10C;6BAFA;mEACAE;6BAFA;mEACAE;6BAFA;mEACAE;6BAFA;mEACAm9C;6BAFA;mEACAE;6BAFA;mEACAE;6BAFAG,kB4RsOS/Y,a5R1Ob1oG,KAII43G;mEACA4J;6BAFA;mEACAE;6BAFAG,kBuc7UFjW,avc2UF5rG,KAEI03G;mEACAkK;6BAFAG,kBuc5UFnW,avc2UF5rG,KACIy3G;mEACAqK;6BA8xBAG,UA/xBAD;6BA+xBA6rC,sCACAF;6BAzBF,+BAuBEhF;6BAvBF,QAuBEA;6BAvBF,MAuBEA;6BAvBF,MAuBEA;6BAvBF,KAuBEA;6BAlBE;;6BADA;mEACA3nC;6BAFA;mEACAkB;6BAFA;mEACAE;6BAFA2rC;8BwJr6BNlpL;;;mCxJq6BY5nD;;;;;gCAAN6mM;mEACAlD;6BAqBFotC,UAtBE1rC;6BAsBF2rC,sCACAJ;6BAwJAK,UAzJAD;6BAyJAE,sCAFJP;6BAjDA,SAkDIlF;6BAlDJ,SAkDIA;6BAlDJ,SAkDIA;6BAlDJ,SAkDIA;6BAlDJ;qCAvCE9kC,Y,OwJ1/BF/+I;;6BxJqiCIwpL;8BwJnqBJ5pL;;kCxJwnBE;;;;mCAA8Cv1G,IwJxnBhDu1G,exJwnBEm/I,KAA8C6kC;;mCAAb;uEAAa/lJ;mCAAhC7/C,MwJ1/BhBgiB,cxJ0/BE++I,KAAcnhH;uEAAmBE;4CAAnB6G;gCA2CZ++I;mEAJJ6F;6BAGIG,OwJpiCJ1pL,oBxJoiCIyjL;mEACAgG;6BAFAG,OwJniCJ5pL,oBxJmiCIwjL;mEACAmG;6BAFAG;;gCucjtCF/iD;gD,O/S+KF/mI;gCxJkiCIujL;mEACAsG;6BAgDAG,UAjDAD;6BAiDAE,sCACAX;sCADAW;mCsBznCF3kH;qCtBwnCF6kH,csBrnCMj6K;8B,OATNmtK,kCASMntK;;;;mCAHJ7lH;;6BtBukCF+/R;;gCuchtCE1jD;yCvcitCWx2H,S,O0E3uCf+8H,sB1E2uCe/8H;gCsBxkCXg6K;;6BtBukCFG,O0E1uCFp9C,sB1E0uCEm9C;oC0E1uCFn9C,sB1E0uCEo9C;;6BA7HEE;;gCwJ/iBF5iL;yCxJgrBa0yK;2CA3CXmQ,YA2CWt6K;oC,O0E9uCf+8H,sB1E8uCe/8H;;mCA3CXA,I0EnsCJ+8H,gB1EmsCIu9C,YA2CWnQ;mCA3CXpiH,sBA2CW5tK;oDwJhrBbs9G,iBxJqoBE6iL,kBA2CWngS;gCAJbigS;;mCsBvkCEjgS;;;6BtB08BAogS;8B0E7mCJx9C;yC1E8mCc/8H;;;;;;;gCADVq6K;;;;;6BAsBFM,wBAtBED;;qCAxwBFE,YAgyBa56K;;;;qCAsJbi6K,cAtJaj6K;qCAsJbi6K,cAtJalyH;;;6BAhyBb/nD,euc3UEw2H,evc2UFokD,YA8xBAD;6BA9xBA5yH,iBuc3UEyuE,evc2UFokD;;8C4R0OatnD,e5R1ObsnD;;;;;;;;yCwJyNAnjL,iBxJzNAmjL;;yCwJyNAnjL,iBxJzNAmjL;;yCwJyNAnjL,iBxJzNAmjL;;yCwJyNAnjL,iBxJzNAmjL;;yCwJyNAnjL,iBxJzNAmjL;;yCwJyNAnjL,iBxJzNAmjL;;yCwJyNAnjL,iBxJzNAmjL;;yCwJyNAnjL,iBxJzNAmjL;;;;gC4RqNazoD;yC5RlMOnyH;kC,kBwJsMpBvI,iBxJzNAmjL,YAmBoB56K;gCAnBpB27K;;;yCwJyNAlkL,iBxJzNAmjL;;yCwJyNAnjL,iBxJzNAmjL;;yCwJyNAnjL,iBxJzNAmjL;;yCwJyNAnjL,iBxJzNAmjL;;yCwJyNAnjL,iBxJzNAmjL;6BA8xBAsB;yCwJrkBAzkL,iBxJzNAmjL;oDA8xBAsB;mCsBh+BEv3M;4B,IAAAq7B,IyLUFpH;;qCzLVEw8D,qBAK+C;mCAL/C31G;4BAIE,StBonCJs0N,QsBvnCMppH;+EAAoB;4BtBwnCR,GsBznChB0xE,gBtBynCgB;sCsBznChBD,StBynCgB,MsBznChBC;4BtBynCgB,SAlDlB23C,QAkDemI,wCAAE;4BAjDgC;;;;;;;;kC4R7lBpC1lD;2C5R6lBA4lD;oCAAG;sDAAHE,wCAAE;6CAAFF;mDAAmC;;;;8BAAC;gCACjC;;;;;6CAAHI,wCAAE;;;gCAAC;kCACA;;;;;+CAAHE,wCAAE;;;kCAAC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;;;;;;;;;sBxI6EF;yBjQ3DhBvvI,SACA2tD;;uB;;;;;;4CADA3tD,M;;;;;;;;;;sBiQ2DgB;;;;;;;6CjQ7DhB0tD;;;;;;;sBiQ6DgB;;;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2CrOsNdynB;2C5BnRFznB;sBiQ6DgB;;;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sCrQ+ed7C;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gDP/CE;gD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BwC4CuC;0B,SAUxB21Q,W;mCADDC,W;;oCAAAA;oCACCD;oCACAD;oCACCD;kC;;;;;;;;;;;;;;;;;;sCxMpkBF1rS;;;;;0B;;;;;;;4BgK4gBd;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB4QhcY;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uC5QgcZ,oB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4E0CvgBFm2D;;uB;;;;;;;sBkOuEc;2C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAAA;;;;;;uB;;;sBAAA;uB;;;;;sBAAA;;;;0B;;;;;;;;;;;;sBAAA;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAAA;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kC5QgcZ;oC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAAA;kC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yCwCqpBAe;+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BxCrpBA,yB;;;;;;sB4QhcY;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4DzQqvBd/gC;;qC;;;;;;gD8BxyBF+wB;;;;;+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gDAAAA;;;;;;;;;;;8B;;;;gDAAAA;;;;;;8B;;;;;gDAAAA;;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BjCmfI,wB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2CO+CFjxB;6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oEAAAA;+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4CAAAA;iC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCP/CE;;iD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2CAAA;;;;;;;;;;;2C;;;;;;;;;;;2DqZ5cG61Q,M;;;;;;6CrjBhEW9rS;4B;;;gEyMgBlB/pB,a;;;;;;;;;;;;;;;;;;;;;;;;0BzC4fI;;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEqZ5cG61T;0B;;;;;;;0BrZ4cH;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAAA;kC;;;;;;;;;kEmB5dJ3tQ,4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6CEwCO;6CD+HT,uBADS/tE;4CACT,SAAIuC;uDADKvC;;8CAGC,wBAFNuC,GAEM,MAFNA,UAEM;;oDACR/E;gDAAsB;;6EAJfwC,EAIPxC;mD,mCAAAA;wEADI6D,EACJ7D;kDAAsB,UAAtBA;;;8CADQ,UAAJ6D;4C;;;;;;;;;;;;;;;;;;;;;;8CX3GDkB,WAAH5C,W,OAAAA,K,OAAAA;0C;;;;;;wEAAG4C;;;;;;kC;;;;;;;;;;;;0B+B0vBuC;;;;;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qE6WxyBnCm5U;mC;;;;;qEAAAA;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAAAA;0B,mDAAAA;0B;;;;;;;;;;;;;;sBzIYS,uB;;;;;sBAAA;;;;;;oC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCyIZTA;uB;;;;;;;;;;;;;;;0BrZ4cH;0B;;;;;;;;;;;;;;;;yCqZ5cGA;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAAAA;0B;;;qEAAAA;0B;;;;;;;;;;qEAAAA;0B;;;;;;;;;;;;qEAAAA;0B;;;;;;;;;;;;;qEAAAA;0B;;;;qEAAAA;0B;;;;;qEAAAA;0B;;;;;;;;;;;;;;;qEAAAA;0B;;;;;;;;;;;;;;;qEAAAA;0B;;;;qEAAAA;0B;;;;qEAAAA;0B;;;;;;;;;;;;;;;;;;;;;qEAAAA;0B;;;;;;;;;;;;;;;;;;;;;qEAAAA;0B;;;;;;;;;qEAAAA;0B;;;;;;;;;;;;;qEAAAA;0B;;;;;;;;;;;;;qEAAAA;0B;;;;;;;;;;;;;qEAAAA;0B;;;;;;;;;;;;qEAAAA;0B;;;;;;;;qEAAAA;0B;;;;;;;;;;;;;qEAAAA;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAAAA;0B;;;;;;;;;;;;;;;;;;;;;qEAAAA;0B;;;;;;;;;;qEAAAA;0B;;;;;;;;;qEAAAA;0B;;;;;;;;;;;;;;;;qEAAAA;0B;;;;;;;;qEAAAA;0B;;;;;;;;;;;;;;;;;;qEAAAA;0B;;;;;;;;;;;;;;;;qEAAAA;0B;;;;;;;qEAAAA;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BrZ4cH;;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;;;yC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAAA;iC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDarfJpyQ;iC;;;;;;kDAAAA;gC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BbqfI;;uC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;;;;;;;;;;;;;;;;;;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;;;;;sE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wE+BpYgBgmF,I;yEAAAA,I;qEAAAA,M;kEAAAA,M;;;2CsXxEbosL;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BvlBoJT;;;8B;;;;;;;8BkMwTM,c;;;8BlMxTN;;;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB8cxIkB;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oC0IrCH,WAAJl+U;oCAAI,YAAJA;;;;;mC;;2CAAAA,E,gDAAAA;iC;;;kCvXkGX;wCAAIsZ,IADkBw4I;oCACtB,GADsBA,UAClBx4I,IACoB,OAFFw4I,IAHpB/1E;oCAIF;qCAC4D,MAFtC+1E;qCXmftB;;wC;qCAAA;sDAGkB;oCACT;qCAGA;sCAMA;wCAOA,mBAQF;wCAPH;8CWvgBAx4I;yCXugBA;0CApBAw3B,MAoBIqvI;;6CAEH,qBWzgBD7mK;6CX0gBC,UW1gBDA;6CX2gBC,UW3gBDA;6CX4gBC,UALG6mK;;;uCAPJ;+CWhgBA7mK;wCXggBA;yCAbAw3B,MAaIqtS;;4CAEH,qBWlgBD7kU;4CXmgBC,UWngBDA;4CXogBC,UAJG6kU;;;sCANJ;8CW1fA7kU;uCX0fA;wCAPAw3B,MAOIstS;;2CAEH,qBW5fD9kU;2CX6fC,UAHG8kU;;;sCAHJ,qBWvfA9kU,eAEAxU;;sCAEE,OALgBgtJ,IAHpB/1E;oCASG,SALDziE,MAEAxU;;;;iC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iC/BiYE;+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB4QhcY;;0C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAAA;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4B5QgcZ;6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAAA;;;;;;;;;;;;;;uD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA,gB;;;;;;;;;;;;;;;0BAAA,+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA,qB;;;;0DGqTFyjE;mC;;;;;;;;iCAhyBFe,uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BH2eI,mB;;;;;;;;;;;;;sB4QhcY;uB;;;;;;;;;;;0B5QgcZ;;qD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAAA;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAAA;;;;gC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAAA;;;;yC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;;;;;;;;;;;;;;;;;;;;;;;;;;0E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA,gB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAAA;+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2CwCqpBAggC;gC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BxCrpBA;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB4QhcY;;;;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4B5QgcZ,Y;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sCqZ5cG40O;;;2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BrZ4cH;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB4QhcY;uB;;;;;;;;;;;;;;;;;sBAAA;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDyIZTA,Q;;;;;;;;;;;;;;;;;;;;;;;;6BAAAA;;;;6B;;;;;;;;;;;;;;;;;;;;;;;;;;+BAAAA;;;;;4B;;;;;;;;;;;;sCAAAA;yC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBzIYS;;;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6ByIZTA;;;;;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAAAA;;;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCrZ4cH;qC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB4QhcY;;;2C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8B5QgcZ;gC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB4QhcY;;2C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4B5QgcZ;;;+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCAAA;yC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8CqZ5cGA,mC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4CAAAA,M;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BrZ4cH;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAAA,c;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAAA,qB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA,c;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sCAAA,uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAAA;;;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iDAAA;;8C;;;mDgBtfJ7wQ;;uD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BhBsfI;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB4QhcY;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4B5QgcZ,uC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAAA,Y;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gEqZ5cG6wQ;6B;;;;;;;;;;;;;;;;;;;;;;;;;kEAAAA;6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBzIYS;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gEyIZTA;6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8CAAAA;;;6B;;;;;;;;sBzIYS;uB;;;;;;;;;;;;;;;;;0B5QgcZ;4C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAAA,c;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wDejcArxQ,uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB6PCY;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8B5QgcZ;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA,uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEqZ5cGqxQ;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BrZ4cH;6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qDarfJpyQ;;0B;;;;;;;;;;;;;;;;;;;;;;qCbqfI;sC;;;;;;;;;;;;;;;;;;;;;;;;4BAAA,c;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB4QhcY;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAAA;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mC5QgcZ,Y;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAAA;;;;;sC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;;;;;;;wC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAAA,Y;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAAA;;;;;;;;qC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA,Y;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;;;;;gC;;;;;;;;;;;;;;;;;;4BAAA;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;;;;;gC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB4QhcY;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0B5QgcZ;;;;;gC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;;;;;;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qDAAA;8D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA,kB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCAAA;gD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;;;;sC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA,Y;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4CAAA;4C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0CAAA;0C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2CAAA;oD;;;;;;;;;0BAAA;;;;;;;6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;;;;;;;;;;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAAA;wD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAAA;+B;;;;;;;;;;;;;;;;;;;;;sB4QhcY;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAAA;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;sC5QgcZ,mB;;;;;;;;;;;;;;;;;;sB4QhcY;mD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gDyIZToyQ;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mC7WimCH50O;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oDAAAA,oBCjpCJjhF;yC;;;;;;;;;;;;;;;;uDtBsBAioD,K;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCnBseI;;;qC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB4QhcY;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4B5QgcZ;4B;;;;;;;;;;;;;;;;;;;;;;;;;sB4QhcY;uB;;;;;;;;;;;;gEnQ3ChB3C,oB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCT2eI,uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAAA;yC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAAA,sB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yCAAA;2C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAAA;qD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAAA,sB;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;gD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCSyDN,SAAQ6qJ,OAAO10E,MAAMv3E;oCACnB,SADau3E;sCAGX;;kEAAmB7vG,IAAIhyC,GAAK,UAALA,EAAJgyC,IAAe,QAHjBs4B;oCAKR,qBALQA;oCAKR;0CAEMF,cAAHpqE;sCAAiB,UAAjBA,EAAiB,OAPlB6hJ,cAOIz3E;oCADF,QACqC;kCAPtD,0BADSI;;oC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BTxDH;;;gC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCwCqpBA68B;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAAAA;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0CxCrpBA,sC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAAA;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAAA;kC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB4QhcY;;;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iC5QgcZ;+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uEqZ5cG40O;;;;6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BrZ4cH,Y;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAAA;gC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB4QhcY;;;0B;;;;;;;;sBAAA;;;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCpOqlCZ50O;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BxCrpBA;qC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCgBpfM;;oC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BhBofN;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAAA;;;mC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAAA;mD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA,Y;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB4QhcY;;;;oC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4B5QgcZ;;+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA,mB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAAA,Y;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAAA;oC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mEqZ5cG40O;;;;;;qC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCpY3CP3wQ,sB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB2PuDgB;;;;wC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0B5QgcZ;mC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;mC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA,8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCwCqpBA+7B;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qD6WjmCG40O;6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BrZ4cH,+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qDAAA;;;0D;;;uEqZ5cGA;0D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BrZ4cH;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAAA;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAAA;wD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAAA;sC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8CAAA;8C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB4QhcY;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0B5QgcZ;mC;;;;;;;;;;;;;;;;;;;;;;;;;8BqZ5cGA;0C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BrZ4cH;wE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8DqZ5cGA,kB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCrZ4cH;0C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAAA;;;;;;;;;;;;;;;;2C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;;6B;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAAA;;2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;;;;;;;;;;;;;;oC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAAA;;;;;;;;;;;;;;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6CAAA,gB;;;;;;;;;;;;;;;;4BAAA;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAAA;kC;;;;;;;;;;;;;;;;;;8BAAA;;kC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gFqZ5cGA,S;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4C7XpBPtsQ;;;;mC;;;;;;;;;4C7NjBiBO;;;;mC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BqMifb;qC;;;;;;;;;;;;;;;;;;;;;;;;yES3dJt2D;qC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAAAA;;;;gC;;;;;;;;;;;;;;;;;uEAAAA;mC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gEAAAA;iC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iEAAAA;;;;mD;;;;;;;;;;;;;;;;;;;;6CMlBIywD;kC;;;gEAAAA,6B;4DAuBAI;4B,OAlCJT;0B,IAEOhqE,E;iDAAO,UAAPA,EAFPgqE,O;;;;;;;iEN6BApwD;6B;;;;;;;0CM7BAowD;kC;;;;;;;;;2CAWIK,+B;;;;;;;;;;+DAXJL;oC;;;;;;;;;6CAWIK;kC;4DAuBAI;4B;;;;;qCAvBAJ;0B,OAXJL,K;;;;;;;wDAWIK,uB;;;;;;;;;;;uENkBJzwD;mC;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAAAA;sC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oDT2dI;;mD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;;;iC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;;;iC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qDezeA2wD;6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BfyeA;qC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sCAAA;;;;;wC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAAA,qB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAAA;;;sC;;;;;;;;;;;;;;;;;;;qCAAA;qC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sCAAA;sC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAAA;kC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAAA;;wC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;;6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAAA;;;;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA,Y;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAAA;gC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;;;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAAA;uC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAAA,Y;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCAAA;;;;yC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA,c;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;wC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;;;;+B;;;;;;;;;;;;;;;;;;;;;;4BAAA;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAAA;;;;2D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yCwCqpBA88B,oD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBoOrlCY;;;0B;;;;;;;;;;;;;;;;;;;;;8B5QgcZ;gC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAAA;;;;wD;;;;;;;;;;;;;;;;0BAAA;;;;;;gC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA,qC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA,Y;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;mC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAAA;wC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qFiB9fJnuF;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BjB8fI;;gC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA,mB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAAA;mC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAAA;kC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAAA;;oC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sEqZ5cG+iU;;4C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BrZ4cH;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sCAAA;wC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCuB3UN;;;;iCACal+U;gCACX;qCADWA,MADT8E;;;oCAGQ,qBAFC9E,G;;;;;;;;8CAEqB,QAFrBA;oCAED;;;;;;;;uC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BvBwUN;qC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAAA;;;wC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAAA;kC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAAA;oC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAAA;+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA,2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gDAAA;kD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAAA;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sCAAA;;;yD;;;;;;;;;;;;;sFqZ5cGk+U,M;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCrZ4cH;2C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAAA;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDqZ5cGA,Q;;;2EAAAA;oC,kCAAAA,wB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kEAAAA;;;;;;;;;;;;;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BrZ4cH;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;;;;;;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oDAAA;oD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yCGqTF31Q;;;;;8BHrTE;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB4QhcY;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qD/PrDhBuD;;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+EwYyCOoyQ,yB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6CrZ4cH;wD;;;;;;;iFqZ5cGA,O;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yCrZ4cH;kD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uEqZ5cGA;mC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2DrZ4cH;;;;;;;2D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yDAAA;;;;;;;yD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yDAAA,yB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA,c;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2EqZ5cGA;oD;;;yEAAAA;gC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBzIYS;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kEpOqlCZ50O,oBCjpCJjhF;uD;;;;;;;;;;kEDipCIihF,oBCjpCJjhF;uD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBmO4DgB;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kC5QgcZ;;;;;;;;oC;;;;;;;;;;;;;;;;0BAAA,wB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uDarfJyjD;qC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0DAAAA;wC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAAAA;gC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kEAAAA;iD;;;;;;;;;;;;;;;;;;;;;;;;;;;gDbqfI,Y;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2DarfJA;yC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yEAAAA;oC;;;;;;;;;2EAAAA;sC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sDAAAA;oC;;;;;;;;;;;;;;;;;;;;sB+PqDgB;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kC5QgcZ;kC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAAA;;iC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0CqZ5cGoyQ;;;;;uC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BrZ4cH;uD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8DgBvfJ/wQ,sB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BhBufI;;;qC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0DqZ5cG+wQ,a;;;;;;;;;;0DAAAA;;;;;iE;;;sBzIYS;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6B5QgcZ;+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0CAAA;oG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wEgBxfJhxQ,+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BhBwfI;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB4QhcY;;;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAAA;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gDyIZTgxQ,uB;;;uEAAAA,K;;;wD9Y2fL71Q,gB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0CAAAA;;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BP/CE;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yEqZ5cG61Q;;;;;;0D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCrZ4cH;;;;sC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;mC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAAA;;kC;;;;;;;;;;;;4BAAA;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCarfJpyQ;;0B;;;;;;;;;;;oEnN6BAL;;;qEAJAF;;6C;;;;;;;;;;;;;;;;;;;;;;;;;sBkd4BgB;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8B5QgcZ;;;;kC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mDQ7dAjD,MD4gBFD,kC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BP/CE;;;;;mC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCAAA;yC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAAA,uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iEQ7dAC,MD4gBFD;;;0C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0DP/CE;0D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6CAAA,qC;;;wDO+CFA;uC;;;;;;;;;;;;;;;uCP/CE;uC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEQ7dAC,MD4gBFD;8C;;;;;;;;;;iEC5gBEC,MD4gBFD;2C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iEAAAA;wC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCP/CE;;yC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA,gB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB4QhcY;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qC5P7DhB2E,K;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BhB6fI;;;0BiBzfO;4BAAqB,IAALxoE;4B,4BAAAA;;;0BAA2B,Y;;;;;;;;;;;;;;;;;;;;;sCR6K/CO,0BAAJ3C,WAAFD;kCAAc,sBAAdA,iBAAM4C;iDAAJ3C;;;4C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BT4UC;;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA,Y;;;;;;;;;;4BAAA,Y;;;;;;;;;;;;;;;;;;;;;;;;;8BAAA,c;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAAA;;;8B;;;;;;;;;;;;;;;;;4BAAA,Y;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA,a;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;;;;;;;mE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA,Y;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA,mB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB4QhcY;;;;;2B;;;;;;;;;;;;;;;;;;;;;;;;uCld1BhBopE;;;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BsM0dI,mB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oDqZ5cG0yQ;iC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BrZ4cH;uC;;;;;;;;;;;0BAAA;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAAA;qC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sCAAA;sC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6CtMxdJzyQ;6C;;;;;;;;;;;;;;;;;;;+CAAAA,oB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BsMwdI,Y;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4CAAA;qD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAAA;0C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB4QhcY;;;;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+B5QgcZ,wB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0CAAA,wB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAAA;;;4C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAAA,wB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAAA;;;sC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA,Y;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAAA;gC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sCAAA,a;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB4QhcY;;;;;sB;;;;;;sBAAA;;;;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0B5QgcZ;;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAAA,Y;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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,YAAL5xB,GAHPnN,KAGG8+B,GAHH9+B;6CAIGguc;gCACT,IAAIC,KAFkB7gc,GAATD,GAEkC,6BAFlCA;gCAEgD,oCADpD6gc,KACLC,KACoB;8BAFe;sEADrBlva;+BACF,uCADPD;8BACO;4BAMlB;;;uDAxDE+ua;6BAwDF;;6EAC0D;0BAF5C,qBADLlR,mBARD38b;0BASM,iDAE4C;uBAvB1D,gBADEqgO;uBACF;;;0BA0BSs8N;;;;;;0BAdPoR;uBAZF;;sB4VZc;uB5VYd;iCAoCO/rB,gBAAiBmsB,YAAa9xZ;0BAE5B,IAAPg5C,KAAO,OAFF2sV,gBAAiBmsB;0BAEf,sB;0BAAA,eAMGnuc;4BAAL,MAAKA,KACc,cADqBvD;4BACtC;mCADGuD,CAEA;0BANZ;;iDAGO,MA5CLqgO,4BAuCAhrI;2BAEF;;;2BAUQ,0BAXFujI,ITmxCY22N,UAWAC;0BSnxCV,eACsC/yb,GAAW,kBAZ3Cmrb,MAY2C,UAAXnrb,GAAsB;0BAD5D;kCAAN6+N;2CACmB7+N,GAAa,4BAZvBgD,EAYUhD,GAAkB;wCAA8B;uBAnDrE,OTsxCEipa;uBStxCF,yBTsxCEA;uBStxCF,STsxCEA;uBStxCF,aTsxCEA;uBStxCF,MTsxCEA;uBStxCF,UTsxCEA;uBStxCF,QTsxCEA;uBStxCF,YTsxCEA;uBStxCF,eTsxCEA;uBStxCF,YTsxCEA;uBStxCF,oBTsxCEA;uBStxCF,STsxCEA;uBStxCF,YTsxCEA;uBStxCF,UTsxCEA;uBStxCF,STsxCEA;uBStxCF,aTsxCEA;uBStxCF,cTsxCEA;uBStxCF,gBTsxCEA;uBStxCF,YTsxCEA;uBStxCF,iBTsxCEA;uBStxCF,kBTsxCEA;uBStxCF,UTsxCEA;uBStxCF,UTsxCEA;uBStxCF,STsxCEA;uBStxCF,gBTsxCEA;uBStxCF,STsxCEA;uBStxCF,mBTsxCEA;uBStxCF,KTsxCEA;uBStxCF,aTsxCEA;uBStxCF,eTsxCEA;uBStxCF,oBTsxCEA;uBStxCF,mBTsxCEA;uBStxCF,wBTsxCEA;uBStxCF,wBTsxCEA;uBStxCF,gBTsxCEA;uBStxCF,gBTsxCEA;uBStxCF,oBTsxCEA;uBStxCF,yBTsxCEA;uBStxCF,YTsxCEA;uBStxCF,QTsxCEA;uBStxCF,mBTsxCEA;uBStxCF,wBTsxCEA;uBStxCF,0BTsxCEA;uBStxCF,YTsxCEA;uBStxCF,yBTsxCEA;uBStxCF,WTsxCEA;uBStxCF,cTsxCEA;uBStxCF,STsxCEA;uBStxCF,aTsxCEA;sBStxCF,QTsxCEA;sBqWlyCY;uB5VYd,eTsxCEA;uBSpsCc;;uBAEH;iDAFT0oC,YACA9/N;uBACS;iCACP7xO;0BACJ,IAAIwB,QTgsCJyna;0BS/rCG,gCADCzna,QADAxB,MAE6B;0BADjC,UAEgC,WT8rChCipa,YSjsCIjpa;0BAGmB,qBT8rCvBipa,mBS9rCqD;uBAEvD,wCANIx0F,SACAm9H;;;;;;;;;;0BAcF;2BAEe7rN;4BAFf,OAlBA8rN;;4BAoBsB;uCAAPh9R;kDwEjKf6M,SxEiKe7M,YAAM;8BAANkxE;;;wDAAoC;sB4VjHvC;;;uB5VwHJ,sB,O4DhBN/7H;uB5DgBM;;uBADC,sB,O4DfPA;uB5DcF,kBT4qCAi/S;uBS5qCA,KOtHE6oC;uBPsHF;iCAIQvuc;0BACR;4BAIA;mCTmqCA0la;6BSnqCA,MTmqCAA;6BSnqCA,MTmqCAA;4BSnqC6C,eAFhC3mY;8BAA4B,qBTqqCzC2mY,mBSrqCa3mY;8BAA4B,kBTqqCzC2mY,mBSxqCQ1la;4BAKR;;;gCTmqCA0la,oBSrsCA4oC;6BAkCA,iBTmqCA5oC;6BSnqCA,iBTmqCAA;4BSnqCA,kBTmqCAA,4BSlqC0D;0BAF5C,qBATP8oC,QAKCxuc;0BAIM,kBToqCd0la,4BSlqC0D;uBAV1D,gBOtHE6oC;uBPsHF;;;0BAeOG;;;;;;0BAlBQD;uBAGf;;0BAsBJ;;;;;iCTspCI/oC;;2BSznCA,aTynCAA,KStpCAtpR,OpEu5BM//F;0BoE13BN,sBA7BJ,YA+CuD;0BAlBnD,eALUr8C;4BAAL,MAAKA,KACc,cADCvD;4BAClB,WT6nCPipa;4BS7nCO,OADG1la,CAEA;0BANZ;4CTkoCE0la,QS/nCK,MOnKH6oC;2BPgKJ;;;;4B,OTsoBoBngB,gB3D6PZ/xY,cgO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Y/pBCtoI;0B5YjDI6uG;4BvCER3xJ,0BwQyPsB33C,e5UnMvB6nM;uB4GwpBI8M;;;;wBxC9sBHh9J,0BwQyPsB33C,e5UnMvB6nM;uB4GwpBIs7B,uBgOrdmBnjO,e5UnMvB6nM;uB0HvBH;;;;;;;;;;;wCd+qBOn2a;kC;0CATLsib;;;2CASKmvB;;;;;;8CiUxgBJ77R;;+CjUwgBI07R;;;;;;;uBc/qBP;;0BAAoEzwB;0B;kCAApE6wB;;;mCAAoE7wB;uEA4BrB;uBA5B/C;;0BAAMgxB;0BAA+BC;;0BAArC;;;;;;4CkN0N0BvjO,cuFvKxBn6D;gD,O/VlFN8xG;gD,OuCFA4xJ;;+CiO2P8BvpM,cuFvKxBn6D;mCvTonBO+9R;4B,OxCtsBbjsL;0BwCqsBM;2BAAO6xJ,6BgO5ciBxpM,cuFvKxBn6D;2BvTmnBA,KctqBF69R;2BdsqBE,KctqBFA;2Bd8aE,KAwPArpU;2BAxPA,KAwPAA;2BAxPA,KAwPAA;2BAvbE,KA+LFH;2BA/LE,KA+LFA;2BA/LE,KA+LFA;2BAtaI,KAuOF8B;2BAvOE,KAuOFA;2BAvOE,KAuOFA;2BAvOE,KAuOFA;2BAvOE,KAuOFA;2BAvOE,KAuOFA;2BAvOE;;;;4DA8pBGwtS,kBA9pBH66B;;;4DA8pBG76B,kBA9pBHtnJ;;;;;;;;8BnFuHdn5G,kBmFwiBiB66R,yBA/pBHO;2B5DqJR,G4DrJQD;2B5DqJR,G4DrJQA;2B5DqJR,G4DrJQA;2B5DqJR,G4DrJQA;2B5DqJR,G4DrJQA;2B5DqJR,G4DrJQA;2B5DqJR,G4DrJQA;2B5DqJR,G4DrJQA;2B5DqJR;;;;;;;2B4DkFM;;;;;;gCAvOEpzN;gC5DqJR;2B4DkFM;0D2Y/NJ2pF,oB3Y+NIwpI;2BA+LF;;;;8BA/LE;2BA+LF;2BAwPA;;;;8BAxPA;;;2Cc9aIX,+Bd8aJQ;2Bc9aF;;;;8BdsqBE;;;2CctqBmCP,+BdsqBnCM;2BctqBF;mC1E6hCQU;4B,OvB95BhB19R;0BuB85BM;;gC0E7hCE48R;2B1E6hCF,K0E7hCEA;2B1E6hCF;mCAnCYe;;6BAoCUttZ;;0DADZqtZ,kBACYttZ;8DADZstZ,kBACYrtZ;0BA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DHpJJ5gB,eGgJM2gB;;6BAKAE,iCADFD;6BAEEE;;;;gCADAD;;;2CACAvvW;8B;uC6X/JN03H;gD7X+JM13H;yC,OfrNNw7T;2DeqNMx7T;oD,OtDnNNwpK,2BsDmNMxpK;;;;;;6BApJNyvW;;qEAoJMD;mCARNr1d;qC1Ei3BEu1d,oB0E7+B8B1vW;8B,OA/EhC+8H,gCA+EgC/8H;;qC1E08B5B2vW,kBAoCoB3vW;;;;qCADtB0vW,oBACsB1vW;qCADtB0vW,oBACsB3nT;;;;6BAATv/F;;qD0E9/BfinZ,O1E8/BevlM;6BAxtBb8P,wBAwtBaK;;6BAxtBba;yCuctUFnkD,evc0/BI44O,kBAprBF31L;;yCuctUFjjD,evc0/BI44O,kBAprBFz0L;mCAorBEy0L,kBAprBFx0L;;yC4RPAtnD,e5R2rBE87O,kBAprBFv0L;oCAorBEu0L,kBAprBFt0L;oCAorBEs0L,kBAprBFr0L;oCAorBEq0L,kBAprBFp0L;oCAorBEo0L,kBAprBFn0L;oCAorBEm0L,kBAprBFl0L;oCAorBEk0L,kBAprBFj0L;;;gCwJyNAjkL,iBxJ2dEk4W,kBAprBFh0L;;;gCwJyNAlkL,iBxJ2dEk4W,kBAprBF/zL;;;gCwJyNAnkL,iBxJ2dEk4W,kBAprBF9zL;;;gCwJyNApkL,iBxJ2dEk4W,kBAprBF7zL;;;gCwJyNArkL,iBxJ2dEk4W,kBAprBF5zL;;;gCwJyNAtkL,iBxJ2dEk4W,kBAprBF3zL;;;gCwJyNAvkL,iBxJ2dEk4W,kBAprBF1zL;;;gCwJyNAxkL,iBxJ2dEk4W,kBAprBFzzL;;;;gC4RPAxpD;yC5R0BoB1yH;kC;2CwJsMpBvI,iBxJ2dEk4W,kBAjqBkB3vW;gCAnBpBu6K;;;;gCwJyNA9iL,iBxJ2dEk4W,kBAprBFn1L;;;gCwJyNA/iL,iBxJ2dEk4W,kBAprBFl1L;;;gCwJyNAhjL,iBxJ2dEk4W,kBAprBFj1L;;;gCwJyNAjjL,iBxJ2dEk4W,kBAprBFh1L;;;gCwJyNAljL,iBxJ2dEk4W,kBAprBFz1L;6BAutBAE;;gCwJ9fA3iL,iBxJ2dEk4W,kBAprBFx1L;6B0EtSFy1L,wB1E6/BEx1L;mC0Ej3BFjgS;;;6BP/LE01d;;gCoYmBF94O;yCpYhBS/2H;;;;;;;gCOgDT4vW;;;6BP7CQjnZ;;+DANNknZ,OAMMC;6BANNE,kCAMMD;;6BAgKRE;;gCyN4KEp7O;yCzN1UO70H;;;;;;;gCARPgwW;;;;6BA0CAE;;gCoYvBFn5O;yCpY0BS/2H;;;;;;;gCAyHTiwW;;;6BA5HEE;;gCoYvBFp5O;yCpY6BS/2H;;;;;;;gCANPkwW;;;6BAQQrnZ;;+DARRsnZ,OAQQC;6BARRE,kCAQQD;;6BARRE;;gCyNwSA18O;yCzN9RO7zH;;;;;;;gCAVPswW;;;6BAaM/nZ;;+DAbNgoZ,OAaMC;6BAbNE,kCAaMD;;6BAEAE;;+DAfND,OAeME;6BAfNE,kCAeMD;;6BAEAE;;+DAjBND,OAiBME;6BAjBNE,kCAiBMD;;6BAEAE;;+DAnBND,OAmBME;6BAnBNE,kCAmBMD;;6BAEAE;;+DArBND,OAqBME;6BArBNE,kCAqBMD;;6BAEAE;;+DAvBND,OAuBME;6BAqGRE,kCArGQD;6BnEgiCJE,kCmE37BJD;;;qCnE27BIx3L,YmEt7BIt6K;;;;;;;;;6BnEs7BJgyW;8B0E7mCJj1O;yC1E8mCc/8H;;;;yCADVs6K,YACUt6K;yCADVs6K,YACUvyH;;gCADVgqT;;;;;;mC0El6BJptY;4B,IAAAq7B,IqI9BEpH;oErI8BFI,mBAa+C;mCAb/Cv5C;4BA7HM,GA6HN2yZ,gBA7HM;sCA6HNC,SA7HM,MA6HND;4BdyhBY;;;;8BA3PA;;;;gCArME;;;;;;;6Cc/NN9I;sCAAqB;wDAArBE;4FAAoB;+CAApBF;qDd6NyB;mCAEnB;6CchONF;iFd6NkB;kCAhPJ;;;;;;;sCACD;;wCACC;;0CACD;;4CAC4B;;;;;yDAAlB5tO;0FAAiB;;;4CAAC;;8C5DwI5B;;;;;kDACA;;oDACK;;sDACA;;wDACd;;0DACA;;4DACG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCqJuUX;kCzFtOU;;oCcxNN;;;;;iDADAgvO;0CAAwC;4DAAxCE;qDAAqB;uEAArBE;2GAAoB;8DAApBF;oEAAuC;mDAAvCF;yDAA+D;;;;+CAE/D;;;;;;gCd4ZI;;kCchaJ;;;oCdsUoC;;;sCcnMtC;;uCAGA;;;;kD6XhLNx9L;2CAAe;oD3KiUbh2C;6DrNlSAz9D;sDAAwC;wEAAxCG;iEAAqB;mFAArBE;uHAAoB;0EAApBF;gFAAuC;+DAAvCH;qEgY/BY;oDAAdyzG;0D7X+KQ;8CACF;;;;;;;;;;;gCH7LY;;;kCG+LZ;;oCACoB;;;;+CAApBslM;kFAAmB;qCAAC;;;qCAGpB;;;;gDAFAE;yCACA;2DADAE;oDAAwC;sEAAxCE;+DAAqB;iFAArBE;qHAAoB;wEAApBF;8EAAuC;6DAAvCF;mEAA+D;kDAA/DF;wDACa;;uCACb;;;;;;;;;;;qCAVNH;;+B1Ei3BEvK;yC0E7+B8BkL;kCAAa;oDAAbE;2FAAY;2CAAZF;iDAAkB;+B1E6+BhD15O;yC0E7+BgB85O;gFAAY;8B1E8+Be;;;;gCAnCtB;;;;;;mCAmCR;;;;;+CADb95O,MACag6O;;;;;qCAxtBb/jV;+CAwtBsBmkV;;;;;;;qDADtB5L,YACsB8L,kBAnCmB;oCAprB9B;;;;;;;;0C4RNX58O;mD5RMQo8O,sCAAE;;;;sCAAC;wCACW;;;;;4C4RPtBp8O;qD5ROmBg8O,sCAAE;;;wCAAC;0CACd;;4CACG;;;;;gD4RTXl/O;yD5RSQo/O,sCAAE;;;4CAAC;8CACY;;gDACC;;kDACI;;oDACT;;sDACC;;wDACU;;0DACC;;;;;uEAAH/M,sCAAE;;;0DAAC;4DACA;;;;;yEAAH6N,sCAAE;;;4DAAC;8DACK;;;;;2EAAHE,sCAAE;;;8DAAC;gEACA;;;;;6EAAHE,sCAAE;;;gEAAC;kEACd;;;;;+EAAHE,sCAAE;;;kEAAC;oEACA;;;;;iFAAHE,sCAAE;;;oEAAC;sEACM;;;;;mFAAHE,sCAAE;;;sEAAC;wEACN;;;;;qFAAH32B,sCAAE;;;wEAAC;0EACQ;;;;;8E4RxB9BprN;uF5RwBoB00O;gFAAG;kGAAHuN,sCAAE;yFAAFvN;+FAAS;;;0EAAC;4EACA;;;;;yFAAHhpB,sCAAE;;;4EAAC;8EACS;;;;;2FAAHmpB,sCAAE;;;8EAAC;gFACV;;;;;6FAAHE,sCAAE;;;gFAAC;kFACQ;;;;;+FAAHE,sCAAE;;;kFAAC;oFACA;;;;;iGAAHwK,sCAAE;;;oFAAC;;;;;wFvB/N3C53S;mGuBgO8CukR,sCAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCA+rBC,gBAD3CzlN;;0C0Ej3BF+4O;gCPxBkB;;gCAnKV;;;;;;;;sCyNgVNr7O;+CzNjVO0gD;;;;;;;kGAA+D;;;;kCAChE;oCAEA;;;;;;;;iDAAiC,2BAAjCw9L;oCAA+D;;;;;;yCyN8UrEpgP;kDzN5UO0jD;;;;;;;qGAA+D;;;;;;;;;;kCAsChE;;;;;;;;wCyNsSNxhD;iDzNvSO0+O;;;;;;;oGAA+D;;;;oCAChE;sCAGA;;;;;0CyNmSN1+O;mDzNpSOg/O;;;;;;;sGAA+D;;;sCAChE;wCACE;;;;;;;;qDAAiC,2BAAjCM;wCAA+D;0CAGjE;;;;;8CyN+RNxiP;uDzNhSO4iP;;;;;;;0GAA+D;;;0CAChE;4CAEA;;;;;;;;yDAAiC,2BAAjCE;4CAA+D;8CAE/D;;;;;;;;2DAAiC,2BAAjC9N;8CAA+D;gDAE/D;;;;;;;;6DAAiC,2BAAjCkO;gDAA+D;kDAE/D;;;;;;;;+DAAiC,2BAAjCI;kDAA+D;oDAE/D;;;;;;;;iEAAiC,2BAAjCxD;oDAA+D;sDAE/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAwGO;;;;;uCnEw7BXj+L;iDmEr7BIiiM;wFAA8B;uCnEq7BlCznO;iDmEt7BIylC;;;;;;;oGAA+D;sCnEu7BhD;;;;;;mDAATmrK;;;;;;;yDADV5wM,MACU8wM,kBAAO;;;sCAAE;wCACT;;0CACA;;4CACE;4DAJZ9wM;4CAIY;;;;;;;;oCmE57BD;;;;;gCAHf;;;;wCOqCa;;;;6BAZbthB;;;;;;;;;mCAkBEojO;4BAEA;6BAFWz6c;;6BAEX,YACE,UAHSA;6BAEX,MAFWA;6BAEX,MAFWA;6BAEX,MAFWA;6BAEX,MAFWA;6BAkBD,gBAlBCA,WACTujO;6BAaQ,gBAdCvjO,WACTujO;4BAaQ;mCAWVq3O,QAASv8c;4BAET;6CAFSA;6BAET;6BAKA,kBAPSA;6BAOT;6BAME,gBAPUotb;4BAKZ,OACE,UAXU5zL;4BAUZ;;;sCAXSx5P;;;uCACGw5P;uCAKA4zL;qCANHptb;2CAyBR;mCAEDivG,UAAQrjC,GAAGF;4BAA+B,kBAA/BA,IAAkB,cAArBE;4BAAqB,sCAAyB;mCAEtD02J,QAAM12J,GAAGF;4BAA6B,kBAA7BA,IAAgB,cAAnBE;4BAAmB,sCAAyB;mCAElD2zG,cAAY5gL,EAAEgD;4BAAuB,kBAAvBA,GAAuB,0BAAzBhD,QAAoC;mCAEhDswF,OAAKttF;4BAAc,kBAAdA,GAAc,gCAAW;;sEA1D9By6c,QAyBAG;;;mCA8CArf,UAAUv7b;4BAED,IAAPm5G,KAAO,uBAFCn5G;4BAIM,sCAFdm5G,MAEmC;mCAErCqiV,UAAUC;4BACN,2BADMA;4BACN;8BACI,IAALz7b;8BAAK;gCACC,oCAAW,aADjBA;gCAEW;oCAAPq4B;+DAAa,sBAAbA;4BAHH,qBAIQr7B;wCACH;mCAETwje,eAAe/je;4BAAmB,kBAAnBA,GAAmB,gCAAW;mCAE7C47O,YAAU57O,GAAY,+BAAZA,GAAyB;mCAEnC67O;4B;8BAEE,IADM77O,WACN,iBADMA;4BAGN,YAA+D;;;;;kCA7FjEg+c;kCAyBAG;kCA2BAttW;kCAEAqzH;kCAEA/iD;kCAEAtwF;;;kCAaAiuW;kCAMAC;kCAQAglC;kCAEAnoP;kCAEAC;uBAvRE;;4C;;;0B8PmGJ+oB;0B+HnFY4yE;4B5YjDI6uG;8BvCER3xJ,0BwQyPsB33C,e5UnMvB6nM;uB0HvBH;wC8PmGJhgL;;;2B,OjQzHsDu0M,gB9FqJ1DnyR;;wCmT2FkC+1D,erNvMrBq9N;;;wC,OXsViChsB;uBclEtC;;;;;;;4C,OAvSoEgyB;;uBAuSpE;uBAkB+C;wC,UAlB/C4jB;uBAkB+C;iCAlB/Czhe;0B,qBkN7E0By6O,cuFvKxBn6D;gD,O/VlFN8xG;gD,OuCFA4xJ;;;;8B6QoIA1hL;8C,O+HnFI4yE;4C/HmFJ5yE;;4B,OjQzHEw0M;;4CqNgP4Br8N,cpO9LrBxmE;;iCkB5BL6pS;mD,OdyWEhyB;;mCclEF9rb;uBAkB+C;iCAlB/C4a;0B,qBkN7E0B8/N,euFvKxBn6D;;4B,O/VlFN8xG;;4B,OuCFA6xJ;;;;8B6QoIA3hL;;gC,O+HnFI4yE;4C/HmFJ5yE;;4B,OjQzHE20M;;;4CqNgP4Bx8N,epO9LrBxmE;;iCkB5BL8tS;;qC,OdyWE/1B;;mCclEFrxa;;qCAkB+C;;iCAD7CA;0B,qBkN9FwB+/N,cuFvKxBn6D;;4B,O/VlFN8xG;;4B,OuCFA8xJ;;;;8B6QoIA5hL;;gC,O+HnFI4yE;4C/HmFJ5yE;;4B,OjQzHE80M;;4CqNgP4B38N,crNvM1Bm9N;;iCGnBAwK;;qC,OdyWEl2B;;mCcjDAxxa;;;uBAC6C;iCAlB/CA;0B,qBkN7E0B+/N,cuFvKxBn6D;;4B,O/VlFN8xG;;4B,OuCFA8xJ;;;;8B6QoIA5hL;;gC,O+HnFI4yE;4C/HmFJ5yE;;4B,OjQzHE80M;;4CqNgP4B38N,crNvM1Bm9N;;iCGnBA2K;;qC,OdyWEr2B;;mCclEFxxa;2CAkB+C;uBAlB/C;uCAAK8md;sBuV5PO;uBvV4PZ;;;;;;;;;;;;gCAuCWe;uBAvCX;;yBAAKf;yBAALC;;;;mD;uBAAA;;;;;;;;uBAmCF;;sBuV/Rc;uBvV+Rd;;;;;;;;;;;4C;;wBlBzRUnhD;0B+YjCAvrG;4B5YjDI6uG;8BvCER3xJ,0BwQyPsB33C,e5UnMvB6nM;uB0HmTL;6BlBzRU7B;;;2B,OevE0Co2B,gB9FqJ1DnyR;;6B+EnGgB47P,gBeTHw3B;;;wC,OXsViChsB;uBcGtC;;;;;;;4C,OA5WoEgyB;;uBA4WpE;uBAmB+C;wC,UAnB/CwlB;uBAmB+C;iCAnB/Crje;0B,qBkNlJ0By6O,cuFvKxBn6D;gD,O/VlFN8xG;gD,OuCFA4xJ;gD,O4YiDI9uG;gD,O/YiCAurG;;gD,OAAAA;;4B,OevEFq2B;yCfkDE92c;4B,kBoO8L0By6O,cpO9LrBxmE,UAALj0K;;iCkB5BA89c;mD,OdyWEhyB;;mCcGF9rb;uBAmB+C;iCAnB/C4a;0B,qBkNlJ0B8/N,euFvKxBn6D;;4B,O/VlFN8xG;;4B,OuCFA6xJ;;4B,O4YiDI/uG;;4B,O/YiCAurG;;;4B,OAAAA;;4B,OevEFw2B;;yCfkDEt8b;4B;gDoO8L0B8/N,epO9LrBxmE,SAALt5J;;iCkB5BAonc;;qC,OdyWE/1B;;mCcGFrxa;;qCAmB+C;;iCAD7CA;0B,qBkNpKwB+/N,cuFvKxBn6D;;4B,O/VlFN8xG;;4B,OuCFA8xJ;;4B,O4YiDIhvG;;4B,O/YiCAurG;;;4B,OAAAA;;4B,OevEF22B;;4B,OfkDEh3B,ceTAw3B;;iCGnBAwK;;qC,OdyWEl2B;;mCcqBAxxa;;;uBAC6C;iCAnB/CA;0B,qBkNlJ0B+/N,cuFvKxBn6D;;4B,O/VlFN8xG;;4B,OuCFA8xJ;;4B,O4YiDIhvG;;4B,O/YiCAurG;;;4B,OAAAA;;4B,OevEF22B;;4B,OfkDEh3B,ceTAw3B;;iCGnBA2K;;qC,OdyWEr2B;;mCcGFxxa;2CAmB+C;uBAnB/C;uCAAK0od;sBuVjUO;uBvViUZ;;;;;;;;;;;;;gCAwCWe;uBAxCX;;yBAAKf;yBAALC;;;;mD;uBAAA;;;;;;;;uBAoCF;;sBuVrWc;uBvVqWd;;;;;;;;;;sBAoBH;;sB7G7bGxwV;sBI4HFwV;sBgcxDgB;;;;;;;;;;;;;;;;;;;;;;;;;;;sBhcuDhBD;sBJ5HExV;sBuqBVN;;sBnO+EoB;uBmO/EpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAMI;;0BhoBoBEiwH;mCgoBpByB/kQ;4BAGN,IAJTsC,EAIS,aAHMtC;4BAGf,eAJExC;8BAAkB;mDAAC,iBAArB8E,EAAE9E,G1mB+KG6wN;;4B0mB5KX;oEACsC;sBAAG;;sBvqBE7Ct5E;sBI4HFwV;sBADAD;sBJ5HExV;sB8GVN;;sBsV+EoB;uBtVvEhB2xV;wBACa,OvEiBX1hO;sBuERA;;;;;;;;;;;;;;;;sBsV6Dc;uBtV1DR;iCAM+Bc;0BACzB,IAAZy0M,UAAY,sCADyBz0M;0BAGzB;uEAFZy0M,WAEwC;uBATlC;;;;;;;;;;;;;;;;;;uBAgBC;uBAII,uBAjCbmsB,yBfy2CI/9D;uBex0CS;;gCAsBL89D;uBAtBK;wC,afw0CT99D;uBex0CS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BA8BT/7W;2BA5CJ+5a;uBAca;;;;;;;;;;;;;;0B;;sCfw0CTh+D;;;;mCelzCI89D,SAuBqB;sBsVPb;;;uBtVgCJ,kBtDoEVxwM,cAtGAuiD;uBsDkCU;kCfkwCRmwF;uBelwCQ,OfkwCRA;uBelwCQ,KfkwCRA;uBelwCQ,QfkwCRA;uBelwCQ,SfkwCRA;uBelwCQ,UfkwCRA;uBelwCQ,WfkwCRA;uBelwCQ,WfkwCRA;uBelwCQ,WfkwCRA;uBelwCQ;iCAcGjpa;0BAAsB;mCAHSyne,QAG/Bzne,EAAsB,WfovCjCipa,+BepvC4C;uBAdpC,SfkwCRA;uBelwCQ,SfkwCRA;uBelwCQ,UfkwCRA;uBelwCQ,WfkwCRA;uBelwCQ,WfkwCRA;uBelwCQ,WfkwCRA;uBelwCQ;iCA0BQjpa,EAAEzB,GAAI,kBfwuCtB0qa,WexuCgBjpa,EAAEzB,EAA0B;uBA1BpC;iCA4BMyB,EAAEzB,EAAE8iC,GAAI,kBfsuCtB4nY,WetuCcjpa,EAAEzB,EAAE8iC,EAA0B;uBA5BpC;;;;iCAmCC99B,EAAQvD;0BACA;mCtDgCnBu2R;mCsDhCmB,WtD1EVtkF,QsD0EiB,WtDuC1BukF,UsDxCWjzR,GAAQvD,GACwB;uBApCjC;;0BAsC2B,kBtD8BrCu2R,csD9BqC,WtD5E5Bv2L,UsD4EwC;uBAtCvC,WfkwCRipU;uBelwCQ;iCA0CAz7V,GAAGF;0BACX,SAAI3jE;4B,IAAS3J;8CfutCbipa,8BevtCajpa;0BACV,WAFKwtE,IAEW,OAFRF;0BAGH,WAHGA,IAGa,OAHhBE;0BAKoB;4CtD4B9BgpN,UsDjCalpN;2BAKE,atDyCfyrQ,WsDzCe,WtD4BfviD,UsDjCUhpN;0BAKK;4BACP,qBtDoBR+oN,csDrBQ30R,GAC4B;8CARhCgne,QAQoC;uBAhD9B;iCAkDC5oe;0BAAyB;mCtDkBpCu2R,csDlBoC,WtDxF3BnkP,OsDwFmC,WtDyB5CokP,UsDzBWx2R,IAAgD;uBAlDjD,gCAkDS,YAAwC;uBAlDjD,4B;uBAAA;;;2BfkwCRipa;;4BevvCI4+D;4BAAOD;4BAAOD;4BAAOD;4BAGrBI;4BAH8Bt0P;4BAAeg0P;4BAAPC;;6BAWtCW;6BAAOD;6BAAOD;6BA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C;;;;;;;;;;;;;;kCzEhEEw0O;kCAEA9jT;;;;;;kCA+OA+zT;kCAQAE;uBAtSN;;2B;;;;;;;uBAAA;;;sBA8lF6C;;sBpCtlFvC35W;sBI4HFwV;sBADAD;sBJ5HExV;sB4rBTN;;sBxP8EoB;uBwP9EhB48W;;;2BAIK;;;;;8CjDkIPt3E;;4BiDlIYrrQ,eAALxuB;+CAC6C3jI;6BjDiIpD,sCiDjIoD2nI;oCAD7CorB;;;8BjDmIH,qBiDnIG/yJ;8BjDoIH,4BiDpIGA;8BjD0GO,qBiD1GPA;8BjD0Ge,qBiD1GfA;8BjD0Ge,sBAARwxO,IAAQyjQ;8BA4BlB,2BiDtIGj1e;8BjD8HO,qBiD9HPA;8BjD8He,qBiD9HfA;8BjD8He,UAARo1e,IAAQC;;qCAKlBN;qCACAC;qCACAE;qCACAC;qCACAG,OiDrIkC;+BAF/BtiV;;6BjDkIP;;iCiDlIO5tK;8BjDkIP,GiDlIOA;8BjDkIP,GiDlIOA;8BjDkIP,KiDlIOA;8BjDkIP,KiDlIOA;8BjDkIP;;8BAxBA,GAwBAgyN;8BAxBA,GAwBAA;8BAxBA;8BAwBA;;;;iCAxBA;8BAwBA;8BAJA,KAIAy4B;8BAJA,KAIAA;8BAJA;;;sCAIAI;sCAJA;oCiD9HOt9E;;;8BjDkIP,GiDlIOvtK;8BjDkIP,GiDlIOA;8BjDkIP,GiDlIOA;8BjDkIP,KiDlIOA;8BjDkIP,KiDlIOA;8BjDkIP,uBiDlIO4a,UjDkIPo6H;qDiDlIOp6H,IjDkIPsjC;8BAxBA,GAwBA8zK;8BAxBA,GAwBAA;8BAxBA,qBiD1GOp3M,IjD0GPyjC;qDiD1GOzjC,IjD0GP9F;8BAwBA,uBiDlIO8F,IjDkIPshC;8BAJA,KAIAuuM;8BAJA,KAIAA;8BAJA,uBiD9HO7vO,IjD8HPwjC;qDiD9HOxjC,IjD8HP0hC,WiD5HsC;;4BAF/BkxH;qCAAKT,YAALS;;;;;;;qCAAKT;qCAALS;;;0CAE+B;sBAGi0B;;sB5rBCn2Bz6B;sBI4HFwV;sBADAD;sBJ5HExV;sB6rBVN;;sBAAS,wBnDcLuoE;sBmDZK,sBnDYLA;sBtMiEgB;uByP7EX;;0BAMmB,uBDPxBq0S;0BCOwB;mCDPxBA;iDvfyB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uBAHxC;;;;;;4C7hB6FEo8D,e6hB7FFnlK;;;;0DAGwC;uBAHxC;;mEAEInd,KAAYq4e,UACwB;uBAHxC;;;oCAEIr4e,EAAYq4e,OACwB;sBAG3C;sBtlBhBH;sB+U6EoB;uB/U7EpB;iCAKW95e;0BAAqB,uCAArBA;0BAAqB,4CAAe;uBAS7C;;;mCAA0DyB;4BACtD,eACQzB,GACR,UAHsDyB,EAE9CzB,EACF;4BADM,qB7DyLZk4R,O6D3LsDz2R;4BAE1C,iDACN;uBAHV;uBAeM;;;;;;;4C,OslBnBsB89f,8B3S+LnBz5U;;uB3S5KH;uBAA8D;wC,UAA9Ds6U;;uCAAKC;sB+UgDO;uB/UhDkD;uBAA9D;;;;;;;;4C,OslBnBFruN;8B3S+LKlsH;;uB3S5KH;uBAA8D;wC,UAA9D06U;;;;;;;;;yCzGoIRn6U,2ByGpIao6U;;uBAAL;uBAA8D;wC,UAA9DC;uBAA8D,mBAA9D17f,iBAA8D;;iCAA9D4Z;;mDyD0EAolK,czD1EAplK;6BslBnBFghf,e/iBmBE9G,oBvCAAl6e;;;0BAA8D,OAA9D5Z,CAA8D;;iCAA9D4Z;;;;;;;0BAA8D,OAA9D5Z,CAA8D;0CAA9D67f;uBAA8D;iCAA9D77f;;;;;mEyD0EA8+K,czD1EApuH;;mDslBnBFqqc,c/iBkBAnH,mBvCCEjjc,IAA8D;;iCAA9D/2C;;;;;0CyD0EAmlK,ezD1EAnlK;iCslBnBFohf,e/iBkBAnH,oBvCCEj6e,WAA8D;0CAA9Doif;uBAA8D,YAA9DL;uBAA8D;uBAchE;;;;;;;4C,OslBjCwBpB,8B3S+LnBz5U;;uB3S9JL;uBAuBG,mB,UAvBHs7U;uBAuBG;iCAtBDvzb;0BslBlCF;8BtlBkCEA;2BslBlCF,GtlBkCEA;2BslBlCF,wC/iBkBA+qb,c+iBlBAljc;;uBtlBwDG;iCslBxDH92C,UtlBkCEivD;0BslBlCF;8BtlBkCEA;2BslBlCF,GtlBkCEA;2BslBlCF,e/iBkBAgrb,e+iBlBAj6e;4DtlBmCmC;uBAqBhC,mB2C4IIyif;uB3C5IJ;iCAtB6Czif,IslBlChD2nI,QtlBkCgDmrB;0BslBlChD;uBtlBwDG;iCslBxDH9yJ;0BA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;uB7SrEhB;;;;uESiNOg5J;;uBTjNP;uBAE+C;wC,UAF/CwiR;;uCAAKC;sB6SqEW;uB7SrEhB;;;;;;;6DGiDI5vD;;uBHjDJ;uBAE+C;wC,UAF/C8vD;;;;;;;;uC3IyJJpsY,2B2IzJSqsY;;sB6SqEW;uB7S3DhB;;;;;;;;;yDSuMO5iR;;;uBTvMP;uBAK+C;wC,UAL/C6iR;;uCAAKC;sB6S2DW;uB7S3DhB;;;;;;;;;;;;+CGuCIjwD;;;;uBHvCJ;uBAK+C;wC,UAL/CmwD;;;;;;;;;yC3I+IJzsY,2B2I/IS0sY;;uBAAL;uBAK+C;wC,UAL/CC;uBAK+C,oBAL/ChujB,iBAK+C;uBAcjD,qBSoSEm5J,iBTpSyDx6J,GACvD,UADuDA,EACtB;sBAAE;sBvJ7BnCozI;sBADAD;sBwJRN;sB4S6EoB;uB5S7EpB;;0BAMM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+EA8CyD;uBA9CzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gG5I2JNuvC;;uB4I3JM;uBA8CyD;wC,UA9CzDgtY;uBA8CyD;iCA9CzDl1c;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BgCugBE;qChCvgBF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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UAR/C+C;;;;;;;;;yC9IyENz7Y,2B8IzEW07Y;;uBAAL;uBAQ+C;wC,UAR/CC;uBAQ+C,oBAR/Ch9jB,iBAQ+C;;;iCAwBtCssjB;0BACT,GADSA;4BAEP;;;;0BAIA;;;wEAC+B;uBAR/B6Q;sDYoiDAvna;;;;;;;2BZpiDAvuI;2BADA6yiB;2BADAN;2BADAO;2BADIn7C;wCACJm7C,aACAP,MACAM,YACA7yiB;;;2DMkNJ8xI;;uBNxNEika;sBA6BF;;wCrCnCEj/D;wBqCrEE87D;;;;sB0SuCY;uB1S6Gd;;;;;;;;;0CPtJGna;6CI5BAyN;;uBGkLH;uBAGqD;wC,UAHrD8P;uBAGqD;;0BAHrD;;;6BP/KA,GO+KArpb;6BP/KA,GO+KAA;;6BP/KA;;;;;0BO+KA,kBHlLF,KGkLEG;;gDHlLF,0CGqLuD;;iCAHrDv6H;;;;;6BP/KA,GO+KAo6H;6BP/KA,GO+KAA;6BPtJF;6BAzBE,aO+KAp6H,IPtJFsjC,MAzBEwT;oDO+KA92C,IP/KA9F;0BO+KA;;;2BHlLF,KGkLEqgI;2BHlLF,yBGkLEv6H,IHlLFyjC;0CGkLEzjC,IHlLFshC,WGqLuD;;iCAHrDthC;;;4BPtJF;;6BArBM,oBO2KJA;6BP3K+B,0BO2K/BA;6BP3K+B,SAA3B8jjB,cAA2BC;sCO2K/B9tZ;;4BHlLF,4BGkLEj2J;4BHlLF;6BACsB;mDGiLpBA;yCHjLoBgkjB;;iCGiLpB3xW,QHlLF,uBGkLE1qE;;mEAGqD;;iCAHrDpoC;;;;;;;;;;;;4B8BmVE,c9BnVF;;;;;;;;;;;;;;;;;;;;kCHlLF,SGkLE/5G;;;;;;;2DHlLF,2BGkLEA;;;;;;;;;;;;;0CHlLF;;;;;;;;;;;;;;;;;;;;;uDACsB;mFADtBq8P;;;;0EACsBlnE,aADtB93L;;8DACsB83L,aADtB,sCGkLEn1L;yDHjLoB;;sDADtB;;;;;8CGkLEsjH;+CHlLF,mDGkLEtjH;;6CHlLF;kDGkLEsjH,KHlLF,0CGkLEtjH;;+CHlLF,UACsB0+jB;+CADtB;gFGkLEp7c,QHjLoBq7c;;;iDGiLpBr7c;kDHlLF;;oDGkLEtjH;gEHjLoB0+jB;;;2CGiLpBp7c,KHlLF,mCGkLEtjH;;8CHlLF,kCGkLEA;uDHlLF,2BGkLEA;;;;;;;gCP/KA,SO+KA02I;0CP/KA,oCO+KAA;;kCP/KA;+CO+KAA;mCP/KA;;;;;;;;;;;;;;;;;;;;;;;;;iGO+KAA,KP1KsD;yDALtDZ;;;;;;gDAII;0EAJJF;;kDAII;;;;;+CAA2B;yEAJ/BA;;iDAI+B;;;;8CAJ/B;;;;;sCO+KAe;uCP/KA,iDO+KAD;;qCP/KA;0CO+KAC,KP/KA,wCO+KAD;;uCP/KA;8CAIIkob;wCAJJ,MAI+BC;;;;;yCAA3BE;yCO2KJpob,QP3KIoob,kBAA2BD;;;;;yCO2K/Bnob;0CP/KA;;4CO+KAD;;sDP3KIkob;yDAA2BC;;0CO2K/Blob;;iEAGqD;;;0BAHrD;4BACE;;6BPhLF,SOgLED;6BPhLF,cOgLEA;6BP5K6B;;6BAA3B;iEAA2BK;6BAA3B;kDO4KF/2I;0BACA;;2BHpLJ,eGoLI22I;2BHnLkB;;;gDGmLlBrzB,SACmD;;iCAHrD6tD;0B,SAAA5tK;4BACE;gCADFA;6BACE,iCADF4tK;;6BP/KA/nD,eawOA60Y,eb/MF1qO,MOuJIzwC;oDPhLF15H,IOgLE05H;0BACA,SAFFv/O,OAEE,iCAFF4tK;4CMyDA8sV,eT1OAh6N,MGmLE2nC;uBAFF;uCAAKsyP;sB0S7GS;uB1SwHd;;;;;;;;;0CPvJGrd;6CI5BA2N;;uBGmLH;uBAMqD;wC,UANrD2Q;uBAMqD;;0BANrD;;;6BP/KA,GO+KAvqb;6BP/KA,GO+KAA;6BP/KA,GO+KAA;6BP/KA,GO+KAA;;6BP/KA;;;sEqlBPF6oa,crlBOE7rV;;;;;0BO+KA;;2BHnLF,KGmLE78E;2BHnLF,KGmLEA;2BHnLF;;;;kFGyLuD;;iCANrDv6H;;;;;6BP/KA,GO+KAo6H;6BP/KA,GO+KAA;6BP/KA,GO+KAA;6BP/KA,GO+KAA;6BPvJF;6BAxBE,aO+KAp6H,IPvJF2lC,MAxBEmR;4CO+KA92C,IP/KA9F;8CqlBPFgpiB,e9kBsLEljiB,IP/KAshC;oDO+KAthC,IP/KA0hC;0BO+KA;;;2BHnLF,KGmLE64F;2BHnLF,KGmLEA;2BHnLF,yBGmLEv6H,IHnLFqmC;0CGmLErmC,IHnLFsjC;0CGmLEtjC,IHnLFyjC,WGyLuD;;iCANrDzjC;;;4BPvJF;;6BAvBM,kBO8KJA;6BP7KI,oBO6KJA;6BP5KI,sBqlBVNmjiB,e9kBsLEnjiB;6BP3KI,0BO2KJA;6BP3KI,SAHAgljB,YACAlB,cACAmB,WACAlB;sCO2KJ9tZ;;4BHnLF,4BGmLEj2J;4BHnLF;6BAEQ;gDGiLNA;8BHhLM,qBGgLNA;yCHjLMkljB,YACAlB;;iCGgLN3xW,QHnLF,uBGmLE1qE;;mEAMqD;;iCANrDpoC;;;;;;;;;;;;4B8BwUE,c9BxUF;;;;;;;;;;;;;;;;;;;;kCHnLF,SGmLE/5G;;;;;;;2DHnLF,2BGmLEA;;;;;;;;;;;;;0CHnLF;;;;;;;;;;;;;;;;;;;;;;;;;;;yGGmLEA,GH9K6C;iEAL/C81I;;;;;;wDAGQ;oFAHRumH;;0DAGQ;;;;;uDADA;mFAFRA;;yDAEQ;;;;sDAFR;;;;;8CGmLE/4I;+CHnLF,mDGmLEtjH;;6CHnLF;kDGmLEsjH,KHnLF,0CGmLEtjH;;+CHnLF;sDAEQ4/jB;gDAFR,MAGQlB;;;;;iDADAmB;iDGiLNv8c,QHjLMu8c,gBACAlB;;;;;iDGgLNr7c;kDHnLF;;oDGmLEtjH;;8DHjLM4/jB;iEACAlB;;;2CGgLNp7c,KHnLF,mCGmLEtjH;;8CHnLF,kCGmLEA;uDHnLF,2BGmLEA;;;;;;;gCP/KA,SO+KA02I;0CP/KA,oCO+KAA;;kCP/KA;+CO+KAA;mCP/KA;;;;;;;;;;;;;;;;;;;;;;;;;;;iGO+KAA,KPzKsD;yDANtDZ;;;;;;;;kDAGI;4EAHJF;;oDAGI;;uEqlBVNgoa,crlBUM5oX;;;iDAFA;2EADJp/C;;mDACI;;;;;gDACA;0EAFJA;;kDAEI;;;;;+CAEA;yEAJJA;;iDAII;;;;8CAJJ;;;;;sCO+KAe;uCP/KA,iDO+KAD;;qCP/KA;0CO+KAC,KP/KA,wCO+KAD;;uCP/KA;8CACIopb;wCADJ,MAEIlB;wCAFJ,MAGImB;wCAHJ,MAIIlB;;;;;yCADAmB;yCADAjB;yCADAkB;yCO8KJtpb;;2CP9KIspb;2CACAlB;2CACAiB;2CACAlB;;;;;yCO2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DS62Z;uBCHEoH,WpJxDXj+Z,mBoJwDWuoH;uBA0BL;;;uBAkBA;;;;;;;qCA5CK41S;+B;uCAXLrE;;;wCAWKvxS;;;;;;;;;;;;;;;;uBA4CL;uBAc+C;wC,UAd/C21S;uBAc+C;iCAd/CzhlB;0BAvDA;+BAuDAA;2BAvDA,IAuDAA;2BAvDA,GAuDAA;2BAvDA,GAuDAA;2BAvDA,GAuDAA;2BAvDA,GAuDAA;2BAvDA,KAuDAA;2BAvDA,KAuDAA;2BAvDA,KAuDAA;2BAvDA,KAuDAA;2BAvDA,KAuDAA;;;2BAvDA;;oEwkBzMFi9iB,cxkByME7+Z;;;;;oEJlLAw2W,cIkLApqQ;;;gDpJ7CNhnE,kBoJ6Ca65U,WAAP9yQ;;oEJlLAqqQ,cIkLAtqQ;;;;;0BhB3LA,GgB2LAD;2BhB3LA;+BgB2LAA;4BhB3LAK,GgB2LAL;4BhB3LAr4B,GgB2LAq4B;4BhB3LA14L,GgB2LA04L;4BhB3LA34L,GgB2LA24L;4BhB3LA;;;;;;;0BgB2LA;;;;;sDpJ7CN7mE,kBmJ2DI62Z,cCdElwV;uBAqE+C;iChB/OjDvvO,IgBiOE+mC;0BAvDA;+BAuDA3hD;2BAvDA,IAuDAA;2BAvDA,GAuDAA;2BAvDA,GAuDAA;2BAvDA,GAuDAA;2BAvDA,GAuDAA;2BAvDA,KAuDAA;2BAvDA,KAuDAA;2BAvDA,KAuDAA;2BAvDA,KAuDAA;2BAvDA,KAuDAA;;;2BAvDA,ehB1KF4a,IgBiOE+mC,OAvDAgiE;4CwkBzMFu5b,exlB+BAtiiB,IgB0KEwjC;kDhB1KFxjC,IgB0KE2lC;kDhB1KF3lC,IgB0KEqmC;kDhB1KFrmC,IgB0KEomC;4CJlLA6zc,eZQFj6e,IgB0KEmmC;kCpJ7CN0iI,mBoJ6Ca65U,ShB1KT1if,IgB0KEkmC;6CJlLA+zc,eZQFj6e,IgB0KEsnC;2BhB1KF;;;;0BAjBE,GgB2LAmoM;2BhB3LA;+BgB2LAA;4BhB3LAK,GgB2LAL;4BhB3LAr4B,GgB2LAq4B;4BhB3LA14L,GgB2LA04L;4BhB3LA34L,GgB2LA24L;4BhB3LA,uBAiBFzvO;4BAjBE,uBAiBFA,IAjBE9F;mDAiBF8F,IAjBEshC;mDAiBFthC,IAjBE0hC;mDAiBF1hC,IAjBEsjC;4BgB2LAsD,OhB3LA,iBAiBF5mC,IAjBEyjC;;+BgB2LAmD,OhB3LA,mBAiBF5mC;0BgB0KE,6BhB1KFA,IgB0KE4mC;iCpJ7CNiiI,mBmJ2DI62Z,efxLA1/jB,IgB0KEgnC,WAqE+C;;iCAD7ChnC;0BApEF,sCAoEE2nI;uBAC6C;iChB/OjD3nI;0BgBsLM;;;8ChBtLNA;2BgBuLM,sBwkBtNNuiiB,exlB+BAviiB;2BgBwLM,gChBxLNA;2BgByLM,2BhBzLNA;2BgB0LM,yBhB1LNA;2BgB2LM,gCJlMFk6e,eZOJl6e;2BgB4LMunkB,WpJ/DVz+Z,kBoJ6Ca+5U,MhB1KT7if;2BgB6LM,wBJpMFk6e,eZOJl6e;;;;;2BAjBE,wBAiBFA;0BAjBE;+BgB+MIynkB;;;4BhB5MI;wEAcVznkB;6BAbU,8BAaVA;6BAZU,gCAYVA;6BAXU,kCAWVA;6BAVU,qCAUVA;6BgB8LMynkB;;+BhB5MIC;+BACAC;+BACAC;+BACAC;+BACAC;;gCgBwMJL,ShB/MJ,uBAiBF9/b;0BgBsLM;2BASA,6BhB/LN3nI;2BgBgMMgokB,QpJnEVl/Z,kBmJ2DI62Z,efxLA3/jB;;kCgBsLMirf;kCACAg6D;kCACAmiB;kCACAC;kCACAlmB;kCACAmmB;kCACAC;kCACAC;kCACAC;kCACAM;kCACAC,QA+C2C;;iCAd/C5hlB;0BAWI;4B,O2BwTJ85G,e5B5WFgge;0BCgDM;4B,O2B4TJhge,ejC/gBEsjZ;0BMmNE;mCNnNFA;mC8kBpDJg/C;mCxkByHFo/B;;;mCJjGM9nF;;;mCZOJ2hD;mCKsVAwS;;mCWrHE7njB;uBAc+C;iCAd/ChB;0BAvDA;mCAuDAA;2BAvDA,cAuDAA;2BAvDA,SAuDAA;2BAvDA,aAuDAA;2BAvDA,WAuDAA;2BAvDA,qBAuDAA;2BAvDA,QAuDAA;2BAvDA,UAuDAA;2BAvDA,eAuDAA;2BAvDA,WAuDAA;2BAvDA,aAuDAA;;;2BAjCIm4M,O2B0WJj/F,e5BlXF6he,cCQM6H;;2BADA;+DACAlnZ;;;;;0BhBjNJ,GgB+MI2mZ;2BhBxMI;gDgBwMJA;4BhBzMII,iBgByMJ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oBH5JA96hB;2BEDA;;gDLgOA6hhB,cFzMA5+E,cOvBAx2W;;;gDLgOAo1b,cFzMA5+E,cOvBA5iS;;;gDLgOAwhX,cFzMA5+E,cOvBAlqQ;8DC6JA+hW,oBD7JAhiW;uBC4wBiD;iCH3wBjD7vO,QGkwBE5a;0BDnwBF;8BCmwBEA;2BDnwBF,GCmwBEA;2BDnwBF,GCmwBEA;2BDnwBF,KCmwBEA;2BDnwBF,KCmwBEA;2BHlwBF,GEDA2jH;2BFCA,GEDAA;2BCmwBE;;2BHlwBFvlE,MH+NAq1hB,eFzMA5+E,eKtBAj6e;2BEDAyjC,MC6JAquiB,qBH5JA9xkB;2BEDAsjC,MLgOAu1hB,eFzMA5+E,eKtBAj6e,IEDAyjC;iCLgOAo1hB,eFzMA5+E,eKtBAj6e,IEDAsjC;iCLgOAu1hB,eFzMA5+E,eKtBAj6e,IEDA0hC;iCC6JAowiB,qBH5JA9xkB,IEDAshC,SC4wBiD;;iCH3wBjDthC;0BGkwBE;;;2BH9vBE6ohB,OH2NJiwC,eFxME5+E,eKvBFl6e;2BAIyBw3kB,iBGwJzBzF,qBH5JA/xkB;2BEWIy3kB,YFPA5uD,OAAqB2uD;2BEQrBE,OLmNJ5e,eFxME5+E,eKvBFl6e;2BEaI23kB;4BLkNJ7e,eFxME5+E,eKvBFl6e;2BEgBI43kB,kBL+MJ9e,eFxME5+E,eKvBFl6e;2BEiBI63kB,eC2IJ9F,qBH5JA/xkB;;kCEWIy3kB;kCACAC;kCACAC;kCAGAC;kCACAC,eC0vB6C;;iCAT/CzxlB;0BAII;0BDvwBN,SCmwBEA,KDnwBF,2CCmwBEA;0BAII;2BDvwBN,cCmwBEA;2BDnwBF;;;;;;;;;;;;;;;;;;oCqBwgBE;sCrBxgBF;;;;;;;;;yFCmwBEA,ED/uBmE;iDApBrEk1I;;;;;;;;;2CAcI;uEAdJumH;;6CAcI;;uDLkNJk3U,cFxMEj/E,cOVEv/T;;;0CADA;sEAbJsnE;;4CAaI;;sDLmNJk3U,cFxMEj/E,cOXEr6T;;;yCAIA;qEAjBJoiE;;2CAiBI;;qDL+MJk3U,cFxMEj/E,cOPEn6T;;;wCALA;oEAZJkiE;;0CAYI,IFXJtiJ,KEWI;0CFXJ;+CEWIg8B,OFXJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gHAKqE;mEALrED;;;;;;0DAIyB;oFAJzBF;;4DAIyB;;sEGwJzB42c,oBHxJyBx3Z;;;yDAArB;mFAJJp/C;;2DAII;;qEH2NJ29b,cFxMEj/E,cKnBEr/T;;wDAJJ;;;;;gDEWIl/C;iDFXJ;;;oDEWIA,OFXJ;;;wDAIIktZ;kDAJJ,MAIyB2vD;;;;;mDAArB1vD;mDEOAntZ,UFPAmtZ,WAAqB2vD;;;;;mDEOrB98c;oDFXJ;;;;gEAIIktZ;mEAAqB2vD;;0CEOrBL;;uCAMA;mEAlBJl2V;;yCAkBI;;mDC2IJmwV,oBD3IInyZ;;sCAlBJ;;;;uFCmwBEz5L;4BDnwBF;8ECmwBEA;4BDnwBF;mCAYI2xlB;6BAZJ,MAaIC;6BAbJ,MAcIC;6BAdJ,MAiBIC;6BAjBJ,MAkBIC;;;;+BADAI;+BAHAC;+BADAC;+BADAC;;;sCACAD;sCACAD;sCAGAD;sCACAD;4BAlBJ;;qCCmwBElylB;;+CDvvBE2xlB;;gDACAC;;iDACAC;;kDAGAC;qDACAC;uBC0vB6C;iCAT/C/ylB;0BDnwBF;0CCmwBEA;2BDnwBF,kBCmwBEA;2BDnwBF,mBCmwBEA;2BDnwBF,OCmwBEA;2BDnwBF,SCmwBEA;;2BDjvBE6+C,MC2IJouiB,2BD3IIwF;;2BADAn7f,ML+MJs8e,cFxMEj/E,cOPE69F;+DACAv0c;2BAJAzmD,MLkNJo8e,cFxMEj/E,cOVE49F;+DAGAr0c;2BAJAvmD,MLmNJi8e,cFxMEj/E,cOXE29F;+DACAxhc;2BFbJ,iBEWIuhc;2BFXJ,OEWIA;2BFPqBv6f,MGwJzBm1f,oBHxJyBmF;;2BAArBl6f,MH2NJ07e,cFxMEj/E,cKnBE8uC;+DAAqBtsZ;2BEOrBxzI,OFPAyzI;2BEOAukD,kCACAD;oCADAC;uBCgwB6C;iCARzCnyE,IADN7lH;;;2BAEM4gS,MNriBRuvS,qBMoiBQtqd;2BAGF86K,MA1mBN4oT,+BAwmBQ3oT;2BAGFF,MNxiBNyvS,qBMuiBMxvS,MAJJ3gS;2BAMIgwR,MNziBNmgT,qBMwiBMzvS,MALJ1gS;2BAOI4tK,MN1iBNuia,qBMyiBMngT,MANJhwR;iCAtmBFuplB,4BA6mBM37a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pqB,oBM0dP5nG;;;iDRhlBAgyH,cR/EApzZ,cgB+pBAmhS;;0DRhlBAiyH,oBQglBAlyH;;;iDRhlBAkyH,cQgbEitB,cAgKF4P;2BAgjBA;;;;;2CAhjBAjjX,QRhlBAomV,cFrEAr9E,cUqpBA/0C;2BtC9qBF,GsC8tCEV;2BtC9tCF;2BsC8tCE;0DtC9tCF;2BsC8tCE;;;;;;2BAzLA,KAyLA90N;2BAzLA,KAyLAA;2BAzLA,KAyLAA;2BAzLA;;;;mCF5JS0kX;4B,OA1uBTtiB;0BAyuBE;gCE6JF9uc;2BF7JE,KE6JFA;2BF7JE,KE6JFA;2BF7JE,KE6JFA;2BF7JE,KE6JFA;2BF7JE,KE6JFA;2BF7JE,KE6JFA;2BF7JE;oDNtqBF61b,cFzMA5+E,cQ+2BEt+W;;;;yDAzuBFm2c,oBAyuBE5tI;;0DAzuBF4tI,oBAyuBE7tI;;;2BE6JF;;;;8BF7JE;0BEgDF,UA6GAjtI;;;2BA7GA,SA6GAA;4BA7GA;kCA6GAA;6BF1lBA,GE6eA78L;6BF7eA,GE6eAA;6BF7eA,GE6eAA;6BF7eA,GE6eAA;6BF7eA,GE6eAA;6BF7eA,GE6eAA;6BF7eA,GE6eAA;6BF7eA,KE6eAA;6BF7eA;sDA5SA23c,6BA4SAt3c;;2DA5SAs3c,0BA4SA96hB;;;kDNzOA6hhB,cFzMA5+E,cQkbA5iS;;2DNzOAwhX,cEvBOn2E,WIgQP3yQ;6BE6eA;6BF7eA;;;;;gCqUhcAorV;kD,O3UuNAtC,4BMyOA/oV;;;kDNzOA+oV,mCMyOAhpV;iENzOAgpV,mBMyOAjpV;;;;gCE6eAuB;sDF7eAf,ONzOAyoV,mBMyOAlpV;;4BE6eA;kCA6GAqnF;mCA7GA;0BFhDE;2BE6JF;2BAyLA;;;;;2CAzLAyuI,QFt4BAqsI,0BEs4BAluI;2BAyLA;;;0BAxsCA,UAwsCAt0N;;;2BAxsCA;iCAwsCAA;;6BAxsCA,mCVGA2qQ,cUHAn+W;0BFk3BE;2BE+0BFgrU;;uEAzfAJ;0BpBztCF,UoBktDE3C;;;2BpBltDF,SoBktDEA;4BpBltDF;kCoBktDEA;;8BpBltDF;;;kCoBktDEA;mCpBltDF;uDoBktDE+C,cAE8D;;iC7CttDhE7mc,I6CotDEmqC;;;;2BAzfA,IAyfAo5F;2BAzfA,IAyfAA;2BAzfA,IAyfAA;2BAzfA,IAyfAA;2BAzfA,GAyfAA;2BAzfA,KAyfAA;2BAzfA,KAyfAA;2BAzfA,KAyfAA;2BAzfA,KAyfAA;2BAzfA,KAyfAA;2BAzfA,KAyfAA;2BAzfA,KAyfAA;2BAzfA,KAyfAA;2BAzfA,gB7C3tCFvjI,I6CotDEmqC,OAzfA64F;6CkkB5tCFs/Z,e/mBCAtiiB,I6C2tCE4mC;2BAhjBA,KAgjBA+9Z;2BAhjBA,KAgjBAA;2BAhjBA,KAgjBAA;2BAhjBA,KAgjBAA;2BAhjBA,KAgjBAA;2BAhjBA,KAgjBAA;2BAhjBA,KAgjBAA;2BAhjBA,KAgjBAA;2BAhjBA;;4BmUnqBAw2H;;gC,O3UmFA7D;8BrC3FFt3jB;8B6C2qBEgnC;;kCRhlBAswhB,eE6GO50E,SvCxMT1if,I6C2qBEmvC;kCRhlBAmohB,qBrC3FFt3jB,I6C2qBEuvC;kCRhlBA+nhB,eEsHOpqB,kBvCjNTltiB,I6C2qBEsvC;kCRhlBAgohB,eR/EApzZ,e7BZFlkK,I6C2qBE2vC;kCRhlBA2nhB,qBrC3FFt3jB,I6C2qBEmwC;kCRhlBAmnhB,eQgbEitB,e7C3gBJvklB,I6C2qBEkwC;2BAgjBAF,ORhoCAsnhB,eFrEAr9E,enCtBFj6e,I6C2qBEiwC;2BtC9qBF,GsC8tCEs0Z;2BtC9tCF,GsC8tCEA;2BtC9tCF,8BPGAvkc,I6C2tCEgwC,OtC9tCF8G;2BPGA;4BOHAC;8BPGA;;2B6C2tCE,uB7C3tCF/2C,I6C2tCEshC;iD7C3tCFthC,I6C2tCE+mC;iD7C3tCF/mC,I6C2tCEsnC;kE7C3tCFtnC,I6C2tCEynC;2BAzLA,KAyLAgoM;2BAzLA,KAyLAA;2BAzLA,KAyLAA;2BF1SA;;;mCA3CS4kX;4B,OA1uBTviB;0BAyuBE;gCE6JF/uc;2BF7JE,KE6JFA;2BF7JE,KE6JFA;2BF7JE,KE6JFA;2BF7JE,KE6JFA;2BF7JE,KE6JFA;2BF7JE,KE6JFA;2BF7JEr3F,ONtqBFmthB,eFzMA5+E,enCtBFj6e,I6CkiCEwnC,OF7JEk0F;8C3Cr4BJ17H,I2Cq4BI0rC;8C3Cr4BJ1rC,I2Cq4BIyjC;kCAzuBFquiB,qB3C5JF9xkB,I2Cq4BIwjC;kCAzuBFsuiB,qB3C5JF9xkB,I2Cq4BI4rC;kD3Cr4BJ5rC,I2Cq4BI2rC;kD3Cr4BJ3rC,I2Cq4BI2lC;0BEgDF,UA6GAu+Z;sCA7GA,mB7Cr7BFlkc,I6CkiCEqmC;;2BA7GA,SA6GA69Z;4BA7GA;kCA6GAA;6BA7GA,yB7Cr7BFlkc,I6CkiCEqmC;6BF1lBA,GE6eA6zF;6BF7eA,GE6eAA;6BF7eA,GE6eAA;6BF7eA,GE6eAA;6BF7eA,GE6eAA;6BF7eA,GE6eAA;6BF7eA,KE6eAA;6BF7eA,KE6eAA;6BF7eAzuF,OA5SAqmiB,8B3C5JF9xkB,I2CwcEmmC;oCA5SA2riB,2B3C5JF9xkB,I2CwcEyrC;oCNzOAothB,eFzMA5+E,enCtBFj6e,I2CwcE+tC;oCNzOA8qhB,eEvBOn2E,SvCxMT1if,I2CwcE8tC;;;8BqUhcAqthB;;kC,O3UuNAtC;gCrC/NF74jB;gC2CwcE6tC;;oCNzOAgrhB,oCrC/NF74jB,I2CwcE4tC;oCNzOAirhB,oBrC/NF74jB,I2CwcE2tC;6BE0lBA1H,ORn0BA4yhB,oBrC/NF74jB,I2CwcE0tC;;4BE6eA;kCA6GAw2Z;6BA7GA,yB7Cr7BFlkc,I6CkiCEqmC;oCA7GA,uB7Cr7BFrmC,I6Cq7BEkmC;0BFhDE;2BEsVFuH,OF/jCAqkiB,2B3C5JF9xkB,I6CkiCEimC;2BAyLA,uB7C3tCFjmC,I6C2tCEytC;kD7C3tCFztC,I6C2tCEunC;0BAnkCA,OAmkCA+nM;8CAnkCA,mB7CxJFtvO,I6CwJE+nC;uCAmkCAD,OAnkCA,mB7CxJF9nC,I6CwJE+nC;wCAmkCAD,OAnkCA,mB7CxJF9nC,I6CwJE+nC;0BArIA,UAwsCAsnM;2BAxsCA;4BAisDAxjM;6BAzfAwjM;+BAxsCA,mB7CnBFrvO,I6C2tCE8nC;+BAxsCA,mB7CnBF9nC,I6C2tCE8nC;;2BAxsCA;iCAwsCAunM;4BAxsCA,yB7CnBFrvO,I6C2tCE8nC;4BAyfA+D,OAjsDA,WVGAouc,enCtBFj6e,I6CmBEomC;0BpBjBF,UoBktDEw9Z;2BpBltDF,0BzBFA5jc,I6CotDE6rC;;4BpBltDF,SoBktDE+3Z;8BpBltDF,SoBktDEA,QpBltDF,yBzBFA5jc,I6CotDE6rC;8BpBltDF,oCzBFA7rC,IyBEA0hC;qCoBktDEkia,QpBltDF,yBzBFA5jc,I6CotDE6rC;4BpBltDF,sBzBFA7rC,IyBEAsjC,YoBotDgE;;iC7CttDhEtjC;0B6C4tCM;8C7C5tCNA;2B6C6tCM,sBkkB9tCNuiiB,e/mBCAviiB;2B6C2qBE;2BACI88b;4BmUpqBJs+H;;gC,O3UmFA7D;8BrC3FFv3jB;;2B6C8qBMgwlB,aRnlBJz4B,eE6GO10E,MvCxMT7if;2B6C+qBM4/jB,mBRplBJrI,qBrC3FFv3jB;2B6CirBM+nkB,cRtlBJxQ,eEsHOpqB,evCjNTntiB;2B6CkrBMigkB,YRvlBJ1I,eR/EApzZ,c7BZFnkK;2B6CmrBMonkB,eRxlBJ7P,qBrC3FFv3jB;2B6CqrBMynkB,SR1lBJlQ,eQgbEitB,e7C3gBJxklB;2B6CsrBMwnkB,aR3lBJjQ,eFpEEr9E,enCvBJl6e;2B6C8tCM4vlB;;6BAljBA9yJ;6BAEAkzJ;6BACApwB;6BAEAmI;6BACA9H;6BACAmH;6BAEAK;6BACAD;2BtCvrBF,sCPCJxnkB;;;;;;2B6C+tCM2vlB,oBtChuCFlxF,YAAwBD;2BsCkuCtB,kC7CjuCNx+f;2B6CkuCM,wB7CluCNA;2B6CmuCM,yB7CnuCNA;2B6CouCM,4C7CpuCNA;2B2Ci7BE;;;mCA3CSw6kB;4B,OA1uBTzI;0BA2vBM;2BADAuL;4BNvrBNxkB,eFxME5+E,enCvBJl6e;2B2Cu5BQ,8B3Cv5BRA;2B2Cm6BQ,+B3Cn6BRA;2B2Co6BQw3kB,iBAxwBNzF,qB3C5JF/xkB;2B2Cq6BQm9kB;4BAzwBNpL,qB3C5JF/xkB;2B2Cs6BQ,mC3Ct6BRA;2B2Cu6BQ,gC3Cv6BRA;2B2Cu6BQ;;6BAjBAs9kB;6BACAD;6BAYAD;6BACA5F;6BACA2F;6BACAD;6BACAD;2BEcN,0B7Cr7BFj9kB;0B6Cq7BE;+BA+GI8vlB,UA/GJ,uB7Cr7BFnod;;;;;+B2CycM0/b,UA7SJ0K,8B3C5JF/xkB;+B2C0cMmhjB,QA9SJ4wB,2B3C5JF/xkB;+B2C2cMsnkB;gCN5OJxO,eFxME5+E,enCvBJl6e;+B2C4cMunkB,WN7OJzO,eEvBOj2E,MvCxMT7if;;+B2C6cMsvS;gCqUrcJ8rR;;oC,O3UuNAtC;kCrC/NF94jB;;+B2C8cM8/jB;gCN/OJhH,oCrC/NF94jB;+B2C+cMggkB,eNhPJlH,oBrC/NF94jB;+B2CgdMy1kB,SNjPJ3c,oBrC/NF94jB;+B6Cq7BEmtf;;iCF5eIk6E;iCACAlmB;iCACAmmB;iCACAC;iCACAj4R;iCACAwwR;iCACAE;iCACAyV;+BEolBAqa,aA/GJ3iG;;;;8D7Cr7BFntf;+B6CoiCM8vlB,aA/GJyE;;yCA+GIzE;0BF7IE;2BE8IFD,cFz4BJ9d,2B3C5JF/xkB;2B6CquCMuvlB,mBAlMAQ,UACAD,UACAD;2BAiMA,sC7CtuCN7vlB;2B6CuuCM,+C7CvuCNA;2B6CwJE,0B7CxJFA;0B6CwJE;+BAglCIovlB,gBAhlCJ,uB7CxJFznd;;;wC6CwuCMynd;;;0BFjVE,YEp4BN,kB7CnBFpvlB;0B6CmBE;+BAstCImvlB,qBAttCJ,uB7CnBFxnd;;;wC6CyuCMwnd;;8BAttCJ;kDVIEj1G,enCvBJl6e;+B6CyuCMmvlB,wBAttCJqF;;yCAstCIrF;0BFlVE;2BE8zBFjoC;;6BAzfAj8D;6BACAg6D;6BACA2qC;6BACAD;6BAEA7hD;6BACA4hD;6BACAD;6BACAD;6BACAD;6BACAD;6BACAD;6BACAD;6BACAD;2BpBvuCN,0BzBFAnvlB;0ByBEA;+BoBmtD+By0lB,gBpBntD/B,uBzBFA9sd;;;;8ByBEA;kEzBFA3nI;+B6CqtD+By0lB,mBpBntD/Bx+b;;;;sDzBFAj2J;+B6CqtD+By0lB,mBpBntD/BpiZ;;yCoBmtD+BoiZ;oCAAzBvtC,OAAyButC,gBACiC;;iCAF9Dl1f;;;;;;;;;;4B;4BAAA;;;;;;;;;;sCkB7sCE;wClB6sCF;;;;;;;;;gGAE8D;mDAF9D+7B;;;;;;0CACI;oEADJF;;4CACI,IA1fJ6lH,OA0fI;4CA1fJ;iDA0fI1lH,OA1fJ;;;;;;;;;;;;;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6d;oDA1fJ;;;;gEACIovX;;iEACA46D;;kEACAqvC;;mEACAC;;oEAEAjmD;;qEACAkmD;;sEACAC;;uEACAC;;wEACAC;;yEACAC;;0EACAxG;;2EACAyG;8EACAC;4CA4eA/tC;;yCAAyB;mEAD7Bjsb;;2CAC6B;2CpBntD/B;;;;;;;;;;;;;;;;uDoBmtD+Bs/C,SpBntD/B;;;;qDoBmtD+BA,SpBntD/B;;+DoBmtD+BA;;uDpBntD/B8mE;;;;;;;;;;;;;;;;;;;;;;;;0DoBmtD+B9mE,YpBntD/B5xE;;;;;;0DoBmtD+B4xE;2DpBntD/B;;;;;;;;;wDoBmtD+BA,YpBntD/Bv+C;;;;;wDoBmtD+Bu+C;yDpBntD/B;;mEoBmtD+BA,SpBntD/B;;oDoBmtD+BA,SpBntD/B;;kDoBmtD+BA,SpBntD/B;2DoBmtD+BA,SpBntD/B;2CoBmtD+Bi6a;wCAD7B;;;uCAE8D;0BAF9D;;;;;;oCACIttC,cADJ,MAC6BstC;;6DAAzBrtC;iDAAyB8uC;0BAD7B;;;;6CACI/uC;gDAAyBstC,sCACiC;;;0BAF9D;0BpBltDF,UoBmtD+BF;;;2BpBntD/B,SoBmtD+BA;4BpBltD7B;gCoBktD6BA;6BpBltD7B;6BoBktD6B1rmB,mBpBltD7B+/G;;4BACA;kCoBitD6B2rf;6BpBjtD7B;6BoBitD6B1rmB,mBpBjtD7BozI;0BoBgtDA;2BAC6BK,kCAD7BD;2BACI;+DAAyBC;0BAAzB,iBAC0D;;iCAF9DihV;;;2BAzfA10L,kBN9+BA06N,eMu+CAhmC;2BAziCAz0L,kBkkB5qBF45Q,elkB4tCE75Q;;;2BAhjBA0B;;8BmUnqBArmD;uCnUqqBMx1H;gC,ORllBN+od,qCQklBM/od;8BAFNo6K;;kCRhlBA2uS,eEkJAl0E,eM8bAh5N;kCRhlBAktS,emlB9EAiD,e3kB8pBAlwS;kCRhlBAitS,eTyRF7nB,eiBuTEnlR;kCRhlBAgtS,ekBpEElzZ,eVopBFmmH;kCRhlBA+sS,ekBpEElzZ,eVopBFomH;kCRhlBA8sS,eQgbEgtB,eAgKF75T;2BAgjBA1B,ORhoCAuuS,qBQglBAxuS;;2B7C3qBFv6K,+B6C2tC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uB6JkgBY;uBAS+C;wC,UAT/C22b;uBAS+C;;0BAT/C;;;;2BHymCN,KGzmCMpme;2BHymCN,KGzmCMA;2BHwqBJ,GAicFrxB;2BAjcE,GAicFA;2BAjcE,GAicFA;2BAjcE,GAicFA;2BAjcE;;;;;gD1J1qCR6/D,8B0J0qCQwuC;2BAicF;;;;8BAjcE;2BGxqBI;;;;8BHymCN;;4B,OGpwDE0iZ;qCAqTIjG;0BAsWA;;;;;8B7JlgBZhsb;;kC,O2J9JIuwb;gCEgqBQt2U;;kFAS+C;;iCAT/C9hR;;;;;2BHymCN,KGzmCMo6H;2BHymCN,KGzmCMA;2BHwqBJ,GAicFrxB;2BAjcE,GAicFA;2BAjcE,GAicFA;2BAjcE,GAicFA;2BAjcE,aGxqBI/oG,UHwqBJ82C;2DGxqBI92C,IHwqBJ9F;iC1J1qCR2uK,+B6JkgBY7oK,IHwqBJshC;2BAicFI,6BGzmCM1hC,IHwqBJwjC;2BGxqBIF,MxB/oBRm7f,ewB+oBQz+hB,IHymCN0hC;;4B,OGpwDEs4jB;qCAqTI5F;;;;;;;2BAsWAzujB;4B7JlgBZmiI;;gC,O2J9JIwwb;;8BEgqBQt4lB;;;uEAS+C;;iCAT/CA;2EAS+C;;iCAT/CA;0BHyqBA;8CGzqBAA;2BH0qBA,gCG1qBAA;2BH2qBAohjB,c1J7qCZt4Y,8B6JkgBY9oK;2BH6qBA,+BG7qBAA;2BH6qBA,UAJAirf,aACAg2D,MACAG,cAEAD;2BA8bF,+BG3mCEnhjB;2BH2mCF,eADAknjB,OACAutC;;4B,OGtwDFyF;qCAqTI5F;0BA6WI;2BALAsL;4B7JpgBhB73b;;gC,O2J9JIywb;8BEgqBQx4lB;;2BAOI,8BAPJA;0BAOI,UANA6/lB,YACAD,kBAKAv+C,OAE2C;uBAT/C;wCAAKo/C;sB2RtlBG;uB3RmpBNM;wBAfF;mCAIWC;2CAHEC;8BACT;oCAEO1F,eADIx8G;8DACJw8G;;;;qDH+hCjB1E,uBG/hCiBmK;qC9JjkBjB/kc;uC8J8jBmBglc,wDAUH;;wD9J1kBhBtkd;;6B8J6kBYg7c,+BACJoJ;sB2RnpBM;uB3RwpBV;iCAqBS36mB;0BACX;;;;4BAAQ+6mB;4C,oBACJC;0BAgBJ;4B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B7B9DF,c6B8DE1oQ;;+B7B9DUwR,K6B8DVxR;+B7B9DiC2xD,GAAvBngD;+BAAuBkgD,GAAvBlgD;+BAAuB/O,6B6BY/B6qK,W7BZ+B57G;+BAAvB++G,gCAAuBhuK,K6BY/B6qK,W7BZ+B37G;2DAAvB8+G;uC6B8DVzwK,K7B9DUghnB,Y6BYR1zc,W7BZQr/D;;mC6B8DVsgE;4B7B9DF,c6B8DEvuK;;+B7B9DUwR,K6B8DVxR;+B7B9DU8U,IsDyXZstI,sBzB3TExnI;+B7B9DiC+2C,GAAvBngD;+BAAuBkgD,GAAvBlgD;+BAAuB0qC,M6BY/BqxH,YAkDF3yJ,I7B9DU9F,IAAuB48C;qC6BY/B67G,YAkDF3yJ,I7B9DiCshC;;6BAAvB+xD,O6B8DVjuG;6B7B9DUs8C,MsDyXZ8lG,sBzB3TExnI;mCAlDE2yJ,YAkDF3yJ,I7B9DU0hC,a6B+DqC;8BAD/CkyH;gDAA4B5zJ;4B,O7B9D9Bk3hB,e6BYInkY,aAkD0B/yJ;mCAA5B8zJ;4B,O7B9DFqjY,e6BYIpkY,aAkDF/yJ,YAC+C;;2BAD/C+zJ;sCAAKtB,cAALmB;;;4B,gB7B9DFr0D;;gE6BYI65D,U7BZJ75D;;;;;oDAC+C;qC6B6D7Cn5G;;4B7B9DF,c6B8DEhB;;+B7B9DUI,G6B8DVJ;+B7B9DiC0xD,GAAvBtxD;+BAAuBsjH,KAAvBtjH;+BAAuB02I,K6BY/B3uB,U7BZ+BzE;oC6BY/ByE,U7BZ+Bz2D;;gCAAvBqlF,K6B8DV/2I;kDAlDEmoH,U7BZQ4uB;mC6B8DVxoC;4BAA4B,S7B9D9BwqC,M6B8DWK,wCAAkB;4B7B9D7B,G6B8DE6ne,gB7B9DF;0C6B8DEA;;gC7B9DiC;iCAAnCzuc,U6B8DEr5B;iC7B9DFs5B,S6B8DEwuc;iC7B9DiChtE,MAAnCxhY;iCAAmCyhY,MAAnCzhY;iCAAmCy1U,MAAnC11U;iCAAmC2hY,MAAnC3hY;iCAAmC;+CAAK,MAALyhY;;uC6B8DjC96Z;mC7B9DF+ne,U6B8DE/ne,S7B9DFgoe,S6B8DEF;sC7B9DFloe;gD6B8DEkoe,YAAkD;mCAAlDrjgB;4BAA4B,S7B9D9Bm7B,M6B8DWsoe,sCAAkB;4B7B9D7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LD;;4BpD7fF;gCoD6fEptnB;6BpD7fF,GoD6fEA;6BpD7fF,GoD6fEA;;;;6BpD7fF;;;;;gC9G8HNyiL;;;qC8G7HqB9wH;;;;wEoDmEbmuH,cpDnEanuH;kCADfD;;sEoDoEEouH,cpDpEFnuH;;uDA7BA41c,0BA6BAv1S;mCoD6fEt9C;4BpD7fF;gCoD6fE10K;6BpD7fF,GoD6fEA;6BpD7fF,GoD6fEA;;;;6BpD7fFs8C;8B9G8HNomI;yC8G7HoB9nK;;mCAAC+2C;;0DAAD/2C,QAAC82C;oDoDmEbquH,epDnEYnlK,IAACshC;gCoD4fbthC;;gCpD7fF82C;4CoDoEEquH,eAybAnlK,IpD7fF0hC;mCA7BAord,2BoD0hBE9sf,IpD7fF9F,OoDkgB8B;8BAL5Bw4mB;iDAIE1ymB;4BpDjgBJ,sCoDigBI2nI;mCAJFgre;;;;;6BpD5fEzjH;8B9G6HVnnV;yC8G7HU/nK;;mCAAW82C,oBAAX92C;mCAAW+2C,coDmEbquH,cpDnEEplK;4CAAW82C;gCoD4fb92C;;6BpD3fE,mBoDkEFolK,cAybAplK;6BpD1fEgvf,OAhCJ/B,2BoD0hBEjtf;sCpD5fEkvf,UACAD,QACAD,OoD+f0B;;2BAL5B4jH;uCAAKH,eAALC;;;;;;;;4BpD7fF,SoD6fEtsnB,KpD7fF,0CoD6fEA;4BpD7fF;yCoD6fEA;6BpD7fF;;;;;;;;;;;;;;;;sC8D0eE;wC9D1eF;;;;;;;;;0FoD6fEA,EpDxfuB;mDALzBk1I;;;;;;;2CAGI;qEAHJF;;6CAGI;;gEAhCJkyX,0BAgCI9yU;;;0CAFA;oEADJp/C;;4CACI;;;8CiEscJ76B;yDjEtcehB;kDAAD,SAACA;;;;;;;;;;;kFADfzrD,YACeyrD,KAAgB;gDAA3Bk7E;;;yCACA;mEAFJr/C;;2CAEI;;;;wCAFJ;;;;sFoD6fEh1I;8BpD7fF;6EoD6fEA;8BpD7fF;qCACIsogB;+BADJ,MAEIC;+BAFJ,MAGIC;;;;iCADAE;iCADAC;wDACAD,YACAD;8BAHJ;;uCoD6fEzogB;;iDpD5fEsogB;;kDACAC;qDACAC;mCoD0fFmkH;4BpD7fF;oCoD6fE3tnB;6BpD7fF,QoD6fE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","sourcesContent":[null,"//\n// strftime\n// github.com/samsonjs/strftime\n// @_sjs\n//\n// Copyright 2010 - 2015 Sami Samhuri \n//\n// MIT License\n// http://sjs.mit-license.org\n//\n\n;(function() {\n\n var DefaultLocale = {\n days: ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'],\n shortDays: ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'],\n months: ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'],\n shortMonths: ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'],\n AM: 'AM',\n PM: 'PM',\n am: 'am',\n pm: 'pm',\n formats: {\n D: '%m/%d/%y',\n F: '%Y-%m-%d',\n R: '%H:%M',\n T: '%H:%M:%S',\n X: '%T',\n c: '%a %b %d %X %Y',\n r: '%I:%M:%S %p',\n v: '%e-%b-%Y',\n x: '%D'\n }\n },\n defaultStrftime = new Strftime(DefaultLocale, 0, false),\n isCommonJS = typeof module !== 'undefined',\n namespace;\n\n // CommonJS / Node module\n if (isCommonJS) {\n namespace = module.exports = adaptedStrftime;\n namespace.strftime = deprecatedStrftime;\n if(joo_global_object) joo_global_object.strftime = adaptedStrftime;\n }\n // Browsers and other environments\n else {\n // Get the global object. Works in ES3, ES5, and ES5 strict mode.\n namespace = joo_global_object || (function() { return this || (1,eval)('this'); }());\n namespace.strftime = adaptedStrftime;\n }\n\n // Deprecated API, to be removed in v1.0\n var _require = isCommonJS ? \"require('strftime')\" : \"strftime\";\n var _deprecationWarnings = {};\n function deprecationWarning(name, instead) {\n if (!_deprecationWarnings[name]) {\n if (typeof console !== 'undefined' && typeof console.warn == 'function') {\n console.warn(\"[WARNING] \" + name + \" is deprecated and will be removed in version 1.0. Instead, use `\" + instead + \"`.\");\n }\n _deprecationWarnings[name] = true;\n }\n }\n\n namespace.strftimeTZ = deprecatedStrftimeTZ;\n namespace.strftimeUTC = deprecatedStrftimeUTC;\n namespace.localizedStrftime = deprecatedStrftimeLocalized;\n\n // Adapt the old API while preserving the new API.\n function adaptForwards(fn) {\n fn.localize = defaultStrftime.localize.bind(defaultStrftime);\n fn.timezone = defaultStrftime.timezone.bind(defaultStrftime);\n fn.utc = defaultStrftime.utc.bind(defaultStrftime);\n }\n\n adaptForwards(adaptedStrftime);\n function adaptedStrftime(fmt, d, locale) {\n // d and locale are optional, check if this is (format, locale)\n if (d && d.days) {\n locale = d;\n d = undefined;\n }\n if (locale) {\n deprecationWarning(\"`\" + _require + \"(format, [date], [locale])`\", \"var s = \" + _require + \".localize(locale); s(format, [date])\");\n }\n var strftime = locale ? defaultStrftime.localize(locale) : defaultStrftime;\n return strftime(fmt, d);\n }\n\n adaptForwards(deprecatedStrftime);\n function deprecatedStrftime(fmt, d, locale) {\n if (locale) {\n deprecationWarning(\"`\" + _require + \".strftime(format, [date], [locale])`\", \"var s = \" + _require + \".localize(locale); s(format, [date])\");\n }\n else {\n deprecationWarning(\"`\" + _require + \".strftime(format, [date])`\", _require + \"(format, [date])\");\n }\n var strftime = locale ? defaultStrftime.localize(locale) : defaultStrftime;\n return strftime(fmt, d);\n }\n\n function deprecatedStrftimeTZ(fmt, d, locale, timezone) {\n // locale is optional, check if this is (format, date, timezone)\n if ((typeof locale == 'number' || typeof locale == 'string') && timezone == null) {\n timezone = locale;\n locale = undefined;\n }\n\n if (locale) {\n deprecationWarning(\"`\" + _require + \".strftimeTZ(format, date, locale, tz)`\", \"var s = \" + _require + \".localize(locale).timezone(tz); s(format, [date])` or `var s = \" + _require + \".localize(locale); s.timezone(tz)(format, [date])\");\n }\n else {\n deprecationWarning(\"`\" + _require + \".strftimeTZ(format, date, tz)`\", \"var s = \" + _require + \".timezone(tz); s(format, [date])` or `\" + _require + \".timezone(tz)(format, [date])\");\n }\n\n var strftime = (locale ? defaultStrftime.localize(locale) : defaultStrftime).timezone(timezone);\n return strftime(fmt, d);\n }\n\n var utcStrftime = defaultStrftime.utc();\n function deprecatedStrftimeUTC(fmt, d, locale) {\n if (locale) {\n deprecationWarning(\"`\" + _require + \".strftimeUTC(format, date, locale)`\", \"var s = \" + _require + \".localize(locale).utc(); s(format, [date])\");\n }\n else {\n deprecationWarning(\"`\" + _require + \".strftimeUTC(format, [date])`\", \"var s = \" + _require + \".utc(); s(format, [date])\");\n }\n var strftime = locale ? utcStrftime.localize(locale) : utcStrftime;\n return strftime(fmt, d);\n }\n\n function deprecatedStrftimeLocalized(locale) {\n deprecationWarning(\"`\" + _require + \".localizedStrftime(locale)`\", _require + \".localize(locale)\");\n return defaultStrftime.localize(locale);\n }\n // End of deprecated API\n\n // Polyfill Date.now for old browsers.\n if (typeof Date.now !== 'function') {\n Date.now = function() {\n return +new Date();\n };\n }\n\n function Strftime(locale, customTimezoneOffset, useUtcTimezone) {\n var _locale = locale || DefaultLocale,\n _customTimezoneOffset = customTimezoneOffset || 0,\n _useUtcBasedDate = useUtcTimezone || false,\n\n // we store unix timestamp value here to not create new Date() each iteration (each millisecond)\n // Date.now() is 2 times faster than new Date()\n // while millisecond precise is enough here\n // this could be very helpful when strftime triggered a lot of times one by one\n _cachedDateTimestamp = 0,\n _cachedDate;\n\n function _strftime(format, date) {\n var timestamp;\n\n if (!date) {\n var currentTimestamp = Date.now();\n if (currentTimestamp > _cachedDateTimestamp) {\n _cachedDateTimestamp = currentTimestamp;\n _cachedDate = new Date(_cachedDateTimestamp);\n\n timestamp = _cachedDateTimestamp;\n\n if (_useUtcBasedDate) {\n // how to avoid duplication of date instantiation for utc here?\n // we tied to getTimezoneOffset of the current date\n _cachedDate = new Date(_cachedDateTimestamp + getTimestampToUtcOffsetFor(_cachedDate) + _customTimezoneOffset);\n }\n }\n date = _cachedDate;\n }\n else {\n timestamp = date.getTime();\n\n if (_useUtcBasedDate) {\n date = new Date(date.getTime() + getTimestampToUtcOffsetFor(date) + _customTimezoneOffset);\n }\n }\n\n return _processFormat(format, date, _locale, timestamp);\n }\n\n function _processFormat(format, date, locale, timestamp) {\n var resultString = '',\n padding = null,\n isInScope = false,\n length = format.length,\n extendedTZ = false;\n\n for (var i = 0; i < length; i++) {\n\n var currentCharCode = format.charCodeAt(i);\n\n if (isInScope === true) {\n // '-'\n if (currentCharCode === 45) {\n padding = '';\n continue;\n }\n // '_'\n else if (currentCharCode === 95) {\n padding = ' ';\n continue;\n }\n // '0'\n else if (currentCharCode === 48) {\n padding = '0';\n continue;\n }\n // ':'\n else if (currentCharCode === 58) {\n if (extendedTZ) {\n if (typeof console !== 'undefined' && typeof console.warn == 'function') {\n console.warn(\"[WARNING] detected use of unsupported %:: or %::: modifiers to strftime\");\n }\n }\n extendedTZ = true;\n continue;\n }\n\n switch (currentCharCode) {\n\n // Examples for new Date(0) in GMT\n\n // 'Thursday'\n // case 'A':\n case 65:\n resultString += locale.days[date.getDay()];\n break;\n\n // 'January'\n // case 'B':\n case 66:\n resultString += locale.months[date.getMonth()];\n break;\n\n // '19'\n // case 'C':\n case 67:\n resultString += padTill2(Math.floor(date.getFullYear() / 100), padding);\n break;\n\n // '01/01/70'\n // case 'D':\n case 68:\n resultString += _processFormat(locale.formats.D, date, locale, timestamp);\n break;\n\n // '1970-01-01'\n // case 'F':\n case 70:\n resultString += _processFormat(locale.formats.F, date, locale, timestamp);\n break;\n\n // '00'\n // case 'H':\n case 72:\n resultString += padTill2(date.getHours(), padding);\n break;\n\n // '12'\n // case 'I':\n case 73:\n resultString += padTill2(hours12(date.getHours()), padding);\n break;\n\n // '000'\n // case 'L':\n case 76:\n resultString += padTill3(Math.floor(timestamp % 1000));\n break;\n\n // '00'\n // case 'M':\n case 77:\n resultString += padTill2(date.getMinutes(), padding);\n break;\n\n // 'am'\n // case 'P':\n case 80:\n resultString += date.getHours() < 12 ? locale.am : locale.pm;\n break;\n\n // '00:00'\n // case 'R':\n case 82:\n resultString += _processFormat(locale.formats.R, date, locale, timestamp);\n break;\n\n // '00'\n // case 'S':\n case 83:\n resultString += padTill2(date.getSeconds(), padding);\n break;\n\n // '00:00:00'\n // case 'T':\n case 84:\n resultString += _processFormat(locale.formats.T, date, locale, timestamp);\n break;\n\n // '00'\n // case 'U':\n case 85:\n resultString += padTill2(weekNumber(date, 'sunday'), padding);\n break;\n\n // '00'\n // case 'W':\n case 87:\n resultString += padTill2(weekNumber(date, 'monday'), padding);\n break;\n\n // '16:00:00'\n // case 'X':\n case 88:\n resultString += _processFormat(locale.formats.X, date, locale, timestamp);\n break;\n\n // '1970'\n // case 'Y':\n case 89:\n resultString += date.getFullYear();\n break;\n\n // 'GMT'\n // case 'Z':\n case 90:\n if (_useUtcBasedDate && _customTimezoneOffset === 0) {\n resultString += \"GMT\";\n }\n else {\n // fixme optimize\n var tzString = date.toString().match(/\\(([\\w\\s]+)\\)/);\n resultString += tzString && tzString[1] || '';\n }\n break;\n\n // 'Thu'\n // case 'a':\n case 97:\n resultString += locale.shortDays[date.getDay()];\n break;\n\n // 'Jan'\n // case 'b':\n case 98:\n resultString += locale.shortMonths[date.getMonth()];\n break;\n\n // ''\n // case 'c':\n case 99:\n resultString += _processFormat(locale.formats.c, date, locale, timestamp);\n break;\n\n // '01'\n // case 'd':\n case 100:\n resultString += padTill2(date.getDate(), padding);\n break;\n\n // ' 1'\n // case 'e':\n case 101:\n resultString += padTill2(date.getDate(), padding == null ? ' ' : padding);\n break;\n\n // 'Jan'\n // case 'h':\n case 104:\n resultString += locale.shortMonths[date.getMonth()];\n break;\n\n // '000'\n // case 'j':\n case 106:\n var y = new Date(date.getFullYear(), 0, 1);\n var day = Math.ceil((date.getTime() - y.getTime()) / (1000 * 60 * 60 * 24));\n resultString += padTill3(day);\n break;\n\n // ' 0'\n // case 'k':\n case 107:\n resultString += padTill2(date.getHours(), padding == null ? ' ' : padding);\n break;\n\n // '12'\n // case 'l':\n case 108:\n resultString += padTill2(hours12(date.getHours()), padding == null ? ' ' : padding);\n break;\n\n // '01'\n // case 'm':\n case 109:\n resultString += padTill2(date.getMonth() + 1, padding);\n break;\n\n // '\\n'\n // case 'n':\n case 110:\n resultString += '\\n';\n break;\n\n // '1st'\n // case 'o':\n case 111:\n resultString += String(date.getDate()) + ordinal(date.getDate());\n break;\n\n // 'AM'\n // case 'p':\n case 112:\n resultString += date.getHours() < 12 ? locale.AM : locale.PM;\n break;\n\n // '12:00:00 AM'\n // case 'r':\n case 114:\n resultString += _processFormat(locale.formats.r, date, locale, timestamp);\n break;\n\n // '0'\n // case 's':\n case 115:\n resultString += Math.floor(timestamp / 1000);\n break;\n\n // '\\t'\n // case 't':\n case 116:\n resultString += '\\t';\n break;\n\n // '4'\n // case 'u':\n case 117:\n var day = date.getDay();\n resultString += day === 0 ? 7 : day;\n break; // 1 - 7, Monday is first day of the week\n\n // ' 1-Jan-1970'\n // case 'v':\n case 118:\n resultString += _processFormat(locale.formats.v, date, locale, timestamp);\n break;\n\n // '4'\n // case 'w':\n case 119:\n resultString += date.getDay();\n break; // 0 - 6, Sunday is first day of the week\n\n // '12/31/69'\n // case 'x':\n case 120:\n resultString += _processFormat(locale.formats.x, date, locale, timestamp);\n break;\n\n // '70'\n // case 'y':\n case 121:\n resultString += ('' + date.getFullYear()).slice(2);\n break;\n\n // '+0000'\n // case 'z':\n case 122:\n if (_useUtcBasedDate && _customTimezoneOffset === 0) {\n resultString += extendedTZ ? \"+00:00\" : \"+0000\";\n }\n else {\n var off;\n if (_customTimezoneOffset !== 0) {\n off = _customTimezoneOffset / (60 * 1000);\n }\n else {\n off = -date.getTimezoneOffset();\n }\n var sign = off < 0 ? '-' : '+';\n var sep = extendedTZ ? ':' : '';\n var hours = Math.floor(Math.abs(off / 60));\n var mins = Math.abs(off % 60);\n resultString += sign + padTill2(hours) + sep + padTill2(mins);\n }\n break;\n\n default:\n resultString += format[i];\n break;\n }\n\n padding = null;\n isInScope = false;\n continue;\n }\n\n // '%'\n if (currentCharCode === 37) {\n isInScope = true;\n continue;\n }\n\n resultString += format[i];\n }\n\n return resultString;\n }\n\n var strftime = _strftime;\n\n strftime.localize = function(locale) {\n return new Strftime(locale || _locale, _customTimezoneOffset, _useUtcBasedDate);\n };\n\n strftime.timezone = function(timezone) {\n var customTimezoneOffset = _customTimezoneOffset;\n var useUtcBasedDate = _useUtcBasedDate;\n\n var timezoneType = typeof timezone;\n if (timezoneType === 'number' || timezoneType === 'string') {\n useUtcBasedDate = true;\n\n // ISO 8601 format timezone string, [-+]HHMM\n if (timezoneType === 'string') {\n var sign = timezone[0] === '-' ? -1 : 1,\n hours = parseInt(timezone.slice(1, 3), 10),\n minutes = parseInt(timezone.slice(3, 5), 10);\n\n customTimezoneOffset = sign * ((60 * hours) + minutes) * 60 * 1000;\n // in minutes: 420\n }\n else if (timezoneType === 'number') {\n customTimezoneOffset = timezone * 60 * 1000;\n }\n }\n\n return new Strftime(_locale, customTimezoneOffset, useUtcBasedDate);\n };\n\n strftime.utc = function() {\n return new Strftime(_locale, _customTimezoneOffset, true);\n };\n\n return strftime;\n }\n\n function padTill2(numberToPad, paddingChar) {\n if (paddingChar === '' || numberToPad > 9) {\n return numberToPad;\n }\n if (paddingChar == null) {\n paddingChar = '0';\n }\n return paddingChar + numberToPad;\n }\n\n function padTill3(numberToPad) {\n if (numberToPad > 99) {\n return numberToPad;\n }\n if (numberToPad > 9) {\n return '0' + numberToPad;\n }\n return '00' + numberToPad;\n }\n\n function hours12(hour) {\n if (hour === 0) {\n return 12;\n }\n else if (hour > 12) {\n return hour - 12;\n }\n return hour;\n }\n\n // firstWeekday: 'sunday' or 'monday', default is 'sunday'\n //\n // Pilfered & ported from Ruby's strftime implementation.\n function weekNumber(date, firstWeekday) {\n firstWeekday = firstWeekday || 'sunday';\n\n // This works by shifting the weekday back by one day if we\n // are treating Monday as the first day of the week.\n var weekday = date.getDay();\n if (firstWeekday === 'monday') {\n if (weekday === 0) // Sunday\n weekday = 6;\n else\n weekday--;\n }\n\n var firstDayOfYearUtc = Date.UTC(date.getFullYear(), 0, 1),\n dateUtc = Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()),\n yday = Math.floor((dateUtc - firstDayOfYearUtc) / 86400000),\n weekNum = (yday + 7 - weekday) / 7;\n\n return Math.floor(weekNum);\n }\n\n // Get the ordinal suffix for a number: st, nd, rd, or th\n function ordinal(number) {\n var i = number % 10;\n var ii = number % 100;\n\n if ((ii >= 11 && ii <= 13) || i === 0 || i >= 4) {\n return 'th';\n }\n switch (i) {\n case 1: return 'st';\n case 2: return 'nd';\n case 3: return 'rd';\n }\n }\n\n function getTimestampToUtcOffsetFor(date) {\n return (date.getTimezoneOffset() || 0) * 60000;\n }\n\n}());\n","//Provides: Base_int_math_int_popcount const\nfunction Base_int_math_int_popcount(v) {\n v = v - ((v >>> 1) & 0x55555555);\n v = (v & 0x33333333) + ((v >>> 2) & 0x33333333);\n return ((v + (v >>> 4) & 0xF0F0F0F) * 0x1010101) >>> 24;\n}\n\n//Provides: Base_clear_caml_backtrace_pos const\nfunction Base_clear_caml_backtrace_pos(x) {\n return 0;\n}\n\n//Provides: Base_int_math_int32_clz const\nfunction Base_int_math_int32_clz(x) {\n var n = 32;\n var y;\n y = x >>16; if (y != 0) { n = n -16; x = y; }\n y = x >> 8; if (y != 0) { n = n - 8; x = y; }\n y = x >> 4; if (y != 0) { n = n - 4; x = y; }\n y = x >> 2; if (y != 0) { n = n - 2; x = y; }\n y = x >> 1; if (y != 0) return n - 2;\n return n - x;\n}\n\n//Provides: Base_int_math_int_clz const\n//Requires: Base_int_math_int32_clz\nfunction Base_int_math_int_clz(x) { return Base_int_math_int32_clz(x); }\n\n//Provides: Base_int_math_nativeint_clz const\n//Requires: Base_int_math_int32_clz\nfunction Base_int_math_nativeint_clz(x) { return Base_int_math_int32_clz(x); }\n\n//Provides: Base_int_math_int64_clz const\n//Requires: caml_int64_shift_right_unsigned, caml_int64_is_zero, caml_int64_to_int32\nfunction Base_int_math_int64_clz(x) {\n var n = 64;\n var y;\n y = caml_int64_shift_right_unsigned(x, 32);\n if (!caml_int64_is_zero(y)) { n = n -32; x = y; }\n y = caml_int64_shift_right_unsigned(x, 16);\n if (!caml_int64_is_zero(y)) { n = n -16; x = y; }\n y = caml_int64_shift_right_unsigned(x, 8);\n if (!caml_int64_is_zero(y)) { n = n - 8; x = y; }\n y = caml_int64_shift_right_unsigned(x, 4);\n if (!caml_int64_is_zero(y)) { n = n - 4; x = y; }\n y = caml_int64_shift_right_unsigned(x, 2);\n if (!caml_int64_is_zero(y)) { n = n - 2; x = y; }\n y = caml_int64_shift_right_unsigned(x, 1);\n if (!caml_int64_is_zero(y)) return n - 2;\n return n - caml_int64_to_int32(x);\n}\n\n//Provides: Base_int_math_int32_ctz const\nfunction Base_int_math_int32_ctz(x) {\n if (x === 0) { return 32; }\n var n = 1;\n if ( (x & 0x0000FFFF) === 0) { n = n + 16; x = x >> 16; }\n if ( (x & 0x000000FF) === 0) { n = n + 8; x = x >> 8; }\n if ( (x & 0x0000000F) === 0) { n = n + 4; x = x >> 4; }\n if ( (x & 0x00000003) === 0) { n = n + 2; x = x >> 2; }\n return n - (x & 1);\n}\n\n//Provides: Base_int_math_int_ctz const\n//Requires: Base_int_math_int32_ctz\nfunction Base_int_math_int_ctz(x) { return Base_int_math_int32_ctz(x); }\n\n//Provides: Base_int_math_nativeint_ctz const\n//Requires: Base_int_math_int32_ctz\nfunction Base_int_math_nativeint_ctz(x) { return Base_int_math_int32_ctz(x); }\n\n//Provides: Base_int_math_int64_ctz const\n//Requires: caml_int64_shift_right_unsigned, caml_int64_is_zero, caml_int64_to_int32\n//Requires: caml_int64_and, caml_int64_of_int32, caml_int64_create_lo_mi_hi\nfunction Base_int_math_int64_ctz(x) {\n if (caml_int64_is_zero(x)) { return 64; }\n var n = 1;\n function is_zero (x) { return caml_int64_is_zero(x); }\n function land (x,y) { return caml_int64_and(x, y); }\n function small_int64(x) { return caml_int64_create_lo_mi_hi(x,0,0); }\n if (is_zero(land(x, caml_int64_create_lo_mi_hi(0xFFFFFF, 0x0000FF, 0x0000)))) {\n n = n + 32; x = caml_int64_shift_right_unsigned(x, 32);\n }\n if (is_zero(land(x, small_int64(0x00FFFF)))) {\n n = n + 16; x = caml_int64_shift_right_unsigned(x, 16);\n }\n if (is_zero(land(x, small_int64(0x0000FF)))) {\n n = n + 8; x = caml_int64_shift_right_unsigned(x, 8);\n }\n if (is_zero(land(x, small_int64(0x00000F)))) {\n n = n + 4; x = caml_int64_shift_right_unsigned(x, 4);\n }\n if (is_zero(land(x, small_int64(0x000003)))) {\n n = n + 2; x = caml_int64_shift_right_unsigned(x, 2);\n }\n return n - (caml_int64_to_int32(caml_int64_and(x, small_int64(0x000001))));\n}\n\n//Provides: Base_int_math_int_pow_stub const\nfunction Base_int_math_int_pow_stub(base, exponent) {\n var one = 1;\n var mul = [one, base, one, one];\n var res = one;\n while (!exponent==0) {\n mul[1] = (mul[1] * mul[3]) | 0;\n mul[2] = (mul[1] * mul[1]) | 0;\n mul[3] = (mul[2] * mul[1]) | 0;\n res = (res * mul[exponent & 3]) | 0;\n exponent = exponent >> 2;\n }\n return res;\n}\n\n//Provides: Base_int_math_int64_pow_stub const\n//Requires: caml_int64_mul, caml_int64_is_zero, caml_int64_shift_right_unsigned\n//Requires: caml_int64_create_lo_hi, caml_int64_lo32\nfunction Base_int_math_int64_pow_stub(base, exponent) {\n var one = caml_int64_create_lo_hi(1,0);\n var mul = [one, base, one, one];\n var res = one;\n while (!caml_int64_is_zero(exponent)) {\n mul[1] = caml_int64_mul(mul[1], mul[3]);\n mul[2] = caml_int64_mul(mul[1], mul[1]);\n mul[3] = caml_int64_mul(mul[2], mul[1]);\n res = caml_int64_mul(res, mul[caml_int64_lo32(exponent) & 3]);\n exponent = caml_int64_shift_right_unsigned(exponent, 2);\n }\n return res;\n}\n\n//Provides: Base_hash_string mutable\n//Requires: caml_hash\nfunction Base_hash_string(s) {\n return caml_hash(1,1,0,s)\n}\n//Provides: Base_hash_double const\n//Requires: caml_hash\nfunction Base_hash_double(d) {\n return caml_hash(1,1,0,d);\n}\n\n//Provides: Base_am_testing const\n//Weakdef\nfunction Base_am_testing(x) {\n return 0;\n}\n","// Js_of_ocaml runtime support\n// http://www.ocsigen.org/js_of_ocaml/\n//\n// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU Lesser General Public License as published by\n// the Free Software Foundation, with linking exception;\n// either version 2.1 of the License, or (at your option) any later version.\n//\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n// GNU Lesser General Public License for more details.\n//\n// You should have received a copy of the GNU Lesser General Public License\n// along with this program; if not, write to the Free Software\n// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n\n//Provides: caml_format_int const (const, const)\n//Requires: caml_parse_format, caml_finish_formatting, caml_str_repeat\n//Requires: caml_string_of_jsbytes, caml_jsbytes_of_string\nfunction caml_format_int(fmt, i) {\n if (caml_jsbytes_of_string(fmt) == \"%d\") return caml_string_of_jsbytes(\"\"+i);\n var f = caml_parse_format(fmt);\n if (i < 0) { if (f.signedconv) { f.sign = -1; i = -i; } else i >>>= 0; }\n var s = i.toString(f.base);\n if (f.prec >= 0) {\n f.filler = ' ';\n var n = f.prec - s.length;\n if (n > 0) s = caml_str_repeat (n, '0') + s;\n }\n return caml_finish_formatting(f, s);\n}\n\n//Provides: caml_parse_sign_and_base\n//Requires: caml_string_unsafe_get, caml_ml_string_length\nfunction caml_parse_sign_and_base (s) {\n var i = 0, len = caml_ml_string_length(s), base = 10, sign = 1;\n if (len > 0) {\n switch (caml_string_unsafe_get(s,i)) {\n case 45: i++; sign = -1; break;\n case 43: i++; sign = 1; break;\n }\n }\n if (i + 1 < len && caml_string_unsafe_get(s, i) == 48)\n switch (caml_string_unsafe_get(s, i + 1)) {\n case 120: case 88: base = 16; i += 2; break;\n case 111: case 79: base = 8; i += 2; break;\n case 98: case 66: base = 2; i += 2; break;\n case 117: case 85: i += 2; break;\n }\n return [i, sign, base];\n}\n\n//Provides: caml_parse_digit\nfunction caml_parse_digit(c) {\n if (c >= 48 && c <= 57) return c - 48;\n if (c >= 65 && c <= 90) return c - 55;\n if (c >= 97 && c <= 122) return c - 87;\n return -1;\n}\n\n//Provides: caml_int_of_string (const)\n//Requires: caml_ml_string_length, caml_string_unsafe_get\n//Requires: caml_parse_sign_and_base, caml_parse_digit, caml_failwith\nfunction caml_int_of_string (s) {\n var r = caml_parse_sign_and_base (s);\n var i = r[0], sign = r[1], base = r[2];\n var len = caml_ml_string_length(s);\n var threshold = -1 >>> 0;\n var c = (i < len)?caml_string_unsafe_get(s, i):0;\n var d = caml_parse_digit(c);\n if (d < 0 || d >= base) caml_failwith(\"int_of_string\");\n var res = d;\n for (i++;i= base) break;\n res = base * res + d;\n if (res > threshold) caml_failwith(\"int_of_string\");\n }\n if (i != len) caml_failwith(\"int_of_string\");\n // For base different from 10, we expect an unsigned representation,\n // hence any value of 'res' (less than 'threshold') is acceptable.\n // But we have to convert the result back to a signed integer.\n res = sign * res;\n if ((base == 10) && ((res | 0) != res))\n /* Signed representation expected, allow -2^(nbits-1) to 2^(nbits-1) - 1 */\n caml_failwith(\"int_of_string\");\n return res | 0;\n}\n\n//Provides: caml_mul const\nfunction caml_mul(a,b){\n return Math.imul(a,b);\n}\n\n//Provides: caml_div\n//Requires: caml_raise_zero_divide\nfunction caml_div(x,y) {\n if (y == 0) caml_raise_zero_divide ();\n return (x/y)|0;\n}\n\n//Provides: caml_mod\n//Requires: caml_raise_zero_divide\nfunction caml_mod(x,y) {\n if (y == 0) caml_raise_zero_divide ();\n return x%y;\n}\n\n//Provides: caml_bswap16\nfunction caml_bswap16(x) {\n return ((((x & 0x00FF) << 8) |\n ((x & 0xFF00) >> 8)));\n}\n//Provides: caml_int32_bswap\nfunction caml_int32_bswap(x) {\n return (((x & 0x000000FF) << 24) |\n ((x & 0x0000FF00) << 8) |\n ((x & 0x00FF0000) >>> 8) |\n ((x & 0xFF000000) >>> 24));\n}\n//Provides: caml_int64_bswap\n//Requires: caml_int64_to_bytes, caml_int64_of_bytes\nfunction caml_int64_bswap(x) {\n var y = caml_int64_to_bytes(x);\n return caml_int64_of_bytes([y[7], y[6], y[5], y[4], y[3], y[2], y[1], y[0]]);\n}\n","// Js_of_ocaml runtime support\n// http://www.ocsigen.org/js_of_ocaml/\n//\n// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU Lesser General Public License as published by\n// the Free Software Foundation, with linking exception;\n// either version 2.1 of the License, or (at your option) any later version.\n//\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n// GNU Lesser General Public License for more details.\n//\n// You should have received a copy of the GNU Lesser General Public License\n// along with this program; if not, write to the Free Software\n// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n\n///////////// Hashtbl\n\n//Provides: caml_hash_univ_param mutable\n//Requires: caml_is_ml_string, caml_is_ml_bytes\n//Requires: caml_ml_bytes_content\n//Requires: caml_int64_to_bytes, caml_int64_bits_of_float, caml_custom_ops\n//Requires: caml_ml_bytes_length, caml_jsbytes_of_string\nfunction caml_hash_univ_param (count, limit, obj) {\n var hash_accu = 0;\n function hash_aux (obj) {\n limit --;\n if (count < 0 || limit < 0) return;\n if (obj instanceof Array && obj[0] === (obj[0]|0)) {\n switch (obj[0]) {\n case 248:\n // Object\n count --;\n hash_accu = (hash_accu * 65599 + obj[2]) | 0;\n break;\n case 250:\n // Forward\n limit++; hash_aux(obj); break;\n default:\n count --;\n hash_accu = (hash_accu * 19 + obj[0]) | 0;\n for (var i = obj.length - 1; i > 0; i--) hash_aux (obj[i]);\n }\n } else if (caml_is_ml_bytes(obj)) {\n count --;\n var content = caml_ml_bytes_content(obj);\n if(typeof content === \"string\") {\n\tfor (var b = content, l = b.length, i = 0; i < l; i++)\n hash_accu = (hash_accu * 19 + b.charCodeAt(i)) | 0;\n } else { /* ARRAY */\n for (var a = content, l = a.length, i = 0; i < l; i++)\n hash_accu = (hash_accu * 19 + a[i]) | 0;\n }\n } else if (caml_is_ml_string(obj)) {\n var jsbytes = caml_jsbytes_of_string(obj);\n for (var b = jsbytes, l = jsbytes.length, i = 0; i < l; i++)\n hash_accu = (hash_accu * 19 + b.charCodeAt(i)) | 0;\n } else if (typeof obj === \"string\") {\n for (var b = obj, l = obj.length, i = 0; i < l; i++)\n hash_accu = (hash_accu * 19 + b.charCodeAt(i)) | 0;\n } else if (obj === (obj|0)) {\n // Integer\n count --;\n hash_accu = (hash_accu * 65599 + obj) | 0;\n } else if (obj === +obj) {\n // Float\n count--;\n var p = caml_int64_to_bytes (caml_int64_bits_of_float (obj));\n for (var i = 7; i >= 0; i--) hash_accu = (hash_accu * 19 + p[i]) | 0;\n } else if(obj && obj.caml_custom) {\n if(caml_custom_ops[obj.caml_custom] && caml_custom_ops[obj.caml_custom].hash) {\n var h = caml_custom_ops[obj.caml_custom].hash(obj) | 0;\n hash_accu = (hash_accu * 65599 + h) | 0;\n }\n }\n }\n hash_aux (obj);\n return hash_accu & 0x3FFFFFFF;\n}\n\n//function ROTL32(x,n) { return ((x << n) | (x >>> (32-n))); }\n//Provides: caml_hash_mix_int\n//Requires: caml_mul\nfunction caml_hash_mix_int(h,d) {\n d = caml_mul(d, 0xcc9e2d51|0);\n d = ((d << 15) | (d >>> (32-15))); // ROTL32(d, 15);\n d = caml_mul(d, 0x1b873593);\n h ^= d;\n h = ((h << 13) | (h >>> (32-13))); //ROTL32(h, 13);\n return (((h + (h << 2))|0) + (0xe6546b64|0))|0;\n}\n\n//Provides: caml_hash_mix_final\n//Requires: caml_mul\nfunction caml_hash_mix_final(h) {\n h ^= h >>> 16;\n h = caml_mul (h, 0x85ebca6b|0);\n h ^= h >>> 13;\n h = caml_mul (h, 0xc2b2ae35|0);\n h ^= h >>> 16;\n return h;\n}\n\n//Provides: caml_hash_mix_float\n//Requires: caml_int64_bits_of_float, caml_hash_mix_int64\nfunction caml_hash_mix_float (h, v0) {\n return caml_hash_mix_int64(h, caml_int64_bits_of_float (v0));\n}\n//Provides: caml_hash_mix_int64\n//Requires: caml_hash_mix_int\n//Requires: caml_int64_lo32, caml_int64_hi32\nfunction caml_hash_mix_int64 (h, v) {\n h = caml_hash_mix_int(h, caml_int64_lo32(v));\n h = caml_hash_mix_int(h, caml_int64_hi32(v));\n return h;\n}\n\n//Provides: caml_hash_mix_jsbytes\n//Requires: caml_hash_mix_int\nfunction caml_hash_mix_jsbytes(h, s) {\n var len = s.length, i, w;\n for (i = 0; i + 4 <= len; i += 4) {\n w = s.charCodeAt(i)\n | (s.charCodeAt(i+1) << 8)\n | (s.charCodeAt(i+2) << 16)\n | (s.charCodeAt(i+3) << 24);\n h = caml_hash_mix_int(h, w);\n }\n w = 0;\n switch (len & 3) {\n case 3: w = s.charCodeAt(i+2) << 16;\n case 2: w |= s.charCodeAt(i+1) << 8;\n case 1:\n w |= s.charCodeAt(i);\n h = caml_hash_mix_int(h, w);\n default:\n }\n h ^= len;\n return h;\n}\n\n//Provides: caml_hash_mix_bytes_arr\n//Requires: caml_hash_mix_int\nfunction caml_hash_mix_bytes_arr(h, s) {\n var len = s.length, i, w;\n for (i = 0; i + 4 <= len; i += 4) {\n w = s[i]\n | (s[i+1] << 8)\n | (s[i+2] << 16)\n | (s[i+3] << 24);\n h = caml_hash_mix_int(h, w);\n }\n w = 0;\n switch (len & 3) {\n case 3: w = s[i+2] << 16;\n case 2: w |= s[i+1] << 8;\n case 1: w |= s[i];\n h = caml_hash_mix_int(h, w);\n default:\n }\n h ^= len;\n return h;\n}\n\n//Provides: caml_hash_mix_bytes\n//Requires: caml_ml_bytes_content\n//Requires: caml_hash_mix_jsbytes\n//Requires: caml_hash_mix_bytes_arr\nfunction caml_hash_mix_bytes(h, v) {\n var content = caml_ml_bytes_content(v);\n if(typeof content === \"string\")\n return caml_hash_mix_jsbytes(h, content)\n else /* ARRAY */\n return caml_hash_mix_bytes_arr(h, content);\n}\n\n//Provides: caml_hash_mix_string\n//Requires: caml_hash_mix_jsbytes, caml_jsbytes_of_string\nfunction caml_hash_mix_string(h, v) {\n return caml_hash_mix_jsbytes(h, caml_jsbytes_of_string(v));\n}\n\n\n//Provides: caml_hash mutable\n//Requires: caml_is_ml_string, caml_is_ml_bytes\n//Requires: caml_hash_mix_int, caml_hash_mix_final\n//Requires: caml_hash_mix_float, caml_hash_mix_string, caml_hash_mix_bytes, caml_custom_ops\n//Requires: caml_hash_mix_jsbytes\nfunction caml_hash (count, limit, seed, obj) {\n var queue, rd, wr, sz, num, h, v, i, len;\n sz = limit;\n if (sz < 0 || sz > 256) sz = 256;\n num = count;\n h = seed;\n queue = [obj]; rd = 0; wr = 1;\n while (rd < wr && num > 0) {\n v = queue[rd++];\n if (v && v.caml_custom){\n if(caml_custom_ops[v.caml_custom] && caml_custom_ops[v.caml_custom].hash) {\n var hh = caml_custom_ops[v.caml_custom].hash(v);\n h = caml_hash_mix_int (h, hh);\n num --;\n }\n }\n else if (v instanceof Array && v[0] === (v[0]|0)) {\n switch (v[0]) {\n case 248:\n // Object\n h = caml_hash_mix_int(h, v[2]);\n num--;\n break;\n case 250:\n // Forward\n queue[--rd] = v[1];\n break;\n default:\n var tag = ((v.length - 1) << 10) | v[0];\n h = caml_hash_mix_int(h, tag);\n for (i = 1, len = v.length; i < len; i++) {\n if (wr >= sz) break;\n queue[wr++] = v[i];\n }\n break;\n }\n } else if (caml_is_ml_bytes(v)) {\n h = caml_hash_mix_bytes(h,v)\n num--;\n } else if (caml_is_ml_string(v)) {\n h = caml_hash_mix_string(h,v)\n num--;\n } else if (typeof v === \"string\") {\n h = caml_hash_mix_jsbytes(h,v)\n num--;\n } else if (v === (v|0)) {\n // Integer\n h = caml_hash_mix_int(h, v+v+1);\n num--;\n } else if (v === +v) {\n // Float\n h = caml_hash_mix_float(h,v);\n num--;\n }\n }\n h = caml_hash_mix_final(h);\n return h & 0x3FFFFFFF;\n}\n","// Js_of_ocaml runtime support\n// http://www.ocsigen.org/js_of_ocaml/\n// Copyright (C) 2010 Jérôme Vouillon\n// Laboratoire PPS - CNRS Université Paris Diderot\n//\n// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU Lesser General Public License as published by\n// the Free Software Foundation, with linking exception;\n// either version 2.1 of the License, or (at your option) any later version.\n//\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n// GNU Lesser General Public License for more details.\n//\n// You should have received a copy of the GNU Lesser General Public License\n// along with this program; if not, write to the Free Software\n// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n\n//Provides: jsoo_floor_log2\nvar log2_ok = Math.log2 && Math.log2(1.1235582092889474E+307) == 1020\nfunction jsoo_floor_log2(x) {\n if(log2_ok) return Math.floor(Math.log2(x))\n var i = 0;\n if (x == 0) return -Infinity;\n if(x>=1) {while (x>=2) {x/=2; i++} }\n else {while (x < 1) {x*=2; i--} };\n return i;\n}\n\n//Provides: caml_int64_bits_of_float const\n//Requires: jsoo_floor_log2, caml_int64_create_lo_mi_hi\nfunction caml_int64_bits_of_float (x) {\n if (!isFinite(x)) {\n if (isNaN(x))\n return caml_int64_create_lo_mi_hi(1, 0, 0x7ff0);\n if (x > 0)\n return caml_int64_create_lo_mi_hi(0, 0, 0x7ff0)\n else\n return caml_int64_create_lo_mi_hi(0, 0, 0xfff0)\n }\n var sign = (x==0 && 1/x == -Infinity)?0x8000:(x>=0)?0:0x8000;\n if (sign) x = -x;\n // Int64.bits_of_float 1.1235582092889474E+307 = 0x7fb0000000000000L\n // using Math.LOG2E*Math.log(x) in place of Math.log2 result in precision lost\n var exp = jsoo_floor_log2(x) + 1023;\n if (exp <= 0) {\n exp = 0;\n x /= Math.pow(2,-1026);\n } else {\n x /= Math.pow(2,exp-1027);\n if (x < 16) {\n x *= 2; exp -=1; }\n if (exp == 0) {\n x /= 2; }\n }\n var k = Math.pow(2,24);\n var r3 = x|0;\n x = (x - r3) * k;\n var r2 = x|0;\n x = (x - r2) * k;\n var r1 = x|0;\n r3 = (r3 &0xf) | sign | exp << 4;\n return caml_int64_create_lo_mi_hi(r1, r2, r3);\n}\n\n//Provides: caml_int32_bits_of_float const\n//Requires: jsoo_floor_log2\nfunction caml_int32_bits_of_float (x) {\n var float32a = new globalThis.Float32Array(1);\n float32a[0] = x;\n var int32a = new globalThis.Int32Array(float32a.buffer);\n return int32a[0] | 0;\n}\n\n//FP literals can be written using the hexadecimal\n//notation 0xp from ISO C99.\n//https://github.com/dankogai/js-hexfloat/blob/master/hexfloat.js\n//Provides: caml_hexstring_of_float const\n//Requires: caml_string_of_jsstring, caml_str_repeat\nfunction caml_hexstring_of_float (x, prec, style) {\n if (!isFinite(x)) {\n if (isNaN(x)) return caml_string_of_jsstring(\"nan\");\n return caml_string_of_jsstring ((x > 0)?\"infinity\":\"-infinity\");\n }\n var sign = (x==0 && 1/x == -Infinity)?1:(x>=0)?0:1;\n if(sign) x = -x;\n var exp = 0;\n if (x == 0) { }\n else if (x < 1) {\n while (x < 1 && exp > -1022) { x *= 2; exp-- }\n } else {\n while (x >= 2) { x /= 2; exp++ }\n }\n var exp_sign = exp < 0 ? '' : '+';\n var sign_str = '';\n if (sign) sign_str = '-'\n else {\n switch(style){\n case 43 /* '+' */: sign_str = '+'; break;\n case 32 /* ' ' */: sign_str = ' '; break;\n default: break;\n }\n }\n if (prec >= 0 && prec < 13) {\n /* If a precision is given, and is small, round mantissa accordingly */\n var cst = Math.pow(2,prec * 4);\n x = Math.round(x * cst) / cst;\n }\n var x_str = x.toString(16);\n if(prec >= 0){\n var idx = x_str.indexOf('.');\n if(idx<0) {\n x_str += '.' + caml_str_repeat(prec, '0');\n }\n else {\n var size = idx+1+prec;\n if(x_str.length < size)\n x_str += caml_str_repeat(size - x_str.length, '0');\n else\n x_str = x_str.substr(0,size);\n }\n }\n return caml_string_of_jsstring (sign_str + '0x' + x_str + 'p' + exp_sign + exp.toString(10));\n}\n\n//Provides: caml_int64_float_of_bits const\nfunction caml_int64_float_of_bits (x) {\n var lo = x.lo;\n var mi = x.mi;\n var hi = x.hi;\n var exp = (hi & 0x7fff) >> 4;\n if (exp == 2047) {\n if ((lo|mi|(hi&0xf)) == 0)\n return (hi & 0x8000)?(-Infinity):Infinity;\n else\n return NaN;\n }\n var k = Math.pow(2,-24);\n var res = (lo*k+mi)*k+(hi&0xf);\n if (exp > 0) {\n res += 16;\n res *= Math.pow(2,exp-1027);\n } else\n res *= Math.pow(2,-1026);\n if (hi & 0x8000) res = - res;\n return res;\n}\n\n//Provides: caml_nextafter_float const\n//Requires: caml_int64_float_of_bits, caml_int64_bits_of_float, caml_int64_add, caml_int64_sub,caml_int64_of_int32\nfunction caml_nextafter_float (x,y) {\n if(isNaN(x) || isNaN(y)) return NaN;\n if(x==y) return y;\n if(x==0){\n if(y < 0)\n return -Math.pow(2, -1074)\n else\n return Math.pow(2, -1074)\n }\n var bits = caml_int64_bits_of_float(x);\n var one = caml_int64_of_int32(1);\n if ((x0))\n bits = caml_int64_add(bits, one)\n else\n bits = caml_int64_sub(bits, one)\n return caml_int64_float_of_bits(bits);\n}\n\n//Provides: caml_trunc_float\nfunction caml_trunc_float(x){\n return Math.trunc(x);\n}\n\n//Provides: caml_int32_float_of_bits const\nfunction caml_int32_float_of_bits (x) {\n var int32a = new globalThis.Int32Array(1);\n int32a[0] = x;\n var float32a = new globalThis.Float32Array(int32a.buffer);\n return float32a[0];\n}\n\n//Provides: caml_classify_float const\nfunction caml_classify_float (x) {\n if (isFinite (x)) {\n if (Math.abs(x) >= 2.2250738585072014e-308) return 0;\n if (x != 0) return 1;\n return 2;\n }\n return isNaN(x)?4:3;\n}\n//Provides: caml_modf_float const\nfunction caml_modf_float (x) {\n if (isFinite (x)) {\n var neg = (1/x) < 0;\n x = Math.abs(x);\n var i = Math.floor (x);\n var f = x - i;\n if (neg) { i = -i; f = -f; }\n return [0, f, i];\n }\n if (isNaN (x)) return [0, NaN, NaN];\n return [0, 1/x, x];\n}\n//Provides: caml_ldexp_float const\nfunction caml_ldexp_float (x,exp) {\n exp |= 0;\n if (exp > 1023) {\n exp -= 1023;\n x *= Math.pow(2, 1023);\n if (exp > 1023) { // in case x is subnormal\n exp -= 1023;\n x *= Math.pow(2, 1023);\n }\n }\n if (exp < -1023) {\n exp += 1023;\n x *= Math.pow(2, -1023);\n }\n x *= Math.pow(2, exp);\n return x;\n}\n//Provides: caml_frexp_float const\n//Requires: jsoo_floor_log2\nfunction caml_frexp_float (x) {\n if ((x == 0) || !isFinite(x)) return [0, x, 0];\n var neg = x < 0;\n if (neg) x = - x;\n var exp = Math.max(-1023, jsoo_floor_log2(x) + 1);\n x *= Math.pow(2,-exp);\n while (x < 0.5) {\n x *= 2;\n exp--;\n }\n while (x >= 1) {\n x *= 0.5;\n exp++;\n }\n if (neg) x = - x;\n return [0, x, exp];\n}\n\n//Provides: caml_float_compare const\nfunction caml_float_compare (x, y) {\n if (x === y) return 0;\n if (x < y) return -1;\n if (x > y) return 1;\n if (x === x) return 1;\n if (y === y) return -1;\n return 0;\n}\n\n//Provides: caml_copysign_float const\nfunction caml_copysign_float (x, y) {\n if (y == 0) y = 1 / y;\n x = Math.abs(x);\n return (y < 0)?(-x):x;\n}\n\n//Provides: caml_signbit_float const\nfunction caml_signbit_float(x) {\n if (x == 0) x = 1 / x;\n return (x < 0)?1:0;\n}\n\n//Provides: caml_expm1_float const\nfunction caml_expm1_float (x) { return Math.expm1(x); }\n//Provides: caml_exp2_float const\nfunction caml_exp2_float(x) { return Math.pow(2, x); }\n//Provides: caml_log1p_float const\nfunction caml_log1p_float(x) { return Math.log1p(x); }\n//Provides: caml_log2_float const\nfunction caml_log2_float(x) { return Math.log2(x); }\n//Provides: caml_hypot_float const\nfunction caml_hypot_float (x, y) { return Math.hypot(x, y); }\n//Provides: caml_log10_float const\nfunction caml_log10_float (x) { return Math.log10(x); }\n//Provides: caml_cosh_float const\nfunction caml_cosh_float (x) { return Math.cosh(x); }\n//Provides: caml_acosh_float const\nfunction caml_acosh_float (x) { return Math.acosh(x); }\n//Provides: caml_sinh_float const\nfunction caml_sinh_float (x) { return Math.sinh(x); }\n//Provides: caml_asinh_float const\nfunction caml_asinh_float (x) { return Math.asinh(x); }\n//Provides: caml_tanh_float const\nfunction caml_tanh_float (x) { return Math.tanh(x); }\n//Provides: caml_atanh_float const\nfunction caml_atanh_float (x) { return Math.atanh(x); }\n//Provides: caml_round_float const\nfunction caml_round_float (x) { return Math.round(x); }\n//Provides: caml_cbrt_float const\nfunction caml_cbrt_float (x) { return Math.cbrt(x); }\n\n//Provides: caml_erf_float const\nfunction caml_erf_float(x) {\n var a1 = 0.254829592;\n var a2 = -0.284496736;\n var a3 = 1.421413741;\n var a4 = -1.453152027;\n var a5 = 1.061405429;\n var p = 0.3275911;\n\n var sign = 1;\n if (x < 0) {\n sign = -1;\n }\n x = Math.abs(x);\n var t = 1.0 / (1.0 + p * x);\n var y = 1.0 - ((((a5 * t + a4) * t + a3) * t + a2) * t + a1) * t * Math.exp(-x * x);\n\n return sign * y;\n}\n\n//Provides: caml_erfc_float const\n//Requires: caml_erf_float\nfunction caml_erfc_float(x) {\n return 1 - caml_erf_float(x);\n}\n\n\n//Provides: caml_fma_float const\nfunction caml_fma_float(x, y, z) {\n var SPLIT = Math.pow(2, 27) + 1;\n var MIN_VALUE = Math.pow(2, -1022);\n var EPSILON = Math.pow(2, -52);\n var C = 416;\n var A = Math.pow(2, +C);\n var B = Math.pow(2, -C);\n\n function multiply (a, b) {\n var at = SPLIT * a;\n var ahi = at - (at - a);\n var alo = a - ahi;\n var bt = SPLIT * b;\n var bhi = bt - (bt - b);\n var blo = b - bhi;\n var p = a * b;\n var e = ((ahi * bhi - p) + ahi * blo + alo * bhi) + alo * blo;\n return {\n p: p,\n e: e\n };\n };\n\n function add (a, b) {\n var s = a + b;\n var v = s - a;\n var e = (a - (s - v)) + (b - v);\n return {\n s: s,\n e: e\n };\n };\n\n function adjust (x, y) {\n return x !== 0 && y !== 0 && SPLIT * x - (SPLIT * x - x) === x ? x * (1 + (x < 0 ? -1 : +1) * (y < 0 ? -1 : +1) * EPSILON) : x;\n };\n\n if (x === 0 || x !== x || x === +1 / 0 || x === -1 / 0 ||\n y === 0 || y !== y || y === +1 / 0 || y === -1 / 0) {\n return x * y + z;\n }\n if (z === 0) {\n return x * y;\n }\n if (z !== z || z === +1 / 0 || z === -1 / 0) {\n return z;\n }\n\n var scale = 1;\n while (Math.abs(x) > A) {\n scale *= A;\n x *= B;\n }\n while (Math.abs(y) > A) {\n scale *= A;\n y *= B;\n }\n if (scale === 1 / 0) {\n return x * y * scale;\n }\n while (Math.abs(x) < B) {\n scale *= B;\n x *= A;\n }\n while (Math.abs(y) < B) {\n scale *= B;\n y *= A;\n }\n if (scale === 0) {\n return z;\n }\n\n var xs = x;\n var ys = y;\n var zs = z / scale;\n\n if (Math.abs(zs) > Math.abs(xs * ys) * 4 / EPSILON) {\n return z;\n }\n if (Math.abs(zs) < Math.abs(xs * ys) * EPSILON / 4 * EPSILON / 4) {\n zs = (z < 0 ? -1 : +1) * MIN_VALUE;\n }\n\n var xy = multiply(xs, ys);\n var s = add(xy.p, zs);\n var u = add(xy.e, s.e);\n var i = add(s.s, u.s);\n\n var f = i.s + adjust(i.e, u.e);\n if (f === 0) {\n return f;\n }\n\n var fs = f * scale;\n if (Math.abs(fs) > MIN_VALUE) {\n return fs;\n }\n\n // It is possible that there was extra rounding for a denormalized value.\n return fs + adjust(f - fs / scale, i.e) * scale;\n}\n\n//Provides: caml_format_float const\n//Requires: caml_parse_format, caml_finish_formatting\nfunction caml_format_float (fmt, x) {\n function toFixed(x,dp) {\n if (Math.abs(x) < 1.0) {\n return x.toFixed(dp);\n } else {\n var e = parseInt(x.toString().split('+')[1]);\n if (e > 20) {\n e -= 20;\n x /= Math.pow(10,e);\n x += (new Array(e+1)).join('0');\n if(dp > 0) {\n x = x + '.' + (new Array(dp+1)).join('0');\n }\n return x;\n }\n else return x.toFixed(dp)\n }\n }\n var s, f = caml_parse_format(fmt);\n var prec = (f.prec < 0)?6:f.prec;\n if (x < 0 || (x == 0 && 1/x == -Infinity)) { f.sign = -1; x = -x; }\n if (isNaN(x)) { s = \"nan\"; f.filler = ' '; }\n else if (!isFinite(x)) { s = \"inf\"; f.filler = ' '; }\n else\n switch (f.conv) {\n case 'e':\n var s = x.toExponential(prec);\n // exponent should be at least two digits\n var i = s.length;\n if (s.charAt(i - 3) == 'e')\n s = s.slice (0, i - 1) + '0' + s.slice (i - 1);\n break;\n case 'f':\n s = toFixed(x, prec); break;\n case 'g':\n prec = prec?prec:1;\n s = x.toExponential(prec - 1);\n var j = s.indexOf('e');\n var exp = +s.slice(j + 1);\n if (exp < -4 || x >= 1e21 || x.toFixed(0).length > prec) {\n // remove trailing zeroes\n var i = j - 1; while (s.charAt(i) == '0') i--;\n if (s.charAt(i) == '.') i--;\n s = s.slice(0, i + 1) + s.slice(j);\n i = s.length;\n if (s.charAt(i - 3) == 'e')\n s = s.slice (0, i - 1) + '0' + s.slice (i - 1);\n break;\n } else {\n var p = prec;\n if (exp < 0) { p -= exp + 1; s = x.toFixed(p); }\n else while (s = x.toFixed(p), s.length > prec + 1) p--;\n if (p) {\n // remove trailing zeroes\n var i = s.length - 1; while (s.charAt(i) == '0') i--;\n if (s.charAt(i) == '.') i--;\n s = s.slice(0, i + 1);\n }\n }\n break;\n }\n return caml_finish_formatting(f, s);\n}\n\n//Provides: caml_float_of_string (const)\n//Requires: caml_failwith, caml_jsbytes_of_string\nfunction caml_float_of_string(s) {\n var res;\n s = caml_jsbytes_of_string(s)\n res = +s;\n if ((s.length > 0) && (res === res)) return res;\n s = s.replace(/_/g,\"\");\n res = +s;\n if (((s.length > 0) && (res === res)) || /^[+-]?nan$/i.test(s)) return res;\n var m = /^ *([+-]?)0x([0-9a-f]+)\\.?([0-9a-f]*)(p([+-]?[0-9]+))?/i.exec(s);\n // 1 2 3 5\n if(m){\n var m3 = m[3].replace(/0+$/,'');\n var mantissa = parseInt(m[1] + m[2] + m3, 16);\n var exponent = (m[5]|0) - 4*m3.length;\n res = mantissa * Math.pow(2, exponent);\n return res;\n }\n if(/^\\+?inf(inity)?$/i.test(s)) return Infinity;\n if(/^-inf(inity)?$/i.test(s)) return -Infinity;\n caml_failwith(\"float_of_string\");\n}\n","// Js_of_ocaml runtime support\n// http://www.ocsigen.org/js_of_ocaml/\n// Copyright (C) 2010 Jérôme Vouillon\n// Laboratoire PPS - CNRS Université Paris Diderot\n//\n// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU Lesser General Public License as published by\n// the Free Software Foundation, with linking exception;\n// either version 2.1 of the License, or (at your option) any later version.\n//\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n// GNU Lesser General Public License for more details.\n//\n// You should have received a copy of the GNU Lesser General Public License\n// along with this program; if not, write to the Free Software\n// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n\n//Provides: caml_int64_offset\nvar caml_int64_offset = Math.pow(2, -24);\n\n//Provides: MlInt64\n//Requires: caml_int64_offset, caml_raise_zero_divide\nfunction MlInt64 (lo,mi,hi) {\n this.lo = lo & 0xffffff;\n this.mi = mi & 0xffffff;\n this.hi = hi & 0xffff;\n}\nMlInt64.prototype.caml_custom = \"_j\"\nMlInt64.prototype.copy = function () {\n return new MlInt64(this.lo,this.mi,this.hi);\n}\n\nMlInt64.prototype.ucompare = function (x) {\n if (this.hi > x.hi) return 1;\n if (this.hi < x.hi) return -1;\n if (this.mi > x.mi) return 1;\n if (this.mi < x.mi) return -1;\n if (this.lo > x.lo) return 1;\n if (this.lo < x.lo) return -1;\n return 0;\n}\nMlInt64.prototype.compare = function (x) {\n var hi = this.hi << 16;\n var xhi = x.hi << 16;\n if (hi > xhi) return 1;\n if (hi < xhi) return -1;\n if (this.mi > x.mi) return 1;\n if (this.mi < x.mi) return -1;\n if (this.lo > x.lo) return 1;\n if (this.lo < x.lo) return -1;\n return 0;\n}\nMlInt64.prototype.neg = function () {\n var lo = - this.lo;\n var mi = - this.mi + (lo >> 24);\n var hi = - this.hi + (mi >> 24);\n return new MlInt64(lo, mi, hi);\n}\nMlInt64.prototype.add = function (x) {\n var lo = this.lo + x.lo;\n var mi = this.mi + x.mi + (lo >> 24);\n var hi = this.hi + x.hi + (mi >> 24);\n return new MlInt64(lo, mi, hi);\n}\nMlInt64.prototype.sub = function (x) {\n var lo = this.lo - x.lo;\n var mi = this.mi - x.mi + (lo >> 24);\n var hi = this.hi - x.hi + (mi >> 24);\n return new MlInt64(lo, mi, hi);\n}\nMlInt64.prototype.mul = function (x) {\n var lo = this.lo * x.lo;\n var mi = ((lo * caml_int64_offset) | 0) + this.mi * x.lo + this.lo * x.mi;\n var hi = ((mi * caml_int64_offset) | 0) + this.hi * x.lo + this.mi * x.mi + this.lo * x.hi;\n return new MlInt64(lo, mi, hi);\n}\nMlInt64.prototype.isZero = function () {\n return (this.lo|this.mi|this.hi) == 0;\n}\nMlInt64.prototype.isNeg = function () {\n return (this.hi << 16) < 0;\n}\nMlInt64.prototype.and = function (x) {\n return new MlInt64(this.lo & x.lo, this.mi & x.mi, this.hi & x.hi);\n}\nMlInt64.prototype.or = function (x) {\n return new MlInt64(this.lo|x.lo, this.mi|x.mi, this.hi|x.hi);\n}\nMlInt64.prototype.xor = function (x) {\n return new MlInt64(this.lo^x.lo, this.mi^x.mi, this.hi^x.hi);\n}\nMlInt64.prototype.shift_left = function (s) {\n s = s & 63;\n if (s == 0) return this;\n if (s < 24) {\n return new MlInt64 (this.lo << s,\n (this.mi << s) | (this.lo >> (24 - s)),\n (this.hi << s) | (this.mi >> (24 - s)));\n }\n if (s < 48)\n return new MlInt64 (0,\n this.lo << (s - 24),\n (this.mi << (s - 24)) | (this.lo >> (48 - s)));\n return new MlInt64(0, 0, this.lo << (s - 48))\n}\nMlInt64.prototype.shift_right_unsigned = function (s) {\n s = s & 63;\n if (s == 0) return this;\n if (s < 24)\n return new MlInt64 (\n (this.lo >> s) | (this.mi << (24 - s)),\n (this.mi >> s) | (this.hi << (24 - s)),\n (this.hi >> s));\n if (s < 48)\n return new MlInt64 (\n (this.mi >> (s - 24)) | (this.hi << (48 - s)),\n (this.hi >> (s - 24)),\n 0);\n return new MlInt64 (this.hi >> (s - 48), 0, 0);\n}\nMlInt64.prototype.shift_right = function (s) {\n s = s & 63;\n if (s == 0) return this;\n var h = (this.hi << 16) >> 16;\n if (s < 24)\n return new MlInt64 (\n (this.lo >> s) | (this.mi << (24 - s)),\n (this.mi >> s) | (h << (24 - s)),\n ((this.hi << 16) >> s) >>> 16);\n var sign = (this.hi << 16) >> 31;\n if (s < 48)\n return new MlInt64 (\n (this.mi >> (s - 24)) | (this.hi << (48 - s)),\n (this.hi << 16) >> (s - 24) >> 16,\n sign & 0xffff);\n return new MlInt64 ((this.hi << 16) >> (s - 32), sign, sign);\n}\nMlInt64.prototype.lsl1 = function () {\n this.hi = (this.hi << 1) | (this.mi >> 23);\n this.mi = ((this.mi << 1) | (this.lo >> 23)) & 0xffffff;\n this.lo = (this.lo << 1) & 0xffffff;\n}\nMlInt64.prototype.lsr1 = function () {\n this.lo = ((this.lo >>> 1) | (this.mi << 23)) & 0xffffff;\n this.mi = ((this.mi >>> 1) | (this.hi << 23)) & 0xffffff;\n this.hi = this.hi >>> 1;\n}\nMlInt64.prototype.udivmod = function (x) {\n var offset = 0;\n var modulus = this.copy();\n var divisor = x.copy();\n var quotient = new MlInt64(0,0,0);\n while (modulus.ucompare(divisor) > 0) {\n offset++;\n divisor.lsl1();\n }\n while (offset >= 0) {\n offset --;\n quotient.lsl1();\n if (modulus.ucompare(divisor) >= 0) {\n quotient.lo ++;\n modulus = modulus.sub(divisor);\n }\n divisor.lsr1();\n }\n return { quotient : quotient, modulus : modulus };\n}\nMlInt64.prototype.div = function (y)\n{\n var x = this;\n if (y.isZero()) caml_raise_zero_divide ();\n var sign = x.hi ^ y.hi;\n if (x.hi & 0x8000) x = x.neg();\n if (y.hi & 0x8000) y = y.neg();\n var q = x.udivmod(y).quotient;\n if (sign & 0x8000) q = q.neg();\n return q;\n}\nMlInt64.prototype.mod = function (y)\n{\n var x = this;\n if (y.isZero()) caml_raise_zero_divide ();\n var sign = x.hi;\n if (x.hi & 0x8000) x = x.neg();\n if (y.hi & 0x8000) y = y.neg();\n var r = x.udivmod(y).modulus;\n if (sign & 0x8000) r = r.neg();\n return r;\n}\nMlInt64.prototype.toInt = function () {\n return this.lo | (this.mi << 24);\n}\nMlInt64.prototype.toFloat = function () {\n return ((this.hi << 16) * Math.pow(2, 32) + this.mi * Math.pow(2, 24)) + this.lo;\n}\nMlInt64.prototype.toArray = function () {\n return [this.hi >> 8,\n this.hi & 0xff,\n this.mi >> 16,\n (this.mi >> 8) & 0xff,\n this.mi & 0xff,\n this.lo >> 16,\n (this.lo >> 8) & 0xff,\n this.lo & 0xff];\n}\nMlInt64.prototype.lo32 = function () {\n return this.lo | ((this.mi & 0xff) << 24);\n}\nMlInt64.prototype.hi32 = function () {\n return ((this.mi >>> 8) & 0xffff) | (this.hi << 16);\n}\n\n//Provides: caml_int64_ult const\nfunction caml_int64_ult(x,y) { return x.ucompare(y) < 0; }\n\n//Provides: caml_int64_compare const\nfunction caml_int64_compare(x,y, total) { return x.compare(y) }\n\n//Provides: caml_int64_neg const\nfunction caml_int64_neg (x) { return x.neg() }\n\n//Provides: caml_int64_add const\nfunction caml_int64_add (x, y) { return x.add(y) }\n\n//Provides: caml_int64_sub const\nfunction caml_int64_sub (x, y) { return x.sub(y) }\n\n//Provides: caml_int64_mul const\n//Requires: caml_int64_offset\nfunction caml_int64_mul(x,y) { return x.mul(y) }\n\n//Provides: caml_int64_is_zero const\nfunction caml_int64_is_zero(x) { return +x.isZero(); }\n\n//Provides: caml_int64_is_negative const\nfunction caml_int64_is_negative(x) { return +x.isNeg(); }\n\n//Provides: caml_int64_and const\nfunction caml_int64_and (x, y) { return x.and(y); }\n\n//Provides: caml_int64_or const\nfunction caml_int64_or (x, y) { return x.or(y); }\n\n//Provides: caml_int64_xor const\nfunction caml_int64_xor (x, y) { return x.xor(y) }\n\n//Provides: caml_int64_shift_left const\nfunction caml_int64_shift_left (x, s) { return x.shift_left(s) }\n\n//Provides: caml_int64_shift_right_unsigned const\nfunction caml_int64_shift_right_unsigned (x, s) { return x.shift_right_unsigned(s) }\n\n//Provides: caml_int64_shift_right const\nfunction caml_int64_shift_right (x, s) { return x.shift_right(s) }\n\n//Provides: caml_int64_div const\nfunction caml_int64_div (x, y) { return x.div(y) }\n\n//Provides: caml_int64_mod const\nfunction caml_int64_mod (x, y) { return x.mod(y) }\n\n//Provides: caml_int64_of_int32 const\n//Requires: MlInt64\nfunction caml_int64_of_int32 (x) {\n return new MlInt64(x & 0xffffff, (x >> 24) & 0xffffff, (x >> 31) & 0xffff)\n}\n\n//Provides: caml_int64_to_int32 const\nfunction caml_int64_to_int32 (x) { return x.toInt() }\n\n//Provides: caml_int64_to_float const\nfunction caml_int64_to_float (x) { return x.toFloat () }\n\n//Provides: caml_int64_of_float const\n//Requires: caml_int64_offset, MlInt64\nfunction caml_int64_of_float (x) {\n if (x < 0) x = Math.ceil(x);\n return new MlInt64(\n x & 0xffffff,\n Math.floor(x * caml_int64_offset) & 0xffffff,\n Math.floor(x * caml_int64_offset * caml_int64_offset) & 0xffff);\n}\n\n//Provides: caml_int64_format const\n//Requires: caml_parse_format, caml_finish_formatting\n//Requires: caml_int64_is_negative, caml_int64_neg\n//Requires: caml_int64_of_int32, caml_int64_to_int32\n//Requires: caml_int64_is_zero, caml_str_repeat\nfunction caml_int64_format (fmt, x) {\n var f = caml_parse_format(fmt);\n if (f.signedconv && caml_int64_is_negative(x)) {\n f.sign = -1; x = caml_int64_neg(x);\n }\n var buffer = \"\";\n var wbase = caml_int64_of_int32(f.base);\n var cvtbl = \"0123456789abcdef\";\n do {\n var p = x.udivmod(wbase);\n x = p.quotient;\n buffer = cvtbl.charAt(caml_int64_to_int32(p.modulus)) + buffer;\n } while (! caml_int64_is_zero(x));\n if (f.prec >= 0) {\n f.filler = ' ';\n var n = f.prec - buffer.length;\n if (n > 0) buffer = caml_str_repeat (n, '0') + buffer;\n }\n return caml_finish_formatting(f, buffer);\n}\n\n//Provides: caml_int64_of_string\n//Requires: caml_parse_sign_and_base, caml_failwith, caml_parse_digit\n//Requires: caml_int64_of_int32, caml_int64_ult\n//Requires: caml_int64_add, caml_int64_mul, caml_int64_neg\n//Requires: caml_ml_string_length,caml_string_unsafe_get, MlInt64\nfunction caml_int64_of_string(s) {\n var r = caml_parse_sign_and_base (s);\n var i = r[0], sign = r[1], base = r[2];\n var base64 = caml_int64_of_int32(base);\n var threshold =\n new MlInt64(0xffffff, 0xfffffff, 0xffff).udivmod(base64).quotient;\n var c = caml_string_unsafe_get(s, i);\n var d = caml_parse_digit(c);\n if (d < 0 || d >= base) caml_failwith(\"int_of_string\");\n var res = caml_int64_of_int32(d);\n for (;;) {\n i++;\n c = caml_string_unsafe_get(s, i);\n if (c == 95) continue;\n d = caml_parse_digit(c);\n if (d < 0 || d >= base) break;\n /* Detect overflow in multiplication base * res */\n if (caml_int64_ult(threshold, res)) caml_failwith(\"int_of_string\");\n d = caml_int64_of_int32(d);\n res = caml_int64_add(caml_int64_mul(base64, res), d);\n /* Detect overflow in addition (base * res) + d */\n if (caml_int64_ult(res, d)) caml_failwith(\"int_of_string\");\n }\n if (i != caml_ml_string_length(s)) caml_failwith(\"int_of_string\");\n if (base == 10 && caml_int64_ult(new MlInt64(0, 0, 0x8000), res))\n caml_failwith(\"int_of_string\");\n if (sign < 0) res = caml_int64_neg(res);\n return res;\n}\n\n//Provides: caml_int64_create_lo_mi_hi const\n//Requires: MlInt64\nfunction caml_int64_create_lo_mi_hi(lo, mi, hi){\n return new MlInt64(lo, mi, hi)\n}\n//Provides: caml_int64_create_lo_hi const\n//Requires: MlInt64\nfunction caml_int64_create_lo_hi(lo, hi){\n return new MlInt64 (\n lo & 0xffffff,\n ((lo >>> 24) & 0xff) | ((hi & 0xffff) << 8),\n (hi >>> 16) & 0xffff);\n}\n//Provides: caml_int64_lo32 const\nfunction caml_int64_lo32(v){ return v.lo32() }\n\n//Provides: caml_int64_hi32 const\nfunction caml_int64_hi32(v){ return v.hi32() }\n\n//Provides: caml_int64_of_bytes const\n//Requires: MlInt64\nfunction caml_int64_of_bytes(a) {\n return new MlInt64(a[7] << 0 | (a[6] << 8) | (a[5] << 16),\n a[4] << 0 | (a[3] << 8) | (a[2] << 16),\n a[1] << 0 | (a[0] << 8));\n}\n//Provides: caml_int64_to_bytes const\nfunction caml_int64_to_bytes(x) { return x.toArray() }\n\n//Provides: caml_int64_hash const\nfunction caml_int64_hash(v){\n return (v.lo32()) ^ (v.hi32())\n}\n","// Js_of_ocaml runtime support\n// http://www.ocsigen.org/js_of_ocaml/\n//\n// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU Lesser General Public License as published by\n// the Free Software Foundation, with linking exception;\n// either version 2.1 of the License, or (at your option) any later version.\n//\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n// GNU Lesser General Public License for more details.\n//\n// You should have received a copy of the GNU Lesser General Public License\n// along with this program; if not, write to the Free Software\n// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n\n//Raise exception\n\n//Provides: caml_raise_constant (const)\nfunction caml_raise_constant (tag) { throw tag; }\n\n//Provides: caml_return_exn_constant (const)\nfunction caml_return_exn_constant (tag) { return tag; }\n\n//Provides: caml_raise_with_arg (const, const)\nfunction caml_raise_with_arg (tag, arg) { throw [0, tag, arg]; }\n\n//Provides: caml_raise_with_args (const, const)\nfunction caml_raise_with_args (tag, args) { throw [0, tag].concat(args); }\n\n//Provides: caml_raise_with_string (const, const)\n//Requires: caml_raise_with_arg, caml_string_of_jsbytes\nfunction caml_raise_with_string (tag, msg) {\n caml_raise_with_arg (tag, caml_string_of_jsbytes(msg));\n}\n\n//Provides: caml_failwith (const)\n//Requires: caml_raise_with_string, caml_global_data, caml_string_of_jsbytes\nfunction caml_failwith (msg) {\n if(!caml_global_data.Failure)\n caml_global_data.Failure=[248,caml_string_of_jsbytes(\"Failure\"),-3];\n caml_raise_with_string(caml_global_data.Failure, msg);\n}\n\n\n//Provides: caml_invalid_argument (const)\n//Requires: caml_raise_with_string, caml_global_data\nfunction caml_invalid_argument (msg) {\n caml_raise_with_string(caml_global_data.Invalid_argument, msg);\n}\n\n//Provides: caml_raise_end_of_file\n//Requires: caml_raise_constant, caml_global_data\nfunction caml_raise_end_of_file () {\n caml_raise_constant(caml_global_data.End_of_file);\n}\n\n//Provides: caml_raise_zero_divide\n//Requires: caml_raise_constant, caml_global_data\nfunction caml_raise_zero_divide () {\n caml_raise_constant(caml_global_data.Division_by_zero);\n}\n\n//Provides: caml_raise_not_found\n//Requires: caml_raise_constant, caml_global_data\nfunction caml_raise_not_found () {\n caml_raise_constant(caml_global_data.Not_found); }\n\n\n//Provides: caml_array_bound_error\n//Requires: caml_invalid_argument\nfunction caml_array_bound_error () {\n caml_invalid_argument(\"index out of bounds\");\n}\n","// Js_of_ocaml runtime support\n// http://www.ocsigen.org/js_of_ocaml/\n// Copyright (C) 2010 Jérôme Vouillon\n// Laboratoire PPS - CNRS Université Paris Diderot\n//\n// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU Lesser General Public License as published by\n// the Free Software Foundation, with linking exception;\n// either version 2.1 of the License, or (at your option) any later version.\n//\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n// GNU Lesser General Public License for more details.\n//\n// You should have received a copy of the GNU Lesser General Public License\n// along with this program; if not, write to the Free Software\n// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n\n//Provides: caml_call_gen (const, shallow)\n//Weakdef\nfunction caml_call_gen(f, args) {\n if(f.fun)\n return caml_call_gen(f.fun, args);\n //FIXME, can happen with too many arguments\n if(typeof f !== \"function\") return f;\n var n = f.length | 0;\n if(n === 0) return f.apply(null,args);\n var argsLen = args.length | 0;\n var d = n - argsLen | 0;\n if (d == 0)\n return f.apply(null, args);\n else if (d < 0) {\n return caml_call_gen(f.apply(null,args.slice(0,n)),args.slice(n));\n }\n else {\n return function (){\n var extra_args = (arguments.length == 0)?1:arguments.length;\n var nargs = new Array(args.length+extra_args);\n for(var i = 0; i < args.length; i++ ) nargs[i] = args[i];\n for(var i = 0; i < arguments.length; i++ ) nargs[args.length+i] = arguments[i];\n return caml_call_gen(f, nargs)\n }\n }\n}\n\n//Provides: caml_named_values\nvar caml_named_values = {};\n\n//Provides: caml_register_named_value (const,const)\n//Requires: caml_named_values, caml_jsbytes_of_string\nfunction caml_register_named_value(nm,v) {\n caml_named_values[caml_jsbytes_of_string(nm)] = v;\n return 0;\n}\n\n//Provides: caml_named_value\n//Requires: caml_named_values\nfunction caml_named_value(nm) {\n return caml_named_values[nm]\n}\n\n//Provides: caml_global_data\nvar caml_global_data = [0];\n\n//Provides: caml_register_global (const, shallow, const)\n//Requires: caml_global_data\nfunction caml_register_global (n, v, name_opt) {\n if(name_opt && globalThis.toplevelReloc)\n n = globalThis.toplevelReloc(name_opt);\n caml_global_data[n + 1] = v;\n if(name_opt) caml_global_data[name_opt] = v;\n}\n\n//Provides: caml_get_global_data mutable\n//Requires: caml_global_data\nfunction caml_get_global_data () { return caml_global_data; }\n\n//Provides: caml_is_printable const (const)\nfunction caml_is_printable(c) { return +(c > 31 && c < 127); }\n","// Js_of_ocaml runtime support\n// http://www.ocsigen.org/js_of_ocaml/\n// Copyright (C) 2010-2014 Jérôme Vouillon\n// Laboratoire PPS - CNRS Université Paris Diderot\n//\n// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU Lesser General Public License as published by\n// the Free Software Foundation, with linking exception;\n// either version 2.1 of the License, or (at your option) any later version.\n//\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n// GNU Lesser General Public License for more details.\n//\n// You should have received a copy of the GNU Lesser General Public License\n// along with this program; if not, write to the Free Software\n// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n\n// An OCaml string is an object with three fields:\n// - tag 't'\n// - length 'l'\n// - contents 'c'\n//\n// The contents of the string can be either a JavaScript array or\n// a JavaScript string. The length of this string can be less than the\n// length of the OCaml string. In this case, remaining bytes are\n// assumed to be zeroes. Arrays are mutable but consumes more memory\n// than strings. A common pattern is to start from an empty string and\n// progressively fill it from the start. Partial strings makes it\n// possible to implement this efficiently.\n//\n// When converting to and from UTF-16, we keep track of whether the\n// string is composed only of ASCII characters (in which case, no\n// conversion needs to be performed) or not.\n//\n// The string tag can thus take the following values:\n// full string BYTE | UNKNOWN: 0\n// BYTE | ASCII: 9\n// BYTE | NOT_ASCII: 8\n// string prefix PARTIAL: 2\n// array ARRAY: 4\n//\n// One can use bit masking to discriminate these different cases:\n// known_encoding(x) = x&8\n// is_ascii(x) = x&1\n// kind(x) = x&6\n\n//Provides: caml_str_repeat\nfunction caml_str_repeat(n, s) {\n if(n == 0) return \"\";\n if (s.repeat) {return s.repeat(n);} // ECMAscript 6 and Firefox 24+\n var r = \"\", l = 0;\n for(;;) {\n if (n & 1) r += s;\n n >>= 1;\n if (n == 0) return r;\n s += s;\n l++;\n if (l == 9) {\n s.slice(0,1); // flatten the string\n // then, the flattening of the whole string will be faster,\n // as it will be composed of larger pieces\n }\n }\n}\n\n//Provides: caml_subarray_to_jsbytes\n//Weakdef\n// Pre ECMAScript 5, [apply] would not support array-like object.\n// In such setup, Typed_array would be implemented as polyfill, and [f.apply] would\n// fail here. Mark the primitive as Weakdef, so that people can override it easily.\nfunction caml_subarray_to_jsbytes (a, i, len) {\n var f = String.fromCharCode;\n if (i == 0 && len <= 4096 && len == a.length) return f.apply (null, a);\n var s = \"\";\n for (; 0 < len; i += 1024,len-=1024)\n s += f.apply (null, a.slice(i,i + Math.min(len, 1024)));\n return s;\n}\n\n//Provides: caml_utf8_of_utf16\nfunction caml_utf8_of_utf16(s) {\n for (var b = \"\", t = b, c, d, i = 0, l = s.length; i < l; i++) {\n c = s.charCodeAt(i);\n if (c < 0x80) {\n for (var j = i + 1; (j < l) && (c = s.charCodeAt(j)) < 0x80; j++);\n if (j - i > 512) { t.substr(0, 1); b += t; t = \"\"; b += s.slice(i, j) }\n else t += s.slice(i, j);\n if (j == l) break;\n i = j;\n }\n if (c < 0x800) {\n t += String.fromCharCode(0xc0 | (c >> 6));\n t += String.fromCharCode(0x80 | (c & 0x3f));\n } else if (c < 0xd800 || c >= 0xdfff) {\n t += String.fromCharCode(0xe0 | (c >> 12),\n 0x80 | ((c >> 6) & 0x3f),\n 0x80 | (c & 0x3f));\n } else if (c >= 0xdbff || i + 1 == l ||\n (d = s.charCodeAt(i + 1)) < 0xdc00 || d > 0xdfff) {\n // Unmatched surrogate pair, replaced by \\ufffd (replacement character)\n t += \"\\xef\\xbf\\xbd\";\n } else {\n i++;\n c = (c << 10) + d - 0x35fdc00;\n t += String.fromCharCode(0xf0 | (c >> 18),\n 0x80 | ((c >> 12) & 0x3f),\n 0x80 | ((c >> 6) & 0x3f),\n 0x80 | (c & 0x3f));\n }\n if (t.length > 1024) {t.substr(0, 1); b += t; t = \"\";}\n }\n return b+t;\n}\n\n//Provides: caml_utf16_of_utf8\nfunction caml_utf16_of_utf8(s) {\n for (var b = \"\", t = \"\", c, c1, c2, v, i = 0, l = s.length; i < l; i++) {\n c1 = s.charCodeAt(i);\n if (c1 < 0x80) {\n for (var j = i + 1; (j < l) && (c1 = s.charCodeAt(j)) < 0x80; j++);\n if (j - i > 512) { t.substr(0, 1); b += t; t = \"\"; b += s.slice(i, j) }\n else t += s.slice(i, j);\n if (j == l) break;\n i = j;\n }\n v = 1;\n if ((++i < l) && (((c2 = s.charCodeAt(i)) & -64) == 128)) {\n c = c2 + (c1 << 6);\n if (c1 < 0xe0) {\n v = c - 0x3080;\n if (v < 0x80) v = 1;\n } else {\n v = 2;\n if ((++i < l) && (((c2 = s.charCodeAt(i)) & -64) == 128)) {\n c = c2 + (c << 6);\n if (c1 < 0xf0) {\n v = c - 0xe2080;\n if ((v < 0x800) || ((v >= 0xd7ff) && (v < 0xe000))) v = 2;\n } else {\n v = 3;\n if ((++i < l) && (((c2 = s.charCodeAt(i)) & -64) == 128) &&\n (c1 < 0xf5)) {\n v = c2 - 0x3c82080 + (c << 6);\n if (v < 0x10000 || v > 0x10ffff) v = 3;\n }\n }\n }\n }\n }\n if (v < 4) { // Invalid sequence\n i -= v;\n t += \"\\ufffd\";\n } else if (v > 0xffff)\n t += String.fromCharCode(0xd7c0 + (v >> 10), 0xdc00 + (v & 0x3FF))\n else\n t += String.fromCharCode(v);\n if (t.length > 1024) {t.substr(0, 1); b += t; t = \"\";}\n }\n return b+t;\n}\n\n//Provides: jsoo_is_ascii\nfunction jsoo_is_ascii (s) {\n // The regular expression gets better at around this point for all browsers\n if (s.length < 24) {\n // Spidermonkey gets much slower when s.length >= 24 (on 64 bit archs)\n for (var i = 0; i < s.length; i++) if (s.charCodeAt(i) > 127) return false;\n return true;\n } else\n return !/[^\\x00-\\x7f]/.test(s);\n}\n\n//Provides: caml_bytes_unsafe_get mutable\nfunction caml_bytes_unsafe_get (s, i) {\n switch (s.t & 6) {\n default: /* PARTIAL */\n if (i >= s.c.length) return 0;\n case 0: /* BYTES */\n return s.c.charCodeAt(i);\n case 4: /* ARRAY */\n return s.c[i]\n }\n}\n\n//Provides: caml_bytes_unsafe_set\n//Requires: caml_convert_bytes_to_array\nfunction caml_bytes_unsafe_set (s, i, c) {\n // The OCaml compiler uses Char.unsafe_chr on integers larger than 255!\n c &= 0xff;\n if (s.t != 4 /* ARRAY */) {\n if (i == s.c.length) {\n s.c += String.fromCharCode (c);\n if (i + 1 == s.l) s.t = 0; /*BYTES | UNKOWN*/\n return 0;\n }\n caml_convert_bytes_to_array (s);\n }\n s.c[i] = c;\n return 0;\n}\n\n//Provides: caml_string_bound_error\n//Requires: caml_invalid_argument\nfunction caml_string_bound_error () {\n caml_invalid_argument (\"index out of bounds\");\n}\n\n//Provides: caml_bytes_bound_error\n//Requires: caml_invalid_argument\nfunction caml_bytes_bound_error () {\n caml_invalid_argument (\"index out of bounds\");\n}\n\n//Provides: caml_string_get\n//Requires: caml_string_bound_error, caml_string_unsafe_get\n//Requires: caml_ml_string_length\nfunction caml_string_get (s, i) {\n if (i >>> 0 >= caml_ml_string_length(s)) caml_string_bound_error();\n return caml_string_unsafe_get (s, i);\n}\n\n//Provides: caml_string_get16\n//Requires: caml_string_unsafe_get, caml_string_bound_error\n//Requires: caml_ml_string_length\nfunction caml_string_get16(s,i) {\n if (i >>> 0 >= caml_ml_string_length(s) - 1) caml_string_bound_error();\n var b1 = caml_string_unsafe_get (s, i),\n b2 = caml_string_unsafe_get (s, i + 1);\n return (b2 << 8 | b1);\n}\n\n//Provides: caml_bytes_get16\n//Requires: caml_bytes_unsafe_get, caml_bytes_bound_error\nfunction caml_bytes_get16(s,i) {\n if (i >>> 0 >= s.l - 1) caml_bytes_bound_error();\n var b1 = caml_bytes_unsafe_get (s, i),\n b2 = caml_bytes_unsafe_get (s, i + 1);\n return (b2 << 8 | b1);\n}\n\n//Provides: caml_string_get32\n//Requires: caml_string_unsafe_get, caml_string_bound_error\n//Requires: caml_ml_string_length\nfunction caml_string_get32(s,i) {\n if (i >>> 0 >= caml_ml_string_length(s) - 3) caml_string_bound_error();\n var b1 = caml_string_unsafe_get (s, i),\n b2 = caml_string_unsafe_get (s, i + 1),\n b3 = caml_string_unsafe_get (s, i + 2),\n b4 = caml_string_unsafe_get (s, i + 3);\n return (b4 << 24 | b3 << 16 | b2 << 8 | b1);\n}\n\n//Provides: caml_bytes_get32\n//Requires: caml_bytes_unsafe_get, caml_bytes_bound_error\nfunction caml_bytes_get32(s,i) {\n if (i >>> 0 >= s.l - 3) caml_bytes_bound_error();\n var b1 = caml_bytes_unsafe_get (s, i),\n b2 = caml_bytes_unsafe_get (s, i + 1),\n b3 = caml_bytes_unsafe_get (s, i + 2),\n b4 = caml_bytes_unsafe_get (s, i + 3);\n return (b4 << 24 | b3 << 16 | b2 << 8 | b1);\n}\n\n//Provides: caml_string_get64\n//Requires: caml_string_unsafe_get, caml_string_bound_error\n//Requires: caml_int64_of_bytes\n//Requires: caml_ml_string_length\nfunction caml_string_get64(s,i) {\n if (i >>> 0 >= caml_ml_string_length(s) - 7) caml_string_bound_error();\n var a = new Array(8);\n for(var j = 0; j < 8; j++){\n a[7 - j] = caml_string_unsafe_get (s, i + j);\n }\n return caml_int64_of_bytes(a);\n}\n\n//Provides: caml_bytes_get64\n//Requires: caml_bytes_unsafe_get, caml_bytes_bound_error\n//Requires: caml_int64_of_bytes\nfunction caml_bytes_get64(s,i) {\n if (i >>> 0 >= s.l - 7) caml_bytes_bound_error();\n var a = new Array(8);\n for(var j = 0; j < 8; j++){\n a[7 - j] = caml_bytes_unsafe_get (s, i + j);\n }\n return caml_int64_of_bytes(a);\n}\n\n//Provides: caml_bytes_get\n//Requires: caml_bytes_bound_error, caml_bytes_unsafe_get\nfunction caml_bytes_get (s, i) {\n if (i >>> 0 >= s.l) caml_bytes_bound_error();\n return caml_bytes_unsafe_get (s, i);\n}\n\n//Provides: caml_string_set\n//Requires: caml_failwith\n//If: js-string\nfunction caml_string_set (s, i, c) {\n caml_failwith(\"caml_string_set\");\n}\n\n//Provides: caml_string_set\n//Requires: caml_string_unsafe_set, caml_string_bound_error\n//If: !js-string\nfunction caml_string_set (s, i, c) {\n if (i >>> 0 >= s.l) caml_string_bound_error();\n return caml_string_unsafe_set (s, i, c);\n}\n\n//Provides: caml_bytes_set16\n//Requires: caml_bytes_bound_error, caml_bytes_unsafe_set\nfunction caml_bytes_set16(s,i,i16){\n if (i >>> 0 >= s.l - 1) caml_bytes_bound_error();\n var b2 = 0xFF & i16 >> 8,\n b1 = 0xFF & i16;\n caml_bytes_unsafe_set (s, i + 0, b1);\n caml_bytes_unsafe_set (s, i + 1, b2);\n return 0\n}\n\n//Provides: caml_string_set16\n//Requires: caml_failwith\n//If: js-string\nfunction caml_string_set16(s,i,i16){\n caml_failwith(\"caml_string_set16\");\n}\n\n//Provides: caml_string_set16\n//Requires: caml_bytes_set16\n//If: !js-string\nfunction caml_string_set16(s,i,i16){\n return caml_bytes_set16(s,i,i16);\n}\n\n//Provides: caml_bytes_set32\n//Requires: caml_bytes_bound_error, caml_bytes_unsafe_set\nfunction caml_bytes_set32(s,i,i32){\n if (i >>> 0 >= s.l - 3) caml_bytes_bound_error();\n var b4 = 0xFF & i32 >> 24,\n b3 = 0xFF & i32 >> 16,\n b2 = 0xFF & i32 >> 8,\n b1 = 0xFF & i32;\n caml_bytes_unsafe_set (s, i + 0, b1);\n caml_bytes_unsafe_set (s, i + 1, b2);\n caml_bytes_unsafe_set (s, i + 2, b3);\n caml_bytes_unsafe_set (s, i + 3, b4);\n return 0\n}\n\n//Provides: caml_string_set32\n//Requires: caml_failwith\n//If: js-string\nfunction caml_string_set32(s,i,i32){\n caml_failwith(\"caml_string_set32\");\n}\n\n//Provides: caml_string_set32\n//Requires: caml_bytes_set32\n//If: !js-string\nfunction caml_string_set32(s,i,i32){\n return caml_bytes_set32(s,i,i32);\n}\n\n//Provides: caml_bytes_set64\n//Requires: caml_bytes_bound_error, caml_bytes_unsafe_set\n//Requires: caml_int64_to_bytes\nfunction caml_bytes_set64(s,i,i64){\n if (i >>> 0 >= s.l - 7) caml_bytes_bound_error();\n var a = caml_int64_to_bytes(i64);\n for(var j = 0; j < 8; j++) {\n caml_bytes_unsafe_set (s, i + 7 - j, a[j]);\n }\n return 0\n}\n\n//Provides: caml_string_set64\n//Requires: caml_failwith\n//If: js-string\nfunction caml_string_set64(s,i,i64){\n caml_failwith(\"caml_string_set64\");\n}\n\n//Provides: caml_string_set64\n//Requires: caml_bytes_set64\n//If: !js-string\nfunction caml_string_set64(s,i,i64){\n return caml_bytes_set64(s,i,i64);\n}\n\n//Provides: caml_bytes_set\n//Requires: caml_bytes_bound_error, caml_bytes_unsafe_set\nfunction caml_bytes_set (s, i, c) {\n if (i >>> 0 >= s.l) caml_bytes_bound_error();\n return caml_bytes_unsafe_set (s, i, c);\n}\n\n//Provides: caml_bytes_of_utf16_jsstring\n//Requires: jsoo_is_ascii, caml_utf8_of_utf16, MlBytes\nfunction caml_bytes_of_utf16_jsstring (s) {\n var tag = 9 /* BYTES | ASCII */;\n if (!jsoo_is_ascii(s))\n tag = 8 /* BYTES | NOT_ASCII */, s = caml_utf8_of_utf16(s);\n return new MlBytes(tag, s, s.length);\n}\n\n\n//Provides: MlBytes\n//Requires: caml_convert_string_to_bytes, jsoo_is_ascii, caml_utf16_of_utf8\nfunction MlBytes (tag, contents, length) {\n this.t=tag; this.c=contents; this.l=length;\n}\nMlBytes.prototype.toString = function(){\n switch (this.t) {\n case 9: /*BYTES | ASCII*/\n return this.c;\n default:\n caml_convert_string_to_bytes(this);\n case 0: /*BYTES | UNKOWN*/\n if (jsoo_is_ascii(this.c)) {\n this.t = 9; /*BYTES | ASCII*/\n return this.c;\n }\n this.t = 8; /*BYTES | NOT_ASCII*/\n case 8: /*BYTES | NOT_ASCII*/\n return this.c;\n }\n};\nMlBytes.prototype.toUtf16 = function (){\n var r = this.toString();\n if(this.t == 9) return r\n return caml_utf16_of_utf8(r);\n}\nMlBytes.prototype.slice = function (){\n var content = this.t == 4 ? this.c.slice() : this.c;\n return new MlBytes(this.t,content,this.l);\n}\n\n//Provides: caml_convert_string_to_bytes\n//Requires: caml_str_repeat, caml_subarray_to_jsbytes\nfunction caml_convert_string_to_bytes (s) {\n /* Assumes not BYTES */\n if (s.t == 2 /* PARTIAL */)\n s.c += caml_str_repeat(s.l - s.c.length, '\\0')\n else\n s.c = caml_subarray_to_jsbytes (s.c, 0, s.c.length);\n s.t = 0; /*BYTES | UNKOWN*/\n}\n\n//Provides: caml_convert_bytes_to_array\nfunction caml_convert_bytes_to_array (s) {\n /* Assumes not ARRAY */\n if(globalThis.Uint8Array) {\n var a = new globalThis.Uint8Array(s.l);\n } else {\n var a = new Array(s.l);\n }\n var b = s.c, l = b.length, i = 0;\n for (; i < l; i++) a[i] = b.charCodeAt(i);\n for (l = s.l; i < l; i++) a[i] = 0;\n s.c = a;\n s.t = 4; /* ARRAY */\n return a;\n}\n\n//Provides: caml_array_of_bytes mutable\n//Requires: caml_convert_bytes_to_array\nfunction caml_array_of_bytes (s) {\n if (s.t != 4 /* ARRAY */) caml_convert_bytes_to_array(s);\n return s.c;\n}\n\n//Provides: caml_array_of_string mutable\n//Requires: caml_convert_bytes_to_array\n//Requires: caml_ml_string_length, caml_string_unsafe_get\nfunction caml_array_of_string (s) {\n var l = caml_ml_string_length(s);\n var a = new Array(l);\n var i = 0;\n for (; i < l; i++) a[i] = caml_string_unsafe_get(s,i);\n return a;\n}\n\n//Provides: caml_create_string const\n//Requires: MlBytes, caml_invalid_argument\n//If: !js-string\nfunction caml_create_string(len) {\n if(len < 0) caml_invalid_argument(\"String.create\");\n return new MlBytes(len?2:9,\"\",len);\n}\n\n//Provides: caml_create_string const\n//Requires: caml_invalid_argument\n//If: js-string\nfunction caml_create_string(len) {\n caml_invalid_argument(\"String.create\");\n}\n\n//Provides: caml_create_bytes const\n//Requires: MlBytes,caml_invalid_argument\nfunction caml_create_bytes(len) {\n if (len < 0) caml_invalid_argument(\"Bytes.create\");\n return new MlBytes(len?2:9,\"\",len);\n}\n\n//Provides: caml_string_of_array\n//Requires: caml_subarray_to_jsbytes, caml_string_of_jsbytes\nfunction caml_string_of_array (a) {\n return caml_string_of_jsbytes(caml_subarray_to_jsbytes(a,0,a.length));\n}\n\n//Provides: caml_bytes_of_array\n//Requires: MlBytes\nfunction caml_bytes_of_array (a) {\n return new MlBytes(4,a,a.length);\n}\n\n//Provides: caml_bytes_compare mutable\n//Requires: caml_convert_string_to_bytes\nfunction caml_bytes_compare(s1, s2) {\n (s1.t & 6) && caml_convert_string_to_bytes(s1);\n (s2.t & 6) && caml_convert_string_to_bytes(s2);\n return (s1.c < s2.c)?-1:(s1.c > s2.c)?1:0;\n}\n\n\n//Provides: caml_bytes_equal mutable (const, const)\n//Requires: caml_convert_string_to_bytes\nfunction caml_bytes_equal(s1, s2) {\n if(s1 === s2) return 1;\n (s1.t & 6) && caml_convert_string_to_bytes(s1);\n (s2.t & 6) && caml_convert_string_to_bytes(s2);\n return (s1.c == s2.c)?1:0;\n}\n\n//Provides: caml_string_notequal mutable (const, const)\n//Requires: caml_string_equal\nfunction caml_string_notequal(s1, s2) { return 1-caml_string_equal(s1, s2); }\n\n//Provides: caml_bytes_notequal mutable (const, const)\n//Requires: caml_bytes_equal\nfunction caml_bytes_notequal(s1, s2) { return 1-caml_bytes_equal(s1, s2); }\n\n//Provides: caml_bytes_lessequal mutable\n//Requires: caml_convert_string_to_bytes\nfunction caml_bytes_lessequal(s1, s2) {\n (s1.t & 6) && caml_convert_string_to_bytes(s1);\n (s2.t & 6) && caml_convert_string_to_bytes(s2);\n return (s1.c <= s2.c)?1:0;\n}\n\n//Provides: caml_bytes_lessthan mutable\n//Requires: caml_convert_string_to_bytes\nfunction caml_bytes_lessthan(s1, s2) {\n (s1.t & 6) && caml_convert_string_to_bytes(s1);\n (s2.t & 6) && caml_convert_string_to_bytes(s2);\n return (s1.c < s2.c)?1:0;\n}\n\n//Provides: caml_string_greaterequal\n//Requires: caml_string_lessequal\nfunction caml_string_greaterequal(s1, s2) {\n return caml_string_lessequal(s2,s1);\n}\n//Provides: caml_bytes_greaterequal\n//Requires: caml_bytes_lessequal\nfunction caml_bytes_greaterequal(s1, s2) {\n return caml_bytes_lessequal(s2,s1);\n}\n\n//Provides: caml_string_greaterthan\n//Requires: caml_string_lessthan\nfunction caml_string_greaterthan(s1, s2) {\n return caml_string_lessthan(s2, s1);\n}\n\n//Provides: caml_bytes_greaterthan\n//Requires: caml_bytes_lessthan\nfunction caml_bytes_greaterthan(s1, s2) {\n return caml_bytes_lessthan(s2, s1);\n}\n\n//Provides: caml_fill_bytes\n//Requires: caml_str_repeat, caml_convert_bytes_to_array\nfunction caml_fill_bytes(s, i, l, c) {\n if (l > 0) {\n if (i == 0 && (l >= s.l || (s.t == 2 /* PARTIAL */ && l >= s.c.length))) {\n if (c == 0) {\n s.c = \"\";\n s.t = 2; /* PARTIAL */\n } else {\n s.c = caml_str_repeat (l, String.fromCharCode(c));\n s.t = (l == s.l)?0 /* BYTES | UNKOWN */ :2; /* PARTIAL */\n }\n } else {\n if (s.t != 4 /* ARRAY */) caml_convert_bytes_to_array(s);\n for (l += i; i < l; i++) s.c[i] = c;\n }\n }\n return 0;\n}\n\n//Provides: caml_fill_string\n//Requires: caml_fill_bytes\nvar caml_fill_string = caml_fill_bytes\n\n//Provides: caml_blit_bytes\n//Requires: caml_subarray_to_jsbytes, caml_convert_bytes_to_array\nfunction caml_blit_bytes(s1, i1, s2, i2, len) {\n if (len == 0) return 0;\n if ((i2 == 0) &&\n (len >= s2.l || (s2.t == 2 /* PARTIAL */ && len >= s2.c.length))) {\n s2.c = (s1.t == 4 /* ARRAY */)?\n caml_subarray_to_jsbytes(s1.c, i1, len):\n (i1 == 0 && s1.c.length == len)?s1.c:s1.c.substr(i1, len);\n s2.t = (s2.c.length == s2.l)?0 /* BYTES | UNKOWN */ :2; /* PARTIAL */\n } else if (s2.t == 2 /* PARTIAL */ && i2 == s2.c.length) {\n s2.c += (s1.t == 4 /* ARRAY */)?\n caml_subarray_to_jsbytes(s1.c, i1, len):\n (i1 == 0 && s1.c.length == len)?s1.c:s1.c.substr(i1, len);\n s2.t = (s2.c.length == s2.l)?0 /* BYTES | UNKOWN */ :2; /* PARTIAL */\n } else {\n if (s2.t != 4 /* ARRAY */) caml_convert_bytes_to_array(s2);\n var c1 = s1.c, c2 = s2.c;\n if (s1.t == 4 /* ARRAY */) {\n if (i2 <= i1) {\n for (var i = 0; i < len; i++) c2 [i2 + i] = c1 [i1 + i];\n } else {\n for (var i = len - 1; i >= 0; i--) c2 [i2 + i] = c1 [i1 + i];\n }\n } else {\n var l = Math.min (len, c1.length - i1);\n for (var i = 0; i < l; i++) c2 [i2 + i] = c1.charCodeAt(i1 + i);\n for (; i < len; i++) c2 [i2 + i] = 0;\n }\n }\n return 0;\n}\n\n//Provides: caml_blit_string\n//Requires: caml_blit_bytes, caml_bytes_of_string\nfunction caml_blit_string(a,b,c,d,e) {\n caml_blit_bytes(caml_bytes_of_string(a),b,c,d,e);\n return 0\n}\n\n//Provides: caml_ml_bytes_length const\nfunction caml_ml_bytes_length(s) { return s.l }\n\n//Provides: caml_string_unsafe_get const\n//If: js-string\nfunction caml_string_unsafe_get (s, i) {\n return s.charCodeAt(i);\n}\n\n//Provides: caml_string_unsafe_set\n//Requires: caml_failwith\n//If: js-string\nfunction caml_string_unsafe_set (s, i, c) {\n caml_failwith(\"caml_string_unsafe_set\");\n}\n\n//Provides: caml_ml_string_length const\n//If: js-string\nfunction caml_ml_string_length(s) {\n return s.length\n}\n\n//Provides: caml_string_compare const\n//If: js-string\nfunction caml_string_compare(s1, s2) {\n return (s1 < s2)?-1:(s1 > s2)?1:0;\n}\n\n//Provides: caml_string_equal const\n//If: js-string\nfunction caml_string_equal(s1, s2) {\n if(s1 === s2) return 1;\n return 0;\n}\n\n//Provides: caml_string_lessequal const\n//If: js-string\nfunction caml_string_lessequal(s1, s2) {\n return (s1 <= s2)?1:0;\n}\n\n//Provides: caml_string_lessthan const\n//If: js-string\nfunction caml_string_lessthan(s1, s2) {\n return (s1 < s2)?1:0;\n}\n\n//Provides: caml_string_of_bytes\n//Requires: caml_convert_string_to_bytes, caml_string_of_jsbytes\n//If: js-string\nfunction caml_string_of_bytes(s) {\n (s.t & 6) && caml_convert_string_to_bytes(s);\n return caml_string_of_jsbytes(s.c);\n}\n\n//Provides: caml_bytes_of_string const\n//Requires: caml_bytes_of_jsbytes, caml_jsbytes_of_string\n//If: js-string\nfunction caml_bytes_of_string(s) {\n return caml_bytes_of_jsbytes(caml_jsbytes_of_string(s));\n}\n\n//Provides: caml_string_of_jsbytes const\n//If: js-string\nfunction caml_string_of_jsbytes(x) { return x }\n\n//Provides: caml_jsbytes_of_string const\n//If: js-string\nfunction caml_jsbytes_of_string(x) { return x }\n\n//Provides: caml_jsstring_of_string const\n//Requires: jsoo_is_ascii, caml_utf16_of_utf8\n//If: js-string\nfunction caml_jsstring_of_string(s) {\n if(jsoo_is_ascii(s))\n return s;\n return caml_utf16_of_utf8(s); }\n\n//Provides: caml_string_of_jsstring const\n//Requires: jsoo_is_ascii, caml_utf8_of_utf16, caml_string_of_jsbytes\n//If: js-string\nfunction caml_string_of_jsstring (s) {\n if (jsoo_is_ascii(s))\n return caml_string_of_jsbytes(s)\n else return caml_string_of_jsbytes(caml_utf8_of_utf16(s));\n}\n\n//Provides: caml_bytes_of_jsbytes const\n//Requires: MlBytes\nfunction caml_bytes_of_jsbytes(s) { return new MlBytes(0,s,s.length); }\n\n\n// The section below should be used when use-js-string=false\n\n//Provides: caml_string_unsafe_get const\n//Requires: caml_bytes_unsafe_get\n//If: !js-string\nfunction caml_string_unsafe_get (s, i) {\n return caml_bytes_unsafe_get(s,i);\n}\n\n//Provides: caml_string_unsafe_set\n//Requires: caml_bytes_unsafe_set\n//If: !js-string\nfunction caml_string_unsafe_set (s, i, c) {\n return caml_bytes_unsafe_set(s,i,c);\n}\n\n//Provides: caml_ml_string_length const\n//Requires: caml_ml_bytes_length\n//If: !js-string\nfunction caml_ml_string_length(s) {\n return caml_ml_bytes_length(s)\n}\n\n//Provides: caml_string_compare\n//Requires: caml_bytes_compare\n//If: !js-string\nfunction caml_string_compare(s1, s2) {\n return caml_bytes_compare(s1,s2)\n}\n\n//Provides: caml_string_equal\n//Requires: caml_bytes_equal\n//If: !js-string\nfunction caml_string_equal(s1, s2) {\n return caml_bytes_equal(s1,s2)\n}\n\n//Provides: caml_string_lessequal\n//Requires: caml_bytes_lessequal\n//If: !js-string\nfunction caml_string_lessequal(s1, s2) {\n return caml_bytes_lessequal(s1,s2)\n}\n\n//Provides: caml_string_lessthan\n//Requires: caml_bytes_lessthan\n//If: !js-string\nfunction caml_string_lessthan(s1, s2) {\n return caml_bytes_lessthan(s1,s2)\n}\n\n//Provides: caml_string_of_bytes\n//If: !js-string\nfunction caml_string_of_bytes(s) { return s }\n\n//Provides: caml_bytes_of_string const\n//If: !js-string\nfunction caml_bytes_of_string(s) { return s }\n\n//Provides: caml_string_of_jsbytes const\n//Requires: caml_bytes_of_jsbytes\n//If: !js-string\nfunction caml_string_of_jsbytes(s) { return caml_bytes_of_jsbytes(s); }\n\n//Provides: caml_jsbytes_of_string const\n//Requires: caml_convert_string_to_bytes\n//If: !js-string\nfunction caml_jsbytes_of_string(s) {\n (s.t & 6) && caml_convert_string_to_bytes(s);\n return s.c }\n\n//Provides: caml_jsstring_of_string mutable (const)\n//If: !js-string\nfunction caml_jsstring_of_string(s){\n return s.toUtf16()\n}\n\n//Provides: caml_string_of_jsstring\n//Requires: caml_bytes_of_utf16_jsstring\n//If: !js-string\nfunction caml_string_of_jsstring (s) {\n return caml_bytes_of_utf16_jsstring(s);\n}\n\n//Provides: caml_is_ml_bytes\n//Requires: MlBytes\nfunction caml_is_ml_bytes(s) {\n return (s instanceof MlBytes);\n}\n\n//Provides: caml_ml_bytes_content\n//Requires: MlBytes, caml_convert_string_to_bytes\nfunction caml_ml_bytes_content(s) {\n switch (s.t & 6) {\n default: /* PARTIAL */\n caml_convert_string_to_bytes(s);\n case 0: /* BYTES */\n return s.c;\n case 4:\n return s.c\n }\n}\n\n//Provides: caml_is_ml_string\n//Requires: jsoo_is_ascii\n//If: js-string\nfunction caml_is_ml_string(s) {\n return (typeof s === \"string\" && !/[^\\x00-\\xff]/.test(s));\n}\n\n//Provides: caml_is_ml_string\n//Requires: caml_is_ml_bytes\n//If: !js-string\nfunction caml_is_ml_string(s) {\n return caml_is_ml_bytes(s);\n}\n\n// The functions below are deprecated\n\n//Provides: caml_js_to_byte_string const\n//Requires: caml_string_of_jsbytes\nfunction caml_js_to_byte_string(s) { return caml_string_of_jsbytes(s) }\n\n//Provides: caml_new_string\n//Requires: caml_string_of_jsbytes\nfunction caml_new_string (s) { return caml_string_of_jsbytes(s) }\n\n//Provides: caml_js_from_string mutable (const)\n//Requires: caml_jsstring_of_string\nfunction caml_js_from_string(s) {\n return caml_jsstring_of_string(s)\n}\n\n//Provides: caml_to_js_string mutable (const)\n//Requires: caml_jsstring_of_string\nfunction caml_to_js_string(s) {\n return caml_jsstring_of_string(s)\n}\n\n//Provides: caml_js_to_string const\n//Requires: caml_string_of_jsstring\nfunction caml_js_to_string (s) {\n return caml_string_of_jsstring(s);\n}\n","// Js_of_ocaml runtime support\n// http://www.ocsigen.org/js_of_ocaml/\n// Copyright (C) 2014 Jérôme Vouillon, Hugo Heuzard, Andy Ray\n// Laboratoire PPS - CNRS Université Paris Diderot\n//\n// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU Lesser General Public License as published by\n// the Free Software Foundation, with linking exception;\n// either version 2.1 of the License, or (at your option) any later version.\n//\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n// GNU Lesser General Public License for more details.\n//\n// You should have received a copy of the GNU Lesser General Public License\n// along with this program; if not, write to the Free Software\n// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n//\n// Bigarray.\n//\n// - all bigarray types including Int64 and Complex.\n// - fortran + c layouts\n// - sub/slice/reshape\n// - retain fast path for 1d array access\n\n//Provides: caml_ba_init const\nfunction caml_ba_init() {\n return 0;\n}\n\n//Provides: caml_ba_get_size\n//Requires: caml_invalid_argument\nfunction caml_ba_get_size(dims) {\n var n_dims = dims.length;\n var size = 1;\n for (var i = 0; i < n_dims; i++) {\n if (dims[i] < 0)\n caml_invalid_argument(\"Bigarray.create: negative dimension\");\n size = size * dims[i];\n }\n return size;\n}\n\n//Provides: caml_ba_get_size_per_element\nfunction caml_ba_get_size_per_element(kind){\n switch(kind){\n case 7: case 10: case 11: return 2;\n default: return 1;\n }\n}\n\n//Provides: caml_ba_create_buffer\n//Requires: caml_ba_get_size_per_element\n//Requires: caml_invalid_argument\nfunction caml_ba_create_buffer(kind, size){\n var g = globalThis;\n var view;\n switch(kind){\n case 0: view = g.Float32Array; break;\n case 1: view = g.Float64Array; break;\n case 2: view = g.Int8Array; break;\n case 3: view = g.Uint8Array; break;\n case 4: view = g.Int16Array; break;\n case 5: view = g.Uint16Array; break;\n case 6: view = g.Int32Array; break;\n case 7: view = g.Int32Array; break;\n case 8: view = g.Int32Array; break;\n case 9: view = g.Int32Array; break;\n case 10: view = g.Float32Array; break;\n case 11: view = g.Float64Array; break;\n case 12: view = g.Uint8Array; break;\n }\n if (!view) caml_invalid_argument(\"Bigarray.create: unsupported kind\");\n var data = new view(size * caml_ba_get_size_per_element(kind));\n return data;\n}\n\n//Provides: caml_ba_custom_name\n//Version: < 4.11\nvar caml_ba_custom_name = \"_bigarray\"\n\n//Provides: caml_ba_custom_name\n//Version: >= 4.11\nvar caml_ba_custom_name = \"_bigarr02\"\n\n//Provides: Ml_Bigarray\n//Requires: caml_array_bound_error, caml_invalid_argument, caml_ba_custom_name\n//Requires: caml_int64_create_lo_hi, caml_int64_hi32, caml_int64_lo32\nfunction Ml_Bigarray (kind, layout, dims, buffer) {\n\n this.kind = kind ;\n this.layout = layout;\n this.dims = dims;\n this.data = buffer;\n}\n\nMl_Bigarray.prototype.caml_custom = caml_ba_custom_name;\n\nMl_Bigarray.prototype.offset = function (arg) {\n var ofs = 0;\n if(typeof arg === \"number\") arg = [arg];\n if (! (arg instanceof Array)) caml_invalid_argument(\"bigarray.js: invalid offset\");\n if (this.dims.length != arg.length)\n caml_invalid_argument(\"Bigarray.get/set: bad number of dimensions\");\n if(this.layout == 0 /* c_layout */) {\n for (var i = 0; i < this.dims.length; i++) {\n if (arg[i] < 0 || arg[i] >= this.dims[i])\n caml_array_bound_error();\n ofs = (ofs * this.dims[i]) + arg[i];\n }\n } else {\n for (var i = this.dims.length - 1; i >= 0; i--) {\n if (arg[i] < 1 || arg[i] > this.dims[i]){\n caml_array_bound_error();\n }\n ofs = (ofs * this.dims[i]) + (arg[i] - 1);\n }\n }\n return ofs;\n}\n\nMl_Bigarray.prototype.get = function (ofs) {\n switch(this.kind){\n case 7:\n // Int64\n var l = this.data[ofs * 2 + 0];\n var h = this.data[ofs * 2 + 1];\n return caml_int64_create_lo_hi(l,h);\n case 10: case 11:\n // Complex32, Complex64\n var r = this.data[ofs * 2 + 0];\n var i = this.data[ofs * 2 + 1];\n return [254, r, i];\n default:\n return this.data[ofs]\n }\n}\n\nMl_Bigarray.prototype.set = function (ofs,v) {\n switch(this.kind){\n case 7:\n // Int64\n this.data[ofs * 2 + 0] = caml_int64_lo32(v);\n this.data[ofs * 2 + 1] = caml_int64_hi32(v);\n break;\n case 10: case 11:\n // Complex32, Complex64\n this.data[ofs * 2 + 0] = v[1];\n this.data[ofs * 2 + 1] = v[2];\n break;\n default:\n this.data[ofs] = v;\n break;\n }\n return 0\n}\n\n\nMl_Bigarray.prototype.fill = function (v) {\n switch(this.kind){\n case 7:\n // Int64\n var a = caml_int64_lo32(v);\n var b = caml_int64_hi32(v);\n if(a == b){\n this.data.fill(a);\n }\n else {\n for(var i = 0; i y)\n return 1;\n if (x != y) {\n if (!total) return NaN;\n if (x == x) return 1;\n if (y == y) return -1;\n }\n }\n break;\n case 7:\n // Int64\n for (var i = 0; i < this.data.length; i+=2) {\n // Check highest bits first\n if (this.data[i+1] < b.data[i+1])\n return -1;\n if (this.data[i+1] > b.data[i+1])\n return 1;\n if ((this.data[i] >>> 0) < (b.data[i] >>> 0))\n return -1;\n if ((this.data[i] >>> 0) > (b.data[i] >>> 0))\n return 1;\n }\n break;\n case 2:\n case 3:\n case 4:\n case 5:\n case 6:\n case 8:\n case 9:\n case 12:\n for (var i = 0; i < this.data.length; i++) {\n if (this.data[i] < b.data[i])\n return -1;\n if (this.data[i] > b.data[i])\n return 1;\n }\n break;\n }\n return 0;\n}\n\n//Provides: Ml_Bigarray_c_1_1\n//Requires: Ml_Bigarray, caml_array_bound_error, caml_invalid_argument\nfunction Ml_Bigarray_c_1_1(kind, layout, dims, buffer) {\n this.kind = kind ;\n this.layout = layout;\n this.dims = dims;\n this.data = buffer;\n}\n\nMl_Bigarray_c_1_1.prototype = new Ml_Bigarray()\nMl_Bigarray_c_1_1.prototype.offset = function (arg) {\n if(typeof arg !== \"number\"){\n if((arg instanceof Array) && arg.length == 1)\n arg = arg[0];\n else caml_invalid_argument(\"Ml_Bigarray_c_1_1.offset\");\n }\n if (arg < 0 || arg >= this.dims[0])\n caml_array_bound_error();\n return arg;\n}\n\nMl_Bigarray_c_1_1.prototype.get = function (ofs) {\n return this.data[ofs];\n}\n\nMl_Bigarray_c_1_1.prototype.set = function (ofs,v) {\n this.data[ofs] = v;\n return 0\n}\n\nMl_Bigarray_c_1_1.prototype.fill = function (v) {\n this.data.fill(v);\n return 0\n}\n\n//Provides: caml_ba_compare\nfunction caml_ba_compare(a,b,total){\n return a.compare(b,total)\n}\n\n//Provides: caml_ba_create_unsafe\n//Requires: Ml_Bigarray, Ml_Bigarray_c_1_1, caml_ba_get_size, caml_ba_get_size_per_element\n//Requires: caml_invalid_argument\nfunction caml_ba_create_unsafe(kind, layout, dims, data){\n var size_per_element = caml_ba_get_size_per_element(kind);\n if(caml_ba_get_size(dims) * size_per_element != data.length) {\n caml_invalid_argument(\"length doesn't match dims\");\n }\n if(layout == 0 && // c_layout\n dims.length == 1 && // Array1\n size_per_element == 1) // 1-to-1 mapping\n return new Ml_Bigarray_c_1_1(kind, layout, dims, data);\n return new Ml_Bigarray(kind, layout, dims, data);\n\n}\n\n\n//Provides: caml_ba_create\n//Requires: caml_js_from_array\n//Requires: caml_ba_get_size, caml_ba_create_unsafe\n//Requires: caml_ba_create_buffer\nfunction caml_ba_create(kind, layout, dims_ml) {\n var dims = caml_js_from_array(dims_ml);\n var data = caml_ba_create_buffer(kind, caml_ba_get_size(dims));\n return caml_ba_create_unsafe(kind, layout, dims, data);\n}\n\n//Provides: caml_ba_change_layout\n//Requires: caml_ba_create_unsafe\nfunction caml_ba_change_layout(ba, layout) {\n if(ba.layout == layout) return ba;\n var new_dims = []\n for(var i = 0; i < ba.dims.length; i++) new_dims[i] = ba.dims[ba.dims.length - i - 1];\n return caml_ba_create_unsafe(ba.kind, layout, new_dims, ba.data);\n}\n\n//Provides: caml_ba_kind\nfunction caml_ba_kind(ba) {\n return ba.kind;\n}\n\n//Provides: caml_ba_layout\nfunction caml_ba_layout(ba) {\n return ba.layout;\n}\n\n//Provides: caml_ba_num_dims\nfunction caml_ba_num_dims(ba) {\n return ba.dims.length;\n}\n\n//Provides: caml_ba_dim\n//Requires: caml_invalid_argument\nfunction caml_ba_dim(ba, i) {\n if (i < 0 || i >= ba.dims.length)\n caml_invalid_argument(\"Bigarray.dim\");\n return ba.dims[i];\n}\n\n//Provides: caml_ba_dim_1\n//Requires: caml_ba_dim\nfunction caml_ba_dim_1(ba) {\n return caml_ba_dim(ba, 0);\n}\n\n//Provides: caml_ba_dim_2\n//Requires: caml_ba_dim\nfunction caml_ba_dim_2(ba) {\n return caml_ba_dim(ba, 1);\n}\n\n//Provides: caml_ba_dim_3\n//Requires: caml_ba_dim\nfunction caml_ba_dim_3(ba) {\n return caml_ba_dim(ba, 2);\n}\n\n//Provides: caml_ba_get_generic\n//Requires: caml_js_from_array\nfunction caml_ba_get_generic(ba, i) {\n var ofs = ba.offset(caml_js_from_array(i));\n return ba.get(ofs);\n}\n\n//Provides: caml_ba_uint8_get16\n//Requires: caml_array_bound_error\nfunction caml_ba_uint8_get16(ba, i0) {\n var ofs = ba.offset(i0);\n if(ofs + 1 >= ba.data.length) caml_array_bound_error();\n var b1 = ba.get(ofs);\n var b2 = ba.get(ofs + 1);\n return (b1 | (b2 << 8));\n}\n\n//Provides: caml_ba_uint8_get32\n//Requires: caml_array_bound_error\nfunction caml_ba_uint8_get32(ba, i0) {\n var ofs = ba.offset(i0);\n if(ofs + 3 >= ba.data.length) caml_array_bound_error();\n var b1 = ba.get(ofs+0);\n var b2 = ba.get(ofs+1);\n var b3 = ba.get(ofs+2);\n var b4 = ba.get(ofs+3);\n return ( (b1 << 0) |\n (b2 << 8) |\n (b3 << 16) |\n (b4 << 24) );\n}\n\n//Provides: caml_ba_uint8_get64\n//Requires: caml_array_bound_error, caml_int64_of_bytes\nfunction caml_ba_uint8_get64(ba, i0) {\n var ofs = ba.offset(i0);\n if(ofs + 7 >= ba.data.length) caml_array_bound_error();\n var b1 = ba.get(ofs+0);\n var b2 = ba.get(ofs+1);\n var b3 = ba.get(ofs+2);\n var b4 = ba.get(ofs+3);\n var b5 = ba.get(ofs+4);\n var b6 = ba.get(ofs+5);\n var b7 = ba.get(ofs+6);\n var b8 = ba.get(ofs+7);\n return caml_int64_of_bytes([b8,b7,b6,b5,b4,b3,b2,b1]);\n}\n\n//Provides: caml_ba_get_1\nfunction caml_ba_get_1(ba, i0) {\n return ba.get(ba.offset(i0));\n}\n\n//Provides: caml_ba_get_2\nfunction caml_ba_get_2(ba, i0, i1) {\n return ba.get(ba.offset([i0,i1]));\n}\n\n//Provides: caml_ba_get_3\nfunction caml_ba_get_3(ba, i0, i1, i2) {\n return ba.get(ba.offset([i0,i1,i2]));\n}\n\n//Provides: caml_ba_set_generic\n//Requires: caml_js_from_array\nfunction caml_ba_set_generic(ba, i, v) {\n ba.set(ba.offset(caml_js_from_array(i)), v);\n return 0\n}\n\n//Provides: caml_ba_uint8_set16\n//Requires: caml_array_bound_error\nfunction caml_ba_uint8_set16(ba, i0, v) {\n var ofs = ba.offset(i0);\n if(ofs + 1 >= ba.data.length) caml_array_bound_error();\n ba.set(ofs+0, v & 0xff);\n ba.set(ofs+1, (v >>> 8) & 0xff);\n return 0;\n}\n\n//Provides: caml_ba_uint8_set32\n//Requires: caml_array_bound_error\nfunction caml_ba_uint8_set32(ba, i0, v) {\n var ofs = ba.offset(i0);\n if(ofs + 3 >= ba.data.length) caml_array_bound_error();\n ba.set(ofs+0, v & 0xff);\n ba.set(ofs+1, (v >>> 8) & 0xff);\n ba.set(ofs+2, (v >>> 16) & 0xff);\n ba.set(ofs+3, (v >>> 24) & 0xff);\n return 0;\n}\n\n//Provides: caml_ba_uint8_set64\n//Requires: caml_array_bound_error, caml_int64_to_bytes\nfunction caml_ba_uint8_set64(ba, i0, v) {\n var ofs = ba.offset(i0);\n if(ofs + 7 >= ba.data.length) caml_array_bound_error();\n var v = caml_int64_to_bytes(v);\n for(var i = 0; i < 8; i++) ba.set(ofs+i, v[7-i])\n return 0;\n}\n\n//Provides: caml_ba_set_1\nfunction caml_ba_set_1(ba, i0, v) {\n ba.set(ba.offset(i0), v);\n return 0\n}\n\n//Provides: caml_ba_set_2\nfunction caml_ba_set_2(ba, i0, i1, v) {\n ba.set(ba.offset([i0,i1]), v);\n return 0;\n}\n\n//Provides: caml_ba_set_3\nfunction caml_ba_set_3(ba, i0, i1, i2, v) {\n ba.set(ba.offset([i0,i1,i2]), v);\n return 0;\n}\n\n//Provides: caml_ba_fill\nfunction caml_ba_fill(ba, v) {\n ba.fill(v);\n return 0;\n}\n\n//Provides: caml_ba_blit\n//Requires: caml_invalid_argument\nfunction caml_ba_blit(src, dst) {\n if (dst.dims.length != src.dims.length)\n caml_invalid_argument(\"Bigarray.blit: dimension mismatch\");\n for (var i = 0; i < dst.dims.length; i++)\n if (dst.dims[i] != src.dims[i])\n caml_invalid_argument(\"Bigarray.blit: dimension mismatch\");\n dst.data.set(src.data);\n return 0;\n}\n\n//Provides: caml_ba_sub\n//Requires: caml_invalid_argument, caml_ba_create_unsafe, caml_ba_get_size\n//Requires: caml_ba_get_size_per_element\nfunction caml_ba_sub(ba, ofs, len) {\n var changed_dim;\n var mul = 1;\n if (ba.layout == 0) {\n for (var i = 1; i < ba.dims.length; i++)\n mul = mul * ba.dims[i];\n changed_dim = 0;\n } else {\n for (var i = 0; i < (ba.dims.length - 1); i++)\n mul = mul * ba.dims[i];\n changed_dim = ba.dims.length - 1;\n ofs = ofs - 1;\n }\n if (ofs < 0 || len < 0 || (ofs + len) > ba.dims[changed_dim]){\n caml_invalid_argument(\"Bigarray.sub: bad sub-array\");\n }\n var new_dims = [];\n for (var i = 0; i < ba.dims.length; i++)\n new_dims[i] = ba.dims[i];\n new_dims[changed_dim] = len;\n mul *= caml_ba_get_size_per_element(ba.kind);\n var new_data = ba.data.subarray(ofs * mul, (ofs + len) * mul);\n return caml_ba_create_unsafe(ba.kind, ba.layout, new_dims, new_data);\n}\n\n//Provides: caml_ba_slice\n//Requires: caml_js_from_array, caml_ba_create_unsafe, caml_invalid_argument, caml_ba_get_size\n//Requires: caml_ba_get_size_per_element\nfunction caml_ba_slice(ba, vind) {\n vind = caml_js_from_array(vind);\n var num_inds = vind.length;\n var index = [];\n var sub_dims = [];\n var ofs;\n\n if (num_inds > ba.dims.length)\n caml_invalid_argument(\"Bigarray.slice: too many indices\");\n\n // Compute offset and check bounds\n if (ba.layout == 0) {\n for (var i = 0; i < num_inds; i++)\n index[i] = vind[i];\n for (; i < ba.dims.length; i++)\n index[i] = 0;\n sub_dims = ba.dims.slice(num_inds);\n } else {\n for (var i = 0; i < num_inds; i++)\n index[ba.dims.length - num_inds + i] = vind[i];\n for (var i = 0; i < ba.dims.length - num_inds; i++)\n index[i] = 1;\n sub_dims = ba.dims.slice(0, ba.dims.length - num_inds);\n }\n ofs = ba.offset(index);\n var size = caml_ba_get_size(sub_dims);\n var size_per_element = caml_ba_get_size_per_element(ba.kind);\n var new_data = ba.data.subarray(ofs * size_per_element, (ofs + size) * size_per_element);\n return caml_ba_create_unsafe(ba.kind, ba.layout, sub_dims, new_data);\n}\n\n//Provides: caml_ba_reshape\n//Requires: caml_js_from_array, caml_invalid_argument, caml_ba_create_unsafe, caml_ba_get_size\nfunction caml_ba_reshape(ba, vind) {\n vind = caml_js_from_array(vind);\n var new_dim = [];\n var num_dims = vind.length;\n\n if (num_dims < 0 || num_dims > 16){\n caml_invalid_argument(\"Bigarray.reshape: bad number of dimensions\");\n }\n var num_elts = 1;\n for (var i = 0; i < num_dims; i++) {\n new_dim[i] = vind[i];\n if (new_dim[i] < 0)\n caml_invalid_argument(\"Bigarray.reshape: negative dimension\");\n num_elts = num_elts * new_dim[i];\n }\n\n var size = caml_ba_get_size(ba.dims);\n // Check that sizes agree\n if (num_elts != size)\n caml_invalid_argument(\"Bigarray.reshape: size mismatch\");\n return caml_ba_create_unsafe(ba.kind, ba.layout, new_dim, ba.data);\n}\n\n//Provides: caml_ba_serialize\n//Requires: caml_int64_bits_of_float, caml_int64_to_bytes\n//Requires: caml_int32_bits_of_float\nfunction caml_ba_serialize(writer, ba, sz) {\n writer.write(32, ba.dims.length);\n writer.write(32, (ba.kind | (ba.layout << 8)));\n if(ba.caml_custom == \"_bigarr02\")\n for(var i = 0; i < ba.dims.length; i++) {\n if(ba.dims[i] < 0xffff)\n writer.write(16, ba.dims[i]);\n else {\n writer.write(16, 0xffff);\n writer.write(32, 0);\n writer.write(32, ba.dims[i]);\n }\n }\n else\n for(var i = 0; i < ba.dims.length; i++) writer.write(32,ba.dims[i])\n switch(ba.kind){\n case 2: //Int8Array\n case 3: //Uint8Array\n case 12: //Uint8Array\n for(var i = 0; i < ba.data.length; i++){\n writer.write(8, ba.data[i]);\n }\n break;\n case 4: // Int16Array\n case 5: // Uint16Array\n for(var i = 0; i < ba.data.length; i++){\n writer.write(16, ba.data[i]);\n }\n break;\n case 6: // Int32Array (int32)\n for(var i = 0; i < ba.data.length; i++){\n writer.write(32, ba.data[i]);\n }\n break;\n case 8: // Int32Array (int)\n case 9: // Int32Array (nativeint)\n writer.write(8,0);\n for(var i = 0; i < ba.data.length; i++){\n writer.write(32, ba.data[i]);\n }\n break;\n case 7: // Int32Array (int64)\n for(var i = 0; i < ba.data.length / 2; i++){\n var b = caml_int64_to_bytes(ba.get(i));\n for (var j = 0; j < 8; j++) writer.write (8, b[j]);\n }\n break;\n case 1: // Float64Array\n for(var i = 0; i < ba.data.length; i++){\n var b = caml_int64_to_bytes(caml_int64_bits_of_float(ba.get(i)));\n for (var j = 0; j < 8; j++) writer.write (8, b[j]);\n }\n break;\n case 0: // Float32Array\n for(var i = 0; i < ba.data.length; i++){\n var b = caml_int32_bits_of_float(ba.get(i));\n writer.write(32, b);\n }\n break;\n case 10: // Float32Array (complex32)\n for(var i = 0; i < ba.data.length / 2; i++){\n var j = ba.get(i);\n writer.write(32, caml_int32_bits_of_float(j[1]));\n writer.write(32, caml_int32_bits_of_float(j[2]));\n }\n break;\n case 11: // Float64Array (complex64)\n for(var i = 0; i < ba.data.length / 2; i++){\n var complex = ba.get(i);\n var b = caml_int64_to_bytes(caml_int64_bits_of_float(complex[1]));\n for (var j = 0; j < 8; j++) writer.write (8, b[j]);\n var b = caml_int64_to_bytes(caml_int64_bits_of_float(complex[2]));\n for (var j = 0; j < 8; j++) writer.write (8, b[j]);\n }\n break;\n }\n sz[0] = (4 + ba.dims.length) * 4;\n sz[1] = (4 + ba.dims.length) * 8;\n}\n\n//Provides: caml_ba_deserialize\n//Requires: caml_ba_create_unsafe, caml_failwith\n//Requires: caml_ba_get_size\n//Requires: caml_int64_of_bytes, caml_int64_float_of_bits\n//Requires: caml_int32_float_of_bits\n//Requires: caml_ba_create_buffer\nfunction caml_ba_deserialize(reader, sz, name){\n var num_dims = reader.read32s();\n if (num_dims < 0 || num_dims > 16)\n caml_failwith(\"input_value: wrong number of bigarray dimensions\");\n var tag = reader.read32s();\n var kind = tag & 0xff\n var layout = (tag >> 8) & 1;\n var dims = []\n if(name == \"_bigarr02\")\n for (var i = 0; i < num_dims; i++) {\n var size_dim = reader.read16u();\n if(size_dim == 0xffff){\n var size_dim_hi = reader.read32u();\n var size_dim_lo = reader.read32u();\n if(size_dim_hi != 0)\n caml_failwith(\"input_value: bigarray dimension overflow in 32bit\");\n size_dim = size_dim_lo;\n }\n dims.push(size_dim);\n }\n else\n for (var i = 0; i < num_dims; i++) dims.push(reader.read32u());\n var size = caml_ba_get_size(dims);\n var data = caml_ba_create_buffer(kind, size);\n var ba = caml_ba_create_unsafe(kind, layout, dims, data);\n switch(kind){\n case 2: //Int8Array\n for(var i = 0; i < size; i++){\n data[i] = reader.read8s();\n }\n break;\n case 3: //Uint8Array\n case 12: //Uint8Array\n for(var i = 0; i < size; i++){\n data[i] = reader.read8u();\n }\n break;\n case 4: // Int16Array\n for(var i = 0; i < size; i++){\n data[i] = reader.read16s();\n }\n break;\n case 5: // Uint16Array\n for(var i = 0; i < size; i++){\n data[i] = reader.read16u();\n }\n break;\n case 6: // Int32Array (int32)\n for(var i = 0; i < size; i++){\n data[i] = reader.read32s();\n }\n break;\n case 8: // Int32Array (int)\n case 9: // Int32Array (nativeint)\n var sixty = reader.read8u();\n if(sixty) caml_failwith(\"input_value: cannot read bigarray with 64-bit OCaml ints\");\n for(var i = 0; i < size; i++){\n data[i] = reader.read32s();\n }\n break;\n case 7: // (int64)\n var t = new Array(8);;\n for(var i = 0; i < size; i++){\n for (var j = 0;j < 8;j++) t[j] = reader.read8u();\n var int64 = caml_int64_of_bytes(t);\n ba.set(i,int64);\n }\n break;\n case 1: // Float64Array\n var t = new Array(8);;\n for(var i = 0; i < size; i++){\n for (var j = 0;j < 8;j++) t[j] = reader.read8u();\n var f = caml_int64_float_of_bits(caml_int64_of_bytes(t));\n ba.set(i,f);\n }\n break;\n case 0: // Float32Array\n for(var i = 0; i < size; i++){\n var f = caml_int32_float_of_bits(reader.read32s());\n ba.set(i,f);\n }\n break;\n case 10: // Float32Array (complex32)\n for(var i = 0; i < size; i++){\n var re = caml_int32_float_of_bits(reader.read32s());\n var im = caml_int32_float_of_bits(reader.read32s());\n ba.set(i,[254,re,im]);\n }\n break;\n case 11: // Float64Array (complex64)\n var t = new Array(8);;\n for(var i = 0; i < size; i++){\n for (var j = 0;j < 8;j++) t[j] = reader.read8u();\n var re = caml_int64_float_of_bits(caml_int64_of_bytes(t));\n for (var j = 0;j < 8;j++) t[j] = reader.read8u();\n var im = caml_int64_float_of_bits(caml_int64_of_bytes(t));\n ba.set(i,[254,re,im]);\n }\n break\n }\n sz[0] = (4 + num_dims) * 4;\n return caml_ba_create_unsafe(kind, layout, dims, data);\n}\n\n//Deprecated\n//Provides: caml_ba_create_from\n//Requires: caml_ba_create_unsafe, caml_invalid_argument, caml_ba_get_size_per_element\nfunction caml_ba_create_from(data1, data2, jstyp, kind, layout, dims){\n if(data2 || caml_ba_get_size_per_element(kind) == 2){\n caml_invalid_argument(\"caml_ba_create_from: use return caml_ba_create_unsafe\");\n }\n return caml_ba_create_unsafe(kind, layout, dims, data1);\n}\n\n//Provides: caml_ba_hash const\n//Requires: caml_ba_get_size, caml_hash_mix_int, caml_hash_mix_float\nfunction caml_ba_hash(ba){\n var num_elts = caml_ba_get_size(ba.dims);\n var h = 0;\n switch(ba.kind){\n case 2: //Int8Array\n case 3: //Uint8Array\n case 12: //Uint8Array\n if(num_elts > 256) num_elts = 256;\n var w = 0, i =0;\n for(i = 0; i + 4 <= ba.data.length; i+=4){\n w = ba.data[i+0] | (ba.data[i+1] << 8) | (ba.data[i+2] << 16) | (ba.data[i+3] << 24);\n h = caml_hash_mix_int(h,w);\n }\n w = 0;\n switch (num_elts & 3) {\n case 3: w = ba.data[i+2] << 16; /* fallthrough */\n case 2: w |= ba.data[i+1] << 8; /* fallthrough */\n case 1: w |= ba.data[i+0];\n h = caml_hash_mix_int(h, w);\n }\n break;\n case 4: // Int16Array\n case 5: // Uint16Array\n if(num_elts > 128) num_elts = 128;\n var w = 0, i =0;\n for(i = 0; i + 2 <= ba.data.length; i+=2){\n w = ba.data[i+0] | (ba.data[i+1] << 16);\n h = caml_hash_mix_int(h,w);\n }\n if ((num_elts & 1) != 0)\n h = caml_hash_mix_int(h, ba.data[i]);\n break;\n case 6: // Int32Array (int32)\n if (num_elts > 64) num_elts = 64;\n for (var i = 0; i < num_elts; i++) h = caml_hash_mix_int(h, ba.data[i]);\n break;\n case 8: // Int32Array (int)\n case 9: // Int32Array (nativeint)\n if (num_elts > 64) num_elts = 64;\n for (var i = 0; i < num_elts; i++) h = caml_hash_mix_int(h, ba.data[i]);\n break;\n case 7: // Int32Array (int64)\n if (num_elts > 32) num_elts = 32;\n num_elts *= 2\n for (var i = 0; i < num_elts; i++) {\n h = caml_hash_mix_int(h, ba.data[i]);\n }\n break;\n case 10: // Float32Array (complex32)\n num_elts *=2; /* fallthrough */\n case 0: // Float32Array\n if (num_elts > 64) num_elts = 64;\n for (var i = 0; i < num_elts; i++) h = caml_hash_mix_float(h, ba.data[i]);\n break;\n case 11: // Float64Array (complex64)\n num_elts *=2; /* fallthrough */\n case 1: // Float64Array\n if (num_elts > 32) num_elts = 32;\n for (var i = 0; i < num_elts; i++) h = caml_hash_mix_float(h, ba.data[i]);\n break;\n }\n return h;\n}\n\n//Provides: caml_ba_to_typed_array mutable\nfunction caml_ba_to_typed_array(ba){\n return ba.data;\n}\n\n//Provides: caml_ba_kind_of_typed_array mutable\n//Requires: caml_invalid_argument\nfunction caml_ba_kind_of_typed_array(ta){\n var g = globalThis;\n var kind;\n if (ta instanceof g.Float32Array) kind = 0;\n else if (ta instanceof g.Float64Array) kind = 1;\n else if (ta instanceof g.Int8Array) kind = 2;\n else if (ta instanceof g.Uint8Array) kind = 3;\n else if (ta instanceof g.Int16Array) kind = 4;\n else if (ta instanceof g.Uint16Array) kind = 5;\n else if (ta instanceof g.Int32Array) kind = 6;\n else if (ta instanceof g.Uint32Array) kind = 6;\n else caml_invalid_argument(\"caml_ba_kind_of_typed_array: unsupported kind\");\n return kind;\n}\n\n//Provides: caml_ba_from_typed_array mutable\n//Requires: caml_ba_kind_of_typed_array\n//Requires: caml_ba_create_unsafe\nfunction caml_ba_from_typed_array(ta){\n var kind = caml_ba_kind_of_typed_array(ta);\n return caml_ba_create_unsafe(kind, 0, [ta.length], ta);\n}\n","/* global joo_global_object\n */\n\n//Provides: caml_raise_with_string (const, const)\nfunction caml_raise_with_string(tag, msg) {\n throw globalThis.Error(msg.c);\n}\n\n//Provides: custom_reraise_exn\nfunction custom_reraise_exn(exn, fallbackMessage) {\n // this handles the common case of a JS Error reraised by OCaml\n // in that case, the error will first be wrapped in OCaml with \"caml_wrap_exception\"\n // (defined in js_of_ocaml-compiler / jslib.js)\n // which results in [0, caml_named_value(\"jsError\"), err]\n var err = exn[2];\n if (err instanceof globalThis.Error) {\n throw err;\n } else {\n throw Error(fallbackMessage);\n }\n}\n\n/**\n * This overrides the handler for uncaught exceptions in js_of_ocaml,\n * fixing the flaw that by default, no actual `Error`s are thrown,\n * but other objects (arrays) which are missing an error trace.\n * This override should make it much easier to find the source of an error.\n */\n//Provides: caml_fatal_uncaught_exception\nfunction caml_fatal_uncaught_exception(err) {\n // first, we search for an actual error inside `err`,\n // since this is the best thing to throw\n function throw_errors(err) {\n if (err instanceof Error) throw err;\n else if (Array.isArray(err)) {\n err.forEach(throw_errors);\n }\n }\n throw_errors(err);\n // if this didn't throw an error, let's log whatever we got\n console.dir(err, { depth: 20 });\n // now, try to collect all strings in the error and throw that\n function collect_strings(err, acc) {\n var str = undefined;\n if (typeof err === 'string') {\n str = err;\n } else if (err && err.constructor && err.constructor.name === 'MlBytes') {\n str = err.c;\n } else if (Array.isArray(err)) {\n err.forEach(function (e) {\n collect_strings(e, acc);\n });\n }\n if (!str) return acc.string;\n if (acc.string === undefined) acc.string = str;\n else acc.string = acc.string + '\\n' + str;\n return acc.string;\n }\n var str = collect_strings(err, {});\n if (str !== undefined) throw joo_global_object.Error(str);\n // otherwise, just throw an unhelpful error\n console.dir(err, { depth: 10 });\n throw joo_global_object.Error('Unknown error thrown from OCaml');\n}\n","// Js_of_ocaml runtime support\n// http://www.ocsigen.org/js_of_ocaml/\n// Copyright (C) 2010 Jérôme Vouillon\n// Laboratoire PPS - CNRS Université Paris Diderot\n//\n// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU Lesser General Public License as published by\n// the Free Software Foundation, with linking exception;\n// either version 2.1 of the License, or (at your option) any later version.\n//\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n// GNU Lesser General Public License for more details.\n//\n// You should have received a copy of the GNU Lesser General Public License\n// along with this program; if not, write to the Free Software\n// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n\n//Provides: caml_marshal_constants\nvar caml_marshal_constants = {\n PREFIX_SMALL_BLOCK: 0x80,\n PREFIX_SMALL_INT: 0x40,\n PREFIX_SMALL_STRING: 0x20,\n CODE_INT8: 0x00,\n CODE_INT16: 0x01,\n CODE_INT32: 0x02,\n CODE_INT64: 0x03,\n CODE_SHARED8: 0x04,\n CODE_SHARED16: 0x05,\n CODE_SHARED32: 0x06,\n CODE_BLOCK32: 0x08,\n CODE_BLOCK64: 0x13,\n CODE_STRING8: 0x09,\n CODE_STRING32: 0x0A,\n CODE_DOUBLE_BIG: 0x0B,\n CODE_DOUBLE_LITTLE: 0x0C,\n CODE_DOUBLE_ARRAY8_BIG: 0x0D,\n CODE_DOUBLE_ARRAY8_LITTLE: 0x0E,\n CODE_DOUBLE_ARRAY32_BIG: 0x0F,\n CODE_DOUBLE_ARRAY32_LITTLE: 0x07,\n CODE_CODEPOINTER: 0x10,\n CODE_INFIXPOINTER: 0x11,\n CODE_CUSTOM: 0x12,\n CODE_CUSTOM_LEN: 0x18,\n CODE_CUSTOM_FIXED: 0x19\n}\n\n\n//Provides: MlStringReader\n//Requires: caml_string_of_jsbytes, caml_jsbytes_of_string\nfunction MlStringReader (s, i) { this.s = caml_jsbytes_of_string(s); this.i = i; }\nMlStringReader.prototype = {\n read8u:function () { return this.s.charCodeAt(this.i++); },\n read8s:function () { return this.s.charCodeAt(this.i++) << 24 >> 24; },\n read16u:function () {\n var s = this.s, i = this.i;\n this.i = i + 2;\n return (s.charCodeAt(i) << 8) | s.charCodeAt(i + 1)\n },\n read16s:function () {\n var s = this.s, i = this.i;\n this.i = i + 2;\n return (s.charCodeAt(i) << 24 >> 16) | s.charCodeAt(i + 1);\n },\n read32u:function () {\n var s = this.s, i = this.i;\n this.i = i + 4;\n return ((s.charCodeAt(i) << 24) | (s.charCodeAt(i+1) << 16) |\n (s.charCodeAt(i+2) << 8) | s.charCodeAt(i+3)) >>> 0;\n },\n read32s:function () {\n var s = this.s, i = this.i;\n this.i = i + 4;\n return (s.charCodeAt(i) << 24) | (s.charCodeAt(i+1) << 16) |\n (s.charCodeAt(i+2) << 8) | s.charCodeAt(i+3);\n },\n readstr:function (len) {\n var i = this.i;\n this.i = i + len;\n return caml_string_of_jsbytes(this.s.substring(i, i + len));\n }\n}\n\n//Provides: BigStringReader\n//Requires: caml_string_of_array, caml_ba_get_1\nfunction BigStringReader (bs, i) { this.s = bs; this.i = i; }\nBigStringReader.prototype = {\n read8u:function () { return caml_ba_get_1(this.s,this.i++); },\n read8s:function () { return caml_ba_get_1(this.s,this.i++) << 24 >> 24; },\n read16u:function () {\n var s = this.s, i = this.i;\n this.i = i + 2;\n return (caml_ba_get_1(s,i) << 8) | caml_ba_get_1(s,i + 1)\n },\n read16s:function () {\n var s = this.s, i = this.i;\n this.i = i + 2;\n return (caml_ba_get_1(s,i) << 24 >> 16) | caml_ba_get_1(s,i + 1);\n },\n read32u:function () {\n var s = this.s, i = this.i;\n this.i = i + 4;\n return ((caml_ba_get_1(s,i) << 24) | (caml_ba_get_1(s,i+1) << 16) |\n (caml_ba_get_1(s,i+2) << 8) | caml_ba_get_1(s,i+3) ) >>> 0;\n },\n read32s:function () {\n var s = this.s, i = this.i;\n this.i = i + 4;\n return (caml_ba_get_1(s,i) << 24) | (caml_ba_get_1(s,i+1) << 16) |\n (caml_ba_get_1(s,i+2) << 8) | caml_ba_get_1(s,i+3);\n },\n readstr:function (len) {\n var i = this.i;\n var arr = new Array(len)\n for(var j = 0; j < len; j++){\n arr[j] = caml_ba_get_1(this.s, i+j);\n }\n this.i = i + len;\n return caml_string_of_array(arr);\n }\n}\n\n\n\n//Provides: caml_float_of_bytes\n//Requires: caml_int64_float_of_bits, caml_int64_of_bytes\nfunction caml_float_of_bytes (a) {\n return caml_int64_float_of_bits (caml_int64_of_bytes (a));\n}\n\n//Provides: caml_input_value_from_string mutable\n//Requires: MlStringReader, caml_input_value_from_reader\nfunction caml_input_value_from_string(s,ofs) {\n var reader = new MlStringReader (s, typeof ofs==\"number\"?ofs:ofs[0]);\n return caml_input_value_from_reader(reader, ofs)\n}\n\n//Provides: caml_input_value_from_bytes mutable\n//Requires: MlStringReader, caml_input_value_from_reader, caml_string_of_bytes\nfunction caml_input_value_from_bytes(s,ofs) {\n var reader = new MlStringReader (caml_string_of_bytes(s), typeof ofs==\"number\"?ofs:ofs[0]);\n return caml_input_value_from_reader(reader, ofs)\n}\n\n//Provides: caml_int64_unmarshal\n//Requires: caml_int64_of_bytes\nfunction caml_int64_unmarshal(reader, size){\n var t = new Array(8);;\n for (var j = 0;j < 8;j++) t[j] = reader.read8u();\n size[0] = 8;\n return caml_int64_of_bytes (t);\n}\n\n//Provides: caml_int64_marshal\n//Requires: caml_int64_to_bytes\nfunction caml_int64_marshal(writer, v, sizes) {\n var b = caml_int64_to_bytes (v);\n for (var i = 0; i < 8; i++) writer.write (8, b[i]);\n sizes[0] = 8; sizes[1] = 8;\n}\n\n//Provides: caml_int32_unmarshal\nfunction caml_int32_unmarshal(reader, size){\n size[0] = 4;\n return reader.read32s ();\n}\n\n//Provides: caml_nativeint_unmarshal\n//Requires: caml_failwith\nfunction caml_nativeint_unmarshal(reader, size){\n switch (reader.read8u ()) {\n case 1:\n size[0] = 4;\n return reader.read32s ();\n case 2:\n caml_failwith(\"input_value: native integer value too large\");\n default: caml_failwith(\"input_value: ill-formed native integer\");\n }\n}\n\n//Provides: caml_custom_ops\n//Requires: caml_int64_unmarshal, caml_int64_marshal, caml_int64_compare, caml_int64_hash\n//Requires: caml_int32_unmarshal, caml_nativeint_unmarshal\n//Requires: caml_ba_serialize, caml_ba_deserialize, caml_ba_compare, caml_ba_hash\nvar caml_custom_ops =\n {\"_j\": {\n deserialize : caml_int64_unmarshal,\n serialize : caml_int64_marshal,\n fixed_length : 8,\n compare : caml_int64_compare,\n hash : caml_int64_hash\n },\n \"_i\": {\n deserialize : caml_int32_unmarshal,\n fixed_length : 4,\n },\n \"_n\": {\n deserialize : caml_nativeint_unmarshal,\n fixed_length : 4,\n },\n \"_bigarray\":{\n deserialize : (function (reader, sz) {return caml_ba_deserialize (reader,sz,\"_bigarray\")}),\n serialize : caml_ba_serialize,\n compare : caml_ba_compare,\n hash: caml_ba_hash,\n },\n \"_bigarr02\":{\n deserialize : (function (reader, sz) {return caml_ba_deserialize (reader,sz,\"_bigarr02\")}),\n serialize : caml_ba_serialize,\n compare : caml_ba_compare,\n hash: caml_ba_hash,\n }\n }\n\n//Provides: caml_input_value_from_reader mutable\n//Requires: caml_failwith\n//Requires: caml_float_of_bytes, caml_custom_ops\n\nfunction caml_input_value_from_reader(reader, ofs) {\n var _magic = reader.read32u ()\n var _block_len = reader.read32u ();\n var num_objects = reader.read32u ();\n var _size_32 = reader.read32u ();\n var _size_64 = reader.read32u ();\n var stack = [];\n var intern_obj_table = (num_objects > 0)?[]:null;\n var obj_counter = 0;\n function intern_rec () {\n var code = reader.read8u ();\n if (code >= 0x40 /*cst.PREFIX_SMALL_INT*/) {\n if (code >= 0x80 /*cst.PREFIX_SMALL_BLOCK*/) {\n var tag = code & 0xF;\n var size = (code >> 4) & 0x7;\n var v = [tag];\n if (size == 0) return v;\n if (intern_obj_table) intern_obj_table[obj_counter++] = v;\n stack.push(v, size);\n return v;\n } else\n return (code & 0x3F);\n } else {\n if (code >= 0x20/*cst.PREFIX_SMALL_STRING */) {\n var len = code & 0x1F;\n var v = reader.readstr (len);\n if (intern_obj_table) intern_obj_table[obj_counter++] = v;\n return v;\n } else {\n switch(code) {\n case 0x00: //cst.CODE_INT8:\n return reader.read8s ();\n case 0x01: //cst.CODE_INT16:\n return reader.read16s ();\n case 0x02: //cst.CODE_INT32:\n return reader.read32s ();\n case 0x03: //cst.CODE_INT64:\n caml_failwith(\"input_value: integer too large\");\n break;\n case 0x04: //cst.CODE_SHARED8:\n var offset = reader.read8u ();\n return intern_obj_table[obj_counter - offset];\n case 0x05: //cst.CODE_SHARED16:\n var offset = reader.read16u ();\n return intern_obj_table[obj_counter - offset];\n case 0x06: //cst.CODE_SHARED32:\n var offset = reader.read32u ();\n return intern_obj_table[obj_counter - offset];\n case 0x08: //cst.CODE_BLOCK32:\n var header = reader.read32u ();\n var tag = header & 0xFF;\n var size = header >> 10;\n var v = [tag];\n if (size == 0) return v;\n if (intern_obj_table) intern_obj_table[obj_counter++] = v;\n stack.push(v, size);\n return v;\n case 0x13: //cst.CODE_BLOCK64:\n caml_failwith (\"input_value: data block too large\");\n break;\n case 0x09: //cst.CODE_STRING8:\n var len = reader.read8u();\n var v = reader.readstr (len);\n if (intern_obj_table) intern_obj_table[obj_counter++] = v;\n return v;\n case 0x0A: //cst.CODE_STRING32:\n var len = reader.read32u();\n var v = reader.readstr (len);\n if (intern_obj_table) intern_obj_table[obj_counter++] = v;\n return v;\n case 0x0C: //cst.CODE_DOUBLE_LITTLE:\n var t = new Array(8);;\n for (var i = 0;i < 8;i++) t[7 - i] = reader.read8u ();\n var v = caml_float_of_bytes (t);\n if (intern_obj_table) intern_obj_table[obj_counter++] = v;\n return v;\n case 0x0B: //cst.CODE_DOUBLE_BIG:\n var t = new Array(8);;\n for (var i = 0;i < 8;i++) t[i] = reader.read8u ();\n var v = caml_float_of_bytes (t);\n if (intern_obj_table) intern_obj_table[obj_counter++] = v;\n return v;\n case 0x0E: //cst.CODE_DOUBLE_ARRAY8_LITTLE:\n var len = reader.read8u();\n var v = new Array(len+1);\n v[0] = 254;\n var t = new Array(8);;\n if (intern_obj_table) intern_obj_table[obj_counter++] = v;\n for (var i = 1;i <= len;i++) {\n for (var j = 0;j < 8;j++) t[7 - j] = reader.read8u();\n v[i] = caml_float_of_bytes (t);\n }\n return v;\n case 0x0D: //cst.CODE_DOUBLE_ARRAY8_BIG:\n var len = reader.read8u();\n var v = new Array(len+1);\n v[0] = 254;\n var t = new Array(8);;\n if (intern_obj_table) intern_obj_table[obj_counter++] = v;\n for (var i = 1;i <= len;i++) {\n for (var j = 0;j < 8;j++) t[j] = reader.read8u();\n v [i] = caml_float_of_bytes (t);\n }\n return v;\n case 0x07: //cst.CODE_DOUBLE_ARRAY32_LITTLE:\n var len = reader.read32u();\n var v = new Array(len+1);\n v[0] = 254;\n if (intern_obj_table) intern_obj_table[obj_counter++] = v;\n var t = new Array(8);;\n for (var i = 1;i <= len;i++) {\n for (var j = 0;j < 8;j++) t[7 - j] = reader.read8u();\n v[i] = caml_float_of_bytes (t);\n }\n return v;\n case 0x0F: //cst.CODE_DOUBLE_ARRAY32_BIG:\n var len = reader.read32u();\n var v = new Array(len+1);\n v[0] = 254;\n var t = new Array(8);;\n for (var i = 1;i <= len;i++) {\n for (var j = 0;j < 8;j++) t[j] = reader.read8u();\n v [i] = caml_float_of_bytes (t);\n }\n return v;\n case 0x10: //cst.CODE_CODEPOINTER:\n case 0x11: //cst.CODE_INFIXPOINTER:\n caml_failwith (\"input_value: code pointer\");\n break;\n case 0x12: //cst.CODE_CUSTOM:\n case 0x18: //cst.CODE_CUSTOM_LEN:\n case 0x19: //cst.CODE_CUSTOM_FIXED:\n var c, s = \"\";\n while ((c = reader.read8u ()) != 0) s += String.fromCharCode (c);\n var ops = caml_custom_ops[s];\n var expected_size;\n if(!ops)\n caml_failwith(\"input_value: unknown custom block identifier\");\n switch(code){\n case 0x12: // cst.CODE_CUSTOM (deprecated)\n break;\n case 0x19: // cst.CODE_CUSTOM_FIXED\n if(!ops.fixed_length)\n caml_failwith(\"input_value: expected a fixed-size custom block\");\n expected_size = ops.fixed_length;\n break;\n case 0x18: // cst.CODE_CUSTOM_LEN\n expected_size = reader.read32u ();\n // Skip size64\n reader.read32s(); reader.read32s();\n break;\n }\n var old_pos = reader.i;\n var size = [0];\n var v = ops.deserialize(reader, size);\n if(expected_size != undefined){\n if(expected_size != size[0])\n caml_failwith(\"input_value: incorrect length of serialized custom block\");\n }\n if (intern_obj_table) intern_obj_table[obj_counter++] = v;\n return v;\n default:\n caml_failwith (\"input_value: ill-formed message\");\n }\n }\n }\n }\n var res = intern_rec ();\n while (stack.length > 0) {\n var size = stack.pop();\n var v = stack.pop();\n var d = v.length;\n if (d < size) stack.push(v, size);\n v[d] = intern_rec ();\n }\n if (typeof ofs!=\"number\") ofs[0] = reader.i;\n return res;\n}\n\n//Provides: caml_marshal_data_size mutable\n//Requires: caml_failwith, caml_bytes_unsafe_get\nfunction caml_marshal_data_size (s, ofs) {\n function get32(s,i) {\n return (caml_bytes_unsafe_get(s, i) << 24) |\n (caml_bytes_unsafe_get(s, i + 1) << 16) |\n (caml_bytes_unsafe_get(s, i + 2) << 8) |\n caml_bytes_unsafe_get(s, i + 3);\n }\n if (get32(s, ofs) != (0x8495A6BE|0))\n caml_failwith(\"Marshal.data_size: bad object\");\n return (get32(s, ofs + 4));\n}\n\n//Provides: MlObjectTable\nvar MlObjectTable;\nif (typeof globalThis.WeakMap === 'undefined') {\n MlObjectTable = function() {\n /* polyfill (using linear search) */\n function NaiveLookup(objs) { this.objs = objs; }\n NaiveLookup.prototype.get = function(v) {\n for (var i = 0; i < this.objs.length; i++) {\n if (this.objs[i] === v) return i;\n }\n };\n NaiveLookup.prototype.set = function() {\n // Do nothing here. [MlObjectTable.store] will push to [this.objs] directly.\n };\n\n return function MlObjectTable() {\n this.objs = []; this.lookup = new NaiveLookup(this.objs);\n };\n }();\n}\nelse {\n MlObjectTable = function MlObjectTable() {\n this.objs = []; this.lookup = new globalThis.WeakMap();\n };\n}\n\nMlObjectTable.prototype.store = function(v) {\n this.lookup.set(v, this.objs.length);\n this.objs.push(v);\n}\n\nMlObjectTable.prototype.recall = function(v) {\n var i = this.lookup.get(v);\n return (i === undefined)\n ? undefined : this.objs.length - i; /* index is relative */\n}\n\n//Provides: caml_legacy_custom_code\n//Version: >= 4.08\nvar caml_legacy_custom_code = false\n\n//Provides: caml_legacy_custom_code\n//Version: < 4.08\nvar caml_legacy_custom_code = true\n\n//Provides: caml_output_val\n//Requires: caml_int64_to_bytes, caml_failwith\n//Requires: caml_int64_bits_of_float\n//Requires: caml_is_ml_bytes, caml_ml_bytes_length, caml_bytes_unsafe_get\n//Requires: caml_is_ml_string, caml_ml_string_length, caml_string_unsafe_get\n//Requires: MlObjectTable, caml_list_to_js_array, caml_legacy_custom_code, caml_custom_ops\n//Requires: caml_invalid_argument,caml_string_of_jsbytes\nvar caml_output_val = function (){\n function Writer () { this.chunk = []; }\n Writer.prototype = {\n chunk_idx:20, block_len:0, obj_counter:0, size_32:0, size_64:0,\n write:function (size, value) {\n for (var i = size - 8;i >= 0;i -= 8)\n this.chunk[this.chunk_idx++] = (value >> i) & 0xFF;\n },\n write_at:function (pos, size, value) {\n var pos = pos;\n for (var i = size - 8;i >= 0;i -= 8)\n this.chunk[pos++] = (value >> i) & 0xFF;\n },\n write_code:function (size, code, value) {\n this.chunk[this.chunk_idx++] = code;\n for (var i = size - 8;i >= 0;i -= 8)\n this.chunk[this.chunk_idx++] = (value >> i) & 0xFF;\n },\n write_shared:function (offset) {\n if (offset < (1 << 8)) this.write_code(8, 0x04 /*cst.CODE_SHARED8*/, offset);\n else if (offset < (1 << 16)) this.write_code(16, 0x05 /*cst.CODE_SHARED16*/, offset);\n else this.write_code(32, 0x06 /*cst.CODE_SHARED32*/, offset);\n },\n pos:function () { return this.chunk_idx },\n finalize:function () {\n this.block_len = this.chunk_idx - 20;\n this.chunk_idx = 0;\n this.write (32, 0x8495A6BE);\n this.write (32, this.block_len);\n this.write (32, this.obj_counter);\n this.write (32, this.size_32);\n this.write (32, this.size_64);\n return this.chunk;\n }\n }\n return function (v, flags) {\n flags = caml_list_to_js_array(flags);\n\n var no_sharing = (flags.indexOf(0 /*Marshal.No_sharing*/) !== -1),\n closures = (flags.indexOf(1 /*Marshal.Closures*/) !== -1);\n /* Marshal.Compat_32 is redundant since integers are 32-bit anyway */\n\n if (closures)\n globalThis.console.warn(\"in caml_output_val: flag Marshal.Closures is not supported.\");\n\n var writer = new Writer ();\n var stack = [];\n var intern_obj_table = no_sharing ? null : new MlObjectTable();\n\n function memo(v) {\n if (no_sharing) return false;\n var existing_offset = intern_obj_table.recall(v);\n if (existing_offset) { writer.write_shared(existing_offset); return true; }\n else { intern_obj_table.store(v); return false; }\n }\n\n function extern_rec (v) {\n if (v.caml_custom) {\n if (memo(v)) return;\n var name = v.caml_custom;\n var ops = caml_custom_ops[name];\n var sz_32_64 = [0,0];\n if(!ops.serialize)\n caml_invalid_argument(\"output_value: abstract value (Custom)\");\n if(caml_legacy_custom_code) {\n writer.write (8, 0x12 /*cst.CODE_CUSTOM*/);\n for (var i = 0; i < name.length; i++)\n writer.write (8, name.charCodeAt(i));\n writer.write(8, 0);\n ops.serialize(writer, v, sz_32_64);\n } else if(ops.fixed_length == undefined){\n writer.write (8, 0x18 /*cst.CODE_CUSTOM_LEN*/);\n for (var i = 0; i < name.length; i++)\n writer.write (8, name.charCodeAt(i));\n writer.write(8, 0);\n var header_pos = writer.pos ();\n for(var i = 0; i < 12; i++) {\n writer.write(8, 0);\n }\n ops.serialize(writer, v, sz_32_64);\n writer.write_at(header_pos, 32, sz_32_64[0]);\n writer.write_at(header_pos + 4, 32, 0); // zero\n writer.write_at(header_pos + 8, 32, sz_32_64[1]);\n } else {\n writer.write (8, 0x19 /*cst.CODE_CUSTOM_FIXED*/);\n for (var i = 0; i < name.length; i++)\n writer.write (8, name.charCodeAt(i));\n writer.write(8, 0);\n var old_pos = writer.pos();\n ops.serialize(writer, v, sz_32_64);\n if (ops.fixed_length != writer.pos() - old_pos)\n caml_failwith(\"output_value: incorrect fixed sizes specified by \" + name);\n }\n writer.size_32 += 2 + ((sz_32_64[0] + 3) >> 2);\n writer.size_64 += 2 + ((sz_32_64[1] + 7) >> 3);\n }\n else if (v instanceof Array && v[0] === (v[0]|0)) {\n if (v[0] == 251) {\n caml_failwith(\"output_value: abstract value (Abstract)\");\n }\n if (v.length > 1 && memo(v)) return;\n if (v[0] < 16 && v.length - 1 < 8)\n writer.write (8, 0x80 /*cst.PREFIX_SMALL_BLOCK*/ + v[0] + ((v.length - 1)<<4));\n else\n writer.write_code(32, 0x08 /*cst.CODE_BLOCK32*/, ((v.length-1) << 10) | v[0]);\n writer.size_32 += v.length;\n writer.size_64 += v.length;\n if (v.length > 1) stack.push (v, 1);\n } else if (caml_is_ml_bytes(v)) {\n if(!(caml_is_ml_bytes(caml_string_of_jsbytes(\"\")))) {\n caml_failwith(\"output_value: [Bytes.t] cannot safely be marshaled with [--enable use-js-string]\");\n }\n if (memo(v)) return;\n var len = caml_ml_bytes_length(v);\n if (len < 0x20)\n writer.write (8, 0x20 /*cst.PREFIX_SMALL_STRING*/ + len);\n else if (len < 0x100)\n writer.write_code (8, 0x09/*cst.CODE_STRING8*/, len);\n else\n writer.write_code (32, 0x0A /*cst.CODE_STRING32*/, len);\n for (var i = 0;i < len;i++)\n writer.write (8, caml_bytes_unsafe_get(v,i));\n writer.size_32 += 1 + (((len + 4) / 4)|0);\n writer.size_64 += 1 + (((len + 8) / 8)|0);\n } else if (caml_is_ml_string(v)) {\n var len = caml_ml_string_length(v);\n if (len < 0x20)\n writer.write (8, 0x20 /*cst.PREFIX_SMALL_STRING*/ + len);\n else if (len < 0x100)\n writer.write_code (8, 0x09/*cst.CODE_STRING8*/, len);\n else\n writer.write_code (32, 0x0A /*cst.CODE_STRING32*/, len);\n for (var i = 0;i < len;i++)\n writer.write (8, caml_string_unsafe_get(v,i));\n writer.size_32 += 1 + (((len + 4) / 4)|0);\n writer.size_64 += 1 + (((len + 8) / 8)|0);\n } else {\n if (v != (v|0)){\n var type_of_v = typeof v;\n //\n // If a float happens to be an integer it is serialized as an integer\n // (Js_of_ocaml cannot tell whether the type of an integer number is\n // float or integer.) This can result in unexpected crashes when\n // unmarshalling using the standard runtime. It seems better to\n // systematically fail on marshalling.\n //\n // if(type_of_v != \"number\")\n caml_failwith(\"output_value: abstract value (\"+type_of_v+\")\");\n // var t = caml_int64_to_bytes(caml_int64_bits_of_float(v));\n // writer.write (8, 0x0B /*cst.CODE_DOUBLE_BIG*/);\n // for(var i = 0; i<8; i++){writer.write(8,t[i])}\n }\n else if (v >= 0 && v < 0x40) {\n writer.write (8, 0X40 /*cst.PREFIX_SMALL_INT*/ + v);\n } else {\n if (v >= -(1 << 7) && v < (1 << 7))\n writer.write_code(8, 0x00 /*cst.CODE_INT8*/, v);\n else if (v >= -(1 << 15) && v < (1 << 15))\n writer.write_code(16, 0x01 /*cst.CODE_INT16*/, v);\n else\n writer.write_code(32, 0x02 /*cst.CODE_INT32*/, v);\n }\n }\n }\n extern_rec (v);\n while (stack.length > 0) {\n var i = stack.pop ();\n var v = stack.pop ();\n if (i + 1 < v.length) stack.push (v, i + 1);\n extern_rec (v[i]);\n }\n if (intern_obj_table) writer.obj_counter = intern_obj_table.objs.length;\n writer.finalize();\n return writer.chunk;\n }\n} ();\n\n//Provides: caml_output_value_to_string mutable\n//Requires: caml_output_val, caml_string_of_array\nfunction caml_output_value_to_string (v, flags) {\n return caml_string_of_array (caml_output_val (v, flags));\n}\n\n//Provides: caml_output_value_to_bytes mutable\n//Requires: caml_output_val, caml_bytes_of_array\nfunction caml_output_value_to_bytes (v, flags) {\n return caml_bytes_of_array (caml_output_val (v, flags));\n}\n\n//Provides: caml_output_value_to_buffer\n//Requires: caml_output_val, caml_failwith, caml_blit_bytes\nfunction caml_output_value_to_buffer (s, ofs, len, v, flags) {\n var t = caml_output_val (v, flags);\n if (t.length > len) caml_failwith (\"Marshal.to_buffer: buffer overflow\");\n caml_blit_bytes(t, 0, s, ofs, t.length);\n return 0;\n}\n","//Provides: Base_internalhash_fold_int64\n//Requires: caml_hash_mix_int64\nvar Base_internalhash_fold_int64 = caml_hash_mix_int64;\n//Provides: Base_internalhash_fold_int\n//Requires: caml_hash_mix_int\nvar Base_internalhash_fold_int = caml_hash_mix_int;\n//Provides: Base_internalhash_fold_float\n//Requires: caml_hash_mix_float\nvar Base_internalhash_fold_float = caml_hash_mix_float;\n//Provides: Base_internalhash_fold_string\n//Requires: caml_hash_mix_string\nvar Base_internalhash_fold_string = caml_hash_mix_string;\n//Provides: Base_internalhash_get_hash_value\n//Requires: caml_hash_mix_final\nfunction Base_internalhash_get_hash_value(seed) {\n var h = caml_hash_mix_final(seed);\n return h & 0x3FFFFFFF;\n}\n","//Provides: initialize_nat\n//Requires: caml_custom_ops\n//Requires: serialize_nat, deserialize_nat, caml_hash_nat\nfunction initialize_nat() {\n caml_custom_ops[\"_nat\"] =\n { deserialize : deserialize_nat,\n serialize : serialize_nat,\n hash : caml_hash_nat\n }\n}\n\n//Provides: MlNat\nfunction MlNat(x){\n this.data = new globalThis.Int32Array(x);\n // length_nat isn't external, so we have to make the Obj.size\n // work out right. The +2 to array length seems to work.\n this.length = this.data.length + 2\n}\n\nMlNat.prototype.caml_custom = \"_nat\";\n\n//Provides: caml_hash_nat\n//Requires: caml_hash_mix_int, num_digits_nat\nfunction caml_hash_nat(x) {\n var len = num_digits_nat(x, 0, x.data.length);\n var h = 0;\n for (var i = 0; i < len; i++) {\n h = caml_hash_mix_int(h, x.data[i]);\n }\n return h;\n}\n\n\n//Provides: nat_of_array\n//Requires: MlNat\nfunction nat_of_array(l){\n return new MlNat(l);\n}\n\n//Provides: create_nat\n//Requires: MlNat\nfunction create_nat(size) {\n var arr = new MlNat(size);\n for(var i = 0; i < size; i++) {\n arr.data[i] = -1;\n }\n return arr;\n}\n\n//Provides: set_to_zero_nat\nfunction set_to_zero_nat(nat, ofs, len) {\n for(var i = 0; i < len; i++) {\n nat.data[ofs+i] = 0;\n }\n return 0;\n}\n\n//Provides: blit_nat\nfunction blit_nat(nat1, ofs1, nat2, ofs2, len) {\n for(var i = 0; i < len; i++) {\n nat1.data[ofs1+i] = nat2.data[ofs2+i];\n }\n return 0;\n}\n\n//Provides: set_digit_nat\nfunction set_digit_nat(nat, ofs, digit) {\n nat.data[ofs] = digit;\n return 0;\n}\n\n//Provides: nth_digit_nat\nfunction nth_digit_nat(nat, ofs) {\n return nat.data[ofs];\n}\n\n//Provides: set_digit_nat_native\nfunction set_digit_nat_native(nat, ofs, digit) {\n nat.data[ofs] = digit;\n return 0;\n}\n\n//Provides: nth_digit_nat_native\nfunction nth_digit_nat_native(nat, ofs) {\n return nat.data[ofs];\n}\n\n//Provides: num_digits_nat\nfunction num_digits_nat(nat, ofs, len) {\n for(var i = len - 1; i >= 0; i--) {\n if(nat.data[ofs+i] != 0) return i+1;\n }\n return 1; // 0 counts as 1 digit\n}\n\n//Provides: num_leading_zero_bits_in_digit\nfunction num_leading_zero_bits_in_digit(nat, ofs) {\n var a = nat.data[ofs];\n var b = 0;\n if(a & 0xFFFF0000) { b +=16; a >>>=16; }\n if(a & 0xFF00) { b += 8; a >>>= 8; }\n if(a & 0xF0) { b += 4; a >>>= 4; }\n if(a & 12) { b += 2; a >>>= 2; }\n if(a & 2) { b += 1; a >>>= 1; }\n if(a & 1) { b += 1; }\n return 32 - b;\n}\n\n//Provides: is_digit_int\nfunction is_digit_int(nat, ofs) {\n if (nat.data[ofs] >= 0) return 1\n return 0;\n}\n\n//Provides: is_digit_zero\nfunction is_digit_zero(nat, ofs) {\n if(nat.data[ofs] == 0) return 1;\n return 0;\n}\n\n//Provides: is_digit_odd\nfunction is_digit_odd(nat, ofs) {\n if(nat.data[ofs] & 1) return 1;\n return 0;\n}\n\n//Provides: incr_nat\nfunction incr_nat(nat, ofs, len, carry_in) {\n var carry = carry_in;\n for(var i = 0; i < len; i++) {\n var x = (nat.data[ofs+i] >>> 0) + carry;\n nat.data[ofs+i] = (x | 0);\n if(x == (x >>> 0)) {\n carry = 0;\n break;\n } else {\n carry = 1;\n }\n }\n return carry;\n}\n\n// len1 >= len2\n//Provides: add_nat\n//Requires: incr_nat\nfunction add_nat(nat1, ofs1, len1, nat2, ofs2, len2, carry_in) {\n var carry = carry_in;\n for(var i = 0; i < len2; i++) {\n var x = (nat1.data[ofs1+i] >>> 0) + (nat2.data[ofs2+i] >>> 0) + carry;\n nat1.data[ofs1+i] = x\n if(x == (x >>> 0)) {\n carry = 0;\n } else {\n carry = 1;\n }\n }\n return incr_nat(nat1, ofs1+len2, len1-len2, carry);\n}\n\n//Provides: complement_nat\nfunction complement_nat(nat, ofs, len) {\n for(var i = 0; i < len; i++) {\n nat.data[ofs+i] = (-1 >>> 0) - (nat.data[ofs+i] >>> 0);\n }\n}\n\n// ocaml flips carry_in\n//Provides: decr_nat\nfunction decr_nat(nat, ofs, len, carry_in) {\n var borrow = (carry_in == 1) ? 0 : 1;\n for(var i = 0; i < len; i++) {\n var x = (nat.data[ofs+i] >>>0) - borrow;\n nat.data[ofs+i] = x;\n if (x >= 0) {\n borrow = 0;\n break;\n } else {\n borrow = 1;\n }\n }\n return (borrow == 1) ? 0 : 1;\n}\n\n// ocaml flips carry_in\n// len1 >= len2\n//Provides: sub_nat\n//Requires: decr_nat\nfunction sub_nat(nat1, ofs1, len1, nat2, ofs2, len2, carry_in) {\n var borrow = (carry_in == 1) ? 0 : 1;\n for(var i = 0; i < len2; i++) {\n var x = (nat1.data[ofs1+i] >>> 0) - (nat2.data[ofs2+i] >>> 0) - borrow;\n nat1.data[ofs1+i] = x;\n if (x >= 0) {\n borrow = 0;\n } else {\n borrow = 1;\n }\n }\n return decr_nat(nat1, ofs1+len2, len1-len2, (borrow==1)?0:1);\n}\n\n// nat1 += nat2 * nat3[ofs3]\n// len1 >= len2\n//Provides: mult_digit_nat\n//Requires: add_nat, nat_of_array\nfunction mult_digit_nat(nat1, ofs1, len1, nat2, ofs2, len2, nat3, ofs3) {\n var carry = 0;\n var a = (nat3.data[ofs3] >>> 0);\n for(var i = 0; i < len2; i++) {\n var x1 = (nat1.data[ofs1+i] >>> 0) + (nat2.data[ofs2+i] >>> 0) * (a & 0x0000FFFF) + carry;\n var x2 = (nat2.data[ofs2+i] >>> 0) * (a >>> 16);\n carry = Math.floor(x2/65536);\n var x3 = x1 + (x2 % 65536) * 65536;\n nat1.data[ofs1+i] = x3;\n carry += Math.floor(x3/4294967296);\n }\n\n if(len2 < len1 && carry) {\n return add_nat(nat1, ofs1+len2, len1-len2, nat_of_array([carry]), 0, 1, 0);\n } else {\n return carry;\n }\n}\n\n// nat1 += nat2 * nat3\n// len1 >= len2 + len3.\n//Provides: mult_nat\n//Requires: mult_digit_nat\nfunction mult_nat(nat1, ofs1, len1, nat2, ofs2, len2, nat3, ofs3, len3) {\n var carry = 0;\n for(var i = 0; i < len3; i++) {\n carry += mult_digit_nat(nat1, ofs1+i, len1-i, nat2, ofs2, len2, nat3, ofs3+i);\n }\n return carry;\n}\n\n// nat1 = 2 * nat1 + nat2 * nat2\n// len1 >= 2 * len2\n//Provides: square_nat\n//Requires: mult_nat, add_nat\nfunction square_nat(nat1, ofs1, len1, nat2, ofs2, len2) {\n var carry = 0;\n carry += add_nat(nat1, ofs1, len1, nat1, ofs1, len1, 0);\n carry += mult_nat(nat1, ofs1, len1, nat2, ofs2, len2, nat2, ofs2, len2);\n return carry;\n}\n\n\n// 0 <= shift < 32\n//Provides: shift_left_nat\nfunction shift_left_nat(nat1, ofs1, len1, nat2, ofs2, nbits) {\n if(nbits == 0) {\n nat2.data[ofs2] = 0;\n return 0;\n }\n var wrap = 0;\n for(var i = 0; i < len1; i++) {\n var a = (nat1.data[ofs1+i] >>> 0);\n nat1.data[ofs1+i] = (a << nbits) | wrap;\n wrap = a >>> (32 - nbits);\n }\n nat2.data[ofs2] = wrap;\n return 0;\n}\n\n// Assuming c > a, returns [quotient, remainder] of (a<<32 + b)/c\n//Provides: div_helper\nfunction div_helper(a, b, c) {\n var x = a * 65536 + (b>>>16);\n var y = Math.floor(x/c) * 65536;\n var z = (x % c) * 65536;\n var w = z + (b & 0x0000FFFF);\n return [y + Math.floor(w/c), w % c];\n}\n\n// nat1[ofs1+len] < nat2[ofs2]\n//Provides: div_digit_nat\n//Requires: div_helper\nfunction div_digit_nat(natq, ofsq, natr, ofsr, nat1, ofs1, len, nat2, ofs2) {\n var rem = (nat1.data[ofs1+len-1] >>>0);\n // natq[ofsq+len-1] is guaranteed to be zero (due to the MSD requirement),\n // and should not be written to.\n for(var i = len-2; i >= 0; i--) {\n var x = div_helper(rem, (nat1.data[ofs1+i] >>> 0), (nat2.data[ofs2] >>> 0));\n natq.data[ofsq+i] = x[0];\n rem = x[1];\n }\n natr.data[ofsr] = rem;\n return 0;\n}\n\n// nat1[nat2:] := nat1 / nat2\n// nat1[:nat2] := nat1 % nat2\n// len1 > len2, nat2[ofs2+len2-1] > nat1[ofs1+len1-1]\n//Provides: div_nat\n//Requires: div_digit_nat, div_helper, num_leading_zero_bits_in_digit, shift_left_nat, shift_right_nat, create_nat, set_to_zero_nat, mult_digit_nat, sub_nat, compare_nat, nat_of_array\nfunction div_nat(nat1, ofs1, len1, nat2, ofs2, len2) {\n if(len2 == 1) {\n div_digit_nat(nat1, ofs1+1, nat1, ofs1, nat1, ofs1, len1, nat2, ofs2);\n return 0;\n }\n\n var s = num_leading_zero_bits_in_digit(nat2, ofs2+len2-1);\n shift_left_nat(nat2, ofs2, len2, nat_of_array([0]), 0, s);\n shift_left_nat(nat1, ofs1, len1, nat_of_array([0]), 0, s);\n\n var d = (nat2.data[ofs2+len2-1] >>> 0) + 1;\n var a = create_nat(len2+1);\n for (var i = len1 - 1; i >= len2; i--) {\n // Decent lower bound on quo\n var quo = d == 4294967296 ? (nat1.data[ofs1+i] >>> 0) : div_helper((nat1.data[ofs1+i] >>> 0), (nat1.data[ofs1+i-1] >>>0), d)[0];\n set_to_zero_nat(a, 0, len2+1);\n mult_digit_nat(a, 0, len2+1, nat2, ofs2, len2, nat_of_array([quo]), 0);\n sub_nat(nat1, ofs1+i-len2, len2+1, a, 0, len2+1, 1);\n\n while (nat1.data[ofs1+i] != 0 || compare_nat(nat1, ofs1+i-len2, len2, nat2, ofs2, len2) >= 0) {\n quo = quo + 1;\n sub_nat(nat1, ofs1+i-len2, len2+1, nat2, ofs2, len2, 1);\n }\n\n nat1.data[ofs1+i] = quo;\n }\n\n shift_right_nat(nat1, ofs1, len2, nat_of_array([0]), 0, s); // shift remainder\n shift_right_nat(nat2, ofs2, len2, nat_of_array([0]), 0, s); // restore\n return 0;\n}\n\n\n// 0 <= shift < 32\n//Provides: shift_right_nat\nfunction shift_right_nat(nat1, ofs1, len1, nat2, ofs2, nbits) {\n if(nbits == 0) {\n nat2.data[ofs2] = 0;\n return 0;\n }\n var wrap = 0;\n for(var i = len1-1; i >= 0; i--) {\n var a = nat1.data[ofs1+i] >>> 0;\n nat1.data[ofs1+i] = (a >>> nbits) | wrap;\n wrap = a << (32 - nbits);\n }\n nat2.data[ofs2] = wrap;\n return 0;\n}\n\n//Provides: compare_digits_nat\nfunction compare_digits_nat(nat1, ofs1, nat2, ofs2) {\n if(nat1.data[ofs1] > nat2.data[ofs2]) return 1;\n if(nat1.data[ofs1] < nat2.data[ofs2]) return -1;\n return 0;\n}\n\n//Provides: compare_nat\n//Requires: num_digits_nat\nfunction compare_nat(nat1, ofs1, len1, nat2, ofs2, len2) {\n var a = num_digits_nat(nat1, ofs1, len1);\n var b = num_digits_nat(nat2, ofs2, len2);\n if(a > b) return 1;\n if(a < b) return -1;\n for(var i = len1 - 1; i >= 0; i--) {\n if ((nat1.data[ofs1+i] >>> 0) > (nat2.data[ofs2+i] >>> 0)) return 1;\n if ((nat1.data[ofs1+i] >>> 0) < (nat2.data[ofs2+i] >>> 0)) return -1;\n }\n return 0;\n}\n\n//Provides: compare_nat_real\n//Requires: compare_nat\nfunction compare_nat_real(nat1,nat2){\n return compare_nat(nat1,0,nat1.data.length,nat2,0,nat2.data.length);\n}\n\n//Provides: land_digit_nat\nfunction land_digit_nat(nat1, ofs1, nat2, ofs2) {\n nat1.data[ofs1] &= nat2.data[ofs2];\n return 0;\n}\n\n//Provides: lor_digit_nat\nfunction lor_digit_nat(nat1, ofs1, nat2, ofs2) {\n nat1.data[ofs1] |= nat2.data[ofs2];\n return 0;\n}\n\n//Provides: lxor_digit_nat\nfunction lxor_digit_nat(nat1, ofs1, nat2, ofs2) {\n nat1.data[ofs1] ^= nat2.data[ofs2];\n return 0;\n}\n\n\n//Provides: serialize_nat\nfunction serialize_nat(writer, nat, sz){\n var len = nat.data.length;\n writer.write(32, len);\n for(var i = 0; i < len; i++){\n writer.write(32, nat.data[i]);\n }\n sz[0] = len * 4;\n sz[1] = len * 8;\n}\n\n//Provides: deserialize_nat\n//Requires: MlNat\nfunction deserialize_nat(reader, sz){\n var len = reader.read32s();\n var nat = new MlNat(len);\n for(var i = 0; i < len; i++){\n nat.data[i] = reader.read32s();\n }\n sz[0] = len * 4;\n return nat;\n}\n","// Js_of_ocaml library\n// http://www.ocsigen.org/js_of_ocaml/\n// Copyright (C) 2010 Jérôme Vouillon\n// Laboratoire PPS - CNRS Université Paris Diderot\n//\n// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU Lesser General Public License as published by\n// the Free Software Foundation, with linking exception;\n// either version 2.1 of the License, or (at your option) any later version.\n//\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n// GNU Lesser General Public License for more details.\n//\n// You should have received a copy of the GNU Lesser General Public License\n// along with this program; if not, write to the Free Software\n// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n\n///////////// Jslib\n\n//Provides: caml_js_pure_expr const\nfunction caml_js_pure_expr (f) { return f(); }\n\n//Provides: caml_js_set (mutable, const, const)\nfunction caml_js_set(o,f,v) { o[f]=v;return 0}\n//Provides: caml_js_get mutable (const, const)\nfunction caml_js_get(o,f) { return o[f]; }\n//Provides: caml_js_delete (mutable, const)\nfunction caml_js_delete(o,f) { delete o[f]; return 0}\n\n//Provides: caml_js_instanceof (const, const)\nfunction caml_js_instanceof(o,c) { return (o instanceof c) ? 1 : 0; }\n\n//Provides: caml_js_typeof (const)\nfunction caml_js_typeof(o) { return typeof o; }\n\n//Provides:caml_trampoline\nfunction caml_trampoline(res) {\n var c = 1;\n while(res && res.joo_tramp){\n res = res.joo_tramp.apply(null, res.joo_args);\n c++;\n }\n return res;\n}\n\n//Provides:caml_trampoline_return\nfunction caml_trampoline_return(f,args) {\n return {joo_tramp:f,joo_args:args};\n}\n\n//Provides: js_print_stdout (const)\n//Requires: caml_utf16_of_utf8\nfunction js_print_stdout(s) {\n var s = caml_utf16_of_utf8(s);\n var g = globalThis;\n if (g.process && g.process.stdout && g.process.stdout.write) {\n g.process.stdout.write(s)\n } else {\n // Do not output the last \\n if present\n // as console logging display a newline at the end\n if(s.charCodeAt(s.length - 1) == 10)\n s = s.substr(0,s.length - 1 );\n var v = g.console;\n v && v.log && v.log(s);\n }\n}\n//Provides: js_print_stderr (const)\n//Requires: caml_utf16_of_utf8\nfunction js_print_stderr(s) {\n var s = caml_utf16_of_utf8(s);\n var g = globalThis;\n if (g.process && g.process.stdout && g.process.stdout.write) {\n g.process.stderr.write(s)\n } else {\n // Do not output the last \\n if present\n // as console logging display a newline at the end\n if(s.charCodeAt(s.length - 1) == 10)\n s = s.substr(0,s.length - 1 );\n var v = g.console;\n v && v.error && v.error(s);\n }\n}\n\n//Provides: caml_is_js\nfunction caml_is_js() {\n return 1;\n}\n\n//Provides: caml_wrap_exception const (const)\n//Requires: caml_global_data,caml_string_of_jsstring,caml_named_value\n//Requires: caml_return_exn_constant\nfunction caml_wrap_exception(e) {\n if(e instanceof Array) return e;\n //Stack_overflow: chrome, safari\n if(globalThis.RangeError\n && e instanceof globalThis.RangeError\n && e.message\n && e.message.match(/maximum call stack/i))\n return caml_return_exn_constant(caml_global_data.Stack_overflow);\n //Stack_overflow: firefox\n if(globalThis.InternalError\n && e instanceof globalThis.InternalError\n && e.message\n && e.message.match(/too much recursion/i))\n return caml_return_exn_constant(caml_global_data.Stack_overflow);\n //Wrap Error in Js.Error exception\n if(e instanceof globalThis.Error && caml_named_value(\"jsError\"))\n return [0,caml_named_value(\"jsError\"),e];\n //fallback: wrapped in Failure\n return [0,caml_global_data.Failure,caml_string_of_jsstring (String(e))];\n}\n\n// Experimental\n//Provides: caml_exn_with_js_backtrace\n//Requires: caml_global_data\nfunction caml_exn_with_js_backtrace(exn, force) {\n //never reraise for constant exn\n if(!exn.js_error || force || exn[0] == 248) exn.js_error = new globalThis.Error(\"Js exception containing backtrace\");\n return exn;\n}\n\n\n//Provides: caml_js_error_option_of_exception\nfunction caml_js_error_option_of_exception(exn) {\n if(exn.js_error) { return [0, exn.js_error]; }\n return 0;\n}\n\n\n\n//Provides: caml_js_from_bool const (const)\nfunction caml_js_from_bool(x) { return !!x; }\n//Provides: caml_js_to_bool const (const)\nfunction caml_js_to_bool(x) { return +x; }\n//Provides: caml_js_from_float const (const)\nfunction caml_js_from_float(x) { return x; }\n//Provides: caml_js_to_float const (const)\nfunction caml_js_to_float(x) { return x; }\n\n//Provides: caml_js_from_array mutable (shallow)\nfunction caml_js_from_array(a) {\n return a.slice(1);\n}\n//Provides: caml_js_to_array mutable (shallow)\nfunction caml_js_to_array(a) {\n var len = a.length;\n var b = new Array(len+1);\n b[0] = 0;\n for(var i=0;i=0; i--){\n var e = a[i];\n l = [0,e,l];\n }\n return l\n}\n\n//Provides: caml_list_to_js_array const (const)\nfunction caml_list_to_js_array(l){\n var a = [];\n for(; l !== 0; l = l[2]) {\n a.push(l[1]);\n }\n return a;\n}\n\n//Provides: caml_js_var mutable (const)\n//Requires: js_print_stderr\n//Requires: caml_jsstring_of_string\nfunction caml_js_var(x) {\n var x = caml_jsstring_of_string(x);\n //Checks that x has the form ident[.ident]*\n if(!x.match(/^[a-zA-Z_$][a-zA-Z_$0-9]*(\\.[a-zA-Z_$][a-zA-Z_$0-9]*)*$/)){\n js_print_stderr(\"caml_js_var: \\\"\" + x + \"\\\" is not a valid JavaScript variable. continuing ..\");\n //globalThis.console.error(\"Js.Unsafe.eval_string\")\n }\n return eval(x);\n}\n//Provides: caml_js_call (const, mutable, shallow)\n//Requires: caml_js_from_array\nfunction caml_js_call(f, o, args) { return f.apply(o, caml_js_from_array(args)); }\n//Provides: caml_js_fun_call (const, shallow)\n//Requires: caml_js_from_array\nfunction caml_js_fun_call(f, a) {\n switch (a.length) {\n case 1: return f();\n case 2: return f (a[1]);\n case 3: return f (a[1],a[2]);\n case 4: return f (a[1],a[2],a[3]);\n case 5: return f (a[1],a[2],a[3],a[4]);\n case 6: return f (a[1],a[2],a[3],a[4],a[5]);\n case 7: return f (a[1],a[2],a[3],a[4],a[5],a[6]);\n case 8: return f (a[1],a[2],a[3],a[4],a[5],a[6],a[7]);\n }\n return f.apply(null, caml_js_from_array(a));\n}\n//Provides: caml_js_meth_call (mutable, const, shallow)\n//Requires: caml_jsstring_of_string\n//Requires: caml_js_from_array\nfunction caml_js_meth_call(o, f, args) {\n return o[caml_jsstring_of_string(f)].apply(o, caml_js_from_array(args));\n}\n//Provides: caml_js_new (const, shallow)\n//Requires: caml_js_from_array\nfunction caml_js_new(c, a) {\n switch (a.length) {\n case 1: return new c;\n case 2: return new c (a[1]);\n case 3: return new c (a[1],a[2]);\n case 4: return new c (a[1],a[2],a[3]);\n case 5: return new c (a[1],a[2],a[3],a[4]);\n case 6: return new c (a[1],a[2],a[3],a[4],a[5]);\n case 7: return new c (a[1],a[2],a[3],a[4],a[5],a[6]);\n case 8: return new c (a[1],a[2],a[3],a[4],a[5],a[6],a[7]);\n }\n function F() { return c.apply(this, caml_js_from_array(a)); }\n F.prototype = c.prototype;\n return new F;\n}\n//Provides: caml_ojs_new_arr (const, shallow)\n//Requires: caml_js_from_array\nfunction caml_ojs_new_arr(c, a) {\n switch (a.length) {\n case 0: return new c;\n case 1: return new c (a[0]);\n case 2: return new c (a[0],a[1]);\n case 3: return new c (a[0],a[1],a[2]);\n case 4: return new c (a[0],a[1],a[2],a[3]);\n case 5: return new c (a[0],a[1],a[2],a[3],a[4]);\n case 6: return new c (a[0],a[1],a[2],a[3],a[4],a[5]);\n case 7: return new c (a[0],a[1],a[2],a[3],a[4],a[5],a[6]);\n }\n function F() { return c.apply(this, a); }\n F.prototype = c.prototype;\n return new F;\n}\n//Provides: caml_js_wrap_callback const (const)\n//Requires: caml_call_gen\nfunction caml_js_wrap_callback(f) {\n return function () {\n var len = arguments.length;\n if(len > 0){\n var args = new Array(len);\n for (var i = 0; i < len; i++) args[i] = arguments[i];\n return caml_call_gen(f, args);\n } else {\n return caml_call_gen(f, [undefined]);\n }\n }\n}\n\n//Provides: caml_js_wrap_callback_arguments\n//Requires: caml_call_gen\nfunction caml_js_wrap_callback_arguments(f) {\n return function() {\n var len = arguments.length;\n var args = new Array(len);\n for (var i = 0; i < len; i++) args[i] = arguments[i];\n return caml_call_gen(f, [args]);\n }\n}\n//Provides: caml_js_wrap_callback_strict const\n//Requires: caml_call_gen\nfunction caml_js_wrap_callback_strict(arity, f) {\n return function () {\n var n = arguments.length;\n if(n == arity && f.length == arity) return f.apply(null, arguments);\n var args = new Array(arity);\n var len = Math.min(arguments.length, arity)\n for (var i = 0; i < len; i++) args[i] = arguments[i];\n return caml_call_gen(f, args);\n };\n}\n//Provides: caml_js_wrap_meth_callback const (const)\n//Requires: caml_call_gen\nfunction caml_js_wrap_meth_callback(f) {\n return function () {\n var len = arguments.length;\n var args = new Array(len + 1);\n args[0] = this;\n for (var i = 0; i < len; i++) args[i+1] = arguments[i];\n return caml_call_gen(f,args);\n }\n}\n//Provides: caml_js_wrap_meth_callback_arguments const (const)\n//Requires: caml_call_gen\nfunction caml_js_wrap_meth_callback_arguments(f) {\n return function () {\n var len = arguments.length;\n var args = new Array(len);\n for (var i = 0; i < len; i++) args[i] = arguments[i];\n return caml_call_gen(f,[this,args]);\n }\n}\n//Provides: caml_js_wrap_meth_callback_strict const\n//Requires: caml_call_gen\nfunction caml_js_wrap_meth_callback_strict(arity, f) {\n return function () {\n var args = new Array(arity + 1);\n var len = Math.min(arguments.length, arity)\n args[0] = this;\n for (var i = 0; i < len; i++) args[i+1] = arguments[i];\n return caml_call_gen(f, args);\n };\n}\n//Provides: caml_js_wrap_meth_callback_unsafe const (const)\n//Requires: caml_call_gen\nfunction caml_js_wrap_meth_callback_unsafe(f) {\n return function () {\n var len = arguments.length;\n var args = new Array(len + 1);\n args[0] = this;\n for (var i = 0; i < len; i++) args[i+1] = arguments[i];\n return f.apply(null, args); }\n}\n//Provides: caml_js_equals mutable (const, const)\nfunction caml_js_equals (x, y) { return +(x == y); }\n\n//Provides: caml_js_eval_string (const)\n//Requires: caml_jsstring_of_string\nfunction caml_js_eval_string (s) {return eval(caml_jsstring_of_string(s));}\n\n//Provides: caml_js_expr (const)\n//Requires: js_print_stderr\n//Requires: caml_jsstring_of_string\nfunction caml_js_expr(s) {\n js_print_stderr(\"caml_js_expr: fallback to runtime evaluation\\n\");\n return eval(caml_jsstring_of_string(s));}\n\n//Provides: caml_pure_js_expr const (const)\n//Requires: js_print_stderr\n//Requires: caml_jsstring_of_string\nfunction caml_pure_js_expr (s){\n js_print_stderr(\"caml_pure_js_expr: fallback to runtime evaluation\\n\");\n return eval(caml_jsstring_of_string(s));}\n\n//Provides: caml_js_object (object_literal)\n//Requires: caml_jsstring_of_string\nfunction caml_js_object (a) {\n var o = {};\n for (var i = 1; i < a.length; i++) {\n var p = a[i];\n o[caml_jsstring_of_string(p[1])] = p[2];\n }\n return o;\n}\n","///////// BIGSTRING\n\n//Provides: bigstring_alloc\n//Requires: caml_ba_create\nfunction bigstring_alloc(_,size){\n return caml_ba_create(12, 0, [0,size]);\n}\n\n//Provides: bigstring_is_mmapped_stub\nfunction bigstring_is_mmapped_stub(x){\n return 0;\n}\n\n//Provides: bigstring_blit_stub\n//Requires: caml_bigstring_blit_ba_to_ba\nfunction bigstring_blit_stub(s1, i1, s2, i2, len){\n return caml_bigstring_blit_ba_to_ba(s1,i1,s2,i2,len);\n}\n\n//Provides: bigstring_blit_bytes_bigstring_stub\n//Requires: caml_bigstring_blit_bytes_to_ba\nfunction bigstring_blit_bytes_bigstring_stub(src, src_pos, dst, dst_pos, len){\n return caml_bigstring_blit_bytes_to_ba(src,src_pos,dst,dst_pos,len);\n}\n\n//Provides: bigstring_blit_bigstring_bytes_stub\n//Requires: caml_bigstring_blit_ba_to_bytes\nfunction bigstring_blit_bigstring_bytes_stub(src, src_pos, dst, dst_pos, len){\n return caml_bigstring_blit_ba_to_bytes(src,src_pos,dst,dst_pos,len);\n}\n\n//Provides: bigstring_blit_string_bigstring_stub\n//Requires: caml_bigstring_blit_string_to_ba\nfunction bigstring_blit_string_bigstring_stub(src, src_pos, dst, dst_pos, len){\n return caml_bigstring_blit_string_to_ba(src,src_pos,dst,dst_pos,len);\n}\n\n//Provides: bigstring_memset_stub\n//Requires: caml_ba_set_1\nfunction bigstring_memset_stub(bigstring, v_pos, v_len, v_char) {\n for (var i = 0; i < v_len; i++) {\n caml_ba_set_1(bigstring, v_pos + i, v_char);\n }\n}\n\n//Provides: bigstring_memcmp_stub\n//Requires: caml_ba_get_1\nfunction bigstring_memcmp_stub(v_s1, v_s1_pos, v_s2, v_s2_pos, v_len){\n for (var i = 0; i < v_len; i++) {\n var a = caml_ba_get_1(v_s1,v_s1_pos + i);\n var b = caml_ba_get_1(v_s2,v_s2_pos + i);\n if (a < b) return -1;\n if (a > b) return 1;\n }\n return 0;\n}\n\n//Provides: internalhash_fold_bigstring\n//Requires: caml_hash_mix_bigstring\nvar internalhash_fold_bigstring = caml_hash_mix_bigstring\n\n//Provides: bigstring_find\n//Requires: caml_ba_get_1\nfunction bigstring_find(bs, chr, pos, len){\n while(len > 0){\n if(caml_ba_get_1(bs,pos) == chr) return pos;\n pos++;\n len--;\n }\n return -1;\n}\n","///////// BIGSTRING\n\n//Provides: caml_hash_mix_bigstring\n//Requires: caml_hash_mix_bytes_arr\nfunction caml_hash_mix_bigstring(h, bs) {\n return caml_hash_mix_bytes_arr(h,bs.data);\n}\n\n//Provides: bigstring_to_array_buffer mutable\nfunction bigstring_to_array_buffer(bs) {\n return bs.data.buffer\n}\n\n//Provides: bigstring_to_typed_array mutable\nfunction bigstring_to_typed_array(bs) {\n return bs.data\n}\n\n//Provides: bigstring_of_array_buffer mutable\n//Requires: caml_ba_create_unsafe\nfunction bigstring_of_array_buffer(ab) {\n var ta = new globalThis.Uint8Array(ab);\n return caml_ba_create_unsafe(12, 0, [ta.length], ta);\n}\n\n//Provides: bigstring_of_typed_array mutable\n//Requires: caml_ba_create_unsafe\nfunction bigstring_of_typed_array(ba) {\n var ta = new globalThis.Uint8Array(ba.buffer, ba.byteOffset, ba.length * ba.BYTES_PER_ELEMENT);\n return caml_ba_create_unsafe(12, 0, [ta.length], ta);\n}\n\n//Provides: caml_bigstring_memcmp\n//Requires: caml_ba_get_1\nfunction caml_bigstring_memcmp(s1, pos1, s2, pos2, len){\n for (var i = 0; i < len; i++) {\n var a = caml_ba_get_1(s1,pos1 + i);\n var b = caml_ba_get_1(s2,pos2 + i);\n if (a < b) return -1;\n if (a > b) return 1;\n }\n return 0;\n}\n\n//Provides: caml_bigstring_blit_ba_to_ba\n//Requires: caml_invalid_argument, caml_array_bound_error\nfunction caml_bigstring_blit_ba_to_ba(ba1, pos1, ba2, pos2, len){\n if(12 != ba1.kind)\n caml_invalid_argument(\"caml_bigstring_blit_ba_to_ba: kind mismatch\");\n if(12 != ba2.kind)\n caml_invalid_argument(\"caml_bigstring_blit_ba_to_ba: kind mismatch\");\n if(len == 0) return 0;\n var ofs1 = ba1.offset(pos1);\n var ofs2 = ba2.offset(pos2);\n if(ofs1 + len > ba1.data.length){\n caml_array_bound_error();\n }\n if(ofs2 + len > ba2.data.length){\n caml_array_bound_error();\n }\n var slice = ba1.data.subarray(ofs1,ofs1+len);\n ba2.data.set(slice,pos2);\n return 0\n}\n\n//Provides: caml_bigstring_blit_string_to_ba\n//Requires: caml_invalid_argument, caml_array_bound_error, caml_array_of_string\n//Requires: caml_ml_string_length\nfunction caml_bigstring_blit_string_to_ba(str1, pos1, ba2, pos2, len){\n if(12 != ba2.kind)\n caml_invalid_argument(\"caml_bigstring_blit_string_to_ba: kind mismatch\");\n if(len == 0) return 0;\n var ofs2 = ba2.offset(pos2);\n if(pos1 + len > caml_ml_string_length(str1)) {\n caml_array_bound_error();\n }\n if(ofs2 + len > ba2.data.length) {\n caml_array_bound_error();\n }\n var slice = caml_array_of_string(str1).slice(pos1,pos1 + len);\n ba2.data.set(slice,ofs2);\n return 0\n}\n\n//Provides: caml_bigstring_blit_bytes_to_ba\n//Requires: caml_invalid_argument, caml_array_bound_error, caml_array_of_bytes\n//Requires: caml_ml_bytes_length\nfunction caml_bigstring_blit_bytes_to_ba(str1, pos1, ba2, pos2, len){\n if(12 != ba2.kind)\n caml_invalid_argument(\"caml_bigstring_blit_string_to_ba: kind mismatch\");\n if(len == 0) return 0;\n var ofs2 = ba2.offset(pos2);\n if(pos1 + len > caml_ml_bytes_length(str1)) {\n caml_array_bound_error();\n }\n if(ofs2 + len > ba2.data.length) {\n caml_array_bound_error();\n }\n var slice = caml_array_of_bytes(str1).slice(pos1,pos1 + len);\n ba2.data.set(slice,ofs2);\n return 0\n}\n\n//Provides: caml_bigstring_blit_ba_to_bytes\n//Requires: caml_invalid_argument, caml_array_bound_error\n//Requires: caml_blit_bytes, caml_bytes_of_array\n//Requires: caml_ml_bytes_length\nfunction caml_bigstring_blit_ba_to_bytes(ba1, pos1, bytes2, pos2, len){\n if(12 != ba1.kind)\n caml_invalid_argument(\"caml_bigstring_blit_string_to_ba: kind mismatch\");\n if(len == 0) return 0;\n var ofs1 = ba1.offset(pos1);\n if(ofs1 + len > ba1.data.length){\n caml_array_bound_error();\n }\n if(pos2 + len > caml_ml_bytes_length(bytes2)){\n caml_array_bound_error();\n }\n var slice = ba1.data.slice(ofs1, ofs1+len);\n caml_blit_bytes(caml_bytes_of_array(slice), 0, bytes2, pos2, len);\n return 0\n}\n","/*----------------------------------------------------------------------------\n Copyright (c) 2017 Inhabited Type LLC.\n\n All rights reserved.\n\n Redistribution and use in source and binary forms, with or without\n modification, are permitted provided that the following conditions\n are met:\n\n 1. Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n\n 2. Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n\n 3. Neither the name of the author nor the names of his contributors\n may be used to endorse or promote products derived from this software\n without specific prior written permission.\n\n THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS ``AS IS'' AND ANY EXPRESS\n OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\n WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR\n ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\n DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS\n OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\n HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,\n STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN\n ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n POSSIBILITY OF SUCH DAMAGE.\n ----------------------------------------------------------------------------*/\n\n//Provides: bigstringaf_blit_to_bytes\n//Requires: caml_string_unsafe_set, caml_ba_get_1\nfunction bigstringaf_blit_to_bytes(src, src_off, dst, dst_off, len) {\n for (var i = 0; i < len; i++) {\n caml_string_unsafe_set(dst, dst_off + i, caml_ba_get_1(src, src_off + i));\n }\n}\n\n//Provides: bigstringaf_blit_to_bigstring\n//Requires: caml_ba_set_1, caml_ba_get_1\nfunction bigstringaf_blit_to_bigstring(src, src_off, dst, dst_off, len) {\n for (var i = 0; i < len; i++) {\n caml_ba_set_1(dst, dst_off + i, caml_ba_get_1(src, src_off + i));\n }\n}\n\n//Provides: bigstringaf_blit_from_bytes\n//Requires: caml_ba_set_1, caml_string_unsafe_get\nfunction bigstringaf_blit_from_bytes(src, src_off, dst, dst_off, len) {\n for (var i = 0; i < len; i++) {\n caml_ba_set_1(dst, dst_off + i, caml_string_unsafe_get(src, src_off + i));\n }\n}\n\n//Provides: bigstringaf_memcmp_bigstring\n//Requires: caml_ba_get_1, caml_int_compare\nfunction bigstringaf_memcmp_bigstring(ba1, ba1_off, ba2, ba2_off, len) {\n for (var i = 0; i < len; i++) {\n var c = caml_int_compare(caml_ba_get_1(ba1, ba1_off + i), caml_ba_get_1(ba2, ba2_off + i));\n if (c != 0) return c\n }\n return 0;\n}\n\n//Provides: bigstringaf_memcmp_string\n//Requires: caml_ba_get_1, caml_int_compare, caml_string_unsafe_get\nfunction bigstringaf_memcmp_string(ba, ba_off, str, str_off, len) {\n for (var i = 0; i < len; i++) {\n var c = caml_int_compare(caml_ba_get_1(ba, ba_off + i), caml_string_unsafe_get(str, str_off + i));\n if (c != 0) return c\n }\n return 0;\n}\n","///////// BIN_PROT\n\n//Provides: caml_check_bound_bigstring\n//Requires: caml_array_bound_error\nfunction caml_check_bound_bigstring(bigstring, i){\n if (i >>> 0 >= bigstring.data.length) caml_array_bound_error();\n}\n\n//Provides: bin_prot_blit_buf_float_array_stub\n//Requires: caml_check_bound, caml_check_bound_bigstring\nfunction bin_prot_blit_buf_float_array_stub(src_pos, src, dst_pos, dst, len){\n if(len == 0) return 0;\n caml_check_bound(dst,dst_pos); // first pos\n caml_check_bound(dst,dst_pos+len-1); // last pos\n caml_check_bound_bigstring(src, src_pos); /* first pos */\n caml_check_bound_bigstring(src, src_pos + len * 8 - 1); /* last pos */\n var view = new joo_global_object.Float64Array(len);\n var buffer = new joo_global_object.Uint8Array(view.buffer);\n buffer.set(src.data.subarray(src_pos, src_pos + (len * 8)));\n for(var i = 0; i < len; i++){\n // [+ 1] because the tag is at pos 0 \n dst[dst_pos+i+1] = view[i];\n }\n return 0\n}\n//Provides: bin_prot_blit_buf_bytes_stub\n//Requires: caml_bigstring_blit_ba_to_bytes\nfunction bin_prot_blit_buf_bytes_stub(src_pos, src, dst_pos, dst, len){\n return caml_bigstring_blit_ba_to_bytes(src, src_pos, dst, dst_pos, len);\n}\n//Provides: bin_prot_blit_float_array_buf_stub\n//Requires: caml_check_bound, caml_check_bound_bigstring\nfunction bin_prot_blit_float_array_buf_stub(src_pos,src, dst_pos, dst, len){\n if(len == 0) return 0 \n caml_check_bound (src, src_pos); // first pos \n caml_check_bound (src, src_pos + len - 1); // last pos\n caml_check_bound_bigstring(dst, dst_pos); /* first pos */\n caml_check_bound_bigstring(dst, dst_pos + len * 8 - 1); /* last pos */\n // [+ 1] because the tag is at pos 0\n src_pos = src_pos + 1\n var float64 = new joo_global_object.Float64Array(src.slice(src_pos,src_pos + len));\n var float64_uint8 = new joo_global_object.Uint8Array(float64.buffer);\n var view = dst.data.subarray(dst_pos, dst_pos + (len * 8));\n view.set(float64_uint8);\n return 0\n}\n//Provides: bin_prot_blit_string_buf_stub\n//Requires: caml_bigstring_blit_string_to_ba\nfunction bin_prot_blit_string_buf_stub (src_pos, src, dst_pos, dst, len){\n return caml_bigstring_blit_string_to_ba(src,src_pos, dst, dst_pos,len);\n}\n//Provides: bin_prot_blit_bytes_buf_stub\n//Requires: caml_bigstring_blit_string_to_ba\nfunction bin_prot_blit_bytes_buf_stub (src_pos, src, dst_pos, dst, len){\n return caml_bigstring_blit_string_to_ba(src,src_pos, dst, dst_pos,len);\n}\n\n//Provides: bin_prot_blit_buf_stub\n//Requires: caml_bigstring_blit_ba_to_ba, bigstring_of_typed_array\nfunction bin_prot_blit_buf_stub (src_pos, src, dst_pos, dst, len){\n // [bin_prot_blit_buf_stub] is used with mixed bigarray kinds.\n // Converter everything to bigarray of char before the blit.\n if(src.kind != 12) // 12 is the char kind\n src = bigstring_of_typed_array(src.data);\n if(dst.kind != 12) // 12 is the char kind\n dst = bigstring_of_typed_array(dst.data);\n return caml_bigstring_blit_ba_to_ba(src,src_pos,dst,dst_pos,len);\n}\n","// Js_of_ocaml runtime support\n// http://www.ocsigen.org/js_of_ocaml/\n//\n// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU Lesser General Public License as published by\n// the Free Software Foundation, with linking exception;\n// either version 2.1 of the License, or (at your option) any later version.\n//\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n// GNU Lesser General Public License for more details.\n//\n// You should have received a copy of the GNU Lesser General Public License\n// along with this program; if not, write to the Free Software\n// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n\n///////////// Array\n\n//Provides: caml_array_sub mutable\nfunction caml_array_sub (a, i, len) {\n var a2 = new Array(len+1);\n a2[0]=0;\n for(var i2 = 1, i1= i+1; i2 <= len; i2++,i1++ ){\n a2[i2]=a[i1];\n }\n return a2;\n}\n\n//Provides: caml_array_append mutable\nfunction caml_array_append(a1, a2) {\n var l1 = a1.length, l2 = a2.length;\n var l = l1+l2-1\n var a = new Array(l);\n a[0] = 0;\n var i = 1,j = 1;\n for(;i= 1; j--) a2[i2 + j] = a1[i1 + j];\n };\n return 0;\n}\n\n//Provides: caml_floatarray_blit\nfunction caml_floatarray_blit(a1, i1, a2, i2, len) {\n if (i2 <= i1) {\n for (var j = 1; j <= len; j++) a2[i2 + j] = a1[i1 + j];\n } else {\n for (var j = len; j >= 1; j--) a2[i2 + j] = a1[i1 + j];\n };\n return 0;\n}\n\n///////////// Pervasive\n//Provides: caml_array_set (mutable, const, const)\n//Requires: caml_array_bound_error\nfunction caml_array_set (array, index, newval) {\n if ((index < 0) || (index >= array.length - 1)) caml_array_bound_error();\n array[index+1]=newval; return 0;\n}\n\n//Provides: caml_array_get mutable (const, const)\n//Requires: caml_array_bound_error\nfunction caml_array_get (array, index) {\n if ((index < 0) || (index >= array.length - 1)) caml_array_bound_error();\n return array[index+1];\n}\n\n//Provides: caml_array_fill\nfunction caml_array_fill(array, ofs, len, v){\n for(var i = 0; i < len; i++){\n array[ofs+i+1] = v;\n }\n return 0;\n}\n\n//Provides: caml_check_bound (const, const)\n//Requires: caml_array_bound_error\nfunction caml_check_bound (array, index) {\n if (index >>> 0 >= array.length - 1) caml_array_bound_error();\n return array;\n}\n\n//Provides: caml_make_vect const (const, const)\n//Requires: caml_array_bound_error\nfunction caml_make_vect (len, init) {\n if (len < 0) caml_array_bound_error();\n var len = len + 1 | 0;\n var b = new Array(len);\n b[0]=0;\n for (var i = 1; i < len; i++) b[i] = init;\n return b;\n}\n\n//Provides: caml_make_float_vect const (const)\n//Requires: caml_array_bound_error\nfunction caml_make_float_vect(len){\n if (len < 0) caml_array_bound_error();\n var len = len + 1 | 0;\n var b = new Array(len);\n b[0]=254;\n for (var i = 1; i < len; i++) b[i] = 0;\n return b\n}\n//Provides: caml_floatarray_create const (const)\n//Requires: caml_array_bound_error\nfunction caml_floatarray_create(len){\n if (len < 0) caml_array_bound_error();\n var len = len + 1 | 0;\n var b = new Array(len);\n b[0]=254;\n for (var i = 1; i < len; i++) b[i] = 0;\n return b\n}\n","// Js_of_ocaml runtime support\n// http://www.ocsigen.org/js_of_ocaml/\n//\n// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU Lesser General Public License as published by\n// the Free Software Foundation, with linking exception;\n// either version 2.1 of the License, or (at your option) any later version.\n//\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n// GNU Lesser General Public License for more details.\n//\n// You should have received a copy of the GNU Lesser General Public License\n// along with this program; if not, write to the Free Software\n// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n\n//Provides: caml_ml_debug_info_status const\nfunction caml_ml_debug_info_status () { return 0; }\n//Provides: caml_backtrace_status const\nfunction caml_backtrace_status () { return 0; }\n//Provides: caml_get_exception_backtrace const\nfunction caml_get_exception_backtrace () { return 0; }\n//Provides: caml_get_exception_raw_backtrace const\nfunction caml_get_exception_raw_backtrace () { return [0]; }\n//Provides: caml_record_backtrace\nfunction caml_record_backtrace () { return 0; }\n//Provides: caml_convert_raw_backtrace const\nfunction caml_convert_raw_backtrace () { return [0]; }\n//Provides: caml_raw_backtrace_length\nfunction caml_raw_backtrace_length() { return 0; }\n//Provides: caml_raw_backtrace_next_slot\nfunction caml_raw_backtrace_next_slot() { return 0 }\n//Provides: caml_raw_backtrace_slot\n//Requires: caml_invalid_argument\nfunction caml_raw_backtrace_slot () {\n caml_invalid_argument(\"Printexc.get_raw_backtrace_slot: index out of bounds\");\n}\n//Provides: caml_restore_raw_backtrace\nfunction caml_restore_raw_backtrace(exn, bt) { return 0 }\n//Provides: caml_get_current_callstack const\nfunction caml_get_current_callstack () { return [0]; }\n\n//Provides: caml_convert_raw_backtrace_slot\n//Requires: caml_failwith\nfunction caml_convert_raw_backtrace_slot(){\n caml_failwith(\"caml_convert_raw_backtrace_slot\");\n}\n","// Provides: plonk_wasm\nvar plonk_wasm = require('./plonk_wasm.js')","/* global joo_global_object, plonk_wasm, caml_js_to_bool, caml_jsstring_of_string,\n caml_string_of_jsstring\n caml_create_bytes, caml_bytes_unsafe_set, caml_bytes_unsafe_get, caml_ml_bytes_length,\n UInt64, caml_int64_of_int32\n*/\n\n// Provides: caml_get_field_of_caml_record\nvar caml_get_field_of_caml_record = function (caml_record, i) {\n // Get the ith field of the record [record]\n // The runtime representation of a record is [0, field1, field2, ...], like\n // arrays and tuples, see https://github.com/ocsigen/js_of_ocaml/blob/4.0.0/README.md#data-representation\n // If js_of_ocaml is updated, this has to be reviewed.\n return caml_record[1 + i];\n};\n\n// Provides: caml_bytes_of_uint8array\n// Requires: caml_create_bytes, caml_bytes_unsafe_set\nvar caml_bytes_of_uint8array = function (uint8array) {\n var length = uint8array.length;\n var ocaml_bytes = caml_create_bytes(length);\n for (var i = 0; i < length; i++) {\n // No need to convert here: OCaml Char.t is just an int under the hood.\n caml_bytes_unsafe_set(ocaml_bytes, i, uint8array[i]);\n }\n return ocaml_bytes;\n};\n\n// Provides: caml_bytes_to_uint8array\n// Requires: caml_ml_bytes_length, caml_bytes_unsafe_get\nvar caml_bytes_to_uint8array = function (ocaml_bytes) {\n var length = caml_ml_bytes_length(ocaml_bytes);\n var bytes = new joo_global_object.Uint8Array(length);\n for (var i = 0; i < length; i++) {\n // No need to convert here: OCaml Char.t is just an int under the hood.\n bytes[i] = caml_bytes_unsafe_get(ocaml_bytes, i);\n }\n return bytes;\n};\n\n// Provides: caml_bigint_256_of_numeral\n// Requires: plonk_wasm, caml_jsstring_of_string\nvar caml_bigint_256_of_numeral = function (s, len, base) {\n return plonk_wasm.caml_bigint_256_of_numeral(\n caml_jsstring_of_string(s),\n len,\n base\n );\n};\n\n// Provides: caml_bigint_256_of_decimal_string\n// Requires: plonk_wasm, caml_jsstring_of_string\nvar caml_bigint_256_of_decimal_string = function (s) {\n return plonk_wasm.caml_bigint_256_of_decimal_string(\n caml_jsstring_of_string(s)\n );\n};\n\n// Provides: caml_create_rust_empty_vector\nvar caml_create_rust_empty_vector = function () {\n // If this is correct, it should be equivalent than calling\n // js_class_vector_to_rust_vector with an empty js array\n return new joo_global_object.Uint32Array(0);\n};\n\n// Provides: caml_is_empty_caml_array\nvar caml_is_empty_caml_array = function (caml_array) {\n // An empty caml array will only be the value [0] as a caml array [v1; v2;,\n // ...] is\n // represented as a JavaScript array [0, v1, v2, ...] where [0] is the runtime\n // tag\n return caml_array.length === 1;\n};\n\n// Provides: caml_bigint_256_num_limbs\n// Requires: plonk_wasm\nvar caml_bigint_256_num_limbs = plonk_wasm.caml_bigint_256_num_limbs;\n\n// Provides: caml_bigint_256_bytes_per_limb\n// Requires: plonk_wasm\nvar caml_bigint_256_bytes_per_limb = plonk_wasm.caml_bigint_256_bytes_per_limb;\n\n// Provides: caml_bigint_256_div\n// Requires: plonk_wasm\nvar caml_bigint_256_div = plonk_wasm.caml_bigint_256_div;\n\n// Provides: caml_bigint_256_compare\n// Requires: plonk_wasm\nvar caml_bigint_256_compare = plonk_wasm.caml_bigint_256_compare;\n\n// Provides: caml_bigint_256_print\n// Requires: plonk_wasm\nvar caml_bigint_256_print = plonk_wasm.caml_bigint_256_print;\n\n// Provides: caml_bigint_256_to_string\n// Requires: plonk_wasm, caml_string_of_jsstring\nvar caml_bigint_256_to_string = function (x) {\n return caml_string_of_jsstring(plonk_wasm.caml_bigint_256_to_string(x));\n};\n\n// Provides: caml_bigint_256_test_bit\n// Requires: plonk_wasm, caml_js_to_bool\nvar caml_bigint_256_test_bit = function (x, i) {\n return caml_js_to_bool(plonk_wasm.caml_bigint_256_test_bit(x, i));\n};\n\n// Provides: caml_bigint_256_to_bytes\n// Requires: plonk_wasm, caml_bytes_of_uint8array\nvar caml_bigint_256_to_bytes = function (x) {\n return caml_bytes_of_uint8array(plonk_wasm.caml_bigint_256_to_bytes(x));\n};\n\n// Provides: caml_bigint_256_of_bytes\n// Requires: plonk_wasm, caml_bytes_to_uint8array\nvar caml_bigint_256_of_bytes = function (ocaml_bytes) {\n return plonk_wasm.caml_bigint_256_of_bytes(\n caml_bytes_to_uint8array(ocaml_bytes)\n );\n};\n\n// Provides: caml_bigint_256_deep_copy\n// Requires: plonk_wasm\nvar caml_bigint_256_deep_copy = plonk_wasm.caml_bigint_256_deep_copy;\n\n// Provides: caml_pasta_fp_copy\nvar caml_pasta_fp_copy = function (x, y) {\n for (var i = 0, l = x.length; i < l; i++) {\n x[i] = y[i];\n }\n};\n\n// Provides: caml_option_of_maybe_undefined\nvar caml_option_of_maybe_undefined = function (x) {\n if (x === undefined) {\n return 0; // None\n } else {\n return [0, x]; // Some(x)\n }\n};\n\n// Provides: caml_option_to_maybe_undefined\nvar caml_option_to_maybe_undefined = function (x) {\n if (x === 0) {\n // None\n return undefined;\n } else {\n return x[1];\n }\n};\n\n// Provides: caml_pasta_fp_size_in_bits\n// Requires: plonk_wasm\nvar caml_pasta_fp_size_in_bits = plonk_wasm.caml_pasta_fp_size_in_bits;\n\n// Provides: caml_pasta_fp_size\n// Requires: plonk_wasm\nvar caml_pasta_fp_size = plonk_wasm.caml_pasta_fp_size;\n\n// Provides: caml_pasta_fp_add\n// Requires: plonk_wasm\nvar caml_pasta_fp_add = plonk_wasm.caml_pasta_fp_add;\n\n// Provides: caml_pasta_fp_sub\n// Requires: plonk_wasm\nvar caml_pasta_fp_sub = plonk_wasm.caml_pasta_fp_sub;\n\n// Provides: caml_pasta_fp_negate\n// Requires: plonk_wasm\nvar caml_pasta_fp_negate = plonk_wasm.caml_pasta_fp_negate;\n\n// Provides: caml_pasta_fp_mul\n// Requires: plonk_wasm\nvar caml_pasta_fp_mul = plonk_wasm.caml_pasta_fp_mul;\n\n// Provides: caml_pasta_fp_div\n// Requires: plonk_wasm\nvar caml_pasta_fp_div = plonk_wasm.caml_pasta_fp_div;\n\n// Provides: caml_pasta_fp_inv\n// Requires: plonk_wasm, caml_option_of_maybe_undefined\nvar caml_pasta_fp_inv = function (x) {\n return caml_option_of_maybe_undefined(plonk_wasm.caml_pasta_fp_inv(x));\n};\n\n// Provides: caml_pasta_fp_square\n// Requires: plonk_wasm\nvar caml_pasta_fp_square = plonk_wasm.caml_pasta_fp_square;\n\n// Provides: caml_pasta_fp_is_square\n// Requires: plonk_wasm, caml_js_to_bool\nvar caml_pasta_fp_is_square = function (x) {\n return caml_js_to_bool(plonk_wasm.caml_pasta_fp_is_square(x));\n};\n\n// Provides: caml_pasta_fp_sqrt\n// Requires: plonk_wasm, caml_option_of_maybe_undefined\nvar caml_pasta_fp_sqrt = function (x) {\n return caml_option_of_maybe_undefined(plonk_wasm.caml_pasta_fp_sqrt(x));\n};\n\n// Provides: caml_pasta_fp_of_int\n// Requires: plonk_wasm\nvar caml_pasta_fp_of_int = plonk_wasm.caml_pasta_fp_of_int;\n\n// Provides: caml_pasta_fp_to_string\n// Requires: plonk_wasm, caml_string_of_jsstring\nvar caml_pasta_fp_to_string = function (x) {\n return caml_string_of_jsstring(plonk_wasm.caml_pasta_fp_to_string(x));\n};\n\n// Provides: caml_pasta_fp_of_string\n// Requires: plonk_wasm, caml_jsstring_of_string\nvar caml_pasta_fp_of_string = function (x) {\n return plonk_wasm.caml_pasta_fp_of_string(caml_jsstring_of_string(x));\n};\n\n// Provides: caml_pasta_fp_print\n// Requires: plonk_wasm\nvar caml_pasta_fp_print = plonk_wasm.caml_pasta_fp_print;\n\n// Provides: caml_pasta_fp_mut_add\n// Requires: caml_pasta_fp_copy, caml_pasta_fp_add\nvar caml_pasta_fp_mut_add = function (x, y) {\n caml_pasta_fp_copy(x, caml_pasta_fp_add(x, y));\n};\n\n// Provides: caml_pasta_fp_mut_sub\n// Requires: caml_pasta_fp_copy, caml_pasta_fp_sub\nvar caml_pasta_fp_mut_sub = function (x, y) {\n caml_pasta_fp_copy(x, caml_pasta_fp_sub(x, y));\n};\n\n// Provides: caml_pasta_fp_mut_mul\n// Requires: caml_pasta_fp_copy, caml_pasta_fp_mul\nvar caml_pasta_fp_mut_mul = function (x, y) {\n caml_pasta_fp_copy(x, caml_pasta_fp_mul(x, y));\n};\n\n// Provides: caml_pasta_fp_mut_square\n// Requires: caml_pasta_fp_copy, caml_pasta_fp_square\nvar caml_pasta_fp_mut_square = function (x) {\n caml_pasta_fp_copy(x, caml_pasta_fp_square(x));\n};\n\n// Provides: caml_pasta_fp_compare\n// Requires: plonk_wasm\nvar caml_pasta_fp_compare = plonk_wasm.caml_pasta_fp_compare;\n\n// Provides: caml_pasta_fp_equal\n// Requires: plonk_wasm\nvar caml_pasta_fp_equal = plonk_wasm.caml_pasta_fp_equal;\n\n// Provides: caml_pasta_fp_random\n// Requires: plonk_wasm\nvar caml_pasta_fp_random = plonk_wasm.caml_pasta_fp_random;\n\n// Provides: caml_pasta_fp_rng\n// Requires: plonk_wasm\nvar caml_pasta_fp_rng = plonk_wasm.caml_pasta_fp_rng;\n\n// Provides: caml_pasta_fp_to_bigint\n// Requires: plonk_wasm\nvar caml_pasta_fp_to_bigint = plonk_wasm.caml_pasta_fp_to_bigint;\n\n// Provides: caml_pasta_fp_of_bigint\n// Requires: plonk_wasm\nvar caml_pasta_fp_of_bigint = plonk_wasm.caml_pasta_fp_of_bigint;\n\n// Provides: caml_pasta_fp_two_adic_root_of_unity\n// Requires: plonk_wasm\nvar caml_pasta_fp_two_adic_root_of_unity =\n plonk_wasm.caml_pasta_fp_two_adic_root_of_unity;\n\n// Provides: caml_pasta_fp_domain_generator\n// Requires: plonk_wasm\nvar caml_pasta_fp_domain_generator = plonk_wasm.caml_pasta_fp_domain_generator;\n\n// Provides: caml_pasta_fp_to_bytes\n// Requires: plonk_wasm, caml_bytes_of_uint8array\nvar caml_pasta_fp_to_bytes = function (x) {\n var res = plonk_wasm.caml_pasta_fp_to_bytes(x);\n return caml_bytes_of_uint8array(plonk_wasm.caml_pasta_fp_to_bytes(x));\n};\n\n// Provides: caml_pasta_fp_of_bytes\n// Requires: plonk_wasm, caml_bytes_to_uint8array\nvar caml_pasta_fp_of_bytes = function (ocaml_bytes) {\n return plonk_wasm.caml_pasta_fp_of_bytes(\n caml_bytes_to_uint8array(ocaml_bytes)\n );\n};\n\n// Provides: caml_pasta_fp_deep_copy\n// Requires: plonk_wasm\nvar caml_pasta_fp_deep_copy = plonk_wasm.caml_pasta_fp_deep_copy;\n\n// Provides: caml_pasta_fq_copy\nvar caml_pasta_fq_copy = function (x, y) {\n for (var i = 0, l = x.length; i < l; i++) {\n x[i] = y[i];\n }\n};\n\n// Provides: caml_pasta_fq_size_in_bits\n// Requires: plonk_wasm\nvar caml_pasta_fq_size_in_bits = plonk_wasm.caml_pasta_fq_size_in_bits;\n\n// Provides: caml_pasta_fq_size\n// Requires: plonk_wasm\nvar caml_pasta_fq_size = plonk_wasm.caml_pasta_fq_size;\n\n// Provides: caml_pasta_fq_add\n// Requires: plonk_wasm\nvar caml_pasta_fq_add = plonk_wasm.caml_pasta_fq_add;\n\n// Provides: caml_pasta_fq_sub\n// Requires: plonk_wasm\nvar caml_pasta_fq_sub = plonk_wasm.caml_pasta_fq_sub;\n\n// Provides: caml_pasta_fq_negate\n// Requires: plonk_wasm\nvar caml_pasta_fq_negate = plonk_wasm.caml_pasta_fq_negate;\n\n// Provides: caml_pasta_fq_mul\n// Requires: plonk_wasm\nvar caml_pasta_fq_mul = plonk_wasm.caml_pasta_fq_mul;\n\n// Provides: caml_pasta_fq_div\n// Requires: plonk_wasm\nvar caml_pasta_fq_div = plonk_wasm.caml_pasta_fq_div;\n\n// Provides: caml_pasta_fq_inv\n// Requires: plonk_wasm, caml_option_of_maybe_undefined\nvar caml_pasta_fq_inv = function (x) {\n return caml_option_of_maybe_undefined(plonk_wasm.caml_pasta_fq_inv(x));\n};\n\n// Provides: caml_pasta_fq_square\n// Requires: plonk_wasm\nvar caml_pasta_fq_square = plonk_wasm.caml_pasta_fq_square;\n\n// Provides: caml_pasta_fq_is_square\n// Requires: plonk_wasm, caml_js_to_bool\nvar caml_pasta_fq_is_square = function (x) {\n return caml_js_to_bool(plonk_wasm.caml_pasta_fq_is_square(x));\n};\n\n// Provides: caml_pasta_fq_sqrt\n// Requires: plonk_wasm, caml_option_of_maybe_undefined\nvar caml_pasta_fq_sqrt = function (x) {\n return caml_option_of_maybe_undefined(plonk_wasm.caml_pasta_fq_sqrt(x));\n};\n\n// Provides: caml_pasta_fq_of_int\n// Requires: plonk_wasm\nvar caml_pasta_fq_of_int = plonk_wasm.caml_pasta_fq_of_int;\n\n// Provides: caml_pasta_fq_to_string\n// Requires: plonk_wasm, caml_string_of_jsstring\nvar caml_pasta_fq_to_string = function (x) {\n return caml_string_of_jsstring(plonk_wasm.caml_pasta_fq_to_string(x));\n};\n\n// Provides: caml_pasta_fq_of_string\n// Requires: plonk_wasm, caml_jsstring_of_string\nvar caml_pasta_fq_of_string = function (x) {\n return plonk_wasm.caml_pasta_fq_of_string(caml_jsstring_of_string(x));\n};\n\n// Provides: caml_pasta_fq_print\n// Requires: plonk_wasm\nvar caml_pasta_fq_print = plonk_wasm.caml_pasta_fq_print;\n\n// Provides: caml_pasta_fq_mut_add\n// Requires: caml_pasta_fq_copy, caml_pasta_fq_add\nvar caml_pasta_fq_mut_add = function (x, y) {\n caml_pasta_fq_copy(x, caml_pasta_fq_add(x, y));\n};\n\n// Provides: caml_pasta_fq_mut_sub\n// Requires: caml_pasta_fq_copy, caml_pasta_fq_sub\nvar caml_pasta_fq_mut_sub = function (x, y) {\n caml_pasta_fq_copy(x, caml_pasta_fq_sub(x, y));\n};\n\n// Provides: caml_pasta_fq_mut_mul\n// Requires: caml_pasta_fq_copy, caml_pasta_fq_mul\nvar caml_pasta_fq_mut_mul = function (x, y) {\n caml_pasta_fq_copy(x, caml_pasta_fq_mul(x, y));\n};\n\n// Provides: caml_pasta_fq_mut_square\n// Requires: caml_pasta_fq_copy, caml_pasta_fq_square\nvar caml_pasta_fq_mut_square = function (x) {\n caml_pasta_fq_copy(x, caml_pasta_fq_square(x));\n};\n\n// Provides: caml_pasta_fq_compare\n// Requires: plonk_wasm\nvar caml_pasta_fq_compare = plonk_wasm.caml_pasta_fq_compare;\n\n// Provides: caml_pasta_fq_equal\n// Requires: plonk_wasm\nvar caml_pasta_fq_equal = plonk_wasm.caml_pasta_fq_equal;\n\n// Provides: caml_pasta_fq_random\n// Requires: plonk_wasm\nvar caml_pasta_fq_random = plonk_wasm.caml_pasta_fq_random;\n\n// Provides: caml_pasta_fq_rng\n// Requires: plonk_wasm\nvar caml_pasta_fq_rng = plonk_wasm.caml_pasta_fq_rng;\n\n// Provides: caml_pasta_fq_to_bigint\n// Requires: plonk_wasm\nvar caml_pasta_fq_to_bigint = plonk_wasm.caml_pasta_fq_to_bigint;\n\n// Provides: caml_pasta_fq_of_bigint\n// Requires: plonk_wasm\nvar caml_pasta_fq_of_bigint = plonk_wasm.caml_pasta_fq_of_bigint;\n\n// Provides: caml_pasta_fq_two_adic_root_of_unity\n// Requires: plonk_wasm\nvar caml_pasta_fq_two_adic_root_of_unity =\n plonk_wasm.caml_pasta_fq_two_adic_root_of_unity;\n\n// Provides: caml_pasta_fq_domain_generator\n// Requires: plonk_wasm\nvar caml_pasta_fq_domain_generator = plonk_wasm.caml_pasta_fq_domain_generator;\n\n// Provides: caml_pasta_fq_to_bytes\n// Requires: plonk_wasm, caml_bytes_of_uint8array\nvar caml_pasta_fq_to_bytes = function (x) {\n var res = plonk_wasm.caml_pasta_fq_to_bytes(x);\n return caml_bytes_of_uint8array(plonk_wasm.caml_pasta_fq_to_bytes(x));\n};\n\n// Provides: caml_pasta_fq_of_bytes\n// Requires: plonk_wasm, caml_bytes_to_uint8array\nvar caml_pasta_fq_of_bytes = function (ocaml_bytes) {\n return plonk_wasm.caml_pasta_fq_of_bytes(\n caml_bytes_to_uint8array(ocaml_bytes)\n );\n};\n\n// Provides: caml_pasta_fq_deep_copy\n// Requires: plonk_wasm\nvar caml_pasta_fq_deep_copy = plonk_wasm.caml_pasta_fq_deep_copy;\n\n// Provides: caml_u8array_vector_to_rust_flat_vector\nvar caml_u8array_vector_to_rust_flat_vector = function (v) {\n var i = 1; // The first entry is the OCaml tag for arrays\n var len = v.length - i;\n if (len === 0) {\n return new joo_global_object.Uint8Array(0);\n }\n var inner_len = v[i].length;\n var res = new joo_global_object.Uint8Array(len * inner_len);\n for (var pos = 0; i <= len; i++) {\n for (var j = 0; j < inner_len; j++, pos++) {\n res[pos] = v[i][j];\n }\n }\n return res;\n};\n\n// Provides: caml_u8array_vector_of_rust_flat_vector\nvar caml_u8array_vector_of_rust_flat_vector = function (v, inner_len) {\n var len = v.length;\n var output_len = len / inner_len;\n var res = new Array(output_len + 1);\n res[0] = 0; // OCaml tag before array contents, so that we can use this with arrays or vectors\n for (var i = 1, pos = 0; i <= output_len; i++) {\n var inner_res = new joo_global_object.Uint8Array(inner_len);\n for (var j = 0; j < inner_len; j++, pos++) {\n inner_res[j] = v[pos];\n }\n res[i] = inner_res;\n }\n return res;\n};\n\n// Provides: js_class_vector_to_rust_vector\nvar js_class_vector_to_rust_vector = function (v) {\n var len = v.length;\n var res = new joo_global_object.Uint32Array(len);\n for (var i = 0; i < len; i++) {\n // Beware: caller may need to do finalizer things to avoid these\n // pointers disappearing out from under us.\n res[i] = v[i].ptr;\n }\n return res;\n};\n\n// Provides: js_class_vector_of_rust_vector\nvar js_class_vector_of_rust_vector = function (v, klass) {\n // return v.map(klass.__wrap)\n var len = v.length;\n var res = new Array(len);\n for (var i = 0, pos = 0; i < len; i++) {\n // Beware: the caller may need to add finalizers to these.\n res[i] = klass.__wrap(v[i]);\n }\n return res;\n};\n\n// Provides: caml_fp_vector_create\nvar caml_fp_vector_create = function () {\n return [0]; // OCaml tag for arrays, so that we can use the same utility fns on both\n};\n\n// Provides: caml_fp_vector_length\nvar caml_fp_vector_length = function (v) {\n return v.length - 1;\n};\n\n// Provides: caml_fp_vector_emplace_back\nvar caml_fp_vector_emplace_back = function (v, x) {\n v.push(x);\n};\n\n// Provides: caml_fp_vector_get\nvar caml_fp_vector_get = function (v, i) {\n var value = v[i + 1];\n if (value === undefined) {\n throw Error(\n 'caml_fp_vector_get: Index out of bounds, got ' + i + '/' + (v.length - 1)\n );\n }\n return new joo_global_object.Uint8Array(value);\n};\n\n// Provides: caml_fp_vector_to_rust\n// Requires: caml_u8array_vector_to_rust_flat_vector\nvar caml_fp_vector_to_rust = function (v) {\n return caml_u8array_vector_to_rust_flat_vector(v);\n};\n\n// Provides: caml_fp_vector_of_rust\n// Requires: caml_u8array_vector_of_rust_flat_vector\nvar caml_fp_vector_of_rust = function (v) {\n // TODO: Hardcoding this is a little brittle\n return caml_u8array_vector_of_rust_flat_vector(v, 32);\n};\n\n// Provides: caml_fq_vector_create\nvar caml_fq_vector_create = function () {\n return [0]; // OCaml tag for arrays, so that we can use the same utility fns on both\n};\n\n// Provides: caml_fq_vector_length\nvar caml_fq_vector_length = function (v) {\n return v.length - 1;\n};\n\n// Provides: caml_fq_vector_emplace_back\nvar caml_fq_vector_emplace_back = function (v, x) {\n v.push(x);\n};\n\n// Provides: caml_fq_vector_get\nvar caml_fq_vector_get = function (v, i) {\n var value = v[i + 1];\n if (value === undefined) {\n throw Error(\n 'caml_fq_vector_get: Index out of bounds, got ' + i + '/' + (v.length - 1)\n );\n }\n return new joo_global_object.Uint8Array(value);\n};\n\n// Provides: caml_fq_vector_to_rust\n// Requires: caml_u8array_vector_to_rust_flat_vector\nvar caml_fq_vector_to_rust = function (v) {\n return caml_u8array_vector_to_rust_flat_vector(v);\n};\n\n// Provides: caml_fq_vector_of_rust\n// Requires: caml_u8array_vector_of_rust_flat_vector\nvar caml_fq_vector_of_rust = function (v) {\n // TODO: Hardcoding this is a little brittle\n return caml_u8array_vector_of_rust_flat_vector(v, 32);\n};\n\n// Provides: free_finalization_registry\n// Requires: plonk_wasm\nvar free_finalization_registry = new joo_global_object.FinalizationRegistry(\n function (instance_representative) {\n instance_representative.free();\n }\n);\n\n// Provides: free_on_finalize\n// Requires: free_finalization_registry\nvar free_on_finalize = function (x) {\n // This is an unfortunate hack: we're creating a second instance of the\n // class to be able to call free on it. We can't pass the value itself,\n // since the registry holds a strong reference to the representative value.\n //\n // However, the class is only really a wrapper around a pointer, with a\n // reference to the class' prototype as its __prototype__.\n //\n // It might seem cleaner to call the destructor here on the pointer\n // directly, but unfortunately the destructor name is some mangled internal\n // string generated by wasm_bindgen. For now, this is the best,\n // least-brittle way to free once the original class instance gets collected.\n var instance_representative = x.constructor.__wrap(x.ptr);\n free_finalization_registry.register(x, instance_representative, x);\n return x;\n};\n\n// Provides: rust_affine_to_caml_affine\nvar rust_affine_to_caml_affine = function (pt) {\n var infinity = pt.infinity;\n if (infinity) {\n pt.free();\n return 0;\n } else {\n var x = pt.x;\n var y = pt.y;\n pt.free();\n return [0, [0, x, y]];\n }\n};\n\n// Provides: rust_affine_of_caml_affine\nvar rust_affine_of_caml_affine = function (pt, klass) {\n var res = new klass();\n if (pt === 0) {\n res.infinity = true;\n } else {\n // Layout is [0, [0, x, y]]\n // First 0 is the tag (it's the 0th constructor that takes arguments)\n // Second 0 is the block marker for the anonymous tuple arguments\n res.x = pt[1][1];\n res.y = pt[1][2];\n }\n return res;\n};\n\n// Provides: caml_pallas_one\n// Requires: plonk_wasm, free_on_finalize\nvar caml_pallas_one = function () {\n var res = plonk_wasm.caml_pallas_one();\n free_on_finalize(res);\n return res;\n};\n\n// Provides: caml_pallas_add\n// Requires: plonk_wasm, free_on_finalize\nvar caml_pallas_add = function (x, y) {\n var res = plonk_wasm.caml_pallas_add(x, y);\n free_on_finalize(res);\n return res;\n};\n\n// Provides: caml_pallas_sub\n// Requires: plonk_wasm, free_on_finalize\nvar caml_pallas_sub = function (x, y) {\n var res = plonk_wasm.caml_pallas_sub(x, y);\n free_on_finalize(res);\n return res;\n};\n\n// Provides: caml_pallas_negate\n// Requires: plonk_wasm, free_on_finalize\nvar caml_pallas_negate = function (x) {\n var res = plonk_wasm.caml_pallas_negate(x);\n free_on_finalize(res);\n return res;\n};\n\n// Provides: caml_pallas_double\n// Requires: plonk_wasm, free_on_finalize\nvar caml_pallas_double = function (x) {\n var res = plonk_wasm.caml_pallas_double(x);\n free_on_finalize(res);\n return res;\n};\n\n// Provides: caml_pallas_scale\n// Requires: plonk_wasm, free_on_finalize\nvar caml_pallas_scale = function (x, y) {\n var res = plonk_wasm.caml_pallas_scale(x, y);\n free_on_finalize(res);\n return res;\n};\n\n// Provides: caml_pallas_random\n// Requires: plonk_wasm, free_on_finalize\nvar caml_pallas_random = function () {\n var res = plonk_wasm.caml_pallas_random();\n free_on_finalize(res);\n return res;\n};\n\n// Provides: caml_pallas_rng\n// Requires: plonk_wasm, free_on_finalize\nvar caml_pallas_rng = function (i) {\n var res = plonk_wasm.caml_pallas_rng(i);\n free_on_finalize(res);\n return res;\n};\n\n// Provides: caml_pallas_to_affine\n// Requires: plonk_wasm, rust_affine_to_caml_affine\nvar caml_pallas_to_affine = function (pt) {\n var res = plonk_wasm.caml_pallas_to_affine(pt);\n return rust_affine_to_caml_affine(res);\n};\n\n// Provides: caml_pallas_of_affine\n// Requires: plonk_wasm, rust_affine_of_caml_affine, free_on_finalize\nvar caml_pallas_of_affine = function (pt) {\n var res = plonk_wasm.caml_pallas_of_affine(\n rust_affine_of_caml_affine(pt, plonk_wasm.caml_pallas_affine_one)\n );\n free_on_finalize(res);\n return res;\n};\n\n// Provides: caml_pallas_of_affine_coordinates\n// Requires: plonk_wasm, free_on_finalize\nvar caml_pallas_of_affine_coordinates = function (x, y) {\n var res = plonk_wasm.caml_pallas_of_affine_coordinates(x, y);\n free_on_finalize(res);\n return res;\n};\n\n// Provides: caml_pallas_endo_base\n// Requires: plonk_wasm\nvar caml_pallas_endo_base = plonk_wasm.caml_pallas_endo_base;\n\n// Provides: caml_pallas_endo_scalar\n// Requires: plonk_wasm\nvar caml_pallas_endo_scalar = plonk_wasm.caml_pallas_endo_scalar;\n\n// Provides: caml_pallas_affine_deep_copy\n// Requires: plonk_wasm, rust_affine_of_caml_affine, rust_affine_to_caml_affine\nvar caml_pallas_affine_deep_copy = function (pt) {\n return rust_affine_to_caml_affine(\n plonk_wasm.caml_pallas_affine_deep_copy(\n rust_affine_of_caml_affine(pt, plonk_wasm.caml_pallas_affine_one)\n )\n );\n};\n\n// Provides: caml_vesta_one\n// Requires: plonk_wasm, free_on_finalize\nvar caml_vesta_one = function () {\n var res = plonk_wasm.caml_vesta_one();\n free_on_finalize(res);\n return res;\n};\n\n// Provides: caml_vesta_add\n// Requires: plonk_wasm, free_on_finalize\nvar caml_vesta_add = function (x, y) {\n var res = plonk_wasm.caml_vesta_add(x, y);\n free_on_finalize(res);\n return res;\n};\n\n// Provides: caml_vesta_sub\n// Requires: plonk_wasm, free_on_finalize\nvar caml_vesta_sub = function (x, y) {\n var res = plonk_wasm.caml_vesta_sub(x, y);\n free_on_finalize(res);\n return res;\n};\n\n// Provides: caml_vesta_negate\n// Requires: plonk_wasm, free_on_finalize\nvar caml_vesta_negate = function (x) {\n var res = plonk_wasm.caml_vesta_negate(x);\n free_on_finalize(res);\n return res;\n};\n\n// Provides: caml_vesta_double\n// Requires: plonk_wasm, free_on_finalize\nvar caml_vesta_double = function (x) {\n var res = plonk_wasm.caml_vesta_double(x);\n free_on_finalize(res);\n return res;\n};\n\n// Provides: caml_vesta_scale\n// Requires: plonk_wasm, free_on_finalize\nvar caml_vesta_scale = function (x, y) {\n var res = plonk_wasm.caml_vesta_scale(x, y);\n free_on_finalize(res);\n return res;\n};\n\n// Provides: caml_vesta_random\n// Requires: plonk_wasm, free_on_finalize\nvar caml_vesta_random = function () {\n var res = plonk_wasm.caml_vesta_random();\n free_on_finalize(res);\n return res;\n};\n\n// Provides: caml_vesta_rng\n// Requires: plonk_wasm, free_on_finalize\nvar caml_vesta_rng = function (i) {\n var res = plonk_wasm.caml_vesta_rng(i);\n free_on_finalize(res);\n return res;\n};\n\n// Provides: caml_vesta_to_affine\n// Requires: plonk_wasm, rust_affine_to_caml_affine\nvar caml_vesta_to_affine = function (pt) {\n var res = plonk_wasm.caml_vesta_to_affine(pt);\n return rust_affine_to_caml_affine(res);\n};\n\n// Provides: caml_vesta_of_affine\n// Requires: plonk_wasm, rust_affine_of_caml_affine, free_on_finalize\nvar caml_vesta_of_affine = function (pt) {\n var res = plonk_wasm.caml_vesta_of_affine(\n rust_affine_of_caml_affine(pt, plonk_wasm.caml_vesta_affine_one)\n );\n free_on_finalize(res);\n return res;\n};\n\n// Provides: caml_vesta_of_affine_coordinates\n// Requires: plonk_wasm, free_on_finalize\nvar caml_vesta_of_affine_coordinates = function (x, y) {\n var res = plonk_wasm.caml_vesta_of_affine_coordinates(x, y);\n free_on_finalize(res);\n return res;\n};\n\n// Provides: caml_vesta_endo_base\n// Requires: plonk_wasm\nvar caml_vesta_endo_base = plonk_wasm.caml_vesta_endo_base;\n\n// Provides: caml_vesta_endo_scalar\n// Requires: plonk_wasm\nvar caml_vesta_endo_scalar = plonk_wasm.caml_vesta_endo_scalar;\n\n// Provides: caml_vesta_affine_deep_copy\n// Requires: plonk_wasm, rust_affine_of_caml_affine, rust_affine_to_caml_affine\nvar caml_vesta_affine_deep_copy = function (pt) {\n return rust_affine_to_caml_affine(\n plonk_wasm.caml_vesta_affine_deep_copy(\n rust_affine_of_caml_affine(pt, plonk_wasm.caml_vesta_affine_one)\n )\n );\n};\n\n// Provides: caml_array_of_rust_vector\n// Requires: js_class_vector_of_rust_vector\nvar caml_array_of_rust_vector = function (v, klass, convert, should_free) {\n v = js_class_vector_of_rust_vector(v, klass);\n var len = v.length;\n var res = new Array(len + 1);\n res[0] = 0; // OCaml tag before array contents\n for (var i = 0; i < len; i++) {\n var rust_val = v[i];\n res[i + 1] = convert(rust_val);\n if (should_free) {\n rust_val.free();\n }\n }\n return res;\n};\n\n// Provides: caml_array_to_rust_vector\n// Requires: js_class_vector_to_rust_vector, free_finalization_registry\nvar caml_array_to_rust_vector = function (v, convert, mk_new) {\n v = v.slice(1); // Copy, dropping OCaml tag\n for (var i = 0, l = v.length; i < l; i++) {\n var class_val = convert(v[i], mk_new);\n v[i] = class_val;\n // Don't free when GC runs; rust will free on its end.\n free_finalization_registry.unregister(class_val);\n }\n return js_class_vector_to_rust_vector(v);\n};\n\n// Provides: caml_poly_comm_of_rust_poly_comm\n// Requires: rust_affine_to_caml_affine, caml_array_of_rust_vector\nvar caml_poly_comm_of_rust_poly_comm = function (\n poly_comm,\n klass,\n should_free\n) {\n var rust_shifted = poly_comm.shifted;\n var rust_unshifted = poly_comm.unshifted;\n var caml_shifted;\n if (rust_shifted === undefined) {\n caml_shifted = 0;\n } else {\n caml_shifted = [0, rust_affine_to_caml_affine(rust_shifted)];\n }\n var caml_unshifted = caml_array_of_rust_vector(\n rust_unshifted,\n klass,\n rust_affine_to_caml_affine,\n should_free\n );\n return [0, caml_unshifted, caml_shifted];\n};\n\n// Provides: caml_poly_comm_to_rust_poly_comm\n// Requires: rust_affine_of_caml_affine, caml_array_to_rust_vector\nvar caml_poly_comm_to_rust_poly_comm = function (\n poly_comm,\n poly_comm_class,\n mk_affine\n) {\n var caml_unshifted = poly_comm[1];\n var caml_shifted = poly_comm[2];\n var rust_shifted = undefined;\n if (caml_shifted !== 0) {\n rust_shifted = rust_affine_of_caml_affine(caml_shifted[1], mk_affine);\n }\n var rust_unshifted = caml_array_to_rust_vector(\n caml_unshifted,\n rust_affine_of_caml_affine,\n mk_affine\n );\n return new poly_comm_class(rust_unshifted, rust_shifted);\n};\n\n// Provides: caml_vesta_poly_comm_of_rust\n// Requires: plonk_wasm, caml_poly_comm_of_rust_poly_comm\nvar caml_vesta_poly_comm_of_rust = function (x) {\n return caml_poly_comm_of_rust_poly_comm(x, plonk_wasm.WasmGVesta, false);\n};\n\n// Provides: caml_vesta_poly_comm_to_rust\n// Requires: plonk_wasm, caml_poly_comm_to_rust_poly_comm\nvar caml_vesta_poly_comm_to_rust = function (x) {\n return caml_poly_comm_to_rust_poly_comm(\n x,\n plonk_wasm.WasmFpPolyComm,\n plonk_wasm.caml_vesta_affine_one\n );\n};\n\n// Provides: caml_pallas_poly_comm_of_rust\n// Requires: plonk_wasm, caml_poly_comm_of_rust_poly_comm\nvar caml_pallas_poly_comm_of_rust = function (x) {\n return caml_poly_comm_of_rust_poly_comm(x, plonk_wasm.WasmGPallas, false);\n};\n\n// Provides: caml_pallas_poly_comm_to_rust\n// Requires: plonk_wasm, caml_poly_comm_to_rust_poly_comm\nvar caml_pallas_poly_comm_to_rust = function (x) {\n return caml_poly_comm_to_rust_poly_comm(\n x,\n plonk_wasm.WasmFqPolyComm,\n plonk_wasm.caml_pallas_affine_one\n );\n};\n\n// Provides: caml_fp_srs_create\n// Requires: plonk_wasm, free_on_finalize\nvar caml_fp_srs_create = function (i) {\n return free_on_finalize(plonk_wasm.caml_fp_srs_create(i));\n};\n\n// Provides: caml_fp_srs_write\n// Requires: plonk_wasm, caml_jsstring_of_string\nvar caml_fp_srs_write = function (append, t, path) {\n if (append === 0) {\n append = undefined;\n } else {\n append = append[1];\n }\n return plonk_wasm.caml_fp_srs_write(append, t, caml_jsstring_of_string(path));\n};\n\n// Provides: caml_fp_srs_read\n// Requires: plonk_wasm, caml_jsstring_of_string\nvar caml_fp_srs_read = function (offset, path) {\n if (offset === 0) {\n offset = undefined;\n } else {\n offset = offset[1];\n }\n var res = plonk_wasm.caml_fp_srs_read(offset, caml_jsstring_of_string(path));\n if (res) {\n return [0, res]; // Some(res)\n } else {\n return 0; // None\n }\n};\n\n// Provides: caml_fp_srs_lagrange_commitment\n// Requires: plonk_wasm, caml_vesta_poly_comm_of_rust\nvar caml_fp_srs_lagrange_commitment = function (t, domain_size, i) {\n var res = plonk_wasm.caml_fp_srs_lagrange_commitment(t, domain_size, i);\n return caml_vesta_poly_comm_of_rust(res);\n};\n\n// Provides: caml_fp_srs_commit_evaluations\n// Requires: plonk_wasm, caml_vesta_poly_comm_of_rust, caml_fp_vector_to_rust\nvar caml_fp_srs_commit_evaluations = function (t, domain_size, fps) {\n var res = plonk_wasm.caml_fp_srs_commit_evaluations(\n t,\n domain_size,\n caml_fp_vector_to_rust(fps)\n );\n return caml_vesta_poly_comm_of_rust(res);\n};\n\n// Provides: caml_fp_srs_b_poly_commitment\n// Requires: plonk_wasm, caml_vesta_poly_comm_of_rust, caml_u8array_vector_to_rust_flat_vector\nvar caml_fp_srs_b_poly_commitment = function (srs, chals) {\n var res = plonk_wasm.caml_fp_srs_b_poly_commitment(\n srs,\n caml_u8array_vector_to_rust_flat_vector(chals)\n );\n return caml_vesta_poly_comm_of_rust(res);\n};\n\n// Provides: caml_fp_srs_batch_accumulator_check\n// Requires: plonk_wasm, rust_affine_of_caml_affine, caml_array_to_rust_vector, caml_fp_vector_to_rust\nvar caml_fp_srs_batch_accumulator_check = function (srs, comms, chals) {\n var rust_comms = caml_array_to_rust_vector(\n comms,\n rust_affine_of_caml_affine,\n plonk_wasm.caml_vesta_affine_one\n );\n var rust_chals = caml_fp_vector_to_rust(chals);\n var ok = plonk_wasm.caml_fp_srs_batch_accumulator_check(\n srs,\n rust_comms,\n rust_chals\n );\n return ok;\n};\n\n// Provides: caml_fp_srs_batch_accumulator_generate\n// Requires: plonk_wasm, rust_affine_to_caml_affine, caml_array_of_rust_vector, caml_fp_vector_to_rust\nvar caml_fp_srs_batch_accumulator_generate = function (srs, comms, chals) {\n var rust_chals = caml_fp_vector_to_rust(chals);\n var rust_comms = plonk_wasm.caml_fp_srs_batch_accumulator_generate(\n srs,\n comms,\n rust_chals\n );\n return caml_array_of_rust_vector(\n rust_comms,\n plonk_wasm.WasmGVesta,\n rust_affine_to_caml_affine,\n false\n );\n};\n\n// Provides: caml_fp_srs_h\n// Requires: plonk_wasm, rust_affine_to_caml_affine\nvar caml_fp_srs_h = function (t) {\n return rust_affine_to_caml_affine(plonk_wasm.caml_fp_srs_h(t));\n};\n\n// Provides: caml_fq_srs_create\n// Requires: plonk_wasm, free_on_finalize\nvar caml_fq_srs_create = function (i) {\n return free_on_finalize(plonk_wasm.caml_fq_srs_create(i));\n};\n\n// Provides: caml_fq_srs_write\n// Requires: plonk_wasm, caml_jsstring_of_string\nvar caml_fq_srs_write = function (append, t, path) {\n if (append === 0) {\n append = undefined;\n } else {\n append = append[1];\n }\n return plonk_wasm.caml_fq_srs_write(append, t, caml_jsstring_of_string(path));\n};\n\n// Provides: caml_fq_srs_read\n// Requires: plonk_wasm, caml_jsstring_of_string\nvar caml_fq_srs_read = function (offset, path) {\n if (offset === 0) {\n offset = undefined;\n } else {\n offset = offset[1];\n }\n var res = plonk_wasm.caml_fq_srs_read(offset, caml_jsstring_of_string(path));\n if (res) {\n return [0, res]; // Some(res)\n } else {\n return 0; // None\n }\n};\n\n// Provides: caml_fq_srs_lagrange_commitment\n// Requires: plonk_wasm, caml_pallas_poly_comm_of_rust\nvar caml_fq_srs_lagrange_commitment = function (t, domain_size, i) {\n var res = plonk_wasm.caml_fq_srs_lagrange_commitment(t, domain_size, i);\n return caml_pallas_poly_comm_of_rust(res);\n};\n\n// Provides: caml_fq_srs_commit_evaluations\n// Requires: plonk_wasm, caml_pallas_poly_comm_of_rust, caml_fq_vector_to_rust\nvar caml_fq_srs_commit_evaluations = function (t, domain_size, fqs) {\n var res = plonk_wasm.caml_fq_srs_commit_evaluations(\n t,\n domain_size,\n caml_fq_vector_to_rust(fqs)\n );\n return caml_pallas_poly_comm_of_rust(res);\n};\n\n// Provides: caml_fq_srs_b_poly_commitment\n// Requires: plonk_wasm, caml_pallas_poly_comm_of_rust, caml_u8array_vector_to_rust_flat_vector\nvar caml_fq_srs_b_poly_commitment = function (srs, chals) {\n var res = plonk_wasm.caml_fq_srs_b_poly_commitment(\n srs,\n caml_u8array_vector_to_rust_flat_vector(chals)\n );\n return caml_pallas_poly_comm_of_rust(res);\n};\n\n// Provides: caml_fq_srs_batch_accumulator_check\n// Requires: plonk_wasm, rust_affine_of_caml_affine, caml_array_to_rust_vector, caml_fq_vector_to_rust\nvar caml_fq_srs_batch_accumulator_check = function (srs, comms, chals) {\n var rust_comms = caml_array_to_rust_vector(\n comms,\n rust_affine_of_caml_affine,\n plonk_wasm.caml_pallas_affine_one\n );\n var rust_chals = caml_fq_vector_to_rust(chals);\n var ok = plonk_wasm.caml_fq_srs_batch_accumulator_check(\n srs,\n rust_comms,\n rust_chals\n );\n return ok;\n};\n\n// Provides: caml_fq_srs_batch_accumulator_generate\n// Requires: plonk_wasm, rust_affine_to_caml_affine, caml_array_of_rust_vector, caml_fq_vector_to_rust\nvar caml_fq_srs_batch_accumulator_generate = function (srs, comms, chals) {\n var rust_chals = caml_fq_vector_to_rust(chals);\n var rust_comms = plonk_wasm.caml_fq_srs_batch_accumulator_generate(\n srs,\n comms,\n rust_chals\n );\n return caml_array_of_rust_vector(\n rust_comms,\n plonk_wasm.WasmGPallas,\n rust_affine_to_caml_affine,\n false\n );\n};\n\n// Provides: caml_fq_srs_h\n// Requires: plonk_wasm, rust_affine_to_caml_affine\nvar caml_fq_srs_h = function (t) {\n return rust_affine_to_caml_affine(plonk_wasm.caml_fq_srs_h(t));\n};\n\n// Provides: caml_fq_srs_add_lagrange_basis\n// Requires: plonk_wasm\nfunction caml_fq_srs_add_lagrange_basis(srs, log2_size) {\n return plonk_wasm.caml_fq_srs_add_lagrange_basis(srs, log2_size);\n}\n\n// Provides: caml_plonk_wire_of_rust\nvar caml_plonk_wire_of_rust = function (wire) {\n var res = [0, wire.row, wire.col];\n wire.free();\n return res;\n};\n\n// Provides: caml_plonk_wire_to_rust\n// Requires: plonk_wasm\nvar caml_plonk_wire_to_rust = function (wire) {\n return plonk_wasm.Wire.create(wire[1], wire[2]);\n};\n\n// Provides: caml_plonk_wires_of_rust\n// Requires: caml_plonk_wire_of_rust\nvar caml_plonk_wires_of_rust = function (wires) {\n var res = [\n 0,\n caml_plonk_wire_of_rust(wires[0]),\n caml_plonk_wire_of_rust(wires[1]),\n caml_plonk_wire_of_rust(wires[2]),\n caml_plonk_wire_of_rust(wires[3]),\n caml_plonk_wire_of_rust(wires[4]),\n caml_plonk_wire_of_rust(wires[5]),\n caml_plonk_wire_of_rust(wires[6]),\n ];\n wires.free();\n return res;\n};\n\n// Provides: caml_plonk_wires_to_rust\n// Requires: plonk_wasm, caml_plonk_wire_to_rust\nvar caml_plonk_wires_to_rust = function (wires) {\n return new plonk_wasm.WasmGateWires(\n caml_plonk_wire_to_rust(wires[1]),\n caml_plonk_wire_to_rust(wires[2]),\n caml_plonk_wire_to_rust(wires[3]),\n caml_plonk_wire_to_rust(wires[4]),\n caml_plonk_wire_to_rust(wires[5]),\n caml_plonk_wire_to_rust(wires[6]),\n caml_plonk_wire_to_rust(wires[7])\n );\n};\n\n// Provides: caml_plonk_gate_of_rust\n// Requires: caml_plonk_wires_of_rust, caml_u8array_vector_of_rust_flat_vector\nvar caml_plonk_gate_of_rust = function (gate) {\n // TODO: Hardcoding 32 here is a little brittle\n var res = [\n 0,\n gate.typ,\n caml_plonk_wires_of_rust(gate.wires),\n caml_u8array_vector_of_rust_flat_vector(gate.c, 32),\n ];\n gate.free();\n return res;\n};\n\n// Provides: caml_fp_plonk_gate_to_rust\n// Requires: plonk_wasm, caml_plonk_wires_to_rust, caml_u8array_vector_to_rust_flat_vector\nvar caml_fp_plonk_gate_to_rust = function (gate) {\n return new plonk_wasm.WasmFpGate(\n gate[1],\n caml_plonk_wires_to_rust(gate[2]),\n caml_u8array_vector_to_rust_flat_vector(gate[3])\n );\n};\n\n// Provides: caml_fq_plonk_gate_to_rust\n// Requires: plonk_wasm, caml_plonk_wires_to_rust, caml_u8array_vector_to_rust_flat_vector\nvar caml_fq_plonk_gate_to_rust = function (gate) {\n // TODO: Hardcoding 32 here is a little brittle\n return new plonk_wasm.WasmFqGate(\n gate[1],\n caml_plonk_wires_to_rust(gate[2]),\n caml_u8array_vector_to_rust_flat_vector(gate[3])\n );\n};\n\n// Provides: caml_fp_lookup_table_to_rust\n// Requires: plonk_wasm, caml_fp_vector_of_rust, caml_get_field_of_caml_record\nvar caml_fp_lookup_table_to_rust = function (caml_lookup_table, mk_class) {\n // A value lookup table is a caml record with an id and a data field.\n // The converter should be changed if CamlLookupTable is modified.\n // id field: int32\n var caml_lookup_table_id = caml_get_field_of_caml_record(\n caml_lookup_table,\n 0\n );\n // data field: caml array of fq vectors\n var caml_lookup_table_data = caml_get_field_of_caml_record(\n caml_lookup_table,\n 1\n );\n // caml_lookup_table_data is a Caml array, starting with 0 for the runtime repr.\n // removing 1 for the 0 used by jsoo to represent values.\n var lt_data_length = caml_lookup_table_data.length - 1;\n var data = new plonk_wasm.WasmVecVecFp(lt_data_length);\n for (var i = 1; i < lt_data_length; i++) {\n data.push(caml_fp_vector_of_rust(caml_lookup_table_data.get(i - 1)));\n }\n var res = new mk_class(caml_lookup_table_id, data);\n return res;\n};\n\n// Provides: caml_fq_lookup_table_to_rust\n// Requires: plonk_wasm, caml_fq_vector_to_rust, caml_get_field_of_caml_record\nvar caml_fq_lookup_table_to_rust = function (caml_lookup_table, mk_class) {\n // A value lookup table is a caml record with an id and a data field.\n // The converter should be changed if CamlLookupTable is modified.\n // id field: int32\n var caml_lookup_table_id = caml_get_field_of_caml_record(\n caml_lookup_table,\n 0\n );\n // data field: caml array of fq vectors\n var caml_lookup_table_data = caml_get_field_of_caml_record(\n caml_lookup_table,\n 1\n );\n // caml_lookup_table_data is a Caml array, starting with 0 for the runtime repr.\n // removing 1 for the 0 used by jsoo to represent values.\n var lt_data_length = caml_lookup_table_data.length - 1;\n var data = new plonk_wasm.WasmVecVecFq(lt_data_length);\n for (var i = 1; i < lt_data_length; i++) {\n data.push(caml_fq_vector_to_rust(caml_lookup_table_data.get(i - 1)));\n }\n var res = new mk_class(caml_lookup_table_id, data);\n return res;\n};\n\n// Provides: caml_pasta_fp_plonk_gate_vector_create\n// Requires: plonk_wasm, free_on_finalize\nvar caml_pasta_fp_plonk_gate_vector_create = function () {\n return free_on_finalize(plonk_wasm.caml_pasta_fp_plonk_gate_vector_create());\n};\n\n// Provides: caml_pasta_fp_plonk_gate_vector_add\n// Requires: plonk_wasm, caml_fp_plonk_gate_to_rust\nvar caml_pasta_fp_plonk_gate_vector_add = function (v, x) {\n return plonk_wasm.caml_pasta_fp_plonk_gate_vector_add(\n v,\n caml_fp_plonk_gate_to_rust(x)\n );\n};\n\n// Provides: caml_pasta_fp_plonk_gate_vector_get\n// Requires: plonk_wasm, caml_plonk_gate_of_rust\nvar caml_pasta_fp_plonk_gate_vector_get = function (v, i) {\n return caml_plonk_gate_of_rust(\n plonk_wasm.caml_pasta_fp_plonk_gate_vector_get(v, i)\n );\n};\n\n// Provides: caml_pasta_fp_plonk_gate_vector_len\n// Requires: plonk_wasm\nvar caml_pasta_fp_plonk_gate_vector_len = function (v) {\n return plonk_wasm.caml_pasta_fp_plonk_gate_vector_len(v);\n};\n\n// Provides: caml_pasta_fp_plonk_gate_vector_wrap\n// Requires: plonk_wasm, caml_plonk_wire_to_rust\nvar caml_pasta_fp_plonk_gate_vector_wrap = function (v, x, y) {\n return plonk_wasm.caml_pasta_fp_plonk_gate_vector_wrap(\n v,\n caml_plonk_wire_to_rust(x),\n caml_plonk_wire_to_rust(y)\n );\n};\n\n// Provides: caml_pasta_fp_plonk_gate_vector_digest\n// Requires: plonk_wasm, caml_bytes_of_uint8array\nvar caml_pasta_fp_plonk_gate_vector_digest = function (\n public_input_size,\n gate_vector\n) {\n var uint8array = plonk_wasm.caml_pasta_fp_plonk_gate_vector_digest(\n public_input_size,\n gate_vector\n );\n return caml_bytes_of_uint8array(uint8array);\n};\n\n// Provides: caml_pasta_fp_plonk_circuit_serialize\n// Requires: plonk_wasm, caml_string_of_jsstring\nvar caml_pasta_fp_plonk_circuit_serialize = function (\n public_input_size,\n gate_vector\n) {\n return caml_string_of_jsstring(\n plonk_wasm.caml_pasta_fp_plonk_circuit_serialize(\n public_input_size,\n gate_vector\n )\n );\n};\n\n// Provides: caml_pasta_fq_plonk_gate_vector_create\n// Requires: plonk_wasm, free_on_finalize\nvar caml_pasta_fq_plonk_gate_vector_create = function () {\n return free_on_finalize(plonk_wasm.caml_pasta_fq_plonk_gate_vector_create());\n};\n\n// Provides: caml_pasta_fq_plonk_gate_vector_add\n// Requires: plonk_wasm, caml_fq_plonk_gate_to_rust\nvar caml_pasta_fq_plonk_gate_vector_add = function (v, x) {\n return plonk_wasm.caml_pasta_fq_plonk_gate_vector_add(\n v,\n caml_fq_plonk_gate_to_rust(x)\n );\n};\n\n// Provides: caml_pasta_fq_plonk_gate_vector_get\n// Requires: plonk_wasm, caml_plonk_gate_of_rust\nvar caml_pasta_fq_plonk_gate_vector_get = function (v, i) {\n return caml_plonk_gate_of_rust(\n plonk_wasm.caml_pasta_fq_plonk_gate_vector_get(v, i)\n );\n};\n\n// Provides: caml_pasta_fq_plonk_gate_vector_len\n// Requires: plonk_wasm\nvar caml_pasta_fq_plonk_gate_vector_len = function (v) {\n return plonk_wasm.caml_pasta_fq_plonk_gate_vector_len(v);\n};\n\n// Provides: caml_pasta_fq_plonk_gate_vector_wrap\n// Requires: plonk_wasm, caml_plonk_wire_to_rust\nvar caml_pasta_fq_plonk_gate_vector_wrap = function (v, x, y) {\n return plonk_wasm.caml_pasta_fq_plonk_gate_vector_wrap(\n v,\n caml_plonk_wire_to_rust(x),\n caml_plonk_wire_to_rust(y)\n );\n};\n\n// Provides: caml_pasta_fq_plonk_gate_vector_digest\n// Requires: plonk_wasm, caml_bytes_of_uint8array\nvar caml_pasta_fq_plonk_gate_vector_digest = function (\n public_input_size,\n gate_vector\n) {\n var uint8array = plonk_wasm.caml_pasta_fq_plonk_gate_vector_digest(\n public_input_size,\n gate_vector\n );\n return caml_bytes_of_uint8array(uint8array);\n};\n\n// Provides: caml_pasta_fq_plonk_circuit_serialize\n// Requires: plonk_wasm, caml_string_of_jsstring\nvar caml_pasta_fq_plonk_circuit_serialize = function (\n public_input_size,\n gate_vector\n) {\n return caml_string_of_jsstring(\n plonk_wasm.caml_pasta_fq_plonk_circuit_serialize(\n public_input_size,\n gate_vector\n )\n );\n};\n\n// Provides: caml_fp_runtime_table_cfg_to_rust\n// Requires: plonk_wasm, caml_fp_vector_to_rust, caml_get_field_of_caml_record\nvar caml_fp_runtime_table_cfg_to_rust = function (\n caml_runtime_table_cfg,\n mk_class\n) {\n // A value caml_runtime_table_cfg is a record on the OCaml side.\n // The converter should be changed if CamlRuntimeTableCfg is modified.\n // id field: int32\n var caml_runtime_table_cfg_id = caml_get_field_of_caml_record(\n caml_runtime_table_cfg,\n 0\n );\n // first_column field: Caml array of fq element\n var caml_runtime_table_cfg_first_column = caml_get_field_of_caml_record(\n caml_runtime_table_cfg,\n 1\n );\n var res = new mk_class(\n caml_runtime_table_cfg_id,\n caml_fp_vector_to_rust(caml_runtime_table_cfg_first_column)\n );\n return res;\n};\n\n// Provides: caml_pasta_fp_plonk_index_create\n// Requires: plonk_wasm, free_on_finalize, caml_array_to_rust_vector, caml_fp_runtime_table_cfg_to_rust, caml_create_rust_empty_vector, caml_is_empty_caml_array\nvar caml_pasta_fp_plonk_index_create = function (\n gates,\n public_inputs,\n caml_runtime_table_cfgs,\n prev_challenges,\n urs\n) {\n var wasm_runtime_table_cfgs;\n\n if (caml_is_empty_caml_array(caml_runtime_table_cfgs)) {\n wasm_runtime_table_cfgs = caml_create_rust_empty_vector();\n } else {\n wasm_runtime_table_cfgs = caml_array_to_rust_vector(\n caml_runtime_table_cfgs,\n caml_fp_runtime_table_cfg_to_rust,\n plonk_wasm.WasmPastaFpRuntimeTableCfg\n );\n }\n\n var t = plonk_wasm.caml_pasta_fp_plonk_index_create(\n gates,\n public_inputs,\n wasm_runtime_table_cfgs,\n prev_challenges,\n urs\n );\n return free_on_finalize(t);\n};\n\n// Provides: caml_pasta_fp_plonk_index_max_degree\n// Requires: plonk_wasm\nvar caml_pasta_fp_plonk_index_max_degree =\n plonk_wasm.caml_pasta_fp_plonk_index_max_degree;\n\n// Provides: caml_pasta_fp_plonk_index_public_inputs\n// Requires: plonk_wasm\nvar caml_pasta_fp_plonk_index_public_inputs =\n plonk_wasm.caml_pasta_fp_plonk_index_public_inputs;\n\n// Provides: caml_pasta_fp_plonk_index_domain_d1_size\n// Requires: plonk_wasm\nvar caml_pasta_fp_plonk_index_domain_d1_size =\n plonk_wasm.caml_pasta_fp_plonk_index_domain_d1_size;\n\n// Provides: caml_pasta_fp_plonk_index_domain_d4_size\n// Requires: plonk_wasm\nvar caml_pasta_fp_plonk_index_domain_d4_size =\n plonk_wasm.caml_pasta_fp_plonk_index_domain_d4_size;\n\n// Provides: caml_pasta_fp_plonk_index_domain_d8_size\n// Requires: plonk_wasm\nvar caml_pasta_fp_plonk_index_domain_d8_size =\n plonk_wasm.caml_pasta_fp_plonk_index_domain_d8_size;\n\n// Provides: caml_pasta_fp_plonk_index_read\n// Requires: plonk_wasm, caml_jsstring_of_string\nvar caml_pasta_fp_plonk_index_read = function (offset, urs, path) {\n if (offset === 0) {\n offset = undefined;\n } else {\n offset = offset[1];\n }\n return plonk_wasm.caml_pasta_fp_plonk_index_read(\n offset,\n urs,\n caml_jsstring_of_string(path)\n );\n};\n\n// Provides: caml_pasta_fp_plonk_index_write\n// Requires: plonk_wasm, caml_jsstring_of_string\nvar caml_pasta_fp_plonk_index_write = function (append, t, path) {\n if (append === 0) {\n append = undefined;\n } else {\n append = append[1];\n }\n return plonk_wasm.caml_pasta_fp_plonk_index_write(\n append,\n t,\n caml_jsstring_of_string(path)\n );\n};\n\n// Provides: caml_fq_runtime_table_cfg_to_rust\n// Requires: plonk_wasm, caml_fq_vector_to_rust, caml_get_field_of_caml_record\nvar caml_fq_runtime_table_cfg_to_rust = function (\n caml_runtime_table_cfg,\n mk_class\n) {\n // A value caml_runtime_table_cfg is a record on the OCaml side.\n // The converter should be changed if CamlRuntimeTableCfg is modified.\n // id field: int32\n var caml_runtime_table_cfg_id = caml_get_field_of_caml_record(\n caml_runtime_table_cfg,\n 0\n );\n // first_column field: Caml array of fq element\n var caml_runtime_table_cfg_first_column = caml_get_field_of_caml_record(\n caml_runtime_table_cfg,\n 1\n );\n var res = new mk_class(\n caml_runtime_table_cfg_id,\n caml_fq_vector_to_rust(caml_runtime_table_cfg_first_column)\n );\n return res;\n};\n\n// Provides: caml_pasta_fq_plonk_index_create\n// Requires: plonk_wasm, free_on_finalize, caml_array_to_rust_vector, caml_fq_runtime_table_cfg_to_rust, caml_is_empty_caml_array, caml_create_rust_empty_vector\nvar caml_pasta_fq_plonk_index_create = function (\n gates,\n public_inputs,\n caml_runtime_table_cfgs,\n prev_challenges,\n urs\n) {\n var wasm_runtime_table_cfgs;\n\n if (caml_is_empty_caml_array(caml_runtime_table_cfgs)) {\n wasm_runtime_table_cfgs = caml_create_rust_empty_vector();\n } else {\n wasm_runtime_table_cfgs = caml_array_to_rust_vector(\n caml_runtime_table_cfgs,\n caml_fq_runtime_table_cfg_to_rust,\n plonk_wasm.WasmPastaFqRuntimeTableCfg\n );\n }\n\n return free_on_finalize(\n plonk_wasm.caml_pasta_fq_plonk_index_create(\n gates,\n public_inputs,\n wasm_runtime_table_cfgs,\n prev_challenges,\n urs\n )\n );\n};\n\n// Provides: caml_pasta_fq_plonk_index_max_degree\n// Requires: plonk_wasm\nvar caml_pasta_fq_plonk_index_max_degree =\n plonk_wasm.caml_pasta_fq_plonk_index_max_degree;\n\n// Provides: caml_pasta_fq_plonk_index_public_inputs\n// Requires: plonk_wasm\nvar caml_pasta_fq_plonk_index_public_inputs =\n plonk_wasm.caml_pasta_fq_plonk_index_public_inputs;\n\n// Provides: caml_pasta_fq_plonk_index_domain_d1_size\n// Requires: plonk_wasm\nvar caml_pasta_fq_plonk_index_domain_d1_size =\n plonk_wasm.caml_pasta_fq_plonk_index_domain_d1_size;\n\n// Provides: caml_pasta_fq_plonk_index_domain_d4_size\n// Requires: plonk_wasm\nvar caml_pasta_fq_plonk_index_domain_d4_size =\n plonk_wasm.caml_pasta_fq_plonk_index_domain_d4_size;\n\n// Provides: caml_pasta_fq_plonk_index_domain_d8_size\n// Requires: plonk_wasm\nvar caml_pasta_fq_plonk_index_domain_d8_size =\n plonk_wasm.caml_pasta_fq_plonk_index_domain_d8_size;\n\n// Provides: caml_pasta_fq_plonk_index_read\n// Requires: plonk_wasm, caml_jsstring_of_string\nvar caml_pasta_fq_plonk_index_read = function (offset, urs, path) {\n if (offset === 0) {\n offset = undefined;\n } else {\n offset = offset[1];\n }\n return plonk_wasm.caml_pasta_fq_plonk_index_read(\n offset,\n urs,\n caml_jsstring_of_string(path)\n );\n};\n\n// Provides: caml_pasta_fq_plonk_index_write\n// Requires: plonk_wasm, caml_jsstring_of_string\nvar caml_pasta_fq_plonk_index_write = function (append, t, path) {\n if (append === 0) {\n append = undefined;\n } else {\n append = append[1];\n }\n return plonk_wasm.caml_pasta_fq_plonk_index_write(\n append,\n t,\n caml_jsstring_of_string(path)\n );\n};\n\n// Provides: caml_plonk_domain_of_rust\nvar caml_plonk_domain_of_rust = function (x) {\n var log_size_of_group = x.log_size_of_group;\n var group_gen = x.group_gen;\n x.free();\n return [0, log_size_of_group, group_gen];\n};\n\n// Provides: caml_plonk_domain_to_rust\n// Requires: free_on_finalize\nvar caml_plonk_domain_to_rust = function (x, klass) {\n // TODO: Check if this gets finalized\n return new klass(x[1], x[2]);\n};\n\n// Provides: caml_plonk_verification_evals_of_rust\n// Requires: caml_poly_comm_of_rust_poly_comm, js_class_vector_of_rust_vector, plonk_wasm\nvar caml_plonk_verification_evals_of_rust = function (x, affine_klass) {\n var convert = function (poly_comm) {\n return caml_poly_comm_of_rust_poly_comm(poly_comm, affine_klass, false);\n };\n\n // var convertArray = function(comms) {\n // var n = comms.length;\n // var res = new Array(n-1);\n // for (var i = 1; i < n; i++) {\n // res[i-1] = convert(comms[i]);\n // }\n // return js_class_vector_to_rust_vector(res);\n // };\n\n // should be inverse of the above ^\n // TODO: make work for both Wasm..PolyComm types\n var convertArray = function (comms) {\n comms = js_class_vector_of_rust_vector(comms, plonk_wasm.WasmFqPolyComm);\n // comms = js_class_vector_of_rust_vector(comms, plonk_wasm.WasmFpPolyComm);\n return [0].concat(comms.map(convert));\n };\n\n var sigma_comm = convertArray(x.sigma_comm);\n var coefficients_comm = convertArray(x.coefficients_comm);\n var generic_comm = convert(x.generic_comm);\n var psm_comm = convert(x.psm_comm);\n var complete_add_comm = convert(x.complete_add_comm);\n var mul_comm = convert(x.mul_comm);\n var emul_comm = convert(x.emul_comm);\n var endomul_scalar_comm = convert(x.endomul_scalar_comm);\n\n x.free();\n return [\n 0,\n sigma_comm,\n coefficients_comm,\n generic_comm,\n psm_comm,\n complete_add_comm,\n mul_comm,\n emul_comm,\n endomul_scalar_comm,\n 0,\n ];\n};\n\n// Provides: caml_plonk_verification_evals_to_rust\n// Requires: caml_poly_comm_to_rust_poly_comm, js_class_vector_to_rust_vector\nvar caml_plonk_verification_evals_to_rust = function (\n x,\n klass,\n poly_comm_class,\n mk_affine\n) {\n var convert = function (poly_comm) {\n return caml_poly_comm_to_rust_poly_comm(\n poly_comm,\n poly_comm_class,\n mk_affine\n );\n };\n\n var convertArray = function (comms) {\n var n = comms.length;\n var res = new Array(n - 1);\n for (var i = 1; i < n; i++) {\n res[i - 1] = convert(comms[i]);\n }\n return js_class_vector_to_rust_vector(res);\n };\n\n var sigma_comm = convertArray(x[1]);\n var coefficients_comm = convertArray(x[2]);\n var generic_comm = convert(x[3]);\n var psm_comm = convert(x[4]);\n var complete_add_comm = convert(x[5]);\n var mul_comm = convert(x[6]);\n var emul_comm = convert(x[7]);\n var endomul_scalar_comm = convert(x[8]);\n\n return new klass(\n sigma_comm,\n coefficients_comm,\n generic_comm,\n psm_comm,\n complete_add_comm,\n mul_comm,\n emul_comm,\n endomul_scalar_comm\n );\n};\n\n// Provides: caml_plonk_verification_shifts_of_rust\nvar caml_plonk_verification_shifts_of_rust = function (x) {\n var res = [0, x.s0, x.s1, x.s2, x.s3, x.s4, x.s5, x.s6];\n x.free();\n return res;\n};\n\n// Provides: caml_plonk_verification_shifts_to_rust\nvar caml_plonk_verification_shifts_to_rust = function (x, klass) {\n return new klass(x[1], x[2], x[3], x[4], x[5], x[6], x[7]);\n};\n\n// Provides: column_of_rust\nfunction column_of_rust(col) {\n // type nonrec column = Witness of int | Z | LookupSorted of int | LookupAggreg | LookupTable | LookupKindIndex of int | Index of gate_type | Coefficient of int\n var tag = col.tag;\n var gate_type = col.gate_type;\n var i = col.i;\n col.free();\n return (\n {\n 0: [tag, i],\n 2: [tag, i],\n 5: [tag, i],\n 6: [tag, gate_type],\n 7: [tag, i],\n }[tag] || tag\n );\n}\n\n// Provides: variable_of_rust\n// Requires: column_of_rust\nfunction variable_of_rust(variable) {\n // col * row\n var col = variable.col;\n var row = variable.row; // 0, 1\n variable.free();\n return [0, column_of_rust(col), row];\n}\n\n// Provides: polish_token_of_rust\n// Requires: variable_of_rust\nfunction polish_token_of_rust(token) {\n var tag = token.tag;\n var i0 = token.i0;\n var i1 = token.i1;\n var f = token.f;\n var v = variable_of_rust(token.v);\n token.free();\n return (\n {\n 5: [5, i0, i1],\n 6: [6, f],\n 7: [7, v],\n 9: [9, i0],\n 14: [14, i0],\n 16: [16, i0],\n }[tag] || tag\n );\n}\n\n// Provides: index_term_of_rust\n// Requires: column_of_rust, js_class_vector_of_rust_vector, polish_token_of_rust\nfunction index_term_of_rust(term, token_class) {\n // pub column: WasmColumn,\n // pub coefficient: WasmVector,\n var column = column_of_rust(term.column);\n var coefficient = js_class_vector_of_rust_vector(\n term.coefficient,\n token_class\n );\n coefficient = coefficient.map(polish_token_of_rust);\n coefficient = [0].concat(coefficient);\n term.free();\n return [0, column, coefficient];\n}\n\n// Provides: wrap\nfunction wrap(ptr, klass) {\n var obj = Object.create(klass.prototype);\n obj.ptr = ptr;\n return obj;\n}\n\n// Provides: linearization_of_rust\n// Requires: plonk_wasm, js_class_vector_of_rust_vector, polish_token_of_rust, wrap, index_term_of_rust\nfunction linearization_of_rust(linearization, affine_class) {\n var F = affine_class === plonk_wasm.WasmGVesta ? 'Fq' : 'Fp';\n var WasmPolishToken = plonk_wasm['Wasm' + F + 'PolishToken'];\n var WasmIndexTerm = plonk_wasm['Wasm' + F + 'IndexTerm'];\n\n var constant_term = js_class_vector_of_rust_vector(\n linearization.constant_term,\n WasmPolishToken\n );\n constant_term = constant_term.map(polish_token_of_rust);\n constant_term = [0].concat(constant_term);\n\n var index_terms = Array.from(linearization.index_terms).map(function (ptr) {\n var wasmIndexTerm = wrap(ptr, WasmIndexTerm);\n return index_term_of_rust(wasmIndexTerm, WasmPolishToken);\n });\n index_terms = [0].concat(index_terms);\n\n linearization.free();\n return [0, constant_term, index_terms];\n}\n\n// Provides: None\nvar None = 0;\n\n// Provides: caml_plonk_verifier_index_of_rust\n// Requires: linearization_of_rust, caml_plonk_domain_of_rust, caml_plonk_verification_evals_of_rust, caml_plonk_verification_shifts_of_rust, free_on_finalize, None\nvar caml_plonk_verifier_index_of_rust = function (x, affine_class) {\n var domain = caml_plonk_domain_of_rust(x.domain);\n var max_poly_size = x.max_poly_size;\n var public_ = x.public_;\n var prev_challenges = x.prev_challenges;\n var srs = free_on_finalize(x.srs);\n var evals = caml_plonk_verification_evals_of_rust(x.evals, affine_class);\n var shifts = caml_plonk_verification_shifts_of_rust(x.shifts);\n // TODO: Handle linearization correctly!\n // var linearization = linearization_of_rust(x.linearization, affine_class);\n var lookup_index = None;\n x.free();\n return [\n 0,\n domain,\n max_poly_size,\n public_,\n prev_challenges,\n srs,\n evals,\n shifts,\n None,\n ];\n};\n// Provides: caml_plonk_verifier_index_to_rust\n// Requires: caml_plonk_domain_to_rust, caml_plonk_verification_evals_to_rust, caml_plonk_verification_shifts_to_rust, free_finalization_registry\nvar caml_plonk_verifier_index_to_rust = function (\n x,\n klass,\n domain_class,\n verification_evals_class,\n poly_comm_class,\n mk_affine,\n verification_shifts_class\n) {\n var domain = caml_plonk_domain_to_rust(x[1], domain_class);\n var max_poly_size = x[2];\n var public_ = x[3];\n var prev_challenges = x[4];\n var srs = x[5];\n var evals = caml_plonk_verification_evals_to_rust(\n x[6],\n verification_evals_class,\n poly_comm_class,\n mk_affine\n );\n var shifts = caml_plonk_verification_shifts_to_rust(\n x[7],\n verification_shifts_class\n );\n return new klass(\n domain,\n max_poly_size,\n public_,\n prev_challenges,\n srs,\n evals,\n shifts\n );\n};\n\n// Provides: caml_pasta_fp_plonk_verifier_index_of_rust\n// Requires: plonk_wasm, caml_plonk_verifier_index_of_rust\nvar caml_pasta_fp_plonk_verifier_index_of_rust = function (x) {\n return caml_plonk_verifier_index_of_rust(x, plonk_wasm.WasmGVesta);\n};\n\n// Provides: caml_pasta_fp_plonk_verifier_index_to_rust\n// Requires: plonk_wasm, caml_plonk_verifier_index_to_rust\nvar caml_pasta_fp_plonk_verifier_index_to_rust = function (x) {\n return caml_plonk_verifier_index_to_rust(\n x,\n plonk_wasm.WasmFpPlonkVerifierIndex,\n plonk_wasm.WasmFpDomain,\n plonk_wasm.WasmFpPlonkVerificationEvals,\n plonk_wasm.WasmFpPolyComm,\n plonk_wasm.caml_vesta_affine_one,\n plonk_wasm.WasmFpShifts\n );\n};\n\n// Provides: caml_pasta_fp_plonk_verifier_index_create\n// Requires: plonk_wasm, caml_pasta_fp_plonk_verifier_index_of_rust\nvar caml_pasta_fp_plonk_verifier_index_create = function (x) {\n var vk = plonk_wasm.caml_pasta_fp_plonk_verifier_index_create(x);\n var vk_caml = caml_pasta_fp_plonk_verifier_index_of_rust(vk);\n return vk_caml;\n};\n\n// Provides: caml_pasta_fp_plonk_verifier_index_read\n// Requires: plonk_wasm, caml_jsstring_of_string, caml_pasta_fp_plonk_verifier_index_of_rust\nvar caml_pasta_fp_plonk_verifier_index_read = function (offset, urs, path) {\n if (offset === 0) {\n offset = undefined;\n } else {\n offset = offset[1];\n }\n return caml_pasta_fp_plonk_verifier_index_of_rust(\n plonk_wasm.caml_pasta_fp_plonk_verifier_index_read(\n offset,\n urs,\n caml_jsstring_of_string(path)\n )\n );\n};\n\n// Provides: caml_pasta_fp_plonk_verifier_index_write\n// Requires: plonk_wasm, caml_jsstring_of_string, caml_pasta_fp_plonk_verifier_index_to_rust\nvar caml_pasta_fp_plonk_verifier_index_write = function (append, t, path) {\n if (append === 0) {\n append = undefined;\n } else {\n append = append[1];\n }\n return plonk_wasm.caml_pasta_fp_plonk_verifier_index_write(\n append,\n caml_pasta_fp_plonk_verifier_index_to_rust(t),\n caml_jsstring_of_string(path)\n );\n};\n\n// Provides: caml_pasta_fp_plonk_verifier_index_shifts\n// Requires: plonk_wasm, caml_plonk_verification_shifts_of_rust\nvar caml_pasta_fp_plonk_verifier_index_shifts = function (log2_size) {\n return caml_plonk_verification_shifts_of_rust(\n plonk_wasm.caml_pasta_fp_plonk_verifier_index_shifts(log2_size)\n );\n};\n\n// Provides: caml_pasta_fp_plonk_verifier_index_dummy\n// Requires: plonk_wasm, caml_pasta_fp_plonk_verifier_index_of_rust\nvar caml_pasta_fp_plonk_verifier_index_dummy = function () {\n var res = plonk_wasm.caml_pasta_fp_plonk_verifier_index_dummy();\n return caml_pasta_fp_plonk_verifier_index_of_rust(res);\n // return caml_pasta_fp_plonk_verifier_index_of_rust(plonk_wasm.caml_pasta_fp_plonk_verifier_index_dummy());\n};\n\n// Provides: caml_pasta_fp_plonk_verifier_index_deep_copy\n// Requires: plonk_wasm, caml_pasta_fp_plonk_verifier_index_of_rust, caml_pasta_fp_plonk_verifier_index_to_rust\nvar caml_pasta_fp_plonk_verifier_index_deep_copy = function (x) {\n return caml_pasta_fp_plonk_verifier_index_of_rust(\n plonk_wasm.caml_pasta_fp_plonk_verifier_index_deep_copy(\n caml_pasta_fp_plonk_verifier_index_to_rust(x)\n )\n );\n};\n\n// Provides: caml_pasta_fq_plonk_verifier_index_of_rust\n// Requires: plonk_wasm, caml_plonk_verifier_index_of_rust\nvar caml_pasta_fq_plonk_verifier_index_of_rust = function (x) {\n return caml_plonk_verifier_index_of_rust(x, plonk_wasm.WasmGPallas);\n};\n\n// Provides: caml_pasta_fq_plonk_verifier_index_to_rust\n// Requires: plonk_wasm, caml_plonk_verifier_index_to_rust\nvar caml_pasta_fq_plonk_verifier_index_to_rust = function (x) {\n return caml_plonk_verifier_index_to_rust(\n x,\n plonk_wasm.WasmFqPlonkVerifierIndex,\n plonk_wasm.WasmFqDomain,\n plonk_wasm.WasmFqPlonkVerificationEvals,\n plonk_wasm.WasmFqPolyComm,\n plonk_wasm.caml_pallas_affine_one,\n plonk_wasm.WasmFqShifts\n );\n};\n\n// Provides: caml_pasta_fq_plonk_verifier_index_create\n// Requires: plonk_wasm, caml_pasta_fq_plonk_verifier_index_of_rust\nvar caml_pasta_fq_plonk_verifier_index_create = function (x) {\n return caml_pasta_fq_plonk_verifier_index_of_rust(\n plonk_wasm.caml_pasta_fq_plonk_verifier_index_create(x)\n );\n};\n\n// Provides: caml_pasta_fq_plonk_verifier_index_read\n// Requires: plonk_wasm, caml_jsstring_of_string, caml_pasta_fq_plonk_verifier_index_of_rust\nvar caml_pasta_fq_plonk_verifier_index_read = function (offset, urs, path) {\n if (offset === 0) {\n offset = undefined;\n } else {\n offset = offset[1];\n }\n return caml_pasta_fq_plonk_verifier_index_of_rust(\n plonk_wasm.caml_pasta_fq_plonk_verifier_index_read(\n offset,\n urs,\n caml_jsstring_of_string(path)\n )\n );\n};\n\n// Provides: caml_pasta_fq_plonk_verifier_index_write\n// Requires: plonk_wasm, caml_jsstring_of_string, caml_pasta_fq_plonk_verifier_index_to_rust\nvar caml_pasta_fq_plonk_verifier_index_write = function (append, t, path) {\n if (append === 0) {\n append = undefined;\n } else {\n append = append[1];\n }\n return plonk_wasm.caml_pasta_fq_plonk_verifier_index_write(\n append,\n caml_pasta_fq_plonk_verifier_index_to_rust(t),\n caml_jsstring_of_string(path)\n );\n};\n\n// Provides: caml_pasta_fq_plonk_verifier_index_shifts\n// Requires: plonk_wasm, caml_plonk_verification_shifts_of_rust\nvar caml_pasta_fq_plonk_verifier_index_shifts = function (log2_size) {\n return caml_plonk_verification_shifts_of_rust(\n plonk_wasm.caml_pasta_fq_plonk_verifier_index_shifts(log2_size)\n );\n};\n\n// Provides: caml_pasta_fq_plonk_verifier_index_dummy\n// Requires: plonk_wasm, caml_pasta_fq_plonk_verifier_index_of_rust\nvar caml_pasta_fq_plonk_verifier_index_dummy = function () {\n return caml_pasta_fq_plonk_verifier_index_of_rust(\n plonk_wasm.caml_pasta_fq_plonk_verifier_index_dummy()\n );\n};\n\n// Provides: caml_pasta_fq_plonk_verifier_index_deep_copy\n// Requires: plonk_wasm, caml_pasta_fq_plonk_verifier_index_of_rust, caml_pasta_fq_plonk_verifier_index_to_rust\nvar caml_pasta_fq_plonk_verifier_index_deep_copy = function (x) {\n return caml_pasta_fq_plonk_verifier_index_of_rust(\n plonk_wasm.caml_pasta_fq_plonk_verifier_index_deep_copy(\n caml_pasta_fq_plonk_verifier_index_to_rust(x)\n )\n );\n};\n\n// Provides: COLUMNS\nvar COLUMNS = 15;\n// Provides: PERMUTS_MINUS_1\nvar PERMUTS_MINUS_1 = 6;\n\n// Provides: caml_pasta_fp_proof_evaluations_to_rust\n// Requires: plonk_wasm, caml_fp_vector_to_rust, PERMUTS_MINUS_1, COLUMNS\nvar caml_pasta_fp_proof_evaluations_to_rust = function (x) {\n return x;\n};\n\n// Provides: caml_pasta_fp_proof_evaluations_of_rust\n// Requires: plonk_wasm, caml_fp_vector_of_rust, COLUMNS, PERMUTS_MINUS_1\nvar caml_pasta_fp_proof_evaluations_of_rust = function (x) {\n return x;\n};\n\n// Provides: caml_pasta_fp_opening_proof_to_rust\n// Requires: plonk_wasm, caml_array_to_rust_vector, rust_affine_of_caml_affine\nvar caml_pasta_fp_opening_proof_to_rust = function (x) {\n var convert_affines = function (affines) {\n return caml_array_to_rust_vector(\n affines,\n rust_affine_of_caml_affine,\n plonk_wasm.caml_vesta_affine_one\n );\n };\n var lr = x[1];\n var delta = rust_affine_of_caml_affine(\n x[2],\n plonk_wasm.caml_vesta_affine_one\n );\n var z1 = x[3];\n var z2 = x[4];\n var sg = rust_affine_of_caml_affine(x[5], plonk_wasm.caml_vesta_affine_one);\n var len = lr.length;\n // We pass l and r as separate vectors over the FFI\n var l_ocaml = new Array(len);\n var r_ocaml = new Array(len);\n for (var i = 1; i < len; i++) {\n l_ocaml[i] = lr[i][1];\n r_ocaml[i] = lr[i][2];\n }\n var l = convert_affines(l_ocaml);\n var r = convert_affines(r_ocaml);\n return new plonk_wasm.WasmFpOpeningProof(l, r, delta, z1, z2, sg);\n};\n\n// Provides: caml_pasta_fp_opening_proof_of_rust\n// Requires: plonk_wasm, caml_array_of_rust_vector, rust_affine_to_caml_affine\nvar caml_pasta_fp_opening_proof_of_rust = function (x) {\n var convert_affines = function (affines) {\n return caml_array_of_rust_vector(\n affines,\n plonk_wasm.WasmGVesta,\n rust_affine_to_caml_affine,\n false\n );\n };\n var l = convert_affines(x.lr_0);\n var r = convert_affines(x.lr_1);\n var delta = rust_affine_to_caml_affine(x.delta);\n var z1 = x.z1;\n var z2 = x.z2;\n var sg = rust_affine_to_caml_affine(x.sg);\n x.free();\n var len = l.length;\n if (len !== r.length) {\n throw new Error(\"l and r lengths don't match\");\n }\n var lr = new Array(len);\n lr[0] = 0;\n for (var i = 1; i < len; i++) {\n var tuple = new Array(3);\n tuple[0] = 0;\n tuple[1] = l[i];\n tuple[2] = r[i];\n lr[i] = tuple;\n }\n return [0, lr, delta, z1, z2, sg];\n};\n\n// Provides: caml_pasta_fp_commitments_to_rust\n// Requires: plonk_wasm, caml_vesta_poly_comm_to_rust, js_class_vector_to_rust_vector\nvar caml_pasta_fp_commitments_to_rust = function (x) {\n var convertArray = function (v) {\n var n = v.length - 1;\n var res = new Array(n);\n for (var i = 0; i < n; ++i) {\n res[i] = caml_vesta_poly_comm_to_rust(v[i + 1]);\n }\n // TODO need to do finalizer things?\n return js_class_vector_to_rust_vector(res);\n };\n\n var w_comm = convertArray(x[1]);\n var z_comm = caml_vesta_poly_comm_to_rust(x[2]);\n var t_comm = caml_vesta_poly_comm_to_rust(x[3]);\n return new plonk_wasm.WasmFpProverCommitments(w_comm, z_comm, t_comm);\n};\n\n// Provides: caml_pasta_fp_commitments_of_rust\n// Requires: caml_vesta_poly_comm_of_rust, js_class_vector_of_rust_vector, plonk_wasm\nvar caml_pasta_fp_commitments_of_rust = function (x) {\n var convertArray = function (v) {\n var a = js_class_vector_of_rust_vector(v, plonk_wasm.WasmFpPolyComm);\n var res = [0];\n for (var i = 0; i < a.length; ++i) {\n // TODO Check this. Could be off by 1\n res.push(caml_vesta_poly_comm_of_rust(a[i]));\n }\n return res;\n };\n\n var w_comm = convertArray(x.w_comm);\n var z_comm = caml_vesta_poly_comm_of_rust(x.z_comm);\n var t_comm = caml_vesta_poly_comm_of_rust(x.t_comm);\n x.free();\n return [0, w_comm, z_comm, t_comm];\n};\n\n// Provides: caml_pasta_fp_proof_to_rust\n// Requires: plonk_wasm, caml_pasta_fp_commitments_to_rust, caml_pasta_fp_opening_proof_to_rust, caml_pasta_fp_proof_evaluations_to_rust, caml_fp_vector_to_rust, caml_vesta_poly_comm_to_rust, js_class_vector_to_rust_vector\nvar caml_pasta_fp_proof_to_rust = function (x) {\n var commitments = caml_pasta_fp_commitments_to_rust(x[1]);\n var proof = caml_pasta_fp_opening_proof_to_rust(x[2]);\n var evals = caml_pasta_fp_proof_evaluations_to_rust(x[3]);\n var ft_eval1 = x[4];\n var public_ = caml_fp_vector_to_rust(x[5]);\n var prev_challenges = x[6];\n var chals_len = prev_challenges.length;\n var prev_challenges_scalars = new plonk_wasm.WasmVecVecFp(chals_len - 1);\n var prev_challenges_comms = new Array(chals_len - 1);\n for (var i = 1; i < chals_len; i++) {\n prev_challenges_scalars.push(caml_fp_vector_to_rust(prev_challenges[i][1]));\n prev_challenges_comms[i - 1] = caml_vesta_poly_comm_to_rust(\n prev_challenges[i][2]\n );\n }\n prev_challenges_comms = js_class_vector_to_rust_vector(prev_challenges_comms);\n return new plonk_wasm.WasmFpProverProof(\n commitments,\n proof,\n evals,\n ft_eval1,\n public_,\n prev_challenges_scalars,\n prev_challenges_comms\n );\n};\n\n// Provides: caml_pasta_fp_proof_of_rust\n// Requires: plonk_wasm, caml_pasta_fp_commitments_of_rust, caml_pasta_fp_opening_proof_of_rust, caml_pasta_fp_proof_evaluations_of_rust, caml_fp_vector_of_rust, js_class_vector_of_rust_vector, caml_vesta_poly_comm_of_rust\nvar caml_pasta_fp_proof_of_rust = function (x) {\n var messages = caml_pasta_fp_commitments_of_rust(x.commitments);\n var proof = caml_pasta_fp_opening_proof_of_rust(x.proof);\n var evals = caml_pasta_fp_proof_evaluations_of_rust(x.evals);\n var ft_eval1 = x.ft_eval1;\n var public_ = caml_fp_vector_of_rust(x.public_);\n var prev_challenges_scalars = x.prev_challenges_scalars;\n var prev_challenges_comms = js_class_vector_of_rust_vector(\n x.prev_challenges_comms,\n plonk_wasm.WasmFpPolyComm\n );\n var chals_len = prev_challenges_comms.length;\n var prev_challenges = new Array(chals_len);\n prev_challenges[0] = 0;\n for (var i = 1; i < chals_len; i++) {\n var res = new Array(3);\n res[0] = 0;\n res[1] = caml_fp_vector_of_rust(prev_challenges_scalars.get(i - 1));\n // TODO Check this. Could be off by 1\n res[2] = caml_vesta_poly_comm_of_rust(prev_challenges_comms[i]);\n prev_challenges[i] = res;\n }\n return [0, messages, proof, evals, ft_eval1, public_, prev_challenges];\n};\n\n// Provides: caml_fp_runtime_table_to_rust\n// Requires: plonk_wasm, caml_fp_vector_to_rust, caml_get_field_of_caml_record\nvar caml_fp_runtime_table_to_rust = function (caml_runtime_table, mk_class) {\n // A value caml_runtime_table is a record on the OCaml side.\n // The converter should be changed if CamlRuntimeTable is modified.\n // id field: int32\n var caml_runtime_table_id = caml_get_field_of_caml_record(\n caml_runtime_table,\n 0\n );\n // data field: Caml array of fq elements\n var caml_runtime_table_data = caml_get_field_of_caml_record(\n caml_runtime_table,\n 1\n );\n var res = new mk_class(\n caml_runtime_table_id,\n caml_fp_vector_to_rust(caml_runtime_table_data)\n );\n return res;\n};\n\n// Provides: caml_pasta_fp_plonk_proof_create\n// Requires: plonk_wasm, caml_fp_vector_to_rust, caml_array_to_rust_vector, rust_affine_of_caml_affine, caml_pasta_fp_proof_of_rust\nvar caml_pasta_fp_plonk_proof_create = function (\n index,\n witness_cols,\n prev_challenges,\n prev_sgs\n) {\n var w = new plonk_wasm.WasmVecVecFp(witness_cols.length - 1);\n for (var i = 1; i < witness_cols.length; i++) {\n w.push(caml_fp_vector_to_rust(witness_cols[i]));\n }\n witness_cols = w;\n prev_challenges = caml_fp_vector_to_rust(prev_challenges);\n prev_sgs = caml_array_to_rust_vector(\n prev_sgs,\n rust_affine_of_caml_affine,\n plonk_wasm.caml_vesta_affine_one\n );\n var res = plonk_wasm.caml_pasta_fp_plonk_proof_create(\n index,\n witness_cols,\n prev_challenges,\n prev_sgs\n );\n var proof = caml_pasta_fp_proof_of_rust(res);\n return proof;\n};\n\n// Provides: caml_pasta_fp_plonk_proof_verify\n// Requires: plonk_wasm, caml_array_to_rust_vector, caml_vesta_poly_comm_to_rust, caml_pasta_fp_plonk_verifier_index_to_rust, caml_pasta_fp_proof_to_rust\nvar caml_pasta_fp_plonk_proof_verify = function (index, proof) {\n index = caml_pasta_fp_plonk_verifier_index_to_rust(index);\n proof = caml_pasta_fp_proof_to_rust(proof);\n return plonk_wasm.caml_pasta_fp_plonk_proof_verify(index, proof);\n};\n\n// Provides: caml_pasta_fp_plonk_proof_batch_verify\n// Requires: plonk_wasm, caml_array_to_rust_vector, caml_vesta_poly_comm_to_rust, caml_pasta_fp_plonk_verifier_index_to_rust, caml_pasta_fp_proof_to_rust\nvar caml_pasta_fp_plonk_proof_batch_verify = function (indexes, proofs) {\n indexes = caml_array_to_rust_vector(\n indexes,\n caml_pasta_fp_plonk_verifier_index_to_rust\n );\n proofs = caml_array_to_rust_vector(proofs, caml_pasta_fp_proof_to_rust);\n return plonk_wasm.caml_pasta_fp_plonk_proof_batch_verify(indexes, proofs);\n};\n\n// Provides: caml_pasta_fp_plonk_proof_dummy\n// Requires: plonk_wasm, caml_pasta_fp_proof_of_rust\nvar caml_pasta_fp_plonk_proof_dummy = function () {\n return caml_pasta_fp_proof_of_rust(\n plonk_wasm.caml_pasta_fp_plonk_proof_dummy()\n );\n};\n\n// Provides: caml_pasta_fp_plonk_proof_deep_copy\n// Requires: plonk_wasm, caml_pasta_fp_proof_to_rust, caml_pasta_fp_proof_of_rust\nvar caml_pasta_fp_plonk_proof_deep_copy = function (proof) {\n return caml_pasta_fp_proof_of_rust(\n plonk_wasm.caml_pasta_fp_plonk_proof_deep_copy(\n caml_pasta_fp_proof_to_rust(proof)\n )\n );\n};\n\n// Provides: caml_pasta_fq_proof_evaluations_to_rust\n// Requires: plonk_wasm, caml_fq_vector_to_rust, PERMUTS_MINUS_1, COLUMNS\nvar caml_pasta_fq_proof_evaluations_to_rust = function (x) {\n return x;\n};\n\n// Provides: caml_pasta_fq_proof_evaluations_of_rust\n// Requires: plonk_wasm, caml_fq_vector_of_rust, COLUMNS, PERMUTS_MINUS_1\nvar caml_pasta_fq_proof_evaluations_of_rust = function (x) {\n return x;\n};\n\n// Provides: caml_pasta_fq_opening_proof_to_rust\n// Requires: plonk_wasm, caml_array_to_rust_vector, rust_affine_of_caml_affine\nvar caml_pasta_fq_opening_proof_to_rust = function (x) {\n var convert_affines = function (affines) {\n return caml_array_to_rust_vector(\n affines,\n rust_affine_of_caml_affine,\n plonk_wasm.caml_pallas_affine_one\n );\n };\n var lr = x[1];\n var delta = rust_affine_of_caml_affine(\n x[2],\n plonk_wasm.caml_pallas_affine_one\n );\n var z1 = x[3];\n var z2 = x[4];\n var sg = rust_affine_of_caml_affine(x[5], plonk_wasm.caml_pallas_affine_one);\n var len = lr.length;\n // We pass l and r as separate vectors over the FFI\n var l_ocaml = new Array(len);\n var r_ocaml = new Array(len);\n for (var i = 1; i < len; i++) {\n l_ocaml[i] = lr[i][1];\n r_ocaml[i] = lr[i][2];\n }\n var l = convert_affines(l_ocaml);\n var r = convert_affines(r_ocaml);\n return new plonk_wasm.WasmFqOpeningProof(l, r, delta, z1, z2, sg);\n};\n\n// Provides: caml_pasta_fq_opening_proof_of_rust\n// Requires: plonk_wasm, caml_array_of_rust_vector, rust_affine_to_caml_affine\nvar caml_pasta_fq_opening_proof_of_rust = function (x) {\n var convert_affines = function (affines) {\n return caml_array_of_rust_vector(\n affines,\n plonk_wasm.WasmGPallas,\n rust_affine_to_caml_affine,\n false\n );\n };\n var l = convert_affines(x.lr_0);\n var r = convert_affines(x.lr_1);\n var delta = rust_affine_to_caml_affine(x.delta);\n var z1 = x.z1;\n var z2 = x.z2;\n var sg = rust_affine_to_caml_affine(x.sg);\n x.free();\n var len = l.length;\n if (len !== r.length) {\n throw new Error(\"l and r lengths don't match\");\n }\n var lr = new Array(len);\n lr[0] = 0;\n for (var i = 1; i < len; i++) {\n var tuple = new Array(3);\n tuple[0] = 0;\n tuple[1] = l[i];\n tuple[2] = r[i];\n lr[i] = tuple;\n }\n return [0, lr, delta, z1, z2, sg];\n};\n\n// Provides: caml_pasta_fq_commitments_to_rust\n// Requires: plonk_wasm, caml_pallas_poly_comm_to_rust, js_class_vector_to_rust_vector\nvar caml_pasta_fq_commitments_to_rust = function (x) {\n var convertArray = function (v) {\n var n = v.length - 1;\n var res = new Array(n);\n for (var i = 0; i < n; ++i) {\n res[i] = caml_pallas_poly_comm_to_rust(v[i + 1]);\n }\n return js_class_vector_to_rust_vector(res);\n };\n\n var w_comm = convertArray(x[1]);\n var z_comm = caml_pallas_poly_comm_to_rust(x[2]);\n var t_comm = caml_pallas_poly_comm_to_rust(x[3]);\n return new plonk_wasm.WasmFqProverCommitments(w_comm, z_comm, t_comm);\n};\n\n// Provides: caml_pasta_fq_commitments_of_rust\n// Requires: caml_pallas_poly_comm_of_rust, js_class_vector_of_rust_vector, plonk_wasm\nvar caml_pasta_fq_commitments_of_rust = function (x) {\n var convertArray = function (v) {\n var a = js_class_vector_of_rust_vector(v, plonk_wasm.WasmFqPolyComm);\n var res = [0];\n for (var i = 0; i < a.length; ++i) {\n // TODO Check this. Could be off by 1\n res.push(caml_pallas_poly_comm_of_rust(a[i]));\n }\n return res;\n };\n\n var w_comm = convertArray(x.w_comm);\n var z_comm = caml_pallas_poly_comm_of_rust(x.z_comm);\n var t_comm = caml_pallas_poly_comm_of_rust(x.t_comm);\n x.free();\n return [0, w_comm, z_comm, t_comm];\n};\n\n// Provides: caml_pasta_fq_proof_to_rust\n// Requires: plonk_wasm, caml_pasta_fq_commitments_to_rust, caml_pasta_fq_opening_proof_to_rust, caml_pasta_fq_proof_evaluations_to_rust, caml_fq_vector_to_rust, caml_pallas_poly_comm_to_rust, js_class_vector_to_rust_vector\nvar caml_pasta_fq_proof_to_rust = function (x) {\n var messages = caml_pasta_fq_commitments_to_rust(x[1]);\n var proof = caml_pasta_fq_opening_proof_to_rust(x[2]);\n var evals = caml_pasta_fq_proof_evaluations_to_rust(x[3]);\n var ft_eval1 = x[4];\n var public_ = caml_fq_vector_to_rust(x[5]);\n var prev_challenges = x[6];\n var chals_len = prev_challenges.length;\n var prev_challenges_scalars = new plonk_wasm.WasmVecVecFq(chals_len - 1);\n var prev_challenges_comms = new Array(chals_len - 1);\n for (var i = 1; i < chals_len; i++) {\n prev_challenges_scalars.push(caml_fq_vector_to_rust(prev_challenges[i][1]));\n prev_challenges_comms[i - 1] = caml_pallas_poly_comm_to_rust(\n prev_challenges[i][2]\n );\n }\n prev_challenges_comms = js_class_vector_to_rust_vector(prev_challenges_comms);\n return new plonk_wasm.WasmFqProverProof(\n messages,\n proof,\n evals,\n ft_eval1,\n public_,\n prev_challenges_scalars,\n prev_challenges_comms\n );\n};\n\n// Provides: caml_pasta_fq_proof_of_rust\n// Requires: plonk_wasm, caml_pasta_fq_commitments_of_rust, caml_pasta_fq_opening_proof_of_rust, caml_pasta_fq_proof_evaluations_of_rust, caml_fq_vector_of_rust, js_class_vector_of_rust_vector, caml_pallas_poly_comm_of_rust\nvar caml_pasta_fq_proof_of_rust = function (x) {\n var messages = caml_pasta_fq_commitments_of_rust(x.commitments);\n var proof = caml_pasta_fq_opening_proof_of_rust(x.proof);\n var evals = caml_pasta_fq_proof_evaluations_of_rust(x.evals);\n var evals1 = caml_pasta_fq_proof_evaluations_of_rust(x.evals1);\n var ft_eval1 = x.ft_eval1;\n var public_ = caml_fq_vector_of_rust(x.public_);\n var prev_challenges_scalars = x.prev_challenges_scalars;\n var prev_challenges_comms = js_class_vector_of_rust_vector(\n x.prev_challenges_comms,\n plonk_wasm.WasmFqPolyComm\n );\n var chals_len = prev_challenges_comms.length;\n var prev_challenges = new Array(chals_len);\n prev_challenges[0] = 0;\n for (var i = 1; i < chals_len; i++) {\n var res = new Array(3);\n res[0] = 0;\n res[1] = caml_fq_vector_of_rust(prev_challenges_scalars.get(i - 1));\n res[2] = caml_pallas_poly_comm_of_rust(prev_challenges_comms[i]);\n prev_challenges[i] = res;\n }\n return [0, messages, proof, evals, ft_eval1, public_, prev_challenges];\n};\n\n// Provides: caml_fq_runtime_table_to_rust\n// Requires: plonk_wasm, caml_fq_vector_to_rust, caml_get_field_of_caml_record\nvar caml_fq_runtime_table_to_rust = function (caml_runtime_table, mk_class) {\n // A value caml_runtime_table is a record on the OCaml side.\n // The converter should be changed if CamlRuntimeTable is modified.\n // id field: int32\n var caml_runtime_table_id = caml_get_field_of_caml_record(\n caml_runtime_table,\n 0\n );\n // data field: Caml array of fq elements\n var caml_runtime_table_data = caml_get_field_of_caml_record(\n caml_runtime_table,\n 1\n );\n var res = new mk_class(\n caml_runtime_table_id,\n caml_fq_vector_to_rust(caml_runtime_table_data)\n );\n return res;\n};\n\n// Provides: caml_pasta_fq_plonk_proof_create\n// Requires: plonk_wasm, caml_fq_vector_to_rust, caml_array_to_rust_vector, rust_affine_of_caml_affine, caml_pasta_fq_proof_of_rust\nvar caml_pasta_fq_plonk_proof_create = function (\n index,\n witness_cols,\n prev_challenges,\n prev_sgs\n) {\n var w = new plonk_wasm.WasmVecVecFq(witness_cols.length - 1);\n for (var i = 1; i < witness_cols.length; i++) {\n w.push(caml_fq_vector_to_rust(witness_cols[i]));\n }\n witness_cols = w;\n prev_challenges = caml_fq_vector_to_rust(prev_challenges);\n prev_sgs = caml_array_to_rust_vector(\n prev_sgs,\n rust_affine_of_caml_affine,\n plonk_wasm.caml_pallas_affine_one\n );\n var res = plonk_wasm.caml_pasta_fq_plonk_proof_create(\n index,\n witness_cols,\n prev_challenges,\n prev_sgs\n );\n var proof = caml_pasta_fq_proof_of_rust(res);\n return proof;\n};\n\n// Provides: caml_pasta_fq_plonk_proof_verify\n// Requires: plonk_wasm, caml_array_to_rust_vector, caml_pallas_poly_comm_to_rust, caml_pasta_fq_plonk_verifier_index_to_rust, caml_pasta_fq_proof_to_rust\nvar caml_pasta_fq_plonk_proof_verify = function (index, proof) {\n index = caml_pasta_fq_plonk_verifier_index_to_rust(index);\n proof = caml_pasta_fq_proof_to_rust(proof);\n return plonk_wasm.caml_pasta_fq_plonk_proof_verify(index, proof);\n};\n\n// Provides: caml_pasta_fq_plonk_proof_batch_verify\n// Requires: plonk_wasm, caml_array_to_rust_vector, caml_pallas_poly_comm_to_rust, caml_pasta_fq_plonk_verifier_index_to_rust, caml_pasta_fq_proof_to_rust\nvar caml_pasta_fq_plonk_proof_batch_verify = function (indexes, proofs) {\n indexes = caml_array_to_rust_vector(\n indexes,\n caml_pasta_fq_plonk_verifier_index_to_rust\n );\n proofs = caml_array_to_rust_vector(proofs, caml_pasta_fq_proof_to_rust);\n return plonk_wasm.caml_pasta_fq_plonk_proof_batch_verify(indexes, proofs);\n};\n\n// Provides: caml_pasta_fq_plonk_proof_dummy\n// Requires: plonk_wasm, caml_pasta_fq_proof_of_rust\nvar caml_pasta_fq_plonk_proof_dummy = function () {\n return caml_pasta_fq_proof_of_rust(\n plonk_wasm.caml_pasta_fq_plonk_proof_dummy()\n );\n};\n\n// Provides: caml_pasta_fq_plonk_proof_deep_copy\n// Requires: plonk_wasm, caml_pasta_fq_proof_to_rust, caml_pasta_fq_proof_of_rust\nvar caml_pasta_fq_plonk_proof_deep_copy = function (proof) {\n return caml_pasta_fq_proof_of_rust(\n plonk_wasm.caml_pasta_fq_plonk_proof_deep_copy(\n caml_pasta_fq_proof_to_rust(proof)\n )\n );\n};\n\n// Provides: caml_random_oracles_of_rust\n// Requires: caml_u8array_vector_of_rust_flat_vector, caml_option_of_maybe_undefined\nvar caml_random_oracles_of_rust = function (x) {\n var joint_combiner_chal = x.joint_combiner_chal;\n var joint_combiner = x.joint_combiner;\n var joint_combiner_ocaml = undefined;\n if (joint_combiner_chal !== undefined && joint_combiner !== undefined) {\n joint_combiner_ocaml = [0, [0, joint_combiner_chal], joint_combiner];\n }\n return [\n 0,\n caml_option_of_maybe_undefined(joint_combiner_ocaml),\n x.beta,\n x.gamma,\n [0, x.alpha_chal],\n x.alpha,\n x.zeta,\n x.v,\n x.u,\n [0, x.zeta_chal],\n [0, x.v_chal],\n [0, x.u_chal],\n ];\n};\n\n// Provides: caml_random_oracles_to_rust\n// Requires: caml_u8array_vector_to_rust_flat_vector, caml_option_to_maybe_undefined\nvar caml_random_oracles_to_rust = function (x, roKlass) {\n // var caml_vector = [0, x[1], x[2], x[3][1], x[4], x[5], x[6], x[7], x[8][1], x[9][1], x[10][1]];\n var joint_combiner_ocaml = caml_option_to_maybe_undefined(x[1]);\n var joint_combiner_chal = undefined;\n var joint_combiner = undefined;\n if (joint_combiner_ocaml !== undefined) {\n joint_combiner_chal = joint_combiner_ocaml[1][1];\n joint_combiner = joint_combiner_ocaml[2];\n }\n return new roKlass(\n joint_combiner_chal,\n joint_combiner,\n x[2],\n x[3],\n x[4][1],\n x[5],\n x[6],\n x[7],\n x[8],\n x[9][1],\n x[10][1],\n x[11][1]\n );\n};\n\n// Provides: caml_oracles_of_rust\n// Requires: caml_u8array_vector_of_rust_flat_vector, caml_random_oracles_of_rust\nvar caml_oracles_of_rust = function (x) {\n return [\n 0,\n caml_random_oracles_of_rust(x.o),\n [0, x.p_eval0, x.p_eval1],\n caml_u8array_vector_of_rust_flat_vector(\n x.opening_prechallenges,\n 32 /* TODO: Don't hardcode */\n ),\n x.digest_before_evaluations,\n ];\n};\n\n// Provides: caml_oracles_to_rust\n// Requires: caml_u8array_vector_to_rust_flat_vector, caml_random_oracles_to_rust\nvar caml_oracles_to_rust = function (x, klass, roKlass) {\n return new klass(\n caml_random_oracles_to_rust(x[1], roKlass),\n x[2][1],\n x[2][2],\n caml_u8array_vector_to_rust_flat_vector(x[3]),\n x[4]\n );\n};\n\n// Provides: fp_oracles_create\n// Requires: plonk_wasm, caml_oracles_of_rust, caml_array_to_rust_vector, caml_vesta_poly_comm_to_rust, caml_pasta_fp_plonk_verifier_index_to_rust, caml_pasta_fp_proof_to_rust\nvar fp_oracles_create = function (lgr_comm, verifier_index, proof) {\n return caml_oracles_of_rust(\n plonk_wasm.fp_oracles_create(\n caml_array_to_rust_vector(lgr_comm, caml_vesta_poly_comm_to_rust),\n caml_pasta_fp_plonk_verifier_index_to_rust(verifier_index),\n caml_pasta_fp_proof_to_rust(proof)\n )\n );\n};\n\n// Provides: fp_oracles_dummy\n// Requires: plonk_wasm, caml_oracles_of_rust\nvar fp_oracles_dummy = function () {\n return caml_oracles_of_rust(plonk_wasm.fp_oracles_dummy());\n};\n\n// Provides: fp_oracles_deep_copy\n// Requires: plonk_wasm, caml_oracles_of_rust, caml_oracles_to_rust\nvar fp_oracles_deep_copy = function (x) {\n return caml_oracles_of_rust(\n plonk_wasm.fp_oracles_deep_copy(\n caml_oracles_to_rust(\n x,\n plonk_wasm.WasmFpOracles,\n plonk_wasm.WasmFpRandomOracles\n )\n )\n );\n};\n\n// Provides: fq_oracles_create\n// Requires: plonk_wasm, caml_oracles_of_rust, caml_array_to_rust_vector, caml_pallas_poly_comm_to_rust, caml_pasta_fq_plonk_verifier_index_to_rust, caml_pasta_fq_proof_to_rust\nvar fq_oracles_create = function (lgr_comm, verifier_index, proof) {\n return caml_oracles_of_rust(\n plonk_wasm.fq_oracles_create(\n caml_array_to_rust_vector(lgr_comm, caml_pallas_poly_comm_to_rust),\n caml_pasta_fq_plonk_verifier_index_to_rust(verifier_index),\n caml_pasta_fq_proof_to_rust(proof)\n )\n );\n};\n\n// Provides: fq_oracles_dummy\n// Requires: plonk_wasm, caml_oracles_of_rust\nvar fq_oracles_dummy = function () {\n return caml_oracles_of_rust(plonk_wasm.fq_oracles_dummy());\n};\n\n// Provides: fq_oracles_deep_copy\n// Requires: plonk_wasm, caml_oracles_of_rust, caml_oracles_to_rust\nvar fq_oracles_deep_copy = function (x) {\n return caml_oracles_of_rust(\n plonk_wasm.fq_oracles_deep_copy(\n caml_oracles_to_rust(\n x,\n plonk_wasm.WasmFqOracles,\n plonk_wasm.WasmFqRandomOracles\n )\n )\n );\n};\n\n// This is fake -- parameters are only needed on the Rust side, so no need to return something meaningful\n// Provides: caml_pasta_fp_poseidon_params_create\nfunction caml_pasta_fp_poseidon_params_create() {\n return [0];\n}\n// Provides: caml_pasta_fq_poseidon_params_create\nfunction caml_pasta_fq_poseidon_params_create() {\n return [0];\n}\n\n// Provides: caml_pasta_fp_poseidon_block_cipher\n// Requires: plonk_wasm, caml_fp_vector_to_rust, caml_fp_vector_of_rust\nfunction caml_pasta_fp_poseidon_block_cipher(_fake_params, fp_vector) {\n // 1. get permuted field vector from rust\n var wasm_flat_vector = plonk_wasm.caml_pasta_fp_poseidon_block_cipher(\n caml_fp_vector_to_rust(fp_vector)\n );\n var new_fp_vector = caml_fp_vector_of_rust(wasm_flat_vector);\n // 2. write back modified field vector to original one\n new_fp_vector.forEach(function (a, i) {\n fp_vector[i] = a;\n });\n}\n\n// Provides: caml_pasta_fq_poseidon_block_cipher\n// Requires: plonk_wasm, caml_fq_vector_to_rust, caml_fq_vector_of_rust\nfunction caml_pasta_fq_poseidon_block_cipher(_fake_params, fq_vector) {\n // 1. get permuted field vector from rust\n var wasm_flat_vector = plonk_wasm.caml_pasta_fq_poseidon_block_cipher(\n caml_fq_vector_to_rust(fq_vector)\n );\n var new_fq_vector = caml_fq_vector_of_rust(wasm_flat_vector);\n // 2. write back modified field vector to original one\n new_fq_vector.forEach(function (a, i) {\n fq_vector[i] = a;\n });\n}\n\n// Provides: caml_pasta_fp_plonk_proof_example_with_lookup\nfunction caml_pasta_fp_plonk_proof_example_with_lookup() {\n // This is only used in the pickles unit tests\n throw new Error(\n 'Unimplemented caml_pasta_fp_plonk_proof_example_with_lookup'\n );\n}\n\n// Provides: prover_to_json\n// Requires: plonk_wasm\nvar prover_to_json = plonk_wasm.prover_to_json;\n\n// Provides: integers_uint64_of_uint32\n// Requires: UInt64, caml_int64_of_int32\nfunction integers_uint64_of_uint32(i) {\n // Same as integers_uint64_of_int\n return new UInt64(caml_int64_of_int32(i));\n}\n\n// Provides: caml_pasta_fp_plonk_proof_create_and_verify\nfunction caml_pasta_fp_plonk_proof_create_and_verify() {\n throw new Error('Unimplemented caml_pasta_fp_plonk_proof_create_and_verify');\n}\n\n/////////////////////////////////////////////////////////////////////////////\n// The *_example_* functions below are only used in the pickles unit tests //\n/////////////////////////////////////////////////////////////////////////////\n\n// Provides: caml_pasta_fp_plonk_proof_example_with_ffadd\nfunction caml_pasta_fp_plonk_proof_example_with_ffadd() {\n throw new Error('Unimplemented caml_pasta_fp_plonk_proof_example_with_ffadd');\n}\n\n// Provides: caml_pasta_fp_plonk_proof_example_with_foreign_field_mul\nfunction caml_pasta_fp_plonk_proof_example_with_foreign_field_mul() {\n throw new Error(\n 'Unimplemented caml_pasta_fp_plonk_proof_example_with_foreign_field_mul'\n );\n}\n\n// Provides: caml_pasta_fp_plonk_proof_example_with_range_check\nfunction caml_pasta_fp_plonk_proof_example_with_range_check() {\n throw new Error(\n 'Unimplemented caml_pasta_fp_plonk_proof_example_with_range_check'\n );\n}\n\n// Provides: caml_pasta_fp_plonk_proof_example_with_range_check0\nfunction caml_pasta_fp_plonk_proof_example_with_range_check0() {\n throw new Error(\n 'Unimplemented caml_pasta_fp_plonk_proof_example_with_range_check0'\n );\n}\n\n// Provides: caml_pasta_fp_plonk_proof_example_with_rot\nfunction caml_pasta_fp_plonk_proof_example_with_rot() {\n throw new Error('Unimplemented caml_pasta_fp_plonk_proof_example_with_rot');\n}\n\n// Provides: caml_pasta_fp_plonk_proof_example_with_xor\nfunction caml_pasta_fp_plonk_proof_example_with_xor() {\n throw new Error('Unimplemented caml_pasta_fp_plonk_proof_example_with_xor');\n}\n","// Js_of_ocaml runtime support\n// http://www.ocsigen.org/js_of_ocaml/\n//\n// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU Lesser General Public License as published by\n// the Free Software Foundation, with linking exception;\n// either version 2.1 of the License, or (at your option) any later version.\n//\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n// GNU Lesser General Public License for more details.\n//\n// You should have received a copy of the GNU Lesser General Public License\n// along with this program; if not, write to the Free Software\n// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n\n//Provides: caml_compare_val_tag\n//Requires: caml_is_ml_string, caml_is_ml_bytes\nfunction caml_compare_val_tag(a){\n if (typeof a === \"number\") return 1000; // int_tag (we use it for all numbers)\n else if (caml_is_ml_bytes(a)) return 252; // string_tag\n else if (caml_is_ml_string(a)) return 1252; // ocaml string (if different from bytes)\n else if (a instanceof Array && a[0] === (a[0]>>>0) && a[0] <= 255) {\n // Look like an ocaml block\n var tag = a[0] | 0;\n // ignore double_array_tag because we cannot accurately set\n // this tag when we create an array of float.\n return (tag == 254)?0:tag\n }\n else if (a instanceof String) return 12520; // javascript string, like string_tag (252)\n else if (typeof a == \"string\") return 12520; // javascript string, like string_tag (252)\n else if (a instanceof Number) return 1000; // int_tag (we use it for all numbers)\n else if (a && a.caml_custom) return 1255; // like custom_tag (255)\n else if (a && a.compare) return 1256; // like custom_tag (255)\n else if (typeof a == \"function\") return 1247; // like closure_tag (247)\n else if (typeof a == \"symbol\") return 1251;\n return 1001; //out_of_heap_tag\n}\n\n//Provides: caml_compare_val_get_custom\n//Requires: caml_custom_ops\nfunction caml_compare_val_get_custom(a){\n return caml_custom_ops[a.caml_custom] && caml_custom_ops[a.caml_custom].compare;\n}\n\n//Provides: caml_compare_val_number_custom\n//Requires: caml_compare_val_get_custom\nfunction caml_compare_val_number_custom(num, custom, swap, total) {\n var comp = caml_compare_val_get_custom(custom);\n if(comp) {\n var x = (swap > 0)?comp(custom,num,total):comp(num,custom,total);\n if(total && x != x) return swap; // total && nan\n if(+x != +x) return +x; // nan\n if((x | 0) != 0) return (x | 0); // !nan\n }\n return swap\n}\n\n//Provides: caml_compare_val (const, const, const)\n//Requires: caml_int_compare, caml_string_compare, caml_bytes_compare\n//Requires: caml_invalid_argument, caml_compare_val_get_custom, caml_compare_val_tag\n//Requires: caml_compare_val_number_custom\n//Requires: caml_jsbytes_of_string\nfunction caml_compare_val (a, b, total) {\n var stack = [];\n for(;;) {\n if (!(total && a === b)) {\n var tag_a = caml_compare_val_tag(a);\n // forward_tag ?\n if(tag_a == 250) { a = a[1]; continue }\n\n var tag_b = caml_compare_val_tag(b);\n // forward_tag ?\n if(tag_b == 250) { b = b[1]; continue }\n\n // tags are different\n if(tag_a !== tag_b) {\n if(tag_a == 1000) {\n if(tag_b == 1255) { //immediate can compare against custom\n return caml_compare_val_number_custom(a, b, -1, total);\n }\n return -1\n }\n if(tag_b == 1000) {\n if(tag_a == 1255) { //immediate can compare against custom\n return caml_compare_val_number_custom(b, a, 1, total);\n }\n return 1\n }\n return (tag_a < tag_b)?-1:1;\n }\n switch(tag_a){\n // 246: Lazy_tag handled bellow\n case 247: // Closure_tag\n // Cannot happen\n caml_invalid_argument(\"compare: functional value\");\n break\n case 248: // Object\n var x = caml_int_compare(a[2], b[2]);\n if (x != 0) return (x | 0);\n break;\n case 249: // Infix\n // Cannot happen\n caml_invalid_argument(\"compare: functional value\");\n break\n case 250: // Forward tag\n // Cannot happen, handled above\n caml_invalid_argument(\"equal: got Forward_tag, should not happen\");\n break;\n case 251: //Abstract\n caml_invalid_argument(\"equal: abstract value\");\n break;\n case 252: // OCaml bytes\n if (a !== b) {\n var x = caml_bytes_compare(a, b);\n if (x != 0) return (x | 0);\n };\n break;\n case 253: // Double_tag\n // Cannot happen\n caml_invalid_argument(\"equal: got Double_tag, should not happen\");\n break;\n case 254: // Double_array_tag\n // Cannot happen, handled above\n caml_invalid_argument(\"equal: got Double_array_tag, should not happen\");\n break\n case 255: // Custom_tag\n caml_invalid_argument(\"equal: got Custom_tag, should not happen\");\n break;\n case 1247: // Function\n caml_invalid_argument(\"compare: functional value\");\n break;\n case 1255: // Custom\n var comp = caml_compare_val_get_custom(a);\n if(comp != caml_compare_val_get_custom(b)){\n return (a.caml_custom b) return 1;\n if (a != b) {\n if (!total) return NaN;\n if (a == a) return 1;\n if (b == b) return -1;\n }\n break;\n case 1001: // The rest\n // Here we can be in the following cases:\n // 1. JavaScript primitive types\n // 2. JavaScript object that can be coerced to primitive types\n // 3. JavaScript object than cannot be coerced to primitive types\n //\n // (3) will raise a [TypeError]\n // (2) will coerce to primitive types using [valueOf] or [toString]\n // (2) and (3), after eventual coercion\n // - if a and b are strings, apply lexicographic comparison\n // - if a or b are not strings, convert a and b to number\n // and apply standard comparison\n //\n // Exception: `!=` will not coerce/convert if both a and b are objects\n if (a < b) return -1;\n if (a > b) return 1;\n if (a != b) {\n if (!total) return NaN;\n if (a == a) return 1;\n if (b == b) return -1;\n }\n break;\n case 1251: // JavaScript Symbol, no ordering.\n if(a !== b) {\n if (!total) return NaN;\n return 1;\n }\n break;\n case 1252: // ocaml strings\n var a = caml_jsbytes_of_string(a);\n var b = caml_jsbytes_of_string(b);\n if(a !== b) {\n if(a < b) return -1;\n if(a > b) return 1;\n }\n break;\n case 12520: // javascript strings\n var a = a.toString();\n var b = b.toString();\n if(a !== b) {\n if(a < b) return -1;\n if(a > b) return 1;\n }\n break;\n case 246: // Lazy_tag\n case 254: // Double_array\n default: // Block with other tag\n if (a.length != b.length) return (a.length < b.length)?-1:1;\n if (a.length > 1) stack.push(a, b, 1);\n break;\n }\n }\n if (stack.length == 0) return 0;\n var i = stack.pop();\n b = stack.pop();\n a = stack.pop();\n if (i + 1 < a.length) stack.push(a, b, i + 1);\n a = a[i];\n b = b[i];\n }\n}\n//Provides: caml_compare (const, const)\n//Requires: caml_compare_val\nfunction caml_compare (a, b) { return caml_compare_val (a, b, true); }\n//Provides: caml_int_compare mutable (const, const)\nfunction caml_int_compare (a, b) {\n if (a < b) return (-1); if (a == b) return 0; return 1;\n}\n//Provides: caml_equal mutable (const, const)\n//Requires: caml_compare_val\nfunction caml_equal (x, y) { return +(caml_compare_val(x,y,false) == 0); }\n//Provides: caml_notequal mutable (const, const)\n//Requires: caml_compare_val\nfunction caml_notequal (x, y) { return +(caml_compare_val(x,y,false) != 0); }\n//Provides: caml_greaterequal mutable (const, const)\n//Requires: caml_compare_val\nfunction caml_greaterequal (x, y) { return +(caml_compare_val(x,y,false) >= 0); }\n//Provides: caml_greaterthan mutable (const, const)\n//Requires: caml_compare_val\nfunction caml_greaterthan (x, y) { return +(caml_compare_val(x,y,false) > 0); }\n//Provides: caml_lessequal mutable (const, const)\n//Requires: caml_compare_val\nfunction caml_lessequal (x, y) { return +(caml_compare_val(x,y,false) <= 0); }\n//Provides: caml_lessthan mutable (const, const)\n//Requires: caml_compare_val\nfunction caml_lessthan (x, y) { return +(caml_compare_val(x,y,false) < 0); }\n","// Js_of_ocaml runtime support\n// http://www.ocsigen.org/js_of_ocaml/\n// Copyright (C) 2010 Jérôme Vouillon\n// Laboratoire PPS - CNRS Université Paris Diderot\n//\n// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU Lesser General Public License as published by\n// the Free Software Foundation, with linking exception;\n// either version 2.1 of the License, or (at your option) any later version.\n//\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n// GNU Lesser General Public License for more details.\n//\n// You should have received a copy of the GNU Lesser General Public License\n// along with this program; if not, write to the Free Software\n// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n\n// Weak API, but without the weak semantics\n\n//Provides: caml_ephe_key_offset\nvar caml_ephe_key_offset = 3\n\n//Provides: caml_ephe_data_offset\nvar caml_ephe_data_offset = 2\n\n//Provides: caml_weak_create\n//Requires: caml_ephe_key_offset, caml_invalid_argument\nfunction caml_weak_create (n) {\n if (n < 0) caml_invalid_argument (\"Weak.create\");\n var x = [251,\"caml_ephe_list_head\"];\n x.length = caml_ephe_key_offset + n;\n return x;\n}\n\n//Provides: caml_weak_set\n//Requires: caml_ephe_key_offset, caml_invalid_argument\nfunction caml_weak_set(x, i, v) {\n if(i < 0 || caml_ephe_key_offset + i >= x.length)\n caml_invalid_argument (\"Weak.set\");\n x[caml_ephe_key_offset + i] = v;\n return 0;\n}\n//Provides: caml_weak_get\n//Requires: caml_ephe_key_offset, caml_invalid_argument\nfunction caml_weak_get(x, i) {\n if(i < 0 || caml_ephe_key_offset + i >= x.length)\n caml_invalid_argument (\"Weak.get_key\");\n return (x[caml_ephe_key_offset + i ]===undefined)?0:x[caml_ephe_key_offset + i];\n}\n//Provides: caml_weak_get_copy\n//Requires: caml_weak_get,caml_ephe_key_offset\n//Requires: caml_obj_dup, caml_invalid_argument\nfunction caml_weak_get_copy(x, i) {\n if(i < 0 || caml_ephe_key_offset + i >= x.length)\n caml_invalid_argument (\"Weak.get_copy\");\n var y = caml_weak_get(x, i);\n if (y === 0) return y;\n var z = y[1];\n if (z instanceof Array) return [0, caml_obj_dup(z)];\n return y;\n}\n\n//Provides: caml_weak_check mutable\n//Requires: caml_ephe_key_offset\nfunction caml_weak_check(x, i) {\n if(x[caml_ephe_key_offset + i]!==undefined && x[caml_ephe_key_offset + i] !==0)\n return 1;\n else\n return 0;\n}\n\n//Provides: caml_weak_blit\n//Requires: caml_array_blit\n//Requires: caml_ephe_key_offset\nfunction caml_weak_blit(a1, i1, a2, i2, len) {\n // minus one because caml_array_blit works on ocaml array\n caml_array_blit(a1, caml_ephe_key_offset + i1 - 1,\n a2, caml_ephe_key_offset + i2 - 1,\n len);\n return 0;\n}\n\n//Provides: caml_ephe_create\n//Requires: caml_weak_create\nvar caml_ephe_create = caml_weak_create\n\n//Provides: caml_ephe_blit_key\n//Requires: caml_weak_blit\nvar caml_ephe_blit_key = caml_weak_blit\n\n//Provides: caml_ephe_get_key\n//Requires: caml_weak_get\nvar caml_ephe_get_key = caml_weak_get\n\n//Provides: caml_ephe_get_key_copy\n//Requires: caml_weak_get_copy\nvar caml_ephe_get_key_copy = caml_weak_get_copy\n\n//Provides: caml_ephe_check_key\n//Requires: caml_weak_check\nvar caml_ephe_check_key = caml_weak_check\n\n//Provides: caml_ephe_set_key\n//Requires: caml_weak_set\nfunction caml_ephe_set_key(x, i, v) {\n return caml_weak_set(x, i, [0, v])\n}\n\n//Provides: caml_ephe_unset_key\n//Requires: caml_weak_set\nfunction caml_ephe_unset_key(x, i) {\n return caml_weak_set(x, i, 0)\n}\n\n//Provides: caml_ephe_blit_data\n//Requires: caml_ephe_data_offset\nfunction caml_ephe_blit_data(src, dst){\n dst[caml_ephe_data_offset] = src[caml_ephe_data_offset];\n return 0;\n}\n\n//Provides: caml_ephe_get_data\n//Requires: caml_ephe_data_offset\nfunction caml_ephe_get_data(x){\n if(x[caml_ephe_data_offset] === undefined)\n return 0;\n else\n return [0, x[caml_ephe_data_offset]];\n}\n\n//Provides: caml_ephe_get_data_copy\n//Requires: caml_ephe_data_offset\n//Requires: caml_obj_dup\nfunction caml_ephe_get_data_copy(x){\n if(x[caml_ephe_data_offset] === undefined)\n return 0;\n else\n return [0, caml_obj_dup(x[caml_ephe_data_offset])];\n}\n\n//Provides: caml_ephe_set_data\n//Requires: caml_ephe_data_offset\nfunction caml_ephe_set_data(x, data){\n x[caml_ephe_data_offset] = data;\n return 0;\n}\n\n//Provides: caml_ephe_unset_data\n//Requires: caml_ephe_data_offset\nfunction caml_ephe_unset_data(x, data){\n x[caml_ephe_data_offset] = undefined;\n return 0;\n}\n\n//Provides: caml_ephe_check_data\n//Requires: caml_ephe_data_offset\nfunction caml_ephe_check_data(x){\n if(x[caml_ephe_data_offset] === undefined)\n return 0;\n else\n return 1;\n}\n","\n\n//Provides: caml_gc_minor\nfunction caml_gc_minor(){ return 0}\n//Provides: caml_gc_major\nfunction caml_gc_major(){ return 0}\n//Provides: caml_gc_full_major\nfunction caml_gc_full_major(){ return 0}\n//Provides: caml_gc_compaction\nfunction caml_gc_compaction(){ return 0}\n//Provides: caml_gc_counters\nfunction caml_gc_counters() { return [254,0,0,0] }\n//Provides: caml_gc_quick_stat\nfunction caml_gc_quick_stat(){\n return [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]\n}\n//Provides: caml_gc_stat\nfunction caml_gc_stat() {\n return [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]\n}\n\n//Provides: caml_gc_set\nfunction caml_gc_set(_control) {\n return 0;\n}\n\n//Provides: caml_gc_get\nfunction caml_gc_get(){\n return [0,0,0,0,0,0,0,0,0]\n}\n\n//Provides: caml_memprof_set\nfunction caml_memprof_set(_control) {\n return 0;\n}\n\n//Provides: caml_final_register const\nfunction caml_final_register () { return 0; }\n//Provides: caml_final_register_called_without_value const\nfunction caml_final_register_called_without_value () { return 0; }\n//Provides: caml_final_release const\nfunction caml_final_release () { return 0; }\n\n//Provides: caml_memprof_start\nfunction caml_memprof_start(rate,stack_size,tracker){\n return 0;\n}\n\n//Provides: caml_memprof_stop\nfunction caml_memprof_stop(unit) {\n return 0;\n}\n\n//Provides: caml_eventlog_resume\nfunction caml_eventlog_resume(unit) { return 0; }\n\n//Provides: caml_eventlog_pause\nfunction caml_eventlog_pause(unit) { return 0; }\n\n//Provides: caml_gc_huge_fallback_count\nfunction caml_gc_huge_fallback_count(unit) { return 0; }\n\n//Provides: caml_gc_major_slice\nfunction caml_gc_major_slice(work) { return 0; }\n\n//Provides: caml_gc_minor_words\nfunction caml_gc_minor_words(unit) { return 0; }\n\n//Provides: caml_get_minor_free\nfunction caml_get_minor_free(unit) { return 0; }\n\n//Provides: caml_get_major_bucket\nfunction caml_get_major_bucket(n) { return 0; }\n\n//Provides: caml_get_major_credit\nfunction caml_get_major_credit(n) { return 0; }\n","// Js_of_ocaml runtime support\n// http://www.ocsigen.org/js_of_ocaml/\n//\n// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU Lesser General Public License as published by\n// the Free Software Foundation, with linking exception;\n// either version 2.1 of the License, or (at your option) any later version.\n//\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n// GNU Lesser General Public License for more details.\n//\n// You should have received a copy of the GNU Lesser General Public License\n// along with this program; if not, write to the Free Software\n// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n\n///////////// Format\n\n//Provides: caml_parse_format\n//Requires: caml_jsbytes_of_string, caml_invalid_argument\nfunction caml_parse_format (fmt) {\n fmt = caml_jsbytes_of_string(fmt);\n var len = fmt.length;\n if (len > 31) caml_invalid_argument(\"format_int: format too long\");\n var f =\n { justify:'+', signstyle:'-', filler:' ', alternate:false,\n base:0, signedconv:false, width:0, uppercase:false,\n sign:1, prec:-1, conv:'f' };\n for (var i = 0; i < len; i++) {\n var c = fmt.charAt(i);\n switch (c) {\n case '-':\n f.justify = '-'; break;\n case '+': case ' ':\n f.signstyle = c; break;\n case '0':\n f.filler = '0'; break;\n case '#':\n f.alternate = true; break;\n case '1': case '2': case '3': case '4': case '5':\n case '6': case '7': case '8': case '9':\n f.width = 0;\n while (c=fmt.charCodeAt(i) - 48, c >= 0 && c <= 9) {\n f.width = f.width * 10 + c; i++\n }\n i--;\n break;\n case '.':\n f.prec = 0;\n i++;\n while (c=fmt.charCodeAt(i) - 48, c >= 0 && c <= 9) {\n f.prec = f.prec * 10 + c; i++\n }\n i--;\n case 'd': case 'i':\n f.signedconv = true; /* fallthrough */\n case 'u':\n f.base = 10; break;\n case 'x':\n f.base = 16; break;\n case 'X':\n f.base = 16; f.uppercase = true; break;\n case 'o':\n f.base = 8; break;\n case 'e': case 'f': case 'g':\n f.signedconv = true; f.conv = c; break;\n case 'E': case 'F': case 'G':\n f.signedconv = true; f.uppercase = true;\n f.conv = c.toLowerCase (); break;\n }\n }\n return f;\n}\n\n//Provides: caml_finish_formatting\n//Requires: caml_string_of_jsbytes\nfunction caml_finish_formatting(f, rawbuffer) {\n if (f.uppercase) rawbuffer = rawbuffer.toUpperCase();\n var len = rawbuffer.length;\n /* Adjust len to reflect additional chars (sign, etc) */\n if (f.signedconv && (f.sign < 0 || f.signstyle != '-')) len++;\n if (f.alternate) {\n if (f.base == 8) len += 1;\n if (f.base == 16) len += 2;\n }\n /* Do the formatting */\n var buffer = \"\";\n if (f.justify == '+' && f.filler == ' ')\n for (var i = len; i < f.width; i++) buffer += ' ';\n if (f.signedconv) {\n if (f.sign < 0) buffer += '-';\n else if (f.signstyle != '-') buffer += f.signstyle;\n }\n if (f.alternate && f.base == 8) buffer += '0';\n if (f.alternate && f.base == 16) buffer += \"0x\";\n if (f.justify == '+' && f.filler == '0')\n for (var i = len; i < f.width; i++) buffer += '0';\n buffer += rawbuffer;\n if (f.justify == '-')\n for (var i = len; i < f.width; i++) buffer += ' ';\n return caml_string_of_jsbytes(buffer);\n}\n","// Js_of_ocaml runtime support\n// http://www.ocsigen.org/js_of_ocaml/\n//\n// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU Lesser General Public License as published by\n// the Free Software Foundation, with linking exception;\n// either version 2.1 of the License, or (at your option) any later version.\n//\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n// GNU Lesser General Public License for more details.\n//\n// You should have received a copy of the GNU Lesser General Public License\n// along with this program; if not, write to the Free Software\n// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n\n//Provides: caml_update_dummy\nfunction caml_update_dummy (x, y) {\n if( typeof y===\"function\" ) { x.fun = y; return 0; }\n if( y.fun ) { x.fun = y.fun; return 0; }\n var i = y.length; while (i--) x[i] = y[i]; return 0;\n}\n\n//Provides: caml_obj_is_block const (const)\nfunction caml_obj_is_block (x) { return +(x instanceof Array); }\n\n\n//Provides: caml_obj_tag\n//Requires: caml_is_ml_bytes, caml_is_ml_string\nfunction caml_obj_tag (x) {\n if ((x instanceof Array) && x[0] == (x[0] >>> 0))\n return x[0]\n else if (caml_is_ml_bytes(x))\n return 252\n else if (caml_is_ml_string(x))\n return 252\n else if ((x instanceof Function) || typeof x == \"function\")\n return 247\n else if (x && x.caml_custom)\n return 255\n else\n return 1000\n}\n\n//Provides: caml_obj_set_tag (mutable, const)\nfunction caml_obj_set_tag (x, tag) { x[0] = tag; return 0; }\n//Provides: caml_obj_block const (const,const)\nfunction caml_obj_block (tag, size) {\n var o = new Array(size+1);\n o[0]=tag;\n for (var i = 1; i <= size; i++) o[i] = 0;\n return o;\n}\n\n//Provides: caml_obj_with_tag\nfunction caml_obj_with_tag(tag,x) {\n var l = x.length;\n var a = new Array(l);\n a[0] = tag;\n for(var i = 1; i < l; i++ ) a[i] = x[i];\n return a;\n}\n\n//Provides: caml_obj_dup mutable (const)\nfunction caml_obj_dup (x) {\n var l = x.length;\n var a = new Array(l);\n for(var i = 0; i < l; i++ ) a[i] = x[i];\n return a;\n}\n\n//Provides: caml_obj_truncate (mutable, const)\n//Requires: caml_invalid_argument\nfunction caml_obj_truncate (x, s) {\n if (s<=0 || s + 1 > x.length)\n caml_invalid_argument (\"Obj.truncate\");\n if (x.length != s + 1) x.length = s + 1;\n return 0;\n}\n\n//Provides: caml_obj_make_forward\nfunction caml_obj_make_forward (b,v) {\n b[0]=250;\n b[1]=v;\n return 0\n}\n\n//Provides: caml_lazy_make_forward const (const)\nfunction caml_lazy_make_forward (v) { return [250, v]; }\n\n///////////// CamlinternalOO\n//Provides: caml_get_public_method const\nvar caml_method_cache = [];\nfunction caml_get_public_method (obj, tag, cacheid) {\n var meths = obj[1];\n var ofs = caml_method_cache[cacheid];\n if (ofs === undefined) {\n // Make sure the array is not sparse\n for (var i = caml_method_cache.length; i < cacheid; i++)\n caml_method_cache[i] = 0;\n } else if (meths[ofs] === tag) {\n return meths[ofs - 1];\n }\n var li = 3, hi = meths[1] * 2 + 1, mi;\n while (li < hi) {\n mi = ((li+hi) >> 1) | 1;\n if (tag < meths[mi+1]) hi = mi-2;\n else li = mi;\n }\n caml_method_cache[cacheid] = li + 1;\n /* return 0 if tag is not there */\n return (tag == meths[li+1] ? meths[li] : 0);\n}\n\n//Provides: caml_oo_last_id\nvar caml_oo_last_id = 0;\n\n//Provides: caml_set_oo_id\n//Requires: caml_oo_last_id\nfunction caml_set_oo_id (b) {\n b[2]=caml_oo_last_id++;\n return b;\n}\n\n//Provides: caml_fresh_oo_id const\n//Requires: caml_oo_last_id\nfunction caml_fresh_oo_id() {\n return caml_oo_last_id++;\n}\n\n//Provides: caml_obj_raw_field\nfunction caml_obj_raw_field(o,i) { return o[i+1] }\n\n//Provides: caml_obj_set_raw_field\nfunction caml_obj_set_raw_field(o,i,v) { return o[i+1] = v }\n\n//Provides: caml_obj_reachable_words\nfunction caml_obj_reachable_words(o) { return 0; }\n\n//Provides: caml_obj_add_offset\n//Requires: caml_failwith\nfunction caml_obj_add_offset(v,offset) {\n caml_failwith(\"Obj.add_offset is not supported\");\n}\n","// Js_of_ocaml runtime support\n// http://www.ocsigen.org/js_of_ocaml/\n// Copyright (C) 2014 Jérôme Vouillon, Hugo Heuzard\n// Laboratoire PPS - CNRS Université Paris Diderot\n//\n// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU Lesser General Public License as published by\n// the Free Software Foundation, with linking exception;\n// either version 2.1 of the License, or (at your option) any later version.\n//\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n// GNU Lesser General Public License for more details.\n//\n// You should have received a copy of the GNU Lesser General Public License\n// along with this program; if not, write to the Free Software\n// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n\n//Provides: fs_node_supported\nfunction fs_node_supported () {\n return (\n typeof globalThis.process !== 'undefined'\n && typeof globalThis.process.versions !== 'undefined'\n && typeof globalThis.process.versions.node !== 'undefined')\n}\n//Provides: fs_node_supported\n//If: browser\nfunction fs_node_supported () {\n return false\n}\n\n\n//Provides: MlNodeDevice\n//Requires: MlNodeFile, caml_raise_sys_error, caml_raise_with_args\n//Requires: make_unix_err_args, caml_named_value, caml_string_of_jsstring\nfunction MlNodeDevice(root) {\n this.fs = require('fs');\n this.root = root;\n}\nMlNodeDevice.prototype.nm = function(name) {\n return (this.root + name);\n}\nMlNodeDevice.prototype.exists = function(name) {\n try {\n return this.fs.existsSync(this.nm(name))?1:0;\n } catch (err) {\n return 0;\n }\n}\nMlNodeDevice.prototype.mkdir = function(name, mode, raise_unix) {\n try {\n this.fs.mkdirSync(this.nm(name),{mode:mode});\n return 0\n } catch (err) {\n this.raise_nodejs_error(err, raise_unix);\n }\n}\nMlNodeDevice.prototype.rmdir = function(name, raise_unix) {\n try {\n this.fs.rmdirSync(this.nm(name));\n return 0\n } catch (err) {\n this.raise_nodejs_error(err, raise_unix);\n }\n}\nMlNodeDevice.prototype.readdir = function(name, raise_unix) {\n try {\n return this.fs.readdirSync(this.nm(name));\n } catch (err) {\n this.raise_nodejs_error(err, raise_unix);\n }\n}\nMlNodeDevice.prototype.is_dir = function(name) {\n try {\n return this.fs.statSync(this.nm(name)).isDirectory()?1:0;\n } catch (err) {\n caml_raise_sys_error(err.toString());\n }\n}\nMlNodeDevice.prototype.unlink = function(name, raise_unix) {\n try {\n var b = this.fs.existsSync(this.nm(name))?1:0;\n this.fs.unlinkSync(this.nm(name));\n return b;\n } catch (err) {\n this.raise_nodejs_error(err, raise_unix);\n }\n}\nMlNodeDevice.prototype.open = function(name, f, raise_unix) {\n var consts = require('constants');\n var res = 0;\n for(var key in f){\n switch(key){\n case \"rdonly\" : res |= consts.O_RDONLY; break;\n case \"wronly\" : res |= consts.O_WRONLY; break;\n case \"append\" :\n res |= consts.O_WRONLY | consts.O_APPEND;\n break;\n case \"create\" : res |= consts.O_CREAT; break;\n case \"truncate\" : res |= consts.O_TRUNC; break;\n case \"excl\" : res |= consts.O_EXCL; break;\n case \"binary\" : res |= consts.O_BINARY; break;\n case \"text\" : res |= consts.O_TEXT; break;\n case \"nonblock\" : res |= consts.O_NONBLOCK; break;\n }\n }\n try {\n var fd = this.fs.openSync(this.nm(name), res);\n return new MlNodeFile(fd);\n } catch (err) {\n this.raise_nodejs_error(err, raise_unix);\n }\n}\n\nMlNodeDevice.prototype.rename = function(o, n, raise_unix) {\n try {\n this.fs.renameSync(this.nm(o), this.nm(n));\n } catch (err) {\n this.raise_nodejs_error(err, raise_unix);\n }\n}\nMlNodeDevice.prototype.stat = function(name, raise_unix) {\n try {\n var js_stats = this.fs.statSync(this.nm(name));\n return this.stats_from_js(js_stats);\n } catch (err) {\n this.raise_nodejs_error(err, raise_unix);\n }\n}\nMlNodeDevice.prototype.lstat = function(name, raise_unix) {\n try {\n var js_stats = this.fs.lstatSync(this.nm(name));\n return this.stats_from_js(js_stats);\n } catch (err) {\n this.raise_nodejs_error(err, raise_unix);\n }\n}\nMlNodeDevice.prototype.symlink = function(to_dir, target, path, raise_unix) {\n try {\n this.fs.symlinkSync(this.nm(target), this.nm(path), to_dir ? 'dir' : 'file');\n return 0;\n } catch (err) {\n this.raise_nodejs_error(err, raise_unix);\n }\n}\nMlNodeDevice.prototype.readlink = function(name, raise_unix) {\n try {\n var link = this.fs.readlinkSync(this.nm(name), 'utf8');\n return caml_string_of_jsstring(link);\n } catch (err) {\n this.raise_nodejs_error(err, raise_unix);\n }\n}\nMlNodeDevice.prototype.raise_nodejs_error = function(err, raise_unix) {\n var unix_error = caml_named_value(\"Unix.Unix_error\");\n if (raise_unix && unix_error) {\n var args = make_unix_err_args(err.code, err.syscall, err.path, err.errno);\n caml_raise_with_args(unix_error, args);\n } else {\n caml_raise_sys_error(err.toString());\n }\n}\nMlNodeDevice.prototype.stats_from_js = function(js_stats) {\n /* ===Unix.file_kind===\n * type file_kind =\n * S_REG (** Regular file *)\n * | S_DIR (** Directory *)\n * | S_CHR (** Character device *)\n * | S_BLK (** Block device *)\n * | S_LNK (** Symbolic link *)\n * | S_FIFO (** Named pipe *)\n * | S_SOCK (** Socket *)\n */\n var file_kind;\n if (js_stats.isFile()) {\n file_kind = 0;\n } else if (js_stats.isDirectory()) {\n file_kind = 1;\n } else if (js_stats.isCharacterDevice()) {\n file_kind = 2;\n } else if (js_stats.isBlockDevice()) {\n file_kind = 3;\n } else if (js_stats.isSymbolicLink()) {\n file_kind = 4;\n } else if (js_stats.isFIFO()) {\n file_kind = 5;\n } else if (js_stats.isSocket()) {\n file_kind = 6;\n }\n /* ===Unix.stats===\n * type stats =\n * { st_dev : int; (** Device number *)\n * st_ino : int; (** Inode number *)\n * st_kind : file_kind; (** Kind of the file *)\n * st_perm : file_perm; (** Access rights *)\n * st_nlink : int; (** Number of links *)\n * st_uid : int; (** User id of the owner *)\n * st_gid : int; (** Group ID of the file's group *)\n * st_rdev : int; (** Device ID (if special file) *)\n * st_size : int; (** Size in bytes *)\n * st_atime : float; (** Last access time *)\n * st_mtime : float; (** Last modification time *)\n * st_ctime : float; (** Last status change time *)\n * }\n */\n return BLOCK(\n 0,\n js_stats.dev,\n js_stats.ino,\n file_kind,\n js_stats.mode,\n js_stats.nlink,\n js_stats.uid,\n js_stats.gid,\n js_stats.rdev,\n js_stats.size,\n js_stats.atimeMs,\n js_stats.mtimeMs,\n js_stats.ctimeMs\n );\n}\n\nMlNodeDevice.prototype.constructor = MlNodeDevice\n\n//Provides: MlNodeDevice\n//If: browser\nfunction MlNodeDevice() {\n}\n\n//Provides: MlNodeFile\n//Requires: MlFile, caml_array_of_string, caml_array_of_bytes, caml_bytes_set, caml_raise_sys_error\nfunction MlNodeFile(fd){\n this.fs = require('fs');\n this.fd = fd;\n}\nMlNodeFile.prototype = new MlFile ();\n\nMlNodeFile.prototype.truncate = function(len){\n try {\n this.fs.ftruncateSync(this.fd,len|0)\n } catch (err) {\n caml_raise_sys_error(err.toString());\n }\n}\nMlNodeFile.prototype.length = function () {\n try {\n return this.fs.fstatSync(this.fd).size;\n } catch (err) {\n caml_raise_sys_error(err.toString());\n }\n}\nMlNodeFile.prototype.write = function(offset,buf,buf_offset,len){\n var a = caml_array_of_string(buf);\n if(! (a instanceof globalThis.Uint8Array))\n a = new globalThis.Uint8Array(a);\n var buffer = globalThis.Buffer.from(a);\n try {\n this.fs.writeSync(this.fd, buffer, buf_offset, len, offset);\n } catch (err) {\n caml_raise_sys_error(err.toString());\n }\n return 0;\n}\nMlNodeFile.prototype.read = function(offset,buf,buf_offset,len){\n var a = caml_array_of_bytes(buf);\n if(! (a instanceof globalThis.Uint8Array))\n a = new globalThis.Uint8Array(a);\n var buffer = globalThis.Buffer.from(a);\n try {\n this.fs.readSync(this.fd, buffer, buf_offset, len, offset);\n } catch (err) {\n caml_raise_sys_error(err.toString());\n }\n for(var i = 0; i < len; i++){\n caml_bytes_set(buf,buf_offset + i,buffer[buf_offset+i]);\n }\n return 0\n}\nMlNodeFile.prototype.read_one = function(offset){\n var a = new globalThis.Uint8Array(1);\n var buffer = globalThis.Buffer.from(a);\n try {\n this.fs.readSync(this.fd, buffer, 0, 1, offset);\n } catch (err) {\n caml_raise_sys_error(err.toString());\n }\n return buffer[0];\n}\nMlNodeFile.prototype.close = function(){\n try {\n this.fs.closeSync(this.fd);\n } catch (err) {\n caml_raise_sys_error(err.toString());\n }\n}\n\nMlNodeFile.prototype.constructor = MlNodeFile;\n\n//Provides: MlNodeFile\n//If: browser\nfunction MlNodeFile(){\n}\n","// Js_of_ocaml runtime support\n// http://www.ocsigen.org/js_of_ocaml/\n// Copyright (C) 2014 Jérôme Vouillon, Hugo Heuzard\n// Laboratoire PPS - CNRS Université Paris Diderot\n//\n// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU Lesser General Public License as published by\n// the Free Software Foundation, with linking exception;\n// either version 2.1 of the License, or (at your option) any later version.\n//\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n// GNU Lesser General Public License for more details.\n//\n// You should have received a copy of the GNU Lesser General Public License\n// along with this program; if not, write to the Free Software\n// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n\n///////////// Dummy filesystem\n\n//Provides: caml_trailing_slash\nfunction caml_trailing_slash(name){\n return (name.slice(-1) !== \"/\") ? (name + \"/\") : name;\n}\n\n//Provides: caml_current_dir\n//Requires: caml_trailing_slash, fs_node_supported\nif(fs_node_supported () && globalThis.process && globalThis.process.cwd)\n var caml_current_dir = globalThis.process.cwd().replace(/\\\\/g,'/');\nelse\n var caml_current_dir = \"/static\";\ncaml_current_dir = caml_trailing_slash(caml_current_dir);\n\n//Provides: caml_get_root\n//Requires: path_is_absolute\nfunction caml_get_root(path){\n var x = path_is_absolute(path);\n if (!x) return;\n return x[0] + \"/\"}\n\n//Provides: caml_root\n//Requires: caml_get_root, caml_current_dir, caml_failwith\nvar caml_root = caml_get_root(caml_current_dir) || caml_failwith(\"unable to compute caml_root\");\n\n\n//Provides: MlFile\nfunction MlFile(){ }\n\n//Provides: path_is_absolute\n//Requires: fs_node_supported\nfunction make_path_is_absolute() {\n function posix(path) {\n if (path.charAt(0) === '/') return [\"\", path.substring(1)];\n return;\n }\n\n function win32(path) {\n // https://github.com/nodejs/node/blob/b3fcc245fb25539909ef1d5eaa01dbf92e168633/lib/path.js#L56\n var splitDeviceRe = /^([a-zA-Z]:|[\\\\/]{2}[^\\\\/]+[\\\\/]+[^\\\\/]+)?([\\\\/])?([\\s\\S]*?)$/;\n var result = splitDeviceRe.exec(path);\n var device = result[1] || '';\n var isUnc = Boolean(device && device.charAt(1) !== ':');\n\n // UNC paths are always absolute\n if (Boolean(result[2] || isUnc)) {\n var root = (result[1] || '');\n var sep = (result[2] || '');\n return [root, path.substring(root.length + sep.length)]\n }\n return;\n }\n if(fs_node_supported () && globalThis.process && globalThis.process.platform) {\n return globalThis.process.platform === 'win32' ? win32 : posix;\n }\n else return posix\n}\nvar path_is_absolute = make_path_is_absolute();\n\n//Provides: caml_make_path\n//Requires: caml_current_dir\n//Requires: caml_jsstring_of_string, path_is_absolute\nfunction caml_make_path (name) {\n name=caml_jsstring_of_string(name);\n if( !path_is_absolute(name) )\n name = caml_current_dir + name;\n var comp0 = path_is_absolute(name);\n var comp = comp0[1].split(\"/\");\n var ncomp = []\n for(var i = 0; i1) ncomp.pop(); break;\n case \".\": break;\n default: ncomp.push(comp[i]);break\n }\n }\n ncomp.unshift(comp0[0]);\n ncomp.orig = name;\n return ncomp;\n}\n\n//Provides:jsoo_mount_point\n//Requires: MlFakeDevice, MlNodeDevice, caml_root, fs_node_supported\nvar jsoo_mount_point = []\nif (fs_node_supported()) {\n jsoo_mount_point.push({path:caml_root,device:new MlNodeDevice(caml_root)});\n} else {\n jsoo_mount_point.push({path:caml_root,device:new MlFakeDevice(caml_root)});\n}\njsoo_mount_point.push({path:\"/static/\", device:new MlFakeDevice(\"/static/\")});\n\n//Provides:caml_list_mount_point\n//Requires: jsoo_mount_point, caml_string_of_jsbytes\nfunction caml_list_mount_point(){\n var prev = 0\n for(var i = 0; i < jsoo_mount_point.length; i++){\n var old = prev;\n prev = [0, caml_string_of_jsbytes(jsoo_mount_point[i].path), old]\n }\n return prev;\n}\n\n//Provides: resolve_fs_device\n//Requires: caml_make_path, jsoo_mount_point, caml_raise_sys_error, caml_get_root, MlNodeDevice, caml_trailing_slash, fs_node_supported\nfunction resolve_fs_device(name){\n var path = caml_make_path(name);\n var name = path.join(\"/\");\n var name_slash = caml_trailing_slash(name);\n var res;\n for(var i = 0; i < jsoo_mount_point.length; i++) {\n var m = jsoo_mount_point[i];\n if(name_slash.search(m.path) == 0\n && (!res || res.path.length < m.path.length))\n res = {path:m.path,device:m.device,rest:name.substring(m.path.length,name.length)};\n }\n if( !res && fs_node_supported()) {\n var root = caml_get_root(name);\n if (root && root.match(/^[a-zA-Z]:\\/$/)){\n var m = {path:root,device:new MlNodeDevice(root)};\n jsoo_mount_point.push(m);\n res = {path:m.path,device:m.device,rest:name.substring(m.path.length,name.length)};\n }\n }\n if( res ) return res;\n caml_raise_sys_error(\"no device found for \" + name_slash);\n}\n\n//Provides: caml_mount_autoload\n//Requires: MlFakeDevice, caml_make_path, jsoo_mount_point, caml_trailing_slash\nfunction caml_mount_autoload(name,f){\n var path = caml_make_path(name);\n var name = caml_trailing_slash(path.join(\"/\"));\n jsoo_mount_point.push({path:name,device:new MlFakeDevice(name,f)})\n return 0;\n}\n\n//Provides: caml_unmount\n//Requires: jsoo_mount_point, caml_make_path, caml_trailing_slash\nfunction caml_unmount(name){\n var path = caml_make_path(name);\n var name = caml_trailing_slash(path.join(\"/\"));\n var idx = -1;\n for(var i = 0; i < jsoo_mount_point.length; i++)\n if(jsoo_mount_point[i].path == name) idx = i;\n if(idx > -1) jsoo_mount_point.splice(idx,1);\n return 0\n}\n\n//Provides: caml_sys_getcwd\n//Requires: caml_current_dir, caml_string_of_jsbytes\nfunction caml_sys_getcwd() {\n return caml_string_of_jsbytes(caml_current_dir);\n}\n\n//Provides: caml_sys_chdir\n//Requires: caml_current_dir, caml_raise_no_such_file, resolve_fs_device, caml_trailing_slash, caml_jsbytes_of_string\nfunction caml_sys_chdir(dir) {\n var root = resolve_fs_device(dir);\n if(root.device.exists(root.rest)) {\n if(root.rest) caml_current_dir = caml_trailing_slash(root.path + root.rest);\n else caml_current_dir = root.path;\n return 0;\n }\n else {\n caml_raise_no_such_file(caml_jsbytes_of_string(dir));\n }\n}\n\n//Provides: caml_raise_no_such_file\n//Requires: caml_raise_sys_error\nfunction caml_raise_no_such_file(name){\n caml_raise_sys_error (name + \": No such file or directory\");\n}\n\n//Provides: caml_raise_not_a_dir\n//Requires: caml_raise_sys_error\nfunction caml_raise_not_a_dir(name){\n caml_raise_sys_error (name + \": Not a directory\");\n}\n\n//Provides: caml_sys_file_exists\n//Requires: resolve_fs_device\nfunction caml_sys_file_exists (name) {\n var root = resolve_fs_device(name);\n return root.device.exists(root.rest);\n}\n\n//Provides: caml_sys_read_directory\n//Requires: caml_string_of_jsbytes\n//Requires: caml_raise_not_a_dir, resolve_fs_device\nfunction caml_sys_read_directory(name){\n var root = resolve_fs_device(name);\n var a = root.device.readdir(root.rest);\n var l = new Array(a.length + 1);\n l[0] = 0;\n for(var i=0;i start) r+=\", \";\n var v = bucket[i]\n if(typeof v == \"number\")\n r+= v.toString();\n else if(v instanceof MlBytes){\n r+= '\"' + v.toString() + '\"';\n }\n else if(typeof v == \"string\"){\n r+= '\"' + v.toString() + '\"';\n }\n else r += \"_\";\n }\n r += \")\"\n } else if (exn[0] == 248){\n r += exn[1]\n }\n return r\n}\n\n//Provides: caml_fatal_uncaught_exception\n//Requires: caml_named_value, caml_format_exception\nfunction caml_fatal_uncaught_exception(err){\n if(err instanceof Array && (err[0] == 0 || err[0] == 248)) {\n var handler = caml_named_value(\"Printexc.handle_uncaught_exception\");\n if(handler) handler(err,false);\n else {\n var msg = caml_format_exception(err);\n var at_exit = caml_named_value(\"Pervasives.do_at_exit\");\n if(at_exit) { at_exit(0) }\n globalThis.console.error(\"Fatal error: exception \" + msg + \"\\n\");\n }\n }\n else {\n throw err\n }\n}\n\n\n//Provides: caml_set_static_env\nfunction caml_set_static_env(k,v){\n if(!globalThis.jsoo_static_env)\n globalThis.jsoo_static_env = {}\n globalThis.jsoo_static_env[k] = v;\n return 0;\n}\n//Provides: caml_sys_getenv (const)\n//Requires: caml_raise_not_found\n//Requires: caml_string_of_jsstring\n//Requires: caml_jsstring_of_string\nfunction caml_sys_getenv (name) {\n var g = globalThis;\n var n = caml_jsstring_of_string(name);\n //nodejs env\n if(g.process\n && g.process.env\n && g.process.env[n] != undefined)\n return caml_string_of_jsstring(g.process.env[n]);\n if(globalThis.jsoo_static_env\n && globalThis.jsoo_static_env[n])\n return caml_string_of_jsstring(globalThis.jsoo_static_env[n])\n caml_raise_not_found ();\n}\n\n//Provides: caml_sys_unsafe_getenv\n//Requires: caml_sys_getenv\nfunction caml_sys_unsafe_getenv(name){\n return caml_sys_getenv (name);\n}\n\n//Provides: caml_argv\n//Requires: caml_string_of_jsstring\nvar caml_argv = ((function () {\n var g = globalThis;\n var main = \"a.out\";\n var args = []\n\n if(g.process\n && g.process.argv\n && g.process.argv.length > 1) {\n var argv = g.process.argv\n //nodejs\n main = argv[1];\n args = argv.slice(2);\n }\n\n var p = caml_string_of_jsstring(main);\n var args2 = [0, p];\n for(var i = 0; i < args.length; i++)\n args2.push(caml_string_of_jsstring(args[i]));\n return args2;\n})())\n\n//Provides: caml_executable_name\n//Requires: caml_argv\nvar caml_executable_name = caml_argv[1]\n\n//Provides: caml_sys_get_argv\n//Requires: caml_argv\nfunction caml_sys_get_argv (a) {\n return [0, caml_argv[1], caml_argv];\n}\n\n//Provides: caml_sys_argv\n//Requires: caml_argv\nfunction caml_sys_argv (a) {\n return caml_argv;\n}\n\n//Provides: caml_sys_modify_argv\n//Requires: caml_argv\nfunction caml_sys_modify_argv(arg){\n caml_argv = arg;\n return 0;\n}\n\n//Provides: caml_sys_executable_name const\n//Requires: caml_executable_name\nfunction caml_sys_executable_name(a){\n return caml_executable_name\n}\n\n//Provides: caml_sys_system_command\n//Requires: caml_jsstring_of_string\nfunction caml_sys_system_command(cmd){\n var cmd = caml_jsstring_of_string(cmd);\n if (typeof require != \"undefined\"\n && require('child_process')\n && require('child_process').execSync) {\n try {require('child_process').execSync(cmd,{stdio: 'inherit'}); return 0}\n catch (e) {return 1}\n }\n else return 127;\n}\n\n//Provides: caml_sys_time mutable\nvar caml_initial_time = (new Date()).getTime() * 0.001;\nfunction caml_sys_time () {\n var now = (new Date()).getTime();\n return now * 0.001 - caml_initial_time;\n}\n\n//Provides: caml_sys_time_include_children\n//Requires: caml_sys_time\nfunction caml_sys_time_include_children(b) {\n return caml_sys_time();\n}\n\n//Provides: caml_sys_random_seed mutable\n//The function needs to return an array since OCaml 4.0...\nfunction caml_sys_random_seed () {\n if(globalThis.crypto) {\n if(typeof globalThis.crypto.getRandomValues === 'function'){\n // Webbrowsers\n var a = new globalThis.Uint32Array(1);\n globalThis.crypto.getRandomValues(a);\n return [0,a[0]];\n } else if(globalThis.crypto.randomBytes === 'function'){\n // Nodejs\n var buff = globalThis.crypto.randomBytes(4);\n var a = new globalThis.Uint32Array(buff);\n return [0,a[0]];\n }\n }\n var now = (new Date()).getTime();\n var x = now^0xffffffff*Math.random();\n return [0,x];\n}\n\n//Provides: caml_sys_const_big_endian const\nfunction caml_sys_const_big_endian () { return 0; }\n\n//Provides: caml_sys_const_word_size const\nfunction caml_sys_const_word_size () { return 32; }\n\n//Provides: caml_sys_const_int_size const\nfunction caml_sys_const_int_size () { return 32; }\n\n//Provides: caml_sys_const_max_wosize const\n// max_int / 4 so that the following does not overflow\n//let max_string_length = word_size / 8 * max_array_length - 1;;\nfunction caml_sys_const_max_wosize () { return (0x7FFFFFFF/4) | 0;}\n\n//Provides: caml_sys_const_ostype_unix const\n//Requires: os_type\nfunction caml_sys_const_ostype_unix () { return os_type == \"Unix\" ? 1 : 0; }\n//Provides: caml_sys_const_ostype_win32 const\n//Requires: os_type\nfunction caml_sys_const_ostype_win32 () { return os_type == \"Win32\" ? 1 : 0; }\n//Provides: caml_sys_const_ostype_cygwin const\n//Requires: os_type\nfunction caml_sys_const_ostype_cygwin () { return os_type == \"Cygwin\" ? 1 : 0; }\n\n//Provides: caml_sys_const_backend_type const\n//Requires: caml_string_of_jsbytes\nfunction caml_sys_const_backend_type () {\n return [0, caml_string_of_jsbytes(\"js_of_ocaml\")];\n}\n\n//Provides: os_type\nvar os_type = (globalThis.process &&\n globalThis.process.platform &&\n globalThis.process.platform == \"win32\") ? \"Cygwin\" : \"Unix\";\n\n\n//Provides: caml_sys_get_config const\n//Requires: caml_string_of_jsbytes, os_type\nfunction caml_sys_get_config () {\n return [0, caml_string_of_jsbytes(os_type), 32, 0];\n}\n\n//Provides: caml_sys_isatty\nfunction caml_sys_isatty(_chan) {\n return 0;\n}\n\n//Provides: caml_runtime_variant\n//Requires: caml_string_of_jsbytes\nfunction caml_runtime_variant(_unit) {\n return caml_string_of_jsbytes(\"\");\n}\n//Provides: caml_runtime_parameters\n//Requires: caml_string_of_jsbytes\nfunction caml_runtime_parameters(_unit) {\n return caml_string_of_jsbytes(\"\");\n}\n\n//Provides: caml_install_signal_handler const\nfunction caml_install_signal_handler(){return 0}\n\n//Provides: unix_inet_addr_of_string\nfunction unix_inet_addr_of_string () {return 0;}\n\n\n\n//Provides: caml_runtime_warnings\nvar caml_runtime_warnings = 0;\n\n//Provides: caml_ml_enable_runtime_warnings\n//Requires: caml_runtime_warnings\nfunction caml_ml_enable_runtime_warnings (bool) {\n caml_runtime_warnings = bool;\n return 0;\n}\n\n//Provides: caml_ml_runtime_warnings_enabled\n//Requires: caml_runtime_warnings\nfunction caml_ml_runtime_warnings_enabled (_unit) {\n return caml_runtime_warnings;\n}\n\n\n//Provides: caml_spacetime_enabled const (const)\nfunction caml_spacetime_enabled(_unit) {\n return 0;\n}\n\n//Provides: caml_sys_const_naked_pointers_checked const (const)\nfunction caml_sys_const_naked_pointers_checked(_unit) {\n return 0;\n}\n\n//Provides: caml_register_channel_for_spacetime const (const)\nfunction caml_register_channel_for_spacetime(_channel) {\n return 0;\n}\n\n//Provides: caml_spacetime_only_works_for_native_code\n//Requires: caml_failwith\nfunction caml_spacetime_only_works_for_native_code() {\n caml_failwith(\"Spacetime profiling only works for native code\");\n}\n\n//Always\n//Requires: caml_fatal_uncaught_exception\nfunction caml_setup_uncaught_exception_handler() {\n var g = globalThis;\n if(g.process && g.process.on) {\n g.process.on('uncaughtException', function (err, origin) {\n caml_fatal_uncaught_exception(err);\n g.process.exit (2);\n })\n }\n else if(g.addEventListener){\n g.addEventListener('error', function(event){\n if(event.error){\n caml_fatal_uncaught_exception(event.error);\n }\n });\n }\n}\ncaml_setup_uncaught_exception_handler();\n","// Js_of_ocaml runtime support\n// http://www.ocsigen.org/js_of_ocaml/\n// Copyright (C) 2014 Jérôme Vouillon, Hugo Heuzard\n// Laboratoire PPS - CNRS Université Paris Diderot\n//\n// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU Lesser General Public License as published by\n// the Free Software Foundation, with linking exception;\n// either version 2.1 of the License, or (at your option) any later version.\n//\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n// GNU Lesser General Public License for more details.\n//\n// You should have received a copy of the GNU Lesser General Public License\n// along with this program; if not, write to the Free Software\n// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n\n//Provides: MlFakeDevice\n//Requires: MlFakeFile, caml_create_bytes\n//Requires: caml_raise_sys_error, caml_raise_no_such_file\n//Requires: caml_string_of_jsbytes, caml_string_of_jsstring\n//Requires: caml_bytes_of_array, caml_bytes_of_string, caml_bytes_of_jsbytes\n//Requires: caml_is_ml_bytes, caml_is_ml_string\n//Requires: caml_named_value, caml_raise_with_args, caml_named_values\n//Requires: make_unix_err_args\nfunction MlFakeDevice (root, f) {\n this.content={};\n this.root = root;\n this.lookupFun = f;\n}\nMlFakeDevice.prototype.nm = function(name) {\n return (this.root + name);\n}\nMlFakeDevice.prototype.create_dir_if_needed = function(name) {\n var comp = name.split(\"/\");\n var res = \"\";\n for(var i = 0; i < comp.length - 1; i++){\n res += comp[i] + \"/\";\n if(this.content[res]) continue;\n this.content[res] = Symbol(\"directory\");\n }\n}\nMlFakeDevice.prototype.slash = function(name){\n return /\\/$/.test(name)?name:(name + \"/\");\n}\nMlFakeDevice.prototype.lookup = function(name) {\n if(!this.content[name] && this.lookupFun) {\n var res = this.lookupFun(caml_string_of_jsbytes(this.root), caml_string_of_jsbytes(name));\n if(res !== 0) {\n this.create_dir_if_needed(name);\n this.content[name]=new MlFakeFile(caml_bytes_of_string(res[1]));\n }\n }\n}\nMlFakeDevice.prototype.exists = function(name) {\n // The root of the device exists\n if(name == \"\") return 1;\n // Check if a directory exists\n var name_slash = this.slash(name);\n if(this.content[name_slash]) return 1;\n // Check if a file exists\n this.lookup(name);\n return this.content[name]?1:0;\n}\nMlFakeDevice.prototype.mkdir = function(name,mode, raise_unix) {\n var unix_error = raise_unix && caml_named_value('Unix.Unix_error');\n if(this.exists(name)) {\n if (unix_error) {\n caml_raise_with_args(unix_error, make_unix_err_args(\"EEXIST\", \"mkdir\", this.nm(name)));\n }\n else {\n caml_raise_sys_error(name + \": File exists\");\n }\n }\n var parent = /^(.*)\\/[^/]+/.exec(name);\n parent = (parent && parent[1]) || '';\n if(!this.exists(parent)){\n if (unix_error) {\n caml_raise_with_args(unix_error, make_unix_err_args(\"ENOENT\", \"mkdir\", this.nm(parent)));\n }\n else {\n caml_raise_sys_error(parent + \": No such file or directory\");\n }\n }\n if(!this.is_dir(parent)){\n if (unix_error) {\n caml_raise_with_args(unix_error, make_unix_err_args(\"ENOTDIR\", \"mkdir\", this.nm(parent)));\n }\n else {\n caml_raise_sys_error(parent + \": Not a directory\");\n }\n }\n this.create_dir_if_needed(this.slash(name));\n}\nMlFakeDevice.prototype.rmdir = function(name, raise_unix) {\n var unix_error = raise_unix && caml_named_value('Unix.Unix_error');\n var name_slash = (name == \"\")?\"\":(this.slash(name));\n var r = new RegExp(\"^\" + name_slash + \"([^/]+)\");\n if(!this.exists(name)) {\n if (unix_error) {\n caml_raise_with_args(unix_error, make_unix_err_args(\"ENOENT\", \"rmdir\", this.nm(name)));\n }\n else {\n caml_raise_sys_error(name + \": No such file or directory\");\n }\n }\n if(!this.is_dir(name)) {\n if (unix_error) {\n caml_raise_with_args(unix_error, make_unix_err_args(\"ENOTDIR\", \"rmdir\", this.nm(name)));\n }\n else {\n caml_raise_sys_error(name + \": Not a directory\");\n }\n }\n for(var n in this.content) {\n if(n.match(r)) {\n if (unix_error) {\n caml_raise_with_args(unix_error, make_unix_err_args(\"ENOTEMPTY\", \"rmdir\", this.nm(name)));\n } else {\n caml_raise_sys_error(this.nm(name) + \": Directory not empty\");\n }\n }\n }\n delete this.content[name_slash];\n}\nMlFakeDevice.prototype.readdir = function(name) {\n var name_slash = (name == \"\")?\"\":(this.slash(name));\n if(!this.exists(name)) {\n caml_raise_sys_error(name + \": No such file or directory\");\n }\n if(!this.is_dir(name)) {\n caml_raise_sys_error(name + \": Not a directory\");\n }\n var r = new RegExp(\"^\" + name_slash + \"([^/]+)\");\n var seen = {}\n var a = [];\n for(var n in this.content) {\n var m = n.match(r);\n if(m && !seen[m[1]]) {seen[m[1]] = true; a.push(m[1])}\n }\n return a;\n}\nMlFakeDevice.prototype.is_dir = function(name) {\n if(name == \"\") return true;\n var name_slash = this.slash(name);\n return this.content[name_slash]?1:0;\n}\nMlFakeDevice.prototype.unlink = function(name) {\n var ok = this.content[name]?true:false;\n delete this.content[name];\n return ok;\n}\nMlFakeDevice.prototype.open = function(name, f) {\n if(f.rdonly && f.wronly)\n caml_raise_sys_error(this.nm(name) + \" : flags Open_rdonly and Open_wronly are not compatible\");\n if(f.text && f.binary)\n caml_raise_sys_error(this.nm(name) + \" : flags Open_text and Open_binary are not compatible\");\n this.lookup(name);\n if (this.content[name]) {\n if (this.is_dir(name)) caml_raise_sys_error(this.nm(name) + \" : is a directory\");\n if (f.create && f.excl) caml_raise_sys_error(this.nm(name) + \" : file already exists\");\n var file = this.content[name];\n if(f.truncate) file.truncate();\n return file;\n } else if (f.create) {\n this.create_dir_if_needed(name);\n this.content[name] = new MlFakeFile(caml_create_bytes(0));\n return this.content[name];\n } else {\n caml_raise_no_such_file (this.nm(name));\n }\n}\n\nMlFakeDevice.prototype.register= function (name,content){\n var file;\n if(this.content[name]) caml_raise_sys_error(this.nm(name) + \" : file already exists\");\n if(caml_is_ml_bytes(content))\n file = new MlFakeFile(content);\n if(caml_is_ml_string(content))\n file = new MlFakeFile(caml_bytes_of_string(content));\n else if(content instanceof Array)\n file = new MlFakeFile(caml_bytes_of_array(content));\n else if(typeof content === \"string\")\n file = new MlFakeFile(caml_bytes_of_jsbytes(content));\n else if(content.toString) {\n var bytes = caml_bytes_of_string(caml_string_of_jsstring(content.toString()));\n file = new MlFakeFile(bytes);\n }\n if(file){\n this.create_dir_if_needed(name);\n this.content[name] = file;\n }\n else caml_raise_sys_error(this.nm(name) + \" : registering file with invalid content type\");\n}\n\nMlFakeDevice.prototype.constructor = MlFakeDevice\n\n//Provides: MlFakeFile\n//Requires: MlFile\n//Requires: caml_create_bytes, caml_ml_bytes_length, caml_blit_bytes, caml_blit_string\n//Requires: caml_bytes_get\nfunction MlFakeFile(content){\n this.data = content;\n}\nMlFakeFile.prototype = new MlFile ();\nMlFakeFile.prototype.truncate = function(len){\n var old = this.data;\n this.data = caml_create_bytes(len|0);\n caml_blit_bytes(old, 0, this.data, 0, len);\n}\nMlFakeFile.prototype.length = function () {\n return caml_ml_bytes_length(this.data);\n}\nMlFakeFile.prototype.write = function(offset,buf,pos,len){\n var clen = this.length();\n if(offset + len >= clen) {\n var new_str = caml_create_bytes(offset + len);\n var old_data = this.data;\n this.data = new_str;\n caml_blit_bytes(old_data, 0, this.data, 0, clen);\n }\n caml_blit_string(buf, pos, this.data, offset, len);\n return 0\n}\nMlFakeFile.prototype.read = function(offset,buf,pos,len){\n var clen = this.length();\n caml_blit_bytes(this.data, offset, buf, pos, len);\n return 0\n}\nMlFakeFile.prototype.read_one = function(offset){\n return caml_bytes_get(this.data, offset);\n}\nMlFakeFile.prototype.close = function(){\n\n}\nMlFakeFile.prototype.constructor = MlFakeFile\n","// Js_of_ocaml runtime support\n// http://www.ocsigen.org/js_of_ocaml/\n// Copyright (C) 2014 Jérôme Vouillon, Hugo Heuzard\n// Laboratoire PPS - CNRS Université Paris Diderot\n//\n// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU Lesser General Public License as published by\n// the Free Software Foundation, with linking exception;\n// either version 2.1 of the License, or (at your option) any later version.\n//\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n// GNU Lesser General Public License for more details.\n//\n// You should have received a copy of the GNU Lesser General Public License\n// along with this program; if not, write to the Free Software\n// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n\n///////////// Io\n\n//Provides: caml_sys_close\n//Requires: caml_global_data\nfunction caml_sys_close(fd) {\n delete caml_global_data.fds[fd];\n return 0;\n}\n\n//Provides: caml_std_output\n//Requires: caml_string_of_jsbytes, caml_ml_string_length, caml_ml_channels\nfunction caml_std_output(chanid,s){\n var chan = caml_ml_channels[chanid];\n var str = caml_string_of_jsbytes(s);\n var slen = caml_ml_string_length(str);\n chan.file.write(chan.offset, str, 0, slen);\n chan.offset += slen;\n return 0;\n}\n\n//Provides: caml_sys_open\n//Requires: caml_raise_sys_error, caml_global_data\n//Requires: caml_create_bytes,MlFakeFile\n//Requires: js_print_stderr, js_print_stdout\n//Requires: caml_std_output\n//Requires: resolve_fs_device\n//Requires: caml_jsbytes_of_string\nfunction caml_sys_open_internal(idx,output,file,flags) {\n if(caml_global_data.fds === undefined) caml_global_data.fds = new Array();\n flags=flags?flags:{};\n var info = {};\n info.file = file;\n info.offset = flags.append?file.length():0;\n info.flags = flags;\n info.output = output;\n caml_global_data.fds[idx] = info;\n if(!caml_global_data.fd_last_idx || idx > caml_global_data.fd_last_idx)\n caml_global_data.fd_last_idx = idx;\n return idx;\n}\nfunction caml_sys_open (name, flags, _perms) {\n var f = {};\n while(flags){\n switch(flags[1]){\n case 0: f.rdonly = 1;break;\n case 1: f.wronly = 1;break;\n case 2: f.append = 1;break;\n case 3: f.create = 1;break;\n case 4: f.truncate = 1;break;\n case 5: f.excl = 1; break;\n case 6: f.binary = 1;break;\n case 7: f.text = 1;break;\n case 8: f.nonblock = 1;break;\n }\n flags=flags[2];\n }\n if(f.rdonly && f.wronly)\n caml_raise_sys_error(caml_jsbytes_of_string(name) + \" : flags Open_rdonly and Open_wronly are not compatible\");\n if(f.text && f.binary)\n caml_raise_sys_error(caml_jsbytes_of_string(name) + \" : flags Open_text and Open_binary are not compatible\");\n var root = resolve_fs_device(name);\n var file = root.device.open(root.rest,f);\n var idx = caml_global_data.fd_last_idx?caml_global_data.fd_last_idx:0;\n return caml_sys_open_internal (idx+1,caml_std_output,file,f);\n}\ncaml_sys_open_internal(0,caml_std_output, new MlFakeFile(caml_create_bytes(0))); //stdin\ncaml_sys_open_internal(1,js_print_stdout, new MlFakeFile(caml_create_bytes(0))); //stdout\ncaml_sys_open_internal(2,js_print_stderr, new MlFakeFile(caml_create_bytes(0))); //stderr\n\n\n// ocaml Channels\n\n//Provides: caml_ml_set_channel_name\nfunction caml_ml_set_channel_name() {\n return 0\n}\n\n//Provides: caml_ml_channels\nvar caml_ml_channels = new Array();\n\n//Provides: caml_ml_out_channels_list\n//Requires: caml_ml_channels\nfunction caml_ml_out_channels_list () {\n var l = 0;\n for(var c = 0; c < caml_ml_channels.length; c++){\n if(caml_ml_channels[c] && caml_ml_channels[c].opened && caml_ml_channels[c].out)\n l=[0,caml_ml_channels[c].fd,l];\n }\n return l;\n}\n\n\n//Provides: caml_ml_open_descriptor_out\n//Requires: caml_ml_channels, caml_global_data\n//Requires: caml_raise_sys_error\nfunction caml_ml_open_descriptor_out (fd) {\n var data = caml_global_data.fds[fd];\n if(data.flags.rdonly) caml_raise_sys_error(\"fd \"+ fd + \" is readonly\");\n var channel = {\n file:data.file,\n offset:data.offset,\n fd:fd,\n opened:true,\n out:true,\n buffer:\"\"\n };\n caml_ml_channels[channel.fd]=channel;\n return channel.fd;\n}\n\n//Provides: caml_ml_open_descriptor_in\n//Requires: caml_global_data,caml_sys_open,caml_raise_sys_error, caml_ml_channels\n//Requires: fs_node_supported, caml_string_of_jsstring\nfunction caml_ml_open_descriptor_in (fd) {\n var data = caml_global_data.fds[fd];\n if(data.flags.wronly) caml_raise_sys_error(\"fd \"+ fd + \" is writeonly\");\n var refill = null;\n if(fd == 0 && fs_node_supported()){\n var fs = require('fs');\n refill = function () {\n return caml_string_of_jsstring(fs.readFileSync(0, 'utf8'))};\n }\n var channel = {\n file:data.file,\n offset:data.offset,\n fd:fd,\n opened:true,\n out: false,\n refill:refill\n };\n caml_ml_channels[channel.fd]=channel;\n return channel.fd;\n}\n\n\n//Provides: caml_channel_descriptor\n//Requires: caml_global_data, caml_ml_channels\nfunction caml_channel_descriptor(chanid){\n var chan = caml_ml_channels[chanid];\n return chan.fd;\n}\n\n//Provides: win_filedescr_of_channel\n//Requires: caml_channel_descriptor\nvar win_filedescr_of_channel = caml_channel_descriptor\n\n//Provides: caml_ml_set_binary_mode\n//Requires: caml_global_data, caml_ml_channels\nfunction caml_ml_set_binary_mode(chanid,mode){\n var chan = caml_ml_channels[chanid];\n var data = caml_global_data.fds[chan.fd];\n data.flags.text = !mode\n data.flags.binary = mode\n return 0;\n}\n\n//Input from in_channel\n\n//Provides: caml_ml_close_channel\n//Requires: caml_ml_flush, caml_ml_channels\n//Requires: caml_sys_close\nfunction caml_ml_close_channel (chanid) {\n var chan = caml_ml_channels[chanid];\n caml_ml_flush(chanid);\n chan.opened = false;\n chan.file.close();\n caml_sys_close(chan.fd)\n return 0;\n}\n\n//Provides: caml_ml_channel_size\n//Requires: caml_ml_channels\nfunction caml_ml_channel_size(chanid) {\n var chan = caml_ml_channels[chanid];\n return chan.file.length();\n}\n\n//Provides: caml_ml_channel_size_64\n//Requires: caml_int64_of_float,caml_ml_channels\nfunction caml_ml_channel_size_64(chanid) {\n var chan = caml_ml_channels[chanid];\n return caml_int64_of_float(chan.file.length ());\n}\n\n//Provides: caml_ml_set_channel_output\n//Requires: caml_ml_channels, caml_global_data\nfunction caml_ml_set_channel_output(chanid,f) {\n var chan = caml_ml_channels[chanid];\n caml_global_data.fds[chan.fd].output = f;\n return 0;\n}\n\n//Provides: caml_ml_set_channel_refill\n//Requires: caml_ml_channels, caml_global_data\nfunction caml_ml_set_channel_refill(chanid,f) {\n caml_ml_channels[chanid].refill = f;\n return 0;\n}\n\n//Provides: caml_ml_refill_input\n//Requires: caml_ml_string_length\nfunction caml_ml_refill_input (chan) {\n var str = chan.refill();\n var str_len = caml_ml_string_length(str);\n if (str_len == 0) chan.refill = null;\n chan.file.write(chan.file.length(), str, 0, str_len);\n return str_len;\n}\n\n//Provides: caml_ml_may_refill_input\n//Requires: caml_ml_refill_input, caml_ml_channels\nfunction caml_ml_may_refill_input (chanid) {\n var chan = caml_ml_channels[chanid];\n if (chan.refill == null) return;\n if (chan.file.length() != chan.offset) return;\n caml_ml_refill_input (chan);\n}\n\n//Provides: caml_ml_input\n//Requires: caml_ml_refill_input, caml_ml_channels\nfunction caml_ml_input (chanid, s, i, l) {\n var chan = caml_ml_channels[chanid];\n var l2 = chan.file.length() - chan.offset;\n if (l2 == 0 && chan.refill != null) l2 = caml_ml_refill_input(chan);\n if (l2 < l) l = l2;\n chan.file.read(chan.offset, s, i, l);\n chan.offset += l;\n return l;\n}\n\n//Provides: caml_input_value\n//Requires: caml_marshal_data_size, caml_input_value_from_bytes, caml_create_bytes, caml_ml_channels\nfunction caml_input_value (chanid) {\n var chan = caml_ml_channels[chanid];\n\n var buf = caml_create_bytes(8);\n chan.file.read(chan.offset,buf,0,8);\n\n // Header is 20 bytes\n var len = caml_marshal_data_size (buf, 0) + 20;\n\n var buf = caml_create_bytes(len);\n chan.file.read(chan.offset,buf,0,len);\n\n var offset = [0];\n var res = caml_input_value_from_bytes(buf, offset);\n chan.offset = chan.offset + offset[0];\n return res;\n}\n\n//Provides: caml_ml_input_char\n//Requires: caml_raise_end_of_file, caml_array_bound_error\n//Requires: caml_ml_may_refill_input, caml_ml_channels\nfunction caml_ml_input_char (chanid) {\n var chan = caml_ml_channels[chanid];\n caml_ml_may_refill_input(chanid);\n if (chan.offset >= chan.file.length())\n caml_raise_end_of_file();\n var res = chan.file.read_one(chan.offset);\n chan.offset++;\n return res;\n}\n\n//Provides: caml_ml_input_int\n//Requires: caml_raise_end_of_file\n//Requires: caml_ml_refill_input, caml_ml_channels\nfunction caml_ml_input_int (chanid) {\n var chan = caml_ml_channels[chanid];\n var file = chan.file;\n while ((chan.offset + 3) >= file.length()) {\n var l = caml_ml_refill_input(chan);\n if (l == 0) caml_raise_end_of_file();\n }\n var o = chan.offset;\n var r =(file.read_one(o ) << 24)\n | (file.read_one(o+1) << 16)\n | (file.read_one(o+2) << 8)\n | (file.read_one(o+3));\n chan.offset+=4;\n return r;\n}\n\n//Provides: caml_ml_seek_in\n//Requires: caml_raise_sys_error, caml_ml_channels\nfunction caml_ml_seek_in(chanid,pos){\n var chan = caml_ml_channels[chanid];\n if (chan.refill != null) caml_raise_sys_error(\"Illegal seek\");\n chan.offset = pos;\n return 0;\n}\n\n//Provides: caml_ml_seek_in_64\n//Requires: caml_int64_to_float, caml_raise_sys_error, caml_ml_channels\nfunction caml_ml_seek_in_64(chanid,pos){\n var chan = caml_ml_channels[chanid];\n if (chan.refill != null) caml_raise_sys_error(\"Illegal seek\");\n chan.offset = caml_int64_to_float(pos);\n return 0;\n}\n\n//Provides: caml_ml_pos_in\n//Requires: caml_ml_channels\nfunction caml_ml_pos_in(chanid) {return caml_ml_channels[chanid].offset}\n\n//Provides: caml_ml_pos_in_64\n//Requires: caml_int64_of_float, caml_ml_channels\nfunction caml_ml_pos_in_64(chanid) {return caml_int64_of_float(caml_ml_channels[chanid].offset)}\n\n//Provides: caml_ml_input_scan_line\n//Requires: caml_array_bound_error\n//Requires: caml_ml_may_refill_input, caml_ml_channels\nfunction caml_ml_input_scan_line(chanid){\n var chan = caml_ml_channels[chanid];\n caml_ml_may_refill_input(chanid);\n var p = chan.offset;\n var len = chan.file.length();\n if(p >= len) { return 0;}\n while(true) {\n if(p >= len) return - (p - chan.offset);\n if(chan.file.read_one(p) == 10) return p - chan.offset + 1;\n p++;\n }\n}\n\n//Provides: caml_ml_flush\n//Requires: caml_raise_sys_error, caml_global_data, caml_ml_channels\nfunction caml_ml_flush (chanid) {\n var chan = caml_ml_channels[chanid];\n if(! chan.opened) caml_raise_sys_error(\"Cannot flush a closed channel\");\n if(!chan.buffer || chan.buffer == \"\") return 0;\n if(chan.fd\n && caml_global_data.fds[chan.fd]\n && caml_global_data.fds[chan.fd].output) {\n var output = caml_global_data.fds[chan.fd].output;\n switch(output.length){\n case 2: output(chanid,chan.buffer);break;\n default: output(chan.buffer)\n };\n }\n chan.buffer = \"\";\n return 0;\n}\n\n//output to out_channel\n\n//Provides: caml_ml_output_bytes\n//Requires: caml_ml_flush,caml_ml_bytes_length\n//Requires: caml_create_bytes, caml_blit_bytes, caml_raise_sys_error, caml_ml_channels, caml_string_of_bytes\n//Requires: caml_jsbytes_of_string\nfunction caml_ml_output_bytes(chanid,buffer,offset,len) {\n var chan = caml_ml_channels[chanid];\n if(! chan.opened) caml_raise_sys_error(\"Cannot output to a closed channel\");\n var bytes;\n if(offset == 0 && caml_ml_bytes_length(buffer) == len)\n bytes = buffer;\n else {\n bytes = caml_create_bytes(len);\n caml_blit_bytes(buffer,offset,bytes,0,len);\n }\n var string = caml_string_of_bytes(bytes);\n var jsstring = caml_jsbytes_of_string(string);\n var id = jsstring.lastIndexOf(\"\\n\");\n if(id < 0)\n chan.buffer+=jsstring;\n else {\n chan.buffer+=jsstring.substr(0,id+1);\n caml_ml_flush (chanid);\n chan.buffer += jsstring.substr(id+1);\n }\n return 0;\n}\n\n//Provides: caml_ml_output\n//Requires: caml_ml_output_bytes, caml_bytes_of_string\nfunction caml_ml_output(chanid,buffer,offset,len){\n return caml_ml_output_bytes(chanid,caml_bytes_of_string(buffer),offset,len);\n}\n\n//Provides: caml_ml_output_char\n//Requires: caml_ml_output\n//Requires: caml_string_of_jsbytes\nfunction caml_ml_output_char (chanid,c) {\n var s = caml_string_of_jsbytes(String.fromCharCode(c));\n caml_ml_output(chanid,s,0,1);\n return 0;\n}\n\n//Provides: caml_output_value\n//Requires: caml_output_value_to_string, caml_ml_output,caml_ml_string_length\nfunction caml_output_value (chanid,v,flags) {\n var s = caml_output_value_to_string(v, flags);\n caml_ml_output(chanid,s,0,caml_ml_string_length(s));\n return 0;\n}\n\n\n//Provides: caml_ml_seek_out\n//Requires: caml_ml_channels, caml_ml_flush\nfunction caml_ml_seek_out(chanid,pos){\n caml_ml_flush(chanid);\n caml_ml_channels[chanid].offset = pos;\n return 0;\n}\n\n//Provides: caml_ml_seek_out_64\n//Requires: caml_int64_to_float, caml_ml_channels, caml_ml_flush\nfunction caml_ml_seek_out_64(chanid,pos){\n caml_ml_flush(chanid);\n caml_ml_channels[chanid].offset = caml_int64_to_float(pos);\n return 0;\n}\n\n//Provides: caml_ml_pos_out\n//Requires: caml_ml_channels, caml_ml_flush\nfunction caml_ml_pos_out(chanid) {\n caml_ml_flush(chanid);\n return caml_ml_channels[chanid].offset\n}\n\n//Provides: caml_ml_pos_out_64\n//Requires: caml_int64_of_float, caml_ml_channels, caml_ml_flush\nfunction caml_ml_pos_out_64(chanid) {\n caml_ml_flush(chanid);\n return caml_int64_of_float (caml_ml_channels[chanid].offset);\n}\n\n//Provides: caml_ml_output_int\n//Requires: caml_ml_output\n//Requires: caml_string_of_array\nfunction caml_ml_output_int (chanid,i) {\n var arr = [(i>>24) & 0xFF,(i>>16) & 0xFF,(i>>8) & 0xFF,i & 0xFF ];\n var s = caml_string_of_array(arr);\n caml_ml_output(chanid,s,0,4);\n return 0\n}\n\n//Provides: caml_ml_is_buffered\nfunction caml_ml_is_buffered(c) { return 1 }\n\n//Provides: caml_ml_set_buffered\nfunction caml_ml_set_buffered(c,v) { return 0 }\n","/***********************************************************************/\n/* */\n/* Objective Caml */\n/* */\n/* Xavier Leroy, projet Cristal, INRIA Rocquencourt */\n/* */\n/* Copyright 1996 Institut National de Recherche en Informatique et */\n/* en Automatique. All rights reserved. This file is distributed */\n/* under the terms of the GNU Lesser General Public License, with */\n/* the special exception on linking described in file ../LICENSE. */\n/* */\n/***********************************************************************/\n\n/* $Id: lexing.c 6045 2004-01-01 16:42:43Z doligez $ */\n\n/* The table-driven automaton for lexers generated by camllex. */\n\n//Provides: caml_lex_array\n//Requires: caml_jsbytes_of_string\nfunction caml_lex_array(s) {\n s = caml_jsbytes_of_string(s);\n var l = s.length / 2;\n var a = new Array(l);\n for (var i = 0; i < l; i++)\n a[i] = (s.charCodeAt(2 * i) | (s.charCodeAt(2 * i + 1) << 8)) << 16 >> 16;\n return a;\n}\n\n//Provides: caml_lex_engine\n//Requires: caml_failwith, caml_lex_array, caml_array_of_bytes\nfunction caml_lex_engine(tbl, start_state, lexbuf) {\n var lex_buffer = 2;\n var lex_buffer_len = 3;\n var lex_start_pos = 5;\n var lex_curr_pos = 6;\n var lex_last_pos = 7;\n var lex_last_action = 8;\n var lex_eof_reached = 9;\n var lex_base = 1;\n var lex_backtrk = 2;\n var lex_default = 3;\n var lex_trans = 4;\n var lex_check = 5;\n\n if (!tbl.lex_default) {\n tbl.lex_base = caml_lex_array (tbl[lex_base]);\n tbl.lex_backtrk = caml_lex_array (tbl[lex_backtrk]);\n tbl.lex_check = caml_lex_array (tbl[lex_check]);\n tbl.lex_trans = caml_lex_array (tbl[lex_trans]);\n tbl.lex_default = caml_lex_array (tbl[lex_default]);\n }\n\n var c, state = start_state;\n\n var buffer = caml_array_of_bytes(lexbuf[lex_buffer]);\n\n if (state >= 0) {\n /* First entry */\n lexbuf[lex_last_pos] = lexbuf[lex_start_pos] = lexbuf[lex_curr_pos];\n lexbuf[lex_last_action] = -1;\n } else {\n /* Reentry after refill */\n state = -state - 1;\n }\n for(;;) {\n /* Lookup base address or action number for current state */\n var base = tbl.lex_base[state];\n if (base < 0) return -base-1;\n /* See if it's a backtrack point */\n var backtrk = tbl.lex_backtrk[state];\n if (backtrk >= 0) {\n lexbuf[lex_last_pos] = lexbuf[lex_curr_pos];\n lexbuf[lex_last_action] = backtrk;\n }\n /* See if we need a refill */\n if (lexbuf[lex_curr_pos] >= lexbuf[lex_buffer_len]){\n if (lexbuf[lex_eof_reached] == 0)\n return -state - 1;\n else\n c = 256;\n }else{\n /* Read next input char */\n c = buffer[lexbuf[lex_curr_pos]];\n lexbuf[lex_curr_pos] ++;\n }\n /* Determine next state */\n if (tbl.lex_check[base + c] == state)\n state = tbl.lex_trans[base + c];\n else\n state = tbl.lex_default[state];\n /* If no transition on this char, return to last backtrack point */\n if (state < 0) {\n lexbuf[lex_curr_pos] = lexbuf[lex_last_pos];\n if (lexbuf[lex_last_action] == -1)\n caml_failwith(\"lexing: empty token\");\n else\n return lexbuf[lex_last_action];\n }else{\n /* Erase the EOF condition only if the EOF pseudo-character was\n consumed by the automaton (i.e. there was no backtrack above)\n */\n if (c == 256) lexbuf[lex_eof_reached] = 0;\n }\n }\n}\n\n/***********************************************/\n/* New lexer engine, with memory of positions */\n/***********************************************/\n\n//Provides: caml_new_lex_engine\n//Requires: caml_failwith, caml_lex_array\n//Requires: caml_jsbytes_of_string, caml_array_of_bytes\nfunction caml_lex_run_mem(s, i, mem, curr_pos) {\n for (;;) {\n var dst = s.charCodeAt(i); i++;\n if (dst == 0xff) return;\n var src = s.charCodeAt(i); i++;\n if (src == 0xff)\n mem [dst + 1] = curr_pos;\n else\n mem [dst + 1] = mem [src + 1];\n }\n}\n\nfunction caml_lex_run_tag(s, i, mem) {\n for (;;) {\n var dst = s.charCodeAt(i); i++;\n if (dst == 0xff) return ;\n var src = s.charCodeAt(i); i++;\n if (src == 0xff)\n mem [dst + 1] = -1;\n else\n mem [dst + 1] = mem [src + 1];\n }\n}\n\nfunction caml_new_lex_engine(tbl, start_state, lexbuf) {\n var lex_buffer = 2;\n var lex_buffer_len = 3;\n var lex_start_pos = 5;\n var lex_curr_pos = 6;\n var lex_last_pos = 7;\n var lex_last_action = 8;\n var lex_eof_reached = 9;\n var lex_mem = 10;\n var lex_base = 1;\n var lex_backtrk = 2;\n var lex_default = 3;\n var lex_trans = 4;\n var lex_check = 5;\n var lex_base_code = 6;\n var lex_backtrk_code = 7;\n var lex_default_code = 8;\n var lex_trans_code = 9;\n var lex_check_code = 10;\n var lex_code = 11;\n\n if (!tbl.lex_default) {\n tbl.lex_base = caml_lex_array (tbl[lex_base]);\n tbl.lex_backtrk = caml_lex_array (tbl[lex_backtrk]);\n tbl.lex_check = caml_lex_array (tbl[lex_check]);\n tbl.lex_trans = caml_lex_array (tbl[lex_trans]);\n tbl.lex_default = caml_lex_array (tbl[lex_default]);\n }\n if (!tbl.lex_default_code) {\n tbl.lex_base_code = caml_lex_array (tbl[lex_base_code]);\n tbl.lex_backtrk_code = caml_lex_array (tbl[lex_backtrk_code]);\n tbl.lex_check_code = caml_lex_array (tbl[lex_check_code]);\n tbl.lex_trans_code = caml_lex_array (tbl[lex_trans_code]);\n tbl.lex_default_code = caml_lex_array (tbl[lex_default_code]);\n }\n if (tbl.lex_code == null) tbl.lex_code = caml_jsbytes_of_string(tbl[lex_code]);\n\n var c, state = start_state;\n\n var buffer = caml_array_of_bytes(lexbuf[lex_buffer]);\n\n if (state >= 0) {\n /* First entry */\n lexbuf[lex_last_pos] = lexbuf[lex_start_pos] = lexbuf[lex_curr_pos];\n lexbuf[lex_last_action] = -1;\n } else {\n /* Reentry after refill */\n state = -state - 1;\n }\n for(;;) {\n /* Lookup base address or action number for current state */\n var base = tbl.lex_base[state];\n if (base < 0) {\n var pc_off = tbl.lex_base_code[state];\n caml_lex_run_tag(tbl.lex_code, pc_off, lexbuf[lex_mem]);\n return -base-1;\n }\n /* See if it's a backtrack point */\n var backtrk = tbl.lex_backtrk[state];\n if (backtrk >= 0) {\n var pc_off = tbl.lex_backtrk_code[state];\n caml_lex_run_tag(tbl.lex_code, pc_off, lexbuf[lex_mem]);\n lexbuf[lex_last_pos] = lexbuf[lex_curr_pos];\n lexbuf[lex_last_action] = backtrk;\n }\n /* See if we need a refill */\n if (lexbuf[lex_curr_pos] >= lexbuf[lex_buffer_len]){\n if (lexbuf[lex_eof_reached] == 0)\n return -state - 1;\n else\n c = 256;\n }else{\n /* Read next input char */\n c = buffer[lexbuf[lex_curr_pos]];\n lexbuf[lex_curr_pos] ++;\n }\n /* Determine next state */\n var pstate = state ;\n if (tbl.lex_check[base + c] == state)\n state = tbl.lex_trans[base + c];\n else\n state = tbl.lex_default[state];\n /* If no transition on this char, return to last backtrack point */\n if (state < 0) {\n lexbuf[lex_curr_pos] = lexbuf[lex_last_pos];\n if (lexbuf[lex_last_action] == -1)\n caml_failwith(\"lexing: empty token\");\n else\n return lexbuf[lex_last_action];\n }else{\n /* If some transition, get and perform memory moves */\n var base_code = tbl.lex_base_code[pstate], pc_off;\n if (tbl.lex_check_code[base_code + c] == pstate)\n pc_off = tbl.lex_trans_code[base_code + c];\n else\n pc_off = tbl.lex_default_code[pstate];\n if (pc_off > 0)\n caml_lex_run_mem\n (tbl.lex_code, pc_off, lexbuf[lex_mem], lexbuf[lex_curr_pos]);\n /* Erase the EOF condition only if the EOF pseudo-character was\n consumed by the automaton (i.e. there was no backtrack above)\n */\n if (c == 256) lexbuf[lex_eof_reached] = 0;\n }\n }\n}\n","// Js_of_ocaml runtime support\n// http://www.ocsigen.org/js_of_ocaml/\n// Copyright (C) 2010 Jérôme Vouillon\n// Laboratoire PPS - CNRS Université Paris Diderot\n//\n// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU Lesser General Public License as published by\n// the Free Software Foundation, with linking exception;\n// either version 2.1 of the License, or (at your option) any later version.\n//\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n// GNU Lesser General Public License for more details.\n//\n// You should have received a copy of the GNU Lesser General Public License\n// along with this program; if not, write to the Free Software\n// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n\n\n//Provides: caml_md5_chan\n//Requires: caml_md5_string, caml_string_of_array,caml_ml_channels\n//Requires: caml_raise_end_of_file, caml_create_bytes, caml_string_of_bytes\nfunction caml_md5_chan(chanid,len){\n var chan = caml_ml_channels[chanid];\n var chan_len = chan.file.length();\n if(len<0) len = chan_len - chan.offset;\n if(chan.offset + len > chan_len) caml_raise_end_of_file();\n var buf = caml_create_bytes(len);\n chan.file.read(chan.offset,buf,0,len);\n return caml_md5_string(caml_string_of_bytes(buf),0,len);\n}\n\n//Provides: caml_md5_string\n//Requires: caml_bytes_of_string, caml_md5_bytes\nfunction caml_md5_string(s, ofs, len) {\n return caml_md5_bytes(caml_bytes_of_string(s),ofs,len);\n}\n\n//Provides: caml_md5_bytes\n//Requires: caml_string_of_array, caml_ml_bytes_content\nvar caml_md5_bytes = function () {\n function add (x, y) { return (x + y) | 0; }\n function xx(q,a,b,x,s,t) {\n a = add(add(a, q), add(x, t));\n return add((a << s) | (a >>> (32 - s)), b);\n }\n function ff(a,b,c,d,x,s,t) {\n return xx((b & c) | ((~b) & d), a, b, x, s, t);\n }\n function gg(a,b,c,d,x,s,t) {\n return xx((b & d) | (c & (~d)), a, b, x, s, t);\n }\n function hh(a,b,c,d,x,s,t) { return xx(b ^ c ^ d, a, b, x, s, t); }\n function ii(a,b,c,d,x,s,t) { return xx(c ^ (b | (~d)), a, b, x, s, t); }\n\n function md5(buffer, length) {\n var i = length;\n buffer[i >> 2] |= 0x80 << (8 * (i & 3));\n for (i = (i & ~0x3) + 8;(i & 0x3F) < 60 ;i += 4)\n buffer[(i >> 2) - 1] = 0;\n buffer[(i >> 2) -1] = length << 3;\n buffer[i >> 2] = (length >> 29) & 0x1FFFFFFF;\n\n var w = [0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476];\n\n for(i = 0; i < buffer.length; i += 16) {\n var a = w[0], b = w[1], c = w[2], d = w[3];\n\n a = ff(a, b, c, d, buffer[i+ 0], 7, 0xD76AA478);\n d = ff(d, a, b, c, buffer[i+ 1], 12, 0xE8C7B756);\n c = ff(c, d, a, b, buffer[i+ 2], 17, 0x242070DB);\n b = ff(b, c, d, a, buffer[i+ 3], 22, 0xC1BDCEEE);\n a = ff(a, b, c, d, buffer[i+ 4], 7, 0xF57C0FAF);\n d = ff(d, a, b, c, buffer[i+ 5], 12, 0x4787C62A);\n c = ff(c, d, a, b, buffer[i+ 6], 17, 0xA8304613);\n b = ff(b, c, d, a, buffer[i+ 7], 22, 0xFD469501);\n a = ff(a, b, c, d, buffer[i+ 8], 7, 0x698098D8);\n d = ff(d, a, b, c, buffer[i+ 9], 12, 0x8B44F7AF);\n c = ff(c, d, a, b, buffer[i+10], 17, 0xFFFF5BB1);\n b = ff(b, c, d, a, buffer[i+11], 22, 0x895CD7BE);\n a = ff(a, b, c, d, buffer[i+12], 7, 0x6B901122);\n d = ff(d, a, b, c, buffer[i+13], 12, 0xFD987193);\n c = ff(c, d, a, b, buffer[i+14], 17, 0xA679438E);\n b = ff(b, c, d, a, buffer[i+15], 22, 0x49B40821);\n\n a = gg(a, b, c, d, buffer[i+ 1], 5, 0xF61E2562);\n d = gg(d, a, b, c, buffer[i+ 6], 9, 0xC040B340);\n c = gg(c, d, a, b, buffer[i+11], 14, 0x265E5A51);\n b = gg(b, c, d, a, buffer[i+ 0], 20, 0xE9B6C7AA);\n a = gg(a, b, c, d, buffer[i+ 5], 5, 0xD62F105D);\n d = gg(d, a, b, c, buffer[i+10], 9, 0x02441453);\n c = gg(c, d, a, b, buffer[i+15], 14, 0xD8A1E681);\n b = gg(b, c, d, a, buffer[i+ 4], 20, 0xE7D3FBC8);\n a = gg(a, b, c, d, buffer[i+ 9], 5, 0x21E1CDE6);\n d = gg(d, a, b, c, buffer[i+14], 9, 0xC33707D6);\n c = gg(c, d, a, b, buffer[i+ 3], 14, 0xF4D50D87);\n b = gg(b, c, d, a, buffer[i+ 8], 20, 0x455A14ED);\n a = gg(a, b, c, d, buffer[i+13], 5, 0xA9E3E905);\n d = gg(d, a, b, c, buffer[i+ 2], 9, 0xFCEFA3F8);\n c = gg(c, d, a, b, buffer[i+ 7], 14, 0x676F02D9);\n b = gg(b, c, d, a, buffer[i+12], 20, 0x8D2A4C8A);\n\n a = hh(a, b, c, d, buffer[i+ 5], 4, 0xFFFA3942);\n d = hh(d, a, b, c, buffer[i+ 8], 11, 0x8771F681);\n c = hh(c, d, a, b, buffer[i+11], 16, 0x6D9D6122);\n b = hh(b, c, d, a, buffer[i+14], 23, 0xFDE5380C);\n a = hh(a, b, c, d, buffer[i+ 1], 4, 0xA4BEEA44);\n d = hh(d, a, b, c, buffer[i+ 4], 11, 0x4BDECFA9);\n c = hh(c, d, a, b, buffer[i+ 7], 16, 0xF6BB4B60);\n b = hh(b, c, d, a, buffer[i+10], 23, 0xBEBFBC70);\n a = hh(a, b, c, d, buffer[i+13], 4, 0x289B7EC6);\n d = hh(d, a, b, c, buffer[i+ 0], 11, 0xEAA127FA);\n c = hh(c, d, a, b, buffer[i+ 3], 16, 0xD4EF3085);\n b = hh(b, c, d, a, buffer[i+ 6], 23, 0x04881D05);\n a = hh(a, b, c, d, buffer[i+ 9], 4, 0xD9D4D039);\n d = hh(d, a, b, c, buffer[i+12], 11, 0xE6DB99E5);\n c = hh(c, d, a, b, buffer[i+15], 16, 0x1FA27CF8);\n b = hh(b, c, d, a, buffer[i+ 2], 23, 0xC4AC5665);\n\n a = ii(a, b, c, d, buffer[i+ 0], 6, 0xF4292244);\n d = ii(d, a, b, c, buffer[i+ 7], 10, 0x432AFF97);\n c = ii(c, d, a, b, buffer[i+14], 15, 0xAB9423A7);\n b = ii(b, c, d, a, buffer[i+ 5], 21, 0xFC93A039);\n a = ii(a, b, c, d, buffer[i+12], 6, 0x655B59C3);\n d = ii(d, a, b, c, buffer[i+ 3], 10, 0x8F0CCC92);\n c = ii(c, d, a, b, buffer[i+10], 15, 0xFFEFF47D);\n b = ii(b, c, d, a, buffer[i+ 1], 21, 0x85845DD1);\n a = ii(a, b, c, d, buffer[i+ 8], 6, 0x6FA87E4F);\n d = ii(d, a, b, c, buffer[i+15], 10, 0xFE2CE6E0);\n c = ii(c, d, a, b, buffer[i+ 6], 15, 0xA3014314);\n b = ii(b, c, d, a, buffer[i+13], 21, 0x4E0811A1);\n a = ii(a, b, c, d, buffer[i+ 4], 6, 0xF7537E82);\n d = ii(d, a, b, c, buffer[i+11], 10, 0xBD3AF235);\n c = ii(c, d, a, b, buffer[i+ 2], 15, 0x2AD7D2BB);\n b = ii(b, c, d, a, buffer[i+ 9], 21, 0xEB86D391);\n\n w[0] = add(a, w[0]);\n w[1] = add(b, w[1]);\n w[2] = add(c, w[2]);\n w[3] = add(d, w[3]);\n }\n\n var t = new Array(16);\n for (var i = 0; i < 4; i++)\n for (var j = 0; j < 4; j++)\n t[i * 4 + j] = (w[i] >> (8 * j)) & 0xFF;\n return t;\n }\n\n return function (s, ofs, len) {\n // FIX: maybe we should perform the computation by chunk of 64 bytes\n // as in http://www.myersdaily.org/joseph/javascript/md5.js\n var buf = [];\n var content = caml_ml_bytes_content(s);\n if(typeof content === \"string\"){\n var b = content;\n for (var i = 0; i < len; i+=4) {\n var j = i + ofs;\n buf[i>>2] =\n b.charCodeAt(j) | (b.charCodeAt(j+1) << 8) |\n (b.charCodeAt(j+2) << 16) | (b.charCodeAt(j+3) << 24);\n }\n for (; i < len; i++) buf[i>>2] |= b.charCodeAt(i + ofs) << (8 * (i & 3));\n } else { /* ARRAY */\n var a = content;\n for (var i = 0; i < len; i+=4) {\n var j = i + ofs;\n buf[i>>2] = a[j] | (a[j+1] << 8) | (a[j+2] << 16) | (a[j+3] << 24);\n }\n for (; i < len; i++) buf[i>>2] |= a[i + ofs] << (8 * (i & 3));\n }\n return caml_string_of_array(md5(buf, len));\n }\n} ();\n","//Provides: expect_test_collector_saved_stdout\nvar expect_test_collector_saved_stdout \n//Provides: expect_test_collector_saved_stderr\nvar expect_test_collector_saved_stderr\n\n//Provides: expect_test_collector_before_test\n//Requires: caml_global_data, caml_ml_channels\n//Requires: expect_test_collector_saved_stderr, expect_test_collector_saved_stdout\nfunction expect_test_collector_before_test (voutput, vstdout, vstderr){\n expect_test_collector_saved_stderr = caml_ml_channels[vstderr];\n expect_test_collector_saved_stdout = caml_ml_channels[vstdout];\n var output = caml_ml_channels[voutput];\n caml_ml_channels[vstdout] = output;\n caml_ml_channels[vstderr] = output;\n return 0;\n}\n\n//Provides: expect_test_collector_after_test\n//Requires: caml_global_data, caml_ml_channels\n//Requires: expect_test_collector_saved_stderr, expect_test_collector_saved_stdout\nfunction expect_test_collector_after_test (vstdout, vstderr){\n caml_ml_channels[vstdout] = expect_test_collector_saved_stdout;\n caml_ml_channels[vstderr] = expect_test_collector_saved_stderr;\n return 0;\n}\n\n//Provides:caml_out_channel_pos_fd\n//Requires: caml_global_data, caml_ml_channels\nfunction caml_out_channel_pos_fd(chan){\n var info = caml_ml_channels[chan];\n return info.offset\n}\n","///////// CORE_KERNEL\n\n//Provides: core_array_unsafe_int_blit\n//Requires: caml_array_blit\nvar core_array_unsafe_int_blit = caml_array_blit\n//Provides: core_array_unsafe_float_blit\n//Requires: caml_array_blit\nvar core_array_unsafe_float_blit = caml_array_blit\n\n//Provides: core_kernel_time_ns_format\n//Requires: caml_jsbytes_of_string, caml_string_of_jsbytes\nfunction core_kernel_time_ns_format(time,format){\n var d = new Date(time * 1000);\n var formatjs = caml_jsbytes_of_string(format);\n var jstring = joo_global_object.strftime(formatjs, d);\n return caml_string_of_jsbytes(jstring);\n}\n\n//Provides: core_kernel_gc_compactions\nfunction core_kernel_gc_compactions () { return 0 }\n//Provides: core_kernel_gc_heap_chunks\nfunction core_kernel_gc_heap_chunks () { return 0 }\n//Provides: core_kernel_gc_heap_words\nfunction core_kernel_gc_heap_words () { return 0 }\n//Provides: core_kernel_gc_major_collections\nfunction core_kernel_gc_major_collections () { return 0 }\n//Provides: core_kernel_gc_major_plus_minor_words\nfunction core_kernel_gc_major_plus_minor_words () { return 0 }\n//Provides: core_kernel_gc_major_words\nfunction core_kernel_gc_major_words () { return 0 }\n//Provides: core_kernel_gc_minor_collections\nfunction core_kernel_gc_minor_collections () { return 0 }\n//Provides: core_kernel_gc_minor_words\nfunction core_kernel_gc_minor_words () { return 0 }\n//Provides: core_kernel_gc_promoted_words\nfunction core_kernel_gc_promoted_words () { return 0 }\n//Provides: core_kernel_gc_top_heap_words\nfunction core_kernel_gc_top_heap_words () { return 0 }\n\n//Provides: Core_kernel_heap_block_is_heap_block\nfunction Core_kernel_heap_block_is_heap_block(x){\n return +(x instanceof Array);\n}\n\n//Provides: core_md5_fd\n//Requires: caml_ml_open_descriptor_in, caml_md5_chan, caml_ml_close_channel\nfunction core_md5_fd(fd){\n var ic = caml_ml_open_descriptor_in(fd);\n try {\n return caml_md5_chan(ic, -1);\n } finally {\n caml_ml_close_channel(ic);\n }\n}\n\n//Provides: core_md5_digest_subbigstring\n//Requires: caml_md5_string, caml_blit_string, caml_create_bytes\n//Requires: bigstring_blit_bigstring_bytes_stub, caml_string_of_bytes\nfunction core_md5_digest_subbigstring(buf, ofs, len, res){\n var bytes = caml_create_bytes(len);\n bigstring_blit_bigstring_bytes_stub(buf, ofs, bytes, 0, len);\n var res2 = caml_md5_string(caml_string_of_bytes(bytes), 0, len);\n caml_blit_string(res2, 0, res, 0, 16);\n return 0;\n}\n\n//Bigstring\n\n//Provides: bigstring_destroy_stub\n//Requires: caml_invalid_argument\nfunction bigstring_destroy_stub(v_bstr) {\n if (v_bstr.hasOwnProperty('__is_deallocated')) {\n caml_invalid_argument(\"bigstring_destroy: bigstring is already deallocated\");\n }\n // Mutate the original bigstring in-place, to simulate what the C version does\n v_bstr.__is_deallocated = true;\n v_bstr.data = new v_bstr.data.__proto__.constructor(0);\n v_bstr.dims = [ 0 ];\n return 0;\n}\n\n//Provides: bigstring_realloc\n//Requires: caml_invalid_argument, caml_ba_create_unsafe, bigstring_destroy_stub\nfunction bigstring_realloc(bigstring, size) {\n if (bigstring.hasOwnProperty('__is_deallocated')) {\n caml_invalid_argument(\"bigstring_realloc: bigstring is already deallocated\");\n }\n\n var new_data = new bigstring.data.__proto__.constructor(size);\n new_data.set(bigstring.data.slice(0, size));\n var new_bigstring = caml_ba_create_unsafe(bigstring.kind, bigstring.layout, [size], new_data);\n bigstring_destroy_stub(bigstring);\n\n return new_bigstring;\n}\n","// Provides: deferred_run\nfunction deferred_run(func) {\n var deferred = {\n promise: Promise.resolve()\n .then(func) // the ocaml types don't know this, but func can actually be async or sync\n .then(function (value) {\n deferred.value = value;\n deferred.isDetermined = true;\n return value;\n })\n .catch(function (err) {\n deferred.error = err;\n deferred.isError = true;\n deferred.isDetermined = true;\n throw err;\n }),\n isError: false,\n isDetermined: false,\n };\n return deferred;\n}\n\n// Provides: deferred_map\nfunction deferred_map(deferred, func) {\n var newDeferred = {\n promise: deferred.promise\n .then(func) // the ocaml types don't know this, but func can actually be async or sync\n .then(function (value) {\n newDeferred.value = value;\n newDeferred.isDetermined = true;\n return value;\n })\n .catch(function (err) {\n newDeferred.error = err;\n newDeferred.isError = true;\n newDeferred.isDetermined = true;\n throw err;\n }),\n isError: false,\n isDetermined: false,\n };\n return newDeferred;\n}\n\n// Provides: deferred_bind\nfunction deferred_bind(deferred, func) {\n var newDeferred = {\n promise: deferred.promise\n .then(func)\n .then(function (anotherDeferred) {\n return anotherDeferred.promise;\n })\n .then(function (value) {\n newDeferred.value = value;\n newDeferred.isDetermined = true;\n return value;\n })\n .catch(function (err) {\n newDeferred.error = err;\n newDeferred.isError = true;\n newDeferred.isDetermined = true;\n throw err;\n }),\n isError: false,\n isDetermined: false,\n };\n return newDeferred;\n}\n\n// Provides: deferred_upon\nfunction deferred_upon(deferred, func) {\n deferred.promise\n .then(function () {\n func(deferred.value);\n })\n .catch(function () {});\n}\n\n// Provides: deferred_upon_exn\nfunction deferred_upon_exn(deferred, func) {\n deferred.promise.then(function () {\n func(deferred.value);\n });\n}\n\n// Provides: deferred_is_determined\nfunction deferred_is_determined(deferred) {\n return deferred.isDetermined;\n}\n\n// Provides: deferred_peek\nfunction deferred_peek(deferred) {\n if (!deferred.isDetermined || deferred.isError) {\n return 0;\n }\n return [0, deferred.value];\n}\n\n// Provides: deferred_value_exn\nfunction deferred_value_exn(deferred) {\n if (!deferred.isDetermined) {\n throw Error(\"Deferred has not returned yet.\");\n }\n if (deferred.isError) {\n throw deferred.error;\n }\n return deferred.value;\n}\n\n// Provides: deferred_return\nfunction deferred_return(value) {\n return {\n promise: Promise.resolve(value),\n value: value,\n isError: false,\n isDetermined: true,\n };\n}\n\n// Provides: deferred_create\nfunction deferred_create(promise_creator) {\n var deferred = {\n promise: new Promise(function (resolve) {\n promise_creator(resolve);\n })\n .then(function (value) {\n deferred.value = value;\n deferred.isDetermined = true;\n })\n .catch(function (err) {\n deferred.error = err;\n deferred.isError = true;\n deferred.isDetermined = true;\n throw err;\n }),\n isError: false,\n isDetermined: false,\n };\n return deferred;\n}\n\n// Provides: deferred_to_promise\nfunction deferred_to_promise(deferred) {\n return deferred.promise;\n}\n\n// Provides: deferred_of_promise\nfunction deferred_of_promise(promise) {\n var deferred = {\n promise: promise\n .then(function (value) {\n deferred.value = value;\n deferred.isDetermined = true;\n return value;\n })\n .catch(function (err) {\n deferred.error = err;\n deferred.isError = true;\n deferred.isDetermined = true;\n throw err;\n }),\n isError: false,\n isDetermined: false,\n };\n return deferred;\n}\n","// This code supports both Array and MlInt64 implementations of int64 in\n// js_of_ocaml (pre- vs post-887507db1eb8efd779070cbedab3774098a52939).\n//\n// Compilation is currently broken on the MlInt64 implementation, due to\n// removed internal js_of_ocaml primitives. Removing these (and the Array\n// implementations, signalled by [instanceof Array] checks) will cause\n// compilation to succeed.\n//\n// TODO: build-time magic to stub the unavailable primitives on later versions.\n\n//Provides: UInt32 const\nvar UInt32 = (function() {\n var UInt32 = function(x) {\n this.value = x >>> 0;\n };\n UInt32.prototype.caml_custom = \"integers:uint32\";\n return UInt32;\n})();\n\n//Provides: integers_int32_of_uint32\nfunction integers_int32_of_uint32(i) {\n return (i.value | 0);\n}\n\n//Provides: integers_size_t_size\nfunction integers_size_t_size(unit) {\n return 4; // Set size_t = u32\n}\n\n//Provides: integers_uint16_of_string\n//Requires: integers_uint32_of_string\nfunction integers_uint16_of_string(x) {\n var y = integers_uint32_of_string(x);\n return (y.value & 0xFFFF);\n}\n\n//Provides: integers_uint32_add\n//Requires: UInt32\nfunction integers_uint32_add(x, y) {\n return new UInt32(x.value + y.value);\n}\n\n//Provides: integers_uint32_sub\n//Requires: UInt32\nfunction integers_uint32_sub(x, y) {\n return new UInt32(x.value - y.value);\n}\n\n//Provides: integers_uint32_div\n//Requires: UInt32\nfunction integers_uint32_div(x, y) {\n return new UInt32(x.value / y.value);\n}\n\n//Provides: integers_uint32_logand\n//Requires: UInt32\nfunction integers_uint32_logand(x, y) {\n return new UInt32(x.value & y.value);\n}\n\n//Provides: integers_uint32_logor\n//Requires: UInt32\nfunction integers_uint32_logor(x, y) {\n return new UInt32(x.value | y.value);\n}\n\n//Provides: integers_uint32_logxor\n//Requires: UInt32\nfunction integers_uint32_logxor(x, y) {\n return new UInt32(x.value ^ y.value);\n}\n\n//Provides: integers_uint32_max\n//Requires: UInt32\nfunction integers_uint32_max(unit) {\n return new UInt32(0xFFFFFFFF);\n}\n\n//Provides: integers_uint32_mul\n//Requires: integers_uint32_to_int64, caml_int64_mul, caml_int64_to_int32, UInt32\nfunction integers_uint32_mul(x, y) {\n // Convert to 64-bit and compute there.\n var x_64 = integers_uint32_to_int64(x);\n var y_64 = integers_uint32_to_int64(y);\n return new UInt32 (caml_int64_to_int32(caml_int64_mul(x_64, y_64)));\n}\n\n//Provides: integers_uint32_of_int\n//Requires: UInt32\nfunction integers_uint32_of_int(i) {\n return new UInt32(i);\n}\n\n//Provides: integers_uint32_of_int32\n//Requires: UInt32\nfunction integers_uint32_of_int32(i) {\n return new UInt32(i);\n}\n\n//Provides: integers_uint32_of_int64\n//Requires: caml_int64_to_int32, UInt32\nfunction integers_uint32_of_int64(i) {\n return new UInt32(caml_int64_to_int32(i));\n}\n\n//Provides: integers_uint32_of_string\n//Requires: integers_uint_of_string, integers_uint32_of_int64, caml_int64_create_lo_mi_hi\nfunction integers_uint32_of_string(s) {\n // To match the C implementation, we should parse the string as an uint64\n // and then downcast.\n var max_val = caml_int64_create_lo_mi_hi(0xffffff, 0xffffff, 0xffff);\n return integers_uint32_of_int64(integers_uint_of_string(s, max_val));\n}\n\n//Provides: integers_uint32_rem\n//Requires: caml_raise_zero_divide, UInt32\nfunction integers_uint32_rem(x, y) {\n if (y.value == 0) {\n caml_raise_zero_divide();\n }\n return new UInt32(x.value % y.value);\n}\n\n//Provides: integers_uint32_shift_left\n//Requires: UInt32\nfunction integers_uint32_shift_left(x, y) {\n return new UInt32(x.value << y);\n}\n\n//Provides: integers_uint32_shift_right\n//Requires: UInt32\nfunction integers_uint32_shift_right(x, y) {\n return new UInt32(x.value >>> y);\n}\n\n//Provides: integers_uint32_to_int\nfunction integers_uint32_to_int(i) {\n return (i.value | 0);\n}\n\n//Provides: integers_uint32_to_int64\n//Requires: caml_int64_create_lo_mi_hi\nfunction integers_uint32_to_int64(i) {\n return caml_int64_create_lo_mi_hi(i.value & 0xffffff, (i.value >>> 24) & 0xffffff, 0);\n}\n\n//Provides: integers_uint32_to_string\n//Requires: caml_new_string\nfunction integers_uint32_to_string(i) {\n return caml_new_string(i.value.toString());\n}\n\n//Provides: UInt64 const\nvar UInt64 = (function () {\n var UInt64 = function (x) {\n this.value = x; // x is an MlInt64\n };\n UInt64.prototype.caml_custom = \"integers:uint64\";\n return UInt64;\n})();\n\n//Provides: integers_uint64_add\n//Requires: caml_int64_add, UInt64\nfunction integers_uint64_add(x, y) {\n return new UInt64(caml_int64_add(x.value, y.value));\n}\n\n//Provides: integers_uint64_div\n//Requires: caml_raise_zero_divide, UInt64\nfunction integers_uint64_div(x, y) {\n if (y.value.isZero()) {\n caml_raise_zero_divide();\n }\n // Coerce the high parts to be unsigned before division.\n x.value.hi = x.value.hi >>> 0;\n y.value.hi = y.value.hi >>> 0;\n return new UInt64(x.value.udivmod(y.value).quotient);\n}\n\n//Provides: integers_uint64_logand\n//Requires: caml_int64_and, UInt64\nfunction integers_uint64_logand(x, y) {\n return new UInt64(caml_int64_and(x.value, y.value));\n}\n\n//Provides: integers_uint64_logor\n//Requires: caml_int64_or, UInt64\nfunction integers_uint64_logor(x, y) {\n return new UInt64(caml_int64_or(x.value, y.value));\n}\n\n//Provides: integers_uint64_logxor\n//Requires: caml_int64_xor, UInt64\nfunction integers_uint64_logxor(x, y) {\n return new UInt64(caml_int64_xor(x.value, y.value));\n}\n\n//Provides: integers_uint64_max\n//Requires: caml_int64_create_lo_mi_hi, UInt64\nfunction integers_uint64_max(unit) {\n var x = caml_int64_create_lo_mi_hi(0xffffff, 0xffffff, 0xffff);\n x.hi = x.hi >>> 0;\n return new UInt64(x);\n}\n\n//Provides: integers_uint64_mul\n//Requires: caml_int64_mul, UInt64\nfunction integers_uint64_mul(x, y) {\n return new UInt64(caml_int64_mul(x.value, y.value));\n}\n\n//Provides: integers_uint64_of_int\n//Requires: caml_int64_of_int32, UInt64\nfunction integers_uint64_of_int(i) {\n return new UInt64(caml_int64_of_int32(i));\n}\n\n//Provides: integers_uint64_of_int64\n//Requires: caml_int64_create_lo_mi_hi, UInt64\nfunction integers_uint64_of_int64(i) {\n return new UInt64(caml_int64_create_lo_mi_hi(i.lo, i.mi, i.hi >>> 0));\n}\n\n//Provides: integers_uint_of_string\n//Requires: caml_ml_string_length, caml_failwith, caml_string_unsafe_get, caml_int64_create_lo_mi_hi, caml_int64_of_int32, caml_parse_digit, caml_int64_ult, caml_int64_add, caml_int64_mul, caml_int64_neg\nfunction integers_uint_of_string(s, max_val) {\n // Note: This code matches the behavior of the C function.\n // In particular,\n // - only base-10 numbers are accepted\n // - negative numbers are accepted and coerced to 2's-complement uint64\n // - the longest numeric prefix is accepted, only raising an error when there\n // isn't a numeric prefix\n var i = 0, len = caml_ml_string_length(s), negative = false;\n if (i >= len) {\n caml_failwith(\"int_of_string\");\n }\n var c = caml_string_unsafe_get(s, i);\n if (c === 45) { // Minus sign\n i++;\n negative = true;\n } else if (c === 43) { // Plus sign\n i++;\n }\n var no_digits = true;\n // Ensure that the high byte is unsigned before division.\n max_val.hi = max_val.hi >>> 0;\n var ten = caml_int64_of_int32(10);\n var max_base_10 = max_val.udivmod(ten).quotient;\n var res = caml_int64_of_int32(0);\n for (; i < len; i++) {\n var c = caml_string_unsafe_get(s, i);\n var d = caml_parse_digit(c);\n if (d < 0 || d >= 10) {\n break;\n }\n no_digits = false;\n // Any digit here would overflow. Pin to the maximum value.\n if (caml_int64_ult(max_base_10, res)) {\n return max_val;\n }\n d = caml_int64_of_int32(d);\n res = caml_int64_add(caml_int64_mul(ten, res), d);\n // The given digit was too large. Pin to the maximum value.\n if (caml_int64_ult(res, d)) {\n return max_val;\n }\n }\n if (no_digits) {\n caml_failwith(\"int_of_string\");\n }\n if (negative) {\n res = caml_int64_neg(res);\n }\n // Set the high byte as unsigned.\n res.hi = res.hi >>> 0;\n return res;\n}\n\n//Provides: integers_uint64_of_string\n//Requires: integers_uint_of_string, caml_int64_create_lo_mi_hi, UInt64\nfunction integers_uint64_of_string(s) {\n var max_val = caml_int64_create_lo_mi_hi(0xffffff, 0xffffff, 0xffff);\n return new UInt64(integers_uint_of_string(s, max_val));\n}\n\n//Provides: integers_uint64_rem\n//Requires: caml_raise_zero_divide, caml_int64_is_zero, UInt64\nfunction integers_uint64_rem(x, y) {\n if (y.value.isZero()) {\n caml_raise_zero_divide();\n }\n // Coerce the high parts to be unsigned before division.\n x.value.hi = x.value.hi >>> 0;\n y.value.hi = y.value.hi >>> 0;\n return new UInt64(x.value.udivmod(y.value).modulus);\n}\n\n//Provides: integers_uint64_shift_left\n//Requires: caml_int64_shift_left, UInt64\nfunction integers_uint64_shift_left(x, y) {\n return new UInt64(caml_int64_shift_left(x.value, y));\n}\n\n//Provides: integers_uint64_shift_right\n//Requires: caml_int64_shift_right_unsigned, UInt64\nfunction integers_uint64_shift_right(x, y) {\n return new UInt64(caml_int64_shift_right_unsigned(x.value, y));\n}\n\n//Provides: integers_uint64_sub\n//Requires: caml_int64_sub, UInt64\nfunction integers_uint64_sub(x, y) {\n return new UInt64(caml_int64_sub(x.value, y.value));\n}\n\n//Provides: integers_uint64_to_int\n//Requires: caml_int64_to_int32\nfunction integers_uint64_to_int(i) {\n return caml_int64_to_int32(i.value);\n}\n\n//Provides: integers_uint64_to_int64\n//Requires: caml_int64_create_lo_mi_hi\nfunction integers_uint64_to_int64(i) {\n i = i.value;\n return caml_int64_create_lo_mi_hi(i.lo, i.mi, i.hi | 0);\n}\n\n//Provides: integers_uint64_to_string\n//Requires: caml_int64_format, caml_new_string\nfunction integers_uint64_to_string(i) {\n return caml_int64_format(caml_new_string(\"%u\"), i.value);\n}\n\n//Provides: integers_uint64_unmarshal\n//Requires: caml_int64_unmarshal, UInt64\nfunction integers_uint64_unmarshal(reader, size){\n return new UInt64(caml_int64_unmarshal(reader, size));\n}\n \n//Provides: integers_uint64_marshal\n//Requires: caml_int64_marshal\nfunction integers_uint64_marshal(writer, v, sizes) {\n caml_int64_marshal(writer, v.value, sizes);\n}\n\n//Provides: integers_uint64_hash\n//Requires: caml_int64_hash\nfunction integers_uint64_hash(v) {\n return caml_int64_hash(v.value);\n}\n\n//Provides: integers_uint8_of_string\n//Requires: integers_uint32_of_string\nfunction integers_uint8_of_string(x) {\n var y = integers_uint32_of_string(x);\n return (x.value & 0xFF);\n}\n\n//Provides: integers_uint_size\nfunction integers_uint_size(unit) {\n return 4;\n}\n\n//Provides: integers_ulong_size\nfunction integers_ulong_size(unit) {\n return 4;\n}\n\n//Provides: integers_ulonglong_size\nfunction integers_ulonglong_size(unit) {\n return 8;\n}\n\n//Provides: integers_unsigned_init\n//Requires: caml_custom_ops, integers_uint8_deserialize, integers_uint16_deserialize, integers_uint32_serialize, integers_uint32_deserialize, integers_uint32_hash, integers_uint32_compare, integers_uint64_compare, integers_uint64_hash, integers_uint64_marshal, integers_uint64_unmarshal\nfunction integers_unsigned_init(unit) {\n caml_custom_ops[\"integers:uint8\"] =\n { deserialize: integers_uint8_deserialize\n , fixed_length: 1 };\n caml_custom_ops[\"integers:uint16\"] =\n { deserialize: integers_uint16_deserialize\n , fixed_length: 2 };\n caml_custom_ops[\"integers:uint32\"] =\n { serialize: integers_uint32_serialize\n , deserialize: integers_uint32_deserialize\n , fixed_length: 4\n , hash: integers_uint32_hash\n , compare: integers_uint32_compare };\n caml_custom_ops[\"integers:uint64\"] =\n { serialize: integers_uint64_marshal\n , deserialize: integers_uint64_unmarshal\n , hash: integers_uint64_hash\n , compare: integers_uint64_compare };\n return unit;\n}\n\n//Provides: integers_ushort_size\nfunction integers_ushort_size(unit) {\n return 4;\n}\n\n//Provides: integers_uint32_serialize\nfunction integers_uint32_serialize(writer, v, size) {\n writer.write(32, v.value);\n size[0] = 4;\n size[1] = 4;\n}\n\n//Provides: integers_uint8_deserialize\nfunction integers_uint8_deserialize(reader, size) {\n size[0] = 1;\n return reader.read8u();\n}\n\n//Provides: integers_uint16_deserialize\nfunction integers_uint16_deserialize(reader, size) {\n size[0] = 2;\n return reader.read16u();\n}\n\n//Provides: integers_uint32_deserialize\n//Requires: UInt32\nfunction integers_uint32_deserialize(reader, size) {\n size[0] = 4;\n return new UInt32(reader.read32u());\n}\n\n//Provides: integers_uint32_hash\nfunction integers_uint32_hash(v) {\n return v.value;\n}\n\n//Provides: integers_uint32_compare\nfunction integers_uint32_compare(x, y) {\n if (x.value > y.value) { return 1; }\n if (x.value < y.value) { return -1; }\n return 0;\n}\n\n//Provides: integers_uint64_compare\n//Requires: caml_int64_compare\nfunction integers_uint64_compare(x, y) {\n x.value.hi = x.value.hi >>> 0;\n y.value.hi = y.value.hi >>> 0;\n return x.value.ucompare(y.value);\n}\n","//Imported from https://github.com/peterolson/BigInteger.js#4e99b15b7951338f164728377c906caae5a78202\n\n//Provides: bigInt const\nvar bigInt = (function (undefined) {\n \"use strict\";\n\n var BASE = 1e7,\n LOG_BASE = 7,\n MAX_INT = 9007199254740992,\n MAX_INT_ARR = smallToArray(MAX_INT),\n DEFAULT_ALPHABET = \"0123456789abcdefghijklmnopqrstuvwxyz\";\n\n var BigInt = joo_global_object.BigInt;\n\n var supportsNativeBigInt = typeof BigInt === \"function\";\n\n function Integer(v, radix, alphabet, caseSensitive) {\n if (typeof v === \"undefined\") return Integer[0];\n if (typeof radix !== \"undefined\") return +radix === 10 && !alphabet ? parseValue(v) : parseBase(v, radix, alphabet, caseSensitive);\n return parseValue(v);\n }\n\n function BigInteger(value, sign) {\n this.value = value;\n this.sign = sign;\n this.isSmall = false;\n this.caml_custom = '_z';\n }\n BigInteger.prototype = Object.create(Integer.prototype);\n\n function SmallInteger(value) {\n this.value = value;\n this.sign = value < 0;\n this.isSmall = true;\n this.caml_custom = '_z';\n }\n SmallInteger.prototype = Object.create(Integer.prototype);\n\n function NativeBigInt(value) {\n this.value = value;\n this.caml_custom = '_z';\n }\n NativeBigInt.prototype = Object.create(Integer.prototype);\n\n function isPrecise(n) {\n return -MAX_INT < n && n < MAX_INT;\n }\n\n function smallToArray(n) { // For performance reasons doesn't reference BASE, need to change this function if BASE changes\n if (n < 1e7)\n return [n];\n if (n < 1e14)\n return [n % 1e7, Math.floor(n / 1e7)];\n return [n % 1e7, Math.floor(n / 1e7) % 1e7, Math.floor(n / 1e14)];\n }\n\n function arrayToSmall(arr) { // If BASE changes this function may need to change\n trim(arr);\n var length = arr.length;\n if (length < 4 && compareAbs(arr, MAX_INT_ARR) < 0) {\n switch (length) {\n case 0: return 0;\n case 1: return arr[0];\n case 2: return arr[0] + arr[1] * BASE;\n default: return arr[0] + (arr[1] + arr[2] * BASE) * BASE;\n }\n }\n return arr;\n }\n\n function trim(v) {\n var i = v.length;\n while (v[--i] === 0);\n v.length = i + 1;\n }\n\n function createArray(length) { // function shamelessly stolen from Yaffle's library https://github.com/Yaffle/BigInteger\n var x = new Array(length);\n var i = -1;\n while (++i < length) {\n x[i] = 0;\n }\n return x;\n }\n\n function truncate(n) {\n if (n > 0) return Math.floor(n);\n return Math.ceil(n);\n }\n\n function add(a, b) { // assumes a and b are arrays with a.length >= b.length\n var l_a = a.length,\n l_b = b.length,\n r = new Array(l_a),\n carry = 0,\n base = BASE,\n sum, i;\n for (i = 0; i < l_b; i++) {\n sum = a[i] + b[i] + carry;\n carry = sum >= base ? 1 : 0;\n r[i] = sum - carry * base;\n }\n while (i < l_a) {\n sum = a[i] + carry;\n carry = sum === base ? 1 : 0;\n r[i++] = sum - carry * base;\n }\n if (carry > 0) r.push(carry);\n return r;\n }\n\n function addAny(a, b) {\n if (a.length >= b.length) return add(a, b);\n return add(b, a);\n }\n\n function addSmall(a, carry) { // assumes a is array, carry is number with 0 <= carry < MAX_INT\n var l = a.length,\n r = new Array(l),\n base = BASE,\n sum, i;\n for (i = 0; i < l; i++) {\n sum = a[i] - base + carry;\n carry = Math.floor(sum / base);\n r[i] = sum - carry * base;\n carry += 1;\n }\n while (carry > 0) {\n r[i++] = carry % base;\n carry = Math.floor(carry / base);\n }\n return r;\n }\n\n BigInteger.prototype.add = function (v) {\n var n = parseValue(v);\n if (this.sign !== n.sign) {\n return this.subtract(n.negate());\n }\n var a = this.value, b = n.value;\n if (n.isSmall) {\n return new BigInteger(addSmall(a, Math.abs(b)), this.sign);\n }\n return new BigInteger(addAny(a, b), this.sign);\n };\n BigInteger.prototype.plus = BigInteger.prototype.add;\n\n SmallInteger.prototype.add = function (v) {\n var n = parseValue(v);\n var a = this.value;\n if (a < 0 !== n.sign) {\n return this.subtract(n.negate());\n }\n var b = n.value;\n if (n.isSmall) {\n if (isPrecise(a + b)) return new SmallInteger(a + b);\n b = smallToArray(Math.abs(b));\n }\n return new BigInteger(addSmall(b, Math.abs(a)), a < 0);\n };\n SmallInteger.prototype.plus = SmallInteger.prototype.add;\n\n NativeBigInt.prototype.add = function (v) {\n return new NativeBigInt(this.value + parseValue(v).value);\n }\n NativeBigInt.prototype.plus = NativeBigInt.prototype.add;\n\n function subtract(a, b) { // assumes a and b are arrays with a >= b\n var a_l = a.length,\n b_l = b.length,\n r = new Array(a_l),\n borrow = 0,\n base = BASE,\n i, difference;\n for (i = 0; i < b_l; i++) {\n difference = a[i] - borrow - b[i];\n if (difference < 0) {\n difference += base;\n borrow = 1;\n } else borrow = 0;\n r[i] = difference;\n }\n for (i = b_l; i < a_l; i++) {\n difference = a[i] - borrow;\n if (difference < 0) difference += base;\n else {\n r[i++] = difference;\n break;\n }\n r[i] = difference;\n }\n for (; i < a_l; i++) {\n r[i] = a[i];\n }\n trim(r);\n return r;\n }\n\n function subtractAny(a, b, sign) {\n var value;\n if (compareAbs(a, b) >= 0) {\n value = subtract(a, b);\n } else {\n value = subtract(b, a);\n sign = !sign;\n }\n value = arrayToSmall(value);\n if (typeof value === \"number\") {\n if (sign) value = -value;\n return new SmallInteger(value);\n }\n return new BigInteger(value, sign);\n }\n\n function subtractSmall(a, b, sign) { // assumes a is array, b is number with 0 <= b < MAX_INT\n var l = a.length,\n r = new Array(l),\n carry = -b,\n base = BASE,\n i, difference;\n for (i = 0; i < l; i++) {\n difference = a[i] + carry;\n carry = Math.floor(difference / base);\n difference %= base;\n r[i] = difference < 0 ? difference + base : difference;\n }\n r = arrayToSmall(r);\n if (typeof r === \"number\") {\n if (sign) r = -r;\n return new SmallInteger(r);\n } return new BigInteger(r, sign);\n }\n\n BigInteger.prototype.subtract = function (v) {\n var n = parseValue(v);\n if (this.sign !== n.sign) {\n return this.add(n.negate());\n }\n var a = this.value, b = n.value;\n if (n.isSmall)\n return subtractSmall(a, Math.abs(b), this.sign);\n return subtractAny(a, b, this.sign);\n };\n BigInteger.prototype.minus = BigInteger.prototype.subtract;\n\n SmallInteger.prototype.subtract = function (v) {\n var n = parseValue(v);\n var a = this.value;\n if (a < 0 !== n.sign) {\n return this.add(n.negate());\n }\n var b = n.value;\n if (n.isSmall) {\n return new SmallInteger(a - b);\n }\n return subtractSmall(b, Math.abs(a), a >= 0);\n };\n SmallInteger.prototype.minus = SmallInteger.prototype.subtract;\n\n NativeBigInt.prototype.subtract = function (v) {\n return new NativeBigInt(this.value - parseValue(v).value);\n }\n NativeBigInt.prototype.minus = NativeBigInt.prototype.subtract;\n\n BigInteger.prototype.negate = function () {\n return new BigInteger(this.value, !this.sign);\n };\n SmallInteger.prototype.negate = function () {\n var sign = this.sign;\n var small = new SmallInteger(-this.value);\n small.sign = !sign;\n return small;\n };\n NativeBigInt.prototype.negate = function () {\n return new NativeBigInt(-this.value);\n }\n\n BigInteger.prototype.abs = function () {\n return new BigInteger(this.value, false);\n };\n SmallInteger.prototype.abs = function () {\n return new SmallInteger(Math.abs(this.value));\n };\n NativeBigInt.prototype.abs = function () {\n return new NativeBigInt(this.value >= 0 ? this.value : -this.value);\n }\n\n\n function multiplyLong(a, b) {\n var a_l = a.length,\n b_l = b.length,\n l = a_l + b_l,\n r = createArray(l),\n base = BASE,\n product, carry, i, a_i, b_j;\n for (i = 0; i < a_l; ++i) {\n a_i = a[i];\n for (var j = 0; j < b_l; ++j) {\n b_j = b[j];\n product = a_i * b_j + r[i + j];\n carry = Math.floor(product / base);\n r[i + j] = product - carry * base;\n r[i + j + 1] += carry;\n }\n }\n trim(r);\n return r;\n }\n\n function multiplySmall(a, b) { // assumes a is array, b is number with |b| < BASE\n var l = a.length,\n r = new Array(l),\n base = BASE,\n carry = 0,\n product, i;\n for (i = 0; i < l; i++) {\n product = a[i] * b + carry;\n carry = Math.floor(product / base);\n r[i] = product - carry * base;\n }\n while (carry > 0) {\n r[i++] = carry % base;\n carry = Math.floor(carry / base);\n }\n return r;\n }\n\n function shiftLeft(x, n) {\n var r = [];\n while (n-- > 0) r.push(0);\n return r.concat(x);\n }\n\n function multiplyKaratsuba(x, y) {\n var n = Math.max(x.length, y.length);\n\n if (n <= 30) return multiplyLong(x, y);\n n = Math.ceil(n / 2);\n\n var b = x.slice(n),\n a = x.slice(0, n),\n d = y.slice(n),\n c = y.slice(0, n);\n\n var ac = multiplyKaratsuba(a, c),\n bd = multiplyKaratsuba(b, d),\n abcd = multiplyKaratsuba(addAny(a, b), addAny(c, d));\n\n var product = addAny(addAny(ac, shiftLeft(subtract(subtract(abcd, ac), bd), n)), shiftLeft(bd, 2 * n));\n trim(product);\n return product;\n }\n\n // The following function is derived from a surface fit of a graph plotting the performance difference\n // between long multiplication and karatsuba multiplication versus the lengths of the two arrays.\n function useKaratsuba(l1, l2) {\n return -0.012 * l1 - 0.012 * l2 + 0.000015 * l1 * l2 > 0;\n }\n\n BigInteger.prototype.multiply = function (v) {\n var n = parseValue(v),\n a = this.value, b = n.value,\n sign = this.sign !== n.sign,\n abs;\n if (n.isSmall) {\n if (b === 0) return Integer[0];\n if (b === 1) return this;\n if (b === -1) return this.negate();\n abs = Math.abs(b);\n if (abs < BASE) {\n return new BigInteger(multiplySmall(a, abs), sign);\n }\n b = smallToArray(abs);\n }\n if (useKaratsuba(a.length, b.length)) // Karatsuba is only faster for certain array sizes\n return new BigInteger(multiplyKaratsuba(a, b), sign);\n return new BigInteger(multiplyLong(a, b), sign);\n };\n\n BigInteger.prototype.times = BigInteger.prototype.multiply;\n\n function multiplySmallAndArray(a, b, sign) { // a >= 0\n if (a < BASE) {\n return new BigInteger(multiplySmall(b, a), sign);\n }\n return new BigInteger(multiplyLong(b, smallToArray(a)), sign);\n }\n SmallInteger.prototype._multiplyBySmall = function (a) {\n if (isPrecise(a.value * this.value)) {\n return new SmallInteger(a.value * this.value);\n }\n return multiplySmallAndArray(Math.abs(a.value), smallToArray(Math.abs(this.value)), this.sign !== a.sign);\n };\n BigInteger.prototype._multiplyBySmall = function (a) {\n if (a.value === 0) return Integer[0];\n if (a.value === 1) return this;\n if (a.value === -1) return this.negate();\n return multiplySmallAndArray(Math.abs(a.value), this.value, this.sign !== a.sign);\n };\n SmallInteger.prototype.multiply = function (v) {\n return parseValue(v)._multiplyBySmall(this);\n };\n SmallInteger.prototype.times = SmallInteger.prototype.multiply;\n\n NativeBigInt.prototype.multiply = function (v) {\n return new NativeBigInt(this.value * parseValue(v).value);\n }\n NativeBigInt.prototype.times = NativeBigInt.prototype.multiply;\n\n function square(a) {\n //console.assert(2 * BASE * BASE < MAX_INT);\n var l = a.length,\n r = createArray(l + l),\n base = BASE,\n product, carry, i, a_i, a_j;\n for (i = 0; i < l; i++) {\n a_i = a[i];\n carry = 0 - a_i * a_i;\n for (var j = i; j < l; j++) {\n a_j = a[j];\n product = 2 * (a_i * a_j) + r[i + j] + carry;\n carry = Math.floor(product / base);\n r[i + j] = product - carry * base;\n }\n r[i + l] = carry;\n }\n trim(r);\n return r;\n }\n\n BigInteger.prototype.square = function () {\n return new BigInteger(square(this.value), false);\n };\n\n SmallInteger.prototype.square = function () {\n var value = this.value * this.value;\n if (isPrecise(value)) return new SmallInteger(value);\n return new BigInteger(square(smallToArray(Math.abs(this.value))), false);\n };\n\n NativeBigInt.prototype.square = function (v) {\n return new NativeBigInt(this.value * this.value);\n }\n\n function divMod1(a, b) { // Left over from previous version. Performs faster than divMod2 on smaller input sizes.\n var a_l = a.length,\n b_l = b.length,\n base = BASE,\n result = createArray(b.length),\n divisorMostSignificantDigit = b[b_l - 1],\n // normalization\n lambda = Math.ceil(base / (2 * divisorMostSignificantDigit)),\n remainder = multiplySmall(a, lambda),\n divisor = multiplySmall(b, lambda),\n quotientDigit, shift, carry, borrow, i, l, q;\n if (remainder.length <= a_l) remainder.push(0);\n divisor.push(0);\n divisorMostSignificantDigit = divisor[b_l - 1];\n for (shift = a_l - b_l; shift >= 0; shift--) {\n quotientDigit = base - 1;\n if (remainder[shift + b_l] !== divisorMostSignificantDigit) {\n quotientDigit = Math.floor((remainder[shift + b_l] * base + remainder[shift + b_l - 1]) / divisorMostSignificantDigit);\n }\n // quotientDigit <= base - 1\n carry = 0;\n borrow = 0;\n l = divisor.length;\n for (i = 0; i < l; i++) {\n carry += quotientDigit * divisor[i];\n q = Math.floor(carry / base);\n borrow += remainder[shift + i] - (carry - q * base);\n carry = q;\n if (borrow < 0) {\n remainder[shift + i] = borrow + base;\n borrow = -1;\n } else {\n remainder[shift + i] = borrow;\n borrow = 0;\n }\n }\n while (borrow !== 0) {\n quotientDigit -= 1;\n carry = 0;\n for (i = 0; i < l; i++) {\n carry += remainder[shift + i] - base + divisor[i];\n if (carry < 0) {\n remainder[shift + i] = carry + base;\n carry = 0;\n } else {\n remainder[shift + i] = carry;\n carry = 1;\n }\n }\n borrow += carry;\n }\n result[shift] = quotientDigit;\n }\n // denormalization\n remainder = divModSmall(remainder, lambda)[0];\n return [arrayToSmall(result), arrayToSmall(remainder)];\n }\n\n function divMod2(a, b) { // Implementation idea shamelessly stolen from Silent Matt's library http://silentmatt.com/biginteger/\n // Performs faster than divMod1 on larger input sizes.\n var a_l = a.length,\n b_l = b.length,\n result = [],\n part = [],\n base = BASE,\n guess, xlen, highx, highy, check;\n while (a_l) {\n part.unshift(a[--a_l]);\n trim(part);\n if (compareAbs(part, b) < 0) {\n result.push(0);\n continue;\n }\n xlen = part.length;\n highx = part[xlen - 1] * base + part[xlen - 2];\n highy = b[b_l - 1] * base + b[b_l - 2];\n if (xlen > b_l) {\n highx = (highx + 1) * base;\n }\n guess = Math.ceil(highx / highy);\n do {\n check = multiplySmall(b, guess);\n if (compareAbs(check, part) <= 0) break;\n guess--;\n } while (guess);\n result.push(guess);\n part = subtract(part, check);\n }\n result.reverse();\n return [arrayToSmall(result), arrayToSmall(part)];\n }\n\n function divModSmall(value, lambda) {\n var length = value.length,\n quotient = createArray(length),\n base = BASE,\n i, q, remainder, divisor;\n remainder = 0;\n for (i = length - 1; i >= 0; --i) {\n divisor = remainder * base + value[i];\n q = truncate(divisor / lambda);\n remainder = divisor - q * lambda;\n quotient[i] = q | 0;\n }\n return [quotient, remainder | 0];\n }\n\n function divModAny(self, v) {\n var value, n = parseValue(v);\n if (supportsNativeBigInt) {\n return [new NativeBigInt(self.value / n.value), new NativeBigInt(self.value % n.value)];\n }\n var a = self.value, b = n.value;\n var quotient;\n if (b === 0) throw new Error(\"Cannot divide by zero\");\n if (self.isSmall) {\n if (n.isSmall) {\n return [new SmallInteger(truncate(a / b)), new SmallInteger(a % b)];\n }\n return [Integer[0], self];\n }\n if (n.isSmall) {\n if (b === 1) return [self, Integer[0]];\n if (b == -1) return [self.negate(), Integer[0]];\n var abs = Math.abs(b);\n if (abs < BASE) {\n value = divModSmall(a, abs);\n quotient = arrayToSmall(value[0]);\n var remainder = value[1];\n if (self.sign) remainder = -remainder;\n if (typeof quotient === \"number\") {\n if (self.sign !== n.sign) quotient = -quotient;\n return [new SmallInteger(quotient), new SmallInteger(remainder)];\n }\n return [new BigInteger(quotient, self.sign !== n.sign), new SmallInteger(remainder)];\n }\n b = smallToArray(abs);\n }\n var comparison = compareAbs(a, b);\n if (comparison === -1) return [Integer[0], self];\n if (comparison === 0) return [Integer[self.sign === n.sign ? 1 : -1], Integer[0]];\n\n // divMod1 is faster on smaller input sizes\n if (a.length + b.length <= 200)\n value = divMod1(a, b);\n else value = divMod2(a, b);\n\n quotient = value[0];\n var qSign = self.sign !== n.sign,\n mod = value[1],\n mSign = self.sign;\n if (typeof quotient === \"number\") {\n if (qSign) quotient = -quotient;\n quotient = new SmallInteger(quotient);\n } else quotient = new BigInteger(quotient, qSign);\n if (typeof mod === \"number\") {\n if (mSign) mod = -mod;\n mod = new SmallInteger(mod);\n } else mod = new BigInteger(mod, mSign);\n return [quotient, mod];\n }\n\n BigInteger.prototype.divmod = function (v) {\n var result = divModAny(this, v);\n return {\n quotient: result[0],\n remainder: result[1]\n };\n };\n NativeBigInt.prototype.divmod = SmallInteger.prototype.divmod = BigInteger.prototype.divmod;\n\n\n BigInteger.prototype.divide = function (v) {\n return divModAny(this, v)[0];\n };\n NativeBigInt.prototype.over = NativeBigInt.prototype.divide = function (v) {\n return new NativeBigInt(this.value / parseValue(v).value);\n };\n SmallInteger.prototype.over = SmallInteger.prototype.divide = BigInteger.prototype.over = BigInteger.prototype.divide;\n\n BigInteger.prototype.mod = function (v) {\n return divModAny(this, v)[1];\n };\n NativeBigInt.prototype.mod = NativeBigInt.prototype.remainder = function (v) {\n return new NativeBigInt(this.value % parseValue(v).value);\n };\n SmallInteger.prototype.remainder = SmallInteger.prototype.mod = BigInteger.prototype.remainder = BigInteger.prototype.mod;\n\n BigInteger.prototype.pow = function (v) {\n var n = parseValue(v),\n a = this.value,\n b = n.value,\n value, x, y;\n if (b === 0) return Integer[1];\n if (a === 0) return Integer[0];\n if (a === 1) return Integer[1];\n if (a === -1) return n.isEven() ? Integer[1] : Integer[-1];\n if (n.sign) {\n return Integer[0];\n }\n if (!n.isSmall) throw new Error(\"The exponent \" + n.toString() + \" is too large.\");\n if (this.isSmall) {\n if (isPrecise(value = Math.pow(a, b)))\n return new SmallInteger(truncate(value));\n }\n x = this;\n y = Integer[1];\n while (true) {\n if (b & 1 === 1) {\n y = y.times(x);\n --b;\n }\n if (b === 0) break;\n b /= 2;\n x = x.square();\n }\n return y;\n };\n SmallInteger.prototype.pow = BigInteger.prototype.pow;\n\n NativeBigInt.prototype.pow = function (v) {\n var n = parseValue(v);\n var a = this.value, b = n.value;\n var _0 = BigInt(0), _1 = BigInt(1), _2 = BigInt(2);\n if (b === _0) return Integer[1];\n if (a === _0) return Integer[0];\n if (a === _1) return Integer[1];\n if (a === BigInt(-1)) return n.isEven() ? Integer[1] : Integer[-1];\n if (n.isNegative()) return new NativeBigInt(_0);\n var x = this;\n var y = Integer[1];\n while (true) {\n if ((b & _1) === _1) {\n y = y.times(x);\n --b;\n }\n if (b === _0) break;\n b /= _2;\n x = x.square();\n }\n return y;\n }\n\n BigInteger.prototype.modPow = function (exp, mod) {\n exp = parseValue(exp);\n mod = parseValue(mod);\n if (mod.isZero()) throw new Error(\"Cannot take modPow with modulus 0\");\n var r = Integer[1],\n base = this.mod(mod);\n if (exp.isNegative()) {\n exp = exp.multiply(Integer[-1]);\n base = base.modInv(mod);\n }\n while (exp.isPositive()) {\n if (base.isZero()) return Integer[0];\n if (exp.isOdd()) r = r.multiply(base).mod(mod);\n exp = exp.divide(2);\n base = base.square().mod(mod);\n }\n return r;\n };\n NativeBigInt.prototype.modPow = SmallInteger.prototype.modPow = BigInteger.prototype.modPow;\n\n function compareAbs(a, b) {\n if (a.length !== b.length) {\n return a.length > b.length ? 1 : -1;\n }\n for (var i = a.length - 1; i >= 0; i--) {\n if (a[i] !== b[i]) return a[i] > b[i] ? 1 : -1;\n }\n return 0;\n }\n\n BigInteger.prototype.compareAbs = function (v) {\n var n = parseValue(v),\n a = this.value,\n b = n.value;\n if (n.isSmall) return 1;\n return compareAbs(a, b);\n };\n SmallInteger.prototype.compareAbs = function (v) {\n var n = parseValue(v),\n a = Math.abs(this.value),\n b = n.value;\n if (n.isSmall) {\n b = Math.abs(b);\n return a === b ? 0 : a > b ? 1 : -1;\n }\n return -1;\n };\n NativeBigInt.prototype.compareAbs = function (v) {\n var a = this.value;\n var b = parseValue(v).value;\n a = a >= 0 ? a : -a;\n b = b >= 0 ? b : -b;\n return a === b ? 0 : a > b ? 1 : -1;\n }\n\n BigInteger.prototype.compare = function (v) {\n // See discussion about comparison with Infinity:\n // https://github.com/peterolson/BigInteger.js/issues/61\n if (v === Infinity) {\n return -1;\n }\n if (v === -Infinity) {\n return 1;\n }\n\n var n = parseValue(v),\n a = this.value,\n b = n.value;\n if (this.sign !== n.sign) {\n return n.sign ? 1 : -1;\n }\n if (n.isSmall) {\n return this.sign ? -1 : 1;\n }\n return compareAbs(a, b) * (this.sign ? -1 : 1);\n };\n BigInteger.prototype.compareTo = BigInteger.prototype.compare;\n\n SmallInteger.prototype.compare = function (v) {\n if (v === Infinity) {\n return -1;\n }\n if (v === -Infinity) {\n return 1;\n }\n\n var n = parseValue(v),\n a = this.value,\n b = n.value;\n if (n.isSmall) {\n return a == b ? 0 : a > b ? 1 : -1;\n }\n if (a < 0 !== n.sign) {\n return a < 0 ? -1 : 1;\n }\n return a < 0 ? 1 : -1;\n };\n SmallInteger.prototype.compareTo = SmallInteger.prototype.compare;\n\n NativeBigInt.prototype.compare = function (v) {\n if (v === Infinity) {\n return -1;\n }\n if (v === -Infinity) {\n return 1;\n }\n var a = this.value;\n var b = parseValue(v).value;\n return a === b ? 0 : a > b ? 1 : -1;\n }\n NativeBigInt.prototype.compareTo = NativeBigInt.prototype.compare;\n\n BigInteger.prototype.equals = function (v) {\n return this.compare(v) === 0;\n };\n NativeBigInt.prototype.eq = NativeBigInt.prototype.equals = SmallInteger.prototype.eq = SmallInteger.prototype.equals = BigInteger.prototype.eq = BigInteger.prototype.equals;\n\n BigInteger.prototype.notEquals = function (v) {\n return this.compare(v) !== 0;\n };\n NativeBigInt.prototype.neq = NativeBigInt.prototype.notEquals = SmallInteger.prototype.neq = SmallInteger.prototype.notEquals = BigInteger.prototype.neq = BigInteger.prototype.notEquals;\n\n BigInteger.prototype.greater = function (v) {\n return this.compare(v) > 0;\n };\n NativeBigInt.prototype.gt = NativeBigInt.prototype.greater = SmallInteger.prototype.gt = SmallInteger.prototype.greater = BigInteger.prototype.gt = BigInteger.prototype.greater;\n\n BigInteger.prototype.lesser = function (v) {\n return this.compare(v) < 0;\n };\n NativeBigInt.prototype.lt = NativeBigInt.prototype.lesser = SmallInteger.prototype.lt = SmallInteger.prototype.lesser = BigInteger.prototype.lt = BigInteger.prototype.lesser;\n\n BigInteger.prototype.greaterOrEquals = function (v) {\n return this.compare(v) >= 0;\n };\n NativeBigInt.prototype.geq = NativeBigInt.prototype.greaterOrEquals = SmallInteger.prototype.geq = SmallInteger.prototype.greaterOrEquals = BigInteger.prototype.geq = BigInteger.prototype.greaterOrEquals;\n\n BigInteger.prototype.lesserOrEquals = function (v) {\n return this.compare(v) <= 0;\n };\n NativeBigInt.prototype.leq = NativeBigInt.prototype.lesserOrEquals = SmallInteger.prototype.leq = SmallInteger.prototype.lesserOrEquals = BigInteger.prototype.leq = BigInteger.prototype.lesserOrEquals;\n\n BigInteger.prototype.isEven = function () {\n return (this.value[0] & 1) === 0;\n };\n SmallInteger.prototype.isEven = function () {\n return (this.value & 1) === 0;\n };\n NativeBigInt.prototype.isEven = function () {\n return (this.value & BigInt(1)) === BigInt(0);\n }\n\n BigInteger.prototype.isOdd = function () {\n return (this.value[0] & 1) === 1;\n };\n SmallInteger.prototype.isOdd = function () {\n return (this.value & 1) === 1;\n };\n NativeBigInt.prototype.isOdd = function () {\n return (this.value & BigInt(1)) === BigInt(1);\n }\n\n BigInteger.prototype.isPositive = function () {\n return !this.sign;\n };\n SmallInteger.prototype.isPositive = function () {\n return this.value > 0;\n };\n NativeBigInt.prototype.isPositive = SmallInteger.prototype.isPositive;\n\n BigInteger.prototype.isNegative = function () {\n return this.sign;\n };\n SmallInteger.prototype.isNegative = function () {\n return this.value < 0;\n };\n NativeBigInt.prototype.isNegative = SmallInteger.prototype.isNegative;\n\n BigInteger.prototype.isUnit = function () {\n return false;\n };\n SmallInteger.prototype.isUnit = function () {\n return Math.abs(this.value) === 1;\n };\n NativeBigInt.prototype.isUnit = function () {\n return this.abs().value === BigInt(1);\n }\n\n BigInteger.prototype.isZero = function () {\n return false;\n };\n SmallInteger.prototype.isZero = function () {\n return this.value === 0;\n };\n NativeBigInt.prototype.isZero = function () {\n return this.value === BigInt(0);\n }\n\n BigInteger.prototype.isDivisibleBy = function (v) {\n var n = parseValue(v);\n if (n.isZero()) return false;\n if (n.isUnit()) return true;\n if (n.compareAbs(2) === 0) return this.isEven();\n return this.mod(n).isZero();\n };\n NativeBigInt.prototype.isDivisibleBy = SmallInteger.prototype.isDivisibleBy = BigInteger.prototype.isDivisibleBy;\n\n function isBasicPrime(v) {\n var n = v.abs();\n if (n.isUnit()) return false;\n if (n.equals(2) || n.equals(3) || n.equals(5)) return true;\n if (n.isEven() || n.isDivisibleBy(3) || n.isDivisibleBy(5)) return false;\n if (n.lesser(49)) return true;\n // we don't know if it's prime: let the other functions figure it out\n }\n\n function millerRabinTest(n, a) {\n var nPrev = n.prev(),\n b = nPrev,\n r = 0,\n d, t, i, x;\n while (b.isEven()) b = b.divide(2), r++;\n next: for (i = 0; i < a.length; i++) {\n if (n.lesser(a[i])) continue;\n x = bigInt(a[i]).modPow(b, n);\n if (x.isUnit() || x.equals(nPrev)) continue;\n for (d = r - 1; d != 0; d--) {\n x = x.square().mod(n);\n if (x.isUnit()) return false;\n if (x.equals(nPrev)) continue next;\n }\n return false;\n }\n return true;\n }\n\n // Set \"strict\" to true to force GRH-supported lower bound of 2*log(N)^2\n BigInteger.prototype.isPrime = function (strict) {\n var isPrime = isBasicPrime(this);\n if (isPrime !== undefined) return isPrime;\n var n = this.abs();\n var bits = n.bitLength();\n if (bits <= 64)\n return millerRabinTest(n, [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37]);\n var logN = Math.log(2) * bits.toJSNumber();\n var t = Math.ceil((strict === true) ? (2 * Math.pow(logN, 2)) : logN);\n for (var a = [], i = 0; i < t; i++) {\n a.push(bigInt(i + 2));\n }\n return millerRabinTest(n, a);\n };\n NativeBigInt.prototype.isPrime = SmallInteger.prototype.isPrime = BigInteger.prototype.isPrime;\n\n BigInteger.prototype.isProbablePrime = function (iterations) {\n var isPrime = isBasicPrime(this);\n if (isPrime !== undefined) return isPrime;\n var n = this.abs();\n var t = iterations === undefined ? 5 : iterations;\n for (var a = [], i = 0; i < t; i++) {\n a.push(bigInt.randBetween(2, n.minus(2)));\n }\n return millerRabinTest(n, a);\n };\n NativeBigInt.prototype.isProbablePrime = SmallInteger.prototype.isProbablePrime = BigInteger.prototype.isProbablePrime;\n\n BigInteger.prototype.modInv = function (n) {\n var t = bigInt.zero, newT = bigInt.one, r = parseValue(n), newR = this.abs(), q, lastT, lastR;\n while (!newR.isZero()) {\n q = r.divide(newR);\n lastT = t;\n lastR = r;\n t = newT;\n r = newR;\n newT = lastT.subtract(q.multiply(newT));\n newR = lastR.subtract(q.multiply(newR));\n }\n if (!r.isUnit()) throw new Error(this.toString() + \" and \" + n.toString() + \" are not co-prime\");\n if (t.compare(0) === -1) {\n t = t.add(n);\n }\n if (this.isNegative()) {\n return t.negate();\n }\n return t;\n };\n\n NativeBigInt.prototype.modInv = SmallInteger.prototype.modInv = BigInteger.prototype.modInv;\n\n BigInteger.prototype.next = function () {\n var value = this.value;\n if (this.sign) {\n return subtractSmall(value, 1, this.sign);\n }\n return new BigInteger(addSmall(value, 1), this.sign);\n };\n SmallInteger.prototype.next = function () {\n var value = this.value;\n if (value + 1 < MAX_INT) return new SmallInteger(value + 1);\n return new BigInteger(MAX_INT_ARR, false);\n };\n NativeBigInt.prototype.next = function () {\n return new NativeBigInt(this.value + BigInt(1));\n }\n\n BigInteger.prototype.prev = function () {\n var value = this.value;\n if (this.sign) {\n return new BigInteger(addSmall(value, 1), true);\n }\n return subtractSmall(value, 1, this.sign);\n };\n SmallInteger.prototype.prev = function () {\n var value = this.value;\n if (value - 1 > -MAX_INT) return new SmallInteger(value - 1);\n return new BigInteger(MAX_INT_ARR, true);\n };\n NativeBigInt.prototype.prev = function () {\n return new NativeBigInt(this.value - BigInt(1));\n }\n\n var powersOfTwo = [1];\n while (2 * powersOfTwo[powersOfTwo.length - 1] <= BASE) powersOfTwo.push(2 * powersOfTwo[powersOfTwo.length - 1]);\n var powers2Length = powersOfTwo.length, highestPower2 = powersOfTwo[powers2Length - 1];\n\n function shift_isSmall(n) {\n return Math.abs(n) <= BASE;\n }\n\n BigInteger.prototype.shiftLeft = function (v) {\n var n = parseValue(v).toJSNumber();\n if (!shift_isSmall(n)) {\n throw new Error(String(n) + \" is too large for shifting.\");\n }\n if (n < 0) return this.shiftRight(-n);\n var result = this;\n if (result.isZero()) return result;\n while (n >= powers2Length) {\n result = result.multiply(highestPower2);\n n -= powers2Length - 1;\n }\n return result.multiply(powersOfTwo[n]);\n };\n NativeBigInt.prototype.shiftLeft = SmallInteger.prototype.shiftLeft = BigInteger.prototype.shiftLeft;\n\n BigInteger.prototype.shiftRight = function (v) {\n var remQuo;\n var n = parseValue(v).toJSNumber();\n if (!shift_isSmall(n)) {\n throw new Error(String(n) + \" is too large for shifting.\");\n }\n if (n < 0) return this.shiftLeft(-n);\n var result = this;\n while (n >= powers2Length) {\n if (result.isZero() || (result.isNegative() && result.isUnit())) return result;\n remQuo = divModAny(result, highestPower2);\n result = remQuo[1].isNegative() ? remQuo[0].prev() : remQuo[0];\n n -= powers2Length - 1;\n }\n remQuo = divModAny(result, powersOfTwo[n]);\n return remQuo[1].isNegative() ? remQuo[0].prev() : remQuo[0];\n };\n NativeBigInt.prototype.shiftRight = SmallInteger.prototype.shiftRight = BigInteger.prototype.shiftRight;\n\n function bitwise(x, y, fn) {\n y = parseValue(y);\n var xSign = x.isNegative(), ySign = y.isNegative();\n var xRem = xSign ? x.not() : x,\n yRem = ySign ? y.not() : y;\n var xDigit = 0, yDigit = 0;\n var xDivMod = null, yDivMod = null;\n var result = [];\n while (!xRem.isZero() || !yRem.isZero()) {\n xDivMod = divModAny(xRem, highestPower2);\n xDigit = xDivMod[1].toJSNumber();\n if (xSign) {\n xDigit = highestPower2 - 1 - xDigit; // two's complement for negative numbers\n }\n\n yDivMod = divModAny(yRem, highestPower2);\n yDigit = yDivMod[1].toJSNumber();\n if (ySign) {\n yDigit = highestPower2 - 1 - yDigit; // two's complement for negative numbers\n }\n\n xRem = xDivMod[0];\n yRem = yDivMod[0];\n result.push(fn(xDigit, yDigit));\n }\n var sum = fn(xSign ? 1 : 0, ySign ? 1 : 0) !== 0 ? bigInt(-1) : bigInt(0);\n for (var i = result.length - 1; i >= 0; i -= 1) {\n sum = sum.multiply(highestPower2).add(bigInt(result[i]));\n }\n return sum;\n }\n\n BigInteger.prototype.not = function () {\n return this.negate().prev();\n };\n NativeBigInt.prototype.not = SmallInteger.prototype.not = BigInteger.prototype.not;\n\n BigInteger.prototype.and = function (n) {\n return bitwise(this, n, function (a, b) { return a & b; });\n };\n NativeBigInt.prototype.and = SmallInteger.prototype.and = BigInteger.prototype.and;\n\n BigInteger.prototype.or = function (n) {\n return bitwise(this, n, function (a, b) { return a | b; });\n };\n NativeBigInt.prototype.or = SmallInteger.prototype.or = BigInteger.prototype.or;\n\n BigInteger.prototype.xor = function (n) {\n return bitwise(this, n, function (a, b) { return a ^ b; });\n };\n NativeBigInt.prototype.xor = SmallInteger.prototype.xor = BigInteger.prototype.xor;\n\n var LOBMASK_I = 1 << 30, LOBMASK_BI = (BASE & -BASE) * (BASE & -BASE) | LOBMASK_I;\n function roughLOB(n) { // get lowestOneBit (rough)\n // SmallInteger: return Min(lowestOneBit(n), 1 << 30)\n // BigInteger: return Min(lowestOneBit(n), 1 << 14) [BASE=1e7]\n var v = n.value,\n x = typeof v === \"number\" ? v | LOBMASK_I :\n typeof v === \"bigint\" ? v | BigInt(LOBMASK_I) :\n v[0] + v[1] * BASE | LOBMASK_BI;\n return x & -x;\n }\n\n function integerLogarithm(value, base) {\n if (base.compareTo(value) <= 0) {\n var tmp = integerLogarithm(value, base.square(base));\n var p = tmp.p;\n var e = tmp.e;\n var t = p.multiply(base);\n return t.compareTo(value) <= 0 ? { p: t, e: e * 2 + 1 } : { p: p, e: e * 2 };\n }\n return { p: bigInt(1), e: 0 };\n }\n\n BigInteger.prototype.bitLength = function () {\n var n = this;\n if (n.compareTo(bigInt(0)) < 0) {\n n = n.negate().subtract(bigInt(1));\n }\n if (n.compareTo(bigInt(0)) === 0) {\n return bigInt(0);\n }\n return bigInt(integerLogarithm(n, bigInt(2)).e).add(bigInt(1));\n }\n NativeBigInt.prototype.bitLength = SmallInteger.prototype.bitLength = BigInteger.prototype.bitLength;\n\n function max(a, b) {\n a = parseValue(a);\n b = parseValue(b);\n return a.greater(b) ? a : b;\n }\n function min(a, b) {\n a = parseValue(a);\n b = parseValue(b);\n return a.lesser(b) ? a : b;\n }\n function gcd(a, b) {\n a = parseValue(a).abs();\n b = parseValue(b).abs();\n if (a.equals(b)) return a;\n if (a.isZero()) return b;\n if (b.isZero()) return a;\n var c = Integer[1], d, t;\n while (a.isEven() && b.isEven()) {\n d = min(roughLOB(a), roughLOB(b));\n a = a.divide(d);\n b = b.divide(d);\n c = c.multiply(d);\n }\n while (a.isEven()) {\n a = a.divide(roughLOB(a));\n }\n do {\n while (b.isEven()) {\n b = b.divide(roughLOB(b));\n }\n if (a.greater(b)) {\n t = b; b = a; a = t;\n }\n b = b.subtract(a);\n } while (!b.isZero());\n return c.isUnit() ? a : a.multiply(c);\n }\n function lcm(a, b) {\n a = parseValue(a).abs();\n b = parseValue(b).abs();\n return a.divide(gcd(a, b)).multiply(b);\n }\n function randBetween(a, b) {\n a = parseValue(a);\n b = parseValue(b);\n var low = min(a, b), high = max(a, b);\n var range = high.subtract(low).add(1);\n if (range.isSmall) return low.add(Math.floor(Math.random() * range));\n var digits = toBase(range, BASE).value;\n var result = [], restricted = true;\n for (var i = 0; i < digits.length; i++) {\n var top = restricted ? digits[i] : BASE;\n var digit = truncate(Math.random() * top);\n result.push(digit);\n if (digit < top) restricted = false;\n }\n return low.add(Integer.fromArray(result, BASE, false));\n }\n\n var parseBase = function (text, base, alphabet, caseSensitive) {\n alphabet = alphabet || DEFAULT_ALPHABET;\n text = String(text);\n if (!caseSensitive) {\n text = text.toLowerCase();\n alphabet = alphabet.toLowerCase();\n }\n var length = text.length;\n var i;\n var absBase = Math.abs(base);\n var alphabetValues = {};\n for (i = 0; i < alphabet.length; i++) {\n alphabetValues[alphabet[i]] = i;\n }\n for (i = 0; i < length; i++) {\n var c = text[i];\n if (c === \"-\") continue;\n if (c in alphabetValues) {\n if (alphabetValues[c] >= absBase) {\n if (c === \"1\" && absBase === 1) continue;\n throw new Error(c + \" is not a valid digit in base \" + base + \".\");\n }\n }\n }\n base = parseValue(base);\n var digits = [];\n var isNegative = text[0] === \"-\";\n for (i = isNegative ? 1 : 0; i < text.length; i++) {\n var c = text[i];\n if (c in alphabetValues) digits.push(parseValue(alphabetValues[c]));\n else if (c === \"<\") {\n var start = i;\n do { i++; } while (text[i] !== \">\" && i < text.length);\n digits.push(parseValue(text.slice(start + 1, i)));\n }\n else throw new Error(c + \" is not a valid character\");\n }\n return parseBaseFromArray(digits, base, isNegative);\n };\n\n function parseBaseFromArray(digits, base, isNegative) {\n var val = Integer[0], pow = Integer[1], i;\n for (i = digits.length - 1; i >= 0; i--) {\n val = val.add(digits[i].times(pow));\n pow = pow.times(base);\n }\n return isNegative ? val.negate() : val;\n }\n\n function stringify(digit, alphabet) {\n alphabet = alphabet || DEFAULT_ALPHABET;\n if (digit < alphabet.length) {\n return alphabet[digit];\n }\n return \"<\" + digit + \">\";\n }\n\n function toBase(n, base) {\n base = bigInt(base);\n if (base.isZero()) {\n if (n.isZero()) return { value: [0], isNegative: false };\n throw new Error(\"Cannot convert nonzero numbers to base 0.\");\n }\n if (base.equals(-1)) {\n if (n.isZero()) return { value: [0], isNegative: false };\n if (n.isNegative())\n return {\n value: [].concat.apply([], Array.apply(null, Array(-n.toJSNumber()))\n .map(Array.prototype.valueOf, [1, 0])\n ),\n isNegative: false\n };\n\n var arr = Array.apply(null, Array(n.toJSNumber() - 1))\n .map(Array.prototype.valueOf, [0, 1]);\n arr.unshift([1]);\n return {\n value: [].concat.apply([], arr),\n isNegative: false\n };\n }\n\n var neg = false;\n if (n.isNegative() && base.isPositive()) {\n neg = true;\n n = n.abs();\n }\n if (base.isUnit()) {\n if (n.isZero()) return { value: [0], isNegative: false };\n\n return {\n value: Array.apply(null, Array(n.toJSNumber()))\n .map(Number.prototype.valueOf, 1),\n isNegative: neg\n };\n }\n var out = [];\n var left = n, divmod;\n while (left.isNegative() || left.compareAbs(base) >= 0) {\n divmod = left.divmod(base);\n left = divmod.quotient;\n var digit = divmod.remainder;\n if (digit.isNegative()) {\n digit = base.minus(digit).abs();\n left = left.next();\n }\n out.push(digit.toJSNumber());\n }\n out.push(left.toJSNumber());\n return { value: out.reverse(), isNegative: neg };\n }\n\n function toBaseString(n, base, alphabet) {\n var arr = toBase(n, base);\n return (arr.isNegative ? \"-\" : \"\") + arr.value.map(function (x) {\n return stringify(x, alphabet);\n }).join('');\n }\n\n BigInteger.prototype.toArray = function (radix) {\n return toBase(this, radix);\n };\n\n SmallInteger.prototype.toArray = function (radix) {\n return toBase(this, radix);\n };\n\n NativeBigInt.prototype.toArray = function (radix) {\n return toBase(this, radix);\n };\n\n BigInteger.prototype.toString = function (radix, alphabet) {\n if (radix === undefined) radix = 10;\n if (radix !== 10) return toBaseString(this, radix, alphabet);\n var v = this.value, l = v.length, str = String(v[--l]), zeros = \"0000000\", digit;\n while (--l >= 0) {\n digit = String(v[l]);\n str += zeros.slice(digit.length) + digit;\n }\n var sign = this.sign ? \"-\" : \"\";\n return sign + str;\n };\n\n SmallInteger.prototype.toString = function (radix, alphabet) {\n if (radix === undefined) radix = 10;\n if (radix != 10) return toBaseString(this, radix, alphabet);\n return String(this.value);\n };\n\n NativeBigInt.prototype.toString = SmallInteger.prototype.toString;\n\n NativeBigInt.prototype.toJSON = BigInteger.prototype.toJSON = SmallInteger.prototype.toJSON = function () { return this.toString(); }\n\n BigInteger.prototype.valueOf = function () {\n return parseInt(this.toString(), 10);\n };\n BigInteger.prototype.toJSNumber = BigInteger.prototype.valueOf;\n\n SmallInteger.prototype.valueOf = function () {\n return this.value;\n };\n SmallInteger.prototype.toJSNumber = SmallInteger.prototype.valueOf;\n NativeBigInt.prototype.valueOf = NativeBigInt.prototype.toJSNumber = function () {\n return parseInt(this.toString(), 10);\n }\n\n function parseStringValue(v) {\n if (isPrecise(+v)) {\n var x = +v;\n if (x === truncate(x))\n return supportsNativeBigInt ? new NativeBigInt(BigInt(x)) : new SmallInteger(x);\n throw new Error(\"Invalid integer: \" + v);\n }\n var sign = v[0] === \"-\";\n if (sign) v = v.slice(1);\n var split = v.split(/e/i);\n if (split.length > 2) throw new Error(\"Invalid integer: \" + split.join(\"e\"));\n if (split.length === 2) {\n var exp = split[1];\n if (exp[0] === \"+\") exp = exp.slice(1);\n exp = +exp;\n if (exp !== truncate(exp) || !isPrecise(exp)) throw new Error(\"Invalid integer: \" + exp + \" is not a valid exponent.\");\n var text = split[0];\n var decimalPlace = text.indexOf(\".\");\n if (decimalPlace >= 0) {\n exp -= text.length - decimalPlace - 1;\n text = text.slice(0, decimalPlace) + text.slice(decimalPlace + 1);\n }\n if (exp < 0) throw new Error(\"Cannot include negative exponent part for integers\");\n text += (new Array(exp + 1)).join(\"0\");\n v = text;\n }\n var isValid = /^([0-9][0-9]*)$/.test(v);\n if (!isValid) throw new Error(\"Invalid integer: \" + v);\n if (supportsNativeBigInt) {\n return new NativeBigInt(BigInt(sign ? \"-\" + v : v));\n }\n var r = [], max = v.length, l = LOG_BASE, min = max - l;\n while (max > 0) {\n r.push(+v.slice(min, max));\n min -= l;\n if (min < 0) min = 0;\n max -= l;\n }\n trim(r);\n return new BigInteger(r, sign);\n }\n\n function parseNumberValue(v) {\n if (supportsNativeBigInt) {\n return new NativeBigInt(BigInt(v));\n }\n if (isPrecise(v)) {\n if (v !== truncate(v)) throw new Error(v + \" is not an integer.\");\n return new SmallInteger(v);\n }\n return parseStringValue(v.toString());\n }\n\n function parseValue(v) {\n if (typeof v === \"number\") {\n return parseNumberValue(v);\n }\n if (typeof v === \"string\") {\n return parseStringValue(v);\n }\n if (typeof v === \"bigint\") {\n return new NativeBigInt(v);\n }\n return v;\n }\n // Pre-define numbers in range [-999,999]\n for (var i = 0; i < 1000; i++) {\n Integer[i] = parseValue(i);\n if (i > 0) Integer[-i] = parseValue(-i);\n }\n // Backwards compatibility\n Integer.one = Integer[1];\n Integer.zero = Integer[0];\n Integer.minusOne = Integer[-1];\n Integer.max = max;\n Integer.min = min;\n Integer.gcd = gcd;\n Integer.lcm = lcm;\n Integer.isInstance = function (x) { return x instanceof BigInteger || x instanceof SmallInteger || x instanceof NativeBigInt; };\n Integer.randBetween = randBetween;\n\n Integer.fromArray = function (digits, base, isNegative) {\n return parseBaseFromArray(digits.map(parseValue), parseValue(base || 10), isNegative);\n };\n\n return Integer;\n})();\n","/* global bigInt */\n/* eslint-disable no-unused-vars */\n\n// We represent a [Z.t] as a javascript 32bit integers if it fits or as a bigInt.\n\n//Provides: ml_z_normalize\n//Requires: bigInt\nfunction ml_z_normalize(x){\n var y = x.toJSNumber () | 0;\n if(x.equals(bigInt(y))) return y;\n return x;\n}\n\n//Provides: ml_z_mul_overflows\nfunction ml_z_mul_overflows(x,y){\n var z = x*y;\n return z != (z|0);\n}\n\n//external init: unit -> unit\n//Provides: ml_z_init\n//Requires: caml_zarith_marshal, caml_zarith_unmarshal, caml_custom_ops, ml_z_hash, ml_z_compare\nfunction ml_z_init(unit) {\n caml_custom_ops['_z'] =\n { serialize : caml_zarith_marshal,\n deserialize : caml_zarith_unmarshal,\n hash : ml_z_hash,\n compare : ml_z_compare,\n };\n return 0 }\n\n//external ml_z_install_frametable: unit -> unit\n//Provides: ml_z_install_frametable const\nfunction ml_z_install_frametable(unit) { return 0 }\n\n//external neg: t -> t\n//Provides: ml_z_neg const\n//Requires: bigInt, ml_z_normalize\nfunction ml_z_neg(z1) {\n return ml_z_normalize(bigInt(z1).negate());\n}\n\n//external add: t -> t -> t\n//Provides: ml_z_add const\n//Requires: bigInt, ml_z_normalize\nfunction ml_z_add(z1, z2) {\n return ml_z_normalize(bigInt(z1).add(bigInt(z2)));\n}\n\n//external sub: t -> t -> t\n//Provides: ml_z_sub const\n//Requires: bigInt, ml_z_normalize\nfunction ml_z_sub(z1, z2) {\n return ml_z_normalize(bigInt(z1).subtract(bigInt(z2)));\n}\n\n//external mul: t -> t -> t\n//Provides: ml_z_mul const\n//Requires: bigInt, ml_z_normalize\nfunction ml_z_mul(z1, z2) {\n return ml_z_normalize(bigInt(z1).multiply(bigInt(z2)));\n}\n\n//external div: t -> t -> t\n//Provides: ml_z_div\n//Requires: bigInt, caml_raise_zero_divide, ml_z_normalize\nfunction ml_z_div(z1, z2) {\n z2 = bigInt(z2)\n if(z2.equals(bigInt(0))) caml_raise_zero_divide();\n return ml_z_normalize(bigInt(z1).divide(bigInt(z2)))\n}\n\n//external cdiv: t -> t -> t\n//Provides: ml_z_cdiv\n//Requires: bigInt, ml_z_div, ml_z_sign, ml_z_add\nfunction ml_z_cdiv(z1, z2) {\n var z1_pos = ml_z_sign(z1);\n var z2_pos = ml_z_sign(z2);\n if (z1_pos * z2_pos > 0) /* Multiplication is like a signwise xor */ {\n if (!bigInt(z1).mod(bigInt(z2)).equals(bigInt(0))) {\n return ml_z_add(ml_z_div(z1, z2), bigInt(1)) ;\n }\n }\n return ml_z_div(z1, z2);\n}\n\n//external fdiv: t -> t -> t\n//Provides: ml_z_fdiv\n//Requires: bigInt, ml_z_div, ml_z_sign, ml_z_sub\nfunction ml_z_fdiv(z1, z2) {\n var z1_pos = ml_z_sign(z1);\n var z2_pos = ml_z_sign(z2);\n if (z1_pos * z2_pos < 0) /* Multiplication is like a signwise xor */ {\n if (!bigInt(z1).mod(bigInt(z2)).equals(bigInt(0))) {\n return ml_z_sub(ml_z_div(z1, z2), bigInt(1)) ;\n }\n }\n return ml_z_div(z1, z2);\n}\n\n//external rem: t -> t -> t\n//Provides: ml_z_rem\n//Requires: bigInt, caml_raise_zero_divide, ml_z_normalize\nfunction ml_z_rem(z1, z2) {\n z2 = bigInt(z2);\n if (z2.equals(bigInt(0))) {\n caml_raise_zero_divide();\n }\n return ml_z_normalize(bigInt(z1).mod(z2));\n}\n\n//external div_rem: t -> t -> (t * t)\n//Provides: ml_z_div_rem\n//Requires: ml_z_div, ml_z_rem\nfunction ml_z_div_rem(z1, z2) {\n return [0, ml_z_div(z1,z2), ml_z_rem(z1, z2)]\n}\n//external succ: t -> t\n//Provides: ml_z_succ const\n//Requires: bigInt, ml_z_normalize\nfunction ml_z_succ(z1) {\n return ml_z_normalize(bigInt(z1).next());\n}\n\n//external pred: t -> t\n//Provides: ml_z_pred const\n//Requires: bigInt, ml_z_normalize\nfunction ml_z_pred(z1) {\n return ml_z_normalize(bigInt(z1).prev());\n}\n\n//external abs: t -> t\n//Provides: ml_z_abs const\n//Requires: bigInt, ml_z_normalize\nfunction ml_z_abs(z1) {\n return ml_z_normalize(bigInt(z1).abs());\n}\n\n//external logand: t -> t -> t\n//Provides: ml_z_logand const\n//Requires: bigInt, ml_z_normalize\nfunction ml_z_logand(z1, z2) {\n return ml_z_normalize(bigInt(z1).and(bigInt(z2)));\n}\n\n//external logor: t -> t -> t\n//Provides: ml_z_logor const\n//Requires: bigInt, ml_z_normalize\nfunction ml_z_logor(z1, z2) {\n return ml_z_normalize(bigInt(z1).or(bigInt(z2)));\n}\n\n//external logxor: t -> t -> t\n//Provides: ml_z_logxor const\n//Requires: bigInt, ml_z_normalize\nfunction ml_z_logxor(z1, z2) {\n return ml_z_normalize(bigInt(z1).xor(bigInt(z2)));\n}\n\n//external lognot: t -> t\n//Provides: ml_z_lognot const\n//Requires: bigInt,ml_z_normalize\nfunction ml_z_lognot(z1) {\n return ml_z_normalize(bigInt(z1).not());\n}\n\n//external shift_left: t -> int -> t\n//Provides: ml_z_shift_left const\n//Requires: bigInt, ml_z_normalize\nfunction ml_z_shift_left(z1, amt) {\n return ml_z_normalize(bigInt(z1).shiftLeft(amt));\n}\n\n//external shift_right: t -> int -> t\n//Provides: ml_z_shift_right const\n//Requires: bigInt, ml_z_normalize\nfunction ml_z_shift_right(z1, amt) {\n return ml_z_normalize(bigInt(z1).shiftRight(amt));\n}\n\n//external shift_right_trunc: t -> int -> t\n//Provides: ml_z_shift_right_trunc const\n//Requires: bigInt, ml_z_div\nfunction ml_z_shift_right_trunc(z1, z2) {\n return ml_z_div(bigInt(z1), bigInt(2).pow(z2))\n}\n\n//external of_int: int -> t\n//Provides: ml_z_of_int const\n//Requires: bigInt\nfunction ml_z_of_int(i) {\n return i | 0;\n}\n\n//external of_int32: int32 -> t\n//Provides: ml_z_of_int32 const\n//Requires: ml_z_of_int\nfunction ml_z_of_int32(i32) {\n return ml_z_of_int(i32);\n}\n\n//external of_nativeint: nativeint -> t\n//Provides: ml_z_of_nativeint const\n//Requires: ml_z_of_int\nfunction ml_z_of_nativeint(z) {\n return ml_z_of_int(z)\n}\n\n//external of_int64: int64 -> t\n//Provides: ml_z_of_int64 const\n//Requires: bigInt, caml_int64_compare, caml_int64_neg, ml_z_normalize\n//Requires: caml_int64_create_lo_hi,caml_int64_hi32,caml_int64_lo32\nfunction ml_z_of_int64(i64) {\n var neg = false;\n if(caml_int64_compare(i64, caml_int64_create_lo_hi(0,0)) < 0) {\n neg = true;\n i64 = caml_int64_neg(i64)\n }\n var lo = caml_int64_lo32(i64) >>> 0;\n var hi = caml_int64_hi32(i64) >>> 0;\n var x = bigInt(lo).add(bigInt(hi).shiftLeft(32));\n if(neg) { x = x.negate() };\n return ml_z_normalize(x)\n}\n\n//external of_float: float -> t\n//Provides: ml_z_of_float\n//Requires: bigInt, caml_raise_constant, caml_named_value, ml_z_normalize\nfunction ml_z_of_float(f1) {\n if(f1 == Infinity || f1 == -Infinity || f1 != f1)\n caml_raise_constant(caml_named_value(\"ml_z_overflow\"));\n return ml_z_normalize(bigInt(f1<0?Math.ceil(f1):Math.floor(f1)));\n}\n\n//external to_int: t -> int\n//Provides: ml_z_to_int\n//Requires: bigInt, caml_raise_constant, caml_named_value\nfunction ml_z_to_int(z1) {\n if (z1 == (z1 | 0)) return z1 | 0;\n caml_raise_constant(caml_named_value(\"ml_z_overflow\"));\n}\n\n//external to_int32: t -> int32\n//Provides: ml_z_to_int32\n//Requires: ml_z_to_int\nfunction ml_z_to_int32(z1) { return ml_z_to_int(z1) }\n\n//external to_int64: t -> int64\n//Provides: ml_z_to_int64\n//Requires: bigInt, ml_z_fits_int64, caml_raise_constant, caml_named_value\n//Requires: caml_int64_create_lo_hi\nfunction ml_z_to_int64(z1) {\n z1 = bigInt(z1)\n if(!ml_z_fits_int64(z1)) {\n caml_raise_constant(caml_named_value(\"ml_z_overflow\"));\n }\n var mask = bigInt(0xffffffff)\n var lo = z1.and(mask).toJSNumber();\n var hi = z1.shiftRight(32).and(mask).toJSNumber();\n var x = caml_int64_create_lo_hi(lo, hi);\n return x;\n}\n\n//external testbit: t -> bool\n//Provides: ml_z_testbit\n//Requires: bigInt\nfunction ml_z_testbit(z,pos){\n z = bigInt(z);\n return (z.shiftRight(pos).and(bigInt(1)).toJSNumber())|0;\n}\n\n//external to_nativeint: t -> nativeint\n//Provides: ml_z_to_nativeint\n//Requires: ml_z_to_int\nfunction ml_z_to_nativeint(z1) { return ml_z_to_int(z1) }\n\n//external format: string -> t -> string\n//Provides: ml_z_format \n//Requires: bigInt\n//Requires: caml_jsbytes_of_string, caml_failwith, caml_string_of_jsbytes, ml_z_normalize\nfunction ml_z_format(fmt, z1) {\n z1 = bigInt(z1);\n var fmt = caml_jsbytes_of_string(fmt);\n // https://github.com/ocaml/Zarith/blob/d0555d451ce295c4497f24a8d9993f8dd23097df/z.mlip#L297\n var base = 10;\n var cas = 0;\n var width = 0;\n var alt = 0;\n var dir = 0;\n var sign = '';\n var pad = ' ';\n var idx = 0;\n var prefix=\"\";\n while(fmt[idx] == '%') idx++;\n for(;; idx++) {\n if(fmt[idx] == '#') alt = 1;\n else if (fmt[idx] == '0') pad = '0';\n else if (fmt[idx] == '-') dir = 1;\n else if (fmt[idx] == ' ' || fmt[idx] == '+') sign = fmt[idx];\n else break;\n }\n if(z1.lt(bigInt(0))){sign = '-';z1 = z1.negate()};\n for(;fmt[idx]>='0' && fmt[idx] <='9';idx++)\n width=10*width + (+fmt[idx]);\n switch(fmt[idx]){\n case 'i': case 'd': case 'u': break;\n case 'b': base = 2; if(alt) prefix = \"0b\"; break;\n case 'o': base = 8; if(alt) prefix = \"0o\"; break;\n case 'x': base = 16; if(alt) prefix = \"0x\"; break;\n case 'X': base = 16; if(alt) prefix = \"0X\"; cas = 1; break;\n default:\n caml_failwith(\"Unsupported format '\" + fmt + \"'\");\n }\n if (dir) pad = ' ';\n var res = z1.toString(base);\n if (cas === 1) {\n res = res.toUpperCase();\n }\n var size = res.length;\n if (pad == ' ') {\n if(dir) {\n res = sign + prefix + res;\n for(;res.length= 48 && code <= 57) return code - 48;\n if(code >= 97 && code <= 102) return code - 97 + 10;\n if(code >= 65 && code <= 70) return code - 65 + 10;\n }\n var i = 0;\n if(s[i] == '-') i++;\n for( ; i < s.length ; i++){\n var c = digit(s.charCodeAt(i));\n if(c == undefined || c >= base)\n caml_invalid_argument(\"Z.of_substring_base: invalid digit\");\n }\n return ml_z_normalize(bigInt(s, base));\n \n}\n\n//external of_substring_base: int -> string -> pos:int -> len:int -> t\n//Provides: ml_z_of_substring_base\n//Requires: jsoo_z_of_js_string_base, caml_jsbytes_of_string, caml_invalid_argument, caml_ml_string_length\nfunction ml_z_of_substring_base(base, s, pos, len) {\n s = caml_jsbytes_of_string(s);\n if(pos != 0 || len != s.length) {\n if (s.length - pos < len) {\n caml_invalid_argument(\"Z.of_substring_base: invalid offset or length\");\n }\n s = s.slice(pos,pos+len);\n }\n return jsoo_z_of_js_string_base(base, s);\n}\n\n//external compare: t -> t -> int\n//Provides: ml_z_compare const\n//Requires: bigInt\nfunction ml_z_compare(z1, z2) {\n return bigInt(z1).compare(bigInt(z2));\n}\n\n//external equal: t -> t -> bool\n//Provides: ml_z_equal const\n//Requires: bigInt\nfunction ml_z_equal(z1, z2) {\n return bigInt(z1).equals(bigInt(z2));\n}\n\n//external sign: t -> int\n//Provides: ml_z_sign const\n//Requires: bigInt\nfunction ml_z_sign(z1) {\n return bigInt(z1).compare(bigInt.zero);\n}\n\n//external gcd: t -> t -> t\n//Provides: ml_z_gcd\n//Requires: bigInt, ml_z_normalize\nfunction ml_z_gcd(z1, z2) {\n return ml_z_normalize(bigInt.gcd(bigInt(z1), bigInt(z2)).abs());\n}\n\n//external numbits: t -> int\n//Provides: ml_z_numbits const\n//Requires: bigInt\nfunction ml_z_numbits(z1) {\n z1 = bigInt(z1).abs();\n var n = 0;\n var upperBound = bigInt.one;\n while (upperBound.leq(z1)) {\n n += 1;\n upperBound = upperBound.multiply(2);\n }\n return n; // 2^{n-1} <= |x| < 2^n\n}\n\n//external fits_int: t -> bool\n//Provides: ml_z_fits_int const\n//Requires: bigInt\nfunction ml_z_fits_int(z1) {\n if(z1 == (z1 | 0)) return 1;\n else return 0;\n}\n\n//external fits_int32: t -> bool\n//Provides: ml_z_fits_int32\n//Requires: ml_z_fits_int\nfunction ml_z_fits_int32(z1) {\n return ml_z_fits_int(z1);\n}\n\n//external fits_int64: t -> bool\n//Provides: ml_z_fits_int64\n//Requires: bigInt\nfunction ml_z_fits_int64(z1) {\n z1 = bigInt(z1)\n if (z1.compare(bigInt(\"9223372036854775807\")) <= 0 && z1.compare(bigInt(\"-9223372036854775808\")) >= 0)\n return 1\n else\n return 0\n}\n\n//external fits_nativeint: t -> bool\n//Provides: ml_z_fits_nativeint\n//Requires: ml_z_fits_int\nfunction ml_z_fits_nativeint(z1) {\n return ml_z_fits_int(z1);\n}\n\n//external powm: t -> t -> t -> t\n//Provides: ml_z_powm\n//Requires: bigInt, ml_z_normalize, ml_z_invert, caml_raise_zero_divide\nfunction ml_z_powm(z1, z2, z3) {\n var zero = bigInt(0);\n var one = bigInt(1);\n z1 = bigInt(z1);\n z2 = bigInt(z2);\n z3 = bigInt(z3);\n if(z3.equals(zero)) caml_raise_zero_divide();\n if(z3.abs().equals(one)) return 0;\n if(z2.equals(zero)) return 1;\n if(z2.lt(0)) {\n var inv = bigInt(ml_z_invert(z1, z3));\n var r = inv.modPow(z2.negate(), z3);\n if(r.lt(zero)) r = r.add(z3.abs());\n return ml_z_normalize(r);\n } else {\n var r = bigInt(z1).modPow(z2, z3);\n if(r.lt(zero)) r = r.add(z3.abs());\n return ml_z_normalize(r);\n }\n}\n\n//external pown: t -> t -> t\n//Provides: ml_z_pow\n//Requires: bigInt, caml_failwith, ml_z_normalize, caml_invalid_argument\nfunction ml_z_pow(z1, i1) {\n i1 = bigInt(i1);\n if (i1.lt(bigInt(0))) {\n caml_invalid_argument(\"Z.pow: exponent must be nonnegative\");\n }\n return ml_z_normalize(bigInt(z1).pow(i1));\n}\n\n//external hash: t -> int\n//Provides: ml_z_hash const\n//Requires: bigInt, caml_hash_mix_int\nfunction ml_z_hash(z1) {\n var a = bigInt(z1).toArray(Math.pow(2, 32));\n var acc = 0;\n for (var i = 0; i < a.value.length; i++) {\n acc = caml_hash_mix_int(acc, a.value[i]);\n }\n if(a.value.length % 2 != 0) {\n acc = caml_hash_mix_int(acc, 0);\n }\n if(a.isNegative){\n acc = acc + 1\n }\n return acc | 0\n}\n\n//external to_bits: t -> string\n//Provides: ml_z_to_bits const\n//Requires: caml_string_of_jsbytes, caml_str_repeat, bigInt\nfunction ml_z_to_bits(z1) {\n z1 = bigInt(z1).abs();\n var res = \"\";\n while(!z1.equals(bigInt(0))){\n res += String.fromCharCode(z1.mod(bigInt(256)));\n z1 = z1.divide(bigInt(256));\n }\n while(res.length % 4 != 0){\n res += String.fromCharCode(0);\n }\n return caml_string_of_jsbytes(res);\n}\n\n//external of_bits: string -> t\n//Provides: ml_z_of_bits const\n//Requires: caml_string_unsafe_get, caml_ml_string_length, bigInt, ml_z_normalize\nfunction ml_z_of_bits(z1) {\n var r = bigInt.zero\n var base1 = bigInt(256);\n var base = bigInt.one;\n for(var i = 0; i < caml_ml_string_length(z1); i++){\n var d = caml_string_unsafe_get(z1,i);\n r = bigInt(base).multiply(d).add(r);\n base = bigInt(base).multiply(base1);\n }\n return ml_z_normalize(r);\n}\n\n//external powm_sec: t -> t -> t -> t\n//Provides: ml_z_powm_sec\n//Requires: bigInt, caml_failwith, ml_z_powm, caml_invalid_argument\nfunction ml_z_powm_sec(z1, z2, z3) {\n z3 = bigInt(z3).abs();\n // powm_sec requires that the exponent be positive\n var one = bigInt(1);\n if (bigInt(z2).lt(one)) {\n caml_invalid_argument(\"Z.powm_sec: exponent must be positive\");\n }\n if (!bigInt(z3).and(one).equals(one)) {\n caml_invalid_argument(\"Z.powm_sec: modulus must be odd\");\n }\n return ml_z_powm(z1, z2, z3)\n}\n\n//external root: t -> int -> t\n//Provides: ml_z_root\n//Requires: ml_z_pow, bigInt, ml_z_normalize, caml_invalid_argument\nfunction ml_z_root(z, i) {\n var zero = bigInt(0);\n var one = bigInt(1);\n z = bigInt(z);\n\n if (i % 2 === 0 && z.lt(zero)) {\n caml_invalid_argument(\"Z.root: even root of a negative number\");\n }\n\n if (z.equals(zero) || z.equals(one)) {\n return ml_z_normalize(z);\n }\n\n var start = zero;\n var end = z;\n var ans = null;\n\n var two = bigInt(2);\n\n while (start.leq(end))\n {\n var mid = start.add(end).divide(two);\n var po = mid.pow(i);\n if (po.equals(z)) {\n return ml_z_normalize(mid);\n } else if (po.lt(z)) {\n start = mid.next();\n ans = mid;\n } else {\n end = mid.prev();\n }\n }\n return ml_z_normalize(ans);\n}\n\n//external invert: t -> t -> t\n//Provides: ml_z_invert\n//Requires: bigInt, caml_raise_zero_divide, ml_z_gcdext_intern, ml_z_normalize\nfunction ml_z_invert(a, n) {\n // Because [a.modInv(n)] produces different results for edge cases,\n // we wrote our own implementation based on gcdext_intern.\n a = bigInt(a);\n n = bigInt(n);\n var zero = bigInt(0);\n var one = bigInt(1);\n if(n.abs().equals(one))\n return 0;\n if (n.equals(zero) && a.abs().equals(one)) {\n return a;\n }\n if (n.equals(zero) || a.equals(zero)) {\n caml_raise_zero_divide();\n }\n var x = ml_z_gcdext_intern(a, n);\n var r = bigInt(x[2]);\n var tmp = bigInt(a).multiply(r).mod(n);\n if(tmp.lt(zero)) tmp = tmp.add(n.abs());\n if(r.lt(zero)) r = r.add(n.abs());\n if(tmp.equals(one)) {\n return ml_z_normalize(r);\n }\n caml_raise_zero_divide();\n}\n\n//external perfect_power: t -> bool\n//Provides: ml_z_perfect_power\n//Requires: bigInt, caml_failwith, ml_z_numbits, ml_z_root, ml_z_pow\nfunction ml_z_perfect_power(z) {\n // Return true if op is a perfect power, i.e., if there exist integers a and\n // b, with b > 1, such that op = a^b.\n // Otherwise false.\n z = bigInt(z);\n var zero = bigInt(0);\n var one = bigInt(1);\n\n if (z.equals(zero) || z.equals(one) || z.equals(one.negate())) {\n return 1;\n }\n var log2z = ml_z_numbits(z.abs());\n for (var b = 2; b <= log2z; b++) {\n if(z.lt(zero) && b % 2 == 0) continue;\n var zp = z.abs();\n var p = bigInt(ml_z_root(zp, b));\n if(z.lt(zero)) p = p.negate();\n var r = bigInt(ml_z_pow(p, b));\n if (z.equals(r)) {\n return 1;\n }\n }\n return 0;\n}\n\n//external perfect_square: t -> bool\n//Provides: ml_z_perfect_square\n//Requires: bigInt, ml_z_root\nfunction ml_z_perfect_square(z) {\n z = bigInt(z);\n if (z.lt(bigInt(0))) {\n return 0;\n }\n var root = bigInt(ml_z_root(z, 2));\n if (root.multiply(root).eq(z)) {\n return 1;\n }\n else {\n return 0\n };\n}\n\n//external probab_prime: t -> int -> int\n//Provides: ml_z_probab_prime const\n//Requires: bigInt\nfunction ml_z_probab_prime(z, i) {\n if (bigInt(z).isProbablePrime(i)) {\n return 1;\n } else {\n return 0;\n }\n}\n\n//external nextprime: t -> t\n//Provides: ml_z_nextprime const\n//Requires: bigInt, ml_z_normalize\nfunction ml_z_nextprime(z1) {\n // Interestingly, the zarith next_prime only returns \n // probabalistic primes. We do the same, with the \n // same probablistic parameter of 25.\n // https://fossies.org/dox/gmp-6.1.2/mpz_2nextprime_8c_source.html\n \n z1 = bigInt(z1)\n var one = bigInt(1);\n var two = bigInt(2);\n\n if (z1.lt(one) || z1.equals(one)) {\n return 2;\n }\n\n if (z1.and(one).equals(one)) {\n z1 = z1.add(two);\n } else {\n z1 = z1.add(one);\n }\n\n while (true) {\n if (z1.isProbablePrime(25)) {\n return ml_z_normalize(z1);\n } else {\n z1 = z1.add(two)\n }\n }\n}\n\n//external extract: t -> int -> int -> t\n//Provides: ml_z_extract\n//Requires: caml_failwith, bigInt, ml_z_normalize\nfunction ml_z_extract(z1, pos, len) {\n z1 = bigInt(z1);\n return ml_z_normalize(z1.shiftRight(pos).and(bigInt(2).pow(len).subtract(1)));\n}\n\n//external gcdext_intern: t -> t -> (t * t * bool)\n//Provides: ml_z_gcdext_intern\n//Requires: bigInt, caml_raise_zero_divide, ml_z_normalize\nfunction ml_z_gcdext_intern(z1, z2) {\n z1 = bigInt(z1);\n z2 = bigInt(z2);\n var gcd = bigInt.gcd(z1,z2);\n var a = z1;\n var b = z2;\n var x = bigInt(0);\n var lastx = bigInt(1);\n var y = bigInt(1);\n var lasty = bigInt(1);\n var q, t, r;\n if(z1.equals(bigInt(0))) {\n caml_raise_zero_divide();\n }\n while(!b.equals(bigInt(0))) {\n q = a.divide(b);\n r = a.subtract(q.multiply(b));\n t = x;\n x = lastx.subtract(q.multiply(x));\n lastx = t;\n t = y;\n y = lasty.subtract(q.multiply(y));\n lasty = t;\n a = b;\n b = r;\n }\n if(a.lt(bigInt(0)))\n return [0,ml_z_normalize(a.negate()),ml_z_normalize(lastx.negate()),1]\n else\n return [0,ml_z_normalize(a),ml_z_normalize(lastx),1]\n}\n\n//external sqrt: t -> t\n//Provides: ml_z_sqrt\n//Requires: bigInt, ml_z_root, caml_invalid_argument\nfunction ml_z_sqrt(z1) {\n var z = bigInt(z1);\n var zero = bigInt(0);\n if (z.lt(zero)) {\n caml_invalid_argument(\"Z.sqrt: square root of a negative number\");\n }\n return ml_z_root(z, 2);\n}\n\n//external sqrt_rem: t -> (t * t)\n//Provides: ml_z_sqrt_rem\n//Requires: bigInt, ml_z_root, caml_invalid_argument, ml_z_normalize\nfunction ml_z_sqrt_rem(z) {\n z = bigInt(z);\n var zero = bigInt(0);\n if (z.lt(zero)) {\n caml_invalid_argument(\"Z.sqrt_rem: square root of a negative number\");\n }\n var root = bigInt(ml_z_root(z, 2));\n var mul = root.multiply(root);\n var diff = z.subtract(mul);\n return [0, ml_z_normalize(root), ml_z_normalize(diff)]\n}\n\n//external trailing_zeros: t -> int\n//Provides: ml_z_trailing_zeros const\n//Requires: bigInt\nfunction ml_z_trailing_zeros(z) {\n z = bigInt(z).abs();\n var zero = bigInt(0);\n var one = bigInt(1);\n if (z.equals(zero)) {\n // max_int in 32bit\n return 0x7fffffff;\n }\n var i = 0\n z = z.xor(z.prev()).shiftRight(1);\n for (i = 0; !z.equals(bigInt.zero); i++) {\n z = z.shiftRight(1);\n }\n return i;\n}\n\n//external popcount: t -> int\n//Provides: ml_z_popcount\n//Requires: bigInt, caml_raise_constant, caml_named_value\nfunction ml_z_popcount(z) {\n z = bigInt(z);\n var zero = bigInt(0);\n var one = bigInt(1);\n if (z.lt(zero)) {\n caml_raise_constant(caml_named_value(\"ml_z_overflow\"));\n }\n var i;\n for (i = 0; !z.equals(zero); i++) {\n z = z.and(z.prev());\n }\n if(i != (i|0)) caml_raise_constant(caml_named_value(\"ml_z_overflow\"));\n return i|0;\n}\n\n//external hamdist: t -> t -> int\n//Provides: ml_z_hamdist\n//Requires: bigInt, ml_z_popcount, caml_invalid_argument, caml_raise_constant, caml_named_value\nfunction ml_z_hamdist(z1, z2) {\n if(bigInt(z1).isNegative() != bigInt(z2).isNegative ()){\n caml_raise_constant(caml_named_value(\"ml_z_overflow\"));\n }\n if((z1 != (z1 | 0) || z2 != (z2 | 0)) && (bigInt(z1).isNegative() || bigInt(z2).isNegative ())){\n caml_invalid_argument(\"Z.hamdist: negative arguments\");\n }\n return ml_z_popcount(bigInt(z1).xor(bigInt(z2)));\n}\n\n//external size: t -> int\n//Provides: ml_z_size const\n//Requires: bigInt\nfunction ml_z_size(z1) {\n // Claim to be a 32-bit architecture.\n return bigInt(z1).toArray(Math.pow(2, 32)).value.length;\n}\n\n//external divexact: t -> t -> t\n//Provides: ml_z_divexact\n//Requires: bigInt, ml_z_div\nfunction ml_z_divexact(z1, z2) {\n return ml_z_div(z1, z2);\n}\n\n//Provides: caml_zarith_marshal\n//Requires: bigInt\nfunction caml_zarith_marshal(writer, v, sz) {\n v = bigInt(v);\n var bits = v.toArray(Math.pow(2, 32));\n writer.write(8, bits.isNegative ?1 : 0);\n var block = bits.value.length;\n var len = block * 4;\n writer.write(32, len);\n for(var i = block - 1; i >= 0; i --){\n writer.write(8, (bits.value[i] >>> 0 ) & 0xff);\n writer.write(8, (bits.value[i] >>> 8 ) & 0xff);\n writer.write(8, (bits.value[i] >>> 16) & 0xff);\n writer.write(8, (bits.value[i] >>> 24) & 0xff);\n }\n sz[0] = 4 * (1 + (((len + 3) / 4) | 0));\n sz[1] = 8 * (1 + (((len + 7) / 8) | 0));\n}\n\n//Provides: caml_zarith_unmarshal\n//Requires: bigInt, caml_failwith, ml_z_normalize\nfunction caml_zarith_unmarshal(reader, sz) {\n var negate;\n switch(reader.read8u ()) {\n case 1: negate = true; break;\n case 0: negate = false; break;\n default: caml_failwith(\"input_value: z (malformed input)\");\n }\n var len = reader.read32u();\n var x = bigInt(0);\n for(var i = 0; i < len / 4; i++){\n var y = bigInt(reader.read8u());\n y = y.add((reader.read8u()) << 8);\n y = y.add((reader.read8u()) << 16);\n y = y.add(((reader.read8u()) << 24) >>> 0);\n x = y.shiftLeft(i * 32).add(x);\n }\n if(negate) x = x.negate();\n sz[0] = len + 4;\n return ml_z_normalize(x)\n}\n","///////// TIME_NOW\n\n//Provides: time_now_nanoseconds_since_unix_epoch_or_zero\n//Requires: caml_int64_mul, caml_int64_of_float, caml_int64_of_int32\nvar ms_to_nano = caml_int64_of_int32(1000*1000);\nfunction time_now_nanoseconds_since_unix_epoch_or_zero(){\n var ms = Date.now();\n // multiple by two - int63 integers are shifted to the left\n var ms_i63 = caml_int64_of_float(ms*2);\n return caml_int64_mul(ms_i63,ms_to_nano);\n}\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* Operations on internal representations of values *)\n\ntype t\n\ntype raw_data = nativeint\n\nexternal repr : 'a -> t = \"%identity\"\nexternal obj : t -> 'a = \"%identity\"\nexternal magic : 'a -> 'b = \"%identity\"\nexternal is_int : t -> bool = \"%obj_is_int\"\nlet [@inline always] is_block a = not (is_int a)\nexternal tag : t -> int = \"caml_obj_tag\" [@@noalloc]\nexternal set_tag : t -> int -> unit = \"caml_obj_set_tag\"\nexternal size : t -> int = \"%obj_size\"\nexternal reachable_words : t -> int = \"caml_obj_reachable_words\"\nexternal field : t -> int -> t = \"%obj_field\"\nexternal set_field : t -> int -> t -> unit = \"%obj_set_field\"\nexternal floatarray_get : floatarray -> int -> float = \"caml_floatarray_get\"\nexternal floatarray_set :\n floatarray -> int -> float -> unit = \"caml_floatarray_set\"\nlet [@inline always] double_field x i = floatarray_get (obj x : floatarray) i\nlet [@inline always] set_double_field x i v =\n floatarray_set (obj x : floatarray) i v\nexternal raw_field : t -> int -> raw_data = \"caml_obj_raw_field\"\nexternal set_raw_field : t -> int -> raw_data -> unit\n = \"caml_obj_set_raw_field\"\n\nexternal new_block : int -> int -> t = \"caml_obj_block\"\nexternal dup : t -> t = \"caml_obj_dup\"\nexternal truncate : t -> int -> unit = \"caml_obj_truncate\"\nexternal add_offset : t -> Int32.t -> t = \"caml_obj_add_offset\"\nexternal with_tag : int -> t -> t = \"caml_obj_with_tag\"\n\nlet first_non_constant_constructor_tag = 0\nlet last_non_constant_constructor_tag = 245\n\nlet lazy_tag = 246\nlet closure_tag = 247\nlet object_tag = 248\nlet infix_tag = 249\nlet forward_tag = 250\n\nlet no_scan_tag = 251\n\nlet abstract_tag = 251\nlet string_tag = 252\nlet double_tag = 253\nlet double_array_tag = 254\nlet custom_tag = 255\nlet final_tag = custom_tag\n\n\nlet int_tag = 1000\nlet out_of_heap_tag = 1001\nlet unaligned_tag = 1002\n\nmodule Closure = struct\n type info = {\n arity: int;\n start_env: int;\n }\n\n let info_of_raw (info : nativeint) =\n let open Nativeint in\n let arity =\n (* signed: negative for tupled functions *)\n if Sys.word_size = 64 then\n to_int (shift_right info 56)\n else\n to_int (shift_right info 24)\n in\n let start_env =\n (* start_env is unsigned, but we know it can always fit an OCaml\n integer so we use [to_int] instead of [unsigned_to_int]. *)\n to_int (shift_right_logical (shift_left info 8) 9) in\n { arity; start_env }\n\n (* note: we expect a closure, not an infix pointer *)\n let info (obj : t) =\n assert (tag obj = closure_tag);\n info_of_raw (raw_field obj 1)\nend\n\nmodule Extension_constructor =\nstruct\n type t = extension_constructor\n let of_val x =\n let x = repr x in\n let slot =\n if (is_block x) && (tag x) <> object_tag && (size x) >= 1 then field x 0\n else x\n in\n let name =\n if (is_block slot) && (tag slot) = object_tag then field slot 0\n else invalid_arg \"Obj.extension_constructor\"\n in\n if (tag name) = string_tag then (obj slot : t)\n else invalid_arg \"Obj.extension_constructor\"\n\n let [@inline always] name (slot : t) =\n (obj (field (repr slot) 0) : string)\n\n let [@inline always] id (slot : t) =\n (obj (field (repr slot) 1) : int)\nend\n\nlet extension_constructor = Extension_constructor.of_val\nlet extension_name = Extension_constructor.name\nlet extension_id = Extension_constructor.id\n\nmodule Ephemeron = struct\n type obj_t = t\n\n type t (** ephemeron *)\n\n (** To change in sync with weak.h *)\n let additional_values = 2\n let max_ephe_length = Sys.max_array_length - additional_values\n\n external create : int -> t = \"caml_ephe_create\";;\n let create l =\n if not (0 <= l && l <= max_ephe_length) then\n invalid_arg \"Obj.Ephemeron.create\";\n create l\n\n let length x = size(repr x) - additional_values\n\n let raise_if_invalid_offset e o msg =\n if not (0 <= o && o < length e) then\n invalid_arg msg\n\n external get_key: t -> int -> obj_t option = \"caml_ephe_get_key\"\n let get_key e o =\n raise_if_invalid_offset e o \"Obj.Ephemeron.get_key\";\n get_key e o\n\n external get_key_copy: t -> int -> obj_t option = \"caml_ephe_get_key_copy\"\n let get_key_copy e o =\n raise_if_invalid_offset e o \"Obj.Ephemeron.get_key_copy\";\n get_key_copy e o\n\n external set_key: t -> int -> obj_t -> unit = \"caml_ephe_set_key\"\n let set_key e o x =\n raise_if_invalid_offset e o \"Obj.Ephemeron.set_key\";\n set_key e o x\n\n external unset_key: t -> int -> unit = \"caml_ephe_unset_key\"\n let unset_key e o =\n raise_if_invalid_offset e o \"Obj.Ephemeron.unset_key\";\n unset_key e o\n\n external check_key: t -> int -> bool = \"caml_ephe_check_key\"\n let check_key e o =\n raise_if_invalid_offset e o \"Obj.Ephemeron.check_key\";\n check_key e o\n\n external blit_key : t -> int -> t -> int -> int -> unit\n = \"caml_ephe_blit_key\"\n\n let blit_key e1 o1 e2 o2 l =\n if l < 0 || o1 < 0 || o1 > length e1 - l\n || o2 < 0 || o2 > length e2 - l\n then invalid_arg \"Obj.Ephemeron.blit_key\"\n else if l <> 0 then blit_key e1 o1 e2 o2 l\n\n external get_data: t -> obj_t option = \"caml_ephe_get_data\"\n external get_data_copy: t -> obj_t option = \"caml_ephe_get_data_copy\"\n external set_data: t -> obj_t -> unit = \"caml_ephe_set_data\"\n external unset_data: t -> unit = \"caml_ephe_unset_data\"\n external check_data: t -> bool = \"caml_ephe_check_data\"\n external blit_data : t -> t -> unit = \"caml_ephe_blit_data\"\n\nend\n","open Core_kernel\nopen Pickles_types\n\ntype 'n t = (Int64.t, 'n) Vector.t [@@deriving sexp_of]\n\nlet to_bits t =\n Vector.to_list t\n |> List.concat_map ~f:(fun n ->\n let test_bit i = Int64.(shift_right n i land one = one) in\n List.init 64 ~f:test_bit )\n\nmodule Hex64 = struct\n module T = struct\n type t = Int64.t [@@deriving yojson]\n\n (* Modify the [of_yojson] handler to add a case for [`String].\n This isn't necessary when using Yojson's parser, because it will\n correctly infer [`Intlit] for any possible value that appears here.\n However, if this json was constructed from a GraphQL query then it will\n be encoded as a [`String] and the conversion will fail unless we handle\n it ourselves.\n *)\n let of_yojson yojson =\n match yojson with\n | `String x -> (\n try Result.Ok (Int64.of_string x)\n with _ -> Result.Error \"Constant.Make.Hex64.t\" )\n | _ ->\n of_yojson yojson\n\n include (Int64 : module type of Int64 with type t := t)\n\n let to_hex t =\n let lo = t land of_int 0xffffff in\n let mi = (t lsr 24) land of_int 0xffffff in\n let hi = (t lsr 48) land of_int 0xffff in\n sprintf \"%04x%06x%06x\" (to_int_exn hi) (to_int_exn mi) (to_int_exn lo)\n\n let of_hex h =\n let f s = Hex.of_string (\"0x\" ^ s) in\n let hi, lo = String.(f (sub h ~pos:0 ~len:8), f (sub h ~pos:8 ~len:8)) in\n (hi lsl 32) lor lo\n\n let%test_unit \"int64 hex\" =\n Quickcheck.test (Int64.gen_incl zero max_value) ~f:(fun x ->\n assert (equal x (of_hex (to_hex x))) )\n\n let sexp_of_t = Fn.compose String.sexp_of_t to_hex\n\n let t_of_sexp = Fn.compose of_hex String.t_of_sexp\n end\n\n include T\n\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n type t = (T.t[@version_asserted])\n [@@deriving compare, sexp, yojson, hash, equal]\n\n let to_latest = Fn.id\n end\n end]\nend\n\nmodule Make (N : Vector.Nat_intf) = struct\n module A = Vector.With_length (N)\n\n let length = 64 * Nat.to_int N.n\n\n type t = Hex64.t A.t [@@deriving sexp, compare, yojson, hash, equal]\n\n let to_bits = to_bits\n\n let of_bits bits =\n let pack =\n List.foldi ~init:Int64.zero ~f:(fun i acc b ->\n if b then Int64.(acc lor shift_left one i) else acc )\n in\n let bits =\n List.groupi ~break:(fun i _ _ -> i mod 64 = 0) bits |> List.map ~f:pack\n in\n let n = List.length bits in\n let n_expected = Nat.to_int N.n in\n assert (n <= n_expected) ;\n let bits = bits @ List.init (n_expected - n) ~f:(fun _ -> Int64.zero) in\n Vector.of_list_and_length_exn bits N.n\n\n let of_tick_field x =\n of_bits (List.take (Backend.Tick.Field.to_bits x) length)\n\n let of_tock_field x =\n of_bits (List.take (Backend.Tock.Field.to_bits x) length)\n\n let to_tick_field t = Backend.Tick.Field.of_bits (to_bits t)\n\n let to_tock_field t = Backend.Tock.Field.of_bits (to_bits t)\n\n let dummy : t = Vector.init N.n ~f:(fun _ -> Int64.one)\n\n let zero : t = Vector.init N.n ~f:(fun _ -> Int64.zero)\nend\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* Module [Int64]: 64-bit integers *)\n\nexternal neg : int64 -> int64 = \"%int64_neg\"\nexternal add : int64 -> int64 -> int64 = \"%int64_add\"\nexternal sub : int64 -> int64 -> int64 = \"%int64_sub\"\nexternal mul : int64 -> int64 -> int64 = \"%int64_mul\"\nexternal div : int64 -> int64 -> int64 = \"%int64_div\"\nexternal rem : int64 -> int64 -> int64 = \"%int64_mod\"\nexternal logand : int64 -> int64 -> int64 = \"%int64_and\"\nexternal logor : int64 -> int64 -> int64 = \"%int64_or\"\nexternal logxor : int64 -> int64 -> int64 = \"%int64_xor\"\nexternal shift_left : int64 -> int -> int64 = \"%int64_lsl\"\nexternal shift_right : int64 -> int -> int64 = \"%int64_asr\"\nexternal shift_right_logical : int64 -> int -> int64 = \"%int64_lsr\"\nexternal of_int : int -> int64 = \"%int64_of_int\"\nexternal to_int : int64 -> int = \"%int64_to_int\"\nexternal of_float : float -> int64\n = \"caml_int64_of_float\" \"caml_int64_of_float_unboxed\"\n [@@unboxed] [@@noalloc]\nexternal to_float : int64 -> float\n = \"caml_int64_to_float\" \"caml_int64_to_float_unboxed\"\n [@@unboxed] [@@noalloc]\nexternal of_int32 : int32 -> int64 = \"%int64_of_int32\"\nexternal to_int32 : int64 -> int32 = \"%int64_to_int32\"\nexternal of_nativeint : nativeint -> int64 = \"%int64_of_nativeint\"\nexternal to_nativeint : int64 -> nativeint = \"%int64_to_nativeint\"\n\nlet zero = 0L\nlet one = 1L\nlet minus_one = -1L\nlet succ n = add n 1L\nlet pred n = sub n 1L\nlet abs n = if n >= 0L then n else neg n\nlet min_int = 0x8000000000000000L\nlet max_int = 0x7FFFFFFFFFFFFFFFL\nlet lognot n = logxor n (-1L)\n\nlet unsigned_to_int =\n let max_int = of_int Stdlib.max_int in\n fun n ->\n if compare zero n <= 0 && compare n max_int <= 0 then\n Some (to_int n)\n else\n None\n\nexternal format : string -> int64 -> string = \"caml_int64_format\"\nlet to_string n = format \"%d\" n\n\nexternal of_string : string -> int64 = \"caml_int64_of_string\"\n\nlet of_string_opt s =\n (* TODO: expose a non-raising primitive directly. *)\n try Some (of_string s)\n with Failure _ -> None\n\n\n\nexternal bits_of_float : float -> int64\n = \"caml_int64_bits_of_float\" \"caml_int64_bits_of_float_unboxed\"\n [@@unboxed] [@@noalloc]\nexternal float_of_bits : int64 -> float\n = \"caml_int64_float_of_bits\" \"caml_int64_float_of_bits_unboxed\"\n [@@unboxed] [@@noalloc]\n\ntype t = int64\n\nlet compare (x: t) (y: t) = Stdlib.compare x y\nlet equal (x: t) (y: t) = compare x y = 0\n\nlet unsigned_compare n m =\n compare (sub n min_int) (sub m min_int)\n\nlet min x y : t = if x <= y then x else y\nlet max x y : t = if x >= y then x else y\n\n(* Unsigned division from signed division of the same\n bitness. See Warren Jr., Henry S. (2013). Hacker's Delight (2 ed.), Sec 9-3.\n*)\nlet unsigned_div n d =\n if d < zero then\n if unsigned_compare n d < 0 then zero else one\n else\n let q = shift_left (div (shift_right_logical n 1) d) 1 in\n let r = sub n (mul q d) in\n if unsigned_compare r d >= 0 then succ q else q\n\nlet unsigned_rem n d =\n sub n (mul (unsigned_div n d) d)\n","open! Import\nmodule Array = Array0\nmodule Int = Int0\nmodule Char = Char0\n\n(* Unfortunately, because the standard library does not expose\n [Caml.Random.State.default], we have to construct our own. We then build the\n [Caml.Random.int], [Caml.Random.bool] functions and friends using that default state in\n exactly the same way as the standard library.\n\n One other trickiness is that we need access to the unexposed [Caml.Random.State.assign]\n function, which accesses the unexposed state representation. So, we copy the\n [State.repr] type definition and [assign] function to here from the standard library,\n and use [Obj.magic] to get access to the underlying implementation. *)\n\n(* Regression tests ought to be deterministic because that way anyone who breaks the test\n knows that it's their code that broke the test. If tests are nondeterministic, a test\n failure may instead happen because the test runner got unlucky and uncovered an\n existing bug in the code supposedly being \"protected\" by the test in question. *)\nlet forbid_nondeterminism_in_tests ~allow_in_tests =\n if am_testing\n then (\n match allow_in_tests with\n | Some true -> ()\n | None | Some false ->\n failwith\n \"initializing Random with a nondeterministic seed is forbidden in inline tests\")\n;;\n\nexternal random_seed : unit -> int array = \"caml_sys_random_seed\"\n\nlet random_seed ?allow_in_tests () =\n forbid_nondeterminism_in_tests ~allow_in_tests;\n random_seed ()\n;;\n\nmodule State = struct\n (* We allow laziness only for the definition of [default], below, which may lazily call\n [make_self_init]. For all other purposes, we create and use [t] eagerly. *)\n type t = Caml.Random.State.t Lazy.t\n\n let bits t = Caml.Random.State.bits (Lazy.force t)\n let bool t = Caml.Random.State.bool (Lazy.force t)\n let int t x = Caml.Random.State.int (Lazy.force t) x\n let int32 t x = Caml.Random.State.int32 (Lazy.force t) x\n let int64 t x = Caml.Random.State.int64 (Lazy.force t) x\n let nativeint t x = Caml.Random.State.nativeint (Lazy.force t) x\n let make seed = Lazy.from_val (Caml.Random.State.make seed)\n let copy t = Lazy.from_val (Caml.Random.State.copy (Lazy.force t))\n let char t = int t 256 |> Char.unsafe_of_int\n let ascii t = int t 128 |> Char.unsafe_of_int\n\n let make_self_init ?allow_in_tests () =\n forbid_nondeterminism_in_tests ~allow_in_tests;\n Lazy.from_val (Caml.Random.State.make_self_init ())\n ;;\n\n module Repr = struct\n type t =\n { st : int array\n ; mutable idx : int\n }\n\n let of_state : Caml.Random.State.t -> t = Caml.Obj.magic\n end\n\n let assign t1 t2 =\n let t1 = Repr.of_state (Lazy.force t1) in\n let t2 = Repr.of_state (Lazy.force t2) in\n Array.blit ~src:t2.st ~src_pos:0 ~dst:t1.st ~dst_pos:0 ~len:(Array.length t1.st);\n t1.idx <- t2.idx\n ;;\n\n let full_init t seed = assign t (make seed)\n\n let default =\n if am_testing\n then (\n (* We define Base's default random state as a copy of OCaml's default random state.\n This means that programs that use Base.Random will see the same sequence of\n random bits as if they had used Caml.Random. However, because [get_state] returns\n a copy, Base.Random and OCaml.Random are not using the same state. If a program\n used both, each of them would go through the same sequence of random bits. To\n avoid that, we reset OCaml's random state to a different seed, giving it a\n different sequence. *)\n let t = Caml.Random.get_state () in\n Caml.Random.init 137;\n Lazy.from_val t)\n else\n lazy\n (* Outside of tests, we initialize random state nondeterministically and lazily.\n We force the random initialization to be lazy so that we do not pay any cost\n for it in programs that do not use randomness. *)\n (Lazy.force (make_self_init ()))\n ;;\n\n let int_on_64bits t bound =\n if bound <= 0x3FFFFFFF (* (1 lsl 30) - 1 *)\n then int t bound\n else Caml.Int64.to_int (int64 t (Caml.Int64.of_int bound))\n ;;\n\n let int_on_32bits t bound =\n (* Not always true with the JavaScript backend. *)\n if bound <= 0x3FFFFFFF (* (1 lsl 30) - 1 *)\n then int t bound\n else Caml.Int32.to_int (int32 t (Caml.Int32.of_int bound))\n ;;\n\n let int =\n match Word_size.word_size with\n | W64 -> int_on_64bits\n | W32 -> int_on_32bits\n ;;\n\n let full_range_int64 =\n let open Caml.Int64 in\n let bits state = of_int (bits state) in\n fun state ->\n logxor\n (bits state)\n (logxor (shift_left (bits state) 30) (shift_left (bits state) 60))\n ;;\n\n let full_range_int32 =\n let open Caml.Int32 in\n let bits state = of_int (bits state) in\n fun state -> logxor (bits state) (shift_left (bits state) 30)\n ;;\n\n let full_range_int_on_64bits state = Caml.Int64.to_int (full_range_int64 state)\n let full_range_int_on_32bits state = Caml.Int32.to_int (full_range_int32 state)\n\n let full_range_int =\n match Word_size.word_size with\n | W64 -> full_range_int_on_64bits\n | W32 -> full_range_int_on_32bits\n ;;\n\n let full_range_nativeint_on_64bits state =\n Caml.Int64.to_nativeint (full_range_int64 state)\n ;;\n\n let full_range_nativeint_on_32bits state =\n Caml.Nativeint.of_int32 (full_range_int32 state)\n ;;\n\n let full_range_nativeint =\n match Word_size.word_size with\n | W64 -> full_range_nativeint_on_64bits\n | W32 -> full_range_nativeint_on_32bits\n ;;\n\n let raise_crossed_bounds name lower_bound upper_bound string_of_bound =\n Printf.failwithf\n \"Random.%s: crossed bounds [%s > %s]\"\n name\n (string_of_bound lower_bound)\n (string_of_bound upper_bound)\n ()\n [@@cold] [@@inline never] [@@local never] [@@specialise never]\n ;;\n\n let int_incl =\n let rec in_range state lo hi =\n let int = full_range_int state in\n if int >= lo && int <= hi then int else in_range state lo hi\n in\n fun state lo hi ->\n if lo > hi then raise_crossed_bounds \"int\" lo hi Int.to_string;\n let diff = hi - lo in\n if diff = Int.max_value\n then lo + (full_range_int state land Int.max_value)\n else if diff >= 0\n then lo + int state (Int.succ diff)\n else in_range state lo hi\n ;;\n\n let int32_incl =\n let open Int32_replace_polymorphic_compare in\n let rec in_range state lo hi =\n let int = full_range_int32 state in\n if int >= lo && int <= hi then int else in_range state lo hi\n in\n let open Caml.Int32 in\n fun state lo hi ->\n if lo > hi then raise_crossed_bounds \"int32\" lo hi to_string;\n let diff = sub hi lo in\n if diff = max_int\n then add lo (logand (full_range_int32 state) max_int)\n else if diff >= 0l\n then add lo (int32 state (succ diff))\n else in_range state lo hi\n ;;\n\n let nativeint_incl =\n let open Nativeint_replace_polymorphic_compare in\n let rec in_range state lo hi =\n let int = full_range_nativeint state in\n if int >= lo && int <= hi then int else in_range state lo hi\n in\n let open Caml.Nativeint in\n fun state lo hi ->\n if lo > hi then raise_crossed_bounds \"nativeint\" lo hi to_string;\n let diff = sub hi lo in\n if diff = max_int\n then add lo (logand (full_range_nativeint state) max_int)\n else if diff >= 0n\n then add lo (nativeint state (succ diff))\n else in_range state lo hi\n ;;\n\n let int64_incl =\n let open Int64_replace_polymorphic_compare in\n let rec in_range state lo hi =\n let int = full_range_int64 state in\n if int >= lo && int <= hi then int else in_range state lo hi\n in\n let open Caml.Int64 in\n fun state lo hi ->\n if lo > hi then raise_crossed_bounds \"int64\" lo hi to_string;\n let diff = sub hi lo in\n if diff = max_int\n then add lo (logand (full_range_int64 state) max_int)\n else if diff >= 0L\n then add lo (int64 state (succ diff))\n else in_range state lo hi\n ;;\n\n (* Return a uniformly random float in [0, 1). *)\n let rec rawfloat state =\n let open Float_replace_polymorphic_compare in\n let scale = 0x1p-30 in\n (* 2^-30 *)\n let r1 = Caml.float_of_int (bits state) in\n let r2 = Caml.float_of_int (bits state) in\n let result = ((r1 *. scale) +. r2) *. scale in\n (* With very small probability, result can round up to 1.0, so in that case, we just\n try again. *)\n if result < 1.0 then result else rawfloat state\n ;;\n\n let float state hi = rawfloat state *. hi\n\n let float_range state lo hi =\n let open Float_replace_polymorphic_compare in\n if lo > hi then raise_crossed_bounds \"float\" lo hi Caml.string_of_float;\n lo +. float state (hi -. lo)\n ;;\nend\n\nlet default = State.default\nlet bits () = State.bits default\nlet int x = State.int default x\nlet int32 x = State.int32 default x\nlet nativeint x = State.nativeint default x\nlet int64 x = State.int64 default x\nlet float x = State.float default x\nlet int_incl x y = State.int_incl default x y\nlet int32_incl x y = State.int32_incl default x y\nlet nativeint_incl x y = State.nativeint_incl default x y\nlet int64_incl x y = State.int64_incl default x y\nlet float_range x y = State.float_range default x y\nlet bool () = State.bool default\nlet char () = State.char default\nlet ascii () = State.ascii default\nlet full_init seed = State.full_init default seed\nlet init seed = full_init [| seed |]\nlet self_init ?allow_in_tests () = full_init (random_seed ?allow_in_tests ())\nlet set_state s = State.assign default s\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* The run-time library for lexers generated by camllex *)\n\ntype position = {\n pos_fname : string;\n pos_lnum : int;\n pos_bol : int;\n pos_cnum : int;\n}\n\nlet dummy_pos = {\n pos_fname = \"\";\n pos_lnum = 0;\n pos_bol = 0;\n pos_cnum = -1;\n}\n\ntype lexbuf =\n { refill_buff : lexbuf -> unit;\n mutable lex_buffer : bytes;\n mutable lex_buffer_len : int;\n mutable lex_abs_pos : int;\n mutable lex_start_pos : int;\n mutable lex_curr_pos : int;\n mutable lex_last_pos : int;\n mutable lex_last_action : int;\n mutable lex_eof_reached : bool;\n mutable lex_mem : int array;\n mutable lex_start_p : position;\n mutable lex_curr_p : position;\n }\n\ntype lex_tables =\n { lex_base: string;\n lex_backtrk: string;\n lex_default: string;\n lex_trans: string;\n lex_check: string;\n lex_base_code : string;\n lex_backtrk_code : string;\n lex_default_code : string;\n lex_trans_code : string;\n lex_check_code : string;\n lex_code: string;}\n\nexternal c_engine : lex_tables -> int -> lexbuf -> int = \"caml_lex_engine\"\nexternal c_new_engine : lex_tables -> int -> lexbuf -> int\n = \"caml_new_lex_engine\"\n\nlet engine tbl state buf =\n let result = c_engine tbl state buf in\n if result >= 0 && buf.lex_curr_p != dummy_pos then begin\n buf.lex_start_p <- buf.lex_curr_p;\n buf.lex_curr_p <- {buf.lex_curr_p\n with pos_cnum = buf.lex_abs_pos + buf.lex_curr_pos};\n end;\n result\n\n\nlet new_engine tbl state buf =\n let result = c_new_engine tbl state buf in\n if result >= 0 && buf.lex_curr_p != dummy_pos then begin\n buf.lex_start_p <- buf.lex_curr_p;\n buf.lex_curr_p <- {buf.lex_curr_p\n with pos_cnum = buf.lex_abs_pos + buf.lex_curr_pos};\n end;\n result\n\nlet lex_refill read_fun aux_buffer lexbuf =\n let read =\n read_fun aux_buffer (Bytes.length aux_buffer) in\n let n =\n if read > 0\n then read\n else (lexbuf.lex_eof_reached <- true; 0) in\n (* Current state of the buffer:\n <-------|---------------------|----------->\n | junk | valid data | junk |\n ^ ^ ^ ^\n 0 start_pos buffer_end Bytes.length buffer\n *)\n if lexbuf.lex_buffer_len + n > Bytes.length lexbuf.lex_buffer then begin\n (* There is not enough space at the end of the buffer *)\n if lexbuf.lex_buffer_len - lexbuf.lex_start_pos + n\n <= Bytes.length lexbuf.lex_buffer\n then begin\n (* But there is enough space if we reclaim the junk at the beginning\n of the buffer *)\n Bytes.blit lexbuf.lex_buffer lexbuf.lex_start_pos\n lexbuf.lex_buffer 0\n (lexbuf.lex_buffer_len - lexbuf.lex_start_pos)\n end else begin\n (* We must grow the buffer. Doubling its size will provide enough\n space since n <= String.length aux_buffer <= String.length buffer.\n Watch out for string length overflow, though. *)\n let newlen =\n Int.min (2 * Bytes.length lexbuf.lex_buffer) Sys.max_string_length in\n if lexbuf.lex_buffer_len - lexbuf.lex_start_pos + n > newlen\n then failwith \"Lexing.lex_refill: cannot grow buffer\";\n let newbuf = Bytes.create newlen in\n (* Copy the valid data to the beginning of the new buffer *)\n Bytes.blit lexbuf.lex_buffer lexbuf.lex_start_pos\n newbuf 0\n (lexbuf.lex_buffer_len - lexbuf.lex_start_pos);\n lexbuf.lex_buffer <- newbuf\n end;\n (* Reallocation or not, we have shifted the data left by\n start_pos characters; update the positions *)\n let s = lexbuf.lex_start_pos in\n lexbuf.lex_abs_pos <- lexbuf.lex_abs_pos + s;\n lexbuf.lex_curr_pos <- lexbuf.lex_curr_pos - s;\n lexbuf.lex_start_pos <- 0;\n lexbuf.lex_last_pos <- lexbuf.lex_last_pos - s;\n lexbuf.lex_buffer_len <- lexbuf.lex_buffer_len - s ;\n let t = lexbuf.lex_mem in\n for i = 0 to Array.length t-1 do\n let v = t.(i) in\n if v >= 0 then\n t.(i) <- v-s\n done\n end;\n (* There is now enough space at the end of the buffer *)\n Bytes.blit aux_buffer 0 lexbuf.lex_buffer lexbuf.lex_buffer_len n;\n lexbuf.lex_buffer_len <- lexbuf.lex_buffer_len + n\n\nlet zero_pos = {\n pos_fname = \"\";\n pos_lnum = 1;\n pos_bol = 0;\n pos_cnum = 0;\n}\n\nlet from_function ?(with_positions = true) f =\n { refill_buff = lex_refill f (Bytes.create 512);\n lex_buffer = Bytes.create 1024;\n lex_buffer_len = 0;\n lex_abs_pos = 0;\n lex_start_pos = 0;\n lex_curr_pos = 0;\n lex_last_pos = 0;\n lex_last_action = 0;\n lex_mem = [||];\n lex_eof_reached = false;\n lex_start_p = if with_positions then zero_pos else dummy_pos;\n lex_curr_p = if with_positions then zero_pos else dummy_pos;\n }\n\nlet from_channel ?with_positions ic =\n from_function ?with_positions (fun buf n -> input ic buf 0 n)\n\nlet from_string ?(with_positions = true) s =\n { refill_buff = (fun lexbuf -> lexbuf.lex_eof_reached <- true);\n lex_buffer = Bytes.of_string s; (* have to make a copy for compatibility\n with unsafe-string mode *)\n lex_buffer_len = String.length s;\n lex_abs_pos = 0;\n lex_start_pos = 0;\n lex_curr_pos = 0;\n lex_last_pos = 0;\n lex_last_action = 0;\n lex_mem = [||];\n lex_eof_reached = true;\n lex_start_p = if with_positions then zero_pos else dummy_pos;\n lex_curr_p = if with_positions then zero_pos else dummy_pos;\n }\n\nlet set_position lexbuf position =\n lexbuf.lex_curr_p <- {position with pos_fname = lexbuf.lex_curr_p.pos_fname};\n lexbuf.lex_abs_pos <- position.pos_cnum\n\nlet set_filename lexbuf fname =\n lexbuf.lex_curr_p <- {lexbuf.lex_curr_p with pos_fname = fname}\n\nlet with_positions lexbuf = lexbuf.lex_curr_p != dummy_pos\n\nlet lexeme lexbuf =\n let len = lexbuf.lex_curr_pos - lexbuf.lex_start_pos in\n Bytes.sub_string lexbuf.lex_buffer lexbuf.lex_start_pos len\n\nlet sub_lexeme lexbuf i1 i2 =\n let len = i2-i1 in\n Bytes.sub_string lexbuf.lex_buffer i1 len\n\nlet sub_lexeme_opt lexbuf i1 i2 =\n if i1 >= 0 then begin\n let len = i2-i1 in\n Some (Bytes.sub_string lexbuf.lex_buffer i1 len)\n end else begin\n None\n end\n\nlet sub_lexeme_char lexbuf i = Bytes.get lexbuf.lex_buffer i\n\nlet sub_lexeme_char_opt lexbuf i =\n if i >= 0 then\n Some (Bytes.get lexbuf.lex_buffer i)\n else\n None\n\n\nlet lexeme_char lexbuf i =\n Bytes.get lexbuf.lex_buffer (lexbuf.lex_start_pos + i)\n\nlet lexeme_start lexbuf = lexbuf.lex_start_p.pos_cnum\nlet lexeme_end lexbuf = lexbuf.lex_curr_p.pos_cnum\n\nlet lexeme_start_p lexbuf = lexbuf.lex_start_p\nlet lexeme_end_p lexbuf = lexbuf.lex_curr_p\n\nlet new_line lexbuf =\n let lcp = lexbuf.lex_curr_p in\n if lcp != dummy_pos then\n lexbuf.lex_curr_p <-\n { lcp with\n pos_lnum = lcp.pos_lnum + 1;\n pos_bol = lcp.pos_cnum;\n }\n\n\n\n(* Discard data left in lexer buffer. *)\n\nlet flush_input lb =\n lb.lex_curr_pos <- 0;\n lb.lex_abs_pos <- 0;\n let lcp = lb.lex_curr_p in\n if lcp != dummy_pos then\n lb.lex_curr_p <- {zero_pos with pos_fname = lcp.pos_fname};\n lb.lex_buffer_len <- 0;\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Benoit Vaugon, ENSTA *)\n(* *)\n(* Copyright 2014 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nopen CamlinternalFormatBasics\n\n(******************************************************************************)\n (* Tools to manipulate scanning set of chars (see %[...]) *)\n\ntype mutable_char_set = bytes\n\n(* Create a fresh, empty, mutable char set. *)\nlet create_char_set () = Bytes.make 32 '\\000'\n\n(* Add a char in a mutable char set. *)\nlet add_in_char_set char_set c =\n let ind = int_of_char c in\n let str_ind = ind lsr 3 and mask = 1 lsl (ind land 0b111) in\n Bytes.set char_set str_ind\n (char_of_int (int_of_char (Bytes.get char_set str_ind) lor mask))\n\nlet freeze_char_set char_set =\n Bytes.to_string char_set\n\n(* Compute the complement of a char set. *)\nlet rev_char_set char_set =\n let char_set' = create_char_set () in\n for i = 0 to 31 do\n Bytes.set char_set' i\n (char_of_int (int_of_char (String.get char_set i) lxor 0xFF));\n done;\n Bytes.unsafe_to_string char_set'\n\n(* Return true if a `c' is in `char_set'. *)\nlet is_in_char_set char_set c =\n let ind = int_of_char c in\n let str_ind = ind lsr 3 and mask = 1 lsl (ind land 0b111) in\n (int_of_char (String.get char_set str_ind) land mask) <> 0\n\n\n(******************************************************************************)\n (* Ignored param conversion *)\n\n(* GADT used to abstract an existential type parameter. *)\n(* See param_format_of_ignored_format. *)\ntype ('a, 'b, 'c, 'd, 'e, 'f) param_format_ebb = Param_format_EBB :\n ('x -> 'a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('a, 'b, 'c, 'd, 'e, 'f) param_format_ebb\n\n(* Compute a padding associated to a pad_option (see \"%_42d\"). *)\nlet pad_of_pad_opt pad_opt = match pad_opt with\n | None -> No_padding\n | Some width -> Lit_padding (Right, width)\n\n(* Compute a precision associated to a prec_option (see \"%_.42f\"). *)\nlet prec_of_prec_opt prec_opt = match prec_opt with\n | None -> No_precision\n | Some ndec -> Lit_precision ndec\n\n(* Turn an ignored param into its equivalent not-ignored format node. *)\n(* Used for format pretty-printing and Scanf. *)\nlet param_format_of_ignored_format : type a b c d e f x y .\n (a, b, c, d, y, x) ignored -> (x, b, c, y, e, f) fmt ->\n (a, b, c, d, e, f) param_format_ebb =\nfun ign fmt -> match ign with\n | Ignored_char ->\n Param_format_EBB (Char fmt)\n | Ignored_caml_char ->\n Param_format_EBB (Caml_char fmt)\n | Ignored_string pad_opt ->\n Param_format_EBB (String (pad_of_pad_opt pad_opt, fmt))\n | Ignored_caml_string pad_opt ->\n Param_format_EBB (Caml_string (pad_of_pad_opt pad_opt, fmt))\n | Ignored_int (iconv, pad_opt) ->\n Param_format_EBB (Int (iconv, pad_of_pad_opt pad_opt, No_precision, fmt))\n | Ignored_int32 (iconv, pad_opt) ->\n Param_format_EBB\n (Int32 (iconv, pad_of_pad_opt pad_opt, No_precision, fmt))\n | Ignored_nativeint (iconv, pad_opt) ->\n Param_format_EBB\n (Nativeint (iconv, pad_of_pad_opt pad_opt, No_precision, fmt))\n | Ignored_int64 (iconv, pad_opt) ->\n Param_format_EBB\n (Int64 (iconv, pad_of_pad_opt pad_opt, No_precision, fmt))\n | Ignored_float (pad_opt, prec_opt) ->\n Param_format_EBB\n (Float ((Float_flag_, Float_f),\n pad_of_pad_opt pad_opt, prec_of_prec_opt prec_opt, fmt))\n | Ignored_bool pad_opt ->\n Param_format_EBB (Bool (pad_of_pad_opt pad_opt, fmt))\n | Ignored_format_arg (pad_opt, fmtty) ->\n Param_format_EBB (Format_arg (pad_opt, fmtty, fmt))\n | Ignored_format_subst (pad_opt, fmtty) ->\n Param_format_EBB\n (Format_subst (pad_opt, fmtty, fmt))\n | Ignored_reader ->\n Param_format_EBB (Reader fmt)\n | Ignored_scan_char_set (width_opt, char_set) ->\n Param_format_EBB (Scan_char_set (width_opt, char_set, fmt))\n | Ignored_scan_get_counter counter ->\n Param_format_EBB (Scan_get_counter (counter, fmt))\n | Ignored_scan_next_char ->\n Param_format_EBB (Scan_next_char fmt)\n\n\n(******************************************************************************)\n (* Types *)\n\ntype ('b, 'c) acc_formatting_gen =\n | Acc_open_tag of ('b, 'c) acc\n | Acc_open_box of ('b, 'c) acc\n\n(* Reversed list of printing atoms. *)\n(* Used to accumulate printf arguments. *)\nand ('b, 'c) acc =\n | Acc_formatting_lit of ('b, 'c) acc * formatting_lit\n (* Special fmtting (box) *)\n | Acc_formatting_gen of ('b, 'c) acc * ('b, 'c) acc_formatting_gen\n (* Special fmtting (box) *)\n | Acc_string_literal of ('b, 'c) acc * string (* Literal string *)\n | Acc_char_literal of ('b, 'c) acc * char (* Literal char *)\n | Acc_data_string of ('b, 'c) acc * string (* Generated string *)\n | Acc_data_char of ('b, 'c) acc * char (* Generated char *)\n | Acc_delay of ('b, 'c) acc * ('b -> 'c)\n (* Delayed printing (%a, %t) *)\n | Acc_flush of ('b, 'c) acc (* Flush *)\n | Acc_invalid_arg of ('b, 'c) acc * string\n (* Raise Invalid_argument msg *)\n | End_of_acc\n\n(* List of heterogeneous values. *)\n(* Used to accumulate scanf callback arguments. *)\ntype ('a, 'b) heter_list =\n | Cons : 'c * ('a, 'b) heter_list -> ('c -> 'a, 'b) heter_list\n | Nil : ('b, 'b) heter_list\n\n(* Existential Black Boxes. *)\n(* Used to abstract some existential type parameters. *)\n\n(* GADT type associating a padding and an fmtty. *)\n(* See the type_padding function. *)\ntype ('a, 'b, 'c, 'd, 'e, 'f) padding_fmtty_ebb = Padding_fmtty_EBB :\n ('x, 'y) padding * ('y, 'b, 'c, 'd, 'e, 'f) fmtty ->\n ('x, 'b, 'c, 'd, 'e, 'f) padding_fmtty_ebb\n\n(* GADT type associating a padding, a precision and an fmtty. *)\n(* See the type_padprec function. *)\ntype ('a, 'b, 'c, 'd, 'e, 'f) padprec_fmtty_ebb = Padprec_fmtty_EBB :\n ('x, 'y) padding * ('y, 'z) precision * ('z, 'b, 'c, 'd, 'e, 'f) fmtty ->\n ('x, 'b, 'c, 'd, 'e, 'f) padprec_fmtty_ebb\n\n(* GADT type associating a padding and an fmt. *)\n(* See make_padding_fmt_ebb and parse_format functions. *)\ntype ('a, 'b, 'c, 'e, 'f) padding_fmt_ebb = Padding_fmt_EBB :\n (_, 'x -> 'a) padding *\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('x, 'b, 'c, 'e, 'f) padding_fmt_ebb\n\n(* GADT type associating a precision and an fmt. *)\n(* See make_precision_fmt_ebb and parse_format functions. *)\ntype ('a, 'b, 'c, 'e, 'f) precision_fmt_ebb = Precision_fmt_EBB :\n (_, 'x -> 'a) precision *\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('x, 'b, 'c, 'e, 'f) precision_fmt_ebb\n\n(* GADT type associating a padding, a precision and an fmt. *)\n(* See make_padprec_fmt_ebb and parse_format functions. *)\ntype ('p, 'b, 'c, 'e, 'f) padprec_fmt_ebb = Padprec_fmt_EBB :\n ('x, 'y) padding * ('y, 'p -> 'a) precision *\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('p, 'b, 'c, 'e, 'f) padprec_fmt_ebb\n\n(* Abstract the 'a and 'd parameters of an fmt. *)\n(* Output type of the format parsing function. *)\ntype ('b, 'c, 'e, 'f) fmt_ebb = Fmt_EBB :\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('b, 'c, 'e, 'f) fmt_ebb\n\n(* GADT type associating an fmtty and an fmt. *)\n(* See the type_format_gen function. *)\ntype ('a, 'b, 'c, 'd, 'e, 'f) fmt_fmtty_ebb = Fmt_fmtty_EBB :\n ('a, 'b, 'c, 'd, 'y, 'x) fmt *\n ('x, 'b, 'c, 'y, 'e, 'f) fmtty ->\n ('a, 'b, 'c, 'd, 'e, 'f) fmt_fmtty_ebb\n\n(* GADT type associating an fmtty and an fmt. *)\n(* See the type_ignored_format_substitution function. *)\ntype ('a, 'b, 'c, 'd, 'e, 'f) fmtty_fmt_ebb = Fmtty_fmt_EBB :\n ('a, 'b, 'c, 'd, 'y, 'x) fmtty *\n ('x, 'b, 'c, 'y, 'e, 'f) fmt_fmtty_ebb ->\n ('a, 'b, 'c, 'd, 'e, 'f) fmtty_fmt_ebb\n\n(* Abstract all fmtty type parameters. *)\n(* Used to compare format types. *)\ntype fmtty_ebb = Fmtty_EBB : ('a, 'b, 'c, 'd, 'e, 'f) fmtty -> fmtty_ebb\n\n(* Abstract all padding type parameters. *)\n(* Used to compare paddings. *)\ntype padding_ebb = Padding_EBB : ('a, 'b) padding -> padding_ebb\n\n(* Abstract all precision type parameters. *)\n(* Used to compare precisions. *)\ntype precision_ebb = Precision_EBB : ('a, 'b) precision -> precision_ebb\n\n(******************************************************************************)\n (* Constants *)\n\n(* Default precision for float printing. *)\nlet default_float_precision fconv =\n match snd fconv with\n | Float_f | Float_e | Float_E | Float_g | Float_G | Float_h | Float_H\n | Float_CF -> -6\n (* For %h %H and %#F formats, a negative precision means \"as many digits as\n necessary\". For the other FP formats, we take the absolute value\n of the precision, hence 6 digits by default. *)\n | Float_F -> 12\n (* Default precision for OCaml float printing (%F). *)\n\n(******************************************************************************)\n (* Externals *)\n\nexternal format_float: string -> float -> string\n = \"caml_format_float\"\nexternal format_int: string -> int -> string\n = \"caml_format_int\"\nexternal format_int32: string -> int32 -> string\n = \"caml_int32_format\"\nexternal format_nativeint: string -> nativeint -> string\n = \"caml_nativeint_format\"\nexternal format_int64: string -> int64 -> string\n = \"caml_int64_format\"\nexternal hexstring_of_float: float -> int -> char -> string\n = \"caml_hexstring_of_float\"\n\n(******************************************************************************)\n (* Tools to pretty-print formats *)\n\n(* Type of extensible character buffers. *)\ntype buffer = {\n mutable ind : int;\n mutable bytes : bytes;\n}\n\n(* Create a fresh buffer. *)\nlet buffer_create init_size = { ind = 0; bytes = Bytes.create init_size }\n\n(* Check size of the buffer and grow it if needed. *)\nlet buffer_check_size buf overhead =\n let len = Bytes.length buf.bytes in\n let min_len = buf.ind + overhead in\n if min_len > len then (\n let new_len = Int.max (len * 2) min_len in\n let new_str = Bytes.create new_len in\n Bytes.blit buf.bytes 0 new_str 0 len;\n buf.bytes <- new_str;\n )\n\n(* Add the character `c' to the buffer `buf'. *)\nlet buffer_add_char buf c =\n buffer_check_size buf 1;\n Bytes.set buf.bytes buf.ind c;\n buf.ind <- buf.ind + 1\n\n(* Add the string `s' to the buffer `buf'. *)\nlet buffer_add_string buf s =\n let str_len = String.length s in\n buffer_check_size buf str_len;\n String.blit s 0 buf.bytes buf.ind str_len;\n buf.ind <- buf.ind + str_len\n\n(* Get the content of the buffer. *)\nlet buffer_contents buf =\n Bytes.sub_string buf.bytes 0 buf.ind\n\n(***)\n\n(* Convert an integer conversion to char. *)\nlet char_of_iconv iconv = match iconv with\n | Int_d | Int_pd | Int_sd | Int_Cd -> 'd' | Int_i | Int_pi | Int_si\n | Int_Ci -> 'i' | Int_x | Int_Cx -> 'x' | Int_X | Int_CX -> 'X' | Int_o\n | Int_Co -> 'o' | Int_u | Int_Cu -> 'u'\n\n(* Convert a float conversion to char. *)\n(* `cF' will be 'F' for displaying format and 'g' to call libc printf *)\nlet char_of_fconv ?(cF='F') fconv = match snd fconv with\n | Float_f -> 'f' | Float_e -> 'e'\n | Float_E -> 'E' | Float_g -> 'g'\n | Float_G -> 'G' | Float_F -> cF\n | Float_h -> 'h' | Float_H -> 'H'\n | Float_CF -> 'F'\n\n\n(* Convert a scanning counter to char. *)\nlet char_of_counter counter = match counter with\n | Line_counter -> 'l'\n | Char_counter -> 'n'\n | Token_counter -> 'N'\n\n(***)\n\n(* Print a char_set in a buffer with the OCaml format lexical convention. *)\nlet bprint_char_set buf char_set =\n let rec print_start set =\n let is_alone c =\n let before, after = Char.(chr (code c - 1), chr (code c + 1)) in\n is_in_char_set set c\n && not (is_in_char_set set before && is_in_char_set set after) in\n if is_alone ']' then buffer_add_char buf ']';\n print_out set 1;\n if is_alone '-' then buffer_add_char buf '-';\n and print_out set i =\n if i < 256 then\n if is_in_char_set set (char_of_int i) then print_first set i\n else print_out set (i + 1)\n and print_first set i =\n match char_of_int i with\n | '\\255' -> print_char buf 255;\n | ']' | '-' -> print_out set (i + 1);\n | _ -> print_second set (i + 1);\n and print_second set i =\n if is_in_char_set set (char_of_int i) then\n match char_of_int i with\n | '\\255' ->\n print_char buf 254;\n print_char buf 255;\n | ']' | '-' when not (is_in_char_set set (char_of_int (i + 1))) ->\n print_char buf (i - 1);\n print_out set (i + 1);\n | _ when not (is_in_char_set set (char_of_int (i + 1))) ->\n print_char buf (i - 1);\n print_char buf i;\n print_out set (i + 2);\n | _ ->\n print_in set (i - 1) (i + 2);\n else (\n print_char buf (i - 1);\n print_out set (i + 1);\n )\n and print_in set i j =\n if j = 256 || not (is_in_char_set set (char_of_int j)) then (\n print_char buf i;\n print_char buf (int_of_char '-');\n print_char buf (j - 1);\n if j < 256 then print_out set (j + 1);\n ) else\n print_in set i (j + 1);\n and print_char buf i = match char_of_int i with\n | '%' -> buffer_add_char buf '%'; buffer_add_char buf '%';\n | '@' -> buffer_add_char buf '%'; buffer_add_char buf '@';\n | c -> buffer_add_char buf c;\n in\n buffer_add_char buf '[';\n print_start (\n if is_in_char_set char_set '\\000'\n then ( buffer_add_char buf '^'; rev_char_set char_set )\n else char_set\n );\n buffer_add_char buf ']'\n\n(***)\n\n(* Print a padty in a buffer with the format-like syntax. *)\nlet bprint_padty buf padty = match padty with\n | Left -> buffer_add_char buf '-'\n | Right -> ()\n | Zeros -> buffer_add_char buf '0'\n\n(* Print the '_' of an ignored flag if needed. *)\nlet bprint_ignored_flag buf ign_flag =\n if ign_flag then buffer_add_char buf '_'\n\n(***)\n\nlet bprint_pad_opt buf pad_opt = match pad_opt with\n | None -> ()\n | Some width -> buffer_add_string buf (Int.to_string width)\n\n(***)\n\n(* Print padding in a buffer with the format-like syntax. *)\nlet bprint_padding : type a b . buffer -> (a, b) padding -> unit =\nfun buf pad -> match pad with\n | No_padding -> ()\n | Lit_padding (padty, n) ->\n bprint_padty buf padty;\n buffer_add_string buf (Int.to_string n);\n | Arg_padding padty ->\n bprint_padty buf padty;\n buffer_add_char buf '*'\n\n(* Print precision in a buffer with the format-like syntax. *)\nlet bprint_precision : type a b . buffer -> (a, b) precision -> unit =\n fun buf prec -> match prec with\n | No_precision -> ()\n | Lit_precision n ->\n buffer_add_char buf '.';\n buffer_add_string buf (Int.to_string n);\n | Arg_precision ->\n buffer_add_string buf \".*\"\n\n(***)\n\n(* Print the optional '+', ' ' or '#' associated to an int conversion. *)\nlet bprint_iconv_flag buf iconv = match iconv with\n | Int_pd | Int_pi -> buffer_add_char buf '+'\n | Int_sd | Int_si -> buffer_add_char buf ' '\n | Int_Cx | Int_CX | Int_Co | Int_Cd | Int_Ci | Int_Cu ->\n buffer_add_char buf '#'\n | Int_d | Int_i | Int_x | Int_X | Int_o | Int_u -> ()\n\n(* Print an complete int format in a buffer (ex: \"%3.*d\"). *)\nlet bprint_int_fmt buf ign_flag iconv pad prec =\n buffer_add_char buf '%';\n bprint_ignored_flag buf ign_flag;\n bprint_iconv_flag buf iconv;\n bprint_padding buf pad;\n bprint_precision buf prec;\n buffer_add_char buf (char_of_iconv iconv)\n\n(* Print a complete int32, nativeint or int64 format in a buffer. *)\nlet bprint_altint_fmt buf ign_flag iconv pad prec c =\n buffer_add_char buf '%';\n bprint_ignored_flag buf ign_flag;\n bprint_iconv_flag buf iconv;\n bprint_padding buf pad;\n bprint_precision buf prec;\n buffer_add_char buf c;\n buffer_add_char buf (char_of_iconv iconv)\n\n(***)\n\n(* Print the optional '+', ' ' and/or '#' associated to a float conversion. *)\nlet bprint_fconv_flag buf fconv =\n begin match fst fconv with\n | Float_flag_p -> buffer_add_char buf '+'\n | Float_flag_s -> buffer_add_char buf ' '\n | Float_flag_ -> () end;\n match snd fconv with\n | Float_CF -> buffer_add_char buf '#'\n | Float_f | Float_e | Float_E | Float_g | Float_G\n | Float_F | Float_h | Float_H -> ()\n\n(* Print a complete float format in a buffer (ex: \"%+*.3f\"). *)\nlet bprint_float_fmt buf ign_flag fconv pad prec =\n buffer_add_char buf '%';\n bprint_ignored_flag buf ign_flag;\n bprint_fconv_flag buf fconv;\n bprint_padding buf pad;\n bprint_precision buf prec;\n buffer_add_char buf (char_of_fconv fconv)\n\n(* Compute the literal string representation of a Formatting_lit. *)\n(* Used by Printf and Scanf where formatting is not interpreted. *)\nlet string_of_formatting_lit formatting_lit = match formatting_lit with\n | Close_box -> \"@]\"\n | Close_tag -> \"@}\"\n | Break (str, _, _) -> str\n | FFlush -> \"@?\"\n | Force_newline -> \"@\\n\"\n | Flush_newline -> \"@.\"\n | Magic_size (str, _) -> str\n | Escaped_at -> \"@@\"\n | Escaped_percent -> \"@%\"\n | Scan_indic c -> \"@\" ^ (String.make 1 c)\n\n(***)\n\n(* Print a literal char in a buffer, escape '%' by \"%%\". *)\nlet bprint_char_literal buf chr = match chr with\n | '%' -> buffer_add_string buf \"%%\"\n | _ -> buffer_add_char buf chr\n\n(* Print a literal string in a buffer, escape all '%' by \"%%\". *)\nlet bprint_string_literal buf str =\n for i = 0 to String.length str - 1 do\n bprint_char_literal buf str.[i]\n done\n\n(******************************************************************************)\n (* Format pretty-printing *)\n\n(* Print a complete format type (an fmtty) in a buffer. *)\nlet rec bprint_fmtty : type a b c d e f g h i j k l .\n buffer -> (a, b, c, d, e, f, g, h, i, j, k, l) fmtty_rel -> unit =\nfun buf fmtty -> match fmtty with\n | Char_ty rest -> buffer_add_string buf \"%c\"; bprint_fmtty buf rest;\n | String_ty rest -> buffer_add_string buf \"%s\"; bprint_fmtty buf rest;\n | Int_ty rest -> buffer_add_string buf \"%i\"; bprint_fmtty buf rest;\n | Int32_ty rest -> buffer_add_string buf \"%li\"; bprint_fmtty buf rest;\n | Nativeint_ty rest -> buffer_add_string buf \"%ni\"; bprint_fmtty buf rest;\n | Int64_ty rest -> buffer_add_string buf \"%Li\"; bprint_fmtty buf rest;\n | Float_ty rest -> buffer_add_string buf \"%f\"; bprint_fmtty buf rest;\n | Bool_ty rest -> buffer_add_string buf \"%B\"; bprint_fmtty buf rest;\n | Alpha_ty rest -> buffer_add_string buf \"%a\"; bprint_fmtty buf rest;\n | Theta_ty rest -> buffer_add_string buf \"%t\"; bprint_fmtty buf rest;\n | Any_ty rest -> buffer_add_string buf \"%?\"; bprint_fmtty buf rest;\n | Reader_ty rest -> buffer_add_string buf \"%r\"; bprint_fmtty buf rest;\n\n | Ignored_reader_ty rest ->\n buffer_add_string buf \"%_r\";\n bprint_fmtty buf rest;\n\n | Format_arg_ty (sub_fmtty, rest) ->\n buffer_add_string buf \"%{\"; bprint_fmtty buf sub_fmtty;\n buffer_add_string buf \"%}\"; bprint_fmtty buf rest;\n | Format_subst_ty (sub_fmtty, _, rest) ->\n buffer_add_string buf \"%(\"; bprint_fmtty buf sub_fmtty;\n buffer_add_string buf \"%)\"; bprint_fmtty buf rest;\n\n | End_of_fmtty -> ()\n\n(***)\n\nlet rec int_of_custom_arity : type a b c .\n (a, b, c) custom_arity -> int =\n function\n | Custom_zero -> 0\n | Custom_succ x -> 1 + int_of_custom_arity x\n\n(* Print a complete format in a buffer. *)\nlet bprint_fmt buf fmt =\n let rec fmtiter : type a b c d e f .\n (a, b, c, d, e, f) fmt -> bool -> unit =\n fun fmt ign_flag -> match fmt with\n | String (pad, rest) ->\n buffer_add_char buf '%'; bprint_ignored_flag buf ign_flag;\n bprint_padding buf pad; buffer_add_char buf 's';\n fmtiter rest false;\n | Caml_string (pad, rest) ->\n buffer_add_char buf '%'; bprint_ignored_flag buf ign_flag;\n bprint_padding buf pad; buffer_add_char buf 'S';\n fmtiter rest false;\n\n | Int (iconv, pad, prec, rest) ->\n bprint_int_fmt buf ign_flag iconv pad prec;\n fmtiter rest false;\n | Int32 (iconv, pad, prec, rest) ->\n bprint_altint_fmt buf ign_flag iconv pad prec 'l';\n fmtiter rest false;\n | Nativeint (iconv, pad, prec, rest) ->\n bprint_altint_fmt buf ign_flag iconv pad prec 'n';\n fmtiter rest false;\n | Int64 (iconv, pad, prec, rest) ->\n bprint_altint_fmt buf ign_flag iconv pad prec 'L';\n fmtiter rest false;\n | Float (fconv, pad, prec, rest) ->\n bprint_float_fmt buf ign_flag fconv pad prec;\n fmtiter rest false;\n\n | Char rest ->\n buffer_add_char buf '%'; bprint_ignored_flag buf ign_flag;\n buffer_add_char buf 'c'; fmtiter rest false;\n | Caml_char rest ->\n buffer_add_char buf '%'; bprint_ignored_flag buf ign_flag;\n buffer_add_char buf 'C'; fmtiter rest false;\n | Bool (pad, rest) ->\n buffer_add_char buf '%'; bprint_ignored_flag buf ign_flag;\n bprint_padding buf pad; buffer_add_char buf 'B';\n fmtiter rest false;\n | Alpha rest ->\n buffer_add_char buf '%'; bprint_ignored_flag buf ign_flag;\n buffer_add_char buf 'a'; fmtiter rest false;\n | Theta rest ->\n buffer_add_char buf '%'; bprint_ignored_flag buf ign_flag;\n buffer_add_char buf 't'; fmtiter rest false;\n | Custom (arity, _, rest) ->\n for _i = 1 to int_of_custom_arity arity do\n buffer_add_char buf '%'; bprint_ignored_flag buf ign_flag;\n buffer_add_char buf '?';\n done;\n fmtiter rest false;\n | Reader rest ->\n buffer_add_char buf '%'; bprint_ignored_flag buf ign_flag;\n buffer_add_char buf 'r'; fmtiter rest false;\n | Flush rest ->\n buffer_add_string buf \"%!\";\n fmtiter rest ign_flag;\n\n | String_literal (str, rest) ->\n bprint_string_literal buf str;\n fmtiter rest ign_flag;\n | Char_literal (chr, rest) ->\n bprint_char_literal buf chr;\n fmtiter rest ign_flag;\n\n | Format_arg (pad_opt, fmtty, rest) ->\n buffer_add_char buf '%'; bprint_ignored_flag buf ign_flag;\n bprint_pad_opt buf pad_opt; buffer_add_char buf '{';\n bprint_fmtty buf fmtty; buffer_add_char buf '%'; buffer_add_char buf '}';\n fmtiter rest false;\n | Format_subst (pad_opt, fmtty, rest) ->\n buffer_add_char buf '%'; bprint_ignored_flag buf ign_flag;\n bprint_pad_opt buf pad_opt; buffer_add_char buf '(';\n bprint_fmtty buf fmtty; buffer_add_char buf '%'; buffer_add_char buf ')';\n fmtiter rest false;\n\n | Scan_char_set (width_opt, char_set, rest) ->\n buffer_add_char buf '%'; bprint_ignored_flag buf ign_flag;\n bprint_pad_opt buf width_opt; bprint_char_set buf char_set;\n fmtiter rest false;\n | Scan_get_counter (counter, rest) ->\n buffer_add_char buf '%'; bprint_ignored_flag buf ign_flag;\n buffer_add_char buf (char_of_counter counter);\n fmtiter rest false;\n | Scan_next_char rest ->\n buffer_add_char buf '%'; bprint_ignored_flag buf ign_flag;\n bprint_string_literal buf \"0c\"; fmtiter rest false;\n\n | Ignored_param (ign, rest) ->\n let Param_format_EBB fmt' = param_format_of_ignored_format ign rest in\n fmtiter fmt' true;\n\n | Formatting_lit (fmting_lit, rest) ->\n bprint_string_literal buf (string_of_formatting_lit fmting_lit);\n fmtiter rest ign_flag;\n | Formatting_gen (fmting_gen, rest) ->\n begin match fmting_gen with\n | Open_tag (Format (_, str)) ->\n buffer_add_string buf \"@{\"; buffer_add_string buf str\n | Open_box (Format (_, str)) ->\n buffer_add_string buf \"@[\"; buffer_add_string buf str\n end;\n fmtiter rest ign_flag;\n\n | End_of_format -> ()\n\n in fmtiter fmt false\n\n(***)\n\n(* Convert a format to string. *)\nlet string_of_fmt fmt =\n let buf = buffer_create 16 in\n bprint_fmt buf fmt;\n buffer_contents buf\n\n(******************************************************************************)\n (* Type extraction *)\n\ntype (_, _) eq = Refl : ('a, 'a) eq\n\n(* Invariant: this function is the identity on values.\n\n In particular, if (ty1, ty2) have equal values, then\n (trans (symm ty1) ty2) respects the 'trans' precondition. *)\nlet rec symm : type a1 b1 c1 d1 e1 f1 a2 b2 c2 d2 e2 f2 .\n (a1, b1, c1, d1, e1, f1,\n a2, b2, c2, d2, e2, f2) fmtty_rel\n-> (a2, b2, c2, d2, e2, f2,\n a1, b1, c1, d1, e1, f1) fmtty_rel\n= function\n | Char_ty rest -> Char_ty (symm rest)\n | Int_ty rest -> Int_ty (symm rest)\n | Int32_ty rest -> Int32_ty (symm rest)\n | Int64_ty rest -> Int64_ty (symm rest)\n | Nativeint_ty rest -> Nativeint_ty (symm rest)\n | Float_ty rest -> Float_ty (symm rest)\n | Bool_ty rest -> Bool_ty (symm rest)\n | String_ty rest -> String_ty (symm rest)\n | Theta_ty rest -> Theta_ty (symm rest)\n | Alpha_ty rest -> Alpha_ty (symm rest)\n | Any_ty rest -> Any_ty (symm rest)\n | Reader_ty rest -> Reader_ty (symm rest)\n | Ignored_reader_ty rest -> Ignored_reader_ty (symm rest)\n | Format_arg_ty (ty, rest) ->\n Format_arg_ty (ty, symm rest)\n | Format_subst_ty (ty1, ty2, rest) ->\n Format_subst_ty (ty2, ty1, symm rest)\n | End_of_fmtty -> End_of_fmtty\n\nlet rec fmtty_rel_det : type a1 b c d1 e1 f1 a2 d2 e2 f2 .\n (a1, b, c, d1, e1, f1,\n a2, b, c, d2, e2, f2) fmtty_rel ->\n ((f1, f2) eq -> (a1, a2) eq)\n * ((a1, a2) eq -> (f1, f2) eq)\n * ((e1, e2) eq -> (d1, d2) eq)\n * ((d1, d2) eq -> (e1, e2) eq)\n= function\n | End_of_fmtty ->\n (fun Refl -> Refl),\n (fun Refl -> Refl),\n (fun Refl -> Refl),\n (fun Refl -> Refl)\n | Char_ty rest ->\n let fa, af, ed, de = fmtty_rel_det rest in\n (fun Refl -> let Refl = fa Refl in Refl),\n (fun Refl -> let Refl = af Refl in Refl),\n ed, de\n | String_ty rest ->\n let fa, af, ed, de = fmtty_rel_det rest in\n (fun Refl -> let Refl = fa Refl in Refl),\n (fun Refl -> let Refl = af Refl in Refl),\n ed, de\n | Int_ty rest ->\n let fa, af, ed, de = fmtty_rel_det rest in\n (fun Refl -> let Refl = fa Refl in Refl),\n (fun Refl -> let Refl = af Refl in Refl),\n ed, de\n | Int32_ty rest ->\n let fa, af, ed, de = fmtty_rel_det rest in\n (fun Refl -> let Refl = fa Refl in Refl),\n (fun Refl -> let Refl = af Refl in Refl),\n ed, de\n | Int64_ty rest ->\n let fa, af, ed, de = fmtty_rel_det rest in\n (fun Refl -> let Refl = fa Refl in Refl),\n (fun Refl -> let Refl = af Refl in Refl),\n ed, de\n | Nativeint_ty rest ->\n let fa, af, ed, de = fmtty_rel_det rest in\n (fun Refl -> let Refl = fa Refl in Refl),\n (fun Refl -> let Refl = af Refl in Refl),\n ed, de\n | Float_ty rest ->\n let fa, af, ed, de = fmtty_rel_det rest in\n (fun Refl -> let Refl = fa Refl in Refl),\n (fun Refl -> let Refl = af Refl in Refl),\n ed, de\n | Bool_ty rest ->\n let fa, af, ed, de = fmtty_rel_det rest in\n (fun Refl -> let Refl = fa Refl in Refl),\n (fun Refl -> let Refl = af Refl in Refl),\n ed, de\n\n | Theta_ty rest ->\n let fa, af, ed, de = fmtty_rel_det rest in\n (fun Refl -> let Refl = fa Refl in Refl),\n (fun Refl -> let Refl = af Refl in Refl),\n ed, de\n | Alpha_ty rest ->\n let fa, af, ed, de = fmtty_rel_det rest in\n (fun Refl -> let Refl = fa Refl in Refl),\n (fun Refl -> let Refl = af Refl in Refl),\n ed, de\n | Any_ty rest ->\n let fa, af, ed, de = fmtty_rel_det rest in\n (fun Refl -> let Refl = fa Refl in Refl),\n (fun Refl -> let Refl = af Refl in Refl),\n ed, de\n | Reader_ty rest ->\n let fa, af, ed, de = fmtty_rel_det rest in\n (fun Refl -> let Refl = fa Refl in Refl),\n (fun Refl -> let Refl = af Refl in Refl),\n (fun Refl -> let Refl = ed Refl in Refl),\n (fun Refl -> let Refl = de Refl in Refl)\n | Ignored_reader_ty rest ->\n let fa, af, ed, de = fmtty_rel_det rest in\n (fun Refl -> let Refl = fa Refl in Refl),\n (fun Refl -> let Refl = af Refl in Refl),\n (fun Refl -> let Refl = ed Refl in Refl),\n (fun Refl -> let Refl = de Refl in Refl)\n | Format_arg_ty (_ty, rest) ->\n let fa, af, ed, de = fmtty_rel_det rest in\n (fun Refl -> let Refl = fa Refl in Refl),\n (fun Refl -> let Refl = af Refl in Refl),\n ed, de\n | Format_subst_ty (ty1, ty2, rest) ->\n let fa, af, ed, de = fmtty_rel_det rest in\n let ty = trans (symm ty1) ty2 in\n let ag, ga, dj, jd = fmtty_rel_det ty in\n (fun Refl -> let Refl = fa Refl in let Refl = ag Refl in Refl),\n (fun Refl -> let Refl = ga Refl in let Refl = af Refl in Refl),\n (fun Refl -> let Refl = ed Refl in let Refl = dj Refl in Refl),\n (fun Refl -> let Refl = jd Refl in let Refl = de Refl in Refl)\n\n(* Precondition: we assume that the two fmtty_rel arguments have equal\n values (at possibly distinct types); this invariant comes from the way\n fmtty_rel witnesses are produced by the type-checker\n\n The code below uses (assert false) when this assumption is broken. The\n code pattern is the following:\n\n | Foo x, Foo y ->\n (* case where indeed both values\n start with constructor Foo *)\n | Foo _, _\n | _, Foo _ ->\n (* different head constructors: broken precondition *)\n assert false\n*)\nand trans : type\n a1 b1 c1 d1 e1 f1\n a2 b2 c2 d2 e2 f2\n a3 b3 c3 d3 e3 f3\n.\n (a1, b1, c1, d1, e1, f1,\n a2, b2, c2, d2, e2, f2) fmtty_rel\n-> (a2, b2, c2, d2, e2, f2,\n a3, b3, c3, d3, e3, f3) fmtty_rel\n-> (a1, b1, c1, d1, e1, f1,\n a3, b3, c3, d3, e3, f3) fmtty_rel\n= fun ty1 ty2 -> match ty1, ty2 with\n | Char_ty rest1, Char_ty rest2 -> Char_ty (trans rest1 rest2)\n | String_ty rest1, String_ty rest2 -> String_ty (trans rest1 rest2)\n | Bool_ty rest1, Bool_ty rest2 -> Bool_ty (trans rest1 rest2)\n | Int_ty rest1, Int_ty rest2 -> Int_ty (trans rest1 rest2)\n | Int32_ty rest1, Int32_ty rest2 -> Int32_ty (trans rest1 rest2)\n | Int64_ty rest1, Int64_ty rest2 -> Int64_ty (trans rest1 rest2)\n | Nativeint_ty rest1, Nativeint_ty rest2 -> Nativeint_ty (trans rest1 rest2)\n | Float_ty rest1, Float_ty rest2 -> Float_ty (trans rest1 rest2)\n\n | Alpha_ty rest1, Alpha_ty rest2 -> Alpha_ty (trans rest1 rest2)\n | Alpha_ty _, _ -> assert false\n | _, Alpha_ty _ -> assert false\n\n | Theta_ty rest1, Theta_ty rest2 -> Theta_ty (trans rest1 rest2)\n | Theta_ty _, _ -> assert false\n | _, Theta_ty _ -> assert false\n\n | Any_ty rest1, Any_ty rest2 -> Any_ty (trans rest1 rest2)\n | Any_ty _, _ -> assert false\n | _, Any_ty _ -> assert false\n\n | Reader_ty rest1, Reader_ty rest2 -> Reader_ty (trans rest1 rest2)\n | Reader_ty _, _ -> assert false\n | _, Reader_ty _ -> assert false\n\n | Ignored_reader_ty rest1, Ignored_reader_ty rest2 ->\n Ignored_reader_ty (trans rest1 rest2)\n | Ignored_reader_ty _, _ -> assert false\n | _, Ignored_reader_ty _ -> assert false\n\n | Format_arg_ty (ty1, rest1), Format_arg_ty (ty2, rest2) ->\n Format_arg_ty (trans ty1 ty2, trans rest1 rest2)\n | Format_arg_ty _, _ -> assert false\n | _, Format_arg_ty _ -> assert false\n\n | Format_subst_ty (ty11, ty12, rest1),\n Format_subst_ty (ty21, ty22, rest2) ->\n let ty = trans (symm ty12) ty21 in\n let _, f2, _, f4 = fmtty_rel_det ty in\n let Refl = f2 Refl in\n let Refl = f4 Refl in\n Format_subst_ty (ty11, ty22, trans rest1 rest2)\n | Format_subst_ty _, _ -> assert false\n | _, Format_subst_ty _ -> assert false\n\n | End_of_fmtty, End_of_fmtty -> End_of_fmtty\n | End_of_fmtty, _ -> assert false\n | _, End_of_fmtty -> assert false\n\nlet rec fmtty_of_formatting_gen : type a b c d e f .\n (a, b, c, d, e, f) formatting_gen ->\n (a, b, c, d, e, f) fmtty =\nfun formatting_gen -> match formatting_gen with\n | Open_tag (Format (fmt, _)) -> fmtty_of_fmt fmt\n | Open_box (Format (fmt, _)) -> fmtty_of_fmt fmt\n\n(* Extract the type representation (an fmtty) of a format. *)\nand fmtty_of_fmt : type a b c d e f .\n (a, b, c, d, e, f) fmt -> (a, b, c, d, e, f) fmtty =\nfun fmtty -> match fmtty with\n | String (pad, rest) ->\n fmtty_of_padding_fmtty pad (String_ty (fmtty_of_fmt rest))\n | Caml_string (pad, rest) ->\n fmtty_of_padding_fmtty pad (String_ty (fmtty_of_fmt rest))\n\n | Int (_, pad, prec, rest) ->\n let ty_rest = fmtty_of_fmt rest in\n let prec_ty = fmtty_of_precision_fmtty prec (Int_ty ty_rest) in\n fmtty_of_padding_fmtty pad prec_ty\n | Int32 (_, pad, prec, rest) ->\n let ty_rest = fmtty_of_fmt rest in\n let prec_ty = fmtty_of_precision_fmtty prec (Int32_ty ty_rest) in\n fmtty_of_padding_fmtty pad prec_ty\n | Nativeint (_, pad, prec, rest) ->\n let ty_rest = fmtty_of_fmt rest in\n let prec_ty = fmtty_of_precision_fmtty prec (Nativeint_ty ty_rest) in\n fmtty_of_padding_fmtty pad prec_ty\n | Int64 (_, pad, prec, rest) ->\n let ty_rest = fmtty_of_fmt rest in\n let prec_ty = fmtty_of_precision_fmtty prec (Int64_ty ty_rest) in\n fmtty_of_padding_fmtty pad prec_ty\n | Float (_, pad, prec, rest) ->\n let ty_rest = fmtty_of_fmt rest in\n let prec_ty = fmtty_of_precision_fmtty prec (Float_ty ty_rest) in\n fmtty_of_padding_fmtty pad prec_ty\n\n | Char rest -> Char_ty (fmtty_of_fmt rest)\n | Caml_char rest -> Char_ty (fmtty_of_fmt rest)\n | Bool (pad, rest) ->\n fmtty_of_padding_fmtty pad (Bool_ty (fmtty_of_fmt rest))\n | Alpha rest -> Alpha_ty (fmtty_of_fmt rest)\n | Theta rest -> Theta_ty (fmtty_of_fmt rest)\n | Custom (arity, _, rest) -> fmtty_of_custom arity (fmtty_of_fmt rest)\n | Reader rest -> Reader_ty (fmtty_of_fmt rest)\n\n | Format_arg (_, ty, rest) ->\n Format_arg_ty (ty, fmtty_of_fmt rest)\n | Format_subst (_, ty, rest) ->\n Format_subst_ty (ty, ty, fmtty_of_fmt rest)\n\n | Flush rest -> fmtty_of_fmt rest\n | String_literal (_, rest) -> fmtty_of_fmt rest\n | Char_literal (_, rest) -> fmtty_of_fmt rest\n\n | Scan_char_set (_, _, rest) -> String_ty (fmtty_of_fmt rest)\n | Scan_get_counter (_, rest) -> Int_ty (fmtty_of_fmt rest)\n | Scan_next_char rest -> Char_ty (fmtty_of_fmt rest)\n | Ignored_param (ign, rest) -> fmtty_of_ignored_format ign rest\n | Formatting_lit (_, rest) -> fmtty_of_fmt rest\n | Formatting_gen (fmting_gen, rest) ->\n concat_fmtty (fmtty_of_formatting_gen fmting_gen) (fmtty_of_fmt rest)\n\n | End_of_format -> End_of_fmtty\n\nand fmtty_of_custom : type x y a b c d e f .\n (a, x, y) custom_arity -> (a, b, c, d, e, f) fmtty ->\n (y, b, c, d, e, f) fmtty =\nfun arity fmtty -> match arity with\n | Custom_zero -> fmtty\n | Custom_succ arity -> Any_ty (fmtty_of_custom arity fmtty)\n\n(* Extract the fmtty of an ignored parameter followed by the rest of\n the format. *)\nand fmtty_of_ignored_format : type x y a b c d e f .\n (a, b, c, d, y, x) ignored ->\n (x, b, c, y, e, f) fmt ->\n (a, b, c, d, e, f) fmtty =\nfun ign fmt -> match ign with\n | Ignored_char -> fmtty_of_fmt fmt\n | Ignored_caml_char -> fmtty_of_fmt fmt\n | Ignored_string _ -> fmtty_of_fmt fmt\n | Ignored_caml_string _ -> fmtty_of_fmt fmt\n | Ignored_int (_, _) -> fmtty_of_fmt fmt\n | Ignored_int32 (_, _) -> fmtty_of_fmt fmt\n | Ignored_nativeint (_, _) -> fmtty_of_fmt fmt\n | Ignored_int64 (_, _) -> fmtty_of_fmt fmt\n | Ignored_float (_, _) -> fmtty_of_fmt fmt\n | Ignored_bool _ -> fmtty_of_fmt fmt\n | Ignored_format_arg _ -> fmtty_of_fmt fmt\n | Ignored_format_subst (_, fmtty) -> concat_fmtty fmtty (fmtty_of_fmt fmt)\n | Ignored_reader -> Ignored_reader_ty (fmtty_of_fmt fmt)\n | Ignored_scan_char_set _ -> fmtty_of_fmt fmt\n | Ignored_scan_get_counter _ -> fmtty_of_fmt fmt\n | Ignored_scan_next_char -> fmtty_of_fmt fmt\n\n(* Add an Int_ty node if padding is taken as an extra argument (ex: \"%*s\"). *)\nand fmtty_of_padding_fmtty : type x a b c d e f .\n (x, a) padding -> (a, b, c, d, e, f) fmtty -> (x, b, c, d, e, f) fmtty =\n fun pad fmtty -> match pad with\n | No_padding -> fmtty\n | Lit_padding _ -> fmtty\n | Arg_padding _ -> Int_ty fmtty\n\n(* Add an Int_ty node if precision is taken as an extra argument (ex: \"%.*f\").*)\nand fmtty_of_precision_fmtty : type x a b c d e f .\n (x, a) precision -> (a, b, c, d, e, f) fmtty -> (x, b, c, d, e, f) fmtty =\n fun prec fmtty -> match prec with\n | No_precision -> fmtty\n | Lit_precision _ -> fmtty\n | Arg_precision -> Int_ty fmtty\n\n(******************************************************************************)\n (* Format typing *)\n\n(* Exception raised when a format does not match a given format type. *)\nexception Type_mismatch\n\n(* Type a padding. *)\n(* Take an Int_ty from the fmtty if the integer should be kept as argument. *)\n(* Raise Type_mismatch in case of type mismatch. *)\nlet type_padding : type a b c d e f x y .\n (x, y) padding -> (a, b, c, d, e, f) fmtty ->\n (a, b, c, d, e, f) padding_fmtty_ebb =\nfun pad fmtty -> match pad, fmtty with\n | No_padding, _ -> Padding_fmtty_EBB (No_padding, fmtty)\n | Lit_padding (padty, w), _ -> Padding_fmtty_EBB (Lit_padding (padty,w),fmtty)\n | Arg_padding padty, Int_ty rest -> Padding_fmtty_EBB (Arg_padding padty,rest)\n | _ -> raise Type_mismatch\n\n(* Convert a (upadding, uprecision) to a (padding, precision). *)\n(* Take one or two Int_ty from the fmtty if needed. *)\n(* Raise Type_mismatch in case of type mismatch. *)\nlet type_padprec : type a b c d e f x y z .\n (x, y) padding -> (y, z) precision -> (a, b, c, d, e, f) fmtty ->\n (a, b, c, d, e, f) padprec_fmtty_ebb =\nfun pad prec fmtty -> match prec, type_padding pad fmtty with\n | No_precision, Padding_fmtty_EBB (pad, rest) ->\n Padprec_fmtty_EBB (pad, No_precision, rest)\n | Lit_precision p, Padding_fmtty_EBB (pad, rest) ->\n Padprec_fmtty_EBB (pad, Lit_precision p, rest)\n | Arg_precision, Padding_fmtty_EBB (pad, Int_ty rest) ->\n Padprec_fmtty_EBB (pad, Arg_precision, rest)\n | _, Padding_fmtty_EBB (_, _) -> raise Type_mismatch\n\n(* Type a format according to an fmtty. *)\n(* If typing succeed, generate a copy of the format with the same\n type parameters as the fmtty. *)\n(* Raise [Failure] with an error message in case of type mismatch. *)\nlet rec type_format :\n type a1 b1 c1 d1 e1 f1\n a2 b2 c2 d2 e2 f2 .\n (a1, b1, c1, d1, e1, f1) fmt\n -> (a2, b2, c2, d2, e2, f2) fmtty\n -> (a2, b2, c2, d2, e2, f2) fmt\n= fun fmt fmtty -> match type_format_gen fmt fmtty with\n | Fmt_fmtty_EBB (fmt', End_of_fmtty) -> fmt'\n | _ -> raise Type_mismatch\n\nand type_format_gen :\n type a1 b1 c1 d1 e1 f1\n a2 b2 c2 d2 e2 f2 .\n (a1, b1, c1, d1, e1, f1) fmt\n -> (a2, b2, c2, d2, e2, f2) fmtty\n -> (a2, b2, c2, d2, e2, f2) fmt_fmtty_ebb\n= fun fmt fmtty -> match fmt, fmtty with\n | Char fmt_rest, Char_ty fmtty_rest ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (Char fmt', fmtty')\n | Caml_char fmt_rest, Char_ty fmtty_rest ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (Caml_char fmt', fmtty')\n | String (pad, fmt_rest), _ -> (\n match type_padding pad fmtty with\n | Padding_fmtty_EBB (pad, String_ty fmtty_rest) ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (String (pad, fmt'), fmtty')\n | Padding_fmtty_EBB (_, _) -> raise Type_mismatch\n )\n | Caml_string (pad, fmt_rest), _ -> (\n match type_padding pad fmtty with\n | Padding_fmtty_EBB (pad, String_ty fmtty_rest) ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (Caml_string (pad, fmt'), fmtty')\n | Padding_fmtty_EBB (_, _) -> raise Type_mismatch\n )\n | Int (iconv, pad, prec, fmt_rest), _ -> (\n match type_padprec pad prec fmtty with\n | Padprec_fmtty_EBB (pad, prec, Int_ty fmtty_rest) ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (Int (iconv, pad, prec, fmt'), fmtty')\n | Padprec_fmtty_EBB (_, _, _) -> raise Type_mismatch\n )\n | Int32 (iconv, pad, prec, fmt_rest), _ -> (\n match type_padprec pad prec fmtty with\n | Padprec_fmtty_EBB (pad, prec, Int32_ty fmtty_rest) ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (Int32 (iconv, pad, prec, fmt'), fmtty')\n | Padprec_fmtty_EBB (_, _, _) -> raise Type_mismatch\n )\n | Nativeint (iconv, pad, prec, fmt_rest), _ -> (\n match type_padprec pad prec fmtty with\n | Padprec_fmtty_EBB (pad, prec, Nativeint_ty fmtty_rest) ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (Nativeint (iconv, pad, prec, fmt'), fmtty')\n | Padprec_fmtty_EBB (_, _, _) -> raise Type_mismatch\n )\n | Int64 (iconv, pad, prec, fmt_rest), _ -> (\n match type_padprec pad prec fmtty with\n | Padprec_fmtty_EBB (pad, prec, Int64_ty fmtty_rest) ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (Int64 (iconv, pad, prec, fmt'), fmtty')\n | Padprec_fmtty_EBB (_, _, _) -> raise Type_mismatch\n )\n | Float (fconv, pad, prec, fmt_rest), _ -> (\n match type_padprec pad prec fmtty with\n | Padprec_fmtty_EBB (pad, prec, Float_ty fmtty_rest) ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (Float (fconv, pad, prec, fmt'), fmtty')\n | Padprec_fmtty_EBB (_, _, _) -> raise Type_mismatch\n )\n | Bool (pad, fmt_rest), _ -> (\n match type_padding pad fmtty with\n | Padding_fmtty_EBB (pad, Bool_ty fmtty_rest) ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (Bool (pad, fmt'), fmtty')\n | Padding_fmtty_EBB (_, _) -> raise Type_mismatch\n )\n | Flush fmt_rest, fmtty_rest ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (Flush fmt', fmtty')\n\n | String_literal (str, fmt_rest), fmtty_rest ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (String_literal (str, fmt'), fmtty')\n | Char_literal (chr, fmt_rest), fmtty_rest ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (Char_literal (chr, fmt'), fmtty')\n\n | Format_arg (pad_opt, sub_fmtty, fmt_rest),\n Format_arg_ty (sub_fmtty', fmtty_rest) ->\n if Fmtty_EBB sub_fmtty <> Fmtty_EBB sub_fmtty' then raise Type_mismatch;\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (Format_arg (pad_opt, sub_fmtty', fmt'), fmtty')\n | Format_subst (pad_opt, sub_fmtty, fmt_rest),\n Format_subst_ty (sub_fmtty1, _sub_fmtty2, fmtty_rest) ->\n if Fmtty_EBB (erase_rel sub_fmtty) <> Fmtty_EBB (erase_rel sub_fmtty1) then\n raise Type_mismatch;\n let Fmt_fmtty_EBB (fmt', fmtty') =\n type_format_gen fmt_rest (erase_rel fmtty_rest)\n in\n Fmt_fmtty_EBB (Format_subst (pad_opt, sub_fmtty1, fmt'), fmtty')\n (* Printf and Format specific constructors: *)\n | Alpha fmt_rest, Alpha_ty fmtty_rest ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (Alpha fmt', fmtty')\n | Theta fmt_rest, Theta_ty fmtty_rest ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (Theta fmt', fmtty')\n\n (* Format specific constructors: *)\n | Formatting_lit (formatting_lit, fmt_rest), fmtty_rest ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (Formatting_lit (formatting_lit, fmt'), fmtty')\n | Formatting_gen (formatting_gen, fmt_rest), fmtty_rest ->\n type_formatting_gen formatting_gen fmt_rest fmtty_rest\n\n (* Scanf specific constructors: *)\n | Reader fmt_rest, Reader_ty fmtty_rest ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (Reader fmt', fmtty')\n | Scan_char_set (width_opt, char_set, fmt_rest), String_ty fmtty_rest ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (Scan_char_set (width_opt, char_set, fmt'), fmtty')\n | Scan_get_counter (counter, fmt_rest), Int_ty fmtty_rest ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (Scan_get_counter (counter, fmt'), fmtty')\n | Ignored_param (ign, rest), fmtty_rest ->\n type_ignored_param ign rest fmtty_rest\n\n | End_of_format, fmtty_rest -> Fmt_fmtty_EBB (End_of_format, fmtty_rest)\n\n | _ -> raise Type_mismatch\n\nand type_formatting_gen : type a1 a3 b1 b3 c1 c3 d1 d3 e1 e2 e3 f1 f2 f3 .\n (a1, b1, c1, d1, e1, f1) formatting_gen ->\n (f1, b1, c1, e1, e2, f2) fmt ->\n (a3, b3, c3, d3, e3, f3) fmtty ->\n (a3, b3, c3, d3, e3, f3) fmt_fmtty_ebb =\nfun formatting_gen fmt0 fmtty0 -> match formatting_gen with\n | Open_tag (Format (fmt1, str)) ->\n let Fmt_fmtty_EBB (fmt2, fmtty2) = type_format_gen fmt1 fmtty0 in\n let Fmt_fmtty_EBB (fmt3, fmtty3) = type_format_gen fmt0 fmtty2 in\n Fmt_fmtty_EBB (Formatting_gen (Open_tag (Format (fmt2, str)), fmt3), fmtty3)\n | Open_box (Format (fmt1, str)) ->\n let Fmt_fmtty_EBB (fmt2, fmtty2) = type_format_gen fmt1 fmtty0 in\n let Fmt_fmtty_EBB (fmt3, fmtty3) = type_format_gen fmt0 fmtty2 in\n Fmt_fmtty_EBB (Formatting_gen (Open_box (Format (fmt2, str)), fmt3), fmtty3)\n\n(* Type an Ignored_param node according to an fmtty. *)\nand type_ignored_param : type p q x y z t u v a b c d e f .\n (x, y, z, t, q, p) ignored ->\n (p, y, z, q, u, v) fmt ->\n (a, b, c, d, e, f) fmtty ->\n (a, b, c, d, e, f) fmt_fmtty_ebb =\nfun ign fmt fmtty -> match ign with\n | Ignored_char as ign' -> type_ignored_param_one ign' fmt fmtty\n | Ignored_caml_char as ign' -> type_ignored_param_one ign' fmt fmtty\n | Ignored_string _ as ign' -> type_ignored_param_one ign' fmt fmtty\n | Ignored_caml_string _ as ign' -> type_ignored_param_one ign' fmt fmtty\n | Ignored_int _ as ign' -> type_ignored_param_one ign' fmt fmtty\n | Ignored_int32 _ as ign' -> type_ignored_param_one ign' fmt fmtty\n | Ignored_nativeint _ as ign' -> type_ignored_param_one ign' fmt fmtty\n | Ignored_int64 _ as ign' -> type_ignored_param_one ign' fmt fmtty\n | Ignored_float _ as ign' -> type_ignored_param_one ign' fmt fmtty\n | Ignored_bool _ as ign' -> type_ignored_param_one ign' fmt fmtty\n | Ignored_scan_char_set _ as ign' -> type_ignored_param_one ign' fmt fmtty\n | Ignored_scan_get_counter _ as ign' -> type_ignored_param_one ign' fmt fmtty\n | Ignored_scan_next_char as ign' -> type_ignored_param_one ign' fmt fmtty\n | Ignored_format_arg (pad_opt, sub_fmtty) ->\n type_ignored_param_one (Ignored_format_arg (pad_opt, sub_fmtty)) fmt fmtty\n | Ignored_format_subst (pad_opt, sub_fmtty) ->\n let Fmtty_fmt_EBB (sub_fmtty', Fmt_fmtty_EBB (fmt', fmtty')) =\n type_ignored_format_substitution sub_fmtty fmt fmtty in\n Fmt_fmtty_EBB (Ignored_param (Ignored_format_subst (pad_opt, sub_fmtty'),\n fmt'),\n fmtty')\n | Ignored_reader -> (\n match fmtty with\n | Ignored_reader_ty fmtty_rest ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt fmtty_rest in\n Fmt_fmtty_EBB (Ignored_param (Ignored_reader, fmt'), fmtty')\n | _ -> raise Type_mismatch\n )\n\nand type_ignored_param_one : type a1 a2 b1 b2 c1 c2 d1 d2 e1 e2 f1 f2 .\n (a2, b2, c2, d2, d2, a2) ignored ->\n (a1, b1, c1, d1, e1, f1) fmt ->\n (a2, b2, c2, d2, e2, f2) fmtty ->\n (a2, b2, c2, d2, e2, f2) fmt_fmtty_ebb\n= fun ign fmt fmtty ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt fmtty in\n Fmt_fmtty_EBB (Ignored_param (ign, fmt'), fmtty')\n\n(* Typing of the complex case: \"%_(...%)\". *)\nand type_ignored_format_substitution : type w x y z p s t u a b c d e f .\n (w, x, y, z, s, p) fmtty ->\n (p, x, y, s, t, u) fmt ->\n (a, b, c, d, e, f) fmtty -> (a, b, c, d, e, f) fmtty_fmt_ebb =\nfun sub_fmtty fmt fmtty -> match sub_fmtty, fmtty with\n | Char_ty sub_fmtty_rest, Char_ty fmtty_rest ->\n let Fmtty_fmt_EBB (sub_fmtty_rest', fmt') =\n type_ignored_format_substitution sub_fmtty_rest fmt fmtty_rest in\n Fmtty_fmt_EBB (Char_ty sub_fmtty_rest', fmt')\n | String_ty sub_fmtty_rest, String_ty fmtty_rest ->\n let Fmtty_fmt_EBB (sub_fmtty_rest', fmt') =\n type_ignored_format_substitution sub_fmtty_rest fmt fmtty_rest in\n Fmtty_fmt_EBB (String_ty sub_fmtty_rest', fmt')\n | Int_ty sub_fmtty_rest, Int_ty fmtty_rest ->\n let Fmtty_fmt_EBB (sub_fmtty_rest', fmt') =\n type_ignored_format_substitution sub_fmtty_rest fmt fmtty_rest in\n Fmtty_fmt_EBB (Int_ty sub_fmtty_rest', fmt')\n | Int32_ty sub_fmtty_rest, Int32_ty fmtty_rest ->\n let Fmtty_fmt_EBB (sub_fmtty_rest', fmt') =\n type_ignored_format_substitution sub_fmtty_rest fmt fmtty_rest in\n Fmtty_fmt_EBB (Int32_ty sub_fmtty_rest', fmt')\n | Nativeint_ty sub_fmtty_rest, Nativeint_ty fmtty_rest ->\n let Fmtty_fmt_EBB (sub_fmtty_rest', fmt') =\n type_ignored_format_substitution sub_fmtty_rest fmt fmtty_rest in\n Fmtty_fmt_EBB (Nativeint_ty sub_fmtty_rest', fmt')\n | Int64_ty sub_fmtty_rest, Int64_ty fmtty_rest ->\n let Fmtty_fmt_EBB (sub_fmtty_rest', fmt') =\n type_ignored_format_substitution sub_fmtty_rest fmt fmtty_rest in\n Fmtty_fmt_EBB (Int64_ty sub_fmtty_rest', fmt')\n | Float_ty sub_fmtty_rest, Float_ty fmtty_rest ->\n let Fmtty_fmt_EBB (sub_fmtty_rest', fmt') =\n type_ignored_format_substitution sub_fmtty_rest fmt fmtty_rest in\n Fmtty_fmt_EBB (Float_ty sub_fmtty_rest', fmt')\n | Bool_ty sub_fmtty_rest, Bool_ty fmtty_rest ->\n let Fmtty_fmt_EBB (sub_fmtty_rest', fmt') =\n type_ignored_format_substitution sub_fmtty_rest fmt fmtty_rest in\n Fmtty_fmt_EBB (Bool_ty sub_fmtty_rest', fmt')\n | Alpha_ty sub_fmtty_rest, Alpha_ty fmtty_rest ->\n let Fmtty_fmt_EBB (sub_fmtty_rest', fmt') =\n type_ignored_format_substitution sub_fmtty_rest fmt fmtty_rest in\n Fmtty_fmt_EBB (Alpha_ty sub_fmtty_rest', fmt')\n | Theta_ty sub_fmtty_rest, Theta_ty fmtty_rest ->\n let Fmtty_fmt_EBB (sub_fmtty_rest', fmt') =\n type_ignored_format_substitution sub_fmtty_rest fmt fmtty_rest in\n Fmtty_fmt_EBB (Theta_ty sub_fmtty_rest', fmt')\n | Reader_ty sub_fmtty_rest, Reader_ty fmtty_rest ->\n let Fmtty_fmt_EBB (sub_fmtty_rest', fmt') =\n type_ignored_format_substitution sub_fmtty_rest fmt fmtty_rest in\n Fmtty_fmt_EBB (Reader_ty sub_fmtty_rest', fmt')\n | Ignored_reader_ty sub_fmtty_rest, Ignored_reader_ty fmtty_rest ->\n let Fmtty_fmt_EBB (sub_fmtty_rest', fmt') =\n type_ignored_format_substitution sub_fmtty_rest fmt fmtty_rest in\n Fmtty_fmt_EBB (Ignored_reader_ty sub_fmtty_rest', fmt')\n\n | Format_arg_ty (sub2_fmtty, sub_fmtty_rest),\n Format_arg_ty (sub2_fmtty', fmtty_rest) ->\n if Fmtty_EBB sub2_fmtty <> Fmtty_EBB sub2_fmtty' then raise Type_mismatch;\n let Fmtty_fmt_EBB (sub_fmtty_rest', fmt') =\n type_ignored_format_substitution sub_fmtty_rest fmt fmtty_rest in\n Fmtty_fmt_EBB (Format_arg_ty (sub2_fmtty', sub_fmtty_rest'), fmt')\n | Format_subst_ty (sub1_fmtty, sub2_fmtty, sub_fmtty_rest),\n Format_subst_ty (sub1_fmtty', sub2_fmtty', fmtty_rest) ->\n (* TODO define Fmtty_rel_EBB to remove those erase_rel *)\n if Fmtty_EBB (erase_rel sub1_fmtty) <> Fmtty_EBB (erase_rel sub1_fmtty')\n then raise Type_mismatch;\n if Fmtty_EBB (erase_rel sub2_fmtty) <> Fmtty_EBB (erase_rel sub2_fmtty')\n then raise Type_mismatch;\n let sub_fmtty' = trans (symm sub1_fmtty') sub2_fmtty' in\n let _, f2, _, f4 = fmtty_rel_det sub_fmtty' in\n let Refl = f2 Refl in\n let Refl = f4 Refl in\n let Fmtty_fmt_EBB (sub_fmtty_rest', fmt') =\n type_ignored_format_substitution (erase_rel sub_fmtty_rest) fmt fmtty_rest\n in\n Fmtty_fmt_EBB (Format_subst_ty (sub1_fmtty', sub2_fmtty',\n symm sub_fmtty_rest'),\n fmt')\n | End_of_fmtty, fmtty ->\n Fmtty_fmt_EBB (End_of_fmtty, type_format_gen fmt fmtty)\n | _ -> raise Type_mismatch\n\n(* This implementation of `recast` is a bit disappointing. The\n invariant provided by the type are very strong: the input format's\n type is in relation to the output type's as witnessed by the\n fmtty_rel argument. One would at first expect this function to be\n total, and implementable by exhaustive pattern matching. Instead,\n we reuse the highly partial and much less well-defined function\n `type_format` that has lost all knowledge of the correspondence\n between the argument's types.\n\n Besides the fact that this function reuses a lot of the\n `type_format` logic (eg.: seeing Int_ty in the fmtty parameter does\n not let you match on Int only, as you may in fact have Float\n (Arg_padding, ...) (\"%.*d\") beginning with an Int_ty), it is also\n a partial function, because the typing information in a format is\n not quite enough to reconstruct it unambiguously. For example, the\n format types of \"%d%_r\" and \"%_r%d\" have the same format6\n parameters, but they are not at all exchangeable, and putting one\n in place of the other must result in a dynamic failure.\n\n Given that:\n - we'd have to duplicate a lot of non-trivial typing logic from type_format\n - this wouldn't even eliminate (all) the dynamic failures\n we decided to just reuse type_format directly for now.\n*)\nlet recast :\n type a1 b1 c1 d1 e1 f1\n a2 b2 c2 d2 e2 f2\n .\n (a1, b1, c1, d1, e1, f1) fmt\n -> (a1, b1, c1, d1, e1, f1,\n a2, b2, c2, d2, e2, f2) fmtty_rel\n -> (a2, b2, c2, d2, e2, f2) fmt\n= fun fmt fmtty ->\n type_format fmt (erase_rel (symm fmtty))\n\n(******************************************************************************)\n (* Printing tools *)\n\n(* Add padding spaces around a string. *)\nlet fix_padding padty width str =\n let len = String.length str in\n let width, padty =\n abs width,\n (* while literal padding widths are always non-negative,\n dynamically-set widths (Arg_padding, eg. %*d) may be negative;\n we interpret those as specifying a padding-to-the-left; this\n means that '0' may get dropped even if it was explicitly set,\n but:\n - this is what the legacy implementation does, and\n we preserve compatibility if possible\n - we could only signal this issue by failing at runtime,\n which is not very nice... *)\n if width < 0 then Left else padty in\n if width <= len then str else\n let res = Bytes.make width (if padty = Zeros then '0' else ' ') in\n begin match padty with\n | Left -> String.blit str 0 res 0 len\n | Right -> String.blit str 0 res (width - len) len\n | Zeros when len > 0 && (str.[0] = '+' || str.[0] = '-' || str.[0] = ' ') ->\n Bytes.set res 0 str.[0];\n String.blit str 1 res (width - len + 1) (len - 1)\n | Zeros when len > 1 && str.[0] = '0' && (str.[1] = 'x' || str.[1] = 'X') ->\n Bytes.set res 1 str.[1];\n String.blit str 2 res (width - len + 2) (len - 2)\n | Zeros ->\n String.blit str 0 res (width - len) len\n end;\n Bytes.unsafe_to_string res\n\n(* Add '0' padding to int, int32, nativeint or int64 string representation. *)\nlet fix_int_precision prec str =\n let prec = abs prec in\n let len = String.length str in\n match str.[0] with\n | ('+' | '-' | ' ') as c when prec + 1 > len ->\n let res = Bytes.make (prec + 1) '0' in\n Bytes.set res 0 c;\n String.blit str 1 res (prec - len + 2) (len - 1);\n Bytes.unsafe_to_string res\n | '0' when prec + 2 > len && len > 1 && (str.[1] = 'x' || str.[1] = 'X') ->\n let res = Bytes.make (prec + 2) '0' in\n Bytes.set res 1 str.[1];\n String.blit str 2 res (prec - len + 4) (len - 2);\n Bytes.unsafe_to_string res\n | '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' when prec > len ->\n let res = Bytes.make prec '0' in\n String.blit str 0 res (prec - len) len;\n Bytes.unsafe_to_string res\n | _ ->\n str\n\n(* Escape a string according to the OCaml lexing convention. *)\nlet string_to_caml_string str =\n let str = String.escaped str in\n let l = String.length str in\n let res = Bytes.make (l + 2) '\\\"' in\n String.unsafe_blit str 0 res 1 l;\n Bytes.unsafe_to_string res\n\n(* Generate the format_int/int32/nativeint/int64 first argument\n from an int_conv. *)\nlet format_of_iconv = function\n | Int_d | Int_Cd -> \"%d\" | Int_pd -> \"%+d\" | Int_sd -> \"% d\"\n | Int_i | Int_Ci -> \"%i\" | Int_pi -> \"%+i\" | Int_si -> \"% i\"\n | Int_x -> \"%x\" | Int_Cx -> \"%#x\"\n | Int_X -> \"%X\" | Int_CX -> \"%#X\"\n | Int_o -> \"%o\" | Int_Co -> \"%#o\"\n | Int_u | Int_Cu -> \"%u\"\n\nlet format_of_iconvL = function\n | Int_d | Int_Cd -> \"%Ld\" | Int_pd -> \"%+Ld\" | Int_sd -> \"% Ld\"\n | Int_i | Int_Ci -> \"%Li\" | Int_pi -> \"%+Li\" | Int_si -> \"% Li\"\n | Int_x -> \"%Lx\" | Int_Cx -> \"%#Lx\"\n | Int_X -> \"%LX\" | Int_CX -> \"%#LX\"\n | Int_o -> \"%Lo\" | Int_Co -> \"%#Lo\"\n | Int_u | Int_Cu -> \"%Lu\"\n\nlet format_of_iconvl = function\n | Int_d | Int_Cd -> \"%ld\" | Int_pd -> \"%+ld\" | Int_sd -> \"% ld\"\n | Int_i | Int_Ci -> \"%li\" | Int_pi -> \"%+li\" | Int_si -> \"% li\"\n | Int_x -> \"%lx\" | Int_Cx -> \"%#lx\"\n | Int_X -> \"%lX\" | Int_CX -> \"%#lX\"\n | Int_o -> \"%lo\" | Int_Co -> \"%#lo\"\n | Int_u | Int_Cu -> \"%lu\"\n\nlet format_of_iconvn = function\n | Int_d | Int_Cd -> \"%nd\" | Int_pd -> \"%+nd\" | Int_sd -> \"% nd\"\n | Int_i | Int_Ci -> \"%ni\" | Int_pi -> \"%+ni\" | Int_si -> \"% ni\"\n | Int_x -> \"%nx\" | Int_Cx -> \"%#nx\"\n | Int_X -> \"%nX\" | Int_CX -> \"%#nX\"\n | Int_o -> \"%no\" | Int_Co -> \"%#no\"\n | Int_u | Int_Cu -> \"%nu\"\n\n(* Generate the format_float first argument from a float_conv. *)\nlet format_of_fconv fconv prec =\n let prec = abs prec in\n let symb = char_of_fconv ~cF:'g' fconv in\n let buf = buffer_create 16 in\n buffer_add_char buf '%';\n bprint_fconv_flag buf fconv;\n buffer_add_char buf '.';\n buffer_add_string buf (Int.to_string prec);\n buffer_add_char buf symb;\n buffer_contents buf\n\nlet transform_int_alt iconv s =\n match iconv with\n | Int_Cd | Int_Ci | Int_Cu ->\n let digits =\n let n = ref 0 in\n for i = 0 to String.length s - 1 do\n match String.unsafe_get s i with\n | '0'..'9' -> incr n\n | _ -> ()\n done;\n !n\n in\n let buf = Bytes.create (String.length s + (digits - 1) / 3) in\n let pos = ref 0 in\n let put c = Bytes.set buf !pos c; incr pos in\n let left = ref ((digits - 1) mod 3 + 1) in\n for i = 0 to String.length s - 1 do\n match String.unsafe_get s i with\n | '0'..'9' as c ->\n if !left = 0 then (put '_'; left := 3); decr left; put c\n | c -> put c\n done;\n Bytes.unsafe_to_string buf\n | _ -> s\n\n(* Convert an integer to a string according to a conversion. *)\nlet convert_int iconv n =\n transform_int_alt iconv (format_int (format_of_iconv iconv) n)\nlet convert_int32 iconv n =\n transform_int_alt iconv (format_int32 (format_of_iconvl iconv) n)\nlet convert_nativeint iconv n =\n transform_int_alt iconv (format_nativeint (format_of_iconvn iconv) n)\nlet convert_int64 iconv n =\n transform_int_alt iconv (format_int64 (format_of_iconvL iconv) n)\n\n(* Convert a float to string. *)\n(* Fix special case of \"OCaml float format\". *)\nlet convert_float fconv prec x =\n let hex () =\n let sign =\n match fst fconv with\n | Float_flag_p -> '+'\n | Float_flag_s -> ' '\n | _ -> '-' in\n hexstring_of_float x prec sign in\n let add_dot_if_needed str =\n let len = String.length str in\n let rec is_valid i =\n if i = len then false else\n match str.[i] with\n | '.' | 'e' | 'E' -> true\n | _ -> is_valid (i + 1) in\n if is_valid 0 then str else str ^ \".\" in\n let caml_special_val str = match classify_float x with\n | FP_normal | FP_subnormal | FP_zero -> str\n | FP_infinite -> if x < 0.0 then \"neg_infinity\" else \"infinity\"\n | FP_nan -> \"nan\" in\n match snd fconv with\n | Float_h -> hex ()\n | Float_H -> String.uppercase_ascii (hex ())\n | Float_CF -> caml_special_val (hex ())\n | Float_F ->\n let str = format_float (format_of_fconv fconv prec) x in\n caml_special_val (add_dot_if_needed str)\n | Float_f | Float_e | Float_E | Float_g | Float_G ->\n format_float (format_of_fconv fconv prec) x\n\n(* Convert a char to a string according to the OCaml lexical convention. *)\nlet format_caml_char c =\n let str = Char.escaped c in\n let l = String.length str in\n let res = Bytes.make (l + 2) '\\'' in\n String.unsafe_blit str 0 res 1 l;\n Bytes.unsafe_to_string res\n\n(* Convert a format type to string *)\nlet string_of_fmtty fmtty =\n let buf = buffer_create 16 in\n bprint_fmtty buf fmtty;\n buffer_contents buf\n\n(******************************************************************************)\n (* Generic printing function *)\n\n(* Make a generic printing function. *)\n(* Used to generate Printf and Format printing functions. *)\n(* Parameters:\n k: a continuation finally applied to the output stream and the accumulator.\n o: the output stream (see k, %a and %t).\n acc: rev list of printing entities (string, char, flush, formatting, ...).\n fmt: the format. *)\nlet rec make_printf : type a b c d e f .\n ((b, c) acc -> f) -> (b, c) acc ->\n (a, b, c, d, e, f) fmt -> a =\nfun k acc fmt -> match fmt with\n | Char rest ->\n fun c ->\n let new_acc = Acc_data_char (acc, c) in\n make_printf k new_acc rest\n | Caml_char rest ->\n fun c ->\n let new_acc = Acc_data_string (acc, format_caml_char c) in\n make_printf k new_acc rest\n | String (pad, rest) ->\n make_padding k acc rest pad (fun str -> str)\n | Caml_string (pad, rest) ->\n make_padding k acc rest pad string_to_caml_string\n | Int (iconv, pad, prec, rest) ->\n make_int_padding_precision k acc rest pad prec convert_int iconv\n | Int32 (iconv, pad, prec, rest) ->\n make_int_padding_precision k acc rest pad prec convert_int32 iconv\n | Nativeint (iconv, pad, prec, rest) ->\n make_int_padding_precision k acc rest pad prec convert_nativeint iconv\n | Int64 (iconv, pad, prec, rest) ->\n make_int_padding_precision k acc rest pad prec convert_int64 iconv\n | Float (fconv, pad, prec, rest) ->\n make_float_padding_precision k acc rest pad prec fconv\n | Bool (pad, rest) ->\n make_padding k acc rest pad string_of_bool\n | Alpha rest ->\n fun f x -> make_printf k (Acc_delay (acc, fun o -> f o x)) rest\n | Theta rest ->\n fun f -> make_printf k (Acc_delay (acc, f)) rest\n | Custom (arity, f, rest) ->\n make_custom k acc rest arity (f ())\n | Reader _ ->\n (* This case is impossible, by typing of formats. *)\n (* Indeed, since printf and co. take a format4 as argument, the 'd and 'e\n type parameters of fmt are obviously equals. The Reader is the\n only constructor which touch 'd and 'e type parameters of the format\n type, it adds an (->) to the 'd parameters. Consequently, a format4\n cannot contain a Reader node, except in the sub-format associated to\n an %{...%}. It's not a problem because make_printf do not call\n itself recursively on the sub-format associated to %{...%}. *)\n assert false\n | Flush rest ->\n make_printf k (Acc_flush acc) rest\n\n | String_literal (str, rest) ->\n make_printf k (Acc_string_literal (acc, str)) rest\n | Char_literal (chr, rest) ->\n make_printf k (Acc_char_literal (acc, chr)) rest\n\n | Format_arg (_, sub_fmtty, rest) ->\n let ty = string_of_fmtty sub_fmtty in\n (fun str ->\n ignore str;\n make_printf k (Acc_data_string (acc, ty)) rest)\n | Format_subst (_, fmtty, rest) ->\n fun (Format (fmt, _)) -> make_printf k acc\n (concat_fmt (recast fmt fmtty) rest)\n\n | Scan_char_set (_, _, rest) ->\n let new_acc = Acc_invalid_arg (acc, \"Printf: bad conversion %[\") in\n fun _ -> make_printf k new_acc rest\n | Scan_get_counter (_, rest) ->\n (* This case should be refused for Printf. *)\n (* Accepted for backward compatibility. *)\n (* Interpret %l, %n and %L as %u. *)\n fun n ->\n let new_acc = Acc_data_string (acc, format_int \"%u\" n) in\n make_printf k new_acc rest\n | Scan_next_char rest ->\n fun c ->\n let new_acc = Acc_data_char (acc, c) in\n make_printf k new_acc rest\n | Ignored_param (ign, rest) ->\n make_ignored_param k acc ign rest\n\n | Formatting_lit (fmting_lit, rest) ->\n make_printf k (Acc_formatting_lit (acc, fmting_lit)) rest\n | Formatting_gen (Open_tag (Format (fmt', _)), rest) ->\n let k' kacc =\n make_printf k (Acc_formatting_gen (acc, Acc_open_tag kacc)) rest in\n make_printf k' End_of_acc fmt'\n | Formatting_gen (Open_box (Format (fmt', _)), rest) ->\n let k' kacc =\n make_printf k (Acc_formatting_gen (acc, Acc_open_box kacc)) rest in\n make_printf k' End_of_acc fmt'\n\n | End_of_format ->\n k acc\n\n(* Delay the error (Invalid_argument \"Printf: bad conversion %_\"). *)\n(* Generate functions to take remaining arguments (after the \"%_\"). *)\nand make_ignored_param : type x y a b c d e f .\n ((b, c) acc -> f) -> (b, c) acc ->\n (a, b, c, d, y, x) ignored ->\n (x, b, c, y, e, f) fmt -> a =\nfun k acc ign fmt -> match ign with\n | Ignored_char -> make_invalid_arg k acc fmt\n | Ignored_caml_char -> make_invalid_arg k acc fmt\n | Ignored_string _ -> make_invalid_arg k acc fmt\n | Ignored_caml_string _ -> make_invalid_arg k acc fmt\n | Ignored_int (_, _) -> make_invalid_arg k acc fmt\n | Ignored_int32 (_, _) -> make_invalid_arg k acc fmt\n | Ignored_nativeint (_, _) -> make_invalid_arg k acc fmt\n | Ignored_int64 (_, _) -> make_invalid_arg k acc fmt\n | Ignored_float (_, _) -> make_invalid_arg k acc fmt\n | Ignored_bool _ -> make_invalid_arg k acc fmt\n | Ignored_format_arg _ -> make_invalid_arg k acc fmt\n | Ignored_format_subst (_, fmtty) -> make_from_fmtty k acc fmtty fmt\n | Ignored_reader -> assert false\n | Ignored_scan_char_set _ -> make_invalid_arg k acc fmt\n | Ignored_scan_get_counter _ -> make_invalid_arg k acc fmt\n | Ignored_scan_next_char -> make_invalid_arg k acc fmt\n\n\n(* Special case of printf \"%_(\". *)\nand make_from_fmtty : type x y a b c d e f .\n ((b, c) acc -> f) -> (b, c) acc ->\n (a, b, c, d, y, x) fmtty ->\n (x, b, c, y, e, f) fmt -> a =\nfun k acc fmtty fmt -> match fmtty with\n | Char_ty rest -> fun _ -> make_from_fmtty k acc rest fmt\n | String_ty rest -> fun _ -> make_from_fmtty k acc rest fmt\n | Int_ty rest -> fun _ -> make_from_fmtty k acc rest fmt\n | Int32_ty rest -> fun _ -> make_from_fmtty k acc rest fmt\n | Nativeint_ty rest -> fun _ -> make_from_fmtty k acc rest fmt\n | Int64_ty rest -> fun _ -> make_from_fmtty k acc rest fmt\n | Float_ty rest -> fun _ -> make_from_fmtty k acc rest fmt\n | Bool_ty rest -> fun _ -> make_from_fmtty k acc rest fmt\n | Alpha_ty rest -> fun _ _ -> make_from_fmtty k acc rest fmt\n | Theta_ty rest -> fun _ -> make_from_fmtty k acc rest fmt\n | Any_ty rest -> fun _ -> make_from_fmtty k acc rest fmt\n | Reader_ty _ -> assert false\n | Ignored_reader_ty _ -> assert false\n | Format_arg_ty (_, rest) -> fun _ -> make_from_fmtty k acc rest fmt\n | End_of_fmtty -> make_invalid_arg k acc fmt\n | Format_subst_ty (ty1, ty2, rest) ->\n let ty = trans (symm ty1) ty2 in\n fun _ -> make_from_fmtty k acc (concat_fmtty ty rest) fmt\n\n(* Insert an Acc_invalid_arg in the accumulator and continue to generate\n closures to get the remaining arguments. *)\nand make_invalid_arg : type a b c d e f .\n ((b, c) acc -> f) -> (b, c) acc ->\n (a, b, c, d, e, f) fmt -> a =\nfun k acc fmt ->\n make_printf k (Acc_invalid_arg (acc, \"Printf: bad conversion %_\")) fmt\n\n(* Fix padding, take it as an extra integer argument if needed. *)\nand make_padding : type x z a b c d e f .\n ((b, c) acc -> f) -> (b, c) acc ->\n (a, b, c, d, e, f) fmt ->\n (x, z -> a) padding -> (z -> string) -> x =\n fun k acc fmt pad trans -> match pad with\n | No_padding ->\n fun x ->\n let new_acc = Acc_data_string (acc, trans x) in\n make_printf k new_acc fmt\n | Lit_padding (padty, width) ->\n fun x ->\n let new_acc = Acc_data_string (acc, fix_padding padty width (trans x)) in\n make_printf k new_acc fmt\n | Arg_padding padty ->\n fun w x ->\n let new_acc = Acc_data_string (acc, fix_padding padty w (trans x)) in\n make_printf k new_acc fmt\n\n(* Fix padding and precision for int, int32, nativeint or int64. *)\n(* Take one or two extra integer arguments if needed. *)\nand make_int_padding_precision : type x y z a b c d e f .\n ((b, c) acc -> f) -> (b, c) acc ->\n (a, b, c, d, e, f) fmt ->\n (x, y) padding -> (y, z -> a) precision -> (int_conv -> z -> string) ->\n int_conv -> x =\n fun k acc fmt pad prec trans iconv -> match pad, prec with\n | No_padding, No_precision ->\n fun x ->\n let str = trans iconv x in\n make_printf k (Acc_data_string (acc, str)) fmt\n | No_padding, Lit_precision p ->\n fun x ->\n let str = fix_int_precision p (trans iconv x) in\n make_printf k (Acc_data_string (acc, str)) fmt\n | No_padding, Arg_precision ->\n fun p x ->\n let str = fix_int_precision p (trans iconv x) in\n make_printf k (Acc_data_string (acc, str)) fmt\n | Lit_padding (padty, w), No_precision ->\n fun x ->\n let str = fix_padding padty w (trans iconv x) in\n make_printf k (Acc_data_string (acc, str)) fmt\n | Lit_padding (padty, w), Lit_precision p ->\n fun x ->\n let str = fix_padding padty w (fix_int_precision p (trans iconv x)) in\n make_printf k (Acc_data_string (acc, str)) fmt\n | Lit_padding (padty, w), Arg_precision ->\n fun p x ->\n let str = fix_padding padty w (fix_int_precision p (trans iconv x)) in\n make_printf k (Acc_data_string (acc, str)) fmt\n | Arg_padding padty, No_precision ->\n fun w x ->\n let str = fix_padding padty w (trans iconv x) in\n make_printf k (Acc_data_string (acc, str)) fmt\n | Arg_padding padty, Lit_precision p ->\n fun w x ->\n let str = fix_padding padty w (fix_int_precision p (trans iconv x)) in\n make_printf k (Acc_data_string (acc, str)) fmt\n | Arg_padding padty, Arg_precision ->\n fun w p x ->\n let str = fix_padding padty w (fix_int_precision p (trans iconv x)) in\n make_printf k (Acc_data_string (acc, str)) fmt\n\n(* Convert a float, fix padding and precision if needed. *)\n(* Take the float argument and one or two extra integer arguments if needed. *)\nand make_float_padding_precision : type x y a b c d e f .\n ((b, c) acc -> f) -> (b, c) acc ->\n (a, b, c, d, e, f) fmt ->\n (x, y) padding -> (y, float -> a) precision -> float_conv -> x =\n fun k acc fmt pad prec fconv -> match pad, prec with\n | No_padding, No_precision ->\n fun x ->\n let str = convert_float fconv (default_float_precision fconv) x in\n make_printf k (Acc_data_string (acc, str)) fmt\n | No_padding, Lit_precision p ->\n fun x ->\n let str = convert_float fconv p x in\n make_printf k (Acc_data_string (acc, str)) fmt\n | No_padding, Arg_precision ->\n fun p x ->\n let str = convert_float fconv p x in\n make_printf k (Acc_data_string (acc, str)) fmt\n | Lit_padding (padty, w), No_precision ->\n fun x ->\n let str = convert_float fconv (default_float_precision fconv) x in\n let str' = fix_padding padty w str in\n make_printf k (Acc_data_string (acc, str')) fmt\n | Lit_padding (padty, w), Lit_precision p ->\n fun x ->\n let str = fix_padding padty w (convert_float fconv p x) in\n make_printf k (Acc_data_string (acc, str)) fmt\n | Lit_padding (padty, w), Arg_precision ->\n fun p x ->\n let str = fix_padding padty w (convert_float fconv p x) in\n make_printf k (Acc_data_string (acc, str)) fmt\n | Arg_padding padty, No_precision ->\n fun w x ->\n let str = convert_float fconv (default_float_precision fconv) x in\n let str' = fix_padding padty w str in\n make_printf k (Acc_data_string (acc, str')) fmt\n | Arg_padding padty, Lit_precision p ->\n fun w x ->\n let str = fix_padding padty w (convert_float fconv p x) in\n make_printf k (Acc_data_string (acc, str)) fmt\n | Arg_padding padty, Arg_precision ->\n fun w p x ->\n let str = fix_padding padty w (convert_float fconv p x) in\n make_printf k (Acc_data_string (acc, str)) fmt\nand make_custom : type x y a b c d e f .\n ((b, c) acc -> f) -> (b, c) acc ->\n (a, b, c, d, e, f) fmt ->\n (a, x, y) custom_arity -> x -> y =\n fun k acc rest arity f -> match arity with\n | Custom_zero -> make_printf k (Acc_data_string (acc, f)) rest\n | Custom_succ arity ->\n fun x ->\n make_custom k acc rest arity (f x)\n\nlet const x _ = x\n\nlet rec make_iprintf : type a b c d e f state.\n (state -> f) -> state -> (a, b, c, d, e, f) fmt -> a =\n fun k o fmt -> match fmt with\n | Char rest ->\n const (make_iprintf k o rest)\n | Caml_char rest ->\n const (make_iprintf k o rest)\n | String (No_padding, rest) ->\n const (make_iprintf k o rest)\n | String (Lit_padding _, rest) ->\n const (make_iprintf k o rest)\n | String (Arg_padding _, rest) ->\n const (const (make_iprintf k o rest))\n | Caml_string (No_padding, rest) ->\n const (make_iprintf k o rest)\n | Caml_string (Lit_padding _, rest) ->\n const (make_iprintf k o rest)\n | Caml_string (Arg_padding _, rest) ->\n const (const (make_iprintf k o rest))\n | Int (_, pad, prec, rest) ->\n fn_of_padding_precision k o rest pad prec\n | Int32 (_, pad, prec, rest) ->\n fn_of_padding_precision k o rest pad prec\n | Nativeint (_, pad, prec, rest) ->\n fn_of_padding_precision k o rest pad prec\n | Int64 (_, pad, prec, rest) ->\n fn_of_padding_precision k o rest pad prec\n | Float (_, pad, prec, rest) ->\n fn_of_padding_precision k o rest pad prec\n | Bool (No_padding, rest) ->\n const (make_iprintf k o rest)\n | Bool (Lit_padding _, rest) ->\n const (make_iprintf k o rest)\n | Bool (Arg_padding _, rest) ->\n const (const (make_iprintf k o rest))\n | Alpha rest ->\n const (const (make_iprintf k o rest))\n | Theta rest ->\n const (make_iprintf k o rest)\n | Custom (arity, _, rest) ->\n fn_of_custom_arity k o rest arity\n | Reader _ ->\n (* This case is impossible, by typing of formats. See the\n note in the corresponding case for make_printf. *)\n assert false\n | Flush rest ->\n make_iprintf k o rest\n | String_literal (_, rest) ->\n make_iprintf k o rest\n | Char_literal (_, rest) ->\n make_iprintf k o rest\n | Format_arg (_, _, rest) ->\n const (make_iprintf k o rest)\n | Format_subst (_, fmtty, rest) ->\n fun (Format (fmt, _)) ->\n make_iprintf k o\n (concat_fmt (recast fmt fmtty) rest)\n | Scan_char_set (_, _, rest) ->\n const (make_iprintf k o rest)\n | Scan_get_counter (_, rest) ->\n const (make_iprintf k o rest)\n | Scan_next_char rest ->\n const (make_iprintf k o rest)\n | Ignored_param (ign, rest) ->\n make_ignored_param (fun _ -> k o) (End_of_acc) ign rest\n | Formatting_lit (_, rest) ->\n make_iprintf k o rest\n | Formatting_gen (Open_tag (Format (fmt', _)), rest) ->\n make_iprintf (fun koc -> make_iprintf k koc rest) o fmt'\n | Formatting_gen (Open_box (Format (fmt', _)), rest) ->\n make_iprintf (fun koc -> make_iprintf k koc rest) o fmt'\n | End_of_format ->\n k o\nand fn_of_padding_precision :\n type x y z a b c d e f state.\n (state -> f) -> state -> (a, b, c, d, e, f) fmt ->\n (x, y) padding -> (y, z -> a) precision -> x =\n fun k o fmt pad prec -> match pad, prec with\n | No_padding , No_precision ->\n const (make_iprintf k o fmt)\n | No_padding , Lit_precision _ ->\n const (make_iprintf k o fmt)\n | No_padding , Arg_precision ->\n const (const (make_iprintf k o fmt))\n | Lit_padding _, No_precision ->\n const (make_iprintf k o fmt)\n | Lit_padding _, Lit_precision _ ->\n const (make_iprintf k o fmt)\n | Lit_padding _, Arg_precision ->\n const (const (make_iprintf k o fmt))\n | Arg_padding _, No_precision ->\n const (const (make_iprintf k o fmt))\n | Arg_padding _, Lit_precision _ ->\n const (const (make_iprintf k o fmt))\n | Arg_padding _, Arg_precision ->\n const (const (const (make_iprintf k o fmt)))\nand fn_of_custom_arity : type x y a b c d e f state.\n (state -> f) ->\n state -> (a, b, c, d, e, f) fmt -> (a, x, y) custom_arity -> y =\n fun k o fmt -> function\n | Custom_zero ->\n make_iprintf k o fmt\n | Custom_succ arity ->\n const (fn_of_custom_arity k o fmt arity)\n\n(******************************************************************************)\n (* Continuations for make_printf *)\n\n(* Recursively output an \"accumulator\" containing a reversed list of\n printing entities (string, char, flus, ...) in an output_stream. *)\n(* Used as a continuation of make_printf. *)\nlet rec output_acc o acc = match acc with\n | Acc_formatting_lit (p, fmting_lit) ->\n let s = string_of_formatting_lit fmting_lit in\n output_acc o p; output_string o s;\n | Acc_formatting_gen (p, Acc_open_tag acc') ->\n output_acc o p; output_string o \"@{\"; output_acc o acc';\n | Acc_formatting_gen (p, Acc_open_box acc') ->\n output_acc o p; output_string o \"@[\"; output_acc o acc';\n | Acc_string_literal (p, s)\n | Acc_data_string (p, s) -> output_acc o p; output_string o s\n | Acc_char_literal (p, c)\n | Acc_data_char (p, c) -> output_acc o p; output_char o c\n | Acc_delay (p, f) -> output_acc o p; f o\n | Acc_flush p -> output_acc o p; flush o\n | Acc_invalid_arg (p, msg) -> output_acc o p; invalid_arg msg;\n | End_of_acc -> ()\n\n(* Recursively output an \"accumulator\" containing a reversed list of\n printing entities (string, char, flus, ...) in a buffer. *)\n(* Used as a continuation of make_printf. *)\nlet rec bufput_acc b acc = match acc with\n | Acc_formatting_lit (p, fmting_lit) ->\n let s = string_of_formatting_lit fmting_lit in\n bufput_acc b p; Buffer.add_string b s;\n | Acc_formatting_gen (p, Acc_open_tag acc') ->\n bufput_acc b p; Buffer.add_string b \"@{\"; bufput_acc b acc';\n | Acc_formatting_gen (p, Acc_open_box acc') ->\n bufput_acc b p; Buffer.add_string b \"@[\"; bufput_acc b acc';\n | Acc_string_literal (p, s)\n | Acc_data_string (p, s) -> bufput_acc b p; Buffer.add_string b s\n | Acc_char_literal (p, c)\n | Acc_data_char (p, c) -> bufput_acc b p; Buffer.add_char b c\n | Acc_delay (p, f) -> bufput_acc b p; f b\n | Acc_flush p -> bufput_acc b p;\n | Acc_invalid_arg (p, msg) -> bufput_acc b p; invalid_arg msg;\n | End_of_acc -> ()\n\n(* Recursively output an \"accumulator\" containing a reversed list of\n printing entities (string, char, flus, ...) in a buffer. *)\n(* Differ from bufput_acc by the interpretation of %a and %t. *)\n(* Used as a continuation of make_printf. *)\nlet rec strput_acc b acc = match acc with\n | Acc_formatting_lit (p, fmting_lit) ->\n let s = string_of_formatting_lit fmting_lit in\n strput_acc b p; Buffer.add_string b s;\n | Acc_formatting_gen (p, Acc_open_tag acc') ->\n strput_acc b p; Buffer.add_string b \"@{\"; strput_acc b acc';\n | Acc_formatting_gen (p, Acc_open_box acc') ->\n strput_acc b p; Buffer.add_string b \"@[\"; strput_acc b acc';\n | Acc_string_literal (p, s)\n | Acc_data_string (p, s) -> strput_acc b p; Buffer.add_string b s\n | Acc_char_literal (p, c)\n | Acc_data_char (p, c) -> strput_acc b p; Buffer.add_char b c\n | Acc_delay (p, f) -> strput_acc b p; Buffer.add_string b (f ())\n | Acc_flush p -> strput_acc b p;\n | Acc_invalid_arg (p, msg) -> strput_acc b p; invalid_arg msg;\n | End_of_acc -> ()\n\n(******************************************************************************)\n (* Error management *)\n\n(* Raise [Failure] with a pretty-printed error message. *)\nlet failwith_message (Format (fmt, _)) =\n let buf = Buffer.create 256 in\n let k acc = strput_acc buf acc; failwith (Buffer.contents buf) in\n make_printf k End_of_acc fmt\n\n(******************************************************************************)\n (* Formatting tools *)\n\n(* Convert a string to an open block description (indent, block_type) *)\nlet open_box_of_string str =\n if str = \"\" then (0, Pp_box) else\n let len = String.length str in\n let invalid_box () = failwith_message \"invalid box description %S\" str in\n let rec parse_spaces i =\n if i = len then i else\n match str.[i] with\n | ' ' | '\\t' -> parse_spaces (i + 1)\n | _ -> i\n and parse_lword i j =\n if j = len then j else\n match str.[j] with\n | 'a' .. 'z' -> parse_lword i (j + 1)\n | _ -> j\n and parse_int i j =\n if j = len then j else\n match str.[j] with\n | '0' .. '9' | '-' -> parse_int i (j + 1)\n | _ -> j in\n let wstart = parse_spaces 0 in\n let wend = parse_lword wstart wstart in\n let box_name = String.sub str wstart (wend - wstart) in\n let nstart = parse_spaces wend in\n let nend = parse_int nstart nstart in\n let indent =\n if nstart = nend then 0 else\n try int_of_string (String.sub str nstart (nend - nstart))\n with Failure _ -> invalid_box () in\n let exp_end = parse_spaces nend in\n if exp_end <> len then invalid_box ();\n let box_type = match box_name with\n | \"\" | \"b\" -> Pp_box\n | \"h\" -> Pp_hbox\n | \"v\" -> Pp_vbox\n | \"hv\" -> Pp_hvbox\n | \"hov\" -> Pp_hovbox\n | _ -> invalid_box () in\n (indent, box_type)\n\n(******************************************************************************)\n (* Parsing tools *)\n\n(* Create a padding_fmt_ebb from a padding and a format. *)\n(* Copy the padding to disjoin the type parameters of argument and result. *)\nlet make_padding_fmt_ebb : type x y .\n (x, y) padding -> (_, _, _, _, _, _) fmt ->\n (_, _, _, _, _) padding_fmt_ebb =\nfun pad fmt -> match pad with\n | No_padding -> Padding_fmt_EBB (No_padding, fmt)\n | Lit_padding (s, w) -> Padding_fmt_EBB (Lit_padding (s, w), fmt)\n | Arg_padding s -> Padding_fmt_EBB (Arg_padding s, fmt)\n\n(* Create a precision_fmt_ebb from a precision and a format. *)\n(* Copy the precision to disjoin the type parameters of argument and result. *)\nlet make_precision_fmt_ebb : type x y .\n (x, y) precision -> (_, _, _, _, _, _) fmt ->\n (_, _, _, _, _) precision_fmt_ebb =\nfun prec fmt -> match prec with\n | No_precision -> Precision_fmt_EBB (No_precision, fmt)\n | Lit_precision p -> Precision_fmt_EBB (Lit_precision p, fmt)\n | Arg_precision -> Precision_fmt_EBB (Arg_precision, fmt)\n\n(* Create a padprec_fmt_ebb from a padding, a precision and a format. *)\n(* Copy the padding and the precision to disjoin type parameters of arguments\n and result. *)\nlet make_padprec_fmt_ebb : type x y z t .\n (x, y) padding -> (z, t) precision ->\n (_, _, _, _, _, _) fmt ->\n (_, _, _, _, _) padprec_fmt_ebb =\nfun pad prec fmt ->\n let Precision_fmt_EBB (prec, fmt') = make_precision_fmt_ebb prec fmt in\n match pad with\n | No_padding -> Padprec_fmt_EBB (No_padding, prec, fmt')\n | Lit_padding (s, w) -> Padprec_fmt_EBB (Lit_padding (s, w), prec, fmt')\n | Arg_padding s -> Padprec_fmt_EBB (Arg_padding s, prec, fmt')\n\n(******************************************************************************)\n (* Format parsing *)\n\n(* Parse a string representing a format and create a fmt_ebb. *)\n(* Raise [Failure] in case of invalid format. *)\nlet fmt_ebb_of_string ?legacy_behavior str =\n (* Parameters naming convention: *)\n (* - lit_start: start of the literal sequence. *)\n (* - str_ind: current index in the string. *)\n (* - end_ind: end of the current (sub-)format. *)\n (* - pct_ind: index of the '%' in the current micro-format. *)\n (* - zero: is the '0' flag defined in the current micro-format. *)\n (* - minus: is the '-' flag defined in the current micro-format. *)\n (* - plus: is the '+' flag defined in the current micro-format. *)\n (* - hash: is the '#' flag defined in the current micro-format. *)\n (* - space: is the ' ' flag defined in the current micro-format. *)\n (* - ign: is the '_' flag defined in the current micro-format. *)\n (* - pad: padding of the current micro-format. *)\n (* - prec: precision of the current micro-format. *)\n (* - symb: char representing the conversion ('c', 's', 'd', ...). *)\n (* - char_set: set of characters as bitmap (see scanf %[...]). *)\n\n let legacy_behavior = match legacy_behavior with\n | Some flag -> flag\n | None -> true\n (* When this flag is enabled, the format parser tries to behave as\n the <4.02 implementations, in particular it ignores most benine\n nonsensical format. When the flag is disabled, it will reject any\n format that is not accepted by the specification.\n\n A typical example would be \"%+ d\": specifying both '+' (if the\n number is positive, pad with a '+' to get the same width as\n negative numbers) and ' ' (if the number is positive, pad with\n a space) does not make sense, but the legacy (< 4.02)\n implementation was happy to just ignore the space.\n *)\n in\n\n (* Raise [Failure] with a friendly error message. *)\n let invalid_format_message str_ind msg =\n failwith_message\n \"invalid format %S: at character number %d, %s\"\n str str_ind msg\n in\n\n (* Used when the end of the format (or the current sub-format) was encountered\n unexpectedly. *)\n let unexpected_end_of_format end_ind =\n invalid_format_message end_ind\n \"unexpected end of format\"\n in\n\n (* Used for %0c: no other widths are implemented *)\n let invalid_nonnull_char_width str_ind =\n invalid_format_message str_ind\n \"non-zero widths are unsupported for %c conversions\"\n in\n (* Raise [Failure] with a friendly error message about an option dependency\n problem. *)\n let invalid_format_without str_ind c s =\n failwith_message\n \"invalid format %S: at character number %d, '%c' without %s\"\n str str_ind c s\n in\n\n (* Raise [Failure] with a friendly error message about an unexpected\n character. *)\n let expected_character str_ind expected read =\n failwith_message\n \"invalid format %S: at character number %d, %s expected, read %C\"\n str str_ind expected read\n in\n\n (* Parse the string from beg_ind (included) to end_ind (excluded). *)\n let rec parse : type e f . int -> int -> (_, _, e, f) fmt_ebb =\n fun beg_ind end_ind -> parse_literal beg_ind beg_ind end_ind\n\n (* Read literal characters up to '%' or '@' special characters. *)\n and parse_literal : type e f . int -> int -> int -> (_, _, e, f) fmt_ebb =\n fun lit_start str_ind end_ind ->\n if str_ind = end_ind then add_literal lit_start str_ind End_of_format else\n match str.[str_ind] with\n | '%' ->\n let Fmt_EBB fmt_rest = parse_format str_ind end_ind in\n add_literal lit_start str_ind fmt_rest\n | '@' ->\n let Fmt_EBB fmt_rest = parse_after_at (str_ind + 1) end_ind in\n add_literal lit_start str_ind fmt_rest\n | _ ->\n parse_literal lit_start (str_ind + 1) end_ind\n\n (* Parse a format after '%' *)\n and parse_format : type e f . int -> int -> (_, _, e, f) fmt_ebb =\n fun pct_ind end_ind -> parse_ign pct_ind (pct_ind + 1) end_ind\n\n and parse_ign : type e f . int -> int -> int -> (_, _, e, f) fmt_ebb =\n fun pct_ind str_ind end_ind ->\n if str_ind = end_ind then unexpected_end_of_format end_ind;\n match str.[str_ind] with\n | '_' -> parse_flags pct_ind (str_ind+1) end_ind true\n | _ -> parse_flags pct_ind str_ind end_ind false\n\n and parse_flags : type e f . int -> int -> int -> bool -> (_, _, e, f) fmt_ebb\n =\n fun pct_ind str_ind end_ind ign ->\n let zero = ref false and minus = ref false\n and plus = ref false and space = ref false\n and hash = ref false in\n let set_flag str_ind flag =\n (* in legacy mode, duplicate flags are accepted *)\n if !flag && not legacy_behavior then\n failwith_message\n \"invalid format %S: at character number %d, duplicate flag %C\"\n str str_ind str.[str_ind];\n flag := true;\n in\n let rec read_flags str_ind =\n if str_ind = end_ind then unexpected_end_of_format end_ind;\n begin match str.[str_ind] with\n | '0' -> set_flag str_ind zero; read_flags (str_ind + 1)\n | '-' -> set_flag str_ind minus; read_flags (str_ind + 1)\n | '+' -> set_flag str_ind plus; read_flags (str_ind + 1)\n | '#' -> set_flag str_ind hash; read_flags (str_ind + 1)\n | ' ' -> set_flag str_ind space; read_flags (str_ind + 1)\n | _ ->\n parse_padding pct_ind str_ind end_ind\n !zero !minus !plus !hash !space ign\n end\n in\n read_flags str_ind\n\n (* Try to read a digital or a '*' padding. *)\n and parse_padding : type e f .\n int -> int -> int -> bool -> bool -> bool -> bool -> bool -> bool ->\n (_, _, e, f) fmt_ebb =\n fun pct_ind str_ind end_ind zero minus plus hash space ign ->\n if str_ind = end_ind then unexpected_end_of_format end_ind;\n let padty = match zero, minus with\n | false, false -> Right\n | false, true -> Left\n | true, false -> Zeros\n | true, true ->\n if legacy_behavior then Left\n else incompatible_flag pct_ind str_ind '-' \"0\" in\n match str.[str_ind] with\n | '0' .. '9' ->\n let new_ind, width = parse_positive str_ind end_ind 0 in\n parse_after_padding pct_ind new_ind end_ind minus plus hash space ign\n (Lit_padding (padty, width))\n | '*' ->\n parse_after_padding pct_ind (str_ind + 1) end_ind minus plus hash space\n ign (Arg_padding padty)\n | _ ->\n begin match padty with\n | Left ->\n if not legacy_behavior then\n invalid_format_without (str_ind - 1) '-' \"padding\";\n parse_after_padding pct_ind str_ind end_ind minus plus hash space ign\n No_padding\n | Zeros ->\n (* a '0' padding indication not followed by anything should\n be interpreted as a Right padding of width 0. This is used\n by scanning conversions %0s and %0c *)\n parse_after_padding pct_ind str_ind end_ind minus plus hash space ign\n (Lit_padding (Right, 0))\n | Right ->\n parse_after_padding pct_ind str_ind end_ind minus plus hash space ign\n No_padding\n end\n\n (* Is precision defined? *)\n and parse_after_padding : type x e f .\n int -> int -> int -> bool -> bool -> bool -> bool -> bool ->\n (x, _) padding -> (_, _, e, f) fmt_ebb =\n fun pct_ind str_ind end_ind minus plus hash space ign pad ->\n if str_ind = end_ind then unexpected_end_of_format end_ind;\n match str.[str_ind] with\n | '.' ->\n parse_precision pct_ind (str_ind + 1) end_ind minus plus hash space ign\n pad\n | symb ->\n parse_conversion pct_ind (str_ind + 1) end_ind plus hash space ign pad\n No_precision pad symb\n\n (* Read the digital or '*' precision. *)\n and parse_precision : type x e f .\n int -> int -> int -> bool -> bool -> bool -> bool -> bool ->\n (x, _) padding -> (_, _, e, f) fmt_ebb =\n fun pct_ind str_ind end_ind minus plus hash space ign pad ->\n if str_ind = end_ind then unexpected_end_of_format end_ind;\n let parse_literal minus str_ind =\n let new_ind, prec = parse_positive str_ind end_ind 0 in\n parse_after_precision pct_ind new_ind end_ind minus plus hash space ign\n pad (Lit_precision prec) in\n match str.[str_ind] with\n | '0' .. '9' -> parse_literal minus str_ind\n | ('+' | '-') as symb when legacy_behavior ->\n (* Legacy mode would accept and ignore '+' or '-' before the\n integer describing the desired precision; note that this\n cannot happen for padding width, as '+' and '-' already have\n a semantics there.\n\n That said, the idea (supported by this tweak) that width and\n precision literals are \"integer literals\" in the OCaml sense is\n still blatantly wrong, as 123_456 or 0xFF are rejected. *)\n parse_literal (minus || symb = '-') (str_ind + 1)\n | '*' ->\n parse_after_precision pct_ind (str_ind + 1) end_ind minus plus hash space\n ign pad Arg_precision\n | _ ->\n if legacy_behavior then\n (* note that legacy implementation did not ignore '.' without\n a number (as it does for padding indications), but\n interprets it as '.0' *)\n parse_after_precision pct_ind str_ind end_ind minus plus hash space ign\n pad (Lit_precision 0)\n else\n invalid_format_without (str_ind - 1) '.' \"precision\"\n\n (* Try to read the conversion. *)\n and parse_after_precision : type x y z t e f .\n int -> int -> int -> bool -> bool -> bool -> bool -> bool ->\n (x, y) padding -> (z, t) precision -> (_, _, e, f) fmt_ebb =\n fun pct_ind str_ind end_ind minus plus hash space ign pad prec ->\n if str_ind = end_ind then unexpected_end_of_format end_ind;\n let parse_conv (type u) (type v) (padprec : (u, v) padding) =\n parse_conversion pct_ind (str_ind + 1) end_ind plus hash space ign pad\n prec padprec str.[str_ind] in\n (* in legacy mode, some formats (%s and %S) accept a weird mix of\n padding and precision, which is merged as a single padding\n information. For example, in %.10s the precision is implicitly\n understood as padding %10s, but the left-padding component may\n be specified either as a left padding or a negative precision:\n %-.3s and %.-3s are equivalent to %-3s *)\n match pad with\n | No_padding -> (\n match minus, prec with\n | _, No_precision -> parse_conv No_padding\n | false, Lit_precision n -> parse_conv (Lit_padding (Right, n))\n | true, Lit_precision n -> parse_conv (Lit_padding (Left, n))\n | false, Arg_precision -> parse_conv (Arg_padding Right)\n | true, Arg_precision -> parse_conv (Arg_padding Left)\n )\n | pad -> parse_conv pad\n\n (* Case analysis on conversion. *)\n and parse_conversion : type x y z t u v e f .\n int -> int -> int -> bool -> bool -> bool -> bool -> (x, y) padding ->\n (z, t) precision -> (u, v) padding -> char -> (_, _, e, f) fmt_ebb =\n fun pct_ind str_ind end_ind plus hash space ign pad prec padprec symb ->\n (* Flags used to check option usages/compatibilities. *)\n let plus_used = ref false and hash_used = ref false\n and space_used = ref false and ign_used = ref false\n and pad_used = ref false and prec_used = ref false in\n\n (* Access to options, update flags. *)\n let get_plus () = plus_used := true; plus\n and get_hash () = hash_used := true; hash\n and get_space () = space_used := true; space\n and get_ign () = ign_used := true; ign\n and get_pad () = pad_used := true; pad\n and get_prec () = prec_used := true; prec\n and get_padprec () = pad_used := true; padprec in\n\n let get_int_pad () : (x,y) padding =\n (* %5.3d is accepted and meaningful: pad to length 5 with\n spaces, but first pad with zeros upto length 3 (0-padding\n is the interpretation of \"precision\" for integer formats).\n\n %05.3d is redundant: pad to length 5 *with zeros*, but\n first pad with zeros... To add insult to the injury, the\n legacy implementation ignores the 0-padding indication and\n does the 5 padding with spaces instead. We reuse this\n interpretation for compatibility, but statically reject this\n format when the legacy mode is disabled, to protect strict\n users from this corner case. *)\n match get_pad (), get_prec () with\n | pad, No_precision -> pad\n | No_padding, _ -> No_padding\n | Lit_padding (Zeros, n), _ ->\n if legacy_behavior then Lit_padding (Right, n)\n else incompatible_flag pct_ind str_ind '0' \"precision\"\n | Arg_padding Zeros, _ ->\n if legacy_behavior then Arg_padding Right\n else incompatible_flag pct_ind str_ind '0' \"precision\"\n | Lit_padding _ as pad, _ -> pad\n | Arg_padding _ as pad, _ -> pad in\n\n (* Check that padty <> Zeros. *)\n let check_no_0 symb (type a b) (pad : (a, b) padding) : (a,b) padding =\n match pad with\n | No_padding -> pad\n | Lit_padding ((Left | Right), _) -> pad\n | Arg_padding (Left | Right) -> pad\n | Lit_padding (Zeros, width) ->\n if legacy_behavior then Lit_padding (Right, width)\n else incompatible_flag pct_ind str_ind symb \"0\"\n | Arg_padding Zeros ->\n if legacy_behavior then Arg_padding Right\n else incompatible_flag pct_ind str_ind symb \"0\"\n in\n\n (* Get padding as a pad_option (see \"%_\", \"%{\", \"%(\" and \"%[\").\n (no need for legacy mode tweaking, those were rejected by the\n legacy parser as well) *)\n let opt_of_pad c (type a) (type b) (pad : (a, b) padding) = match pad with\n | No_padding -> None\n | Lit_padding (Right, width) -> Some width\n | Lit_padding (Zeros, width) ->\n if legacy_behavior then Some width\n else incompatible_flag pct_ind str_ind c \"'0'\"\n | Lit_padding (Left, width) ->\n if legacy_behavior then Some width\n else incompatible_flag pct_ind str_ind c \"'-'\"\n | Arg_padding _ -> incompatible_flag pct_ind str_ind c \"'*'\"\n in\n let get_pad_opt c = opt_of_pad c (get_pad ()) in\n let get_padprec_opt c = opt_of_pad c (get_padprec ()) in\n\n (* Get precision as a prec_option (see \"%_f\").\n (no need for legacy mode tweaking, those were rejected by the\n legacy parser as well) *)\n let get_prec_opt () = match get_prec () with\n | No_precision -> None\n | Lit_precision ndec -> Some ndec\n | Arg_precision -> incompatible_flag pct_ind str_ind '_' \"'*'\"\n in\n\n let fmt_result = match symb with\n | ',' ->\n parse str_ind end_ind\n | 'c' ->\n let char_format fmt_rest = (* %c *)\n if get_ign ()\n then Fmt_EBB (Ignored_param (Ignored_char, fmt_rest))\n else Fmt_EBB (Char fmt_rest)\n in\n let scan_format fmt_rest = (* %0c *)\n if get_ign ()\n then Fmt_EBB (Ignored_param (Ignored_scan_next_char, fmt_rest))\n else Fmt_EBB (Scan_next_char fmt_rest)\n in\n let Fmt_EBB fmt_rest = parse str_ind end_ind in\n begin match get_pad_opt 'c' with\n | None -> char_format fmt_rest\n | Some 0 -> scan_format fmt_rest\n | Some _n ->\n if not legacy_behavior\n then invalid_nonnull_char_width str_ind\n else (* legacy ignores %c widths *) char_format fmt_rest\n end\n | 'C' ->\n let Fmt_EBB fmt_rest = parse str_ind end_ind in\n if get_ign () then Fmt_EBB (Ignored_param (Ignored_caml_char,fmt_rest))\n else Fmt_EBB (Caml_char fmt_rest)\n | 's' ->\n let pad = check_no_0 symb (get_padprec ()) in\n let Fmt_EBB fmt_rest = parse str_ind end_ind in\n if get_ign () then\n let ignored = Ignored_string (get_padprec_opt '_') in\n Fmt_EBB (Ignored_param (ignored, fmt_rest))\n else\n let Padding_fmt_EBB (pad', fmt_rest') =\n make_padding_fmt_ebb pad fmt_rest in\n Fmt_EBB (String (pad', fmt_rest'))\n | 'S' ->\n let pad = check_no_0 symb (get_padprec ()) in\n let Fmt_EBB fmt_rest = parse str_ind end_ind in\n if get_ign () then\n let ignored = Ignored_caml_string (get_padprec_opt '_') in\n Fmt_EBB (Ignored_param (ignored, fmt_rest))\n else\n let Padding_fmt_EBB (pad', fmt_rest') =\n make_padding_fmt_ebb pad fmt_rest in\n Fmt_EBB (Caml_string (pad', fmt_rest'))\n | 'd' | 'i' | 'x' | 'X' | 'o' | 'u' ->\n let iconv = compute_int_conv pct_ind str_ind (get_plus ()) (get_hash ())\n (get_space ()) symb in\n let Fmt_EBB fmt_rest = parse str_ind end_ind in\n if get_ign () then\n let ignored = Ignored_int (iconv, get_pad_opt '_') in\n Fmt_EBB (Ignored_param (ignored, fmt_rest))\n else\n let Padprec_fmt_EBB (pad', prec', fmt_rest') =\n make_padprec_fmt_ebb (get_int_pad ()) (get_prec ()) fmt_rest in\n Fmt_EBB (Int (iconv, pad', prec', fmt_rest'))\n | 'N' ->\n let Fmt_EBB fmt_rest = parse str_ind end_ind in\n let counter = Token_counter in\n if get_ign () then\n let ignored = Ignored_scan_get_counter counter in\n Fmt_EBB (Ignored_param (ignored, fmt_rest))\n else\n Fmt_EBB (Scan_get_counter (counter, fmt_rest))\n | 'l' | 'n' | 'L' when str_ind=end_ind || not (is_int_base str.[str_ind]) ->\n let Fmt_EBB fmt_rest = parse str_ind end_ind in\n let counter = counter_of_char symb in\n if get_ign () then\n let ignored = Ignored_scan_get_counter counter in\n Fmt_EBB (Ignored_param (ignored, fmt_rest))\n else\n Fmt_EBB (Scan_get_counter (counter, fmt_rest))\n | 'l' ->\n let iconv =\n compute_int_conv pct_ind (str_ind + 1) (get_plus ()) (get_hash ())\n (get_space ()) str.[str_ind] in\n let Fmt_EBB fmt_rest = parse (str_ind + 1) end_ind in\n if get_ign () then\n let ignored = Ignored_int32 (iconv, get_pad_opt '_') in\n Fmt_EBB (Ignored_param (ignored, fmt_rest))\n else\n let Padprec_fmt_EBB (pad', prec', fmt_rest') =\n make_padprec_fmt_ebb (get_int_pad ()) (get_prec ()) fmt_rest in\n Fmt_EBB (Int32 (iconv, pad', prec', fmt_rest'))\n | 'n' ->\n let iconv =\n compute_int_conv pct_ind (str_ind + 1) (get_plus ())\n (get_hash ()) (get_space ()) str.[str_ind] in\n let Fmt_EBB fmt_rest = parse (str_ind + 1) end_ind in\n if get_ign () then\n let ignored = Ignored_nativeint (iconv, get_pad_opt '_') in\n Fmt_EBB (Ignored_param (ignored, fmt_rest))\n else\n let Padprec_fmt_EBB (pad', prec', fmt_rest') =\n make_padprec_fmt_ebb (get_int_pad ()) (get_prec ()) fmt_rest in\n Fmt_EBB (Nativeint (iconv, pad', prec', fmt_rest'))\n | 'L' ->\n let iconv =\n compute_int_conv pct_ind (str_ind + 1) (get_plus ()) (get_hash ())\n (get_space ()) str.[str_ind] in\n let Fmt_EBB fmt_rest = parse (str_ind + 1) end_ind in\n if get_ign () then\n let ignored = Ignored_int64 (iconv, get_pad_opt '_') in\n Fmt_EBB (Ignored_param (ignored, fmt_rest))\n else\n let Padprec_fmt_EBB (pad', prec', fmt_rest') =\n make_padprec_fmt_ebb (get_int_pad ()) (get_prec ()) fmt_rest in\n Fmt_EBB (Int64 (iconv, pad', prec', fmt_rest'))\n | 'f' | 'e' | 'E' | 'g' | 'G' | 'F' | 'h' | 'H' ->\n let fconv =\n compute_float_conv pct_ind str_ind\n (get_plus ()) (get_hash ()) (get_space ()) symb in\n let Fmt_EBB fmt_rest = parse str_ind end_ind in\n if get_ign () then\n let ignored = Ignored_float (get_pad_opt '_', get_prec_opt ()) in\n Fmt_EBB (Ignored_param (ignored, fmt_rest))\n else\n let Padprec_fmt_EBB (pad', prec', fmt_rest') =\n make_padprec_fmt_ebb (get_pad ()) (get_prec ()) fmt_rest in\n Fmt_EBB (Float (fconv, pad', prec', fmt_rest'))\n | 'b' | 'B' ->\n let pad = check_no_0 symb (get_padprec ()) in\n let Fmt_EBB fmt_rest = parse str_ind end_ind in\n if get_ign () then\n let ignored = Ignored_bool (get_padprec_opt '_') in\n Fmt_EBB (Ignored_param (ignored, fmt_rest))\n else\n let Padding_fmt_EBB (pad', fmt_rest') =\n make_padding_fmt_ebb pad fmt_rest in\n Fmt_EBB (Bool (pad', fmt_rest'))\n | 'a' ->\n let Fmt_EBB fmt_rest = parse str_ind end_ind in\n Fmt_EBB (Alpha fmt_rest)\n | 't' ->\n let Fmt_EBB fmt_rest = parse str_ind end_ind in\n Fmt_EBB (Theta fmt_rest)\n | 'r' ->\n let Fmt_EBB fmt_rest = parse str_ind end_ind in\n if get_ign () then Fmt_EBB (Ignored_param (Ignored_reader, fmt_rest))\n else Fmt_EBB (Reader fmt_rest)\n | '!' ->\n let Fmt_EBB fmt_rest = parse str_ind end_ind in\n Fmt_EBB (Flush fmt_rest)\n | ('%' | '@') as c ->\n let Fmt_EBB fmt_rest = parse str_ind end_ind in\n Fmt_EBB (Char_literal (c, fmt_rest))\n | '{' ->\n let sub_end = search_subformat_end str_ind end_ind '}' in\n let Fmt_EBB sub_fmt = parse str_ind sub_end in\n let Fmt_EBB fmt_rest = parse (sub_end + 2) end_ind in\n let sub_fmtty = fmtty_of_fmt sub_fmt in\n if get_ign () then\n let ignored = Ignored_format_arg (get_pad_opt '_', sub_fmtty) in\n Fmt_EBB (Ignored_param (ignored, fmt_rest))\n else\n Fmt_EBB (Format_arg (get_pad_opt '{', sub_fmtty, fmt_rest))\n | '(' ->\n let sub_end = search_subformat_end str_ind end_ind ')' in\n let Fmt_EBB fmt_rest = parse (sub_end + 2) end_ind in\n let Fmt_EBB sub_fmt = parse str_ind sub_end in\n let sub_fmtty = fmtty_of_fmt sub_fmt in\n if get_ign () then\n let ignored = Ignored_format_subst (get_pad_opt '_', sub_fmtty) in\n Fmt_EBB (Ignored_param (ignored, fmt_rest))\n else\n Fmt_EBB (Format_subst (get_pad_opt '(', sub_fmtty, fmt_rest))\n | '[' ->\n let next_ind, char_set = parse_char_set str_ind end_ind in\n let Fmt_EBB fmt_rest = parse next_ind end_ind in\n if get_ign () then\n let ignored = Ignored_scan_char_set (get_pad_opt '_', char_set) in\n Fmt_EBB (Ignored_param (ignored, fmt_rest))\n else\n Fmt_EBB (Scan_char_set (get_pad_opt '[', char_set, fmt_rest))\n | '-' | '+' | '#' | ' ' | '_' ->\n failwith_message\n \"invalid format %S: at character number %d, \\\n flag %C is only allowed after the '%%', before padding and precision\"\n str pct_ind symb\n | _ ->\n failwith_message\n \"invalid format %S: at character number %d, \\\n invalid conversion \\\"%%%c\\\"\" str (str_ind - 1) symb\n in\n (* Check for unused options, and reject them as incompatible.\n\n Such checks need to be disabled in legacy mode, as the legacy\n parser silently ignored incompatible flags. *)\n if not legacy_behavior then begin\n if not !plus_used && plus then\n incompatible_flag pct_ind str_ind symb \"'+'\";\n if not !hash_used && hash then\n incompatible_flag pct_ind str_ind symb \"'#'\";\n if not !space_used && space then\n incompatible_flag pct_ind str_ind symb \"' '\";\n if not !pad_used && Padding_EBB pad <> Padding_EBB No_padding then\n incompatible_flag pct_ind str_ind symb \"`padding'\";\n if not !prec_used && Precision_EBB prec <> Precision_EBB No_precision then\n incompatible_flag pct_ind str_ind (if ign then '_' else symb)\n \"`precision'\";\n if ign && plus then incompatible_flag pct_ind str_ind '_' \"'+'\";\n end;\n (* this last test must not be disabled in legacy mode,\n as ignoring it would typically result in a different typing\n than what the legacy parser used *)\n if not !ign_used && ign then\n begin match symb with\n (* argument-less formats can safely be ignored in legacy mode *)\n | ('@' | '%' | '!' | ',') when legacy_behavior -> ()\n | _ ->\n incompatible_flag pct_ind str_ind symb \"'_'\"\n end;\n fmt_result\n\n (* Parse formatting information (after '@'). *)\n and parse_after_at : type e f . int -> int -> (_, _, e, f) fmt_ebb =\n fun str_ind end_ind ->\n if str_ind = end_ind then Fmt_EBB (Char_literal ('@', End_of_format))\n else\n match str.[str_ind] with\n | '[' ->\n parse_tag false (str_ind + 1) end_ind\n | ']' ->\n let Fmt_EBB fmt_rest = parse (str_ind + 1) end_ind in\n Fmt_EBB (Formatting_lit (Close_box, fmt_rest))\n | '{' ->\n parse_tag true (str_ind + 1) end_ind\n | '}' ->\n let Fmt_EBB fmt_rest = parse (str_ind + 1) end_ind in\n Fmt_EBB (Formatting_lit (Close_tag, fmt_rest))\n | ',' ->\n let Fmt_EBB fmt_rest = parse (str_ind + 1) end_ind in\n Fmt_EBB (Formatting_lit (Break (\"@,\", 0, 0), fmt_rest))\n | ' ' ->\n let Fmt_EBB fmt_rest = parse (str_ind + 1) end_ind in\n Fmt_EBB (Formatting_lit (Break (\"@ \", 1, 0), fmt_rest))\n | ';' ->\n parse_good_break (str_ind + 1) end_ind\n | '?' ->\n let Fmt_EBB fmt_rest = parse (str_ind + 1) end_ind in\n Fmt_EBB (Formatting_lit (FFlush, fmt_rest))\n | '\\n' ->\n let Fmt_EBB fmt_rest = parse (str_ind + 1) end_ind in\n Fmt_EBB (Formatting_lit (Force_newline, fmt_rest))\n | '.' ->\n let Fmt_EBB fmt_rest = parse (str_ind + 1) end_ind in\n Fmt_EBB (Formatting_lit (Flush_newline, fmt_rest))\n | '<' ->\n parse_magic_size (str_ind + 1) end_ind\n | '@' ->\n let Fmt_EBB fmt_rest = parse (str_ind + 1) end_ind in\n Fmt_EBB (Formatting_lit (Escaped_at, fmt_rest))\n | '%' when str_ind + 1 < end_ind && str.[str_ind + 1] = '%' ->\n let Fmt_EBB fmt_rest = parse (str_ind + 2) end_ind in\n Fmt_EBB (Formatting_lit (Escaped_percent, fmt_rest))\n | '%' ->\n let Fmt_EBB fmt_rest = parse str_ind end_ind in\n Fmt_EBB (Char_literal ('@', fmt_rest))\n | c ->\n let Fmt_EBB fmt_rest = parse (str_ind + 1) end_ind in\n Fmt_EBB (Formatting_lit (Scan_indic c, fmt_rest))\n\n (* Try to read the optional after \"@{\" or \"@[\". *)\n and parse_tag : type e f . bool -> int -> int -> (_, _, e, f) fmt_ebb =\n fun is_open_tag str_ind end_ind ->\n try\n if str_ind = end_ind then raise Not_found;\n match str.[str_ind] with\n | '<' ->\n let ind = String.index_from str (str_ind + 1) '>' in\n if ind >= end_ind then raise Not_found;\n let sub_str = String.sub str str_ind (ind - str_ind + 1) in\n let Fmt_EBB fmt_rest = parse (ind + 1) end_ind in\n let Fmt_EBB sub_fmt = parse str_ind (ind + 1) in\n let sub_format = Format (sub_fmt, sub_str) in\n let formatting =\n if is_open_tag then Open_tag sub_format else Open_box sub_format in\n Fmt_EBB (Formatting_gen (formatting, fmt_rest))\n | _ ->\n raise Not_found\n with Not_found ->\n let Fmt_EBB fmt_rest = parse str_ind end_ind in\n let sub_format = Format (End_of_format, \"\") in\n let formatting =\n if is_open_tag then Open_tag sub_format else Open_box sub_format in\n Fmt_EBB (Formatting_gen (formatting, fmt_rest))\n\n (* Try to read the optional after \"@;\". *)\n and parse_good_break : type e f . int -> int -> (_, _, e, f) fmt_ebb =\n fun str_ind end_ind ->\n let next_ind, formatting_lit =\n try\n if str_ind = end_ind || str.[str_ind] <> '<' then raise Not_found;\n let str_ind_1 = parse_spaces (str_ind + 1) end_ind in\n match str.[str_ind_1] with\n | '0' .. '9' | '-' -> (\n let str_ind_2, width = parse_integer str_ind_1 end_ind in\n let str_ind_3 = parse_spaces str_ind_2 end_ind in\n match str.[str_ind_3] with\n | '>' ->\n let s = String.sub str (str_ind-2) (str_ind_3-str_ind+3) in\n str_ind_3 + 1, Break (s, width, 0)\n | '0' .. '9' | '-' ->\n let str_ind_4, offset = parse_integer str_ind_3 end_ind in\n let str_ind_5 = parse_spaces str_ind_4 end_ind in\n if str.[str_ind_5] <> '>' then raise Not_found;\n let s = String.sub str (str_ind-2) (str_ind_5-str_ind+3) in\n str_ind_5 + 1, Break (s, width, offset)\n | _ -> raise Not_found\n )\n | _ -> raise Not_found\n with Not_found | Failure _ ->\n str_ind, Break (\"@;\", 1, 0)\n in\n let Fmt_EBB fmt_rest = parse next_ind end_ind in\n Fmt_EBB (Formatting_lit (formatting_lit, fmt_rest))\n\n (* Parse the size in a . *)\n and parse_magic_size : type e f . int -> int -> (_, _, e, f) fmt_ebb =\n fun str_ind end_ind ->\n match\n try\n let str_ind_1 = parse_spaces str_ind end_ind in\n match str.[str_ind_1] with\n | '0' .. '9' | '-' ->\n let str_ind_2, size = parse_integer str_ind_1 end_ind in\n let str_ind_3 = parse_spaces str_ind_2 end_ind in\n if str.[str_ind_3] <> '>' then raise Not_found;\n let s = String.sub str (str_ind - 2) (str_ind_3 - str_ind + 3) in\n Some (str_ind_3 + 1, Magic_size (s, size))\n | _ -> None\n with Not_found | Failure _ ->\n None\n with\n | Some (next_ind, formatting_lit) ->\n let Fmt_EBB fmt_rest = parse next_ind end_ind in\n Fmt_EBB (Formatting_lit (formatting_lit, fmt_rest))\n | None ->\n let Fmt_EBB fmt_rest = parse str_ind end_ind in\n Fmt_EBB (Formatting_lit (Scan_indic '<', fmt_rest))\n\n (* Parse and construct a char set. *)\n and parse_char_set str_ind end_ind =\n if str_ind = end_ind then unexpected_end_of_format end_ind;\n\n let char_set = create_char_set () in\n let add_char c =\n add_in_char_set char_set c;\n in\n let add_range c c' =\n for i = int_of_char c to int_of_char c' do\n add_in_char_set char_set (char_of_int i);\n done;\n in\n\n let fail_single_percent str_ind =\n failwith_message\n \"invalid format %S: '%%' alone is not accepted in character sets, \\\n use %%%% instead at position %d.\" str str_ind\n in\n\n (* Parse the first character of a char set. *)\n let rec parse_char_set_start str_ind end_ind =\n if str_ind = end_ind then unexpected_end_of_format end_ind;\n let c = str.[str_ind] in\n parse_char_set_after_char (str_ind + 1) end_ind c\n\n (* Parse the content of a char set until the first ']'. *)\n and parse_char_set_content str_ind end_ind =\n if str_ind = end_ind then unexpected_end_of_format end_ind;\n match str.[str_ind] with\n | ']' ->\n str_ind + 1\n | '-' ->\n add_char '-';\n parse_char_set_content (str_ind + 1) end_ind\n | c ->\n parse_char_set_after_char (str_ind + 1) end_ind c\n\n (* Test for range in char set. *)\n and parse_char_set_after_char str_ind end_ind c =\n if str_ind = end_ind then unexpected_end_of_format end_ind;\n match str.[str_ind] with\n | ']' ->\n add_char c;\n str_ind + 1\n | '-' ->\n parse_char_set_after_minus (str_ind + 1) end_ind c\n | ('%' | '@') as c' when c = '%' ->\n add_char c';\n parse_char_set_content (str_ind + 1) end_ind\n | c' ->\n if c = '%' then fail_single_percent str_ind;\n (* note that '@' alone is accepted, as done by the legacy\n implementation; the documentation specifically requires %@\n so we could warn on that *)\n add_char c;\n parse_char_set_after_char (str_ind + 1) end_ind c'\n\n (* Manage range in char set (except if the '-' the last char before ']') *)\n and parse_char_set_after_minus str_ind end_ind c =\n if str_ind = end_ind then unexpected_end_of_format end_ind;\n match str.[str_ind] with\n | ']' ->\n add_char c;\n add_char '-';\n str_ind + 1\n | '%' ->\n if str_ind + 1 = end_ind then unexpected_end_of_format end_ind;\n begin match str.[str_ind + 1] with\n | ('%' | '@') as c' ->\n add_range c c';\n parse_char_set_content (str_ind + 2) end_ind\n | _ -> fail_single_percent str_ind\n end\n | c' ->\n add_range c c';\n parse_char_set_content (str_ind + 1) end_ind\n in\n let str_ind, reverse =\n if str_ind = end_ind then unexpected_end_of_format end_ind;\n match str.[str_ind] with\n | '^' -> str_ind + 1, true\n | _ -> str_ind, false in\n let next_ind = parse_char_set_start str_ind end_ind in\n let char_set = freeze_char_set char_set in\n next_ind, (if reverse then rev_char_set char_set else char_set)\n\n (* Consume all next spaces, raise an Failure if end_ind is reached. *)\n and parse_spaces str_ind end_ind =\n if str_ind = end_ind then unexpected_end_of_format end_ind;\n if str.[str_ind] = ' ' then parse_spaces (str_ind + 1) end_ind else str_ind\n\n (* Read a positive integer from the string, raise a Failure if end_ind is\n reached. *)\n and parse_positive str_ind end_ind acc =\n if str_ind = end_ind then unexpected_end_of_format end_ind;\n match str.[str_ind] with\n | '0' .. '9' as c ->\n let new_acc = acc * 10 + (int_of_char c - int_of_char '0') in\n if new_acc > Sys.max_string_length then\n failwith_message\n \"invalid format %S: integer %d is greater than the limit %d\"\n str new_acc Sys.max_string_length\n else\n parse_positive (str_ind + 1) end_ind new_acc\n | _ -> str_ind, acc\n\n (* Read a positive or negative integer from the string, raise a Failure\n if end_ind is reached. *)\n and parse_integer str_ind end_ind =\n if str_ind = end_ind then unexpected_end_of_format end_ind;\n match str.[str_ind] with\n | '0' .. '9' -> parse_positive str_ind end_ind 0\n | '-' -> (\n if str_ind + 1 = end_ind then unexpected_end_of_format end_ind;\n match str.[str_ind + 1] with\n | '0' .. '9' ->\n let next_ind, n = parse_positive (str_ind + 1) end_ind 0 in\n next_ind, -n\n | c ->\n expected_character (str_ind + 1) \"digit\" c\n )\n | _ -> assert false\n\n (* Add a literal to a format from a literal character sub-sequence. *)\n and add_literal : type a d e f .\n int -> int -> (a, _, _, d, e, f) fmt ->\n (_, _, e, f) fmt_ebb =\n fun lit_start str_ind fmt -> match str_ind - lit_start with\n | 0 -> Fmt_EBB fmt\n | 1 -> Fmt_EBB (Char_literal (str.[lit_start], fmt))\n | size -> Fmt_EBB (String_literal (String.sub str lit_start size, fmt))\n\n (* Search the end of the current sub-format\n (i.e. the corresponding \"%}\" or \"%)\") *)\n and search_subformat_end str_ind end_ind c =\n if str_ind = end_ind then\n failwith_message\n \"invalid format %S: unclosed sub-format, \\\n expected \\\"%%%c\\\" at character number %d\" str c end_ind;\n match str.[str_ind] with\n | '%' ->\n if str_ind + 1 = end_ind then unexpected_end_of_format end_ind;\n if str.[str_ind + 1] = c then (* End of format found *) str_ind else\n begin match str.[str_ind + 1] with\n | '_' ->\n (* Search for \"%_(\" or \"%_{\". *)\n if str_ind + 2 = end_ind then unexpected_end_of_format end_ind;\n begin match str.[str_ind + 2] with\n | '{' ->\n let sub_end = search_subformat_end (str_ind + 3) end_ind '}' in\n search_subformat_end (sub_end + 2) end_ind c\n | '(' ->\n let sub_end = search_subformat_end (str_ind + 3) end_ind ')' in\n search_subformat_end (sub_end + 2) end_ind c\n | _ -> search_subformat_end (str_ind + 3) end_ind c\n end\n | '{' ->\n (* %{...%} sub-format found. *)\n let sub_end = search_subformat_end (str_ind + 2) end_ind '}' in\n search_subformat_end (sub_end + 2) end_ind c\n | '(' ->\n (* %(...%) sub-format found. *)\n let sub_end = search_subformat_end (str_ind + 2) end_ind ')' in\n search_subformat_end (sub_end + 2) end_ind c\n | '}' ->\n (* Error: %(...%}. *)\n expected_character (str_ind + 1) \"character ')'\" '}'\n | ')' ->\n (* Error: %{...%). *)\n expected_character (str_ind + 1) \"character '}'\" ')'\n | _ ->\n search_subformat_end (str_ind + 2) end_ind c\n end\n | _ -> search_subformat_end (str_ind + 1) end_ind c\n\n (* Check if symb is a valid int conversion after \"%l\", \"%n\" or \"%L\" *)\n and is_int_base symb = match symb with\n | 'd' | 'i' | 'x' | 'X' | 'o' | 'u' -> true\n | _ -> false\n\n (* Convert a char (l, n or L) to its associated counter. *)\n and counter_of_char symb = match symb with\n | 'l' -> Line_counter | 'n' -> Char_counter\n | 'L' -> Token_counter | _ -> assert false\n\n (* Convert (plus, symb) to its associated int_conv. *)\n and compute_int_conv pct_ind str_ind plus hash space symb =\n match plus, hash, space, symb with\n | false, false, false, 'd' -> Int_d | false, false, false, 'i' -> Int_i\n | false, false, true, 'd' -> Int_sd | false, false, true, 'i' -> Int_si\n | true, false, false, 'd' -> Int_pd | true, false, false, 'i' -> Int_pi\n | false, false, false, 'x' -> Int_x | false, false, false, 'X' -> Int_X\n | false, true, false, 'x' -> Int_Cx | false, true, false, 'X' -> Int_CX\n | false, false, false, 'o' -> Int_o\n | false, true, false, 'o' -> Int_Co\n | false, false, false, 'u' -> Int_u\n | false, true, false, 'd' -> Int_Cd\n | false, true, false, 'i' -> Int_Ci\n | false, true, false, 'u' -> Int_Cu\n | _, true, _, 'x' when legacy_behavior -> Int_Cx\n | _, true, _, 'X' when legacy_behavior -> Int_CX\n | _, true, _, 'o' when legacy_behavior -> Int_Co\n | _, true, _, ('d' | 'i' | 'u') ->\n if legacy_behavior then (* ignore *)\n compute_int_conv pct_ind str_ind plus false space symb\n else incompatible_flag pct_ind str_ind symb \"'#'\"\n | true, _, true, _ ->\n if legacy_behavior then\n (* plus and space: legacy implementation prefers plus *)\n compute_int_conv pct_ind str_ind plus hash false symb\n else incompatible_flag pct_ind str_ind ' ' \"'+'\"\n | false, _, true, _ ->\n if legacy_behavior then (* ignore *)\n compute_int_conv pct_ind str_ind plus hash false symb\n else incompatible_flag pct_ind str_ind symb \"' '\"\n | true, _, false, _ ->\n if legacy_behavior then (* ignore *)\n compute_int_conv pct_ind str_ind false hash space symb\n else incompatible_flag pct_ind str_ind symb \"'+'\"\n | false, _, false, _ -> assert false\n\n (* Convert (plus, space, symb) to its associated float_conv. *)\n and compute_float_conv pct_ind str_ind plus hash space symb =\n let flag = match plus, space with\n | false, false -> Float_flag_\n | false, true -> Float_flag_s\n | true, false -> Float_flag_p\n | true, true ->\n (* plus and space: legacy implementation prefers plus *)\n if legacy_behavior then Float_flag_p\n else incompatible_flag pct_ind str_ind ' ' \"'+'\" in\n let kind = match hash, symb with\n | _, 'f' -> Float_f\n | _, 'e' -> Float_e\n | _, 'E' -> Float_E\n | _, 'g' -> Float_g\n | _, 'G' -> Float_G\n | _, 'h' -> Float_h\n | _, 'H' -> Float_H\n | false, 'F' -> Float_F\n | true, 'F' -> Float_CF\n | _ -> assert false in\n flag, kind\n\n (* Raise [Failure] with a friendly error message about incompatible options.*)\n and incompatible_flag : type a . int -> int -> char -> string -> a =\n fun pct_ind str_ind symb option ->\n let subfmt = String.sub str pct_ind (str_ind - pct_ind) in\n failwith_message\n \"invalid format %S: at character number %d, \\\n %s is incompatible with '%c' in sub-format %S\"\n str pct_ind option symb subfmt\n\n in parse 0 (String.length str)\n\n(******************************************************************************)\n (* Guarded string to format conversions *)\n\n(* Convert a string to a format according to an fmtty. *)\n(* Raise [Failure] with an error message in case of type mismatch. *)\nlet format_of_string_fmtty str fmtty =\n let Fmt_EBB fmt = fmt_ebb_of_string str in\n try Format (type_format fmt fmtty, str)\n with Type_mismatch ->\n failwith_message\n \"bad input: format type mismatch between %S and %S\"\n str (string_of_fmtty fmtty)\n\n(* Convert a string to a format compatible with an other format. *)\n(* Raise [Failure] with an error message in case of type mismatch. *)\nlet format_of_string_format str (Format (fmt', str')) =\n let Fmt_EBB fmt = fmt_ebb_of_string str in\n try Format (type_format fmt (fmtty_of_fmt fmt'), str)\n with Type_mismatch ->\n failwith_message\n \"bad input: format type mismatch between %S and %S\" str str'\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nopen Printf\n\ntype t = exn = ..\n\nlet printers = Atomic.make []\n\nlet locfmt = format_of_string \"File \\\"%s\\\", line %d, characters %d-%d: %s\"\n\nlet field x i =\n let f = Obj.field x i in\n if not (Obj.is_block f) then\n sprintf \"%d\" (Obj.magic f : int) (* can also be a char *)\n else if Obj.tag f = Obj.string_tag then\n sprintf \"%S\" (Obj.magic f : string)\n else if Obj.tag f = Obj.double_tag then\n string_of_float (Obj.magic f : float)\n else\n \"_\"\n\nlet rec other_fields x i =\n if i >= Obj.size x then \"\"\n else sprintf \", %s%s\" (field x i) (other_fields x (i+1))\n\nlet fields x =\n match Obj.size x with\n | 0 -> \"\"\n | 1 -> \"\"\n | 2 -> sprintf \"(%s)\" (field x 1)\n | _ -> sprintf \"(%s%s)\" (field x 1) (other_fields x 2)\n\nlet use_printers x =\n let rec conv = function\n | hd :: tl ->\n (match hd x with\n | None | exception _ -> conv tl\n | Some s -> Some s)\n | [] -> None in\n conv (Atomic.get printers)\n\nlet to_string_default = function\n | Out_of_memory -> \"Out of memory\"\n | Stack_overflow -> \"Stack overflow\"\n | Match_failure(file, line, char) ->\n sprintf locfmt file line char (char+5) \"Pattern matching failed\"\n | Assert_failure(file, line, char) ->\n sprintf locfmt file line char (char+6) \"Assertion failed\"\n | Undefined_recursive_module(file, line, char) ->\n sprintf locfmt file line char (char+6) \"Undefined recursive module\"\n | x ->\n let x = Obj.repr x in\n if Obj.tag x <> 0 then\n (Obj.magic (Obj.field x 0) : string)\n else\n let constructor =\n (Obj.magic (Obj.field (Obj.field x 0) 0) : string) in\n constructor ^ (fields x)\n\nlet to_string e =\n match use_printers e with\n | Some s -> s\n | None -> to_string_default e\n\nlet print fct arg =\n try\n fct arg\n with x ->\n eprintf \"Uncaught exception: %s\\n\" (to_string x);\n flush stderr;\n raise x\n\nlet catch fct arg =\n try\n fct arg\n with x ->\n flush stdout;\n eprintf \"Uncaught exception: %s\\n\" (to_string x);\n exit 2\n\ntype raw_backtrace_slot\ntype raw_backtrace_entry = private int\ntype raw_backtrace = raw_backtrace_entry array\n\nlet raw_backtrace_entries bt = bt\n\nexternal get_raw_backtrace:\n unit -> raw_backtrace = \"caml_get_exception_raw_backtrace\"\n\nexternal raise_with_backtrace: exn -> raw_backtrace -> 'a\n = \"%raise_with_backtrace\"\n\ntype backtrace_slot =\n | Known_location of {\n is_raise : bool;\n filename : string;\n line_number : int;\n start_char : int;\n end_char : int;\n is_inline : bool;\n defname : string;\n }\n | Unknown_location of {\n is_raise : bool\n }\n\n(* to avoid warning *)\nlet _ = [Known_location { is_raise = false; filename = \"\";\n line_number = 0; start_char = 0; end_char = 0;\n is_inline = false; defname = \"\" };\n Unknown_location { is_raise = false }]\n\nexternal convert_raw_backtrace_slot:\n raw_backtrace_slot -> backtrace_slot = \"caml_convert_raw_backtrace_slot\"\n\nexternal convert_raw_backtrace:\n raw_backtrace -> backtrace_slot array = \"caml_convert_raw_backtrace\"\n\nlet convert_raw_backtrace bt =\n try Some (convert_raw_backtrace bt)\n with Failure _ -> None\n\nlet format_backtrace_slot pos slot =\n let info is_raise =\n if is_raise then\n if pos = 0 then \"Raised at\" else \"Re-raised at\"\n else\n if pos = 0 then \"Raised by primitive operation at\" else \"Called from\"\n in\n match slot with\n | Unknown_location l ->\n if l.is_raise then\n (* compiler-inserted re-raise, skipped *) None\n else\n Some (sprintf \"%s unknown location\" (info false))\n | Known_location l ->\n Some (sprintf \"%s %s in file \\\"%s\\\"%s, line %d, characters %d-%d\"\n (info l.is_raise) l.defname l.filename\n (if l.is_inline then \" (inlined)\" else \"\")\n l.line_number l.start_char l.end_char)\n\nlet print_exception_backtrace outchan backtrace =\n match backtrace with\n | None ->\n fprintf outchan\n \"(Program not linked with -g, cannot print stack backtrace)\\n\"\n | Some a ->\n for i = 0 to Array.length a - 1 do\n match format_backtrace_slot i a.(i) with\n | None -> ()\n | Some str -> fprintf outchan \"%s\\n\" str\n done\n\nlet print_raw_backtrace outchan raw_backtrace =\n print_exception_backtrace outchan (convert_raw_backtrace raw_backtrace)\n\n(* confusingly named: prints the global current backtrace *)\nlet print_backtrace outchan =\n print_raw_backtrace outchan (get_raw_backtrace ())\n\nlet backtrace_to_string backtrace =\n match backtrace with\n | None ->\n \"(Program not linked with -g, cannot print stack backtrace)\\n\"\n | Some a ->\n let b = Buffer.create 1024 in\n for i = 0 to Array.length a - 1 do\n match format_backtrace_slot i a.(i) with\n | None -> ()\n | Some str -> bprintf b \"%s\\n\" str\n done;\n Buffer.contents b\n\nlet raw_backtrace_to_string raw_backtrace =\n backtrace_to_string (convert_raw_backtrace raw_backtrace)\n\nlet backtrace_slot_is_raise = function\n | Known_location l -> l.is_raise\n | Unknown_location l -> l.is_raise\n\nlet backtrace_slot_is_inline = function\n | Known_location l -> l.is_inline\n | Unknown_location _ -> false\n\ntype location = {\n filename : string;\n line_number : int;\n start_char : int;\n end_char : int;\n}\n\nlet backtrace_slot_location = function\n | Unknown_location _ -> None\n | Known_location l ->\n Some {\n filename = l.filename;\n line_number = l.line_number;\n start_char = l.start_char;\n end_char = l.end_char;\n }\n\nlet backtrace_slot_defname = function\n | Unknown_location _\n | Known_location { defname = \"\" } -> None\n | Known_location l -> Some l.defname\n\nlet backtrace_slots raw_backtrace =\n (* The documentation of this function guarantees that Some is\n returned only if a part of the trace is usable. This gives us\n a bit more work than just convert_raw_backtrace, but it makes the\n API more user-friendly -- otherwise most users would have to\n reimplement the \"Program not linked with -g, sorry\" logic\n themselves. *)\n match convert_raw_backtrace raw_backtrace with\n | None -> None\n | Some backtrace ->\n let usable_slot = function\n | Unknown_location _ -> false\n | Known_location _ -> true in\n let rec exists_usable = function\n | (-1) -> false\n | i -> usable_slot backtrace.(i) || exists_usable (i - 1) in\n if exists_usable (Array.length backtrace - 1)\n then Some backtrace\n else None\n\nlet backtrace_slots_of_raw_entry entry =\n backtrace_slots [| entry |]\n\nmodule Slot = struct\n type t = backtrace_slot\n let format = format_backtrace_slot\n let is_raise = backtrace_slot_is_raise\n let is_inline = backtrace_slot_is_inline\n let location = backtrace_slot_location\n let name = backtrace_slot_defname\nend\n\nlet raw_backtrace_length bt = Array.length bt\n\nexternal get_raw_backtrace_slot :\n raw_backtrace -> int -> raw_backtrace_slot = \"caml_raw_backtrace_slot\"\n\nexternal get_raw_backtrace_next_slot :\n raw_backtrace_slot -> raw_backtrace_slot option\n = \"caml_raw_backtrace_next_slot\"\n\n(* confusingly named:\n returns the *string* corresponding to the global current backtrace *)\nlet get_backtrace () = raw_backtrace_to_string (get_raw_backtrace ())\n\nexternal record_backtrace: bool -> unit = \"caml_record_backtrace\"\nexternal backtrace_status: unit -> bool = \"caml_backtrace_status\"\n\nlet rec register_printer fn =\n let old_printers = Atomic.get printers in\n let new_printers = fn :: old_printers in\n let success = Atomic.compare_and_set printers old_printers new_printers in\n if not success then register_printer fn\n\nexternal get_callstack: int -> raw_backtrace = \"caml_get_current_callstack\"\n\nlet exn_slot x =\n let x = Obj.repr x in\n if Obj.tag x = 0 then Obj.field x 0 else x\n\nlet exn_slot_id x =\n let slot = exn_slot x in\n (Obj.obj (Obj.field slot 1) : int)\n\nlet exn_slot_name x =\n let slot = exn_slot x in\n (Obj.obj (Obj.field slot 0) : string)\n\nexternal get_debug_info_status : unit -> int = \"caml_ml_debug_info_status\"\n\n(* Descriptions for errors in startup.h. See also backtrace.c *)\nlet errors = [| \"\";\n (* FILE_NOT_FOUND *)\n \"(Cannot print locations:\\n \\\n bytecode executable program file not found)\";\n (* BAD_BYTECODE *)\n \"(Cannot print locations:\\n \\\n bytecode executable program file appears to be corrupt)\";\n (* WRONG_MAGIC *)\n \"(Cannot print locations:\\n \\\n bytecode executable program file has wrong magic number)\";\n (* NO_FDS *)\n \"(Cannot print locations:\\n \\\n bytecode executable program file cannot be opened;\\n \\\n -- too many open files. Try running with OCAMLRUNPARAM=b=2)\"\n|]\n\nlet default_uncaught_exception_handler exn raw_backtrace =\n eprintf \"Fatal error: exception %s\\n\" (to_string exn);\n print_raw_backtrace stderr raw_backtrace;\n let status = get_debug_info_status () in\n if status < 0 then\n prerr_endline errors.(abs status);\n flush stderr\n\nlet uncaught_exception_handler = ref default_uncaught_exception_handler\n\nlet set_uncaught_exception_handler fn = uncaught_exception_handler := fn\n\nlet empty_backtrace : raw_backtrace = [| |]\n\nlet try_get_raw_backtrace () =\n try\n get_raw_backtrace ()\n with _ (* Out_of_memory? *) ->\n empty_backtrace\n\nlet handle_uncaught_exception' exn debugger_in_use =\n try\n (* Get the backtrace now, in case one of the [at_exit] function\n destroys it. *)\n let raw_backtrace =\n if debugger_in_use (* Same test as in [runtime/printexc.c] *) then\n empty_backtrace\n else\n try_get_raw_backtrace ()\n in\n (try Stdlib.do_at_exit () with _ -> ());\n try\n !uncaught_exception_handler exn raw_backtrace\n with exn' ->\n let raw_backtrace' = try_get_raw_backtrace () in\n eprintf \"Fatal error: exception %s\\n\" (to_string exn);\n print_raw_backtrace stderr raw_backtrace;\n eprintf \"Fatal error in uncaught exception handler: exception %s\\n\"\n (to_string exn');\n print_raw_backtrace stderr raw_backtrace';\n flush stderr\n with\n | Out_of_memory ->\n prerr_endline\n \"Fatal error: out of memory in uncaught exception handler\"\n\n(* This function is called by [caml_fatal_uncaught_exception] in\n [runtime/printexc.c] which expects no exception is raised. *)\nlet handle_uncaught_exception exn debugger_in_use =\n try\n handle_uncaught_exception' exn debugger_in_use\n with _ ->\n (* There is not much we can do at this point *)\n ()\n\nexternal register_named_value : string -> 'a -> unit\n = \"caml_register_named_value\"\n\nlet () =\n register_named_value \"Printexc.handle_uncaught_exception\"\n handle_uncaught_exception\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy and Damien Doligez, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nlet generic_quote quotequote s =\n let l = String.length s in\n let b = Buffer.create (l + 20) in\n Buffer.add_char b '\\'';\n for i = 0 to l - 1 do\n if s.[i] = '\\''\n then Buffer.add_string b quotequote\n else Buffer.add_char b s.[i]\n done;\n Buffer.add_char b '\\'';\n Buffer.contents b\n\n(* This function implements the Open Group specification found here:\n [[1]] http://pubs.opengroup.org/onlinepubs/9699919799/utilities/basename.html\n In step 1 of [[1]], we choose to return \".\" for empty input.\n (for compatibility with previous versions of OCaml)\n In step 2, we choose to process \"//\" normally.\n Step 6 is not implemented: we consider that the [suffix] operand is\n always absent. Suffixes are handled by [chop_suffix] and [chop_extension].\n*)\nlet generic_basename is_dir_sep current_dir_name name =\n let rec find_end n =\n if n < 0 then String.sub name 0 1\n else if is_dir_sep name n then find_end (n - 1)\n else find_beg n (n + 1)\n and find_beg n p =\n if n < 0 then String.sub name 0 p\n else if is_dir_sep name n then String.sub name (n + 1) (p - n - 1)\n else find_beg (n - 1) p\n in\n if name = \"\"\n then current_dir_name\n else find_end (String.length name - 1)\n\n(* This function implements the Open Group specification found here:\n [[2]] http://pubs.opengroup.org/onlinepubs/9699919799/utilities/dirname.html\n In step 6 of [[2]], we choose to process \"//\" normally.\n*)\nlet generic_dirname is_dir_sep current_dir_name name =\n let rec trailing_sep n =\n if n < 0 then String.sub name 0 1\n else if is_dir_sep name n then trailing_sep (n - 1)\n else base n\n and base n =\n if n < 0 then current_dir_name\n else if is_dir_sep name n then intermediate_sep n\n else base (n - 1)\n and intermediate_sep n =\n if n < 0 then String.sub name 0 1\n else if is_dir_sep name n then intermediate_sep (n - 1)\n else String.sub name 0 (n + 1)\n in\n if name = \"\"\n then current_dir_name\n else trailing_sep (String.length name - 1)\n\nmodule type SYSDEPS = sig\n val null : string\n val current_dir_name : string\n val parent_dir_name : string\n val dir_sep : string\n val is_dir_sep : string -> int -> bool\n val is_relative : string -> bool\n val is_implicit : string -> bool\n val check_suffix : string -> string -> bool\n val chop_suffix_opt : suffix:string -> string -> string option\n val temp_dir_name : string\n val quote : string -> string\n val quote_command :\n string -> ?stdin: string -> ?stdout: string -> ?stderr: string\n -> string list -> string\n val basename : string -> string\n val dirname : string -> string\nend\n\nmodule Unix : SYSDEPS = struct\n let null = \"/dev/null\"\n let current_dir_name = \".\"\n let parent_dir_name = \"..\"\n let dir_sep = \"/\"\n let is_dir_sep s i = s.[i] = '/'\n let is_relative n = String.length n < 1 || n.[0] <> '/'\n let is_implicit n =\n is_relative n\n && (String.length n < 2 || String.sub n 0 2 <> \"./\")\n && (String.length n < 3 || String.sub n 0 3 <> \"../\")\n let check_suffix name suff =\n String.ends_with ~suffix:suff name\n\n let chop_suffix_opt ~suffix filename =\n let len_s = String.length suffix and len_f = String.length filename in\n if len_f >= len_s then\n let r = String.sub filename (len_f - len_s) len_s in\n if r = suffix then\n Some (String.sub filename 0 (len_f - len_s))\n else\n None\n else\n None\n\n let temp_dir_name =\n try Sys.getenv \"TMPDIR\" with Not_found -> \"/tmp\"\n let quote = generic_quote \"'\\\\''\"\n let quote_command cmd ?stdin ?stdout ?stderr args =\n String.concat \" \" (List.map quote (cmd :: args))\n ^ (match stdin with None -> \"\" | Some f -> \" <\" ^ quote f)\n ^ (match stdout with None -> \"\" | Some f -> \" >\" ^ quote f)\n ^ (match stderr with None -> \"\" | Some f -> if stderr = stdout\n then \" 2>&1\"\n else \" 2>\" ^ quote f)\n let basename = generic_basename is_dir_sep current_dir_name\n let dirname = generic_dirname is_dir_sep current_dir_name\nend\n\nmodule Win32 : SYSDEPS = struct\n let null = \"NUL\"\n let current_dir_name = \".\"\n let parent_dir_name = \"..\"\n let dir_sep = \"\\\\\"\n let is_dir_sep s i = let c = s.[i] in c = '/' || c = '\\\\' || c = ':'\n let is_relative n =\n (String.length n < 1 || n.[0] <> '/')\n && (String.length n < 1 || n.[0] <> '\\\\')\n && (String.length n < 2 || n.[1] <> ':')\n let is_implicit n =\n is_relative n\n && (String.length n < 2 || String.sub n 0 2 <> \"./\")\n && (String.length n < 2 || String.sub n 0 2 <> \".\\\\\")\n && (String.length n < 3 || String.sub n 0 3 <> \"../\")\n && (String.length n < 3 || String.sub n 0 3 <> \"..\\\\\")\n let check_suffix name suff =\n String.length name >= String.length suff &&\n (let s = String.sub name (String.length name - String.length suff)\n (String.length suff) in\n String.lowercase_ascii s = String.lowercase_ascii suff)\n\n let chop_suffix_opt ~suffix filename =\n let len_s = String.length suffix and len_f = String.length filename in\n if len_f >= len_s then\n let r = String.sub filename (len_f - len_s) len_s in\n if String.lowercase_ascii r = String.lowercase_ascii suffix then\n Some (String.sub filename 0 (len_f - len_s))\n else\n None\n else\n None\n\n\n let temp_dir_name =\n try Sys.getenv \"TEMP\" with Not_found -> \".\"\n let quote s =\n let l = String.length s in\n let b = Buffer.create (l + 20) in\n Buffer.add_char b '\\\"';\n let rec loop i =\n if i = l then Buffer.add_char b '\\\"' else\n match s.[i] with\n | '\\\"' -> loop_bs 0 i;\n | '\\\\' -> loop_bs 0 i;\n | c -> Buffer.add_char b c; loop (i+1);\n and loop_bs n i =\n if i = l then begin\n Buffer.add_char b '\\\"';\n add_bs n;\n end else begin\n match s.[i] with\n | '\\\"' -> add_bs (2*n+1); Buffer.add_char b '\\\"'; loop (i+1);\n | '\\\\' -> loop_bs (n+1) (i+1);\n | _ -> add_bs n; loop i\n end\n and add_bs n = for _j = 1 to n do Buffer.add_char b '\\\\'; done\n in\n loop 0;\n Buffer.contents b\n(*\nQuoting commands for execution by cmd.exe is difficult.\n1- Each argument is first quoted using the \"quote\" function above, to\n protect it against the processing performed by the C runtime system,\n then cmd.exe's special characters are escaped with '^', using\n the \"quote_cmd\" function below. For more details, see\n https://blogs.msdn.microsoft.com/twistylittlepassagesallalike/2011/04/23\n2- The command and the redirection files, if any, must be double-quoted\n in case they contain spaces. This quoting is interpreted by cmd.exe,\n not by the C runtime system, hence the \"quote\" function above\n cannot be used. The two characters we don't know how to quote\n inside a double-quoted cmd.exe string are double-quote and percent.\n We just fail if the command name or the redirection file names\n contain a double quote (not allowed in Windows file names, anyway)\n or a percent. See function \"quote_cmd_filename\" below.\n3- The whole string passed to Sys.command is then enclosed in double\n quotes, which are immediately stripped by cmd.exe. Otherwise,\n some of the double quotes from step 2 above can be misparsed.\n See e.g. https://stackoverflow.com/a/9965141\n*)\n let quote_cmd s =\n let b = Buffer.create (String.length s + 20) in\n String.iter\n (fun c ->\n match c with\n | '(' | ')' | '!' | '^' | '%' | '\\\"' | '<' | '>' | '&' | '|' ->\n Buffer.add_char b '^'; Buffer.add_char b c\n | _ ->\n Buffer.add_char b c)\n s;\n Buffer.contents b\n let quote_cmd_filename f =\n if String.contains f '\\\"' || String.contains f '%' then\n failwith (\"Filename.quote_command: bad file name \" ^ f)\n else if String.contains f ' ' then\n \"\\\"\" ^ f ^ \"\\\"\"\n else\n f\n (* Redirections in cmd.exe: see https://ss64.com/nt/syntax-redirection.html\n and https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-xp/bb490982(v=technet.10)\n *)\n let quote_command cmd ?stdin ?stdout ?stderr args =\n String.concat \"\" [\n \"\\\"\";\n quote_cmd_filename cmd;\n \" \";\n quote_cmd (String.concat \" \" (List.map quote args));\n (match stdin with None -> \"\" | Some f -> \" <\" ^ quote_cmd_filename f);\n (match stdout with None -> \"\" | Some f -> \" >\" ^ quote_cmd_filename f);\n (match stderr with None -> \"\" | Some f ->\n if stderr = stdout\n then \" 2>&1\"\n else \" 2>\" ^ quote_cmd_filename f);\n \"\\\"\"\n ]\n let has_drive s =\n let is_letter = function\n | 'A' .. 'Z' | 'a' .. 'z' -> true\n | _ -> false\n in\n String.length s >= 2 && is_letter s.[0] && s.[1] = ':'\n let drive_and_path s =\n if has_drive s\n then (String.sub s 0 2, String.sub s 2 (String.length s - 2))\n else (\"\", s)\n let dirname s =\n let (drive, path) = drive_and_path s in\n let dir = generic_dirname is_dir_sep current_dir_name path in\n drive ^ dir\n let basename s =\n let (_drive, path) = drive_and_path s in\n generic_basename is_dir_sep current_dir_name path\nend\n\nmodule Cygwin : SYSDEPS = struct\n let null = \"/dev/null\"\n let current_dir_name = \".\"\n let parent_dir_name = \"..\"\n let dir_sep = \"/\"\n let is_dir_sep = Win32.is_dir_sep\n let is_relative = Win32.is_relative\n let is_implicit = Win32.is_implicit\n let check_suffix = Win32.check_suffix\n let chop_suffix_opt = Win32.chop_suffix_opt\n let temp_dir_name = Unix.temp_dir_name\n let quote = Unix.quote\n let quote_command = Unix.quote_command\n let basename = generic_basename is_dir_sep current_dir_name\n let dirname = generic_dirname is_dir_sep current_dir_name\nend\n\nmodule Sysdeps =\n (val (match Sys.os_type with\n | \"Win32\" -> (module Win32: SYSDEPS)\n | \"Cygwin\" -> (module Cygwin: SYSDEPS)\n | _ -> (module Unix: SYSDEPS)))\n\ninclude Sysdeps\n\nlet concat dirname filename =\n let l = String.length dirname in\n if l = 0 || is_dir_sep dirname (l-1)\n then dirname ^ filename\n else dirname ^ dir_sep ^ filename\n\nlet chop_suffix name suff =\n if check_suffix name suff\n then String.sub name 0 (String.length name - String.length suff)\n else invalid_arg \"Filename.chop_suffix\"\n\nlet extension_len name =\n let rec check i0 i =\n if i < 0 || is_dir_sep name i then 0\n else if name.[i] = '.' then check i0 (i - 1)\n else String.length name - i0\n in\n let rec search_dot i =\n if i < 0 || is_dir_sep name i then 0\n else if name.[i] = '.' then check i (i - 1)\n else search_dot (i - 1)\n in\n search_dot (String.length name - 1)\n\nlet extension name =\n let l = extension_len name in\n if l = 0 then \"\" else String.sub name (String.length name - l) l\n\nlet chop_extension name =\n let l = extension_len name in\n if l = 0 then invalid_arg \"Filename.chop_extension\"\n else String.sub name 0 (String.length name - l)\n\nlet remove_extension name =\n let l = extension_len name in\n if l = 0 then name else String.sub name 0 (String.length name - l)\n\nexternal open_desc: string -> open_flag list -> int -> int = \"caml_sys_open\"\nexternal close_desc: int -> unit = \"caml_sys_close\"\n\nlet prng = lazy(Random.State.make_self_init ())\n\nlet temp_file_name temp_dir prefix suffix =\n let rnd = (Random.State.bits (Lazy.force prng)) land 0xFFFFFF in\n concat temp_dir (Printf.sprintf \"%s%06x%s\" prefix rnd suffix)\n\n\nlet current_temp_dir_name = ref temp_dir_name\n\nlet set_temp_dir_name s = current_temp_dir_name := s\nlet get_temp_dir_name () = !current_temp_dir_name\n\nlet temp_file ?(temp_dir = !current_temp_dir_name) prefix suffix =\n let rec try_name counter =\n let name = temp_file_name temp_dir prefix suffix in\n try\n close_desc(open_desc name [Open_wronly; Open_creat; Open_excl] 0o600);\n name\n with Sys_error _ as e ->\n if counter >= 1000 then raise e else try_name (counter + 1)\n in try_name 0\n\nlet open_temp_file ?(mode = [Open_text]) ?(perms = 0o600)\n ?(temp_dir = !current_temp_dir_name) prefix suffix =\n let rec try_name counter =\n let name = temp_file_name temp_dir prefix suffix in\n try\n (name,\n open_out_gen (Open_wronly::Open_creat::Open_excl::mode) perms name)\n with Sys_error _ as e ->\n if counter >= 1000 then raise e else try_name (counter + 1)\n in try_name 0\n","open! Import\n\ntype t = exn [@@deriving_inline sexp_of]\n\nlet sexp_of_t = (sexp_of_exn : t -> Ppx_sexp_conv_lib.Sexp.t)\n\n[@@@end]\n\nlet exit = Caml.exit\n\nexception Finally of t * t [@@deriving_inline sexp]\n\nlet () =\n Ppx_sexp_conv_lib.Conv.Exn_converter.add [%extension_constructor Finally] (function\n | Finally (v0, v1) ->\n let v0 = sexp_of_t v0\n and v1 = sexp_of_t v1 in\n Ppx_sexp_conv_lib.Sexp.List\n [ Ppx_sexp_conv_lib.Sexp.Atom \"exn.ml.Finally\"; v0; v1 ]\n | _ -> assert false)\n;;\n\n[@@@end]\n\nexception Reraised of string * t [@@deriving_inline sexp]\n\nlet () =\n Ppx_sexp_conv_lib.Conv.Exn_converter.add [%extension_constructor Reraised] (function\n | Reraised (v0, v1) ->\n let v0 = sexp_of_string v0\n and v1 = sexp_of_t v1 in\n Ppx_sexp_conv_lib.Sexp.List\n [ Ppx_sexp_conv_lib.Sexp.Atom \"exn.ml.Reraised\"; v0; v1 ]\n | _ -> assert false)\n;;\n\n[@@@end]\n\nexception Sexp of Sexp.t\n\n(* We install a custom exn-converter rather than use:\n\n {[\n exception Sexp of Sexp.t [@@deriving_inline sexp]\n (* ... *)\n [@@@end]\n ]}\n\n to eliminate the extra wrapping of [(Sexp ...)]. *)\nlet () =\n Sexplib.Conv.Exn_converter.add [%extension_constructor Sexp] (function\n | Sexp t -> t\n | _ ->\n (* Reaching this branch indicates a bug in sexplib. *)\n assert false)\n;;\n\nlet create_s sexp = Sexp sexp\nlet reraise exc str = raise (Reraised (str, exc))\nlet reraisef exc format = Printf.ksprintf (fun str () -> reraise exc str) format\nlet to_string exc = Sexp.to_string_hum ~indent:2 (sexp_of_exn exc)\nlet to_string_mach exc = Sexp.to_string_mach (sexp_of_exn exc)\nlet sexp_of_t = sexp_of_exn\n\nlet protectx ~f x ~(finally : _ -> unit) =\n match f x with\n | res ->\n finally x;\n res\n | exception exn ->\n raise\n (match finally x with\n | () -> exn\n | exception final_exn -> Finally (exn, final_exn))\n;;\n\nlet protect ~f ~finally = protectx ~f () ~finally\n\nlet does_raise (type a) (f : unit -> a) =\n try\n ignore (f () : a);\n false\n with\n | _ -> true\n;;\n\ninclude Pretty_printer.Register_pp (struct\n type t = exn\n\n let pp ppf t =\n match sexp_of_exn_opt t with\n | Some sexp -> Sexp.pp_hum ppf sexp\n | None -> Caml.Format.pp_print_string ppf (Caml.Printexc.to_string t)\n ;;\n\n let module_name = \"Base.Exn\"\n end)\n\nlet print_with_backtrace exc raw_backtrace =\n Caml.Format.eprintf \"@[<2>Uncaught exception:@\\n@\\n@[%a@]@]@\\n@.\" pp exc;\n if Caml.Printexc.backtrace_status ()\n then Caml.Printexc.print_raw_backtrace Caml.stderr raw_backtrace;\n Caml.flush Caml.stderr\n;;\n\nlet set_uncaught_exception_handler () =\n Caml.Printexc.set_uncaught_exception_handler print_with_backtrace\n;;\n\nlet handle_uncaught_aux ~do_at_exit ~exit f =\n try f () with\n | exc ->\n let raw_backtrace = Caml.Printexc.get_raw_backtrace () in\n (* One reason to run [do_at_exit] handlers before printing out the error message is\n that it helps curses applications bring the terminal in a good state, otherwise the\n error message might get corrupted. Also, the OCaml top-level uncaught exception\n handler does the same. *)\n if do_at_exit\n then (\n try Caml.do_at_exit () with\n | _ -> ());\n (try print_with_backtrace exc raw_backtrace with\n | _ ->\n (try\n Caml.Printf.eprintf \"Exn.handle_uncaught could not print; exiting anyway\\n%!\"\n with\n | _ -> ()));\n exit 1\n;;\n\nlet handle_uncaught_and_exit f = handle_uncaught_aux f ~exit ~do_at_exit:true\n\nlet handle_uncaught ~exit:must_exit f =\n handle_uncaught_aux f ~exit:(if must_exit then exit else ignore) ~do_at_exit:must_exit\n;;\n\nlet reraise_uncaught str func =\n try func () with\n | exn -> raise (Reraised (str, exn))\n;;\n\nexternal clear_backtrace : unit -> unit = \"Base_clear_caml_backtrace_pos\" [@@noalloc]\n\nlet raise_without_backtrace e =\n (* We clear the backtrace to reduce confusion, so that people don't think whatever\n is stored corresponds to this raise. *)\n clear_backtrace ();\n Caml.raise_notrace e\n;;\n\nlet initialize_module () = set_uncaught_exception_handler ()\n\nmodule Private = struct\n let clear_backtrace = clear_backtrace\nend\n","(* This is broken off to avoid circular dependency between Sign and Comparable. *)\n\nopen! Import\n\ntype t =\n | Neg\n | Zero\n | Pos\n[@@deriving_inline sexp, compare, hash, enumerate]\n\nlet t_of_sexp =\n (let _tp_loc = \"sign0.ml.t\" in\n function\n | Ppx_sexp_conv_lib.Sexp.Atom (\"neg\" | \"Neg\") -> Neg\n | Ppx_sexp_conv_lib.Sexp.Atom (\"zero\" | \"Zero\") -> Zero\n | Ppx_sexp_conv_lib.Sexp.Atom (\"pos\" | \"Pos\") -> Pos\n | Ppx_sexp_conv_lib.Sexp.List (Ppx_sexp_conv_lib.Sexp.Atom (\"neg\" | \"Neg\") :: _) as\n sexp -> Ppx_sexp_conv_lib.Conv_error.stag_no_args _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.List (Ppx_sexp_conv_lib.Sexp.Atom (\"zero\" | \"Zero\") :: _) as\n sexp -> Ppx_sexp_conv_lib.Conv_error.stag_no_args _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.List (Ppx_sexp_conv_lib.Sexp.Atom (\"pos\" | \"Pos\") :: _) as\n sexp -> Ppx_sexp_conv_lib.Conv_error.stag_no_args _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.List (Ppx_sexp_conv_lib.Sexp.List _ :: _) as sexp ->\n Ppx_sexp_conv_lib.Conv_error.nested_list_invalid_sum _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.List [] as sexp ->\n Ppx_sexp_conv_lib.Conv_error.empty_list_invalid_sum _tp_loc sexp\n | sexp -> Ppx_sexp_conv_lib.Conv_error.unexpected_stag _tp_loc sexp\n : Ppx_sexp_conv_lib.Sexp.t -> t)\n;;\n\nlet sexp_of_t =\n (function\n | Neg -> Ppx_sexp_conv_lib.Sexp.Atom \"Neg\"\n | Zero -> Ppx_sexp_conv_lib.Sexp.Atom \"Zero\"\n | Pos -> Ppx_sexp_conv_lib.Sexp.Atom \"Pos\"\n : t -> Ppx_sexp_conv_lib.Sexp.t)\n;;\n\nlet compare = (Ppx_compare_lib.polymorphic_compare : t -> t -> int)\n\nlet (hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state) =\n (fun hsv arg ->\n match arg with\n | Neg -> Ppx_hash_lib.Std.Hash.fold_int hsv 0\n | Zero -> Ppx_hash_lib.Std.Hash.fold_int hsv 1\n | Pos -> Ppx_hash_lib.Std.Hash.fold_int hsv 2\n : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state)\n;;\n\nlet (hash : t -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func arg =\n Ppx_hash_lib.Std.Hash.get_hash_value\n (let hsv = Ppx_hash_lib.Std.Hash.create () in\n hash_fold_t hsv arg)\n in\n fun x -> func x\n;;\n\nlet all = ([ Neg; Zero; Pos ] : t list)\n\n[@@@end]\n\nmodule Replace_polymorphic_compare = struct\n let ( < ) (x : t) y = Poly.( < ) x y\n let ( <= ) (x : t) y = Poly.( <= ) x y\n let ( <> ) (x : t) y = Poly.( <> ) x y\n let ( = ) (x : t) y = Poly.( = ) x y\n let ( > ) (x : t) y = Poly.( > ) x y\n let ( >= ) (x : t) y = Poly.( >= ) x y\n let ascending (x : t) y = Poly.ascending x y\n let descending (x : t) y = Poly.descending x y\n let compare (x : t) y = Poly.compare x y\n let equal (x : t) y = Poly.equal x y\n let max (x : t) y = if x >= y then x else y\n let min (x : t) y = if x <= y then x else y\nend\n\nlet of_string s = t_of_sexp (sexp_of_string s)\nlet to_string t = string_of_sexp (sexp_of_t t)\n\nlet to_int = function\n | Neg -> -1\n | Zero -> 0\n | Pos -> 1\n;;\n\nlet _ = hash\n\n(* Ignore the hash function produced by [@@deriving_inline hash] *)\nlet hash = to_int\nlet module_name = \"Base.Sign\"\nlet of_int n = if n < 0 then Neg else if n = 0 then Zero else Pos\n","# 1 \"src/hex_lexer.mll\"\n \ntype result =\n| Neg of string\n| Pos of string\n\n# 8 \"src/hex_lexer.ml\"\nlet __ocaml_lex_tables = {\n Lexing.lex_base =\n \"\\000\\000\\000\\000\\001\\000\\001\\000\\002\\000\\027\\000\\082\\000\\105\\000\\\n \";\n Lexing.lex_backtrk =\n \"\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\255\\255\\001\\000\\\n \";\n Lexing.lex_default =\n \"\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \";\n Lexing.lex_trans =\n \"\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\000\\000\\000\\000\\000\\\n \\001\\000\\003\\000\\005\\000\\005\\000\\005\\000\\005\\000\\005\\000\\005\\000\\\n \\005\\000\\005\\000\\005\\000\\005\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\005\\000\\005\\000\\005\\000\\005\\000\\005\\000\\\n \\005\\000\\000\\000\\000\\000\\005\\000\\005\\000\\005\\000\\005\\000\\005\\000\\\n \\005\\000\\005\\000\\005\\000\\005\\000\\005\\000\\000\\000\\000\\000\\000\\000\\\n \\006\\000\\004\\000\\000\\000\\000\\000\\005\\000\\005\\000\\005\\000\\005\\000\\\n \\005\\000\\005\\000\\000\\000\\005\\000\\005\\000\\005\\000\\005\\000\\005\\000\\\n \\005\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\006\\000\\004\\000\\005\\000\\000\\000\\005\\000\\005\\000\\005\\000\\005\\000\\\n \\005\\000\\005\\000\\007\\000\\007\\000\\007\\000\\007\\000\\007\\000\\007\\000\\\n \\007\\000\\007\\000\\007\\000\\007\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\007\\000\\007\\000\\007\\000\\007\\000\\007\\000\\\n \\007\\000\\007\\000\\007\\000\\007\\000\\007\\000\\007\\000\\007\\000\\007\\000\\\n \\007\\000\\007\\000\\007\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\007\\000\\007\\000\\007\\000\\007\\000\\007\\000\\007\\000\\\n \\000\\000\\000\\000\\000\\000\\007\\000\\007\\000\\007\\000\\007\\000\\007\\000\\\n \\007\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\007\\000\\000\\000\\007\\000\\007\\000\\007\\000\\007\\000\\007\\000\\007\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\";\n Lexing.lex_check =\n \"\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\\n \\000\\000\\002\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\\n \\004\\000\\004\\000\\004\\000\\004\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\\n \\004\\000\\255\\255\\255\\255\\005\\000\\005\\000\\005\\000\\005\\000\\005\\000\\\n \\005\\000\\005\\000\\005\\000\\005\\000\\005\\000\\255\\255\\255\\255\\255\\255\\\n \\001\\000\\003\\000\\255\\255\\255\\255\\005\\000\\005\\000\\005\\000\\005\\000\\\n \\005\\000\\005\\000\\255\\255\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\\n \\004\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\001\\000\\003\\000\\005\\000\\255\\255\\005\\000\\005\\000\\005\\000\\005\\000\\\n \\005\\000\\005\\000\\006\\000\\006\\000\\006\\000\\006\\000\\006\\000\\006\\000\\\n \\006\\000\\006\\000\\006\\000\\006\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\006\\000\\006\\000\\006\\000\\006\\000\\006\\000\\\n \\006\\000\\007\\000\\007\\000\\007\\000\\007\\000\\007\\000\\007\\000\\007\\000\\\n \\007\\000\\007\\000\\007\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\007\\000\\007\\000\\007\\000\\007\\000\\007\\000\\007\\000\\\n \\255\\255\\255\\255\\255\\255\\006\\000\\006\\000\\006\\000\\006\\000\\006\\000\\\n \\006\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\007\\000\\255\\255\\007\\000\\007\\000\\007\\000\\007\\000\\007\\000\\007\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\";\n Lexing.lex_base_code =\n \"\";\n Lexing.lex_backtrk_code =\n \"\";\n Lexing.lex_default_code =\n \"\";\n Lexing.lex_trans_code =\n \"\";\n Lexing.lex_check_code =\n \"\";\n Lexing.lex_code =\n \"\";\n}\n\nlet rec parse_hex lexbuf =\n __ocaml_lex_parse_hex_rec lexbuf 0\nand __ocaml_lex_parse_hex_rec lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\nlet\n# 8 \"src/hex_lexer.mll\"\n body\n# 135 \"src/hex_lexer.ml\"\n= Lexing.sub_lexeme lexbuf (lexbuf.Lexing.lex_start_pos + 3) lexbuf.Lexing.lex_curr_pos in\n# 14 \"src/hex_lexer.mll\"\n ( Neg body )\n# 139 \"src/hex_lexer.ml\"\n\n | 1 ->\nlet\n# 8 \"src/hex_lexer.mll\"\n body\n# 145 \"src/hex_lexer.ml\"\n= Lexing.sub_lexeme lexbuf (lexbuf.Lexing.lex_start_pos + 2) lexbuf.Lexing.lex_curr_pos in\n# 15 \"src/hex_lexer.mll\"\n ( Pos body )\n# 149 \"src/hex_lexer.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_parse_hex_rec lexbuf __ocaml_lex_state\n\n;;\n\n","open! Import\n\n(* C stub for int popcount to use the POPCNT instruction where possible *)\nexternal int_popcount : int -> int = \"Base_int_math_int_popcount\" [@@noalloc]\n\n(* To maintain javascript compatibility and enable unboxing, we implement popcount in\n OCaml rather than use C stubs. Implementation adapted from:\n https://en.wikipedia.org/wiki/Hamming_weight#Efficient_implementation *)\nlet int64_popcount =\n let open Caml.Int64 in\n let ( + ) = add in\n let ( - ) = sub in\n let ( * ) = mul in\n let ( lsr ) = shift_right_logical in\n let ( land ) = logand in\n let m1 = 0x5555555555555555L in\n (* 0b01010101... *)\n let m2 = 0x3333333333333333L in\n (* 0b00110011... *)\n let m4 = 0x0f0f0f0f0f0f0f0fL in\n (* 0b00001111... *)\n let h01 = 0x0101010101010101L in\n (* 1 bit set per byte *)\n fun [@inline] x ->\n (* gather the bit count for every pair of bits *)\n let x = x - ((x lsr 1) land m1) in\n (* gather the bit count for every 4 bits *)\n let x = (x land m2) + ((x lsr 2) land m2) in\n (* gather the bit count for every byte *)\n let x = (x + (x lsr 4)) land m4 in\n (* sum the bit counts in the top byte and shift it down *)\n to_int ((x * h01) lsr 56)\n;;\n\nlet int32_popcount =\n (* On 64-bit systems, this is faster than implementing using [int32] arithmetic. *)\n let mask = 0xffff_ffffL in\n fun [@inline] x -> int64_popcount (Caml.Int64.logand (Caml.Int64.of_int32 x) mask)\n;;\n\nlet nativeint_popcount =\n match Caml.Nativeint.size with\n | 32 -> fun [@inline] x -> int32_popcount (Caml.Nativeint.to_int32 x)\n | 64 -> fun [@inline] x -> int64_popcount (Caml.Int64.of_nativeint x)\n | _ -> assert false\n;;\n","(* A 63bit integer is a 64bit integer with its bits shifted to the left\n and its lowest bit set to 0.\n This is the same kind of encoding as OCaml int on 64bit architecture.\n The only difference being the lowest bit (immediate bit) set to 1. *)\n\nopen! Import\ninclude Int64_replace_polymorphic_compare\n\n\nmodule T0 = struct\n module T = struct\n type t = int64 [@@deriving_inline compare, hash, sexp, sexp_grammar]\n\n let compare = (compare_int64 : t -> t -> int)\n\n let (hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state) =\n hash_fold_int64\n\n and (hash : t -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func = hash_int64 in\n fun x -> func x\n ;;\n\n let t_of_sexp = (int64_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t)\n let sexp_of_t = (sexp_of_int64 : t -> Ppx_sexp_conv_lib.Sexp.t)\n\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group)\n =\n { implicit_vars = [ \"int64\" ]\n ; ggid = \"\\146e\\023\\249\\235eE\\139c\\132W\\195\\137\\129\\235\\025\"\n ; types = [ \"t\", Implicit_var 0 ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ int64_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"int63_emul.ml.T0.T\"\n }\n in\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"t\", _the_group)\n in\n t_sexp_grammar\n ;;\n\n [@@@end]\n end\n\n include T\n include Comparator.Make (T)\nend\n\nmodule Conv = Int_conversions\n\nmodule W : sig\n\n type t = int64\n\n include module type of struct\n include T0\n end\n with type t := t\n\n val wrap_exn : Caml.Int64.t -> t\n val wrap_modulo : Caml.Int64.t -> t\n val unwrap : t -> Caml.Int64.t\n\n (** Returns a non-negative int64 that is equal to the input int63 modulo 2^63. *)\n val unwrap_unsigned : t -> Caml.Int64.t\n\n val invariant : t -> unit\n val add : t -> t -> t\n val sub : t -> t -> t\n val neg : t -> t\n val abs : t -> t\n val succ : t -> t\n val pred : t -> t\n val mul : t -> t -> t\n val pow : t -> t -> t\n val div : t -> t -> t\n val rem : t -> t -> t\n val popcount : t -> int\n val bit_not : t -> t\n val bit_xor : t -> t -> t\n val bit_or : t -> t -> t\n val bit_and : t -> t -> t\n val shift_left : t -> int -> t\n val shift_right : t -> int -> t\n val shift_right_logical : t -> int -> t\n val min_value : t\n val max_value : t\n val to_int64 : t -> Caml.Int64.t\n val of_int64 : Caml.Int64.t -> t option\n val of_int64_exn : Caml.Int64.t -> t\n val of_int64_trunc : Caml.Int64.t -> t\n val compare : t -> t -> int\n val ceil_pow2 : t -> t\n val floor_pow2 : t -> t\n val ceil_log2 : t -> int\n val floor_log2 : t -> int\n val is_pow2 : t -> bool\n val clz : t -> int\n val ctz : t -> int\nend = struct\n type t = int64\n\n include (\n T0 :\n module type of struct\n include T0\n end\n with type t := t)\n\n let wrap_exn x =\n (* Raises if the int64 value does not fit on int63. *)\n Conv.int64_fit_on_int63_exn x;\n Caml.Int64.mul x 2L\n ;;\n\n let wrap x =\n if Conv.int64_is_representable_as_int63 x then Some (Caml.Int64.mul x 2L) else None\n ;;\n\n let wrap_modulo x = Caml.Int64.mul x 2L\n let unwrap x = Caml.Int64.shift_right x 1\n let unwrap_unsigned x = Caml.Int64.shift_right_logical x 1\n\n (* This does not use wrap or unwrap to avoid generating exceptions in the case of\n overflows. This is to preserve the semantics of int type on 64 bit architecture. *)\n let f2 f a b =\n Caml.Int64.mul (f (Caml.Int64.shift_right a 1) (Caml.Int64.shift_right b 1)) 2L\n ;;\n\n let mask = 0xffff_ffff_ffff_fffeL\n let m x = Caml.Int64.logand x mask\n let invariant t = assert (m t = t)\n let add x y = Caml.Int64.add x y\n let sub x y = Caml.Int64.sub x y\n let neg x = Caml.Int64.neg x\n let abs x = Caml.Int64.abs x\n let one = wrap_exn 1L\n let succ a = add a one\n let pred a = sub a one\n let min_value = m Caml.Int64.min_int\n let max_value = m Caml.Int64.max_int\n let bit_not x = m (Caml.Int64.lognot x)\n let bit_and = Caml.Int64.logand\n let bit_xor = Caml.Int64.logxor\n let bit_or = Caml.Int64.logor\n let shift_left x i = Caml.Int64.shift_left x i\n let shift_right x i = m (Caml.Int64.shift_right x i)\n let shift_right_logical x i = m (Caml.Int64.shift_right_logical x i)\n let pow = f2 Int_math.Private.int63_pow_on_int64\n let mul a b = Caml.Int64.mul a (Caml.Int64.shift_right b 1)\n let div a b = wrap_modulo (Caml.Int64.div a b)\n let rem a b = Caml.Int64.rem a b\n let popcount x = Popcount.int64_popcount x\n let to_int64 t = unwrap t\n let of_int64 t = wrap t\n let of_int64_exn t = wrap_exn t\n let of_int64_trunc t = wrap_modulo t\n let t_of_sexp x = wrap_exn (int64_of_sexp x)\n let sexp_of_t x = sexp_of_int64 (unwrap x)\n let compare (x : t) y = compare x y\n let is_pow2 x = Int64.is_pow2 (unwrap x)\n\n let clz x =\n (* We run Int64.clz directly on the wrapped int63 value. This is correct because the\n bits of the int63_emul are left-aligned in the Int64. *)\n Int64.clz x\n ;;\n\n let ctz x = Int64.ctz (unwrap x)\n let floor_pow2 x = Int64.floor_pow2 (unwrap x) |> wrap_exn\n let ceil_pow2 x = Int64.floor_pow2 (unwrap x) |> wrap_exn\n let floor_log2 x = Int64.floor_log2 (unwrap x)\n let ceil_log2 x = Int64.ceil_log2 (unwrap x)\nend\n\nopen W\n\nmodule T = struct\n type t = W.t [@@deriving_inline hash, sexp, sexp_grammar]\n\n let (hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state) =\n W.hash_fold_t\n\n and (hash : t -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func = W.hash in\n fun x -> func x\n ;;\n\n let t_of_sexp = (W.t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t)\n let sexp_of_t = (W.sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t)\n\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group) =\n { implicit_vars = [ \"W.t\" ]\n ; ggid = \"\\146e\\023\\249\\235eE\\139c\\132W\\195\\137\\129\\235\\025\"\n ; types = [ \"t\", Implicit_var 0 ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ W.t_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"int63_emul.ml.T\"\n }\n in\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"t\", _the_group)\n in\n t_sexp_grammar\n ;;\n\n [@@@end]\n\n type comparator_witness = W.comparator_witness\n\n let comparator = W.comparator\n let compare = W.compare\n let invariant = W.invariant\n\n (* We don't expect [hash] to follow the behavior of int in 64bit architecture *)\n let _ = hash\n let hash (x : t) = Caml.Hashtbl.hash x\n let invalid_str x = Printf.failwithf \"Int63.of_string: invalid input %S\" x ()\n\n (*\n \"sign\" refers to whether the number starts with a '-'\n \"signedness = false\" means the rest of the number is parsed as unsigned and then cast\n to signed with wrap-around modulo 2^i\n \"signedness = true\" means no such craziness happens\n\n The terminology and the logic is due to the code in byterun/ints.c in ocaml 4.03\n ([parse_sign_and_base] function).\n\n Signedness equals true for plain decimal number (e.g. 1235, -6789)\n\n Signedness equals false in the following cases:\n - [0xffff], [-0xffff] (hexadecimal representation)\n - [0b0101], [-0b0101] (binary representation)\n - [0o1237], [-0o1237] (octal representation)\n - [0u9812], [-0u9812] (unsigned decimal representation - available from OCaml 4.03) *)\n let sign_and_signedness x =\n let len = String.length x in\n let open Int_replace_polymorphic_compare in\n let pos, sign =\n if 0 < len\n then (\n match x.[0] with\n | '-' -> 1, `Neg\n | '+' -> 1, `Pos\n | _ -> 0, `Pos)\n else 0, `Pos\n in\n if pos + 2 < len\n then (\n let c1 = x.[pos] in\n let c2 = x.[pos + 1] in\n match c1, c2 with\n | '0', '0' .. '9' -> sign, true\n | '0', _ -> sign, false\n | _ -> sign, true)\n else sign, true\n ;;\n\n let to_string x = Caml.Int64.to_string (unwrap x)\n\n let of_string str =\n try\n let sign, signedness = sign_and_signedness str in\n if signedness\n then of_int64_exn (Caml.Int64.of_string str)\n else (\n let pos_str =\n match sign with\n | `Neg -> String.sub str ~pos:1 ~len:(String.length str - 1)\n | `Pos -> str\n in\n let int64 = Caml.Int64.of_string pos_str in\n (* unsigned 63-bit int must parse as a positive signed 64-bit int *)\n if Int64_replace_polymorphic_compare.( < ) int64 0L then invalid_str str;\n let int63 = wrap_modulo int64 in\n match sign with\n | `Neg -> neg int63\n | `Pos -> int63)\n with\n | _ -> invalid_str str\n ;;\n\n let bswap16 t = wrap_modulo (Int64.bswap16 (unwrap t))\n let bswap32 t = wrap_modulo (Int64.bswap32 (unwrap t))\n let bswap48 t = wrap_modulo (Int64.bswap48 (unwrap t))\nend\n\ninclude T\n\nlet num_bits = 63\nlet float_lower_bound = Float0.lower_bound_for_int num_bits\nlet float_upper_bound = Float0.upper_bound_for_int num_bits\nlet shift_right_logical = shift_right_logical\nlet shift_right = shift_right\nlet shift_left = shift_left\nlet bit_not = bit_not\nlet bit_xor = bit_xor\nlet bit_or = bit_or\nlet bit_and = bit_and\nlet popcount = popcount\nlet abs = abs\nlet pred = pred\nlet succ = succ\nlet pow = pow\nlet rem = rem\nlet neg = neg\nlet max_value = max_value\nlet min_value = min_value\nlet minus_one = wrap_exn Caml.Int64.minus_one\nlet one = wrap_exn Caml.Int64.one\nlet zero = wrap_exn Caml.Int64.zero\nlet is_pow2 = is_pow2\nlet floor_pow2 = floor_pow2\nlet ceil_pow2 = ceil_pow2\nlet floor_log2 = floor_log2\nlet ceil_log2 = ceil_log2\nlet clz = clz\nlet ctz = ctz\nlet to_float x = Caml.Int64.to_float (unwrap x)\nlet of_float_unchecked x = wrap_modulo (Caml.Int64.of_float x)\n\nlet of_float t =\n let open Float_replace_polymorphic_compare in\n if t >= float_lower_bound && t <= float_upper_bound\n then wrap_modulo (Caml.Int64.of_float t)\n else\n Printf.invalid_argf\n \"Int63.of_float: argument (%f) is out of range or NaN\"\n (Float0.box t)\n ()\n;;\n\nlet of_int64 = of_int64\nlet of_int64_exn = of_int64_exn\nlet of_int64_trunc = of_int64_trunc\nlet to_int64 = to_int64\n\ninclude Comparable.Validate_with_zero (struct\n include T\n\n let zero = zero\n end)\n\nlet between t ~low ~high = low <= t && t <= high\nlet clamp_unchecked t ~min ~max = if t < min then min else if t <= max then t else max\n\nlet clamp_exn t ~min ~max =\n assert (min <= max);\n clamp_unchecked t ~min ~max\n;;\n\nlet clamp t ~min ~max =\n if min > max\n then\n Or_error.error_s\n (Sexp.message\n \"clamp requires [min <= max]\"\n [ \"min\", T.sexp_of_t min; \"max\", T.sexp_of_t max ])\n else Ok (clamp_unchecked t ~min ~max)\n;;\n\nlet ( / ) = div\nlet ( * ) = mul\nlet ( - ) = sub\nlet ( + ) = add\nlet ( ~- ) = neg\nlet ( ** ) b e = pow b e\nlet incr r = r := !r + one\nlet decr r = r := !r - one\n\n(* We can reuse conversion function from/to int64 here. *)\nlet of_int x = wrap_exn (Conv.int_to_int64 x)\nlet of_int_exn x = of_int x\nlet to_int x = Conv.int64_to_int (unwrap x)\nlet to_int_exn x = Conv.int64_to_int_exn (unwrap x)\nlet to_int_trunc x = Conv.int64_to_int_trunc (unwrap x)\nlet of_int32 x = wrap_exn (Conv.int32_to_int64 x)\nlet of_int32_exn x = of_int32 x\nlet to_int32 x = Conv.int64_to_int32 (unwrap x)\nlet to_int32_exn x = Conv.int64_to_int32_exn (unwrap x)\nlet to_int32_trunc x = Conv.int64_to_int32_trunc (unwrap x)\nlet of_nativeint x = of_int64 (Conv.nativeint_to_int64 x)\nlet of_nativeint_exn x = wrap_exn (Conv.nativeint_to_int64 x)\nlet of_nativeint_trunc x = of_int64_trunc (Conv.nativeint_to_int64 x)\nlet to_nativeint x = Conv.int64_to_nativeint (unwrap x)\nlet to_nativeint_exn x = Conv.int64_to_nativeint_exn (unwrap x)\nlet to_nativeint_trunc x = Conv.int64_to_nativeint_trunc (unwrap x)\n\ninclude Conv.Make (T)\n\ninclude Conv.Make_hex (struct\n type t = T.t [@@deriving_inline compare, hash]\n\n let compare = (T.compare : t -> t -> int)\n\n let (hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state) =\n T.hash_fold_t\n\n and (hash : t -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func = T.hash in\n fun x -> func x\n ;;\n\n [@@@end]\n\n let zero = zero\n let neg = ( ~- )\n let ( < ) = ( < )\n\n let to_string i =\n (* the use of [unwrap_unsigned] here is important for the case of [min_value] *)\n Printf.sprintf \"%Lx\" (unwrap_unsigned i)\n ;;\n\n let of_string s = of_string (\"0x\" ^ s)\n let module_name = \"Base.Int63.Hex\"\n end)\n\ninclude Pretty_printer.Register (struct\n type nonrec t = t\n\n let to_string x = to_string x\n let module_name = \"Base.Int63\"\n end)\n\nmodule Pre_O = struct\n let ( + ) = ( + )\n let ( - ) = ( - )\n let ( * ) = ( * )\n let ( / ) = ( / )\n let ( ~- ) = ( ~- )\n let ( ** ) = ( ** )\n\n include (Int64_replace_polymorphic_compare : Comparisons.Infix with type t := t)\n\n let abs = abs\n let neg = neg\n let zero = zero\n let of_int_exn = of_int_exn\nend\n\nmodule O = struct\n include Pre_O\n\n include Int_math.Make (struct\n type nonrec t = t\n\n include Pre_O\n\n let rem = rem\n let to_float = to_float\n let of_float = of_float\n let of_string = T.of_string\n let to_string = T.to_string\n end)\n\n let ( land ) = bit_and\n let ( lor ) = bit_or\n let ( lxor ) = bit_xor\n let lnot = bit_not\n let ( lsl ) = shift_left\n let ( asr ) = shift_right\n let ( lsr ) = shift_right_logical\nend\n\ninclude O\n\n(* [Int63] and [Int63.O] agree value-wise *)\n\nmodule Repr = struct\n type emulated = t\n\n type ('underlying_type, 'intermediate_type) t =\n | Int : (int, int) t\n | Int64 : (int64, emulated) t\nend\n\nlet repr = Repr.Int64\n\n(* Include type-specific [Replace_polymorphic_compare] at the end, after\n including functor application that could shadow its definitions. This is\n here so that efficient versions of the comparison functions are exported by\n this module. *)\ninclude Int64_replace_polymorphic_compare\n","open! Import\nmodule Sys = Sys0\n\ntype t = Caml.Printexc.raw_backtrace\n\nlet elide = ref am_testing\nlet elided_message = \"\"\n\nlet get ?(at_most_num_frames = Int.max_value) () =\n Caml.Printexc.get_callstack at_most_num_frames\n;;\n\nlet to_string t =\n if !elide then elided_message else Caml.Printexc.raw_backtrace_to_string t\n;;\n\nlet to_string_list t = String.split_lines (to_string t)\nlet sexp_of_t t = Sexp.List (List.map (to_string_list t) ~f:(fun x -> Sexp.Atom x))\n\nmodule Exn = struct\n let set_recording = Caml.Printexc.record_backtrace\n let am_recording = Caml.Printexc.backtrace_status\n let most_recent () = Caml.Printexc.get_raw_backtrace ()\n\n (* We turn on backtraces by default if OCAMLRUNPARAM doesn't explicitly mention them. *)\n let maybe_set_recording () =\n let ocamlrunparam_mentions_backtraces =\n match Sys.getenv \"OCAMLRUNPARAM\" with\n | None -> false\n | Some x -> List.exists (String.split x ~on:',') ~f:(String.is_prefix ~prefix:\"b\")\n in\n if not ocamlrunparam_mentions_backtraces then set_recording true\n ;;\n\n (* the caller set something, they are responsible *)\n\n let with_recording b ~f =\n let saved = am_recording () in\n set_recording b;\n Exn.protect ~f ~finally:(fun () -> set_recording saved)\n ;;\nend\n\nlet initialize_module () = Exn.maybe_set_recording ()\n","let unique_id =\n let r = ref 0 in\n fun () -> incr r; !r\n\n(* Used to track the current libname in such a way that for functor applications, it is\n the calling libraries name that gets registered. *)\nmodule Current_libname = struct\n let null = \"\"\n let libname_ref = ref null\n\n let set str = libname_ref := str\n let unset () = libname_ref := null\n let get () = !libname_ref\nend\n\nmodule Current_bench_module_stack = struct\n let t = ref []\n\n let push s = t := s :: !t\n\n let pop_exn () = t := List.tl !t\n\n let to_name () =\n match !t with\n | [] -> None\n | ms -> Some (String.concat \".\" (List.rev ms))\nend\n\n(* This is the main data structure of this module. An [Entry.t] represents a benchmark\n along with some metadata about is position, arguments etc. *)\nmodule Entry = struct\n\n type 'a indexed_spec = {\n arg_name : string;\n arg_values : int list;\n thunk : int -> unit -> 'a;\n }\n\n type test_spec =\n | Regular_thunk : ([`init] -> unit -> 'a) -> test_spec\n | Indexed_thunk : 'a indexed_spec -> test_spec\n\n type t = {\n unique_id : int;\n code : string;\n type_conv_path : string;\n name : string;\n filename : string;\n line : int;\n startpos : int;\n endpos : int;\n test_spec : test_spec;\n bench_module_name : string option;\n }\n\n let compare t1 t2 = compare t1.unique_id t2.unique_id\n\n let get_indexed_arg_name t =\n match t.test_spec with\n | Regular_thunk _ -> None\n | Indexed_thunk {arg_name; _} -> Some arg_name\n\n (* Extracts module name from [\"filename.ml.Module\"], which is the format of [ext_name]\n as set by [typeconv]. *)\n let get_module_name_opt t =\n let str = t.type_conv_path in\n let len = String.length str in\n let rec loop i =\n if i + 4 <= len\n then\n if String.sub str i 4 = \".ml.\"\n then Some (String.sub str (i + 4) (len - i - 4))\n else loop (i + 1)\n else None\n in\n loop 0\nend\n\n(* Inspect system environment variables to decide if benchmarks are being run. This is\n called by the code generated by the [pa_bench] syntax to decide if the global hashtable\n should be populated. *)\nlet add_environment_var =\n let v =\n try Sys.getenv \"BENCHMARKS_RUNNER\" with\n | Not_found -> \"\"\n in\n v = \"TRUE\"\n\n(* This hashtable contains all the benchmarks from all the of libraries that have been\n loaded. At the time the benchmarks are registering themselves with [ppx_bench_lib] we\n don't yet know which libraries will need to be run. *)\nlet libs_to_entries : (string, Entry.t list) Hashtbl.t = Hashtbl.create 10\n\nlet lookup_rev_lib ~libname =\n try Hashtbl.find libs_to_entries libname\n with Not_found -> []\n\nlet lookup_lib ~libname =\n List.rev (lookup_rev_lib ~libname)\n\nlet force_drop =\n (* Useful for js_of_ocaml to perform deadcode elimination.\n see ppx/ppx_inline_test/runtime-lib/runtime.ml [Action.get] for more details *)\n try ignore (Sys.getenv \"FORCE_DROP_BENCH\" : string); true\n with Not_found -> false\n\nlet get_mode () =\n if force_drop\n then `Ignore\n else `Collect\n\nlet[@inline never] add_bench\n ~name\n ~code\n ~filename\n ~type_conv_path\n ~line\n ~startpos\n ~endpos\n test_spec\n =\n match get_mode () with\n | `Ignore -> ()\n | `Collect ->\n let libname = Current_libname.get () in\n let entry = { Entry.\n code; unique_id = unique_id ();\n type_conv_path; bench_module_name = Current_bench_module_stack.to_name ();\n name; filename; line; startpos; endpos; test_spec;\n } in\n Hashtbl.add libs_to_entries libname (entry :: lookup_rev_lib ~libname)\n\nlet[@inline never] add_bench_module\n ~name\n ~code:_\n ~type_conv_path:_\n ~filename:_\n ~line:_\n ~startpos:_\n ~endpos:_\n f =\n match get_mode () with\n | `Ignore -> ()\n | `Collect ->\n (* Running f registers the benchmarks using BENCH *)\n Current_bench_module_stack.push name;\n try\n f ();\n Current_bench_module_stack.pop_exn ();\n with ex ->\n Current_bench_module_stack.pop_exn ();\n raise ex\n","open! Base\n\nmodule Location : sig\n include Identifiable.S\nend = struct\n include String\nend\n\nmodule Uuid : sig\n include Identifiable.S\nend = struct\n include String\nend\n\nlet eval_fail loc fmt =\n Printf.ksprintf (fun s -> failwith (Printf.sprintf !\"%{Location}: %s\" loc s)) fmt\n;;\n\nlet equal_option equal a b =\n match a, b with\n | Some _, None | None, Some _ -> false\n | None, None -> true\n | Some x, Some y -> equal x y\n;;\n\nmodule Sorted_table : sig\n type 'a t [@@deriving compare, sexp]\n\n val create : Location.t -> eq:('a -> 'a -> bool) -> (string * 'a) list -> 'a t\n val expose : 'a t -> (string * 'a) list\n val map : 'a t -> f:('a -> 'b) -> 'b t\nend = struct\n type 'a t = { sorted : (string * 'a) list } [@@deriving compare, sexp]\n\n let merge_check_adjacent_dups\n : eq:('a -> 'a -> bool) -> (string * 'a) list\n -> [ `Ok of (string * 'a) list | `Mismatch of string ]\n =\n fun ~eq ->\n let rec loop acc ~last_key ~last_value = function\n | [] -> `Ok (List.rev acc)\n | (key, value) :: xs ->\n if String.(last_key = key)\n then\n if eq last_value value\n then loop acc ~last_key ~last_value xs\n else `Mismatch key\n else loop ((key, value) :: acc) ~last_key:key ~last_value:value xs\n in\n function\n | [] -> `Ok []\n | (key, value) :: xs -> loop [ key, value ] ~last_key:key ~last_value:value xs\n ;;\n\n let create loc ~eq xs =\n let sorted = List.sort ~compare:(fun (s1, _) (s2, _) -> String.compare s1 s2) xs in\n match merge_check_adjacent_dups ~eq sorted with\n | `Ok sorted -> { sorted }\n | `Mismatch s ->\n eval_fail loc \"Different shapes for duplicated polymorphic constructor: `%s\" s ()\n ;;\n\n let expose t = t.sorted\n let map t ~f = { sorted = List.map t.sorted ~f:(fun (k, v) -> k, f v) }\nend\n\nmodule Digest : sig\n type t = Md5_lib.t [@@deriving compare, sexp]\n\n val to_md5 : t -> Md5_lib.t\n val of_md5 : Md5_lib.t -> t\n val to_hex : t -> string\n val constructor : string -> t list -> t\n val list : t list -> t\n val pair : t -> t -> t\n val string : string -> t\n val uuid : Uuid.t -> t\n val int : int -> t\n val option : t option -> t\nend = struct\n include Md5_lib\n\n let to_md5 t = t\n let of_md5 t = t\n let sexp_of_t t = t |> to_hex |> sexp_of_string\n let t_of_sexp s = s |> string_of_sexp |> of_hex_exn\n let uuid u = string (Uuid.to_string u)\n let int x = string (Int.to_string x)\n let pair x y = string (to_binary x ^ to_binary y)\n let list l = string (String.concat ~sep:\"\" (List.map ~f:to_binary l))\n let constructor s l = string (s ^ to_binary (list l))\n\n let option = function\n | None -> constructor \"none\" []\n | Some x -> constructor \"some\" [ x ]\n ;;\nend\n\nmodule Canonical_exp_constructor = struct\n (* ['a t] is a non-recursive type, used to represent 1-layer of expression. The\n recursive knot is tied below in [Canonical_full.Exp.t]. *)\n type 'a t =\n | Annotate of Uuid.t * 'a\n | Base of Uuid.t * 'a list\n | Tuple of 'a list\n | Record of (string * 'a) list\n | Variant of (string * 'a list) list\n (* Polymorphic variants are insensitive to the order the constructors are listed *)\n | Poly_variant of 'a option Sorted_table.t\n (* Left-hand-side of [Application] is a potentially recursive definition: it\n can refer to itself using [Rec_app (i, _)] where [i] is the depth of this\n application node (how many application nodes are above it).\n It also has its own scope of type variables so it can not refer to type variables\n of the enclosing scope.\n *)\n | Application of 'a * 'a list\n | Rec_app of int * 'a list\n | Var of int\n [@@deriving sexp, compare]\n\n let map x ~f =\n match x with\n | Annotate (u, x) -> Annotate (u, f x)\n | Base (s, xs) -> Base (s, List.map ~f xs)\n | Tuple xs -> Tuple (List.map ~f xs)\n | Record l -> Record (List.map l ~f:(fun (s, x) -> s, f x))\n | Variant l -> Variant (List.map l ~f:(fun (s, xs) -> s, List.map ~f xs))\n | Poly_variant t -> Poly_variant (Sorted_table.map t ~f:(Option.map ~f))\n | Application (x, l) -> Application (f x, List.map ~f l)\n | Rec_app (t, l) -> Rec_app (t, List.map ~f l)\n | Var v -> Var v\n ;;\n\n let to_string t = Sexp.to_string (sexp_of_t (fun _ -> Atom \"...\") t)\nend\n\nmodule Create_digest : sig\n (* Digest various expression forms *)\n\n val digest_layer : Digest.t Canonical_exp_constructor.t -> Digest.t\nend = struct\n let digest_layer = function\n | Canonical_exp_constructor.Annotate (u, x) ->\n Digest.constructor \"annotate\" [ Digest.uuid u; x ]\n | Base (u, l) -> Digest.constructor \"base\" [ Digest.uuid u; Digest.list l ]\n | Tuple l -> Digest.constructor \"tuple\" [ Digest.list l ]\n | Record l ->\n Digest.constructor\n \"record\"\n [ Digest.list (List.map l ~f:(fun (s, t) -> Digest.pair (Digest.string s) t)) ]\n | Variant l ->\n Digest.constructor\n \"variant\"\n [ Digest.list\n (List.map l ~f:(fun (s, l) -> Digest.pair (Digest.string s) (Digest.list l)))\n ]\n | Poly_variant table ->\n Digest.constructor\n \"poly_variant\"\n [ Digest.list\n (List.map (Sorted_table.expose table) ~f:(fun (x, y) ->\n Digest.pair (Digest.string x) (Digest.option y)))\n ]\n | Application (x, l) -> Digest.constructor \"application\" [ x; Digest.list l ]\n | Rec_app (n, l) -> Digest.constructor \"rec_app\" [ Digest.int n; Digest.list l ]\n | Var n -> Digest.constructor \"var\" [ Digest.int n ]\n ;;\nend\n\nmodule Visibility = struct\n type visible = Visible\n type opaque = Opaque\n\n let _ = Visible\n let _ = Opaque\nend\n\nmodule type Canonical = sig\n type t\n\n val to_digest : t -> Digest.t\n\n module Exp1 : sig\n type _ t\n\n val var : int -> _ t\n val recurse : int -> _ t list -> _ t\n val apply : 'a t -> 'a t list -> _ t\n val opaque : _ t -> Visibility.opaque t\n\n val get_poly_variant\n : Visibility.visible t\n -> (Visibility.opaque t option Sorted_table.t, string) Result.t\n end\n\n module Def : sig\n type t = Visibility.visible Exp1.t\n end\n\n module Create : sig\n val annotate : Uuid.t -> _ Exp1.t -> _ Exp1.t\n val basetype : Uuid.t -> _ Exp1.t list -> _ Exp1.t\n val tuple : _ Exp1.t list -> _ Exp1.t\n val poly_variant : Location.t -> (string * _ Exp1.t option) list -> _ Exp1.t\n val var : int -> _ Exp1.t\n val recurse : int -> _ Exp1.t list -> _ Exp1.t\n val apply : 'a Exp1.t -> 'a Exp1.t list -> _ Exp1.t\n val define : Visibility.visible Exp1.t -> Def.t\n val record : (string * _ Exp1.t) list -> _ Exp1.t\n val variant : (string * _ Exp1.t list) list -> _ Exp1.t\n val create : _ Exp1.t -> t\n end\nend\n\nmodule Canonical_digest : Canonical = struct\n type t = Canonical of Digest.t\n\n let to_digest (Canonical x) = x\n\n module CD = Create_digest\n\n module Exp1 = struct\n type opaque = Digest.t\n\n type 'a t =\n | Poly_variant of opaque option Sorted_table.t\n | Non_poly_variant of (string * opaque)\n | Opaque : opaque -> Visibility.opaque t\n\n let to_digest (type a) (x : a t) =\n match x with\n | Opaque x -> x\n | Non_poly_variant (_, x) -> x\n | Poly_variant x -> CD.digest_layer (Poly_variant x)\n ;;\n\n let equal (type a) (x : a t) (y : a t) =\n Digest.compare (to_digest x) (to_digest y) = 0\n ;;\n\n let opaque x = Opaque (to_digest x)\n\n let create x =\n let x = Canonical_exp_constructor.map ~f:to_digest x in\n let desc = Canonical_exp_constructor.to_string x in\n match x with\n | Canonical_exp_constructor.Poly_variant l -> Poly_variant l\n | Base _ -> Non_poly_variant (desc, CD.digest_layer x)\n | Annotate _ ->\n (* It's unsafe to use deriving bin_io when inheriting from a polymorphic variant\n that has a custom bin_io. If we forbid that, we can happily reject here\n anything that's annotated. *)\n Non_poly_variant (desc, CD.digest_layer x)\n | Application _ ->\n (* Application can really be a poly-variant you can inherit from! But it's a\n rare situation that mostly (only?) arises with inheritance from recursive\n polymorpic variants, which we've not seen anywhere yet. So we reject it. *)\n Non_poly_variant (desc, CD.digest_layer x)\n | Rec_app _ ->\n (* You can only get the [Rec_app] constructor for type-references within the\n mutual group being defined. References which\n follow after the current group will always be [Application]s.\n\n And since ocaml rejects references in `inheritance' position to types within\n the current group (see example) with:\n\n Error: The type constructor t\n is not yet completely defined\n\n then its ok to say that a rec-app is something that can't be inherited from and\n return [Non_poly_variant].\n\n And unlike the [Application] case, it should never be possible to see\n an error message with the [desc] = [Rec_app].\n\n Example: [type t = [`a of [ | t] ]]\n Here, [| t] would be an example of inheritance from a Rec_app, which\n is rejected by the compiler.\n *)\n Non_poly_variant (desc, CD.digest_layer x)\n | Var _ | Tuple _ | Record _ | Variant _ ->\n Non_poly_variant (desc, CD.digest_layer x)\n ;;\n\n let var x = create (Var x)\n let apply def l = create (Application (def, l))\n let recurse tid l = create (Rec_app (tid, l))\n\n let get_poly_variant (x : Visibility.visible t) =\n match x with\n | Non_poly_variant (desc, _) -> Error desc\n | Poly_variant l -> Ok (Sorted_table.map ~f:(Option.map ~f:(fun x -> Opaque x)) l)\n ;;\n end\n\n module Def = struct\n type t = Visibility.visible Exp1.t\n end\n\n module Create = struct\n let annotate u x = Exp1.create (Annotate (u, x))\n let basetype u l = Exp1.create (Base (u, l))\n let tuple l = Exp1.create (Tuple l)\n\n let poly_variant loc l =\n Exp1.create\n (Poly_variant (Sorted_table.create loc ~eq:(equal_option Exp1.equal) l))\n ;;\n\n let var x = Exp1.create (Var x)\n let apply x l = Exp1.create (Application (x, l))\n let recurse t l = Exp1.create (Rec_app (t, l))\n let define x = x\n let record l = Exp1.create (Record l)\n let variant l = Exp1.create (Variant l)\n let create e = Canonical (Exp1.to_digest e)\n end\nend\n\nmodule Canonical_full : sig\n type t [@@deriving compare, sexp]\n\n include Canonical with type t := t\n\n val to_string_hum : t -> string\nend = struct\n module CD = Create_digest\n\n module Exp1 = struct\n type t0 = Exp of t0 Canonical_exp_constructor.t [@@deriving compare, sexp]\n\n let equal_t0 x y = compare_t0 x y = 0\n\n type 'a t = t0 [@@deriving compare, sexp]\n\n let var x = Exp (Canonical_exp_constructor.Var x)\n let apply d xs = Exp (Canonical_exp_constructor.Application (d, xs))\n let recurse r xs = Exp (Canonical_exp_constructor.Rec_app (r, xs))\n\n let poly_variant loc xs =\n Exp\n (Canonical_exp_constructor.Poly_variant\n (Sorted_table.create loc ~eq:(equal_option equal_t0) xs))\n ;;\n\n let get_poly_variant = function\n | Exp (Poly_variant tab) -> Ok tab\n | Exp cc -> Error (Canonical_exp_constructor.to_string cc)\n ;;\n\n let opaque t = t\n\n let rec to_digest = function\n | Exp e -> CD.digest_layer (Canonical_exp_constructor.map ~f:to_digest e)\n ;;\n end\n\n module Def = struct\n (* A [Def.t] is an expression which may be applied *)\n type t = Exp1.t0 [@@deriving compare, sexp]\n end\n\n (* A canonical shape [t] is an [Exp1.t]. *)\n type t = Exp1.t0 [@@deriving compare, sexp]\n\n let to_digest e = Exp1.to_digest e\n\n module Create = struct\n let annotate u x = Exp1.Exp (Annotate (u, x))\n let basetype u xs = Exp1.Exp (Base (u, xs))\n let tuple xs = Exp1.Exp (Tuple xs)\n let poly_variant loc xs = Exp1.poly_variant loc xs\n let var n = Exp1.Exp (Var n)\n let recurse r xs = Exp1.recurse r xs\n let apply d xs = Exp1.apply d xs\n let define x = x\n let record xs = Exp1.Exp (Record xs)\n let variant xs = Exp1.Exp (Variant xs)\n let create exp = exp\n end\n\n let to_string_hum t = Sexp.to_string_hum (sexp_of_t t)\nend\n\nmodule Tid : sig\n include Identifiable.S\nend = struct\n include String\nend\n\nmodule Vid : sig\n include Identifiable.S\nend = struct\n include String\nend\n\nmodule Gid : sig\n (* unique group-id, used as key for Tenv below *)\n type t [@@deriving compare, sexp_of]\n\n val create : unit -> t\nend = struct\n type t = int [@@deriving compare, sexp_of]\n\n let r = ref 0\n\n let create () =\n let u = !r in\n r := 1 + u;\n u\n ;;\nend\n\nmodule Expression = struct\n type 't poly_constr =\n [ `Constr of string * 't option\n | `Inherit of Location.t * 't\n ]\n [@@deriving compare, sexp_of]\n\n module Group : sig\n type 'a t [@@deriving compare, sexp_of]\n\n val create : Location.t -> (Tid.t * Vid.t list * 'a) list -> 'a t\n val id : 'a t -> Gid.t\n val lookup : 'a t -> Tid.t -> Vid.t list * 'a\n end = struct\n type 'a t =\n { gid : Gid.t\n ; loc : Location.t\n ; members : (Tid.t * (Vid.t list * 'a)) list\n }\n [@@deriving compare, sexp_of]\n\n let create loc trips =\n let gid = Gid.create () in\n let members = List.map trips ~f:(fun (x, vs, t) -> x, (vs, t)) in\n { gid; loc; members }\n ;;\n\n let id g = g.gid\n\n let lookup g tid =\n match List.Assoc.find g.members ~equal:Tid.( = ) tid with\n | Some scheme -> scheme\n | None ->\n eval_fail\n g.loc\n !\"impossible: lookup_group, unbound type-identifier: %{Tid}\"\n tid\n ()\n ;;\n end\n\n type t =\n | Annotate of Uuid.t * t\n | Base of Uuid.t * t list\n | Record of (string * t) list\n | Variant of (string * t list) list\n | Tuple of t list\n | Poly_variant of (Location.t * t poly_constr list)\n | Var of (Location.t * Vid.t)\n | Rec_app of Tid.t * t list\n | Top_app of t Group.t * Tid.t * t list\n [@@deriving variants, sexp_of]\n\n type group = t Group.t\n\n let group = Group.create\n\n type poly_variant_row = t poly_constr\n\n let constr s t = `Constr (s, t)\n let inherit_ loc t = `Inherit (loc, t)\n let var loc t = Var (loc, t)\n let poly_variant loc xs = Poly_variant (loc, xs)\n let basetype = base\n\n (* \"VR\" stands for \"variant or record\" *)\n\n let is_cyclic_0 ~(via_VR : bool) : group -> Tid.t -> bool =\n fun group tid ->\n let set = ref [] in\n let visited tid = List.mem !set tid ~equal:Tid.equal in\n let add tid = set := tid :: !set in\n let rec trav = function\n (* We look for cycles by traversing the structure of type-expressions *)\n | Annotate (_, t) -> trav t\n | Base (_, ts) | Tuple ts | Top_app (_, _, ts) -> List.iter ts ~f:trav\n (* ..including poly-variants *)\n | Poly_variant (_, cs) ->\n List.iter cs ~f:(function\n | `Constr (_, None) -> ()\n | `Constr (_, Some t) -> trav t\n | `Inherit (_loc, t) -> trav t)\n (* .. and records & (normal) variants *)\n | Record xs -> if via_VR then List.iter xs ~f:(fun (_, t) -> trav t) else ()\n | Variant xs ->\n if via_VR then List.iter xs ~f:(fun (_, ts) -> List.iter ~f:trav ts) else ()\n (* We dont follow type-vars *)\n | Var _ -> ()\n (* traverse (recursive) type-apps when first encountered *)\n | Rec_app (tid, ts) ->\n if visited tid\n then ()\n else (\n add tid;\n trav_tid tid);\n List.iter ts ~f:trav\n and trav_tid tid =\n let _, body = Group.lookup group tid in\n trav body\n in\n trav_tid tid;\n let res = visited tid in\n (*let _ss = String.concat ~sep:\",\" (List.map (!set) ~f:(sprintf !\"%{Tid}\")) in*)\n (*Printf.printf !\"is_cylic: %{Tid} --> (%s) %b -- %s%!\" tid _ss res (Group.loc group);*)\n res\n ;;\n\n let is_cyclic = is_cyclic_0 ~via_VR:true\n let is_cyclic_with_no_intervening_VR = is_cyclic_0 ~via_VR:false\nend\n\ninclude Expression\n\nmodule Evaluation (Canonical : Canonical) = struct\n (* [Venv.t]\n Environment for resolving type-vars *)\n module Venv : sig\n type t\n\n val lookup : t -> Vid.t -> Visibility.visible Canonical.Exp1.t option\n val create : (Vid.t * Visibility.visible Canonical.Exp1.t) list -> t\n end = struct\n type t = Visibility.visible Canonical.Exp1.t Map.M(Vid).t\n\n let create =\n List.fold\n ~init:(Map.empty (module Vid))\n ~f:(fun t (k, v) -> Map.set ~key:k ~data:v t)\n ;;\n\n let lookup t k = Map.find t k\n end\n\n module Applicand = struct\n type t =\n | Recursion_level of int\n | Definition of Canonical.Def.t\n end\n\n (* [Tenv.t]\n Environment for resolving type-definitions *)\n module Tenv : sig\n type key = Gid.t * Tid.t\n type t\n\n val find : t -> key -> [ `Recursion_level of int ] option\n val empty : t\n val extend : t -> key -> [ `Recursion_level of int ] -> t\n end = struct\n module Key = struct\n module T = struct\n type t = Gid.t * Tid.t [@@deriving compare, sexp_of]\n end\n\n include T\n include Comparator.Make (T)\n end\n\n type key = Key.t\n type t = [ `Recursion_level of int ] Map.M(Key).t\n\n let find t k = Map.find t k\n let empty = Map.empty (module Key)\n let extend t k v = Map.set ~key:k ~data:v t\n end\n\n (* [Defining.t]\n Monad for managing un-rolling depth, and maintaing a [Tenv.t] *)\n module Defining : sig\n type 'a t\n\n val return : 'a -> 'a t\n val bind : 'a t -> ('a -> 'b t) -> 'b t\n val look_env : Tenv.key -> Applicand.t option t\n val extend_new_tid : Tenv.key -> Canonical.Def.t t -> Applicand.t t\n val exec : 'a t -> 'a\n end = struct\n type 'a t = depth:int -> Tenv.t -> 'a\n\n let return x ~depth:_ _tenv = x\n\n let bind t f ~depth tenv =\n let x = t ~depth tenv in\n (f x) ~depth tenv\n ;;\n\n let look_env key ~depth:_ tenv =\n let result = Tenv.find tenv key in\n Option.map ~f:(fun (`Recursion_level x) -> Applicand.Recursion_level x) result\n ;;\n\n let extend_new_tid key def_t ~depth tenv =\n Applicand.Definition\n (let value = `Recursion_level depth in\n let tenv = Tenv.extend tenv key value in\n def_t ~depth:(depth + 1) tenv)\n ;;\n\n let exec t = t ~depth:0 Tenv.empty\n end\n\n type 'a defining = 'a Defining.t\n\n let ( >>= ) = Defining.bind\n let return = Defining.return\n\n let sequence_defining : 'a list -> f:('a -> 'b defining) -> 'b list defining =\n fun xs ~f ->\n let rec loop acc_ys = function\n | [] -> return (List.rev acc_ys)\n | x :: xs -> f x >>= fun y -> loop (y :: acc_ys) xs\n in\n loop [] xs\n ;;\n\n (*\n Shape evaluation.\n\n Shapes are evaluated to canonical-shape (expressions), with additional defs collected\n in the [defining] monad, which also manages generation/mapping to [Canonical.Tid.t]\n\n There is downwards context of [group] and [Venv.t]\n The (current) [group] changes when the case for [Top_app] calls [eval_app].\n\n The current [Venv.t] is abandoned when [eval_app] is called, and then re-created after\n the decision has been made to either inline the type-application, or make a reference\n to a type-definition, which is created at most once for each (Gid.t * Tid.t).\n\n We make a type-definition always for Records and Variants, and in addition for any\n other cyclic type-definition.\n *)\n\n let rec eval : group -> Venv.t -> t -> Visibility.visible Canonical.Exp1.t defining =\n fun group venv t ->\n match t with\n | Record binds ->\n sequence_defining binds ~f:(fun (s, x) ->\n eval group venv x >>= fun y -> return (s, y))\n >>= fun binds -> return (Canonical.Create.record binds)\n | Variant alts ->\n sequence_defining alts ~f:(fun (s, xs) ->\n eval_list group venv xs >>= fun ys -> return (s, ys))\n >>= fun alts -> return (Canonical.Create.variant alts)\n | Var (loc, vid) ->\n (match Venv.lookup venv vid with\n | Some x -> return x\n | None -> eval_fail loc !\"Free type variable: '%{Vid}\" vid ())\n | Annotate (s, t) ->\n eval group venv t >>= fun v -> return (Canonical.Create.annotate s v)\n | Base (s, ts) ->\n eval_list group venv ts >>= fun vs -> return (Canonical.Create.basetype s vs)\n | Tuple ts ->\n eval_list group venv ts >>= fun vs -> return (Canonical.Create.tuple vs)\n | Top_app (in_group, tid, args) ->\n eval_list group venv args\n >>= fun args ->\n (* args evaluated in current group *)\n eval_app in_group tid args\n (* group changed here *)\n | Rec_app (tid, args) ->\n eval_list group venv args >>= fun args -> eval_app group tid args\n | Poly_variant (loc, cs) ->\n sequence_defining ~f:(eval_poly_constr group venv) cs\n >>= fun xss -> return (Canonical.Create.poly_variant loc (List.concat xss))\n\n and eval_list : group -> Venv.t -> t list -> _ Canonical.Exp1.t list defining =\n fun group venv ts -> sequence_defining ts ~f:(eval group venv)\n\n and eval_poly_constr\n : group -> Venv.t -> t poly_constr\n -> (string * Visibility.opaque Canonical.Exp1.t option) list defining\n =\n fun group venv c ->\n match c with\n | `Constr (s, None) -> return [ s, None ]\n | `Constr (s, Some t) ->\n eval group venv t >>= fun v -> return [ s, Some (Canonical.Exp1.opaque v) ]\n | `Inherit (loc, t) ->\n eval group venv t\n >>= fun v ->\n (match Canonical.Exp1.get_poly_variant v with\n | Ok tab -> return (Sorted_table.expose tab)\n | Error desc ->\n eval_fail\n loc\n \"The shape for an inherited type is not described as a polymorphic-variant: %s\"\n desc\n ())\n\n and eval_definition : group -> Vid.t list -> t -> Canonical.Def.t defining =\n fun group formals body ->\n let venv = Venv.create (List.mapi formals ~f:(fun i x -> x, Canonical.Exp1.var i)) in\n eval group venv body >>= fun v -> return (Canonical.Create.define v)\n\n and eval_app : group -> Tid.t -> _ Canonical.Exp1.t list -> _ Canonical.Exp1.t defining\n =\n fun group tid args ->\n let gid = Group.id group in\n let formals, body = Group.lookup group tid in\n let record_or_normal_variant =\n match body with\n | Record _ | Variant _ -> true\n | Tuple _ | Annotate _ | Base _ | Poly_variant _ | Var _ | Rec_app _ | Top_app _ ->\n false\n in\n let cyclic = is_cyclic group tid in\n let cyclic_no_VR = is_cyclic_with_no_intervening_VR group tid in\n if (record_or_normal_variant && cyclic) || cyclic_no_VR\n then\n Defining.look_env (gid, tid)\n >>= (function\n | Some recurse -> return recurse\n | None ->\n Defining.extend_new_tid (gid, tid) (eval_definition group formals body))\n >>= function\n | Recursion_level r -> return (Canonical.Exp1.recurse r args)\n | Definition def -> return (Canonical.Exp1.apply def args)\n else (\n let venv =\n match List.zip formals args with\n | Ok x -> Venv.create x\n | Unequal_lengths -> failwith \"apply, incorrect type application arity\"\n in\n eval group venv body)\n ;;\n\n (* top level entry point for evaluation *)\n let eval : t -> Canonical.t =\n fun t ->\n let group = group (Location.of_string \"top-level\") [] in\n let venv = Venv.create [] in\n let v = Defining.exec (eval group venv t) in\n Canonical.Create.create v\n ;;\nend\n\nmodule Canonical = struct\n include Canonical_full\n\n module Exp = struct\n type t = Visibility.visible Exp1.t\n end\nend\n\ninclude Evaluation (Canonical_full)\nmodule Canonical_selected = Canonical_digest\nmodule Evaluation_to_digest = Evaluation (Canonical_selected)\n\nlet eval_to_digest exp = Canonical_selected.to_digest (Evaluation_to_digest.eval exp)\nlet eval_to_digest_string exp = Digest.to_hex (eval_to_digest exp)\n\nmodule For_typerep = struct\n exception Not_a_tuple of t [@@deriving sexp_of]\n\n let deconstruct_tuple_exn t =\n match t with\n | Tuple ts -> ts\n | _ -> raise (Not_a_tuple t)\n ;;\nend\n","open! Base\nopen! Import\n\ntype t = Caml.in_channel\n\nlet equal (t1 : t) t2 = phys_equal t1 t2\n\nlet seek = Caml.LargeFile.seek_in\nlet pos = Caml.LargeFile.pos_in\nlet length = Caml.LargeFile.in_channel_length\n\nlet stdin = Caml.stdin\n\nlet create ?(binary = true) file =\n let flags = [Open_rdonly] in\n let flags = if binary then Open_binary :: flags else flags in\n Caml.open_in_gen flags 0o000 file\n;;\n\nlet close = Caml.close_in\n\nlet with_file ?binary file ~f = Exn.protectx (create ?binary file) ~f ~finally:close\n\nlet may_eof f = try Some (f ()) with End_of_file -> None\n\nlet input t ~buf ~pos ~len = Caml.input t buf pos len\nlet really_input t ~buf ~pos ~len =\n may_eof (fun () -> Caml.really_input t buf pos len)\nlet really_input_exn t ~buf ~pos ~len =\n Caml.really_input t buf pos len\nlet input_byte t = may_eof (fun () -> Caml.input_byte t)\nlet input_char t = may_eof (fun () -> Caml.input_char t)\nlet input_binary_int t = may_eof (fun () -> Caml.input_binary_int t)\nlet unsafe_input_value t = may_eof (fun () -> Caml.input_value t)\nlet input_buffer t buf ~len = may_eof (fun () -> Caml.Buffer.add_channel buf t len)\n\nlet set_binary_mode = Caml.set_binary_mode_in\n\nlet input_all t =\n (* We use 65536 because that is the size of OCaml's IO buffers. *)\n let chunk_size = 65536 in\n let buffer = Buffer.create chunk_size in\n let rec loop () =\n Caml.Buffer.add_channel buffer t chunk_size;\n loop ()\n in\n try loop () with\n | End_of_file -> Buffer.contents buffer\n;;\n\nlet trim ~fix_win_eol line =\n if fix_win_eol then begin\n let len = String.length line in\n if len > 0\n && Char.equal (String.get line (len - 1)) '\\r'\n then String.sub line ~pos:0 ~len:(len - 1)\n else line\n end\n else line\n\nlet input_line ?(fix_win_eol = true) t =\n match may_eof (fun () -> Caml.input_line t) with\n | None -> None\n | Some line -> Some (trim ~fix_win_eol line)\n;;\n\nlet input_line_exn ?(fix_win_eol = true) t =\n let line = Caml.input_line t in\n trim ~fix_win_eol line\n\nlet fold_lines ?fix_win_eol t ~init ~f =\n let rec loop ac =\n match input_line ?fix_win_eol t with\n | None -> ac\n | Some line -> loop (f ac line)\n in\n loop init\n;;\n\nlet input_lines ?fix_win_eol t =\n List.rev\n (fold_lines ?fix_win_eol t ~init:[] ~f:(fun lines line -> line :: lines))\n;;\n\nlet iter_lines ?fix_win_eol t ~f =\n fold_lines ?fix_win_eol t ~init:() ~f:(fun () line -> f line)\n;;\n\nlet read_lines ?fix_win_eol fname = with_file fname ~f:(input_lines ?fix_win_eol)\n\nlet read_all fname = with_file fname ~f:input_all\n","open! Base\nopen! Import\n\ntype t = Caml.out_channel\n\nlet equal (t1 : t) t2 = phys_equal t1 t2\n\nlet seek = Caml.LargeFile.seek_out\nlet pos = Caml.LargeFile.pos_out\nlet length = Caml.LargeFile.out_channel_length\n\nlet stdout = Caml.stdout\nlet stderr = Caml.stderr\n\nlet sexp_of_t t =\n if phys_equal t stderr\n then Sexp.Atom \"\"\n else if phys_equal t stdout\n then Sexp.Atom \"\"\n else Sexp.Atom \"\"\n;;\n\ntype 'a with_create_args =\n ?binary:bool\n -> ?append:bool\n -> ?fail_if_exists:bool\n -> ?perm:int\n -> 'a\n\nlet create ?(binary = true) ?(append = false) ?(fail_if_exists = false) ?(perm = 0o666) file =\n let flags = [Open_wronly; Open_creat] in\n let flags = (if binary then Open_binary else Open_text) :: flags in\n let flags = (if append then Open_append else Open_trunc) :: flags in\n let flags = (if fail_if_exists then Open_excl :: flags else flags) in\n Caml.open_out_gen flags perm file\n;;\n\nlet set_binary_mode = Caml.set_binary_mode_out\n\nlet flush = Caml.flush\n\nlet close = Caml.close_out\nlet close_no_err = Caml.close_out_noerr\n\nlet output t ~buf ~pos ~len = Caml.output t buf pos len\nlet output_substring t ~buf ~pos ~len = Caml.output_substring t buf pos len\nlet output_string = Caml.output_string\nlet output_bytes = Caml.output_bytes\nlet output_char = Caml.output_char\nlet output_byte = Caml.output_byte\nlet output_binary_int = Caml.output_binary_int\nlet output_buffer = Caml.Buffer.output_buffer\nlet output_value = Caml.output_value\n\nlet newline t = output_string t \"\\n\"\n\nlet output_lines t lines =\n List.iter lines ~f:(fun line -> output_string t line; newline t)\n;;\n\nlet printf = Caml.Printf.printf\nlet eprintf = Caml.Printf.eprintf\nlet fprintf = Caml.Printf.fprintf\nlet kfprintf = Caml.Printf.kfprintf\n\nlet print_string = Caml.print_string\nlet print_endline = Caml.print_endline\nlet prerr_endline = Caml.prerr_endline\n\nlet print_s ?mach sexp =\n print_endline\n (match mach with\n | Some () -> Sexp.to_string_mach sexp\n | None -> Sexp.to_string_hum sexp)\n;;\n\nlet eprint_s ?mach sexp =\n prerr_endline\n (match mach with\n | Some () -> Sexp.to_string_mach sexp\n | None -> Sexp.to_string_hum sexp)\n;;\n\n\nlet with_file ?binary ?append ?fail_if_exists ?perm file ~f =\n Exn.protectx (create ?binary ?append ?fail_if_exists ?perm file) ~f ~finally:close\n;;\n\nlet write_lines file lines = with_file file ~f:(fun t -> output_lines t lines)\n\nlet write_all file ~data = with_file file ~f:(fun t -> output_string t data)\n","open! Base\nmodule Gc = Caml.Gc\n\nexternal __MODULE__ : string = \"%loc_MODULE\"\n\nlet am_recording_environment_variable = \"PPX_MODULE_TIMER\"\n\nlet get_am_recording_environment_variable () =\n (* avoid Caml.Sys.getenv_opt to preserve 4.04.x compatibility *)\n match Caml.Sys.getenv am_recording_environment_variable with\n | value -> Some value\n | exception _ -> None\n;;\n\nlet am_recording_value = get_am_recording_environment_variable ()\nlet am_recording = Option.is_some am_recording_value\n\nmodule Duration = struct\n type t = Int63.t\n\n let to_nanoseconds t = t\n let of_nanoseconds t = t\n\n module type Format = sig\n val of_string : string -> t\n val to_string_with_same_unit : t list -> string list\n end\n\n module Default_format = struct\n let of_string string = String.chop_suffix_exn string ~suffix:\"ns\" |> Int63.of_string\n let to_string nanos = Int63.to_string nanos ^ \"ns\"\n let to_string_with_same_unit list = List.map list ~f:to_string\n end\n\n let format = ref (module Default_format : Format)\n\n let of_string string =\n let (module Format) = !format in\n Format.of_string string\n ;;\n\n let to_string_with_same_unit string =\n let (module Format) = !format in\n Format.to_string_with_same_unit string\n ;;\nend\n\nmodule Gc_events = struct\n type t =\n { minor_collections : int\n ; major_collections : int\n ; compactions : int\n }\nend\n\nmodule Timing_event = struct\n type t =\n { description : string\n ; runtime : Duration.t\n ; gc_events : Gc_events.t\n ; nested_timing_events : t list\n }\nend\n\nmodule Timer = struct\n type t =\n { mutable currently_running_description : string\n ; mutable currently_running_start_time : Duration.t\n ; mutable currently_running_gc_stats : Gc.stat\n ; mutable nested_timer : t option\n ; mutable timing_events_in_reverse_chronological_order : Timing_event.t list\n }\n\n let create ?nested_timer () =\n { currently_running_description = \"\"\n ; currently_running_start_time = Int63.zero\n ; currently_running_gc_stats = Gc.quick_stat ()\n ; nested_timer\n ; timing_events_in_reverse_chronological_order = []\n }\n ;;\n\n let reset t =\n t.currently_running_description <- \"\";\n t.currently_running_start_time <- Int63.zero;\n match t.nested_timer with\n | None -> ()\n | Some nested -> nested.timing_events_in_reverse_chronological_order <- []\n ;;\n\n let record_start t description =\n if am_recording\n then (\n assert (String.is_empty t.currently_running_description);\n t.currently_running_description <- description;\n t.currently_running_gc_stats <- Gc.quick_stat ();\n (* call [Time_now] as late as possible before running the module body *)\n t.currently_running_start_time <- Time_now.nanoseconds_since_unix_epoch ())\n ;;\n\n let record_until t description =\n if am_recording\n then (\n (* compute [Time_now] as soon as possible after running the module body *)\n let until = Time_now.nanoseconds_since_unix_epoch () in\n let start = t.currently_running_start_time in\n let gc_stats_after = Gc.quick_stat () in\n let gc_stats_before = t.currently_running_gc_stats in\n let runtime = Int63.( - ) until start in\n assert (String.equal t.currently_running_description description);\n let gc_events : Gc_events.t =\n { minor_collections =\n gc_stats_after.minor_collections - gc_stats_before.minor_collections\n ; major_collections =\n gc_stats_after.major_collections - gc_stats_before.major_collections\n ; compactions = gc_stats_after.compactions - gc_stats_before.compactions\n }\n in\n let nested_timing_events =\n match t.nested_timer with\n | None -> []\n | Some nested -> List.rev nested.timing_events_in_reverse_chronological_order\n in\n let timing_event : Timing_event.t =\n { description; runtime; gc_events; nested_timing_events }\n in\n t.timing_events_in_reverse_chronological_order\n <- timing_event :: t.timing_events_in_reverse_chronological_order;\n reset t)\n ;;\nend\n\nlet definition_timer = Timer.create ()\nlet module_timer = Timer.create ~nested_timer:definition_timer ()\nlet record_start module_name = Timer.record_start module_timer module_name\nlet record_until module_name = Timer.record_until module_timer module_name\nlet record_definition_start loc = Timer.record_start definition_timer loc\nlet record_definition_until loc = Timer.record_until definition_timer loc\n\nlet gc_events_suffix_string\n ({ minor_collections; major_collections; compactions } : Gc_events.t)\n =\n let to_list description count =\n if count = 0 then [] else [ Int.to_string count ^ \" \" ^ description ]\n in\n let strings =\n to_list \"minor collections\" minor_collections\n @ to_list \"major collections\" major_collections\n @ to_list \"compactions\" compactions\n in\n if List.is_empty strings then \"\" else \"; GC: \" ^ String.concat strings ~sep:\", \"\n;;\n\nlet with_left_column_right_justified list =\n let left_column_width =\n List.fold list ~init:0 ~f:(fun width (left, _) -> Int.max width (String.length left))\n in\n List.map list ~f:(fun (left, right) ->\n Printf.sprintf \"%*s %s\" left_column_width left right)\n;;\n\nlet rec timing_events_to_strings list ~indent =\n let duration_strings =\n List.map list ~f:(fun (timing_event : Timing_event.t) -> timing_event.runtime)\n |> Duration.to_string_with_same_unit\n in\n let prefix = String.make indent ' ' in\n List.map2_exn\n duration_strings\n list\n ~f:(fun duration_string\n { runtime = _; description; gc_events; nested_timing_events }\n ->\n ( duration_string\n , description\n ^ gc_events_suffix_string gc_events\n ^ String.concat\n (List.map\n (timing_events_to_strings nested_timing_events ~indent:(indent + 4))\n ~f:(fun line -> \"\\n\" ^ line)) ))\n |> with_left_column_right_justified\n |> List.map ~f:(fun line -> prefix ^ line)\n;;\n\nlet fake_timing_events =\n let gc_events i : Gc_events.t =\n { minor_collections = (if i % 2 = 1 then 1 else 0)\n ; major_collections = (if i % 4 = 3 then 1 else 0)\n ; compactions = (if i % 8 = 7 then 1 else 0)\n }\n in\n lazy\n (List.init 12 ~f:(fun i ->\n ({ description = Printf.sprintf \"Fake__Dependency_%d\" (i + 1)\n ; runtime = Int63.of_int (900 * (i + 1))\n ; gc_events = gc_events i\n ; nested_timing_events =\n (if (i + 1) % 4 = 0\n then\n List.init (i + 1) ~f:(fun j ->\n ({ description = Printf.sprintf \"Line %d\" (j + 1)\n ; runtime = Int63.of_int (900 * (j + 1))\n ; gc_events = gc_events j\n ; nested_timing_events = []\n }\n : Timing_event.t))\n else [])\n }\n : Timing_event.t)))\n;;\n\nlet print_recorded_timing_events timing_events =\n let notify_of_overriding () =\n Stdio.print_endline \"ppx_module_timer: overriding time measurements for testing\"\n in\n let timing_events =\n match Option.value_exn am_recording_value with\n | \"FAKE_MODULES\" ->\n notify_of_overriding ();\n force fake_timing_events\n | string ->\n (match Duration.of_string string with\n | override ->\n notify_of_overriding ();\n List.mapi timing_events ~f:(fun index (timing_event : Timing_event.t) ->\n let runtime = Int63.( * ) override (Int63.of_int (index + 1)) in\n let nested_timing_events =\n List.mapi\n timing_event.nested_timing_events\n ~f:(fun index nested_timing_event ->\n let runtime = Int63.( * ) override (Int63.of_int (index + 1)) in\n { nested_timing_event with runtime })\n in\n { timing_event with runtime; nested_timing_events })\n | exception _ -> timing_events)\n in\n timing_events |> timing_events_to_strings ~indent:0 |> List.iter ~f:Stdio.print_endline\n;;\n\nlet () =\n if am_recording\n then\n Caml.at_exit (fun () ->\n print_recorded_timing_events\n (List.rev module_timer.timing_events_in_reverse_chronological_order))\n;;\n","module Name_of = struct\n let typename_of_int =\n let module M = Typename.Make0(struct type t = int let name = \"int\" end) in\n M.typename_of_t\n\n let typename_of_int32 =\n let module M = Typename.Make0(struct type t = int32 let name = \"int32\" end) in\n M.typename_of_t\n\n let typename_of_int64 =\n let module M = Typename.Make0(struct type t = int64 let name = \"int64\" end) in\n M.typename_of_t\n\n let typename_of_nativeint =\n let module M = Typename.Make0(struct\n type t = nativeint\n let name = \"nativeint\"\n end) in\n M.typename_of_t\n\n let typename_of_char =\n let module M = Typename.Make0(struct type t = char let name = \"char\" end) in\n M.typename_of_t\n\n let typename_of_float =\n let module M = Typename.Make0(struct type t = float let name = \"float\" end) in\n M.typename_of_t\n\n let typename_of_string =\n let module M = Typename.Make0(struct type t = string let name = \"string\" end) in\n M.typename_of_t\n\n let typename_of_bytes =\n let module M = Typename.Make0(struct type t = bytes let name = \"bytes\" end) in\n M.typename_of_t\n\n let typename_of_bool =\n let module M = Typename.Make0(struct type t = bool let name = \"bool\" end) in\n M.typename_of_t\n\n let typename_of_unit =\n let module M = Typename.Make0(struct type t = unit let name = \"unit\" end) in\n M.typename_of_t\n\n module M_option = Typename.Make1(struct type 'a t = 'a option let name = \"option\" end)\n let typename_of_option = M_option.typename_of_t\n\n module M_list = Typename.Make1(struct type 'a t = 'a list let name = \"list\" end)\n let typename_of_list = M_list.typename_of_t\n\n module M_array = Typename.Make1(struct type 'a t = 'a array let name = \"array\" end)\n let typename_of_array = M_array.typename_of_t\n\n module M_lazy_t = Typename.Make1(struct type 'a t = 'a lazy_t let name = \"lazy_t\" end)\n let typename_of_lazy_t = M_lazy_t.typename_of_t\n\n module M_ref = Typename.Make1(struct type 'a t = 'a ref let name = \"ref\" end)\n let typename_of_ref = M_ref.typename_of_t\n\n module M_function = Typename.Make2(struct\n type ('a, 'b) t = 'a -> 'b\n let name = \"function\"\n end)\n let typename_of_function = M_function.typename_of_t\n\n type tuple0 = unit\n module M_tuple0 = Typename.Make0(struct type t = tuple0 let name = \"tuple0\" end)\n let typename_of_tuple0 = M_tuple0.typename_of_t\n\n module M_tuple2 = Typename.Make2(struct\n type ('a, 'b) t = 'a * 'b\n let name = \"tuple2\"\n end)\n let typename_of_tuple2 = M_tuple2.typename_of_t\n\n module M_tuple3 = Typename.Make3(struct\n type ('a, 'b, 'c) t = 'a * 'b * 'c\n let name = \"tuple3\"\n end)\n let typename_of_tuple3 = M_tuple3.typename_of_t\n\n module M_tuple4 = Typename.Make4(struct\n type ('a, 'b, 'c, 'd) t = 'a * 'b * 'c * 'd\n let name = \"tuple4\"\n end)\n let typename_of_tuple4 = M_tuple4.typename_of_t\n\n module M_tuple5 = Typename.Make5(struct\n type ('a, 'b, 'c, 'd, 'e) t = 'a * 'b * 'c *'d * 'e\n let name = \"tuple5\"\n end)\n let typename_of_tuple5 = M_tuple5.typename_of_t\nend\n\nmodule rec Typerep : sig\n\n type _ t =\n | Int : int t\n | Int32 : int32 t\n | Int64 : int64 t\n | Nativeint : nativeint t\n | Char : char t\n | Float : float t\n | String : string t\n | Bytes : bytes t\n | Bool : bool t\n | Unit : unit t\n | Option : 'a t -> 'a option t\n | List : 'a t -> 'a list t\n | Array : 'a t -> 'a array t\n | Lazy : 'a t -> 'a lazy_t t\n | Ref : 'a t -> 'a ref t\n | Function : ('dom t * 'rng t) -> ('dom -> 'rng) t\n | Tuple : 'a Typerep.Tuple.t -> 'a t\n | Record : 'a Typerep.Record.t -> 'a t\n | Variant : 'a Typerep.Variant.t -> 'a t\n | Named : ('a Typerep.Named.t * 'a t lazy_t option) -> 'a t\n\n type packed = T : 'a t -> packed\n\n module Named : sig\n module type T0 = sig\n type named\n type t\n val typename_of_named : named Typename.t\n val typename_of_t : t Typename.t\n val witness : (t, named) Type_equal.t\n end\n module type T1 = sig\n type 'a named\n type a val a : a Typerep.t\n type t\n val typename_of_named : 'a Typename.t -> 'a named Typename.t\n val typename_of_t : t Typename.t\n val witness : (t, a named) Type_equal.t\n end\n module type T2 = sig\n type ('a, 'b) named\n type a val a : a Typerep.t\n type b val b : b Typerep.t\n type t\n val typename_of_named :\n 'a Typename.t\n -> 'b Typename.t\n -> ('a, 'b) named Typename.t\n val typename_of_t : t Typename.t\n val witness : (t, (a, b) named) Type_equal.t\n end\n module type T3 = sig\n type ('a, 'b, 'c) named\n type a val a : a Typerep.t\n type b val b : b Typerep.t\n type c val c : c Typerep.t\n type t\n val typename_of_named :\n 'a Typename.t\n -> 'b Typename.t\n -> 'c Typename.t\n -> ('a, 'b, 'c) named Typename.t\n val typename_of_t : t Typename.t\n val witness : (t, (a, b, c) named) Type_equal.t\n end\n module type T4 = sig\n type ('a, 'b, 'c, 'd) named\n type a val a : a Typerep.t\n type b val b : b Typerep.t\n type c val c : c Typerep.t\n type d val d : d Typerep.t\n type t\n val typename_of_named :\n 'a Typename.t\n -> 'b Typename.t\n -> 'c Typename.t\n -> 'd Typename.t\n -> ('a, 'b, 'c, 'd) named Typename.t\n val typename_of_t : t Typename.t\n val witness : (t, (a, b, c, d) named) Type_equal.t\n end\n module type T5 = sig\n type ('a, 'b, 'c, 'd, 'e) named\n type a val a : a Typerep.t\n type b val b : b Typerep.t\n type c val c : c Typerep.t\n type d val d : d Typerep.t\n type e val e : e Typerep.t\n type t\n val typename_of_named :\n 'a Typename.t\n -> 'b Typename.t\n -> 'c Typename.t\n -> 'd Typename.t\n -> 'e Typename.t\n -> ('a, 'b, 'c, 'd, 'e) named Typename.t\n val typename_of_t : t Typename.t\n val witness : (t, (a, b, c, d, e) named) Type_equal.t\n end\n (* there the module is necessary because we need to deal with a type [t] with\n parameters whose kind is not representable as a type variable: ['a 't], even with\n a gadt. *)\n type 'a t =\n | T0 of (module T0 with type t = 'a)\n | T1 of (module T1 with type t = 'a)\n | T2 of (module T2 with type t = 'a)\n | T3 of (module T3 with type t = 'a)\n | T4 of (module T4 with type t = 'a)\n | T5 of (module T5 with type t = 'a)\n\n val arity : _ t -> int\n val typename_of_t : 'a t -> 'a Typename.t\n val name : _ t -> string\n end\n\n module Tuple : sig\n (* these constructors could be plunged at toplevel of Typerep.t, however it is less\n verbose that way *)\n type _ t =\n | T2 : ('a Typerep.t * 'b Typerep.t)\n -> ('a * 'b) t\n | T3 : ('a Typerep.t * 'b Typerep.t * 'c Typerep.t)\n -> ('a * 'b * 'c) t\n | T4 : ('a Typerep.t * 'b Typerep.t * 'c Typerep.t * 'd Typerep.t)\n -> ('a * 'b * 'c * 'd) t\n | T5 : ('a Typerep.t * 'b Typerep.t * 'c Typerep.t * 'd Typerep.t * 'e Typerep.t)\n -> ('a * 'b * 'c * 'd * 'e) t\n\n val arity : _ t -> int\n val typename_of_t : 'a t -> 'a Typename.t\n end\n\n include Variant_and_record_intf.S with type 'a t := 'a Typerep.t\n\n val same : _ t -> _ t -> bool\n val same_witness : 'a t -> 'b t -> ('a, 'b) Type_equal.t option\n val same_witness_exn : 'a t -> 'b t -> ('a, 'b) Type_equal.t\n val typename_of_t : 'a t -> 'a Typename.t\n val head : 'a t -> 'a t\nend = struct\n\n type _ t =\n | Int : int t\n | Int32 : int32 t\n | Int64 : int64 t\n | Nativeint : nativeint t\n | Char : char t\n | Float : float t\n | String : string t\n | Bytes : bytes t\n | Bool : bool t\n | Unit : unit t\n | Option : 'a t -> 'a option t\n | List : 'a t -> 'a list t\n | Array : 'a t -> 'a array t\n | Lazy : 'a t -> 'a lazy_t t\n | Ref : 'a t -> 'a ref t\n | Function : ('dom t * 'rng t) -> ('dom -> 'rng) t\n | Tuple : 'a Typerep.Tuple.t -> 'a t\n | Record : 'a Typerep.Record.t -> 'a t\n | Variant : 'a Typerep.Variant.t -> 'a t\n | Named : ('a Typerep.Named.t * 'a t lazy_t option) -> 'a t\n\n type packed = T : 'a t -> packed\n\n module Named = struct\n module type T0 = sig\n type named\n type t\n val typename_of_named : named Typename.t\n val typename_of_t : t Typename.t\n val witness : (t, named) Type_equal.t\n end\n module type T1 = sig\n type 'a named\n type a val a : a Typerep.t\n type t\n val typename_of_named : 'a Typename.t -> 'a named Typename.t\n val typename_of_t : t Typename.t\n val witness : (t, a named) Type_equal.t\n end\n module type T2 = sig\n type ('a, 'b) named\n type a val a : a Typerep.t\n type b val b : b Typerep.t\n type t\n val typename_of_named :\n 'a Typename.t\n -> 'b Typename.t\n -> ('a, 'b) named Typename.t\n val typename_of_t : t Typename.t\n val witness : (t, (a, b) named) Type_equal.t\n end\n module type T3 = sig\n type ('a, 'b, 'c) named\n type a val a : a Typerep.t\n type b val b : b Typerep.t\n type c val c : c Typerep.t\n type t\n val typename_of_named :\n 'a Typename.t\n -> 'b Typename.t\n -> 'c Typename.t\n -> ('a, 'b, 'c) named Typename.t\n val typename_of_t : t Typename.t\n val witness : (t, (a, b, c) named) Type_equal.t\n end\n module type T4 = sig\n type ('a, 'b, 'c, 'd) named\n type a val a : a Typerep.t\n type b val b : b Typerep.t\n type c val c : c Typerep.t\n type d val d : d Typerep.t\n type t\n val typename_of_named :\n 'a Typename.t\n -> 'b Typename.t\n -> 'c Typename.t\n -> 'd Typename.t\n -> ('a, 'b, 'c, 'd) named Typename.t\n val typename_of_t : t Typename.t\n val witness : (t, (a, b, c, d) named) Type_equal.t\n end\n module type T5 = sig\n type ('a, 'b, 'c, 'd, 'e) named\n type a val a : a Typerep.t\n type b val b : b Typerep.t\n type c val c : c Typerep.t\n type d val d : d Typerep.t\n type e val e : e Typerep.t\n type t\n val typename_of_named :\n 'a Typename.t\n -> 'b Typename.t\n -> 'c Typename.t\n -> 'd Typename.t\n -> 'e Typename.t\n -> ('a, 'b, 'c, 'd, 'e) named Typename.t\n val typename_of_t : t Typename.t\n val witness : (t, (a, b, c, d, e) named) Type_equal.t\n end\n (* there the module is necessary because we need to deal with a type [t] with\n parameters whose kind is not representable as a type variable: ['a 't], even with\n a gadt. *)\n type 'a t =\n | T0 of (module T0 with type t = 'a)\n | T1 of (module T1 with type t = 'a)\n | T2 of (module T2 with type t = 'a)\n | T3 of (module T3 with type t = 'a)\n | T4 of (module T4 with type t = 'a)\n | T5 of (module T5 with type t = 'a)\n\n let arity = function\n | T0 _ -> 0\n | T1 _ -> 1\n | T2 _ -> 2\n | T3 _ -> 3\n | T4 _ -> 4\n | T5 _ -> 5\n\n let typename_of_t (type a) = function\n | T0 rep ->\n let module T = (val rep : T0 with type t = a) in\n T.typename_of_t\n | T1 rep ->\n let module T = (val rep : T1 with type t = a) in\n T.typename_of_t\n | T2 rep ->\n let module T = (val rep : T2 with type t = a) in\n T.typename_of_t\n | T3 rep ->\n let module T = (val rep : T3 with type t = a) in\n T.typename_of_t\n | T4 rep ->\n let module T = (val rep : T4 with type t = a) in\n T.typename_of_t\n | T5 rep ->\n let module T = (val rep : T5 with type t = a) in\n T.typename_of_t\n\n let name rep =\n Typename.Uid.name (Typename.uid (typename_of_t rep))\n end\n\n module Tuple = struct\n (* these constructors could be plunged at toplevel of Typerep.t, however it is less\n verbose this way *)\n type _ t =\n | T2 : ('a Typerep.t * 'b Typerep.t)\n -> ('a * 'b) t\n | T3 : ('a Typerep.t * 'b Typerep.t * 'c Typerep.t)\n -> ('a * 'b * 'c) t\n | T4 : ('a Typerep.t * 'b Typerep.t * 'c Typerep.t * 'd Typerep.t)\n -> ('a * 'b * 'c * 'd) t\n | T5 : ('a Typerep.t * 'b Typerep.t * 'c Typerep.t * 'd Typerep.t * 'e Typerep.t)\n -> ('a * 'b * 'c * 'd * 'e) t\n\n let arity : type a. a t -> int = function\n | Typerep.Tuple.T2 _ -> 2\n | Typerep.Tuple.T3 _ -> 3\n | Typerep.Tuple.T4 _ -> 4\n | Typerep.Tuple.T5 _ -> 5\n\n let typename_of_t : type a. a t -> a Typename.t = function\n | T2 (a, b) ->\n Name_of.typename_of_tuple2\n (Typerep.typename_of_t a)\n (Typerep.typename_of_t b)\n | T3 (a, b, c) ->\n Name_of.typename_of_tuple3\n (Typerep.typename_of_t a)\n (Typerep.typename_of_t b)\n (Typerep.typename_of_t c)\n | T4 (a, b, c, d) ->\n Name_of.typename_of_tuple4\n (Typerep.typename_of_t a)\n (Typerep.typename_of_t b)\n (Typerep.typename_of_t c)\n (Typerep.typename_of_t d)\n | T5 (a, b, c, d, e) ->\n Name_of.typename_of_tuple5\n (Typerep.typename_of_t a)\n (Typerep.typename_of_t b)\n (Typerep.typename_of_t c)\n (Typerep.typename_of_t d)\n (Typerep.typename_of_t e)\n end\n\n include Variant_and_record_intf.M (struct type 'a rep = 'a t type 'a t = 'a rep end)\n\n let rec typename_of_t : type a. a t -> a Typename.t = function\n | Int -> Name_of.typename_of_int\n | Int32 -> Name_of.typename_of_int32\n | Int64 -> Name_of.typename_of_int64\n | Nativeint -> Name_of.typename_of_nativeint\n | Char -> Name_of.typename_of_char\n | Float -> Name_of.typename_of_float\n | String -> Name_of.typename_of_string\n | Bytes -> Name_of.typename_of_bytes\n | Bool -> Name_of.typename_of_bool\n | Unit -> Name_of.typename_of_unit\n\n | Option rep -> Name_of.typename_of_option (typename_of_t rep)\n | List rep -> Name_of.typename_of_list (typename_of_t rep)\n | Array rep -> Name_of.typename_of_array (typename_of_t rep)\n | Lazy rep -> Name_of.typename_of_lazy_t (typename_of_t rep)\n | Ref rep -> Name_of.typename_of_ref (typename_of_t rep)\n\n | Function (dom, rng) ->\n Name_of.typename_of_function (typename_of_t dom) (typename_of_t rng)\n\n | Tuple rep -> Typerep.Tuple.typename_of_t rep\n\n | Record rep -> Typerep.Record.typename_of_t rep\n | Variant rep -> Typerep.Variant.typename_of_t rep\n\n | Named (name, _) -> Named.typename_of_t name\n ;;\n\n let rec same_witness : type a b. a t -> b t -> (a, b) Type_equal.t option = fun t1 t2 ->\n let module E = Type_equal in\n match t1, t2 with\n | Named (name1, r1), Named (name2, r2) -> begin\n match Typename.same_witness\n (Named.typename_of_t name1)\n (Named.typename_of_t name2) with\n | Some E.T as x -> x\n | None ->\n match r1, r2 with\n | Some (lazy t1), Some (lazy t2) -> same_witness t1 t2\n | Some (lazy t1), None -> same_witness t1 t2\n | None, Some (lazy t2) -> same_witness t1 t2\n | None, None -> None\n end\n | Named (_, r1), t2 -> begin\n match r1 with\n | Some (lazy t1) -> same_witness t1 t2\n | None -> None\n end\n | t1, Named (_, r2) -> begin\n match r2 with\n | Some (lazy t2) -> same_witness t1 t2\n | None -> None\n end\n | Int , Int -> Some E.T\n | Int32 , Int32 -> Some E.T\n | Int64 , Int64 -> Some E.T\n | Nativeint , Nativeint -> Some E.T\n | Char , Char -> Some E.T\n | Float , Float -> Some E.T\n | String , String -> Some E.T\n | Bytes , Bytes -> Some E.T\n | Bool , Bool -> Some E.T\n | Unit , Unit -> Some E.T\n | Option r1, Option r2 -> begin\n match same_witness r1 r2 with\n | None as x -> x\n | Some E.T as x -> x\n end\n | List r1, List r2 -> begin\n match same_witness r1 r2 with\n | None as x -> x\n | Some E.T as x -> x\n end\n | Array r1, Array r2 -> begin\n match same_witness r1 r2 with\n | None as x -> x\n | Some E.T as x -> x\n end\n | Lazy r1, Lazy r2 -> begin\n match same_witness r1 r2 with\n | None as x -> x\n | Some E.T as x -> x\n end\n | Ref r1, Ref r2 -> begin\n match same_witness r1 r2 with\n | None as x -> x\n | Some E.T as x -> x\n end\n | Function (dom1, rng1), Function (dom2, rng2) -> begin\n match same_witness dom1 dom2, same_witness rng1 rng2 with\n | Some E.T, Some E.T -> Some E.T\n | None, _ | _, None -> None\n end\n | Tuple t1, Tuple t2 -> begin\n let module T = Typerep.Tuple in\n match t1, t2 with\n | T.T2 (a1, b1), T.T2 (a2, b2) -> begin\n match same_witness a1 a2, same_witness b1 b2 with\n | Some E.T, Some E.T -> Some E.T\n | None, _ | _, None -> None\n end\n | T.T3 (a1, b1, c1), T.T3 (a2, b2, c2) -> begin\n match\n same_witness a1 a2,\n same_witness b1 b2,\n same_witness c1 c2\n with\n | Some E.T, Some E.T, Some E.T -> Some E.T\n | None, _, _\n | _, None, _\n | _, _, None\n -> None\n end\n | T.T4 (a1, b1, c1, d1), T.T4 (a2, b2, c2, d2) -> begin\n match\n same_witness a1 a2,\n same_witness b1 b2,\n same_witness c1 c2,\n same_witness d1 d2\n with\n | Some E.T, Some E.T, Some E.T, Some E.T -> Some E.T\n | None, _, _, _\n | _, None, _, _\n | _, _, None, _\n | _, _, _, None\n -> None\n end\n | T.T5 (a1, b1, c1, d1, e1), T.T5 (a2, b2, c2, d2, e2) -> begin\n match\n same_witness a1 a2,\n same_witness b1 b2,\n same_witness c1 c2,\n same_witness d1 d2,\n same_witness e1 e2\n with\n | Some E.T, Some E.T, Some E.T, Some E.T, Some E.T -> Some E.T\n | None, _, _, _, _\n | _, None, _, _, _\n | _, _, None, _, _\n | _, _, _, None, _\n | _, _, _, _, None\n -> None\n end\n | T.T2 _, _ -> None\n | T.T3 _, _ -> None\n | T.T4 _, _ -> None\n | T.T5 _, _ -> None\n end\n | Record r1, Record r2 ->\n Typename.same_witness\n (Typerep.Record.typename_of_t r1)\n (Typerep.Record.typename_of_t r2)\n | Variant r1, Variant r2 ->\n Typename.same_witness\n (Typerep.Variant.typename_of_t r1)\n (Typerep.Variant.typename_of_t r2)\n | Int, _ -> None\n | Int32, _ -> None\n | Int64, _ -> None\n | Nativeint, _ -> None\n | Char, _ -> None\n | Float, _ -> None\n | String, _ -> None\n | Bytes, _ -> None\n | Bool, _ -> None\n | Unit, _ -> None\n | Option _, _ -> None\n | List _, _ -> None\n | Array _, _ -> None\n | Lazy _, _ -> None\n | Ref _, _ -> None\n | Function _, _ -> None\n | Tuple _, _ -> None\n | Record _, _ -> None\n | Variant _, _ -> None\n ;;\n\n let same a b = same_witness a b <> None\n let same_witness_exn a b =\n match same_witness a b with\n | Some proof -> proof\n | None -> assert false\n\n let rec head = function\n | Typerep.Named (_, Some (lazy t)) -> head t\n | t -> t\nend\n\nlet typerep_of_int = Typerep.Int\nlet typerep_of_int32 = Typerep.Int32\nlet typerep_of_int64 = Typerep.Int64\nlet typerep_of_nativeint = Typerep.Nativeint\nlet typerep_of_char = Typerep.Char\nlet typerep_of_float = Typerep.Float\nlet typerep_of_string = Typerep.String\nlet typerep_of_bytes = Typerep.Bytes\nlet typerep_of_bool = Typerep.Bool\nlet typerep_of_unit = Typerep.Unit\n\nlet typerep_of_option rep = Typerep.Option rep\nlet typerep_of_list rep = Typerep.List rep\nlet typerep_of_array rep = Typerep.Array rep\nlet typerep_of_lazy_t rep = Typerep.Lazy rep\nlet typerep_of_ref rep = Typerep.Ref rep\n\nlet typerep_of_function dom rng = Typerep.Function (dom, rng)\n\nlet typerep_of_tuple0 = Typerep.Unit\nlet typerep_of_tuple2 a b = Typerep.Tuple (Typerep.Tuple.T2 (a, b))\nlet typerep_of_tuple3 a b c = Typerep.Tuple (Typerep.Tuple.T3 (a, b, c))\nlet typerep_of_tuple4 a b c d = Typerep.Tuple (Typerep.Tuple.T4 (a, b, c, d))\nlet typerep_of_tuple5 a b c d e = Typerep.Tuple (Typerep.Tuple.T5 (a, b, c, d, e))\n\ninclude Name_of\nlet value_tuple0 = ()\n\nlet typerep_of_int63, typename_of_int63 =\n let typerep_and_typename_of_int63_repr\n : type a b . (a, b) Base.Int63.Private.Repr.t -> a Typerep.t * a Typename.t\n = function\n | Base.Int63.Private.Repr.Int -> typerep_of_int, typename_of_int\n | Base.Int63.Private.Repr.Int64 -> typerep_of_int64, typename_of_int64\n in\n typerep_and_typename_of_int63_repr Base.Int63.Private.repr\n","let __ocaml_lex_tables = {\n Lexing.lex_base =\n \"\\000\\000\\000\\000\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\005\\000\\000\\000\\000\\000\\001\\000\\255\\255\\002\\000\\000\\000\\000\\000\\\n \\001\\000\\000\\000\\002\\000\\001\\000\\003\\000\\000\\000\\003\\000\\003\\000\\\n \\000\\000\\001\\000\\009\\000\\005\\000\\002\\000\\004\\000\\017\\000\\012\\000\\\n \\014\\000\\004\\000\\017\\000\\018\\000\\026\\000\\028\\000\\005\\000\\027\\000\\\n \\016\\000\\020\\000\\023\\000\\006\\000\\085\\000\\253\\255\\254\\255\\001\\000\\\n \\046\\000\\047\\000\\040\\000\\031\\000\\046\\000\\048\\000\\007\\000\\079\\000\\\n \\028\\000\\062\\000\\008\\000\\255\\255\\009\\000\\067\\000\\067\\000\\103\\000\\\n \\100\\000\\105\\000\\095\\000\\107\\000\\095\\000\\113\\000\\010\\000\\104\\000\\\n \\104\\000\\116\\000\\104\\000\\122\\000\\104\\000\\116\\000\\111\\000\\113\\000\\\n \\011\\000\\116\\000\\117\\000\\125\\000\\127\\000\\012\\000\\126\\000\\115\\000\\\n \\119\\000\\122\\000\\013\\000\";\n Lexing.lex_backtrk =\n \"\\001\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\";\n Lexing.lex_default =\n \"\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\047\\000\\000\\000\\000\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\";\n Lexing.lex_trans =\n \"\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\008\\000\\012\\000\\014\\000\\024\\000\\012\\000\\039\\000\\012\\000\\055\\000\\\n \\059\\000\\061\\000\\071\\000\\059\\000\\086\\000\\059\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\001\\000\\048\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\002\\000\\049\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\034\\000\\003\\000\\029\\000\\007\\000\\006\\000\\010\\000\\009\\000\\\n \\023\\000\\004\\000\\017\\000\\019\\000\\021\\000\\018\\000\\027\\000\\025\\000\\\n \\015\\000\\026\\000\\016\\000\\005\\000\\011\\000\\020\\000\\022\\000\\028\\000\\\n \\030\\000\\013\\000\\031\\000\\032\\000\\033\\000\\035\\000\\036\\000\\037\\000\\\n \\038\\000\\040\\000\\041\\000\\042\\000\\043\\000\\046\\000\\046\\000\\046\\000\\\n \\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\081\\000\\\n \\050\\000\\051\\000\\052\\000\\053\\000\\054\\000\\060\\000\\046\\000\\046\\000\\\n \\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\\n \\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\\n \\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\\n \\057\\000\\056\\000\\058\\000\\062\\000\\046\\000\\063\\000\\046\\000\\046\\000\\\n \\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\\n \\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\\n \\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\\n \\064\\000\\065\\000\\066\\000\\067\\000\\068\\000\\069\\000\\070\\000\\072\\000\\\n \\073\\000\\074\\000\\075\\000\\076\\000\\077\\000\\078\\000\\079\\000\\080\\000\\\n \\082\\000\\083\\000\\084\\000\\085\\000\\087\\000\\088\\000\\089\\000\\090\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\045\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \";\n Lexing.lex_check =\n \"\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\007\\000\\011\\000\\013\\000\\023\\000\\033\\000\\038\\000\\043\\000\\054\\000\\\n \\058\\000\\060\\000\\070\\000\\080\\000\\085\\000\\090\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\000\\000\\047\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\000\\000\\047\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\001\\000\\002\\000\\028\\000\\006\\000\\005\\000\\008\\000\\008\\000\\\n \\022\\000\\003\\000\\016\\000\\018\\000\\020\\000\\017\\000\\026\\000\\024\\000\\\n \\014\\000\\025\\000\\015\\000\\004\\000\\010\\000\\019\\000\\021\\000\\027\\000\\\n \\029\\000\\009\\000\\030\\000\\031\\000\\032\\000\\034\\000\\035\\000\\036\\000\\\n \\037\\000\\039\\000\\040\\000\\041\\000\\042\\000\\044\\000\\044\\000\\044\\000\\\n \\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\048\\000\\\n \\049\\000\\050\\000\\051\\000\\052\\000\\053\\000\\056\\000\\044\\000\\044\\000\\\n \\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\\n \\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\\n \\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\\n \\055\\000\\055\\000\\057\\000\\061\\000\\044\\000\\062\\000\\044\\000\\044\\000\\\n \\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\\n \\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\\n \\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\\n \\063\\000\\064\\000\\065\\000\\066\\000\\067\\000\\068\\000\\069\\000\\071\\000\\\n \\072\\000\\073\\000\\074\\000\\075\\000\\076\\000\\077\\000\\078\\000\\079\\000\\\n \\081\\000\\082\\000\\083\\000\\084\\000\\086\\000\\087\\000\\088\\000\\089\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\044\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \";\n Lexing.lex_base_code =\n \"\";\n Lexing.lex_backtrk_code =\n \"\";\n Lexing.lex_default_code =\n \"\";\n Lexing.lex_trans_code =\n \"\";\n Lexing.lex_check_code =\n \"\";\n Lexing.lex_code =\n \"\";\n}\n\nlet rec check lexbuf =\n __ocaml_lex_check_rec lexbuf 0\nand __ocaml_lex_check_rec lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 4 \"collector/check_backtraces.mll\"\n ( true )\n# 163 \"collector/check_backtraces.ml\"\n\n | 1 ->\n# 5 \"collector/check_backtraces.mll\"\n ( not_at_bos lexbuf )\n# 168 \"collector/check_backtraces.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_check_rec lexbuf __ocaml_lex_state\n\nand not_at_bos lexbuf =\n __ocaml_lex_not_at_bos_rec lexbuf 44\nand __ocaml_lex_not_at_bos_rec lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 8 \"collector/check_backtraces.mll\"\n ( true )\n# 180 \"collector/check_backtraces.ml\"\n\n | 1 ->\n# 9 \"collector/check_backtraces.mll\"\n ( not_at_bos lexbuf )\n# 185 \"collector/check_backtraces.ml\"\n\n | 2 ->\n# 10 \"collector/check_backtraces.mll\"\n ( false )\n# 190 \"collector/check_backtraces.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_not_at_bos_rec lexbuf __ocaml_lex_state\n\n;;\n\n# 12 \"collector/check_backtraces.mll\"\n \n let contains_backtraces s = check (Lexing.from_string s)\n\n# 201 \"collector/check_backtraces.ml\"\n","(** This module implements \"Fast Splittable Pseudorandom Number Generators\" by Steele et.\n al. (1). The paper's algorithm provides decent randomness for most purposes, but\n sacrifices cryptographic-quality randomness in favor of performance. The original\n implementation was tested with DieHarder and BigCrush; see the paper for details.\n\n Our implementation is a port from Java to OCaml of the paper's algorithm. Other than\n the choice of initial seed for [create], our port should be faithful. We have not\n re-run the DieHarder or BigCrush tests on our implementation. Our port is also not as\n performant as the original; two factors that hurt us are boxed [int64] values and lack\n of a POPCNT primitive.\n\n (1) http://2014.splashcon.org/event/oopsla2014-fast-splittable-pseudorandom-number-generators\n (also mirrored at http://gee.cs.oswego.edu/dl/papers/oopsla14.pdf)\n\n Beware when implementing this interface; it is easy to implement a [split] operation\n whose output is not as \"independent\" as it seems (2). This bug caused problems for\n Haskell's Quickcheck library for a long time.\n\n (2) Schaathun, \"Evaluation of splittable pseudo-random generators\", JFP 2015.\n http://www.hg.schaathun.net/research/Papers/hgs2015jfp.pdf\n*)\n\nopen! Base\nopen Int64.O\n\nlet is_odd x = x lor 1L = x\n\nlet popcount = Int64.popcount\n\nmodule State = struct\n\n type t =\n { mutable seed : int64\n ; odd_gamma : int64\n }\n\n let golden_gamma = 0x9e37_79b9_7f4a_7c15L\n\n let of_int seed =\n { seed = Int64.of_int seed\n ; odd_gamma = golden_gamma\n }\n\n let copy { seed ; odd_gamma } = { seed ; odd_gamma }\n\n let mix_bits z n =\n z lxor (z lsr n)\n\n let mix64 z =\n let z = (mix_bits z 33) * 0xff51_afd7_ed55_8ccdL in\n let z = (mix_bits z 33) * 0xc4ce_b9fe_1a85_ec53L in\n mix_bits z 33\n\n let mix64_variant13 z =\n let z = (mix_bits z 30) * 0xbf58_476d_1ce4_e5b9L in\n let z = (mix_bits z 27) * 0x94d0_49bb_1331_11ebL in\n mix_bits z 31\n\n let mix_odd_gamma z =\n let z = (mix64_variant13 z) lor 1L in\n let n = popcount (z lxor (z lsr 1)) in\n (* The original paper uses [>=] in the conditional immediately below; however this is\n a typo, and we correct it by using [<]. This was fixed in response to [1] and [2].\n\n [1] https://github.com/janestreet/splittable_random/issues/1\n [2] http://www.pcg-random.org/posts/bugs-in-splitmix.html\n *)\n if Int.( < ) n 24\n then z lxor 0xaaaa_aaaa_aaaa_aaaaL\n else z\n\n let%test_unit \"odd gamma\" =\n for input = -1_000_000 to 1_000_000 do\n let output = mix_odd_gamma (Int64.of_int input) in\n if not (is_odd output) then\n Error.raise_s [%message\n \"gamma value is not odd\"\n (input : int)\n (output : int64)]\n done\n\n let next_seed t =\n let next = t.seed + t.odd_gamma in\n t.seed <- next;\n next\n\n let of_seed_and_gamma ~seed ~gamma =\n let seed = mix64 seed in\n let odd_gamma = mix_odd_gamma gamma in\n { seed; odd_gamma }\n\n let random_int64 random_state =\n Random.State.int64_incl random_state Int64.min_value Int64.max_value\n\n let create random_state =\n let seed = random_int64 random_state in\n let gamma = random_int64 random_state in\n of_seed_and_gamma ~seed ~gamma\n\n let split t =\n let seed = next_seed t in\n let gamma = next_seed t in\n of_seed_and_gamma ~seed ~gamma\n\n let next_int64 t = mix64 (next_seed t)\n\n (* [perturb] is not from any external source, but provides a way to mix in external\n entropy with a pseudo-random state. *)\n let perturb t salt =\n let next = t.seed + mix64 (Int64.of_int salt) in\n t.seed <- next\n\nend\n\nlet bool state = is_odd (State.next_int64 state)\n\n(* We abuse terminology and refer to individual values as biased or unbiased. More\n properly, what is unbiased is the sampler that results if we keep only these \"unbiased\"\n values. *)\nlet remainder_is_unbiased\n ~draw\n ~remainder\n ~draw_maximum\n ~remainder_maximum\n =\n let open Int64.O in\n draw - remainder <= draw_maximum - remainder_maximum\n\nlet%test_unit \"remainder_is_unbiased\" =\n (* choosing a range of 10 values based on a range of 105 values *)\n let draw_maximum = 104L in\n let remainder_maximum = 9L in\n let is_unbiased draw =\n let remainder = Int64.rem draw (Int64.succ remainder_maximum) in\n remainder_is_unbiased ~draw ~remainder ~draw_maximum ~remainder_maximum\n in\n for i = 0 to 99 do\n [%test_result: bool]\n (is_unbiased (Int64.of_int i))\n ~expect:true\n ~message:(Int.to_string i)\n done;\n for i = 100 to 104 do\n [%test_result: bool]\n (is_unbiased (Int64.of_int i))\n ~expect:false\n ~message:(Int.to_string i)\n done\n\n(* This implementation of bounded randomness is adapted from [Random.State.int*] in the\n OCaml standard library. The purpose is to use the minimum number of calls to\n [next_int64] to produce a number uniformly chosen within the given range. *)\nlet int64 =\n let open Int64.O in\n let rec between state ~lo ~hi =\n let draw = State.next_int64 state in\n if lo <= draw && draw <= hi\n then draw\n else between state ~lo ~hi\n in\n let rec non_negative_up_to state maximum =\n let draw = State.next_int64 state land Int64.max_value in\n let remainder = Int64.rem draw (Int64.succ maximum) in\n if remainder_is_unbiased\n ~draw\n ~remainder\n ~draw_maximum:Int64.max_value\n ~remainder_maximum:maximum\n then remainder\n else non_negative_up_to state maximum\n in\n fun state ~lo ~hi ->\n if lo > hi then begin\n Error.raise_s [%message \"int64: crossed bounds\" (lo : int64) (hi : int64)]\n end;\n let diff = hi - lo in\n if diff = Int64.max_value\n then ((State.next_int64 state) land Int64.max_value) + lo\n else if diff >= 0L\n then (non_negative_up_to state diff) + lo\n else between state ~lo ~hi\n\nlet int state ~lo ~hi =\n let lo = Int64.of_int lo in\n let hi = Int64.of_int hi in\n (* truncate unneeded bits *)\n Int64.to_int_trunc (int64 state ~lo ~hi)\n\nlet int32 state ~lo ~hi =\n let lo = Int64.of_int32 lo in\n let hi = Int64.of_int32 hi in\n (* truncate unneeded bits *)\n Int64.to_int32_trunc (int64 state ~lo ~hi)\n\nlet nativeint state ~lo ~hi =\n let lo = Int64.of_nativeint lo in\n let hi = Int64.of_nativeint hi in\n (* truncate unneeded bits *)\n Int64.to_nativeint_trunc (int64 state ~lo ~hi)\n\nlet int63 state ~lo ~hi =\n let lo = Int63.to_int64 lo in\n let hi = Int63.to_int64 hi in\n (* truncate unneeded bits *)\n Int63.of_int64_trunc (int64 state ~lo ~hi)\n\nlet double_ulp = 2. **. -53.\n\nlet%test_unit \"double_ulp\" =\n let open Float.O in\n match Word_size.word_size with\n | W64 ->\n assert (1.0 -. double_ulp < 1.0);\n assert (1.0 -. (double_ulp /. 2.0) = 1.0)\n | W32 ->\n (* 32-bit OCaml uses a 64-bit float representation but 80-bit float instructions, so\n rounding works differently due to the conversion back and forth. *)\n assert (1.0 -. double_ulp < 1.0);\n assert (1.0 -. (double_ulp /. 2.0) <= 1.0)\n\nlet unit_float_from_int64 int64 =\n (Int64.to_float (int64 lsr 11)) *. double_ulp\n\nlet%test_unit \"unit_float_from_int64\" = begin\n let open Float.O in\n assert (unit_float_from_int64 0x0000_0000_0000_0000L = 0.);\n assert (unit_float_from_int64 0xffff_ffff_ffff_ffffL < 1.0);\n assert (unit_float_from_int64 0xffff_ffff_ffff_ffffL = (1.0 -. double_ulp));\nend\n\nlet unit_float state =\n unit_float_from_int64 (State.next_int64 state)\n\n(* Note about roundoff error:\n\n Although [float state ~lo ~hi] is nominally inclusive of endpoints, we are relying on\n the fact that [unit_float] never returns 1., because there are pairs [(lo,hi)] for\n which [lo +. 1. *. (hi -. lo) > hi]. There are also pairs [(lo,hi)] and values of [x]\n with [x < 1.] such that [lo +. x *. (hi -. lo) = hi], so it would not be correct to\n document this as being exclusive of [hi].\n*)\nlet float =\n let rec finite_float state ~lo ~hi =\n let range = hi -. lo in\n if Float.is_finite range\n then (lo +. (unit_float state *. range))\n else begin\n (* If [hi - lo] is infinite, then [hi + lo] is finite because [hi] and [lo] have\n opposite signs. *)\n let mid = (hi +. lo) /. 2. in\n if bool state\n (* Depending on rounding, the recursion with [~hi:mid] might be inclusive of [mid],\n which would mean the two cases overlap on [mid]. The alternative is to increment\n or decrement [mid] using [one_ulp] in either of the calls, but then if the first\n case is exclusive we leave a \"gap\" between the two ranges. There's no perfectly\n uniform solution, so we use the simpler code that does not call [one_ulp]. *)\n then finite_float state ~lo ~hi:mid\n else finite_float state ~lo:mid ~hi\n end\n in\n fun state ~lo ~hi ->\n if not (Float.is_finite lo && Float.is_finite hi)\n then begin\n raise_s [%message\n \"float: bounds are not finite numbers\"\n (lo : float)\n (hi : float)]\n end;\n if Float.( > ) lo hi\n then begin\n raise_s [%message\n \"float: bounds are crossed\"\n (lo : float)\n (hi : float)]\n end;\n finite_float state ~lo ~hi\n\nlet%bench_fun \"unit_float_from_int64\" =\n let int64 = 1L in\n fun () -> unit_float_from_int64 int64\n\nmodule Log_uniform = struct\n module Make (M : sig include Int.S val uniform : State.t -> lo:t -> hi:t -> t end) : sig\n val log_uniform : State.t -> lo:M.t -> hi:M.t -> M.t\n end = struct\n open M\n\n let bits_to_represent t =\n assert (t >= zero);\n let t = ref t in\n let n = ref 0 in\n while !t > zero do\n t := shift_right !t 1;\n Int.incr n;\n done;\n !n\n\n let%test_unit \"bits_to_represent\" =\n let test n expect = [%test_result: int] (bits_to_represent n) ~expect in\n test (M.of_int_exn 0) 0;\n test (M.of_int_exn 1) 1;\n test (M.of_int_exn 2) 2;\n test (M.of_int_exn 3) 2;\n test (M.of_int_exn 4) 3;\n test (M.of_int_exn 5) 3;\n test (M.of_int_exn 6) 3;\n test (M.of_int_exn 7) 3;\n test (M.of_int_exn 8) 4;\n test (M.of_int_exn 100) 7;\n test M.max_value (Int.pred M.num_bits);\n ;;\n\n let min_represented_by_n_bits n =\n if Int.equal n 0\n then zero\n else shift_left one (Int.pred n)\n\n let%test_unit \"min_represented_by_n_bits\" =\n let test n expect = [%test_result: M.t] (min_represented_by_n_bits n) ~expect in\n test 0 (M.of_int_exn 0);\n test 1 (M.of_int_exn 1);\n test 2 (M.of_int_exn 2);\n test 3 (M.of_int_exn 4);\n test 4 (M.of_int_exn 8);\n test 7 (M.of_int_exn 64);\n test (Int.pred M.num_bits) (M.shift_right_logical M.min_value 1);\n ;;\n\n let max_represented_by_n_bits n =\n pred (shift_left one n)\n\n let%test_unit \"max_represented_by_n_bits\" =\n let test n expect = [%test_result: M.t] (max_represented_by_n_bits n) ~expect in\n test 0 (M.of_int_exn 0);\n test 1 (M.of_int_exn 1);\n test 2 (M.of_int_exn 3);\n test 3 (M.of_int_exn 7);\n test 4 (M.of_int_exn 15);\n test 7 (M.of_int_exn 127);\n test (Int.pred M.num_bits) M.max_value;\n ;;\n\n let log_uniform state ~lo ~hi =\n let min_bits = bits_to_represent lo in\n let max_bits = bits_to_represent hi in\n let bits = int state ~lo:min_bits ~hi:max_bits in\n uniform state\n ~lo:(min_represented_by_n_bits bits |> max lo)\n ~hi:(max_represented_by_n_bits bits |> min hi)\n end\n\n module For_int = Make (struct include Int let uniform = int end)\n module For_int32 = Make (struct include Int32 let uniform = int32 end)\n module For_int63 = Make (struct include Int63 let uniform = int63 end)\n module For_int64 = Make (struct include Int64 let uniform = int64 end)\n module For_nativeint = Make (struct include Nativeint let uniform = nativeint end)\n\n let int = For_int.log_uniform\n let int32 = For_int32.log_uniform\n let int63 = For_int63.log_uniform\n let int64 = For_int64.log_uniform\n let nativeint = For_nativeint.log_uniform\nend\n\n","(* This module builds a buffer of \"instructions\", in order to represent a compact sequence\n of delimiting positions and newlines. The parser stores the positions of each:\n\n - newline\n - beginning of atom\n - end of atom\n - left parenthesis\n - right parenthesis\n\n Instructions are encoded as a sequence bits. The next instruction is determined by\n looking at the next few bits:\n\n - bit 0 represents a saved position followed by an offset increment\n - bits 10 represent an offset increment\n - bits 110 are followed by 5 bits of payload. The 5-bit payloads of any subsequent 110-\n instructions are squashed to form a number (least significant 5-bit chunk first).\n This number + 5 represents an offset increment\n - bits 1110 marks the beginning of a new line (with offset incremented)\n - bits 1111 represent a position saved twice followed by an offset increment\n\n For instance let's consider the following sexp:\n\n {[\n {|\n(abc\n \"foo\n bar\"\n)\n|}\n ]}\n\n the sequence of instructions to record in order to reconstruct the position of any\n sub-sexp is:\n\n - 0 save position and advance 1: first '('\n - 0 save position and advance 1: start of \"abc\"\n - 10 advance 1\n - 0 save position and advance 1: end of \"abc\"\n - 1110 newline\n - 1100_0001 advance 6\n - 0 save position and advance 1: start of \"foo\\n bar\"\n - 10 advance 1\n - 10 advance 1\n - 10 advance 1\n - 1110 newline\n - 1100_0000 advance 5\n - 0 save position and advance 1: end of \"foo\\n bar\"\n - 1110 newline\n - 0 save position and advance 1: last ')'\n\n (we save the position after the closing parenthesis)\n\n The total sequence is 42 bits, so we need 6 bytes to store it\n\n The sequence of bits is encoded as a sequence of 16-bit values, where the earlier bits\n are most significant.\n\n Note that the parser stores the end positions as inclusive. This way only single\n character atoms require a double positions. If we were storing end positions as\n exclusive, we would need double positions for [)(] and [a(], which are likely to be\n frequent in s-expressions printed with the non [_hum] printer. We expect single\n character atoms to be less frequent so it makes sense to penalize them instead.\n*)\n\nopen! Import\n\ntype pos =\n { line : int\n ; col : int\n ; offset : int\n }\n[@@deriving_inline sexp_of]\n\nlet sexp_of_pos =\n (function\n | { line = v_line; col = v_col; offset = v_offset } ->\n let bnds = [] in\n let bnds =\n let arg = sexp_of_int v_offset in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"offset\"; arg ] :: bnds\n in\n let bnds =\n let arg = sexp_of_int v_col in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"col\"; arg ] :: bnds\n in\n let bnds =\n let arg = sexp_of_int v_line in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"line\"; arg ] :: bnds\n in\n Ppx_sexp_conv_lib.Sexp.List bnds\n : pos -> Ppx_sexp_conv_lib.Sexp.t)\n;;\n\n[@@@end]\n\nlet compare_pos = Caml.compare\nlet beginning_of_file = { line = 1; col = 0; offset = 0 }\nlet shift_pos pos ~cols = { pos with col = pos.col + cols; offset = pos.offset + cols }\n\ntype range =\n { start_pos : pos\n ; end_pos : pos\n }\n[@@deriving_inline sexp_of]\n\nlet sexp_of_range =\n (function\n | { start_pos = v_start_pos; end_pos = v_end_pos } ->\n let bnds = [] in\n let bnds =\n let arg = sexp_of_pos v_end_pos in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"end_pos\"; arg ] :: bnds\n in\n let bnds =\n let arg = sexp_of_pos v_start_pos in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"start_pos\"; arg ]\n :: bnds\n in\n Ppx_sexp_conv_lib.Sexp.List bnds\n : range -> Ppx_sexp_conv_lib.Sexp.t)\n;;\n\n[@@@end]\n\nlet compare_range = Caml.compare\n\nlet make_range_incl ~start_pos ~last_pos =\n { start_pos; end_pos = shift_pos last_pos ~cols:1 }\n;;\n\nmodule Chunk : sig\n (** Represents an array of [length/2] signed 16-bit values *)\n type t\n\n (** Length in bytes. *)\n val length : int\n\n val alloc : unit -> t\n\n (** [get16 ~pos] and [set16 ~pos] manipulate the [pos/2]th stored value.\n [pos] must be even.\n [set16 x] only uses the 16 least significant bits of [x]. *)\n val get16 : t -> pos:int -> int\n\n val set16 : t -> pos:int -> int -> unit\nend = struct\n type t = bytes\n\n (* OCaml strings always waste two bytes at the end, so we take a power of two minus two\n to be sure we don't waste space. *)\n let length = 62\n let alloc () = Bytes.create length\n let get16 = Bytes0.get16\n let set16 = Bytes0.set16\n\n (* If we want to make a [Positions.t] serializable:\n\n {[\n external bswap16 : int -> int = \"%bswap16\";;\n\n let get16 =\n if Caml.Sys.arch_big_endian then\n fun buf ~pos -> get16 buf ~pos |> bswap16\n else\n get16\n\n let set16 =\n if Caml.Sys.arch_big_endian then\n fun buf ~pos x -> set16 buf ~pos (bswap16 x)\n else\n set16\n ]}\n\n *)\nend\n\ntype t_ =\n { chunks : Chunk.t list\n ; (* [num_bytes * 8 + extra_bits] is the number of bits stored in [chunks].\n The last [extra_bits] bits will be stored as the *least* significant bits\n of the appropriate pair of bytes of the last chunk. *)\n num_bytes : int\n ; extra_bits : int\n ; initial_pos : pos\n }\n\ntype t = t_ Lazy.t\n\nlet memory_footprint_in_bytes (lazy t) =\n let num_fields = 4 in\n let header_words = 1 in\n let word_bytes =\n match Sys.word_size with\n | 32 -> 4\n | 64 -> 8\n | _ -> assert false\n in\n let chunk_words =\n let div_ceil a b = (a + b - 1) / b in\n let n =\n div_ceil\n (Chunk.length\n + 1 (* NUL terminating bytes *)\n + 1 (* number of wasted bytes to fill a word *))\n word_bytes\n in\n n + header_words\n in\n let pos_fields = 3 in\n let pos_words = header_words + pos_fields in\n let list_cons_words = header_words + 2 in\n (header_words\n + num_fields\n + pos_words\n + (List.length t.chunks * (chunk_words + list_cons_words)))\n * word_bytes\n;;\n\nmodule Builder = struct\n type t =\n { mutable chunk : Chunk.t\n ; mutable chunk_pos : int\n ; mutable filled_chunks : Chunk.t list (* Filled chunks in reverse order *)\n ; mutable offset : int\n (* Offset of the last saved position or newline plus\n one, or [initial_pos] *)\n ; mutable int_buf : int\n (* the [num_bits] least significant bits of [int_buf]\n are the bits not yet pushed to [chunk]. *)\n ; mutable num_bits : int (* number of bits stored in [int_buf] *)\n ; mutable initial_pos : pos\n }\n\n let invariant t =\n assert (t.chunk_pos >= 0 && t.chunk_pos <= Chunk.length);\n assert (t.offset >= t.initial_pos.offset);\n assert (t.num_bits <= 15)\n ;;\n\n let check_invariant = false\n let invariant t = if check_invariant then invariant t\n\n let create ?(initial_pos = beginning_of_file) () =\n { chunk = Chunk.alloc ()\n ; chunk_pos = 0\n ; filled_chunks = []\n ; offset = initial_pos.offset\n ; int_buf = 0\n ; num_bits = 0\n ; initial_pos\n }\n ;;\n\n let reset t (pos : pos) =\n (* We need a new chunk as [contents] keeps the current chunk in the closure of the\n lazy value. *)\n t.chunk <- Chunk.alloc ();\n t.chunk_pos <- 0;\n t.filled_chunks <- [];\n t.offset <- pos.offset;\n t.int_buf <- 0;\n t.num_bits <- 0;\n t.initial_pos <- pos\n ;;\n\n let[@inlined never] alloc_new_chunk t =\n t.filled_chunks <- t.chunk :: t.filled_chunks;\n t.chunk <- Chunk.alloc ();\n t.chunk_pos <- 0\n ;;\n\n let add_uint16 t n =\n if t.chunk_pos = Chunk.length then alloc_new_chunk t;\n Chunk.set16 t.chunk ~pos:t.chunk_pos n\n ;;\n\n let add_bits t n ~num_bits =\n let int_buf = (t.int_buf lsl num_bits) lor n in\n let num_bits = t.num_bits + num_bits in\n t.int_buf <- int_buf;\n if num_bits < 16\n then t.num_bits <- num_bits\n else (\n let num_bits = num_bits - 16 in\n t.num_bits <- num_bits;\n add_uint16 t (int_buf lsr num_bits);\n t.chunk_pos <- t.chunk_pos + 2\n (* no need to clear the bits of int_buf we just wrote, as further set16 will ignore\n these extra bits. *))\n ;;\n\n let contents t =\n (* Flush the current [t.int_buf] *)\n add_uint16 t t.int_buf;\n let rev_chunks = t.chunk :: t.filled_chunks in\n let chunk_pos = t.chunk_pos in\n let extra_bits = t.num_bits in\n let initial_pos = t.initial_pos in\n lazy\n { chunks = List.rev rev_chunks\n ; num_bytes = ((List.length rev_chunks - 1) * Chunk.length) + chunk_pos\n ; extra_bits\n ; initial_pos\n }\n ;;\n\n let long_shift t n =\n let n = ref (n - 5) in\n while !n > 0 do\n add_bits t (0b1100_0000 lor (!n land 0b0001_1111)) ~num_bits:8;\n n := !n lsr 5\n done\n ;;\n\n (* precondition: n >= 5 *)\n let[@inlined never] add_gen_slow t n ~instr ~instr_bits =\n long_shift t n;\n add_bits t instr ~num_bits:instr_bits\n ;;\n\n let shift4 = 0b10_10_10_10\n\n let[@inline always] add_gen t ~offset ~instr ~instr_bits =\n invariant t;\n let n = offset - t.offset in\n t.offset <- offset + 1;\n match n with\n | 0 | 1 | 2 | 3 | 4 ->\n let num_bits = (n lsl 1) + instr_bits in\n add_bits\n t\n ((shift4 lsl instr_bits) lor instr land ((1 lsl num_bits) - 1))\n ~num_bits\n | 5\n | 6\n | 7\n | 8\n | 9\n | 10\n | 11\n | 12\n | 13\n | 14\n | 15\n | 16\n | 17\n | 18\n | 19\n | 20\n | 21\n | 22\n | 23\n | 24\n | 25\n | 26\n | 27\n | 28\n | 29\n | 30\n | 31\n | 32\n | 33\n | 34\n | 35\n | 36 ->\n add_bits\n t\n (((0b1100_0000 lor (n - 5)) lsl instr_bits) lor instr)\n ~num_bits:(8 + instr_bits)\n | _ ->\n if n < 0 then invalid_arg \"Parsexp.Positions.add_gen\";\n add_gen_slow t n ~instr ~instr_bits\n ;;\n\n let add t ~offset = add_gen t ~offset ~instr:0b0 ~instr_bits:1\n let add_twice t ~offset = add_gen t ~offset ~instr:0b1111 ~instr_bits:4\n let add_newline t ~offset = add_gen t ~offset ~instr:0b1110 ~instr_bits:4\nend\n\ntype positions = t\n\nmodule Iterator : sig\n type t\n\n val create : positions -> t\n\n exception No_more\n\n (* [advance t ~skip] ignores [skip] saved positions and returns the next saved position.\n Raises [No_more] when reaching the end of the position set. *)\n val advance_exn : t -> skip:int -> pos\nend = struct\n type t =\n { mutable chunk : Chunk.t\n ; mutable chunks : Chunk.t list\n ; (* [num_bytes * 8 + extra_bits] is the number of bits available from [instr_pos] in\n [chunk :: chunks]. *)\n mutable num_bytes : int\n ; extra_bits : int\n ; mutable instr_pos : int (* position in [chunk] *)\n ; mutable offset : int\n ; mutable line : int\n ; mutable bol : int\n ; mutable int_buf : int\n ; mutable num_bits : int (* Number of bits not yet consumed in [int_buf] *)\n ; mutable pending : pos option\n }\n\n let create ((lazy p) : positions) =\n match p.chunks with\n | [] -> assert false\n | chunk :: chunks ->\n { chunk\n ; chunks\n ; num_bytes = p.num_bytes\n ; extra_bits = p.extra_bits\n ; instr_pos = 0\n ; offset = p.initial_pos.offset\n ; line = p.initial_pos.line\n ; bol = p.initial_pos.offset - p.initial_pos.col\n ; int_buf = 0\n ; num_bits = 0\n ; pending = None\n }\n ;;\n\n exception No_more\n\n let no_more () = raise_notrace No_more\n\n let[@inlined never] fetch_chunk t =\n match t.chunks with\n | [] -> assert false\n | chunk :: chunks ->\n t.instr_pos <- 0;\n t.num_bytes <- t.num_bytes - Chunk.length;\n t.chunk <- chunk;\n t.chunks <- chunks\n ;;\n\n let fetch t =\n if t.instr_pos > t.num_bytes then no_more ();\n if t.instr_pos = Chunk.length then fetch_chunk t;\n let v = Chunk.get16 t.chunk ~pos:t.instr_pos in\n let added_bits = if t.instr_pos = t.num_bytes then t.extra_bits else 16 in\n t.int_buf <- (t.int_buf lsl added_bits) lor (v land ((1 lsl added_bits) - 1));\n t.num_bits <- t.num_bits + added_bits;\n t.instr_pos <- t.instr_pos + 2\n ;;\n\n let next_instruction_bits t ~num_bits =\n if t.num_bits < num_bits\n then (\n fetch t;\n if t.num_bits < num_bits then no_more ());\n let n = (t.int_buf lsr (t.num_bits - num_bits)) land ((1 lsl num_bits) - 1) in\n t.num_bits <- t.num_bits - num_bits;\n n\n ;;\n\n (* [offset_shift] and [offset_shift_num_bits] encode the offset number\n specified by the immediately preceding [110] instructions. *)\n let rec advance t ~skip ~offset_shift ~offset_shift_num_bits =\n match next_instruction_bits t ~num_bits:1 with\n | 0 ->\n (* bit seq 0 -> new item *)\n let offset = t.offset + offset_shift in\n t.offset <- offset + 1;\n if skip = 0\n then { line = t.line; col = offset - t.bol; offset }\n else advance t ~skip:(skip - 1) ~offset_shift:0 ~offset_shift_num_bits:0\n | _ ->\n (match next_instruction_bits t ~num_bits:1 with\n | 0 ->\n (* bit seq 10 -> shift *)\n t.offset <- t.offset + offset_shift + 1;\n advance t ~skip ~offset_shift:0 ~offset_shift_num_bits:0\n | _ ->\n (match next_instruction_bits t ~num_bits:1 with\n | 0 ->\n (* bit seq 110 -> long shift *)\n let n = next_instruction_bits t ~num_bits:5 in\n let offset_shift = if offset_shift_num_bits = 0 then 5 else offset_shift in\n advance\n t\n ~skip\n ~offset_shift:(offset_shift + (n lsl offset_shift_num_bits))\n ~offset_shift_num_bits:(offset_shift_num_bits + 5)\n | _ ->\n (match next_instruction_bits t ~num_bits:1 with\n | 0 ->\n (* bit seq 1110 -> newline *)\n t.offset <- t.offset + offset_shift + 1;\n t.bol <- t.offset;\n t.line <- t.line + 1;\n advance t ~skip ~offset_shift:0 ~offset_shift_num_bits:0\n | _ ->\n (* bit seq 1111 -> 2 new items *)\n let offset = t.offset + offset_shift in\n t.offset <- offset + 1;\n if skip <= 1\n then (\n let pos = { line = t.line; col = offset - t.bol; offset } in\n if skip = 0 then t.pending <- Some pos;\n pos)\n else advance t ~skip:(skip - 2) ~offset_shift:0 ~offset_shift_num_bits:0)))\n ;;\n\n let advance_exn t ~skip =\n match t.pending with\n | Some pos ->\n t.pending <- None;\n if skip = 0\n then pos\n else advance t ~skip:(skip - 1) ~offset_shift:0 ~offset_shift_num_bits:0\n | None -> advance t ~skip ~offset_shift:0 ~offset_shift_num_bits:0\n ;;\nend\n\nlet find t a b =\n if a < 0 || b <= a then invalid_arg \"Parsexp.Positions.find\";\n let iter = Iterator.create t in\n try\n let start_pos = Iterator.advance_exn iter ~skip:a in\n let last_pos = Iterator.advance_exn iter ~skip:(b - a - 1) in\n make_range_incl ~start_pos ~last_pos\n with\n | Iterator.No_more -> failwith \"Parsexp.Position.find\"\n;;\n\nlet rec sub_sexp_count (sexp : Sexp.t) =\n match sexp with\n | Atom _ -> 1\n | List l -> List.fold_left l ~init:1 ~f:(fun acc x -> acc + sub_sexp_count x)\n;;\n\nmodule Sexp_search = struct\n exception Found of int\n\n let rec loop ~sub index (sexp : Sexp.t) =\n if sexp == sub\n then raise_notrace (Found index)\n else (\n match sexp with\n | Atom _ -> index + 2\n | List l ->\n let index = loop_list ~sub (index + 1) l in\n index + 1)\n\n and loop_list ~sub index (sexps : Sexp.t list) =\n List.fold_left sexps ~init:index ~f:(loop ~sub)\n ;;\n\n let finalize t ~sub a =\n let b = a + (sub_sexp_count sub * 2) - 1 in\n Some (find t a b)\n ;;\n\n let find_sub_sexp_phys t sexp ~sub =\n match loop ~sub 0 sexp with\n | (_ : int) -> None\n | exception Found n -> finalize t ~sub n\n ;;\n\n let find_sub_sexp_in_list_phys t sexps ~sub =\n match loop_list ~sub 0 sexps with\n | (_ : int) -> None\n | exception Found n -> finalize t ~sub n\n ;;\nend\n\nlet find_sub_sexp_phys = Sexp_search.find_sub_sexp_phys\nlet find_sub_sexp_in_list_phys = Sexp_search.find_sub_sexp_in_list_phys\n\nlet to_list t =\n let iter = Iterator.create t in\n let rec loop acc =\n match Iterator.advance_exn iter ~skip:0 with\n | exception Iterator.No_more -> List.rev acc\n | pos -> loop (pos :: acc)\n in\n loop []\n;;\n\nlet to_array t = to_list t |> Array.of_list\nlet compare t1 t2 = Caml.compare (to_array t1) (to_array t2)\nlet sexp_of_t t = sexp_of_array sexp_of_pos (to_array t)\n","open! Import\nmodule Binable = Binable0\n\n(* All the types as exposed in the mli are defined in this [Types] module. The rest of\n this file is simply overriding all the bin_io, compare, and sexp functions to raise\n exceptions. *)\nmodule Types = struct\n module Nobody = struct\n type t [@@deriving bin_io, compare, hash, sexp]\n\n let name = \"Nobody\"\n end\n\n module Me = struct\n type t [@@deriving bin_io, compare, hash, sexp]\n\n let name = \"Me\"\n end\n\n module Read = struct\n type t = [ `Read ] [@@deriving bin_io, compare, hash, sexp]\n\n let name = \"Read\"\n end\n\n module Write = struct\n type t = [ `Who_can_write of Me.t ] [@@deriving bin_io, compare, hash, sexp]\n\n let name = \"Write\"\n end\n\n module Immutable = struct\n type t =\n [ Read.t\n | `Who_can_write of Nobody.t\n ]\n [@@deriving bin_io, compare, hash, sexp]\n\n let name = \"Immutable\"\n end\n\n module Read_write = struct\n type t =\n [ Read.t\n | Write.t\n ]\n [@@deriving bin_io, compare, hash, sexp]\n\n let name = \"Read_write\"\n end\n\n module Upper_bound = struct\n type 'a t =\n [ Read.t\n | `Who_can_write of 'a\n ]\n [@@deriving bin_io, compare, hash, sexp]\n\n let name = \"Upper_bound\"\n end\nend\n\nlet failwithf = Printf.failwithf\n\n(* This is an explicit module type instead of just given inline as the return signature of\n [Only_used_as_phantom_type1] to avoid an unused value warning with bin_io values. *)\nmodule type Sexpable_binable_comparable = sig\n type 'a t = 'a [@@deriving bin_io, compare, hash, sexp]\nend\n\n(* Override all bin_io, sexp, compare functions to raise exceptions *)\nmodule Only_used_as_phantom_type1 (Name : sig\n val name : string\n end) : Sexpable_binable_comparable = struct\n type 'a t = 'a\n\n let sexp_of_t _ _ = failwithf \"Unexpectedly called [%s.sexp_of_t]\" Name.name ()\n let t_of_sexp _ _ = failwithf \"Unexpectedly called [%s.t_of_sexp]\" Name.name ()\n let compare _ _ _ = failwithf \"Unexpectedly called [%s.compare]\" Name.name ()\n let hash_fold_t _ _ _ = failwithf \"Unexpectedly called [%s.hash_fold_t]\" Name.name ()\n\n include Binable.Of_binable1_without_uuid [@alert \"-legacy\"]\n (struct\n type 'a t = 'a [@@deriving bin_io]\n end)\n (struct\n type nonrec 'a t = 'a t\n\n let to_binable _ =\n failwithf \"Unexpectedly used %s bin_io serialization\" Name.name ()\n ;;\n\n let of_binable _ =\n failwithf \"Unexpectedly used %s bin_io deserialization\" Name.name ()\n ;;\n end)\nend\n\nmodule Only_used_as_phantom_type0 (T : sig\n type t [@@deriving bin_io, compare, hash, sexp]\n\n val name : string\n end) : sig\n type t = T.t [@@deriving bin_io, compare, hash, sexp_poly]\nend = struct\n module M = Only_used_as_phantom_type1 (T)\n\n type t = T.t M.t [@@deriving bin_io, compare, hash, sexp]\n\n let __t_of_sexp__ = t_of_sexp\nend\n\nmodule Stable = struct\n module V1 = struct\n module Nobody = Only_used_as_phantom_type0 (Types.Nobody)\n module Me = Only_used_as_phantom_type0 (Types.Me)\n module Read = Only_used_as_phantom_type0 (Types.Read)\n module Write = Only_used_as_phantom_type0 (Types.Write)\n module Read_write = Only_used_as_phantom_type0 (Types.Read_write)\n module Immutable = Only_used_as_phantom_type0 (Types.Immutable)\n\n type nobody = Nobody.t [@@deriving bin_io, compare, hash, sexp]\n type me = Me.t [@@deriving bin_io, compare, hash, sexp]\n\n module Upper_bound = struct\n module M = Only_used_as_phantom_type1 (Types.Upper_bound)\n\n type 'a t = 'a Types.Upper_bound.t M.t [@@deriving bin_io, compare, hash, sexp]\n\n let __t_of_sexp__ = t_of_sexp\n end\n end\n\n module Export = struct\n type read = V1.Read.t [@@deriving bin_io, compare, hash, sexp]\n type write = V1.Write.t [@@deriving compare, hash, sexp]\n type immutable = V1.Immutable.t [@@deriving bin_io, compare, hash, sexp]\n type read_write = V1.Read_write.t [@@deriving bin_io, compare, hash, sexp]\n type 'a perms = 'a V1.Upper_bound.t [@@deriving bin_io, compare, hash, sexp]\n end\nend\n\ninclude Stable.V1\nmodule Export = Stable.Export\n","(* Conv_error: Module for Handling Errors during Automated S-expression\n Conversions *)\n\nopen StdLabels\nopen Printf\nopen Sexp_conv\n\nexception Of_sexp_error = Of_sexp_error\n\n(* Errors concerning tuples *)\n\nlet tuple_of_size_n_expected loc n sexp =\n of_sexp_error (sprintf \"%s_of_sexp: tuple of size %d expected\" loc n) sexp\n\n\n(* Errors concerning sum types *)\n\nlet stag_no_args loc sexp =\n of_sexp_error (loc ^ \"_of_sexp: sum tag does not take arguments\") sexp\n\nlet stag_incorrect_n_args loc tag sexp =\n let msg =\n sprintf \"%s_of_sexp: sum tag %S has incorrect number of arguments\" loc tag\n in\n of_sexp_error msg sexp\n\nlet stag_takes_args loc sexp =\n of_sexp_error (loc ^ \"_of_sexp: sum tag must be a structured value\") sexp\n\nlet nested_list_invalid_sum loc sexp =\n of_sexp_error (loc ^ \"_of_sexp: a nested list is an invalid sum\") sexp\n\nlet empty_list_invalid_sum loc sexp =\n of_sexp_error (loc ^ \"_of_sexp: the empty list is an invalid sum\") sexp\n\nlet unexpected_stag loc sexp =\n of_sexp_error (loc ^ \"_of_sexp: unexpected sum tag\") sexp\n\n\n(* Errors concerning records *)\n\nlet record_sexp_bool_with_payload loc sexp =\n let msg =\n loc ^\n \"_of_sexp: record conversion: a [sexp.bool] field was given a payload.\" in\n of_sexp_error msg sexp\n\nlet record_only_pairs_expected loc sexp =\n let msg =\n loc ^\n \"_of_sexp: record conversion: only pairs expected, \\\n their first element must be an atom\" in\n of_sexp_error msg sexp\n\nlet record_superfluous_fields ~what ~loc rev_fld_names sexp =\n let fld_names_str = String.concat (List.rev rev_fld_names) ~sep:\" \" in\n let msg = sprintf \"%s_of_sexp: %s: %s\" loc what fld_names_str in\n of_sexp_error msg sexp\n\nlet record_duplicate_fields loc rev_fld_names sexp =\n record_superfluous_fields ~what:\"duplicate fields\" ~loc rev_fld_names sexp\n\nlet record_extra_fields loc rev_fld_names sexp =\n record_superfluous_fields ~what:\"extra fields\" ~loc rev_fld_names sexp\n\nlet rec record_get_undefined_loop fields = function\n | [] -> String.concat (List.rev fields) ~sep:\" \"\n | (true, field) :: rest -> record_get_undefined_loop (field :: fields) rest\n | _ :: rest -> record_get_undefined_loop fields rest\n\nlet record_undefined_elements loc sexp lst =\n let undefined = record_get_undefined_loop [] lst in\n let msg =\n sprintf \"%s_of_sexp: the following record elements were undefined: %s\"\n loc undefined\n in\n of_sexp_error msg sexp\n\nlet record_list_instead_atom loc sexp =\n let msg = loc ^ \"_of_sexp: list instead of atom for record expected\" in\n of_sexp_error msg sexp\n\nlet record_poly_field_value loc sexp =\n let msg =\n loc ^\n \"_of_sexp: cannot convert values of types resulting from polymorphic \\\n record fields\"\n in\n of_sexp_error msg sexp\n\n\n(* Errors concerning polymorphic variants *)\n\nexception No_variant_match\n\nlet no_variant_match () =\n raise No_variant_match\n\nlet no_matching_variant_found loc sexp =\n of_sexp_error (loc ^ \"_of_sexp: no matching variant found\") sexp\n\nlet ptag_no_args loc sexp =\n of_sexp_error (\n loc ^ \"_of_sexp: polymorphic variant does not take arguments\") sexp\n\nlet ptag_incorrect_n_args loc cnstr sexp =\n let msg =\n sprintf\n \"%s_of_sexp: polymorphic variant tag %S has incorrect number of arguments\"\n loc cnstr\n in\n of_sexp_error msg sexp\n\nlet ptag_takes_args loc sexp =\n of_sexp_error (loc ^ \"_of_sexp: polymorphic variant tag takes an argument\")\n sexp\n\nlet nested_list_invalid_poly_var loc sexp =\n of_sexp_error (\n loc ^ \"_of_sexp: a nested list is an invalid polymorphic variant\") sexp\n\nlet empty_list_invalid_poly_var loc sexp =\n of_sexp_error (\n loc ^ \"_of_sexp: the empty list is an invalid polymorphic variant\") sexp\n\nlet empty_type loc sexp =\n of_sexp_error (loc ^ \"_of_sexp: trying to convert an empty type\") sexp\n","open! Import\nopen Quickcheck_intf\nopen Base_quickcheck\nmodule Array = Base.Array\nmodule Bool = Base.Bool\nmodule Char = Base.Char\nmodule Float = Base.Float\nmodule Int = Base.Int\nmodule List = Base.List\nmodule Option = Base.Option\nmodule Type_equal = Base.Type_equal\n\nmodule Polymorphic_types = struct\n type ('a, 'b) variant2 =\n [ `A of 'a\n | `B of 'b\n ]\n [@@deriving quickcheck]\n\n type ('a, 'b, 'c) variant3 =\n [ `A of 'a\n | `B of 'b\n | `C of 'c\n ]\n [@@deriving quickcheck]\n\n type ('a, 'b, 'c, 'd) variant4 =\n [ `A of 'a\n | `B of 'b\n | `C of 'c\n | `D of 'd\n ]\n [@@deriving quickcheck]\n\n type ('a, 'b, 'c, 'd, 'e) variant5 =\n [ `A of 'a\n | `B of 'b\n | `C of 'c\n | `D of 'd\n | `E of 'e\n ]\n [@@deriving quickcheck]\n\n type ('a, 'b, 'c, 'd, 'e, 'f) variant6 =\n [ `A of 'a\n | `B of 'b\n | `C of 'c\n | `D of 'd\n | `E of 'e\n | `F of 'f\n ]\n [@@deriving quickcheck]\n\n type ('a, 'b) tuple2 = 'a * 'b [@@deriving quickcheck]\n type ('a, 'b, 'c) tuple3 = 'a * 'b * 'c [@@deriving quickcheck]\n type ('a, 'b, 'c, 'd) tuple4 = 'a * 'b * 'c * 'd [@@deriving quickcheck]\n type ('a, 'b, 'c, 'd, 'e) tuple5 = 'a * 'b * 'c * 'd * 'e [@@deriving quickcheck]\n\n type ('a, 'b, 'c, 'd, 'e, 'f) tuple6 = 'a * 'b * 'c * 'd * 'e * 'f\n [@@deriving quickcheck]\n\n type (-'a, -'b, 'r) fn2 = 'a -> 'b -> 'r [@@deriving quickcheck]\n type (-'a, -'b, -'c, 'r) fn3 = 'a -> 'b -> 'c -> 'r [@@deriving quickcheck]\n type (-'a, -'b, -'c, -'d, 'r) fn4 = 'a -> 'b -> 'c -> 'd -> 'r [@@deriving quickcheck]\n\n type (-'a, -'b, -'c, -'d, -'e, 'r) fn5 = 'a -> 'b -> 'c -> 'd -> 'e -> 'r\n [@@deriving quickcheck]\n\n type (-'a, -'b, -'c, -'d, -'e, -'f, 'r) fn6 = 'a -> 'b -> 'c -> 'd -> 'e -> 'f -> 'r\n [@@deriving quickcheck]\nend\n\nmodule Observer = struct\n include Observer\n\n let of_hash (type a) (module M : Deriving_hash with type t = a) =\n of_hash_fold M.hash_fold_t\n ;;\n\n let variant2 = Polymorphic_types.quickcheck_observer_variant2\n let variant3 = Polymorphic_types.quickcheck_observer_variant3\n let variant4 = Polymorphic_types.quickcheck_observer_variant4\n let variant5 = Polymorphic_types.quickcheck_observer_variant5\n let variant6 = Polymorphic_types.quickcheck_observer_variant6\n let tuple2 = Polymorphic_types.quickcheck_observer_tuple2\n let tuple3 = Polymorphic_types.quickcheck_observer_tuple3\n let tuple4 = Polymorphic_types.quickcheck_observer_tuple4\n let tuple5 = Polymorphic_types.quickcheck_observer_tuple5\n let tuple6 = Polymorphic_types.quickcheck_observer_tuple6\n let of_predicate a b ~f = unmap (variant2 a b) ~f:(fun x -> if f x then `A x else `B x)\n let singleton () = opaque\n let doubleton f = of_predicate (singleton ()) (singleton ()) ~f\n let enum _ ~f = unmap int ~f\n\n let of_list list ~equal =\n let f x =\n match List.findi list ~f:(fun _ y -> equal x y) with\n | None -> failwith \"Quickcheck.Observer.of_list: value not found\"\n | Some (i, _) -> i\n in\n enum (List.length list) ~f\n ;;\n\n let of_fun f = create (fun x ~size ~hash -> observe (f ()) x ~size ~hash)\n\n let comparison ~compare ~eq ~lt ~gt =\n unmap\n (variant3 lt (singleton ()) gt)\n ~f:(fun x ->\n let c = compare x eq in\n if c < 0 then `A x else if c > 0 then `C x else `B x)\n ;;\nend\n\nmodule Generator = struct\n include Generator\n open Let_syntax\n\n let singleton = return\n\n let doubleton x y =\n create (fun ~size:_ ~random -> if Splittable_random.bool random then x else y)\n ;;\n\n let of_fun f = create (fun ~size ~random -> generate (f ()) ~size ~random)\n\n let of_sequence ~p seq =\n if Float.( <= ) p 0. || Float.( > ) p 1.\n then\n failwith (Printf.sprintf \"Generator.of_sequence: probability [%f] out of bounds\" p);\n Sequence.delayed_fold\n seq\n ~init:()\n ~finish:(fun () -> failwith \"Generator.of_sequence: ran out of values\")\n ~f:(fun () x ~k -> weighted_union [ p, singleton x; 1. -. p, of_fun k ])\n ;;\n\n let rec bounded_geometric ~p ~maximum init =\n if init = maximum\n then singleton maximum\n else\n weighted_union\n [ p, singleton init\n ; 1. -. p, of_fun (fun () -> bounded_geometric ~p ~maximum (init + 1))\n ]\n ;;\n\n let geometric ~p init = bounded_geometric ~p ~maximum:Int.max_value init\n let small_non_negative_int = small_positive_or_zero_int\n let small_positive_int = small_strictly_positive_int\n let list_with_length length t = list_with_length t ~length\n let variant2 = Polymorphic_types.quickcheck_generator_variant2\n let variant3 = Polymorphic_types.quickcheck_generator_variant3\n let variant4 = Polymorphic_types.quickcheck_generator_variant4\n let variant5 = Polymorphic_types.quickcheck_generator_variant5\n let variant6 = Polymorphic_types.quickcheck_generator_variant6\n let tuple2 = Polymorphic_types.quickcheck_generator_tuple2\n let tuple3 = Polymorphic_types.quickcheck_generator_tuple3\n let tuple4 = Polymorphic_types.quickcheck_generator_tuple4\n let tuple5 = Polymorphic_types.quickcheck_generator_tuple5\n let tuple6 = Polymorphic_types.quickcheck_generator_tuple6\n let fn2 = Polymorphic_types.quickcheck_generator_fn2\n let fn3 = Polymorphic_types.quickcheck_generator_fn3\n let fn4 = Polymorphic_types.quickcheck_generator_fn4\n let fn5 = Polymorphic_types.quickcheck_generator_fn5\n let fn6 = Polymorphic_types.quickcheck_generator_fn6\n\n let compare_fn dom =\n fn dom int >>| fun get_index x y -> [%compare: int] (get_index x) (get_index y)\n ;;\n\n let equal_fn dom = compare_fn dom >>| fun cmp x y -> Int.( = ) (cmp x y) 0\nend\n\nmodule Shrinker = struct\n include Shrinker\n\n let empty () = atomic\n let variant2 = Polymorphic_types.quickcheck_shrinker_variant2\n let variant3 = Polymorphic_types.quickcheck_shrinker_variant3\n let variant4 = Polymorphic_types.quickcheck_shrinker_variant4\n let variant5 = Polymorphic_types.quickcheck_shrinker_variant5\n let variant6 = Polymorphic_types.quickcheck_shrinker_variant6\n let tuple2 = Polymorphic_types.quickcheck_shrinker_tuple2\n let tuple3 = Polymorphic_types.quickcheck_shrinker_tuple3\n let tuple4 = Polymorphic_types.quickcheck_shrinker_tuple4\n let tuple5 = Polymorphic_types.quickcheck_shrinker_tuple5\n let tuple6 = Polymorphic_types.quickcheck_shrinker_tuple6\nend\n\nmodule Let_syntax = struct\n module Let_syntax = struct\n include Generator\n module Open_on_rhs = Generator\n end\n\n include Generator.Monad_infix\n\n let return = Generator.return\nend\n\nmodule Configure (Config : Quickcheck_config) = struct\n include Config\n\n let nondeterministic_state = lazy (Random.State.make_self_init ())\n\n let random_state_of_seed seed =\n match seed with\n | `Nondeterministic -> Splittable_random.State.create (force nondeterministic_state)\n | `Deterministic str -> Splittable_random.State.of_int ([%hash: string] str)\n ;;\n\n let make_seed seed : Test.Config.Seed.t =\n match seed with\n | `Nondeterministic -> Nondeterministic\n | `Deterministic string -> Deterministic string\n ;;\n\n let make_shrink_count = function\n | `Exhaustive -> Int.max_value\n | `Limit n -> n\n ;;\n\n let make_config ~seed ~sizes ~trials ~shrink_attempts : Test.Config.t =\n { seed = make_seed (Option.value seed ~default:default_seed)\n ; sizes = Option.value sizes ~default:default_sizes\n ; test_count = Option.value trials ~default:default_trial_count\n ; shrink_count =\n make_shrink_count (Option.value shrink_attempts ~default:default_shrink_attempts)\n }\n ;;\n\n let make_test_m (type a) ~gen ~shrinker ~sexp_of : (module Test.S with type t = a) =\n let module M = struct\n type t = a\n\n let quickcheck_generator = gen\n let quickcheck_shrinker = Option.value shrinker ~default:Shrinker.atomic\n let sexp_of_t = Option.value sexp_of ~default:[%sexp_of: _]\n end\n in\n (module M)\n ;;\n\n let random_value ?(seed = default_seed) ?(size = 30) gen =\n let random = random_state_of_seed seed in\n Generator.generate gen ~size ~random\n ;;\n\n let random_sequence ?seed ?sizes gen =\n let config =\n make_config ~seed ~sizes ~trials:(Some Int.max_value) ~shrink_attempts:None\n in\n let return = ref Sequence.empty in\n Test.with_sample_exn ~config gen ~f:(fun sequence -> return := sequence);\n !return\n ;;\n\n let iter ?seed ?sizes ?trials gen ~f =\n let config = make_config ~seed ~sizes ~trials ~shrink_attempts:None in\n Test.with_sample_exn ~config gen ~f:(fun sequence -> Sequence.iter sequence ~f)\n ;;\n\n let test ?seed ?sizes ?trials ?shrinker ?shrink_attempts ?sexp_of ?examples gen ~f =\n let config = make_config ~seed ~sizes ~trials ~shrink_attempts in\n let test_m = make_test_m ~gen ~shrinker ~sexp_of in\n Test.run_exn ~config ?examples ~f test_m\n ;;\n\n let test_or_error\n ?seed\n ?sizes\n ?trials\n ?shrinker\n ?shrink_attempts\n ?sexp_of\n ?examples\n gen\n ~f\n =\n let config = make_config ~seed ~sizes ~trials ~shrink_attempts in\n let test_m = make_test_m ~gen ~shrinker ~sexp_of in\n Test.run ~config ?examples ~f test_m\n ;;\n\n let test_distinct_values\n (type key)\n ?seed\n ?sizes\n ?sexp_of\n gen\n ~trials\n ~distinct_values\n ~compare\n =\n let module S =\n Caml.Set.Make (struct\n type t = key\n\n let compare = compare\n end)\n in\n let fail set =\n let expect_count = distinct_values in\n let actual_count = S.cardinal set in\n let values =\n match sexp_of with\n | None -> None\n | Some sexp_of_elt -> Some [%sexp (S.elements set : elt list)]\n in\n raise_s\n [%message\n \"insufficient distinct values\"\n (trials : int)\n (expect_count : int)\n (actual_count : int)\n (values : (Base.Sexp.t option[@sexp.option]))]\n in\n with_return (fun r ->\n let set = ref S.empty in\n iter ?seed ?sizes ~trials gen ~f:(fun elt ->\n set := S.add elt !set;\n if S.cardinal !set >= distinct_values then r.return ());\n fail !set)\n ;;\n\n let test_can_generate\n ?seed\n ?sizes\n ?(trials = default_can_generate_trial_count)\n ?sexp_of\n gen\n ~f\n =\n let r = ref [] in\n let f_and_enqueue return x = if f x then return `Can_generate else r := x :: !r in\n match\n With_return.with_return (fun return ->\n iter ?seed ?sizes ~trials gen ~f:(f_and_enqueue return.return);\n `Cannot_generate)\n with\n | `Can_generate -> ()\n | `Cannot_generate ->\n (match sexp_of with\n | None -> failwith \"cannot generate\"\n | Some sexp_of_value ->\n Error.raise_s [%message \"cannot generate\" ~attempts:(!r : value list)])\n ;;\nend\n\ninclude Configure (struct\n let default_seed = `Deterministic \"an arbitrary but deterministic string\"\n\n let default_trial_count =\n match Word_size.word_size with\n | W64 -> 10_000\n | W32 -> 1_000\n ;;\n\n let default_can_generate_trial_count = 10_000\n let default_shrink_attempts = `Limit 1000\n\n let default_sizes =\n Sequence.cycle_list_exn (List.range 0 30 ~stop:`inclusive)\n ;;\n end)\n\nmodule type S = S\nmodule type S1 = S1\nmodule type S2 = S2\nmodule type S_int = S_int\nmodule type S_range = S_range\n\ntype nonrec seed = seed\ntype nonrec shrink_attempts = shrink_attempts\n\nmodule type Quickcheck_config = Quickcheck_config\nmodule type Quickcheck_configured = Quickcheck_configured\n","(* We don't just include Sexplib.Std because one can only define Hashtbl once in this\n module. *)\n\nopen! Import\n\n(** [include]d first so that everything else shadows it *)\ninclude Core_pervasives\n\ninclude Int.Replace_polymorphic_compare\ninclude Base_quickcheck.Export\ninclude Deprecate_pipe_bang\ninclude Either.Export\ninclude From_sexplib\ninclude Interfaces\ninclude List.Infix\ninclude Never_returns\ninclude Ordering.Export\ninclude Perms.Export\ninclude Result.Export\n\ntype -'a return = 'a With_return.return = private { return : 'b. 'a -> 'b } [@@unboxed]\n\ninclude struct\n exception Bug of string [@deprecated \"[since 2020-03] Don't use [Bug]\"]\n [@@deriving sexp]\nend [@@alert \"-deprecated\"]\n\n\n(** Raised if malloc in C bindings fail (errno * size). *)\nexception C_malloc_exn of int * int\n\n(* errno, size *)\nlet () = Callback.register_exception \"C_malloc_exn\" (C_malloc_exn (0, 0))\n\nexception Finally = Exn.Finally\n\nlet fst3 (x, _, _) = x\nlet snd3 (_, y, _) = y\nlet trd3 (_, _, z) = z\n\nlet[@deprecated \"[since 2018-12] Use [Option.value_exn]\"] uw = function\n | Some x -> x\n | None ->\n raise Caml.Not_found\n;;\n\n(** [phys_same] is like [phys_equal], but with a more general type. [phys_same] is useful\n when dealing with existential types, when one has a packed value and an unpacked value\n that one wants to check are physically equal. One can't use [phys_equal] in such a\n situation because the types are different. *)\nlet phys_same (type a b) (a : a) (b : b) = phys_equal a (Obj.magic b : a)\n\nlet ( % ) = Int.( % )\nlet ( /% ) = Int.( /% )\nlet ( // ) = Int.( // )\nlet ( ==> ) a b = (not a) || b\nlet bprintf = Printf.bprintf\nlet const = Fn.const\nlet eprintf = Printf.eprintf\nlet error = Or_error.error\nlet error_s = Or_error.error_s\nlet failwithf = Base.Printf.failwithf\n\nlet failwithp =\n (Error.failwithp [@alert \"-deprecated\"])\n[@@deprecated \"[since 2020-03] Use [failwiths] instead.\"]\n;;\n\nlet failwiths = Error.failwiths\nlet force = Base.Lazy.force\nlet fprintf = Printf.fprintf\nlet ident = Fn.id\n\nlet invalid_argf = Base.Printf.invalid_argf\nlet ifprintf = Printf.ifprintf\nlet is_none = Option.is_none\nlet is_some = Option.is_some\nlet ksprintf = Printf.ksprintf\nlet ok_exn = Or_error.ok_exn\nlet phys_equal = Base.phys_equal\nlet phys_same = phys_same\nlet print_s = Stdio.print_s\nlet eprint_s = Stdio.eprint_s\nlet printf = Printf.printf\nlet protect = Exn.protect\nlet protectx = Exn.protectx\nlet raise_s = Error.raise_s\nlet round = Float.round\nlet ( **. ) = Base.( **. )\n\nlet sprintf = Printf.sprintf\nlet stage = Staged.stage\nlet unstage = Staged.unstage\nlet with_return = With_return.with_return\nlet with_return_option = With_return.with_return_option\n\n(* With the following aliases, we are just making extra sure that the toplevel sexp\n converters line up with the ones in our modules. *)\n\n\ninclude Typerep_lib.Std_internal\n\ninclude (\nstruct\n (* [deriving hash] is missing for [array], [bytes], and [ref] since these types are\n mutable. *)\n type 'a array = 'a Array.t\n [@@deriving bin_io, compare, equal, sexp, sexp_grammar, typerep]\n\n type bool = Bool.t\n [@@deriving bin_io, compare, hash, equal, sexp, sexp_grammar, typerep]\n\n type char = Char.t\n [@@deriving bin_io, compare, hash, equal, sexp, sexp_grammar, typerep]\n\n type float = Float.t\n [@@deriving bin_io, compare, hash, equal, sexp, sexp_grammar, typerep]\n\n type int = Int.t\n [@@deriving bin_io, compare, hash, equal, sexp, sexp_grammar, typerep]\n\n type int32 = Int32.t\n [@@deriving bin_io, compare, hash, equal, sexp, sexp_grammar, typerep]\n\n type int64 = Int64.t\n [@@deriving bin_io, compare, hash, equal, sexp, sexp_grammar, typerep]\n\n type 'a lazy_t = 'a Lazy.t\n [@@deriving bin_io, compare, hash, sexp, sexp_grammar, typerep]\n\n type 'a list = 'a List.t\n [@@deriving bin_io, compare, hash, equal, sexp, sexp_grammar, typerep]\n\n type nativeint = Nativeint.t\n [@@deriving bin_io, compare, equal, hash, sexp, sexp_grammar, typerep]\n\n type 'a option = 'a Option.t\n [@@deriving bin_io, compare, equal, hash, sexp, sexp_grammar, typerep]\n\n type string = String.t\n [@@deriving bin_io, compare, equal, hash, sexp, sexp_grammar, typerep]\n\n type bytes = Bytes.t [@@deriving bin_io, compare, equal, sexp, sexp_grammar, typerep]\n\n type 'a ref = 'a Ref.t\n [@@deriving bin_io, compare, equal, sexp, sexp_grammar, typerep]\n\n type unit = Unit.t\n [@@deriving bin_io, compare, equal, hash, sexp, sexp_grammar, typerep]\n\n (* Bin_prot has optimized functions for float arrays *)\n type float_array = Bin_prot.Std.float_array [@@deriving bin_io]\n\n include (\n struct\n type float_array = Float.t array\n [@@deriving compare, sexp, sexp_grammar, typerep]\n end :\n sig\n type float_array [@@deriving compare, sexp, sexp_grammar, typerep]\n end\n with type float_array := float_array)\nend :\nsig\n type 'a array [@@deriving bin_io, compare, equal, sexp, sexp_grammar, typerep]\n type bool [@@deriving bin_io, compare, equal, hash, sexp, sexp_grammar, typerep]\n type char [@@deriving bin_io, compare, equal, hash, sexp, sexp_grammar, typerep]\n type float [@@deriving bin_io, compare, equal, hash, sexp, sexp_grammar, typerep]\n type int [@@deriving bin_io, compare, equal, hash, sexp, sexp_grammar, typerep]\n type int32 [@@deriving bin_io, compare, equal, hash, sexp, sexp_grammar, typerep]\n type int64 [@@deriving bin_io, compare, equal, hash, sexp, sexp_grammar, typerep]\n type 'a lazy_t [@@deriving bin_io, compare, hash, sexp, sexp_grammar, typerep]\n type 'a list [@@deriving bin_io, compare, equal, hash, sexp, sexp_grammar, typerep]\n\n type nativeint\n [@@deriving bin_io, compare, equal, hash, sexp, sexp_grammar, typerep]\n\n type 'a option\n [@@deriving bin_io, compare, equal, hash, sexp, sexp_grammar, typerep]\n\n type string [@@deriving bin_io, compare, equal, hash, sexp, sexp_grammar, typerep]\n type bytes [@@deriving bin_io, compare, equal, sexp, sexp_grammar, typerep]\n type 'a ref [@@deriving bin_io, compare, equal, sexp, sexp_grammar, typerep]\n type unit [@@deriving bin_io, compare, equal, hash, sexp, sexp_grammar, typerep]\n\n type float_array = float array\n [@@deriving bin_io, compare, sexp, sexp_grammar, typerep]\nend\nwith type 'a array := 'a array\nwith type bool := bool\nwith type char := char\nwith type float := float\nwith type int := int\nwith type int32 := int32\nwith type int64 := int64\nwith type 'a list := 'a list\nwith type nativeint := nativeint\nwith type 'a option := 'a option\nwith type string := string\nwith type bytes := bytes\nwith type 'a lazy_t := 'a lazy_t\nwith type 'a ref := 'a ref\nwith type unit := unit)\n\nlet sexp_of_exn = Exn.sexp_of_t\n\n\n(* The below declarations define converters for the special types recognized by pa-sexp.\n E.g. this allows the following to work:\n\n type t = { foo : int sexp_option } [@@deriving bin_io, compare, hash, sexp] *)\ninclude struct\n [@@@ocaml.warning \"-3\"]\n\n type 'a sexp_array = 'a array\n [@@deriving bin_io, compare, typerep]\n [@@deprecated \"[since 2019-03] use [@sexp.array] instead\"]\n\n type sexp_bool = bool\n [@@deriving bin_io, compare, hash, typerep]\n [@@deprecated \"[since 2019-03] use [@sexp.bool] instead\"]\n\n type 'a sexp_list = 'a list\n [@@deriving bin_io, compare, hash, typerep]\n [@@deprecated \"[since 2019-03] use [@sexp.list] instead\"]\n\n type 'a sexp_option = 'a option\n [@@deriving bin_io, compare, hash, typerep]\n [@@deprecated \"[since 2019-03] use [@sexp.option] instead\"]\n\n type 'a sexp_opaque = 'a\n [@@deriving bin_io, compare, hash, typerep]\n [@@deprecated \"[since 2019-03] use [@sexp.opaque] instead\"]\nend\n\n(* The code below checks that the signatures in core_map.mli and core_set.mli are\n consistent with the generic map and set signatures defined in map_intf.ml\n and core_set_intf.ml. *)\n\nlet () =\n let module T = struct\n type 'a elt = 'a\n type 'a cmp = 'a\n end\n in\n let module M : sig\n open Set_intf\n\n module Tree : sig\n type ('a, 'b) t\n\n include\n Creators_and_accessors2_with_comparator\n with type ('a, 'b) set := ('a, 'b) t\n with type ('a, 'b) t := ('a, 'b) t\n with type ('a, 'b) tree := ('a, 'b) t\n with type ('a, 'b) named := ('a, 'b) Tree.Named.t\n end\n\n type ('a, 'b) t\n\n include\n Accessors2\n with type ('a, 'b) t := ('a, 'b) t\n with type ('a, 'b) tree := ('a, 'b) Tree.t\n with type ('a, 'b) named := ('a, 'b) Named.t\n\n include\n Creators_generic\n with type ('a, 'b) set := ('a, 'b) t\n with type ('a, 'b) t := ('a, 'b) t\n with type ('a, 'b) tree := ('a, 'b) Tree.t\n with type 'a elt := 'a T.elt\n with type 'a cmp := 'a T.cmp\n with type ('a, 'cmp, 'z) options :=\n ('a, 'cmp, 'z) Set_intf.With_first_class_module.t\n end =\n Set\n in\n ()\n;;\n\nlet () =\n let module T = struct\n type 'k key = 'k\n type 'c cmp = 'c\n end\n in\n let module M : sig\n open Map_intf\n\n module Tree : sig\n type ('a, 'b, 'c) t\n\n include\n Creators_and_accessors3_with_comparator\n with type ('a, 'b, 'c) t := ('a, 'b, 'c) t\n with type ('a, 'b, 'c) tree := ('a, 'b, 'c) t\n end\n\n type ('a, 'b, 'c) t\n\n include\n Accessors3\n with type ('a, 'b, 'c) t := ('a, 'b, 'c) t\n with type ('a, 'b, 'c) tree := ('a, 'b, 'c) Tree.t\n\n include\n Creators_generic\n with type ('a, 'b, 'c) t := ('a, 'b, 'c) t\n with type ('a, 'b, 'c) tree := ('a, 'b, 'c) Tree.t\n with type ('a, 'cmp, 'z) options :=\n ('a, 'cmp, 'z) Map_intf.With_first_class_module.t\n with type 'k key := 'k T.key\n with type 'c cmp := 'c T.cmp\n end =\n Map\n in\n ()\n;;\n\n","open! Import\nopen Std_internal\nopen! Int.Replace_polymorphic_compare\n\nmodule Stable = struct\n module V1 = struct\n module Parts = struct\n type t =\n { sign : Sign.t\n ; hr : int\n ; min : int\n ; sec : int\n ; ms : int\n ; us : int\n ; ns : int\n }\n [@@deriving compare, sexp]\n end\n\n module type Like_a_float = sig\n type t [@@deriving bin_io, hash, quickcheck, typerep]\n\n include Comparable.S_common with type t := t\n include Comparable.With_zero with type t := t\n include Floatable with type t := t\n\n val ( + ) : t -> t -> t\n val ( - ) : t -> t -> t\n val zero : t\n val robust_comparison_tolerance : t\n val abs : t -> t\n val neg : t -> t\n val scale : t -> float -> t\n end\n\n module T : sig\n type underlying = float [@@deriving hash]\n type t = private underlying [@@deriving bin_io, hash]\n\n include Like_a_float with type t := t\n include Robustly_comparable with type t := t\n\n module Constant : sig\n val nanoseconds_per_second : float\n val microseconds_per_second : float\n val milliseconds_per_second : float\n val nanosecond : t\n val microsecond : t\n val millisecond : t\n val second : t\n val minute : t\n val hour : t\n val day : t\n end\n\n val to_parts : t -> Parts.t\n val next : t -> t\n val prev : t -> t\n end = struct\n type underlying = float [@@deriving hash]\n type t = underlying [@@deriving hash]\n\n let next t = Float.one_ulp `Up t\n let prev t = Float.one_ulp `Down t\n\n (* IF THIS REPRESENTATION EVER CHANGES, ENSURE THAT EITHER\n (1) all values serialize the same way in both representations, or\n (2) you add a new Time.Span version to stable.ml *)\n include (\n struct\n include Float\n\n let sign = sign_exn\n end :\n Like_a_float with type t := t)\n\n (* due to precision limitations in float we can't expect better than microsecond\n precision *)\n include Float.Robust_compare.Make (struct\n let robust_comparison_tolerance = 1E-6\n end)\n\n (* this prevents any worry about having these very common names redefined below and\n makes their usage within this module safer. Constant is included at the very\n bottom to re-export these constants in a more convenient way *)\n module Constant = struct\n let nanoseconds_per_second = 1E9\n let microseconds_per_second = 1E6\n let milliseconds_per_second = 1E3\n\n (* spans are stored as a float in seconds *)\n let nanosecond = of_float (1. /. nanoseconds_per_second)\n let microsecond = of_float (1. /. microseconds_per_second)\n let millisecond = of_float (1. /. milliseconds_per_second)\n let second = of_float 1.\n let minute = of_float 60.\n let hour = of_float (60. *. 60.)\n let day = of_float (24. *. 60. *. 60.)\n end\n\n\n let to_parts t : Parts.t =\n let sign = Float.sign_exn t in\n let t = abs t in\n let integral = Float.round_down t in\n let fractional = t -. integral in\n let seconds = Float.iround_down_exn integral in\n let nanoseconds = Float.iround_nearest_exn (fractional *. 1E9) in\n let seconds, nanoseconds =\n if Int.equal nanoseconds 1_000_000_000\n then Int.succ seconds, 0\n else seconds, nanoseconds\n in\n let sec = seconds mod 60 in\n let minutes = seconds / 60 in\n let min = minutes mod 60 in\n let hr = minutes / 60 in\n let ns = nanoseconds mod 1000 in\n let microseconds = nanoseconds / 1000 in\n let us = microseconds mod 1000 in\n let milliseconds = microseconds / 1000 in\n let ms = milliseconds in\n { sign; hr; min; sec; ms; us; ns }\n ;;\n end\n\n let ( / ) t f = T.of_float ((t : T.t :> float) /. f)\n let ( // ) (f : T.t) (t : T.t) = (f :> float) /. (t :> float)\n\n (* Multiplying by 1E3 is more accurate than division by 1E-3 *)\n let to_ns (x : T.t) = (x :> float) *. T.Constant.nanoseconds_per_second\n let to_us (x : T.t) = (x :> float) *. T.Constant.microseconds_per_second\n let to_ms (x : T.t) = (x :> float) *. T.Constant.milliseconds_per_second\n let to_sec (x : T.t) = (x :> float)\n let to_min x = x // T.Constant.minute\n let to_hr x = x // T.Constant.hour\n let to_day x = x // T.Constant.day\n let to_int63_seconds_round_down_exn x = Float.int63_round_down_exn (to_sec x)\n let ( ** ) f (t : T.t) = T.of_float (f *. (t :> float))\n\n (* Division by 1E3 is more accurate than multiplying by 1E-3 *)\n let of_ns x = T.of_float (x /. T.Constant.nanoseconds_per_second)\n let of_us x = T.of_float (x /. T.Constant.microseconds_per_second)\n let of_ms x = T.of_float (x /. T.Constant.milliseconds_per_second)\n let of_sec x = T.of_float x\n let of_int_sec x = of_sec (Float.of_int x)\n let of_int32_seconds sec = of_sec (Int32.to_float sec)\n\n (* Note that [Int63.to_float] can lose precision, but only on inputs large enough that\n [of_sec] in either the Time_ns or Time_float case would lose precision (or just be\n plain out of bounds) anyway. *)\n let of_int63_seconds sec = of_sec (Int63.to_float sec)\n let of_min x = x ** T.Constant.minute\n let of_hr x = x ** T.Constant.hour\n let of_day x = x ** T.Constant.day\n\n let divide_by_unit_of_time t unit_of_time =\n match (unit_of_time : Unit_of_time.t) with\n | Nanosecond -> to_ns t\n | Microsecond -> to_us t\n | Millisecond -> to_ms t\n | Second -> to_sec t\n | Minute -> to_min t\n | Hour -> to_hr t\n | Day -> to_day t\n ;;\n\n let scale_by_unit_of_time float unit_of_time =\n match (unit_of_time : Unit_of_time.t) with\n | Nanosecond -> of_ns float\n | Microsecond -> of_us float\n | Millisecond -> of_ms float\n | Second -> of_sec float\n | Minute -> of_min float\n | Hour -> of_hr float\n | Day -> of_day float\n ;;\n\n let create\n ?(sign = Sign.Pos)\n ?(day = 0)\n ?(hr = 0)\n ?(min = 0)\n ?(sec = 0)\n ?(ms = 0)\n ?(us = 0)\n ?(ns = 0)\n ()\n =\n let ( + ) = T.( + ) in\n let t =\n of_day (Float.of_int day)\n + of_hr (Float.of_int hr)\n + of_min (Float.of_int min)\n + of_sec (Float.of_int sec)\n + of_ms (Float.of_int ms)\n + of_us (Float.of_int us)\n + of_ns (Float.of_int ns)\n in\n match sign with\n | Neg -> T.( - ) T.zero t\n | Pos | Zero -> t\n ;;\n\n include T\n include Constant\n\n let randomize t ~percent = Span_helpers.randomize t ~percent ~scale\n\n let to_short_string t =\n let ({ sign; hr; min; sec; ms; us; ns } : Parts.t) = to_parts t in\n Span_helpers.short_string ~sign ~hr ~min ~sec ~ms ~us ~ns\n ;;\n\n (* WARNING: if you are going to change this function in any material way, make sure\n you update Stable appropriately. *)\n let of_string_v1_v2 (s : string) ~is_v2 =\n try\n match s with\n | \"\" -> failwith \"empty string\"\n | _ ->\n let float n =\n match String.drop_suffix s n with\n | \"\" -> failwith \"no number given\"\n | s ->\n let v = Float.of_string s in\n Validate.maybe_raise (Float.validate_ordinary v);\n v\n in\n let len = String.length s in\n (match s.[Int.( - ) len 1] with\n | 's' ->\n if Int.( >= ) len 2 && Char.( = ) s.[Int.( - ) len 2] 'm'\n then of_ms (float 2)\n else if is_v2 && Int.( >= ) len 2 && Char.( = ) s.[Int.( - ) len 2] 'u'\n then of_us (float 2)\n else if is_v2 && Int.( >= ) len 2 && Char.( = ) s.[Int.( - ) len 2] 'n'\n then of_ns (float 2)\n else T.of_float (float 1)\n | 'm' -> of_min (float 1)\n | 'h' -> of_hr (float 1)\n | 'd' -> of_day (float 1)\n | _ ->\n if is_v2\n then failwith \"Time spans must end in ns, us, ms, s, m, h, or d.\"\n else failwith \"Time spans must end in ms, s, m, h, or d.\")\n with\n | exn ->\n invalid_argf \"Span.of_string could not parse '%s': %s\" s (Exn.to_string exn) ()\n ;;\n\n let of_sexp_error_exn exn sexp = of_sexp_error (Exn.to_string exn) sexp\n\n exception T_of_sexp of Sexp.t * exn [@@deriving sexp]\n exception T_of_sexp_expected_atom_but_got of Sexp.t [@@deriving sexp]\n\n let t_of_sexp_v1_v2 sexp ~is_v2 =\n match sexp with\n | Sexp.Atom x ->\n (try of_string_v1_v2 x ~is_v2 with\n | exn -> of_sexp_error_exn (T_of_sexp (sexp, exn)) sexp)\n | Sexp.List _ -> of_sexp_error_exn (T_of_sexp_expected_atom_but_got sexp) sexp\n ;;\n\n let string ~is_v2 suffix float =\n if is_v2\n (* This is the same float-to-string conversion used in [Float.sexp_of_t]. It's like\n [Float.to_string], but may leave off trailing period. *)\n then !Sexplib.Conv.default_string_of_float float ^ suffix\n else sprintf \"%g%s\" float suffix\n ;;\n\n (* WARNING: if you are going to change this function in any material way, make sure\n you update Stable appropriately. *)\n (* I'd like it to be the case that you could never construct an infinite span, but I\n can't think of a good way to enforce it. So this to_string function can produce\n strings that will raise an exception when they are fed to of_string *)\n let to_string_v1_v2 (t : T.t) ~is_v2 =\n (* this is a sad broken abstraction... *)\n let module C = Float.Class in\n match Float.classify (t :> float) with\n | C.Subnormal | C.Zero -> \"0s\"\n | C.Infinite -> if T.( > ) t T.zero then \"inf\" else \"-inf\"\n | C.Nan -> \"nan\"\n | C.Normal ->\n let ( < ) = T.( < ) in\n let abs_t = T.of_float (Float.abs (t :> float)) in\n if is_v2 && abs_t < T.Constant.microsecond\n then string ~is_v2 \"ns\" (to_ns t)\n else if is_v2 && abs_t < T.Constant.millisecond\n then string ~is_v2 \"us\" (to_us t)\n else if abs_t < T.Constant.second\n then string ~is_v2 \"ms\" (to_ms t)\n else if abs_t < T.Constant.minute\n then string ~is_v2 \"s\" (to_sec t)\n else if abs_t < T.Constant.hour\n then string ~is_v2 \"m\" (to_min t)\n else if abs_t < T.Constant.day\n then string ~is_v2 \"h\" (to_hr t)\n else string ~is_v2 \"d\" (to_day t)\n ;;\n\n let sexp_of_t_v1_v2 t ~is_v2 = Sexp.Atom (to_string_v1_v2 t ~is_v2)\n let t_of_sexp sexp = t_of_sexp_v1_v2 sexp ~is_v2:false\n let sexp_of_t t = sexp_of_t_v1_v2 t ~is_v2:false\n end\n\n module V2 = struct\n include V1\n\n let t_of_sexp sexp = t_of_sexp_v1_v2 sexp ~is_v2:true\n let sexp_of_t t = sexp_of_t_v1_v2 t ~is_v2:true\n end\n\n module V3 = struct\n include V1\n\n let to_unit_of_time t : Unit_of_time.t =\n let open T in\n let open Constant in\n let abs_t = T.abs t in\n if abs_t >= day\n then Day\n else if abs_t >= hour\n then Hour\n else if abs_t >= minute\n then Minute\n else if abs_t >= second\n then Second\n else if abs_t >= millisecond\n then Millisecond\n else if abs_t >= microsecond\n then Microsecond\n else Nanosecond\n ;;\n\n let of_unit_of_time : Unit_of_time.t -> T.t =\n let open T.Constant in\n function\n | Nanosecond -> nanosecond\n | Microsecond -> microsecond\n | Millisecond -> millisecond\n | Second -> second\n | Minute -> minute\n | Hour -> hour\n | Day -> day\n ;;\n\n let suffix_of_unit_of_time unit_of_time =\n match (unit_of_time : Unit_of_time.t) with\n | Nanosecond -> \"ns\"\n | Microsecond -> \"us\"\n | Millisecond -> \"ms\"\n | Second -> \"s\"\n | Minute -> \"m\"\n | Hour -> \"h\"\n | Day -> \"d\"\n ;;\n\n module Of_string = struct\n let invalid_string string ~reason =\n let message = \"Time.Span.of_string: \" ^ reason in\n raise_s [%message message string]\n ;;\n\n let rec find_unit_of_time_by_suffix string ~index unit_of_time_list =\n match unit_of_time_list with\n | [] -> invalid_string string ~reason:\"invalid span part suffix\"\n | unit_of_time :: rest ->\n let suffix = suffix_of_unit_of_time unit_of_time in\n if String.is_substring_at string ~pos:index ~substring:suffix\n then unit_of_time\n else find_unit_of_time_by_suffix string ~index rest\n ;;\n\n let parse_suffix string ~index =\n (* We rely on the fact that \"ms\" comes before \"m\" in [Unit_of_time.all] to get a\n correct match on millisecond timestamps. This assumption is demonstrated in the\n expect test below. *)\n find_unit_of_time_by_suffix string ~index Unit_of_time.all\n ;;\n\n (* We validate magnitude strings so that we know where the unit-of-time suffix\n begins, and so that only sensible strings are allowed. We do not want to be as\n permissive as [Float.of_string]; for example, hexadecimal span magnitudes are not\n allowed. After validation, we still use [Float.of_string] to produce the actual\n value. *)\n module Float_parser = struct\n (* [In_decimal_have_digit] includes having a digit before the decimal point. *)\n type state =\n | In_integer_need_digit\n | In_integer_have_digit\n | In_decimal_need_digit\n | In_decimal_have_digit\n | In_exponent_need_digit_or_sign\n | In_exponent_need_digit\n | In_exponent_have_digit\n\n type token =\n | Digit\n | Point\n | Under\n | Sign\n | Expt\n\n let state_is_final = function\n | In_integer_have_digit | In_decimal_have_digit | In_exponent_have_digit ->\n true\n | In_integer_need_digit\n | In_decimal_need_digit\n | In_exponent_need_digit_or_sign\n | In_exponent_need_digit -> false\n ;;\n\n let token_of_char = function\n | '0' .. '9' -> Some Digit\n | '.' -> Some Point\n | '_' -> Some Under\n | '-' | '+' -> Some Sign\n | 'E' | 'e' -> Some Expt\n | _ -> None\n ;;\n\n let invalid_string string =\n invalid_string string ~reason:\"invalid span part magnitude\"\n ;;\n\n let rec find_index_after_float_in_state string ~index ~len ~state =\n let open Int.O in\n if index = len\n then if state_is_final state then index else invalid_string string\n else (\n match token_of_char string.[index] with\n | None -> if state_is_final state then index else invalid_string string\n | Some token ->\n let state =\n match state, token with\n | In_integer_need_digit, Digit -> In_integer_have_digit\n | In_integer_need_digit, Point -> In_decimal_need_digit\n | In_integer_need_digit, Under\n | In_integer_need_digit, Sign\n | In_integer_need_digit, Expt -> invalid_string string\n | In_integer_have_digit, Digit | In_integer_have_digit, Under ->\n In_integer_have_digit\n | In_integer_have_digit, Point -> In_decimal_have_digit\n | In_integer_have_digit, Expt -> In_exponent_need_digit_or_sign\n | In_integer_have_digit, Sign -> invalid_string string\n | In_decimal_need_digit, Digit -> In_decimal_have_digit\n | In_decimal_need_digit, Point\n | In_decimal_need_digit, Under\n | In_decimal_need_digit, Expt\n | In_decimal_need_digit, Sign -> invalid_string string\n | In_decimal_have_digit, Digit | In_decimal_have_digit, Under ->\n In_decimal_have_digit\n | In_decimal_have_digit, Expt -> In_exponent_need_digit_or_sign\n | In_decimal_have_digit, Point | In_decimal_have_digit, Sign ->\n invalid_string string\n | In_exponent_need_digit_or_sign, Digit -> In_exponent_have_digit\n | In_exponent_need_digit_or_sign, Sign -> In_exponent_need_digit\n | In_exponent_need_digit_or_sign, Point\n | In_exponent_need_digit_or_sign, Under\n | In_exponent_need_digit_or_sign, Expt -> invalid_string string\n | In_exponent_need_digit, Digit -> In_exponent_have_digit\n | In_exponent_need_digit, Point\n | In_exponent_need_digit, Under\n | In_exponent_need_digit, Expt\n | In_exponent_need_digit, Sign -> invalid_string string\n | In_exponent_have_digit, Digit | In_exponent_have_digit, Under ->\n In_exponent_have_digit\n | In_exponent_have_digit, Point\n | In_exponent_have_digit, Expt\n | In_exponent_have_digit, Sign -> invalid_string string\n in\n find_index_after_float_in_state string ~index:(index + 1) ~len ~state)\n ;;\n\n let find_index_after_float string ~index ~len =\n find_index_after_float_in_state string ~index ~len ~state:In_integer_need_digit\n ;;\n end\n\n let rec accumulate_magnitude string ~magnitude ~index ~len =\n if Int.equal index len\n then magnitude\n else (\n let suffix_index = Float_parser.find_index_after_float string ~index ~len in\n let unit_of_time = parse_suffix string ~index:suffix_index in\n let until_index =\n Int.( + ) suffix_index (String.length (suffix_of_unit_of_time unit_of_time))\n in\n let float_string =\n String.sub string ~pos:index ~len:(Int.( - ) suffix_index index)\n in\n let float = Float.of_string float_string in\n let magnitude = magnitude + scale_by_unit_of_time float unit_of_time in\n accumulate_magnitude string ~magnitude ~index:until_index ~len)\n ;;\n\n let parse_magnitude string ~index ~len =\n accumulate_magnitude string ~magnitude:T.zero ~index ~len\n ;;\n\n let of_string string =\n let open Int.O in\n match string with\n | \"NANs\" -> of_sec Float.nan\n | \"-INFs\" -> of_sec Float.neg_infinity\n | \"INFs\" -> of_sec Float.infinity\n | _ ->\n let len = String.length string in\n if len = 0 then invalid_string string ~reason:\"empty input\";\n let negative, index =\n match string.[0] with\n | '-' -> true, 1\n | '+' -> false, 1\n | _ -> false, 0\n in\n if index >= len then invalid_string string ~reason:\"empty input\";\n let magnitude = parse_magnitude string ~index ~len in\n if negative then T.neg magnitude else magnitude\n ;;\n end\n\n let of_string = Of_string.of_string\n\n module To_string = struct\n let string_of_float_without_trailing_decimal float =\n let string = Float.to_string float in\n let suffix = \".\" in\n if String.is_suffix string ~suffix\n then String.chop_suffix_exn string ~suffix\n else string\n ;;\n\n (* As we build up a string, we keep a running sum of the value that will be read\n back in, so that we can compute the remainder that needs to be generated. *)\n let sum ~sum_t ~unit_of_time ~magnitude =\n sum_t + scale_by_unit_of_time magnitude unit_of_time\n ;;\n\n (* For some units (very large numbers of days, or seconds and smaller) we just\n render a float directly, with a fix for roundoff error. *)\n let to_float_string ~abs_t ~unit_of_time ~fixup_unit_of_time =\n let magnitude = divide_by_unit_of_time abs_t unit_of_time in\n let sum_t = sum ~sum_t:zero ~unit_of_time ~magnitude in\n if sum_t = abs_t\n then\n string_of_float_without_trailing_decimal magnitude\n ^ suffix_of_unit_of_time unit_of_time\n else (\n let magnitude =\n if sum_t < abs_t\n then magnitude\n else divide_by_unit_of_time (prev abs_t) unit_of_time\n in\n let sum_t = sum ~sum_t:zero ~unit_of_time ~magnitude in\n let rem_t = abs_t - sum_t in\n let fixup_magnitude = divide_by_unit_of_time rem_t fixup_unit_of_time in\n string_of_float_without_trailing_decimal magnitude\n ^ suffix_of_unit_of_time unit_of_time\n (* [rem_t] is at ULP size of [abs_t], it needs just one bit of precision *)\n ^ sprintf \"%.1g\" fixup_magnitude\n ^ suffix_of_unit_of_time fixup_unit_of_time)\n ;;\n\n (* For non-decimal units (minutes and greater), we render an integer magnitude, and\n return that with the running sum so the remainder can be rendered at a smaller\n unit. *)\n let to_int_string_and_sum unit_of_time ~abs_t ~sum_t =\n let unit_span = of_unit_of_time unit_of_time in\n let rem_t = abs_t - sum_t in\n (* We calculate the approximate multiple of [unit_of_time] that needs to be\n added to [sum_t]. Due to rounding, this can be off by one (we've never seen a\n case off by two or more), so we re-compute the remainder and correct if\n necessary. *)\n let magnitude = Float.round_down (rem_t // unit_span) in\n let new_sum_t = sum ~sum_t ~unit_of_time ~magnitude in\n let new_rem_t = abs_t - new_sum_t in\n let magnitude =\n if new_rem_t = zero\n then magnitude\n else if new_rem_t < zero\n then magnitude -. 1.\n else (\n let next_magnitude = magnitude +. 1. in\n let next_sum_t = sum ~sum_t ~unit_of_time ~magnitude:next_magnitude in\n let next_rem_t = abs_t - next_sum_t in\n if next_rem_t < zero then magnitude else next_magnitude)\n in\n if Float.( <= ) magnitude 0.\n then \"\", sum_t\n else (\n let new_sum_t = sum ~sum_t ~unit_of_time ~magnitude in\n let string =\n Int63.to_string (Int63.of_float magnitude)\n ^ suffix_of_unit_of_time unit_of_time\n in\n string, new_sum_t)\n ;;\n\n let decimal_order_of_magnitude t = Float.log10 (to_sec t)\n\n (* The final seconds-or-smaller unit needs to be printed with enough digits to\n round-trip the whole span (which is minutes or greater); this can be\n significantly fewer digits than would be needed for the seconds-or-smaller\n remainder itself. *)\n let to_float_string_after_int_strings ~sum_t ~abs_t =\n if sum_t >= abs_t\n then \"\"\n else (\n let rem_t = abs_t - sum_t in\n let unit_of_time = to_unit_of_time rem_t in\n let unit_span = of_unit_of_time unit_of_time in\n let magnitude = rem_t // unit_span in\n let new_sum_t = sum ~sum_t ~unit_of_time ~magnitude in\n let new_rem_t = abs_t - new_sum_t in\n if abs rem_t <= abs new_rem_t\n then \"\"\n else (\n let order_of_magnitude_of_first_digit =\n Float.iround_down_exn (decimal_order_of_magnitude rem_t)\n in\n let half_ulp = (abs_t - prev abs_t) / 2. in\n let order_of_magnitude_of_final_digit =\n (* This works out to rounding down, except in the case of exact integers,\n which are decremented. This makes sure we always stop at a digit with\n strictly more precision than half the ULP. *)\n Int.pred (Float.iround_up_exn (decimal_order_of_magnitude half_ulp))\n in\n let number_of_digits =\n let open Int.O in\n 1 + order_of_magnitude_of_first_digit - order_of_magnitude_of_final_digit\n in\n let suffix = suffix_of_unit_of_time unit_of_time in\n sprintf \"%.*g\" number_of_digits magnitude ^ suffix))\n ;;\n\n (* This helper avoids unnecessary allocation, because for our use below, it is\n common to have either or both arguments be empty. Currently (2018-02), the\n built-in [^] allocates even when appending to an empty string. *)\n let ( ^? ) x y =\n if String.is_empty x then y else if String.is_empty y then x else x ^ y\n ;;\n\n let to_string t =\n let float = to_float t in\n if not (Float.is_finite float)\n then\n if (* We print specific special strings for non-finite floats *)\n Float.is_nan float\n then \"NANs\"\n else if Float.is_negative float\n then \"-INFs\"\n else \"INFs\"\n else if t = zero\n then \"0s\"\n else (\n let unit_of_time = to_unit_of_time t in\n let abs_t = abs t in\n let sign = if t < zero then \"-\" else \"\" in\n let magnitude_string =\n match unit_of_time with\n (* We can use normal float notation for seconds and sub-second units, they are\n readable with a decimal point. *)\n | Nanosecond | Microsecond | Millisecond | Second ->\n to_float_string ~abs_t ~unit_of_time ~fixup_unit_of_time:Nanosecond\n (* For large enough values that the ULP is a day or more, we can use float\n notation because we are expressing a single, very large integer. *)\n | Day when next abs_t - abs_t >= day ->\n to_float_string ~abs_t ~unit_of_time ~fixup_unit_of_time:Day\n (* For everything in between, we need to use integer units of days, hours,\n and/or minutes, because those units are not readable as decimals, and we\n tack on a decimal remainder of a seconds-or-smaller unit if necessary. *)\n | Minute | Hour | Day ->\n let sum_t = zero in\n let day_string, sum_t = to_int_string_and_sum ~abs_t ~sum_t Day in\n let hour_string, sum_t = to_int_string_and_sum ~abs_t ~sum_t Hour in\n let minute_string, sum_t = to_int_string_and_sum ~abs_t ~sum_t Minute in\n let float_string = to_float_string_after_int_strings ~abs_t ~sum_t in\n day_string ^? hour_string ^? minute_string ^? float_string\n in\n sign ^? magnitude_string)\n ;;\n end\n\n let to_string = To_string.to_string\n let sexp_of_t t = Sexp.Atom (to_string t)\n\n let t_of_sexp s =\n match s with\n | Sexp.Atom x ->\n (try of_string x with\n | exn -> of_sexp_error (Exn.to_string exn) s)\n | Sexp.List _ ->\n of_sexp_error \"Time.Span.Stable.V3.t_of_sexp: sexp must be an Atom\" s\n ;;\n end\nend\n\ninclude Stable.V3\n\nlet to_proportional_float = to_float\n\nlet to_string_hum\n ?(delimiter = '_')\n ?(decimals = 3)\n ?(align_decimal = false)\n ?unit_of_time\n t\n =\n let float, suffix =\n match Option.value unit_of_time ~default:(to_unit_of_time t) with\n | Day -> to_day t, \"d\"\n | Hour -> to_hr t, \"h\"\n | Minute -> to_min t, \"m\"\n | Second -> to_sec t, \"s\"\n | Millisecond -> to_ms t, \"ms\"\n | Microsecond -> to_us t, \"us\"\n | Nanosecond -> to_ns t, \"ns\"\n in\n let prefix =\n Float.to_string_hum float ~delimiter ~decimals ~strip_zero:(not align_decimal)\n in\n let suffix =\n if align_decimal && Int.( = ) (String.length suffix) 1 then suffix ^ \" \" else suffix\n in\n prefix ^ suffix\n;;\n\nlet gen_incl lo hi =\n Float.gen_incl (to_sec lo) (to_sec hi) |> Quickcheck.Generator.map ~f:of_sec\n;;\n\nlet gen_uniform_incl lo hi =\n (* Technically exclusive rather than inclusive, but otherwise satisfies the contract to\n within 1ulp of the given bounds. *)\n Float.gen_uniform_excl (to_sec lo) (to_sec hi) |> Quickcheck.Generator.map ~f:of_sec\n;;\n\ninclude Pretty_printer.Register (struct\n type nonrec t = t\n\n let to_string = to_string\n let module_name = \"Core_kernel.Time.Span\"\n end)\n\ninclude Hashable.Make_binable (struct\n type nonrec t = t [@@deriving bin_io, compare, hash, sexp_of]\n\n (* Previous versions rendered hash-based containers using float serialization rather\n than time serialization, so when reading hash-based containers in we accept either\n serialization. *)\n let t_of_sexp sexp =\n match Float.t_of_sexp sexp with\n | float -> of_float float\n | exception _ -> t_of_sexp sexp\n ;;\n end)\n\nmodule C = struct\n type t = T.t [@@deriving bin_io]\n type comparator_witness = T.comparator_witness\n\n let comparator = T.comparator\n\n (* In 108.06a and earlier, spans in sexps of Maps and Sets were raw floats. From 108.07\n through 109.13, the output format remained raw as before, but both the raw and pretty\n format were accepted as input. From 109.14 on, the output format was changed from\n raw to pretty, while continuing to accept both formats. Once we believe most\n programs are beyond 109.14, we will switch the input format to no longer accept\n raw. *)\n let sexp_of_t = sexp_of_t\n\n let t_of_sexp sexp =\n match Option.try_with (fun () -> T.of_float (Float.t_of_sexp sexp)) with\n | Some t -> t\n | None -> t_of_sexp sexp\n ;;\nend\n\nmodule Map = Map.Make_binable_using_comparator (C)\nmodule Set = Set.Make_binable_using_comparator (C)\n\nmodule Private = struct\n let suffix_of_unit_of_time = suffix_of_unit_of_time\n let parse_suffix = Stable.V3.Of_string.parse_suffix\nend\n","open! Import\n\nmodule type T = sig\n type t\nend\n\nmodule Make (T1 : T) (T2 : T) = struct\n type t = T1.t * T2.t\nend\n\nmodule T2 = struct\n type ('a, 'b) t = 'a * 'b [@@deriving sexp, typerep]\n\n let create a b = a, b\n\n let curry f =\n ();\n fun a b -> f (a, b)\n ;;\n\n let uncurry f =\n ();\n fun (a, b) -> f a b\n ;;\n\n external get1 : ('a, _) t -> 'a = \"%field0\"\n external get2 : (_, 'a) t -> 'a = \"%field1\"\n\n let map1 ~f (x, y) = f x, y\n let map2 ~f (x, y) = x, f y\n let map (x, y) ~f = f x, f y\n let map_fst (x, y) ~f = f x, y\n let map_snd (x, y) ~f = x, f y\n\n let compare ~cmp1 ~cmp2 (x, y) (x', y') =\n match cmp1 x x' with\n | 0 -> cmp2 y y'\n | i -> i\n ;;\n\n let equal ~eq1 ~eq2 (x, y) (x', y') = eq1 x x' && eq2 y y'\n let swap (a, b) = b, a\n\n include Comparator.Derived2 (struct\n type nonrec ('a, 'b) t = ('a, 'b) t [@@deriving sexp_of]\n\n let compare cmp1 cmp2 = compare ~cmp1 ~cmp2\n end)\nend\n\nmodule T3 = struct\n type ('a, 'b, 'c) t = 'a * 'b * 'c [@@deriving sexp, typerep]\n\n let create a b c = a, b, c\n\n let curry f =\n ();\n fun a b c -> f (a, b, c)\n ;;\n\n let uncurry f =\n ();\n fun (a, b, c) -> f a b c\n ;;\n\n let map1 ~f (x, y, z) = f x, y, z\n let map2 ~f (x, y, z) = x, f y, z\n let map3 ~f (x, y, z) = x, y, f z\n let map (x, y, z) ~f = f x, f y, f z\n let map_fst (x, y, z) ~f = f x, y, z\n let map_snd (x, y, z) ~f = x, f y, z\n let map_trd (x, y, z) ~f = x, y, f z\n\n external get1 : ('a, _, _) t -> 'a = \"%field0\"\n external get2 : (_, 'a, _) t -> 'a = \"%field1\"\n\n (* There's no %field2....*)\n let get3 (_, _, a) = a\n\n (* lexicographic comparison *)\n let compare ~cmp1 ~cmp2 ~cmp3 (x, y, z) (x', y', z') =\n let c1 = cmp1 x x' in\n if c1 <> 0\n then c1\n else (\n let c2 = cmp2 y y' in\n if c2 <> 0 then c2 else cmp3 z z')\n ;;\n\n let equal ~eq1 ~eq2 ~eq3 (x, y, z) (x', y', z') = eq1 x x' && eq2 y y' && eq3 z z'\nend\n\nmodule type Comparable_sexpable = sig\n type t [@@deriving sexp]\n\n include Comparable.S with type t := t\nend\n\nmodule type Hashable_sexpable = sig\n type t [@@deriving sexp]\n\n include Hashable.S with type t := t\nend\n\nmodule type Hasher_sexpable = sig\n type t [@@deriving compare, hash, sexp]\nend\n\nmodule Sexpable (S1 : Sexpable.S) (S2 : Sexpable.S) = struct\n type t = S1.t * S2.t [@@deriving sexp]\nend\n\nmodule Binable (B1 : Binable.S) (B2 : Binable.S) = struct\n type t = B1.t * B2.t [@@deriving bin_io]\nend\n\nmodule Comparable_plain (S1 : Comparable.S_plain) (S2 : Comparable.S_plain) = struct\n module T = struct\n type t = S1.t * S2.t\n\n type comparator_witness =\n (S1.comparator_witness, S2.comparator_witness) T2.comparator_witness\n\n let comparator = T2.comparator S1.comparator S2.comparator\n let sexp_of_t = comparator.sexp_of_t\n end\n\n include T\n include Comparable.Make_plain_using_comparator (T)\nend\n\nmodule Comparable (S1 : Comparable_sexpable) (S2 : Comparable_sexpable) = struct\n module T = struct\n include Sexpable (S1) (S2)\n\n let compare (s1, s2) (s1', s2') =\n match S1.compare s1 s1' with\n | 0 -> S2.compare s2 s2'\n | x -> x\n ;;\n end\n\n include T\n include Comparable.Make (T)\nend\n\nmodule Hasher (H1 : Hasher_sexpable) (H2 : Hasher_sexpable) = struct\n module T = struct\n type t = H1.t * H2.t [@@deriving compare, hash, sexp]\n end\n\n include T\n include Hashable.Make (T)\nend\n\nmodule Hasher_sexpable_of_hashable_sexpable (S : Hashable_sexpable) :\n Hasher_sexpable with type t = S.t = struct\n include S\n\n let hash_fold_t state t = hash_fold_int state (hash t)\nend\n\nmodule Hashable_t (S1 : Hashable_sexpable) (S2 : Hashable_sexpable) =\n Hasher\n (Hasher_sexpable_of_hashable_sexpable\n (S1))\n (Hasher_sexpable_of_hashable_sexpable (S2))\n\nmodule Hashable = Hashable_t\n","open! Import\nopen Std_internal\nopen Int.Replace_polymorphic_compare\n\nmodule Round = struct\n type t =\n | Toward_positive_infinity\n | Toward_negative_infinity\n [@@deriving compare, sexp_of]\nend\n\nlet module_name = \"Digit_string_helpers\"\nlet int63_two = Int63.of_int 2\nlet int63_ten = Int63.of_int 10\nlet int63_twenty = Int63.of_int 20\nlet int63_billion = Int63.of_int 1_000_000_000\nlet max_billions = Int63.( / ) Int63.max_value int63_billion\n\nlet rec digits_of_positive_int63 n =\n if Int63.( < ) n int63_ten\n then 1\n else Int.succ (digits_of_positive_int63 (Int63.( / ) n int63_ten))\n;;\n\nlet digits_of_int63_max_value = digits_of_positive_int63 Int63.max_value\n\nlet rec max_int63_with ~digits =\n match digits with\n | 1 -> Int63.of_int 9\n | 2 -> Int63.of_int 99\n | 3 -> Int63.of_int 999\n | 4 -> Int63.of_int 9_999\n | 5 -> Int63.of_int 99_999\n | 6 -> Int63.of_int 999_999\n | 7 -> Int63.of_int 9_999_999\n | 8 -> Int63.of_int 99_999_999\n | 9 -> Int63.of_int 999_999_999\n | _ ->\n if digits >= digits_of_int63_max_value\n then Int63.max_value\n else (\n let billions = Int63.succ (max_int63_with ~digits:(digits - 9)) in\n Int63.pred (Int63.( * ) int63_billion billions))\n;;\n\nmodule Unsafe = struct\n let unsafe_char_of_digit n = Char.unsafe_of_int (Char.to_int '0' + n)\n let digit_of_char char = Char.get_digit_exn char\n\n let write_1_digit_int bytes ~pos int =\n Bytes.unsafe_set bytes pos (unsafe_char_of_digit int)\n ;;\n\n let return_tens_and_write_ones bytes ~pos int =\n let tens = int / 10 in\n let ones = int - (tens * 10) in\n write_1_digit_int bytes ~pos ones;\n tens\n ;;\n\n let write_2_digit_int bytes ~pos int =\n let tens = return_tens_and_write_ones bytes ~pos:(pos + 1) int in\n write_1_digit_int bytes ~pos tens\n ;;\n\n let write_3_digit_int bytes ~pos int =\n let tens = return_tens_and_write_ones bytes ~pos:(pos + 2) int in\n write_2_digit_int bytes ~pos tens\n ;;\n\n let write_4_digit_int bytes ~pos int =\n let tens = return_tens_and_write_ones bytes ~pos:(pos + 3) int in\n write_3_digit_int bytes ~pos tens\n ;;\n\n let write_5_digit_int bytes ~pos int =\n let tens = return_tens_and_write_ones bytes ~pos:(pos + 4) int in\n write_4_digit_int bytes ~pos tens\n ;;\n\n let write_6_digit_int bytes ~pos int =\n let tens = return_tens_and_write_ones bytes ~pos:(pos + 5) int in\n write_5_digit_int bytes ~pos tens\n ;;\n\n let write_7_digit_int bytes ~pos int =\n let tens = return_tens_and_write_ones bytes ~pos:(pos + 6) int in\n write_6_digit_int bytes ~pos tens\n ;;\n\n let write_8_digit_int bytes ~pos int =\n let tens = return_tens_and_write_ones bytes ~pos:(pos + 7) int in\n write_7_digit_int bytes ~pos tens\n ;;\n\n let write_9_digit_int bytes ~pos int =\n let tens = return_tens_and_write_ones bytes ~pos:(pos + 8) int in\n write_8_digit_int bytes ~pos tens\n ;;\n\n let return_billions_and_write_remainder bytes ~pos int63 =\n let billions = Int63.( / ) int63 int63_billion in\n let remainder = Int63.( - ) int63 (Int63.( * ) billions int63_billion) in\n write_9_digit_int bytes ~pos (Int63.to_int_exn remainder);\n billions\n ;;\n\n let rec write_int63 bytes ~pos ~digits int63 =\n match digits with\n | 1 -> write_1_digit_int bytes ~pos (Int63.to_int_exn int63)\n | 2 -> write_2_digit_int bytes ~pos (Int63.to_int_exn int63)\n | 3 -> write_3_digit_int bytes ~pos (Int63.to_int_exn int63)\n | 4 -> write_4_digit_int bytes ~pos (Int63.to_int_exn int63)\n | 5 -> write_5_digit_int bytes ~pos (Int63.to_int_exn int63)\n | 6 -> write_6_digit_int bytes ~pos (Int63.to_int_exn int63)\n | 7 -> write_7_digit_int bytes ~pos (Int63.to_int_exn int63)\n | 8 -> write_8_digit_int bytes ~pos (Int63.to_int_exn int63)\n | 9 -> write_9_digit_int bytes ~pos (Int63.to_int_exn int63)\n | _ ->\n let digits_of_billions = digits - 9 in\n let billions =\n return_billions_and_write_remainder bytes ~pos:(pos + digits_of_billions) int63\n in\n write_int63 bytes ~pos ~digits:digits_of_billions billions\n ;;\n\n let read_1_digit_int string ~pos = digit_of_char (String.unsafe_get string pos)\n\n let read_2_digit_int string ~pos =\n (read_1_digit_int string ~pos * 10) + read_1_digit_int string ~pos:(pos + 1)\n ;;\n\n let read_3_digit_int string ~pos =\n (read_2_digit_int string ~pos * 10) + read_1_digit_int string ~pos:(pos + 2)\n ;;\n\n let read_4_digit_int string ~pos =\n (read_3_digit_int string ~pos * 10) + read_1_digit_int string ~pos:(pos + 3)\n ;;\n\n let read_5_digit_int string ~pos =\n (read_4_digit_int string ~pos * 10) + read_1_digit_int string ~pos:(pos + 4)\n ;;\n\n let read_6_digit_int string ~pos =\n (read_5_digit_int string ~pos * 10) + read_1_digit_int string ~pos:(pos + 5)\n ;;\n\n let read_7_digit_int string ~pos =\n (read_6_digit_int string ~pos * 10) + read_1_digit_int string ~pos:(pos + 6)\n ;;\n\n let read_8_digit_int string ~pos =\n (read_7_digit_int string ~pos * 10) + read_1_digit_int string ~pos:(pos + 7)\n ;;\n\n let read_9_digit_int string ~pos =\n (read_8_digit_int string ~pos * 10) + read_1_digit_int string ~pos:(pos + 8)\n ;;\n\n let raise_int63_overflow name =\n invalid_argf \"%s.%s: overflow reading int63\" module_name name ()\n ;;\n\n let rec read_int63 string ~pos ~digits =\n match digits with\n | 1 -> Int63.of_int (read_1_digit_int string ~pos)\n | 2 -> Int63.of_int (read_2_digit_int string ~pos)\n | 3 -> Int63.of_int (read_3_digit_int string ~pos)\n | 4 -> Int63.of_int (read_4_digit_int string ~pos)\n | 5 -> Int63.of_int (read_5_digit_int string ~pos)\n | 6 -> Int63.of_int (read_6_digit_int string ~pos)\n | 7 -> Int63.of_int (read_7_digit_int string ~pos)\n | 8 -> Int63.of_int (read_8_digit_int string ~pos)\n | 9 -> Int63.of_int (read_9_digit_int string ~pos)\n | _ ->\n let digits_of_billions = digits - 9 in\n let billions = read_int63 string ~pos ~digits:digits_of_billions in\n let remainder =\n Int63.of_int (read_9_digit_int string ~pos:(pos + digits_of_billions))\n in\n if Int63.( > ) billions max_billions then raise_int63_overflow \"read_int63\";\n let sum = Int63.( + ) (Int63.( * ) billions int63_billion) remainder in\n if Int63.( < ) sum Int63.zero then raise_int63_overflow \"read_int63\";\n sum\n ;;\n\n let divide_and_round_up ~numerator ~denominator =\n let open Int63.O in\n (numerator + denominator - Int63.one) /% denominator\n ;;\n\n let raise_invalid_decimal name =\n invalid_argf \"%s.%s: invalid decimal character\" module_name name ()\n ;;\n\n (* Reads the portion of string between [pos] and [pos+decimals-1], inclusive, and\n interperets it as a positive decimal part of a number, which we call [x].\n\n Let [i] and [r] be the integer part and remaining fractional part of\n [x * scale / divisor].\n\n If [r < round_at/divisor], returns [i].\n If [r = round_at/divisor], returns [i] or [i+1] based on [round_exact].\n If [r > round_at/divisor], returns [i+1].\n\n Assumes without checking that [scale] and [divisor] are both positive and\n less than [Int63.max_value / 10] (to avoid internal overflow during the algorithm\n when multiplying by 10), and that [round_at >= 0] and [round_at < divisor]. *)\n let read_int63_decimal_rounded\n string\n ~pos:start\n ~decimals\n ~scale\n ~divisor\n ~round_at\n ~round_exact\n ~allow_underscore\n =\n let open Int63.O in\n let until = Int.( + ) start decimals in\n (* The loop invariant is that each iteration, we strip off the next decimal digit and\n update [sum], [round_at], and [divisor] such that the desired result is:\n\n [ sum + round(remaining_digits_of_x_parsed_as_decimal * scale / divisor) ]\n where \"round\" rounds based on the new value of [round_at].\n *)\n let divisor = ref divisor in\n let round_at = ref round_at in\n let sum = ref Int63.zero in\n let pos = ref start in\n (* Stop if we run out of characters, or if further digits cannot increase our sum. *)\n while Int.( <> ) !pos until && !round_at < scale do\n (match String.unsafe_get string !pos with\n | '0' .. '9' as char ->\n let digit = Int63.of_int (digit_of_char char) in\n (* Every new decimal place implicitly scales our numerator by a factor of ten,\n so must also effectively scale our denominator.\n\n 0.abcdef * scale/divisor [round at round_at]\n = a.bcdef * scale/(divisor*10) [round at round_at*10]\n\n Then redefine divisor := divisor*10 and round_at := round_at*10, so we have:\n a.bcdef * scale/divisor [round at round_at] *)\n divisor := !divisor * int63_ten;\n round_at := !round_at * int63_ten;\n (* Next we work out the part of the sum based on our current digit:\n\n a.bcdef * scale/divisor [round at round_at]\n = a.bcdef * scale/divisor - round_at / divisor [round at 0]\n = (a*scale-round_at) / divisor + 0.bcdef * scale/divisor [round at 0]\n\n Decompose the first term into integer and remainder parts.\n Since we have already subtracted [round_at], we decompose based\n on the ceiling rather than the floor of the division,\n e.g. 5/3 would decompose as 2 + (-1)/3, rather than 1 + (2/3).\n\n = increment + remainder/divisor + 0.bcdef * scale/divisor [round at 0]\n = increment + 0.bcdef * scale/divisor [round at -remainder]\n *)\n let numerator = (digit * scale) - !round_at in\n let denominator = !divisor in\n let increment = divide_and_round_up ~numerator ~denominator in\n let remainder = numerator - (increment * denominator) in\n (* Now just accumulate the new increment and iterate on the remaining part:\n 0.bcdef * scale/divisor [round at -remainder].\n\n Since [remainder] is between [-(divisor-1)] and [0] inclusive, the new\n [round_at] will be within [0] and [divisor-1] inclusive. *)\n round_at := -remainder;\n sum := !sum + increment;\n (* This line prevents the divisor from growing without bound and overflowing. If\n this line actually changes the divisor, then the divisor is larger than the\n scale, so the sum will increase if and only if [parsed_remaining_digits *\n scale (> or >=) round_at], which doesn't depend on how much larger the\n divisor is. So this change is safe. *)\n divisor := Int63.min denominator scale\n | '_' when allow_underscore -> ()\n | _ -> raise_invalid_decimal \"read_int63_decimal\");\n pos := Int.succ !pos\n done;\n if !round_at = zero\n then (\n match round_exact with\n | Round.Toward_negative_infinity -> ()\n | Round.Toward_positive_infinity -> sum := !sum + Int63.one);\n !sum\n ;;\n\n let read_int63_decimal string ~pos ~decimals ~scale ~round_ties ~allow_underscore =\n read_int63_decimal_rounded\n string\n ~pos\n ~decimals\n ~scale:(Int63.( * ) scale int63_two)\n ~divisor:int63_two\n ~round_at:Int63.one\n ~round_exact:round_ties\n ~allow_underscore\n ;;\nend\n\nlet min_scale = Int63.one\nlet max_scale = Int63.( / ) Int63.max_value int63_twenty\n\nlet raise_negative_decimals name ~decimals =\n invalid_argf \"%s.%s: decimals=%d is negative\" module_name name decimals ()\n;;\n\nlet raise_non_positive_digits name ~digits =\n invalid_argf \"%s.%s: digits=%d is not a positive number\" module_name name digits ()\n;;\n\nlet raise_scale_out_of_bounds name ~scale =\n invalid_argf\n \"%s.%s: scale=%Ld out of range [%Ld, %Ld]\"\n module_name\n name\n (Int63.to_int64 scale)\n (Int63.to_int64 min_scale)\n (Int63.to_int64 max_scale)\n ()\n;;\n\nlet raise_pos_out_of_bounds name ~len ~pos ~digits =\n if pos < 0 || pos >= len\n then\n invalid_argf\n \"%s.%s: pos=%d out of range for string of length %d\"\n module_name\n name\n pos\n len\n ()\n else\n invalid_argf\n \"%s.%s: %d digits do not fit at pos %d in string of length %d\"\n module_name\n name\n digits\n pos\n len\n ()\n;;\n\nlet raise_int_out_of_bounds name ~max int =\n invalid_argf \"%s.%s: %d out of range [0, %d]\" module_name name int max ()\n;;\n\nlet raise_int63_out_of_bounds name ~max int63 =\n invalid_argf\n !\"%s.%s: %{Int63} out of range [0, %{Int63}]\"\n module_name\n name\n int63\n max\n ()\n;;\n\nlet check_decimals name ~decimals =\n if decimals < 0 then raise_negative_decimals name ~decimals\n;;\n\nlet check_digits name ~digits = if digits < 1 then raise_non_positive_digits name ~digits\n\nlet check_pos name ~len ~pos ~digits =\n if pos < 0 || pos + digits > len then raise_pos_out_of_bounds name ~len ~pos ~digits\n;;\n\nlet check_int name ~max int =\n if int < 0 || int > max then raise_int_out_of_bounds name ~max int\n;;\n\nlet check_int63 name ~max int63 =\n if Int63.( < ) int63 Int63.zero || Int63.( > ) int63 max\n then raise_int63_out_of_bounds name ~max int63\n;;\n\nlet check_scale name ~scale =\n if Int63.( < ) scale min_scale || Int63.( > ) scale max_scale\n then raise_scale_out_of_bounds name ~scale\n;;\n\nlet check_write name ~bytes ~pos ~digits ~max int =\n let len = Bytes.length bytes in\n check_pos name ~digits ~len ~pos;\n check_int name ~max int\n;;\n\nlet check_write63 name ~bytes ~pos ~digits int63 =\n check_digits name ~digits;\n let max = max_int63_with ~digits in\n let len = Bytes.length bytes in\n check_pos name ~digits ~len ~pos;\n check_int63 name ~max int63\n;;\n\nlet write_1_digit_int bytes ~pos int =\n check_write \"write_1_digit_int\" ~bytes ~pos ~digits:1 ~max:9 int;\n Unsafe.write_1_digit_int bytes ~pos int\n;;\n\nlet write_2_digit_int bytes ~pos int =\n check_write \"write_2_digit_int\" ~bytes ~pos ~digits:2 ~max:99 int;\n Unsafe.write_2_digit_int bytes ~pos int\n;;\n\nlet write_3_digit_int bytes ~pos int =\n check_write \"write_3_digit_int\" ~bytes ~pos ~digits:3 ~max:999 int;\n Unsafe.write_3_digit_int bytes ~pos int\n;;\n\nlet write_4_digit_int bytes ~pos int =\n check_write \"write_4_digit_int\" ~bytes ~pos ~digits:4 ~max:9_999 int;\n Unsafe.write_4_digit_int bytes ~pos int\n;;\n\nlet write_5_digit_int bytes ~pos int =\n check_write \"write_5_digit_int\" ~bytes ~pos ~digits:5 ~max:99_999 int;\n Unsafe.write_5_digit_int bytes ~pos int\n;;\n\nlet write_6_digit_int bytes ~pos int =\n check_write \"write_6_digit_int\" ~bytes ~pos ~digits:6 ~max:999_999 int;\n Unsafe.write_6_digit_int bytes ~pos int\n;;\n\nlet write_7_digit_int bytes ~pos int =\n check_write \"write_7_digit_int\" ~bytes ~pos ~digits:7 ~max:9_999_999 int;\n Unsafe.write_7_digit_int bytes ~pos int\n;;\n\nlet write_8_digit_int bytes ~pos int =\n check_write \"write_8_digit_int\" ~bytes ~pos ~digits:8 ~max:99_999_999 int;\n Unsafe.write_8_digit_int bytes ~pos int\n;;\n\nlet write_9_digit_int bytes ~pos int =\n check_write \"write_9_digit_int\" ~bytes ~pos ~digits:9 ~max:999_999_999 int;\n Unsafe.write_9_digit_int bytes ~pos int\n;;\n\nlet write_int63 bytes ~pos ~digits int63 =\n check_write63 \"write_int63\" ~bytes ~pos ~digits int63;\n Unsafe.write_int63 bytes ~pos ~digits int63\n;;\n\nlet check_read name ~string ~pos ~digits =\n let len = String.length string in\n check_pos name ~digits ~len ~pos\n;;\n\nlet check_read63 name ~string ~pos ~digits =\n check_digits name ~digits;\n let len = String.length string in\n check_pos name ~digits ~len ~pos\n;;\n\nlet check_read63_decimal name ~string ~pos ~decimals ~scale =\n let len = String.length string in\n check_decimals name ~decimals;\n check_scale name ~scale;\n check_pos name ~digits:decimals ~len ~pos\n;;\n\nlet read_1_digit_int string ~pos =\n check_read \"read_1_digit_int\" ~string ~pos ~digits:1;\n Unsafe.read_1_digit_int string ~pos\n;;\n\nlet read_2_digit_int string ~pos =\n check_read \"read_2_digit_int\" ~string ~pos ~digits:2;\n Unsafe.read_2_digit_int string ~pos\n;;\n\nlet read_3_digit_int string ~pos =\n check_read \"read_3_digit_int\" ~string ~pos ~digits:3;\n Unsafe.read_3_digit_int string ~pos\n;;\n\nlet read_4_digit_int string ~pos =\n check_read \"read_4_digit_int\" ~string ~pos ~digits:4;\n Unsafe.read_4_digit_int string ~pos\n;;\n\nlet read_5_digit_int string ~pos =\n check_read \"read_5_digit_int\" ~string ~pos ~digits:5;\n Unsafe.read_5_digit_int string ~pos\n;;\n\nlet read_6_digit_int string ~pos =\n check_read \"read_6_digit_int\" ~string ~pos ~digits:6;\n Unsafe.read_6_digit_int string ~pos\n;;\n\nlet read_7_digit_int string ~pos =\n check_read \"read_7_digit_int\" ~string ~pos ~digits:7;\n Unsafe.read_7_digit_int string ~pos\n;;\n\nlet read_8_digit_int string ~pos =\n check_read \"read_8_digit_int\" ~string ~pos ~digits:8;\n Unsafe.read_8_digit_int string ~pos\n;;\n\nlet read_9_digit_int string ~pos =\n check_read \"read_9_digit_int\" ~string ~pos ~digits:9;\n Unsafe.read_9_digit_int string ~pos\n;;\n\nlet read_int63 string ~pos ~digits =\n check_read63 \"read_int63\" ~string ~pos ~digits;\n Unsafe.read_int63 string ~pos ~digits\n;;\n\nlet read_int63_decimal string ~pos ~decimals ~scale ~round_ties ~allow_underscore =\n check_read63_decimal \"read_int63_decimal\" ~string ~pos ~decimals ~scale;\n Unsafe.read_int63_decimal string ~pos ~decimals ~scale ~round_ties ~allow_underscore\n;;\n","open! Import\n\nmodule Stable = struct\n module V1 = struct\n type t =\n | Jan\n | Feb\n | Mar\n | Apr\n | May\n | Jun\n | Jul\n | Aug\n | Sep\n | Oct\n | Nov\n | Dec\n [@@deriving sexp, compare, hash, variants, equal]\n\n let failwithf = Printf.failwithf\n\n let of_int_exn i : t =\n match i with\n | 1 -> Jan\n | 2 -> Feb\n | 3 -> Mar\n | 4 -> Apr\n | 5 -> May\n | 6 -> Jun\n | 7 -> Jul\n | 8 -> Aug\n | 9 -> Sep\n | 10 -> Oct\n | 11 -> Nov\n | 12 -> Dec\n | _ -> failwithf \"Month.of_int_exn %d\" i ()\n ;;\n\n let of_int i =\n try Some (of_int_exn i) with\n | _ -> None\n ;;\n\n let to_int (t : t) =\n match t with\n | Jan -> 1\n | Feb -> 2\n | Mar -> 3\n | Apr -> 4\n | May -> 5\n | Jun -> 6\n | Jul -> 7\n | Aug -> 8\n | Sep -> 9\n | Oct -> 10\n | Nov -> 11\n | Dec -> 12\n ;;\n\n include Binable.Stable.Of_binable.V1 [@alert \"-legacy\"]\n (Int)\n (struct\n type nonrec t = t\n\n let to_binable t = to_int t - 1\n let of_binable i = of_int_exn (i + 1)\n end)\n end\nend\n\nlet num_months = 12\n\nmodule T = struct\n include Stable.V1\n\n let all = [ Jan; Feb; Mar; Apr; May; Jun; Jul; Aug; Sep; Oct; Nov; Dec ]\n let hash = to_int\nend\n\ninclude T\n\ninclude (\n Hashable.Make_binable (struct\n include T\n end) :\n Hashable.S_binable with type t := t)\n\ninclude Comparable.Make_binable (struct\n include T\n\n (* In 108.06a and earlier, months in sexps of Maps and Sets were raw ints. From 108.07\n through 109.13, the output format remained raw as before, but both the raw and\n pretty format were accepted as input. From 109.14 on, the output format was\n changed from raw to pretty, while continuing to accept both formats. Once we believe\n most programs are beyond 109.14, we will switch the input format to no longer accept\n raw. *)\n let t_of_sexp sexp =\n match Option.try_with (fun () -> Int.t_of_sexp sexp) with\n | Some i -> of_int_exn (i + 1)\n | None -> T.t_of_sexp sexp\n ;;\n end)\n\n(* Replace the overriden sexp converters from [Comparable.Make_binable] with the ordinary\n symbolic converters. *)\nlet sexp_of_t = T.sexp_of_t\nlet t_of_sexp = T.t_of_sexp\nlet shift t i = of_int_exn (1 + Int.( % ) (to_int t - 1 + i) num_months)\n\nlet all_strings =\n lazy\n (Array.of_list (List.map all ~f:(fun variant -> Sexp.to_string (sexp_of_t variant))))\n;;\n\nlet to_string (t : t) =\n let all_strings = Lazy.force all_strings in\n all_strings.(to_int t - 1)\n;;\n\nlet of_string =\n let table =\n lazy\n (let module T = String.Table in\n let table = T.create ~size:num_months () in\n Array.iteri (Lazy.force all_strings) ~f:(fun i s ->\n let t = of_int_exn (i + 1) in\n Hashtbl.set table ~key:s ~data:t;\n Hashtbl.set table ~key:(String.lowercase s) ~data:t;\n Hashtbl.set table ~key:(String.uppercase s) ~data:t);\n table)\n in\n fun str ->\n match Hashtbl.find (Lazy.force table) str with\n | Some x -> x\n | None -> failwithf \"Invalid month: %s\" str ()\n;;\n\nmodule Export = struct\n type month = t =\n | Jan\n | Feb\n | Mar\n | Apr\n | May\n | Jun\n | Jul\n | Aug\n | Sep\n | Oct\n | Nov\n | Dec\nend\n","open! Import\nopen Std_internal\nopen Digit_string_helpers\n\nlet is_leap_year ~year = (year mod 4 = 0 && not (year mod 100 = 0)) || year mod 400 = 0\n\n(* Create a local private date type to ensure that all dates are created via\n Date.create_exn.\n*)\nmodule Stable = struct\n module V1 = struct\n module Without_comparable = struct\n module T : sig\n type t [@@immediate] [@@deriving bin_io, hash, typerep]\n\n val create_exn : y:int -> m:Month.Stable.V1.t -> d:int -> t\n val year : t -> int\n val month : t -> Month.Stable.V1.t\n val day : t -> int\n val days_in_month : year:int -> month:Month.t -> int\n val to_int : t -> int\n val of_int_exn : int -> t\n val invalid_value__for_internal_use_only : t\n end = struct\n (* We used to store dates like this:\n type t = { y: int; m: Month.Stable.V1.t; d: int; }\n In the below we make sure that the bin_io representation is\n identical (and the stable unit tests check this)\n\n In memory we use the following much more compact representation:\n 2 bytes year\n 1 byte month\n 1 byte day\n\n all packed into a single immediate int (so from 4 words down to 1).\n *)\n type t = int\n [@@deriving\n hash, typerep, bin_shape ~basetype:\"899ee3e0-490a-11e6-a10a-a3734f733566\"]\n\n let create0 ~year ~month ~day =\n (* create_exn's validation make sure that each value fits *)\n (year lsl 16) lor (Month.to_int month lsl 8) lor day\n ;;\n\n let year t = t lsr 16\n let month t = Month.of_int_exn ((t lsr 8) land 0xff)\n let day t = t land 0xff\n\n let days_in_month ~year ~month =\n match (month : Month.t) with\n | Jan | Mar | May | Jul | Aug | Oct | Dec -> 31\n | Apr | Jun | Sep | Nov -> 30\n | Feb -> if is_leap_year ~year then 29 else 28\n ;;\n\n let create_exn ~y:year ~m:month ~d:day =\n (* year, month, and day need to be passed as parameters to avoid allocating\n a closure (see unit test below) *)\n let invalid ~year ~month ~day msg =\n invalid_argf\n !\"Date.create_exn ~y:%d ~m:%{Month} ~d:%d error: %s\"\n year\n month\n day\n msg\n ()\n in\n if year < 0 || year > 9999\n then invalid ~year ~month ~day \"year outside of [0..9999]\";\n if day <= 0 then invalid ~year ~month ~day \"day <= 0\";\n let days_in_month = days_in_month ~year ~month in\n if day > days_in_month\n then invalid ~year ~month ~day (sprintf \"%d day month violation\" days_in_month);\n create0 ~year ~month ~day\n ;;\n\n (* We don't use Make_binable here, because that would go via an immediate\n tuple or record. That is exactly the 32 bytes we worked so hard above to\n get rid of. We also don't want to just bin_io the integer directly\n because that would mean a new bin_io format. *)\n\n let bin_read_t buf ~pos_ref =\n let year = Int.bin_read_t buf ~pos_ref in\n let month = Month.Stable.V1.bin_read_t buf ~pos_ref in\n let day = Int.bin_read_t buf ~pos_ref in\n create0 ~year ~month ~day\n ;;\n\n let __bin_read_t__ _buf ~pos_ref =\n (* __bin_read_t is only needed for variants *)\n Bin_prot.Common.raise_variant_wrong_type \"Date.t\" !pos_ref\n ;;\n\n let bin_reader_t =\n { Bin_prot.Type_class.read = bin_read_t; vtag_read = __bin_read_t__ }\n ;;\n\n let bin_size_t t =\n Int.bin_size_t (year t) + Month.bin_size_t (month t) + Int.bin_size_t (day t)\n ;;\n\n let bin_write_t buf ~pos t =\n let pos = Int.bin_write_t buf ~pos (year t) in\n let pos = Month.bin_write_t buf ~pos (month t) in\n Int.bin_write_t buf ~pos (day t)\n ;;\n\n let bin_writer_t = { Bin_prot.Type_class.size = bin_size_t; write = bin_write_t }\n\n let bin_t =\n { Bin_prot.Type_class.reader = bin_reader_t\n ; writer = bin_writer_t\n ; shape = bin_shape_t\n }\n ;;\n\n let to_int t = t\n let of_int_exn n = create_exn ~y:(year n) ~m:(month n) ~d:(day n)\n let invalid_value__for_internal_use_only = 0\n\n let%test \"invalid value\" =\n Exn.does_raise (fun () ->\n (of_int_exn invalid_value__for_internal_use_only : t))\n ;;\n end\n\n include T\n\n\n (** YYYY-MM-DD *)\n let to_string_iso8601_extended t =\n let buf = Bytes.create 10 in\n write_4_digit_int buf ~pos:0 (year t);\n Bytes.set buf 4 '-';\n write_2_digit_int buf ~pos:5 (Month.to_int (month t));\n Bytes.set buf 7 '-';\n write_2_digit_int buf ~pos:8 (day t);\n Bytes.unsafe_to_string ~no_mutation_while_string_reachable:buf\n ;;\n\n let to_string = to_string_iso8601_extended\n\n (** YYYYMMDD *)\n let to_string_iso8601_basic t =\n let buf = Bytes.create 8 in\n write_4_digit_int buf ~pos:0 (year t);\n write_2_digit_int buf ~pos:4 (Month.to_int (month t));\n write_2_digit_int buf ~pos:6 (day t);\n Bytes.unsafe_to_string ~no_mutation_while_string_reachable:buf\n ;;\n\n (** MM/DD/YYYY *)\n let to_string_american t =\n let buf = Bytes.create 10 in\n write_2_digit_int buf ~pos:0 (Month.to_int (month t));\n Bytes.set buf 2 '/';\n write_2_digit_int buf ~pos:3 (day t);\n Bytes.set buf 5 '/';\n write_4_digit_int buf ~pos:6 (year t);\n Bytes.unsafe_to_string ~no_mutation_while_string_reachable:buf\n ;;\n\n let parse_year4 str pos = read_4_digit_int str ~pos\n let parse_month str pos = Month.of_int_exn (read_2_digit_int str ~pos)\n let parse_day str pos = read_2_digit_int str ~pos\n\n (** YYYYMMDD *)\n let of_string_iso8601_basic str ~pos =\n if pos + 8 > String.length str\n then invalid_arg \"Date.of_string_iso8601_basic: pos + 8 > string length\";\n create_exn\n ~y:(parse_year4 str pos)\n ~m:(parse_month str (pos + 4))\n ~d:(parse_day str (pos + 6))\n ;;\n\n (* WARNING: if you are going to change this function in a material way, be sure you\n understand the implications of working in Stable *)\n let of_string s =\n let invalid () = failwith (\"invalid date: \" ^ s) in\n let ensure b = if not b then invalid () in\n let month_num ~year ~month ~day =\n create_exn\n ~y:(parse_year4 s year)\n ~m:(parse_month s month)\n ~d:(parse_day s day)\n in\n let month_abrv ~year ~month ~day =\n create_exn\n ~y:(parse_year4 s year)\n ~m:(Month.of_string (String.sub s ~pos:month ~len:3))\n ~d:(parse_day s day)\n in\n if String.contains s '/'\n then (\n let y, m, d =\n match String.split s ~on:'/' with\n | [ a; b; c ] ->\n if String.length a = 4 then a, b, c (* y/m/d *) else c, a, b (* m/d/y *)\n | _ -> invalid ()\n in\n let year = Int.of_string y in\n let year =\n if year >= 100 then year else if year < 75 then 2000 + year else 1900 + year\n in\n let month = Month.of_int_exn (Int.of_string m) in\n let day = Int.of_string d in\n create_exn ~y:year ~m:month ~d:day)\n else if String.contains s '-'\n then (\n (* yyyy-mm-dd *)\n ensure (String.length s = 10 && Char.( = ) s.[4] '-' && Char.( = ) s.[7] '-');\n month_num ~year:0 ~month:5 ~day:8)\n else if String.contains s ' '\n then\n if String.length s = 11 && Char.( = ) s.[2] ' ' && Char.( = ) s.[6] ' '\n then (* DD MMM YYYY *)\n month_abrv ~day:0 ~month:3 ~year:7\n else (\n (* YYYY MMM DD *)\n ensure (String.length s = 11 && Char.( = ) s.[4] ' ' && Char.( = ) s.[8] ' ');\n month_abrv ~day:9 ~month:5 ~year:0)\n else if String.length s = 9\n then (* DDMMMYYYY *)\n month_abrv ~day:0 ~month:2 ~year:5\n else if String.length s = 8\n then (* assume YYYYMMDD *)\n month_num ~year:0 ~month:4 ~day:6\n else invalid ()\n ;;\n\n let of_string s =\n try of_string s with\n | exn -> invalid_argf \"Date.of_string (%s): %s\" s (Exn.to_string exn) ()\n ;;\n\n module Sexpable = struct\n module Old_date = struct\n type t =\n { y : int\n ; m : int\n ; d : int\n }\n [@@deriving sexp]\n\n let to_date t = T.create_exn ~y:t.y ~m:(Month.of_int_exn t.m) ~d:t.d\n end\n\n let t_of_sexp = function\n | Sexp.Atom s -> of_string s\n | Sexp.List _ as sexp -> Old_date.to_date (Old_date.t_of_sexp sexp)\n ;;\n\n let t_of_sexp s =\n try t_of_sexp s with\n | Of_sexp_error _ as exn -> raise exn\n | Invalid_argument a -> of_sexp_error a s\n ;;\n\n let sexp_of_t t = Sexp.Atom (to_string t)\n end\n\n include Sexpable\n\n let compare t1 t2 =\n let n = Int.compare (year t1) (year t2) in\n if n <> 0\n then n\n else (\n let n = Month.compare (month t1) (month t2) in\n if n <> 0 then n else Int.compare (day t1) (day t2))\n ;;\n\n include (val Comparator.Stable.V1.make ~compare ~sexp_of_t)\n end\n\n include Without_comparable\n include Comparable.Stable.V1.Make (Without_comparable)\n end\n\n module Option = struct\n module V1 = struct\n type t = int\n [@@deriving\n bin_io\n , bin_shape ~basetype:\"826a3e79-3321-451a-9707-ed6c03b84e2f\"\n , compare\n , hash\n , typerep]\n\n let none = V1.(to_int invalid_value__for_internal_use_only)\n let is_none t = t = none\n let is_some t = not (is_none t)\n let some_is_representable _ = true\n let some t = V1.to_int t\n let unchecked_value = V1.of_int_exn\n let to_option t = if is_some t then Some (unchecked_value t) else None\n\n let of_option opt =\n match opt with\n | None -> none\n | Some v -> some v\n ;;\n\n let value_exn t =\n if is_some t\n then unchecked_value t\n else raise_s [%message [%here] \"Date.Option.value_exn none\"]\n ;;\n\n let value t ~default = if is_some t then unchecked_value t else default\n let sexp_of_t t = to_option t |> Option.sexp_of_t V1.sexp_of_t\n let t_of_sexp sexp = (Option.t_of_sexp V1.t_of_sexp) sexp |> of_option\n end\n end\nend\n\nmodule Without_comparable = Stable.V1.Without_comparable\ninclude Without_comparable\nmodule C = Comparable.Make_binable_using_comparator (Without_comparable)\ninclude C\n\nmodule O = struct\n include (C : Comparable.Infix with type t := t)\nend\n\ninclude (\n Hashable.Make_binable (struct\n include T\n include Sexpable\n include Binable\n\n let compare (a : t) (b : t) = compare a b\n end) :\n Hashable.S_binable with type t := t)\n\ninclude Pretty_printer.Register (struct\n type nonrec t = t\n\n let module_name = \"Core_kernel.Date\"\n let to_string = to_string\n end)\n\nlet unix_epoch = create_exn ~y:1970 ~m:Jan ~d:1\n\n(* The Days module is used for calculations that involve adding or removing a known number\n of days from a date. Internally the date is translated to a day number, the days are\n added, and the new date is returned. Those interested in the math can read:\n\n http://alcor.concordia.ca/~gpkatch/gdate-method.html\n\n note: unit tests are in lib_test/time_test.ml\n*)\nmodule Days : sig\n type date = t\n type t [@@immediate]\n\n val of_date : date -> t\n val to_date : t -> date\n val diff : t -> t -> int\n val add_days : t -> int -> t\n val unix_epoch : t\nend\nwith type date := t = struct\n open Int\n\n type t = int\n\n let of_year y = (365 * y) + (y / 4) - (y / 100) + (y / 400)\n\n let of_date date =\n let m = (Month.to_int (month date) + 9) % 12 in\n let y = year date - (m / 10) in\n of_year y + (((m * 306) + 5) / 10) + (day date - 1)\n ;;\n\n let c_10_000 = Int63.of_int 10_000\n let c_14_780 = Int63.of_int 14_780\n let c_3_652_425 = Int63.of_int 3_652_425\n\n let to_date days =\n let y =\n let open Int63 in\n to_int_exn (((c_10_000 * of_int days) + c_14_780) / c_3_652_425)\n in\n let ddd = days - of_year y in\n let y, ddd =\n if ddd < 0\n then (\n let y = y - 1 in\n y, days - of_year y)\n else y, ddd\n in\n let mi = ((100 * ddd) + 52) / 3_060 in\n let y = y + ((mi + 2) / 12) in\n let m = ((mi + 2) % 12) + 1 in\n let d = ddd - (((mi * 306) + 5) / 10) + 1 in\n create_exn ~y ~m:(Month.of_int_exn m) ~d\n ;;\n\n let unix_epoch = of_date unix_epoch\n let add_days t days = t + days\n let diff t1 t2 = t1 - t2\nend\n\nlet add_days t days = Days.to_date (Days.add_days (Days.of_date t) days)\nlet diff t1 t2 = Days.diff (Days.of_date t1) (Days.of_date t2)\n\nlet add_months t n =\n let total_months = Month.to_int (month t) + n in\n let y = year t + (total_months /% 12) in\n let m = total_months % 12 in\n (* correct for december *)\n let y, m = if Int.( = ) m 0 then y - 1, m + 12 else y, m in\n let m = Month.of_int_exn m in\n (* handle invalid dates for months with fewer number of days *)\n let rec try_create d =\n try create_exn ~y ~m ~d with\n | _exn ->\n assert (Int.( >= ) d 1);\n try_create (d - 1)\n in\n try_create (day t)\n;;\n\nlet add_years t n = add_months t (n * 12)\n\n(* http://en.wikipedia.org/wiki/Determination_of_the_day_of_the_week#Purely_mathematical_methods\n\n note: unit tests in lib_test/time_test.ml\n*)\nlet day_of_week =\n let table = [| 0; 3; 2; 5; 0; 3; 5; 1; 4; 6; 2; 4 |] in\n fun t ->\n let m = Month.to_int (month t) in\n let y = if Int.( < ) m 3 then year t - 1 else year t in\n Day_of_week.of_int_exn\n ((y + (y / 4) - (y / 100) + (y / 400) + table.(m - 1) + day t) % 7)\n;;\n\n(* http://en.wikipedia.org/wiki/Ordinal_date *)\nlet non_leap_year_table = [| 0; 31; 59; 90; 120; 151; 181; 212; 243; 273; 304; 334 |]\nlet leap_year_table = [| 0; 31; 60; 91; 121; 152; 182; 213; 244; 274; 305; 335 |]\n\nlet ordinal_date t =\n let table =\n if is_leap_year ~year:(year t) then leap_year_table else non_leap_year_table\n in\n let offset = table.(Month.to_int (month t) - 1) in\n day t + offset\n;;\n\nlet last_week_of_year y =\n let first_of_year = create_exn ~y ~m:Jan ~d:1 in\n let is t day = Day_of_week.equal (day_of_week t) day in\n if is first_of_year Thu || (is_leap_year ~year:y && is first_of_year Wed)\n then 53\n else 52\n;;\n\n(* See http://en.wikipedia.org/wiki/ISO_week_date or ISO 8601 for the details of this\n algorithm.\n\n Uses a [~f] argument to avoid allocating a tuple when called by [week_number].\n*)\nlet call_with_week_and_year t ~f =\n let ordinal = ordinal_date t in\n let weekday = Day_of_week.iso_8601_weekday_number (day_of_week t) in\n (* [ordinal - weekday + 4] is the ordinal of this week's Thursday, then (n + 6) / 7 is\n division by 7 rounding up *)\n let week = (ordinal - weekday + 10) / 7 in\n let year = year t in\n if Int.( < ) week 1\n then f ~week:(last_week_of_year (year - 1)) ~year:(year - 1)\n else if Int.( > ) week (last_week_of_year year)\n then f ~week:1 ~year:(year + 1)\n else f ~week ~year\n;;\n\nlet week_number_and_year t = call_with_week_and_year t ~f:(fun ~week ~year -> week, year)\nlet week_number t = call_with_week_and_year t ~f:(fun ~week ~year:_ -> week)\nlet is_weekend t = Day_of_week.is_sun_or_sat (day_of_week t)\nlet is_weekday t = not (is_weekend t)\nlet is_business_day t ~is_holiday = is_weekday t && not (is_holiday t)\n\nlet rec diff_weekend_days t1 t2 =\n if t1 < t2\n then -diff_weekend_days t2 t1\n else (\n (* Basic date diff *)\n let diff = diff t1 t2 in\n (* Compute the number of Saturday -> Sunday crossings *)\n let d1 = day_of_week t1 in\n let d2 = day_of_week t2 in\n let num_satsun_crossings =\n if Int.( < ) (Day_of_week.to_int d1) (Day_of_week.to_int d2)\n then 1 + (diff / 7)\n else diff / 7\n in\n (num_satsun_crossings * 2)\n + (if Day_of_week.( = ) d2 Day_of_week.Sun then 1 else 0)\n + if Day_of_week.( = ) d1 Day_of_week.Sun then -1 else 0)\n;;\n\nlet diff_weekdays t1 t2 = diff t1 t2 - diff_weekend_days t1 t2\n\nlet add_days_skipping t ~skip n =\n let step = if Int.( >= ) n 0 then 1 else -1 in\n let rec loop t k =\n let t_next = add_days t step in\n if skip t then loop t_next k else if Int.( = ) k 0 then t else loop t_next (k - 1)\n in\n loop t (abs n)\n;;\n\nlet rec first_day_satisfying t ~step ~condition =\n if condition t then t else first_day_satisfying (add_days t step) ~step ~condition\n;;\n\nlet next_day_satisfying t ~step ~condition =\n let next_day = add_days t step in\n first_day_satisfying next_day ~step ~condition\n;;\n\nlet following_weekday t = next_day_satisfying t ~step:1 ~condition:is_weekday\nlet previous_weekday t = next_day_satisfying t ~step:(-1) ~condition:is_weekday\nlet round_forward_to_weekday t = first_day_satisfying t ~step:1 ~condition:is_weekday\nlet round_backward_to_weekday t = first_day_satisfying t ~step:(-1) ~condition:is_weekday\n\nlet round_forward_to_business_day t ~is_holiday =\n first_day_satisfying t ~step:1 ~condition:(is_business_day ~is_holiday)\n;;\n\nlet round_backward_to_business_day t ~is_holiday =\n first_day_satisfying t ~step:(-1) ~condition:(is_business_day ~is_holiday)\n;;\n\nlet add_weekdays t n = add_days_skipping t ~skip:is_weekend n\nlet add_weekdays_rounding_in_direction_of_step = add_weekdays\n\nlet add_weekdays_rounding_forward t n =\n add_days_skipping (round_forward_to_weekday t) ~skip:is_weekend n\n;;\n\nlet add_weekdays_rounding_backward t n =\n add_days_skipping (round_backward_to_weekday t) ~skip:is_weekend n\n;;\n\nlet add_business_days t ~is_holiday n =\n add_days_skipping t n ~skip:(fun d -> is_weekend d || is_holiday d)\n;;\n\nlet add_business_days_rounding_in_direction_of_step = add_business_days\n\nlet add_business_days_rounding_forward t ~is_holiday n =\n add_days_skipping (round_forward_to_business_day ~is_holiday t) n ~skip:(fun d ->\n not (is_business_day ~is_holiday d))\n;;\n\nlet add_business_days_rounding_backward t ~is_holiday n =\n add_days_skipping (round_backward_to_business_day ~is_holiday t) n ~skip:(fun d ->\n not (is_business_day ~is_holiday d))\n;;\n\nlet dates_between ~min:t1 ~max:t2 =\n let rec loop t l = if t < t1 then l else loop (add_days t (-1)) (t :: l) in\n loop t2 []\n;;\n\nlet weekdays_between ~min ~max =\n let all_dates = dates_between ~min ~max in\n Option.value_map (List.hd all_dates) ~default:[] ~f:(fun first_date ->\n (* to avoid a system call on every date, we just get the weekday for the first\n date and use it to get all the other weekdays *)\n let first_weekday = day_of_week first_date in\n let date_and_weekdays =\n List.mapi all_dates ~f:(fun i date -> date, Day_of_week.shift first_weekday i)\n in\n List.filter_map date_and_weekdays ~f:(fun (date, weekday) ->\n if Day_of_week.is_sun_or_sat weekday then None else Some date))\n;;\n\nlet business_dates_between ~min ~max ~is_holiday =\n weekdays_between ~min ~max |> List.filter ~f:(fun d -> not (is_holiday d))\n;;\n\nlet first_strictly_after t ~on:dow =\n let dow = Day_of_week.to_int dow in\n let tplus1 = add_days t 1 in\n let cur = Day_of_week.to_int (day_of_week tplus1) in\n let diff = (dow + 7 - cur) mod 7 in\n add_days tplus1 diff\n;;\n\nmodule For_quickcheck = struct\n open Quickcheck\n\n let gen_uniform_incl d1 d2 =\n if d1 > d2\n then\n raise_s\n [%message\n \"Date.gen_uniform_incl: bounds are crossed\"\n ~lower_bound:(d1 : t)\n ~upper_bound:(d2 : t)];\n Generator.map (Int.gen_uniform_incl 0 (diff d2 d1)) ~f:(fun days -> add_days d1 days)\n ;;\n\n let gen_incl d1 d2 =\n Generator.weighted_union\n [ 1., Generator.return d1; 1., Generator.return d2; 18., gen_uniform_incl d1 d2 ]\n ;;\n\n let quickcheck_generator = gen_incl (of_string \"1900-01-01\") (of_string \"2100-01-01\")\n let quickcheck_observer = Observer.create (fun t ~size:_ ~hash -> hash_fold_t hash t)\n let quickcheck_shrinker = Shrinker.empty ()\nend\n\nlet quickcheck_generator = For_quickcheck.quickcheck_generator\nlet gen_incl = For_quickcheck.gen_incl\nlet gen_uniform_incl = For_quickcheck.gen_uniform_incl\nlet quickcheck_observer = For_quickcheck.quickcheck_observer\nlet quickcheck_shrinker = For_quickcheck.quickcheck_shrinker\n\nmodule Private = struct\n let leap_year_table = leap_year_table\n let non_leap_year_table = non_leap_year_table\n let ordinal_date = ordinal_date\nend\n\nmodule Option = struct\n module Stable = Stable.Option\n include Stable.V1\n\n module Optional_syntax = struct\n module Optional_syntax = struct\n let is_none = is_none\n let unsafe_value = unchecked_value\n end\n end\n\n let quickcheck_generator =\n Quickcheck.Generator.map\n (Option.quickcheck_generator quickcheck_generator)\n ~f:of_option\n ;;\n\n let quickcheck_shrinker =\n Quickcheck.Shrinker.map\n (Option.quickcheck_shrinker quickcheck_shrinker)\n ~f:of_option\n ~f_inverse:to_option\n ;;\n\n let quickcheck_observer =\n Quickcheck.Observer.of_hash\n (module struct\n type nonrec t = t [@@deriving hash]\n end)\n ;;\n\n include Comparable.Make_plain (struct\n type nonrec t = t [@@deriving compare, sexp_of]\n end)\nend\n","open! Import\nopen Std_internal\n\nmodule Stable = struct\n module V1 = struct\n type t = (float[@quickcheck.generator Float.gen_finite])\n [@@deriving compare, hash, quickcheck, typerep]\n\n let of_mult f = f\n let to_mult t = t\n let of_percentage f = f /. 100.\n let to_percentage t = t *. 100.\n let of_bp f = f /. 10_000.\n let to_bp t = t *. 10_000.\n let of_bp_int i = of_bp (Float.of_int i)\n let to_bp_int t = Float.to_int (to_bp t)\n\n let round_significant p ~significant_digits =\n Float.round_significant p ~significant_digits\n ;;\n\n let round_decimal_mult p ~decimal_digits = Float.round_decimal p ~decimal_digits\n\n let round_decimal_percentage p ~decimal_digits =\n Float.round_decimal (p *. 100.) ~decimal_digits /. 100.\n ;;\n\n let round_decimal_bp p ~decimal_digits =\n Float.round_decimal (p *. 10000.) ~decimal_digits /. 10000.\n ;;\n\n module Format = struct\n type t =\n | Exponent of int\n | Exponent_E of int\n | Decimal of int\n | Ocaml\n | Compact of int\n | Compact_E of int\n | Hex of int\n | Hex_E of int\n [@@deriving sexp_of]\n\n let exponent ~precision = Exponent precision\n let exponent_E ~precision = Exponent_E precision\n let decimal ~precision = Decimal precision\n let ocaml = Ocaml\n let compact ~precision = Compact precision\n let compact_E ~precision = Compact_E precision\n let hex ~precision = Hex precision\n let hex_E ~precision = Hex_E precision\n\n let format_float t =\n match t with\n | Exponent precision -> sprintf \"%.*e\" precision\n | Exponent_E precision -> sprintf \"%.*E\" precision\n | Decimal precision -> sprintf \"%.*f\" precision\n | Ocaml -> sprintf \"%F\"\n | Compact precision -> sprintf \"%.*g\" precision\n | Compact_E precision -> sprintf \"%.*G\" precision\n | Hex precision -> sprintf \"%.*h\" precision\n | Hex_E precision -> sprintf \"%.*H\" precision\n ;;\n end\n\n let format x format =\n let x_abs = Float.abs x in\n let string float = Format.format_float format float in\n if Float.( = ) x_abs 0.\n then \"0x\"\n else if Float.( >= ) x_abs 1.\n then string (x *. 1.) ^ \"x\"\n else if Float.( >= ) x_abs 0.01\n then string (x *. 100.) ^ \"%\"\n else string (x *. 10_000.) ^ \"bp\"\n ;;\n\n module Stringable = struct\n type t = float\n\n (* WARNING - PLEASE READ BEFORE EDITING THESE FUNCTIONS:\n\n The string converters in Stable.V1 should never change. If you are changing the\n semantics of anything that affects the sexp or bin-io representation of values of\n this type (this includes to_string and of_string) make a Stable.V2 and make your\n changes there. Thanks! *)\n let to_string x =\n let x_abs = Float.abs x in\n let string float = sprintf \"%.6G\" float in\n if Float.( = ) x_abs 0.\n then \"0x\"\n else if Float.( >= ) x_abs 1.\n then string (x *. 1.) ^ \"x\"\n else if Float.( >= ) x_abs 0.01\n then string (x *. 100.) ^ \"%\"\n else string (x *. 10_000.) ^ \"bp\"\n ;;\n\n let really_of_string str float_of_string =\n match String.chop_suffix str ~suffix:\"x\" with\n | Some str -> float_of_string str\n | None ->\n (match String.chop_suffix str ~suffix:\"%\" with\n | Some str -> float_of_string str *. 0.01\n | None ->\n (match String.chop_suffix str ~suffix:\"bp\" with\n | Some str -> of_bp (float_of_string str)\n | None -> failwithf \"Percent.of_string: must end in x, %%, or bp: %s\" str ()))\n ;;\n\n let of_string str =\n let float str = Float_with_finite_only_serialization.t_of_sexp (Sexp.Atom str) in\n really_of_string str float\n ;;\n\n let of_string_allow_nan_and_inf str = really_of_string str Float.of_string\n end\n\n include (\n Stringable :\n sig\n type t\n\n val of_string : string -> t\n val to_string : t -> string\n end\n with type t := t)\n\n include (Sexpable.Stable.Of_stringable.V1 (Stringable) : Sexpable.S with type t := t)\n include (Float : Binable with type t := t)\n\n include Comparable.Make_binable (struct\n type nonrec t = t [@@deriving compare, sexp_of, bin_io]\n\n (* Previous versions rendered comparable-based containers using float\n serialization rather than percent serialization, so when reading\n comparable-based containers in we accept either serialization. *)\n let t_of_sexp sexp =\n match Float.t_of_sexp sexp with\n | float -> float\n | exception _ -> t_of_sexp sexp\n ;;\n end)\n end\n\n module Option = struct\n module V1 = struct\n type t = V1.t [@@deriving bin_io, compare, hash, typerep]\n\n let none = Float.nan\n let is_none t = Float.is_nan t\n let is_some t = not (is_none t)\n let some_is_representable = is_some\n let some = Fn.id\n let unchecked_value = Fn.id\n let to_option t = if is_some t then Some (unchecked_value t) else None\n\n let of_option opt =\n match opt with\n | None -> none\n | Some v -> some v\n ;;\n\n let value_exn t =\n if is_some t\n then unchecked_value t\n else raise_s [%message [%here] \"Percent.Option.value_exn none\"]\n ;;\n\n let value t ~default = if is_some t then unchecked_value t else default\n let sexp_of_t t = to_option t |> Option.sexp_of_t V1.sexp_of_t\n let t_of_sexp sexp = (Option.t_of_sexp V1.t_of_sexp) sexp |> of_option\n end\n end\nend\n\ninclude Stable.V1\n\nmodule Option = struct\n module Stable = Stable.Option\n include Stable.V1\n\n module Optional_syntax = struct\n module Optional_syntax = struct\n let is_none = is_none\n let unsafe_value = unchecked_value\n end\n end\nend\n\nlet is_zero t = t = 0.\nlet apply t f = t *. f\nlet scale t f = t *. f\n\ninclude (\nstruct\n include Float\n\n let sign = sign_exn\nend :\nsig\n val zero : t\n val ( * ) : t -> t -> t\n val ( + ) : t -> t -> t\n val ( - ) : t -> t -> t\n val abs : t -> t\n val neg : t -> t\n val is_nan : t -> bool\n val is_inf : t -> bool\n val sign_exn : t -> Sign.t\n\n include Comparable.With_zero with type t := t\n include Robustly_comparable with type t := t\nend)\n\nlet validate = Float.validate_ordinary\nlet of_string_allow_nan_and_inf s = Stringable.of_string_allow_nan_and_inf s\nlet t_of_sexp_allow_nan_and_inf sexp = of_string_allow_nan_and_inf (Sexp.to_string sexp)\n","open! Import\nopen Std_internal\nopen Digit_string_helpers\nopen! Int.Replace_polymorphic_compare\nmodule Span = Span_float\n\n(* Create an abstract type for Ofday to prevent us from confusing it with\n other floats.\n*)\nmodule Stable = struct\n module V1 = struct\n module T : sig\n type underlying = float\n type t = private underlying [@@deriving bin_io, hash, typerep]\n\n include Comparable.S_common with type t := t\n include Robustly_comparable with type t := t\n include Floatable with type t := t\n\n val add : t -> Span.t -> t option\n val sub : t -> Span.t -> t option\n val next : t -> t option\n val prev : t -> t option\n val diff : t -> t -> Span.t\n val of_span_since_start_of_day_exn : Span.t -> t\n val of_span_since_start_of_day_unchecked : Span.t -> t\n val span_since_start_of_day_is_valid : Span.t -> bool\n val to_span_since_start_of_day : t -> Span.t\n val start_of_day : t\n val start_of_next_day : t\n end = struct\n (* Number of seconds since midnight. *)\n type underlying = Float.t\n\n include (\n struct\n include Float\n\n let sign = sign_exn\n end :\n sig\n type t = underlying [@@deriving bin_io, hash, typerep]\n\n include Comparable.S_common with type t := t\n include Comparable.With_zero with type t := t\n include Robustly_comparable with type t := t\n include Floatable with type t := t\n end)\n\n (* IF THIS REPRESENTATION EVER CHANGES, ENSURE THAT EITHER\n (1) all values serialize the same way in both representations, or\n (2) you add a new Time.Ofday version to stable.ml *)\n\n (* due to precision limitations in float we can't expect better than microsecond\n precision *)\n include Float.Robust_compare.Make (struct\n let robust_comparison_tolerance = 1E-6\n end)\n\n let to_span_since_start_of_day t = Span.of_sec t\n\n (* Another reasonable choice would be only allowing Ofday.t to be < 24hr, but this\n choice was made early on and people became used to being able to easily call 24hr\n the end of the day. It's a bit sad because it shares that moment with the\n beginning of the next day, and round trips oddly if passed through\n Time.to_date_ofday/Time.of_date_ofday.\n\n Note: [Schedule.t] requires that the end of day be representable, as it's the\n only way to write a schedule in terms of [Ofday.t]s that spans two weekdays. *)\n (* ofday must be >= 0 and <= 24h *)\n let is_valid (t : t) =\n let t = to_span_since_start_of_day t in\n Span.( <= ) Span.zero t && Span.( <= ) t Span.day\n ;;\n\n let of_span_since_start_of_day_unchecked span = Span.to_sec span\n\n let span_since_start_of_day_is_valid span =\n is_valid (of_span_since_start_of_day_unchecked span)\n ;;\n\n let of_span_since_start_of_day_exn span =\n let module C = Float.Class in\n let s = Span.to_sec span in\n match Float.classify s with\n | C.Infinite ->\n invalid_arg \"Ofday.of_span_since_start_of_day_exn: infinite value\"\n | C.Nan -> invalid_arg \"Ofday.of_span_since_start_of_day_exn: NaN value\"\n | C.Normal | C.Subnormal | C.Zero ->\n if not (is_valid s)\n then invalid_argf !\"Ofday out of range: %{Span}\" span ()\n else s\n ;;\n\n let start_of_day = 0.\n let start_of_next_day = of_span_since_start_of_day_exn Span.day\n\n let add (t : t) (span : Span.t) =\n let t = t +. Span.to_sec span in\n if is_valid t then Some t else None\n ;;\n\n let sub (t : t) (span : Span.t) =\n let t = t -. Span.to_sec span in\n if is_valid t then Some t else None\n ;;\n\n let next t =\n let candidate = Float.one_ulp `Up t in\n if is_valid candidate then Some candidate else None\n ;;\n\n let prev t =\n let candidate = Float.one_ulp `Down t in\n if is_valid candidate then Some candidate else None\n ;;\n\n let diff t1 t2 =\n Span.( - ) (to_span_since_start_of_day t1) (to_span_since_start_of_day t2)\n ;;\n end\n\n let approximate_end_of_day =\n Option.value_exn (T.sub T.start_of_next_day Span.microsecond)\n ;;\n\n (* [create] chops off any subsecond part when [sec = 60] to handle leap seconds. In\n particular it's trying to be generous about reading in times on things like fix\n messages that might include an extra unlikely second.\n\n Other ways of writing a time, like 1000ms, while mathematically valid, don't match\n ways that people actually write times down, so we didn't see the need to support\n them. That is, a clock might legitimately read 23:59:60 (or, with 60 seconds at\n times of day other than 23:59, depending on the time zone), but it doesn't seem\n reasonable for a clock to read \"23:59:59 and 1000ms\". *)\n let create ?hr ?min ?sec ?ms ?us ?ns () =\n let ms, us, ns =\n match sec with\n | Some 60 -> Some 0, Some 0, Some 0\n | _ -> ms, us, ns\n in\n T.of_span_since_start_of_day_exn (Span.create ?hr ?min ?sec ?ms ?us ?ns ())\n ;;\n\n let to_parts t = Span.to_parts (T.to_span_since_start_of_day t)\n\n let to_string_gen ~drop_ms ~drop_us ~trim t =\n let ( / ) = Int63.( / ) in\n let ( ! ) = Int63.of_int in\n let ( mod ) = Int63.rem in\n let i = Int63.to_int_exn in\n assert (if drop_ms then drop_us else true);\n let float_sec = Span.to_sec (T.to_span_since_start_of_day t) in\n let us = Float.int63_round_nearest_exn (float_sec *. 1e6) in\n let ms, us = us / !1000, us mod !1000 |> i in\n let sec, ms = ms / !1000, ms mod !1000 |> i in\n let min, sec = sec / !60, sec mod !60 |> i in\n let hr, min = min / !60, min mod !60 |> i in\n let hr = i hr in\n let dont_print_us = drop_us || (trim && us = 0) in\n let dont_print_ms = drop_ms || (trim && ms = 0 && dont_print_us) in\n let dont_print_s = trim && sec = 0 && dont_print_ms in\n let len =\n if dont_print_s\n then 5\n else if dont_print_ms\n then 8\n else if dont_print_us\n then 12\n else 15\n in\n let buf = Bytes.create len in\n write_2_digit_int buf ~pos:0 hr;\n Bytes.set buf 2 ':';\n write_2_digit_int buf ~pos:3 min;\n if dont_print_s\n then ()\n else (\n Bytes.set buf 5 ':';\n write_2_digit_int buf ~pos:6 sec;\n if dont_print_ms\n then ()\n else (\n Bytes.set buf 8 '.';\n write_3_digit_int buf ~pos:9 ms;\n if dont_print_us then () else write_3_digit_int buf ~pos:12 us));\n Bytes.unsafe_to_string ~no_mutation_while_string_reachable:buf\n ;;\n\n let to_string_trimmed t = to_string_gen ~drop_ms:false ~drop_us:false ~trim:true t\n let to_sec_string t = to_string_gen ~drop_ms:true ~drop_us:true ~trim:false t\n\n let to_millisecond_string t =\n to_string_gen ~drop_ms:false ~drop_us:true ~trim:false t\n ;;\n\n let small_diff =\n let hour = 3600. in\n fun ofday1 ofday2 ->\n let ofday1 = Span.to_sec (T.to_span_since_start_of_day ofday1) in\n let ofday2 = Span.to_sec (T.to_span_since_start_of_day ofday2) in\n let diff = ofday1 -. ofday2 in\n (* d1 is in (-hour; hour) *)\n let d1 = Float.mod_float diff hour in\n (* d2 is in (0;hour) *)\n let d2 = Float.mod_float (d1 +. hour) hour in\n let d = if Float.( > ) d2 (hour /. 2.) then d2 -. hour else d2 in\n Span.of_sec d\n ;;\n\n include T\n\n let to_string t = to_string_gen ~drop_ms:false ~drop_us:false ~trim:false t\n\n include Pretty_printer.Register (struct\n type nonrec t = t\n\n let to_string = to_string\n let module_name = \"Core_kernel.Time.Ofday\"\n end)\n\n let create_from_parsed string ~hr ~min ~sec ~subsec_pos ~subsec_len =\n let subsec =\n if Int.equal subsec_len 0\n then 0.\n else Float.of_string (String.sub string ~pos:subsec_pos ~len:subsec_len)\n in\n Float.of_int ((hr * 3600) + (min * 60) + sec) +. subsec\n |> Span.of_sec\n |> T.of_span_since_start_of_day_exn\n ;;\n\n let of_string s = Ofday_helpers.parse s ~f:create_from_parsed\n\n let t_of_sexp sexp =\n match sexp with\n | Sexp.Atom s ->\n (try of_string s with\n | Invalid_argument s -> of_sexp_error (\"Ofday.t_of_sexp: \" ^ s) sexp)\n | _ -> of_sexp_error \"Ofday.t_of_sexp\" sexp\n ;;\n\n let sexp_of_t span = Sexp.Atom (to_string span)\n\n let of_string_iso8601_extended ?pos ?len str =\n try Ofday_helpers.parse_iso8601_extended ?pos ?len str ~f:create_from_parsed with\n | exn ->\n invalid_argf\n \"Ofday.of_string_iso8601_extended(%s): %s\"\n (String.subo str ?pos ?len)\n (Exn.to_string exn)\n ()\n ;;\n end\nend\n\ninclude Stable.V1\n\nlet gen_incl lo hi =\n Span.gen_incl (to_span_since_start_of_day lo) (to_span_since_start_of_day hi)\n |> Quickcheck.Generator.map ~f:of_span_since_start_of_day_exn\n;;\n\nlet gen_uniform_incl lo hi =\n Span.gen_uniform_incl (to_span_since_start_of_day lo) (to_span_since_start_of_day hi)\n |> Quickcheck.Generator.map ~f:of_span_since_start_of_day_exn\n;;\n\nlet quickcheck_generator = gen_incl start_of_day start_of_next_day\n\nlet quickcheck_observer =\n Quickcheck.Observer.unmap Span.quickcheck_observer ~f:to_span_since_start_of_day\n;;\n\nlet quickcheck_shrinker = Quickcheck.Shrinker.empty ()\n\ninclude Hashable.Make_binable (struct\n type nonrec t = t [@@deriving bin_io, compare, hash, sexp_of]\n\n (* Previous versions rendered hash-based containers using float serialization rather\n than time serialization, so when reading hash-based containers in we accept either\n serialization. *)\n let t_of_sexp sexp =\n match Float.t_of_sexp sexp with\n | float -> of_float float\n | exception _ -> t_of_sexp sexp\n ;;\n end)\n\nmodule C = struct\n type t = T.t [@@deriving bin_io]\n type comparator_witness = T.comparator_witness\n\n let comparator = T.comparator\n\n (* In 108.06a and earlier, ofdays in sexps of Maps and Sets were raw floats. From\n 108.07 through 109.13, the output format remained raw as before, but both the raw and\n pretty format were accepted as input. From 109.14 on, the output format was changed\n from raw to pretty, while continuing to accept both formats. Once we believe most\n programs are beyond 109.14, we will switch the input format to no longer accept\n raw. *)\n let sexp_of_t = sexp_of_t\n\n let t_of_sexp sexp =\n match Option.try_with (fun () -> T.of_float (Float.t_of_sexp sexp)) with\n | Some t -> t\n | None -> t_of_sexp sexp\n ;;\nend\n\nmodule Map = Map.Make_binable_using_comparator (C)\nmodule Set = Set.Make_binable_using_comparator (C)\n\nlet of_span_since_start_of_day = of_span_since_start_of_day_exn\nlet to_millisec_string = to_millisecond_string\n","open! Import\nopen Std_internal\nopen! Int63.O\n\nlet module_name = \"Core_kernel.Time_ns.Span\"\n\ntype underlying = Int63.t\n\nlet arch_sixtyfour = Int.equal Sys.word_size 64\nlet round_nearest = Float.int63_round_nearest_exn\nlet float x = Int63.to_float x\n\n(* [Span] is basically a [Int63]. It even silently ignores overflow. *)\nmodule T = struct\n type t = Int63.t (* nanoseconds *) [@@deriving hash, bin_io, quickcheck, typerep]\n\n module Replace_polymorphic_compare = Int63.Replace_polymorphic_compare\n\n let zero = Int63.zero\nend\n\ninclude T\nopen Replace_polymorphic_compare\n\nmodule Parts = struct\n type t =\n { sign : Sign.t\n ; hr : int\n ; min : int\n ; sec : int\n ; ms : int\n ; us : int\n ; ns : int\n }\n [@@deriving compare, sexp]\nend\n\nlet next t = Int63.succ t\nlet prev t = Int63.pred t\nlet nanosecond = Int63.of_int 1\nlet microsecond = Int63.(of_int 1000 * nanosecond)\nlet millisecond = Int63.(of_int 1000 * microsecond)\nlet second = Int63.(of_int 1000 * millisecond)\nlet minute = Int63.(of_int 60 * second)\nlet hour = Int63.(of_int 60 * minute)\nlet day = Int63.(of_int 24 * hour)\n\n(* Beyond [min_value_for_1us_rounding..max_value_for_1us_rounding], not every microsecond\n can be represented as a [float] number of seconds. (In fact, it is around 135y, but we\n leave a small margin.)\n\n In the presence of silently ignored overflow, note that [t] is not actually bound to\n stay between these limits. *)\nlet max_value_for_1us_rounding = Int63.(of_int 135 * of_int 365 * day)\nlet min_value_for_1us_rounding = Int63.neg max_value_for_1us_rounding\n\nlet create\n ?sign:(sign_ = Sign.Pos (* rebind so not shadowed by [open Int63] below *))\n ?day:(days = 0)\n ?(hr = 0)\n ?min:(minutes = 0)\n ?(sec = 0)\n ?(ms = 0)\n ?(us = 0)\n ?(ns = 0)\n ()\n =\n let open Int63 in\n let t =\n (of_int days * day)\n + (of_int hr * hour)\n + (of_int minutes * minute)\n + (of_int sec * second)\n + (of_int ms * millisecond)\n + (of_int us * microsecond)\n + (of_int ns * nanosecond)\n in\n match sign_ with\n | Neg -> neg t\n | Pos | Zero -> t\n;;\n\nlet to_parts t =\n let open Int63 in\n let mag = abs t in\n { Parts.sign = (if t < zero then Neg else if t > zero then Pos else Zero)\n ; hr = to_int_exn (mag / hour)\n ; min = to_int_exn (rem mag hour / minute)\n ; sec = to_int_exn (rem mag minute / second)\n ; ms = to_int_exn (rem mag second / millisecond)\n ; us = to_int_exn (rem mag millisecond / microsecond)\n ; ns = to_int_exn (rem mag microsecond / nanosecond)\n }\n;;\n\nlet of_parts { Parts.sign; hr; min; sec; ms; us; ns } =\n create ~sign ~hr ~min ~sec ~ms ~us ~ns ()\n;;\n\nlet of_ns f = round_nearest f\nlet of_int63_ns i = i\nlet of_int_us i = Int63.(of_int i * microsecond)\nlet of_int_ms i = Int63.(of_int i * millisecond)\nlet of_int_sec i = Int63.(of_int i * second)\nlet of_us f = round_nearest (f *. float microsecond)\nlet of_ms f = round_nearest (f *. float millisecond)\nlet of_sec f = round_nearest (f *. float second)\nlet of_min f = round_nearest (f *. float minute)\nlet of_hr f = round_nearest (f *. float hour)\nlet of_day f = round_nearest (f *. float day)\n\nlet of_sec_with_microsecond_precision sec =\n let us = round_nearest (sec *. 1e6) in\n of_int63_ns Int63.(us * of_int 1000)\n;;\n\nlet of_int63_seconds x = x * second\nlet of_int32_seconds x = of_int63_seconds (Int63.of_int32 x)\n\nlet to_ns t = float t\nlet to_int63_ns t = t\nlet to_us t = float t /. float microsecond\nlet to_ms t = float t /. float millisecond\nlet to_sec t = float t /. float second\nlet to_min t = float t /. float minute\nlet to_hr t = float t /. float hour\nlet to_day t = float t /. float day\nlet to_int_us t = Int63.(to_int_exn (t / microsecond))\nlet to_int_ms t = Int63.(to_int_exn (t / millisecond))\nlet to_int_sec t = Int63.(to_int_exn (t / second))\nlet to_int63_seconds_round_down_exn t = t /% second\nlet of_int_ns i = of_int63_ns (Int63.of_int i)\n\nlet to_int_ns =\n if arch_sixtyfour\n then fun t -> Int63.to_int_exn (to_int63_ns t)\n else fun _ -> failwith \"Time_ns.Span.to_int_ns: unsupported on 32bit machines\"\n;;\n\nlet ( + ) t u = Int63.( + ) t u\nlet ( - ) t u = Int63.( - ) t u\nlet abs = Int63.abs\nlet neg = Int63.neg\nlet scale t f = round_nearest (float t *. f)\nlet scale_int63 t i = Int63.( * ) t i\nlet scale_int t i = scale_int63 t (Int63.of_int i)\nlet div = Int63.( /% )\nlet ( / ) t f = round_nearest (float t /. f)\nlet ( // ) = Int63.( // )\nlet to_proportional_float t = Int63.to_float t\n\nlet of_unit_of_time u =\n match (u : Unit_of_time.t) with\n | Nanosecond -> nanosecond\n | Microsecond -> microsecond\n | Millisecond -> millisecond\n | Second -> second\n | Minute -> minute\n | Hour -> hour\n | Day -> day\n;;\n\nlet to_unit_of_time t : Unit_of_time.t =\n let abs_t = abs t in\n if abs_t >= day\n then Day\n else if abs_t >= hour\n then Hour\n else if abs_t >= minute\n then Minute\n else if abs_t >= second\n then Second\n else if abs_t >= millisecond\n then Millisecond\n else if abs_t >= microsecond\n then Microsecond\n else Nanosecond\n;;\n\nmodule Stable = struct\n module V2 = struct\n module T = struct\n module T0 = struct\n type nonrec t = t [@@deriving bin_io, compare, hash]\n\n let of_int63_exn t = of_int63_ns t\n let to_int63 t = to_int63_ns t\n\n module To_string = struct\n let number_of_digits_to_write ~span_part_magnitude =\n let open Int.O in\n if span_part_magnitude = 0\n then 0\n else if span_part_magnitude < 10\n then 1\n else if span_part_magnitude < 100\n then 2\n else if span_part_magnitude < 1_000\n then 3\n else if span_part_magnitude < 10_000\n then 4\n else if span_part_magnitude < 100_000\n then 5\n else assert false\n ;;\n\n (* span part magnitudes are always < 100_000 *)\n\n let number_of_decimal_places_to_write ~billionths =\n let open Int.O in\n assert (billionths >= 0 && billionths <= 999_999_999);\n if billionths = 0\n then 0\n else if billionths % 10 <> 0\n then 9\n else if billionths % 100 <> 0\n then 8\n else if billionths % 1_000 <> 0\n then 7\n else if billionths % 10_000 <> 0\n then 6\n else if billionths % 100_000 <> 0\n then 5\n else if billionths % 1_000_000 <> 0\n then 4\n else if billionths % 10_000_000 <> 0\n then 3\n else if billionths % 100_000_000 <> 0\n then 2\n else 1\n ;;\n\n let write_char buf ~pos char =\n let open Int.O in\n Bytes.unsafe_set buf pos char;\n pos + 1\n ;;\n\n let write_2_chars buf ~pos char1 char2 =\n let open Int.O in\n Bytes.unsafe_set buf pos char1;\n Bytes.unsafe_set buf (pos + 1) char2;\n pos + 2\n ;;\n\n let write_digits buf ~pos ~digits int =\n let open Int.O in\n Digit_string_helpers.write_int63 buf ~pos ~digits (Int63.of_int int);\n pos + digits\n ;;\n\n let write_decimals buf ~pos ~decimals ~billionths =\n let open Int.O in\n Digit_string_helpers.write_int63\n buf\n ~pos\n ~digits:decimals\n (Int63.of_int (billionths / Int.pow 10 (9 - decimals)));\n pos + decimals\n ;;\n\n let write_if_non_empty buf ~pos ~digits int suffix =\n let open Int.O in\n if digits = 0\n then pos\n else (\n let pos = write_digits buf ~pos ~digits int in\n let pos = write_char buf ~pos suffix in\n pos)\n ;;\n\n let nanos_of_millisecond = to_int63_ns millisecond |> Int63.to_int_exn\n let nanos_of_microsecond = to_int63_ns microsecond |> Int63.to_int_exn\n let int63_60 = Int63.of_int 60\n let int63_24 = Int63.of_int 24\n\n (* Units of seconds and smaller can be written in decimal notation without\n worrying about non-power-of-ten factors. *)\n module Decimal_unit = struct\n type t =\n | Second\n | Millisecond\n | Microsecond\n | Nanosecond\n | None\n [@@deriving compare, sexp_of]\n\n let create ~s ~ns =\n let open Int.O in\n if s > 0\n then Second\n else if ns >= nanos_of_millisecond\n then Millisecond\n else if ns >= nanos_of_microsecond\n then Microsecond\n else if ns >= 1\n then Nanosecond\n else None\n ;;\n\n let integer t ~s ~ns =\n let open Int.O in\n match t with\n | Second -> s\n | Millisecond -> ns / nanos_of_millisecond\n | Microsecond -> ns / nanos_of_microsecond\n | Nanosecond -> ns\n | None -> 0\n ;;\n\n let billionths t ~ns =\n let open Int.O in\n match t with\n | Second -> ns\n | Millisecond -> ns % nanos_of_millisecond * 1_000\n | Microsecond -> ns % nanos_of_microsecond * 1_000_000\n | Nanosecond -> 0\n | None -> 0\n ;;\n\n let length t ~digits ~decimals =\n let open Int.O in\n let digits_len =\n match t with\n | Second -> digits + 1\n | Millisecond | Microsecond | Nanosecond -> digits + 2\n | None -> 0\n in\n let decimals_len = if decimals > 0 then decimals + 1 else 0 in\n digits_len + decimals_len\n ;;\n\n let write_suffix t buf ~pos =\n match t with\n | Second -> write_char buf ~pos 's'\n | Millisecond -> write_2_chars buf ~pos 'm' 's'\n | Microsecond -> write_2_chars buf ~pos 'u' 's'\n | Nanosecond -> write_2_chars buf ~pos 'n' 's'\n | None -> pos\n ;;\n\n let write t buf ~pos ~integer ~digits ~billionths ~decimals =\n let open Int.O in\n if digits = 0\n then pos\n else (\n let pos = write_digits buf ~pos integer ~digits in\n let pos =\n if decimals = 0\n then pos\n else (\n let pos = write_char buf ~pos '.' in\n write_decimals buf ~pos ~billionths ~decimals)\n in\n write_suffix t buf ~pos)\n ;;\n end\n\n let to_string t =\n if equal t zero\n then \"0s\"\n else (\n let is_negative = t < zero in\n let seconds = Int63.( / ) (to_int63_ns t) (to_int63_ns second) in\n let ns =\n Int63.rem (to_int63_ns t) (to_int63_ns second) |> Int63.to_int_exn\n in\n let seconds = Int63.abs seconds in\n let ns = Int.abs ns in\n let s = Int63.rem seconds int63_60 |> Int63.to_int_exn in\n let minutes = Int63.( / ) seconds int63_60 in\n let m = Int63.rem minutes int63_60 |> Int63.to_int_exn in\n let hours = Int63.( / ) minutes int63_60 in\n let h = Int63.rem hours int63_24 |> Int63.to_int_exn in\n let d = Int63.( / ) hours int63_24 |> Int63.to_int_exn in\n let open Int.O in\n let digits_of_d = number_of_digits_to_write ~span_part_magnitude:d in\n let digits_of_h = number_of_digits_to_write ~span_part_magnitude:h in\n let digits_of_m = number_of_digits_to_write ~span_part_magnitude:m in\n let decimal_unit = Decimal_unit.create ~s ~ns in\n let decimal_unit_integer = Decimal_unit.integer decimal_unit ~s ~ns in\n let decimal_unit_billionths = Decimal_unit.billionths decimal_unit ~ns in\n let digits_of_decimal_unit =\n number_of_digits_to_write ~span_part_magnitude:decimal_unit_integer\n in\n let decimals_of_decimal_unit =\n number_of_decimal_places_to_write ~billionths:decimal_unit_billionths\n in\n let string_length =\n let sign_len = if is_negative then 1 else 0 in\n let d_len = if digits_of_d > 0 then digits_of_d + 1 else 0 in\n let h_len = if digits_of_h > 0 then digits_of_h + 1 else 0 in\n let m_len = if digits_of_m > 0 then digits_of_m + 1 else 0 in\n let decimal_unit_len =\n Decimal_unit.length\n decimal_unit\n ~digits:digits_of_decimal_unit\n ~decimals:decimals_of_decimal_unit\n in\n sign_len + d_len + h_len + m_len + decimal_unit_len\n in\n assert (string_length > 0);\n let buf = Bytes.create string_length in\n let pos = 0 in\n let pos = if is_negative then write_char buf ~pos '-' else pos in\n let pos = write_if_non_empty buf ~pos ~digits:digits_of_d d 'd' in\n let pos = write_if_non_empty buf ~pos ~digits:digits_of_h h 'h' in\n let pos = write_if_non_empty buf ~pos ~digits:digits_of_m m 'm' in\n let pos =\n Decimal_unit.write\n decimal_unit\n buf\n ~pos\n ~integer:decimal_unit_integer\n ~digits:digits_of_decimal_unit\n ~billionths:decimal_unit_billionths\n ~decimals:decimals_of_decimal_unit\n in\n assert (pos = string_length);\n Bytes.unsafe_to_string ~no_mutation_while_string_reachable:buf)\n ;;\n end\n\n let to_string = To_string.to_string\n\n module Of_string = struct\n (* We do computations using negative numbers everywhere and test against\n things related to [Int63.min_value] rather than using positive numbers\n and testing against things related to [Int63.max_value] because the\n negative integer range is one wider than the positive integer range\n (-2**63 vs 2**63-1), and we need that to be able to handle Int63.min_value\n nicely. *)\n\n let int63_10 = Int63.of_int 10\n let min_mult10_without_underflow = Int63.(min_value / int63_10)\n\n let[@cold] invalid_string string ~reason =\n raise_s\n [%message\n \"Time_ns.Span.of_string: invalid string\"\n (string : string)\n (reason : string)]\n ;;\n\n (* Assumes x and y are both nonpositive *)\n let add_without_underflow ~string x y =\n let open Int63.O in\n let sum = x + y in\n if sum > x\n then invalid_string string ~reason:\"span would be outside of int63 range\";\n sum\n ;;\n\n let add_neg_digit ~string int63 char =\n let open Int63.O in\n let digit = Int63.of_int (Char.get_digit_exn char) in\n if int63 < min_mult10_without_underflow\n then invalid_string string ~reason:\"span would be outside of int63 range\";\n add_without_underflow ~string (int63 * int63_10) (-digit)\n ;;\n\n let min_factor_of span = Int63.( / ) Int63.min_value (to_int63_ns span)\n let min_days_without_underflow = min_factor_of day\n let min_hours_without_underflow = min_factor_of hour\n let min_minutes_without_underflow = min_factor_of minute\n let min_seconds_without_underflow = min_factor_of second\n let min_milliseconds_without_underflow = min_factor_of millisecond\n let min_microseconds_without_underflow = min_factor_of microsecond\n let min_nanoseconds_without_underflow = min_factor_of nanosecond\n\n let min_without_underflow_of_unit_of_time unit_of_time =\n match (unit_of_time : Unit_of_time.t) with\n | Day -> min_days_without_underflow\n | Hour -> min_hours_without_underflow\n | Minute -> min_minutes_without_underflow\n | Second -> min_seconds_without_underflow\n | Millisecond -> min_milliseconds_without_underflow\n | Microsecond -> min_microseconds_without_underflow\n | Nanosecond -> min_nanoseconds_without_underflow\n ;;\n\n let negative_part\n string\n ~neg_integer\n ~decimal_pos\n ~end_pos\n ~unit_of_time\n ~round_ties_before_negating\n =\n let open Int.O in\n let scale = to_int63_ns (of_unit_of_time unit_of_time) in\n let min_without_underflow =\n min_without_underflow_of_unit_of_time unit_of_time\n in\n if Int63.( < ) neg_integer min_without_underflow\n then invalid_string string ~reason:\"span would be outside of int63 range\";\n let neg_integer_ns = Int63.( * ) neg_integer scale in\n let fraction_pos = decimal_pos + 1 in\n if fraction_pos >= end_pos\n then neg_integer_ns\n else (\n let decimal_ns =\n Digit_string_helpers.read_int63_decimal\n string\n ~pos:fraction_pos\n ~scale\n ~decimals:(end_pos - fraction_pos)\n ~allow_underscore:true\n ~round_ties:round_ties_before_negating\n in\n add_without_underflow ~string neg_integer_ns (Int63.( ~- ) decimal_ns))\n ;;\n\n let of_string string =\n let open Int.O in\n let neg_ns = ref Int63.zero in\n let pos = ref 0 in\n let len = String.length string in\n if len = 0 then invalid_string string ~reason:\"empty string\";\n let is_negative =\n match String.unsafe_get string !pos with\n | '-' ->\n incr pos;\n true\n | '+' ->\n incr pos;\n false\n | _ -> false\n in\n let round_ties_before_negating : Digit_string_helpers.Round.t =\n (* Ultimately, we always round parsed spans towards positive infinity when\n the nearest round ns are equidistant. For example, \"1.5ns\" is read as\n 2.0ns, and \"-1.5ns\" is read as -1ns. Since we read absolute values before\n applying the sign, we must choose our rounding direction based on the\n sign. Rounding decimal values happens before negating their magnitude. *)\n match is_negative with\n | false -> Toward_positive_infinity\n | true -> Toward_negative_infinity\n in\n (* Loop over parts, like \"5m\" in \"1h5m30s\" *)\n while !pos < len do\n let has_digit = ref false in\n let neg_integer =\n let i = ref Int63.zero in\n let end_of_digits = ref false in\n while !pos < len && not !end_of_digits do\n let c = String.unsafe_get string !pos in\n match c with\n | '0' .. '9' ->\n i := add_neg_digit ~string !i c;\n has_digit := true;\n incr pos\n | '_' -> incr pos\n | _ -> end_of_digits := true\n done;\n !i\n in\n let decimal_pos = !pos in\n if !pos < len && Char.equal '.' (String.unsafe_get string !pos)\n then (\n incr pos;\n let end_of_decimals = ref false in\n while !pos < len && not !end_of_decimals do\n match String.unsafe_get string !pos with\n | '0' .. '9' ->\n has_digit := true;\n incr pos\n | '_' -> incr pos\n | _ -> end_of_decimals := true\n done);\n let end_pos = !pos in\n if not !has_digit\n then invalid_string string ~reason:\"no digits before unit suffix\";\n let unit_of_time : Unit_of_time.t =\n if !pos + 1 < len && Char.equal 's' (String.unsafe_get string (!pos + 1))\n then (\n match String.unsafe_get string !pos with\n | 'm' ->\n pos := !pos + 2;\n Millisecond\n | 'u' ->\n pos := !pos + 2;\n Microsecond\n | 'n' ->\n pos := !pos + 2;\n Nanosecond\n | _ -> invalid_string string ~reason:\"unparseable unit suffix\")\n else if !pos < len\n then (\n match String.unsafe_get string !pos with\n | 'd' ->\n incr pos;\n Day\n | 'h' ->\n incr pos;\n Hour\n | 'm' ->\n incr pos;\n Minute\n | 's' ->\n incr pos;\n Second\n | _ -> invalid_string string ~reason:\"unparseable unit suffix\")\n else invalid_string string ~reason:\"no unit suffix after digits\"\n in\n let neg_nanos_of_part =\n negative_part\n string\n ~neg_integer\n ~decimal_pos\n ~end_pos\n ~unit_of_time\n ~round_ties_before_negating\n in\n neg_ns := add_without_underflow ~string !neg_ns neg_nanos_of_part\n done;\n let ns =\n if is_negative\n then !neg_ns\n else if Int63.( = ) !neg_ns Int63.min_value\n then invalid_string string ~reason:\"span would be outside of int63 range\"\n else Int63.( ~- ) !neg_ns\n in\n of_int63_ns ns\n ;;\n end\n\n let of_string = Of_string.of_string\n let sexp_of_t t = Sexp.Atom (to_string t)\n\n let t_of_sexp sexp =\n match sexp with\n | Sexp.Atom x ->\n (try of_string x with\n | exn -> of_sexp_error (Exn.to_string exn) sexp)\n | Sexp.List _ ->\n of_sexp_error \"Time_ns.Span.Stable.V2.t_of_sexp: sexp must be an Atom\" sexp\n ;;\n end\n\n include T0\n include Comparator.Stable.V1.Make (T0)\n end\n\n include T\n include Comparable.Stable.V1.Make (T)\n end\nend\n\nlet to_string = Stable.V2.to_string\nlet of_string = Stable.V2.of_string\nlet sexp_of_t = Stable.V2.sexp_of_t\nlet t_of_sexp = Stable.V2.t_of_sexp\n\nmodule Alternate_sexp = struct\n type nonrec t = t [@@deriving sexp]\nend\n\ninclude Comparable.Validate_with_zero (struct\n type nonrec t = t [@@deriving compare, sexp]\n\n let zero = zero\n end)\n\n(* Functions required by [Robustly_comparable]: allows for [robust_comparison_tolerance]\n granularity.\n\n A microsecond is a reasonable granularity because there is very little network\n activity that can be measured to sub-microsecond resolution. *)\nlet robust_comparison_tolerance = microsecond\nlet ( >=. ) t u = t >= Int63.(u - robust_comparison_tolerance)\nlet ( <=. ) t u = t <= Int63.(u + robust_comparison_tolerance)\nlet ( =. ) t u = Int63.(abs (t - u)) <= robust_comparison_tolerance\nlet ( >. ) t u = t > Int63.(u + robust_comparison_tolerance)\nlet ( <. ) t u = t < Int63.(u - robust_comparison_tolerance)\nlet ( <>. ) t u = Int63.(abs (t - u)) > robust_comparison_tolerance\nlet robustly_compare t u = if t <. u then -1 else if t >. u then 1 else 0\n\n(* We don't just convert to [Time.Span.t] and use the conversion there because our\n [to_span] conversion is limited to microsecond precision. *)\nlet to_string_hum\n ?(delimiter = '_')\n ?(decimals = 3)\n ?(align_decimal = false)\n ?unit_of_time\n t\n =\n let float, suffix =\n match Option.value unit_of_time ~default:(to_unit_of_time t) with\n | Day -> to_day t, \"d\"\n | Hour -> to_hr t, \"h\"\n | Minute -> to_min t, \"m\"\n | Second -> to_sec t, \"s\"\n | Millisecond -> to_ms t, \"ms\"\n | Microsecond -> to_us t, \"us\"\n | Nanosecond -> to_ns t, \"ns\"\n in\n let prefix =\n Float.to_string_hum float ~delimiter ~decimals ~strip_zero:(not align_decimal)\n in\n let suffix =\n if align_decimal && Int.( = ) (String.length suffix) 1 then suffix ^ \" \" else suffix\n in\n prefix ^ suffix\n;;\n\nlet since_unix_epoch () = Time_now.nanoseconds_since_unix_epoch () |> of_int63_ns\n\nlet random ?state () =\n Int63.random ?state (max_value_for_1us_rounding + Int63.one)\n - Int63.random ?state (neg min_value_for_1us_rounding + Int63.one)\n;;\n\nlet randomize t ~percent = Span_helpers.randomize t ~percent ~scale\n\nlet to_short_string t =\n let ({ sign; hr; min; sec; ms; us; ns } : Parts.t) = to_parts t in\n Span_helpers.short_string ~sign ~hr ~min ~sec ~ms ~us ~ns\n;;\n\nlet gen_incl = Int63.gen_incl\nlet gen_uniform_incl = Int63.gen_uniform_incl\n\ninclude Pretty_printer.Register (struct\n type nonrec t = t\n\n let to_string = to_string\n let module_name = module_name\n end)\n\ninclude Hashable.Make_binable (struct\n type nonrec t = t [@@deriving bin_io, compare, hash, sexp]\n end)\n\ntype comparator_witness = Stable.V2.comparator_witness\n\ninclude Comparable.Make_binable_using_comparator (struct\n type nonrec t = t [@@deriving bin_io, compare, sexp]\n type nonrec comparator_witness = comparator_witness\n\n let comparator = Stable.V2.comparator\n end)\n\n(* re-include [Replace_polymorphic_compare] and its comparisons to shadow the\n un-inlineable ones from [Comparable] *)\nmodule Replace_polymorphic_compare = T.Replace_polymorphic_compare\ninclude Replace_polymorphic_compare\n\nlet to_span_float_round_nearest t = Span_float.of_sec (to_sec t)\nlet of_span_float_round_nearest s = of_sec (Span_float.to_sec s)\nlet half_microsecond = Int63.of_int 500\nlet nearest_microsecond t = Int63.((to_int63_ns t + half_microsecond) /% of_int 1000)\n\nlet[@cold] invalid_range_for_1us_rounding t =\n raise_s\n [%message\n \"Span.t exceeds limits\"\n (t : t)\n (min_value_for_1us_rounding : t)\n (max_value_for_1us_rounding : t)]\n;;\n\nlet check_range_for_1us_rounding t =\n if t < min_value_for_1us_rounding || t > max_value_for_1us_rounding\n then invalid_range_for_1us_rounding t\n else t\n;;\n\nlet to_span_float_round_nearest_microsecond t =\n Span_float.of_us\n (Int63.to_float (nearest_microsecond (check_range_for_1us_rounding t)))\n;;\n\nlet min_span_float_value_for_1us_rounding =\n to_span_float_round_nearest min_value_for_1us_rounding\n;;\n\nlet max_span_float_value_for_1us_rounding =\n to_span_float_round_nearest max_value_for_1us_rounding\n;;\n\nlet of_span_float_round_nearest_microsecond s =\n if Span_float.( > ) s max_span_float_value_for_1us_rounding\n || Span_float.( < ) s min_span_float_value_for_1us_rounding\n then\n failwiths\n ~here:[%here]\n \"Time_ns.Span does not support this span\"\n s\n [%sexp_of: Span_float.t];\n (* Using [Time.Span.to_sec] (being the identity) so that\n we make don't apply too many conversion\n - Too many : `[Span.t] -> [a] -> [t]`\n - Only One : `[Span.t]==[a] -> [t]`. *)\n of_sec_with_microsecond_precision (Span_float.to_sec s)\n;;\n\nlet min_value_representable = of_int63_ns Int63.min_value\nlet max_value_representable = of_int63_ns Int63.max_value\n\nmodule Private = struct\n module Parts = Parts\n\n let of_parts = of_parts\n let to_parts = to_parts\nend\n\n(* Legacy definitions based on rounding to the nearest microsecond. *)\nlet min_value = min_value_for_1us_rounding\nlet max_value = max_value_for_1us_rounding\nlet of_span = of_span_float_round_nearest_microsecond\nlet to_span = to_span_float_round_nearest_microsecond\n","open! Import\nmodule Span = Span_ns\n\ntype underlying = Int63.t\n\ntype t = Span.t (* since wall-clock midnight *)\n[@@deriving bin_io, compare, hash, typerep]\n\ninclude (Span : Robustly_comparable.S with type t := t)\n\nlet to_parts t = Span.to_parts t\n\n\nlet start_of_day : t = Span.zero\nlet start_of_next_day : t = Span.day\nlet approximate_end_of_day = Span.( - ) start_of_next_day Span.nanosecond\nlet to_span_since_start_of_day t = t\n\nlet[@cold] input_out_of_bounds span =\n raise_s\n [%message\n \"Time_ns.Ofday.of_span_since_start_of_day_exn: input out of bounds\"\n ~_:(span : Span.t)]\n;;\n\nlet[@inline always] is_invalid span =\n (* Why we use [Span.( > )] rather than [( >= )] below:\n\n We allow to represent the end-of-day sentinel value ([24.000000000h]), which is not\n itself a valid clock face time. However, since valid clock face times readily\n round up to it, it's better to allow it to be represented. *)\n Span.( < ) span start_of_day || Span.( > ) span start_of_next_day\n;;\n\nlet span_since_start_of_day_is_valid span = not (is_invalid span)\nlet of_span_since_start_of_day_unchecked span = span\n\nlet of_span_since_start_of_day_exn span =\n if is_invalid span then input_out_of_bounds span else span\n;;\n\nlet of_span_since_start_of_day_opt span = if is_invalid span then None else Some span\nlet add_exn t span = of_span_since_start_of_day_exn (Span.( + ) t span)\nlet sub_exn t span = of_span_since_start_of_day_exn (Span.( - ) t span)\nlet add t span = of_span_since_start_of_day_opt (Span.( + ) t span)\nlet sub t span = of_span_since_start_of_day_opt (Span.( - ) t span)\nlet next t = of_span_since_start_of_day_opt (Span.next t)\nlet prev t = of_span_since_start_of_day_opt (Span.prev t)\nlet diff t u = Span.( - ) t u\n\nlet create ?hr ?min ?sec ?ms ?us ?ns () =\n (* Similar to [Time.Ofday.create], if we detect a leap second we strip off all\n sub-second elements so that HH:MM:60.XXXXXXXXX is all mapped to HH:MM:60. *)\n let ms, us, ns =\n match sec with\n | Some 60 -> Some 0, Some 0, Some 0\n | _ -> ms, us, ns\n in\n of_span_since_start_of_day_exn (Span.create ?hr ?min ?sec ?ms ?us ?ns ())\n;;\n\nmodule Stable = struct\n module V1 = struct\n module T = struct\n type nonrec t = t [@@deriving compare, bin_io]\n\n let to_string_with_unit =\n let ( / ) = Int63.( / ) in\n let ( mod ) = Int63.rem in\n let ( ! ) = Int63.of_int in\n let i = Int63.to_int_exn in\n fun t ~unit ->\n if Span.( < ) t start_of_day || Span.( < ) start_of_next_day t\n then \"Incorrect day\"\n else (\n let sixty = !60 in\n let thousand = !1000 in\n let ns = Span.to_int63_ns t in\n let us = ns / thousand in\n let ns = ns mod thousand |> i in\n let ms = us / thousand in\n let us = us mod thousand |> i in\n let s = ms / thousand in\n let ms = ms mod thousand |> i in\n let m = s / sixty in\n let s = s mod sixty |> i in\n let h = m / sixty |> i in\n let m = m mod sixty |> i in\n let unit =\n match unit with\n | (`Nanosecond | `Millisecond | `Second) as unit -> unit\n | `Minute_or_less ->\n if ns <> 0\n then `Nanosecond\n else if us <> 0\n then `Microsecond\n else if ms <> 0\n then `Millisecond\n else if s <> 0\n then `Second\n else `Minute\n in\n let len =\n match unit with\n | `Minute -> 5\n | `Second -> 8\n | `Millisecond -> 12\n | `Microsecond -> 15\n | `Nanosecond -> 18\n in\n let str = Bytes.create len in\n Digit_string_helpers.write_2_digit_int str ~pos:0 h;\n Bytes.set str 2 ':';\n Digit_string_helpers.write_2_digit_int str ~pos:3 m;\n (match unit with\n | `Minute -> ()\n | (`Second | `Millisecond | `Microsecond | `Nanosecond) as unit ->\n Bytes.set str 5 ':';\n Digit_string_helpers.write_2_digit_int str ~pos:6 s;\n (match unit with\n | `Second -> ()\n | (`Millisecond | `Microsecond | `Nanosecond) as unit ->\n Bytes.set str 8 '.';\n Digit_string_helpers.write_3_digit_int str ~pos:9 ms;\n (match unit with\n | `Millisecond -> ()\n | (`Microsecond | `Nanosecond) as unit ->\n Digit_string_helpers.write_3_digit_int str ~pos:12 us;\n (match unit with\n | `Microsecond -> ()\n | `Nanosecond -> Digit_string_helpers.write_3_digit_int str ~pos:15 ns))));\n Bytes.unsafe_to_string ~no_mutation_while_string_reachable:str)\n ;;\n\n let parse_nanoseconds string ~pos ~until =\n let open Int.O in\n let digits = ref 0 in\n let num_digits = ref 0 in\n let pos = ref pos in\n (* read up to 10 digits; store the first 9, use the 10th to round *)\n while !pos < until && !num_digits < 10 do\n let c = string.[!pos] in\n if Char.is_digit c\n then (\n incr num_digits;\n if !num_digits < 10\n then digits := (!digits * 10) + Char.get_digit_exn c\n else if Char.get_digit_exn c >= 5\n then incr digits\n else ());\n incr pos\n done;\n (* if there are missing digits, add zeroes *)\n if !num_digits < 9 then digits := !digits * Int.pow 10 (9 - !num_digits);\n !digits\n ;;\n\n let create_from_parsed string ~hr ~min ~sec ~subsec_pos ~subsec_len =\n let nanoseconds =\n if Int.equal subsec_len 0\n then 0\n else\n parse_nanoseconds\n string\n ~pos:(subsec_pos + 1)\n ~until:(subsec_pos + subsec_len)\n in\n Span.of_int63_ns (Int63.of_int nanoseconds)\n |> Span.( + ) (Span.scale_int Span.second sec)\n |> Span.( + ) (Span.scale_int Span.minute min)\n |> Span.( + ) (Span.scale_int Span.hour hr)\n |> of_span_since_start_of_day_exn\n ;;\n\n let of_string string = Ofday_helpers.parse string ~f:create_from_parsed\n\n let t_of_sexp sexp : t =\n match sexp with\n | Sexp.List _ -> of_sexp_error \"expected an atom\" sexp\n | Sexp.Atom s ->\n (try of_string s with\n | exn -> of_sexp_error_exn exn sexp)\n ;;\n\n let to_string (t : t) = to_string_with_unit t ~unit:`Nanosecond\n let sexp_of_t (t : t) = Sexp.Atom (to_string t)\n let to_int63 t = Span_ns.Stable.V2.to_int63 t\n\n let of_int63_exn t =\n of_span_since_start_of_day_exn (Span_ns.Stable.V2.of_int63_exn t)\n ;;\n end\n\n include T\n include Comparator.Stable.V1.Make (T)\n end\nend\n\nlet sexp_of_t = Stable.V1.sexp_of_t\nlet t_of_sexp = Stable.V1.t_of_sexp\nlet of_string = Stable.V1.of_string\nlet to_string = Stable.V1.to_string\nlet to_millisecond_string t = Stable.V1.to_string_with_unit t ~unit:`Millisecond\nlet to_sec_string t = Stable.V1.to_string_with_unit t ~unit:`Second\nlet to_string_trimmed t = Stable.V1.to_string_with_unit t ~unit:`Minute_or_less\n\nlet of_string_iso8601_extended ?pos ?len str =\n try\n Ofday_helpers.parse_iso8601_extended ?pos ?len str ~f:Stable.V1.create_from_parsed\n with\n | exn ->\n raise_s\n [%message\n \"Time_ns.Ofday.of_string_iso8601_extended: cannot parse string\"\n ~_:(String.subo str ?pos ?len : string)\n ~_:(exn : exn)]\n;;\n\nlet every =\n let rec every_valid_ofday_span span ~start ~stop ~acc =\n (* Assumes [span], [start], and [stop] are valid ofdays. Assumes [start < stop].\n Assumes [span > 0]. *)\n let acc = start :: acc in\n let start = Span.( + ) start span in\n if Span.( > ) start stop (* cannot overflow *)\n then List.rev acc\n else every_valid_ofday_span span ~start ~stop ~acc\n in\n (* internal [every] named to show up in stack traces *)\n let every span ~start ~stop =\n if Span.( > ) start stop\n then\n Or_error.error_s\n [%message\n \"[Time_ns.Ofday.every] called with [start] > [stop]\" (start : t) (stop : t)]\n else if Span.( <= ) span Span.zero\n then\n Or_error.error_s\n [%message \"[Time_ns.Ofday.every] called with negative span\" ~_:(span : Span.t)]\n else if is_invalid span\n then Ok [ start ]\n else Ok (every_valid_ofday_span span ~start ~stop ~acc:[])\n in\n every\n;;\n\nlet small_diff =\n let hour = Span.to_int63_ns Span.hour in\n fun ofday1 ofday2 ->\n let open Int63.O in\n let ofday1 = Span.to_int63_ns (to_span_since_start_of_day ofday1) in\n let ofday2 = Span.to_int63_ns (to_span_since_start_of_day ofday2) in\n let diff = ofday1 - ofday2 in\n (* d1 is in (-hour; hour) *)\n let d1 = Int63.rem diff hour in\n (* d2 is in (0;hour) *)\n let d2 = Int63.rem (d1 + hour) hour in\n let d = if d2 > hour / Int63.of_int 2 then d2 - hour else d2 in\n Span.of_int63_ns d\n;;\n\nlet%expect_test \"small_diff\" =\n let test x y =\n let diff = small_diff x y in\n printf !\"small_diff %s %s = %s\\n\" (to_string x) (to_string y) (Span.to_string diff)\n in\n let examples =\n List.map\n ~f:(fun (x, y) -> of_string x, of_string y)\n [ \"12:00\", \"12:05\"; \"12:58\", \"13:02\"; \"00:52\", \"23:19\"; \"00:00\", \"24:00\" ]\n in\n List.iter examples ~f:(fun (x, y) ->\n test x y;\n test y x);\n [%expect\n {|\n small_diff 12:00:00.000000000 12:05:00.000000000 = -5m\n small_diff 12:05:00.000000000 12:00:00.000000000 = 5m\n small_diff 12:58:00.000000000 13:02:00.000000000 = -4m\n small_diff 13:02:00.000000000 12:58:00.000000000 = 4m\n small_diff 00:52:00.000000000 23:19:00.000000000 = -27m\n small_diff 23:19:00.000000000 00:52:00.000000000 = 27m\n small_diff 00:00:00.000000000 24:00:00.000000000 = 0s\n small_diff 24:00:00.000000000 00:00:00.000000000 = 0s |}]\n;;\n\nlet gen_incl = Span.gen_incl\nlet gen_uniform_incl = Span.gen_uniform_incl\nlet quickcheck_generator = gen_incl start_of_day start_of_next_day\nlet quickcheck_observer = Span.quickcheck_observer\nlet quickcheck_shrinker = Quickcheck.Shrinker.empty ()\n\ninclude Identifiable.Make (struct\n type nonrec t = t [@@deriving bin_io, compare, hash, sexp]\n\n let module_name = \"Core.Time_ns.Ofday\"\n let hash = Span.hash\n let of_string, to_string = of_string, to_string\n end)\n\ninclude (Span : Comparisons.S with type t := t)\n\n(* deprecated bindings *)\nlet of_span_since_start_of_day = of_span_since_start_of_day_exn\nlet to_millisec_string = to_millisecond_string\n","open! Import\n\nmodule Stable = struct\n module Allocation_policy = struct\n module V1 = struct\n type t =\n | Next_fit\n | First_fit\n | Best_fit\n [@@deriving bin_io, compare, equal, hash, sexp]\n end\n end\nend\n\ninclude Caml.Gc\n\nmodule Stat = struct\n module T = struct\n [%%if ocaml_version >= (4, 12, 0)]\n\n type t = Caml.Gc.stat =\n { minor_words : float\n ; promoted_words : float\n ; major_words : float\n ; minor_collections : int\n ; major_collections : int\n ; heap_words : int\n ; heap_chunks : int\n ; live_words : int\n ; live_blocks : int\n ; free_words : int\n ; free_blocks : int\n ; largest_free : int\n ; fragments : int\n ; compactions : int\n ; top_heap_words : int\n ; stack_size : int\n ; forced_major_collections : int\n }\n [@@deriving compare, hash, bin_io, sexp, fields]\n\n [%%else]\n\n type t = Caml.Gc.stat =\n { minor_words : float\n ; promoted_words : float\n ; major_words : float\n ; minor_collections : int\n ; major_collections : int\n ; heap_words : int\n ; heap_chunks : int\n ; live_words : int\n ; live_blocks : int\n ; free_words : int\n ; free_blocks : int\n ; largest_free : int\n ; fragments : int\n ; compactions : int\n ; top_heap_words : int\n ; stack_size : int\n }\n [@@deriving compare, hash, bin_io, sexp, fields]\n\n [%%endif]\n end\n\n include T\n include Comparable.Make (T)\nend\n\nmodule Control = struct\n module T = struct\n [%%if\n ocaml_version < (4, 08, 0)]\n\n type t = Caml.Gc.control =\n { mutable minor_heap_size : int\n ; mutable major_heap_increment : int\n ; mutable space_overhead : int\n ; mutable verbose : int\n ; mutable max_overhead : int\n ; mutable stack_limit : int\n ; mutable allocation_policy : int\n ; window_size : int\n }\n [@@deriving compare, bin_io, sexp, fields]\n\n [%%else]\n\n [@@@ocaml.warning \"-3\"]\n\n type t = Caml.Gc.control =\n { mutable minor_heap_size : int\n ; mutable major_heap_increment : int\n ; mutable space_overhead : int\n ; mutable verbose : int\n ; mutable max_overhead : int\n ; mutable stack_limit : int\n ; mutable allocation_policy : int\n ; window_size : int\n ; custom_major_ratio : int\n ; custom_minor_ratio : int\n ; custom_minor_max_size : int\n }\n [@@deriving compare, bin_io, sexp, fields]\n\n [%%endif]\n end\n\n include T\n include Comparable.Make (T)\nend\n\nmodule Allocation_policy = struct\n include Stable.Allocation_policy.V1\n\n let to_int = function\n | Next_fit -> 0\n | First_fit -> 1\n | Best_fit -> 2\n ;;\nend\n\n[%%if\n ocaml_version < (4, 08, 0)]\n\nlet tune\n ?logger\n ?minor_heap_size\n ?major_heap_increment\n ?space_overhead\n ?verbose\n ?max_overhead\n ?stack_limit\n ?allocation_policy\n ?window_size\n ()\n =\n let old_control_params = get () in\n let f opt to_string field =\n let old_value = Field.get field old_control_params in\n match opt with\n | None -> old_value\n | Some new_value ->\n Option.iter logger ~f:(fun f ->\n Printf.ksprintf\n f\n \"Gc.Control.%s: %s -> %s\"\n (Field.name field)\n (to_string old_value)\n (to_string new_value));\n new_value\n in\n let allocation_policy = Option.map allocation_policy ~f:Allocation_policy.to_int in\n let new_control_params =\n Control.Fields.map\n ~minor_heap_size:(f minor_heap_size string_of_int)\n ~major_heap_increment:(f major_heap_increment string_of_int)\n ~space_overhead:(f space_overhead string_of_int)\n ~verbose:(f verbose string_of_int)\n ~max_overhead:(f max_overhead string_of_int)\n ~stack_limit:(f stack_limit string_of_int)\n ~allocation_policy:(f allocation_policy string_of_int)\n ~window_size:(f window_size string_of_int)\n in\n set new_control_params\n;;\n\n[%%else]\n\nlet tune\n ?logger\n ?minor_heap_size\n ?major_heap_increment\n ?space_overhead\n ?verbose\n ?max_overhead\n ?stack_limit\n ?allocation_policy\n ?window_size\n ?custom_major_ratio\n ?custom_minor_ratio\n ?custom_minor_max_size\n ()\n =\n let old_control_params = get () in\n let f opt to_string field =\n let old_value = Field.get field old_control_params in\n match opt with\n | None -> old_value\n | Some new_value ->\n Option.iter logger ~f:(fun f ->\n Printf.ksprintf\n f\n \"Gc.Control.%s: %s -> %s\"\n (Field.name field)\n (to_string old_value)\n (to_string new_value));\n new_value\n in\n let allocation_policy = Option.map allocation_policy ~f:Allocation_policy.to_int in\n let new_control_params =\n Control.Fields.map\n ~minor_heap_size:(f minor_heap_size string_of_int)\n ~major_heap_increment:(f major_heap_increment string_of_int)\n ~space_overhead:(f space_overhead string_of_int)\n ~verbose:(f verbose string_of_int)\n ~max_overhead:(f max_overhead string_of_int)\n ~stack_limit:(f stack_limit string_of_int)\n ~allocation_policy:(f allocation_policy string_of_int)\n ~window_size:(f window_size string_of_int)\n ~custom_major_ratio:(f custom_major_ratio string_of_int)\n ~custom_minor_ratio:(f custom_minor_ratio string_of_int)\n ~custom_minor_max_size:(f custom_minor_max_size string_of_int)\n in\n set new_control_params\n;;\n\n[%%endif]\n\nlet disable_compaction ?logger ~allocation_policy () =\n let allocation_policy =\n match allocation_policy with\n | `Don't_change -> None\n | `Set_to policy -> Some policy\n in\n (* The value 1_000_000, according to\n http://caml.inria.fr/pub/docs/manual-ocaml-4.02/libref/Gc.html\n will disable compactions.\n *)\n tune ?logger ?allocation_policy ~max_overhead:1_000_000 ()\n;;\n\nexternal minor_words : unit -> int = \"core_kernel_gc_minor_words\"\nexternal major_words : unit -> int = \"core_kernel_gc_major_words\" [@@noalloc]\nexternal promoted_words : unit -> int = \"core_kernel_gc_promoted_words\" [@@noalloc]\nexternal minor_collections : unit -> int = \"core_kernel_gc_minor_collections\" [@@noalloc]\nexternal major_collections : unit -> int = \"core_kernel_gc_major_collections\" [@@noalloc]\nexternal heap_words : unit -> int = \"core_kernel_gc_heap_words\" [@@noalloc]\nexternal heap_chunks : unit -> int = \"core_kernel_gc_heap_chunks\" [@@noalloc]\nexternal compactions : unit -> int = \"core_kernel_gc_compactions\" [@@noalloc]\nexternal top_heap_words : unit -> int = \"core_kernel_gc_top_heap_words\" [@@noalloc]\nexternal major_plus_minor_words : unit -> int = \"core_kernel_gc_major_plus_minor_words\"\nexternal allocated_words : unit -> int = \"core_kernel_gc_allocated_words\"\n\nlet zero = Sys.opaque_identity (int_of_string \"0\")\n\n(* The compiler won't optimize int_of_string away so it won't\n perform constant folding below. *)\nlet rec keep_alive o = if zero <> 0 then keep_alive (Sys.opaque_identity o)\n\nmodule For_testing = struct\n let prepare_heap_to_count_minor_allocation () =\n (* We call [minor] to empty the minor heap, so that our allocation is unlikely to\n trigger a minor gc. *)\n minor ();\n (* We allocate two words in case the [Gc.minor] finishes a major gc cycle, in which\n case it requests a minor gc to occur at the next minor allocation. We don't want\n the subsequent minor allocation to trigger a minor GC, because there is a bug\n (https://github.com/ocaml/ocaml/issues/7798) in the OCaml runtime that double\n counts [Gc.minor_words] in that case. *)\n ignore (Sys.opaque_identity (ref (Sys.opaque_identity 1)) : int ref)\n ;;\n\n (* We disable inlining for this function so the GC stats and the call to [f] are never\n rearranged. *)\n let[@cold] measure_internal ~on_result f =\n let minor_words_before = minor_words () in\n let major_words_before = major_words () in\n (* We wrap [f ()] with [Sys.opaque_identity] to prevent the return value from being\n optimized away. *)\n let x = Sys.opaque_identity (f ()) in\n let minor_words_after = minor_words () in\n let major_words_after = major_words () in\n let major_words_allocated = major_words_after - major_words_before in\n let minor_words_allocated = minor_words_after - minor_words_before in\n on_result ~major_words_allocated ~minor_words_allocated x\n ;;\n\n let is_zero_alloc (type a) (f : unit -> a) =\n (* Instead of using [Allocation_report.measure], and matching on the result, we use\n this construction, in order to have [is_zero_alloc] not allocate itself. This\n enables [is_zero_alloc] to be used in a nested way.\n\n This also means we cannot call [prepare_heap_to_count_minor_allocation]. This is\n okay, since we do not need a precise count, we only need to check if the count is\n zero or not. *)\n measure_internal\n f\n ~on_result:(fun ~major_words_allocated ~minor_words_allocated value ->\n ignore (Sys.opaque_identity value : a);\n major_words_allocated == 0 && minor_words_allocated == 0)\n ;;\n\n module Allocation_report = struct\n type t =\n { major_words_allocated : int\n ; minor_words_allocated : int\n }\n\n let create ~major_words_allocated ~minor_words_allocated =\n { major_words_allocated; minor_words_allocated }\n ;;\n end\n\n let measure_allocation f =\n prepare_heap_to_count_minor_allocation ();\n measure_internal f ~on_result:(fun ~major_words_allocated ~minor_words_allocated x ->\n x, Allocation_report.create ~major_words_allocated ~minor_words_allocated)\n ;;\nend\n\nmodule Expert = struct\n let add_finalizer x f =\n try Caml.Gc.finalise (fun x -> Exn.handle_uncaught_and_exit (fun () -> f x)) x with\n | Invalid_argument _ ->\n (* The type of add_finalizer ensures that the only possible failure\n is due to [x] being static data. In this case, we simply drop the\n finalizer since static data would never have been collected by the\n GC anyway. *)\n ()\n ;;\n\n (* [add_finalizer_exn] is the same as [add_finalizer]. However, their types in\n core_gc.mli are different, and the type of [add_finalizer] guarantees that it always\n receives a heap block, which ensures that it will not raise, while\n [add_finalizer_exn] accepts any type, and so may raise. *)\n let add_finalizer_exn x f =\n try Caml.Gc.finalise (fun x -> Exn.handle_uncaught_and_exit (fun () -> f x)) x with\n | Invalid_argument _ ->\n ignore (Heap_block.create x : _ Heap_block.t option);\n (* If [Heap_block.create] succeeds then [x] is static data and so\n we can simply drop the finaliser. *)\n ()\n ;;\n\n let add_finalizer_last x f =\n try Caml.Gc.finalise_last (fun () -> Exn.handle_uncaught_and_exit f) x with\n | Invalid_argument _ ->\n (* The type of add_finalizer_last ensures that the only possible failure\n is due to [x] being static data. In this case, we simply drop the\n finalizer since static data would never have been collected by the\n GC anyway. *)\n ()\n ;;\n\n let add_finalizer_last_exn x f =\n try Caml.Gc.finalise_last (fun () -> Exn.handle_uncaught_and_exit f) x with\n | Invalid_argument _ ->\n ignore (Heap_block.create x : _ Heap_block.t option);\n (* If [Heap_block.create] succeeds then [x] is static data and so\n we can simply drop the finaliser. *)\n ()\n ;;\n\n let finalize_release = Caml.Gc.finalise_release\n\n module Alarm = struct\n type t = alarm\n\n let sexp_of_t _ = \"\" |> [%sexp_of: string]\n let create f = create_alarm (fun () -> Exn.handle_uncaught_and_exit f)\n let delete = delete_alarm\n end\nend\n","open Format\n\nlet rev_split l =\n let rec inner xs ys = function\n | (x, y) :: xys ->\n inner (x::xs) (y::ys) xys\n | [] -> (xs, ys)\n in\n inner [] [] l\n\ntype wrap = [\n | `Wrap_atoms\n | `Always_wrap\n | `Never_wrap\n | `Force_breaks\n | `Force_breaks_rec\n | `No_breaks\n]\n\ntype label_break = [\n | `Auto\n | `Always\n | `Always_rec\n | `Never\n]\n\ntype style_name = string\ntype style = {\n tag_open : string;\n tag_close : string\n}\n\ntype atom_param = {\n atom_style : style_name option;\n}\n\nlet atom = {\n atom_style = None\n}\n\ntype list_param = {\n space_after_opening : bool;\n space_after_separator : bool;\n space_before_separator : bool;\n separators_stick_left : bool;\n space_before_closing : bool;\n stick_to_label : bool;\n align_closing : bool;\n wrap_body : wrap;\n indent_body : int;\n list_style : style_name option;\n opening_style : style_name option;\n body_style : style_name option;\n separator_style : style_name option;\n closing_style : style_name option;\n}\n\nlet list = {\n space_after_opening = true;\n space_after_separator = true;\n space_before_separator = false;\n separators_stick_left = true;\n space_before_closing = true;\n stick_to_label = true;\n align_closing = true;\n wrap_body = `Wrap_atoms;\n indent_body = 2;\n list_style = None;\n opening_style = None;\n body_style = None;\n separator_style = None;\n closing_style = None;\n}\n\ntype label_param = {\n label_break: label_break;\n space_after_label : bool;\n indent_after_label : int;\n label_style : style_name option;\n}\n\nlet label = {\n label_break = `Auto;\n space_after_label = true;\n indent_after_label = 2;\n label_style = None;\n}\n\ntype t =\n Atom of string * atom_param\n | List of (string * string * string * list_param) * t list\n | Label of (t * label_param) * t\n | Custom of (formatter -> unit)\n\ntype escape =\n [ `None\n | `Escape of\n ((string -> int -> int -> unit) -> string -> int -> int -> unit)\n | `Escape_string of (string -> string) ]\n\ntype styles = (style_name * style) list\n\n(*\n Transform a tree starting from the leaves, propagating and merging\n accumulators until reaching the root.\n*)\nlet propagate_from_leaf_to_root\n ~init_acc (* create initial accumulator for a leaf *)\n ~merge_acc (* merge two accumulators coming from child nodes *)\n ~map_node (* (node, acc) -> (node, acc) *)\n x =\n\n let rec aux x =\n match x with\n | Atom _ ->\n let acc = init_acc x in\n map_node x acc\n | List (param, children) ->\n let new_children, accs = rev_split (List.rev_map aux children) in\n let acc = List.fold_left merge_acc (init_acc x) accs in\n map_node (List (param, new_children)) acc\n | Label ((x1, param), x2) ->\n let acc0 = init_acc x in\n let new_x1, acc1 = aux x1 in\n let new_x2, acc2 = aux x2 in\n let acc = merge_acc (merge_acc acc0 acc1) acc2 in\n map_node (Label ((new_x1, param), new_x2)) acc\n | Custom _ ->\n let acc = init_acc x in\n map_node x acc\n in\n aux x\n\n(*\n Convert wrappable lists into vertical lists if any of their descendants\n has the attribute wrap_body = `Force_breaks_rec.\n*)\nlet propagate_forced_breaks x =\n (* acc = whether to force breaks in wrappable lists or labels *)\n let init_acc = function\n | List ((_, _, _, { wrap_body = `Force_breaks_rec; _ }), _)\n | Label ((_, { label_break = `Always_rec; _ }), _) -> true\n | Atom _\n | Label _\n | Custom _\n | List _ -> false\n in\n let merge_acc force_breaks1 force_breaks2 =\n force_breaks1 || force_breaks2\n in\n let map_node x force_breaks =\n match x with\n | List ((_, _, _, { wrap_body = `Force_breaks_rec; _ }), _) -> x, true\n | List ((_, _, _, { wrap_body = `Force_breaks; _ }), _) -> x, force_breaks\n\n | List ((op, sep, cl, ({ wrap_body = (`Wrap_atoms\n | `Never_wrap\n | `Always_wrap); _ } as p)),\n children) ->\n if force_breaks then\n let p = { p with wrap_body = `Force_breaks } in\n List ((op, sep, cl, p), children), true\n else\n x, false\n\n | Label ((a, ({ label_break = `Auto; _ } as lp)), b) ->\n if force_breaks then\n let lp = { lp with label_break = `Always } in\n Label ((a, lp), b), true\n else\n x, false\n\n | List ((_, _, _, { wrap_body = `No_breaks; _ }), _)\n | Label ((_, { label_break = (`Always | `Always_rec | `Never); _ }), _)\n | Atom _\n | Custom _ -> x, force_breaks\n in\n let new_x, _forced_breaks =\n propagate_from_leaf_to_root\n ~init_acc\n ~merge_acc\n ~map_node\n x\n in\n new_x\n\nmodule Pretty =\nstruct\n (*\n Rewrite the tree to be printed.\n Currently, this is used only to handle `Force_breaks_rec.\n *)\n let rewrite x = propagate_forced_breaks x\n\n (*\n Relies on the fact that mark_open_tag and mark_close_tag\n are called exactly once before calling pp_output_string once.\n It's a reasonable assumption although not guaranteed by the\n documentation of the Format module.\n *)\n let set_escape fmt escape =\n let print0, flush0 = pp_get_formatter_output_functions fmt () in\n let tagf0 = pp_get_formatter_tag_functions fmt () in\n\n let is_tag = ref false in\n\n let mot tag =\n is_tag := true;\n tagf0.mark_open_tag tag\n in\n\n let mct tag =\n is_tag := true;\n tagf0.mark_close_tag tag\n in\n\n let print s p n =\n if !is_tag then\n (print0 s p n;\n is_tag := false)\n else\n escape print0 s p n\n in\n\n let tagf = {\n tagf0 with\n mark_open_tag = mot;\n mark_close_tag = mct\n }\n in\n pp_set_formatter_output_functions fmt print flush0;\n pp_set_formatter_tag_functions fmt tagf\n\n\n let set_escape_string fmt esc =\n let escape print s p n =\n let s0 = String.sub s p n in\n let s1 = esc s0 in\n print s1 0 (String.length s1)\n in\n set_escape fmt escape\n\n\n let define_styles fmt escape l =\n if l <> [] then (\n pp_set_tags fmt true;\n let tbl1 = Hashtbl.create (2 * List.length l) in\n let tbl2 = Hashtbl.create (2 * List.length l) in\n List.iter (\n fun (style_name, style) ->\n Hashtbl.add tbl1 style_name style.tag_open;\n Hashtbl.add tbl2 style_name style.tag_close\n ) l;\n let mark_open_tag style_name =\n try Hashtbl.find tbl1 style_name\n with Not_found -> \"\"\n in\n let mark_close_tag style_name =\n try Hashtbl.find tbl2 style_name\n with Not_found -> \"\"\n in\n\n let tagf = {\n (pp_get_formatter_tag_functions fmt ()) with\n mark_open_tag = mark_open_tag;\n mark_close_tag = mark_close_tag\n }\n in\n pp_set_formatter_tag_functions fmt tagf\n );\n\n (match escape with\n `None -> ()\n | `Escape esc -> set_escape fmt esc\n | `Escape_string esc -> set_escape_string fmt esc)\n\n\n let pp_open_xbox fmt p indent =\n match p.wrap_body with\n `Always_wrap\n | `Never_wrap\n | `Wrap_atoms -> pp_open_hvbox fmt indent\n | `Force_breaks\n | `Force_breaks_rec -> pp_open_vbox fmt indent\n | `No_breaks -> pp_open_hbox fmt ()\n\n let extra_box p l =\n let wrap =\n match p.wrap_body with\n `Always_wrap -> true\n | `Never_wrap\n | `Force_breaks\n | `Force_breaks_rec\n | `No_breaks -> false\n | `Wrap_atoms ->\n List.for_all (function Atom _ -> true | _ -> false) l\n in\n if wrap then\n ((fun fmt -> pp_open_hovbox fmt 0),\n (fun fmt -> pp_close_box fmt ()))\n else\n ((fun _ -> ()),\n (fun _ -> ()))\n\n\n let pp_open_nonaligned_box fmt p indent l =\n match p.wrap_body with\n `Always_wrap -> pp_open_hovbox fmt indent\n | `Never_wrap -> pp_open_hvbox fmt indent\n | `Wrap_atoms ->\n if List.for_all (function Atom _ -> true | _ -> false) l then\n pp_open_hovbox fmt indent\n else\n pp_open_hvbox fmt indent\n | `Force_breaks\n | `Force_breaks_rec -> pp_open_vbox fmt indent\n | `No_breaks -> pp_open_hbox fmt ()\n\n\n let open_tag fmt = function\n None -> ()\n | Some s -> pp_open_tag fmt s\n\n let close_tag fmt = function\n None -> ()\n | Some _ -> pp_close_tag fmt ()\n\n let tag_string fmt o s =\n match o with\n None -> pp_print_string fmt s\n | Some tag ->\n pp_open_tag fmt tag;\n pp_print_string fmt s;\n pp_close_tag fmt ()\n\n let rec fprint_t fmt = function\n Atom (s, p) ->\n tag_string fmt p.atom_style s;\n\n | List ((_, _, _, p) as param, l) ->\n open_tag fmt p.list_style;\n if p.align_closing then\n fprint_list fmt None param l\n else\n fprint_list2 fmt param l;\n close_tag fmt p.list_style\n\n | Label (label, x) -> fprint_pair fmt label x\n | Custom f -> f fmt\n\n and fprint_list_body_stick_left fmt p sep hd tl =\n open_tag fmt p.body_style;\n fprint_t fmt hd;\n List.iter (\n fun x ->\n if p.space_before_separator then\n pp_print_string fmt \" \";\n tag_string fmt p.separator_style sep;\n if p.space_after_separator then\n pp_print_space fmt ()\n else\n pp_print_cut fmt ();\n fprint_t fmt x\n ) tl;\n close_tag fmt p.body_style\n\n and fprint_list_body_stick_right fmt p sep hd tl =\n open_tag fmt p.body_style;\n fprint_t fmt hd;\n List.iter (\n fun x ->\n if p.space_before_separator then\n pp_print_space fmt ()\n else\n pp_print_cut fmt ();\n tag_string fmt p.separator_style sep;\n if p.space_after_separator then\n pp_print_string fmt \" \";\n fprint_t fmt x\n ) tl;\n close_tag fmt p.body_style\n\n and fprint_opt_label fmt = function\n None -> ()\n | Some (lab, lp) ->\n open_tag fmt lp.label_style;\n fprint_t fmt lab;\n close_tag fmt lp.label_style;\n if lp.space_after_label then\n pp_print_string fmt \" \"\n\n (* Either horizontal or vertical list *)\n and fprint_list fmt label ((op, _sep, cl, p) as param) = function\n [] ->\n fprint_opt_label fmt label;\n tag_string fmt p.opening_style op;\n if p.space_after_opening || p.space_before_closing then\n pp_print_string fmt \" \";\n tag_string fmt p.closing_style cl\n\n | hd :: tl as l ->\n\n if tl = [] || p.separators_stick_left then\n fprint_list_stick_left fmt label param hd tl l\n else\n fprint_list_stick_right fmt label param hd tl l\n\n\n and fprint_list_stick_left fmt label (op, sep, cl, p) hd tl l =\n let indent = p.indent_body in\n pp_open_xbox fmt p indent;\n fprint_opt_label fmt label;\n\n tag_string fmt p.opening_style op;\n\n if p.space_after_opening then\n pp_print_space fmt ()\n else\n pp_print_cut fmt ();\n\n let open_extra, close_extra = extra_box p l in\n open_extra fmt;\n fprint_list_body_stick_left fmt p sep hd tl;\n close_extra fmt;\n\n if p.space_before_closing then\n pp_print_break fmt 1 (-indent)\n else\n pp_print_break fmt 0 (-indent);\n tag_string fmt p.closing_style cl;\n pp_close_box fmt ()\n\n and fprint_list_stick_right fmt label (op, sep, cl, p) hd tl l =\n let base_indent = p.indent_body in\n let sep_indent =\n String.length sep + (if p.space_after_separator then 1 else 0)\n in\n let indent = base_indent + sep_indent in\n\n pp_open_xbox fmt p indent;\n fprint_opt_label fmt label;\n\n tag_string fmt p.opening_style op;\n\n if p.space_after_opening then\n pp_print_space fmt ()\n else\n pp_print_cut fmt ();\n\n let open_extra, close_extra = extra_box p l in\n open_extra fmt;\n\n fprint_t fmt hd;\n List.iter (\n fun x ->\n if p.space_before_separator then\n pp_print_break fmt 1 (-sep_indent)\n else\n pp_print_break fmt 0 (-sep_indent);\n tag_string fmt p.separator_style sep;\n if p.space_after_separator then\n pp_print_string fmt \" \";\n fprint_t fmt x\n ) tl;\n\n close_extra fmt;\n\n if p.space_before_closing then\n pp_print_break fmt 1 (-indent)\n else\n pp_print_break fmt 0 (-indent);\n tag_string fmt p.closing_style cl;\n pp_close_box fmt ()\n\n\n\n (* align_closing = false *)\n and fprint_list2 fmt (op, sep, cl, p) = function\n [] ->\n tag_string fmt p.opening_style op;\n if p.space_after_opening || p.space_before_closing then\n pp_print_string fmt \" \";\n tag_string fmt p.closing_style cl\n\n | hd :: tl as l ->\n tag_string fmt p.opening_style op;\n if p.space_after_opening then\n pp_print_string fmt \" \";\n\n pp_open_nonaligned_box fmt p 0 l ;\n if p.separators_stick_left then\n fprint_list_body_stick_left fmt p sep hd tl\n else\n fprint_list_body_stick_right fmt p sep hd tl;\n pp_close_box fmt ();\n\n if p.space_before_closing then\n pp_print_string fmt \" \";\n tag_string fmt p.closing_style cl\n\n\n (* Printing a label:value pair.\n\n The opening bracket stays on the same line as the key, no matter what,\n and the closing bracket is either on the same line\n or vertically aligned with the beginning of the key.\n *)\n and fprint_pair fmt ((lab, lp) as label) x =\n match x with\n List ((op, sep, cl, p), l) when p.stick_to_label && p.align_closing ->\n fprint_list fmt (Some label) (op, sep, cl, p) l\n\n | _ ->\n let indent = lp.indent_after_label in\n pp_open_hvbox fmt 0;\n\n open_tag fmt lp.label_style;\n fprint_t fmt lab;\n close_tag fmt lp.label_style;\n\n (match lp.label_break with\n | `Auto ->\n if lp.space_after_label then\n pp_print_break fmt 1 indent\n else\n pp_print_break fmt 0 indent\n | `Always\n | `Always_rec ->\n pp_force_newline fmt ();\n pp_print_string fmt (String.make indent ' ')\n | `Never ->\n if lp.space_after_label then\n pp_print_char fmt ' '\n else\n ()\n );\n fprint_t fmt x;\n pp_close_box fmt ()\n\n let to_formatter fmt x =\n let x = rewrite x in\n fprint_t fmt x;\n pp_print_flush fmt ()\n\n let to_buffer ?(escape = `None) ?(styles = []) buf x =\n let fmt = Format.formatter_of_buffer buf in\n define_styles fmt escape styles;\n to_formatter fmt x\n\n let to_string ?escape ?styles x =\n let buf = Buffer.create 500 in\n to_buffer ?escape ?styles buf x;\n Buffer.contents buf\n\n let to_channel ?(escape = `None) ?(styles = []) oc x =\n let fmt = formatter_of_out_channel oc in\n define_styles fmt escape styles;\n to_formatter fmt x\n\n let to_stdout ?escape ?styles x = to_channel ?escape ?styles stdout x\n let to_stderr ?escape ?styles x = to_channel ?escape ?styles stderr x\n\nend\n\n\n\n\nmodule Compact =\nstruct\n open Printf\n\n let rec fprint_t buf = function\n Atom (s, _) -> Buffer.add_string buf s\n | List (param, l) -> fprint_list buf param l\n | Label (label, x) -> fprint_pair buf label x\n | Custom f ->\n (* Will most likely not be compact *)\n let fmt = formatter_of_buffer buf in\n f fmt;\n pp_print_flush fmt ()\n\n and fprint_list buf (op, sep, cl, _) = function\n [] -> bprintf buf \"%s%s\" op cl\n | x :: tl ->\n Buffer.add_string buf op;\n fprint_t buf x;\n List.iter (\n fun x ->\n Buffer.add_string buf sep;\n fprint_t buf x\n ) tl;\n Buffer.add_string buf cl\n\n and fprint_pair buf (label, _) x =\n fprint_t buf label;\n fprint_t buf x\n\n\n let to_buffer buf x = fprint_t buf x\n\n let to_string x =\n let buf = Buffer.create 500 in\n to_buffer buf x;\n Buffer.contents buf\n\n let to_formatter fmt x =\n let s = to_string x in\n Format.fprintf fmt \"%s\" s;\n pp_print_flush fmt ()\n\n let to_channel oc x =\n let buf = Buffer.create 500 in\n to_buffer buf x;\n Buffer.output_buffer oc buf\n\n let to_stdout x = to_channel stdout x\n let to_stderr x = to_channel stderr x\nend\n\n\n\n\n(* Obsolete *)\nmodule Param =\nstruct\n let list_true = {\n space_after_opening = true;\n space_after_separator = true;\n space_before_separator = true;\n separators_stick_left = true;\n space_before_closing = true;\n stick_to_label = true;\n align_closing = true;\n wrap_body = `Wrap_atoms;\n indent_body = 2;\n list_style = None;\n opening_style = None;\n body_style = None;\n separator_style = None;\n closing_style = None;\n }\n\n let list_false = {\n space_after_opening = false;\n space_after_separator = false;\n space_before_separator = false;\n separators_stick_left = false;\n space_before_closing = false;\n stick_to_label = false;\n align_closing = false;\n wrap_body = `Wrap_atoms;\n indent_body = 2;\n list_style = None;\n opening_style = None;\n body_style = None;\n separator_style = None;\n closing_style = None;\n }\n\n let label_true = {\n label_break = `Auto;\n space_after_label = true;\n indent_after_label = 2;\n label_style = None;\n }\n\n let label_false = {\n label_break = `Auto;\n space_after_label = false;\n indent_after_label = 2;\n label_style = None;\n }\nend\n","# 1 \"common.ml\"\nlet version = \"1.7.0\"\n\nexception Json_error of string\n\nlet json_error s = raise (Json_error s)\n\nexception End_of_array\nexception End_of_object\nexception End_of_tuple\nexception End_of_input\n\ntype in_param = {\n string_buf : Buffer.t\n}\n\nlet create_in_param ?(len = 256) () = {\n string_buf = Buffer.create len\n}\n\n\nlet utf8_of_code buf x =\n let add = Bi_outbuf.add_char in\n\n (* Straight <= doesn't work with signed 31-bit ints *)\n let maxbits n x = x lsr n = 0 in\n\n if maxbits 7 x then\n (* 7 *)\n add buf (Char.chr x)\n else if maxbits 11 x then (\n (* 5 + 6 *)\n add buf (Char.chr (0b11000000 lor ((x lsr 6) land 0b00011111)));\n add buf (Char.chr (0b10000000 lor (x land 0b00111111)))\n )\n else if maxbits 16 x then (\n (* 4 + 6 + 6 *)\n add buf (Char.chr (0b11100000 lor ((x lsr 12) land 0b00001111)));\n add buf (Char.chr (0b10000000 lor ((x lsr 6) land 0b00111111)));\n add buf (Char.chr (0b10000000 lor (x land 0b00111111)))\n )\n else if maxbits 21 x then (\n (* 3 + 6 + 6 + 6 *)\n add buf (Char.chr (0b11110000 lor ((x lsr 18) land 0b00000111)));\n add buf (Char.chr (0b10000000 lor ((x lsr 12) land 0b00111111)));\n add buf (Char.chr (0b10000000 lor ((x lsr 6) land 0b00111111)));\n add buf (Char.chr (0b10000000 lor (x land 0b00111111)));\n )\n else if maxbits 26 x then (\n (* 2 + 6 + 6 + 6 + 6 *)\n add buf (Char.chr (0b11111000 lor ((x lsr 24) land 0b00000011)));\n add buf (Char.chr (0b10000000 lor ((x lsr 18) land 0b00111111)));\n add buf (Char.chr (0b10000000 lor ((x lsr 12) land 0b00111111)));\n add buf (Char.chr (0b10000000 lor ((x lsr 6) land 0b00111111)));\n add buf (Char.chr (0b10000000 lor (x land 0b00111111)));\n )\n else (\n assert (maxbits 31 x);\n (* 1 + 6 + 6 + 6 + 6 + 6 *)\n add buf (Char.chr (0b11111100 lor ((x lsr 30) land 0b00000001)));\n add buf (Char.chr (0b10000000 lor ((x lsr 24) land 0b00111111)));\n add buf (Char.chr (0b10000000 lor ((x lsr 18) land 0b00111111)));\n add buf (Char.chr (0b10000000 lor ((x lsr 12) land 0b00111111)));\n add buf (Char.chr (0b10000000 lor ((x lsr 6) land 0b00111111)));\n add buf (Char.chr (0b10000000 lor (x land 0b00111111)));\n )\n\nlet code_of_surrogate_pair i j =\n let high10 = i - 0xD800 in\n let low10 = j - 0xDC00 in\n 0x10000 + ((high10 lsl 10) lor low10)\n\nlet utf8_of_surrogate_pair buf i j =\n utf8_of_code buf (code_of_surrogate_pair i j)\n\nlet is_object_or_array x =\n match x with\n `List _\n | `Assoc _ -> true\n | _ -> false\n\n\ntype lexer_state = {\n buf : Bi_outbuf.t;\n (* Buffer used to accumulate substrings *)\n\n mutable lnum : int;\n (* Current line number (starting from 1) *)\n\n mutable bol : int;\n (* Absolute position of the first character of the current line\n (starting from 0) *)\n\n mutable fname : string option;\n (* Name describing the input file *)\n}\n\nmodule Lexer_state =\nstruct\n type t = lexer_state = {\n buf : Bi_outbuf.t;\n mutable lnum : int;\n mutable bol : int;\n mutable fname : string option;\n }\nend\n\nlet init_lexer ?buf ?fname ?(lnum = 1) () =\n let buf =\n match buf with\n\tNone -> Bi_outbuf.create 256\n | Some buf -> buf\n in\n {\n buf = buf;\n lnum = lnum;\n bol = 0;\n fname = fname\n }\n\n# 1 \"type.ml\"\n(** {3 Type of the JSON tree} *)\n\ntype t =\n [\n | `Null\n | `Bool of bool\n \n# 8 \"type.ml\"\n | `Int of int\n \n# 11 \"type.ml\"\n | `Intlit of string\n \n# 14 \"type.ml\"\n | `Float of float\n \n# 17 \"type.ml\"\n | `Floatlit of string\n \n# 20 \"type.ml\"\n | `String of string\n \n# 23 \"type.ml\"\n | `Stringlit of string\n \n# 25 \"type.ml\"\n | `Assoc of (string * t) list\n | `List of t list\n \n# 28 \"type.ml\"\n | `Tuple of t list\n \n# 31 \"type.ml\"\n | `Variant of (string * t option)\n \n# 33 \"type.ml\"\n ]\n(**\nAll possible cases defined in Yojson:\n- `Null: JSON null\n- `Bool of bool: JSON boolean\n- `Int of int: JSON number without decimal point or exponent.\n- `Intlit of string: JSON number without decimal point or exponent,\n\t preserved as a string.\n- `Float of float: JSON number, Infinity, -Infinity or NaN.\n- `Floatlit of string: JSON number, Infinity, -Infinity or NaN,\n\t preserved as a string.\n- `String of string: JSON string. Bytes in the range 128-255 are preserved\n\t as-is without encoding validation for both reading\n\t and writing.\n- `Stringlit of string: JSON string literal including the double quotes.\n- `Assoc of (string * json) list: JSON object.\n- `List of json list: JSON array.\n- `Tuple of json list: Tuple (non-standard extension of JSON).\n\t Syntax: [(\"abc\", 123)].\n- `Variant of (string * json option): Variant (non-standard extension of JSON).\n\t Syntax: [<\"Foo\">] or [<\"Bar\":123>].\n*)\n\ntype json = t [@@deprecated \"json types are being renamed and will be removed in the next Yojson major version. Use type t instead\"]\n(**\n * Compatibility type alias for type `t`\n *)\n\n(*\n Note to adventurers: ocamldoc does not support inline comments\n on each polymorphic variant, and cppo doesn't allow to concatenate\n comments, so it would be complicated to document only the\n cases that are preserved by cppo in the type definition.\n*)\n# 12 \"yojson.cppo.ml\"\ntype json_max = t\n# 1 \"write.ml\"\n(* included: type.ml *)\n\nlet hex n =\n Char.chr (\n if n < 10 then n + 48\n else n + 87\n )\n\nlet write_special src start stop ob str =\n Bi_outbuf.add_substring ob src !start (stop - !start);\n Bi_outbuf.add_string ob str;\n start := stop + 1\n\nlet write_control_char src start stop ob c =\n Bi_outbuf.add_substring ob src !start (stop - !start);\n let i = Bi_outbuf.alloc ob 6 in\n let dst = ob.o_s in\n Bytes.blit_string \"\\\\u00\" 0 dst i 4;\n Bytes.set dst (i+4) (hex (Char.code c lsr 4));\n Bytes.set dst (i+5) (hex (Char.code c land 0xf));\n start := stop + 1\n\nlet finish_string src start ob =\n try\n Bi_outbuf.add_substring ob src !start (String.length src - !start)\n with exc ->\n Printf.eprintf \"src=%S start=%i len=%i\\n%!\"\n src !start (String.length src - !start);\n raise exc\n\nlet write_string_body ob s =\n let start = ref 0 in\n for i = 0 to String.length s - 1 do\n match s.[i] with\n '\"' -> write_special s start i ob \"\\\\\\\"\"\n | '\\\\' -> write_special s start i ob \"\\\\\\\\\"\n | '\\b' -> write_special s start i ob \"\\\\b\"\n | '\\012' -> write_special s start i ob \"\\\\f\"\n | '\\n' -> write_special s start i ob \"\\\\n\"\n | '\\r' -> write_special s start i ob \"\\\\r\"\n | '\\t' -> write_special s start i ob \"\\\\t\"\n | '\\x00'..'\\x1F'\n | '\\x7F' as c -> write_control_char s start i ob c\n | _ -> ()\n done;\n finish_string s start ob\n\nlet write_string ob s =\n Bi_outbuf.add_char ob '\"';\n write_string_body ob s;\n Bi_outbuf.add_char ob '\"'\n\nlet json_string_of_string s =\n let ob = Bi_outbuf.create 10 in\n write_string ob s;\n Bi_outbuf.contents ob\n\nlet test_string () =\n let s = Bytes.create 256 in\n for i = 0 to 255 do\n Bytes.set s i (Char.chr i)\n done;\n json_string_of_string (Bytes.to_string s)\n\n\nlet write_null ob () =\n Bi_outbuf.add_string ob \"null\"\n\nlet write_bool ob x =\n Bi_outbuf.add_string ob (if x then \"true\" else \"false\")\n\n\nlet max_digits =\n max\n (String.length (string_of_int max_int))\n (String.length (string_of_int min_int))\n\nlet dec n =\n Char.chr (n + 48)\n\nlet rec write_digits s pos x =\n if x = 0 then pos\n else\n let d = x mod 10 in\n let pos = write_digits s pos (x / 10) in\n Bytes.set s pos (dec (abs d));\n pos + 1\n\nlet write_int ob x =\n Bi_outbuf.extend ob max_digits;\n if x > 0 then\n ob.o_len <- write_digits ob.o_s ob.o_len x\n else if x < 0 then (\n let s = ob.o_s in\n let pos = ob.o_len in\n Bytes.set s pos '-';\n ob.o_len <- write_digits s (pos + 1) x\n )\n else\n Bi_outbuf.add_char ob '0'\n\n\nlet json_string_of_int i =\n string_of_int i\n\n\n(*\n Ensure that the float is not printed as an int.\n This is not required by JSON, but useful in order to guarantee\n reversibility.\n*)\nlet float_needs_period s =\n try\n for i = 0 to String.length s - 1 do\n match s.[i] with\n '0'..'9' | '-' -> ()\n | _ -> raise Exit\n done;\n true\n with Exit ->\n false\n\n(*\n Both write_float_fast and write_float guarantee\n that a sufficient number of digits are printed in order to\n allow reversibility.\n\n The _fast version is faster but often produces unnecessarily long numbers.\n*)\nlet write_float_fast ob x =\n match classify_float x with\n FP_nan ->\n Bi_outbuf.add_string ob \"NaN\"\n | FP_infinite ->\n Bi_outbuf.add_string ob (if x > 0. then \"Infinity\" else \"-Infinity\")\n | _ ->\n let s = Printf.sprintf \"%.17g\" x in\n Bi_outbuf.add_string ob s;\n if float_needs_period s then\n Bi_outbuf.add_string ob \".0\"\n\nlet write_float ob x =\n match classify_float x with\n FP_nan ->\n Bi_outbuf.add_string ob \"NaN\"\n | FP_infinite ->\n Bi_outbuf.add_string ob (if x > 0. then \"Infinity\" else \"-Infinity\")\n | _ ->\n let s1 = Printf.sprintf \"%.16g\" x in\n let s =\n if float_of_string s1 = x then s1\n else Printf.sprintf \"%.17g\" x\n in\n Bi_outbuf.add_string ob s;\n if float_needs_period s then\n Bi_outbuf.add_string ob \".0\"\n\nlet write_normal_float_prec significant_figures ob x =\n let open Printf in\n let s =\n match significant_figures with\n 1 -> sprintf \"%.1g\" x\n | 2 -> sprintf \"%.2g\" x\n | 3 -> sprintf \"%.3g\" x\n | 4 -> sprintf \"%.4g\" x\n | 5 -> sprintf \"%.5g\" x\n | 6 -> sprintf \"%.6g\" x\n | 7 -> sprintf \"%.7g\" x\n | 8 -> sprintf \"%.8g\" x\n | 9 -> sprintf \"%.9g\" x\n | 10 -> sprintf \"%.10g\" x\n | 11 -> sprintf \"%.11g\" x\n | 12 -> sprintf \"%.12g\" x\n | 13 -> sprintf \"%.13g\" x\n | 14 -> sprintf \"%.14g\" x\n | 15 -> sprintf \"%.15g\" x\n | 16 -> sprintf \"%.16g\" x\n | _ -> sprintf \"%.17g\" x\n in\n Bi_outbuf.add_string ob s;\n if float_needs_period s then\n Bi_outbuf.add_string ob \".0\"\n\nlet write_float_prec significant_figures ob x =\n match classify_float x with\n FP_nan ->\n Bi_outbuf.add_string ob \"NaN\"\n | FP_infinite ->\n Bi_outbuf.add_string ob (if x > 0. then \"Infinity\" else \"-Infinity\")\n | _ ->\n write_normal_float_prec significant_figures ob x\n\nlet json_string_of_float x =\n let ob = Bi_outbuf.create 20 in\n write_float ob x;\n Bi_outbuf.contents ob\n\n\nlet write_std_float_fast ob x =\n match classify_float x with\n FP_nan ->\n json_error \"NaN value not allowed in standard JSON\"\n | FP_infinite ->\n json_error\n (if x > 0. then\n \"Infinity value not allowed in standard JSON\"\n else\n \"-Infinity value not allowed in standard JSON\")\n | _ ->\n let s = Printf.sprintf \"%.17g\" x in\n Bi_outbuf.add_string ob s;\n if float_needs_period s then\n Bi_outbuf.add_string ob \".0\"\n\nlet write_std_float ob x =\n match classify_float x with\n FP_nan ->\n json_error \"NaN value not allowed in standard JSON\"\n | FP_infinite ->\n json_error\n (if x > 0. then\n \"Infinity value not allowed in standard JSON\"\n else\n \"-Infinity value not allowed in standard JSON\")\n | _ ->\n let s1 = Printf.sprintf \"%.16g\" x in\n let s =\n if float_of_string s1 = x then s1\n else Printf.sprintf \"%.17g\" x\n in\n Bi_outbuf.add_string ob s;\n if float_needs_period s then\n Bi_outbuf.add_string ob \".0\"\n\nlet write_std_float_prec significant_figures ob x =\n match classify_float x with\n FP_nan ->\n json_error \"NaN value not allowed in standard JSON\"\n | FP_infinite ->\n json_error\n (if x > 0. then\n \"Infinity value not allowed in standard JSON\"\n else\n \"-Infinity value not allowed in standard JSON\")\n | _ ->\n write_normal_float_prec significant_figures ob x\n\nlet std_json_string_of_float x =\n let ob = Bi_outbuf.create 20 in\n write_std_float ob x;\n Bi_outbuf.contents ob\n\n\nlet test_float () =\n let l = [ 0.; 1.; -1. ] in\n let l = l @ List.map (fun x -> 2. *. x +. 1.) l in\n let l = l @ List.map (fun x -> x /. sqrt 2.) l in\n let l = l @ List.map (fun x -> x *. sqrt 3.) l in\n let l = l @ List.map cos l in\n let l = l @ List.map (fun x -> x *. 1.23e50) l in\n let l = l @ [ infinity; neg_infinity ] in\n List.iter (\n fun x ->\n let s = Printf.sprintf \"%.17g\" x in\n let y = float_of_string s in\n Printf.printf \"%g %g %S %B\\n\" x y s (x = y)\n )\n l\n\n(*\nlet () = test_float ()\n*)\n\nlet write_intlit = Bi_outbuf.add_string\nlet write_floatlit = Bi_outbuf.add_string\nlet write_stringlit = Bi_outbuf.add_string\n\nlet rec iter2_aux f_elt f_sep x = function\n [] -> ()\n | y :: l ->\n f_sep x;\n f_elt x y;\n iter2_aux f_elt f_sep x l\n\nlet iter2 f_elt f_sep x = function\n [] -> ()\n | y :: l ->\n f_elt x y;\n iter2_aux f_elt f_sep x l\n\nlet f_sep ob =\n Bi_outbuf.add_char ob ','\n\nlet rec write_json ob (x : t) =\n match x with\n `Null -> write_null ob ()\n | `Bool b -> write_bool ob b\n \n# 299 \"write.ml\"\n | `Int i -> write_int ob i\n \n# 302 \"write.ml\"\n | `Intlit s -> Bi_outbuf.add_string ob s\n \n# 305 \"write.ml\"\n | `Float f -> write_float ob f\n \n# 308 \"write.ml\"\n | `Floatlit s -> Bi_outbuf.add_string ob s\n \n# 311 \"write.ml\"\n | `String s -> write_string ob s\n \n# 314 \"write.ml\"\n | `Stringlit s -> Bi_outbuf.add_string ob s\n \n# 316 \"write.ml\"\n | `Assoc l -> write_assoc ob l\n | `List l -> write_list ob l\n \n# 319 \"write.ml\"\n | `Tuple l -> write_tuple ob l\n \n# 322 \"write.ml\"\n | `Variant (s, o) -> write_variant ob s o\n\n# 325 \"write.ml\"\nand write_assoc ob l =\n let f_elt ob (s, x) =\n write_string ob s;\n Bi_outbuf.add_char ob ':';\n write_json ob x\n in\n Bi_outbuf.add_char ob '{';\n iter2 f_elt f_sep ob l;\n Bi_outbuf.add_char ob '}';\n\nand write_list ob l =\n Bi_outbuf.add_char ob '[';\n iter2 write_json f_sep ob l;\n Bi_outbuf.add_char ob ']'\n\n# 341 \"write.ml\"\nand write_tuple ob l =\n Bi_outbuf.add_char ob '(';\n iter2 write_json f_sep ob l;\n Bi_outbuf.add_char ob ')'\n\n# 348 \"write.ml\"\nand write_variant ob s o =\n Bi_outbuf.add_char ob '<';\n write_string ob s;\n (match o with\n None -> ()\n | Some x ->\n Bi_outbuf.add_char ob ':';\n write_json ob x\n );\n Bi_outbuf.add_char ob '>'\n\n# 360 \"write.ml\"\nlet write_t = write_json\n\nlet rec write_std_json ob (x : t) =\n match x with\n `Null -> write_null ob ()\n | `Bool b -> write_bool ob b\n \n# 367 \"write.ml\"\n | `Int i -> write_int ob i\n \n# 370 \"write.ml\"\n | `Intlit s -> Bi_outbuf.add_string ob s\n \n# 373 \"write.ml\"\n | `Float f -> write_std_float ob f\n \n# 376 \"write.ml\"\n | `Floatlit s -> Bi_outbuf.add_string ob s\n \n# 379 \"write.ml\"\n | `String s -> write_string ob s\n \n# 382 \"write.ml\"\n | `Stringlit s -> Bi_outbuf.add_string ob s\n \n# 384 \"write.ml\"\n | `Assoc l -> write_std_assoc ob l\n | `List l -> write_std_list ob l\n \n# 387 \"write.ml\"\n | `Tuple l -> write_std_tuple ob l\n \n# 390 \"write.ml\"\n | `Variant (s, o) -> write_std_variant ob s o\n\n# 393 \"write.ml\"\nand write_std_assoc ob l =\n let f_elt ob (s, x) =\n write_string ob s;\n Bi_outbuf.add_char ob ':';\n write_std_json ob x\n in\n Bi_outbuf.add_char ob '{';\n iter2 f_elt f_sep ob l;\n Bi_outbuf.add_char ob '}';\n\nand write_std_list ob l =\n Bi_outbuf.add_char ob '[';\n iter2 write_std_json f_sep ob l;\n Bi_outbuf.add_char ob ']'\n\nand write_std_tuple ob l =\n Bi_outbuf.add_char ob '[';\n iter2 write_std_json f_sep ob l;\n Bi_outbuf.add_char ob ']'\n\n# 414 \"write.ml\"\nand write_std_variant ob s o =\n match o with\n None -> write_string ob s\n | Some x ->\n Bi_outbuf.add_char ob '[';\n write_string ob s;\n Bi_outbuf.add_char ob ',';\n write_std_json ob x;\n Bi_outbuf.add_char ob ']'\n\n\n# 426 \"write.ml\"\nlet to_outbuf ?(std = false) ob x =\n if std then (\n if not (is_object_or_array x) then\n json_error \"Root is not an object or array\"\n else\n write_std_json ob x\n )\n else\n write_json ob x\n\n\nlet to_string ?buf ?(len = 256) ?std x =\n let ob =\n match buf with\n None -> Bi_outbuf.create len\n | Some ob ->\n Bi_outbuf.clear ob;\n ob\n in\n to_outbuf ?std ob x;\n let s = Bi_outbuf.contents ob in\n Bi_outbuf.clear ob;\n s\n\nlet to_channel ?buf ?len ?std oc x =\n let ob =\n match buf with\n None -> Bi_outbuf.create_channel_writer ?len oc\n | Some ob -> ob\n in\n to_outbuf ?std ob x;\n Bi_outbuf.flush_channel_writer ob\n\nlet to_output ?buf ?len ?std out x =\n let ob =\n match buf with\n None -> Bi_outbuf.create_output_writer ?len out\n | Some ob -> ob\n in\n to_outbuf ?std ob x;\n Bi_outbuf.flush_output_writer ob\n\nlet to_file ?len ?std file x =\n let oc = open_out file in\n try\n to_channel ?len ?std oc x;\n close_out oc\n with e ->\n close_out_noerr oc;\n raise e\n\nlet stream_to_outbuf ?std ob st =\n Stream.iter (to_outbuf ?std ob) st\n\nlet stream_to_string ?buf ?(len = 256) ?std st =\n let ob =\n match buf with\n None -> Bi_outbuf.create len\n | Some ob ->\n Bi_outbuf.clear ob;\n ob\n in\n stream_to_outbuf ?std ob st;\n let s = Bi_outbuf.contents ob in\n Bi_outbuf.clear ob;\n s\n\nlet stream_to_channel ?buf ?len ?std oc st =\n let ob =\n match buf with\n None -> Bi_outbuf.create_channel_writer ?len oc\n | Some ob -> ob\n in\n stream_to_outbuf ?std ob st;\n Bi_outbuf.flush_channel_writer ob\n\nlet stream_to_file ?len ?std file st =\n let oc = open_out file in\n try\n stream_to_channel ?len ?std oc st;\n close_out oc\n with e ->\n close_out_noerr oc;\n raise e\n\n\nlet rec sort = function\n | `Assoc l ->\n let l = List.rev (List.rev_map (fun (k, v) -> (k, sort v)) l) in\n `Assoc (List.stable_sort (fun (a, _) (b, _) -> String.compare a b) l)\n | `List l ->\n `List (List.rev (List.rev_map sort l))\n \n# 519 \"write.ml\"\n | `Tuple l ->\n `Tuple (List.rev (List.rev_map sort l))\n \n# 523 \"write.ml\"\n | `Variant (k, Some v) as x ->\n let v' = sort v in\n if v == v' then x\n else\n `Variant (k, Some v')\n \n# 529 \"write.ml\"\n | x -> x\n# 1 \"monomorphic.ml\"\nlet rec pp fmt =\n function\n | `Null -> Format.pp_print_string fmt \"`Null\"\n | `Bool x ->\n Format.fprintf fmt \"`Bool (@[\";\n Format.fprintf fmt \"%B\" x;\n Format.fprintf fmt \"@])\"\n \n# 9 \"monomorphic.ml\"\n | `Int x ->\n Format.fprintf fmt \"`Int (@[\";\n Format.fprintf fmt \"%d\" x;\n Format.fprintf fmt \"@])\"\n \n# 15 \"monomorphic.ml\"\n | `Intlit x ->\n Format.fprintf fmt \"`Intlit (@[\";\n Format.fprintf fmt \"%S\" x;\n Format.fprintf fmt \"@])\"\n \n# 21 \"monomorphic.ml\"\n | `Float x ->\n Format.fprintf fmt \"`Float (@[\";\n Format.fprintf fmt \"%F\" x;\n Format.fprintf fmt \"@])\"\n \n# 27 \"monomorphic.ml\"\n | `Floatlit x ->\n Format.fprintf fmt \"`Floatlit (@[\";\n Format.fprintf fmt \"%S\" x;\n Format.fprintf fmt \"@])\"\n \n# 33 \"monomorphic.ml\"\n | `String x ->\n Format.fprintf fmt \"`String (@[\";\n Format.fprintf fmt \"%S\" x;\n Format.fprintf fmt \"@])\"\n \n# 39 \"monomorphic.ml\"\n | `Stringlit x ->\n Format.fprintf fmt \"`Stringlit (@[\";\n Format.fprintf fmt \"%S\" x;\n Format.fprintf fmt \"@])\"\n \n# 44 \"monomorphic.ml\"\n | `Assoc xs ->\n Format.fprintf fmt \"`Assoc (@[\";\n Format.fprintf fmt \"@[<2>[\";\n ignore (List.fold_left\n (fun sep (key, value) ->\n if sep then\n Format.fprintf fmt \";@ \";\n Format.fprintf fmt \"(@[\";\n Format.fprintf fmt \"%S\" key;\n Format.fprintf fmt \",@ \";\n pp fmt value;\n Format.fprintf fmt \"@])\";\n true) false xs);\n Format.fprintf fmt \"@,]@]\";\n Format.fprintf fmt \"@])\"\n | `List xs ->\n Format.fprintf fmt \"`List (@[\";\n Format.fprintf fmt \"@[<2>[\";\n ignore (List.fold_left\n (fun sep x ->\n if sep then\n Format.fprintf fmt \";@ \";\n pp fmt x;\n true) false xs);\n Format.fprintf fmt \"@,]@]\";\n Format.fprintf fmt \"@])\"\n \n# 71 \"monomorphic.ml\"\n | `Tuple tup ->\n Format.fprintf fmt \"`Tuple (@[\";\n Format.fprintf fmt \"@[<2>[\";\n ignore (List.fold_left\n (fun sep e ->\n if sep then\n Format.fprintf fmt \";@ \";\n pp fmt e;\n true) false tup);\n Format.fprintf fmt \"@,]@]\";\n Format.fprintf fmt \"@])\"\n \n# 84 \"monomorphic.ml\"\n | `Variant (name, value) ->\n Format.fprintf fmt \"`Variant (@[\";\n Format.fprintf fmt \"(@[\";\n Format.fprintf fmt \"%S\" name;\n Format.fprintf fmt \",@ \";\n (match value with\n | None -> Format.pp_print_string fmt \"None\"\n | Some x ->\n Format.pp_print_string fmt \"(Some \";\n pp fmt x;\n Format.pp_print_string fmt \")\");\n Format.fprintf fmt \"@])\";\n Format.fprintf fmt \"@])\"\n\n# 99 \"monomorphic.ml\"\nlet show x =\n Format.asprintf \"%a\" pp x\n\nlet rec equal a b =\n match a, b with\n | `Null, `Null -> true\n | `Bool a, `Bool b -> a = b\n \n# 107 \"monomorphic.ml\"\n | `Int a, `Int b -> a = b\n \n# 110 \"monomorphic.ml\"\n | `Intlit a, `Intlit b -> a = b\n \n# 113 \"monomorphic.ml\"\n | `Float a, `Float b -> a = b\n \n# 116 \"monomorphic.ml\"\n | `Floatlit a, `Floatlit b -> a = b\n \n# 119 \"monomorphic.ml\"\n | `String a, `String b -> a = b\n \n# 122 \"monomorphic.ml\"\n | `Stringlit a, `Stringlit b -> a = b\n \n# 124 \"monomorphic.ml\"\n | `Assoc xs, `Assoc ys ->\n let compare_keys = fun (key, _) (key', _) -> String.compare key key' in\n let xs = List.stable_sort compare_keys xs in\n let ys = List.stable_sort compare_keys ys in\n (match List.for_all2 (fun (key, value) (key', value') ->\n match key = key' with\n | false -> false\n | true -> equal value value') xs ys with\n | result -> result\n | exception Invalid_argument _ ->\n (* the lists were of different lengths, thus unequal *)\n false)\n \n# 137 \"monomorphic.ml\"\n | `Tuple xs, `Tuple ys\n \n# 139 \"monomorphic.ml\"\n | `List xs, `List ys ->\n (match List.for_all2 equal xs ys with\n | result -> result\n | exception Invalid_argument _ ->\n (* the lists were of different lengths, thus unequal *)\n false)\n \n# 146 \"monomorphic.ml\"\n | `Variant (name, value), `Variant (name', value') ->\n (match name = name' with\n | false -> false\n | true ->\n match value, value' with\n | None, None -> true\n | Some x, Some y -> equal x y\n | _ -> false)\n \n# 155 \"monomorphic.ml\"\n | _ -> false\n# 15 \"yojson.cppo.ml\"\nmodule Pretty =\nstruct\n# 1 \"pretty.ml\"\nopen Printf\n\nlet array = Easy_format.list\nlet record = Easy_format.list\nlet tuple = { Easy_format.list with\n space_after_opening = false;\n space_before_closing = false;\n align_closing = false }\nlet variant = { Easy_format.list with\n space_before_closing = false; }\n\nlet rec format std (x : t) =\n match x with\n `Null -> Easy_format.Atom (\"null\", Easy_format.atom)\n | `Bool x -> Easy_format.Atom ((if x then \"true\" else \"false\"), Easy_format.atom)\n | `Int x -> Easy_format.Atom (json_string_of_int x, Easy_format.atom)\n | `Float x ->\n let s =\n if std then std_json_string_of_float x\n else json_string_of_float x\n in\n Easy_format.Atom (s, Easy_format.atom)\n | `String s -> Easy_format.Atom (json_string_of_string s, Easy_format.atom)\n | `Intlit s\n | `Floatlit s\n | `Stringlit s -> Easy_format.Atom (s, Easy_format.atom)\n | `List [] -> Easy_format.Atom (\"[]\", Easy_format.atom)\n | `List l -> Easy_format.List ((\"[\", \",\", \"]\", array), List.map (format std) l)\n | `Assoc [] -> Easy_format.Atom (\"{}\", Easy_format.atom)\n | `Assoc l -> Easy_format.List ((\"{\", \",\", \"}\", record), List.map (format_field std) l)\n | `Tuple l ->\n if std then\n format std (`List l)\n else\n if l = [] then\n Easy_format.Atom (\"()\", Easy_format.atom)\n else\n Easy_format.List ((\"(\", \",\", \")\", tuple), List.map (format std) l)\n\n | `Variant (s, None) ->\n if std then\n format std (`String s)\n else\n Easy_format.Atom (\"<\" ^ json_string_of_string s ^ \">\", Easy_format.atom)\n\n | `Variant (s, Some x) ->\n if std then\n format std (`List [ `String s; x ])\n else\n let op = \"<\" ^ json_string_of_string s ^ \":\" in\n Easy_format.List ((op, \"\", \">\", variant), [format std x])\n\nand format_field std (name, x) =\n let s = sprintf \"%s:\" (json_string_of_string name) in\n Easy_format.Label ((Easy_format.Atom (s, Easy_format.atom), Easy_format.label), format std x)\n\n\nlet format ?(std = false) x =\n if std && not (is_object_or_array x) then\n json_error\n \"Root is not an object or array as requested by the JSON standard\"\n else\n format std (x :> t)\n\nlet to_string ?std x =\n Easy_format.Pretty.to_string (format ?std x)\n\nlet to_channel ?std oc x =\n Easy_format.Pretty.to_channel oc (format ?std x)\n# 18 \"yojson.cppo.ml\"\nend\n# 1 \"write2.ml\"\nlet pretty_format ?std (x : t) =\n Pretty.format ?std (x :> json_max)\n\nlet pretty_print ?std out (x : t) =\n Easy_format.Pretty.to_formatter out (pretty_format ?std x)\n\nlet pretty_to_string ?std (x : t) =\n Pretty.to_string ?std (x :> json_max)\n\nlet pretty_to_channel ?std oc (x : t) =\n Pretty.to_channel ?std oc (x :> json_max)\n\n# 29 \"yojson.cppo.ml\"\nmodule Basic =\nstruct\n# 1 \"type.ml\"\n(** {3 Type of the JSON tree} *)\n\ntype t =\n [\n | `Null\n | `Bool of bool\n \n# 8 \"type.ml\"\n | `Int of int\n \n# 14 \"type.ml\"\n | `Float of float\n \n# 20 \"type.ml\"\n | `String of string\n \n# 25 \"type.ml\"\n | `Assoc of (string * t) list\n | `List of t list\n \n# 33 \"type.ml\"\n ]\n(**\nAll possible cases defined in Yojson:\n- `Null: JSON null\n- `Bool of bool: JSON boolean\n- `Int of int: JSON number without decimal point or exponent.\n- `Intlit of string: JSON number without decimal point or exponent,\n\t preserved as a string.\n- `Float of float: JSON number, Infinity, -Infinity or NaN.\n- `Floatlit of string: JSON number, Infinity, -Infinity or NaN,\n\t preserved as a string.\n- `String of string: JSON string. Bytes in the range 128-255 are preserved\n\t as-is without encoding validation for both reading\n\t and writing.\n- `Stringlit of string: JSON string literal including the double quotes.\n- `Assoc of (string * json) list: JSON object.\n- `List of json list: JSON array.\n- `Tuple of json list: Tuple (non-standard extension of JSON).\n\t Syntax: [(\"abc\", 123)].\n- `Variant of (string * json option): Variant (non-standard extension of JSON).\n\t Syntax: [<\"Foo\">] or [<\"Bar\":123>].\n*)\n\ntype json = t [@@deprecated \"json types are being renamed and will be removed in the next Yojson major version. Use type t instead\"]\n(**\n * Compatibility type alias for type `t`\n *)\n\n(*\n Note to adventurers: ocamldoc does not support inline comments\n on each polymorphic variant, and cppo doesn't allow to concatenate\n comments, so it would be complicated to document only the\n cases that are preserved by cppo in the type definition.\n*)\n# 1 \"write.ml\"\n(* included: type.ml *)\n\nlet hex n =\n Char.chr (\n if n < 10 then n + 48\n else n + 87\n )\n\nlet write_special src start stop ob str =\n Bi_outbuf.add_substring ob src !start (stop - !start);\n Bi_outbuf.add_string ob str;\n start := stop + 1\n\nlet write_control_char src start stop ob c =\n Bi_outbuf.add_substring ob src !start (stop - !start);\n let i = Bi_outbuf.alloc ob 6 in\n let dst = ob.o_s in\n Bytes.blit_string \"\\\\u00\" 0 dst i 4;\n Bytes.set dst (i+4) (hex (Char.code c lsr 4));\n Bytes.set dst (i+5) (hex (Char.code c land 0xf));\n start := stop + 1\n\nlet finish_string src start ob =\n try\n Bi_outbuf.add_substring ob src !start (String.length src - !start)\n with exc ->\n Printf.eprintf \"src=%S start=%i len=%i\\n%!\"\n src !start (String.length src - !start);\n raise exc\n\nlet write_string_body ob s =\n let start = ref 0 in\n for i = 0 to String.length s - 1 do\n match s.[i] with\n '\"' -> write_special s start i ob \"\\\\\\\"\"\n | '\\\\' -> write_special s start i ob \"\\\\\\\\\"\n | '\\b' -> write_special s start i ob \"\\\\b\"\n | '\\012' -> write_special s start i ob \"\\\\f\"\n | '\\n' -> write_special s start i ob \"\\\\n\"\n | '\\r' -> write_special s start i ob \"\\\\r\"\n | '\\t' -> write_special s start i ob \"\\\\t\"\n | '\\x00'..'\\x1F'\n | '\\x7F' as c -> write_control_char s start i ob c\n | _ -> ()\n done;\n finish_string s start ob\n\nlet write_string ob s =\n Bi_outbuf.add_char ob '\"';\n write_string_body ob s;\n Bi_outbuf.add_char ob '\"'\n\nlet json_string_of_string s =\n let ob = Bi_outbuf.create 10 in\n write_string ob s;\n Bi_outbuf.contents ob\n\nlet test_string () =\n let s = Bytes.create 256 in\n for i = 0 to 255 do\n Bytes.set s i (Char.chr i)\n done;\n json_string_of_string (Bytes.to_string s)\n\n\nlet write_null ob () =\n Bi_outbuf.add_string ob \"null\"\n\nlet write_bool ob x =\n Bi_outbuf.add_string ob (if x then \"true\" else \"false\")\n\n\nlet max_digits =\n max\n (String.length (string_of_int max_int))\n (String.length (string_of_int min_int))\n\nlet dec n =\n Char.chr (n + 48)\n\nlet rec write_digits s pos x =\n if x = 0 then pos\n else\n let d = x mod 10 in\n let pos = write_digits s pos (x / 10) in\n Bytes.set s pos (dec (abs d));\n pos + 1\n\nlet write_int ob x =\n Bi_outbuf.extend ob max_digits;\n if x > 0 then\n ob.o_len <- write_digits ob.o_s ob.o_len x\n else if x < 0 then (\n let s = ob.o_s in\n let pos = ob.o_len in\n Bytes.set s pos '-';\n ob.o_len <- write_digits s (pos + 1) x\n )\n else\n Bi_outbuf.add_char ob '0'\n\n\nlet json_string_of_int i =\n string_of_int i\n\n\n(*\n Ensure that the float is not printed as an int.\n This is not required by JSON, but useful in order to guarantee\n reversibility.\n*)\nlet float_needs_period s =\n try\n for i = 0 to String.length s - 1 do\n match s.[i] with\n '0'..'9' | '-' -> ()\n | _ -> raise Exit\n done;\n true\n with Exit ->\n false\n\n(*\n Both write_float_fast and write_float guarantee\n that a sufficient number of digits are printed in order to\n allow reversibility.\n\n The _fast version is faster but often produces unnecessarily long numbers.\n*)\nlet write_float_fast ob x =\n match classify_float x with\n FP_nan ->\n Bi_outbuf.add_string ob \"NaN\"\n | FP_infinite ->\n Bi_outbuf.add_string ob (if x > 0. then \"Infinity\" else \"-Infinity\")\n | _ ->\n let s = Printf.sprintf \"%.17g\" x in\n Bi_outbuf.add_string ob s;\n if float_needs_period s then\n Bi_outbuf.add_string ob \".0\"\n\nlet write_float ob x =\n match classify_float x with\n FP_nan ->\n Bi_outbuf.add_string ob \"NaN\"\n | FP_infinite ->\n Bi_outbuf.add_string ob (if x > 0. then \"Infinity\" else \"-Infinity\")\n | _ ->\n let s1 = Printf.sprintf \"%.16g\" x in\n let s =\n if float_of_string s1 = x then s1\n else Printf.sprintf \"%.17g\" x\n in\n Bi_outbuf.add_string ob s;\n if float_needs_period s then\n Bi_outbuf.add_string ob \".0\"\n\nlet write_normal_float_prec significant_figures ob x =\n let open Printf in\n let s =\n match significant_figures with\n 1 -> sprintf \"%.1g\" x\n | 2 -> sprintf \"%.2g\" x\n | 3 -> sprintf \"%.3g\" x\n | 4 -> sprintf \"%.4g\" x\n | 5 -> sprintf \"%.5g\" x\n | 6 -> sprintf \"%.6g\" x\n | 7 -> sprintf \"%.7g\" x\n | 8 -> sprintf \"%.8g\" x\n | 9 -> sprintf \"%.9g\" x\n | 10 -> sprintf \"%.10g\" x\n | 11 -> sprintf \"%.11g\" x\n | 12 -> sprintf \"%.12g\" x\n | 13 -> sprintf \"%.13g\" x\n | 14 -> sprintf \"%.14g\" x\n | 15 -> sprintf \"%.15g\" x\n | 16 -> sprintf \"%.16g\" x\n | _ -> sprintf \"%.17g\" x\n in\n Bi_outbuf.add_string ob s;\n if float_needs_period s then\n Bi_outbuf.add_string ob \".0\"\n\nlet write_float_prec significant_figures ob x =\n match classify_float x with\n FP_nan ->\n Bi_outbuf.add_string ob \"NaN\"\n | FP_infinite ->\n Bi_outbuf.add_string ob (if x > 0. then \"Infinity\" else \"-Infinity\")\n | _ ->\n write_normal_float_prec significant_figures ob x\n\nlet json_string_of_float x =\n let ob = Bi_outbuf.create 20 in\n write_float ob x;\n Bi_outbuf.contents ob\n\n\nlet write_std_float_fast ob x =\n match classify_float x with\n FP_nan ->\n json_error \"NaN value not allowed in standard JSON\"\n | FP_infinite ->\n json_error\n (if x > 0. then\n \"Infinity value not allowed in standard JSON\"\n else\n \"-Infinity value not allowed in standard JSON\")\n | _ ->\n let s = Printf.sprintf \"%.17g\" x in\n Bi_outbuf.add_string ob s;\n if float_needs_period s then\n Bi_outbuf.add_string ob \".0\"\n\nlet write_std_float ob x =\n match classify_float x with\n FP_nan ->\n json_error \"NaN value not allowed in standard JSON\"\n | FP_infinite ->\n json_error\n (if x > 0. then\n \"Infinity value not allowed in standard JSON\"\n else\n \"-Infinity value not allowed in standard JSON\")\n | _ ->\n let s1 = Printf.sprintf \"%.16g\" x in\n let s =\n if float_of_string s1 = x then s1\n else Printf.sprintf \"%.17g\" x\n in\n Bi_outbuf.add_string ob s;\n if float_needs_period s then\n Bi_outbuf.add_string ob \".0\"\n\nlet write_std_float_prec significant_figures ob x =\n match classify_float x with\n FP_nan ->\n json_error \"NaN value not allowed in standard JSON\"\n | FP_infinite ->\n json_error\n (if x > 0. then\n \"Infinity value not allowed in standard JSON\"\n else\n \"-Infinity value not allowed in standard JSON\")\n | _ ->\n write_normal_float_prec significant_figures ob x\n\nlet std_json_string_of_float x =\n let ob = Bi_outbuf.create 20 in\n write_std_float ob x;\n Bi_outbuf.contents ob\n\n\nlet test_float () =\n let l = [ 0.; 1.; -1. ] in\n let l = l @ List.map (fun x -> 2. *. x +. 1.) l in\n let l = l @ List.map (fun x -> x /. sqrt 2.) l in\n let l = l @ List.map (fun x -> x *. sqrt 3.) l in\n let l = l @ List.map cos l in\n let l = l @ List.map (fun x -> x *. 1.23e50) l in\n let l = l @ [ infinity; neg_infinity ] in\n List.iter (\n fun x ->\n let s = Printf.sprintf \"%.17g\" x in\n let y = float_of_string s in\n Printf.printf \"%g %g %S %B\\n\" x y s (x = y)\n )\n l\n\n(*\nlet () = test_float ()\n*)\n\nlet write_intlit = Bi_outbuf.add_string\nlet write_floatlit = Bi_outbuf.add_string\nlet write_stringlit = Bi_outbuf.add_string\n\nlet rec iter2_aux f_elt f_sep x = function\n [] -> ()\n | y :: l ->\n f_sep x;\n f_elt x y;\n iter2_aux f_elt f_sep x l\n\nlet iter2 f_elt f_sep x = function\n [] -> ()\n | y :: l ->\n f_elt x y;\n iter2_aux f_elt f_sep x l\n\nlet f_sep ob =\n Bi_outbuf.add_char ob ','\n\nlet rec write_json ob (x : t) =\n match x with\n `Null -> write_null ob ()\n | `Bool b -> write_bool ob b\n \n# 299 \"write.ml\"\n | `Int i -> write_int ob i\n \n# 305 \"write.ml\"\n | `Float f -> write_float ob f\n \n# 311 \"write.ml\"\n | `String s -> write_string ob s\n \n# 316 \"write.ml\"\n | `Assoc l -> write_assoc ob l\n | `List l -> write_list ob l\n\n# 325 \"write.ml\"\nand write_assoc ob l =\n let f_elt ob (s, x) =\n write_string ob s;\n Bi_outbuf.add_char ob ':';\n write_json ob x\n in\n Bi_outbuf.add_char ob '{';\n iter2 f_elt f_sep ob l;\n Bi_outbuf.add_char ob '}';\n\nand write_list ob l =\n Bi_outbuf.add_char ob '[';\n iter2 write_json f_sep ob l;\n Bi_outbuf.add_char ob ']'\n\n\n\n# 360 \"write.ml\"\nlet write_t = write_json\n\nlet rec write_std_json ob (x : t) =\n match x with\n `Null -> write_null ob ()\n | `Bool b -> write_bool ob b\n \n# 367 \"write.ml\"\n | `Int i -> write_int ob i\n \n# 373 \"write.ml\"\n | `Float f -> write_std_float ob f\n \n# 379 \"write.ml\"\n | `String s -> write_string ob s\n \n# 384 \"write.ml\"\n | `Assoc l -> write_std_assoc ob l\n | `List l -> write_std_list ob l\n\n# 393 \"write.ml\"\nand write_std_assoc ob l =\n let f_elt ob (s, x) =\n write_string ob s;\n Bi_outbuf.add_char ob ':';\n write_std_json ob x\n in\n Bi_outbuf.add_char ob '{';\n iter2 f_elt f_sep ob l;\n Bi_outbuf.add_char ob '}';\n\nand write_std_list ob l =\n Bi_outbuf.add_char ob '[';\n iter2 write_std_json f_sep ob l;\n Bi_outbuf.add_char ob ']'\n\nand write_std_tuple ob l =\n Bi_outbuf.add_char ob '[';\n iter2 write_std_json f_sep ob l;\n Bi_outbuf.add_char ob ']'\n\n\n\n# 426 \"write.ml\"\nlet to_outbuf ?(std = false) ob x =\n if std then (\n if not (is_object_or_array x) then\n json_error \"Root is not an object or array\"\n else\n write_std_json ob x\n )\n else\n write_json ob x\n\n\nlet to_string ?buf ?(len = 256) ?std x =\n let ob =\n match buf with\n None -> Bi_outbuf.create len\n | Some ob ->\n Bi_outbuf.clear ob;\n ob\n in\n to_outbuf ?std ob x;\n let s = Bi_outbuf.contents ob in\n Bi_outbuf.clear ob;\n s\n\nlet to_channel ?buf ?len ?std oc x =\n let ob =\n match buf with\n None -> Bi_outbuf.create_channel_writer ?len oc\n | Some ob -> ob\n in\n to_outbuf ?std ob x;\n Bi_outbuf.flush_channel_writer ob\n\nlet to_output ?buf ?len ?std out x =\n let ob =\n match buf with\n None -> Bi_outbuf.create_output_writer ?len out\n | Some ob -> ob\n in\n to_outbuf ?std ob x;\n Bi_outbuf.flush_output_writer ob\n\nlet to_file ?len ?std file x =\n let oc = open_out file in\n try\n to_channel ?len ?std oc x;\n close_out oc\n with e ->\n close_out_noerr oc;\n raise e\n\nlet stream_to_outbuf ?std ob st =\n Stream.iter (to_outbuf ?std ob) st\n\nlet stream_to_string ?buf ?(len = 256) ?std st =\n let ob =\n match buf with\n None -> Bi_outbuf.create len\n | Some ob ->\n Bi_outbuf.clear ob;\n ob\n in\n stream_to_outbuf ?std ob st;\n let s = Bi_outbuf.contents ob in\n Bi_outbuf.clear ob;\n s\n\nlet stream_to_channel ?buf ?len ?std oc st =\n let ob =\n match buf with\n None -> Bi_outbuf.create_channel_writer ?len oc\n | Some ob -> ob\n in\n stream_to_outbuf ?std ob st;\n Bi_outbuf.flush_channel_writer ob\n\nlet stream_to_file ?len ?std file st =\n let oc = open_out file in\n try\n stream_to_channel ?len ?std oc st;\n close_out oc\n with e ->\n close_out_noerr oc;\n raise e\n\n\nlet rec sort = function\n | `Assoc l ->\n let l = List.rev (List.rev_map (fun (k, v) -> (k, sort v)) l) in\n `Assoc (List.stable_sort (fun (a, _) (b, _) -> String.compare a b) l)\n | `List l ->\n `List (List.rev (List.rev_map sort l))\n \n# 529 \"write.ml\"\n | x -> x\n# 1 \"monomorphic.ml\"\nlet rec pp fmt =\n function\n | `Null -> Format.pp_print_string fmt \"`Null\"\n | `Bool x ->\n Format.fprintf fmt \"`Bool (@[\";\n Format.fprintf fmt \"%B\" x;\n Format.fprintf fmt \"@])\"\n \n# 9 \"monomorphic.ml\"\n | `Int x ->\n Format.fprintf fmt \"`Int (@[\";\n Format.fprintf fmt \"%d\" x;\n Format.fprintf fmt \"@])\"\n \n# 21 \"monomorphic.ml\"\n | `Float x ->\n Format.fprintf fmt \"`Float (@[\";\n Format.fprintf fmt \"%F\" x;\n Format.fprintf fmt \"@])\"\n \n# 33 \"monomorphic.ml\"\n | `String x ->\n Format.fprintf fmt \"`String (@[\";\n Format.fprintf fmt \"%S\" x;\n Format.fprintf fmt \"@])\"\n \n# 44 \"monomorphic.ml\"\n | `Assoc xs ->\n Format.fprintf fmt \"`Assoc (@[\";\n Format.fprintf fmt \"@[<2>[\";\n ignore (List.fold_left\n (fun sep (key, value) ->\n if sep then\n Format.fprintf fmt \";@ \";\n Format.fprintf fmt \"(@[\";\n Format.fprintf fmt \"%S\" key;\n Format.fprintf fmt \",@ \";\n pp fmt value;\n Format.fprintf fmt \"@])\";\n true) false xs);\n Format.fprintf fmt \"@,]@]\";\n Format.fprintf fmt \"@])\"\n | `List xs ->\n Format.fprintf fmt \"`List (@[\";\n Format.fprintf fmt \"@[<2>[\";\n ignore (List.fold_left\n (fun sep x ->\n if sep then\n Format.fprintf fmt \";@ \";\n pp fmt x;\n true) false xs);\n Format.fprintf fmt \"@,]@]\";\n Format.fprintf fmt \"@])\"\n\n# 99 \"monomorphic.ml\"\nlet show x =\n Format.asprintf \"%a\" pp x\n\nlet rec equal a b =\n match a, b with\n | `Null, `Null -> true\n | `Bool a, `Bool b -> a = b\n \n# 107 \"monomorphic.ml\"\n | `Int a, `Int b -> a = b\n \n# 113 \"monomorphic.ml\"\n | `Float a, `Float b -> a = b\n \n# 119 \"monomorphic.ml\"\n | `String a, `String b -> a = b\n \n# 124 \"monomorphic.ml\"\n | `Assoc xs, `Assoc ys ->\n let compare_keys = fun (key, _) (key', _) -> String.compare key key' in\n let xs = List.stable_sort compare_keys xs in\n let ys = List.stable_sort compare_keys ys in\n (match List.for_all2 (fun (key, value) (key', value') ->\n match key = key' with\n | false -> false\n | true -> equal value value') xs ys with\n | result -> result\n | exception Invalid_argument _ ->\n (* the lists were of different lengths, thus unequal *)\n false)\n \n# 139 \"monomorphic.ml\"\n | `List xs, `List ys ->\n (match List.for_all2 equal xs ys with\n | result -> result\n | exception Invalid_argument _ ->\n (* the lists were of different lengths, thus unequal *)\n false)\n \n# 155 \"monomorphic.ml\"\n | _ -> false\n# 1 \"write2.ml\"\nlet pretty_format ?std (x : t) =\n Pretty.format ?std (x :> json_max)\n\nlet pretty_print ?std out (x : t) =\n Easy_format.Pretty.to_formatter out (pretty_format ?std x)\n\nlet pretty_to_string ?std (x : t) =\n Pretty.to_string ?std (x :> json_max)\n\nlet pretty_to_channel ?std oc (x : t) =\n Pretty.to_channel ?std oc (x :> json_max)\n\n# 1 \"lib/read.mll\"\n \n \n# 2 \"lib/read.mll\"\n module Lexing =\n (*\n We override Lexing.engine in order to avoid creating a new position\n record each time a rule is matched.\n This reduces total parsing time by about 31%.\n *)\n struct\n include Lexing\n\n external c_engine : lex_tables -> int -> lexbuf -> int = \"caml_lex_engine\"\n\n let engine tbl state buf =\n let result = c_engine tbl state buf in\n (*\n if result >= 0 then begin\n buf.lex_start_p <- buf.lex_curr_p;\n buf.lex_curr_p <- {buf.lex_curr_p\n with pos_cnum = buf.lex_abs_pos + buf.lex_curr_pos};\n end;\n *)\n result\n end\n\n open Printf\n open Lexing\n\n (* see description in common.mli *)\n type lexer_state = Lexer_state.t = {\n buf : Bi_outbuf.t;\n mutable lnum : int;\n mutable bol : int;\n mutable fname : string option;\n }\n\n let dec c =\n Char.code c - 48\n\n let hex c =\n match c with\n '0'..'9' -> int_of_char c - int_of_char '0'\n | 'a'..'f' -> int_of_char c - int_of_char 'a' + 10\n | 'A'..'F' -> int_of_char c - int_of_char 'A' + 10\n | _ -> assert false\n\n let custom_error descr v lexbuf =\n let offs = lexbuf.lex_abs_pos - 1 in\n let bol = v.bol in\n let pos1 = offs + lexbuf.lex_start_pos - bol - 1 in\n let pos2 = max pos1 (offs + lexbuf.lex_curr_pos - bol) in\n let file_line =\n match v.fname with\n None -> \"Line\"\n | Some s ->\n sprintf \"File %s, line\" s\n in\n let bytes =\n if pos1 = pos2 then\n sprintf \"byte %i\" (pos1+1)\n else\n sprintf \"bytes %i-%i\" (pos1+1) (pos2+1)\n in\n let msg = sprintf \"%s %i, %s:\\n%s\" file_line v.lnum bytes descr in\n json_error msg\n\n\n let lexer_error descr v lexbuf =\n custom_error\n (sprintf \"%s '%s'\" descr (Lexing.lexeme lexbuf))\n v lexbuf\n\n let read_junk = ref (fun _ -> assert false)\n\n let long_error descr v lexbuf =\n let junk = Lexing.lexeme lexbuf in\n let extra_junk = !read_junk lexbuf in\n custom_error\n (sprintf \"%s '%s%s'\" descr junk extra_junk)\n v lexbuf\n\n let min10 = min_int / 10 - (if min_int mod 10 = 0 then 0 else 1)\n let max10 = max_int / 10 + (if max_int mod 10 = 0 then 0 else 1)\n\n exception Int_overflow\n\n let extract_positive_int lexbuf =\n let start = lexbuf.lex_start_pos in\n let stop = lexbuf.lex_curr_pos in\n let s = lexbuf.lex_buffer in\n let n = ref 0 in\n for i = start to stop - 1 do\n if !n >= max10 then\n raise Int_overflow\n else\n n := 10 * !n + dec (Bytes.get s i)\n done;\n if !n < 0 then\n raise Int_overflow\n else\n !n\n\n let make_positive_int v lexbuf =\n \n# 104 \"lib/read.mll\"\n try `Int (extract_positive_int lexbuf)\n with Int_overflow ->\n \n# 110 \"lib/read.mll\"\n lexer_error \"Int overflow\" v lexbuf\n\n \n# 113 \"lib/read.mll\"\n let extract_negative_int lexbuf =\n let start = lexbuf.lex_start_pos + 1 in\n let stop = lexbuf.lex_curr_pos in\n let s = lexbuf.lex_buffer in\n let n = ref 0 in\n for i = start to stop - 1 do\n if !n <= min10 then\n raise Int_overflow\n else\n n := 10 * !n - dec (Bytes.get s i)\n done;\n if !n > 0 then\n raise Int_overflow\n else\n !n\n\n let make_negative_int v lexbuf =\n \n# 131 \"lib/read.mll\"\n try `Int (extract_negative_int lexbuf)\n with Int_overflow ->\n \n# 137 \"lib/read.mll\"\n lexer_error \"Int overflow\" v lexbuf\n\n\n \n# 141 \"lib/read.mll\"\n let set_file_name v fname =\n v.fname <- fname\n\n let newline v lexbuf =\n v.lnum <- v.lnum + 1;\n v.bol <- lexbuf.lex_abs_pos + lexbuf.lex_curr_pos\n\n let add_lexeme buf lexbuf =\n let len = lexbuf.lex_curr_pos - lexbuf.lex_start_pos in\n Bi_outbuf.add_subbytes buf lexbuf.lex_buffer lexbuf.lex_start_pos len\n\n let map_lexeme f lexbuf =\n let len = lexbuf.lex_curr_pos - lexbuf.lex_start_pos in\n f (Bytes.to_string lexbuf.lex_buffer) lexbuf.lex_start_pos len\n\n type variant_kind = [ `Edgy_bracket | `Square_bracket | `Double_quote ]\n type tuple_kind = [ `Parenthesis | `Square_bracket ]\n\n\n# 161 \"lib/read.ml\"\n# 161 \"lib/read.ml\"\nlet __ocaml_lex_tables = {\n Lexing.lex_base =\n \"\\000\\000\\236\\255\\237\\255\\003\\000\\239\\255\\016\\000\\242\\255\\243\\255\\\n \\244\\255\\245\\255\\000\\000\\031\\000\\249\\255\\085\\000\\001\\000\\000\\000\\\n \\000\\000\\001\\000\\000\\000\\001\\000\\002\\000\\255\\255\\000\\000\\000\\000\\\n \\003\\000\\254\\255\\001\\000\\004\\000\\253\\255\\011\\000\\252\\255\\003\\000\\\n \\001\\000\\003\\000\\002\\000\\003\\000\\000\\000\\251\\255\\021\\000\\097\\000\\\n \\010\\000\\022\\000\\020\\000\\016\\000\\022\\000\\012\\000\\008\\000\\250\\255\\\n \\119\\000\\129\\000\\139\\000\\161\\000\\171\\000\\181\\000\\193\\000\\209\\000\\\n \\240\\255\\011\\000\\038\\000\\252\\255\\065\\000\\254\\255\\255\\255\\110\\000\\\n \\252\\255\\163\\000\\254\\255\\255\\255\\234\\000\\247\\255\\248\\255\\048\\001\\\n \\250\\255\\251\\255\\252\\255\\253\\255\\254\\255\\255\\255\\071\\001\\126\\001\\\n \\149\\001\\249\\255\\039\\000\\253\\255\\254\\255\\038\\000\\187\\001\\210\\001\\\n \\248\\001\\015\\002\\255\\255\\220\\000\\253\\255\\255\\255\\245\\000\\039\\002\\\n \\109\\002\\014\\001\\088\\002\\164\\002\\187\\002\\225\\002\\013\\000\\252\\255\\\n \\253\\255\\254\\255\\255\\255\\014\\000\\253\\255\\254\\255\\255\\255\\030\\000\\\n \\253\\255\\254\\255\\255\\255\\015\\000\\253\\255\\254\\255\\255\\255\\017\\001\\\n \\251\\255\\252\\255\\253\\255\\254\\255\\255\\255\\019\\000\\252\\255\\253\\255\\\n \\254\\255\\015\\000\\255\\255\\016\\000\\255\\255\\008\\001\\005\\000\\253\\255\\\n \\023\\000\\254\\255\\020\\000\\255\\255\\046\\000\\253\\255\\254\\255\\042\\000\\\n \\052\\000\\053\\000\\255\\255\\053\\000\\048\\000\\091\\000\\092\\000\\255\\255\\\n \\027\\001\\250\\255\\251\\255\\137\\000\\104\\000\\089\\000\\088\\000\\106\\000\\\n \\255\\255\\143\\000\\137\\000\\177\\000\\254\\255\\183\\000\\168\\000\\166\\000\\\n \\183\\000\\002\\000\\253\\255\\177\\000\\172\\000\\187\\000\\004\\000\\252\\255\\\n \\053\\002\\251\\255\\252\\255\\253\\255\\103\\001\\255\\255\\248\\002\\254\\255\\\n \\006\\003\\030\\003\\252\\255\\253\\255\\254\\255\\255\\255\\040\\003\\050\\003\\\n \\074\\003\\252\\255\\253\\255\\254\\255\\255\\255\\061\\003\\084\\003\\108\\003\\\n \\249\\255\\250\\255\\251\\255\\244\\000\\120\\003\\142\\003\\179\\000\\194\\000\\\n \\015\\000\\255\\255\\190\\000\\188\\000\\187\\000\\193\\000\\183\\000\\179\\000\\\n \\254\\255\\191\\000\\201\\000\\200\\000\\196\\000\\203\\000\\193\\000\\189\\000\\\n \\253\\255\\157\\003\\095\\003\\174\\003\\196\\003\\206\\003\\216\\003\\228\\003\\\n \\239\\003\\060\\000\\253\\255\\254\\255\\255\\255\\012\\004\\252\\255\\253\\255\\\n \\087\\004\\255\\255\\145\\004\\252\\255\\253\\255\\221\\004\\255\\255\\229\\000\\\n \\253\\255\\254\\255\\255\\255\\231\\000\\253\\255\\254\\255\\255\\255\\002\\000\\\n \\255\\255\\018\\001\\252\\255\\253\\255\\254\\255\\255\\255\\034\\001\\253\\255\\\n \\254\\255\\255\\255\\000\\000\\255\\255\\003\\000\\254\\255\\255\\255\\038\\001\\\n \\252\\255\\253\\255\\254\\255\\255\\255\\120\\001\\251\\255\\252\\255\\253\\255\\\n \\254\\255\\255\\255\\208\\000\\253\\255\\254\\255\\255\\255\\211\\000\\253\\255\\\n \\254\\255\\255\\255\\189\\000\\255\\255\\143\\001\\252\\255\\253\\255\\254\\255\\\n \\255\\255\\013\\001\\253\\255\\254\\255\\255\\255\\095\\001\\252\\255\\253\\255\\\n \\254\\255\\255\\255\\050\\001\\253\\255\\254\\255\\255\\255\\026\\001\\253\\255\\\n \\254\\255\\255\\255\\233\\000\\253\\255\\254\\255\\255\\255\\222\\000\\253\\255\\\n \\254\\255\\255\\255\\079\\005\\237\\255\\238\\255\\010\\000\\240\\255\\044\\001\\\n \\243\\255\\244\\255\\245\\255\\246\\255\\061\\001\\002\\004\\249\\255\\045\\005\\\n \\209\\000\\228\\000\\211\\000\\232\\000\\225\\000\\223\\000\\240\\000\\255\\255\\\n \\235\\000\\234\\000\\008\\001\\254\\255\\004\\001\\023\\001\\253\\255\\054\\001\\\n \\252\\255\\031\\001\\029\\001\\032\\001\\039\\001\\049\\001\\045\\001\\251\\255\\\n \\057\\001\\082\\001\\080\\001\\078\\001\\084\\001\\074\\001\\086\\001\\250\\255\\\n \\110\\005\\012\\004\\123\\005\\155\\005\\165\\005\\177\\005\\187\\005\\197\\005\\\n \\241\\255\\199\\001\\077\\002\\253\\255\\255\\255\\154\\002\\222\\005\\209\\005\\\n \\155\\002\\239\\005\\053\\006\\076\\006\\114\\006\\016\\002\\252\\255\\253\\255\\\n \\254\\255\\255\\255\\152\\006\\252\\255\\253\\255\\227\\006\\255\\255\\085\\007\\\n \\244\\255\\245\\255\\011\\000\\247\\255\\076\\002\\250\\255\\251\\255\\252\\255\\\n \\253\\255\\254\\255\\031\\002\\243\\005\\051\\007\\100\\001\\115\\001\\104\\001\\\n \\133\\001\\118\\001\\154\\001\\171\\001\\255\\255\\173\\001\\176\\001\\191\\001\\\n \\185\\001\\187\\001\\253\\001\\230\\001\\230\\001\\234\\001\\247\\001\\237\\001\\\n \\234\\001\\009\\002\\019\\002\\019\\002\\015\\002\\021\\002\\011\\002\\007\\002\\\n \\142\\006\\152\\006\\116\\007\\170\\007\\180\\007\\190\\007\\200\\007\\210\\007\\\n \\248\\255\\120\\002\\167\\002\\253\\255\\255\\255\\216\\002\\082\\007\\220\\007\\\n \\236\\002\\244\\007\\058\\008\\081\\008\\119\\008\\076\\002\\252\\255\\253\\255\\\n \\254\\255\\255\\255\\157\\008\\252\\255\\253\\255\\232\\008\\255\\255\\135\\002\\\n \\120\\002\\253\\255\\100\\002\\254\\255\\182\\002\\255\\255\\011\\002\\255\\255\\\n \\204\\002\\252\\255\\253\\255\\254\\255\\255\\255\\046\\002\\255\\255\\178\\002\\\n \\252\\255\\253\\255\\254\\255\\255\\255\\023\\000\\255\\255\\183\\002\\252\\255\\\n \\253\\255\\254\\255\\255\\255\\187\\002\\253\\255\\254\\255\\255\\255\\121\\002\\\n \\253\\255\\254\\255\\255\\255\\184\\002\\252\\255\\253\\255\\254\\255\\019\\000\\\n \\255\\255\\140\\001\\146\\001\\255\\255\\150\\001\\151\\001\\154\\001\\168\\001\\\n \\170\\001\\171\\001\\172\\001\\173\\001\\181\\001\\184\\001\\185\\001\\187\\001\\\n \\191\\001\\193\\001\\195\\001\\196\\001\\197\\001\\200\\001\\203\\001\\223\\001\\\n \\225\\001\\228\\001\\249\\001\\251\\001\\002\\002\\004\\002\\011\\002\\012\\002\\\n \\013\\002\\000\\000\";\n Lexing.lex_backtrk =\n \"\\255\\255\\255\\255\\255\\255\\017\\000\\255\\255\\019\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\007\\000\\007\\000\\255\\255\\019\\000\\019\\000\\019\\000\\\n \\019\\000\\019\\000\\019\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\008\\000\\008\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\009\\000\\255\\255\\009\\000\\255\\255\\009\\000\\255\\255\\\n \\255\\255\\014\\000\\255\\255\\255\\255\\002\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\002\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\007\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\001\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\003\\000\\255\\255\\001\\000\\255\\255\\004\\000\\003\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\\n \\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\004\\000\\004\\000\\004\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\003\\000\\255\\255\\000\\000\\255\\255\\\n \\001\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\002\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\002\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\003\\000\\003\\000\\005\\000\\005\\000\\005\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\003\\000\\255\\255\\003\\000\\255\\255\\003\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\001\\000\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\001\\000\\255\\255\\002\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\001\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\016\\000\\255\\255\\018\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\007\\000\\007\\000\\255\\255\\018\\000\\\n \\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\008\\000\\255\\255\\008\\000\\255\\255\\008\\000\\255\\255\\\n \\255\\255\\013\\000\\255\\255\\255\\255\\255\\255\\001\\000\\001\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\009\\000\\255\\255\\011\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\000\\000\\000\\000\\011\\000\\011\\000\\011\\000\\011\\000\\\n \\011\\000\\011\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\000\\000\\255\\255\\000\\000\\255\\255\\000\\000\\255\\255\\\n \\255\\255\\006\\000\\255\\255\\255\\255\\255\\255\\001\\000\\001\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\004\\000\\\n \\003\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\003\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\";\n Lexing.lex_default =\n \"\\001\\000\\000\\000\\000\\000\\255\\255\\000\\000\\255\\255\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\\n \\255\\255\\000\\000\\255\\255\\255\\255\\000\\000\\255\\255\\000\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\000\\000\\057\\000\\060\\000\\000\\000\\060\\000\\000\\000\\000\\000\\065\\000\\\n \\000\\000\\065\\000\\000\\000\\000\\000\\070\\000\\000\\000\\000\\000\\255\\255\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\255\\255\\\n \\255\\255\\000\\000\\084\\000\\000\\000\\000\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\000\\000\\094\\000\\000\\000\\000\\000\\097\\000\\255\\255\\\n \\255\\255\\097\\000\\255\\255\\255\\255\\255\\255\\255\\255\\104\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\109\\000\\000\\000\\000\\000\\000\\000\\113\\000\\\n \\000\\000\\000\\000\\000\\000\\117\\000\\000\\000\\000\\000\\000\\000\\121\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\126\\000\\000\\000\\000\\000\\\n \\000\\000\\255\\255\\000\\000\\255\\255\\000\\000\\255\\255\\255\\255\\000\\000\\\n \\255\\255\\000\\000\\138\\000\\000\\000\\142\\000\\000\\000\\000\\000\\255\\255\\\n \\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\\n \\154\\000\\000\\000\\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\000\\000\\255\\255\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\\n \\178\\000\\000\\000\\000\\000\\000\\000\\255\\255\\000\\000\\255\\255\\000\\000\\\n \\255\\255\\187\\000\\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\255\\255\\\n \\194\\000\\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\255\\255\\201\\000\\\n \\000\\000\\000\\000\\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\235\\000\\000\\000\\000\\000\\000\\000\\239\\000\\000\\000\\000\\000\\\n \\255\\255\\000\\000\\244\\000\\000\\000\\000\\000\\255\\255\\000\\000\\249\\000\\\n \\000\\000\\000\\000\\000\\000\\253\\000\\000\\000\\000\\000\\000\\000\\255\\255\\\n \\000\\000\\003\\001\\000\\000\\000\\000\\000\\000\\000\\000\\008\\001\\000\\000\\\n \\000\\000\\000\\000\\255\\255\\000\\000\\255\\255\\000\\000\\000\\000\\017\\001\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\022\\001\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\028\\001\\000\\000\\000\\000\\000\\000\\032\\001\\000\\000\\\n \\000\\000\\000\\000\\255\\255\\000\\000\\038\\001\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\043\\001\\000\\000\\000\\000\\000\\000\\047\\001\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\052\\001\\000\\000\\000\\000\\000\\000\\056\\001\\000\\000\\\n \\000\\000\\000\\000\\060\\001\\000\\000\\000\\000\\000\\000\\064\\001\\000\\000\\\n \\000\\000\\000\\000\\067\\001\\000\\000\\000\\000\\255\\255\\000\\000\\255\\255\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\255\\255\\000\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\\n \\255\\255\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\000\\000\\255\\255\\\n \\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\000\\000\\121\\001\\125\\001\\000\\000\\000\\000\\128\\001\\255\\255\\255\\255\\\n \\128\\001\\255\\255\\255\\255\\255\\255\\255\\255\\135\\001\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\140\\001\\000\\000\\000\\000\\255\\255\\000\\000\\144\\001\\\n \\000\\000\\000\\000\\255\\255\\000\\000\\255\\255\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\000\\000\\193\\001\\197\\001\\000\\000\\000\\000\\200\\001\\255\\255\\255\\255\\\n \\200\\001\\255\\255\\255\\255\\255\\255\\255\\255\\207\\001\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\212\\001\\000\\000\\000\\000\\255\\255\\000\\000\\255\\255\\\n \\255\\255\\000\\000\\255\\255\\000\\000\\220\\001\\000\\000\\255\\255\\000\\000\\\n \\226\\001\\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\000\\000\\233\\001\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\000\\000\\240\\001\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\245\\001\\000\\000\\000\\000\\000\\000\\249\\001\\\n \\000\\000\\000\\000\\000\\000\\252\\001\\000\\000\\000\\000\\000\\000\\255\\255\\\n \\000\\000\\002\\002\\004\\002\\000\\000\\005\\002\\006\\002\\007\\002\\008\\002\\\n \\009\\002\\010\\002\\011\\002\\012\\002\\013\\002\\014\\002\\015\\002\\016\\002\\\n \\017\\002\\018\\002\\019\\002\\020\\002\\021\\002\\022\\002\\023\\002\\024\\002\\\n \\025\\002\\026\\002\\027\\002\\028\\002\\029\\002\\030\\002\\031\\002\\032\\002\\\n \\033\\002\\003\\002\";\n Lexing.lex_trans =\n \"\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\003\\000\\004\\000\\000\\000\\003\\000\\003\\000\\134\\000\\000\\000\\\n \\003\\000\\000\\000\\134\\000\\069\\001\\146\\001\\255\\255\\000\\000\\069\\001\\\n \\146\\001\\000\\000\\000\\000\\000\\000\\000\\000\\127\\000\\139\\000\\000\\000\\\n \\003\\000\\000\\000\\012\\000\\003\\000\\170\\000\\134\\000\\175\\000\\000\\000\\\n \\007\\000\\011\\001\\069\\001\\146\\001\\014\\001\\013\\000\\049\\000\\005\\000\\\n \\010\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\\n \\011\\000\\011\\000\\056\\000\\118\\000\\006\\000\\129\\000\\130\\000\\057\\000\\\n \\237\\001\\137\\000\\000\\002\\049\\000\\000\\000\\048\\000\\138\\000\\106\\000\\\n \\062\\000\\014\\000\\110\\000\\105\\000\\000\\000\\049\\000\\015\\000\\011\\000\\\n \\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\\n \\011\\000\\030\\000\\048\\000\\008\\000\\114\\000\\209\\000\\236\\000\\000\\001\\\n \\013\\001\\029\\000\\022\\000\\255\\255\\048\\000\\048\\000\\017\\000\\021\\000\\\n \\025\\000\\032\\000\\033\\000\\035\\000\\023\\000\\027\\000\\016\\000\\031\\000\\\n \\028\\000\\034\\000\\019\\000\\024\\000\\018\\000\\026\\000\\020\\000\\036\\000\\\n \\041\\000\\037\\000\\048\\000\\009\\000\\042\\000\\043\\000\\044\\000\\045\\000\\\n \\046\\000\\047\\000\\061\\000\\085\\000\\048\\000\\038\\000\\039\\000\\039\\000\\\n \\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\049\\000\\\n \\067\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\\n \\039\\000\\039\\000\\039\\000\\086\\000\\143\\000\\255\\255\\040\\000\\144\\000\\\n \\145\\000\\146\\000\\055\\000\\148\\000\\055\\000\\149\\000\\048\\000\\054\\000\\\n \\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\\n \\054\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\\n \\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\\n \\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\255\\255\\048\\000\\150\\000\\\n \\151\\000\\161\\000\\066\\000\\158\\000\\053\\000\\159\\000\\053\\000\\160\\000\\\n \\051\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\\n \\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\\n \\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\\n \\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\165\\000\\\n \\051\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\\n \\054\\000\\054\\000\\054\\000\\162\\000\\163\\000\\166\\000\\093\\000\\255\\255\\\n \\002\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\\n \\054\\000\\054\\000\\054\\000\\255\\255\\077\\000\\103\\000\\108\\000\\116\\000\\\n \\132\\000\\134\\000\\135\\000\\128\\000\\139\\000\\134\\000\\164\\000\\093\\000\\\n \\171\\000\\077\\000\\167\\000\\168\\000\\169\\000\\172\\000\\112\\000\\173\\000\\\n \\174\\000\\210\\000\\226\\000\\208\\000\\211\\000\\212\\000\\059\\000\\083\\000\\\n \\134\\000\\213\\000\\214\\000\\215\\000\\216\\000\\218\\000\\141\\000\\219\\000\\\n \\093\\000\\220\\000\\221\\000\\123\\000\\222\\000\\223\\000\\224\\000\\136\\000\\\n \\095\\000\\225\\000\\035\\001\\065\\001\\234\\000\\155\\000\\005\\001\\097\\001\\\n \\250\\000\\255\\255\\254\\000\\057\\001\\061\\001\\095\\001\\077\\000\\044\\001\\\n \\092\\001\\088\\001\\009\\001\\029\\001\\076\\000\\124\\000\\033\\001\\018\\001\\\n \\075\\000\\098\\000\\019\\001\\085\\001\\086\\001\\087\\001\\120\\001\\089\\001\\\n \\074\\000\\225\\000\\053\\001\\121\\001\\073\\000\\090\\001\\072\\000\\071\\000\\\n \\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\\n \\078\\000\\078\\000\\098\\000\\113\\001\\122\\000\\091\\001\\064\\000\\004\\001\\\n \\093\\001\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\079\\000\\\n \\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\\n \\079\\000\\156\\000\\112\\001\\094\\001\\096\\001\\098\\001\\099\\001\\049\\001\\\n \\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\100\\001\\157\\000\\\n \\101\\001\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\183\\000\\\n \\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\\n \\184\\000\\024\\001\\112\\001\\255\\255\\025\\001\\102\\001\\103\\001\\105\\001\\\n \\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\080\\000\\080\\000\\\n \\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\\n \\106\\001\\107\\001\\048\\001\\040\\001\\108\\001\\109\\001\\110\\001\\080\\000\\\n \\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\081\\000\\081\\000\\081\\000\\\n \\081\\000\\081\\000\\081\\000\\081\\000\\081\\000\\081\\000\\081\\000\\111\\001\\\n \\027\\001\\255\\255\\171\\001\\031\\001\\170\\001\\023\\001\\081\\000\\081\\000\\\n \\081\\000\\081\\000\\081\\000\\081\\000\\092\\000\\168\\001\\063\\001\\080\\000\\\n \\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\248\\000\\165\\001\\252\\000\\\n \\162\\001\\059\\001\\069\\000\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\\n \\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\255\\255\\081\\000\\081\\000\\\n \\081\\000\\081\\000\\081\\000\\081\\000\\087\\000\\087\\000\\087\\000\\087\\000\\\n \\087\\000\\087\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\\n \\088\\000\\088\\000\\088\\000\\088\\000\\039\\001\\042\\001\\255\\255\\163\\001\\\n \\164\\001\\120\\000\\002\\001\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\\n \\088\\000\\166\\001\\055\\001\\153\\000\\087\\000\\087\\000\\087\\000\\087\\000\\\n \\087\\000\\087\\000\\007\\001\\167\\001\\164\\001\\169\\001\\016\\001\\164\\001\\\n \\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\\n \\089\\000\\089\\000\\051\\001\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\\n \\088\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\090\\000\\\n \\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\\n \\090\\000\\097\\000\\137\\001\\164\\001\\172\\001\\185\\001\\136\\001\\173\\001\\\n \\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\097\\000\\179\\000\\\n \\174\\001\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\046\\001\\\n \\175\\001\\176\\001\\180\\000\\164\\001\\184\\001\\181\\000\\182\\000\\182\\000\\\n \\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\124\\001\\\n \\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\192\\001\\178\\001\\\n \\021\\001\\179\\001\\097\\000\\193\\001\\180\\001\\181\\001\\182\\001\\183\\001\\\n \\164\\001\\216\\001\\255\\255\\097\\000\\184\\001\\216\\001\\209\\001\\097\\000\\\n \\223\\001\\097\\000\\208\\001\\230\\001\\003\\002\\097\\000\\219\\001\\037\\001\\\n \\216\\001\\217\\001\\003\\002\\220\\001\\216\\001\\097\\000\\003\\002\\003\\002\\\n \\216\\001\\097\\000\\003\\002\\097\\000\\096\\000\\099\\000\\099\\000\\099\\000\\\n \\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\216\\001\\\n \\003\\002\\126\\001\\003\\002\\003\\002\\003\\002\\003\\002\\099\\000\\099\\000\\\n \\099\\000\\099\\000\\099\\000\\099\\000\\097\\000\\003\\002\\218\\001\\250\\001\\\n \\003\\002\\003\\002\\097\\000\\003\\002\\124\\001\\124\\001\\097\\000\\003\\002\\\n \\221\\001\\003\\002\\253\\001\\003\\002\\003\\002\\003\\002\\097\\000\\255\\255\\\n \\003\\002\\196\\001\\097\\000\\003\\002\\097\\000\\096\\000\\099\\000\\099\\000\\\n \\099\\000\\099\\000\\099\\000\\099\\000\\100\\000\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\235\\001\\003\\002\\\n \\241\\001\\003\\002\\255\\001\\242\\001\\003\\002\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\100\\000\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\\n \\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\246\\001\\129\\001\\129\\001\\\n \\228\\001\\003\\002\\196\\001\\003\\002\\101\\000\\101\\000\\101\\000\\101\\000\\\n \\101\\000\\101\\000\\003\\002\\198\\001\\003\\002\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\100\\000\\003\\002\\003\\002\\003\\002\\196\\001\\234\\001\\\n \\134\\001\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\\n \\097\\000\\097\\000\\097\\000\\000\\000\\101\\000\\101\\000\\101\\000\\101\\000\\\n \\101\\000\\101\\000\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\\n \\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\\n \\182\\000\\182\\000\\000\\000\\000\\000\\201\\001\\177\\000\\184\\000\\184\\000\\\n \\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\\n \\188\\000\\000\\000\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\\n \\201\\001\\227\\001\\000\\000\\191\\000\\206\\001\\123\\001\\189\\000\\190\\000\\\n \\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\\n \\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\\n \\190\\000\\190\\000\\189\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\\n \\190\\000\\190\\000\\190\\000\\190\\000\\195\\000\\197\\000\\197\\000\\197\\000\\\n \\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\198\\000\\\n \\255\\255\\248\\001\\196\\000\\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\\n \\197\\000\\197\\000\\197\\000\\197\\000\\196\\000\\197\\000\\197\\000\\197\\000\\\n \\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\202\\000\\227\\000\\\n \\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\\n \\227\\000\\205\\000\\255\\255\\255\\255\\203\\000\\204\\000\\204\\000\\204\\000\\\n \\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\226\\000\\195\\001\\\n \\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\\n \\204\\000\\204\\000\\232\\001\\000\\000\\000\\000\\206\\000\\221\\001\\239\\001\\\n \\254\\001\\000\\000\\207\\000\\244\\001\\000\\000\\225\\000\\203\\000\\204\\000\\\n \\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\\n \\232\\000\\000\\000\\232\\000\\000\\000\\225\\001\\231\\000\\231\\000\\231\\000\\\n \\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\217\\000\\\n \\255\\255\\000\\000\\000\\000\\000\\000\\000\\000\\225\\000\\227\\000\\227\\000\\\n \\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\000\\000\\000\\000\\230\\000\\\n \\000\\000\\230\\000\\000\\000\\228\\000\\229\\000\\229\\000\\229\\000\\229\\000\\\n \\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\\n \\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\\n \\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\\n \\229\\000\\229\\000\\000\\000\\228\\000\\231\\000\\231\\000\\231\\000\\231\\000\\\n \\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\186\\000\\231\\000\\\n \\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\\n \\231\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\241\\000\\000\\000\\\n \\113\\001\\000\\000\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\\n \\077\\001\\077\\001\\077\\001\\077\\001\\114\\001\\114\\001\\114\\001\\114\\001\\\n \\114\\001\\114\\001\\114\\001\\114\\001\\114\\001\\114\\001\\000\\000\\112\\001\\\n \\000\\000\\000\\000\\193\\000\\000\\000\\000\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\112\\001\\\n \\000\\000\\000\\000\\000\\000\\240\\000\\200\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\000\\000\\246\\000\\000\\000\\000\\000\\240\\000\\000\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\245\\000\\000\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\238\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\245\\000\\000\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\069\\001\\070\\001\\000\\000\\000\\000\\069\\001\\076\\001\\077\\001\\077\\001\\\n \\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\069\\001\\\n \\000\\000\\078\\001\\000\\000\\000\\000\\000\\000\\000\\000\\104\\001\\073\\001\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\079\\001\\000\\000\\071\\001\\076\\001\\\n \\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\\n \\077\\001\\000\\000\\000\\000\\072\\001\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\243\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\080\\001\\119\\001\\000\\000\\119\\001\\000\\000\\081\\001\\118\\001\\118\\001\\\n \\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\\n \\000\\000\\000\\000\\074\\001\\114\\001\\114\\001\\114\\001\\114\\001\\114\\001\\\n \\114\\001\\114\\001\\114\\001\\114\\001\\114\\001\\083\\001\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\082\\001\\000\\000\\000\\000\\\n \\115\\001\\000\\000\\000\\000\\084\\001\\000\\000\\000\\000\\117\\001\\000\\000\\\n \\117\\001\\000\\000\\075\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\\n \\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\\n \\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\000\\000\\\n \\115\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\\n \\116\\001\\116\\001\\116\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\\n \\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\\n \\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\000\\000\\\n \\128\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\\n \\130\\001\\130\\001\\130\\001\\000\\000\\000\\000\\128\\001\\000\\000\\000\\000\\\n \\000\\000\\128\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\001\\000\\000\\\n \\000\\000\\185\\001\\000\\000\\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\\n \\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\\n \\184\\001\\000\\000\\128\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\128\\001\\000\\000\\000\\000\\000\\000\\128\\001\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\128\\001\\128\\001\\000\\000\\000\\000\\068\\001\\\n \\128\\001\\128\\001\\128\\001\\127\\001\\000\\000\\128\\001\\000\\000\\000\\000\\\n \\184\\001\\000\\000\\000\\000\\000\\000\\000\\000\\128\\001\\000\\000\\000\\000\\\n \\000\\000\\128\\001\\000\\000\\128\\001\\127\\001\\131\\001\\131\\001\\131\\001\\\n \\131\\001\\131\\001\\131\\001\\131\\001\\131\\001\\131\\001\\131\\001\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\131\\001\\131\\001\\\n \\131\\001\\131\\001\\131\\001\\131\\001\\132\\001\\132\\001\\132\\001\\132\\001\\\n \\132\\001\\132\\001\\132\\001\\132\\001\\132\\001\\132\\001\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\132\\001\\132\\001\\132\\001\\\n \\132\\001\\132\\001\\132\\001\\000\\000\\000\\000\\000\\000\\131\\001\\131\\001\\\n \\131\\001\\131\\001\\131\\001\\131\\001\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\128\\001\\128\\001\\128\\001\\128\\001\\128\\001\\128\\001\\\n \\128\\001\\128\\001\\128\\001\\128\\001\\000\\000\\132\\001\\132\\001\\132\\001\\\n \\132\\001\\132\\001\\132\\001\\128\\001\\128\\001\\128\\001\\128\\001\\128\\001\\\n \\128\\001\\191\\001\\142\\001\\191\\001\\000\\000\\000\\000\\190\\001\\190\\001\\\n \\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\\n \\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\\n \\186\\001\\186\\001\\000\\000\\128\\001\\128\\001\\128\\001\\128\\001\\128\\001\\\n \\128\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\000\\000\\000\\000\\000\\000\\000\\000\\141\\001\\\n \\000\\000\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\141\\001\\000\\000\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\146\\001\\147\\001\\\n \\000\\000\\000\\000\\146\\001\\154\\001\\155\\001\\155\\001\\155\\001\\155\\001\\\n \\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\200\\001\\146\\001\\000\\000\\153\\001\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\177\\001\\150\\001\\000\\000\\000\\000\\\n \\000\\000\\200\\001\\156\\001\\000\\000\\148\\001\\154\\001\\155\\001\\155\\001\\\n \\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\000\\000\\\n \\000\\000\\149\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\139\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\157\\001\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\158\\001\\186\\001\\186\\001\\186\\001\\186\\001\\\n \\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\200\\001\\000\\000\\\n \\151\\001\\000\\000\\000\\000\\000\\000\\200\\001\\000\\000\\000\\000\\000\\000\\\n \\200\\001\\187\\001\\000\\000\\160\\001\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\200\\001\\000\\000\\000\\000\\159\\001\\200\\001\\000\\000\\200\\001\\199\\001\\\n \\000\\000\\161\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\152\\001\\000\\000\\000\\000\\000\\000\\000\\000\\189\\001\\000\\000\\189\\001\\\n \\000\\000\\187\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\\n \\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\\n \\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\\n \\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\\n \\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\\n \\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\\n \\190\\001\\190\\001\\190\\001\\190\\001\\202\\001\\202\\001\\202\\001\\202\\001\\\n \\202\\001\\202\\001\\202\\001\\202\\001\\202\\001\\202\\001\\200\\001\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\202\\001\\202\\001\\202\\001\\\n \\202\\001\\202\\001\\202\\001\\200\\001\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\202\\001\\202\\001\\202\\001\\\n \\202\\001\\202\\001\\202\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\200\\001\\000\\000\\000\\000\\000\\000\\000\\000\\145\\001\\200\\001\\000\\000\\\n \\000\\000\\000\\000\\200\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\200\\001\\000\\000\\000\\000\\000\\000\\200\\001\\000\\000\\\n \\200\\001\\199\\001\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\\n \\203\\001\\203\\001\\203\\001\\203\\001\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\\n \\203\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\\n \\204\\001\\204\\001\\204\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\\n \\000\\000\\000\\000\\000\\000\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\\n \\203\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\200\\001\\\n \\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\\n \\200\\001\\000\\000\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\\n \\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\000\\000\\214\\001\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\213\\001\\000\\000\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\000\\000\\000\\000\\000\\000\\000\\000\\213\\001\\\n \\000\\000\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\211\\001\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\";\n Lexing.lex_check =\n \"\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\000\\000\\000\\000\\255\\255\\003\\000\\000\\000\\134\\000\\255\\255\\\n \\003\\000\\255\\255\\134\\000\\069\\001\\146\\001\\057\\000\\255\\255\\069\\001\\\n \\146\\001\\255\\255\\255\\255\\255\\255\\255\\255\\125\\000\\138\\000\\255\\255\\\n \\000\\000\\255\\255\\000\\000\\003\\000\\169\\000\\134\\000\\174\\000\\255\\255\\\n \\000\\000\\010\\001\\069\\001\\146\\001\\012\\001\\000\\000\\010\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\005\\000\\115\\000\\000\\000\\125\\000\\129\\000\\005\\000\\\n \\236\\001\\136\\000\\255\\001\\038\\000\\255\\255\\010\\000\\136\\000\\102\\000\\\n \\058\\000\\000\\000\\107\\000\\102\\000\\255\\255\\011\\000\\000\\000\\011\\000\\\n \\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\\n \\011\\000\\029\\000\\038\\000\\000\\000\\111\\000\\208\\000\\233\\000\\255\\000\\\n \\012\\001\\015\\000\\017\\000\\060\\000\\011\\000\\010\\000\\000\\000\\020\\000\\\n \\024\\000\\031\\000\\032\\000\\034\\000\\022\\000\\026\\000\\000\\000\\014\\000\\\n \\027\\000\\033\\000\\018\\000\\023\\000\\000\\000\\016\\000\\019\\000\\035\\000\\\n \\040\\000\\036\\000\\038\\000\\000\\000\\041\\000\\042\\000\\043\\000\\044\\000\\\n \\045\\000\\046\\000\\058\\000\\082\\000\\011\\000\\013\\000\\013\\000\\013\\000\\\n \\013\\000\\013\\000\\013\\000\\013\\000\\013\\000\\013\\000\\013\\000\\039\\000\\\n \\063\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\\n \\039\\000\\039\\000\\039\\000\\085\\000\\140\\000\\060\\000\\013\\000\\143\\000\\\n \\144\\000\\145\\000\\048\\000\\147\\000\\048\\000\\148\\000\\039\\000\\048\\000\\\n \\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\\n \\048\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\\n \\049\\000\\049\\000\\049\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\\n \\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\065\\000\\039\\000\\149\\000\\\n \\150\\000\\156\\000\\063\\000\\157\\000\\051\\000\\158\\000\\051\\000\\159\\000\\\n \\050\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\\n \\051\\000\\051\\000\\051\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\\n \\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\053\\000\\053\\000\\053\\000\\\n \\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\155\\000\\\n \\050\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\\n \\054\\000\\054\\000\\054\\000\\161\\000\\162\\000\\155\\000\\091\\000\\065\\000\\\n \\000\\000\\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\\n \\055\\000\\055\\000\\055\\000\\057\\000\\068\\000\\102\\000\\107\\000\\115\\000\\\n \\131\\000\\133\\000\\133\\000\\125\\000\\138\\000\\133\\000\\163\\000\\094\\000\\\n \\165\\000\\068\\000\\166\\000\\167\\000\\168\\000\\171\\000\\111\\000\\172\\000\\\n \\173\\000\\206\\000\\203\\000\\207\\000\\210\\000\\211\\000\\058\\000\\082\\000\\\n \\133\\000\\212\\000\\213\\000\\214\\000\\215\\000\\217\\000\\140\\000\\218\\000\\\n \\097\\000\\219\\000\\220\\000\\119\\000\\221\\000\\222\\000\\223\\000\\133\\000\\\n \\091\\000\\203\\000\\034\\001\\062\\001\\233\\000\\152\\000\\001\\001\\080\\001\\\n \\247\\000\\060\\000\\251\\000\\054\\001\\058\\001\\081\\001\\068\\000\\041\\001\\\n \\082\\001\\083\\001\\006\\001\\026\\001\\068\\000\\119\\000\\030\\001\\015\\001\\\n \\068\\000\\094\\000\\015\\001\\084\\001\\085\\001\\086\\001\\071\\001\\088\\001\\\n \\068\\000\\203\\000\\050\\001\\071\\001\\068\\000\\089\\001\\068\\000\\068\\000\\\n \\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\\n \\071\\000\\071\\000\\097\\000\\076\\001\\119\\000\\090\\001\\063\\000\\001\\001\\\n \\092\\001\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\078\\000\\\n \\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\\n \\078\\000\\152\\000\\076\\001\\093\\001\\095\\001\\097\\001\\098\\001\\045\\001\\\n \\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\099\\001\\152\\000\\\n \\100\\001\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\180\\000\\\n \\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\\n \\180\\000\\020\\001\\076\\001\\065\\000\\020\\001\\101\\001\\102\\001\\104\\001\\\n \\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\079\\000\\079\\000\\\n \\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\\n \\105\\001\\106\\001\\045\\001\\036\\001\\107\\001\\108\\001\\109\\001\\079\\000\\\n \\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\080\\000\\080\\000\\080\\000\\\n \\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\110\\001\\\n \\026\\001\\121\\001\\157\\001\\030\\001\\158\\001\\020\\001\\080\\000\\080\\000\\\n \\080\\000\\080\\000\\080\\000\\080\\000\\091\\000\\159\\001\\062\\001\\079\\000\\\n \\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\247\\000\\160\\001\\251\\000\\\n \\161\\001\\058\\001\\068\\000\\086\\000\\086\\000\\086\\000\\086\\000\\086\\000\\\n \\086\\000\\086\\000\\086\\000\\086\\000\\086\\000\\094\\000\\080\\000\\080\\000\\\n \\080\\000\\080\\000\\080\\000\\080\\000\\086\\000\\086\\000\\086\\000\\086\\000\\\n \\086\\000\\086\\000\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\\n \\087\\000\\087\\000\\087\\000\\087\\000\\036\\001\\041\\001\\097\\000\\162\\001\\\n \\163\\001\\119\\000\\001\\001\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\\n \\087\\000\\165\\001\\054\\001\\152\\000\\086\\000\\086\\000\\086\\000\\086\\000\\\n \\086\\000\\086\\000\\006\\001\\166\\001\\167\\001\\168\\001\\015\\001\\169\\001\\\n \\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\\n \\088\\000\\088\\000\\050\\001\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\\n \\087\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\089\\000\\\n \\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\\n \\089\\000\\095\\000\\133\\001\\170\\001\\171\\001\\154\\001\\133\\001\\172\\001\\\n \\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\095\\000\\176\\000\\\n \\173\\001\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\045\\001\\\n \\174\\001\\175\\001\\176\\000\\176\\001\\154\\001\\176\\000\\176\\000\\176\\000\\\n \\176\\000\\176\\000\\176\\000\\176\\000\\176\\000\\176\\000\\176\\000\\122\\001\\\n \\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\148\\001\\177\\001\\\n \\020\\001\\178\\001\\098\\000\\148\\001\\179\\001\\180\\001\\181\\001\\182\\001\\\n \\183\\001\\216\\001\\193\\001\\095\\000\\154\\001\\216\\001\\205\\001\\098\\000\\\n \\222\\001\\095\\000\\205\\001\\229\\001\\001\\002\\095\\000\\218\\001\\036\\001\\\n \\215\\001\\215\\001\\002\\002\\218\\001\\215\\001\\095\\000\\004\\002\\005\\002\\\n \\216\\001\\095\\000\\006\\002\\095\\000\\095\\000\\096\\000\\096\\000\\096\\000\\\n \\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\215\\001\\\n \\007\\002\\122\\001\\008\\002\\009\\002\\010\\002\\011\\002\\096\\000\\096\\000\\\n \\096\\000\\096\\000\\096\\000\\096\\000\\098\\000\\012\\002\\215\\001\\247\\001\\\n \\013\\002\\014\\002\\098\\000\\015\\002\\125\\001\\128\\001\\098\\000\\016\\002\\\n \\220\\001\\017\\002\\251\\001\\018\\002\\019\\002\\020\\002\\098\\000\\121\\001\\\n \\021\\002\\194\\001\\098\\000\\022\\002\\098\\000\\098\\000\\096\\000\\096\\000\\\n \\096\\000\\096\\000\\096\\000\\096\\000\\099\\000\\099\\000\\099\\000\\099\\000\\\n \\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\231\\001\\023\\002\\\n \\238\\001\\024\\002\\251\\001\\238\\001\\025\\002\\099\\000\\099\\000\\099\\000\\\n \\099\\000\\099\\000\\099\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\243\\001\\125\\001\\128\\001\\\n \\224\\001\\026\\002\\197\\001\\027\\002\\100\\000\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\028\\002\\194\\001\\029\\002\\099\\000\\099\\000\\099\\000\\\n \\099\\000\\099\\000\\099\\000\\030\\002\\031\\002\\032\\002\\200\\001\\231\\001\\\n \\133\\001\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\\n \\101\\000\\101\\000\\101\\000\\255\\255\\100\\000\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\\n \\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\\n \\182\\000\\182\\000\\255\\255\\255\\255\\197\\001\\176\\000\\184\\000\\184\\000\\\n \\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\\n \\185\\000\\255\\255\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\\n \\200\\001\\224\\001\\255\\255\\185\\000\\205\\001\\122\\001\\185\\000\\185\\000\\\n \\185\\000\\185\\000\\185\\000\\185\\000\\185\\000\\185\\000\\185\\000\\185\\000\\\n \\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\\n \\190\\000\\190\\000\\191\\000\\191\\000\\191\\000\\191\\000\\191\\000\\191\\000\\\n \\191\\000\\191\\000\\191\\000\\191\\000\\192\\000\\197\\000\\197\\000\\197\\000\\\n \\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\192\\000\\\n \\193\\001\\247\\001\\192\\000\\192\\000\\192\\000\\192\\000\\192\\000\\192\\000\\\n \\192\\000\\192\\000\\192\\000\\192\\000\\198\\000\\198\\000\\198\\000\\198\\000\\\n \\198\\000\\198\\000\\198\\000\\198\\000\\198\\000\\198\\000\\199\\000\\226\\000\\\n \\226\\000\\226\\000\\226\\000\\226\\000\\226\\000\\226\\000\\226\\000\\226\\000\\\n \\226\\000\\199\\000\\125\\001\\128\\001\\199\\000\\199\\000\\199\\000\\199\\000\\\n \\199\\000\\199\\000\\199\\000\\199\\000\\199\\000\\199\\000\\204\\000\\194\\001\\\n \\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\\n \\204\\000\\204\\000\\231\\001\\255\\255\\255\\255\\199\\000\\220\\001\\238\\001\\\n \\251\\001\\255\\255\\199\\000\\243\\001\\255\\255\\204\\000\\205\\000\\205\\000\\\n \\205\\000\\205\\000\\205\\000\\205\\000\\205\\000\\205\\000\\205\\000\\205\\000\\\n \\225\\000\\255\\255\\225\\000\\255\\255\\224\\001\\225\\000\\225\\000\\225\\000\\\n \\225\\000\\225\\000\\225\\000\\225\\000\\225\\000\\225\\000\\225\\000\\205\\000\\\n \\197\\001\\255\\255\\255\\255\\255\\255\\255\\255\\204\\000\\227\\000\\227\\000\\\n \\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\200\\001\\255\\255\\255\\255\\228\\000\\\n \\255\\255\\228\\000\\255\\255\\227\\000\\228\\000\\228\\000\\228\\000\\228\\000\\\n \\228\\000\\228\\000\\228\\000\\228\\000\\228\\000\\228\\000\\229\\000\\229\\000\\\n \\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\\n \\230\\000\\230\\000\\230\\000\\230\\000\\230\\000\\230\\000\\230\\000\\230\\000\\\n \\230\\000\\230\\000\\255\\255\\227\\000\\231\\000\\231\\000\\231\\000\\231\\000\\\n \\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\185\\000\\232\\000\\\n \\232\\000\\232\\000\\232\\000\\232\\000\\232\\000\\232\\000\\232\\000\\232\\000\\\n \\232\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\237\\000\\255\\255\\\n \\077\\001\\255\\255\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\\n \\077\\001\\077\\001\\077\\001\\077\\001\\113\\001\\113\\001\\113\\001\\113\\001\\\n \\113\\001\\113\\001\\113\\001\\113\\001\\113\\001\\113\\001\\255\\255\\077\\001\\\n \\255\\255\\255\\255\\192\\000\\255\\255\\255\\255\\237\\000\\237\\000\\237\\000\\\n \\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\\n \\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\\n \\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\077\\001\\\n \\255\\255\\255\\255\\255\\255\\237\\000\\199\\000\\237\\000\\237\\000\\237\\000\\\n \\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\\n \\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\\n \\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\255\\255\\242\\000\\255\\255\\255\\255\\240\\000\\255\\255\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\\n \\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\\n \\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\\n \\242\\000\\242\\000\\242\\000\\242\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\242\\000\\255\\255\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\\n \\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\\n \\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\\n \\242\\000\\242\\000\\242\\000\\242\\000\\237\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\245\\000\\255\\255\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\066\\001\\066\\001\\255\\255\\255\\255\\066\\001\\079\\001\\079\\001\\079\\001\\\n \\079\\001\\079\\001\\079\\001\\079\\001\\079\\001\\079\\001\\079\\001\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\066\\001\\\n \\255\\255\\066\\001\\255\\255\\255\\255\\255\\255\\255\\255\\079\\001\\066\\001\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\066\\001\\255\\255\\066\\001\\066\\001\\\n \\066\\001\\066\\001\\066\\001\\066\\001\\066\\001\\066\\001\\066\\001\\066\\001\\\n \\066\\001\\255\\255\\255\\255\\066\\001\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\242\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\066\\001\\112\\001\\255\\255\\112\\001\\255\\255\\066\\001\\112\\001\\112\\001\\\n \\112\\001\\112\\001\\112\\001\\112\\001\\112\\001\\112\\001\\112\\001\\112\\001\\\n \\255\\255\\255\\255\\066\\001\\114\\001\\114\\001\\114\\001\\114\\001\\114\\001\\\n \\114\\001\\114\\001\\114\\001\\114\\001\\114\\001\\066\\001\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\066\\001\\255\\255\\255\\255\\\n \\114\\001\\255\\255\\255\\255\\066\\001\\255\\255\\255\\255\\115\\001\\255\\255\\\n \\115\\001\\255\\255\\066\\001\\115\\001\\115\\001\\115\\001\\115\\001\\115\\001\\\n \\115\\001\\115\\001\\115\\001\\115\\001\\115\\001\\116\\001\\116\\001\\116\\001\\\n \\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\255\\255\\\n \\114\\001\\117\\001\\117\\001\\117\\001\\117\\001\\117\\001\\117\\001\\117\\001\\\n \\117\\001\\117\\001\\117\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\\n \\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\119\\001\\119\\001\\119\\001\\\n \\119\\001\\119\\001\\119\\001\\119\\001\\119\\001\\119\\001\\119\\001\\255\\255\\\n \\126\\001\\127\\001\\127\\001\\127\\001\\127\\001\\127\\001\\127\\001\\127\\001\\\n \\127\\001\\127\\001\\127\\001\\255\\255\\255\\255\\126\\001\\255\\255\\255\\255\\\n \\255\\255\\129\\001\\127\\001\\127\\001\\127\\001\\127\\001\\127\\001\\127\\001\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\129\\001\\255\\255\\\n \\255\\255\\155\\001\\255\\255\\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\\n \\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\127\\001\\127\\001\\127\\001\\127\\001\\127\\001\\127\\001\\\n \\155\\001\\255\\255\\126\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\126\\001\\255\\255\\255\\255\\255\\255\\126\\001\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\129\\001\\126\\001\\255\\255\\255\\255\\066\\001\\\n \\126\\001\\129\\001\\126\\001\\126\\001\\255\\255\\129\\001\\255\\255\\255\\255\\\n \\155\\001\\255\\255\\255\\255\\255\\255\\255\\255\\129\\001\\255\\255\\255\\255\\\n \\255\\255\\129\\001\\255\\255\\129\\001\\129\\001\\130\\001\\130\\001\\130\\001\\\n \\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\130\\001\\130\\001\\\n \\130\\001\\130\\001\\130\\001\\130\\001\\131\\001\\131\\001\\131\\001\\131\\001\\\n \\131\\001\\131\\001\\131\\001\\131\\001\\131\\001\\131\\001\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\131\\001\\131\\001\\131\\001\\\n \\131\\001\\131\\001\\131\\001\\255\\255\\255\\255\\255\\255\\130\\001\\130\\001\\\n \\130\\001\\130\\001\\130\\001\\130\\001\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\132\\001\\132\\001\\132\\001\\132\\001\\132\\001\\132\\001\\\n \\132\\001\\132\\001\\132\\001\\132\\001\\255\\255\\131\\001\\131\\001\\131\\001\\\n \\131\\001\\131\\001\\131\\001\\132\\001\\132\\001\\132\\001\\132\\001\\132\\001\\\n \\132\\001\\184\\001\\138\\001\\184\\001\\255\\255\\255\\255\\184\\001\\184\\001\\\n \\184\\001\\184\\001\\184\\001\\184\\001\\184\\001\\184\\001\\184\\001\\184\\001\\\n \\185\\001\\185\\001\\185\\001\\185\\001\\185\\001\\185\\001\\185\\001\\185\\001\\\n \\185\\001\\185\\001\\255\\255\\132\\001\\132\\001\\132\\001\\132\\001\\132\\001\\\n \\132\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\\n \\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\\n \\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\\n \\138\\001\\138\\001\\138\\001\\255\\255\\255\\255\\255\\255\\255\\255\\138\\001\\\n \\255\\255\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\\n \\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\\n \\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\\n \\138\\001\\138\\001\\138\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\141\\001\\255\\255\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\143\\001\\143\\001\\\n \\255\\255\\255\\255\\143\\001\\156\\001\\156\\001\\156\\001\\156\\001\\156\\001\\\n \\156\\001\\156\\001\\156\\001\\156\\001\\156\\001\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\198\\001\\143\\001\\255\\255\\143\\001\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\156\\001\\143\\001\\255\\255\\255\\255\\\n \\255\\255\\198\\001\\143\\001\\255\\255\\143\\001\\143\\001\\143\\001\\143\\001\\\n \\143\\001\\143\\001\\143\\001\\143\\001\\143\\001\\143\\001\\143\\001\\255\\255\\\n \\255\\255\\143\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\138\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\143\\001\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\143\\001\\186\\001\\186\\001\\186\\001\\186\\001\\\n \\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\198\\001\\255\\255\\\n \\143\\001\\255\\255\\255\\255\\255\\255\\198\\001\\255\\255\\255\\255\\255\\255\\\n \\198\\001\\186\\001\\255\\255\\143\\001\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\198\\001\\255\\255\\255\\255\\143\\001\\198\\001\\255\\255\\198\\001\\198\\001\\\n \\255\\255\\143\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\143\\001\\255\\255\\255\\255\\255\\255\\255\\255\\187\\001\\255\\255\\187\\001\\\n \\255\\255\\186\\001\\187\\001\\187\\001\\187\\001\\187\\001\\187\\001\\187\\001\\\n \\187\\001\\187\\001\\187\\001\\187\\001\\188\\001\\188\\001\\188\\001\\188\\001\\\n \\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\189\\001\\189\\001\\\n \\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\\n \\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\\n \\190\\001\\190\\001\\191\\001\\191\\001\\191\\001\\191\\001\\191\\001\\191\\001\\\n \\191\\001\\191\\001\\191\\001\\191\\001\\199\\001\\199\\001\\199\\001\\199\\001\\\n \\199\\001\\199\\001\\199\\001\\199\\001\\199\\001\\199\\001\\201\\001\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\199\\001\\199\\001\\199\\001\\\n \\199\\001\\199\\001\\199\\001\\201\\001\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\199\\001\\199\\001\\199\\001\\\n \\199\\001\\199\\001\\199\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\201\\001\\255\\255\\255\\255\\255\\255\\255\\255\\143\\001\\201\\001\\255\\255\\\n \\255\\255\\255\\255\\201\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\201\\001\\255\\255\\255\\255\\255\\255\\201\\001\\255\\255\\\n \\201\\001\\201\\001\\202\\001\\202\\001\\202\\001\\202\\001\\202\\001\\202\\001\\\n \\202\\001\\202\\001\\202\\001\\202\\001\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\202\\001\\202\\001\\202\\001\\202\\001\\202\\001\\\n \\202\\001\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\\n \\203\\001\\203\\001\\203\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\\n \\255\\255\\255\\255\\255\\255\\202\\001\\202\\001\\202\\001\\202\\001\\202\\001\\\n \\202\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\204\\001\\\n \\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\\n \\204\\001\\255\\255\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\\n \\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\255\\255\\210\\001\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\210\\001\\210\\001\\\n \\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\\n \\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\\n \\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\210\\001\\255\\255\\210\\001\\210\\001\\\n \\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\\n \\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\\n \\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\255\\255\\255\\255\\255\\255\\255\\255\\213\\001\\\n \\255\\255\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\210\\001\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\";\n Lexing.lex_base_code =\n \"\";\n Lexing.lex_backtrk_code =\n \"\";\n Lexing.lex_default_code =\n \"\";\n Lexing.lex_trans_code =\n \"\";\n Lexing.lex_check_code =\n \"\";\n Lexing.lex_code =\n \"\";\n}\n\nlet rec read_json v lexbuf =\n __ocaml_lex_read_json_rec v lexbuf 0\nand __ocaml_lex_read_json_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 188 \"lib/read.mll\"\n \n# 188 \"lib/read.mll\"\n ( `Bool true )\n\n# 1032 \"lib/read.ml\"\n\n \n# 1033 \"lib/read.ml\"\n | 1 ->\n\n# 189 \"lib/read.mll\"\n \n# 189 \"lib/read.mll\"\n ( `Bool false )\n\n# 1037 \"lib/read.ml\"\n\n \n# 1038 \"lib/read.ml\"\n | 2 ->\n\n# 190 \"lib/read.mll\"\n \n# 190 \"lib/read.mll\"\n ( `Null )\n\n# 1042 \"lib/read.ml\"\n\n \n# 1043 \"lib/read.ml\"\n | 3 ->\n\n# 191 \"lib/read.mll\"\n \n# 191 \"lib/read.mll\"\n (\n \n# 193 \"lib/read.mll\"\n `Float nan\n \n# 197 \"lib/read.mll\"\n )\n\n# 1053 \"lib/read.ml\"\n\n \n# 1054 \"lib/read.ml\"\n | 4 ->\n\n# 198 \"lib/read.mll\"\n \n# 198 \"lib/read.mll\"\n (\n \n# 200 \"lib/read.mll\"\n `Float infinity\n \n# 204 \"lib/read.mll\"\n )\n\n# 1064 \"lib/read.ml\"\n\n \n# 1065 \"lib/read.ml\"\n | 5 ->\n\n# 205 \"lib/read.mll\"\n \n# 205 \"lib/read.mll\"\n (\n \n# 207 \"lib/read.mll\"\n `Float neg_infinity\n \n# 211 \"lib/read.mll\"\n )\n\n# 1075 \"lib/read.ml\"\n\n \n# 1076 \"lib/read.ml\"\n | 6 ->\n\n# 212 \"lib/read.mll\"\n \n# 212 \"lib/read.mll\"\n (\n \n# 214 \"lib/read.mll\"\n Bi_outbuf.clear v.buf;\n `String (finish_string v lexbuf)\n \n# 219 \"lib/read.mll\"\n )\n\n# 1087 \"lib/read.ml\"\n\n \n# 1088 \"lib/read.ml\"\n | 7 ->\n\n# 220 \"lib/read.mll\"\n \n# 220 \"lib/read.mll\"\n ( make_positive_int v lexbuf )\n\n# 1092 \"lib/read.ml\"\n\n \n# 1093 \"lib/read.ml\"\n | 8 ->\n\n# 221 \"lib/read.mll\"\n \n# 221 \"lib/read.mll\"\n ( make_negative_int v lexbuf )\n\n# 1097 \"lib/read.ml\"\n\n \n# 1098 \"lib/read.ml\"\n | 9 ->\n\n# 222 \"lib/read.mll\"\n \n# 222 \"lib/read.mll\"\n (\n \n# 224 \"lib/read.mll\"\n `Float (float_of_string (lexeme lexbuf))\n \n# 228 \"lib/read.mll\"\n )\n\n# 1108 \"lib/read.ml\"\n\n \n# 1109 \"lib/read.ml\"\n | 10 ->\n\n# 230 \"lib/read.mll\"\n \n# 230 \"lib/read.mll\"\n ( let acc = ref [] in\n try\n read_space v lexbuf;\n read_object_end lexbuf;\n let field_name = read_ident v lexbuf in\n read_space v lexbuf;\n read_colon v lexbuf;\n read_space v lexbuf;\n acc := (field_name, read_json v lexbuf) :: !acc;\n while true do\n read_space v lexbuf;\n read_object_sep v lexbuf;\n read_space v lexbuf;\n let field_name = read_ident v lexbuf in\n read_space v lexbuf;\n read_colon v lexbuf;\n read_space v lexbuf;\n acc := (field_name, read_json v lexbuf) :: !acc;\n done;\n assert false\n with End_of_object ->\n `Assoc (List.rev !acc)\n )\n\n# 1135 \"lib/read.ml\"\n\n \n# 1136 \"lib/read.ml\"\n | 11 ->\n\n# 254 \"lib/read.mll\"\n \n# 254 \"lib/read.mll\"\n ( let acc = ref [] in\n try\n read_space v lexbuf;\n read_array_end lexbuf;\n acc := read_json v lexbuf :: !acc;\n while true do\n read_space v lexbuf;\n read_array_sep v lexbuf;\n read_space v lexbuf;\n acc := read_json v lexbuf :: !acc;\n done;\n assert false\n with End_of_array ->\n `List (List.rev !acc)\n )\n\n# 1154 \"lib/read.ml\"\n\n \n# 1155 \"lib/read.ml\"\n | 12 ->\n\n# 270 \"lib/read.mll\"\n \n# 270 \"lib/read.mll\"\n (\n \n# 287 \"lib/read.mll\"\n long_error \"Invalid token\" v lexbuf\n \n# 289 \"lib/read.mll\"\n )\n\n# 1178 \"lib/read.ml\"\n\n \n# 1179 \"lib/read.ml\"\n | 13 ->\n\n# 291 \"lib/read.mll\"\n \n# 291 \"lib/read.mll\"\n (\n \n# 298 \"lib/read.mll\"\n long_error \"Invalid token\" v lexbuf\n \n# 300 \"lib/read.mll\"\n )\n\n# 1192 \"lib/read.ml\"\n\n \n# 1193 \"lib/read.ml\"\n | 14 ->\n\n# 302 \"lib/read.mll\"\n \n# 302 \"lib/read.mll\"\n ( read_json v lexbuf )\n\n# 1197 \"lib/read.ml\"\n\n \n# 1198 \"lib/read.ml\"\n | 15 ->\n\n# 303 \"lib/read.mll\"\n \n# 303 \"lib/read.mll\"\n ( finish_comment v lexbuf; read_json v lexbuf )\n\n# 1202 \"lib/read.ml\"\n\n \n# 1203 \"lib/read.ml\"\n | 16 ->\n\n# 304 \"lib/read.mll\"\n \n# 304 \"lib/read.mll\"\n ( newline v lexbuf; read_json v lexbuf )\n\n# 1207 \"lib/read.ml\"\n\n \n# 1208 \"lib/read.ml\"\n | 17 ->\n\n# 305 \"lib/read.mll\"\n \n# 305 \"lib/read.mll\"\n ( read_json v lexbuf )\n\n# 1212 \"lib/read.ml\"\n\n \n# 1213 \"lib/read.ml\"\n | 18 ->\n\n# 306 \"lib/read.mll\"\n \n# 306 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1217 \"lib/read.ml\"\n\n \n# 1218 \"lib/read.ml\"\n | 19 ->\n\n# 307 \"lib/read.mll\"\n \n# 307 \"lib/read.mll\"\n ( long_error \"Invalid token\" v lexbuf )\n\n# 1222 \"lib/read.ml\"\n\n \n# 1223 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_json_rec v lexbuf __ocaml_lex_state\n\nand finish_string v lexbuf =\n __ocaml_lex_finish_string_rec v lexbuf 58\nand __ocaml_lex_finish_string_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 311 \"lib/read.mll\"\n \n# 311 \"lib/read.mll\"\n ( Bi_outbuf.contents v.buf )\n\n# 1234 \"lib/read.ml\"\n\n \n# 1235 \"lib/read.ml\"\n | 1 ->\n\n# 312 \"lib/read.mll\"\n \n# 312 \"lib/read.mll\"\n ( finish_escaped_char v lexbuf;\n finish_string v lexbuf )\n\n# 1240 \"lib/read.ml\"\n\n \n# 1241 \"lib/read.ml\"\n | 2 ->\n\n# 314 \"lib/read.mll\"\n \n# 314 \"lib/read.mll\"\n ( add_lexeme v.buf lexbuf;\n finish_string v lexbuf )\n\n# 1246 \"lib/read.ml\"\n\n \n# 1247 \"lib/read.ml\"\n | 3 ->\n\n# 316 \"lib/read.mll\"\n \n# 316 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1251 \"lib/read.ml\"\n\n \n# 1252 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_string_rec v lexbuf __ocaml_lex_state\n\nand map_string v f lexbuf =\n __ocaml_lex_map_string_rec v f lexbuf 63\nand __ocaml_lex_map_string_rec v f lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 319 \"lib/read.mll\"\n \n# 319 \"lib/read.mll\"\n ( let b = v.buf in\n f (Bytes.to_string b.Bi_outbuf.o_s) 0 b.Bi_outbuf.o_len )\n\n# 1264 \"lib/read.ml\"\n\n \n# 1265 \"lib/read.ml\"\n | 1 ->\n\n# 321 \"lib/read.mll\"\n \n# 321 \"lib/read.mll\"\n ( finish_escaped_char v lexbuf;\n map_string v f lexbuf )\n\n# 1270 \"lib/read.ml\"\n\n \n# 1271 \"lib/read.ml\"\n | 2 ->\n\n# 323 \"lib/read.mll\"\n \n# 323 \"lib/read.mll\"\n ( add_lexeme v.buf lexbuf;\n map_string v f lexbuf )\n\n# 1276 \"lib/read.ml\"\n\n \n# 1277 \"lib/read.ml\"\n | 3 ->\n\n# 325 \"lib/read.mll\"\n \n# 325 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1281 \"lib/read.ml\"\n\n \n# 1282 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_map_string_rec v f lexbuf __ocaml_lex_state\n\nand finish_escaped_char v lexbuf =\n __ocaml_lex_finish_escaped_char_rec v lexbuf 68\nand __ocaml_lex_finish_escaped_char_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\nlet\n\n# 330 \"lib/read.mll\"\n \n# 330 \"lib/read.mll\"\n c\n\n# 1294 \"lib/read.ml\"\n# 1294 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf lexbuf.Lexing.lex_start_pos in\n\n# 330 \"lib/read.mll\"\n \n# 330 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf c )\n\n# 1298 \"lib/read.ml\"\n\n \n# 1299 \"lib/read.ml\"\n | 1 ->\n\n# 331 \"lib/read.mll\"\n \n# 331 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\\b' )\n\n# 1303 \"lib/read.ml\"\n\n \n# 1304 \"lib/read.ml\"\n | 2 ->\n\n# 332 \"lib/read.mll\"\n \n# 332 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\\012' )\n\n# 1308 \"lib/read.ml\"\n\n \n# 1309 \"lib/read.ml\"\n | 3 ->\n\n# 333 \"lib/read.mll\"\n \n# 333 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\\n' )\n\n# 1313 \"lib/read.ml\"\n\n \n# 1314 \"lib/read.ml\"\n | 4 ->\n\n# 334 \"lib/read.mll\"\n \n# 334 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\\r' )\n\n# 1318 \"lib/read.ml\"\n\n \n# 1319 \"lib/read.ml\"\n | 5 ->\n\n# 335 \"lib/read.mll\"\n \n# 335 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\\t' )\n\n# 1323 \"lib/read.ml\"\n\n \n# 1324 \"lib/read.ml\"\n | 6 ->\nlet\n\n# 336 \"lib/read.mll\"\n \n# 336 \"lib/read.mll\"\n a\n\n# 1329 \"lib/read.ml\"\n# 1329 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 1)\nand\n\n# 336 \"lib/read.mll\"\n \n# 336 \"lib/read.mll\"\n b\n\n# 1334 \"lib/read.ml\"\n# 1334 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 2)\nand\n\n# 336 \"lib/read.mll\"\n \n# 336 \"lib/read.mll\"\n c\n\n# 1339 \"lib/read.ml\"\n# 1339 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 3)\nand\n\n# 336 \"lib/read.mll\"\n \n# 336 \"lib/read.mll\"\n d\n\n# 1344 \"lib/read.ml\"\n# 1344 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 4) in\n\n# 337 \"lib/read.mll\"\n \n# 337 \"lib/read.mll\"\n ( let x =\n (hex a lsl 12) lor (hex b lsl 8) lor (hex c lsl 4) lor hex d\n in\n if x >= 0xD800 && x <= 0xDBFF then\n finish_surrogate_pair v x lexbuf\n else\n utf8_of_code v.buf x\n )\n\n# 1355 \"lib/read.ml\"\n\n \n# 1356 \"lib/read.ml\"\n | 7 ->\n\n# 345 \"lib/read.mll\"\n \n# 345 \"lib/read.mll\"\n ( long_error \"Invalid escape sequence\" v lexbuf )\n\n# 1360 \"lib/read.ml\"\n\n \n# 1361 \"lib/read.ml\"\n | 8 ->\n\n# 346 \"lib/read.mll\"\n \n# 346 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1365 \"lib/read.ml\"\n\n \n# 1366 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_escaped_char_rec v lexbuf __ocaml_lex_state\n\nand finish_surrogate_pair v x lexbuf =\n __ocaml_lex_finish_surrogate_pair_rec v x lexbuf 82\nand __ocaml_lex_finish_surrogate_pair_rec v x lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\nlet\n\n# 349 \"lib/read.mll\"\n \n# 349 \"lib/read.mll\"\n a\n\n# 1378 \"lib/read.ml\"\n# 1378 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 2)\nand\n\n# 349 \"lib/read.mll\"\n \n# 349 \"lib/read.mll\"\n b\n\n# 1383 \"lib/read.ml\"\n# 1383 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 3)\nand\n\n# 349 \"lib/read.mll\"\n \n# 349 \"lib/read.mll\"\n c\n\n# 1388 \"lib/read.ml\"\n# 1388 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 4)\nand\n\n# 349 \"lib/read.mll\"\n \n# 349 \"lib/read.mll\"\n d\n\n# 1393 \"lib/read.ml\"\n# 1393 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 5) in\n\n# 350 \"lib/read.mll\"\n \n# 350 \"lib/read.mll\"\n ( let y =\n (hex a lsl 12) lor (hex b lsl 8) lor (hex c lsl 4) lor hex d\n in\n if y >= 0xDC00 && y <= 0xDFFF then\n utf8_of_surrogate_pair v.buf x y\n else\n long_error \"Invalid low surrogate for code point beyond U+FFFF\"\n v lexbuf\n )\n\n# 1405 \"lib/read.ml\"\n\n \n# 1406 \"lib/read.ml\"\n | 1 ->\n\n# 359 \"lib/read.mll\"\n \n# 359 \"lib/read.mll\"\n ( long_error \"Missing escape sequence representing low surrogate \\\n for code point beyond U+FFFF\" v lexbuf )\n\n# 1411 \"lib/read.ml\"\n\n \n# 1412 \"lib/read.ml\"\n | 2 ->\n\n# 361 \"lib/read.mll\"\n \n# 361 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1416 \"lib/read.ml\"\n\n \n# 1417 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_surrogate_pair_rec v x lexbuf __ocaml_lex_state\n\nand finish_stringlit v lexbuf =\n __ocaml_lex_finish_stringlit_rec v lexbuf 91\nand __ocaml_lex_finish_stringlit_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 366 \"lib/read.mll\"\n \n# 366 \"lib/read.mll\"\n ( let len = lexbuf.lex_curr_pos - lexbuf.lex_start_pos in\n let s = Bytes.create (len+1) in\n Bytes.set s 0 '\"';\n Bytes.blit lexbuf.lex_buffer lexbuf.lex_start_pos s 1 len;\n Bytes.to_string s\n )\n\n# 1433 \"lib/read.ml\"\n\n \n# 1434 \"lib/read.ml\"\n | 1 ->\n\n# 372 \"lib/read.mll\"\n \n# 372 \"lib/read.mll\"\n ( long_error \"Invalid string literal\" v lexbuf )\n\n# 1438 \"lib/read.ml\"\n\n \n# 1439 \"lib/read.ml\"\n | 2 ->\n\n# 373 \"lib/read.mll\"\n \n# 373 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1443 \"lib/read.ml\"\n\n \n# 1444 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_stringlit_rec v lexbuf __ocaml_lex_state\n\nand finish_variant v lexbuf =\n __ocaml_lex_finish_variant_rec v lexbuf 102\nand __ocaml_lex_finish_variant_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 376 \"lib/read.mll\"\n \n# 376 \"lib/read.mll\"\n ( let x = read_json v lexbuf in\n read_space v lexbuf;\n read_gt v lexbuf;\n Some x )\n\n# 1458 \"lib/read.ml\"\n\n \n# 1459 \"lib/read.ml\"\n | 1 ->\n\n# 380 \"lib/read.mll\"\n \n# 380 \"lib/read.mll\"\n ( None )\n\n# 1463 \"lib/read.ml\"\n\n \n# 1464 \"lib/read.ml\"\n | 2 ->\n\n# 381 \"lib/read.mll\"\n \n# 381 \"lib/read.mll\"\n ( long_error \"Expected ':' or '>' but found\" v lexbuf )\n\n# 1468 \"lib/read.ml\"\n\n \n# 1469 \"lib/read.ml\"\n | 3 ->\n\n# 382 \"lib/read.mll\"\n \n# 382 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1473 \"lib/read.ml\"\n\n \n# 1474 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_variant_rec v lexbuf __ocaml_lex_state\n\nand read_lt v lexbuf =\n __ocaml_lex_read_lt_rec v lexbuf 107\nand __ocaml_lex_read_lt_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 385 \"lib/read.mll\"\n \n# 385 \"lib/read.mll\"\n ( () )\n\n# 1485 \"lib/read.ml\"\n\n \n# 1486 \"lib/read.ml\"\n | 1 ->\n\n# 386 \"lib/read.mll\"\n \n# 386 \"lib/read.mll\"\n ( long_error \"Expected '<' but found\" v lexbuf )\n\n# 1490 \"lib/read.ml\"\n\n \n# 1491 \"lib/read.ml\"\n | 2 ->\n\n# 387 \"lib/read.mll\"\n \n# 387 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1495 \"lib/read.ml\"\n\n \n# 1496 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_lt_rec v lexbuf __ocaml_lex_state\n\nand read_gt v lexbuf =\n __ocaml_lex_read_gt_rec v lexbuf 111\nand __ocaml_lex_read_gt_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 390 \"lib/read.mll\"\n \n# 390 \"lib/read.mll\"\n ( () )\n\n# 1507 \"lib/read.ml\"\n\n \n# 1508 \"lib/read.ml\"\n | 1 ->\n\n# 391 \"lib/read.mll\"\n \n# 391 \"lib/read.mll\"\n ( long_error \"Expected '>' but found\" v lexbuf )\n\n# 1512 \"lib/read.ml\"\n\n \n# 1513 \"lib/read.ml\"\n | 2 ->\n\n# 392 \"lib/read.mll\"\n \n# 392 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1517 \"lib/read.ml\"\n\n \n# 1518 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_gt_rec v lexbuf __ocaml_lex_state\n\nand read_comma v lexbuf =\n __ocaml_lex_read_comma_rec v lexbuf 115\nand __ocaml_lex_read_comma_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 395 \"lib/read.mll\"\n \n# 395 \"lib/read.mll\"\n ( () )\n\n# 1529 \"lib/read.ml\"\n\n \n# 1530 \"lib/read.ml\"\n | 1 ->\n\n# 396 \"lib/read.mll\"\n \n# 396 \"lib/read.mll\"\n ( long_error \"Expected ',' but found\" v lexbuf )\n\n# 1534 \"lib/read.ml\"\n\n \n# 1535 \"lib/read.ml\"\n | 2 ->\n\n# 397 \"lib/read.mll\"\n \n# 397 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1539 \"lib/read.ml\"\n\n \n# 1540 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_comma_rec v lexbuf __ocaml_lex_state\n\nand start_any_variant v lexbuf =\n __ocaml_lex_start_any_variant_rec v lexbuf 119\nand __ocaml_lex_start_any_variant_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 400 \"lib/read.mll\"\n \n# 400 \"lib/read.mll\"\n ( `Edgy_bracket )\n\n# 1551 \"lib/read.ml\"\n\n \n# 1552 \"lib/read.ml\"\n | 1 ->\n\n# 401 \"lib/read.mll\"\n \n# 401 \"lib/read.mll\"\n ( Bi_outbuf.clear v.buf;\n `Double_quote )\n\n# 1557 \"lib/read.ml\"\n\n \n# 1558 \"lib/read.ml\"\n | 2 ->\n\n# 403 \"lib/read.mll\"\n \n# 403 \"lib/read.mll\"\n ( `Square_bracket )\n\n# 1562 \"lib/read.ml\"\n\n \n# 1563 \"lib/read.ml\"\n | 3 ->\n\n# 404 \"lib/read.mll\"\n \n# 404 \"lib/read.mll\"\n ( long_error \"Expected '<', '\\\"' or '[' but found\" v lexbuf )\n\n# 1567 \"lib/read.ml\"\n\n \n# 1568 \"lib/read.ml\"\n | 4 ->\n\n# 405 \"lib/read.mll\"\n \n# 405 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1572 \"lib/read.ml\"\n\n \n# 1573 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_start_any_variant_rec v lexbuf __ocaml_lex_state\n\nand finish_comment v lexbuf =\n __ocaml_lex_finish_comment_rec v lexbuf 125\nand __ocaml_lex_finish_comment_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 408 \"lib/read.mll\"\n \n# 408 \"lib/read.mll\"\n ( () )\n\n# 1584 \"lib/read.ml\"\n\n \n# 1585 \"lib/read.ml\"\n | 1 ->\n\n# 409 \"lib/read.mll\"\n \n# 409 \"lib/read.mll\"\n ( long_error \"Unterminated comment\" v lexbuf )\n\n# 1589 \"lib/read.ml\"\n\n \n# 1590 \"lib/read.ml\"\n | 2 ->\n\n# 410 \"lib/read.mll\"\n \n# 410 \"lib/read.mll\"\n ( newline v lexbuf; finish_comment v lexbuf )\n\n# 1594 \"lib/read.ml\"\n\n \n# 1595 \"lib/read.ml\"\n | 3 ->\n\n# 411 \"lib/read.mll\"\n \n# 411 \"lib/read.mll\"\n ( finish_comment v lexbuf )\n\n# 1599 \"lib/read.ml\"\n\n \n# 1600 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_comment_rec v lexbuf __ocaml_lex_state\n\nand read_eof lexbuf =\n __ocaml_lex_read_eof_rec lexbuf 131\nand __ocaml_lex_read_eof_rec lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 419 \"lib/read.mll\"\n \n# 419 \"lib/read.mll\"\n ( true )\n\n# 1611 \"lib/read.ml\"\n\n \n# 1612 \"lib/read.ml\"\n | 1 ->\n\n# 420 \"lib/read.mll\"\n \n# 420 \"lib/read.mll\"\n ( false )\n\n# 1616 \"lib/read.ml\"\n\n \n# 1617 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_eof_rec lexbuf __ocaml_lex_state\n\nand read_space v lexbuf =\n __ocaml_lex_read_space_rec v lexbuf 133\nand __ocaml_lex_read_space_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 423 \"lib/read.mll\"\n \n# 423 \"lib/read.mll\"\n ( newline v lexbuf; read_space v lexbuf )\n\n# 1628 \"lib/read.ml\"\n\n \n# 1629 \"lib/read.ml\"\n | 1 ->\n\n# 424 \"lib/read.mll\"\n \n# 424 \"lib/read.mll\"\n ( finish_comment v lexbuf; read_space v lexbuf )\n\n# 1633 \"lib/read.ml\"\n\n \n# 1634 \"lib/read.ml\"\n | 2 ->\n\n# 425 \"lib/read.mll\"\n \n# 425 \"lib/read.mll\"\n ( newline v lexbuf; read_space v lexbuf )\n\n# 1638 \"lib/read.ml\"\n\n \n# 1639 \"lib/read.ml\"\n | 3 ->\n\n# 426 \"lib/read.mll\"\n \n# 426 \"lib/read.mll\"\n ( read_space v lexbuf )\n\n# 1643 \"lib/read.ml\"\n\n \n# 1644 \"lib/read.ml\"\n | 4 ->\n\n# 427 \"lib/read.mll\"\n \n# 427 \"lib/read.mll\"\n ( () )\n\n# 1648 \"lib/read.ml\"\n\n \n# 1649 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_space_rec v lexbuf __ocaml_lex_state\n\nand read_null v lexbuf =\n __ocaml_lex_read_null_rec v lexbuf 140\nand __ocaml_lex_read_null_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 430 \"lib/read.mll\"\n \n# 430 \"lib/read.mll\"\n ( () )\n\n# 1660 \"lib/read.ml\"\n\n \n# 1661 \"lib/read.ml\"\n | 1 ->\n\n# 431 \"lib/read.mll\"\n \n# 431 \"lib/read.mll\"\n ( long_error \"Expected 'null' but found\" v lexbuf )\n\n# 1665 \"lib/read.ml\"\n\n \n# 1666 \"lib/read.ml\"\n | 2 ->\n\n# 432 \"lib/read.mll\"\n \n# 432 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1670 \"lib/read.ml\"\n\n \n# 1671 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_null_rec v lexbuf __ocaml_lex_state\n\nand read_null_if_possible v lexbuf =\n __ocaml_lex_read_null_if_possible_rec v lexbuf 147\nand __ocaml_lex_read_null_if_possible_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 435 \"lib/read.mll\"\n \n# 435 \"lib/read.mll\"\n ( true )\n\n# 1682 \"lib/read.ml\"\n\n \n# 1683 \"lib/read.ml\"\n | 1 ->\n\n# 436 \"lib/read.mll\"\n \n# 436 \"lib/read.mll\"\n ( false )\n\n# 1687 \"lib/read.ml\"\n\n \n# 1688 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_null_if_possible_rec v lexbuf __ocaml_lex_state\n\nand read_bool v lexbuf =\n __ocaml_lex_read_bool_rec v lexbuf 152\nand __ocaml_lex_read_bool_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 439 \"lib/read.mll\"\n \n# 439 \"lib/read.mll\"\n ( true )\n\n# 1699 \"lib/read.ml\"\n\n \n# 1700 \"lib/read.ml\"\n | 1 ->\n\n# 440 \"lib/read.mll\"\n \n# 440 \"lib/read.mll\"\n ( false )\n\n# 1704 \"lib/read.ml\"\n\n \n# 1705 \"lib/read.ml\"\n | 2 ->\n\n# 443 \"lib/read.mll\"\n \n# 443 \"lib/read.mll\"\n ( true )\n\n# 1709 \"lib/read.ml\"\n\n \n# 1710 \"lib/read.ml\"\n | 3 ->\n\n# 444 \"lib/read.mll\"\n \n# 444 \"lib/read.mll\"\n ( false )\n\n# 1714 \"lib/read.ml\"\n\n \n# 1715 \"lib/read.ml\"\n | 4 ->\n\n# 446 \"lib/read.mll\"\n \n# 446 \"lib/read.mll\"\n ( long_error \"Expected 'true' or 'false' but found\" v lexbuf )\n\n# 1719 \"lib/read.ml\"\n\n \n# 1720 \"lib/read.ml\"\n | 5 ->\n\n# 447 \"lib/read.mll\"\n \n# 447 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1724 \"lib/read.ml\"\n\n \n# 1725 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_bool_rec v lexbuf __ocaml_lex_state\n\nand read_int v lexbuf =\n __ocaml_lex_read_int_rec v lexbuf 176\nand __ocaml_lex_read_int_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 450 \"lib/read.mll\"\n \n# 450 \"lib/read.mll\"\n ( try extract_positive_int lexbuf\n with Int_overflow ->\n lexer_error \"Int overflow\" v lexbuf )\n\n# 1738 \"lib/read.ml\"\n\n \n# 1739 \"lib/read.ml\"\n | 1 ->\n\n# 453 \"lib/read.mll\"\n \n# 453 \"lib/read.mll\"\n ( try extract_negative_int lexbuf\n with Int_overflow ->\n lexer_error \"Int overflow\" v lexbuf )\n\n# 1745 \"lib/read.ml\"\n\n \n# 1746 \"lib/read.ml\"\n | 2 ->\n\n# 456 \"lib/read.mll\"\n \n# 456 \"lib/read.mll\"\n ( (* Support for double-quoted \"ints\" *)\n Bi_outbuf.clear v.buf;\n let s = finish_string v lexbuf in\n try\n (* Any OCaml-compliant int will pass,\n including hexadecimal and octal notations,\n and embedded underscores *)\n int_of_string s\n with _ ->\n custom_error\n \"Expected an integer but found a string that \\\n doesn't even represent an integer\"\n v lexbuf\n )\n\n# 1763 \"lib/read.ml\"\n\n \n# 1764 \"lib/read.ml\"\n | 3 ->\n\n# 470 \"lib/read.mll\"\n \n# 470 \"lib/read.mll\"\n ( long_error \"Expected integer but found\" v lexbuf )\n\n# 1768 \"lib/read.ml\"\n\n \n# 1769 \"lib/read.ml\"\n | 4 ->\n\n# 471 \"lib/read.mll\"\n \n# 471 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1773 \"lib/read.ml\"\n\n \n# 1774 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_int_rec v lexbuf __ocaml_lex_state\n\nand read_int32 v lexbuf =\n __ocaml_lex_read_int32_rec v lexbuf 185\nand __ocaml_lex_read_int32_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 474 \"lib/read.mll\"\n \n# 474 \"lib/read.mll\"\n ( try Int32.of_string (Lexing.lexeme lexbuf)\n with _ ->\n lexer_error \"Int32 overflow\" v lexbuf )\n\n# 1787 \"lib/read.ml\"\n\n \n# 1788 \"lib/read.ml\"\n | 1 ->\n\n# 477 \"lib/read.mll\"\n \n# 477 \"lib/read.mll\"\n ( (* Support for double-quoted \"ints\" *)\n Bi_outbuf.clear v.buf;\n let s = finish_string v lexbuf in\n try\n (* Any OCaml-compliant int will pass,\n including hexadecimal and octal notations,\n and embedded underscores *)\n Int32.of_string s\n with _ ->\n custom_error\n \"Expected an int32 but found a string that \\\n doesn't even represent an integer\"\n v lexbuf\n )\n\n# 1805 \"lib/read.ml\"\n\n \n# 1806 \"lib/read.ml\"\n | 2 ->\n\n# 491 \"lib/read.mll\"\n \n# 491 \"lib/read.mll\"\n ( long_error \"Expected int32 but found\" v lexbuf )\n\n# 1810 \"lib/read.ml\"\n\n \n# 1811 \"lib/read.ml\"\n | 3 ->\n\n# 492 \"lib/read.mll\"\n \n# 492 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1815 \"lib/read.ml\"\n\n \n# 1816 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_int32_rec v lexbuf __ocaml_lex_state\n\nand read_int64 v lexbuf =\n __ocaml_lex_read_int64_rec v lexbuf 192\nand __ocaml_lex_read_int64_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 495 \"lib/read.mll\"\n \n# 495 \"lib/read.mll\"\n ( try Int64.of_string (Lexing.lexeme lexbuf)\n with _ ->\n lexer_error \"Int32 overflow\" v lexbuf )\n\n# 1829 \"lib/read.ml\"\n\n \n# 1830 \"lib/read.ml\"\n | 1 ->\n\n# 498 \"lib/read.mll\"\n \n# 498 \"lib/read.mll\"\n ( (* Support for double-quoted \"ints\" *)\n Bi_outbuf.clear v.buf;\n let s = finish_string v lexbuf in\n try\n (* Any OCaml-compliant int will pass,\n including hexadecimal and octal notations,\n and embedded underscores *)\n Int64.of_string s\n with _ ->\n custom_error\n \"Expected an int64 but found a string that \\\n doesn't even represent an integer\"\n v lexbuf\n )\n\n# 1847 \"lib/read.ml\"\n\n \n# 1848 \"lib/read.ml\"\n | 2 ->\n\n# 512 \"lib/read.mll\"\n \n# 512 \"lib/read.mll\"\n ( long_error \"Expected int64 but found\" v lexbuf )\n\n# 1852 \"lib/read.ml\"\n\n \n# 1853 \"lib/read.ml\"\n | 3 ->\n\n# 513 \"lib/read.mll\"\n \n# 513 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1857 \"lib/read.ml\"\n\n \n# 1858 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_int64_rec v lexbuf __ocaml_lex_state\n\nand read_number v lexbuf =\n __ocaml_lex_read_number_rec v lexbuf 199\nand __ocaml_lex_read_number_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 516 \"lib/read.mll\"\n \n# 516 \"lib/read.mll\"\n ( nan )\n\n# 1869 \"lib/read.ml\"\n\n \n# 1870 \"lib/read.ml\"\n | 1 ->\n\n# 517 \"lib/read.mll\"\n \n# 517 \"lib/read.mll\"\n ( infinity )\n\n# 1874 \"lib/read.ml\"\n\n \n# 1875 \"lib/read.ml\"\n | 2 ->\n\n# 518 \"lib/read.mll\"\n \n# 518 \"lib/read.mll\"\n ( neg_infinity )\n\n# 1879 \"lib/read.ml\"\n\n \n# 1880 \"lib/read.ml\"\n | 3 ->\n\n# 519 \"lib/read.mll\"\n \n# 519 \"lib/read.mll\"\n ( float_of_string (lexeme lexbuf) )\n\n# 1884 \"lib/read.ml\"\n\n \n# 1885 \"lib/read.ml\"\n | 4 ->\n\n# 520 \"lib/read.mll\"\n \n# 520 \"lib/read.mll\"\n ( Bi_outbuf.clear v.buf;\n let s = finish_string v lexbuf in\n try\n (* Any OCaml-compliant float will pass,\n including hexadecimal and octal notations,\n and embedded underscores. *)\n float_of_string s\n with _ ->\n match s with\n \"NaN\" -> nan\n | \"Infinity\" -> infinity\n | \"-Infinity\" -> neg_infinity\n | _ ->\n custom_error\n \"Expected a number but found a string that \\\n doesn't even represent a number\"\n v lexbuf\n )\n\n# 1906 \"lib/read.ml\"\n\n \n# 1907 \"lib/read.ml\"\n | 5 ->\n\n# 538 \"lib/read.mll\"\n \n# 538 \"lib/read.mll\"\n ( long_error \"Expected number but found\" v lexbuf )\n\n# 1911 \"lib/read.ml\"\n\n \n# 1912 \"lib/read.ml\"\n | 6 ->\n\n# 539 \"lib/read.mll\"\n \n# 539 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1916 \"lib/read.ml\"\n\n \n# 1917 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_number_rec v lexbuf __ocaml_lex_state\n\nand read_string v lexbuf =\n __ocaml_lex_read_string_rec v lexbuf 233\nand __ocaml_lex_read_string_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 542 \"lib/read.mll\"\n \n# 542 \"lib/read.mll\"\n ( Bi_outbuf.clear v.buf;\n finish_string v lexbuf )\n\n# 1929 \"lib/read.ml\"\n\n \n# 1930 \"lib/read.ml\"\n | 1 ->\n\n# 544 \"lib/read.mll\"\n \n# 544 \"lib/read.mll\"\n ( long_error \"Expected '\\\"' but found\" v lexbuf )\n\n# 1934 \"lib/read.ml\"\n\n \n# 1935 \"lib/read.ml\"\n | 2 ->\n\n# 545 \"lib/read.mll\"\n \n# 545 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1939 \"lib/read.ml\"\n\n \n# 1940 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_string_rec v lexbuf __ocaml_lex_state\n\nand read_ident v lexbuf =\n __ocaml_lex_read_ident_rec v lexbuf 237\nand __ocaml_lex_read_ident_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 548 \"lib/read.mll\"\n \n# 548 \"lib/read.mll\"\n ( Bi_outbuf.clear v.buf;\n finish_string v lexbuf )\n\n# 1952 \"lib/read.ml\"\n\n \n# 1953 \"lib/read.ml\"\n | 1 ->\nlet\n\n# 550 \"lib/read.mll\"\n \n# 550 \"lib/read.mll\"\n s\n\n# 1958 \"lib/read.ml\"\n# 1958 \"lib/read.ml\"\n= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos lexbuf.Lexing.lex_curr_pos in\n\n# 551 \"lib/read.mll\"\n \n# 551 \"lib/read.mll\"\n ( s )\n\n# 1962 \"lib/read.ml\"\n\n \n# 1963 \"lib/read.ml\"\n | 2 ->\n\n# 552 \"lib/read.mll\"\n \n# 552 \"lib/read.mll\"\n ( long_error \"Expected string or identifier but found\" v lexbuf )\n\n# 1967 \"lib/read.ml\"\n\n \n# 1968 \"lib/read.ml\"\n | 3 ->\n\n# 553 \"lib/read.mll\"\n \n# 553 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1972 \"lib/read.ml\"\n\n \n# 1973 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_ident_rec v lexbuf __ocaml_lex_state\n\nand map_ident v f lexbuf =\n __ocaml_lex_map_ident_rec v f lexbuf 242\nand __ocaml_lex_map_ident_rec v f lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 556 \"lib/read.mll\"\n \n# 556 \"lib/read.mll\"\n ( Bi_outbuf.clear v.buf;\n map_string v f lexbuf )\n\n# 1985 \"lib/read.ml\"\n\n \n# 1986 \"lib/read.ml\"\n | 1 ->\n\n# 559 \"lib/read.mll\"\n \n# 559 \"lib/read.mll\"\n ( map_lexeme f lexbuf )\n\n# 1990 \"lib/read.ml\"\n\n \n# 1991 \"lib/read.ml\"\n | 2 ->\n\n# 560 \"lib/read.mll\"\n \n# 560 \"lib/read.mll\"\n ( long_error \"Expected string or identifier but found\" v lexbuf )\n\n# 1995 \"lib/read.ml\"\n\n \n# 1996 \"lib/read.ml\"\n | 3 ->\n\n# 561 \"lib/read.mll\"\n \n# 561 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2000 \"lib/read.ml\"\n\n \n# 2001 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_map_ident_rec v f lexbuf __ocaml_lex_state\n\nand read_sequence read_cell init_acc v lexbuf =\n __ocaml_lex_read_sequence_rec read_cell init_acc v lexbuf 247\nand __ocaml_lex_read_sequence_rec read_cell init_acc v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 564 \"lib/read.mll\"\n \n# 564 \"lib/read.mll\"\n ( let acc = ref init_acc in\n try\n read_space v lexbuf;\n read_array_end lexbuf;\n acc := read_cell !acc v lexbuf;\n while true do\n read_space v lexbuf;\n read_array_sep v lexbuf;\n read_space v lexbuf;\n acc := read_cell !acc v lexbuf;\n done;\n assert false\n with End_of_array ->\n !acc\n )\n\n# 2026 \"lib/read.ml\"\n\n \n# 2027 \"lib/read.ml\"\n | 1 ->\n\n# 579 \"lib/read.mll\"\n \n# 579 \"lib/read.mll\"\n ( long_error \"Expected '[' but found\" v lexbuf )\n\n# 2031 \"lib/read.ml\"\n\n \n# 2032 \"lib/read.ml\"\n | 2 ->\n\n# 580 \"lib/read.mll\"\n \n# 580 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2036 \"lib/read.ml\"\n\n \n# 2037 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_sequence_rec read_cell init_acc v lexbuf __ocaml_lex_state\n\nand read_list_rev read_cell v lexbuf =\n __ocaml_lex_read_list_rev_rec read_cell v lexbuf 251\nand __ocaml_lex_read_list_rev_rec read_cell v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 583 \"lib/read.mll\"\n \n# 583 \"lib/read.mll\"\n ( let acc = ref [] in\n try\n read_space v lexbuf;\n read_array_end lexbuf;\n acc := read_cell v lexbuf :: !acc;\n while true do\n read_space v lexbuf;\n read_array_sep v lexbuf;\n read_space v lexbuf;\n acc := read_cell v lexbuf :: !acc;\n done;\n assert false\n with End_of_array ->\n !acc\n )\n\n# 2062 \"lib/read.ml\"\n\n \n# 2063 \"lib/read.ml\"\n | 1 ->\n\n# 598 \"lib/read.mll\"\n \n# 598 \"lib/read.mll\"\n ( long_error \"Expected '[' but found\" v lexbuf )\n\n# 2067 \"lib/read.ml\"\n\n \n# 2068 \"lib/read.ml\"\n | 2 ->\n\n# 599 \"lib/read.mll\"\n \n# 599 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2072 \"lib/read.ml\"\n\n \n# 2073 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_list_rev_rec read_cell v lexbuf __ocaml_lex_state\n\nand read_array_end lexbuf =\n __ocaml_lex_read_array_end_rec lexbuf 255\nand __ocaml_lex_read_array_end_rec lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 602 \"lib/read.mll\"\n \n# 602 \"lib/read.mll\"\n ( raise End_of_array )\n\n# 2084 \"lib/read.ml\"\n\n \n# 2085 \"lib/read.ml\"\n | 1 ->\n\n# 603 \"lib/read.mll\"\n \n# 603 \"lib/read.mll\"\n ( () )\n\n# 2089 \"lib/read.ml\"\n\n \n# 2090 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_array_end_rec lexbuf __ocaml_lex_state\n\nand read_array_sep v lexbuf =\n __ocaml_lex_read_array_sep_rec v lexbuf 257\nand __ocaml_lex_read_array_sep_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 606 \"lib/read.mll\"\n \n# 606 \"lib/read.mll\"\n ( () )\n\n# 2101 \"lib/read.ml\"\n\n \n# 2102 \"lib/read.ml\"\n | 1 ->\n\n# 607 \"lib/read.mll\"\n \n# 607 \"lib/read.mll\"\n ( raise End_of_array )\n\n# 2106 \"lib/read.ml\"\n\n \n# 2107 \"lib/read.ml\"\n | 2 ->\n\n# 608 \"lib/read.mll\"\n \n# 608 \"lib/read.mll\"\n ( long_error \"Expected ',' or ']' but found\" v lexbuf )\n\n# 2111 \"lib/read.ml\"\n\n \n# 2112 \"lib/read.ml\"\n | 3 ->\n\n# 609 \"lib/read.mll\"\n \n# 609 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2116 \"lib/read.ml\"\n\n \n# 2117 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_array_sep_rec v lexbuf __ocaml_lex_state\n\nand read_tuple read_cell init_acc v lexbuf =\n __ocaml_lex_read_tuple_rec read_cell init_acc v lexbuf 262\nand __ocaml_lex_read_tuple_rec read_cell init_acc v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 613 \"lib/read.mll\"\n \n# 613 \"lib/read.mll\"\n (\n \n# 633 \"lib/read.mll\"\n long_error \"Invalid token\" v lexbuf\n \n# 635 \"lib/read.mll\"\n )\n\n# 2150 \"lib/read.ml\"\n\n \n# 2151 \"lib/read.ml\"\n | 1 ->\n\n# 636 \"lib/read.mll\"\n \n# 636 \"lib/read.mll\"\n ( long_error \"Expected ')' but found\" v lexbuf )\n\n# 2155 \"lib/read.ml\"\n\n \n# 2156 \"lib/read.ml\"\n | 2 ->\n\n# 637 \"lib/read.mll\"\n \n# 637 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2160 \"lib/read.ml\"\n\n \n# 2161 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_tuple_rec read_cell init_acc v lexbuf __ocaml_lex_state\n\nand read_tuple_end lexbuf =\n __ocaml_lex_read_tuple_end_rec lexbuf 266\nand __ocaml_lex_read_tuple_end_rec lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 640 \"lib/read.mll\"\n \n# 640 \"lib/read.mll\"\n ( raise End_of_tuple )\n\n# 2172 \"lib/read.ml\"\n\n \n# 2173 \"lib/read.ml\"\n | 1 ->\n\n# 641 \"lib/read.mll\"\n \n# 641 \"lib/read.mll\"\n ( () )\n\n# 2177 \"lib/read.ml\"\n\n \n# 2178 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_tuple_end_rec lexbuf __ocaml_lex_state\n\nand read_tuple_end2 v std lexbuf =\n __ocaml_lex_read_tuple_end2_rec v std lexbuf 268\nand __ocaml_lex_read_tuple_end2_rec v std lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 644 \"lib/read.mll\"\n \n# 644 \"lib/read.mll\"\n ( if std then\n long_error \"Expected ')' or '' but found\" v lexbuf\n else\n raise End_of_tuple )\n\n# 2192 \"lib/read.ml\"\n\n \n# 2193 \"lib/read.ml\"\n | 1 ->\n\n# 648 \"lib/read.mll\"\n \n# 648 \"lib/read.mll\"\n ( if std then\n raise End_of_tuple\n else\n long_error \"Expected ']' or '' but found\" v lexbuf )\n\n# 2200 \"lib/read.ml\"\n\n \n# 2201 \"lib/read.ml\"\n | 2 ->\n\n# 652 \"lib/read.mll\"\n \n# 652 \"lib/read.mll\"\n ( () )\n\n# 2205 \"lib/read.ml\"\n\n \n# 2206 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_tuple_end2_rec v std lexbuf __ocaml_lex_state\n\nand read_tuple_sep v lexbuf =\n __ocaml_lex_read_tuple_sep_rec v lexbuf 271\nand __ocaml_lex_read_tuple_sep_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 655 \"lib/read.mll\"\n \n# 655 \"lib/read.mll\"\n ( () )\n\n# 2217 \"lib/read.ml\"\n\n \n# 2218 \"lib/read.ml\"\n | 1 ->\n\n# 656 \"lib/read.mll\"\n \n# 656 \"lib/read.mll\"\n ( raise End_of_tuple )\n\n# 2222 \"lib/read.ml\"\n\n \n# 2223 \"lib/read.ml\"\n | 2 ->\n\n# 657 \"lib/read.mll\"\n \n# 657 \"lib/read.mll\"\n ( long_error \"Expected ',' or ')' but found\" v lexbuf )\n\n# 2227 \"lib/read.ml\"\n\n \n# 2228 \"lib/read.ml\"\n | 3 ->\n\n# 658 \"lib/read.mll\"\n \n# 658 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2232 \"lib/read.ml\"\n\n \n# 2233 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_tuple_sep_rec v lexbuf __ocaml_lex_state\n\nand read_tuple_sep2 v std lexbuf =\n __ocaml_lex_read_tuple_sep2_rec v std lexbuf 276\nand __ocaml_lex_read_tuple_sep2_rec v std lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 661 \"lib/read.mll\"\n \n# 661 \"lib/read.mll\"\n ( () )\n\n# 2244 \"lib/read.ml\"\n\n \n# 2245 \"lib/read.ml\"\n | 1 ->\n\n# 662 \"lib/read.mll\"\n \n# 662 \"lib/read.mll\"\n ( if std then\n long_error \"Expected ',' or ']' but found\" v lexbuf\n else\n raise End_of_tuple )\n\n# 2252 \"lib/read.ml\"\n\n \n# 2253 \"lib/read.ml\"\n | 2 ->\n\n# 666 \"lib/read.mll\"\n \n# 666 \"lib/read.mll\"\n ( if std then\n raise End_of_tuple\n else\n long_error \"Expected ',' or ')' but found\" v lexbuf )\n\n# 2260 \"lib/read.ml\"\n\n \n# 2261 \"lib/read.ml\"\n | 3 ->\n\n# 670 \"lib/read.mll\"\n \n# 670 \"lib/read.mll\"\n ( long_error \"Expected ',' or ')' but found\" v lexbuf )\n\n# 2265 \"lib/read.ml\"\n\n \n# 2266 \"lib/read.ml\"\n | 4 ->\n\n# 671 \"lib/read.mll\"\n \n# 671 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2270 \"lib/read.ml\"\n\n \n# 2271 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_tuple_sep2_rec v std lexbuf __ocaml_lex_state\n\nand read_abstract_fields read_key read_field init_acc v lexbuf =\n __ocaml_lex_read_abstract_fields_rec read_key read_field init_acc v lexbuf 282\nand __ocaml_lex_read_abstract_fields_rec read_key read_field init_acc v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 675 \"lib/read.mll\"\n \n# 675 \"lib/read.mll\"\n ( let acc = ref init_acc in\n try\n read_space v lexbuf;\n read_object_end lexbuf;\n let field_name = read_key v lexbuf in\n read_space v lexbuf;\n read_colon v lexbuf;\n read_space v lexbuf;\n acc := read_field !acc field_name v lexbuf;\n while true do\n read_space v lexbuf;\n read_object_sep v lexbuf;\n read_space v lexbuf;\n let field_name = read_key v lexbuf in\n read_space v lexbuf;\n read_colon v lexbuf;\n read_space v lexbuf;\n acc := read_field !acc field_name v lexbuf;\n done;\n assert false\n with End_of_object ->\n !acc\n )\n\n# 2304 \"lib/read.ml\"\n\n \n# 2305 \"lib/read.ml\"\n | 1 ->\n\n# 698 \"lib/read.mll\"\n \n# 698 \"lib/read.mll\"\n ( long_error \"Expected '{' but found\" v lexbuf )\n\n# 2309 \"lib/read.ml\"\n\n \n# 2310 \"lib/read.ml\"\n | 2 ->\n\n# 699 \"lib/read.mll\"\n \n# 699 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2314 \"lib/read.ml\"\n\n \n# 2315 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_abstract_fields_rec read_key read_field init_acc v lexbuf __ocaml_lex_state\n\nand read_lcurl v lexbuf =\n __ocaml_lex_read_lcurl_rec v lexbuf 286\nand __ocaml_lex_read_lcurl_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 702 \"lib/read.mll\"\n \n# 702 \"lib/read.mll\"\n ( () )\n\n# 2326 \"lib/read.ml\"\n\n \n# 2327 \"lib/read.ml\"\n | 1 ->\n\n# 703 \"lib/read.mll\"\n \n# 703 \"lib/read.mll\"\n ( long_error \"Expected '{' but found\" v lexbuf )\n\n# 2331 \"lib/read.ml\"\n\n \n# 2332 \"lib/read.ml\"\n | 2 ->\n\n# 704 \"lib/read.mll\"\n \n# 704 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2336 \"lib/read.ml\"\n\n \n# 2337 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_lcurl_rec v lexbuf __ocaml_lex_state\n\nand read_object_end lexbuf =\n __ocaml_lex_read_object_end_rec lexbuf 290\nand __ocaml_lex_read_object_end_rec lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 707 \"lib/read.mll\"\n \n# 707 \"lib/read.mll\"\n ( raise End_of_object )\n\n# 2348 \"lib/read.ml\"\n\n \n# 2349 \"lib/read.ml\"\n | 1 ->\n\n# 708 \"lib/read.mll\"\n \n# 708 \"lib/read.mll\"\n ( () )\n\n# 2353 \"lib/read.ml\"\n\n \n# 2354 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_object_end_rec lexbuf __ocaml_lex_state\n\nand read_object_sep v lexbuf =\n __ocaml_lex_read_object_sep_rec v lexbuf 292\nand __ocaml_lex_read_object_sep_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 711 \"lib/read.mll\"\n \n# 711 \"lib/read.mll\"\n ( () )\n\n# 2365 \"lib/read.ml\"\n\n \n# 2366 \"lib/read.ml\"\n | 1 ->\n\n# 712 \"lib/read.mll\"\n \n# 712 \"lib/read.mll\"\n ( raise End_of_object )\n\n# 2370 \"lib/read.ml\"\n\n \n# 2371 \"lib/read.ml\"\n | 2 ->\n\n# 713 \"lib/read.mll\"\n \n# 713 \"lib/read.mll\"\n ( long_error \"Expected ',' or '}' but found\" v lexbuf )\n\n# 2375 \"lib/read.ml\"\n\n \n# 2376 \"lib/read.ml\"\n | 3 ->\n\n# 714 \"lib/read.mll\"\n \n# 714 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2380 \"lib/read.ml\"\n\n \n# 2381 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_object_sep_rec v lexbuf __ocaml_lex_state\n\nand read_colon v lexbuf =\n __ocaml_lex_read_colon_rec v lexbuf 297\nand __ocaml_lex_read_colon_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 717 \"lib/read.mll\"\n \n# 717 \"lib/read.mll\"\n ( () )\n\n# 2392 \"lib/read.ml\"\n\n \n# 2393 \"lib/read.ml\"\n | 1 ->\n\n# 718 \"lib/read.mll\"\n \n# 718 \"lib/read.mll\"\n ( long_error \"Expected ':' but found\" v lexbuf )\n\n# 2397 \"lib/read.ml\"\n\n \n# 2398 \"lib/read.ml\"\n | 2 ->\n\n# 719 \"lib/read.mll\"\n \n# 719 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2402 \"lib/read.ml\"\n\n \n# 2403 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_colon_rec v lexbuf __ocaml_lex_state\n\nand start_any_tuple v lexbuf =\n __ocaml_lex_start_any_tuple_rec v lexbuf 301\nand __ocaml_lex_start_any_tuple_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 722 \"lib/read.mll\"\n \n# 722 \"lib/read.mll\"\n ( false )\n\n# 2414 \"lib/read.ml\"\n\n \n# 2415 \"lib/read.ml\"\n | 1 ->\n\n# 723 \"lib/read.mll\"\n \n# 723 \"lib/read.mll\"\n ( true )\n\n# 2419 \"lib/read.ml\"\n\n \n# 2420 \"lib/read.ml\"\n | 2 ->\n\n# 724 \"lib/read.mll\"\n \n# 724 \"lib/read.mll\"\n ( long_error \"Expected '(' or '[' but found\" v lexbuf )\n\n# 2424 \"lib/read.ml\"\n\n \n# 2425 \"lib/read.ml\"\n | 3 ->\n\n# 725 \"lib/read.mll\"\n \n# 725 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2429 \"lib/read.ml\"\n\n \n# 2430 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_start_any_tuple_rec v lexbuf __ocaml_lex_state\n\nand read_lpar v lexbuf =\n __ocaml_lex_read_lpar_rec v lexbuf 306\nand __ocaml_lex_read_lpar_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 728 \"lib/read.mll\"\n \n# 728 \"lib/read.mll\"\n ( () )\n\n# 2441 \"lib/read.ml\"\n\n \n# 2442 \"lib/read.ml\"\n | 1 ->\n\n# 729 \"lib/read.mll\"\n \n# 729 \"lib/read.mll\"\n ( long_error \"Expected '(' but found\" v lexbuf )\n\n# 2446 \"lib/read.ml\"\n\n \n# 2447 \"lib/read.ml\"\n | 2 ->\n\n# 730 \"lib/read.mll\"\n \n# 730 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2451 \"lib/read.ml\"\n\n \n# 2452 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_lpar_rec v lexbuf __ocaml_lex_state\n\nand read_rpar v lexbuf =\n __ocaml_lex_read_rpar_rec v lexbuf 310\nand __ocaml_lex_read_rpar_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 733 \"lib/read.mll\"\n \n# 733 \"lib/read.mll\"\n ( () )\n\n# 2463 \"lib/read.ml\"\n\n \n# 2464 \"lib/read.ml\"\n | 1 ->\n\n# 734 \"lib/read.mll\"\n \n# 734 \"lib/read.mll\"\n ( long_error \"Expected ')' but found\" v lexbuf )\n\n# 2468 \"lib/read.ml\"\n\n \n# 2469 \"lib/read.ml\"\n | 2 ->\n\n# 735 \"lib/read.mll\"\n \n# 735 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2473 \"lib/read.ml\"\n\n \n# 2474 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_rpar_rec v lexbuf __ocaml_lex_state\n\nand read_lbr v lexbuf =\n __ocaml_lex_read_lbr_rec v lexbuf 314\nand __ocaml_lex_read_lbr_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 738 \"lib/read.mll\"\n \n# 738 \"lib/read.mll\"\n ( () )\n\n# 2485 \"lib/read.ml\"\n\n \n# 2486 \"lib/read.ml\"\n | 1 ->\n\n# 739 \"lib/read.mll\"\n \n# 739 \"lib/read.mll\"\n ( long_error \"Expected '[' but found\" v lexbuf )\n\n# 2490 \"lib/read.ml\"\n\n \n# 2491 \"lib/read.ml\"\n | 2 ->\n\n# 740 \"lib/read.mll\"\n \n# 740 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2495 \"lib/read.ml\"\n\n \n# 2496 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_lbr_rec v lexbuf __ocaml_lex_state\n\nand read_rbr v lexbuf =\n __ocaml_lex_read_rbr_rec v lexbuf 318\nand __ocaml_lex_read_rbr_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 743 \"lib/read.mll\"\n \n# 743 \"lib/read.mll\"\n ( () )\n\n# 2507 \"lib/read.ml\"\n\n \n# 2508 \"lib/read.ml\"\n | 1 ->\n\n# 744 \"lib/read.mll\"\n \n# 744 \"lib/read.mll\"\n ( long_error \"Expected ']' but found\" v lexbuf )\n\n# 2512 \"lib/read.ml\"\n\n \n# 2513 \"lib/read.ml\"\n | 2 ->\n\n# 745 \"lib/read.mll\"\n \n# 745 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2517 \"lib/read.ml\"\n\n \n# 2518 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_rbr_rec v lexbuf __ocaml_lex_state\n\nand skip_json v lexbuf =\n __ocaml_lex_skip_json_rec v lexbuf 322\nand __ocaml_lex_skip_json_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 751 \"lib/read.mll\"\n \n# 751 \"lib/read.mll\"\n ( () )\n\n# 2529 \"lib/read.ml\"\n\n \n# 2530 \"lib/read.ml\"\n | 1 ->\n\n# 752 \"lib/read.mll\"\n \n# 752 \"lib/read.mll\"\n ( () )\n\n# 2534 \"lib/read.ml\"\n\n \n# 2535 \"lib/read.ml\"\n | 2 ->\n\n# 753 \"lib/read.mll\"\n \n# 753 \"lib/read.mll\"\n ( () )\n\n# 2539 \"lib/read.ml\"\n\n \n# 2540 \"lib/read.ml\"\n | 3 ->\n\n# 754 \"lib/read.mll\"\n \n# 754 \"lib/read.mll\"\n ( () )\n\n# 2544 \"lib/read.ml\"\n\n \n# 2545 \"lib/read.ml\"\n | 4 ->\n\n# 755 \"lib/read.mll\"\n \n# 755 \"lib/read.mll\"\n ( () )\n\n# 2549 \"lib/read.ml\"\n\n \n# 2550 \"lib/read.ml\"\n | 5 ->\n\n# 756 \"lib/read.mll\"\n \n# 756 \"lib/read.mll\"\n ( () )\n\n# 2554 \"lib/read.ml\"\n\n \n# 2555 \"lib/read.ml\"\n | 6 ->\n\n# 757 \"lib/read.mll\"\n \n# 757 \"lib/read.mll\"\n ( finish_skip_stringlit v lexbuf )\n\n# 2559 \"lib/read.ml\"\n\n \n# 2560 \"lib/read.ml\"\n | 7 ->\n\n# 758 \"lib/read.mll\"\n \n# 758 \"lib/read.mll\"\n ( () )\n\n# 2564 \"lib/read.ml\"\n\n \n# 2565 \"lib/read.ml\"\n | 8 ->\n\n# 759 \"lib/read.mll\"\n \n# 759 \"lib/read.mll\"\n ( () )\n\n# 2569 \"lib/read.ml\"\n\n \n# 2570 \"lib/read.ml\"\n | 9 ->\n\n# 761 \"lib/read.mll\"\n \n# 761 \"lib/read.mll\"\n ( try\n read_space v lexbuf;\n read_object_end lexbuf;\n skip_ident v lexbuf;\n read_space v lexbuf;\n read_colon v lexbuf;\n read_space v lexbuf;\n skip_json v lexbuf;\n while true do\n read_space v lexbuf;\n read_object_sep v lexbuf;\n read_space v lexbuf;\n skip_ident v lexbuf;\n read_space v lexbuf;\n read_colon v lexbuf;\n read_space v lexbuf;\n skip_json v lexbuf;\n done;\n assert false\n with End_of_object ->\n ()\n )\n\n# 2595 \"lib/read.ml\"\n\n \n# 2596 \"lib/read.ml\"\n | 10 ->\n\n# 784 \"lib/read.mll\"\n \n# 784 \"lib/read.mll\"\n ( try\n read_space v lexbuf;\n read_array_end lexbuf;\n skip_json v lexbuf;\n while true do\n read_space v lexbuf;\n read_array_sep v lexbuf;\n read_space v lexbuf;\n skip_json v lexbuf;\n done;\n assert false\n with End_of_array ->\n ()\n )\n\n# 2613 \"lib/read.ml\"\n\n \n# 2614 \"lib/read.ml\"\n | 11 ->\n\n# 799 \"lib/read.mll\"\n \n# 799 \"lib/read.mll\"\n (\n \n# 815 \"lib/read.mll\"\n long_error \"Invalid token\" v lexbuf\n \n# 817 \"lib/read.mll\"\n )\n\n# 2636 \"lib/read.ml\"\n\n \n# 2637 \"lib/read.ml\"\n | 12 ->\n\n# 819 \"lib/read.mll\"\n \n# 819 \"lib/read.mll\"\n (\n \n# 826 \"lib/read.mll\"\n long_error \"Invalid token\" v lexbuf\n \n# 828 \"lib/read.mll\"\n )\n\n# 2650 \"lib/read.ml\"\n\n \n# 2651 \"lib/read.ml\"\n | 13 ->\n\n# 830 \"lib/read.mll\"\n \n# 830 \"lib/read.mll\"\n ( skip_json v lexbuf )\n\n# 2655 \"lib/read.ml\"\n\n \n# 2656 \"lib/read.ml\"\n | 14 ->\n\n# 831 \"lib/read.mll\"\n \n# 831 \"lib/read.mll\"\n ( finish_comment v lexbuf; skip_json v lexbuf )\n\n# 2660 \"lib/read.ml\"\n\n \n# 2661 \"lib/read.ml\"\n | 15 ->\n\n# 832 \"lib/read.mll\"\n \n# 832 \"lib/read.mll\"\n ( newline v lexbuf; skip_json v lexbuf )\n\n# 2665 \"lib/read.ml\"\n\n \n# 2666 \"lib/read.ml\"\n | 16 ->\n\n# 833 \"lib/read.mll\"\n \n# 833 \"lib/read.mll\"\n ( skip_json v lexbuf )\n\n# 2670 \"lib/read.ml\"\n\n \n# 2671 \"lib/read.ml\"\n | 17 ->\n\n# 834 \"lib/read.mll\"\n \n# 834 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2675 \"lib/read.ml\"\n\n \n# 2676 \"lib/read.ml\"\n | 18 ->\n\n# 835 \"lib/read.mll\"\n \n# 835 \"lib/read.mll\"\n ( long_error \"Invalid token\" v lexbuf )\n\n# 2680 \"lib/read.ml\"\n\n \n# 2681 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_skip_json_rec v lexbuf __ocaml_lex_state\n\nand finish_skip_stringlit v lexbuf =\n __ocaml_lex_finish_skip_stringlit_rec v lexbuf 378\nand __ocaml_lex_finish_skip_stringlit_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 841 \"lib/read.mll\"\n \n# 841 \"lib/read.mll\"\n ( () )\n\n# 2692 \"lib/read.ml\"\n\n \n# 2693 \"lib/read.ml\"\n | 1 ->\n\n# 842 \"lib/read.mll\"\n \n# 842 \"lib/read.mll\"\n ( long_error \"Invalid string literal\" v lexbuf )\n\n# 2697 \"lib/read.ml\"\n\n \n# 2698 \"lib/read.ml\"\n | 2 ->\n\n# 843 \"lib/read.mll\"\n \n# 843 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2702 \"lib/read.ml\"\n\n \n# 2703 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_skip_stringlit_rec v lexbuf __ocaml_lex_state\n\nand finish_skip_variant v lexbuf =\n __ocaml_lex_finish_skip_variant_rec v lexbuf 389\nand __ocaml_lex_finish_skip_variant_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 846 \"lib/read.mll\"\n \n# 846 \"lib/read.mll\"\n ( skip_json v lexbuf;\n read_space v lexbuf;\n read_gt v lexbuf )\n\n# 2716 \"lib/read.ml\"\n\n \n# 2717 \"lib/read.ml\"\n | 1 ->\n\n# 849 \"lib/read.mll\"\n \n# 849 \"lib/read.mll\"\n ( () )\n\n# 2721 \"lib/read.ml\"\n\n \n# 2722 \"lib/read.ml\"\n | 2 ->\n\n# 850 \"lib/read.mll\"\n \n# 850 \"lib/read.mll\"\n ( long_error \"Expected ':' or '>' but found\" v lexbuf )\n\n# 2726 \"lib/read.ml\"\n\n \n# 2727 \"lib/read.ml\"\n | 3 ->\n\n# 851 \"lib/read.mll\"\n \n# 851 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2731 \"lib/read.ml\"\n\n \n# 2732 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_skip_variant_rec v lexbuf __ocaml_lex_state\n\nand skip_ident v lexbuf =\n __ocaml_lex_skip_ident_rec v lexbuf 394\nand __ocaml_lex_skip_ident_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 854 \"lib/read.mll\"\n \n# 854 \"lib/read.mll\"\n ( finish_skip_stringlit v lexbuf )\n\n# 2743 \"lib/read.ml\"\n\n \n# 2744 \"lib/read.ml\"\n | 1 ->\n\n# 855 \"lib/read.mll\"\n \n# 855 \"lib/read.mll\"\n ( () )\n\n# 2748 \"lib/read.ml\"\n\n \n# 2749 \"lib/read.ml\"\n | 2 ->\n\n# 856 \"lib/read.mll\"\n \n# 856 \"lib/read.mll\"\n ( long_error \"Expected string or identifier but found\" v lexbuf )\n\n# 2753 \"lib/read.ml\"\n\n \n# 2754 \"lib/read.ml\"\n | 3 ->\n\n# 857 \"lib/read.mll\"\n \n# 857 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2758 \"lib/read.ml\"\n\n \n# 2759 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_skip_ident_rec v lexbuf __ocaml_lex_state\n\nand buffer_json v lexbuf =\n __ocaml_lex_buffer_json_rec v lexbuf 399\nand __ocaml_lex_buffer_json_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 870 \"lib/read.mll\"\n \n# 870 \"lib/read.mll\"\n ( add_lexeme v.buf lexbuf )\n\n# 2770 \"lib/read.ml\"\n\n \n# 2771 \"lib/read.ml\"\n | 1 ->\n\n# 872 \"lib/read.mll\"\n \n# 872 \"lib/read.mll\"\n ( finish_buffer_stringlit v lexbuf )\n\n# 2775 \"lib/read.ml\"\n\n \n# 2776 \"lib/read.ml\"\n | 2 ->\n\n# 873 \"lib/read.mll\"\n \n# 873 \"lib/read.mll\"\n ( try\n Bi_outbuf.add_char v.buf '{';\n buffer_space v lexbuf;\n buffer_object_end v lexbuf;\n buffer_ident v lexbuf;\n buffer_space v lexbuf;\n buffer_colon v lexbuf;\n buffer_space v lexbuf;\n buffer_json v lexbuf;\n while true do\n buffer_space v lexbuf;\n buffer_object_sep v lexbuf;\n buffer_space v lexbuf;\n buffer_ident v lexbuf;\n buffer_space v lexbuf;\n buffer_colon v lexbuf;\n buffer_space v lexbuf;\n buffer_json v lexbuf;\n done;\n assert false\n with End_of_object ->\n ()\n )\n\n# 2802 \"lib/read.ml\"\n\n \n# 2803 \"lib/read.ml\"\n | 3 ->\n\n# 897 \"lib/read.mll\"\n \n# 897 \"lib/read.mll\"\n ( try\n Bi_outbuf.add_char v.buf '[';\n buffer_space v lexbuf;\n buffer_array_end v lexbuf;\n buffer_json v lexbuf;\n while true do\n buffer_space v lexbuf;\n buffer_array_sep v lexbuf;\n buffer_space v lexbuf;\n buffer_json v lexbuf;\n done;\n assert false\n with End_of_array ->\n ()\n )\n\n# 2821 \"lib/read.ml\"\n\n \n# 2822 \"lib/read.ml\"\n | 4 ->\n\n# 913 \"lib/read.mll\"\n \n# 913 \"lib/read.mll\"\n (\n \n# 930 \"lib/read.mll\"\n long_error \"Invalid token\" v lexbuf\n \n# 932 \"lib/read.mll\"\n )\n\n# 2845 \"lib/read.ml\"\n\n \n# 2846 \"lib/read.ml\"\n | 5 ->\n\n# 934 \"lib/read.mll\"\n \n# 934 \"lib/read.mll\"\n (\n \n# 942 \"lib/read.mll\"\n long_error \"Invalid token\" v lexbuf\n \n# 944 \"lib/read.mll\"\n )\n\n# 2860 \"lib/read.ml\"\n\n \n# 2861 \"lib/read.ml\"\n | 6 ->\n\n# 946 \"lib/read.mll\"\n \n# 946 \"lib/read.mll\"\n ( add_lexeme v.buf lexbuf; buffer_json v lexbuf )\n\n# 2865 \"lib/read.ml\"\n\n \n# 2866 \"lib/read.ml\"\n | 7 ->\n\n# 947 \"lib/read.mll\"\n \n# 947 \"lib/read.mll\"\n ( Bi_outbuf.add_string v.buf \"/*\";\n finish_buffer_comment v lexbuf;\n buffer_json v lexbuf )\n\n# 2872 \"lib/read.ml\"\n\n \n# 2873 \"lib/read.ml\"\n | 8 ->\n\n# 950 \"lib/read.mll\"\n \n# 950 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\\n';\n newline v lexbuf;\n buffer_json v lexbuf )\n\n# 2879 \"lib/read.ml\"\n\n \n# 2880 \"lib/read.ml\"\n | 9 ->\n\n# 953 \"lib/read.mll\"\n \n# 953 \"lib/read.mll\"\n ( add_lexeme v.buf lexbuf; buffer_json v lexbuf )\n\n# 2884 \"lib/read.ml\"\n\n \n# 2885 \"lib/read.ml\"\n | 10 ->\n\n# 954 \"lib/read.mll\"\n \n# 954 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2889 \"lib/read.ml\"\n\n \n# 2890 \"lib/read.ml\"\n | 11 ->\n\n# 955 \"lib/read.mll\"\n \n# 955 \"lib/read.mll\"\n ( long_error \"Invalid token\" v lexbuf )\n\n# 2894 \"lib/read.ml\"\n\n \n# 2895 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_json_rec v lexbuf __ocaml_lex_state\n\nand finish_buffer_stringlit v lexbuf =\n __ocaml_lex_finish_buffer_stringlit_rec v lexbuf 450\nand __ocaml_lex_finish_buffer_stringlit_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 961 \"lib/read.mll\"\n \n# 961 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\"';\n add_lexeme v.buf lexbuf\n )\n\n# 2908 \"lib/read.ml\"\n\n \n# 2909 \"lib/read.ml\"\n | 1 ->\n\n# 964 \"lib/read.mll\"\n \n# 964 \"lib/read.mll\"\n ( long_error \"Invalid string literal\" v lexbuf )\n\n# 2913 \"lib/read.ml\"\n\n \n# 2914 \"lib/read.ml\"\n | 2 ->\n\n# 965 \"lib/read.mll\"\n \n# 965 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2918 \"lib/read.ml\"\n\n \n# 2919 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_buffer_stringlit_rec v lexbuf __ocaml_lex_state\n\nand finish_buffer_variant v lexbuf =\n __ocaml_lex_finish_buffer_variant_rec v lexbuf 461\nand __ocaml_lex_finish_buffer_variant_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 968 \"lib/read.mll\"\n \n# 968 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf ':';\n buffer_json v lexbuf;\n buffer_space v lexbuf;\n buffer_gt v lexbuf )\n\n# 2933 \"lib/read.ml\"\n\n \n# 2934 \"lib/read.ml\"\n | 1 ->\n\n# 972 \"lib/read.mll\"\n \n# 972 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '>' )\n\n# 2938 \"lib/read.ml\"\n\n \n# 2939 \"lib/read.ml\"\n | 2 ->\n\n# 973 \"lib/read.mll\"\n \n# 973 \"lib/read.mll\"\n ( long_error \"Expected ':' or '>' but found\" v lexbuf )\n\n# 2943 \"lib/read.ml\"\n\n \n# 2944 \"lib/read.ml\"\n | 3 ->\n\n# 974 \"lib/read.mll\"\n \n# 974 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2948 \"lib/read.ml\"\n\n \n# 2949 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_buffer_variant_rec v lexbuf __ocaml_lex_state\n\nand buffer_ident v lexbuf =\n __ocaml_lex_buffer_ident_rec v lexbuf 466\nand __ocaml_lex_buffer_ident_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 977 \"lib/read.mll\"\n \n# 977 \"lib/read.mll\"\n ( finish_buffer_stringlit v lexbuf )\n\n# 2960 \"lib/read.ml\"\n\n \n# 2961 \"lib/read.ml\"\n | 1 ->\n\n# 978 \"lib/read.mll\"\n \n# 978 \"lib/read.mll\"\n ( add_lexeme v.buf lexbuf )\n\n# 2965 \"lib/read.ml\"\n\n \n# 2966 \"lib/read.ml\"\n | 2 ->\n\n# 979 \"lib/read.mll\"\n \n# 979 \"lib/read.mll\"\n ( long_error \"Expected string or identifier but found\" v lexbuf )\n\n# 2970 \"lib/read.ml\"\n\n \n# 2971 \"lib/read.ml\"\n | 3 ->\n\n# 980 \"lib/read.mll\"\n \n# 980 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2975 \"lib/read.ml\"\n\n \n# 2976 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_ident_rec v lexbuf __ocaml_lex_state\n\nand buffer_space v lexbuf =\n __ocaml_lex_buffer_space_rec v lexbuf 471\nand __ocaml_lex_buffer_space_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 983 \"lib/read.mll\"\n \n# 983 \"lib/read.mll\"\n (\n add_lexeme v.buf lexbuf;\n newline v lexbuf;\n buffer_space v lexbuf )\n\n# 2990 \"lib/read.ml\"\n\n \n# 2991 \"lib/read.ml\"\n | 1 ->\n\n# 987 \"lib/read.mll\"\n \n# 987 \"lib/read.mll\"\n (\n Bi_outbuf.add_string v.buf \"/*\";\n finish_buffer_comment v lexbuf;\n buffer_space v lexbuf )\n\n# 2998 \"lib/read.ml\"\n\n \n# 2999 \"lib/read.ml\"\n | 2 ->\n\n# 991 \"lib/read.mll\"\n \n# 991 \"lib/read.mll\"\n (\n Bi_outbuf.add_char v.buf '\\n';\n newline v lexbuf;\n buffer_space v lexbuf )\n\n# 3006 \"lib/read.ml\"\n\n \n# 3007 \"lib/read.ml\"\n | 3 ->\n\n# 995 \"lib/read.mll\"\n \n# 995 \"lib/read.mll\"\n (\n add_lexeme v.buf lexbuf;\n buffer_space v lexbuf )\n\n# 3013 \"lib/read.ml\"\n\n \n# 3014 \"lib/read.ml\"\n | 4 ->\n\n# 998 \"lib/read.mll\"\n \n# 998 \"lib/read.mll\"\n ( () )\n\n# 3018 \"lib/read.ml\"\n\n \n# 3019 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_space_rec v lexbuf __ocaml_lex_state\n\nand buffer_object_end v lexbuf =\n __ocaml_lex_buffer_object_end_rec v lexbuf 478\nand __ocaml_lex_buffer_object_end_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1001 \"lib/read.mll\"\n \n# 1001 \"lib/read.mll\"\n (\n Bi_outbuf.add_char v.buf '}';\n raise End_of_object )\n\n# 3032 \"lib/read.ml\"\n\n \n# 3033 \"lib/read.ml\"\n | 1 ->\n\n# 1004 \"lib/read.mll\"\n \n# 1004 \"lib/read.mll\"\n ( () )\n\n# 3037 \"lib/read.ml\"\n\n \n# 3038 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_object_end_rec v lexbuf __ocaml_lex_state\n\nand buffer_object_sep v lexbuf =\n __ocaml_lex_buffer_object_sep_rec v lexbuf 480\nand __ocaml_lex_buffer_object_sep_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1007 \"lib/read.mll\"\n \n# 1007 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf ',' )\n\n# 3049 \"lib/read.ml\"\n\n \n# 3050 \"lib/read.ml\"\n | 1 ->\n\n# 1008 \"lib/read.mll\"\n \n# 1008 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '}'; raise End_of_object )\n\n# 3054 \"lib/read.ml\"\n\n \n# 3055 \"lib/read.ml\"\n | 2 ->\n\n# 1009 \"lib/read.mll\"\n \n# 1009 \"lib/read.mll\"\n ( long_error \"Expected ',' or '}' but found\" v lexbuf )\n\n# 3059 \"lib/read.ml\"\n\n \n# 3060 \"lib/read.ml\"\n | 3 ->\n\n# 1010 \"lib/read.mll\"\n \n# 1010 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 3064 \"lib/read.ml\"\n\n \n# 3065 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_object_sep_rec v lexbuf __ocaml_lex_state\n\nand buffer_array_end v lexbuf =\n __ocaml_lex_buffer_array_end_rec v lexbuf 485\nand __ocaml_lex_buffer_array_end_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1013 \"lib/read.mll\"\n \n# 1013 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf ']'; raise End_of_array )\n\n# 3076 \"lib/read.ml\"\n\n \n# 3077 \"lib/read.ml\"\n | 1 ->\n\n# 1014 \"lib/read.mll\"\n \n# 1014 \"lib/read.mll\"\n ( () )\n\n# 3081 \"lib/read.ml\"\n\n \n# 3082 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_array_end_rec v lexbuf __ocaml_lex_state\n\nand buffer_array_sep v lexbuf =\n __ocaml_lex_buffer_array_sep_rec v lexbuf 487\nand __ocaml_lex_buffer_array_sep_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1017 \"lib/read.mll\"\n \n# 1017 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf ',' )\n\n# 3093 \"lib/read.ml\"\n\n \n# 3094 \"lib/read.ml\"\n | 1 ->\n\n# 1018 \"lib/read.mll\"\n \n# 1018 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf ']'; raise End_of_array )\n\n# 3098 \"lib/read.ml\"\n\n \n# 3099 \"lib/read.ml\"\n | 2 ->\n\n# 1019 \"lib/read.mll\"\n \n# 1019 \"lib/read.mll\"\n ( long_error \"Expected ',' or ']' but found\" v lexbuf )\n\n# 3103 \"lib/read.ml\"\n\n \n# 3104 \"lib/read.ml\"\n | 3 ->\n\n# 1020 \"lib/read.mll\"\n \n# 1020 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 3108 \"lib/read.ml\"\n\n \n# 3109 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_array_sep_rec v lexbuf __ocaml_lex_state\n\nand buffer_tuple_end v lexbuf =\n __ocaml_lex_buffer_tuple_end_rec v lexbuf 492\nand __ocaml_lex_buffer_tuple_end_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1023 \"lib/read.mll\"\n \n# 1023 \"lib/read.mll\"\n (\n Bi_outbuf.add_char v.buf ')';\n raise End_of_tuple )\n\n# 3122 \"lib/read.ml\"\n\n \n# 3123 \"lib/read.ml\"\n | 1 ->\n\n# 1026 \"lib/read.mll\"\n \n# 1026 \"lib/read.mll\"\n ( () )\n\n# 3127 \"lib/read.ml\"\n\n \n# 3128 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_tuple_end_rec v lexbuf __ocaml_lex_state\n\nand buffer_tuple_sep v lexbuf =\n __ocaml_lex_buffer_tuple_sep_rec v lexbuf 494\nand __ocaml_lex_buffer_tuple_sep_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1029 \"lib/read.mll\"\n \n# 1029 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf ',' )\n\n# 3139 \"lib/read.ml\"\n\n \n# 3140 \"lib/read.ml\"\n | 1 ->\n\n# 1030 \"lib/read.mll\"\n \n# 1030 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf ')'; raise End_of_tuple )\n\n# 3144 \"lib/read.ml\"\n\n \n# 3145 \"lib/read.ml\"\n | 2 ->\n\n# 1031 \"lib/read.mll\"\n \n# 1031 \"lib/read.mll\"\n ( long_error \"Expected ',' or ')' but found\" v lexbuf )\n\n# 3149 \"lib/read.ml\"\n\n \n# 3150 \"lib/read.ml\"\n | 3 ->\n\n# 1032 \"lib/read.mll\"\n \n# 1032 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 3154 \"lib/read.ml\"\n\n \n# 3155 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_tuple_sep_rec v lexbuf __ocaml_lex_state\n\nand buffer_colon v lexbuf =\n __ocaml_lex_buffer_colon_rec v lexbuf 499\nand __ocaml_lex_buffer_colon_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1035 \"lib/read.mll\"\n \n# 1035 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf ':' )\n\n# 3166 \"lib/read.ml\"\n\n \n# 3167 \"lib/read.ml\"\n | 1 ->\n\n# 1036 \"lib/read.mll\"\n \n# 1036 \"lib/read.mll\"\n ( long_error \"Expected ':' but found\" v lexbuf )\n\n# 3171 \"lib/read.ml\"\n\n \n# 3172 \"lib/read.ml\"\n | 2 ->\n\n# 1037 \"lib/read.mll\"\n \n# 1037 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 3176 \"lib/read.ml\"\n\n \n# 3177 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_colon_rec v lexbuf __ocaml_lex_state\n\nand buffer_gt v lexbuf =\n __ocaml_lex_buffer_gt_rec v lexbuf 503\nand __ocaml_lex_buffer_gt_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1040 \"lib/read.mll\"\n \n# 1040 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '>' )\n\n# 3188 \"lib/read.ml\"\n\n \n# 3189 \"lib/read.ml\"\n | 1 ->\n\n# 1041 \"lib/read.mll\"\n \n# 1041 \"lib/read.mll\"\n ( long_error \"Expected '>' but found\" v lexbuf )\n\n# 3193 \"lib/read.ml\"\n\n \n# 3194 \"lib/read.ml\"\n | 2 ->\n\n# 1042 \"lib/read.mll\"\n \n# 1042 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 3198 \"lib/read.ml\"\n\n \n# 3199 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_gt_rec v lexbuf __ocaml_lex_state\n\nand finish_buffer_comment v lexbuf =\n __ocaml_lex_finish_buffer_comment_rec v lexbuf 507\nand __ocaml_lex_finish_buffer_comment_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1045 \"lib/read.mll\"\n \n# 1045 \"lib/read.mll\"\n ( Bi_outbuf.add_string v.buf \"*/\" )\n\n# 3210 \"lib/read.ml\"\n\n \n# 3211 \"lib/read.ml\"\n | 1 ->\n\n# 1046 \"lib/read.mll\"\n \n# 1046 \"lib/read.mll\"\n ( long_error \"Unterminated comment\" v lexbuf )\n\n# 3215 \"lib/read.ml\"\n\n \n# 3216 \"lib/read.ml\"\n | 2 ->\n\n# 1047 \"lib/read.mll\"\n \n# 1047 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\\n';\n newline v lexbuf;\n finish_buffer_comment v lexbuf )\n\n# 3222 \"lib/read.ml\"\n\n \n# 3223 \"lib/read.ml\"\n | 3 ->\n\n# 1050 \"lib/read.mll\"\n \n# 1050 \"lib/read.mll\"\n ( add_lexeme v.buf lexbuf; finish_buffer_comment v lexbuf )\n\n# 3227 \"lib/read.ml\"\n\n \n# 3228 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_buffer_comment_rec v lexbuf __ocaml_lex_state\n\nand junk lexbuf =\n __ocaml_lex_junk_rec lexbuf 513\nand __ocaml_lex_junk_rec lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1053 \"lib/read.mll\"\n \n# 1053 \"lib/read.mll\"\n ( Lexing.lexeme lexbuf )\n\n# 3239 \"lib/read.ml\"\n\n \n# 3240 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_junk_rec lexbuf __ocaml_lex_state\n\n;;\n\n\n# 1055 \"lib/read.mll\"\n \n \n# 1056 \"lib/read.mll\"\n let _ = (read_json : lexer_state -> Lexing.lexbuf -> t)\n\n let read_t = read_json\n\n let () =\n read_junk := junk\n\n let read_int8 v lexbuf =\n let n = read_int v lexbuf in\n if n < 0 || n > 255 then\n lexer_error \"Int8 overflow\" v lexbuf\n else\n char_of_int n\n\n let read_list read_cell v lexbuf =\n List.rev (read_list_rev read_cell v lexbuf)\n\n let array_of_rev_list l =\n match l with\n [] -> [| |]\n | x :: tl ->\n let len = List.length l in\n let a = Array.make len x in\n let r = ref tl in\n for i = len - 2 downto 0 do\n a.(i) <- List.hd !r;\n r := List.tl !r\n done;\n a\n\n let read_array read_cell v lexbuf =\n let l = read_list_rev read_cell v lexbuf in\n array_of_rev_list l\n\n (* Read a JSON object, reading the keys into OCaml strings\n (provided for backward compatibility) *)\n let read_fields read_field init_acc v =\n read_abstract_fields read_ident read_field init_acc v\n\n let finish v lexbuf =\n read_space v lexbuf;\n if not (read_eof lexbuf) then\n long_error \"Junk after end of JSON value:\" v lexbuf\n\n let init_lexer = init_lexer\n\n let from_lexbuf v ?(stream = false) lexbuf =\n read_space v lexbuf;\n\n let x =\n if read_eof lexbuf then\n raise End_of_input\n else\n read_json v lexbuf\n in\n\n if not stream then\n finish v lexbuf;\n\n x\n\n\n let from_string ?buf ?fname ?lnum s =\n try\n let lexbuf = Lexing.from_string s in\n let v = init_lexer ?buf ?fname ?lnum () in\n from_lexbuf v lexbuf\n with End_of_input ->\n json_error \"Blank input data\"\n\n let from_channel ?buf ?fname ?lnum ic =\n try\n let lexbuf = Lexing.from_channel ic in\n let v = init_lexer ?buf ?fname ?lnum () in\n from_lexbuf v lexbuf\n with End_of_input ->\n json_error \"Blank input data\"\n\n let from_file ?buf ?fname ?lnum file =\n let ic = open_in file in\n try\n let x = from_channel ?buf ?fname ?lnum ic in\n close_in ic;\n x\n with e ->\n close_in_noerr ic;\n raise e\n\n exception Finally of exn * exn\n\n let stream_from_lexbuf v ?(fin = fun () -> ()) lexbuf =\n let stream = Some true in\n let f i =\n try Some (from_lexbuf v ?stream lexbuf)\n with\n End_of_input ->\n fin ();\n None\n | e ->\n (try fin () with fin_e -> raise (Finally (e, fin_e)));\n raise e\n in\n Stream.from f\n\n let stream_from_string ?buf ?fname ?lnum s =\n let v = init_lexer ?buf ?fname ?lnum () in\n stream_from_lexbuf v (Lexing.from_string s)\n\n let stream_from_channel ?buf ?fin ?fname ?lnum ic =\n let lexbuf = Lexing.from_channel ic in\n let v = init_lexer ?buf ?fname ?lnum () in\n stream_from_lexbuf v ?fin lexbuf\n\n let stream_from_file ?buf ?fname ?lnum file =\n let ic = open_in file in\n let fin () = close_in ic in\n let fname =\n match fname with\n None -> Some file\n | x -> x\n in\n let lexbuf = Lexing.from_channel ic in\n let v = init_lexer ?buf ?fname ?lnum () in\n stream_from_lexbuf v ~fin lexbuf\n\n type json_line = [ `Json of t | `Exn of exn ]\n\n let linestream_from_channel\n ?buf ?(fin = fun () -> ()) ?fname ?lnum:(lnum0 = 1) ic =\n let buf =\n match buf with\n None -> Some (Bi_outbuf.create 256)\n | Some _ -> buf\n in\n let f i =\n try\n let line = input_line ic in\n let lnum = lnum0 + i in\n Some (`Json (from_string ?buf ?fname ~lnum line))\n with\n End_of_file -> fin (); None\n | e -> Some (`Exn e)\n in\n Stream.from f\n\n let linestream_from_file ?buf ?fname ?lnum file =\n let ic = open_in file in\n let fin () = close_in ic in\n let fname =\n match fname with\n None -> Some file\n | x -> x\n in\n linestream_from_channel ?buf ~fin ?fname ?lnum ic\n\n let prettify ?std s =\n pretty_to_string ?std (from_string s)\n\n let compact ?std s =\n to_string (from_string s)\n\n let validate_json _path _value = None\n\n\n# 3411 \"lib/read.ml\"\n# 39 \"yojson.cppo.ml\"\nmodule Util =\nstruct\n# 1 \"util.ml\"\nexception Type_error of string * t\n\nlet typeof = function\n | `Assoc _ -> \"object\"\n | `Bool _ -> \"bool\"\n | `Float _ -> \"float\"\n | `Int _ -> \"int\"\n | `List _ -> \"array\"\n | `Null -> \"null\"\n | `String _ -> \"string\"\n | `Intlit _ -> \"intlit\"\n | `Tuple _ -> \"tuple\"\n | `Variant _ -> \"variant\"\n\nlet typerr msg js = raise (Type_error (msg ^ typeof js, js))\n\nexception Undefined of string * t\n\nlet ( |> ) = ( |> )\n\nlet assoc name obj =\n try List.assoc name obj\n with Not_found -> `Null\n\nlet member name = function\n | `Assoc obj -> assoc name obj\n | js -> typerr (\"Can't get member '\" ^ name ^ \"' of non-object type \") js\n\nlet index i = function\n | `List l as js ->\n let len = List.length l in\n let wrapped_index = if i < 0 then len + i else i in\n if wrapped_index < 0 || wrapped_index >= len then\n raise (Undefined (\"Index \" ^ string_of_int i ^ \" out of bounds\", js))\n else List.nth l wrapped_index\n | js -> typerr (\"Can't get index \" ^ string_of_int i\n ^ \" of non-array type \") js\n\nlet map f = function\n | `List l -> `List (List.map f l)\n | js -> typerr \"Can't map function over non-array type \" js\n\nlet to_assoc = function\n | `Assoc obj -> obj\n | js -> typerr \"Expected object, got \" js\n\nlet to_option f = function\n | `Null -> None\n | x -> Some (f x)\n\nlet to_bool = function\n | `Bool b -> b\n | js -> typerr \"Expected bool, got \" js\n\nlet to_bool_option = function\n | `Bool b -> Some b\n | `Null -> None\n | js -> typerr \"Expected bool or null, got \" js\n\nlet to_number = function\n | `Int i -> float i\n | `Float f -> f\n | js -> typerr \"Expected number, got \" js\n\nlet to_number_option = function\n | `Int i -> Some (float i)\n | `Float f -> Some f\n | `Null -> None\n | js -> typerr \"Expected number or null, got \" js\n\nlet to_float = function\n | `Float f -> f\n | js -> typerr \"Expected float, got \" js\n\nlet to_float_option = function\n | `Float f -> Some f\n | `Null -> None\n | js -> typerr \"Expected float or null, got \" js\n\nlet to_int = function\n | `Int i -> i\n | js -> typerr \"Expected int, got \" js\n\nlet to_int_option = function\n | `Int i -> Some i\n | `Null -> None\n | js -> typerr \"Expected int or null, got \" js\n\nlet to_list = function\n | `List l -> l\n | js -> typerr \"Expected array, got \" js\n\nlet to_string = function\n | `String s -> s\n | js -> typerr \"Expected string, got \" js\n\nlet to_string_option = function\n | `String s -> Some s\n | `Null -> None\n | js -> typerr \"Expected string or null, got \" js\n\nlet convert_each f = function\n | `List l -> List.map f l\n | js -> typerr \"Can't convert each element of non-array type \" js\n\n\nlet rec rev_filter_map f acc l =\n match l with\n [] -> acc\n | x :: tl ->\n match f x with\n None -> rev_filter_map f acc tl\n | Some y -> rev_filter_map f (y :: acc) tl\n\nlet filter_map f l =\n List.rev (rev_filter_map f [] l)\n\nlet rec rev_flatten acc l =\n match l with\n [] -> acc\n | x :: tl ->\n match x with\n `List l2 -> rev_flatten (List.rev_append l2 acc) tl\n | _ -> rev_flatten acc tl\n\nlet flatten l =\n List.rev (rev_flatten [] l)\n\nlet filter_index i l =\n filter_map (\n function\n `List l ->\n (try Some (List.nth l i)\n with _ -> None)\n | _ -> None\n ) l\n\nlet filter_list l =\n filter_map (\n function\n `List l -> Some l\n | _ -> None\n ) l\n\nlet filter_member k l =\n filter_map (\n function\n `Assoc l ->\n (try Some (List.assoc k l)\n with _ -> None)\n | _ -> None\n ) l\n\nlet filter_assoc l =\n filter_map (\n function\n `Assoc l -> Some l\n | _ -> None\n ) l\n\nlet filter_bool l =\n filter_map (\n function\n `Bool x -> Some x\n | _ -> None\n ) l\n\nlet filter_int l =\n filter_map (\n function\n `Int x -> Some x\n | _ -> None\n ) l\n\nlet filter_float l =\n filter_map (\n function\n `Float x -> Some x\n | _ -> None\n ) l\n\nlet filter_number l =\n filter_map (\n function\n `Int x -> Some (float x)\n | `Float x -> Some x\n | _ -> None\n ) l\n\nlet filter_string l =\n filter_map (\n function\n `String x -> Some x\n | _ -> None\n ) l\n\nlet keys o =\n to_assoc o |> List.map (fun (key, _) -> key)\n\nlet values o =\n to_assoc o |> List.map (fun (_, value) -> value)\n\nlet combine (first : t) (second : t) =\n match (first, second) with\n | (`Assoc a, `Assoc b) -> (`Assoc (a @ b) : t)\n | (a, b) -> raise (Invalid_argument \"Expected two objects, check inputs\")\n# 42 \"yojson.cppo.ml\"\nend\n# 46 \"yojson.cppo.ml\"\nend\n\nmodule Safe =\nstruct\n# 1 \"type.ml\"\n(** {3 Type of the JSON tree} *)\n\ntype t =\n [\n | `Null\n | `Bool of bool\n \n# 8 \"type.ml\"\n | `Int of int\n \n# 11 \"type.ml\"\n | `Intlit of string\n \n# 14 \"type.ml\"\n | `Float of float\n \n# 20 \"type.ml\"\n | `String of string\n \n# 25 \"type.ml\"\n | `Assoc of (string * t) list\n | `List of t list\n \n# 28 \"type.ml\"\n | `Tuple of t list\n \n# 31 \"type.ml\"\n | `Variant of (string * t option)\n \n# 33 \"type.ml\"\n ]\n(**\nAll possible cases defined in Yojson:\n- `Null: JSON null\n- `Bool of bool: JSON boolean\n- `Int of int: JSON number without decimal point or exponent.\n- `Intlit of string: JSON number without decimal point or exponent,\n\t preserved as a string.\n- `Float of float: JSON number, Infinity, -Infinity or NaN.\n- `Floatlit of string: JSON number, Infinity, -Infinity or NaN,\n\t preserved as a string.\n- `String of string: JSON string. Bytes in the range 128-255 are preserved\n\t as-is without encoding validation for both reading\n\t and writing.\n- `Stringlit of string: JSON string literal including the double quotes.\n- `Assoc of (string * json) list: JSON object.\n- `List of json list: JSON array.\n- `Tuple of json list: Tuple (non-standard extension of JSON).\n\t Syntax: [(\"abc\", 123)].\n- `Variant of (string * json option): Variant (non-standard extension of JSON).\n\t Syntax: [<\"Foo\">] or [<\"Bar\":123>].\n*)\n\ntype json = t [@@deprecated \"json types are being renamed and will be removed in the next Yojson major version. Use type t instead\"]\n(**\n * Compatibility type alias for type `t`\n *)\n\n(*\n Note to adventurers: ocamldoc does not support inline comments\n on each polymorphic variant, and cppo doesn't allow to concatenate\n comments, so it would be complicated to document only the\n cases that are preserved by cppo in the type definition.\n*)\n# 1 \"safe.ml\"\nlet rec to_basic : t -> Basic.t = function\n `Null\n | `Bool _\n | `Int _\n | `Float _\n | `String _ as x -> x\n | `Intlit s -> `String s\n | `List l\n | `Tuple l ->\n `List (List.rev (List.rev_map to_basic l))\n | `Assoc l ->\n `Assoc (List.rev (List.rev_map (fun (k, v) -> (k, to_basic v)) l))\n | `Variant (k, None) -> `String k\n | `Variant (k, Some v) -> `List [ `String k; to_basic v ]\n# 1 \"write.ml\"\n(* included: type.ml *)\n\nlet hex n =\n Char.chr (\n if n < 10 then n + 48\n else n + 87\n )\n\nlet write_special src start stop ob str =\n Bi_outbuf.add_substring ob src !start (stop - !start);\n Bi_outbuf.add_string ob str;\n start := stop + 1\n\nlet write_control_char src start stop ob c =\n Bi_outbuf.add_substring ob src !start (stop - !start);\n let i = Bi_outbuf.alloc ob 6 in\n let dst = ob.o_s in\n Bytes.blit_string \"\\\\u00\" 0 dst i 4;\n Bytes.set dst (i+4) (hex (Char.code c lsr 4));\n Bytes.set dst (i+5) (hex (Char.code c land 0xf));\n start := stop + 1\n\nlet finish_string src start ob =\n try\n Bi_outbuf.add_substring ob src !start (String.length src - !start)\n with exc ->\n Printf.eprintf \"src=%S start=%i len=%i\\n%!\"\n src !start (String.length src - !start);\n raise exc\n\nlet write_string_body ob s =\n let start = ref 0 in\n for i = 0 to String.length s - 1 do\n match s.[i] with\n '\"' -> write_special s start i ob \"\\\\\\\"\"\n | '\\\\' -> write_special s start i ob \"\\\\\\\\\"\n | '\\b' -> write_special s start i ob \"\\\\b\"\n | '\\012' -> write_special s start i ob \"\\\\f\"\n | '\\n' -> write_special s start i ob \"\\\\n\"\n | '\\r' -> write_special s start i ob \"\\\\r\"\n | '\\t' -> write_special s start i ob \"\\\\t\"\n | '\\x00'..'\\x1F'\n | '\\x7F' as c -> write_control_char s start i ob c\n | _ -> ()\n done;\n finish_string s start ob\n\nlet write_string ob s =\n Bi_outbuf.add_char ob '\"';\n write_string_body ob s;\n Bi_outbuf.add_char ob '\"'\n\nlet json_string_of_string s =\n let ob = Bi_outbuf.create 10 in\n write_string ob s;\n Bi_outbuf.contents ob\n\nlet test_string () =\n let s = Bytes.create 256 in\n for i = 0 to 255 do\n Bytes.set s i (Char.chr i)\n done;\n json_string_of_string (Bytes.to_string s)\n\n\nlet write_null ob () =\n Bi_outbuf.add_string ob \"null\"\n\nlet write_bool ob x =\n Bi_outbuf.add_string ob (if x then \"true\" else \"false\")\n\n\nlet max_digits =\n max\n (String.length (string_of_int max_int))\n (String.length (string_of_int min_int))\n\nlet dec n =\n Char.chr (n + 48)\n\nlet rec write_digits s pos x =\n if x = 0 then pos\n else\n let d = x mod 10 in\n let pos = write_digits s pos (x / 10) in\n Bytes.set s pos (dec (abs d));\n pos + 1\n\nlet write_int ob x =\n Bi_outbuf.extend ob max_digits;\n if x > 0 then\n ob.o_len <- write_digits ob.o_s ob.o_len x\n else if x < 0 then (\n let s = ob.o_s in\n let pos = ob.o_len in\n Bytes.set s pos '-';\n ob.o_len <- write_digits s (pos + 1) x\n )\n else\n Bi_outbuf.add_char ob '0'\n\n\nlet json_string_of_int i =\n string_of_int i\n\n\n(*\n Ensure that the float is not printed as an int.\n This is not required by JSON, but useful in order to guarantee\n reversibility.\n*)\nlet float_needs_period s =\n try\n for i = 0 to String.length s - 1 do\n match s.[i] with\n '0'..'9' | '-' -> ()\n | _ -> raise Exit\n done;\n true\n with Exit ->\n false\n\n(*\n Both write_float_fast and write_float guarantee\n that a sufficient number of digits are printed in order to\n allow reversibility.\n\n The _fast version is faster but often produces unnecessarily long numbers.\n*)\nlet write_float_fast ob x =\n match classify_float x with\n FP_nan ->\n Bi_outbuf.add_string ob \"NaN\"\n | FP_infinite ->\n Bi_outbuf.add_string ob (if x > 0. then \"Infinity\" else \"-Infinity\")\n | _ ->\n let s = Printf.sprintf \"%.17g\" x in\n Bi_outbuf.add_string ob s;\n if float_needs_period s then\n Bi_outbuf.add_string ob \".0\"\n\nlet write_float ob x =\n match classify_float x with\n FP_nan ->\n Bi_outbuf.add_string ob \"NaN\"\n | FP_infinite ->\n Bi_outbuf.add_string ob (if x > 0. then \"Infinity\" else \"-Infinity\")\n | _ ->\n let s1 = Printf.sprintf \"%.16g\" x in\n let s =\n if float_of_string s1 = x then s1\n else Printf.sprintf \"%.17g\" x\n in\n Bi_outbuf.add_string ob s;\n if float_needs_period s then\n Bi_outbuf.add_string ob \".0\"\n\nlet write_normal_float_prec significant_figures ob x =\n let open Printf in\n let s =\n match significant_figures with\n 1 -> sprintf \"%.1g\" x\n | 2 -> sprintf \"%.2g\" x\n | 3 -> sprintf \"%.3g\" x\n | 4 -> sprintf \"%.4g\" x\n | 5 -> sprintf \"%.5g\" x\n | 6 -> sprintf \"%.6g\" x\n | 7 -> sprintf \"%.7g\" x\n | 8 -> sprintf \"%.8g\" x\n | 9 -> sprintf \"%.9g\" x\n | 10 -> sprintf \"%.10g\" x\n | 11 -> sprintf \"%.11g\" x\n | 12 -> sprintf \"%.12g\" x\n | 13 -> sprintf \"%.13g\" x\n | 14 -> sprintf \"%.14g\" x\n | 15 -> sprintf \"%.15g\" x\n | 16 -> sprintf \"%.16g\" x\n | _ -> sprintf \"%.17g\" x\n in\n Bi_outbuf.add_string ob s;\n if float_needs_period s then\n Bi_outbuf.add_string ob \".0\"\n\nlet write_float_prec significant_figures ob x =\n match classify_float x with\n FP_nan ->\n Bi_outbuf.add_string ob \"NaN\"\n | FP_infinite ->\n Bi_outbuf.add_string ob (if x > 0. then \"Infinity\" else \"-Infinity\")\n | _ ->\n write_normal_float_prec significant_figures ob x\n\nlet json_string_of_float x =\n let ob = Bi_outbuf.create 20 in\n write_float ob x;\n Bi_outbuf.contents ob\n\n\nlet write_std_float_fast ob x =\n match classify_float x with\n FP_nan ->\n json_error \"NaN value not allowed in standard JSON\"\n | FP_infinite ->\n json_error\n (if x > 0. then\n \"Infinity value not allowed in standard JSON\"\n else\n \"-Infinity value not allowed in standard JSON\")\n | _ ->\n let s = Printf.sprintf \"%.17g\" x in\n Bi_outbuf.add_string ob s;\n if float_needs_period s then\n Bi_outbuf.add_string ob \".0\"\n\nlet write_std_float ob x =\n match classify_float x with\n FP_nan ->\n json_error \"NaN value not allowed in standard JSON\"\n | FP_infinite ->\n json_error\n (if x > 0. then\n \"Infinity value not allowed in standard JSON\"\n else\n \"-Infinity value not allowed in standard JSON\")\n | _ ->\n let s1 = Printf.sprintf \"%.16g\" x in\n let s =\n if float_of_string s1 = x then s1\n else Printf.sprintf \"%.17g\" x\n in\n Bi_outbuf.add_string ob s;\n if float_needs_period s then\n Bi_outbuf.add_string ob \".0\"\n\nlet write_std_float_prec significant_figures ob x =\n match classify_float x with\n FP_nan ->\n json_error \"NaN value not allowed in standard JSON\"\n | FP_infinite ->\n json_error\n (if x > 0. then\n \"Infinity value not allowed in standard JSON\"\n else\n \"-Infinity value not allowed in standard JSON\")\n | _ ->\n write_normal_float_prec significant_figures ob x\n\nlet std_json_string_of_float x =\n let ob = Bi_outbuf.create 20 in\n write_std_float ob x;\n Bi_outbuf.contents ob\n\n\nlet test_float () =\n let l = [ 0.; 1.; -1. ] in\n let l = l @ List.map (fun x -> 2. *. x +. 1.) l in\n let l = l @ List.map (fun x -> x /. sqrt 2.) l in\n let l = l @ List.map (fun x -> x *. sqrt 3.) l in\n let l = l @ List.map cos l in\n let l = l @ List.map (fun x -> x *. 1.23e50) l in\n let l = l @ [ infinity; neg_infinity ] in\n List.iter (\n fun x ->\n let s = Printf.sprintf \"%.17g\" x in\n let y = float_of_string s in\n Printf.printf \"%g %g %S %B\\n\" x y s (x = y)\n )\n l\n\n(*\nlet () = test_float ()\n*)\n\nlet write_intlit = Bi_outbuf.add_string\nlet write_floatlit = Bi_outbuf.add_string\nlet write_stringlit = Bi_outbuf.add_string\n\nlet rec iter2_aux f_elt f_sep x = function\n [] -> ()\n | y :: l ->\n f_sep x;\n f_elt x y;\n iter2_aux f_elt f_sep x l\n\nlet iter2 f_elt f_sep x = function\n [] -> ()\n | y :: l ->\n f_elt x y;\n iter2_aux f_elt f_sep x l\n\nlet f_sep ob =\n Bi_outbuf.add_char ob ','\n\nlet rec write_json ob (x : t) =\n match x with\n `Null -> write_null ob ()\n | `Bool b -> write_bool ob b\n \n# 299 \"write.ml\"\n | `Int i -> write_int ob i\n \n# 302 \"write.ml\"\n | `Intlit s -> Bi_outbuf.add_string ob s\n \n# 305 \"write.ml\"\n | `Float f -> write_float ob f\n \n# 311 \"write.ml\"\n | `String s -> write_string ob s\n \n# 316 \"write.ml\"\n | `Assoc l -> write_assoc ob l\n | `List l -> write_list ob l\n \n# 319 \"write.ml\"\n | `Tuple l -> write_tuple ob l\n \n# 322 \"write.ml\"\n | `Variant (s, o) -> write_variant ob s o\n\n# 325 \"write.ml\"\nand write_assoc ob l =\n let f_elt ob (s, x) =\n write_string ob s;\n Bi_outbuf.add_char ob ':';\n write_json ob x\n in\n Bi_outbuf.add_char ob '{';\n iter2 f_elt f_sep ob l;\n Bi_outbuf.add_char ob '}';\n\nand write_list ob l =\n Bi_outbuf.add_char ob '[';\n iter2 write_json f_sep ob l;\n Bi_outbuf.add_char ob ']'\n\n# 341 \"write.ml\"\nand write_tuple ob l =\n Bi_outbuf.add_char ob '(';\n iter2 write_json f_sep ob l;\n Bi_outbuf.add_char ob ')'\n\n# 348 \"write.ml\"\nand write_variant ob s o =\n Bi_outbuf.add_char ob '<';\n write_string ob s;\n (match o with\n None -> ()\n | Some x ->\n Bi_outbuf.add_char ob ':';\n write_json ob x\n );\n Bi_outbuf.add_char ob '>'\n\n# 360 \"write.ml\"\nlet write_t = write_json\n\nlet rec write_std_json ob (x : t) =\n match x with\n `Null -> write_null ob ()\n | `Bool b -> write_bool ob b\n \n# 367 \"write.ml\"\n | `Int i -> write_int ob i\n \n# 370 \"write.ml\"\n | `Intlit s -> Bi_outbuf.add_string ob s\n \n# 373 \"write.ml\"\n | `Float f -> write_std_float ob f\n \n# 379 \"write.ml\"\n | `String s -> write_string ob s\n \n# 384 \"write.ml\"\n | `Assoc l -> write_std_assoc ob l\n | `List l -> write_std_list ob l\n \n# 387 \"write.ml\"\n | `Tuple l -> write_std_tuple ob l\n \n# 390 \"write.ml\"\n | `Variant (s, o) -> write_std_variant ob s o\n\n# 393 \"write.ml\"\nand write_std_assoc ob l =\n let f_elt ob (s, x) =\n write_string ob s;\n Bi_outbuf.add_char ob ':';\n write_std_json ob x\n in\n Bi_outbuf.add_char ob '{';\n iter2 f_elt f_sep ob l;\n Bi_outbuf.add_char ob '}';\n\nand write_std_list ob l =\n Bi_outbuf.add_char ob '[';\n iter2 write_std_json f_sep ob l;\n Bi_outbuf.add_char ob ']'\n\nand write_std_tuple ob l =\n Bi_outbuf.add_char ob '[';\n iter2 write_std_json f_sep ob l;\n Bi_outbuf.add_char ob ']'\n\n# 414 \"write.ml\"\nand write_std_variant ob s o =\n match o with\n None -> write_string ob s\n | Some x ->\n Bi_outbuf.add_char ob '[';\n write_string ob s;\n Bi_outbuf.add_char ob ',';\n write_std_json ob x;\n Bi_outbuf.add_char ob ']'\n\n\n# 426 \"write.ml\"\nlet to_outbuf ?(std = false) ob x =\n if std then (\n if not (is_object_or_array x) then\n json_error \"Root is not an object or array\"\n else\n write_std_json ob x\n )\n else\n write_json ob x\n\n\nlet to_string ?buf ?(len = 256) ?std x =\n let ob =\n match buf with\n None -> Bi_outbuf.create len\n | Some ob ->\n Bi_outbuf.clear ob;\n ob\n in\n to_outbuf ?std ob x;\n let s = Bi_outbuf.contents ob in\n Bi_outbuf.clear ob;\n s\n\nlet to_channel ?buf ?len ?std oc x =\n let ob =\n match buf with\n None -> Bi_outbuf.create_channel_writer ?len oc\n | Some ob -> ob\n in\n to_outbuf ?std ob x;\n Bi_outbuf.flush_channel_writer ob\n\nlet to_output ?buf ?len ?std out x =\n let ob =\n match buf with\n None -> Bi_outbuf.create_output_writer ?len out\n | Some ob -> ob\n in\n to_outbuf ?std ob x;\n Bi_outbuf.flush_output_writer ob\n\nlet to_file ?len ?std file x =\n let oc = open_out file in\n try\n to_channel ?len ?std oc x;\n close_out oc\n with e ->\n close_out_noerr oc;\n raise e\n\nlet stream_to_outbuf ?std ob st =\n Stream.iter (to_outbuf ?std ob) st\n\nlet stream_to_string ?buf ?(len = 256) ?std st =\n let ob =\n match buf with\n None -> Bi_outbuf.create len\n | Some ob ->\n Bi_outbuf.clear ob;\n ob\n in\n stream_to_outbuf ?std ob st;\n let s = Bi_outbuf.contents ob in\n Bi_outbuf.clear ob;\n s\n\nlet stream_to_channel ?buf ?len ?std oc st =\n let ob =\n match buf with\n None -> Bi_outbuf.create_channel_writer ?len oc\n | Some ob -> ob\n in\n stream_to_outbuf ?std ob st;\n Bi_outbuf.flush_channel_writer ob\n\nlet stream_to_file ?len ?std file st =\n let oc = open_out file in\n try\n stream_to_channel ?len ?std oc st;\n close_out oc\n with e ->\n close_out_noerr oc;\n raise e\n\n\nlet rec sort = function\n | `Assoc l ->\n let l = List.rev (List.rev_map (fun (k, v) -> (k, sort v)) l) in\n `Assoc (List.stable_sort (fun (a, _) (b, _) -> String.compare a b) l)\n | `List l ->\n `List (List.rev (List.rev_map sort l))\n \n# 519 \"write.ml\"\n | `Tuple l ->\n `Tuple (List.rev (List.rev_map sort l))\n \n# 523 \"write.ml\"\n | `Variant (k, Some v) as x ->\n let v' = sort v in\n if v == v' then x\n else\n `Variant (k, Some v')\n \n# 529 \"write.ml\"\n | x -> x\n# 1 \"monomorphic.ml\"\nlet rec pp fmt =\n function\n | `Null -> Format.pp_print_string fmt \"`Null\"\n | `Bool x ->\n Format.fprintf fmt \"`Bool (@[\";\n Format.fprintf fmt \"%B\" x;\n Format.fprintf fmt \"@])\"\n \n# 9 \"monomorphic.ml\"\n | `Int x ->\n Format.fprintf fmt \"`Int (@[\";\n Format.fprintf fmt \"%d\" x;\n Format.fprintf fmt \"@])\"\n \n# 15 \"monomorphic.ml\"\n | `Intlit x ->\n Format.fprintf fmt \"`Intlit (@[\";\n Format.fprintf fmt \"%S\" x;\n Format.fprintf fmt \"@])\"\n \n# 21 \"monomorphic.ml\"\n | `Float x ->\n Format.fprintf fmt \"`Float (@[\";\n Format.fprintf fmt \"%F\" x;\n Format.fprintf fmt \"@])\"\n \n# 33 \"monomorphic.ml\"\n | `String x ->\n Format.fprintf fmt \"`String (@[\";\n Format.fprintf fmt \"%S\" x;\n Format.fprintf fmt \"@])\"\n \n# 44 \"monomorphic.ml\"\n | `Assoc xs ->\n Format.fprintf fmt \"`Assoc (@[\";\n Format.fprintf fmt \"@[<2>[\";\n ignore (List.fold_left\n (fun sep (key, value) ->\n if sep then\n Format.fprintf fmt \";@ \";\n Format.fprintf fmt \"(@[\";\n Format.fprintf fmt \"%S\" key;\n Format.fprintf fmt \",@ \";\n pp fmt value;\n Format.fprintf fmt \"@])\";\n true) false xs);\n Format.fprintf fmt \"@,]@]\";\n Format.fprintf fmt \"@])\"\n | `List xs ->\n Format.fprintf fmt \"`List (@[\";\n Format.fprintf fmt \"@[<2>[\";\n ignore (List.fold_left\n (fun sep x ->\n if sep then\n Format.fprintf fmt \";@ \";\n pp fmt x;\n true) false xs);\n Format.fprintf fmt \"@,]@]\";\n Format.fprintf fmt \"@])\"\n \n# 71 \"monomorphic.ml\"\n | `Tuple tup ->\n Format.fprintf fmt \"`Tuple (@[\";\n Format.fprintf fmt \"@[<2>[\";\n ignore (List.fold_left\n (fun sep e ->\n if sep then\n Format.fprintf fmt \";@ \";\n pp fmt e;\n true) false tup);\n Format.fprintf fmt \"@,]@]\";\n Format.fprintf fmt \"@])\"\n \n# 84 \"monomorphic.ml\"\n | `Variant (name, value) ->\n Format.fprintf fmt \"`Variant (@[\";\n Format.fprintf fmt \"(@[\";\n Format.fprintf fmt \"%S\" name;\n Format.fprintf fmt \",@ \";\n (match value with\n | None -> Format.pp_print_string fmt \"None\"\n | Some x ->\n Format.pp_print_string fmt \"(Some \";\n pp fmt x;\n Format.pp_print_string fmt \")\");\n Format.fprintf fmt \"@])\";\n Format.fprintf fmt \"@])\"\n\n# 99 \"monomorphic.ml\"\nlet show x =\n Format.asprintf \"%a\" pp x\n\nlet rec equal a b =\n match a, b with\n | `Null, `Null -> true\n | `Bool a, `Bool b -> a = b\n \n# 107 \"monomorphic.ml\"\n | `Int a, `Int b -> a = b\n \n# 110 \"monomorphic.ml\"\n | `Intlit a, `Intlit b -> a = b\n \n# 113 \"monomorphic.ml\"\n | `Float a, `Float b -> a = b\n \n# 119 \"monomorphic.ml\"\n | `String a, `String b -> a = b\n \n# 124 \"monomorphic.ml\"\n | `Assoc xs, `Assoc ys ->\n let compare_keys = fun (key, _) (key', _) -> String.compare key key' in\n let xs = List.stable_sort compare_keys xs in\n let ys = List.stable_sort compare_keys ys in\n (match List.for_all2 (fun (key, value) (key', value') ->\n match key = key' with\n | false -> false\n | true -> equal value value') xs ys with\n | result -> result\n | exception Invalid_argument _ ->\n (* the lists were of different lengths, thus unequal *)\n false)\n \n# 137 \"monomorphic.ml\"\n | `Tuple xs, `Tuple ys\n \n# 139 \"monomorphic.ml\"\n | `List xs, `List ys ->\n (match List.for_all2 equal xs ys with\n | result -> result\n | exception Invalid_argument _ ->\n (* the lists were of different lengths, thus unequal *)\n false)\n \n# 146 \"monomorphic.ml\"\n | `Variant (name, value), `Variant (name', value') ->\n (match name = name' with\n | false -> false\n | true ->\n match value, value' with\n | None, None -> true\n | Some x, Some y -> equal x y\n | _ -> false)\n \n# 155 \"monomorphic.ml\"\n | _ -> false\n# 1 \"write2.ml\"\nlet pretty_format ?std (x : t) =\n Pretty.format ?std (x :> json_max)\n\nlet pretty_print ?std out (x : t) =\n Easy_format.Pretty.to_formatter out (pretty_format ?std x)\n\nlet pretty_to_string ?std (x : t) =\n Pretty.to_string ?std (x :> json_max)\n\nlet pretty_to_channel ?std oc (x : t) =\n Pretty.to_channel ?std oc (x :> json_max)\n\n# 1 \"lib/read.mll\"\n \n \n# 2 \"lib/read.mll\"\n module Lexing =\n (*\n We override Lexing.engine in order to avoid creating a new position\n record each time a rule is matched.\n This reduces total parsing time by about 31%.\n *)\n struct\n include Lexing\n\n external c_engine : lex_tables -> int -> lexbuf -> int = \"caml_lex_engine\"\n\n let engine tbl state buf =\n let result = c_engine tbl state buf in\n (*\n if result >= 0 then begin\n buf.lex_start_p <- buf.lex_curr_p;\n buf.lex_curr_p <- {buf.lex_curr_p\n with pos_cnum = buf.lex_abs_pos + buf.lex_curr_pos};\n end;\n *)\n result\n end\n\n open Printf\n open Lexing\n\n (* see description in common.mli *)\n type lexer_state = Lexer_state.t = {\n buf : Bi_outbuf.t;\n mutable lnum : int;\n mutable bol : int;\n mutable fname : string option;\n }\n\n let dec c =\n Char.code c - 48\n\n let hex c =\n match c with\n '0'..'9' -> int_of_char c - int_of_char '0'\n | 'a'..'f' -> int_of_char c - int_of_char 'a' + 10\n | 'A'..'F' -> int_of_char c - int_of_char 'A' + 10\n | _ -> assert false\n\n let custom_error descr v lexbuf =\n let offs = lexbuf.lex_abs_pos - 1 in\n let bol = v.bol in\n let pos1 = offs + lexbuf.lex_start_pos - bol - 1 in\n let pos2 = max pos1 (offs + lexbuf.lex_curr_pos - bol) in\n let file_line =\n match v.fname with\n None -> \"Line\"\n | Some s ->\n sprintf \"File %s, line\" s\n in\n let bytes =\n if pos1 = pos2 then\n sprintf \"byte %i\" (pos1+1)\n else\n sprintf \"bytes %i-%i\" (pos1+1) (pos2+1)\n in\n let msg = sprintf \"%s %i, %s:\\n%s\" file_line v.lnum bytes descr in\n json_error msg\n\n\n let lexer_error descr v lexbuf =\n custom_error\n (sprintf \"%s '%s'\" descr (Lexing.lexeme lexbuf))\n v lexbuf\n\n let read_junk = ref (fun _ -> assert false)\n\n let long_error descr v lexbuf =\n let junk = Lexing.lexeme lexbuf in\n let extra_junk = !read_junk lexbuf in\n custom_error\n (sprintf \"%s '%s%s'\" descr junk extra_junk)\n v lexbuf\n\n let min10 = min_int / 10 - (if min_int mod 10 = 0 then 0 else 1)\n let max10 = max_int / 10 + (if max_int mod 10 = 0 then 0 else 1)\n\n exception Int_overflow\n\n let extract_positive_int lexbuf =\n let start = lexbuf.lex_start_pos in\n let stop = lexbuf.lex_curr_pos in\n let s = lexbuf.lex_buffer in\n let n = ref 0 in\n for i = start to stop - 1 do\n if !n >= max10 then\n raise Int_overflow\n else\n n := 10 * !n + dec (Bytes.get s i)\n done;\n if !n < 0 then\n raise Int_overflow\n else\n !n\n\n let make_positive_int v lexbuf =\n \n# 104 \"lib/read.mll\"\n try `Int (extract_positive_int lexbuf)\n with Int_overflow ->\n \n# 108 \"lib/read.mll\"\n `Intlit (lexeme lexbuf)\n\n \n# 113 \"lib/read.mll\"\n let extract_negative_int lexbuf =\n let start = lexbuf.lex_start_pos + 1 in\n let stop = lexbuf.lex_curr_pos in\n let s = lexbuf.lex_buffer in\n let n = ref 0 in\n for i = start to stop - 1 do\n if !n <= min10 then\n raise Int_overflow\n else\n n := 10 * !n - dec (Bytes.get s i)\n done;\n if !n > 0 then\n raise Int_overflow\n else\n !n\n\n let make_negative_int v lexbuf =\n \n# 131 \"lib/read.mll\"\n try `Int (extract_negative_int lexbuf)\n with Int_overflow ->\n \n# 135 \"lib/read.mll\"\n `Intlit (lexeme lexbuf)\n\n\n \n# 141 \"lib/read.mll\"\n let set_file_name v fname =\n v.fname <- fname\n\n let newline v lexbuf =\n v.lnum <- v.lnum + 1;\n v.bol <- lexbuf.lex_abs_pos + lexbuf.lex_curr_pos\n\n let add_lexeme buf lexbuf =\n let len = lexbuf.lex_curr_pos - lexbuf.lex_start_pos in\n Bi_outbuf.add_subbytes buf lexbuf.lex_buffer lexbuf.lex_start_pos len\n\n let map_lexeme f lexbuf =\n let len = lexbuf.lex_curr_pos - lexbuf.lex_start_pos in\n f (Bytes.to_string lexbuf.lex_buffer) lexbuf.lex_start_pos len\n\n type variant_kind = [ `Edgy_bracket | `Square_bracket | `Double_quote ]\n type tuple_kind = [ `Parenthesis | `Square_bracket ]\n\n\n# 161 \"lib/read.ml\"\n# 161 \"lib/read.ml\"\nlet __ocaml_lex_tables = {\n Lexing.lex_base =\n \"\\000\\000\\236\\255\\237\\255\\003\\000\\239\\255\\016\\000\\242\\255\\243\\255\\\n \\244\\255\\245\\255\\000\\000\\031\\000\\249\\255\\085\\000\\001\\000\\000\\000\\\n \\000\\000\\001\\000\\000\\000\\001\\000\\002\\000\\255\\255\\000\\000\\000\\000\\\n \\003\\000\\254\\255\\001\\000\\004\\000\\253\\255\\011\\000\\252\\255\\003\\000\\\n \\001\\000\\003\\000\\002\\000\\003\\000\\000\\000\\251\\255\\021\\000\\097\\000\\\n \\010\\000\\022\\000\\020\\000\\016\\000\\022\\000\\012\\000\\008\\000\\250\\255\\\n \\119\\000\\129\\000\\139\\000\\161\\000\\171\\000\\181\\000\\193\\000\\209\\000\\\n \\240\\255\\011\\000\\038\\000\\252\\255\\065\\000\\254\\255\\255\\255\\110\\000\\\n \\252\\255\\163\\000\\254\\255\\255\\255\\234\\000\\247\\255\\248\\255\\048\\001\\\n \\250\\255\\251\\255\\252\\255\\253\\255\\254\\255\\255\\255\\071\\001\\126\\001\\\n \\149\\001\\249\\255\\039\\000\\253\\255\\254\\255\\038\\000\\187\\001\\210\\001\\\n \\248\\001\\015\\002\\255\\255\\220\\000\\253\\255\\255\\255\\245\\000\\039\\002\\\n \\109\\002\\014\\001\\088\\002\\164\\002\\187\\002\\225\\002\\013\\000\\252\\255\\\n \\253\\255\\254\\255\\255\\255\\014\\000\\253\\255\\254\\255\\255\\255\\030\\000\\\n \\253\\255\\254\\255\\255\\255\\015\\000\\253\\255\\254\\255\\255\\255\\017\\001\\\n \\251\\255\\252\\255\\253\\255\\254\\255\\255\\255\\019\\000\\252\\255\\253\\255\\\n \\254\\255\\015\\000\\255\\255\\016\\000\\255\\255\\008\\001\\005\\000\\253\\255\\\n \\023\\000\\254\\255\\020\\000\\255\\255\\046\\000\\253\\255\\254\\255\\042\\000\\\n \\052\\000\\053\\000\\255\\255\\053\\000\\048\\000\\091\\000\\092\\000\\255\\255\\\n \\027\\001\\250\\255\\251\\255\\137\\000\\104\\000\\089\\000\\088\\000\\106\\000\\\n \\255\\255\\143\\000\\137\\000\\177\\000\\254\\255\\183\\000\\168\\000\\166\\000\\\n \\183\\000\\002\\000\\253\\255\\177\\000\\172\\000\\187\\000\\004\\000\\252\\255\\\n \\053\\002\\251\\255\\252\\255\\253\\255\\103\\001\\255\\255\\248\\002\\254\\255\\\n \\006\\003\\030\\003\\252\\255\\253\\255\\254\\255\\255\\255\\040\\003\\050\\003\\\n \\074\\003\\252\\255\\253\\255\\254\\255\\255\\255\\061\\003\\084\\003\\108\\003\\\n \\249\\255\\250\\255\\251\\255\\244\\000\\120\\003\\142\\003\\179\\000\\194\\000\\\n \\015\\000\\255\\255\\190\\000\\188\\000\\187\\000\\193\\000\\183\\000\\179\\000\\\n \\254\\255\\191\\000\\201\\000\\200\\000\\196\\000\\203\\000\\193\\000\\189\\000\\\n \\253\\255\\157\\003\\095\\003\\174\\003\\196\\003\\206\\003\\216\\003\\228\\003\\\n \\239\\003\\060\\000\\253\\255\\254\\255\\255\\255\\012\\004\\252\\255\\253\\255\\\n \\087\\004\\255\\255\\145\\004\\252\\255\\253\\255\\221\\004\\255\\255\\229\\000\\\n \\253\\255\\254\\255\\255\\255\\231\\000\\253\\255\\254\\255\\255\\255\\002\\000\\\n \\255\\255\\018\\001\\252\\255\\253\\255\\254\\255\\255\\255\\034\\001\\253\\255\\\n \\254\\255\\255\\255\\000\\000\\255\\255\\003\\000\\254\\255\\255\\255\\038\\001\\\n \\252\\255\\253\\255\\254\\255\\255\\255\\120\\001\\251\\255\\252\\255\\253\\255\\\n \\254\\255\\255\\255\\208\\000\\253\\255\\254\\255\\255\\255\\211\\000\\253\\255\\\n \\254\\255\\255\\255\\189\\000\\255\\255\\143\\001\\252\\255\\253\\255\\254\\255\\\n \\255\\255\\013\\001\\253\\255\\254\\255\\255\\255\\095\\001\\252\\255\\253\\255\\\n \\254\\255\\255\\255\\050\\001\\253\\255\\254\\255\\255\\255\\026\\001\\253\\255\\\n \\254\\255\\255\\255\\233\\000\\253\\255\\254\\255\\255\\255\\222\\000\\253\\255\\\n \\254\\255\\255\\255\\079\\005\\237\\255\\238\\255\\010\\000\\240\\255\\044\\001\\\n \\243\\255\\244\\255\\245\\255\\246\\255\\061\\001\\002\\004\\249\\255\\045\\005\\\n \\209\\000\\228\\000\\211\\000\\232\\000\\225\\000\\223\\000\\240\\000\\255\\255\\\n \\235\\000\\234\\000\\008\\001\\254\\255\\004\\001\\023\\001\\253\\255\\054\\001\\\n \\252\\255\\031\\001\\029\\001\\032\\001\\039\\001\\049\\001\\045\\001\\251\\255\\\n \\057\\001\\082\\001\\080\\001\\078\\001\\084\\001\\074\\001\\086\\001\\250\\255\\\n \\110\\005\\012\\004\\123\\005\\155\\005\\165\\005\\177\\005\\187\\005\\197\\005\\\n \\241\\255\\199\\001\\077\\002\\253\\255\\255\\255\\154\\002\\222\\005\\209\\005\\\n \\155\\002\\239\\005\\053\\006\\076\\006\\114\\006\\016\\002\\252\\255\\253\\255\\\n \\254\\255\\255\\255\\152\\006\\252\\255\\253\\255\\227\\006\\255\\255\\085\\007\\\n \\244\\255\\245\\255\\011\\000\\247\\255\\076\\002\\250\\255\\251\\255\\252\\255\\\n \\253\\255\\254\\255\\031\\002\\243\\005\\051\\007\\100\\001\\115\\001\\104\\001\\\n \\133\\001\\118\\001\\154\\001\\171\\001\\255\\255\\173\\001\\176\\001\\191\\001\\\n \\185\\001\\187\\001\\253\\001\\230\\001\\230\\001\\234\\001\\247\\001\\237\\001\\\n \\234\\001\\009\\002\\019\\002\\019\\002\\015\\002\\021\\002\\011\\002\\007\\002\\\n \\142\\006\\152\\006\\116\\007\\170\\007\\180\\007\\190\\007\\200\\007\\210\\007\\\n \\248\\255\\120\\002\\167\\002\\253\\255\\255\\255\\216\\002\\082\\007\\220\\007\\\n \\236\\002\\244\\007\\058\\008\\081\\008\\119\\008\\076\\002\\252\\255\\253\\255\\\n \\254\\255\\255\\255\\157\\008\\252\\255\\253\\255\\232\\008\\255\\255\\135\\002\\\n \\120\\002\\253\\255\\100\\002\\254\\255\\182\\002\\255\\255\\011\\002\\255\\255\\\n \\204\\002\\252\\255\\253\\255\\254\\255\\255\\255\\046\\002\\255\\255\\178\\002\\\n \\252\\255\\253\\255\\254\\255\\255\\255\\023\\000\\255\\255\\183\\002\\252\\255\\\n \\253\\255\\254\\255\\255\\255\\187\\002\\253\\255\\254\\255\\255\\255\\121\\002\\\n \\253\\255\\254\\255\\255\\255\\184\\002\\252\\255\\253\\255\\254\\255\\019\\000\\\n \\255\\255\\140\\001\\146\\001\\255\\255\\150\\001\\151\\001\\154\\001\\168\\001\\\n \\170\\001\\171\\001\\172\\001\\173\\001\\181\\001\\184\\001\\185\\001\\187\\001\\\n \\191\\001\\193\\001\\195\\001\\196\\001\\197\\001\\200\\001\\203\\001\\223\\001\\\n \\225\\001\\228\\001\\249\\001\\251\\001\\002\\002\\004\\002\\011\\002\\012\\002\\\n \\013\\002\\000\\000\";\n Lexing.lex_backtrk =\n \"\\255\\255\\255\\255\\255\\255\\017\\000\\255\\255\\019\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\007\\000\\007\\000\\255\\255\\019\\000\\019\\000\\019\\000\\\n \\019\\000\\019\\000\\019\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\008\\000\\008\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\009\\000\\255\\255\\009\\000\\255\\255\\009\\000\\255\\255\\\n \\255\\255\\014\\000\\255\\255\\255\\255\\002\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\002\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\007\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\001\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\003\\000\\255\\255\\001\\000\\255\\255\\004\\000\\003\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\\n \\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\004\\000\\004\\000\\004\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\003\\000\\255\\255\\000\\000\\255\\255\\\n \\001\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\002\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\002\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\003\\000\\003\\000\\005\\000\\005\\000\\005\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\003\\000\\255\\255\\003\\000\\255\\255\\003\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\001\\000\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\001\\000\\255\\255\\002\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\001\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\016\\000\\255\\255\\018\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\007\\000\\007\\000\\255\\255\\018\\000\\\n \\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\008\\000\\255\\255\\008\\000\\255\\255\\008\\000\\255\\255\\\n \\255\\255\\013\\000\\255\\255\\255\\255\\255\\255\\001\\000\\001\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\009\\000\\255\\255\\011\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\000\\000\\000\\000\\011\\000\\011\\000\\011\\000\\011\\000\\\n \\011\\000\\011\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\000\\000\\255\\255\\000\\000\\255\\255\\000\\000\\255\\255\\\n \\255\\255\\006\\000\\255\\255\\255\\255\\255\\255\\001\\000\\001\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\004\\000\\\n \\003\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\003\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\";\n Lexing.lex_default =\n \"\\001\\000\\000\\000\\000\\000\\255\\255\\000\\000\\255\\255\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\\n \\255\\255\\000\\000\\255\\255\\255\\255\\000\\000\\255\\255\\000\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\000\\000\\057\\000\\060\\000\\000\\000\\060\\000\\000\\000\\000\\000\\065\\000\\\n \\000\\000\\065\\000\\000\\000\\000\\000\\070\\000\\000\\000\\000\\000\\255\\255\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\255\\255\\\n \\255\\255\\000\\000\\084\\000\\000\\000\\000\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\000\\000\\094\\000\\000\\000\\000\\000\\097\\000\\255\\255\\\n \\255\\255\\097\\000\\255\\255\\255\\255\\255\\255\\255\\255\\104\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\109\\000\\000\\000\\000\\000\\000\\000\\113\\000\\\n \\000\\000\\000\\000\\000\\000\\117\\000\\000\\000\\000\\000\\000\\000\\121\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\126\\000\\000\\000\\000\\000\\\n \\000\\000\\255\\255\\000\\000\\255\\255\\000\\000\\255\\255\\255\\255\\000\\000\\\n \\255\\255\\000\\000\\138\\000\\000\\000\\142\\000\\000\\000\\000\\000\\255\\255\\\n \\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\\n \\154\\000\\000\\000\\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\000\\000\\255\\255\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\\n \\178\\000\\000\\000\\000\\000\\000\\000\\255\\255\\000\\000\\255\\255\\000\\000\\\n \\255\\255\\187\\000\\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\255\\255\\\n \\194\\000\\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\255\\255\\201\\000\\\n \\000\\000\\000\\000\\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\235\\000\\000\\000\\000\\000\\000\\000\\239\\000\\000\\000\\000\\000\\\n \\255\\255\\000\\000\\244\\000\\000\\000\\000\\000\\255\\255\\000\\000\\249\\000\\\n \\000\\000\\000\\000\\000\\000\\253\\000\\000\\000\\000\\000\\000\\000\\255\\255\\\n \\000\\000\\003\\001\\000\\000\\000\\000\\000\\000\\000\\000\\008\\001\\000\\000\\\n \\000\\000\\000\\000\\255\\255\\000\\000\\255\\255\\000\\000\\000\\000\\017\\001\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\022\\001\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\028\\001\\000\\000\\000\\000\\000\\000\\032\\001\\000\\000\\\n \\000\\000\\000\\000\\255\\255\\000\\000\\038\\001\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\043\\001\\000\\000\\000\\000\\000\\000\\047\\001\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\052\\001\\000\\000\\000\\000\\000\\000\\056\\001\\000\\000\\\n \\000\\000\\000\\000\\060\\001\\000\\000\\000\\000\\000\\000\\064\\001\\000\\000\\\n \\000\\000\\000\\000\\067\\001\\000\\000\\000\\000\\255\\255\\000\\000\\255\\255\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\255\\255\\000\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\\n \\255\\255\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\000\\000\\255\\255\\\n \\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\000\\000\\121\\001\\125\\001\\000\\000\\000\\000\\128\\001\\255\\255\\255\\255\\\n \\128\\001\\255\\255\\255\\255\\255\\255\\255\\255\\135\\001\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\140\\001\\000\\000\\000\\000\\255\\255\\000\\000\\144\\001\\\n \\000\\000\\000\\000\\255\\255\\000\\000\\255\\255\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\000\\000\\193\\001\\197\\001\\000\\000\\000\\000\\200\\001\\255\\255\\255\\255\\\n \\200\\001\\255\\255\\255\\255\\255\\255\\255\\255\\207\\001\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\212\\001\\000\\000\\000\\000\\255\\255\\000\\000\\255\\255\\\n \\255\\255\\000\\000\\255\\255\\000\\000\\220\\001\\000\\000\\255\\255\\000\\000\\\n \\226\\001\\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\000\\000\\233\\001\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\000\\000\\240\\001\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\245\\001\\000\\000\\000\\000\\000\\000\\249\\001\\\n \\000\\000\\000\\000\\000\\000\\252\\001\\000\\000\\000\\000\\000\\000\\255\\255\\\n \\000\\000\\002\\002\\004\\002\\000\\000\\005\\002\\006\\002\\007\\002\\008\\002\\\n \\009\\002\\010\\002\\011\\002\\012\\002\\013\\002\\014\\002\\015\\002\\016\\002\\\n \\017\\002\\018\\002\\019\\002\\020\\002\\021\\002\\022\\002\\023\\002\\024\\002\\\n \\025\\002\\026\\002\\027\\002\\028\\002\\029\\002\\030\\002\\031\\002\\032\\002\\\n \\033\\002\\003\\002\";\n Lexing.lex_trans =\n \"\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\003\\000\\004\\000\\000\\000\\003\\000\\003\\000\\134\\000\\000\\000\\\n \\003\\000\\000\\000\\134\\000\\069\\001\\146\\001\\255\\255\\000\\000\\069\\001\\\n \\146\\001\\000\\000\\000\\000\\000\\000\\000\\000\\127\\000\\139\\000\\000\\000\\\n \\003\\000\\000\\000\\012\\000\\003\\000\\170\\000\\134\\000\\175\\000\\000\\000\\\n \\007\\000\\011\\001\\069\\001\\146\\001\\014\\001\\013\\000\\049\\000\\005\\000\\\n \\010\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\\n \\011\\000\\011\\000\\056\\000\\118\\000\\006\\000\\129\\000\\130\\000\\057\\000\\\n \\237\\001\\137\\000\\000\\002\\049\\000\\000\\000\\048\\000\\138\\000\\106\\000\\\n \\062\\000\\014\\000\\110\\000\\105\\000\\000\\000\\049\\000\\015\\000\\011\\000\\\n \\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\\n \\011\\000\\030\\000\\048\\000\\008\\000\\114\\000\\209\\000\\236\\000\\000\\001\\\n \\013\\001\\029\\000\\022\\000\\255\\255\\048\\000\\048\\000\\017\\000\\021\\000\\\n \\025\\000\\032\\000\\033\\000\\035\\000\\023\\000\\027\\000\\016\\000\\031\\000\\\n \\028\\000\\034\\000\\019\\000\\024\\000\\018\\000\\026\\000\\020\\000\\036\\000\\\n \\041\\000\\037\\000\\048\\000\\009\\000\\042\\000\\043\\000\\044\\000\\045\\000\\\n \\046\\000\\047\\000\\061\\000\\085\\000\\048\\000\\038\\000\\039\\000\\039\\000\\\n \\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\049\\000\\\n \\067\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\\n \\039\\000\\039\\000\\039\\000\\086\\000\\143\\000\\255\\255\\040\\000\\144\\000\\\n \\145\\000\\146\\000\\055\\000\\148\\000\\055\\000\\149\\000\\048\\000\\054\\000\\\n \\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\\n \\054\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\\n \\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\\n \\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\255\\255\\048\\000\\150\\000\\\n \\151\\000\\161\\000\\066\\000\\158\\000\\053\\000\\159\\000\\053\\000\\160\\000\\\n \\051\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\\n \\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\\n \\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\\n \\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\165\\000\\\n \\051\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\\n \\054\\000\\054\\000\\054\\000\\162\\000\\163\\000\\166\\000\\093\\000\\255\\255\\\n \\002\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\\n \\054\\000\\054\\000\\054\\000\\255\\255\\077\\000\\103\\000\\108\\000\\116\\000\\\n \\132\\000\\134\\000\\135\\000\\128\\000\\139\\000\\134\\000\\164\\000\\093\\000\\\n \\171\\000\\077\\000\\167\\000\\168\\000\\169\\000\\172\\000\\112\\000\\173\\000\\\n \\174\\000\\210\\000\\226\\000\\208\\000\\211\\000\\212\\000\\059\\000\\083\\000\\\n \\134\\000\\213\\000\\214\\000\\215\\000\\216\\000\\218\\000\\141\\000\\219\\000\\\n \\093\\000\\220\\000\\221\\000\\123\\000\\222\\000\\223\\000\\224\\000\\136\\000\\\n \\095\\000\\225\\000\\035\\001\\065\\001\\234\\000\\155\\000\\005\\001\\097\\001\\\n \\250\\000\\255\\255\\254\\000\\057\\001\\061\\001\\095\\001\\077\\000\\044\\001\\\n \\092\\001\\088\\001\\009\\001\\029\\001\\076\\000\\124\\000\\033\\001\\018\\001\\\n \\075\\000\\098\\000\\019\\001\\085\\001\\086\\001\\087\\001\\120\\001\\089\\001\\\n \\074\\000\\225\\000\\053\\001\\121\\001\\073\\000\\090\\001\\072\\000\\071\\000\\\n \\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\\n \\078\\000\\078\\000\\098\\000\\113\\001\\122\\000\\091\\001\\064\\000\\004\\001\\\n \\093\\001\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\079\\000\\\n \\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\\n \\079\\000\\156\\000\\112\\001\\094\\001\\096\\001\\098\\001\\099\\001\\049\\001\\\n \\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\100\\001\\157\\000\\\n \\101\\001\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\183\\000\\\n \\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\\n \\184\\000\\024\\001\\112\\001\\255\\255\\025\\001\\102\\001\\103\\001\\105\\001\\\n \\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\080\\000\\080\\000\\\n \\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\\n \\106\\001\\107\\001\\048\\001\\040\\001\\108\\001\\109\\001\\110\\001\\080\\000\\\n \\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\081\\000\\081\\000\\081\\000\\\n \\081\\000\\081\\000\\081\\000\\081\\000\\081\\000\\081\\000\\081\\000\\111\\001\\\n \\027\\001\\255\\255\\171\\001\\031\\001\\170\\001\\023\\001\\081\\000\\081\\000\\\n \\081\\000\\081\\000\\081\\000\\081\\000\\092\\000\\168\\001\\063\\001\\080\\000\\\n \\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\248\\000\\165\\001\\252\\000\\\n \\162\\001\\059\\001\\069\\000\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\\n \\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\255\\255\\081\\000\\081\\000\\\n \\081\\000\\081\\000\\081\\000\\081\\000\\087\\000\\087\\000\\087\\000\\087\\000\\\n \\087\\000\\087\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\\n \\088\\000\\088\\000\\088\\000\\088\\000\\039\\001\\042\\001\\255\\255\\163\\001\\\n \\164\\001\\120\\000\\002\\001\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\\n \\088\\000\\166\\001\\055\\001\\153\\000\\087\\000\\087\\000\\087\\000\\087\\000\\\n \\087\\000\\087\\000\\007\\001\\167\\001\\164\\001\\169\\001\\016\\001\\164\\001\\\n \\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\\n \\089\\000\\089\\000\\051\\001\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\\n \\088\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\090\\000\\\n \\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\\n \\090\\000\\097\\000\\137\\001\\164\\001\\172\\001\\185\\001\\136\\001\\173\\001\\\n \\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\097\\000\\179\\000\\\n \\174\\001\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\046\\001\\\n \\175\\001\\176\\001\\180\\000\\164\\001\\184\\001\\181\\000\\182\\000\\182\\000\\\n \\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\124\\001\\\n \\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\192\\001\\178\\001\\\n \\021\\001\\179\\001\\097\\000\\193\\001\\180\\001\\181\\001\\182\\001\\183\\001\\\n \\164\\001\\216\\001\\255\\255\\097\\000\\184\\001\\216\\001\\209\\001\\097\\000\\\n \\223\\001\\097\\000\\208\\001\\230\\001\\003\\002\\097\\000\\219\\001\\037\\001\\\n \\216\\001\\217\\001\\003\\002\\220\\001\\216\\001\\097\\000\\003\\002\\003\\002\\\n \\216\\001\\097\\000\\003\\002\\097\\000\\096\\000\\099\\000\\099\\000\\099\\000\\\n \\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\216\\001\\\n \\003\\002\\126\\001\\003\\002\\003\\002\\003\\002\\003\\002\\099\\000\\099\\000\\\n \\099\\000\\099\\000\\099\\000\\099\\000\\097\\000\\003\\002\\218\\001\\250\\001\\\n \\003\\002\\003\\002\\097\\000\\003\\002\\124\\001\\124\\001\\097\\000\\003\\002\\\n \\221\\001\\003\\002\\253\\001\\003\\002\\003\\002\\003\\002\\097\\000\\255\\255\\\n \\003\\002\\196\\001\\097\\000\\003\\002\\097\\000\\096\\000\\099\\000\\099\\000\\\n \\099\\000\\099\\000\\099\\000\\099\\000\\100\\000\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\235\\001\\003\\002\\\n \\241\\001\\003\\002\\255\\001\\242\\001\\003\\002\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\100\\000\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\\n \\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\246\\001\\129\\001\\129\\001\\\n \\228\\001\\003\\002\\196\\001\\003\\002\\101\\000\\101\\000\\101\\000\\101\\000\\\n \\101\\000\\101\\000\\003\\002\\198\\001\\003\\002\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\100\\000\\003\\002\\003\\002\\003\\002\\196\\001\\234\\001\\\n \\134\\001\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\\n \\097\\000\\097\\000\\097\\000\\000\\000\\101\\000\\101\\000\\101\\000\\101\\000\\\n \\101\\000\\101\\000\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\\n \\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\\n \\182\\000\\182\\000\\000\\000\\000\\000\\201\\001\\177\\000\\184\\000\\184\\000\\\n \\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\\n \\188\\000\\000\\000\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\\n \\201\\001\\227\\001\\000\\000\\191\\000\\206\\001\\123\\001\\189\\000\\190\\000\\\n \\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\\n \\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\\n \\190\\000\\190\\000\\189\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\\n \\190\\000\\190\\000\\190\\000\\190\\000\\195\\000\\197\\000\\197\\000\\197\\000\\\n \\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\198\\000\\\n \\255\\255\\248\\001\\196\\000\\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\\n \\197\\000\\197\\000\\197\\000\\197\\000\\196\\000\\197\\000\\197\\000\\197\\000\\\n \\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\202\\000\\227\\000\\\n \\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\\n \\227\\000\\205\\000\\255\\255\\255\\255\\203\\000\\204\\000\\204\\000\\204\\000\\\n \\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\226\\000\\195\\001\\\n \\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\\n \\204\\000\\204\\000\\232\\001\\000\\000\\000\\000\\206\\000\\221\\001\\239\\001\\\n \\254\\001\\000\\000\\207\\000\\244\\001\\000\\000\\225\\000\\203\\000\\204\\000\\\n \\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\\n \\232\\000\\000\\000\\232\\000\\000\\000\\225\\001\\231\\000\\231\\000\\231\\000\\\n \\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\217\\000\\\n \\255\\255\\000\\000\\000\\000\\000\\000\\000\\000\\225\\000\\227\\000\\227\\000\\\n \\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\000\\000\\000\\000\\230\\000\\\n \\000\\000\\230\\000\\000\\000\\228\\000\\229\\000\\229\\000\\229\\000\\229\\000\\\n \\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\\n \\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\\n \\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\\n \\229\\000\\229\\000\\000\\000\\228\\000\\231\\000\\231\\000\\231\\000\\231\\000\\\n \\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\186\\000\\231\\000\\\n \\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\\n \\231\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\241\\000\\000\\000\\\n \\113\\001\\000\\000\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\\n \\077\\001\\077\\001\\077\\001\\077\\001\\114\\001\\114\\001\\114\\001\\114\\001\\\n \\114\\001\\114\\001\\114\\001\\114\\001\\114\\001\\114\\001\\000\\000\\112\\001\\\n \\000\\000\\000\\000\\193\\000\\000\\000\\000\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\112\\001\\\n \\000\\000\\000\\000\\000\\000\\240\\000\\200\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\000\\000\\246\\000\\000\\000\\000\\000\\240\\000\\000\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\245\\000\\000\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\238\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\245\\000\\000\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\069\\001\\070\\001\\000\\000\\000\\000\\069\\001\\076\\001\\077\\001\\077\\001\\\n \\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\069\\001\\\n \\000\\000\\078\\001\\000\\000\\000\\000\\000\\000\\000\\000\\104\\001\\073\\001\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\079\\001\\000\\000\\071\\001\\076\\001\\\n \\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\\n \\077\\001\\000\\000\\000\\000\\072\\001\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\243\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\080\\001\\119\\001\\000\\000\\119\\001\\000\\000\\081\\001\\118\\001\\118\\001\\\n \\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\\n \\000\\000\\000\\000\\074\\001\\114\\001\\114\\001\\114\\001\\114\\001\\114\\001\\\n \\114\\001\\114\\001\\114\\001\\114\\001\\114\\001\\083\\001\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\082\\001\\000\\000\\000\\000\\\n \\115\\001\\000\\000\\000\\000\\084\\001\\000\\000\\000\\000\\117\\001\\000\\000\\\n \\117\\001\\000\\000\\075\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\\n \\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\\n \\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\000\\000\\\n \\115\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\\n \\116\\001\\116\\001\\116\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\\n \\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\\n \\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\000\\000\\\n \\128\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\\n \\130\\001\\130\\001\\130\\001\\000\\000\\000\\000\\128\\001\\000\\000\\000\\000\\\n \\000\\000\\128\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\001\\000\\000\\\n \\000\\000\\185\\001\\000\\000\\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\\n \\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\\n \\184\\001\\000\\000\\128\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\128\\001\\000\\000\\000\\000\\000\\000\\128\\001\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\128\\001\\128\\001\\000\\000\\000\\000\\068\\001\\\n \\128\\001\\128\\001\\128\\001\\127\\001\\000\\000\\128\\001\\000\\000\\000\\000\\\n \\184\\001\\000\\000\\000\\000\\000\\000\\000\\000\\128\\001\\000\\000\\000\\000\\\n \\000\\000\\128\\001\\000\\000\\128\\001\\127\\001\\131\\001\\131\\001\\131\\001\\\n \\131\\001\\131\\001\\131\\001\\131\\001\\131\\001\\131\\001\\131\\001\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\131\\001\\131\\001\\\n \\131\\001\\131\\001\\131\\001\\131\\001\\132\\001\\132\\001\\132\\001\\132\\001\\\n \\132\\001\\132\\001\\132\\001\\132\\001\\132\\001\\132\\001\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\132\\001\\132\\001\\132\\001\\\n \\132\\001\\132\\001\\132\\001\\000\\000\\000\\000\\000\\000\\131\\001\\131\\001\\\n \\131\\001\\131\\001\\131\\001\\131\\001\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\128\\001\\128\\001\\128\\001\\128\\001\\128\\001\\128\\001\\\n \\128\\001\\128\\001\\128\\001\\128\\001\\000\\000\\132\\001\\132\\001\\132\\001\\\n \\132\\001\\132\\001\\132\\001\\128\\001\\128\\001\\128\\001\\128\\001\\128\\001\\\n \\128\\001\\191\\001\\142\\001\\191\\001\\000\\000\\000\\000\\190\\001\\190\\001\\\n \\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\\n \\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\\n \\186\\001\\186\\001\\000\\000\\128\\001\\128\\001\\128\\001\\128\\001\\128\\001\\\n \\128\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\000\\000\\000\\000\\000\\000\\000\\000\\141\\001\\\n \\000\\000\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\141\\001\\000\\000\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\146\\001\\147\\001\\\n \\000\\000\\000\\000\\146\\001\\154\\001\\155\\001\\155\\001\\155\\001\\155\\001\\\n \\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\200\\001\\146\\001\\000\\000\\153\\001\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\177\\001\\150\\001\\000\\000\\000\\000\\\n \\000\\000\\200\\001\\156\\001\\000\\000\\148\\001\\154\\001\\155\\001\\155\\001\\\n \\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\000\\000\\\n \\000\\000\\149\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\139\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\157\\001\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\158\\001\\186\\001\\186\\001\\186\\001\\186\\001\\\n \\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\200\\001\\000\\000\\\n \\151\\001\\000\\000\\000\\000\\000\\000\\200\\001\\000\\000\\000\\000\\000\\000\\\n \\200\\001\\187\\001\\000\\000\\160\\001\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\200\\001\\000\\000\\000\\000\\159\\001\\200\\001\\000\\000\\200\\001\\199\\001\\\n \\000\\000\\161\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\152\\001\\000\\000\\000\\000\\000\\000\\000\\000\\189\\001\\000\\000\\189\\001\\\n \\000\\000\\187\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\\n \\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\\n \\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\\n \\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\\n \\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\\n \\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\\n \\190\\001\\190\\001\\190\\001\\190\\001\\202\\001\\202\\001\\202\\001\\202\\001\\\n \\202\\001\\202\\001\\202\\001\\202\\001\\202\\001\\202\\001\\200\\001\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\202\\001\\202\\001\\202\\001\\\n \\202\\001\\202\\001\\202\\001\\200\\001\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\202\\001\\202\\001\\202\\001\\\n \\202\\001\\202\\001\\202\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\200\\001\\000\\000\\000\\000\\000\\000\\000\\000\\145\\001\\200\\001\\000\\000\\\n \\000\\000\\000\\000\\200\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\200\\001\\000\\000\\000\\000\\000\\000\\200\\001\\000\\000\\\n \\200\\001\\199\\001\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\\n \\203\\001\\203\\001\\203\\001\\203\\001\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\\n \\203\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\\n \\204\\001\\204\\001\\204\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\\n \\000\\000\\000\\000\\000\\000\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\\n \\203\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\200\\001\\\n \\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\\n \\200\\001\\000\\000\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\\n \\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\000\\000\\214\\001\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\213\\001\\000\\000\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\000\\000\\000\\000\\000\\000\\000\\000\\213\\001\\\n \\000\\000\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\211\\001\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\";\n Lexing.lex_check =\n \"\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\000\\000\\000\\000\\255\\255\\003\\000\\000\\000\\134\\000\\255\\255\\\n \\003\\000\\255\\255\\134\\000\\069\\001\\146\\001\\057\\000\\255\\255\\069\\001\\\n \\146\\001\\255\\255\\255\\255\\255\\255\\255\\255\\125\\000\\138\\000\\255\\255\\\n \\000\\000\\255\\255\\000\\000\\003\\000\\169\\000\\134\\000\\174\\000\\255\\255\\\n \\000\\000\\010\\001\\069\\001\\146\\001\\012\\001\\000\\000\\010\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\005\\000\\115\\000\\000\\000\\125\\000\\129\\000\\005\\000\\\n \\236\\001\\136\\000\\255\\001\\038\\000\\255\\255\\010\\000\\136\\000\\102\\000\\\n \\058\\000\\000\\000\\107\\000\\102\\000\\255\\255\\011\\000\\000\\000\\011\\000\\\n \\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\\n \\011\\000\\029\\000\\038\\000\\000\\000\\111\\000\\208\\000\\233\\000\\255\\000\\\n \\012\\001\\015\\000\\017\\000\\060\\000\\011\\000\\010\\000\\000\\000\\020\\000\\\n \\024\\000\\031\\000\\032\\000\\034\\000\\022\\000\\026\\000\\000\\000\\014\\000\\\n \\027\\000\\033\\000\\018\\000\\023\\000\\000\\000\\016\\000\\019\\000\\035\\000\\\n \\040\\000\\036\\000\\038\\000\\000\\000\\041\\000\\042\\000\\043\\000\\044\\000\\\n \\045\\000\\046\\000\\058\\000\\082\\000\\011\\000\\013\\000\\013\\000\\013\\000\\\n \\013\\000\\013\\000\\013\\000\\013\\000\\013\\000\\013\\000\\013\\000\\039\\000\\\n \\063\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\\n \\039\\000\\039\\000\\039\\000\\085\\000\\140\\000\\060\\000\\013\\000\\143\\000\\\n \\144\\000\\145\\000\\048\\000\\147\\000\\048\\000\\148\\000\\039\\000\\048\\000\\\n \\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\\n \\048\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\\n \\049\\000\\049\\000\\049\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\\n \\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\065\\000\\039\\000\\149\\000\\\n \\150\\000\\156\\000\\063\\000\\157\\000\\051\\000\\158\\000\\051\\000\\159\\000\\\n \\050\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\\n \\051\\000\\051\\000\\051\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\\n \\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\053\\000\\053\\000\\053\\000\\\n \\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\155\\000\\\n \\050\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\\n \\054\\000\\054\\000\\054\\000\\161\\000\\162\\000\\155\\000\\091\\000\\065\\000\\\n \\000\\000\\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\\n \\055\\000\\055\\000\\055\\000\\057\\000\\068\\000\\102\\000\\107\\000\\115\\000\\\n \\131\\000\\133\\000\\133\\000\\125\\000\\138\\000\\133\\000\\163\\000\\094\\000\\\n \\165\\000\\068\\000\\166\\000\\167\\000\\168\\000\\171\\000\\111\\000\\172\\000\\\n \\173\\000\\206\\000\\203\\000\\207\\000\\210\\000\\211\\000\\058\\000\\082\\000\\\n \\133\\000\\212\\000\\213\\000\\214\\000\\215\\000\\217\\000\\140\\000\\218\\000\\\n \\097\\000\\219\\000\\220\\000\\119\\000\\221\\000\\222\\000\\223\\000\\133\\000\\\n \\091\\000\\203\\000\\034\\001\\062\\001\\233\\000\\152\\000\\001\\001\\080\\001\\\n \\247\\000\\060\\000\\251\\000\\054\\001\\058\\001\\081\\001\\068\\000\\041\\001\\\n \\082\\001\\083\\001\\006\\001\\026\\001\\068\\000\\119\\000\\030\\001\\015\\001\\\n \\068\\000\\094\\000\\015\\001\\084\\001\\085\\001\\086\\001\\071\\001\\088\\001\\\n \\068\\000\\203\\000\\050\\001\\071\\001\\068\\000\\089\\001\\068\\000\\068\\000\\\n \\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\\n \\071\\000\\071\\000\\097\\000\\076\\001\\119\\000\\090\\001\\063\\000\\001\\001\\\n \\092\\001\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\078\\000\\\n \\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\\n \\078\\000\\152\\000\\076\\001\\093\\001\\095\\001\\097\\001\\098\\001\\045\\001\\\n \\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\099\\001\\152\\000\\\n \\100\\001\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\180\\000\\\n \\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\\n \\180\\000\\020\\001\\076\\001\\065\\000\\020\\001\\101\\001\\102\\001\\104\\001\\\n \\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\079\\000\\079\\000\\\n \\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\\n \\105\\001\\106\\001\\045\\001\\036\\001\\107\\001\\108\\001\\109\\001\\079\\000\\\n \\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\080\\000\\080\\000\\080\\000\\\n \\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\110\\001\\\n \\026\\001\\121\\001\\157\\001\\030\\001\\158\\001\\020\\001\\080\\000\\080\\000\\\n \\080\\000\\080\\000\\080\\000\\080\\000\\091\\000\\159\\001\\062\\001\\079\\000\\\n \\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\247\\000\\160\\001\\251\\000\\\n \\161\\001\\058\\001\\068\\000\\086\\000\\086\\000\\086\\000\\086\\000\\086\\000\\\n \\086\\000\\086\\000\\086\\000\\086\\000\\086\\000\\094\\000\\080\\000\\080\\000\\\n \\080\\000\\080\\000\\080\\000\\080\\000\\086\\000\\086\\000\\086\\000\\086\\000\\\n \\086\\000\\086\\000\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\\n \\087\\000\\087\\000\\087\\000\\087\\000\\036\\001\\041\\001\\097\\000\\162\\001\\\n \\163\\001\\119\\000\\001\\001\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\\n \\087\\000\\165\\001\\054\\001\\152\\000\\086\\000\\086\\000\\086\\000\\086\\000\\\n \\086\\000\\086\\000\\006\\001\\166\\001\\167\\001\\168\\001\\015\\001\\169\\001\\\n \\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\\n \\088\\000\\088\\000\\050\\001\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\\n \\087\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\089\\000\\\n \\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\\n \\089\\000\\095\\000\\133\\001\\170\\001\\171\\001\\154\\001\\133\\001\\172\\001\\\n \\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\095\\000\\176\\000\\\n \\173\\001\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\045\\001\\\n \\174\\001\\175\\001\\176\\000\\176\\001\\154\\001\\176\\000\\176\\000\\176\\000\\\n \\176\\000\\176\\000\\176\\000\\176\\000\\176\\000\\176\\000\\176\\000\\122\\001\\\n \\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\148\\001\\177\\001\\\n \\020\\001\\178\\001\\098\\000\\148\\001\\179\\001\\180\\001\\181\\001\\182\\001\\\n \\183\\001\\216\\001\\193\\001\\095\\000\\154\\001\\216\\001\\205\\001\\098\\000\\\n \\222\\001\\095\\000\\205\\001\\229\\001\\001\\002\\095\\000\\218\\001\\036\\001\\\n \\215\\001\\215\\001\\002\\002\\218\\001\\215\\001\\095\\000\\004\\002\\005\\002\\\n \\216\\001\\095\\000\\006\\002\\095\\000\\095\\000\\096\\000\\096\\000\\096\\000\\\n \\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\215\\001\\\n \\007\\002\\122\\001\\008\\002\\009\\002\\010\\002\\011\\002\\096\\000\\096\\000\\\n \\096\\000\\096\\000\\096\\000\\096\\000\\098\\000\\012\\002\\215\\001\\247\\001\\\n \\013\\002\\014\\002\\098\\000\\015\\002\\125\\001\\128\\001\\098\\000\\016\\002\\\n \\220\\001\\017\\002\\251\\001\\018\\002\\019\\002\\020\\002\\098\\000\\121\\001\\\n \\021\\002\\194\\001\\098\\000\\022\\002\\098\\000\\098\\000\\096\\000\\096\\000\\\n \\096\\000\\096\\000\\096\\000\\096\\000\\099\\000\\099\\000\\099\\000\\099\\000\\\n \\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\231\\001\\023\\002\\\n \\238\\001\\024\\002\\251\\001\\238\\001\\025\\002\\099\\000\\099\\000\\099\\000\\\n \\099\\000\\099\\000\\099\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\243\\001\\125\\001\\128\\001\\\n \\224\\001\\026\\002\\197\\001\\027\\002\\100\\000\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\028\\002\\194\\001\\029\\002\\099\\000\\099\\000\\099\\000\\\n \\099\\000\\099\\000\\099\\000\\030\\002\\031\\002\\032\\002\\200\\001\\231\\001\\\n \\133\\001\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\\n \\101\\000\\101\\000\\101\\000\\255\\255\\100\\000\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\\n \\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\\n \\182\\000\\182\\000\\255\\255\\255\\255\\197\\001\\176\\000\\184\\000\\184\\000\\\n \\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\\n \\185\\000\\255\\255\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\\n \\200\\001\\224\\001\\255\\255\\185\\000\\205\\001\\122\\001\\185\\000\\185\\000\\\n \\185\\000\\185\\000\\185\\000\\185\\000\\185\\000\\185\\000\\185\\000\\185\\000\\\n \\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\\n \\190\\000\\190\\000\\191\\000\\191\\000\\191\\000\\191\\000\\191\\000\\191\\000\\\n \\191\\000\\191\\000\\191\\000\\191\\000\\192\\000\\197\\000\\197\\000\\197\\000\\\n \\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\192\\000\\\n \\193\\001\\247\\001\\192\\000\\192\\000\\192\\000\\192\\000\\192\\000\\192\\000\\\n \\192\\000\\192\\000\\192\\000\\192\\000\\198\\000\\198\\000\\198\\000\\198\\000\\\n \\198\\000\\198\\000\\198\\000\\198\\000\\198\\000\\198\\000\\199\\000\\226\\000\\\n \\226\\000\\226\\000\\226\\000\\226\\000\\226\\000\\226\\000\\226\\000\\226\\000\\\n \\226\\000\\199\\000\\125\\001\\128\\001\\199\\000\\199\\000\\199\\000\\199\\000\\\n \\199\\000\\199\\000\\199\\000\\199\\000\\199\\000\\199\\000\\204\\000\\194\\001\\\n \\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\\n \\204\\000\\204\\000\\231\\001\\255\\255\\255\\255\\199\\000\\220\\001\\238\\001\\\n \\251\\001\\255\\255\\199\\000\\243\\001\\255\\255\\204\\000\\205\\000\\205\\000\\\n \\205\\000\\205\\000\\205\\000\\205\\000\\205\\000\\205\\000\\205\\000\\205\\000\\\n \\225\\000\\255\\255\\225\\000\\255\\255\\224\\001\\225\\000\\225\\000\\225\\000\\\n \\225\\000\\225\\000\\225\\000\\225\\000\\225\\000\\225\\000\\225\\000\\205\\000\\\n \\197\\001\\255\\255\\255\\255\\255\\255\\255\\255\\204\\000\\227\\000\\227\\000\\\n \\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\200\\001\\255\\255\\255\\255\\228\\000\\\n \\255\\255\\228\\000\\255\\255\\227\\000\\228\\000\\228\\000\\228\\000\\228\\000\\\n \\228\\000\\228\\000\\228\\000\\228\\000\\228\\000\\228\\000\\229\\000\\229\\000\\\n \\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\\n \\230\\000\\230\\000\\230\\000\\230\\000\\230\\000\\230\\000\\230\\000\\230\\000\\\n \\230\\000\\230\\000\\255\\255\\227\\000\\231\\000\\231\\000\\231\\000\\231\\000\\\n \\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\185\\000\\232\\000\\\n \\232\\000\\232\\000\\232\\000\\232\\000\\232\\000\\232\\000\\232\\000\\232\\000\\\n \\232\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\237\\000\\255\\255\\\n \\077\\001\\255\\255\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\\n \\077\\001\\077\\001\\077\\001\\077\\001\\113\\001\\113\\001\\113\\001\\113\\001\\\n \\113\\001\\113\\001\\113\\001\\113\\001\\113\\001\\113\\001\\255\\255\\077\\001\\\n \\255\\255\\255\\255\\192\\000\\255\\255\\255\\255\\237\\000\\237\\000\\237\\000\\\n \\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\\n \\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\\n \\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\077\\001\\\n \\255\\255\\255\\255\\255\\255\\237\\000\\199\\000\\237\\000\\237\\000\\237\\000\\\n \\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\\n \\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\\n \\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\255\\255\\242\\000\\255\\255\\255\\255\\240\\000\\255\\255\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\\n \\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\\n \\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\\n \\242\\000\\242\\000\\242\\000\\242\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\242\\000\\255\\255\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\\n \\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\\n \\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\\n \\242\\000\\242\\000\\242\\000\\242\\000\\237\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\245\\000\\255\\255\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\066\\001\\066\\001\\255\\255\\255\\255\\066\\001\\079\\001\\079\\001\\079\\001\\\n \\079\\001\\079\\001\\079\\001\\079\\001\\079\\001\\079\\001\\079\\001\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\066\\001\\\n \\255\\255\\066\\001\\255\\255\\255\\255\\255\\255\\255\\255\\079\\001\\066\\001\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\066\\001\\255\\255\\066\\001\\066\\001\\\n \\066\\001\\066\\001\\066\\001\\066\\001\\066\\001\\066\\001\\066\\001\\066\\001\\\n \\066\\001\\255\\255\\255\\255\\066\\001\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\242\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\066\\001\\112\\001\\255\\255\\112\\001\\255\\255\\066\\001\\112\\001\\112\\001\\\n \\112\\001\\112\\001\\112\\001\\112\\001\\112\\001\\112\\001\\112\\001\\112\\001\\\n \\255\\255\\255\\255\\066\\001\\114\\001\\114\\001\\114\\001\\114\\001\\114\\001\\\n \\114\\001\\114\\001\\114\\001\\114\\001\\114\\001\\066\\001\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\066\\001\\255\\255\\255\\255\\\n \\114\\001\\255\\255\\255\\255\\066\\001\\255\\255\\255\\255\\115\\001\\255\\255\\\n \\115\\001\\255\\255\\066\\001\\115\\001\\115\\001\\115\\001\\115\\001\\115\\001\\\n \\115\\001\\115\\001\\115\\001\\115\\001\\115\\001\\116\\001\\116\\001\\116\\001\\\n \\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\255\\255\\\n \\114\\001\\117\\001\\117\\001\\117\\001\\117\\001\\117\\001\\117\\001\\117\\001\\\n \\117\\001\\117\\001\\117\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\\n \\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\119\\001\\119\\001\\119\\001\\\n \\119\\001\\119\\001\\119\\001\\119\\001\\119\\001\\119\\001\\119\\001\\255\\255\\\n \\126\\001\\127\\001\\127\\001\\127\\001\\127\\001\\127\\001\\127\\001\\127\\001\\\n \\127\\001\\127\\001\\127\\001\\255\\255\\255\\255\\126\\001\\255\\255\\255\\255\\\n \\255\\255\\129\\001\\127\\001\\127\\001\\127\\001\\127\\001\\127\\001\\127\\001\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\129\\001\\255\\255\\\n \\255\\255\\155\\001\\255\\255\\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\\n \\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\127\\001\\127\\001\\127\\001\\127\\001\\127\\001\\127\\001\\\n \\155\\001\\255\\255\\126\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\126\\001\\255\\255\\255\\255\\255\\255\\126\\001\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\129\\001\\126\\001\\255\\255\\255\\255\\066\\001\\\n \\126\\001\\129\\001\\126\\001\\126\\001\\255\\255\\129\\001\\255\\255\\255\\255\\\n \\155\\001\\255\\255\\255\\255\\255\\255\\255\\255\\129\\001\\255\\255\\255\\255\\\n \\255\\255\\129\\001\\255\\255\\129\\001\\129\\001\\130\\001\\130\\001\\130\\001\\\n \\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\130\\001\\130\\001\\\n \\130\\001\\130\\001\\130\\001\\130\\001\\131\\001\\131\\001\\131\\001\\131\\001\\\n \\131\\001\\131\\001\\131\\001\\131\\001\\131\\001\\131\\001\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\131\\001\\131\\001\\131\\001\\\n \\131\\001\\131\\001\\131\\001\\255\\255\\255\\255\\255\\255\\130\\001\\130\\001\\\n \\130\\001\\130\\001\\130\\001\\130\\001\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\132\\001\\132\\001\\132\\001\\132\\001\\132\\001\\132\\001\\\n \\132\\001\\132\\001\\132\\001\\132\\001\\255\\255\\131\\001\\131\\001\\131\\001\\\n \\131\\001\\131\\001\\131\\001\\132\\001\\132\\001\\132\\001\\132\\001\\132\\001\\\n \\132\\001\\184\\001\\138\\001\\184\\001\\255\\255\\255\\255\\184\\001\\184\\001\\\n \\184\\001\\184\\001\\184\\001\\184\\001\\184\\001\\184\\001\\184\\001\\184\\001\\\n \\185\\001\\185\\001\\185\\001\\185\\001\\185\\001\\185\\001\\185\\001\\185\\001\\\n \\185\\001\\185\\001\\255\\255\\132\\001\\132\\001\\132\\001\\132\\001\\132\\001\\\n \\132\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\\n \\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\\n \\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\\n \\138\\001\\138\\001\\138\\001\\255\\255\\255\\255\\255\\255\\255\\255\\138\\001\\\n \\255\\255\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\\n \\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\\n \\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\\n \\138\\001\\138\\001\\138\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\141\\001\\255\\255\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\143\\001\\143\\001\\\n \\255\\255\\255\\255\\143\\001\\156\\001\\156\\001\\156\\001\\156\\001\\156\\001\\\n \\156\\001\\156\\001\\156\\001\\156\\001\\156\\001\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\198\\001\\143\\001\\255\\255\\143\\001\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\156\\001\\143\\001\\255\\255\\255\\255\\\n \\255\\255\\198\\001\\143\\001\\255\\255\\143\\001\\143\\001\\143\\001\\143\\001\\\n \\143\\001\\143\\001\\143\\001\\143\\001\\143\\001\\143\\001\\143\\001\\255\\255\\\n \\255\\255\\143\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\138\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\143\\001\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\143\\001\\186\\001\\186\\001\\186\\001\\186\\001\\\n \\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\198\\001\\255\\255\\\n \\143\\001\\255\\255\\255\\255\\255\\255\\198\\001\\255\\255\\255\\255\\255\\255\\\n \\198\\001\\186\\001\\255\\255\\143\\001\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\198\\001\\255\\255\\255\\255\\143\\001\\198\\001\\255\\255\\198\\001\\198\\001\\\n \\255\\255\\143\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\143\\001\\255\\255\\255\\255\\255\\255\\255\\255\\187\\001\\255\\255\\187\\001\\\n \\255\\255\\186\\001\\187\\001\\187\\001\\187\\001\\187\\001\\187\\001\\187\\001\\\n \\187\\001\\187\\001\\187\\001\\187\\001\\188\\001\\188\\001\\188\\001\\188\\001\\\n \\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\189\\001\\189\\001\\\n \\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\\n \\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\\n \\190\\001\\190\\001\\191\\001\\191\\001\\191\\001\\191\\001\\191\\001\\191\\001\\\n \\191\\001\\191\\001\\191\\001\\191\\001\\199\\001\\199\\001\\199\\001\\199\\001\\\n \\199\\001\\199\\001\\199\\001\\199\\001\\199\\001\\199\\001\\201\\001\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\199\\001\\199\\001\\199\\001\\\n \\199\\001\\199\\001\\199\\001\\201\\001\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\199\\001\\199\\001\\199\\001\\\n \\199\\001\\199\\001\\199\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\201\\001\\255\\255\\255\\255\\255\\255\\255\\255\\143\\001\\201\\001\\255\\255\\\n \\255\\255\\255\\255\\201\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\201\\001\\255\\255\\255\\255\\255\\255\\201\\001\\255\\255\\\n \\201\\001\\201\\001\\202\\001\\202\\001\\202\\001\\202\\001\\202\\001\\202\\001\\\n \\202\\001\\202\\001\\202\\001\\202\\001\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\202\\001\\202\\001\\202\\001\\202\\001\\202\\001\\\n \\202\\001\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\\n \\203\\001\\203\\001\\203\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\\n \\255\\255\\255\\255\\255\\255\\202\\001\\202\\001\\202\\001\\202\\001\\202\\001\\\n \\202\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\204\\001\\\n \\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\\n \\204\\001\\255\\255\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\\n \\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\255\\255\\210\\001\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\210\\001\\210\\001\\\n \\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\\n \\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\\n \\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\210\\001\\255\\255\\210\\001\\210\\001\\\n \\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\\n \\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\\n \\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\255\\255\\255\\255\\255\\255\\255\\255\\213\\001\\\n \\255\\255\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\210\\001\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\";\n Lexing.lex_base_code =\n \"\";\n Lexing.lex_backtrk_code =\n \"\";\n Lexing.lex_default_code =\n \"\";\n Lexing.lex_trans_code =\n \"\";\n Lexing.lex_check_code =\n \"\";\n Lexing.lex_code =\n \"\";\n}\n\nlet rec read_json v lexbuf =\n __ocaml_lex_read_json_rec v lexbuf 0\nand __ocaml_lex_read_json_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 188 \"lib/read.mll\"\n \n# 188 \"lib/read.mll\"\n ( `Bool true )\n\n# 1032 \"lib/read.ml\"\n\n \n# 1033 \"lib/read.ml\"\n | 1 ->\n\n# 189 \"lib/read.mll\"\n \n# 189 \"lib/read.mll\"\n ( `Bool false )\n\n# 1037 \"lib/read.ml\"\n\n \n# 1038 \"lib/read.ml\"\n | 2 ->\n\n# 190 \"lib/read.mll\"\n \n# 190 \"lib/read.mll\"\n ( `Null )\n\n# 1042 \"lib/read.ml\"\n\n \n# 1043 \"lib/read.ml\"\n | 3 ->\n\n# 191 \"lib/read.mll\"\n \n# 191 \"lib/read.mll\"\n (\n \n# 193 \"lib/read.mll\"\n `Float nan\n \n# 197 \"lib/read.mll\"\n )\n\n# 1053 \"lib/read.ml\"\n\n \n# 1054 \"lib/read.ml\"\n | 4 ->\n\n# 198 \"lib/read.mll\"\n \n# 198 \"lib/read.mll\"\n (\n \n# 200 \"lib/read.mll\"\n `Float infinity\n \n# 204 \"lib/read.mll\"\n )\n\n# 1064 \"lib/read.ml\"\n\n \n# 1065 \"lib/read.ml\"\n | 5 ->\n\n# 205 \"lib/read.mll\"\n \n# 205 \"lib/read.mll\"\n (\n \n# 207 \"lib/read.mll\"\n `Float neg_infinity\n \n# 211 \"lib/read.mll\"\n )\n\n# 1075 \"lib/read.ml\"\n\n \n# 1076 \"lib/read.ml\"\n | 6 ->\n\n# 212 \"lib/read.mll\"\n \n# 212 \"lib/read.mll\"\n (\n \n# 214 \"lib/read.mll\"\n Bi_outbuf.clear v.buf;\n `String (finish_string v lexbuf)\n \n# 219 \"lib/read.mll\"\n )\n\n# 1087 \"lib/read.ml\"\n\n \n# 1088 \"lib/read.ml\"\n | 7 ->\n\n# 220 \"lib/read.mll\"\n \n# 220 \"lib/read.mll\"\n ( make_positive_int v lexbuf )\n\n# 1092 \"lib/read.ml\"\n\n \n# 1093 \"lib/read.ml\"\n | 8 ->\n\n# 221 \"lib/read.mll\"\n \n# 221 \"lib/read.mll\"\n ( make_negative_int v lexbuf )\n\n# 1097 \"lib/read.ml\"\n\n \n# 1098 \"lib/read.ml\"\n | 9 ->\n\n# 222 \"lib/read.mll\"\n \n# 222 \"lib/read.mll\"\n (\n \n# 224 \"lib/read.mll\"\n `Float (float_of_string (lexeme lexbuf))\n \n# 228 \"lib/read.mll\"\n )\n\n# 1108 \"lib/read.ml\"\n\n \n# 1109 \"lib/read.ml\"\n | 10 ->\n\n# 230 \"lib/read.mll\"\n \n# 230 \"lib/read.mll\"\n ( let acc = ref [] in\n try\n read_space v lexbuf;\n read_object_end lexbuf;\n let field_name = read_ident v lexbuf in\n read_space v lexbuf;\n read_colon v lexbuf;\n read_space v lexbuf;\n acc := (field_name, read_json v lexbuf) :: !acc;\n while true do\n read_space v lexbuf;\n read_object_sep v lexbuf;\n read_space v lexbuf;\n let field_name = read_ident v lexbuf in\n read_space v lexbuf;\n read_colon v lexbuf;\n read_space v lexbuf;\n acc := (field_name, read_json v lexbuf) :: !acc;\n done;\n assert false\n with End_of_object ->\n `Assoc (List.rev !acc)\n )\n\n# 1135 \"lib/read.ml\"\n\n \n# 1136 \"lib/read.ml\"\n | 11 ->\n\n# 254 \"lib/read.mll\"\n \n# 254 \"lib/read.mll\"\n ( let acc = ref [] in\n try\n read_space v lexbuf;\n read_array_end lexbuf;\n acc := read_json v lexbuf :: !acc;\n while true do\n read_space v lexbuf;\n read_array_sep v lexbuf;\n read_space v lexbuf;\n acc := read_json v lexbuf :: !acc;\n done;\n assert false\n with End_of_array ->\n `List (List.rev !acc)\n )\n\n# 1154 \"lib/read.ml\"\n\n \n# 1155 \"lib/read.ml\"\n | 12 ->\n\n# 270 \"lib/read.mll\"\n \n# 270 \"lib/read.mll\"\n (\n \n# 272 \"lib/read.mll\"\n let acc = ref [] in\n try\n read_space v lexbuf;\n read_tuple_end lexbuf;\n acc := read_json v lexbuf :: !acc;\n while true do\n read_space v lexbuf;\n read_tuple_sep v lexbuf;\n read_space v lexbuf;\n acc := read_json v lexbuf :: !acc;\n done;\n assert false\n with End_of_tuple ->\n `Tuple (List.rev !acc)\n \n# 289 \"lib/read.mll\"\n )\n\n# 1178 \"lib/read.ml\"\n\n \n# 1179 \"lib/read.ml\"\n | 13 ->\n\n# 291 \"lib/read.mll\"\n \n# 291 \"lib/read.mll\"\n (\n \n# 293 \"lib/read.mll\"\n read_space v lexbuf;\n let cons = read_ident v lexbuf in\n read_space v lexbuf;\n `Variant (cons, finish_variant v lexbuf)\n \n# 300 \"lib/read.mll\"\n )\n\n# 1192 \"lib/read.ml\"\n\n \n# 1193 \"lib/read.ml\"\n | 14 ->\n\n# 302 \"lib/read.mll\"\n \n# 302 \"lib/read.mll\"\n ( read_json v lexbuf )\n\n# 1197 \"lib/read.ml\"\n\n \n# 1198 \"lib/read.ml\"\n | 15 ->\n\n# 303 \"lib/read.mll\"\n \n# 303 \"lib/read.mll\"\n ( finish_comment v lexbuf; read_json v lexbuf )\n\n# 1202 \"lib/read.ml\"\n\n \n# 1203 \"lib/read.ml\"\n | 16 ->\n\n# 304 \"lib/read.mll\"\n \n# 304 \"lib/read.mll\"\n ( newline v lexbuf; read_json v lexbuf )\n\n# 1207 \"lib/read.ml\"\n\n \n# 1208 \"lib/read.ml\"\n | 17 ->\n\n# 305 \"lib/read.mll\"\n \n# 305 \"lib/read.mll\"\n ( read_json v lexbuf )\n\n# 1212 \"lib/read.ml\"\n\n \n# 1213 \"lib/read.ml\"\n | 18 ->\n\n# 306 \"lib/read.mll\"\n \n# 306 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1217 \"lib/read.ml\"\n\n \n# 1218 \"lib/read.ml\"\n | 19 ->\n\n# 307 \"lib/read.mll\"\n \n# 307 \"lib/read.mll\"\n ( long_error \"Invalid token\" v lexbuf )\n\n# 1222 \"lib/read.ml\"\n\n \n# 1223 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_json_rec v lexbuf __ocaml_lex_state\n\nand finish_string v lexbuf =\n __ocaml_lex_finish_string_rec v lexbuf 58\nand __ocaml_lex_finish_string_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 311 \"lib/read.mll\"\n \n# 311 \"lib/read.mll\"\n ( Bi_outbuf.contents v.buf )\n\n# 1234 \"lib/read.ml\"\n\n \n# 1235 \"lib/read.ml\"\n | 1 ->\n\n# 312 \"lib/read.mll\"\n \n# 312 \"lib/read.mll\"\n ( finish_escaped_char v lexbuf;\n finish_string v lexbuf )\n\n# 1240 \"lib/read.ml\"\n\n \n# 1241 \"lib/read.ml\"\n | 2 ->\n\n# 314 \"lib/read.mll\"\n \n# 314 \"lib/read.mll\"\n ( add_lexeme v.buf lexbuf;\n finish_string v lexbuf )\n\n# 1246 \"lib/read.ml\"\n\n \n# 1247 \"lib/read.ml\"\n | 3 ->\n\n# 316 \"lib/read.mll\"\n \n# 316 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1251 \"lib/read.ml\"\n\n \n# 1252 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_string_rec v lexbuf __ocaml_lex_state\n\nand map_string v f lexbuf =\n __ocaml_lex_map_string_rec v f lexbuf 63\nand __ocaml_lex_map_string_rec v f lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 319 \"lib/read.mll\"\n \n# 319 \"lib/read.mll\"\n ( let b = v.buf in\n f (Bytes.to_string b.Bi_outbuf.o_s) 0 b.Bi_outbuf.o_len )\n\n# 1264 \"lib/read.ml\"\n\n \n# 1265 \"lib/read.ml\"\n | 1 ->\n\n# 321 \"lib/read.mll\"\n \n# 321 \"lib/read.mll\"\n ( finish_escaped_char v lexbuf;\n map_string v f lexbuf )\n\n# 1270 \"lib/read.ml\"\n\n \n# 1271 \"lib/read.ml\"\n | 2 ->\n\n# 323 \"lib/read.mll\"\n \n# 323 \"lib/read.mll\"\n ( add_lexeme v.buf lexbuf;\n map_string v f lexbuf )\n\n# 1276 \"lib/read.ml\"\n\n \n# 1277 \"lib/read.ml\"\n | 3 ->\n\n# 325 \"lib/read.mll\"\n \n# 325 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1281 \"lib/read.ml\"\n\n \n# 1282 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_map_string_rec v f lexbuf __ocaml_lex_state\n\nand finish_escaped_char v lexbuf =\n __ocaml_lex_finish_escaped_char_rec v lexbuf 68\nand __ocaml_lex_finish_escaped_char_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\nlet\n\n# 330 \"lib/read.mll\"\n \n# 330 \"lib/read.mll\"\n c\n\n# 1294 \"lib/read.ml\"\n# 1294 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf lexbuf.Lexing.lex_start_pos in\n\n# 330 \"lib/read.mll\"\n \n# 330 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf c )\n\n# 1298 \"lib/read.ml\"\n\n \n# 1299 \"lib/read.ml\"\n | 1 ->\n\n# 331 \"lib/read.mll\"\n \n# 331 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\\b' )\n\n# 1303 \"lib/read.ml\"\n\n \n# 1304 \"lib/read.ml\"\n | 2 ->\n\n# 332 \"lib/read.mll\"\n \n# 332 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\\012' )\n\n# 1308 \"lib/read.ml\"\n\n \n# 1309 \"lib/read.ml\"\n | 3 ->\n\n# 333 \"lib/read.mll\"\n \n# 333 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\\n' )\n\n# 1313 \"lib/read.ml\"\n\n \n# 1314 \"lib/read.ml\"\n | 4 ->\n\n# 334 \"lib/read.mll\"\n \n# 334 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\\r' )\n\n# 1318 \"lib/read.ml\"\n\n \n# 1319 \"lib/read.ml\"\n | 5 ->\n\n# 335 \"lib/read.mll\"\n \n# 335 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\\t' )\n\n# 1323 \"lib/read.ml\"\n\n \n# 1324 \"lib/read.ml\"\n | 6 ->\nlet\n\n# 336 \"lib/read.mll\"\n \n# 336 \"lib/read.mll\"\n a\n\n# 1329 \"lib/read.ml\"\n# 1329 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 1)\nand\n\n# 336 \"lib/read.mll\"\n \n# 336 \"lib/read.mll\"\n b\n\n# 1334 \"lib/read.ml\"\n# 1334 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 2)\nand\n\n# 336 \"lib/read.mll\"\n \n# 336 \"lib/read.mll\"\n c\n\n# 1339 \"lib/read.ml\"\n# 1339 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 3)\nand\n\n# 336 \"lib/read.mll\"\n \n# 336 \"lib/read.mll\"\n d\n\n# 1344 \"lib/read.ml\"\n# 1344 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 4) in\n\n# 337 \"lib/read.mll\"\n \n# 337 \"lib/read.mll\"\n ( let x =\n (hex a lsl 12) lor (hex b lsl 8) lor (hex c lsl 4) lor hex d\n in\n if x >= 0xD800 && x <= 0xDBFF then\n finish_surrogate_pair v x lexbuf\n else\n utf8_of_code v.buf x\n )\n\n# 1355 \"lib/read.ml\"\n\n \n# 1356 \"lib/read.ml\"\n | 7 ->\n\n# 345 \"lib/read.mll\"\n \n# 345 \"lib/read.mll\"\n ( long_error \"Invalid escape sequence\" v lexbuf )\n\n# 1360 \"lib/read.ml\"\n\n \n# 1361 \"lib/read.ml\"\n | 8 ->\n\n# 346 \"lib/read.mll\"\n \n# 346 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1365 \"lib/read.ml\"\n\n \n# 1366 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_escaped_char_rec v lexbuf __ocaml_lex_state\n\nand finish_surrogate_pair v x lexbuf =\n __ocaml_lex_finish_surrogate_pair_rec v x lexbuf 82\nand __ocaml_lex_finish_surrogate_pair_rec v x lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\nlet\n\n# 349 \"lib/read.mll\"\n \n# 349 \"lib/read.mll\"\n a\n\n# 1378 \"lib/read.ml\"\n# 1378 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 2)\nand\n\n# 349 \"lib/read.mll\"\n \n# 349 \"lib/read.mll\"\n b\n\n# 1383 \"lib/read.ml\"\n# 1383 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 3)\nand\n\n# 349 \"lib/read.mll\"\n \n# 349 \"lib/read.mll\"\n c\n\n# 1388 \"lib/read.ml\"\n# 1388 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 4)\nand\n\n# 349 \"lib/read.mll\"\n \n# 349 \"lib/read.mll\"\n d\n\n# 1393 \"lib/read.ml\"\n# 1393 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 5) in\n\n# 350 \"lib/read.mll\"\n \n# 350 \"lib/read.mll\"\n ( let y =\n (hex a lsl 12) lor (hex b lsl 8) lor (hex c lsl 4) lor hex d\n in\n if y >= 0xDC00 && y <= 0xDFFF then\n utf8_of_surrogate_pair v.buf x y\n else\n long_error \"Invalid low surrogate for code point beyond U+FFFF\"\n v lexbuf\n )\n\n# 1405 \"lib/read.ml\"\n\n \n# 1406 \"lib/read.ml\"\n | 1 ->\n\n# 359 \"lib/read.mll\"\n \n# 359 \"lib/read.mll\"\n ( long_error \"Missing escape sequence representing low surrogate \\\n for code point beyond U+FFFF\" v lexbuf )\n\n# 1411 \"lib/read.ml\"\n\n \n# 1412 \"lib/read.ml\"\n | 2 ->\n\n# 361 \"lib/read.mll\"\n \n# 361 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1416 \"lib/read.ml\"\n\n \n# 1417 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_surrogate_pair_rec v x lexbuf __ocaml_lex_state\n\nand finish_stringlit v lexbuf =\n __ocaml_lex_finish_stringlit_rec v lexbuf 91\nand __ocaml_lex_finish_stringlit_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 366 \"lib/read.mll\"\n \n# 366 \"lib/read.mll\"\n ( let len = lexbuf.lex_curr_pos - lexbuf.lex_start_pos in\n let s = Bytes.create (len+1) in\n Bytes.set s 0 '\"';\n Bytes.blit lexbuf.lex_buffer lexbuf.lex_start_pos s 1 len;\n Bytes.to_string s\n )\n\n# 1433 \"lib/read.ml\"\n\n \n# 1434 \"lib/read.ml\"\n | 1 ->\n\n# 372 \"lib/read.mll\"\n \n# 372 \"lib/read.mll\"\n ( long_error \"Invalid string literal\" v lexbuf )\n\n# 1438 \"lib/read.ml\"\n\n \n# 1439 \"lib/read.ml\"\n | 2 ->\n\n# 373 \"lib/read.mll\"\n \n# 373 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1443 \"lib/read.ml\"\n\n \n# 1444 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_stringlit_rec v lexbuf __ocaml_lex_state\n\nand finish_variant v lexbuf =\n __ocaml_lex_finish_variant_rec v lexbuf 102\nand __ocaml_lex_finish_variant_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 376 \"lib/read.mll\"\n \n# 376 \"lib/read.mll\"\n ( let x = read_json v lexbuf in\n read_space v lexbuf;\n read_gt v lexbuf;\n Some x )\n\n# 1458 \"lib/read.ml\"\n\n \n# 1459 \"lib/read.ml\"\n | 1 ->\n\n# 380 \"lib/read.mll\"\n \n# 380 \"lib/read.mll\"\n ( None )\n\n# 1463 \"lib/read.ml\"\n\n \n# 1464 \"lib/read.ml\"\n | 2 ->\n\n# 381 \"lib/read.mll\"\n \n# 381 \"lib/read.mll\"\n ( long_error \"Expected ':' or '>' but found\" v lexbuf )\n\n# 1468 \"lib/read.ml\"\n\n \n# 1469 \"lib/read.ml\"\n | 3 ->\n\n# 382 \"lib/read.mll\"\n \n# 382 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1473 \"lib/read.ml\"\n\n \n# 1474 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_variant_rec v lexbuf __ocaml_lex_state\n\nand read_lt v lexbuf =\n __ocaml_lex_read_lt_rec v lexbuf 107\nand __ocaml_lex_read_lt_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 385 \"lib/read.mll\"\n \n# 385 \"lib/read.mll\"\n ( () )\n\n# 1485 \"lib/read.ml\"\n\n \n# 1486 \"lib/read.ml\"\n | 1 ->\n\n# 386 \"lib/read.mll\"\n \n# 386 \"lib/read.mll\"\n ( long_error \"Expected '<' but found\" v lexbuf )\n\n# 1490 \"lib/read.ml\"\n\n \n# 1491 \"lib/read.ml\"\n | 2 ->\n\n# 387 \"lib/read.mll\"\n \n# 387 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1495 \"lib/read.ml\"\n\n \n# 1496 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_lt_rec v lexbuf __ocaml_lex_state\n\nand read_gt v lexbuf =\n __ocaml_lex_read_gt_rec v lexbuf 111\nand __ocaml_lex_read_gt_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 390 \"lib/read.mll\"\n \n# 390 \"lib/read.mll\"\n ( () )\n\n# 1507 \"lib/read.ml\"\n\n \n# 1508 \"lib/read.ml\"\n | 1 ->\n\n# 391 \"lib/read.mll\"\n \n# 391 \"lib/read.mll\"\n ( long_error \"Expected '>' but found\" v lexbuf )\n\n# 1512 \"lib/read.ml\"\n\n \n# 1513 \"lib/read.ml\"\n | 2 ->\n\n# 392 \"lib/read.mll\"\n \n# 392 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1517 \"lib/read.ml\"\n\n \n# 1518 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_gt_rec v lexbuf __ocaml_lex_state\n\nand read_comma v lexbuf =\n __ocaml_lex_read_comma_rec v lexbuf 115\nand __ocaml_lex_read_comma_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 395 \"lib/read.mll\"\n \n# 395 \"lib/read.mll\"\n ( () )\n\n# 1529 \"lib/read.ml\"\n\n \n# 1530 \"lib/read.ml\"\n | 1 ->\n\n# 396 \"lib/read.mll\"\n \n# 396 \"lib/read.mll\"\n ( long_error \"Expected ',' but found\" v lexbuf )\n\n# 1534 \"lib/read.ml\"\n\n \n# 1535 \"lib/read.ml\"\n | 2 ->\n\n# 397 \"lib/read.mll\"\n \n# 397 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1539 \"lib/read.ml\"\n\n \n# 1540 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_comma_rec v lexbuf __ocaml_lex_state\n\nand start_any_variant v lexbuf =\n __ocaml_lex_start_any_variant_rec v lexbuf 119\nand __ocaml_lex_start_any_variant_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 400 \"lib/read.mll\"\n \n# 400 \"lib/read.mll\"\n ( `Edgy_bracket )\n\n# 1551 \"lib/read.ml\"\n\n \n# 1552 \"lib/read.ml\"\n | 1 ->\n\n# 401 \"lib/read.mll\"\n \n# 401 \"lib/read.mll\"\n ( Bi_outbuf.clear v.buf;\n `Double_quote )\n\n# 1557 \"lib/read.ml\"\n\n \n# 1558 \"lib/read.ml\"\n | 2 ->\n\n# 403 \"lib/read.mll\"\n \n# 403 \"lib/read.mll\"\n ( `Square_bracket )\n\n# 1562 \"lib/read.ml\"\n\n \n# 1563 \"lib/read.ml\"\n | 3 ->\n\n# 404 \"lib/read.mll\"\n \n# 404 \"lib/read.mll\"\n ( long_error \"Expected '<', '\\\"' or '[' but found\" v lexbuf )\n\n# 1567 \"lib/read.ml\"\n\n \n# 1568 \"lib/read.ml\"\n | 4 ->\n\n# 405 \"lib/read.mll\"\n \n# 405 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1572 \"lib/read.ml\"\n\n \n# 1573 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_start_any_variant_rec v lexbuf __ocaml_lex_state\n\nand finish_comment v lexbuf =\n __ocaml_lex_finish_comment_rec v lexbuf 125\nand __ocaml_lex_finish_comment_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 408 \"lib/read.mll\"\n \n# 408 \"lib/read.mll\"\n ( () )\n\n# 1584 \"lib/read.ml\"\n\n \n# 1585 \"lib/read.ml\"\n | 1 ->\n\n# 409 \"lib/read.mll\"\n \n# 409 \"lib/read.mll\"\n ( long_error \"Unterminated comment\" v lexbuf )\n\n# 1589 \"lib/read.ml\"\n\n \n# 1590 \"lib/read.ml\"\n | 2 ->\n\n# 410 \"lib/read.mll\"\n \n# 410 \"lib/read.mll\"\n ( newline v lexbuf; finish_comment v lexbuf )\n\n# 1594 \"lib/read.ml\"\n\n \n# 1595 \"lib/read.ml\"\n | 3 ->\n\n# 411 \"lib/read.mll\"\n \n# 411 \"lib/read.mll\"\n ( finish_comment v lexbuf )\n\n# 1599 \"lib/read.ml\"\n\n \n# 1600 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_comment_rec v lexbuf __ocaml_lex_state\n\nand read_eof lexbuf =\n __ocaml_lex_read_eof_rec lexbuf 131\nand __ocaml_lex_read_eof_rec lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 419 \"lib/read.mll\"\n \n# 419 \"lib/read.mll\"\n ( true )\n\n# 1611 \"lib/read.ml\"\n\n \n# 1612 \"lib/read.ml\"\n | 1 ->\n\n# 420 \"lib/read.mll\"\n \n# 420 \"lib/read.mll\"\n ( false )\n\n# 1616 \"lib/read.ml\"\n\n \n# 1617 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_eof_rec lexbuf __ocaml_lex_state\n\nand read_space v lexbuf =\n __ocaml_lex_read_space_rec v lexbuf 133\nand __ocaml_lex_read_space_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 423 \"lib/read.mll\"\n \n# 423 \"lib/read.mll\"\n ( newline v lexbuf; read_space v lexbuf )\n\n# 1628 \"lib/read.ml\"\n\n \n# 1629 \"lib/read.ml\"\n | 1 ->\n\n# 424 \"lib/read.mll\"\n \n# 424 \"lib/read.mll\"\n ( finish_comment v lexbuf; read_space v lexbuf )\n\n# 1633 \"lib/read.ml\"\n\n \n# 1634 \"lib/read.ml\"\n | 2 ->\n\n# 425 \"lib/read.mll\"\n \n# 425 \"lib/read.mll\"\n ( newline v lexbuf; read_space v lexbuf )\n\n# 1638 \"lib/read.ml\"\n\n \n# 1639 \"lib/read.ml\"\n | 3 ->\n\n# 426 \"lib/read.mll\"\n \n# 426 \"lib/read.mll\"\n ( read_space v lexbuf )\n\n# 1643 \"lib/read.ml\"\n\n \n# 1644 \"lib/read.ml\"\n | 4 ->\n\n# 427 \"lib/read.mll\"\n \n# 427 \"lib/read.mll\"\n ( () )\n\n# 1648 \"lib/read.ml\"\n\n \n# 1649 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_space_rec v lexbuf __ocaml_lex_state\n\nand read_null v lexbuf =\n __ocaml_lex_read_null_rec v lexbuf 140\nand __ocaml_lex_read_null_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 430 \"lib/read.mll\"\n \n# 430 \"lib/read.mll\"\n ( () )\n\n# 1660 \"lib/read.ml\"\n\n \n# 1661 \"lib/read.ml\"\n | 1 ->\n\n# 431 \"lib/read.mll\"\n \n# 431 \"lib/read.mll\"\n ( long_error \"Expected 'null' but found\" v lexbuf )\n\n# 1665 \"lib/read.ml\"\n\n \n# 1666 \"lib/read.ml\"\n | 2 ->\n\n# 432 \"lib/read.mll\"\n \n# 432 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1670 \"lib/read.ml\"\n\n \n# 1671 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_null_rec v lexbuf __ocaml_lex_state\n\nand read_null_if_possible v lexbuf =\n __ocaml_lex_read_null_if_possible_rec v lexbuf 147\nand __ocaml_lex_read_null_if_possible_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 435 \"lib/read.mll\"\n \n# 435 \"lib/read.mll\"\n ( true )\n\n# 1682 \"lib/read.ml\"\n\n \n# 1683 \"lib/read.ml\"\n | 1 ->\n\n# 436 \"lib/read.mll\"\n \n# 436 \"lib/read.mll\"\n ( false )\n\n# 1687 \"lib/read.ml\"\n\n \n# 1688 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_null_if_possible_rec v lexbuf __ocaml_lex_state\n\nand read_bool v lexbuf =\n __ocaml_lex_read_bool_rec v lexbuf 152\nand __ocaml_lex_read_bool_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 439 \"lib/read.mll\"\n \n# 439 \"lib/read.mll\"\n ( true )\n\n# 1699 \"lib/read.ml\"\n\n \n# 1700 \"lib/read.ml\"\n | 1 ->\n\n# 440 \"lib/read.mll\"\n \n# 440 \"lib/read.mll\"\n ( false )\n\n# 1704 \"lib/read.ml\"\n\n \n# 1705 \"lib/read.ml\"\n | 2 ->\n\n# 443 \"lib/read.mll\"\n \n# 443 \"lib/read.mll\"\n ( true )\n\n# 1709 \"lib/read.ml\"\n\n \n# 1710 \"lib/read.ml\"\n | 3 ->\n\n# 444 \"lib/read.mll\"\n \n# 444 \"lib/read.mll\"\n ( false )\n\n# 1714 \"lib/read.ml\"\n\n \n# 1715 \"lib/read.ml\"\n | 4 ->\n\n# 446 \"lib/read.mll\"\n \n# 446 \"lib/read.mll\"\n ( long_error \"Expected 'true' or 'false' but found\" v lexbuf )\n\n# 1719 \"lib/read.ml\"\n\n \n# 1720 \"lib/read.ml\"\n | 5 ->\n\n# 447 \"lib/read.mll\"\n \n# 447 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1724 \"lib/read.ml\"\n\n \n# 1725 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_bool_rec v lexbuf __ocaml_lex_state\n\nand read_int v lexbuf =\n __ocaml_lex_read_int_rec v lexbuf 176\nand __ocaml_lex_read_int_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 450 \"lib/read.mll\"\n \n# 450 \"lib/read.mll\"\n ( try extract_positive_int lexbuf\n with Int_overflow ->\n lexer_error \"Int overflow\" v lexbuf )\n\n# 1738 \"lib/read.ml\"\n\n \n# 1739 \"lib/read.ml\"\n | 1 ->\n\n# 453 \"lib/read.mll\"\n \n# 453 \"lib/read.mll\"\n ( try extract_negative_int lexbuf\n with Int_overflow ->\n lexer_error \"Int overflow\" v lexbuf )\n\n# 1745 \"lib/read.ml\"\n\n \n# 1746 \"lib/read.ml\"\n | 2 ->\n\n# 456 \"lib/read.mll\"\n \n# 456 \"lib/read.mll\"\n ( (* Support for double-quoted \"ints\" *)\n Bi_outbuf.clear v.buf;\n let s = finish_string v lexbuf in\n try\n (* Any OCaml-compliant int will pass,\n including hexadecimal and octal notations,\n and embedded underscores *)\n int_of_string s\n with _ ->\n custom_error\n \"Expected an integer but found a string that \\\n doesn't even represent an integer\"\n v lexbuf\n )\n\n# 1763 \"lib/read.ml\"\n\n \n# 1764 \"lib/read.ml\"\n | 3 ->\n\n# 470 \"lib/read.mll\"\n \n# 470 \"lib/read.mll\"\n ( long_error \"Expected integer but found\" v lexbuf )\n\n# 1768 \"lib/read.ml\"\n\n \n# 1769 \"lib/read.ml\"\n | 4 ->\n\n# 471 \"lib/read.mll\"\n \n# 471 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1773 \"lib/read.ml\"\n\n \n# 1774 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_int_rec v lexbuf __ocaml_lex_state\n\nand read_int32 v lexbuf =\n __ocaml_lex_read_int32_rec v lexbuf 185\nand __ocaml_lex_read_int32_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 474 \"lib/read.mll\"\n \n# 474 \"lib/read.mll\"\n ( try Int32.of_string (Lexing.lexeme lexbuf)\n with _ ->\n lexer_error \"Int32 overflow\" v lexbuf )\n\n# 1787 \"lib/read.ml\"\n\n \n# 1788 \"lib/read.ml\"\n | 1 ->\n\n# 477 \"lib/read.mll\"\n \n# 477 \"lib/read.mll\"\n ( (* Support for double-quoted \"ints\" *)\n Bi_outbuf.clear v.buf;\n let s = finish_string v lexbuf in\n try\n (* Any OCaml-compliant int will pass,\n including hexadecimal and octal notations,\n and embedded underscores *)\n Int32.of_string s\n with _ ->\n custom_error\n \"Expected an int32 but found a string that \\\n doesn't even represent an integer\"\n v lexbuf\n )\n\n# 1805 \"lib/read.ml\"\n\n \n# 1806 \"lib/read.ml\"\n | 2 ->\n\n# 491 \"lib/read.mll\"\n \n# 491 \"lib/read.mll\"\n ( long_error \"Expected int32 but found\" v lexbuf )\n\n# 1810 \"lib/read.ml\"\n\n \n# 1811 \"lib/read.ml\"\n | 3 ->\n\n# 492 \"lib/read.mll\"\n \n# 492 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1815 \"lib/read.ml\"\n\n \n# 1816 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_int32_rec v lexbuf __ocaml_lex_state\n\nand read_int64 v lexbuf =\n __ocaml_lex_read_int64_rec v lexbuf 192\nand __ocaml_lex_read_int64_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 495 \"lib/read.mll\"\n \n# 495 \"lib/read.mll\"\n ( try Int64.of_string (Lexing.lexeme lexbuf)\n with _ ->\n lexer_error \"Int32 overflow\" v lexbuf )\n\n# 1829 \"lib/read.ml\"\n\n \n# 1830 \"lib/read.ml\"\n | 1 ->\n\n# 498 \"lib/read.mll\"\n \n# 498 \"lib/read.mll\"\n ( (* Support for double-quoted \"ints\" *)\n Bi_outbuf.clear v.buf;\n let s = finish_string v lexbuf in\n try\n (* Any OCaml-compliant int will pass,\n including hexadecimal and octal notations,\n and embedded underscores *)\n Int64.of_string s\n with _ ->\n custom_error\n \"Expected an int64 but found a string that \\\n doesn't even represent an integer\"\n v lexbuf\n )\n\n# 1847 \"lib/read.ml\"\n\n \n# 1848 \"lib/read.ml\"\n | 2 ->\n\n# 512 \"lib/read.mll\"\n \n# 512 \"lib/read.mll\"\n ( long_error \"Expected int64 but found\" v lexbuf )\n\n# 1852 \"lib/read.ml\"\n\n \n# 1853 \"lib/read.ml\"\n | 3 ->\n\n# 513 \"lib/read.mll\"\n \n# 513 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1857 \"lib/read.ml\"\n\n \n# 1858 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_int64_rec v lexbuf __ocaml_lex_state\n\nand read_number v lexbuf =\n __ocaml_lex_read_number_rec v lexbuf 199\nand __ocaml_lex_read_number_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 516 \"lib/read.mll\"\n \n# 516 \"lib/read.mll\"\n ( nan )\n\n# 1869 \"lib/read.ml\"\n\n \n# 1870 \"lib/read.ml\"\n | 1 ->\n\n# 517 \"lib/read.mll\"\n \n# 517 \"lib/read.mll\"\n ( infinity )\n\n# 1874 \"lib/read.ml\"\n\n \n# 1875 \"lib/read.ml\"\n | 2 ->\n\n# 518 \"lib/read.mll\"\n \n# 518 \"lib/read.mll\"\n ( neg_infinity )\n\n# 1879 \"lib/read.ml\"\n\n \n# 1880 \"lib/read.ml\"\n | 3 ->\n\n# 519 \"lib/read.mll\"\n \n# 519 \"lib/read.mll\"\n ( float_of_string (lexeme lexbuf) )\n\n# 1884 \"lib/read.ml\"\n\n \n# 1885 \"lib/read.ml\"\n | 4 ->\n\n# 520 \"lib/read.mll\"\n \n# 520 \"lib/read.mll\"\n ( Bi_outbuf.clear v.buf;\n let s = finish_string v lexbuf in\n try\n (* Any OCaml-compliant float will pass,\n including hexadecimal and octal notations,\n and embedded underscores. *)\n float_of_string s\n with _ ->\n match s with\n \"NaN\" -> nan\n | \"Infinity\" -> infinity\n | \"-Infinity\" -> neg_infinity\n | _ ->\n custom_error\n \"Expected a number but found a string that \\\n doesn't even represent a number\"\n v lexbuf\n )\n\n# 1906 \"lib/read.ml\"\n\n \n# 1907 \"lib/read.ml\"\n | 5 ->\n\n# 538 \"lib/read.mll\"\n \n# 538 \"lib/read.mll\"\n ( long_error \"Expected number but found\" v lexbuf )\n\n# 1911 \"lib/read.ml\"\n\n \n# 1912 \"lib/read.ml\"\n | 6 ->\n\n# 539 \"lib/read.mll\"\n \n# 539 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1916 \"lib/read.ml\"\n\n \n# 1917 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_number_rec v lexbuf __ocaml_lex_state\n\nand read_string v lexbuf =\n __ocaml_lex_read_string_rec v lexbuf 233\nand __ocaml_lex_read_string_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 542 \"lib/read.mll\"\n \n# 542 \"lib/read.mll\"\n ( Bi_outbuf.clear v.buf;\n finish_string v lexbuf )\n\n# 1929 \"lib/read.ml\"\n\n \n# 1930 \"lib/read.ml\"\n | 1 ->\n\n# 544 \"lib/read.mll\"\n \n# 544 \"lib/read.mll\"\n ( long_error \"Expected '\\\"' but found\" v lexbuf )\n\n# 1934 \"lib/read.ml\"\n\n \n# 1935 \"lib/read.ml\"\n | 2 ->\n\n# 545 \"lib/read.mll\"\n \n# 545 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1939 \"lib/read.ml\"\n\n \n# 1940 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_string_rec v lexbuf __ocaml_lex_state\n\nand read_ident v lexbuf =\n __ocaml_lex_read_ident_rec v lexbuf 237\nand __ocaml_lex_read_ident_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 548 \"lib/read.mll\"\n \n# 548 \"lib/read.mll\"\n ( Bi_outbuf.clear v.buf;\n finish_string v lexbuf )\n\n# 1952 \"lib/read.ml\"\n\n \n# 1953 \"lib/read.ml\"\n | 1 ->\nlet\n\n# 550 \"lib/read.mll\"\n \n# 550 \"lib/read.mll\"\n s\n\n# 1958 \"lib/read.ml\"\n# 1958 \"lib/read.ml\"\n= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos lexbuf.Lexing.lex_curr_pos in\n\n# 551 \"lib/read.mll\"\n \n# 551 \"lib/read.mll\"\n ( s )\n\n# 1962 \"lib/read.ml\"\n\n \n# 1963 \"lib/read.ml\"\n | 2 ->\n\n# 552 \"lib/read.mll\"\n \n# 552 \"lib/read.mll\"\n ( long_error \"Expected string or identifier but found\" v lexbuf )\n\n# 1967 \"lib/read.ml\"\n\n \n# 1968 \"lib/read.ml\"\n | 3 ->\n\n# 553 \"lib/read.mll\"\n \n# 553 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1972 \"lib/read.ml\"\n\n \n# 1973 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_ident_rec v lexbuf __ocaml_lex_state\n\nand map_ident v f lexbuf =\n __ocaml_lex_map_ident_rec v f lexbuf 242\nand __ocaml_lex_map_ident_rec v f lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 556 \"lib/read.mll\"\n \n# 556 \"lib/read.mll\"\n ( Bi_outbuf.clear v.buf;\n map_string v f lexbuf )\n\n# 1985 \"lib/read.ml\"\n\n \n# 1986 \"lib/read.ml\"\n | 1 ->\n\n# 559 \"lib/read.mll\"\n \n# 559 \"lib/read.mll\"\n ( map_lexeme f lexbuf )\n\n# 1990 \"lib/read.ml\"\n\n \n# 1991 \"lib/read.ml\"\n | 2 ->\n\n# 560 \"lib/read.mll\"\n \n# 560 \"lib/read.mll\"\n ( long_error \"Expected string or identifier but found\" v lexbuf )\n\n# 1995 \"lib/read.ml\"\n\n \n# 1996 \"lib/read.ml\"\n | 3 ->\n\n# 561 \"lib/read.mll\"\n \n# 561 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2000 \"lib/read.ml\"\n\n \n# 2001 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_map_ident_rec v f lexbuf __ocaml_lex_state\n\nand read_sequence read_cell init_acc v lexbuf =\n __ocaml_lex_read_sequence_rec read_cell init_acc v lexbuf 247\nand __ocaml_lex_read_sequence_rec read_cell init_acc v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 564 \"lib/read.mll\"\n \n# 564 \"lib/read.mll\"\n ( let acc = ref init_acc in\n try\n read_space v lexbuf;\n read_array_end lexbuf;\n acc := read_cell !acc v lexbuf;\n while true do\n read_space v lexbuf;\n read_array_sep v lexbuf;\n read_space v lexbuf;\n acc := read_cell !acc v lexbuf;\n done;\n assert false\n with End_of_array ->\n !acc\n )\n\n# 2026 \"lib/read.ml\"\n\n \n# 2027 \"lib/read.ml\"\n | 1 ->\n\n# 579 \"lib/read.mll\"\n \n# 579 \"lib/read.mll\"\n ( long_error \"Expected '[' but found\" v lexbuf )\n\n# 2031 \"lib/read.ml\"\n\n \n# 2032 \"lib/read.ml\"\n | 2 ->\n\n# 580 \"lib/read.mll\"\n \n# 580 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2036 \"lib/read.ml\"\n\n \n# 2037 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_sequence_rec read_cell init_acc v lexbuf __ocaml_lex_state\n\nand read_list_rev read_cell v lexbuf =\n __ocaml_lex_read_list_rev_rec read_cell v lexbuf 251\nand __ocaml_lex_read_list_rev_rec read_cell v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 583 \"lib/read.mll\"\n \n# 583 \"lib/read.mll\"\n ( let acc = ref [] in\n try\n read_space v lexbuf;\n read_array_end lexbuf;\n acc := read_cell v lexbuf :: !acc;\n while true do\n read_space v lexbuf;\n read_array_sep v lexbuf;\n read_space v lexbuf;\n acc := read_cell v lexbuf :: !acc;\n done;\n assert false\n with End_of_array ->\n !acc\n )\n\n# 2062 \"lib/read.ml\"\n\n \n# 2063 \"lib/read.ml\"\n | 1 ->\n\n# 598 \"lib/read.mll\"\n \n# 598 \"lib/read.mll\"\n ( long_error \"Expected '[' but found\" v lexbuf )\n\n# 2067 \"lib/read.ml\"\n\n \n# 2068 \"lib/read.ml\"\n | 2 ->\n\n# 599 \"lib/read.mll\"\n \n# 599 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2072 \"lib/read.ml\"\n\n \n# 2073 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_list_rev_rec read_cell v lexbuf __ocaml_lex_state\n\nand read_array_end lexbuf =\n __ocaml_lex_read_array_end_rec lexbuf 255\nand __ocaml_lex_read_array_end_rec lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 602 \"lib/read.mll\"\n \n# 602 \"lib/read.mll\"\n ( raise End_of_array )\n\n# 2084 \"lib/read.ml\"\n\n \n# 2085 \"lib/read.ml\"\n | 1 ->\n\n# 603 \"lib/read.mll\"\n \n# 603 \"lib/read.mll\"\n ( () )\n\n# 2089 \"lib/read.ml\"\n\n \n# 2090 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_array_end_rec lexbuf __ocaml_lex_state\n\nand read_array_sep v lexbuf =\n __ocaml_lex_read_array_sep_rec v lexbuf 257\nand __ocaml_lex_read_array_sep_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 606 \"lib/read.mll\"\n \n# 606 \"lib/read.mll\"\n ( () )\n\n# 2101 \"lib/read.ml\"\n\n \n# 2102 \"lib/read.ml\"\n | 1 ->\n\n# 607 \"lib/read.mll\"\n \n# 607 \"lib/read.mll\"\n ( raise End_of_array )\n\n# 2106 \"lib/read.ml\"\n\n \n# 2107 \"lib/read.ml\"\n | 2 ->\n\n# 608 \"lib/read.mll\"\n \n# 608 \"lib/read.mll\"\n ( long_error \"Expected ',' or ']' but found\" v lexbuf )\n\n# 2111 \"lib/read.ml\"\n\n \n# 2112 \"lib/read.ml\"\n | 3 ->\n\n# 609 \"lib/read.mll\"\n \n# 609 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2116 \"lib/read.ml\"\n\n \n# 2117 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_array_sep_rec v lexbuf __ocaml_lex_state\n\nand read_tuple read_cell init_acc v lexbuf =\n __ocaml_lex_read_tuple_rec read_cell init_acc v lexbuf 262\nand __ocaml_lex_read_tuple_rec read_cell init_acc v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 613 \"lib/read.mll\"\n \n# 613 \"lib/read.mll\"\n (\n \n# 615 \"lib/read.mll\"\n let pos = ref 0 in\n let acc = ref init_acc in\n try\n read_space v lexbuf;\n read_tuple_end lexbuf;\n acc := read_cell !pos !acc v lexbuf;\n incr pos;\n while true do\n read_space v lexbuf;\n read_tuple_sep v lexbuf;\n read_space v lexbuf;\n acc := read_cell !pos !acc v lexbuf;\n incr pos;\n done;\n assert false\n with End_of_tuple ->\n !acc\n \n# 635 \"lib/read.mll\"\n )\n\n# 2150 \"lib/read.ml\"\n\n \n# 2151 \"lib/read.ml\"\n | 1 ->\n\n# 636 \"lib/read.mll\"\n \n# 636 \"lib/read.mll\"\n ( long_error \"Expected ')' but found\" v lexbuf )\n\n# 2155 \"lib/read.ml\"\n\n \n# 2156 \"lib/read.ml\"\n | 2 ->\n\n# 637 \"lib/read.mll\"\n \n# 637 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2160 \"lib/read.ml\"\n\n \n# 2161 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_tuple_rec read_cell init_acc v lexbuf __ocaml_lex_state\n\nand read_tuple_end lexbuf =\n __ocaml_lex_read_tuple_end_rec lexbuf 266\nand __ocaml_lex_read_tuple_end_rec lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 640 \"lib/read.mll\"\n \n# 640 \"lib/read.mll\"\n ( raise End_of_tuple )\n\n# 2172 \"lib/read.ml\"\n\n \n# 2173 \"lib/read.ml\"\n | 1 ->\n\n# 641 \"lib/read.mll\"\n \n# 641 \"lib/read.mll\"\n ( () )\n\n# 2177 \"lib/read.ml\"\n\n \n# 2178 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_tuple_end_rec lexbuf __ocaml_lex_state\n\nand read_tuple_end2 v std lexbuf =\n __ocaml_lex_read_tuple_end2_rec v std lexbuf 268\nand __ocaml_lex_read_tuple_end2_rec v std lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 644 \"lib/read.mll\"\n \n# 644 \"lib/read.mll\"\n ( if std then\n long_error \"Expected ')' or '' but found\" v lexbuf\n else\n raise End_of_tuple )\n\n# 2192 \"lib/read.ml\"\n\n \n# 2193 \"lib/read.ml\"\n | 1 ->\n\n# 648 \"lib/read.mll\"\n \n# 648 \"lib/read.mll\"\n ( if std then\n raise End_of_tuple\n else\n long_error \"Expected ']' or '' but found\" v lexbuf )\n\n# 2200 \"lib/read.ml\"\n\n \n# 2201 \"lib/read.ml\"\n | 2 ->\n\n# 652 \"lib/read.mll\"\n \n# 652 \"lib/read.mll\"\n ( () )\n\n# 2205 \"lib/read.ml\"\n\n \n# 2206 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_tuple_end2_rec v std lexbuf __ocaml_lex_state\n\nand read_tuple_sep v lexbuf =\n __ocaml_lex_read_tuple_sep_rec v lexbuf 271\nand __ocaml_lex_read_tuple_sep_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 655 \"lib/read.mll\"\n \n# 655 \"lib/read.mll\"\n ( () )\n\n# 2217 \"lib/read.ml\"\n\n \n# 2218 \"lib/read.ml\"\n | 1 ->\n\n# 656 \"lib/read.mll\"\n \n# 656 \"lib/read.mll\"\n ( raise End_of_tuple )\n\n# 2222 \"lib/read.ml\"\n\n \n# 2223 \"lib/read.ml\"\n | 2 ->\n\n# 657 \"lib/read.mll\"\n \n# 657 \"lib/read.mll\"\n ( long_error \"Expected ',' or ')' but found\" v lexbuf )\n\n# 2227 \"lib/read.ml\"\n\n \n# 2228 \"lib/read.ml\"\n | 3 ->\n\n# 658 \"lib/read.mll\"\n \n# 658 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2232 \"lib/read.ml\"\n\n \n# 2233 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_tuple_sep_rec v lexbuf __ocaml_lex_state\n\nand read_tuple_sep2 v std lexbuf =\n __ocaml_lex_read_tuple_sep2_rec v std lexbuf 276\nand __ocaml_lex_read_tuple_sep2_rec v std lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 661 \"lib/read.mll\"\n \n# 661 \"lib/read.mll\"\n ( () )\n\n# 2244 \"lib/read.ml\"\n\n \n# 2245 \"lib/read.ml\"\n | 1 ->\n\n# 662 \"lib/read.mll\"\n \n# 662 \"lib/read.mll\"\n ( if std then\n long_error \"Expected ',' or ']' but found\" v lexbuf\n else\n raise End_of_tuple )\n\n# 2252 \"lib/read.ml\"\n\n \n# 2253 \"lib/read.ml\"\n | 2 ->\n\n# 666 \"lib/read.mll\"\n \n# 666 \"lib/read.mll\"\n ( if std then\n raise End_of_tuple\n else\n long_error \"Expected ',' or ')' but found\" v lexbuf )\n\n# 2260 \"lib/read.ml\"\n\n \n# 2261 \"lib/read.ml\"\n | 3 ->\n\n# 670 \"lib/read.mll\"\n \n# 670 \"lib/read.mll\"\n ( long_error \"Expected ',' or ')' but found\" v lexbuf )\n\n# 2265 \"lib/read.ml\"\n\n \n# 2266 \"lib/read.ml\"\n | 4 ->\n\n# 671 \"lib/read.mll\"\n \n# 671 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2270 \"lib/read.ml\"\n\n \n# 2271 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_tuple_sep2_rec v std lexbuf __ocaml_lex_state\n\nand read_abstract_fields read_key read_field init_acc v lexbuf =\n __ocaml_lex_read_abstract_fields_rec read_key read_field init_acc v lexbuf 282\nand __ocaml_lex_read_abstract_fields_rec read_key read_field init_acc v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 675 \"lib/read.mll\"\n \n# 675 \"lib/read.mll\"\n ( let acc = ref init_acc in\n try\n read_space v lexbuf;\n read_object_end lexbuf;\n let field_name = read_key v lexbuf in\n read_space v lexbuf;\n read_colon v lexbuf;\n read_space v lexbuf;\n acc := read_field !acc field_name v lexbuf;\n while true do\n read_space v lexbuf;\n read_object_sep v lexbuf;\n read_space v lexbuf;\n let field_name = read_key v lexbuf in\n read_space v lexbuf;\n read_colon v lexbuf;\n read_space v lexbuf;\n acc := read_field !acc field_name v lexbuf;\n done;\n assert false\n with End_of_object ->\n !acc\n )\n\n# 2304 \"lib/read.ml\"\n\n \n# 2305 \"lib/read.ml\"\n | 1 ->\n\n# 698 \"lib/read.mll\"\n \n# 698 \"lib/read.mll\"\n ( long_error \"Expected '{' but found\" v lexbuf )\n\n# 2309 \"lib/read.ml\"\n\n \n# 2310 \"lib/read.ml\"\n | 2 ->\n\n# 699 \"lib/read.mll\"\n \n# 699 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2314 \"lib/read.ml\"\n\n \n# 2315 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_abstract_fields_rec read_key read_field init_acc v lexbuf __ocaml_lex_state\n\nand read_lcurl v lexbuf =\n __ocaml_lex_read_lcurl_rec v lexbuf 286\nand __ocaml_lex_read_lcurl_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 702 \"lib/read.mll\"\n \n# 702 \"lib/read.mll\"\n ( () )\n\n# 2326 \"lib/read.ml\"\n\n \n# 2327 \"lib/read.ml\"\n | 1 ->\n\n# 703 \"lib/read.mll\"\n \n# 703 \"lib/read.mll\"\n ( long_error \"Expected '{' but found\" v lexbuf )\n\n# 2331 \"lib/read.ml\"\n\n \n# 2332 \"lib/read.ml\"\n | 2 ->\n\n# 704 \"lib/read.mll\"\n \n# 704 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2336 \"lib/read.ml\"\n\n \n# 2337 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_lcurl_rec v lexbuf __ocaml_lex_state\n\nand read_object_end lexbuf =\n __ocaml_lex_read_object_end_rec lexbuf 290\nand __ocaml_lex_read_object_end_rec lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 707 \"lib/read.mll\"\n \n# 707 \"lib/read.mll\"\n ( raise End_of_object )\n\n# 2348 \"lib/read.ml\"\n\n \n# 2349 \"lib/read.ml\"\n | 1 ->\n\n# 708 \"lib/read.mll\"\n \n# 708 \"lib/read.mll\"\n ( () )\n\n# 2353 \"lib/read.ml\"\n\n \n# 2354 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_object_end_rec lexbuf __ocaml_lex_state\n\nand read_object_sep v lexbuf =\n __ocaml_lex_read_object_sep_rec v lexbuf 292\nand __ocaml_lex_read_object_sep_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 711 \"lib/read.mll\"\n \n# 711 \"lib/read.mll\"\n ( () )\n\n# 2365 \"lib/read.ml\"\n\n \n# 2366 \"lib/read.ml\"\n | 1 ->\n\n# 712 \"lib/read.mll\"\n \n# 712 \"lib/read.mll\"\n ( raise End_of_object )\n\n# 2370 \"lib/read.ml\"\n\n \n# 2371 \"lib/read.ml\"\n | 2 ->\n\n# 713 \"lib/read.mll\"\n \n# 713 \"lib/read.mll\"\n ( long_error \"Expected ',' or '}' but found\" v lexbuf )\n\n# 2375 \"lib/read.ml\"\n\n \n# 2376 \"lib/read.ml\"\n | 3 ->\n\n# 714 \"lib/read.mll\"\n \n# 714 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2380 \"lib/read.ml\"\n\n \n# 2381 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_object_sep_rec v lexbuf __ocaml_lex_state\n\nand read_colon v lexbuf =\n __ocaml_lex_read_colon_rec v lexbuf 297\nand __ocaml_lex_read_colon_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 717 \"lib/read.mll\"\n \n# 717 \"lib/read.mll\"\n ( () )\n\n# 2392 \"lib/read.ml\"\n\n \n# 2393 \"lib/read.ml\"\n | 1 ->\n\n# 718 \"lib/read.mll\"\n \n# 718 \"lib/read.mll\"\n ( long_error \"Expected ':' but found\" v lexbuf )\n\n# 2397 \"lib/read.ml\"\n\n \n# 2398 \"lib/read.ml\"\n | 2 ->\n\n# 719 \"lib/read.mll\"\n \n# 719 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2402 \"lib/read.ml\"\n\n \n# 2403 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_colon_rec v lexbuf __ocaml_lex_state\n\nand start_any_tuple v lexbuf =\n __ocaml_lex_start_any_tuple_rec v lexbuf 301\nand __ocaml_lex_start_any_tuple_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 722 \"lib/read.mll\"\n \n# 722 \"lib/read.mll\"\n ( false )\n\n# 2414 \"lib/read.ml\"\n\n \n# 2415 \"lib/read.ml\"\n | 1 ->\n\n# 723 \"lib/read.mll\"\n \n# 723 \"lib/read.mll\"\n ( true )\n\n# 2419 \"lib/read.ml\"\n\n \n# 2420 \"lib/read.ml\"\n | 2 ->\n\n# 724 \"lib/read.mll\"\n \n# 724 \"lib/read.mll\"\n ( long_error \"Expected '(' or '[' but found\" v lexbuf )\n\n# 2424 \"lib/read.ml\"\n\n \n# 2425 \"lib/read.ml\"\n | 3 ->\n\n# 725 \"lib/read.mll\"\n \n# 725 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2429 \"lib/read.ml\"\n\n \n# 2430 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_start_any_tuple_rec v lexbuf __ocaml_lex_state\n\nand read_lpar v lexbuf =\n __ocaml_lex_read_lpar_rec v lexbuf 306\nand __ocaml_lex_read_lpar_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 728 \"lib/read.mll\"\n \n# 728 \"lib/read.mll\"\n ( () )\n\n# 2441 \"lib/read.ml\"\n\n \n# 2442 \"lib/read.ml\"\n | 1 ->\n\n# 729 \"lib/read.mll\"\n \n# 729 \"lib/read.mll\"\n ( long_error \"Expected '(' but found\" v lexbuf )\n\n# 2446 \"lib/read.ml\"\n\n \n# 2447 \"lib/read.ml\"\n | 2 ->\n\n# 730 \"lib/read.mll\"\n \n# 730 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2451 \"lib/read.ml\"\n\n \n# 2452 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_lpar_rec v lexbuf __ocaml_lex_state\n\nand read_rpar v lexbuf =\n __ocaml_lex_read_rpar_rec v lexbuf 310\nand __ocaml_lex_read_rpar_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 733 \"lib/read.mll\"\n \n# 733 \"lib/read.mll\"\n ( () )\n\n# 2463 \"lib/read.ml\"\n\n \n# 2464 \"lib/read.ml\"\n | 1 ->\n\n# 734 \"lib/read.mll\"\n \n# 734 \"lib/read.mll\"\n ( long_error \"Expected ')' but found\" v lexbuf )\n\n# 2468 \"lib/read.ml\"\n\n \n# 2469 \"lib/read.ml\"\n | 2 ->\n\n# 735 \"lib/read.mll\"\n \n# 735 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2473 \"lib/read.ml\"\n\n \n# 2474 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_rpar_rec v lexbuf __ocaml_lex_state\n\nand read_lbr v lexbuf =\n __ocaml_lex_read_lbr_rec v lexbuf 314\nand __ocaml_lex_read_lbr_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 738 \"lib/read.mll\"\n \n# 738 \"lib/read.mll\"\n ( () )\n\n# 2485 \"lib/read.ml\"\n\n \n# 2486 \"lib/read.ml\"\n | 1 ->\n\n# 739 \"lib/read.mll\"\n \n# 739 \"lib/read.mll\"\n ( long_error \"Expected '[' but found\" v lexbuf )\n\n# 2490 \"lib/read.ml\"\n\n \n# 2491 \"lib/read.ml\"\n | 2 ->\n\n# 740 \"lib/read.mll\"\n \n# 740 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2495 \"lib/read.ml\"\n\n \n# 2496 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_lbr_rec v lexbuf __ocaml_lex_state\n\nand read_rbr v lexbuf =\n __ocaml_lex_read_rbr_rec v lexbuf 318\nand __ocaml_lex_read_rbr_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 743 \"lib/read.mll\"\n \n# 743 \"lib/read.mll\"\n ( () )\n\n# 2507 \"lib/read.ml\"\n\n \n# 2508 \"lib/read.ml\"\n | 1 ->\n\n# 744 \"lib/read.mll\"\n \n# 744 \"lib/read.mll\"\n ( long_error \"Expected ']' but found\" v lexbuf )\n\n# 2512 \"lib/read.ml\"\n\n \n# 2513 \"lib/read.ml\"\n | 2 ->\n\n# 745 \"lib/read.mll\"\n \n# 745 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2517 \"lib/read.ml\"\n\n \n# 2518 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_rbr_rec v lexbuf __ocaml_lex_state\n\nand skip_json v lexbuf =\n __ocaml_lex_skip_json_rec v lexbuf 322\nand __ocaml_lex_skip_json_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 751 \"lib/read.mll\"\n \n# 751 \"lib/read.mll\"\n ( () )\n\n# 2529 \"lib/read.ml\"\n\n \n# 2530 \"lib/read.ml\"\n | 1 ->\n\n# 752 \"lib/read.mll\"\n \n# 752 \"lib/read.mll\"\n ( () )\n\n# 2534 \"lib/read.ml\"\n\n \n# 2535 \"lib/read.ml\"\n | 2 ->\n\n# 753 \"lib/read.mll\"\n \n# 753 \"lib/read.mll\"\n ( () )\n\n# 2539 \"lib/read.ml\"\n\n \n# 2540 \"lib/read.ml\"\n | 3 ->\n\n# 754 \"lib/read.mll\"\n \n# 754 \"lib/read.mll\"\n ( () )\n\n# 2544 \"lib/read.ml\"\n\n \n# 2545 \"lib/read.ml\"\n | 4 ->\n\n# 755 \"lib/read.mll\"\n \n# 755 \"lib/read.mll\"\n ( () )\n\n# 2549 \"lib/read.ml\"\n\n \n# 2550 \"lib/read.ml\"\n | 5 ->\n\n# 756 \"lib/read.mll\"\n \n# 756 \"lib/read.mll\"\n ( () )\n\n# 2554 \"lib/read.ml\"\n\n \n# 2555 \"lib/read.ml\"\n | 6 ->\n\n# 757 \"lib/read.mll\"\n \n# 757 \"lib/read.mll\"\n ( finish_skip_stringlit v lexbuf )\n\n# 2559 \"lib/read.ml\"\n\n \n# 2560 \"lib/read.ml\"\n | 7 ->\n\n# 758 \"lib/read.mll\"\n \n# 758 \"lib/read.mll\"\n ( () )\n\n# 2564 \"lib/read.ml\"\n\n \n# 2565 \"lib/read.ml\"\n | 8 ->\n\n# 759 \"lib/read.mll\"\n \n# 759 \"lib/read.mll\"\n ( () )\n\n# 2569 \"lib/read.ml\"\n\n \n# 2570 \"lib/read.ml\"\n | 9 ->\n\n# 761 \"lib/read.mll\"\n \n# 761 \"lib/read.mll\"\n ( try\n read_space v lexbuf;\n read_object_end lexbuf;\n skip_ident v lexbuf;\n read_space v lexbuf;\n read_colon v lexbuf;\n read_space v lexbuf;\n skip_json v lexbuf;\n while true do\n read_space v lexbuf;\n read_object_sep v lexbuf;\n read_space v lexbuf;\n skip_ident v lexbuf;\n read_space v lexbuf;\n read_colon v lexbuf;\n read_space v lexbuf;\n skip_json v lexbuf;\n done;\n assert false\n with End_of_object ->\n ()\n )\n\n# 2595 \"lib/read.ml\"\n\n \n# 2596 \"lib/read.ml\"\n | 10 ->\n\n# 784 \"lib/read.mll\"\n \n# 784 \"lib/read.mll\"\n ( try\n read_space v lexbuf;\n read_array_end lexbuf;\n skip_json v lexbuf;\n while true do\n read_space v lexbuf;\n read_array_sep v lexbuf;\n read_space v lexbuf;\n skip_json v lexbuf;\n done;\n assert false\n with End_of_array ->\n ()\n )\n\n# 2613 \"lib/read.ml\"\n\n \n# 2614 \"lib/read.ml\"\n | 11 ->\n\n# 799 \"lib/read.mll\"\n \n# 799 \"lib/read.mll\"\n (\n \n# 801 \"lib/read.mll\"\n try\n read_space v lexbuf;\n read_tuple_end lexbuf;\n skip_json v lexbuf;\n while true do\n read_space v lexbuf;\n read_tuple_sep v lexbuf;\n read_space v lexbuf;\n skip_json v lexbuf;\n done;\n assert false\n with End_of_tuple ->\n ()\n \n# 817 \"lib/read.mll\"\n )\n\n# 2636 \"lib/read.ml\"\n\n \n# 2637 \"lib/read.ml\"\n | 12 ->\n\n# 819 \"lib/read.mll\"\n \n# 819 \"lib/read.mll\"\n (\n \n# 821 \"lib/read.mll\"\n read_space v lexbuf;\n skip_ident v lexbuf;\n read_space v lexbuf;\n finish_skip_variant v lexbuf\n \n# 828 \"lib/read.mll\"\n )\n\n# 2650 \"lib/read.ml\"\n\n \n# 2651 \"lib/read.ml\"\n | 13 ->\n\n# 830 \"lib/read.mll\"\n \n# 830 \"lib/read.mll\"\n ( skip_json v lexbuf )\n\n# 2655 \"lib/read.ml\"\n\n \n# 2656 \"lib/read.ml\"\n | 14 ->\n\n# 831 \"lib/read.mll\"\n \n# 831 \"lib/read.mll\"\n ( finish_comment v lexbuf; skip_json v lexbuf )\n\n# 2660 \"lib/read.ml\"\n\n \n# 2661 \"lib/read.ml\"\n | 15 ->\n\n# 832 \"lib/read.mll\"\n \n# 832 \"lib/read.mll\"\n ( newline v lexbuf; skip_json v lexbuf )\n\n# 2665 \"lib/read.ml\"\n\n \n# 2666 \"lib/read.ml\"\n | 16 ->\n\n# 833 \"lib/read.mll\"\n \n# 833 \"lib/read.mll\"\n ( skip_json v lexbuf )\n\n# 2670 \"lib/read.ml\"\n\n \n# 2671 \"lib/read.ml\"\n | 17 ->\n\n# 834 \"lib/read.mll\"\n \n# 834 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2675 \"lib/read.ml\"\n\n \n# 2676 \"lib/read.ml\"\n | 18 ->\n\n# 835 \"lib/read.mll\"\n \n# 835 \"lib/read.mll\"\n ( long_error \"Invalid token\" v lexbuf )\n\n# 2680 \"lib/read.ml\"\n\n \n# 2681 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_skip_json_rec v lexbuf __ocaml_lex_state\n\nand finish_skip_stringlit v lexbuf =\n __ocaml_lex_finish_skip_stringlit_rec v lexbuf 378\nand __ocaml_lex_finish_skip_stringlit_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 841 \"lib/read.mll\"\n \n# 841 \"lib/read.mll\"\n ( () )\n\n# 2692 \"lib/read.ml\"\n\n \n# 2693 \"lib/read.ml\"\n | 1 ->\n\n# 842 \"lib/read.mll\"\n \n# 842 \"lib/read.mll\"\n ( long_error \"Invalid string literal\" v lexbuf )\n\n# 2697 \"lib/read.ml\"\n\n \n# 2698 \"lib/read.ml\"\n | 2 ->\n\n# 843 \"lib/read.mll\"\n \n# 843 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2702 \"lib/read.ml\"\n\n \n# 2703 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_skip_stringlit_rec v lexbuf __ocaml_lex_state\n\nand finish_skip_variant v lexbuf =\n __ocaml_lex_finish_skip_variant_rec v lexbuf 389\nand __ocaml_lex_finish_skip_variant_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 846 \"lib/read.mll\"\n \n# 846 \"lib/read.mll\"\n ( skip_json v lexbuf;\n read_space v lexbuf;\n read_gt v lexbuf )\n\n# 2716 \"lib/read.ml\"\n\n \n# 2717 \"lib/read.ml\"\n | 1 ->\n\n# 849 \"lib/read.mll\"\n \n# 849 \"lib/read.mll\"\n ( () )\n\n# 2721 \"lib/read.ml\"\n\n \n# 2722 \"lib/read.ml\"\n | 2 ->\n\n# 850 \"lib/read.mll\"\n \n# 850 \"lib/read.mll\"\n ( long_error \"Expected ':' or '>' but found\" v lexbuf )\n\n# 2726 \"lib/read.ml\"\n\n \n# 2727 \"lib/read.ml\"\n | 3 ->\n\n# 851 \"lib/read.mll\"\n \n# 851 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2731 \"lib/read.ml\"\n\n \n# 2732 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_skip_variant_rec v lexbuf __ocaml_lex_state\n\nand skip_ident v lexbuf =\n __ocaml_lex_skip_ident_rec v lexbuf 394\nand __ocaml_lex_skip_ident_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 854 \"lib/read.mll\"\n \n# 854 \"lib/read.mll\"\n ( finish_skip_stringlit v lexbuf )\n\n# 2743 \"lib/read.ml\"\n\n \n# 2744 \"lib/read.ml\"\n | 1 ->\n\n# 855 \"lib/read.mll\"\n \n# 855 \"lib/read.mll\"\n ( () )\n\n# 2748 \"lib/read.ml\"\n\n \n# 2749 \"lib/read.ml\"\n | 2 ->\n\n# 856 \"lib/read.mll\"\n \n# 856 \"lib/read.mll\"\n ( long_error \"Expected string or identifier but found\" v lexbuf )\n\n# 2753 \"lib/read.ml\"\n\n \n# 2754 \"lib/read.ml\"\n | 3 ->\n\n# 857 \"lib/read.mll\"\n \n# 857 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2758 \"lib/read.ml\"\n\n \n# 2759 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_skip_ident_rec v lexbuf __ocaml_lex_state\n\nand buffer_json v lexbuf =\n __ocaml_lex_buffer_json_rec v lexbuf 399\nand __ocaml_lex_buffer_json_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 870 \"lib/read.mll\"\n \n# 870 \"lib/read.mll\"\n ( add_lexeme v.buf lexbuf )\n\n# 2770 \"lib/read.ml\"\n\n \n# 2771 \"lib/read.ml\"\n | 1 ->\n\n# 872 \"lib/read.mll\"\n \n# 872 \"lib/read.mll\"\n ( finish_buffer_stringlit v lexbuf )\n\n# 2775 \"lib/read.ml\"\n\n \n# 2776 \"lib/read.ml\"\n | 2 ->\n\n# 873 \"lib/read.mll\"\n \n# 873 \"lib/read.mll\"\n ( try\n Bi_outbuf.add_char v.buf '{';\n buffer_space v lexbuf;\n buffer_object_end v lexbuf;\n buffer_ident v lexbuf;\n buffer_space v lexbuf;\n buffer_colon v lexbuf;\n buffer_space v lexbuf;\n buffer_json v lexbuf;\n while true do\n buffer_space v lexbuf;\n buffer_object_sep v lexbuf;\n buffer_space v lexbuf;\n buffer_ident v lexbuf;\n buffer_space v lexbuf;\n buffer_colon v lexbuf;\n buffer_space v lexbuf;\n buffer_json v lexbuf;\n done;\n assert false\n with End_of_object ->\n ()\n )\n\n# 2802 \"lib/read.ml\"\n\n \n# 2803 \"lib/read.ml\"\n | 3 ->\n\n# 897 \"lib/read.mll\"\n \n# 897 \"lib/read.mll\"\n ( try\n Bi_outbuf.add_char v.buf '[';\n buffer_space v lexbuf;\n buffer_array_end v lexbuf;\n buffer_json v lexbuf;\n while true do\n buffer_space v lexbuf;\n buffer_array_sep v lexbuf;\n buffer_space v lexbuf;\n buffer_json v lexbuf;\n done;\n assert false\n with End_of_array ->\n ()\n )\n\n# 2821 \"lib/read.ml\"\n\n \n# 2822 \"lib/read.ml\"\n | 4 ->\n\n# 913 \"lib/read.mll\"\n \n# 913 \"lib/read.mll\"\n (\n \n# 915 \"lib/read.mll\"\n try\n Bi_outbuf.add_char v.buf '(';\n buffer_space v lexbuf;\n buffer_tuple_end v lexbuf;\n buffer_json v lexbuf;\n while true do\n buffer_space v lexbuf;\n buffer_tuple_sep v lexbuf;\n buffer_space v lexbuf;\n buffer_json v lexbuf;\n done;\n assert false\n with End_of_tuple ->\n ()\n \n# 932 \"lib/read.mll\"\n )\n\n# 2845 \"lib/read.ml\"\n\n \n# 2846 \"lib/read.ml\"\n | 5 ->\n\n# 934 \"lib/read.mll\"\n \n# 934 \"lib/read.mll\"\n (\n \n# 936 \"lib/read.mll\"\n Bi_outbuf.add_char v.buf '<';\n buffer_space v lexbuf;\n buffer_ident v lexbuf;\n buffer_space v lexbuf;\n finish_buffer_variant v lexbuf\n \n# 944 \"lib/read.mll\"\n )\n\n# 2860 \"lib/read.ml\"\n\n \n# 2861 \"lib/read.ml\"\n | 6 ->\n\n# 946 \"lib/read.mll\"\n \n# 946 \"lib/read.mll\"\n ( add_lexeme v.buf lexbuf; buffer_json v lexbuf )\n\n# 2865 \"lib/read.ml\"\n\n \n# 2866 \"lib/read.ml\"\n | 7 ->\n\n# 947 \"lib/read.mll\"\n \n# 947 \"lib/read.mll\"\n ( Bi_outbuf.add_string v.buf \"/*\";\n finish_buffer_comment v lexbuf;\n buffer_json v lexbuf )\n\n# 2872 \"lib/read.ml\"\n\n \n# 2873 \"lib/read.ml\"\n | 8 ->\n\n# 950 \"lib/read.mll\"\n \n# 950 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\\n';\n newline v lexbuf;\n buffer_json v lexbuf )\n\n# 2879 \"lib/read.ml\"\n\n \n# 2880 \"lib/read.ml\"\n | 9 ->\n\n# 953 \"lib/read.mll\"\n \n# 953 \"lib/read.mll\"\n ( add_lexeme v.buf lexbuf; buffer_json v lexbuf )\n\n# 2884 \"lib/read.ml\"\n\n \n# 2885 \"lib/read.ml\"\n | 10 ->\n\n# 954 \"lib/read.mll\"\n \n# 954 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2889 \"lib/read.ml\"\n\n \n# 2890 \"lib/read.ml\"\n | 11 ->\n\n# 955 \"lib/read.mll\"\n \n# 955 \"lib/read.mll\"\n ( long_error \"Invalid token\" v lexbuf )\n\n# 2894 \"lib/read.ml\"\n\n \n# 2895 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_json_rec v lexbuf __ocaml_lex_state\n\nand finish_buffer_stringlit v lexbuf =\n __ocaml_lex_finish_buffer_stringlit_rec v lexbuf 450\nand __ocaml_lex_finish_buffer_stringlit_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 961 \"lib/read.mll\"\n \n# 961 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\"';\n add_lexeme v.buf lexbuf\n )\n\n# 2908 \"lib/read.ml\"\n\n \n# 2909 \"lib/read.ml\"\n | 1 ->\n\n# 964 \"lib/read.mll\"\n \n# 964 \"lib/read.mll\"\n ( long_error \"Invalid string literal\" v lexbuf )\n\n# 2913 \"lib/read.ml\"\n\n \n# 2914 \"lib/read.ml\"\n | 2 ->\n\n# 965 \"lib/read.mll\"\n \n# 965 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2918 \"lib/read.ml\"\n\n \n# 2919 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_buffer_stringlit_rec v lexbuf __ocaml_lex_state\n\nand finish_buffer_variant v lexbuf =\n __ocaml_lex_finish_buffer_variant_rec v lexbuf 461\nand __ocaml_lex_finish_buffer_variant_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 968 \"lib/read.mll\"\n \n# 968 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf ':';\n buffer_json v lexbuf;\n buffer_space v lexbuf;\n buffer_gt v lexbuf )\n\n# 2933 \"lib/read.ml\"\n\n \n# 2934 \"lib/read.ml\"\n | 1 ->\n\n# 972 \"lib/read.mll\"\n \n# 972 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '>' )\n\n# 2938 \"lib/read.ml\"\n\n \n# 2939 \"lib/read.ml\"\n | 2 ->\n\n# 973 \"lib/read.mll\"\n \n# 973 \"lib/read.mll\"\n ( long_error \"Expected ':' or '>' but found\" v lexbuf )\n\n# 2943 \"lib/read.ml\"\n\n \n# 2944 \"lib/read.ml\"\n | 3 ->\n\n# 974 \"lib/read.mll\"\n \n# 974 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2948 \"lib/read.ml\"\n\n \n# 2949 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_buffer_variant_rec v lexbuf __ocaml_lex_state\n\nand buffer_ident v lexbuf =\n __ocaml_lex_buffer_ident_rec v lexbuf 466\nand __ocaml_lex_buffer_ident_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 977 \"lib/read.mll\"\n \n# 977 \"lib/read.mll\"\n ( finish_buffer_stringlit v lexbuf )\n\n# 2960 \"lib/read.ml\"\n\n \n# 2961 \"lib/read.ml\"\n | 1 ->\n\n# 978 \"lib/read.mll\"\n \n# 978 \"lib/read.mll\"\n ( add_lexeme v.buf lexbuf )\n\n# 2965 \"lib/read.ml\"\n\n \n# 2966 \"lib/read.ml\"\n | 2 ->\n\n# 979 \"lib/read.mll\"\n \n# 979 \"lib/read.mll\"\n ( long_error \"Expected string or identifier but found\" v lexbuf )\n\n# 2970 \"lib/read.ml\"\n\n \n# 2971 \"lib/read.ml\"\n | 3 ->\n\n# 980 \"lib/read.mll\"\n \n# 980 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2975 \"lib/read.ml\"\n\n \n# 2976 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_ident_rec v lexbuf __ocaml_lex_state\n\nand buffer_space v lexbuf =\n __ocaml_lex_buffer_space_rec v lexbuf 471\nand __ocaml_lex_buffer_space_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 983 \"lib/read.mll\"\n \n# 983 \"lib/read.mll\"\n (\n add_lexeme v.buf lexbuf;\n newline v lexbuf;\n buffer_space v lexbuf )\n\n# 2990 \"lib/read.ml\"\n\n \n# 2991 \"lib/read.ml\"\n | 1 ->\n\n# 987 \"lib/read.mll\"\n \n# 987 \"lib/read.mll\"\n (\n Bi_outbuf.add_string v.buf \"/*\";\n finish_buffer_comment v lexbuf;\n buffer_space v lexbuf )\n\n# 2998 \"lib/read.ml\"\n\n \n# 2999 \"lib/read.ml\"\n | 2 ->\n\n# 991 \"lib/read.mll\"\n \n# 991 \"lib/read.mll\"\n (\n Bi_outbuf.add_char v.buf '\\n';\n newline v lexbuf;\n buffer_space v lexbuf )\n\n# 3006 \"lib/read.ml\"\n\n \n# 3007 \"lib/read.ml\"\n | 3 ->\n\n# 995 \"lib/read.mll\"\n \n# 995 \"lib/read.mll\"\n (\n add_lexeme v.buf lexbuf;\n buffer_space v lexbuf )\n\n# 3013 \"lib/read.ml\"\n\n \n# 3014 \"lib/read.ml\"\n | 4 ->\n\n# 998 \"lib/read.mll\"\n \n# 998 \"lib/read.mll\"\n ( () )\n\n# 3018 \"lib/read.ml\"\n\n \n# 3019 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_space_rec v lexbuf __ocaml_lex_state\n\nand buffer_object_end v lexbuf =\n __ocaml_lex_buffer_object_end_rec v lexbuf 478\nand __ocaml_lex_buffer_object_end_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1001 \"lib/read.mll\"\n \n# 1001 \"lib/read.mll\"\n (\n Bi_outbuf.add_char v.buf '}';\n raise End_of_object )\n\n# 3032 \"lib/read.ml\"\n\n \n# 3033 \"lib/read.ml\"\n | 1 ->\n\n# 1004 \"lib/read.mll\"\n \n# 1004 \"lib/read.mll\"\n ( () )\n\n# 3037 \"lib/read.ml\"\n\n \n# 3038 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_object_end_rec v lexbuf __ocaml_lex_state\n\nand buffer_object_sep v lexbuf =\n __ocaml_lex_buffer_object_sep_rec v lexbuf 480\nand __ocaml_lex_buffer_object_sep_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1007 \"lib/read.mll\"\n \n# 1007 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf ',' )\n\n# 3049 \"lib/read.ml\"\n\n \n# 3050 \"lib/read.ml\"\n | 1 ->\n\n# 1008 \"lib/read.mll\"\n \n# 1008 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '}'; raise End_of_object )\n\n# 3054 \"lib/read.ml\"\n\n \n# 3055 \"lib/read.ml\"\n | 2 ->\n\n# 1009 \"lib/read.mll\"\n \n# 1009 \"lib/read.mll\"\n ( long_error \"Expected ',' or '}' but found\" v lexbuf )\n\n# 3059 \"lib/read.ml\"\n\n \n# 3060 \"lib/read.ml\"\n | 3 ->\n\n# 1010 \"lib/read.mll\"\n \n# 1010 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 3064 \"lib/read.ml\"\n\n \n# 3065 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_object_sep_rec v lexbuf __ocaml_lex_state\n\nand buffer_array_end v lexbuf =\n __ocaml_lex_buffer_array_end_rec v lexbuf 485\nand __ocaml_lex_buffer_array_end_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1013 \"lib/read.mll\"\n \n# 1013 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf ']'; raise End_of_array )\n\n# 3076 \"lib/read.ml\"\n\n \n# 3077 \"lib/read.ml\"\n | 1 ->\n\n# 1014 \"lib/read.mll\"\n \n# 1014 \"lib/read.mll\"\n ( () )\n\n# 3081 \"lib/read.ml\"\n\n \n# 3082 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_array_end_rec v lexbuf __ocaml_lex_state\n\nand buffer_array_sep v lexbuf =\n __ocaml_lex_buffer_array_sep_rec v lexbuf 487\nand __ocaml_lex_buffer_array_sep_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1017 \"lib/read.mll\"\n \n# 1017 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf ',' )\n\n# 3093 \"lib/read.ml\"\n\n \n# 3094 \"lib/read.ml\"\n | 1 ->\n\n# 1018 \"lib/read.mll\"\n \n# 1018 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf ']'; raise End_of_array )\n\n# 3098 \"lib/read.ml\"\n\n \n# 3099 \"lib/read.ml\"\n | 2 ->\n\n# 1019 \"lib/read.mll\"\n \n# 1019 \"lib/read.mll\"\n ( long_error \"Expected ',' or ']' but found\" v lexbuf )\n\n# 3103 \"lib/read.ml\"\n\n \n# 3104 \"lib/read.ml\"\n | 3 ->\n\n# 1020 \"lib/read.mll\"\n \n# 1020 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 3108 \"lib/read.ml\"\n\n \n# 3109 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_array_sep_rec v lexbuf __ocaml_lex_state\n\nand buffer_tuple_end v lexbuf =\n __ocaml_lex_buffer_tuple_end_rec v lexbuf 492\nand __ocaml_lex_buffer_tuple_end_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1023 \"lib/read.mll\"\n \n# 1023 \"lib/read.mll\"\n (\n Bi_outbuf.add_char v.buf ')';\n raise End_of_tuple )\n\n# 3122 \"lib/read.ml\"\n\n \n# 3123 \"lib/read.ml\"\n | 1 ->\n\n# 1026 \"lib/read.mll\"\n \n# 1026 \"lib/read.mll\"\n ( () )\n\n# 3127 \"lib/read.ml\"\n\n \n# 3128 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_tuple_end_rec v lexbuf __ocaml_lex_state\n\nand buffer_tuple_sep v lexbuf =\n __ocaml_lex_buffer_tuple_sep_rec v lexbuf 494\nand __ocaml_lex_buffer_tuple_sep_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1029 \"lib/read.mll\"\n \n# 1029 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf ',' )\n\n# 3139 \"lib/read.ml\"\n\n \n# 3140 \"lib/read.ml\"\n | 1 ->\n\n# 1030 \"lib/read.mll\"\n \n# 1030 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf ')'; raise End_of_tuple )\n\n# 3144 \"lib/read.ml\"\n\n \n# 3145 \"lib/read.ml\"\n | 2 ->\n\n# 1031 \"lib/read.mll\"\n \n# 1031 \"lib/read.mll\"\n ( long_error \"Expected ',' or ')' but found\" v lexbuf )\n\n# 3149 \"lib/read.ml\"\n\n \n# 3150 \"lib/read.ml\"\n | 3 ->\n\n# 1032 \"lib/read.mll\"\n \n# 1032 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 3154 \"lib/read.ml\"\n\n \n# 3155 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_tuple_sep_rec v lexbuf __ocaml_lex_state\n\nand buffer_colon v lexbuf =\n __ocaml_lex_buffer_colon_rec v lexbuf 499\nand __ocaml_lex_buffer_colon_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1035 \"lib/read.mll\"\n \n# 1035 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf ':' )\n\n# 3166 \"lib/read.ml\"\n\n \n# 3167 \"lib/read.ml\"\n | 1 ->\n\n# 1036 \"lib/read.mll\"\n \n# 1036 \"lib/read.mll\"\n ( long_error \"Expected ':' but found\" v lexbuf )\n\n# 3171 \"lib/read.ml\"\n\n \n# 3172 \"lib/read.ml\"\n | 2 ->\n\n# 1037 \"lib/read.mll\"\n \n# 1037 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 3176 \"lib/read.ml\"\n\n \n# 3177 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_colon_rec v lexbuf __ocaml_lex_state\n\nand buffer_gt v lexbuf =\n __ocaml_lex_buffer_gt_rec v lexbuf 503\nand __ocaml_lex_buffer_gt_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1040 \"lib/read.mll\"\n \n# 1040 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '>' )\n\n# 3188 \"lib/read.ml\"\n\n \n# 3189 \"lib/read.ml\"\n | 1 ->\n\n# 1041 \"lib/read.mll\"\n \n# 1041 \"lib/read.mll\"\n ( long_error \"Expected '>' but found\" v lexbuf )\n\n# 3193 \"lib/read.ml\"\n\n \n# 3194 \"lib/read.ml\"\n | 2 ->\n\n# 1042 \"lib/read.mll\"\n \n# 1042 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 3198 \"lib/read.ml\"\n\n \n# 3199 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_gt_rec v lexbuf __ocaml_lex_state\n\nand finish_buffer_comment v lexbuf =\n __ocaml_lex_finish_buffer_comment_rec v lexbuf 507\nand __ocaml_lex_finish_buffer_comment_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1045 \"lib/read.mll\"\n \n# 1045 \"lib/read.mll\"\n ( Bi_outbuf.add_string v.buf \"*/\" )\n\n# 3210 \"lib/read.ml\"\n\n \n# 3211 \"lib/read.ml\"\n | 1 ->\n\n# 1046 \"lib/read.mll\"\n \n# 1046 \"lib/read.mll\"\n ( long_error \"Unterminated comment\" v lexbuf )\n\n# 3215 \"lib/read.ml\"\n\n \n# 3216 \"lib/read.ml\"\n | 2 ->\n\n# 1047 \"lib/read.mll\"\n \n# 1047 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\\n';\n newline v lexbuf;\n finish_buffer_comment v lexbuf )\n\n# 3222 \"lib/read.ml\"\n\n \n# 3223 \"lib/read.ml\"\n | 3 ->\n\n# 1050 \"lib/read.mll\"\n \n# 1050 \"lib/read.mll\"\n ( add_lexeme v.buf lexbuf; finish_buffer_comment v lexbuf )\n\n# 3227 \"lib/read.ml\"\n\n \n# 3228 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_buffer_comment_rec v lexbuf __ocaml_lex_state\n\nand junk lexbuf =\n __ocaml_lex_junk_rec lexbuf 513\nand __ocaml_lex_junk_rec lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1053 \"lib/read.mll\"\n \n# 1053 \"lib/read.mll\"\n ( Lexing.lexeme lexbuf )\n\n# 3239 \"lib/read.ml\"\n\n \n# 3240 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_junk_rec lexbuf __ocaml_lex_state\n\n;;\n\n\n# 1055 \"lib/read.mll\"\n \n \n# 1056 \"lib/read.mll\"\n let _ = (read_json : lexer_state -> Lexing.lexbuf -> t)\n\n let read_t = read_json\n\n let () =\n read_junk := junk\n\n let read_int8 v lexbuf =\n let n = read_int v lexbuf in\n if n < 0 || n > 255 then\n lexer_error \"Int8 overflow\" v lexbuf\n else\n char_of_int n\n\n let read_list read_cell v lexbuf =\n List.rev (read_list_rev read_cell v lexbuf)\n\n let array_of_rev_list l =\n match l with\n [] -> [| |]\n | x :: tl ->\n let len = List.length l in\n let a = Array.make len x in\n let r = ref tl in\n for i = len - 2 downto 0 do\n a.(i) <- List.hd !r;\n r := List.tl !r\n done;\n a\n\n let read_array read_cell v lexbuf =\n let l = read_list_rev read_cell v lexbuf in\n array_of_rev_list l\n\n (* Read a JSON object, reading the keys into OCaml strings\n (provided for backward compatibility) *)\n let read_fields read_field init_acc v =\n read_abstract_fields read_ident read_field init_acc v\n\n let finish v lexbuf =\n read_space v lexbuf;\n if not (read_eof lexbuf) then\n long_error \"Junk after end of JSON value:\" v lexbuf\n\n let init_lexer = init_lexer\n\n let from_lexbuf v ?(stream = false) lexbuf =\n read_space v lexbuf;\n\n let x =\n if read_eof lexbuf then\n raise End_of_input\n else\n read_json v lexbuf\n in\n\n if not stream then\n finish v lexbuf;\n\n x\n\n\n let from_string ?buf ?fname ?lnum s =\n try\n let lexbuf = Lexing.from_string s in\n let v = init_lexer ?buf ?fname ?lnum () in\n from_lexbuf v lexbuf\n with End_of_input ->\n json_error \"Blank input data\"\n\n let from_channel ?buf ?fname ?lnum ic =\n try\n let lexbuf = Lexing.from_channel ic in\n let v = init_lexer ?buf ?fname ?lnum () in\n from_lexbuf v lexbuf\n with End_of_input ->\n json_error \"Blank input data\"\n\n let from_file ?buf ?fname ?lnum file =\n let ic = open_in file in\n try\n let x = from_channel ?buf ?fname ?lnum ic in\n close_in ic;\n x\n with e ->\n close_in_noerr ic;\n raise e\n\n exception Finally of exn * exn\n\n let stream_from_lexbuf v ?(fin = fun () -> ()) lexbuf =\n let stream = Some true in\n let f i =\n try Some (from_lexbuf v ?stream lexbuf)\n with\n End_of_input ->\n fin ();\n None\n | e ->\n (try fin () with fin_e -> raise (Finally (e, fin_e)));\n raise e\n in\n Stream.from f\n\n let stream_from_string ?buf ?fname ?lnum s =\n let v = init_lexer ?buf ?fname ?lnum () in\n stream_from_lexbuf v (Lexing.from_string s)\n\n let stream_from_channel ?buf ?fin ?fname ?lnum ic =\n let lexbuf = Lexing.from_channel ic in\n let v = init_lexer ?buf ?fname ?lnum () in\n stream_from_lexbuf v ?fin lexbuf\n\n let stream_from_file ?buf ?fname ?lnum file =\n let ic = open_in file in\n let fin () = close_in ic in\n let fname =\n match fname with\n None -> Some file\n | x -> x\n in\n let lexbuf = Lexing.from_channel ic in\n let v = init_lexer ?buf ?fname ?lnum () in\n stream_from_lexbuf v ~fin lexbuf\n\n type json_line = [ `Json of t | `Exn of exn ]\n\n let linestream_from_channel\n ?buf ?(fin = fun () -> ()) ?fname ?lnum:(lnum0 = 1) ic =\n let buf =\n match buf with\n None -> Some (Bi_outbuf.create 256)\n | Some _ -> buf\n in\n let f i =\n try\n let line = input_line ic in\n let lnum = lnum0 + i in\n Some (`Json (from_string ?buf ?fname ~lnum line))\n with\n End_of_file -> fin (); None\n | e -> Some (`Exn e)\n in\n Stream.from f\n\n let linestream_from_file ?buf ?fname ?lnum file =\n let ic = open_in file in\n let fin () = close_in ic in\n let fname =\n match fname with\n None -> Some file\n | x -> x\n in\n linestream_from_channel ?buf ~fin ?fname ?lnum ic\n\n let prettify ?std s =\n pretty_to_string ?std (from_string s)\n\n let compact ?std s =\n to_string (from_string s)\n\n let validate_json _path _value = None\n\n\n# 3411 \"lib/read.ml\"\n# 62 \"yojson.cppo.ml\"\nmodule Util =\nstruct\n# 1 \"util.ml\"\nexception Type_error of string * t\n\nlet typeof = function\n | `Assoc _ -> \"object\"\n | `Bool _ -> \"bool\"\n | `Float _ -> \"float\"\n | `Int _ -> \"int\"\n | `List _ -> \"array\"\n | `Null -> \"null\"\n | `String _ -> \"string\"\n | `Intlit _ -> \"intlit\"\n | `Tuple _ -> \"tuple\"\n | `Variant _ -> \"variant\"\n\nlet typerr msg js = raise (Type_error (msg ^ typeof js, js))\n\nexception Undefined of string * t\n\nlet ( |> ) = ( |> )\n\nlet assoc name obj =\n try List.assoc name obj\n with Not_found -> `Null\n\nlet member name = function\n | `Assoc obj -> assoc name obj\n | js -> typerr (\"Can't get member '\" ^ name ^ \"' of non-object type \") js\n\nlet index i = function\n | `List l as js ->\n let len = List.length l in\n let wrapped_index = if i < 0 then len + i else i in\n if wrapped_index < 0 || wrapped_index >= len then\n raise (Undefined (\"Index \" ^ string_of_int i ^ \" out of bounds\", js))\n else List.nth l wrapped_index\n | js -> typerr (\"Can't get index \" ^ string_of_int i\n ^ \" of non-array type \") js\n\nlet map f = function\n | `List l -> `List (List.map f l)\n | js -> typerr \"Can't map function over non-array type \" js\n\nlet to_assoc = function\n | `Assoc obj -> obj\n | js -> typerr \"Expected object, got \" js\n\nlet to_option f = function\n | `Null -> None\n | x -> Some (f x)\n\nlet to_bool = function\n | `Bool b -> b\n | js -> typerr \"Expected bool, got \" js\n\nlet to_bool_option = function\n | `Bool b -> Some b\n | `Null -> None\n | js -> typerr \"Expected bool or null, got \" js\n\nlet to_number = function\n | `Int i -> float i\n | `Float f -> f\n | js -> typerr \"Expected number, got \" js\n\nlet to_number_option = function\n | `Int i -> Some (float i)\n | `Float f -> Some f\n | `Null -> None\n | js -> typerr \"Expected number or null, got \" js\n\nlet to_float = function\n | `Float f -> f\n | js -> typerr \"Expected float, got \" js\n\nlet to_float_option = function\n | `Float f -> Some f\n | `Null -> None\n | js -> typerr \"Expected float or null, got \" js\n\nlet to_int = function\n | `Int i -> i\n | js -> typerr \"Expected int, got \" js\n\nlet to_int_option = function\n | `Int i -> Some i\n | `Null -> None\n | js -> typerr \"Expected int or null, got \" js\n\nlet to_list = function\n | `List l -> l\n | js -> typerr \"Expected array, got \" js\n\nlet to_string = function\n | `String s -> s\n | js -> typerr \"Expected string, got \" js\n\nlet to_string_option = function\n | `String s -> Some s\n | `Null -> None\n | js -> typerr \"Expected string or null, got \" js\n\nlet convert_each f = function\n | `List l -> List.map f l\n | js -> typerr \"Can't convert each element of non-array type \" js\n\n\nlet rec rev_filter_map f acc l =\n match l with\n [] -> acc\n | x :: tl ->\n match f x with\n None -> rev_filter_map f acc tl\n | Some y -> rev_filter_map f (y :: acc) tl\n\nlet filter_map f l =\n List.rev (rev_filter_map f [] l)\n\nlet rec rev_flatten acc l =\n match l with\n [] -> acc\n | x :: tl ->\n match x with\n `List l2 -> rev_flatten (List.rev_append l2 acc) tl\n | _ -> rev_flatten acc tl\n\nlet flatten l =\n List.rev (rev_flatten [] l)\n\nlet filter_index i l =\n filter_map (\n function\n `List l ->\n (try Some (List.nth l i)\n with _ -> None)\n | _ -> None\n ) l\n\nlet filter_list l =\n filter_map (\n function\n `List l -> Some l\n | _ -> None\n ) l\n\nlet filter_member k l =\n filter_map (\n function\n `Assoc l ->\n (try Some (List.assoc k l)\n with _ -> None)\n | _ -> None\n ) l\n\nlet filter_assoc l =\n filter_map (\n function\n `Assoc l -> Some l\n | _ -> None\n ) l\n\nlet filter_bool l =\n filter_map (\n function\n `Bool x -> Some x\n | _ -> None\n ) l\n\nlet filter_int l =\n filter_map (\n function\n `Int x -> Some x\n | _ -> None\n ) l\n\nlet filter_float l =\n filter_map (\n function\n `Float x -> Some x\n | _ -> None\n ) l\n\nlet filter_number l =\n filter_map (\n function\n `Int x -> Some (float x)\n | `Float x -> Some x\n | _ -> None\n ) l\n\nlet filter_string l =\n filter_map (\n function\n `String x -> Some x\n | _ -> None\n ) l\n\nlet keys o =\n to_assoc o |> List.map (fun (key, _) -> key)\n\nlet values o =\n to_assoc o |> List.map (fun (_, value) -> value)\n\nlet combine (first : t) (second : t) =\n match (first, second) with\n | (`Assoc a, `Assoc b) -> (`Assoc (a @ b) : t)\n | (a, b) -> raise (Invalid_argument \"Expected two objects, check inputs\")\n# 65 \"yojson.cppo.ml\"\nend\n# 72 \"yojson.cppo.ml\"\nend\n\nmodule Raw =\nstruct\n# 1 \"type.ml\"\n(** {3 Type of the JSON tree} *)\n\ntype t =\n [\n | `Null\n | `Bool of bool\n \n# 11 \"type.ml\"\n | `Intlit of string\n \n# 17 \"type.ml\"\n | `Floatlit of string\n \n# 23 \"type.ml\"\n | `Stringlit of string\n \n# 25 \"type.ml\"\n | `Assoc of (string * t) list\n | `List of t list\n \n# 28 \"type.ml\"\n | `Tuple of t list\n \n# 31 \"type.ml\"\n | `Variant of (string * t option)\n \n# 33 \"type.ml\"\n ]\n(**\nAll possible cases defined in Yojson:\n- `Null: JSON null\n- `Bool of bool: JSON boolean\n- `Int of int: JSON number without decimal point or exponent.\n- `Intlit of string: JSON number without decimal point or exponent,\n\t preserved as a string.\n- `Float of float: JSON number, Infinity, -Infinity or NaN.\n- `Floatlit of string: JSON number, Infinity, -Infinity or NaN,\n\t preserved as a string.\n- `String of string: JSON string. Bytes in the range 128-255 are preserved\n\t as-is without encoding validation for both reading\n\t and writing.\n- `Stringlit of string: JSON string literal including the double quotes.\n- `Assoc of (string * json) list: JSON object.\n- `List of json list: JSON array.\n- `Tuple of json list: Tuple (non-standard extension of JSON).\n\t Syntax: [(\"abc\", 123)].\n- `Variant of (string * json option): Variant (non-standard extension of JSON).\n\t Syntax: [<\"Foo\">] or [<\"Bar\":123>].\n*)\n\ntype json = t [@@deprecated \"json types are being renamed and will be removed in the next Yojson major version. Use type t instead\"]\n(**\n * Compatibility type alias for type `t`\n *)\n\n(*\n Note to adventurers: ocamldoc does not support inline comments\n on each polymorphic variant, and cppo doesn't allow to concatenate\n comments, so it would be complicated to document only the\n cases that are preserved by cppo in the type definition.\n*)\n# 1 \"write.ml\"\n(* included: type.ml *)\n\nlet hex n =\n Char.chr (\n if n < 10 then n + 48\n else n + 87\n )\n\nlet write_special src start stop ob str =\n Bi_outbuf.add_substring ob src !start (stop - !start);\n Bi_outbuf.add_string ob str;\n start := stop + 1\n\nlet write_control_char src start stop ob c =\n Bi_outbuf.add_substring ob src !start (stop - !start);\n let i = Bi_outbuf.alloc ob 6 in\n let dst = ob.o_s in\n Bytes.blit_string \"\\\\u00\" 0 dst i 4;\n Bytes.set dst (i+4) (hex (Char.code c lsr 4));\n Bytes.set dst (i+5) (hex (Char.code c land 0xf));\n start := stop + 1\n\nlet finish_string src start ob =\n try\n Bi_outbuf.add_substring ob src !start (String.length src - !start)\n with exc ->\n Printf.eprintf \"src=%S start=%i len=%i\\n%!\"\n src !start (String.length src - !start);\n raise exc\n\nlet write_string_body ob s =\n let start = ref 0 in\n for i = 0 to String.length s - 1 do\n match s.[i] with\n '\"' -> write_special s start i ob \"\\\\\\\"\"\n | '\\\\' -> write_special s start i ob \"\\\\\\\\\"\n | '\\b' -> write_special s start i ob \"\\\\b\"\n | '\\012' -> write_special s start i ob \"\\\\f\"\n | '\\n' -> write_special s start i ob \"\\\\n\"\n | '\\r' -> write_special s start i ob \"\\\\r\"\n | '\\t' -> write_special s start i ob \"\\\\t\"\n | '\\x00'..'\\x1F'\n | '\\x7F' as c -> write_control_char s start i ob c\n | _ -> ()\n done;\n finish_string s start ob\n\nlet write_string ob s =\n Bi_outbuf.add_char ob '\"';\n write_string_body ob s;\n Bi_outbuf.add_char ob '\"'\n\nlet json_string_of_string s =\n let ob = Bi_outbuf.create 10 in\n write_string ob s;\n Bi_outbuf.contents ob\n\nlet test_string () =\n let s = Bytes.create 256 in\n for i = 0 to 255 do\n Bytes.set s i (Char.chr i)\n done;\n json_string_of_string (Bytes.to_string s)\n\n\nlet write_null ob () =\n Bi_outbuf.add_string ob \"null\"\n\nlet write_bool ob x =\n Bi_outbuf.add_string ob (if x then \"true\" else \"false\")\n\n\nlet max_digits =\n max\n (String.length (string_of_int max_int))\n (String.length (string_of_int min_int))\n\nlet dec n =\n Char.chr (n + 48)\n\nlet rec write_digits s pos x =\n if x = 0 then pos\n else\n let d = x mod 10 in\n let pos = write_digits s pos (x / 10) in\n Bytes.set s pos (dec (abs d));\n pos + 1\n\nlet write_int ob x =\n Bi_outbuf.extend ob max_digits;\n if x > 0 then\n ob.o_len <- write_digits ob.o_s ob.o_len x\n else if x < 0 then (\n let s = ob.o_s in\n let pos = ob.o_len in\n Bytes.set s pos '-';\n ob.o_len <- write_digits s (pos + 1) x\n )\n else\n Bi_outbuf.add_char ob '0'\n\n\nlet json_string_of_int i =\n string_of_int i\n\n\n(*\n Ensure that the float is not printed as an int.\n This is not required by JSON, but useful in order to guarantee\n reversibility.\n*)\nlet float_needs_period s =\n try\n for i = 0 to String.length s - 1 do\n match s.[i] with\n '0'..'9' | '-' -> ()\n | _ -> raise Exit\n done;\n true\n with Exit ->\n false\n\n(*\n Both write_float_fast and write_float guarantee\n that a sufficient number of digits are printed in order to\n allow reversibility.\n\n The _fast version is faster but often produces unnecessarily long numbers.\n*)\nlet write_float_fast ob x =\n match classify_float x with\n FP_nan ->\n Bi_outbuf.add_string ob \"NaN\"\n | FP_infinite ->\n Bi_outbuf.add_string ob (if x > 0. then \"Infinity\" else \"-Infinity\")\n | _ ->\n let s = Printf.sprintf \"%.17g\" x in\n Bi_outbuf.add_string ob s;\n if float_needs_period s then\n Bi_outbuf.add_string ob \".0\"\n\nlet write_float ob x =\n match classify_float x with\n FP_nan ->\n Bi_outbuf.add_string ob \"NaN\"\n | FP_infinite ->\n Bi_outbuf.add_string ob (if x > 0. then \"Infinity\" else \"-Infinity\")\n | _ ->\n let s1 = Printf.sprintf \"%.16g\" x in\n let s =\n if float_of_string s1 = x then s1\n else Printf.sprintf \"%.17g\" x\n in\n Bi_outbuf.add_string ob s;\n if float_needs_period s then\n Bi_outbuf.add_string ob \".0\"\n\nlet write_normal_float_prec significant_figures ob x =\n let open Printf in\n let s =\n match significant_figures with\n 1 -> sprintf \"%.1g\" x\n | 2 -> sprintf \"%.2g\" x\n | 3 -> sprintf \"%.3g\" x\n | 4 -> sprintf \"%.4g\" x\n | 5 -> sprintf \"%.5g\" x\n | 6 -> sprintf \"%.6g\" x\n | 7 -> sprintf \"%.7g\" x\n | 8 -> sprintf \"%.8g\" x\n | 9 -> sprintf \"%.9g\" x\n | 10 -> sprintf \"%.10g\" x\n | 11 -> sprintf \"%.11g\" x\n | 12 -> sprintf \"%.12g\" x\n | 13 -> sprintf \"%.13g\" x\n | 14 -> sprintf \"%.14g\" x\n | 15 -> sprintf \"%.15g\" x\n | 16 -> sprintf \"%.16g\" x\n | _ -> sprintf \"%.17g\" x\n in\n Bi_outbuf.add_string ob s;\n if float_needs_period s then\n Bi_outbuf.add_string ob \".0\"\n\nlet write_float_prec significant_figures ob x =\n match classify_float x with\n FP_nan ->\n Bi_outbuf.add_string ob \"NaN\"\n | FP_infinite ->\n Bi_outbuf.add_string ob (if x > 0. then \"Infinity\" else \"-Infinity\")\n | _ ->\n write_normal_float_prec significant_figures ob x\n\nlet json_string_of_float x =\n let ob = Bi_outbuf.create 20 in\n write_float ob x;\n Bi_outbuf.contents ob\n\n\nlet write_std_float_fast ob x =\n match classify_float x with\n FP_nan ->\n json_error \"NaN value not allowed in standard JSON\"\n | FP_infinite ->\n json_error\n (if x > 0. then\n \"Infinity value not allowed in standard JSON\"\n else\n \"-Infinity value not allowed in standard JSON\")\n | _ ->\n let s = Printf.sprintf \"%.17g\" x in\n Bi_outbuf.add_string ob s;\n if float_needs_period s then\n Bi_outbuf.add_string ob \".0\"\n\nlet write_std_float ob x =\n match classify_float x with\n FP_nan ->\n json_error \"NaN value not allowed in standard JSON\"\n | FP_infinite ->\n json_error\n (if x > 0. then\n \"Infinity value not allowed in standard JSON\"\n else\n \"-Infinity value not allowed in standard JSON\")\n | _ ->\n let s1 = Printf.sprintf \"%.16g\" x in\n let s =\n if float_of_string s1 = x then s1\n else Printf.sprintf \"%.17g\" x\n in\n Bi_outbuf.add_string ob s;\n if float_needs_period s then\n Bi_outbuf.add_string ob \".0\"\n\nlet write_std_float_prec significant_figures ob x =\n match classify_float x with\n FP_nan ->\n json_error \"NaN value not allowed in standard JSON\"\n | FP_infinite ->\n json_error\n (if x > 0. then\n \"Infinity value not allowed in standard JSON\"\n else\n \"-Infinity value not allowed in standard JSON\")\n | _ ->\n write_normal_float_prec significant_figures ob x\n\nlet std_json_string_of_float x =\n let ob = Bi_outbuf.create 20 in\n write_std_float ob x;\n Bi_outbuf.contents ob\n\n\nlet test_float () =\n let l = [ 0.; 1.; -1. ] in\n let l = l @ List.map (fun x -> 2. *. x +. 1.) l in\n let l = l @ List.map (fun x -> x /. sqrt 2.) l in\n let l = l @ List.map (fun x -> x *. sqrt 3.) l in\n let l = l @ List.map cos l in\n let l = l @ List.map (fun x -> x *. 1.23e50) l in\n let l = l @ [ infinity; neg_infinity ] in\n List.iter (\n fun x ->\n let s = Printf.sprintf \"%.17g\" x in\n let y = float_of_string s in\n Printf.printf \"%g %g %S %B\\n\" x y s (x = y)\n )\n l\n\n(*\nlet () = test_float ()\n*)\n\nlet write_intlit = Bi_outbuf.add_string\nlet write_floatlit = Bi_outbuf.add_string\nlet write_stringlit = Bi_outbuf.add_string\n\nlet rec iter2_aux f_elt f_sep x = function\n [] -> ()\n | y :: l ->\n f_sep x;\n f_elt x y;\n iter2_aux f_elt f_sep x l\n\nlet iter2 f_elt f_sep x = function\n [] -> ()\n | y :: l ->\n f_elt x y;\n iter2_aux f_elt f_sep x l\n\nlet f_sep ob =\n Bi_outbuf.add_char ob ','\n\nlet rec write_json ob (x : t) =\n match x with\n `Null -> write_null ob ()\n | `Bool b -> write_bool ob b\n \n# 302 \"write.ml\"\n | `Intlit s -> Bi_outbuf.add_string ob s\n \n# 308 \"write.ml\"\n | `Floatlit s -> Bi_outbuf.add_string ob s\n \n# 314 \"write.ml\"\n | `Stringlit s -> Bi_outbuf.add_string ob s\n \n# 316 \"write.ml\"\n | `Assoc l -> write_assoc ob l\n | `List l -> write_list ob l\n \n# 319 \"write.ml\"\n | `Tuple l -> write_tuple ob l\n \n# 322 \"write.ml\"\n | `Variant (s, o) -> write_variant ob s o\n\n# 325 \"write.ml\"\nand write_assoc ob l =\n let f_elt ob (s, x) =\n write_string ob s;\n Bi_outbuf.add_char ob ':';\n write_json ob x\n in\n Bi_outbuf.add_char ob '{';\n iter2 f_elt f_sep ob l;\n Bi_outbuf.add_char ob '}';\n\nand write_list ob l =\n Bi_outbuf.add_char ob '[';\n iter2 write_json f_sep ob l;\n Bi_outbuf.add_char ob ']'\n\n# 341 \"write.ml\"\nand write_tuple ob l =\n Bi_outbuf.add_char ob '(';\n iter2 write_json f_sep ob l;\n Bi_outbuf.add_char ob ')'\n\n# 348 \"write.ml\"\nand write_variant ob s o =\n Bi_outbuf.add_char ob '<';\n write_string ob s;\n (match o with\n None -> ()\n | Some x ->\n Bi_outbuf.add_char ob ':';\n write_json ob x\n );\n Bi_outbuf.add_char ob '>'\n\n# 360 \"write.ml\"\nlet write_t = write_json\n\nlet rec write_std_json ob (x : t) =\n match x with\n `Null -> write_null ob ()\n | `Bool b -> write_bool ob b\n \n# 370 \"write.ml\"\n | `Intlit s -> Bi_outbuf.add_string ob s\n \n# 376 \"write.ml\"\n | `Floatlit s -> Bi_outbuf.add_string ob s\n \n# 382 \"write.ml\"\n | `Stringlit s -> Bi_outbuf.add_string ob s\n \n# 384 \"write.ml\"\n | `Assoc l -> write_std_assoc ob l\n | `List l -> write_std_list ob l\n \n# 387 \"write.ml\"\n | `Tuple l -> write_std_tuple ob l\n \n# 390 \"write.ml\"\n | `Variant (s, o) -> write_std_variant ob s o\n\n# 393 \"write.ml\"\nand write_std_assoc ob l =\n let f_elt ob (s, x) =\n write_string ob s;\n Bi_outbuf.add_char ob ':';\n write_std_json ob x\n in\n Bi_outbuf.add_char ob '{';\n iter2 f_elt f_sep ob l;\n Bi_outbuf.add_char ob '}';\n\nand write_std_list ob l =\n Bi_outbuf.add_char ob '[';\n iter2 write_std_json f_sep ob l;\n Bi_outbuf.add_char ob ']'\n\nand write_std_tuple ob l =\n Bi_outbuf.add_char ob '[';\n iter2 write_std_json f_sep ob l;\n Bi_outbuf.add_char ob ']'\n\n# 414 \"write.ml\"\nand write_std_variant ob s o =\n match o with\n None -> write_string ob s\n | Some x ->\n Bi_outbuf.add_char ob '[';\n write_string ob s;\n Bi_outbuf.add_char ob ',';\n write_std_json ob x;\n Bi_outbuf.add_char ob ']'\n\n\n# 426 \"write.ml\"\nlet to_outbuf ?(std = false) ob x =\n if std then (\n if not (is_object_or_array x) then\n json_error \"Root is not an object or array\"\n else\n write_std_json ob x\n )\n else\n write_json ob x\n\n\nlet to_string ?buf ?(len = 256) ?std x =\n let ob =\n match buf with\n None -> Bi_outbuf.create len\n | Some ob ->\n Bi_outbuf.clear ob;\n ob\n in\n to_outbuf ?std ob x;\n let s = Bi_outbuf.contents ob in\n Bi_outbuf.clear ob;\n s\n\nlet to_channel ?buf ?len ?std oc x =\n let ob =\n match buf with\n None -> Bi_outbuf.create_channel_writer ?len oc\n | Some ob -> ob\n in\n to_outbuf ?std ob x;\n Bi_outbuf.flush_channel_writer ob\n\nlet to_output ?buf ?len ?std out x =\n let ob =\n match buf with\n None -> Bi_outbuf.create_output_writer ?len out\n | Some ob -> ob\n in\n to_outbuf ?std ob x;\n Bi_outbuf.flush_output_writer ob\n\nlet to_file ?len ?std file x =\n let oc = open_out file in\n try\n to_channel ?len ?std oc x;\n close_out oc\n with e ->\n close_out_noerr oc;\n raise e\n\nlet stream_to_outbuf ?std ob st =\n Stream.iter (to_outbuf ?std ob) st\n\nlet stream_to_string ?buf ?(len = 256) ?std st =\n let ob =\n match buf with\n None -> Bi_outbuf.create len\n | Some ob ->\n Bi_outbuf.clear ob;\n ob\n in\n stream_to_outbuf ?std ob st;\n let s = Bi_outbuf.contents ob in\n Bi_outbuf.clear ob;\n s\n\nlet stream_to_channel ?buf ?len ?std oc st =\n let ob =\n match buf with\n None -> Bi_outbuf.create_channel_writer ?len oc\n | Some ob -> ob\n in\n stream_to_outbuf ?std ob st;\n Bi_outbuf.flush_channel_writer ob\n\nlet stream_to_file ?len ?std file st =\n let oc = open_out file in\n try\n stream_to_channel ?len ?std oc st;\n close_out oc\n with e ->\n close_out_noerr oc;\n raise e\n\n\nlet rec sort = function\n | `Assoc l ->\n let l = List.rev (List.rev_map (fun (k, v) -> (k, sort v)) l) in\n `Assoc (List.stable_sort (fun (a, _) (b, _) -> String.compare a b) l)\n | `List l ->\n `List (List.rev (List.rev_map sort l))\n \n# 519 \"write.ml\"\n | `Tuple l ->\n `Tuple (List.rev (List.rev_map sort l))\n \n# 523 \"write.ml\"\n | `Variant (k, Some v) as x ->\n let v' = sort v in\n if v == v' then x\n else\n `Variant (k, Some v')\n \n# 529 \"write.ml\"\n | x -> x\n# 1 \"monomorphic.ml\"\nlet rec pp fmt =\n function\n | `Null -> Format.pp_print_string fmt \"`Null\"\n | `Bool x ->\n Format.fprintf fmt \"`Bool (@[\";\n Format.fprintf fmt \"%B\" x;\n Format.fprintf fmt \"@])\"\n \n# 15 \"monomorphic.ml\"\n | `Intlit x ->\n Format.fprintf fmt \"`Intlit (@[\";\n Format.fprintf fmt \"%S\" x;\n Format.fprintf fmt \"@])\"\n \n# 27 \"monomorphic.ml\"\n | `Floatlit x ->\n Format.fprintf fmt \"`Floatlit (@[\";\n Format.fprintf fmt \"%S\" x;\n Format.fprintf fmt \"@])\"\n \n# 39 \"monomorphic.ml\"\n | `Stringlit x ->\n Format.fprintf fmt \"`Stringlit (@[\";\n Format.fprintf fmt \"%S\" x;\n Format.fprintf fmt \"@])\"\n \n# 44 \"monomorphic.ml\"\n | `Assoc xs ->\n Format.fprintf fmt \"`Assoc (@[\";\n Format.fprintf fmt \"@[<2>[\";\n ignore (List.fold_left\n (fun sep (key, value) ->\n if sep then\n Format.fprintf fmt \";@ \";\n Format.fprintf fmt \"(@[\";\n Format.fprintf fmt \"%S\" key;\n Format.fprintf fmt \",@ \";\n pp fmt value;\n Format.fprintf fmt \"@])\";\n true) false xs);\n Format.fprintf fmt \"@,]@]\";\n Format.fprintf fmt \"@])\"\n | `List xs ->\n Format.fprintf fmt \"`List (@[\";\n Format.fprintf fmt \"@[<2>[\";\n ignore (List.fold_left\n (fun sep x ->\n if sep then\n Format.fprintf fmt \";@ \";\n pp fmt x;\n true) false xs);\n Format.fprintf fmt \"@,]@]\";\n Format.fprintf fmt \"@])\"\n \n# 71 \"monomorphic.ml\"\n | `Tuple tup ->\n Format.fprintf fmt \"`Tuple (@[\";\n Format.fprintf fmt \"@[<2>[\";\n ignore (List.fold_left\n (fun sep e ->\n if sep then\n Format.fprintf fmt \";@ \";\n pp fmt e;\n true) false tup);\n Format.fprintf fmt \"@,]@]\";\n Format.fprintf fmt \"@])\"\n \n# 84 \"monomorphic.ml\"\n | `Variant (name, value) ->\n Format.fprintf fmt \"`Variant (@[\";\n Format.fprintf fmt \"(@[\";\n Format.fprintf fmt \"%S\" name;\n Format.fprintf fmt \",@ \";\n (match value with\n | None -> Format.pp_print_string fmt \"None\"\n | Some x ->\n Format.pp_print_string fmt \"(Some \";\n pp fmt x;\n Format.pp_print_string fmt \")\");\n Format.fprintf fmt \"@])\";\n Format.fprintf fmt \"@])\"\n\n# 99 \"monomorphic.ml\"\nlet show x =\n Format.asprintf \"%a\" pp x\n\nlet rec equal a b =\n match a, b with\n | `Null, `Null -> true\n | `Bool a, `Bool b -> a = b\n \n# 110 \"monomorphic.ml\"\n | `Intlit a, `Intlit b -> a = b\n \n# 116 \"monomorphic.ml\"\n | `Floatlit a, `Floatlit b -> a = b\n \n# 122 \"monomorphic.ml\"\n | `Stringlit a, `Stringlit b -> a = b\n \n# 124 \"monomorphic.ml\"\n | `Assoc xs, `Assoc ys ->\n let compare_keys = fun (key, _) (key', _) -> String.compare key key' in\n let xs = List.stable_sort compare_keys xs in\n let ys = List.stable_sort compare_keys ys in\n (match List.for_all2 (fun (key, value) (key', value') ->\n match key = key' with\n | false -> false\n | true -> equal value value') xs ys with\n | result -> result\n | exception Invalid_argument _ ->\n (* the lists were of different lengths, thus unequal *)\n false)\n \n# 137 \"monomorphic.ml\"\n | `Tuple xs, `Tuple ys\n \n# 139 \"monomorphic.ml\"\n | `List xs, `List ys ->\n (match List.for_all2 equal xs ys with\n | result -> result\n | exception Invalid_argument _ ->\n (* the lists were of different lengths, thus unequal *)\n false)\n \n# 146 \"monomorphic.ml\"\n | `Variant (name, value), `Variant (name', value') ->\n (match name = name' with\n | false -> false\n | true ->\n match value, value' with\n | None, None -> true\n | Some x, Some y -> equal x y\n | _ -> false)\n \n# 155 \"monomorphic.ml\"\n | _ -> false\n# 1 \"write2.ml\"\nlet pretty_format ?std (x : t) =\n Pretty.format ?std (x :> json_max)\n\nlet pretty_print ?std out (x : t) =\n Easy_format.Pretty.to_formatter out (pretty_format ?std x)\n\nlet pretty_to_string ?std (x : t) =\n Pretty.to_string ?std (x :> json_max)\n\nlet pretty_to_channel ?std oc (x : t) =\n Pretty.to_channel ?std oc (x :> json_max)\n\n# 1 \"lib/read.mll\"\n \n \n# 2 \"lib/read.mll\"\n module Lexing =\n (*\n We override Lexing.engine in order to avoid creating a new position\n record each time a rule is matched.\n This reduces total parsing time by about 31%.\n *)\n struct\n include Lexing\n\n external c_engine : lex_tables -> int -> lexbuf -> int = \"caml_lex_engine\"\n\n let engine tbl state buf =\n let result = c_engine tbl state buf in\n (*\n if result >= 0 then begin\n buf.lex_start_p <- buf.lex_curr_p;\n buf.lex_curr_p <- {buf.lex_curr_p\n with pos_cnum = buf.lex_abs_pos + buf.lex_curr_pos};\n end;\n *)\n result\n end\n\n open Printf\n open Lexing\n\n (* see description in common.mli *)\n type lexer_state = Lexer_state.t = {\n buf : Bi_outbuf.t;\n mutable lnum : int;\n mutable bol : int;\n mutable fname : string option;\n }\n\n let dec c =\n Char.code c - 48\n\n let hex c =\n match c with\n '0'..'9' -> int_of_char c - int_of_char '0'\n | 'a'..'f' -> int_of_char c - int_of_char 'a' + 10\n | 'A'..'F' -> int_of_char c - int_of_char 'A' + 10\n | _ -> assert false\n\n let custom_error descr v lexbuf =\n let offs = lexbuf.lex_abs_pos - 1 in\n let bol = v.bol in\n let pos1 = offs + lexbuf.lex_start_pos - bol - 1 in\n let pos2 = max pos1 (offs + lexbuf.lex_curr_pos - bol) in\n let file_line =\n match v.fname with\n None -> \"Line\"\n | Some s ->\n sprintf \"File %s, line\" s\n in\n let bytes =\n if pos1 = pos2 then\n sprintf \"byte %i\" (pos1+1)\n else\n sprintf \"bytes %i-%i\" (pos1+1) (pos2+1)\n in\n let msg = sprintf \"%s %i, %s:\\n%s\" file_line v.lnum bytes descr in\n json_error msg\n\n\n let lexer_error descr v lexbuf =\n custom_error\n (sprintf \"%s '%s'\" descr (Lexing.lexeme lexbuf))\n v lexbuf\n\n let read_junk = ref (fun _ -> assert false)\n\n let long_error descr v lexbuf =\n let junk = Lexing.lexeme lexbuf in\n let extra_junk = !read_junk lexbuf in\n custom_error\n (sprintf \"%s '%s%s'\" descr junk extra_junk)\n v lexbuf\n\n let min10 = min_int / 10 - (if min_int mod 10 = 0 then 0 else 1)\n let max10 = max_int / 10 + (if max_int mod 10 = 0 then 0 else 1)\n\n exception Int_overflow\n\n let extract_positive_int lexbuf =\n let start = lexbuf.lex_start_pos in\n let stop = lexbuf.lex_curr_pos in\n let s = lexbuf.lex_buffer in\n let n = ref 0 in\n for i = start to stop - 1 do\n if !n >= max10 then\n raise Int_overflow\n else\n n := 10 * !n + dec (Bytes.get s i)\n done;\n if !n < 0 then\n raise Int_overflow\n else\n !n\n\n let make_positive_int v lexbuf =\n \n# 108 \"lib/read.mll\"\n `Intlit (lexeme lexbuf)\n\n \n# 113 \"lib/read.mll\"\n let extract_negative_int lexbuf =\n let start = lexbuf.lex_start_pos + 1 in\n let stop = lexbuf.lex_curr_pos in\n let s = lexbuf.lex_buffer in\n let n = ref 0 in\n for i = start to stop - 1 do\n if !n <= min10 then\n raise Int_overflow\n else\n n := 10 * !n - dec (Bytes.get s i)\n done;\n if !n > 0 then\n raise Int_overflow\n else\n !n\n\n let make_negative_int v lexbuf =\n \n# 135 \"lib/read.mll\"\n `Intlit (lexeme lexbuf)\n\n\n \n# 141 \"lib/read.mll\"\n let set_file_name v fname =\n v.fname <- fname\n\n let newline v lexbuf =\n v.lnum <- v.lnum + 1;\n v.bol <- lexbuf.lex_abs_pos + lexbuf.lex_curr_pos\n\n let add_lexeme buf lexbuf =\n let len = lexbuf.lex_curr_pos - lexbuf.lex_start_pos in\n Bi_outbuf.add_subbytes buf lexbuf.lex_buffer lexbuf.lex_start_pos len\n\n let map_lexeme f lexbuf =\n let len = lexbuf.lex_curr_pos - lexbuf.lex_start_pos in\n f (Bytes.to_string lexbuf.lex_buffer) lexbuf.lex_start_pos len\n\n type variant_kind = [ `Edgy_bracket | `Square_bracket | `Double_quote ]\n type tuple_kind = [ `Parenthesis | `Square_bracket ]\n\n\n# 161 \"lib/read.ml\"\n# 161 \"lib/read.ml\"\nlet __ocaml_lex_tables = {\n Lexing.lex_base =\n \"\\000\\000\\236\\255\\237\\255\\003\\000\\239\\255\\016\\000\\242\\255\\243\\255\\\n \\244\\255\\245\\255\\000\\000\\031\\000\\249\\255\\085\\000\\001\\000\\000\\000\\\n \\000\\000\\001\\000\\000\\000\\001\\000\\002\\000\\255\\255\\000\\000\\000\\000\\\n \\003\\000\\254\\255\\001\\000\\004\\000\\253\\255\\011\\000\\252\\255\\003\\000\\\n \\001\\000\\003\\000\\002\\000\\003\\000\\000\\000\\251\\255\\021\\000\\097\\000\\\n \\010\\000\\022\\000\\020\\000\\016\\000\\022\\000\\012\\000\\008\\000\\250\\255\\\n \\119\\000\\129\\000\\139\\000\\161\\000\\171\\000\\181\\000\\193\\000\\209\\000\\\n \\240\\255\\011\\000\\038\\000\\252\\255\\065\\000\\254\\255\\255\\255\\110\\000\\\n \\252\\255\\163\\000\\254\\255\\255\\255\\234\\000\\247\\255\\248\\255\\048\\001\\\n \\250\\255\\251\\255\\252\\255\\253\\255\\254\\255\\255\\255\\071\\001\\126\\001\\\n \\149\\001\\249\\255\\039\\000\\253\\255\\254\\255\\038\\000\\187\\001\\210\\001\\\n \\248\\001\\015\\002\\255\\255\\220\\000\\253\\255\\255\\255\\245\\000\\039\\002\\\n \\109\\002\\014\\001\\088\\002\\164\\002\\187\\002\\225\\002\\013\\000\\252\\255\\\n \\253\\255\\254\\255\\255\\255\\014\\000\\253\\255\\254\\255\\255\\255\\030\\000\\\n \\253\\255\\254\\255\\255\\255\\015\\000\\253\\255\\254\\255\\255\\255\\017\\001\\\n \\251\\255\\252\\255\\253\\255\\254\\255\\255\\255\\019\\000\\252\\255\\253\\255\\\n \\254\\255\\015\\000\\255\\255\\016\\000\\255\\255\\008\\001\\005\\000\\253\\255\\\n \\023\\000\\254\\255\\020\\000\\255\\255\\046\\000\\253\\255\\254\\255\\042\\000\\\n \\052\\000\\053\\000\\255\\255\\053\\000\\048\\000\\091\\000\\092\\000\\255\\255\\\n \\027\\001\\250\\255\\251\\255\\137\\000\\104\\000\\089\\000\\088\\000\\106\\000\\\n \\255\\255\\143\\000\\137\\000\\177\\000\\254\\255\\183\\000\\168\\000\\166\\000\\\n \\183\\000\\002\\000\\253\\255\\177\\000\\172\\000\\187\\000\\004\\000\\252\\255\\\n \\053\\002\\251\\255\\252\\255\\253\\255\\103\\001\\255\\255\\248\\002\\254\\255\\\n \\006\\003\\030\\003\\252\\255\\253\\255\\254\\255\\255\\255\\040\\003\\050\\003\\\n \\074\\003\\252\\255\\253\\255\\254\\255\\255\\255\\061\\003\\084\\003\\108\\003\\\n \\249\\255\\250\\255\\251\\255\\244\\000\\120\\003\\142\\003\\179\\000\\194\\000\\\n \\015\\000\\255\\255\\190\\000\\188\\000\\187\\000\\193\\000\\183\\000\\179\\000\\\n \\254\\255\\191\\000\\201\\000\\200\\000\\196\\000\\203\\000\\193\\000\\189\\000\\\n \\253\\255\\157\\003\\095\\003\\174\\003\\196\\003\\206\\003\\216\\003\\228\\003\\\n \\239\\003\\060\\000\\253\\255\\254\\255\\255\\255\\012\\004\\252\\255\\253\\255\\\n \\087\\004\\255\\255\\145\\004\\252\\255\\253\\255\\221\\004\\255\\255\\229\\000\\\n \\253\\255\\254\\255\\255\\255\\231\\000\\253\\255\\254\\255\\255\\255\\002\\000\\\n \\255\\255\\018\\001\\252\\255\\253\\255\\254\\255\\255\\255\\034\\001\\253\\255\\\n \\254\\255\\255\\255\\000\\000\\255\\255\\003\\000\\254\\255\\255\\255\\038\\001\\\n \\252\\255\\253\\255\\254\\255\\255\\255\\120\\001\\251\\255\\252\\255\\253\\255\\\n \\254\\255\\255\\255\\208\\000\\253\\255\\254\\255\\255\\255\\211\\000\\253\\255\\\n \\254\\255\\255\\255\\189\\000\\255\\255\\143\\001\\252\\255\\253\\255\\254\\255\\\n \\255\\255\\013\\001\\253\\255\\254\\255\\255\\255\\095\\001\\252\\255\\253\\255\\\n \\254\\255\\255\\255\\050\\001\\253\\255\\254\\255\\255\\255\\026\\001\\253\\255\\\n \\254\\255\\255\\255\\233\\000\\253\\255\\254\\255\\255\\255\\222\\000\\253\\255\\\n \\254\\255\\255\\255\\079\\005\\237\\255\\238\\255\\010\\000\\240\\255\\044\\001\\\n \\243\\255\\244\\255\\245\\255\\246\\255\\061\\001\\002\\004\\249\\255\\045\\005\\\n \\209\\000\\228\\000\\211\\000\\232\\000\\225\\000\\223\\000\\240\\000\\255\\255\\\n \\235\\000\\234\\000\\008\\001\\254\\255\\004\\001\\023\\001\\253\\255\\054\\001\\\n \\252\\255\\031\\001\\029\\001\\032\\001\\039\\001\\049\\001\\045\\001\\251\\255\\\n \\057\\001\\082\\001\\080\\001\\078\\001\\084\\001\\074\\001\\086\\001\\250\\255\\\n \\110\\005\\012\\004\\123\\005\\155\\005\\165\\005\\177\\005\\187\\005\\197\\005\\\n \\241\\255\\199\\001\\077\\002\\253\\255\\255\\255\\154\\002\\222\\005\\209\\005\\\n \\155\\002\\239\\005\\053\\006\\076\\006\\114\\006\\016\\002\\252\\255\\253\\255\\\n \\254\\255\\255\\255\\152\\006\\252\\255\\253\\255\\227\\006\\255\\255\\085\\007\\\n \\244\\255\\245\\255\\011\\000\\247\\255\\076\\002\\250\\255\\251\\255\\252\\255\\\n \\253\\255\\254\\255\\031\\002\\243\\005\\051\\007\\100\\001\\115\\001\\104\\001\\\n \\133\\001\\118\\001\\154\\001\\171\\001\\255\\255\\173\\001\\176\\001\\191\\001\\\n \\185\\001\\187\\001\\253\\001\\230\\001\\230\\001\\234\\001\\247\\001\\237\\001\\\n \\234\\001\\009\\002\\019\\002\\019\\002\\015\\002\\021\\002\\011\\002\\007\\002\\\n \\142\\006\\152\\006\\116\\007\\170\\007\\180\\007\\190\\007\\200\\007\\210\\007\\\n \\248\\255\\120\\002\\167\\002\\253\\255\\255\\255\\216\\002\\082\\007\\220\\007\\\n \\236\\002\\244\\007\\058\\008\\081\\008\\119\\008\\076\\002\\252\\255\\253\\255\\\n \\254\\255\\255\\255\\157\\008\\252\\255\\253\\255\\232\\008\\255\\255\\135\\002\\\n \\120\\002\\253\\255\\100\\002\\254\\255\\182\\002\\255\\255\\011\\002\\255\\255\\\n \\204\\002\\252\\255\\253\\255\\254\\255\\255\\255\\046\\002\\255\\255\\178\\002\\\n \\252\\255\\253\\255\\254\\255\\255\\255\\023\\000\\255\\255\\183\\002\\252\\255\\\n \\253\\255\\254\\255\\255\\255\\187\\002\\253\\255\\254\\255\\255\\255\\121\\002\\\n \\253\\255\\254\\255\\255\\255\\184\\002\\252\\255\\253\\255\\254\\255\\019\\000\\\n \\255\\255\\140\\001\\146\\001\\255\\255\\150\\001\\151\\001\\154\\001\\168\\001\\\n \\170\\001\\171\\001\\172\\001\\173\\001\\181\\001\\184\\001\\185\\001\\187\\001\\\n \\191\\001\\193\\001\\195\\001\\196\\001\\197\\001\\200\\001\\203\\001\\223\\001\\\n \\225\\001\\228\\001\\249\\001\\251\\001\\002\\002\\004\\002\\011\\002\\012\\002\\\n \\013\\002\\000\\000\";\n Lexing.lex_backtrk =\n \"\\255\\255\\255\\255\\255\\255\\017\\000\\255\\255\\019\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\007\\000\\007\\000\\255\\255\\019\\000\\019\\000\\019\\000\\\n \\019\\000\\019\\000\\019\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\008\\000\\008\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\009\\000\\255\\255\\009\\000\\255\\255\\009\\000\\255\\255\\\n \\255\\255\\014\\000\\255\\255\\255\\255\\002\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\002\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\007\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\001\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\003\\000\\255\\255\\001\\000\\255\\255\\004\\000\\003\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\\n \\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\004\\000\\004\\000\\004\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\003\\000\\255\\255\\000\\000\\255\\255\\\n \\001\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\002\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\002\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\003\\000\\003\\000\\005\\000\\005\\000\\005\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\003\\000\\255\\255\\003\\000\\255\\255\\003\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\001\\000\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\001\\000\\255\\255\\002\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\001\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\016\\000\\255\\255\\018\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\007\\000\\007\\000\\255\\255\\018\\000\\\n \\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\008\\000\\255\\255\\008\\000\\255\\255\\008\\000\\255\\255\\\n \\255\\255\\013\\000\\255\\255\\255\\255\\255\\255\\001\\000\\001\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\009\\000\\255\\255\\011\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\000\\000\\000\\000\\011\\000\\011\\000\\011\\000\\011\\000\\\n \\011\\000\\011\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\000\\000\\255\\255\\000\\000\\255\\255\\000\\000\\255\\255\\\n \\255\\255\\006\\000\\255\\255\\255\\255\\255\\255\\001\\000\\001\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\004\\000\\\n \\003\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\003\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\";\n Lexing.lex_default =\n \"\\001\\000\\000\\000\\000\\000\\255\\255\\000\\000\\255\\255\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\\n \\255\\255\\000\\000\\255\\255\\255\\255\\000\\000\\255\\255\\000\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\000\\000\\057\\000\\060\\000\\000\\000\\060\\000\\000\\000\\000\\000\\065\\000\\\n \\000\\000\\065\\000\\000\\000\\000\\000\\070\\000\\000\\000\\000\\000\\255\\255\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\255\\255\\\n \\255\\255\\000\\000\\084\\000\\000\\000\\000\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\000\\000\\094\\000\\000\\000\\000\\000\\097\\000\\255\\255\\\n \\255\\255\\097\\000\\255\\255\\255\\255\\255\\255\\255\\255\\104\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\109\\000\\000\\000\\000\\000\\000\\000\\113\\000\\\n \\000\\000\\000\\000\\000\\000\\117\\000\\000\\000\\000\\000\\000\\000\\121\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\126\\000\\000\\000\\000\\000\\\n \\000\\000\\255\\255\\000\\000\\255\\255\\000\\000\\255\\255\\255\\255\\000\\000\\\n \\255\\255\\000\\000\\138\\000\\000\\000\\142\\000\\000\\000\\000\\000\\255\\255\\\n \\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\\n \\154\\000\\000\\000\\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\000\\000\\255\\255\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\\n \\178\\000\\000\\000\\000\\000\\000\\000\\255\\255\\000\\000\\255\\255\\000\\000\\\n \\255\\255\\187\\000\\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\255\\255\\\n \\194\\000\\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\255\\255\\201\\000\\\n \\000\\000\\000\\000\\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\235\\000\\000\\000\\000\\000\\000\\000\\239\\000\\000\\000\\000\\000\\\n \\255\\255\\000\\000\\244\\000\\000\\000\\000\\000\\255\\255\\000\\000\\249\\000\\\n \\000\\000\\000\\000\\000\\000\\253\\000\\000\\000\\000\\000\\000\\000\\255\\255\\\n \\000\\000\\003\\001\\000\\000\\000\\000\\000\\000\\000\\000\\008\\001\\000\\000\\\n \\000\\000\\000\\000\\255\\255\\000\\000\\255\\255\\000\\000\\000\\000\\017\\001\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\022\\001\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\028\\001\\000\\000\\000\\000\\000\\000\\032\\001\\000\\000\\\n \\000\\000\\000\\000\\255\\255\\000\\000\\038\\001\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\043\\001\\000\\000\\000\\000\\000\\000\\047\\001\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\052\\001\\000\\000\\000\\000\\000\\000\\056\\001\\000\\000\\\n \\000\\000\\000\\000\\060\\001\\000\\000\\000\\000\\000\\000\\064\\001\\000\\000\\\n \\000\\000\\000\\000\\067\\001\\000\\000\\000\\000\\255\\255\\000\\000\\255\\255\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\255\\255\\000\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\\n \\255\\255\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\000\\000\\255\\255\\\n \\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\000\\000\\121\\001\\125\\001\\000\\000\\000\\000\\128\\001\\255\\255\\255\\255\\\n \\128\\001\\255\\255\\255\\255\\255\\255\\255\\255\\135\\001\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\140\\001\\000\\000\\000\\000\\255\\255\\000\\000\\144\\001\\\n \\000\\000\\000\\000\\255\\255\\000\\000\\255\\255\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\000\\000\\193\\001\\197\\001\\000\\000\\000\\000\\200\\001\\255\\255\\255\\255\\\n \\200\\001\\255\\255\\255\\255\\255\\255\\255\\255\\207\\001\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\212\\001\\000\\000\\000\\000\\255\\255\\000\\000\\255\\255\\\n \\255\\255\\000\\000\\255\\255\\000\\000\\220\\001\\000\\000\\255\\255\\000\\000\\\n \\226\\001\\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\000\\000\\233\\001\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\000\\000\\240\\001\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\245\\001\\000\\000\\000\\000\\000\\000\\249\\001\\\n \\000\\000\\000\\000\\000\\000\\252\\001\\000\\000\\000\\000\\000\\000\\255\\255\\\n \\000\\000\\002\\002\\004\\002\\000\\000\\005\\002\\006\\002\\007\\002\\008\\002\\\n \\009\\002\\010\\002\\011\\002\\012\\002\\013\\002\\014\\002\\015\\002\\016\\002\\\n \\017\\002\\018\\002\\019\\002\\020\\002\\021\\002\\022\\002\\023\\002\\024\\002\\\n \\025\\002\\026\\002\\027\\002\\028\\002\\029\\002\\030\\002\\031\\002\\032\\002\\\n \\033\\002\\003\\002\";\n Lexing.lex_trans =\n \"\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\003\\000\\004\\000\\000\\000\\003\\000\\003\\000\\134\\000\\000\\000\\\n \\003\\000\\000\\000\\134\\000\\069\\001\\146\\001\\255\\255\\000\\000\\069\\001\\\n \\146\\001\\000\\000\\000\\000\\000\\000\\000\\000\\127\\000\\139\\000\\000\\000\\\n \\003\\000\\000\\000\\012\\000\\003\\000\\170\\000\\134\\000\\175\\000\\000\\000\\\n \\007\\000\\011\\001\\069\\001\\146\\001\\014\\001\\013\\000\\049\\000\\005\\000\\\n \\010\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\\n \\011\\000\\011\\000\\056\\000\\118\\000\\006\\000\\129\\000\\130\\000\\057\\000\\\n \\237\\001\\137\\000\\000\\002\\049\\000\\000\\000\\048\\000\\138\\000\\106\\000\\\n \\062\\000\\014\\000\\110\\000\\105\\000\\000\\000\\049\\000\\015\\000\\011\\000\\\n \\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\\n \\011\\000\\030\\000\\048\\000\\008\\000\\114\\000\\209\\000\\236\\000\\000\\001\\\n \\013\\001\\029\\000\\022\\000\\255\\255\\048\\000\\048\\000\\017\\000\\021\\000\\\n \\025\\000\\032\\000\\033\\000\\035\\000\\023\\000\\027\\000\\016\\000\\031\\000\\\n \\028\\000\\034\\000\\019\\000\\024\\000\\018\\000\\026\\000\\020\\000\\036\\000\\\n \\041\\000\\037\\000\\048\\000\\009\\000\\042\\000\\043\\000\\044\\000\\045\\000\\\n \\046\\000\\047\\000\\061\\000\\085\\000\\048\\000\\038\\000\\039\\000\\039\\000\\\n \\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\049\\000\\\n \\067\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\\n \\039\\000\\039\\000\\039\\000\\086\\000\\143\\000\\255\\255\\040\\000\\144\\000\\\n \\145\\000\\146\\000\\055\\000\\148\\000\\055\\000\\149\\000\\048\\000\\054\\000\\\n \\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\\n \\054\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\\n \\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\\n \\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\255\\255\\048\\000\\150\\000\\\n \\151\\000\\161\\000\\066\\000\\158\\000\\053\\000\\159\\000\\053\\000\\160\\000\\\n \\051\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\\n \\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\\n \\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\\n \\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\165\\000\\\n \\051\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\\n \\054\\000\\054\\000\\054\\000\\162\\000\\163\\000\\166\\000\\093\\000\\255\\255\\\n \\002\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\\n \\054\\000\\054\\000\\054\\000\\255\\255\\077\\000\\103\\000\\108\\000\\116\\000\\\n \\132\\000\\134\\000\\135\\000\\128\\000\\139\\000\\134\\000\\164\\000\\093\\000\\\n \\171\\000\\077\\000\\167\\000\\168\\000\\169\\000\\172\\000\\112\\000\\173\\000\\\n \\174\\000\\210\\000\\226\\000\\208\\000\\211\\000\\212\\000\\059\\000\\083\\000\\\n \\134\\000\\213\\000\\214\\000\\215\\000\\216\\000\\218\\000\\141\\000\\219\\000\\\n \\093\\000\\220\\000\\221\\000\\123\\000\\222\\000\\223\\000\\224\\000\\136\\000\\\n \\095\\000\\225\\000\\035\\001\\065\\001\\234\\000\\155\\000\\005\\001\\097\\001\\\n \\250\\000\\255\\255\\254\\000\\057\\001\\061\\001\\095\\001\\077\\000\\044\\001\\\n \\092\\001\\088\\001\\009\\001\\029\\001\\076\\000\\124\\000\\033\\001\\018\\001\\\n \\075\\000\\098\\000\\019\\001\\085\\001\\086\\001\\087\\001\\120\\001\\089\\001\\\n \\074\\000\\225\\000\\053\\001\\121\\001\\073\\000\\090\\001\\072\\000\\071\\000\\\n \\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\\n \\078\\000\\078\\000\\098\\000\\113\\001\\122\\000\\091\\001\\064\\000\\004\\001\\\n \\093\\001\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\079\\000\\\n \\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\\n \\079\\000\\156\\000\\112\\001\\094\\001\\096\\001\\098\\001\\099\\001\\049\\001\\\n \\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\100\\001\\157\\000\\\n \\101\\001\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\183\\000\\\n \\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\\n \\184\\000\\024\\001\\112\\001\\255\\255\\025\\001\\102\\001\\103\\001\\105\\001\\\n \\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\080\\000\\080\\000\\\n \\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\\n \\106\\001\\107\\001\\048\\001\\040\\001\\108\\001\\109\\001\\110\\001\\080\\000\\\n \\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\081\\000\\081\\000\\081\\000\\\n \\081\\000\\081\\000\\081\\000\\081\\000\\081\\000\\081\\000\\081\\000\\111\\001\\\n \\027\\001\\255\\255\\171\\001\\031\\001\\170\\001\\023\\001\\081\\000\\081\\000\\\n \\081\\000\\081\\000\\081\\000\\081\\000\\092\\000\\168\\001\\063\\001\\080\\000\\\n \\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\248\\000\\165\\001\\252\\000\\\n \\162\\001\\059\\001\\069\\000\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\\n \\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\255\\255\\081\\000\\081\\000\\\n \\081\\000\\081\\000\\081\\000\\081\\000\\087\\000\\087\\000\\087\\000\\087\\000\\\n \\087\\000\\087\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\\n \\088\\000\\088\\000\\088\\000\\088\\000\\039\\001\\042\\001\\255\\255\\163\\001\\\n \\164\\001\\120\\000\\002\\001\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\\n \\088\\000\\166\\001\\055\\001\\153\\000\\087\\000\\087\\000\\087\\000\\087\\000\\\n \\087\\000\\087\\000\\007\\001\\167\\001\\164\\001\\169\\001\\016\\001\\164\\001\\\n \\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\\n \\089\\000\\089\\000\\051\\001\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\\n \\088\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\090\\000\\\n \\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\\n \\090\\000\\097\\000\\137\\001\\164\\001\\172\\001\\185\\001\\136\\001\\173\\001\\\n \\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\097\\000\\179\\000\\\n \\174\\001\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\046\\001\\\n \\175\\001\\176\\001\\180\\000\\164\\001\\184\\001\\181\\000\\182\\000\\182\\000\\\n \\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\124\\001\\\n \\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\192\\001\\178\\001\\\n \\021\\001\\179\\001\\097\\000\\193\\001\\180\\001\\181\\001\\182\\001\\183\\001\\\n \\164\\001\\216\\001\\255\\255\\097\\000\\184\\001\\216\\001\\209\\001\\097\\000\\\n \\223\\001\\097\\000\\208\\001\\230\\001\\003\\002\\097\\000\\219\\001\\037\\001\\\n \\216\\001\\217\\001\\003\\002\\220\\001\\216\\001\\097\\000\\003\\002\\003\\002\\\n \\216\\001\\097\\000\\003\\002\\097\\000\\096\\000\\099\\000\\099\\000\\099\\000\\\n \\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\216\\001\\\n \\003\\002\\126\\001\\003\\002\\003\\002\\003\\002\\003\\002\\099\\000\\099\\000\\\n \\099\\000\\099\\000\\099\\000\\099\\000\\097\\000\\003\\002\\218\\001\\250\\001\\\n \\003\\002\\003\\002\\097\\000\\003\\002\\124\\001\\124\\001\\097\\000\\003\\002\\\n \\221\\001\\003\\002\\253\\001\\003\\002\\003\\002\\003\\002\\097\\000\\255\\255\\\n \\003\\002\\196\\001\\097\\000\\003\\002\\097\\000\\096\\000\\099\\000\\099\\000\\\n \\099\\000\\099\\000\\099\\000\\099\\000\\100\\000\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\235\\001\\003\\002\\\n \\241\\001\\003\\002\\255\\001\\242\\001\\003\\002\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\100\\000\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\\n \\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\246\\001\\129\\001\\129\\001\\\n \\228\\001\\003\\002\\196\\001\\003\\002\\101\\000\\101\\000\\101\\000\\101\\000\\\n \\101\\000\\101\\000\\003\\002\\198\\001\\003\\002\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\100\\000\\003\\002\\003\\002\\003\\002\\196\\001\\234\\001\\\n \\134\\001\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\\n \\097\\000\\097\\000\\097\\000\\000\\000\\101\\000\\101\\000\\101\\000\\101\\000\\\n \\101\\000\\101\\000\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\\n \\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\\n \\182\\000\\182\\000\\000\\000\\000\\000\\201\\001\\177\\000\\184\\000\\184\\000\\\n \\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\\n \\188\\000\\000\\000\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\\n \\201\\001\\227\\001\\000\\000\\191\\000\\206\\001\\123\\001\\189\\000\\190\\000\\\n \\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\\n \\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\\n \\190\\000\\190\\000\\189\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\\n \\190\\000\\190\\000\\190\\000\\190\\000\\195\\000\\197\\000\\197\\000\\197\\000\\\n \\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\198\\000\\\n \\255\\255\\248\\001\\196\\000\\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\\n \\197\\000\\197\\000\\197\\000\\197\\000\\196\\000\\197\\000\\197\\000\\197\\000\\\n \\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\202\\000\\227\\000\\\n \\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\\n \\227\\000\\205\\000\\255\\255\\255\\255\\203\\000\\204\\000\\204\\000\\204\\000\\\n \\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\226\\000\\195\\001\\\n \\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\\n \\204\\000\\204\\000\\232\\001\\000\\000\\000\\000\\206\\000\\221\\001\\239\\001\\\n \\254\\001\\000\\000\\207\\000\\244\\001\\000\\000\\225\\000\\203\\000\\204\\000\\\n \\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\\n \\232\\000\\000\\000\\232\\000\\000\\000\\225\\001\\231\\000\\231\\000\\231\\000\\\n \\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\217\\000\\\n \\255\\255\\000\\000\\000\\000\\000\\000\\000\\000\\225\\000\\227\\000\\227\\000\\\n \\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\000\\000\\000\\000\\230\\000\\\n \\000\\000\\230\\000\\000\\000\\228\\000\\229\\000\\229\\000\\229\\000\\229\\000\\\n \\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\\n \\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\\n \\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\\n \\229\\000\\229\\000\\000\\000\\228\\000\\231\\000\\231\\000\\231\\000\\231\\000\\\n \\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\186\\000\\231\\000\\\n \\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\\n \\231\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\241\\000\\000\\000\\\n \\113\\001\\000\\000\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\\n \\077\\001\\077\\001\\077\\001\\077\\001\\114\\001\\114\\001\\114\\001\\114\\001\\\n \\114\\001\\114\\001\\114\\001\\114\\001\\114\\001\\114\\001\\000\\000\\112\\001\\\n \\000\\000\\000\\000\\193\\000\\000\\000\\000\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\112\\001\\\n \\000\\000\\000\\000\\000\\000\\240\\000\\200\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\000\\000\\246\\000\\000\\000\\000\\000\\240\\000\\000\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\245\\000\\000\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\238\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\245\\000\\000\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\069\\001\\070\\001\\000\\000\\000\\000\\069\\001\\076\\001\\077\\001\\077\\001\\\n \\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\069\\001\\\n \\000\\000\\078\\001\\000\\000\\000\\000\\000\\000\\000\\000\\104\\001\\073\\001\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\079\\001\\000\\000\\071\\001\\076\\001\\\n \\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\\n \\077\\001\\000\\000\\000\\000\\072\\001\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\243\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\080\\001\\119\\001\\000\\000\\119\\001\\000\\000\\081\\001\\118\\001\\118\\001\\\n \\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\\n \\000\\000\\000\\000\\074\\001\\114\\001\\114\\001\\114\\001\\114\\001\\114\\001\\\n \\114\\001\\114\\001\\114\\001\\114\\001\\114\\001\\083\\001\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\082\\001\\000\\000\\000\\000\\\n \\115\\001\\000\\000\\000\\000\\084\\001\\000\\000\\000\\000\\117\\001\\000\\000\\\n \\117\\001\\000\\000\\075\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\\n \\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\\n \\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\000\\000\\\n \\115\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\\n \\116\\001\\116\\001\\116\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\\n \\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\\n \\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\000\\000\\\n \\128\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\\n \\130\\001\\130\\001\\130\\001\\000\\000\\000\\000\\128\\001\\000\\000\\000\\000\\\n \\000\\000\\128\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\001\\000\\000\\\n \\000\\000\\185\\001\\000\\000\\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\\n \\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\\n \\184\\001\\000\\000\\128\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\128\\001\\000\\000\\000\\000\\000\\000\\128\\001\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\128\\001\\128\\001\\000\\000\\000\\000\\068\\001\\\n \\128\\001\\128\\001\\128\\001\\127\\001\\000\\000\\128\\001\\000\\000\\000\\000\\\n \\184\\001\\000\\000\\000\\000\\000\\000\\000\\000\\128\\001\\000\\000\\000\\000\\\n \\000\\000\\128\\001\\000\\000\\128\\001\\127\\001\\131\\001\\131\\001\\131\\001\\\n \\131\\001\\131\\001\\131\\001\\131\\001\\131\\001\\131\\001\\131\\001\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\131\\001\\131\\001\\\n \\131\\001\\131\\001\\131\\001\\131\\001\\132\\001\\132\\001\\132\\001\\132\\001\\\n \\132\\001\\132\\001\\132\\001\\132\\001\\132\\001\\132\\001\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\132\\001\\132\\001\\132\\001\\\n \\132\\001\\132\\001\\132\\001\\000\\000\\000\\000\\000\\000\\131\\001\\131\\001\\\n \\131\\001\\131\\001\\131\\001\\131\\001\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\128\\001\\128\\001\\128\\001\\128\\001\\128\\001\\128\\001\\\n \\128\\001\\128\\001\\128\\001\\128\\001\\000\\000\\132\\001\\132\\001\\132\\001\\\n \\132\\001\\132\\001\\132\\001\\128\\001\\128\\001\\128\\001\\128\\001\\128\\001\\\n \\128\\001\\191\\001\\142\\001\\191\\001\\000\\000\\000\\000\\190\\001\\190\\001\\\n \\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\\n \\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\\n \\186\\001\\186\\001\\000\\000\\128\\001\\128\\001\\128\\001\\128\\001\\128\\001\\\n \\128\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\000\\000\\000\\000\\000\\000\\000\\000\\141\\001\\\n \\000\\000\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\141\\001\\000\\000\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\146\\001\\147\\001\\\n \\000\\000\\000\\000\\146\\001\\154\\001\\155\\001\\155\\001\\155\\001\\155\\001\\\n \\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\200\\001\\146\\001\\000\\000\\153\\001\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\177\\001\\150\\001\\000\\000\\000\\000\\\n \\000\\000\\200\\001\\156\\001\\000\\000\\148\\001\\154\\001\\155\\001\\155\\001\\\n \\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\000\\000\\\n \\000\\000\\149\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\139\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\157\\001\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\158\\001\\186\\001\\186\\001\\186\\001\\186\\001\\\n \\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\200\\001\\000\\000\\\n \\151\\001\\000\\000\\000\\000\\000\\000\\200\\001\\000\\000\\000\\000\\000\\000\\\n \\200\\001\\187\\001\\000\\000\\160\\001\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\200\\001\\000\\000\\000\\000\\159\\001\\200\\001\\000\\000\\200\\001\\199\\001\\\n \\000\\000\\161\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\152\\001\\000\\000\\000\\000\\000\\000\\000\\000\\189\\001\\000\\000\\189\\001\\\n \\000\\000\\187\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\\n \\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\\n \\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\\n \\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\\n \\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\\n \\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\\n \\190\\001\\190\\001\\190\\001\\190\\001\\202\\001\\202\\001\\202\\001\\202\\001\\\n \\202\\001\\202\\001\\202\\001\\202\\001\\202\\001\\202\\001\\200\\001\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\202\\001\\202\\001\\202\\001\\\n \\202\\001\\202\\001\\202\\001\\200\\001\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\202\\001\\202\\001\\202\\001\\\n \\202\\001\\202\\001\\202\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\200\\001\\000\\000\\000\\000\\000\\000\\000\\000\\145\\001\\200\\001\\000\\000\\\n \\000\\000\\000\\000\\200\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\200\\001\\000\\000\\000\\000\\000\\000\\200\\001\\000\\000\\\n \\200\\001\\199\\001\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\\n \\203\\001\\203\\001\\203\\001\\203\\001\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\\n \\203\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\\n \\204\\001\\204\\001\\204\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\\n \\000\\000\\000\\000\\000\\000\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\\n \\203\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\200\\001\\\n \\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\\n \\200\\001\\000\\000\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\\n \\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\000\\000\\214\\001\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\213\\001\\000\\000\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\000\\000\\000\\000\\000\\000\\000\\000\\213\\001\\\n \\000\\000\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\211\\001\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\";\n Lexing.lex_check =\n \"\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\000\\000\\000\\000\\255\\255\\003\\000\\000\\000\\134\\000\\255\\255\\\n \\003\\000\\255\\255\\134\\000\\069\\001\\146\\001\\057\\000\\255\\255\\069\\001\\\n \\146\\001\\255\\255\\255\\255\\255\\255\\255\\255\\125\\000\\138\\000\\255\\255\\\n \\000\\000\\255\\255\\000\\000\\003\\000\\169\\000\\134\\000\\174\\000\\255\\255\\\n \\000\\000\\010\\001\\069\\001\\146\\001\\012\\001\\000\\000\\010\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\005\\000\\115\\000\\000\\000\\125\\000\\129\\000\\005\\000\\\n \\236\\001\\136\\000\\255\\001\\038\\000\\255\\255\\010\\000\\136\\000\\102\\000\\\n \\058\\000\\000\\000\\107\\000\\102\\000\\255\\255\\011\\000\\000\\000\\011\\000\\\n \\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\\n \\011\\000\\029\\000\\038\\000\\000\\000\\111\\000\\208\\000\\233\\000\\255\\000\\\n \\012\\001\\015\\000\\017\\000\\060\\000\\011\\000\\010\\000\\000\\000\\020\\000\\\n \\024\\000\\031\\000\\032\\000\\034\\000\\022\\000\\026\\000\\000\\000\\014\\000\\\n \\027\\000\\033\\000\\018\\000\\023\\000\\000\\000\\016\\000\\019\\000\\035\\000\\\n \\040\\000\\036\\000\\038\\000\\000\\000\\041\\000\\042\\000\\043\\000\\044\\000\\\n \\045\\000\\046\\000\\058\\000\\082\\000\\011\\000\\013\\000\\013\\000\\013\\000\\\n \\013\\000\\013\\000\\013\\000\\013\\000\\013\\000\\013\\000\\013\\000\\039\\000\\\n \\063\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\\n \\039\\000\\039\\000\\039\\000\\085\\000\\140\\000\\060\\000\\013\\000\\143\\000\\\n \\144\\000\\145\\000\\048\\000\\147\\000\\048\\000\\148\\000\\039\\000\\048\\000\\\n \\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\\n \\048\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\\n \\049\\000\\049\\000\\049\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\\n \\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\065\\000\\039\\000\\149\\000\\\n \\150\\000\\156\\000\\063\\000\\157\\000\\051\\000\\158\\000\\051\\000\\159\\000\\\n \\050\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\\n \\051\\000\\051\\000\\051\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\\n \\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\053\\000\\053\\000\\053\\000\\\n \\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\155\\000\\\n \\050\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\\n \\054\\000\\054\\000\\054\\000\\161\\000\\162\\000\\155\\000\\091\\000\\065\\000\\\n \\000\\000\\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\\n \\055\\000\\055\\000\\055\\000\\057\\000\\068\\000\\102\\000\\107\\000\\115\\000\\\n \\131\\000\\133\\000\\133\\000\\125\\000\\138\\000\\133\\000\\163\\000\\094\\000\\\n \\165\\000\\068\\000\\166\\000\\167\\000\\168\\000\\171\\000\\111\\000\\172\\000\\\n \\173\\000\\206\\000\\203\\000\\207\\000\\210\\000\\211\\000\\058\\000\\082\\000\\\n \\133\\000\\212\\000\\213\\000\\214\\000\\215\\000\\217\\000\\140\\000\\218\\000\\\n \\097\\000\\219\\000\\220\\000\\119\\000\\221\\000\\222\\000\\223\\000\\133\\000\\\n \\091\\000\\203\\000\\034\\001\\062\\001\\233\\000\\152\\000\\001\\001\\080\\001\\\n \\247\\000\\060\\000\\251\\000\\054\\001\\058\\001\\081\\001\\068\\000\\041\\001\\\n \\082\\001\\083\\001\\006\\001\\026\\001\\068\\000\\119\\000\\030\\001\\015\\001\\\n \\068\\000\\094\\000\\015\\001\\084\\001\\085\\001\\086\\001\\071\\001\\088\\001\\\n \\068\\000\\203\\000\\050\\001\\071\\001\\068\\000\\089\\001\\068\\000\\068\\000\\\n \\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\\n \\071\\000\\071\\000\\097\\000\\076\\001\\119\\000\\090\\001\\063\\000\\001\\001\\\n \\092\\001\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\078\\000\\\n \\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\\n \\078\\000\\152\\000\\076\\001\\093\\001\\095\\001\\097\\001\\098\\001\\045\\001\\\n \\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\099\\001\\152\\000\\\n \\100\\001\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\180\\000\\\n \\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\\n \\180\\000\\020\\001\\076\\001\\065\\000\\020\\001\\101\\001\\102\\001\\104\\001\\\n \\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\079\\000\\079\\000\\\n \\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\\n \\105\\001\\106\\001\\045\\001\\036\\001\\107\\001\\108\\001\\109\\001\\079\\000\\\n \\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\080\\000\\080\\000\\080\\000\\\n \\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\110\\001\\\n \\026\\001\\121\\001\\157\\001\\030\\001\\158\\001\\020\\001\\080\\000\\080\\000\\\n \\080\\000\\080\\000\\080\\000\\080\\000\\091\\000\\159\\001\\062\\001\\079\\000\\\n \\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\247\\000\\160\\001\\251\\000\\\n \\161\\001\\058\\001\\068\\000\\086\\000\\086\\000\\086\\000\\086\\000\\086\\000\\\n \\086\\000\\086\\000\\086\\000\\086\\000\\086\\000\\094\\000\\080\\000\\080\\000\\\n \\080\\000\\080\\000\\080\\000\\080\\000\\086\\000\\086\\000\\086\\000\\086\\000\\\n \\086\\000\\086\\000\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\\n \\087\\000\\087\\000\\087\\000\\087\\000\\036\\001\\041\\001\\097\\000\\162\\001\\\n \\163\\001\\119\\000\\001\\001\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\\n \\087\\000\\165\\001\\054\\001\\152\\000\\086\\000\\086\\000\\086\\000\\086\\000\\\n \\086\\000\\086\\000\\006\\001\\166\\001\\167\\001\\168\\001\\015\\001\\169\\001\\\n \\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\\n \\088\\000\\088\\000\\050\\001\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\\n \\087\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\089\\000\\\n \\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\\n \\089\\000\\095\\000\\133\\001\\170\\001\\171\\001\\154\\001\\133\\001\\172\\001\\\n \\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\095\\000\\176\\000\\\n \\173\\001\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\045\\001\\\n \\174\\001\\175\\001\\176\\000\\176\\001\\154\\001\\176\\000\\176\\000\\176\\000\\\n \\176\\000\\176\\000\\176\\000\\176\\000\\176\\000\\176\\000\\176\\000\\122\\001\\\n \\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\148\\001\\177\\001\\\n \\020\\001\\178\\001\\098\\000\\148\\001\\179\\001\\180\\001\\181\\001\\182\\001\\\n \\183\\001\\216\\001\\193\\001\\095\\000\\154\\001\\216\\001\\205\\001\\098\\000\\\n \\222\\001\\095\\000\\205\\001\\229\\001\\001\\002\\095\\000\\218\\001\\036\\001\\\n \\215\\001\\215\\001\\002\\002\\218\\001\\215\\001\\095\\000\\004\\002\\005\\002\\\n \\216\\001\\095\\000\\006\\002\\095\\000\\095\\000\\096\\000\\096\\000\\096\\000\\\n \\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\215\\001\\\n \\007\\002\\122\\001\\008\\002\\009\\002\\010\\002\\011\\002\\096\\000\\096\\000\\\n \\096\\000\\096\\000\\096\\000\\096\\000\\098\\000\\012\\002\\215\\001\\247\\001\\\n \\013\\002\\014\\002\\098\\000\\015\\002\\125\\001\\128\\001\\098\\000\\016\\002\\\n \\220\\001\\017\\002\\251\\001\\018\\002\\019\\002\\020\\002\\098\\000\\121\\001\\\n \\021\\002\\194\\001\\098\\000\\022\\002\\098\\000\\098\\000\\096\\000\\096\\000\\\n \\096\\000\\096\\000\\096\\000\\096\\000\\099\\000\\099\\000\\099\\000\\099\\000\\\n \\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\231\\001\\023\\002\\\n \\238\\001\\024\\002\\251\\001\\238\\001\\025\\002\\099\\000\\099\\000\\099\\000\\\n \\099\\000\\099\\000\\099\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\243\\001\\125\\001\\128\\001\\\n \\224\\001\\026\\002\\197\\001\\027\\002\\100\\000\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\028\\002\\194\\001\\029\\002\\099\\000\\099\\000\\099\\000\\\n \\099\\000\\099\\000\\099\\000\\030\\002\\031\\002\\032\\002\\200\\001\\231\\001\\\n \\133\\001\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\\n \\101\\000\\101\\000\\101\\000\\255\\255\\100\\000\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\\n \\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\\n \\182\\000\\182\\000\\255\\255\\255\\255\\197\\001\\176\\000\\184\\000\\184\\000\\\n \\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\\n \\185\\000\\255\\255\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\\n \\200\\001\\224\\001\\255\\255\\185\\000\\205\\001\\122\\001\\185\\000\\185\\000\\\n \\185\\000\\185\\000\\185\\000\\185\\000\\185\\000\\185\\000\\185\\000\\185\\000\\\n \\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\\n \\190\\000\\190\\000\\191\\000\\191\\000\\191\\000\\191\\000\\191\\000\\191\\000\\\n \\191\\000\\191\\000\\191\\000\\191\\000\\192\\000\\197\\000\\197\\000\\197\\000\\\n \\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\192\\000\\\n \\193\\001\\247\\001\\192\\000\\192\\000\\192\\000\\192\\000\\192\\000\\192\\000\\\n \\192\\000\\192\\000\\192\\000\\192\\000\\198\\000\\198\\000\\198\\000\\198\\000\\\n \\198\\000\\198\\000\\198\\000\\198\\000\\198\\000\\198\\000\\199\\000\\226\\000\\\n \\226\\000\\226\\000\\226\\000\\226\\000\\226\\000\\226\\000\\226\\000\\226\\000\\\n \\226\\000\\199\\000\\125\\001\\128\\001\\199\\000\\199\\000\\199\\000\\199\\000\\\n \\199\\000\\199\\000\\199\\000\\199\\000\\199\\000\\199\\000\\204\\000\\194\\001\\\n \\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\\n \\204\\000\\204\\000\\231\\001\\255\\255\\255\\255\\199\\000\\220\\001\\238\\001\\\n \\251\\001\\255\\255\\199\\000\\243\\001\\255\\255\\204\\000\\205\\000\\205\\000\\\n \\205\\000\\205\\000\\205\\000\\205\\000\\205\\000\\205\\000\\205\\000\\205\\000\\\n \\225\\000\\255\\255\\225\\000\\255\\255\\224\\001\\225\\000\\225\\000\\225\\000\\\n \\225\\000\\225\\000\\225\\000\\225\\000\\225\\000\\225\\000\\225\\000\\205\\000\\\n \\197\\001\\255\\255\\255\\255\\255\\255\\255\\255\\204\\000\\227\\000\\227\\000\\\n \\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\200\\001\\255\\255\\255\\255\\228\\000\\\n \\255\\255\\228\\000\\255\\255\\227\\000\\228\\000\\228\\000\\228\\000\\228\\000\\\n \\228\\000\\228\\000\\228\\000\\228\\000\\228\\000\\228\\000\\229\\000\\229\\000\\\n \\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\\n \\230\\000\\230\\000\\230\\000\\230\\000\\230\\000\\230\\000\\230\\000\\230\\000\\\n \\230\\000\\230\\000\\255\\255\\227\\000\\231\\000\\231\\000\\231\\000\\231\\000\\\n \\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\185\\000\\232\\000\\\n \\232\\000\\232\\000\\232\\000\\232\\000\\232\\000\\232\\000\\232\\000\\232\\000\\\n \\232\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\237\\000\\255\\255\\\n \\077\\001\\255\\255\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\\n \\077\\001\\077\\001\\077\\001\\077\\001\\113\\001\\113\\001\\113\\001\\113\\001\\\n \\113\\001\\113\\001\\113\\001\\113\\001\\113\\001\\113\\001\\255\\255\\077\\001\\\n \\255\\255\\255\\255\\192\\000\\255\\255\\255\\255\\237\\000\\237\\000\\237\\000\\\n \\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\\n \\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\\n \\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\077\\001\\\n \\255\\255\\255\\255\\255\\255\\237\\000\\199\\000\\237\\000\\237\\000\\237\\000\\\n \\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\\n \\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\\n \\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\255\\255\\242\\000\\255\\255\\255\\255\\240\\000\\255\\255\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\\n \\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\\n \\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\\n \\242\\000\\242\\000\\242\\000\\242\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\242\\000\\255\\255\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\\n \\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\\n \\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\\n \\242\\000\\242\\000\\242\\000\\242\\000\\237\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\245\\000\\255\\255\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\066\\001\\066\\001\\255\\255\\255\\255\\066\\001\\079\\001\\079\\001\\079\\001\\\n \\079\\001\\079\\001\\079\\001\\079\\001\\079\\001\\079\\001\\079\\001\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\066\\001\\\n \\255\\255\\066\\001\\255\\255\\255\\255\\255\\255\\255\\255\\079\\001\\066\\001\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\066\\001\\255\\255\\066\\001\\066\\001\\\n \\066\\001\\066\\001\\066\\001\\066\\001\\066\\001\\066\\001\\066\\001\\066\\001\\\n \\066\\001\\255\\255\\255\\255\\066\\001\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\242\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\066\\001\\112\\001\\255\\255\\112\\001\\255\\255\\066\\001\\112\\001\\112\\001\\\n \\112\\001\\112\\001\\112\\001\\112\\001\\112\\001\\112\\001\\112\\001\\112\\001\\\n \\255\\255\\255\\255\\066\\001\\114\\001\\114\\001\\114\\001\\114\\001\\114\\001\\\n \\114\\001\\114\\001\\114\\001\\114\\001\\114\\001\\066\\001\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\066\\001\\255\\255\\255\\255\\\n \\114\\001\\255\\255\\255\\255\\066\\001\\255\\255\\255\\255\\115\\001\\255\\255\\\n \\115\\001\\255\\255\\066\\001\\115\\001\\115\\001\\115\\001\\115\\001\\115\\001\\\n \\115\\001\\115\\001\\115\\001\\115\\001\\115\\001\\116\\001\\116\\001\\116\\001\\\n \\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\255\\255\\\n \\114\\001\\117\\001\\117\\001\\117\\001\\117\\001\\117\\001\\117\\001\\117\\001\\\n \\117\\001\\117\\001\\117\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\\n \\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\119\\001\\119\\001\\119\\001\\\n \\119\\001\\119\\001\\119\\001\\119\\001\\119\\001\\119\\001\\119\\001\\255\\255\\\n \\126\\001\\127\\001\\127\\001\\127\\001\\127\\001\\127\\001\\127\\001\\127\\001\\\n \\127\\001\\127\\001\\127\\001\\255\\255\\255\\255\\126\\001\\255\\255\\255\\255\\\n \\255\\255\\129\\001\\127\\001\\127\\001\\127\\001\\127\\001\\127\\001\\127\\001\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\129\\001\\255\\255\\\n \\255\\255\\155\\001\\255\\255\\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\\n \\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\127\\001\\127\\001\\127\\001\\127\\001\\127\\001\\127\\001\\\n \\155\\001\\255\\255\\126\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\126\\001\\255\\255\\255\\255\\255\\255\\126\\001\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\129\\001\\126\\001\\255\\255\\255\\255\\066\\001\\\n \\126\\001\\129\\001\\126\\001\\126\\001\\255\\255\\129\\001\\255\\255\\255\\255\\\n \\155\\001\\255\\255\\255\\255\\255\\255\\255\\255\\129\\001\\255\\255\\255\\255\\\n \\255\\255\\129\\001\\255\\255\\129\\001\\129\\001\\130\\001\\130\\001\\130\\001\\\n \\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\130\\001\\130\\001\\\n \\130\\001\\130\\001\\130\\001\\130\\001\\131\\001\\131\\001\\131\\001\\131\\001\\\n \\131\\001\\131\\001\\131\\001\\131\\001\\131\\001\\131\\001\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\131\\001\\131\\001\\131\\001\\\n \\131\\001\\131\\001\\131\\001\\255\\255\\255\\255\\255\\255\\130\\001\\130\\001\\\n \\130\\001\\130\\001\\130\\001\\130\\001\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\132\\001\\132\\001\\132\\001\\132\\001\\132\\001\\132\\001\\\n \\132\\001\\132\\001\\132\\001\\132\\001\\255\\255\\131\\001\\131\\001\\131\\001\\\n \\131\\001\\131\\001\\131\\001\\132\\001\\132\\001\\132\\001\\132\\001\\132\\001\\\n \\132\\001\\184\\001\\138\\001\\184\\001\\255\\255\\255\\255\\184\\001\\184\\001\\\n \\184\\001\\184\\001\\184\\001\\184\\001\\184\\001\\184\\001\\184\\001\\184\\001\\\n \\185\\001\\185\\001\\185\\001\\185\\001\\185\\001\\185\\001\\185\\001\\185\\001\\\n \\185\\001\\185\\001\\255\\255\\132\\001\\132\\001\\132\\001\\132\\001\\132\\001\\\n \\132\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\\n \\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\\n \\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\\n \\138\\001\\138\\001\\138\\001\\255\\255\\255\\255\\255\\255\\255\\255\\138\\001\\\n \\255\\255\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\\n \\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\\n \\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\\n \\138\\001\\138\\001\\138\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\141\\001\\255\\255\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\143\\001\\143\\001\\\n \\255\\255\\255\\255\\143\\001\\156\\001\\156\\001\\156\\001\\156\\001\\156\\001\\\n \\156\\001\\156\\001\\156\\001\\156\\001\\156\\001\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\198\\001\\143\\001\\255\\255\\143\\001\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\156\\001\\143\\001\\255\\255\\255\\255\\\n \\255\\255\\198\\001\\143\\001\\255\\255\\143\\001\\143\\001\\143\\001\\143\\001\\\n \\143\\001\\143\\001\\143\\001\\143\\001\\143\\001\\143\\001\\143\\001\\255\\255\\\n \\255\\255\\143\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\138\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\143\\001\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\143\\001\\186\\001\\186\\001\\186\\001\\186\\001\\\n \\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\198\\001\\255\\255\\\n \\143\\001\\255\\255\\255\\255\\255\\255\\198\\001\\255\\255\\255\\255\\255\\255\\\n \\198\\001\\186\\001\\255\\255\\143\\001\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\198\\001\\255\\255\\255\\255\\143\\001\\198\\001\\255\\255\\198\\001\\198\\001\\\n \\255\\255\\143\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\143\\001\\255\\255\\255\\255\\255\\255\\255\\255\\187\\001\\255\\255\\187\\001\\\n \\255\\255\\186\\001\\187\\001\\187\\001\\187\\001\\187\\001\\187\\001\\187\\001\\\n \\187\\001\\187\\001\\187\\001\\187\\001\\188\\001\\188\\001\\188\\001\\188\\001\\\n \\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\189\\001\\189\\001\\\n \\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\\n \\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\\n \\190\\001\\190\\001\\191\\001\\191\\001\\191\\001\\191\\001\\191\\001\\191\\001\\\n \\191\\001\\191\\001\\191\\001\\191\\001\\199\\001\\199\\001\\199\\001\\199\\001\\\n \\199\\001\\199\\001\\199\\001\\199\\001\\199\\001\\199\\001\\201\\001\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\199\\001\\199\\001\\199\\001\\\n \\199\\001\\199\\001\\199\\001\\201\\001\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\199\\001\\199\\001\\199\\001\\\n \\199\\001\\199\\001\\199\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\201\\001\\255\\255\\255\\255\\255\\255\\255\\255\\143\\001\\201\\001\\255\\255\\\n \\255\\255\\255\\255\\201\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\201\\001\\255\\255\\255\\255\\255\\255\\201\\001\\255\\255\\\n \\201\\001\\201\\001\\202\\001\\202\\001\\202\\001\\202\\001\\202\\001\\202\\001\\\n \\202\\001\\202\\001\\202\\001\\202\\001\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\202\\001\\202\\001\\202\\001\\202\\001\\202\\001\\\n \\202\\001\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\\n \\203\\001\\203\\001\\203\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\\n \\255\\255\\255\\255\\255\\255\\202\\001\\202\\001\\202\\001\\202\\001\\202\\001\\\n \\202\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\204\\001\\\n \\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\\n \\204\\001\\255\\255\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\\n \\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\255\\255\\210\\001\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\210\\001\\210\\001\\\n \\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\\n \\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\\n \\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\210\\001\\255\\255\\210\\001\\210\\001\\\n \\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\\n \\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\\n \\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\255\\255\\255\\255\\255\\255\\255\\255\\213\\001\\\n \\255\\255\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\210\\001\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\";\n Lexing.lex_base_code =\n \"\";\n Lexing.lex_backtrk_code =\n \"\";\n Lexing.lex_default_code =\n \"\";\n Lexing.lex_trans_code =\n \"\";\n Lexing.lex_check_code =\n \"\";\n Lexing.lex_code =\n \"\";\n}\n\nlet rec read_json v lexbuf =\n __ocaml_lex_read_json_rec v lexbuf 0\nand __ocaml_lex_read_json_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 188 \"lib/read.mll\"\n \n# 188 \"lib/read.mll\"\n ( `Bool true )\n\n# 1032 \"lib/read.ml\"\n\n \n# 1033 \"lib/read.ml\"\n | 1 ->\n\n# 189 \"lib/read.mll\"\n \n# 189 \"lib/read.mll\"\n ( `Bool false )\n\n# 1037 \"lib/read.ml\"\n\n \n# 1038 \"lib/read.ml\"\n | 2 ->\n\n# 190 \"lib/read.mll\"\n \n# 190 \"lib/read.mll\"\n ( `Null )\n\n# 1042 \"lib/read.ml\"\n\n \n# 1043 \"lib/read.ml\"\n | 3 ->\n\n# 191 \"lib/read.mll\"\n \n# 191 \"lib/read.mll\"\n (\n \n# 195 \"lib/read.mll\"\n `Floatlit \"NaN\"\n \n# 197 \"lib/read.mll\"\n )\n\n# 1053 \"lib/read.ml\"\n\n \n# 1054 \"lib/read.ml\"\n | 4 ->\n\n# 198 \"lib/read.mll\"\n \n# 198 \"lib/read.mll\"\n (\n \n# 202 \"lib/read.mll\"\n `Floatlit \"Infinity\"\n \n# 204 \"lib/read.mll\"\n )\n\n# 1064 \"lib/read.ml\"\n\n \n# 1065 \"lib/read.ml\"\n | 5 ->\n\n# 205 \"lib/read.mll\"\n \n# 205 \"lib/read.mll\"\n (\n \n# 209 \"lib/read.mll\"\n `Floatlit \"-Infinity\"\n \n# 211 \"lib/read.mll\"\n )\n\n# 1075 \"lib/read.ml\"\n\n \n# 1076 \"lib/read.ml\"\n | 6 ->\n\n# 212 \"lib/read.mll\"\n \n# 212 \"lib/read.mll\"\n (\n \n# 217 \"lib/read.mll\"\n `Stringlit (finish_stringlit v lexbuf)\n \n# 219 \"lib/read.mll\"\n )\n\n# 1087 \"lib/read.ml\"\n\n \n# 1088 \"lib/read.ml\"\n | 7 ->\n\n# 220 \"lib/read.mll\"\n \n# 220 \"lib/read.mll\"\n ( make_positive_int v lexbuf )\n\n# 1092 \"lib/read.ml\"\n\n \n# 1093 \"lib/read.ml\"\n | 8 ->\n\n# 221 \"lib/read.mll\"\n \n# 221 \"lib/read.mll\"\n ( make_negative_int v lexbuf )\n\n# 1097 \"lib/read.ml\"\n\n \n# 1098 \"lib/read.ml\"\n | 9 ->\n\n# 222 \"lib/read.mll\"\n \n# 222 \"lib/read.mll\"\n (\n \n# 226 \"lib/read.mll\"\n `Floatlit (lexeme lexbuf)\n \n# 228 \"lib/read.mll\"\n )\n\n# 1108 \"lib/read.ml\"\n\n \n# 1109 \"lib/read.ml\"\n | 10 ->\n\n# 230 \"lib/read.mll\"\n \n# 230 \"lib/read.mll\"\n ( let acc = ref [] in\n try\n read_space v lexbuf;\n read_object_end lexbuf;\n let field_name = read_ident v lexbuf in\n read_space v lexbuf;\n read_colon v lexbuf;\n read_space v lexbuf;\n acc := (field_name, read_json v lexbuf) :: !acc;\n while true do\n read_space v lexbuf;\n read_object_sep v lexbuf;\n read_space v lexbuf;\n let field_name = read_ident v lexbuf in\n read_space v lexbuf;\n read_colon v lexbuf;\n read_space v lexbuf;\n acc := (field_name, read_json v lexbuf) :: !acc;\n done;\n assert false\n with End_of_object ->\n `Assoc (List.rev !acc)\n )\n\n# 1135 \"lib/read.ml\"\n\n \n# 1136 \"lib/read.ml\"\n | 11 ->\n\n# 254 \"lib/read.mll\"\n \n# 254 \"lib/read.mll\"\n ( let acc = ref [] in\n try\n read_space v lexbuf;\n read_array_end lexbuf;\n acc := read_json v lexbuf :: !acc;\n while true do\n read_space v lexbuf;\n read_array_sep v lexbuf;\n read_space v lexbuf;\n acc := read_json v lexbuf :: !acc;\n done;\n assert false\n with End_of_array ->\n `List (List.rev !acc)\n )\n\n# 1154 \"lib/read.ml\"\n\n \n# 1155 \"lib/read.ml\"\n | 12 ->\n\n# 270 \"lib/read.mll\"\n \n# 270 \"lib/read.mll\"\n (\n \n# 272 \"lib/read.mll\"\n let acc = ref [] in\n try\n read_space v lexbuf;\n read_tuple_end lexbuf;\n acc := read_json v lexbuf :: !acc;\n while true do\n read_space v lexbuf;\n read_tuple_sep v lexbuf;\n read_space v lexbuf;\n acc := read_json v lexbuf :: !acc;\n done;\n assert false\n with End_of_tuple ->\n `Tuple (List.rev !acc)\n \n# 289 \"lib/read.mll\"\n )\n\n# 1178 \"lib/read.ml\"\n\n \n# 1179 \"lib/read.ml\"\n | 13 ->\n\n# 291 \"lib/read.mll\"\n \n# 291 \"lib/read.mll\"\n (\n \n# 293 \"lib/read.mll\"\n read_space v lexbuf;\n let cons = read_ident v lexbuf in\n read_space v lexbuf;\n `Variant (cons, finish_variant v lexbuf)\n \n# 300 \"lib/read.mll\"\n )\n\n# 1192 \"lib/read.ml\"\n\n \n# 1193 \"lib/read.ml\"\n | 14 ->\n\n# 302 \"lib/read.mll\"\n \n# 302 \"lib/read.mll\"\n ( read_json v lexbuf )\n\n# 1197 \"lib/read.ml\"\n\n \n# 1198 \"lib/read.ml\"\n | 15 ->\n\n# 303 \"lib/read.mll\"\n \n# 303 \"lib/read.mll\"\n ( finish_comment v lexbuf; read_json v lexbuf )\n\n# 1202 \"lib/read.ml\"\n\n \n# 1203 \"lib/read.ml\"\n | 16 ->\n\n# 304 \"lib/read.mll\"\n \n# 304 \"lib/read.mll\"\n ( newline v lexbuf; read_json v lexbuf )\n\n# 1207 \"lib/read.ml\"\n\n \n# 1208 \"lib/read.ml\"\n | 17 ->\n\n# 305 \"lib/read.mll\"\n \n# 305 \"lib/read.mll\"\n ( read_json v lexbuf )\n\n# 1212 \"lib/read.ml\"\n\n \n# 1213 \"lib/read.ml\"\n | 18 ->\n\n# 306 \"lib/read.mll\"\n \n# 306 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1217 \"lib/read.ml\"\n\n \n# 1218 \"lib/read.ml\"\n | 19 ->\n\n# 307 \"lib/read.mll\"\n \n# 307 \"lib/read.mll\"\n ( long_error \"Invalid token\" v lexbuf )\n\n# 1222 \"lib/read.ml\"\n\n \n# 1223 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_json_rec v lexbuf __ocaml_lex_state\n\nand finish_string v lexbuf =\n __ocaml_lex_finish_string_rec v lexbuf 58\nand __ocaml_lex_finish_string_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 311 \"lib/read.mll\"\n \n# 311 \"lib/read.mll\"\n ( Bi_outbuf.contents v.buf )\n\n# 1234 \"lib/read.ml\"\n\n \n# 1235 \"lib/read.ml\"\n | 1 ->\n\n# 312 \"lib/read.mll\"\n \n# 312 \"lib/read.mll\"\n ( finish_escaped_char v lexbuf;\n finish_string v lexbuf )\n\n# 1240 \"lib/read.ml\"\n\n \n# 1241 \"lib/read.ml\"\n | 2 ->\n\n# 314 \"lib/read.mll\"\n \n# 314 \"lib/read.mll\"\n ( add_lexeme v.buf lexbuf;\n finish_string v lexbuf )\n\n# 1246 \"lib/read.ml\"\n\n \n# 1247 \"lib/read.ml\"\n | 3 ->\n\n# 316 \"lib/read.mll\"\n \n# 316 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1251 \"lib/read.ml\"\n\n \n# 1252 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_string_rec v lexbuf __ocaml_lex_state\n\nand map_string v f lexbuf =\n __ocaml_lex_map_string_rec v f lexbuf 63\nand __ocaml_lex_map_string_rec v f lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 319 \"lib/read.mll\"\n \n# 319 \"lib/read.mll\"\n ( let b = v.buf in\n f (Bytes.to_string b.Bi_outbuf.o_s) 0 b.Bi_outbuf.o_len )\n\n# 1264 \"lib/read.ml\"\n\n \n# 1265 \"lib/read.ml\"\n | 1 ->\n\n# 321 \"lib/read.mll\"\n \n# 321 \"lib/read.mll\"\n ( finish_escaped_char v lexbuf;\n map_string v f lexbuf )\n\n# 1270 \"lib/read.ml\"\n\n \n# 1271 \"lib/read.ml\"\n | 2 ->\n\n# 323 \"lib/read.mll\"\n \n# 323 \"lib/read.mll\"\n ( add_lexeme v.buf lexbuf;\n map_string v f lexbuf )\n\n# 1276 \"lib/read.ml\"\n\n \n# 1277 \"lib/read.ml\"\n | 3 ->\n\n# 325 \"lib/read.mll\"\n \n# 325 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1281 \"lib/read.ml\"\n\n \n# 1282 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_map_string_rec v f lexbuf __ocaml_lex_state\n\nand finish_escaped_char v lexbuf =\n __ocaml_lex_finish_escaped_char_rec v lexbuf 68\nand __ocaml_lex_finish_escaped_char_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\nlet\n\n# 330 \"lib/read.mll\"\n \n# 330 \"lib/read.mll\"\n c\n\n# 1294 \"lib/read.ml\"\n# 1294 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf lexbuf.Lexing.lex_start_pos in\n\n# 330 \"lib/read.mll\"\n \n# 330 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf c )\n\n# 1298 \"lib/read.ml\"\n\n \n# 1299 \"lib/read.ml\"\n | 1 ->\n\n# 331 \"lib/read.mll\"\n \n# 331 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\\b' )\n\n# 1303 \"lib/read.ml\"\n\n \n# 1304 \"lib/read.ml\"\n | 2 ->\n\n# 332 \"lib/read.mll\"\n \n# 332 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\\012' )\n\n# 1308 \"lib/read.ml\"\n\n \n# 1309 \"lib/read.ml\"\n | 3 ->\n\n# 333 \"lib/read.mll\"\n \n# 333 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\\n' )\n\n# 1313 \"lib/read.ml\"\n\n \n# 1314 \"lib/read.ml\"\n | 4 ->\n\n# 334 \"lib/read.mll\"\n \n# 334 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\\r' )\n\n# 1318 \"lib/read.ml\"\n\n \n# 1319 \"lib/read.ml\"\n | 5 ->\n\n# 335 \"lib/read.mll\"\n \n# 335 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\\t' )\n\n# 1323 \"lib/read.ml\"\n\n \n# 1324 \"lib/read.ml\"\n | 6 ->\nlet\n\n# 336 \"lib/read.mll\"\n \n# 336 \"lib/read.mll\"\n a\n\n# 1329 \"lib/read.ml\"\n# 1329 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 1)\nand\n\n# 336 \"lib/read.mll\"\n \n# 336 \"lib/read.mll\"\n b\n\n# 1334 \"lib/read.ml\"\n# 1334 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 2)\nand\n\n# 336 \"lib/read.mll\"\n \n# 336 \"lib/read.mll\"\n c\n\n# 1339 \"lib/read.ml\"\n# 1339 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 3)\nand\n\n# 336 \"lib/read.mll\"\n \n# 336 \"lib/read.mll\"\n d\n\n# 1344 \"lib/read.ml\"\n# 1344 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 4) in\n\n# 337 \"lib/read.mll\"\n \n# 337 \"lib/read.mll\"\n ( let x =\n (hex a lsl 12) lor (hex b lsl 8) lor (hex c lsl 4) lor hex d\n in\n if x >= 0xD800 && x <= 0xDBFF then\n finish_surrogate_pair v x lexbuf\n else\n utf8_of_code v.buf x\n )\n\n# 1355 \"lib/read.ml\"\n\n \n# 1356 \"lib/read.ml\"\n | 7 ->\n\n# 345 \"lib/read.mll\"\n \n# 345 \"lib/read.mll\"\n ( long_error \"Invalid escape sequence\" v lexbuf )\n\n# 1360 \"lib/read.ml\"\n\n \n# 1361 \"lib/read.ml\"\n | 8 ->\n\n# 346 \"lib/read.mll\"\n \n# 346 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1365 \"lib/read.ml\"\n\n \n# 1366 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_escaped_char_rec v lexbuf __ocaml_lex_state\n\nand finish_surrogate_pair v x lexbuf =\n __ocaml_lex_finish_surrogate_pair_rec v x lexbuf 82\nand __ocaml_lex_finish_surrogate_pair_rec v x lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\nlet\n\n# 349 \"lib/read.mll\"\n \n# 349 \"lib/read.mll\"\n a\n\n# 1378 \"lib/read.ml\"\n# 1378 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 2)\nand\n\n# 349 \"lib/read.mll\"\n \n# 349 \"lib/read.mll\"\n b\n\n# 1383 \"lib/read.ml\"\n# 1383 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 3)\nand\n\n# 349 \"lib/read.mll\"\n \n# 349 \"lib/read.mll\"\n c\n\n# 1388 \"lib/read.ml\"\n# 1388 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 4)\nand\n\n# 349 \"lib/read.mll\"\n \n# 349 \"lib/read.mll\"\n d\n\n# 1393 \"lib/read.ml\"\n# 1393 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 5) in\n\n# 350 \"lib/read.mll\"\n \n# 350 \"lib/read.mll\"\n ( let y =\n (hex a lsl 12) lor (hex b lsl 8) lor (hex c lsl 4) lor hex d\n in\n if y >= 0xDC00 && y <= 0xDFFF then\n utf8_of_surrogate_pair v.buf x y\n else\n long_error \"Invalid low surrogate for code point beyond U+FFFF\"\n v lexbuf\n )\n\n# 1405 \"lib/read.ml\"\n\n \n# 1406 \"lib/read.ml\"\n | 1 ->\n\n# 359 \"lib/read.mll\"\n \n# 359 \"lib/read.mll\"\n ( long_error \"Missing escape sequence representing low surrogate \\\n for code point beyond U+FFFF\" v lexbuf )\n\n# 1411 \"lib/read.ml\"\n\n \n# 1412 \"lib/read.ml\"\n | 2 ->\n\n# 361 \"lib/read.mll\"\n \n# 361 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1416 \"lib/read.ml\"\n\n \n# 1417 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_surrogate_pair_rec v x lexbuf __ocaml_lex_state\n\nand finish_stringlit v lexbuf =\n __ocaml_lex_finish_stringlit_rec v lexbuf 91\nand __ocaml_lex_finish_stringlit_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 366 \"lib/read.mll\"\n \n# 366 \"lib/read.mll\"\n ( let len = lexbuf.lex_curr_pos - lexbuf.lex_start_pos in\n let s = Bytes.create (len+1) in\n Bytes.set s 0 '\"';\n Bytes.blit lexbuf.lex_buffer lexbuf.lex_start_pos s 1 len;\n Bytes.to_string s\n )\n\n# 1433 \"lib/read.ml\"\n\n \n# 1434 \"lib/read.ml\"\n | 1 ->\n\n# 372 \"lib/read.mll\"\n \n# 372 \"lib/read.mll\"\n ( long_error \"Invalid string literal\" v lexbuf )\n\n# 1438 \"lib/read.ml\"\n\n \n# 1439 \"lib/read.ml\"\n | 2 ->\n\n# 373 \"lib/read.mll\"\n \n# 373 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1443 \"lib/read.ml\"\n\n \n# 1444 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_stringlit_rec v lexbuf __ocaml_lex_state\n\nand finish_variant v lexbuf =\n __ocaml_lex_finish_variant_rec v lexbuf 102\nand __ocaml_lex_finish_variant_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 376 \"lib/read.mll\"\n \n# 376 \"lib/read.mll\"\n ( let x = read_json v lexbuf in\n read_space v lexbuf;\n read_gt v lexbuf;\n Some x )\n\n# 1458 \"lib/read.ml\"\n\n \n# 1459 \"lib/read.ml\"\n | 1 ->\n\n# 380 \"lib/read.mll\"\n \n# 380 \"lib/read.mll\"\n ( None )\n\n# 1463 \"lib/read.ml\"\n\n \n# 1464 \"lib/read.ml\"\n | 2 ->\n\n# 381 \"lib/read.mll\"\n \n# 381 \"lib/read.mll\"\n ( long_error \"Expected ':' or '>' but found\" v lexbuf )\n\n# 1468 \"lib/read.ml\"\n\n \n# 1469 \"lib/read.ml\"\n | 3 ->\n\n# 382 \"lib/read.mll\"\n \n# 382 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1473 \"lib/read.ml\"\n\n \n# 1474 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_variant_rec v lexbuf __ocaml_lex_state\n\nand read_lt v lexbuf =\n __ocaml_lex_read_lt_rec v lexbuf 107\nand __ocaml_lex_read_lt_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 385 \"lib/read.mll\"\n \n# 385 \"lib/read.mll\"\n ( () )\n\n# 1485 \"lib/read.ml\"\n\n \n# 1486 \"lib/read.ml\"\n | 1 ->\n\n# 386 \"lib/read.mll\"\n \n# 386 \"lib/read.mll\"\n ( long_error \"Expected '<' but found\" v lexbuf )\n\n# 1490 \"lib/read.ml\"\n\n \n# 1491 \"lib/read.ml\"\n | 2 ->\n\n# 387 \"lib/read.mll\"\n \n# 387 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1495 \"lib/read.ml\"\n\n \n# 1496 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_lt_rec v lexbuf __ocaml_lex_state\n\nand read_gt v lexbuf =\n __ocaml_lex_read_gt_rec v lexbuf 111\nand __ocaml_lex_read_gt_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 390 \"lib/read.mll\"\n \n# 390 \"lib/read.mll\"\n ( () )\n\n# 1507 \"lib/read.ml\"\n\n \n# 1508 \"lib/read.ml\"\n | 1 ->\n\n# 391 \"lib/read.mll\"\n \n# 391 \"lib/read.mll\"\n ( long_error \"Expected '>' but found\" v lexbuf )\n\n# 1512 \"lib/read.ml\"\n\n \n# 1513 \"lib/read.ml\"\n | 2 ->\n\n# 392 \"lib/read.mll\"\n \n# 392 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1517 \"lib/read.ml\"\n\n \n# 1518 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_gt_rec v lexbuf __ocaml_lex_state\n\nand read_comma v lexbuf =\n __ocaml_lex_read_comma_rec v lexbuf 115\nand __ocaml_lex_read_comma_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 395 \"lib/read.mll\"\n \n# 395 \"lib/read.mll\"\n ( () )\n\n# 1529 \"lib/read.ml\"\n\n \n# 1530 \"lib/read.ml\"\n | 1 ->\n\n# 396 \"lib/read.mll\"\n \n# 396 \"lib/read.mll\"\n ( long_error \"Expected ',' but found\" v lexbuf )\n\n# 1534 \"lib/read.ml\"\n\n \n# 1535 \"lib/read.ml\"\n | 2 ->\n\n# 397 \"lib/read.mll\"\n \n# 397 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1539 \"lib/read.ml\"\n\n \n# 1540 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_comma_rec v lexbuf __ocaml_lex_state\n\nand start_any_variant v lexbuf =\n __ocaml_lex_start_any_variant_rec v lexbuf 119\nand __ocaml_lex_start_any_variant_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 400 \"lib/read.mll\"\n \n# 400 \"lib/read.mll\"\n ( `Edgy_bracket )\n\n# 1551 \"lib/read.ml\"\n\n \n# 1552 \"lib/read.ml\"\n | 1 ->\n\n# 401 \"lib/read.mll\"\n \n# 401 \"lib/read.mll\"\n ( Bi_outbuf.clear v.buf;\n `Double_quote )\n\n# 1557 \"lib/read.ml\"\n\n \n# 1558 \"lib/read.ml\"\n | 2 ->\n\n# 403 \"lib/read.mll\"\n \n# 403 \"lib/read.mll\"\n ( `Square_bracket )\n\n# 1562 \"lib/read.ml\"\n\n \n# 1563 \"lib/read.ml\"\n | 3 ->\n\n# 404 \"lib/read.mll\"\n \n# 404 \"lib/read.mll\"\n ( long_error \"Expected '<', '\\\"' or '[' but found\" v lexbuf )\n\n# 1567 \"lib/read.ml\"\n\n \n# 1568 \"lib/read.ml\"\n | 4 ->\n\n# 405 \"lib/read.mll\"\n \n# 405 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1572 \"lib/read.ml\"\n\n \n# 1573 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_start_any_variant_rec v lexbuf __ocaml_lex_state\n\nand finish_comment v lexbuf =\n __ocaml_lex_finish_comment_rec v lexbuf 125\nand __ocaml_lex_finish_comment_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 408 \"lib/read.mll\"\n \n# 408 \"lib/read.mll\"\n ( () )\n\n# 1584 \"lib/read.ml\"\n\n \n# 1585 \"lib/read.ml\"\n | 1 ->\n\n# 409 \"lib/read.mll\"\n \n# 409 \"lib/read.mll\"\n ( long_error \"Unterminated comment\" v lexbuf )\n\n# 1589 \"lib/read.ml\"\n\n \n# 1590 \"lib/read.ml\"\n | 2 ->\n\n# 410 \"lib/read.mll\"\n \n# 410 \"lib/read.mll\"\n ( newline v lexbuf; finish_comment v lexbuf )\n\n# 1594 \"lib/read.ml\"\n\n \n# 1595 \"lib/read.ml\"\n | 3 ->\n\n# 411 \"lib/read.mll\"\n \n# 411 \"lib/read.mll\"\n ( finish_comment v lexbuf )\n\n# 1599 \"lib/read.ml\"\n\n \n# 1600 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_comment_rec v lexbuf __ocaml_lex_state\n\nand read_eof lexbuf =\n __ocaml_lex_read_eof_rec lexbuf 131\nand __ocaml_lex_read_eof_rec lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 419 \"lib/read.mll\"\n \n# 419 \"lib/read.mll\"\n ( true )\n\n# 1611 \"lib/read.ml\"\n\n \n# 1612 \"lib/read.ml\"\n | 1 ->\n\n# 420 \"lib/read.mll\"\n \n# 420 \"lib/read.mll\"\n ( false )\n\n# 1616 \"lib/read.ml\"\n\n \n# 1617 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_eof_rec lexbuf __ocaml_lex_state\n\nand read_space v lexbuf =\n __ocaml_lex_read_space_rec v lexbuf 133\nand __ocaml_lex_read_space_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 423 \"lib/read.mll\"\n \n# 423 \"lib/read.mll\"\n ( newline v lexbuf; read_space v lexbuf )\n\n# 1628 \"lib/read.ml\"\n\n \n# 1629 \"lib/read.ml\"\n | 1 ->\n\n# 424 \"lib/read.mll\"\n \n# 424 \"lib/read.mll\"\n ( finish_comment v lexbuf; read_space v lexbuf )\n\n# 1633 \"lib/read.ml\"\n\n \n# 1634 \"lib/read.ml\"\n | 2 ->\n\n# 425 \"lib/read.mll\"\n \n# 425 \"lib/read.mll\"\n ( newline v lexbuf; read_space v lexbuf )\n\n# 1638 \"lib/read.ml\"\n\n \n# 1639 \"lib/read.ml\"\n | 3 ->\n\n# 426 \"lib/read.mll\"\n \n# 426 \"lib/read.mll\"\n ( read_space v lexbuf )\n\n# 1643 \"lib/read.ml\"\n\n \n# 1644 \"lib/read.ml\"\n | 4 ->\n\n# 427 \"lib/read.mll\"\n \n# 427 \"lib/read.mll\"\n ( () )\n\n# 1648 \"lib/read.ml\"\n\n \n# 1649 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_space_rec v lexbuf __ocaml_lex_state\n\nand read_null v lexbuf =\n __ocaml_lex_read_null_rec v lexbuf 140\nand __ocaml_lex_read_null_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 430 \"lib/read.mll\"\n \n# 430 \"lib/read.mll\"\n ( () )\n\n# 1660 \"lib/read.ml\"\n\n \n# 1661 \"lib/read.ml\"\n | 1 ->\n\n# 431 \"lib/read.mll\"\n \n# 431 \"lib/read.mll\"\n ( long_error \"Expected 'null' but found\" v lexbuf )\n\n# 1665 \"lib/read.ml\"\n\n \n# 1666 \"lib/read.ml\"\n | 2 ->\n\n# 432 \"lib/read.mll\"\n \n# 432 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1670 \"lib/read.ml\"\n\n \n# 1671 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_null_rec v lexbuf __ocaml_lex_state\n\nand read_null_if_possible v lexbuf =\n __ocaml_lex_read_null_if_possible_rec v lexbuf 147\nand __ocaml_lex_read_null_if_possible_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 435 \"lib/read.mll\"\n \n# 435 \"lib/read.mll\"\n ( true )\n\n# 1682 \"lib/read.ml\"\n\n \n# 1683 \"lib/read.ml\"\n | 1 ->\n\n# 436 \"lib/read.mll\"\n \n# 436 \"lib/read.mll\"\n ( false )\n\n# 1687 \"lib/read.ml\"\n\n \n# 1688 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_null_if_possible_rec v lexbuf __ocaml_lex_state\n\nand read_bool v lexbuf =\n __ocaml_lex_read_bool_rec v lexbuf 152\nand __ocaml_lex_read_bool_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 439 \"lib/read.mll\"\n \n# 439 \"lib/read.mll\"\n ( true )\n\n# 1699 \"lib/read.ml\"\n\n \n# 1700 \"lib/read.ml\"\n | 1 ->\n\n# 440 \"lib/read.mll\"\n \n# 440 \"lib/read.mll\"\n ( false )\n\n# 1704 \"lib/read.ml\"\n\n \n# 1705 \"lib/read.ml\"\n | 2 ->\n\n# 443 \"lib/read.mll\"\n \n# 443 \"lib/read.mll\"\n ( true )\n\n# 1709 \"lib/read.ml\"\n\n \n# 1710 \"lib/read.ml\"\n | 3 ->\n\n# 444 \"lib/read.mll\"\n \n# 444 \"lib/read.mll\"\n ( false )\n\n# 1714 \"lib/read.ml\"\n\n \n# 1715 \"lib/read.ml\"\n | 4 ->\n\n# 446 \"lib/read.mll\"\n \n# 446 \"lib/read.mll\"\n ( long_error \"Expected 'true' or 'false' but found\" v lexbuf )\n\n# 1719 \"lib/read.ml\"\n\n \n# 1720 \"lib/read.ml\"\n | 5 ->\n\n# 447 \"lib/read.mll\"\n \n# 447 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1724 \"lib/read.ml\"\n\n \n# 1725 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_bool_rec v lexbuf __ocaml_lex_state\n\nand read_int v lexbuf =\n __ocaml_lex_read_int_rec v lexbuf 176\nand __ocaml_lex_read_int_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 450 \"lib/read.mll\"\n \n# 450 \"lib/read.mll\"\n ( try extract_positive_int lexbuf\n with Int_overflow ->\n lexer_error \"Int overflow\" v lexbuf )\n\n# 1738 \"lib/read.ml\"\n\n \n# 1739 \"lib/read.ml\"\n | 1 ->\n\n# 453 \"lib/read.mll\"\n \n# 453 \"lib/read.mll\"\n ( try extract_negative_int lexbuf\n with Int_overflow ->\n lexer_error \"Int overflow\" v lexbuf )\n\n# 1745 \"lib/read.ml\"\n\n \n# 1746 \"lib/read.ml\"\n | 2 ->\n\n# 456 \"lib/read.mll\"\n \n# 456 \"lib/read.mll\"\n ( (* Support for double-quoted \"ints\" *)\n Bi_outbuf.clear v.buf;\n let s = finish_string v lexbuf in\n try\n (* Any OCaml-compliant int will pass,\n including hexadecimal and octal notations,\n and embedded underscores *)\n int_of_string s\n with _ ->\n custom_error\n \"Expected an integer but found a string that \\\n doesn't even represent an integer\"\n v lexbuf\n )\n\n# 1763 \"lib/read.ml\"\n\n \n# 1764 \"lib/read.ml\"\n | 3 ->\n\n# 470 \"lib/read.mll\"\n \n# 470 \"lib/read.mll\"\n ( long_error \"Expected integer but found\" v lexbuf )\n\n# 1768 \"lib/read.ml\"\n\n \n# 1769 \"lib/read.ml\"\n | 4 ->\n\n# 471 \"lib/read.mll\"\n \n# 471 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1773 \"lib/read.ml\"\n\n \n# 1774 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_int_rec v lexbuf __ocaml_lex_state\n\nand read_int32 v lexbuf =\n __ocaml_lex_read_int32_rec v lexbuf 185\nand __ocaml_lex_read_int32_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 474 \"lib/read.mll\"\n \n# 474 \"lib/read.mll\"\n ( try Int32.of_string (Lexing.lexeme lexbuf)\n with _ ->\n lexer_error \"Int32 overflow\" v lexbuf )\n\n# 1787 \"lib/read.ml\"\n\n \n# 1788 \"lib/read.ml\"\n | 1 ->\n\n# 477 \"lib/read.mll\"\n \n# 477 \"lib/read.mll\"\n ( (* Support for double-quoted \"ints\" *)\n Bi_outbuf.clear v.buf;\n let s = finish_string v lexbuf in\n try\n (* Any OCaml-compliant int will pass,\n including hexadecimal and octal notations,\n and embedded underscores *)\n Int32.of_string s\n with _ ->\n custom_error\n \"Expected an int32 but found a string that \\\n doesn't even represent an integer\"\n v lexbuf\n )\n\n# 1805 \"lib/read.ml\"\n\n \n# 1806 \"lib/read.ml\"\n | 2 ->\n\n# 491 \"lib/read.mll\"\n \n# 491 \"lib/read.mll\"\n ( long_error \"Expected int32 but found\" v lexbuf )\n\n# 1810 \"lib/read.ml\"\n\n \n# 1811 \"lib/read.ml\"\n | 3 ->\n\n# 492 \"lib/read.mll\"\n \n# 492 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1815 \"lib/read.ml\"\n\n \n# 1816 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_int32_rec v lexbuf __ocaml_lex_state\n\nand read_int64 v lexbuf =\n __ocaml_lex_read_int64_rec v lexbuf 192\nand __ocaml_lex_read_int64_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 495 \"lib/read.mll\"\n \n# 495 \"lib/read.mll\"\n ( try Int64.of_string (Lexing.lexeme lexbuf)\n with _ ->\n lexer_error \"Int32 overflow\" v lexbuf )\n\n# 1829 \"lib/read.ml\"\n\n \n# 1830 \"lib/read.ml\"\n | 1 ->\n\n# 498 \"lib/read.mll\"\n \n# 498 \"lib/read.mll\"\n ( (* Support for double-quoted \"ints\" *)\n Bi_outbuf.clear v.buf;\n let s = finish_string v lexbuf in\n try\n (* Any OCaml-compliant int will pass,\n including hexadecimal and octal notations,\n and embedded underscores *)\n Int64.of_string s\n with _ ->\n custom_error\n \"Expected an int64 but found a string that \\\n doesn't even represent an integer\"\n v lexbuf\n )\n\n# 1847 \"lib/read.ml\"\n\n \n# 1848 \"lib/read.ml\"\n | 2 ->\n\n# 512 \"lib/read.mll\"\n \n# 512 \"lib/read.mll\"\n ( long_error \"Expected int64 but found\" v lexbuf )\n\n# 1852 \"lib/read.ml\"\n\n \n# 1853 \"lib/read.ml\"\n | 3 ->\n\n# 513 \"lib/read.mll\"\n \n# 513 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1857 \"lib/read.ml\"\n\n \n# 1858 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_int64_rec v lexbuf __ocaml_lex_state\n\nand read_number v lexbuf =\n __ocaml_lex_read_number_rec v lexbuf 199\nand __ocaml_lex_read_number_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 516 \"lib/read.mll\"\n \n# 516 \"lib/read.mll\"\n ( nan )\n\n# 1869 \"lib/read.ml\"\n\n \n# 1870 \"lib/read.ml\"\n | 1 ->\n\n# 517 \"lib/read.mll\"\n \n# 517 \"lib/read.mll\"\n ( infinity )\n\n# 1874 \"lib/read.ml\"\n\n \n# 1875 \"lib/read.ml\"\n | 2 ->\n\n# 518 \"lib/read.mll\"\n \n# 518 \"lib/read.mll\"\n ( neg_infinity )\n\n# 1879 \"lib/read.ml\"\n\n \n# 1880 \"lib/read.ml\"\n | 3 ->\n\n# 519 \"lib/read.mll\"\n \n# 519 \"lib/read.mll\"\n ( float_of_string (lexeme lexbuf) )\n\n# 1884 \"lib/read.ml\"\n\n \n# 1885 \"lib/read.ml\"\n | 4 ->\n\n# 520 \"lib/read.mll\"\n \n# 520 \"lib/read.mll\"\n ( Bi_outbuf.clear v.buf;\n let s = finish_string v lexbuf in\n try\n (* Any OCaml-compliant float will pass,\n including hexadecimal and octal notations,\n and embedded underscores. *)\n float_of_string s\n with _ ->\n match s with\n \"NaN\" -> nan\n | \"Infinity\" -> infinity\n | \"-Infinity\" -> neg_infinity\n | _ ->\n custom_error\n \"Expected a number but found a string that \\\n doesn't even represent a number\"\n v lexbuf\n )\n\n# 1906 \"lib/read.ml\"\n\n \n# 1907 \"lib/read.ml\"\n | 5 ->\n\n# 538 \"lib/read.mll\"\n \n# 538 \"lib/read.mll\"\n ( long_error \"Expected number but found\" v lexbuf )\n\n# 1911 \"lib/read.ml\"\n\n \n# 1912 \"lib/read.ml\"\n | 6 ->\n\n# 539 \"lib/read.mll\"\n \n# 539 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1916 \"lib/read.ml\"\n\n \n# 1917 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_number_rec v lexbuf __ocaml_lex_state\n\nand read_string v lexbuf =\n __ocaml_lex_read_string_rec v lexbuf 233\nand __ocaml_lex_read_string_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 542 \"lib/read.mll\"\n \n# 542 \"lib/read.mll\"\n ( Bi_outbuf.clear v.buf;\n finish_string v lexbuf )\n\n# 1929 \"lib/read.ml\"\n\n \n# 1930 \"lib/read.ml\"\n | 1 ->\n\n# 544 \"lib/read.mll\"\n \n# 544 \"lib/read.mll\"\n ( long_error \"Expected '\\\"' but found\" v lexbuf )\n\n# 1934 \"lib/read.ml\"\n\n \n# 1935 \"lib/read.ml\"\n | 2 ->\n\n# 545 \"lib/read.mll\"\n \n# 545 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1939 \"lib/read.ml\"\n\n \n# 1940 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_string_rec v lexbuf __ocaml_lex_state\n\nand read_ident v lexbuf =\n __ocaml_lex_read_ident_rec v lexbuf 237\nand __ocaml_lex_read_ident_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 548 \"lib/read.mll\"\n \n# 548 \"lib/read.mll\"\n ( Bi_outbuf.clear v.buf;\n finish_string v lexbuf )\n\n# 1952 \"lib/read.ml\"\n\n \n# 1953 \"lib/read.ml\"\n | 1 ->\nlet\n\n# 550 \"lib/read.mll\"\n \n# 550 \"lib/read.mll\"\n s\n\n# 1958 \"lib/read.ml\"\n# 1958 \"lib/read.ml\"\n= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos lexbuf.Lexing.lex_curr_pos in\n\n# 551 \"lib/read.mll\"\n \n# 551 \"lib/read.mll\"\n ( s )\n\n# 1962 \"lib/read.ml\"\n\n \n# 1963 \"lib/read.ml\"\n | 2 ->\n\n# 552 \"lib/read.mll\"\n \n# 552 \"lib/read.mll\"\n ( long_error \"Expected string or identifier but found\" v lexbuf )\n\n# 1967 \"lib/read.ml\"\n\n \n# 1968 \"lib/read.ml\"\n | 3 ->\n\n# 553 \"lib/read.mll\"\n \n# 553 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 1972 \"lib/read.ml\"\n\n \n# 1973 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_ident_rec v lexbuf __ocaml_lex_state\n\nand map_ident v f lexbuf =\n __ocaml_lex_map_ident_rec v f lexbuf 242\nand __ocaml_lex_map_ident_rec v f lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 556 \"lib/read.mll\"\n \n# 556 \"lib/read.mll\"\n ( Bi_outbuf.clear v.buf;\n map_string v f lexbuf )\n\n# 1985 \"lib/read.ml\"\n\n \n# 1986 \"lib/read.ml\"\n | 1 ->\n\n# 559 \"lib/read.mll\"\n \n# 559 \"lib/read.mll\"\n ( map_lexeme f lexbuf )\n\n# 1990 \"lib/read.ml\"\n\n \n# 1991 \"lib/read.ml\"\n | 2 ->\n\n# 560 \"lib/read.mll\"\n \n# 560 \"lib/read.mll\"\n ( long_error \"Expected string or identifier but found\" v lexbuf )\n\n# 1995 \"lib/read.ml\"\n\n \n# 1996 \"lib/read.ml\"\n | 3 ->\n\n# 561 \"lib/read.mll\"\n \n# 561 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2000 \"lib/read.ml\"\n\n \n# 2001 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_map_ident_rec v f lexbuf __ocaml_lex_state\n\nand read_sequence read_cell init_acc v lexbuf =\n __ocaml_lex_read_sequence_rec read_cell init_acc v lexbuf 247\nand __ocaml_lex_read_sequence_rec read_cell init_acc v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 564 \"lib/read.mll\"\n \n# 564 \"lib/read.mll\"\n ( let acc = ref init_acc in\n try\n read_space v lexbuf;\n read_array_end lexbuf;\n acc := read_cell !acc v lexbuf;\n while true do\n read_space v lexbuf;\n read_array_sep v lexbuf;\n read_space v lexbuf;\n acc := read_cell !acc v lexbuf;\n done;\n assert false\n with End_of_array ->\n !acc\n )\n\n# 2026 \"lib/read.ml\"\n\n \n# 2027 \"lib/read.ml\"\n | 1 ->\n\n# 579 \"lib/read.mll\"\n \n# 579 \"lib/read.mll\"\n ( long_error \"Expected '[' but found\" v lexbuf )\n\n# 2031 \"lib/read.ml\"\n\n \n# 2032 \"lib/read.ml\"\n | 2 ->\n\n# 580 \"lib/read.mll\"\n \n# 580 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2036 \"lib/read.ml\"\n\n \n# 2037 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_sequence_rec read_cell init_acc v lexbuf __ocaml_lex_state\n\nand read_list_rev read_cell v lexbuf =\n __ocaml_lex_read_list_rev_rec read_cell v lexbuf 251\nand __ocaml_lex_read_list_rev_rec read_cell v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 583 \"lib/read.mll\"\n \n# 583 \"lib/read.mll\"\n ( let acc = ref [] in\n try\n read_space v lexbuf;\n read_array_end lexbuf;\n acc := read_cell v lexbuf :: !acc;\n while true do\n read_space v lexbuf;\n read_array_sep v lexbuf;\n read_space v lexbuf;\n acc := read_cell v lexbuf :: !acc;\n done;\n assert false\n with End_of_array ->\n !acc\n )\n\n# 2062 \"lib/read.ml\"\n\n \n# 2063 \"lib/read.ml\"\n | 1 ->\n\n# 598 \"lib/read.mll\"\n \n# 598 \"lib/read.mll\"\n ( long_error \"Expected '[' but found\" v lexbuf )\n\n# 2067 \"lib/read.ml\"\n\n \n# 2068 \"lib/read.ml\"\n | 2 ->\n\n# 599 \"lib/read.mll\"\n \n# 599 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2072 \"lib/read.ml\"\n\n \n# 2073 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_list_rev_rec read_cell v lexbuf __ocaml_lex_state\n\nand read_array_end lexbuf =\n __ocaml_lex_read_array_end_rec lexbuf 255\nand __ocaml_lex_read_array_end_rec lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 602 \"lib/read.mll\"\n \n# 602 \"lib/read.mll\"\n ( raise End_of_array )\n\n# 2084 \"lib/read.ml\"\n\n \n# 2085 \"lib/read.ml\"\n | 1 ->\n\n# 603 \"lib/read.mll\"\n \n# 603 \"lib/read.mll\"\n ( () )\n\n# 2089 \"lib/read.ml\"\n\n \n# 2090 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_array_end_rec lexbuf __ocaml_lex_state\n\nand read_array_sep v lexbuf =\n __ocaml_lex_read_array_sep_rec v lexbuf 257\nand __ocaml_lex_read_array_sep_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 606 \"lib/read.mll\"\n \n# 606 \"lib/read.mll\"\n ( () )\n\n# 2101 \"lib/read.ml\"\n\n \n# 2102 \"lib/read.ml\"\n | 1 ->\n\n# 607 \"lib/read.mll\"\n \n# 607 \"lib/read.mll\"\n ( raise End_of_array )\n\n# 2106 \"lib/read.ml\"\n\n \n# 2107 \"lib/read.ml\"\n | 2 ->\n\n# 608 \"lib/read.mll\"\n \n# 608 \"lib/read.mll\"\n ( long_error \"Expected ',' or ']' but found\" v lexbuf )\n\n# 2111 \"lib/read.ml\"\n\n \n# 2112 \"lib/read.ml\"\n | 3 ->\n\n# 609 \"lib/read.mll\"\n \n# 609 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2116 \"lib/read.ml\"\n\n \n# 2117 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_array_sep_rec v lexbuf __ocaml_lex_state\n\nand read_tuple read_cell init_acc v lexbuf =\n __ocaml_lex_read_tuple_rec read_cell init_acc v lexbuf 262\nand __ocaml_lex_read_tuple_rec read_cell init_acc v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 613 \"lib/read.mll\"\n \n# 613 \"lib/read.mll\"\n (\n \n# 615 \"lib/read.mll\"\n let pos = ref 0 in\n let acc = ref init_acc in\n try\n read_space v lexbuf;\n read_tuple_end lexbuf;\n acc := read_cell !pos !acc v lexbuf;\n incr pos;\n while true do\n read_space v lexbuf;\n read_tuple_sep v lexbuf;\n read_space v lexbuf;\n acc := read_cell !pos !acc v lexbuf;\n incr pos;\n done;\n assert false\n with End_of_tuple ->\n !acc\n \n# 635 \"lib/read.mll\"\n )\n\n# 2150 \"lib/read.ml\"\n\n \n# 2151 \"lib/read.ml\"\n | 1 ->\n\n# 636 \"lib/read.mll\"\n \n# 636 \"lib/read.mll\"\n ( long_error \"Expected ')' but found\" v lexbuf )\n\n# 2155 \"lib/read.ml\"\n\n \n# 2156 \"lib/read.ml\"\n | 2 ->\n\n# 637 \"lib/read.mll\"\n \n# 637 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2160 \"lib/read.ml\"\n\n \n# 2161 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_tuple_rec read_cell init_acc v lexbuf __ocaml_lex_state\n\nand read_tuple_end lexbuf =\n __ocaml_lex_read_tuple_end_rec lexbuf 266\nand __ocaml_lex_read_tuple_end_rec lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 640 \"lib/read.mll\"\n \n# 640 \"lib/read.mll\"\n ( raise End_of_tuple )\n\n# 2172 \"lib/read.ml\"\n\n \n# 2173 \"lib/read.ml\"\n | 1 ->\n\n# 641 \"lib/read.mll\"\n \n# 641 \"lib/read.mll\"\n ( () )\n\n# 2177 \"lib/read.ml\"\n\n \n# 2178 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_tuple_end_rec lexbuf __ocaml_lex_state\n\nand read_tuple_end2 v std lexbuf =\n __ocaml_lex_read_tuple_end2_rec v std lexbuf 268\nand __ocaml_lex_read_tuple_end2_rec v std lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 644 \"lib/read.mll\"\n \n# 644 \"lib/read.mll\"\n ( if std then\n long_error \"Expected ')' or '' but found\" v lexbuf\n else\n raise End_of_tuple )\n\n# 2192 \"lib/read.ml\"\n\n \n# 2193 \"lib/read.ml\"\n | 1 ->\n\n# 648 \"lib/read.mll\"\n \n# 648 \"lib/read.mll\"\n ( if std then\n raise End_of_tuple\n else\n long_error \"Expected ']' or '' but found\" v lexbuf )\n\n# 2200 \"lib/read.ml\"\n\n \n# 2201 \"lib/read.ml\"\n | 2 ->\n\n# 652 \"lib/read.mll\"\n \n# 652 \"lib/read.mll\"\n ( () )\n\n# 2205 \"lib/read.ml\"\n\n \n# 2206 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_tuple_end2_rec v std lexbuf __ocaml_lex_state\n\nand read_tuple_sep v lexbuf =\n __ocaml_lex_read_tuple_sep_rec v lexbuf 271\nand __ocaml_lex_read_tuple_sep_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 655 \"lib/read.mll\"\n \n# 655 \"lib/read.mll\"\n ( () )\n\n# 2217 \"lib/read.ml\"\n\n \n# 2218 \"lib/read.ml\"\n | 1 ->\n\n# 656 \"lib/read.mll\"\n \n# 656 \"lib/read.mll\"\n ( raise End_of_tuple )\n\n# 2222 \"lib/read.ml\"\n\n \n# 2223 \"lib/read.ml\"\n | 2 ->\n\n# 657 \"lib/read.mll\"\n \n# 657 \"lib/read.mll\"\n ( long_error \"Expected ',' or ')' but found\" v lexbuf )\n\n# 2227 \"lib/read.ml\"\n\n \n# 2228 \"lib/read.ml\"\n | 3 ->\n\n# 658 \"lib/read.mll\"\n \n# 658 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2232 \"lib/read.ml\"\n\n \n# 2233 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_tuple_sep_rec v lexbuf __ocaml_lex_state\n\nand read_tuple_sep2 v std lexbuf =\n __ocaml_lex_read_tuple_sep2_rec v std lexbuf 276\nand __ocaml_lex_read_tuple_sep2_rec v std lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 661 \"lib/read.mll\"\n \n# 661 \"lib/read.mll\"\n ( () )\n\n# 2244 \"lib/read.ml\"\n\n \n# 2245 \"lib/read.ml\"\n | 1 ->\n\n# 662 \"lib/read.mll\"\n \n# 662 \"lib/read.mll\"\n ( if std then\n long_error \"Expected ',' or ']' but found\" v lexbuf\n else\n raise End_of_tuple )\n\n# 2252 \"lib/read.ml\"\n\n \n# 2253 \"lib/read.ml\"\n | 2 ->\n\n# 666 \"lib/read.mll\"\n \n# 666 \"lib/read.mll\"\n ( if std then\n raise End_of_tuple\n else\n long_error \"Expected ',' or ')' but found\" v lexbuf )\n\n# 2260 \"lib/read.ml\"\n\n \n# 2261 \"lib/read.ml\"\n | 3 ->\n\n# 670 \"lib/read.mll\"\n \n# 670 \"lib/read.mll\"\n ( long_error \"Expected ',' or ')' but found\" v lexbuf )\n\n# 2265 \"lib/read.ml\"\n\n \n# 2266 \"lib/read.ml\"\n | 4 ->\n\n# 671 \"lib/read.mll\"\n \n# 671 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2270 \"lib/read.ml\"\n\n \n# 2271 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_tuple_sep2_rec v std lexbuf __ocaml_lex_state\n\nand read_abstract_fields read_key read_field init_acc v lexbuf =\n __ocaml_lex_read_abstract_fields_rec read_key read_field init_acc v lexbuf 282\nand __ocaml_lex_read_abstract_fields_rec read_key read_field init_acc v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 675 \"lib/read.mll\"\n \n# 675 \"lib/read.mll\"\n ( let acc = ref init_acc in\n try\n read_space v lexbuf;\n read_object_end lexbuf;\n let field_name = read_key v lexbuf in\n read_space v lexbuf;\n read_colon v lexbuf;\n read_space v lexbuf;\n acc := read_field !acc field_name v lexbuf;\n while true do\n read_space v lexbuf;\n read_object_sep v lexbuf;\n read_space v lexbuf;\n let field_name = read_key v lexbuf in\n read_space v lexbuf;\n read_colon v lexbuf;\n read_space v lexbuf;\n acc := read_field !acc field_name v lexbuf;\n done;\n assert false\n with End_of_object ->\n !acc\n )\n\n# 2304 \"lib/read.ml\"\n\n \n# 2305 \"lib/read.ml\"\n | 1 ->\n\n# 698 \"lib/read.mll\"\n \n# 698 \"lib/read.mll\"\n ( long_error \"Expected '{' but found\" v lexbuf )\n\n# 2309 \"lib/read.ml\"\n\n \n# 2310 \"lib/read.ml\"\n | 2 ->\n\n# 699 \"lib/read.mll\"\n \n# 699 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2314 \"lib/read.ml\"\n\n \n# 2315 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_abstract_fields_rec read_key read_field init_acc v lexbuf __ocaml_lex_state\n\nand read_lcurl v lexbuf =\n __ocaml_lex_read_lcurl_rec v lexbuf 286\nand __ocaml_lex_read_lcurl_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 702 \"lib/read.mll\"\n \n# 702 \"lib/read.mll\"\n ( () )\n\n# 2326 \"lib/read.ml\"\n\n \n# 2327 \"lib/read.ml\"\n | 1 ->\n\n# 703 \"lib/read.mll\"\n \n# 703 \"lib/read.mll\"\n ( long_error \"Expected '{' but found\" v lexbuf )\n\n# 2331 \"lib/read.ml\"\n\n \n# 2332 \"lib/read.ml\"\n | 2 ->\n\n# 704 \"lib/read.mll\"\n \n# 704 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2336 \"lib/read.ml\"\n\n \n# 2337 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_lcurl_rec v lexbuf __ocaml_lex_state\n\nand read_object_end lexbuf =\n __ocaml_lex_read_object_end_rec lexbuf 290\nand __ocaml_lex_read_object_end_rec lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 707 \"lib/read.mll\"\n \n# 707 \"lib/read.mll\"\n ( raise End_of_object )\n\n# 2348 \"lib/read.ml\"\n\n \n# 2349 \"lib/read.ml\"\n | 1 ->\n\n# 708 \"lib/read.mll\"\n \n# 708 \"lib/read.mll\"\n ( () )\n\n# 2353 \"lib/read.ml\"\n\n \n# 2354 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_object_end_rec lexbuf __ocaml_lex_state\n\nand read_object_sep v lexbuf =\n __ocaml_lex_read_object_sep_rec v lexbuf 292\nand __ocaml_lex_read_object_sep_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 711 \"lib/read.mll\"\n \n# 711 \"lib/read.mll\"\n ( () )\n\n# 2365 \"lib/read.ml\"\n\n \n# 2366 \"lib/read.ml\"\n | 1 ->\n\n# 712 \"lib/read.mll\"\n \n# 712 \"lib/read.mll\"\n ( raise End_of_object )\n\n# 2370 \"lib/read.ml\"\n\n \n# 2371 \"lib/read.ml\"\n | 2 ->\n\n# 713 \"lib/read.mll\"\n \n# 713 \"lib/read.mll\"\n ( long_error \"Expected ',' or '}' but found\" v lexbuf )\n\n# 2375 \"lib/read.ml\"\n\n \n# 2376 \"lib/read.ml\"\n | 3 ->\n\n# 714 \"lib/read.mll\"\n \n# 714 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2380 \"lib/read.ml\"\n\n \n# 2381 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_object_sep_rec v lexbuf __ocaml_lex_state\n\nand read_colon v lexbuf =\n __ocaml_lex_read_colon_rec v lexbuf 297\nand __ocaml_lex_read_colon_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 717 \"lib/read.mll\"\n \n# 717 \"lib/read.mll\"\n ( () )\n\n# 2392 \"lib/read.ml\"\n\n \n# 2393 \"lib/read.ml\"\n | 1 ->\n\n# 718 \"lib/read.mll\"\n \n# 718 \"lib/read.mll\"\n ( long_error \"Expected ':' but found\" v lexbuf )\n\n# 2397 \"lib/read.ml\"\n\n \n# 2398 \"lib/read.ml\"\n | 2 ->\n\n# 719 \"lib/read.mll\"\n \n# 719 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2402 \"lib/read.ml\"\n\n \n# 2403 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_colon_rec v lexbuf __ocaml_lex_state\n\nand start_any_tuple v lexbuf =\n __ocaml_lex_start_any_tuple_rec v lexbuf 301\nand __ocaml_lex_start_any_tuple_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 722 \"lib/read.mll\"\n \n# 722 \"lib/read.mll\"\n ( false )\n\n# 2414 \"lib/read.ml\"\n\n \n# 2415 \"lib/read.ml\"\n | 1 ->\n\n# 723 \"lib/read.mll\"\n \n# 723 \"lib/read.mll\"\n ( true )\n\n# 2419 \"lib/read.ml\"\n\n \n# 2420 \"lib/read.ml\"\n | 2 ->\n\n# 724 \"lib/read.mll\"\n \n# 724 \"lib/read.mll\"\n ( long_error \"Expected '(' or '[' but found\" v lexbuf )\n\n# 2424 \"lib/read.ml\"\n\n \n# 2425 \"lib/read.ml\"\n | 3 ->\n\n# 725 \"lib/read.mll\"\n \n# 725 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2429 \"lib/read.ml\"\n\n \n# 2430 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_start_any_tuple_rec v lexbuf __ocaml_lex_state\n\nand read_lpar v lexbuf =\n __ocaml_lex_read_lpar_rec v lexbuf 306\nand __ocaml_lex_read_lpar_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 728 \"lib/read.mll\"\n \n# 728 \"lib/read.mll\"\n ( () )\n\n# 2441 \"lib/read.ml\"\n\n \n# 2442 \"lib/read.ml\"\n | 1 ->\n\n# 729 \"lib/read.mll\"\n \n# 729 \"lib/read.mll\"\n ( long_error \"Expected '(' but found\" v lexbuf )\n\n# 2446 \"lib/read.ml\"\n\n \n# 2447 \"lib/read.ml\"\n | 2 ->\n\n# 730 \"lib/read.mll\"\n \n# 730 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2451 \"lib/read.ml\"\n\n \n# 2452 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_lpar_rec v lexbuf __ocaml_lex_state\n\nand read_rpar v lexbuf =\n __ocaml_lex_read_rpar_rec v lexbuf 310\nand __ocaml_lex_read_rpar_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 733 \"lib/read.mll\"\n \n# 733 \"lib/read.mll\"\n ( () )\n\n# 2463 \"lib/read.ml\"\n\n \n# 2464 \"lib/read.ml\"\n | 1 ->\n\n# 734 \"lib/read.mll\"\n \n# 734 \"lib/read.mll\"\n ( long_error \"Expected ')' but found\" v lexbuf )\n\n# 2468 \"lib/read.ml\"\n\n \n# 2469 \"lib/read.ml\"\n | 2 ->\n\n# 735 \"lib/read.mll\"\n \n# 735 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2473 \"lib/read.ml\"\n\n \n# 2474 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_rpar_rec v lexbuf __ocaml_lex_state\n\nand read_lbr v lexbuf =\n __ocaml_lex_read_lbr_rec v lexbuf 314\nand __ocaml_lex_read_lbr_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 738 \"lib/read.mll\"\n \n# 738 \"lib/read.mll\"\n ( () )\n\n# 2485 \"lib/read.ml\"\n\n \n# 2486 \"lib/read.ml\"\n | 1 ->\n\n# 739 \"lib/read.mll\"\n \n# 739 \"lib/read.mll\"\n ( long_error \"Expected '[' but found\" v lexbuf )\n\n# 2490 \"lib/read.ml\"\n\n \n# 2491 \"lib/read.ml\"\n | 2 ->\n\n# 740 \"lib/read.mll\"\n \n# 740 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2495 \"lib/read.ml\"\n\n \n# 2496 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_lbr_rec v lexbuf __ocaml_lex_state\n\nand read_rbr v lexbuf =\n __ocaml_lex_read_rbr_rec v lexbuf 318\nand __ocaml_lex_read_rbr_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 743 \"lib/read.mll\"\n \n# 743 \"lib/read.mll\"\n ( () )\n\n# 2507 \"lib/read.ml\"\n\n \n# 2508 \"lib/read.ml\"\n | 1 ->\n\n# 744 \"lib/read.mll\"\n \n# 744 \"lib/read.mll\"\n ( long_error \"Expected ']' but found\" v lexbuf )\n\n# 2512 \"lib/read.ml\"\n\n \n# 2513 \"lib/read.ml\"\n | 2 ->\n\n# 745 \"lib/read.mll\"\n \n# 745 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2517 \"lib/read.ml\"\n\n \n# 2518 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_rbr_rec v lexbuf __ocaml_lex_state\n\nand skip_json v lexbuf =\n __ocaml_lex_skip_json_rec v lexbuf 322\nand __ocaml_lex_skip_json_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 751 \"lib/read.mll\"\n \n# 751 \"lib/read.mll\"\n ( () )\n\n# 2529 \"lib/read.ml\"\n\n \n# 2530 \"lib/read.ml\"\n | 1 ->\n\n# 752 \"lib/read.mll\"\n \n# 752 \"lib/read.mll\"\n ( () )\n\n# 2534 \"lib/read.ml\"\n\n \n# 2535 \"lib/read.ml\"\n | 2 ->\n\n# 753 \"lib/read.mll\"\n \n# 753 \"lib/read.mll\"\n ( () )\n\n# 2539 \"lib/read.ml\"\n\n \n# 2540 \"lib/read.ml\"\n | 3 ->\n\n# 754 \"lib/read.mll\"\n \n# 754 \"lib/read.mll\"\n ( () )\n\n# 2544 \"lib/read.ml\"\n\n \n# 2545 \"lib/read.ml\"\n | 4 ->\n\n# 755 \"lib/read.mll\"\n \n# 755 \"lib/read.mll\"\n ( () )\n\n# 2549 \"lib/read.ml\"\n\n \n# 2550 \"lib/read.ml\"\n | 5 ->\n\n# 756 \"lib/read.mll\"\n \n# 756 \"lib/read.mll\"\n ( () )\n\n# 2554 \"lib/read.ml\"\n\n \n# 2555 \"lib/read.ml\"\n | 6 ->\n\n# 757 \"lib/read.mll\"\n \n# 757 \"lib/read.mll\"\n ( finish_skip_stringlit v lexbuf )\n\n# 2559 \"lib/read.ml\"\n\n \n# 2560 \"lib/read.ml\"\n | 7 ->\n\n# 758 \"lib/read.mll\"\n \n# 758 \"lib/read.mll\"\n ( () )\n\n# 2564 \"lib/read.ml\"\n\n \n# 2565 \"lib/read.ml\"\n | 8 ->\n\n# 759 \"lib/read.mll\"\n \n# 759 \"lib/read.mll\"\n ( () )\n\n# 2569 \"lib/read.ml\"\n\n \n# 2570 \"lib/read.ml\"\n | 9 ->\n\n# 761 \"lib/read.mll\"\n \n# 761 \"lib/read.mll\"\n ( try\n read_space v lexbuf;\n read_object_end lexbuf;\n skip_ident v lexbuf;\n read_space v lexbuf;\n read_colon v lexbuf;\n read_space v lexbuf;\n skip_json v lexbuf;\n while true do\n read_space v lexbuf;\n read_object_sep v lexbuf;\n read_space v lexbuf;\n skip_ident v lexbuf;\n read_space v lexbuf;\n read_colon v lexbuf;\n read_space v lexbuf;\n skip_json v lexbuf;\n done;\n assert false\n with End_of_object ->\n ()\n )\n\n# 2595 \"lib/read.ml\"\n\n \n# 2596 \"lib/read.ml\"\n | 10 ->\n\n# 784 \"lib/read.mll\"\n \n# 784 \"lib/read.mll\"\n ( try\n read_space v lexbuf;\n read_array_end lexbuf;\n skip_json v lexbuf;\n while true do\n read_space v lexbuf;\n read_array_sep v lexbuf;\n read_space v lexbuf;\n skip_json v lexbuf;\n done;\n assert false\n with End_of_array ->\n ()\n )\n\n# 2613 \"lib/read.ml\"\n\n \n# 2614 \"lib/read.ml\"\n | 11 ->\n\n# 799 \"lib/read.mll\"\n \n# 799 \"lib/read.mll\"\n (\n \n# 801 \"lib/read.mll\"\n try\n read_space v lexbuf;\n read_tuple_end lexbuf;\n skip_json v lexbuf;\n while true do\n read_space v lexbuf;\n read_tuple_sep v lexbuf;\n read_space v lexbuf;\n skip_json v lexbuf;\n done;\n assert false\n with End_of_tuple ->\n ()\n \n# 817 \"lib/read.mll\"\n )\n\n# 2636 \"lib/read.ml\"\n\n \n# 2637 \"lib/read.ml\"\n | 12 ->\n\n# 819 \"lib/read.mll\"\n \n# 819 \"lib/read.mll\"\n (\n \n# 821 \"lib/read.mll\"\n read_space v lexbuf;\n skip_ident v lexbuf;\n read_space v lexbuf;\n finish_skip_variant v lexbuf\n \n# 828 \"lib/read.mll\"\n )\n\n# 2650 \"lib/read.ml\"\n\n \n# 2651 \"lib/read.ml\"\n | 13 ->\n\n# 830 \"lib/read.mll\"\n \n# 830 \"lib/read.mll\"\n ( skip_json v lexbuf )\n\n# 2655 \"lib/read.ml\"\n\n \n# 2656 \"lib/read.ml\"\n | 14 ->\n\n# 831 \"lib/read.mll\"\n \n# 831 \"lib/read.mll\"\n ( finish_comment v lexbuf; skip_json v lexbuf )\n\n# 2660 \"lib/read.ml\"\n\n \n# 2661 \"lib/read.ml\"\n | 15 ->\n\n# 832 \"lib/read.mll\"\n \n# 832 \"lib/read.mll\"\n ( newline v lexbuf; skip_json v lexbuf )\n\n# 2665 \"lib/read.ml\"\n\n \n# 2666 \"lib/read.ml\"\n | 16 ->\n\n# 833 \"lib/read.mll\"\n \n# 833 \"lib/read.mll\"\n ( skip_json v lexbuf )\n\n# 2670 \"lib/read.ml\"\n\n \n# 2671 \"lib/read.ml\"\n | 17 ->\n\n# 834 \"lib/read.mll\"\n \n# 834 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2675 \"lib/read.ml\"\n\n \n# 2676 \"lib/read.ml\"\n | 18 ->\n\n# 835 \"lib/read.mll\"\n \n# 835 \"lib/read.mll\"\n ( long_error \"Invalid token\" v lexbuf )\n\n# 2680 \"lib/read.ml\"\n\n \n# 2681 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_skip_json_rec v lexbuf __ocaml_lex_state\n\nand finish_skip_stringlit v lexbuf =\n __ocaml_lex_finish_skip_stringlit_rec v lexbuf 378\nand __ocaml_lex_finish_skip_stringlit_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 841 \"lib/read.mll\"\n \n# 841 \"lib/read.mll\"\n ( () )\n\n# 2692 \"lib/read.ml\"\n\n \n# 2693 \"lib/read.ml\"\n | 1 ->\n\n# 842 \"lib/read.mll\"\n \n# 842 \"lib/read.mll\"\n ( long_error \"Invalid string literal\" v lexbuf )\n\n# 2697 \"lib/read.ml\"\n\n \n# 2698 \"lib/read.ml\"\n | 2 ->\n\n# 843 \"lib/read.mll\"\n \n# 843 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2702 \"lib/read.ml\"\n\n \n# 2703 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_skip_stringlit_rec v lexbuf __ocaml_lex_state\n\nand finish_skip_variant v lexbuf =\n __ocaml_lex_finish_skip_variant_rec v lexbuf 389\nand __ocaml_lex_finish_skip_variant_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 846 \"lib/read.mll\"\n \n# 846 \"lib/read.mll\"\n ( skip_json v lexbuf;\n read_space v lexbuf;\n read_gt v lexbuf )\n\n# 2716 \"lib/read.ml\"\n\n \n# 2717 \"lib/read.ml\"\n | 1 ->\n\n# 849 \"lib/read.mll\"\n \n# 849 \"lib/read.mll\"\n ( () )\n\n# 2721 \"lib/read.ml\"\n\n \n# 2722 \"lib/read.ml\"\n | 2 ->\n\n# 850 \"lib/read.mll\"\n \n# 850 \"lib/read.mll\"\n ( long_error \"Expected ':' or '>' but found\" v lexbuf )\n\n# 2726 \"lib/read.ml\"\n\n \n# 2727 \"lib/read.ml\"\n | 3 ->\n\n# 851 \"lib/read.mll\"\n \n# 851 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2731 \"lib/read.ml\"\n\n \n# 2732 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_skip_variant_rec v lexbuf __ocaml_lex_state\n\nand skip_ident v lexbuf =\n __ocaml_lex_skip_ident_rec v lexbuf 394\nand __ocaml_lex_skip_ident_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 854 \"lib/read.mll\"\n \n# 854 \"lib/read.mll\"\n ( finish_skip_stringlit v lexbuf )\n\n# 2743 \"lib/read.ml\"\n\n \n# 2744 \"lib/read.ml\"\n | 1 ->\n\n# 855 \"lib/read.mll\"\n \n# 855 \"lib/read.mll\"\n ( () )\n\n# 2748 \"lib/read.ml\"\n\n \n# 2749 \"lib/read.ml\"\n | 2 ->\n\n# 856 \"lib/read.mll\"\n \n# 856 \"lib/read.mll\"\n ( long_error \"Expected string or identifier but found\" v lexbuf )\n\n# 2753 \"lib/read.ml\"\n\n \n# 2754 \"lib/read.ml\"\n | 3 ->\n\n# 857 \"lib/read.mll\"\n \n# 857 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2758 \"lib/read.ml\"\n\n \n# 2759 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_skip_ident_rec v lexbuf __ocaml_lex_state\n\nand buffer_json v lexbuf =\n __ocaml_lex_buffer_json_rec v lexbuf 399\nand __ocaml_lex_buffer_json_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 870 \"lib/read.mll\"\n \n# 870 \"lib/read.mll\"\n ( add_lexeme v.buf lexbuf )\n\n# 2770 \"lib/read.ml\"\n\n \n# 2771 \"lib/read.ml\"\n | 1 ->\n\n# 872 \"lib/read.mll\"\n \n# 872 \"lib/read.mll\"\n ( finish_buffer_stringlit v lexbuf )\n\n# 2775 \"lib/read.ml\"\n\n \n# 2776 \"lib/read.ml\"\n | 2 ->\n\n# 873 \"lib/read.mll\"\n \n# 873 \"lib/read.mll\"\n ( try\n Bi_outbuf.add_char v.buf '{';\n buffer_space v lexbuf;\n buffer_object_end v lexbuf;\n buffer_ident v lexbuf;\n buffer_space v lexbuf;\n buffer_colon v lexbuf;\n buffer_space v lexbuf;\n buffer_json v lexbuf;\n while true do\n buffer_space v lexbuf;\n buffer_object_sep v lexbuf;\n buffer_space v lexbuf;\n buffer_ident v lexbuf;\n buffer_space v lexbuf;\n buffer_colon v lexbuf;\n buffer_space v lexbuf;\n buffer_json v lexbuf;\n done;\n assert false\n with End_of_object ->\n ()\n )\n\n# 2802 \"lib/read.ml\"\n\n \n# 2803 \"lib/read.ml\"\n | 3 ->\n\n# 897 \"lib/read.mll\"\n \n# 897 \"lib/read.mll\"\n ( try\n Bi_outbuf.add_char v.buf '[';\n buffer_space v lexbuf;\n buffer_array_end v lexbuf;\n buffer_json v lexbuf;\n while true do\n buffer_space v lexbuf;\n buffer_array_sep v lexbuf;\n buffer_space v lexbuf;\n buffer_json v lexbuf;\n done;\n assert false\n with End_of_array ->\n ()\n )\n\n# 2821 \"lib/read.ml\"\n\n \n# 2822 \"lib/read.ml\"\n | 4 ->\n\n# 913 \"lib/read.mll\"\n \n# 913 \"lib/read.mll\"\n (\n \n# 915 \"lib/read.mll\"\n try\n Bi_outbuf.add_char v.buf '(';\n buffer_space v lexbuf;\n buffer_tuple_end v lexbuf;\n buffer_json v lexbuf;\n while true do\n buffer_space v lexbuf;\n buffer_tuple_sep v lexbuf;\n buffer_space v lexbuf;\n buffer_json v lexbuf;\n done;\n assert false\n with End_of_tuple ->\n ()\n \n# 932 \"lib/read.mll\"\n )\n\n# 2845 \"lib/read.ml\"\n\n \n# 2846 \"lib/read.ml\"\n | 5 ->\n\n# 934 \"lib/read.mll\"\n \n# 934 \"lib/read.mll\"\n (\n \n# 936 \"lib/read.mll\"\n Bi_outbuf.add_char v.buf '<';\n buffer_space v lexbuf;\n buffer_ident v lexbuf;\n buffer_space v lexbuf;\n finish_buffer_variant v lexbuf\n \n# 944 \"lib/read.mll\"\n )\n\n# 2860 \"lib/read.ml\"\n\n \n# 2861 \"lib/read.ml\"\n | 6 ->\n\n# 946 \"lib/read.mll\"\n \n# 946 \"lib/read.mll\"\n ( add_lexeme v.buf lexbuf; buffer_json v lexbuf )\n\n# 2865 \"lib/read.ml\"\n\n \n# 2866 \"lib/read.ml\"\n | 7 ->\n\n# 947 \"lib/read.mll\"\n \n# 947 \"lib/read.mll\"\n ( Bi_outbuf.add_string v.buf \"/*\";\n finish_buffer_comment v lexbuf;\n buffer_json v lexbuf )\n\n# 2872 \"lib/read.ml\"\n\n \n# 2873 \"lib/read.ml\"\n | 8 ->\n\n# 950 \"lib/read.mll\"\n \n# 950 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\\n';\n newline v lexbuf;\n buffer_json v lexbuf )\n\n# 2879 \"lib/read.ml\"\n\n \n# 2880 \"lib/read.ml\"\n | 9 ->\n\n# 953 \"lib/read.mll\"\n \n# 953 \"lib/read.mll\"\n ( add_lexeme v.buf lexbuf; buffer_json v lexbuf )\n\n# 2884 \"lib/read.ml\"\n\n \n# 2885 \"lib/read.ml\"\n | 10 ->\n\n# 954 \"lib/read.mll\"\n \n# 954 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2889 \"lib/read.ml\"\n\n \n# 2890 \"lib/read.ml\"\n | 11 ->\n\n# 955 \"lib/read.mll\"\n \n# 955 \"lib/read.mll\"\n ( long_error \"Invalid token\" v lexbuf )\n\n# 2894 \"lib/read.ml\"\n\n \n# 2895 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_json_rec v lexbuf __ocaml_lex_state\n\nand finish_buffer_stringlit v lexbuf =\n __ocaml_lex_finish_buffer_stringlit_rec v lexbuf 450\nand __ocaml_lex_finish_buffer_stringlit_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 961 \"lib/read.mll\"\n \n# 961 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\"';\n add_lexeme v.buf lexbuf\n )\n\n# 2908 \"lib/read.ml\"\n\n \n# 2909 \"lib/read.ml\"\n | 1 ->\n\n# 964 \"lib/read.mll\"\n \n# 964 \"lib/read.mll\"\n ( long_error \"Invalid string literal\" v lexbuf )\n\n# 2913 \"lib/read.ml\"\n\n \n# 2914 \"lib/read.ml\"\n | 2 ->\n\n# 965 \"lib/read.mll\"\n \n# 965 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2918 \"lib/read.ml\"\n\n \n# 2919 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_buffer_stringlit_rec v lexbuf __ocaml_lex_state\n\nand finish_buffer_variant v lexbuf =\n __ocaml_lex_finish_buffer_variant_rec v lexbuf 461\nand __ocaml_lex_finish_buffer_variant_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 968 \"lib/read.mll\"\n \n# 968 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf ':';\n buffer_json v lexbuf;\n buffer_space v lexbuf;\n buffer_gt v lexbuf )\n\n# 2933 \"lib/read.ml\"\n\n \n# 2934 \"lib/read.ml\"\n | 1 ->\n\n# 972 \"lib/read.mll\"\n \n# 972 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '>' )\n\n# 2938 \"lib/read.ml\"\n\n \n# 2939 \"lib/read.ml\"\n | 2 ->\n\n# 973 \"lib/read.mll\"\n \n# 973 \"lib/read.mll\"\n ( long_error \"Expected ':' or '>' but found\" v lexbuf )\n\n# 2943 \"lib/read.ml\"\n\n \n# 2944 \"lib/read.ml\"\n | 3 ->\n\n# 974 \"lib/read.mll\"\n \n# 974 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2948 \"lib/read.ml\"\n\n \n# 2949 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_buffer_variant_rec v lexbuf __ocaml_lex_state\n\nand buffer_ident v lexbuf =\n __ocaml_lex_buffer_ident_rec v lexbuf 466\nand __ocaml_lex_buffer_ident_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 977 \"lib/read.mll\"\n \n# 977 \"lib/read.mll\"\n ( finish_buffer_stringlit v lexbuf )\n\n# 2960 \"lib/read.ml\"\n\n \n# 2961 \"lib/read.ml\"\n | 1 ->\n\n# 978 \"lib/read.mll\"\n \n# 978 \"lib/read.mll\"\n ( add_lexeme v.buf lexbuf )\n\n# 2965 \"lib/read.ml\"\n\n \n# 2966 \"lib/read.ml\"\n | 2 ->\n\n# 979 \"lib/read.mll\"\n \n# 979 \"lib/read.mll\"\n ( long_error \"Expected string or identifier but found\" v lexbuf )\n\n# 2970 \"lib/read.ml\"\n\n \n# 2971 \"lib/read.ml\"\n | 3 ->\n\n# 980 \"lib/read.mll\"\n \n# 980 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 2975 \"lib/read.ml\"\n\n \n# 2976 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_ident_rec v lexbuf __ocaml_lex_state\n\nand buffer_space v lexbuf =\n __ocaml_lex_buffer_space_rec v lexbuf 471\nand __ocaml_lex_buffer_space_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 983 \"lib/read.mll\"\n \n# 983 \"lib/read.mll\"\n (\n add_lexeme v.buf lexbuf;\n newline v lexbuf;\n buffer_space v lexbuf )\n\n# 2990 \"lib/read.ml\"\n\n \n# 2991 \"lib/read.ml\"\n | 1 ->\n\n# 987 \"lib/read.mll\"\n \n# 987 \"lib/read.mll\"\n (\n Bi_outbuf.add_string v.buf \"/*\";\n finish_buffer_comment v lexbuf;\n buffer_space v lexbuf )\n\n# 2998 \"lib/read.ml\"\n\n \n# 2999 \"lib/read.ml\"\n | 2 ->\n\n# 991 \"lib/read.mll\"\n \n# 991 \"lib/read.mll\"\n (\n Bi_outbuf.add_char v.buf '\\n';\n newline v lexbuf;\n buffer_space v lexbuf )\n\n# 3006 \"lib/read.ml\"\n\n \n# 3007 \"lib/read.ml\"\n | 3 ->\n\n# 995 \"lib/read.mll\"\n \n# 995 \"lib/read.mll\"\n (\n add_lexeme v.buf lexbuf;\n buffer_space v lexbuf )\n\n# 3013 \"lib/read.ml\"\n\n \n# 3014 \"lib/read.ml\"\n | 4 ->\n\n# 998 \"lib/read.mll\"\n \n# 998 \"lib/read.mll\"\n ( () )\n\n# 3018 \"lib/read.ml\"\n\n \n# 3019 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_space_rec v lexbuf __ocaml_lex_state\n\nand buffer_object_end v lexbuf =\n __ocaml_lex_buffer_object_end_rec v lexbuf 478\nand __ocaml_lex_buffer_object_end_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1001 \"lib/read.mll\"\n \n# 1001 \"lib/read.mll\"\n (\n Bi_outbuf.add_char v.buf '}';\n raise End_of_object )\n\n# 3032 \"lib/read.ml\"\n\n \n# 3033 \"lib/read.ml\"\n | 1 ->\n\n# 1004 \"lib/read.mll\"\n \n# 1004 \"lib/read.mll\"\n ( () )\n\n# 3037 \"lib/read.ml\"\n\n \n# 3038 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_object_end_rec v lexbuf __ocaml_lex_state\n\nand buffer_object_sep v lexbuf =\n __ocaml_lex_buffer_object_sep_rec v lexbuf 480\nand __ocaml_lex_buffer_object_sep_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1007 \"lib/read.mll\"\n \n# 1007 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf ',' )\n\n# 3049 \"lib/read.ml\"\n\n \n# 3050 \"lib/read.ml\"\n | 1 ->\n\n# 1008 \"lib/read.mll\"\n \n# 1008 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '}'; raise End_of_object )\n\n# 3054 \"lib/read.ml\"\n\n \n# 3055 \"lib/read.ml\"\n | 2 ->\n\n# 1009 \"lib/read.mll\"\n \n# 1009 \"lib/read.mll\"\n ( long_error \"Expected ',' or '}' but found\" v lexbuf )\n\n# 3059 \"lib/read.ml\"\n\n \n# 3060 \"lib/read.ml\"\n | 3 ->\n\n# 1010 \"lib/read.mll\"\n \n# 1010 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 3064 \"lib/read.ml\"\n\n \n# 3065 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_object_sep_rec v lexbuf __ocaml_lex_state\n\nand buffer_array_end v lexbuf =\n __ocaml_lex_buffer_array_end_rec v lexbuf 485\nand __ocaml_lex_buffer_array_end_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1013 \"lib/read.mll\"\n \n# 1013 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf ']'; raise End_of_array )\n\n# 3076 \"lib/read.ml\"\n\n \n# 3077 \"lib/read.ml\"\n | 1 ->\n\n# 1014 \"lib/read.mll\"\n \n# 1014 \"lib/read.mll\"\n ( () )\n\n# 3081 \"lib/read.ml\"\n\n \n# 3082 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_array_end_rec v lexbuf __ocaml_lex_state\n\nand buffer_array_sep v lexbuf =\n __ocaml_lex_buffer_array_sep_rec v lexbuf 487\nand __ocaml_lex_buffer_array_sep_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1017 \"lib/read.mll\"\n \n# 1017 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf ',' )\n\n# 3093 \"lib/read.ml\"\n\n \n# 3094 \"lib/read.ml\"\n | 1 ->\n\n# 1018 \"lib/read.mll\"\n \n# 1018 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf ']'; raise End_of_array )\n\n# 3098 \"lib/read.ml\"\n\n \n# 3099 \"lib/read.ml\"\n | 2 ->\n\n# 1019 \"lib/read.mll\"\n \n# 1019 \"lib/read.mll\"\n ( long_error \"Expected ',' or ']' but found\" v lexbuf )\n\n# 3103 \"lib/read.ml\"\n\n \n# 3104 \"lib/read.ml\"\n | 3 ->\n\n# 1020 \"lib/read.mll\"\n \n# 1020 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 3108 \"lib/read.ml\"\n\n \n# 3109 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_array_sep_rec v lexbuf __ocaml_lex_state\n\nand buffer_tuple_end v lexbuf =\n __ocaml_lex_buffer_tuple_end_rec v lexbuf 492\nand __ocaml_lex_buffer_tuple_end_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1023 \"lib/read.mll\"\n \n# 1023 \"lib/read.mll\"\n (\n Bi_outbuf.add_char v.buf ')';\n raise End_of_tuple )\n\n# 3122 \"lib/read.ml\"\n\n \n# 3123 \"lib/read.ml\"\n | 1 ->\n\n# 1026 \"lib/read.mll\"\n \n# 1026 \"lib/read.mll\"\n ( () )\n\n# 3127 \"lib/read.ml\"\n\n \n# 3128 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_tuple_end_rec v lexbuf __ocaml_lex_state\n\nand buffer_tuple_sep v lexbuf =\n __ocaml_lex_buffer_tuple_sep_rec v lexbuf 494\nand __ocaml_lex_buffer_tuple_sep_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1029 \"lib/read.mll\"\n \n# 1029 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf ',' )\n\n# 3139 \"lib/read.ml\"\n\n \n# 3140 \"lib/read.ml\"\n | 1 ->\n\n# 1030 \"lib/read.mll\"\n \n# 1030 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf ')'; raise End_of_tuple )\n\n# 3144 \"lib/read.ml\"\n\n \n# 3145 \"lib/read.ml\"\n | 2 ->\n\n# 1031 \"lib/read.mll\"\n \n# 1031 \"lib/read.mll\"\n ( long_error \"Expected ',' or ')' but found\" v lexbuf )\n\n# 3149 \"lib/read.ml\"\n\n \n# 3150 \"lib/read.ml\"\n | 3 ->\n\n# 1032 \"lib/read.mll\"\n \n# 1032 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 3154 \"lib/read.ml\"\n\n \n# 3155 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_tuple_sep_rec v lexbuf __ocaml_lex_state\n\nand buffer_colon v lexbuf =\n __ocaml_lex_buffer_colon_rec v lexbuf 499\nand __ocaml_lex_buffer_colon_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1035 \"lib/read.mll\"\n \n# 1035 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf ':' )\n\n# 3166 \"lib/read.ml\"\n\n \n# 3167 \"lib/read.ml\"\n | 1 ->\n\n# 1036 \"lib/read.mll\"\n \n# 1036 \"lib/read.mll\"\n ( long_error \"Expected ':' but found\" v lexbuf )\n\n# 3171 \"lib/read.ml\"\n\n \n# 3172 \"lib/read.ml\"\n | 2 ->\n\n# 1037 \"lib/read.mll\"\n \n# 1037 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 3176 \"lib/read.ml\"\n\n \n# 3177 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_colon_rec v lexbuf __ocaml_lex_state\n\nand buffer_gt v lexbuf =\n __ocaml_lex_buffer_gt_rec v lexbuf 503\nand __ocaml_lex_buffer_gt_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1040 \"lib/read.mll\"\n \n# 1040 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '>' )\n\n# 3188 \"lib/read.ml\"\n\n \n# 3189 \"lib/read.ml\"\n | 1 ->\n\n# 1041 \"lib/read.mll\"\n \n# 1041 \"lib/read.mll\"\n ( long_error \"Expected '>' but found\" v lexbuf )\n\n# 3193 \"lib/read.ml\"\n\n \n# 3194 \"lib/read.ml\"\n | 2 ->\n\n# 1042 \"lib/read.mll\"\n \n# 1042 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n\n# 3198 \"lib/read.ml\"\n\n \n# 3199 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_buffer_gt_rec v lexbuf __ocaml_lex_state\n\nand finish_buffer_comment v lexbuf =\n __ocaml_lex_finish_buffer_comment_rec v lexbuf 507\nand __ocaml_lex_finish_buffer_comment_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1045 \"lib/read.mll\"\n \n# 1045 \"lib/read.mll\"\n ( Bi_outbuf.add_string v.buf \"*/\" )\n\n# 3210 \"lib/read.ml\"\n\n \n# 3211 \"lib/read.ml\"\n | 1 ->\n\n# 1046 \"lib/read.mll\"\n \n# 1046 \"lib/read.mll\"\n ( long_error \"Unterminated comment\" v lexbuf )\n\n# 3215 \"lib/read.ml\"\n\n \n# 3216 \"lib/read.ml\"\n | 2 ->\n\n# 1047 \"lib/read.mll\"\n \n# 1047 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\\n';\n newline v lexbuf;\n finish_buffer_comment v lexbuf )\n\n# 3222 \"lib/read.ml\"\n\n \n# 3223 \"lib/read.ml\"\n | 3 ->\n\n# 1050 \"lib/read.mll\"\n \n# 1050 \"lib/read.mll\"\n ( add_lexeme v.buf lexbuf; finish_buffer_comment v lexbuf )\n\n# 3227 \"lib/read.ml\"\n\n \n# 3228 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_finish_buffer_comment_rec v lexbuf __ocaml_lex_state\n\nand junk lexbuf =\n __ocaml_lex_junk_rec lexbuf 513\nand __ocaml_lex_junk_rec lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n\n# 1053 \"lib/read.mll\"\n \n# 1053 \"lib/read.mll\"\n ( Lexing.lexeme lexbuf )\n\n# 3239 \"lib/read.ml\"\n\n \n# 3240 \"lib/read.ml\"\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_junk_rec lexbuf __ocaml_lex_state\n\n;;\n\n\n# 1055 \"lib/read.mll\"\n \n \n# 1056 \"lib/read.mll\"\n let _ = (read_json : lexer_state -> Lexing.lexbuf -> t)\n\n let read_t = read_json\n\n let () =\n read_junk := junk\n\n let read_int8 v lexbuf =\n let n = read_int v lexbuf in\n if n < 0 || n > 255 then\n lexer_error \"Int8 overflow\" v lexbuf\n else\n char_of_int n\n\n let read_list read_cell v lexbuf =\n List.rev (read_list_rev read_cell v lexbuf)\n\n let array_of_rev_list l =\n match l with\n [] -> [| |]\n | x :: tl ->\n let len = List.length l in\n let a = Array.make len x in\n let r = ref tl in\n for i = len - 2 downto 0 do\n a.(i) <- List.hd !r;\n r := List.tl !r\n done;\n a\n\n let read_array read_cell v lexbuf =\n let l = read_list_rev read_cell v lexbuf in\n array_of_rev_list l\n\n (* Read a JSON object, reading the keys into OCaml strings\n (provided for backward compatibility) *)\n let read_fields read_field init_acc v =\n read_abstract_fields read_ident read_field init_acc v\n\n let finish v lexbuf =\n read_space v lexbuf;\n if not (read_eof lexbuf) then\n long_error \"Junk after end of JSON value:\" v lexbuf\n\n let init_lexer = init_lexer\n\n let from_lexbuf v ?(stream = false) lexbuf =\n read_space v lexbuf;\n\n let x =\n if read_eof lexbuf then\n raise End_of_input\n else\n read_json v lexbuf\n in\n\n if not stream then\n finish v lexbuf;\n\n x\n\n\n let from_string ?buf ?fname ?lnum s =\n try\n let lexbuf = Lexing.from_string s in\n let v = init_lexer ?buf ?fname ?lnum () in\n from_lexbuf v lexbuf\n with End_of_input ->\n json_error \"Blank input data\"\n\n let from_channel ?buf ?fname ?lnum ic =\n try\n let lexbuf = Lexing.from_channel ic in\n let v = init_lexer ?buf ?fname ?lnum () in\n from_lexbuf v lexbuf\n with End_of_input ->\n json_error \"Blank input data\"\n\n let from_file ?buf ?fname ?lnum file =\n let ic = open_in file in\n try\n let x = from_channel ?buf ?fname ?lnum ic in\n close_in ic;\n x\n with e ->\n close_in_noerr ic;\n raise e\n\n exception Finally of exn * exn\n\n let stream_from_lexbuf v ?(fin = fun () -> ()) lexbuf =\n let stream = Some true in\n let f i =\n try Some (from_lexbuf v ?stream lexbuf)\n with\n End_of_input ->\n fin ();\n None\n | e ->\n (try fin () with fin_e -> raise (Finally (e, fin_e)));\n raise e\n in\n Stream.from f\n\n let stream_from_string ?buf ?fname ?lnum s =\n let v = init_lexer ?buf ?fname ?lnum () in\n stream_from_lexbuf v (Lexing.from_string s)\n\n let stream_from_channel ?buf ?fin ?fname ?lnum ic =\n let lexbuf = Lexing.from_channel ic in\n let v = init_lexer ?buf ?fname ?lnum () in\n stream_from_lexbuf v ?fin lexbuf\n\n let stream_from_file ?buf ?fname ?lnum file =\n let ic = open_in file in\n let fin () = close_in ic in\n let fname =\n match fname with\n None -> Some file\n | x -> x\n in\n let lexbuf = Lexing.from_channel ic in\n let v = init_lexer ?buf ?fname ?lnum () in\n stream_from_lexbuf v ~fin lexbuf\n\n type json_line = [ `Json of t | `Exn of exn ]\n\n let linestream_from_channel\n ?buf ?(fin = fun () -> ()) ?fname ?lnum:(lnum0 = 1) ic =\n let buf =\n match buf with\n None -> Some (Bi_outbuf.create 256)\n | Some _ -> buf\n in\n let f i =\n try\n let line = input_line ic in\n let lnum = lnum0 + i in\n Some (`Json (from_string ?buf ?fname ~lnum line))\n with\n End_of_file -> fin (); None\n | e -> Some (`Exn e)\n in\n Stream.from f\n\n let linestream_from_file ?buf ?fname ?lnum file =\n let ic = open_in file in\n let fin () = close_in ic in\n let fname =\n match fname with\n None -> Some file\n | x -> x\n in\n linestream_from_channel ?buf ~fin ?fname ?lnum ic\n\n let prettify ?std s =\n pretty_to_string ?std (from_string s)\n\n let compact ?std s =\n to_string (from_string s)\n\n let validate_json _path _value = None\n\n\n# 3411 \"lib/read.ml\"\n# 91 \"yojson.cppo.ml\"\nend\n","open Core_kernel\nmodule Z = Zarith.Z\n\ntype t = Z.t [@@deriving typerep ~abstract]\n\nlet module_name = \"Bigint\"\nlet invariant (_ : t) = ()\n\nmodule Stringable_t = struct\n type nonrec t = t\n\n let to_string = Z.to_string\n\n let rec is_integer_suffix s i ~len ~char_is_digit =\n if i < len\n then (\n let c = s.[i] in\n if char_is_digit c || Char.equal c '_'\n then is_integer_suffix s (i + 1) ~len ~char_is_digit\n else false)\n else true\n ;;\n\n let is_integer_string s ~char_is_digit =\n let len = String.length s in\n if 0 < len\n then (\n let i = if Char.equal s.[0] '-' then 1 else 0 in\n if i < len\n then\n if char_is_digit s.[i]\n then is_integer_suffix s (i + 1) ~len ~char_is_digit\n else false\n else false)\n else false\n ;;\n\n let of_string_base str ~name ~of_string_no_underscores ~char_is_digit =\n try of_string_no_underscores str with\n | _ ->\n if is_integer_string str ~char_is_digit\n then of_string_no_underscores (String.filter str ~f:(fun c -> Char.( <> ) c '_'))\n else failwithf \"%s.%s: invalid argument %S\" name module_name str ()\n ;;\n\n let of_string str =\n of_string_base\n str\n ~name:\"of_string\"\n ~of_string_no_underscores:Z.of_string\n ~char_is_digit:Char.is_digit\n ;;\nend\n\nmodule Stable = struct\n module V1 = struct\n module Bin_rep = struct\n type t =\n | Zero\n | Pos of string\n | Neg of string\n [@@deriving bin_io]\n end\n\n module Bin_rep_conversion = struct\n type nonrec t = t\n\n let to_binable t =\n let s = Z.sign t in\n if s > 0\n then Bin_rep.Pos (Z.to_bits t)\n else if s < 0\n then Bin_rep.Neg (Z.to_bits t)\n else Bin_rep.Zero\n ;;\n\n let of_binable = function\n | Bin_rep.Zero -> Z.zero\n | Bin_rep.Pos bits -> Z.of_bits bits\n | Bin_rep.Neg bits -> Z.of_bits bits |> Z.neg\n ;;\n end\n\n type nonrec t = t\n\n let compare = Z.compare\n\n include Sexpable.Stable.Of_stringable.V1 (Stringable_t)\n\n include Binable.Stable.Of_binable.V1 [@alert \"-legacy\"]\n (Bin_rep)\n (Bin_rep_conversion)\n end\n\n module V2 = struct\n type nonrec t = t\n\n let compare = Z.compare\n\n include Sexpable.Stable.Of_stringable.V1 (Stringable_t)\n\n let compute_size_in_bytes x =\n let numbits = Z.numbits x in\n Int.round_up ~to_multiple_of:8 numbits / 8\n ;;\n\n let compute_tag ~size_in_bytes ~negative =\n let open Int63 in\n let sign_bit = if negative then one else zero in\n (* Can't overflow:\n size <= String.length bits < 2 * max_string_length < max_int63\n *)\n shift_left (of_int size_in_bytes) 1 + sign_bit\n ;;\n\n let bin_size_t : t Bin_prot.Size.sizer =\n fun x ->\n let size_in_bytes = compute_size_in_bytes x in\n if size_in_bytes = 0\n then Int63.bin_size_t Int63.zero\n else (\n let negative = Z.sign x = -1 in\n let tag = compute_tag ~size_in_bytes ~negative in\n Int63.bin_size_t tag + size_in_bytes)\n ;;\n\n let bin_write_t : t Bin_prot.Write.writer =\n fun buf ~pos x ->\n let size_in_bytes = compute_size_in_bytes x in\n if size_in_bytes = 0\n then Int63.bin_write_t buf ~pos Int63.zero\n else (\n let bits = Z.to_bits x in\n let negative = Z.sign x = -1 in\n let tag = compute_tag ~size_in_bytes ~negative in\n let pos = Int63.bin_write_t buf ~pos tag in\n Bin_prot.Common.blit_string_buf bits ~dst_pos:pos buf ~len:size_in_bytes;\n pos + size_in_bytes)\n ;;\n\n let bin_read_t : t Bin_prot.Read.reader =\n fun buf ~pos_ref ->\n let tag = Core_kernel.Int63.bin_read_t buf ~pos_ref in\n if Int63.equal tag Int63.zero\n then Z.zero\n else (\n let negative = Int63.(tag land one = one) in\n let size_in_bytes = Int63.(to_int_exn (shift_right tag 1)) in\n (* Even though we could cache a buffer for small sizes, the extra logic leads to\n a decrease in performance *)\n let bytes = Bytes.create size_in_bytes in\n Bin_prot.Common.blit_buf_bytes ~src_pos:!pos_ref buf bytes ~len:size_in_bytes;\n let abs =\n Z.of_bits (Bytes.unsafe_to_string ~no_mutation_while_string_reachable:bytes)\n in\n pos_ref := !pos_ref + size_in_bytes;\n if negative then Z.neg abs else abs)\n ;;\n\n let module_name = \"Bigint.Stable.V2.t\"\n\n let bin_writer_t : t Bin_prot.Type_class.writer =\n { size = bin_size_t; write = bin_write_t }\n ;;\n\n let __bin_read_t__ _buf ~pos_ref _vint =\n Bin_prot.Common.raise_variant_wrong_type module_name !pos_ref\n ;;\n\n let bin_reader_t : t Bin_prot.Type_class.reader =\n { read = bin_read_t; vtag_read = __bin_read_t__ }\n ;;\n\n let bin_shape_t : Bin_prot.Shape.t =\n Bin_prot.Shape.basetype\n (Bin_prot.Shape.Uuid.of_string \"7a8cceb2-f3a2-11e9-b7cb-aae95a547ff6\")\n []\n ;;\n\n let bin_t : t Bin_prot.Type_class.t =\n { shape = bin_shape_t; writer = bin_writer_t; reader = bin_reader_t }\n ;;\n end\nend\n\nmodule Unstable = struct\n include Stable.V1\n include Stringable_t\n\n let t_sexp_grammar = [%sexp_grammar: String.t]\n let of_zarith_bigint t = t\n let to_zarith_bigint t = t\n\n let ( /% ) x y =\n if Z.sign y >= 0\n then Z.ediv x y\n else\n failwithf\n \"%s.(%s /%% %s) : divisor must be positive\"\n module_name\n (to_string x)\n (to_string y)\n ()\n ;;\n\n let ( % ) x y =\n if Z.sign y >= 0\n then Z.erem x y\n else\n failwithf\n \"%s.(%s %% %s) : divisor must be positive\"\n module_name\n (to_string x)\n (to_string y)\n ()\n ;;\n\n let hash_fold_t state t = Int.hash_fold_t state (Z.hash t)\n let hash = Z.hash\n let compare = Z.compare\n let ( - ) = Z.( - )\n let ( + ) = Z.( + )\n let ( * ) = Z.( * )\n let ( / ) = Z.( / )\n let rem = Z.rem\n let ( ~- ) = Z.( ~- )\n let neg = Z.neg\n let abs = Z.abs\n let succ = Z.succ\n let pred = Z.pred\n let equal = Z.equal\n let ( = ) = Z.equal\n let ( < ) = Z.lt\n let ( > ) = Z.gt\n let ( <= ) = Z.leq\n let ( >= ) = Z.geq\n let max = Z.max\n let min = Z.min\n let ascending = compare\n let shift_right = Z.shift_right\n let shift_left = Z.shift_left\n let bit_not = Z.lognot\n let bit_xor = Z.logxor\n let bit_or = Z.logor\n let bit_and = Z.logand\n let ( land ) = bit_and\n let ( lor ) = bit_or\n let ( lxor ) = bit_xor\n let lnot = bit_not\n let ( lsl ) = shift_left\n let ( asr ) = shift_right\n let of_int = Z.of_int\n let of_int32 = Z.of_int32\n let of_int64 = Z.of_int64\n let of_nativeint = Z.of_nativeint\n let of_float_unchecked = Z.of_float\n let of_float = Z.of_float\n let of_int_exn = of_int\n let of_int32_exn = of_int32\n let of_int64_exn = of_int64\n let of_nativeint_exn = of_nativeint\n let to_int_exn = Z.to_int\n let to_int32_exn = Z.to_int32\n let to_int64_exn = Z.to_int64\n let to_nativeint_exn = Z.to_nativeint\n let to_float = Z.to_float\n let zero = Z.zero\n let one = Z.one\n let minus_one = Z.minus_one\n let to_int t = if Z.fits_int t then Some (Z.to_int t) else None\n let to_int32 t = if Z.fits_int32 t then Some (Z.to_int32 t) else None\n let to_int64 t = if Z.fits_int64 t then Some (Z.to_int64 t) else None\n let to_nativeint t = if Z.fits_nativeint t then Some (Z.to_nativeint t) else None\n let ( <> ) x y = not (equal x y)\n let incr cell = cell := succ !cell\n let decr cell = cell := pred !cell\n let pow x y = Z.pow x (to_int_exn y)\n let ( ** ) x y = pow x y\n let popcount x = Z.popcount x\nend\n\nmodule T_math = Int_math.Make (Unstable)\nmodule T_conversions = Int_conversions.Make (Unstable)\nmodule T_comparable_with_zero = Comparable.Validate_with_zero (Unstable)\n\nmodule T_identifiable = Identifiable.Make (struct\n let module_name = module_name\n\n include Unstable\n end)\n\n(* Including in opposite order to shadow functorized bindings with direct bindings. *)\nmodule O = struct\n include T_identifiable\n include T_comparable_with_zero\n include T_conversions\n include T_math\n include Unstable\nend\n\ninclude (O : module type of O with type t := t)\n\nmodule Make_random (State : sig\n type t\n\n val bits : t -> int\n val int : t -> int -> int\n end) : sig\n val random : state:State.t -> t -> t\nend = struct\n (* Uniform random generation of Bigint values.\n\n [random ~state range] chooses a [depth] and generates random values using\n [Random.State.bits state], called [1 lsl depth] times and concatenated. The\n preliminary result [n] therefore satisfies [0 <= n < 1 lsl (30 lsl depth)].\n\n In order for the random choice to be uniform between [0] and [range-1], there must\n exist [k > 0] such that [n < k * range <= 1 lsl (30 lsl depth)]. If so, [n % range]\n is returned. Otherwise the random choice process is repeated from scratch.\n\n The [depth] value is chosen so that repeating is uncommon (1 in 1,000 or less). *)\n\n let bits_at_depth ~depth = Int.shift_left 30 depth\n let range_at_depth ~depth = shift_left one (bits_at_depth ~depth)\n\n let rec choose_bit_depth_for_range_from ~range ~depth =\n if range_at_depth ~depth >= range\n then depth\n else choose_bit_depth_for_range_from ~range ~depth:(Int.succ depth)\n ;;\n\n let choose_bit_depth_for_range ~range = choose_bit_depth_for_range_from ~range ~depth:0\n\n let rec random_bigint_at_depth ~state ~depth =\n if Int.equal depth 0\n then of_int (State.bits state)\n else (\n let prev_depth = Int.pred depth in\n let prefix = random_bigint_at_depth ~state ~depth:prev_depth in\n let suffix = random_bigint_at_depth ~state ~depth:prev_depth in\n bit_or (shift_left prefix (bits_at_depth ~depth:prev_depth)) suffix)\n ;;\n\n let random_value_is_uniform_in_range ~range ~depth n =\n let k = range_at_depth ~depth / range in\n n < k * range\n ;;\n\n let rec large_random_at_depth ~state ~range ~depth =\n let result = random_bigint_at_depth ~state ~depth in\n if random_value_is_uniform_in_range ~range ~depth result\n then result % range\n else large_random_at_depth ~state ~range ~depth\n ;;\n\n let large_random ~state ~range =\n let tolerance_factor = of_int 1_000 in\n let depth = choose_bit_depth_for_range ~range:(range * tolerance_factor) in\n large_random_at_depth ~state ~range ~depth\n ;;\n\n let random ~state range =\n if range <= zero\n then\n failwithf \"Bigint.random: argument %s <= 0\" (to_string_hum range) ()\n (* Note that it's not safe to do [1 lsl 30] on a 32-bit machine (with 31-bit signed\n integers) *)\n else if range < shift_left one 30\n then of_int (State.int state (to_int_exn range))\n else large_random ~state ~range\n ;;\nend\n\nmodule Random_internal = Make_random (Random.State)\n\nlet random ?(state = Random.State.default) range = Random_internal.random ~state range\n\nmodule For_quickcheck : sig\n include Quickcheckable.S_int with type t := t\n\n val gen_negative : t Quickcheck.Generator.t\n val gen_positive : t Quickcheck.Generator.t\nend = struct\n module Generator = Quickcheck.Generator\n open Generator.Let_syntax\n\n module Uniform = Make_random (struct\n type t = Splittable_random.State.t\n\n let int t range = Splittable_random.int t ~lo:0 ~hi:(Int.pred range)\n let bits t = int t (Int.shift_left 1 30)\n end)\n\n let random_uniform ~state lo hi = lo + Uniform.random ~state (succ (hi - lo))\n\n let gen_uniform_incl lower_bound upper_bound =\n if lower_bound > upper_bound\n then\n raise_s\n [%message\n \"Bigint.gen_uniform_incl: bounds are crossed\"\n (lower_bound : t)\n (upper_bound : t)];\n Generator.create (fun ~size:_ ~random:state ->\n random_uniform ~state lower_bound upper_bound)\n ;;\n\n let gen_incl lower_bound upper_bound =\n Generator.weighted_union\n [ 0.05, Generator.return lower_bound\n ; 0.05, Generator.return upper_bound\n ; 0.9, gen_uniform_incl lower_bound upper_bound\n ]\n ;;\n\n let min_represented_by_n_bits n =\n if Int.equal n 0 then zero else shift_left one (Int.pred n)\n ;;\n\n let max_represented_by_n_bits n = pred (shift_left one n)\n\n let gen_log_uniform_incl lower_bound upper_bound =\n if lower_bound < zero || lower_bound > upper_bound\n then\n raise_s\n [%message\n \"Bigint.gen_log_incl: invalid bounds\" (lower_bound : t) (upper_bound : t)];\n let min_bits = Z.numbits lower_bound in\n let max_bits = Z.numbits upper_bound in\n let%bind bits = Int.gen_uniform_incl min_bits max_bits in\n gen_uniform_incl\n (max lower_bound (min_represented_by_n_bits bits))\n (min upper_bound (max_represented_by_n_bits bits))\n ;;\n\n let gen_log_incl lower_bound upper_bound =\n Generator.weighted_union\n [ 0.05, Generator.return lower_bound\n ; 0.05, Generator.return upper_bound\n ; 0.9, gen_log_uniform_incl lower_bound upper_bound\n ]\n ;;\n\n let gen_positive =\n let%bind extra_bytes = Generator.size in\n let num_bytes = Int.succ extra_bytes in\n let num_bits = Int.( * ) num_bytes 8 in\n gen_log_uniform_incl one (pred (shift_left one num_bits))\n ;;\n\n let gen_negative = Generator.map gen_positive ~f:neg\n\n let quickcheck_generator =\n Generator.weighted_union\n [ 0.45, gen_positive; 0.1, Generator.return zero; 0.45, gen_negative ]\n ;;\n\n let quickcheck_observer =\n Quickcheck.Observer.create (fun t ~size:_ ~hash -> hash_fold_t hash t)\n ;;\n\n let quickcheck_shrinker = Quickcheck.Shrinker.empty ()\nend\n\ninclude For_quickcheck\n\nmodule Hex = struct\n type nonrec t = t [@@deriving bin_io, typerep]\n\n module M = Base.Int_conversions.Make_hex (struct\n type nonrec t = t [@@deriving hash, compare]\n\n let to_string i = Z.format \"%x\" i\n\n let char_is_hex_digit = function\n | '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' -> true\n | _ -> false\n ;;\n\n let of_hex_string_no_underscores str = Z.of_string_base 16 str\n\n let of_string str =\n of_string_base\n str\n ~name:\"Hex.of_string\"\n ~char_is_digit:char_is_hex_digit\n ~of_string_no_underscores:of_hex_string_no_underscores\n ;;\n\n let ( < ) = ( < )\n let neg = neg\n let zero = zero\n let module_name = module_name ^ \".Hex\"\n end)\n\n include (\n M.Hex :\n module type of struct\n include M.Hex\n end\n with type t := t)\nend\n","open Core_kernel\n\ntype 'f t =\n | Constant of 'f\n | Var of int\n | Add of 'f t * 'f t\n | Scale of 'f * 'f t\n[@@deriving sexp]\n\ntype 'f cvar = 'f t [@@deriving sexp]\n\nlet to_constant_and_terms ~equal ~add ~mul ~zero ~one =\n let rec go scale constant terms = function\n | Constant c ->\n (add constant (mul scale c), terms)\n | Var v ->\n (constant, (scale, v) :: terms)\n | Scale (s, t) ->\n go (mul s scale) constant terms t\n | Add (x1, x2) ->\n let c1, terms1 = go scale constant terms x1 in\n go scale c1 terms1 x2\n in\n fun t ->\n let c, ts = go one zero [] t in\n let c = if equal c zero then None else Some c in\n (c, ts)\n\nmodule Unsafe = struct\n let of_index v = Var v\nend\n\nmodule Make (Field : Snarky_intf.Field.Extended) = struct\n type t = Field.t cvar [@@deriving sexp]\n\n let length _ = failwith \"TODO\"\n\n module Unsafe = Unsafe\n\n let scratch = Field.of_int 0\n\n let eval (`Return_values_will_be_mutated context) t0 =\n let open Field in\n let res = of_int 0 in\n let rec go ~can_mutate_scale scale = function\n | Constant c when can_mutate_scale ->\n scale *= c ; res += scale\n | Constant c ->\n Mutable.copy ~over:scratch c ;\n scratch *= scale ;\n res += scratch\n | Var v ->\n let v = context v in\n v *= scale ; res += v\n | Scale (s, t) when can_mutate_scale ->\n scale *= s ;\n go scale ~can_mutate_scale t\n | Scale (s, t) ->\n go (mul s scale) ~can_mutate_scale:true t\n | Add (t1, t2) ->\n go scale ~can_mutate_scale:false t1 ;\n go scale ~can_mutate_scale t2\n in\n go one ~can_mutate_scale:false t0 ;\n res\n\n let constant c = Constant c\n\n let to_constant_and_terms =\n let rec go scale constant terms = function\n | Constant c ->\n (Field.add constant (Field.mul scale c), terms)\n | Var v ->\n (constant, (scale, v) :: terms)\n | Scale (s, t) ->\n go (Field.mul s scale) constant terms t\n | Add (x1, x2) ->\n let c1, terms1 = go scale constant terms x1 in\n go scale c1 terms1 x2\n in\n fun t ->\n let c, ts = go Field.one Field.zero [] t in\n let c = if Field.equal c Field.zero then None else Some c in\n (c, ts)\n\n let add x y =\n match (x, y) with\n | Constant x, _ when Field.(equal x zero) ->\n y\n | _, Constant y when Field.(equal y zero) ->\n x\n | Constant x, Constant y ->\n Constant (Field.add x y)\n | _, _ ->\n Add (x, y)\n\n let scale x s =\n if Field.(equal s zero) then Constant Field.zero\n else if Field.(equal s one) then x\n else\n match x with\n | Constant x ->\n Constant (Field.mul x s)\n | Scale (sx, x) ->\n Scale (Field.mul sx s, x)\n | _ ->\n Scale (s, x)\n\n let neg_one = Field.(sub zero one)\n\n let sub t1 t2 =\n match (t1, t2) with\n | Constant x, Constant y ->\n Constant (Field.sub x y)\n | _ ->\n add t1 (scale t2 neg_one)\n\n let linear_combination (terms : (Field.t * t) list) : t =\n List.fold terms ~init:(constant Field.zero) ~f:(fun acc (c, t) ->\n add acc (scale t c) )\n\n let sum vs = linear_combination (List.map vs ~f:(fun v -> (Field.one, v)))\n\n let ( + ) = add\n\n let ( - ) = sub\n\n let ( * ) c x = scale x c\n\n let negate x = scale x neg_one\n\n let to_json x =\n let singleton = Map.singleton (module Int) in\n let join = Map.merge_skewed ~combine:(fun ~key:_ -> Field.add) in\n let rec go scale = function\n | Constant f ->\n singleton 0 (Field.mul scale f)\n | Var i ->\n singleton i scale\n | Add (x, y) ->\n join (go scale x) (go scale y)\n | Scale (s, x) ->\n go Field.(scale * s) x\n in\n let map = go Field.one x in\n `Assoc\n (List.filter_map (Map.to_alist map) ~f:(fun (i, f) ->\n if Field.(equal f zero) then None\n else Some (Int.to_string i, `String (Field.to_string f)) ) )\nend\n","open Base\n\ntype ('var, 'field) basic = ..\n\nmodule Conv (F : sig\n type (_, _) t\nend) =\nstruct\n type t =\n { to_basic : 'v 'f. ('v, 'f) F.t -> ('v, 'f) basic\n ; of_basic : 'v 'f. ('v, 'f) basic -> ('v, 'f) F.t\n }\nend\n\nmodule type S = sig\n type (_, _) t [@@deriving sexp]\n\n val map : ('a, 'f) t -> f:('a -> 'b) -> ('b, 'f) t\n\n (* TODO: Try making this a functor and seeing how it affects performance *)\n val eval :\n (module Snarky_intf.Field.S with type t = 'f)\n -> ('v -> 'f)\n -> ('v, 'f) t\n -> bool\nend\n\nmodule Basic = struct\n type ('v, 'f) t = ('v, 'f) basic\n\n module type S_with_conv = sig\n include S\n\n val to_basic : ('v, 'f) t -> ('v, 'f) basic\n\n val of_basic : ('v, 'f) basic -> ('v, 'f) t\n end\n\n module Entry = struct\n type t = (module S_with_conv)\n end\n\n let cases : Entry.t list ref = ref []\n\n let add_case m = cases := m :: !cases\n\n let case f =\n List.find_map_exn !cases ~f:(fun m -> Option.try_with (fun () -> f m))\n\n let sexp_of_t f1 f2 t =\n case (fun (module M) -> M.sexp_of_t f1 f2 (M.of_basic t))\n\n let t_of_sexp f1 f2 s =\n case (fun (module M) -> M.to_basic (M.t_of_sexp f1 f2 s))\n\n let eval (type f) (fm : (module Snarky_intf.Field.S with type t = f))\n (f : 'v -> f) (t : ('v, f) basic) : bool =\n case (fun (module M) -> M.eval fm f (M.of_basic t))\n\n let map t ~f = case (fun (module M) -> M.to_basic (M.map (M.of_basic t) ~f))\nend\n\nmodule Add_kind (C : S) : sig\n type ('v, 'f) basic += T of ('v, 'f) C.t\nend = struct\n type ('v, 'f) basic += T of ('v, 'f) C.t\n\n module M = struct\n include C\n\n let to_basic x = T x\n\n let of_basic = function T x -> x | _ -> failwith \"different constructor\"\n end\n\n let () = Basic.add_case (module M)\nend\n\n(* We special case these for compatibility with existing code. *)\ntype ('var, _) basic +=\n | Boolean of 'var\n | Equal of 'var * 'var\n | Square of 'var * 'var\n | R1CS of 'var * 'var * 'var\n\nlet basic_of_sexp = Basic.t_of_sexp\n\nlet sexp_of_basic = Basic.sexp_of_t\n\nlet () =\n let unhandled s = Core_kernel.failwithf \"%s: non-basic constraint\" s () in\n let module Essential = struct\n type 'var t =\n | Boolean of 'var\n | Equal of 'var * 'var\n | Square of 'var * 'var\n | R1CS of 'var * 'var * 'var\n [@@deriving sexp]\n\n let to_basic : 'v t -> ('v, _) basic = function\n | Boolean x ->\n Boolean x\n | Equal (x, y) ->\n Equal (x, y)\n | Square (x, y) ->\n Square (x, y)\n | R1CS (x, y, z) ->\n R1CS (x, y, z)\n\n let of_basic : ('v, _) basic -> 'v t = function\n | Boolean x ->\n Boolean x\n | Equal (x, y) ->\n Equal (x, y)\n | Square (x, y) ->\n Square (x, y)\n | R1CS (x, y, z) ->\n R1CS (x, y, z)\n | _ ->\n unhandled \"of_basic\"\n end in\n let module M = struct\n type ('v, 'f) t = ('v, 'f) basic\n\n let sexp_of_t f _ t = Essential.(sexp_of_t f (of_basic t))\n\n let t_of_sexp f _ s = Essential.(to_basic (t_of_sexp f s))\n\n let of_basic = Fn.id\n\n let to_basic = Fn.id\n\n let map t ~f =\n match t with\n | Boolean v ->\n Boolean (f v)\n | Equal (v1, v2) ->\n Equal (f v1, f v2)\n | R1CS (v1, v2, v3) ->\n R1CS (f v1, f v2, f v3)\n | Square (a, c) ->\n Square (f a, f c)\n | _ ->\n unhandled \"map\"\n\n let eval (type f v) (module Field : Snarky_intf.Field.S with type t = f)\n (get_value : v -> f) (t : (v, f) basic) : bool =\n match t with\n | Boolean v ->\n let x = get_value v in\n Field.(equal x zero || equal x one)\n | Equal (v1, v2) ->\n Field.equal (get_value v1) (get_value v2)\n | R1CS (v1, v2, v3) ->\n Field.(equal (mul (get_value v1) (get_value v2)) (get_value v3))\n | Square (a, c) ->\n Field.equal (Field.square (get_value a)) (get_value c)\n | _ ->\n unhandled \"eval\"\n end in\n Basic.add_case (module M)\n\ntype ('v, 'f) basic_with_annotation =\n { basic : ('v, 'f) basic; annotation : string option }\n[@@deriving sexp]\n\ntype ('v, 'f) t = ('v, 'f) basic_with_annotation [@@deriving sexp]\n\nmodule T = struct\n let create_basic ?label basic = { basic; annotation = label }\n\n let override_label { basic; annotation = a } label_opt =\n { basic\n ; annotation = (match label_opt with Some x -> Some x | None -> a)\n }\n\n let equal ?label x y = create_basic ?label (Equal (x, y))\n\n let boolean ?label x = create_basic ?label (Boolean x)\n\n let r1cs ?label a b c = create_basic ?label (R1CS (a, b, c))\n\n let square ?label a c = create_basic ?label (Square (a, c))\n\n let annotation (t : _ t) =\n match t.annotation with Some str -> str | None -> \"\"\nend\n\ninclude T\n","open Core_kernel\nmodule Bignum_bigint = Bigint\n\n(** Yojson-compatible JSON type. *)\ntype 'a json =\n [> `String of string\n | `Assoc of (string * 'a json) list\n | `List of 'a json list ]\n as\n 'a\n\nmodule type S = sig\n module Field : Snarky_intf.Field.Full\n\n module Bigint : sig\n include Snarky_intf.Bigint_intf.Extended with type field := Field.t\n\n val of_bignum_bigint : Bignum_bigint.t -> t\n\n val to_bignum_bigint : t -> Bignum_bigint.t\n end\n\n module Cvar : sig\n type t = Field.t Cvar.t [@@deriving sexp]\n\n val length : t -> int\n\n module Unsafe : sig\n val of_index : int -> t\n end\n\n val eval :\n [ `Return_values_will_be_mutated of int -> Field.t ] -> t -> Field.t\n\n val constant : Field.t -> t\n\n val to_constant_and_terms : t -> Field.t option * (Field.t * int) list\n\n val add : t -> t -> t\n\n val negate : t -> t\n\n val scale : t -> Field.t -> t\n\n val sub : t -> t -> t\n\n val linear_combination : (Field.t * t) list -> t\n\n val sum : t list -> t\n\n val ( + ) : t -> t -> t\n\n val ( - ) : t -> t -> t\n\n val ( * ) : Field.t -> t -> t\n\n val var_indices : t -> int list\n\n val to_constant : t -> Field.t option\n end\n\n module R1CS_constraint_system :\n Backend_intf.Constraint_system_intf with module Field := Field\n\n module Constraint : sig\n type t = (Cvar.t, Field.t) Constraint.t [@@deriving sexp]\n\n type 'k with_constraint_args = ?label:string -> 'k\n\n val boolean : (Cvar.t -> t) with_constraint_args\n\n val equal : (Cvar.t -> Cvar.t -> t) with_constraint_args\n\n val r1cs : (Cvar.t -> Cvar.t -> Cvar.t -> t) with_constraint_args\n\n val square : (Cvar.t -> Cvar.t -> t) with_constraint_args\n\n val annotation : t -> string\n\n val eval :\n (Cvar.t, Field.t) Constraint.basic_with_annotation\n -> (Cvar.t -> Field.t)\n -> bool\n end\nend\n\nmodule Make (Backend : Backend_intf.S) :\n S\n with type Field.t = Backend.Field.t\n and type Field.Vector.t = Backend.Field.Vector.t\n and type Bigint.t = Backend.Bigint.t\n and type R1CS_constraint_system.t = Backend.R1CS_constraint_system.t =\nstruct\n open Backend\n\n module Bigint = struct\n include Bigint\n\n let of_bignum_bigint n = of_decimal_string (Bignum_bigint.to_string n)\n\n let to_bignum_bigint n =\n let rec go i two_to_the_i acc =\n if i = Field.size_in_bits then acc\n else\n let acc' =\n if test_bit n i then Bignum_bigint.(acc + two_to_the_i) else acc\n in\n go (i + 1) Bignum_bigint.(two_to_the_i + two_to_the_i) acc'\n in\n go 0 Bignum_bigint.one Bignum_bigint.zero\n end\n\n module Field = struct\n include Field\n\n let size = Bigint.to_bignum_bigint Backend.field_size\n\n let inv x = if equal x zero then failwith \"Field.inv: zero\" else inv x\n\n (* TODO: Optimize *)\n let div x y = mul x (inv y)\n\n let negate x = sub zero x\n\n let unpack x =\n let n = Bigint.of_field x in\n List.init size_in_bits ~f:(fun i -> Bigint.test_bit n i)\n\n let project_reference =\n let rec go x acc = function\n | [] ->\n acc\n | b :: bs ->\n go (Field.add x x) (if b then Field.add acc x else acc) bs\n in\n fun bs -> go Field.one Field.zero bs\n\n let _project bs =\n (* todo: 32-bit and ARM support. basically this code needs to always match the loop in the C++ of_data implementation. *)\n assert (Sys.word_size = 64 && not Sys.big_endian) ;\n let chunks_of n xs =\n List.groupi ~break:(fun i _ _ -> Int.equal (i mod n) 0) xs\n in\n let chunks64 = chunks_of 64 bs in\n let z = Char.of_int_exn 0 in\n let arr =\n Bigstring.init (8 * Backend.Bigint.length_in_bytes) ~f:(fun _ -> z)\n in\n List.(\n iteri ~f:(fun i elt ->\n Bigstring.set_int64_t_le arr ~pos:(i * 8)\n Int64.(\n foldi ~init:zero\n ~f:(fun i acc el ->\n acc + if el then shift_left one i else zero )\n elt) ))\n chunks64 ;\n Backend.Bigint.(of_data arr ~bitcount:(List.length bs) |> to_field)\n\n let project = project_reference\n\n let compare t1 t2 = Bigint.(compare (of_field t1) (of_field t2))\n\n let hash_fold_t s x =\n Bignum_bigint.hash_fold_t s Bigint.(to_bignum_bigint (of_field x))\n\n let hash = Hash.of_fold hash_fold_t\n\n let to_bignum_bigint = Fn.compose Bigint.to_bignum_bigint Bigint.of_field\n\n let of_bignum_bigint = Fn.compose Bigint.to_field Bigint.of_bignum_bigint\n\n let sexp_of_t = Fn.compose Bignum_bigint.sexp_of_t to_bignum_bigint\n\n let t_of_sexp = Fn.compose of_bignum_bigint Bignum_bigint.t_of_sexp\n\n let to_string = Fn.compose Bignum_bigint.to_string to_bignum_bigint\n\n let of_string = Fn.compose of_bignum_bigint Bignum_bigint.of_string\n\n let%test_unit \"project correctness\" =\n Quickcheck.test\n Quickcheck.Generator.(\n small_positive_int >>= fun x -> list_with_length x bool)\n ~f:(fun bs ->\n [%test_eq: string]\n (project bs |> to_string)\n (project_reference bs |> to_string) )\n\n let ( + ) = add\n\n let ( * ) = mul\n\n let ( - ) = sub\n\n let ( / ) = div\n end\n\n module Cvar = struct\n include Cvar.Make (Field)\n\n let var_indices t =\n let _, terms = to_constant_and_terms t in\n List.map ~f:(fun (_, v) -> v) terms\n\n let to_constant : t -> Field.t option = function\n | Constant x ->\n Some x\n | _ ->\n None\n end\n\n module Constraint = struct\n open Constraint\n include Constraint.T\n\n type 'k with_constraint_args = ?label:string -> 'k\n\n type t = (Cvar.t, Field.t) Constraint.t [@@deriving sexp]\n\n let m = (module Field : Snarky_intf.Field.S with type t = Field.t)\n\n let eval { basic; _ } get_value = Constraint.Basic.eval m get_value basic\n end\n\n module R1CS_constraint_system = R1CS_constraint_system\nend\n","open Core_kernel\nmodule Constraint0 = Constraint\n\nlet stack_to_string = String.concat ~sep:\"\\n\"\n\nlet eval_constraints = ref true\n\nlet eval_constraints_ref = eval_constraints\n\nmodule Simple = struct\n module Types = struct\n module Checked = struct\n type ('a, 'f) t =\n | Pure of 'a\n | Function of ('f Run_state.t -> 'f Run_state.t * 'a)\n end\n\n module Typ = struct\n include Types.Typ.T\n\n type ('var, 'value, 'f) t = ('var, 'value, 'f, (unit, 'f) Checked.t) typ\n end\n\n module Provider = struct\n include Types.Provider.T\n\n type ('a, 'f) t =\n (('a Request.t, 'f) As_prover0.t, ('a, 'f) As_prover0.t) provider\n end\n end\n\n type 'f field = 'f\n\n type ('a, 'f) t = ('a, 'f field) Types.Checked.t\n\n let eval (t : ('a, 'f) t) : 'f field Run_state.t -> 'f field Run_state.t * 'a\n =\n match t with Pure a -> fun s -> (s, a) | Function g -> g\n\n include Monad_let.Make2 (struct\n type ('a, 'f) t = ('a, 'f field) Types.Checked.t\n\n let return x : _ t = Pure x\n\n let map =\n `Custom\n (fun (x : _ t) ~f : _ t ->\n match x with\n | Pure a ->\n Pure (f a)\n | Function g ->\n Function\n (fun s ->\n let s, a = g s in\n (s, f a) ) )\n\n let bind (x : _ t) ~f : _ t =\n match x with\n | Pure a ->\n f a\n | Function g ->\n Function\n (fun s ->\n let s, a = g s in\n eval (f a) s )\n end)\nend\n\nmodule Make_checked\n (Backend : Backend_extended.S)\n (As_prover : As_prover_intf.Basic with type 'f field := Backend.Field.t) =\nstruct\n type run_state = Backend.Field.t Run_state.t\n\n module Types = struct\n module Checked = struct\n type ('a, 'f) t = ('a, Backend.Field.t) Simple.Types.Checked.t\n end\n\n module Typ = struct\n include Types.Typ.T\n\n type ('var, 'value, 'f) t = ('var, 'value, 'f, (unit, 'f) Checked.t) typ\n end\n\n module Provider = struct\n include Types.Provider.T\n\n type ('a, 'f) t =\n (('a Request.t, 'f) As_prover.t, ('a, 'f) As_prover.t) provider\n end\n end\n\n type 'f field = Backend.Field.t\n\n include Types.Checked\n\n let eval : ('a, 'f) t -> run_state -> run_state * 'a = Simple.eval\n\n include Monad_let.Make2 (struct\n include Types.Checked\n\n let map = `Custom Simple.map\n\n let bind = Simple.bind\n\n let return = Simple.return\n end)\n\n open Constraint\n open Backend\n\n let get_value (t : Field.t Run_state.t) : Cvar.t -> Field.t =\n let get_one i = Run_state.get_variable_value t i in\n Cvar.eval (`Return_values_will_be_mutated get_one)\n\n let run_as_prover x state =\n match (x, Run_state.has_witness state) with\n | Some x, true ->\n let old = Run_state.as_prover state in\n Run_state.set_as_prover state true ;\n let y = As_prover.run x (get_value state) in\n Run_state.set_as_prover state old ;\n (state, Some y)\n | _, _ ->\n (state, None)\n\n let as_prover x : _ Simple.t =\n Function\n (fun s ->\n let s', (_ : unit option) = run_as_prover (Some x) s in\n (s', ()) )\n\n let mk_lazy x : _ Simple.t =\n Function\n (fun s ->\n let old_stack = Run_state.stack s in\n ( s\n , Lazy.from_fun (fun () ->\n let stack = Run_state.stack s in\n\n (* Add a label to indicate that the new stack is the point at which\n this was forced. When printed for errors, this will split the\n stack into\n\n ...\n stack to lazy\n ...\n\n Lazy value forced at:\n ...\n stack to lazy forcing point\n ...\n *)\n let label = \"\\nLazy value forced at:\" in\n let _s', y =\n Simple.eval (x ())\n (Run_state.set_stack s (old_stack @ (label :: stack)))\n in\n y ) ) )\n\n let with_label lab t : _ Simple.t =\n Function\n (fun s ->\n let stack = Run_state.stack s in\n Option.iter (Run_state.log_constraint s) ~f:(fun f ->\n f ~at_label_boundary:(`Start, lab) None ) ;\n let s', y = Simple.eval (t ()) (Run_state.set_stack s (lab :: stack)) in\n Option.iter (Run_state.log_constraint s) ~f:(fun f ->\n f ~at_label_boundary:(`End, lab) None ) ;\n (Run_state.set_stack s' stack, y) )\n\n let log_constraint { basic; _ } s =\n match basic with\n | Boolean var ->\n Format.(asprintf \"Boolean %s\" (Field.to_string (get_value s var)))\n | Equal (var1, var2) ->\n Format.(\n asprintf \"Equal %s %s\"\n (Field.to_string (get_value s var1))\n (Field.to_string (get_value s var2)))\n | Square (var1, var2) ->\n Format.(\n asprintf \"Square %s %s\"\n (Field.to_string (get_value s var1))\n (Field.to_string (get_value s var2)))\n | R1CS (var1, var2, var3) ->\n Format.(\n asprintf \"R1CS %s %s %s\"\n (Field.to_string (get_value s var1))\n (Field.to_string (get_value s var2))\n (Field.to_string (get_value s var3)))\n | _ ->\n Format.asprintf\n !\"%{sexp:(Field.t, Field.t) Constraint0.basic}\"\n (Constraint0.Basic.map basic ~f:(get_value s))\n\n let add_constraint ~stack ({ basic; annotation } : Constraint.t)\n (Constraint_system.T ((module C), system) : Field.t Constraint_system.t) =\n let label = Option.value annotation ~default:\"\" in\n C.add_constraint system basic ~label:(stack_to_string (label :: stack))\n\n let add_constraint c : _ Simple.t =\n Function\n (fun s ->\n if Run_state.as_prover s then\n (* Don't add constraints as the prover, or the constraint system won't match! *)\n (s, ())\n else (\n Option.iter (Run_state.log_constraint s) ~f:(fun f -> f (Some c)) ;\n if\n Run_state.eval_constraints s\n && !eval_constraints\n && not (Constraint.eval c (get_value s))\n then\n failwithf\n \"Constraint unsatisfied (unreduced):\\n\\\n %s\\n\\\n %s\\n\\n\\\n Constraint:\\n\\\n %s\\n\\\n Data:\\n\\\n %s\"\n (Constraint.annotation c)\n (stack_to_string (Run_state.stack s))\n (Sexp.to_string (Constraint.sexp_of_t c))\n (log_constraint c s) () ;\n if not (Run_state.as_prover s) then\n Option.iter (Run_state.system s) ~f:(fun system ->\n add_constraint ~stack:(Run_state.stack s) c system ) ;\n (s, ()) ) )\n\n let with_handler h t : _ Simple.t =\n Function\n (fun s ->\n let handler = Run_state.handler s in\n let s', y =\n Simple.eval (t ())\n (Run_state.set_handler s (Request.Handler.push handler h))\n in\n (Run_state.set_handler s' handler, y) )\n\n let exists\n (Types.Typ.Typ\n { Types.Typ.var_of_fields\n ; value_to_fields\n ; size_in_field_elements\n ; check\n ; constraint_system_auxiliary\n ; _\n } :\n (_, _, _, _ Simple.t) Types.Typ.typ ) p : _ Simple.t =\n Function\n (fun s ->\n if Run_state.has_witness s then (\n let old = Run_state.as_prover s in\n Run_state.set_as_prover s true ;\n let value =\n As_prover.Provider.run p (Run_state.stack s) (get_value s)\n (Run_state.handler s)\n in\n Run_state.set_as_prover s old ;\n let var =\n let store_value =\n if Run_state.as_prover s then\n (* If we're nested in a prover block, create constants instead of\n storing.\n *)\n Cvar.constant\n else Run_state.store_field_elt s\n in\n let fields, aux = value_to_fields value in\n let field_vars = Array.map ~f:store_value fields in\n var_of_fields (field_vars, aux)\n in\n (* TODO: Push a label onto the stack here *)\n let s, () = Simple.eval (check var) s in\n (s, { Handle.var; value = Some value }) )\n else\n let var =\n var_of_fields\n ( Array.init size_in_field_elements ~f:(fun _ ->\n Run_state.alloc_var s () )\n , constraint_system_auxiliary () )\n in\n (* TODO: Push a label onto the stack here *)\n let s, () = Simple.eval (check var) s in\n (s, { Handle.var; value = None }) )\n\n let next_auxiliary () : _ Simple.t =\n Function (fun s -> (s, Run_state.next_auxiliary s))\n\n let direct f : _ Simple.t = Function f\n\n let constraint_count ?(weight = Fn.const 1)\n ?(log = fun ?start:_ _lab _pos -> ()) (t : unit -> _ Simple.t) =\n (* TODO: Integrate log with log_constraint *)\n let count = ref 0 in\n let log_constraint ?at_label_boundary c =\n ( match at_label_boundary with\n | None ->\n ()\n | Some (pos, lab) ->\n let start = match pos with `Start -> true | _ -> false in\n log ~start lab !count ) ;\n count := !count + Option.value_map ~default:0 ~f:weight c\n in\n let state =\n Run_state.make ~num_inputs:0 ~input:Run_state.Vector.null\n ~next_auxiliary:(ref 1) ~aux:Run_state.Vector.null\n ~eval_constraints:false ~log_constraint ~with_witness:false ()\n in\n let _ = Simple.eval (t ()) state in\n !count\nend\n\nmodule type Run_extras = sig\n type field\n\n type cvar\n\n module Types : Types.Types\n\n val get_value : field Run_state.t -> cvar -> field\n\n val run_as_prover :\n ('a, field) As_prover0.t option\n -> field Run_state.t\n -> field Run_state.t * 'a option\nend\n\nmodule Make (Backend : Backend_extended.S) = struct\n open Backend\n\n type 'f field = 'f\n\n let constraint_logger = ref None\n\n let set_constraint_logger f = constraint_logger := Some f\n\n let clear_constraint_logger () = constraint_logger := None\n\n module Checked_runner = Make_checked (Backend) (As_prover0)\n\n type run_state = Checked_runner.run_state\n\n type state = run_state\n\n type ('a, 't) run = 't -> run_state -> run_state * 'a\n\n include (\n Checked_runner :\n sig\n include\n Checked_intf.Basic\n with module Types := Checked_runner.Types\n with type 'f field := 'f Checked_runner.field\n\n include\n Run_extras\n with module Types := Checked_runner.Types\n with type field := Backend.Field.t\n and type cvar := Backend.Cvar.t\n end )\n\n module Types = Checked_runner.Types\n\n let run = Simple.eval\n\n let dummy_vector = Run_state.Vector.null\n\n let fake_state next_auxiliary stack =\n Run_state.make ~num_inputs:0 ~input:Run_state.Vector.null ~next_auxiliary\n ~aux:Run_state.Vector.null ~eval_constraints:false ~stack\n ~with_witness:false ()\n\n module State = struct\n let make ~num_inputs ~input ~next_auxiliary ~aux ?system\n ?(eval_constraints = !eval_constraints_ref) ?handler ~with_witness\n ?log_constraint () =\n let log_constraint =\n match log_constraint with\n | Some _ ->\n log_constraint\n | None ->\n !constraint_logger\n in\n (* We can't evaluate the constraints if we are not computing over a value. *)\n let eval_constraints = eval_constraints && with_witness in\n Option.iter\n (system : R1CS_constraint_system.t option)\n ~f:(fun system ->\n R1CS_constraint_system.set_primary_input_size system num_inputs ) ;\n let system =\n Option.map system ~f:(fun sys ->\n let module M = struct\n module Field = struct\n type nonrec t = Field.t\n end\n\n include R1CS_constraint_system\n end in\n Constraint_system.T ((module M), sys) )\n in\n Run_state.make ~num_inputs ~input ~next_auxiliary ~aux ?system\n ~eval_constraints ?log_constraint ?handler ~with_witness ()\n end\nend\n\nmodule type S = sig\n include Run_extras\n\n type constr\n\n type r1cs\n\n val set_constraint_logger :\n (?at_label_boundary:[ `Start | `End ] * string -> constr -> unit) -> unit\n\n val clear_constraint_logger : unit -> unit\n\n type run_state = field Run_state.t\n\n type state = run_state\n\n type ('a, 't) run = 't -> run_state -> run_state * 'a\n\n val run : ('a, field) Types.Checked.t -> run_state -> run_state * 'a\n\n module State : sig\n val make :\n num_inputs:int\n -> input:field Run_state.Vector.t\n -> next_auxiliary:int ref\n -> aux:field Run_state.Vector.t\n -> ?system:r1cs\n -> ?eval_constraints:bool\n -> ?handler:Request.Handler.t\n -> with_witness:bool\n -> ?log_constraint:\n ( ?at_label_boundary:[ `End | `Start ] * string\n -> (field Cvar.t, field) Constraint.t option\n -> unit )\n -> unit\n -> field Run_state.t\n end\nend\n","open Core_kernel\nmodule Cvar0 = Cvar\nmodule Runner = Checked_runner\n\nlet set_eval_constraints b = Runner.eval_constraints := b\n\nmodule Make\n (Backend : Backend_extended.S)\n (Checked : Checked_intf.Extended with type field = Backend.Field.t)\n (As_prover : As_prover0.Extended with type field := Backend.Field.t)\n (Runner : Runner.S\n with module Types := Checked.Types\n with type field := Backend.Field.t\n and type cvar := Backend.Cvar.t\n and type constr := Backend.Constraint.t option\n and type r1cs := Backend.R1CS_constraint_system.t) =\nstruct\n open Backend\n\n open Runners.Make (Backend) (Checked) (As_prover) (Runner)\n\n module Typ = struct\n include Types.Typ.T\n module T = Typ.Make (Checked_intf.Unextend (Checked))\n include T.T\n\n type ('var, 'value) t = ('var, 'value, Field.t) T.t\n\n let unit : (unit, unit) t = unit ()\n\n let field : (Cvar.t, Field.t) t = field ()\n end\n\n open (\n Checked :\n Checked_intf.Extended\n with module Types := Checked.Types\n with type field := field )\n\n (* [equal_constraints z z_inv r] asserts that\n if z = 0 then r = 1, or\n if z <> 0 then r = 0 and z * z_inv = 1\n *)\n let equal_constraints (z : Cvar.t) (z_inv : Cvar.t) (r : Cvar.t) =\n Checked.assert_all\n [ Constraint.r1cs ~label:\"equals_1\" z_inv z Cvar.(constant Field.one - r)\n ; Constraint.r1cs ~label:\"equals_2\" r z (Cvar.constant Field.zero)\n ]\n\n (* [equal_vars z] computes [(r, z_inv)] that satisfy the constraints in\n [equal_constraints z z_inv r].\n\n In particular, [r] is [1] if [z = 0] and [0] otherwise.\n *)\n let equal_vars (z : Cvar.t) : (Field.t * Field.t) As_prover.t =\n let open As_prover.Let_syntax in\n let%map z = As_prover.read_var z in\n if Field.equal z Field.zero then (Field.one, Field.zero)\n else (Field.zero, Field.inv z)\n\n let constant (Typ typ : _ Typ.t) x =\n let fields, aux = typ.value_to_fields x in\n let field_vars = Array.map fields ~f:(fun x -> Cvar0.Constant x) in\n typ.var_of_fields (field_vars, aux)\n\n let equal (x : Cvar.t) (y : Cvar.t) : Cvar.t Boolean.t Checked.t =\n match (x, y) with\n | Constant x, Constant y ->\n Checked.return\n (Boolean.Unsafe.create\n (Cvar.constant\n (if Field.equal x y then Field.one else Field.zero) ) )\n | _ ->\n let z = Cvar.(x - y) in\n let%bind r, inv =\n Checked.exists Typ.(tuple2 field field) ~compute:(equal_vars z)\n in\n let%map () = equal_constraints z inv r in\n Boolean.Unsafe.create r\n\n let mul ?(label = \"Checked.mul\") (x : Cvar.t) (y : Cvar.t) =\n match (x, y) with\n | Constant x, Constant y ->\n return (Cvar.constant (Field.mul x y))\n | Constant x, _ ->\n return (Cvar.scale y x)\n | _, Constant y ->\n return (Cvar.scale x y)\n | _, _ ->\n with_label label (fun () ->\n let open Let_syntax in\n let%bind z =\n Checked.exists Typ.field\n ~compute:As_prover.(map2 (read_var x) (read_var y) ~f:Field.mul)\n in\n let%map () = assert_r1cs x y z in\n z )\n\n let square ?(label = \"Checked.square\") (x : Cvar.t) =\n match x with\n | Constant x ->\n return (Cvar.constant (Field.square x))\n | _ ->\n with_label label (fun () ->\n let open Let_syntax in\n let%bind z =\n exists Typ.field\n ~compute:As_prover.(map (read_var x) ~f:Field.square)\n in\n let%map () = assert_square x z in\n z )\n\n (* We get a better stack trace by failing at the call to is_satisfied, so we\n put a bogus value for the inverse to make the constraint system unsat if\n x is zero. *)\n let inv ?(label = \"Checked.inv\") (x : Cvar.t) =\n match x with\n | Constant x ->\n return (Cvar.constant (Field.inv x))\n | _ ->\n with_label label (fun () ->\n let open Let_syntax in\n let%bind x_inv =\n exists Typ.field\n ~compute:\n As_prover.(\n map (read_var x) ~f:(fun x ->\n if Field.(equal zero x) then Field.zero\n else Backend.Field.inv x ))\n in\n let%map () =\n assert_r1cs ~label:\"field_inverse\" x x_inv\n (Cvar.constant Field.one)\n in\n x_inv )\n\n let div ?(label = \"Checked.div\") (x : Cvar.t) (y : Cvar.t) =\n match (x, y) with\n | Constant x, Constant y ->\n return (Cvar.constant (Field.( / ) x y))\n | _ ->\n with_label label (fun () ->\n let open Let_syntax in\n let%bind y_inv = inv y in\n mul x y_inv )\n\n let%snarkydef_ if_ (b : Cvar.t Boolean.t) ~(then_ : Cvar.t) ~(else_ : Cvar.t)\n =\n let open Let_syntax in\n (* r = e + b (t - e)\n r - e = b (t - e)\n *)\n let b = (b :> Cvar.t) in\n match b with\n | Constant b ->\n if Field.(equal b one) then return then_ else return else_\n | _ -> (\n match (then_, else_) with\n | Constant t, Constant e ->\n return Cvar.((t * b) + (e * (constant Field0.one - b)))\n | _, _ ->\n let%bind r =\n exists Typ.field\n ~compute:\n (let open As_prover in\n let open Let_syntax in\n let%bind b = read_var b in\n read Typ.field\n (if Field.equal b Field.one then then_ else else_))\n in\n let%map () = assert_r1cs b Cvar.(then_ - else_) Cvar.(r - else_) in\n r )\n\n let%snarkydef_ assert_non_zero (v : Cvar.t) =\n let open Let_syntax in\n let%map _ = inv v in\n ()\n\n module Boolean = struct\n open Boolean.Unsafe\n\n type var = Cvar.t Boolean.t\n\n type value = bool\n\n let true_ : var = create (Cvar.constant Field.one)\n\n let false_ : var = create (Cvar.constant Field.zero)\n\n let not (x : var) : var = create Cvar.((true_ :> Cvar.t) - (x :> Cvar.t))\n\n let if_ b ~(then_ : var) ~(else_ : var) =\n map ~f:create (if_ b ~then_:(then_ :> Cvar.t) ~else_:(else_ :> Cvar.t))\n\n (* This is unused for now as we are not using any square constraint system based\n backends. *)\n let _and_for_square_constraint_systems (x : var) (y : var) =\n (* (x + y)^2 = 2 z + x + y\n\n x^2 + 2 x*y + y^2 = 2 z + x + y\n x + 2 x*y + y = 2 z + x + y\n 2 x*y = 2 z\n x * y = z\n *)\n let x = (x :> Cvar.t) in\n let y = (y :> Cvar.t) in\n let open Let_syntax in\n let%bind z =\n exists Typ.field\n ~compute:\n (let open As_prover in\n let open Let_syntax in\n let%map x = read_var x and y = read_var y in\n if Field.(equal one x) && Field.(equal one y) then Field.one\n else Field.zero)\n in\n let%map () =\n let x_plus_y = Cvar.add x y in\n assert_square x_plus_y Cvar.((Field.of_int 2 * z) + x_plus_y)\n in\n create z\n\n let ( && ) (x : var) (y : var) : var Checked.t =\n Checked.map ~f:create (mul (x :> Cvar.t) (y :> Cvar.t))\n\n let ( &&& ) = ( && )\n\n let ( || ) x y =\n let open Let_syntax in\n let%map both_false = (not x) && not y in\n not both_false\n\n let ( ||| ) = ( || )\n\n let any = function\n | [] ->\n return false_\n | [ b1 ] ->\n return b1\n | [ b1; b2 ] ->\n b1 || b2\n | bs ->\n let open Let_syntax in\n let%map all_zero =\n equal (Cvar.sum (bs :> Cvar.t list)) (Cvar.constant Field.zero)\n in\n not all_zero\n\n let all = function\n | [] ->\n return true_\n | [ b1 ] ->\n return b1\n | [ b1; b2 ] ->\n b1 && b2\n | bs ->\n equal\n (Cvar.constant (Field.of_int (List.length bs)))\n (Cvar.sum (bs :> Cvar.t list))\n\n let to_constant (b : var) =\n Option.map (Cvar.to_constant (b :> Cvar.t)) ~f:Field.(equal one)\n\n let var_of_value b = if b then true_ else false_\n\n let typ : (var, value) Typ.t =\n let (Typ typ) =\n Typ.field\n |> Typ.transport\n ~there:(function true -> Field.one | false -> Field.zero)\n ~back:(fun x -> if Field.equal x Field.zero then false else true)\n |> Typ.transport_var\n ~there:(fun (b : var) -> (b :> Cvar.t))\n ~back:create\n in\n Typ\n { typ with\n check =\n (fun v ->\n Checked.assert_\n (Constraint.boolean ~label:\"boolean-alloc\" (v :> Cvar.t)) )\n }\n\n let typ_unchecked : (var, value) Typ.t =\n let (Typ typ) = typ in\n Typ { typ with check = (fun _ -> Checked.return ()) }\n\n let%test_unit \"all\" =\n let gen =\n let open Quickcheck.Generator in\n let open Let_syntax in\n let%bind length = small_positive_int in\n list_with_length length bool\n in\n Quickcheck.test gen ~sexp_of:[%sexp_of: bool list] ~f:(fun x ->\n let r =\n run_and_check\n (Checked.map ~f:(As_prover.read typ)\n (all (List.map ~f:(constant typ_unchecked) x)) )\n |> Or_error.ok_exn\n in\n [%test_eq: bool] r (List.for_all x ~f:Fn.id) )\n\n let ( lxor ) b1 b2 =\n match (to_constant b1, to_constant b2) with\n | Some b1, Some b2 ->\n return (constant typ (Caml.not (Bool.equal b1 b2)))\n | Some true, None ->\n return (not b2)\n | None, Some true ->\n return (not b1)\n | Some false, None ->\n return b2\n | None, Some false ->\n return b1\n | None, None ->\n (* (1 - 2 a) (1 - 2 b) = 1 - 2 c\n 1 - 2 (a + b) + 4 a b = 1 - 2 c\n - 2 (a + b) + 4 a b = - 2 c\n (a + b) - 2 a b = c\n 2 a b = a + b - c\n *)\n let open Let_syntax in\n let%bind res =\n exists typ_unchecked\n ~compute:\n As_prover.(\n map2 ~f:Bool.( <> ) (read typ_unchecked b1)\n (read typ_unchecked b2))\n in\n let%map () =\n let a = (b1 :> Cvar.t) in\n let b = (b2 :> Cvar.t) in\n let c = (res :> Cvar.t) in\n let open Cvar in\n assert_r1cs (a + a) b (a + b - c)\n in\n res\n\n module Array = struct\n let num_true (bs : var array) =\n Array.fold bs ~init:(Cvar.constant Field.zero) ~f:(fun x y ->\n Cvar.add x (y :> Cvar.t) )\n\n let any = function\n | [||] ->\n return false_\n | [| b1 |] ->\n return b1\n | [| b1; b2 |] ->\n b1 || b2\n | bs ->\n let open Let_syntax in\n let%map all_zero = equal (num_true bs) (Cvar.constant Field.zero) in\n not all_zero\n\n let all = function\n | [||] ->\n return true_\n | [| b1 |] ->\n return b1\n | [| b1; b2 |] ->\n b1 && b2\n | bs ->\n equal (Cvar.constant (Field.of_int (Array.length bs))) (num_true bs)\n\n module Assert = struct\n let any bs = assert_non_zero (num_true bs)\n\n let all bs =\n assert_equal (num_true bs)\n (Cvar.constant (Field.of_int (Array.length bs)))\n end\n end\n\n let equal (a : var) (b : var) = a lxor b >>| not\n\n let of_field x =\n let open Let_syntax in\n let%map () = assert_ (Constraint.boolean x) in\n create x\n\n module Unsafe = struct\n let of_cvar (t : Cvar.t) : var = create t\n end\n\n module Assert = struct\n let ( = ) (x : var) (y : var) = assert_equal (x :> Cvar.t) (y :> Cvar.t)\n\n let is_true (v : var) = v = true_\n\n let%snarkydef_ any (bs : var list) =\n assert_non_zero (Cvar.sum (bs :> Cvar.t list))\n\n let%snarkydef_ all (bs : var list) =\n assert_equal\n (Cvar.sum (bs :> Cvar.t list))\n (Cvar.constant (Field.of_int (List.length bs)))\n\n let%snarkydef_ exactly_one (bs : var list) =\n assert_equal (Cvar.sum (bs :> Cvar.t list)) (Cvar.constant Field.one)\n end\n\n module Expr = struct\n type t = Var of var | And of t list | Or of t list | Not of t\n\n let rec eval t =\n let open Let_syntax in\n match t with\n | Not t ->\n eval t >>| not\n | Var v ->\n return v\n | And ts ->\n Checked.all (List.map ~f:eval ts) >>= all\n | Or ts ->\n Checked.all (List.map ~f:eval ts) >>= any\n\n let assert_ t = eval t >>= Assert.is_true\n\n let ( ! ) v = Var v\n\n let ( && ) x y = And [ x; y ]\n\n let ( &&& ) = ( && )\n\n let ( || ) x y = Or [ x; y ]\n\n let ( ||| ) = ( || )\n\n let not t = Not t\n\n let any xs = Or xs\n\n let all xs = And xs\n end\n end\n\n module Typ2 = Typ\nend\n","open Core_kernel\n\nmodule Address = struct\n type t = int\nend\n\nmodule Free_hash = struct\n type 'a t = Hash_value of 'a | Hash_empty | Merge of 'a t * 'a t\n [@@deriving sexp]\n\n let diff t1 t2 =\n let module M = struct\n exception Done of bool list\n end in\n let rec go path t1 t2 =\n match (t1, t2) with\n | Hash_empty, Hash_empty ->\n None\n | Hash_value x, Hash_value y ->\n (* poly equality; we don't know type of x and y *)\n if Caml.( = ) x y then None else raise (M.Done path)\n | Merge (l1, r1), Merge (l2, r2) ->\n ignore (go (false :: path) l1 l2) ;\n ignore (go (true :: path) r1 r2) ;\n None\n | Hash_empty, Hash_value _\n | Hash_empty, Merge _\n | Hash_value _, Hash_empty\n | Hash_value _, Merge _\n | Merge _, Hash_empty\n | Merge _, Hash_value _ ->\n raise (M.Done path)\n in\n try go [] t1 t2 with M.Done addr -> Some addr\n\n let rec run t ~hash ~merge =\n match t with\n | Hash_value x ->\n hash (Some x)\n | Hash_empty ->\n hash None\n | Merge (l, r) ->\n merge (run ~hash ~merge l) (run ~hash ~merge r)\nend\n\ntype ('hash, 'a) non_empty_tree =\n | Node of 'hash * ('hash, 'a) tree * ('hash, 'a) tree\n | Leaf of 'hash * 'a\n\nand ('hash, 'a) tree = Non_empty of ('hash, 'a) non_empty_tree | Empty\n[@@deriving sexp]\n\ntype ('hash, 'a) t =\n { tree : ('hash, 'a) non_empty_tree\n ; depth : int\n ; count : int\n ; hash : 'a option -> 'hash\n ; merge : 'hash -> 'hash -> 'hash\n }\n[@@deriving sexp]\n\nlet check_exn { tree; hash; merge; _ } =\n let default = hash None in\n let rec check_hash = function\n | Non_empty t ->\n check_hash_non_empty t\n | Empty ->\n default\n and check_hash_non_empty = function\n | Leaf (h, x) ->\n (* poly equality; don't know the hash type *)\n assert (Caml.( = ) h (hash (Some x))) ;\n h\n | Node (h, l, r) ->\n (* poly equality *)\n assert (Caml.( = ) (merge (check_hash l) (check_hash r)) h) ;\n h\n in\n ignore (check_hash_non_empty tree)\n\nlet non_empty_hash = function Node (h, _, _) -> h | Leaf (h, _) -> h\n\nlet depth { depth; _ } = depth\n\nlet tree_hash ~default = function\n | Empty ->\n default\n | Non_empty t ->\n non_empty_hash t\n\nlet to_list : ('hash, 'a) t -> 'a list =\n let rec go acc = function\n | Empty ->\n acc\n | Non_empty (Leaf (_, x)) ->\n x :: acc\n | Non_empty (Node (_h, l, r)) ->\n let acc' = go acc r in\n go acc' l\n in\n fun t -> go [] (Non_empty t.tree)\n\nlet left_tree hash merge depth x =\n let empty_hash = hash None in\n let rec go i h acc =\n if i = depth then (h, acc)\n else\n let h' = merge h empty_hash in\n go (i + 1) h' (Node (h', Non_empty acc, Empty))\n in\n let h = hash (Some x) in\n go 0 h (Leaf (h, x))\n\nlet insert hash merge t0 mask0 address x =\n let default = hash None in\n let rec go mask t =\n if mask = 0 then\n match t with\n | Empty ->\n Leaf (hash (Some x), x)\n | Non_empty _ ->\n failwith \"Tree should be empty\"\n else\n let go_left = mask land address = 0 in\n let mask' = mask lsr 1 in\n match t with\n | Empty ->\n if go_left then\n let t_l' = go mask' Empty in\n Node (merge (non_empty_hash t_l') default, Non_empty t_l', Empty)\n else\n let t_r' = go mask' Empty in\n Node (merge default (non_empty_hash t_r'), Empty, Non_empty t_r')\n | Non_empty (Node (_h, t_l, t_r)) ->\n if go_left then\n let t_l' = go mask' t_l in\n Node\n ( merge (non_empty_hash t_l') (tree_hash ~default t_r)\n , Non_empty t_l'\n , t_r )\n else\n let t_r' = go mask' t_r in\n Node\n ( merge (tree_hash ~default t_l) (non_empty_hash t_r')\n , t_l\n , Non_empty t_r' )\n | Non_empty (Leaf _) ->\n failwith \"Cannot insert into leaf\"\n in\n go mask0 t0\n\nlet ith_bit n i = (n lsr i) land 1 = 1\n\nlet get { tree; depth; _ } addr0 =\n let rec get t i =\n match t with Empty -> None | Non_empty t -> get_non_empty t i\n and get_non_empty t i =\n match t with\n | Node (_, l, r) ->\n let go_right = ith_bit addr0 i in\n if go_right then get r (i - 1) else get l (i - 1)\n | Leaf (_, x) ->\n Some x\n in\n get_non_empty tree (depth - 1)\n\nlet get_exn t addr = Option.value_exn (get t addr)\n\nlet set_dirty default tree addr x =\n let rec go tree addr =\n match (tree, addr) with\n | Empty, go_right :: bs ->\n let t = Non_empty (go Empty bs) in\n let l, r = if go_right then (Empty, t) else (t, Empty) in\n Node (default, l, r)\n | Empty, [] ->\n Leaf (default, x)\n | Non_empty t, _ ->\n go_non_empty t addr\n and go_non_empty tree addr =\n match (tree, addr) with\n | Leaf _, [] ->\n Leaf (default, x)\n | Node (_, l, r), go_right :: bs ->\n let l', r' =\n if go_right then (l, Non_empty (go r bs)) else (Non_empty (go l bs), r)\n in\n Node (default, l', r')\n | Leaf _, _ :: _ | Node _, [] ->\n failwith \"Merkle_tree.set_dirty (go_non_empty): Mismatch\"\n in\n go_non_empty tree (List.rev addr)\n\nlet recompute_hashes { tree; hash; merge; _ } =\n let h =\n let default = hash None in\n fun t -> tree_hash ~default t\n in\n let rec go = function\n | Non_empty t ->\n Non_empty (go_non_empty t)\n | Empty ->\n Empty\n and go_non_empty = function\n | Leaf (_, x) ->\n Leaf (hash (Some x), x)\n | Node (_, l, r) ->\n let l' = go l in\n let r' = go r in\n Node (merge (h l') (h r'), l', r')\n in\n go_non_empty tree\n\nlet address_of_int ~depth n : bool list =\n List.init depth ~f:(fun i -> n land (1 lsl i) <> 0)\n\nlet add_many t xs =\n let default = t.hash None in\n let left_tree_dirty depth x =\n let rec go i acc =\n if i = depth then acc\n else go (i + 1) (Node (default, Non_empty acc, Empty))\n in\n go 0 (Leaf (default, x))\n in\n let add_one_dirty { tree; depth; count; hash; merge } x =\n if count = 1 lsl depth then\n let t_r = left_tree_dirty depth x in\n { tree = Node (default, Non_empty tree, Non_empty t_r)\n ; count = count + 1\n ; depth = depth + 1\n ; hash\n ; merge\n }\n else\n { tree = set_dirty default tree (address_of_int ~depth count) x\n ; count = count + 1\n ; depth\n ; hash\n ; merge\n }\n in\n let t = List.fold_left xs ~init:t ~f:add_one_dirty in\n { t with tree = recompute_hashes t }\n\nlet add { tree; depth; count; hash; merge } x =\n if count = 1 lsl depth then\n let h_r, t_r = left_tree hash merge depth x in\n let h_l = non_empty_hash tree in\n { tree = Node (merge h_l h_r, Non_empty tree, Non_empty t_r)\n ; count = count + 1\n ; depth = depth + 1\n ; hash\n ; merge\n }\n else\n { tree = insert hash merge (Non_empty tree) (1 lsl (depth - 1)) count x\n ; count = count + 1\n ; depth\n ; hash\n ; merge\n }\n\nlet root { tree; _ } = non_empty_hash tree\n\nlet create ~hash ~merge x =\n { tree = Leaf (hash (Some x), x); count = 1; depth = 0; hash; merge }\n\nlet get_path { tree; hash; depth; _ } addr0 =\n let default = hash None in\n let rec go acc t i =\n if i < 0 then acc\n else\n let go_right = ith_bit addr0 i in\n if go_right then\n match t with\n | Leaf _ ->\n failwith \"get_path\"\n | Node (_h, _t_l, Empty) ->\n failwith \"get_path\"\n | Node (_h, t_l, Non_empty t_r) ->\n go (tree_hash ~default t_l :: acc) t_r (i - 1)\n else\n match t with\n | Leaf _ ->\n failwith \"get_path\"\n | Node (_h, Empty, _t_r) ->\n failwith \"get_path\"\n | Node (_h, Non_empty t_l, t_r) ->\n go (tree_hash ~default t_r :: acc) t_l (i - 1)\n in\n go [] tree (depth - 1)\n\nlet implied_root ~merge addr0 entry_hash path0 =\n let rec go acc i path =\n match path with\n | [] ->\n acc\n | h :: hs ->\n go (if ith_bit addr0 i then merge h acc else merge acc h) (i + 1) hs\n in\n go entry_hash 0 path0\n\nlet rec free_tree_hash = function\n | Empty ->\n Free_hash.Hash_empty\n | Non_empty (Leaf (_, x)) ->\n Hash_value x\n | Non_empty (Node (_, l, r)) ->\n Merge (free_tree_hash l, free_tree_hash r)\n\nlet free_root { tree; _ } = free_tree_hash (Non_empty tree)\n\nlet get_free_path { tree; depth; _ } addr0 =\n let rec go acc t i =\n if i < 0 then acc\n else\n let go_right = ith_bit addr0 i in\n if go_right then\n match t with\n | Leaf _ ->\n failwith \"get_path\"\n | Node (_h, _t_l, Empty) ->\n failwith \"get_path\"\n | Node (_h, t_l, Non_empty t_r) ->\n go (free_tree_hash t_l :: acc) t_r (i - 1)\n else\n match t with\n | Leaf _ ->\n failwith \"get_path\"\n | Node (_h, Empty, _t_r) ->\n failwith \"get_path\"\n | Node (_h, Non_empty t_l, t_r) ->\n go (free_tree_hash t_r :: acc) t_l (i - 1)\n in\n go [] tree (depth - 1)\n\nlet implied_free_root addr0 x path0 =\n implied_root\n ~merge:(fun a b -> Free_hash.Merge (a, b))\n addr0 (Hash_value x) path0\n\ntype ('hash, 'a) merkle_tree = ('hash, 'a) t\n\nmodule Checked\n (Impl : Snark_intf.Basic) (Hash : sig\n type var\n\n type value\n\n val typ : (var, value) Impl.Typ.t\n\n val merge : height:int -> var -> var -> var Impl.Checked.t\n\n val if_ : Impl.Boolean.var -> then_:var -> else_:var -> var Impl.Checked.t\n\n val assert_equal : var -> var -> unit Impl.Checked.t\n end) (Elt : sig\n type var\n\n type value\n\n val typ : (var, value) Impl.Typ.t\n\n val hash : var -> Hash.var Impl.Checked.t\n end) =\nstruct\n open Impl\n\n module Address = struct\n type var = Boolean.var list\n\n type value = int\n\n let typ ~depth : (var, value) Typ.t =\n Typ.transport\n (Typ.list ~length:depth Boolean.typ)\n ~there:(address_of_int ~depth)\n ~back:\n (List.foldi ~init:0 ~f:(fun i acc b ->\n if b then acc lor (1 lsl i) else acc ) )\n end\n\n module Path = struct\n type value = Hash.value list\n\n type var = Hash.var list\n\n let typ ~depth : (var, value) Typ.t = Typ.(list ~length:depth Hash.typ)\n end\n\n let implied_root entry_hash addr0 path0 =\n let rec go height acc addr path =\n let open Let_syntax in\n match (addr, path) with\n | [], [] ->\n return acc\n | b :: bs, h :: hs ->\n let%bind l = Hash.if_ b ~then_:h ~else_:acc\n and r = Hash.if_ b ~then_:acc ~else_:h in\n let%bind acc' = Hash.merge ~height l r in\n go (height + 1) acc' bs hs\n | _, _ ->\n failwith\n \"Merkle_tree.Checked.implied_root: address, path length mismatch\"\n in\n go 0 entry_hash addr0 path0\n\n type _ Request.t +=\n | Get_element : Address.value -> (Elt.value * Path.value) Request.t\n | Get_path : Address.value -> Path.value Request.t\n | Set : Address.value * Elt.value -> unit Request.t\n\n (* addr0 should have least significant bit first *)\n let%snarkydef_ fetch_and_update_req ~(depth : int) root addr0 ~f :\n (Hash.var * [ `Old of Elt.var ] * [ `New of Elt.var ]) Checked.t =\n let open Let_syntax in\n let%bind prev, prev_path =\n request_witness\n Typ.(Elt.typ * Path.typ ~depth)\n As_prover.(\n read (Address.typ ~depth) addr0 >>| fun addr -> Get_element addr)\n in\n let%bind () =\n let%bind prev_entry_hash = Elt.hash prev in\n implied_root prev_entry_hash addr0 prev_path >>= Hash.assert_equal root\n in\n let%bind next = f prev in\n let%bind next_entry_hash = Elt.hash next in\n let%bind () =\n perform\n (let open As_prover in\n let open Let_syntax in\n let%map addr = read (Address.typ ~depth) addr0\n and next = read Elt.typ next in\n Set (addr, next))\n in\n let%map new_root = implied_root next_entry_hash addr0 prev_path in\n (new_root, `Old prev, `New next)\n\n (* addr0 should have least significant bit first *)\n let%snarkydef_ modify_req ~(depth : int) root addr0 ~f : Hash.var Checked.t =\n let%map root, _, _ = fetch_and_update_req ~depth root addr0 ~f in\n root\n\n (* addr0 should have least significant bit first *)\n let%snarkydef_ get_req ~(depth : int) root addr0 : Elt.var Checked.t =\n let open Let_syntax in\n let%bind prev, prev_path =\n request_witness\n Typ.(Elt.typ * Path.typ ~depth)\n As_prover.(\n map (read (Address.typ ~depth) addr0) ~f:(fun a -> Get_element a))\n in\n let%bind () =\n let%bind prev_entry_hash = Elt.hash prev in\n implied_root prev_entry_hash addr0 prev_path >>= Hash.assert_equal root\n in\n return prev\n\n (* addr0 should have least significant bit first *)\n let%snarkydef_ update_req ~(depth : int) ~root ~prev ~next addr0 :\n Hash.var Checked.t =\n let open Let_syntax in\n let%bind prev_entry_hash = Elt.hash prev\n and next_entry_hash = Elt.hash next\n and prev_path =\n request_witness (Path.typ ~depth)\n As_prover.(\n map (read (Address.typ ~depth) addr0) ~f:(fun a -> Get_path a))\n in\n let%bind () =\n implied_root prev_entry_hash addr0 prev_path >>= Hash.assert_equal root\n in\n let%bind () =\n perform\n (let open As_prover in\n let open Let_syntax in\n let%map addr = read (Address.typ ~depth) addr0\n and next = read Elt.typ next in\n Set (addr, next))\n in\n implied_root next_entry_hash addr0 prev_path\nend\n\nmodule Run = struct\n module Make\n (Impl : Snark_intf.Run_basic) (Hash : sig\n type var\n\n type value\n\n val typ : (var, value) Impl.Typ.t\n\n val merge : height:int -> var -> var -> var\n\n val if_ : Impl.Boolean.var -> then_:var -> else_:var -> var\n\n val assert_equal : var -> var -> unit\n end) (Elt : sig\n type var\n\n type value\n\n val typ : (var, value) Impl.Typ.t\n\n val hash : var -> Hash.var\n end) =\n struct\n open Impl\n\n include\n Checked\n (Impl.Internal_Basic)\n (struct\n include Hash\n\n let merge ~height x y = make_checked (fun () -> merge ~height x y)\n\n let if_ x ~then_ ~else_ = make_checked (fun () -> if_ x ~then_ ~else_)\n\n let assert_equal x y = make_checked (fun () -> assert_equal x y)\n end)\n (struct\n include Elt\n\n let hash var = make_checked (fun () -> hash var)\n end)\n\n let implied_root entry_hash addr0 path0 =\n run_checked (implied_root entry_hash addr0 path0)\n\n let modify_req ~depth root addr0 ~f =\n run_checked\n (modify_req ~depth root addr0 ~f:(fun x -> make_checked (fun () -> f x)))\n\n let get_req ~depth root addr0 = run_checked (get_req ~depth root addr0)\n\n let update_req ~depth ~root ~prev ~next addr0 =\n run_checked (update_req ~depth ~root ~prev ~next addr0)\n end\nend\n","open Core_kernel\nmodule Cvar0 = Cvar\nmodule Bignum_bigint = Bigint\n\nexception Runtime_error of string list * exn * string\n\nmodule Runner = Checked_runner\n\nlet set_eval_constraints b = Runner.eval_constraints := b\n\nmodule Make_basic\n (Backend : Backend_extended.S)\n (Checked : Checked_intf.Extended with type field = Backend.Field.t)\n (As_prover : As_prover0.Extended with type field := Backend.Field.t)\n (Ref : As_prover_ref.S\n with module Types := Checked.Types\n and type 'f field := Backend.Field.t\n and type ('a, 'f) checked := 'a Checked.t)\n (Runner : Runner.S\n with module Types := Checked.Types\n with type field := Backend.Field.t\n and type cvar := Backend.Cvar.t\n and type constr := Backend.Constraint.t option\n and type r1cs := Backend.R1CS_constraint_system.t) =\nstruct\n open Backend\n module Checked_S = Checked_intf.Unextend (Checked)\n include Runners.Make (Backend) (Checked) (As_prover) (Runner)\n module Bigint = Bigint\n module Field0 = Field\n module Cvar = Cvar\n module Constraint = Constraint\n\n module Handler = struct\n type t = Request.request -> Request.response\n end\n\n module Typ = struct\n include Types.Typ.T\n module T = Typ.Make (Checked_S)\n include T.T\n\n type ('var, 'value) t = ('var, 'value, Field.t) T.t\n\n let unit : (unit, unit) t = unit ()\n\n let field : (Cvar.t, Field.t) t = field ()\n end\n\n let constant (Typ typ : _ Typ.t) x =\n let fields, aux = typ.value_to_fields x in\n let field_vars = Array.map fields ~f:(fun x -> Cvar0.Constant x) in\n typ.var_of_fields (field_vars, aux)\n\n module As_prover = struct\n include As_prover\n\n type 'a as_prover = 'a t\n\n module Ref = Ref\n end\n\n module Handle = struct\n include Handle\n\n let value = As_prover.Handle.value\n end\n\n module Checked = struct\n include (\n Checked :\n Checked_intf.Extended\n with module Types := Checked.Types\n with type field := field )\n\n let perform req = request_witness Typ.unit req\n\n module Runner = Runner\n\n type run_state = Runner.run_state\n\n include Utils.Make (Backend) (Checked) (As_prover) (Runner)\n\n module Control = struct end\n\n let two_to_the n =\n let rec go acc i =\n if i = 0 then acc else go (Field0.add acc acc) (i - 1)\n in\n go Field0.one n\n\n type _ Request.t += Choose_preimage : Field.t * int -> bool list Request.t\n\n let choose_preimage_unchecked v ~length =\n exists\n (Typ.list Boolean.typ ~length)\n ~request:\n As_prover.(map (read_var v) ~f:(fun x -> Choose_preimage (x, length)))\n ~compute:\n (let open As_prover.Let_syntax in\n let%map x = As_prover.read_var v in\n let x = Bigint.of_field x in\n List.init length ~f:(fun i -> Bigint.test_bit x i))\n\n let packing_sum (bits : Boolean.var list) =\n let ts, _ =\n List.fold_left bits ~init:([], Field.one) ~f:(fun (acc, c) v ->\n ((c, (v :> Cvar.t)) :: acc, Field.add c c) )\n in\n Cvar.linear_combination ts\n\n let choose_preimage (v : Cvar.t) ~length : Boolean.var list t =\n let open Let_syntax in\n let%bind bits = choose_preimage_unchecked v ~length in\n let lc = packing_sum bits in\n let%map () =\n assert_r1cs ~label:\"Choose_preimage\" lc (Cvar.constant Field.one) v\n in\n bits\n\n let choose_preimage_flagged (v : Cvar.t) ~length =\n let open Let_syntax in\n let%bind bits = choose_preimage_unchecked v ~length in\n let lc = packing_sum bits in\n let%map success = equal lc v in\n (bits, `Success success)\n\n module List =\n Monad_sequence.List\n (Checked)\n (struct\n type t = Boolean.var\n\n include Boolean\n end)\n\n module Array =\n Monad_sequence.Array\n (Checked)\n (struct\n type t = Boolean.var\n\n let any = Boolean.Array.any\n\n let all = Boolean.Array.all\n end)\n end\n\n module Cvar1 = struct\n include Cvar\n\n let project =\n let two = Field.of_int 2 in\n fun (vars : Checked.Boolean.var list) ->\n let rec go res = function\n | [] ->\n res\n | v :: vs ->\n go Cvar0.(Add (v, Scale (two, res))) vs\n in\n match List.rev (vars :> Cvar.t list) with\n | [] ->\n Cvar0.Constant Field.zero\n | v :: vs ->\n go v vs\n\n let pack vars =\n assert (List.length vars < Field.size_in_bits) ;\n project vars\n\n let unpack v ~length =\n assert (length < Field.size_in_bits) ;\n Checked.choose_preimage v ~length\n\n let unpack_flagged v ~length =\n assert (length < Field.size_in_bits) ;\n Checked.choose_preimage_flagged v ~length\n end\n\n module Field = struct\n include Field0\n\n let gen =\n Quickcheck.Generator.map\n Bignum_bigint.(gen_incl zero (size - one))\n ~f:(fun x -> Bigint.(to_field (of_bignum_bigint x)))\n\n let gen_incl lo hi =\n let lo_bigint = Bigint.(to_bignum_bigint @@ of_field lo) in\n let hi_bigint = Bigint.(to_bignum_bigint @@ of_field hi) in\n Quickcheck.Generator.map\n Bignum_bigint.(gen_incl lo_bigint hi_bigint)\n ~f:(fun x -> Bigint.(to_field (of_bignum_bigint x)))\n\n let gen_uniform =\n Quickcheck.Generator.map\n Bignum_bigint.(gen_uniform_incl zero (size - one))\n ~f:(fun x -> Bigint.(to_field (of_bignum_bigint x)))\n\n let gen_uniform_incl lo hi =\n let lo_bigint = Bigint.(to_bignum_bigint @@ of_field lo) in\n let hi_bigint = Bigint.(to_bignum_bigint @@ of_field hi) in\n Quickcheck.Generator.map\n Bignum_bigint.(gen_uniform_incl lo_bigint hi_bigint)\n ~f:(fun x -> Bigint.(to_field (of_bignum_bigint x)))\n\n let typ = Typ.field\n\n module Var = Cvar1\n\n let parity x = Bigint.(test_bit (of_field x) 0)\n\n module Checked = struct\n include Cvar1\n\n let equal = Checked.equal\n\n let mul x y = Checked.mul ~label:\"Field.Checked.mul\" x y\n\n let square x = Checked.square ~label:\"Field.Checked.square\" x\n\n let div x y = Checked.div ~label:\"Field.Checked.div\" x y\n\n let inv x = Checked.inv ~label:\"Field.Checked.inv\" x\n\n let sqrt (x : Cvar.t) : Cvar.t Checked.t =\n match x with\n | Constant x ->\n Checked.return (Cvar.constant (Field.sqrt x))\n | _ ->\n let open Checked in\n let open Let_syntax in\n let%bind y =\n exists ~compute:As_prover.(map (read_var x) ~f:Field.sqrt) typ\n in\n let%map () = assert_square y x in\n y\n\n let quadratic_nonresidue =\n lazy\n (let rec go i =\n let x = Field.of_int i in\n if not (Field.is_square x) then x else go Int.(i + 1)\n in\n go 2 )\n\n (* The trick here is the following.\n\n Let beta be a known non-square.\n\n x is not a square iff beta*x is a square\n\n So we guess the result [is_square] and y a sqrt of one of {x, beta*x} and assert\n\n y * y = is_square * x + (1 - is_square) * (beta * x)\n\n which, letting B = beta*x holds iff\n\n y * y\n = is_square * x + B - is_square * B\n = is_square * (x - B) + B\n *)\n let sqrt_check x =\n let open Checked in\n let open Let_syntax in\n let%bind is_square =\n exists\n ~compute:As_prover.(map (read_var x) ~f:Field.is_square)\n Boolean.typ\n in\n let%bind y =\n exists typ\n ~compute:\n As_prover.(\n Let_syntax.(\n let%map is_square = read Boolean.typ is_square\n and x = read_var x in\n if is_square then Field.sqrt x\n else Field.(sqrt (Lazy.force quadratic_nonresidue * x))))\n in\n let b = scale x (Lazy.force quadratic_nonresidue) in\n let%bind t = mul (is_square :> Var.t) (x - b) in\n let%map () = assert_square y (t + b) in\n (y, is_square)\n\n let is_square x =\n let open Checked.Let_syntax in\n let%map _, b = sqrt_check x in\n b\n\n let%test_unit \"is_square\" =\n let x = Field.random () in\n let typf = Typ.field in\n let x2 = Field.square x in\n assert (Field.(equal (x * x) x2)) ;\n let run elt =\n let answer =\n run_and_check\n (Checked.map\n ~f:(As_prover.read Checked.Boolean.typ)\n Checked.(\n Let_syntax.(\n let%bind x = exists typf ~compute:(As_prover.return elt) in\n is_square x)) )\n |> Or_error.ok_exn\n in\n answer\n in\n assert (run x2) ;\n assert (not (run (Field.mul (Lazy.force quadratic_nonresidue) x2)))\n\n let choose_preimage_var = Checked.choose_preimage\n\n type comparison_result =\n { less : Checked.Boolean.var; less_or_equal : Checked.Boolean.var }\n\n let if_ = Checked.if_\n\n let compare ~bit_length a b =\n (* Overview of the logic:\n let n = bit_length\n We have 0 <= a < 2^n, 0 <= b < 2^n, and so\n -2^n < b - a < 2^n\n If (b - a) >= 0, then\n 2^n <= 2^n + b - a < 2^{n+1},\n and so the n-th bit must be set.\n If (b - a) < 0 then\n 0 < 2^n + b - a < 2^n\n and so the n-th bit must not be set.\n Thus, we can use the n-th bit of 2^n + b - a to determine whether\n (b - a) >= 0 <-> a <= b.\n\n We also need that the maximum value\n 2^n + (2^n - 1) - 0 = 2^{n+1} - 1\n fits inside the field, so for the max field element f,\n 2^{n+1} - 1 <= f -> n+1 <= log2(f) = size_in_bits - 1\n *)\n assert (Int.(bit_length <= size_in_bits - 2)) ;\n let open Checked in\n let open Let_syntax in\n [%with_label_ \"compare\"] (fun () ->\n let alpha_packed =\n Cvar.(constant (two_to_the bit_length) + b - a)\n in\n let%bind alpha = unpack alpha_packed ~length:Int.(bit_length + 1) in\n let prefix, less_or_equal =\n match Core_kernel.List.split_n alpha bit_length with\n | p, [ l ] ->\n (p, l)\n | _ ->\n failwith \"compare: Invalid alpha\"\n in\n let%bind not_all_zeros = Boolean.any prefix in\n let%map less = Boolean.(less_or_equal && not_all_zeros) in\n { less; less_or_equal } )\n\n module Assert = struct\n let lt ~bit_length (x : Cvar.t) (y : Cvar.t) =\n match (x, y) with\n | Constant x, Constant y ->\n assert (Field.compare x y < 0) ;\n Checked.return ()\n | _ ->\n let open Checked in\n let open Let_syntax in\n let%bind { less; _ } = compare ~bit_length x y in\n Boolean.Assert.is_true less\n\n let lte ~bit_length (x : Cvar.t) (y : Cvar.t) =\n match (x, y) with\n | Constant x, Constant y ->\n assert (Field.compare x y <= 0) ;\n Checked.return ()\n | _ ->\n let open Checked in\n let open Let_syntax in\n let%bind { less_or_equal; _ } = compare ~bit_length x y in\n Boolean.Assert.is_true less_or_equal\n\n let gt ~bit_length x y = lt ~bit_length y x\n\n let gte ~bit_length x y = lte ~bit_length y x\n\n let non_zero (v : Cvar.t) =\n match v with\n | Constant v ->\n if Field.(equal zero v) then\n failwithf \"assert_non_zero: failed on constant %s\"\n (Field.to_string v) () ;\n Checked.return ()\n | _ ->\n Checked.assert_non_zero v\n\n let equal x y = Checked.assert_equal ~label:\"Checked.Assert.equal\" x y\n\n let not_equal (x : t) (y : t) =\n match (x, y) with\n | Constant x, Constant y ->\n if Field.(equal x y) then\n failwithf \"not_equal: failed on constants %s and %s\"\n (Field.to_string x) (Field.to_string y) () ;\n Checked.return ()\n | _, _ ->\n Checked.with_label \"Checked.Assert.not_equal\" (fun () ->\n non_zero (sub x y) )\n end\n\n let lt_bitstring_value =\n let module Boolean = Checked.Boolean in\n let module Expr = struct\n module Binary = struct\n type 'a t = Lit of 'a | And of 'a * 'a t | Or of 'a * 'a t\n end\n\n module Nary = struct\n type 'a t = Lit of 'a | And of 'a t list | Or of 'a t list\n\n let rec of_binary : 'a Binary.t -> 'a t = function\n | Lit x ->\n Lit x\n | And (x, And (y, t)) ->\n And [ Lit x; Lit y; of_binary t ]\n | Or (x, Or (y, t)) ->\n Or [ Lit x; Lit y; of_binary t ]\n | And (x, t) ->\n And [ Lit x; of_binary t ]\n | Or (x, t) ->\n Or [ Lit x; of_binary t ]\n\n let rec eval =\n let open Checked.Let_syntax in\n function\n | Lit x ->\n return x\n | And xs ->\n Checked.List.map xs ~f:eval >>= Boolean.all\n | Or xs ->\n Checked.List.map xs ~f:eval >>= Boolean.any\n end\n end in\n let rec lt_binary xs ys : Boolean.var Expr.Binary.t =\n match (xs, ys) with\n | [], [] ->\n Lit Boolean.false_\n | [ _x ], [ false ] ->\n Lit Boolean.false_\n | [ x ], [ true ] ->\n Lit (Boolean.not x)\n | [ x1; _x2 ], [ true; false ] ->\n Lit (Boolean.not x1)\n | [ _x1; _x2 ], [ false; false ] ->\n Lit Boolean.false_\n | x :: xs, false :: ys ->\n And (Boolean.not x, lt_binary xs ys)\n | x :: xs, true :: ys ->\n Or (Boolean.not x, lt_binary xs ys)\n | _ :: _, [] | [], _ :: _ ->\n failwith \"lt_bitstring_value: Got unequal length strings\"\n in\n fun (xs : Boolean.var Bitstring_lib.Bitstring.Msb_first.t)\n (ys : bool Bitstring_lib.Bitstring.Msb_first.t) ->\n let open Expr.Nary in\n eval\n (of_binary (lt_binary (xs :> Boolean.var list) (ys :> bool list)))\n\n let field_size_bits =\n List.init Field.size_in_bits ~f:(fun i ->\n Z.testbit\n (Bignum_bigint.to_zarith_bigint Field.size)\n Stdlib.(Field.size_in_bits - 1 - i) )\n |> Bitstring_lib.Bitstring.Msb_first.of_list\n\n let unpack_full x =\n let module Bitstring = Bitstring_lib.Bitstring in\n let open Checked.Let_syntax in\n let%bind res =\n choose_preimage_var x ~length:Field.size_in_bits\n >>| Bitstring.Lsb_first.of_list\n in\n let%map () =\n lt_bitstring_value\n (Bitstring.Msb_first.of_lsb_first res)\n field_size_bits\n >>= Checked.Boolean.Assert.is_true\n in\n res\n\n let parity ?length x =\n let open Checked in\n let unpack =\n let unpack_full x =\n unpack_full x >>| Bitstring_lib.Bitstring.Lsb_first.to_list\n in\n match length with\n | None ->\n unpack_full\n | Some length ->\n let length = Int.min length Field.size_in_bits in\n if Int.equal length Field.size_in_bits then unpack_full\n else choose_preimage_var ~length\n in\n unpack x >>| Base.List.hd_exn\n end\n end\n\n module Bitstring_checked = struct\n type t = Checked.Boolean.var list\n\n let lt_value = Field.Checked.lt_bitstring_value\n\n let chunk_for_equality (t1 : t) (t2 : t) =\n let chunk_size = Field.size_in_bits - 1 in\n let rec go acc t1 t2 =\n match (t1, t2) with\n | [], [] ->\n acc\n | _, _ ->\n let t1_a, t1_b = List.split_n t1 chunk_size in\n let t2_a, t2_b = List.split_n t2 chunk_size in\n go ((t1_a, t2_a) :: acc) t1_b t2_b\n in\n go [] t1 t2\n\n let equal t1 t2 =\n let open Checked in\n all\n (Base.List.map (chunk_for_equality t1 t2) ~f:(fun (x1, x2) ->\n equal (Cvar1.pack x1) (Cvar1.pack x2) ) )\n >>= Boolean.all\n\n let equal_expect_true t1 t2 =\n let open Checked in\n all\n (Core_kernel.List.map (chunk_for_equality t1 t2) ~f:(fun (x1, x2) ->\n (* Inlined [Field.equal], but skip creating the field element for\n this chunk if possible.\n *)\n let z = Cvar1.(pack x1 - pack x2) in\n let%bind r, inv =\n exists\n Typ.(field * field)\n ~compute:\n As_prover.(\n match\n Core_kernel.List.map2 x1 x2 ~f:(fun x1 x2 ->\n let%map x1 = read_var (x1 :> Cvar.t)\n and x2 = read_var (x2 :> Cvar.t) in\n Field.equal x1 x2 )\n with\n | Ok res ->\n let%bind res = all res in\n if Core_kernel.List.for_all ~f:Fn.id res then\n return (Field.one, Field.zero)\n else equal_vars z\n | _ ->\n equal_vars z)\n in\n let%map () = equal_constraints z inv r in\n Boolean.Unsafe.of_cvar r ) )\n >>= Boolean.all\n\n module Assert = struct\n let equal t1 t2 =\n let open Checked in\n Base.List.map (chunk_for_equality t1 t2) ~f:(fun (x1, x2) ->\n Constraint.equal (Cvar1.pack x1) (Cvar1.pack x2) )\n |> assert_all ~label:\"Bitstring.Assert.equal\"\n end\n end\n\n let%test_unit \"lt_bitstring_value\" =\n let gen =\n let open Quickcheck.Generator in\n let open Let_syntax in\n let%bind length = small_positive_int in\n let%map x = list_with_length length bool\n and y = list_with_length length bool in\n (x, y)\n in\n Quickcheck.test gen ~f:(fun (x, y) ->\n let correct_answer = [%compare: bool list] x y < 0 in\n let lt =\n run_and_check\n (Checked.map\n ~f:(As_prover.read Checked.Boolean.typ)\n (Field.Checked.lt_bitstring_value\n (Bitstring_lib.Bitstring.Msb_first.of_list\n (List.map ~f:Checked.(constant Boolean.typ) x) )\n (Bitstring_lib.Bitstring.Msb_first.of_list y) ) )\n |> Or_error.ok_exn\n in\n assert (Bool.equal lt correct_answer) )\n\n include Checked\n\n let%snarkydef_ if_ (b : Boolean.var) ~typ:(Typ typ : ('var, _) Typ.t)\n ~(then_ : 'var) ~(else_ : 'var) =\n let then_, then_aux = typ.var_to_fields then_ in\n let else_, else_aux = typ.var_to_fields else_ in\n let%bind res =\n Array.all\n (Core_kernel.Array.map2_exn then_ else_ ~f:(fun then_ else_ ->\n if_ b ~then_ ~else_ ) )\n in\n let%map res_aux =\n (* Abstraction leak.. *)\n let res_aux = ref None in\n let%map () =\n as_prover\n As_prover.(\n if%map read Boolean.typ b then res_aux := Some then_aux\n else res_aux := Some else_aux)\n in\n match !res_aux with\n | Some res_aux ->\n res_aux\n | None ->\n typ.constraint_system_auxiliary ()\n in\n typ.var_of_fields (res, res_aux)\n\n module Test = struct\n let checked_to_unchecked typ1 typ2 checked input =\n let checked_result =\n run_and_check\n (let open Let_syntax in\n let%bind input = exists typ1 ~compute:(As_prover.return input) in\n let%map result = checked input in\n As_prover.read typ2 result)\n |> Or_error.ok_exn\n in\n checked_result\n\n let test_equal (type a) ?(sexp_of_t = sexp_of_opaque) ?(equal = Caml.( = ))\n typ1 typ2 checked unchecked input =\n let checked_result = checked_to_unchecked typ1 typ2 checked input in\n let sexp_of_a = sexp_of_t in\n let compare_a x y = if equal x y then 0 else 1 in\n [%test_eq: a] checked_result (unchecked input)\n end\n\n module R1CS_constraint_system = struct\n include R1CS_constraint_system\n end\nend\n\n(** The main functor for the monadic interface. \n See [Run.Make] for the same thing but for the imperative interface. *)\nmodule Make (Backend : Backend_intf.S) = struct\n module Backend_extended = Backend_extended.Make (Backend)\n module Runner0 = Runner.Make (Backend_extended)\n module Checked_runner = Runner0.Checked_runner\n module Checked1 = Checked.Make (Backend.Field) (Checked_runner) (As_prover0)\n\n module Field_T = struct\n type field = Backend_extended.Field.t\n end\n\n module As_prover_ext = As_prover0.Make_extended (Field_T) (As_prover0)\n\n module Ref :\n As_prover_ref.S\n with module Types = Checked1.Types\n and type ('a, 'f) checked := ('a, 'f) Checked1.t\n and type 'f field := Backend_extended.Field.t =\n As_prover_ref.Make (Checked1) (As_prover0)\n\n module Checked_for_basic = struct\n include (\n Checked1 :\n Checked_intf.S\n with module Types = Checked1.Types\n with type ('a, 'f) t := ('a, 'f) Checked1.t\n and type 'f field := Backend_extended.Field.t )\n\n type field = Backend_extended.Field.t\n\n type 'a t = ('a, field) Types.Checked.t\n\n let run = Runner0.run\n end\n\n module Basic =\n Make_basic (Backend_extended) (Checked_for_basic) (As_prover_ext) (Ref)\n (Runner0)\n include Basic\n module Number = Number.Make (Basic)\n module Enumerable = Enumerable.Make (Basic)\nend\n\nmodule Typ0 = Typ\n\nmodule Run = struct\n let functor_counter = ref 0\n\n let active_counters = ref []\n\n let is_active_functor_id num =\n match !active_counters with\n | [] ->\n (* Show the usual error, the functor isn't wrong as far as we can tell.\n *)\n true\n | active :: _ ->\n Int.equal active num\n\n let active_functor_id () = List.hd_exn !active_counters\n\n module Make_basic (Backend : Backend_intf.S) = struct\n module Snark = Make (Backend)\n open Run_state\n open Snark\n\n let set_constraint_logger = set_constraint_logger\n\n let clear_constraint_logger = clear_constraint_logger\n\n let this_functor_id = incr functor_counter ; !functor_counter\n\n let state =\n ref\n (Run_state.make ~input:(field_vec ()) ~aux:(field_vec ())\n ~eval_constraints:false ~num_inputs:0 ~next_auxiliary:(ref 0)\n ~with_witness:false ~stack:[] ~is_running:false () )\n\n let dump () = Run_state.dump !state\n\n let in_prover () : bool = Run_state.has_witness !state\n\n let in_checked_computation () : bool =\n is_active_functor_id this_functor_id && Run_state.is_running !state\n\n let run (checked : _ Checked.t) =\n match checked with\n | Pure a ->\n a\n | _ ->\n if not (is_active_functor_id this_functor_id) then\n failwithf\n \"Could not run this function.\\n\\n\\\n Hint: The module used to create this function had internal ID \\\n %i, but the module used to run it had internal ID %i. The same \\\n instance of Snarky.Snark.Run.Make must be used for both.\"\n this_functor_id (active_functor_id ()) ()\n else if not (Run_state.is_running !state) then\n failwith\n \"This function can't be run outside of a checked computation.\" ;\n let state', x = Runner.run checked !state in\n state := state' ;\n x\n\n let as_stateful x state' =\n state := state' ;\n let a = x () in\n (!state, a)\n\n let make_checked (type a) (f : unit -> a) : _ Checked.t =\n let g : run_state -> run_state * a = as_stateful f in\n Function g\n\n module R1CS_constraint_system = Snark.R1CS_constraint_system\n\n type field = Snark.field\n\n module Bigint = Snark.Bigint\n module Constraint = Snark.Constraint\n\n module Typ = struct\n open Snark.Typ\n\n type nonrec ('var, 'value) t = ('var, 'value) t\n\n let unit = unit\n\n let field = field\n\n let tuple2 = tuple2\n\n let ( * ) = ( * )\n\n let tuple3 = tuple3\n\n let list = list\n\n let array = array\n\n let hlist = hlist\n\n let transport = transport\n\n let transport_var = transport_var\n\n let of_hlistable = of_hlistable\n\n module Internal = Internal\n end\n\n let constant (Typ typ : _ Typ.t) x =\n let fields, aux = typ.value_to_fields x in\n let field_vars = Core_kernel.Array.map ~f:Cvar.constant fields in\n typ.var_of_fields (field_vars, aux)\n\n module Boolean = struct\n open Snark.Boolean\n\n type nonrec var = var\n\n type value = bool\n\n let true_ = true_\n\n let false_ = false_\n\n let if_ b ~then_ ~else_ = run (if_ b ~then_ ~else_)\n\n let not = not\n\n let ( && ) x y = run (x && y)\n\n let ( &&& ) = ( && )\n\n let ( || ) x y = run (x || y)\n\n let ( ||| ) = ( || )\n\n let ( lxor ) x y = run (x lxor y)\n\n let any l = run (any l)\n\n let all l = run (all l)\n\n let of_field x = run (of_field x)\n\n let var_of_value = var_of_value\n\n let typ = typ\n\n let typ_unchecked = typ_unchecked\n\n let equal x y = run (equal x y)\n\n module Expr = struct\n open Snark.Boolean.Expr\n\n type nonrec t = t\n\n let ( ! ) = ( ! )\n\n let ( && ) = ( && )\n\n let ( &&& ) = ( && )\n\n let ( || ) = ( || )\n\n let ( ||| ) = ( ||| )\n\n let any = any\n\n let all = all\n\n let not = not\n\n let eval x = run (eval x)\n\n let assert_ x = run (assert_ x)\n end\n\n module Unsafe = Unsafe\n\n module Assert = struct\n open Snark.Boolean.Assert\n\n let ( = ) x y = run (x = y)\n\n let is_true x = run (is_true x)\n\n let any l = run (any l)\n\n let all l = run (all l)\n\n let exactly_one l = run (exactly_one l)\n end\n\n module Array = struct\n open Snark.Boolean.Array\n\n let any x = run (any x)\n\n let all x = run (all x)\n\n module Assert = struct\n let any x = run (Assert.any x)\n\n let all x = run (Assert.all x)\n end\n end\n end\n\n module Field = struct\n open Snark.Field\n\n let size_in_bits = size_in_bits\n\n let size = size\n\n module Constant = struct\n type t = Snark.Field.t [@@deriving bin_io, sexp, hash, compare, eq]\n\n let gen = gen\n\n let gen_uniform = gen_uniform\n\n module T = struct\n let bin_shape_t = bin_shape_t\n\n let bin_writer_t = bin_writer_t\n\n let bin_write_t = bin_write_t\n\n let bin_size_t = bin_size_t\n\n let bin_reader_t = bin_reader_t\n\n let __bin_read_t__ = __bin_read_t__\n\n let bin_read_t = bin_read_t\n\n let bin_t = bin_t\n\n let sexp_of_t = sexp_of_t\n\n let t_of_sexp = t_of_sexp\n\n let of_int = of_int\n\n let one = one\n\n let zero = zero\n\n let add = add\n\n let sub = sub\n\n let mul = mul\n\n let inv = inv\n\n let square = square\n\n let sqrt = sqrt\n\n let is_square = is_square\n\n let equal = equal\n\n let size_in_bits = size_in_bits\n\n let print = print\n\n let to_string = to_string\n\n let random = random\n\n module Mutable = Mutable\n\n let ( += ) = ( += )\n\n let ( -= ) = ( -= )\n\n let ( *= ) = ( *= )\n\n module Vector = Vector\n\n let negate = negate\n\n let ( + ) = ( + )\n\n let ( - ) = ( - )\n\n let ( * ) = ( * )\n\n let ( / ) = ( / )\n\n let of_string = of_string\n\n let to_string = to_string\n\n let unpack = unpack\n\n let project = project\n\n let parity = parity\n end\n\n include T\n end\n\n open Snark.Field.Var\n\n type nonrec t = t\n\n let length = length\n\n let var_indices = var_indices\n\n let to_constant_and_terms = to_constant_and_terms\n\n let constant = constant\n\n let to_constant = to_constant\n\n let linear_combination = linear_combination\n\n let sum = sum\n\n let add = add\n\n let negate = negate\n\n let sub = sub\n\n let scale = scale\n\n let project = project\n\n let pack = pack\n\n (* New definitions *)\n\n let of_int i = constant (Constant.of_int i)\n\n let one = constant Constant.one\n\n let zero = constant Constant.zero\n\n open Snark.Field.Checked\n\n let mul x y = run (mul x y)\n\n let square x = run (square x)\n\n let div x y = run (div x y)\n\n let inv x = run (inv x)\n\n let is_square x = run (is_square x)\n\n let sqrt x = run (sqrt x)\n\n let sqrt_check x = run (sqrt_check x)\n\n let equal x y = run (equal x y)\n\n let unpack x ~length = run (unpack x ~length)\n\n let unpack_flagged x ~length = run (unpack_flagged x ~length)\n\n let unpack_full x = run (unpack_full x)\n\n let parity ?length x = run (parity ?length x)\n\n let choose_preimage_var x ~length = run (choose_preimage_var x ~length)\n\n type nonrec comparison_result = comparison_result =\n { less : Boolean.var; less_or_equal : Boolean.var }\n\n let compare ~bit_length x y = run (compare ~bit_length x y)\n\n let if_ b ~then_ ~else_ = run (if_ b ~then_ ~else_)\n\n let ( + ) = add\n\n let ( - ) = sub\n\n let ( * ) = mul\n\n let ( / ) = div\n\n module Unsafe = Unsafe\n\n module Assert = struct\n open Snark.Field.Checked.Assert\n\n let lte ~bit_length x y = run (lte ~bit_length x y)\n\n let gte ~bit_length x y = run (gte ~bit_length x y)\n\n let lt ~bit_length x y = run (lt ~bit_length x y)\n\n let gt ~bit_length x y = run (gt ~bit_length x y)\n\n let not_equal x y = run (not_equal x y)\n\n let equal x y = run (equal x y)\n\n let non_zero x = run (non_zero x)\n end\n\n let typ = typ\n end\n\n module Proof_inputs = Proof_inputs\n\n module Bitstring_checked = struct\n open Snark.Bitstring_checked\n\n type nonrec t = t\n\n let equal x y = run (equal x y)\n\n let equal_expect_true x y = run (equal_expect_true x y)\n\n let lt_value x y = run (lt_value x y)\n\n module Assert = struct\n open Snark.Bitstring_checked.Assert\n\n let equal x y = run (equal x y)\n end\n end\n\n module As_prover = struct\n type 'a t = 'a\n\n type 'a as_prover = 'a t\n\n let eval_as_prover f =\n if Run_state.as_prover !state && Run_state.has_witness !state then\n let a = f (Runner.get_value !state) in\n a\n else failwith \"Can't evaluate prover code outside an as_prover block\"\n\n let in_prover_block () = Run_state.as_prover !state\n\n let read_var var = eval_as_prover (As_prover.read_var var)\n\n let read typ var = eval_as_prover (As_prover.read typ var)\n\n include Field.Constant.T\n\n module Ref = struct\n type 'a t = 'a As_prover_ref.t\n\n let create f = run As_prover.(Ref.create (map (return ()) ~f))\n\n let get r = eval_as_prover (As_prover.Ref.get r)\n\n let set r x = eval_as_prover (As_prover.Ref.set r x)\n end\n\n let run_prover f _tbl =\n (* Allow for nesting of prover blocks, by caching the current value and\n restoring it once we're done.\n *)\n let old = Run_state.as_prover !state in\n Run_state.set_as_prover !state true ;\n let a = f () in\n Run_state.set_as_prover !state old ;\n a\n end\n\n module Handle = struct\n type ('var, 'value) t = ('var, 'value) Handle.t\n\n let value handle () = As_prover.eval_as_prover (Handle.value handle)\n\n let var = Handle.var\n end\n\n let mark_active ~f =\n let counters = !active_counters in\n active_counters := this_functor_id :: counters ;\n try\n let ret = f () in\n active_counters := counters ;\n ret\n with exn ->\n active_counters := counters ;\n raise exn\n\n let mark_active_deferred (type a ma) ~(map : ma -> f:(a -> a) -> ma) ~f =\n let counters = !active_counters in\n active_counters := this_functor_id :: counters ;\n try\n map (f ()) ~f:(fun (ret : a) ->\n active_counters := counters ;\n ret )\n with exn ->\n active_counters := counters ;\n raise exn\n\n let assert_ ?label c = run (assert_ ?label c)\n\n let assert_all ?label c = run (assert_all ?label c)\n\n let assert_r1cs ?label a b c = run (assert_r1cs ?label a b c)\n\n let assert_square ?label x y = run (assert_square ?label x y)\n\n let as_prover p = run (as_prover (As_prover.run_prover p))\n\n let next_auxiliary () = run (next_auxiliary ())\n\n let request_witness typ p =\n run (request_witness typ (As_prover.run_prover p))\n\n let perform p = run (perform (As_prover.run_prover p))\n\n let request ?such_that typ r =\n match such_that with\n | None ->\n request_witness typ (fun () -> r)\n | Some such_that ->\n let x = request_witness typ (fun () -> r) in\n such_that x ; x\n\n let exists ?request ?compute typ =\n let request = Option.map request ~f:As_prover.run_prover in\n let compute = Option.map compute ~f:As_prover.run_prover in\n run (exists ?request ?compute typ)\n\n let exists_handle ?request ?compute typ =\n let request = Option.map request ~f:As_prover.run_prover in\n let compute = Option.map compute ~f:As_prover.run_prover in\n run (exists_handle ?request ?compute typ)\n\n type nonrec response = response\n\n let unhandled = unhandled\n\n type request = Request.request =\n | With :\n { request : 'a Request.t\n ; respond : 'a Request.Response.t -> response\n }\n -> request\n\n module Handler = Handler\n\n let handle x h =\n let h = Request.Handler.create_single h in\n let handler = Run_state.handler !state in\n state := Run_state.set_handler !state (Request.Handler.push handler h) ;\n let a = x () in\n state := Run_state.set_handler !state handler ;\n a\n\n let handle_as_prover x h =\n let h = h () in\n handle x h\n\n let if_ b ~typ ~then_ ~else_ = run (if_ b ~typ ~then_ ~else_)\n\n let with_label lbl x =\n let stack = Run_state.stack !state in\n let log_constraint = Run_state.log_constraint !state in\n state := Run_state.set_stack !state (lbl :: stack) ;\n Option.iter log_constraint ~f:(fun f ->\n f ~at_label_boundary:(`Start, lbl) None ) ;\n let a = x () in\n Option.iter log_constraint ~f:(fun f ->\n f ~at_label_boundary:(`End, lbl) None ) ;\n state := Run_state.set_stack !state stack ;\n a\n\n let inject_wrapper :\n type r_var input_var.\n f:(r_var -> r_var) -> (input_var -> r_var) -> input_var -> r_var =\n fun ~f x a ->\n let inject_wrapper ~f x = f x in\n inject_wrapper ~f (x a)\n\n (** Caches the global [state] before running [f]. \n It is expected that [f] will reset the global state for its own use only, \n hence why we need to reset it after running [f].*)\n let finalize_is_running f =\n let cached_state = !state in\n let x =\n match f () with\n | exception e ->\n (* Warning: it is important to clean the global state before reraising the exception.\n Imagine if a user of snarky catches exceptions instead of letting the program panic,\n then the next usage of snarky might be messed up. *)\n state := cached_state ;\n raise e\n | x ->\n x\n in\n state := cached_state ;\n x\n\n let constraint_system ~input_typ ~return_typ x : R1CS_constraint_system.t =\n finalize_is_running (fun () ->\n let x = inject_wrapper x ~f:(fun x () -> mark_active ~f:x) in\n Perform.constraint_system ~run:as_stateful ~input_typ ~return_typ x )\n\n let generate_public_input t x : As_prover.Vector.t =\n finalize_is_running (fun () -> generate_public_input t x)\n\n let generate_witness ~input_typ ~return_typ x a : Proof_inputs.t =\n finalize_is_running (fun () ->\n let x = inject_wrapper x ~f:(fun x () -> mark_active ~f:x) in\n Perform.generate_witness ~run:as_stateful ~input_typ ~return_typ x a )\n\n let generate_witness_conv (type out)\n ~(f : Proof_inputs.t -> 'r_value -> out) ~input_typ ~return_typ x input\n : out =\n finalize_is_running (fun () ->\n let x = inject_wrapper x ~f:(fun x () -> mark_active ~f:x) in\n Perform.generate_witness_conv ~run:as_stateful ~f ~input_typ\n ~return_typ x input )\n\n let run_unchecked x =\n finalize_is_running (fun () ->\n Perform.run_unchecked ~run:as_stateful (fun () -> mark_active ~f:x) )\n\n let run_and_check_exn (type a) (x : unit -> (unit -> a) As_prover.t) : a =\n finalize_is_running (fun () ->\n let res =\n Perform.run_and_check_exn ~run:as_stateful (fun () ->\n mark_active ~f:(fun () ->\n let prover_block = x () in\n Run_state.set_as_prover !state true ;\n As_prover.run_prover prover_block ) )\n in\n Run_state.set_as_prover !state true ;\n res )\n\n let run_and_check (type a) (x : unit -> (unit -> a) As_prover.t) :\n a Or_error.t =\n finalize_is_running (fun () ->\n let res =\n Perform.run_and_check ~run:as_stateful (fun () ->\n mark_active ~f:(fun () ->\n let prover_block = x () in\n Run_state.set_as_prover !state true ;\n As_prover.run_prover prover_block ) )\n in\n Run_state.set_as_prover !state true ;\n res )\n\n module Run_and_check_deferred (M : sig\n type _ t\n\n val return : 'a -> 'a t\n\n val map : 'a t -> f:('a -> 'b) -> 'b t\n end) =\n struct\n open M\n\n let run_and_check_exn ~run t =\n map (run_and_check_deferred_exn' ~run t ~map) ~f:(fun (x, get_value) ->\n let x = Basic.As_prover.run x get_value in\n x )\n\n let run_and_check ~run t =\n map\n (run_and_check_deferred' ~run t ~map ~return)\n ~f:\n (Or_error.map ~f:(fun (x, get_value) ->\n let x = Basic.As_prover.run x get_value in\n x ) )\n\n let as_stateful x state' =\n state := state' ;\n map (x ()) ~f:(fun a -> (!state, a))\n\n let run_and_check_exn (type a) (x : unit -> (unit -> a) As_prover.t M.t) :\n a M.t =\n finalize_is_running (fun () ->\n let mark_active = mark_active_deferred ~map in\n let res =\n run_and_check_exn ~run:as_stateful (fun () ->\n mark_active ~f:(fun () ->\n map (x ()) ~f:(fun prover_block ->\n Run_state.set_as_prover !state true ;\n As_prover.run_prover prover_block ) ) )\n in\n Run_state.set_as_prover !state true ;\n res )\n\n let run_and_check (type a) (x : unit -> (unit -> a) As_prover.t M.t) :\n a Or_error.t M.t =\n finalize_is_running (fun () ->\n let mark_active = mark_active_deferred ~map in\n let res =\n run_and_check ~run:as_stateful (fun () ->\n mark_active ~f:(fun () ->\n map (x ()) ~f:(fun prover_block ->\n Run_state.set_as_prover !state true ;\n As_prover.run_prover prover_block ) ) )\n in\n Run_state.set_as_prover !state true ;\n res )\n end\n\n let check_exn x : unit =\n finalize_is_running (fun () -> Perform.check_exn ~run:as_stateful x)\n\n let check x : unit Or_error.t =\n finalize_is_running (fun () -> Perform.check ~run:as_stateful x)\n\n let constraint_count ?(weight = Fn.const 1) ?log x =\n let count = ref 0 in\n let log_constraint ?at_label_boundary c =\n ( match at_label_boundary with\n | None ->\n ()\n | Some (pos, lab) ->\n Option.iter log ~f:(fun f ->\n let start =\n Some (match pos with `Start -> true | _ -> false)\n in\n f ?start lab !count ) ) ;\n count := !count + Option.value_map ~default:0 ~f:weight c\n in\n (* TODO(mrmr1993): Enable label-level logging for the imperative API. *)\n let old = !state in\n state :=\n Runner.State.make ~num_inputs:0 ~input:Vector.null ~aux:Vector.null\n ~next_auxiliary:(ref 0) ~eval_constraints:false ~with_witness:false\n ~log_constraint () ;\n ignore (mark_active ~f:x) ;\n state := old ;\n !count\n\n module Internal_Basic = Snark\n\n let run_checked = run\n end\n\n module Make (Backend : Backend_intf.S) = struct\n module Basic = Make_basic (Backend)\n include Basic\n module Number = Number.Run.Make (Basic)\n module Enumerable = Enumerable.Run.Make (Basic)\n end\nend\n\ntype 'field m = (module Snark_intf.Run with type field = 'field)\n\nlet make (type field) (module Backend : Backend_intf.S with type Field.t = field)\n : field m =\n (module Run.Make (Backend))\n","type bigstring =\n (char, Bigarray.int8_unsigned_elt, Bigarray.c_layout) Bigarray.Array1.t\n\ntype t = bigstring\n\nlet create size = Bigarray.(Array1.create char c_layout size)\nlet empty = create 0\n\nmodule BA1 = Bigarray.Array1\n\nlet length t = BA1.dim t\n\nexternal get : t -> int -> char = \"%caml_ba_ref_1\"\nexternal set : t -> int -> char -> unit = \"%caml_ba_set_1\"\n\nexternal unsafe_get : t -> int -> char = \"%caml_ba_unsafe_ref_1\"\nexternal unsafe_set : t -> int -> char -> unit = \"%caml_ba_unsafe_set_1\"\n\nexternal unsafe_blit : t -> src_off:int -> t -> dst_off:int -> len:int -> unit =\n \"bigstringaf_blit_to_bigstring\" [@@noalloc]\n\nexternal unsafe_blit_to_bytes : t -> src_off:int -> Bytes.t -> dst_off:int -> len:int -> unit =\n \"bigstringaf_blit_to_bytes\" [@@noalloc]\n\nexternal unsafe_blit_from_bytes : Bytes.t -> src_off:int -> t -> dst_off:int -> len:int -> unit =\n \"bigstringaf_blit_from_bytes\" [@@noalloc]\n\nexternal unsafe_blit_from_string : string -> src_off:int -> t -> dst_off:int -> len:int -> unit =\n \"bigstringaf_blit_from_bytes\" [@@noalloc]\n\nexternal unsafe_memcmp : t -> int -> t -> int -> int -> int =\n \"bigstringaf_memcmp_bigstring\" [@@noalloc]\n\nexternal unsafe_memcmp_string : t -> int -> string -> int -> int -> int =\n \"bigstringaf_memcmp_string\" [@@noalloc]\n\nlet sub t ~off ~len =\n BA1.sub t off len\n\nlet[@inline never] invalid_bounds op buffer_len off len =\n let message =\n Printf.sprintf \"Bigstringaf.%s invalid range: { buffer_len: %d, off: %d, len: %d }\"\n op buffer_len off len\n in\n raise (Invalid_argument message)\n;;\n\nlet[@inline never] invalid_bounds_blit op src_len src_off dst_len dst_off len =\n let message =\n Printf.sprintf \"Bigstringaf.%s invalid range: { src_len: %d, src_off: %d, dst_len: %d, dst_off: %d, len: %d }\"\n op src_len src_off dst_len dst_off len\n in\n raise (Invalid_argument message)\n;;\n\nlet[@inline never] invalid_bounds_memcmp op buf1_len buf1_off buf2_len buf2_off len =\n let message =\n Printf.sprintf \"Bigstringaf.%s invalid range: { buf1_len: %d, buf1_off: %d, buf2_len: %d, buf2_off: %d, len: %d }\"\n op buf1_len buf1_off buf2_len buf2_off len\n in\n raise (Invalid_argument message)\n;;\n\n(* A note on bounds checking.\n *\n * The code should perform the following check to ensure that the blit doesn't\n * run off the end of the input buffer:\n *\n * {[off + len <= buffer_len]}\n *\n * However, this may lead to an interger overflow for large values of [off],\n * e.g., [max_int], which will cause the comparison to return [true] when it\n * should really return [false].\n *\n * An equivalent comparison that does not run into this integer overflow\n * problem is:\n *\n * {[buffer_len - off => len]}\n *\n * This is checking that the input buffer, less the offset, is sufficiently\n * long to perform the blit. Since the expression is subtracting [off] rather\n * than adding it, it doesn't suffer from the overflow that the previous\n * inequality did. As long as there is check to ensure that [off] is not\n * negative, it won't underflow either. *)\n\nlet copy t ~off ~len =\n let buffer_len = length t in\n if len < 0 || off < 0 || buffer_len - off < len\n then invalid_bounds \"copy\" buffer_len off len;\n let dst = create len in\n unsafe_blit t ~src_off:off dst ~dst_off:0 ~len;\n dst\n;;\n\nlet substring t ~off ~len =\n let buffer_len = length t in\n if len < 0 || off < 0 || buffer_len - off < len\n then invalid_bounds \"substring\" buffer_len off len;\n let b = Bytes.create len in\n unsafe_blit_to_bytes t ~src_off:off b ~dst_off:0 ~len;\n Bytes.unsafe_to_string b\n;;\n\nlet to_string t =\n let len = length t in\n let b = Bytes.create len in\n unsafe_blit_to_bytes t ~src_off:0 b ~dst_off:0 ~len;\n Bytes.unsafe_to_string b\n;;\n\nlet of_string ~off ~len s =\n let buffer_len = String.length s in\n if len < 0 || off < 0 || buffer_len - off < len\n then invalid_bounds \"of_string\" buffer_len off len;\n let b = create len in\n unsafe_blit_from_string s ~src_off:off b ~dst_off:0 ~len;\n b\n;;\n\nlet blit src ~src_off dst ~dst_off ~len =\n let src_len = length src in\n let dst_len = length dst in\n if len < 0\n then invalid_bounds_blit \"blit\" src_len src_off dst_len dst_off len;\n if src_off < 0 || src_len - src_off < len\n then invalid_bounds_blit \"blit\" src_len src_off dst_len dst_off len;\n if dst_off < 0 || dst_len - dst_off < len\n then invalid_bounds_blit \"blit\" src_len src_off dst_len dst_off len;\n unsafe_blit src ~src_off dst ~dst_off ~len\n;;\n\nlet blit_from_string src ~src_off dst ~dst_off ~len =\n let src_len = String.length src in\n let dst_len = length dst in\n if len < 0\n then invalid_bounds_blit \"blit_from_string\" src_len src_off dst_len dst_off len;\n if src_off < 0 || src_len - src_off < len\n then invalid_bounds_blit \"blit_from_string\" src_len src_off dst_len dst_off len;\n if dst_off < 0 || dst_len - dst_off < len\n then invalid_bounds_blit \"blit_from_string\" src_len src_off dst_len dst_off len;\n unsafe_blit_from_string src ~src_off dst ~dst_off ~len\n;;\n\nlet blit_from_bytes src ~src_off dst ~dst_off ~len =\n let src_len = Bytes.length src in\n let dst_len = length dst in\n if len < 0\n then invalid_bounds_blit \"blit_from_bytes\" src_len src_off dst_len dst_off len;\n if src_off < 0 || src_len - src_off < len\n then invalid_bounds_blit \"blit_from_bytes\" src_len src_off dst_len dst_off len;\n if dst_off < 0 || dst_len - dst_off < len\n then invalid_bounds_blit \"blit_from_bytes\" src_len src_off dst_len dst_off len;\n unsafe_blit_from_bytes src ~src_off dst ~dst_off ~len\n;;\n\nlet blit_to_bytes src ~src_off dst ~dst_off ~len =\n let src_len = length src in\n let dst_len = Bytes.length dst in\n if len < 0\n then invalid_bounds_blit \"blit_to_bytes\" src_len src_off dst_len dst_off len;\n if src_off < 0 || src_len - src_off < len\n then invalid_bounds_blit \"blit_to_bytes\" src_len src_off dst_len dst_off len;\n if dst_off < 0 || dst_len - dst_off < len\n then invalid_bounds_blit \"blit_to_bytes\" src_len src_off dst_len dst_off len;\n unsafe_blit_to_bytes src ~src_off dst ~dst_off ~len\n;;\n\nlet memcmp buf1 buf1_off buf2 buf2_off len =\n let buf1_len = length buf1 in\n let buf2_len = length buf2 in\n if len < 0\n then invalid_bounds_memcmp \"memcmp\" buf1_len buf1_off buf2_len buf2_off len;\n if buf1_off < 0 || buf1_len - buf1_off < len\n then invalid_bounds_memcmp \"memcmp\" buf1_len buf1_off buf2_len buf2_off len;\n if buf2_off < 0 || buf2_len - buf2_off < len\n then invalid_bounds_memcmp \"memcmp\" buf1_len buf1_off buf2_len buf2_off len;\n unsafe_memcmp buf1 buf1_off buf2 buf2_off len\n;;\n\nlet memcmp_string buf1 buf1_off buf2 buf2_off len =\n let buf1_len = length buf1 in\n let buf2_len = String.length buf2 in\n if len < 0\n then invalid_bounds_memcmp \"memcmp_string\" buf1_len buf1_off buf2_len buf2_off len;\n if buf1_off < 0 || buf1_len - buf1_off < len\n then invalid_bounds_memcmp \"memcmp_string\" buf1_len buf1_off buf2_len buf2_off len;\n if buf2_off < 0 || buf2_len - buf2_off < len\n then invalid_bounds_memcmp \"memcmp_string\" buf1_len buf1_off buf2_len buf2_off len;\n unsafe_memcmp_string buf1 buf1_off buf2 buf2_off len\n;;\n\n\n(* Safe operations *)\n\nexternal caml_bigstring_set_16 : bigstring -> int -> int -> unit = \"%caml_bigstring_set16\"\nexternal caml_bigstring_set_32 : bigstring -> int -> int32 -> unit = \"%caml_bigstring_set32\"\nexternal caml_bigstring_set_64 : bigstring -> int -> int64 -> unit = \"%caml_bigstring_set64\"\n\nexternal caml_bigstring_get_16 : bigstring -> int -> int = \"%caml_bigstring_get16\"\nexternal caml_bigstring_get_32 : bigstring -> int -> int32 = \"%caml_bigstring_get32\"\nexternal caml_bigstring_get_64 : bigstring -> int -> int64 = \"%caml_bigstring_get64\"\n\nmodule Swap = struct\n external bswap16 : int -> int = \"%bswap16\"\n external bswap_int32 : int32 -> int32 = \"%bswap_int32\"\n external bswap_int64 : int64 -> int64 = \"%bswap_int64\"\n\n let caml_bigstring_set_16 bs off i =\n caml_bigstring_set_16 bs off (bswap16 i)\n\n let caml_bigstring_set_32 bs off i =\n caml_bigstring_set_32 bs off (bswap_int32 i)\n\n let caml_bigstring_set_64 bs off i =\n caml_bigstring_set_64 bs off (bswap_int64 i)\n\n let caml_bigstring_get_16 bs off =\n bswap16 (caml_bigstring_get_16 bs off)\n\n let caml_bigstring_get_32 bs off =\n bswap_int32 (caml_bigstring_get_32 bs off)\n\n let caml_bigstring_get_64 bs off =\n bswap_int64 (caml_bigstring_get_64 bs off)\n\n let get_int16_sign_extended x off =\n ((caml_bigstring_get_16 x off) lsl (Sys.int_size - 16)) asr (Sys.int_size - 16)\nend\n\nlet set_int16_le, set_int16_be =\n if Sys.big_endian\n then Swap.caml_bigstring_set_16, caml_bigstring_set_16\n else caml_bigstring_set_16 , Swap.caml_bigstring_set_16\n\nlet set_int32_le, set_int32_be =\n if Sys.big_endian\n then Swap.caml_bigstring_set_32, caml_bigstring_set_32\n else caml_bigstring_set_32 , Swap.caml_bigstring_set_32\n\nlet set_int64_le, set_int64_be =\n if Sys.big_endian\n then Swap.caml_bigstring_set_64, caml_bigstring_set_64\n else caml_bigstring_set_64 , Swap.caml_bigstring_set_64\n\nlet get_int16_le, get_int16_be =\n if Sys.big_endian\n then Swap.caml_bigstring_get_16, caml_bigstring_get_16\n else caml_bigstring_get_16 , Swap.caml_bigstring_get_16\n\nlet get_int16_sign_extended_noswap x off =\n ((caml_bigstring_get_16 x off) lsl (Sys.int_size - 16)) asr (Sys.int_size - 16)\n\nlet get_int16_sign_extended_le, get_int16_sign_extended_be =\n if Sys.big_endian\n then Swap.get_int16_sign_extended , get_int16_sign_extended_noswap\n else get_int16_sign_extended_noswap, Swap.get_int16_sign_extended\n\nlet get_int32_le, get_int32_be =\n if Sys.big_endian\n then Swap.caml_bigstring_get_32, caml_bigstring_get_32\n else caml_bigstring_get_32 , Swap.caml_bigstring_get_32\n\nlet get_int64_le, get_int64_be =\n if Sys.big_endian\n then Swap.caml_bigstring_get_64, caml_bigstring_get_64\n else caml_bigstring_get_64 , Swap.caml_bigstring_get_64\n\n(* Unsafe operations *)\n\nexternal caml_bigstring_unsafe_set_16 : bigstring -> int -> int -> unit = \"%caml_bigstring_set16u\"\nexternal caml_bigstring_unsafe_set_32 : bigstring -> int -> int32 -> unit = \"%caml_bigstring_set32u\"\nexternal caml_bigstring_unsafe_set_64 : bigstring -> int -> int64 -> unit = \"%caml_bigstring_set64u\"\n\nexternal caml_bigstring_unsafe_get_16 : bigstring -> int -> int = \"%caml_bigstring_get16u\"\nexternal caml_bigstring_unsafe_get_32 : bigstring -> int -> int32 = \"%caml_bigstring_get32u\"\nexternal caml_bigstring_unsafe_get_64 : bigstring -> int -> int64 = \"%caml_bigstring_get64u\"\n\nmodule USwap = struct\n external bswap16 : int -> int = \"%bswap16\"\n external bswap_int32 : int32 -> int32 = \"%bswap_int32\"\n external bswap_int64 : int64 -> int64 = \"%bswap_int64\"\n\n let caml_bigstring_unsafe_set_16 bs off i =\n caml_bigstring_unsafe_set_16 bs off (bswap16 i)\n\n let caml_bigstring_unsafe_set_32 bs off i =\n caml_bigstring_unsafe_set_32 bs off (bswap_int32 i)\n\n let caml_bigstring_unsafe_set_64 bs off i =\n caml_bigstring_unsafe_set_64 bs off (bswap_int64 i)\n\n let caml_bigstring_unsafe_get_16 bs off =\n bswap16 (caml_bigstring_unsafe_get_16 bs off)\n\n let caml_bigstring_unsafe_get_32 bs off =\n bswap_int32 (caml_bigstring_unsafe_get_32 bs off)\n\n let caml_bigstring_unsafe_get_64 bs off =\n bswap_int64 (caml_bigstring_unsafe_get_64 bs off)\nend\n\nlet unsafe_set_int16_le, unsafe_set_int16_be =\n if Sys.big_endian\n then USwap.caml_bigstring_unsafe_set_16, caml_bigstring_unsafe_set_16\n else caml_bigstring_unsafe_set_16 , USwap.caml_bigstring_unsafe_set_16\n\nlet unsafe_set_int32_le, unsafe_set_int32_be =\n if Sys.big_endian\n then USwap.caml_bigstring_unsafe_set_32, caml_bigstring_unsafe_set_32\n else caml_bigstring_unsafe_set_32 , USwap.caml_bigstring_unsafe_set_32\n\nlet unsafe_set_int64_le, unsafe_set_int64_be =\n if Sys.big_endian\n then USwap.caml_bigstring_unsafe_set_64, caml_bigstring_unsafe_set_64\n else caml_bigstring_unsafe_set_64 , USwap.caml_bigstring_unsafe_set_64\n\nlet unsafe_get_int16_le, unsafe_get_int16_be =\n if Sys.big_endian\n then USwap.caml_bigstring_unsafe_get_16, caml_bigstring_unsafe_get_16\n else caml_bigstring_unsafe_get_16 , USwap.caml_bigstring_unsafe_get_16\n\nlet unsafe_get_int16_sign_extended_le x off =\n ((unsafe_get_int16_le x off) lsl (Sys.int_size - 16)) asr (Sys.int_size - 16)\n\nlet unsafe_get_int16_sign_extended_be x off =\n ((unsafe_get_int16_be x off ) lsl (Sys.int_size - 16)) asr (Sys.int_size - 16)\n\nlet unsafe_get_int32_le, unsafe_get_int32_be =\n if Sys.big_endian\n then USwap.caml_bigstring_unsafe_get_32, caml_bigstring_unsafe_get_32\n else caml_bigstring_unsafe_get_32 , USwap.caml_bigstring_unsafe_get_32\n\nlet unsafe_get_int64_le, unsafe_get_int64_be =\n if Sys.big_endian\n then USwap.caml_bigstring_unsafe_get_64, caml_bigstring_unsafe_get_64\n else caml_bigstring_unsafe_get_64 , USwap.caml_bigstring_unsafe_get_64\n","open Core_kernel\n\nmodule type Field_intf = sig\n type t\n\n val size_in_bits : int\n\n val negate : t -> t\n\n val ( - ) : t -> t -> t\n\n val ( + ) : t -> t -> t\n\n val ( * ) : t -> t -> t\n\n val ( / ) : t -> t -> t\n\n val inv : t -> t\n\n val zero : t\n\n val one : t\n\n val of_int : int -> t\nend\n\nlet two_to_the (type f) (module F : Field_intf with type t = f) =\n let rec two_to_the n =\n if n = 0 then F.one\n else\n let r = two_to_the (n - 1) in\n F.(r + r)\n in\n two_to_the\n\n(* Our custom constraints let us efficiently compute\n\n f = fun (g, t) -> (2 * t + 1 + 2^len(t)) g\n\n We want to compute\n\n f' = fun (g, s) -> s * g\n\n Let n be the field size in bits.\n\n For a scalar s, let t = (s - 2^n - 1)/2.\n t can be represented with an n bit string.\n\n Then\n\n f (g, t)\n = (2 t + 2^n + 1) * g\n = (2 (s - 2^n - 1)/2 + 2^n + 1) * g\n = (s - 2^n - 1 + 2^n + 1) * g\n = s * g\n = f' (g, s)\n\n as desired.\n*)\n\nmodule type S = sig\n [%%versioned:\n module Stable : sig\n module V1 : sig\n type 'f t [@@deriving sexp, compare, equal, yojson, hash]\n end\n end]\n\n val typ :\n ('a, 'b, 'f) Snarky_backendless.Typ.t\n -> ('a t, 'b t, 'f) Snarky_backendless.Typ.t\n\n val map : 'a t -> f:('a -> 'b) -> 'b t\n\n module Shift : sig\n type _ t\n\n val create : (module Field_intf with type t = 'f) -> 'f t\n\n val map : 'a t -> f:('a -> 'b) -> 'b t\n end\n\n val of_field :\n (module Field_intf with type t = 'f) -> shift:'f Shift.t -> 'f -> 'f t\n\n val to_field :\n (module Field_intf with type t = 'f) -> shift:'f Shift.t -> 'f t -> 'f\n\n val equal : ('f, 'res) Sigs.rel2 -> ('f t, 'res) Sigs.rel2\nend\n\n[@@@warning \"-4\"]\n\nmodule Type1 = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type 'f t = Shifted_value of 'f\n [@@deriving sexp, compare, equal, yojson, hash]\n end\n end]\n\n let typ f =\n let there (Shifted_value x) = x in\n let back x = Shifted_value x in\n Snarky_backendless.Typ.(\n transport_var (transport f ~there ~back) ~there ~back)\n\n let map (Shifted_value x) ~f = Shifted_value (f x)\n\n module Shift : sig\n type 'f t = private { c : 'f; scale : 'f }\n\n val create : (module Field_intf with type t = 'f) -> 'f t\n\n val map : 'a t -> f:('a -> 'b) -> 'b t\n end = struct\n type 'f t = { c : 'f; scale : 'f }\n\n let map t ~f = { c = f t.c; scale = f t.scale }\n\n (* 2^{field size in bits} + 1 *)\n let create (type f) (module F : Field_intf with type t = f) : f t =\n { c = F.(two_to_the (module F) size_in_bits + one)\n ; scale = F.(inv (of_int 2))\n }\n end\n\n let of_field (type f) (module F : Field_intf with type t = f)\n ~(shift : f Shift.t) (s : f) : f t =\n Shifted_value F.((s - shift.c) * shift.scale)\n\n let to_field (type f) (module F : Field_intf with type t = f)\n ~(shift : f Shift.t) (Shifted_value t : f t) : f =\n F.(t + t + shift.c)\n\n let equal equal (Shifted_value t1) (Shifted_value t2) = equal t1 t2\nend\n\n(* When the scalar field is larger than the inner field of the circuit,\n we need to encode a scalar [s] as a pair ((s >> 1), s & 1). In other\n words, the high bits, and then the low bit separately.\n\n We can then efficiently compute the function\n\n f = fun (g, s) -> (2 * (s >> 1) + (s & 1) + 2^(5 * ceil(len(s >> 1) / 5))) g\n = fun (g, s) -> (s + 2^field_size_in_bits) g\n\n This is a different notion of shifted value, so we have a separate type for it.\n*)\n\nmodule Type2 = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type 'f t = Shifted_value of 'f\n [@@deriving sexp, compare, equal, yojson, hash]\n end\n end]\n\n let typ f =\n let there (Shifted_value x) = x in\n let back x = Shifted_value x in\n Snarky_backendless.Typ.(\n transport_var (transport f ~there ~back) ~there ~back)\n\n let map (Shifted_value x) ~f = Shifted_value (f x)\n\n module Shift : sig\n type 'f t = private 'f\n\n val create : (module Field_intf with type t = 'f) -> 'f t\n\n val map : 'a t -> f:('a -> 'b) -> 'b t\n end = struct\n type 'f t = 'f\n\n let map t ~f = f t\n\n (* 2^{field size in bits} *)\n let create (type f) (module F : Field_intf with type t = f) : f t =\n two_to_the (module F) F.size_in_bits\n end\n\n let of_field (type f) (module F : Field_intf with type t = f)\n ~(shift : f Shift.t) (s : f) : f t =\n Shifted_value F.(s - (shift :> t))\n\n let to_field (type f) (module F : Field_intf with type t = f)\n ~(shift : f Shift.t) (Shifted_value t : f t) : f =\n F.(t + (shift :> t))\n\n let equal equal (Shifted_value t1) (Shifted_value t2) = equal t1 t2\nend\n","open Core_kernel\n\nlet padded_array_typ ~length ~dummy elt =\n Snarky_backendless.Typ.array ~length elt\n |> Snarky_backendless.Typ.transport\n ~there:(fun a ->\n let n = Array.length a in\n if n > length then failwithf \"Expected %d <= %d\" n length () ;\n Array.append a (Array.create ~len:(length - n) dummy) )\n ~back:Fn.id\n\nlet hash_fold_array f s x = hash_fold_list f s (Array.to_list x)\n\nmodule Columns = Nat.N15\nmodule Columns_vec = Vector.Vector_15\nmodule Permuts_minus_1 = Nat.N6\nmodule Permuts_minus_1_vec = Vector.Vector_6\nmodule Permuts = Nat.N7\nmodule Permuts_vec = Vector.Vector_7\nmodule Lookup_sorted_vec = Vector.Vector_5\n\nmodule Opt = struct\n [@@@warning \"-4\"]\n\n type ('a, 'bool) t = Some of 'a | None | Maybe of 'bool * 'a\n [@@deriving sexp, compare, yojson, hash, equal]\n\n let to_option : ('a, bool) t -> 'a option = function\n | Some x ->\n Some x\n | Maybe (true, x) ->\n Some x\n | Maybe (false, _x) ->\n None\n | None ->\n None\n\n let to_option_unsafe : ('a, 'bool) t -> 'a option = function\n | Some x ->\n Some x\n | Maybe (_, x) ->\n Some x\n | None ->\n None\n\n let value_exn = function\n | Some x ->\n x\n | Maybe (_, x) ->\n x\n | None ->\n invalid_arg \"Opt.value_exn\"\n\n let of_option (t : 'a option) : ('a, 'bool) t =\n match t with None -> None | Some x -> Some x\n\n module Flag = struct\n type t = Yes | No | Maybe [@@deriving sexp, compare, yojson, hash, equal]\n\n let ( ||| ) x y =\n match (x, y) with\n | Yes, _ | _, Yes ->\n Yes\n | Maybe, _ | _, Maybe ->\n Maybe\n | No, No ->\n No\n end\n\n let map t ~f =\n match t with\n | None ->\n None\n | Some x ->\n Some (f x)\n | Maybe (b, x) ->\n Maybe (b, f x)\n\n open Snarky_backendless\n\n let some_typ (type a a_var f bool_var) (t : (a_var, a, f) Typ.t) :\n ((a_var, bool_var) t, a option, f) Typ.t =\n Typ.transport t ~there:(fun x -> Option.value_exn x) ~back:Option.return\n |> Typ.transport_var\n ~there:(function\n | Some x ->\n x\n | Maybe _ | None ->\n failwith \"Opt.some_typ: expected Some\" )\n ~back:(fun x -> Some x)\n\n let none_typ (type a a_var f bool) () : ((a_var, bool) t, a option, f) Typ.t =\n Typ.transport (Typ.unit ())\n ~there:(fun _ -> ())\n ~back:(fun () : _ Option.t -> None)\n |> Typ.transport_var\n ~there:(function\n | None ->\n ()\n | Maybe _ | Some _ ->\n failwith \"Opt.none_typ: expected None\" )\n ~back:(fun () : _ t -> None)\n\n let maybe_typ (type a a_var bool_var f)\n (bool_typ : (bool_var, bool, f) Snarky_backendless.Typ.t) ~(dummy : a)\n (a_typ : (a_var, a, f) Typ.t) : ((a_var, bool_var) t, a option, f) Typ.t =\n Typ.transport\n (Typ.tuple2 bool_typ a_typ)\n ~there:(fun (t : a option) ->\n match t with None -> (false, dummy) | Some x -> (true, x) )\n ~back:(fun (b, x) -> if b then Some x else None)\n |> Typ.transport_var\n ~there:(fun (t : (a_var, _) t) ->\n match t with\n | Maybe (b, x) ->\n (b, x)\n | None | Some _ ->\n failwith \"Opt.maybe_typ: expected Maybe\" )\n ~back:(fun (b, x) -> Maybe (b, x))\n\n let constant_layout_typ (type a a_var f) (bool_typ : _ Typ.t) ~true_ ~false_\n (flag : Flag.t) (a_typ : (a_var, a, f) Typ.t) ~(dummy : a)\n ~(dummy_var : a_var) =\n let (Typ bool_typ) = bool_typ in\n let bool_typ : _ Typ.t =\n let check =\n (* No need to boolean constrain in the No or Yes case *)\n match flag with\n | No | Yes ->\n fun _ -> Checked_runner.Simple.return ()\n | Maybe ->\n bool_typ.check\n in\n Typ { bool_typ with check }\n in\n Typ.transport\n (Typ.tuple2 bool_typ a_typ)\n ~there:(fun (t : a option) ->\n match t with None -> (false, dummy) | Some x -> (true, x) )\n ~back:(fun (b, x) -> if b then Some x else None)\n |> Typ.transport_var\n ~there:(fun (t : (a_var, _) t) ->\n match t with\n | Maybe (b, x) ->\n (b, x)\n | None ->\n (false_, dummy_var)\n | Some x ->\n (true_, x) )\n ~back:(fun (b, x) ->\n match flag with No -> None | Yes -> Some x | Maybe -> Maybe (b, x) )\n\n let typ (type a a_var f) bool_typ (flag : Flag.t)\n (a_typ : (a_var, a, f) Typ.t) ~(dummy : a) =\n match flag with\n | Yes ->\n some_typ a_typ\n | No ->\n none_typ ()\n | Maybe ->\n maybe_typ bool_typ ~dummy a_typ\n\n module Early_stop_sequence = struct\n (* A sequence that should be considered to have stopped at\n the first No flag *)\n (* TODO: The documentation above makes it sound like the type below is too\n generic: we're not guaranteed to have flags in there *)\n type nonrec ('a, 'bool) t = ('a, 'bool) t list\n\n let fold (type a bool acc res)\n (if_res : bool -> then_:res -> else_:res -> res) (t : (a, bool) t)\n ~(init : acc) ~(f : acc -> a -> acc) ~(finish : acc -> res) =\n let rec go acc = function\n | [] ->\n finish acc\n | None :: xs ->\n go acc xs\n | Some x :: xs ->\n go (f acc x) xs\n | Maybe (b, x) :: xs ->\n (* Computing this first makes mutation in f OK. *)\n let stop_res = finish acc in\n let continue_res = go (f acc x) xs in\n if_res b ~then_:continue_res ~else_:stop_res\n in\n go init t\n end\nend\n\nmodule Features = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type 'bool t =\n { range_check0 : 'bool\n ; range_check1 : 'bool\n ; foreign_field_add : 'bool\n ; foreign_field_mul : 'bool\n ; xor : 'bool\n ; rot : 'bool\n ; lookup : 'bool\n ; runtime_tables : 'bool\n }\n [@@deriving sexp, compare, yojson, hash, equal, hlist]\n end\n end]\n\n type options = Opt.Flag.t t\n\n type flags = bool t\n\n let to_data\n { range_check0\n ; range_check1\n ; foreign_field_add\n ; foreign_field_mul\n ; xor\n ; rot\n ; lookup\n ; runtime_tables\n } : _ Hlist.HlistId.t =\n [ range_check0\n ; range_check1\n ; foreign_field_add\n ; foreign_field_mul\n ; xor\n ; rot\n ; lookup\n ; runtime_tables\n ]\n\n let of_data\n ([ range_check0\n ; range_check1\n ; foreign_field_add\n ; foreign_field_mul\n ; xor\n ; rot\n ; lookup\n ; runtime_tables\n ] :\n _ Hlist.HlistId.t ) =\n { range_check0\n ; range_check1\n ; foreign_field_add\n ; foreign_field_mul\n ; xor\n ; rot\n ; lookup\n ; runtime_tables\n }\n\n let typ bool\n ~feature_flags:\n { range_check0\n ; range_check1\n ; foreign_field_add\n ; foreign_field_mul\n ; xor\n ; rot\n ; lookup\n ; runtime_tables\n } =\n (* TODO: This should come from snarky. *)\n let constant (type var value)\n (typ : (var, value, _) Snarky_backendless.Typ.t) (x : value) : var =\n let (Typ typ) = typ in\n let fields, aux = typ.value_to_fields x in\n let fields =\n Array.map ~f:(fun x -> Snarky_backendless.Cvar.Constant x) fields\n in\n typ.var_of_fields (fields, aux)\n in\n let constant_typ ~there value =\n let open Snarky_backendless.Typ in\n unit ()\n |> transport ~there ~back:(fun () -> value)\n |> transport_var ~there:(fun _ -> ()) ~back:(fun () -> constant bool value)\n in\n let bool_typ_of_flag = function\n | Opt.Flag.Yes ->\n constant_typ\n ~there:(function true -> () | false -> assert false)\n true\n | Opt.Flag.No ->\n constant_typ\n ~there:(function false -> () | true -> assert false)\n false\n | Opt.Flag.Maybe ->\n bool\n in\n Snarky_backendless.Typ.of_hlistable\n [ bool_typ_of_flag range_check0\n ; bool_typ_of_flag range_check1\n ; bool_typ_of_flag foreign_field_add\n ; bool_typ_of_flag foreign_field_mul\n ; bool_typ_of_flag xor\n ; bool_typ_of_flag rot\n ; bool_typ_of_flag lookup\n ; bool_typ_of_flag runtime_tables\n ]\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist\n\n let none =\n { range_check0 = Opt.Flag.No\n ; range_check1 = Opt.Flag.No\n ; foreign_field_add = Opt.Flag.No\n ; foreign_field_mul = Opt.Flag.No\n ; xor = Opt.Flag.No\n ; rot = Opt.Flag.No\n ; lookup = Opt.Flag.No\n ; runtime_tables = Opt.Flag.No\n }\n\n let none_bool =\n { range_check0 = false\n ; range_check1 = false\n ; foreign_field_add = false\n ; foreign_field_mul = false\n ; xor = false\n ; rot = false\n ; lookup = false\n ; runtime_tables = false\n }\n\n let map\n { range_check0\n ; range_check1\n ; foreign_field_add\n ; foreign_field_mul\n ; rot\n ; xor\n ; lookup\n ; runtime_tables\n } ~f =\n { range_check0 = f range_check0\n ; range_check1 = f range_check1\n ; foreign_field_add = f foreign_field_add\n ; foreign_field_mul = f foreign_field_mul\n ; xor = f xor\n ; rot = f rot\n ; lookup = f lookup\n ; runtime_tables = f runtime_tables\n }\n\n let map2 x1 x2 ~f =\n { range_check0 = f x1.range_check0 x2.range_check0\n ; range_check1 = f x1.range_check1 x2.range_check1\n ; foreign_field_add = f x1.foreign_field_add x2.foreign_field_add\n ; foreign_field_mul = f x1.foreign_field_mul x2.foreign_field_mul\n ; xor = f x1.xor x2.xor\n ; rot = f x1.rot x2.rot\n ; lookup = f x1.lookup x2.lookup\n ; runtime_tables = f x1.runtime_tables x2.runtime_tables\n }\nend\n\nmodule Evals = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type 'a t =\n { w : 'a Columns_vec.Stable.V1.t\n ; coefficients : 'a Columns_vec.Stable.V1.t\n ; z : 'a\n ; s : 'a Permuts_minus_1_vec.Stable.V1.t\n ; generic_selector : 'a\n ; poseidon_selector : 'a\n ; complete_add_selector : 'a\n ; mul_selector : 'a\n ; emul_selector : 'a\n ; endomul_scalar_selector : 'a\n ; range_check0_selector : 'a option\n ; range_check1_selector : 'a option\n ; foreign_field_add_selector : 'a option\n ; foreign_field_mul_selector : 'a option\n ; xor_selector : 'a option\n ; rot_selector : 'a option\n ; lookup_aggregation : 'a option\n ; lookup_table : 'a option\n ; lookup_sorted : 'a option Lookup_sorted_vec.Stable.V1.t\n ; runtime_lookup_table : 'a option\n ; runtime_lookup_table_selector : 'a option\n ; xor_lookup_selector : 'a option\n ; lookup_gate_lookup_selector : 'a option\n ; range_check_lookup_selector : 'a option\n ; foreign_field_mul_lookup_selector : 'a option\n }\n [@@deriving fields, sexp, compare, yojson, hash, equal, hlist]\n end\n end]\n\n let validate_feature_flags ~feature_flags:(f : bool Features.t)\n { w = _\n ; coefficients = _\n ; z = _\n ; s = _\n ; generic_selector = _\n ; poseidon_selector = _\n ; complete_add_selector = _\n ; mul_selector = _\n ; emul_selector = _\n ; endomul_scalar_selector = _\n ; range_check0_selector\n ; range_check1_selector\n ; foreign_field_add_selector\n ; foreign_field_mul_selector\n ; xor_selector\n ; rot_selector\n ; lookup_aggregation\n ; lookup_table\n ; lookup_sorted\n ; runtime_lookup_table\n ; runtime_lookup_table_selector\n ; xor_lookup_selector\n ; lookup_gate_lookup_selector\n ; range_check_lookup_selector\n ; foreign_field_mul_lookup_selector\n } =\n let enable_if x flag = Bool.(Option.is_some x = flag) in\n let range_check_lookup = f.range_check0 || f.range_check1 || f.rot in\n let lookups_per_row_4 = f.xor || range_check_lookup in\n let lookups_per_row_3 = lookups_per_row_4 || f.lookup in\n let lookups_per_row_2 = lookups_per_row_3 || f.foreign_field_mul in\n Array.reduce_exn ~f:( && )\n [| enable_if range_check0_selector f.range_check0\n ; enable_if range_check1_selector f.range_check1\n ; enable_if foreign_field_add_selector f.foreign_field_add\n ; enable_if foreign_field_mul_selector f.foreign_field_mul\n ; enable_if xor_selector f.xor\n ; enable_if rot_selector f.rot\n ; enable_if lookup_aggregation lookups_per_row_2\n ; enable_if lookup_table lookups_per_row_2\n ; Vector.foldi lookup_sorted ~init:true ~f:(fun i acc x ->\n let flag =\n (* NB: lookups_per_row + 1 in sorted, due to the lookup table. *)\n match i with\n | 0 | 1 | 2 ->\n lookups_per_row_2\n | 3 ->\n lookups_per_row_3\n | 4 ->\n lookups_per_row_4\n | _ ->\n assert false\n in\n acc && enable_if x flag )\n ; enable_if runtime_lookup_table f.runtime_tables\n ; enable_if runtime_lookup_table_selector f.runtime_tables\n ; enable_if xor_lookup_selector f.xor\n ; enable_if lookup_gate_lookup_selector f.lookup\n ; enable_if range_check_lookup_selector range_check_lookup\n ; enable_if foreign_field_mul_lookup_selector f.foreign_field_mul\n |]\n\n let to_absorption_sequence\n { w\n ; coefficients\n ; z\n ; s\n ; generic_selector\n ; poseidon_selector\n ; complete_add_selector\n ; mul_selector\n ; emul_selector\n ; endomul_scalar_selector\n ; range_check0_selector\n ; range_check1_selector\n ; foreign_field_add_selector\n ; foreign_field_mul_selector\n ; xor_selector\n ; rot_selector\n ; lookup_aggregation\n ; lookup_table\n ; lookup_sorted\n ; runtime_lookup_table\n ; runtime_lookup_table_selector\n ; xor_lookup_selector\n ; lookup_gate_lookup_selector\n ; range_check_lookup_selector\n ; foreign_field_mul_lookup_selector\n } : _ list =\n let always_present =\n [ z\n ; generic_selector\n ; poseidon_selector\n ; complete_add_selector\n ; mul_selector\n ; emul_selector\n ; endomul_scalar_selector\n ]\n @ Vector.to_list w\n @ Vector.to_list coefficients\n @ Vector.to_list s\n in\n let optional_gates =\n List.filter_map ~f:Fn.id\n [ range_check0_selector\n ; range_check1_selector\n ; foreign_field_add_selector\n ; foreign_field_mul_selector\n ; xor_selector\n ; rot_selector\n ; lookup_aggregation\n ; lookup_table\n ]\n in\n let lookup_final_terms =\n List.filter_map ~f:Fn.id\n [ runtime_lookup_table\n ; runtime_lookup_table_selector\n ; xor_lookup_selector\n ; lookup_gate_lookup_selector\n ; range_check_lookup_selector\n ; foreign_field_mul_lookup_selector\n ]\n in\n always_present @ optional_gates\n @ List.filter_map ~f:Fn.id (Vector.to_list lookup_sorted)\n @ lookup_final_terms\n\n module In_circuit = struct\n type ('f, 'bool) t =\n { w : 'f Columns_vec.t\n ; coefficients : 'f Columns_vec.t\n ; z : 'f\n ; s : 'f Permuts_minus_1_vec.t\n ; generic_selector : 'f\n ; poseidon_selector : 'f\n ; complete_add_selector : 'f\n ; mul_selector : 'f\n ; emul_selector : 'f\n ; endomul_scalar_selector : 'f\n ; range_check0_selector : ('f, 'bool) Opt.t\n ; range_check1_selector : ('f, 'bool) Opt.t\n ; foreign_field_add_selector : ('f, 'bool) Opt.t\n ; foreign_field_mul_selector : ('f, 'bool) Opt.t\n ; xor_selector : ('f, 'bool) Opt.t\n ; rot_selector : ('f, 'bool) Opt.t\n ; lookup_aggregation : ('f, 'bool) Opt.t\n ; lookup_table : ('f, 'bool) Opt.t\n ; lookup_sorted : ('f, 'bool) Opt.t Lookup_sorted_vec.t\n ; runtime_lookup_table : ('f, 'bool) Opt.t\n ; runtime_lookup_table_selector : ('f, 'bool) Opt.t\n ; xor_lookup_selector : ('f, 'bool) Opt.t\n ; lookup_gate_lookup_selector : ('f, 'bool) Opt.t\n ; range_check_lookup_selector : ('f, 'bool) Opt.t\n ; foreign_field_mul_lookup_selector : ('f, 'bool) Opt.t\n }\n [@@deriving hlist, fields]\n\n let map (type bool a b)\n ({ w\n ; coefficients\n ; z\n ; s\n ; generic_selector\n ; poseidon_selector\n ; complete_add_selector\n ; mul_selector\n ; emul_selector\n ; endomul_scalar_selector\n ; range_check0_selector\n ; range_check1_selector\n ; foreign_field_add_selector\n ; foreign_field_mul_selector\n ; xor_selector\n ; rot_selector\n ; lookup_aggregation\n ; lookup_table\n ; lookup_sorted\n ; runtime_lookup_table\n ; runtime_lookup_table_selector\n ; xor_lookup_selector\n ; lookup_gate_lookup_selector\n ; range_check_lookup_selector\n ; foreign_field_mul_lookup_selector\n } :\n (a, bool) t ) ~(f : a -> b) : (b, bool) t =\n { w = Vector.map w ~f\n ; coefficients = Vector.map coefficients ~f\n ; z = f z\n ; s = Vector.map s ~f\n ; generic_selector = f generic_selector\n ; poseidon_selector = f poseidon_selector\n ; complete_add_selector = f complete_add_selector\n ; mul_selector = f mul_selector\n ; emul_selector = f emul_selector\n ; endomul_scalar_selector = f endomul_scalar_selector\n ; range_check0_selector = Opt.map ~f range_check0_selector\n ; range_check1_selector = Opt.map ~f range_check1_selector\n ; foreign_field_add_selector = Opt.map ~f foreign_field_add_selector\n ; foreign_field_mul_selector = Opt.map ~f foreign_field_mul_selector\n ; xor_selector = Opt.map ~f xor_selector\n ; rot_selector = Opt.map ~f rot_selector\n ; lookup_aggregation = Opt.map ~f lookup_aggregation\n ; lookup_table = Opt.map ~f lookup_table\n ; lookup_sorted = Vector.map ~f:(Opt.map ~f) lookup_sorted\n ; runtime_lookup_table = Opt.map ~f runtime_lookup_table\n ; runtime_lookup_table_selector = Opt.map ~f runtime_lookup_table_selector\n ; xor_lookup_selector = Opt.map ~f xor_lookup_selector\n ; lookup_gate_lookup_selector = Opt.map ~f lookup_gate_lookup_selector\n ; range_check_lookup_selector = Opt.map ~f range_check_lookup_selector\n ; foreign_field_mul_lookup_selector =\n Opt.map ~f foreign_field_mul_lookup_selector\n }\n\n let to_list\n { w\n ; coefficients\n ; z\n ; s\n ; generic_selector\n ; poseidon_selector\n ; complete_add_selector\n ; mul_selector\n ; emul_selector\n ; endomul_scalar_selector\n ; range_check0_selector\n ; range_check1_selector\n ; foreign_field_add_selector\n ; foreign_field_mul_selector\n ; xor_selector\n ; rot_selector\n ; lookup_aggregation\n ; lookup_table\n ; lookup_sorted\n ; runtime_lookup_table\n ; runtime_lookup_table_selector\n ; xor_lookup_selector\n ; lookup_gate_lookup_selector\n ; range_check_lookup_selector\n ; foreign_field_mul_lookup_selector\n } =\n let some x = Opt.Some x in\n let always_present =\n List.map ~f:some\n ( [ z\n ; generic_selector\n ; poseidon_selector\n ; complete_add_selector\n ; mul_selector\n ; emul_selector\n ; endomul_scalar_selector\n ]\n @ Vector.to_list w\n @ Vector.to_list coefficients\n @ Vector.to_list s )\n in\n let optional_gates =\n [ range_check0_selector\n ; range_check1_selector\n ; foreign_field_add_selector\n ; foreign_field_mul_selector\n ; xor_selector\n ; rot_selector\n ]\n in\n always_present @ optional_gates\n @ Vector.to_list lookup_sorted\n @ [ lookup_aggregation\n ; lookup_table\n ; runtime_lookup_table\n ; runtime_lookup_table_selector\n ; xor_lookup_selector\n ; lookup_gate_lookup_selector\n ; range_check_lookup_selector\n ; foreign_field_mul_lookup_selector\n ]\n\n let to_absorption_sequence\n { w\n ; coefficients\n ; z\n ; s\n ; generic_selector\n ; poseidon_selector\n ; complete_add_selector\n ; mul_selector\n ; emul_selector\n ; endomul_scalar_selector\n ; range_check0_selector\n ; range_check1_selector\n ; foreign_field_add_selector\n ; foreign_field_mul_selector\n ; xor_selector\n ; rot_selector\n ; lookup_aggregation\n ; lookup_table\n ; lookup_sorted\n ; runtime_lookup_table\n ; runtime_lookup_table_selector\n ; xor_lookup_selector\n ; lookup_gate_lookup_selector\n ; range_check_lookup_selector\n ; foreign_field_mul_lookup_selector\n } : _ Opt.Early_stop_sequence.t =\n let always_present =\n [ z\n ; generic_selector\n ; poseidon_selector\n ; complete_add_selector\n ; mul_selector\n ; emul_selector\n ; endomul_scalar_selector\n ]\n @ Vector.to_list w\n @ Vector.to_list coefficients\n @ Vector.to_list s\n in\n let optional_gates =\n [ range_check0_selector\n ; range_check1_selector\n ; foreign_field_add_selector\n ; foreign_field_mul_selector\n ; xor_selector\n ; rot_selector\n ; lookup_aggregation\n ; lookup_table\n ]\n in\n let some x = Opt.Some x in\n List.map ~f:some always_present\n @ optional_gates\n @ Vector.to_list lookup_sorted\n @ [ runtime_lookup_table\n ; runtime_lookup_table_selector\n ; xor_lookup_selector\n ; lookup_gate_lookup_selector\n ; range_check_lookup_selector\n ; foreign_field_mul_lookup_selector\n ]\n end\n\n let to_in_circuit (type bool a)\n ({ w\n ; coefficients\n ; z\n ; s\n ; generic_selector\n ; poseidon_selector\n ; complete_add_selector\n ; mul_selector\n ; emul_selector\n ; endomul_scalar_selector\n ; range_check0_selector\n ; range_check1_selector\n ; foreign_field_add_selector\n ; foreign_field_mul_selector\n ; xor_selector\n ; rot_selector\n ; lookup_aggregation\n ; lookup_table\n ; lookup_sorted\n ; runtime_lookup_table\n ; runtime_lookup_table_selector\n ; xor_lookup_selector\n ; lookup_gate_lookup_selector\n ; range_check_lookup_selector\n ; foreign_field_mul_lookup_selector\n } :\n a t ) : (a, bool) In_circuit.t =\n { w\n ; coefficients\n ; z\n ; s\n ; generic_selector\n ; poseidon_selector\n ; complete_add_selector\n ; mul_selector\n ; emul_selector\n ; endomul_scalar_selector\n ; range_check0_selector = Opt.of_option range_check0_selector\n ; range_check1_selector = Opt.of_option range_check1_selector\n ; foreign_field_add_selector = Opt.of_option foreign_field_add_selector\n ; foreign_field_mul_selector = Opt.of_option foreign_field_mul_selector\n ; xor_selector = Opt.of_option xor_selector\n ; rot_selector = Opt.of_option rot_selector\n ; lookup_aggregation = Opt.of_option lookup_aggregation\n ; lookup_table = Opt.of_option lookup_table\n ; lookup_sorted = Vector.map ~f:Opt.of_option lookup_sorted\n ; runtime_lookup_table = Opt.of_option runtime_lookup_table\n ; runtime_lookup_table_selector =\n Opt.of_option runtime_lookup_table_selector\n ; xor_lookup_selector = Opt.of_option xor_lookup_selector\n ; lookup_gate_lookup_selector = Opt.of_option lookup_gate_lookup_selector\n ; range_check_lookup_selector = Opt.of_option range_check_lookup_selector\n ; foreign_field_mul_lookup_selector =\n Opt.of_option foreign_field_mul_lookup_selector\n }\n\n let map (type a b)\n ({ w\n ; coefficients\n ; z\n ; s\n ; generic_selector\n ; poseidon_selector\n ; complete_add_selector\n ; mul_selector\n ; emul_selector\n ; endomul_scalar_selector\n ; range_check0_selector\n ; range_check1_selector\n ; foreign_field_add_selector\n ; foreign_field_mul_selector\n ; xor_selector\n ; rot_selector\n ; lookup_aggregation\n ; lookup_table\n ; lookup_sorted\n ; runtime_lookup_table\n ; runtime_lookup_table_selector\n ; xor_lookup_selector\n ; lookup_gate_lookup_selector\n ; range_check_lookup_selector\n ; foreign_field_mul_lookup_selector\n } :\n a t ) ~(f : a -> b) : b t =\n { w = Vector.map w ~f\n ; coefficients = Vector.map coefficients ~f\n ; z = f z\n ; s = Vector.map s ~f\n ; generic_selector = f generic_selector\n ; poseidon_selector = f poseidon_selector\n ; complete_add_selector = f complete_add_selector\n ; mul_selector = f mul_selector\n ; emul_selector = f emul_selector\n ; endomul_scalar_selector = f endomul_scalar_selector\n ; range_check0_selector = Option.map ~f range_check0_selector\n ; range_check1_selector = Option.map ~f range_check1_selector\n ; foreign_field_add_selector = Option.map ~f foreign_field_add_selector\n ; foreign_field_mul_selector = Option.map ~f foreign_field_mul_selector\n ; xor_selector = Option.map ~f xor_selector\n ; rot_selector = Option.map ~f rot_selector\n ; lookup_aggregation = Option.map ~f lookup_aggregation\n ; lookup_table = Option.map ~f lookup_table\n ; lookup_sorted = Vector.map ~f:(Option.map ~f) lookup_sorted\n ; runtime_lookup_table = Option.map ~f runtime_lookup_table\n ; runtime_lookup_table_selector =\n Option.map ~f runtime_lookup_table_selector\n ; xor_lookup_selector = Option.map ~f xor_lookup_selector\n ; lookup_gate_lookup_selector = Option.map ~f lookup_gate_lookup_selector\n ; range_check_lookup_selector = Option.map ~f range_check_lookup_selector\n ; foreign_field_mul_lookup_selector =\n Option.map ~f foreign_field_mul_lookup_selector\n }\n\n let map2 (type a b c) (t1 : a t) (t2 : b t) ~(f : a -> b -> c) : c t =\n { w = Vector.map2 t1.w t2.w ~f\n ; coefficients = Vector.map2 t1.coefficients t2.coefficients ~f\n ; z = f t1.z t2.z\n ; s = Vector.map2 t1.s t2.s ~f\n ; generic_selector = f t1.generic_selector t2.generic_selector\n ; poseidon_selector = f t1.poseidon_selector t2.poseidon_selector\n ; complete_add_selector =\n f t1.complete_add_selector t2.complete_add_selector\n ; mul_selector = f t1.mul_selector t2.mul_selector\n ; emul_selector = f t1.emul_selector t2.emul_selector\n ; endomul_scalar_selector =\n f t1.endomul_scalar_selector t2.endomul_scalar_selector\n ; range_check0_selector =\n Option.map2 ~f t1.range_check0_selector t2.range_check0_selector\n ; range_check1_selector =\n Option.map2 ~f t1.range_check1_selector t2.range_check1_selector\n ; foreign_field_add_selector =\n Option.map2 ~f t1.foreign_field_add_selector\n t2.foreign_field_add_selector\n ; foreign_field_mul_selector =\n Option.map2 ~f t1.foreign_field_mul_selector\n t2.foreign_field_mul_selector\n ; xor_selector = Option.map2 ~f t1.xor_selector t2.xor_selector\n ; rot_selector = Option.map2 ~f t1.rot_selector t2.rot_selector\n ; lookup_aggregation =\n Option.map2 ~f t1.lookup_aggregation t2.lookup_aggregation\n ; lookup_table = Option.map2 ~f t1.lookup_table t2.lookup_table\n ; lookup_sorted =\n Vector.map2 ~f:(Option.map2 ~f) t1.lookup_sorted t2.lookup_sorted\n ; runtime_lookup_table =\n Option.map2 ~f t1.runtime_lookup_table t2.runtime_lookup_table\n ; runtime_lookup_table_selector =\n Option.map2 ~f t1.runtime_lookup_table_selector\n t2.runtime_lookup_table_selector\n ; xor_lookup_selector =\n Option.map2 ~f t1.xor_lookup_selector t2.xor_lookup_selector\n ; lookup_gate_lookup_selector =\n Option.map2 ~f t1.lookup_gate_lookup_selector\n t2.lookup_gate_lookup_selector\n ; range_check_lookup_selector =\n Option.map2 ~f t1.range_check_lookup_selector\n t2.range_check_lookup_selector\n ; foreign_field_mul_lookup_selector =\n Option.map2 ~f t1.foreign_field_mul_lookup_selector\n t2.foreign_field_mul_lookup_selector\n }\n\n (*\n This is in the same order as the evaluations in the opening proof:\n added later:\n - old sg polynomials\n - public input polynomial\n - ft\n here:\n - z\n - generic selector\n - poseidon selector\n - complete_add_selector\n - mul_selector\n - emul_selector\n - endomul_scalar_selector\n - w (witness columns)\n - coefficients\n - s (sigma columns)\n\n then optionally:\n - lookup sorted\n - lookup aggreg\n - lookup table\n - lookup runtime\n *)\n\n let to_list\n { w\n ; coefficients\n ; z\n ; s\n ; generic_selector\n ; poseidon_selector\n ; complete_add_selector\n ; mul_selector\n ; emul_selector\n ; endomul_scalar_selector\n ; range_check0_selector\n ; range_check1_selector\n ; foreign_field_add_selector\n ; foreign_field_mul_selector\n ; xor_selector\n ; rot_selector\n ; lookup_aggregation\n ; lookup_table\n ; lookup_sorted\n ; runtime_lookup_table\n ; runtime_lookup_table_selector\n ; xor_lookup_selector\n ; lookup_gate_lookup_selector\n ; range_check_lookup_selector\n ; foreign_field_mul_lookup_selector\n } =\n let always_present =\n [ z\n ; generic_selector\n ; poseidon_selector\n ; complete_add_selector\n ; mul_selector\n ; emul_selector\n ; endomul_scalar_selector\n ]\n @ Vector.to_list w\n @ Vector.to_list coefficients\n @ Vector.to_list s\n in\n let optional_gates =\n List.filter_map ~f:Fn.id\n [ range_check0_selector\n ; range_check1_selector\n ; foreign_field_add_selector\n ; foreign_field_mul_selector\n ; xor_selector\n ; rot_selector\n ]\n in\n always_present @ optional_gates\n @ List.filter_map ~f:Fn.id (Vector.to_list lookup_sorted)\n @ List.filter_map ~f:Fn.id\n [ lookup_aggregation\n ; lookup_table\n ; runtime_lookup_table\n ; runtime_lookup_table_selector\n ; xor_lookup_selector\n ; lookup_gate_lookup_selector\n ; range_check_lookup_selector\n ; foreign_field_mul_lookup_selector\n ]\n\n let typ (type f a_var a)\n (module Impl : Snarky_backendless.Snark_intf.Run with type field = f)\n ~dummy e (feature_flags : _ Features.t) :\n ((a_var, Impl.Boolean.var) In_circuit.t, a t, f) Snarky_backendless.Typ.t\n =\n let open Impl in\n let opt flag = Opt.typ Impl.Boolean.typ flag e ~dummy in\n let uses_lookup =\n let { Features.range_check0\n ; range_check1\n ; foreign_field_add = _ (* Doesn't use lookup *)\n ; foreign_field_mul\n ; xor\n ; rot\n ; lookup\n ; runtime_tables = _ (* Fixme *)\n } =\n feature_flags\n in\n Array.reduce_exn ~f:Opt.Flag.( ||| )\n [| range_check0; range_check1; foreign_field_mul; xor; rot; lookup |]\n in\n let lookup_sorted =\n match uses_lookup with\n | Opt.Flag.No ->\n Opt.Flag.No\n | Yes | Maybe ->\n Opt.Flag.Maybe\n in\n Typ.of_hlistable\n [ Vector.typ e Columns.n\n ; Vector.typ e Columns.n\n ; e\n ; Vector.typ e Permuts_minus_1.n\n ; e\n ; e\n ; e\n ; e\n ; e\n ; e\n ; opt feature_flags.range_check0\n ; opt feature_flags.range_check1\n ; opt feature_flags.foreign_field_add\n ; opt feature_flags.foreign_field_mul\n ; opt feature_flags.xor\n ; opt feature_flags.rot\n ; opt uses_lookup\n ; opt uses_lookup\n ; Vector.typ (opt lookup_sorted) Nat.N5.n (* TODO: Fixme *)\n ; opt feature_flags.runtime_tables\n ; opt feature_flags.runtime_tables\n ; opt feature_flags.xor\n ; opt feature_flags.lookup\n ; opt\n Opt.Flag.(\n feature_flags.range_check0 ||| feature_flags.range_check1\n ||| feature_flags.rot)\n (* TODO: This logic does not belong here. *)\n ; opt feature_flags.foreign_field_mul\n ]\n ~var_to_hlist:In_circuit.to_hlist ~var_of_hlist:In_circuit.of_hlist\n ~value_to_hlist:to_hlist ~value_of_hlist:of_hlist\nend\n\nmodule All_evals = struct\n module With_public_input = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type ('f, 'f_multi) t =\n { public_input : 'f; evals : 'f_multi Evals.Stable.V2.t }\n [@@deriving sexp, compare, yojson, hash, equal, hlist]\n end\n end]\n\n module In_circuit = struct\n type ('f, 'f_multi, 'bool) t =\n { public_input : 'f; evals : ('f_multi, 'bool) Evals.In_circuit.t }\n [@@deriving hlist]\n\n let factor (type f f_multi bool)\n ({ public_input = p1, p2; evals } : (f * f, f_multi * f_multi, bool) t)\n : (f, f_multi, bool) t Tuple_lib.Double.t =\n ( { evals = Evals.In_circuit.map ~f:fst evals; public_input = p1 }\n , { evals = Evals.In_circuit.map ~f:snd evals; public_input = p2 } )\n end\n\n let map (type a1 a2 b1 b2) (t : (a1, a2) t) ~(f1 : a1 -> b1) ~(f2 : a2 -> b2)\n : (b1, b2) t =\n { public_input = f1 t.public_input; evals = Evals.map ~f:f2 t.evals }\n\n let typ impl feature_flags f f_multi ~dummy =\n let evals = Evals.typ impl f_multi feature_flags ~dummy in\n let open Snarky_backendless.Typ in\n of_hlistable [ f; evals ] ~var_to_hlist:In_circuit.to_hlist\n ~var_of_hlist:In_circuit.of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist\n end\n\n [@@@warning \"-4\"]\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n type ('f, 'f_multi) t =\n { evals : ('f * 'f, 'f_multi * 'f_multi) With_public_input.Stable.V1.t\n ; ft_eval1 : 'f\n }\n [@@deriving sexp, compare, yojson, hash, equal, hlist]\n end\n end]\n\n module In_circuit = struct\n type ('f, 'f_multi, 'bool) t =\n { evals :\n ('f * 'f, 'f_multi * 'f_multi, 'bool) With_public_input.In_circuit.t\n ; ft_eval1 : 'f\n }\n [@@deriving hlist]\n end\n\n let map (type a1 a2 b1 b2) (t : (a1, a2) t) ~(f1 : a1 -> b1) ~(f2 : a2 -> b2)\n : (b1, b2) t =\n { evals =\n With_public_input.map t.evals\n ~f1:(Tuple_lib.Double.map ~f:f1)\n ~f2:(Tuple_lib.Double.map ~f:f2)\n ; ft_eval1 = f1 t.ft_eval1\n }\n\n let typ (type f)\n (module Impl : Snarky_backendless.Snark_intf.Run with type field = f)\n feature_flags =\n let open Impl.Typ in\n let single = array ~length:1 field in\n let evals =\n With_public_input.typ\n (module Impl)\n feature_flags (tuple2 field field) (tuple2 single single)\n ~dummy:Impl.Field.Constant.([| zero |], [| zero |])\n in\n of_hlistable [ evals; Impl.Field.typ ] ~var_to_hlist:In_circuit.to_hlist\n ~var_of_hlist:In_circuit.of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist\nend\n\nmodule Openings = struct\n [@@@warning \"-4\"] (* Deals with the 2 sexp-deriving types below *)\n\n module Bulletproof = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type ('g, 'fq) t =\n { lr : ('g * 'g) array\n ; z_1 : 'fq\n ; z_2 : 'fq\n ; delta : 'g\n ; challenge_polynomial_commitment : 'g\n }\n [@@deriving sexp, compare, yojson, hash, equal, hlist]\n end\n end]\n\n let typ fq g ~length =\n let open Snarky_backendless.Typ in\n of_hlistable\n [ array ~length (g * g); fq; fq; g; g ]\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist\n end\n\n [%%versioned\n module Stable = struct\n module V2 = struct\n type ('g, 'fq, 'fqv) t =\n { proof : ('g, 'fq) Bulletproof.Stable.V1.t\n ; evals : ('fqv * 'fqv) Evals.Stable.V2.t\n ; ft_eval1 : 'fq\n }\n [@@deriving sexp, compare, yojson, hash, equal, hlist]\n end\n end]\nend\n\nmodule Poly_comm = struct\n module With_degree_bound = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type 'g_opt t = { unshifted : 'g_opt array; shifted : 'g_opt }\n [@@deriving sexp, compare, yojson, hlist, hash, equal]\n end\n end]\n\n let padded_array_typ0 = padded_array_typ\n\n let typ (type f g g_var bool_var)\n (g : (g_var, g, f) Snarky_backendless.Typ.t) ~length\n ~dummy_group_element\n ~(bool : (bool_var, bool, f) Snarky_backendless.Typ.t) :\n ((bool_var * g_var) t, g Or_infinity.t t, f) Snarky_backendless.Typ.t =\n let open Snarky_backendless.Typ in\n let g_inf =\n transport (tuple2 bool g)\n ~there:(function\n | Or_infinity.Infinity ->\n (false, dummy_group_element)\n | Finite x ->\n (true, x) )\n ~back:(fun (b, x) -> if b then Infinity else Finite x)\n in\n let arr = padded_array_typ0 ~length ~dummy:Or_infinity.Infinity g_inf in\n of_hlistable [ arr; g_inf ] ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist\n ~value_to_hlist:to_hlist ~value_of_hlist:of_hlist\n end\n\n module Without_degree_bound = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type 'g t = 'g array [@@deriving sexp, compare, yojson, hash, equal]\n end\n end]\n end\nend\n\nmodule Messages = struct\n open Poly_comm\n\n module Poly = struct\n type ('w, 'z, 't) t = { w : 'w; z : 'z; t : 't }\n [@@deriving sexp, compare, yojson, fields, hash, equal, hlist]\n end\n\n module Lookup = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type 'g t = { sorted : 'g array; aggreg : 'g; runtime : 'g option }\n [@@deriving fields, sexp, compare, yojson, hash, equal, hlist]\n end\n end]\n\n module In_circuit = struct\n type ('g, 'bool) t =\n { sorted : 'g array; aggreg : 'g; runtime : ('g, 'bool) Opt.t }\n [@@deriving hlist]\n end\n\n let sorted_length = 5\n\n let dummy ~runtime_tables z =\n { aggreg = z\n ; sorted = Array.create ~len:sorted_length z\n ; runtime = Option.some_if runtime_tables z\n }\n\n let typ bool_typ e ~runtime_tables ~dummy =\n Snarky_backendless.Typ.of_hlistable\n [ Snarky_backendless.Typ.array ~length:sorted_length e\n ; e\n ; Opt.typ bool_typ runtime_tables e ~dummy\n ]\n ~value_to_hlist:to_hlist ~value_of_hlist:of_hlist\n ~var_to_hlist:In_circuit.to_hlist ~var_of_hlist:In_circuit.of_hlist\n\n let opt_typ bool_typ ~(lookup : Opt.Flag.t) ~(runtime_tables : Opt.Flag.t)\n ~dummy:z elt =\n Opt.typ bool_typ lookup\n ~dummy:\n (dummy z ~runtime_tables:Opt.Flag.(not (equal runtime_tables No)))\n (typ bool_typ ~runtime_tables ~dummy:z elt)\n end\n\n [%%versioned\n module Stable = struct\n module V2 = struct\n type 'g t =\n { w_comm : 'g Without_degree_bound.Stable.V1.t Columns_vec.Stable.V1.t\n ; z_comm : 'g Without_degree_bound.Stable.V1.t\n ; t_comm : 'g Without_degree_bound.Stable.V1.t\n ; lookup : 'g Without_degree_bound.Stable.V1.t Lookup.Stable.V1.t option\n }\n [@@deriving sexp, compare, yojson, fields, hash, equal, hlist]\n end\n end]\n\n module In_circuit = struct\n type ('g, 'bool) t =\n { w_comm : 'g Without_degree_bound.t Columns_vec.t\n ; z_comm : 'g Without_degree_bound.t\n ; t_comm : 'g Without_degree_bound.t\n ; lookup :\n (('g Without_degree_bound.t, 'bool) Lookup.In_circuit.t, 'bool) Opt.t\n }\n [@@deriving hlist, fields]\n end\n\n let typ (type n f)\n (module Impl : Snarky_backendless.Snark_intf.Run with type field = f) g\n ({ lookup; runtime_tables; _ } : Opt.Flag.t Features.t) ~dummy\n ~(commitment_lengths : (((int, n) Vector.t as 'v), int, int) Poly.t) ~bool\n =\n let open Snarky_backendless.Typ in\n let { Poly.w = w_lens; z; t } = commitment_lengths in\n let array ~length elt = padded_array_typ ~dummy ~length elt in\n let wo n = array ~length:(Vector.reduce_exn n ~f:Int.max) g in\n let _w n =\n With_degree_bound.typ g\n ~length:(Vector.reduce_exn n ~f:Int.max)\n ~dummy_group_element:dummy ~bool\n in\n let lookup =\n Lookup.opt_typ Impl.Boolean.typ ~lookup ~runtime_tables ~dummy:[| dummy |]\n (wo [ 1 ])\n in\n of_hlistable\n [ Vector.typ (wo w_lens) Columns.n; wo [ z ]; wo [ t ]; lookup ]\n ~var_to_hlist:In_circuit.to_hlist ~var_of_hlist:In_circuit.of_hlist\n ~value_to_hlist:to_hlist ~value_of_hlist:of_hlist\nend\n\nmodule Proof = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type ('g, 'fq, 'fqv) t =\n { messages : 'g Messages.Stable.V2.t\n ; openings : ('g, 'fq, 'fqv) Openings.Stable.V2.t\n }\n [@@deriving sexp, compare, yojson, hash, equal]\n end\n end]\nend\n\nmodule Shifts = struct\n open Core_kernel\n\n [%%versioned\n module Stable = struct\n module V2 = struct\n type 'field t = 'field array [@@deriving sexp, compare, yojson, equal]\n end\n end]\nend\n","(** Pickles implementation *)\n\n(** See documentation of the {!Mina_wire_types} library *)\nmodule Wire_types = Mina_wire_types.Pickles\n\nmodule Make_sig (A : Wire_types.Types.S) = struct\n module type S =\n Pickles_intf.S\n with type Side_loaded.Verification_key.Stable.V2.t =\n A.Side_loaded.Verification_key.V2.t\n and type ('a, 'b) Proof.t = ('a, 'b) A.Proof.t\nend\n\nmodule Make_str (_ : Wire_types.Concrete) = struct\n module Endo = Endo\n module P = Proof\n\n module type Statement_intf = Intf.Statement\n\n module type Statement_var_intf = Intf.Statement_var\n\n module type Statement_value_intf = Intf.Statement_value\n\n module Common = Common\n module Scalar_challenge = Scalar_challenge\n module SC = Scalar_challenge\n open Core_kernel\n open Async_kernel\n open Import\n open Pickles_types\n open Hlist\n open Common\n open Backend\n module Backend = Backend\n module Sponge_inputs = Sponge_inputs\n module Util = Util\n module Tick_field_sponge = Tick_field_sponge\n module Impls = Impls\n module Inductive_rule = Inductive_rule\n module Tag = Tag\n module Types_map = Types_map\n module Dirty = Dirty\n module Cache_handle = Cache_handle\n module Step_main_inputs = Step_main_inputs\n module Step_verifier = Step_verifier\n\n exception Return_digest = Compile.Return_digest\n\n let verify_promise = Verify.verify\n\n let verify max_proofs_verified statement key proofs =\n verify_promise max_proofs_verified statement key proofs\n |> Promise.to_deferred\n\n (* This file (as you can see from the mli) defines a compiler which turns an inductive\n definition of a set into an inductive SNARK system for proving using those rules.\n\n The two ingredients we use are two SNARKs.\n - A step based SNARK for a field Fp, using the group G1/Fq (whose scalar field is Fp)\n - A DLOG based SNARK for a field Fq, using the group G/Fp (whose scalar field is Fq)\n\n For convenience in this discussion, let's define\n (F_0, G_0) := (Fp, G1)\n (F_1, G_1) := (Fq, G)\n So ScalarField(G_i) = F_i and G_i / F_{1-i}.\n\n An inductive set A is defined by a sequence of inductive rules.\n An inductive rule is intuitively described by something of the form\n\n a1 ∈ A1, ..., an ∈ An\n f [ a0, ... a1 ] a\n ----------------------\n a ∈ A\n\n where f is a snarky function defined over an Impl with Field.t = Fp\n and each Ai is itself an inductive rule (possibly equal to A itself).\n\n We pursue the \"step\" then \"wrap\" approach for proof composition.\n\n The main source of complexity is that we must \"wrap\" proofs whose verifiers are\n slightly different.\n\n The main sources of complexity are twofold:\n 1. Each SNARK verifier includes group operations and scalar field operations.\n This is problematic because the group operations use the base field, which is\n not equal to the scalar field.\n\n Schematically, from the circuit point-of-view, we can say a proof is\n - a sequence of F_0 elements xs_0\n - a sequence of F_1 elelements xs_1\n and a verifier is a pair of \"snarky functions\"\n - check_0 : F_0 list -> F_1 list -> unit which uses the Impl with Field.t = F_0\n - check_1 : F_0 list -> F_1 list -> unit which uses the Impl with Field.t = F_1\n - subset_00 : 'a list -> 'a list\n - subset_01 : 'a list -> 'a list\n - subset_10 : 'a list -> 'a list\n - subset_11 : 'a list -> 'a list\n and a proof verifies if\n ( check_0 (subset_00 xs_0) (subset_01 xs_1) ;\n check_1 (subset_10 xs_0) (subset_11 xs_1) )\n\n When verifying a proof, we perform the parts of the verifier involving group operations\n and expose as public input the scalar-field elements we need to perform the final checks.\n\n In the F_0 circuit, we witness xs_0 and xs_1,\n execute `check_0 (subset_00 xs_0) (subset_01 xs_1)` and\n expose `subset_10 xs_0` and `subset_11 xs_1` as public inputs.\n\n So the \"public inputs\" contain within them an \"unfinalized proof\".\n\n Then, the next time we verify that proof within an F_1 circuit we \"finalize\" those\n unfinalized proofs by running `check_1 xs_0_subset xs_1_subset`.\n\n I didn't implement it exactly this way (although in retrospect probably I should have) but\n that's the basic idea.\n\n **The complexity this causes:**\n When you prove a rule that includes k recursive verifications, you expose k unfinalized\n proofs. So, the shape of a statement depends on how many \"predecessor statements\" it has\n or in other words, how many verifications were performed within it.\n\n Say we have an inductive set given by inductive rules R_1, ... R_n such that\n each rule R_i has k_i predecessor statements.\n\n In the \"wrap\" circuit, we must be able to verify a proof coming from any of the R_i.\n So, we must pad the statement for the proof we're wrapping to have `max_i k_i`\n unfinalized proof components.\n\n 2. The verifier for each R_i looks a little different depending on the complexity of the \"step\"\n circuit corresponding to R_i has. Namely, it is dependent on the \"domains\" H and K for this\n circuit.\n\n So, when the \"wrap\" circuit proves the statement,\n \"there exists some index i in 1,...,n and a proof P such that verifies(P)\"\n \"verifies(P)\" must also take the index \"i\", compute the correct domain sizes correspond to rule \"i\"\n and use *that* in the \"verifies\" computation.\n *)\n open Kimchi_backend\n module Proof = P\n\n module Statement_with_proof = struct\n type ('s, 'max_width, _) t =\n (* TODO: use Max local max proofs verified instead of max_width *)\n ('max_width, 'max_width) Proof.t\n end\n\n module Verification_key = struct\n include Verification_key\n\n module Id = struct\n include Cache.Wrap.Key.Verification\n\n let dummy_id = Type_equal.Id.(uid (create ~name:\"dummy\" sexp_of_opaque))\n\n let dummy : unit -> t =\n let header =\n { Snark_keys_header.header_version = Snark_keys_header.header_version\n ; kind = { type_ = \"verification key\"; identifier = \"dummy\" }\n ; constraint_constants =\n { sub_windows_per_window = 0\n ; ledger_depth = 0\n ; work_delay = 0\n ; block_window_duration_ms = 0\n ; transaction_capacity = Log_2 0\n ; pending_coinbase_depth = 0\n ; coinbase_amount = Unsigned.UInt64.of_int 0\n ; supercharged_coinbase_factor = 0\n ; account_creation_fee = Unsigned.UInt64.of_int 0\n ; fork = None\n }\n ; commits = { mina = \"\"; marlin = \"\" }\n ; length = 0\n ; commit_date = \"\"\n ; constraint_system_hash = \"\"\n ; identifying_hash = \"\"\n }\n in\n let t = lazy (dummy_id, header, Md5.digest_string \"\") in\n fun () -> Lazy.force t\n end\n\n (* TODO: Make async *)\n let load ~cache id =\n Key_cache.Sync.read cache\n (Key_cache.Sync.Disk_storable.of_binable Id.to_string\n (module Verification_key.Stable.Latest) )\n id\n |> Deferred.return\n end\n\n module type Proof_intf = Compile.Proof_intf\n\n module Prover = Compile.Prover\n\n module Side_loaded = struct\n module V = Verification_key\n\n module Verification_key = struct\n include Side_loaded_verification_key\n\n let to_input (t : t) =\n to_input ~field_of_int:Impls.Step.Field.Constant.of_int t\n\n let of_compiled tag : t =\n let d = Types_map.lookup_compiled tag.Tag.id in\n let actual_wrap_domain_size =\n Common.actual_wrap_domain_size\n ~log_2_domain_size:(Lazy.force d.wrap_vk).domain.log_size_of_group\n in\n { wrap_vk = Some (Lazy.force d.wrap_vk)\n ; wrap_index = Lazy.force d.wrap_key\n ; max_proofs_verified =\n Pickles_base.Proofs_verified.of_nat\n (Nat.Add.n d.max_proofs_verified)\n ; actual_wrap_domain_size\n }\n\n module Max_width = Width.Max\n end\n\n let in_circuit tag vk =\n Types_map.set_ephemeral tag { index = `In_circuit vk }\n\n let in_prover tag vk = Types_map.set_ephemeral tag { index = `In_prover vk }\n\n let create ~name ~max_proofs_verified ~feature_flags ~typ =\n Types_map.add_side_loaded ~name\n { max_proofs_verified\n ; public_input = typ\n ; branches = Verification_key.Max_branches.n\n ; feature_flags\n }\n\n module Proof = struct\n include Proof.Proofs_verified_max\n\n let of_proof : _ Proof.t -> t = Wrap_hack.pad_proof\n end\n\n let verify_promise (type t) ~(typ : (_, t) Impls.Step.Typ.t)\n (ts : (Verification_key.t * t * Proof.t) list) =\n let m =\n ( module struct\n type nonrec t = t\n\n let to_field_elements =\n let (Typ typ) = typ in\n fun x -> fst (typ.value_to_fields x)\n end : Intf.Statement_value\n with type t = t )\n in\n (* TODO: This should be the actual max width on a per proof basis *)\n let max_proofs_verified =\n (module Verification_key.Max_width : Nat.Intf\n with type n = Verification_key.Max_width.n )\n in\n with_return (fun { return } ->\n List.map ts ~f:(fun (vk, x, p) ->\n let vk : V.t =\n { commitments = vk.wrap_index\n ; index =\n ( match vk.wrap_vk with\n | None ->\n return\n (Promise.return\n (Or_error.errorf\n \"Pickles.verify: wrap_vk not found\" ) )\n | Some x ->\n x )\n ; data =\n (* This isn't used in verify_heterogeneous, so we can leave this dummy *)\n { constraints = 0 }\n }\n in\n Verify.Instance.T (max_proofs_verified, m, vk, x, p) )\n |> Verify.verify_heterogenous )\n\n let verify ~typ ts = verify_promise ~typ ts |> Promise.to_deferred\n\n let srs_precomputation () : unit =\n let srs = Tock.Keypair.load_urs () in\n List.iter [ 0; 1; 2 ] ~f:(fun i ->\n Kimchi_bindings.Protocol.SRS.Fq.add_lagrange_basis srs\n (Domain.log2_size (Common.wrap_domains ~proofs_verified:i).h) )\n end\n\n let compile_with_wrap_main_override_promise =\n Compile.compile_with_wrap_main_override_promise\n\n let compile_promise ?self ?cache ?disk_keys ?return_early_digest_exception\n ?override_wrap_domain ~public_input ~auxiliary_typ ~branches\n ~max_proofs_verified ~name ~constraint_constants ~choices () =\n compile_with_wrap_main_override_promise ?self ?cache ?disk_keys\n ?return_early_digest_exception ?override_wrap_domain ~public_input\n ~auxiliary_typ ~branches ~max_proofs_verified ~name ~constraint_constants\n ~choices ()\n\n let compile ?self ?cache ?disk_keys ?override_wrap_domain ~public_input\n ~auxiliary_typ ~branches ~max_proofs_verified ~name ~constraint_constants\n ~choices () =\n let self, cache_handle, proof_module, provers =\n compile_promise ?self ?cache ?disk_keys ?override_wrap_domain\n ~public_input ~auxiliary_typ ~branches ~max_proofs_verified ~name\n ~constraint_constants ~choices ()\n in\n let rec adjust_provers :\n type a1 a2 a3 s1 s2_inner.\n (a1, a2, a3, s1, s2_inner Promise.t) H3_2.T(Prover).t\n -> (a1, a2, a3, s1, s2_inner Deferred.t) H3_2.T(Prover).t = function\n | [] ->\n []\n | prover :: tl ->\n (fun ?handler public_input ->\n Promise.to_deferred (prover ?handler public_input) )\n :: adjust_provers tl\n in\n (self, cache_handle, proof_module, adjust_provers provers)\n\n module Provers = H3_2.T (Prover)\n module Proof0 = Proof\n\n let%test_module \"test no side-loaded\" =\n ( module struct\n let () = Tock.Keypair.set_urs_info []\n\n let () = Tick.Keypair.set_urs_info []\n\n let () = Backtrace.elide := false\n\n (*\n let%test_unit \"test deserialization and verification for side-loaded keys\" =\n Side_loaded.srs_precomputation () ;\n let pi =\n match\n \"((statement((proof_state((deferred_values((plonk((alpha((inner(528cdbf16708a53a 1f90a7eea2e06f6a))))(beta(617e5a7fd6be366a de197122a4415175))(gamma(3ca35d4452181c99 10f08540ba61b0ec))(zeta((inner(9b9cb3eb89f99860 fc3f2a556b3da3b8))))))(combined_inner_product(Shifted_value 0x0823E56793B5592614ADBA4D0E5FE7182C36059EFA67B62FF348C298025ED3B1))(b(Shifted_value 0x15E6E583088F3839A0A24BA096058D311F80E63DC7C5F96961EDF0E8431B3A89))(xi((inner(5c78b5106dc9196b dd923608f3a2d7c7))))(bulletproof_challenges(((prechallenge((inner(0277f6aad9d835a5 d7ce644af1e0a623)))))((prechallenge((inner(7155c8ca270890a9 88210ef505d7463a)))))((prechallenge((inner(66dd09cf8c767ca8 49a1f3f0d02c27d1)))))((prechallenge((inner(b3af5b7fff77d3dd 7e3d53b2d699d210)))))((prechallenge((inner(1a7034722f39c680 dac0b920710a3baf)))))((prechallenge((inner(31a391963a1eda22 1768f963fda30dbd)))))((prechallenge((inner(ca6977bc2cd08f02 8cca080a3eea91de)))))((prechallenge((inner(ca1c4459c6db90e0 5dc97444224692b8)))))((prechallenge((inner(5a8691fe938d7766 ffa7b76d50545300)))))((prechallenge((inner(e28a6bd7885e2dce cffc710fd023fcf2)))))((prechallenge((inner(67c9cacdbec10152 dbbbb17446514cdc)))))((prechallenge((inner(b962690d4c6147fe 047ed2b6432ae9a8)))))((prechallenge((inner(247a3c026fd42a1f 30ffd3eb2e92f6e0)))))((prechallenge((inner(fb040a5f7ae1682a 67e88c03b46429fb)))))((prechallenge((inner(da7aaeb99142d490 e6df1ef2a27bd5dd)))))((prechallenge((inner(c9590ba2d65e774c 6513be976dbbd014)))))))(branch_data((proofs_verified N0)(domain_log2"\n")))))(sponge_digest_before_evaluations(345bca89a18be6eb 32b32bea9853ce51 e4b78bd09bbb68a5 0c6791fb08e0ca57))(me_only((challenge_polynomial_commitment(0x0F69B65A5855F3A398D0DFD0C131B9612C9F2061D2F06E676F612C48D827E1E6 0x0CCAF3F03F9D2C3C3D44E09A12106911FA699DF934F706E62131BAD639F30155))(old_bulletproof_challenges((((prechallenge((inner(3382b3c9ace6bf6f 79974358f9761863)))))((prechallenge((inner(dd3a2b06e9888797 dd7ae6402944a1c7)))))((prechallenge((inner(c6e8e530f49c9fcb 07ddbb65cda09cdd)))))((prechallenge((inner(532c59a287691a13 a921bcb02a656f7b)))))((prechallenge((inner(e29c77b18f10078b f85c5f00df6b0cee)))))((prechallenge((inner(1dbda72d07b09c87 4d1b97e2e95f26a0)))))((prechallenge((inner(9c75747c56805f11 a1fe6369facef1e8)))))((prechallenge((inner(5c2b8adfdbe9604d 5a8c718cf210f79b)))))((prechallenge((inner(22c0b35c51e06b48 a6888b7340a96ded)))))((prechallenge((inner(9007d7b55e76646e c1c68b39db4e8e12)))))((prechallenge((inner(4445e35e373f2bc9 9d40c715fc8ccde5)))))((prechallenge((inner(429882844bbcaa4e 97a927d7d0afb7bc)))))((prechallenge((inner(99ca3d5bfffd6e77 efe66a55155c4294)))))((prechallenge((inner(4b7db27121979954 951fa2e06193c840)))))((prechallenge((inner(2cd1ccbeb20747b3 5bd1de3cf264021d))))))(((prechallenge((inner(3382b3c9ace6bf6f 79974358f9761863)))))((prechallenge((inner(dd3a2b06e9888797 dd7ae6402944a1c7)))))((prechallenge((inner(c6e8e530f49c9fcb 07ddbb65cda09cdd)))))((prechallenge((inner(532c59a287691a13 a921bcb02a656f7b)))))((prechallenge((inner(e29c77b18f10078b f85c5f00df6b0cee)))))((prechallenge((inner(1dbda72d07b09c87 4d1b97e2e95f26a0)))))((prechallenge((inner(9c75747c56805f11 a1fe6369facef1e8)))))((prechallenge((inner(5c2b8adfdbe9604d 5a8c718cf210f79b)))))((prechallenge((inner(22c0b35c51e06b48 a6888b7340a96ded)))))((prechallenge((inner(9007d7b55e76646e c1c68b39db4e8e12)))))((prechallenge((inner(4445e35e373f2bc9 9d40c715fc8ccde5)))))((prechallenge((inner(429882844bbcaa4e 97a927d7d0afb7bc)))))((prechallenge((inner(99ca3d5bfffd6e77 efe66a55155c4294)))))((prechallenge((inner(4b7db27121979954 951fa2e06193c840)))))((prechallenge((inner(2cd1ccbeb20747b3 5bd1de3cf264021d))))))))))))(pass_through((app_state())(challenge_polynomial_commitments())(old_bulletproof_challenges())))))(prev_evals((evals(((public_input 0x1D5050ABC193FD8288FE8B09DA9A2AA8C4A95E796C33DFB712E8CCAD7367266A)(evals((w((0x2C33C173BDE9340BE941ECD209AB6E99ECA8BDCA1CA8BDA8DAC3E40C3315F696)(0x02AE92968344D1F59603BA015C29D7801897F6B59E5ED43A3BEE316D6A876C3B)(0x3D4FDD240284F096B0D9CE405C2016E7CAE49931D0571F27DA7A3DDB202FC437)(0x1D8A9A17ABDFF5975832B2EA4AEB94BADE6346A554EB24A51B3ECFF560D33748)(0x36F806F043D8F33F7FD89730FB69E5DAF323E8637D23D95694665AB1B29AD194)(0x21CE677E9416783DBA7310E2813D200104A0328DCA5CF2C0E632BFD719951CBD)(0x0A3464D5ABBDF1C1FA6C3CF5C5328CBED7D1402AD4990AF2D07CF6958700E079)(0x3067923AF93C85BC677715F78EFEE2B765F4712D92A18DD691B2D617245D2837)(0x1D75E1CCE4165FD19BBF1D834F0366E3330A916F252801ACC2A9FCCFE19BB03F)(0x29793C3D311353444C4FCF2BF62299893F69FCEF0ADF7345310DB7E736C21758)(0x3F90E2448CAB2639788EEF0EDBD4F87463082EAE0C52F710E0A57B4238577C09)(0x3E19E9E45C6CFCF0F7036D3A598E26BC4C250AB45049E19A81EF3F9C68E7B09E)(0x31CF2FC45C59E45E5B16A9FA357972AEF1F744388C81C886B28BDBC55815CE45)(0x24B310A418CB5815513DCC5B4DBF4B2C64BD94A2D4764294EEBDF4C7DE1B1B08)(0x3E748B8BF7F3F63235B650DB873BD652BC58DB1C67C94AF03B218DB58CA0EA86)))(z(0x3FA6741D84E11434D7918A459AD1B698B8F3616E2A901B3B17E9E0BA8C229A95))(s((0x2160285A788031C45B0E041C0C3E1322E1330C718B709999E677E4C82C1A8DEC)(0x2CC1EE1154F527B33A011A5F816AFC3C219892D0CC3A25501A90183A2221B847)(0x299366D7BDB50CD278BDB43FFCC1AF66CFD6C821203F980AC22A9E0178612FCC)(0x04204759E7D8E84C1122BCF65008ABAC017DE7DAE44B7E479D30773966EB6B0A)(0x08D5ABDB38CEEA6D50FC378FCCEA65116C298EE0307D827FF67447502C5C5A23)(0x0AB1B1605C07FB055414308FD9D3872D1184AC436BF62BE06BF68A429EB806C8)))(generic_selector(0x2073E57ECA097CDB4349F56A96DD870EF4232F547624BFDD7AFFDF8407826000))(poseidon_selector(0x1412641F378B7B4AA2DF1B29573E3BBA2E092E74D48CC8CA03BFBD88755F5DD5)))))((public_input 0x0EFC0CC4E8604CB4B337B237BB46916110F5604041669E38EB1712C78A86539D)(evals((w((0x30C812455D840F09B1A10D73E607F1CD23F0977E205946DD7252149C3C8EB2EB)(0x0301082FC85A85A5C5E48483CB231F64BE4E42ADB7AB73B973034F92C2008243)(0x1AC263C293B548E7862234481865A6C4255180F33D5FCB1E30360DC5AA4A8164)(0x2679B03901AA2A286DF1E2A90BC72A3AF57C13DD65B9BB11104DB9189ADBB970)(0x39F0CFE5133D4CC3B598F1F6EA16004661DF7BA6D1316C38E124C65EF4F21C95)(0x16457DFD6BF323BE13162779EB0F48CAD3AD8D4970E9E6433F275B2226CF99D9)(0x2AF436FE0FAF0CB905DD8202DDC42C09D1565CE415FD44F33178D94B1BF76127)(0x26A914F7D55AC312918D41FDA516342E929034C06D1970794C1156FF8690B0E6)(0x0BDDDB276B9CDF4B2C9B4C6B43F2F302D46E2A0104724D7779B714CC1C13D10C)(0x057C045F4DA7202317E4A47952BEF19D109475749FC8BF0ED9244FD6BDB20CC3)(0x3AD9805BE86345B3FE98367D2ADAAAF6A3B2A511B7011D354CC074BB0F0B618C)(0x0864BB2DF60F29BEBC8D55DEC2B6F199DF53CB650BD797D8C81AA7D39F7A494C)(0x375F21536B66E816DCFCE829495A7B429CA1EB658123DE8858B765DB26D1DC68)(0x34D1B59A33369350867EE0E538C68D693E19BD5F8F05FBDE52828A6AE39666CA)(0x381AD285334A7884690F3AB8412291FCB0D3357169C0F176D2A6DB8D2B3FC02B)))(z(0x2FB41536E4655C119BE5F0DED90391A8171C191B3A9764F765FBB6EBF2AABAC9))(s((0x3F5522A1D8A0ABFA8876B4185E9CA1F885663F55579C39F7352F981CB304CCEF)(0x2E0700D6F8A02C04B1DFE630896B59615F21C4B3B541E26EE63DBCFDFE59D658)(0x10F7327C833EB35B4499AD4A1EF0BCB66861822381DEB0CC6799E7182892BD26)(0x29AB8F4C7E256D2D7703E368F9101BED0215E08CEC87AA5499CFA7D1E9E11657)(0x16523DDF438ACF2C072DC7F00C41F1E3A5214761C77D2533970A9382B5B48D30)(0x0D684A460B348082F5EFB03F7A635B5358E52235821D36251D67644CE694ABC4)))(generic_selector(0x2B204B8595299D22CC83DE6E2A78D4AF39AAE8527FB4B297A35051F376AE10C6))(poseidon_selector(0x370C7DAC58DB1DAB1147DAA8BBF7EE1F1E2C2EAB64BEED885CA14FC86D786459)))))))(ft_eval1 0x0459DE9EA74B8CB38B54454FA0F59D375307B1210F7403526153D5CC1288DE63)))(proof((messages((w_comm(((0x3E2CF8FDB7F25CC3D523E88735CC8B0068A436A107D926977B4408955AFB5A7D 0x32CEE955EC5BFCF269A050C50C9ED868664F26AEDB4FCC96A2EB22C4E9031ACC))((0x2029F54CE3FE1255005DC6E0D56F45ED46D9294A2021AD7C4D9ECB9A2FC35DDC 0x20098E9EB437414F861C8BB5FDF3111EB3C6707DC156FFEE3F3B712FB67F4A2E))((0x1110AE3F05A3DF2FE4149EB7125B7CF315D01D6BFBDC4E1EBEA05ADD633470FD 0x30BAEF091C165B8FCFAFAA96C0FB9EB59A6FD98176897423043623AFB8DCB084))((0x3395D2993CCBB9C0A22BE321D70F5F01F39B83D78D7D3684DE7EFEF71C9EED94 0x3A99A078DA706F3C43B6C081DE5A09A69D2D308BA50B961CAC6A664E3D4E8E3E))((0x258C56FA32B555BFC3288F6EEAA11344E4430C51F3ED6A59F35F749F9FAF084E 0x1D47AC341EF7AA76F15F0239A494A541E018C113ACD62E87FAA7764E23251944))((0x2C04311B81ED29240DE9DA622C894323236DD623846E83C08309D1C552B06503 0x2438036EE7EF2EAEB9216A843692A2FA45F8B595107D9EA6C05523C8274DCDFE))((0x19C1DE13982583A22FAD04553082499C88055C0D707C09DC77650EBC14718F6C 0x2611B1FC721B8B73B109886E5A2960ABBC5A471472F2DE27F0B70989B0E640BF))((0x136550315A4440E22DB32906E3C7C955B96C735E4058F1AFF8BDCF75BE2324C8 0x34AB87A590CB4B9674F28A75F6CF92757E84E1649F32CABCBE0B76AED1A60E8D))((0x2EE8D5BEA4D460321B9BD1B58BD5F9EF76DF3D0DEBB015190D317C61C73584AC 0x3D330403E54BD189C55448170D59D6F9D3EF48C8095281F45588B92B6107535F))((0x370E23375707B4E74486415A153CB1F0111C2B950C87178FA85891CCAB0D3D8A 0x0E75C598E63688217BEFBB5DCA020433CE158D4F8070C63982275F8261A3CE95))((0x2EFA160350CC4282EE06AF463EC8CA6980AF07983A42B6275E42FC4AA6E685C8 0x0EECA9EDB51265182CBEC10EF3B0AAF81EFB53E9B919940194C2726B9A785D1C))((0x27FE69FF4A716E2DF1389CFCD4C425B050C00931CDD123C0C5BEA7DFFDD3D603 0x122E05931206355AAB60DBAE077D490887DD1CAA599BAC05458BC3F41428CBB6))((0x3663E1C1C27C6F163AB552E83B21FDDC5EBAA3B735EFFFE38BAE99B01D71D037 0x2C46C91336CE381F3900BD2A80C2B36A6BC90C5D53A579E02240BBABB2018E60))((0x26667E23A0085FDDA970D4CDC78D6A4D9C9F003061F40F5AE8F81986C0D6D260 0x2B05A9F120DAAA355F54E8D0B96A78A674898FB1830A4EB71356137C8984BDA5))((0x105D2491EEAE03D1AA4AD8908412F3ED0B988A43C4F33C81581C3A60FEE9721F 0x2DBAAD56BFA1DCDDE5CFE40480C8E8E57E0093FEB153D9D4F983407B3EA91412))))(z_comm((0x029EE7F64D3FFF1F6920D6F009304C2C8F9ABF2B769ACD69F7F78201A09F10BB 0x301449483BF3A688552192934E10391D7BE97E54BEB26F7A3F3B1A2443CA07EC)))(t_comm((0x27ED056E28864693AB1653F62ADF5C6F47DCCD070EF16A2E911283224015921E 0x1077284DD15F99143EFACBA85D3DD63608F222CD6D7CF7A793DFC64390B7DBD8)(0x07A10F95A4F55597F66C3C92BBF9D69A23C6EE86CE2C864FC0A35FB199980B89 0x2BC564EC06B8B7052F469C3EC74ADD32C1C713EFA19F26102E7C73520F90ED2C)(0x3F30E96C3D5A23170F94895565422C6D54B8C8594D154CB495BD808941848C21 0x17F853D3C5869042C600C71720610A21DD057D689A34CF08E6A7054B1BDDD70C)(0x0C27FA8D2829BCBDD90E245677394DF7151F7C4E94D95832962D7187FEB33432 0x0442C73BC7C37791DA9CE0BE6332F69166EF6E6F651E23D859207B1FADF9E1A9)(0x039B920067F59B3458F8CFA660BC585B705826906B88893B88CADE19930604C4 0x33AAA622113A14BB1408538B38CA5157BCC835546BC081BA2D39E5A636F7854B)(0x0E76AEE47485073ADB66E8827B7F11C99B74F5D360AF12C326DEBFF457ABB298 0x15D7F59BD6BD0E49B36BAE1A8E17073FAD3442B8268D50D327E87CD4374C9E2E)(0x24B17C42758CD977DA31A5D619D0B0CC885A074F13DF1B0D9036A5BE962FAA66 0x33ABF75964D4318F21AA7F3C889EA88C495E1322B29C81646C90190626AF93A0)))))(openings((proof((lr(((0x018E82B85F43380E32CEDAD571886DCDB651FD16C54AFACC8A5F0FCA1A35D77A 0x07558C8DE9362826F52ED1FC9F3FAC3E60BE6BF9A693F1A960CB2F54BF9AD308)(0x2DD34ADF732340CE166A3989C2863E00AA20EE8DD3681A6FC47948DDC2291919 0x39EFB3592924CF49F45D5B471ACD66BD6A9D72C7F034EC75703740737E068FF9))((0x05DD7845B0D19212ACDF666DD90F309999BF28719B2A1F70B228AF5D3E59A633 0x207799AB420155C6FFECDB3538B0EF2259EEF776A33A781AC4F3EF6BCEE60700)(0x3AAFC4E24A25D2AFF714F0008F2465496C62EB6C1F7562E605C38EC59DBDBC67 0x378F5BACCE5C4BD6FEF8630F68C439F8FE986F218A562B1EC054E07FC5824B59))((0x38E608E6C866AD1C61BC6F250A0AD7761B71C6E5E0F7A065F01B7B2F4F485D18 0x2F1CFCEE96584F592CDE05B0B3F936A8D1FB603A2984EECB1DB042BA6D81A6D9)(0x07AD6181A8E32C3898B06BF092E28D1C8E928293125609033979AEDDB9116BCE 0x35287F7AA2300ECA1CC58AE8141AB97411E00F61C65F5B1A98A58EF5918C363B))((0x3461FACE1BEB85F605E72FAF9A3C804CC3BF82FC2094583528F0C7EBA74DFB48 0x2212015E8CA2965FE0E8A4A06838CEDDED1EA531A139F5CFD1588DB5736381C3)(0x0DE143977BA8B3FC93D25434EEDA4921E8BDE5AD59E1181E6B456B4309057F08 0x24B094D4AC456EC3F55D46830F4E82BF07312A1FAA97D9138BF41F16F7E23A9A))((0x21E5645330DC73F6F6819176F8E90A0827117664A93B4D96E19DE8B2819689F2 0x1AC631D608FDEB1EEFFB6C18A720E40CF1408B0BE266A62BE8B7D0B46DAF0FD3)(0x00D73BE9C319319E4C12A8F9610C476D16F0878F032DE6D6664E77DAAA446387 0x12814F8638826EA6099E0691770FFE50F817CFB3C45C1F065EB0F85D6EE7BA8B))((0x27D05D5CE92F8375D15C7E28A4F6A02E1C240BBA18978329DCA072436CDB3B7B 0x1C994843BE3797E9A6F2AC6FCCAB1C9B1745E819143F2918A383D3D336C5846C)(0x1D8ABC594EDE311A74A3CEE7DE36E4065851C0ED03A4148F1A13AF8A4E1CE8B2 0x2C3207B67EE005C7FC5B1C072E980ADF9695F015AE26BF16AE32E83C06FCC611))((0x135DC0F98465E36AEFC4AFAF082F4594434B4A4374309CBD334750983A7811A4 0x11057C0DF6BD2CC7A505A6B39969070656CB39E4EC479DCFE42E01E70BA39114)(0x1E254D9B7E6BEDFE142264E1B93B1CA92B943264E48C8E276AABBC063E79C02B 0x2A617229F4D194F3BE3D15D38B777EA4ABBA28F3641B269F7A251FBFC511B25A))((0x1E9E3FA46A50EC7A42F370E9A429C21984FCF730FAAC8913EC6E50B9DBA0390C 0x19A7CD7A84C3E998ABFCAB1D1AB8DF1E9F57D5878ECB12636A8C0D008E466934)(0x3F2C2B737CD73658ACE3CC9242DD9A52E39836B138BCDB71658B1052C7FE9C83 0x218E8EAB1F657EFEF1A281FE61A6B1CDD93033130FC664403EB1610AE20EFB3B))((0x063E8B50A90E7AFAA45B4AE2BB4F48537F14CFE82BEF31A110093999F0AB5333 0x10281C8C0E0174FA2121F435F35D9E8050637AA3F58E2A342DEB9C91798C47AC)(0x0D43AB0853C6C202A2CE3C39E9D1CDA61449A8A16A91012FFE58AFCBF675D3D6 0x3B5DADAAAE57CF6FB972C521FED1AC03B960851C0D44B6122EBB72A2258A4604))((0x18AE3885AC8AF0E6BD9C0E7785D83477ED6F5FE8A239AE2526141931D81EAB56 0x29FBB084D8FBE703D008E9CD70B702B3113B49F859C2A19B4406AD130D3731A2)(0x04AF99E720254B22E8DF368AE6FC273AC75A4639A6F3007369FD405532964CBE 0x124525E37EC615B1F57D54002836E35380548276C61D6B2539EA51C9015EED9C))((0x32A4ECA72864EEFFCF2D83B843B9BE4ADBCD45B972624811C894F916E4C81A30 0x3E6F57AB9CF53618664A7AD9862F65BF164EFFB42B7497B64A8844339318C365)(0x2F7EECC63F3EDF519A83E20D64E88213179264F93A2438A22A16335EB2853E6A 0x1D03C4087516EE01C13982505997CF5E13A8E4C228B4346DEFDCB1101E656494))((0x394C3F476F8DFAE68E5B4610E73239F7ACD8C5AE12E6F094B2D199D39308D87D 0x1A38D41C68C7BD3C6176D24F774641136D6C929811D86AE72E54598BB7DB27F4)(0x160CB44B2FAF93B0375D40E77D560091F066C8616B692FF842F90B6FEBC9BAB2 0x16C4E5ADA6534B5EA0406918AD2D64BC414EAFFBC723F27B359C524FF5FCE39C))((0x3FB19114E947FFDC540FB4284835CB74279DAB1CF3154F0874B0A0A5E63A3EEB 0x3D65D5B172CEF8D31F34A49AB0889F7A10A2238846B6B24569D68AA791F94CB6)(0x0F02699D800DB868A06E3EE4A0C158C90BC48A691E81744FFBCFDA32FF24DCF4 0x2714671243FD8237D339E0AC2C941EE9A642FDF6FCBBE031B42696FD69E831AB))((0x0521F6B05212DC975AF0007CD24D328B2ECED1C82791D2E606059B65BCBE554E 0x36BE6DAC4B773494121F7DD5F8507D36AE6ACC1DC99FA860DED1CA7AE8A3ED01)(0x38B51B590BF50CC6A24AB80474EB147A30C4AF3DD19A5654C1B105559BD14D4D 0x3E11DE8B1B4638FBD8C4D6836A747C0A81578A4D22B84AC58EC061FEB68B3177))((0x2D5328E0BA58995C7066774A463F8A902D7C2B97BD45C10B9D8B4D823DF106AC 0x26933A9C217727C9CDC4A4494D3E332B36BB997396FCA706099FFD3439BB4836)(0x0BB116BA807D12D4DF79557FFB7F60B48858601912530E3F49C890A34AED31CB 0x2462E0396ED302DD10A6EF43AE532333543F4A875599E83FBE4106644DDD3F8E))))(z_1 0x06A616C3A625F92ED65B5CA99D9A1DAAA476481B9C45E4553E7A8E436B13D570)(z_2 0x310AE40CBCE21FA0DC92D1DFE7DF49D939A579FF029F869118036BF8B370438C)(delta(0x366414F4FE9C3DDB27DA5A85452CEDBC65AFD104D1F5C241BE2E594F615ABBBC 0x0B4190D59EEA6EBF8B9316054439E92B5BFDC8CD9BB0C864783D5F1D785DF87E))(challenge_polynomial_commitment(0x1340C10B30AD07F4913C3CDD588C3E8A5A6E6DAC9947378FA97D11F52CCD4AE1 0x0B110AAD2D1957C9C6944439DED80C9CE9A0EAD35C96903AC1EADBC94AEB5D29))))(evals(((w((0x1BF1CE494D243FEF9253CB66CC3D6300A37ED4A230C154451779FA16F6AAEDD7)(0x2A9AB4178F95EAE6A3D608276A4BCD390A88DAF8C35196061ED79DADB747CA62)(0x2F272FD8DF352C035E81FC1A5C8664AABEF4F62962B7E3D03F6BF53C10C2B398)(0x0967B0F7F74E6558AB86D813EAB8490C43C569BAB9E72761C8D4086810A621B2)(0x3BE58E7E3C8DFFE8317E68E50729FFBD6E22E3FE43F3FD0C469F46768068550B)(0x2417CB5380DAD79780D62428CC09175FBE2DBC443E0767157589A7D581458D33)(0x206FA1779C5057CD0639666D2581A170B83CE654C654544C73F7DFD022FF1597)(0x3EC85737838ED8C4CB90D54523231C950FC641DAA8390AC6612995ADBBFC2947)(0x1A24C3397D2F39F1DFEECCCB66C78BE61279D5C22AD692C23DD5268133793F38)(0x1813C59133F4204F15554D891F94D802D26E2F18343D513E164706636CD7D6E4)(0x0534DF67954B7AAA90DBDFA81468B83F4182B927D5B418E531795998B9825BE3)(0x0F7FC2CEA19984972EE5732743ACDA4C6C406F03A852555019F213E43326B61A)(0x367ADA537033A054A65F0E145E6E79B56F054EEB8011F1EEE163E137D6366B89)(0x1B3232DFA316997F453D7A6F2005E6E096B54B3847F6FE8D581165887F85FD71)(0x0EDC1BCD8B78233F2C5E236D6D05265A586587AB0B1C0F5EE3A26E3EC45C8559)))(z(0x2D46727CABD1AD20E476E7ED8D664640D0565D3F01CBBF7C6258E2F436E0FB64))(s((0x16C1D17F88C267C43D4DFD19768583A2E9AB7AEC6975B09F139DF1AB5C41C815)(0x250EA67AD22E2661208B05E72B1054F60798FD58DDFE3333FAA9B5AB547C6745)(0x258A8C918280C265F825EB72C0B8C625665C2FAF60697D588EC6AACAC73D0B86)(0x072EFAAFC967EFE45BFF2EEC1A8CBF8A0B2CC1F44B25296DA33F73B3E48862D2)(0x3A23A8AA2A3D0DC85299DE4975C8485473C9C1D0D0D84A0BECFFD31351A6071D)(0x0DBC51C9DF923ACB44274742095761E599ED1D8F94EF8F414C151DCC5223A13F)))(generic_selector(0x1AB9C88B53C9CFD0A65823311711ABF1E13E5B352DC2D35C6D34A4508EF42C1D))(poseidon_selector(0x0D4DB96949873B90F365BCBC73B2A1AAE695533742F6472E050D024C47EF051F)))((w((0x044E2486D22B5737733C4933944865079C1D24CB1B62D5A5D99FB4A84D1A7806)(0x2B7D6F8FCA7A01770626488AD8540BDBAD1337C627CD8A9E63212A2A05831410)(0x2D92673EBC67FB88DC3053F021AA44F5ECC10FE56E9D8169EB28B63C86AE5766)(0x11BD17917D68A2E68F4E16998A89F15F53BCEE8524042E87316A917BE118B573)(0x1978EF73627746A050DFFFB981ACCAFDE1ED51690921994DBCEE69E44892C07A)(0x20B24CDDD02F9E3E3864B905A0E34C1910914A3990497208B44D9B7D2F9C04D8)(0x074347DE39DBB739163EC16F4AC610BAFE9328C7677A59ADB0E4949BEA72139F)(0x29F334283A097BEF545ED4BD25FE90538565AFB1ECCFBF12BB636F536950AAE5)(0x1D956F27A2C2B32F5108F9261BF08336CABF3F43A34D76549747C589AB268E26)(0x0F67F822B5005129FDDFA19806B63E2F9293651319E024F470A4E3C093C953FA)(0x07FE17373605026D0611EA8C56D5A5E012737A651B9DB4F2B6D3643E66AE8055)(0x050CA2177E768D190DB1B8EF36BFC9295796447C0F00F1C30D4EAD2C4CCF2576)(0x008B132B8DD971E8BD710E2176BA1A1486E982682603D7C99354FFDDD42ED0DF)(0x386E04A8455ACB87D0E73727740ECD7FD21607BBE70CE413AAA2ED5293FA203B)(0x29225BD92F00CC712E9F3FFCA7660592B80987BE8B35DDFF83194F0799DC3B44)))(z(0x2345A1A7FB004FF4B933E47E914BC762D3321AC74A1EB807F22F75F716A29745))(s((0x384F9DCC50FFCCCD17FE53094FDD6C6E3A189937EF2202055A9E84207D1F990F)(0x3E3C73F348C36B61D52D5DDFF36D766357B58A914875549471351BEAB35952CB)(0x193A462B9731E73C8622E658BAD0DB5A932213978DB3925DBB5ACF07F8AB2B4C)(0x2B6E71A35F8A6C161A22D6CA45CA5766378890C30EA61AF0A179CB6B5496E177)(0x03A7BF41CF46215871DC385F1C4AB03A8C3DD67EC3F789E425BAEC8ED2B4A65F)(0x23C3758C52FE243A5E63FD6AEC2218CC2A001A6F655F2E44F1A13E391FFA4BB8)))(generic_selector(0x2CC43F0A9D98CBE8E5B6FC354E9B090B910754181165DBE475E88A0A02F5A786))(poseidon_selector(0x22A81C50CBBE608CB6F8A807471424EB0A5167B392446F32E192E33EFDBFCE75)))))(ft_eval1 0x34AD5FA8AD38D9FB83534F851F0924BA3B9B43E1C45703F151A19BCCE71F4E7D))))))\"\n |> Side_loaded.Proof.of_base64\n with\n | Error e ->\n failwith e\n | Ok pi ->\n pi\n in\n let statement =\n let transaction =\n Backend.Tick.Field.t_of_sexp\n (Atom\n \"0x2340A5795E22C7C923991D225400D0052B3A995C35BCCDC612E6205287419EC1\"\n )\n in\n let at_account_update =\n Backend.Tick.Field.t_of_sexp\n (Atom\n \"0x2340A5795E22C7C923991D225400D0052B3A995C35BCCDC612E6205287419EC1\"\n )\n in\n [| transaction; at_account_update |]\n in\n let vk =\n Side_loaded.Verification_key.of_base58_check_exn\n \"VVA53aPgmCXemUiPjxo1dhgdNUSWbJarTh9Xhaki6b1AjVE31nk6wnSKcPa6JSJ8KDTDMryCozStCeisLTXLoYxBo3fjFhgPJn25EnuJMggPrVocSW3SfQBY7dgpPqQVccsqSPcFGJptarG6dRrLcx65M4SqudGDWbzpKd2oLyeTVifRTREq2BibC3rWMpUDuLwXEnp61FfFaktb4WKu3hfHyYBt5vL3Xndi9kynUWuhznijLG2yP7eX7o5M3nbjfkg7NdWaGReZH1yt4ewtrmHEMF5qTdK2UPgNzpScaK7ix8wZV5qECT483DsuY6Wpx3s2FfdmRDYwdr2YejhW4ZnJLNAxMgUkV3xkid5esqnk5TuQrdHMYvLZXju3RrZrvqhmbTFXpANKskZnuH1BUvkeoPvpQeYdoeYDJ6bgM6NFB3oWsPTU3vSMg3Wjsqx6Ekc8MuZHuaziGax9WNxbM3H6HscZFRs4npttEiwj1gSvZNaVc9FfRdCa3CMMWJNR1CkA1zKtCb8Sie1yiHc89hDA7K5mufV1yaX88xmAQrhZpTLCE8Ch62Zp3P1Vy6QVDACZCKSiz3bhikYEXFKZaJfRYVZVPeEBgjnUDrB4SD61KKnvWWESV8a3uGudeBLnJqoPJuBC8bZTUfskxqzkXmz2XTv4HMARJRTg21tFB8mZmLgVuaSWpc6inGxTZeWmE9ECSFzHuazEPNQ6yn1xo7G72ixrmLZrZqhbhPfnqSL5SWnmFWaWTihNNdHac8FDwb8JKvneC5yUur3WAZ8tTULiiNVvQhjhKVUrym2wTWFwhDAy6GqZcYeWRig9gpgdaxEuA7YnDc8XZZ5JS643PBfAWZZ3mZR4NxXPnVfn1xAUD2VFXmA8pzkqRwQ8DSpSPpKuwzwuJQUW6QSGtBheKFSxrXt6qekFX2azueedJZrhnwPW78dM7v3Qd2zTWo8iD2wfBB1Yot8BfUqAk7FYyi9hajKT1qZWQMg3kUVBywX93KBht2RFDJeVwiuE2hHaAzobxnnwsPJKPHaU8SM1EXQ4cFP2zJ2acPig52MNht3Z34fMeZ65bA3eEbcDbJw3pk2YS1pHtEr818b5TisPu6gshwkRGghbnTsQzHCjZVf61rpT4WphBsv6ob6foLwdc5ZSxq2BFzAWUv5j5nrtU9fqnQCx1DooZxAc8BnjxCXQ5TnE4Rpj82JwUR59QFNza2RwK2vZLvrNPt1LK5eCkZV8fBWuYD9J4AnxGA8icQbWBAfsSk9xXJBynEKymAsw6eTFPWCAMjQgJLhJP8MJR3NyNbqMfT1nR924EyZged7US9ogU8CLV5GcMBTSzAyCSFwFN8LGL1uT9sStzwQNbUvKvXYRwWNMYpb7Mxcjz1NjBaMbiWUryMcJc3D19yXt8VNt5g3L3Ty4GtL3WWV2aXRRXcuzYZai6wV8ESPGd3R6o4NJS5Ct5Z98fx25sNtswb77Q18pU379m4wsk8ck872oMZTPp9bDHTVpLoEBHd1gkC6j7pP8dx3cNTWc1NoewCGLi6zLDNfPZDrRXZESnaDRgVGEDinXS5SeAihMcQxvriHyskPW4SidcZsZtPvLnoQz7HQRpDnXfg4j6b8P5EX6sSJbkU9is3k6e8puQirFzLLgh2uC4oZH8EzLRZcGkonQPP5sLTmfwX4s5DJYdS4NLAVYSXndVZ4fazLfqPLukdWQkxZihUq4NtFkfzpNB8MPUBe6T72zhnvqVPegeEhgVvUokcn2DRJUc93DSYSGEJ3eZNFTruCgbM7xMXq83K6eraFRvxGqAgsQcTcQKwEfF9XvuppFDBbEHjdg84w1XiRkZ7xPKDdF6Hvi5G8V6rr6q1T7qypKiFqNrwM6frbJqgjedLpAY6RkPchip2WsZTpEX3EY1ryyGnJxZvb2fjCooQ9u1R6zNArVCV383KNJQZAaWFgzd58F7ZJ1fGU8zeFzDuhqSwqPyDE299sVYMSfbvp7xjWygxrbjApRE2FkjQtjuxaiXzsuemvrrSedVCGrktCHNqPKkJxbLcpz97rRBvwnKSd26x8LKHn2Zjzp2qeyxsY8HN7WVPATxPE4xXqi9dw41o8LBQ3GDGe1ASjphdp4bxj1guHhSZbMKTJDj7hJKyuvBMdG1YKQo3uv2qu5MiB3Afu5SZbZStNKBnxc2DRoDyF45yrQNeoBJogcSLAqWG624ZAdU4BWrqRJNjoAu6GxxE6E8TvFtvyDW1R9Nv7tXzmWE7RarrAL9YUD6uqe7gAanAv1cdAJRcPcdr2YvUL7zeB5d1daPfwJW4PYDvMwnnqDFSXgNqPreh8nFaiReDYjiHkwCojPcCgdcK5gJwpQTasjkWQBk2RmFQdfaLCpiPZGroZ6hTvRBHq2MwdUtkQHZjjCvY9fUtnniMVdUgkAZ9oLj8evpeoDEwyEHE1upmZZN84CMPP32NpHDtH3PwgGR3\"\n in\n assert (\n Promise.block_on_async_exn (fun () ->\n Side_loaded.verify_promise ~value_to_field_elements:Fn.id\n ~return_typ:Impls.Step.Typ.unit\n [ (vk, (statement, ()), pi) ] ) )*)\n\n open Impls.Step\n\n let () = Snarky_backendless.Snark0.set_eval_constraints true\n\n (* Currently, a circuit must have at least 1 of every type of constraint. *)\n let dummy_constraints () =\n Impl.(\n let x =\n exists Field.typ ~compute:(fun () -> Field.Constant.of_int 3)\n in\n let g =\n exists Step_main_inputs.Inner_curve.typ ~compute:(fun _ ->\n Tick.Inner_curve.(to_affine_exn one) )\n in\n ignore\n ( SC.to_field_checked'\n (module Impl)\n ~num_bits:16\n (Kimchi_backend_common.Scalar_challenge.create x)\n : Field.t * Field.t * Field.t ) ;\n ignore\n ( Step_main_inputs.Ops.scale_fast g ~num_bits:5 (Shifted_value x)\n : Step_main_inputs.Inner_curve.t ) ;\n ignore\n ( Step_main_inputs.Ops.scale_fast g ~num_bits:5 (Shifted_value x)\n : Step_main_inputs.Inner_curve.t ) ;\n ignore\n ( Step_verifier.Scalar_challenge.endo g ~num_bits:4\n (Kimchi_backend_common.Scalar_challenge.create x)\n : Field.t * Field.t ))\n\n module No_recursion = struct\n let[@warning \"-45\"] tag, _, p, Provers.[ step ] =\n Common.time \"compile\" (fun () ->\n compile_promise () ~public_input:(Input Field.typ)\n ~auxiliary_typ:Typ.unit\n ~branches:(module Nat.N1)\n ~max_proofs_verified:(module Nat.N0)\n ~name:\"blockchain-snark\"\n ~constraint_constants:\n (* Dummy values *)\n { sub_windows_per_window = 0\n ; ledger_depth = 0\n ; work_delay = 0\n ; block_window_duration_ms = 0\n ; transaction_capacity = Log_2 0\n ; pending_coinbase_depth = 0\n ; coinbase_amount = Unsigned.UInt64.of_int 0\n ; supercharged_coinbase_factor = 0\n ; account_creation_fee = Unsigned.UInt64.of_int 0\n ; fork = None\n }\n ~choices:(fun ~self:_ ->\n [ { identifier = \"main\"\n ; prevs = []\n ; feature_flags = Plonk_types.Features.none_bool\n ; main =\n (fun { public_input = self } ->\n dummy_constraints () ;\n Field.Assert.equal self Field.zero ;\n { previous_proof_statements = []\n ; public_output = ()\n ; auxiliary_output = ()\n } )\n }\n ] ) )\n\n module Proof = (val p)\n\n let example =\n let (), (), b0 =\n Common.time \"b0\" (fun () ->\n Promise.block_on_async_exn (fun () -> step Field.Constant.zero) )\n in\n Or_error.ok_exn\n (Promise.block_on_async_exn (fun () ->\n Proof.verify_promise [ (Field.Constant.zero, b0) ] ) ) ;\n (Field.Constant.zero, b0)\n\n let _example_input, _example_proof = example\n end\n\n module No_recursion_return = struct\n let[@warning \"-45\"] tag, _, p, Provers.[ step ] =\n Common.time \"compile\" (fun () ->\n compile_promise () ~public_input:(Output Field.typ)\n ~auxiliary_typ:Typ.unit\n ~branches:(module Nat.N1)\n ~max_proofs_verified:(module Nat.N0)\n ~name:\"blockchain-snark\"\n ~constraint_constants:\n (* Dummy values *)\n { sub_windows_per_window = 0\n ; ledger_depth = 0\n ; work_delay = 0\n ; block_window_duration_ms = 0\n ; transaction_capacity = Log_2 0\n ; pending_coinbase_depth = 0\n ; coinbase_amount = Unsigned.UInt64.of_int 0\n ; supercharged_coinbase_factor = 0\n ; account_creation_fee = Unsigned.UInt64.of_int 0\n ; fork = None\n }\n ~choices:(fun ~self:_ ->\n [ { identifier = \"main\"\n ; prevs = []\n ; feature_flags = Plonk_types.Features.none_bool\n ; main =\n (fun _ ->\n dummy_constraints () ;\n { previous_proof_statements = []\n ; public_output = Field.zero\n ; auxiliary_output = ()\n } )\n }\n ] ) )\n\n module Proof = (val p)\n\n let example =\n let res, (), b0 =\n Common.time \"b0\" (fun () ->\n Promise.block_on_async_exn (fun () -> step ()) )\n in\n assert (Field.Constant.(equal zero) res) ;\n Or_error.ok_exn\n (Promise.block_on_async_exn (fun () ->\n Proof.verify_promise [ (res, b0) ] ) ) ;\n (res, b0)\n\n let _example_input, _example_proof = example\n end\n\n [@@@warning \"-60\"]\n\n module Simple_chain = struct\n type _ Snarky_backendless.Request.t +=\n | Prev_input : Field.Constant.t Snarky_backendless.Request.t\n | Proof : (Nat.N1.n, Nat.N1.n) Proof.t Snarky_backendless.Request.t\n\n let handler (prev_input : Field.Constant.t) (proof : _ Proof.t)\n (Snarky_backendless.Request.With { request; respond }) =\n match request with\n | Prev_input ->\n respond (Provide prev_input)\n | Proof ->\n respond (Provide proof)\n | _ ->\n respond Unhandled\n\n let[@warning \"-45\"] _tag, _, p, Provers.[ step ] =\n Common.time \"compile\" (fun () ->\n compile_promise () ~public_input:(Input Field.typ)\n ~auxiliary_typ:Typ.unit\n ~branches:(module Nat.N1)\n ~max_proofs_verified:(module Nat.N1)\n ~name:\"blockchain-snark\"\n ~constraint_constants:\n (* Dummy values *)\n { sub_windows_per_window = 0\n ; ledger_depth = 0\n ; work_delay = 0\n ; block_window_duration_ms = 0\n ; transaction_capacity = Log_2 0\n ; pending_coinbase_depth = 0\n ; coinbase_amount = Unsigned.UInt64.of_int 0\n ; supercharged_coinbase_factor = 0\n ; account_creation_fee = Unsigned.UInt64.of_int 0\n ; fork = None\n }\n ~choices:(fun ~self ->\n [ { identifier = \"main\"\n ; prevs = [ self ]\n ; feature_flags = Plonk_types.Features.none_bool\n ; main =\n (fun { public_input = self } ->\n let prev =\n exists Field.typ ~request:(fun () -> Prev_input)\n in\n let proof =\n exists (Typ.Internal.ref ()) ~request:(fun () ->\n Proof )\n in\n let is_base_case = Field.equal Field.zero self in\n let proof_must_verify = Boolean.not is_base_case in\n let self_correct = Field.(equal (one + prev) self) in\n Boolean.Assert.any [ self_correct; is_base_case ] ;\n { previous_proof_statements =\n [ { public_input = prev\n ; proof\n ; proof_must_verify\n }\n ]\n ; public_output = ()\n ; auxiliary_output = ()\n } )\n }\n ] ) )\n\n module Proof = (val p)\n\n let example =\n let s_neg_one = Field.Constant.(negate one) in\n let b_neg_one : (Nat.N1.n, Nat.N1.n) Proof0.t =\n Proof0.dummy Nat.N1.n Nat.N1.n Nat.N1.n ~domain_log2:14\n in\n let (), (), b0 =\n Common.time \"b0\" (fun () ->\n Promise.block_on_async_exn (fun () ->\n step\n ~handler:(handler s_neg_one b_neg_one)\n Field.Constant.zero ) )\n in\n Or_error.ok_exn\n (Promise.block_on_async_exn (fun () ->\n Proof.verify_promise [ (Field.Constant.zero, b0) ] ) ) ;\n let (), (), b1 =\n Common.time \"b1\" (fun () ->\n Promise.block_on_async_exn (fun () ->\n step\n ~handler:(handler Field.Constant.zero b0)\n Field.Constant.one ) )\n in\n Or_error.ok_exn\n (Promise.block_on_async_exn (fun () ->\n Proof.verify_promise [ (Field.Constant.one, b1) ] ) ) ;\n (Field.Constant.one, b1)\n\n let _example_input, _example_proof = example\n end\n\n module Tree_proof = struct\n type _ Snarky_backendless.Request.t +=\n | No_recursion_input : Field.Constant.t Snarky_backendless.Request.t\n | No_recursion_proof :\n (Nat.N0.n, Nat.N0.n) Proof.t Snarky_backendless.Request.t\n | Recursive_input : Field.Constant.t Snarky_backendless.Request.t\n | Recursive_proof :\n (Nat.N2.n, Nat.N2.n) Proof.t Snarky_backendless.Request.t\n\n let handler\n ((no_recursion_input, no_recursion_proof) :\n Field.Constant.t * _ Proof.t )\n ((recursion_input, recursion_proof) : Field.Constant.t * _ Proof.t)\n (Snarky_backendless.Request.With { request; respond }) =\n match request with\n | No_recursion_input ->\n respond (Provide no_recursion_input)\n | No_recursion_proof ->\n respond (Provide no_recursion_proof)\n | Recursive_input ->\n respond (Provide recursion_input)\n | Recursive_proof ->\n respond (Provide recursion_proof)\n | _ ->\n respond Unhandled\n\n let[@warning \"-45\"] _tag, _, p, Provers.[ step ] =\n Common.time \"compile\" (fun () ->\n compile_promise () ~public_input:(Input Field.typ)\n ~override_wrap_domain:Pickles_base.Proofs_verified.N1\n ~auxiliary_typ:Typ.unit\n ~branches:(module Nat.N1)\n ~max_proofs_verified:(module Nat.N2)\n ~name:\"blockchain-snark\"\n ~constraint_constants:\n (* Dummy values *)\n { sub_windows_per_window = 0\n ; ledger_depth = 0\n ; work_delay = 0\n ; block_window_duration_ms = 0\n ; transaction_capacity = Log_2 0\n ; pending_coinbase_depth = 0\n ; coinbase_amount = Unsigned.UInt64.of_int 0\n ; supercharged_coinbase_factor = 0\n ; account_creation_fee = Unsigned.UInt64.of_int 0\n ; fork = None\n }\n ~choices:(fun ~self ->\n [ { identifier = \"main\"\n ; feature_flags = Plonk_types.Features.none_bool\n ; prevs = [ No_recursion.tag; self ]\n ; main =\n (fun { public_input = self } ->\n let no_recursive_input =\n exists Field.typ ~request:(fun () ->\n No_recursion_input )\n in\n let no_recursive_proof =\n exists (Typ.Internal.ref ()) ~request:(fun () ->\n No_recursion_proof )\n in\n let prev =\n exists Field.typ ~request:(fun () ->\n Recursive_input )\n in\n let prev_proof =\n exists (Typ.Internal.ref ()) ~request:(fun () ->\n Recursive_proof )\n in\n let is_base_case = Field.equal Field.zero self in\n let proof_must_verify = Boolean.not is_base_case in\n let self_correct = Field.(equal (one + prev) self) in\n Boolean.Assert.any [ self_correct; is_base_case ] ;\n { previous_proof_statements =\n [ { public_input = no_recursive_input\n ; proof = no_recursive_proof\n ; proof_must_verify = Boolean.true_\n }\n ; { public_input = prev\n ; proof = prev_proof\n ; proof_must_verify\n }\n ]\n ; public_output = ()\n ; auxiliary_output = ()\n } )\n }\n ] ) )\n\n module Proof = (val p)\n\n let example1, example2 =\n let s_neg_one = Field.Constant.(negate one) in\n let b_neg_one : (Nat.N2.n, Nat.N2.n) Proof0.t =\n Proof0.dummy Nat.N2.n Nat.N2.n Nat.N2.n ~domain_log2:15\n in\n let (), (), b0 =\n Common.time \"tree b0\" (fun () ->\n Promise.block_on_async_exn (fun () ->\n step\n ~handler:\n (handler No_recursion.example (s_neg_one, b_neg_one))\n Field.Constant.zero ) )\n in\n Or_error.ok_exn\n (Promise.block_on_async_exn (fun () ->\n Proof.verify_promise [ (Field.Constant.zero, b0) ] ) ) ;\n let (), (), b1 =\n Common.time \"tree b1\" (fun () ->\n Promise.block_on_async_exn (fun () ->\n step\n ~handler:\n (handler No_recursion.example (Field.Constant.zero, b0))\n Field.Constant.one ) )\n in\n ((Field.Constant.zero, b0), (Field.Constant.one, b1))\n\n let examples = [ example1; example2 ]\n\n let _example1_input, _example_proof = example1\n\n let _example2_input, _example2_proof = example2\n end\n\n let%test_unit \"verify\" =\n Or_error.ok_exn\n (Promise.block_on_async_exn (fun () ->\n Tree_proof.Proof.verify_promise Tree_proof.examples ) )\n\n module Tree_proof_return = struct\n type _ Snarky_backendless.Request.t +=\n | Is_base_case : bool Snarky_backendless.Request.t\n | No_recursion_input : Field.Constant.t Snarky_backendless.Request.t\n | No_recursion_proof :\n (Nat.N0.n, Nat.N0.n) Proof.t Snarky_backendless.Request.t\n | Recursive_input : Field.Constant.t Snarky_backendless.Request.t\n | Recursive_proof :\n (Nat.N2.n, Nat.N2.n) Proof.t Snarky_backendless.Request.t\n\n let handler (is_base_case : bool)\n ((no_recursion_input, no_recursion_proof) :\n Field.Constant.t * _ Proof.t )\n ((recursion_input, recursion_proof) : Field.Constant.t * _ Proof.t)\n (Snarky_backendless.Request.With { request; respond }) =\n match request with\n | Is_base_case ->\n respond (Provide is_base_case)\n | No_recursion_input ->\n respond (Provide no_recursion_input)\n | No_recursion_proof ->\n respond (Provide no_recursion_proof)\n | Recursive_input ->\n respond (Provide recursion_input)\n | Recursive_proof ->\n respond (Provide recursion_proof)\n | _ ->\n respond Unhandled\n\n let[@warning \"-45\"] _tag, _, p, Provers.[ step ] =\n Common.time \"compile\" (fun () ->\n compile_promise () ~public_input:(Output Field.typ)\n ~override_wrap_domain:Pickles_base.Proofs_verified.N1\n ~auxiliary_typ:Typ.unit\n ~branches:(module Nat.N1)\n ~max_proofs_verified:(module Nat.N2)\n ~name:\"blockchain-snark\"\n ~constraint_constants:\n (* Dummy values *)\n { sub_windows_per_window = 0\n ; ledger_depth = 0\n ; work_delay = 0\n ; block_window_duration_ms = 0\n ; transaction_capacity = Log_2 0\n ; pending_coinbase_depth = 0\n ; coinbase_amount = Unsigned.UInt64.of_int 0\n ; supercharged_coinbase_factor = 0\n ; account_creation_fee = Unsigned.UInt64.of_int 0\n ; fork = None\n }\n ~choices:(fun ~self ->\n [ { identifier = \"main\"\n ; feature_flags = Plonk_types.Features.none_bool\n ; prevs = [ No_recursion_return.tag; self ]\n ; main =\n (fun { public_input = () } ->\n let no_recursive_input =\n exists Field.typ ~request:(fun () ->\n No_recursion_input )\n in\n let no_recursive_proof =\n exists (Typ.Internal.ref ()) ~request:(fun () ->\n No_recursion_proof )\n in\n let prev =\n exists Field.typ ~request:(fun () ->\n Recursive_input )\n in\n let prev_proof =\n exists (Typ.Internal.ref ()) ~request:(fun () ->\n Recursive_proof )\n in\n let is_base_case =\n exists Boolean.typ ~request:(fun () -> Is_base_case)\n in\n let proof_must_verify = Boolean.not is_base_case in\n let self =\n Field.(\n if_ is_base_case ~then_:zero ~else_:(one + prev))\n in\n { previous_proof_statements =\n [ { public_input = no_recursive_input\n ; proof = no_recursive_proof\n ; proof_must_verify = Boolean.true_\n }\n ; { public_input = prev\n ; proof = prev_proof\n ; proof_must_verify\n }\n ]\n ; public_output = self\n ; auxiliary_output = ()\n } )\n }\n ] ) )\n\n module Proof = (val p)\n\n let example1, example2 =\n let s_neg_one = Field.Constant.(negate one) in\n let b_neg_one : (Nat.N2.n, Nat.N2.n) Proof0.t =\n Proof0.dummy Nat.N2.n Nat.N2.n Nat.N2.n ~domain_log2:15\n in\n let s0, (), b0 =\n Common.time \"tree b0\" (fun () ->\n Promise.block_on_async_exn (fun () ->\n step\n ~handler:\n (handler true No_recursion_return.example\n (s_neg_one, b_neg_one) )\n () ) )\n in\n assert (Field.Constant.(equal zero) s0) ;\n Or_error.ok_exn\n (Promise.block_on_async_exn (fun () ->\n Proof.verify_promise [ (s0, b0) ] ) ) ;\n let s1, (), b1 =\n Common.time \"tree b1\" (fun () ->\n Promise.block_on_async_exn (fun () ->\n step\n ~handler:\n (handler false No_recursion_return.example (s0, b0))\n () ) )\n in\n assert (Field.Constant.(equal one) s1) ;\n ((s0, b0), (s1, b1))\n\n let examples = [ example1; example2 ]\n\n let _example1_input, _example1_proof = example1\n\n let _example2_input, _example2_proof = example2\n end\n\n let%test_unit \"verify\" =\n Or_error.ok_exn\n (Promise.block_on_async_exn (fun () ->\n Tree_proof_return.Proof.verify_promise Tree_proof_return.examples )\n )\n\n module Add_one_return = struct\n let[@warning \"-45\"] _tag, _, p, Provers.[ step ] =\n Common.time \"compile\" (fun () ->\n compile_promise ()\n ~public_input:(Input_and_output (Field.typ, Field.typ))\n ~auxiliary_typ:Typ.unit\n ~branches:(module Nat.N1)\n ~max_proofs_verified:(module Nat.N0)\n ~name:\"blockchain-snark\"\n ~constraint_constants:\n (* Dummy values *)\n { sub_windows_per_window = 0\n ; ledger_depth = 0\n ; work_delay = 0\n ; block_window_duration_ms = 0\n ; transaction_capacity = Log_2 0\n ; pending_coinbase_depth = 0\n ; coinbase_amount = Unsigned.UInt64.of_int 0\n ; supercharged_coinbase_factor = 0\n ; account_creation_fee = Unsigned.UInt64.of_int 0\n ; fork = None\n }\n ~choices:(fun ~self:_ ->\n [ { identifier = \"main\"\n ; feature_flags = Plonk_types.Features.none_bool\n ; prevs = []\n ; main =\n (fun { public_input = x } ->\n dummy_constraints () ;\n { previous_proof_statements = []\n ; public_output = Field.(add one) x\n ; auxiliary_output = ()\n } )\n }\n ] ) )\n\n module Proof = (val p)\n\n let example =\n let input = Field.Constant.of_int 42 in\n let res, (), b0 =\n Common.time \"b0\" (fun () ->\n Promise.block_on_async_exn (fun () -> step input) )\n in\n assert (Field.Constant.(equal (of_int 43)) res) ;\n Or_error.ok_exn\n (Promise.block_on_async_exn (fun () ->\n Proof.verify_promise [ ((input, res), b0) ] ) ) ;\n ((input, res), b0)\n\n let _example_input, _example_proof = example\n end\n\n module Auxiliary_return = struct\n let[@warning \"-45\"] _tag, _, p, Provers.[ step ] =\n Common.time \"compile\" (fun () ->\n compile_promise ()\n ~public_input:(Input_and_output (Field.typ, Field.typ))\n ~auxiliary_typ:Field.typ\n ~branches:(module Nat.N1)\n ~max_proofs_verified:(module Nat.N0)\n ~name:\"blockchain-snark\"\n ~constraint_constants:\n (* Dummy values *)\n { sub_windows_per_window = 0\n ; ledger_depth = 0\n ; work_delay = 0\n ; block_window_duration_ms = 0\n ; transaction_capacity = Log_2 0\n ; pending_coinbase_depth = 0\n ; coinbase_amount = Unsigned.UInt64.of_int 0\n ; supercharged_coinbase_factor = 0\n ; account_creation_fee = Unsigned.UInt64.of_int 0\n ; fork = None\n }\n ~choices:(fun ~self:_ ->\n [ { identifier = \"main\"\n ; feature_flags = Plonk_types.Features.none_bool\n ; prevs = []\n ; main =\n (fun { public_input = input } ->\n dummy_constraints () ;\n let sponge =\n Step_main_inputs.Sponge.create\n Step_main_inputs.sponge_params\n in\n let blinding_value =\n exists Field.typ ~compute:Field.Constant.random\n in\n Step_main_inputs.Sponge.absorb sponge (`Field input) ;\n Step_main_inputs.Sponge.absorb sponge\n (`Field blinding_value) ;\n let result = Step_main_inputs.Sponge.squeeze sponge in\n { previous_proof_statements = []\n ; public_output = result\n ; auxiliary_output = blinding_value\n } )\n }\n ] ) )\n\n module Proof = (val p)\n\n let example =\n let input = Field.Constant.of_int 42 in\n let result, blinding_value, b0 =\n Common.time \"b0\" (fun () ->\n Promise.block_on_async_exn (fun () -> step input) )\n in\n let sponge =\n Tick_field_sponge.Field.create Tick_field_sponge.params\n in\n Tick_field_sponge.Field.absorb sponge input ;\n Tick_field_sponge.Field.absorb sponge blinding_value ;\n let result' = Tick_field_sponge.Field.squeeze sponge in\n assert (Field.Constant.equal result result') ;\n Or_error.ok_exn\n (Promise.block_on_async_exn (fun () ->\n Proof.verify_promise [ ((input, result), b0) ] ) ) ;\n ((input, result), b0)\n\n let _example_input, _example_proof = example\n end\n end )\n\n let%test_module \"test uncorrelated bulletproof_challenges\" =\n ( module struct\n let () = Backtrace.elide := false\n\n let () = Snarky_backendless.Snark0.set_eval_constraints true\n\n module Statement = struct\n type t = unit\n\n let to_field_elements () = [||]\n end\n\n module A = Statement\n module A_value = Statement\n\n let typ = Impls.Step.Typ.unit\n\n module Branches = Nat.N1\n module Max_proofs_verified = Nat.N2\n\n let constraint_constants : Snark_keys_header.Constraint_constants.t =\n { sub_windows_per_window = 0\n ; ledger_depth = 0\n ; work_delay = 0\n ; block_window_duration_ms = 0\n ; transaction_capacity = Log_2 0\n ; pending_coinbase_depth = 0\n ; coinbase_amount = Unsigned.UInt64.of_int 0\n ; supercharged_coinbase_factor = 0\n ; account_creation_fee = Unsigned.UInt64.of_int 0\n ; fork = None\n }\n\n let tag =\n let tagname = \"\" in\n Tag.create ~kind:Compiled tagname\n\n let rule : _ Inductive_rule.t =\n let open Impls.Step in\n { identifier = \"main\"\n ; prevs = [ tag; tag ]\n ; main =\n (fun { public_input = () } ->\n let dummy_proof =\n As_prover.Ref.create (fun () ->\n Proof0.dummy Nat.N2.n Nat.N2.n Nat.N2.n ~domain_log2:15 )\n in\n { previous_proof_statements =\n [ { public_input = ()\n ; proof = dummy_proof\n ; proof_must_verify = Boolean.false_\n }\n ; { public_input = ()\n ; proof = dummy_proof\n ; proof_must_verify = Boolean.false_\n }\n ]\n ; public_output = ()\n ; auxiliary_output = ()\n } )\n ; feature_flags = Plonk_types.Features.none_bool\n }\n\n module M = struct\n module IR = Inductive_rule.T (A) (A_value) (A) (A_value) (A) (A_value)\n\n let max_local_max_proofs_verifieds ~self (type n)\n (module Max_proofs_verified : Nat.Intf with type n = n) branches\n choices =\n let module Local_max_proofs_verifieds = struct\n type t = (int, Max_proofs_verified.n) Vector.t\n end in\n let module M =\n H4.Map (IR) (E04 (Local_max_proofs_verifieds))\n (struct\n module V = H4.To_vector (Int)\n module HT = H4.T (Tag)\n\n module M =\n H4.Map (Tag) (E04 (Int))\n (struct\n let f (type a b c d) (t : (a, b, c, d) Tag.t) : int =\n if Type_equal.Id.same t.id self then\n Nat.to_int Max_proofs_verified.n\n else\n let (module M) = Types_map.max_proofs_verified t in\n Nat.to_int M.n\n end)\n\n let f :\n type a b c d.\n (a, b, c, d) IR.t -> Local_max_proofs_verifieds.t =\n fun rule ->\n let (T (_, l)) = HT.length rule.prevs in\n Vector.extend_front_exn\n (V.f l (M.f rule.prevs))\n Max_proofs_verified.n 0\n end)\n in\n let module V = H4.To_vector (Local_max_proofs_verifieds) in\n let padded = V.f branches (M.f choices) |> Vector.transpose in\n (padded, Maxes.m padded)\n\n module Lazy_keys = struct\n type t =\n (Impls.Step.Keypair.t * Dirty.t) Lazy.t\n * (Kimchi_bindings.Protocol.VerifierIndex.Fp.t * Dirty.t) Lazy.t\n\n (* TODO Think this is right.. *)\n end\n\n let compile :\n ( unit\n -> (Max_proofs_verified.n, Max_proofs_verified.n) Proof.t Promise.t\n )\n * _\n * _ =\n let self = tag in\n let snark_keys_header kind constraint_system_hash =\n { Snark_keys_header.header_version =\n Snark_keys_header.header_version\n ; kind\n ; constraint_constants\n ; commits =\n { mina = Mina_version.commit_id\n ; marlin = Mina_version.marlin_commit_id\n }\n ; length = (* This is a dummy, it gets filled in on read/write. *) 0\n ; commit_date = Mina_version.commit_date\n ; constraint_system_hash\n ; identifying_hash =\n (* TODO: Proper identifying hash. *)\n constraint_system_hash\n }\n in\n let T = Max_proofs_verified.eq in\n let prev_varss_n = Branches.n in\n let prev_varss_length : _ Length.t = S Z in\n let T = Nat.eq_exn prev_varss_n Branches.n in\n let padded, (module Maxes) =\n max_local_max_proofs_verifieds\n (module Max_proofs_verified)\n prev_varss_length [ rule ] ~self:self.id\n in\n let full_signature =\n { Full_signature.padded; maxes = (module Maxes) }\n in\n let feature_flags = Plonk_types.Features.none in\n let actual_feature_flags = Plonk_types.Features.none_bool in\n let wrap_domains =\n let module M =\n Wrap_domains.Make (A) (A_value) (A) (A_value) (A) (A_value)\n in\n M.f full_signature prev_varss_n prev_varss_length ~feature_flags\n ~max_proofs_verified:(module Max_proofs_verified)\n in\n let module Branch_data = struct\n type ('vars, 'vals, 'n, 'm) t =\n ( A.t\n , A_value.t\n , A.t\n , A_value.t\n , A.t\n , A_value.t\n , Max_proofs_verified.n\n , Branches.n\n , 'vars\n , 'vals\n , 'n\n , 'm )\n Step_branch_data.t\n end in\n let proofs_verifieds = Vector.singleton 2 in\n let (T inner_step_data as step_data) =\n Step_branch_data.create ~index:0 ~feature_flags\n ~actual_feature_flags ~max_proofs_verified:Max_proofs_verified.n\n ~branches:Branches.n ~self ~public_input:(Input typ)\n ~auxiliary_typ:typ A.to_field_elements A_value.to_field_elements\n rule ~wrap_domains ~proofs_verifieds\n in\n let step_domains = Vector.singleton inner_step_data.domains in\n let step_keypair =\n let etyp =\n Impls.Step.input ~feature_flags\n ~proofs_verified:Max_proofs_verified.n\n ~wrap_rounds:Tock.Rounds.n\n in\n let (T (typ, _conv, conv_inv)) = etyp in\n let main () () =\n let res = inner_step_data.main ~step_domains () in\n Impls.Step.with_label \"conv_inv\" (fun () -> conv_inv res)\n in\n let open Impls.Step in\n let k_p =\n lazy\n (let cs =\n constraint_system ~input_typ:Typ.unit ~return_typ:typ main\n in\n let cs_hash = Md5.to_hex (R1CS_constraint_system.digest cs) in\n ( Type_equal.Id.uid self.id\n , snark_keys_header\n { type_ = \"step-proving-key\"\n ; identifier = inner_step_data.rule.identifier\n }\n cs_hash\n , inner_step_data.index\n , cs ) )\n in\n let k_v =\n lazy\n (let id, _header, index, cs = Lazy.force k_p in\n let digest = R1CS_constraint_system.digest cs in\n ( id\n , snark_keys_header\n { type_ = \"step-verification-key\"\n ; identifier = inner_step_data.rule.identifier\n }\n (Md5.to_hex digest)\n , index\n , digest ) )\n in\n Cache.Step.read_or_generate\n ~prev_challenges:\n (Nat.to_int (fst inner_step_data.proofs_verified))\n [] k_p k_v\n (Snarky_backendless.Typ.unit ())\n typ main\n in\n let step_vks =\n lazy\n (Vector.map [ step_keypair ] ~f:(fun (_, vk) ->\n Tick.Keypair.vk_commitments (fst (Lazy.force vk)) ) )\n in\n let wrap_main _ =\n let module SC' = SC in\n let open Impls.Wrap in\n let open Wrap_main_inputs in\n let x =\n exists Field.typ ~compute:(fun () -> Field.Constant.of_int 3)\n in\n let y =\n exists Field.typ ~compute:(fun () -> Field.Constant.of_int 0)\n in\n let z =\n exists Field.typ ~compute:(fun () -> Field.Constant.of_int 0)\n in\n let g = Inner_curve.one in\n let sponge = Sponge.create sponge_params in\n Sponge.absorb sponge x ;\n ignore (Sponge.squeeze_field sponge : Field.t) ;\n ignore\n ( SC'.to_field_checked'\n (module Impl)\n ~num_bits:16\n (Kimchi_backend_common.Scalar_challenge.create x)\n : Field.t * Field.t * Field.t ) ;\n ignore\n (Ops.scale_fast g ~num_bits:5 (Shifted_value x) : Inner_curve.t) ;\n ignore\n ( Wrap_verifier.Scalar_challenge.endo g ~num_bits:4\n (Kimchi_backend_common.Scalar_challenge.create x)\n : Field.t * Field.t ) ;\n for _i = 0 to 64000 do\n assert_r1cs x y z\n done\n in\n let (wrap_pk, wrap_vk), disk_key =\n let open Impls.Wrap in\n let (T (typ, conv, _conv_inv)) = input () in\n let main x () : unit = wrap_main (conv x) in\n let self_id = Type_equal.Id.uid self.id in\n let disk_key_prover =\n lazy\n (let cs =\n constraint_system ~input_typ:typ ~return_typ:Typ.unit main\n in\n let cs_hash = Md5.to_hex (R1CS_constraint_system.digest cs) in\n ( self_id\n , snark_keys_header\n { type_ = \"wrap-proving-key\"; identifier = \"\" }\n cs_hash\n , cs ) )\n in\n let disk_key_verifier =\n lazy\n (let id, _header, cs = Lazy.force disk_key_prover in\n let digest = R1CS_constraint_system.digest cs in\n ( id\n , snark_keys_header\n { type_ = \"wrap-verification-key\"; identifier = \"\" }\n (Md5.to_hex digest)\n , digest ) )\n in\n let r =\n Common.time \"wrap read or generate \" (fun () ->\n Cache.Wrap.read_or_generate ~prev_challenges:2 []\n disk_key_prover disk_key_verifier typ Typ.unit main )\n in\n (r, disk_key_verifier)\n in\n let wrap_vk = Lazy.map wrap_vk ~f:fst in\n let module S = Step.Make (A) (A_value) (Max_proofs_verified) in\n let prover =\n let f :\n ( unit * (unit * unit)\n , unit * (unit * unit)\n , Nat.N2.n * (Nat.N2.n * unit)\n , Nat.N1.n * (Nat.N1.n * unit) )\n Branch_data.t\n -> Lazy_keys.t\n -> unit\n -> (Max_proofs_verified.n, Max_proofs_verified.n) Proof.t\n Promise.t =\n fun (T b as branch_data) (step_pk, step_vk) () ->\n let (_ : (Max_proofs_verified.n, Maxes.ns) Requests.Wrap.t) =\n Requests.Wrap.create ()\n in\n let _, prev_vars_length = b.proofs_verified in\n let step =\n let wrap_vk = Lazy.force wrap_vk in\n S.f branch_data () ~feature_flags ~prevs_length:prev_vars_length\n ~self ~public_input:(Input typ)\n ~auxiliary_typ:Impls.Step.Typ.unit ~step_domains\n ~self_dlog_plonk_index:wrap_vk.commitments\n (Impls.Step.Keypair.pk (fst (Lazy.force step_pk)))\n wrap_vk.index\n in\n let pairing_vk = fst (Lazy.force step_vk) in\n let wrap =\n let wrap_vk = Lazy.force wrap_vk in\n let%bind.Promise proof, (), (), _ =\n step ~maxes:(module Maxes)\n in\n let proof =\n { proof with\n statement =\n { proof.statement with\n messages_for_next_wrap_proof =\n Compile.pad_messages_for_next_wrap_proof\n (module Maxes)\n proof.statement.messages_for_next_wrap_proof\n }\n }\n in\n let%map.Promise proof =\n (* The prover for wrapping a proof *)\n let wrap (type actual_branching)\n ~(max_proofs_verified : Max_proofs_verified.n Nat.t)\n (module Max_local_max_proofs_verifieds : Hlist.Maxes.S\n with type ns = Maxes.ns\n and type length = Max_proofs_verified.n )\n ~dlog_plonk_index wrap_main to_field_elements ~pairing_vk\n ~step_domains:_ ~wrap_domains:_ ~pairing_plonk_indices:_\n pk\n ({ statement = prev_statement\n ; prev_evals = _\n ; proof\n ; index = _which_index\n } :\n ( _\n , _\n , (_, actual_branching) Vector.t\n , (_, actual_branching) Vector.t\n , Maxes.ns\n H1.T\n (P.Base.Messages_for_next_proof_over_same_field.Wrap)\n .t\n , ( ( Tock.Field.t\n , Tock.Field.t array )\n Plonk_types.All_evals.t\n , Max_proofs_verified.n )\n Vector.t )\n P.Base.Step.t ) =\n let prev_messages_for_next_wrap_proof =\n let module M =\n H1.Map\n (P.Base.Messages_for_next_proof_over_same_field.Wrap)\n (P.Base.Messages_for_next_proof_over_same_field.Wrap\n .Prepared)\n (struct\n let f =\n P.Base.Messages_for_next_proof_over_same_field\n .Wrap\n .prepare\n end)\n in\n M.f prev_statement.messages_for_next_wrap_proof\n in\n let prev_statement_with_hashes : _ Types.Step.Statement.t =\n { proof_state =\n { prev_statement.proof_state with\n messages_for_next_step_proof =\n (* TODO: Careful here... the length of\n old_buletproof_challenges inside the messages_for_next_wrap_proof\n might not be correct *)\n Common.hash_messages_for_next_step_proof\n ~app_state:to_field_elements\n (P.Base.Messages_for_next_proof_over_same_field\n .Step\n .prepare ~dlog_plonk_index\n prev_statement.proof_state\n .messages_for_next_step_proof )\n }\n ; messages_for_next_wrap_proof =\n (let module M =\n H1.Map\n (P.Base.Messages_for_next_proof_over_same_field\n .Wrap\n .Prepared)\n (E01 (Digest.Constant))\n (struct\n let f (type n)\n (m :\n n\n P.Base\n .Messages_for_next_proof_over_same_field\n .Wrap\n .Prepared\n .t ) =\n let T =\n Nat.eq_exn max_proofs_verified\n (Vector.length\n m.old_bulletproof_challenges )\n in\n Wrap_hack.hash_messages_for_next_wrap_proof\n max_proofs_verified m\n end)\n in\n let module V = H1.To_vector (Digest.Constant) in\n V.f Max_local_max_proofs_verifieds.length\n (M.f prev_messages_for_next_wrap_proof) )\n }\n in\n let module O = Tick.Oracles in\n let public_input =\n tick_public_input_of_statement ~max_proofs_verified\n ~feature_flags:Plonk_types.Features.none\n prev_statement_with_hashes\n in\n let prev_challenges =\n Vector.map ~f:Ipa.Step.compute_challenges\n prev_statement.proof_state.messages_for_next_step_proof\n .old_bulletproof_challenges\n in\n let actual_proofs_verified =\n Vector.length prev_challenges\n in\n let lte =\n Nat.lte_exn actual_proofs_verified\n (Length.to_nat Max_local_max_proofs_verifieds.length)\n in\n let o =\n let sgs =\n let module M =\n H1.Map\n (P.Base.Messages_for_next_proof_over_same_field.Wrap\n .Prepared)\n (E01 (Tick.Curve.Affine))\n (struct\n let f :\n type n.\n n\n P.Base\n .Messages_for_next_proof_over_same_field\n .Wrap\n .Prepared\n .t\n -> _ =\n fun t -> t.challenge_polynomial_commitment\n end)\n in\n let module V = H1.To_vector (Tick.Curve.Affine) in\n V.f Max_local_max_proofs_verifieds.length\n (M.f prev_messages_for_next_wrap_proof)\n in\n O.create pairing_vk\n Vector.(\n map2 (Vector.trim_front sgs lte) prev_challenges\n ~f:(fun commitment cs ->\n { Tick.Proof.Challenge_polynomial.commitment\n ; challenges = Vector.to_array cs\n } )\n |> to_list)\n public_input proof\n in\n let x_hat = O.(p_eval_1 o, p_eval_2 o) in\n let step_vk, _ = Lazy.force step_vk in\n let next_statement : _ Types.Wrap.Statement.In_circuit.t =\n let scalar_chal f =\n Scalar_challenge.map ~f:Challenge.Constant.of_tick_field\n (f o)\n in\n let sponge_digest_before_evaluations =\n O.digest_before_evaluations o\n in\n let plonk0 =\n { Types.Wrap.Proof_state.Deferred_values.Plonk.Minimal\n .alpha = scalar_chal O.alpha\n ; beta = O.beta o\n ; gamma = O.gamma o\n ; zeta = scalar_chal O.zeta\n ; joint_combiner =\n Option.map (O.joint_combiner_chal o)\n ~f:\n (Scalar_challenge.map\n ~f:Challenge.Constant.of_tick_field )\n ; feature_flags = Plonk_types.Features.none_bool\n }\n in\n let r = scalar_chal O.u in\n let xi = scalar_chal O.v in\n let to_field =\n SC.to_field_constant\n (module Tick.Field)\n ~endo:Endo.Wrap_inner_curve.scalar\n in\n let module As_field = struct\n let r = to_field r\n\n let xi = to_field xi\n\n let zeta = to_field plonk0.zeta\n\n let alpha = to_field plonk0.alpha\n\n let joint_combiner =\n Option.map ~f:to_field plonk0.joint_combiner\n end in\n let domain =\n Domain.Pow_2_roots_of_unity\n step_vk.domain.log_size_of_group\n in\n let w = step_vk.domain.group_gen in\n (* Debug *)\n [%test_eq: Tick.Field.t] w\n (Tick.Field.domain_generator\n ~log2_size:(Domain.log2_size domain) ) ;\n let zetaw = Tick.Field.mul As_field.zeta w in\n let tick_plonk_minimal =\n { plonk0 with\n zeta = As_field.zeta\n ; alpha = As_field.alpha\n ; joint_combiner = As_field.joint_combiner\n }\n in\n let tick_combined_evals =\n Plonk_checks.evals_of_split_evals\n (module Tick.Field)\n proof.openings.evals\n ~rounds:(Nat.to_int Tick.Rounds.n) ~zeta:As_field.zeta\n ~zetaw\n in\n let tick_domain =\n Plonk_checks.domain\n (module Tick.Field)\n domain ~shifts:Common.tick_shifts\n ~domain_generator:Backend.Tick.Field.domain_generator\n in\n let tick_combined_evals =\n Plonk_types.Evals.to_in_circuit tick_combined_evals\n in\n let tick_env =\n let module Env_bool = struct\n type t = bool\n\n let true_ = true\n\n let false_ = false\n\n let ( &&& ) = ( && )\n\n let ( ||| ) = ( || )\n\n let any = List.exists ~f:Fn.id\n end in\n let module Env_field = struct\n include Tick.Field\n\n type bool = Env_bool.t\n\n let if_ (b : bool) ~then_ ~else_ =\n if b then then_ () else else_ ()\n end in\n Plonk_checks.scalars_env\n (module Env_bool)\n (module Env_field)\n ~endo:Endo.Step_inner_curve.base\n ~mds:Tick_field_sponge.params.mds\n ~srs_length_log2:Common.Max_degree.step_log2\n ~field_of_hex:(fun s ->\n Kimchi_pasta.Pasta.Bigint256.of_hex_string s\n |> Kimchi_pasta.Pasta.Fp.of_bigint )\n ~domain:tick_domain tick_plonk_minimal\n tick_combined_evals\n in\n let combined_inner_product =\n let open As_field in\n Wrap.combined_inner_product\n (* Note: We do not pad here. *)\n ~actual_proofs_verified:\n (Nat.Add.create actual_proofs_verified)\n { evals = proof.openings.evals; public_input = x_hat }\n ~r ~xi ~zeta ~zetaw\n ~old_bulletproof_challenges:prev_challenges\n ~env:tick_env ~domain:tick_domain\n ~ft_eval1:proof.openings.ft_eval1\n ~plonk:tick_plonk_minimal\n in\n let chal = Challenge.Constant.of_tick_field in\n let sg_new, new_bulletproof_challenges, b =\n let prechals =\n Array.map (O.opening_prechallenges o) ~f:(fun x ->\n let x =\n Scalar_challenge.map\n ~f:Challenge.Constant.of_tick_field x\n in\n x )\n in\n let chals =\n Array.map prechals ~f:(fun x ->\n Ipa.Step.compute_challenge x )\n in\n let challenge_polynomial =\n unstage (Wrap.challenge_polynomial chals)\n in\n let open As_field in\n let b =\n let open Tick.Field in\n challenge_polynomial zeta\n + (r * challenge_polynomial zetaw)\n in\n let overwritten_prechals =\n Array.map prechals\n ~f:\n (Scalar_challenge.map ~f:(fun _ ->\n Challenge.Constant.of_tick_field\n (Impls.Step.Field.Constant.of_int 100) ) )\n in\n let chals =\n Array.map overwritten_prechals ~f:(fun x ->\n Ipa.Step.compute_challenge x )\n in\n let sg_new =\n let urs = Backend.Tick.Keypair.load_urs () in\n Kimchi_bindings.Protocol.SRS.Fp\n .batch_accumulator_generate urs 1 chals\n in\n let[@warning \"-4\"] sg_new =\n match sg_new with\n | [| Kimchi_types.Finite x |] ->\n x\n | _ ->\n assert false\n in\n let overwritten_prechals =\n Array.map overwritten_prechals\n ~f:Bulletproof_challenge.unpack\n in\n\n (sg_new, overwritten_prechals, b)\n in\n let plonk =\n let module Field = struct\n include Tick.Field\n end in\n Wrap.Type1.derive_plonk\n (module Field)\n ~shift:Shifts.tick1 ~env:tick_env tick_plonk_minimal\n tick_combined_evals\n in\n let shift_value =\n Shifted_value.Type1.of_field\n (module Tick.Field)\n ~shift:Shifts.tick1\n in\n let branch_data : Composition_types.Branch_data.t =\n { proofs_verified =\n ( match actual_proofs_verified with\n | Z ->\n Composition_types.Branch_data.Proofs_verified.N0\n | S Z ->\n N1\n | S (S Z) ->\n N2\n | S _ ->\n assert false )\n ; domain_log2 =\n Composition_types.Branch_data.Domain_log2.of_int_exn\n step_vk.domain.log_size_of_group\n }\n in\n let messages_for_next_wrap_proof :\n _\n P.Base.Messages_for_next_proof_over_same_field.Wrap.t\n =\n { challenge_polynomial_commitment = sg_new\n ; old_bulletproof_challenges =\n Vector.map\n prev_statement.proof_state.unfinalized_proofs\n ~f:(fun t ->\n t.deferred_values.bulletproof_challenges )\n }\n in\n { proof_state =\n { deferred_values =\n { xi\n ; b = shift_value b\n ; bulletproof_challenges =\n Vector.of_array_and_length_exn\n new_bulletproof_challenges Tick.Rounds.n\n ; combined_inner_product =\n shift_value combined_inner_product\n ; branch_data\n ; plonk =\n { plonk with\n zeta = plonk0.zeta\n ; alpha = plonk0.alpha\n ; beta = chal plonk0.beta\n ; gamma = chal plonk0.gamma\n ; lookup = Plonk_types.Opt.None\n }\n }\n ; sponge_digest_before_evaluations =\n Digest.Constant.of_tick_field\n sponge_digest_before_evaluations\n ; messages_for_next_wrap_proof\n }\n ; messages_for_next_step_proof =\n prev_statement.proof_state\n .messages_for_next_step_proof\n }\n in\n let messages_for_next_wrap_proof_prepared =\n P.Base.Messages_for_next_proof_over_same_field.Wrap\n .prepare\n next_statement.proof_state.messages_for_next_wrap_proof\n in\n let%map.Promise next_proof =\n let (T (input, conv, _conv_inv)) = Impls.Wrap.input () in\n Common.time \"wrap proof\" (fun () ->\n Impls.Wrap.generate_witness_conv\n ~f:(fun { Impls.Wrap.Proof_inputs.auxiliary_inputs\n ; public_inputs\n } () ->\n Backend.Tock.Proof.create_async\n ~primary:public_inputs\n ~auxiliary:auxiliary_inputs pk\n ~message:\n ( Vector.map2\n (Vector.extend_front_exn\n prev_statement.proof_state\n .messages_for_next_step_proof\n .challenge_polynomial_commitments\n max_proofs_verified\n (Lazy.force Dummy.Ipa.Wrap.sg) )\n messages_for_next_wrap_proof_prepared\n .old_bulletproof_challenges\n ~f:(fun sg chals ->\n { Tock.Proof.Challenge_polynomial\n .commitment = sg\n ; challenges = Vector.to_array chals\n } )\n |> Wrap_hack.pad_accumulator ) )\n ~input_typ:input\n ~return_typ:(Snarky_backendless.Typ.unit ())\n (fun x () : unit -> wrap_main (conv x))\n { messages_for_next_step_proof =\n prev_statement_with_hashes.proof_state\n .messages_for_next_step_proof\n ; proof_state =\n { next_statement.proof_state with\n messages_for_next_wrap_proof =\n Wrap_hack.hash_messages_for_next_wrap_proof\n max_proofs_verified\n messages_for_next_wrap_proof_prepared\n ; deferred_values =\n { next_statement.proof_state.deferred_values with\n plonk =\n { next_statement.proof_state\n .deferred_values\n .plonk\n with\n lookup = None\n }\n }\n }\n } )\n in\n ( { proof = Wrap_wire_proof.of_kimchi_proof next_proof\n ; statement =\n Types.Wrap.Statement.to_minimal\n ~to_option:Plonk_types.Opt.to_option next_statement\n ; prev_evals =\n { Plonk_types.All_evals.evals =\n { public_input = x_hat\n ; evals = proof.openings.evals\n }\n ; ft_eval1 = proof.openings.ft_eval1\n }\n }\n : _ P.Base.Wrap.t )\n in\n wrap ~max_proofs_verified:Max_proofs_verified.n\n full_signature.maxes ~dlog_plonk_index:wrap_vk.commitments\n wrap_main A_value.to_field_elements ~pairing_vk\n ~step_domains:b.domains\n ~pairing_plonk_indices:(Lazy.force step_vks) ~wrap_domains\n (Impls.Wrap.Keypair.pk (fst (Lazy.force wrap_pk)))\n proof\n in\n Proof.T\n { proof with\n statement =\n { proof.statement with\n messages_for_next_step_proof =\n { proof.statement.messages_for_next_step_proof with\n app_state = ()\n }\n }\n }\n in\n wrap\n in\n f step_data step_keypair\n in\n let data : _ Types_map.Compiled.t =\n { branches = Branches.n\n ; feature_flags\n ; proofs_verifieds\n ; max_proofs_verified = (module Max_proofs_verified)\n ; public_input = typ\n ; wrap_key = Lazy.map wrap_vk ~f:Verification_key.commitments\n ; wrap_vk = Lazy.map wrap_vk ~f:Verification_key.index\n ; wrap_domains\n ; step_domains\n }\n in\n Types_map.add_exn self data ;\n (prover, wrap_vk, disk_key)\n end\n\n let step, wrap_vk, wrap_disk_key = M.compile\n\n module Proof = struct\n module Max_local_max_proofs_verified = Max_proofs_verified\n include Proof.Make (Max_proofs_verified) (Max_local_max_proofs_verified)\n\n let _id = wrap_disk_key\n\n let verification_key = wrap_vk\n\n let verify ts =\n verify_promise\n (module Max_proofs_verified)\n (module A_value)\n (Lazy.force verification_key)\n ts\n\n let _statement (T p : t) =\n p.statement.messages_for_next_step_proof.app_state\n end\n\n let proof_with_stmt =\n let p = Promise.block_on_async_exn (fun () -> step ()) in\n ((), p)\n\n let%test \"should not be able to verify invalid proof\" =\n Or_error.is_error\n @@ Promise.block_on_async_exn (fun () ->\n Proof.verify [ proof_with_stmt ] )\n\n module Recurse_on_bad_proof = struct\n open Impls.Step\n\n let _dummy_proof =\n Proof0.dummy Nat.N2.n Nat.N2.n Nat.N2.n ~domain_log2:15\n\n type _ Snarky_backendless.Request.t +=\n | Proof : (Nat.N2.n, Nat.N2.n) Proof0.t Snarky_backendless.Request.t\n\n let handler (proof : _ Proof0.t)\n (Snarky_backendless.Request.With { request; respond }) =\n match request with\n | Proof ->\n respond (Provide proof)\n | _ ->\n respond Unhandled\n\n let[@warning \"-45\"] _tag, _, p, Provers.[ step ] =\n Common.time \"compile\" (fun () ->\n compile_promise () ~public_input:(Input Typ.unit)\n ~auxiliary_typ:Typ.unit\n ~branches:(module Nat.N1)\n ~max_proofs_verified:(module Nat.N2)\n ~name:\"recurse-on-bad\" ~constraint_constants\n ~choices:(fun ~self:_ ->\n [ { identifier = \"main\"\n ; feature_flags = Plonk_types.Features.none_bool\n ; prevs = [ tag; tag ]\n ; main =\n (fun { public_input = () } ->\n let proof =\n exists (Typ.Internal.ref ()) ~request:(fun () ->\n Proof )\n in\n { previous_proof_statements =\n [ { public_input = ()\n ; proof\n ; proof_must_verify = Boolean.true_\n }\n ; { public_input = ()\n ; proof\n ; proof_must_verify = Boolean.true_\n }\n ]\n ; public_output = ()\n ; auxiliary_output = ()\n } )\n }\n ] ) )\n\n module Proof = (val p)\n end\n\n let%test \"should not be able to create a recursive proof from an invalid \\\n proof\" =\n try\n let (), (), proof =\n Promise.block_on_async_exn (fun () ->\n Recurse_on_bad_proof.step\n ~handler:(Recurse_on_bad_proof.handler (snd proof_with_stmt))\n () )\n in\n Or_error.is_error\n @@ Promise.block_on_async_exn (fun () ->\n Recurse_on_bad_proof.Proof.verify_promise [ ((), proof) ] )\n with _ -> true\n end )\n\n let%test_module \"adversarial_tests\" =\n ( module struct\n [@@@warning \"-60\"]\n\n let () = Backtrace.elide := false\n\n let () = Snarky_backendless.Snark0.set_eval_constraints true\n\n let%test_module \"test domain size too large\" =\n ( module Compile.Make_adversarial_test (struct\n let tweak_statement (stmt : _ Import.Types.Wrap.Statement.In_circuit.t)\n =\n (* Modify the statement to use an invalid domain size. *)\n { stmt with\n proof_state =\n { stmt.proof_state with\n deferred_values =\n { stmt.proof_state.deferred_values with\n branch_data =\n { stmt.proof_state.deferred_values.branch_data with\n Branch_data.domain_log2 =\n Branch_data.Domain_log2.of_int_exn\n (Nat.to_int Kimchi_pasta.Basic.Rounds.Step.n + 1)\n }\n }\n }\n }\n\n let check_verifier_error err =\n (* Convert to JSON to make it easy to parse. *)\n err |> Error_json.error_to_yojson\n |> Yojson.Safe.Util.member \"multiple\"\n |> Yojson.Safe.Util.to_list\n |> List.find_exn ~f:(fun json ->\n let error =\n json\n |> Yojson.Safe.Util.member \"string\"\n |> Yojson.Safe.Util.to_string\n in\n String.equal error \"domain size is small enough\" )\n |> fun _ -> ()\n end) )\n end )\n\n let%test_module \"domain too small\" =\n ( module struct\n open Impls.Step\n\n (* Currently, a circuit must have at least 1 of every type of constraint. *)\n let dummy_constraints () =\n Impl.(\n let x =\n exists Field.typ ~compute:(fun () -> Field.Constant.of_int 3)\n in\n let g =\n exists Step_main_inputs.Inner_curve.typ ~compute:(fun _ ->\n Tick.Inner_curve.(to_affine_exn one) )\n in\n ignore\n ( SC.to_field_checked'\n (module Impl)\n ~num_bits:16\n (Kimchi_backend_common.Scalar_challenge.create x)\n : Field.t * Field.t * Field.t ) ;\n ignore\n ( Step_main_inputs.Ops.scale_fast g ~num_bits:5 (Shifted_value x)\n : Step_main_inputs.Inner_curve.t ) ;\n ignore\n ( Step_main_inputs.Ops.scale_fast g ~num_bits:5 (Shifted_value x)\n : Step_main_inputs.Inner_curve.t ) ;\n ignore\n ( Step_verifier.Scalar_challenge.endo g ~num_bits:4\n (Kimchi_backend_common.Scalar_challenge.create x)\n : Field.t * Field.t ))\n\n module No_recursion = struct\n let[@warning \"-45\"] tag, _, p, Provers.[ step ] =\n Common.time \"compile\" (fun () ->\n compile_promise () ~public_input:(Input Field.typ)\n ~auxiliary_typ:Typ.unit\n ~branches:(module Nat.N1)\n ~max_proofs_verified:(module Nat.N0)\n ~name:\"blockchain-snark\"\n ~constraint_constants:\n (* Dummy values *)\n { sub_windows_per_window = 0\n ; ledger_depth = 0\n ; work_delay = 0\n ; block_window_duration_ms = 0\n ; transaction_capacity = Log_2 0\n ; pending_coinbase_depth = 0\n ; coinbase_amount = Unsigned.UInt64.of_int 0\n ; supercharged_coinbase_factor = 0\n ; account_creation_fee = Unsigned.UInt64.of_int 0\n ; fork = None\n }\n ~choices:(fun ~self:_ ->\n [ { identifier = \"main\"\n ; prevs = []\n ; feature_flags = Plonk_types.Features.none_bool\n ; main =\n (fun { public_input = self } ->\n dummy_constraints () ;\n Field.Assert.equal self Field.zero ;\n { previous_proof_statements = []\n ; public_output = ()\n ; auxiliary_output = ()\n } )\n }\n ] ) )\n\n module Proof = (val p)\n\n let example =\n let (), (), b0 =\n Common.time \"b0\" (fun () ->\n Promise.block_on_async_exn (fun () -> step Field.Constant.zero) )\n in\n Or_error.ok_exn\n (Promise.block_on_async_exn (fun () ->\n Proof.verify_promise [ (Field.Constant.zero, b0) ] ) ) ;\n (Field.Constant.zero, b0)\n\n let example_input, example_proof = example\n end\n\n module Fake_1_recursion = struct\n let[@warning \"-45\"] tag, _, p, Provers.[ step ] =\n Common.time \"compile\" (fun () ->\n compile_promise () ~public_input:(Input Field.typ)\n ~auxiliary_typ:Typ.unit\n ~branches:(module Nat.N1)\n ~max_proofs_verified:(module Nat.N1)\n ~name:\"blockchain-snark\"\n ~constraint_constants:\n (* Dummy values *)\n { sub_windows_per_window = 0\n ; ledger_depth = 0\n ; work_delay = 0\n ; block_window_duration_ms = 0\n ; transaction_capacity = Log_2 0\n ; pending_coinbase_depth = 0\n ; coinbase_amount = Unsigned.UInt64.of_int 0\n ; supercharged_coinbase_factor = 0\n ; account_creation_fee = Unsigned.UInt64.of_int 0\n ; fork = None\n }\n ~choices:(fun ~self:_ ->\n [ { identifier = \"main\"\n ; prevs = []\n ; feature_flags = Plonk_types.Features.none_bool\n ; main =\n (fun { public_input = self } ->\n dummy_constraints () ;\n Field.Assert.equal self Field.zero ;\n { previous_proof_statements = []\n ; public_output = ()\n ; auxiliary_output = ()\n } )\n }\n ] ) )\n\n module Proof = (val p)\n\n let example =\n let (), (), b0 =\n Common.time \"b0\" (fun () ->\n Promise.block_on_async_exn (fun () -> step Field.Constant.zero) )\n in\n Or_error.ok_exn\n (Promise.block_on_async_exn (fun () ->\n Proof.verify_promise [ (Field.Constant.zero, b0) ] ) ) ;\n (Field.Constant.zero, b0)\n\n let example_input, example_proof = example\n end\n\n module Fake_2_recursion = struct\n let[@warning \"-45\"] tag, _, p, Provers.[ step ] =\n Common.time \"compile\" (fun () ->\n compile_promise () ~public_input:(Input Field.typ)\n ~override_wrap_domain:Pickles_base.Proofs_verified.N1\n ~auxiliary_typ:Typ.unit\n ~branches:(module Nat.N1)\n ~max_proofs_verified:(module Nat.N2)\n ~name:\"blockchain-snark\"\n ~constraint_constants:\n (* Dummy values *)\n { sub_windows_per_window = 0\n ; ledger_depth = 0\n ; work_delay = 0\n ; block_window_duration_ms = 0\n ; transaction_capacity = Log_2 0\n ; pending_coinbase_depth = 0\n ; coinbase_amount = Unsigned.UInt64.of_int 0\n ; supercharged_coinbase_factor = 0\n ; account_creation_fee = Unsigned.UInt64.of_int 0\n ; fork = None\n }\n ~choices:(fun ~self:_ ->\n [ { identifier = \"main\"\n ; prevs = []\n ; feature_flags = Plonk_types.Features.none_bool\n ; main =\n (fun { public_input = self } ->\n dummy_constraints () ;\n Field.Assert.equal self Field.zero ;\n { previous_proof_statements = []\n ; public_output = ()\n ; auxiliary_output = ()\n } )\n }\n ] ) )\n\n module Proof = (val p)\n\n let example =\n let (), (), b0 =\n Common.time \"b0\" (fun () ->\n Promise.block_on_async_exn (fun () -> step Field.Constant.zero) )\n in\n Or_error.ok_exn\n (Promise.block_on_async_exn (fun () ->\n Proof.verify_promise [ (Field.Constant.zero, b0) ] ) ) ;\n (Field.Constant.zero, b0)\n\n let example_input, example_proof = example\n end\n\n [@@@warning \"-60\"]\n\n module Simple_chain = struct\n type _ Snarky_backendless.Request.t +=\n | Prev_input : Field.Constant.t Snarky_backendless.Request.t\n | Proof : Side_loaded.Proof.t Snarky_backendless.Request.t\n | Verifier_index :\n Side_loaded.Verification_key.t Snarky_backendless.Request.t\n\n let handler (prev_input : Field.Constant.t) (proof : _ Proof.t)\n (verifier_index : Side_loaded.Verification_key.t)\n (Snarky_backendless.Request.With { request; respond }) =\n match request with\n | Prev_input ->\n respond (Provide prev_input)\n | Proof ->\n respond (Provide proof)\n | Verifier_index ->\n respond (Provide verifier_index)\n | _ ->\n respond Unhandled\n\n let side_loaded_tag =\n Side_loaded.create ~name:\"foo\"\n ~max_proofs_verified:(Nat.Add.create Nat.N2.n)\n ~feature_flags:Plonk_types.Features.none ~typ:Field.typ\n\n let[@warning \"-45\"] _tag, _, p, Provers.[ step ] =\n Common.time \"compile\" (fun () ->\n compile_promise () ~public_input:(Input Field.typ)\n ~auxiliary_typ:Typ.unit\n ~branches:(module Nat.N1)\n ~max_proofs_verified:(module Nat.N1)\n ~name:\"blockchain-snark\"\n ~constraint_constants:\n (* Dummy values *)\n { sub_windows_per_window = 0\n ; ledger_depth = 0\n ; work_delay = 0\n ; block_window_duration_ms = 0\n ; transaction_capacity = Log_2 0\n ; pending_coinbase_depth = 0\n ; coinbase_amount = Unsigned.UInt64.of_int 0\n ; supercharged_coinbase_factor = 0\n ; account_creation_fee = Unsigned.UInt64.of_int 0\n ; fork = None\n }\n ~choices:(fun ~self:_ ->\n [ { identifier = \"main\"\n ; prevs = [ side_loaded_tag ]\n ; feature_flags = Plonk_types.Features.none_bool\n ; main =\n (fun { public_input = self } ->\n let prev =\n exists Field.typ ~request:(fun () -> Prev_input)\n in\n let proof =\n exists (Typ.Internal.ref ()) ~request:(fun () ->\n Proof )\n in\n let vk =\n exists (Typ.Internal.ref ()) ~request:(fun () ->\n Verifier_index )\n in\n as_prover (fun () ->\n let vk = As_prover.Ref.get vk in\n Side_loaded.in_prover side_loaded_tag vk ) ;\n let vk =\n exists Side_loaded_verification_key.typ\n ~compute:(fun () -> As_prover.Ref.get vk)\n in\n Side_loaded.in_circuit side_loaded_tag vk ;\n let is_base_case = Field.equal Field.zero self in\n let self_correct = Field.(equal (one + prev) self) in\n Boolean.Assert.any [ self_correct; is_base_case ] ;\n { previous_proof_statements =\n [ { public_input = prev\n ; proof\n ; proof_must_verify = Boolean.true_\n }\n ]\n ; public_output = ()\n ; auxiliary_output = ()\n } )\n }\n ] ) )\n\n module Proof = (val p)\n\n let _example1 =\n let (), (), b1 =\n Common.time \"b1\" (fun () ->\n Promise.block_on_async_exn (fun () ->\n step\n ~handler:\n (handler No_recursion.example_input\n (Side_loaded.Proof.of_proof\n No_recursion.example_proof )\n (Side_loaded.Verification_key.of_compiled\n No_recursion.tag ) )\n Field.Constant.one ) )\n in\n Or_error.ok_exn\n (Promise.block_on_async_exn (fun () ->\n Proof.verify_promise [ (Field.Constant.one, b1) ] ) ) ;\n (Field.Constant.one, b1)\n\n let _example2 =\n let (), (), b2 =\n Common.time \"b2\" (fun () ->\n Promise.block_on_async_exn (fun () ->\n step\n ~handler:\n (handler Fake_1_recursion.example_input\n (Side_loaded.Proof.of_proof\n Fake_1_recursion.example_proof )\n (Side_loaded.Verification_key.of_compiled\n Fake_1_recursion.tag ) )\n Field.Constant.one ) )\n in\n Or_error.ok_exn\n (Promise.block_on_async_exn (fun () ->\n Proof.verify_promise [ (Field.Constant.one, b2) ] ) ) ;\n (Field.Constant.one, b2)\n\n let _example3 =\n let (), (), b3 =\n Common.time \"b3\" (fun () ->\n Promise.block_on_async_exn (fun () ->\n step\n ~handler:\n (handler Fake_2_recursion.example_input\n (Side_loaded.Proof.of_proof\n Fake_2_recursion.example_proof )\n (Side_loaded.Verification_key.of_compiled\n Fake_2_recursion.tag ) )\n Field.Constant.one ) )\n in\n Or_error.ok_exn\n (Promise.block_on_async_exn (fun () ->\n Proof.verify_promise [ (Field.Constant.one, b3) ] ) ) ;\n (Field.Constant.one, b3)\n end\n end )\n\n let%test_module \"side-loaded with feature flags\" =\n ( module struct\n open Impls.Step\n\n [@@@warning \"-60\"]\n\n module Statement = struct\n [@@@warning \"-32-34\"]\n\n type t = Field.t\n\n let to_field_elements x = [| x |]\n\n module Constant = struct\n type t = Field.Constant.t [@@deriving bin_io]\n\n [@@@warning \"-32\"]\n\n let to_field_elements x = [| x |]\n end\n end\n\n (* Currently, a circuit must have at least 1 of every type of constraint. *)\n let dummy_constraints () =\n Impl.(\n let x =\n exists Field.typ ~compute:(fun () -> Field.Constant.of_int 3)\n in\n let g =\n exists Step_main_inputs.Inner_curve.typ ~compute:(fun _ ->\n Tick.Inner_curve.(to_affine_exn one) )\n in\n ignore\n ( SC.to_field_checked'\n (module Impl)\n ~num_bits:16\n (Kimchi_backend_common.Scalar_challenge.create x)\n : Field.t * Field.t * Field.t ) ;\n ignore\n ( Step_main_inputs.Ops.scale_fast g ~num_bits:5 (Shifted_value x)\n : Step_main_inputs.Inner_curve.t ) ;\n ignore\n ( Step_main_inputs.Ops.scale_fast g ~num_bits:5 (Shifted_value x)\n : Step_main_inputs.Inner_curve.t ) ;\n ignore\n ( Step_verifier.Scalar_challenge.endo g ~num_bits:4\n (Kimchi_backend_common.Scalar_challenge.create x)\n : Field.t * Field.t ))\n\n module No_recursion = struct\n let[@warning \"-45\"] tag, _, p, Provers.[ step ] =\n Common.time \"compile\" (fun () ->\n compile_promise () ~public_input:(Input Field.typ)\n ~auxiliary_typ:Typ.unit\n ~branches:(module Nat.N1)\n ~max_proofs_verified:(module Nat.N0)\n ~name:\"blockchain-snark\"\n ~constraint_constants:\n (* Dummy values *)\n { sub_windows_per_window = 0\n ; ledger_depth = 0\n ; work_delay = 0\n ; block_window_duration_ms = 0\n ; transaction_capacity = Log_2 0\n ; pending_coinbase_depth = 0\n ; coinbase_amount = Unsigned.UInt64.of_int 0\n ; supercharged_coinbase_factor = 0\n ; account_creation_fee = Unsigned.UInt64.of_int 0\n ; fork = None\n }\n ~choices:(fun ~self:_ ->\n [ { identifier = \"main\"\n ; prevs = []\n ; feature_flags = Plonk_types.Features.none_bool\n ; main =\n (fun { public_input = self } ->\n dummy_constraints () ;\n Field.Assert.equal self Field.zero ;\n { previous_proof_statements = []\n ; public_output = ()\n ; auxiliary_output = ()\n } )\n }\n ] ) )\n\n module Proof = (val p)\n\n let example =\n let (), (), b0 =\n Common.time \"b0\" (fun () ->\n Promise.block_on_async_exn (fun () -> step Field.Constant.zero) )\n in\n Or_error.ok_exn\n (Promise.block_on_async_exn (fun () ->\n Proof.verify_promise [ (Field.Constant.zero, b0) ] ) ) ;\n (Field.Constant.zero, b0)\n\n let example_input, example_proof = example\n end\n\n module Fake_1_recursion = struct\n let[@warning \"-45\"] tag, _, p, Provers.[ step ] =\n Common.time \"compile\" (fun () ->\n compile_promise () ~public_input:(Input Field.typ)\n ~auxiliary_typ:Typ.unit\n ~branches:(module Nat.N1)\n ~max_proofs_verified:(module Nat.N1)\n ~name:\"blockchain-snark\"\n ~constraint_constants:\n (* Dummy values *)\n { sub_windows_per_window = 0\n ; ledger_depth = 0\n ; work_delay = 0\n ; block_window_duration_ms = 0\n ; transaction_capacity = Log_2 0\n ; pending_coinbase_depth = 0\n ; coinbase_amount = Unsigned.UInt64.of_int 0\n ; supercharged_coinbase_factor = 0\n ; account_creation_fee = Unsigned.UInt64.of_int 0\n ; fork = None\n }\n ~choices:(fun ~self:_ ->\n [ { identifier = \"main\"\n ; prevs = []\n ; feature_flags = Plonk_types.Features.none_bool\n ; main =\n (fun { public_input = self } ->\n dummy_constraints () ;\n Field.Assert.equal self Field.zero ;\n { previous_proof_statements = []\n ; public_output = ()\n ; auxiliary_output = ()\n } )\n }\n ] ) )\n\n module Proof = (val p)\n\n let example =\n let (), (), b0 =\n Common.time \"b0\" (fun () ->\n Promise.block_on_async_exn (fun () -> step Field.Constant.zero) )\n in\n Or_error.ok_exn\n (Promise.block_on_async_exn (fun () ->\n Proof.verify_promise [ (Field.Constant.zero, b0) ] ) ) ;\n (Field.Constant.zero, b0)\n\n let example_input, example_proof = example\n end\n\n module Fake_2_recursion = struct\n let[@warning \"-45\"] tag, _, p, Provers.[ step ] =\n Common.time \"compile\" (fun () ->\n compile_promise () ~public_input:(Input Field.typ)\n ~override_wrap_domain:Pickles_base.Proofs_verified.N1\n ~auxiliary_typ:Typ.unit\n ~branches:(module Nat.N1)\n ~max_proofs_verified:(module Nat.N2)\n ~name:\"blockchain-snark\"\n ~constraint_constants:\n (* Dummy values *)\n { sub_windows_per_window = 0\n ; ledger_depth = 0\n ; work_delay = 0\n ; block_window_duration_ms = 0\n ; transaction_capacity = Log_2 0\n ; pending_coinbase_depth = 0\n ; coinbase_amount = Unsigned.UInt64.of_int 0\n ; supercharged_coinbase_factor = 0\n ; account_creation_fee = Unsigned.UInt64.of_int 0\n ; fork = None\n }\n ~choices:(fun ~self:_ ->\n [ { identifier = \"main\"\n ; prevs = []\n ; feature_flags = Plonk_types.Features.none_bool\n ; main =\n (fun { public_input = self } ->\n dummy_constraints () ;\n Field.Assert.equal self Field.zero ;\n { previous_proof_statements = []\n ; public_output = ()\n ; auxiliary_output = ()\n } )\n }\n ] ) )\n\n module Proof = (val p)\n\n let example =\n let (), (), b0 =\n Common.time \"b0\" (fun () ->\n Promise.block_on_async_exn (fun () -> step Field.Constant.zero) )\n in\n Or_error.ok_exn\n (Promise.block_on_async_exn (fun () ->\n Proof.verify_promise [ (Field.Constant.zero, b0) ] ) ) ;\n (Field.Constant.zero, b0)\n\n let example_input, example_proof = example\n end\n\n [@@@warning \"-60\"]\n\n module Simple_chain = struct\n type _ Snarky_backendless.Request.t +=\n | Prev_input : Field.Constant.t Snarky_backendless.Request.t\n | Proof : Side_loaded.Proof.t Snarky_backendless.Request.t\n | Verifier_index :\n Side_loaded.Verification_key.t Snarky_backendless.Request.t\n\n let handler (prev_input : Field.Constant.t) (proof : _ Proof.t)\n (verifier_index : Side_loaded.Verification_key.t)\n (Snarky_backendless.Request.With { request; respond }) =\n match request with\n | Prev_input ->\n respond (Provide prev_input)\n | Proof ->\n respond (Provide proof)\n | Verifier_index ->\n respond (Provide verifier_index)\n | _ ->\n respond Unhandled\n\n let maybe_features =\n Plonk_types.Features.(\n map none ~f:(fun _ -> Plonk_types.Opt.Flag.Maybe))\n\n let side_loaded_tag =\n Side_loaded.create ~name:\"foo\"\n ~max_proofs_verified:(Nat.Add.create Nat.N2.n)\n ~feature_flags:maybe_features ~typ:Field.typ\n\n let[@warning \"-45\"] _tag, _, p, Provers.[ step ] =\n Common.time \"compile\" (fun () ->\n compile_promise () ~public_input:(Input Field.typ)\n ~auxiliary_typ:Typ.unit\n ~branches:(module Nat.N1)\n ~max_proofs_verified:(module Nat.N1)\n ~name:\"blockchain-snark\"\n ~constraint_constants:\n (* Dummy values *)\n { sub_windows_per_window = 0\n ; ledger_depth = 0\n ; work_delay = 0\n ; block_window_duration_ms = 0\n ; transaction_capacity = Log_2 0\n ; pending_coinbase_depth = 0\n ; coinbase_amount = Unsigned.UInt64.of_int 0\n ; supercharged_coinbase_factor = 0\n ; account_creation_fee = Unsigned.UInt64.of_int 0\n ; fork = None\n }\n ~choices:(fun ~self:_ ->\n [ { identifier = \"main\"\n ; prevs = [ side_loaded_tag ]\n ; feature_flags = Plonk_types.Features.none_bool\n ; main =\n (fun { public_input = self } ->\n let prev =\n exists Field.typ ~request:(fun () -> Prev_input)\n in\n let proof =\n exists (Typ.Internal.ref ()) ~request:(fun () ->\n Proof )\n in\n let vk =\n exists (Typ.Internal.ref ()) ~request:(fun () ->\n Verifier_index )\n in\n as_prover (fun () ->\n let vk = As_prover.Ref.get vk in\n Side_loaded.in_prover side_loaded_tag vk ) ;\n let vk =\n exists Side_loaded_verification_key.typ\n ~compute:(fun () -> As_prover.Ref.get vk)\n in\n Side_loaded.in_circuit side_loaded_tag vk ;\n let is_base_case = Field.equal Field.zero self in\n let self_correct = Field.(equal (one + prev) self) in\n Boolean.Assert.any [ self_correct; is_base_case ] ;\n { previous_proof_statements =\n [ { public_input = prev\n ; proof\n ; proof_must_verify = Boolean.true_\n }\n ]\n ; public_output = ()\n ; auxiliary_output = ()\n } )\n }\n ] ) )\n\n module Proof = (val p)\n\n let _example1 =\n let (), (), b1 =\n Common.time \"b1\" (fun () ->\n Promise.block_on_async_exn (fun () ->\n step\n ~handler:\n (handler No_recursion.example_input\n (Side_loaded.Proof.of_proof\n No_recursion.example_proof )\n (Side_loaded.Verification_key.of_compiled\n No_recursion.tag ) )\n Field.Constant.one ) )\n in\n Or_error.ok_exn\n (Promise.block_on_async_exn (fun () ->\n Proof.verify_promise [ (Field.Constant.one, b1) ] ) ) ;\n (Field.Constant.one, b1)\n\n let _example2 =\n let (), (), b2 =\n Common.time \"b2\" (fun () ->\n Promise.block_on_async_exn (fun () ->\n step\n ~handler:\n (handler Fake_1_recursion.example_input\n (Side_loaded.Proof.of_proof\n Fake_1_recursion.example_proof )\n (Side_loaded.Verification_key.of_compiled\n Fake_1_recursion.tag ) )\n Field.Constant.one ) )\n in\n Or_error.ok_exn\n (Promise.block_on_async_exn (fun () ->\n Proof.verify_promise [ (Field.Constant.one, b2) ] ) ) ;\n (Field.Constant.one, b2)\n\n let _example3 =\n let (), (), b3 =\n Common.time \"b3\" (fun () ->\n Promise.block_on_async_exn (fun () ->\n step\n ~handler:\n (handler Fake_2_recursion.example_input\n (Side_loaded.Proof.of_proof\n Fake_2_recursion.example_proof )\n (Side_loaded.Verification_key.of_compiled\n Fake_2_recursion.tag ) )\n Field.Constant.one ) )\n in\n Or_error.ok_exn\n (Promise.block_on_async_exn (fun () ->\n Proof.verify_promise [ (Field.Constant.one, b3) ] ) ) ;\n (Field.Constant.one, b3)\n end\n end )\nend\n\ninclude Wire_types.Make (Make_sig) (Make_str)\n","open Core_kernel\nmodule H_list = Snarky_backendless.H_list\n\n[%%versioned\nmodule Stable = struct\n module V2 = struct\n type 'comm t =\n { sigma_comm : 'comm Plonk_types.Permuts_vec.Stable.V1.t\n ; coefficients_comm : 'comm Plonk_types.Columns_vec.Stable.V1.t\n ; generic_comm : 'comm\n ; psm_comm : 'comm\n ; complete_add_comm : 'comm\n ; mul_comm : 'comm\n ; emul_comm : 'comm\n ; endomul_scalar_comm : 'comm\n }\n [@@deriving sexp, equal, compare, hash, yojson, hlist, fields]\n (* TODO: Remove unused annotations *)\n end\nend]\n\n(* TODO: Remove unused functions *)\n\nlet map\n { sigma_comm\n ; coefficients_comm\n ; generic_comm\n ; psm_comm\n ; complete_add_comm\n ; mul_comm\n ; emul_comm\n ; endomul_scalar_comm\n } ~f =\n { sigma_comm = Vector.map ~f sigma_comm\n ; coefficients_comm = Vector.map ~f coefficients_comm\n ; generic_comm = f generic_comm\n ; psm_comm = f psm_comm\n ; complete_add_comm = f complete_add_comm\n ; mul_comm = f mul_comm\n ; emul_comm = f emul_comm\n ; endomul_scalar_comm = f endomul_scalar_comm\n }\n\nlet map2 t1 t2 ~f =\n { sigma_comm = Vector.map2 ~f t1.sigma_comm t2.sigma_comm\n ; coefficients_comm = Vector.map2 ~f t1.coefficients_comm t2.coefficients_comm\n ; generic_comm = f t1.generic_comm t2.generic_comm\n ; psm_comm = f t1.psm_comm t2.psm_comm\n ; complete_add_comm = f t1.complete_add_comm t2.complete_add_comm\n ; mul_comm = f t1.mul_comm t2.mul_comm\n ; emul_comm = f t1.emul_comm t2.emul_comm\n ; endomul_scalar_comm = f t1.endomul_scalar_comm t2.endomul_scalar_comm\n }\n\nlet typ g =\n Snarky_backendless.Typ.of_hlistable\n [ Vector.typ g Plonk_types.Permuts.n\n ; Vector.typ g Plonk_types.Columns.n\n ; g\n ; g\n ; g\n ; g\n ; g\n ; g\n ]\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist\n","open Core_kernel\n\ntype ('a, 'n, 'm) t =\n { without_degree_bound : 'n Nat.t; with_degree_bound : ('a, 'm) Vector.t }\n\nlet map t ~f = { t with with_degree_bound = Vector.map t.with_degree_bound ~f }\n\nlet num_bits n = Int.floor_log2 n + 1\n\nlet%test_unit \"num_bits\" =\n let naive n =\n let rec go k =\n (* [Invalid_argument] represents an overflow, which is certainly bigger\n than any given value.\n *)\n let n_lt_2k = try n < Int.pow 2 k with Invalid_argument _ -> true in\n if n_lt_2k then k else go (k + 1)\n in\n go 0\n in\n Quickcheck.test (Int.gen_uniform_incl 0 Int.max_value) ~f:(fun n ->\n [%test_eq: int] (num_bits n) (naive n) )\n\nlet pow ~one ~mul x n =\n assert (n >= 0) ;\n let k = num_bits n in\n let rec go acc i =\n if i < 0 then acc\n else\n let acc = mul acc acc in\n let b = (n lsr i) land 1 = 1 in\n let acc = if b then mul x acc else acc in\n go acc (i - 1)\n in\n go one (k - 1)\n\nlet create ~without_degree_bound ~with_degree_bound =\n { without_degree_bound; with_degree_bound }\n\nlet combine_commitments _t ~scale ~add ~xi (type n)\n (without_degree_bound : (_, n) Vector.t) with_degree_bound =\n match without_degree_bound with\n | [] ->\n failwith \"combine_commitments: empty list\"\n | init :: without_degree_bound ->\n let polys =\n Vector.to_list without_degree_bound\n @ List.concat_map (Vector.to_list with_degree_bound)\n ~f:(fun (unshifted, shifted) -> [ unshifted; shifted ])\n in\n List.fold_left polys ~init ~f:(fun acc p -> add p (scale acc xi))\n\nlet combine_evaluations' (type a n m)\n ({ without_degree_bound = _; with_degree_bound } : (a, n Nat.s, m) t)\n ~shifted_pow ~mul ~add ~one:_ ~evaluation_point ~xi\n (init :: evals0 : (_, n Nat.s) Vector.t) (evals1 : (_, m) Vector.t) =\n let evals =\n Vector.to_list evals0\n @ List.concat\n (Vector.to_list\n (Vector.map2 with_degree_bound evals1 ~f:(fun deg fx ->\n [ fx; mul (shifted_pow deg evaluation_point) fx ] ) ) )\n in\n List.fold_left evals ~init ~f:(fun acc fx -> add fx (mul acc xi))\n\nlet[@warning \"-45\"] combine_evaluations' (type n) (t : (_, n, _) t) ~shifted_pow\n ~mul ~add ~one ~evaluation_point ~xi (evals0 : (_, n) Vector.t) evals1 =\n match evals0 with\n | Vector.[] ->\n failwith \"Empty evals0\"\n | _ :: _ ->\n combine_evaluations' t ~shifted_pow ~mul ~add ~one ~evaluation_point ~xi\n evals0 evals1\n\nlet combine_evaluations (type f) t ~crs_max_degree ~(mul : f -> f -> f) ~add\n ~one ~evaluation_point ~xi evals0 evals1 =\n let pow = pow ~one ~mul in\n combine_evaluations' t evals0 evals1\n ~shifted_pow:(fun deg x -> pow x (crs_max_degree - deg))\n ~mul ~add ~one ~evaluation_point ~xi\n\nopen Plonk_types.Poly_comm\n\nlet combine_split_commitments _t ~scale_and_add ~init:i ~xi (type n)\n (without_degree_bound : (_, n) Vector.t) with_degree_bound =\n let flat =\n List.concat_map (Vector.to_list without_degree_bound) ~f:Array.to_list\n @ List.concat_map (Vector.to_list with_degree_bound)\n ~f:(fun { With_degree_bound.unshifted; shifted } ->\n Array.to_list unshifted @ [ shifted ] )\n in\n match List.rev flat with\n | [] ->\n failwith \"combine_split_commitments: empty\"\n | init :: comms ->\n List.fold_left comms ~init:(i init) ~f:(fun acc p ->\n scale_and_add ~acc ~xi p )\n\nlet combine_split_evaluations (type f f')\n ~(mul_and_add : acc:f' -> xi:f' -> f -> f') ~init:(i : f -> f') ~(xi : f')\n (evals0 : f array list) : f' =\n let flat = List.concat_map evals0 ~f:Array.to_list in\n match List.rev flat with\n | [] ->\n failwith \"combine_split_evaluations: empty\"\n | init :: es ->\n List.fold_left es ~init:(i init) ~f:(fun acc fx ->\n mul_and_add ~acc ~xi fx )\n","open Core_kernel\nmodule Intf = Intf\n\nmodule Params = struct\n include Params\n\n let bn128 = Constants.params_Bn128\n\n let mnt4_298 = Constants.params_Mnt4_298\n\n let mnt4_753 = Constants.params_Mnt4_753\n\n let bn382_p = Constants.params_Bn382_p\n\n let bn382_q = Constants.params_Bn382_q\n\n let tweedle_p = Constants.params_Tweedle_p\n\n let tweedle_q = Constants.params_Tweedle_q\n\n let pasta_p_legacy = Constants.params_Pasta_p_legacy\n\n let pasta_q_legacy = Constants.params_Pasta_q_legacy\n\n let pasta_p_kimchi = Constants.params_Pasta_p_kimchi\n\n let pasta_q_kimchi = Constants.params_Pasta_q_kimchi\nend\n\nmodule State = Array\n\nlet for_ n ~init ~f =\n let rec go i acc = if Int.(i = n) then acc else go (i + 1) (f i acc) in\n go 0 init\n\nmodule Make_operations (Field : Intf.Field) = struct\n let add_assign ~state i x = state.(i) <- Field.( + ) state.(i) x\n\n let apply_affine_map (matrix, constants) v =\n let dotv row =\n Array.reduce_exn (Array.map2_exn row v ~f:Field.( * )) ~f:Field.( + )\n in\n let res = Array.map matrix ~f:dotv in\n for i = 0 to Array.length res - 1 do\n res.(i) <- Field.( + ) res.(i) constants.(i)\n done ;\n res\n\n let copy = Array.copy\nend\n\nlet m = 3\n\nmodule Bn382_inputs (Field : Intf.Field_mutable) = struct\n let rounds_full = 8\n\n let initial_ark = true\n\n let rounds_partial = 30\n\n module Field = Field\n\n let alpha = 17\n\n (* alpha = 17 *)\n let to_the_alpha x =\n let open Field in\n let res = square x in\n Mutable.square res ;\n (* x^4 *)\n Mutable.square res ;\n (* x^8 *)\n Mutable.square res ;\n (* x^16 *)\n res *= x ;\n res\n\n module Operations = struct\n let add_assign ~state i x = Field.(state.(i) += x)\n\n (* Sparse pseudo-MDS matrix *)\n let apply_affine_map (_rows, c) v =\n let open Field in\n let res = [| v.(0) + v.(2); v.(0) + v.(1); v.(1) + v.(2) |] in\n Array.iteri res ~f:(fun i ri -> ri += c.(i)) ;\n res\n\n let copy a = Array.map a ~f:(fun x -> Field.(x + zero))\n end\nend\n\nmodule Rescue (Inputs : Intf.Inputs.Rescue) = struct\n (*\n We refer below to this paper: https://eprint.iacr.org/2019/426.pdf.\n\nI arrived at this value for the number of rounds in the following way.\nAs mentioned on page 34, the cost of performing the Grobner basis attack is estimated as\n\n( (n + d) choose d ) ^ omega\nwhere\n\n- omega is some number which is known to be >= 2\n- n = 1 + m*N is the number of variables in the system of equations on page 3\n- d is a quantity which they estimate as ((alpha - 1)(m*N + 1) + 1) / 2\n- m is the state size, which we can choose\n- N is the number of rounds which we can choose\n\nFor the MNT curves, `alpha = 11`, and I took `m = 3` which is optimal for binary Merkle trees.\nEvaluating the above formula with these values and `N = 11` and `omega = 2` yields an attack complexity\nof a little over 2^257, which if we take the same factor of 2 security margin as they use in the paper,\ngives us a security level of 257/2 ~= 128.\n\nNB: As you can see from the analysis this is really specialized to alpha = 11 and the number of rounds\nshould be higher for smaller alpha.\n*)\n\n open Inputs\n include Operations\n module Field = Field\n\n let sbox0, sbox1 = (alphath_root, to_the_alpha)\n\n let add_block ~state block = Array.iteri block ~f:(add_assign ~state)\n\n let block_cipher { Params.round_constants; mds } state =\n add_block ~state round_constants.(0) ;\n for_ (2 * rounds) ~init:state ~f:(fun r state ->\n let sbox = if Int.(r mod 2 = 0) then sbox0 else sbox1 in\n Array.map_inplace state ~f:sbox ;\n apply_affine_map (mds, round_constants.(r + 1)) state )\nend\n\nmodule Poseidon (Inputs : Intf.Inputs.Poseidon) = struct\n open Inputs\n include Operations\n module Field = Field\n\n let first_half_rounds_full = rounds_full / 2\n\n let add_block ~state block = Array.iteri block ~f:(add_assign ~state)\n\n (* Poseidon goes\n\n ARK_0 -> SBOX -> MDS\n -> ARK_1 -> SBOX -> MDS\n -> ...\n -> ARK_{half_rounds_full - 1} -> SBOX -> MDS\n -> ARK_{half_rounds_full} -> SBOX0 -> MDS\n -> ...\n -> ARK_{half_rounds_full + rounds_partial - 1} -> SBOX0 -> MDS\n -> ARK_{half_rounds_full + rounds_partial} -> SBOX -> MDS\n -> ...\n -> ARK_{half_rounds_full + rounds_partial + half_rounds_full - 1} -> SBOX -> MDS\n\n It is best to apply the matrix and add the round constants at the same\n time for Marlin constraint efficiency, so that is how this implementation does it.\n Like,\n\n ARK_0\n -> SBOX -> (MDS -> ARK_1)\n -> SBOX -> (MDS -> ARK_2)\n -> ...\n -> SBOX -> (MDS -> ARK_{half_rounds_full - 1})\n -> SBOX -> (MDS -> ARK_{half_rounds_full})\n -> SBOX0 -> (MDS -> ARK_{half_rounds_full + 1})\n -> ...\n -> SBOX0 -> (MDS -> ARK_{half_rounds_full + rounds_partial - 1})\n -> SBOX0 -> (MDS -> ARK_{half_rounds_full + rounds_partial})\n -> SBOX -> (MDS -> ARK_{half_rounds_full + rounds_partial + 1})\n -> ...\n -> SBOX -> (MDS -> ARK_{half_rounds_full + rounds_partial + half_rounds_full - 1})\n -> SBOX -> MDS ->* ARK_{half_rounds_full + rounds_partial + half_rounds_full}\n\n *this last round is a deviation from standard poseidon made for efficiency reasons.\n clearly it does not impact security to add round constants\n *)\n let block_cipher { Params.round_constants; mds } state =\n let sbox = to_the_alpha in\n let state = ref state in\n let constant_offset =\n if initial_ark then (\n add_block ~state:!state round_constants.(0) ;\n 1 )\n else 0\n in\n let range =\n (constant_offset, constant_offset + first_half_rounds_full - 1)\n in\n for i = fst range to snd range do\n (* SBOX -> MDS -> ARK *)\n Array.map_inplace !state ~f:sbox ;\n state := apply_affine_map (mds, round_constants.(i)) !state\n done ;\n let range = (snd range + 1, snd range + rounds_partial) in\n for i = fst range to snd range do\n !state.(0) <- sbox !state.(0) ;\n state := apply_affine_map (mds, round_constants.(i)) !state\n done ;\n let second_half_rounds_full = rounds_full - first_half_rounds_full in\n let range = (snd range + 1, snd range + second_half_rounds_full) in\n for i = fst range to snd range do\n Array.map_inplace !state ~f:sbox ;\n state := apply_affine_map (mds, round_constants.(i)) !state\n done ;\n !state\nend\n\nmodule Make_hash (P : Intf.Permutation) = struct\n open P\n\n let state_size = m\n\n let rate = state_size - 1\n\n let add_block ~state block = Array.iteri block ~f:(add_assign ~state)\n\n let sponge perm blocks ~state =\n Array.fold ~init:state blocks ~f:(fun state block ->\n add_block ~state block ; perm state )\n\n (* takes an array of field elements, and spread them into blocks/arrays that can contain [rate] fied elements *)\n let to_blocks rate field_elems =\n let n = Array.length field_elems in\n let num_blocks = if n = 0 then 1 else (n + rate - 1) / rate in\n let fill_block block_idx pos =\n let global_pos = (rate * block_idx) + pos in\n if global_pos < n then field_elems.(global_pos)\n else (* padding *) Field.zero\n in\n let create_block idx = Array.init rate ~f:(fill_block idx) in\n Array.init num_blocks ~f:create_block\n\n let%test_unit \"empty field_elems to_blocks\" =\n let blocks = to_blocks 2 [||] in\n assert (Array.length blocks = 1) ;\n [%test_eq: unit array array]\n (Array.map blocks ~f:(Array.map ~f:ignore))\n [| [| (); () |] |]\n\n let%test_unit \"block\" =\n let z = Field.zero in\n [%test_eq: unit array array]\n (Array.map (to_blocks 2 [| z; z; z |]) ~f:(Array.map ~f:ignore))\n [| [| (); () |]; [| (); () |] |]\n\n let update params ~state inputs =\n let state = copy state in\n sponge (block_cipher params) (to_blocks rate inputs) ~state\n\n let digest state = state.(0)\n\n let initial_state = Array.init state_size ~f:(fun _ -> Field.zero)\n\n let hash ?(init = initial_state) params inputs =\n update params ~state:init inputs |> digest\nend\n\ntype sponge_state = Absorbed of int | Squeezed of int [@@deriving sexp]\n\ntype 'f t =\n { mutable state : 'f State.t\n ; params : 'f Params.t\n ; mutable sponge_state : sponge_state\n ; id : int\n }\n\nlet id = ref (-1)\n\nlet make ~state ~params ~sponge_state =\n incr id ;\n { state; params; sponge_state; id = !id }\n\nmodule Make_sponge (P : Intf.Permutation) = struct\n open P\n\n let make = make\n\n let capacity = 1\n\n type sponge_state = Absorbed of int | Squeezed of int [@@deriving sexp]\n\n type nonrec t = Field.t t\n\n let state { state; _ } = copy state\n\n let initial_state = Array.init m ~f:(fun _ -> Field.zero)\n\n let create ?(init = initial_state) params =\n make ~state:(copy init) ~sponge_state:(Absorbed 0) ~params\n\n let copy { state; params; sponge_state; id } =\n { state = copy state; params; sponge_state; id }\n\n let rate = m - capacity\n\n let absorb t x =\n match t.sponge_state with\n | Absorbed n ->\n if n = rate then (\n t.state <- block_cipher t.params t.state ;\n add_assign ~state:t.state 0 x ;\n t.sponge_state <- Absorbed 1 )\n else (\n add_assign ~state:t.state n x ;\n t.sponge_state <- Absorbed (n + 1) )\n | Squeezed _ ->\n add_assign ~state:t.state 0 x ;\n t.sponge_state <- Absorbed 1\n\n let squeeze t =\n match t.sponge_state with\n | Squeezed n ->\n if n = rate then (\n t.state <- block_cipher t.params t.state ;\n t.sponge_state <- Squeezed 1 ;\n t.state.(0) )\n else (\n t.sponge_state <- Squeezed (n + 1) ;\n t.state.(n) )\n | Absorbed _ ->\n t.state <- block_cipher t.params t.state ;\n t.sponge_state <- Squeezed 1 ;\n t.state.(0)\nend\n\nmodule Make_debug_sponge (P : sig\n include Intf.Permutation\n\n module Circuit : Snarky_backendless.Snark_intf.Run\n\n val sponge_name : string\n\n val debug_helper_fn : Field.t -> string\nend) =\nstruct\n include Make_sponge (P)\n\n (* In sponge debug mode, prints a standard sponge debug line, otherwise does nothing.\n Note: standard sponge debug line must match the output of Kimchi's sponge debug mode *)\n let debug (operation : string) (sponge : t) (input : P.Field.t option) =\n match Sys.getenv_opt P.sponge_name with\n | Some s -> (\n match String.lowercase s with\n | \"t\" | \"1\" | \"true\" ->\n P.Circuit.as_prover (fun () ->\n (* Convert sponge_state to match Rust style debug string *)\n let sponge_state =\n match sponge.sponge_state with\n | Absorbed n ->\n Printf.sprintf \"Absorbed(%d)\" n\n | Squeezed n ->\n Printf.sprintf \"Squeezed(%d)\" n\n in\n (* Print debug header, operation and sponge_state *)\n Format.eprintf \"debug_sponge: %s%d %s state %s\" P.sponge_name\n sponge.id operation sponge_state ;\n (* Print sponge's state array *)\n Array.iter sponge.state ~f:(fun fe ->\n Format.eprintf \" %s\" (P.debug_helper_fn fe) ) ;\n Format.eprintf \"@.\" ;\n (* Print optional input *)\n match input with\n | Some input ->\n Format.eprintf \"debug_sponge: %s%d %s input %s@.\"\n P.sponge_name sponge.id operation\n (P.debug_helper_fn input)\n | None ->\n () )\n | _ ->\n () )\n | None ->\n ()\n\n let make ~state ~params ~sponge_state =\n let t = make ~state ~params ~sponge_state in\n debug \"make\" t None ; t\n\n let absorb t x = debug \"absorb\" t (Some x) ; absorb t x\n\n let squeeze t = debug \"squeeze\" t None ; squeeze t\nend\n\nmodule Bit_sponge = struct\n type ('s, 'bool) t =\n { underlying : 's\n (* TODO: Have to be careful about these bits. They aren't perfectly uniform. *)\n ; mutable last_squeezed : 'bool list\n }\n\n let map (type a b) t ~(f : a -> b) : (b, _) t =\n { t with underlying = f t.underlying }\n\n let make ?(last_squeezed = []) underlying = { underlying; last_squeezed }\n\n let underlying { underlying; last_squeezed = _ } = underlying\n\n module Make\n (Bool : Intf.T) (Field : sig\n type t\n\n val to_bits : t -> Bool.t list\n\n val finalize_discarded : Bool.t list -> unit\n\n val high_entropy_bits : int\n end)\n (Input : Intf.T)\n (S : Intf.Sponge\n with module State := State\n and module Field := Field\n and type digest := Field.t\n and type input := Input.t) =\n struct\n type nonrec t = (S.t, Bool.t) t\n\n let state t = S.state t.underlying\n\n let high_entropy_bits = Field.high_entropy_bits\n\n let create ?init params =\n { underlying = S.create ?init params; last_squeezed = [] }\n\n let copy { underlying; last_squeezed } =\n { underlying = S.copy underlying; last_squeezed }\n\n let absorb t x =\n S.absorb t.underlying x ;\n t.last_squeezed <- []\n\n let rec squeeze t ~length =\n if List.length t.last_squeezed >= length then (\n let digest, remaining = List.split_n t.last_squeezed length in\n t.last_squeezed <- remaining ;\n digest )\n else\n let x = S.squeeze t.underlying in\n let hi =\n let hi, lo = List.split_n (Field.to_bits x) high_entropy_bits in\n Field.finalize_discarded lo ;\n hi\n in\n t.last_squeezed <- t.last_squeezed @ hi ;\n squeeze ~length t\n\n let squeeze_field t =\n t.last_squeezed <- [] ;\n S.squeeze t.underlying\n end\nend\n","open! Core_kernel\nopen! Import\nopen Tuple_pool_intf\nmodule Tuple_type = Tuple_type\n\nlet failwiths = Error.failwiths\nlet phys_equal = Caml.( == )\nlet arch_sixtyfour = Sys.word_size = 64\n\nmodule Int = struct\n let num_bits = Int.num_bits\n let max_value = Caml.max_int\n let to_string = string_of_int\nend\n\nlet sprintf = Printf.sprintf\nlet concat l = Base.String.concat ~sep:\"\" l\n\nmodule type S = S\n\nmodule Pool = struct\n let grow_capacity ~capacity ~old_capacity =\n match capacity with\n | None -> if old_capacity = 0 then 1 else old_capacity * 2\n | Some capacity ->\n if capacity <= old_capacity\n then\n failwiths\n ~here:[%here]\n \"Pool.grow got too small capacity\"\n (`capacity capacity, `old_capacity old_capacity)\n [%sexp_of: [ `capacity of int ] * [ `old_capacity of int ]];\n capacity\n ;;\n\n module Slots = Tuple_type.Slots\n\n let max_slot = 14\n\n (* The pool is represented as a single [Uniform_array.t], where index zero has the\n metadata about the pool and the remaining indices are the tuples layed out one after\n the other. Each tuple takes [1 + slots_per_tuple] indices in the pool, where the\n first index holds a header and the remaining indices hold the tuple's slots:\n\n {v\n | header | s0 | s1 | ... | s |\n v}\n\n A [Pointer.t] to a tuple contains the integer index where its header is, as well as\n (a mask of) the tuple's unique id.\n\n The free tuples are singly linked via the headers.\n\n When a tuple is in use, its header is marked to indicate so, and also to include the\n tuple's unique id. This allows us to check in constant time whether a pointer is\n valid, by comparing the id in the pointer with the id in the header.\n\n When a tuple is not in use, its header is part of the free list, and its tuple slots\n have dummy values of the appropriate types, from the [dummy] tuple supplied to\n [create]. We must have dummy values of the correct type to prevent a segfault in\n code that (mistakenly) uses a pointer to a free tuple.\n\n For [Pool.Unsafe], a slot in a free object is guaranteed to be an int; it must not be\n pointer to prevent a space leak. However, the int in the slot may not represent a\n valid value of the type.\n *)\n\n module Slot = struct\n type ('slots, 'a) t = int [@@deriving sexp_of]\n\n let equal (t1 : (_, _) t) t2 = t1 = t2\n let t0 = 1\n let t1 = 2\n let t2 = 3\n let t3 = 4\n let t4 = 5\n let t5 = 6\n let t6 = 7\n let t7 = 8\n let t8 = 9\n let t9 = 10\n let t10 = 11\n let t11 = 12\n let t12 = 13\n let t13 = 14\n\n let%test _ = t13 = max_slot\n end\n\n (* We only have [Int.num_bits] bits available for pool pointers. The bits of a pool\n pointer encode two things:\n\n - the tuple's array index in the pool\n - the tuple's identifier (not necessarily unique)\n\n We choose [array_index_num_bits] as large as needed for the maximum pool capacity\n that we want to support, and use the remaining [masked_tuple_id_num_bits] bits for\n the identifier. 64-bit and 32-bit architectures typically have very different\n address-space sizes, so we choose [array_index_num_bits] differently. *)\n\n let array_index_num_bits =\n if arch_sixtyfour\n then (\n assert (Int.num_bits = 63);\n 30)\n else (\n assert (Int.num_bits = 31 || Int.num_bits = 32);\n 22)\n ;;\n\n let masked_tuple_id_num_bits = Int.num_bits - array_index_num_bits\n\n let%test _ = array_index_num_bits > 0\n let%test _ = masked_tuple_id_num_bits > 0\n let%test _ = array_index_num_bits + masked_tuple_id_num_bits <= Int.num_bits\n\n let max_array_length = 1 lsl array_index_num_bits\n\n module Tuple_id : sig\n type t = private int [@@deriving sexp_of]\n\n include Invariant.S with type t := t\n\n val to_string : t -> string\n val equal : t -> t -> bool\n val init : t\n val next : t -> t\n val of_int : int -> t\n val to_int : t -> int\n val examples : t list\n end = struct\n type t = int [@@deriving sexp_of]\n\n (* We guarantee that tuple ids are nonnegative so that they can be encoded in\n headers. *)\n let invariant t = assert (t >= 0)\n let to_string = Int.to_string\n let equal (t1 : t) t2 = t1 = t2\n let init = 0\n let next t = if arch_sixtyfour then t + 1 else if t = Int.max_value then 0 else t + 1\n let to_int t = t\n\n let of_int i =\n if i < 0\n then failwiths ~here:[%here] \"Tuple_id.of_int got negative int\" i [%sexp_of: int];\n i\n ;;\n\n let examples = [ 0; 1; 0x1FFF_FFFF; Int.max_value ]\n end\n\n let tuple_id_mask = (1 lsl masked_tuple_id_num_bits) - 1\n\n module Pointer : sig\n (* [Pointer.t] is an encoding as an [int] of the following sum type:\n\n {[\n | Null\n | Normal of { header_index : int; masked_tuple_id : int }\n ]}\n\n The encoding is chosen to optimize the most common operation, namely tuple-slot\n access, the [slot_index] function. The encoding is designed so that [slot_index]\n produces a negative number for [Null], which will cause the subsequent array bounds\n check to fail. *)\n\n type 'slots t = private int [@@deriving sexp_of, typerep]\n\n include Invariant.S1 with type 'a t := 'a t\n\n val phys_compare : 'a t -> 'a t -> int\n val phys_equal : 'a t -> 'a t -> bool\n\n (* The null pointer. [null] is a function due to issues with the value restriction. *)\n\n val null : unit -> _ t\n val is_null : _ t -> bool\n\n (* Normal pointers. *)\n\n val create : header_index:int -> Tuple_id.t -> _ t\n val header_index : _ t -> int\n val masked_tuple_id : _ t -> int\n val slot_index : _ t -> (_, _) Slot.t -> int\n val first_slot_index : _ t -> int\n\n module Id : sig\n type t [@@deriving bin_io, sexp]\n\n val to_int63 : t -> Int63.t\n val of_int63 : Int63.t -> t\n end\n\n val to_id : _ t -> Id.t\n val of_id_exn : Id.t -> _ t\n end = struct\n (* A pointer is either [null] or the (positive) index in the pool of the next-free\n field preceeding the tuple's slots. *)\n type 'slots t = int [@@deriving typerep]\n\n let sexp_of_t _ t = Sexp.Atom (sprintf \"\" t)\n let phys_equal (t1 : _ t) t2 = phys_equal t1 t2\n let phys_compare = compare\n let null () = -max_slot - 1\n let is_null t = phys_equal t (null ())\n\n (* [null] must be such that [null + slot] is an invalid array index for all slots.\n Otherwise get/set on the null pointer may lead to a segfault. *)\n let%test _ = null () + max_slot < 0\n\n let create ~header_index (tuple_id : Tuple_id.t) =\n header_index\n lor ((Tuple_id.to_int tuple_id land tuple_id_mask) lsl array_index_num_bits)\n ;;\n\n let header_index_mask = (1 lsl array_index_num_bits) - 1\n let masked_tuple_id t = t lsr array_index_num_bits\n let header_index t = t land header_index_mask\n let invariant _ t = if not (is_null t) then assert (header_index t > 0)\n\n let%test_unit _ = invariant ignore (null ())\n\n let%test_unit _ =\n List.iter Tuple_id.examples ~f:(fun tuple_id ->\n invariant ignore (create ~header_index:1 tuple_id))\n ;;\n\n let slot_index t slot = header_index t + slot\n let first_slot_index t = slot_index t Slot.t0\n\n module Id = struct\n include Int63\n\n let to_int63 t = t\n let of_int63 i = i\n end\n\n let to_id t = Id.of_int t\n\n let of_id_exn id =\n try\n let t = Id.to_int_exn id in\n if is_null t\n then t\n else (\n let should_equal =\n create ~header_index:(header_index t) (Tuple_id.of_int (masked_tuple_id t))\n in\n if phys_equal t should_equal\n then t\n else failwiths ~here:[%here] \"should equal\" should_equal [%sexp_of: _ t])\n with\n | exn ->\n failwiths\n ~here:[%here]\n \"Pointer.of_id_exn got strange id\"\n (id, exn)\n [%sexp_of: Id.t * exn]\n ;;\n end\n\n module Header : sig\n (* A [Header.t] is an encoding as an [int] of the following type:\n\n {[\n | Null\n | Free of { next_free_header_index : int }\n | Used of { tuple_id : int }\n ]}\n\n If a tuple is free, its header is set to either [Null] or [Free] with\n [next_free_header_index] indicating the header of the next tuple on the free list.\n If a tuple is in use, it header is set to [Used]. *)\n\n type t = private int [@@deriving sexp_of]\n\n val null : t\n val is_null : t -> bool\n val free : next_free_header_index:int -> t\n val is_free : t -> bool\n val next_free_header_index : t -> int\n\n (* only valid if [is_free t] *)\n\n val used : Tuple_id.t -> t\n val is_used : t -> bool\n val tuple_id : t -> Tuple_id.t\n\n (* only valid if [is_used t] *)\n end = struct\n type t = int\n\n let null = 0\n let is_null t = t = 0\n\n (* We know that header indices are [> 0], because index [0] holds the metadata. *)\n let free ~next_free_header_index = next_free_header_index\n let is_free t = t > 0\n let next_free_header_index t = t\n let used (tuple_id : Tuple_id.t) = -1 - (tuple_id :> int)\n let is_used t = t < 0\n let tuple_id t = Tuple_id.of_int (-(t + 1))\n\n let%test_unit _ =\n List.iter Tuple_id.examples ~f:(fun id ->\n let t = used id in\n assert (is_used t);\n assert (Tuple_id.equal (tuple_id t) id))\n ;;\n\n let sexp_of_t t =\n if is_null t\n then Sexp.Atom \"null\"\n else if is_free t\n then Sexp.(List [ Atom \"Free\"; Atom (Int.to_string (next_free_header_index t)) ])\n else Sexp.(List [ Atom \"Used\"; Atom (Tuple_id.to_string (tuple_id t)) ])\n ;;\n end\n\n let metadata_index = 0\n let start_of_tuples_index = 1\n\n let max_capacity ~slots_per_tuple =\n (max_array_length - start_of_tuples_index) / (1 + slots_per_tuple)\n ;;\n\n let%test_unit _ =\n for slots_per_tuple = 1 to max_slot do\n assert (\n start_of_tuples_index + ((1 + slots_per_tuple) * max_capacity ~slots_per_tuple)\n <= max_array_length)\n done\n ;;\n\n module Metadata = struct\n type 'slots t =\n { (* [slots_per_tuple] is number of slots in a tuple as seen by the user; i.e. not\n counting the next-free pointer. *)\n slots_per_tuple : int\n ; capacity : int\n ; mutable length : int\n ; mutable next_id : Tuple_id.t\n ; mutable first_free : Header.t\n (* [dummy] is [None] in an unsafe pool. In a safe pool, [dummy] is [Some a], with\n [Uniform_array.length a = slots_per_tuple]. [dummy] is actually a tuple value\n with the correct type (corresponding to ['slots]), but we make the type of\n [dummy] be [Obj.t Uniform_array.t] because we can't write that type here. Also,\n the purpose of [dummy] is to initialize a pool element, making [dummy] an [Obj.t\n Uniform_array.t] lets us initialize a pool element using [Uniform_array.blit]\n from [dummy] to the pool, which is an [Obj.t Uniform_array.t]. *)\n ; dummy : (Obj.t Uniform_array.t[@sexp.opaque]) option\n }\n [@@deriving fields, sexp_of]\n\n let array_indices_per_tuple t = 1 + t.slots_per_tuple\n let array_length t = start_of_tuples_index + (t.capacity * array_indices_per_tuple t)\n\n let header_index_to_tuple_num t ~header_index =\n (header_index - start_of_tuples_index) / array_indices_per_tuple t\n ;;\n\n let tuple_num_to_header_index t tuple_num =\n start_of_tuples_index + (tuple_num * array_indices_per_tuple t)\n ;;\n\n let tuple_num_to_first_slot_index t tuple_num =\n tuple_num_to_header_index t tuple_num + 1\n ;;\n\n let is_full t = t.length = t.capacity\n end\n\n open Metadata\n\n (* We use type [Obj.t] because the array holds a mix of integers as well as OCaml values\n of arbitrary type. *)\n type 'slots t = Obj.t Uniform_array.t\n\n let metadata (type slots) (t : slots t) =\n Uniform_array.unsafe_get t metadata_index |> (Obj.obj : _ -> slots Metadata.t)\n ;;\n\n let length t = (metadata t).length\n let sexp_of_t sexp_of_ty t = Metadata.sexp_of_t sexp_of_ty (metadata t)\n\n (* Because [unsafe_header] and [unsafe_set_header] do not do a bounds check, one must be\n sure that one has a valid [header_index] before calling them. *)\n let unsafe_header t ~header_index =\n Uniform_array.unsafe_get t header_index |> (Obj.obj : _ -> Header.t)\n ;;\n\n let unsafe_set_header t ~header_index (header : Header.t) =\n Uniform_array.unsafe_set_int_assuming_currently_int t header_index (header :> int)\n ;;\n\n let header_index_is_in_bounds t ~header_index =\n header_index >= start_of_tuples_index && header_index < Uniform_array.length t\n ;;\n\n let unsafe_pointer_is_live t pointer =\n let header_index = Pointer.header_index pointer in\n let header = unsafe_header t ~header_index in\n Header.is_used header\n && Tuple_id.to_int (Header.tuple_id header) land tuple_id_mask\n = Pointer.masked_tuple_id pointer\n ;;\n\n let pointer_is_valid t pointer =\n header_index_is_in_bounds t ~header_index:(Pointer.header_index pointer)\n (* At this point, we know the pointer isn't [null] and is in bounds, so we know it is\n the index of a header, since we maintain the invariant that all pointers other than\n [null] are. *)\n && unsafe_pointer_is_live t pointer\n ;;\n\n let id_of_pointer _t pointer = Pointer.to_id pointer\n\n let is_valid_header_index t ~header_index =\n let metadata = metadata t in\n header_index_is_in_bounds t ~header_index\n && 0\n = (header_index - start_of_tuples_index)\n mod Metadata.array_indices_per_tuple metadata\n ;;\n\n let pointer_of_id_exn t id =\n try\n let pointer = Pointer.of_id_exn id in\n if not (Pointer.is_null pointer)\n then (\n let header_index = Pointer.header_index pointer in\n if not (is_valid_header_index t ~header_index)\n then failwiths ~here:[%here] \"invalid header index\" header_index [%sexp_of: int];\n if not (unsafe_pointer_is_live t pointer) then failwith \"pointer not live\");\n pointer\n with\n | exn ->\n failwiths\n ~here:[%here]\n \"Pool.pointer_of_id_exn got invalid id\"\n (id, t, exn)\n [%sexp_of: Pointer.Id.t * _ t * exn]\n ;;\n\n let invariant _invariant_a t : unit =\n try\n let metadata = metadata t in\n let check f field = f (Field.get field metadata) in\n Metadata.Fields.iter\n ~slots_per_tuple:(check (fun slots_per_tuple -> assert (slots_per_tuple > 0)))\n ~capacity:\n (check (fun capacity ->\n assert (capacity >= 0);\n assert (Uniform_array.length t = Metadata.array_length metadata)))\n ~length:\n (check (fun length ->\n assert (length >= 0);\n assert (length <= metadata.capacity)))\n ~next_id:(check Tuple_id.invariant)\n ~first_free:\n (check (fun first_free ->\n let free = Array.create ~len:metadata.capacity false in\n let r = ref first_free in\n while not (Header.is_null !r) do\n let header = !r in\n assert (Header.is_free header);\n let header_index = Header.next_free_header_index header in\n assert (is_valid_header_index t ~header_index);\n let tuple_num = header_index_to_tuple_num metadata ~header_index in\n if free.(tuple_num)\n then\n failwiths ~here:[%here] \"cycle in free list\" tuple_num [%sexp_of: int];\n free.(tuple_num) <- true;\n r := unsafe_header t ~header_index\n done))\n ~dummy:\n (check (function\n | Some dummy ->\n assert (Uniform_array.length dummy = metadata.slots_per_tuple)\n | None ->\n for tuple_num = 0 to metadata.capacity - 1 do\n let header_index = tuple_num_to_header_index metadata tuple_num in\n let header = unsafe_header t ~header_index in\n if Header.is_free header\n then (\n let first_slot = tuple_num_to_first_slot_index metadata tuple_num in\n for slot = 0 to metadata.slots_per_tuple - 1 do\n assert (Obj.is_int (Uniform_array.get t (first_slot + slot)))\n done)\n done))\n with\n | exn ->\n failwiths ~here:[%here] \"Pool.invariant failed\" (exn, t) [%sexp_of: exn * _ t]\n ;;\n\n let capacity t = (metadata t).capacity\n let is_full t = Metadata.is_full (metadata t)\n\n let unsafe_add_to_free_list t metadata ~header_index =\n unsafe_set_header t ~header_index metadata.first_free;\n metadata.first_free <- Header.free ~next_free_header_index:header_index\n ;;\n\n let set_metadata (type slots) (t : slots t) metadata =\n Uniform_array.set t metadata_index (Obj.repr (metadata : slots Metadata.t))\n ;;\n\n let create_array (type slots) (metadata : slots Metadata.t) : slots t =\n let t = Uniform_array.create_obj_array ~len:(Metadata.array_length metadata) in\n set_metadata t metadata;\n t\n ;;\n\n (* Initialize tuples numbered from [lo] (inclusive) up to [hi] (exclusive). For each\n tuple, this puts dummy values in the tuple's slots and adds the tuple to the free\n list. *)\n let unsafe_init_range t metadata ~lo ~hi =\n (match metadata.dummy with\n | None -> ()\n | Some dummy ->\n for tuple_num = lo to hi - 1 do\n Uniform_array.blit\n ~src:dummy\n ~src_pos:0\n ~dst:t\n ~dst_pos:(tuple_num_to_first_slot_index metadata tuple_num)\n ~len:metadata.slots_per_tuple\n done);\n for tuple_num = hi - 1 downto lo do\n unsafe_add_to_free_list\n t\n metadata\n ~header_index:(tuple_num_to_header_index metadata tuple_num)\n done\n ;;\n\n let create_with_dummy slots ~capacity ~dummy =\n if capacity < 0\n then\n failwiths ~here:[%here] \"Pool.create got invalid capacity\" capacity [%sexp_of: int];\n let slots_per_tuple = Slots.slots_per_tuple slots in\n let max_capacity = max_capacity ~slots_per_tuple in\n if capacity > max_capacity\n then\n failwiths\n ~here:[%here]\n \"Pool.create got too large capacity\"\n (capacity, `max max_capacity)\n [%sexp_of: int * [ `max of int ]];\n let metadata =\n { Metadata.slots_per_tuple\n ; capacity\n ; length = 0\n ; next_id = Tuple_id.init\n ; first_free = Header.null\n ; dummy\n }\n in\n let t = create_array metadata in\n unsafe_init_range t metadata ~lo:0 ~hi:capacity;\n t\n ;;\n\n let create (type tuple) (slots : (tuple, _) Slots.t) ~capacity ~dummy =\n let dummy =\n if Slots.slots_per_tuple slots = 1\n then Uniform_array.singleton (Obj.repr (dummy : tuple))\n else (Obj.magic (dummy : tuple) : Obj.t Uniform_array.t)\n in\n create_with_dummy slots ~capacity ~dummy:(Some dummy)\n ;;\n\n (* Purge a pool and make it unusable. *)\n let destroy t =\n let metadata = metadata t in\n (* We clear out all the pool's entries, which causes all pointers to be invalid. This\n also prevents the destroyed pool from unnecessarily keeping heap blocks alive.\n This is similar to [free]ing all the entries with the difference that we make the\n free list empty as well. *)\n (match metadata.dummy with\n | None ->\n for i = start_of_tuples_index to Uniform_array.length t - 1 do\n Uniform_array.unsafe_set t i (Obj.repr 0)\n done\n | Some dummy ->\n for tuple_num = 0 to metadata.capacity - 1 do\n let header_index = tuple_num_to_header_index metadata tuple_num in\n unsafe_set_header t ~header_index Header.null;\n Uniform_array.blit\n ~src:dummy\n ~src_pos:0\n ~dst:t\n ~dst_pos:(header_index + 1)\n ~len:metadata.slots_per_tuple\n done);\n let metadata =\n { Metadata.slots_per_tuple = metadata.slots_per_tuple\n ; capacity = 0\n ; length = 0\n ; next_id = metadata.next_id\n ; first_free = Header.null\n ; dummy = metadata.dummy\n }\n in\n set_metadata t metadata\n ;;\n\n let[@cold] grow ?capacity t =\n let { Metadata.slots_per_tuple\n ; capacity = old_capacity\n ; length\n ; next_id\n ; first_free = _\n ; dummy\n }\n =\n metadata t\n in\n let capacity =\n min (max_capacity ~slots_per_tuple) (grow_capacity ~capacity ~old_capacity)\n in\n if capacity = old_capacity\n then\n failwiths\n ~here:[%here]\n \"Pool.grow cannot grow pool; capacity already at maximum\"\n capacity\n [%sexp_of: int];\n let metadata =\n { Metadata.slots_per_tuple\n ; capacity\n ; length\n ; next_id\n ; first_free = Header.null\n ; dummy\n }\n in\n let t' = create_array metadata in\n Uniform_array.blit\n ~src:t\n ~src_pos:start_of_tuples_index\n ~dst:t'\n ~dst_pos:start_of_tuples_index\n ~len:(old_capacity * Metadata.array_indices_per_tuple metadata);\n destroy t;\n unsafe_init_range t' metadata ~lo:old_capacity ~hi:capacity;\n for tuple_num = old_capacity - 1 downto 0 do\n let header_index = tuple_num_to_header_index metadata tuple_num in\n let header = unsafe_header t' ~header_index in\n if not (Header.is_used header)\n then unsafe_add_to_free_list t' metadata ~header_index\n done;\n t'\n ;;\n\n let[@cold] raise_malloc_full t =\n failwiths ~here:[%here] \"Pool.malloc of full pool\" t [%sexp_of: _ t]\n ;;\n\n let malloc (type slots) (t : slots t) : slots Pointer.t =\n let metadata = metadata t in\n let first_free = metadata.first_free in\n if Header.is_null first_free then raise_malloc_full t;\n let header_index = Header.next_free_header_index first_free in\n metadata.first_free <- unsafe_header t ~header_index;\n metadata.length <- metadata.length + 1;\n let tuple_id = metadata.next_id in\n unsafe_set_header t ~header_index (Header.used tuple_id);\n metadata.next_id <- Tuple_id.next tuple_id;\n Pointer.create ~header_index tuple_id\n ;;\n\n let unsafe_free (type slots) (t : slots t) (pointer : slots Pointer.t) =\n let metadata = metadata t in\n metadata.length <- metadata.length - 1;\n unsafe_add_to_free_list t metadata ~header_index:(Pointer.header_index pointer);\n match metadata.dummy with\n | None ->\n let pos = Pointer.first_slot_index pointer in\n for i = 0 to metadata.slots_per_tuple - 1 do\n Uniform_array.unsafe_clear_if_pointer t (pos + i)\n done\n | Some dummy ->\n Uniform_array.unsafe_blit\n ~src:dummy\n ~src_pos:0\n ~len:metadata.slots_per_tuple\n ~dst:t\n ~dst_pos:(Pointer.first_slot_index pointer)\n ;;\n\n let free (type slots) (t : slots t) (pointer : slots Pointer.t) =\n (* Check [pointer_is_valid] to:\n - avoid freeing a null pointer\n - avoid freeing a free pointer (this would lead to a pool inconsistency)\n - be able to use unsafe functions after. *)\n if not (pointer_is_valid t pointer)\n then\n failwiths\n ~here:[%here]\n \"Pool.free of invalid pointer\"\n (pointer, t)\n [%sexp_of: _ Pointer.t * _ t];\n unsafe_free t pointer\n ;;\n\n let new1 t a0 =\n let pointer = malloc t in\n let offset = Pointer.header_index pointer in\n Uniform_array.unsafe_set t (offset + 1) (Obj.repr a0);\n pointer\n ;;\n\n let new2 t a0 a1 =\n let pointer = malloc t in\n let offset = Pointer.header_index pointer in\n Uniform_array.unsafe_set t (offset + 1) (Obj.repr a0);\n Uniform_array.unsafe_set t (offset + 2) (Obj.repr a1);\n pointer\n ;;\n\n let new3 t a0 a1 a2 =\n let pointer = malloc t in\n let offset = Pointer.header_index pointer in\n Uniform_array.unsafe_set t (offset + 1) (Obj.repr a0);\n Uniform_array.unsafe_set t (offset + 2) (Obj.repr a1);\n Uniform_array.unsafe_set t (offset + 3) (Obj.repr a2);\n pointer\n ;;\n\n let new4 t a0 a1 a2 a3 =\n let pointer = malloc t in\n let offset = Pointer.header_index pointer in\n Uniform_array.unsafe_set t (offset + 1) (Obj.repr a0);\n Uniform_array.unsafe_set t (offset + 2) (Obj.repr a1);\n Uniform_array.unsafe_set t (offset + 3) (Obj.repr a2);\n Uniform_array.unsafe_set t (offset + 4) (Obj.repr a3);\n pointer\n ;;\n\n let new5 t a0 a1 a2 a3 a4 =\n let pointer = malloc t in\n let offset = Pointer.header_index pointer in\n Uniform_array.unsafe_set t (offset + 1) (Obj.repr a0);\n Uniform_array.unsafe_set t (offset + 2) (Obj.repr a1);\n Uniform_array.unsafe_set t (offset + 3) (Obj.repr a2);\n Uniform_array.unsafe_set t (offset + 4) (Obj.repr a3);\n Uniform_array.unsafe_set t (offset + 5) (Obj.repr a4);\n pointer\n ;;\n\n let new6 t a0 a1 a2 a3 a4 a5 =\n let pointer = malloc t in\n let offset = Pointer.header_index pointer in\n Uniform_array.unsafe_set t (offset + 1) (Obj.repr a0);\n Uniform_array.unsafe_set t (offset + 2) (Obj.repr a1);\n Uniform_array.unsafe_set t (offset + 3) (Obj.repr a2);\n Uniform_array.unsafe_set t (offset + 4) (Obj.repr a3);\n Uniform_array.unsafe_set t (offset + 5) (Obj.repr a4);\n Uniform_array.unsafe_set t (offset + 6) (Obj.repr a5);\n pointer\n ;;\n\n let new7 t a0 a1 a2 a3 a4 a5 a6 =\n let pointer = malloc t in\n let offset = Pointer.header_index pointer in\n Uniform_array.unsafe_set t (offset + 1) (Obj.repr a0);\n Uniform_array.unsafe_set t (offset + 2) (Obj.repr a1);\n Uniform_array.unsafe_set t (offset + 3) (Obj.repr a2);\n Uniform_array.unsafe_set t (offset + 4) (Obj.repr a3);\n Uniform_array.unsafe_set t (offset + 5) (Obj.repr a4);\n Uniform_array.unsafe_set t (offset + 6) (Obj.repr a5);\n Uniform_array.unsafe_set t (offset + 7) (Obj.repr a6);\n pointer\n ;;\n\n let new8 t a0 a1 a2 a3 a4 a5 a6 a7 =\n let pointer = malloc t in\n let offset = Pointer.header_index pointer in\n Uniform_array.unsafe_set t (offset + 1) (Obj.repr a0);\n Uniform_array.unsafe_set t (offset + 2) (Obj.repr a1);\n Uniform_array.unsafe_set t (offset + 3) (Obj.repr a2);\n Uniform_array.unsafe_set t (offset + 4) (Obj.repr a3);\n Uniform_array.unsafe_set t (offset + 5) (Obj.repr a4);\n Uniform_array.unsafe_set t (offset + 6) (Obj.repr a5);\n Uniform_array.unsafe_set t (offset + 7) (Obj.repr a6);\n Uniform_array.unsafe_set t (offset + 8) (Obj.repr a7);\n pointer\n ;;\n\n let new9 t a0 a1 a2 a3 a4 a5 a6 a7 a8 =\n let pointer = malloc t in\n let offset = Pointer.header_index pointer in\n Uniform_array.unsafe_set t (offset + 1) (Obj.repr a0);\n Uniform_array.unsafe_set t (offset + 2) (Obj.repr a1);\n Uniform_array.unsafe_set t (offset + 3) (Obj.repr a2);\n Uniform_array.unsafe_set t (offset + 4) (Obj.repr a3);\n Uniform_array.unsafe_set t (offset + 5) (Obj.repr a4);\n Uniform_array.unsafe_set t (offset + 6) (Obj.repr a5);\n Uniform_array.unsafe_set t (offset + 7) (Obj.repr a6);\n Uniform_array.unsafe_set t (offset + 8) (Obj.repr a7);\n Uniform_array.unsafe_set t (offset + 9) (Obj.repr a8);\n pointer\n ;;\n\n let new10 t a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 =\n let pointer = malloc t in\n let offset = Pointer.header_index pointer in\n Uniform_array.unsafe_set t (offset + 1) (Obj.repr a0);\n Uniform_array.unsafe_set t (offset + 2) (Obj.repr a1);\n Uniform_array.unsafe_set t (offset + 3) (Obj.repr a2);\n Uniform_array.unsafe_set t (offset + 4) (Obj.repr a3);\n Uniform_array.unsafe_set t (offset + 5) (Obj.repr a4);\n Uniform_array.unsafe_set t (offset + 6) (Obj.repr a5);\n Uniform_array.unsafe_set t (offset + 7) (Obj.repr a6);\n Uniform_array.unsafe_set t (offset + 8) (Obj.repr a7);\n Uniform_array.unsafe_set t (offset + 9) (Obj.repr a8);\n Uniform_array.unsafe_set t (offset + 10) (Obj.repr a9);\n pointer\n ;;\n\n let new11 t a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 =\n let pointer = malloc t in\n let offset = Pointer.header_index pointer in\n Uniform_array.unsafe_set t (offset + 1) (Obj.repr a0);\n Uniform_array.unsafe_set t (offset + 2) (Obj.repr a1);\n Uniform_array.unsafe_set t (offset + 3) (Obj.repr a2);\n Uniform_array.unsafe_set t (offset + 4) (Obj.repr a3);\n Uniform_array.unsafe_set t (offset + 5) (Obj.repr a4);\n Uniform_array.unsafe_set t (offset + 6) (Obj.repr a5);\n Uniform_array.unsafe_set t (offset + 7) (Obj.repr a6);\n Uniform_array.unsafe_set t (offset + 8) (Obj.repr a7);\n Uniform_array.unsafe_set t (offset + 9) (Obj.repr a8);\n Uniform_array.unsafe_set t (offset + 10) (Obj.repr a9);\n Uniform_array.unsafe_set t (offset + 11) (Obj.repr a10);\n pointer\n ;;\n\n let new12 t a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 =\n let pointer = malloc t in\n let offset = Pointer.header_index pointer in\n Uniform_array.unsafe_set t (offset + 1) (Obj.repr a0);\n Uniform_array.unsafe_set t (offset + 2) (Obj.repr a1);\n Uniform_array.unsafe_set t (offset + 3) (Obj.repr a2);\n Uniform_array.unsafe_set t (offset + 4) (Obj.repr a3);\n Uniform_array.unsafe_set t (offset + 5) (Obj.repr a4);\n Uniform_array.unsafe_set t (offset + 6) (Obj.repr a5);\n Uniform_array.unsafe_set t (offset + 7) (Obj.repr a6);\n Uniform_array.unsafe_set t (offset + 8) (Obj.repr a7);\n Uniform_array.unsafe_set t (offset + 9) (Obj.repr a8);\n Uniform_array.unsafe_set t (offset + 10) (Obj.repr a9);\n Uniform_array.unsafe_set t (offset + 11) (Obj.repr a10);\n Uniform_array.unsafe_set t (offset + 12) (Obj.repr a11);\n pointer\n ;;\n\n let new13 t a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 =\n let pointer = malloc t in\n let offset = Pointer.header_index pointer in\n Uniform_array.unsafe_set t (offset + 1) (Obj.repr a0);\n Uniform_array.unsafe_set t (offset + 2) (Obj.repr a1);\n Uniform_array.unsafe_set t (offset + 3) (Obj.repr a2);\n Uniform_array.unsafe_set t (offset + 4) (Obj.repr a3);\n Uniform_array.unsafe_set t (offset + 5) (Obj.repr a4);\n Uniform_array.unsafe_set t (offset + 6) (Obj.repr a5);\n Uniform_array.unsafe_set t (offset + 7) (Obj.repr a6);\n Uniform_array.unsafe_set t (offset + 8) (Obj.repr a7);\n Uniform_array.unsafe_set t (offset + 9) (Obj.repr a8);\n Uniform_array.unsafe_set t (offset + 10) (Obj.repr a9);\n Uniform_array.unsafe_set t (offset + 11) (Obj.repr a10);\n Uniform_array.unsafe_set t (offset + 12) (Obj.repr a11);\n Uniform_array.unsafe_set t (offset + 13) (Obj.repr a12);\n pointer\n ;;\n\n let new14 t a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 a13 =\n let pointer = malloc t in\n let offset = Pointer.header_index pointer in\n Uniform_array.unsafe_set t (offset + 1) (Obj.repr a0);\n Uniform_array.unsafe_set t (offset + 2) (Obj.repr a1);\n Uniform_array.unsafe_set t (offset + 3) (Obj.repr a2);\n Uniform_array.unsafe_set t (offset + 4) (Obj.repr a3);\n Uniform_array.unsafe_set t (offset + 5) (Obj.repr a4);\n Uniform_array.unsafe_set t (offset + 6) (Obj.repr a5);\n Uniform_array.unsafe_set t (offset + 7) (Obj.repr a6);\n Uniform_array.unsafe_set t (offset + 8) (Obj.repr a7);\n Uniform_array.unsafe_set t (offset + 9) (Obj.repr a8);\n Uniform_array.unsafe_set t (offset + 10) (Obj.repr a9);\n Uniform_array.unsafe_set t (offset + 11) (Obj.repr a10);\n Uniform_array.unsafe_set t (offset + 12) (Obj.repr a11);\n Uniform_array.unsafe_set t (offset + 13) (Obj.repr a12);\n Uniform_array.unsafe_set t (offset + 14) (Obj.repr a13);\n pointer\n ;;\n\n let get t p slot = Obj.obj (Uniform_array.get t (Pointer.slot_index p slot))\n\n let unsafe_get t p slot =\n Obj.obj (Uniform_array.unsafe_get t (Pointer.slot_index p slot))\n ;;\n\n let set t p slot x = Uniform_array.set t (Pointer.slot_index p slot) (Obj.repr x)\n\n let unsafe_set t p slot x =\n Uniform_array.unsafe_set t (Pointer.slot_index p slot) (Obj.repr x)\n ;;\n\n let get_tuple (type tuple) (t : (tuple, _) Slots.t t) pointer =\n let metadata = metadata t in\n let len = metadata.slots_per_tuple in\n if len = 1\n then get t pointer Slot.t0\n else\n (Obj.magic\n (Uniform_array.sub t ~pos:(Pointer.first_slot_index pointer) ~len\n : Obj.t Uniform_array.t)\n : tuple)\n ;;\nend\n\ninclude Pool\n\nmodule Unsafe = struct\n include Pool\n\n let create slots ~capacity = create_with_dummy slots ~capacity ~dummy:None\nend\n\nmodule Debug (Pool : S) = struct\n open Pool\n\n let check_invariant = ref true\n let show_messages = ref true\n\n let debug name ts arg sexp_of_arg sexp_of_result f =\n let prefix = \"Pool.\" in\n if !check_invariant then List.iter ts ~f:(invariant ignore);\n if !show_messages then Debug.eprints (concat [ prefix; name ]) arg sexp_of_arg;\n let result_or_exn = Result.try_with f in\n if !show_messages\n then\n Debug.eprints\n (concat [ prefix; name; \" result\" ])\n result_or_exn\n [%sexp_of: (result, exn) Result.t];\n Result.ok_exn result_or_exn\n ;;\n\n module Slots = Slots\n module Slot = Slot\n\n module Pointer = struct\n open Pointer\n\n type nonrec 'slots t = 'slots t [@@deriving sexp_of, typerep]\n\n let phys_compare t1 t2 =\n debug\n \"Pointer.phys_compare\"\n []\n (t1, t2)\n [%sexp_of: _ t * _ t]\n [%sexp_of: int]\n (fun () -> phys_compare t1 t2)\n ;;\n\n let phys_equal t1 t2 =\n debug\n \"Pointer.phys_equal\"\n []\n (t1, t2)\n [%sexp_of: _ t * _ t]\n [%sexp_of: bool]\n (fun () -> phys_equal t1 t2)\n ;;\n\n let is_null t =\n debug \"Pointer.is_null\" [] t [%sexp_of: _ t] [%sexp_of: bool] (fun () -> is_null t)\n ;;\n\n let null = null\n\n module Id = struct\n open Id\n\n type nonrec t = t [@@deriving bin_io, sexp]\n\n let of_int63 i =\n debug \"Pointer.Id.of_int63\" [] i [%sexp_of: Int63.t] [%sexp_of: t] (fun () ->\n of_int63 i)\n ;;\n\n let to_int63 t =\n debug \"Pointer.Id.to_int63\" [] t [%sexp_of: t] [%sexp_of: Int63.t] (fun () ->\n to_int63 t)\n ;;\n end\n end\n\n type nonrec 'slots t = 'slots t [@@deriving sexp_of]\n\n let invariant = invariant\n let length = length\n\n let id_of_pointer t pointer =\n debug\n \"id_of_pointer\"\n [ t ]\n pointer\n [%sexp_of: _ Pointer.t]\n [%sexp_of: Pointer.Id.t]\n (fun () -> id_of_pointer t pointer)\n ;;\n\n let pointer_of_id_exn t id =\n debug\n \"pointer_of_id_exn\"\n [ t ]\n id\n [%sexp_of: Pointer.Id.t]\n [%sexp_of: _ Pointer.t]\n (fun () -> pointer_of_id_exn t id)\n ;;\n\n let pointer_is_valid t pointer =\n debug\n \"pointer_is_valid\"\n [ t ]\n pointer\n [%sexp_of: _ Pointer.t]\n [%sexp_of: bool]\n (fun () -> pointer_is_valid t pointer)\n ;;\n\n let create slots ~capacity ~dummy =\n debug \"create\" [] capacity [%sexp_of: int] [%sexp_of: _ t] (fun () ->\n create slots ~capacity ~dummy)\n ;;\n\n let max_capacity ~slots_per_tuple =\n debug \"max_capacity\" [] slots_per_tuple [%sexp_of: int] [%sexp_of: int] (fun () ->\n max_capacity ~slots_per_tuple)\n ;;\n\n let capacity t =\n debug \"capacity\" [ t ] t [%sexp_of: _ t] [%sexp_of: int] (fun () -> capacity t)\n ;;\n\n let grow ?capacity t =\n debug\n \"grow\"\n [ t ]\n (`capacity capacity)\n [%sexp_of: [ `capacity of int option ]]\n [%sexp_of: _ t]\n (fun () -> grow ?capacity t)\n ;;\n\n let is_full t =\n debug \"is_full\" [ t ] t [%sexp_of: _ t] [%sexp_of: bool] (fun () -> is_full t)\n ;;\n\n let unsafe_free t p =\n debug \"unsafe_free\" [ t ] p [%sexp_of: _ Pointer.t] [%sexp_of: unit] (fun () ->\n unsafe_free t p)\n ;;\n\n let free t p =\n debug \"free\" [ t ] p [%sexp_of: _ Pointer.t] [%sexp_of: unit] (fun () -> free t p)\n ;;\n\n let debug_new t f = debug \"new\" [ t ] () [%sexp_of: unit] [%sexp_of: _ Pointer.t] f\n let new1 t a0 = debug_new t (fun () -> new1 t a0)\n let new2 t a0 a1 = debug_new t (fun () -> new2 t a0 a1)\n let new3 t a0 a1 a2 = debug_new t (fun () -> new3 t a0 a1 a2)\n let new4 t a0 a1 a2 a3 = debug_new t (fun () -> new4 t a0 a1 a2 a3)\n let new5 t a0 a1 a2 a3 a4 = debug_new t (fun () -> new5 t a0 a1 a2 a3 a4)\n let new6 t a0 a1 a2 a3 a4 a5 = debug_new t (fun () -> new6 t a0 a1 a2 a3 a4 a5)\n let new7 t a0 a1 a2 a3 a4 a5 a6 = debug_new t (fun () -> new7 t a0 a1 a2 a3 a4 a5 a6)\n\n let new8 t a0 a1 a2 a3 a4 a5 a6 a7 =\n debug_new t (fun () -> new8 t a0 a1 a2 a3 a4 a5 a6 a7)\n ;;\n\n let new9 t a0 a1 a2 a3 a4 a5 a6 a7 a8 =\n debug_new t (fun () -> new9 t a0 a1 a2 a3 a4 a5 a6 a7 a8)\n ;;\n\n let new10 t a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 =\n debug_new t (fun () -> new10 t a0 a1 a2 a3 a4 a5 a6 a7 a8 a9)\n ;;\n\n let new11 t a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 =\n debug_new t (fun () -> new11 t a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10)\n ;;\n\n let new12 t a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 =\n debug_new t (fun () -> new12 t a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11)\n ;;\n\n let new13 t a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 =\n debug_new t (fun () -> new13 t a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12)\n ;;\n\n let new14 t a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 a13 =\n debug_new t (fun () -> new14 t a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 a13)\n ;;\n\n let get_tuple t pointer =\n debug \"get_tuple\" [ t ] pointer [%sexp_of: _ Pointer.t] [%sexp_of: _] (fun () ->\n get_tuple t pointer)\n ;;\n\n let debug_get name f t pointer =\n debug name [ t ] pointer [%sexp_of: _ Pointer.t] [%sexp_of: _] (fun () ->\n f t pointer)\n ;;\n\n let get t pointer slot = debug_get \"get\" get t pointer slot\n let unsafe_get t pointer slot = debug_get \"unsafe_get\" unsafe_get t pointer slot\n\n let debug_set name f t pointer slot a =\n debug name [ t ] pointer [%sexp_of: _ Pointer.t] [%sexp_of: unit] (fun () ->\n f t pointer slot a)\n ;;\n\n let set t pointer slot a = debug_set \"set\" set t pointer slot a\n let unsafe_set t pointer slot a = debug_set \"unsafe_set\" unsafe_set t pointer slot a\nend\n\nmodule Error_check (Pool : S) = struct\n open Pool\n module Slots = Slots\n module Slot = Slot\n\n module Pointer = struct\n type 'slots t =\n { mutable is_valid : bool\n ; pointer : 'slots Pointer.t\n }\n [@@deriving sexp_of, typerep]\n\n let create pointer = { is_valid = true; pointer }\n let null () = { is_valid = false; pointer = Pointer.null () }\n let phys_compare t1 t2 = Pointer.phys_compare t1.pointer t2.pointer\n let phys_equal t1 t2 = Pointer.phys_equal t1.pointer t2.pointer\n let is_null t = Pointer.is_null t.pointer\n\n let follow t =\n if not t.is_valid\n then failwiths ~here:[%here] \"attempt to use invalid pointer\" t [%sexp_of: _ t];\n t.pointer\n ;;\n\n let invalidate t = t.is_valid <- false\n\n module Id = Pointer.Id\n end\n\n type 'slots t = 'slots Pool.t [@@deriving sexp_of]\n\n let invariant = invariant\n let length = length\n\n let pointer_is_valid t { Pointer.is_valid; pointer } =\n is_valid && pointer_is_valid t pointer\n ;;\n\n (* We don't do [Pointer.follow pointer], because that would disallow [id_of_pointer t\n (Pointer.null ())]. *)\n let id_of_pointer t pointer = id_of_pointer t pointer.Pointer.pointer\n\n let pointer_of_id_exn t id =\n let pointer = pointer_of_id_exn t id in\n let is_valid = Pool.pointer_is_valid t pointer in\n { Pointer.is_valid; pointer }\n ;;\n\n let create = create\n let capacity = capacity\n let max_capacity = max_capacity\n let grow = grow\n let is_full = is_full\n let get_tuple t p = get_tuple t (Pointer.follow p)\n let get t p = get t (Pointer.follow p)\n let unsafe_get t p = unsafe_get t (Pointer.follow p)\n let set t p slot v = set t (Pointer.follow p) slot v\n let unsafe_set t p slot v = unsafe_set t (Pointer.follow p) slot v\n\n let unsafe_free t p =\n unsafe_free t (Pointer.follow p);\n Pointer.invalidate p\n ;;\n\n let free t p =\n free t (Pointer.follow p);\n Pointer.invalidate p\n ;;\n\n let new1 t a0 = Pointer.create (Pool.new1 t a0)\n let new2 t a0 a1 = Pointer.create (Pool.new2 t a0 a1)\n let new3 t a0 a1 a2 = Pointer.create (Pool.new3 t a0 a1 a2)\n let new4 t a0 a1 a2 a3 = Pointer.create (Pool.new4 t a0 a1 a2 a3)\n let new5 t a0 a1 a2 a3 a4 = Pointer.create (Pool.new5 t a0 a1 a2 a3 a4)\n let new6 t a0 a1 a2 a3 a4 a5 = Pointer.create (Pool.new6 t a0 a1 a2 a3 a4 a5)\n let new7 t a0 a1 a2 a3 a4 a5 a6 = Pointer.create (Pool.new7 t a0 a1 a2 a3 a4 a5 a6)\n\n let new8 t a0 a1 a2 a3 a4 a5 a6 a7 =\n Pointer.create (Pool.new8 t a0 a1 a2 a3 a4 a5 a6 a7)\n ;;\n\n let new9 t a0 a1 a2 a3 a4 a5 a6 a7 a8 =\n Pointer.create (Pool.new9 t a0 a1 a2 a3 a4 a5 a6 a7 a8)\n ;;\n\n let new10 t a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 =\n Pointer.create (Pool.new10 t a0 a1 a2 a3 a4 a5 a6 a7 a8 a9)\n ;;\n\n let new11 t a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 =\n Pointer.create (Pool.new11 t a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10)\n ;;\n\n let new12 t a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 =\n Pointer.create (Pool.new12 t a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11)\n ;;\n\n let new13 t a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 =\n Pointer.create (Pool.new13 t a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12)\n ;;\n\n let new14 t a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 a13 =\n Pointer.create (Pool.new14 t a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 a13)\n ;;\nend\n","open! Import\nmodule Int = Int0\nmodule String = String0\n\n(** Each single_error is a path indicating the location within the datastructure in\n question that is being validated, along with an error message. *)\ntype single_error =\n { path : string list\n ; error : Error.t\n }\n\ntype t = single_error list\ntype 'a check = 'a -> t\n\nlet pass : t = []\n\nlet fails message a sexp_of_a =\n [ { path = []; error = Error.create message a sexp_of_a } ]\n;;\n\nlet fail message = [ { path = []; error = Error.of_string message } ]\nlet failf format = Printf.ksprintf fail format\nlet fail_s sexp = [ { path = []; error = Error.create_s sexp } ]\nlet combine t1 t2 = t1 @ t2\nlet of_list = List.concat\n\nlet name name t =\n match t with\n | [] -> [] (* when successful, avoid the allocation of a closure for [~f], below *)\n | _ -> List.map t ~f:(fun { path; error } -> { path = name :: path; error })\n;;\n\nlet name_list n l = name n (of_list l)\nlet fail_fn message _ = fail message\nlet pass_bool (_ : bool) = pass\nlet pass_unit (_ : unit) = pass\n\nlet protect f v =\n try f v with\n | exn ->\n fail_s (Sexp.message \"Exception raised during validation\" [ \"\", sexp_of_exn exn ])\n;;\n\nlet try_with f =\n protect\n (fun () ->\n f ();\n pass)\n ()\n;;\n\nlet path_string path = String.concat ~sep:\".\" path\n\nlet errors t =\n List.map t ~f:(fun { path; error } ->\n Error.to_string_hum (Error.tag error ~tag:(path_string path)))\n;;\n\nlet result_fail t =\n Or_error.error\n \"validation errors\"\n (List.map t ~f:(fun { path; error } -> path_string path, error))\n (sexp_of_list (sexp_of_pair sexp_of_string Error.sexp_of_t))\n[@@cold] [@@inline never] [@@local never] [@@specialise never]\n;;\n\n(** [result] is carefully implemented so that it can be inlined -- calling [result_fail],\n which is not inlineable, is key to this. *)\nlet result t = if List.is_empty t then Ok () else result_fail t\n\nlet maybe_raise t = Or_error.ok_exn (result t)\nlet valid_or_error x check = Or_error.map (result (protect check x)) ~f:(fun () -> x)\n\nlet field record fld f =\n let v = Field.get fld record in\n let result = protect f v in\n name (Field.name fld) result\n;;\n\nlet field_folder record check =\n ();\n fun acc fld -> field record fld check :: acc\n;;\n\nlet field_direct_folder check =\n Staged.stage (fun acc fld _record v ->\n match protect check v with\n | [] -> acc\n | result -> name (Field.name fld) result :: acc)\n;;\n\nlet all checks v =\n let rec loop checks v errs =\n match checks with\n | [] -> errs\n | check :: checks ->\n (match protect check v with\n | [] -> loop checks v errs\n | err -> loop checks v (err :: errs))\n in\n of_list (List.rev (loop checks v []))\n;;\n\nlet of_result f =\n protect (fun v ->\n match f v with\n | Ok () -> pass\n | Error error -> fail error)\n;;\n\nlet of_error f =\n protect (fun v ->\n match f v with\n | Ok () -> pass\n | Error error -> [ { path = []; error } ])\n;;\n\nlet booltest f ~if_false = protect (fun v -> if f v then pass else fail if_false)\n\nlet pair ~fst ~snd (fst_value, snd_value) =\n of_list [ name \"fst\" (protect fst fst_value); name \"snd\" (protect snd snd_value) ]\n;;\n\nlet list_indexed check list =\n List.mapi list ~f:(fun i el -> name (Int.to_string (i + 1)) (protect check el))\n |> of_list\n;;\n\nlet list ~name:extract_name check list =\n List.map list ~f:(fun el ->\n match protect check el with\n | [] -> []\n | t ->\n (* extra level of protection in case extract_name throws an exception *)\n protect (fun t -> name (extract_name el) t) t)\n |> of_list\n;;\n\nlet alist ~name f list' = list (fun (_, x) -> f x) list' ~name:(fun (key, _) -> name key)\nlet first_failure t1 t2 = if List.is_empty t1 then t2 else t1\n\nlet of_error_opt = function\n | None -> pass\n | Some error -> fail error\n;;\n\nlet bounded ~name ~lower ~upper ~compare x =\n match Maybe_bound.compare_to_interval_exn ~lower ~upper ~compare x with\n | In_range -> pass\n | Below_lower_bound ->\n (match lower with\n | Unbounded -> assert false\n | Incl incl -> fail (Printf.sprintf \"value %s < bound %s\" (name x) (name incl))\n | Excl excl -> fail (Printf.sprintf \"value %s <= bound %s\" (name x) (name excl)))\n | Above_upper_bound ->\n (match upper with\n | Unbounded -> assert false\n | Incl incl -> fail (Printf.sprintf \"value %s > bound %s\" (name x) (name incl))\n | Excl excl -> fail (Printf.sprintf \"value %s >= bound %s\" (name x) (name excl)))\n;;\n\nmodule Infix = struct\n let ( ++ ) t1 t2 = combine t1 t2\nend\n","open! Core_kernel\nopen! Import\n\nmodule Cpuset = struct\n include Validated.Make (struct\n type t = Int.Set.t [@@deriving sexp]\n\n let here = [%here]\n\n let validate t =\n Validate.first_failure\n (Int.validate_lbound ~min:(Incl 1) (Int.Set.length t))\n (Int.Set.to_list t\n |> List.map ~f:Int.validate_non_negative\n |> Validate.name_list \"Thread_pool_cpuset\")\n ;;\n end)\n\n let equal t1 t2 = Int.Set.equal (t1 |> raw) (t2 |> raw)\nend\n\ntype t =\n | Inherit\n | Cpuset of Cpuset.t\n[@@deriving sexp]\n","open Core_kernel\n\ntype 'a t = 'a\n\n(* This [Obj.magic] is OK because we never allow user code access to [none] (except via\n [unsafe_value]. We disallow [_ Uopt.t Uopt.t], so there is no chance of confusing\n [none] with [some none]. And [float Uopt.t array] is similarly disallowed. *)\nlet none = \"Uopt.none\" |> (Obj.magic : string -> _ t)\nlet is_none t = phys_equal t none\nlet is_some t = not (is_none t)\nlet invariant invariant_a t = if is_some t then invariant_a t\nlet sexp_of_t sexp_of_a t = if is_none t then [%sexp None] else [%sexp Some (t : a)]\nlet some a = a\nlet value_exn t = if is_none t then failwith \"Uopt.value_exn\" else t\nlet unsafe_value t = t\nlet to_option t = if is_none t then None else Some t\n\nlet of_option = function\n | None -> none\n | Some a -> some a\n;;\n\nmodule Optional_syntax = struct\n module Optional_syntax = struct\n let is_none = is_none\n let unsafe_value = unsafe_value\n end\nend\n","(* Be sure and first read the implementation overview in timing_wheel_intf.ml.\n\n A timing wheel is represented as an array of \"levels\", where each level is an array of\n \"slots\". Each slot represents a range of keys, and holds elements associated with\n those keys. Each level is determined by two parameters: [bits], the number of key bits\n that that level is responsible for distinguishing, and [bits_per_slot], the size of the\n range of keys that correspond to a single slot in the array. Conceptually, each level\n breaks up all possible keys into ranges of size [2^bits_per_slot]. The length of a\n level array is [2^bits], and the array is used like a circular buffer to traverse the\n ranges as the timing wheel's [min_allowed_key] increases. A key [k], if stored in the\n level, is stored at index [(k / 2^bits_per_slot) mod 2^bits].\n\n The settings of the [bits] values are configurable by user code using [Level_bits],\n although there is a reasonable default setting. Given the [bits] values, the\n [bits_per_slot] are chosen so that [bits_per_slot] at level [i] is the sum of the\n [bits] at all lower levels. Thus, a slot's range at level [i] is as large as the\n entire range of the array at level [i - 1].\n\n Each level has a [min_allowed_key] and a [max_allowed_key] that determine the range of\n keys that it currently represents. The crucial invariant of the timing wheel data\n structure is that the [min_allowed_key] at level [i] is no more than the\n [max_allowed_key + 1] of level [i - 1]. This ensures that the levels can represent all\n keys from the [min_allowed_key] of the lowest level to the [max_allowed_key] of the\n highest level. The [increase_min_allowed_key] function is responsible for restoring\n this invariant.\n\n At level 0, [bits_per_slot = 0], and so the size of each slot is [1]. That is, level 0\n precisely distinguishes all the keys between its [min_allowed_key] (which is the same\n as the [min_allowed_key] of the entire timing wheel) and [max_allowed_key]. As the\n levels increase, the [min_allowed_key] increases, the [bits_per_slot] increases, and\n the range of keys stored in the level increases (dramatically).\n\n The idea of the implementation is similar to the hierarchical approach described in:\n\n {v\n Hashed and Hierarchical Timing Wheels:\n Efficient Data Structures for Implementing a Timer Facility\n\n Varghese & Lauck, 1996\n v}\n\n However, the code is completely new. *)\n\nopen! Core_kernel\nopen! Import\nopen! Timing_wheel_intf\nmodule Pool = Tuple_pool\nmodule Time_ns = Core_kernel_private.Time_ns_alternate_sexp\n\nlet sexp_of_t_style : [ `Pretty | `Internal ] ref = ref `Pretty\n\n(* [{max,min}_time] are bounds on the times supported by a timing wheel. *)\n\nlet max_time = Time_ns.max_value_representable\nlet min_time = Time_ns.epoch\n\nmodule Num_key_bits : sig\n type t = private int [@@deriving compare, sexp]\n\n include Comparable with type t := t\n include Invariant.S with type t := t\n\n val zero : t\n\n (* val min_value : t *)\n\n val max_value : t\n val to_int : t -> int\n val of_int : int -> t\n val ( + ) : t -> t -> t\n val ( - ) : t -> t -> t\n val pow2 : t -> Int63.t\nend = struct\n include Int\n\n let min_value = 0\n\n (** We support all non-negative [Time_ns.t] values. *)\n let max_value = Int63.num_bits - 1\n\n let invariant t =\n assert (t >= min_value);\n assert (t <= max_value)\n ;;\n\n let of_int i =\n invariant i;\n i\n ;;\n\n let ( + ) t1 t2 =\n let t = t1 + t2 in\n invariant t;\n t\n ;;\n\n let ( - ) t1 t2 =\n let t = t1 - t2 in\n invariant t;\n t\n ;;\n\n let pow2 t = Int63.shift_left Int63.one t\nend\n\nmodule Level_bits = struct\n type t = Num_key_bits.t list [@@deriving compare, sexp]\n\n let max_num_bits = (Num_key_bits.max_value :> int)\n let num_bits_internal t = List.fold t ~init:Num_key_bits.zero ~f:Num_key_bits.( + )\n let num_bits t = (num_bits_internal t :> int)\n\n let invariant t =\n assert (not (List.is_empty t));\n List.iter t ~f:(fun num_key_bits ->\n Num_key_bits.invariant num_key_bits;\n assert (Num_key_bits.( > ) num_key_bits Num_key_bits.zero));\n Num_key_bits.invariant (num_bits_internal t)\n ;;\n\n let t_of_sexp sexp =\n let t = sexp |> [%of_sexp: t] in\n invariant t;\n t\n ;;\n\n let create_exn ?(extend_to_max_num_bits = false) ints =\n if List.is_empty ints then failwith \"Level_bits.create_exn requires a nonempty list\";\n if List.exists ints ~f:(fun bits -> bits <= 0)\n then\n raise_s\n [%message \"Level_bits.create_exn got nonpositive num bits\" ~_:(ints : int list)];\n let num_bits = List.fold ints ~init:0 ~f:( + ) in\n if num_bits > max_num_bits\n then\n raise_s\n [%message\n \"Level_bits.create_exn got too many bits\"\n ~_:(ints : int list)\n ~got:(num_bits : int)\n (max_num_bits : int)];\n let ints =\n if extend_to_max_num_bits\n then ints @ List.init (max_num_bits - num_bits) ~f:(const 1)\n else ints\n in\n List.map ints ~f:Num_key_bits.of_int\n ;;\n\n let default = create_exn [ 11; 10; 10; 10; 10; 10; 1 ]\n\n let trim t ~max_num_bits =\n if Num_key_bits.( <= ) (num_bits_internal t) max_num_bits\n then t\n else (\n let rec loop t ~remaining =\n match t with\n | [] -> []\n | b :: t ->\n if Num_key_bits.( >= ) b remaining\n then [ remaining ]\n else b :: loop t ~remaining:(Num_key_bits.( - ) remaining b)\n in\n loop t ~remaining:max_num_bits)\n ;;\nend\n\nmodule Alarm_precision : sig\n include Alarm_precision\n\n val num_key_bits : t -> Num_key_bits.t\n val interval_num : t -> Time_ns.t -> Int63.t\n val interval_num_start : t -> Int63.t -> Time_ns.t\nend = struct\n (** [t] is represented as the log2 of a number of nanoseconds. *)\n type t = int [@@deriving compare, hash]\n\n let equal = [%compare.equal: t]\n let num_key_bits t = t |> Num_key_bits.of_int\n\n let to_span t =\n if t < 0\n then\n raise_s\n [%message\n \"[Alarm_precision.to_span] of negative power of two nanoseconds\" ~_:(t : int)];\n Int63.(shift_left one) t |> Time_ns.Span.of_int63_ns\n ;;\n\n let sexp_of_t t = [%sexp (t |> to_span : Time_ns.Span.t)]\n let one_nanosecond = 0\n let about_one_microsecond = 10\n let about_one_millisecond = 20\n let about_one_second = 30\n let about_one_day = 46\n let mul t ~pow2 = t + pow2\n let div t ~pow2 = t - pow2\n let interval_num t time = Int63.shift_right (time |> Time_ns.to_int63_ns_since_epoch) t\n\n let interval_num_start t interval_num =\n Int63.shift_left interval_num t |> Time_ns.of_int63_ns_since_epoch\n ;;\n\n let of_span_floor_pow2_ns span =\n if Time_ns.Span.( <= ) span Time_ns.Span.zero\n then\n raise_s\n [%message\n \"[Alarm_precision.of_span_floor_pow2_ns] got non-positive span\"\n (span : Time_ns.Span.t)];\n span |> Time_ns.Span.to_int63_ns |> Int63.floor_log2\n ;;\n\n let of_span = of_span_floor_pow2_ns\n\n module Unstable = struct\n module T = struct\n type nonrec t = t [@@deriving compare]\n\n let of_binable = of_span_floor_pow2_ns\n let to_binable = to_span\n let of_sexpable = of_span_floor_pow2_ns\n let to_sexpable = to_span\n end\n\n include T\n include Binable.Of_binable_without_uuid [@alert \"-legacy\"] (Time_ns.Span) (T)\n include Sexpable.Of_sexpable (Time_ns.Span) (T)\n end\nend\n\nmodule Config = struct\n let level_bits_default = Level_bits.default\n\n type t =\n { alarm_precision : Alarm_precision.Unstable.t\n ; level_bits : Level_bits.t [@default level_bits_default]\n ; capacity : int option [@sexp.option]\n }\n [@@deriving fields, sexp]\n\n let alarm_precision t = Alarm_precision.to_span t.alarm_precision\n\n (* [max_num_level_bits alarm_precision] returns the number of level bits needed for a\n timing wheel with the specified [alarm_precision] to be able to represent all\n possible times from [Time_ns.epoch] onward. Since non-negative times have 62 bits,\n we require [L <= 62 - A], where [A] is the number of alarm bits and [L] is the\n number of level bits. *)\n let max_num_level_bits alarm_precision =\n Num_key_bits.( - )\n Num_key_bits.max_value\n (Alarm_precision.num_key_bits alarm_precision)\n ;;\n\n let invariant t =\n Invariant.invariant [%here] t [%sexp_of: t] (fun () ->\n assert (\n Num_key_bits.( <= )\n (Level_bits.num_bits_internal t.level_bits)\n (max_num_level_bits t.alarm_precision));\n let check f = Invariant.check_field t f in\n Fields.iter\n ~alarm_precision:ignore\n ~capacity:ignore\n ~level_bits:(check Level_bits.invariant))\n ;;\n\n let create ?capacity ?(level_bits = level_bits_default) ~alarm_precision () =\n let level_bits =\n Level_bits.trim level_bits ~max_num_bits:(max_num_level_bits alarm_precision)\n in\n { alarm_precision; level_bits; capacity }\n ;;\n\n let microsecond_precision () =\n create\n ()\n ~alarm_precision:Alarm_precision.about_one_microsecond\n ~level_bits:(Level_bits.create_exn [ 10; 10; 6; 6; 5 ])\n ;;\n\n let durations t =\n List.folding_map\n t.level_bits\n ~init:(Alarm_precision.num_key_bits t.alarm_precision |> Num_key_bits.to_int)\n ~f:(fun num_bits_accum level_num_bits ->\n let num_bits_accum = num_bits_accum + (level_num_bits |> Num_key_bits.to_int) in\n let duration =\n Time_ns.Span.of_int63_ns\n (if num_bits_accum = Int63.num_bits - 1\n then Int63.max_value\n else Int63.shift_left Int63.one num_bits_accum)\n in\n num_bits_accum, duration)\n ;;\nend\n\n\n(** Timing wheel is implemented as a priority queue in which the keys are\n non-negative integers corresponding to the intervals of time. The priority queue is\n unlike a typical priority queue in that rather than having a \"delete min\" operation,\n it has a nondecreasing minimum allowed key, which corresponds to the current time,\n and an [increase_min_allowed_key] operation, which implements [advance_clock].\n [increase_min_allowed_key] as a side effect removes all elements from the timing\n wheel whose key is smaller than the new minimum, which implements firing the alarms\n whose time has expired.\n\n Adding elements to and removing elements from a timing wheel takes constant time,\n unlike a heap-based priority queue which takes log(N), where N is the number of\n elements in the heap. [increase_min_allowed_key] takes time proportional to the\n amount of increase in the min-allowed key, as compared to log(N) for a heap. It is\n these performance differences that motivate the existence of timing wheels and make\n them a good choice for maintaing a set of alarms. With a timing wheel, one can\n support any number of alarms paying constant overhead per alarm, while paying a\n small constant overhead per unit of time passed.\n\n As the minimum allowed key increases, the timing wheel does a lazy radix sort of the\n element keys, with level 0 handling the least significant [b_0] bits in a key, and\n each subsequent level [i] handling the next most significant [b_i] bits. The levels\n hold increasingly larger ranges of keys, where the union of all the levels can hold\n any key from [min_allowed_key t] to [max_allowed_key t]. When a key is added to the\n timing wheel, it is added at the lowest possible level that can store the key. As\n the minimum allowed key increases, timing-wheel elements move down levels until they\n reach level 0, and then are eventually removed. *)\nmodule Priority_queue : sig\n type 'a t [@@deriving sexp_of]\n type 'a priority_queue = 'a t\n\n module Key : Interval_num\n\n module Elt : sig\n (** An [Elt.t] represents an element that was added to a timing wheel. *)\n type 'a t [@@deriving sexp_of]\n\n val at : 'a priority_queue -> 'a t -> Time_ns.t\n val key : 'a priority_queue -> 'a t -> Key.t\n val value : 'a priority_queue -> 'a t -> 'a\n val null : unit -> 'a t\n end\n\n module Internal_elt : sig\n module Pool : sig\n type 'a t\n end\n\n type 'a t\n\n val key : 'a Pool.t -> 'a t -> Key.t\n val max_alarm_time : 'a Pool.t -> 'a t -> with_key:Key.t -> Time_ns.t\n val is_null : _ t -> bool\n val to_external : 'a t -> 'a Elt.t\n end\n\n val pool : 'a t -> 'a Internal_elt.Pool.t\n\n include Invariant.S1 with type 'a t := 'a t\n\n (** [create ?level_bits ()] creates a new empty timing wheel, [t], with [length t = 0]\n and [min_allowed_key t = 0]. *)\n val create : ?capacity:int -> ?level_bits:Level_bits.t -> unit -> 'a t\n\n (** [length t] returns the number of elements in the timing wheel. *)\n val length : _ t -> int\n\n (** [min_allowed_key t] is the minimum key that can be stored in [t]. This only\n indicates the possibility; there need not be an element [elt] in [t] with [Elt.key\n elt = min_allowed_key t]. This is not the same as the \"min_key\" operation in a\n typical priority queue.\n\n [min_allowed_key t] can increase over time, via calls to\n [increase_min_allowed_key]. *)\n val min_allowed_key : _ t -> Key.t\n\n (** [max_allowed_key t] is the maximum allowed key that can be stored in [t]. As\n [min_allowed_key] increases, so does [max_allowed_key]; however it is not the case\n that [max_allowed_key t - min_allowed_key t] is a constant. It is guaranteed that\n [max_allowed_key t >= min_allowed_key t + 2^B - 1],\n where [B] is the sum of the b_i in [level_bits]. *)\n val max_allowed_key : _ t -> Key.t\n\n val min_elt_ : 'a t -> 'a Internal_elt.t\n val internal_add : 'a t -> key:Key.t -> at:Time_ns.t -> 'a -> 'a Internal_elt.t\n\n (** [remove t elt] removes [elt] from [t]. It is an error if [elt] is not currently\n in [t], and this error may or may not be detected. *)\n val remove : 'a t -> 'a Elt.t -> unit\n\n val change : 'a t -> 'a Elt.t -> key:Key.t -> at:Time_ns.t -> unit\n\n (** [clear t] removes all elts from [t]. *)\n val clear : _ t -> unit\n\n val mem : 'a t -> 'a Elt.t -> bool\n\n (** [increase_min_allowed_key t ~key ~handle_removed] increases the minimum allowed\n key in [t] to [key], and removes all elements with keys less than [key], applying\n [handle_removed] to each element that is removed. If [key <= min_allowed_key t],\n then [increase_min_allowed_key] does nothing. Otherwise, if\n [increase_min_allowed_key] returns successfully, [min_allowed_key t = key].\n\n [increase_min_allowed_key] takes time proportional to [key - min_allowed_key t],\n although possibly less time.\n\n Behavior is unspecified if [handle_removed] accesses [t] in any way other than\n [Elt] functions. *)\n val increase_min_allowed_key\n : 'a t\n -> key:Key.t\n -> handle_removed:('a Elt.t -> unit)\n -> unit\n\n val iter : 'a t -> f:('a Elt.t -> unit) -> unit\n\n val fire_past_alarms\n : 'a t\n -> handle_fired:('a Elt.t -> unit)\n -> key:Key.t\n -> now:Time_ns.t\n -> unit\nend = struct\n (** Each slot in a level is a (possibly null) pointer to a circular doubly-linked list\n of elements. We pool the elements so that we can reuse them after they are removed\n from the timing wheel (either via [remove] or [increase_min_allowed_key]). In\n addition to storing the [key], [at], and [value] in the element, we store the\n [level_index] so that we can quickly get to the level holding an element when we\n [remove] it.\n\n We distinguish between [External_elt] and [Internal_elt], which are the same\n underneath. We maintain the invariant that an [Internal_elt] is either [null] or a\n valid pointer. On the other hand, [External_elt]s are returned to user code, so\n there is no guarantee of validity -- we always validate an [External_elt] before\n doing anything with it.\n\n It is therefore OK to use [Pool.Unsafe], because we will never attempt to access a\n slot of an invalid pointer. *)\n module Pool = Pool.Unsafe\n\n module Pointer = Pool.Pointer\n\n module Key : sig\n (** [Interval_num] is the public API. Everything following in the signature is\n for internal use. *)\n include\n Timing_wheel_intf.Interval_num\n\n (** [add_clamp_to_max] doesn't work at all with negative spans *)\n val add_clamp_to_max : t -> Span.t -> t\n\n val succ_clamp_to_max : t -> t\n\n (** [Slots_mask] is used to quickly determine a key's slot in a given level. *)\n module Slots_mask : sig\n type t = private Int63.t [@@deriving compare, sexp_of]\n\n val create : level_bits:Num_key_bits.t -> t\n val next_slot : t -> int -> int\n end\n\n (** [Min_key_in_same_slot_mask] is used to quickly determine the minimum key in the\n same slot as a given key. *)\n module Min_key_in_same_slot_mask : sig\n type t = private Int63.t [@@deriving compare, sexp_of]\n\n include Equal.S with type t := t\n\n val create : bits_per_slot:Num_key_bits.t -> t\n end\n\n val num_keys : Num_key_bits.t -> Span.t\n val min_key_in_same_slot : t -> Min_key_in_same_slot_mask.t -> t\n val slot : t -> bits_per_slot:Num_key_bits.t -> slots_mask:Slots_mask.t -> int\n end = struct\n module Slots_mask = struct\n type t = Int63.t [@@deriving compare, sexp_of]\n\n let create ~level_bits = Int63.( - ) (Num_key_bits.pow2 level_bits) Int63.one\n let next_slot t slot = (slot + 1) land Int63.to_int_exn t\n end\n\n let num_keys num_bits = Num_key_bits.pow2 num_bits\n\n module Min_key_in_same_slot_mask = struct\n include Int63\n\n let create ~bits_per_slot = bit_not (Num_key_bits.pow2 bits_per_slot - one)\n end\n\n module Span = struct\n include Int63\n\n let to_int63 t = t\n let of_int63 i = i\n let scale_int t i = t * of_int i\n end\n\n include Int63\n\n let of_int63 i = i\n let to_int63 t = t\n let add t i = t + i\n let add_clamp_to_max t i = if t > max_value - i then max_value else t + i\n let succ_clamp_to_max t = if t = max_value then max_value else succ t\n let sub t i = t - i\n let diff t1 t2 = t1 - t2\n\n let slot t ~(bits_per_slot : Num_key_bits.t) ~slots_mask =\n to_int_exn (bit_and (shift_right t (bits_per_slot :> int)) slots_mask)\n ;;\n\n let min_key_in_same_slot t min_key_in_same_slot_mask =\n bit_and t min_key_in_same_slot_mask\n ;;\n end\n\n module Min_key_in_same_slot_mask = Key.Min_key_in_same_slot_mask\n module Slots_mask = Key.Slots_mask\n\n module External_elt = struct\n\n (** The [pool_slots] here has nothing to do with the slots in a level array. This is\n for the slots in the pool tuple representing a level element. *)\n type 'a pool_slots =\n ( Key.t\n , Time_ns.t\n , 'a\n , int\n , 'a pool_slots Pointer.t\n , 'a pool_slots Pointer.t )\n Pool.Slots.t6\n [@@deriving sexp_of]\n\n type 'a t = 'a pool_slots Pointer.t [@@deriving sexp_of]\n\n let null = Pointer.null\n end\n\n module Internal_elt : sig\n module Pool : sig\n type 'a t [@@deriving sexp_of]\n\n include Invariant.S1 with type 'a t := 'a t\n\n val create : ?capacity:int -> unit -> _ t\n val is_full : _ t -> bool\n val grow : ?capacity:int -> 'a t -> 'a t\n end\n\n type 'a t = private 'a External_elt.t [@@deriving sexp_of]\n\n val null : unit -> _ t\n val is_null : _ t -> bool\n val is_valid : 'a Pool.t -> 'a t -> bool\n\n (** Dealing with [External_elt]s. *)\n\n val external_is_valid : 'a Pool.t -> 'a External_elt.t -> bool\n val to_external : 'a t -> 'a External_elt.t\n val of_external_exn : 'a Pool.t -> 'a External_elt.t -> 'a t\n val equal : 'a t -> 'a t -> bool\n val invariant : 'a Pool.t -> ('a -> unit) -> 'a t -> unit\n\n (** [create] returns an element whose [next] and [prev] are [null]. *)\n val create\n : 'a Pool.t\n -> key:Key.t\n (** [at] is used when the priority queue is used to implement a timing wheel. If\n unused, it will be [Time_ns.epoch]. *)\n -> at:Time_ns.t\n -> value:'a\n -> level_index:int\n -> 'a t\n\n val free : 'a Pool.t -> 'a t -> unit\n\n (** accessors *)\n\n val key : 'a Pool.t -> 'a t -> Key.t\n val at : 'a Pool.t -> 'a t -> Time_ns.t\n val level_index : 'a Pool.t -> 'a t -> int\n val next : 'a Pool.t -> 'a t -> 'a t\n val value : 'a Pool.t -> 'a t -> 'a\n\n (** mutators *)\n\n val set_key : 'a Pool.t -> 'a t -> Key.t -> unit\n val set_at : 'a Pool.t -> 'a t -> Time_ns.t -> unit\n val set_level_index : 'a Pool.t -> 'a t -> int -> unit\n\n (** [insert_at_end pool t ~to_add] treats [t] as the head of the list and adds [to_add]\n to the end of it. *)\n val insert_at_end : 'a Pool.t -> 'a t -> to_add:'a t -> unit\n\n (** [link_to_self pool t] makes [t] be a singleton circular doubly-linked list. *)\n val link_to_self : 'a Pool.t -> 'a t -> unit\n\n (** [unlink p t] unlinks [t] from the circularly doubly-linked list that it is in. It\n changes the pointers of [t]'s [prev] and [next] elts, but not [t]'s [prev] and\n [next] pointers. [unlink] is meaningless if [t] is a singleton. *)\n val unlink : 'a Pool.t -> 'a t -> unit\n\n (** Iterators. [iter p t ~init ~f] visits each element in the doubly-linked list\n containing [t], starting at [t], and following [next] pointers. [length] counts\n by visiting each element in the list. *)\n val iter : 'a Pool.t -> 'a t -> f:('a t -> unit) -> unit\n\n val length : 'a Pool.t -> 'a t -> int\n\n (** [max_alarm_time t elt ~with_key] finds the max [at] in [elt]'s list among the elts\n whose key is [with_key], returning [Time_ns.epoch] if the list is empty. *)\n val max_alarm_time : 'a Pool.t -> 'a t -> with_key:Key.t -> Time_ns.t\n end = struct\n type 'a pool_slots = 'a External_elt.pool_slots [@@deriving sexp_of]\n type 'a t = 'a External_elt.t [@@deriving sexp_of]\n\n let null = Pointer.null\n let is_null = Pointer.is_null\n let equal t1 t2 = Pointer.phys_equal t1 t2\n\n let create pool ~key ~at ~value ~level_index =\n Pool.new6 pool key at value level_index (null ()) (null ())\n ;;\n\n let free = Pool.free\n let key p t = Pool.get p t Pool.Slot.t0\n let set_key p t k = Pool.set p t Pool.Slot.t0 k\n let at p t = Pool.get p t Pool.Slot.t1\n let set_at p t x = Pool.set p t Pool.Slot.t1 x\n let value p t = Pool.get p t Pool.Slot.t2\n let level_index p t = Pool.get p t Pool.Slot.t3\n let set_level_index p t i = Pool.set p t Pool.Slot.t3 i\n let prev p t = Pool.get p t Pool.Slot.t4\n let set_prev p t x = Pool.set p t Pool.Slot.t4 x\n let next p t = Pool.get p t Pool.Slot.t5\n let set_next p t x = Pool.set p t Pool.Slot.t5 x\n let is_valid p t = Pool.pointer_is_valid p t\n let external_is_valid = is_valid\n\n let invariant pool invariant_a t =\n Invariant.invariant [%here] t [%sexp_of: _ t] (fun () ->\n assert (is_valid pool t);\n invariant_a (value pool t);\n let n = next pool t in\n assert (is_null n || Pointer.phys_equal t (prev pool n));\n let p = prev pool t in\n assert (is_null p || Pointer.phys_equal t (next pool p)))\n ;;\n\n module Pool = struct\n type 'a t = 'a pool_slots Pool.t [@@deriving sexp_of]\n\n let invariant _invariant_a t = Pool.invariant ignore t\n let create ?(capacity = 1) () = Pool.create Pool.Slots.t6 ~capacity\n let grow = Pool.grow\n let is_full = Pool.is_full\n end\n\n let to_external t = t\n\n let of_external_exn pool t =\n if is_valid pool t then t else raise_s [%message \"Timing_wheel got invalid alarm\"]\n ;;\n\n let unlink pool t =\n set_next pool (prev pool t) (next pool t);\n set_prev pool (next pool t) (prev pool t)\n ;;\n\n let link pool prev next =\n set_next pool prev next;\n set_prev pool next prev\n ;;\n\n let link_to_self pool t = link pool t t\n\n let insert_at_end pool t ~to_add =\n let prev = prev pool t in\n link pool prev to_add;\n link pool to_add t\n ;;\n\n let iter pool first ~f =\n let current = ref first in\n let continue = ref true in\n while !continue do\n (* We get [next] before calling [f] so that [f] can modify or [free] [!current]. *)\n let next = next pool !current in\n f !current;\n if phys_equal next first then continue := false else current := next\n done\n ;;\n\n let length pool first =\n let r = ref 0 in\n let current = ref first in\n let continue = ref true in\n while !continue do\n incr r;\n let next = next pool !current in\n if phys_equal next first then continue := false else current := next\n done;\n !r\n ;;\n\n let max_alarm_time pool first ~with_key =\n let max_alarm_time = ref Time_ns.epoch in\n let current = ref first in\n let continue = ref true in\n while !continue do\n let next = next pool !current in\n if Key.equal (key pool !current) with_key\n then max_alarm_time := Time_ns.max (at pool !current) !max_alarm_time;\n if phys_equal next first then continue := false else current := next\n done;\n !max_alarm_time\n ;;\n end\n\n module Level = struct\n (** For given level, one can break the bits into a key into three regions:\n\n {v\n | higher levels | this level | lower levels |\n v}\n\n \"Lower levels\" is [bits_per_slot] bits wide. \"This level\" is [bits] wide. *)\n type 'a t =\n { (* The [index] in the timing wheel's array of levels where this level is. *)\n index : int\n ; (* How many [bits] this level is responsible for. *)\n bits : Num_key_bits.t\n ; (* [slots_mask = Slots_mask.create ~level_bits:t.bits]. *)\n slots_mask : Slots_mask.t\n ; (* [bits_per_slot] is how many bits each slot distinguishes, and is the sum of of\n the [bits] of all the lower levels. *)\n bits_per_slot : Num_key_bits.t\n ; keys_per_slot : Key.Span.t\n ; min_key_in_same_slot_mask : Min_key_in_same_slot_mask.t\n ; (* [diff_max_min_allowed_key = keys_per_slot * Array.length slots - 1] *)\n diff_max_min_allowed_key : Key.Span.t\n ; (* [length] is the number of elts currently in this level. *)\n mutable length : int\n ; (* All elements at this level have their [key] satisfy [min_allowed_key <= key <=\n max_allowed_key]. Also, [min_allowed_key] is a multiple of [keys_per_slot]. *)\n mutable min_allowed_key : Key.t\n ; mutable max_allowed_key : Key.t\n ; (* [slots] holds the (possibly null) pointers to the circular doubly-linked lists\n of elts. [Array.length slots = 1 lsl bits]. *)\n slots : ('a Internal_elt.t array[@sexp.opaque])\n }\n [@@deriving fields, sexp_of]\n\n let slot t ~key =\n Key.slot key ~bits_per_slot:t.bits_per_slot ~slots_mask:t.slots_mask\n ;;\n\n let next_slot t slot = Slots_mask.next_slot t.slots_mask slot\n\n let min_key_in_same_slot t ~key =\n Key.min_key_in_same_slot key t.min_key_in_same_slot_mask\n ;;\n\n let compute_min_allowed_key t ~prev_level_max_allowed_key =\n (* This computation ensures that [t]'s [min_allowed_key] is as large as possible\n subject to the constraint that there is no inter-level gap. *)\n if Key.equal prev_level_max_allowed_key Key.max_value\n then Key.max_value\n else min_key_in_same_slot t ~key:(Key.succ prev_level_max_allowed_key)\n ;;\n end\n\n type 'a t =\n { mutable length : int\n ; mutable pool : 'a Internal_elt.Pool.t\n ; (* [min_elt] is either null or an element whose key is [elt_key_lower_bound]. *)\n mutable min_elt : 'a Internal_elt.t\n ; (* All elements in the priority queue have their key [>= elt_key_lower_bound]. *)\n mutable elt_key_lower_bound : Key.t\n ; levels : 'a Level.t array\n }\n [@@deriving fields, sexp_of]\n\n type 'a priority_queue = 'a t\n\n module Elt = struct\n type 'a t = 'a External_elt.t [@@deriving sexp_of]\n\n let null = External_elt.null\n let at p t = Internal_elt.at p.pool (Internal_elt.of_external_exn p.pool t)\n let key p t = Internal_elt.key p.pool (Internal_elt.of_external_exn p.pool t)\n let value p t = Internal_elt.value p.pool (Internal_elt.of_external_exn p.pool t)\n end\n\n let sexp_of_t_internal = sexp_of_t\n let is_empty t = length t = 0\n let num_levels t = Array.length t.levels\n let min_allowed_key t = Level.min_allowed_key t.levels.(0)\n let max_allowed_key t = Level.max_allowed_key t.levels.(num_levels t - 1)\n\n let internal_iter t ~f =\n if t.length > 0\n then (\n let pool = t.pool in\n let levels = t.levels in\n for level_index = 0 to Array.length levels - 1 do\n let level = levels.(level_index) in\n if level.length > 0\n then (\n let slots = level.slots in\n for slot_index = 0 to Array.length slots - 1 do\n let elt = slots.(slot_index) in\n if not (Internal_elt.is_null elt) then Internal_elt.iter pool elt ~f\n done)\n done)\n ;;\n\n let iter t ~f = internal_iter t ~f:(f : _ Elt.t -> unit :> _ Internal_elt.t -> unit)\n\n module Pretty = struct\n module Elt = struct\n type 'a t =\n { key : Key.t\n ; value : 'a\n }\n [@@deriving sexp_of]\n end\n\n type 'a t =\n { min_allowed_key : Key.t\n ; max_allowed_key : Key.t\n ; elts : 'a Elt.t list\n }\n [@@deriving sexp_of]\n end\n\n let pretty t =\n let pool = t.pool in\n { Pretty.min_allowed_key = min_allowed_key t\n ; max_allowed_key = max_allowed_key t\n ; elts =\n (let r = ref [] in\n internal_iter t ~f:(fun elt ->\n r\n := { Pretty.Elt.key = Internal_elt.key pool elt\n ; value = Internal_elt.value pool elt\n }\n :: !r);\n List.rev !r)\n }\n ;;\n\n let sexp_of_t sexp_of_a t =\n match !sexp_of_t_style with\n | `Internal -> [%sexp (t : a t_internal)]\n | `Pretty -> [%sexp (pretty t : a Pretty.t)]\n ;;\n\n let compute_diff_max_min_allowed_key ~level_bits ~bits_per_slot =\n let bits = Num_key_bits.( + ) level_bits bits_per_slot in\n if Num_key_bits.equal bits Num_key_bits.max_value\n then Key.Span.max_value\n else Key.Span.pred (Key.num_keys bits)\n ;;\n\n let invariant invariant_a t : unit =\n let pool = t.pool in\n let level_invariant level =\n Invariant.invariant [%here] level [%sexp_of: _ Level.t] (fun () ->\n let check f = Invariant.check_field level f in\n Level.Fields.iter\n ~index:(check (fun index -> assert (index >= 0)))\n ~bits:\n (check (fun bits -> assert (Num_key_bits.( > ) bits Num_key_bits.zero)))\n ~slots_mask:\n (check\n ([%test_result: Slots_mask.t]\n ~expect:(Slots_mask.create ~level_bits:level.bits)))\n ~bits_per_slot:\n (check (fun bits_per_slot ->\n assert (Num_key_bits.( >= ) bits_per_slot Num_key_bits.zero)))\n ~keys_per_slot:\n (check (fun keys_per_slot ->\n [%test_result: Key.Span.t]\n keys_per_slot\n ~expect:(Key.num_keys level.bits_per_slot)))\n ~min_key_in_same_slot_mask:\n (check (fun min_key_in_same_slot_mask ->\n assert (\n Min_key_in_same_slot_mask.equal\n min_key_in_same_slot_mask\n (Min_key_in_same_slot_mask.create\n ~bits_per_slot:level.bits_per_slot))))\n ~diff_max_min_allowed_key:\n (check\n ([%test_result: Key.Span.t]\n ~expect:\n (compute_diff_max_min_allowed_key\n ~level_bits:level.bits\n ~bits_per_slot:level.bits_per_slot)))\n ~length:\n (check (fun length ->\n assert (\n length\n = Array.fold level.slots ~init:0 ~f:(fun n elt ->\n if Internal_elt.is_null elt\n then n\n else n + Internal_elt.length pool elt))))\n ~min_allowed_key:\n (check (fun min_allowed_key ->\n assert (Key.( >= ) min_allowed_key Key.zero);\n if Key.( < ) min_allowed_key Key.max_value\n then\n [%test_result: Key.Span.t]\n (Key.rem min_allowed_key level.keys_per_slot)\n ~expect:Key.Span.zero))\n ~max_allowed_key:\n (check (fun max_allowed_key ->\n [%test_result: Key.t]\n max_allowed_key\n ~expect:\n (Key.add_clamp_to_max\n level.min_allowed_key\n level.diff_max_min_allowed_key)))\n ~slots:\n (check (fun slots ->\n Array.iter slots ~f:(fun elt ->\n if not (Internal_elt.is_null elt)\n then (\n Internal_elt.invariant pool invariant_a elt;\n Internal_elt.iter pool elt ~f:(fun elt ->\n assert (\n Key.( >= )\n (Internal_elt.key pool elt)\n level.min_allowed_key);\n assert (\n Key.( <= )\n (Internal_elt.key pool elt)\n level.max_allowed_key);\n assert (\n Key.( >= )\n (Internal_elt.key pool elt)\n t.elt_key_lower_bound);\n assert (Internal_elt.level_index pool elt = level.index);\n invariant_a (Internal_elt.value pool elt)))))))\n in\n Invariant.invariant [%here] t [%sexp_of: _ t_internal] (fun () ->\n let check f = Invariant.check_field t f in\n assert (Key.( >= ) (min_allowed_key t) Key.zero);\n assert (Key.( >= ) (max_allowed_key t) (min_allowed_key t));\n Fields.iter\n ~length:(check (fun length -> assert (length >= 0)))\n ~pool:(check (Internal_elt.Pool.invariant ignore))\n ~min_elt:\n (check (fun elt_ ->\n if not (Internal_elt.is_null elt_)\n then (\n assert (Internal_elt.is_valid t.pool elt_);\n assert (Key.equal t.elt_key_lower_bound (Internal_elt.key t.pool elt_)))))\n ~elt_key_lower_bound:\n (check (fun elt_key_lower_bound ->\n assert (Key.( >= ) elt_key_lower_bound (min_allowed_key t));\n assert (Key.( <= ) elt_key_lower_bound (max_allowed_key t));\n if not (Internal_elt.is_null t.min_elt)\n then\n assert (\n Key.equal elt_key_lower_bound (Internal_elt.key t.pool t.min_elt))))\n ~levels:\n (check (fun levels ->\n assert (num_levels t > 0);\n Array.iteri levels ~f:(fun level_index level ->\n assert (level_index = Level.index level);\n level_invariant level;\n if level_index > 0\n then (\n let prev_level = levels.(level_index - 1) in\n let module L = Level in\n [%test_result: Key.Span.t]\n (L.keys_per_slot level)\n ~expect:(Key.Span.succ prev_level.diff_max_min_allowed_key);\n [%test_result: Key.t]\n level.min_allowed_key\n ~expect:\n (Level.compute_min_allowed_key\n level\n ~prev_level_max_allowed_key:prev_level.max_allowed_key))))))\n ;;\n\n (** [min_elt_] returns [null] if it can't find the desired element. We wrap it up\n afterwards to return an [option]. *)\n let min_elt_ t =\n if is_empty t\n then Internal_elt.null ()\n else if not (Internal_elt.is_null t.min_elt)\n then t.min_elt\n else (\n let pool = t.pool in\n let min_elt_already_found = ref (Internal_elt.null ()) in\n let min_key_already_found = ref Key.max_value in\n let level_index = ref 0 in\n let num_levels = num_levels t in\n while !level_index < num_levels do\n let level = t.levels.(!level_index) in\n if Key.( > ) (Level.min_allowed_key level) !min_key_already_found\n then\n (* We don't need to consider any more levels. Quit the loop. *)\n level_index := num_levels\n else if level.length = 0\n then incr level_index\n else (\n (* Look in [level]. *)\n let slots = level.slots in\n let slot_min_key =\n ref\n (Level.min_key_in_same_slot\n level\n ~key:(Key.max level.min_allowed_key t.elt_key_lower_bound))\n in\n let slot = ref (Level.slot level ~key:!slot_min_key) in\n (* Find the first nonempty slot with a small enough [slot_min_key]. *)\n while\n Internal_elt.is_null slots.(!slot)\n && Key.( < ) !slot_min_key !min_key_already_found\n do\n slot := Level.next_slot level !slot;\n slot_min_key := Key.add !slot_min_key level.keys_per_slot\n done;\n let first = slots.(!slot) in\n if not (Internal_elt.is_null first)\n then (\n (* Visit all of the elts in this slot and find one with minimum key. *)\n let continue = ref true in\n let current = ref first in\n while !continue do\n let current_key = Internal_elt.key pool !current in\n if Key.( <= ) current_key !min_key_already_found\n then (\n min_elt_already_found := !current;\n min_key_already_found := current_key);\n let next = Internal_elt.next pool !current in\n (* If [!level_index = 0] then all elts in this slot have the same [key],\n i.e. [!slot_min_key]. So, we don't have to check any elements after\n [first]. This is a useful short cut in the common case that there are\n multiple elements in the same min slot in level 0. *)\n if phys_equal next first || !level_index = 0\n then continue := false\n else current := next\n done);\n (* Finished looking in [level]. Move up to the next level. *)\n incr level_index)\n done;\n t.min_elt <- !min_elt_already_found;\n t.elt_key_lower_bound <- !min_key_already_found;\n t.min_elt)\n ;;\n\n let[@cold] raise_add_elt_key_out_of_bounds t key =\n raise_s\n [%message\n \"Priority_queue.add_elt key out of bounds\"\n (key : Key.t)\n (min_allowed_key t : Key.t)\n (max_allowed_key t : Key.t)\n ~priority_queue:(t : _ t)]\n ;;\n\n let[@cold] raise_add_elt_key_out_of_level_bounds key level =\n raise_s\n [%message\n \"Priority_queue.add_elt key out of level bounds\"\n (key : Key.t)\n (level : _ Level.t)]\n ;;\n\n let add_elt t elt =\n let pool = t.pool in\n let key = Internal_elt.key pool elt in\n if not (Key.( >= ) key (min_allowed_key t) && Key.( <= ) key (max_allowed_key t))\n then raise_add_elt_key_out_of_bounds t key;\n (* Find the lowest level that will hold [elt]. *)\n let level_index =\n let level_index = ref 0 in\n while Key.( > ) key (Level.max_allowed_key t.levels.(!level_index)) do\n incr level_index\n done;\n !level_index\n in\n let level = t.levels.(level_index) in\n if not (Key.( >= ) key level.min_allowed_key && Key.( <= ) key level.max_allowed_key)\n then raise_add_elt_key_out_of_level_bounds key level;\n level.length <- level.length + 1;\n Internal_elt.set_level_index pool elt level_index;\n let slot = Level.slot level ~key in\n let slots = level.slots in\n let first = slots.(slot) in\n if not (Internal_elt.is_null first)\n then Internal_elt.insert_at_end pool first ~to_add:elt\n else (\n slots.(slot) <- elt;\n Internal_elt.link_to_self pool elt)\n ;;\n\n let internal_add_elt t elt =\n let key = Internal_elt.key t.pool elt in\n if Key.( < ) key t.elt_key_lower_bound\n then (\n t.min_elt <- elt;\n t.elt_key_lower_bound <- key);\n add_elt t elt;\n t.length <- t.length + 1\n ;;\n\n let[@cold] raise_got_invalid_key t key =\n raise_s\n [%message\n \"Timing_wheel.add_at_interval_num got invalid interval num\"\n ~interval_num:(key : Key.t)\n ~min_allowed_alarm_interval_num:(min_allowed_key t : Key.t)\n ~max_allowed_alarm_interval_num:(max_allowed_key t : Key.t)]\n ;;\n\n let ensure_valid_key t ~key =\n if Key.( < ) key (min_allowed_key t) || Key.( > ) key (max_allowed_key t)\n then raise_got_invalid_key t key\n ;;\n\n let internal_add t ~key ~at value =\n ensure_valid_key t ~key;\n if Internal_elt.Pool.is_full t.pool then t.pool <- Internal_elt.Pool.grow t.pool;\n let elt = Internal_elt.create t.pool ~key ~at ~value ~level_index:(-1) in\n internal_add_elt t elt;\n elt\n ;;\n\n (** [remove_or_re_add_elts] visits each element in the circular doubly-linked list\n [first]. If the element's key is [>= t_min_allowed_key], then it adds the element\n back at a lower level. If not, then it calls [handle_removed] and [free]s the\n element. *)\n let remove_or_re_add_elts\n t\n (level : _ Level.t)\n first\n ~t_min_allowed_key\n ~handle_removed\n =\n let pool = t.pool in\n let current = ref first in\n let continue = ref true in\n while !continue do\n (* We extract [next] from [current] first, because we will modify or [free]\n [current] before continuing the loop. *)\n let next = Internal_elt.next pool !current in\n level.length <- level.length - 1;\n if Key.( >= ) (Internal_elt.key pool !current) t_min_allowed_key\n then add_elt t !current\n else (\n t.length <- t.length - 1;\n handle_removed (Internal_elt.to_external !current);\n Internal_elt.free pool !current);\n if phys_equal next first then continue := false else current := next\n done\n ;;\n\n (** [increase_level_min_allowed_key] increases the [min_allowed_key] of [level] to as\n large a value as possible, but no more than [max_level_min_allowed_key].\n [t_min_allowed_key] is the minimum allowed key for the entire timing wheel. As\n elements are encountered, they are removed from the timing wheel if their key is\n smaller than [t_min_allowed_key], or added at a lower level if not. *)\n let increase_level_min_allowed_key\n t\n (level : _ Level.t)\n ~prev_level_max_allowed_key\n ~t_min_allowed_key\n ~handle_removed\n =\n let desired_min_allowed_key =\n Level.compute_min_allowed_key level ~prev_level_max_allowed_key\n in\n (* We require that [mod level.min_allowed_key level.keys_per_slot = 0]. So,\n we start [level_min_allowed_key] where that is true, and then increase it by\n [keys_per_slot] each iteration of the loop. *)\n let level_min_allowed_key =\n Level.min_key_in_same_slot\n level\n ~key:\n (Key.min\n desired_min_allowed_key\n (Key.max level.min_allowed_key t.elt_key_lower_bound))\n in\n let level_min_allowed_key = ref level_min_allowed_key in\n let slot = ref (Level.slot level ~key:!level_min_allowed_key) in\n let keys_per_slot = level.keys_per_slot in\n let slots = level.slots in\n while Key.( < ) !level_min_allowed_key desired_min_allowed_key do\n if level.length = 0\n then\n (* If no elements remain at this level, we can just set [min_allowed_key] to the\n desired value. *)\n level_min_allowed_key := desired_min_allowed_key\n else (\n let first = slots.(!slot) in\n if not (Internal_elt.is_null first)\n then (\n slots.(!slot) <- Internal_elt.null ();\n remove_or_re_add_elts t level first ~t_min_allowed_key ~handle_removed);\n slot := Level.next_slot level !slot;\n level_min_allowed_key\n := Key.add_clamp_to_max !level_min_allowed_key keys_per_slot)\n done;\n level.min_allowed_key <- desired_min_allowed_key;\n level.max_allowed_key\n <- Key.add_clamp_to_max desired_min_allowed_key level.diff_max_min_allowed_key\n ;;\n\n let increase_min_allowed_key t ~key ~handle_removed =\n if Key.( > ) key (min_allowed_key t)\n then (\n (* We increase the [min_allowed_key] of levels in order to restore the invariant\n that they have as large as possible a [min_allowed_key], while leaving no gaps\n in keys. *)\n let level_index = ref 0 in\n let prev_level_max_allowed_key = ref (Key.pred key) in\n let levels = t.levels in\n let num_levels = num_levels t in\n while !level_index < num_levels do\n let level = levels.(!level_index) in\n let min_allowed_key_before = level.min_allowed_key in\n increase_level_min_allowed_key\n t\n level\n ~prev_level_max_allowed_key:!prev_level_max_allowed_key\n ~t_min_allowed_key:key\n ~handle_removed;\n if Key.equal (Level.min_allowed_key level) min_allowed_key_before\n then\n (* This level did not shift. Don't shift any higher levels. *)\n level_index := num_levels\n else (\n (* Level [level_index] shifted. Consider shifting higher levels. *)\n level_index := !level_index + 1;\n prev_level_max_allowed_key := Level.max_allowed_key level)\n done;\n if Key.( > ) key t.elt_key_lower_bound\n then (\n (* We have removed [t.min_elt] or it was already null, so just set it to\n null. *)\n t.min_elt <- Internal_elt.null ();\n t.elt_key_lower_bound <- min_allowed_key t))\n ;;\n\n let create ?capacity ?level_bits () =\n let level_bits =\n match level_bits with\n | Some l -> l\n | None -> Level_bits.default\n in\n let _, _, levels =\n List.foldi\n level_bits\n ~init:(Num_key_bits.zero, Key.zero, [])\n ~f:(fun index\n (bits_per_slot, max_level_min_allowed_key, levels)\n (level_bits : Num_key_bits.t)\n ->\n let keys_per_slot = Key.num_keys bits_per_slot in\n let diff_max_min_allowed_key =\n compute_diff_max_min_allowed_key ~level_bits ~bits_per_slot\n in\n let min_key_in_same_slot_mask =\n Min_key_in_same_slot_mask.create ~bits_per_slot\n in\n let min_allowed_key =\n Key.min_key_in_same_slot max_level_min_allowed_key min_key_in_same_slot_mask\n in\n let max_allowed_key =\n Key.add_clamp_to_max min_allowed_key diff_max_min_allowed_key\n in\n let level =\n { Level.index\n ; bits = level_bits\n ; slots_mask = Slots_mask.create ~level_bits\n ; bits_per_slot\n ; keys_per_slot\n ; min_key_in_same_slot_mask\n ; diff_max_min_allowed_key\n ; length = 0\n ; min_allowed_key\n ; max_allowed_key\n ; slots =\n Array.create\n ~len:(Int63.to_int_exn (Num_key_bits.pow2 level_bits))\n (Internal_elt.null ())\n }\n in\n ( Num_key_bits.( + ) level_bits bits_per_slot\n , Key.succ_clamp_to_max max_allowed_key\n , level :: levels ))\n in\n { length = 0\n ; pool = Internal_elt.Pool.create ?capacity ()\n ; min_elt = Internal_elt.null ()\n ; elt_key_lower_bound = Key.zero\n ; levels = Array.of_list_rev levels\n }\n ;;\n\n let mem t elt = Internal_elt.external_is_valid t.pool elt\n\n let internal_remove t elt =\n let pool = t.pool in\n if Internal_elt.equal elt t.min_elt\n then\n t.min_elt <- Internal_elt.null ()\n (* We keep [t.elt_lower_bound] since it is valid even though [t.min_elt] is being\n removed. *);\n t.length <- t.length - 1;\n let level = t.levels.(Internal_elt.level_index pool elt) in\n level.length <- level.length - 1;\n let slots = level.slots in\n let slot = Level.slot level ~key:(Internal_elt.key pool elt) in\n let first = slots.(slot) in\n if phys_equal elt (Internal_elt.next pool elt)\n then (* [elt] is the only element in the slot *)\n slots.(slot) <- Internal_elt.null ()\n else (\n if phys_equal elt first then slots.(slot) <- Internal_elt.next pool elt;\n Internal_elt.unlink pool elt)\n ;;\n\n let remove t elt =\n let pool = t.pool in\n let elt = Internal_elt.of_external_exn pool elt in\n internal_remove t elt;\n Internal_elt.free pool elt\n ;;\n\n let fire_past_alarms t ~handle_fired ~key ~now =\n let level = t.levels.(0) in\n if level.length > 0\n then (\n let slot = Level.slot level ~key in\n let slots = level.slots in\n let pool = t.pool in\n let first = ref slots.(slot) in\n if not (Internal_elt.is_null !first)\n then (\n let current = ref !first in\n let continue = ref true in\n while !continue do\n let elt = !current in\n let next = Internal_elt.next pool elt in\n if phys_equal next !first then continue := false else current := next;\n if Time_ns.( <= ) (Internal_elt.at pool elt) now\n then (\n handle_fired (Internal_elt.to_external elt);\n internal_remove t elt;\n Internal_elt.free pool elt;\n (* We recompute [first] because [internal_remove] may have changed it. *)\n first := slots.(slot))\n done))\n ;;\n\n let change t elt ~key ~at =\n ensure_valid_key t ~key;\n let pool = t.pool in\n let elt = Internal_elt.of_external_exn pool elt in\n internal_remove t elt;\n Internal_elt.set_key pool elt key;\n Internal_elt.set_at pool elt at;\n internal_add_elt t elt\n ;;\n\n let clear t =\n if not (is_empty t)\n then (\n t.length <- 0;\n let pool = t.pool in\n let free_elt elt = Internal_elt.free pool elt in\n let levels = t.levels in\n for level_index = 0 to Array.length levels - 1 do\n let level = levels.(level_index) in\n if level.length > 0\n then (\n level.length <- 0;\n let slots = level.slots in\n for slot_index = 0 to Array.length slots - 1 do\n let elt = slots.(slot_index) in\n if not (Internal_elt.is_null elt)\n then (\n Internal_elt.iter pool elt ~f:free_elt;\n slots.(slot_index) <- Internal_elt.null ())\n done)\n done)\n ;;\nend\n\nmodule Internal_elt = Priority_queue.Internal_elt\nmodule Key = Priority_queue.Key\nmodule Interval_num = Key\n\nlet min_interval_num = Interval_num.zero\n\n(* All time from the epoch onwards is broken into half-open intervals of size\n [Config.alarm_precision config]. The intervals are numbered starting at zero, and a\n time's interval number serves as its key in [priority_queue]. *)\ntype 'a t =\n { config : Config.t\n ; start : Time_ns.t\n ; (* [max_interval_num] is the interval number of [max_time]. *)\n max_interval_num : Interval_num.t\n ; mutable now : Time_ns.t\n ; mutable now_interval_num_start : Time_ns.t\n ; mutable max_allowed_alarm_time : Time_ns.t\n ; priority_queue : 'a Priority_queue.t\n }\n[@@deriving fields, sexp_of]\n\ntype 'a timing_wheel = 'a t\ntype 'a t_now = 'a t\n\nlet sexp_of_t_now _ t = [%sexp (t.now : Time_ns.t)]\nlet alarm_precision t = Config.alarm_precision t.config\n\nmodule Alarm = struct\n type 'a t = 'a Priority_queue.Elt.t [@@deriving sexp_of]\n\n let null = Priority_queue.Elt.null\n let at tw t = Priority_queue.Elt.at tw.priority_queue t\n let value tw t = Priority_queue.Elt.value tw.priority_queue t\n let interval_num tw t = Priority_queue.Elt.key tw.priority_queue t\nend\n\nlet sexp_of_t_internal = sexp_of_t\nlet iter t ~f = Priority_queue.iter t.priority_queue ~f\n\nmodule Pretty = struct\n module Alarm = struct\n type 'a t =\n { at : Time_ns.t\n ; value : 'a\n }\n [@@deriving fields, sexp_of]\n\n let create t alarm = { at = Alarm.at t alarm; value = Alarm.value t alarm }\n let compare t1 t2 = Time_ns.compare (at t1) (at t2)\n end\n\n type 'a t =\n { config : Config.t\n ; start : Time_ns.t\n ; max_interval_num : Interval_num.t\n ; now : Time_ns.t\n ; alarms : 'a Alarm.t list\n }\n [@@deriving sexp_of]\nend\n\nlet pretty\n ({ config\n ; start\n ; max_interval_num\n ; now\n ; now_interval_num_start = _\n ; max_allowed_alarm_time = _\n ; priority_queue = _\n } as t)\n =\n let r = ref [] in\n iter t ~f:(fun a -> r := Pretty.Alarm.create t a :: !r);\n let alarms = List.sort !r ~compare:Pretty.Alarm.compare in\n { Pretty.config; start; max_interval_num; now; alarms }\n;;\n\nlet sexp_of_t sexp_of_a t =\n match !sexp_of_t_style with\n | `Internal -> sexp_of_t_internal sexp_of_a t\n | `Pretty -> [%sexp (pretty t : a Pretty.t)]\n;;\n\nlet length t = Priority_queue.length t.priority_queue\nlet is_empty t = length t = 0\n\nlet interval_num_internal ~time ~alarm_precision =\n Interval_num.of_int63 (Alarm_precision.interval_num alarm_precision time)\n;;\n\nlet interval_num_unchecked t time =\n interval_num_internal ~time ~alarm_precision:t.config.alarm_precision\n;;\n\nlet interval_num t time =\n if Time_ns.( < ) time min_time\n then\n raise_s\n [%message\n \"Timing_wheel.interval_num got time too far in the past\" (time : Time_ns.t)];\n interval_num_unchecked t time\n;;\n\nlet interval_num_start_unchecked t interval_num =\n Alarm_precision.interval_num_start\n t.config.alarm_precision\n (interval_num |> Interval_num.to_int63)\n;;\n\nlet[@cold] raise_interval_num_start_got_too_small interval_num =\n raise_s\n [%message\n \"Timing_wheel.interval_num_start got too small interval_num\"\n (interval_num : Interval_num.t)\n (min_interval_num : Interval_num.t)]\n;;\n\nlet[@cold] raise_interval_num_start_got_too_large t interval_num =\n raise_s\n [%message\n \"Timing_wheel.interval_num_start got too large interval_num\"\n (interval_num : Interval_num.t)\n (t.max_interval_num : Interval_num.t)]\n;;\n\nlet interval_num_start t interval_num =\n if Interval_num.( < ) interval_num min_interval_num\n then raise_interval_num_start_got_too_small interval_num;\n if Interval_num.( > ) interval_num t.max_interval_num\n then raise_interval_num_start_got_too_large t interval_num;\n interval_num_start_unchecked t interval_num\n;;\n\nlet compute_max_allowed_alarm_time t =\n let max_allowed_key = Priority_queue.max_allowed_key t.priority_queue in\n if Interval_num.( >= ) max_allowed_key t.max_interval_num\n then max_time\n else\n Time_ns.add\n (interval_num_start_unchecked t max_allowed_key)\n (Time_ns.Span.( - ) (alarm_precision t) Time_ns.Span.nanosecond)\n;;\n\nlet now_interval_num t = Priority_queue.min_allowed_key t.priority_queue\nlet min_allowed_alarm_interval_num = now_interval_num\nlet max_allowed_alarm_interval_num t = interval_num t (max_allowed_alarm_time t)\nlet interval_start t time = interval_num_start_unchecked t (interval_num t time)\n\nlet invariant invariant_a t =\n Invariant.invariant [%here] t [%sexp_of: _ t] (fun () ->\n let check f = Invariant.check_field t f in\n Fields.iter\n ~config:(check Config.invariant)\n ~start:\n (check (fun start ->\n assert (Time_ns.( >= ) start min_time);\n assert (Time_ns.( <= ) start max_time)))\n ~max_interval_num:\n (check (fun max_interval_num ->\n [%test_result: Interval_num.t]\n ~expect:max_interval_num\n (interval_num t max_time);\n [%test_result: Interval_num.t]\n ~expect:max_interval_num\n (interval_num t (interval_num_start t max_interval_num))))\n ~now:\n (check (fun now ->\n assert (Time_ns.( >= ) now t.start);\n assert (Time_ns.( <= ) now max_time);\n assert (\n Interval_num.equal\n (interval_num t t.now)\n (Priority_queue.min_allowed_key t.priority_queue))))\n ~now_interval_num_start:\n (check (fun now_interval_num_start ->\n [%test_result: Time_ns.t]\n now_interval_num_start\n ~expect:(interval_num_start t (now_interval_num t))))\n ~max_allowed_alarm_time:\n (check (fun max_allowed_alarm_time ->\n [%test_result: Time_ns.t]\n max_allowed_alarm_time\n ~expect:(compute_max_allowed_alarm_time t)))\n ~priority_queue:(check (Priority_queue.invariant invariant_a));\n iter t ~f:(fun alarm ->\n assert (\n Interval_num.equal\n (Alarm.interval_num t alarm)\n (interval_num t (Alarm.at t alarm)));\n assert (\n Time_ns.( >= )\n (interval_start t (Alarm.at t alarm))\n (interval_start t (now t)));\n assert (\n Time_ns.( > ) (Alarm.at t alarm) (Time_ns.sub (now t) (alarm_precision t)))))\n;;\n\nlet advance_clock t ~to_ ~handle_fired =\n if Time_ns.( > ) to_ (now t)\n then (\n t.now <- to_;\n let key = interval_num_unchecked t to_ in\n t.now_interval_num_start <- interval_num_start_unchecked t key;\n Priority_queue.increase_min_allowed_key\n t.priority_queue\n ~key\n ~handle_removed:handle_fired;\n t.max_allowed_alarm_time <- compute_max_allowed_alarm_time t)\n;;\n\nlet create ~config ~start =\n if Time_ns.( < ) start Time_ns.epoch\n then\n raise_s\n [%message \"Timing_wheel.create got start before the epoch\" (start : Time_ns.t)];\n let t =\n { config\n ; start\n ; max_interval_num =\n interval_num_internal ~time:max_time ~alarm_precision:config.alarm_precision\n ; now = Time_ns.min_value_for_1us_rounding (* set by [advance_clock] below *)\n ; now_interval_num_start =\n Time_ns.min_value_for_1us_rounding (* set by [advance_clock] below *)\n ; max_allowed_alarm_time = max_time (* set by [advance_clock] below *)\n ; priority_queue =\n Priority_queue.create ?capacity:config.capacity ~level_bits:config.level_bits ()\n }\n in\n advance_clock t ~to_:start ~handle_fired:(fun _ -> assert false);\n t\n;;\n\nlet add_at_interval_num t ~at value =\n Internal_elt.to_external\n (Priority_queue.internal_add\n t.priority_queue\n ~key:at\n ~at:(interval_num_start t at)\n value)\n;;\n\nlet[@cold] raise_that_far_in_the_future t at =\n raise_s\n [%message\n \"Timing_wheel cannot schedule alarm that far in the future\"\n (at : Time_ns.t)\n ~max_allowed_alarm_time:(t.max_allowed_alarm_time : Time_ns.t)]\n;;\n\nlet[@cold] raise_before_start_of_current_interval t at =\n raise_s\n [%message\n \"Timing_wheel cannot schedule alarm before start of current interval\"\n (at : Time_ns.t)\n ~now_interval_num_start:(t.now_interval_num_start : Time_ns.t)]\n;;\n\nlet ensure_can_schedule_alarm t ~at =\n if Time_ns.( > ) at t.max_allowed_alarm_time then raise_that_far_in_the_future t at;\n if Time_ns.( < ) at t.now_interval_num_start\n then raise_before_start_of_current_interval t at\n;;\n\nlet add t ~at value =\n ensure_can_schedule_alarm t ~at;\n Internal_elt.to_external\n (Priority_queue.internal_add\n t.priority_queue\n ~key:(interval_num_unchecked t at)\n ~at\n value)\n;;\n\nlet remove t alarm = Priority_queue.remove t.priority_queue alarm\nlet clear t = Priority_queue.clear t.priority_queue\nlet mem t alarm = Priority_queue.mem t.priority_queue alarm\n\nlet reschedule_gen t alarm ~key ~at =\n if not (mem t alarm)\n then failwith \"Timing_wheel cannot reschedule alarm not in timing wheel\";\n ensure_can_schedule_alarm t ~at;\n Priority_queue.change t.priority_queue alarm ~key ~at\n;;\n\nlet reschedule t alarm ~at =\n reschedule_gen t alarm ~key:(interval_num_unchecked t at) ~at\n;;\n\nlet reschedule_at_interval_num t alarm ~at =\n reschedule_gen t alarm ~key:at ~at:(interval_num_start t at)\n;;\n\nlet pool t = Priority_queue.pool t.priority_queue\n\nlet min_alarm_interval_num t =\n let elt = Priority_queue.min_elt_ t.priority_queue in\n if Internal_elt.is_null elt then None else Some (Internal_elt.key (pool t) elt)\n;;\n\nlet min_alarm_interval_num_exn t =\n let elt = Priority_queue.min_elt_ t.priority_queue in\n if Internal_elt.is_null elt\n then\n raise_s\n [%message\n \"Timing_wheel.min_alarm_interval_num_exn of empty timing_wheel\"\n ~timing_wheel:(t : _ t)]\n else Internal_elt.key (pool t) elt\n;;\n\nlet max_alarm_time_in_list t elt =\n let pool = pool t in\n Internal_elt.max_alarm_time pool elt ~with_key:(Internal_elt.key pool elt)\n;;\n\nlet max_alarm_time_in_min_interval t =\n let elt = Priority_queue.min_elt_ t.priority_queue in\n if Internal_elt.is_null elt then None else Some (max_alarm_time_in_list t elt)\n;;\n\nlet max_alarm_time_in_min_interval_exn t =\n let elt = Priority_queue.min_elt_ t.priority_queue in\n if Internal_elt.is_null elt\n then\n raise_s\n [%message\n \"Timing_wheel.max_alarm_time_in_min_interval_exn of empty timing wheel\"\n ~timing_wheel:(t : _ t)];\n max_alarm_time_in_list t elt\n;;\n\nlet next_alarm_fires_at_internal t key =\n (* [interval_num_start t key] is the key corresponding to the start of the time interval\n holding the first alarm in [t]. Advancing to that would not be enough, since the\n alarms in that interval don't fire until the clock is advanced to the start of the\n next interval. So, we use [succ key] to advance to the start of the next\n interval. *)\n interval_num_start t (Key.succ key)\n;;\n\nlet next_alarm_fires_at t =\n let elt = Priority_queue.min_elt_ t.priority_queue in\n if Internal_elt.is_null elt\n then None\n else (\n let key = Internal_elt.key (pool t) elt in\n if Interval_num.equal key t.max_interval_num\n then None\n else Some (next_alarm_fires_at_internal t key))\n;;\n\nlet[@cold] raise_next_alarm_fires_at_exn_of_empty_timing_wheel t =\n raise_s\n [%message\n \"Timing_wheel.next_alarm_fires_at_exn of empty timing wheel\"\n ~timing_wheel:(t : _ t)]\n;;\n\nlet[@cold] raise_next_alarm_fires_at_with_all_alarms_in_max_interval t =\n raise_s\n [%message\n \"Timing_wheel.next_alarm_fires_at_exn with all alarms in max interval\"\n ~timing_wheel:(t : _ t)]\n;;\n\nlet next_alarm_fires_at_exn t =\n let elt = Priority_queue.min_elt_ t.priority_queue in\n if Internal_elt.is_null elt then raise_next_alarm_fires_at_exn_of_empty_timing_wheel t;\n let key = Internal_elt.key (pool t) elt in\n if Interval_num.equal key t.max_interval_num\n then raise_next_alarm_fires_at_with_all_alarms_in_max_interval t;\n next_alarm_fires_at_internal t key\n;;\n\nlet fire_past_alarms t ~handle_fired =\n Priority_queue.fire_past_alarms\n t.priority_queue\n ~handle_fired\n ~key:(now_interval_num t)\n ~now:t.now\n;;\n\nmodule Private = struct\n module Num_key_bits = Num_key_bits\n\n let interval_num_internal = interval_num_internal\n let max_time = max_time\nend\n","module Inria_sys = Sys\nmodule Time_ns_in_this_directory = Time_ns\nopen Core_kernel\nopen Poly\nmodule Time_ns = Time_ns_in_this_directory\n\nlet sec = Time_ns.Span.of_sec\nlet concat = String.concat\n\nmodule Epoll_max_ready_events = Validated.Make (struct\n include Int\n\n let here = [%here]\n let validate = Int.validate_positive\n end)\n\nmodule Max_inter_cycle_timeout = Validated.Make (struct\n include Time_ns.Span\n\n let here = [%here]\n let validate = Time_ns.Span.validate_non_negative\n end)\n\nmodule Min_inter_cycle_timeout = Validated.Make (struct\n include Time_ns.Span\n\n let here = [%here]\n let validate = Time_ns.Span.validate_non_negative\n end)\n\nmodule Max_num_open_file_descrs = struct\n include Validated.Make (struct\n include Int\n\n let here = [%here]\n let validate = Int.validate_positive\n end)\n\n let default = create_exn (1 lsl 16)\n let equal (t1 : t) t2 = t1 = t2\nend\n\nmodule Max_num_threads = Validated.Make (struct\n include Int\n\n let here = [%here]\n let validate = Int.validate_positive\n end)\n\nmodule Max_num_jobs_per_priority_per_cycle = Validated.Make (struct\n include Int\n\n let here = [%here]\n let validate = Int.validate_positive\n end)\n\nmodule Dump_core_on_job_delay = struct\n module How_to_dump = struct\n type t =\n | Default\n | Call_abort\n | Call_gcore\n [@@deriving sexp]\n end\n\n type watch =\n { dump_if_delayed_by : Time_ns.Span.t\n ; how_to_dump : How_to_dump.t\n }\n [@@deriving sexp]\n\n type t =\n | Watch of watch\n | Do_not_watch\n [@@deriving sexp]\nend\n\nmodule Debug_tag = struct\n module T = struct\n type t =\n | All\n | Clock\n | Fd\n | File_descr_watcher\n | Finalizers\n | Interruptor\n | Monitor\n | Monitor_send_exn\n | Parallel\n | Reader\n | Scheduler\n | Shutdown\n | Thread_pool\n | Thread_safe\n | Writer\n [@@deriving compare, sexp]\n\n let equal = [%compare.equal: t]\n end\n\n include T\n include Sexpable.To_stringable (T)\n\n let list =\n [ All\n ; Clock\n ; Fd\n ; File_descr_watcher\n ; Finalizers\n ; Interruptor\n ; Monitor\n ; Monitor_send_exn\n ; Parallel\n ; Reader\n ; Scheduler\n ; Shutdown\n ; Thread_pool\n ; Thread_safe\n ; Writer\n ]\n ;;\nend\n\nmodule File_descr_watcher = struct\n module T = struct\n type t =\n | Epoll_if_timerfd\n | Epoll\n | Select\n [@@deriving sexp]\n end\n\n include T\n include Sexpable.To_stringable (T)\n\n let list = [ Epoll_if_timerfd; Epoll; Select ]\nend\n\ntype t =\n { abort_after_thread_pool_stuck_for : Time_ns.Span.t option [@sexp.option]\n ; check_invariants : bool option [@sexp.option]\n ; detect_invalid_access_from_thread : bool option [@sexp.option]\n ; dump_core_on_job_delay : Dump_core_on_job_delay.t option [@sexp.option]\n ; epoll_max_ready_events : Epoll_max_ready_events.t option [@sexp.option]\n ; file_descr_watcher : File_descr_watcher.t option [@sexp.option]\n ; max_inter_cycle_timeout : Max_inter_cycle_timeout.t option [@sexp.option]\n ; max_num_open_file_descrs : Max_num_open_file_descrs.t option [@sexp.option]\n ; max_num_threads : Max_num_threads.t option [@sexp.option]\n ; max_num_jobs_per_priority_per_cycle : Max_num_jobs_per_priority_per_cycle.t option\n [@sexp.option]\n ; min_inter_cycle_timeout : Min_inter_cycle_timeout.t option [@sexp.option]\n ; print_debug_messages_for : Debug_tag.t list option [@sexp.option]\n ; record_backtraces : bool option [@sexp.option]\n ; report_thread_pool_stuck_for : Time_ns.Span.t option [@sexp.option]\n ; thread_pool_cpu_affinity : Thread_pool_cpu_affinity.t option [@sexp.option]\n ; timing_wheel_config : Timing_wheel.Config.t option [@sexp.option]\n }\n[@@deriving fields, sexp]\n\nlet empty =\n { abort_after_thread_pool_stuck_for = None\n ; check_invariants = None\n ; detect_invalid_access_from_thread = None\n ; dump_core_on_job_delay = None\n ; epoll_max_ready_events = None\n ; file_descr_watcher = None\n ; max_inter_cycle_timeout = None\n ; max_num_open_file_descrs = None\n ; max_num_threads = None\n ; max_num_jobs_per_priority_per_cycle = None\n ; min_inter_cycle_timeout = None\n ; print_debug_messages_for = None\n ; record_backtraces = None\n ; report_thread_pool_stuck_for = None\n ; thread_pool_cpu_affinity = None\n ; timing_wheel_config = None\n }\n;;\n\nlet default_timing_wheel_config_for_word_size (word_size : Word_size.t) =\n let module Alarm_precision = Timing_wheel.Alarm_precision in\n let alarm_precision, level_bits =\n match word_size with\n | W32 -> Alarm_precision.about_one_millisecond, [ 10; 10; 9 ]\n | W64 -> Alarm_precision.(div about_one_millisecond ~pow2:3), [ 14; 15; 9; 6 ]\n in\n Timing_wheel.Config.create\n ~alarm_precision\n ~level_bits:(Timing_wheel.Level_bits.create_exn level_bits)\n ()\n;;\n\nlet default_timing_wheel_config =\n default_timing_wheel_config_for_word_size Word_size.word_size\n;;\n\nlet default =\n (* For [file_descr_watcher] and [max_num_open_file_descrs] we choose the default for the\n common case that [epoll] is available. There is some additional code in\n [Async_unix.Config] that checks whether [epoll] is actually available, and if not,\n uses [select] and a smaller number of file descriptors. *)\n { abort_after_thread_pool_stuck_for = Some (sec 60.)\n ; check_invariants = Some false\n ; detect_invalid_access_from_thread = Some false\n ; dump_core_on_job_delay = Some Do_not_watch\n ; epoll_max_ready_events = Some (Epoll_max_ready_events.create_exn 256)\n ; file_descr_watcher = Some Epoll_if_timerfd\n ; max_inter_cycle_timeout = Some (Max_inter_cycle_timeout.create_exn (sec 0.05))\n ; max_num_open_file_descrs = Some Max_num_open_file_descrs.default\n ; max_num_threads = Some (Max_num_threads.create_exn 50)\n ; max_num_jobs_per_priority_per_cycle =\n Some (Max_num_jobs_per_priority_per_cycle.create_exn 500)\n ; min_inter_cycle_timeout = Some (Min_inter_cycle_timeout.create_exn (sec 0.))\n ; print_debug_messages_for = Some []\n ; record_backtraces = Some false\n ; report_thread_pool_stuck_for = Some (sec 1.)\n ; thread_pool_cpu_affinity = Some Inherit\n ; timing_wheel_config = Some default_timing_wheel_config\n }\n;;\n\nlet example =\n { default with\n print_debug_messages_for = Some Debug_tag.[ Fd; Scheduler ]\n ; thread_pool_cpu_affinity =\n Some\n (Cpuset\n ([ 0; 1; 2 ] |> Int.Set.of_list |> Thread_pool_cpu_affinity.Cpuset.create_exn))\n }\n;;\n\nlet environment_variable = \"ASYNC_CONFIG\"\n\nlet field_descriptions () : string =\n let field to_sexp description ac field =\n (Field.name field, to_sexp (Option.value_exn (Field.get field default)), description)\n :: ac\n in\n let fields =\n Fields.fold\n ~init:[]\n ~abort_after_thread_pool_stuck_for:\n (field\n [%sexp_of: Time_ns.Span.t]\n [ {|\n By default, Async will send an exception to the toplevel monitor\n if it detects that the thread pool is stuck for longer than this.\n|}\n ])\n ~check_invariants:\n (field\n [%sexp_of: bool]\n [ {|\n If true, causes Async to regularly check invariants of its internal\n data structures. This can substantially slow down your program.\n|}\n ])\n ~detect_invalid_access_from_thread:\n (field\n [%sexp_of: bool]\n [ {|\n If true, causes Async routines to check if they are being accessed\n from some thread other than the thread currently holding the Async\n lock, which is not allowed and can lead to very confusing behavior.\n|}\n ])\n ~dump_core_on_job_delay:\n (field\n [%sexp_of: Dump_core_on_job_delay.t]\n [ {|\n Can be set to [Do_not_watch] or:\n\n (Watch ((dump_if_delayed_by SPAN) (how_to_dump HOW)))\n\n If set to [Watch], then on program start this will start a regular\n Async job that increments a counter, and a C thread that will\n detect if that job is delayed by [dump_if_delayed_by], and if so,\n will core dump the program. If available, [/usr/bin/gcore] is\n used by default to dump the core, which should allow the program\n to continue running. Otherwise, [abort] will be called from C,\n which will kill the program while causing a core dump. One can\n force [abort] or [gcore] via [how_to_dump], which should be one of:\n [Call_abort], [Call_gcore], or [Default].\n|}\n ])\n ~epoll_max_ready_events:\n (field\n [%sexp_of: Epoll_max_ready_events.t]\n [ {|\n The maximum number of ready events that Async's call to [Epoll.wait]\n will handle.\n|}\n ])\n ~file_descr_watcher:\n (field\n [%sexp_of: File_descr_watcher.t]\n [ {|\n This determines what OS subsystem Async uses to watch file descriptors for being ready.\n The default is to use [epoll] if timerfd's are supported and if not, use [select].\n\n Allowed values are:|}\n ; concat\n ~sep:\", \"\n (List.map File_descr_watcher.list ~f:File_descr_watcher.to_string)\n ; {|.\n|}\n ])\n ~max_num_open_file_descrs:\n (field\n (fun default ->\n [%message\n \"\"\n ~_:\n (concat\n [ \"min \"\n ; default |> Max_num_open_file_descrs.raw |> Int.to_string_hum\n ; \" [ulimit -n -H]\"\n ]\n : string)])\n [ {|\n The maximum number of open file descriptors allowed at any one time.|} ])\n ~max_num_threads:\n (field\n [%sexp_of: Max_num_threads.t]\n [ {|\n The maximum number of threads that Async will create to do blocking\n system calls and handle calls to [In_thread.run].\n|}\n ])\n ~max_inter_cycle_timeout:\n (field\n [%sexp_of: Max_inter_cycle_timeout.t]\n [ {|\n The maximum amount of time the scheduler will pause between cycles\n when it has no jobs and is going to wait for I/O. In principle one\n doesn't need this, and we could use an infinite timeout. We instead\n use a small timeout (by default), to be more robust to bugs that\n could prevent Async from waking up and servicing events. For\n example, as of 2013-01, the OCaml runtime has a bug that causes it\n to not necessarily run an OCaml signal handler in a timely manner.\n This in turn can cause a simple Async program that is waiting on a\n signal to hang, when in fact it should handle the signal.\n\n We use 50ms as the default timeout, because it is infrequent enough\n to have a negligible performance impact, and frequent enough that\n the latency would typically be not noticeable. Also, 50ms is what\n the OCaml ticker thread uses.\n|}\n ])\n ~max_num_jobs_per_priority_per_cycle:\n (field\n [%sexp_of: Max_num_jobs_per_priority_per_cycle.t]\n [ {|\n The maximum number of jobs that will be done at each priority within\n each Async cycle. This limits how many jobs the scheduler will run\n before pausing to check for I/O.\n|}\n ])\n ~min_inter_cycle_timeout:\n (field\n [%sexp_of: Min_inter_cycle_timeout.t]\n [ {|\n The minimum timeout the scheduler will pass to the OS when it checks\n for I/O between cycles. This is zero by default. Setting it to a\n nonzero value is used to increase thread fairness between the scheduler\n and other threads. A plausible setting is 1us. This is also\n configurable in OCaml via [Scheduler.set_min_inter_cycle_timeout].\n|}\n ])\n ~print_debug_messages_for:\n (field\n [%sexp_of: Debug_tag.t list]\n [ {|\n A list of tags specifying which Async functions should print debug\n messages to stderr. Each tag identifies a group of related Async\n functions. The tag [all] means to print debug messages for all\n functions. Allowed values are:\n\n|}\n ; concat\n (List.map Debug_tag.list ~f:(fun d ->\n concat [ \" \"; Debug_tag.to_string d; \"\\n\" ]))\n ; {|\n Turning on debug messages will substantially slow down most programs.\n|}\n ])\n ~record_backtraces:\n (field\n [%sexp_of: bool]\n [ {|\n If true, this will cause Async to keep in the execution context the\n history of stack backtraces (obtained via [Backtrace.get]) that led\n to the current job. If an Async job has an unhandled exception,\n this backtrace history will be recorded in the exception. In\n particular the history will appear in an unhandled exception that\n reaches the main monitor. This can have a substantial performance\n impact, both in running time and space usage.\n|}\n ])\n ~report_thread_pool_stuck_for:\n (field\n [%sexp_of: Time_ns.Span.t]\n [ {|\n By default, Async will print a message to stderr every second if\n the thread pool is stuck for longer than this.\n|}\n ])\n ~thread_pool_cpu_affinity:\n (field\n [%sexp_of: Thread_pool_cpu_affinity.t]\n [ {|\n Whether and how threads in the thread pool should be affinitized to CPUs.\n|}\n ])\n ~timing_wheel_config:\n (field\n [%sexp_of: Timing_wheel.Config.t]\n [ {|\n This is used to adjust the time/space tradeoff in the timing wheel\n used to implement Async's clock. Time is split into intervals of\n size [alarm_precision], and alarms with times in the same interval\n fire in the same cycle. Level [i] in the timing wheel has an\n array of size [2^b], where [b] is the [i]'th entry in [level_bits].\n|}\n ])\n in\n concat\n (List.map\n (List.sort fields ~compare:(fun (name1, _, _) (name2, _, _) ->\n String.compare name1 name2))\n ~f:(fun (name, default, description) ->\n concat\n (\"\\n\" :: name :: \" (default \" :: Sexp.to_string default :: \")\" :: description)))\n;;\n\nlet help_message () =\n concat\n [ \"The \"\n ; environment_variable\n ; {| environment variable affects Async\nin various ways. Its value should be a sexp of the following form,\nwhere all fields are optional:\n\n|}\n ; Sexp.to_string_hum (sexp_of_t example)\n ; {|\n\nHere is an explanation of each field.\n|}\n ; field_descriptions ()\n ]\n;;\n\nlet usage () =\n eprintf \"%s%!\" (help_message ());\n exit 1\n;;\n\nlet t =\n match Option.try_with (fun () -> Inria_sys.getenv environment_variable) with\n | None -> empty\n | Some \"\" -> usage ()\n | Some string ->\n (match Result.try_with (fun () -> t_of_sexp (Sexp.of_string string)) with\n | Ok t -> t\n | Error exn ->\n eprintf\n \"%s\\n\\n\"\n (Sexp.to_string_hum\n (Error.sexp_of_t\n (Error.create\n (sprintf\n \"invalid value for %s environment variable\"\n environment_variable)\n exn\n [%sexp_of: exn])));\n usage ())\n;;\n\nmodule Print_debug_messages_for = struct\n let print_debug_messages_for tag =\n match t.print_debug_messages_for with\n | None -> false\n | Some l -> List.mem l tag ~equal:Debug_tag.equal\n ;;\n\n let all = print_debug_messages_for All\n let debug tag = all || print_debug_messages_for tag\n let clock = debug Clock\n let fd = debug Fd\n let file_descr_watcher = debug File_descr_watcher\n let finalizers = debug Finalizers\n let interruptor = debug Interruptor\n let monitor = debug Monitor\n let monitor_send_exn = debug Monitor_send_exn\n let parallel = debug Parallel\n let reader = debug Reader\n let scheduler = debug Scheduler\n let shutdown = debug Shutdown\n let thread_pool = debug Thread_pool\n let thread_safe = debug Thread_safe\n let writer = debug Writer\nend\n\nlet ( !! ) field =\n Option.value (Field.get field t) ~default:(Option.value_exn (Field.get field default))\n;;\n\nlet abort_after_thread_pool_stuck_for = !!Fields.abort_after_thread_pool_stuck_for\nlet check_invariants = !!Fields.check_invariants\nlet detect_invalid_access_from_thread = !!Fields.detect_invalid_access_from_thread\nlet epoll_max_ready_events = !!Fields.epoll_max_ready_events\nlet thread_pool_cpu_affinity = !!Fields.thread_pool_cpu_affinity\nlet file_descr_watcher = !!Fields.file_descr_watcher\nlet max_inter_cycle_timeout = !!Fields.max_inter_cycle_timeout\nlet max_num_open_file_descrs = !!Fields.max_num_open_file_descrs\nlet max_num_threads = !!Fields.max_num_threads\nlet max_num_jobs_per_priority_per_cycle = !!Fields.max_num_jobs_per_priority_per_cycle\nlet min_inter_cycle_timeout = !!Fields.min_inter_cycle_timeout\nlet record_backtraces = !!Fields.record_backtraces\nlet report_thread_pool_stuck_for = !!Fields.report_thread_pool_stuck_for\nlet timing_wheel_config = !!Fields.timing_wheel_config\nlet dump_core_on_job_delay = !!Fields.dump_core_on_job_delay\n\nlet t =\n { abort_after_thread_pool_stuck_for = Some abort_after_thread_pool_stuck_for\n ; check_invariants = Some check_invariants\n ; detect_invalid_access_from_thread = Some detect_invalid_access_from_thread\n ; dump_core_on_job_delay = Some dump_core_on_job_delay\n ; thread_pool_cpu_affinity = Some thread_pool_cpu_affinity\n ; epoll_max_ready_events = Some epoll_max_ready_events\n ; file_descr_watcher = Some file_descr_watcher\n ; max_inter_cycle_timeout = Some max_inter_cycle_timeout\n ; max_num_open_file_descrs = Some max_num_open_file_descrs\n ; max_num_threads = Some max_num_threads\n ; max_num_jobs_per_priority_per_cycle = Some max_num_jobs_per_priority_per_cycle\n ; min_inter_cycle_timeout = Some min_inter_cycle_timeout\n ; print_debug_messages_for = t.print_debug_messages_for\n ; record_backtraces = Some record_backtraces\n ; report_thread_pool_stuck_for = Some report_thread_pool_stuck_for\n ; timing_wheel_config = Some timing_wheel_config\n }\n;;\n\nlet task_id = ref (fun () -> Sexp.Atom \"\")\n","open Core_kernel\nopen Import\nopen Deferred_std\nmodule Deferred = Deferred1\nmodule Scheduler = Scheduler1\nmodule Stream = Tail.Stream\nmodule Monitor = Monitor0\ninclude Monitor\n\ntype monitor = t [@@deriving sexp_of]\n\nlet invariant t =\n Invariant.invariant [%here] t [%sexp_of: t] (fun () ->\n let check f = Invariant.check_field t f in\n Fields.iter\n ~name:ignore\n ~here:ignore\n ~id:ignore\n ~parent:ignore\n ~next_error:(check (fun next_error -> assert (Ivar.is_empty next_error)))\n ~handlers_for_all_errors:ignore\n ~tails_for_all_errors:ignore\n ~has_seen_error:ignore\n ~is_detached:ignore)\n;;\n\nlet current_execution_context () = Scheduler.(current_execution_context (t ()))\nlet current () = Execution_context.monitor (current_execution_context ())\n\nlet depth t =\n let rec loop t n =\n match t.parent with\n | None -> n\n | Some t -> loop t (n + 1)\n in\n loop t 0\n;;\n\ntype 'a with_optional_monitor_name =\n ?here:Source_code_position.t -> ?info:Info.t -> ?name:string -> 'a\n\nlet detach t = t.is_detached <- true\n\ntype handler_state =\n | Uninitialized\n | Running of (Execution_context.t * (exn -> unit)) Bag.Elt.t\n | Terminated\n\nlet detach_and_iter_errors t ~f =\n detach t;\n let scheduler = Scheduler.t () in\n let execution_context = Scheduler.current_execution_context scheduler in\n let handler_state_ref = ref Uninitialized in\n let run_f exn =\n match !handler_state_ref with\n | Uninitialized -> assert false\n | Terminated -> ()\n | Running bag_elt ->\n (try f exn with\n | inner_exn ->\n handler_state_ref := Terminated;\n Bag.remove t.handlers_for_all_errors bag_elt;\n (* [run_f] always runs in [execution_context]. Hence, [raise inner_exn] sends\n [inner_exn] to [execution_context]'s monitor, i.e. the monitor in effect when\n [detach_and_iter_errors] was called. *)\n raise inner_exn)\n in\n handler_state_ref\n := Running (Bag.add t.handlers_for_all_errors (execution_context, run_f))\n;;\n\nlet detach_and_get_error_stream t =\n detach t;\n let tail = Tail.create () in\n t.tails_for_all_errors <- tail :: t.tails_for_all_errors;\n Tail.collect tail\n;;\n\nlet get_next_error t = Ivar.read t.next_error\n\nlet detach_and_get_next_error t =\n detach t;\n get_next_error t\n;;\n\nlet create ?here ?info ?name () =\n let parent = current () in\n create_with_parent ?here ?info ?name (Some parent)\n;;\n\nmodule Exn_for_monitor = struct\n type t =\n { exn : exn\n ; backtrace : Backtrace.t option\n ; backtrace_history : Backtrace.t list\n ; monitor : Monitor.t\n }\n\n let backtrace_truncation_heuristics =\n let job_queue = \"Called from file \\\"job_queue.ml\\\"\" in\n let deferred0 = \"Called from file \\\"deferred0.ml\\\"\" in\n let deferred1 = \"Called from file \\\"deferred1.ml\\\"\" in\n let monitor = \"Called from file \\\"monitor.ml\\\"\" in\n let import0 = \"Raised at file \\\"import0.ml\\\"\" in\n let error = \"Called from file \\\"error.ml\\\"\" in\n fun traces ->\n (* ../test/test_try_with_error_display.ml makes sure this stays up-to-date. *)\n let traces =\n match traces with\n | t1 :: rest when String.is_prefix t1 ~prefix:import0 ->\n (match rest with\n | t2 :: rest when String.is_prefix t2 ~prefix:error ->\n (match rest with\n | t3 :: rest when String.is_prefix t3 ~prefix:error -> rest\n | _ -> rest)\n | _ -> rest)\n | _ -> traces\n in\n match List.rev traces with\n | t1 :: rest when String.is_prefix t1 ~prefix:job_queue ->\n (match rest with\n | t2 :: rest when String.is_prefix t2 ~prefix:job_queue ->\n (match rest with\n | t2 :: rest\n when String.is_prefix t2 ~prefix:deferred0\n (* bind *)\n || String.is_prefix t2 ~prefix:deferred1\n (* map *)\n || String.is_prefix t2 ~prefix:monitor\n (* try_with *) -> List.rev rest\n | _ -> List.rev rest)\n | _ -> List.rev rest)\n | _ -> traces\n ;;\n\n let sexp_of_t { exn; backtrace; backtrace_history; monitor } =\n let monitor =\n let name =\n match Info.to_string_hum monitor.name with\n | \"\" -> None\n | s -> Some s\n in\n let pos =\n match monitor.here with\n | None -> None\n | Some here ->\n (* We display the full filename, whereas backtraces only have basenames, but\n perhaps that's what should change. *)\n let column = here.pos_cnum - here.pos_bol in\n Some\n (sprintf\n \"file %S, line %d, characters %d-%d\"\n here.pos_fname\n here.pos_lnum\n column\n column)\n in\n match pos, name with\n | None, None -> []\n | Some pos, None -> [ sprintf \"Caught by monitor at %s\" pos ]\n | None, Some name -> [ sprintf \"Caught by monitor %s\" name ]\n | Some pos, Some name -> [ sprintf \"Caught by monitor %s at %s\" name pos ]\n in\n let backtrace =\n let backtrace =\n match backtrace with\n | None -> []\n | Some backtrace -> Backtrace.to_string_list backtrace\n in\n backtrace_truncation_heuristics backtrace @ monitor\n in\n let list_if_not_empty = function\n | [] -> None\n | _ :: _ as l -> Some l\n in\n [%sexp\n (exn : exn)\n , (list_if_not_empty backtrace : (string list option[@sexp.option]))\n , `backtrace_history\n (list_if_not_empty backtrace_history : (Backtrace.t list option[@sexp.option]))]\n ;;\nend\n\nexception Error_ of Exn_for_monitor.t\n\nlet () =\n Sexplib.Conv.Exn_converter.add [%extension_constructor Error_] (function\n | Error_ t -> [%sexp \"monitor.ml.Error\" :: (t : Exn_for_monitor.t)]\n | _ ->\n (* Reaching this branch indicates a bug in sexplib. *)\n assert false)\n;;\n\nlet extract_exn exn =\n match exn with\n | Error_ error -> error.exn\n | exn -> exn\n;;\n\nlet send_exn t ?backtrace exn =\n let exn =\n match exn with\n | Error_ _ -> exn\n | _ ->\n let backtrace =\n match backtrace with\n | None -> None\n | Some `Get -> Some (Backtrace.Exn.most_recent ())\n | Some (`This b) -> Some b\n in\n let backtrace_history = (current_execution_context ()).backtrace_history in\n Error_ { Exn_for_monitor.exn; backtrace; backtrace_history; monitor = t }\n in\n if Debug.monitor_send_exn\n then Debug.log \"Monitor.send_exn\" (t, exn) [%sexp_of: t * exn];\n t.has_seen_error <- true;\n let scheduler = Scheduler.t () in\n let rec loop t =\n Ivar.fill t.next_error exn;\n t.next_error <- Ivar.create ();\n if t.is_detached\n then (\n if Debug.monitor_send_exn\n then\n Debug.log \"Monitor.send_exn found listening monitor\" (t, exn) [%sexp_of: t * exn];\n Bag.iter t.handlers_for_all_errors ~f:(fun (execution_context, f) ->\n Scheduler.enqueue scheduler execution_context f exn);\n List.iter t.tails_for_all_errors ~f:(fun tail -> Tail.extend tail exn))\n else (\n match t.parent with\n | Some t' -> loop t'\n | None ->\n (* Do not change this branch to print the exception or to exit. Having the\n scheduler raise an uncaught exception is the necessary behavior for programs\n that call [Scheduler.go] and want to handle it. *)\n Scheduler.(got_uncaught_exn (t ())) exn (!Async_kernel_config.task_id ()))\n in\n loop t\n;;\n\nmodule Exported_for_scheduler = struct\n let within_context context f =\n Scheduler.(with_execution_context (t ())) context ~f:(fun () ->\n match Result.try_with f with\n | Ok x -> Ok x\n | Error exn ->\n send_exn (Execution_context.monitor context) exn ~backtrace:`Get;\n Error ())\n ;;\n\n type 'a with_options = ?monitor:t -> ?priority:Priority.t -> 'a\n\n let within_gen ?monitor ?priority f =\n let tmp_context =\n Execution_context.create_like (current_execution_context ()) ?monitor ?priority\n in\n within_context tmp_context f\n ;;\n\n let within' ?monitor ?priority f =\n match within_gen ?monitor ?priority f with\n | Error () -> Deferred.never ()\n | Ok d -> d\n ;;\n\n let within_v ?monitor ?priority f =\n match within_gen ?monitor ?priority f with\n | Error () -> None\n | Ok x -> Some x\n ;;\n\n let within ?monitor ?priority f =\n match within_gen ?monitor ?priority f with\n | Error () -> ()\n | Ok () -> ()\n ;;\n\n let schedule_with_data ?monitor ?priority work x =\n let scheduler = Scheduler.t () in\n Scheduler.enqueue\n scheduler\n (Execution_context.create_like\n (Scheduler.current_execution_context scheduler)\n ?monitor\n ?priority)\n work\n x\n ;;\n\n let schedule ?monitor ?priority work = schedule_with_data ?monitor ?priority work ()\n\n let schedule' =\n (* For performance, we use [schedule_with_data] with a closed function, and inline\n [Deferred.create]. *)\n let upon_work_fill_i (work, i) = upon (work ()) (fun a -> Ivar.fill i a) in\n fun ?monitor ?priority work ->\n let i = Ivar.create () in\n schedule_with_data ?monitor ?priority upon_work_fill_i (work, i);\n Ivar.read i\n ;;\n\n let preserve_execution_context f =\n let scheduler = Scheduler.t () in\n let execution_context = Scheduler.current_execution_context scheduler in\n stage (fun a -> Scheduler.enqueue scheduler execution_context f a)\n ;;\n\n let preserve_execution_context' f =\n let scheduler = Scheduler.t () in\n let execution_context = Scheduler.current_execution_context scheduler in\n let call_and_fill (f, a, i) = upon (f a) (fun r -> Ivar.fill i r) in\n stage (fun a ->\n Deferred.create (fun i ->\n Scheduler.enqueue scheduler execution_context call_and_fill (f, a, i)))\n ;;\nend\n\nopen Exported_for_scheduler\n\nlet stream_iter stream ~f =\n let rec loop stream =\n Stream.next stream\n >>> function\n | Nil -> ()\n | Cons (v, stream) ->\n loop stream;\n f v\n in\n loop stream\n;;\n\n(* An ['a Ok_and_exns.t] represents the output of a computation running in a detached\n monitor. *)\nmodule Ok_and_exns = struct\n type 'a t =\n { ok : 'a Deferred.t\n ; exns : exn Stream.t\n }\n [@@deriving fields, sexp_of]\n\n let create ?here ?info ?name ~run f =\n (* We call [create_with_parent None] because [monitor] does not need a parent. It\n does not because we call [detach_and_get_error_stream monitor] and deal with the\n errors explicitly, thus [send_exn] would never propagate an exn past [monitor]. *)\n let monitor = create_with_parent ?here ?info ?name None in\n let exns = detach_and_get_error_stream monitor in\n let ok =\n match run with\n | `Now -> within' ~monitor f\n | `Schedule -> schedule' ~monitor f\n in\n { ok; exns }\n ;;\nend\n\nlet fill_result_and_handle_background_errors\n result_filler\n result\n exns\n handle_exns_after_result\n =\n if Ivar_filler.is_empty result_filler\n then (\n Ivar_filler.fill result_filler result;\n handle_exns_after_result exns)\n;;\n\nmodule Expert = struct\n let try_with_log_exn : (exn -> unit) ref =\n ref (fun exn ->\n raise_s\n [%message \"failed to set [Monitor.Expert.try_with_log_exn]\" (exn : Exn.t)])\n ;;\nend\n\nlet make_handle_exn rest =\n match rest with\n | `Log ->\n (* We are careful to not close over current context, which is not needed. *)\n !Expert.try_with_log_exn\n | `Raise ->\n let parent = current () in\n fun exn -> send_exn parent exn ?backtrace:None\n | `Call f ->\n let parent = current () in\n fun exn -> within ~monitor:parent (fun () -> f exn)\n;;\n\nlet try_with\n ?here\n ?info\n ?(name = \"\")\n ?extract_exn:(do_extract_exn = false)\n ?(run = `Schedule)\n ?(rest = `Log)\n f\n =\n let { Ok_and_exns.ok; exns } = Ok_and_exns.create ?here ?info ~name ~run f in\n let handle_exn = make_handle_exn rest in\n let handle_exns_after_result exns = stream_iter exns ~f:handle_exn in\n (* We run [within' ~monitor:main] to avoid holding on to references to the evaluation\n context in which [try_with] was called. This avoids a space leak when a chain of\n [try_with]'s are run each nested within the previous one. Without the [within'], the\n error handling for the innermost [try_with] would keep alive the entire chain. *)\n within' ~monitor:main (fun () ->\n if Deferred.is_determined ok\n then (\n handle_exns_after_result exns;\n return (Ok (Deferred.value_exn ok)))\n else (\n let result_filler, result = Ivar_filler.create () in\n upon ok (fun res ->\n fill_result_and_handle_background_errors\n result_filler\n (Ok res)\n exns\n handle_exns_after_result);\n upon (Stream.next exns) (function\n | Nil -> assert false\n | Cons (exn, exns) ->\n let exn = if do_extract_exn then extract_exn exn else exn in\n fill_result_and_handle_background_errors\n result_filler\n (Error exn)\n exns\n handle_exns_after_result);\n result))\n;;\n\nlet try_with_or_error ?here ?info ?(name = \"try_with_or_error\") ?extract_exn f =\n try_with f ?here ?info ~name ?extract_exn ~run:`Now ~rest:`Log\n >>| Or_error.of_exn_result\n;;\n\nlet try_with_join_or_error ?here ?info ?(name = \"try_with_join_or_error\") ?extract_exn f =\n try_with_or_error f ?here ?info ~name ?extract_exn >>| Or_error.join\n;;\n\nlet protect ?here ?info ?(name = \"Monitor.protect\") ?extract_exn ?run f ~finally =\n let%bind r = try_with ?extract_exn ?here ?info ?run ~name f in\n let%map fr = try_with ~extract_exn:false ?here ?info ~name:\"finally\" finally in\n match r, fr with\n | Error exn, Error finally_exn ->\n raise_s [%message \"Async finally\" (exn : exn) (finally_exn : exn)]\n | Error e, Ok () | Ok _, Error e -> raise e\n | Ok r, Ok () -> r\n;;\n\nlet handle_errors ?here ?info ?name f handler =\n let { Ok_and_exns.ok; exns } = Ok_and_exns.create ?here ?info ?name ~run:`Now f in\n stream_iter exns ~f:handler;\n ok\n;;\n\nlet catch_stream ?here ?info ?name f =\n let { Ok_and_exns.exns; _ } =\n Ok_and_exns.create ?here ?info ?name ~run:`Now (fun () ->\n f ();\n return ())\n in\n exns\n;;\n\nlet catch ?here ?info ?name f =\n match%map Stream.next (catch_stream ?here ?info ?name f) with\n | Cons (x, _) -> x\n | Nil -> raise_s [%message \"Monitor.catch got unexpected empty stream\"]\n;;\n\nlet catch_error ?here ?info ?name f = catch ?here ?info ?name f >>| Error.of_exn\n","(** Contains Async's core data structures, like {{!Async_kernel.Deferred}[Deferred]},\n {{!Async_kernel.Ivar}[Ivar]}, and {{!Async_kernel.Clock_intf.Clock}[Clock]}.\n\n [Async_kernel] is designed to depend only on {{!Core_kernel}[Core_kernel]} (as opposed\n to {{!Core}[Core]}), and so is more platform-independent. *)\n\nopen! Core_kernel\nopen! Import\nmodule Async_kernel_config = Async_kernel_config\nmodule Async_kernel_require_explicit_time_source = Require_explicit_time_source\nmodule Async_kernel_scheduler = Async_kernel_scheduler\nmodule Bvar = Bvar\nmodule Clock_ns = Clock_ns\nmodule Condition = Async_condition\nmodule Deferred = Deferred\nmodule Execution_context = Execution_context\nmodule Gc = Async_gc\nmodule Invariant = Async_invariant\nmodule Ivar = Ivar\nmodule Lazy_deferred = Lazy_deferred\nmodule Monad_sequence = Monad_sequence\nmodule Monitor = Monitor\nmodule Mvar = Mvar\nmodule Pipe = Pipe\nmodule Priority = Priority\nmodule Sequencer = Throttle.Sequencer\nmodule Stream = Async_stream\nmodule Synchronous_time_source = Synchronous_time_source\nmodule Tail = Tail\nmodule Throttle = Throttle\nmodule Time_source = Time_source\nmodule Tracing = Tracing\n\n(** {2 Toplevel functions }\n\n The functions below are broadly useful when writing Async programs, and so are made\n available at the toplevel. *)\n\nlet after = Clock_ns.after\nlet at = Clock_ns.at\nlet catch = Monitor.catch\nlet choice = Deferred.choice\nlet choose = Deferred.choose\nlet don't_wait_for = Deferred.don't_wait_for\nlet every = Clock_ns.every\nlet never = Deferred.never\nlet schedule = Scheduler.schedule\nlet schedule' = Scheduler.schedule'\nlet try_with = Monitor.try_with\nlet upon = Deferred.upon\nlet with_timeout = Clock_ns.with_timeout\nlet within = Scheduler.within\nlet within' = Scheduler.within'\n\n(** {2 Infix operators and [Let_syntax] support} *)\n\ninclude (Deferred : Monad.Infix with type 'a t := 'a Deferred.t)\n\n(** equivalent to {!Deferred.upon}. *)\nlet ( >>> ) = Deferred.Infix.( >>> )\n\n(** equivalent to {!Deferred.Result.bind}. *)\nlet ( >>=? ) = Deferred.Result.( >>= )\n\n(** equivalent to {!Deferred.Result.map}. *)\nlet ( >>|? ) = Deferred.Result.( >>| )\n\ninclude Deferred.Let_syntax\n\n(**/**)\n\n(** The modules in [Async_kernel_private] are used for constructing and testing Async, and\n should not otherwise be used. *)\nmodule Async_kernel_private = struct\n module Debug = Debug\n module Ivar0 = Ivar0\n module Ivar_filler = Ivar_filler\n module Job = Job\n module Stack_or_counter = Stack_or_counter\nend\n\n(**/**)\n\n(* This test must be in this library, because it requires [return] to be inlined. Moving\n it to another library will cause it to break with [X_LIBRARY_INLINING=false]. *)\nlet%test_unit \"[return ()] does not allocate\" =\n let w1 = Gc.minor_words () in\n ignore (Sys.opaque_identity (return ()) : _ Deferred.t);\n ignore (Sys.opaque_identity (Deferred.return ()) : _ Deferred.t);\n ignore (Sys.opaque_identity (Deferred.Let_syntax.return ()) : _ Deferred.t);\n ignore (Sys.opaque_identity (Deferred.Let_syntax.Let_syntax.return ()) : _ Deferred.t);\n let w2 = Gc.minor_words () in\n [%test_result: int] w2 ~expect:w1\n;;\n","module By = Digestif_by\nmodule Bi = Digestif_bi\n\nlet failwith fmt = Format.kasprintf failwith fmt\n\nmodule Int32 = struct\n include Int32\n\n let ( lsl ) = Int32.shift_left\n\n let ( lsr ) = Int32.shift_right_logical\n\n let ( asr ) = Int32.shift_right\n\n let ( lor ) = Int32.logor\n\n let ( lxor ) = Int32.logxor\n\n let ( land ) = Int32.logand\n\n let lnot = Int32.lognot\n\n let ( + ) = Int32.add\n\n let rol32 a n = (a lsl n) lor (a lsr (32 - n))\n\n let ror32 a n = (a lsr n) lor (a lsl (32 - n))\nend\n\nmodule Int64 = struct\n include Int64\n\n let ( land ) = Int64.logand\n\n let ( lsl ) = Int64.shift_left\n\n let ( lsr ) = Int64.shift_right_logical\n\n let ( lor ) = Int64.logor\n\n let ( asr ) = Int64.shift_right\n\n let ( lxor ) = Int64.logxor\n\n let ( + ) = Int64.add\n\n let rol64 a n = (a lsl n) lor (a lsr (64 - n))\n\n let ror64 a n = (a lsr n) lor (a lsl (64 - n))\nend\n\nmodule type S = sig\n type ctx\n\n type kind = [ `BLAKE2B ]\n\n val init : unit -> ctx\n\n val with_outlen_and_bytes_key : int -> By.t -> int -> int -> ctx\n\n val with_outlen_and_bigstring_key : int -> Bi.t -> int -> int -> ctx\n\n val unsafe_feed_bytes : ctx -> By.t -> int -> int -> unit\n\n val unsafe_feed_bigstring : ctx -> Bi.t -> int -> int -> unit\n\n val unsafe_get : ctx -> By.t\n\n val dup : ctx -> ctx\n\n val max_outlen : int\nend\n\nmodule Unsafe : S = struct\n type kind = [ `BLAKE2B ]\n\n type param = {\n digest_length : int;\n key_length : int;\n fanout : int;\n depth : int;\n leaf_length : int32;\n node_offset : int32;\n xof_length : int32;\n node_depth : int;\n inner_length : int;\n reserved : int array;\n salt : int array;\n personal : int array;\n }\n\n type ctx = {\n mutable buflen : int;\n outlen : int;\n mutable last_node : int;\n buf : Bytes.t;\n h : int64 array;\n t : int64 array;\n f : int64 array;\n }\n\n let dup ctx =\n {\n buflen = ctx.buflen;\n outlen = ctx.outlen;\n last_node = ctx.last_node;\n buf = By.copy ctx.buf;\n h = Array.copy ctx.h;\n t = Array.copy ctx.t;\n f = Array.copy ctx.f;\n }\n\n let param_to_bytes param =\n let arr =\n [|\n param.digest_length land 0xFF;\n param.key_length land 0xFF;\n param.fanout land 0xFF;\n param.depth land 0xFF (* store to little-endian *);\n Int32.(to_int ((param.leaf_length lsr 0) land 0xFFl));\n Int32.(to_int ((param.leaf_length lsr 8) land 0xFFl));\n Int32.(to_int ((param.leaf_length lsr 16) land 0xFFl));\n Int32.(to_int ((param.leaf_length lsr 24) land 0xFFl))\n (* store to little-endian *);\n Int32.(to_int ((param.node_offset lsr 0) land 0xFFl));\n Int32.(to_int ((param.node_offset lsr 8) land 0xFFl));\n Int32.(to_int ((param.node_offset lsr 16) land 0xFFl));\n Int32.(to_int ((param.node_offset lsr 24) land 0xFFl))\n (* store to little-endian *);\n Int32.(to_int ((param.xof_length lsr 0) land 0xFFl));\n Int32.(to_int ((param.xof_length lsr 8) land 0xFFl));\n Int32.(to_int ((param.xof_length lsr 16) land 0xFFl));\n Int32.(to_int ((param.xof_length lsr 24) land 0xFFl));\n param.node_depth land 0xFF;\n param.inner_length land 0xFF;\n param.reserved.(0) land 0xFF;\n param.reserved.(1) land 0xFF;\n param.reserved.(2) land 0xFF;\n param.reserved.(3) land 0xFF;\n param.reserved.(4) land 0xFF;\n param.reserved.(5) land 0xFF;\n param.reserved.(6) land 0xFF;\n param.reserved.(7) land 0xFF;\n param.reserved.(8) land 0xFF;\n param.reserved.(9) land 0xFF;\n param.reserved.(10) land 0xFF;\n param.reserved.(11) land 0xFF;\n param.reserved.(12) land 0xFF;\n param.reserved.(13) land 0xFF;\n param.salt.(0) land 0xFF;\n param.salt.(1) land 0xFF;\n param.salt.(2) land 0xFF;\n param.salt.(3) land 0xFF;\n param.salt.(4) land 0xFF;\n param.salt.(5) land 0xFF;\n param.salt.(6) land 0xFF;\n param.salt.(7) land 0xFF;\n param.salt.(8) land 0xFF;\n param.salt.(9) land 0xFF;\n param.salt.(10) land 0xFF;\n param.salt.(11) land 0xFF;\n param.salt.(12) land 0xFF;\n param.salt.(13) land 0xFF;\n param.salt.(14) land 0xFF;\n param.salt.(15) land 0xFF;\n param.personal.(0) land 0xFF;\n param.personal.(1) land 0xFF;\n param.personal.(2) land 0xFF;\n param.personal.(3) land 0xFF;\n param.personal.(4) land 0xFF;\n param.personal.(5) land 0xFF;\n param.personal.(6) land 0xFF;\n param.personal.(7) land 0xFF;\n param.personal.(8) land 0xFF;\n param.personal.(9) land 0xFF;\n param.personal.(10) land 0xFF;\n param.personal.(11) land 0xFF;\n param.personal.(12) land 0xFF;\n param.personal.(13) land 0xFF;\n param.personal.(14) land 0xFF;\n param.personal.(15) land 0xFF;\n |] in\n By.init 64 (fun i -> Char.unsafe_chr arr.(i))\n\n let max_outlen = 64\n\n let default_param =\n {\n digest_length = max_outlen;\n key_length = 0;\n fanout = 1;\n depth = 1;\n leaf_length = 0l;\n node_offset = 0l;\n xof_length = 0l;\n node_depth = 0;\n inner_length = 0;\n reserved = [| 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0 |];\n salt = [| 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0 |];\n personal = [| 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0 |];\n }\n\n let iv =\n [|\n 0x6a09e667f3bcc908L;\n 0xbb67ae8584caa73bL;\n 0x3c6ef372fe94f82bL;\n 0xa54ff53a5f1d36f1L;\n 0x510e527fade682d1L;\n 0x9b05688c2b3e6c1fL;\n 0x1f83d9abfb41bd6bL;\n 0x5be0cd19137e2179L;\n |]\n\n let increment_counter ctx inc =\n let open Int64 in\n ctx.t.(0) <- ctx.t.(0) + inc ;\n ctx.t.(1) <- (ctx.t.(1) + if ctx.t.(0) < inc then 1L else 0L)\n\n let set_lastnode ctx = ctx.f.(1) <- Int64.minus_one\n\n let set_lastblock ctx =\n if ctx.last_node <> 0 then set_lastnode ctx ;\n ctx.f.(0) <- Int64.minus_one\n\n let init () =\n let buf = By.make 128 '\\x00' in\n By.fill buf 0 128 '\\x00' ;\n let ctx =\n {\n buflen = 0;\n outlen = default_param.digest_length;\n last_node = 0;\n buf;\n h = Array.make 8 0L;\n t = Array.make 2 0L;\n f = Array.make 2 0L;\n } in\n let param_bytes = param_to_bytes default_param in\n for i = 0 to 7 do\n ctx.h.(i) <- Int64.(iv.(i) lxor By.le64_to_cpu param_bytes (i * 8))\n done ;\n ctx\n\n let sigma =\n [|\n [| 0; 1; 2; 3; 4; 5; 6; 7; 8; 9; 10; 11; 12; 13; 14; 15 |];\n [| 14; 10; 4; 8; 9; 15; 13; 6; 1; 12; 0; 2; 11; 7; 5; 3 |];\n [| 11; 8; 12; 0; 5; 2; 15; 13; 10; 14; 3; 6; 7; 1; 9; 4 |];\n [| 7; 9; 3; 1; 13; 12; 11; 14; 2; 6; 5; 10; 4; 0; 15; 8 |];\n [| 9; 0; 5; 7; 2; 4; 10; 15; 14; 1; 11; 12; 6; 8; 3; 13 |];\n [| 2; 12; 6; 10; 0; 11; 8; 3; 4; 13; 7; 5; 15; 14; 1; 9 |];\n [| 12; 5; 1; 15; 14; 13; 4; 10; 0; 7; 6; 3; 9; 2; 8; 11 |];\n [| 13; 11; 7; 14; 12; 1; 3; 9; 5; 0; 15; 4; 8; 6; 2; 10 |];\n [| 6; 15; 14; 9; 11; 3; 0; 8; 12; 2; 13; 7; 1; 4; 10; 5 |];\n [| 10; 2; 8; 4; 7; 6; 1; 5; 15; 11; 9; 14; 3; 12; 13; 0 |];\n [| 0; 1; 2; 3; 4; 5; 6; 7; 8; 9; 10; 11; 12; 13; 14; 15 |];\n [| 14; 10; 4; 8; 9; 15; 13; 6; 1; 12; 0; 2; 11; 7; 5; 3 |];\n |]\n\n let compress :\n type a. le64_to_cpu:(a -> int -> int64) -> ctx -> a -> int -> unit =\n fun ~le64_to_cpu ctx block off ->\n let v = Array.make 16 0L in\n let m = Array.make 16 0L in\n let g r i a_idx b_idx c_idx d_idx =\n let ( ++ ) = ( + ) in\n let open Int64 in\n v.(a_idx) <- v.(a_idx) + v.(b_idx) + m.(sigma.(r).((2 * i) ++ 0)) ;\n v.(d_idx) <- ror64 (v.(d_idx) lxor v.(a_idx)) 32 ;\n v.(c_idx) <- v.(c_idx) + v.(d_idx) ;\n v.(b_idx) <- ror64 (v.(b_idx) lxor v.(c_idx)) 24 ;\n v.(a_idx) <- v.(a_idx) + v.(b_idx) + m.(sigma.(r).((2 * i) ++ 1)) ;\n v.(d_idx) <- ror64 (v.(d_idx) lxor v.(a_idx)) 16 ;\n v.(c_idx) <- v.(c_idx) + v.(d_idx) ;\n v.(b_idx) <- ror64 (v.(b_idx) lxor v.(c_idx)) 63 in\n let r r =\n g r 0 0 4 8 12 ;\n g r 1 1 5 9 13 ;\n g r 2 2 6 10 14 ;\n g r 3 3 7 11 15 ;\n g r 4 0 5 10 15 ;\n g r 5 1 6 11 12 ;\n g r 6 2 7 8 13 ;\n g r 7 3 4 9 14 in\n for i = 0 to 15 do\n m.(i) <- le64_to_cpu block (off + (i * 8))\n done ;\n for i = 0 to 7 do\n v.(i) <- ctx.h.(i)\n done ;\n v.(8) <- iv.(0) ;\n v.(9) <- iv.(1) ;\n v.(10) <- iv.(2) ;\n v.(11) <- iv.(3) ;\n v.(12) <- Int64.(iv.(4) lxor ctx.t.(0)) ;\n v.(13) <- Int64.(iv.(5) lxor ctx.t.(1)) ;\n v.(14) <- Int64.(iv.(6) lxor ctx.f.(0)) ;\n v.(15) <- Int64.(iv.(7) lxor ctx.f.(1)) ;\n r 0 ;\n r 1 ;\n r 2 ;\n r 3 ;\n r 4 ;\n r 5 ;\n r 6 ;\n r 7 ;\n r 8 ;\n r 9 ;\n r 10 ;\n r 11 ;\n let ( ++ ) = ( + ) in\n for i = 0 to 7 do\n ctx.h.(i) <- Int64.(ctx.h.(i) lxor v.(i) lxor v.(i ++ 8))\n done ;\n ()\n\n let feed :\n type a.\n blit:(a -> int -> By.t -> int -> int -> unit) ->\n le64_to_cpu:(a -> int -> int64) ->\n ctx ->\n a ->\n int ->\n int ->\n unit =\n fun ~blit ~le64_to_cpu ctx buf off len ->\n let in_off = ref off in\n let in_len = ref len in\n if !in_len > 0\n then (\n let left = ctx.buflen in\n let fill = 128 - left in\n if !in_len > fill\n then (\n ctx.buflen <- 0 ;\n blit buf !in_off ctx.buf left fill ;\n increment_counter ctx 128L ;\n compress ~le64_to_cpu:By.le64_to_cpu ctx ctx.buf 0 ;\n in_off := !in_off + fill ;\n in_len := !in_len - fill ;\n while !in_len > 128 do\n increment_counter ctx 128L ;\n compress ~le64_to_cpu ctx buf !in_off ;\n in_off := !in_off + 128 ;\n in_len := !in_len - 128\n done) ;\n blit buf !in_off ctx.buf ctx.buflen !in_len ;\n ctx.buflen <- ctx.buflen + !in_len) ;\n ()\n\n let unsafe_feed_bytes = feed ~blit:By.blit ~le64_to_cpu:By.le64_to_cpu\n\n let unsafe_feed_bigstring =\n feed ~blit:By.blit_from_bigstring ~le64_to_cpu:Bi.le64_to_cpu\n\n let with_outlen_and_key ~blit outlen key off len =\n if outlen > max_outlen\n then\n failwith \"out length can not be upper than %d (out length: %d)\" max_outlen\n outlen ;\n let buf = By.make 128 '\\x00' in\n let ctx =\n {\n buflen = 0;\n outlen;\n last_node = 0;\n buf;\n h = Array.make 8 0L;\n t = Array.make 2 0L;\n f = Array.make 2 0L;\n } in\n let param_bytes =\n param_to_bytes\n { default_param with digest_length = outlen; key_length = len } in\n for i = 0 to 7 do\n ctx.h.(i) <- Int64.(iv.(i) lxor By.le64_to_cpu param_bytes (i * 8))\n done ;\n if len > 0\n then (\n let block = By.make 128 '\\x00' in\n blit key off block 0 len ;\n unsafe_feed_bytes ctx block 0 128) ;\n ctx\n\n let with_outlen_and_bytes_key outlen key off len =\n with_outlen_and_key ~blit:By.blit outlen key off len\n\n let with_outlen_and_bigstring_key outlen key off len =\n with_outlen_and_key ~blit:By.blit_from_bigstring outlen key off len\n\n let unsafe_get ctx =\n let res = By.make default_param.digest_length '\\x00' in\n increment_counter ctx (Int64.of_int ctx.buflen) ;\n set_lastblock ctx ;\n By.fill ctx.buf ctx.buflen (128 - ctx.buflen) '\\x00' ;\n compress ~le64_to_cpu:By.le64_to_cpu ctx ctx.buf 0 ;\n for i = 0 to 7 do\n By.cpu_to_le64 res (i * 8) ctx.h.(i)\n done ;\n if ctx.outlen < default_param.digest_length\n then By.sub res 0 ctx.outlen\n else if ctx.outlen > default_param.digest_length\n then\n assert false\n (* XXX(dinosaure): [ctx] can not be initialized with [outlen > digest_length = max_outlen]. *)\n else res\nend\n","module By = Digestif_by\nmodule Bi = Digestif_bi\n\nlet failwith fmt = Format.kasprintf failwith fmt\n\nmodule Int32 = struct\n include Int32\n\n let ( lsl ) = Int32.shift_left\n\n let ( lsr ) = Int32.shift_right_logical\n\n let ( asr ) = Int32.shift_right\n\n let ( lor ) = Int32.logor\n\n let ( lxor ) = Int32.logxor\n\n let ( land ) = Int32.logand\n\n let lnot = Int32.lognot\n\n let ( + ) = Int32.add\n\n let rol32 a n = (a lsl n) lor (a lsr (32 - n))\n\n let ror32 a n = (a lsr n) lor (a lsl (32 - n))\nend\n\nmodule Int64 = struct\n include Int64\n\n let ( land ) = Int64.logand\n\n let ( lsl ) = Int64.shift_left\n\n let ( lsr ) = Int64.shift_right_logical\n\n let ( lor ) = Int64.logor\n\n let ( asr ) = Int64.shift_right\n\n let ( lxor ) = Int64.logxor\n\n let ( + ) = Int64.add\n\n let rol64 a n = (a lsl n) lor (a lsr (64 - n))\n\n let ror64 a n = (a lsr n) lor (a lsl (64 - n))\nend\n\nmodule type S = sig\n type ctx\n\n type kind = [ `BLAKE2S ]\n\n val init : unit -> ctx\n\n val with_outlen_and_bytes_key : int -> By.t -> int -> int -> ctx\n\n val with_outlen_and_bigstring_key : int -> Bi.t -> int -> int -> ctx\n\n val unsafe_feed_bytes : ctx -> By.t -> int -> int -> unit\n\n val unsafe_feed_bigstring : ctx -> Bi.t -> int -> int -> unit\n\n val unsafe_get : ctx -> By.t\n\n val dup : ctx -> ctx\n\n val max_outlen : int\nend\n\nmodule Unsafe : S = struct\n type kind = [ `BLAKE2S ]\n\n type param = {\n digest_length : int;\n key_length : int;\n fanout : int;\n depth : int;\n leaf_length : int32;\n node_offset : int32;\n xof_length : int;\n node_depth : int;\n inner_length : int;\n salt : int array;\n personal : int array;\n }\n\n type ctx = {\n mutable buflen : int;\n outlen : int;\n mutable last_node : int;\n buf : Bytes.t;\n h : int32 array;\n t : int32 array;\n f : int32 array;\n }\n\n let dup ctx =\n {\n buflen = ctx.buflen;\n outlen = ctx.outlen;\n last_node = ctx.last_node;\n buf = By.copy ctx.buf;\n h = Array.copy ctx.h;\n t = Array.copy ctx.t;\n f = Array.copy ctx.f;\n }\n\n let param_to_bytes param =\n let arr =\n [|\n param.digest_length land 0xFF;\n param.key_length land 0xFF;\n param.fanout land 0xFF;\n param.depth land 0xFF (* store to little-endian *);\n Int32.(to_int ((param.leaf_length lsr 0) land 0xFFl));\n Int32.(to_int ((param.leaf_length lsr 8) land 0xFFl));\n Int32.(to_int ((param.leaf_length lsr 16) land 0xFFl));\n Int32.(to_int ((param.leaf_length lsr 24) land 0xFFl))\n (* store to little-endian *);\n Int32.(to_int ((param.node_offset lsr 0) land 0xFFl));\n Int32.(to_int ((param.node_offset lsr 8) land 0xFFl));\n Int32.(to_int ((param.node_offset lsr 16) land 0xFFl));\n Int32.(to_int ((param.node_offset lsr 24) land 0xFFl))\n (* store to little-endian *);\n (param.xof_length lsr 0) land 0xFF;\n (param.xof_length lsr 8) land 0xFF;\n param.node_depth land 0xFF;\n param.inner_length land 0xFF;\n param.salt.(0) land 0xFF;\n param.salt.(1) land 0xFF;\n param.salt.(2) land 0xFF;\n param.salt.(3) land 0xFF;\n param.salt.(4) land 0xFF;\n param.salt.(5) land 0xFF;\n param.salt.(6) land 0xFF;\n param.salt.(7) land 0xFF;\n param.personal.(0) land 0xFF;\n param.personal.(1) land 0xFF;\n param.personal.(2) land 0xFF;\n param.personal.(3) land 0xFF;\n param.personal.(4) land 0xFF;\n param.personal.(5) land 0xFF;\n param.personal.(6) land 0xFF;\n param.personal.(7) land 0xFF;\n |] in\n By.init 32 (fun i -> Char.unsafe_chr arr.(i))\n\n let max_outlen = 32\n\n let default_param =\n {\n digest_length = max_outlen;\n key_length = 0;\n fanout = 1;\n depth = 1;\n leaf_length = 0l;\n node_offset = 0l;\n xof_length = 0;\n node_depth = 0;\n inner_length = 0;\n salt = [| 0; 0; 0; 0; 0; 0; 0; 0 |];\n personal = [| 0; 0; 0; 0; 0; 0; 0; 0 |];\n }\n\n let iv =\n [|\n 0x6A09E667l;\n 0xBB67AE85l;\n 0x3C6EF372l;\n 0xA54FF53Al;\n 0x510E527Fl;\n 0x9B05688Cl;\n 0x1F83D9ABl;\n 0x5BE0CD19l;\n |]\n\n let increment_counter ctx inc =\n let open Int32 in\n ctx.t.(0) <- ctx.t.(0) + inc ;\n ctx.t.(1) <- (ctx.t.(1) + if ctx.t.(0) < inc then 1l else 0l)\n\n let set_lastnode ctx = ctx.f.(1) <- Int32.minus_one\n\n let set_lastblock ctx =\n if ctx.last_node <> 0 then set_lastnode ctx ;\n ctx.f.(0) <- Int32.minus_one\n\n let init () =\n let buf = By.make 64 '\\x00' in\n let ctx =\n {\n buflen = 0;\n outlen = default_param.digest_length;\n last_node = 0;\n buf;\n h = Array.make 8 0l;\n t = Array.make 2 0l;\n f = Array.make 2 0l;\n } in\n let param_bytes = param_to_bytes default_param in\n for i = 0 to 7 do\n ctx.h.(i) <- Int32.(iv.(i) lxor By.le32_to_cpu param_bytes (i * 4))\n done ;\n ctx\n\n let sigma =\n [|\n [| 0; 1; 2; 3; 4; 5; 6; 7; 8; 9; 10; 11; 12; 13; 14; 15 |];\n [| 14; 10; 4; 8; 9; 15; 13; 6; 1; 12; 0; 2; 11; 7; 5; 3 |];\n [| 11; 8; 12; 0; 5; 2; 15; 13; 10; 14; 3; 6; 7; 1; 9; 4 |];\n [| 7; 9; 3; 1; 13; 12; 11; 14; 2; 6; 5; 10; 4; 0; 15; 8 |];\n [| 9; 0; 5; 7; 2; 4; 10; 15; 14; 1; 11; 12; 6; 8; 3; 13 |];\n [| 2; 12; 6; 10; 0; 11; 8; 3; 4; 13; 7; 5; 15; 14; 1; 9 |];\n [| 12; 5; 1; 15; 14; 13; 4; 10; 0; 7; 6; 3; 9; 2; 8; 11 |];\n [| 13; 11; 7; 14; 12; 1; 3; 9; 5; 0; 15; 4; 8; 6; 2; 10 |];\n [| 6; 15; 14; 9; 11; 3; 0; 8; 12; 2; 13; 7; 1; 4; 10; 5 |];\n [| 10; 2; 8; 4; 7; 6; 1; 5; 15; 11; 9; 14; 3; 12; 13; 0 |];\n |]\n\n let compress :\n type a. le32_to_cpu:(a -> int -> int32) -> ctx -> a -> int -> unit =\n fun ~le32_to_cpu ctx block off ->\n let v = Array.make 16 0l in\n let m = Array.make 16 0l in\n let g r i a_idx b_idx c_idx d_idx =\n let ( ++ ) = ( + ) in\n let open Int32 in\n v.(a_idx) <- v.(a_idx) + v.(b_idx) + m.(sigma.(r).((2 * i) ++ 0)) ;\n v.(d_idx) <- ror32 (v.(d_idx) lxor v.(a_idx)) 16 ;\n v.(c_idx) <- v.(c_idx) + v.(d_idx) ;\n v.(b_idx) <- ror32 (v.(b_idx) lxor v.(c_idx)) 12 ;\n v.(a_idx) <- v.(a_idx) + v.(b_idx) + m.(sigma.(r).((2 * i) ++ 1)) ;\n v.(d_idx) <- ror32 (v.(d_idx) lxor v.(a_idx)) 8 ;\n v.(c_idx) <- v.(c_idx) + v.(d_idx) ;\n v.(b_idx) <- ror32 (v.(b_idx) lxor v.(c_idx)) 7 in\n let r r =\n g r 0 0 4 8 12 ;\n g r 1 1 5 9 13 ;\n g r 2 2 6 10 14 ;\n g r 3 3 7 11 15 ;\n g r 4 0 5 10 15 ;\n g r 5 1 6 11 12 ;\n g r 6 2 7 8 13 ;\n g r 7 3 4 9 14 in\n for i = 0 to 15 do\n m.(i) <- le32_to_cpu block (off + (i * 4))\n done ;\n for i = 0 to 7 do\n v.(i) <- ctx.h.(i)\n done ;\n v.(8) <- iv.(0) ;\n v.(9) <- iv.(1) ;\n v.(10) <- iv.(2) ;\n v.(11) <- iv.(3) ;\n v.(12) <- Int32.(iv.(4) lxor ctx.t.(0)) ;\n v.(13) <- Int32.(iv.(5) lxor ctx.t.(1)) ;\n v.(14) <- Int32.(iv.(6) lxor ctx.f.(0)) ;\n v.(15) <- Int32.(iv.(7) lxor ctx.f.(1)) ;\n r 0 ;\n r 1 ;\n r 2 ;\n r 3 ;\n r 4 ;\n r 5 ;\n r 6 ;\n r 7 ;\n r 8 ;\n r 9 ;\n let ( ++ ) = ( + ) in\n for i = 0 to 7 do\n ctx.h.(i) <- Int32.(ctx.h.(i) lxor v.(i) lxor v.(i ++ 8))\n done ;\n ()\n\n let feed :\n type a.\n blit:(a -> int -> By.t -> int -> int -> unit) ->\n le32_to_cpu:(a -> int -> int32) ->\n ctx ->\n a ->\n int ->\n int ->\n unit =\n fun ~blit ~le32_to_cpu ctx buf off len ->\n let in_off = ref off in\n let in_len = ref len in\n if !in_len > 0\n then (\n let left = ctx.buflen in\n let fill = 64 - left in\n if !in_len > fill\n then (\n ctx.buflen <- 0 ;\n blit buf !in_off ctx.buf left fill ;\n increment_counter ctx 64l ;\n compress ~le32_to_cpu:By.le32_to_cpu ctx ctx.buf 0 ;\n in_off := !in_off + fill ;\n in_len := !in_len - fill ;\n while !in_len > 64 do\n increment_counter ctx 64l ;\n compress ~le32_to_cpu ctx buf !in_off ;\n in_off := !in_off + 64 ;\n in_len := !in_len - 64\n done) ;\n blit buf !in_off ctx.buf ctx.buflen !in_len ;\n ctx.buflen <- ctx.buflen + !in_len) ;\n ()\n\n let unsafe_feed_bytes = feed ~blit:By.blit ~le32_to_cpu:By.le32_to_cpu\n\n let unsafe_feed_bigstring =\n feed ~blit:By.blit_from_bigstring ~le32_to_cpu:Bi.le32_to_cpu\n\n let with_outlen_and_key ~blit outlen key off len =\n if outlen > max_outlen\n then\n failwith \"out length can not be upper than %d (out length: %d)\" max_outlen\n outlen ;\n let buf = By.make 64 '\\x00' in\n let ctx =\n {\n buflen = 0;\n outlen;\n last_node = 0;\n buf;\n h = Array.make 8 0l;\n t = Array.make 2 0l;\n f = Array.make 2 0l;\n } in\n let param_bytes =\n param_to_bytes\n { default_param with key_length = len; digest_length = outlen } in\n for i = 0 to 7 do\n ctx.h.(i) <- Int32.(iv.(i) lxor By.le32_to_cpu param_bytes (i * 4))\n done ;\n if len > 0\n then (\n let block = By.make 64 '\\x00' in\n blit key off block 0 len ;\n unsafe_feed_bytes ctx block 0 64) ;\n ctx\n\n let with_outlen_and_bytes_key outlen key off len =\n with_outlen_and_key ~blit:By.blit outlen key off len\n\n let with_outlen_and_bigstring_key outlen key off len =\n with_outlen_and_key ~blit:By.blit_from_bigstring outlen key off len\n\n let unsafe_get ctx =\n let res = By.make default_param.digest_length '\\x00' in\n increment_counter ctx (Int32.of_int ctx.buflen) ;\n set_lastblock ctx ;\n By.fill ctx.buf ctx.buflen (64 - ctx.buflen) '\\x00' ;\n compress ~le32_to_cpu:By.le32_to_cpu ctx ctx.buf 0 ;\n for i = 0 to 7 do\n By.cpu_to_le32 res (i * 4) ctx.h.(i)\n done ;\n if ctx.outlen < default_param.digest_length\n then By.sub res 0 ctx.outlen\n else if ctx.outlen > default_param.digest_length\n then\n assert false\n (* XXX(dinosaure): [ctx] can not be initialized with [outlen > digest_length = max_outlen]. *)\n else res\nend\n","type bigstring =\n ( char,\n Bigarray_compat.int8_unsigned_elt,\n Bigarray_compat.c_layout )\n Bigarray_compat.Array1.t\n\ntype 'a iter = ('a -> unit) -> unit\n\ntype 'a compare = 'a -> 'a -> int\n\ntype 'a equal = 'a -> 'a -> bool\n\ntype 'a pp = Format.formatter -> 'a -> unit\n\nmodule By = Digestif_by\nmodule Bi = Digestif_bi\nmodule Eq = Digestif_eq\nmodule Hash = Digestif_hash\nmodule Conv = Digestif_conv\n\nlet failwith fmt = Format.ksprintf failwith fmt\n\nmodule type S = sig\n val digest_size : int\n\n type ctx\n\n type kind\n\n type t\n\n val kind : kind\n\n val empty : ctx\n\n val init : unit -> ctx\n\n val feed_bytes : ctx -> ?off:int -> ?len:int -> Bytes.t -> ctx\n\n val feed_string : ctx -> ?off:int -> ?len:int -> String.t -> ctx\n\n val feed_bigstring : ctx -> ?off:int -> ?len:int -> bigstring -> ctx\n\n val feedi_bytes : ctx -> Bytes.t iter -> ctx\n\n val feedi_string : ctx -> String.t iter -> ctx\n\n val feedi_bigstring : ctx -> bigstring iter -> ctx\n\n val get : ctx -> t\n\n val digest_bytes : ?off:int -> ?len:int -> Bytes.t -> t\n\n val digest_string : ?off:int -> ?len:int -> String.t -> t\n\n val digest_bigstring : ?off:int -> ?len:int -> bigstring -> t\n\n val digesti_bytes : Bytes.t iter -> t\n\n val digesti_string : String.t iter -> t\n\n val digesti_bigstring : bigstring iter -> t\n\n val digestv_bytes : Bytes.t list -> t\n\n val digestv_string : String.t list -> t\n\n val digestv_bigstring : bigstring list -> t\n\n val hmac_bytes : key:Bytes.t -> ?off:int -> ?len:int -> Bytes.t -> t\n\n val hmac_string : key:String.t -> ?off:int -> ?len:int -> String.t -> t\n\n val hmac_bigstring : key:bigstring -> ?off:int -> ?len:int -> bigstring -> t\n\n val hmaci_bytes : key:Bytes.t -> Bytes.t iter -> t\n\n val hmaci_string : key:String.t -> String.t iter -> t\n\n val hmaci_bigstring : key:bigstring -> bigstring iter -> t\n\n val hmacv_bytes : key:Bytes.t -> Bytes.t list -> t\n\n val hmacv_string : key:String.t -> String.t list -> t\n\n val hmacv_bigstring : key:bigstring -> bigstring list -> t\n\n val unsafe_compare : t compare\n\n val equal : t equal\n\n val pp : t pp\n\n val of_hex : string -> t\n\n val of_hex_opt : string -> t option\n\n val consistent_of_hex : string -> t\n\n val consistent_of_hex_opt : string -> t option\n\n val to_hex : t -> string\n\n val of_raw_string : string -> t\n\n val of_raw_string_opt : string -> t option\n\n val to_raw_string : t -> string\nend\n\nmodule type MAC = sig\n type t\n\n val mac_bytes : key:Bytes.t -> ?off:int -> ?len:int -> Bytes.t -> t\n\n val mac_string : key:String.t -> ?off:int -> ?len:int -> String.t -> t\n\n val mac_bigstring : key:bigstring -> ?off:int -> ?len:int -> bigstring -> t\n\n val maci_bytes : key:Bytes.t -> Bytes.t iter -> t\n\n val maci_string : key:String.t -> String.t iter -> t\n\n val maci_bigstring : key:bigstring -> bigstring iter -> t\n\n val macv_bytes : key:Bytes.t -> Bytes.t list -> t\n\n val macv_string : key:String.t -> String.t list -> t\n\n val macv_bigstring : key:bigstring -> bigstring list -> t\nend\n\nmodule type Desc = sig\n type kind\n\n val digest_size : int\n\n val block_size : int\n\n val kind : kind\nend\n\nmodule type Hash = sig\n type ctx\n\n type kind\n\n val init : unit -> ctx\n\n val unsafe_feed_bytes : ctx -> By.t -> int -> int -> unit\n\n val unsafe_feed_bigstring : ctx -> Bi.t -> int -> int -> unit\n\n val unsafe_get : ctx -> By.t\n\n val dup : ctx -> ctx\nend\n\nmodule Unsafe (Hash : Hash) (D : Desc) = struct\n open Hash\n\n let digest_size = D.digest_size\n\n let block_size = D.block_size\n\n let empty = init ()\n\n let init = init\n\n let unsafe_feed_bytes ctx ?off ?len buf =\n let off, len =\n match (off, len) with\n | Some off, Some len -> (off, len)\n | Some off, None -> (off, By.length buf - off)\n | None, Some len -> (0, len)\n | None, None -> (0, By.length buf) in\n if off < 0 || len < 0 || off > By.length buf - len\n then invalid_arg \"offset out of bounds\"\n else unsafe_feed_bytes ctx buf off len\n\n let unsafe_feed_string ctx ?off ?len buf =\n unsafe_feed_bytes ctx ?off ?len (By.unsafe_of_string buf)\n\n let unsafe_feed_bigstring ctx ?off ?len buf =\n let off, len =\n match (off, len) with\n | Some off, Some len -> (off, len)\n | Some off, None -> (off, Bi.length buf - off)\n | None, Some len -> (0, len)\n | None, None -> (0, Bi.length buf) in\n if off < 0 || len < 0 || off > Bi.length buf - len\n then invalid_arg \"offset out of bounds\"\n else unsafe_feed_bigstring ctx buf off len\n\n let unsafe_get = unsafe_get\nend\n\nmodule Core (Hash : Hash) (D : Desc) = struct\n type t = string\n\n type ctx = Hash.ctx\n\n type kind = Hash.kind\n\n include Unsafe (Hash) (D)\n include Conv.Make (D)\n include Eq.Make (D)\n\n let kind = D.kind\n\n let get t =\n let t = Hash.dup t in\n unsafe_get t |> By.unsafe_to_string\n\n let feed_bytes t ?off ?len buf =\n let t = Hash.dup t in\n unsafe_feed_bytes t ?off ?len buf ;\n t\n\n let feed_string t ?off ?len buf =\n let t = Hash.dup t in\n unsafe_feed_string t ?off ?len buf ;\n t\n\n let feed_bigstring t ?off ?len buf =\n let t = Hash.dup t in\n unsafe_feed_bigstring t ?off ?len buf ;\n t\n\n let feedi_bytes t iter =\n let t = Hash.dup t in\n let feed buf = unsafe_feed_bytes t buf in\n iter feed ;\n t\n\n let feedi_string t iter =\n let t = Hash.dup t in\n let feed buf = unsafe_feed_string t buf in\n iter feed ;\n t\n\n let feedi_bigstring t iter =\n let t = Hash.dup t in\n let feed buf = unsafe_feed_bigstring t buf in\n iter feed ;\n t\n\n let digest_bytes ?off ?len buf = feed_bytes empty ?off ?len buf |> get\n\n let digest_string ?off ?len buf = feed_string empty ?off ?len buf |> get\n\n let digest_bigstring ?off ?len buf = feed_bigstring empty ?off ?len buf |> get\n\n let digesti_bytes iter = feedi_bytes empty iter |> get\n\n let digesti_string iter = feedi_string empty iter |> get\n\n let digesti_bigstring iter = feedi_bigstring empty iter |> get\n\n let digestv_bytes lst = digesti_bytes (fun f -> List.iter f lst)\n\n let digestv_string lst = digesti_string (fun f -> List.iter f lst)\n\n let digestv_bigstring lst = digesti_bigstring (fun f -> List.iter f lst)\nend\n\nmodule Make (H : Hash) (D : Desc) = struct\n include Core (H) (D)\n\n let bytes_opad = By.init block_size (fun _ -> '\\x5c')\n\n let bytes_ipad = By.init block_size (fun _ -> '\\x36')\n\n let rec norm_bytes key =\n match Stdlib.compare (By.length key) block_size with\n | 1 -> norm_bytes (By.unsafe_of_string (digest_bytes key))\n | -1 -> By.rpad key block_size '\\000'\n | _ -> key\n\n let bigstring_opad = Bi.init block_size (fun _ -> '\\x5c')\n\n let bigstring_ipad = Bi.init block_size (fun _ -> '\\x36')\n\n let norm_bigstring key =\n let key = Bi.to_string key in\n let res0 = norm_bytes (By.unsafe_of_string key) in\n let res1 = Bi.create (By.length res0) in\n Bi.blit_from_bytes res0 0 res1 0 (By.length res0) ;\n res1\n\n let hmaci_bytes ~key iter =\n let key = norm_bytes key in\n let outer = Xor.Bytes.xor key bytes_opad in\n let inner = Xor.Bytes.xor key bytes_ipad in\n let res =\n digesti_bytes (fun f ->\n f inner ;\n iter f) in\n digesti_bytes (fun f ->\n f outer ;\n f (By.unsafe_of_string res))\n\n let hmaci_string ~key iter =\n let key = norm_bytes (By.unsafe_of_string key) in\n (* XXX(dinosaure): safe, [rpad] and [digest] have a read-only access. *)\n let outer = Xor.Bytes.xor key bytes_opad in\n let inner = Xor.Bytes.xor key bytes_ipad in\n let ctx = feed_bytes empty inner in\n let res = feedi_string ctx iter |> get in\n let ctx = feed_bytes empty outer in\n feed_string ctx (res :> string) |> get\n\n let hmaci_bigstring ~key iter =\n let key = norm_bigstring key in\n let outer = Xor.Bigstring.xor key bigstring_opad in\n let inner = Xor.Bigstring.xor key bigstring_ipad in\n let res =\n digesti_bigstring (fun f ->\n f inner ;\n iter f) in\n let ctx = feed_bigstring empty outer in\n feed_string ctx (res :> string) |> get\n\n let hmac_bytes ~key ?off ?len buf =\n let buf =\n match (off, len) with\n | Some off, Some len -> By.sub buf off len\n | Some off, None -> By.sub buf off (By.length buf - off)\n | None, Some len -> By.sub buf 0 len\n | None, None -> buf in\n hmaci_bytes ~key (fun f -> f buf)\n\n let hmac_string ~key ?off ?len buf =\n let buf =\n match (off, len) with\n | Some off, Some len -> String.sub buf off len\n | Some off, None -> String.sub buf off (String.length buf - off)\n | None, Some len -> String.sub buf 0 len\n | None, None -> buf in\n hmaci_string ~key (fun f -> f buf)\n\n let hmac_bigstring ~key ?off ?len buf =\n let buf =\n match (off, len) with\n | Some off, Some len -> Bi.sub buf off len\n | Some off, None -> Bi.sub buf off (Bi.length buf - off)\n | None, Some len -> Bi.sub buf 0 len\n | None, None -> buf in\n hmaci_bigstring ~key (fun f -> f buf)\n\n let hmacv_bytes ~key bufs = hmaci_bytes ~key (fun f -> List.iter f bufs)\n\n let hmacv_string ~key bufs = hmaci_string ~key (fun f -> List.iter f bufs)\n\n let hmacv_bigstring ~key bufs =\n hmaci_bigstring ~key (fun f -> List.iter f bufs)\nend\n\nmodule type Hash_BLAKE2 = sig\n type ctx\n\n type kind\n\n val with_outlen_and_bytes_key : int -> By.t -> int -> int -> ctx\n\n val with_outlen_and_bigstring_key : int -> Bi.t -> int -> int -> ctx\n\n val unsafe_feed_bytes : ctx -> By.t -> int -> int -> unit\n\n val unsafe_feed_bigstring : ctx -> Bi.t -> int -> int -> unit\n\n val unsafe_get : ctx -> By.t\n\n val dup : ctx -> ctx\n\n val max_outlen : int\nend\n\nmodule Make_BLAKE2 (H : Hash_BLAKE2) (D : Desc) = struct\n let () =\n if D.digest_size > H.max_outlen\n then\n failwith \"Invalid digest_size:%d to make a BLAKE2{S,B} implementation\"\n D.digest_size\n\n include Make\n (struct\n type ctx = H.ctx\n\n type kind = H.kind\n\n let init () =\n H.with_outlen_and_bytes_key D.digest_size By.empty 0 0\n\n let unsafe_feed_bytes = H.unsafe_feed_bytes\n\n let unsafe_feed_bigstring = H.unsafe_feed_bigstring\n\n let unsafe_get = H.unsafe_get\n\n let dup = H.dup\n end)\n (D)\n\n type outer = t\n\n module Keyed = struct\n type t = outer\n\n let maci_bytes ~key iter =\n let ctx = H.with_outlen_and_bytes_key digest_size key 0 (By.length key) in\n feedi_bytes ctx iter |> get\n\n let maci_string ~key iter =\n let ctx =\n H.with_outlen_and_bytes_key digest_size (By.unsafe_of_string key) 0\n (String.length key) in\n feedi_string ctx iter |> get\n\n let maci_bigstring ~key iter =\n let ctx =\n H.with_outlen_and_bigstring_key digest_size key 0 (Bi.length key) in\n feedi_bigstring ctx iter |> get\n\n let mac_bytes ~key ?off ?len buf : t =\n let buf =\n match (off, len) with\n | Some off, Some len -> By.sub buf off len\n | Some off, None -> By.sub buf off (By.length buf - off)\n | None, Some len -> By.sub buf 0 len\n | None, None -> buf in\n maci_bytes ~key (fun f -> f buf)\n\n let mac_string ~key ?off ?len buf =\n let buf =\n match (off, len) with\n | Some off, Some len -> String.sub buf off len\n | Some off, None -> String.sub buf off (String.length buf - off)\n | None, Some len -> String.sub buf 0 len\n | None, None -> buf in\n maci_string ~key (fun f -> f buf)\n\n let mac_bigstring ~key ?off ?len buf =\n let buf =\n match (off, len) with\n | Some off, Some len -> Bi.sub buf off len\n | Some off, None -> Bi.sub buf off (Bi.length buf - off)\n | None, Some len -> Bi.sub buf 0 len\n | None, None -> buf in\n maci_bigstring ~key (fun f -> f buf)\n\n let macv_bytes ~key bufs = maci_bytes ~key (fun f -> List.iter f bufs)\n\n let macv_string ~key bufs = maci_string ~key (fun f -> List.iter f bufs)\n\n let macv_bigstring ~key bufs =\n maci_bigstring ~key (fun f -> List.iter f bufs)\n end\nend\n\nmodule MD5 : S with type kind = [ `MD5 ] =\n Make\n (Baijiu_md5.Unsafe)\n (struct\n let digest_size, block_size = (16, 64)\n\n type kind = [ `MD5 ]\n\n let kind = `MD5\n end)\n\nmodule SHA1 : S with type kind = [ `SHA1 ] =\n Make\n (Baijiu_sha1.Unsafe)\n (struct\n let digest_size, block_size = (20, 64)\n\n type kind = [ `SHA1 ]\n\n let kind = `SHA1\n end)\n\nmodule SHA224 : S with type kind = [ `SHA224 ] =\n Make\n (Baijiu_sha224.Unsafe)\n (struct\n let digest_size, block_size = (28, 64)\n\n type kind = [ `SHA224 ]\n\n let kind = `SHA224\n end)\n\nmodule SHA256 : S with type kind = [ `SHA256 ] =\n Make\n (Baijiu_sha256.Unsafe)\n (struct\n let digest_size, block_size = (32, 64)\n\n type kind = [ `SHA256 ]\n\n let kind = `SHA256\n end)\n\nmodule SHA384 : S with type kind = [ `SHA384 ] =\n Make\n (Baijiu_sha384.Unsafe)\n (struct\n let digest_size, block_size = (48, 128)\n\n type kind = [ `SHA384 ]\n\n let kind = `SHA384\n end)\n\nmodule SHA512 : S with type kind = [ `SHA512 ] =\n Make\n (Baijiu_sha512.Unsafe)\n (struct\n let digest_size, block_size = (64, 128)\n\n type kind = [ `SHA512 ]\n\n let kind = `SHA512\n end)\n\nmodule SHA3_224 : S with type kind = [ `SHA3_224 ] =\n Make\n (Baijiu_sha3_224.Unsafe)\n (struct\n let digest_size, block_size = (28, 144)\n\n type kind = [ `SHA3_224 ]\n\n let kind = `SHA3_224\n end)\n\nmodule SHA3_256 : S with type kind = [ `SHA3_256 ] =\n Make\n (Baijiu_sha3_256.Unsafe)\n (struct\n let digest_size, block_size = (32, 136)\n\n type kind = [ `SHA3_256 ]\n\n let kind = `SHA3_256\n end)\n\nmodule SHA3_384 : S with type kind = [ `SHA3_384 ] =\n Make\n (Baijiu_sha3_384.Unsafe)\n (struct\n let digest_size, block_size = (48, 104)\n\n type kind = [ `SHA3_384 ]\n\n let kind = `SHA3_384\n end)\n\nmodule SHA3_512 : S with type kind = [ `SHA3_512 ] =\n Make\n (Baijiu_sha3_512.Unsafe)\n (struct\n let digest_size, block_size = (64, 72)\n\n type kind = [ `SHA3_512 ]\n\n let kind = `SHA3_512\n end)\n\nmodule WHIRLPOOL : S with type kind = [ `WHIRLPOOL ] =\n Make\n (Baijiu_whirlpool.Unsafe)\n (struct\n let digest_size, block_size = (64, 64)\n\n type kind = [ `WHIRLPOOL ]\n\n let kind = `WHIRLPOOL\n end)\n\nmodule BLAKE2B : sig\n include S with type kind = [ `BLAKE2B ]\n\n module Keyed : MAC with type t = t\nend =\n Make_BLAKE2\n (Baijiu_blake2b.Unsafe)\n (struct\n let digest_size, block_size = (64, 128)\n\n type kind = [ `BLAKE2B ]\n\n let kind = `BLAKE2B\n end)\n\nmodule BLAKE2S : sig\n include S with type kind = [ `BLAKE2S ]\n\n module Keyed : MAC with type t = t\nend =\n Make_BLAKE2\n (Baijiu_blake2s.Unsafe)\n (struct\n let digest_size, block_size = (32, 64)\n\n type kind = [ `BLAKE2S ]\n\n let kind = `BLAKE2S\n end)\n\nmodule RMD160 : S with type kind = [ `RMD160 ] =\n Make\n (Baijiu_rmd160.Unsafe)\n (struct\n let digest_size, block_size = (20, 64)\n\n type kind = [ `RMD160 ]\n\n let kind = `RMD160\n end)\n\nmodule Make_BLAKE2B (D : sig\n val digest_size : int\nend) : S with type kind = [ `BLAKE2B ] = struct\n include Make_BLAKE2\n (Baijiu_blake2b.Unsafe)\n (struct\n let digest_size, block_size = (D.digest_size, 128)\n\n type kind = [ `BLAKE2B ]\n\n let kind = `BLAKE2B\n end)\nend\n\nmodule Make_BLAKE2S (D : sig\n val digest_size : int\nend) : S with type kind = [ `BLAKE2S ] = struct\n include Make_BLAKE2\n (Baijiu_blake2s.Unsafe)\n (struct\n let digest_size, block_size = (D.digest_size, 64)\n\n type kind = [ `BLAKE2S ]\n\n let kind = `BLAKE2S\n end)\nend\n\ninclude Hash\n\ntype blake2b = (module S with type kind = [ `BLAKE2B ])\n\ntype blake2s = (module S with type kind = [ `BLAKE2S ])\n\nlet module_of : type k. k hash -> (module S with type kind = k) =\n fun hash ->\n let b2b : (int, blake2b) Hashtbl.t = Hashtbl.create 13 in\n let b2s : (int, blake2s) Hashtbl.t = Hashtbl.create 13 in\n match hash with\n | MD5 -> (module MD5)\n | SHA1 -> (module SHA1)\n | RMD160 -> (module RMD160)\n | SHA224 -> (module SHA224)\n | SHA256 -> (module SHA256)\n | SHA384 -> (module SHA384)\n | SHA512 -> (module SHA512)\n | SHA3_224 -> (module SHA3_224)\n | SHA3_256 -> (module SHA3_256)\n | SHA3_384 -> (module SHA3_384)\n | SHA3_512 -> (module SHA3_512)\n | WHIRLPOOL -> (module WHIRLPOOL)\n | BLAKE2B digest_size -> (\n match Hashtbl.find b2b digest_size with\n | exception Not_found ->\n let m : (module S with type kind = [ `BLAKE2B ]) =\n (module Make_BLAKE2B (struct\n let digest_size = digest_size\n end) : S\n with type kind = [ `BLAKE2B ]) in\n Hashtbl.replace b2b digest_size m ;\n m\n | m -> m)\n | BLAKE2S digest_size ->\n match Hashtbl.find b2s digest_size with\n | exception Not_found ->\n let m =\n (module Make_BLAKE2S (struct\n let digest_size = digest_size\n end) : S\n with type kind = [ `BLAKE2S ]) in\n Hashtbl.replace b2s digest_size m ;\n m\n | m -> m\n\ntype 'kind t = string\n\nlet digest_bytes : type k. k hash -> Bytes.t -> k t =\n fun hash buf ->\n let module H = (val module_of hash) in\n (H.to_raw_string (H.digest_bytes buf) : H.kind t)\n\nlet digest_string : type k. k hash -> String.t -> k t =\n fun hash buf ->\n let module H = (val module_of hash) in\n (H.to_raw_string (H.digest_string buf) : H.kind t)\n\nlet digest_bigstring : type k. k hash -> bigstring -> k t =\n fun hash buf ->\n let module H = (val module_of hash) in\n (H.to_raw_string (H.digest_bigstring buf) : H.kind t)\n\nlet digesti_bytes : type k. k hash -> Bytes.t iter -> k t =\n fun hash iter ->\n let module H = (val module_of hash) in\n (H.to_raw_string (H.digesti_bytes iter) : H.kind t)\n\nlet digesti_string : type k. k hash -> String.t iter -> k t =\n fun hash iter ->\n let module H = (val module_of hash) in\n (H.to_raw_string (H.digesti_string iter) : H.kind t)\n\nlet digesti_bigstring : type k. k hash -> bigstring iter -> k t =\n fun hash iter ->\n let module H = (val module_of hash) in\n (H.to_raw_string (H.digesti_bigstring iter) : H.kind t)\n\nlet hmaci_bytes : type k. k hash -> key:Bytes.t -> Bytes.t iter -> k t =\n fun hash ~key iter ->\n let module H = (val module_of hash) in\n (H.to_raw_string (H.hmaci_bytes ~key iter) : H.kind t)\n\nlet hmaci_string : type k. k hash -> key:String.t -> String.t iter -> k t =\n fun hash ~key iter ->\n let module H = (val module_of hash) in\n (H.to_raw_string (H.hmaci_string ~key iter) : H.kind t)\n\nlet hmaci_bigstring : type k. k hash -> key:bigstring -> bigstring iter -> k t =\n fun hash ~key iter ->\n let module H = (val module_of hash) in\n (H.to_raw_string (H.hmaci_bigstring ~key iter) : H.kind t)\n\n(* XXX(dinosaure): unsafe part to avoid overhead. *)\n\nlet unsafe_compare : type k. k hash -> k t -> k t -> int =\n fun hash a b ->\n let module H = (val module_of hash) in\n let unsafe : 'k t -> H.t = H.of_raw_string in\n H.unsafe_compare (unsafe a) (unsafe b)\n\nlet equal : type k. k hash -> k t equal =\n fun hash a b ->\n let module H = (val module_of hash) in\n let unsafe : 'k t -> H.t = H.of_raw_string in\n H.equal (unsafe a) (unsafe b)\n\nlet pp : type k. k hash -> k t pp =\n fun hash ppf t ->\n let module H = (val module_of hash) in\n let unsafe : 'k t -> H.t = H.of_raw_string in\n H.pp ppf (unsafe t)\n\nlet of_hex : type k. k hash -> string -> k t =\n fun hash hex ->\n let module H = (val module_of hash) in\n H.to_raw_string (H.of_hex hex)\n\nlet of_hex_opt : type k. k hash -> string -> k t option =\n fun hash hex ->\n let module H = (val module_of hash) in\n match H.of_hex_opt hex with\n | None -> None\n | Some digest -> Some (H.to_raw_string digest)\n\nlet consistent_of_hex : type k. k hash -> string -> k t =\n fun hash hex ->\n let module H = (val module_of hash) in\n H.to_raw_string (H.consistent_of_hex hex)\n\nlet consistent_of_hex_opt : type k. k hash -> string -> k t option =\n fun hash hex ->\n let module H = (val module_of hash) in\n match H.consistent_of_hex_opt hex with\n | None -> None\n | Some digest -> Some (H.to_raw_string digest)\n\nlet to_hex : type k. k hash -> k t -> string =\n fun hash t ->\n let module H = (val module_of hash) in\n let unsafe : 'k t -> H.t = H.of_raw_string in\n H.to_hex (unsafe t)\n\nlet of_raw_string : type k. k hash -> string -> k t =\n fun hash s ->\n let module H = (val module_of hash) in\n let unsafe : H.t -> 'k t = H.to_raw_string in\n unsafe (H.of_raw_string s)\n\nlet of_raw_string_opt : type k. k hash -> string -> k t option =\n fun hash s ->\n let module H = (val module_of hash) in\n let unsafe : H.t -> 'k t = H.to_raw_string in\n match H.of_raw_string_opt s with\n | None -> None\n | Some digest -> Some (unsafe digest)\n\nlet to_raw_string : type k. k hash -> k t -> string = fun _ t -> t\n\nlet of_digest (type hash kind)\n (module H : S with type t = hash and type kind = kind) (hash : H.t) : kind t\n =\n H.to_raw_string hash\n\nlet of_md5 hash = of_raw_string md5 (MD5.to_raw_string hash)\n\nlet of_sha1 hash = of_raw_string sha1 (SHA1.to_raw_string hash)\n\nlet of_rmd160 hash = of_raw_string rmd160 (RMD160.to_raw_string hash)\n\nlet of_sha224 hash = of_raw_string sha224 (SHA224.to_raw_string hash)\n\nlet of_sha256 hash = of_raw_string sha256 (SHA256.to_raw_string hash)\n\nlet of_sha384 hash = of_raw_string sha384 (SHA384.to_raw_string hash)\n\nlet of_sha512 hash = of_raw_string sha512 (SHA512.to_raw_string hash)\n\nlet of_sha3_224 hash = of_raw_string sha3_224 (SHA3_224.to_raw_string hash)\n\nlet of_sha3_256 hash = of_raw_string sha3_256 (SHA3_256.to_raw_string hash)\n\nlet of_sha3_384 hash = of_raw_string sha3_384 (SHA3_384.to_raw_string hash)\n\nlet of_sha3_512 hash = of_raw_string sha3_512 (SHA3_512.to_raw_string hash)\n\nlet of_whirlpool hash = of_raw_string whirlpool (WHIRLPOOL.to_raw_string hash)\n\nlet of_blake2b hash =\n of_raw_string (blake2b BLAKE2B.digest_size) (BLAKE2B.to_raw_string hash)\n\nlet of_blake2s hash =\n of_raw_string (blake2s BLAKE2S.digest_size) (BLAKE2S.to_raw_string hash)\n","open Core_kernel\n\nmodule Digit = struct\n (* A number between 0 and 15 *)\n type t =\n | H0\n | H1\n | H2\n | H3\n | H4\n | H5\n | H6\n | H7\n | H8\n | H9\n | H10\n | H11\n | H12\n | H13\n | H14\n | H15\n\n let of_char_exn c =\n match Char.lowercase c with\n | '0' ->\n H0\n | '1' ->\n H1\n | '2' ->\n H2\n | '3' ->\n H3\n | '4' ->\n H4\n | '5' ->\n H5\n | '6' ->\n H6\n | '7' ->\n H7\n | '8' ->\n H8\n | '9' ->\n H9\n | 'a' ->\n H10\n | 'b' ->\n H11\n | 'c' ->\n H12\n | 'd' ->\n H13\n | 'e' ->\n H14\n | 'f' ->\n H15\n | _ ->\n failwithf \"bad hex digit %c\" c ()\n\n let to_int = function\n | H0 ->\n 0\n | H1 ->\n 1\n | H2 ->\n 2\n | H3 ->\n 3\n | H4 ->\n 4\n | H5 ->\n 5\n | H6 ->\n 6\n | H7 ->\n 7\n | H8 ->\n 8\n | H9 ->\n 9\n | H10 ->\n 10\n | H11 ->\n 11\n | H12 ->\n 12\n | H13 ->\n 13\n | H14 ->\n 14\n | H15 ->\n 15\nend\n\nlet hex_char_of_int_exn = function\n | 0 ->\n '0'\n | 1 ->\n '1'\n | 2 ->\n '2'\n | 3 ->\n '3'\n | 4 ->\n '4'\n | 5 ->\n '5'\n | 6 ->\n '6'\n | 7 ->\n '7'\n | 8 ->\n '8'\n | 9 ->\n '9'\n | 10 ->\n 'a'\n | 11 ->\n 'b'\n | 12 ->\n 'c'\n | 13 ->\n 'd'\n | 14 ->\n 'e'\n | 15 ->\n 'f'\n | d ->\n failwithf \"bad hex digit %d\" d ()\n\nmodule Sequence_be = struct\n type t = Digit.t array\n\n let decode ?(pos = 0) s =\n let n = String.length s - pos in\n Array.init n ~f:(fun i -> Digit.of_char_exn s.[pos + i])\n\n let to_bytes_like ~init (t : t) =\n let n = Array.length t in\n let k = n / 2 in\n assert (n = k + k) ;\n init k ~f:(fun i ->\n Char.of_int_exn\n ((16 * Digit.to_int t.(2 * i)) + Digit.to_int t.((2 * i) + 1)) )\n\n let to_string = to_bytes_like ~init:String.init\n\n let to_bytes = to_bytes_like ~init:Bytes.init\n\n let to_bigstring = to_bytes_like ~init:Bigstring.init\nend\n\nlet decode ?(reverse = false) ?(pos = 0) ~init t =\n let n = String.length t - pos in\n let k = n / 2 in\n assert (n = k + k) ;\n let h j = Digit.(to_int (of_char_exn t.[pos + j])) in\n init k ~f:(fun i ->\n let i = if reverse then k - 1 - i else i in\n Char.of_int_exn ((16 * h (2 * i)) + h ((2 * i) + 1)) )\n\nlet encode ?(reverse = false) t =\n let n = String.length t in\n String.init (2 * n) ~f:(fun i ->\n let c =\n let byte = i / 2 in\n Char.to_int t.[if reverse then n - 1 - byte else byte]\n in\n let c = if i mod 2 = 0 then (* hi *)\n c lsr 4 else (* lo *)\n c in\n hex_char_of_int_exn (c land 15) )\n\nlet%test_unit \"decode\" =\n let t = String.init 100 ~f:(fun _ -> Char.of_int_exn (Random.int 256)) in\n let h = encode t in\n assert (String.equal t (decode ~init:String.init h)) ;\n assert (\n String.equal t\n (decode ~reverse:true ~init:String.init (encode ~reverse:true t)) ) ;\n assert (String.equal t Sequence_be.(to_string (decode h)))\n\n(* TODO: Better deduplicate the hex coding between these two implementations #5711 *)\nmodule Safe = struct\n (** to_hex : {0x0-0xff}* -> [A-F0-9]* *)\n let to_hex (data : string) : string =\n String.to_list data\n |> List.map ~f:(fun c ->\n let charify u4 =\n match u4 with\n | x when x <= 9 && x >= 0 ->\n Char.(of_int_exn @@ (x + to_int '0'))\n | x when x <= 15 && x >= 10 ->\n Char.(of_int_exn @@ (x - 10 + to_int 'A'))\n | _ ->\n failwith \"Unexpected u4 has only 4bits of information\"\n in\n let high = charify @@ ((Char.to_int c land 0xF0) lsr 4) in\n let lo = charify (Char.to_int c land 0x0F) in\n String.of_char_list [ high; lo ] )\n |> String.concat\n\n let%test_unit \"to_hex sane\" =\n let start = \"a\" in\n let hexified = to_hex start in\n let expected = \"61\" in\n if String.equal expected hexified then ()\n else\n failwithf \"start: %s ; hexified : %s ; expected: %s\" start hexified\n expected ()\n\n (** of_hex : [a-fA-F0-9]* -> {0x0-0xff}* option *)\n let of_hex (hex : string) : string option =\n let to_u4 c =\n let open Char in\n assert (is_alphanum c) ;\n match c with\n | _ when is_digit c ->\n to_int c - to_int '0'\n | _ when is_uppercase c ->\n to_int c - to_int 'A' + 10\n | _ (* when is_alpha *) ->\n to_int c - to_int 'a' + 10\n in\n String.to_list hex |> List.chunks_of ~length:2\n |> List.fold_result ~init:[] ~f:(fun acc chunk ->\n match chunk with\n | [ a; b ] when Char.is_alphanum a && Char.is_alphanum b ->\n Or_error.return\n @@ (Char.((to_u4 a lsl 4) lor to_u4 b |> of_int_exn) :: acc)\n | _ ->\n Or_error.error_string \"invalid hex\" )\n |> Or_error.ok\n |> Option.map ~f:(Fn.compose String.of_char_list List.rev)\n\n let%test_unit \"partial isomorphism\" =\n Quickcheck.test ~sexp_of:[%sexp_of: string] ~examples:[ \"\\243\"; \"abc\" ]\n Quickcheck.Generator.(map (list char) ~f:String.of_char_list)\n ~f:(fun s ->\n let hexified = to_hex s in\n let actual = Option.value_exn (of_hex hexified) in\n let expected = s in\n if String.equal actual expected then ()\n else\n failwithf\n !\"expected: %s ; hexified: %s ; actual: %s\"\n expected hexified actual () )\nend\n","(* logger.ml : the fake one *)\n\nopen Core_kernel\n\nlet not_implemented () = failwith \"Not implemented\"\n\nmodule Level = struct\n type t =\n | Internal\n | Spam\n | Trace\n | Debug\n | Info\n | Warn\n | Error\n | Faulty_peer\n | Fatal\n [@@deriving sexp, equal, compare, show { with_path = false }, enumerate]\n\n let of_string _ = not_implemented ()\n\n let to_yojson _ = not_implemented ()\n\n let of_yojson _ = not_implemented ()\nend\n\n(* Core modules extended with Yojson converters *)\nmodule Time = struct\n include Time\n\n let to_yojson _ = not_implemented ()\n\n let of_yojson _ = not_implemented ()\n\n let pp _ _ = not_implemented ()\n\n let set_pretty_to_string _ = not_implemented ()\n\n let pretty_to_string _ = not_implemented ()\nend\n\nmodule Source = struct\n type t = { module_ : string [@key \"module\"]; location : string }\n [@@deriving yojson]\n\n let create ~module_:_ ~location:_ = not_implemented ()\nend\n\nmodule Metadata = struct\n [%%versioned_binable\n module Stable = struct\n module V1 = struct\n type t = Yojson.Safe.t String.Map.t\n\n let to_latest = Fn.id\n\n let to_yojson _ = not_implemented ()\n\n let of_yojson _ = not_implemented ()\n\n include\n Binable.Of_binable_without_uuid\n (Core_kernel.String.Stable.V1)\n (struct\n type nonrec t = t\n\n let to_binable _ = not_implemented ()\n\n let of_binable _ = not_implemented ()\n end)\n end\n end]\n\n [%%define_locally Stable.Latest.(to_yojson, of_yojson)]\n\n let empty = String.Map.empty\nend\n\nlet append_to_global_metadata _ = not_implemented ()\n\nmodule Message = struct\n type t =\n { timestamp : Time.t\n ; level : Level.t\n ; source : Source.t option [@default None]\n ; message : string\n ; metadata : Metadata.t\n ; event_id : Structured_log_events.id option [@default None]\n }\n [@@deriving yojson]\nend\n\nmodule Processor = struct\n module type S = sig\n type t\n\n val process : t -> Message.t -> string option\n end\n\n type t\n\n let create _ _ = not_implemented ()\n\n let raw ?log_level:_ () = not_implemented ()\n\n let raw_structured_log_events _ = not_implemented ()\n\n let pretty ~log_level:_ ~config:_ = not_implemented ()\nend\n\nmodule Transport = struct\n module type S = sig\n type t\n\n val transport : t -> string -> unit\n end\n\n type t\n\n let create _ _ = not_implemented ()\n\n let raw _ = not_implemented ()\n\n let stdout () = not_implemented ()\nend\n\nmodule Consumer_registry = struct\n type id = string\n\n let register ~id:_ ~processor:_ ~transport:_ = not_implemented ()\nend\n\n[%%versioned\nmodule Stable = struct\n module V1 = struct\n type t = { null : bool; metadata : Metadata.Stable.V1.t; id : string }\n\n let to_latest = Fn.id\n end\nend]\n\nlet metadata t = t.metadata\n\nlet create ?metadata:_ ?(id = \"default\") () =\n { null = false; metadata = Metadata.empty; id }\n\nlet null () = { null = true; metadata = Metadata.empty; id = \"default\" }\n\nlet extend t _ = t\n\nlet change_id { null; metadata; id = _ } ~id = { null; metadata; id }\n\nlet raw _ _ = not_implemented ()\n\nlet log _t ~level:_ ~module_:_ ~location:_ ?metadata:_ ?event_id:_ fmt =\n let f _message = () in\n ksprintf f fmt\n\ntype 'a log_function =\n t\n -> module_:string\n -> location:string\n -> ?metadata:(string, Yojson.Safe.t) List.Assoc.t\n -> ?event_id:Structured_log_events.id\n -> ('a, unit, string, unit) format4\n -> 'a\n\nlet trace = log ~level:Level.Trace\n\nlet internal = log ~level:Level.Internal\n\nlet debug = log ~level:Level.Debug\n\nlet info = log ~level:Level.Info\n\nlet warn = log ~level:Level.Warn\n\nlet error = log ~level:Level.Error\n\nlet fatal = log ~level:Level.Fatal\n\nlet faulty_peer_without_punishment = log ~level:Level.Faulty_peer\n\nlet spam = log ~level:Level.Spam ~module_:\"\" ~location:\"\" ?event_id:None\n\n(* deprecated, use Trust_system.record instead *)\nlet faulty_peer = faulty_peer_without_punishment\n\nmodule Structured = struct\n type log_function =\n t\n -> module_:string\n -> location:string\n -> ?metadata:(string, Yojson.Safe.t) List.Assoc.t\n -> Structured_log_events.t\n -> unit\n\n let log _t ~level:_ ~module_:_ ~location:_ ?metadata:_ _event = ()\n\n let trace : log_function = log ~level:Level.Trace\n\n let debug = log ~level:Level.Debug\n\n let info = log ~level:Level.Info\n\n let warn = log ~level:Level.Warn\n\n let error = log ~level:Level.Error\n\n let fatal = log ~level:Level.Fatal\n\n let faulty_peer_without_punishment = log ~level:Level.Faulty_peer\n\n let best_tip_diff = log ~level:Level.Spam ~module_:\"\" ~location:\"\"\nend\n\nmodule Str = Structured\n\nmodule Logger_id = struct\n let invalid = \"fake\"\n\n let mina = invalid\n\n let best_tip_diff = invalid\n\n let rejected_blocks = invalid\n\n let snark_worker = invalid\n\n let oversized_logs = invalid\nend\n","open Core_kernel\n\n(** immutable, serializable statistics derived from allocation data *)\nmodule Allocation_statistics = struct\n (* times represented in ms *)\n type quartiles = { q1 : float; q2 : float; q3 : float; q4 : float }\n [@@deriving yojson]\n\n let make_quartiles n = { q1 = n; q2 = n; q3 = n; q4 = n }\n\n let empty_quartiles = make_quartiles 0.0\n\n type t = { count : int; lifetimes : quartiles } [@@deriving yojson]\n\n let write_metrics { count; lifetimes } object_id =\n let open Mina_metrics in\n let open Mina_metrics.Object_lifetime_statistics in\n let { q1; q2; q3; q4 } = lifetimes in\n let q x = lifetime_quartile_ms ~name:object_id ~quartile:x in\n Gauge.set (live_count ~name:object_id) (Int.to_float count) ;\n Gauge.set (q `Q1) q1 ;\n Gauge.set (q `Q2) q2 ;\n Gauge.set (q `Q3) q3 ;\n Gauge.set (q `Q4) q4\nend\n\n(** mutable data for an object we track allocations of (one exists per object type) *)\nmodule Allocation_data = struct\n (* stops being unique after 2^{30,62} values; perhaps we should use guids instead *)\n type allocation_id = int\n\n let initial_allocation_id = Int.min_value\n\n (* indexed queue data structure would be more effecient here, but keeping this simple for now *)\n type t =\n { allocation_times : (allocation_id * Time.t) Queue.t\n ; mutable next_allocation_id : allocation_id\n }\n\n let create () =\n { allocation_times = Queue.create ()\n ; next_allocation_id = initial_allocation_id\n }\n\n let register_allocation data =\n let id = data.next_allocation_id in\n Queue.enqueue data.allocation_times (id, Time.now ()) ;\n data.next_allocation_id <- data.next_allocation_id + 1 ;\n id\n\n (* currently O(n) wrt queue size *)\n let unregister_allocation data id =\n Queue.filter_inplace data.allocation_times ~f:(fun (id', _) -> id = id')\n\n let compute_statistics { allocation_times; _ } =\n let now = Time.now () in\n let count = Queue.length allocation_times in\n let lifetime_ms_of_time time = Time.Span.to_ms (Time.diff now time) in\n let get_lifetime_ms i =\n lifetime_ms_of_time (snd @@ Queue.get allocation_times i)\n in\n let mean_indices max_len =\n let m = max_len - 1 in\n if m mod 2 = 0 then [ m / 2 ] else [ m / 2; (m / 2) + 1 ]\n in\n let mean offset length =\n let indices =\n mean_indices length |> List.filter ~f:(fun x -> x < count)\n in\n let sum =\n List.fold_left indices ~init:0.0 ~f:(fun acc i ->\n acc +. get_lifetime_ms (count - 1 - (i + offset)) )\n in\n sum /. Int.to_float (List.length indices)\n in\n let lifetimes =\n match count with\n | 0 ->\n Allocation_statistics.empty_quartiles\n | 1 ->\n Allocation_statistics.make_quartiles (get_lifetime_ms 0)\n | _ ->\n let q1 = mean 0 (count / 2) in\n let q2 = mean 0 count in\n let q3_offset = if count mod 2 = 0 then 0 else 1 in\n let q3 = mean ((count / 2) + q3_offset) (count / 2) in\n let q4 = get_lifetime_ms 0 in\n Allocation_statistics.{ q1; q2; q3; q4 }\n in\n Allocation_statistics.{ count; lifetimes }\n\n let compute_statistics t =\n try compute_statistics t\n with _ ->\n Allocation_statistics.\n { count = 0; lifetimes = Allocation_statistics.make_quartiles 0. }\n\n let%test_module \"Allocation_data unit tests\" =\n ( module struct\n open Allocation_statistics\n\n module Float_compare = Float.Robust_compare.Make (struct\n let robust_comparison_tolerance = 0.04\n end)\n\n type robust_float = float [@@deriving sexp]\n\n let compare_robust_float = Float_compare.robustly_compare\n\n (* time_offsets passed in here should be ordered monotonically (to match real world behavior) *)\n let run_test time_offsets expected_quartiles =\n let now = Time.now () in\n (* ids do not need to be unique in this test *)\n let data =\n { allocation_times =\n Queue.of_list\n @@ List.map (List.rev time_offsets) ~f:(fun offset ->\n (0, Time.sub now (Time.Span.of_ms offset)) )\n ; next_allocation_id = 0\n }\n in\n let stats = compute_statistics data in\n [%test_eq: int] stats.count (List.length time_offsets) ;\n [%test_eq: robust_float] stats.lifetimes.q1 expected_quartiles.q1 ;\n [%test_eq: robust_float] stats.lifetimes.q2 expected_quartiles.q2 ;\n [%test_eq: robust_float] stats.lifetimes.q3 expected_quartiles.q3 ;\n [%test_eq: robust_float] stats.lifetimes.q4 expected_quartiles.q4\n\n let%test_unit \"quartiles of empty list\" =\n run_test [] { q1 = 0.0; q2 = 0.0; q3 = 0.0; q4 = 0.0 }\n\n let%test_unit \"quartiles of singleton list\" =\n run_test [ 1.0 ] { q1 = 1.0; q2 = 1.0; q3 = 1.0; q4 = 1.0 }\n\n let%test_unit \"quartiles of 2 element list\" =\n run_test [ 1.0; 2.0 ] { q1 = 1.0; q2 = 1.5; q3 = 2.0; q4 = 2.0 }\n\n let%test_unit \"quartiles of 3 element list\" =\n run_test [ 1.0; 2.0; 3.0 ] { q1 = 1.0; q2 = 2.0; q3 = 3.0; q4 = 3.0 }\n\n let%test_unit \"quartiles of even list (> 3)\" =\n run_test\n [ 1.0; 2.0; 3.0; 4.0; 5.0; 6.0 ]\n { q1 = 2.0; q2 = 3.5; q3 = 5.0; q4 = 6.0 }\n\n let%test_unit \"quartiles of odd list with even split (> 3)\" =\n run_test\n [ 1.0; 2.0; 3.0; 4.0; 5.0; 6.0; 7.0 ]\n { q1 = 2.0; q2 = 4.0; q3 = 6.0; q4 = 7.0 }\n\n let%test_unit \"quartiles of odd list with odd split (> 3)\" =\n run_test\n [ 1.0; 2.0; 3.0; 4.0; 5.0; 6.0; 7.0; 8.0; 9.0 ]\n { q1 = 2.5; q2 = 5.0; q3 = 7.5; q4 = 9.0 }\n end )\nend\n\n(** correlation of allocation data and derived statistics *)\nmodule Allocation_info = struct\n type t = { statistics : Allocation_statistics.t; data : Allocation_data.t }\nend\n\nlet table = String.Table.create ()\n\nlet capture object_id =\n let open Allocation_info in\n let info_opt = String.Table.find table object_id in\n let data_opt = Option.map info_opt ~f:(fun { data; _ } -> data) in\n let data =\n Lazy.(\n force\n @@ Option.value_map data_opt\n ~default:(lazy (Allocation_data.create ()))\n ~f:Lazy.return)\n in\n let allocation_id = Allocation_data.register_allocation data in\n let statistics = Allocation_data.compute_statistics data in\n String.Table.set table ~key:object_id ~data:{ data; statistics } ;\n Allocation_statistics.write_metrics statistics object_id ;\n Mina_metrics.(\n Counter.inc_one (Object_lifetime_statistics.allocated_count ~name:object_id)) ;\n allocation_id\n\n(* release is currently O(n), where n = number of active allocations for this object type; this can be improved by implementing indexed queues (with decent random delete computational complexity) in ocaml *)\nlet release ~object_id ~allocation_id =\n let open Allocation_info in\n let info = String.Table.find_exn table object_id in\n Allocation_data.unregister_allocation info.data allocation_id ;\n let statistics = Allocation_data.compute_statistics info.data in\n String.Table.set table ~key:object_id ~data:{ info with statistics } ;\n Allocation_statistics.write_metrics statistics object_id ;\n Mina_metrics.(\n Counter.inc_one (Object_lifetime_statistics.collected_count ~name:object_id))\n\nlet attach_finalizer object_id obj =\n let allocation_id = capture object_id in\n Gc.Expert.add_finalizer_exn obj (fun _ -> release ~object_id ~allocation_id) ;\n obj\n\nlet dump () =\n let open Allocation_info in\n let entries =\n String.Table.to_alist table\n |> List.Assoc.map ~f:(fun { statistics; _ } ->\n Allocation_statistics.to_yojson statistics )\n in\n `Assoc entries\n","open Core_kernel\n\n[%%versioned\nmodule Stable = struct\n module V2 = struct\n type 'a t =\n { accs : ('a * 'a) array\n ; bits : 'a array\n ; ss : 'a array\n ; base : 'a * 'a\n ; n_prev : 'a\n ; n_next : 'a\n }\n [@@deriving sexp, fields, hlist]\n end\nend]\n\nlet map { accs; bits; ss; base; n_prev; n_next } ~f =\n { accs = Array.map accs ~f:(fun (x, y) -> (f x, f y))\n ; bits = Array.map bits ~f\n ; ss = Array.map ss ~f\n ; base = (f (fst base), f (snd base))\n ; n_prev = f n_prev\n ; n_next = f n_next\n }\n\nlet map2 t1 t2 ~f =\n { accs =\n Array.map (Array.zip_exn t1.accs t2.accs) ~f:(fun ((x1, y1), (x2, y2)) ->\n (f x1 x2, f y1 y2) )\n ; bits =\n Array.map (Array.zip_exn t1.bits t2.bits) ~f:(fun (x1, x2) -> f x1 x2)\n ; ss = Array.map (Array.zip_exn t1.ss t2.ss) ~f:(fun (x1, x2) -> f x1 x2)\n ; base = (f (fst t1.base) (fst t2.base), f (snd t1.base) (snd t2.base))\n ; n_prev = f t1.n_prev t2.n_prev\n ; n_next = f t1.n_next t2.n_next\n }\n\nlet fold { accs; bits; ss; base; n_prev; n_next } ~f ~init =\n let t = Array.fold accs ~init ~f:(fun acc (x, y) -> f [ x; y ] acc) in\n let t = Array.fold bits ~init:t ~f:(fun acc x -> f [ x ] acc) in\n let t = Array.fold ss ~init:t ~f:(fun acc x -> f [ x ] acc) in\n let t = f [ fst base; snd base ] t in\n let t = f [ n_prev ] t in\n let t = f [ n_next ] t in\n t\n","open Core_kernel\n\n[%%versioned\nmodule Stable = struct\n module V2 = struct\n type 'f t = 'f Kimchi_types.scalar_challenge = { inner : 'f }\n [@@deriving sexp, compare, equal, yojson, hash]\n end\nend]\n\nlet create t = { inner = t }\n\nlet typ f =\n let there { inner = x } = x in\n let back x = create x in\n Snarky_backendless.Typ.(transport_var (transport f ~there ~back) ~there ~back)\n\nlet map { inner = x } ~f = create (f x)\n","open Intf\nopen Core_kernel\n\nmodule type Input_intf = sig\n module BaseField : sig\n type t\n end\n\n module ScalarField : sig\n type t\n end\n\n module Affine : sig\n type t = BaseField.t Kimchi_types.or_infinity\n end\n\n type t\n\n val to_affine : t -> Affine.t\n\n val of_affine_coordinates : BaseField.t -> BaseField.t -> t\n\n val add : t -> t -> t\n\n val double : t -> t\n\n val scale : t -> ScalarField.t -> t\n\n val sub : t -> t -> t\n\n val negate : t -> t\n\n val random : unit -> t\n\n val one : unit -> t\nend\n\nmodule type Field_intf = sig\n module Stable : sig\n module Latest : sig\n type t [@@deriving bin_io, equal, sexp, compare, yojson, hash]\n end\n end\n\n type t = Stable.Latest.t\n\n val ( + ) : t -> t -> t\n\n val ( * ) : t -> t -> t\n\n val one : t\n\n val square : t -> t\n\n val is_square : t -> bool\n\n val sqrt : t -> t\n\n val random : unit -> t\nend\n\nmodule Make\n (BaseField : Field_intf) (ScalarField : sig\n type t\n end) (Params : sig\n val a : BaseField.t\n\n val b : BaseField.t\n end)\n (C : Input_intf\n with module BaseField := BaseField\n and module ScalarField := ScalarField) =\nstruct\n include (C : module type of C with type t = C.t with module Affine := C.Affine)\n\n module Base_field = BaseField\n\n let one = one ()\n\n (* TODO: wouldn't be easier if Input_intf exposed a `zero`? *)\n let zero = sub one one\n\n let y_squared x =\n let open BaseField in\n Params.b + (x * (Params.a + square x))\n\n module Affine = struct\n module Backend = struct\n include C.Affine\n\n let zero () = Kimchi_types.Infinity\n\n let create x y = Kimchi_types.Finite (x, y)\n end\n\n module Stable = struct\n module V1 = struct\n module T = struct\n type t = BaseField.Stable.Latest.t * BaseField.Stable.Latest.t\n [@@deriving equal, bin_io, sexp, compare, yojson, hash]\n end\n\n (* asserts the versioned-ness of V1\n to do this properly, we'd move the Stable module outside the functor\n *)\n let __versioned__ = ()\n\n include T\n\n exception Invalid_curve_point of t\n\n include\n Binable.Of_binable\n (T)\n (struct\n let on_curve (x, y) =\n BaseField.Stable.Latest.equal (y_squared x) (BaseField.square y)\n\n type t = T.t\n\n let to_binable = Fn.id\n\n let of_binable t =\n if not (on_curve t) then raise (Invalid_curve_point t) ;\n t\n end)\n end\n\n module Latest = V1\n end\n\n let%test \"cannot deserialize invalid points\" =\n (* y^2 = x^3 + a x + b\n\n pick c at random\n let (x, y) = (c^2, c^3)\n\n Then the above equation becomes\n c^6 = c^6 + (a c^2 + b)\n\n a c^3 + b is almost certainly nonzero (and for our curves, with a = 0, it always is)\n so this point is almost certainly (and for our curves, always) invalid\n *)\n let invalid =\n let open BaseField in\n let c = random () in\n let c2 = square c in\n (c2, c2 * c)\n in\n match\n Binable.to_string (module Stable.Latest) invalid\n |> Binable.of_string (module Stable.Latest)\n with\n | exception Stable.V1.Invalid_curve_point _ ->\n true\n | _ ->\n false\n\n include Stable.Latest\n\n let to_backend :\n (Base_field.t * Base_field.t) Pickles_types.Or_infinity.t -> Backend.t =\n function\n | Infinity ->\n Infinity\n | Finite (x, y) ->\n Finite (x, y)\n\n let of_backend :\n Backend.t -> (Base_field.t * Base_field.t) Pickles_types.Or_infinity.t =\n function\n | Infinity ->\n Infinity\n | Finite (x, y) ->\n Finite (x, y)\n end\n\n let to_affine_or_infinity = C.to_affine\n\n let to_affine_exn t =\n match C.to_affine t with\n | Infinity ->\n failwith \"to_affine_exn: Got identity\"\n | Finite (x, y) ->\n (x, y)\n\n let of_affine (x, y) = C.of_affine_coordinates x y\n\n include\n Binable.Of_binable\n (Affine)\n (struct\n type nonrec t = t\n\n let to_binable = to_affine_exn\n\n let of_binable = of_affine\n end)\n\n let ( + ) = add\n\n let ( * ) s t = scale t s\n\n let find_y x =\n let open BaseField in\n let y2 = y_squared x in\n if is_square y2 then Some (sqrt y2) else None\n\n let point_near_x (x : BaseField.t) =\n let rec go x = function\n | Some y ->\n of_affine (x, y)\n | None ->\n let x' = BaseField.(one + x) in\n go x' (find_y x')\n in\n go x (find_y x)\nend\n","open Core_kernel\nopen Async_kernel\nopen Pickles_types\n\nlet tuple15_to_vec\n (w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, w10, w11, w12, w13, w14) =\n Vector.[ w0; w1; w2; w3; w4; w5; w6; w7; w8; w9; w10; w11; w12; w13; w14 ]\n\nlet tuple15_of_vec\n Vector.[ w0; w1; w2; w3; w4; w5; w6; w7; w8; w9; w10; w11; w12; w13; w14 ] =\n (w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, w10, w11, w12, w13, w14)\n\nlet tuple6_to_vec (w0, w1, w2, w3, w4, w5) = Vector.[ w0; w1; w2; w3; w4; w5 ]\n\nlet tuple6_of_vec Vector.[ w0; w1; w2; w3; w4; w5 ] = (w0, w1, w2, w3, w4, w5)\n\nmodule type Stable_v1 = sig\n module Stable : sig\n module V1 : sig\n type t [@@deriving version, bin_io, sexp, compare, yojson, hash, equal]\n end\n\n module Latest = V1\n end\n\n type t = Stable.V1.t [@@deriving sexp, compare, yojson]\nend\n\nmodule type Inputs_intf = sig\n open Intf\n\n val id : string\n\n module Scalar_field : sig\n include Stable_v1\n\n val one : t\n\n module Vector : Snarky_intf.Vector.S with type elt = t\n end\n\n module Base_field : sig\n type t\n end\n\n module Curve : sig\n module Affine : sig\n include Stable_v1 with type Stable.V1.t = Base_field.t * Base_field.t\n\n module Backend : sig\n type t = Base_field.t Kimchi_types.or_infinity\n end\n\n val of_backend :\n Backend.t -> (Base_field.t * Base_field.t) Pickles_types.Or_infinity.t\n\n val to_backend :\n (Base_field.t * Base_field.t) Pickles_types.Or_infinity.t -> Backend.t\n end\n end\n\n module Poly_comm : sig\n type t = Base_field.t Poly_comm.t\n\n module Backend : sig\n type t = Curve.Affine.Backend.t Kimchi_types.poly_comm\n end\n\n val of_backend_with_degree_bound : Backend.t -> t\n\n val of_backend_without_degree_bound : Backend.t -> t\n\n val to_backend : t -> Backend.t\n end\n\n module Opening_proof_backend : sig\n type t = (Curve.Affine.Backend.t, Scalar_field.t) Kimchi_types.opening_proof\n end\n\n module Evaluations_backend : sig\n type t = Scalar_field.t Kimchi_types.proof_evaluations\n end\n\n module Index : sig\n type t\n end\n\n module Verifier_index : sig\n type t\n end\n\n module Backend : sig\n type t = (Curve.Affine.Backend.t, Scalar_field.t) Kimchi_types.prover_proof\n\n val create :\n Index.t\n -> Scalar_field.Vector.t\n -> Scalar_field.Vector.t\n -> Scalar_field.t array\n -> Curve.Affine.Backend.t array\n -> t\n\n val create_async :\n Index.t\n -> Scalar_field.Vector.t\n -> Scalar_field.Vector.t\n -> Scalar_field.t array\n -> Curve.Affine.Backend.t array\n -> t Promise.t\n\n val create_and_verify_async :\n Index.t\n -> Scalar_field.Vector.t\n -> Scalar_field.Vector.t\n -> Scalar_field.t array\n -> Curve.Affine.Backend.t array\n -> t Promise.t\n\n val verify : Verifier_index.t -> t -> bool\n\n val batch_verify : Verifier_index.t array -> t array -> bool Promise.t\n end\nend\n\nmodule Challenge_polynomial = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type ('g, 'fq) t = { challenges : 'fq array; commitment : 'g }\n [@@deriving version, bin_io, sexp, compare, yojson]\n\n let to_latest = Fn.id\n end\n end]\nend\n\nmodule Make (Inputs : Inputs_intf) = struct\n open Inputs\n module Backend = Backend\n module Fq = Scalar_field\n module G = Curve\n\n module Challenge_polynomial = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t =\n ( G.Affine.Stable.V1.t\n , Fq.Stable.V1.t )\n Challenge_polynomial.Stable.V1.t\n [@@deriving sexp, compare, yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n type ('g, 'fq) t_ = ('g, 'fq) Challenge_polynomial.t =\n { challenges : 'fq array; commitment : 'g }\n end\n\n type message = Challenge_polynomial.t list\n\n let hash_fold_array f s x = hash_fold_list f s (Array.to_list x)\n\n [%%versioned\n module Stable = struct\n module V2 = struct\n module T = struct\n type t =\n ( G.Affine.Stable.V1.t\n , Fq.Stable.V1.t\n , Fq.Stable.V1.t array )\n Pickles_types.Plonk_types.Proof.Stable.V2.t\n [@@deriving compare, sexp, yojson, hash, equal]\n\n let id = \"plong_dlog_proof_\" ^ Inputs.id\n\n type 'a creator =\n messages:G.Affine.t Pickles_types.Plonk_types.Messages.Stable.V2.t\n -> openings:\n ( G.Affine.t\n , Fq.t\n , Fq.t array )\n Pickles_types.Plonk_types.Openings.Stable.V2.t\n -> 'a\n\n let map_creator c ~f ~messages ~openings = f (c ~messages ~openings)\n\n let create ~messages ~openings =\n let open Pickles_types.Plonk_types.Proof in\n { messages; openings }\n end\n\n include T\n\n include (\n Allocation_functor.Make.Full\n (T) :\n Allocation_functor.Intf.Output.Full_intf\n with type t := t\n and type 'a creator := 'a creator )\n\n let to_latest = Fn.id\n end\n end]\n\n include (\n Stable.Latest :\n sig\n type t [@@deriving compare, sexp, yojson, hash, equal, bin_io]\n end\n with type t := t )\n\n [%%define_locally Stable.Latest.(create)]\n\n let g t f = G.Affine.of_backend (f t)\n\n let fq_array_to_vec arr =\n let vec = Fq.Vector.create () in\n Array.iter arr ~f:(fun fe -> Fq.Vector.emplace_back vec fe) ;\n vec\n\n (** Note that this function will panic if any of the points are points at infinity *)\n let opening_proof_of_backend_exn (t : Opening_proof_backend.t) =\n let g (x : G.Affine.Backend.t) : G.Affine.t =\n G.Affine.of_backend x |> Pickles_types.Or_infinity.finite_exn\n in\n let gpair ((g1, g2) : G.Affine.Backend.t * G.Affine.Backend.t) :\n G.Affine.t * G.Affine.t =\n (g g1, g g2)\n in\n { Pickles_types.Plonk_types.Openings.Bulletproof.lr =\n Array.map ~f:gpair t.lr\n ; z_1 = t.z1\n ; z_2 = t.z2\n ; delta = g t.delta\n ; challenge_polynomial_commitment = g t.sg\n }\n\n let eval_of_backend\n ({ w\n ; coefficients\n ; z\n ; s\n ; generic_selector\n ; poseidon_selector\n ; complete_add_selector\n ; mul_selector\n ; emul_selector\n ; endomul_scalar_selector\n ; range_check0_selector\n ; range_check1_selector\n ; foreign_field_add_selector\n ; foreign_field_mul_selector\n ; xor_selector\n ; rot_selector\n ; lookup_aggregation\n ; lookup_table\n ; lookup_sorted\n ; runtime_lookup_table\n ; runtime_lookup_table_selector\n ; xor_lookup_selector\n ; lookup_gate_lookup_selector\n ; range_check_lookup_selector\n ; foreign_field_mul_lookup_selector\n } :\n Evaluations_backend.t ) : _ Pickles_types.Plonk_types.Evals.t =\n { w = tuple15_to_vec w\n ; coefficients = tuple15_to_vec coefficients\n ; z\n ; s = tuple6_to_vec s\n ; generic_selector\n ; poseidon_selector\n ; complete_add_selector\n ; mul_selector\n ; emul_selector\n ; endomul_scalar_selector\n ; range_check0_selector\n ; range_check1_selector\n ; foreign_field_add_selector\n ; foreign_field_mul_selector\n ; xor_selector\n ; rot_selector\n ; lookup_aggregation\n ; lookup_table\n ; lookup_sorted =\n Vector.init Nat.N5.n ~f:(fun i ->\n Option.try_with_join (fun () -> lookup_sorted.(i)) )\n ; runtime_lookup_table\n ; runtime_lookup_table_selector\n ; xor_lookup_selector\n ; lookup_gate_lookup_selector\n ; range_check_lookup_selector\n ; foreign_field_mul_lookup_selector\n }\n\n let of_backend (t : Backend.t) : t =\n let proof = opening_proof_of_backend_exn t.proof in\n let evals =\n let evals_to_tuple\n ({ zeta; zeta_omega } : _ Kimchi_types.point_evaluations) =\n (zeta, zeta_omega)\n in\n Plonk_types.Evals.map ~f:evals_to_tuple (eval_of_backend t.evals)\n in\n let wo x : Inputs.Curve.Affine.t array =\n match Poly_comm.of_backend_without_degree_bound x with\n | `Without_degree_bound gs ->\n gs\n | _ ->\n assert false\n in\n let w_comm =\n tuple15_to_vec t.commitments.w_comm |> Pickles_types.Vector.map ~f:wo\n in\n create\n ~messages:\n { w_comm\n ; z_comm = wo t.commitments.z_comm\n ; t_comm = wo t.commitments.t_comm\n ; lookup =\n Option.map t.commitments.lookup\n ~f:(fun l : _ Pickles_types.Plonk_types.Messages.Lookup.t ->\n { sorted = Array.map ~f:wo l.sorted\n ; aggreg = wo l.aggreg\n ; runtime = Option.map ~f:wo l.runtime\n } )\n }\n ~openings:{ proof; evals; ft_eval1 = t.ft_eval1 }\n\n let eval_to_backend\n { Pickles_types.Plonk_types.Evals.w\n ; coefficients\n ; z\n ; s\n ; generic_selector\n ; poseidon_selector\n ; complete_add_selector\n ; mul_selector\n ; emul_selector\n ; endomul_scalar_selector\n ; range_check0_selector\n ; range_check1_selector\n ; foreign_field_add_selector\n ; foreign_field_mul_selector\n ; xor_selector\n ; rot_selector\n ; lookup_aggregation\n ; lookup_table\n ; lookup_sorted\n ; runtime_lookup_table\n ; runtime_lookup_table_selector\n ; xor_lookup_selector\n ; lookup_gate_lookup_selector\n ; range_check_lookup_selector\n ; foreign_field_mul_lookup_selector\n } : Evaluations_backend.t =\n { w = tuple15_of_vec w\n ; coefficients = tuple15_of_vec coefficients\n ; z\n ; s = tuple6_of_vec s\n ; generic_selector\n ; poseidon_selector\n ; complete_add_selector\n ; mul_selector\n ; emul_selector\n ; endomul_scalar_selector\n ; range_check0_selector\n ; range_check1_selector\n ; foreign_field_add_selector\n ; foreign_field_mul_selector\n ; xor_selector\n ; rot_selector\n ; lookup_aggregation\n ; lookup_table\n ; lookup_sorted = Vector.to_array lookup_sorted\n ; runtime_lookup_table\n ; runtime_lookup_table_selector\n ; xor_lookup_selector\n ; lookup_gate_lookup_selector\n ; range_check_lookup_selector\n ; foreign_field_mul_lookup_selector\n }\n\n let vec_to_array (type t elt)\n (module V : Snarky_intf.Vector.S with type t = t and type elt = elt)\n (v : t) =\n Array.init (V.length v) ~f:(V.get v)\n\n let to_backend' (chal_polys : Challenge_polynomial.t list) primary_input\n ({ messages = { w_comm; z_comm; t_comm; lookup }\n ; openings =\n { proof = { lr; z_1; z_2; delta; challenge_polynomial_commitment }\n ; evals\n ; ft_eval1\n }\n } :\n t ) : Backend.t =\n let g x = G.Affine.to_backend (Pickles_types.Or_infinity.Finite x) in\n let pcwo t = Poly_comm.to_backend (`Without_degree_bound t) in\n let lr = Array.map lr ~f:(fun (x, y) -> (g x, g y)) in\n let evals_of_tuple (zeta, zeta_omega) : _ Kimchi_types.point_evaluations =\n { zeta; zeta_omega }\n in\n { commitments =\n { w_comm = tuple15_of_vec (Pickles_types.Vector.map ~f:pcwo w_comm)\n ; z_comm = pcwo z_comm\n ; t_comm = pcwo t_comm\n ; lookup =\n Option.map lookup ~f:(fun t : _ Kimchi_types.lookup_commitments ->\n { sorted = Array.map ~f:pcwo t.sorted\n ; aggreg = pcwo t.aggreg\n ; runtime = Option.map ~f:pcwo t.runtime\n } )\n }\n ; proof =\n { lr\n ; delta = g delta\n ; z1 = z_1\n ; z2 = z_2\n ; sg = g challenge_polynomial_commitment\n }\n ; evals = eval_to_backend (Plonk_types.Evals.map ~f:evals_of_tuple evals)\n ; ft_eval1\n ; public = primary_input\n ; prev_challenges =\n Array.of_list_map chal_polys\n ~f:(fun { Challenge_polynomial.commitment = x, y; challenges } ->\n { Kimchi_types.chals = challenges\n ; comm =\n { Kimchi_types.shifted = None\n ; unshifted = [| Kimchi_types.Finite (x, y) |]\n }\n } )\n }\n\n let to_backend chal_polys primary_input t =\n to_backend' chal_polys (List.to_array primary_input) t\n\n let create ?message pk ~primary ~auxiliary =\n let chal_polys =\n match (message : message option) with Some s -> s | None -> []\n in\n let challenges =\n List.map chal_polys ~f:(fun { Challenge_polynomial.challenges; _ } ->\n challenges )\n |> Array.concat\n in\n let commitments =\n Array.of_list_map chal_polys\n ~f:(fun { Challenge_polynomial.commitment; _ } ->\n G.Affine.to_backend (Finite commitment) )\n in\n let res = Backend.create pk primary auxiliary challenges commitments in\n of_backend res\n\n let create_async ?message pk ~primary ~auxiliary =\n let chal_polys =\n match (message : message option) with Some s -> s | None -> []\n in\n let challenges =\n List.map chal_polys ~f:(fun { Challenge_polynomial.challenges; _ } ->\n challenges )\n |> Array.concat\n in\n let commitments =\n Array.of_list_map chal_polys\n ~f:(fun { Challenge_polynomial.commitment; _ } ->\n G.Affine.to_backend (Finite commitment) )\n in\n let%map.Promise res =\n Backend.create_async pk primary auxiliary challenges commitments\n in\n of_backend res\n\n let create_and_verify_async ?message pk ~primary ~auxiliary =\n let chal_polys =\n match (message : message option) with Some s -> s | None -> []\n in\n let challenges =\n List.map chal_polys ~f:(fun { Challenge_polynomial.challenges; _ } ->\n challenges )\n |> Array.concat\n in\n let commitments =\n Array.of_list_map chal_polys\n ~f:(fun { Challenge_polynomial.commitment; _ } ->\n G.Affine.to_backend (Finite commitment) )\n in\n let%map.Promise res =\n Backend.create_and_verify_async pk primary auxiliary challenges\n commitments\n in\n of_backend res\n\n let batch_verify' (conv : 'a -> Fq.t array)\n (ts : (Verifier_index.t * t * 'a * message option) list) =\n let logger = Internal_tracing_context_logger.get () in\n [%log internal] \"Batch_verify_backend_convert_inputs\" ;\n let vks_and_v =\n Array.of_list_map ts ~f:(fun (vk, t, xs, m) ->\n let p = to_backend' (Option.value ~default:[] m) (conv xs) t in\n (vk, p) )\n in\n [%log internal] \"Batch_verify_backend_convert_inputs_done\" ;\n [%log internal] \"Batch_verify_backend\" ;\n let%map.Promise result =\n Backend.batch_verify\n (Array.map ~f:fst vks_and_v)\n (Array.map ~f:snd vks_and_v)\n in\n [%log internal] \"Batch_verify_backend_done\" ;\n result\n\n let batch_verify = batch_verify' (fun xs -> List.to_array xs)\n\n let verify ?message t vk xs : bool =\n Backend.verify vk\n (to_backend'\n (Option.value ~default:[] message)\n (vec_to_array (module Scalar_field.Vector) xs)\n t )\nend\n","open Core_kernel\n\nmodule type Bindings = sig\n type t\n\n val num_limbs : unit -> int\n\n val bytes_per_limb : unit -> int\n\n val compare : t -> t -> int\n\n val div : t -> t -> t\n\n val test_bit : t -> int -> bool\n\n val print : t -> unit\n\n val to_string : t -> string\n\n val of_numeral : string -> int -> int -> t\n\n val of_decimal_string : string -> t\n\n val to_bytes : t -> Bytes.t\n\n val of_bytes : Bytes.t -> t\nend\n\nmodule type Intf = sig\n type t [@@deriving bin_io, sexp, compare]\n\n include Bindings with type t := t\n\n val num_limbs : int\n\n val bytes_per_limb : int\n\n val length_in_bytes : int\n\n val to_hex : t -> string\n\n val to_hex_string : t -> string\n\n val of_hex_string : ?reverse:bool -> string -> t\n\n val of_numeral : string -> base:int -> t\nend\n\nmodule Make\n (B : Bindings) (M : sig\n val length_in_bytes : int\n end) : Intf with type t = B.t = struct\n include B\n\n let num_limbs = num_limbs ()\n\n let bytes_per_limb = bytes_per_limb ()\n\n let length_in_bytes = num_limbs * bytes_per_limb\n\n let to_hex t =\n let data = to_bytes t in\n String.uppercase (Hex.encode ~reverse:true (Bytes.to_string data))\n\n let to_hex_string t = \"0x\" ^ to_hex t\n\n let sexp_of_t t = to_hex_string t |> Sexp.of_string\n\n let of_hex_string ?(reverse = true) s =\n assert (Char.equal s.[0] '0' && Char.equal s.[1] 'x') ;\n let s = String.drop_prefix s 2 in\n Option.try_with (fun () -> Hex.decode ~init:Bytes.init ~reverse s)\n |> Option.value_exn ~here:[%here]\n |> of_bytes\n\n let%test_unit \"hex test\" =\n let bytes =\n String.init length_in_bytes ~f:(fun _ -> Char.of_int_exn (Random.int 255))\n in\n let h = \"0x\" ^ Hex.encode bytes in\n [%test_eq: string] h (String.lowercase (to_hex_string (of_hex_string h)))\n\n let t_of_sexp s = of_hex_string (String.t_of_sexp s)\n\n include Bin_prot.Utils.Of_minimal (struct\n type nonrec t = t\n\n (* increment if serialization changes *)\n let version = 1\n\n let bin_shape_t =\n Bin_prot.Shape.basetype\n (Bin_prot.Shape.Uuid.of_string\n (sprintf \"kimchi_backend_bigint_%d_V%d\" M.length_in_bytes version) )\n []\n\n let __bin_read_t__ _buf ~pos_ref _vint =\n Bin_prot.Common.raise_variant_wrong_type \"Bigint.t\" !pos_ref\n\n let bin_size_t _ = length_in_bytes\n\n let bin_write_t buf ~pos t =\n let bytes = to_bytes t in\n let len = length_in_bytes in\n Bigstring.From_bytes.blit ~src:bytes ~src_pos:0 ~len:length_in_bytes\n ~dst:buf ~dst_pos:pos ;\n pos + len\n\n let bin_read_t buf ~pos_ref =\n let remaining_bytes = Bigstring.length buf - !pos_ref in\n let len = length_in_bytes in\n if remaining_bytes < len then\n failwithf \"Bigint.bin_read_t: Expected %d bytes, got %d\"\n M.length_in_bytes remaining_bytes () ;\n let bytes = Bigstring.To_bytes.sub ~pos:!pos_ref ~len buf in\n pos_ref := len + !pos_ref ;\n of_bytes bytes\n end)\n\n let of_numeral s ~base = of_numeral s (String.length s) base\nend\n","open Core_kernel\nmodule H_list = Snarky_backendless.H_list\n\n[%%versioned\nmodule Stable = struct\n module V2 = struct\n type 'a t =\n { xt : 'a\n ; yt : 'a\n ; xp : 'a\n ; yp : 'a\n ; n_acc : 'a\n ; xr : 'a\n ; yr : 'a\n ; s1 : 'a\n ; s3 : 'a\n ; b1 : 'a\n ; b2 : 'a\n ; b3 : 'a\n ; b4 : 'a\n }\n [@@deriving sexp, fields, hlist]\n end\nend]\n\nlet map { xt; yt; xp; yp; n_acc; xr; yr; s1; s3; b1; b2; b3; b4 } ~f =\n { xt = f xt\n ; yt = f yt\n ; xp = f xp\n ; yp = f yp\n ; n_acc = f n_acc\n ; xr = f xr\n ; yr = f yr\n ; s1 = f s1\n ; s3 = f s3\n ; b1 = f b1\n ; b2 = f b2\n ; b3 = f b3\n ; b4 = f b4\n }\n\nlet map2 t1 t2 ~f =\n { xt = f t1.xt t2.xt\n ; yt = f t1.yt t2.yt\n ; xp = f t1.xp t2.xp\n ; yp = f t1.yp t2.yp\n ; n_acc = f t1.n_acc t2.n_acc\n ; xr = f t1.xr t2.xr\n ; yr = f t1.yr t2.yr\n ; s1 = f t1.s1 t2.s1\n ; s3 = f t1.s3 t2.s3\n ; b1 = f t1.b1 t2.b1\n ; b2 = f t1.b2 t2.b2\n ; b3 = f t1.b3 t2.b3\n ; b4 = f t1.b4 t2.b4\n }\n","open Core_kernel\n\n[%%versioned\nmodule Stable = struct\n module V2 = struct\n type 'a t =\n { n0 : 'a\n ; n8 : 'a\n ; a0 : 'a\n ; b0 : 'a\n ; a8 : 'a\n ; b8 : 'a\n ; x0 : 'a\n ; x1 : 'a\n ; x2 : 'a\n ; x3 : 'a\n ; x4 : 'a\n ; x5 : 'a\n ; x6 : 'a\n ; x7 : 'a\n }\n [@@deriving sexp, fields, hlist]\n end\nend]\n\nlet map { n0; n8; a0; b0; a8; b8; x0; x1; x2; x3; x4; x5; x6; x7 } ~f =\n { n0 = f n0\n ; n8 = f n8\n ; a0 = f a0\n ; b0 = f b0\n ; a8 = f a8\n ; b8 = f b8\n ; x0 = f x0\n ; x1 = f x1\n ; x2 = f x2\n ; x3 = f x3\n ; x4 = f x4\n ; x5 = f x5\n ; x6 = f x6\n ; x7 = f x7\n }\n\nlet map2 t1 t2 ~f =\n { n0 = f t1.n0 t2.n0\n ; n8 = f t1.n8 t2.n8\n ; a0 = f t1.a0 t2.a0\n ; b0 = f t1.b0 t2.b0\n ; a8 = f t1.a8 t2.a8\n ; b8 = f t1.b8 t2.b8\n ; x0 = f t1.x0 t2.x0\n ; x1 = f t1.x1 t2.x1\n ; x2 = f t1.x2 t2.x2\n ; x3 = f t1.x3 t2.x3\n ; x4 = f t1.x4 t2.x4\n ; x5 = f t1.x5 t2.x5\n ; x6 = f t1.x6 t2.x6\n ; x7 = f t1.x7 t2.x7\n }\n","open Intf\nopen Core_kernel\nmodule Bignum_bigint = Snarky_backendless.Backend_extended.Bignum_bigint\n\nmodule type Input_intf = sig\n type t\n\n module Bigint : Bigint.Intf\n\n val size : unit -> Bigint.t\n\n val size_in_bits : unit -> int\n\n val to_bigint : t -> Bigint.t\n\n val of_bigint : Bigint.t -> t\n\n val of_int : int -> t\n\n val domain_generator : int -> t\n\n val add : t -> t -> t\n\n val sub : t -> t -> t\n\n val mul : t -> t -> t\n\n val div : t -> t -> t\n\n val inv : t -> t option\n\n val negate : t -> t\n\n val square : t -> t\n\n val sqrt : t -> t option\n\n val is_square : t -> bool\n\n val equal : t -> t -> bool\n\n val print : t -> unit\n\n val to_string : t -> string\n\n val of_string : string -> t\n\n val random : unit -> t\n\n val rng : int -> t\n\n val two_adic_root_of_unity : unit -> t\n\n val mut_add : t -> t -> unit\n\n val mut_mul : t -> t -> unit\n\n val mut_square : t -> unit\n\n val mut_sub : t -> t -> unit\n\n val copy : t -> t -> unit\n\n val to_bytes : t -> bytes\n\n val of_bytes : bytes -> t\n\n val domain_generator : int -> t\n\n module Vector : Snarky_intf.Vector.S with type elt = t\nend\n\nmodule type S = sig\n type t [@@deriving sexp, compare, yojson, bin_io, hash]\n\n include Input_intf with type t := t\n\n val size : Bigint.t\n\n val domain_generator : log2_size:int -> t\n\n val one : t\n\n val zero : t\n\n val inv : t -> t\n\n val sqrt : t -> t\n\n val size_in_bits : int\n\n val to_bits : t -> bool list\n\n val of_bits : bool list -> t\n\n val ( + ) : t -> t -> t\n\n val ( - ) : t -> t -> t\n\n val ( * ) : t -> t -> t\n\n val ( / ) : t -> t -> t\n\n module Mutable : sig\n val add : t -> other:t -> unit\n\n val mul : t -> other:t -> unit\n\n val square : t -> unit\n\n val sub : t -> other:t -> unit\n\n val copy : over:t -> t -> unit\n end\n\n val ( += ) : t -> t -> unit\n\n val ( *= ) : t -> t -> unit\n\n val ( -= ) : t -> t -> unit\nend\n\nmodule type S_with_version = sig\n [%%versioned:\n module Stable : sig\n [@@@no_toplevel_latest_type]\n\n module V1 : sig\n [@@@with_all_version_tags]\n\n type t [@@deriving version, sexp, bin_io, compare, yojson, hash, equal]\n end\n end]\n\n include S with type t = Stable.Latest.t\nend\n\nmodule Make (F : Input_intf) :\n S_with_version\n with type Stable.V1.t = F.t\n and module Bigint = F.Bigint\n and module Vector = F.Vector = struct\n include F\n\n let size = size ()\n\n let size_in_bits = size_in_bits ()\n\n [%%versioned_binable\n module Stable = struct\n module V1 = struct\n [@@@with_all_version_tags]\n\n type t = (F.t[@version_asserted]) [@@deriving version]\n\n let to_latest = Fn.id\n\n include\n Binable.Of_binable\n (Bigint)\n (struct\n type nonrec t = t\n\n let to_binable = to_bigint\n\n let of_binable = of_bigint\n end)\n\n include\n Sexpable.Of_sexpable\n (Bigint)\n (struct\n type nonrec t = t\n\n let to_sexpable = to_bigint\n\n let of_sexpable = of_bigint\n end)\n\n let to_bignum_bigint n =\n let rec go i two_to_the_i acc =\n if Int.equal i size_in_bits then acc\n else\n let acc' =\n if Bigint.test_bit n i then Bignum_bigint.(acc + two_to_the_i)\n else acc\n in\n go (i + 1) Bignum_bigint.(two_to_the_i + two_to_the_i) acc'\n in\n go 0 Bignum_bigint.one Bignum_bigint.zero\n\n let hash_fold_t s x =\n Bignum_bigint.hash_fold_t s (to_bignum_bigint (to_bigint x))\n\n let hash = Hash.of_fold hash_fold_t\n\n let compare t1 t2 = Bigint.compare (to_bigint t1) (to_bigint t2)\n\n let equal = equal\n\n let to_yojson t : Yojson.Safe.t =\n `String (Bigint.to_hex_string (to_bigint t))\n\n let of_yojson j =\n match j with\n | `String h ->\n Ok (of_bigint (Bigint.of_hex_string h))\n | _ ->\n Error \"expected hex string\"\n end\n end]\n\n include (\n Stable.Latest : module type of Stable.Latest with type t := Stable.Latest.t )\n\n let domain_generator ~log2_size = domain_generator log2_size\n\n let one = of_int 1\n\n let zero = of_int 0\n\n (* TODO: Improve snarky interface so these aren't necessary.. *)\n let inv x = Option.value (inv x) ~default:zero\n\n let sqrt x = Option.value (sqrt x) ~default:zero\n\n let to_bits t =\n (* Avoids allocation *)\n let n = F.to_bigint t in\n List.init size_in_bits ~f:(Bigint.test_bit n)\n\n let of_bits bs =\n List.fold (List.rev bs) ~init:zero ~f:(fun acc b ->\n let acc = add acc acc in\n if b then add acc one else acc )\n\n let%test_unit \"sexp round trip\" =\n let t = random () in\n assert (equal t (t_of_sexp (sexp_of_t t)))\n\n let%test_unit \"bin_io round trip\" =\n let t = random () in\n [%test_eq: Stable.Latest.t] t\n (Binable.of_string\n (module Stable.Latest)\n (Binable.to_string (module Stable.Latest) t) )\n\n let ( + ) = add\n\n let ( - ) = sub\n\n let ( * ) = mul\n\n let ( / ) = div\n\n module Mutable = struct\n let add t ~other = mut_add t other\n\n let mul t ~other = mut_mul t other\n\n let square = mut_square\n\n let sub t ~other = mut_sub t other\n\n let copy ~over t = copy over t\n end\n\n let op f t other = f t ~other\n\n let ( += ) = op Mutable.add\n\n let ( *= ) = op Mutable.mul\n\n let ( -= ) = op Mutable.sub\n\n let%test \"of_bits to_bits\" =\n let x = random () in\n equal x (of_bits (to_bits x))\n\n let%test_unit \"to_bits of_bits\" =\n Quickcheck.test\n (Quickcheck.Generator.list_with_length\n Int.(size_in_bits - 1)\n Bool.quickcheck_generator )\n ~f:(fun bs ->\n [%test_eq: bool list] (bs @ [ false ]) (to_bits (of_bits bs)) )\nend\n","(* TODO: remove these openings *)\nopen Sponge\nopen Unsigned.Size_t\n\n(* TODO: open Core here instead of opening it multiple times below *)\n\nmodule Kimchi_gate_type = struct\n (* Alias to allow deriving sexp *)\n type t = Kimchi_types.gate_type =\n | Zero\n | Generic\n | Poseidon\n | CompleteAdd\n | VarBaseMul\n | EndoMul\n | EndoMulScalar\n | Lookup\n | CairoClaim\n | CairoInstruction\n | CairoFlags\n | CairoTransition\n | RangeCheck0\n | RangeCheck1\n | ForeignFieldAdd\n | ForeignFieldMul\n | Xor16\n | Rot64\n [@@deriving sexp]\nend\n\n(** A gate interface, parameterized by a field. *)\nmodule type Gate_vector_intf = sig\n open Unsigned\n\n type field\n\n type t\n\n val create : unit -> t\n\n val add : t -> field Kimchi_types.circuit_gate -> unit\n\n val get : t -> int -> field Kimchi_types.circuit_gate\n\n val len : t -> int\n\n val digest : int -> t -> bytes\n\n val to_json : int -> t -> string\nend\n\n(** A row indexing in a constraint system. *)\nmodule Row = struct\n open Core_kernel\n\n (** Either a public input row,\n or a non-public input row that starts at index 0.\n *)\n type t = Public_input of int | After_public_input of int\n [@@deriving hash, sexp, compare]\n\n let to_absolute ~public_input_size = function\n | Public_input i ->\n i\n | After_public_input i ->\n (* the first i rows are public-input rows *)\n i + public_input_size\nend\n\n(* TODO: rename module Position to Permutation/Wiring? *)\n\n(** A position represents the position of a cell in the constraint system. *)\nmodule Position = struct\n open Core_kernel\n\n (** A position is a row and a column. *)\n type 'row t = { row : 'row; col : int } [@@deriving hash, sexp, compare]\n\n (** Generates a full row of positions that each points to itself. *)\n let create_cols (row : 'row) : _ t array =\n Array.init Constants.permutation_cols ~f:(fun i -> { row; col = i })\n\n (** Given a number of columns,\n append enough column wires to get an entire row.\n The wire appended will simply point to themselves,\n so as to not take part in the permutation argument.\n *)\n let append_cols (row : 'row) (cols : _ t array) : _ t array =\n let padding_offset = Array.length cols in\n assert (padding_offset <= Constants.permutation_cols) ;\n let padding_len = Constants.permutation_cols - padding_offset in\n let padding =\n Array.init padding_len ~f:(fun i -> { row; col = i + padding_offset })\n in\n Array.append cols padding\n\n (** Converts an array of [Constants.columns] to [Constants.permutation_cols].\n This is useful to truncate arrays of cells to the ones that only matter for the permutation argument.\n *)\n let cols_to_perms cols = Array.slice cols 0 Constants.permutation_cols\n\n (** Converts a [Position.t] into the Rust-compatible type [Kimchi_types.wire].\n *)\n let to_rust_wire { row; col } : Kimchi_types.wire = { row; col }\nend\n\n(** A gate. *)\nmodule Gate_spec = struct\n open Core_kernel\n\n (* TODO: split kind/coeffs from row/wired_to *)\n\n (** A gate/row/constraint consists of a type (kind), a row, the other cells its columns/cells are connected to (wired_to), and the selector polynomial associated with the gate. *)\n type ('row, 'f) t =\n { kind : Kimchi_gate_type.t\n ; wired_to : 'row Position.t array\n ; coeffs : 'f array\n }\n [@@deriving sexp_of]\n\n (** Applies a function [f] to the [row] of [t] and all the rows of its [wired_to]. *)\n let map_rows (t : (_, _) t) ~f : (_, _) t =\n (* { wire with row = f row } *)\n let wired_to =\n Array.map\n ~f:(fun (pos : _ Position.t) -> { pos with row = f pos.row })\n t.wired_to\n in\n { t with wired_to }\n\n (* TODO: just send the array to Rust directly *)\n let to_rust_gate { kind; wired_to; coeffs } : _ Kimchi_types.circuit_gate =\n let typ = kind in\n let wired_to = Array.map ~f:Position.to_rust_wire wired_to in\n let wires =\n ( wired_to.(0)\n , wired_to.(1)\n , wired_to.(2)\n , wired_to.(3)\n , wired_to.(4)\n , wired_to.(5)\n , wired_to.(6) )\n in\n { typ; wires; coeffs }\nend\n\n(** The PLONK constraints. *)\nmodule Plonk_constraint = struct\n open Core_kernel\n\n (** A PLONK constraint (or gate) can be [Basic], [Poseidon], [EC_add_complete], [EC_scale], [EC_endoscale], [EC_endoscalar], [RangeCheck0], [RangeCheck1], [Xor] *)\n module T = struct\n type ('v, 'f) t =\n | Basic of { l : 'f * 'v; r : 'f * 'v; o : 'f * 'v; m : 'f; c : 'f }\n (** the Poseidon state is an array of states (and states are arrays of size 3). *)\n | Poseidon of { state : 'v array array }\n | EC_add_complete of\n { p1 : 'v * 'v\n ; p2 : 'v * 'v\n ; p3 : 'v * 'v\n ; inf : 'v\n ; same_x : 'v\n ; slope : 'v\n ; inf_z : 'v\n ; x21_inv : 'v\n }\n | EC_scale of { state : 'v Scale_round.t array }\n | EC_endoscale of\n { state : 'v Endoscale_round.t array; xs : 'v; ys : 'v; n_acc : 'v }\n | EC_endoscalar of { state : 'v Endoscale_scalar_round.t array }\n | Lookup of\n { w0 : 'v; w1 : 'v; w2 : 'v; w3 : 'v; w4 : 'v; w5 : 'v; w6 : 'v }\n | RangeCheck0 of\n { v0 : 'v (* Value to constrain to 88-bits *)\n ; v0p0 : 'v (* MSBs *)\n ; v0p1 : 'v (* vpX are 12-bit plookup chunks *)\n ; v0p2 : 'v\n ; v0p3 : 'v\n ; v0p4 : 'v\n ; v0p5 : 'v\n ; v0c0 : 'v (* vcX are 2-bit crumbs *)\n ; v0c1 : 'v\n ; v0c2 : 'v\n ; v0c3 : 'v\n ; v0c4 : 'v\n ; v0c5 : 'v\n ; v0c6 : 'v\n ; v0c7 : 'v (* LSBs *)\n ; (* Coefficients *)\n compact : 'f\n (* Limbs mode coefficient: 0 (standard 3-limb) or 1 (compact 2-limb) *)\n }\n | RangeCheck1 of\n { (* Current row *)\n v2 : 'v (* Value to constrain to 88-bits *)\n ; v12 : 'v (* Optional value used in compact 2-limb mode *)\n ; v2c0 : 'v (* MSBs, 2-bit crumb *)\n ; v2p0 : 'v (* vpX are 12-bit plookup chunks *)\n ; v2p1 : 'v\n ; v2p2 : 'v\n ; v2p3 : 'v\n ; v2c1 : 'v (* vcX are 2-bit crumbs *)\n ; v2c2 : 'v\n ; v2c3 : 'v\n ; v2c4 : 'v\n ; v2c5 : 'v\n ; v2c6 : 'v\n ; v2c7 : 'v\n ; v2c8 : 'v (* LSBs *)\n ; (* Next row *) v2c9 : 'v\n ; v2c10 : 'v\n ; v2c11 : 'v\n ; v0p0 : 'v\n ; v0p1 : 'v\n ; v1p0 : 'v\n ; v1p1 : 'v\n ; v2c12 : 'v\n ; v2c13 : 'v\n ; v2c14 : 'v\n ; v2c15 : 'v\n ; v2c16 : 'v\n ; v2c17 : 'v\n ; v2c18 : 'v\n ; v2c19 : 'v\n }\n | Xor of\n { in1 : 'v\n ; in2 : 'v\n ; out : 'v\n ; in1_0 : 'v\n ; in1_1 : 'v\n ; in1_2 : 'v\n ; in1_3 : 'v\n ; in2_0 : 'v\n ; in2_1 : 'v\n ; in2_2 : 'v\n ; in2_3 : 'v\n ; out_0 : 'v\n ; out_1 : 'v\n ; out_2 : 'v\n ; out_3 : 'v\n }\n | ForeignFieldAdd of\n { left_input_lo : 'v\n ; left_input_mi : 'v\n ; left_input_hi : 'v\n ; right_input_lo : 'v\n ; right_input_mi : 'v\n ; right_input_hi : 'v\n ; field_overflow : 'v\n ; carry : 'v\n ; (* Coefficients *) foreign_field_modulus0 : 'f\n ; foreign_field_modulus1 : 'f\n ; foreign_field_modulus2 : 'f\n ; sign : 'f\n }\n | ForeignFieldMul of\n { left_input0 : 'v\n ; left_input1 : 'v\n ; left_input2 : 'v\n ; right_input0 : 'v\n ; right_input1 : 'v\n ; right_input2 : 'v\n ; remainder01 : 'v\n ; remainder2 : 'v\n ; quotient0 : 'v\n ; quotient1 : 'v\n ; quotient2 : 'v\n ; quotient_hi_bound : 'v\n ; product1_lo : 'v\n ; product1_hi_0 : 'v\n ; product1_hi_1 : 'v\n ; carry0 : 'v\n ; carry1_0 : 'v\n ; carry1_12 : 'v\n ; carry1_24 : 'v\n ; carry1_36 : 'v\n ; carry1_48 : 'v\n ; carry1_60 : 'v\n ; carry1_72 : 'v\n ; carry1_84 : 'v\n ; carry1_86 : 'v\n ; carry1_88 : 'v\n ; carry1_90 : 'v\n ; (* Coefficients *) foreign_field_modulus2 : 'f\n ; neg_foreign_field_modulus0 : 'f\n ; neg_foreign_field_modulus1 : 'f\n ; neg_foreign_field_modulus2 : 'f\n }\n | Rot64 of\n { (* Current row *)\n word : 'v\n ; rotated : 'v\n ; excess : 'v\n ; bound_limb0 : 'v\n ; bound_limb1 : 'v\n ; bound_limb2 : 'v\n ; bound_limb3 : 'v\n ; bound_crumb0 : 'v\n ; bound_crumb1 : 'v\n ; bound_crumb2 : 'v\n ; bound_crumb3 : 'v\n ; bound_crumb4 : 'v\n ; bound_crumb5 : 'v\n ; bound_crumb6 : 'v\n ; bound_crumb7 : 'v\n ; (* Coefficients *) two_to_rot : 'f (* Rotation scalar 2^rot *)\n }\n | Raw of\n { kind : Kimchi_gate_type.t; values : 'v array; coeffs : 'f array }\n [@@deriving sexp]\n\n (** map t *)\n let map (type a b f) (t : (a, f) t) ~(f : a -> b) =\n let fp (x, y) = (f x, f y) in\n match t with\n | Basic { l; r; o; m; c } ->\n let p (x, y) = (x, f y) in\n Basic { l = p l; r = p r; o = p o; m; c }\n | Poseidon { state } ->\n Poseidon { state = Array.map ~f:(fun x -> Array.map ~f x) state }\n | EC_add_complete { p1; p2; p3; inf; same_x; slope; inf_z; x21_inv } ->\n EC_add_complete\n { p1 = fp p1\n ; p2 = fp p2\n ; p3 = fp p3\n ; inf = f inf\n ; same_x = f same_x\n ; slope = f slope\n ; inf_z = f inf_z\n ; x21_inv = f x21_inv\n }\n | EC_scale { state } ->\n EC_scale\n { state = Array.map ~f:(fun x -> Scale_round.map ~f x) state }\n | EC_endoscale { state; xs; ys; n_acc } ->\n EC_endoscale\n { state = Array.map ~f:(fun x -> Endoscale_round.map ~f x) state\n ; xs = f xs\n ; ys = f ys\n ; n_acc = f n_acc\n }\n | EC_endoscalar { state } ->\n EC_endoscalar\n { state =\n Array.map ~f:(fun x -> Endoscale_scalar_round.map ~f x) state\n }\n | Lookup { w0; w1; w2; w3; w4; w5; w6 } ->\n Lookup\n { w0 = f w0\n ; w1 = f w1\n ; w2 = f w2\n ; w3 = f w3\n ; w4 = f w4\n ; w5 = f w5\n ; w6 = f w6\n }\n | RangeCheck0\n { v0\n ; v0p0\n ; v0p1\n ; v0p2\n ; v0p3\n ; v0p4\n ; v0p5\n ; v0c0\n ; v0c1\n ; v0c2\n ; v0c3\n ; v0c4\n ; v0c5\n ; v0c6\n ; v0c7\n ; compact\n } ->\n RangeCheck0\n { v0 = f v0\n ; v0p0 = f v0p0\n ; v0p1 = f v0p1\n ; v0p2 = f v0p2\n ; v0p3 = f v0p3\n ; v0p4 = f v0p4\n ; v0p5 = f v0p5\n ; v0c0 = f v0c0\n ; v0c1 = f v0c1\n ; v0c2 = f v0c2\n ; v0c3 = f v0c3\n ; v0c4 = f v0c4\n ; v0c5 = f v0c5\n ; v0c6 = f v0c6\n ; v0c7 = f v0c7\n ; compact\n }\n | RangeCheck1\n { (* Current row *) v2\n ; v12\n ; v2c0\n ; v2p0\n ; v2p1\n ; v2p2\n ; v2p3\n ; v2c1\n ; v2c2\n ; v2c3\n ; v2c4\n ; v2c5\n ; v2c6\n ; v2c7\n ; v2c8\n ; (* Next row *) v2c9\n ; v2c10\n ; v2c11\n ; v0p0\n ; v0p1\n ; v1p0\n ; v1p1\n ; v2c12\n ; v2c13\n ; v2c14\n ; v2c15\n ; v2c16\n ; v2c17\n ; v2c18\n ; v2c19\n } ->\n RangeCheck1\n { (* Current row *) v2 = f v2\n ; v12 = f v12\n ; v2c0 = f v2c0\n ; v2p0 = f v2p0\n ; v2p1 = f v2p1\n ; v2p2 = f v2p2\n ; v2p3 = f v2p3\n ; v2c1 = f v2c1\n ; v2c2 = f v2c2\n ; v2c3 = f v2c3\n ; v2c4 = f v2c4\n ; v2c5 = f v2c5\n ; v2c6 = f v2c6\n ; v2c7 = f v2c7\n ; v2c8 = f v2c8\n ; (* Next row *) v2c9 = f v2c9\n ; v2c10 = f v2c10\n ; v2c11 = f v2c11\n ; v0p0 = f v0p0\n ; v0p1 = f v0p1\n ; v1p0 = f v1p0\n ; v1p1 = f v1p1\n ; v2c12 = f v2c12\n ; v2c13 = f v2c13\n ; v2c14 = f v2c14\n ; v2c15 = f v2c15\n ; v2c16 = f v2c16\n ; v2c17 = f v2c17\n ; v2c18 = f v2c18\n ; v2c19 = f v2c19\n }\n | Xor\n { in1\n ; in2\n ; out\n ; in1_0\n ; in1_1\n ; in1_2\n ; in1_3\n ; in2_0\n ; in2_1\n ; in2_2\n ; in2_3\n ; out_0\n ; out_1\n ; out_2\n ; out_3\n } ->\n Xor\n { in1 = f in1\n ; in2 = f in2\n ; out = f out\n ; in1_0 = f in1_0\n ; in1_1 = f in1_1\n ; in1_2 = f in1_2\n ; in1_3 = f in1_3\n ; in2_0 = f in2_0\n ; in2_1 = f in2_1\n ; in2_2 = f in2_2\n ; in2_3 = f in2_3\n ; out_0 = f out_0\n ; out_1 = f out_1\n ; out_2 = f out_2\n ; out_3 = f out_3\n }\n | ForeignFieldAdd\n { left_input_lo\n ; left_input_mi\n ; left_input_hi\n ; right_input_lo\n ; right_input_mi\n ; right_input_hi\n ; field_overflow\n ; carry\n ; (* Coefficients *) foreign_field_modulus0\n ; foreign_field_modulus1\n ; foreign_field_modulus2\n ; sign\n } ->\n ForeignFieldAdd\n { left_input_lo = f left_input_lo\n ; left_input_mi = f left_input_mi\n ; left_input_hi = f left_input_hi\n ; right_input_lo = f right_input_lo\n ; right_input_mi = f right_input_mi\n ; right_input_hi = f right_input_hi\n ; field_overflow = f field_overflow\n ; carry = f carry\n ; (* Coefficients *) foreign_field_modulus0\n ; foreign_field_modulus1\n ; foreign_field_modulus2\n ; sign\n }\n | ForeignFieldMul\n { left_input0\n ; left_input1\n ; left_input2\n ; right_input0\n ; right_input1\n ; right_input2\n ; remainder01\n ; remainder2\n ; quotient0\n ; quotient1\n ; quotient2\n ; quotient_hi_bound\n ; product1_lo\n ; product1_hi_0\n ; product1_hi_1\n ; carry0\n ; carry1_0\n ; carry1_12\n ; carry1_24\n ; carry1_36\n ; carry1_48\n ; carry1_60\n ; carry1_72\n ; carry1_84\n ; carry1_86\n ; carry1_88\n ; carry1_90\n ; (* Coefficients *) foreign_field_modulus2\n ; neg_foreign_field_modulus0\n ; neg_foreign_field_modulus1\n ; neg_foreign_field_modulus2\n } ->\n ForeignFieldMul\n { left_input0 = f left_input0\n ; left_input1 = f left_input1\n ; left_input2 = f left_input2\n ; right_input0 = f right_input0\n ; right_input1 = f right_input1\n ; right_input2 = f right_input2\n ; remainder01 = f remainder01\n ; remainder2 = f remainder2\n ; quotient0 = f quotient0\n ; quotient1 = f quotient1\n ; quotient2 = f quotient2\n ; quotient_hi_bound = f quotient_hi_bound\n ; product1_lo = f product1_lo\n ; product1_hi_0 = f product1_hi_0\n ; product1_hi_1 = f product1_hi_1\n ; carry0 = f carry0\n ; carry1_0 = f carry1_0\n ; carry1_12 = f carry1_12\n ; carry1_24 = f carry1_24\n ; carry1_36 = f carry1_36\n ; carry1_48 = f carry1_48\n ; carry1_60 = f carry1_60\n ; carry1_72 = f carry1_72\n ; carry1_84 = f carry1_84\n ; carry1_86 = f carry1_86\n ; carry1_88 = f carry1_88\n ; carry1_90 = f carry1_90\n ; (* Coefficients *) foreign_field_modulus2\n ; neg_foreign_field_modulus0\n ; neg_foreign_field_modulus1\n ; neg_foreign_field_modulus2\n }\n | Rot64\n { (* Current row *) word\n ; rotated\n ; excess\n ; bound_limb0\n ; bound_limb1\n ; bound_limb2\n ; bound_limb3\n ; bound_crumb0\n ; bound_crumb1\n ; bound_crumb2\n ; bound_crumb3\n ; bound_crumb4\n ; bound_crumb5\n ; bound_crumb6\n ; bound_crumb7\n ; (* Coefficients *) two_to_rot\n } ->\n Rot64\n { word = f word\n ; rotated = f rotated\n ; excess = f excess\n ; bound_limb0 = f bound_limb0\n ; bound_limb1 = f bound_limb1\n ; bound_limb2 = f bound_limb2\n ; bound_limb3 = f bound_limb3\n ; bound_crumb0 = f bound_crumb0\n ; bound_crumb1 = f bound_crumb1\n ; bound_crumb2 = f bound_crumb2\n ; bound_crumb3 = f bound_crumb3\n ; bound_crumb4 = f bound_crumb4\n ; bound_crumb5 = f bound_crumb5\n ; bound_crumb6 = f bound_crumb6\n ; bound_crumb7 = f bound_crumb7\n ; (* Coefficients *) two_to_rot\n }\n | Raw { kind; values; coeffs } ->\n Raw { kind; values = Array.map ~f values; coeffs }\n\n (** [eval (module F) get_variable gate] checks that [gate]'s polynomial is\n satisfied by the assignments given by [get_variable].\n Warning: currently only implemented for the [Basic] gate.\n *)\n let eval (type v f)\n (module F : Snarky_backendless.Field_intf.S with type t = f)\n (eval_one : v -> f) (t : (v, f) t) =\n match t with\n (* cl * vl + cr * vr + co * vo + m * vl*vr + c = 0 *)\n | Basic { l = cl, vl; r = cr, vr; o = co, vo; m; c } ->\n let vl = eval_one vl in\n let vr = eval_one vr in\n let vo = eval_one vo in\n let open F in\n let res =\n List.reduce_exn ~f:add\n [ mul cl vl; mul cr vr; mul co vo; mul m (mul vl vr); c ]\n in\n if not (equal zero res) then (\n eprintf\n !\"%{sexp:t} * %{sexp:t}\\n\\\n + %{sexp:t} * %{sexp:t}\\n\\\n + %{sexp:t} * %{sexp:t}\\n\\\n + %{sexp:t} * %{sexp:t}\\n\\\n + %{sexp:t}\\n\\\n = %{sexp:t}%!\"\n cl vl cr vr co vo m (mul vl vr) c res ;\n false )\n else true\n | _ ->\n true\n end\n\n include T\n\n (* Adds our constraint enum to the list of constraints handled by Snarky. *)\n include Snarky_backendless.Constraint.Add_kind (T)\nend\n\nmodule Internal_var = Core_kernel.Unique_id.Int ()\n\nmodule V = struct\n open Core_kernel\n\n module T = struct\n (** Variables linking uses of the same data between different gates.\n\n Every internal variable is computable from a finite list of external\n variables and internal variables.\n Currently, in fact, every internal variable is a linear combination of\n external variables and previously generated internal variables.\n *)\n type t =\n | External of int\n (** An external variable (generated by snarky, via [exists]). *)\n | Internal of Internal_var.t\n (** An internal variable is generated to hold an intermediate value\n (e.g., in reducing linear combinations to single PLONK positions).\n *)\n [@@deriving compare, hash, sexp]\n end\n\n include T\n include Comparable.Make (T)\n include Hashable.Make (T)\nend\n\n(** Keeps track of a circuit (which is a list of gates)\n while it is being written.\n *)\ntype ('f, 'rust_gates) circuit =\n | Unfinalized_rev of (unit, 'f) Gate_spec.t list\n (** A circuit still being written. *)\n | Compiled of Core_kernel.Md5.t * 'rust_gates\n (** Once finalized, a circuit is represented as a digest\n and a list of gates that corresponds to the circuit.\n *)\n\n(** The constraint system. *)\ntype ('f, 'rust_gates) t =\n { (* Map of cells that share the same value (enforced by to the permutation). *)\n equivalence_classes : Row.t Position.t list V.Table.t\n ; (* How to compute each internal variable (as a linear combination of other variables). *)\n internal_vars : (('f * V.t) list * 'f option) Internal_var.Table.t\n ; (* The variables that hold each witness value for each row, in reverse order. *)\n mutable rows_rev : V.t option array list\n ; (* A circuit is described by a series of gates.\n A gate is finalized once [finalize_and_get_gates] is called.\n The finalized tag contains the digest of the circuit.\n *)\n mutable gates : ('f, 'rust_gates) circuit\n ; (* The row to use the next time we add a constraint. *)\n mutable next_row : int\n ; (* The size of the public input (which fills the first rows of our constraint system. *)\n public_input_size : int Core_kernel.Set_once.t\n ; (* The number of previous recursion challenges. *)\n prev_challenges : int Core_kernel.Set_once.t\n ; (* Whatever is not public input. *)\n mutable auxiliary_input_size : int\n ; (* Queue (of size 1) of generic gate. *)\n mutable pending_generic_gate :\n (V.t option * V.t option * V.t option * 'f array) option\n ; (* V.t's corresponding to constant values. We reuse them so we don't need to\n use a fresh generic constraint each time to create a constant.\n *)\n cached_constants : ('f, V.t) Core_kernel.Hashtbl.t\n (* The [equivalence_classes] field keeps track of the positions which must be\n enforced to be equivalent due to the fact that they correspond to the same V.t value.\n I.e., positions that are different usages of the same [V.t].\n\n We use a union-find data structure to track equalities that a constraint system wants\n enforced *between* [V.t] values. Then, at the end, for all [V.t]s that have been unioned\n together, we combine their equivalence classes in the [equivalence_classes] table into\n a single equivalence class, so that the permutation argument enforces these desired equalities\n as well.\n *)\n ; union_finds : V.t Core_kernel.Union_find.t V.Table.t\n }\n\nlet get_public_input_size sys = sys.public_input_size\n\nlet get_rows_len sys = List.length sys.rows_rev\n\nlet get_prev_challenges sys = sys.prev_challenges\n\nlet set_prev_challenges sys challenges =\n Core_kernel.Set_once.set_exn sys.prev_challenges [%here] challenges\n\n(* TODO: shouldn't that Make create something bounded by a signature? As we know what a back end should be? Check where this is used *)\n\n(* TODO: glossary of terms in this file (terms, reducing, feeding) + module doc *)\n\n(* TODO: rename Fp to F or Field *)\n\n(** ? *)\nmodule Make\n (Fp : Field.S)\n (* We create a type for gate vector, instead of using `Gate.t list`. If we did, we would have to convert it to a `Gate.t array` to pass it across the FFI boundary, where then it gets converted to a `Vec`; it's more efficient to just create the `Vec` directly.\n *)\n (Gates : Gate_vector_intf with type field := Fp.t)\n (Params : sig\n val params : Fp.t Params.t\n end) : sig\n open Core_kernel\n\n type nonrec t = (Fp.t, Gates.t) t\n\n val create : unit -> t\n\n val get_public_input_size : t -> int Set_once.t\n\n val get_primary_input_size : t -> int\n\n val set_primary_input_size : t -> int -> unit\n\n val get_auxiliary_input_size : t -> int\n\n val set_auxiliary_input_size : t -> int -> unit\n\n val get_prev_challenges : t -> int option\n\n val set_prev_challenges : t -> int -> unit\n\n val get_rows_len : t -> int\n\n val next_row : t -> int\n\n val add_constraint :\n ?label:string\n -> t\n -> ( Fp.t Snarky_backendless.Cvar.t\n , Fp.t )\n Snarky_backendless.Constraint.basic\n -> unit\n\n val compute_witness : t -> (int -> Fp.t) -> Fp.t array array\n\n val finalize : t -> unit\n\n val finalize_and_get_gates : t -> Gates.t\n\n val num_constraints : t -> int\n\n val digest : t -> Md5.t\n\n val to_json : t -> string\nend = struct\n open Core_kernel\n open Pickles_types\n\n type nonrec t = (Fp.t, Gates.t) t\n\n (** Converts the set of permutations (equivalence_classes) to\n a hash table that maps each position to the next one.\n For example, if one of the equivalence class is [pos1, pos3, pos7],\n the function will return a hashtable that maps pos1 to pos3,\n pos3 to pos7, and pos7 to pos1.\n *)\n let equivalence_classes_to_hashtbl sys =\n let module Relative_position = struct\n module T = struct\n type t = Row.t Position.t [@@deriving hash, sexp, compare]\n end\n\n include T\n include Core_kernel.Hashable.Make (T)\n end in\n let equivalence_classes = V.Table.create () in\n Hashtbl.iteri sys.equivalence_classes ~f:(fun ~key ~data ->\n let u = Hashtbl.find_exn sys.union_finds key in\n Hashtbl.update equivalence_classes (Union_find.get u) ~f:(function\n | None ->\n Relative_position.Hash_set.of_list data\n | Some ps ->\n List.iter ~f:(Hash_set.add ps) data ;\n ps ) ) ;\n let res = Relative_position.Table.create () in\n Hashtbl.iter equivalence_classes ~f:(fun ps ->\n let rotate_left = function [] -> [] | x :: xs -> xs @ [ x ] in\n let ps =\n Hash_set.to_list ps |> List.sort ~compare:[%compare: Row.t Position.t]\n in\n List.iter2_exn ps (rotate_left ps) ~f:(fun input output ->\n Hashtbl.add_exn res ~key:input ~data:output ) ) ;\n res\n\n (** Compute the witness, given the constraint system `sys`\n and a function that converts the indexed secret inputs to their concrete values.\n *)\n let compute_witness (sys : t) (external_values : int -> Fp.t) :\n Fp.t array array =\n let internal_values : Fp.t Internal_var.Table.t =\n Internal_var.Table.create ()\n in\n let public_input_size = Set_once.get_exn sys.public_input_size [%here] in\n let num_rows = public_input_size + sys.next_row in\n let res =\n Array.init Constants.columns ~f:(fun _ ->\n Array.create ~len:num_rows Fp.zero )\n in\n (* Public input *)\n for i = 0 to public_input_size - 1 do\n res.(0).(i) <- external_values i\n done ;\n let find t k =\n match Hashtbl.find t k with\n | None ->\n failwithf !\"Could not find %{sexp:Internal_var.t}\\n%!\" k ()\n | Some x ->\n x\n in\n (* Compute an internal variable associated value. *)\n let compute ((lc, c) : (Fp.t * V.t) list * Fp.t option) =\n List.fold lc ~init:(Option.value c ~default:Fp.zero) ~f:(fun acc (s, x) ->\n let x =\n match x with\n | External x ->\n external_values x\n | Internal x ->\n find internal_values x\n in\n Fp.(acc + (s * x)) )\n in\n (* Update the witness table with the value of the variables from each row. *)\n List.iteri (List.rev sys.rows_rev) ~f:(fun i_after_input cols ->\n let row_idx = i_after_input + public_input_size in\n Array.iteri cols ~f:(fun col_idx var ->\n match var with\n | None ->\n ()\n | Some (External var) ->\n res.(col_idx).(row_idx) <- external_values var\n | Some (Internal var) ->\n let lc = find sys.internal_vars var in\n let value = compute lc in\n res.(col_idx).(row_idx) <- value ;\n Hashtbl.set internal_values ~key:var ~data:value ) ) ;\n (* Return the witness. *)\n res\n\n let union_find sys v =\n Hashtbl.find_or_add sys.union_finds v ~default:(fun () ->\n Union_find.create v )\n\n (** Creates an internal variable and assigns it the value lc and constant. *)\n let create_internal ?constant sys lc : V.t =\n let v = Internal_var.create () in\n ignore (union_find sys (Internal v) : _ Union_find.t) ;\n Hashtbl.add_exn sys.internal_vars ~key:v ~data:(lc, constant) ;\n V.Internal v\n\n (* Initializes a constraint system. *)\n let create () : t =\n { public_input_size = Set_once.create ()\n ; prev_challenges = Set_once.create ()\n ; internal_vars = Internal_var.Table.create ()\n ; gates = Unfinalized_rev [] (* Gates.create () *)\n ; rows_rev = []\n ; next_row = 0\n ; equivalence_classes = V.Table.create ()\n ; auxiliary_input_size = 0\n ; pending_generic_gate = None\n ; cached_constants = Hashtbl.create (module Fp)\n ; union_finds = V.Table.create ()\n }\n\n (** Returns the number of auxiliary inputs. *)\n let get_auxiliary_input_size t = t.auxiliary_input_size\n\n (** Returns the number of public inputs. *)\n let get_primary_input_size t = Set_once.get_exn t.public_input_size [%here]\n\n (** Returns the number of previous challenges. *)\n let get_prev_challenges t = Set_once.get t.prev_challenges\n\n (* Non-public part of the witness. *)\n let set_auxiliary_input_size t x = t.auxiliary_input_size <- x\n\n (** Sets the number of public-input. It must and can only be called once. *)\n let set_primary_input_size (sys : t) num_pub_inputs =\n Set_once.set_exn sys.public_input_size [%here] num_pub_inputs\n\n (** Sets the number of previous challenges. It must and can only be called once. *)\n let set_prev_challenges (sys : t) num_prev_challenges =\n Set_once.set_exn sys.prev_challenges [%here] num_prev_challenges\n\n let get_public_input_size (sys : t) = get_public_input_size sys\n\n let get_rows_len (sys : t) = get_rows_len sys\n\n let next_row (sys : t) = sys.next_row\n\n (** Adds {row; col} to the system's wiring under a specific key.\n A key is an external or internal variable.\n The row must be given relative to the start of the circuit\n (so at the start of the public-input rows). *)\n let wire' sys key row (col : int) =\n ignore (union_find sys key : V.t Union_find.t) ;\n V.Table.add_multi sys.equivalence_classes ~key ~data:{ row; col }\n\n (* TODO: rename to wire_abs and wire_rel? or wire_public and wire_after_public? or force a single use function that takes a Row.t? *)\n\n (** Same as wire', except that the row must be given relatively to the end of the public-input rows. *)\n let wire sys key row col = wire' sys key (Row.After_public_input row) col\n\n (** Adds a row/gate/constraint to a constraint system `sys`. *)\n let add_row sys (vars : V.t option array) kind coeffs =\n match sys.gates with\n | Compiled _ ->\n failwith \"add_row called on finalized constraint system\"\n | Unfinalized_rev gates ->\n (* As we're adding a row, we're adding new cells.\n If these cells (the first 7) contain variables,\n make sure that they are wired\n *)\n let num_vars = min Constants.permutation_cols (Array.length vars) in\n let vars_for_perm = Array.slice vars 0 num_vars in\n Array.iteri vars_for_perm ~f:(fun col x ->\n Option.iter x ~f:(fun x -> wire sys x sys.next_row col) ) ;\n (* Add to gates. *)\n let open Position in\n sys.gates <- Unfinalized_rev ({ kind; wired_to = [||]; coeffs } :: gates) ;\n (* Increment row. *)\n sys.next_row <- sys.next_row + 1 ;\n (* Add to row. *)\n sys.rows_rev <- vars :: sys.rows_rev\n\n (** Adds zero-knowledgeness to the gates/rows,\n and convert into Rust type [Gates.t].\n This can only be called once.\n *)\n let rec finalize_and_get_gates sys =\n match sys with\n | { gates = Compiled (_, gates); _ } ->\n gates\n | { pending_generic_gate = Some (l, r, o, coeffs); _ } ->\n (* Finalize any pending generic constraint first. *)\n add_row sys [| l; r; o |] Generic coeffs ;\n sys.pending_generic_gate <- None ;\n finalize_and_get_gates sys\n | { gates = Unfinalized_rev gates_rev; _ } ->\n let rust_gates = Gates.create () in\n\n (* Create rows for public input. *)\n let public_input_size =\n Set_once.get_exn sys.public_input_size [%here]\n in\n let pub_selectors = [| Fp.one; Fp.zero; Fp.zero; Fp.zero; Fp.zero |] in\n let pub_input_gate_specs_rev = ref [] in\n for row = 0 to public_input_size - 1 do\n let public_var = V.External row in\n wire' sys public_var (Row.Public_input row) 0 ;\n pub_input_gate_specs_rev :=\n { Gate_spec.kind = Generic\n ; wired_to = [||]\n ; coeffs = pub_selectors\n }\n :: !pub_input_gate_specs_rev\n done ;\n\n (* Construct permutation hashmap. *)\n let pos_map = equivalence_classes_to_hashtbl sys in\n let permutation (pos : Row.t Position.t) : Row.t Position.t =\n Option.value (Hashtbl.find pos_map pos) ~default:pos\n in\n\n let update_gate_with_permutation_info (row : Row.t)\n (gate : (unit, _) Gate_spec.t) : (Row.t, _) Gate_spec.t =\n { gate with\n wired_to =\n Array.init Constants.permutation_cols ~f:(fun col ->\n permutation { row; col } )\n }\n in\n\n (* Process public gates. *)\n let public_gates = List.rev !pub_input_gate_specs_rev in\n let public_gates =\n List.mapi public_gates ~f:(fun absolute_row gate ->\n update_gate_with_permutation_info (Row.Public_input absolute_row)\n gate )\n in\n\n (* construct all the other gates (except zero-knowledge rows) *)\n let gates = List.rev gates_rev in\n let gates =\n List.mapi gates ~f:(fun relative_row gate ->\n update_gate_with_permutation_info\n (Row.After_public_input relative_row) gate )\n in\n\n (* concatenate and convert to absolute rows *)\n let to_absolute_row =\n Gate_spec.map_rows ~f:(Row.to_absolute ~public_input_size)\n in\n\n (* convert all the gates into our Gates.t Rust vector type *)\n let add_gates gates =\n List.iter gates ~f:(fun g ->\n let g = to_absolute_row g in\n Gates.add rust_gates (Gate_spec.to_rust_gate g) )\n in\n add_gates public_gates ;\n add_gates gates ;\n\n (* compute the circuit's digest *)\n let digest = Gates.digest public_input_size rust_gates in\n let md5_digest = Md5.digest_bytes digest in\n\n (* drop the gates, we don't need them anymore *)\n sys.gates <- Compiled (md5_digest, rust_gates) ;\n\n (* return the gates *)\n rust_gates\n\n (** Calls [finalize_and_get_gates] and ignores the result. *)\n let finalize t = ignore (finalize_and_get_gates t : Gates.t)\n\n let num_constraints sys = finalize_and_get_gates sys |> Gates.len\n\n let to_json (sys : t) : string =\n let gates = finalize_and_get_gates sys in\n let public_input_size = Set_once.get_exn sys.public_input_size [%here] in\n Gates.to_json public_input_size gates\n\n (* Returns a hash of the circuit. *)\n let rec digest (sys : t) =\n match sys.gates with\n | Unfinalized_rev _ ->\n finalize sys ; digest sys\n | Compiled (digest, _) ->\n digest\n\n (** Regroup terms that share the same variable.\n For example, (3, i2) ; (2, i2) can be simplified to (5, i2).\n It assumes that the list of given terms is sorted,\n and that i0 is the smallest one.\n For example, `i0 = 1` and `terms = [(_, 2); (_, 2); (_; 4); ...]`\n\n Returns `(last_scalar, last_variable, terms, terms_length)`\n where terms does not contain the last scalar and last variable observed.\n *)\n let accumulate_terms terms =\n List.fold terms ~init:Int.Map.empty ~f:(fun acc (x, i) ->\n Map.change acc i ~f:(fun y ->\n let res = match y with None -> x | Some y -> Fp.add x y in\n if Fp.(equal zero res) then None else Some res ) )\n\n (** Converts a [Cvar.t] to a `(terms, terms_length, has_constant)`.\n if `has_constant` is set, then terms start with a constant term in the form of (c, 0).\n *)\n let canonicalize x =\n let c, terms =\n Fp.(\n Snarky_backendless.Cvar.to_constant_and_terms ~add ~mul ~zero:(of_int 0)\n ~equal ~one:(of_int 1))\n x\n in\n (* Note: [(c, 0)] represents the field element [c] multiplied by the 0th\n variable, which is held constant as [Field.one].\n *)\n let terms = match c with None -> terms | Some c -> (c, 0) :: terms in\n let has_constant_term = Option.is_some c in\n let terms = accumulate_terms terms in\n let terms_list =\n Map.fold_right ~init:[] terms ~f:(fun ~key ~data acc ->\n (data, key) :: acc )\n in\n Some (terms_list, Map.length terms, has_constant_term)\n\n (** Adds a generic constraint to the constraint system.\n As there are two generic gates per row, we queue\n every other generic gate.\n *)\n let add_generic_constraint ?l ?r ?o coeffs sys : unit =\n match sys.pending_generic_gate with\n (* if the queue of generic gate is empty, queue this *)\n | None ->\n sys.pending_generic_gate <- Some (l, r, o, coeffs)\n (* otherwise empty the queue and create the row *)\n | Some (l2, r2, o2, coeffs2) ->\n let coeffs = Array.append coeffs coeffs2 in\n add_row sys [| l; r; o; l2; r2; o2 |] Generic coeffs ;\n sys.pending_generic_gate <- None\n\n (** Converts a number of scaled additions \\sum s_i * x_i\n to as many constraints as needed,\n creating temporary variables for each new row/constraint,\n and returning the output variable.\n\n For example, [(s1, x1), (s2, x2)] is transformed into:\n - internal_var_1 = s1 * x1 + s2 * x2\n - return (1, internal_var_1)\n\n and [(s1, x1), (s2, x2), (s3, x3)] is transformed into:\n - internal_var_1 = s1 * x1 + s2 * x2\n - internal_var_2 = 1 * internal_var_1 + s3 * x3\n - return (1, internal_var_2)\n\n It assumes that the list of terms is not empty. *)\n let completely_reduce sys (terms : (Fp.t * int) list) =\n (* just adding constrained variables without values *)\n let rec go = function\n | [] ->\n assert false\n | [ (s, x) ] ->\n (s, V.External x)\n | (ls, lx) :: t ->\n let lx = V.External lx in\n (* TODO: this should be rewritten to be tail-optimized *)\n let rs, rx = go t in\n let s1x1_plus_s2x2 = create_internal sys [ (ls, lx); (rs, rx) ] in\n add_generic_constraint ~l:lx ~r:rx ~o:s1x1_plus_s2x2\n [| ls; rs; Fp.(negate one); Fp.zero; Fp.zero |]\n sys ;\n (Fp.one, s1x1_plus_s2x2)\n in\n go terms\n\n (** Converts a linear combination of variables into a set of constraints.\n It returns the output variable as (1, `Var res),\n unless the output is a constant, in which case it returns (c, `Constant).\n *)\n let reduce_lincom sys (x : Fp.t Snarky_backendless.Cvar.t) =\n let constant, terms =\n Fp.(\n Snarky_backendless.Cvar.to_constant_and_terms ~add ~mul ~zero:(of_int 0)\n ~equal ~one:(of_int 1))\n x\n in\n let terms = accumulate_terms terms in\n let terms_list =\n Map.fold_right ~init:[] terms ~f:(fun ~key ~data acc ->\n (data, key) :: acc )\n in\n match (constant, Map.is_empty terms) with\n | Some c, true ->\n (c, `Constant)\n | None, true ->\n (Fp.zero, `Constant)\n | _ -> (\n match terms_list with\n | [] ->\n assert false\n | [ (ls, lx) ] -> (\n match constant with\n | None ->\n (ls, `Var (V.External lx))\n | Some c ->\n (* res = ls * lx + c *)\n let res =\n create_internal ~constant:c sys [ (ls, External lx) ]\n in\n add_generic_constraint ~l:(External lx) ~o:res\n [| ls; Fp.zero; Fp.(negate one); Fp.zero; c |]\n (* Could be here *)\n sys ;\n (Fp.one, `Var res) )\n | (ls, lx) :: tl ->\n (* reduce the terms, then add the constant *)\n let rs, rx = completely_reduce sys tl in\n let res =\n create_internal ?constant sys [ (ls, External lx); (rs, rx) ]\n in\n (* res = ls * lx + rs * rx + c *)\n add_generic_constraint ~l:(External lx) ~r:rx ~o:res\n [| ls\n ; rs\n ; Fp.(negate one)\n ; Fp.zero\n ; (match constant with Some x -> x | None -> Fp.zero)\n |]\n (* Could be here *)\n sys ;\n (Fp.one, `Var res) )\n\n (** Adds a constraint to the constraint system. *)\n let add_constraint ?label:_ sys\n (constr :\n ( Fp.t Snarky_backendless.Cvar.t\n , Fp.t )\n Snarky_backendless.Constraint.basic ) =\n let red = reduce_lincom sys in\n (* reduce any [Cvar.t] to a single internal variable *)\n let reduce_to_v (x : Fp.t Snarky_backendless.Cvar.t) : V.t =\n match red x with\n | s, `Var x ->\n if Fp.equal s Fp.one then x\n else\n let sx = create_internal sys [ (s, x) ] in\n (* s * x - sx = 0 *)\n add_generic_constraint ~l:x ~o:sx\n [| s; Fp.zero; Fp.(negate one); Fp.zero; Fp.zero |]\n sys ;\n sx\n | s, `Constant -> (\n match Hashtbl.find sys.cached_constants s with\n | Some x ->\n x\n | None ->\n let x = create_internal sys ~constant:s [] in\n add_generic_constraint ~l:x\n [| Fp.one; Fp.zero; Fp.zero; Fp.zero; Fp.negate s |]\n sys ;\n Hashtbl.set sys.cached_constants ~key:s ~data:x ;\n x )\n in\n match constr with\n | Snarky_backendless.Constraint.Square (v1, v2) -> (\n match (red v1, red v2) with\n | (sl, `Var xl), (so, `Var xo) ->\n (* (sl * xl)^2 = so * xo\n sl^2 * xl * xl - so * xo = 0\n *)\n add_generic_constraint ~l:xl ~r:xl ~o:xo\n [| Fp.zero; Fp.zero; Fp.negate so; Fp.(sl * sl); Fp.zero |]\n sys\n | (sl, `Var xl), (so, `Constant) ->\n (* TODO: it's hard to read the array of selector values, name them! *)\n add_generic_constraint ~l:xl ~r:xl\n [| Fp.zero; Fp.zero; Fp.zero; Fp.(sl * sl); Fp.negate so |]\n sys\n | (sl, `Constant), (so, `Var xo) ->\n (* sl^2 = so * xo *)\n add_generic_constraint ~o:xo\n [| Fp.zero; Fp.zero; so; Fp.zero; Fp.negate (Fp.square sl) |]\n sys\n | (sl, `Constant), (so, `Constant) ->\n assert (Fp.(equal (square sl) so)) )\n | Snarky_backendless.Constraint.R1CS (v1, v2, v3) -> (\n match (red v1, red v2, red v3) with\n | (s1, `Var x1), (s2, `Var x2), (s3, `Var x3) ->\n (* s1 x1 * s2 x2 = s3 x3\n - s1 s2 (x1 x2) + s3 x3 = 0\n *)\n add_generic_constraint ~l:x1 ~r:x2 ~o:x3\n [| Fp.zero; Fp.zero; s3; Fp.(negate s1 * s2); Fp.zero |]\n sys\n | (s1, `Var x1), (s2, `Var x2), (s3, `Constant) ->\n add_generic_constraint ~l:x1 ~r:x2\n [| Fp.zero; Fp.zero; Fp.zero; Fp.(s1 * s2); Fp.negate s3 |]\n sys\n | (s1, `Var x1), (s2, `Constant), (s3, `Var x3) ->\n (* s1 x1 * s2 = s3 x3\n *)\n add_generic_constraint ~l:x1 ~o:x3\n [| Fp.(s1 * s2); Fp.zero; Fp.negate s3; Fp.zero; Fp.zero |]\n sys\n | (s1, `Constant), (s2, `Var x2), (s3, `Var x3) ->\n add_generic_constraint ~r:x2 ~o:x3\n [| Fp.zero; Fp.(s1 * s2); Fp.negate s3; Fp.zero; Fp.zero |]\n sys\n | (s1, `Var x1), (s2, `Constant), (s3, `Constant) ->\n add_generic_constraint ~l:x1\n [| Fp.(s1 * s2); Fp.zero; Fp.zero; Fp.zero; Fp.negate s3 |]\n sys\n | (s1, `Constant), (s2, `Var x2), (s3, `Constant) ->\n add_generic_constraint ~r:x2\n [| Fp.zero; Fp.(s1 * s2); Fp.zero; Fp.zero; Fp.negate s3 |]\n sys\n | (s1, `Constant), (s2, `Constant), (s3, `Var x3) ->\n add_generic_constraint ~o:x3\n [| Fp.zero; Fp.zero; s3; Fp.zero; Fp.(negate s1 * s2) |]\n sys\n | (s1, `Constant), (s2, `Constant), (s3, `Constant) ->\n assert (Fp.(equal s3 Fp.(s1 * s2))) )\n | Snarky_backendless.Constraint.Boolean v -> (\n let s, x = red v in\n match x with\n | `Var x ->\n (* -x + x * x = 0 *)\n add_generic_constraint ~l:x ~r:x\n [| Fp.(negate one); Fp.zero; Fp.zero; Fp.one; Fp.zero |]\n sys\n | `Constant ->\n assert (Fp.(equal s (s * s))) )\n | Snarky_backendless.Constraint.Equal (v1, v2) -> (\n let (s1, x1), (s2, x2) = (red v1, red v2) in\n match (x1, x2) with\n | `Var x1, `Var x2 ->\n if Fp.equal s1 s2 then (\n if not (Fp.equal s1 Fp.zero) then\n Union_find.union (union_find sys x1) (union_find sys x2) )\n else if (* s1 x1 - s2 x2 = 0\n *)\n not (Fp.equal s1 s2) then\n add_generic_constraint ~l:x1 ~r:x2\n [| s1; Fp.(negate s2); Fp.zero; Fp.zero; Fp.zero |]\n sys\n else\n add_generic_constraint ~l:x1 ~r:x2\n [| s1; Fp.(negate s2); Fp.zero; Fp.zero; Fp.zero |]\n sys\n | `Var x1, `Constant -> (\n (* s1 * x1 = s2\n x1 = s2 / s1\n *)\n let ratio = Fp.(s2 / s1) in\n match Hashtbl.find sys.cached_constants ratio with\n | Some x2 ->\n Union_find.union (union_find sys x1) (union_find sys x2)\n | None ->\n add_generic_constraint ~l:x1\n [| s1; Fp.zero; Fp.zero; Fp.zero; Fp.negate s2 |]\n sys ;\n Hashtbl.set sys.cached_constants ~key:ratio ~data:x1 )\n | `Constant, `Var x2 -> (\n (* s1 = s2 * x2\n x2 = s1 / s2\n *)\n let ratio = Fp.(s1 / s2) in\n match Hashtbl.find sys.cached_constants ratio with\n | Some x1 ->\n Union_find.union (union_find sys x1) (union_find sys x2)\n | None ->\n add_generic_constraint ~r:x2\n [| Fp.zero; s2; Fp.zero; Fp.zero; Fp.negate s1 |]\n sys ;\n Hashtbl.set sys.cached_constants ~key:ratio ~data:x2 )\n | `Constant, `Constant ->\n assert (Fp.(equal s1 s2)) )\n | Plonk_constraint.T (Basic { l; r; o; m; c }) ->\n (* 0\n = l.s * l.x\n + r.s * r.x\n + o.s * o.x\n + m * (l.x * r.x)\n + c\n =\n l.s * l.s' * l.x'\n + r.s * r.s' * r.x'\n + o.s * o.s' * o.x'\n + m * (l.s' * l.x' * r.s' * r.x')\n + c\n =\n (l.s * l.s') * l.x'\n + (r.s * r.s') * r.x'\n + (o.s * o.s') * o.x'\n + (m * l.s' * r.s') * l.x' r.x'\n + c\n *)\n (* TODO: This is sub-optimal *)\n let c = ref c in\n let red_pr (s, x) =\n match red x with\n | s', `Constant ->\n c := Fp.add !c Fp.(s * s') ;\n (* No need to have a real term. *)\n (s', None)\n | s', `Var x ->\n (s', Some (Fp.(s * s'), x))\n in\n (* l.s * l.x\n + r.s * r.x\n + o.s * o.x\n + m * (l.x * r.x)\n + c\n =\n l.s * l.s' * l.x'\n + r.s * r.x\n + o.s * o.x\n + m * (l.x * r.x)\n + c\n =\n *)\n let l_s', l = red_pr l in\n let r_s', r = red_pr r in\n let _, o = red_pr o in\n let var = Option.map ~f:snd in\n let coeff = Option.value_map ~default:Fp.zero ~f:fst in\n let m =\n match (l, r) with\n | Some _, Some _ ->\n Fp.(l_s' * r_s' * m)\n | _ ->\n (* TODO: Figure this out later. *)\n failwith \"Must use non-constant cvar in plonk constraints\"\n in\n add_generic_constraint ?l:(var l) ?r:(var r) ?o:(var o)\n [| coeff l; coeff r; coeff o; m; !c |]\n sys\n (* | w0 | w1 | w2 | w3 | w4 | w5\n state = [ x , x , x ], [ y, y, y ], ... ]\n i=0, perm^ i=1, perm^\n *)\n | Plonk_constraint.T (Poseidon { state }) ->\n (* reduce the state *)\n let reduce_state sys (s : Fp.t Snarky_backendless.Cvar.t array array) :\n V.t array array =\n Array.map ~f:(Array.map ~f:reduce_to_v) s\n in\n let state = reduce_state sys state in\n (* add_round_state adds a row that contains 5 rounds of permutation *)\n let add_round_state ~round (s1, s2, s3, s4, s5) =\n let vars =\n [| Some s1.(0)\n ; Some s1.(1)\n ; Some s1.(2)\n ; Some s5.(0) (* the last state is in 2nd position *)\n ; Some s5.(1)\n ; Some s5.(2)\n ; Some s2.(0)\n ; Some s2.(1)\n ; Some s2.(2)\n ; Some s3.(0)\n ; Some s3.(1)\n ; Some s3.(2)\n ; Some s4.(0)\n ; Some s4.(1)\n ; Some s4.(2)\n |]\n in\n let coeffs =\n [| Params.params.round_constants.(round).(0)\n ; Params.params.round_constants.(round).(1)\n ; Params.params.round_constants.(round).(2)\n ; Params.params.round_constants.(round + 1).(0)\n ; Params.params.round_constants.(round + 1).(1)\n ; Params.params.round_constants.(round + 1).(2)\n ; Params.params.round_constants.(round + 2).(0)\n ; Params.params.round_constants.(round + 2).(1)\n ; Params.params.round_constants.(round + 2).(2)\n ; Params.params.round_constants.(round + 3).(0)\n ; Params.params.round_constants.(round + 3).(1)\n ; Params.params.round_constants.(round + 3).(2)\n ; Params.params.round_constants.(round + 4).(0)\n ; Params.params.round_constants.(round + 4).(1)\n ; Params.params.round_constants.(round + 4).(2)\n |]\n in\n add_row sys vars Poseidon coeffs\n in\n (* add_last_row adds the last row containing the output *)\n let add_last_row state =\n let vars =\n [| Some state.(0)\n ; Some state.(1)\n ; Some state.(2)\n ; None\n ; None\n ; None\n ; None\n ; None\n ; None\n ; None\n ; None\n ; None\n ; None\n ; None\n ; None\n |]\n in\n add_row sys vars Zero [||]\n in\n (* go through the states row by row (a row contains 5 states) *)\n let rec process_5_states_at_a_time ~round = function\n | [ s1; s2; s3; s4; s5; last ] ->\n add_round_state ~round (s1, s2, s3, s4, s5) ;\n add_last_row last\n | s1 :: s2 :: s3 :: s4 :: s5 :: tl ->\n add_round_state ~round (s1, s2, s3, s4, s5) ;\n process_5_states_at_a_time ~round:(round + 5) tl\n | _ ->\n failwith \"incorrect number of states given\"\n in\n process_5_states_at_a_time ~round:0 (Array.to_list state)\n | Plonk_constraint.T\n (EC_add_complete { p1; p2; p3; inf; same_x; slope; inf_z; x21_inv }) ->\n let reduce_curve_point (x, y) = (reduce_to_v x, reduce_to_v y) in\n\n (*\n //! 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14\n //! x1 y1 x2 y2 x3 y3 inf same_x s inf_z x21_inv\n *)\n let x1, y1 = reduce_curve_point p1 in\n let x2, y2 = reduce_curve_point p2 in\n let x3, y3 = reduce_curve_point p3 in\n let vars =\n [| Some x1\n ; Some y1\n ; Some x2\n ; Some y2\n ; Some x3\n ; Some y3\n ; Some (reduce_to_v inf)\n ; Some (reduce_to_v same_x)\n ; Some (reduce_to_v slope)\n ; Some (reduce_to_v inf_z)\n ; Some (reduce_to_v x21_inv)\n ; None\n ; None\n ; None\n ; None\n |]\n in\n add_row sys vars CompleteAdd [||]\n | Plonk_constraint.T (EC_scale { state }) ->\n let i = ref 0 in\n (*\n 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14\n xT yT x0 y0 n n' x1 y1 x2 y2 x3 y3 x4 y4\n x5 y5 b0 b1 b2 b3 b4 s0 s1 s2 s3 s4\n *)\n let add_ecscale_round\n Scale_round.{ accs; bits; ss; base = xt, yt; n_prev; n_next } =\n let curr_row =\n [| Some xt\n ; Some yt\n ; Some (fst accs.(0))\n ; Some (snd accs.(0))\n ; Some n_prev\n ; Some n_next\n ; None\n ; Some (fst accs.(1))\n ; Some (snd accs.(1))\n ; Some (fst accs.(2))\n ; Some (snd accs.(2))\n ; Some (fst accs.(3))\n ; Some (snd accs.(3))\n ; Some (fst accs.(4))\n ; Some (snd accs.(4))\n |]\n in\n let next_row =\n [| Some (fst accs.(5))\n ; Some (snd accs.(5))\n ; Some bits.(0)\n ; Some bits.(1)\n ; Some bits.(2)\n ; Some bits.(3)\n ; Some bits.(4)\n ; Some ss.(0)\n ; Some ss.(1)\n ; Some ss.(2)\n ; Some ss.(3)\n ; Some ss.(4)\n ; None\n ; None\n ; None\n |]\n in\n add_row sys curr_row VarBaseMul [||] ;\n add_row sys next_row Zero [||]\n in\n\n Array.iter\n ~f:(fun round -> add_ecscale_round round ; incr i)\n (Array.map state ~f:(Scale_round.map ~f:reduce_to_v)) ;\n ()\n | Plonk_constraint.T (EC_endoscale { state; xs; ys; n_acc }) ->\n (* Reduce state. *)\n let state = Array.map state ~f:(Endoscale_round.map ~f:reduce_to_v) in\n (* Add round function. *)\n let add_endoscale_round (round : V.t Endoscale_round.t) =\n let row =\n [| Some round.xt\n ; Some round.yt\n ; None\n ; None\n ; Some round.xp\n ; Some round.yp\n ; Some round.n_acc\n ; Some round.xr\n ; Some round.yr\n ; Some round.s1\n ; Some round.s3\n ; Some round.b1\n ; Some round.b2\n ; Some round.b3\n ; Some round.b4\n |]\n in\n add_row sys row Kimchi_types.EndoMul [||]\n in\n Array.iter state ~f:add_endoscale_round ;\n (* Last row. *)\n let vars =\n [| None\n ; None\n ; None\n ; None\n ; Some (reduce_to_v xs)\n ; Some (reduce_to_v ys)\n ; Some (reduce_to_v n_acc)\n ; None\n ; None\n ; None\n ; None\n ; None\n ; None\n ; None\n ; None\n |]\n in\n add_row sys vars Zero [||]\n | Plonk_constraint.T\n (EC_endoscalar { state : 'v Endoscale_scalar_round.t array }) ->\n (* Add round function. *)\n let add_endoscale_scalar_round (round : V.t Endoscale_scalar_round.t) =\n let row =\n [| Some round.n0\n ; Some round.n8\n ; Some round.a0\n ; Some round.b0\n ; Some round.a8\n ; Some round.b8\n ; Some round.x0\n ; Some round.x1\n ; Some round.x2\n ; Some round.x3\n ; Some round.x4\n ; Some round.x5\n ; Some round.x6\n ; Some round.x7\n ; None\n |]\n in\n add_row sys row Kimchi_types.EndoMulScalar [||]\n in\n Array.iter state\n ~f:\n (Fn.compose add_endoscale_scalar_round\n (Endoscale_scalar_round.map ~f:reduce_to_v) )\n | Plonk_constraint.T (Lookup { w0; w1; w2; w3; w4; w5; w6 }) ->\n let vars =\n [| Some (reduce_to_v w0)\n ; Some (reduce_to_v w1)\n ; Some (reduce_to_v w2)\n ; Some (reduce_to_v w3)\n ; Some (reduce_to_v w4)\n ; Some (reduce_to_v w5)\n ; Some (reduce_to_v w6)\n |]\n in\n add_row sys vars Lookup [||]\n | Plonk_constraint.T\n (RangeCheck0\n { v0\n ; v0p0\n ; v0p1\n ; v0p2\n ; v0p3\n ; v0p4\n ; v0p5\n ; v0c0\n ; v0c1\n ; v0c2\n ; v0c3\n ; v0c4\n ; v0c5\n ; v0c6\n ; v0c7\n ; compact\n } ) ->\n (*\n //! 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14\n //! v vp0 vp1 vp2 vp3 vp4 vp5 vc0 vc1 vc2 vc3 vc4 vc5 vc6 vc7\n *)\n let vars =\n [| Some (reduce_to_v v0)\n ; Some (reduce_to_v v0p0) (* MSBs *)\n ; Some (reduce_to_v v0p1)\n ; Some (reduce_to_v v0p2)\n ; Some (reduce_to_v v0p3)\n ; Some (reduce_to_v v0p4)\n ; Some (reduce_to_v v0p5)\n ; Some (reduce_to_v v0c0)\n ; Some (reduce_to_v v0c1)\n ; Some (reduce_to_v v0c2)\n ; Some (reduce_to_v v0c3)\n ; Some (reduce_to_v v0c4)\n ; Some (reduce_to_v v0c5)\n ; Some (reduce_to_v v0c6)\n ; Some (reduce_to_v v0c7) (* LSBs *)\n |]\n in\n let coeff = if Fp.equal compact Fp.one then Fp.one else Fp.zero in\n add_row sys vars RangeCheck0 [| coeff |]\n | Plonk_constraint.T\n (RangeCheck1\n { (* Current row *) v2\n ; v12\n ; v2c0\n ; v2p0\n ; v2p1\n ; v2p2\n ; v2p3\n ; v2c1\n ; v2c2\n ; v2c3\n ; v2c4\n ; v2c5\n ; v2c6\n ; v2c7\n ; v2c8\n ; (* Next row *) v2c9\n ; v2c10\n ; v2c11\n ; v0p0\n ; v0p1\n ; v1p0\n ; v1p1\n ; v2c12\n ; v2c13\n ; v2c14\n ; v2c15\n ; v2c16\n ; v2c17\n ; v2c18\n ; v2c19\n } ) ->\n (*\n //! 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14\n //! Curr: v2 v12 v2c0 v2p0 v2p1 v2p2 v2p3 v2c1 v2c2 v2c3 v2c4 v2c5 v2c6 v2c7 v2c8\n //! Next: v2c9 v2c10 v2c11 v0p0 v0p1 v1p0 v1p1 v2c12 v2c13 v2c14 v2c15 v2c16 v2c17 v2c18 v2c19\n *)\n let vars_curr =\n [| (* Current row *) Some (reduce_to_v v2)\n ; Some (reduce_to_v v12)\n ; Some (reduce_to_v v2c0) (* MSBs *)\n ; Some (reduce_to_v v2p0)\n ; Some (reduce_to_v v2p1)\n ; Some (reduce_to_v v2p2)\n ; Some (reduce_to_v v2p3)\n ; Some (reduce_to_v v2c1)\n ; Some (reduce_to_v v2c2)\n ; Some (reduce_to_v v2c3)\n ; Some (reduce_to_v v2c4)\n ; Some (reduce_to_v v2c5)\n ; Some (reduce_to_v v2c6)\n ; Some (reduce_to_v v2c7)\n ; Some (reduce_to_v v2c8) (* LSBs *)\n |]\n in\n let vars_next =\n [| (* Next row *) Some (reduce_to_v v2c9)\n ; Some (reduce_to_v v2c10)\n ; Some (reduce_to_v v2c11)\n ; Some (reduce_to_v v0p0)\n ; Some (reduce_to_v v0p1)\n ; Some (reduce_to_v v1p0)\n ; Some (reduce_to_v v1p1)\n ; Some (reduce_to_v v2c12)\n ; Some (reduce_to_v v2c13)\n ; Some (reduce_to_v v2c14)\n ; Some (reduce_to_v v2c15)\n ; Some (reduce_to_v v2c16)\n ; Some (reduce_to_v v2c17)\n ; Some (reduce_to_v v2c18)\n ; Some (reduce_to_v v2c19)\n |]\n in\n add_row sys vars_curr RangeCheck1 [||] ;\n add_row sys vars_next Zero [||]\n | Plonk_constraint.T\n (Xor\n { in1\n ; in2\n ; out\n ; in1_0\n ; in1_1\n ; in1_2\n ; in1_3\n ; in2_0\n ; in2_1\n ; in2_2\n ; in2_3\n ; out_0\n ; out_1\n ; out_2\n ; out_3\n } ) ->\n (* | Column | Curr | Next (gadget responsibility) |\n | ------ | ---------------- | ---------------------------- |\n | 0 | copy `in1` | copy `in1'` |\n | 1 | copy `in2` | copy `in2'` |\n | 2 | copy `out` | copy `out'` |\n | 3 | plookup0 `in1_0` | |\n | 4 | plookup1 `in1_1` | |\n | 5 | plookup2 `in1_2` | |\n | 6 | plookup3 `in1_3` | |\n | 7 | plookup0 `in2_0` | |\n | 8 | plookup1 `in2_1` | |\n | 9 | plookup2 `in2_2` | |\n | 10 | plookup3 `in2_3` | |\n | 11 | plookup0 `out_0` | |\n | 12 | plookup1 `out_1` | |\n | 13 | plookup2 `out_2` | |\n | 14 | plookup3 `out_3` | |\n *)\n let curr_row =\n [| Some (reduce_to_v in1)\n ; Some (reduce_to_v in2)\n ; Some (reduce_to_v out)\n ; Some (reduce_to_v in1_0)\n ; Some (reduce_to_v in1_1)\n ; Some (reduce_to_v in1_2)\n ; Some (reduce_to_v in1_3)\n ; Some (reduce_to_v in2_0)\n ; Some (reduce_to_v in2_1)\n ; Some (reduce_to_v in2_2)\n ; Some (reduce_to_v in2_3)\n ; Some (reduce_to_v out_0)\n ; Some (reduce_to_v out_1)\n ; Some (reduce_to_v out_2)\n ; Some (reduce_to_v out_3)\n |]\n in\n (* The raw gate after a Xor16 gate is a Const to check that all values are zero.\n For that, the first coefficient is 1 and the rest will be zero.\n This will be included in the gadget for a chain of Xors, not here.*)\n add_row sys curr_row Xor16 [||]\n | Plonk_constraint.T\n (ForeignFieldAdd\n { left_input_lo\n ; left_input_mi\n ; left_input_hi\n ; right_input_lo\n ; right_input_mi\n ; right_input_hi\n ; field_overflow\n ; carry\n ; (* Coefficients *) foreign_field_modulus0\n ; foreign_field_modulus1\n ; foreign_field_modulus2\n ; sign\n } ) ->\n (*\n //! | Gate | `ForeignFieldAdd` | Circuit/gadget responsibility |\n //! | ------ | ------------------------ | ------------------------------ |\n //! | Column | `Curr` | `Next` |\n //! | ------ | ------------------------ | ------------------------------ |\n //! | 0 | `left_input_lo` (copy) | `result_lo` (copy) |\n //! | 1 | `left_input_mi` (copy) | `result_mi` (copy) |\n //! | 2 | `left_input_hi` (copy) | `result_hi` (copy) |\n //! | 3 | `right_input_lo` (copy) | |\n //! | 4 | `right_input_mi` (copy) | |\n //! | 5 | `right_input_hi` (copy) | |\n //! | 6 | `field_overflow` (copy?) | |\n //! | 7 | `carry` | |\n //! | 8 | | |\n //! | 9 | | |\n //! | 10 | | |\n //! | 11 | | |\n //! | 12 | | |\n //! | 13 | | |\n //! | 14 | | |\n *)\n let vars =\n [| (* Current row *) Some (reduce_to_v left_input_lo)\n ; Some (reduce_to_v left_input_mi)\n ; Some (reduce_to_v left_input_hi)\n ; Some (reduce_to_v right_input_lo)\n ; Some (reduce_to_v right_input_mi)\n ; Some (reduce_to_v right_input_hi)\n ; Some (reduce_to_v field_overflow)\n ; Some (reduce_to_v carry)\n ; None\n ; None\n ; None\n ; None\n ; None\n ; None\n ; None\n |]\n in\n add_row sys vars ForeignFieldAdd\n [| foreign_field_modulus0\n ; foreign_field_modulus1\n ; foreign_field_modulus2\n ; sign\n |]\n | Plonk_constraint.T\n (ForeignFieldMul\n { left_input0\n ; left_input1\n ; left_input2\n ; right_input0\n ; right_input1\n ; right_input2\n ; remainder01\n ; remainder2\n ; quotient0\n ; quotient1\n ; quotient2\n ; quotient_hi_bound\n ; product1_lo\n ; product1_hi_0\n ; product1_hi_1\n ; carry0\n ; carry1_0\n ; carry1_12\n ; carry1_24\n ; carry1_36\n ; carry1_48\n ; carry1_60\n ; carry1_72\n ; carry1_84\n ; carry1_86\n ; carry1_88\n ; carry1_90\n ; (* Coefficients *) foreign_field_modulus2\n ; neg_foreign_field_modulus0\n ; neg_foreign_field_modulus1\n ; neg_foreign_field_modulus2\n } ) ->\n (*\n | col | `ForeignFieldMul` | `Zero` |\n | --- | ----------------------- | -------------------------- |\n | 0 | `left_input0` (copy) | `remainder01` (copy) |\n | 1 | `left_input1` (copy) | `remainder2` (copy) |\n | 2 | `left_input2` (copy) | `quotient0` (copy) |\n | 3 | `right_input0` (copy) | `quotient1` (copy) |\n | 4 | `right_input1` (copy) | `quotient2` (copy) |\n | 5 | `right_input2` (copy) | `quotient_hi_bound` (copy) |\n | 6 | `product1_lo` (copy) | `product1_hi_0` (copy) |\n | 7 | `carry1_0` (plookup) | `product1_hi_1` (dummy) |\n | 8 | `carry1_12 (plookup) | `carry1_48` (plookup) |\n | 9 | `carry1_24` (plookup) | `carry1_60` (plookup) |\n | 10 | `carry1_36` (plookup) | `carry1_72` (plookup) |\n | 11 | `carry1_84` | `carry0` |\n | 12 | `carry1_86` | |\n | 13 | `carry1_88` | |\n | 14 | `carry1_90` | |\n *)\n (* Current row *)\n let vars_curr =\n [| Some (reduce_to_v left_input0)\n ; Some (reduce_to_v left_input1)\n ; Some (reduce_to_v left_input2)\n ; Some (reduce_to_v right_input0)\n ; Some (reduce_to_v right_input1)\n ; Some (reduce_to_v right_input2)\n ; Some (reduce_to_v product1_lo)\n ; Some (reduce_to_v carry1_0)\n ; Some (reduce_to_v carry1_12)\n ; Some (reduce_to_v carry1_24)\n ; Some (reduce_to_v carry1_36)\n ; Some (reduce_to_v carry1_84)\n ; Some (reduce_to_v carry1_86)\n ; Some (reduce_to_v carry1_88)\n ; Some (reduce_to_v carry1_90)\n |]\n in\n (* Next row *)\n let vars_next =\n [| Some (reduce_to_v remainder01)\n ; Some (reduce_to_v remainder2)\n ; Some (reduce_to_v quotient0)\n ; Some (reduce_to_v quotient1)\n ; Some (reduce_to_v quotient2)\n ; Some (reduce_to_v quotient_hi_bound)\n ; Some (reduce_to_v product1_hi_0)\n ; Some (reduce_to_v product1_hi_1)\n ; Some (reduce_to_v carry1_48)\n ; Some (reduce_to_v carry1_60)\n ; Some (reduce_to_v carry1_72)\n ; Some (reduce_to_v carry0)\n ; None\n ; None\n ; None\n |]\n in\n add_row sys vars_curr ForeignFieldMul\n [| foreign_field_modulus2\n ; neg_foreign_field_modulus0\n ; neg_foreign_field_modulus1\n ; neg_foreign_field_modulus2\n |] ;\n add_row sys vars_next Zero [||]\n | Plonk_constraint.T\n (Rot64\n { word\n ; rotated\n ; excess\n ; bound_limb0\n ; bound_limb1\n ; bound_limb2\n ; bound_limb3\n ; bound_crumb0\n ; bound_crumb1\n ; bound_crumb2\n ; bound_crumb3\n ; bound_crumb4\n ; bound_crumb5\n ; bound_crumb6\n ; bound_crumb7\n ; (* Coefficients *) two_to_rot\n } ) ->\n (*\n //! | Gate | `Rot64` | `RangeCheck0` gadgets (designer's duty) |\n //! | ------ | ------------------- | --------------------------------------------------------- |\n //! | Column | `Curr` | `Next` | `Next` + 1 | `Next`+ 2, if needed |\n //! | ------ | ------------------- | ---------------- | --------------- | -------------------- |\n //! | 0 | copy `word` |`shifted` | copy `excess` | copy `word` |\n //! | 1 | copy `rotated` | 0 | 0 | 0 |\n //! | 2 | `excess` | 0 | 0 | 0 |\n //! | 3 | `bound_limb0` | `shifted_limb0` | `excess_limb0` | `word_limb0` |\n //! | 4 | `bound_limb1` | `shifted_limb1` | `excess_limb1` | `word_limb1` |\n //! | 5 | `bound_limb2` | `shifted_limb2` | `excess_limb2` | `word_limb2` |\n //! | 6 | `bound_limb3` | `shifted_limb3` | `excess_limb3` | `word_limb3` |\n //! | 7 | `bound_crumb0` | `shifted_crumb0` | `excess_crumb0` | `word_crumb0` |\n //! | 8 | `bound_crumb1` | `shifted_crumb1` | `excess_crumb1` | `word_crumb1` | \n //! | 9 | `bound_crumb2` | `shifted_crumb2` | `excess_crumb2` | `word_crumb2` | \n //! | 10 | `bound_crumb3` | `shifted_crumb3` | `excess_crumb3` | `word_crumb3` | \n //! | 11 | `bound_crumb4` | `shifted_crumb4` | `excess_crumb4` | `word_crumb4` |\n //! | 12 | `bound_crumb5` | `shifted_crumb5` | `excess_crumb5` | `word_crumb5` |\n //! | 13 | `bound_crumb6` | `shifted_crumb6` | `excess_crumb6` | `word_crumb6` |\n //! | 14 | `bound_crumb7` | `shifted_crumb7` | `excess_crumb7` | `word_crumb7` |\n *)\n let vars_curr =\n [| (* Current row *) Some (reduce_to_v word)\n ; Some (reduce_to_v rotated)\n ; Some (reduce_to_v excess)\n ; Some (reduce_to_v bound_limb0)\n ; Some (reduce_to_v bound_limb1)\n ; Some (reduce_to_v bound_limb2)\n ; Some (reduce_to_v bound_limb3)\n ; Some (reduce_to_v bound_crumb0)\n ; Some (reduce_to_v bound_crumb1)\n ; Some (reduce_to_v bound_crumb2)\n ; Some (reduce_to_v bound_crumb3)\n ; Some (reduce_to_v bound_crumb4)\n ; Some (reduce_to_v bound_crumb5)\n ; Some (reduce_to_v bound_crumb6)\n ; Some (reduce_to_v bound_crumb7)\n |]\n in\n add_row sys vars_curr Rot64 [| two_to_rot |]\n | Plonk_constraint.T (Raw { kind; values; coeffs }) ->\n let values =\n Array.init 15 ~f:(fun i ->\n (* Insert [None] if the index is beyond the end of the [values]\n array.\n *)\n Option.try_with (fun () -> reduce_to_v values.(i)) )\n in\n add_row sys values kind coeffs\n | constr ->\n failwithf \"Unhandled constraint %s\"\n Obj.(Extension_constructor.name (Extension_constructor.of_val constr))\n ()\nend\n","open Core_kernel\n\ntype ('a, 's) fold = init:'s -> f:('s -> 'a -> 's) -> 's\n\ntype 'a t = { fold : 's. ('a, 's) fold }\n\nlet map (t : 'a t) ~(f : 'a -> 'b) : 'b t =\n { fold =\n (fun ~init ~f:update -> t.fold ~init ~f:(fun acc x -> update acc (f x)))\n }\n\nlet concat (t : 'a t t) : 'a t =\n { fold =\n (fun ~init ~f ->\n t.fold ~init ~f:(fun acc inner -> inner.fold ~init:acc ~f) )\n }\n\nlet concat_map (t : 'a t) ~(f : 'a -> 'b t) : 'b t =\n { fold =\n (fun ~init ~f:update ->\n t.fold ~init ~f:(fun acc x -> (f x).fold ~init:acc ~f:update) )\n }\n\nlet init n ~f:ith_elt =\n { fold =\n (fun ~init ~f ->\n let rec go i acc =\n if i = n then acc else go (i + 1) (f acc (ith_elt i))\n in\n go 0 init )\n }\n\ninclude Monad.Make (struct\n type nonrec 'a t = 'a t\n\n let map = `Custom map\n\n let return x = { fold = (fun ~init ~f -> f init x) }\n\n let bind = concat_map\nend)\n\nlet to_list (t : 'a t) : 'a list =\n List.rev (t.fold ~init:[] ~f:(Fn.flip List.cons))\n\nlet of_list (xs : 'a list) : 'a t =\n { fold = (fun ~init ~f -> List.fold xs ~init ~f) }\n\nlet of_array (xs : 'a array) : 'a t =\n { fold = (fun ~init ~f -> Array.fold xs ~init ~f) }\n\nlet%test_unit \"fold-to-list\" =\n Quickcheck.test (Quickcheck.Generator.list Int.quickcheck_generator)\n ~f:(fun xs -> assert ([%equal: Int.t list] xs (to_list (of_list xs))))\n\nlet sexp_of_t f t = List.sexp_of_t f (to_list t)\n\nlet compose (t1 : 'a t) (t2 : 'a t) : 'a t =\n { fold = (fun ~init ~f -> t2.fold ~init:(t1.fold ~init ~f) ~f) }\n\nlet ( +> ) = compose\n\nlet group3 ~default (t : 'a t) : ('a * 'a * 'a) t =\n { fold =\n (fun ~init ~f ->\n let pt, bs =\n t.fold ~init:(init, []) ~f:(fun (pt, bs) b ->\n match bs with\n | [ b2; b1; b0 ] ->\n let pt' = f pt (b0, b1, b2) in\n (pt', [ b ])\n | _ ->\n (pt, b :: bs) )\n in\n match bs with\n | [ b2; b1; b0 ] ->\n f pt (b0, b1, b2)\n | [ b1; b0 ] ->\n f pt (b0, b1, default)\n | [ b0 ] ->\n f pt (b0, default, default)\n | [] ->\n pt\n | _x1 :: _x2 :: _x3 :: _x4 :: _ ->\n assert false )\n }\n\nlet%test_unit \"group3\" =\n Quickcheck.test (Quickcheck.Generator.list Int.quickcheck_generator)\n ~f:(fun xs ->\n let default = 0 in\n let n = List.length xs in\n let tuples = to_list (group3 ~default (of_list xs)) in\n let k = List.length tuples in\n let r = n mod 3 in\n (let padded =\n xs @ if r = 0 then [] else List.init (3 - r) ~f:(fun _ -> default)\n in\n let concated =\n List.concat_map ~f:(fun (b1, b2, b3) -> [ b1; b2; b3 ]) tuples\n in\n [%test_eq: int list] padded concated ) ;\n assert ((n + 2) / 3 = k) )\n\nlet string_bits s =\n let ith_bit_int n i = (n lsr i) land 1 = 1 in\n { fold =\n (fun ~init ~f ->\n String.fold s ~init ~f:(fun acc c ->\n let c = Char.to_int c in\n let update i acc = f acc (ith_bit_int c i) in\n update 0 acc |> update 1 |> update 2 |> update 3 |> update 4\n |> update 5 |> update 6 |> update 7 ) )\n }\n\nlet bool_t_to_string =\n let module State = struct\n type t = { curr : int; acc : char list; i : int }\n end in\n let open State in\n fun t ->\n let { curr; i; acc } =\n t.fold ~init:{ curr = 0; acc = []; i = 0 } ~f:(fun { curr; acc; i } b ->\n let curr = if b then curr lor (1 lsl i) else curr in\n if i = 7 then { i = 0; acc = Char.of_int_exn curr :: acc; curr = 0 }\n else { i = i + 1; acc; curr } )\n in\n let cs = if i = 0 then acc else Char.of_int_exn curr :: acc in\n String.of_char_list cs\n\nlet string_triples s = group3 ~default:false (string_bits s)\n","open Core_kernel\nopen Fold_lib\nopen Tuple_lib\n\nlet ( = ) = `Don't_use_polymorphic_equality\n\nmodule type Basic_intf = sig\n module Nat : Nat_intf.S\n\n type t [@@deriving eq]\n\n val order : Nat.t\n\n val one : t\n\n val zero : t\n\n val ( + ) : t -> t -> t\n\n val ( * ) : t -> t -> t\n\n val ( - ) : t -> t -> t\n\n val ( / ) : t -> t -> t\n\n val square : t -> t\nend\n\nmodule type Intf = sig\n type t [@@deriving bin_io, sexp, yojson, compare, hash]\n\n include Basic_intf with type t := t\n\n val gen : t Quickcheck.Generator.t\n\n val gen_incl : t -> t -> t Quickcheck.Generator.t\n\n val gen_uniform : t Quickcheck.Generator.t\n\n val gen_uniform_incl : t -> t -> t Quickcheck.Generator.t\n\n val random : unit -> t\n\n val negate : t -> t\n\n val inv : t -> t\n\n val parity : t -> bool\nend\n\nmodule type Sqrt_field_intf = sig\n include Intf\n\n val is_square : t -> bool\n\n val sqrt : t -> t\nend\n\nmodule type Extended_intf = sig\n include Sqrt_field_intf\n\n val ( ** ) : t -> Nat.t -> t\nend\n\nmodule type Fp_intf = sig\n include Intf\n\n include Stringable.S with type t := t\n\n include Stringable.S with type t := t\n\n val of_int : int -> t\n\n val of_bits : bool list -> t option\n\n val to_bigint : t -> Nat.t\n\n val of_bigint : Nat.t -> t\n\n val fold_bits : t -> bool Fold.t\n\n val fold : t -> bool Triple.t Fold.t\n\n val to_bits : t -> bool list\n\n val length_in_bits : int\n\n val is_square : t -> bool\n\n val sqrt : t -> t\nend\n\nmodule type Extension_intf = sig\n type base\n\n include Extended_intf\n\n val scale : t -> base -> t\n\n val of_base : base -> t\n\n val project_to_base : t -> base\n\n val to_list : t -> base list\nend\n\nmodule Extend (F : Basic_intf) = struct\n open F\n\n let ( ** ) x n =\n let k = Nat.num_bits n in\n let rec go acc i =\n if Int.(i < 0) then acc\n else\n let acc = square acc in\n let acc = if Nat.test_bit n i then acc * x else acc in\n go acc Int.(i - 1)\n in\n go one Int.(k - 1)\n\n let is_square =\n let euler = Nat.((order - of_int 1) // of_int 2) in\n fun x -> equal (x ** euler) one\n\n module Sqrt_params = struct\n let two_adicity n =\n let rec go i = if Nat.test_bit n i then i else go Int.(i + 1) in\n go 0\n\n type nonrec t =\n { two_adicity : int\n ; quadratic_non_residue_to_t : t\n ; t_minus_1_over_2 : Nat.t\n }\n\n let first f =\n let rec go i = match f i with Some x -> x | None -> go (i + one) in\n go one\n\n let create () =\n let p_minus_one = Nat.(order - of_int 1) in\n let s = two_adicity p_minus_one in\n let t = Nat.shift_right p_minus_one s in\n let quadratic_non_residue =\n first (fun i -> Option.some_if (not (is_square i)) i)\n in\n { two_adicity = s\n ; quadratic_non_residue_to_t = quadratic_non_residue ** t\n ; t_minus_1_over_2 = Nat.((t - of_int 1) // of_int 2)\n }\n\n let t = lazy (create ())\n end\n\n let rec loop ~while_ ~init f =\n if while_ init then loop ~while_ ~init:(f init) f else init\n\n let rec pow2 b n = if n > 0 then pow2 (square b) Int.(n - 1) else b\n\n let sqrt =\n let pow2_order b =\n loop\n ~while_:(fun (b2m, _) -> not (equal b2m one))\n ~init:(b, 0)\n (fun (b2m, m) -> (square b2m, Int.succ m))\n |> snd\n in\n let module Loop_params = struct\n type nonrec t = { z : t; b : t; x : t; v : int }\n end in\n let open Loop_params in\n fun a ->\n let { Sqrt_params.two_adicity = v\n ; quadratic_non_residue_to_t = z\n ; t_minus_1_over_2\n } =\n Lazy.force Sqrt_params.t\n in\n let w = a ** t_minus_1_over_2 in\n let x = a * w in\n let b = x * w in\n let { x; _ } =\n loop\n ~while_:(fun p -> not (equal p.b one))\n ~init:{ z; b; x; v }\n (fun { z; b; x; v } ->\n let m = pow2_order b in\n let w = pow2 z Int.(v - m - 1) in\n let z = square w in\n { z; b = b * z; x = x * w; v = m } )\n in\n x\nend\n\nmodule Make_fp\n (N : Nat_intf.S) (Info : sig\n val order : N.t\n end) : Fp_intf with module Nat = N and type t = private N.t = struct\n include Info\n\n module T = struct\n let zero = N.of_int 0\n\n let one = N.of_int 1\n\n let length_in_bits = N.num_bits N.(Info.order - one)\n\n module Nat = N\n open Nat\n\n let order = Info.order\n\n (* TODO version *)\n type t = N.t [@@deriving eq, sexp, yojson, compare, hash]\n\n let length_in_bytes = Int.((length_in_bits + 7) / 8)\n\n (** serialization meant to be identical to field serializations in snarky *)\n include Bin_prot.Utils.Of_minimal (struct\n type nonrec t = t\n\n (* increment if serialization changes *)\n let version = 1\n\n let bin_shape_t =\n Bin_prot.Shape.basetype\n (Bin_prot.Shape.Uuid.of_string\n (sprintf \"snarkette_field_%d_V%d\" length_in_bytes version) )\n []\n\n let __bin_read_t__ _buf ~pos_ref _vint =\n Bin_prot.Common.raise_variant_wrong_type \"Fp.t\" !pos_ref\n\n let bin_size_t _ = length_in_bytes\n\n let bin_write_t buf ~pos t =\n let bs = Bigstring.of_string (N.to_bytes t) in\n let n = Bigstring.length bs in\n Bigstring.blit ~src:bs ~dst:buf ~src_pos:0 ~dst_pos:pos ~len:n ;\n if Int.(n < length_in_bytes) then\n for i = n to Int.(length_in_bytes - 1) do\n Bigstring.set buf Int.(pos + i) '\\000'\n done ;\n Int.(pos + length_in_bytes)\n\n let bin_read_t buf ~pos_ref =\n let open Int in\n let remaining_bytes = Bigstring.length buf - !pos_ref in\n if remaining_bytes < length_in_bytes then\n failwithf \"Field.bin_read_t: Expected %d bytes, got %d\"\n length_in_bytes remaining_bytes () ;\n let t =\n N.of_bytes\n (Bigstring.to_string buf ~pos:!pos_ref ~len:length_in_bytes)\n in\n pos_ref := length_in_bytes + !pos_ref ;\n t\n end)\n\n let ( + ) x y = (x + y) % Info.order\n\n let ( - ) x y = (x - y) % Info.order\n\n let ( * ) x y = x * y % Info.order\n\n let square x = x * x\n\n let rec extended_euclidean a b =\n if equal b zero then (a, one, zero)\n else\n match extended_euclidean b (a % b) with\n | d, x, y ->\n (d, y, x - (a // b * y))\n\n let inv_no_mod x =\n let _, a, _b = extended_euclidean x Info.order in\n a\n\n let inv x = inv_no_mod x % Info.order\n\n let ( / ) x y = x * inv_no_mod y\n end\n\n include Extend (T)\n include T\n\n let of_bigint x = N.(x % Info.order)\n\n let to_bigint = Fn.id\n\n let parity t = N.test_bit (to_bigint t) 0\n\n let make_gen gen lo hi =\n let t_of_bignum_bigint n = Bigint.to_string n |> N.of_string in\n Quickcheck.Generator.map (gen lo hi) ~f:t_of_bignum_bigint\n\n (* fix zero, size - 1 bounds *)\n let make_gen_full gen =\n let size = order |> N.to_string |> Bigint.of_string in\n make_gen gen Bigint.zero Bigint.(size - one)\n\n let gen = make_gen_full Bigint.gen_incl\n\n let gen_incl lo hi =\n let bignum_bigint_of_t t = N.to_string t |> Bigint.of_string in\n make_gen Bigint.gen_incl (bignum_bigint_of_t lo) (bignum_bigint_of_t hi)\n\n let gen_uniform = make_gen_full Bigint.gen_uniform_incl\n\n let gen_uniform_incl lo hi =\n let bignum_bigint_of_t t = N.to_string t |> Bigint.of_string in\n make_gen Bigint.gen_uniform_incl (bignum_bigint_of_t lo)\n (bignum_bigint_of_t hi)\n\n let random () = Quickcheck.random_value gen_uniform\n\n let fold_bits n : bool Fold_lib.Fold.t =\n { fold =\n (fun ~init ~f ->\n let rec go acc i =\n if Int.(i = length_in_bits) then acc\n else go (f acc (N.test_bit n i)) Int.(i + 1)\n in\n go init 0 )\n }\n\n let to_bits = Fn.compose Fold_lib.Fold.to_list fold_bits\n\n let fold n = Fold_lib.Fold.group3 ~default:false (fold_bits n)\n\n let of_bits bits =\n let rec go acc i = function\n | [] ->\n acc\n | b :: bs ->\n let acc = if b then N.log_or acc (N.shift_left one i) else acc in\n go acc Int.(i + 1) bs\n in\n let r = go zero 0 bits in\n if N.( < ) r Info.order then Some r else None\n\n open N\n\n let of_int = N.of_int\n\n let of_string = N.of_string\n\n let to_string = N.to_string\n\n let negate x = N.( - ) Info.order x\n\n let%test_unit \"exp test\" = [%test_eq: t] (of_int 8) (of_int 2 ** of_int 3)\n\n let%test_unit \"pow2\" =\n let b = 7 in\n if N.(of_int Int.(7 ** 8) < order) then\n [%test_eq: t] (pow2 (of_int b) 3) (of_int Int.(7 ** 8))\n else ()\n\n let%test_unit \"sqrt agrees with integer square root on small values\" =\n let rec mem a = function\n | [] ->\n ()\n | x :: xs -> (\n try [%test_eq: t] a x with _ -> mem a xs )\n in\n let gen = Int.gen_incl 1 Int.max_value_30_bits in\n Quickcheck.test ~trials:10 gen ~f:(fun n ->\n let n = abs n in\n let n2 = Int.(n * n) in\n mem (sqrt (of_int n2)) [ of_int n; Info.order - of_int n ] )\nend\n\nmodule type Degree_2_extension_intf = sig\n type base\n\n include Extension_intf with type base := base and type t = base * base\nend\n\nmodule type Degree_3_extension_intf = sig\n type base\n\n include Extension_intf with type base := base and type t = base * base * base\nend\n\nlet ( % ) x n =\n let r = x mod n in\n if r < 0 then r + n else r\n\nlet find_wnaf (type t) (module N : Nat_intf.S with type t = t) window_size\n scalar =\n let one = N.of_int 1 in\n let first_k_bits c k =\n let k_bits = N.(shift_left one k - one) in\n N.to_int_exn (N.log_and k_bits c)\n in\n let length = N.num_bits scalar in\n let res = Array.init (length + 1) ~f:(fun _ -> 0) in\n let zero = N.of_int 0 in\n let rec go c j =\n if N.equal zero c then ()\n else\n let u, c =\n if N.test_bit c 0 then\n let u =\n let u = first_k_bits c (window_size + 1) in\n if u > 1 lsl window_size then u - (1 lsl (window_size + 1)) else u\n in\n let c = N.(c - of_int u) in\n (u, c)\n else (0, c)\n in\n res.(j) <- u ;\n go (N.shift_right c 1) (j + 1)\n in\n go scalar 0 ; res\n\nmodule Make_fp3\n (Fp : Intf) (Info : sig\n val non_residue : Fp.t\n\n val frobenius_coeffs_c1 : Fp.t array\n\n val frobenius_coeffs_c2 : Fp.t array\n end) : sig\n include Degree_3_extension_intf with type base = Fp.t and module Nat = Fp.Nat\n\n val non_residue : Fp.t\n\n val frobenius : t -> int -> t\nend = struct\n include Info\n\n type base = Fp.t\n\n let componentwise f (x1, x2, x3) (y1, y2, y3) = (f x1 y1, f x2 y2, f x3 y3)\n\n let of_base x = (x, Fp.zero, Fp.zero)\n\n module T = struct\n module Nat = Fp.Nat\n\n let order = Nat.(Fp.order * Fp.order * Fp.order)\n\n type t = Fp.t * Fp.t * Fp.t\n [@@deriving eq, bin_io, sexp, yojson, compare, hash]\n\n let ( + ) = componentwise Fp.( + )\n\n let ( - ) = componentwise Fp.( - )\n\n let ( * ) (a1, b1, c1) (a2, b2, c2) =\n let a = Fp.(a1 * a2) in\n let b = Fp.(b1 * b2) in\n let c = Fp.(c1 * c2) in\n let open Fp in\n ( a + (non_residue * (((b1 + c1) * (b2 + c2)) - b - c))\n , ((a1 + b1) * (a2 + b2)) - a - b + (non_residue * c)\n , ((a1 + c1) * (a2 + c2)) - a + b - c )\n\n let square (a, b, c) =\n let s0 = Fp.square a in\n let ab = Fp.(a * b) in\n let s1 = Fp.(ab + ab) in\n let s2 = Fp.(square (a - b + c)) in\n let bc = Fp.(b * c) in\n let s3 = Fp.(bc + bc) in\n let s4 = Fp.square c in\n let open Fp in\n (s0 + (non_residue * s3), s1 + (non_residue * s4), s1 + s2 + s3 - s0 - s4)\n\n let inv (a, b, c) =\n let open Fp in\n let t0 = square a in\n let t1 = square b in\n let t2 = square c in\n let t3 = a * b in\n let t4 = a * c in\n let t5 = b * c in\n let c0 = t0 - (non_residue * t5) in\n let c1 = (non_residue * t2) - t3 in\n let c2 = t1 - t4 in\n let t6 = (a * c0) + (non_residue * ((c * c1) + (b * c2))) |> inv in\n (t6 * c0, t6 * c1, t6 * c2)\n\n let ( / ) x y = x * inv y\n\n let one = of_base Fp.one\n\n let zero = of_base Fp.zero\n end\n\n include T\n include Extend (T)\n\n let gen = Quickcheck.Generator.tuple3 Fp.gen Fp.gen Fp.gen\n\n let gen_incl (lo1, lo2, lo3) (hi1, hi2, hi3) =\n Quickcheck.Generator.tuple3 (Fp.gen_incl lo1 hi1) (Fp.gen_incl lo2 hi2)\n (Fp.gen_incl lo3 hi3)\n\n let gen_uniform =\n Quickcheck.Generator.tuple3 Fp.gen_uniform Fp.gen_uniform Fp.gen_uniform\n\n let gen_uniform_incl (lo1, lo2, lo3) (hi1, hi2, hi3) =\n Quickcheck.Generator.tuple3\n (Fp.gen_uniform_incl lo1 hi1)\n (Fp.gen_uniform_incl lo2 hi2)\n (Fp.gen_uniform_incl lo3 hi3)\n\n let random () = Quickcheck.random_value gen_uniform\n\n let to_list (x, y, z) = [ x; y; z ]\n\n let project_to_base (x, _, _) = x\n\n let parity = Fn.compose Fp.parity project_to_base\n\n let scale (x1, x2, x3) s = Fp.(s * x1, s * x2, s * x3)\n\n let negate (x1, x2, x3) = Fp.(negate x1, negate x2, negate x3)\n\n let frobenius (c0, c1, c2) power =\n let open Fp in\n let open Info in\n let i = power mod 3 in\n (c0, frobenius_coeffs_c1.(i) * c1, frobenius_coeffs_c2.(i) * c2)\nend\n\nmodule Make_fp2\n (Fp : Intf) (Info : sig\n val non_residue : Fp.t\n end) : sig\n include Degree_2_extension_intf with type base = Fp.t and module Nat = Fp.Nat\nend = struct\n type base = Fp.t\n\n let of_base x = (x, Fp.zero)\n\n let componentwise f (x1, x2) (y1, y2) = (f x1 y1, f x2 y2)\n\n module T = struct\n type t = Fp.t * Fp.t [@@deriving eq, yojson, bin_io, sexp, compare, hash]\n\n module Nat = Fp.Nat\n\n let order = Nat.(Fp.order * Fp.order)\n\n let one = of_base Fp.one\n\n let zero = of_base Fp.zero\n\n let ( + ) = componentwise Fp.( + )\n\n let ( - ) = componentwise Fp.( - )\n\n let square (a, b) =\n let open Info in\n let ab = Fp.(a * b) in\n Fp.(((a + b) * (a + (non_residue * b))) - ab - (non_residue * ab), ab + ab)\n\n let ( * ) (a1, b1) (a2, b2) =\n let open Fp in\n let a = a1 * a2 in\n let b = b1 * b2 in\n (a + (Info.non_residue * b), ((a1 + b1) * (a2 + b2)) - a - b)\n\n let inv (a, b) =\n let open Fp in\n let t0 = square a in\n let t1 = square b in\n let t2 = t0 - (Info.non_residue * t1) in\n let t3 = inv t2 in\n let c0 = a * t3 in\n let c1 = negate (b * t3) in\n (c0, c1)\n\n let ( / ) x y = x * inv y\n end\n\n include T\n include Extend (T)\n\n let gen = Quickcheck.Generator.tuple2 Fp.gen Fp.gen\n\n let gen_incl (lo1, lo2) (hi1, hi2) =\n Quickcheck.Generator.tuple2 (Fp.gen_incl lo1 hi1) (Fp.gen_incl lo2 hi2)\n\n let gen_uniform = Quickcheck.Generator.tuple2 Fp.gen_uniform Fp.gen_uniform\n\n let gen_uniform_incl (lo1, lo2) (hi1, hi2) =\n Quickcheck.Generator.tuple2\n (Fp.gen_uniform_incl lo1 hi1)\n (Fp.gen_uniform_incl lo2 hi2)\n\n let random () = Quickcheck.random_value gen_uniform\n\n let to_list (x, y) = [ x; y ]\n\n let project_to_base (x, _) = x\n\n let parity = Fn.compose Fp.parity project_to_base\n\n let scale (x1, x2) s = Fp.(s * x1, s * x2)\n\n let negate (a, b) = Fp.(negate a, negate b)\nend\n\nmodule Make_fp6\n (N : Nat_intf.S)\n (Fp : Intf)\n (Fp2 : Degree_2_extension_intf with type base = Fp.t) (Fp3 : sig\n include Degree_3_extension_intf with type base = Fp.t\n\n val frobenius : t -> int -> t\n\n val non_residue : Fp.t\n end) (Info : sig\n val non_residue : Fp.t\n\n val frobenius_coeffs_c1 : Fp.t array\n end) : sig\n include Degree_2_extension_intf with type base = Fp3.t and module Nat = Fp.Nat\n\n val mul_by_2345 : t -> t -> t\n\n val frobenius : t -> int -> t\n\n val cyclotomic_exp : t -> N.t -> t\n\n val unitary_inverse : t -> t\nend = struct\n module T = struct\n module Nat = Fp.Nat\n\n let of_base x = (x, Fp3.zero)\n\n let componentwise f (x1, x2) (y1, y2) = (f x1 y1, f x2 y2)\n\n type t = Fp3.t * Fp3.t [@@deriving eq, yojson, bin_io, sexp, compare, hash]\n\n let order =\n let open Nat in\n let square x = x * x in\n let p = Fp.order in\n square (p * square p)\n\n let zero = of_base Fp3.zero\n\n let one = of_base Fp3.one\n\n let ( + ) = componentwise Fp3.( + )\n\n let ( - ) = componentwise Fp3.( - )\n\n let mul_by_non_residue ((c0, c1, c2) : Fp3.t) =\n Fp.(Info.non_residue * c2, c0, c1)\n\n let square (a, b) =\n let ab = Fp3.(a * b) in\n let open Fp3 in\n ( ((a + b) * (a + mul_by_non_residue b)) - ab - mul_by_non_residue ab\n , ab + ab )\n\n let ( * ) (a1, b1) (a2, b2) =\n let a = Fp3.(a1 * a2) in\n let b = Fp3.(b1 * b2) in\n let beta_b = mul_by_non_residue b in\n Fp3.(a + beta_b, ((a1 + b1) * (a2 + b2)) - a - b)\n\n let inv (a, b) =\n let t1 = Fp3.square b in\n let t0 = Fp3.(square a - mul_by_non_residue t1) in\n let new_t1 = Fp3.inv t0 in\n Fp3.(a * new_t1, negate (b * new_t1))\n\n let ( / ) x y = x * inv y\n end\n\n include T\n include Extend (T)\n\n type base = Fp3.t\n\n let gen = Quickcheck.Generator.tuple2 Fp3.gen Fp3.gen\n\n let gen_incl (lo1, lo2) (hi1, hi2) =\n Quickcheck.Generator.tuple2 (Fp3.gen_incl lo1 hi1) (Fp3.gen_incl lo2 hi2)\n\n let gen_uniform = Quickcheck.Generator.tuple2 Fp3.gen_uniform Fp3.gen_uniform\n\n let gen_uniform_incl (lo1, lo2) (hi1, hi2) =\n Quickcheck.Generator.tuple2\n (Fp3.gen_uniform_incl lo1 hi1)\n (Fp3.gen_uniform_incl lo2 hi2)\n\n let random () = Quickcheck.random_value gen_uniform\n\n let to_list (x, y) = [ x; y ]\n\n let project_to_base (x, _) = x\n\n let parity = Fn.compose Fp3.parity project_to_base\n\n let scale (x1, x2) s = Fp3.(s * x1, s * x2)\n\n let mul_by_2345 (a1, b1) (a2, b2) =\n let open Info in\n let a1_0, a1_1, a1_2 = a1 in\n let _, _, a2_2 = a2 in\n (let a2_0, a2_1, _ = a2 in\n assert (Fp.(equal a2_0 zero)) ;\n assert (Fp.(equal a2_1 zero)) ) ;\n let a =\n Fp.(a1_1 * a2_2 * non_residue, a1_2 * a2_2 * non_residue, a1_0 * a2_2)\n in\n let b = Fp3.(b1 * b2) in\n let beta_b = mul_by_non_residue b in\n Fp3.(a + beta_b, ((a1 + b2) * (a2 + b2)) - a - b)\n\n let negate (a, b) = Fp3.(negate a, negate b)\n\n let unitary_inverse (x, y) = (x, Fp3.negate y)\n\n let cyclotomic_square ((c00, c01, c02), (c10, c11, c12)) =\n let a : Fp2.t = (c00, c11) in\n let b : Fp2.t = (c10, c02) in\n let c : Fp2.t = (c01, c12) in\n let asq = Fp2.square a in\n let bsq = Fp2.square b in\n let csq = Fp2.square c in\n let a_a =\n let open Fp in\n let a_a = fst asq - fst a in\n a_a + a_a + fst asq\n in\n let a_b =\n let open Fp in\n let a_b = snd asq + snd a in\n a_b + a_b + snd asq\n in\n let b_a =\n let open Fp in\n let b_tmp = Fp3.non_residue * snd csq in\n let b_a = b_tmp + fst b in\n b_a + b_a + b_tmp\n in\n let b_b =\n let open Fp in\n let b_b = fst csq - snd b in\n b_b + b_b + fst csq\n in\n let c_a =\n let open Fp in\n let c_a = fst bsq - fst c in\n c_a + c_a + fst bsq\n in\n let c_b =\n let open Fp in\n let c_b = snd bsq + snd c in\n c_b + c_b + snd bsq\n in\n ((a_a, c_a, b_b), (b_a, a_b, c_b))\n\n let cyclotomic_exp x exponent =\n let x_inv = inv x in\n let naf = find_wnaf (module N) 1 exponent in\n let rec go found_nonzero res i =\n if i < 0 then res\n else\n let res = if found_nonzero then cyclotomic_square res else res in\n if naf.(i) <> 0 then\n let found_nonzero = true in\n let res = if naf.(i) > 0 then res * x else res * x_inv in\n go found_nonzero res Int.(i - 1)\n else go found_nonzero res Int.(i - 1)\n in\n go false one Int.(Array.length naf - 1)\n\n let frobenius (c0, c1) power =\n ( Fp3.frobenius c0 power\n , Fp3.(scale (frobenius c1 power) Info.frobenius_coeffs_c1.(power mod 6)) )\nend\n","open Core_kernel\nopen Kimchi_backend_common\nopen Kimchi_pasta_basic\nmodule Field = Fp\nmodule Curve = Vesta\n\nmodule Bigint = struct\n include Field.Bigint\n\n let of_data _ = failwith __LOC__\n\n let to_field = Field.of_bigint\n\n let of_field = Field.to_bigint\nend\n\nlet field_size : Bigint.t = Field.size\n\nmodule Verification_key = struct\n type t =\n ( Pasta_bindings.Fp.t\n , Kimchi_bindings.Protocol.SRS.Fp.t\n , Pasta_bindings.Fq.t Kimchi_types.or_infinity Kimchi_types.poly_comm )\n Kimchi_types.VerifierIndex.verifier_index\n\n let to_string _ = failwith __LOC__\n\n let of_string _ = failwith __LOC__\n\n let shifts (t : t) = t.shifts\nend\n\nmodule R1CS_constraint_system =\n Kimchi_pasta_constraint_system.Vesta_constraint_system\n\nlet lagrange srs domain_log2 : _ Kimchi_types.poly_comm array =\n let domain_size = Int.pow 2 domain_log2 in\n Array.init domain_size ~f:(fun i ->\n Kimchi_bindings.Protocol.SRS.Fp.lagrange_commitment srs domain_size i )\n\nlet with_lagrange f (vk : Verification_key.t) =\n f (lagrange vk.srs vk.domain.log_size_of_group) vk\n\nlet with_lagranges f (vks : Verification_key.t array) =\n let lgrs =\n Array.map vks ~f:(fun vk -> lagrange vk.srs vk.domain.log_size_of_group)\n in\n f lgrs vks\n\nmodule Rounds_vector = Rounds.Step_vector\nmodule Rounds = Rounds.Step\n\nmodule Keypair = Dlog_plonk_based_keypair.Make (struct\n let name = \"vesta\"\n\n module Rounds = Rounds\n module Urs = Kimchi_bindings.Protocol.SRS.Fp\n module Index = Kimchi_bindings.Protocol.Index.Fp\n module Curve = Curve\n module Poly_comm = Fp_poly_comm\n module Scalar_field = Field\n module Verifier_index = Kimchi_bindings.Protocol.VerifierIndex.Fp\n module Gate_vector = Kimchi_bindings.Protocol.Gates.Vector.Fp\n module Constraint_system = R1CS_constraint_system\nend)\n\nmodule Proof = Plonk_dlog_proof.Make (struct\n let id = \"pasta_vesta\"\n\n module Scalar_field = Field\n module Base_field = Fq\n\n module Backend = struct\n type t =\n ( Pasta_bindings.Fq.t Kimchi_types.or_infinity\n , Pasta_bindings.Fp.t )\n Kimchi_types.prover_proof\n\n include Kimchi_bindings.Protocol.Proof.Fp\n\n let batch_verify vks ts =\n Promise.run_in_thread (fun () -> batch_verify vks ts)\n\n let create_aux ~f:create (pk : Keypair.t) primary auxiliary prev_chals\n prev_comms =\n (* external values contains [1, primary..., auxiliary ] *)\n let external_values i =\n let open Field.Vector in\n if i < length primary then get primary i\n else get auxiliary (i - length primary)\n in\n\n (* compute witness *)\n let computed_witness =\n R1CS_constraint_system.compute_witness pk.cs external_values\n in\n let num_rows = Array.length computed_witness.(0) in\n\n (* convert to Rust vector *)\n let witness_cols =\n Array.init Kimchi_backend_common.Constants.columns ~f:(fun col ->\n let witness = Field.Vector.create () in\n for row = 0 to num_rows - 1 do\n Field.Vector.emplace_back witness computed_witness.(col).(row)\n done ;\n witness )\n in\n create pk.index witness_cols prev_chals prev_comms\n\n let create_async (pk : Keypair.t) primary auxiliary prev_chals prev_comms =\n create_aux pk primary auxiliary prev_chals prev_comms\n ~f:(fun pk auxiliary_input prev_challenges prev_sgs ->\n Promise.run_in_thread (fun () ->\n create pk auxiliary_input prev_challenges prev_sgs ) )\n\n let create_and_verify_async (pk : Keypair.t) primary auxiliary prev_chals\n prev_comms =\n create_aux pk primary auxiliary prev_chals prev_comms\n ~f:(fun pk auxiliary_input prev_challenges prev_sgs ->\n Promise.run_in_thread (fun () ->\n create_and_verify pk auxiliary_input prev_challenges prev_sgs ) )\n\n let create (pk : Keypair.t) primary auxiliary prev_chals prev_comms =\n create_aux pk primary auxiliary prev_chals prev_comms ~f:create\n end\n\n module Verifier_index = Kimchi_bindings.Protocol.VerifierIndex.Fp\n module Index = Keypair\n\n module Evaluations_backend = struct\n type t = Scalar_field.t Kimchi_types.proof_evaluations\n end\n\n module Opening_proof_backend = struct\n type t = (Curve.Affine.Backend.t, Scalar_field.t) Kimchi_types.opening_proof\n end\n\n module Poly_comm = Fp_poly_comm\n module Curve = Curve\nend)\n\nmodule Proving_key = struct\n type t = Keypair.t\n\n include\n Core_kernel.Binable.Of_binable\n (Core_kernel.Unit)\n (struct\n type nonrec t = t\n\n let to_binable _ = ()\n\n let of_binable () = failwith \"TODO\"\n end)\n\n let is_initialized _ = `Yes\n\n let set_constraint_system _ _ = ()\n\n let to_string _ = failwith \"TODO\"\n\n let of_string _ = failwith \"TODO\"\nend\n\nmodule Oracles = Plonk_dlog_oracles.Make (struct\n module Verifier_index = Verification_key\n module Field = Field\n module Proof = Proof\n\n module Backend = struct\n include Kimchi_bindings.Protocol.Oracles.Fp\n\n let create = with_lagrange create\n end\nend)\n","open Core_kernel\nopen Kimchi_backend_common\nopen Kimchi_pasta_basic\nmodule Field = Fq\nmodule Curve = Pallas\n\nmodule Bigint = struct\n include Field.Bigint\n\n let of_data _ = failwith __LOC__\n\n let to_field = Field.of_bigint\n\n let of_field = Field.to_bigint\nend\n\nlet field_size : Bigint.t = Field.size\n\nmodule Verification_key = struct\n type t =\n ( Pasta_bindings.Fq.t\n , Kimchi_bindings.Protocol.SRS.Fq.t\n , Pasta_bindings.Fp.t Kimchi_types.or_infinity Kimchi_types.poly_comm )\n Kimchi_types.VerifierIndex.verifier_index\n\n let to_string _ = failwith __LOC__\n\n let of_string _ = failwith __LOC__\n\n let shifts (t : t) : Field.t array = t.shifts\nend\n\n(* TODO: change name *)\nmodule R1CS_constraint_system =\n Kimchi_pasta_constraint_system.Pallas_constraint_system\n\nlet lagrange srs domain_log2 : _ Kimchi_types.poly_comm array =\n let domain_size = Int.pow 2 domain_log2 in\n Array.init domain_size ~f:(fun i ->\n Kimchi_bindings.Protocol.SRS.Fq.lagrange_commitment srs domain_size i )\n\nlet with_lagrange f (vk : Verification_key.t) =\n f (lagrange vk.srs vk.domain.log_size_of_group) vk\n\nlet with_lagranges f (vks : Verification_key.t array) =\n let lgrs =\n Array.map vks ~f:(fun vk -> lagrange vk.srs vk.domain.log_size_of_group)\n in\n f lgrs vks\n\nmodule Rounds_vector = Rounds.Wrap_vector\nmodule Rounds = Rounds.Wrap\n\nmodule Keypair = Dlog_plonk_based_keypair.Make (struct\n let name = \"pallas\"\n\n module Rounds = Rounds\n module Urs = Kimchi_bindings.Protocol.SRS.Fq\n module Index = Kimchi_bindings.Protocol.Index.Fq\n module Curve = Curve\n module Poly_comm = Fq_poly_comm\n module Scalar_field = Field\n module Verifier_index = Kimchi_bindings.Protocol.VerifierIndex.Fq\n module Gate_vector = Kimchi_bindings.Protocol.Gates.Vector.Fq\n module Constraint_system = R1CS_constraint_system\nend)\n\nmodule Proof = Plonk_dlog_proof.Make (struct\n let id = \"pasta_pallas\"\n\n module Scalar_field = Field\n module Base_field = Fp\n\n module Backend = struct\n type t =\n ( Pasta_bindings.Fp.t Kimchi_types.or_infinity\n , Pasta_bindings.Fq.t )\n Kimchi_types.prover_proof\n\n include Kimchi_bindings.Protocol.Proof.Fq\n\n let batch_verify vks ts =\n Promise.run_in_thread (fun () -> batch_verify vks ts)\n\n let create_aux ~f:create (pk : Keypair.t) primary auxiliary prev_chals\n prev_comms =\n (* external values contains [1, primary..., auxiliary ] *)\n let external_values i =\n let open Field.Vector in\n if i < length primary then get primary i\n else get auxiliary (i - length primary)\n in\n\n (* compute witness *)\n let computed_witness =\n R1CS_constraint_system.compute_witness pk.cs external_values\n in\n let num_rows = Array.length computed_witness.(0) in\n\n (* convert to Rust vector *)\n let witness_cols =\n Array.init Kimchi_backend_common.Constants.columns ~f:(fun col ->\n let witness = Field.Vector.create () in\n for row = 0 to num_rows - 1 do\n Field.Vector.emplace_back witness computed_witness.(col).(row)\n done ;\n witness )\n in\n create pk.index witness_cols prev_chals prev_comms\n\n let create_async (pk : Keypair.t) primary auxiliary prev_chals prev_comms =\n create_aux pk primary auxiliary prev_chals prev_comms\n ~f:(fun pk auxiliary_input prev_challenges prev_sgs ->\n Promise.run_in_thread (fun () ->\n create pk auxiliary_input prev_challenges prev_sgs ) )\n\n let create_and_verify_async (pk : Keypair.t) primary auxiliary prev_chals\n prev_comms =\n failwith \"not implemented\"\n (* TODO: Remove this function when vesta_based_plonk.create_and_verify_async is removed *)\n\n let create (pk : Keypair.t) primary auxiliary prev_chals prev_comms =\n create_aux pk primary auxiliary prev_chals prev_comms ~f:create\n end\n\n module Verifier_index = Kimchi_bindings.Protocol.VerifierIndex.Fq\n module Index = Keypair\n\n module Evaluations_backend = struct\n type t = Scalar_field.t Kimchi_types.proof_evaluations\n end\n\n module Opening_proof_backend = struct\n type t = (Curve.Affine.Backend.t, Scalar_field.t) Kimchi_types.opening_proof\n end\n\n module Poly_comm = Fq_poly_comm\n module Curve = Curve\nend)\n\nmodule Proving_key = struct\n type t = Keypair.t\n\n include\n Core_kernel.Binable.Of_binable\n (Core_kernel.Unit)\n (struct\n type nonrec t = t\n\n let to_binable _ = ()\n\n let of_binable () = failwith \"TODO\"\n end)\n\n let is_initialized _ = `Yes\n\n let set_constraint_system _ _ = ()\n\n let to_string _ = failwith \"TODO\"\n\n let of_string _ = failwith \"TODO\"\nend\n\nmodule Oracles = Plonk_dlog_oracles.Make (struct\n module Verifier_index = Verification_key\n module Field = Field\n module Proof = Proof\n\n module Backend = struct\n include Kimchi_bindings.Protocol.Oracles.Fq\n\n let create = with_lagrange create\n end\nend)\n","open Core_kernel\n\nmodule Make () = struct\n let digest_size_in_bits = 256\n\n let digest_size_in_bytes = digest_size_in_bits / 8\n\n module T0 = struct\n include Digestif.Make_BLAKE2B (struct\n let digest_size = digest_size_in_bytes\n end)\n\n let hash = Fn.compose String.hash to_raw_string\n\n let hash_fold_t state t = Hash.fold_string state (to_raw_string t)\n\n let compare = unsafe_compare\n\n let of_string = of_raw_string\n\n let to_string = to_raw_string\n\n let gen =\n let char_generator =\n Base_quickcheck.Generator.of_list\n [ '0'\n ; '1'\n ; '2'\n ; '3'\n ; '4'\n ; '5'\n ; '6'\n ; '7'\n ; '8'\n ; '9'\n ; 'A'\n ; 'B'\n ; 'C'\n ; 'D'\n ; 'E'\n ; 'F'\n ]\n in\n String.gen_with_length (digest_size_in_bytes * 2) char_generator\n |> Quickcheck.Generator.map ~f:of_hex\n end\n\n module T1 = struct\n include T0\n include Sexpable.Of_stringable (T0)\n end\n\n [%%versioned_binable\n module Stable = struct\n module V1 = struct\n type t = T1.t [@@deriving hash, sexp, compare, equal]\n\n let to_latest = Fn.id\n\n let to_yojson t : Yojson.Safe.t = `String (T1.to_hex t)\n\n let of_yojson (v : Yojson.Safe.t) =\n let open Ppx_deriving_yojson_runtime in\n match v with\n | `String s ->\n Option.value_map ~default:(Result.Error \"not a hex string\")\n ~f:(fun x -> Result.Ok x)\n (T1.of_hex_opt s)\n | _ ->\n Result.Error \"not a string\"\n\n module Arg = struct\n type nonrec t = t\n\n [%%define_locally T1.(to_string, of_string)]\n end\n\n include Binable.Of_stringable_without_uuid (Arg)\n end\n end]\n\n [%%define_locally Stable.Latest.(to_yojson, of_yojson)]\n\n [%%define_locally\n T1.\n ( of_raw_string\n , to_raw_string\n , digest_string\n , digest_bigstring\n , to_hex\n , of_hex\n , gen )]\n\n (* do not create bin_io serialization *)\n include Hashable.Make (T1)\n include Comparable.Make (T1)\n\n (* Little endian *)\n let bits_to_string bits =\n let n = Array.length bits in\n let rec make_byte offset acc (i : int) =\n let finished = Int.(i = 8 || offset + i >= n) in\n if finished then Char.of_int_exn acc\n else\n let acc = if bits.(offset + i) then acc lor (1 lsl i) else acc in\n make_byte offset acc (i + 1)\n in\n let len = (n + 7) / 8 in\n String.init len ~f:(fun i -> make_byte (8 * i) 0 0)\n\n let string_to_bits s =\n Array.init\n (8 * String.length s)\n ~f:(fun i ->\n let c = Char.to_int s.[i / 8] in\n let j = i mod 8 in\n Int.((c lsr j) land 1 = 1) )\nend\n\ninclude Make ()\n\nlet%test_unit \"bits_to_string\" =\n [%test_eq: string]\n (bits_to_string [| true; false |])\n (String.of_char_list [ Char.of_int_exn 1 ])\n\nlet%test_unit \"string to bits\" =\n Quickcheck.test ~trials:5 String.quickcheck_generator ~f:(fun s ->\n [%test_eq: string] s (bits_to_string (string_to_bits s)) )\n","(**************************************************************************)\n(* *)\n(* OCaml Migrate Parsetree *)\n(* *)\n(* Frédéric Bour, Facebook *)\n(* Jérémie Dimino and Leo White, Jane Street Europe *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* Alain Frisch, LexiFi *)\n(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 2018 Institut National de Recherche en Informatique et *)\n(* en Automatique (INRIA). *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nmodule Asttypes = struct\n type constant (*IF_CURRENT = Asttypes.constant *) =\n Const_int of int\n | Const_char of char\n | Const_string of string * Location.t * string option\n | Const_float of string\n | Const_int32 of int32\n | Const_int64 of int64\n | Const_nativeint of nativeint\n\n type rec_flag (*IF_CURRENT = Asttypes.rec_flag *) = Nonrecursive | Recursive\n\n type direction_flag (*IF_CURRENT = Asttypes.direction_flag *) = Upto | Downto\n\n (* Order matters, used in polymorphic comparison *)\n type private_flag (*IF_CURRENT = Asttypes.private_flag *) = Private | Public\n\n type mutable_flag (*IF_CURRENT = Asttypes.mutable_flag *) = Immutable | Mutable\n\n type virtual_flag (*IF_CURRENT = Asttypes.virtual_flag *) = Virtual | Concrete\n\n type override_flag (*IF_CURRENT = Asttypes.override_flag *) = Override | Fresh\n\n type closed_flag (*IF_CURRENT = Asttypes.closed_flag *) = Closed | Open\n\n type label = string\n\n type arg_label (*IF_CURRENT = Asttypes.arg_label *) =\n Nolabel\n | Labelled of string (* label:T -> ... *)\n | Optional of string (* ?label:T -> ... *)\n\n type 'a loc = 'a Location.loc = {\n txt : 'a;\n loc : Location.t;\n }\n\n type variance (*IF_CURRENT = Asttypes.variance *) =\n | Covariant\n | Contravariant\n | NoVariance\n\n type injectivity (*IF_CURRENT = Asttypes.injectivity *) =\n | Injective\n | NoInjectivity\nend\n\nmodule Parsetree = struct\n open Asttypes\n\n type constant (*IF_CURRENT = Parsetree.constant *) =\n Pconst_integer of string * char option\n (* 3 3l 3L 3n\n\n Suffixes [g-z][G-Z] are accepted by the parser.\n Suffixes except 'l', 'L' and 'n' are rejected by the typechecker\n *)\n | Pconst_char of char\n (* 'c' *)\n | Pconst_string of string * Location.t * string option\n (* \"constant\"\n {delim|other constant|delim}\n\n The location span the content of the string, without the delimiters.\n *)\n | Pconst_float of string * char option\n (* 3.4 2e5 1.4e-4\n\n Suffixes [g-z][G-Z] are accepted by the parser.\n Suffixes are rejected by the typechecker.\n *)\n\n type location_stack = Location.t list\n\n (** {1 Extension points} *)\n\n type attribute (*IF_CURRENT = Parsetree.attribute *) = {\n attr_name : string loc;\n attr_payload : payload;\n attr_loc : Location.t;\n }\n (* [@id ARG]\n [@@id ARG]\n\n Metadata containers passed around within the AST.\n The compiler ignores unknown attributes.\n *)\n\n and extension = string loc * payload\n (* [%id ARG]\n [%%id ARG]\n\n Sub-language placeholder -- rejected by the typechecker.\n *)\n\n and attributes = attribute list\n\n and payload (*IF_CURRENT = Parsetree.payload *) =\n | PStr of structure\n | PSig of signature (* : SIG *)\n | PTyp of core_type (* : T *)\n | PPat of pattern * expression option (* ? P or ? P when E *)\n\n (** {1 Core language} *)\n\n (* Type expressions *)\n\n and core_type (*IF_CURRENT = Parsetree.core_type *) =\n {\n ptyp_desc: core_type_desc;\n ptyp_loc: Location.t;\n ptyp_loc_stack: location_stack;\n ptyp_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and core_type_desc (*IF_CURRENT = Parsetree.core_type_desc *) =\n | Ptyp_any\n (* _ *)\n | Ptyp_var of string\n (* 'a *)\n | Ptyp_arrow of arg_label * core_type * core_type\n (* T1 -> T2 Simple\n ~l:T1 -> T2 Labelled\n ?l:T1 -> T2 Optional\n *)\n | Ptyp_tuple of core_type list\n (* T1 * ... * Tn\n\n Invariant: n >= 2\n *)\n | Ptyp_constr of Longident.t loc * core_type list\n (* tconstr\n T tconstr\n (T1, ..., Tn) tconstr\n *)\n | Ptyp_object of object_field list * closed_flag\n (* < l1:T1; ...; ln:Tn > (flag = Closed)\n < l1:T1; ...; ln:Tn; .. > (flag = Open)\n *)\n | Ptyp_class of Longident.t loc * core_type list\n (* #tconstr\n T #tconstr\n (T1, ..., Tn) #tconstr\n *)\n | Ptyp_alias of core_type * string\n (* T as 'a *)\n | Ptyp_variant of row_field list * closed_flag * label list option\n (* [ `A|`B ] (flag = Closed; labels = None)\n [> `A|`B ] (flag = Open; labels = None)\n [< `A|`B ] (flag = Closed; labels = Some [])\n [< `A|`B > `X `Y ](flag = Closed; labels = Some [\"X\";\"Y\"])\n *)\n | Ptyp_poly of string loc list * core_type\n (* 'a1 ... 'an. T\n\n Can only appear in the following context:\n\n - As the core_type of a Ppat_constraint node corresponding\n to a constraint on a let-binding: let x : 'a1 ... 'an. T\n = e ...\n\n - Under Cfk_virtual for methods (not values).\n\n - As the core_type of a Pctf_method node.\n\n - As the core_type of a Pexp_poly node.\n\n - As the pld_type field of a label_declaration.\n\n - As a core_type of a Ptyp_object node.\n *)\n\n | Ptyp_package of package_type\n (* (module S) *)\n | Ptyp_extension of extension\n (* [%id] *)\n\n and package_type = Longident.t loc * (Longident.t loc * core_type) list\n (*\n (module S)\n (module S with type t1 = T1 and ... and tn = Tn)\n *)\n\n and row_field (*IF_CURRENT = Parsetree.row_field *) = {\n prf_desc : row_field_desc;\n prf_loc : Location.t;\n prf_attributes : attributes;\n }\n\n and row_field_desc (*IF_CURRENT = Parsetree.row_field_desc *) =\n | Rtag of label loc * bool * core_type list\n (* [`A] ( true, [] )\n [`A of T] ( false, [T] )\n [`A of T1 & .. & Tn] ( false, [T1;...Tn] )\n [`A of & T1 & .. & Tn] ( true, [T1;...Tn] )\n\n - The 'bool' field is true if the tag contains a\n constant (empty) constructor.\n - '&' occurs when several types are used for the same constructor\n (see 4.2 in the manual)\n *)\n | Rinherit of core_type\n (* [ T ] *)\n\n and object_field (*IF_CURRENT = Parsetree.object_field *) = {\n pof_desc : object_field_desc;\n pof_loc : Location.t;\n pof_attributes : attributes;\n }\n\n and object_field_desc (*IF_CURRENT = Parsetree.object_field_desc *) =\n | Otag of label loc * core_type\n | Oinherit of core_type\n\n (* Patterns *)\n\n and pattern (*IF_CURRENT = Parsetree.pattern *) =\n {\n ppat_desc: pattern_desc;\n ppat_loc: Location.t;\n ppat_loc_stack: location_stack;\n ppat_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and pattern_desc (*IF_CURRENT = Parsetree.pattern_desc *) =\n | Ppat_any\n (* _ *)\n | Ppat_var of string loc\n (* x *)\n | Ppat_alias of pattern * string loc\n (* P as 'a *)\n | Ppat_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Ppat_interval of constant * constant\n (* 'a'..'z'\n\n Other forms of interval are recognized by the parser\n but rejected by the type-checker. *)\n | Ppat_tuple of pattern list\n (* (P1, ..., Pn)\n\n Invariant: n >= 2\n *)\n | Ppat_construct of Longident.t loc * pattern option\n (* C None\n C P Some P\n C (P1, ..., Pn) Some (Ppat_tuple [P1; ...; Pn])\n *)\n | Ppat_variant of label * pattern option\n (* `A (None)\n `A P (Some P)\n *)\n | Ppat_record of (Longident.t loc * pattern) list * closed_flag\n (* { l1=P1; ...; ln=Pn } (flag = Closed)\n { l1=P1; ...; ln=Pn; _} (flag = Open)\n\n Invariant: n > 0\n *)\n | Ppat_array of pattern list\n (* [| P1; ...; Pn |] *)\n | Ppat_or of pattern * pattern\n (* P1 | P2 *)\n | Ppat_constraint of pattern * core_type\n (* (P : T) *)\n | Ppat_type of Longident.t loc\n (* #tconst *)\n | Ppat_lazy of pattern\n (* lazy P *)\n | Ppat_unpack of string option loc\n (* (module P) Some \"P\"\n (module _) None\n\n Note: (module P : S) is represented as\n Ppat_constraint(Ppat_unpack, Ptyp_package)\n *)\n | Ppat_exception of pattern\n (* exception P *)\n | Ppat_extension of extension\n (* [%id] *)\n | Ppat_open of Longident.t loc * pattern\n (* M.(P) *)\n\n (* Value expressions *)\n\n and expression (*IF_CURRENT = Parsetree.expression *) =\n {\n pexp_desc: expression_desc;\n pexp_loc: Location.t;\n pexp_loc_stack: location_stack;\n pexp_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and expression_desc (*IF_CURRENT = Parsetree.expression_desc *) =\n | Pexp_ident of Longident.t loc\n (* x\n M.x\n *)\n | Pexp_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Pexp_let of rec_flag * value_binding list * expression\n (* let P1 = E1 and ... and Pn = EN in E (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in E (flag = Recursive)\n *)\n | Pexp_function of case list\n (* function P1 -> E1 | ... | Pn -> En *)\n | Pexp_fun of arg_label * expression option * pattern * expression\n (* fun P -> E1 (Simple, None)\n fun ~l:P -> E1 (Labelled l, None)\n fun ?l:P -> E1 (Optional l, None)\n fun ?l:(P = E0) -> E1 (Optional l, Some E0)\n\n Notes:\n - If E0 is provided, only Optional is allowed.\n - \"fun P1 P2 .. Pn -> E1\" is represented as nested Pexp_fun.\n - \"let f P = E\" is represented using Pexp_fun.\n *)\n | Pexp_apply of expression * (arg_label * expression) list\n (* E0 ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pexp_match of expression * case list\n (* match E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_try of expression * case list\n (* try E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_tuple of expression list\n (* (E1, ..., En)\n\n Invariant: n >= 2\n *)\n | Pexp_construct of Longident.t loc * expression option\n (* C None\n C E Some E\n C (E1, ..., En) Some (Pexp_tuple[E1;...;En])\n *)\n | Pexp_variant of label * expression option\n (* `A (None)\n `A E (Some E)\n *)\n | Pexp_record of (Longident.t loc * expression) list * expression option\n (* { l1=P1; ...; ln=Pn } (None)\n { E0 with l1=P1; ...; ln=Pn } (Some E0)\n\n Invariant: n > 0\n *)\n | Pexp_field of expression * Longident.t loc\n (* E.l *)\n | Pexp_setfield of expression * Longident.t loc * expression\n (* E1.l <- E2 *)\n | Pexp_array of expression list\n (* [| E1; ...; En |] *)\n | Pexp_ifthenelse of expression * expression * expression option\n (* if E1 then E2 else E3 *)\n | Pexp_sequence of expression * expression\n (* E1; E2 *)\n | Pexp_while of expression * expression\n (* while E1 do E2 done *)\n | Pexp_for of\n pattern * expression * expression * direction_flag * expression\n (* for i = E1 to E2 do E3 done (flag = Upto)\n for i = E1 downto E2 do E3 done (flag = Downto)\n *)\n | Pexp_constraint of expression * core_type\n (* (E : T) *)\n | Pexp_coerce of expression * core_type option * core_type\n (* (E :> T) (None, T)\n (E : T0 :> T) (Some T0, T)\n *)\n | Pexp_send of expression * label loc\n (* E # m *)\n | Pexp_new of Longident.t loc\n (* new M.c *)\n | Pexp_setinstvar of label loc * expression\n (* x <- 2 *)\n | Pexp_override of (label loc * expression) list\n (* {< x1 = E1; ...; Xn = En >} *)\n | Pexp_letmodule of string option loc * module_expr * expression\n (* let module M = ME in E *)\n | Pexp_letexception of extension_constructor * expression\n (* let exception C in E *)\n | Pexp_assert of expression\n (* assert E\n Note: \"assert false\" is treated in a special way by the\n type-checker. *)\n | Pexp_lazy of expression\n (* lazy E *)\n | Pexp_poly of expression * core_type option\n (* Used for method bodies.\n\n Can only be used as the expression under Cfk_concrete\n for methods (not values). *)\n | Pexp_object of class_structure\n (* object ... end *)\n | Pexp_newtype of string loc * expression\n (* fun (type t) -> E *)\n | Pexp_pack of module_expr\n (* (module ME)\n\n (module ME : S) is represented as\n Pexp_constraint(Pexp_pack, Ptyp_package S) *)\n | Pexp_open of open_declaration * expression\n (* M.(E)\n let open M in E\n let! open M in E *)\n | Pexp_letop of letop\n (* let* P = E in E\n let* P = E and* P = E in E *)\n | Pexp_extension of extension\n (* [%id] *)\n | Pexp_unreachable\n (* . *)\n\n and case (*IF_CURRENT = Parsetree.case *) = (* (P -> E) or (P when E0 -> E) *)\n {\n pc_lhs: pattern;\n pc_guard: expression option;\n pc_rhs: expression;\n }\n\n and letop (*IF_CURRENT = Parsetree.letop *) =\n {\n let_ : binding_op;\n ands : binding_op list;\n body : expression;\n }\n\n and binding_op (*IF_CURRENT = Parsetree.binding_op *) =\n {\n pbop_op : string loc;\n pbop_pat : pattern;\n pbop_exp : expression;\n pbop_loc : Location.t;\n }\n\n (* Value descriptions *)\n\n and value_description (*IF_CURRENT = Parsetree.value_description *) =\n {\n pval_name: string loc;\n pval_type: core_type;\n pval_prim: string list;\n pval_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pval_loc: Location.t;\n }\n\n(*\n val x: T (prim = [])\n external x: T = \"s1\" ... \"sn\" (prim = [\"s1\";...\"sn\"])\n*)\n\n (* Type declarations *)\n\n and type_declaration (*IF_CURRENT = Parsetree.type_declaration *) =\n {\n ptype_name: string loc;\n ptype_params: (core_type * (variance * injectivity)) list;\n (* ('a1,...'an) t; None represents _*)\n ptype_cstrs: (core_type * core_type * Location.t) list;\n (* ... constraint T1=T1' ... constraint Tn=Tn' *)\n ptype_kind: type_kind;\n ptype_private: private_flag; (* = private ... *)\n ptype_manifest: core_type option; (* = T *)\n ptype_attributes: attributes; (* ... [@@id1] [@@id2] *)\n ptype_loc: Location.t;\n }\n\n(*\n type t (abstract, no manifest)\n type t = T0 (abstract, manifest=T0)\n type t = C of T | ... (variant, no manifest)\n type t = T0 = C of T | ... (variant, manifest=T0)\n type t = {l: T; ...} (record, no manifest)\n type t = T0 = {l : T; ...} (record, manifest=T0)\n type t = .. (open, no manifest)\n*)\n\n and type_kind (*IF_CURRENT = Parsetree.type_kind *) =\n | Ptype_abstract\n | Ptype_variant of constructor_declaration list\n | Ptype_record of label_declaration list\n (* Invariant: non-empty list *)\n | Ptype_open\n\n and label_declaration (*IF_CURRENT = Parsetree.label_declaration *) =\n {\n pld_name: string loc;\n pld_mutable: mutable_flag;\n pld_type: core_type;\n pld_loc: Location.t;\n pld_attributes: attributes; (* l : T [@id1] [@id2] *)\n }\n\n (* { ...; l: T; ... } (mutable=Immutable)\n { ...; mutable l: T; ... } (mutable=Mutable)\n\n Note: T can be a Ptyp_poly.\n *)\n\n and constructor_declaration (*IF_CURRENT = Parsetree.constructor_declaration *) =\n {\n pcd_name: string loc;\n pcd_args: constructor_arguments;\n pcd_res: core_type option;\n pcd_loc: Location.t;\n pcd_attributes: attributes; (* C of ... [@id1] [@id2] *)\n }\n\n and constructor_arguments (*IF_CURRENT = Parsetree.constructor_arguments *) =\n | Pcstr_tuple of core_type list\n | Pcstr_record of label_declaration list\n\n(*\n | C of T1 * ... * Tn (res = None, args = Pcstr_tuple [])\n | C: T0 (res = Some T0, args = [])\n | C: T1 * ... * Tn -> T0 (res = Some T0, args = Pcstr_tuple)\n | C of {...} (res = None, args = Pcstr_record)\n | C: {...} -> T0 (res = Some T0, args = Pcstr_record)\n | C of {...} as t (res = None, args = Pcstr_record)\n*)\n\n and type_extension (*IF_CURRENT = Parsetree.type_extension *) =\n {\n ptyext_path: Longident.t loc;\n ptyext_params: (core_type * (variance * injectivity)) list;\n ptyext_constructors: extension_constructor list;\n ptyext_private: private_flag;\n ptyext_loc: Location.t;\n ptyext_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n(*\n type t += ...\n*)\n\n and extension_constructor (*IF_CURRENT = Parsetree.extension_constructor *) =\n {\n pext_name: string loc;\n pext_kind : extension_constructor_kind;\n pext_loc : Location.t;\n pext_attributes: attributes; (* C of ... [@id1] [@id2] *)\n }\n\n (* exception E *)\n and type_exception (*IF_CURRENT = Parsetree.type_exception *) =\n {\n ptyexn_constructor: extension_constructor;\n ptyexn_loc: Location.t;\n ptyexn_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and extension_constructor_kind (*IF_CURRENT = Parsetree.extension_constructor_kind *) =\n Pext_decl of constructor_arguments * core_type option\n (*\n | C of T1 * ... * Tn ([T1; ...; Tn], None)\n | C: T0 ([], Some T0)\n | C: T1 * ... * Tn -> T0 ([T1; ...; Tn], Some T0)\n *)\n | Pext_rebind of Longident.t loc\n (*\n | C = D\n *)\n\n (** {1 Class language} *)\n\n (* Type expressions for the class language *)\n\n and class_type (*IF_CURRENT = Parsetree.class_type *) =\n {\n pcty_desc: class_type_desc;\n pcty_loc: Location.t;\n pcty_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and class_type_desc (*IF_CURRENT = Parsetree.class_type_desc *) =\n | Pcty_constr of Longident.t loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcty_signature of class_signature\n (* object ... end *)\n | Pcty_arrow of arg_label * core_type * class_type\n (* T -> CT Simple\n ~l:T -> CT Labelled l\n ?l:T -> CT Optional l\n *)\n | Pcty_extension of extension\n (* [%id] *)\n | Pcty_open of open_description * class_type\n (* let open M in CT *)\n\n and class_signature (*IF_CURRENT = Parsetree.class_signature *) =\n {\n pcsig_self: core_type;\n pcsig_fields: class_type_field list;\n }\n (* object('selfpat) ... end\n object ... end (self = Ptyp_any)\n *)\n\n and class_type_field (*IF_CURRENT = Parsetree.class_type_field *) =\n {\n pctf_desc: class_type_field_desc;\n pctf_loc: Location.t;\n pctf_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and class_type_field_desc (*IF_CURRENT = Parsetree.class_type_field_desc *) =\n | Pctf_inherit of class_type\n (* inherit CT *)\n | Pctf_val of (label loc * mutable_flag * virtual_flag * core_type)\n (* val x: T *)\n | Pctf_method of (label loc * private_flag * virtual_flag * core_type)\n (* method x: T\n\n Note: T can be a Ptyp_poly.\n *)\n | Pctf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pctf_attribute of attribute\n (* [@@@id] *)\n | Pctf_extension of extension\n (* [%%id] *)\n\n and 'a class_infos (*IF_CURRENT = 'a Parsetree.class_infos *) =\n {\n pci_virt: virtual_flag;\n pci_params: (core_type * (variance * injectivity)) list;\n pci_name: string loc;\n pci_expr: 'a;\n pci_loc: Location.t;\n pci_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n (* class c = ...\n class ['a1,...,'an] c = ...\n class virtual c = ...\n\n Also used for \"class type\" declaration.\n *)\n\n and class_description = class_type class_infos\n\n and class_type_declaration = class_type class_infos\n\n (* Value expressions for the class language *)\n\n and class_expr (*IF_CURRENT = Parsetree.class_expr *) =\n {\n pcl_desc: class_expr_desc;\n pcl_loc: Location.t;\n pcl_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and class_expr_desc (*IF_CURRENT = Parsetree.class_expr_desc *) =\n | Pcl_constr of Longident.t loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcl_structure of class_structure\n (* object ... end *)\n | Pcl_fun of arg_label * expression option * pattern * class_expr\n (* fun P -> CE (Simple, None)\n fun ~l:P -> CE (Labelled l, None)\n fun ?l:P -> CE (Optional l, None)\n fun ?l:(P = E0) -> CE (Optional l, Some E0)\n *)\n | Pcl_apply of class_expr * (arg_label * expression) list\n (* CE ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pcl_let of rec_flag * value_binding list * class_expr\n (* let P1 = E1 and ... and Pn = EN in CE (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in CE (flag = Recursive)\n *)\n | Pcl_constraint of class_expr * class_type\n (* (CE : CT) *)\n | Pcl_extension of extension\n (* [%id] *)\n | Pcl_open of open_description * class_expr\n (* let open M in CE *)\n\n\n and class_structure (*IF_CURRENT = Parsetree.class_structure *) =\n {\n pcstr_self: pattern;\n pcstr_fields: class_field list;\n }\n (* object(selfpat) ... end\n object ... end (self = Ppat_any)\n *)\n\n and class_field (*IF_CURRENT = Parsetree.class_field *) =\n {\n pcf_desc: class_field_desc;\n pcf_loc: Location.t;\n pcf_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and class_field_desc (*IF_CURRENT = Parsetree.class_field_desc *) =\n | Pcf_inherit of override_flag * class_expr * string loc option\n (* inherit CE\n inherit CE as x\n inherit! CE\n inherit! CE as x\n *)\n | Pcf_val of (label loc * mutable_flag * class_field_kind)\n (* val x = E\n val virtual x: T\n *)\n | Pcf_method of (label loc * private_flag * class_field_kind)\n (* method x = E (E can be a Pexp_poly)\n method virtual x: T (T can be a Ptyp_poly)\n *)\n | Pcf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pcf_initializer of expression\n (* initializer E *)\n | Pcf_attribute of attribute\n (* [@@@id] *)\n | Pcf_extension of extension\n (* [%%id] *)\n\n and class_field_kind (*IF_CURRENT = Parsetree.class_field_kind *) =\n | Cfk_virtual of core_type\n | Cfk_concrete of override_flag * expression\n\n and class_declaration = class_expr class_infos\n\n (** {1 Module language} *)\n\n (* Type expressions for the module language *)\n\n and module_type (*IF_CURRENT = Parsetree.module_type *) =\n {\n pmty_desc: module_type_desc;\n pmty_loc: Location.t;\n pmty_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and module_type_desc (*IF_CURRENT = Parsetree.module_type_desc *) =\n | Pmty_ident of Longident.t loc\n (* S *)\n | Pmty_signature of signature\n (* sig ... end *)\n | Pmty_functor of functor_parameter * module_type\n (* functor(X : MT1) -> MT2 *)\n | Pmty_with of module_type * with_constraint list\n (* MT with ... *)\n | Pmty_typeof of module_expr\n (* module type of ME *)\n | Pmty_extension of extension\n (* [%id] *)\n | Pmty_alias of Longident.t loc\n (* (module M) *)\n\n and functor_parameter (*IF_CURRENT = Parsetree.functor_parameter *) =\n | Unit\n (* () *)\n | Named of string option loc * module_type\n (* (X : MT) Some X, MT\n (_ : MT) None, MT *)\n\n and signature = signature_item list\n\n and signature_item (*IF_CURRENT = Parsetree.signature_item *) =\n {\n psig_desc: signature_item_desc;\n psig_loc: Location.t;\n }\n\n and signature_item_desc (*IF_CURRENT = Parsetree.signature_item_desc *) =\n | Psig_value of value_description\n (*\n val x: T\n external x: T = \"s1\" ... \"sn\"\n *)\n | Psig_type of rec_flag * type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Psig_typesubst of type_declaration list\n (* type t1 := ... and ... and tn := ... *)\n | Psig_typext of type_extension\n (* type t1 += ... *)\n | Psig_exception of type_exception\n (* exception C of T *)\n | Psig_module of module_declaration\n (* module X = M\n module X : MT *)\n | Psig_modsubst of module_substitution\n (* module X := M *)\n | Psig_recmodule of module_declaration list\n (* module rec X1 : MT1 and ... and Xn : MTn *)\n | Psig_modtype of module_type_declaration\n (* module type S = MT\n module type S *)\n | Psig_open of open_description\n (* open X *)\n | Psig_include of include_description\n (* include MT *)\n | Psig_class of class_description list\n (* class c1 : ... and ... and cn : ... *)\n | Psig_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Psig_attribute of attribute\n (* [@@@id] *)\n | Psig_extension of extension * attributes\n (* [%%id] *)\n\n and module_declaration (*IF_CURRENT = Parsetree.module_declaration *) =\n {\n pmd_name: string option loc;\n pmd_type: module_type;\n pmd_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pmd_loc: Location.t;\n }\n (* S : MT *)\n\n and module_substitution (*IF_CURRENT = Parsetree.module_substitution *) =\n {\n pms_name: string loc;\n pms_manifest: Longident.t loc;\n pms_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pms_loc: Location.t;\n }\n\n and module_type_declaration (*IF_CURRENT = Parsetree.module_type_declaration *) =\n {\n pmtd_name: string loc;\n pmtd_type: module_type option;\n pmtd_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pmtd_loc: Location.t;\n }\n (* S = MT\n S (abstract module type declaration, pmtd_type = None)\n *)\n\n and 'a open_infos (*IF_CURRENT = 'a Parsetree.open_infos *) =\n {\n popen_expr: 'a;\n popen_override: override_flag;\n popen_loc: Location.t;\n popen_attributes: attributes;\n }\n (* open! X - popen_override = Override (silences the 'used identifier\n shadowing' warning)\n open X - popen_override = Fresh\n *)\n\n and open_description = Longident.t loc open_infos\n (* open M.N\n open M(N).O *)\n\n and open_declaration = module_expr open_infos\n (* open M.N\n open M(N).O\n open struct ... end *)\n\n and 'a include_infos (*IF_CURRENT = 'a Parsetree.include_infos *) =\n {\n pincl_mod: 'a;\n pincl_loc: Location.t;\n pincl_attributes: attributes;\n }\n\n and include_description = module_type include_infos\n (* include MT *)\n\n and include_declaration = module_expr include_infos\n (* include ME *)\n\n and with_constraint (*IF_CURRENT = Parsetree.with_constraint *) =\n | Pwith_type of Longident.t loc * type_declaration\n (* with type X.t = ...\n\n Note: the last component of the longident must match\n the name of the type_declaration. *)\n | Pwith_module of Longident.t loc * Longident.t loc\n (* with module X.Y = Z *)\n | Pwith_typesubst of Longident.t loc * type_declaration\n (* with type X.t := ..., same format as [Pwith_type] *)\n | Pwith_modsubst of Longident.t loc * Longident.t loc\n (* with module X.Y := Z *)\n\n (* Value expressions for the module language *)\n\n and module_expr (*IF_CURRENT = Parsetree.module_expr *) =\n {\n pmod_desc: module_expr_desc;\n pmod_loc: Location.t;\n pmod_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and module_expr_desc (*IF_CURRENT = Parsetree.module_expr_desc *) =\n | Pmod_ident of Longident.t loc\n (* X *)\n | Pmod_structure of structure\n (* struct ... end *)\n | Pmod_functor of functor_parameter * module_expr\n (* functor(X : MT1) -> ME *)\n | Pmod_apply of module_expr * module_expr\n (* ME1(ME2) *)\n | Pmod_constraint of module_expr * module_type\n (* (ME : MT) *)\n | Pmod_unpack of expression\n (* (val E) *)\n | Pmod_extension of extension\n (* [%id] *)\n\n and structure = structure_item list\n\n and structure_item (*IF_CURRENT = Parsetree.structure_item *) =\n {\n pstr_desc: structure_item_desc;\n pstr_loc: Location.t;\n }\n\n and structure_item_desc (*IF_CURRENT = Parsetree.structure_item_desc *) =\n | Pstr_eval of expression * attributes\n (* E *)\n | Pstr_value of rec_flag * value_binding list\n (* let P1 = E1 and ... and Pn = EN (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN (flag = Recursive)\n *)\n | Pstr_primitive of value_description\n (* val x: T\n external x: T = \"s1\" ... \"sn\" *)\n | Pstr_type of rec_flag * type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Pstr_typext of type_extension\n (* type t1 += ... *)\n | Pstr_exception of type_exception\n (* exception C of T\n exception C = M.X *)\n | Pstr_module of module_binding\n (* module X = ME *)\n | Pstr_recmodule of module_binding list\n (* module rec X1 = ME1 and ... and Xn = MEn *)\n | Pstr_modtype of module_type_declaration\n (* module type S = MT *)\n | Pstr_open of open_declaration\n (* open X *)\n | Pstr_class of class_declaration list\n (* class c1 = ... and ... and cn = ... *)\n | Pstr_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Pstr_include of include_declaration\n (* include ME *)\n | Pstr_attribute of attribute\n (* [@@@id] *)\n | Pstr_extension of extension * attributes\n (* [%%id] *)\n\n and value_binding (*IF_CURRENT = Parsetree.value_binding *) =\n {\n pvb_pat: pattern;\n pvb_expr: expression;\n pvb_attributes: attributes;\n pvb_loc: Location.t;\n }\n\n and module_binding (*IF_CURRENT = Parsetree.module_binding *) =\n {\n pmb_name: string option loc;\n pmb_expr: module_expr;\n pmb_attributes: attributes;\n pmb_loc: Location.t;\n }\n (* X = ME *)\n\n (** {1 Toplevel} *)\n\n (* Toplevel phrases *)\n\n type toplevel_phrase (*IF_CURRENT = Parsetree.toplevel_phrase *) =\n | Ptop_def of structure\n | Ptop_dir of toplevel_directive\n (* #use, #load ... *)\n\n and toplevel_directive (*IF_CURRENT = Parsetree.toplevel_directive *) =\n {\n pdir_name : string loc;\n pdir_arg : directive_argument option;\n pdir_loc : Location.t;\n }\n\n and directive_argument (*IF_CURRENT = Parsetree.directive_argument *) =\n {\n pdira_desc : directive_argument_desc;\n pdira_loc : Location.t;\n }\n\n and directive_argument_desc (*IF_CURRENT = Parsetree.directive_argument_desc *) =\n | Pdir_string of string\n | Pdir_int of string * char option\n | Pdir_ident of Longident.t\n | Pdir_bool of bool\nend\n\nmodule Config = struct\n let ast_impl_magic_number = \"Caml1999M029\"\n let ast_intf_magic_number = \"Caml1999N029\"\nend\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Thomas Gazagnaire, OCamlPro *)\n(* Fabrice Le Fessant, INRIA Saclay *)\n(* Hongbo Zhang, University of Pennsylvania *)\n(* *)\n(* Copyright 2007 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* Original Code from Ber-metaocaml, modified for 3.12.0 and fixed *)\n(* Printing code expressions *)\n(* Authors: Ed Pizzi, Fabrice Le Fessant *)\n(* Extensive Rewrite: Hongbo Zhang: University of Pennsylvania *)\n(* TODO more fine-grained precedence pretty-printing *)\n\nopen Ast_412\nopen Asttypes\nopen Format\nopen Location\nopen Longident\nopen Parsetree\n\nlet varify_type_constructors var_names t =\n let check_variable vl loc v =\n if List.mem v vl then\n Location.raise_errorf ~loc \"variable in scope syntax error: %s\" v\n in\n let var_names = List.map (fun v -> v.txt) var_names in\n let rec loop t =\n let desc =\n match t.ptyp_desc with\n | Ptyp_any -> Ptyp_any\n | Ptyp_var x ->\n check_variable var_names t.ptyp_loc x;\n Ptyp_var x\n | Ptyp_arrow (label, core_type, core_type') ->\n Ptyp_arrow (label, loop core_type, loop core_type')\n | Ptyp_tuple lst -> Ptyp_tuple (List.map loop lst)\n | Ptyp_constr ({ txt = Longident.Lident s }, []) when List.mem s var_names\n ->\n Ptyp_var s\n | Ptyp_constr (longident, lst) ->\n Ptyp_constr (longident, List.map loop lst)\n | Ptyp_object (lst, o) -> Ptyp_object (List.map loop_object_field lst, o)\n | Ptyp_class (longident, lst) -> Ptyp_class (longident, List.map loop lst)\n | Ptyp_alias (core_type, string) ->\n check_variable var_names t.ptyp_loc string;\n Ptyp_alias (loop core_type, string)\n | Ptyp_variant (row_field_list, flag, lbl_lst_option) ->\n Ptyp_variant\n (List.map loop_row_field row_field_list, flag, lbl_lst_option)\n | Ptyp_poly (string_lst, core_type) ->\n List.iter\n (fun v -> check_variable var_names t.ptyp_loc v.txt)\n string_lst;\n Ptyp_poly (string_lst, loop core_type)\n | Ptyp_package (longident, lst) ->\n Ptyp_package (longident, List.map (fun (n, typ) -> (n, loop typ)) lst)\n | Ptyp_extension (s, arg) -> Ptyp_extension (s, arg)\n in\n { t with ptyp_desc = desc }\n and loop_row_field field =\n let prf_desc =\n match field.prf_desc with\n | Rtag (label, flag, lst) -> Rtag (label, flag, List.map loop lst)\n | Rinherit t -> Rinherit (loop t)\n in\n { field with prf_desc }\n and loop_object_field field =\n let pof_desc =\n match field.pof_desc with\n | Otag (label, t) -> Otag (label, loop t)\n | Oinherit t -> Oinherit (loop t)\n in\n { field with pof_desc }\n in\n loop t\n\nlet prefix_symbols = [ '!'; '?'; '~' ]\n\nlet infix_symbols =\n [ '='; '<'; '>'; '@'; '^'; '|'; '&'; '+'; '-'; '*'; '/'; '$'; '%'; '#' ]\n\n(* type fixity = Infix| Prefix *)\nlet special_infix_strings =\n [ \"asr\"; \"land\"; \"lor\"; \"lsl\"; \"lsr\"; \"lxor\"; \"mod\"; \"or\"; \":=\"; \"!=\"; \"::\" ]\n\nlet letop s =\n String.length s > 3\n && s.[0] = 'l'\n && s.[1] = 'e'\n && s.[2] = 't'\n && List.mem s.[3] infix_symbols\n\nlet andop s =\n String.length s > 3\n && s.[0] = 'a'\n && s.[1] = 'n'\n && s.[2] = 'd'\n && List.mem s.[3] infix_symbols\n\n(* determines if the string is an infix string.\n checks backwards, first allowing a renaming postfix (\"_102\") which\n may have resulted from Pexp -> Texp -> Pexp translation, then checking\n if all the characters in the beginning of the string are valid infix\n characters. *)\nlet fixity_of_string = function\n | \"\" -> `Normal\n | s when List.mem s special_infix_strings -> `Infix s\n | s when List.mem s.[0] infix_symbols -> `Infix s\n | s when List.mem s.[0] prefix_symbols -> `Prefix s\n | s when s.[0] = '.' -> `Mixfix s\n | s when letop s -> `Letop s\n | s when andop s -> `Andop s\n | _ -> `Normal\n\nlet view_fixity_of_exp = function\n | { pexp_desc = Pexp_ident { txt = Lident l; _ }; pexp_attributes = [] } ->\n fixity_of_string l\n | _ -> `Normal\n\nlet is_infix = function `Infix _ -> true | _ -> false\nlet is_mixfix = function `Mixfix _ -> true | _ -> false\nlet is_kwdop = function `Letop _ | `Andop _ -> true | _ -> false\nlet first_is c str = str <> \"\" && str.[0] = c\nlet last_is c str = str <> \"\" && str.[String.length str - 1] = c\nlet first_is_in cs str = str <> \"\" && List.mem str.[0] cs\n\n(* which identifiers are in fact operators needing parentheses *)\nlet needs_parens txt =\n let fix = fixity_of_string txt in\n is_infix fix || is_mixfix fix || is_kwdop fix\n || first_is_in prefix_symbols txt\n\n(* some infixes need spaces around parens to avoid clashes with comment\n syntax *)\nlet needs_spaces txt = first_is '*' txt || last_is '*' txt\n\n(* add parentheses to binders when they are in fact infix or prefix operators *)\nlet protect_ident ppf txt =\n let format : (_, _, _) format =\n if not (needs_parens txt) then \"%s\"\n else if needs_spaces txt then \"(@;%s@;)\"\n else \"(%s)\"\n in\n fprintf ppf format txt\n\nlet protect_longident ppf print_longident longprefix txt =\n let format : (_, _, _) format =\n if not (needs_parens txt) then \"%a.%s\"\n else if needs_spaces txt then \"%a.(@;%s@;)\"\n else \"%a.(%s)\"\n in\n fprintf ppf format print_longident longprefix txt\n\ntype space_formatter = (unit, Format.formatter, unit) format\n\nlet override = function Override -> \"!\" | Fresh -> \"\"\n\n(* variance encoding: need to sync up with the [parser.mly] *)\nlet type_variance = function\n | NoVariance -> \"\"\n | Covariant -> \"+\"\n | Contravariant -> \"-\"\n\nlet type_injectivity = function NoInjectivity -> \"\" | Injective -> \"!\"\n\ntype construct =\n [ `cons of expression list\n | `list of expression list\n | `nil\n | `normal\n | `simple of Longident.t\n | `tuple ]\n\nlet view_expr x =\n match x.pexp_desc with\n | Pexp_construct ({ txt = Lident \"()\"; _ }, _) -> `tuple\n | Pexp_construct ({ txt = Lident \"[]\"; _ }, _) -> `nil\n | Pexp_construct ({ txt = Lident \"::\"; _ }, Some _) ->\n let rec loop exp acc =\n match exp with\n | {\n pexp_desc = Pexp_construct ({ txt = Lident \"[]\"; _ }, _);\n pexp_attributes = [];\n } ->\n (List.rev acc, true)\n | {\n pexp_desc =\n Pexp_construct\n ( { txt = Lident \"::\"; _ },\n Some { pexp_desc = Pexp_tuple [ e1; e2 ]; pexp_attributes = [] }\n );\n pexp_attributes = [];\n } ->\n loop e2 (e1 :: acc)\n | e -> (List.rev (e :: acc), false)\n in\n let ls, b = loop x [] in\n if b then `list ls else `cons ls\n | Pexp_construct (x, None) -> `simple x.txt\n | _ -> `normal\n\nlet is_simple_construct : construct -> bool = function\n | `nil | `tuple | `list _ | `simple _ -> true\n | `cons _ | `normal -> false\n\nlet pp = fprintf\n\ntype ctxt = { pipe : bool; semi : bool; ifthenelse : bool }\n\nlet reset_ctxt = { pipe = false; semi = false; ifthenelse = false }\nlet under_pipe ctxt = { ctxt with pipe = true }\nlet under_semi ctxt = { ctxt with semi = true }\nlet under_ifthenelse ctxt = { ctxt with ifthenelse = true }\n(*\nlet reset_semi ctxt = { ctxt with semi=false }\nlet reset_ifthenelse ctxt = { ctxt with ifthenelse=false }\nlet reset_pipe ctxt = { ctxt with pipe=false }\n*)\n\nlet list :\n 'a.\n ?sep:space_formatter ->\n ?first:space_formatter ->\n ?last:space_formatter ->\n (Format.formatter -> 'a -> unit) ->\n Format.formatter ->\n 'a list ->\n unit =\n fun ?sep ?first ?last fu f xs ->\n let first = match first with Some x -> x | None -> (\"\" : _ format6)\n and last = match last with Some x -> x | None -> (\"\" : _ format6)\n and sep = match sep with Some x -> x | None -> (\"@ \" : _ format6) in\n let aux f = function\n | [] -> ()\n | [ x ] -> fu f x\n | xs ->\n let rec loop f = function\n | [ x ] -> fu f x\n | x :: xs ->\n fu f x;\n pp f sep;\n loop f xs\n | _ -> assert false\n in\n pp f first;\n loop f xs;\n pp f last\n in\n aux f xs\n\nlet option :\n 'a.\n ?first:space_formatter ->\n ?last:space_formatter ->\n (Format.formatter -> 'a -> unit) ->\n Format.formatter ->\n 'a option ->\n unit =\n fun ?first ?last fu f a ->\n let first = match first with Some x -> x | None -> (\"\" : _ format6)\n and last = match last with Some x -> x | None -> (\"\" : _ format6) in\n match a with\n | None -> ()\n | Some x ->\n pp f first;\n fu f x;\n pp f last\n\nlet paren :\n 'a.\n ?first:space_formatter ->\n ?last:space_formatter ->\n bool ->\n (Format.formatter -> 'a -> unit) ->\n Format.formatter ->\n 'a ->\n unit =\n fun ?(first = (\"\" : _ format6)) ?(last = (\"\" : _ format6)) b fu f x ->\n if b then (\n pp f \"(\";\n pp f first;\n fu f x;\n pp f last;\n pp f \")\")\n else fu f x\n\nlet rec longident f = function\n | Lident s -> protect_ident f s\n | Ldot (y, s) -> protect_longident f longident y s\n | Lapply (y, s) -> pp f \"%a(%a)\" longident y longident s\n\nlet longident_loc f x = pp f \"%a\" longident x.txt\n\nlet constant f = function\n | Pconst_char i -> pp f \"%C\" i\n | Pconst_string (i, _, None) -> pp f \"%S\" i\n | Pconst_string (i, _, Some delim) -> pp f \"{%s|%s|%s}\" delim i delim\n | Pconst_integer (i, None) -> paren (first_is '-' i) (fun f -> pp f \"%s\") f i\n | Pconst_integer (i, Some m) ->\n paren (first_is '-' i) (fun f (i, m) -> pp f \"%s%c\" i m) f (i, m)\n | Pconst_float (i, None) -> paren (first_is '-' i) (fun f -> pp f \"%s\") f i\n | Pconst_float (i, Some m) ->\n paren (first_is '-' i) (fun f (i, m) -> pp f \"%s%c\" i m) f (i, m)\n\n(* trailing space*)\nlet mutable_flag f = function Immutable -> () | Mutable -> pp f \"mutable@;\"\nlet virtual_flag f = function Concrete -> () | Virtual -> pp f \"virtual@;\"\n\n(* trailing space added *)\nlet rec_flag f rf =\n match rf with Nonrecursive -> () | Recursive -> pp f \"rec \"\n\nlet nonrec_flag f rf =\n match rf with Nonrecursive -> pp f \"nonrec \" | Recursive -> ()\n\nlet direction_flag f = function\n | Upto -> pp f \"to@ \"\n | Downto -> pp f \"downto@ \"\n\nlet private_flag f = function Public -> () | Private -> pp f \"private@ \"\nlet iter_loc f ctxt { txt; loc = _ } = f ctxt txt\nlet constant_string f s = pp f \"%S\" s\n\nlet tyvar ppf s =\n if String.length s >= 2 && s.[1] = '\\'' then\n (* without the space, this would be parsed as\n a character literal *)\n Format.fprintf ppf \"' %s\" s\n else Format.fprintf ppf \"'%s\" s\n\nlet tyvar_loc f str = tyvar f str.txt\nlet string_quot f x = pp f \"`%s\" x\n\n(* c ['a,'b] *)\nlet rec class_params_def ctxt f = function\n | [] -> ()\n | l -> pp f \"[%a] \" (* space *) (list (type_param ctxt) ~sep:\",\") l\n\nand type_with_label ctxt f (label, c) =\n match label with\n | Nolabel -> core_type1 ctxt f c (* otherwise parenthesize *)\n | Labelled s -> pp f \"%s:%a\" s (core_type1 ctxt) c\n | Optional s -> pp f \"?%s:%a\" s (core_type1 ctxt) c\n\nand core_type ctxt f x =\n if x.ptyp_attributes <> [] then\n pp f \"((%a)%a)\" (core_type ctxt)\n { x with ptyp_attributes = [] }\n (attributes ctxt) x.ptyp_attributes\n else\n match x.ptyp_desc with\n | Ptyp_arrow (l, ct1, ct2) ->\n pp f \"@[<2>%a@;->@;%a@]\" (* FIXME remove parens later *)\n (type_with_label ctxt) (l, ct1) (core_type ctxt) ct2\n | Ptyp_alias (ct, s) ->\n pp f \"@[<2>%a@;as@;%a@]\" (core_type1 ctxt) ct tyvar s\n | Ptyp_poly ([], ct) -> core_type ctxt f ct\n | Ptyp_poly (sl, ct) ->\n pp f \"@[<2>%a%a@]\"\n (fun f l ->\n pp f \"%a\"\n (fun f l ->\n match l with\n | [] -> ()\n | _ -> pp f \"%a@;.@;\" (list tyvar_loc ~sep:\"@;\") l)\n l)\n sl (core_type ctxt) ct\n | _ -> pp f \"@[<2>%a@]\" (core_type1 ctxt) x\n\nand core_type1 ctxt f x =\n if x.ptyp_attributes <> [] then core_type ctxt f x\n else\n match x.ptyp_desc with\n | Ptyp_any -> pp f \"_\"\n | Ptyp_var s -> tyvar f s\n | Ptyp_tuple l -> pp f \"(%a)\" (list (core_type1 ctxt) ~sep:\"@;*@;\") l\n | Ptyp_constr (li, l) ->\n pp f (* \"%a%a@;\" *) \"%a%a\"\n (fun f l ->\n match l with\n | [] -> ()\n | [ x ] -> pp f \"%a@;\" (core_type1 ctxt) x\n | _ -> list ~first:\"(\" ~last:\")@;\" (core_type ctxt) ~sep:\",@;\" f l)\n l longident_loc li\n | Ptyp_variant (l, closed, low) ->\n let first_is_inherit =\n match l with\n | { Parsetree.prf_desc = Rinherit _ } :: _ -> true\n | _ -> false\n in\n let type_variant_helper f x =\n match x.prf_desc with\n | Rtag (l, _, ctl) ->\n pp f \"@[<2>%a%a@;%a@]\" (iter_loc string_quot) l\n (fun f l ->\n match l with\n | [] -> ()\n | _ -> pp f \"@;of@;%a\" (list (core_type ctxt) ~sep:\"&\") ctl)\n ctl (attributes ctxt) x.prf_attributes\n | Rinherit ct -> core_type ctxt f ct\n in\n pp f \"@[<2>[%a%a]@]\"\n (fun f l ->\n match (l, closed) with\n | [], Closed -> ()\n | [], Open -> pp f \">\" (* Cf #7200: print [>] correctly *)\n | _ ->\n pp f \"%s@;%a\"\n (match (closed, low) with\n | Closed, None -> if first_is_inherit then \" |\" else \"\"\n | Closed, Some _ -> \"<\" (* FIXME desugar the syntax sugar*)\n | Open, _ -> \">\")\n (list type_variant_helper ~sep:\"@;<1 -2>| \")\n l)\n l\n (fun f low ->\n match low with\n | Some [] | None -> ()\n | Some xs -> pp f \">@ %a\" (list string_quot) xs)\n low\n | Ptyp_object (l, o) ->\n let core_field_type f x =\n match x.pof_desc with\n | Otag (l, ct) ->\n (* Cf #7200 *)\n pp f \"@[%s: %a@ %a@ @]\" l.txt (core_type ctxt) ct\n (attributes ctxt) x.pof_attributes\n | Oinherit ct -> pp f \"@[%a@ @]\" (core_type ctxt) ct\n in\n let field_var f = function\n | Asttypes.Closed -> ()\n | Asttypes.Open -> (\n match l with [] -> pp f \"..\" | _ -> pp f \" ;..\")\n in\n pp f \"@[<@ %a%a@ > @]\"\n (list core_field_type ~sep:\";\")\n l field_var o\n (* Cf #7200 *)\n | Ptyp_class (li, l) ->\n (*FIXME*)\n pp f \"@[%a#%a@]\"\n (list (core_type ctxt) ~sep:\",\" ~first:\"(\" ~last:\")\")\n l longident_loc li\n | Ptyp_package (lid, cstrs) -> (\n let aux f (s, ct) =\n pp f \"type %a@ =@ %a\" longident_loc s (core_type ctxt) ct\n in\n match cstrs with\n | [] -> pp f \"@[(module@ %a)@]\" longident_loc lid\n | _ ->\n pp f \"@[(module@ %a@ with@ %a)@]\" longident_loc lid\n (list aux ~sep:\"@ and@ \") cstrs)\n | Ptyp_extension e -> extension ctxt f e\n | _ -> paren true (core_type ctxt) f x\n\n(********************pattern********************)\n(* be cautious when use [pattern], [pattern1] is preferred *)\nand pattern ctxt f x =\n let rec list_of_pattern acc = function\n (* only consider ((A|B)|C)*)\n | { ppat_desc = Ppat_or (p1, p2); ppat_attributes = [] } ->\n list_of_pattern (p2 :: acc) p1\n | x -> x :: acc\n in\n if x.ppat_attributes <> [] then\n pp f \"((%a)%a)\" (pattern ctxt)\n { x with ppat_attributes = [] }\n (attributes ctxt) x.ppat_attributes\n else\n match x.ppat_desc with\n | Ppat_alias (p, s) ->\n pp f \"@[<2>%a@;as@;%a@]\" (pattern ctxt) p protect_ident s.txt (* RA*)\n | Ppat_or _ ->\n (* *)\n pp f \"@[%a@]\"\n (list ~sep:\"@,|\" (pattern ctxt))\n (list_of_pattern [] x)\n | _ -> pattern1 ctxt f x\n\nand pattern1 ctxt (f : Format.formatter) (x : pattern) : unit =\n let rec pattern_list_helper f = function\n | {\n ppat_desc =\n Ppat_construct\n ( { txt = Lident \"::\"; _ },\n Some { ppat_desc = Ppat_tuple [ pat1; pat2 ]; _ } );\n ppat_attributes = [];\n } ->\n pp f \"%a::%a\" (simple_pattern ctxt) pat1 pattern_list_helper pat2 (*RA*)\n | p -> pattern1 ctxt f p\n in\n if x.ppat_attributes <> [] then pattern ctxt f x\n else\n match x.ppat_desc with\n | Ppat_variant (l, Some p) ->\n pp f \"@[<2>`%s@;%a@]\" l (simple_pattern ctxt) p\n | Ppat_construct ({ txt = Lident (\"()\" | \"[]\"); _ }, _) ->\n simple_pattern ctxt f x\n | Ppat_construct (({ txt; _ } as li), po) -> (\n if (* FIXME The third field always false *)\n txt = Lident \"::\" then pp f \"%a\" pattern_list_helper x\n else\n match po with\n | Some x -> pp f \"%a@;%a\" longident_loc li (simple_pattern ctxt) x\n | None -> pp f \"%a\" longident_loc li)\n | _ -> simple_pattern ctxt f x\n\nand simple_pattern ctxt (f : Format.formatter) (x : pattern) : unit =\n if x.ppat_attributes <> [] then pattern ctxt f x\n else\n match x.ppat_desc with\n | Ppat_construct ({ txt = Lident ((\"()\" | \"[]\") as x); _ }, _) ->\n pp f \"%s\" x\n | Ppat_any -> pp f \"_\"\n | Ppat_var { txt; _ } -> protect_ident f txt\n | Ppat_array l -> pp f \"@[<2>[|%a|]@]\" (list (pattern1 ctxt) ~sep:\";\") l\n | Ppat_unpack { txt = None } -> pp f \"(module@ _)@ \"\n | Ppat_unpack { txt = Some s } -> pp f \"(module@ %s)@ \" s\n | Ppat_type li -> pp f \"#%a\" longident_loc li\n | Ppat_record (l, closed) -> (\n let longident_x_pattern f (li, p) =\n match (li, p) with\n | ( { txt = Lident s; _ },\n { ppat_desc = Ppat_var { txt; _ }; ppat_attributes = []; _ } )\n when s = txt ->\n pp f \"@[<2>%a@]\" longident_loc li\n | _ -> pp f \"@[<2>%a@;=@;%a@]\" longident_loc li (pattern1 ctxt) p\n in\n match closed with\n | Closed ->\n pp f \"@[<2>{@;%a@;}@]\" (list longident_x_pattern ~sep:\";@;\") l\n | _ -> pp f \"@[<2>{@;%a;_}@]\" (list longident_x_pattern ~sep:\";@;\") l)\n | Ppat_tuple l ->\n pp f \"@[<1>(%a)@]\" (list ~sep:\",@;\" (pattern1 ctxt)) l (* level1*)\n | Ppat_constant c -> pp f \"%a\" constant c\n | Ppat_interval (c1, c2) -> pp f \"%a..%a\" constant c1 constant c2\n | Ppat_variant (l, None) -> pp f \"`%s\" l\n | Ppat_constraint (p, ct) ->\n pp f \"@[<2>(%a@;:@;%a)@]\" (pattern1 ctxt) p (core_type ctxt) ct\n | Ppat_lazy p -> pp f \"@[<2>(lazy@;%a)@]\" (pattern1 ctxt) p\n | Ppat_exception p -> pp f \"@[<2>exception@;%a@]\" (pattern1 ctxt) p\n | Ppat_extension e -> extension ctxt f e\n | Ppat_open (lid, p) ->\n let with_paren =\n match p.ppat_desc with\n | Ppat_array _ | Ppat_record _\n | Ppat_construct ({ txt = Lident (\"()\" | \"[]\"); _ }, _) ->\n false\n | _ -> true\n in\n pp f \"@[<2>%a.%a @]\" longident_loc lid\n (paren with_paren @@ pattern1 ctxt)\n p\n | _ -> paren true (pattern ctxt) f x\n\nand label_exp ctxt f (l, opt, p) =\n match l with\n | Nolabel ->\n (* single case pattern parens needed here *)\n pp f \"%a@ \" (simple_pattern ctxt) p\n | Optional rest -> (\n match p with\n | { ppat_desc = Ppat_var { txt; _ }; ppat_attributes = [] }\n when txt = rest -> (\n match opt with\n | Some o -> pp f \"?(%s=@;%a)@;\" rest (expression ctxt) o\n | None -> pp f \"?%s@ \" rest)\n | _ -> (\n match opt with\n | Some o ->\n pp f \"?%s:(%a=@;%a)@;\" rest (pattern1 ctxt) p (expression ctxt) o\n | None -> pp f \"?%s:%a@;\" rest (simple_pattern ctxt) p))\n | Labelled l -> (\n match p with\n | { ppat_desc = Ppat_var { txt; _ }; ppat_attributes = [] } when txt = l\n ->\n pp f \"~%s@;\" l\n | _ -> pp f \"~%s:%a@;\" l (simple_pattern ctxt) p)\n\nand sugar_expr ctxt f e =\n if e.pexp_attributes <> [] then false\n else\n match e.pexp_desc with\n | Pexp_apply\n ( { pexp_desc = Pexp_ident { txt = id; _ }; pexp_attributes = []; _ },\n args )\n when List.for_all (fun (lab, _) -> lab = Nolabel) args -> (\n let print_indexop a path_prefix assign left right print_index indices\n rem_args =\n let print_path ppf = function\n | None -> ()\n | Some m -> pp ppf \".%a\" longident m\n in\n match (assign, rem_args) with\n | false, [] ->\n pp f \"@[%a%a%s%a%s@]\" (simple_expr ctxt) a print_path path_prefix\n left\n (list ~sep:\",\" print_index)\n indices right;\n true\n | true, [ v ] ->\n pp f \"@[%a%a%s%a%s@ <-@;<1 2>%a@]\" (simple_expr ctxt) a print_path\n path_prefix left\n (list ~sep:\",\" print_index)\n indices right (simple_expr ctxt) v;\n true\n | _ -> false\n in\n match (id, List.map snd args) with\n | Lident \"!\", [ e ] ->\n pp f \"@[!%a@]\" (simple_expr ctxt) e;\n true\n | Ldot (path, ((\"get\" | \"set\") as func)), a :: other_args -> (\n let assign = func = \"set\" in\n let print = print_indexop a None assign in\n match (path, other_args) with\n | Lident \"Array\", i :: rest ->\n print \".(\" \")\" (expression ctxt) [ i ] rest\n | Lident \"String\", i :: rest ->\n print \".[\" \"]\" (expression ctxt) [ i ] rest\n | Ldot (Lident \"Bigarray\", \"Array1\"), i1 :: rest ->\n print \".{\" \"}\" (simple_expr ctxt) [ i1 ] rest\n | Ldot (Lident \"Bigarray\", \"Array2\"), i1 :: i2 :: rest ->\n print \".{\" \"}\" (simple_expr ctxt) [ i1; i2 ] rest\n | Ldot (Lident \"Bigarray\", \"Array3\"), i1 :: i2 :: i3 :: rest ->\n print \".{\" \"}\" (simple_expr ctxt) [ i1; i2; i3 ] rest\n | ( Ldot (Lident \"Bigarray\", \"Genarray\"),\n { pexp_desc = Pexp_array indexes; pexp_attributes = [] } :: rest\n ) ->\n print \".{\" \"}\" (simple_expr ctxt) indexes rest\n | _ -> false)\n | (Lident s | Ldot (_, s)), a :: i :: rest when first_is '.' s ->\n (* extract operator:\n assignment operators end with [right_bracket ^ \"<-\"],\n access operators end with [right_bracket] directly\n *)\n let assign = last_is '-' s in\n let kind =\n (* extract the right end bracket *)\n let n = String.length s in\n if assign then s.[n - 3] else s.[n - 1]\n in\n let left, right =\n match kind with\n | ')' -> ('(', \")\")\n | ']' -> ('[', \"]\")\n | '}' -> ('{', \"}\")\n | _ -> assert false\n in\n let path_prefix =\n match id with Ldot (m, _) -> Some m | _ -> None\n in\n let left = String.sub s 0 (1 + String.index s left) in\n print_indexop a path_prefix assign left right (expression ctxt)\n [ i ] rest\n | _ -> false)\n | _ -> false\n\nand expression ctxt f x =\n if x.pexp_attributes <> [] then\n pp f \"((%a)@,%a)\" (expression ctxt)\n { x with pexp_attributes = [] }\n (attributes ctxt) x.pexp_attributes\n else\n match x.pexp_desc with\n | Pexp_function _ | Pexp_fun _ | Pexp_match _ | Pexp_try _ | Pexp_sequence _\n when ctxt.pipe || ctxt.semi ->\n paren true (expression reset_ctxt) f x\n | (Pexp_ifthenelse _ | Pexp_sequence _) when ctxt.ifthenelse ->\n paren true (expression reset_ctxt) f x\n | Pexp_let _ | Pexp_letmodule _ | Pexp_open _ | Pexp_letexception _\n | Pexp_letop _\n when ctxt.semi ->\n paren true (expression reset_ctxt) f x\n | Pexp_fun (l, e0, p, e) ->\n pp f \"@[<2>fun@;%a->@;%a@]\" (label_exp ctxt) (l, e0, p)\n (expression ctxt) e\n | Pexp_function l -> pp f \"@[function%a@]\" (case_list ctxt) l\n | Pexp_match (e, l) ->\n pp f \"@[@[@[<2>match %a@]@ with@]%a@]\" (expression reset_ctxt)\n e (case_list ctxt) l\n | Pexp_try (e, l) ->\n pp f \"@[<0>@[try@ %a@]@ @[<0>with%a@]@]\"\n (* \"try@;@[<2>%a@]@\\nwith@\\n%a\"*)\n (expression reset_ctxt)\n e (case_list ctxt) l\n | Pexp_let (rf, l, e) ->\n (* pp f \"@[<2>let %a%a in@;<1 -2>%a@]\"\n (*no indentation here, a new line*) *)\n (* rec_flag rf *)\n pp f \"@[<2>%a in@;<1 -2>%a@]\" (bindings reset_ctxt) (rf, l)\n (expression ctxt) e\n | Pexp_apply (e, l) -> (\n if not (sugar_expr ctxt f x) then\n match view_fixity_of_exp e with\n | `Infix s -> (\n match l with\n | [ ((Nolabel, _) as arg1); ((Nolabel, _) as arg2) ] ->\n (* FIXME associativity label_x_expression_param *)\n pp f \"@[<2>%a@;%s@;%a@]\"\n (label_x_expression_param reset_ctxt)\n arg1 s\n (label_x_expression_param ctxt)\n arg2\n | _ ->\n pp f \"@[<2>%a %a@]\" (simple_expr ctxt) e\n (list (label_x_expression_param ctxt))\n l)\n | `Prefix s -> (\n let s =\n if\n List.mem s [ \"~+\"; \"~-\"; \"~+.\"; \"~-.\" ]\n &&\n match l with\n (* See #7200: avoid turning (~- 1) into (- 1) which is\n parsed as an int literal *)\n | [ (_, { pexp_desc = Pexp_constant _ }) ] -> false\n | _ -> true\n then String.sub s 1 (String.length s - 1)\n else s\n in\n match l with\n | [ (Nolabel, x) ] -> pp f \"@[<2>%s@;%a@]\" s (simple_expr ctxt) x\n | _ ->\n pp f \"@[<2>%a %a@]\" (simple_expr ctxt) e\n (list (label_x_expression_param ctxt))\n l)\n | _ ->\n pp f \"@[%a@]\"\n (fun f (e, l) ->\n pp f \"%a@ %a\" (expression2 ctxt) e\n (list (label_x_expression_param reset_ctxt))\n l\n (* reset here only because [function,match,try,sequence]\n are lower priority *))\n (e, l))\n | Pexp_construct (li, Some eo) when not (is_simple_construct (view_expr x))\n -> (\n (* Not efficient FIXME*)\n match view_expr x with\n | `cons ls -> list (simple_expr ctxt) f ls ~sep:\"@;::@;\"\n | `normal -> pp f \"@[<2>%a@;%a@]\" longident_loc li (simple_expr ctxt) eo\n | _ -> assert false)\n | Pexp_setfield (e1, li, e2) ->\n pp f \"@[<2>%a.%a@ <-@ %a@]\" (simple_expr ctxt) e1 longident_loc li\n (simple_expr ctxt) e2\n | Pexp_ifthenelse (e1, e2, eo) ->\n (* @;@[<2>else@ %a@]@] *)\n let fmt : (_, _, _) format =\n \"@[@[<2>if@ %a@]@;@[<2>then@ %a@]%a@]\"\n in\n let expression_under_ifthenelse = expression (under_ifthenelse ctxt) in\n pp f fmt expression_under_ifthenelse e1 expression_under_ifthenelse e2\n (fun f eo ->\n match eo with\n | Some x ->\n pp f \"@;@[<2>else@;%a@]\" (expression (under_semi ctxt)) x\n | None -> ()\n (* pp f \"()\" *))\n eo\n | Pexp_sequence _ ->\n let rec sequence_helper acc = function\n | { pexp_desc = Pexp_sequence (e1, e2); pexp_attributes = [] } ->\n sequence_helper (e1 :: acc) e2\n | v -> List.rev (v :: acc)\n in\n let lst = sequence_helper [] x in\n pp f \"@[%a@]\" (list (expression (under_semi ctxt)) ~sep:\";@;\") lst\n | Pexp_new li -> pp f \"@[new@ %a@]\" longident_loc li\n | Pexp_setinstvar (s, e) ->\n pp f \"@[%s@ <-@ %a@]\" s.txt (expression ctxt) e\n | Pexp_override l ->\n (* FIXME *)\n let string_x_expression f (s, e) =\n pp f \"@[%s@ =@ %a@]\" s.txt (expression ctxt) e\n in\n pp f \"@[{<%a>}@]\" (list string_x_expression ~sep:\";\") l\n | Pexp_letmodule (s, me, e) ->\n pp f \"@[let@ module@ %s@ =@ %a@ in@ %a@]\"\n (match s.txt with None -> \"_\" | Some s -> s)\n (module_expr reset_ctxt) me (expression ctxt) e\n | Pexp_letexception (cd, e) ->\n pp f \"@[let@ exception@ %a@ in@ %a@]\"\n (extension_constructor ctxt)\n cd (expression ctxt) e\n | Pexp_assert e -> pp f \"@[assert@ %a@]\" (simple_expr ctxt) e\n | Pexp_lazy e -> pp f \"@[lazy@ %a@]\" (simple_expr ctxt) e\n (* Pexp_poly: impossible but we should print it anyway, rather than\n assert false *)\n | Pexp_poly (e, None) -> pp f \"@[!poly!@ %a@]\" (simple_expr ctxt) e\n | Pexp_poly (e, Some ct) ->\n pp f \"@[(!poly!@ %a@ : %a)@]\" (simple_expr ctxt) e\n (core_type ctxt) ct\n | Pexp_open (o, e) ->\n pp f \"@[<2>let open%s %a in@;%a@]\"\n (override o.popen_override)\n (module_expr ctxt) o.popen_expr (expression ctxt) e\n | Pexp_variant (l, Some eo) -> pp f \"@[<2>`%s@;%a@]\" l (simple_expr ctxt) eo\n | Pexp_letop { let_; ands; body } ->\n pp f \"@[<2>@[%a@,%a@] in@;<1 -2>%a@]\" (binding_op ctxt) let_\n (list ~sep:\"@,\" (binding_op ctxt))\n ands (expression ctxt) body\n | Pexp_extension e -> extension ctxt f e\n | Pexp_unreachable -> pp f \".\"\n | _ -> expression1 ctxt f x\n\nand expression1 ctxt f x =\n if x.pexp_attributes <> [] then expression ctxt f x\n else\n match x.pexp_desc with\n | Pexp_object cs -> pp f \"%a\" (class_structure ctxt) cs\n | _ -> expression2 ctxt f x\n(* used in [Pexp_apply] *)\n\nand expression2 ctxt f x =\n if x.pexp_attributes <> [] then expression ctxt f x\n else\n match x.pexp_desc with\n | Pexp_field (e, li) ->\n pp f \"@[%a.%a@]\" (simple_expr ctxt) e longident_loc li\n | Pexp_send (e, s) -> pp f \"@[%a#%s@]\" (simple_expr ctxt) e s.txt\n | _ -> simple_expr ctxt f x\n\nand simple_expr ctxt f x =\n if x.pexp_attributes <> [] then expression ctxt f x\n else\n match x.pexp_desc with\n | Pexp_construct _ when is_simple_construct (view_expr x) -> (\n match view_expr x with\n | `nil -> pp f \"[]\"\n | `tuple -> pp f \"()\"\n | `list xs ->\n pp f \"@[[%a]@]\"\n (list (expression (under_semi ctxt)) ~sep:\";@;\")\n xs\n | `simple x -> longident f x\n | _ -> assert false)\n | Pexp_ident li -> longident_loc f li\n (* (match view_fixity_of_exp x with *)\n (* |`Normal -> longident_loc f li *)\n (* | `Prefix _ | `Infix _ -> pp f \"( %a )\" longident_loc li) *)\n | Pexp_constant c -> constant f c\n | Pexp_pack me -> pp f \"(module@;%a)\" (module_expr ctxt) me\n | Pexp_newtype (lid, e) ->\n pp f \"fun@;(type@;%s)@;->@;%a\" lid.txt (expression ctxt) e\n | Pexp_tuple l ->\n pp f \"@[(%a)@]\" (list (simple_expr ctxt) ~sep:\",@;\") l\n | Pexp_constraint (e, ct) ->\n pp f \"(%a : %a)\" (expression ctxt) e (core_type ctxt) ct\n | Pexp_coerce (e, cto1, ct) ->\n pp f \"(%a%a :> %a)\" (expression ctxt) e\n (option (core_type ctxt) ~first:\" : \" ~last:\" \")\n cto1\n (* no sep hint*) (core_type ctxt)\n ct\n | Pexp_variant (l, None) -> pp f \"`%s\" l\n | Pexp_record (l, eo) ->\n let longident_x_expression f (li, e) =\n match e with\n | { pexp_desc = Pexp_ident { txt; _ }; pexp_attributes = []; _ }\n when li.txt = txt ->\n pp f \"@[%a@]\" longident_loc li\n | _ ->\n pp f \"@[%a@;=@;%a@]\" longident_loc li (simple_expr ctxt) e\n in\n pp f \"@[@[{@;%a%a@]@;}@]\" (* \"@[{%a%a}@]\" *)\n (option ~last:\" with@;\" (simple_expr ctxt))\n eo\n (list longident_x_expression ~sep:\";@;\")\n l\n | Pexp_array l ->\n pp f \"@[<0>@[<2>[|%a|]@]@]\"\n (list (simple_expr (under_semi ctxt)) ~sep:\";\")\n l\n | Pexp_while (e1, e2) ->\n let fmt : (_, _, _) format = \"@[<2>while@;%a@;do@;%a@;done@]\" in\n pp f fmt (expression ctxt) e1 (expression ctxt) e2\n | Pexp_for (s, e1, e2, df, e3) ->\n let fmt : (_, _, _) format =\n \"@[@[@[<2>for %a =@;%a@;%a%a@;do@]@;%a@]@;done@]\"\n in\n let expression = expression ctxt in\n pp f fmt (pattern ctxt) s expression e1 direction_flag df expression e2\n expression e3\n | _ -> paren true (expression ctxt) f x\n\nand attributes ctxt f l = List.iter (attribute ctxt f) l\nand item_attributes ctxt f l = List.iter (item_attribute ctxt f) l\n\nand attribute ctxt f a =\n pp f \"@[<2>[@@%s@ %a]@]\" a.attr_name.txt (payload ctxt) a.attr_payload\n\nand item_attribute ctxt f a =\n pp f \"@[<2>[@@@@%s@ %a]@]\" a.attr_name.txt (payload ctxt) a.attr_payload\n\nand floating_attribute ctxt f a =\n pp f \"@[<2>[@@@@@@%s@ %a]@]\" a.attr_name.txt (payload ctxt) a.attr_payload\n\nand value_description ctxt f x =\n (* note: value_description has an attribute field,\n but they're already printed by the callers this method *)\n pp f \"@[%a%a@]\" (core_type ctxt) x.pval_type\n (fun f x ->\n if x.pval_prim <> [] then\n pp f \"@ =@ %a\" (list constant_string) x.pval_prim)\n x\n\nand extension ctxt f (s, e) = pp f \"@[<2>[%%%s@ %a]@]\" s.txt (payload ctxt) e\n\nand item_extension ctxt f (s, e) =\n pp f \"@[<2>[%%%%%s@ %a]@]\" s.txt (payload ctxt) e\n\nand exception_declaration ctxt f x =\n pp f \"@[exception@ %a@]%a\"\n (extension_constructor ctxt)\n x.ptyexn_constructor (item_attributes ctxt) x.ptyexn_attributes\n\nand class_type_field ctxt f x =\n match x.pctf_desc with\n | Pctf_inherit ct ->\n pp f \"@[<2>inherit@ %a@]%a\" (class_type ctxt) ct (item_attributes ctxt)\n x.pctf_attributes\n | Pctf_val (s, mf, vf, ct) ->\n pp f \"@[<2>val @ %a%a%s@ :@ %a@]%a\" mutable_flag mf virtual_flag vf s.txt\n (core_type ctxt) ct (item_attributes ctxt) x.pctf_attributes\n | Pctf_method (s, pf, vf, ct) ->\n pp f \"@[<2>method %a %a%s :@;%a@]%a\" private_flag pf virtual_flag vf s.txt\n (core_type ctxt) ct (item_attributes ctxt) x.pctf_attributes\n | Pctf_constraint (ct1, ct2) ->\n pp f \"@[<2>constraint@ %a@ =@ %a@]%a\" (core_type ctxt) ct1\n (core_type ctxt) ct2 (item_attributes ctxt) x.pctf_attributes\n | Pctf_attribute a -> floating_attribute ctxt f a\n | Pctf_extension e ->\n item_extension ctxt f e;\n item_attributes ctxt f x.pctf_attributes\n\nand class_signature ctxt f { pcsig_self = ct; pcsig_fields = l; _ } =\n pp f \"@[@[object@[<1>%a@]@ %a@]@ end@]\"\n (fun f -> function\n | { ptyp_desc = Ptyp_any; ptyp_attributes = []; _ } -> ()\n | ct -> pp f \" (%a)\" (core_type ctxt) ct)\n ct\n (list (class_type_field ctxt) ~sep:\"@;\")\n l\n\n(* call [class_signature] called by [class_signature] *)\nand class_type ctxt f x =\n match x.pcty_desc with\n | Pcty_signature cs ->\n class_signature ctxt f cs;\n attributes ctxt f x.pcty_attributes\n | Pcty_constr (li, l) ->\n pp f \"%a%a%a\"\n (fun f l ->\n match l with\n | [] -> ()\n | _ -> pp f \"[%a]@ \" (list (core_type ctxt) ~sep:\",\") l)\n l longident_loc li (attributes ctxt) x.pcty_attributes\n | Pcty_arrow (l, co, cl) ->\n pp f \"@[<2>%a@;->@;%a@]\" (* FIXME remove parens later *)\n (type_with_label ctxt) (l, co) (class_type ctxt) cl\n | Pcty_extension e ->\n extension ctxt f e;\n attributes ctxt f x.pcty_attributes\n | Pcty_open (o, e) ->\n pp f \"@[<2>let open%s %a in@;%a@]\"\n (override o.popen_override)\n longident_loc o.popen_expr (class_type ctxt) e\n\n(* [class type a = object end] *)\nand class_type_declaration_list ctxt f l =\n let class_type_declaration kwd f x =\n let { pci_params = ls; pci_name = { txt; _ }; _ } = x in\n pp f \"@[<2>%s %a%a%s@ =@ %a@]%a\" kwd virtual_flag x.pci_virt\n (class_params_def ctxt) ls txt (class_type ctxt) x.pci_expr\n (item_attributes ctxt) x.pci_attributes\n in\n match l with\n | [] -> ()\n | [ x ] -> class_type_declaration \"class type\" f x\n | x :: xs ->\n pp f \"@[%a@,%a@]\"\n (class_type_declaration \"class type\")\n x\n (list ~sep:\"@,\" (class_type_declaration \"and\"))\n xs\n\nand class_field ctxt f x =\n match x.pcf_desc with\n | Pcf_inherit (ovf, ce, so) ->\n pp f \"@[<2>inherit@ %s@ %a%a@]%a\" (override ovf) (class_expr ctxt) ce\n (fun f so ->\n match so with None -> () | Some s -> pp f \"@ as %s\" s.txt)\n so (item_attributes ctxt) x.pcf_attributes\n | Pcf_val (s, mf, Cfk_concrete (ovf, e)) ->\n pp f \"@[<2>val%s %a%s =@;%a@]%a\" (override ovf) mutable_flag mf s.txt\n (expression ctxt) e (item_attributes ctxt) x.pcf_attributes\n | Pcf_method (s, pf, Cfk_virtual ct) ->\n pp f \"@[<2>method virtual %a %s :@;%a@]%a\" private_flag pf s.txt\n (core_type ctxt) ct (item_attributes ctxt) x.pcf_attributes\n | Pcf_val (s, mf, Cfk_virtual ct) ->\n pp f \"@[<2>val virtual %a%s :@ %a@]%a\" mutable_flag mf s.txt\n (core_type ctxt) ct (item_attributes ctxt) x.pcf_attributes\n | Pcf_method (s, pf, Cfk_concrete (ovf, e)) ->\n let bind e =\n binding ctxt f\n {\n pvb_pat =\n {\n ppat_desc = Ppat_var s;\n ppat_loc = Location.none;\n ppat_loc_stack = [];\n ppat_attributes = [];\n };\n pvb_expr = e;\n pvb_attributes = [];\n pvb_loc = Location.none;\n }\n in\n pp f \"@[<2>method%s %a%a@]%a\" (override ovf) private_flag pf\n (fun f -> function\n | { pexp_desc = Pexp_poly (e, Some ct); pexp_attributes = []; _ } ->\n pp f \"%s :@;%a=@;%a\" s.txt (core_type ctxt) ct (expression ctxt) e\n | { pexp_desc = Pexp_poly (e, None); pexp_attributes = []; _ } ->\n bind e\n | _ -> bind e)\n e (item_attributes ctxt) x.pcf_attributes\n | Pcf_constraint (ct1, ct2) ->\n pp f \"@[<2>constraint %a =@;%a@]%a\" (core_type ctxt) ct1 (core_type ctxt)\n ct2 (item_attributes ctxt) x.pcf_attributes\n | Pcf_initializer e ->\n pp f \"@[<2>initializer@ %a@]%a\" (expression ctxt) e (item_attributes ctxt)\n x.pcf_attributes\n | Pcf_attribute a -> floating_attribute ctxt f a\n | Pcf_extension e ->\n item_extension ctxt f e;\n item_attributes ctxt f x.pcf_attributes\n\nand class_structure ctxt f { pcstr_self = p; pcstr_fields = l } =\n pp f \"@[@[object%a@;%a@]@;end@]\"\n (fun f p ->\n match p.ppat_desc with\n | Ppat_any -> ()\n | Ppat_constraint _ -> pp f \" %a\" (pattern ctxt) p\n | _ -> pp f \" (%a)\" (pattern ctxt) p)\n p\n (list (class_field ctxt))\n l\n\nand class_expr ctxt f x =\n if x.pcl_attributes <> [] then\n pp f \"((%a)%a)\" (class_expr ctxt)\n { x with pcl_attributes = [] }\n (attributes ctxt) x.pcl_attributes\n else\n match x.pcl_desc with\n | Pcl_structure cs -> class_structure ctxt f cs\n | Pcl_fun (l, eo, p, e) ->\n pp f \"fun@ %a@ ->@ %a\" (label_exp ctxt) (l, eo, p) (class_expr ctxt) e\n | Pcl_let (rf, l, ce) ->\n pp f \"%a@ in@ %a\" (bindings ctxt) (rf, l) (class_expr ctxt) ce\n | Pcl_apply (ce, l) ->\n pp f \"((%a)@ %a)\"\n (* Cf: #7200 *) (class_expr ctxt)\n ce\n (list (label_x_expression_param ctxt))\n l\n | Pcl_constr (li, l) ->\n pp f \"%a%a\"\n (fun f l ->\n if l <> [] then pp f \"[%a]@ \" (list (core_type ctxt) ~sep:\",\") l)\n l longident_loc li\n | Pcl_constraint (ce, ct) ->\n pp f \"(%a@ :@ %a)\" (class_expr ctxt) ce (class_type ctxt) ct\n | Pcl_extension e -> extension ctxt f e\n | Pcl_open (o, e) ->\n pp f \"@[<2>let open%s %a in@;%a@]\"\n (override o.popen_override)\n longident_loc o.popen_expr (class_expr ctxt) e\n\nand module_type ctxt f x =\n if x.pmty_attributes <> [] then\n pp f \"((%a)%a)\" (module_type ctxt)\n { x with pmty_attributes = [] }\n (attributes ctxt) x.pmty_attributes\n else\n match x.pmty_desc with\n | Pmty_functor (Unit, mt2) ->\n pp f \"@[functor () ->@ %a@]\" (module_type ctxt) mt2\n | Pmty_functor (Named (s, mt1), mt2) -> (\n match s.txt with\n | None ->\n pp f \"@[%a@ ->@ %a@]\" (module_type1 ctxt) mt1\n (module_type ctxt) mt2\n | Some name ->\n pp f \"@[functor@ (%s@ :@ %a)@ ->@ %a@]\" name\n (module_type ctxt) mt1 (module_type ctxt) mt2)\n | Pmty_with (mt, []) -> module_type ctxt f mt\n | Pmty_with (mt, l) ->\n let with_constraint f = function\n | Pwith_type (li, ({ ptype_params = ls; _ } as td)) ->\n let ls = List.map fst ls in\n pp f \"type@ %a %a =@ %a\"\n (list (core_type ctxt) ~sep:\",\" ~first:\"(\" ~last:\")\")\n ls longident_loc li (type_declaration ctxt) td\n | Pwith_module (li, li2) ->\n pp f \"module %a =@ %a\" longident_loc li longident_loc li2\n | Pwith_typesubst (li, ({ ptype_params = ls; _ } as td)) ->\n let ls = List.map fst ls in\n pp f \"type@ %a %a :=@ %a\"\n (list (core_type ctxt) ~sep:\",\" ~first:\"(\" ~last:\")\")\n ls longident_loc li (type_declaration ctxt) td\n | Pwith_modsubst (li, li2) ->\n pp f \"module %a :=@ %a\" longident_loc li longident_loc li2\n in\n pp f \"@[%a@ with@ %a@]\" (module_type1 ctxt) mt\n (list with_constraint ~sep:\"@ and@ \")\n l\n | _ -> module_type1 ctxt f x\n\nand module_type1 ctxt f x =\n if x.pmty_attributes <> [] then module_type ctxt f x\n else\n match x.pmty_desc with\n | Pmty_ident li -> pp f \"%a\" longident_loc li\n | Pmty_alias li -> pp f \"(module %a)\" longident_loc li\n | Pmty_signature s ->\n pp f \"@[@[sig@ %a@]@ end@]\" (* \"@[sig@ %a@ end@]\" *)\n (list (signature_item ctxt))\n s\n (* FIXME wrong indentation*)\n | Pmty_typeof me ->\n pp f \"@[module@ type@ of@ %a@]\" (module_expr ctxt) me\n | Pmty_extension e -> extension ctxt f e\n | _ -> paren true (module_type ctxt) f x\n\nand signature ctxt f x = list ~sep:\"@\\n\" (signature_item ctxt) f x\n\nand signature_item ctxt f x : unit =\n match x.psig_desc with\n | Psig_type (rf, l) -> type_def_list ctxt f (rf, true, l)\n | Psig_typesubst l ->\n (* Psig_typesubst is never recursive, but we specify [Recursive] here to\n avoid printing a [nonrec] flag, which would be rejected by the parser.\n *)\n type_def_list ctxt f (Recursive, false, l)\n | Psig_value vd ->\n let intro = if vd.pval_prim = [] then \"val\" else \"external\" in\n pp f \"@[<2>%s@ %a@ :@ %a@]%a\" intro protect_ident vd.pval_name.txt\n (value_description ctxt) vd (item_attributes ctxt) vd.pval_attributes\n | Psig_typext te -> type_extension ctxt f te\n | Psig_exception ed -> exception_declaration ctxt f ed\n | Psig_class l -> (\n let class_description kwd f\n ({ pci_params = ls; pci_name = { txt; _ }; _ } as x) =\n pp f \"@[<2>%s %a%a%s@;:@;%a@]%a\" kwd virtual_flag x.pci_virt\n (class_params_def ctxt) ls txt (class_type ctxt) x.pci_expr\n (item_attributes ctxt) x.pci_attributes\n in\n match l with\n | [] -> ()\n | [ x ] -> class_description \"class\" f x\n | x :: xs ->\n pp f \"@[%a@,%a@]\"\n (class_description \"class\")\n x\n (list ~sep:\"@,\" (class_description \"and\"))\n xs)\n | Psig_module\n ({\n pmd_type = { pmty_desc = Pmty_alias alias; pmty_attributes = []; _ };\n _;\n } as pmd) ->\n pp f \"@[module@ %s@ =@ %a@]%a\"\n (match pmd.pmd_name.txt with None -> \"_\" | Some s -> s)\n longident_loc alias (item_attributes ctxt) pmd.pmd_attributes\n | Psig_module pmd ->\n pp f \"@[module@ %s@ :@ %a@]%a\"\n (match pmd.pmd_name.txt with None -> \"_\" | Some s -> s)\n (module_type ctxt) pmd.pmd_type (item_attributes ctxt)\n pmd.pmd_attributes\n | Psig_modsubst pms ->\n pp f \"@[module@ %s@ :=@ %a@]%a\" pms.pms_name.txt longident_loc\n pms.pms_manifest (item_attributes ctxt) pms.pms_attributes\n | Psig_open od ->\n pp f \"@[open%s@ %a@]%a\"\n (override od.popen_override)\n longident_loc od.popen_expr (item_attributes ctxt) od.popen_attributes\n | Psig_include incl ->\n pp f \"@[include@ %a@]%a\" (module_type ctxt) incl.pincl_mod\n (item_attributes ctxt) incl.pincl_attributes\n | Psig_modtype { pmtd_name = s; pmtd_type = md; pmtd_attributes = attrs } ->\n pp f \"@[module@ type@ %s%a@]%a\" s.txt\n (fun f md ->\n match md with\n | None -> ()\n | Some mt ->\n pp_print_space f ();\n pp f \"@ =@ %a\" (module_type ctxt) mt)\n md (item_attributes ctxt) attrs\n | Psig_class_type l -> class_type_declaration_list ctxt f l\n | Psig_recmodule decls ->\n let rec string_x_module_type_list f ?(first = true) l =\n match l with\n | [] -> ()\n | pmd :: tl ->\n if not first then\n pp f \"@ @[and@ %s:@ %a@]%a\"\n (match pmd.pmd_name.txt with None -> \"_\" | Some s -> s)\n (module_type1 ctxt) pmd.pmd_type (item_attributes ctxt)\n pmd.pmd_attributes\n else\n pp f \"@[module@ rec@ %s:@ %a@]%a\"\n (match pmd.pmd_name.txt with None -> \"_\" | Some s -> s)\n (module_type1 ctxt) pmd.pmd_type (item_attributes ctxt)\n pmd.pmd_attributes;\n string_x_module_type_list f ~first:false tl\n in\n string_x_module_type_list f decls\n | Psig_attribute a -> floating_attribute ctxt f a\n | Psig_extension (e, a) ->\n item_extension ctxt f e;\n item_attributes ctxt f a\n\nand module_expr ctxt f x =\n if x.pmod_attributes <> [] then\n pp f \"((%a)%a)\" (module_expr ctxt)\n { x with pmod_attributes = [] }\n (attributes ctxt) x.pmod_attributes\n else\n match x.pmod_desc with\n | Pmod_structure s ->\n pp f \"@[struct@;@[<0>%a@]@;<1 -2>end@]\"\n (list (structure_item ctxt) ~sep:\"@\\n\")\n s\n | Pmod_constraint (me, mt) ->\n pp f \"@[(%a@ :@ %a)@]\" (module_expr ctxt) me (module_type ctxt) mt\n | Pmod_ident li -> pp f \"%a\" longident_loc li\n | Pmod_functor (Unit, me) -> pp f \"functor ()@;->@;%a\" (module_expr ctxt) me\n | Pmod_functor (Named (s, mt), me) ->\n pp f \"functor@ (%s@ :@ %a)@;->@;%a\"\n (match s.txt with None -> \"_\" | Some s -> s)\n (module_type ctxt) mt (module_expr ctxt) me\n | Pmod_apply (me1, me2) ->\n pp f \"(%a)(%a)\" (module_expr ctxt) me1 (module_expr ctxt) me2\n (* Cf: #7200 *)\n | Pmod_unpack e -> pp f \"(val@ %a)\" (expression ctxt) e\n | Pmod_extension e -> extension ctxt f e\n\nand structure ctxt f x = list ~sep:\"@\\n\" (structure_item ctxt) f x\n\nand payload ctxt f = function\n | PStr [ { pstr_desc = Pstr_eval (e, attrs) } ] ->\n pp f \"@[<2>%a@]%a\" (expression ctxt) e (item_attributes ctxt) attrs\n | PStr x -> structure ctxt f x\n | PTyp x ->\n pp f \":@ \";\n core_type ctxt f x\n | PSig x ->\n pp f \":@ \";\n signature ctxt f x\n | PPat (x, None) ->\n pp f \"?@ \";\n pattern ctxt f x\n | PPat (x, Some e) ->\n pp f \"?@ \";\n pattern ctxt f x;\n pp f \" when \";\n expression ctxt f e\n\n(* transform [f = fun g h -> ..] to [f g h = ... ] could be improved *)\nand binding ctxt f { pvb_pat = p; pvb_expr = x; _ } =\n (* .pvb_attributes have already been printed by the caller, #bindings *)\n let rec pp_print_pexp_function f x =\n if x.pexp_attributes <> [] then pp f \"=@;%a\" (expression ctxt) x\n else\n match x.pexp_desc with\n | Pexp_fun (label, eo, p, e) ->\n if label = Nolabel then\n pp f \"%a@ %a\" (simple_pattern ctxt) p pp_print_pexp_function e\n else\n pp f \"%a@ %a\" (label_exp ctxt) (label, eo, p) pp_print_pexp_function\n e\n | Pexp_newtype (str, e) ->\n pp f \"(type@ %s)@ %a\" str.txt pp_print_pexp_function e\n | _ -> pp f \"=@;%a\" (expression ctxt) x\n in\n let tyvars_str tyvars = List.map (fun v -> v.txt) tyvars in\n let is_desugared_gadt p e =\n let gadt_pattern =\n match p with\n | {\n ppat_desc =\n Ppat_constraint\n ( ({ ppat_desc = Ppat_var _ } as pat),\n { ptyp_desc = Ptyp_poly (args_tyvars, rt) } );\n ppat_attributes = [];\n } ->\n Some (pat, args_tyvars, rt)\n | _ -> None\n in\n let rec gadt_exp tyvars e =\n match e with\n | { pexp_desc = Pexp_newtype (tyvar, e); pexp_attributes = [] } ->\n gadt_exp (tyvar :: tyvars) e\n | { pexp_desc = Pexp_constraint (e, ct); pexp_attributes = [] } ->\n Some (List.rev tyvars, e, ct)\n | _ -> None\n in\n let gadt_exp = gadt_exp [] e in\n match (gadt_pattern, gadt_exp) with\n | Some (p, pt_tyvars, pt_ct), Some (e_tyvars, e, e_ct)\n when tyvars_str pt_tyvars = tyvars_str e_tyvars ->\n let ety = varify_type_constructors e_tyvars e_ct in\n if ety = pt_ct then Some (p, pt_tyvars, e_ct, e) else None\n | _ -> None\n in\n if x.pexp_attributes <> [] then\n match p with\n | {\n ppat_desc =\n Ppat_constraint\n ( ({ ppat_desc = Ppat_var _; _ } as pat),\n ({ ptyp_desc = Ptyp_poly _; _ } as typ) );\n ppat_attributes = [];\n _;\n } ->\n pp f \"%a@;: %a@;=@;%a\" (simple_pattern ctxt) pat (core_type ctxt) typ\n (expression ctxt) x\n | _ -> pp f \"%a@;=@;%a\" (pattern ctxt) p (expression ctxt) x\n else\n match is_desugared_gadt p x with\n | Some (p, [], ct, e) ->\n pp f \"%a@;: %a@;=@;%a\" (simple_pattern ctxt) p (core_type ctxt) ct\n (expression ctxt) e\n | Some (p, tyvars, ct, e) ->\n pp f \"%a@;: type@;%a.@;%a@;=@;%a\" (simple_pattern ctxt) p\n (list pp_print_string ~sep:\"@;\")\n (tyvars_str tyvars) (core_type ctxt) ct (expression ctxt) e\n | None -> (\n match p with\n | { ppat_desc = Ppat_constraint (p, ty); ppat_attributes = [] } -> (\n (* special case for the first*)\n match ty with\n | { ptyp_desc = Ptyp_poly _; ptyp_attributes = [] } ->\n pp f \"%a@;:@;%a@;=@;%a\" (simple_pattern ctxt) p (core_type ctxt)\n ty (expression ctxt) x\n | _ ->\n pp f \"(%a@;:@;%a)@;=@;%a\" (simple_pattern ctxt) p\n (core_type ctxt) ty (expression ctxt) x)\n | { ppat_desc = Ppat_var _; ppat_attributes = [] } ->\n pp f \"%a@ %a\" (simple_pattern ctxt) p pp_print_pexp_function x\n | _ -> pp f \"%a@;=@;%a\" (pattern ctxt) p (expression ctxt) x)\n\n(* [in] is not printed *)\nand bindings ctxt f (rf, l) =\n let binding kwd rf f x =\n pp f \"@[<2>%s %a%a@]%a\" kwd rec_flag rf (binding ctxt) x\n (item_attributes ctxt) x.pvb_attributes\n in\n match l with\n | [] -> ()\n | [ x ] -> binding \"let\" rf f x\n | x :: xs ->\n pp f \"@[%a@,%a@]\" (binding \"let\" rf) x\n (list ~sep:\"@,\" (binding \"and\" Nonrecursive))\n xs\n\nand binding_op ctxt f x =\n pp f \"@[<2>%s %a@;=@;%a@]\" x.pbop_op.txt (pattern ctxt) x.pbop_pat\n (expression ctxt) x.pbop_exp\n\nand structure_item ctxt f x =\n match x.pstr_desc with\n | Pstr_eval (e, attrs) ->\n pp f \"@[;;%a@]%a\" (expression ctxt) e (item_attributes ctxt) attrs\n | Pstr_type (_, []) -> assert false\n | Pstr_type (rf, l) -> type_def_list ctxt f (rf, true, l)\n | Pstr_value (rf, l) ->\n (* pp f \"@[let %a%a@]\" rec_flag rf bindings l *)\n pp f \"@[<2>%a@]\" (bindings ctxt) (rf, l)\n | Pstr_typext te -> type_extension ctxt f te\n | Pstr_exception ed -> exception_declaration ctxt f ed\n | Pstr_module x ->\n let rec module_helper = function\n | { pmod_desc = Pmod_functor (arg_opt, me'); pmod_attributes = [] } ->\n (match arg_opt with\n | Unit -> pp f \"()\"\n | Named (s, mt) ->\n pp f \"(%s:%a)\"\n (match s.txt with None -> \"_\" | Some s -> s)\n (module_type ctxt) mt);\n module_helper me'\n | me -> me\n in\n pp f \"@[module %s%a@]%a\"\n (match x.pmb_name.txt with None -> \"_\" | Some s -> s)\n (fun f me ->\n let me = module_helper me in\n match me with\n | {\n pmod_desc =\n Pmod_constraint\n (me', ({ pmty_desc = Pmty_ident _ | Pmty_signature _; _ } as mt));\n pmod_attributes = [];\n } ->\n pp f \" :@;%a@;=@;%a@;\" (module_type ctxt) mt (module_expr ctxt)\n me'\n | _ -> pp f \" =@ %a\" (module_expr ctxt) me)\n x.pmb_expr (item_attributes ctxt) x.pmb_attributes\n | Pstr_open od ->\n pp f \"@[<2>open%s@;%a@]%a\"\n (override od.popen_override)\n (module_expr ctxt) od.popen_expr (item_attributes ctxt)\n od.popen_attributes\n | Pstr_modtype { pmtd_name = s; pmtd_type = md; pmtd_attributes = attrs } ->\n pp f \"@[module@ type@ %s%a@]%a\" s.txt\n (fun f md ->\n match md with\n | None -> ()\n | Some mt ->\n pp_print_space f ();\n pp f \"@ =@ %a\" (module_type ctxt) mt)\n md (item_attributes ctxt) attrs\n | Pstr_class l -> (\n let extract_class_args cl =\n let rec loop acc = function\n | { pcl_desc = Pcl_fun (l, eo, p, cl'); pcl_attributes = [] } ->\n loop ((l, eo, p) :: acc) cl'\n | cl -> (List.rev acc, cl)\n in\n let args, cl = loop [] cl in\n let constr, cl =\n match cl with\n | { pcl_desc = Pcl_constraint (cl', ct); pcl_attributes = [] } ->\n (Some ct, cl')\n | _ -> (None, cl)\n in\n (args, constr, cl)\n in\n let class_constraint f ct = pp f \": @[%a@] \" (class_type ctxt) ct in\n let class_declaration kwd f\n ({ pci_params = ls; pci_name = { txt; _ }; _ } as x) =\n let args, constr, cl = extract_class_args x.pci_expr in\n pp f \"@[<2>%s %a%a%s %a%a=@;%a@]%a\" kwd virtual_flag x.pci_virt\n (class_params_def ctxt) ls txt\n (list (label_exp ctxt))\n args (option class_constraint) constr (class_expr ctxt) cl\n (item_attributes ctxt) x.pci_attributes\n in\n match l with\n | [] -> ()\n | [ x ] -> class_declaration \"class\" f x\n | x :: xs ->\n pp f \"@[%a@,%a@]\"\n (class_declaration \"class\")\n x\n (list ~sep:\"@,\" (class_declaration \"and\"))\n xs)\n | Pstr_class_type l -> class_type_declaration_list ctxt f l\n | Pstr_primitive vd ->\n pp f \"@[external@ %a@ :@ %a@]%a\" protect_ident vd.pval_name.txt\n (value_description ctxt) vd (item_attributes ctxt) vd.pval_attributes\n | Pstr_include incl ->\n pp f \"@[include@ %a@]%a\" (module_expr ctxt) incl.pincl_mod\n (item_attributes ctxt) incl.pincl_attributes\n | Pstr_recmodule decls -> (\n (* 3.07 *)\n let aux f = function\n | { pmb_expr = { pmod_desc = Pmod_constraint (expr, typ) } } as pmb ->\n pp f \"@[@ and@ %s:%a@ =@ %a@]%a\"\n (match pmb.pmb_name.txt with None -> \"_\" | Some s -> s)\n (module_type ctxt) typ (module_expr ctxt) expr\n (item_attributes ctxt) pmb.pmb_attributes\n | pmb ->\n pp f \"@[@ and@ %s@ =@ %a@]%a\"\n (match pmb.pmb_name.txt with None -> \"_\" | Some s -> s)\n (module_expr ctxt) pmb.pmb_expr (item_attributes ctxt)\n pmb.pmb_attributes\n in\n match decls with\n | ({ pmb_expr = { pmod_desc = Pmod_constraint (expr, typ) } } as pmb)\n :: l2 ->\n pp f \"@[@[module@ rec@ %s:%a@ =@ %a@]%a@ %a@]\"\n (match pmb.pmb_name.txt with None -> \"_\" | Some s -> s)\n (module_type ctxt) typ (module_expr ctxt) expr\n (item_attributes ctxt) pmb.pmb_attributes\n (fun f l2 -> List.iter (aux f) l2)\n l2\n | pmb :: l2 ->\n pp f \"@[@[module@ rec@ %s@ =@ %a@]%a@ %a@]\"\n (match pmb.pmb_name.txt with None -> \"_\" | Some s -> s)\n (module_expr ctxt) pmb.pmb_expr (item_attributes ctxt)\n pmb.pmb_attributes\n (fun f l2 -> List.iter (aux f) l2)\n l2\n | _ -> assert false)\n | Pstr_attribute a -> floating_attribute ctxt f a\n | Pstr_extension (e, a) ->\n item_extension ctxt f e;\n item_attributes ctxt f a\n\nand type_param ctxt f (ct, (a, b)) =\n pp f \"%s%s%a\" (type_variance a) (type_injectivity b) (core_type ctxt) ct\n\nand type_params ctxt f = function\n | [] -> ()\n | l -> pp f \"%a \" (list (type_param ctxt) ~first:\"(\" ~last:\")\" ~sep:\",@;\") l\n\nand type_def_list ctxt f (rf, exported, l) =\n let type_decl kwd rf f x =\n let eq =\n if x.ptype_kind = Ptype_abstract && x.ptype_manifest = None then \"\"\n else if exported then \" =\"\n else \" :=\"\n in\n pp f \"@[<2>%s %a%a%s%s%a@]%a\" kwd nonrec_flag rf (type_params ctxt)\n x.ptype_params x.ptype_name.txt eq (type_declaration ctxt) x\n (item_attributes ctxt) x.ptype_attributes\n in\n match l with\n | [] -> assert false\n | [ x ] -> type_decl \"type\" rf f x\n | x :: xs ->\n pp f \"@[%a@,%a@]\" (type_decl \"type\" rf) x\n (list ~sep:\"@,\" (type_decl \"and\" Recursive))\n xs\n\nand record_declaration ctxt f lbls =\n let type_record_field f pld =\n pp f \"@[<2>%a%s:@;%a@;%a@]\" mutable_flag pld.pld_mutable pld.pld_name.txt\n (core_type ctxt) pld.pld_type (attributes ctxt) pld.pld_attributes\n in\n pp f \"{@\\n%a}\" (list type_record_field ~sep:\";@\\n\") lbls\n\nand type_declaration ctxt f x =\n (* type_declaration has an attribute field,\n but it's been printed by the caller of this method *)\n let priv f =\n match x.ptype_private with Public -> () | Private -> pp f \"@;private\"\n in\n let manifest f =\n match x.ptype_manifest with\n | None -> ()\n | Some y ->\n if x.ptype_kind = Ptype_abstract then\n pp f \"%t@;%a\" priv (core_type ctxt) y\n else pp f \"@;%a\" (core_type ctxt) y\n in\n let constructor_declaration f pcd =\n pp f \"|@;\";\n constructor_declaration ctxt f\n (pcd.pcd_name.txt, pcd.pcd_args, pcd.pcd_res, pcd.pcd_attributes)\n in\n let repr f =\n let intro f = if x.ptype_manifest = None then () else pp f \"@;=\" in\n match x.ptype_kind with\n | Ptype_variant xs ->\n let variants fmt xs =\n if xs = [] then pp fmt \" |\"\n else pp fmt \"@\\n%a\" (list ~sep:\"@\\n\" constructor_declaration) xs\n in\n pp f \"%t%t%a\" intro priv variants xs\n | Ptype_abstract -> ()\n | Ptype_record l -> pp f \"%t%t@;%a\" intro priv (record_declaration ctxt) l\n | Ptype_open -> pp f \"%t%t@;..\" intro priv\n in\n let constraints f =\n List.iter\n (fun (ct1, ct2, _) ->\n pp f \"@[@ constraint@ %a@ =@ %a@]\" (core_type ctxt) ct1\n (core_type ctxt) ct2)\n x.ptype_cstrs\n in\n pp f \"%t%t%t\" manifest repr constraints\n\nand type_extension ctxt f x =\n let extension_constructor f x =\n pp f \"@\\n|@;%a\" (extension_constructor ctxt) x\n in\n pp f \"@[<2>type %a%a += %a@ %a@]%a\"\n (fun f -> function\n | [] -> ()\n | l ->\n pp f \"%a@;\" (list (type_param ctxt) ~first:\"(\" ~last:\")\" ~sep:\",\") l)\n x.ptyext_params longident_loc x.ptyext_path private_flag\n x.ptyext_private (* Cf: #7200 *)\n (list ~sep:\"\" extension_constructor)\n x.ptyext_constructors (item_attributes ctxt) x.ptyext_attributes\n\nand constructor_declaration ctxt f (name, args, res, attrs) =\n let name = match name with \"::\" -> \"(::)\" | s -> s in\n match res with\n | None ->\n pp f \"%s%a@;%a\" name\n (fun f -> function\n | Pcstr_tuple [] -> ()\n | Pcstr_tuple l ->\n pp f \"@;of@;%a\" (list (core_type1 ctxt) ~sep:\"@;*@;\") l\n | Pcstr_record l -> pp f \"@;of@;%a\" (record_declaration ctxt) l)\n args (attributes ctxt) attrs\n | Some r ->\n pp f \"%s:@;%a@;%a\" name\n (fun f -> function\n | Pcstr_tuple [] -> core_type1 ctxt f r\n | Pcstr_tuple l ->\n pp f \"%a@;->@;%a\"\n (list (core_type1 ctxt) ~sep:\"@;*@;\")\n l (core_type1 ctxt) r\n | Pcstr_record l ->\n pp f \"%a@;->@;%a\" (record_declaration ctxt) l (core_type1 ctxt) r)\n args (attributes ctxt) attrs\n\nand extension_constructor ctxt f x =\n (* Cf: #7200 *)\n match x.pext_kind with\n | Pext_decl (l, r) ->\n constructor_declaration ctxt f (x.pext_name.txt, l, r, x.pext_attributes)\n | Pext_rebind li ->\n pp f \"%s@;=@;%a%a\" x.pext_name.txt longident_loc li (attributes ctxt)\n x.pext_attributes\n\nand case_list ctxt f l : unit =\n let aux f { pc_lhs; pc_guard; pc_rhs } =\n pp f \"@;| @[<2>%a%a@;->@;%a@]\" (pattern ctxt) pc_lhs\n (option (expression ctxt) ~first:\"@;when@;\")\n pc_guard\n (expression (under_pipe ctxt))\n pc_rhs\n in\n list aux f l ~sep:\"\"\n\nand label_x_expression_param ctxt f (l, e) =\n let simple_name =\n match e with\n | { pexp_desc = Pexp_ident { txt = Lident l; _ }; pexp_attributes = [] } ->\n Some l\n | _ -> None\n in\n match l with\n | Nolabel -> expression2 ctxt f e (* level 2*)\n | Optional str ->\n if Some str = simple_name then pp f \"?%s\" str\n else pp f \"?%s:%a\" str (simple_expr ctxt) e\n | Labelled lbl ->\n if Some lbl = simple_name then pp f \"~%s\" lbl\n else pp f \"~%s:%a\" lbl (simple_expr ctxt) e\n\nand directive_argument f x =\n match x.pdira_desc with\n | Pdir_string s -> pp f \"@ %S\" s\n | Pdir_int (n, None) -> pp f \"@ %s\" n\n | Pdir_int (n, Some m) -> pp f \"@ %s%c\" n m\n | Pdir_ident li -> pp f \"@ %a\" longident li\n | Pdir_bool b -> pp f \"@ %s\" (string_of_bool b)\n\nlet toplevel_phrase f x =\n match x with\n | Ptop_def s -> pp f \"@[%a@]\" (list (structure_item reset_ctxt)) s\n (* pp_open_hvbox f 0; *)\n (* pp_print_list structure_item f s ; *)\n (* pp_close_box f (); *)\n | Ptop_dir { pdir_name; pdir_arg = None; _ } ->\n pp f \"@[#%s@]\" pdir_name.txt\n | Ptop_dir { pdir_name; pdir_arg = Some pdir_arg; _ } ->\n pp f \"@[#%s@ %a@]\" pdir_name.txt directive_argument pdir_arg\n\nlet expression f x = pp f \"@[%a@]\" (expression reset_ctxt) x\n\nlet string_of_expression x =\n ignore (flush_str_formatter ());\n let f = str_formatter in\n expression f x;\n flush_str_formatter ()\n\nlet string_of_structure x =\n ignore (flush_str_formatter ());\n let f = str_formatter in\n structure reset_ctxt f x;\n flush_str_formatter ()\n\nlet top_phrase f x =\n pp_print_newline f ();\n toplevel_phrase f x;\n pp f \";;\";\n pp_print_newline f ()\n\nlet core_type = core_type reset_ctxt\nlet pattern = pattern reset_ctxt\nlet signature = signature reset_ctxt\nlet structure = structure reset_ctxt\nlet class_expr = class_expr reset_ctxt\nlet class_field = class_field reset_ctxt\nlet class_type = class_type reset_ctxt\nlet class_signature = class_signature reset_ctxt\nlet class_type_field = class_type_field reset_ctxt\nlet module_expr = module_expr reset_ctxt\nlet module_type = module_type reset_ctxt\nlet signature_item = signature_item reset_ctxt\nlet structure_item = structure_item reset_ctxt\nlet type_declaration = type_declaration reset_ctxt\n","(**************************************************************************)\n(* *)\n(* OCaml Migrate Parsetree *)\n(* *)\n(* Frédéric Bour, Facebook *)\n(* Jérémie Dimino and Leo White, Jane Street Europe *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* Alain Frisch, LexiFi *)\n(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 2018 Institut National de Recherche en Informatique et *)\n(* en Automatique (INRIA). *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nmodule Asttypes = struct\n type constant (*IF_CURRENT = Asttypes.constant *) =\n Const_int of int\n | Const_char of char\n | Const_string of string * Location.t * string option\n | Const_float of string\n | Const_int32 of int32\n | Const_int64 of int64\n | Const_nativeint of nativeint\n\n type rec_flag (*IF_CURRENT = Asttypes.rec_flag *) = Nonrecursive | Recursive\n\n type direction_flag (*IF_CURRENT = Asttypes.direction_flag *) = Upto | Downto\n\n (* Order matters, used in polymorphic comparison *)\n type private_flag (*IF_CURRENT = Asttypes.private_flag *) = Private | Public\n\n type mutable_flag (*IF_CURRENT = Asttypes.mutable_flag *) = Immutable | Mutable\n\n type virtual_flag (*IF_CURRENT = Asttypes.virtual_flag *) = Virtual | Concrete\n\n type override_flag (*IF_CURRENT = Asttypes.override_flag *) = Override | Fresh\n\n type closed_flag (*IF_CURRENT = Asttypes.closed_flag *) = Closed | Open\n\n type label = string\n\n type arg_label (*IF_CURRENT = Asttypes.arg_label *) =\n Nolabel\n | Labelled of string (* label:T -> ... *)\n | Optional of string (* ?label:T -> ... *)\n\n type 'a loc = 'a Location.loc = {\n txt : 'a;\n loc : Location.t;\n }\n\n type variance (*IF_CURRENT = Asttypes.variance *) =\n | Covariant\n | Contravariant\n | NoVariance\n\n type injectivity (*IF_CURRENT = Asttypes.injectivity *) =\n | Injective\n | NoInjectivity\nend\n\nmodule Parsetree = struct\n open Asttypes\n\n type constant (*IF_CURRENT = Parsetree.constant *) =\n Pconst_integer of string * char option\n (* 3 3l 3L 3n\n\n Suffixes [g-z][G-Z] are accepted by the parser.\n Suffixes except 'l', 'L' and 'n' are rejected by the typechecker\n *)\n | Pconst_char of char\n (* 'c' *)\n | Pconst_string of string * Location.t * string option\n (* \"constant\"\n {delim|other constant|delim}\n\n The location span the content of the string, without the delimiters.\n *)\n | Pconst_float of string * char option\n (* 3.4 2e5 1.4e-4\n\n Suffixes [g-z][G-Z] are accepted by the parser.\n Suffixes are rejected by the typechecker.\n *)\n\n type location_stack = Location.t list\n\n (** {1 Extension points} *)\n\n type attribute (*IF_CURRENT = Parsetree.attribute *) = {\n attr_name : string loc;\n attr_payload : payload;\n attr_loc : Location.t;\n }\n (* [@id ARG]\n [@@id ARG]\n\n Metadata containers passed around within the AST.\n The compiler ignores unknown attributes.\n *)\n\n and extension = string loc * payload\n (* [%id ARG]\n [%%id ARG]\n\n Sub-language placeholder -- rejected by the typechecker.\n *)\n\n and attributes = attribute list\n\n and payload (*IF_CURRENT = Parsetree.payload *) =\n | PStr of structure\n | PSig of signature (* : SIG *)\n | PTyp of core_type (* : T *)\n | PPat of pattern * expression option (* ? P or ? P when E *)\n\n (** {1 Core language} *)\n\n (* Type expressions *)\n\n and core_type (*IF_CURRENT = Parsetree.core_type *) =\n {\n ptyp_desc: core_type_desc;\n ptyp_loc: Location.t;\n ptyp_loc_stack: location_stack;\n ptyp_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and core_type_desc (*IF_CURRENT = Parsetree.core_type_desc *) =\n | Ptyp_any\n (* _ *)\n | Ptyp_var of string\n (* 'a *)\n | Ptyp_arrow of arg_label * core_type * core_type\n (* T1 -> T2 Simple\n ~l:T1 -> T2 Labelled\n ?l:T1 -> T2 Optional\n *)\n | Ptyp_tuple of core_type list\n (* T1 * ... * Tn\n\n Invariant: n >= 2\n *)\n | Ptyp_constr of Longident.t loc * core_type list\n (* tconstr\n T tconstr\n (T1, ..., Tn) tconstr\n *)\n | Ptyp_object of object_field list * closed_flag\n (* < l1:T1; ...; ln:Tn > (flag = Closed)\n < l1:T1; ...; ln:Tn; .. > (flag = Open)\n *)\n | Ptyp_class of Longident.t loc * core_type list\n (* #tconstr\n T #tconstr\n (T1, ..., Tn) #tconstr\n *)\n | Ptyp_alias of core_type * string\n (* T as 'a *)\n | Ptyp_variant of row_field list * closed_flag * label list option\n (* [ `A|`B ] (flag = Closed; labels = None)\n [> `A|`B ] (flag = Open; labels = None)\n [< `A|`B ] (flag = Closed; labels = Some [])\n [< `A|`B > `X `Y ](flag = Closed; labels = Some [\"X\";\"Y\"])\n *)\n | Ptyp_poly of string loc list * core_type\n (* 'a1 ... 'an. T\n\n Can only appear in the following context:\n\n - As the core_type of a Ppat_constraint node corresponding\n to a constraint on a let-binding: let x : 'a1 ... 'an. T\n = e ...\n\n - Under Cfk_virtual for methods (not values).\n\n - As the core_type of a Pctf_method node.\n\n - As the core_type of a Pexp_poly node.\n\n - As the pld_type field of a label_declaration.\n\n - As a core_type of a Ptyp_object node.\n *)\n\n | Ptyp_package of package_type\n (* (module S) *)\n | Ptyp_extension of extension\n (* [%id] *)\n\n and package_type = Longident.t loc * (Longident.t loc * core_type) list\n (*\n (module S)\n (module S with type t1 = T1 and ... and tn = Tn)\n *)\n\n and row_field (*IF_CURRENT = Parsetree.row_field *) = {\n prf_desc : row_field_desc;\n prf_loc : Location.t;\n prf_attributes : attributes;\n }\n\n and row_field_desc (*IF_CURRENT = Parsetree.row_field_desc *) =\n | Rtag of label loc * bool * core_type list\n (* [`A] ( true, [] )\n [`A of T] ( false, [T] )\n [`A of T1 & .. & Tn] ( false, [T1;...Tn] )\n [`A of & T1 & .. & Tn] ( true, [T1;...Tn] )\n\n - The 'bool' field is true if the tag contains a\n constant (empty) constructor.\n - '&' occurs when several types are used for the same constructor\n (see 4.2 in the manual)\n *)\n | Rinherit of core_type\n (* [ T ] *)\n\n and object_field (*IF_CURRENT = Parsetree.object_field *) = {\n pof_desc : object_field_desc;\n pof_loc : Location.t;\n pof_attributes : attributes;\n }\n\n and object_field_desc (*IF_CURRENT = Parsetree.object_field_desc *) =\n | Otag of label loc * core_type\n | Oinherit of core_type\n\n (* Patterns *)\n\n and pattern (*IF_CURRENT = Parsetree.pattern *) =\n {\n ppat_desc: pattern_desc;\n ppat_loc: Location.t;\n ppat_loc_stack: location_stack;\n ppat_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and pattern_desc (*IF_CURRENT = Parsetree.pattern_desc *) =\n | Ppat_any\n (* _ *)\n | Ppat_var of string loc\n (* x *)\n | Ppat_alias of pattern * string loc\n (* P as 'a *)\n | Ppat_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Ppat_interval of constant * constant\n (* 'a'..'z'\n\n Other forms of interval are recognized by the parser\n but rejected by the type-checker. *)\n | Ppat_tuple of pattern list\n (* (P1, ..., Pn)\n\n Invariant: n >= 2\n *)\n | Ppat_construct of Longident.t loc * (string loc list * pattern) option\n (* C None\n C P Some ([], P)\n C (P1, ..., Pn) Some ([], Ppat_tuple [P1; ...; Pn])\n C (type a b) P Some ([a; b], P)\n *)\n | Ppat_variant of label * pattern option\n (* `A (None)\n `A P (Some P)\n *)\n | Ppat_record of (Longident.t loc * pattern) list * closed_flag\n (* { l1=P1; ...; ln=Pn } (flag = Closed)\n { l1=P1; ...; ln=Pn; _} (flag = Open)\n\n Invariant: n > 0\n *)\n | Ppat_array of pattern list\n (* [| P1; ...; Pn |] *)\n | Ppat_or of pattern * pattern\n (* P1 | P2 *)\n | Ppat_constraint of pattern * core_type\n (* (P : T) *)\n | Ppat_type of Longident.t loc\n (* #tconst *)\n | Ppat_lazy of pattern\n (* lazy P *)\n | Ppat_unpack of string option loc\n (* (module P) Some \"P\"\n (module _) None\n\n Note: (module P : S) is represented as\n Ppat_constraint(Ppat_unpack, Ptyp_package)\n *)\n | Ppat_exception of pattern\n (* exception P *)\n | Ppat_extension of extension\n (* [%id] *)\n | Ppat_open of Longident.t loc * pattern\n (* M.(P) *)\n\n (* Value expressions *)\n\n and expression (*IF_CURRENT = Parsetree.expression *) =\n {\n pexp_desc: expression_desc;\n pexp_loc: Location.t;\n pexp_loc_stack: location_stack;\n pexp_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and expression_desc (*IF_CURRENT = Parsetree.expression_desc *) =\n | Pexp_ident of Longident.t loc\n (* x\n M.x\n *)\n | Pexp_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Pexp_let of rec_flag * value_binding list * expression\n (* let P1 = E1 and ... and Pn = EN in E (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in E (flag = Recursive)\n *)\n | Pexp_function of case list\n (* function P1 -> E1 | ... | Pn -> En *)\n | Pexp_fun of arg_label * expression option * pattern * expression\n (* fun P -> E1 (Simple, None)\n fun ~l:P -> E1 (Labelled l, None)\n fun ?l:P -> E1 (Optional l, None)\n fun ?l:(P = E0) -> E1 (Optional l, Some E0)\n\n Notes:\n - If E0 is provided, only Optional is allowed.\n - \"fun P1 P2 .. Pn -> E1\" is represented as nested Pexp_fun.\n - \"let f P = E\" is represented using Pexp_fun.\n *)\n | Pexp_apply of expression * (arg_label * expression) list\n (* E0 ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pexp_match of expression * case list\n (* match E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_try of expression * case list\n (* try E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_tuple of expression list\n (* (E1, ..., En)\n\n Invariant: n >= 2\n *)\n | Pexp_construct of Longident.t loc * expression option\n (* C None\n C E Some E\n C (E1, ..., En) Some (Pexp_tuple[E1;...;En])\n *)\n | Pexp_variant of label * expression option\n (* `A (None)\n `A E (Some E)\n *)\n | Pexp_record of (Longident.t loc * expression) list * expression option\n (* { l1=P1; ...; ln=Pn } (None)\n { E0 with l1=P1; ...; ln=Pn } (Some E0)\n\n Invariant: n > 0\n *)\n | Pexp_field of expression * Longident.t loc\n (* E.l *)\n | Pexp_setfield of expression * Longident.t loc * expression\n (* E1.l <- E2 *)\n | Pexp_array of expression list\n (* [| E1; ...; En |] *)\n | Pexp_ifthenelse of expression * expression * expression option\n (* if E1 then E2 else E3 *)\n | Pexp_sequence of expression * expression\n (* E1; E2 *)\n | Pexp_while of expression * expression\n (* while E1 do E2 done *)\n | Pexp_for of\n pattern * expression * expression * direction_flag * expression\n (* for i = E1 to E2 do E3 done (flag = Upto)\n for i = E1 downto E2 do E3 done (flag = Downto)\n *)\n | Pexp_constraint of expression * core_type\n (* (E : T) *)\n | Pexp_coerce of expression * core_type option * core_type\n (* (E :> T) (None, T)\n (E : T0 :> T) (Some T0, T)\n *)\n | Pexp_send of expression * label loc\n (* E # m *)\n | Pexp_new of Longident.t loc\n (* new M.c *)\n | Pexp_setinstvar of label loc * expression\n (* x <- 2 *)\n | Pexp_override of (label loc * expression) list\n (* {< x1 = E1; ...; Xn = En >} *)\n | Pexp_letmodule of string option loc * module_expr * expression\n (* let module M = ME in E *)\n | Pexp_letexception of extension_constructor * expression\n (* let exception C in E *)\n | Pexp_assert of expression\n (* assert E\n Note: \"assert false\" is treated in a special way by the\n type-checker. *)\n | Pexp_lazy of expression\n (* lazy E *)\n | Pexp_poly of expression * core_type option\n (* Used for method bodies.\n\n Can only be used as the expression under Cfk_concrete\n for methods (not values). *)\n | Pexp_object of class_structure\n (* object ... end *)\n | Pexp_newtype of string loc * expression\n (* fun (type t) -> E *)\n | Pexp_pack of module_expr\n (* (module ME)\n\n (module ME : S) is represented as\n Pexp_constraint(Pexp_pack, Ptyp_package S) *)\n | Pexp_open of open_declaration * expression\n (* M.(E)\n let open M in E\n let! open M in E *)\n | Pexp_letop of letop\n (* let* P = E in E\n let* P = E and* P = E in E *)\n | Pexp_extension of extension\n (* [%id] *)\n | Pexp_unreachable\n (* . *)\n\n and case (*IF_CURRENT = Parsetree.case *) = (* (P -> E) or (P when E0 -> E) *)\n {\n pc_lhs: pattern;\n pc_guard: expression option;\n pc_rhs: expression;\n }\n\n and letop (*IF_CURRENT = Parsetree.letop *) =\n {\n let_ : binding_op;\n ands : binding_op list;\n body : expression;\n }\n\n and binding_op (*IF_CURRENT = Parsetree.binding_op *) =\n {\n pbop_op : string loc;\n pbop_pat : pattern;\n pbop_exp : expression;\n pbop_loc : Location.t;\n }\n\n (* Value descriptions *)\n\n and value_description (*IF_CURRENT = Parsetree.value_description *) =\n {\n pval_name: string loc;\n pval_type: core_type;\n pval_prim: string list;\n pval_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pval_loc: Location.t;\n }\n\n(*\n val x: T (prim = [])\n external x: T = \"s1\" ... \"sn\" (prim = [\"s1\";...\"sn\"])\n*)\n\n (* Type declarations *)\n\n and type_declaration (*IF_CURRENT = Parsetree.type_declaration *) =\n {\n ptype_name: string loc;\n ptype_params: (core_type * (variance * injectivity)) list;\n (* ('a1,...'an) t; None represents _*)\n ptype_cstrs: (core_type * core_type * Location.t) list;\n (* ... constraint T1=T1' ... constraint Tn=Tn' *)\n ptype_kind: type_kind;\n ptype_private: private_flag; (* = private ... *)\n ptype_manifest: core_type option; (* = T *)\n ptype_attributes: attributes; (* ... [@@id1] [@@id2] *)\n ptype_loc: Location.t;\n }\n\n(*\n type t (abstract, no manifest)\n type t = T0 (abstract, manifest=T0)\n type t = C of T | ... (variant, no manifest)\n type t = T0 = C of T | ... (variant, manifest=T0)\n type t = {l: T; ...} (record, no manifest)\n type t = T0 = {l : T; ...} (record, manifest=T0)\n type t = .. (open, no manifest)\n*)\n\n and type_kind (*IF_CURRENT = Parsetree.type_kind *) =\n | Ptype_abstract\n | Ptype_variant of constructor_declaration list\n | Ptype_record of label_declaration list\n (* Invariant: non-empty list *)\n | Ptype_open\n\n and label_declaration (*IF_CURRENT = Parsetree.label_declaration *) =\n {\n pld_name: string loc;\n pld_mutable: mutable_flag;\n pld_type: core_type;\n pld_loc: Location.t;\n pld_attributes: attributes; (* l : T [@id1] [@id2] *)\n }\n\n (* { ...; l: T; ... } (mutable=Immutable)\n { ...; mutable l: T; ... } (mutable=Mutable)\n\n Note: T can be a Ptyp_poly.\n *)\n\n and constructor_declaration (*IF_CURRENT = Parsetree.constructor_declaration *) =\n {\n pcd_name: string loc;\n pcd_args: constructor_arguments;\n pcd_res: core_type option;\n pcd_loc: Location.t;\n pcd_attributes: attributes; (* C of ... [@id1] [@id2] *)\n }\n\n and constructor_arguments (*IF_CURRENT = Parsetree.constructor_arguments *) =\n | Pcstr_tuple of core_type list\n | Pcstr_record of label_declaration list\n\n(*\n | C of T1 * ... * Tn (res = None, args = Pcstr_tuple [])\n | C: T0 (res = Some T0, args = [])\n | C: T1 * ... * Tn -> T0 (res = Some T0, args = Pcstr_tuple)\n | C of {...} (res = None, args = Pcstr_record)\n | C: {...} -> T0 (res = Some T0, args = Pcstr_record)\n | C of {...} as t (res = None, args = Pcstr_record)\n*)\n\n and type_extension (*IF_CURRENT = Parsetree.type_extension *) =\n {\n ptyext_path: Longident.t loc;\n ptyext_params: (core_type * (variance * injectivity)) list;\n ptyext_constructors: extension_constructor list;\n ptyext_private: private_flag;\n ptyext_loc: Location.t;\n ptyext_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n(*\n type t += ...\n*)\n\n and extension_constructor (*IF_CURRENT = Parsetree.extension_constructor *) =\n {\n pext_name: string loc;\n pext_kind : extension_constructor_kind;\n pext_loc : Location.t;\n pext_attributes: attributes; (* C of ... [@id1] [@id2] *)\n }\n\n (* exception E *)\n and type_exception (*IF_CURRENT = Parsetree.type_exception *) =\n {\n ptyexn_constructor: extension_constructor;\n ptyexn_loc: Location.t;\n ptyexn_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and extension_constructor_kind (*IF_CURRENT = Parsetree.extension_constructor_kind *) =\n Pext_decl of constructor_arguments * core_type option\n (*\n | C of T1 * ... * Tn ([T1; ...; Tn], None)\n | C: T0 ([], Some T0)\n | C: T1 * ... * Tn -> T0 ([T1; ...; Tn], Some T0)\n *)\n | Pext_rebind of Longident.t loc\n (*\n | C = D\n *)\n\n (** {1 Class language} *)\n\n (* Type expressions for the class language *)\n\n and class_type (*IF_CURRENT = Parsetree.class_type *) =\n {\n pcty_desc: class_type_desc;\n pcty_loc: Location.t;\n pcty_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and class_type_desc (*IF_CURRENT = Parsetree.class_type_desc *) =\n | Pcty_constr of Longident.t loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcty_signature of class_signature\n (* object ... end *)\n | Pcty_arrow of arg_label * core_type * class_type\n (* T -> CT Simple\n ~l:T -> CT Labelled l\n ?l:T -> CT Optional l\n *)\n | Pcty_extension of extension\n (* [%id] *)\n | Pcty_open of open_description * class_type\n (* let open M in CT *)\n\n and class_signature (*IF_CURRENT = Parsetree.class_signature *) =\n {\n pcsig_self: core_type;\n pcsig_fields: class_type_field list;\n }\n (* object('selfpat) ... end\n object ... end (self = Ptyp_any)\n *)\n\n and class_type_field (*IF_CURRENT = Parsetree.class_type_field *) =\n {\n pctf_desc: class_type_field_desc;\n pctf_loc: Location.t;\n pctf_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and class_type_field_desc (*IF_CURRENT = Parsetree.class_type_field_desc *) =\n | Pctf_inherit of class_type\n (* inherit CT *)\n | Pctf_val of (label loc * mutable_flag * virtual_flag * core_type)\n (* val x: T *)\n | Pctf_method of (label loc * private_flag * virtual_flag * core_type)\n (* method x: T\n\n Note: T can be a Ptyp_poly.\n *)\n | Pctf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pctf_attribute of attribute\n (* [@@@id] *)\n | Pctf_extension of extension\n (* [%%id] *)\n\n and 'a class_infos (*IF_CURRENT = 'a Parsetree.class_infos *) =\n {\n pci_virt: virtual_flag;\n pci_params: (core_type * (variance * injectivity)) list;\n pci_name: string loc;\n pci_expr: 'a;\n pci_loc: Location.t;\n pci_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n (* class c = ...\n class ['a1,...,'an] c = ...\n class virtual c = ...\n\n Also used for \"class type\" declaration.\n *)\n\n and class_description = class_type class_infos\n\n and class_type_declaration = class_type class_infos\n\n (* Value expressions for the class language *)\n\n and class_expr (*IF_CURRENT = Parsetree.class_expr *) =\n {\n pcl_desc: class_expr_desc;\n pcl_loc: Location.t;\n pcl_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and class_expr_desc (*IF_CURRENT = Parsetree.class_expr_desc *) =\n | Pcl_constr of Longident.t loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcl_structure of class_structure\n (* object ... end *)\n | Pcl_fun of arg_label * expression option * pattern * class_expr\n (* fun P -> CE (Simple, None)\n fun ~l:P -> CE (Labelled l, None)\n fun ?l:P -> CE (Optional l, None)\n fun ?l:(P = E0) -> CE (Optional l, Some E0)\n *)\n | Pcl_apply of class_expr * (arg_label * expression) list\n (* CE ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pcl_let of rec_flag * value_binding list * class_expr\n (* let P1 = E1 and ... and Pn = EN in CE (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in CE (flag = Recursive)\n *)\n | Pcl_constraint of class_expr * class_type\n (* (CE : CT) *)\n | Pcl_extension of extension\n (* [%id] *)\n | Pcl_open of open_description * class_expr\n (* let open M in CE *)\n\n\n and class_structure (*IF_CURRENT = Parsetree.class_structure *) =\n {\n pcstr_self: pattern;\n pcstr_fields: class_field list;\n }\n (* object(selfpat) ... end\n object ... end (self = Ppat_any)\n *)\n\n and class_field (*IF_CURRENT = Parsetree.class_field *) =\n {\n pcf_desc: class_field_desc;\n pcf_loc: Location.t;\n pcf_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and class_field_desc (*IF_CURRENT = Parsetree.class_field_desc *) =\n | Pcf_inherit of override_flag * class_expr * string loc option\n (* inherit CE\n inherit CE as x\n inherit! CE\n inherit! CE as x\n *)\n | Pcf_val of (label loc * mutable_flag * class_field_kind)\n (* val x = E\n val virtual x: T\n *)\n | Pcf_method of (label loc * private_flag * class_field_kind)\n (* method x = E (E can be a Pexp_poly)\n method virtual x: T (T can be a Ptyp_poly)\n *)\n | Pcf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pcf_initializer of expression\n (* initializer E *)\n | Pcf_attribute of attribute\n (* [@@@id] *)\n | Pcf_extension of extension\n (* [%%id] *)\n\n and class_field_kind (*IF_CURRENT = Parsetree.class_field_kind *) =\n | Cfk_virtual of core_type\n | Cfk_concrete of override_flag * expression\n\n and class_declaration = class_expr class_infos\n\n (** {1 Module language} *)\n\n (* Type expressions for the module language *)\n\n and module_type (*IF_CURRENT = Parsetree.module_type *) =\n {\n pmty_desc: module_type_desc;\n pmty_loc: Location.t;\n pmty_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and module_type_desc (*IF_CURRENT = Parsetree.module_type_desc *) =\n | Pmty_ident of Longident.t loc\n (* S *)\n | Pmty_signature of signature\n (* sig ... end *)\n | Pmty_functor of functor_parameter * module_type\n (* functor(X : MT1) -> MT2 *)\n | Pmty_with of module_type * with_constraint list\n (* MT with ... *)\n | Pmty_typeof of module_expr\n (* module type of ME *)\n | Pmty_extension of extension\n (* [%id] *)\n | Pmty_alias of Longident.t loc\n (* (module M) *)\n\n and functor_parameter (*IF_CURRENT = Parsetree.functor_parameter *) =\n | Unit\n (* () *)\n | Named of string option loc * module_type\n (* (X : MT) Some X, MT\n (_ : MT) None, MT *)\n\n and signature = signature_item list\n\n and signature_item (*IF_CURRENT = Parsetree.signature_item *) =\n {\n psig_desc: signature_item_desc;\n psig_loc: Location.t;\n }\n\n and signature_item_desc (*IF_CURRENT = Parsetree.signature_item_desc *) =\n | Psig_value of value_description\n (*\n val x: T\n external x: T = \"s1\" ... \"sn\"\n *)\n | Psig_type of rec_flag * type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Psig_typesubst of type_declaration list\n (* type t1 := ... and ... and tn := ... *)\n | Psig_typext of type_extension\n (* type t1 += ... *)\n | Psig_exception of type_exception\n (* exception C of T *)\n | Psig_module of module_declaration\n (* module X = M\n module X : MT *)\n | Psig_modsubst of module_substitution\n (* module X := M *)\n | Psig_recmodule of module_declaration list\n (* module rec X1 : MT1 and ... and Xn : MTn *)\n | Psig_modtype of module_type_declaration\n (* module type S = MT\n module type S *)\n | Psig_modtypesubst of module_type_declaration\n (* module type S := ... *)\n | Psig_open of open_description\n (* open X *)\n | Psig_include of include_description\n (* include MT *)\n | Psig_class of class_description list\n (* class c1 : ... and ... and cn : ... *)\n | Psig_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Psig_attribute of attribute\n (* [@@@id] *)\n | Psig_extension of extension * attributes\n (* [%%id] *)\n\n and module_declaration (*IF_CURRENT = Parsetree.module_declaration *) =\n {\n pmd_name: string option loc;\n pmd_type: module_type;\n pmd_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pmd_loc: Location.t;\n }\n (* S : MT *)\n\n and module_substitution (*IF_CURRENT = Parsetree.module_substitution *) =\n {\n pms_name: string loc;\n pms_manifest: Longident.t loc;\n pms_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pms_loc: Location.t;\n }\n\n and module_type_declaration (*IF_CURRENT = Parsetree.module_type_declaration *) =\n {\n pmtd_name: string loc;\n pmtd_type: module_type option;\n pmtd_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pmtd_loc: Location.t;\n }\n (* S = MT\n S (abstract module type declaration, pmtd_type = None)\n *)\n\n and 'a open_infos (*IF_CURRENT = 'a Parsetree.open_infos *) =\n {\n popen_expr: 'a;\n popen_override: override_flag;\n popen_loc: Location.t;\n popen_attributes: attributes;\n }\n (* open! X - popen_override = Override (silences the 'used identifier\n shadowing' warning)\n open X - popen_override = Fresh\n *)\n\n and open_description = Longident.t loc open_infos\n (* open M.N\n open M(N).O *)\n\n and open_declaration = module_expr open_infos\n (* open M.N\n open M(N).O\n open struct ... end *)\n\n and 'a include_infos (*IF_CURRENT = 'a Parsetree.include_infos *) =\n {\n pincl_mod: 'a;\n pincl_loc: Location.t;\n pincl_attributes: attributes;\n }\n\n and include_description = module_type include_infos\n (* include MT *)\n\n and include_declaration = module_expr include_infos\n (* include ME *)\n\n and with_constraint (*IF_CURRENT = Parsetree.with_constraint *) =\n | Pwith_type of Longident.t loc * type_declaration\n (* with type X.t = ...\n\n Note: the last component of the longident must match\n the name of the type_declaration. *)\n | Pwith_module of Longident.t loc * Longident.t loc\n (* with module X.Y = Z *)\n | Pwith_modtype of Longident.t loc * module_type\n (* with module type X.Y = Z *)\n | Pwith_modtypesubst of Longident.t loc * module_type\n (* with module type X.Y := sig end *)\n | Pwith_typesubst of Longident.t loc * type_declaration\n (* with type X.t := ..., same format as [Pwith_type] *)\n | Pwith_modsubst of Longident.t loc * Longident.t loc\n (* with module X.Y := Z *)\n\n (* Value expressions for the module language *)\n\n and module_expr (*IF_CURRENT = Parsetree.module_expr *) =\n {\n pmod_desc: module_expr_desc;\n pmod_loc: Location.t;\n pmod_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and module_expr_desc (*IF_CURRENT = Parsetree.module_expr_desc *) =\n | Pmod_ident of Longident.t loc\n (* X *)\n | Pmod_structure of structure\n (* struct ... end *)\n | Pmod_functor of functor_parameter * module_expr\n (* functor(X : MT1) -> ME *)\n | Pmod_apply of module_expr * module_expr\n (* ME1(ME2) *)\n | Pmod_constraint of module_expr * module_type\n (* (ME : MT) *)\n | Pmod_unpack of expression\n (* (val E) *)\n | Pmod_extension of extension\n (* [%id] *)\n\n and structure = structure_item list\n\n and structure_item (*IF_CURRENT = Parsetree.structure_item *) =\n {\n pstr_desc: structure_item_desc;\n pstr_loc: Location.t;\n }\n\n and structure_item_desc (*IF_CURRENT = Parsetree.structure_item_desc *) =\n | Pstr_eval of expression * attributes\n (* E *)\n | Pstr_value of rec_flag * value_binding list\n (* let P1 = E1 and ... and Pn = EN (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN (flag = Recursive)\n *)\n | Pstr_primitive of value_description\n (* val x: T\n external x: T = \"s1\" ... \"sn\" *)\n | Pstr_type of rec_flag * type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Pstr_typext of type_extension\n (* type t1 += ... *)\n | Pstr_exception of type_exception\n (* exception C of T\n exception C = M.X *)\n | Pstr_module of module_binding\n (* module X = ME *)\n | Pstr_recmodule of module_binding list\n (* module rec X1 = ME1 and ... and Xn = MEn *)\n | Pstr_modtype of module_type_declaration\n (* module type S = MT *)\n | Pstr_open of open_declaration\n (* open X *)\n | Pstr_class of class_declaration list\n (* class c1 = ... and ... and cn = ... *)\n | Pstr_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Pstr_include of include_declaration\n (* include ME *)\n | Pstr_attribute of attribute\n (* [@@@id] *)\n | Pstr_extension of extension * attributes\n (* [%%id] *)\n\n and value_binding (*IF_CURRENT = Parsetree.value_binding *) =\n {\n pvb_pat: pattern;\n pvb_expr: expression;\n pvb_attributes: attributes;\n pvb_loc: Location.t;\n }\n\n and module_binding (*IF_CURRENT = Parsetree.module_binding *) =\n {\n pmb_name: string option loc;\n pmb_expr: module_expr;\n pmb_attributes: attributes;\n pmb_loc: Location.t;\n }\n (* X = ME *)\n\n (** {1 Toplevel} *)\n\n (* Toplevel phrases *)\n\n type toplevel_phrase (*IF_CURRENT = Parsetree.toplevel_phrase *) =\n | Ptop_def of structure\n | Ptop_dir of toplevel_directive\n (* #use, #load ... *)\n\n and toplevel_directive (*IF_CURRENT = Parsetree.toplevel_directive *) =\n {\n pdir_name : string loc;\n pdir_arg : directive_argument option;\n pdir_loc : Location.t;\n }\n\n and directive_argument (*IF_CURRENT = Parsetree.directive_argument *) =\n {\n pdira_desc : directive_argument_desc;\n pdira_loc : Location.t;\n }\n\n and directive_argument_desc (*IF_CURRENT = Parsetree.directive_argument_desc *) =\n | Pdir_string of string\n | Pdir_int of string * char option\n | Pdir_ident of Longident.t\n | Pdir_bool of bool\nend\n\nmodule Config = struct\n let ast_impl_magic_number = \"Caml1999M030\"\n let ast_intf_magic_number = \"Caml1999N030\"\nend\n","(**************************************************************************)\n(* *)\n(* OCaml Migrate Parsetree *)\n(* *)\n(* Frédéric Bour, Facebook *)\n(* Jérémie Dimino and Leo White, Jane Street Europe *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* Alain Frisch, LexiFi *)\n(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 2018 Institut National de Recherche en Informatique et *)\n(* en Automatique (INRIA). *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nmodule Asttypes = struct\n type constant (*IF_CURRENT = Asttypes.constant *) =\n Const_int of int\n | Const_char of char\n | Const_string of string * Location.t * string option\n | Const_float of string\n | Const_int32 of int32\n | Const_int64 of int64\n | Const_nativeint of nativeint\n\n type rec_flag (*IF_CURRENT = Asttypes.rec_flag *) = Nonrecursive | Recursive\n\n type direction_flag (*IF_CURRENT = Asttypes.direction_flag *) = Upto | Downto\n\n (* Order matters, used in polymorphic comparison *)\n type private_flag (*IF_CURRENT = Asttypes.private_flag *) = Private | Public\n\n type mutable_flag (*IF_CURRENT = Asttypes.mutable_flag *) = Immutable | Mutable\n\n type virtual_flag (*IF_CURRENT = Asttypes.virtual_flag *) = Virtual | Concrete\n\n type override_flag (*IF_CURRENT = Asttypes.override_flag *) = Override | Fresh\n\n type closed_flag (*IF_CURRENT = Asttypes.closed_flag *) = Closed | Open\n\n type label = string\n\n type arg_label (*IF_CURRENT = Asttypes.arg_label *) =\n Nolabel\n | Labelled of string (* label:T -> ... *)\n | Optional of string (* ?label:T -> ... *)\n\n type 'a loc = 'a Location.loc = {\n txt : 'a;\n loc : Location.t;\n }\n\n type variance (*IF_CURRENT = Asttypes.variance *) =\n | Covariant\n | Contravariant\n | NoVariance\n\n type injectivity (*IF_CURRENT = Asttypes.injectivity *) =\n | Injective\n | NoInjectivity\nend\n\nmodule Parsetree = struct\n open Asttypes\n\n type constant (*IF_CURRENT = Parsetree.constant *) =\n Pconst_integer of string * char option\n (* 3 3l 3L 3n\n\n Suffixes [g-z][G-Z] are accepted by the parser.\n Suffixes except 'l', 'L' and 'n' are rejected by the typechecker\n *)\n | Pconst_char of char\n (* 'c' *)\n | Pconst_string of string * Location.t * string option\n (* \"constant\"\n {delim|other constant|delim}\n\n The location span the content of the string, without the delimiters.\n *)\n | Pconst_float of string * char option\n (* 3.4 2e5 1.4e-4\n\n Suffixes [g-z][G-Z] are accepted by the parser.\n Suffixes are rejected by the typechecker.\n *)\n\n type location_stack = Location.t list\n\n (** {1 Extension points} *)\n\n type attribute (*IF_CURRENT = Parsetree.attribute *) = {\n attr_name : string loc;\n attr_payload : payload;\n attr_loc : Location.t;\n }\n (* [@id ARG]\n [@@id ARG]\n\n Metadata containers passed around within the AST.\n The compiler ignores unknown attributes.\n *)\n\n and extension = string loc * payload\n (* [%id ARG]\n [%%id ARG]\n\n Sub-language placeholder -- rejected by the typechecker.\n *)\n\n and attributes = attribute list\n\n and payload (*IF_CURRENT = Parsetree.payload *) =\n | PStr of structure\n | PSig of signature (* : SIG *)\n | PTyp of core_type (* : T *)\n | PPat of pattern * expression option (* ? P or ? P when E *)\n\n (** {1 Core language} *)\n\n (* Type expressions *)\n\n and core_type (*IF_CURRENT = Parsetree.core_type *) =\n {\n ptyp_desc: core_type_desc;\n ptyp_loc: Location.t;\n ptyp_loc_stack: location_stack;\n ptyp_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and core_type_desc (*IF_CURRENT = Parsetree.core_type_desc *) =\n | Ptyp_any\n (* _ *)\n | Ptyp_var of string\n (* 'a *)\n | Ptyp_arrow of arg_label * core_type * core_type\n (* T1 -> T2 Simple\n ~l:T1 -> T2 Labelled\n ?l:T1 -> T2 Optional\n *)\n | Ptyp_tuple of core_type list\n (* T1 * ... * Tn\n\n Invariant: n >= 2\n *)\n | Ptyp_constr of Longident.t loc * core_type list\n (* tconstr\n T tconstr\n (T1, ..., Tn) tconstr\n *)\n | Ptyp_object of object_field list * closed_flag\n (* < l1:T1; ...; ln:Tn > (flag = Closed)\n < l1:T1; ...; ln:Tn; .. > (flag = Open)\n *)\n | Ptyp_class of Longident.t loc * core_type list\n (* #tconstr\n T #tconstr\n (T1, ..., Tn) #tconstr\n *)\n | Ptyp_alias of core_type * string\n (* T as 'a *)\n | Ptyp_variant of row_field list * closed_flag * label list option\n (* [ `A|`B ] (flag = Closed; labels = None)\n [> `A|`B ] (flag = Open; labels = None)\n [< `A|`B ] (flag = Closed; labels = Some [])\n [< `A|`B > `X `Y ](flag = Closed; labels = Some [\"X\";\"Y\"])\n *)\n | Ptyp_poly of string loc list * core_type\n (* 'a1 ... 'an. T\n\n Can only appear in the following context:\n\n - As the core_type of a Ppat_constraint node corresponding\n to a constraint on a let-binding: let x : 'a1 ... 'an. T\n = e ...\n\n - Under Cfk_virtual for methods (not values).\n\n - As the core_type of a Pctf_method node.\n\n - As the core_type of a Pexp_poly node.\n\n - As the pld_type field of a label_declaration.\n\n - As a core_type of a Ptyp_object node.\n\n - As the pval_type field of a value_description.\n *)\n\n | Ptyp_package of package_type\n (* (module S) *)\n | Ptyp_extension of extension\n (* [%id] *)\n\n and package_type = Longident.t loc * (Longident.t loc * core_type) list\n (*\n (module S)\n (module S with type t1 = T1 and ... and tn = Tn)\n *)\n\n and row_field (*IF_CURRENT = Parsetree.row_field *) = {\n prf_desc : row_field_desc;\n prf_loc : Location.t;\n prf_attributes : attributes;\n }\n\n and row_field_desc (*IF_CURRENT = Parsetree.row_field_desc *) =\n | Rtag of label loc * bool * core_type list\n (* [`A] ( true, [] )\n [`A of T] ( false, [T] )\n [`A of T1 & .. & Tn] ( false, [T1;...Tn] )\n [`A of & T1 & .. & Tn] ( true, [T1;...Tn] )\n\n - The 'bool' field is true if the tag contains a\n constant (empty) constructor.\n - '&' occurs when several types are used for the same constructor\n (see 4.2 in the manual)\n *)\n | Rinherit of core_type\n (* [ | t ] *)\n\n and object_field (*IF_CURRENT = Parsetree.object_field *) = {\n pof_desc : object_field_desc;\n pof_loc : Location.t;\n pof_attributes : attributes;\n }\n\n and object_field_desc (*IF_CURRENT = Parsetree.object_field_desc *) =\n | Otag of label loc * core_type\n | Oinherit of core_type\n\n (* Patterns *)\n\n and pattern (*IF_CURRENT = Parsetree.pattern *) =\n {\n ppat_desc: pattern_desc;\n ppat_loc: Location.t;\n ppat_loc_stack: location_stack;\n ppat_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and pattern_desc (*IF_CURRENT = Parsetree.pattern_desc *) =\n | Ppat_any\n (* _ *)\n | Ppat_var of string loc\n (* x *)\n | Ppat_alias of pattern * string loc\n (* P as 'a *)\n | Ppat_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Ppat_interval of constant * constant\n (* 'a'..'z'\n\n Other forms of interval are recognized by the parser\n but rejected by the type-checker. *)\n | Ppat_tuple of pattern list\n (* (P1, ..., Pn)\n\n Invariant: n >= 2\n *)\n | Ppat_construct of Longident.t loc * (string loc list * pattern) option\n (* C None\n C P Some ([], P)\n C (P1, ..., Pn) Some ([], Ppat_tuple [P1; ...; Pn])\n C (type a b) P Some ([a; b], P)\n *)\n | Ppat_variant of label * pattern option\n (* `A (None)\n `A P (Some P)\n *)\n | Ppat_record of (Longident.t loc * pattern) list * closed_flag\n (* { l1=P1; ...; ln=Pn } (flag = Closed)\n { l1=P1; ...; ln=Pn; _} (flag = Open)\n\n Invariant: n > 0\n *)\n | Ppat_array of pattern list\n (* [| P1; ...; Pn |] *)\n | Ppat_or of pattern * pattern\n (* P1 | P2 *)\n | Ppat_constraint of pattern * core_type\n (* (P : T) *)\n | Ppat_type of Longident.t loc\n (* #tconst *)\n | Ppat_lazy of pattern\n (* lazy P *)\n | Ppat_unpack of string option loc\n (* (module P) Some \"P\"\n (module _) None\n\n Note: (module P : S) is represented as\n Ppat_constraint(Ppat_unpack, Ptyp_package)\n *)\n | Ppat_exception of pattern\n (* exception P *)\n | Ppat_extension of extension\n (* [%id] *)\n | Ppat_open of Longident.t loc * pattern\n (* M.(P) *)\n\n (* Value expressions *)\n\n and expression (*IF_CURRENT = Parsetree.expression *) =\n {\n pexp_desc: expression_desc;\n pexp_loc: Location.t;\n pexp_loc_stack: location_stack;\n pexp_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and expression_desc (*IF_CURRENT = Parsetree.expression_desc *) =\n | Pexp_ident of Longident.t loc\n (* x\n M.x\n *)\n | Pexp_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Pexp_let of rec_flag * value_binding list * expression\n (* let P1 = E1 and ... and Pn = EN in E (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in E (flag = Recursive)\n *)\n | Pexp_function of case list\n (* function P1 -> E1 | ... | Pn -> En *)\n | Pexp_fun of arg_label * expression option * pattern * expression\n (* fun P -> E1 (Simple, None)\n fun ~l:P -> E1 (Labelled l, None)\n fun ?l:P -> E1 (Optional l, None)\n fun ?l:(P = E0) -> E1 (Optional l, Some E0)\n\n Notes:\n - If E0 is provided, only Optional is allowed.\n - \"fun P1 P2 .. Pn -> E1\" is represented as nested Pexp_fun.\n - \"let f P = E\" is represented using Pexp_fun.\n *)\n | Pexp_apply of expression * (arg_label * expression) list\n (* E0 ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pexp_match of expression * case list\n (* match E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_try of expression * case list\n (* try E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_tuple of expression list\n (* (E1, ..., En)\n\n Invariant: n >= 2\n *)\n | Pexp_construct of Longident.t loc * expression option\n (* C None\n C E Some E\n C (E1, ..., En) Some (Pexp_tuple[E1;...;En])\n *)\n | Pexp_variant of label * expression option\n (* `A (None)\n `A E (Some E)\n *)\n | Pexp_record of (Longident.t loc * expression) list * expression option\n (* { l1=P1; ...; ln=Pn } (None)\n { E0 with l1=P1; ...; ln=Pn } (Some E0)\n\n Invariant: n > 0\n *)\n | Pexp_field of expression * Longident.t loc\n (* E.l *)\n | Pexp_setfield of expression * Longident.t loc * expression\n (* E1.l <- E2 *)\n | Pexp_array of expression list\n (* [| E1; ...; En |] *)\n | Pexp_ifthenelse of expression * expression * expression option\n (* if E1 then E2 else E3 *)\n | Pexp_sequence of expression * expression\n (* E1; E2 *)\n | Pexp_while of expression * expression\n (* while E1 do E2 done *)\n | Pexp_for of\n pattern * expression * expression * direction_flag * expression\n (* for i = E1 to E2 do E3 done (flag = Upto)\n for i = E1 downto E2 do E3 done (flag = Downto)\n *)\n | Pexp_constraint of expression * core_type\n (* (E : T) *)\n | Pexp_coerce of expression * core_type option * core_type\n (* (E :> T) (None, T)\n (E : T0 :> T) (Some T0, T)\n *)\n | Pexp_send of expression * label loc\n (* E # m *)\n | Pexp_new of Longident.t loc\n (* new M.c *)\n | Pexp_setinstvar of label loc * expression\n (* x <- 2 *)\n | Pexp_override of (label loc * expression) list\n (* {< x1 = E1; ...; Xn = En >} *)\n | Pexp_letmodule of string option loc * module_expr * expression\n (* let module M = ME in E *)\n | Pexp_letexception of extension_constructor * expression\n (* let exception C in E *)\n | Pexp_assert of expression\n (* assert E\n Note: \"assert false\" is treated in a special way by the\n type-checker. *)\n | Pexp_lazy of expression\n (* lazy E *)\n | Pexp_poly of expression * core_type option\n (* Used for method bodies.\n\n Can only be used as the expression under Cfk_concrete\n for methods (not values). *)\n | Pexp_object of class_structure\n (* object ... end *)\n | Pexp_newtype of string loc * expression\n (* fun (type t) -> E *)\n | Pexp_pack of module_expr\n (* (module ME)\n\n (module ME : S) is represented as\n Pexp_constraint(Pexp_pack, Ptyp_package S) *)\n | Pexp_open of open_declaration * expression\n (* M.(E)\n let open M in E\n let! open M in E *)\n | Pexp_letop of letop\n (* let* P = E in E\n let* P = E and* P = E in E *)\n | Pexp_extension of extension\n (* [%id] *)\n | Pexp_unreachable\n (* . *)\n\n and case (*IF_CURRENT = Parsetree.case *) = (* (P -> E) or (P when E0 -> E) *)\n {\n pc_lhs: pattern;\n pc_guard: expression option;\n pc_rhs: expression;\n }\n\n and letop (*IF_CURRENT = Parsetree.letop *) =\n {\n let_ : binding_op;\n ands : binding_op list;\n body : expression;\n }\n\n and binding_op (*IF_CURRENT = Parsetree.binding_op *) =\n {\n pbop_op : string loc;\n pbop_pat : pattern;\n pbop_exp : expression;\n pbop_loc : Location.t;\n }\n\n (* Value descriptions *)\n\n and value_description (*IF_CURRENT = Parsetree.value_description *) =\n {\n pval_name: string loc;\n pval_type: core_type;\n pval_prim: string list;\n pval_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pval_loc: Location.t;\n }\n\n(*\n val x: T (prim = [])\n external x: T = \"s1\" ... \"sn\" (prim = [\"s1\";...\"sn\"])\n*)\n\n (* Type declarations *)\n\n and type_declaration (*IF_CURRENT = Parsetree.type_declaration *) =\n {\n ptype_name: string loc;\n ptype_params: (core_type * (variance * injectivity)) list;\n (* ('a1,...'an) t; None represents _*)\n ptype_cstrs: (core_type * core_type * Location.t) list;\n (* ... constraint T1=T1' ... constraint Tn=Tn' *)\n ptype_kind: type_kind;\n ptype_private: private_flag; (* = private ... *)\n ptype_manifest: core_type option; (* = T *)\n ptype_attributes: attributes; (* ... [@@id1] [@@id2] *)\n ptype_loc: Location.t;\n }\n\n(*\n type t (abstract, no manifest)\n type t = T0 (abstract, manifest=T0)\n type t = C of T | ... (variant, no manifest)\n type t = T0 = C of T | ... (variant, manifest=T0)\n type t = {l: T; ...} (record, no manifest)\n type t = T0 = {l : T; ...} (record, manifest=T0)\n type t = .. (open, no manifest)\n*)\n\n and type_kind (*IF_CURRENT = Parsetree.type_kind *) =\n | Ptype_abstract\n | Ptype_variant of constructor_declaration list\n | Ptype_record of label_declaration list\n (* Invariant: non-empty list *)\n | Ptype_open\n\n and label_declaration (*IF_CURRENT = Parsetree.label_declaration *) =\n {\n pld_name: string loc;\n pld_mutable: mutable_flag;\n pld_type: core_type;\n pld_loc: Location.t;\n pld_attributes: attributes; (* l : T [@id1] [@id2] *)\n }\n\n (* { ...; l: T; ... } (mutable=Immutable)\n { ...; mutable l: T; ... } (mutable=Mutable)\n\n Note: T can be a Ptyp_poly.\n *)\n\n and constructor_declaration (*IF_CURRENT = Parsetree.constructor_declaration *) =\n {\n pcd_name: string loc;\n pcd_vars: string loc list;\n pcd_args: constructor_arguments;\n pcd_res: core_type option;\n pcd_loc: Location.t;\n pcd_attributes: attributes; (* C of ... [@id1] [@id2] *)\n }\n\n and constructor_arguments (*IF_CURRENT = Parsetree.constructor_arguments *) =\n | Pcstr_tuple of core_type list\n | Pcstr_record of label_declaration list\n\n(*\n | C of T1 * ... * Tn (res = None, args = Pcstr_tuple [])\n | C: T0 (res = Some T0, args = [])\n | C: T1 * ... * Tn -> T0 (res = Some T0, args = Pcstr_tuple)\n | C of {...} (res = None, args = Pcstr_record)\n | C: {...} -> T0 (res = Some T0, args = Pcstr_record)\n | C of {...} as t (res = None, args = Pcstr_record)\n*)\n\n and type_extension (*IF_CURRENT = Parsetree.type_extension *) =\n {\n ptyext_path: Longident.t loc;\n ptyext_params: (core_type * (variance * injectivity)) list;\n ptyext_constructors: extension_constructor list;\n ptyext_private: private_flag;\n ptyext_loc: Location.t;\n ptyext_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n(*\n type t += ...\n*)\n\n and extension_constructor (*IF_CURRENT = Parsetree.extension_constructor *) =\n {\n pext_name: string loc;\n pext_kind : extension_constructor_kind;\n pext_loc : Location.t;\n pext_attributes: attributes; (* C of ... [@id1] [@id2] *)\n }\n\n (* exception E *)\n and type_exception (*IF_CURRENT = Parsetree.type_exception *) =\n {\n ptyexn_constructor: extension_constructor;\n ptyexn_loc: Location.t;\n ptyexn_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and extension_constructor_kind (*IF_CURRENT = Parsetree.extension_constructor_kind *) =\n Pext_decl of string loc list * constructor_arguments * core_type option\n (*\n | C of T1 * ... * Tn ([], [T1; ...; Tn], None)\n | C: T0 ([], [], Some T0)\n | C: T1 * ... * Tn -> T0 ([], [T1; ...; Tn], Some T0)\n | C: 'a... . T1... -> T0 (['a;...]; [T1;...], Some T0)\n *)\n | Pext_rebind of Longident.t loc\n (*\n | C = D\n *)\n\n (** {1 Class language} *)\n\n (* Type expressions for the class language *)\n\n and class_type (*IF_CURRENT = Parsetree.class_type *) =\n {\n pcty_desc: class_type_desc;\n pcty_loc: Location.t;\n pcty_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and class_type_desc (*IF_CURRENT = Parsetree.class_type_desc *) =\n | Pcty_constr of Longident.t loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcty_signature of class_signature\n (* object ... end *)\n | Pcty_arrow of arg_label * core_type * class_type\n (* T -> CT Simple\n ~l:T -> CT Labelled l\n ?l:T -> CT Optional l\n *)\n | Pcty_extension of extension\n (* [%id] *)\n | Pcty_open of open_description * class_type\n (* let open M in CT *)\n\n and class_signature (*IF_CURRENT = Parsetree.class_signature *) =\n {\n pcsig_self: core_type;\n pcsig_fields: class_type_field list;\n }\n (* object('selfpat) ... end\n object ... end (self = Ptyp_any)\n *)\n\n and class_type_field (*IF_CURRENT = Parsetree.class_type_field *) =\n {\n pctf_desc: class_type_field_desc;\n pctf_loc: Location.t;\n pctf_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and class_type_field_desc (*IF_CURRENT = Parsetree.class_type_field_desc *) =\n | Pctf_inherit of class_type\n (* inherit CT *)\n | Pctf_val of (label loc * mutable_flag * virtual_flag * core_type)\n (* val x: T *)\n | Pctf_method of (label loc * private_flag * virtual_flag * core_type)\n (* method x: T\n\n Note: T can be a Ptyp_poly.\n *)\n | Pctf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pctf_attribute of attribute\n (* [@@@id] *)\n | Pctf_extension of extension\n (* [%%id] *)\n\n and 'a class_infos (*IF_CURRENT = 'a Parsetree.class_infos *) =\n {\n pci_virt: virtual_flag;\n pci_params: (core_type * (variance * injectivity)) list;\n pci_name: string loc;\n pci_expr: 'a;\n pci_loc: Location.t;\n pci_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n (* class c = ...\n class ['a1,...,'an] c = ...\n class virtual c = ...\n\n Also used for \"class type\" declaration.\n *)\n\n and class_description = class_type class_infos\n\n and class_type_declaration = class_type class_infos\n\n (* Value expressions for the class language *)\n\n and class_expr (*IF_CURRENT = Parsetree.class_expr *) =\n {\n pcl_desc: class_expr_desc;\n pcl_loc: Location.t;\n pcl_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and class_expr_desc (*IF_CURRENT = Parsetree.class_expr_desc *) =\n | Pcl_constr of Longident.t loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcl_structure of class_structure\n (* object ... end *)\n | Pcl_fun of arg_label * expression option * pattern * class_expr\n (* fun P -> CE (Simple, None)\n fun ~l:P -> CE (Labelled l, None)\n fun ?l:P -> CE (Optional l, None)\n fun ?l:(P = E0) -> CE (Optional l, Some E0)\n *)\n | Pcl_apply of class_expr * (arg_label * expression) list\n (* CE ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pcl_let of rec_flag * value_binding list * class_expr\n (* let P1 = E1 and ... and Pn = EN in CE (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in CE (flag = Recursive)\n *)\n | Pcl_constraint of class_expr * class_type\n (* (CE : CT) *)\n | Pcl_extension of extension\n (* [%id] *)\n | Pcl_open of open_description * class_expr\n (* let open M in CE *)\n\n\n and class_structure (*IF_CURRENT = Parsetree.class_structure *) =\n {\n pcstr_self: pattern;\n pcstr_fields: class_field list;\n }\n (* object(selfpat) ... end\n object ... end (self = Ppat_any)\n *)\n\n and class_field (*IF_CURRENT = Parsetree.class_field *) =\n {\n pcf_desc: class_field_desc;\n pcf_loc: Location.t;\n pcf_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and class_field_desc (*IF_CURRENT = Parsetree.class_field_desc *) =\n | Pcf_inherit of override_flag * class_expr * string loc option\n (* inherit CE\n inherit CE as x\n inherit! CE\n inherit! CE as x\n *)\n | Pcf_val of (label loc * mutable_flag * class_field_kind)\n (* val x = E\n val virtual x: T\n *)\n | Pcf_method of (label loc * private_flag * class_field_kind)\n (* method x = E (E can be a Pexp_poly)\n method virtual x: T (T can be a Ptyp_poly)\n *)\n | Pcf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pcf_initializer of expression\n (* initializer E *)\n | Pcf_attribute of attribute\n (* [@@@id] *)\n | Pcf_extension of extension\n (* [%%id] *)\n\n and class_field_kind (*IF_CURRENT = Parsetree.class_field_kind *) =\n | Cfk_virtual of core_type\n | Cfk_concrete of override_flag * expression\n\n and class_declaration = class_expr class_infos\n\n (** {1 Module language} *)\n\n (* Type expressions for the module language *)\n\n and module_type (*IF_CURRENT = Parsetree.module_type *) =\n {\n pmty_desc: module_type_desc;\n pmty_loc: Location.t;\n pmty_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and module_type_desc (*IF_CURRENT = Parsetree.module_type_desc *) =\n | Pmty_ident of Longident.t loc\n (* S *)\n | Pmty_signature of signature\n (* sig ... end *)\n | Pmty_functor of functor_parameter * module_type\n (* functor(X : MT1) -> MT2 *)\n | Pmty_with of module_type * with_constraint list\n (* MT with ... *)\n | Pmty_typeof of module_expr\n (* module type of ME *)\n | Pmty_extension of extension\n (* [%id] *)\n | Pmty_alias of Longident.t loc\n (* (module M) *)\n\n and functor_parameter (*IF_CURRENT = Parsetree.functor_parameter *) =\n | Unit\n (* () *)\n | Named of string option loc * module_type\n (* (X : MT) Some X, MT\n (_ : MT) None, MT *)\n\n and signature = signature_item list\n\n and signature_item (*IF_CURRENT = Parsetree.signature_item *) =\n {\n psig_desc: signature_item_desc;\n psig_loc: Location.t;\n }\n\n and signature_item_desc (*IF_CURRENT = Parsetree.signature_item_desc *) =\n | Psig_value of value_description\n (*\n val x: T\n external x: T = \"s1\" ... \"sn\"\n *)\n | Psig_type of rec_flag * type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Psig_typesubst of type_declaration list\n (* type t1 := ... and ... and tn := ... *)\n | Psig_typext of type_extension\n (* type t1 += ... *)\n | Psig_exception of type_exception\n (* exception C of T *)\n | Psig_module of module_declaration\n (* module X = M\n module X : MT *)\n | Psig_modsubst of module_substitution\n (* module X := M *)\n | Psig_recmodule of module_declaration list\n (* module rec X1 : MT1 and ... and Xn : MTn *)\n | Psig_modtype of module_type_declaration\n (* module type S = MT\n module type S *)\n | Psig_modtypesubst of module_type_declaration\n (* module type S := ... *)\n | Psig_open of open_description\n (* open X *)\n | Psig_include of include_description\n (* include MT *)\n | Psig_class of class_description list\n (* class c1 : ... and ... and cn : ... *)\n | Psig_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Psig_attribute of attribute\n (* [@@@id] *)\n | Psig_extension of extension * attributes\n (* [%%id] *)\n\n and module_declaration (*IF_CURRENT = Parsetree.module_declaration *) =\n {\n pmd_name: string option loc;\n pmd_type: module_type;\n pmd_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pmd_loc: Location.t;\n }\n (* S : MT *)\n\n and module_substitution (*IF_CURRENT = Parsetree.module_substitution *) =\n {\n pms_name: string loc;\n pms_manifest: Longident.t loc;\n pms_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pms_loc: Location.t;\n }\n\n and module_type_declaration (*IF_CURRENT = Parsetree.module_type_declaration *) =\n {\n pmtd_name: string loc;\n pmtd_type: module_type option;\n pmtd_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pmtd_loc: Location.t;\n }\n (* S = MT\n S (abstract module type declaration, pmtd_type = None)\n *)\n\n and 'a open_infos (*IF_CURRENT = 'a Parsetree.open_infos *) =\n {\n popen_expr: 'a;\n popen_override: override_flag;\n popen_loc: Location.t;\n popen_attributes: attributes;\n }\n (* open! X - popen_override = Override (silences the 'used identifier\n shadowing' warning)\n open X - popen_override = Fresh\n *)\n\n and open_description = Longident.t loc open_infos\n (* open M.N\n open M(N).O *)\n\n and open_declaration = module_expr open_infos\n (* open M.N\n open M(N).O\n open struct ... end *)\n\n and 'a include_infos (*IF_CURRENT = 'a Parsetree.include_infos *) =\n {\n pincl_mod: 'a;\n pincl_loc: Location.t;\n pincl_attributes: attributes;\n }\n\n and include_description = module_type include_infos\n (* include MT *)\n\n and include_declaration = module_expr include_infos\n (* include ME *)\n\n and with_constraint (*IF_CURRENT = Parsetree.with_constraint *) =\n | Pwith_type of Longident.t loc * type_declaration\n (* with type X.t = ...\n\n Note: the last component of the longident must match\n the name of the type_declaration. *)\n | Pwith_module of Longident.t loc * Longident.t loc\n (* with module X.Y = Z *)\n | Pwith_modtype of Longident.t loc * module_type\n (* with module type X.Y = Z *)\n | Pwith_modtypesubst of Longident.t loc * module_type\n (* with module type X.Y := sig end *)\n | Pwith_typesubst of Longident.t loc * type_declaration\n (* with type X.t := ..., same format as [Pwith_type] *)\n | Pwith_modsubst of Longident.t loc * Longident.t loc\n (* with module X.Y := Z *)\n\n (* Value expressions for the module language *)\n\n and module_expr (*IF_CURRENT = Parsetree.module_expr *) =\n {\n pmod_desc: module_expr_desc;\n pmod_loc: Location.t;\n pmod_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and module_expr_desc (*IF_CURRENT = Parsetree.module_expr_desc *) =\n | Pmod_ident of Longident.t loc\n (* X *)\n | Pmod_structure of structure\n (* struct ... end *)\n | Pmod_functor of functor_parameter * module_expr\n (* functor(X : MT1) -> ME *)\n | Pmod_apply of module_expr * module_expr\n (* ME1(ME2) *)\n | Pmod_constraint of module_expr * module_type\n (* (ME : MT) *)\n | Pmod_unpack of expression\n (* (val E) *)\n | Pmod_extension of extension\n (* [%id] *)\n\n and structure = structure_item list\n\n and structure_item (*IF_CURRENT = Parsetree.structure_item *) =\n {\n pstr_desc: structure_item_desc;\n pstr_loc: Location.t;\n }\n\n and structure_item_desc (*IF_CURRENT = Parsetree.structure_item_desc *) =\n | Pstr_eval of expression * attributes\n (* E *)\n | Pstr_value of rec_flag * value_binding list\n (* let P1 = E1 and ... and Pn = EN (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN (flag = Recursive)\n *)\n | Pstr_primitive of value_description\n (* val x: T\n external x: T = \"s1\" ... \"sn\" *)\n | Pstr_type of rec_flag * type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Pstr_typext of type_extension\n (* type t1 += ... *)\n | Pstr_exception of type_exception\n (* exception C of T\n exception C = M.X *)\n | Pstr_module of module_binding\n (* module X = ME *)\n | Pstr_recmodule of module_binding list\n (* module rec X1 = ME1 and ... and Xn = MEn *)\n | Pstr_modtype of module_type_declaration\n (* module type S = MT *)\n | Pstr_open of open_declaration\n (* open X *)\n | Pstr_class of class_declaration list\n (* class c1 = ... and ... and cn = ... *)\n | Pstr_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Pstr_include of include_declaration\n (* include ME *)\n | Pstr_attribute of attribute\n (* [@@@id] *)\n | Pstr_extension of extension * attributes\n (* [%%id] *)\n\n and value_binding (*IF_CURRENT = Parsetree.value_binding *) =\n {\n pvb_pat: pattern;\n pvb_expr: expression;\n pvb_attributes: attributes;\n pvb_loc: Location.t;\n }\n\n and module_binding (*IF_CURRENT = Parsetree.module_binding *) =\n {\n pmb_name: string option loc;\n pmb_expr: module_expr;\n pmb_attributes: attributes;\n pmb_loc: Location.t;\n }\n (* X = ME *)\n\n (** {1 Toplevel} *)\n\n (* Toplevel phrases *)\n\n type toplevel_phrase (*IF_CURRENT = Parsetree.toplevel_phrase *) =\n | Ptop_def of structure\n | Ptop_dir of toplevel_directive\n (* #use, #load ... *)\n\n and toplevel_directive (*IF_CURRENT = Parsetree.toplevel_directive *) =\n {\n pdir_name : string loc;\n pdir_arg : directive_argument option;\n pdir_loc : Location.t;\n }\n\n and directive_argument (*IF_CURRENT = Parsetree.directive_argument *) =\n {\n pdira_desc : directive_argument_desc;\n pdira_loc : Location.t;\n }\n\n and directive_argument_desc (*IF_CURRENT = Parsetree.directive_argument_desc *) =\n | Pdir_string of string\n | Pdir_int of string * char option\n | Pdir_ident of Longident.t\n | Pdir_bool of bool\nend\n\nmodule Config = struct\n let ast_impl_magic_number = \"Caml1999M031\"\n let ast_intf_magic_number = \"Caml1999N031\"\nend\n","(**************************************************************************)\n(* *)\n(* OCaml Migrate Parsetree *)\n(* *)\n(* Frédéric Bour, Facebook *)\n(* Jérémie Dimino and Leo White, Jane Street Europe *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* Alain Frisch, LexiFi *)\n(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 2018 Institut National de Recherche en Informatique et *)\n(* en Automatique (INRIA). *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nmodule Asttypes = struct\n type constant (*IF_CURRENT = Asttypes.constant *) =\n Const_int of int\n | Const_char of char\n | Const_string of string * Location.t * string option\n | Const_float of string\n | Const_int32 of int32\n | Const_int64 of int64\n | Const_nativeint of nativeint\n\n type rec_flag (*IF_CURRENT = Asttypes.rec_flag *) = Nonrecursive | Recursive\n\n type direction_flag (*IF_CURRENT = Asttypes.direction_flag *) = Upto | Downto\n\n (* Order matters, used in polymorphic comparison *)\n type private_flag (*IF_CURRENT = Asttypes.private_flag *) = Private | Public\n\n type mutable_flag (*IF_CURRENT = Asttypes.mutable_flag *) = Immutable | Mutable\n\n type virtual_flag (*IF_CURRENT = Asttypes.virtual_flag *) = Virtual | Concrete\n\n type override_flag (*IF_CURRENT = Asttypes.override_flag *) = Override | Fresh\n\n type closed_flag (*IF_CURRENT = Asttypes.closed_flag *) = Closed | Open\n\n type label = string\n\n type arg_label (*IF_CURRENT = Asttypes.arg_label *) =\n Nolabel\n | Labelled of string (* label:T -> ... *)\n | Optional of string (* ?label:T -> ... *)\n\n type 'a loc = 'a Location.loc = {\n txt : 'a;\n loc : Location.t;\n }\n\n\n type variance (*IF_CURRENT = Asttypes.variance *) =\n | Covariant\n | Contravariant\n | Invariant\nend\n\nmodule Parsetree = struct\n open Asttypes\n\n type constant (*IF_CURRENT = Parsetree.constant *) =\n Pconst_integer of string * char option\n (* 3 3l 3L 3n\n\n Suffixes [g-z][G-Z] are accepted by the parser.\n Suffixes except 'l', 'L' and 'n' are rejected by the typechecker\n *)\n | Pconst_char of char\n (* 'c' *)\n | Pconst_string of string * Location.t * string option\n (* \"constant\"\n {delim|other constant|delim}\n\n The location span the content of the string, without the delimiters.\n *)\n | Pconst_float of string * char option\n (* 3.4 2e5 1.4e-4\n\n Suffixes [g-z][G-Z] are accepted by the parser.\n Suffixes are rejected by the typechecker.\n *)\n\n type location_stack = Location.t list\n\n (** {1 Extension points} *)\n\n type attribute (*IF_CURRENT = Parsetree.attribute *) = {\n attr_name : string loc;\n attr_payload : payload;\n attr_loc : Location.t;\n }\n (* [@id ARG]\n [@@id ARG]\n\n Metadata containers passed around within the AST.\n The compiler ignores unknown attributes.\n *)\n\n and extension = string loc * payload\n (* [%id ARG]\n [%%id ARG]\n\n Sub-language placeholder -- rejected by the typechecker.\n *)\n\n and attributes = attribute list\n\n and payload (*IF_CURRENT = Parsetree.payload *) =\n | PStr of structure\n | PSig of signature (* : SIG *)\n | PTyp of core_type (* : T *)\n | PPat of pattern * expression option (* ? P or ? P when E *)\n\n (** {1 Core language} *)\n\n (* Type expressions *)\n\n and core_type (*IF_CURRENT = Parsetree.core_type *) =\n {\n ptyp_desc: core_type_desc;\n ptyp_loc: Location.t;\n ptyp_loc_stack: location_stack;\n ptyp_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and core_type_desc (*IF_CURRENT = Parsetree.core_type_desc *) =\n | Ptyp_any\n (* _ *)\n | Ptyp_var of string\n (* 'a *)\n | Ptyp_arrow of arg_label * core_type * core_type\n (* T1 -> T2 Simple\n ~l:T1 -> T2 Labelled\n ?l:T1 -> T2 Optional\n *)\n | Ptyp_tuple of core_type list\n (* T1 * ... * Tn\n\n Invariant: n >= 2\n *)\n | Ptyp_constr of Longident.t loc * core_type list\n (* tconstr\n T tconstr\n (T1, ..., Tn) tconstr\n *)\n | Ptyp_object of object_field list * closed_flag\n (* < l1:T1; ...; ln:Tn > (flag = Closed)\n < l1:T1; ...; ln:Tn; .. > (flag = Open)\n *)\n | Ptyp_class of Longident.t loc * core_type list\n (* #tconstr\n T #tconstr\n (T1, ..., Tn) #tconstr\n *)\n | Ptyp_alias of core_type * string\n (* T as 'a *)\n | Ptyp_variant of row_field list * closed_flag * label list option\n (* [ `A|`B ] (flag = Closed; labels = None)\n [> `A|`B ] (flag = Open; labels = None)\n [< `A|`B ] (flag = Closed; labels = Some [])\n [< `A|`B > `X `Y ](flag = Closed; labels = Some [\"X\";\"Y\"])\n *)\n | Ptyp_poly of string loc list * core_type\n (* 'a1 ... 'an. T\n\n Can only appear in the following context:\n\n - As the core_type of a Ppat_constraint node corresponding\n to a constraint on a let-binding: let x : 'a1 ... 'an. T\n = e ...\n\n - Under Cfk_virtual for methods (not values).\n\n - As the core_type of a Pctf_method node.\n\n - As the core_type of a Pexp_poly node.\n\n - As the pld_type field of a label_declaration.\n\n - As a core_type of a Ptyp_object node.\n *)\n\n | Ptyp_package of package_type\n (* (module S) *)\n | Ptyp_extension of extension\n (* [%id] *)\n\n and package_type = Longident.t loc * (Longident.t loc * core_type) list\n (*\n (module S)\n (module S with type t1 = T1 and ... and tn = Tn)\n *)\n\n and row_field (*IF_CURRENT = Parsetree.row_field *) = {\n prf_desc : row_field_desc;\n prf_loc : Location.t;\n prf_attributes : attributes;\n }\n\n and row_field_desc (*IF_CURRENT = Parsetree.row_field_desc *) =\n | Rtag of label loc * bool * core_type list\n (* [`A] ( true, [] )\n [`A of T] ( false, [T] )\n [`A of T1 & .. & Tn] ( false, [T1;...Tn] )\n [`A of & T1 & .. & Tn] ( true, [T1;...Tn] )\n\n - The 'bool' field is true if the tag contains a\n constant (empty) constructor.\n - '&' occurs when several types are used for the same constructor\n (see 4.2 in the manual)\n *)\n | Rinherit of core_type\n (* [ T ] *)\n\n and object_field (*IF_CURRENT = Parsetree.object_field *) = {\n pof_desc : object_field_desc;\n pof_loc : Location.t;\n pof_attributes : attributes;\n }\n\n and object_field_desc (*IF_CURRENT = Parsetree.object_field_desc *) =\n | Otag of label loc * core_type\n | Oinherit of core_type\n\n (* Patterns *)\n\n and pattern (*IF_CURRENT = Parsetree.pattern *) =\n {\n ppat_desc: pattern_desc;\n ppat_loc: Location.t;\n ppat_loc_stack: location_stack;\n ppat_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and pattern_desc (*IF_CURRENT = Parsetree.pattern_desc *) =\n | Ppat_any\n (* _ *)\n | Ppat_var of string loc\n (* x *)\n | Ppat_alias of pattern * string loc\n (* P as 'a *)\n | Ppat_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Ppat_interval of constant * constant\n (* 'a'..'z'\n\n Other forms of interval are recognized by the parser\n but rejected by the type-checker. *)\n | Ppat_tuple of pattern list\n (* (P1, ..., Pn)\n\n Invariant: n >= 2\n *)\n | Ppat_construct of Longident.t loc * pattern option\n (* C None\n C P Some P\n C (P1, ..., Pn) Some (Ppat_tuple [P1; ...; Pn])\n *)\n | Ppat_variant of label * pattern option\n (* `A (None)\n `A P (Some P)\n *)\n | Ppat_record of (Longident.t loc * pattern) list * closed_flag\n (* { l1=P1; ...; ln=Pn } (flag = Closed)\n { l1=P1; ...; ln=Pn; _} (flag = Open)\n\n Invariant: n > 0\n *)\n | Ppat_array of pattern list\n (* [| P1; ...; Pn |] *)\n | Ppat_or of pattern * pattern\n (* P1 | P2 *)\n | Ppat_constraint of pattern * core_type\n (* (P : T) *)\n | Ppat_type of Longident.t loc\n (* #tconst *)\n | Ppat_lazy of pattern\n (* lazy P *)\n | Ppat_unpack of string option loc\n (* (module P) Some \"P\"\n (module _) None\n\n Note: (module P : S) is represented as\n Ppat_constraint(Ppat_unpack, Ptyp_package)\n *)\n | Ppat_exception of pattern\n (* exception P *)\n | Ppat_extension of extension\n (* [%id] *)\n | Ppat_open of Longident.t loc * pattern\n (* M.(P) *)\n\n (* Value expressions *)\n\n and expression (*IF_CURRENT = Parsetree.expression *) =\n {\n pexp_desc: expression_desc;\n pexp_loc: Location.t;\n pexp_loc_stack: location_stack;\n pexp_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and expression_desc (*IF_CURRENT = Parsetree.expression_desc *) =\n | Pexp_ident of Longident.t loc\n (* x\n M.x\n *)\n | Pexp_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Pexp_let of rec_flag * value_binding list * expression\n (* let P1 = E1 and ... and Pn = EN in E (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in E (flag = Recursive)\n *)\n | Pexp_function of case list\n (* function P1 -> E1 | ... | Pn -> En *)\n | Pexp_fun of arg_label * expression option * pattern * expression\n (* fun P -> E1 (Simple, None)\n fun ~l:P -> E1 (Labelled l, None)\n fun ?l:P -> E1 (Optional l, None)\n fun ?l:(P = E0) -> E1 (Optional l, Some E0)\n\n Notes:\n - If E0 is provided, only Optional is allowed.\n - \"fun P1 P2 .. Pn -> E1\" is represented as nested Pexp_fun.\n - \"let f P = E\" is represented using Pexp_fun.\n *)\n | Pexp_apply of expression * (arg_label * expression) list\n (* E0 ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pexp_match of expression * case list\n (* match E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_try of expression * case list\n (* try E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_tuple of expression list\n (* (E1, ..., En)\n\n Invariant: n >= 2\n *)\n | Pexp_construct of Longident.t loc * expression option\n (* C None\n C E Some E\n C (E1, ..., En) Some (Pexp_tuple[E1;...;En])\n *)\n | Pexp_variant of label * expression option\n (* `A (None)\n `A E (Some E)\n *)\n | Pexp_record of (Longident.t loc * expression) list * expression option\n (* { l1=P1; ...; ln=Pn } (None)\n { E0 with l1=P1; ...; ln=Pn } (Some E0)\n\n Invariant: n > 0\n *)\n | Pexp_field of expression * Longident.t loc\n (* E.l *)\n | Pexp_setfield of expression * Longident.t loc * expression\n (* E1.l <- E2 *)\n | Pexp_array of expression list\n (* [| E1; ...; En |] *)\n | Pexp_ifthenelse of expression * expression * expression option\n (* if E1 then E2 else E3 *)\n | Pexp_sequence of expression * expression\n (* E1; E2 *)\n | Pexp_while of expression * expression\n (* while E1 do E2 done *)\n | Pexp_for of\n pattern * expression * expression * direction_flag * expression\n (* for i = E1 to E2 do E3 done (flag = Upto)\n for i = E1 downto E2 do E3 done (flag = Downto)\n *)\n | Pexp_constraint of expression * core_type\n (* (E : T) *)\n | Pexp_coerce of expression * core_type option * core_type\n (* (E :> T) (None, T)\n (E : T0 :> T) (Some T0, T)\n *)\n | Pexp_send of expression * label loc\n (* E # m *)\n | Pexp_new of Longident.t loc\n (* new M.c *)\n | Pexp_setinstvar of label loc * expression\n (* x <- 2 *)\n | Pexp_override of (label loc * expression) list\n (* {< x1 = E1; ...; Xn = En >} *)\n | Pexp_letmodule of string option loc * module_expr * expression\n (* let module M = ME in E *)\n | Pexp_letexception of extension_constructor * expression\n (* let exception C in E *)\n | Pexp_assert of expression\n (* assert E\n Note: \"assert false\" is treated in a special way by the\n type-checker. *)\n | Pexp_lazy of expression\n (* lazy E *)\n | Pexp_poly of expression * core_type option\n (* Used for method bodies.\n\n Can only be used as the expression under Cfk_concrete\n for methods (not values). *)\n | Pexp_object of class_structure\n (* object ... end *)\n | Pexp_newtype of string loc * expression\n (* fun (type t) -> E *)\n | Pexp_pack of module_expr\n (* (module ME)\n\n (module ME : S) is represented as\n Pexp_constraint(Pexp_pack, Ptyp_package S) *)\n | Pexp_open of open_declaration * expression\n (* M.(E)\n let open M in E\n let! open M in E *)\n | Pexp_letop of letop\n (* let* P = E in E\n let* P = E and* P = E in E *)\n | Pexp_extension of extension\n (* [%id] *)\n | Pexp_unreachable\n (* . *)\n\n and case (*IF_CURRENT = Parsetree.case *) = (* (P -> E) or (P when E0 -> E) *)\n {\n pc_lhs: pattern;\n pc_guard: expression option;\n pc_rhs: expression;\n }\n\n and letop (*IF_CURRENT = Parsetree.letop *) =\n {\n let_ : binding_op;\n ands : binding_op list;\n body : expression;\n }\n\n and binding_op (*IF_CURRENT = Parsetree.binding_op *) =\n {\n pbop_op : string loc;\n pbop_pat : pattern;\n pbop_exp : expression;\n pbop_loc : Location.t;\n }\n\n (* Value descriptions *)\n\n and value_description (*IF_CURRENT = Parsetree.value_description *) =\n {\n pval_name: string loc;\n pval_type: core_type;\n pval_prim: string list;\n pval_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pval_loc: Location.t;\n }\n\n(*\n val x: T (prim = [])\n external x: T = \"s1\" ... \"sn\" (prim = [\"s1\";...\"sn\"])\n*)\n\n (* Type declarations *)\n\n and type_declaration (*IF_CURRENT = Parsetree.type_declaration *) =\n {\n ptype_name: string loc;\n ptype_params: (core_type * variance) list;\n (* ('a1,...'an) t; None represents _*)\n ptype_cstrs: (core_type * core_type * Location.t) list;\n (* ... constraint T1=T1' ... constraint Tn=Tn' *)\n ptype_kind: type_kind;\n ptype_private: private_flag; (* = private ... *)\n ptype_manifest: core_type option; (* = T *)\n ptype_attributes: attributes; (* ... [@@id1] [@@id2] *)\n ptype_loc: Location.t;\n }\n\n(*\n type t (abstract, no manifest)\n type t = T0 (abstract, manifest=T0)\n type t = C of T | ... (variant, no manifest)\n type t = T0 = C of T | ... (variant, manifest=T0)\n type t = {l: T; ...} (record, no manifest)\n type t = T0 = {l : T; ...} (record, manifest=T0)\n type t = .. (open, no manifest)\n*)\n\n and type_kind (*IF_CURRENT = Parsetree.type_kind *) =\n | Ptype_abstract\n | Ptype_variant of constructor_declaration list\n | Ptype_record of label_declaration list\n (* Invariant: non-empty list *)\n | Ptype_open\n\n and label_declaration (*IF_CURRENT = Parsetree.label_declaration *) =\n {\n pld_name: string loc;\n pld_mutable: mutable_flag;\n pld_type: core_type;\n pld_loc: Location.t;\n pld_attributes: attributes; (* l : T [@id1] [@id2] *)\n }\n\n (* { ...; l: T; ... } (mutable=Immutable)\n { ...; mutable l: T; ... } (mutable=Mutable)\n\n Note: T can be a Ptyp_poly.\n *)\n\n and constructor_declaration (*IF_CURRENT = Parsetree.constructor_declaration *) =\n {\n pcd_name: string loc;\n pcd_args: constructor_arguments;\n pcd_res: core_type option;\n pcd_loc: Location.t;\n pcd_attributes: attributes; (* C of ... [@id1] [@id2] *)\n }\n\n and constructor_arguments (*IF_CURRENT = Parsetree.constructor_arguments *) =\n | Pcstr_tuple of core_type list\n | Pcstr_record of label_declaration list\n\n(*\n | C of T1 * ... * Tn (res = None, args = Pcstr_tuple [])\n | C: T0 (res = Some T0, args = [])\n | C: T1 * ... * Tn -> T0 (res = Some T0, args = Pcstr_tuple)\n | C of {...} (res = None, args = Pcstr_record)\n | C: {...} -> T0 (res = Some T0, args = Pcstr_record)\n | C of {...} as t (res = None, args = Pcstr_record)\n*)\n\n and type_extension (*IF_CURRENT = Parsetree.type_extension *) =\n {\n ptyext_path: Longident.t loc;\n ptyext_params: (core_type * variance) list;\n ptyext_constructors: extension_constructor list;\n ptyext_private: private_flag;\n ptyext_loc: Location.t;\n ptyext_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n(*\n type t += ...\n*)\n\n and extension_constructor (*IF_CURRENT = Parsetree.extension_constructor *) =\n {\n pext_name: string loc;\n pext_kind : extension_constructor_kind;\n pext_loc : Location.t;\n pext_attributes: attributes; (* C of ... [@id1] [@id2] *)\n }\n\n (* exception E *)\n and type_exception (*IF_CURRENT = Parsetree.type_exception *) =\n {\n ptyexn_constructor: extension_constructor;\n ptyexn_loc: Location.t;\n ptyexn_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and extension_constructor_kind (*IF_CURRENT = Parsetree.extension_constructor_kind *) =\n Pext_decl of constructor_arguments * core_type option\n (*\n | C of T1 * ... * Tn ([T1; ...; Tn], None)\n | C: T0 ([], Some T0)\n | C: T1 * ... * Tn -> T0 ([T1; ...; Tn], Some T0)\n *)\n | Pext_rebind of Longident.t loc\n (*\n | C = D\n *)\n\n (** {1 Class language} *)\n\n (* Type expressions for the class language *)\n\n and class_type (*IF_CURRENT = Parsetree.class_type *) =\n {\n pcty_desc: class_type_desc;\n pcty_loc: Location.t;\n pcty_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and class_type_desc (*IF_CURRENT = Parsetree.class_type_desc *) =\n | Pcty_constr of Longident.t loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcty_signature of class_signature\n (* object ... end *)\n | Pcty_arrow of arg_label * core_type * class_type\n (* T -> CT Simple\n ~l:T -> CT Labelled l\n ?l:T -> CT Optional l\n *)\n | Pcty_extension of extension\n (* [%id] *)\n | Pcty_open of open_description * class_type\n (* let open M in CT *)\n\n and class_signature (*IF_CURRENT = Parsetree.class_signature *) =\n {\n pcsig_self: core_type;\n pcsig_fields: class_type_field list;\n }\n (* object('selfpat) ... end\n object ... end (self = Ptyp_any)\n *)\n\n and class_type_field (*IF_CURRENT = Parsetree.class_type_field *) =\n {\n pctf_desc: class_type_field_desc;\n pctf_loc: Location.t;\n pctf_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and class_type_field_desc (*IF_CURRENT = Parsetree.class_type_field_desc *) =\n | Pctf_inherit of class_type\n (* inherit CT *)\n | Pctf_val of (label loc * mutable_flag * virtual_flag * core_type)\n (* val x: T *)\n | Pctf_method of (label loc * private_flag * virtual_flag * core_type)\n (* method x: T\n\n Note: T can be a Ptyp_poly.\n *)\n | Pctf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pctf_attribute of attribute\n (* [@@@id] *)\n | Pctf_extension of extension\n (* [%%id] *)\n\n and 'a class_infos (*IF_CURRENT = 'a Parsetree.class_infos *) =\n {\n pci_virt: virtual_flag;\n pci_params: (core_type * variance) list;\n pci_name: string loc;\n pci_expr: 'a;\n pci_loc: Location.t;\n pci_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n (* class c = ...\n class ['a1,...,'an] c = ...\n class virtual c = ...\n\n Also used for \"class type\" declaration.\n *)\n\n and class_description = class_type class_infos\n\n and class_type_declaration = class_type class_infos\n\n (* Value expressions for the class language *)\n\n and class_expr (*IF_CURRENT = Parsetree.class_expr *) =\n {\n pcl_desc: class_expr_desc;\n pcl_loc: Location.t;\n pcl_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and class_expr_desc (*IF_CURRENT = Parsetree.class_expr_desc *) =\n | Pcl_constr of Longident.t loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcl_structure of class_structure\n (* object ... end *)\n | Pcl_fun of arg_label * expression option * pattern * class_expr\n (* fun P -> CE (Simple, None)\n fun ~l:P -> CE (Labelled l, None)\n fun ?l:P -> CE (Optional l, None)\n fun ?l:(P = E0) -> CE (Optional l, Some E0)\n *)\n | Pcl_apply of class_expr * (arg_label * expression) list\n (* CE ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pcl_let of rec_flag * value_binding list * class_expr\n (* let P1 = E1 and ... and Pn = EN in CE (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in CE (flag = Recursive)\n *)\n | Pcl_constraint of class_expr * class_type\n (* (CE : CT) *)\n | Pcl_extension of extension\n (* [%id] *)\n | Pcl_open of open_description * class_expr\n (* let open M in CE *)\n\n\n and class_structure (*IF_CURRENT = Parsetree.class_structure *) =\n {\n pcstr_self: pattern;\n pcstr_fields: class_field list;\n }\n (* object(selfpat) ... end\n object ... end (self = Ppat_any)\n *)\n\n and class_field (*IF_CURRENT = Parsetree.class_field *) =\n {\n pcf_desc: class_field_desc;\n pcf_loc: Location.t;\n pcf_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and class_field_desc (*IF_CURRENT = Parsetree.class_field_desc *) =\n | Pcf_inherit of override_flag * class_expr * string loc option\n (* inherit CE\n inherit CE as x\n inherit! CE\n inherit! CE as x\n *)\n | Pcf_val of (label loc * mutable_flag * class_field_kind)\n (* val x = E\n val virtual x: T\n *)\n | Pcf_method of (label loc * private_flag * class_field_kind)\n (* method x = E (E can be a Pexp_poly)\n method virtual x: T (T can be a Ptyp_poly)\n *)\n | Pcf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pcf_initializer of expression\n (* initializer E *)\n | Pcf_attribute of attribute\n (* [@@@id] *)\n | Pcf_extension of extension\n (* [%%id] *)\n\n and class_field_kind (*IF_CURRENT = Parsetree.class_field_kind *) =\n | Cfk_virtual of core_type\n | Cfk_concrete of override_flag * expression\n\n and class_declaration = class_expr class_infos\n\n (** {1 Module language} *)\n\n (* Type expressions for the module language *)\n\n and module_type (*IF_CURRENT = Parsetree.module_type *) =\n {\n pmty_desc: module_type_desc;\n pmty_loc: Location.t;\n pmty_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and module_type_desc (*IF_CURRENT = Parsetree.module_type_desc *) =\n | Pmty_ident of Longident.t loc\n (* S *)\n | Pmty_signature of signature\n (* sig ... end *)\n | Pmty_functor of functor_parameter * module_type\n (* functor(X : MT1) -> MT2 *)\n | Pmty_with of module_type * with_constraint list\n (* MT with ... *)\n | Pmty_typeof of module_expr\n (* module type of ME *)\n | Pmty_extension of extension\n (* [%id] *)\n | Pmty_alias of Longident.t loc\n (* (module M) *)\n\n and functor_parameter (*IF_CURRENT = Parsetree.functor_parameter *) =\n | Unit\n (* () *)\n | Named of string option loc * module_type\n (* (X : MT) Some X, MT\n (_ : MT) None, MT *)\n\n and signature = signature_item list\n\n and signature_item (*IF_CURRENT = Parsetree.signature_item *) =\n {\n psig_desc: signature_item_desc;\n psig_loc: Location.t;\n }\n\n and signature_item_desc (*IF_CURRENT = Parsetree.signature_item_desc *) =\n | Psig_value of value_description\n (*\n val x: T\n external x: T = \"s1\" ... \"sn\"\n *)\n | Psig_type of rec_flag * type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Psig_typesubst of type_declaration list\n (* type t1 := ... and ... and tn := ... *)\n | Psig_typext of type_extension\n (* type t1 += ... *)\n | Psig_exception of type_exception\n (* exception C of T *)\n | Psig_module of module_declaration\n (* module X = M\n module X : MT *)\n | Psig_modsubst of module_substitution\n (* module X := M *)\n | Psig_recmodule of module_declaration list\n (* module rec X1 : MT1 and ... and Xn : MTn *)\n | Psig_modtype of module_type_declaration\n (* module type S = MT\n module type S *)\n | Psig_open of open_description\n (* open X *)\n | Psig_include of include_description\n (* include MT *)\n | Psig_class of class_description list\n (* class c1 : ... and ... and cn : ... *)\n | Psig_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Psig_attribute of attribute\n (* [@@@id] *)\n | Psig_extension of extension * attributes\n (* [%%id] *)\n\n and module_declaration (*IF_CURRENT = Parsetree.module_declaration *) =\n {\n pmd_name: string option loc;\n pmd_type: module_type;\n pmd_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pmd_loc: Location.t;\n }\n (* S : MT *)\n\n and module_substitution (*IF_CURRENT = Parsetree.module_substitution *) =\n {\n pms_name: string loc;\n pms_manifest: Longident.t loc;\n pms_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pms_loc: Location.t;\n }\n\n and module_type_declaration (*IF_CURRENT = Parsetree.module_type_declaration *) =\n {\n pmtd_name: string loc;\n pmtd_type: module_type option;\n pmtd_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pmtd_loc: Location.t;\n }\n (* S = MT\n S (abstract module type declaration, pmtd_type = None)\n *)\n\n and 'a open_infos (*IF_CURRENT = 'a Parsetree.open_infos *) =\n {\n popen_expr: 'a;\n popen_override: override_flag;\n popen_loc: Location.t;\n popen_attributes: attributes;\n }\n (* open! X - popen_override = Override (silences the 'used identifier\n shadowing' warning)\n open X - popen_override = Fresh\n *)\n\n and open_description = Longident.t loc open_infos\n (* open M.N\n open M(N).O *)\n\n and open_declaration = module_expr open_infos\n (* open M.N\n open M(N).O\n open struct ... end *)\n\n and 'a include_infos (*IF_CURRENT = 'a Parsetree.include_infos *) =\n {\n pincl_mod: 'a;\n pincl_loc: Location.t;\n pincl_attributes: attributes;\n }\n\n and include_description = module_type include_infos\n (* include MT *)\n\n and include_declaration = module_expr include_infos\n (* include ME *)\n\n and with_constraint (*IF_CURRENT = Parsetree.with_constraint *) =\n | Pwith_type of Longident.t loc * type_declaration\n (* with type X.t = ...\n\n Note: the last component of the longident must match\n the name of the type_declaration. *)\n | Pwith_module of Longident.t loc * Longident.t loc\n (* with module X.Y = Z *)\n | Pwith_typesubst of Longident.t loc * type_declaration\n (* with type X.t := ..., same format as [Pwith_type] *)\n | Pwith_modsubst of Longident.t loc * Longident.t loc\n (* with module X.Y := Z *)\n\n (* Value expressions for the module language *)\n\n and module_expr (*IF_CURRENT = Parsetree.module_expr *) =\n {\n pmod_desc: module_expr_desc;\n pmod_loc: Location.t;\n pmod_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and module_expr_desc (*IF_CURRENT = Parsetree.module_expr_desc *) =\n | Pmod_ident of Longident.t loc\n (* X *)\n | Pmod_structure of structure\n (* struct ... end *)\n | Pmod_functor of functor_parameter * module_expr\n (* functor(X : MT1) -> ME *)\n | Pmod_apply of module_expr * module_expr\n (* ME1(ME2) *)\n | Pmod_constraint of module_expr * module_type\n (* (ME : MT) *)\n | Pmod_unpack of expression\n (* (val E) *)\n | Pmod_extension of extension\n (* [%id] *)\n\n and structure = structure_item list\n\n and structure_item (*IF_CURRENT = Parsetree.structure_item *) =\n {\n pstr_desc: structure_item_desc;\n pstr_loc: Location.t;\n }\n\n and structure_item_desc (*IF_CURRENT = Parsetree.structure_item_desc *) =\n | Pstr_eval of expression * attributes\n (* E *)\n | Pstr_value of rec_flag * value_binding list\n (* let P1 = E1 and ... and Pn = EN (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN (flag = Recursive)\n *)\n | Pstr_primitive of value_description\n (* val x: T\n external x: T = \"s1\" ... \"sn\" *)\n | Pstr_type of rec_flag * type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Pstr_typext of type_extension\n (* type t1 += ... *)\n | Pstr_exception of type_exception\n (* exception C of T\n exception C = M.X *)\n | Pstr_module of module_binding\n (* module X = ME *)\n | Pstr_recmodule of module_binding list\n (* module rec X1 = ME1 and ... and Xn = MEn *)\n | Pstr_modtype of module_type_declaration\n (* module type S = MT *)\n | Pstr_open of open_declaration\n (* open X *)\n | Pstr_class of class_declaration list\n (* class c1 = ... and ... and cn = ... *)\n | Pstr_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Pstr_include of include_declaration\n (* include ME *)\n | Pstr_attribute of attribute\n (* [@@@id] *)\n | Pstr_extension of extension * attributes\n (* [%%id] *)\n\n and value_binding (*IF_CURRENT = Parsetree.value_binding *) =\n {\n pvb_pat: pattern;\n pvb_expr: expression;\n pvb_attributes: attributes;\n pvb_loc: Location.t;\n }\n\n and module_binding (*IF_CURRENT = Parsetree.module_binding *) =\n {\n pmb_name: string option loc;\n pmb_expr: module_expr;\n pmb_attributes: attributes;\n pmb_loc: Location.t;\n }\n (* X = ME *)\n\n (** {1 Toplevel} *)\n\n (* Toplevel phrases *)\n\n type toplevel_phrase (*IF_CURRENT = Parsetree.toplevel_phrase *) =\n | Ptop_def of structure\n | Ptop_dir of toplevel_directive\n (* #use, #load ... *)\n\n and toplevel_directive (*IF_CURRENT = Parsetree.toplevel_directive *) =\n {\n pdir_name : string loc;\n pdir_arg : directive_argument option;\n pdir_loc : Location.t;\n }\n\n and directive_argument (*IF_CURRENT = Parsetree.directive_argument *) =\n {\n pdira_desc : directive_argument_desc;\n pdira_loc : Location.t;\n }\n\n and directive_argument_desc (*IF_CURRENT = Parsetree.directive_argument_desc *) =\n | Pdir_string of string\n | Pdir_int of string * char option\n | Pdir_ident of Longident.t\n | Pdir_bool of bool\nend\n\nmodule Config = struct\n let ast_impl_magic_number = \"Caml1999M028\"\n let ast_intf_magic_number = \"Caml1999N028\"\nend\n","(**************************************************************************)\n(* *)\n(* OCaml Migrate Parsetree *)\n(* *)\n(* Frédéric Bour, Facebook *)\n(* Jérémie Dimino and Leo White, Jane Street Europe *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* Alain Frisch, LexiFi *)\n(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 2018 Institut National de Recherche en Informatique et *)\n(* en Automatique (INRIA). *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nmodule Asttypes = struct\n type constant (*IF_CURRENT = Asttypes.constant *) =\n Const_int of int\n | Const_char of char\n | Const_string of string * string option\n | Const_float of string\n | Const_int32 of int32\n | Const_int64 of int64\n | Const_nativeint of nativeint\n\n type rec_flag (*IF_CURRENT = Asttypes.rec_flag *) = Nonrecursive | Recursive\n\n type direction_flag (*IF_CURRENT = Asttypes.direction_flag *) = Upto | Downto\n\n (* Order matters, used in polymorphic comparison *)\n type private_flag (*IF_CURRENT = Asttypes.private_flag *) = Private | Public\n\n type mutable_flag (*IF_CURRENT = Asttypes.mutable_flag *) = Immutable | Mutable\n\n type virtual_flag (*IF_CURRENT = Asttypes.virtual_flag *) = Virtual | Concrete\n\n type override_flag (*IF_CURRENT = Asttypes.override_flag *) = Override | Fresh\n\n type closed_flag (*IF_CURRENT = Asttypes.closed_flag *) = Closed | Open\n\n type label = string\n\n type arg_label (*IF_CURRENT = Asttypes.arg_label *) =\n Nolabel\n | Labelled of string (* label:T -> ... *)\n | Optional of string (* ?label:T -> ... *)\n\n type 'a loc = 'a Location.loc = {\n txt : 'a;\n loc : Location.t;\n }\n\n\n type variance (*IF_CURRENT = Asttypes.variance *) =\n | Covariant\n | Contravariant\n | Invariant\nend\n\nmodule Parsetree = struct\n\n open Asttypes\n\n type constant (*IF_CURRENT = Parsetree.constant *) =\n Pconst_integer of string * char option\n (* 3 3l 3L 3n\n\n Suffixes [g-z][G-Z] are accepted by the parser.\n Suffixes except 'l', 'L' and 'n' are rejected by the typechecker\n *)\n | Pconst_char of char\n (* 'c' *)\n | Pconst_string of string * string option\n (* \"constant\"\n {delim|other constant|delim}\n *)\n | Pconst_float of string * char option\n (* 3.4 2e5 1.4e-4\n\n Suffixes [g-z][G-Z] are accepted by the parser.\n Suffixes are rejected by the typechecker.\n *)\n\n type location_stack = Location.t list\n\n (** {1 Extension points} *)\n\n type attribute (*IF_CURRENT = Parsetree.attribute *) = {\n attr_name : string loc;\n attr_payload : payload;\n attr_loc : Location.t;\n }\n (* [@id ARG]\n [@@id ARG]\n\n Metadata containers passed around within the AST.\n The compiler ignores unknown attributes.\n *)\n\n and extension = string loc * payload\n (* [%id ARG]\n [%%id ARG]\n\n Sub-language placeholder -- rejected by the typechecker.\n *)\n\n and attributes = attribute list\n\n and payload (*IF_CURRENT = Parsetree.payload *) =\n | PStr of structure\n | PSig of signature (* : SIG *)\n | PTyp of core_type (* : T *)\n | PPat of pattern * expression option (* ? P or ? P when E *)\n\n (** {1 Core language} *)\n\n (* Type expressions *)\n\n and core_type (*IF_CURRENT = Parsetree.core_type *) =\n {\n ptyp_desc: core_type_desc;\n ptyp_loc: Location.t;\n ptyp_loc_stack: location_stack;\n ptyp_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and core_type_desc (*IF_CURRENT = Parsetree.core_type_desc *) =\n | Ptyp_any\n (* _ *)\n | Ptyp_var of string\n (* 'a *)\n | Ptyp_arrow of arg_label * core_type * core_type\n (* T1 -> T2 Simple\n ~l:T1 -> T2 Labelled\n ?l:T1 -> T2 Optional\n *)\n | Ptyp_tuple of core_type list\n (* T1 * ... * Tn\n\n Invariant: n >= 2\n *)\n | Ptyp_constr of Longident.t loc * core_type list\n (* tconstr\n T tconstr\n (T1, ..., Tn) tconstr\n *)\n | Ptyp_object of object_field list * closed_flag\n (* < l1:T1; ...; ln:Tn > (flag = Closed)\n < l1:T1; ...; ln:Tn; .. > (flag = Open)\n *)\n | Ptyp_class of Longident.t loc * core_type list\n (* #tconstr\n T #tconstr\n (T1, ..., Tn) #tconstr\n *)\n | Ptyp_alias of core_type * string\n (* T as 'a *)\n | Ptyp_variant of row_field list * closed_flag * label list option\n (* [ `A|`B ] (flag = Closed; labels = None)\n [> `A|`B ] (flag = Open; labels = None)\n [< `A|`B ] (flag = Closed; labels = Some [])\n [< `A|`B > `X `Y ](flag = Closed; labels = Some [\"X\";\"Y\"])\n *)\n | Ptyp_poly of string loc list * core_type\n (* 'a1 ... 'an. T\n\n Can only appear in the following context:\n\n - As the core_type of a Ppat_constraint node corresponding\n to a constraint on a let-binding: let x : 'a1 ... 'an. T\n = e ...\n\n - Under Cfk_virtual for methods (not values).\n\n - As the core_type of a Pctf_method node.\n\n - As the core_type of a Pexp_poly node.\n\n - As the pld_type field of a label_declaration.\n\n - As a core_type of a Ptyp_object node.\n *)\n\n | Ptyp_package of package_type\n (* (module S) *)\n | Ptyp_extension of extension\n (* [%id] *)\n\n and package_type = Longident.t loc * (Longident.t loc * core_type) list\n (*\n (module S)\n (module S with type t1 = T1 and ... and tn = Tn)\n *)\n\n and row_field (*IF_CURRENT = Parsetree.row_field *) = {\n prf_desc : row_field_desc;\n prf_loc : Location.t;\n prf_attributes : attributes;\n }\n\n and row_field_desc (*IF_CURRENT = Parsetree.row_field_desc *) =\n | Rtag of label loc * bool * core_type list\n (* [`A] ( true, [] )\n [`A of T] ( false, [T] )\n [`A of T1 & .. & Tn] ( false, [T1;...Tn] )\n [`A of & T1 & .. & Tn] ( true, [T1;...Tn] )\n\n - The 'bool' field is true if the tag contains a\n constant (empty) constructor.\n - '&' occurs when several types are used for the same constructor\n (see 4.2 in the manual)\n *)\n | Rinherit of core_type\n (* [ T ] *)\n\n and object_field (*IF_CURRENT = Parsetree.object_field *) = {\n pof_desc : object_field_desc;\n pof_loc : Location.t;\n pof_attributes : attributes;\n }\n\n and object_field_desc (*IF_CURRENT = Parsetree.object_field_desc *) =\n | Otag of label loc * core_type\n | Oinherit of core_type\n\n (* Patterns *)\n\n and pattern (*IF_CURRENT = Parsetree.pattern *) =\n {\n ppat_desc: pattern_desc;\n ppat_loc: Location.t;\n ppat_loc_stack: location_stack;\n ppat_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and pattern_desc (*IF_CURRENT = Parsetree.pattern_desc *) =\n | Ppat_any\n (* _ *)\n | Ppat_var of string loc\n (* x *)\n | Ppat_alias of pattern * string loc\n (* P as 'a *)\n | Ppat_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Ppat_interval of constant * constant\n (* 'a'..'z'\n\n Other forms of interval are recognized by the parser\n but rejected by the type-checker. *)\n | Ppat_tuple of pattern list\n (* (P1, ..., Pn)\n\n Invariant: n >= 2\n *)\n | Ppat_construct of Longident.t loc * pattern option\n (* C None\n C P Some P\n C (P1, ..., Pn) Some (Ppat_tuple [P1; ...; Pn])\n *)\n | Ppat_variant of label * pattern option\n (* `A (None)\n `A P (Some P)\n *)\n | Ppat_record of (Longident.t loc * pattern) list * closed_flag\n (* { l1=P1; ...; ln=Pn } (flag = Closed)\n { l1=P1; ...; ln=Pn; _} (flag = Open)\n\n Invariant: n > 0\n *)\n | Ppat_array of pattern list\n (* [| P1; ...; Pn |] *)\n | Ppat_or of pattern * pattern\n (* P1 | P2 *)\n | Ppat_constraint of pattern * core_type\n (* (P : T) *)\n | Ppat_type of Longident.t loc\n (* #tconst *)\n | Ppat_lazy of pattern\n (* lazy P *)\n | Ppat_unpack of string option loc\n (* (module P) Some \"P\"\n (module _) None\n\n Note: (module P : S) is represented as\n Ppat_constraint(Ppat_unpack, Ptyp_package)\n *)\n | Ppat_exception of pattern\n (* exception P *)\n | Ppat_extension of extension\n (* [%id] *)\n | Ppat_open of Longident.t loc * pattern\n (* M.(P) *)\n\n (* Value expressions *)\n\n and expression (*IF_CURRENT = Parsetree.expression *) =\n {\n pexp_desc: expression_desc;\n pexp_loc: Location.t;\n pexp_loc_stack: location_stack;\n pexp_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and expression_desc (*IF_CURRENT = Parsetree.expression_desc *) =\n | Pexp_ident of Longident.t loc\n (* x\n M.x\n *)\n | Pexp_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Pexp_let of rec_flag * value_binding list * expression\n (* let P1 = E1 and ... and Pn = EN in E (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in E (flag = Recursive)\n *)\n | Pexp_function of case list\n (* function P1 -> E1 | ... | Pn -> En *)\n | Pexp_fun of arg_label * expression option * pattern * expression\n (* fun P -> E1 (Simple, None)\n fun ~l:P -> E1 (Labelled l, None)\n fun ?l:P -> E1 (Optional l, None)\n fun ?l:(P = E0) -> E1 (Optional l, Some E0)\n\n Notes:\n - If E0 is provided, only Optional is allowed.\n - \"fun P1 P2 .. Pn -> E1\" is represented as nested Pexp_fun.\n - \"let f P = E\" is represented using Pexp_fun.\n *)\n | Pexp_apply of expression * (arg_label * expression) list\n (* E0 ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pexp_match of expression * case list\n (* match E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_try of expression * case list\n (* try E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_tuple of expression list\n (* (E1, ..., En)\n\n Invariant: n >= 2\n *)\n | Pexp_construct of Longident.t loc * expression option\n (* C None\n C E Some E\n C (E1, ..., En) Some (Pexp_tuple[E1;...;En])\n *)\n | Pexp_variant of label * expression option\n (* `A (None)\n `A E (Some E)\n *)\n | Pexp_record of (Longident.t loc * expression) list * expression option\n (* { l1=P1; ...; ln=Pn } (None)\n { E0 with l1=P1; ...; ln=Pn } (Some E0)\n\n Invariant: n > 0\n *)\n | Pexp_field of expression * Longident.t loc\n (* E.l *)\n | Pexp_setfield of expression * Longident.t loc * expression\n (* E1.l <- E2 *)\n | Pexp_array of expression list\n (* [| E1; ...; En |] *)\n | Pexp_ifthenelse of expression * expression * expression option\n (* if E1 then E2 else E3 *)\n | Pexp_sequence of expression * expression\n (* E1; E2 *)\n | Pexp_while of expression * expression\n (* while E1 do E2 done *)\n | Pexp_for of\n pattern * expression * expression * direction_flag * expression\n (* for i = E1 to E2 do E3 done (flag = Upto)\n for i = E1 downto E2 do E3 done (flag = Downto)\n *)\n | Pexp_constraint of expression * core_type\n (* (E : T) *)\n | Pexp_coerce of expression * core_type option * core_type\n (* (E :> T) (None, T)\n (E : T0 :> T) (Some T0, T)\n *)\n | Pexp_send of expression * label loc\n (* E # m *)\n | Pexp_new of Longident.t loc\n (* new M.c *)\n | Pexp_setinstvar of label loc * expression\n (* x <- 2 *)\n | Pexp_override of (label loc * expression) list\n (* {< x1 = E1; ...; Xn = En >} *)\n | Pexp_letmodule of string option loc * module_expr * expression\n (* let module M = ME in E *)\n | Pexp_letexception of extension_constructor * expression\n (* let exception C in E *)\n | Pexp_assert of expression\n (* assert E\n Note: \"assert false\" is treated in a special way by the\n type-checker. *)\n | Pexp_lazy of expression\n (* lazy E *)\n | Pexp_poly of expression * core_type option\n (* Used for method bodies.\n\n Can only be used as the expression under Cfk_concrete\n for methods (not values). *)\n | Pexp_object of class_structure\n (* object ... end *)\n | Pexp_newtype of string loc * expression\n (* fun (type t) -> E *)\n | Pexp_pack of module_expr\n (* (module ME)\n\n (module ME : S) is represented as\n Pexp_constraint(Pexp_pack, Ptyp_package S) *)\n | Pexp_open of open_declaration * expression\n (* M.(E)\n let open M in E\n let! open M in E *)\n | Pexp_letop of letop\n (* let* P = E in E\n let* P = E and* P = E in E *)\n | Pexp_extension of extension\n (* [%id] *)\n | Pexp_unreachable\n (* . *)\n\n and case (*IF_CURRENT = Parsetree.case *) = (* (P -> E) or (P when E0 -> E) *)\n {\n pc_lhs: pattern;\n pc_guard: expression option;\n pc_rhs: expression;\n }\n\n and letop (*IF_CURRENT = Parsetree.letop *) =\n {\n let_ : binding_op;\n ands : binding_op list;\n body : expression;\n }\n\n and binding_op (*IF_CURRENT = Parsetree.binding_op *) =\n {\n pbop_op : string loc;\n pbop_pat : pattern;\n pbop_exp : expression;\n pbop_loc : Location.t;\n }\n\n (* Value descriptions *)\n\n and value_description (*IF_CURRENT = Parsetree.value_description *) =\n {\n pval_name: string loc;\n pval_type: core_type;\n pval_prim: string list;\n pval_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pval_loc: Location.t;\n }\n\n(*\n val x: T (prim = [])\n external x: T = \"s1\" ... \"sn\" (prim = [\"s1\";...\"sn\"])\n*)\n\n (* Type declarations *)\n\n and type_declaration (*IF_CURRENT = Parsetree.type_declaration *) =\n {\n ptype_name: string loc;\n ptype_params: (core_type * variance) list;\n (* ('a1,...'an) t; None represents _*)\n ptype_cstrs: (core_type * core_type * Location.t) list;\n (* ... constraint T1=T1' ... constraint Tn=Tn' *)\n ptype_kind: type_kind;\n ptype_private: private_flag; (* = private ... *)\n ptype_manifest: core_type option; (* = T *)\n ptype_attributes: attributes; (* ... [@@id1] [@@id2] *)\n ptype_loc: Location.t;\n }\n\n(*\n type t (abstract, no manifest)\n type t = T0 (abstract, manifest=T0)\n type t = C of T | ... (variant, no manifest)\n type t = T0 = C of T | ... (variant, manifest=T0)\n type t = {l: T; ...} (record, no manifest)\n type t = T0 = {l : T; ...} (record, manifest=T0)\n type t = .. (open, no manifest)\n*)\n\n and type_kind (*IF_CURRENT = Parsetree.type_kind *) =\n | Ptype_abstract\n | Ptype_variant of constructor_declaration list\n | Ptype_record of label_declaration list\n (* Invariant: non-empty list *)\n | Ptype_open\n\n and label_declaration (*IF_CURRENT = Parsetree.label_declaration *) =\n {\n pld_name: string loc;\n pld_mutable: mutable_flag;\n pld_type: core_type;\n pld_loc: Location.t;\n pld_attributes: attributes; (* l : T [@id1] [@id2] *)\n }\n\n (* { ...; l: T; ... } (mutable=Immutable)\n { ...; mutable l: T; ... } (mutable=Mutable)\n\n Note: T can be a Ptyp_poly.\n *)\n\n and constructor_declaration (*IF_CURRENT = Parsetree.constructor_declaration *) =\n {\n pcd_name: string loc;\n pcd_args: constructor_arguments;\n pcd_res: core_type option;\n pcd_loc: Location.t;\n pcd_attributes: attributes; (* C of ... [@id1] [@id2] *)\n }\n\n and constructor_arguments (*IF_CURRENT = Parsetree.constructor_arguments *) =\n | Pcstr_tuple of core_type list\n | Pcstr_record of label_declaration list\n\n(*\n | C of T1 * ... * Tn (res = None, args = Pcstr_tuple [])\n | C: T0 (res = Some T0, args = [])\n | C: T1 * ... * Tn -> T0 (res = Some T0, args = Pcstr_tuple)\n | C of {...} (res = None, args = Pcstr_record)\n | C: {...} -> T0 (res = Some T0, args = Pcstr_record)\n | C of {...} as t (res = None, args = Pcstr_record)\n*)\n\n and type_extension (*IF_CURRENT = Parsetree.type_extension *) =\n {\n ptyext_path: Longident.t loc;\n ptyext_params: (core_type * variance) list;\n ptyext_constructors: extension_constructor list;\n ptyext_private: private_flag;\n ptyext_loc: Location.t;\n ptyext_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n(*\n type t += ...\n*)\n\n and extension_constructor (*IF_CURRENT = Parsetree.extension_constructor *) =\n {\n pext_name: string loc;\n pext_kind : extension_constructor_kind;\n pext_loc : Location.t;\n pext_attributes: attributes; (* C of ... [@id1] [@id2] *)\n }\n\n (* exception E *)\n and type_exception (*IF_CURRENT = Parsetree.type_exception *) =\n {\n ptyexn_constructor: extension_constructor;\n ptyexn_loc: Location.t;\n ptyexn_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and extension_constructor_kind (*IF_CURRENT = Parsetree.extension_constructor_kind *) =\n Pext_decl of constructor_arguments * core_type option\n (*\n | C of T1 * ... * Tn ([T1; ...; Tn], None)\n | C: T0 ([], Some T0)\n | C: T1 * ... * Tn -> T0 ([T1; ...; Tn], Some T0)\n *)\n | Pext_rebind of Longident.t loc\n (*\n | C = D\n *)\n\n (** {1 Class language} *)\n\n (* Type expressions for the class language *)\n\n and class_type (*IF_CURRENT = Parsetree.class_type *) =\n {\n pcty_desc: class_type_desc;\n pcty_loc: Location.t;\n pcty_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and class_type_desc (*IF_CURRENT = Parsetree.class_type_desc *) =\n | Pcty_constr of Longident.t loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcty_signature of class_signature\n (* object ... end *)\n | Pcty_arrow of arg_label * core_type * class_type\n (* T -> CT Simple\n ~l:T -> CT Labelled l\n ?l:T -> CT Optional l\n *)\n | Pcty_extension of extension\n (* [%id] *)\n | Pcty_open of open_description * class_type\n (* let open M in CT *)\n\n and class_signature (*IF_CURRENT = Parsetree.class_signature *) =\n {\n pcsig_self: core_type;\n pcsig_fields: class_type_field list;\n }\n (* object('selfpat) ... end\n object ... end (self = Ptyp_any)\n *)\n\n and class_type_field (*IF_CURRENT = Parsetree.class_type_field *) =\n {\n pctf_desc: class_type_field_desc;\n pctf_loc: Location.t;\n pctf_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and class_type_field_desc (*IF_CURRENT = Parsetree.class_type_field_desc *) =\n | Pctf_inherit of class_type\n (* inherit CT *)\n | Pctf_val of (label loc * mutable_flag * virtual_flag * core_type)\n (* val x: T *)\n | Pctf_method of (label loc * private_flag * virtual_flag * core_type)\n (* method x: T\n\n Note: T can be a Ptyp_poly.\n *)\n | Pctf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pctf_attribute of attribute\n (* [@@@id] *)\n | Pctf_extension of extension\n (* [%%id] *)\n\n and 'a class_infos (*IF_CURRENT = 'a Parsetree.class_infos *) =\n {\n pci_virt: virtual_flag;\n pci_params: (core_type * variance) list;\n pci_name: string loc;\n pci_expr: 'a;\n pci_loc: Location.t;\n pci_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n (* class c = ...\n class ['a1,...,'an] c = ...\n class virtual c = ...\n\n Also used for \"class type\" declaration.\n *)\n\n and class_description = class_type class_infos\n\n and class_type_declaration = class_type class_infos\n\n (* Value expressions for the class language *)\n\n and class_expr (*IF_CURRENT = Parsetree.class_expr *) =\n {\n pcl_desc: class_expr_desc;\n pcl_loc: Location.t;\n pcl_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and class_expr_desc (*IF_CURRENT = Parsetree.class_expr_desc *) =\n | Pcl_constr of Longident.t loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcl_structure of class_structure\n (* object ... end *)\n | Pcl_fun of arg_label * expression option * pattern * class_expr\n (* fun P -> CE (Simple, None)\n fun ~l:P -> CE (Labelled l, None)\n fun ?l:P -> CE (Optional l, None)\n fun ?l:(P = E0) -> CE (Optional l, Some E0)\n *)\n | Pcl_apply of class_expr * (arg_label * expression) list\n (* CE ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pcl_let of rec_flag * value_binding list * class_expr\n (* let P1 = E1 and ... and Pn = EN in CE (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in CE (flag = Recursive)\n *)\n | Pcl_constraint of class_expr * class_type\n (* (CE : CT) *)\n | Pcl_extension of extension\n (* [%id] *)\n | Pcl_open of open_description * class_expr\n (* let open M in CE *)\n\n\n and class_structure (*IF_CURRENT = Parsetree.class_structure *) =\n {\n pcstr_self: pattern;\n pcstr_fields: class_field list;\n }\n (* object(selfpat) ... end\n object ... end (self = Ppat_any)\n *)\n\n and class_field (*IF_CURRENT = Parsetree.class_field *) =\n {\n pcf_desc: class_field_desc;\n pcf_loc: Location.t;\n pcf_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and class_field_desc (*IF_CURRENT = Parsetree.class_field_desc *) =\n | Pcf_inherit of override_flag * class_expr * string loc option\n (* inherit CE\n inherit CE as x\n inherit! CE\n inherit! CE as x\n *)\n | Pcf_val of (label loc * mutable_flag * class_field_kind)\n (* val x = E\n val virtual x: T\n *)\n | Pcf_method of (label loc * private_flag * class_field_kind)\n (* method x = E (E can be a Pexp_poly)\n method virtual x: T (T can be a Ptyp_poly)\n *)\n | Pcf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pcf_initializer of expression\n (* initializer E *)\n | Pcf_attribute of attribute\n (* [@@@id] *)\n | Pcf_extension of extension\n (* [%%id] *)\n\n and class_field_kind (*IF_CURRENT = Parsetree.class_field_kind *) =\n | Cfk_virtual of core_type\n | Cfk_concrete of override_flag * expression\n\n and class_declaration = class_expr class_infos\n\n (** {1 Module language} *)\n\n (* Type expressions for the module language *)\n\n and module_type (*IF_CURRENT = Parsetree.module_type *) =\n {\n pmty_desc: module_type_desc;\n pmty_loc: Location.t;\n pmty_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and module_type_desc (*IF_CURRENT = Parsetree.module_type_desc *) =\n | Pmty_ident of Longident.t loc\n (* S *)\n | Pmty_signature of signature\n (* sig ... end *)\n | Pmty_functor of functor_parameter * module_type\n (* functor(X : MT1) -> MT2 *)\n | Pmty_with of module_type * with_constraint list\n (* MT with ... *)\n | Pmty_typeof of module_expr\n (* module type of ME *)\n | Pmty_extension of extension\n (* [%id] *)\n | Pmty_alias of Longident.t loc\n (* (module M) *)\n\n and functor_parameter (*IF_CURRENT = Parsetree.functor_parameter *) =\n | Unit\n (* () *)\n | Named of string option loc * module_type\n (* (X : MT) Some X, MT\n (_ : MT) None, MT *)\n\n and signature = signature_item list\n\n and signature_item (*IF_CURRENT = Parsetree.signature_item *) =\n {\n psig_desc: signature_item_desc;\n psig_loc: Location.t;\n }\n\n and signature_item_desc (*IF_CURRENT = Parsetree.signature_item_desc *) =\n | Psig_value of value_description\n (*\n val x: T\n external x: T = \"s1\" ... \"sn\"\n *)\n | Psig_type of rec_flag * type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Psig_typesubst of type_declaration list\n (* type t1 := ... and ... and tn := ... *)\n | Psig_typext of type_extension\n (* type t1 += ... *)\n | Psig_exception of type_exception\n (* exception C of T *)\n | Psig_module of module_declaration\n (* module X = M\n module X : MT *)\n | Psig_modsubst of module_substitution\n (* module X := M *)\n | Psig_recmodule of module_declaration list\n (* module rec X1 : MT1 and ... and Xn : MTn *)\n | Psig_modtype of module_type_declaration\n (* module type S = MT\n module type S *)\n | Psig_open of open_description\n (* open X *)\n | Psig_include of include_description\n (* include MT *)\n | Psig_class of class_description list\n (* class c1 : ... and ... and cn : ... *)\n | Psig_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Psig_attribute of attribute\n (* [@@@id] *)\n | Psig_extension of extension * attributes\n (* [%%id] *)\n\n and module_declaration (*IF_CURRENT = Parsetree.module_declaration *) =\n {\n pmd_name: string option loc;\n pmd_type: module_type;\n pmd_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pmd_loc: Location.t;\n }\n (* S : MT *)\n\n and module_substitution (*IF_CURRENT = Parsetree.module_substitution *) =\n {\n pms_name: string loc;\n pms_manifest: Longident.t loc;\n pms_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pms_loc: Location.t;\n }\n\n and module_type_declaration (*IF_CURRENT = Parsetree.module_type_declaration *) =\n {\n pmtd_name: string loc;\n pmtd_type: module_type option;\n pmtd_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pmtd_loc: Location.t;\n }\n (* S = MT\n S (abstract module type declaration, pmtd_type = None)\n *)\n\n and 'a open_infos (*IF_CURRENT = 'a Parsetree.open_infos *) =\n {\n popen_expr: 'a;\n popen_override: override_flag;\n popen_loc: Location.t;\n popen_attributes: attributes;\n }\n (* open! X - popen_override = Override (silences the 'used identifier\n shadowing' warning)\n open X - popen_override = Fresh\n *)\n\n and open_description = Longident.t loc open_infos\n (* open M.N\n open M(N).O *)\n\n and open_declaration = module_expr open_infos\n (* open M.N\n open M(N).O\n open struct ... end *)\n\n and 'a include_infos (*IF_CURRENT = 'a Parsetree.include_infos *) =\n {\n pincl_mod: 'a;\n pincl_loc: Location.t;\n pincl_attributes: attributes;\n }\n\n and include_description = module_type include_infos\n (* include MT *)\n\n and include_declaration = module_expr include_infos\n (* include ME *)\n\n and with_constraint (*IF_CURRENT = Parsetree.with_constraint *) =\n | Pwith_type of Longident.t loc * type_declaration\n (* with type X.t = ...\n\n Note: the last component of the longident must match\n the name of the type_declaration. *)\n | Pwith_module of Longident.t loc * Longident.t loc\n (* with module X.Y = Z *)\n | Pwith_typesubst of Longident.t loc * type_declaration\n (* with type X.t := ..., same format as [Pwith_type] *)\n | Pwith_modsubst of Longident.t loc * Longident.t loc\n (* with module X.Y := Z *)\n\n (* Value expressions for the module language *)\n\n and module_expr (*IF_CURRENT = Parsetree.module_expr *) =\n {\n pmod_desc: module_expr_desc;\n pmod_loc: Location.t;\n pmod_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and module_expr_desc (*IF_CURRENT = Parsetree.module_expr_desc *) =\n | Pmod_ident of Longident.t loc\n (* X *)\n | Pmod_structure of structure\n (* struct ... end *)\n | Pmod_functor of functor_parameter * module_expr\n (* functor(X : MT1) -> ME *)\n | Pmod_apply of module_expr * module_expr\n (* ME1(ME2) *)\n | Pmod_constraint of module_expr * module_type\n (* (ME : MT) *)\n | Pmod_unpack of expression\n (* (val E) *)\n | Pmod_extension of extension\n (* [%id] *)\n\n and structure = structure_item list\n\n and structure_item (*IF_CURRENT = Parsetree.structure_item *) =\n {\n pstr_desc: structure_item_desc;\n pstr_loc: Location.t;\n }\n\n and structure_item_desc (*IF_CURRENT = Parsetree.structure_item_desc *) =\n | Pstr_eval of expression * attributes\n (* E *)\n | Pstr_value of rec_flag * value_binding list\n (* let P1 = E1 and ... and Pn = EN (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN (flag = Recursive)\n *)\n | Pstr_primitive of value_description\n (* val x: T\n external x: T = \"s1\" ... \"sn\" *)\n | Pstr_type of rec_flag * type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Pstr_typext of type_extension\n (* type t1 += ... *)\n | Pstr_exception of type_exception\n (* exception C of T\n exception C = M.X *)\n | Pstr_module of module_binding\n (* module X = ME *)\n | Pstr_recmodule of module_binding list\n (* module rec X1 = ME1 and ... and Xn = MEn *)\n | Pstr_modtype of module_type_declaration\n (* module type S = MT *)\n | Pstr_open of open_declaration\n (* open X *)\n | Pstr_class of class_declaration list\n (* class c1 = ... and ... and cn = ... *)\n | Pstr_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Pstr_include of include_declaration\n (* include ME *)\n | Pstr_attribute of attribute\n (* [@@@id] *)\n | Pstr_extension of extension * attributes\n (* [%%id] *)\n\n and value_binding (*IF_CURRENT = Parsetree.value_binding *) =\n {\n pvb_pat: pattern;\n pvb_expr: expression;\n pvb_attributes: attributes;\n pvb_loc: Location.t;\n }\n\n and module_binding (*IF_CURRENT = Parsetree.module_binding *) =\n {\n pmb_name: string option loc;\n pmb_expr: module_expr;\n pmb_attributes: attributes;\n pmb_loc: Location.t;\n }\n (* X = ME *)\n\n (** {1 Toplevel} *)\n\n (* Toplevel phrases *)\n\n type toplevel_phrase (*IF_CURRENT = Parsetree.toplevel_phrase *) =\n | Ptop_def of structure\n | Ptop_dir of toplevel_directive\n (* #use, #load ... *)\n\n and toplevel_directive (*IF_CURRENT = Parsetree.toplevel_directive *) =\n {\n pdir_name : string loc;\n pdir_arg : directive_argument option;\n pdir_loc : Location.t;\n }\n\n and directive_argument (*IF_CURRENT = Parsetree.directive_argument *) =\n {\n pdira_desc : directive_argument_desc;\n pdira_loc : Location.t;\n }\n\n and directive_argument_desc (*IF_CURRENT = Parsetree.directive_argument_desc *) =\n | Pdir_string of string\n | Pdir_int of string * char option\n | Pdir_ident of Longident.t\n | Pdir_bool of bool\n\nend\n\nmodule Config = struct\n let ast_impl_magic_number = \"Caml1999M027\"\n let ast_intf_magic_number = \"Caml1999N027\"\nend\n","(**************************************************************************)\n(* *)\n(* OCaml Migrate Parsetree *)\n(* *)\n(* Frédéric Bour, Facebook *)\n(* Jérémie Dimino and Leo White, Jane Street Europe *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* Alain Frisch, LexiFi *)\n(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 2018 Institut National de Recherche en Informatique et *)\n(* en Automatique (INRIA). *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nmodule Asttypes = struct\n\n type constant (*IF_CURRENT = Asttypes.constant *) =\n Const_int of int\n | Const_char of char\n | Const_string of string * string option\n | Const_float of string\n | Const_int32 of int32\n | Const_int64 of int64\n | Const_nativeint of nativeint\n\n type rec_flag (*IF_CURRENT = Asttypes.rec_flag *) = Nonrecursive | Recursive\n\n type direction_flag (*IF_CURRENT = Asttypes.direction_flag *) = Upto | Downto\n\n (* Order matters, used in polymorphic comparison *)\n type private_flag (*IF_CURRENT = Asttypes.private_flag *) = Private | Public\n\n type mutable_flag (*IF_CURRENT = Asttypes.mutable_flag *) = Immutable | Mutable\n\n type virtual_flag (*IF_CURRENT = Asttypes.virtual_flag *) = Virtual | Concrete\n\n type override_flag (*IF_CURRENT = Asttypes.override_flag *) = Override | Fresh\n\n type closed_flag (*IF_CURRENT = Asttypes.closed_flag *) = Closed | Open\n\n type label = string\n\n type arg_label (*IF_CURRENT = Asttypes.arg_label *) =\n Nolabel\n | Labelled of string (* label:T -> ... *)\n | Optional of string (* ?label:T -> ... *)\n\n type 'a loc = 'a Location.loc = {\n txt : 'a;\n loc : Location.t;\n }\n\n\n type variance (*IF_CURRENT = Asttypes.variance *) =\n | Covariant\n | Contravariant\n | Invariant\n\nend\n\nmodule Parsetree = struct\n\n open Asttypes\n\n type constant (*IF_CURRENT = Parsetree.constant *) =\n Pconst_integer of string * char option\n (* 3 3l 3L 3n\n\n Suffixes [g-z][G-Z] are accepted by the parser.\n Suffixes except 'l', 'L' and 'n' are rejected by the typechecker\n *)\n | Pconst_char of char\n (* 'c' *)\n | Pconst_string of string * string option\n (* \"constant\"\n {delim|other constant|delim}\n *)\n | Pconst_float of string * char option\n (* 3.4 2e5 1.4e-4\n\n Suffixes [g-z][G-Z] are accepted by the parser.\n Suffixes are rejected by the typechecker.\n *)\n\n (** {1 Extension points} *)\n\n type attribute (*IF_CURRENT = Parsetree.attribute *) = {\n attr_name : string loc;\n attr_payload : payload;\n attr_loc : Location.t;\n }\n (* [@id ARG]\n [@@id ARG]\n\n Metadata containers passed around within the AST.\n The compiler ignores unknown attributes.\n *)\n\n and extension = string loc * payload\n (* [%id ARG]\n [%%id ARG]\n\n Sub-language placeholder -- rejected by the typechecker.\n *)\n\n and attributes = attribute list\n\n and payload (*IF_CURRENT = Parsetree.payload *) =\n | PStr of structure\n | PSig of signature (* : SIG *)\n | PTyp of core_type (* : T *)\n | PPat of pattern * expression option (* ? P or ? P when E *)\n\n (** {1 Core language} *)\n\n (* Type expressions *)\n\n and core_type (*IF_CURRENT = Parsetree.core_type *) =\n {\n ptyp_desc: core_type_desc;\n ptyp_loc: Location.t;\n ptyp_loc_stack: Location.t list;\n ptyp_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and typ = core_type\n\n and core_type_desc (*IF_CURRENT = Parsetree.core_type_desc *) =\n | Ptyp_any\n (* _ *)\n | Ptyp_var of string\n (* 'a *)\n | Ptyp_arrow of arg_label * core_type * core_type\n (* T1 -> T2 Simple\n ~l:T1 -> T2 Labelled\n ?l:T1 -> T2 Optional\n *)\n | Ptyp_tuple of core_type list\n (* T1 * ... * Tn\n\n Invariant: n >= 2\n *)\n | Ptyp_constr of Longident.t loc * core_type list\n (* tconstr\n T tconstr\n (T1, ..., Tn) tconstr\n *)\n | Ptyp_object of object_field list * closed_flag\n (* < l1:T1; ...; ln:Tn > (flag = Closed)\n < l1:T1; ...; ln:Tn; .. > (flag = Open)\n *)\n | Ptyp_class of Longident.t loc * core_type list\n (* #tconstr\n T #tconstr\n (T1, ..., Tn) #tconstr\n *)\n | Ptyp_alias of core_type * string\n (* T as 'a *)\n | Ptyp_variant of row_field list * closed_flag * label list option\n (* [ `A|`B ] (flag = Closed; labels = None)\n [> `A|`B ] (flag = Open; labels = None)\n [< `A|`B ] (flag = Closed; labels = Some [])\n [< `A|`B > `X `Y ](flag = Closed; labels = Some [\"X\";\"Y\"])\n *)\n | Ptyp_poly of string loc list * core_type\n (* 'a1 ... 'an. T\n\n Can only appear in the following context:\n\n - As the core_type of a Ppat_constraint node corresponding\n to a constraint on a let-binding: let x : 'a1 ... 'an. T\n = e ...\n\n - Under Cfk_virtual for methods (not values).\n\n - As the core_type of a Pctf_method node.\n\n - As the core_type of a Pexp_poly node.\n\n - As the pld_type field of a label_declaration.\n\n - As a core_type of a Ptyp_object node.\n *)\n\n | Ptyp_package of package_type\n (* (module S) *)\n | Ptyp_extension of extension\n (* [%id] *)\n\n and package_type = Longident.t loc * (Longident.t loc * core_type) list\n (*\n (module S)\n (module S with type t1 = T1 and ... and tn = Tn)\n *)\n\n and row_field (*IF_CURRENT = Parsetree.row_field *) = {\n prf_desc : row_field_desc;\n prf_loc : Location.t;\n prf_attributes : attributes;\n }\n\n and row_field_desc (*IF_CURRENT = Parsetree.row_field_desc *) =\n | Rtag of label loc * bool * core_type list\n (* [`A] ( true, [] )\n [`A of T] ( false, [T] )\n [`A of T1 & .. & Tn] ( false, [T1;...Tn] )\n [`A of & T1 & .. & Tn] ( true, [T1;...Tn] )\n\n - The 'bool' field is true if the tag contains a\n constant (empty) constructor.\n - '&' occurs when several types are used for the same constructor\n (see 4.2 in the manual)\n *)\n | Rinherit of core_type\n (* [ T ] *)\n\n and object_field (*IF_CURRENT = Parsetree.object_field *) = {\n pof_desc : object_field_desc;\n pof_loc : Location.t;\n pof_attributes : attributes;\n }\n\n and object_field_desc (*IF_CURRENT = Parsetree.object_field_desc *) =\n | Otag of label loc * core_type\n | Oinherit of core_type\n\n (* Patterns *)\n\n and pattern (*IF_CURRENT = Parsetree.pattern *) =\n {\n ppat_desc: pattern_desc;\n ppat_loc: Location.t;\n ppat_loc_stack: Location.t list;\n ppat_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and pat = pattern\n\n and pattern_desc (*IF_CURRENT = Parsetree.pattern_desc *) =\n | Ppat_any\n (* _ *)\n | Ppat_var of string loc\n (* x *)\n | Ppat_alias of pattern * string loc\n (* P as 'a *)\n | Ppat_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Ppat_interval of constant * constant\n (* 'a'..'z'\n\n Other forms of interval are recognized by the parser\n but rejected by the type-checker. *)\n | Ppat_tuple of pattern list\n (* (P1, ..., Pn)\n\n Invariant: n >= 2\n *)\n | Ppat_construct of Longident.t loc * pattern option\n (* C None\n C P Some P\n C (P1, ..., Pn) Some (Ppat_tuple [P1; ...; Pn])\n *)\n | Ppat_variant of label * pattern option\n (* `A (None)\n `A P (Some P)\n *)\n | Ppat_record of (Longident.t loc * pattern) list * closed_flag\n (* { l1=P1; ...; ln=Pn } (flag = Closed)\n { l1=P1; ...; ln=Pn; _} (flag = Open)\n\n Invariant: n > 0\n *)\n | Ppat_array of pattern list\n (* [| P1; ...; Pn |] *)\n | Ppat_or of pattern * pattern\n (* P1 | P2 *)\n | Ppat_constraint of pattern * core_type\n (* (P : T) *)\n | Ppat_type of Longident.t loc\n (* #tconst *)\n | Ppat_lazy of pattern\n (* lazy P *)\n | Ppat_unpack of string loc\n (* (module P)\n Note: (module P : S) is represented as\n Ppat_constraint(Ppat_unpack, Ptyp_package)\n *)\n | Ppat_exception of pattern\n (* exception P *)\n | Ppat_extension of extension\n (* [%id] *)\n | Ppat_open of Longident.t loc * pattern\n (* M.(P) *)\n\n (* Value expressions *)\n\n and expression (*IF_CURRENT = Parsetree.expression *) =\n {\n pexp_desc: expression_desc;\n pexp_loc: Location.t;\n pexp_loc_stack: Location.t list;\n pexp_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and expr = expression\n\n and expression_desc (*IF_CURRENT = Parsetree.expression_desc *) =\n | Pexp_ident of Longident.t loc\n (* x\n M.x\n *)\n | Pexp_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Pexp_let of rec_flag * value_binding list * expression\n (* let P1 = E1 and ... and Pn = EN in E (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in E (flag = Recursive)\n *)\n | Pexp_function of cases\n (* function P1 -> E1 | ... | Pn -> En *)\n | Pexp_fun of arg_label * expression option * pattern * expression\n (* fun P -> E1 (Simple, None)\n fun ~l:P -> E1 (Labelled l, None)\n fun ?l:P -> E1 (Optional l, None)\n fun ?l:(P = E0) -> E1 (Optional l, Some E0)\n\n Notes:\n - If E0 is provided, only Optional is allowed.\n - \"fun P1 P2 .. Pn -> E1\" is represented as nested Pexp_fun.\n - \"let f P = E\" is represented using Pexp_fun.\n *)\n | Pexp_apply of expression * (arg_label * expression) list\n (* E0 ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pexp_match of expression * cases\n (* match E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_try of expression * cases\n (* try E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_tuple of expression list\n (* (E1, ..., En)\n\n Invariant: n >= 2\n *)\n | Pexp_construct of Longident.t loc * expression option\n (* C None\n C E Some E\n C (E1, ..., En) Some (Pexp_tuple[E1;...;En])\n *)\n | Pexp_variant of label * expression option\n (* `A (None)\n `A E (Some E)\n *)\n | Pexp_record of (Longident.t loc * expression) list * expression option\n (* { l1=P1; ...; ln=Pn } (None)\n { E0 with l1=P1; ...; ln=Pn } (Some E0)\n\n Invariant: n > 0\n *)\n | Pexp_field of expression * Longident.t loc\n (* E.l *)\n | Pexp_setfield of expression * Longident.t loc * expression\n (* E1.l <- E2 *)\n | Pexp_array of expression list\n (* [| E1; ...; En |] *)\n | Pexp_ifthenelse of expression * expression * expression option\n (* if E1 then E2 else E3 *)\n | Pexp_sequence of expression * expression\n (* E1; E2 *)\n | Pexp_while of expression * expression\n (* while E1 do E2 done *)\n | Pexp_for of\n pattern * expression * expression * direction_flag * expression\n (* for i = E1 to E2 do E3 done (flag = Upto)\n for i = E1 downto E2 do E3 done (flag = Downto)\n *)\n | Pexp_constraint of expression * core_type\n (* (E : T) *)\n | Pexp_coerce of expression * core_type option * core_type\n (* (E :> T) (None, T)\n (E : T0 :> T) (Some T0, T)\n *)\n | Pexp_send of expression * label loc\n (* E # m *)\n | Pexp_new of Longident.t loc\n (* new M.c *)\n | Pexp_setinstvar of label loc * expression\n (* x <- 2 *)\n | Pexp_override of (label loc * expression) list\n (* {< x1 = E1; ...; Xn = En >} *)\n | Pexp_letmodule of string loc * module_expr * expression\n (* let module M = ME in E *)\n | Pexp_letexception of extension_constructor * expression\n (* let exception C in E *)\n | Pexp_assert of expression\n (* assert E\n Note: \"assert false\" is treated in a special way by the\n type-checker. *)\n | Pexp_lazy of expression\n (* lazy E *)\n | Pexp_poly of expression * core_type option\n (* Used for method bodies.\n\n Can only be used as the expression under Cfk_concrete\n for methods (not values). *)\n | Pexp_object of class_structure\n (* object ... end *)\n | Pexp_newtype of string loc * expression\n (* fun (type t) -> E *)\n | Pexp_pack of module_expr\n (* (module ME)\n\n (module ME : S) is represented as\n Pexp_constraint(Pexp_pack, Ptyp_package S) *)\n | Pexp_open of open_declaration * expression\n (* M.(E)\n let open M in E\n let! open M in E *)\n | Pexp_letop of letop\n (* let* P = E in E\n let* P = E and* P = E in E *)\n | Pexp_extension of extension\n (* [%id] *)\n | Pexp_unreachable\n (* . *)\n\n and case (*IF_CURRENT = Parsetree.case *) = (* (P -> E) or (P when E0 -> E) *)\n {\n pc_lhs: pattern;\n pc_guard: expression option;\n pc_rhs: expression;\n }\n\n and cases = case list\n\n and letop (*IF_CURRENT = Parsetree.letop *) =\n {\n let_ : binding_op;\n ands : binding_op list;\n body : expression;\n }\n\n and binding_op (*IF_CURRENT = Parsetree.binding_op *) =\n {\n pbop_op : string loc;\n pbop_pat : pattern;\n pbop_exp : expression;\n pbop_loc : Location.t;\n }\n\n (* Value descriptions *)\n\n and value_description (*IF_CURRENT = Parsetree.value_description *) =\n {\n pval_name: string loc;\n pval_type: core_type;\n pval_prim: string list;\n pval_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pval_loc: Location.t;\n }\n\n(*\n val x: T (prim = [])\n external x: T = \"s1\" ... \"sn\" (prim = [\"s1\";...\"sn\"])\n *)\n\n (* Type declarations *)\n\n and type_declaration (*IF_CURRENT = Parsetree.type_declaration *) =\n {\n ptype_name: string loc;\n ptype_params: (core_type * variance) list;\n (* ('a1,...'an) t; None represents _*)\n ptype_cstrs: (core_type * core_type * Location.t) list;\n (* ... constraint T1=T1' ... constraint Tn=Tn' *)\n ptype_kind: type_kind;\n ptype_private: private_flag; (* = private ... *)\n ptype_manifest: core_type option; (* = T *)\n ptype_attributes: attributes; (* ... [@@id1] [@@id2] *)\n ptype_loc: Location.t;\n }\n\n(*\n type t (abstract, no manifest)\n type t = T0 (abstract, manifest=T0)\n type t = C of T | ... (variant, no manifest)\n type t = T0 = C of T | ... (variant, manifest=T0)\n type t = {l: T; ...} (record, no manifest)\n type t = T0 = {l : T; ...} (record, manifest=T0)\n type t = .. (open, no manifest)\n *)\n\n and type_kind (*IF_CURRENT = Parsetree.type_kind *) =\n | Ptype_abstract\n | Ptype_variant of constructor_declaration list\n | Ptype_record of label_declaration list\n (* Invariant: non-empty list *)\n | Ptype_open\n\n and label_declaration (*IF_CURRENT = Parsetree.label_declaration *) =\n {\n pld_name: string loc;\n pld_mutable: mutable_flag;\n pld_type: core_type;\n pld_loc: Location.t;\n pld_attributes: attributes; (* l : T [@id1] [@id2] *)\n }\n\n (* { ...; l: T; ... } (mutable=Immutable)\n { ...; mutable l: T; ... } (mutable=Mutable)\n\n Note: T can be a Ptyp_poly.\n *)\n\n and constructor_declaration (*IF_CURRENT = Parsetree.constructor_declaration *) =\n {\n pcd_name: string loc;\n pcd_args: constructor_arguments;\n pcd_res: core_type option;\n pcd_loc: Location.t;\n pcd_attributes: attributes; (* C of ... [@id1] [@id2] *)\n }\n\n and constructor_arguments (*IF_CURRENT = Parsetree.constructor_arguments *) =\n | Pcstr_tuple of core_type list\n | Pcstr_record of label_declaration list\n\n(*\n | C of T1 * ... * Tn (res = None, args = Pcstr_tuple [])\n | C: T0 (res = Some T0, args = [])\n | C: T1 * ... * Tn -> T0 (res = Some T0, args = Pcstr_tuple)\n | C of {...} (res = None, args = Pcstr_record)\n | C: {...} -> T0 (res = Some T0, args = Pcstr_record)\n | C of {...} as t (res = None, args = Pcstr_record)\n *)\n\n and type_extension (*IF_CURRENT = Parsetree.type_extension *) =\n {\n ptyext_path: Longident.t loc;\n ptyext_params: (core_type * variance) list;\n ptyext_constructors: extension_constructor list;\n ptyext_private: private_flag;\n ptyext_loc: Location.t;\n ptyext_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n(*\n type t += ...\n *)\n\n and extension_constructor (*IF_CURRENT = Parsetree.extension_constructor *) =\n {\n pext_name: string loc;\n pext_kind : extension_constructor_kind;\n pext_loc : Location.t;\n pext_attributes: attributes; (* C of ... [@id1] [@id2] *)\n }\n\n (* exception E *)\n and type_exception (*IF_CURRENT = Parsetree.type_exception *) =\n {\n ptyexn_constructor: extension_constructor;\n ptyexn_loc: Location.t;\n ptyexn_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and extension_constructor_kind (*IF_CURRENT = Parsetree.extension_constructor_kind *) =\n Pext_decl of constructor_arguments * core_type option\n (*\n | C of T1 * ... * Tn ([T1; ...; Tn], None)\n | C: T0 ([], Some T0)\n | C: T1 * ... * Tn -> T0 ([T1; ...; Tn], Some T0)\n *)\n | Pext_rebind of Longident.t loc\n (*\n | C = D\n *)\n\n (** {1 Class language} *)\n\n (* Type expressions for the class language *)\n\n and class_type (*IF_CURRENT = Parsetree.class_type *) =\n {\n pcty_desc: class_type_desc;\n pcty_loc: Location.t;\n pcty_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and class_type_desc (*IF_CURRENT = Parsetree.class_type_desc *) =\n | Pcty_constr of Longident.t loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcty_signature of class_signature\n (* object ... end *)\n | Pcty_arrow of arg_label * core_type * class_type\n (* T -> CT Simple\n ~l:T -> CT Labelled l\n ?l:T -> CT Optional l\n *)\n | Pcty_extension of extension\n (* [%id] *)\n | Pcty_open of open_description * class_type\n (* let open M in CT *)\n\n and class_signature (*IF_CURRENT = Parsetree.class_signature *) =\n {\n pcsig_self: core_type;\n pcsig_fields: class_type_field list;\n }\n (* object('selfpat) ... end\n object ... end (self = Ptyp_any)\n *)\n\n and class_type_field (*IF_CURRENT = Parsetree.class_type_field *) =\n {\n pctf_desc: class_type_field_desc;\n pctf_loc: Location.t;\n pctf_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and class_type_field_desc (*IF_CURRENT = Parsetree.class_type_field_desc *) =\n | Pctf_inherit of class_type\n (* inherit CT *)\n | Pctf_val of (label loc * mutable_flag * virtual_flag * core_type)\n (* val x: T *)\n | Pctf_method of (label loc * private_flag * virtual_flag * core_type)\n (* method x: T\n\n Note: T can be a Ptyp_poly.\n *)\n | Pctf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pctf_attribute of attribute\n (* [@@@id] *)\n | Pctf_extension of extension\n (* [%%id] *)\n\n and 'a class_infos (*IF_CURRENT = 'a Parsetree.class_infos *) =\n {\n pci_virt: virtual_flag;\n pci_params: (core_type * variance) list;\n pci_name: string loc;\n pci_expr: 'a;\n pci_loc: Location.t;\n pci_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n (* class c = ...\n class ['a1,...,'an] c = ...\n class virtual c = ...\n\n Also used for \"class type\" declaration.\n *)\n\n and class_description = class_type class_infos\n\n and class_type_declaration = class_type class_infos\n\n (* Value expressions for the class language *)\n\n and class_expr (*IF_CURRENT = Parsetree.class_expr *) =\n {\n pcl_desc: class_expr_desc;\n pcl_loc: Location.t;\n pcl_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and class_expr_desc (*IF_CURRENT = Parsetree.class_expr_desc *) =\n | Pcl_constr of Longident.t loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcl_structure of class_structure\n (* object ... end *)\n | Pcl_fun of arg_label * expression option * pattern * class_expr\n (* fun P -> CE (Simple, None)\n fun ~l:P -> CE (Labelled l, None)\n fun ?l:P -> CE (Optional l, None)\n fun ?l:(P = E0) -> CE (Optional l, Some E0)\n *)\n | Pcl_apply of class_expr * (arg_label * expression) list\n (* CE ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pcl_let of rec_flag * value_binding list * class_expr\n (* let P1 = E1 and ... and Pn = EN in CE (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in CE (flag = Recursive)\n *)\n | Pcl_constraint of class_expr * class_type\n (* (CE : CT) *)\n | Pcl_extension of extension\n (* [%id] *)\n | Pcl_open of open_description * class_expr\n (* let open M in CE *)\n\n\n and class_structure (*IF_CURRENT = Parsetree.class_structure *) =\n {\n pcstr_self: pattern;\n pcstr_fields: class_field list;\n }\n (* object(selfpat) ... end\n object ... end (self = Ppat_any)\n *)\n\n and class_field (*IF_CURRENT = Parsetree.class_field *) =\n {\n pcf_desc: class_field_desc;\n pcf_loc: Location.t;\n pcf_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and class_field_desc (*IF_CURRENT = Parsetree.class_field_desc *) =\n | Pcf_inherit of override_flag * class_expr * string loc option\n (* inherit CE\n inherit CE as x\n inherit! CE\n inherit! CE as x\n *)\n | Pcf_val of (label loc * mutable_flag * class_field_kind)\n (* val x = E\n val virtual x: T\n *)\n | Pcf_method of (label loc * private_flag * class_field_kind)\n (* method x = E (E can be a Pexp_poly)\n method virtual x: T (T can be a Ptyp_poly)\n *)\n | Pcf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pcf_initializer of expression\n (* initializer E *)\n | Pcf_attribute of attribute\n (* [@@@id] *)\n | Pcf_extension of extension\n (* [%%id] *)\n\n and class_field_kind (*IF_CURRENT = Parsetree.class_field_kind *) =\n | Cfk_virtual of core_type\n | Cfk_concrete of override_flag * expression\n\n and class_declaration = class_expr class_infos\n\n (** {1 Module language} *)\n\n (* Type expressions for the module language *)\n\n and module_type (*IF_CURRENT = Parsetree.module_type *) =\n {\n pmty_desc: module_type_desc;\n pmty_loc: Location.t;\n pmty_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and module_type_desc (*IF_CURRENT = Parsetree.module_type_desc *) =\n | Pmty_ident of Longident.t loc\n (* S *)\n | Pmty_signature of signature\n (* sig ... end *)\n | Pmty_functor of string loc * module_type option * module_type\n (* functor(X : MT1) -> MT2 *)\n | Pmty_with of module_type * with_constraint list\n (* MT with ... *)\n | Pmty_typeof of module_expr\n (* module type of ME *)\n | Pmty_extension of extension\n (* [%id] *)\n | Pmty_alias of Longident.t loc\n (* (module M) *)\n\n and signature = signature_item list\n\n and signature_item (*IF_CURRENT = Parsetree.signature_item *) =\n {\n psig_desc: signature_item_desc;\n psig_loc: Location.t;\n }\n\n and signature_item_desc (*IF_CURRENT = Parsetree.signature_item_desc *) =\n | Psig_value of value_description\n (*\n val x: T\n external x: T = \"s1\" ... \"sn\"\n *)\n | Psig_type of rec_flag * type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Psig_typesubst of type_declaration list\n (* type t1 := ... and ... and tn := ... *)\n | Psig_typext of type_extension\n (* type t1 += ... *)\n | Psig_exception of type_exception\n (* exception C of T *)\n | Psig_module of module_declaration\n (* module X = M\n module X : MT *)\n | Psig_modsubst of module_substitution\n (* module X := M *)\n | Psig_recmodule of module_declaration list\n (* module rec X1 : MT1 and ... and Xn : MTn *)\n | Psig_modtype of module_type_declaration\n (* module type S = MT\n module type S *)\n | Psig_open of open_description\n (* open X *)\n | Psig_include of include_description\n (* include MT *)\n | Psig_class of class_description list\n (* class c1 : ... and ... and cn : ... *)\n | Psig_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Psig_attribute of attribute\n (* [@@@id] *)\n | Psig_extension of extension * attributes\n (* [%%id] *)\n\n and module_declaration (*IF_CURRENT = Parsetree.module_declaration *) =\n {\n pmd_name: string loc;\n pmd_type: module_type;\n pmd_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pmd_loc: Location.t;\n }\n (* S : MT *)\n\n and module_substitution (*IF_CURRENT = Parsetree.module_substitution *) =\n {\n pms_name: string loc;\n pms_manifest: Longident.t loc;\n pms_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pms_loc: Location.t;\n }\n\n and module_type_declaration (*IF_CURRENT = Parsetree.module_type_declaration *) =\n {\n pmtd_name: string loc;\n pmtd_type: module_type option;\n pmtd_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pmtd_loc: Location.t;\n }\n (* S = MT\n S (abstract module type declaration, pmtd_type = None)\n *)\n\n and 'a open_infos (*IF_CURRENT = 'a Parsetree.open_infos *) =\n {\n popen_expr: 'a;\n popen_override: override_flag;\n popen_loc: Location.t;\n popen_attributes: attributes;\n }\n (* open! X - popen_override = Override (silences the 'used identifier\n shadowing' warning)\n open X - popen_override = Fresh\n *)\n\n and open_description = Longident.t loc open_infos\n (* open M.N\n open M(N).O *)\n\n and open_declaration = module_expr open_infos\n (* open M.N\n open M(N).O\n open struct ... end *)\n\n and 'a include_infos (*IF_CURRENT = 'a Parsetree.include_infos *) =\n {\n pincl_mod: 'a;\n pincl_loc: Location.t;\n pincl_attributes: attributes;\n }\n\n and include_description = module_type include_infos\n (* include MT *)\n\n and include_declaration = module_expr include_infos\n (* include ME *)\n\n and with_constraint (*IF_CURRENT = Parsetree.with_constraint *) =\n | Pwith_type of Longident.t loc * type_declaration\n (* with type X.t = ...\n\n Note: the last component of the longident must match\n the name of the type_declaration. *)\n | Pwith_module of Longident.t loc * Longident.t loc\n (* with module X.Y = Z *)\n | Pwith_typesubst of Longident.t loc * type_declaration\n (* with type X.t := ..., same format as [Pwith_type] *)\n | Pwith_modsubst of Longident.t loc * Longident.t loc\n (* with module X.Y := Z *)\n\n (* Value expressions for the module language *)\n\n and module_expr (*IF_CURRENT = Parsetree.module_expr *) =\n {\n pmod_desc: module_expr_desc;\n pmod_loc: Location.t;\n pmod_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and module_expr_desc (*IF_CURRENT = Parsetree.module_expr_desc *) =\n | Pmod_ident of Longident.t loc\n (* X *)\n | Pmod_structure of structure\n (* struct ... end *)\n | Pmod_functor of string loc * module_type option * module_expr\n (* functor(X : MT1) -> ME *)\n | Pmod_apply of module_expr * module_expr\n (* ME1(ME2) *)\n | Pmod_constraint of module_expr * module_type\n (* (ME : MT) *)\n | Pmod_unpack of expression\n (* (val E) *)\n | Pmod_extension of extension\n (* [%id] *)\n\n and structure = structure_item list\n\n and structure_item (*IF_CURRENT = Parsetree.structure_item *) =\n {\n pstr_desc: structure_item_desc;\n pstr_loc: Location.t;\n }\n\n and structure_item_desc (*IF_CURRENT = Parsetree.structure_item_desc *) =\n | Pstr_eval of expression * attributes\n (* E *)\n | Pstr_value of rec_flag * value_binding list\n (* let P1 = E1 and ... and Pn = EN (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN (flag = Recursive)\n *)\n | Pstr_primitive of value_description\n (* val x: T\n external x: T = \"s1\" ... \"sn\" *)\n | Pstr_type of rec_flag * type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Pstr_typext of type_extension\n (* type t1 += ... *)\n | Pstr_exception of type_exception\n (* exception C of T\n exception C = M.X *)\n | Pstr_module of module_binding\n (* module X = ME *)\n | Pstr_recmodule of module_binding list\n (* module rec X1 = ME1 and ... and Xn = MEn *)\n | Pstr_modtype of module_type_declaration\n (* module type S = MT *)\n | Pstr_open of open_declaration\n (* open X *)\n | Pstr_class of class_declaration list\n (* class c1 = ... and ... and cn = ... *)\n | Pstr_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Pstr_include of include_declaration\n (* include ME *)\n | Pstr_attribute of attribute\n (* [@@@id] *)\n | Pstr_extension of extension * attributes\n (* [%%id] *)\n\n and value_binding (*IF_CURRENT = Parsetree.value_binding *) =\n {\n pvb_pat: pattern;\n pvb_expr: expression;\n pvb_attributes: attributes;\n pvb_loc: Location.t;\n }\n\n and module_binding (*IF_CURRENT = Parsetree.module_binding *) =\n {\n pmb_name: string loc;\n pmb_expr: module_expr;\n pmb_attributes: attributes;\n pmb_loc: Location.t;\n }\n (* X = ME *)\n\n (** {1 Toplevel} *)\n\n (* Toplevel phrases *)\n\n type toplevel_phrase (*IF_CURRENT = Parsetree.toplevel_phrase *) =\n | Ptop_def of structure\n | Ptop_dir of toplevel_directive\n (* #use, #load ... *)\n\n and toplevel_directive (*IF_CURRENT = Parsetree.toplevel_directive *) =\n {\n pdir_name : string loc;\n pdir_arg : directive_argument option;\n pdir_loc : Location.t;\n }\n\n and directive_argument (*IF_CURRENT = Parsetree.directive_argument *) =\n {\n pdira_desc : directive_argument_desc;\n pdira_loc : Location.t;\n }\n\n and directive_argument_desc (*IF_CURRENT = Parsetree.directive_argument_desc *) =\n | Pdir_string of string\n | Pdir_int of string * char option\n | Pdir_ident of Longident.t\n | Pdir_bool of bool\n\nend\n\nmodule Config = struct\n let ast_impl_magic_number = \"Caml1999M026\"\n let ast_intf_magic_number = \"Caml1999N026\"\nend\n","(**************************************************************************)\n(* *)\n(* OCaml Migrate Parsetree *)\n(* *)\n(* Frédéric Bour, Facebook *)\n(* Jérémie Dimino and Leo White, Jane Street Europe *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* Alain Frisch, LexiFi *)\n(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 2018 Institut National de Recherche en Informatique et *)\n(* en Automatique (INRIA). *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* Ast ported on Thu Mar 21 09:50:42 GMT 2019\n OCaml was:\n commit 55c9ba466362f303eb4d5ed511f6fda142879137 (HEAD -> 4.08, origin/4.08)\n Author: Nicolás Ojeda Bär \n Date: Tue Mar 19 08:11:02 2019 +0100\n\n Merge pull request #8521 from nojb/fix_unix_tests_408\n\n Actually run all lib-unix tests [4.08]\n*)\n\nmodule Asttypes = struct\n\n type constant (*IF_CURRENT = Asttypes.constant *) =\n Const_int of int\n | Const_char of char\n | Const_string of string * string option\n | Const_float of string\n | Const_int32 of int32\n | Const_int64 of int64\n | Const_nativeint of nativeint\n\n type rec_flag (*IF_CURRENT = Asttypes.rec_flag *) = Nonrecursive | Recursive\n\n type direction_flag (*IF_CURRENT = Asttypes.direction_flag *) = Upto | Downto\n\n (* Order matters, used in polymorphic comparison *)\n type private_flag (*IF_CURRENT = Asttypes.private_flag *) = Private | Public\n\n type mutable_flag (*IF_CURRENT = Asttypes.mutable_flag *) = Immutable | Mutable\n\n type virtual_flag (*IF_CURRENT = Asttypes.virtual_flag *) = Virtual | Concrete\n\n type override_flag (*IF_CURRENT = Asttypes.override_flag *) = Override | Fresh\n\n type closed_flag (*IF_CURRENT = Asttypes.closed_flag *) = Closed | Open\n\n type label = string\n\n type arg_label (*IF_CURRENT = Asttypes.arg_label *) =\n Nolabel\n | Labelled of string (* label:T -> ... *)\n | Optional of string (* ?label:T -> ... *)\n\n type 'a loc = 'a Location.loc = {\n txt : 'a;\n loc : Location.t;\n }\n\n\n type variance (*IF_CURRENT = Asttypes.variance *) =\n | Covariant\n | Contravariant\n | Invariant\n\nend\n\nmodule Parsetree = struct\n\n open Asttypes\n\n type constant (*IF_CURRENT = Parsetree.constant *) =\n Pconst_integer of string * char option\n (* 3 3l 3L 3n\n\n Suffixes [g-z][G-Z] are accepted by the parser.\n Suffixes except 'l', 'L' and 'n' are rejected by the typechecker\n *)\n | Pconst_char of char\n (* 'c' *)\n | Pconst_string of string * string option\n (* \"constant\"\n {delim|other constant|delim}\n *)\n | Pconst_float of string * char option\n (* 3.4 2e5 1.4e-4\n\n Suffixes [g-z][G-Z] are accepted by the parser.\n Suffixes are rejected by the typechecker.\n *)\n\n (** {1 Extension points} *)\n\n type attribute (*IF_CURRENT = Parsetree.attribute *) = {\n attr_name : string loc;\n attr_payload : payload;\n attr_loc : Location.t;\n }\n (* [@id ARG]\n [@@id ARG]\n\n Metadata containers passed around within the AST.\n The compiler ignores unknown attributes.\n *)\n\n and extension = string loc * payload\n (* [%id ARG]\n [%%id ARG]\n\n Sub-language placeholder -- rejected by the typechecker.\n *)\n\n and attributes = attribute list\n\n and payload (*IF_CURRENT = Parsetree.payload *) =\n | PStr of structure\n | PSig of signature (* : SIG *)\n | PTyp of core_type (* : T *)\n | PPat of pattern * expression option (* ? P or ? P when E *)\n\n (** {1 Core language} *)\n\n (* Type expressions *)\n\n and core_type (*IF_CURRENT = Parsetree.core_type *) =\n {\n ptyp_desc: core_type_desc;\n ptyp_loc: Location.t;\n ptyp_loc_stack: Location.t list;\n ptyp_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and typ = core_type\n\n and core_type_desc (*IF_CURRENT = Parsetree.core_type_desc *) =\n | Ptyp_any\n (* _ *)\n | Ptyp_var of string\n (* 'a *)\n | Ptyp_arrow of arg_label * core_type * core_type\n (* T1 -> T2 Simple\n ~l:T1 -> T2 Labelled\n ?l:T1 -> T2 Optional\n *)\n | Ptyp_tuple of core_type list\n (* T1 * ... * Tn\n\n Invariant: n >= 2\n *)\n | Ptyp_constr of Longident.t loc * core_type list\n (* tconstr\n T tconstr\n (T1, ..., Tn) tconstr\n *)\n | Ptyp_object of object_field list * closed_flag\n (* < l1:T1; ...; ln:Tn > (flag = Closed)\n < l1:T1; ...; ln:Tn; .. > (flag = Open)\n *)\n | Ptyp_class of Longident.t loc * core_type list\n (* #tconstr\n T #tconstr\n (T1, ..., Tn) #tconstr\n *)\n | Ptyp_alias of core_type * string\n (* T as 'a *)\n | Ptyp_variant of row_field list * closed_flag * label list option\n (* [ `A|`B ] (flag = Closed; labels = None)\n [> `A|`B ] (flag = Open; labels = None)\n [< `A|`B ] (flag = Closed; labels = Some [])\n [< `A|`B > `X `Y ](flag = Closed; labels = Some [\"X\";\"Y\"])\n *)\n | Ptyp_poly of string loc list * core_type\n (* 'a1 ... 'an. T\n\n Can only appear in the following context:\n\n - As the core_type of a Ppat_constraint node corresponding\n to a constraint on a let-binding: let x : 'a1 ... 'an. T\n = e ...\n\n - Under Cfk_virtual for methods (not values).\n\n - As the core_type of a Pctf_method node.\n\n - As the core_type of a Pexp_poly node.\n\n - As the pld_type field of a label_declaration.\n\n - As a core_type of a Ptyp_object node.\n *)\n\n | Ptyp_package of package_type\n (* (module S) *)\n | Ptyp_extension of extension\n (* [%id] *)\n\n and package_type = Longident.t loc * (Longident.t loc * core_type) list\n (*\n (module S)\n (module S with type t1 = T1 and ... and tn = Tn)\n *)\n\n and row_field (*IF_CURRENT = Parsetree.row_field *) = {\n prf_desc : row_field_desc;\n prf_loc : Location.t;\n prf_attributes : attributes;\n }\n\n and row_field_desc (*IF_CURRENT = Parsetree.row_field_desc *) =\n | Rtag of label loc * bool * core_type list\n (* [`A] ( true, [] )\n [`A of T] ( false, [T] )\n [`A of T1 & .. & Tn] ( false, [T1;...Tn] )\n [`A of & T1 & .. & Tn] ( true, [T1;...Tn] )\n\n - The 'bool' field is true if the tag contains a\n constant (empty) constructor.\n - '&' occurs when several types are used for the same constructor\n (see 4.2 in the manual)\n *)\n | Rinherit of core_type\n (* [ T ] *)\n\n and object_field (*IF_CURRENT = Parsetree.object_field *) = {\n pof_desc : object_field_desc;\n pof_loc : Location.t;\n pof_attributes : attributes;\n }\n\n and object_field_desc (*IF_CURRENT = Parsetree.object_field_desc *) =\n | Otag of label loc * core_type\n | Oinherit of core_type\n\n (* Patterns *)\n\n and pattern (*IF_CURRENT = Parsetree.pattern *) =\n {\n ppat_desc: pattern_desc;\n ppat_loc: Location.t;\n ppat_loc_stack: Location.t list;\n ppat_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and pat = pattern\n\n and pattern_desc (*IF_CURRENT = Parsetree.pattern_desc *) =\n | Ppat_any\n (* _ *)\n | Ppat_var of string loc\n (* x *)\n | Ppat_alias of pattern * string loc\n (* P as 'a *)\n | Ppat_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Ppat_interval of constant * constant\n (* 'a'..'z'\n\n Other forms of interval are recognized by the parser\n but rejected by the type-checker. *)\n | Ppat_tuple of pattern list\n (* (P1, ..., Pn)\n\n Invariant: n >= 2\n *)\n | Ppat_construct of Longident.t loc * pattern option\n (* C None\n C P Some P\n C (P1, ..., Pn) Some (Ppat_tuple [P1; ...; Pn])\n *)\n | Ppat_variant of label * pattern option\n (* `A (None)\n `A P (Some P)\n *)\n | Ppat_record of (Longident.t loc * pattern) list * closed_flag\n (* { l1=P1; ...; ln=Pn } (flag = Closed)\n { l1=P1; ...; ln=Pn; _} (flag = Open)\n\n Invariant: n > 0\n *)\n | Ppat_array of pattern list\n (* [| P1; ...; Pn |] *)\n | Ppat_or of pattern * pattern\n (* P1 | P2 *)\n | Ppat_constraint of pattern * core_type\n (* (P : T) *)\n | Ppat_type of Longident.t loc\n (* #tconst *)\n | Ppat_lazy of pattern\n (* lazy P *)\n | Ppat_unpack of string loc\n (* (module P)\n Note: (module P : S) is represented as\n Ppat_constraint(Ppat_unpack, Ptyp_package)\n *)\n | Ppat_exception of pattern\n (* exception P *)\n | Ppat_extension of extension\n (* [%id] *)\n | Ppat_open of Longident.t loc * pattern\n (* M.(P) *)\n\n (* Value expressions *)\n\n and expression (*IF_CURRENT = Parsetree.expression *) =\n {\n pexp_desc: expression_desc;\n pexp_loc: Location.t;\n pexp_loc_stack: Location.t list;\n pexp_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and expr = expression\n\n and expression_desc (*IF_CURRENT = Parsetree.expression_desc *) =\n | Pexp_ident of Longident.t loc\n (* x\n M.x\n *)\n | Pexp_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Pexp_let of rec_flag * value_binding list * expression\n (* let P1 = E1 and ... and Pn = EN in E (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in E (flag = Recursive)\n *)\n | Pexp_function of cases\n (* function P1 -> E1 | ... | Pn -> En *)\n | Pexp_fun of arg_label * expression option * pattern * expression\n (* fun P -> E1 (Simple, None)\n fun ~l:P -> E1 (Labelled l, None)\n fun ?l:P -> E1 (Optional l, None)\n fun ?l:(P = E0) -> E1 (Optional l, Some E0)\n\n Notes:\n - If E0 is provided, only Optional is allowed.\n - \"fun P1 P2 .. Pn -> E1\" is represented as nested Pexp_fun.\n - \"let f P = E\" is represented using Pexp_fun.\n *)\n | Pexp_apply of expression * (arg_label * expression) list\n (* E0 ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pexp_match of expression * cases\n (* match E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_try of expression * cases\n (* try E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_tuple of expression list\n (* (E1, ..., En)\n\n Invariant: n >= 2\n *)\n | Pexp_construct of Longident.t loc * expression option\n (* C None\n C E Some E\n C (E1, ..., En) Some (Pexp_tuple[E1;...;En])\n *)\n | Pexp_variant of label * expression option\n (* `A (None)\n `A E (Some E)\n *)\n | Pexp_record of (Longident.t loc * expression) list * expression option\n (* { l1=P1; ...; ln=Pn } (None)\n { E0 with l1=P1; ...; ln=Pn } (Some E0)\n\n Invariant: n > 0\n *)\n | Pexp_field of expression * Longident.t loc\n (* E.l *)\n | Pexp_setfield of expression * Longident.t loc * expression\n (* E1.l <- E2 *)\n | Pexp_array of expression list\n (* [| E1; ...; En |] *)\n | Pexp_ifthenelse of expression * expression * expression option\n (* if E1 then E2 else E3 *)\n | Pexp_sequence of expression * expression\n (* E1; E2 *)\n | Pexp_while of expression * expression\n (* while E1 do E2 done *)\n | Pexp_for of\n pattern * expression * expression * direction_flag * expression\n (* for i = E1 to E2 do E3 done (flag = Upto)\n for i = E1 downto E2 do E3 done (flag = Downto)\n *)\n | Pexp_constraint of expression * core_type\n (* (E : T) *)\n | Pexp_coerce of expression * core_type option * core_type\n (* (E :> T) (None, T)\n (E : T0 :> T) (Some T0, T)\n *)\n | Pexp_send of expression * label loc\n (* E # m *)\n | Pexp_new of Longident.t loc\n (* new M.c *)\n | Pexp_setinstvar of label loc * expression\n (* x <- 2 *)\n | Pexp_override of (label loc * expression) list\n (* {< x1 = E1; ...; Xn = En >} *)\n | Pexp_letmodule of string loc * module_expr * expression\n (* let module M = ME in E *)\n | Pexp_letexception of extension_constructor * expression\n (* let exception C in E *)\n | Pexp_assert of expression\n (* assert E\n Note: \"assert false\" is treated in a special way by the\n type-checker. *)\n | Pexp_lazy of expression\n (* lazy E *)\n | Pexp_poly of expression * core_type option\n (* Used for method bodies.\n\n Can only be used as the expression under Cfk_concrete\n for methods (not values). *)\n | Pexp_object of class_structure\n (* object ... end *)\n | Pexp_newtype of string loc * expression\n (* fun (type t) -> E *)\n | Pexp_pack of module_expr\n (* (module ME)\n\n (module ME : S) is represented as\n Pexp_constraint(Pexp_pack, Ptyp_package S) *)\n | Pexp_open of open_declaration * expression\n (* M.(E)\n let open M in E\n let! open M in E *)\n | Pexp_letop of letop\n (* let* P = E in E\n let* P = E and* P = E in E *)\n | Pexp_extension of extension\n (* [%id] *)\n | Pexp_unreachable\n (* . *)\n\n and case (*IF_CURRENT = Parsetree.case *) = (* (P -> E) or (P when E0 -> E) *)\n {\n pc_lhs: pattern;\n pc_guard: expression option;\n pc_rhs: expression;\n }\n\n and cases = case list\n\n and letop (*IF_CURRENT = Parsetree.letop *) =\n {\n let_ : binding_op;\n ands : binding_op list;\n body : expression;\n }\n\n and binding_op (*IF_CURRENT = Parsetree.binding_op *) =\n {\n pbop_op : string loc;\n pbop_pat : pattern;\n pbop_exp : expression;\n pbop_loc : Location.t;\n }\n\n (* Value descriptions *)\n\n and value_description (*IF_CURRENT = Parsetree.value_description *) =\n {\n pval_name: string loc;\n pval_type: core_type;\n pval_prim: string list;\n pval_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pval_loc: Location.t;\n }\n\n(*\n val x: T (prim = [])\n external x: T = \"s1\" ... \"sn\" (prim = [\"s1\";...\"sn\"])\n *)\n\n (* Type declarations *)\n\n and type_declaration (*IF_CURRENT = Parsetree.type_declaration *) =\n {\n ptype_name: string loc;\n ptype_params: (core_type * variance) list;\n (* ('a1,...'an) t; None represents _*)\n ptype_cstrs: (core_type * core_type * Location.t) list;\n (* ... constraint T1=T1' ... constraint Tn=Tn' *)\n ptype_kind: type_kind;\n ptype_private: private_flag; (* = private ... *)\n ptype_manifest: core_type option; (* = T *)\n ptype_attributes: attributes; (* ... [@@id1] [@@id2] *)\n ptype_loc: Location.t;\n }\n\n(*\n type t (abstract, no manifest)\n type t = T0 (abstract, manifest=T0)\n type t = C of T | ... (variant, no manifest)\n type t = T0 = C of T | ... (variant, manifest=T0)\n type t = {l: T; ...} (record, no manifest)\n type t = T0 = {l : T; ...} (record, manifest=T0)\n type t = .. (open, no manifest)\n *)\n\n and type_kind (*IF_CURRENT = Parsetree.type_kind *) =\n | Ptype_abstract\n | Ptype_variant of constructor_declaration list\n | Ptype_record of label_declaration list\n (* Invariant: non-empty list *)\n | Ptype_open\n\n and label_declaration (*IF_CURRENT = Parsetree.label_declaration *) =\n {\n pld_name: string loc;\n pld_mutable: mutable_flag;\n pld_type: core_type;\n pld_loc: Location.t;\n pld_attributes: attributes; (* l : T [@id1] [@id2] *)\n }\n\n (* { ...; l: T; ... } (mutable=Immutable)\n { ...; mutable l: T; ... } (mutable=Mutable)\n\n Note: T can be a Ptyp_poly.\n *)\n\n and constructor_declaration (*IF_CURRENT = Parsetree.constructor_declaration *) =\n {\n pcd_name: string loc;\n pcd_args: constructor_arguments;\n pcd_res: core_type option;\n pcd_loc: Location.t;\n pcd_attributes: attributes; (* C of ... [@id1] [@id2] *)\n }\n\n and constructor_arguments (*IF_CURRENT = Parsetree.constructor_arguments *) =\n | Pcstr_tuple of core_type list\n | Pcstr_record of label_declaration list\n\n(*\n | C of T1 * ... * Tn (res = None, args = Pcstr_tuple [])\n | C: T0 (res = Some T0, args = [])\n | C: T1 * ... * Tn -> T0 (res = Some T0, args = Pcstr_tuple)\n | C of {...} (res = None, args = Pcstr_record)\n | C: {...} -> T0 (res = Some T0, args = Pcstr_record)\n | C of {...} as t (res = None, args = Pcstr_record)\n *)\n\n and type_extension (*IF_CURRENT = Parsetree.type_extension *) =\n {\n ptyext_path: Longident.t loc;\n ptyext_params: (core_type * variance) list;\n ptyext_constructors: extension_constructor list;\n ptyext_private: private_flag;\n ptyext_loc: Location.t;\n ptyext_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n(*\n type t += ...\n *)\n\n and extension_constructor (*IF_CURRENT = Parsetree.extension_constructor *) =\n {\n pext_name: string loc;\n pext_kind : extension_constructor_kind;\n pext_loc : Location.t;\n pext_attributes: attributes; (* C of ... [@id1] [@id2] *)\n }\n\n (* exception E *)\n and type_exception (*IF_CURRENT = Parsetree.type_exception *) =\n {\n ptyexn_constructor: extension_constructor;\n ptyexn_loc: Location.t;\n ptyexn_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and extension_constructor_kind (*IF_CURRENT = Parsetree.extension_constructor_kind *) =\n Pext_decl of constructor_arguments * core_type option\n (*\n | C of T1 * ... * Tn ([T1; ...; Tn], None)\n | C: T0 ([], Some T0)\n | C: T1 * ... * Tn -> T0 ([T1; ...; Tn], Some T0)\n *)\n | Pext_rebind of Longident.t loc\n (*\n | C = D\n *)\n\n (** {1 Class language} *)\n\n (* Type expressions for the class language *)\n\n and class_type (*IF_CURRENT = Parsetree.class_type *) =\n {\n pcty_desc: class_type_desc;\n pcty_loc: Location.t;\n pcty_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and class_type_desc (*IF_CURRENT = Parsetree.class_type_desc *) =\n | Pcty_constr of Longident.t loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcty_signature of class_signature\n (* object ... end *)\n | Pcty_arrow of arg_label * core_type * class_type\n (* T -> CT Simple\n ~l:T -> CT Labelled l\n ?l:T -> CT Optional l\n *)\n | Pcty_extension of extension\n (* [%id] *)\n | Pcty_open of open_description * class_type\n (* let open M in CT *)\n\n and class_signature (*IF_CURRENT = Parsetree.class_signature *) =\n {\n pcsig_self: core_type;\n pcsig_fields: class_type_field list;\n }\n (* object('selfpat) ... end\n object ... end (self = Ptyp_any)\n *)\n\n and class_type_field (*IF_CURRENT = Parsetree.class_type_field *) =\n {\n pctf_desc: class_type_field_desc;\n pctf_loc: Location.t;\n pctf_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and class_type_field_desc (*IF_CURRENT = Parsetree.class_type_field_desc *) =\n | Pctf_inherit of class_type\n (* inherit CT *)\n | Pctf_val of (label loc * mutable_flag * virtual_flag * core_type)\n (* val x: T *)\n | Pctf_method of (label loc * private_flag * virtual_flag * core_type)\n (* method x: T\n\n Note: T can be a Ptyp_poly.\n *)\n | Pctf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pctf_attribute of attribute\n (* [@@@id] *)\n | Pctf_extension of extension\n (* [%%id] *)\n\n and 'a class_infos (*IF_CURRENT = 'a Parsetree.class_infos *) =\n {\n pci_virt: virtual_flag;\n pci_params: (core_type * variance) list;\n pci_name: string loc;\n pci_expr: 'a;\n pci_loc: Location.t;\n pci_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n (* class c = ...\n class ['a1,...,'an] c = ...\n class virtual c = ...\n\n Also used for \"class type\" declaration.\n *)\n\n and class_description = class_type class_infos\n\n and class_type_declaration = class_type class_infos\n\n (* Value expressions for the class language *)\n\n and class_expr (*IF_CURRENT = Parsetree.class_expr *) =\n {\n pcl_desc: class_expr_desc;\n pcl_loc: Location.t;\n pcl_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and class_expr_desc (*IF_CURRENT = Parsetree.class_expr_desc *) =\n | Pcl_constr of Longident.t loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcl_structure of class_structure\n (* object ... end *)\n | Pcl_fun of arg_label * expression option * pattern * class_expr\n (* fun P -> CE (Simple, None)\n fun ~l:P -> CE (Labelled l, None)\n fun ?l:P -> CE (Optional l, None)\n fun ?l:(P = E0) -> CE (Optional l, Some E0)\n *)\n | Pcl_apply of class_expr * (arg_label * expression) list\n (* CE ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pcl_let of rec_flag * value_binding list * class_expr\n (* let P1 = E1 and ... and Pn = EN in CE (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in CE (flag = Recursive)\n *)\n | Pcl_constraint of class_expr * class_type\n (* (CE : CT) *)\n | Pcl_extension of extension\n (* [%id] *)\n | Pcl_open of open_description * class_expr\n (* let open M in CE *)\n\n\n and class_structure (*IF_CURRENT = Parsetree.class_structure *) =\n {\n pcstr_self: pattern;\n pcstr_fields: class_field list;\n }\n (* object(selfpat) ... end\n object ... end (self = Ppat_any)\n *)\n\n and class_field (*IF_CURRENT = Parsetree.class_field *) =\n {\n pcf_desc: class_field_desc;\n pcf_loc: Location.t;\n pcf_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and class_field_desc (*IF_CURRENT = Parsetree.class_field_desc *) =\n | Pcf_inherit of override_flag * class_expr * string loc option\n (* inherit CE\n inherit CE as x\n inherit! CE\n inherit! CE as x\n *)\n | Pcf_val of (label loc * mutable_flag * class_field_kind)\n (* val x = E\n val virtual x: T\n *)\n | Pcf_method of (label loc * private_flag * class_field_kind)\n (* method x = E (E can be a Pexp_poly)\n method virtual x: T (T can be a Ptyp_poly)\n *)\n | Pcf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pcf_initializer of expression\n (* initializer E *)\n | Pcf_attribute of attribute\n (* [@@@id] *)\n | Pcf_extension of extension\n (* [%%id] *)\n\n and class_field_kind (*IF_CURRENT = Parsetree.class_field_kind *) =\n | Cfk_virtual of core_type\n | Cfk_concrete of override_flag * expression\n\n and class_declaration = class_expr class_infos\n\n (** {1 Module language} *)\n\n (* Type expressions for the module language *)\n\n and module_type (*IF_CURRENT = Parsetree.module_type *) =\n {\n pmty_desc: module_type_desc;\n pmty_loc: Location.t;\n pmty_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and module_type_desc (*IF_CURRENT = Parsetree.module_type_desc *) =\n | Pmty_ident of Longident.t loc\n (* S *)\n | Pmty_signature of signature\n (* sig ... end *)\n | Pmty_functor of string loc * module_type option * module_type\n (* functor(X : MT1) -> MT2 *)\n | Pmty_with of module_type * with_constraint list\n (* MT with ... *)\n | Pmty_typeof of module_expr\n (* module type of ME *)\n | Pmty_extension of extension\n (* [%id] *)\n | Pmty_alias of Longident.t loc\n (* (module M) *)\n\n and signature = signature_item list\n\n and signature_item (*IF_CURRENT = Parsetree.signature_item *) =\n {\n psig_desc: signature_item_desc;\n psig_loc: Location.t;\n }\n\n and signature_item_desc (*IF_CURRENT = Parsetree.signature_item_desc *) =\n | Psig_value of value_description\n (*\n val x: T\n external x: T = \"s1\" ... \"sn\"\n *)\n | Psig_type of rec_flag * type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Psig_typesubst of type_declaration list\n (* type t1 := ... and ... and tn := ... *)\n | Psig_typext of type_extension\n (* type t1 += ... *)\n | Psig_exception of type_exception\n (* exception C of T *)\n | Psig_module of module_declaration\n (* module X = M\n module X : MT *)\n | Psig_modsubst of module_substitution\n (* module X := M *)\n | Psig_recmodule of module_declaration list\n (* module rec X1 : MT1 and ... and Xn : MTn *)\n | Psig_modtype of module_type_declaration\n (* module type S = MT\n module type S *)\n | Psig_open of open_description\n (* open X *)\n | Psig_include of include_description\n (* include MT *)\n | Psig_class of class_description list\n (* class c1 : ... and ... and cn : ... *)\n | Psig_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Psig_attribute of attribute\n (* [@@@id] *)\n | Psig_extension of extension * attributes\n (* [%%id] *)\n\n and module_declaration (*IF_CURRENT = Parsetree.module_declaration *) =\n {\n pmd_name: string loc;\n pmd_type: module_type;\n pmd_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pmd_loc: Location.t;\n }\n (* S : MT *)\n\n and module_substitution (*IF_CURRENT = Parsetree.module_substitution *) =\n {\n pms_name: string loc;\n pms_manifest: Longident.t loc;\n pms_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pms_loc: Location.t;\n }\n\n and module_type_declaration (*IF_CURRENT = Parsetree.module_type_declaration *) =\n {\n pmtd_name: string loc;\n pmtd_type: module_type option;\n pmtd_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pmtd_loc: Location.t;\n }\n (* S = MT\n S (abstract module type declaration, pmtd_type = None)\n *)\n\n and 'a open_infos (*IF_CURRENT = 'a Parsetree.open_infos *) =\n {\n popen_expr: 'a;\n popen_override: override_flag;\n popen_loc: Location.t;\n popen_attributes: attributes;\n }\n (* open! X - popen_override = Override (silences the 'used identifier\n shadowing' warning)\n open X - popen_override = Fresh\n *)\n\n and open_description = Longident.t loc open_infos\n (* open M.N\n open M(N).O *)\n\n and open_declaration = module_expr open_infos\n (* open M.N\n open M(N).O\n open struct ... end *)\n\n and 'a include_infos (*IF_CURRENT = 'a Parsetree.include_infos *) =\n {\n pincl_mod: 'a;\n pincl_loc: Location.t;\n pincl_attributes: attributes;\n }\n\n and include_description = module_type include_infos\n (* include MT *)\n\n and include_declaration = module_expr include_infos\n (* include ME *)\n\n and with_constraint (*IF_CURRENT = Parsetree.with_constraint *) =\n | Pwith_type of Longident.t loc * type_declaration\n (* with type X.t = ...\n\n Note: the last component of the longident must match\n the name of the type_declaration. *)\n | Pwith_module of Longident.t loc * Longident.t loc\n (* with module X.Y = Z *)\n | Pwith_typesubst of Longident.t loc * type_declaration\n (* with type X.t := ..., same format as [Pwith_type] *)\n | Pwith_modsubst of Longident.t loc * Longident.t loc\n (* with module X.Y := Z *)\n\n (* Value expressions for the module language *)\n\n and module_expr (*IF_CURRENT = Parsetree.module_expr *) =\n {\n pmod_desc: module_expr_desc;\n pmod_loc: Location.t;\n pmod_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and module_expr_desc (*IF_CURRENT = Parsetree.module_expr_desc *) =\n | Pmod_ident of Longident.t loc\n (* X *)\n | Pmod_structure of structure\n (* struct ... end *)\n | Pmod_functor of string loc * module_type option * module_expr\n (* functor(X : MT1) -> ME *)\n | Pmod_apply of module_expr * module_expr\n (* ME1(ME2) *)\n | Pmod_constraint of module_expr * module_type\n (* (ME : MT) *)\n | Pmod_unpack of expression\n (* (val E) *)\n | Pmod_extension of extension\n (* [%id] *)\n\n and structure = structure_item list\n\n and structure_item (*IF_CURRENT = Parsetree.structure_item *) =\n {\n pstr_desc: structure_item_desc;\n pstr_loc: Location.t;\n }\n\n and structure_item_desc (*IF_CURRENT = Parsetree.structure_item_desc *) =\n | Pstr_eval of expression * attributes\n (* E *)\n | Pstr_value of rec_flag * value_binding list\n (* let P1 = E1 and ... and Pn = EN (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN (flag = Recursive)\n *)\n | Pstr_primitive of value_description\n (* val x: T\n external x: T = \"s1\" ... \"sn\" *)\n | Pstr_type of rec_flag * type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Pstr_typext of type_extension\n (* type t1 += ... *)\n | Pstr_exception of type_exception\n (* exception C of T\n exception C = M.X *)\n | Pstr_module of module_binding\n (* module X = ME *)\n | Pstr_recmodule of module_binding list\n (* module rec X1 = ME1 and ... and Xn = MEn *)\n | Pstr_modtype of module_type_declaration\n (* module type S = MT *)\n | Pstr_open of open_declaration\n (* open X *)\n | Pstr_class of class_declaration list\n (* class c1 = ... and ... and cn = ... *)\n | Pstr_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Pstr_include of include_declaration\n (* include ME *)\n | Pstr_attribute of attribute\n (* [@@@id] *)\n | Pstr_extension of extension * attributes\n (* [%%id] *)\n\n and value_binding (*IF_CURRENT = Parsetree.value_binding *) =\n {\n pvb_pat: pattern;\n pvb_expr: expression;\n pvb_attributes: attributes;\n pvb_loc: Location.t;\n }\n\n and module_binding (*IF_CURRENT = Parsetree.module_binding *) =\n {\n pmb_name: string loc;\n pmb_expr: module_expr;\n pmb_attributes: attributes;\n pmb_loc: Location.t;\n }\n (* X = ME *)\n\n (** {1 Toplevel} *)\n\n (* Toplevel phrases *)\n\n type toplevel_phrase (*IF_CURRENT = Parsetree.toplevel_phrase *) =\n | Ptop_def of structure\n | Ptop_dir of toplevel_directive\n (* #use, #load ... *)\n\n and toplevel_directive (*IF_CURRENT = Parsetree.toplevel_directive *) =\n {\n pdir_name : string loc;\n pdir_arg : directive_argument option;\n pdir_loc : Location.t;\n }\n\n and directive_argument (*IF_CURRENT = Parsetree.directive_argument *) =\n {\n pdira_desc : directive_argument_desc;\n pdira_loc : Location.t;\n }\n\n and directive_argument_desc (*IF_CURRENT = Parsetree.directive_argument_desc *) =\n | Pdir_string of string\n | Pdir_int of string * char option\n | Pdir_ident of Longident.t\n | Pdir_bool of bool\n\nend\n\nmodule Config = struct\n let ast_impl_magic_number = \"Caml1999M025\"\n let ast_intf_magic_number = \"Caml1999N025\"\nend\n","(**************************************************************************)\n(* *)\n(* OCaml Migrate Parsetree *)\n(* *)\n(* Frédéric Bour, Facebook *)\n(* Jérémie Dimino and Leo White, Jane Street Europe *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* Alain Frisch, LexiFi *)\n(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 2018 Institut National de Recherche en Informatique et *)\n(* en Automatique (INRIA). *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* Ast ported on Wed Apr 18 10:33:29 BST 2018\n OCaml trunk was:\n commit c0bd6a27e138911560f43dc75d5fde2ade4d6cfe (HEAD, tag: 4.07.0+beta2)\n Author: Damien Doligez \n Date: Tue Apr 10 14:50:48 2018 +0200\n\n change VERSION for 4.07.0+beta2\n*)\n\nmodule Asttypes = struct\n (** Auxiliary AST types used by parsetree and typedtree. *)\n\n type constant (*IF_CURRENT = Asttypes.constant *) =\n Const_int of int\n | Const_char of char\n | Const_string of string * string option\n | Const_float of string\n | Const_int32 of int32\n | Const_int64 of int64\n | Const_nativeint of nativeint\n\n type rec_flag (*IF_CURRENT = Asttypes.rec_flag *) = Nonrecursive | Recursive\n\n type direction_flag (*IF_CURRENT = Asttypes.direction_flag *) = Upto | Downto\n\n (* Order matters, used in polymorphic comparison *)\n type private_flag (*IF_CURRENT = Asttypes.private_flag *) = Private | Public\n\n type mutable_flag (*IF_CURRENT = Asttypes.mutable_flag *) = Immutable | Mutable\n\n type virtual_flag (*IF_CURRENT = Asttypes.virtual_flag *) = Virtual | Concrete\n\n type override_flag (*IF_CURRENT = Asttypes.override_flag *) = Override | Fresh\n\n type closed_flag (*IF_CURRENT = Asttypes.closed_flag *) = Closed | Open\n\n type label = string\n\n type arg_label (*IF_CURRENT = Asttypes.arg_label *) =\n Nolabel\n | Labelled of string (* label:T -> ... *)\n | Optional of string (* ?label:T -> ... *)\n\n type 'a loc = 'a Location.loc = {\n txt : 'a;\n loc : Location.t;\n }\n\n\n type variance (*IF_CURRENT = Asttypes.variance *) =\n | Covariant\n | Contravariant\n | Invariant\nend\n\nmodule Parsetree = struct\n (** Abstract syntax tree produced by parsing *)\n\n open Asttypes\n\n type constant (*IF_CURRENT = Parsetree.constant *) =\n Pconst_integer of string * char option\n (* 3 3l 3L 3n\n\n Suffixes [g-z][G-Z] are accepted by the parser.\n Suffixes except 'l', 'L' and 'n' are rejected by the typechecker\n *)\n | Pconst_char of char\n (* 'c' *)\n | Pconst_string of string * string option\n (* \"constant\"\n {delim|other constant|delim}\n *)\n | Pconst_float of string * char option\n (* 3.4 2e5 1.4e-4\n\n Suffixes [g-z][G-Z] are accepted by the parser.\n Suffixes are rejected by the typechecker.\n *)\n\n (** {1 Extension points} *)\n\n type attribute = string loc * payload\n (* [@id ARG]\n [@@id ARG]\n\n Metadata containers passed around within the AST.\n The compiler ignores unknown attributes.\n *)\n\n and extension = string loc * payload\n (* [%id ARG]\n [%%id ARG]\n\n Sub-language placeholder -- rejected by the typechecker.\n *)\n\n and attributes = attribute list\n\n and payload (*IF_CURRENT = Parsetree.payload *) =\n | PStr of structure\n | PSig of signature (* : SIG *)\n | PTyp of core_type (* : T *)\n | PPat of pattern * expression option (* ? P or ? P when E *)\n\n (** {1 Core language} *)\n\n (* Type expressions *)\n\n and core_type (*IF_CURRENT = Parsetree.core_type *) =\n {\n ptyp_desc: core_type_desc;\n ptyp_loc: Location.t;\n ptyp_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and core_type_desc (*IF_CURRENT = Parsetree.core_type_desc *) =\n | Ptyp_any\n (* _ *)\n | Ptyp_var of string\n (* 'a *)\n | Ptyp_arrow of arg_label * core_type * core_type\n (* T1 -> T2 Simple\n ~l:T1 -> T2 Labelled\n ?l:T1 -> T2 Optional\n *)\n | Ptyp_tuple of core_type list\n (* T1 * ... * Tn\n\n Invariant: n >= 2\n *)\n | Ptyp_constr of Longident.t loc * core_type list\n (* tconstr\n T tconstr\n (T1, ..., Tn) tconstr\n *)\n | Ptyp_object of object_field list * closed_flag\n (* < l1:T1; ...; ln:Tn > (flag = Closed)\n < l1:T1; ...; ln:Tn; .. > (flag = Open)\n *)\n | Ptyp_class of Longident.t loc * core_type list\n (* #tconstr\n T #tconstr\n (T1, ..., Tn) #tconstr\n *)\n | Ptyp_alias of core_type * string\n (* T as 'a *)\n | Ptyp_variant of row_field list * closed_flag * label list option\n (* [ `A|`B ] (flag = Closed; labels = None)\n [> `A|`B ] (flag = Open; labels = None)\n [< `A|`B ] (flag = Closed; labels = Some [])\n [< `A|`B > `X `Y ](flag = Closed; labels = Some [\"X\";\"Y\"])\n *)\n | Ptyp_poly of string loc list * core_type\n (* 'a1 ... 'an. T\n\n Can only appear in the following context:\n\n - As the core_type of a Ppat_constraint node corresponding\n to a constraint on a let-binding: let x : 'a1 ... 'an. T\n = e ...\n\n - Under Cfk_virtual for methods (not values).\n\n - As the core_type of a Pctf_method node.\n\n - As the core_type of a Pexp_poly node.\n\n - As the pld_type field of a label_declaration.\n\n - As a core_type of a Ptyp_object node.\n *)\n\n | Ptyp_package of package_type\n (* (module S) *)\n | Ptyp_extension of extension\n (* [%id] *)\n\n and package_type = Longident.t loc * (Longident.t loc * core_type) list\n (*\n (module S)\n (module S with type t1 = T1 and ... and tn = Tn)\n *)\n\n and row_field (*IF_CURRENT = Parsetree.row_field *) =\n | Rtag of label loc * attributes * bool * core_type list\n (* [`A] ( true, [] )\n [`A of T] ( false, [T] )\n [`A of T1 & .. & Tn] ( false, [T1;...Tn] )\n [`A of & T1 & .. & Tn] ( true, [T1;...Tn] )\n\n - The 2nd field is true if the tag contains a\n constant (empty) constructor.\n - '&' occurs when several types are used for the same constructor\n (see 4.2 in the manual)\n\n - TODO: switch to a record representation, and keep location\n *)\n | Rinherit of core_type\n (* [ T ] *)\n\n and object_field (*IF_CURRENT = Parsetree.object_field *) =\n | Otag of label loc * attributes * core_type\n | Oinherit of core_type\n\n (* Patterns *)\n\n and pattern (*IF_CURRENT = Parsetree.pattern *) =\n {\n ppat_desc: pattern_desc;\n ppat_loc: Location.t;\n ppat_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and pattern_desc (*IF_CURRENT = Parsetree.pattern_desc *) =\n | Ppat_any\n (* _ *)\n | Ppat_var of string loc\n (* x *)\n | Ppat_alias of pattern * string loc\n (* P as 'a *)\n | Ppat_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Ppat_interval of constant * constant\n (* 'a'..'z'\n\n Other forms of interval are recognized by the parser\n but rejected by the type-checker. *)\n | Ppat_tuple of pattern list\n (* (P1, ..., Pn)\n\n Invariant: n >= 2\n *)\n | Ppat_construct of Longident.t loc * pattern option\n (* C None\n C P Some P\n C (P1, ..., Pn) Some (Ppat_tuple [P1; ...; Pn])\n *)\n | Ppat_variant of label * pattern option\n (* `A (None)\n `A P (Some P)\n *)\n | Ppat_record of (Longident.t loc * pattern) list * closed_flag\n (* { l1=P1; ...; ln=Pn } (flag = Closed)\n { l1=P1; ...; ln=Pn; _} (flag = Open)\n\n Invariant: n > 0\n *)\n | Ppat_array of pattern list\n (* [| P1; ...; Pn |] *)\n | Ppat_or of pattern * pattern\n (* P1 | P2 *)\n | Ppat_constraint of pattern * core_type\n (* (P : T) *)\n | Ppat_type of Longident.t loc\n (* #tconst *)\n | Ppat_lazy of pattern\n (* lazy P *)\n | Ppat_unpack of string loc\n (* (module P)\n Note: (module P : S) is represented as\n Ppat_constraint(Ppat_unpack, Ptyp_package)\n *)\n | Ppat_exception of pattern\n (* exception P *)\n | Ppat_extension of extension\n (* [%id] *)\n | Ppat_open of Longident.t loc * pattern\n (* M.(P) *)\n\n (* Value expressions *)\n\n and expression (*IF_CURRENT = Parsetree.expression *) =\n {\n pexp_desc: expression_desc;\n pexp_loc: Location.t;\n pexp_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and expression_desc (*IF_CURRENT = Parsetree.expression_desc *) =\n | Pexp_ident of Longident.t loc\n (* x\n M.x\n *)\n | Pexp_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Pexp_let of rec_flag * value_binding list * expression\n (* let P1 = E1 and ... and Pn = EN in E (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in E (flag = Recursive)\n *)\n | Pexp_function of case list\n (* function P1 -> E1 | ... | Pn -> En *)\n | Pexp_fun of arg_label * expression option * pattern * expression\n (* fun P -> E1 (Simple, None)\n fun ~l:P -> E1 (Labelled l, None)\n fun ?l:P -> E1 (Optional l, None)\n fun ?l:(P = E0) -> E1 (Optional l, Some E0)\n\n Notes:\n - If E0 is provided, only Optional is allowed.\n - \"fun P1 P2 .. Pn -> E1\" is represented as nested Pexp_fun.\n - \"let f P = E\" is represented using Pexp_fun.\n *)\n | Pexp_apply of expression * (arg_label * expression) list\n (* E0 ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pexp_match of expression * case list\n (* match E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_try of expression * case list\n (* try E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_tuple of expression list\n (* (E1, ..., En)\n\n Invariant: n >= 2\n *)\n | Pexp_construct of Longident.t loc * expression option\n (* C None\n C E Some E\n C (E1, ..., En) Some (Pexp_tuple[E1;...;En])\n *)\n | Pexp_variant of label * expression option\n (* `A (None)\n `A E (Some E)\n *)\n | Pexp_record of (Longident.t loc * expression) list * expression option\n (* { l1=P1; ...; ln=Pn } (None)\n { E0 with l1=P1; ...; ln=Pn } (Some E0)\n\n Invariant: n > 0\n *)\n | Pexp_field of expression * Longident.t loc\n (* E.l *)\n | Pexp_setfield of expression * Longident.t loc * expression\n (* E1.l <- E2 *)\n | Pexp_array of expression list\n (* [| E1; ...; En |] *)\n | Pexp_ifthenelse of expression * expression * expression option\n (* if E1 then E2 else E3 *)\n | Pexp_sequence of expression * expression\n (* E1; E2 *)\n | Pexp_while of expression * expression\n (* while E1 do E2 done *)\n | Pexp_for of\n pattern * expression * expression * direction_flag * expression\n (* for i = E1 to E2 do E3 done (flag = Upto)\n for i = E1 downto E2 do E3 done (flag = Downto)\n *)\n | Pexp_constraint of expression * core_type\n (* (E : T) *)\n | Pexp_coerce of expression * core_type option * core_type\n (* (E :> T) (None, T)\n (E : T0 :> T) (Some T0, T)\n *)\n | Pexp_send of expression * label loc\n (* E # m *)\n | Pexp_new of Longident.t loc\n (* new M.c *)\n | Pexp_setinstvar of label loc * expression\n (* x <- 2 *)\n | Pexp_override of (label loc * expression) list\n (* {< x1 = E1; ...; Xn = En >} *)\n | Pexp_letmodule of string loc * module_expr * expression\n (* let module M = ME in E *)\n | Pexp_letexception of extension_constructor * expression\n (* let exception C in E *)\n | Pexp_assert of expression\n (* assert E\n Note: \"assert false\" is treated in a special way by the\n type-checker. *)\n | Pexp_lazy of expression\n (* lazy E *)\n | Pexp_poly of expression * core_type option\n (* Used for method bodies.\n\n Can only be used as the expression under Cfk_concrete\n for methods (not values). *)\n | Pexp_object of class_structure\n (* object ... end *)\n | Pexp_newtype of string loc * expression\n (* fun (type t) -> E *)\n | Pexp_pack of module_expr\n (* (module ME)\n\n (module ME : S) is represented as\n Pexp_constraint(Pexp_pack, Ptyp_package S) *)\n | Pexp_open of override_flag * Longident.t loc * expression\n (* M.(E)\n let open M in E\n let! open M in E *)\n | Pexp_extension of extension\n (* [%id] *)\n | Pexp_unreachable\n (* . *)\n\n and case (*IF_CURRENT = Parsetree.case *) = (* (P -> E) or (P when E0 -> E) *)\n {\n pc_lhs: pattern;\n pc_guard: expression option;\n pc_rhs: expression;\n }\n\n (* Value descriptions *)\n\n and value_description (*IF_CURRENT = Parsetree.value_description *) =\n {\n pval_name: string loc;\n pval_type: core_type;\n pval_prim: string list;\n pval_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pval_loc: Location.t;\n }\n\n (*\n val x: T (prim = [])\n external x: T = \"s1\" ... \"sn\" (prim = [\"s1\";...\"sn\"])\n *)\n\n (* Type declarations *)\n\n and type_declaration (*IF_CURRENT = Parsetree.type_declaration *) =\n {\n ptype_name: string loc;\n ptype_params: (core_type * variance) list;\n (* ('a1,...'an) t; None represents _*)\n ptype_cstrs: (core_type * core_type * Location.t) list;\n (* ... constraint T1=T1' ... constraint Tn=Tn' *)\n ptype_kind: type_kind;\n ptype_private: private_flag; (* = private ... *)\n ptype_manifest: core_type option; (* = T *)\n ptype_attributes: attributes; (* ... [@@id1] [@@id2] *)\n ptype_loc: Location.t;\n }\n\n (*\n type t (abstract, no manifest)\n type t = T0 (abstract, manifest=T0)\n type t = C of T | ... (variant, no manifest)\n type t = T0 = C of T | ... (variant, manifest=T0)\n type t = {l: T; ...} (record, no manifest)\n type t = T0 = {l : T; ...} (record, manifest=T0)\n type t = .. (open, no manifest)\n *)\n\n and type_kind (*IF_CURRENT = Parsetree.type_kind *) =\n | Ptype_abstract\n | Ptype_variant of constructor_declaration list\n | Ptype_record of label_declaration list\n (* Invariant: non-empty list *)\n | Ptype_open\n\n and label_declaration (*IF_CURRENT = Parsetree.label_declaration *) =\n {\n pld_name: string loc;\n pld_mutable: mutable_flag;\n pld_type: core_type;\n pld_loc: Location.t;\n pld_attributes: attributes; (* l : T [@id1] [@id2] *)\n }\n\n (* { ...; l: T; ... } (mutable=Immutable)\n { ...; mutable l: T; ... } (mutable=Mutable)\n\n Note: T can be a Ptyp_poly.\n *)\n\n and constructor_declaration (*IF_CURRENT = Parsetree.constructor_declaration *) =\n {\n pcd_name: string loc;\n pcd_args: constructor_arguments;\n pcd_res: core_type option;\n pcd_loc: Location.t;\n pcd_attributes: attributes; (* C of ... [@id1] [@id2] *)\n }\n\n and constructor_arguments (*IF_CURRENT = Parsetree.constructor_arguments *) =\n | Pcstr_tuple of core_type list\n | Pcstr_record of label_declaration list\n\n (*\n | C of T1 * ... * Tn (res = None, args = Pcstr_tuple [])\n | C: T0 (res = Some T0, args = [])\n | C: T1 * ... * Tn -> T0 (res = Some T0, args = Pcstr_tuple)\n | C of {...} (res = None, args = Pcstr_record)\n | C: {...} -> T0 (res = Some T0, args = Pcstr_record)\n | C of {...} as t (res = None, args = Pcstr_record)\n *)\n\n and type_extension (*IF_CURRENT = Parsetree.type_extension *) =\n {\n ptyext_path: Longident.t loc;\n ptyext_params: (core_type * variance) list;\n ptyext_constructors: extension_constructor list;\n ptyext_private: private_flag;\n ptyext_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n (*\n type t += ...\n *)\n\n and extension_constructor (*IF_CURRENT = Parsetree.extension_constructor *) =\n {\n pext_name: string loc;\n pext_kind : extension_constructor_kind;\n pext_loc : Location.t;\n pext_attributes: attributes; (* C of ... [@id1] [@id2] *)\n }\n\n and extension_constructor_kind (*IF_CURRENT = Parsetree.extension_constructor_kind *) =\n Pext_decl of constructor_arguments * core_type option\n (*\n | C of T1 * ... * Tn ([T1; ...; Tn], None)\n | C: T0 ([], Some T0)\n | C: T1 * ... * Tn -> T0 ([T1; ...; Tn], Some T0)\n *)\n | Pext_rebind of Longident.t loc\n (*\n | C = D\n *)\n\n (** {1 Class language} *)\n\n (* Type expressions for the class language *)\n\n and class_type (*IF_CURRENT = Parsetree.class_type *) =\n {\n pcty_desc: class_type_desc;\n pcty_loc: Location.t;\n pcty_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and class_type_desc (*IF_CURRENT = Parsetree.class_type_desc *) =\n | Pcty_constr of Longident.t loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcty_signature of class_signature\n (* object ... end *)\n | Pcty_arrow of arg_label * core_type * class_type\n (* T -> CT Simple\n ~l:T -> CT Labelled l\n ?l:T -> CT Optional l\n *)\n | Pcty_extension of extension\n (* [%id] *)\n | Pcty_open of override_flag * Longident.t loc * class_type\n (* let open M in CT *)\n\n and class_signature (*IF_CURRENT = Parsetree.class_signature *) =\n {\n pcsig_self: core_type;\n pcsig_fields: class_type_field list;\n }\n (* object('selfpat) ... end\n object ... end (self = Ptyp_any)\n *)\n\n and class_type_field (*IF_CURRENT = Parsetree.class_type_field *) =\n {\n pctf_desc: class_type_field_desc;\n pctf_loc: Location.t;\n pctf_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and class_type_field_desc (*IF_CURRENT = Parsetree.class_type_field_desc *) =\n | Pctf_inherit of class_type\n (* inherit CT *)\n | Pctf_val of (label loc * mutable_flag * virtual_flag * core_type)\n (* val x: T *)\n | Pctf_method of (label loc * private_flag * virtual_flag * core_type)\n (* method x: T\n\n Note: T can be a Ptyp_poly.\n *)\n | Pctf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pctf_attribute of attribute\n (* [@@@id] *)\n | Pctf_extension of extension\n (* [%%id] *)\n\n and 'a class_infos (*IF_CURRENT = 'a Parsetree.class_infos *) =\n {\n pci_virt: virtual_flag;\n pci_params: (core_type * variance) list;\n pci_name: string loc;\n pci_expr: 'a;\n pci_loc: Location.t;\n pci_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n (* class c = ...\n class ['a1,...,'an] c = ...\n class virtual c = ...\n\n Also used for \"class type\" declaration.\n *)\n\n and class_description = class_type class_infos\n\n and class_type_declaration = class_type class_infos\n\n (* Value expressions for the class language *)\n\n and class_expr (*IF_CURRENT = Parsetree.class_expr *) =\n {\n pcl_desc: class_expr_desc;\n pcl_loc: Location.t;\n pcl_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and class_expr_desc (*IF_CURRENT = Parsetree.class_expr_desc *) =\n | Pcl_constr of Longident.t loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcl_structure of class_structure\n (* object ... end *)\n | Pcl_fun of arg_label * expression option * pattern * class_expr\n (* fun P -> CE (Simple, None)\n fun ~l:P -> CE (Labelled l, None)\n fun ?l:P -> CE (Optional l, None)\n fun ?l:(P = E0) -> CE (Optional l, Some E0)\n *)\n | Pcl_apply of class_expr * (arg_label * expression) list\n (* CE ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pcl_let of rec_flag * value_binding list * class_expr\n (* let P1 = E1 and ... and Pn = EN in CE (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in CE (flag = Recursive)\n *)\n | Pcl_constraint of class_expr * class_type\n (* (CE : CT) *)\n | Pcl_extension of extension\n (* [%id] *)\n | Pcl_open of override_flag * Longident.t loc * class_expr\n (* let open M in CE *)\n\n\n and class_structure (*IF_CURRENT = Parsetree.class_structure *) =\n {\n pcstr_self: pattern;\n pcstr_fields: class_field list;\n }\n (* object(selfpat) ... end\n object ... end (self = Ppat_any)\n *)\n\n and class_field (*IF_CURRENT = Parsetree.class_field *) =\n {\n pcf_desc: class_field_desc;\n pcf_loc: Location.t;\n pcf_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and class_field_desc (*IF_CURRENT = Parsetree.class_field_desc *) =\n | Pcf_inherit of override_flag * class_expr * string loc option\n (* inherit CE\n inherit CE as x\n inherit! CE\n inherit! CE as x\n *)\n | Pcf_val of (label loc * mutable_flag * class_field_kind)\n (* val x = E\n val virtual x: T\n *)\n | Pcf_method of (label loc * private_flag * class_field_kind)\n (* method x = E (E can be a Pexp_poly)\n method virtual x: T (T can be a Ptyp_poly)\n *)\n | Pcf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pcf_initializer of expression\n (* initializer E *)\n | Pcf_attribute of attribute\n (* [@@@id] *)\n | Pcf_extension of extension\n (* [%%id] *)\n\n and class_field_kind (*IF_CURRENT = Parsetree.class_field_kind *) =\n | Cfk_virtual of core_type\n | Cfk_concrete of override_flag * expression\n\n and class_declaration = class_expr class_infos\n\n (** {1 Module language} *)\n\n (* Type expressions for the module language *)\n\n and module_type (*IF_CURRENT = Parsetree.module_type *) =\n {\n pmty_desc: module_type_desc;\n pmty_loc: Location.t;\n pmty_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and module_type_desc (*IF_CURRENT = Parsetree.module_type_desc *) =\n | Pmty_ident of Longident.t loc\n (* S *)\n | Pmty_signature of signature\n (* sig ... end *)\n | Pmty_functor of string loc * module_type option * module_type\n (* functor(X : MT1) -> MT2 *)\n | Pmty_with of module_type * with_constraint list\n (* MT with ... *)\n | Pmty_typeof of module_expr\n (* module type of ME *)\n | Pmty_extension of extension\n (* [%id] *)\n | Pmty_alias of Longident.t loc\n (* (module M) *)\n\n and signature = signature_item list\n\n and signature_item (*IF_CURRENT = Parsetree.signature_item *) =\n {\n psig_desc: signature_item_desc;\n psig_loc: Location.t;\n }\n\n and signature_item_desc (*IF_CURRENT = Parsetree.signature_item_desc *) =\n | Psig_value of value_description\n (*\n val x: T\n external x: T = \"s1\" ... \"sn\"\n *)\n | Psig_type of rec_flag * type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Psig_typext of type_extension\n (* type t1 += ... *)\n | Psig_exception of extension_constructor\n (* exception C of T *)\n | Psig_module of module_declaration\n (* module X : MT *)\n | Psig_recmodule of module_declaration list\n (* module rec X1 : MT1 and ... and Xn : MTn *)\n | Psig_modtype of module_type_declaration\n (* module type S = MT\n module type S *)\n | Psig_open of open_description\n (* open X *)\n | Psig_include of include_description\n (* include MT *)\n | Psig_class of class_description list\n (* class c1 : ... and ... and cn : ... *)\n | Psig_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Psig_attribute of attribute\n (* [@@@id] *)\n | Psig_extension of extension * attributes\n (* [%%id] *)\n\n and module_declaration (*IF_CURRENT = Parsetree.module_declaration *) =\n {\n pmd_name: string loc;\n pmd_type: module_type;\n pmd_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pmd_loc: Location.t;\n }\n (* S : MT *)\n\n and module_type_declaration (*IF_CURRENT = Parsetree.module_type_declaration *) =\n {\n pmtd_name: string loc;\n pmtd_type: module_type option;\n pmtd_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pmtd_loc: Location.t;\n }\n (* S = MT\n S (abstract module type declaration, pmtd_type = None)\n *)\n\n and open_description (*IF_CURRENT = Parsetree.open_description *) =\n {\n popen_lid: Longident.t loc;\n popen_override: override_flag;\n popen_loc: Location.t;\n popen_attributes: attributes;\n }\n (* open! X - popen_override = Override (silences the 'used identifier\n shadowing' warning)\n open X - popen_override = Fresh\n *)\n\n and 'a include_infos (*IF_CURRENT = 'a Parsetree.include_infos *) =\n {\n pincl_mod: 'a;\n pincl_loc: Location.t;\n pincl_attributes: attributes;\n }\n\n and include_description = module_type include_infos\n (* include MT *)\n\n and include_declaration = module_expr include_infos\n (* include ME *)\n\n and with_constraint (*IF_CURRENT = Parsetree.with_constraint *) =\n | Pwith_type of Longident.t loc * type_declaration\n (* with type X.t = ...\n\n Note: the last component of the longident must match\n the name of the type_declaration. *)\n | Pwith_module of Longident.t loc * Longident.t loc\n (* with module X.Y = Z *)\n | Pwith_typesubst of Longident.t loc * type_declaration\n (* with type X.t := ..., same format as [Pwith_type] *)\n | Pwith_modsubst of Longident.t loc * Longident.t loc\n (* with module X.Y := Z *)\n\n (* Value expressions for the module language *)\n\n and module_expr (*IF_CURRENT = Parsetree.module_expr *) =\n {\n pmod_desc: module_expr_desc;\n pmod_loc: Location.t;\n pmod_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and module_expr_desc (*IF_CURRENT = Parsetree.module_expr_desc *) =\n | Pmod_ident of Longident.t loc\n (* X *)\n | Pmod_structure of structure\n (* struct ... end *)\n | Pmod_functor of string loc * module_type option * module_expr\n (* functor(X : MT1) -> ME *)\n | Pmod_apply of module_expr * module_expr\n (* ME1(ME2) *)\n | Pmod_constraint of module_expr * module_type\n (* (ME : MT) *)\n | Pmod_unpack of expression\n (* (val E) *)\n | Pmod_extension of extension\n (* [%id] *)\n\n and structure = structure_item list\n\n and structure_item (*IF_CURRENT = Parsetree.structure_item *) =\n {\n pstr_desc: structure_item_desc;\n pstr_loc: Location.t;\n }\n\n and structure_item_desc (*IF_CURRENT = Parsetree.structure_item_desc *) =\n | Pstr_eval of expression * attributes\n (* E *)\n | Pstr_value of rec_flag * value_binding list\n (* let P1 = E1 and ... and Pn = EN (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN (flag = Recursive)\n *)\n | Pstr_primitive of value_description\n (* val x: T\n external x: T = \"s1\" ... \"sn\" *)\n | Pstr_type of rec_flag * type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Pstr_typext of type_extension\n (* type t1 += ... *)\n | Pstr_exception of extension_constructor\n (* exception C of T\n exception C = M.X *)\n | Pstr_module of module_binding\n (* module X = ME *)\n | Pstr_recmodule of module_binding list\n (* module rec X1 = ME1 and ... and Xn = MEn *)\n | Pstr_modtype of module_type_declaration\n (* module type S = MT *)\n | Pstr_open of open_description\n (* open X *)\n | Pstr_class of class_declaration list\n (* class c1 = ... and ... and cn = ... *)\n | Pstr_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Pstr_include of include_declaration\n (* include ME *)\n | Pstr_attribute of attribute\n (* [@@@id] *)\n | Pstr_extension of extension * attributes\n (* [%%id] *)\n\n and value_binding (*IF_CURRENT = Parsetree.value_binding *) =\n {\n pvb_pat: pattern;\n pvb_expr: expression;\n pvb_attributes: attributes;\n pvb_loc: Location.t;\n }\n\n and module_binding (*IF_CURRENT = Parsetree.module_binding *) =\n {\n pmb_name: string loc;\n pmb_expr: module_expr;\n pmb_attributes: attributes;\n pmb_loc: Location.t;\n }\n (* X = ME *)\n\n (** {1 Toplevel} *)\n\n (* Toplevel phrases *)\n\n type toplevel_phrase (*IF_CURRENT = Parsetree.toplevel_phrase *) =\n | Ptop_def of structure\n | Ptop_dir of string * directive_argument\n (* #use, #load ... *)\n\n and directive_argument (*IF_CURRENT = Parsetree.directive_argument *) =\n | Pdir_none\n | Pdir_string of string\n | Pdir_int of string * char option\n | Pdir_ident of Longident.t\n | Pdir_bool of bool\n\nend\n\nmodule Config = struct\n let ast_impl_magic_number = \"Caml1999M023\"\n let ast_intf_magic_number = \"Caml1999N023\"\nend\n","(**************************************************************************)\n(* *)\n(* OCaml Migrate Parsetree *)\n(* *)\n(* Frédéric Bour *)\n(* Jérémie Dimino and Leo White, Jane Street Europe *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* Alain Frisch, LexiFi *)\n(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 2017 Institut National de Recherche en Informatique et *)\n(* en Automatique (INRIA). *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* Ast ported on Mon Oct 2 11:25:57 CEST 2017\n OCaml trunk was:\n commit 65940a2c6be43c42f75c6c6b255974f7e6de03ca (HEAD -> 4.06, origin/4.06)\n Author: Christophe Raffalli \n Date: Sun Oct 1 18:27:07 2017 +0200\n\n fixed position of last optional last semicolumn in sequence (#1387)\n*)\n\nmodule Asttypes = struct\n (** Auxiliary AST types used by parsetree and typedtree. *)\n\n type constant (*IF_CURRENT = Asttypes.constant *) =\n Const_int of int\n | Const_char of char\n | Const_string of string * string option\n | Const_float of string\n | Const_int32 of int32\n | Const_int64 of int64\n | Const_nativeint of nativeint\n\n type rec_flag (*IF_CURRENT = Asttypes.rec_flag *) = Nonrecursive | Recursive\n\n type direction_flag (*IF_CURRENT = Asttypes.direction_flag *) = Upto | Downto\n\n (* Order matters, used in polymorphic comparison *)\n type private_flag (*IF_CURRENT = Asttypes.private_flag *) = Private | Public\n\n type mutable_flag (*IF_CURRENT = Asttypes.mutable_flag *) = Immutable | Mutable\n\n type virtual_flag (*IF_CURRENT = Asttypes.virtual_flag *) = Virtual | Concrete\n\n type override_flag (*IF_CURRENT = Asttypes.override_flag *) = Override | Fresh\n\n type closed_flag (*IF_CURRENT = Asttypes.closed_flag *) = Closed | Open\n\n type label = string\n\n type arg_label (*IF_CURRENT = Asttypes.arg_label *) =\n Nolabel\n | Labelled of string (* label:T -> ... *)\n | Optional of string (* ?label:T -> ... *)\n\n type 'a loc = 'a Location.loc = {\n txt : 'a;\n loc : Location.t;\n }\n\n\n type variance (*IF_CURRENT = Asttypes.variance *) =\n | Covariant\n | Contravariant\n | Invariant\nend\n\nmodule Parsetree = struct\n (** Abstract syntax tree produced by parsing *)\n\n open Asttypes\n\n type constant (*IF_CURRENT = Parsetree.constant *) =\n Pconst_integer of string * char option\n (* 3 3l 3L 3n\n\n Suffixes [g-z][G-Z] are accepted by the parser.\n Suffixes except 'l', 'L' and 'n' are rejected by the typechecker\n *)\n | Pconst_char of char\n (* 'c' *)\n | Pconst_string of string * string option\n (* \"constant\"\n {delim|other constant|delim}\n *)\n | Pconst_float of string * char option\n (* 3.4 2e5 1.4e-4\n\n Suffixes [g-z][G-Z] are accepted by the parser.\n Suffixes are rejected by the typechecker.\n *)\n\n (** {2 Extension points} *)\n\n type attribute = string loc * payload\n (* [@id ARG]\n [@@id ARG]\n\n Metadata containers passed around within the AST.\n The compiler ignores unknown attributes.\n *)\n\n and extension = string loc * payload\n (* [%id ARG]\n [%%id ARG]\n\n Sub-language placeholder -- rejected by the typechecker.\n *)\n\n and attributes = attribute list\n\n and payload (*IF_CURRENT = Parsetree.payload *) =\n | PStr of structure\n | PSig of signature (* : SIG *)\n | PTyp of core_type (* : T *)\n | PPat of pattern * expression option (* ? P or ? P when E *)\n\n (** {2 Core language} *)\n\n (* Type expressions *)\n\n and core_type (*IF_CURRENT = Parsetree.core_type *) =\n {\n ptyp_desc: core_type_desc;\n ptyp_loc: Location.t;\n ptyp_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and core_type_desc (*IF_CURRENT = Parsetree.core_type_desc *) =\n | Ptyp_any\n (* _ *)\n | Ptyp_var of string\n (* 'a *)\n | Ptyp_arrow of arg_label * core_type * core_type\n (* T1 -> T2 Simple\n ~l:T1 -> T2 Labelled\n ?l:T1 -> T2 Optional\n *)\n | Ptyp_tuple of core_type list\n (* T1 * ... * Tn\n\n Invariant: n >= 2\n *)\n | Ptyp_constr of Longident.t loc * core_type list\n (* tconstr\n T tconstr\n (T1, ..., Tn) tconstr\n *)\n | Ptyp_object of object_field list * closed_flag\n (* < l1:T1; ...; ln:Tn > (flag = Closed)\n < l1:T1; ...; ln:Tn; .. > (flag = Open)\n *)\n | Ptyp_class of Longident.t loc * core_type list\n (* #tconstr\n T #tconstr\n (T1, ..., Tn) #tconstr\n *)\n | Ptyp_alias of core_type * string\n (* T as 'a *)\n | Ptyp_variant of row_field list * closed_flag * label list option\n (* [ `A|`B ] (flag = Closed; labels = None)\n [> `A|`B ] (flag = Open; labels = None)\n [< `A|`B ] (flag = Closed; labels = Some [])\n [< `A|`B > `X `Y ](flag = Closed; labels = Some [\"X\";\"Y\"])\n *)\n | Ptyp_poly of string loc list * core_type\n (* 'a1 ... 'an. T\n\n Can only appear in the following context:\n\n - As the core_type of a Ppat_constraint node corresponding\n to a constraint on a let-binding: let x : 'a1 ... 'an. T\n = e ...\n\n - Under Cfk_virtual for methods (not values).\n\n - As the core_type of a Pctf_method node.\n\n - As the core_type of a Pexp_poly node.\n\n - As the pld_type field of a label_declaration.\n\n - As a core_type of a Ptyp_object node.\n *)\n\n | Ptyp_package of package_type\n (* (module S) *)\n | Ptyp_extension of extension\n (* [%id] *)\n\n and package_type = Longident.t loc * (Longident.t loc * core_type) list\n (*\n (module S)\n (module S with type t1 = T1 and ... and tn = Tn)\n *)\n\n and row_field (*IF_CURRENT = Parsetree.row_field *) =\n | Rtag of label loc * attributes * bool * core_type list\n (* [`A] ( true, [] )\n [`A of T] ( false, [T] )\n [`A of T1 & .. & Tn] ( false, [T1;...Tn] )\n [`A of & T1 & .. & Tn] ( true, [T1;...Tn] )\n\n - The 2nd field is true if the tag contains a\n constant (empty) constructor.\n - '&' occurs when several types are used for the same constructor\n (see 4.2 in the manual)\n\n - TODO: switch to a record representation, and keep location\n *)\n | Rinherit of core_type\n (* [ T ] *)\n\n and object_field (*IF_CURRENT = Parsetree.object_field *) =\n | Otag of label loc * attributes * core_type\n | Oinherit of core_type\n\n (* Patterns *)\n\n and pattern (*IF_CURRENT = Parsetree.pattern *) =\n {\n ppat_desc: pattern_desc;\n ppat_loc: Location.t;\n ppat_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and pattern_desc (*IF_CURRENT = Parsetree.pattern_desc *) =\n | Ppat_any\n (* _ *)\n | Ppat_var of string loc\n (* x *)\n | Ppat_alias of pattern * string loc\n (* P as 'a *)\n | Ppat_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Ppat_interval of constant * constant\n (* 'a'..'z'\n\n Other forms of interval are recognized by the parser\n but rejected by the type-checker. *)\n | Ppat_tuple of pattern list\n (* (P1, ..., Pn)\n\n Invariant: n >= 2\n *)\n | Ppat_construct of Longident.t loc * pattern option\n (* C None\n C P Some P\n C (P1, ..., Pn) Some (Ppat_tuple [P1; ...; Pn])\n *)\n | Ppat_variant of label * pattern option\n (* `A (None)\n `A P (Some P)\n *)\n | Ppat_record of (Longident.t loc * pattern) list * closed_flag\n (* { l1=P1; ...; ln=Pn } (flag = Closed)\n { l1=P1; ...; ln=Pn; _} (flag = Open)\n\n Invariant: n > 0\n *)\n | Ppat_array of pattern list\n (* [| P1; ...; Pn |] *)\n | Ppat_or of pattern * pattern\n (* P1 | P2 *)\n | Ppat_constraint of pattern * core_type\n (* (P : T) *)\n | Ppat_type of Longident.t loc\n (* #tconst *)\n | Ppat_lazy of pattern\n (* lazy P *)\n | Ppat_unpack of string loc\n (* (module P)\n Note: (module P : S) is represented as\n Ppat_constraint(Ppat_unpack, Ptyp_package)\n *)\n | Ppat_exception of pattern\n (* exception P *)\n | Ppat_extension of extension\n (* [%id] *)\n | Ppat_open of Longident.t loc * pattern\n (* M.(P) *)\n\n (* Value expressions *)\n\n and expression (*IF_CURRENT = Parsetree.expression *) =\n {\n pexp_desc: expression_desc;\n pexp_loc: Location.t;\n pexp_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and expression_desc (*IF_CURRENT = Parsetree.expression_desc *) =\n | Pexp_ident of Longident.t loc\n (* x\n M.x\n *)\n | Pexp_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Pexp_let of rec_flag * value_binding list * expression\n (* let P1 = E1 and ... and Pn = EN in E (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in E (flag = Recursive)\n *)\n | Pexp_function of case list\n (* function P1 -> E1 | ... | Pn -> En *)\n | Pexp_fun of arg_label * expression option * pattern * expression\n (* fun P -> E1 (Simple, None)\n fun ~l:P -> E1 (Labelled l, None)\n fun ?l:P -> E1 (Optional l, None)\n fun ?l:(P = E0) -> E1 (Optional l, Some E0)\n\n Notes:\n - If E0 is provided, only Optional is allowed.\n - \"fun P1 P2 .. Pn -> E1\" is represented as nested Pexp_fun.\n - \"let f P = E\" is represented using Pexp_fun.\n *)\n | Pexp_apply of expression * (arg_label * expression) list\n (* E0 ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pexp_match of expression * case list\n (* match E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_try of expression * case list\n (* try E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_tuple of expression list\n (* (E1, ..., En)\n\n Invariant: n >= 2\n *)\n | Pexp_construct of Longident.t loc * expression option\n (* C None\n C E Some E\n C (E1, ..., En) Some (Pexp_tuple[E1;...;En])\n *)\n | Pexp_variant of label * expression option\n (* `A (None)\n `A E (Some E)\n *)\n | Pexp_record of (Longident.t loc * expression) list * expression option\n (* { l1=P1; ...; ln=Pn } (None)\n { E0 with l1=P1; ...; ln=Pn } (Some E0)\n\n Invariant: n > 0\n *)\n | Pexp_field of expression * Longident.t loc\n (* E.l *)\n | Pexp_setfield of expression * Longident.t loc * expression\n (* E1.l <- E2 *)\n | Pexp_array of expression list\n (* [| E1; ...; En |] *)\n | Pexp_ifthenelse of expression * expression * expression option\n (* if E1 then E2 else E3 *)\n | Pexp_sequence of expression * expression\n (* E1; E2 *)\n | Pexp_while of expression * expression\n (* while E1 do E2 done *)\n | Pexp_for of\n pattern * expression * expression * direction_flag * expression\n (* for i = E1 to E2 do E3 done (flag = Upto)\n for i = E1 downto E2 do E3 done (flag = Downto)\n *)\n | Pexp_constraint of expression * core_type\n (* (E : T) *)\n | Pexp_coerce of expression * core_type option * core_type\n (* (E :> T) (None, T)\n (E : T0 :> T) (Some T0, T)\n *)\n | Pexp_send of expression * label loc\n (* E # m *)\n | Pexp_new of Longident.t loc\n (* new M.c *)\n | Pexp_setinstvar of label loc * expression\n (* x <- 2 *)\n | Pexp_override of (label loc * expression) list\n (* {< x1 = E1; ...; Xn = En >} *)\n | Pexp_letmodule of string loc * module_expr * expression\n (* let module M = ME in E *)\n | Pexp_letexception of extension_constructor * expression\n (* let exception C in E *)\n | Pexp_assert of expression\n (* assert E\n Note: \"assert false\" is treated in a special way by the\n type-checker. *)\n | Pexp_lazy of expression\n (* lazy E *)\n | Pexp_poly of expression * core_type option\n (* Used for method bodies.\n\n Can only be used as the expression under Cfk_concrete\n for methods (not values). *)\n | Pexp_object of class_structure\n (* object ... end *)\n | Pexp_newtype of string loc * expression\n (* fun (type t) -> E *)\n | Pexp_pack of module_expr\n (* (module ME)\n\n (module ME : S) is represented as\n Pexp_constraint(Pexp_pack, Ptyp_package S) *)\n | Pexp_open of override_flag * Longident.t loc * expression\n (* M.(E)\n let open M in E\n let! open M in E *)\n | Pexp_extension of extension\n (* [%id] *)\n | Pexp_unreachable\n (* . *)\n\n and case (*IF_CURRENT = Parsetree.case *) = (* (P -> E) or (P when E0 -> E) *)\n {\n pc_lhs: pattern;\n pc_guard: expression option;\n pc_rhs: expression;\n }\n\n (* Value descriptions *)\n\n and value_description (*IF_CURRENT = Parsetree.value_description *) =\n {\n pval_name: string loc;\n pval_type: core_type;\n pval_prim: string list;\n pval_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pval_loc: Location.t;\n }\n\n (*\n val x: T (prim = [])\n external x: T = \"s1\" ... \"sn\" (prim = [\"s1\";...\"sn\"])\n *)\n\n (* Type declarations *)\n\n and type_declaration (*IF_CURRENT = Parsetree.type_declaration *) =\n {\n ptype_name: string loc;\n ptype_params: (core_type * variance) list;\n (* ('a1,...'an) t; None represents _*)\n ptype_cstrs: (core_type * core_type * Location.t) list;\n (* ... constraint T1=T1' ... constraint Tn=Tn' *)\n ptype_kind: type_kind;\n ptype_private: private_flag; (* = private ... *)\n ptype_manifest: core_type option; (* = T *)\n ptype_attributes: attributes; (* ... [@@id1] [@@id2] *)\n ptype_loc: Location.t;\n }\n\n (*\n type t (abstract, no manifest)\n type t = T0 (abstract, manifest=T0)\n type t = C of T | ... (variant, no manifest)\n type t = T0 = C of T | ... (variant, manifest=T0)\n type t = {l: T; ...} (record, no manifest)\n type t = T0 = {l : T; ...} (record, manifest=T0)\n type t = .. (open, no manifest)\n *)\n\n and type_kind (*IF_CURRENT = Parsetree.type_kind *) =\n | Ptype_abstract\n | Ptype_variant of constructor_declaration list\n (* Invariant: non-empty list *)\n | Ptype_record of label_declaration list\n (* Invariant: non-empty list *)\n | Ptype_open\n\n and label_declaration (*IF_CURRENT = Parsetree.label_declaration *) =\n {\n pld_name: string loc;\n pld_mutable: mutable_flag;\n pld_type: core_type;\n pld_loc: Location.t;\n pld_attributes: attributes; (* l : T [@id1] [@id2] *)\n }\n\n (* { ...; l: T; ... } (mutable=Immutable)\n { ...; mutable l: T; ... } (mutable=Mutable)\n\n Note: T can be a Ptyp_poly.\n *)\n\n and constructor_declaration (*IF_CURRENT = Parsetree.constructor_declaration *) =\n {\n pcd_name: string loc;\n pcd_args: constructor_arguments;\n pcd_res: core_type option;\n pcd_loc: Location.t;\n pcd_attributes: attributes; (* C of ... [@id1] [@id2] *)\n }\n\n and constructor_arguments (*IF_CURRENT = Parsetree.constructor_arguments *) =\n | Pcstr_tuple of core_type list\n | Pcstr_record of label_declaration list\n\n (*\n | C of T1 * ... * Tn (res = None, args = Pcstr_tuple [])\n | C: T0 (res = Some T0, args = [])\n | C: T1 * ... * Tn -> T0 (res = Some T0, args = Pcstr_tuple)\n | C of {...} (res = None, args = Pcstr_record)\n | C: {...} -> T0 (res = Some T0, args = Pcstr_record)\n | C of {...} as t (res = None, args = Pcstr_record)\n *)\n\n and type_extension (*IF_CURRENT = Parsetree.type_extension *) =\n {\n ptyext_path: Longident.t loc;\n ptyext_params: (core_type * variance) list;\n ptyext_constructors: extension_constructor list;\n ptyext_private: private_flag;\n ptyext_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n (*\n type t += ...\n *)\n\n and extension_constructor (*IF_CURRENT = Parsetree.extension_constructor *) =\n {\n pext_name: string loc;\n pext_kind : extension_constructor_kind;\n pext_loc : Location.t;\n pext_attributes: attributes; (* C of ... [@id1] [@id2] *)\n }\n\n and extension_constructor_kind (*IF_CURRENT = Parsetree.extension_constructor_kind *) =\n Pext_decl of constructor_arguments * core_type option\n (*\n | C of T1 * ... * Tn ([T1; ...; Tn], None)\n | C: T0 ([], Some T0)\n | C: T1 * ... * Tn -> T0 ([T1; ...; Tn], Some T0)\n *)\n | Pext_rebind of Longident.t loc\n (*\n | C = D\n *)\n\n (** {2 Class language} *)\n\n (* Type expressions for the class language *)\n\n and class_type (*IF_CURRENT = Parsetree.class_type *) =\n {\n pcty_desc: class_type_desc;\n pcty_loc: Location.t;\n pcty_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and class_type_desc (*IF_CURRENT = Parsetree.class_type_desc *) =\n | Pcty_constr of Longident.t loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcty_signature of class_signature\n (* object ... end *)\n | Pcty_arrow of arg_label * core_type * class_type\n (* T -> CT Simple\n ~l:T -> CT Labelled l\n ?l:T -> CT Optional l\n *)\n | Pcty_extension of extension\n (* [%id] *)\n | Pcty_open of override_flag * Longident.t loc * class_type\n (* let open M in CT *)\n\n\n and class_signature (*IF_CURRENT = Parsetree.class_signature *) =\n {\n pcsig_self: core_type;\n pcsig_fields: class_type_field list;\n }\n (* object('selfpat) ... end\n object ... end (self = Ptyp_any)\n *)\n\n and class_type_field (*IF_CURRENT = Parsetree.class_type_field *) =\n {\n pctf_desc: class_type_field_desc;\n pctf_loc: Location.t;\n pctf_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and class_type_field_desc (*IF_CURRENT = Parsetree.class_type_field_desc *) =\n | Pctf_inherit of class_type\n (* inherit CT *)\n | Pctf_val of (label loc * mutable_flag * virtual_flag * core_type)\n (* val x: T *)\n | Pctf_method of (label loc * private_flag * virtual_flag * core_type)\n (* method x: T\n\n Note: T can be a Ptyp_poly.\n *)\n | Pctf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pctf_attribute of attribute\n (* [@@@id] *)\n | Pctf_extension of extension\n (* [%%id] *)\n\n and 'a class_infos (*IF_CURRENT = 'a Parsetree.class_infos *) =\n {\n pci_virt: virtual_flag;\n pci_params: (core_type * variance) list;\n pci_name: string loc;\n pci_expr: 'a;\n pci_loc: Location.t;\n pci_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n (* class c = ...\n class ['a1,...,'an] c = ...\n class virtual c = ...\n\n Also used for \"class type\" declaration.\n *)\n\n and class_description = class_type class_infos\n\n and class_type_declaration = class_type class_infos\n\n (* Value expressions for the class language *)\n\n and class_expr (*IF_CURRENT = Parsetree.class_expr *) =\n {\n pcl_desc: class_expr_desc;\n pcl_loc: Location.t;\n pcl_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and class_expr_desc (*IF_CURRENT = Parsetree.class_expr_desc *) =\n | Pcl_constr of Longident.t loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcl_structure of class_structure\n (* object ... end *)\n | Pcl_fun of arg_label * expression option * pattern * class_expr\n (* fun P -> CE (Simple, None)\n fun ~l:P -> CE (Labelled l, None)\n fun ?l:P -> CE (Optional l, None)\n fun ?l:(P = E0) -> CE (Optional l, Some E0)\n *)\n | Pcl_apply of class_expr * (arg_label * expression) list\n (* CE ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pcl_let of rec_flag * value_binding list * class_expr\n (* let P1 = E1 and ... and Pn = EN in CE (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in CE (flag = Recursive)\n *)\n | Pcl_constraint of class_expr * class_type\n (* (CE : CT) *)\n | Pcl_extension of extension\n (* [%id] *)\n | Pcl_open of override_flag * Longident.t loc * class_expr\n (* let open M in CE *)\n\n\n and class_structure (*IF_CURRENT = Parsetree.class_structure *) =\n {\n pcstr_self: pattern;\n pcstr_fields: class_field list;\n }\n (* object(selfpat) ... end\n object ... end (self = Ppat_any)\n *)\n\n and class_field (*IF_CURRENT = Parsetree.class_field *) =\n {\n pcf_desc: class_field_desc;\n pcf_loc: Location.t;\n pcf_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and class_field_desc (*IF_CURRENT = Parsetree.class_field_desc *) =\n | Pcf_inherit of override_flag * class_expr * string loc option\n (* inherit CE\n inherit CE as x\n inherit! CE\n inherit! CE as x\n *)\n | Pcf_val of (label loc * mutable_flag * class_field_kind)\n (* val x = E\n val virtual x: T\n *)\n | Pcf_method of (label loc * private_flag * class_field_kind)\n (* method x = E (E can be a Pexp_poly)\n method virtual x: T (T can be a Ptyp_poly)\n *)\n | Pcf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pcf_initializer of expression\n (* initializer E *)\n | Pcf_attribute of attribute\n (* [@@@id] *)\n | Pcf_extension of extension\n (* [%%id] *)\n\n and class_field_kind (*IF_CURRENT = Parsetree.class_field_kind *) =\n | Cfk_virtual of core_type\n | Cfk_concrete of override_flag * expression\n\n and class_declaration = class_expr class_infos\n\n (** {2 Module language} *)\n\n (* Type expressions for the module language *)\n\n and module_type (*IF_CURRENT = Parsetree.module_type *) =\n {\n pmty_desc: module_type_desc;\n pmty_loc: Location.t;\n pmty_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and module_type_desc (*IF_CURRENT = Parsetree.module_type_desc *) =\n | Pmty_ident of Longident.t loc\n (* S *)\n | Pmty_signature of signature\n (* sig ... end *)\n | Pmty_functor of string loc * module_type option * module_type\n (* functor(X : MT1) -> MT2 *)\n | Pmty_with of module_type * with_constraint list\n (* MT with ... *)\n | Pmty_typeof of module_expr\n (* module type of ME *)\n | Pmty_extension of extension\n (* [%id] *)\n | Pmty_alias of Longident.t loc\n (* (module M) *)\n\n and signature = signature_item list\n\n and signature_item (*IF_CURRENT = Parsetree.signature_item *) =\n {\n psig_desc: signature_item_desc;\n psig_loc: Location.t;\n }\n\n and signature_item_desc (*IF_CURRENT = Parsetree.signature_item_desc *) =\n | Psig_value of value_description\n (*\n val x: T\n external x: T = \"s1\" ... \"sn\"\n *)\n | Psig_type of rec_flag * type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Psig_typext of type_extension\n (* type t1 += ... *)\n | Psig_exception of extension_constructor\n (* exception C of T *)\n | Psig_module of module_declaration\n (* module X : MT *)\n | Psig_recmodule of module_declaration list\n (* module rec X1 : MT1 and ... and Xn : MTn *)\n | Psig_modtype of module_type_declaration\n (* module type S = MT\n module type S *)\n | Psig_open of open_description\n (* open X *)\n | Psig_include of include_description\n (* include MT *)\n | Psig_class of class_description list\n (* class c1 : ... and ... and cn : ... *)\n | Psig_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Psig_attribute of attribute\n (* [@@@id] *)\n | Psig_extension of extension * attributes\n (* [%%id] *)\n\n and module_declaration (*IF_CURRENT = Parsetree.module_declaration *) =\n {\n pmd_name: string loc;\n pmd_type: module_type;\n pmd_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pmd_loc: Location.t;\n }\n (* S : MT *)\n\n and module_type_declaration (*IF_CURRENT = Parsetree.module_type_declaration *) =\n {\n pmtd_name: string loc;\n pmtd_type: module_type option;\n pmtd_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pmtd_loc: Location.t;\n }\n (* S = MT\n S (abstract module type declaration, pmtd_type = None)\n *)\n\n and open_description (*IF_CURRENT = Parsetree.open_description *) =\n {\n popen_lid: Longident.t loc;\n popen_override: override_flag;\n popen_loc: Location.t;\n popen_attributes: attributes;\n }\n (* open! X - popen_override = Override (silences the 'used identifier\n shadowing' warning)\n open X - popen_override = Fresh\n *)\n\n and 'a include_infos (*IF_CURRENT = 'a Parsetree.include_infos *) =\n {\n pincl_mod: 'a;\n pincl_loc: Location.t;\n pincl_attributes: attributes;\n }\n\n and include_description = module_type include_infos\n (* include MT *)\n\n and include_declaration = module_expr include_infos\n (* include ME *)\n\n and with_constraint (*IF_CURRENT = Parsetree.with_constraint *) =\n | Pwith_type of Longident.t loc * type_declaration\n (* with type X.t = ...\n\n Note: the last component of the longident must match\n the name of the type_declaration. *)\n | Pwith_module of Longident.t loc * Longident.t loc\n (* with module X.Y = Z *)\n | Pwith_typesubst of Longident.t loc * type_declaration\n (* with type X.t := ..., same format as [Pwith_type] *)\n | Pwith_modsubst of Longident.t loc * Longident.t loc\n (* with module X.Y := Z *)\n\n (* Value expressions for the module language *)\n\n and module_expr (*IF_CURRENT = Parsetree.module_expr *) =\n {\n pmod_desc: module_expr_desc;\n pmod_loc: Location.t;\n pmod_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and module_expr_desc (*IF_CURRENT = Parsetree.module_expr_desc *) =\n | Pmod_ident of Longident.t loc\n (* X *)\n | Pmod_structure of structure\n (* struct ... end *)\n | Pmod_functor of string loc * module_type option * module_expr\n (* functor(X : MT1) -> ME *)\n | Pmod_apply of module_expr * module_expr\n (* ME1(ME2) *)\n | Pmod_constraint of module_expr * module_type\n (* (ME : MT) *)\n | Pmod_unpack of expression\n (* (val E) *)\n | Pmod_extension of extension\n (* [%id] *)\n\n and structure = structure_item list\n\n and structure_item (*IF_CURRENT = Parsetree.structure_item *) =\n {\n pstr_desc: structure_item_desc;\n pstr_loc: Location.t;\n }\n\n and structure_item_desc (*IF_CURRENT = Parsetree.structure_item_desc *) =\n | Pstr_eval of expression * attributes\n (* E *)\n | Pstr_value of rec_flag * value_binding list\n (* let P1 = E1 and ... and Pn = EN (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN (flag = Recursive)\n *)\n | Pstr_primitive of value_description\n (* val x: T\n external x: T = \"s1\" ... \"sn\" *)\n | Pstr_type of rec_flag * type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Pstr_typext of type_extension\n (* type t1 += ... *)\n | Pstr_exception of extension_constructor\n (* exception C of T\n exception C = M.X *)\n | Pstr_module of module_binding\n (* module X = ME *)\n | Pstr_recmodule of module_binding list\n (* module rec X1 = ME1 and ... and Xn = MEn *)\n | Pstr_modtype of module_type_declaration\n (* module type S = MT *)\n | Pstr_open of open_description\n (* open X *)\n | Pstr_class of class_declaration list\n (* class c1 = ... and ... and cn = ... *)\n | Pstr_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Pstr_include of include_declaration\n (* include ME *)\n | Pstr_attribute of attribute\n (* [@@@id] *)\n | Pstr_extension of extension * attributes\n (* [%%id] *)\n\n and value_binding (*IF_CURRENT = Parsetree.value_binding *) =\n {\n pvb_pat: pattern;\n pvb_expr: expression;\n pvb_attributes: attributes;\n pvb_loc: Location.t;\n }\n\n and module_binding (*IF_CURRENT = Parsetree.module_binding *) =\n {\n pmb_name: string loc;\n pmb_expr: module_expr;\n pmb_attributes: attributes;\n pmb_loc: Location.t;\n }\n (* X = ME *)\n\n (** {2 Toplevel} *)\n\n (* Toplevel phrases *)\n\n type toplevel_phrase (*IF_CURRENT = Parsetree.toplevel_phrase *) =\n | Ptop_def of structure\n | Ptop_dir of string * directive_argument\n (* #use, #load ... *)\n\n and directive_argument (*IF_CURRENT = Parsetree.directive_argument *) =\n | Pdir_none\n | Pdir_string of string\n | Pdir_int of string * char option\n | Pdir_ident of Longident.t\n | Pdir_bool of bool\n\nend\n\nmodule Config = struct\n let ast_impl_magic_number = \"Caml1999M022\"\n let ast_intf_magic_number = \"Caml1999N022\"\nend\n","(**************************************************************************)\n(* *)\n(* OCaml Migrate Parsetree *)\n(* *)\n(* Frédéric Bour *)\n(* Jérémie Dimino and Leo White, Jane Street Europe *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* Alain Frisch, LexiFi *)\n(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 2017 Institut National de Recherche en Informatique et *)\n(* en Automatique (INRIA). *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nmodule Asttypes = struct\n (** Auxiliary AST types used by parsetree and typedtree. *)\n\n type constant (*IF_CURRENT = Asttypes.constant *) =\n Const_int of int\n | Const_char of char\n | Const_string of string * string option\n | Const_float of string\n | Const_int32 of int32\n | Const_int64 of int64\n | Const_nativeint of nativeint\n\n type rec_flag (*IF_CURRENT = Asttypes.rec_flag *) = Nonrecursive | Recursive\n\n type direction_flag (*IF_CURRENT = Asttypes.direction_flag *) = Upto | Downto\n\n (* Order matters, used in polymorphic comparison *)\n type private_flag (*IF_CURRENT = Asttypes.private_flag *) = Private | Public\n\n type mutable_flag (*IF_CURRENT = Asttypes.mutable_flag *) = Immutable | Mutable\n\n type virtual_flag (*IF_CURRENT = Asttypes.virtual_flag *) = Virtual | Concrete\n\n type override_flag (*IF_CURRENT = Asttypes.override_flag *) = Override | Fresh\n\n type closed_flag (*IF_CURRENT = Asttypes.closed_flag *) = Closed | Open\n\n type label = string\n\n type arg_label (*IF_CURRENT = Asttypes.arg_label *) =\n Nolabel\n | Labelled of string (* label:T -> ... *)\n | Optional of string (* ?label:T -> ... *)\n\n type 'a loc = 'a Location.loc = {\n txt : 'a;\n loc : Location.t;\n }\n\n\n type variance (*IF_CURRENT = Asttypes.variance *) =\n | Covariant\n | Contravariant\n | Invariant\nend\n\nmodule Parsetree = struct\n (** Abstract syntax tree produced by parsing *)\n\n open Asttypes\n\n type constant (*IF_CURRENT = Parsetree.constant *) =\n Pconst_integer of string * char option\n (* 3 3l 3L 3n\n\n Suffixes [g-z][G-Z] are accepted by the parser.\n Suffixes except 'l', 'L' and 'n' are rejected by the typechecker\n *)\n | Pconst_char of char\n (* 'c' *)\n | Pconst_string of string * string option\n (* \"constant\"\n {delim|other constant|delim}\n *)\n | Pconst_float of string * char option\n (* 3.4 2e5 1.4e-4\n\n Suffixes [g-z][G-Z] are accepted by the parser.\n Suffixes are rejected by the typechecker.\n *)\n\n (** {2 Extension points} *)\n\n type attribute = string loc * payload\n (* [@id ARG]\n [@@id ARG]\n\n Metadata containers passed around within the AST.\n The compiler ignores unknown attributes.\n *)\n\n and extension = string loc * payload\n (* [%id ARG]\n [%%id ARG]\n\n Sub-language placeholder -- rejected by the typechecker.\n *)\n\n and attributes = attribute list\n\n and payload (*IF_CURRENT = Parsetree.payload *) =\n | PStr of structure\n | PSig of signature (* : SIG *)\n | PTyp of core_type (* : T *)\n | PPat of pattern * expression option (* ? P or ? P when E *)\n\n (** {2 Core language} *)\n\n (* Type expressions *)\n\n and core_type (*IF_CURRENT = Parsetree.core_type *) =\n {\n ptyp_desc: core_type_desc;\n ptyp_loc: Location.t;\n ptyp_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and core_type_desc (*IF_CURRENT = Parsetree.core_type_desc *) =\n | Ptyp_any\n (* _ *)\n | Ptyp_var of string\n (* 'a *)\n | Ptyp_arrow of arg_label * core_type * core_type\n (* T1 -> T2 Simple\n ~l:T1 -> T2 Labelled\n ?l:T1 -> T2 Otional\n *)\n | Ptyp_tuple of core_type list\n (* T1 * ... * Tn\n\n Invariant: n >= 2\n *)\n | Ptyp_constr of Longident.t loc * core_type list\n (* tconstr\n T tconstr\n (T1, ..., Tn) tconstr\n *)\n | Ptyp_object of (string loc * attributes * core_type) list * closed_flag\n (* < l1:T1; ...; ln:Tn > (flag = Closed)\n < l1:T1; ...; ln:Tn; .. > (flag = Open)\n *)\n | Ptyp_class of Longident.t loc * core_type list\n (* #tconstr\n T #tconstr\n (T1, ..., Tn) #tconstr\n *)\n | Ptyp_alias of core_type * string\n (* T as 'a *)\n | Ptyp_variant of row_field list * closed_flag * label list option\n (* [ `A|`B ] (flag = Closed; labels = None)\n [> `A|`B ] (flag = Open; labels = None)\n [< `A|`B ] (flag = Closed; labels = Some [])\n [< `A|`B > `X `Y ](flag = Closed; labels = Some [\"X\";\"Y\"])\n *)\n | Ptyp_poly of string loc list * core_type\n (* 'a1 ... 'an. T\n\n Can only appear in the following context:\n\n - As the core_type of a Ppat_constraint node corresponding\n to a constraint on a let-binding: let x : 'a1 ... 'an. T\n = e ...\n\n - Under Cfk_virtual for methods (not values).\n\n - As the core_type of a Pctf_method node.\n\n - As the core_type of a Pexp_poly node.\n\n - As the pld_type field of a label_declaration.\n\n - As a core_type of a Ptyp_object node.\n *)\n\n | Ptyp_package of package_type\n (* (module S) *)\n | Ptyp_extension of extension\n (* [%id] *)\n\n and package_type = Longident.t loc * (Longident.t loc * core_type) list\n (*\n (module S)\n (module S with type t1 = T1 and ... and tn = Tn)\n *)\n\n and row_field (*IF_CURRENT = Parsetree.row_field *) =\n | Rtag of label * attributes * bool * core_type list\n (* [`A] ( true, [] )\n [`A of T] ( false, [T] )\n [`A of T1 & .. & Tn] ( false, [T1;...Tn] )\n [`A of & T1 & .. & Tn] ( true, [T1;...Tn] )\n\n - The 2nd field is true if the tag contains a\n constant (empty) constructor.\n - '&' occurs when several types are used for the same constructor\n (see 4.2 in the manual)\n\n - TODO: switch to a record representation, and keep location\n *)\n | Rinherit of core_type\n (* [ T ] *)\n\n (* Patterns *)\n\n and pattern (*IF_CURRENT = Parsetree.pattern *) =\n {\n ppat_desc: pattern_desc;\n ppat_loc: Location.t;\n ppat_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and pattern_desc (*IF_CURRENT = Parsetree.pattern_desc *) =\n | Ppat_any\n (* _ *)\n | Ppat_var of string loc\n (* x *)\n | Ppat_alias of pattern * string loc\n (* P as 'a *)\n | Ppat_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Ppat_interval of constant * constant\n (* 'a'..'z'\n\n Other forms of interval are recognized by the parser\n but rejected by the type-checker. *)\n | Ppat_tuple of pattern list\n (* (P1, ..., Pn)\n\n Invariant: n >= 2\n *)\n | Ppat_construct of Longident.t loc * pattern option\n (* C None\n C P Some P\n C (P1, ..., Pn) Some (Ppat_tuple [P1; ...; Pn])\n *)\n | Ppat_variant of label * pattern option\n (* `A (None)\n `A P (Some P)\n *)\n | Ppat_record of (Longident.t loc * pattern) list * closed_flag\n (* { l1=P1; ...; ln=Pn } (flag = Closed)\n { l1=P1; ...; ln=Pn; _} (flag = Open)\n\n Invariant: n > 0\n *)\n | Ppat_array of pattern list\n (* [| P1; ...; Pn |] *)\n | Ppat_or of pattern * pattern\n (* P1 | P2 *)\n | Ppat_constraint of pattern * core_type\n (* (P : T) *)\n | Ppat_type of Longident.t loc\n (* #tconst *)\n | Ppat_lazy of pattern\n (* lazy P *)\n | Ppat_unpack of string loc\n (* (module P)\n Note: (module P : S) is represented as\n Ppat_constraint(Ppat_unpack, Ptyp_package)\n *)\n | Ppat_exception of pattern\n (* exception P *)\n | Ppat_extension of extension\n (* [%id] *)\n | Ppat_open of Longident.t loc * pattern\n (* M.(P) *)\n\n (* Value expressions *)\n\n and expression (*IF_CURRENT = Parsetree.expression *) =\n {\n pexp_desc: expression_desc;\n pexp_loc: Location.t;\n pexp_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and expression_desc (*IF_CURRENT = Parsetree.expression_desc *) =\n | Pexp_ident of Longident.t loc\n (* x\n M.x\n *)\n | Pexp_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Pexp_let of rec_flag * value_binding list * expression\n (* let P1 = E1 and ... and Pn = EN in E (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in E (flag = Recursive)\n *)\n | Pexp_function of case list\n (* function P1 -> E1 | ... | Pn -> En *)\n | Pexp_fun of arg_label * expression option * pattern * expression\n (* fun P -> E1 (Simple, None)\n fun ~l:P -> E1 (Labelled l, None)\n fun ?l:P -> E1 (Optional l, None)\n fun ?l:(P = E0) -> E1 (Optional l, Some E0)\n\n Notes:\n - If E0 is provided, only Optional is allowed.\n - \"fun P1 P2 .. Pn -> E1\" is represented as nested Pexp_fun.\n - \"let f P = E\" is represented using Pexp_fun.\n *)\n | Pexp_apply of expression * (arg_label * expression) list\n (* E0 ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pexp_match of expression * case list\n (* match E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_try of expression * case list\n (* try E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_tuple of expression list\n (* (E1, ..., En)\n\n Invariant: n >= 2\n *)\n | Pexp_construct of Longident.t loc * expression option\n (* C None\n C E Some E\n C (E1, ..., En) Some (Pexp_tuple[E1;...;En])\n *)\n | Pexp_variant of label * expression option\n (* `A (None)\n `A E (Some E)\n *)\n | Pexp_record of (Longident.t loc * expression) list * expression option\n (* { l1=P1; ...; ln=Pn } (None)\n { E0 with l1=P1; ...; ln=Pn } (Some E0)\n\n Invariant: n > 0\n *)\n | Pexp_field of expression * Longident.t loc\n (* E.l *)\n | Pexp_setfield of expression * Longident.t loc * expression\n (* E1.l <- E2 *)\n | Pexp_array of expression list\n (* [| E1; ...; En |] *)\n | Pexp_ifthenelse of expression * expression * expression option\n (* if E1 then E2 else E3 *)\n | Pexp_sequence of expression * expression\n (* E1; E2 *)\n | Pexp_while of expression * expression\n (* while E1 do E2 done *)\n | Pexp_for of\n pattern * expression * expression * direction_flag * expression\n (* for i = E1 to E2 do E3 done (flag = Upto)\n for i = E1 downto E2 do E3 done (flag = Downto)\n *)\n | Pexp_constraint of expression * core_type\n (* (E : T) *)\n | Pexp_coerce of expression * core_type option * core_type\n (* (E :> T) (None, T)\n (E : T0 :> T) (Some T0, T)\n *)\n | Pexp_send of expression * string loc\n (* E # m *)\n | Pexp_new of Longident.t loc\n (* new M.c *)\n | Pexp_setinstvar of string loc * expression\n (* x <- 2 *)\n | Pexp_override of (string loc * expression) list\n (* {< x1 = E1; ...; Xn = En >} *)\n | Pexp_letmodule of string loc * module_expr * expression\n (* let module M = ME in E *)\n | Pexp_letexception of extension_constructor * expression\n (* let exception C in E *)\n | Pexp_assert of expression\n (* assert E\n Note: \"assert false\" is treated in a special way by the\n type-checker. *)\n | Pexp_lazy of expression\n (* lazy E *)\n | Pexp_poly of expression * core_type option\n (* Used for method bodies.\n\n Can only be used as the expression under Cfk_concrete\n for methods (not values). *)\n | Pexp_object of class_structure\n (* object ... end *)\n | Pexp_newtype of string loc * expression\n (* fun (type t) -> E *)\n | Pexp_pack of module_expr\n (* (module ME)\n\n (module ME : S) is represented as\n Pexp_constraint(Pexp_pack, Ptyp_package S) *)\n | Pexp_open of override_flag * Longident.t loc * expression\n (* M.(E)\n let open M in E\n let! open M in E *)\n | Pexp_extension of extension\n (* [%id] *)\n | Pexp_unreachable\n (* . *)\n\n and case (*IF_CURRENT = Parsetree.case *) = (* (P -> E) or (P when E0 -> E) *)\n {\n pc_lhs: pattern;\n pc_guard: expression option;\n pc_rhs: expression;\n }\n\n (* Value descriptions *)\n\n and value_description (*IF_CURRENT = Parsetree.value_description *) =\n {\n pval_name: string loc;\n pval_type: core_type;\n pval_prim: string list;\n pval_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pval_loc: Location.t;\n }\n\n (*\n val x: T (prim = [])\n external x: T = \"s1\" ... \"sn\" (prim = [\"s1\";...\"sn\"])\n *)\n\n (* Type declarations *)\n\n and type_declaration (*IF_CURRENT = Parsetree.type_declaration *) =\n {\n ptype_name: string loc;\n ptype_params: (core_type * variance) list;\n (* ('a1,...'an) t; None represents _*)\n ptype_cstrs: (core_type * core_type * Location.t) list;\n (* ... constraint T1=T1' ... constraint Tn=Tn' *)\n ptype_kind: type_kind;\n ptype_private: private_flag; (* = private ... *)\n ptype_manifest: core_type option; (* = T *)\n ptype_attributes: attributes; (* ... [@@id1] [@@id2] *)\n ptype_loc: Location.t;\n }\n\n (*\n type t (abstract, no manifest)\n type t = T0 (abstract, manifest=T0)\n type t = C of T | ... (variant, no manifest)\n type t = T0 = C of T | ... (variant, manifest=T0)\n type t = {l: T; ...} (record, no manifest)\n type t = T0 = {l : T; ...} (record, manifest=T0)\n type t = .. (open, no manifest)\n *)\n\n and type_kind (*IF_CURRENT = Parsetree.type_kind *) =\n | Ptype_abstract\n | Ptype_variant of constructor_declaration list\n (* Invariant: non-empty list *)\n | Ptype_record of label_declaration list\n (* Invariant: non-empty list *)\n | Ptype_open\n\n and label_declaration (*IF_CURRENT = Parsetree.label_declaration *) =\n {\n pld_name: string loc;\n pld_mutable: mutable_flag;\n pld_type: core_type;\n pld_loc: Location.t;\n pld_attributes: attributes; (* l [@id1] [@id2] : T *)\n }\n\n (* { ...; l: T; ... } (mutable=Immutable)\n { ...; mutable l: T; ... } (mutable=Mutable)\n\n Note: T can be a Ptyp_poly.\n *)\n\n and constructor_declaration (*IF_CURRENT = Parsetree.constructor_declaration *) =\n {\n pcd_name: string loc;\n pcd_args: constructor_arguments;\n pcd_res: core_type option;\n pcd_loc: Location.t;\n pcd_attributes: attributes; (* C [@id1] [@id2] of ... *)\n }\n\n and constructor_arguments (*IF_CURRENT = Parsetree.constructor_arguments *) =\n | Pcstr_tuple of core_type list\n | Pcstr_record of label_declaration list\n\n (*\n | C of T1 * ... * Tn (res = None, args = Pcstr_tuple [])\n | C: T0 (res = Some T0, args = [])\n | C: T1 * ... * Tn -> T0 (res = Some T0, args = Pcstr_tuple)\n | C of {...} (res = None, args = Pcstr_record)\n | C: {...} -> T0 (res = Some T0, args = Pcstr_record)\n | C of {...} as t (res = None, args = Pcstr_record)\n *)\n\n and type_extension (*IF_CURRENT = Parsetree.type_extension *) =\n {\n ptyext_path: Longident.t loc;\n ptyext_params: (core_type * variance) list;\n ptyext_constructors: extension_constructor list;\n ptyext_private: private_flag;\n ptyext_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n (*\n type t += ...\n *)\n\n and extension_constructor (*IF_CURRENT = Parsetree.extension_constructor *) =\n {\n pext_name: string loc;\n pext_kind : extension_constructor_kind;\n pext_loc : Location.t;\n pext_attributes: attributes; (* C [@id1] [@id2] of ... *)\n }\n\n and extension_constructor_kind (*IF_CURRENT = Parsetree.extension_constructor_kind *) =\n Pext_decl of constructor_arguments * core_type option\n (*\n | C of T1 * ... * Tn ([T1; ...; Tn], None)\n | C: T0 ([], Some T0)\n | C: T1 * ... * Tn -> T0 ([T1; ...; Tn], Some T0)\n *)\n | Pext_rebind of Longident.t loc\n (*\n | C = D\n *)\n\n (** {2 Class language} *)\n\n (* Type expressions for the class language *)\n\n and class_type (*IF_CURRENT = Parsetree.class_type *) =\n {\n pcty_desc: class_type_desc;\n pcty_loc: Location.t;\n pcty_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and class_type_desc (*IF_CURRENT = Parsetree.class_type_desc *) =\n | Pcty_constr of Longident.t loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcty_signature of class_signature\n (* object ... end *)\n | Pcty_arrow of arg_label * core_type * class_type\n (* T -> CT Simple\n ~l:T -> CT Labelled l\n ?l:T -> CT Optional l\n *)\n | Pcty_extension of extension\n (* [%id] *)\n\n and class_signature (*IF_CURRENT = Parsetree.class_signature *) =\n {\n pcsig_self: core_type;\n pcsig_fields: class_type_field list;\n }\n (* object('selfpat) ... end\n object ... end (self = Ptyp_any)\n *)\n\n and class_type_field (*IF_CURRENT = Parsetree.class_type_field *) =\n {\n pctf_desc: class_type_field_desc;\n pctf_loc: Location.t;\n pctf_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and class_type_field_desc (*IF_CURRENT = Parsetree.class_type_field_desc *) =\n | Pctf_inherit of class_type\n (* inherit CT *)\n | Pctf_val of (string loc * mutable_flag * virtual_flag * core_type)\n (* val x: T *)\n | Pctf_method of (string loc * private_flag * virtual_flag * core_type)\n (* method x: T\n\n Note: T can be a Ptyp_poly.\n *)\n | Pctf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pctf_attribute of attribute\n (* [@@@id] *)\n | Pctf_extension of extension\n (* [%%id] *)\n\n and 'a class_infos (*IF_CURRENT = 'a Parsetree.class_infos *) =\n {\n pci_virt: virtual_flag;\n pci_params: (core_type * variance) list;\n pci_name: string loc;\n pci_expr: 'a;\n pci_loc: Location.t;\n pci_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n (* class c = ...\n class ['a1,...,'an] c = ...\n class virtual c = ...\n\n Also used for \"class type\" declaration.\n *)\n\n and class_description = class_type class_infos\n\n and class_type_declaration = class_type class_infos\n\n (* Value expressions for the class language *)\n\n and class_expr (*IF_CURRENT = Parsetree.class_expr *) =\n {\n pcl_desc: class_expr_desc;\n pcl_loc: Location.t;\n pcl_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and class_expr_desc (*IF_CURRENT = Parsetree.class_expr_desc *) =\n | Pcl_constr of Longident.t loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcl_structure of class_structure\n (* object ... end *)\n | Pcl_fun of arg_label * expression option * pattern * class_expr\n (* fun P -> CE (Simple, None)\n fun ~l:P -> CE (Labelled l, None)\n fun ?l:P -> CE (Optional l, None)\n fun ?l:(P = E0) -> CE (Optional l, Some E0)\n *)\n | Pcl_apply of class_expr * (arg_label * expression) list\n (* CE ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pcl_let of rec_flag * value_binding list * class_expr\n (* let P1 = E1 and ... and Pn = EN in CE (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in CE (flag = Recursive)\n *)\n | Pcl_constraint of class_expr * class_type\n (* (CE : CT) *)\n | Pcl_extension of extension\n (* [%id] *)\n\n and class_structure (*IF_CURRENT = Parsetree.class_structure *) =\n {\n pcstr_self: pattern;\n pcstr_fields: class_field list;\n }\n (* object(selfpat) ... end\n object ... end (self = Ppat_any)\n *)\n\n and class_field (*IF_CURRENT = Parsetree.class_field *) =\n {\n pcf_desc: class_field_desc;\n pcf_loc: Location.t;\n pcf_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and class_field_desc (*IF_CURRENT = Parsetree.class_field_desc *) =\n | Pcf_inherit of override_flag * class_expr * string loc option\n (* inherit CE\n inherit CE as x\n inherit! CE\n inherit! CE as x\n *)\n | Pcf_val of (string loc * mutable_flag * class_field_kind)\n (* val x = E\n val virtual x: T\n *)\n | Pcf_method of (string loc * private_flag * class_field_kind)\n (* method x = E (E can be a Pexp_poly)\n method virtual x: T (T can be a Ptyp_poly)\n *)\n | Pcf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pcf_initializer of expression\n (* initializer E *)\n | Pcf_attribute of attribute\n (* [@@@id] *)\n | Pcf_extension of extension\n (* [%%id] *)\n\n and class_field_kind (*IF_CURRENT = Parsetree.class_field_kind *) =\n | Cfk_virtual of core_type\n | Cfk_concrete of override_flag * expression\n\n and class_declaration = class_expr class_infos\n\n (** {2 Module language} *)\n\n (* Type expressions for the module language *)\n\n and module_type (*IF_CURRENT = Parsetree.module_type *) =\n {\n pmty_desc: module_type_desc;\n pmty_loc: Location.t;\n pmty_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and module_type_desc (*IF_CURRENT = Parsetree.module_type_desc *) =\n | Pmty_ident of Longident.t loc\n (* S *)\n | Pmty_signature of signature\n (* sig ... end *)\n | Pmty_functor of string loc * module_type option * module_type\n (* functor(X : MT1) -> MT2 *)\n | Pmty_with of module_type * with_constraint list\n (* MT with ... *)\n | Pmty_typeof of module_expr\n (* module type of ME *)\n | Pmty_extension of extension\n (* [%id] *)\n | Pmty_alias of Longident.t loc\n (* (module M) *)\n\n and signature = signature_item list\n\n and signature_item (*IF_CURRENT = Parsetree.signature_item *) =\n {\n psig_desc: signature_item_desc;\n psig_loc: Location.t;\n }\n\n and signature_item_desc (*IF_CURRENT = Parsetree.signature_item_desc *) =\n | Psig_value of value_description\n (*\n val x: T\n external x: T = \"s1\" ... \"sn\"\n *)\n | Psig_type of rec_flag * type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Psig_typext of type_extension\n (* type t1 += ... *)\n | Psig_exception of extension_constructor\n (* exception C of T *)\n | Psig_module of module_declaration\n (* module X : MT *)\n | Psig_recmodule of module_declaration list\n (* module rec X1 : MT1 and ... and Xn : MTn *)\n | Psig_modtype of module_type_declaration\n (* module type S = MT\n module type S *)\n | Psig_open of open_description\n (* open X *)\n | Psig_include of include_description\n (* include MT *)\n | Psig_class of class_description list\n (* class c1 : ... and ... and cn : ... *)\n | Psig_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Psig_attribute of attribute\n (* [@@@id] *)\n | Psig_extension of extension * attributes\n (* [%%id] *)\n\n and module_declaration (*IF_CURRENT = Parsetree.module_declaration *) =\n {\n pmd_name: string loc;\n pmd_type: module_type;\n pmd_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pmd_loc: Location.t;\n }\n (* S : MT *)\n\n and module_type_declaration (*IF_CURRENT = Parsetree.module_type_declaration *) =\n {\n pmtd_name: string loc;\n pmtd_type: module_type option;\n pmtd_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pmtd_loc: Location.t;\n }\n (* S = MT\n S (abstract module type declaration, pmtd_type = None)\n *)\n\n and open_description (*IF_CURRENT = Parsetree.open_description *) =\n {\n popen_lid: Longident.t loc;\n popen_override: override_flag;\n popen_loc: Location.t;\n popen_attributes: attributes;\n }\n (* open! X - popen_override = Override (silences the 'used identifier\n shadowing' warning)\n open X - popen_override = Fresh\n *)\n\n and 'a include_infos (*IF_CURRENT = 'a Parsetree.include_infos *) =\n {\n pincl_mod: 'a;\n pincl_loc: Location.t;\n pincl_attributes: attributes;\n }\n\n and include_description = module_type include_infos\n (* include MT *)\n\n and include_declaration = module_expr include_infos\n (* include ME *)\n\n and with_constraint (*IF_CURRENT = Parsetree.with_constraint *) =\n | Pwith_type of Longident.t loc * type_declaration\n (* with type X.t = ...\n\n Note: the last component of the longident must match\n the name of the type_declaration. *)\n | Pwith_module of Longident.t loc * Longident.t loc\n (* with module X.Y = Z *)\n | Pwith_typesubst of type_declaration\n (* with type t := ... *)\n | Pwith_modsubst of string loc * Longident.t loc\n (* with module X := Z *)\n\n (* Value expressions for the module language *)\n\n and module_expr (*IF_CURRENT = Parsetree.module_expr *) =\n {\n pmod_desc: module_expr_desc;\n pmod_loc: Location.t;\n pmod_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and module_expr_desc (*IF_CURRENT = Parsetree.module_expr_desc *) =\n | Pmod_ident of Longident.t loc\n (* X *)\n | Pmod_structure of structure\n (* struct ... end *)\n | Pmod_functor of string loc * module_type option * module_expr\n (* functor(X : MT1) -> ME *)\n | Pmod_apply of module_expr * module_expr\n (* ME1(ME2) *)\n | Pmod_constraint of module_expr * module_type\n (* (ME : MT) *)\n | Pmod_unpack of expression\n (* (val E) *)\n | Pmod_extension of extension\n (* [%id] *)\n\n and structure = structure_item list\n\n and structure_item (*IF_CURRENT = Parsetree.structure_item *) =\n {\n pstr_desc: structure_item_desc;\n pstr_loc: Location.t;\n }\n\n and structure_item_desc (*IF_CURRENT = Parsetree.structure_item_desc *) =\n | Pstr_eval of expression * attributes\n (* E *)\n | Pstr_value of rec_flag * value_binding list\n (* let P1 = E1 and ... and Pn = EN (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN (flag = Recursive)\n *)\n | Pstr_primitive of value_description\n (* val x: T\n external x: T = \"s1\" ... \"sn\" *)\n | Pstr_type of rec_flag * type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Pstr_typext of type_extension\n (* type t1 += ... *)\n | Pstr_exception of extension_constructor\n (* exception C of T\n exception C = M.X *)\n | Pstr_module of module_binding\n (* module X = ME *)\n | Pstr_recmodule of module_binding list\n (* module rec X1 = ME1 and ... and Xn = MEn *)\n | Pstr_modtype of module_type_declaration\n (* module type S = MT *)\n | Pstr_open of open_description\n (* open X *)\n | Pstr_class of class_declaration list\n (* class c1 = ... and ... and cn = ... *)\n | Pstr_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Pstr_include of include_declaration\n (* include ME *)\n | Pstr_attribute of attribute\n (* [@@@id] *)\n | Pstr_extension of extension * attributes\n (* [%%id] *)\n\n and value_binding (*IF_CURRENT = Parsetree.value_binding *) =\n {\n pvb_pat: pattern;\n pvb_expr: expression;\n pvb_attributes: attributes;\n pvb_loc: Location.t;\n }\n\n and module_binding (*IF_CURRENT = Parsetree.module_binding *) =\n {\n pmb_name: string loc;\n pmb_expr: module_expr;\n pmb_attributes: attributes;\n pmb_loc: Location.t;\n }\n (* X = ME *)\n\n (** {2 Toplevel} *)\n\n (* Toplevel phrases *)\n\n type toplevel_phrase (*IF_CURRENT = Parsetree.toplevel_phrase *) =\n | Ptop_def of structure\n | Ptop_dir of string * directive_argument\n (* #use, #load ... *)\n\n and directive_argument (*IF_CURRENT = Parsetree.directive_argument *) =\n | Pdir_none\n | Pdir_string of string\n | Pdir_int of string * char option\n | Pdir_ident of Longident.t\n | Pdir_bool of bool\n\nend\n\nmodule Config = struct\n let ast_impl_magic_number = \"Caml1999M020\"\n let ast_intf_magic_number = \"Caml1999N018\"\nend\n","(**************************************************************************)\n(* *)\n(* OCaml Migrate Parsetree *)\n(* *)\n(* Frédéric Bour *)\n(* Jérémie Dimino and Leo White, Jane Street Europe *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* Alain Frisch, LexiFi *)\n(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 2017 Institut National de Recherche en Informatique et *)\n(* en Automatique (INRIA). *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nmodule Asttypes = struct\n (** Auxiliary AST types used by parsetree and typedtree. *)\n\n type constant (*IF_CURRENT = Asttypes.constant *) =\n Const_int of int\n | Const_char of char\n | Const_string of string * string option\n | Const_float of string\n | Const_int32 of int32\n | Const_int64 of int64\n | Const_nativeint of nativeint\n\n type rec_flag (*IF_CURRENT = Asttypes.rec_flag *) = Nonrecursive | Recursive\n\n type direction_flag (*IF_CURRENT = Asttypes.direction_flag *) = Upto | Downto\n\n (* Order matters, used in polymorphic comparison *)\n type private_flag (*IF_CURRENT = Asttypes.private_flag *) = Private | Public\n\n type mutable_flag (*IF_CURRENT = Asttypes.mutable_flag *) = Immutable | Mutable\n\n type virtual_flag (*IF_CURRENT = Asttypes.virtual_flag *) = Virtual | Concrete\n\n type override_flag (*IF_CURRENT = Asttypes.override_flag *) = Override | Fresh\n\n type closed_flag (*IF_CURRENT = Asttypes.closed_flag *) = Closed | Open\n\n type label = string\n\n type arg_label (*IF_CURRENT = Asttypes.arg_label *) =\n Nolabel\n | Labelled of string (* label:T -> ... *)\n | Optional of string (* ?label:T -> ... *)\n\n type 'a loc = 'a Location.loc = {\n txt : 'a;\n loc : Location.t;\n }\n\n\n type variance (*IF_CURRENT = Asttypes.variance *) =\n | Covariant\n | Contravariant\n | Invariant\nend\n\nmodule Parsetree = struct\n (** Abstract syntax tree produced by parsing *)\n\n open Asttypes\n\n type constant (*IF_CURRENT = Parsetree.constant *) =\n Pconst_integer of string * char option\n (* 3 3l 3L 3n\n\n Suffixes [g-z][G-Z] are accepted by the parser.\n Suffixes except 'l', 'L' and 'n' are rejected by the typechecker\n *)\n | Pconst_char of char\n (* 'c' *)\n | Pconst_string of string * string option\n (* \"constant\"\n {delim|other constant|delim}\n *)\n | Pconst_float of string * char option\n (* 3.4 2e5 1.4e-4\n\n Suffixes [g-z][G-Z] are accepted by the parser.\n Suffixes are rejected by the typechecker.\n *)\n\n (** {2 Extension points} *)\n\n type attribute = string loc * payload\n (* [@id ARG]\n [@@id ARG]\n\n Metadata containers passed around within the AST.\n The compiler ignores unknown attributes.\n *)\n\n and extension = string loc * payload\n (* [%id ARG]\n [%%id ARG]\n\n Sub-language placeholder -- rejected by the typechecker.\n *)\n\n and attributes = attribute list\n\n and payload (*IF_CURRENT = Parsetree.payload *) =\n | PStr of structure\n | PSig of signature (* : SIG *)\n | PTyp of core_type (* : T *)\n | PPat of pattern * expression option (* ? P or ? P when E *)\n\n (** {2 Core language} *)\n\n (* Type expressions *)\n\n and core_type (*IF_CURRENT = Parsetree.core_type *) =\n {\n ptyp_desc: core_type_desc;\n ptyp_loc: Location.t;\n ptyp_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and core_type_desc (*IF_CURRENT = Parsetree.core_type_desc *) =\n | Ptyp_any\n (* _ *)\n | Ptyp_var of string\n (* 'a *)\n | Ptyp_arrow of arg_label * core_type * core_type\n (* T1 -> T2 Simple\n ~l:T1 -> T2 Labelled\n ?l:T1 -> T2 Otional\n *)\n | Ptyp_tuple of core_type list\n (* T1 * ... * Tn\n\n Invariant: n >= 2\n *)\n | Ptyp_constr of Longident.t loc * core_type list\n (* tconstr\n T tconstr\n (T1, ..., Tn) tconstr\n *)\n | Ptyp_object of (string * attributes * core_type) list * closed_flag\n (* < l1:T1; ...; ln:Tn > (flag = Closed)\n < l1:T1; ...; ln:Tn; .. > (flag = Open)\n *)\n | Ptyp_class of Longident.t loc * core_type list\n (* #tconstr\n T #tconstr\n (T1, ..., Tn) #tconstr\n *)\n | Ptyp_alias of core_type * string\n (* T as 'a *)\n | Ptyp_variant of row_field list * closed_flag * label list option\n (* [ `A|`B ] (flag = Closed; labels = None)\n [> `A|`B ] (flag = Open; labels = None)\n [< `A|`B ] (flag = Closed; labels = Some [])\n [< `A|`B > `X `Y ](flag = Closed; labels = Some [\"X\";\"Y\"])\n *)\n | Ptyp_poly of string list * core_type\n (* 'a1 ... 'an. T\n\n Can only appear in the following context:\n\n - As the core_type of a Ppat_constraint node corresponding\n to a constraint on a let-binding: let x : 'a1 ... 'an. T\n = e ...\n\n - Under Cfk_virtual for methods (not values).\n\n - As the core_type of a Pctf_method node.\n\n - As the core_type of a Pexp_poly node.\n\n - As the pld_type field of a label_declaration.\n\n - As a core_type of a Ptyp_object node.\n *)\n\n | Ptyp_package of package_type\n (* (module S) *)\n | Ptyp_extension of extension\n (* [%id] *)\n\n and package_type = Longident.t loc * (Longident.t loc * core_type) list\n (*\n (module S)\n (module S with type t1 = T1 and ... and tn = Tn)\n *)\n\n and row_field (*IF_CURRENT = Parsetree.row_field *) =\n | Rtag of label * attributes * bool * core_type list\n (* [`A] ( true, [] )\n [`A of T] ( false, [T] )\n [`A of T1 & .. & Tn] ( false, [T1;...Tn] )\n [`A of & T1 & .. & Tn] ( true, [T1;...Tn] )\n\n - The 2nd field is true if the tag contains a\n constant (empty) constructor.\n - '&' occurs when several types are used for the same constructor\n (see 4.2 in the manual)\n\n - TODO: switch to a record representation, and keep location\n *)\n | Rinherit of core_type\n (* [ T ] *)\n\n (* Patterns *)\n\n and pattern (*IF_CURRENT = Parsetree.pattern *) =\n {\n ppat_desc: pattern_desc;\n ppat_loc: Location.t;\n ppat_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and pattern_desc (*IF_CURRENT = Parsetree.pattern_desc *) =\n | Ppat_any\n (* _ *)\n | Ppat_var of string loc\n (* x *)\n | Ppat_alias of pattern * string loc\n (* P as 'a *)\n | Ppat_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Ppat_interval of constant * constant\n (* 'a'..'z'\n\n Other forms of interval are recognized by the parser\n but rejected by the type-checker. *)\n | Ppat_tuple of pattern list\n (* (P1, ..., Pn)\n\n Invariant: n >= 2\n *)\n | Ppat_construct of Longident.t loc * pattern option\n (* C None\n C P Some P\n C (P1, ..., Pn) Some (Ppat_tuple [P1; ...; Pn])\n *)\n | Ppat_variant of label * pattern option\n (* `A (None)\n `A P (Some P)\n *)\n | Ppat_record of (Longident.t loc * pattern) list * closed_flag\n (* { l1=P1; ...; ln=Pn } (flag = Closed)\n { l1=P1; ...; ln=Pn; _} (flag = Open)\n\n Invariant: n > 0\n *)\n | Ppat_array of pattern list\n (* [| P1; ...; Pn |] *)\n | Ppat_or of pattern * pattern\n (* P1 | P2 *)\n | Ppat_constraint of pattern * core_type\n (* (P : T) *)\n | Ppat_type of Longident.t loc\n (* #tconst *)\n | Ppat_lazy of pattern\n (* lazy P *)\n | Ppat_unpack of string loc\n (* (module P)\n Note: (module P : S) is represented as\n Ppat_constraint(Ppat_unpack, Ptyp_package)\n *)\n | Ppat_exception of pattern\n (* exception P *)\n | Ppat_extension of extension\n (* [%id] *)\n | Ppat_open of Longident.t loc * pattern\n\n (* Value expressions *)\n\n and expression (*IF_CURRENT = Parsetree.expression *) =\n {\n pexp_desc: expression_desc;\n pexp_loc: Location.t;\n pexp_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and expression_desc (*IF_CURRENT = Parsetree.expression_desc *) =\n | Pexp_ident of Longident.t loc\n (* x\n M.x\n *)\n | Pexp_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Pexp_let of rec_flag * value_binding list * expression\n (* let P1 = E1 and ... and Pn = EN in E (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in E (flag = Recursive)\n *)\n | Pexp_function of case list\n (* function P1 -> E1 | ... | Pn -> En *)\n | Pexp_fun of arg_label * expression option * pattern * expression\n (* fun P -> E1 (Simple, None)\n fun ~l:P -> E1 (Labelled l, None)\n fun ?l:P -> E1 (Optional l, None)\n fun ?l:(P = E0) -> E1 (Optional l, Some E0)\n\n Notes:\n - If E0 is provided, only Optional is allowed.\n - \"fun P1 P2 .. Pn -> E1\" is represented as nested Pexp_fun.\n - \"let f P = E\" is represented using Pexp_fun.\n *)\n | Pexp_apply of expression * (arg_label * expression) list\n (* E0 ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pexp_match of expression * case list\n (* match E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_try of expression * case list\n (* try E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_tuple of expression list\n (* (E1, ..., En)\n\n Invariant: n >= 2\n *)\n | Pexp_construct of Longident.t loc * expression option\n (* C None\n C E Some E\n C (E1, ..., En) Some (Pexp_tuple[E1;...;En])\n *)\n | Pexp_variant of label * expression option\n (* `A (None)\n `A E (Some E)\n *)\n | Pexp_record of (Longident.t loc * expression) list * expression option\n (* { l1=P1; ...; ln=Pn } (None)\n { E0 with l1=P1; ...; ln=Pn } (Some E0)\n\n Invariant: n > 0\n *)\n | Pexp_field of expression * Longident.t loc\n (* E.l *)\n | Pexp_setfield of expression * Longident.t loc * expression\n (* E1.l <- E2 *)\n | Pexp_array of expression list\n (* [| E1; ...; En |] *)\n | Pexp_ifthenelse of expression * expression * expression option\n (* if E1 then E2 else E3 *)\n | Pexp_sequence of expression * expression\n (* E1; E2 *)\n | Pexp_while of expression * expression\n (* while E1 do E2 done *)\n | Pexp_for of\n pattern * expression * expression * direction_flag * expression\n (* for i = E1 to E2 do E3 done (flag = Upto)\n for i = E1 downto E2 do E3 done (flag = Downto)\n *)\n | Pexp_constraint of expression * core_type\n (* (E : T) *)\n | Pexp_coerce of expression * core_type option * core_type\n (* (E :> T) (None, T)\n (E : T0 :> T) (Some T0, T)\n *)\n | Pexp_send of expression * string\n (* E # m *)\n | Pexp_new of Longident.t loc\n (* new M.c *)\n | Pexp_setinstvar of string loc * expression\n (* x <- 2 *)\n | Pexp_override of (string loc * expression) list\n (* {< x1 = E1; ...; Xn = En >} *)\n | Pexp_letmodule of string loc * module_expr * expression\n (* let module M = ME in E *)\n | Pexp_letexception of extension_constructor * expression\n (* let exception C in E *)\n | Pexp_assert of expression\n (* assert E\n Note: \"assert false\" is treated in a special way by the\n type-checker. *)\n | Pexp_lazy of expression\n (* lazy E *)\n | Pexp_poly of expression * core_type option\n (* Used for method bodies.\n\n Can only be used as the expression under Cfk_concrete\n for methods (not values). *)\n | Pexp_object of class_structure\n (* object ... end *)\n | Pexp_newtype of string * expression\n (* fun (type t) -> E *)\n | Pexp_pack of module_expr\n (* (module ME)\n\n (module ME : S) is represented as\n Pexp_constraint(Pexp_pack, Ptyp_package S) *)\n | Pexp_open of override_flag * Longident.t loc * expression\n (* let open M in E\n let! open M in E\n *)\n | Pexp_extension of extension\n (* [%id] *)\n | Pexp_unreachable\n (* . *)\n\n and case (*IF_CURRENT = Parsetree.case *) = (* (P -> E) or (P when E0 -> E) *)\n {\n pc_lhs: pattern;\n pc_guard: expression option;\n pc_rhs: expression;\n }\n\n (* Value descriptions *)\n\n and value_description (*IF_CURRENT = Parsetree.value_description *) =\n {\n pval_name: string loc;\n pval_type: core_type;\n pval_prim: string list;\n pval_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pval_loc: Location.t;\n }\n\n (*\n val x: T (prim = [])\n external x: T = \"s1\" ... \"sn\" (prim = [\"s1\";...\"sn\"])\n *)\n\n (* Type declarations *)\n\n and type_declaration (*IF_CURRENT = Parsetree.type_declaration *) =\n {\n ptype_name: string loc;\n ptype_params: (core_type * variance) list;\n (* ('a1,...'an) t; None represents _*)\n ptype_cstrs: (core_type * core_type * Location.t) list;\n (* ... constraint T1=T1' ... constraint Tn=Tn' *)\n ptype_kind: type_kind;\n ptype_private: private_flag; (* = private ... *)\n ptype_manifest: core_type option; (* = T *)\n ptype_attributes: attributes; (* ... [@@id1] [@@id2] *)\n ptype_loc: Location.t;\n }\n\n (*\n type t (abstract, no manifest)\n type t = T0 (abstract, manifest=T0)\n type t = C of T | ... (variant, no manifest)\n type t = T0 = C of T | ... (variant, manifest=T0)\n type t = {l: T; ...} (record, no manifest)\n type t = T0 = {l : T; ...} (record, manifest=T0)\n type t = .. (open, no manifest)\n *)\n\n and type_kind (*IF_CURRENT = Parsetree.type_kind *) =\n | Ptype_abstract\n | Ptype_variant of constructor_declaration list\n (* Invariant: non-empty list *)\n | Ptype_record of label_declaration list\n (* Invariant: non-empty list *)\n | Ptype_open\n\n and label_declaration (*IF_CURRENT = Parsetree.label_declaration *) =\n {\n pld_name: string loc;\n pld_mutable: mutable_flag;\n pld_type: core_type;\n pld_loc: Location.t;\n pld_attributes: attributes; (* l [@id1] [@id2] : T *)\n }\n\n (* { ...; l: T; ... } (mutable=Immutable)\n { ...; mutable l: T; ... } (mutable=Mutable)\n\n Note: T can be a Ptyp_poly.\n *)\n\n and constructor_declaration (*IF_CURRENT = Parsetree.constructor_declaration *) =\n {\n pcd_name: string loc;\n pcd_args: constructor_arguments;\n pcd_res: core_type option;\n pcd_loc: Location.t;\n pcd_attributes: attributes; (* C [@id1] [@id2] of ... *)\n }\n\n and constructor_arguments (*IF_CURRENT = Parsetree.constructor_arguments *) =\n | Pcstr_tuple of core_type list\n | Pcstr_record of label_declaration list\n\n (*\n | C of T1 * ... * Tn (res = None, args = Pcstr_tuple [])\n | C: T0 (res = Some T0, args = [])\n | C: T1 * ... * Tn -> T0 (res = Some T0, args = Pcstr_tuple)\n | C of {...} (res = None, args = Pcstr_record)\n | C: {...} -> T0 (res = Some T0, args = Pcstr_record)\n | C of {...} as t (res = None, args = Pcstr_record)\n *)\n\n and type_extension (*IF_CURRENT = Parsetree.type_extension *) =\n {\n ptyext_path: Longident.t loc;\n ptyext_params: (core_type * variance) list;\n ptyext_constructors: extension_constructor list;\n ptyext_private: private_flag;\n ptyext_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n (*\n type t += ...\n *)\n\n and extension_constructor (*IF_CURRENT = Parsetree.extension_constructor *) =\n {\n pext_name: string loc;\n pext_kind : extension_constructor_kind;\n pext_loc : Location.t;\n pext_attributes: attributes; (* C [@id1] [@id2] of ... *)\n }\n\n and extension_constructor_kind (*IF_CURRENT = Parsetree.extension_constructor_kind *) =\n Pext_decl of constructor_arguments * core_type option\n (*\n | C of T1 * ... * Tn ([T1; ...; Tn], None)\n | C: T0 ([], Some T0)\n | C: T1 * ... * Tn -> T0 ([T1; ...; Tn], Some T0)\n *)\n | Pext_rebind of Longident.t loc\n (*\n | C = D\n *)\n\n (** {2 Class language} *)\n\n (* Type expressions for the class language *)\n\n and class_type (*IF_CURRENT = Parsetree.class_type *) =\n {\n pcty_desc: class_type_desc;\n pcty_loc: Location.t;\n pcty_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and class_type_desc (*IF_CURRENT = Parsetree.class_type_desc *) =\n | Pcty_constr of Longident.t loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcty_signature of class_signature\n (* object ... end *)\n | Pcty_arrow of arg_label * core_type * class_type\n (* T -> CT Simple\n ~l:T -> CT Labelled l\n ?l:T -> CT Optional l\n *)\n | Pcty_extension of extension\n (* [%id] *)\n\n and class_signature (*IF_CURRENT = Parsetree.class_signature *) =\n {\n pcsig_self: core_type;\n pcsig_fields: class_type_field list;\n }\n (* object('selfpat) ... end\n object ... end (self = Ptyp_any)\n *)\n\n and class_type_field (*IF_CURRENT = Parsetree.class_type_field *) =\n {\n pctf_desc: class_type_field_desc;\n pctf_loc: Location.t;\n pctf_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and class_type_field_desc (*IF_CURRENT = Parsetree.class_type_field_desc *) =\n | Pctf_inherit of class_type\n (* inherit CT *)\n | Pctf_val of (string * mutable_flag * virtual_flag * core_type)\n (* val x: T *)\n | Pctf_method of (string * private_flag * virtual_flag * core_type)\n (* method x: T\n\n Note: T can be a Ptyp_poly.\n *)\n | Pctf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pctf_attribute of attribute\n (* [@@@id] *)\n | Pctf_extension of extension\n (* [%%id] *)\n\n and 'a class_infos (*IF_CURRENT = 'a Parsetree.class_infos *) =\n {\n pci_virt: virtual_flag;\n pci_params: (core_type * variance) list;\n pci_name: string loc;\n pci_expr: 'a;\n pci_loc: Location.t;\n pci_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n (* class c = ...\n class ['a1,...,'an] c = ...\n class virtual c = ...\n\n Also used for \"class type\" declaration.\n *)\n\n and class_description = class_type class_infos\n\n and class_type_declaration = class_type class_infos\n\n (* Value expressions for the class language *)\n\n and class_expr (*IF_CURRENT = Parsetree.class_expr *) =\n {\n pcl_desc: class_expr_desc;\n pcl_loc: Location.t;\n pcl_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and class_expr_desc (*IF_CURRENT = Parsetree.class_expr_desc *) =\n | Pcl_constr of Longident.t loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcl_structure of class_structure\n (* object ... end *)\n | Pcl_fun of arg_label * expression option * pattern * class_expr\n (* fun P -> CE (Simple, None)\n fun ~l:P -> CE (Labelled l, None)\n fun ?l:P -> CE (Optional l, None)\n fun ?l:(P = E0) -> CE (Optional l, Some E0)\n *)\n | Pcl_apply of class_expr * (arg_label * expression) list\n (* CE ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pcl_let of rec_flag * value_binding list * class_expr\n (* let P1 = E1 and ... and Pn = EN in CE (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in CE (flag = Recursive)\n *)\n | Pcl_constraint of class_expr * class_type\n (* (CE : CT) *)\n | Pcl_extension of extension\n (* [%id] *)\n\n and class_structure (*IF_CURRENT = Parsetree.class_structure *) =\n {\n pcstr_self: pattern;\n pcstr_fields: class_field list;\n }\n (* object(selfpat) ... end\n object ... end (self = Ppat_any)\n *)\n\n and class_field (*IF_CURRENT = Parsetree.class_field *) =\n {\n pcf_desc: class_field_desc;\n pcf_loc: Location.t;\n pcf_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and class_field_desc (*IF_CURRENT = Parsetree.class_field_desc *) =\n | Pcf_inherit of override_flag * class_expr * string option\n (* inherit CE\n inherit CE as x\n inherit! CE\n inherit! CE as x\n *)\n | Pcf_val of (string loc * mutable_flag * class_field_kind)\n (* val x = E\n val virtual x: T\n *)\n | Pcf_method of (string loc * private_flag * class_field_kind)\n (* method x = E (E can be a Pexp_poly)\n method virtual x: T (T can be a Ptyp_poly)\n *)\n | Pcf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pcf_initializer of expression\n (* initializer E *)\n | Pcf_attribute of attribute\n (* [@@@id] *)\n | Pcf_extension of extension\n (* [%%id] *)\n\n and class_field_kind (*IF_CURRENT = Parsetree.class_field_kind *) =\n | Cfk_virtual of core_type\n | Cfk_concrete of override_flag * expression\n\n and class_declaration = class_expr class_infos\n\n (** {2 Module language} *)\n\n (* Type expressions for the module language *)\n\n and module_type (*IF_CURRENT = Parsetree.module_type *) =\n {\n pmty_desc: module_type_desc;\n pmty_loc: Location.t;\n pmty_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and module_type_desc (*IF_CURRENT = Parsetree.module_type_desc *) =\n | Pmty_ident of Longident.t loc\n (* S *)\n | Pmty_signature of signature\n (* sig ... end *)\n | Pmty_functor of string loc * module_type option * module_type\n (* functor(X : MT1) -> MT2 *)\n | Pmty_with of module_type * with_constraint list\n (* MT with ... *)\n | Pmty_typeof of module_expr\n (* module type of ME *)\n | Pmty_extension of extension\n (* [%id] *)\n | Pmty_alias of Longident.t loc\n (* (module M) *)\n\n and signature = signature_item list\n\n and signature_item (*IF_CURRENT = Parsetree.signature_item *) =\n {\n psig_desc: signature_item_desc;\n psig_loc: Location.t;\n }\n\n and signature_item_desc (*IF_CURRENT = Parsetree.signature_item_desc *) =\n | Psig_value of value_description\n (*\n val x: T\n external x: T = \"s1\" ... \"sn\"\n *)\n | Psig_type of rec_flag * type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Psig_typext of type_extension\n (* type t1 += ... *)\n | Psig_exception of extension_constructor\n (* exception C of T *)\n | Psig_module of module_declaration\n (* module X : MT *)\n | Psig_recmodule of module_declaration list\n (* module rec X1 : MT1 and ... and Xn : MTn *)\n | Psig_modtype of module_type_declaration\n (* module type S = MT\n module type S *)\n | Psig_open of open_description\n (* open X *)\n | Psig_include of include_description\n (* include MT *)\n | Psig_class of class_description list\n (* class c1 : ... and ... and cn : ... *)\n | Psig_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Psig_attribute of attribute\n (* [@@@id] *)\n | Psig_extension of extension * attributes\n (* [%%id] *)\n\n and module_declaration (*IF_CURRENT = Parsetree.module_declaration *) =\n {\n pmd_name: string loc;\n pmd_type: module_type;\n pmd_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pmd_loc: Location.t;\n }\n (* S : MT *)\n\n and module_type_declaration (*IF_CURRENT = Parsetree.module_type_declaration *) =\n {\n pmtd_name: string loc;\n pmtd_type: module_type option;\n pmtd_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pmtd_loc: Location.t;\n }\n (* S = MT\n S (abstract module type declaration, pmtd_type = None)\n *)\n\n and open_description (*IF_CURRENT = Parsetree.open_description *) =\n {\n popen_lid: Longident.t loc;\n popen_override: override_flag;\n popen_loc: Location.t;\n popen_attributes: attributes;\n }\n (* open! X - popen_override = Override (silences the 'used identifier\n shadowing' warning)\n open X - popen_override = Fresh\n *)\n\n and 'a include_infos (*IF_CURRENT = 'a Parsetree.include_infos *) =\n {\n pincl_mod: 'a;\n pincl_loc: Location.t;\n pincl_attributes: attributes;\n }\n\n and include_description = module_type include_infos\n (* include MT *)\n\n and include_declaration = module_expr include_infos\n (* include ME *)\n\n and with_constraint (*IF_CURRENT = Parsetree.with_constraint *) =\n | Pwith_type of Longident.t loc * type_declaration\n (* with type X.t = ...\n\n Note: the last component of the longident must match\n the name of the type_declaration. *)\n | Pwith_module of Longident.t loc * Longident.t loc\n (* with module X.Y = Z *)\n | Pwith_typesubst of type_declaration\n (* with type t := ... *)\n | Pwith_modsubst of string loc * Longident.t loc\n (* with module X := Z *)\n\n (* Value expressions for the module language *)\n\n and module_expr (*IF_CURRENT = Parsetree.module_expr *) =\n {\n pmod_desc: module_expr_desc;\n pmod_loc: Location.t;\n pmod_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and module_expr_desc (*IF_CURRENT = Parsetree.module_expr_desc *) =\n | Pmod_ident of Longident.t loc\n (* X *)\n | Pmod_structure of structure\n (* struct ... end *)\n | Pmod_functor of string loc * module_type option * module_expr\n (* functor(X : MT1) -> ME *)\n | Pmod_apply of module_expr * module_expr\n (* ME1(ME2) *)\n | Pmod_constraint of module_expr * module_type\n (* (ME : MT) *)\n | Pmod_unpack of expression\n (* (val E) *)\n | Pmod_extension of extension\n (* [%id] *)\n\n and structure = structure_item list\n\n and structure_item (*IF_CURRENT = Parsetree.structure_item *) =\n {\n pstr_desc: structure_item_desc;\n pstr_loc: Location.t;\n }\n\n and structure_item_desc (*IF_CURRENT = Parsetree.structure_item_desc *) =\n | Pstr_eval of expression * attributes\n (* E *)\n | Pstr_value of rec_flag * value_binding list\n (* let P1 = E1 and ... and Pn = EN (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN (flag = Recursive)\n *)\n | Pstr_primitive of value_description\n (* val x: T\n external x: T = \"s1\" ... \"sn\" *)\n | Pstr_type of rec_flag * type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Pstr_typext of type_extension\n (* type t1 += ... *)\n | Pstr_exception of extension_constructor\n (* exception C of T\n exception C = M.X *)\n | Pstr_module of module_binding\n (* module X = ME *)\n | Pstr_recmodule of module_binding list\n (* module rec X1 = ME1 and ... and Xn = MEn *)\n | Pstr_modtype of module_type_declaration\n (* module type S = MT *)\n | Pstr_open of open_description\n (* open X *)\n | Pstr_class of class_declaration list\n (* class c1 = ... and ... and cn = ... *)\n | Pstr_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Pstr_include of include_declaration\n (* include ME *)\n | Pstr_attribute of attribute\n (* [@@@id] *)\n | Pstr_extension of extension * attributes\n (* [%%id] *)\n\n and value_binding (*IF_CURRENT = Parsetree.value_binding *) =\n {\n pvb_pat: pattern;\n pvb_expr: expression;\n pvb_attributes: attributes;\n pvb_loc: Location.t;\n }\n\n and module_binding (*IF_CURRENT = Parsetree.module_binding *) =\n {\n pmb_name: string loc;\n pmb_expr: module_expr;\n pmb_attributes: attributes;\n pmb_loc: Location.t;\n }\n (* X = ME *)\n\n (** {2 Toplevel} *)\n\n (* Toplevel phrases *)\n\n type toplevel_phrase (*IF_CURRENT = Parsetree.toplevel_phrase *) =\n | Ptop_def of structure\n | Ptop_dir of string * directive_argument\n (* #use, #load ... *)\n\n and directive_argument (*IF_CURRENT = Parsetree.directive_argument *) =\n | Pdir_none\n | Pdir_string of string\n | Pdir_int of string * char option\n | Pdir_ident of Longident.t\n | Pdir_bool of bool\nend\n\nmodule Config = struct\n let ast_impl_magic_number = \"Caml1999M020\"\n let ast_intf_magic_number = \"Caml1999N018\"\nend\n","(**************************************************************************)\n(* *)\n(* OCaml Migrate Parsetree *)\n(* *)\n(* Frédéric Bour *)\n(* Jérémie Dimino and Leo White, Jane Street Europe *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* Alain Frisch, LexiFi *)\n(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 2017 Institut National de Recherche en Informatique et *)\n(* en Automatique (INRIA). *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nmodule Asttypes = struct\n (* Auxiliary a.s.t. types used by parsetree and typedtree. *)\n\n type constant (*IF_CURRENT = Asttypes.constant *) =\n Const_int of int\n | Const_char of char\n | Const_string of string * string option\n | Const_float of string\n | Const_int32 of int32\n | Const_int64 of int64\n | Const_nativeint of nativeint\n\n type rec_flag (*IF_CURRENT = Asttypes.rec_flag *) = Nonrecursive | Recursive\n\n type direction_flag (*IF_CURRENT = Asttypes.direction_flag *) = Upto | Downto\n\n (* Order matters, used in polymorphic comparison *)\n type private_flag (*IF_CURRENT = Asttypes.private_flag *) = Private | Public\n\n type mutable_flag (*IF_CURRENT = Asttypes.mutable_flag *) = Immutable | Mutable\n\n type virtual_flag (*IF_CURRENT = Asttypes.virtual_flag *) = Virtual | Concrete\n\n type override_flag (*IF_CURRENT = Asttypes.override_flag *) = Override | Fresh\n\n type closed_flag (*IF_CURRENT = Asttypes.closed_flag *) = Closed | Open\n\n type label = string\n\n type arg_label (*IF_CURRENT = Asttypes.arg_label *) =\n Nolabel\n | Labelled of string (* label:T -> ... *)\n | Optional of string (* ?label:T -> ... *)\n\n type 'a loc = 'a Location.loc = {\n txt : 'a;\n loc : Location.t;\n }\n\n\n type variance (*IF_CURRENT = Asttypes.variance *) =\n | Covariant\n | Contravariant\n | Invariant\nend\n\nmodule Parsetree = struct\n (** Abstract syntax tree produced by parsing *)\n\n open Asttypes\n\n type constant (*IF_CURRENT = Parsetree.constant *) =\n Pconst_integer of string * char option\n (* 3 3l 3L 3n\n\n Suffixes [g-z][G-Z] are accepted by the parser.\n Suffixes except 'l', 'L' and 'n' are rejected by the typechecker\n *)\n | Pconst_char of char\n (* 'c' *)\n | Pconst_string of string * string option\n (* \"constant\"\n {delim|other constant|delim}\n *)\n | Pconst_float of string * char option\n (* 3.4 2e5 1.4e-4\n\n Suffixes [g-z][G-Z] are accepted by the parser.\n Suffixes are rejected by the typechecker.\n *)\n\n (** {2 Extension points} *)\n\n type attribute = string loc * payload\n (* [@id ARG]\n [@@id ARG]\n\n Metadata containers passed around within the AST.\n The compiler ignores unknown attributes.\n *)\n\n and extension = string loc * payload\n (* [%id ARG]\n [%%id ARG]\n\n Sub-language placeholder -- rejected by the typechecker.\n *)\n\n and attributes = attribute list\n\n and payload (*IF_CURRENT = Parsetree.payload *) =\n | PStr of structure\n | PSig of signature (* : SIG *)\n | PTyp of core_type (* : T *)\n | PPat of pattern * expression option (* ? P or ? P when E *)\n\n (** {2 Core language} *)\n\n (* Type expressions *)\n\n and core_type (*IF_CURRENT = Parsetree.core_type *) =\n {\n ptyp_desc: core_type_desc;\n ptyp_loc: Location.t;\n ptyp_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and core_type_desc (*IF_CURRENT = Parsetree.core_type_desc *) =\n | Ptyp_any\n (* _ *)\n | Ptyp_var of string\n (* 'a *)\n | Ptyp_arrow of arg_label * core_type * core_type\n (* T1 -> T2 Simple\n ~l:T1 -> T2 Labelled\n ?l:T1 -> T2 Otional\n *)\n | Ptyp_tuple of core_type list\n (* T1 * ... * Tn\n\n Invariant: n >= 2\n *)\n | Ptyp_constr of Longident.t loc * core_type list\n (* tconstr\n T tconstr\n (T1, ..., Tn) tconstr\n *)\n | Ptyp_object of (string * attributes * core_type) list * closed_flag\n (* < l1:T1; ...; ln:Tn > (flag = Closed)\n < l1:T1; ...; ln:Tn; .. > (flag = Open)\n *)\n | Ptyp_class of Longident.t loc * core_type list\n (* #tconstr\n T #tconstr\n (T1, ..., Tn) #tconstr\n *)\n | Ptyp_alias of core_type * string\n (* T as 'a *)\n | Ptyp_variant of row_field list * closed_flag * label list option\n (* [ `A|`B ] (flag = Closed; labels = None)\n [> `A|`B ] (flag = Open; labels = None)\n [< `A|`B ] (flag = Closed; labels = Some [])\n [< `A|`B > `X `Y ](flag = Closed; labels = Some [\"X\";\"Y\"])\n *)\n | Ptyp_poly of string list * core_type\n (* 'a1 ... 'an. T\n\n Can only appear in the following context:\n\n - As the core_type of a Ppat_constraint node corresponding\n to a constraint on a let-binding: let x : 'a1 ... 'an. T\n = e ...\n\n - Under Cfk_virtual for methods (not values).\n\n - As the core_type of a Pctf_method node.\n\n - As the core_type of a Pexp_poly node.\n\n - As the pld_type field of a label_declaration.\n\n - As a core_type of a Ptyp_object node.\n *)\n\n | Ptyp_package of package_type\n (* (module S) *)\n | Ptyp_extension of extension\n (* [%id] *)\n\n and package_type = Longident.t loc * (Longident.t loc * core_type) list\n (*\n (module S)\n (module S with type t1 = T1 and ... and tn = Tn)\n *)\n\n and row_field (*IF_CURRENT = Parsetree.row_field *) =\n | Rtag of label * attributes * bool * core_type list\n (* [`A] ( true, [] )\n [`A of T] ( false, [T] )\n [`A of T1 & .. & Tn] ( false, [T1;...Tn] )\n [`A of & T1 & .. & Tn] ( true, [T1;...Tn] )\n\n - The 2nd field is true if the tag contains a\n constant (empty) constructor.\n - '&' occurs when several types are used for the same constructor\n (see 4.2 in the manual)\n\n - TODO: switch to a record representation, and keep location\n *)\n | Rinherit of core_type\n (* [ T ] *)\n\n (* Patterns *)\n\n and pattern (*IF_CURRENT = Parsetree.pattern *) =\n {\n ppat_desc: pattern_desc;\n ppat_loc: Location.t;\n ppat_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and pattern_desc (*IF_CURRENT = Parsetree.pattern_desc *) =\n | Ppat_any\n (* _ *)\n | Ppat_var of string loc\n (* x *)\n | Ppat_alias of pattern * string loc\n (* P as 'a *)\n | Ppat_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Ppat_interval of constant * constant\n (* 'a'..'z'\n\n Other forms of interval are recognized by the parser\n but rejected by the type-checker. *)\n | Ppat_tuple of pattern list\n (* (P1, ..., Pn)\n\n Invariant: n >= 2\n *)\n | Ppat_construct of Longident.t loc * pattern option\n (* C None\n C P Some P\n C (P1, ..., Pn) Some (Ppat_tuple [P1; ...; Pn])\n *)\n | Ppat_variant of label * pattern option\n (* `A (None)\n `A P (Some P)\n *)\n | Ppat_record of (Longident.t loc * pattern) list * closed_flag\n (* { l1=P1; ...; ln=Pn } (flag = Closed)\n { l1=P1; ...; ln=Pn; _} (flag = Open)\n\n Invariant: n > 0\n *)\n | Ppat_array of pattern list\n (* [| P1; ...; Pn |] *)\n | Ppat_or of pattern * pattern\n (* P1 | P2 *)\n | Ppat_constraint of pattern * core_type\n (* (P : T) *)\n | Ppat_type of Longident.t loc\n (* #tconst *)\n | Ppat_lazy of pattern\n (* lazy P *)\n | Ppat_unpack of string loc\n (* (module P)\n Note: (module P : S) is represented as\n Ppat_constraint(Ppat_unpack, Ptyp_package)\n *)\n | Ppat_exception of pattern\n (* exception P *)\n | Ppat_extension of extension\n (* [%id] *)\n\n (* Value expressions *)\n\n and expression (*IF_CURRENT = Parsetree.expression *) =\n {\n pexp_desc: expression_desc;\n pexp_loc: Location.t;\n pexp_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and expression_desc (*IF_CURRENT = Parsetree.expression_desc *) =\n | Pexp_ident of Longident.t loc\n (* x\n M.x\n *)\n | Pexp_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Pexp_let of rec_flag * value_binding list * expression\n (* let P1 = E1 and ... and Pn = EN in E (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in E (flag = Recursive)\n *)\n | Pexp_function of case list\n (* function P1 -> E1 | ... | Pn -> En *)\n | Pexp_fun of arg_label * expression option * pattern * expression\n (* fun P -> E1 (Simple, None)\n fun ~l:P -> E1 (Labelled l, None)\n fun ?l:P -> E1 (Optional l, None)\n fun ?l:(P = E0) -> E1 (Optional l, Some E0)\n\n Notes:\n - If E0 is provided, only Optional is allowed.\n - \"fun P1 P2 .. Pn -> E1\" is represented as nested Pexp_fun.\n - \"let f P = E\" is represented using Pexp_fun.\n *)\n | Pexp_apply of expression * (arg_label * expression) list\n (* E0 ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pexp_match of expression * case list\n (* match E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_try of expression * case list\n (* try E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_tuple of expression list\n (* (E1, ..., En)\n\n Invariant: n >= 2\n *)\n | Pexp_construct of Longident.t loc * expression option\n (* C None\n C E Some E\n C (E1, ..., En) Some (Pexp_tuple[E1;...;En])\n *)\n | Pexp_variant of label * expression option\n (* `A (None)\n `A E (Some E)\n *)\n | Pexp_record of (Longident.t loc * expression) list * expression option\n (* { l1=P1; ...; ln=Pn } (None)\n { E0 with l1=P1; ...; ln=Pn } (Some E0)\n\n Invariant: n > 0\n *)\n | Pexp_field of expression * Longident.t loc\n (* E.l *)\n | Pexp_setfield of expression * Longident.t loc * expression\n (* E1.l <- E2 *)\n | Pexp_array of expression list\n (* [| E1; ...; En |] *)\n | Pexp_ifthenelse of expression * expression * expression option\n (* if E1 then E2 else E3 *)\n | Pexp_sequence of expression * expression\n (* E1; E2 *)\n | Pexp_while of expression * expression\n (* while E1 do E2 done *)\n | Pexp_for of\n pattern * expression * expression * direction_flag * expression\n (* for i = E1 to E2 do E3 done (flag = Upto)\n for i = E1 downto E2 do E3 done (flag = Downto)\n *)\n | Pexp_constraint of expression * core_type\n (* (E : T) *)\n | Pexp_coerce of expression * core_type option * core_type\n (* (E :> T) (None, T)\n (E : T0 :> T) (Some T0, T)\n *)\n | Pexp_send of expression * string\n (* E # m *)\n | Pexp_new of Longident.t loc\n (* new M.c *)\n | Pexp_setinstvar of string loc * expression\n (* x <- 2 *)\n | Pexp_override of (string loc * expression) list\n (* {< x1 = E1; ...; Xn = En >} *)\n | Pexp_letmodule of string loc * module_expr * expression\n (* let module M = ME in E *)\n | Pexp_assert of expression\n (* assert E\n Note: \"assert false\" is treated in a special way by the\n type-checker. *)\n | Pexp_lazy of expression\n (* lazy E *)\n | Pexp_poly of expression * core_type option\n (* Used for method bodies.\n\n Can only be used as the expression under Cfk_concrete\n for methods (not values). *)\n | Pexp_object of class_structure\n (* object ... end *)\n | Pexp_newtype of string * expression\n (* fun (type t) -> E *)\n | Pexp_pack of module_expr\n (* (module ME)\n\n (module ME : S) is represented as\n Pexp_constraint(Pexp_pack, Ptyp_package S) *)\n | Pexp_open of override_flag * Longident.t loc * expression\n (* let open M in E\n let! open M in E\n *)\n | Pexp_extension of extension\n (* [%id] *)\n | Pexp_unreachable\n (* . *)\n\n and case (*IF_CURRENT = Parsetree.case *) = (* (P -> E) or (P when E0 -> E) *)\n {\n pc_lhs: pattern;\n pc_guard: expression option;\n pc_rhs: expression;\n }\n\n (* Value descriptions *)\n\n and value_description (*IF_CURRENT = Parsetree.value_description *) =\n {\n pval_name: string loc;\n pval_type: core_type;\n pval_prim: string list;\n pval_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pval_loc: Location.t;\n }\n\n (*\n val x: T (prim = [])\n external x: T = \"s1\" ... \"sn\" (prim = [\"s1\";...\"sn\"])\n *)\n\n (* Type declarations *)\n\n and type_declaration (*IF_CURRENT = Parsetree.type_declaration *) =\n {\n ptype_name: string loc;\n ptype_params: (core_type * variance) list;\n (* ('a1,...'an) t; None represents _*)\n ptype_cstrs: (core_type * core_type * Location.t) list;\n (* ... constraint T1=T1' ... constraint Tn=Tn' *)\n ptype_kind: type_kind;\n ptype_private: private_flag; (* = private ... *)\n ptype_manifest: core_type option; (* = T *)\n ptype_attributes: attributes; (* ... [@@id1] [@@id2] *)\n ptype_loc: Location.t;\n }\n\n (*\n type t (abstract, no manifest)\n type t = T0 (abstract, manifest=T0)\n type t = C of T | ... (variant, no manifest)\n type t = T0 = C of T | ... (variant, manifest=T0)\n type t = {l: T; ...} (record, no manifest)\n type t = T0 = {l : T; ...} (record, manifest=T0)\n type t = .. (open, no manifest)\n *)\n\n and type_kind (*IF_CURRENT = Parsetree.type_kind *) =\n | Ptype_abstract\n | Ptype_variant of constructor_declaration list\n (* Invariant: non-empty list *)\n | Ptype_record of label_declaration list\n (* Invariant: non-empty list *)\n | Ptype_open\n\n and label_declaration (*IF_CURRENT = Parsetree.label_declaration *) =\n {\n pld_name: string loc;\n pld_mutable: mutable_flag;\n pld_type: core_type;\n pld_loc: Location.t;\n pld_attributes: attributes; (* l [@id1] [@id2] : T *)\n }\n\n (* { ...; l: T; ... } (mutable=Immutable)\n { ...; mutable l: T; ... } (mutable=Mutable)\n\n Note: T can be a Ptyp_poly.\n *)\n\n and constructor_declaration (*IF_CURRENT = Parsetree.constructor_declaration *) =\n {\n pcd_name: string loc;\n pcd_args: constructor_arguments;\n pcd_res: core_type option;\n pcd_loc: Location.t;\n pcd_attributes: attributes; (* C [@id1] [@id2] of ... *)\n }\n\n and constructor_arguments (*IF_CURRENT = Parsetree.constructor_arguments *) =\n | Pcstr_tuple of core_type list\n | Pcstr_record of label_declaration list\n\n (*\n | C of T1 * ... * Tn (res = None, args = Pcstr_tuple [])\n | C: T0 (res = Some T0, args = [])\n | C: T1 * ... * Tn -> T0 (res = Some T0, args = Pcstr_tuple)\n | C of {...} (res = None, args = Pcstr_record)\n | C: {...} -> T0 (res = Some T0, args = Pcstr_record)\n | C of {...} as t (res = None, args = Pcstr_record)\n *)\n\n and type_extension (*IF_CURRENT = Parsetree.type_extension *) =\n {\n ptyext_path: Longident.t loc;\n ptyext_params: (core_type * variance) list;\n ptyext_constructors: extension_constructor list;\n ptyext_private: private_flag;\n ptyext_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n (*\n type t += ...\n *)\n\n and extension_constructor (*IF_CURRENT = Parsetree.extension_constructor *) =\n {\n pext_name: string loc;\n pext_kind : extension_constructor_kind;\n pext_loc : Location.t;\n pext_attributes: attributes; (* C [@id1] [@id2] of ... *)\n }\n\n and extension_constructor_kind (*IF_CURRENT = Parsetree.extension_constructor_kind *) =\n Pext_decl of constructor_arguments * core_type option\n (*\n | C of T1 * ... * Tn ([T1; ...; Tn], None)\n | C: T0 ([], Some T0)\n | C: T1 * ... * Tn -> T0 ([T1; ...; Tn], Some T0)\n *)\n | Pext_rebind of Longident.t loc\n (*\n | C = D\n *)\n\n (** {2 Class language} *)\n\n (* Type expressions for the class language *)\n\n and class_type (*IF_CURRENT = Parsetree.class_type *) =\n {\n pcty_desc: class_type_desc;\n pcty_loc: Location.t;\n pcty_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and class_type_desc (*IF_CURRENT = Parsetree.class_type_desc *) =\n | Pcty_constr of Longident.t loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcty_signature of class_signature\n (* object ... end *)\n | Pcty_arrow of arg_label * core_type * class_type\n (* T -> CT Simple\n ~l:T -> CT Labelled l\n ?l:T -> CT Optional l\n *)\n | Pcty_extension of extension\n (* [%id] *)\n\n and class_signature (*IF_CURRENT = Parsetree.class_signature *) =\n {\n pcsig_self: core_type;\n pcsig_fields: class_type_field list;\n }\n (* object('selfpat) ... end\n object ... end (self = Ptyp_any)\n *)\n\n and class_type_field (*IF_CURRENT = Parsetree.class_type_field *) =\n {\n pctf_desc: class_type_field_desc;\n pctf_loc: Location.t;\n pctf_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and class_type_field_desc (*IF_CURRENT = Parsetree.class_type_field_desc *) =\n | Pctf_inherit of class_type\n (* inherit CT *)\n | Pctf_val of (string * mutable_flag * virtual_flag * core_type)\n (* val x: T *)\n | Pctf_method of (string * private_flag * virtual_flag * core_type)\n (* method x: T\n\n Note: T can be a Ptyp_poly.\n *)\n | Pctf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pctf_attribute of attribute\n (* [@@@id] *)\n | Pctf_extension of extension\n (* [%%id] *)\n\n and 'a class_infos (*IF_CURRENT = 'a Parsetree.class_infos *) =\n {\n pci_virt: virtual_flag;\n pci_params: (core_type * variance) list;\n pci_name: string loc;\n pci_expr: 'a;\n pci_loc: Location.t;\n pci_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n (* class c = ...\n class ['a1,...,'an] c = ...\n class virtual c = ...\n\n Also used for \"class type\" declaration.\n *)\n\n and class_description = class_type class_infos\n\n and class_type_declaration = class_type class_infos\n\n (* Value expressions for the class language *)\n\n and class_expr (*IF_CURRENT = Parsetree.class_expr *) =\n {\n pcl_desc: class_expr_desc;\n pcl_loc: Location.t;\n pcl_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and class_expr_desc (*IF_CURRENT = Parsetree.class_expr_desc *) =\n | Pcl_constr of Longident.t loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcl_structure of class_structure\n (* object ... end *)\n | Pcl_fun of arg_label * expression option * pattern * class_expr\n (* fun P -> CE (Simple, None)\n fun ~l:P -> CE (Labelled l, None)\n fun ?l:P -> CE (Optional l, None)\n fun ?l:(P = E0) -> CE (Optional l, Some E0)\n *)\n | Pcl_apply of class_expr * (arg_label * expression) list\n (* CE ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pcl_let of rec_flag * value_binding list * class_expr\n (* let P1 = E1 and ... and Pn = EN in CE (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in CE (flag = Recursive)\n *)\n | Pcl_constraint of class_expr * class_type\n (* (CE : CT) *)\n | Pcl_extension of extension\n (* [%id] *)\n\n and class_structure (*IF_CURRENT = Parsetree.class_structure *) =\n {\n pcstr_self: pattern;\n pcstr_fields: class_field list;\n }\n (* object(selfpat) ... end\n object ... end (self = Ppat_any)\n *)\n\n and class_field (*IF_CURRENT = Parsetree.class_field *) =\n {\n pcf_desc: class_field_desc;\n pcf_loc: Location.t;\n pcf_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and class_field_desc (*IF_CURRENT = Parsetree.class_field_desc *) =\n | Pcf_inherit of override_flag * class_expr * string option\n (* inherit CE\n inherit CE as x\n inherit! CE\n inherit! CE as x\n *)\n | Pcf_val of (string loc * mutable_flag * class_field_kind)\n (* val x = E\n val virtual x: T\n *)\n | Pcf_method of (string loc * private_flag * class_field_kind)\n (* method x = E (E can be a Pexp_poly)\n method virtual x: T (T can be a Ptyp_poly)\n *)\n | Pcf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pcf_initializer of expression\n (* initializer E *)\n | Pcf_attribute of attribute\n (* [@@@id] *)\n | Pcf_extension of extension\n (* [%%id] *)\n\n and class_field_kind (*IF_CURRENT = Parsetree.class_field_kind *) =\n | Cfk_virtual of core_type\n | Cfk_concrete of override_flag * expression\n\n and class_declaration = class_expr class_infos\n\n (** {2 Module language} *)\n\n (* Type expressions for the module language *)\n\n and module_type (*IF_CURRENT = Parsetree.module_type *) =\n {\n pmty_desc: module_type_desc;\n pmty_loc: Location.t;\n pmty_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and module_type_desc (*IF_CURRENT = Parsetree.module_type_desc *) =\n | Pmty_ident of Longident.t loc\n (* S *)\n | Pmty_signature of signature\n (* sig ... end *)\n | Pmty_functor of string loc * module_type option * module_type\n (* functor(X : MT1) -> MT2 *)\n | Pmty_with of module_type * with_constraint list\n (* MT with ... *)\n | Pmty_typeof of module_expr\n (* module type of ME *)\n | Pmty_extension of extension\n (* [%id] *)\n | Pmty_alias of Longident.t loc\n (* (module M) *)\n\n and signature = signature_item list\n\n and signature_item (*IF_CURRENT = Parsetree.signature_item *) =\n {\n psig_desc: signature_item_desc;\n psig_loc: Location.t;\n }\n\n and signature_item_desc (*IF_CURRENT = Parsetree.signature_item_desc *) =\n | Psig_value of value_description\n (*\n val x: T\n external x: T = \"s1\" ... \"sn\"\n *)\n | Psig_type of rec_flag * type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Psig_typext of type_extension\n (* type t1 += ... *)\n | Psig_exception of extension_constructor\n (* exception C of T *)\n | Psig_module of module_declaration\n (* module X : MT *)\n | Psig_recmodule of module_declaration list\n (* module rec X1 : MT1 and ... and Xn : MTn *)\n | Psig_modtype of module_type_declaration\n (* module type S = MT\n module type S *)\n | Psig_open of open_description\n (* open X *)\n | Psig_include of include_description\n (* include MT *)\n | Psig_class of class_description list\n (* class c1 : ... and ... and cn : ... *)\n | Psig_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Psig_attribute of attribute\n (* [@@@id] *)\n | Psig_extension of extension * attributes\n (* [%%id] *)\n\n and module_declaration (*IF_CURRENT = Parsetree.module_declaration *) =\n {\n pmd_name: string loc;\n pmd_type: module_type;\n pmd_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pmd_loc: Location.t;\n }\n (* S : MT *)\n\n and module_type_declaration (*IF_CURRENT = Parsetree.module_type_declaration *) =\n {\n pmtd_name: string loc;\n pmtd_type: module_type option;\n pmtd_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pmtd_loc: Location.t;\n }\n (* S = MT\n S (abstract module type declaration, pmtd_type = None)\n *)\n\n and open_description (*IF_CURRENT = Parsetree.open_description *) =\n {\n popen_lid: Longident.t loc;\n popen_override: override_flag;\n popen_loc: Location.t;\n popen_attributes: attributes;\n }\n (* open! X - popen_override = Override (silences the 'used identifier\n shadowing' warning)\n open X - popen_override = Fresh\n *)\n\n and 'a include_infos (*IF_CURRENT = 'a Parsetree.include_infos *) =\n {\n pincl_mod: 'a;\n pincl_loc: Location.t;\n pincl_attributes: attributes;\n }\n\n and include_description = module_type include_infos\n (* include MT *)\n\n and include_declaration = module_expr include_infos\n (* include ME *)\n\n and with_constraint (*IF_CURRENT = Parsetree.with_constraint *) =\n | Pwith_type of Longident.t loc * type_declaration\n (* with type X.t = ...\n\n Note: the last component of the longident must match\n the name of the type_declaration. *)\n | Pwith_module of Longident.t loc * Longident.t loc\n (* with module X.Y = Z *)\n | Pwith_typesubst of type_declaration\n (* with type t := ... *)\n | Pwith_modsubst of string loc * Longident.t loc\n (* with module X := Z *)\n\n (* Value expressions for the module language *)\n\n and module_expr (*IF_CURRENT = Parsetree.module_expr *) =\n {\n pmod_desc: module_expr_desc;\n pmod_loc: Location.t;\n pmod_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and module_expr_desc (*IF_CURRENT = Parsetree.module_expr_desc *) =\n | Pmod_ident of Longident.t loc\n (* X *)\n | Pmod_structure of structure\n (* struct ... end *)\n | Pmod_functor of string loc * module_type option * module_expr\n (* functor(X : MT1) -> ME *)\n | Pmod_apply of module_expr * module_expr\n (* ME1(ME2) *)\n | Pmod_constraint of module_expr * module_type\n (* (ME : MT) *)\n | Pmod_unpack of expression\n (* (val E) *)\n | Pmod_extension of extension\n (* [%id] *)\n\n and structure = structure_item list\n\n and structure_item (*IF_CURRENT = Parsetree.structure_item *) =\n {\n pstr_desc: structure_item_desc;\n pstr_loc: Location.t;\n }\n\n and structure_item_desc (*IF_CURRENT = Parsetree.structure_item_desc *) =\n | Pstr_eval of expression * attributes\n (* E *)\n | Pstr_value of rec_flag * value_binding list\n (* let P1 = E1 and ... and Pn = EN (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN (flag = Recursive)\n *)\n | Pstr_primitive of value_description\n (* val x: T\n external x: T = \"s1\" ... \"sn\" *)\n | Pstr_type of rec_flag * type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Pstr_typext of type_extension\n (* type t1 += ... *)\n | Pstr_exception of extension_constructor\n (* exception C of T\n exception C = M.X *)\n | Pstr_module of module_binding\n (* module X = ME *)\n | Pstr_recmodule of module_binding list\n (* module rec X1 = ME1 and ... and Xn = MEn *)\n | Pstr_modtype of module_type_declaration\n (* module type S = MT *)\n | Pstr_open of open_description\n (* open X *)\n | Pstr_class of class_declaration list\n (* class c1 = ... and ... and cn = ... *)\n | Pstr_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Pstr_include of include_declaration\n (* include ME *)\n | Pstr_attribute of attribute\n (* [@@@id] *)\n | Pstr_extension of extension * attributes\n (* [%%id] *)\n\n and value_binding (*IF_CURRENT = Parsetree.value_binding *) =\n {\n pvb_pat: pattern;\n pvb_expr: expression;\n pvb_attributes: attributes;\n pvb_loc: Location.t;\n }\n\n and module_binding (*IF_CURRENT = Parsetree.module_binding *) =\n {\n pmb_name: string loc;\n pmb_expr: module_expr;\n pmb_attributes: attributes;\n pmb_loc: Location.t;\n }\n (* X = ME *)\n\n (** {2 Toplevel} *)\n\n (* Toplevel phrases *)\n\n type toplevel_phrase (*IF_CURRENT = Parsetree.toplevel_phrase *) =\n | Ptop_def of structure\n | Ptop_dir of string * directive_argument\n (* #use, #load ... *)\n\n and directive_argument (*IF_CURRENT = Parsetree.directive_argument *) =\n | Pdir_none\n | Pdir_string of string\n | Pdir_int of string * char option\n | Pdir_ident of Longident.t\n | Pdir_bool of bool\nend\n\nmodule Config = struct\n let ast_impl_magic_number = \"Caml1999M019\"\n let ast_intf_magic_number = \"Caml1999N018\"\nend\n","(**************************************************************************)\n(* *)\n(* OCaml Migrate Parsetree *)\n(* *)\n(* Frédéric Bour *)\n(* Jérémie Dimino and Leo White, Jane Street Europe *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* Alain Frisch, LexiFi *)\n(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 2017 Institut National de Recherche en Informatique et *)\n(* en Automatique (INRIA). *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nmodule Asttypes = struct\n (* Auxiliary a.s.t. types used by parsetree and typedtree. *)\n\n type constant (*IF_CURRENT = Asttypes.constant *) =\n Const_int of int\n | Const_char of char\n | Const_string of string * string option\n | Const_float of string\n | Const_int32 of int32\n | Const_int64 of int64\n | Const_nativeint of nativeint\n\n type rec_flag (*IF_CURRENT = Asttypes.rec_flag *) = Nonrecursive | Recursive\n\n type direction_flag (*IF_CURRENT = Asttypes.direction_flag *) = Upto | Downto\n\n type private_flag (*IF_CURRENT = Asttypes.private_flag *) = Private | Public\n\n type mutable_flag (*IF_CURRENT = Asttypes.mutable_flag *) = Immutable | Mutable\n\n type virtual_flag (*IF_CURRENT = Asttypes.virtual_flag *) = Virtual | Concrete\n\n type override_flag (*IF_CURRENT = Asttypes.override_flag *) = Override | Fresh\n\n type closed_flag (*IF_CURRENT = Asttypes.closed_flag *) = Closed | Open\n\n type label = string\n\n type 'a loc = 'a Location.loc = {\n txt : 'a;\n loc : Location.t;\n }\n\n\n type variance (*IF_CURRENT = Asttypes.variance *) =\n | Covariant\n | Contravariant\n | Invariant\nend\n\nmodule Parsetree = struct\n (** Abstract syntax tree produced by parsing *)\n\n open Asttypes\n\n (** {2 Extension points} *)\n\n type attribute = string loc * payload\n (* [@id ARG]\n [@@id ARG]\n\n Metadata containers passed around within the AST.\n The compiler ignores unknown attributes.\n *)\n\n and extension = string loc * payload\n (* [%id ARG]\n [%%id ARG]\n\n Sub-language placeholder -- rejected by the typechecker.\n *)\n\n and attributes = attribute list\n\n and payload (*IF_CURRENT = Parsetree.payload *) =\n | PStr of structure\n | PTyp of core_type (* : T *)\n | PPat of pattern * expression option (* ? P or ? P when E *)\n\n (** {2 Core language} *)\n\n (* Type expressions *)\n\n and core_type (*IF_CURRENT = Parsetree.core_type *) =\n {\n ptyp_desc: core_type_desc;\n ptyp_loc: Location.t;\n ptyp_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and core_type_desc (*IF_CURRENT = Parsetree.core_type_desc *) =\n | Ptyp_any\n (* _ *)\n | Ptyp_var of string\n (* 'a *)\n | Ptyp_arrow of label * core_type * core_type\n (* T1 -> T2 (label = \"\")\n ~l:T1 -> T2 (label = \"l\")\n ?l:T1 -> T2 (label = \"?l\")\n *)\n | Ptyp_tuple of core_type list\n (* T1 * ... * Tn\n\n Invariant: n >= 2\n *)\n | Ptyp_constr of Longident.t loc * core_type list\n (* tconstr\n T tconstr\n (T1, ..., Tn) tconstr\n *)\n | Ptyp_object of (string * attributes * core_type) list * closed_flag\n (* < l1:T1; ...; ln:Tn > (flag = Closed)\n < l1:T1; ...; ln:Tn; .. > (flag = Open)\n *)\n | Ptyp_class of Longident.t loc * core_type list\n (* #tconstr\n T #tconstr\n (T1, ..., Tn) #tconstr\n *)\n | Ptyp_alias of core_type * string\n (* T as 'a *)\n | Ptyp_variant of row_field list * closed_flag * label list option\n (* [ `A|`B ] (flag = Closed; labels = None)\n [> `A|`B ] (flag = Open; labels = None)\n [< `A|`B ] (flag = Closed; labels = Some [])\n [< `A|`B > `X `Y ](flag = Closed; labels = Some [\"X\";\"Y\"])\n *)\n | Ptyp_poly of string list * core_type\n (* 'a1 ... 'an. T\n\n Can only appear in the following context:\n\n - As the core_type of a Ppat_constraint node corresponding\n to a constraint on a let-binding: let x : 'a1 ... 'an. T\n = e ...\n\n - Under Cfk_virtual for methods (not values).\n\n - As the core_type of a Pctf_method node.\n\n - As the core_type of a Pexp_poly node.\n\n - As the pld_type field of a label_declaration.\n\n - As a core_type of a Ptyp_object node.\n *)\n\n | Ptyp_package of package_type\n (* (module S) *)\n | Ptyp_extension of extension\n (* [%id] *)\n\n and package_type = Longident.t loc * (Longident.t loc * core_type) list\n (*\n (module S)\n (module S with type t1 = T1 and ... and tn = Tn)\n *)\n\n and row_field (*IF_CURRENT = Parsetree.row_field *) =\n | Rtag of label * attributes * bool * core_type list\n (* [`A] ( true, [] )\n [`A of T] ( false, [T] )\n [`A of T1 & .. & Tn] ( false, [T1;...Tn] )\n [`A of & T1 & .. & Tn] ( true, [T1;...Tn] )\n\n - The 2nd field is true if the tag contains a\n constant (empty) constructor.\n - '&' occurs when several types are used for the same constructor\n (see 4.2 in the manual)\n\n - TODO: switch to a record representation, and keep location\n *)\n | Rinherit of core_type\n (* [ T ] *)\n\n (* Patterns *)\n\n and pattern (*IF_CURRENT = Parsetree.pattern *) =\n {\n ppat_desc: pattern_desc;\n ppat_loc: Location.t;\n ppat_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and pattern_desc (*IF_CURRENT = Parsetree.pattern_desc *) =\n | Ppat_any\n (* _ *)\n | Ppat_var of string loc\n (* x *)\n | Ppat_alias of pattern * string loc\n (* P as 'a *)\n | Ppat_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Ppat_interval of constant * constant\n (* 'a'..'z'\n\n Other forms of interval are recognized by the parser\n but rejected by the type-checker. *)\n | Ppat_tuple of pattern list\n (* (P1, ..., Pn)\n\n Invariant: n >= 2\n *)\n | Ppat_construct of Longident.t loc * pattern option\n (* C None\n C P Some P\n C (P1, ..., Pn) Some (Ppat_tuple [P1; ...; Pn])\n *)\n | Ppat_variant of label * pattern option\n (* `A (None)\n `A P (Some P)\n *)\n | Ppat_record of (Longident.t loc * pattern) list * closed_flag\n (* { l1=P1; ...; ln=Pn } (flag = Closed)\n { l1=P1; ...; ln=Pn; _} (flag = Open)\n\n Invariant: n > 0\n *)\n | Ppat_array of pattern list\n (* [| P1; ...; Pn |] *)\n | Ppat_or of pattern * pattern\n (* P1 | P2 *)\n | Ppat_constraint of pattern * core_type\n (* (P : T) *)\n | Ppat_type of Longident.t loc\n (* #tconst *)\n | Ppat_lazy of pattern\n (* lazy P *)\n | Ppat_unpack of string loc\n (* (module P)\n Note: (module P : S) is represented as\n Ppat_constraint(Ppat_unpack, Ptyp_package)\n *)\n | Ppat_exception of pattern\n (* exception P *)\n | Ppat_extension of extension\n (* [%id] *)\n\n (* Value expressions *)\n\n and expression (*IF_CURRENT = Parsetree.expression *) =\n {\n pexp_desc: expression_desc;\n pexp_loc: Location.t;\n pexp_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and expression_desc (*IF_CURRENT = Parsetree.expression_desc *) =\n | Pexp_ident of Longident.t loc\n (* x\n M.x\n *)\n | Pexp_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Pexp_let of rec_flag * value_binding list * expression\n (* let P1 = E1 and ... and Pn = EN in E (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in E (flag = Recursive)\n *)\n | Pexp_function of case list\n (* function P1 -> E1 | ... | Pn -> En *)\n | Pexp_fun of label * expression option * pattern * expression\n (* fun P -> E1 (lab = \"\", None)\n fun ~l:P -> E1 (lab = \"l\", None)\n fun ?l:P -> E1 (lab = \"?l\", None)\n fun ?l:(P = E0) -> E1 (lab = \"?l\", Some E0)\n\n Notes:\n - If E0 is provided, lab must start with '?'.\n - \"fun P1 P2 .. Pn -> E1\" is represented as nested Pexp_fun.\n - \"let f P = E\" is represented using Pexp_fun.\n *)\n | Pexp_apply of expression * (label * expression) list\n (* E0 ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pexp_match of expression * case list\n (* match E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_try of expression * case list\n (* try E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_tuple of expression list\n (* (E1, ..., En)\n\n Invariant: n >= 2\n *)\n | Pexp_construct of Longident.t loc * expression option\n (* C None\n C E Some E\n C (E1, ..., En) Some (Pexp_tuple[E1;...;En])\n *)\n | Pexp_variant of label * expression option\n (* `A (None)\n `A E (Some E)\n *)\n | Pexp_record of (Longident.t loc * expression) list * expression option\n (* { l1=P1; ...; ln=Pn } (None)\n { E0 with l1=P1; ...; ln=Pn } (Some E0)\n\n Invariant: n > 0\n *)\n | Pexp_field of expression * Longident.t loc\n (* E.l *)\n | Pexp_setfield of expression * Longident.t loc * expression\n (* E1.l <- E2 *)\n | Pexp_array of expression list\n (* [| E1; ...; En |] *)\n | Pexp_ifthenelse of expression * expression * expression option\n (* if E1 then E2 else E3 *)\n | Pexp_sequence of expression * expression\n (* E1; E2 *)\n | Pexp_while of expression * expression\n (* while E1 do E2 done *)\n | Pexp_for of\n pattern * expression * expression * direction_flag * expression\n (* for i = E1 to E2 do E3 done (flag = Upto)\n for i = E1 downto E2 do E3 done (flag = Downto)\n *)\n | Pexp_constraint of expression * core_type\n (* (E : T) *)\n | Pexp_coerce of expression * core_type option * core_type\n (* (E :> T) (None, T)\n (E : T0 :> T) (Some T0, T)\n *)\n | Pexp_send of expression * string\n (* E # m *)\n | Pexp_new of Longident.t loc\n (* new M.c *)\n | Pexp_setinstvar of string loc * expression\n (* x <- 2 *)\n | Pexp_override of (string loc * expression) list\n (* {< x1 = E1; ...; Xn = En >} *)\n | Pexp_letmodule of string loc * module_expr * expression\n (* let module M = ME in E *)\n | Pexp_assert of expression\n (* assert E\n Note: \"assert false\" is treated in a special way by the\n type-checker. *)\n | Pexp_lazy of expression\n (* lazy E *)\n | Pexp_poly of expression * core_type option\n (* Used for method bodies.\n\n Can only be used as the expression under Cfk_concrete\n for methods (not values). *)\n | Pexp_object of class_structure\n (* object ... end *)\n | Pexp_newtype of string * expression\n (* fun (type t) -> E *)\n | Pexp_pack of module_expr\n (* (module ME)\n\n (module ME : S) is represented as\n Pexp_constraint(Pexp_pack, Ptyp_package S) *)\n | Pexp_open of override_flag * Longident.t loc * expression\n (* let open M in E\n let! open M in E\n *)\n | Pexp_extension of extension\n (* [%id] *)\n\n and case (*IF_CURRENT = Parsetree.case *) = (* (P -> E) or (P when E0 -> E) *)\n {\n pc_lhs: pattern;\n pc_guard: expression option;\n pc_rhs: expression;\n }\n\n (* Value descriptions *)\n\n and value_description (*IF_CURRENT = Parsetree.value_description *) =\n {\n pval_name: string loc;\n pval_type: core_type;\n pval_prim: string list;\n pval_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pval_loc: Location.t;\n }\n\n (*\n val x: T (prim = [])\n external x: T = \"s1\" ... \"sn\" (prim = [\"s1\";...\"sn\"])\n\n Note: when used under Pstr_primitive, prim cannot be empty\n *)\n\n (* Type declarations *)\n\n and type_declaration (*IF_CURRENT = Parsetree.type_declaration *) =\n {\n ptype_name: string loc;\n ptype_params: (core_type * variance) list;\n (* ('a1,...'an) t; None represents _*)\n ptype_cstrs: (core_type * core_type * Location.t) list;\n (* ... constraint T1=T1' ... constraint Tn=Tn' *)\n ptype_kind: type_kind;\n ptype_private: private_flag; (* = private ... *)\n ptype_manifest: core_type option; (* = T *)\n ptype_attributes: attributes; (* ... [@@id1] [@@id2] *)\n ptype_loc: Location.t;\n }\n\n (*\n type t (abstract, no manifest)\n type t = T0 (abstract, manifest=T0)\n type t = C of T | ... (variant, no manifest)\n type t = T0 = C of T | ... (variant, manifest=T0)\n type t = {l: T; ...} (record, no manifest)\n type t = T0 = {l : T; ...} (record, manifest=T0)\n type t = .. (open, no manifest)\n *)\n\n and type_kind (*IF_CURRENT = Parsetree.type_kind *) =\n | Ptype_abstract\n | Ptype_variant of constructor_declaration list\n (* Invariant: non-empty list *)\n | Ptype_record of label_declaration list\n (* Invariant: non-empty list *)\n | Ptype_open\n\n and label_declaration (*IF_CURRENT = Parsetree.label_declaration *) =\n {\n pld_name: string loc;\n pld_mutable: mutable_flag;\n pld_type: core_type;\n pld_loc: Location.t;\n pld_attributes: attributes; (* l [@id1] [@id2] : T *)\n }\n\n (* { ...; l: T; ... } (mutable=Immutable)\n { ...; mutable l: T; ... } (mutable=Mutable)\n\n Note: T can be a Ptyp_poly.\n *)\n\n and constructor_declaration (*IF_CURRENT = Parsetree.constructor_declaration *) =\n {\n pcd_name: string loc;\n pcd_args: core_type list;\n pcd_res: core_type option;\n pcd_loc: Location.t;\n pcd_attributes: attributes; (* C [@id1] [@id2] of ... *)\n }\n (*\n | C of T1 * ... * Tn (res = None)\n | C: T0 (args = [], res = Some T0)\n | C: T1 * ... * Tn -> T0 (res = Some T0)\n *)\n\n and type_extension (*IF_CURRENT = Parsetree.type_extension *) =\n {\n ptyext_path: Longident.t loc;\n ptyext_params: (core_type * variance) list;\n ptyext_constructors: extension_constructor list;\n ptyext_private: private_flag;\n ptyext_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n (*\n type t += ...\n *)\n\n and extension_constructor (*IF_CURRENT = Parsetree.extension_constructor *) =\n {\n pext_name: string loc;\n pext_kind : extension_constructor_kind;\n pext_loc : Location.t;\n pext_attributes: attributes; (* C [@id1] [@id2] of ... *)\n }\n\n and extension_constructor_kind (*IF_CURRENT = Parsetree.extension_constructor_kind *) =\n Pext_decl of core_type list * core_type option\n (*\n | C of T1 * ... * Tn ([T1; ...; Tn], None)\n | C: T0 ([], Some T0)\n | C: T1 * ... * Tn -> T0 ([T1; ...; Tn], Some T0)\n *)\n | Pext_rebind of Longident.t loc\n (*\n | C = D\n *)\n\n (** {2 Class language} *)\n\n (* Type expressions for the class language *)\n\n and class_type (*IF_CURRENT = Parsetree.class_type *) =\n {\n pcty_desc: class_type_desc;\n pcty_loc: Location.t;\n pcty_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and class_type_desc (*IF_CURRENT = Parsetree.class_type_desc *) =\n | Pcty_constr of Longident.t loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcty_signature of class_signature\n (* object ... end *)\n | Pcty_arrow of label * core_type * class_type\n (* T -> CT (label = \"\")\n ~l:T -> CT (label = \"l\")\n ?l:T -> CT (label = \"?l\")\n *)\n | Pcty_extension of extension\n (* [%id] *)\n\n and class_signature (*IF_CURRENT = Parsetree.class_signature *) =\n {\n pcsig_self: core_type;\n pcsig_fields: class_type_field list;\n }\n (* object('selfpat) ... end\n object ... end (self = Ptyp_any)\n *)\n\n and class_type_field (*IF_CURRENT = Parsetree.class_type_field *) =\n {\n pctf_desc: class_type_field_desc;\n pctf_loc: Location.t;\n pctf_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and class_type_field_desc (*IF_CURRENT = Parsetree.class_type_field_desc *) =\n | Pctf_inherit of class_type\n (* inherit CT *)\n | Pctf_val of (string * mutable_flag * virtual_flag * core_type)\n (* val x: T *)\n | Pctf_method of (string * private_flag * virtual_flag * core_type)\n (* method x: T\n\n Note: T can be a Ptyp_poly.\n *)\n | Pctf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pctf_attribute of attribute\n (* [@@@id] *)\n | Pctf_extension of extension\n (* [%%id] *)\n\n and 'a class_infos (*IF_CURRENT = 'a Parsetree.class_infos *) =\n {\n pci_virt: virtual_flag;\n pci_params: (core_type * variance) list;\n pci_name: string loc;\n pci_expr: 'a;\n pci_loc: Location.t;\n pci_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n (* class c = ...\n class ['a1,...,'an] c = ...\n class virtual c = ...\n\n Also used for \"class type\" declaration.\n *)\n\n and class_description = class_type class_infos\n\n and class_type_declaration = class_type class_infos\n\n (* Value expressions for the class language *)\n\n and class_expr (*IF_CURRENT = Parsetree.class_expr *) =\n {\n pcl_desc: class_expr_desc;\n pcl_loc: Location.t;\n pcl_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and class_expr_desc (*IF_CURRENT = Parsetree.class_expr_desc *) =\n | Pcl_constr of Longident.t loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcl_structure of class_structure\n (* object ... end *)\n | Pcl_fun of label * expression option * pattern * class_expr\n (* fun P -> CE (lab = \"\", None)\n fun ~l:P -> CE (lab = \"l\", None)\n fun ?l:P -> CE (lab = \"?l\", None)\n fun ?l:(P = E0) -> CE (lab = \"?l\", Some E0)\n *)\n | Pcl_apply of class_expr * (label * expression) list\n (* CE ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pcl_let of rec_flag * value_binding list * class_expr\n (* let P1 = E1 and ... and Pn = EN in CE (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in CE (flag = Recursive)\n *)\n | Pcl_constraint of class_expr * class_type\n (* (CE : CT) *)\n | Pcl_extension of extension\n (* [%id] *)\n\n and class_structure (*IF_CURRENT = Parsetree.class_structure *) =\n {\n pcstr_self: pattern;\n pcstr_fields: class_field list;\n }\n (* object(selfpat) ... end\n object ... end (self = Ppat_any)\n *)\n\n and class_field (*IF_CURRENT = Parsetree.class_field *) =\n {\n pcf_desc: class_field_desc;\n pcf_loc: Location.t;\n pcf_attributes: attributes; (* ... [@@id1] [@@id2] *)\n }\n\n and class_field_desc (*IF_CURRENT = Parsetree.class_field_desc *) =\n | Pcf_inherit of override_flag * class_expr * string option\n (* inherit CE\n inherit CE as x\n inherit! CE\n inherit! CE as x\n *)\n | Pcf_val of (string loc * mutable_flag * class_field_kind)\n (* val x = E\n val virtual x: T\n *)\n | Pcf_method of (string loc * private_flag * class_field_kind)\n (* method x = E (E can be a Pexp_poly)\n method virtual x: T (T can be a Ptyp_poly)\n *)\n | Pcf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pcf_initializer of expression\n (* initializer E *)\n | Pcf_attribute of attribute\n (* [@@@id] *)\n | Pcf_extension of extension\n (* [%%id] *)\n\n and class_field_kind (*IF_CURRENT = Parsetree.class_field_kind *) =\n | Cfk_virtual of core_type\n | Cfk_concrete of override_flag * expression\n\n and class_declaration = class_expr class_infos\n\n (** {2 Module language} *)\n\n (* Type expressions for the module language *)\n\n and module_type (*IF_CURRENT = Parsetree.module_type *) =\n {\n pmty_desc: module_type_desc;\n pmty_loc: Location.t;\n pmty_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and module_type_desc (*IF_CURRENT = Parsetree.module_type_desc *) =\n | Pmty_ident of Longident.t loc\n (* S *)\n | Pmty_signature of signature\n (* sig ... end *)\n | Pmty_functor of string loc * module_type option * module_type\n (* functor(X : MT1) -> MT2 *)\n | Pmty_with of module_type * with_constraint list\n (* MT with ... *)\n | Pmty_typeof of module_expr\n (* module type of ME *)\n | Pmty_extension of extension\n (* [%id] *)\n | Pmty_alias of Longident.t loc\n (* (module M) *)\n\n and signature = signature_item list\n\n and signature_item (*IF_CURRENT = Parsetree.signature_item *) =\n {\n psig_desc: signature_item_desc;\n psig_loc: Location.t;\n }\n\n and signature_item_desc (*IF_CURRENT = Parsetree.signature_item_desc *) =\n | Psig_value of value_description\n (*\n val x: T\n external x: T = \"s1\" ... \"sn\"\n *)\n | Psig_type of type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Psig_typext of type_extension\n (* type t1 += ... *)\n | Psig_exception of extension_constructor\n (* exception C of T *)\n | Psig_module of module_declaration\n (* module X : MT *)\n | Psig_recmodule of module_declaration list\n (* module rec X1 : MT1 and ... and Xn : MTn *)\n | Psig_modtype of module_type_declaration\n (* module type S = MT\n module type S *)\n | Psig_open of open_description\n (* open X *)\n | Psig_include of include_description\n (* include MT *)\n | Psig_class of class_description list\n (* class c1 : ... and ... and cn : ... *)\n | Psig_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Psig_attribute of attribute\n (* [@@@id] *)\n | Psig_extension of extension * attributes\n (* [%%id] *)\n\n and module_declaration (*IF_CURRENT = Parsetree.module_declaration *) =\n {\n pmd_name: string loc;\n pmd_type: module_type;\n pmd_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pmd_loc: Location.t;\n }\n (* S : MT *)\n\n and module_type_declaration (*IF_CURRENT = Parsetree.module_type_declaration *) =\n {\n pmtd_name: string loc;\n pmtd_type: module_type option;\n pmtd_attributes: attributes; (* ... [@@id1] [@@id2] *)\n pmtd_loc: Location.t;\n }\n (* S = MT\n S (abstract module type declaration, pmtd_type = None)\n *)\n\n and open_description (*IF_CURRENT = Parsetree.open_description *) =\n {\n popen_lid: Longident.t loc;\n popen_override: override_flag;\n popen_loc: Location.t;\n popen_attributes: attributes;\n }\n (* open! X - popen_override = Override (silences the 'used identifier\n shadowing' warning)\n open X - popen_override = Fresh\n *)\n\n and 'a include_infos (*IF_CURRENT = 'a Parsetree.include_infos *) =\n {\n pincl_mod: 'a;\n pincl_loc: Location.t;\n pincl_attributes: attributes;\n }\n\n and include_description = module_type include_infos\n (* include MT *)\n\n and include_declaration = module_expr include_infos\n (* include ME *)\n\n and with_constraint (*IF_CURRENT = Parsetree.with_constraint *) =\n | Pwith_type of Longident.t loc * type_declaration\n (* with type X.t = ...\n\n Note: the last component of the longident must match\n the name of the type_declaration. *)\n | Pwith_module of Longident.t loc * Longident.t loc\n (* with module X.Y = Z *)\n | Pwith_typesubst of type_declaration\n (* with type t := ... *)\n | Pwith_modsubst of string loc * Longident.t loc\n (* with module X := Z *)\n\n (* Value expressions for the module language *)\n\n and module_expr (*IF_CURRENT = Parsetree.module_expr *) =\n {\n pmod_desc: module_expr_desc;\n pmod_loc: Location.t;\n pmod_attributes: attributes; (* ... [@id1] [@id2] *)\n }\n\n and module_expr_desc (*IF_CURRENT = Parsetree.module_expr_desc *) =\n | Pmod_ident of Longident.t loc\n (* X *)\n | Pmod_structure of structure\n (* struct ... end *)\n | Pmod_functor of string loc * module_type option * module_expr\n (* functor(X : MT1) -> ME *)\n | Pmod_apply of module_expr * module_expr\n (* ME1(ME2) *)\n | Pmod_constraint of module_expr * module_type\n (* (ME : MT) *)\n | Pmod_unpack of expression\n (* (val E) *)\n | Pmod_extension of extension\n (* [%id] *)\n\n and structure = structure_item list\n\n and structure_item (*IF_CURRENT = Parsetree.structure_item *) =\n {\n pstr_desc: structure_item_desc;\n pstr_loc: Location.t;\n }\n\n and structure_item_desc (*IF_CURRENT = Parsetree.structure_item_desc *) =\n | Pstr_eval of expression * attributes\n (* E *)\n | Pstr_value of rec_flag * value_binding list\n (* let P1 = E1 and ... and Pn = EN (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN (flag = Recursive)\n *)\n | Pstr_primitive of value_description\n (* external x: T = \"s1\" ... \"sn\" *)\n | Pstr_type of type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Pstr_typext of type_extension\n (* type t1 += ... *)\n | Pstr_exception of extension_constructor\n (* exception C of T\n exception C = M.X *)\n | Pstr_module of module_binding\n (* module X = ME *)\n | Pstr_recmodule of module_binding list\n (* module rec X1 = ME1 and ... and Xn = MEn *)\n | Pstr_modtype of module_type_declaration\n (* module type S = MT *)\n | Pstr_open of open_description\n (* open X *)\n | Pstr_class of class_declaration list\n (* class c1 = ... and ... and cn = ... *)\n | Pstr_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Pstr_include of include_declaration\n (* include ME *)\n | Pstr_attribute of attribute\n (* [@@@id] *)\n | Pstr_extension of extension * attributes\n (* [%%id] *)\n\n and value_binding (*IF_CURRENT = Parsetree.value_binding *) =\n {\n pvb_pat: pattern;\n pvb_expr: expression;\n pvb_attributes: attributes;\n pvb_loc: Location.t;\n }\n\n and module_binding (*IF_CURRENT = Parsetree.module_binding *) =\n {\n pmb_name: string loc;\n pmb_expr: module_expr;\n pmb_attributes: attributes;\n pmb_loc: Location.t;\n }\n (* X = ME *)\n\n (** {2 Toplevel} *)\n\n (* Toplevel phrases *)\n\n type toplevel_phrase (*IF_CURRENT = Parsetree.toplevel_phrase *) =\n | Ptop_def of structure\n | Ptop_dir of string * directive_argument\n (* #use, #load ... *)\n\n and directive_argument (*IF_CURRENT = Parsetree.directive_argument *) =\n | Pdir_none\n | Pdir_string of string\n | Pdir_int of int\n | Pdir_ident of Longident.t\n | Pdir_bool of bool\nend\n\nmodule Config = struct\n let ast_impl_magic_number = \"Caml1999M016\"\n let ast_intf_magic_number = \"Caml1999N015\"\nend\n","(**************************************************************************)\n(* *)\n(* OCaml Migrate Parsetree *)\n(* *)\n(* Frédéric Bour *)\n(* Alain Frisch, LexiFi *)\n(* *)\n(* Copyright 2017 Institut National de Recherche en Informatique et *)\n(* en Automatique (INRIA). *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nmodule From = Ast_403\nmodule To = Ast_402\n\nlet inject_predef_option label d =\n let open To in\n let open Parsetree in\n match label with\n | From.Asttypes.Optional _ ->\n let loc = { d.ptyp_loc with Location.loc_ghost = true } in\n let txt = Longident.Ldot (Longident.Lident \"*predef*\", \"option\") in\n let ident = { Location.txt; loc } in\n {\n ptyp_desc = Ptyp_constr (ident, [ d ]);\n ptyp_loc = loc;\n ptyp_attributes = [];\n }\n | _ -> d\n\nlet from_loc { Location.txt = _; loc } = loc\n\nlet migration_error loc missing_feature =\n Location.raise_errorf ~loc\n \"migration error: %s is not supported before OCaml 4.03\" missing_feature\n\nlet rec copy_expression : From.Parsetree.expression -> To.Parsetree.expression =\n fun {\n From.Parsetree.pexp_desc;\n From.Parsetree.pexp_loc;\n From.Parsetree.pexp_attributes;\n } ->\n {\n To.Parsetree.pexp_desc = copy_expression_desc pexp_loc pexp_desc;\n To.Parsetree.pexp_loc = copy_location pexp_loc;\n To.Parsetree.pexp_attributes = copy_attributes pexp_attributes;\n }\n\nand copy_expression_desc loc :\n From.Parsetree.expression_desc -> To.Parsetree.expression_desc = function\n | From.Parsetree.Pexp_ident x0 ->\n To.Parsetree.Pexp_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pexp_constant x0 ->\n To.Parsetree.Pexp_constant (copy_constant loc x0)\n | From.Parsetree.Pexp_let (x0, x1, x2) ->\n To.Parsetree.Pexp_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_expression x2)\n | From.Parsetree.Pexp_function x0 ->\n To.Parsetree.Pexp_function (List.map copy_case x0)\n | From.Parsetree.Pexp_fun (x0, x1, x2, x3) ->\n To.Parsetree.Pexp_fun\n ( copy_arg_label x0,\n copy_option copy_expression x1,\n copy_pattern x2,\n copy_expression x3 )\n | From.Parsetree.Pexp_apply (x0, x1) ->\n To.Parsetree.Pexp_apply\n ( copy_expression x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | From.Parsetree.Pexp_match (x0, x1) ->\n To.Parsetree.Pexp_match (copy_expression x0, List.map copy_case x1)\n | From.Parsetree.Pexp_try (x0, x1) ->\n To.Parsetree.Pexp_try (copy_expression x0, List.map copy_case x1)\n | From.Parsetree.Pexp_tuple x0 ->\n To.Parsetree.Pexp_tuple (List.map copy_expression x0)\n | From.Parsetree.Pexp_construct (x0, x1) ->\n To.Parsetree.Pexp_construct\n (copy_loc copy_longident x0, copy_option copy_expression x1)\n | From.Parsetree.Pexp_variant (x0, x1) ->\n To.Parsetree.Pexp_variant (copy_label x0, copy_option copy_expression x1)\n | From.Parsetree.Pexp_record (x0, x1) ->\n To.Parsetree.Pexp_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_expression x1))\n x0,\n copy_option copy_expression x1 )\n | From.Parsetree.Pexp_field (x0, x1) ->\n To.Parsetree.Pexp_field (copy_expression x0, copy_loc copy_longident x1)\n | From.Parsetree.Pexp_setfield (x0, x1, x2) ->\n To.Parsetree.Pexp_setfield\n (copy_expression x0, copy_loc copy_longident x1, copy_expression x2)\n | From.Parsetree.Pexp_array x0 ->\n To.Parsetree.Pexp_array (List.map copy_expression x0)\n | From.Parsetree.Pexp_ifthenelse (x0, x1, x2) ->\n To.Parsetree.Pexp_ifthenelse\n (copy_expression x0, copy_expression x1, copy_option copy_expression x2)\n | From.Parsetree.Pexp_sequence (x0, x1) ->\n To.Parsetree.Pexp_sequence (copy_expression x0, copy_expression x1)\n | From.Parsetree.Pexp_while (x0, x1) ->\n To.Parsetree.Pexp_while (copy_expression x0, copy_expression x1)\n | From.Parsetree.Pexp_for (x0, x1, x2, x3, x4) ->\n To.Parsetree.Pexp_for\n ( copy_pattern x0,\n copy_expression x1,\n copy_expression x2,\n copy_direction_flag x3,\n copy_expression x4 )\n | From.Parsetree.Pexp_constraint (x0, x1) ->\n To.Parsetree.Pexp_constraint (copy_expression x0, copy_core_type x1)\n | From.Parsetree.Pexp_coerce (x0, x1, x2) ->\n To.Parsetree.Pexp_coerce\n (copy_expression x0, copy_option copy_core_type x1, copy_core_type x2)\n | From.Parsetree.Pexp_send (x0, x1) ->\n To.Parsetree.Pexp_send (copy_expression x0, x1)\n | From.Parsetree.Pexp_new x0 ->\n To.Parsetree.Pexp_new (copy_loc copy_longident x0)\n | From.Parsetree.Pexp_setinstvar (x0, x1) ->\n To.Parsetree.Pexp_setinstvar (copy_loc (fun x -> x) x0, copy_expression x1)\n | From.Parsetree.Pexp_override x0 ->\n To.Parsetree.Pexp_override\n (List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_expression x1))\n x0)\n | From.Parsetree.Pexp_letmodule (x0, x1, x2) ->\n To.Parsetree.Pexp_letmodule\n (copy_loc (fun x -> x) x0, copy_module_expr x1, copy_expression x2)\n | From.Parsetree.Pexp_assert x0 ->\n To.Parsetree.Pexp_assert (copy_expression x0)\n | From.Parsetree.Pexp_lazy x0 -> To.Parsetree.Pexp_lazy (copy_expression x0)\n | From.Parsetree.Pexp_poly (x0, x1) ->\n To.Parsetree.Pexp_poly (copy_expression x0, copy_option copy_core_type x1)\n | From.Parsetree.Pexp_object x0 ->\n To.Parsetree.Pexp_object (copy_class_structure x0)\n | From.Parsetree.Pexp_newtype (x0, x1) ->\n To.Parsetree.Pexp_newtype (x0, copy_expression x1)\n | From.Parsetree.Pexp_pack x0 -> To.Parsetree.Pexp_pack (copy_module_expr x0)\n | From.Parsetree.Pexp_open (x0, x1, x2) ->\n To.Parsetree.Pexp_open\n (copy_override_flag x0, copy_loc copy_longident x1, copy_expression x2)\n | From.Parsetree.Pexp_extension x0 ->\n To.Parsetree.Pexp_extension (copy_extension x0)\n | From.Parsetree.Pexp_unreachable ->\n migration_error loc \"unreachable patterns\"\n\nand copy_direction_flag :\n From.Asttypes.direction_flag -> To.Asttypes.direction_flag = function\n | From.Asttypes.Upto -> To.Asttypes.Upto\n | From.Asttypes.Downto -> To.Asttypes.Downto\n\nand copy_case : From.Parsetree.case -> To.Parsetree.case =\n fun { From.Parsetree.pc_lhs; From.Parsetree.pc_guard; From.Parsetree.pc_rhs } ->\n {\n To.Parsetree.pc_lhs = copy_pattern pc_lhs;\n To.Parsetree.pc_guard = copy_option copy_expression pc_guard;\n To.Parsetree.pc_rhs = copy_expression pc_rhs;\n }\n\nand copy_value_binding :\n From.Parsetree.value_binding -> To.Parsetree.value_binding =\n fun {\n From.Parsetree.pvb_pat;\n From.Parsetree.pvb_expr;\n From.Parsetree.pvb_attributes;\n From.Parsetree.pvb_loc;\n } ->\n {\n To.Parsetree.pvb_pat = copy_pattern pvb_pat;\n To.Parsetree.pvb_expr = copy_expression pvb_expr;\n To.Parsetree.pvb_attributes = copy_attributes pvb_attributes;\n To.Parsetree.pvb_loc = copy_location pvb_loc;\n }\n\nand copy_pattern : From.Parsetree.pattern -> To.Parsetree.pattern =\n fun {\n From.Parsetree.ppat_desc;\n From.Parsetree.ppat_loc;\n From.Parsetree.ppat_attributes;\n } ->\n {\n To.Parsetree.ppat_desc = copy_pattern_desc ppat_loc ppat_desc;\n To.Parsetree.ppat_loc = copy_location ppat_loc;\n To.Parsetree.ppat_attributes = copy_attributes ppat_attributes;\n }\n\nand copy_pattern_desc loc :\n From.Parsetree.pattern_desc -> To.Parsetree.pattern_desc = function\n | From.Parsetree.Ppat_any -> To.Parsetree.Ppat_any\n | From.Parsetree.Ppat_var x0 ->\n To.Parsetree.Ppat_var (copy_loc (fun x -> x) x0)\n | From.Parsetree.Ppat_alias (x0, x1) ->\n To.Parsetree.Ppat_alias (copy_pattern x0, copy_loc (fun x -> x) x1)\n | From.Parsetree.Ppat_constant x0 ->\n To.Parsetree.Ppat_constant (copy_constant loc x0)\n | From.Parsetree.Ppat_interval (x0, x1) ->\n To.Parsetree.Ppat_interval (copy_constant loc x0, copy_constant loc x1)\n | From.Parsetree.Ppat_tuple x0 ->\n To.Parsetree.Ppat_tuple (List.map copy_pattern x0)\n | From.Parsetree.Ppat_construct (x0, x1) ->\n To.Parsetree.Ppat_construct\n (copy_loc copy_longident x0, copy_option copy_pattern x1)\n | From.Parsetree.Ppat_variant (x0, x1) ->\n To.Parsetree.Ppat_variant (copy_label x0, copy_option copy_pattern x1)\n | From.Parsetree.Ppat_record (x0, x1) ->\n To.Parsetree.Ppat_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_pattern x1))\n x0,\n copy_closed_flag x1 )\n | From.Parsetree.Ppat_array x0 ->\n To.Parsetree.Ppat_array (List.map copy_pattern x0)\n | From.Parsetree.Ppat_or (x0, x1) ->\n To.Parsetree.Ppat_or (copy_pattern x0, copy_pattern x1)\n | From.Parsetree.Ppat_constraint (x0, x1) ->\n To.Parsetree.Ppat_constraint (copy_pattern x0, copy_core_type x1)\n | From.Parsetree.Ppat_type x0 ->\n To.Parsetree.Ppat_type (copy_loc copy_longident x0)\n | From.Parsetree.Ppat_lazy x0 -> To.Parsetree.Ppat_lazy (copy_pattern x0)\n | From.Parsetree.Ppat_unpack x0 ->\n To.Parsetree.Ppat_unpack (copy_loc (fun x -> x) x0)\n | From.Parsetree.Ppat_exception x0 ->\n To.Parsetree.Ppat_exception (copy_pattern x0)\n | From.Parsetree.Ppat_extension x0 ->\n To.Parsetree.Ppat_extension (copy_extension x0)\n\nand copy_core_type : From.Parsetree.core_type -> To.Parsetree.core_type =\n fun {\n From.Parsetree.ptyp_desc;\n From.Parsetree.ptyp_loc;\n From.Parsetree.ptyp_attributes;\n } ->\n {\n To.Parsetree.ptyp_desc = copy_core_type_desc ptyp_desc;\n To.Parsetree.ptyp_loc = copy_location ptyp_loc;\n To.Parsetree.ptyp_attributes = copy_attributes ptyp_attributes;\n }\n\nand copy_core_type_desc :\n From.Parsetree.core_type_desc -> To.Parsetree.core_type_desc = function\n | From.Parsetree.Ptyp_any -> To.Parsetree.Ptyp_any\n | From.Parsetree.Ptyp_var x0 -> To.Parsetree.Ptyp_var x0\n | From.Parsetree.Ptyp_arrow (x0, x1, x2) ->\n To.Parsetree.Ptyp_arrow\n ( copy_arg_label x0,\n inject_predef_option x0 (copy_core_type x1),\n copy_core_type x2 )\n | From.Parsetree.Ptyp_tuple x0 ->\n To.Parsetree.Ptyp_tuple (List.map copy_core_type x0)\n | From.Parsetree.Ptyp_constr (x0, x1) ->\n To.Parsetree.Ptyp_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Ptyp_object (x0, x1) ->\n To.Parsetree.Ptyp_object\n ( List.map\n (fun x ->\n let x0, x1, x2 = x in\n (x0, copy_attributes x1, copy_core_type x2))\n x0,\n copy_closed_flag x1 )\n | From.Parsetree.Ptyp_class (x0, x1) ->\n To.Parsetree.Ptyp_class\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Ptyp_alias (x0, x1) ->\n To.Parsetree.Ptyp_alias (copy_core_type x0, x1)\n | From.Parsetree.Ptyp_variant (x0, x1, x2) ->\n To.Parsetree.Ptyp_variant\n ( List.map copy_row_field x0,\n copy_closed_flag x1,\n copy_option (fun x -> List.map copy_label x) x2 )\n | From.Parsetree.Ptyp_poly (x0, x1) ->\n To.Parsetree.Ptyp_poly (List.map (fun x -> x) x0, copy_core_type x1)\n | From.Parsetree.Ptyp_package x0 ->\n To.Parsetree.Ptyp_package (copy_package_type x0)\n | From.Parsetree.Ptyp_extension x0 ->\n To.Parsetree.Ptyp_extension (copy_extension x0)\n\nand copy_package_type : From.Parsetree.package_type -> To.Parsetree.package_type\n =\n fun x ->\n let x0, x1 = x in\n ( copy_loc copy_longident x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_core_type x1))\n x1 )\n\nand copy_row_field : From.Parsetree.row_field -> To.Parsetree.row_field =\n function\n | From.Parsetree.Rtag (x0, x1, x2, x3) ->\n To.Parsetree.Rtag\n ( copy_label x0,\n copy_attributes x1,\n copy_bool x2,\n List.map copy_core_type x3 )\n | From.Parsetree.Rinherit x0 -> To.Parsetree.Rinherit (copy_core_type x0)\n\nand copy_attributes : From.Parsetree.attributes -> To.Parsetree.attributes =\n fun x -> List.map copy_attribute x\n\nand copy_attribute : From.Parsetree.attribute -> To.Parsetree.attribute =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload (from_loc x0) x1)\n\nand copy_payload loc : From.Parsetree.payload -> To.Parsetree.payload = function\n | From.Parsetree.PStr x0 -> To.Parsetree.PStr (copy_structure x0)\n | From.Parsetree.PSig _x0 -> migration_error loc \"signatures in attribute\"\n | From.Parsetree.PTyp x0 -> To.Parsetree.PTyp (copy_core_type x0)\n | From.Parsetree.PPat (x0, x1) ->\n To.Parsetree.PPat (copy_pattern x0, copy_option copy_expression x1)\n\nand copy_structure : From.Parsetree.structure -> To.Parsetree.structure =\n fun x -> List.map copy_structure_item x\n\nand copy_structure_item :\n From.Parsetree.structure_item -> To.Parsetree.structure_item =\n fun { From.Parsetree.pstr_desc; From.Parsetree.pstr_loc } ->\n {\n To.Parsetree.pstr_desc = copy_structure_item_desc pstr_desc;\n To.Parsetree.pstr_loc = copy_location pstr_loc;\n }\n\nand copy_structure_item_desc :\n From.Parsetree.structure_item_desc -> To.Parsetree.structure_item_desc =\n function\n | From.Parsetree.Pstr_eval (x0, x1) ->\n To.Parsetree.Pstr_eval (copy_expression x0, copy_attributes x1)\n | From.Parsetree.Pstr_value (x0, x1) ->\n To.Parsetree.Pstr_value (copy_rec_flag x0, List.map copy_value_binding x1)\n | From.Parsetree.Pstr_primitive x0 ->\n To.Parsetree.Pstr_primitive (copy_value_description x0)\n | From.Parsetree.Pstr_type (x0, x1) ->\n To.Parsetree.Pstr_type (type_declarations x0 x1)\n | From.Parsetree.Pstr_typext x0 ->\n To.Parsetree.Pstr_typext (copy_type_extension x0)\n | From.Parsetree.Pstr_exception x0 ->\n To.Parsetree.Pstr_exception (copy_extension_constructor x0)\n | From.Parsetree.Pstr_module x0 ->\n To.Parsetree.Pstr_module (copy_module_binding x0)\n | From.Parsetree.Pstr_recmodule x0 ->\n To.Parsetree.Pstr_recmodule (List.map copy_module_binding x0)\n | From.Parsetree.Pstr_modtype x0 ->\n To.Parsetree.Pstr_modtype (copy_module_type_declaration x0)\n | From.Parsetree.Pstr_open x0 ->\n To.Parsetree.Pstr_open (copy_open_description x0)\n | From.Parsetree.Pstr_class x0 ->\n To.Parsetree.Pstr_class (List.map copy_class_declaration x0)\n | From.Parsetree.Pstr_class_type x0 ->\n To.Parsetree.Pstr_class_type (List.map copy_class_type_declaration x0)\n | From.Parsetree.Pstr_include x0 ->\n To.Parsetree.Pstr_include (copy_include_declaration x0)\n | From.Parsetree.Pstr_attribute x0 ->\n To.Parsetree.Pstr_attribute (copy_attribute x0)\n | From.Parsetree.Pstr_extension (x0, x1) ->\n To.Parsetree.Pstr_extension (copy_extension x0, copy_attributes x1)\n\nand copy_include_declaration :\n From.Parsetree.include_declaration -> To.Parsetree.include_declaration =\n fun x -> copy_include_infos copy_module_expr x\n\nand copy_class_declaration :\n From.Parsetree.class_declaration -> To.Parsetree.class_declaration =\n fun x -> copy_class_infos copy_class_expr x\n\nand copy_class_expr : From.Parsetree.class_expr -> To.Parsetree.class_expr =\n fun {\n From.Parsetree.pcl_desc;\n From.Parsetree.pcl_loc;\n From.Parsetree.pcl_attributes;\n } ->\n {\n To.Parsetree.pcl_desc = copy_class_expr_desc pcl_desc;\n To.Parsetree.pcl_loc = copy_location pcl_loc;\n To.Parsetree.pcl_attributes = copy_attributes pcl_attributes;\n }\n\nand copy_class_expr_desc :\n From.Parsetree.class_expr_desc -> To.Parsetree.class_expr_desc = function\n | From.Parsetree.Pcl_constr (x0, x1) ->\n To.Parsetree.Pcl_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Pcl_structure x0 ->\n To.Parsetree.Pcl_structure (copy_class_structure x0)\n | From.Parsetree.Pcl_fun (x0, x1, x2, x3) ->\n To.Parsetree.Pcl_fun\n ( copy_arg_label x0,\n copy_option copy_expression x1,\n copy_pattern x2,\n copy_class_expr x3 )\n | From.Parsetree.Pcl_apply (x0, x1) ->\n To.Parsetree.Pcl_apply\n ( copy_class_expr x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | From.Parsetree.Pcl_let (x0, x1, x2) ->\n To.Parsetree.Pcl_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_class_expr x2)\n | From.Parsetree.Pcl_constraint (x0, x1) ->\n To.Parsetree.Pcl_constraint (copy_class_expr x0, copy_class_type x1)\n | From.Parsetree.Pcl_extension x0 ->\n To.Parsetree.Pcl_extension (copy_extension x0)\n\nand copy_class_structure :\n From.Parsetree.class_structure -> To.Parsetree.class_structure =\n fun { From.Parsetree.pcstr_self; From.Parsetree.pcstr_fields } ->\n {\n To.Parsetree.pcstr_self = copy_pattern pcstr_self;\n To.Parsetree.pcstr_fields = List.map copy_class_field pcstr_fields;\n }\n\nand copy_class_field : From.Parsetree.class_field -> To.Parsetree.class_field =\n fun {\n From.Parsetree.pcf_desc;\n From.Parsetree.pcf_loc;\n From.Parsetree.pcf_attributes;\n } ->\n {\n To.Parsetree.pcf_desc = copy_class_field_desc pcf_desc;\n To.Parsetree.pcf_loc = copy_location pcf_loc;\n To.Parsetree.pcf_attributes = copy_attributes pcf_attributes;\n }\n\nand copy_class_field_desc :\n From.Parsetree.class_field_desc -> To.Parsetree.class_field_desc = function\n | From.Parsetree.Pcf_inherit (x0, x1, x2) ->\n To.Parsetree.Pcf_inherit\n (copy_override_flag x0, copy_class_expr x1, copy_option (fun x -> x) x2)\n | From.Parsetree.Pcf_val x0 ->\n To.Parsetree.Pcf_val\n (let x0, x1, x2 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_mutable_flag x1,\n copy_class_field_kind x2 ))\n | From.Parsetree.Pcf_method x0 ->\n To.Parsetree.Pcf_method\n (let x0, x1, x2 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_private_flag x1,\n copy_class_field_kind x2 ))\n | From.Parsetree.Pcf_constraint x0 ->\n To.Parsetree.Pcf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | From.Parsetree.Pcf_initializer x0 ->\n To.Parsetree.Pcf_initializer (copy_expression x0)\n | From.Parsetree.Pcf_attribute x0 ->\n To.Parsetree.Pcf_attribute (copy_attribute x0)\n | From.Parsetree.Pcf_extension x0 ->\n To.Parsetree.Pcf_extension (copy_extension x0)\n\nand copy_class_field_kind :\n From.Parsetree.class_field_kind -> To.Parsetree.class_field_kind = function\n | From.Parsetree.Cfk_virtual x0 ->\n To.Parsetree.Cfk_virtual (copy_core_type x0)\n | From.Parsetree.Cfk_concrete (x0, x1) ->\n To.Parsetree.Cfk_concrete (copy_override_flag x0, copy_expression x1)\n\nand copy_module_binding :\n From.Parsetree.module_binding -> To.Parsetree.module_binding =\n fun {\n From.Parsetree.pmb_name;\n From.Parsetree.pmb_expr;\n From.Parsetree.pmb_attributes;\n From.Parsetree.pmb_loc;\n } ->\n {\n To.Parsetree.pmb_name = copy_loc (fun x -> x) pmb_name;\n To.Parsetree.pmb_expr = copy_module_expr pmb_expr;\n To.Parsetree.pmb_attributes = copy_attributes pmb_attributes;\n To.Parsetree.pmb_loc = copy_location pmb_loc;\n }\n\nand copy_module_expr : From.Parsetree.module_expr -> To.Parsetree.module_expr =\n fun {\n From.Parsetree.pmod_desc;\n From.Parsetree.pmod_loc;\n From.Parsetree.pmod_attributes;\n } ->\n {\n To.Parsetree.pmod_desc = copy_module_expr_desc pmod_desc;\n To.Parsetree.pmod_loc = copy_location pmod_loc;\n To.Parsetree.pmod_attributes = copy_attributes pmod_attributes;\n }\n\nand copy_module_expr_desc :\n From.Parsetree.module_expr_desc -> To.Parsetree.module_expr_desc = function\n | From.Parsetree.Pmod_ident x0 ->\n To.Parsetree.Pmod_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pmod_structure x0 ->\n To.Parsetree.Pmod_structure (copy_structure x0)\n | From.Parsetree.Pmod_functor (x0, x1, x2) ->\n To.Parsetree.Pmod_functor\n ( copy_loc (fun x -> x) x0,\n copy_option copy_module_type x1,\n copy_module_expr x2 )\n | From.Parsetree.Pmod_apply (x0, x1) ->\n To.Parsetree.Pmod_apply (copy_module_expr x0, copy_module_expr x1)\n | From.Parsetree.Pmod_constraint (x0, x1) ->\n To.Parsetree.Pmod_constraint (copy_module_expr x0, copy_module_type x1)\n | From.Parsetree.Pmod_unpack x0 ->\n To.Parsetree.Pmod_unpack (copy_expression x0)\n | From.Parsetree.Pmod_extension x0 ->\n To.Parsetree.Pmod_extension (copy_extension x0)\n\nand copy_module_type : From.Parsetree.module_type -> To.Parsetree.module_type =\n fun {\n From.Parsetree.pmty_desc;\n From.Parsetree.pmty_loc;\n From.Parsetree.pmty_attributes;\n } ->\n {\n To.Parsetree.pmty_desc = copy_module_type_desc pmty_desc;\n To.Parsetree.pmty_loc = copy_location pmty_loc;\n To.Parsetree.pmty_attributes = copy_attributes pmty_attributes;\n }\n\nand copy_module_type_desc :\n From.Parsetree.module_type_desc -> To.Parsetree.module_type_desc = function\n | From.Parsetree.Pmty_ident x0 ->\n To.Parsetree.Pmty_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pmty_signature x0 ->\n To.Parsetree.Pmty_signature (copy_signature x0)\n | From.Parsetree.Pmty_functor (x0, x1, x2) ->\n To.Parsetree.Pmty_functor\n ( copy_loc (fun x -> x) x0,\n copy_option copy_module_type x1,\n copy_module_type x2 )\n | From.Parsetree.Pmty_with (x0, x1) ->\n To.Parsetree.Pmty_with\n (copy_module_type x0, List.map copy_with_constraint x1)\n | From.Parsetree.Pmty_typeof x0 ->\n To.Parsetree.Pmty_typeof (copy_module_expr x0)\n | From.Parsetree.Pmty_extension x0 ->\n To.Parsetree.Pmty_extension (copy_extension x0)\n | From.Parsetree.Pmty_alias x0 ->\n To.Parsetree.Pmty_alias (copy_loc copy_longident x0)\n\nand copy_with_constraint :\n From.Parsetree.with_constraint -> To.Parsetree.with_constraint = function\n | From.Parsetree.Pwith_type (x0, x1) ->\n To.Parsetree.Pwith_type\n (copy_loc copy_longident x0, copy_type_declaration x1)\n | From.Parsetree.Pwith_module (x0, x1) ->\n To.Parsetree.Pwith_module\n (copy_loc copy_longident x0, copy_loc copy_longident x1)\n | From.Parsetree.Pwith_typesubst x0 ->\n To.Parsetree.Pwith_typesubst (copy_type_declaration x0)\n | From.Parsetree.Pwith_modsubst (x0, x1) ->\n To.Parsetree.Pwith_modsubst\n (copy_loc (fun x -> x) x0, copy_loc copy_longident x1)\n\nand copy_signature : From.Parsetree.signature -> To.Parsetree.signature =\n fun x -> List.map copy_signature_item x\n\nand copy_signature_item :\n From.Parsetree.signature_item -> To.Parsetree.signature_item =\n fun { From.Parsetree.psig_desc; From.Parsetree.psig_loc } ->\n {\n To.Parsetree.psig_desc = copy_signature_item_desc psig_desc;\n To.Parsetree.psig_loc = copy_location psig_loc;\n }\n\nand copy_signature_item_desc :\n From.Parsetree.signature_item_desc -> To.Parsetree.signature_item_desc =\n function\n | From.Parsetree.Psig_value x0 ->\n To.Parsetree.Psig_value (copy_value_description x0)\n | From.Parsetree.Psig_type (x0, x1) ->\n To.Parsetree.Psig_type (type_declarations x0 x1)\n | From.Parsetree.Psig_typext x0 ->\n To.Parsetree.Psig_typext (copy_type_extension x0)\n | From.Parsetree.Psig_exception x0 ->\n To.Parsetree.Psig_exception (copy_extension_constructor x0)\n | From.Parsetree.Psig_module x0 ->\n To.Parsetree.Psig_module (copy_module_declaration x0)\n | From.Parsetree.Psig_recmodule x0 ->\n To.Parsetree.Psig_recmodule (List.map copy_module_declaration x0)\n | From.Parsetree.Psig_modtype x0 ->\n To.Parsetree.Psig_modtype (copy_module_type_declaration x0)\n | From.Parsetree.Psig_open x0 ->\n To.Parsetree.Psig_open (copy_open_description x0)\n | From.Parsetree.Psig_include x0 ->\n To.Parsetree.Psig_include (copy_include_description x0)\n | From.Parsetree.Psig_class x0 ->\n To.Parsetree.Psig_class (List.map copy_class_description x0)\n | From.Parsetree.Psig_class_type x0 ->\n To.Parsetree.Psig_class_type (List.map copy_class_type_declaration x0)\n | From.Parsetree.Psig_attribute x0 ->\n To.Parsetree.Psig_attribute (copy_attribute x0)\n | From.Parsetree.Psig_extension (x0, x1) ->\n To.Parsetree.Psig_extension (copy_extension x0, copy_attributes x1)\n\nand copy_class_type_declaration :\n From.Parsetree.class_type_declaration -> To.Parsetree.class_type_declaration\n =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_description :\n From.Parsetree.class_description -> To.Parsetree.class_description =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_type : From.Parsetree.class_type -> To.Parsetree.class_type =\n fun {\n From.Parsetree.pcty_desc;\n From.Parsetree.pcty_loc;\n From.Parsetree.pcty_attributes;\n } ->\n {\n To.Parsetree.pcty_desc = copy_class_type_desc pcty_desc;\n To.Parsetree.pcty_loc = copy_location pcty_loc;\n To.Parsetree.pcty_attributes = copy_attributes pcty_attributes;\n }\n\nand copy_class_type_desc :\n From.Parsetree.class_type_desc -> To.Parsetree.class_type_desc = function\n | From.Parsetree.Pcty_constr (x0, x1) ->\n To.Parsetree.Pcty_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Pcty_signature x0 ->\n To.Parsetree.Pcty_signature (copy_class_signature x0)\n | From.Parsetree.Pcty_arrow (x0, x1, x2) ->\n To.Parsetree.Pcty_arrow\n ( copy_arg_label x0,\n inject_predef_option x0 (copy_core_type x1),\n copy_class_type x2 )\n | From.Parsetree.Pcty_extension x0 ->\n To.Parsetree.Pcty_extension (copy_extension x0)\n\nand copy_class_signature :\n From.Parsetree.class_signature -> To.Parsetree.class_signature =\n fun { From.Parsetree.pcsig_self; From.Parsetree.pcsig_fields } ->\n {\n To.Parsetree.pcsig_self = copy_core_type pcsig_self;\n To.Parsetree.pcsig_fields = List.map copy_class_type_field pcsig_fields;\n }\n\nand copy_class_type_field :\n From.Parsetree.class_type_field -> To.Parsetree.class_type_field =\n fun {\n From.Parsetree.pctf_desc;\n From.Parsetree.pctf_loc;\n From.Parsetree.pctf_attributes;\n } ->\n {\n To.Parsetree.pctf_desc = copy_class_type_field_desc pctf_desc;\n To.Parsetree.pctf_loc = copy_location pctf_loc;\n To.Parsetree.pctf_attributes = copy_attributes pctf_attributes;\n }\n\nand copy_class_type_field_desc :\n From.Parsetree.class_type_field_desc -> To.Parsetree.class_type_field_desc =\n function\n | From.Parsetree.Pctf_inherit x0 ->\n To.Parsetree.Pctf_inherit (copy_class_type x0)\n | From.Parsetree.Pctf_val x0 ->\n To.Parsetree.Pctf_val\n (let x0, x1, x2, x3 = x0 in\n (x0, copy_mutable_flag x1, copy_virtual_flag x2, copy_core_type x3))\n | From.Parsetree.Pctf_method x0 ->\n To.Parsetree.Pctf_method\n (let x0, x1, x2, x3 = x0 in\n (x0, copy_private_flag x1, copy_virtual_flag x2, copy_core_type x3))\n | From.Parsetree.Pctf_constraint x0 ->\n To.Parsetree.Pctf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | From.Parsetree.Pctf_attribute x0 ->\n To.Parsetree.Pctf_attribute (copy_attribute x0)\n | From.Parsetree.Pctf_extension x0 ->\n To.Parsetree.Pctf_extension (copy_extension x0)\n\nand copy_extension : From.Parsetree.extension -> To.Parsetree.extension =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload (from_loc x0) x1)\n\nand copy_class_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 From.Parsetree.class_infos ->\n 'g0 To.Parsetree.class_infos =\n fun f0\n {\n From.Parsetree.pci_virt;\n From.Parsetree.pci_params;\n From.Parsetree.pci_name;\n From.Parsetree.pci_expr;\n From.Parsetree.pci_loc;\n From.Parsetree.pci_attributes;\n } ->\n {\n To.Parsetree.pci_virt = copy_virtual_flag pci_virt;\n To.Parsetree.pci_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n pci_params;\n To.Parsetree.pci_name = copy_loc (fun x -> x) pci_name;\n To.Parsetree.pci_expr = f0 pci_expr;\n To.Parsetree.pci_loc = copy_location pci_loc;\n To.Parsetree.pci_attributes = copy_attributes pci_attributes;\n }\n\nand copy_virtual_flag : From.Asttypes.virtual_flag -> To.Asttypes.virtual_flag =\n function\n | From.Asttypes.Virtual -> To.Asttypes.Virtual\n | From.Asttypes.Concrete -> To.Asttypes.Concrete\n\nand copy_include_description :\n From.Parsetree.include_description -> To.Parsetree.include_description =\n fun x -> copy_include_infos copy_module_type x\n\nand copy_include_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 From.Parsetree.include_infos ->\n 'g0 To.Parsetree.include_infos =\n fun f0\n {\n From.Parsetree.pincl_mod;\n From.Parsetree.pincl_loc;\n From.Parsetree.pincl_attributes;\n } ->\n {\n To.Parsetree.pincl_mod = f0 pincl_mod;\n To.Parsetree.pincl_loc = copy_location pincl_loc;\n To.Parsetree.pincl_attributes = copy_attributes pincl_attributes;\n }\n\nand copy_open_description :\n From.Parsetree.open_description -> To.Parsetree.open_description =\n fun {\n From.Parsetree.popen_lid;\n From.Parsetree.popen_override;\n From.Parsetree.popen_loc;\n From.Parsetree.popen_attributes;\n } ->\n {\n To.Parsetree.popen_lid = copy_loc copy_longident popen_lid;\n To.Parsetree.popen_override = copy_override_flag popen_override;\n To.Parsetree.popen_loc = copy_location popen_loc;\n To.Parsetree.popen_attributes = copy_attributes popen_attributes;\n }\n\nand copy_override_flag :\n From.Asttypes.override_flag -> To.Asttypes.override_flag = function\n | From.Asttypes.Override -> To.Asttypes.Override\n | From.Asttypes.Fresh -> To.Asttypes.Fresh\n\nand copy_module_type_declaration :\n From.Parsetree.module_type_declaration ->\n To.Parsetree.module_type_declaration =\n fun {\n From.Parsetree.pmtd_name;\n From.Parsetree.pmtd_type;\n From.Parsetree.pmtd_attributes;\n From.Parsetree.pmtd_loc;\n } ->\n {\n To.Parsetree.pmtd_name = copy_loc (fun x -> x) pmtd_name;\n To.Parsetree.pmtd_type = copy_option copy_module_type pmtd_type;\n To.Parsetree.pmtd_attributes = copy_attributes pmtd_attributes;\n To.Parsetree.pmtd_loc = copy_location pmtd_loc;\n }\n\nand copy_module_declaration :\n From.Parsetree.module_declaration -> To.Parsetree.module_declaration =\n fun {\n From.Parsetree.pmd_name;\n From.Parsetree.pmd_type;\n From.Parsetree.pmd_attributes;\n From.Parsetree.pmd_loc;\n } ->\n {\n To.Parsetree.pmd_name = copy_loc (fun x -> x) pmd_name;\n To.Parsetree.pmd_type = copy_module_type pmd_type;\n To.Parsetree.pmd_attributes = copy_attributes pmd_attributes;\n To.Parsetree.pmd_loc = copy_location pmd_loc;\n }\n\nand copy_type_extension :\n From.Parsetree.type_extension -> To.Parsetree.type_extension =\n fun {\n From.Parsetree.ptyext_path;\n From.Parsetree.ptyext_params;\n From.Parsetree.ptyext_constructors;\n From.Parsetree.ptyext_private;\n From.Parsetree.ptyext_attributes;\n } ->\n {\n To.Parsetree.ptyext_path = copy_loc copy_longident ptyext_path;\n To.Parsetree.ptyext_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptyext_params;\n To.Parsetree.ptyext_constructors =\n List.map copy_extension_constructor ptyext_constructors;\n To.Parsetree.ptyext_private = copy_private_flag ptyext_private;\n To.Parsetree.ptyext_attributes = copy_attributes ptyext_attributes;\n }\n\nand copy_extension_constructor :\n From.Parsetree.extension_constructor -> To.Parsetree.extension_constructor =\n fun {\n From.Parsetree.pext_name;\n From.Parsetree.pext_kind;\n From.Parsetree.pext_loc;\n From.Parsetree.pext_attributes;\n } ->\n {\n To.Parsetree.pext_name = copy_loc (fun x -> x) pext_name;\n To.Parsetree.pext_kind =\n copy_extension_constructor_kind (from_loc pext_name) pext_kind;\n To.Parsetree.pext_loc = copy_location pext_loc;\n To.Parsetree.pext_attributes = copy_attributes pext_attributes;\n }\n\nand copy_extension_constructor_kind loc :\n From.Parsetree.extension_constructor_kind ->\n To.Parsetree.extension_constructor_kind = function\n | From.Parsetree.Pext_decl (x0, x1) ->\n To.Parsetree.Pext_decl\n (copy_constructor_arguments loc x0, copy_option copy_core_type x1)\n | From.Parsetree.Pext_rebind x0 ->\n To.Parsetree.Pext_rebind (copy_loc copy_longident x0)\n\nand copy_type_declaration :\n From.Parsetree.type_declaration -> To.Parsetree.type_declaration =\n fun {\n From.Parsetree.ptype_name;\n From.Parsetree.ptype_params;\n From.Parsetree.ptype_cstrs;\n From.Parsetree.ptype_kind;\n From.Parsetree.ptype_private;\n From.Parsetree.ptype_manifest;\n From.Parsetree.ptype_attributes;\n From.Parsetree.ptype_loc;\n } ->\n {\n To.Parsetree.ptype_name = copy_loc (fun x -> x) ptype_name;\n To.Parsetree.ptype_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptype_params;\n To.Parsetree.ptype_cstrs =\n List.map\n (fun x ->\n let x0, x1, x2 = x in\n (copy_core_type x0, copy_core_type x1, copy_location x2))\n ptype_cstrs;\n To.Parsetree.ptype_kind = copy_type_kind ptype_kind;\n To.Parsetree.ptype_private = copy_private_flag ptype_private;\n To.Parsetree.ptype_manifest = copy_option copy_core_type ptype_manifest;\n To.Parsetree.ptype_attributes = copy_attributes ptype_attributes;\n To.Parsetree.ptype_loc = copy_location ptype_loc;\n }\n\nand copy_private_flag : From.Asttypes.private_flag -> To.Asttypes.private_flag =\n function\n | From.Asttypes.Private -> To.Asttypes.Private\n | From.Asttypes.Public -> To.Asttypes.Public\n\nand copy_type_kind : From.Parsetree.type_kind -> To.Parsetree.type_kind =\n function\n | From.Parsetree.Ptype_abstract -> To.Parsetree.Ptype_abstract\n | From.Parsetree.Ptype_variant x0 ->\n To.Parsetree.Ptype_variant (List.map copy_constructor_declaration x0)\n | From.Parsetree.Ptype_record x0 ->\n To.Parsetree.Ptype_record (List.map copy_label_declaration x0)\n | From.Parsetree.Ptype_open -> To.Parsetree.Ptype_open\n\nand copy_constructor_declaration :\n From.Parsetree.constructor_declaration ->\n To.Parsetree.constructor_declaration =\n fun {\n From.Parsetree.pcd_name;\n From.Parsetree.pcd_args;\n From.Parsetree.pcd_res;\n From.Parsetree.pcd_loc;\n From.Parsetree.pcd_attributes;\n } ->\n {\n To.Parsetree.pcd_name = copy_loc (fun x -> x) pcd_name;\n To.Parsetree.pcd_args =\n copy_constructor_arguments (from_loc pcd_name) pcd_args;\n To.Parsetree.pcd_res = copy_option copy_core_type pcd_res;\n To.Parsetree.pcd_loc = copy_location pcd_loc;\n To.Parsetree.pcd_attributes = copy_attributes pcd_attributes;\n }\n\nand copy_constructor_arguments loc :\n From.Parsetree.constructor_arguments -> To.Parsetree.core_type list =\n function\n | From.Parsetree.Pcstr_tuple x0 -> List.map copy_core_type x0\n | From.Parsetree.Pcstr_record _x0 -> migration_error loc \"inline records\"\n\nand copy_label_declaration :\n From.Parsetree.label_declaration -> To.Parsetree.label_declaration =\n fun {\n From.Parsetree.pld_name;\n From.Parsetree.pld_mutable;\n From.Parsetree.pld_type;\n From.Parsetree.pld_loc;\n From.Parsetree.pld_attributes;\n } ->\n {\n To.Parsetree.pld_name = copy_loc (fun x -> x) pld_name;\n To.Parsetree.pld_mutable = copy_mutable_flag pld_mutable;\n To.Parsetree.pld_type = copy_core_type pld_type;\n To.Parsetree.pld_loc = copy_location pld_loc;\n To.Parsetree.pld_attributes = copy_attributes pld_attributes;\n }\n\nand copy_mutable_flag : From.Asttypes.mutable_flag -> To.Asttypes.mutable_flag =\n function\n | From.Asttypes.Immutable -> To.Asttypes.Immutable\n | From.Asttypes.Mutable -> To.Asttypes.Mutable\n\nand copy_variance : From.Asttypes.variance -> To.Asttypes.variance = function\n | From.Asttypes.Covariant -> To.Asttypes.Covariant\n | From.Asttypes.Contravariant -> To.Asttypes.Contravariant\n | From.Asttypes.Invariant -> To.Asttypes.Invariant\n\nand copy_value_description :\n From.Parsetree.value_description -> To.Parsetree.value_description =\n fun {\n From.Parsetree.pval_name;\n From.Parsetree.pval_type;\n From.Parsetree.pval_prim;\n From.Parsetree.pval_attributes;\n From.Parsetree.pval_loc;\n } ->\n {\n To.Parsetree.pval_name = copy_loc (fun x -> x) pval_name;\n To.Parsetree.pval_type = copy_core_type pval_type;\n To.Parsetree.pval_prim = List.map (fun x -> x) pval_prim;\n To.Parsetree.pval_attributes = copy_attributes pval_attributes;\n To.Parsetree.pval_loc = copy_location pval_loc;\n }\n\nand copy_arg_label : From.Asttypes.arg_label -> string = function\n | From.Asttypes.Nolabel -> \"\"\n | From.Asttypes.Labelled x0 -> x0\n | From.Asttypes.Optional x0 -> \"?\" ^ x0\n\nand copy_closed_flag : From.Asttypes.closed_flag -> To.Asttypes.closed_flag =\n function\n | From.Asttypes.Closed -> To.Asttypes.Closed\n | From.Asttypes.Open -> To.Asttypes.Open\n\nand copy_label : From.Asttypes.label -> To.Asttypes.label = fun x -> x\n\nand copy_rec_flag : From.Asttypes.rec_flag -> To.Asttypes.rec_flag = function\n | From.Asttypes.Nonrecursive -> To.Asttypes.Nonrecursive\n | From.Asttypes.Recursive -> To.Asttypes.Recursive\n\nand copy_constant loc : From.Parsetree.constant -> To.Asttypes.constant =\n function\n | From.Parsetree.Pconst_integer (x0, x1) -> (\n match x1 with\n | None -> To.Asttypes.Const_int (int_of_string x0)\n | Some 'l' -> To.Asttypes.Const_int32 (Int32.of_string x0)\n | Some 'L' -> To.Asttypes.Const_int64 (Int64.of_string x0)\n | Some 'n' -> To.Asttypes.Const_nativeint (Nativeint.of_string x0)\n | Some _ -> migration_error loc \"custom integer literals\")\n | From.Parsetree.Pconst_char x0 -> To.Asttypes.Const_char x0\n | From.Parsetree.Pconst_string (x0, x1) -> To.Asttypes.Const_string (x0, x1)\n | From.Parsetree.Pconst_float (x0, x1) -> (\n match x1 with\n | None -> To.Asttypes.Const_float x0\n | Some _ -> migration_error loc \"custom float literals\")\n\nand copy_option : 'f0 'g0. ('f0 -> 'g0) -> 'f0 option -> 'g0 option =\n fun f0 -> function None -> None | Some x0 -> Some (f0 x0)\n\nand copy_longident : Longident.t -> Longident.t = fun x -> x\n\nand copy_loc :\n 'f0 'g0. ('f0 -> 'g0) -> 'f0 From.Asttypes.loc -> 'g0 To.Asttypes.loc =\n fun f0 { From.Asttypes.txt; From.Asttypes.loc } ->\n { To.Asttypes.txt = f0 txt; To.Asttypes.loc = copy_location loc }\n\nand copy_location : Location.t -> Location.t = fun x -> x\nand copy_bool : bool -> bool = function false -> false | true -> true\n\nand type_declarations recflag types =\n match (recflag, List.map copy_type_declaration types) with\n | From.Asttypes.Recursive, types -> types\n | From.Asttypes.Nonrecursive, [] -> []\n | From.Asttypes.Nonrecursive, x :: xs ->\n let pos =\n {\n Lexing.pos_fname = \"_none_\";\n pos_lnum = 1;\n pos_bol = 0;\n pos_cnum = -1;\n }\n in\n let loc = { Location.loc_start = pos; loc_end = pos; loc_ghost = true } in\n let ptype_attributes =\n ({ To.Asttypes.txt = \"nonrec\"; loc }, To.Parsetree.PStr [])\n :: x.To.Parsetree.ptype_attributes\n in\n { x with To.Parsetree.ptype_attributes } :: xs\n\nlet rec copy_toplevel_phrase :\n From.Parsetree.toplevel_phrase -> To.Parsetree.toplevel_phrase = function\n | From.Parsetree.Ptop_def x0 -> To.Parsetree.Ptop_def (copy_structure x0)\n | From.Parsetree.Ptop_dir (x0, x1) ->\n To.Parsetree.Ptop_dir (x0, copy_directive_argument x1)\n\nand copy_directive_argument :\n From.Parsetree.directive_argument -> To.Parsetree.directive_argument =\n function\n | From.Parsetree.Pdir_none -> To.Parsetree.Pdir_none\n | From.Parsetree.Pdir_string x0 -> To.Parsetree.Pdir_string x0\n | From.Parsetree.Pdir_int (x0, _x1) ->\n To.Parsetree.Pdir_int (int_of_string x0)\n | From.Parsetree.Pdir_ident x0 -> To.Parsetree.Pdir_ident (copy_longident x0)\n | From.Parsetree.Pdir_bool x0 -> To.Parsetree.Pdir_bool (copy_bool x0)\n\nlet copy_cases x = List.map copy_case x\nlet copy_pat = copy_pattern\nlet copy_expr = copy_expression\nlet copy_typ = copy_core_type\n","(**************************************************************************)\n(* *)\n(* OCaml Migrate Parsetree *)\n(* *)\n(* Frédéric Bour *)\n(* Jérémie Dimino, Jane Street Europe *)\n(* *)\n(* Copyright 2017 Institut National de Recherche en Informatique et *)\n(* en Automatique (INRIA). *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* BEGIN of BLACK MAGIC *)\n(*$ open Ast_cinaps_helpers $*)\n\ntype _ witnesses = ..\n\ntype _ migration = ..\ntype _ migration += Undefined : _ migration\n\ntype 'a migration_info = {\n mutable next_version : 'a migration;\n mutable previous_version : 'a migration;\n}\n\n(** Abstract view of a version of an OCaml Ast *)\nmodule type Ast = sig\n (*$ foreach_module (fun m types ->\n printf \" module %s : sig\\n\" m;\n List.iter types ~f:(printf \" type %s\\n\");\n printf \" end\\n\"\n )\n *)\n module Parsetree : sig\n type structure\n type signature\n type toplevel_phrase\n type core_type\n type expression\n type pattern\n type case\n type type_declaration\n type type_extension\n type extension_constructor\n end\n(*$*)\n module Config : sig\n val ast_impl_magic_number : string\n val ast_intf_magic_number : string\n end\nend\n\n(* Shortcuts for talking about ast types outside of the module language *)\n\ntype 'a _types = 'a constraint 'a\n = <\n (*$ foreach_type (fun _ s -> printf \" %-21s : _;\\n\" s) *)\n structure : _;\n signature : _;\n toplevel_phrase : _;\n core_type : _;\n expression : _;\n pattern : _;\n case : _;\n type_declaration : _;\n type_extension : _;\n extension_constructor : _;\n(*$*)\n >\n;;\n\n(*$ foreach_type (fun _ s ->\n printf \"type 'a get_%s =\\n\" s;\n printf \" 'x constraint 'a _types = < %s : 'x; .. >\\n\" s\n ) *)\ntype 'a get_structure =\n 'x constraint 'a _types = < structure : 'x; .. >\ntype 'a get_signature =\n 'x constraint 'a _types = < signature : 'x; .. >\ntype 'a get_toplevel_phrase =\n 'x constraint 'a _types = < toplevel_phrase : 'x; .. >\ntype 'a get_core_type =\n 'x constraint 'a _types = < core_type : 'x; .. >\ntype 'a get_expression =\n 'x constraint 'a _types = < expression : 'x; .. >\ntype 'a get_pattern =\n 'x constraint 'a _types = < pattern : 'x; .. >\ntype 'a get_case =\n 'x constraint 'a _types = < case : 'x; .. >\ntype 'a get_type_declaration =\n 'x constraint 'a _types = < type_declaration : 'x; .. >\ntype 'a get_type_extension =\n 'x constraint 'a _types = < type_extension : 'x; .. >\ntype 'a get_extension_constructor =\n 'x constraint 'a _types = < extension_constructor : 'x; .. >\n(*$*)\n\nmodule type OCaml_version = sig\n module Ast : Ast\n val version : int\n val string_version : string\n type types = <\n (*$ foreach_type (fun m s -> printf \" %-21s : Ast.%s.%s;\\n\" s m s)*)\n structure : Ast.Parsetree.structure;\n signature : Ast.Parsetree.signature;\n toplevel_phrase : Ast.Parsetree.toplevel_phrase;\n core_type : Ast.Parsetree.core_type;\n expression : Ast.Parsetree.expression;\n pattern : Ast.Parsetree.pattern;\n case : Ast.Parsetree.case;\n type_declaration : Ast.Parsetree.type_declaration;\n type_extension : Ast.Parsetree.type_extension;\n extension_constructor : Ast.Parsetree.extension_constructor;\n(*$*)\n > _types\n type _ witnesses += Version : types witnesses\n val migration_info : types migration_info\nend\n\nmodule Make_witness(Ast : Ast) =\nstruct\n type types = <\n (*$ foreach_type (fun m s -> printf \" %-21s : Ast.%s.%s;\\n\" s m s)*)\n structure : Ast.Parsetree.structure;\n signature : Ast.Parsetree.signature;\n toplevel_phrase : Ast.Parsetree.toplevel_phrase;\n core_type : Ast.Parsetree.core_type;\n expression : Ast.Parsetree.expression;\n pattern : Ast.Parsetree.pattern;\n case : Ast.Parsetree.case;\n type_declaration : Ast.Parsetree.type_declaration;\n type_extension : Ast.Parsetree.type_extension;\n extension_constructor : Ast.Parsetree.extension_constructor;\n(*$*)\n > _types\n type _ witnesses += Version : types witnesses\n let migration_info : types migration_info =\n { next_version = Undefined; previous_version = Undefined }\nend\n\ntype 'types ocaml_version =\n (module OCaml_version\n (*$ let sep = with_then_and () in\n foreach_type (fun m s ->\n printf \" %t type Ast.%s.%s = 'types get_%s\\n\" sep m s s) *)\n with type Ast.Parsetree.structure = 'types get_structure\n and type Ast.Parsetree.signature = 'types get_signature\n and type Ast.Parsetree.toplevel_phrase = 'types get_toplevel_phrase\n and type Ast.Parsetree.core_type = 'types get_core_type\n and type Ast.Parsetree.expression = 'types get_expression\n and type Ast.Parsetree.pattern = 'types get_pattern\n and type Ast.Parsetree.case = 'types get_case\n and type Ast.Parsetree.type_declaration = 'types get_type_declaration\n and type Ast.Parsetree.type_extension = 'types get_type_extension\n and type Ast.Parsetree.extension_constructor = 'types get_extension_constructor\n(*$*)\n )\n\ntype ('from, 'to_) migration_functions = {\n (*$ foreach_type (fun _ s ->\n printf \" copy_%s: 'from get_%s -> 'to_ get_%s;\\n\" s s s) *)\n copy_structure: 'from get_structure -> 'to_ get_structure;\n copy_signature: 'from get_signature -> 'to_ get_signature;\n copy_toplevel_phrase: 'from get_toplevel_phrase -> 'to_ get_toplevel_phrase;\n copy_core_type: 'from get_core_type -> 'to_ get_core_type;\n copy_expression: 'from get_expression -> 'to_ get_expression;\n copy_pattern: 'from get_pattern -> 'to_ get_pattern;\n copy_case: 'from get_case -> 'to_ get_case;\n copy_type_declaration: 'from get_type_declaration -> 'to_ get_type_declaration;\n copy_type_extension: 'from get_type_extension -> 'to_ get_type_extension;\n copy_extension_constructor: 'from get_extension_constructor -> 'to_ get_extension_constructor;\n(*$*)\n}\n\nlet id x = x\nlet migration_identity : ('a, 'a) migration_functions = {\n (*$ foreach_type (fun _ s -> printf \" copy_%s = id;\\n\" s) *)\n copy_structure = id;\n copy_signature = id;\n copy_toplevel_phrase = id;\n copy_core_type = id;\n copy_expression = id;\n copy_pattern = id;\n copy_case = id;\n copy_type_declaration = id;\n copy_type_extension = id;\n copy_extension_constructor = id;\n(*$*)\n}\n\nlet compose f g x = f (g x)\nlet migration_compose (ab : ('a, 'b) migration_functions) (bc : ('b, 'c) migration_functions) : ('a, 'c) migration_functions = {\n (*$ foreach_type (fun _ s ->\n printf \" copy_%-21s = compose bc.copy_%-21s ab.copy_%s;\\n\" s s s) *)\n copy_structure = compose bc.copy_structure ab.copy_structure;\n copy_signature = compose bc.copy_signature ab.copy_signature;\n copy_toplevel_phrase = compose bc.copy_toplevel_phrase ab.copy_toplevel_phrase;\n copy_core_type = compose bc.copy_core_type ab.copy_core_type;\n copy_expression = compose bc.copy_expression ab.copy_expression;\n copy_pattern = compose bc.copy_pattern ab.copy_pattern;\n copy_case = compose bc.copy_case ab.copy_case;\n copy_type_declaration = compose bc.copy_type_declaration ab.copy_type_declaration;\n copy_type_extension = compose bc.copy_type_extension ab.copy_type_extension;\n copy_extension_constructor = compose bc.copy_extension_constructor ab.copy_extension_constructor;\n(*$*)\n}\n\ntype _ migration += Migration : 'from ocaml_version * ('from, 'to_) migration_functions * 'to_ ocaml_version -> 'from migration\n\nmodule type Migrate_module = sig\n module From : Ast\n module To : Ast\n (*$ foreach_type (fun m s ->\n printf \" val copy_%-21s: From.%s.%s -> To.%s.%s\\n\" s m s m s) *)\n val copy_structure : From.Parsetree.structure -> To.Parsetree.structure\n val copy_signature : From.Parsetree.signature -> To.Parsetree.signature\n val copy_toplevel_phrase : From.Parsetree.toplevel_phrase -> To.Parsetree.toplevel_phrase\n val copy_core_type : From.Parsetree.core_type -> To.Parsetree.core_type\n val copy_expression : From.Parsetree.expression -> To.Parsetree.expression\n val copy_pattern : From.Parsetree.pattern -> To.Parsetree.pattern\n val copy_case : From.Parsetree.case -> To.Parsetree.case\n val copy_type_declaration : From.Parsetree.type_declaration -> To.Parsetree.type_declaration\n val copy_type_extension : From.Parsetree.type_extension -> To.Parsetree.type_extension\n val copy_extension_constructor: From.Parsetree.extension_constructor -> To.Parsetree.extension_constructor\n(*$*)\nend\n\nmodule Migration_functions\n (A : OCaml_version) (B : OCaml_version)\n (A_to_B : Migrate_module with module From = A.Ast and module To = B.Ast)\n=\nstruct\n let migration_functions : (A.types, B.types) migration_functions =\n let open A_to_B in\n {\n (*$ foreach_type (fun _ s -> printf \" copy_%s;\\n\" s) *)\n copy_structure;\n copy_signature;\n copy_toplevel_phrase;\n copy_core_type;\n copy_expression;\n copy_pattern;\n copy_case;\n copy_type_declaration;\n copy_type_extension;\n copy_extension_constructor;\n(*$*)\n }\nend\n\nmodule Register_migration (A : OCaml_version) (B : OCaml_version)\n (A_to_B : Migrate_module with module From = A.Ast and module To = B.Ast)\n (B_to_A : Migrate_module with module From = B.Ast and module To = A.Ast)\n=\nstruct\n let () = (\n let is_undefined : type a. a migration -> bool = function\n | Undefined -> true\n | _ -> false\n in\n assert (A.version < B.version);\n assert (is_undefined A.migration_info.next_version);\n assert (is_undefined B.migration_info.previous_version);\n let module A_to_B_fun = Migration_functions(A)(B)(A_to_B) in\n let module B_to_A_fun = Migration_functions(B)(A)(B_to_A) in\n A.migration_info.next_version <-\n Migration ((module A), A_to_B_fun.migration_functions, (module B));\n B.migration_info.previous_version <-\n Migration ((module B), B_to_A_fun.migration_functions, (module A));\n )\nend\n\ntype 'from immediate_migration =\n | No_migration : 'from immediate_migration\n | Immediate_migration\n : ('from, 'to_) migration_functions * 'to_ ocaml_version\n -> 'from immediate_migration\n\nlet immediate_migration\n (*$ foreach_type (fun _ s -> printf \" (type %s)\\n\" s) *)\n (type structure)\n (type signature)\n (type toplevel_phrase)\n (type core_type)\n (type expression)\n (type pattern)\n (type case)\n (type type_declaration)\n (type type_extension)\n (type extension_constructor)\n(*$*)\n ((module A) : <\n (*$ foreach_type (fun _ s -> printf \" %-21s : %s;\\n\" s s) *)\n structure : structure;\n signature : signature;\n toplevel_phrase : toplevel_phrase;\n core_type : core_type;\n expression : expression;\n pattern : pattern;\n case : case;\n type_declaration : type_declaration;\n type_extension : type_extension;\n extension_constructor : extension_constructor;\n(*$*)\n > ocaml_version)\n direction\n =\n let version = match direction with\n | `Next -> A.migration_info.next_version\n | `Previous -> A.migration_info.previous_version\n in\n match version with\n | Undefined -> No_migration\n | Migration (_, funs, to_) -> Immediate_migration (funs, to_)\n | _ -> assert false\n\nlet migrate\n (*$ foreach_type (fun _ s -> printf \" (type %s1) (type %s2)\\n\" s s) *)\n (type structure1) (type structure2)\n (type signature1) (type signature2)\n (type toplevel_phrase1) (type toplevel_phrase2)\n (type core_type1) (type core_type2)\n (type expression1) (type expression2)\n (type pattern1) (type pattern2)\n (type case1) (type case2)\n (type type_declaration1) (type type_declaration2)\n (type type_extension1) (type type_extension2)\n (type extension_constructor1) (type extension_constructor2)\n(*$*)\n ((module A) : <\n (*$ foreach_type (fun _ s -> printf \" %-21s : %s1;\\n\" s s) *)\n structure : structure1;\n signature : signature1;\n toplevel_phrase : toplevel_phrase1;\n core_type : core_type1;\n expression : expression1;\n pattern : pattern1;\n case : case1;\n type_declaration : type_declaration1;\n type_extension : type_extension1;\n extension_constructor : extension_constructor1;\n(*$*)\n > ocaml_version)\n ((module B) : <\n (*$ foreach_type (fun _ s -> printf \" %-21s : %s2;\\n\" s s) *)\n structure : structure2;\n signature : signature2;\n toplevel_phrase : toplevel_phrase2;\n core_type : core_type2;\n expression : expression2;\n pattern : pattern2;\n case : case2;\n type_declaration : type_declaration2;\n type_extension : type_extension2;\n extension_constructor : extension_constructor2;\n(*$*)\n > ocaml_version)\n : (A.types, B.types) migration_functions\n =\n match A.Version with\n | B.Version -> migration_identity\n | _ ->\n let direction = if A.version < B.version then `Next else `Previous in\n let rec migrate (m : A.types immediate_migration) : (A.types, B.types) migration_functions =\n match m with\n | No_migration -> assert false\n | Immediate_migration (f, (module To)) ->\n match To.Version with\n | B.Version -> f\n | _ ->\n match immediate_migration (module To) direction with\n | No_migration -> assert false\n | Immediate_migration (g, to2) ->\n migrate (Immediate_migration (migration_compose f g, to2))\n in\n migrate (immediate_migration (module A) direction)\n\nmodule Convert (A : OCaml_version) (B : OCaml_version) = struct\n let {\n (*$ foreach_type (fun _ s -> printf \" copy_%s;\\n\" s) *)\n copy_structure;\n copy_signature;\n copy_toplevel_phrase;\n copy_core_type;\n copy_expression;\n copy_pattern;\n copy_case;\n copy_type_declaration;\n copy_type_extension;\n copy_extension_constructor;\n(*$*)\n } : (A.types, B.types) migration_functions =\n migrate (module A) (module B)\nend\n\n(*$ foreach_version (fun n version ->\n printf \"module OCaml_%d = struct\\n\" n;\n printf \" module Ast = Astlib.Ast_%d\\n\" n;\n printf \" include Make_witness(Astlib.Ast_%d)\\n\" n;\n printf \" let version = %d\\n\" n;\n printf \" let string_version = %S\\n\" version;\n printf \"end\\n\";\n printf \"let ocaml_%d : OCaml_%d.types ocaml_version = (module OCaml_%d)\\n\"\n n n n;\n )\n*)\nmodule OCaml_402 = struct\n module Ast = Astlib.Ast_402\n include Make_witness(Astlib.Ast_402)\n let version = 402\n let string_version = \"4.02\"\nend\nlet ocaml_402 : OCaml_402.types ocaml_version = (module OCaml_402)\nmodule OCaml_403 = struct\n module Ast = Astlib.Ast_403\n include Make_witness(Astlib.Ast_403)\n let version = 403\n let string_version = \"4.03\"\nend\nlet ocaml_403 : OCaml_403.types ocaml_version = (module OCaml_403)\nmodule OCaml_404 = struct\n module Ast = Astlib.Ast_404\n include Make_witness(Astlib.Ast_404)\n let version = 404\n let string_version = \"4.04\"\nend\nlet ocaml_404 : OCaml_404.types ocaml_version = (module OCaml_404)\nmodule OCaml_405 = struct\n module Ast = Astlib.Ast_405\n include Make_witness(Astlib.Ast_405)\n let version = 405\n let string_version = \"4.05\"\nend\nlet ocaml_405 : OCaml_405.types ocaml_version = (module OCaml_405)\nmodule OCaml_406 = struct\n module Ast = Astlib.Ast_406\n include Make_witness(Astlib.Ast_406)\n let version = 406\n let string_version = \"4.06\"\nend\nlet ocaml_406 : OCaml_406.types ocaml_version = (module OCaml_406)\nmodule OCaml_407 = struct\n module Ast = Astlib.Ast_407\n include Make_witness(Astlib.Ast_407)\n let version = 407\n let string_version = \"4.07\"\nend\nlet ocaml_407 : OCaml_407.types ocaml_version = (module OCaml_407)\nmodule OCaml_408 = struct\n module Ast = Astlib.Ast_408\n include Make_witness(Astlib.Ast_408)\n let version = 408\n let string_version = \"4.08\"\nend\nlet ocaml_408 : OCaml_408.types ocaml_version = (module OCaml_408)\nmodule OCaml_409 = struct\n module Ast = Astlib.Ast_409\n include Make_witness(Astlib.Ast_409)\n let version = 409\n let string_version = \"4.09\"\nend\nlet ocaml_409 : OCaml_409.types ocaml_version = (module OCaml_409)\nmodule OCaml_410 = struct\n module Ast = Astlib.Ast_410\n include Make_witness(Astlib.Ast_410)\n let version = 410\n let string_version = \"4.10\"\nend\nlet ocaml_410 : OCaml_410.types ocaml_version = (module OCaml_410)\nmodule OCaml_411 = struct\n module Ast = Astlib.Ast_411\n include Make_witness(Astlib.Ast_411)\n let version = 411\n let string_version = \"4.11\"\nend\nlet ocaml_411 : OCaml_411.types ocaml_version = (module OCaml_411)\nmodule OCaml_412 = struct\n module Ast = Astlib.Ast_412\n include Make_witness(Astlib.Ast_412)\n let version = 412\n let string_version = \"4.12\"\nend\nlet ocaml_412 : OCaml_412.types ocaml_version = (module OCaml_412)\nmodule OCaml_413 = struct\n module Ast = Astlib.Ast_413\n include Make_witness(Astlib.Ast_413)\n let version = 413\n let string_version = \"4.13\"\nend\nlet ocaml_413 : OCaml_413.types ocaml_version = (module OCaml_413)\nmodule OCaml_414 = struct\n module Ast = Astlib.Ast_414\n include Make_witness(Astlib.Ast_414)\n let version = 414\n let string_version = \"4.14\"\nend\nlet ocaml_414 : OCaml_414.types ocaml_version = (module OCaml_414)\n(*$*)\n\nlet all_versions : (module OCaml_version) list = [\n (*$foreach_version (fun n _ ->\n printf \"(module OCaml_%d : OCaml_version);\\n\" n)*)\n(module OCaml_402 : OCaml_version);\n(module OCaml_403 : OCaml_version);\n(module OCaml_404 : OCaml_version);\n(module OCaml_405 : OCaml_version);\n(module OCaml_406 : OCaml_version);\n(module OCaml_407 : OCaml_version);\n(module OCaml_408 : OCaml_version);\n(module OCaml_409 : OCaml_version);\n(module OCaml_410 : OCaml_version);\n(module OCaml_411 : OCaml_version);\n(module OCaml_412 : OCaml_version);\n(module OCaml_413 : OCaml_version);\n(module OCaml_414 : OCaml_version);\n(*$*)\n]\n\n(*$foreach_version_pair (fun a b ->\n printf \"include Register_migration(OCaml_%d)(OCaml_%d)\\n\" a b;\n printf \" (Astlib.Migrate_%d_%d)(Astlib.Migrate_%d_%d)\\n\" a b b a\n )\n*)\ninclude Register_migration(OCaml_402)(OCaml_403)\n (Astlib.Migrate_402_403)(Astlib.Migrate_403_402)\ninclude Register_migration(OCaml_403)(OCaml_404)\n (Astlib.Migrate_403_404)(Astlib.Migrate_404_403)\ninclude Register_migration(OCaml_404)(OCaml_405)\n (Astlib.Migrate_404_405)(Astlib.Migrate_405_404)\ninclude Register_migration(OCaml_405)(OCaml_406)\n (Astlib.Migrate_405_406)(Astlib.Migrate_406_405)\ninclude Register_migration(OCaml_406)(OCaml_407)\n (Astlib.Migrate_406_407)(Astlib.Migrate_407_406)\ninclude Register_migration(OCaml_407)(OCaml_408)\n (Astlib.Migrate_407_408)(Astlib.Migrate_408_407)\ninclude Register_migration(OCaml_408)(OCaml_409)\n (Astlib.Migrate_408_409)(Astlib.Migrate_409_408)\ninclude Register_migration(OCaml_409)(OCaml_410)\n (Astlib.Migrate_409_410)(Astlib.Migrate_410_409)\ninclude Register_migration(OCaml_410)(OCaml_411)\n (Astlib.Migrate_410_411)(Astlib.Migrate_411_410)\ninclude Register_migration(OCaml_411)(OCaml_412)\n (Astlib.Migrate_411_412)(Astlib.Migrate_412_411)\ninclude Register_migration(OCaml_412)(OCaml_413)\n (Astlib.Migrate_412_413)(Astlib.Migrate_413_412)\ninclude Register_migration(OCaml_413)(OCaml_414)\n (Astlib.Migrate_413_414)(Astlib.Migrate_414_413)\n(*$*)\n\nmodule OCaml_current = OCaml_OCAML_VERSION\n\nmodule Find_version = struct\n type t = Impl of (module OCaml_version) | Intf of (module OCaml_version) | Unknown\n\n let from_magic magic =\n let rec loop = function\n | [] -> Unknown\n | (module Version : OCaml_version) :: tail ->\n if Version.Ast.Config.ast_impl_magic_number = magic then\n Impl (module Version)\n else if Version.Ast.Config.ast_intf_magic_number = magic then\n Intf (module Version)\n else\n loop tail\n in\n loop all_versions\nend\n","module Caml = Stdlib\nopen Caml\nopen StdLabels\nmodule Sexp = Sexplib0.Sexp\nmodule Sexpable = Sexplib0.Sexpable\ninclude Sexplib0.Sexp_conv\n\nmodule type Comparisons = sig\n type t\n\n val compare : t -> t -> int\n val equal : t -> t -> bool\n val ( = ) : t -> t -> bool\n val ( < ) : t -> t -> bool\n val ( > ) : t -> t -> bool\n val ( <> ) : t -> t -> bool\n val ( <= ) : t -> t -> bool\n val ( >= ) : t -> t -> bool\n val min : t -> t -> t\n val max : t -> t -> t\nend\n\nmodule Poly = struct\n let compare = compare\n let equal = ( = )\n let ( = ) = ( = )\n let ( < ) = ( < )\n let ( > ) = ( > )\n let ( <> ) = ( <> )\n let ( <= ) = ( <= )\n let ( >= ) = ( >= )\n let min = min\n let max = max\nend\n\ninclude (Poly : Comparisons with type t := int)\nmodule Array = Array\n\nmodule Bool = struct\n let to_string = string_of_bool\n\n include (Poly : Comparisons with type t := bool)\nend\n\nmodule Bytes = struct\n include Bytes\n\n let sub_string t ~pos ~len = Stdlib.Bytes.sub_string t pos len\n\n let blit_string ~src ~src_pos ~dst ~dst_pos ~len =\n Stdlib.Bytes.blit_string src src_pos dst dst_pos len\nend\n\nmodule Char = struct\n include Char\n include (Poly : Comparisons with type t := char)\nend\n\nmodule Exn = struct\n let protectx x ~f ~finally =\n match f x with\n | y ->\n finally x;\n y\n | exception exn ->\n finally x;\n raise exn\nend\n\nmodule Float = struct\n let to_string = string_of_float\n\n include (Poly : Comparisons with type t := float)\nend\n\nmodule Fn = struct\n let id x = x\nend\n\nmodule Hashtbl = struct\n include Hashtbl\n\n let set t ~key ~data =\n while mem t key do\n remove t key\n done;\n add t key data\n\n let add t ~key ~data =\n if mem t key then Error (Invalid_argument \"Hashtbl.add_exn\")\n else (\n add t key data;\n Ok ())\n\n let add_exn t ~key ~data =\n match add t ~key ~data with Ok () -> () | Error exn -> raise exn\n\n let find_opt t key =\n match find t key with data -> Some data | exception Not_found -> None\n\n let find_or_add t key ~default =\n match find_opt t key with\n | Some data -> data\n | None ->\n let data = default () in\n add_exn t ~key ~data;\n data\n\n let rec add_alist t alist =\n match alist with\n | [] -> Ok ()\n | (key, data) :: tail -> (\n match add t ~key ~data with\n | Ok () -> add_alist t tail\n | Error (_ : exn) -> Error key)\n\n let of_alist ?size alist =\n let size =\n match size with Some size -> size | None -> List.length alist\n in\n let t = create size in\n match add_alist t alist with Ok () -> Ok t | Error _ as error -> error\n\n let of_alist_exn ?size alist =\n match of_alist ?size alist with\n | Ok t -> t\n | Error _ -> raise (Invalid_argument \"Hashtbl.of_alist_exn\")\nend\n\nmodule In_channel = struct\n let create ?(binary = true) file =\n let flags = [ Open_rdonly ] in\n let flags = if binary then Open_binary :: flags else flags in\n open_in_gen flags 0o000 file\n\n let with_file ?binary filename ~f =\n let t = create ?binary filename in\n Exn.protectx t ~f ~finally:close_in\n\n let input_all t =\n let rec read_all_into t buf =\n match input_char t with\n | char ->\n Buffer.add_char buf char;\n read_all_into t buf\n | exception End_of_file -> ()\n in\n let buf = Buffer.create 64 in\n read_all_into t buf;\n Buffer.contents buf\n\n let read_all filename = with_file filename ~f:input_all\nend\n\nmodule Int = struct\n let max_int = max_int\n let to_string = string_of_int\n\n include (Poly : Comparisons with type t := int)\nend\n\nmodule List = struct\n include List\n\n include struct\n (* shadow non-tail-recursive functions *)\n let merge = `not_tail_recursive\n let remove_assoc = `not_tail_recursive\n let remove_assq = `not_tail_recursive\n\n let rev_mapi list ~f =\n let rec rev_mapi_at list i ~f ~acc =\n match list with\n | [] -> acc\n | head :: tail -> rev_mapi_at tail (i + 1) ~f ~acc:(f i head :: acc)\n in\n rev_mapi_at list 0 ~f ~acc:[]\n\n let fold_right2 list1 list2 ~init ~f =\n fold_left2 (rev list1) (rev list2) ~init ~f:(fun acc x y -> f x y acc)\n\n let map list ~f = rev (rev_map list ~f)\n let mapi list ~f = rev (rev_mapi list ~f)\n\n let fold_right list ~init ~f =\n fold_left (List.rev list) ~init ~f:(fun acc x -> f x acc)\n\n let append x y = rev_append (rev x) y\n let concat list = fold_right list ~init:[] ~f:append\n\n let rev_combine list1 list2 =\n fold_left2 list1 list2 ~init:[] ~f:(fun acc x y -> (x, y) :: acc)\n\n let combine list1 list2 = rev (rev_combine list1 list2)\n\n let split list =\n fold_right list ~init:([], []) ~f:(fun (x, y) (xs, ys) ->\n (x :: xs, y :: ys))\n\n let map2 list1 list2 ~f =\n rev (fold_left2 list1 list2 ~init:[] ~f:(fun acc x y -> f x y :: acc))\n end\n\n let init ~len ~f =\n let rec loop ~len ~pos ~f ~acc =\n if pos >= len then List.rev acc\n else loop ~len ~pos:(pos + 1) ~f ~acc:(f pos :: acc)\n in\n loop ~len ~pos:0 ~f ~acc:[]\n\n let is_empty = function [] -> true | _ :: _ -> false\n\n let rev_filter_opt list =\n fold_left list ~init:[] ~f:(fun tail option ->\n match option with None -> tail | Some head -> head :: tail)\n\n let filter_opt list = rev (rev_filter_opt list)\n let filter_map list ~f = rev_filter_opt (rev_map list ~f)\n let concat_map list ~f = concat (map list ~f)\n\n let rec find_map list ~f =\n match list with\n | [] -> None\n | head :: tail -> (\n match f head with Some _ as some -> some | None -> find_map tail ~f)\n\n let find_map_exn list ~f =\n match find_map list ~f with Some x -> x | None -> raise Not_found\n\n let rec last = function\n | [] -> None\n | [ x ] -> Some x\n | _ :: (_ :: _ as rest) -> last rest\n\n let split_while list ~f =\n let rec split_while_into list ~f ~acc =\n match list with\n | head :: tail when f head -> split_while_into tail ~f ~acc:(head :: acc)\n | _ :: _ | [] -> (List.rev acc, list)\n in\n split_while_into list ~f ~acc:[]\n\n let find_a_dup (type elt) list ~compare =\n let module Elt = struct\n type t = elt\n\n let compare = compare\n end in\n let module Elt_set = Set.Make (Elt) in\n let rec find_a_dup_in list ~set =\n match list with\n | [] -> None\n | head :: tail ->\n if Elt_set.mem head set then Some head\n else find_a_dup_in tail ~set:(Elt_set.add head set)\n in\n find_a_dup_in list ~set:Elt_set.empty\n\n let assoc_opt key alist =\n match assoc key alist with x -> Some x | exception Not_found -> None\n\n (* reorders arguments to improve type inference *)\n let iter list ~f = iter list ~f\nend\n\nmodule Option = struct\n let is_some = function None -> false | Some _ -> true\n let iter t ~f = match t with None -> () | Some x -> f x\n let map t ~f = match t with None -> None | Some x -> Some (f x)\n let value t ~default = match t with None -> default | Some x -> x\nend\n\nmodule Out_channel = struct\n let create ?(binary = true) ?(append = false) ?(fail_if_exists = false)\n ?(perm = 0o666) file =\n let flags = [ Open_wronly; Open_creat ] in\n let flags = (if binary then Open_binary else Open_text) :: flags in\n let flags = (if append then Open_append else Open_trunc) :: flags in\n let flags = if fail_if_exists then Open_excl :: flags else flags in\n open_out_gen flags perm file\n\n let with_file ?binary ?append ?fail_if_exists ?perm file ~f =\n let t = create ?binary ?append ?fail_if_exists ?perm file in\n Exn.protectx t ~f ~finally:close_out\n\n let write_all filename ~data =\n with_file filename ~f:(fun t -> output_string t data)\nend\n\nmodule String = struct\n include String\n\n let is_empty (t : t) = length t = 0\n let prefix t len = sub t ~pos:0 ~len\n let suffix t len = sub t ~pos:(length t - len) ~len\n let drop_prefix t len = sub t ~pos:len ~len:(length t - len)\n let drop_suffix t len = sub t ~pos:0 ~len:(length t - len)\n\n let is_prefix t ~prefix =\n let rec is_prefix_from t ~prefix ~pos ~len =\n pos >= len\n || Char.equal (get t pos) (get prefix pos)\n && is_prefix_from t ~prefix ~pos:(pos + 1) ~len\n in\n length t >= length prefix\n && is_prefix_from t ~prefix ~pos:0 ~len:(length prefix)\n\n let is_suffix t ~suffix =\n let rec is_suffix_up_to t ~suffix ~pos ~suffix_offset =\n pos < 0\n || Char.equal (get t (suffix_offset + pos)) (get suffix pos)\n && is_suffix_up_to t ~suffix ~pos:(pos - 1) ~suffix_offset\n in\n length t >= length suffix\n && is_suffix_up_to t ~suffix\n ~pos:(length suffix - 1)\n ~suffix_offset:(length t - length suffix)\n\n let exists t ~f =\n let rec exists_at t ~f ~pos ~len =\n pos < len && (f (get t pos) || exists_at t ~f ~pos:(pos + 1) ~len)\n in\n exists_at t ~f ~pos:0 ~len:(length t)\n\n let for_all t ~f =\n let rec for_all_at t ~f ~pos ~len =\n pos >= len || (f (get t pos) && for_all_at t ~f ~pos:(pos + 1) ~len)\n in\n for_all_at t ~f ~pos:0 ~len:(length t)\n\n let index_opt t char =\n match index t char with i -> Some i | exception Not_found -> None\n\n let rindex_opt t char =\n match rindex t char with i -> Some i | exception Not_found -> None\n\n let index_from_opt t char pos =\n match index_from t char pos with i -> Some i | exception Not_found -> None\n\n let rindex_from_opt t char pos =\n match rindex_from t char pos with\n | i -> Some i\n | exception Not_found -> None\n\n let lsplit2 t ~on =\n match index_opt t on with\n | None -> None\n | Some i ->\n Some (sub t ~pos:0 ~len:i, sub t ~pos:(i + 1) ~len:(length t - i - 1))\n\n let capitalize_ascii = Stdlib.String.capitalize_ascii\n let lowercase_ascii = Stdlib.String.lowercase_ascii\n let uncapitalize_ascii = Stdlib.String.uncapitalize_ascii\n let split_on_char t ~sep = Stdlib.String.split_on_char sep t\n\n include (Poly : Comparisons with type t := string)\n\n module Map = struct\n include Map.Make (String)\n\n let find_opt key t =\n match find key t with x -> Some x | exception Not_found -> None\n end\n\n module Set = Set.Make (String)\nend\n\nlet ( @ ) = List.append\nlet output oc bytes ~pos ~len = output oc bytes pos len\nlet output_substring oc string ~pos ~len = output_substring oc string pos len\n","open! Import\nmodule Format = Caml.Format\n\nlet fold_dot_suffixes name ~init:acc ~f =\n let rec collapse_after_at = function\n | [] -> []\n | part :: parts ->\n if (not (String.is_empty part)) && Char.equal part.[0] '@' then\n [ String.concat (String.drop_prefix part 1 :: parts) ~sep:\".\" ]\n else part :: collapse_after_at parts\n in\n let rec loop acc parts =\n match parts with\n | [] -> acc\n | part :: parts ->\n loop (f (String.concat (part :: parts) ~sep:\".\") acc) parts\n in\n String.split_on_char name ~sep:'.' |> collapse_after_at |> loop acc\n\nlet dot_suffixes name =\n fold_dot_suffixes name ~init:[] ~f:(fun x acc -> x :: acc)\n\nlet split_path =\n let rec loop s i =\n if i = String.length s then (s, None)\n else match s.[i] with '.' -> after_dot s (i + 1) | _ -> loop s (i + 1)\n and after_dot s i =\n if i = String.length s then (s, None)\n else\n match s.[i] with\n | 'A' .. 'Z' -> (String.prefix s (i - 1), Some (String.drop_prefix s i))\n | '.' -> after_dot s (i + 1)\n | _ -> loop s (i + 1)\n in\n fun s -> loop s 0\n\nmodule Pattern = struct\n type t = { name : string; dot_suffixes : String.Set.t }\n\n let make name =\n { name; dot_suffixes = String.Set.of_list (dot_suffixes name) }\n\n let name t = t.name\n let matches t matched = String.Set.mem matched t.dot_suffixes\nend\n\nlet get_outer_namespace name =\n match String.index_opt name '.' with\n | None -> None\n | Some i -> Some (String.sub name ~pos:0 ~len:i)\n\nmodule Whitelisted = struct\n (* White list the following attributes, as well as all their dot suffixes.\n\n Since these attributes are interpreted by the compiler itself, we cannot check\n at the level of a ppx rewriter that they have been properly interpreted, so\n we just accept them anywhere.\n\n Sadly, the compiler silently ignores them if they are misplaced...\n *)\n let create_set fully_qualified_names =\n List.fold_left\n ~f:(fun acc name ->\n fold_dot_suffixes name ~init:acc ~f:(fun x acc -> String.Set.add x acc))\n ~init:String.Set.empty fully_qualified_names\n\n let attributes =\n create_set\n [\n \"ocaml.alert\";\n \"ocaml.boxed\";\n \"ocaml.deprecated\";\n \"ocaml.deprecated_mutable\";\n \"ocaml.doc\";\n \"ocaml.extension_constructor\";\n \"ocaml.immediate\";\n \"ocaml.immediate64\";\n \"ocaml.inline\";\n \"ocaml.inlined\";\n \"ocaml.local\";\n \"ocaml.noalloc\";\n \"ocaml.ppwarning\";\n \"ocaml.remove_aliases\";\n \"ocaml.specialise\";\n \"ocaml.specialised\";\n \"ocaml.tailcall\";\n \"ocaml.text\";\n \"ocaml.unboxed\";\n \"ocaml.unroll\";\n \"ocaml.unrolled\";\n \"ocaml.untagged\";\n \"ocaml.warn_on_literal_pattern\";\n \"ocaml.warnerror\";\n \"ocaml.warning\";\n ]\n\n (* White list the following extensions.\n\n Since these extensions are interpreted by the compiler itself, we cannot check\n at the level of a ppx rewriter that they have been properly interpreted, so\n we just accept them anywhere.\n *)\n let extensions = create_set [ \"ocaml.error\"; \"ocaml.extension_constructor\" ]\n\n let is_whitelisted ~kind name =\n match kind with\n | `Attribute -> String.Set.mem name attributes\n | `Extension -> String.Set.mem name extensions\n\n let get_attribute_list () = String.Set.elements attributes\n let get_extension_list () = String.Set.elements extensions\nend\n\nmodule Reserved_namespaces = struct\n let tbl : (string, unit) Hashtbl.t = Hashtbl.create 16\n let reserve ns = Hashtbl.add_exn tbl ~key:ns ~data:()\n let () = reserve \"merlin\"\n let () = reserve \"reason\"\n let () = reserve \"refmt\"\n let () = reserve \"metaocaml\"\n let () = reserve \"ocamlformat\"\n\n let is_in_reserved_namespaces name =\n match get_outer_namespace name with\n | Some ns -> Hashtbl.mem tbl ns\n | None -> Hashtbl.mem tbl name\n\n let check_not_reserved ~kind name =\n let kind, list =\n match kind with\n | `Attribute -> (\"attribute\", Whitelisted.attributes)\n | `Extension -> (\"extension\", Whitelisted.extensions)\n in\n if String.Set.mem name list then\n Printf.ksprintf failwith\n \"Cannot register %s with name '%s' as it matches an %s reserved by the \\\n compiler\"\n kind name kind\n else if is_in_reserved_namespaces name then\n Printf.ksprintf failwith\n \"Cannot register %s with name '%s' as its namespace is marked as \\\n reserved\"\n kind name\nend\n\nlet ignore_checks name =\n Reserved_namespaces.is_in_reserved_namespaces name\n || String.is_prefix name ~prefix:\"_\"\n\nmodule Registrar = struct\n type element = { fully_qualified_name : string; declared_at : Caller_id.t }\n type all_for_context = { mutable all : element String.Map.t }\n\n type 'a t = {\n all_by_context : ('a, all_for_context) Hashtbl.t;\n skip : string list;\n kind : string;\n string_of_context : 'a -> string option;\n }\n\n let create ~kind ~current_file ~string_of_context =\n {\n all_by_context = Hashtbl.create 16;\n skip = [ current_file; __FILE__ ];\n kind;\n string_of_context;\n }\n\n let get_all_for_context t context =\n Hashtbl.find_or_add t.all_by_context context ~default:(fun () ->\n { all = String.Map.empty })\n\n let check_collisions_local ~caller ~all_for_context t context name =\n match String.Map.find_opt name all_for_context.all with\n | None -> ()\n | Some e ->\n let declared_at = function\n | None -> \"\"\n | Some (loc : Caml.Printexc.location) ->\n Printf.sprintf \" declared at %s:%d\" loc.filename loc.line_number\n in\n let context =\n match t.string_of_context context with\n | None -> \"\"\n | Some s -> \" on \" ^ s ^ \"s\"\n in\n Printf.ksprintf failwith\n \"Some ppx-es tried to register conflicting transformations: %s \\\n '%s'%s%s matches %s '%s'%s\"\n (String.capitalize_ascii t.kind)\n name context (declared_at caller) t.kind e.fully_qualified_name\n (declared_at e.declared_at)\n\n let check_collisions t context name =\n let caller = Caller_id.get ~skip:t.skip in\n let all_for_context = get_all_for_context t context in\n check_collisions_local ~caller ~all_for_context t context name\n\n let register ~kind t context name =\n Reserved_namespaces.check_not_reserved ~kind name;\n let caller = Caller_id.get ~skip:t.skip in\n let all = get_all_for_context t context in\n check_collisions_local ~caller ~all_for_context:all t context name;\n let t = { fully_qualified_name = name; declared_at = caller } in\n all.all <-\n fold_dot_suffixes name ~init:all.all ~f:(fun name acc ->\n String.Map.add name t acc)\n\n let spellcheck t context ?(white_list = []) name =\n let all =\n let all = get_all_for_context t context in\n String.Map.fold (fun key _ acc -> key :: acc) all.all []\n in\n match Spellcheck.spellcheck (all @ white_list) name with\n | Some _ as x -> x\n | None -> (\n let other_contexts =\n Hashtbl.fold\n (fun ctx { all } acc ->\n if Poly.( <> ) context ctx && String.Map.mem name all then\n match t.string_of_context ctx with\n | None -> acc\n | Some s -> (s ^ \"s\") :: acc\n else acc)\n t.all_by_context []\n in\n let pp_text = Format.pp_print_text in\n let current_context ppf =\n match t.string_of_context context with\n | None | Some \"\" -> ()\n | Some s ->\n let a_or_an =\n match s.[0] with\n | 'a' | 'e' | 'i' | 'o' | 'u' | 'y' -> \"an\"\n | _ -> \"a\"\n in\n Format.fprintf ppf\n \"@ but@ is@ used@ here@ in@ the@ context@ of@ %s@ %a\" a_or_an\n pp_text s\n in\n match\n List.sort ~cmp:(fun x y -> -String.compare x y) other_contexts\n with\n | [] -> None\n | [ c ] ->\n Some\n (Format.asprintf\n \"@[Hint:@ `%s'@ is@ available@ for@ %a%t.@]@\\n\\\n Did you put it at the wrong level?\" name pp_text c\n current_context)\n | last :: rev_others ->\n let others = List.rev rev_others in\n Some\n (Format.asprintf\n \"@[Hint:@ `%s'@ is@ available@ for@ %a@ and@ %a%t.@]@\\n\\\n Did you put it at the wrong level?\" name\n (Format.pp_print_list pp_text ~pp_sep:(fun ppf () ->\n Format.fprintf ppf \",@ \"))\n others pp_text last current_context))\n\n (* TODO: hint spelling errors regarding reserved namespaces names and white\n listed names instead of taking an optional [white_list] parameter. *)\n let raise_errorf t context ?white_list fmt (name : string Loc.t) =\n Printf.ksprintf\n (fun msg ->\n match spellcheck t context name.txt ?white_list with\n | None -> Location.raise_errorf ~loc:name.loc \"%s\" msg\n | Some s -> Location.raise_errorf ~loc:name.loc \"%s.\\n%s\" msg s)\n fmt name.txt\nend\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Jerome Vouillon, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 2002 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nopen Obj\n\n(**** Object representation ****)\n\nexternal set_id: 'a -> 'a = \"caml_set_oo_id\" [@@noalloc]\n\n(**** Object copy ****)\n\nlet copy o =\n let o = (Obj.obj (Obj.dup (Obj.repr o))) in\n set_id o\n\n(**** Compression options ****)\n(* Parameters *)\ntype params = {\n mutable compact_table : bool;\n mutable copy_parent : bool;\n mutable clean_when_copying : bool;\n mutable retry_count : int;\n mutable bucket_small_size : int\n }\n\nlet params = {\n compact_table = true;\n copy_parent = true;\n clean_when_copying = true;\n retry_count = 3;\n bucket_small_size = 16\n}\n\n(**** Parameters ****)\n\nlet initial_object_size = 2\n\n(**** Items ****)\n\ntype item = DummyA | DummyB | DummyC of int\nlet _ = [DummyA; DummyB; DummyC 0] (* to avoid warnings *)\n\nlet dummy_item = (magic () : item)\n\n(**** Types ****)\n\ntype tag\ntype label = int\ntype closure = item\ntype t = DummyA | DummyB | DummyC of int\nlet _ = [DummyA; DummyB; DummyC 0] (* to avoid warnings *)\n\ntype obj = t array\nexternal ret : (obj -> 'a) -> closure = \"%identity\"\n\n(**** Labels ****)\n\nlet public_method_label s : tag =\n let accu = ref 0 in\n for i = 0 to String.length s - 1 do\n accu := 223 * !accu + Char.code s.[i]\n done;\n (* reduce to 31 bits *)\n accu := !accu land (1 lsl 31 - 1);\n (* make it signed for 64 bits architectures *)\n let tag = if !accu > 0x3FFFFFFF then !accu - (1 lsl 31) else !accu in\n (* Printf.eprintf \"%s = %d\\n\" s tag; flush stderr; *)\n magic tag\n\n(**** Sparse array ****)\n\nmodule Vars =\n Map.Make(struct type t = string let compare (x:t) y = compare x y end)\ntype vars = int Vars.t\n\nmodule Meths =\n Map.Make(struct type t = string let compare (x:t) y = compare x y end)\ntype meths = label Meths.t\nmodule Labs =\n Map.Make(struct type t = label let compare (x:t) y = compare x y end)\ntype labs = bool Labs.t\n\n(* The compiler assumes that the first field of this structure is [size]. *)\ntype table =\n { mutable size: int;\n mutable methods: closure array;\n mutable methods_by_name: meths;\n mutable methods_by_label: labs;\n mutable previous_states:\n (meths * labs * (label * item) list * vars *\n label list * string list) list;\n mutable hidden_meths: (label * item) list;\n mutable vars: vars;\n mutable initializers: (obj -> unit) list }\n\nlet dummy_table =\n { methods = [| dummy_item |];\n methods_by_name = Meths.empty;\n methods_by_label = Labs.empty;\n previous_states = [];\n hidden_meths = [];\n vars = Vars.empty;\n initializers = [];\n size = 0 }\n\nlet table_count = ref 0\n\n(* dummy_met should be a pointer, so use an atom *)\nlet dummy_met : item = obj (Obj.new_block 0 0)\n(* if debugging is needed, this could be a good idea: *)\n(* let dummy_met () = failwith \"Undefined method\" *)\n\nlet rec fit_size n =\n if n <= 2 then n else\n fit_size ((n+1)/2) * 2\n\nlet new_table pub_labels =\n incr table_count;\n let len = Array.length pub_labels in\n let methods = Array.make (len*2+2) dummy_met in\n methods.(0) <- magic len;\n methods.(1) <- magic (fit_size len * Sys.word_size / 8 - 1);\n for i = 0 to len - 1 do methods.(i*2+3) <- magic pub_labels.(i) done;\n { methods = methods;\n methods_by_name = Meths.empty;\n methods_by_label = Labs.empty;\n previous_states = [];\n hidden_meths = [];\n vars = Vars.empty;\n initializers = [];\n size = initial_object_size }\n\nlet resize array new_size =\n let old_size = Array.length array.methods in\n if new_size > old_size then begin\n let new_buck = Array.make new_size dummy_met in\n Array.blit array.methods 0 new_buck 0 old_size;\n array.methods <- new_buck\n end\n\nlet put array label element =\n resize array (label + 1);\n array.methods.(label) <- element\n\n(**** Classes ****)\n\nlet method_count = ref 0\nlet inst_var_count = ref 0\n\n(* type t *)\ntype meth = item\n\nlet new_method table =\n let index = Array.length table.methods in\n resize table (index + 1);\n index\n\nlet get_method_label table name =\n try\n Meths.find name table.methods_by_name\n with Not_found ->\n let label = new_method table in\n table.methods_by_name <- Meths.add name label table.methods_by_name;\n table.methods_by_label <- Labs.add label true table.methods_by_label;\n label\n\nlet get_method_labels table names =\n Array.map (get_method_label table) names\n\nlet set_method table label element =\n incr method_count;\n if Labs.find label table.methods_by_label then\n put table label element\n else\n table.hidden_meths <- (label, element) :: table.hidden_meths\n\nlet get_method table label =\n try List.assoc label table.hidden_meths\n with Not_found -> table.methods.(label)\n\nlet to_list arr =\n if arr == magic 0 then [] else Array.to_list arr\n\nlet narrow table vars virt_meths concr_meths =\n let vars = to_list vars\n and virt_meths = to_list virt_meths\n and concr_meths = to_list concr_meths in\n let virt_meth_labs = List.map (get_method_label table) virt_meths in\n let concr_meth_labs = List.map (get_method_label table) concr_meths in\n table.previous_states <-\n (table.methods_by_name, table.methods_by_label, table.hidden_meths,\n table.vars, virt_meth_labs, vars)\n :: table.previous_states;\n table.vars <-\n Vars.fold\n (fun lab info tvars ->\n if List.mem lab vars then Vars.add lab info tvars else tvars)\n table.vars Vars.empty;\n let by_name = ref Meths.empty in\n let by_label = ref Labs.empty in\n List.iter2\n (fun met label ->\n by_name := Meths.add met label !by_name;\n by_label :=\n Labs.add label\n (try Labs.find label table.methods_by_label with Not_found -> true)\n !by_label)\n concr_meths concr_meth_labs;\n List.iter2\n (fun met label ->\n by_name := Meths.add met label !by_name;\n by_label := Labs.add label false !by_label)\n virt_meths virt_meth_labs;\n table.methods_by_name <- !by_name;\n table.methods_by_label <- !by_label;\n table.hidden_meths <-\n List.fold_right\n (fun ((lab, _) as met) hm ->\n if List.mem lab virt_meth_labs then hm else met::hm)\n table.hidden_meths\n []\n\nlet widen table =\n let (by_name, by_label, saved_hidden_meths, saved_vars, virt_meths, vars) =\n List.hd table.previous_states\n in\n table.previous_states <- List.tl table.previous_states;\n table.vars <-\n List.fold_left\n (fun s v -> Vars.add v (Vars.find v table.vars) s)\n saved_vars vars;\n table.methods_by_name <- by_name;\n table.methods_by_label <- by_label;\n table.hidden_meths <-\n List.fold_right\n (fun ((lab, _) as met) hm ->\n if List.mem lab virt_meths then hm else met::hm)\n table.hidden_meths\n saved_hidden_meths\n\nlet new_slot table =\n let index = table.size in\n table.size <- index + 1;\n index\n\nlet new_variable table name =\n try Vars.find name table.vars\n with Not_found ->\n let index = new_slot table in\n if name <> \"\" then table.vars <- Vars.add name index table.vars;\n index\n\nlet to_array arr =\n if arr = Obj.magic 0 then [||] else arr\n\nlet new_methods_variables table meths vals =\n let meths = to_array meths in\n let nmeths = Array.length meths and nvals = Array.length vals in\n let res = Array.make (nmeths + nvals) 0 in\n for i = 0 to nmeths - 1 do\n res.(i) <- get_method_label table meths.(i)\n done;\n for i = 0 to nvals - 1 do\n res.(i+nmeths) <- new_variable table vals.(i)\n done;\n res\n\nlet get_variable table name =\n try Vars.find name table.vars with Not_found -> assert false\n\nlet get_variables table names =\n Array.map (get_variable table) names\n\nlet add_initializer table f =\n table.initializers <- f::table.initializers\n\n(*\nmodule Keys =\n Map.Make(struct type t = tag array let compare (x:t) y = compare x y end)\nlet key_map = ref Keys.empty\nlet get_key tags : item =\n try magic (Keys.find tags !key_map : tag array)\n with Not_found ->\n key_map := Keys.add tags tags !key_map;\n magic tags\n*)\n\nlet create_table public_methods =\n if public_methods == magic 0 then new_table [||] else\n (* [public_methods] must be in ascending order for bytecode *)\n let tags = Array.map public_method_label public_methods in\n let table = new_table tags in\n Array.iteri\n (fun i met ->\n let lab = i*2+2 in\n table.methods_by_name <- Meths.add met lab table.methods_by_name;\n table.methods_by_label <- Labs.add lab true table.methods_by_label)\n public_methods;\n table\n\nlet init_class table =\n inst_var_count := !inst_var_count + table.size - 1;\n table.initializers <- List.rev table.initializers;\n resize table (3 + magic table.methods.(1) * 16 / Sys.word_size)\n\nlet inherits cla vals virt_meths concr_meths (_, super, _, env) top =\n narrow cla vals virt_meths concr_meths;\n let init =\n if top then super cla env else Obj.repr (super cla) in\n widen cla;\n Array.concat\n [[| repr init |];\n magic (Array.map (get_variable cla) (to_array vals) : int array);\n Array.map\n (fun nm -> repr (get_method cla (get_method_label cla nm) : closure))\n (to_array concr_meths) ]\n\nlet make_class pub_meths class_init =\n let table = create_table pub_meths in\n let env_init = class_init table in\n init_class table;\n (env_init (Obj.repr 0), class_init, env_init, Obj.repr 0)\n\ntype init_table = { mutable env_init: t; mutable class_init: table -> t }\n[@@warning \"-unused-field\"]\n\nlet make_class_store pub_meths class_init init_table =\n let table = create_table pub_meths in\n let env_init = class_init table in\n init_class table;\n init_table.class_init <- class_init;\n init_table.env_init <- env_init\n\nlet dummy_class loc =\n let undef = fun _ -> raise (Undefined_recursive_module loc) in\n (Obj.magic undef, undef, undef, Obj.repr 0)\n\n(**** Objects ****)\n\nlet create_object table =\n (* XXX Appel de [obj_block] | Call to [obj_block] *)\n let obj = Obj.new_block Obj.object_tag table.size in\n (* XXX Appel de [caml_modify] | Call to [caml_modify] *)\n Obj.set_field obj 0 (Obj.repr table.methods);\n Obj.obj (set_id obj)\n\nlet create_object_opt obj_0 table =\n if (Obj.magic obj_0 : bool) then obj_0 else begin\n (* XXX Appel de [obj_block] | Call to [obj_block] *)\n let obj = Obj.new_block Obj.object_tag table.size in\n (* XXX Appel de [caml_modify] | Call to [caml_modify] *)\n Obj.set_field obj 0 (Obj.repr table.methods);\n Obj.obj (set_id obj)\n end\n\nlet rec iter_f obj =\n function\n [] -> ()\n | f::l -> f obj; iter_f obj l\n\nlet run_initializers obj table =\n let inits = table.initializers in\n if inits <> [] then\n iter_f obj inits\n\nlet run_initializers_opt obj_0 obj table =\n if (Obj.magic obj_0 : bool) then obj else begin\n let inits = table.initializers in\n if inits <> [] then iter_f obj inits;\n obj\n end\n\nlet create_object_and_run_initializers obj_0 table =\n if (Obj.magic obj_0 : bool) then obj_0 else begin\n let obj = create_object table in\n run_initializers obj table;\n obj\n end\n\n(* Equivalent primitive below\nlet sendself obj lab =\n (magic obj : (obj -> t) array array).(0).(lab) obj\n*)\nexternal send : obj -> tag -> 'a = \"%send\"\nexternal sendcache : obj -> tag -> t -> int -> 'a = \"%sendcache\"\nexternal sendself : obj -> label -> 'a = \"%sendself\"\nexternal get_public_method : obj -> tag -> closure\n = \"caml_get_public_method\" [@@noalloc]\n\n(**** table collection access ****)\n\ntype tables =\n | Empty\n | Cons of {key : closure; mutable data: tables; mutable next: tables}\n\nlet set_data tables v = match tables with\n | Empty -> assert false\n | Cons tables -> tables.data <- v\nlet set_next tables v = match tables with\n | Empty -> assert false\n | Cons tables -> tables.next <- v\nlet get_key = function\n | Empty -> assert false\n | Cons tables -> tables.key\nlet get_data = function\n | Empty -> assert false\n | Cons tables -> tables.data\nlet get_next = function\n | Empty -> assert false\n | Cons tables -> tables.next\n\nlet build_path n keys tables =\n let res = Cons {key = Obj.magic 0; data = Empty; next = Empty} in\n let r = ref res in\n for i = 0 to n do\n r := Cons {key = keys.(i); data = !r; next = Empty}\n done;\n set_data tables !r;\n res\n\nlet rec lookup_keys i keys tables =\n if i < 0 then tables else\n let key = keys.(i) in\n let rec lookup_key (tables:tables) =\n if get_key tables == key then\n match get_data tables with\n | Empty -> assert false\n | Cons _ as tables_data ->\n lookup_keys (i-1) keys tables_data\n else\n match get_next tables with\n | Cons _ as next -> lookup_key next\n | Empty ->\n let next : tables = Cons {key; data = Empty; next = Empty} in\n set_next tables next;\n build_path (i-1) keys next\n in\n lookup_key tables\n\nlet lookup_tables root keys =\n match get_data root with\n | Cons _ as root_data ->\n lookup_keys (Array.length keys - 1) keys root_data\n | Empty ->\n build_path (Array.length keys - 1) keys root\n\n(**** builtin methods ****)\n\nlet get_const x = ret (fun _obj -> x)\nlet get_var n = ret (fun obj -> Array.unsafe_get obj n)\nlet get_env e n =\n ret (fun obj ->\n Array.unsafe_get (Obj.magic (Array.unsafe_get obj e) : obj) n)\nlet get_meth n = ret (fun obj -> sendself obj n)\nlet set_var n = ret (fun obj x -> Array.unsafe_set obj n x)\nlet app_const f x = ret (fun _obj -> f x)\nlet app_var f n = ret (fun obj -> f (Array.unsafe_get obj n))\nlet app_env f e n =\n ret (fun obj ->\n f (Array.unsafe_get (Obj.magic (Array.unsafe_get obj e) : obj) n))\nlet app_meth f n = ret (fun obj -> f (sendself obj n))\nlet app_const_const f x y = ret (fun _obj -> f x y)\nlet app_const_var f x n = ret (fun obj -> f x (Array.unsafe_get obj n))\nlet app_const_meth f x n = ret (fun obj -> f x (sendself obj n))\nlet app_var_const f n x = ret (fun obj -> f (Array.unsafe_get obj n) x)\nlet app_meth_const f n x = ret (fun obj -> f (sendself obj n) x)\nlet app_const_env f x e n =\n ret (fun obj ->\n f x (Array.unsafe_get (Obj.magic (Array.unsafe_get obj e) : obj) n))\nlet app_env_const f e n x =\n ret (fun obj ->\n f (Array.unsafe_get (Obj.magic (Array.unsafe_get obj e) : obj) n) x)\nlet meth_app_const n x = ret (fun obj -> (sendself obj n : _ -> _) x)\nlet meth_app_var n m =\n ret (fun obj -> (sendself obj n : _ -> _) (Array.unsafe_get obj m))\nlet meth_app_env n e m =\n ret (fun obj -> (sendself obj n : _ -> _)\n (Array.unsafe_get (Obj.magic (Array.unsafe_get obj e) : obj) m))\nlet meth_app_meth n m =\n ret (fun obj -> (sendself obj n : _ -> _) (sendself obj m))\nlet send_const m x c =\n ret (fun obj -> sendcache x m (Array.unsafe_get obj 0) c)\nlet send_var m n c =\n ret (fun obj ->\n sendcache (Obj.magic (Array.unsafe_get obj n) : obj) m\n (Array.unsafe_get obj 0) c)\nlet send_env m e n c =\n ret (fun obj ->\n sendcache\n (Obj.magic (Array.unsafe_get\n (Obj.magic (Array.unsafe_get obj e) : obj) n) : obj)\n m (Array.unsafe_get obj 0) c)\nlet send_meth m n c =\n ret (fun obj ->\n sendcache (sendself obj n) m (Array.unsafe_get obj 0) c)\nlet new_cache table =\n let n = new_method table in\n let n =\n if n mod 2 = 0 || n > 2 + magic table.methods.(1) * 16 / Sys.word_size\n then n else new_method table\n in\n table.methods.(n) <- Obj.magic 0;\n n\n\ntype impl =\n GetConst\n | GetVar\n | GetEnv\n | GetMeth\n | SetVar\n | AppConst\n | AppVar\n | AppEnv\n | AppMeth\n | AppConstConst\n | AppConstVar\n | AppConstEnv\n | AppConstMeth\n | AppVarConst\n | AppEnvConst\n | AppMethConst\n | MethAppConst\n | MethAppVar\n | MethAppEnv\n | MethAppMeth\n | SendConst\n | SendVar\n | SendEnv\n | SendMeth\n | Closure of closure\n\nlet method_impl table i arr =\n let next () = incr i; magic arr.(!i) in\n match next() with\n GetConst -> let x : t = next() in get_const x\n | GetVar -> let n = next() in get_var n\n | GetEnv -> let e = next() in let n = next() in get_env e n\n | GetMeth -> let n = next() in get_meth n\n | SetVar -> let n = next() in set_var n\n | AppConst -> let f = next() in let x = next() in app_const f x\n | AppVar -> let f = next() in let n = next () in app_var f n\n | AppEnv ->\n let f = next() in let e = next() in let n = next() in\n app_env f e n\n | AppMeth -> let f = next() in let n = next () in app_meth f n\n | AppConstConst ->\n let f = next() in let x = next() in let y = next() in\n app_const_const f x y\n | AppConstVar ->\n let f = next() in let x = next() in let n = next() in\n app_const_var f x n\n | AppConstEnv ->\n let f = next() in let x = next() in let e = next () in let n = next() in\n app_const_env f x e n\n | AppConstMeth ->\n let f = next() in let x = next() in let n = next() in\n app_const_meth f x n\n | AppVarConst ->\n let f = next() in let n = next() in let x = next() in\n app_var_const f n x\n | AppEnvConst ->\n let f = next() in let e = next () in let n = next() in let x = next() in\n app_env_const f e n x\n | AppMethConst ->\n let f = next() in let n = next() in let x = next() in\n app_meth_const f n x\n | MethAppConst ->\n let n = next() in let x = next() in meth_app_const n x\n | MethAppVar ->\n let n = next() in let m = next() in meth_app_var n m\n | MethAppEnv ->\n let n = next() in let e = next() in let m = next() in\n meth_app_env n e m\n | MethAppMeth ->\n let n = next() in let m = next() in meth_app_meth n m\n | SendConst ->\n let m = next() in let x = next() in send_const m x (new_cache table)\n | SendVar ->\n let m = next() in let n = next () in send_var m n (new_cache table)\n | SendEnv ->\n let m = next() in let e = next() in let n = next() in\n send_env m e n (new_cache table)\n | SendMeth ->\n let m = next() in let n = next () in send_meth m n (new_cache table)\n | Closure _ as clo -> magic clo\n\nlet set_methods table methods =\n let len = Array.length methods in let i = ref 0 in\n while !i < len do\n let label = methods.(!i) in let clo = method_impl table i methods in\n set_method table label clo;\n incr i\n done\n\n(**** Statistics ****)\n\ntype stats =\n { classes: int; methods: int; inst_vars: int; }\n\nlet stats () =\n { classes = !table_count;\n methods = !method_count; inst_vars = !inst_var_count; }\n","open Import\nopen Ast_builder.Default\n\n(* [do_insert_unused_warning_attribute] -- If true, generated code\n contains compiler attribute to disable unused warnings, instead of\n inserting [let _ = ... ]. *)\nlet do_insert_unused_warning_attribute = ref false\nlet keep_w32_impl = ref false\nlet keep_w32_intf = ref false\n\nlet () =\n let keep_w32_spec =\n Caml.Arg.Symbol\n ( [ \"impl\"; \"intf\"; \"both\" ],\n function\n | \"impl\" -> keep_w32_impl := true\n | \"intf\" -> keep_w32_intf := true\n | \"both\" ->\n keep_w32_impl := true;\n keep_w32_intf := true\n | _ -> assert false )\n in\n let conv_w32_spec =\n Caml.Arg.Symbol\n ( [ \"code\"; \"attribute\" ],\n function\n | \"code\" -> do_insert_unused_warning_attribute := false\n | \"attribute\" -> do_insert_unused_warning_attribute := true\n | _ -> assert false )\n in\n Driver.add_arg \"-deriving-keep-w32\" keep_w32_spec\n ~doc:\" Do not try to disable warning 32 for the generated code\";\n Driver.add_arg \"-deriving-disable-w32-method\" conv_w32_spec\n ~doc:\" How to disable warning 32 for the generated code\";\n Driver.add_arg \"-type-conv-keep-w32\" keep_w32_spec\n ~doc:\" Deprecated, use -deriving-keep-w32\";\n Driver.add_arg \"-type-conv-w32\" conv_w32_spec\n ~doc:\" Deprecated, use -deriving-disable-w32-method\"\n\nlet keep_w32_impl () = !keep_w32_impl || Driver.pretty ()\nlet keep_w32_intf () = !keep_w32_intf || Driver.pretty ()\nlet keep_w60_impl = ref false\nlet keep_w60_intf = ref false\n\nlet () =\n let keep_w60_spec =\n Caml.Arg.Symbol\n ( [ \"impl\"; \"intf\"; \"both\" ],\n function\n | \"impl\" -> keep_w60_impl := true\n | \"intf\" -> keep_w60_intf := true\n | \"both\" ->\n keep_w60_impl := true;\n keep_w60_intf := true\n | _ -> assert false )\n in\n Driver.add_arg \"-deriving-keep-w60\" keep_w60_spec\n ~doc:\" Do not try to disable warning 60 for the generated code\"\n\nlet keep_w60_impl () = !keep_w60_impl || Driver.pretty ()\nlet keep_w60_intf () = !keep_w60_intf || Driver.pretty ()\n\nmodule Args = struct\n include (\n Ast_pattern :\n module type of struct\n include Ast_pattern\n end\n with type ('a, 'b, 'c) t := ('a, 'b, 'c) Ast_pattern.t)\n\n type 'a param = {\n name : string;\n pattern : (expression, 'a) Ast_pattern.Packed.t;\n default : 'a;\n }\n\n let arg name pattern =\n {\n name;\n default = None;\n pattern = Ast_pattern.Packed.create pattern (fun x -> Some x);\n }\n\n let flag name =\n let pattern = pexp_ident (lident (string name)) in\n { name; default = false; pattern = Ast_pattern.Packed.create pattern true }\n\n type (_, _) t =\n | Nil : ('m, 'm) t\n | Cons : ('m1, 'a -> 'm2) t * 'a param -> ('m1, 'm2) t\n\n let empty = Nil\n let ( +> ) a b = Cons (a, b)\n\n let rec names : type a b. (a, b) t -> string list = function\n | Nil -> []\n | Cons (t, p) -> p.name :: names t\n\n module Instance = struct\n type (_, _) instance =\n | I_nil : ('m, 'm) instance\n | I_cons : ('m1, 'a -> 'm2) instance * 'a -> ('m1, 'm2) instance\n\n let rec create :\n type a b. (a, b) t -> (string * expression) list -> (a, b) instance =\n fun spec args ->\n match spec with\n | Nil -> I_nil\n | Cons (t, p) ->\n let value =\n match List.assoc_opt p.name args with\n | None -> p.default\n | Some expr -> Ast_pattern.Packed.parse p.pattern expr.pexp_loc expr\n in\n I_cons (create t args, value)\n\n let rec apply : type a b. (a, b) instance -> a -> b =\n fun t f -> match t with I_nil -> f | I_cons (t, x) -> apply t f x\n end\n\n let apply t args f = Instance.apply (Instance.create t args) f\nend\n\n(* +-----------------------------------------------------------------+\n | Generators |\n +-----------------------------------------------------------------+ *)\n\ntype t = string\n\nlet ignore (_ : t) = ()\n\ntype parsed_args =\n | Args of (string * expression) list\n | Unknown_syntax of Location.t * string\n\nmodule Generator = struct\n type deriver = t\n\n type ('a, 'b) t =\n | T : {\n spec : ('c, 'a) Args.t;\n gen : ctxt:Expansion_context.Deriver.t -> 'b -> 'c;\n arg_names : String.Set.t;\n attributes : Attribute.packed list;\n deps : deriver list;\n }\n -> ('a, 'b) t\n\n let deps (T t) = t.deps\n\n module V2 = struct\n let make ?(attributes = []) ?(deps = []) spec gen =\n let arg_names = String.Set.of_list (Args.names spec) in\n T { spec; gen; arg_names; attributes; deps }\n\n let make_noarg ?attributes ?deps gen = make ?attributes ?deps Args.empty gen\n end\n\n let make ?attributes ?deps spec gen =\n V2.make ?attributes ?deps spec\n (Expansion_context.Deriver.with_loc_and_path gen)\n\n let make_noarg ?attributes ?deps gen = make ?attributes ?deps Args.empty gen\n\n let merge_accepted_args l =\n let rec loop acc = function\n | [] -> acc\n | T t :: rest -> loop (String.Set.union acc t.arg_names) rest\n in\n loop String.Set.empty l\n\n let check_arguments name generators (args : (string * expression) list) =\n List.iter args ~f:(fun (label, e) ->\n if String.is_empty label then\n Location.raise_errorf ~loc:e.pexp_loc\n \"Ppxlib.Deriving: generator arguments must be labelled\");\n Option.iter\n (List.find_a_dup args ~compare:(fun (a, _) (b, _) -> String.compare a b))\n ~f:(fun (label, e) ->\n Location.raise_errorf ~loc:e.pexp_loc\n \"Ppxlib.Deriving: argument labelled '%s' appears more than once\" label);\n let accepted_args = merge_accepted_args generators in\n List.iter args ~f:(fun (label, e) ->\n if not (String.Set.mem label accepted_args) then\n let spellcheck_msg =\n match\n Spellcheck.spellcheck (String.Set.elements accepted_args) label\n with\n | None -> \"\"\n | Some s -> \".\\n\" ^ s\n in\n Location.raise_errorf ~loc:e.pexp_loc\n \"Ppxlib.Deriving: generator '%s' doesn't accept argument '%s'%s\"\n name label spellcheck_msg)\n\n let apply (T t) ~name:_ ~ctxt x args = Args.apply t.spec args (t.gen ~ctxt x)\n\n let apply_all ~ctxt entry (name, generators, args) =\n check_arguments name.txt generators args;\n List.concat_map generators ~f:(fun t ->\n apply t ~name:name.txt ~ctxt entry args)\n\n let apply_all ~ctxt entry generators =\n List.concat_map generators ~f:(apply_all ~ctxt entry)\nend\n\nmodule Deriver = struct\n module Actual_deriver = struct\n type t = {\n name : string;\n str_type_decl :\n (structure, rec_flag * type_declaration list) Generator.t option;\n str_type_ext : (structure, type_extension) Generator.t option;\n str_exception : (structure, type_exception) Generator.t option;\n str_module_type_decl :\n (structure, module_type_declaration) Generator.t option;\n sig_type_decl :\n (signature, rec_flag * type_declaration list) Generator.t option;\n sig_type_ext : (signature, type_extension) Generator.t option;\n sig_exception : (signature, type_exception) Generator.t option;\n sig_module_type_decl :\n (signature, module_type_declaration) Generator.t option;\n extension :\n (loc:Location.t -> path:string -> core_type -> expression) option;\n }\n end\n\n module Alias = struct\n type t = {\n str_type_decl : string list;\n str_type_ext : string list;\n str_exception : string list;\n str_module_type_decl : string list;\n sig_type_decl : string list;\n sig_type_ext : string list;\n sig_exception : string list;\n sig_module_type_decl : string list;\n }\n end\n\n module Field = struct\n type kind = Str | Sig\n\n type ('a, 'b) t = {\n name : string;\n kind : kind;\n get : Actual_deriver.t -> ('a, 'b) Generator.t option;\n get_set : Alias.t -> string list;\n }\n\n let str_type_decl =\n {\n kind = Str;\n name = \"type\";\n get = (fun t -> t.str_type_decl);\n get_set = (fun t -> t.str_type_decl);\n }\n\n let str_type_ext =\n {\n kind = Str;\n name = \"type extension\";\n get = (fun t -> t.str_type_ext);\n get_set = (fun t -> t.str_type_ext);\n }\n\n let str_exception =\n {\n kind = Str;\n name = \"exception\";\n get = (fun t -> t.str_exception);\n get_set = (fun t -> t.str_exception);\n }\n\n let str_module_type_decl =\n {\n kind = Str;\n name = \"module type\";\n get = (fun t -> t.str_module_type_decl);\n get_set = (fun t -> t.str_module_type_decl);\n }\n\n let sig_type_decl =\n {\n kind = Sig;\n name = \"signature type\";\n get = (fun t -> t.sig_type_decl);\n get_set = (fun t -> t.sig_type_decl);\n }\n\n let sig_type_ext =\n {\n kind = Sig;\n name = \"signature type extension\";\n get = (fun t -> t.sig_type_ext);\n get_set = (fun t -> t.sig_type_ext);\n }\n\n let sig_exception =\n {\n kind = Sig;\n name = \"signature exception\";\n get = (fun t -> t.sig_exception);\n get_set = (fun t -> t.sig_exception);\n }\n\n let sig_module_type_decl =\n {\n kind = Sig;\n name = \"signature module type\";\n get = (fun t -> t.sig_module_type_decl);\n get_set = (fun t -> t.sig_module_type_decl);\n }\n end\n\n type t = Actual_deriver of Actual_deriver.t | Alias of Alias.t\n type Ppx_derivers.deriver += T of t\n\n let derivers () =\n List.filter_map (Ppx_derivers.derivers ()) ~f:(function\n | name, T t -> Some (name, t)\n | _ -> None)\n\n exception Not_supported of string\n\n let resolve_actual_derivers (field : (_, _) Field.t) name =\n let rec loop name collected =\n if\n List.exists collected ~f:(fun (d : Actual_deriver.t) ->\n String.equal d.name name)\n then collected\n else\n match Ppx_derivers.lookup name with\n | Some (T (Actual_deriver drv)) -> drv :: collected\n | Some (T (Alias alias)) ->\n let set = field.get_set alias in\n List.fold_right set ~init:collected ~f:loop\n | _ -> raise (Not_supported name)\n in\n List.rev (loop name [])\n\n let resolve_internal (field : (_, _) Field.t) name =\n List.map (resolve_actual_derivers field name) ~f:(fun drv ->\n match field.get drv with\n | None -> raise (Not_supported name)\n | Some g -> (drv.name, g))\n\n let supported_for field =\n List.fold_left (derivers ()) ~init:String.Set.empty ~f:(fun acc (name, _) ->\n match resolve_internal field name with\n | _ -> String.Set.add name acc\n | exception Not_supported _ -> acc)\n |> String.Set.elements\n\n let not_supported (field : (_, _) Field.t) ?(spellcheck = true) name =\n let spellcheck_msg =\n if spellcheck then\n match Spellcheck.spellcheck (supported_for field) name.txt with\n | None -> \"\"\n | Some s -> \".\\n\" ^ s\n else \"\"\n in\n Location.raise_errorf ~loc:name.loc\n \"Ppxlib.Deriving: '%s' is not a supported %s deriving generator%s\"\n name.txt field.name spellcheck_msg\n\n let resolve field name =\n try resolve_internal field name.txt\n with Not_supported name' ->\n not_supported field ~spellcheck:(String.equal name.txt name') name\n\n let resolve_all field derivers =\n let derivers_and_args =\n List.filter_map derivers ~f:(fun (name, args) ->\n match Ppx_derivers.lookup name.txt with\n | None -> not_supported field name\n | Some (T _) ->\n (* It's one of ours, parse the arguments now. We can't do it before since\n ppx_deriving uses a different syntax for arguments. *)\n Some\n ( name,\n match args with\n | Args l -> l\n | Unknown_syntax (loc, msg) ->\n Location.raise_errorf ~loc \"Ppxlib.Deriving: %s\" msg )\n | Some _ ->\n (* It's not one of ours, ignore it. *)\n None)\n in\n (* Set of actual deriver names *)\n let seen = Hashtbl.create 16 in\n List.map derivers_and_args ~f:(fun (name, args) ->\n let named_generators = resolve field name in\n List.iter named_generators ~f:(fun (actual_deriver_name, gen) ->\n if\n Options.fail_on_duplicate_derivers\n && Hashtbl.mem seen actual_deriver_name\n then\n Location.raise_errorf ~loc:name.loc \"Deriver %s appears twice\"\n actual_deriver_name;\n List.iter (Generator.deps gen) ~f:(fun dep ->\n List.iter (resolve_actual_derivers field dep) ~f:(fun drv ->\n let dep_name = drv.name in\n if not (Hashtbl.mem seen dep_name) then\n Location.raise_errorf ~loc:name.loc\n \"Deriver %s is needed for %s, you need to add it \\\n before in the list\"\n dep_name name.txt));\n Hashtbl.set seen ~key:actual_deriver_name ~data:());\n (name, List.map named_generators ~f:snd, args))\n\n let add ?str_type_decl ?str_type_ext ?str_exception ?str_module_type_decl\n ?sig_type_decl ?sig_type_ext ?sig_exception ?sig_module_type_decl\n ?extension name =\n let actual_deriver : Actual_deriver.t =\n {\n name;\n str_type_decl;\n str_type_ext;\n str_exception;\n str_module_type_decl;\n sig_type_decl;\n sig_type_ext;\n sig_exception;\n sig_module_type_decl;\n extension;\n }\n in\n Ppx_derivers.register name (T (Actual_deriver actual_deriver));\n (match extension with\n | None -> ()\n | Some f ->\n let extension =\n Extension.declare name Expression Ast_pattern.(ptyp __) f\n in\n Driver.register_transformation\n (\"Ppxlib.Deriving.\" ^ name)\n ~rules:[ Context_free.Rule.extension extension ]);\n name\n\n let add_alias name ?str_type_decl ?str_type_ext ?str_exception\n ?str_module_type_decl ?sig_type_decl ?sig_type_ext ?sig_exception\n ?sig_module_type_decl set =\n let alias : Alias.t =\n let get = function None -> set | Some set -> set in\n {\n str_type_decl = get str_type_decl;\n str_type_ext = get str_type_ext;\n str_exception = get str_exception;\n str_module_type_decl = get str_module_type_decl;\n sig_type_decl = get sig_type_decl;\n sig_type_ext = get sig_type_ext;\n sig_exception = get sig_exception;\n sig_module_type_decl = get sig_module_type_decl;\n }\n in\n Ppx_derivers.register name (T (Alias alias));\n name\nend\n\nlet add = Deriver.add\nlet add_alias = Deriver.add_alias\n\n(* +-----------------------------------------------------------------+\n | [@@deriving ] parsing |\n +-----------------------------------------------------------------+ *)\n\nlet invalid_with ~loc =\n Location.raise_errorf ~loc \"invalid [@@deriving ] attribute syntax\"\n\nlet generator_name_of_id loc id =\n match Longident.flatten_exn id with\n | l -> { loc; txt = String.concat ~sep:\".\" l }\n | exception _ -> invalid_with ~loc\n\nexception Unknown_syntax of Location.t * string\n\nlet parse_arguments l =\n try\n Args\n (match l with\n | [ (Nolabel, e) ] -> (\n match e.pexp_desc with\n | Pexp_record (fields, None) ->\n List.map fields ~f:(fun (id, expr) ->\n let name =\n match id.txt with\n | Lident s -> s\n | _ ->\n raise_notrace\n (Unknown_syntax (id.loc, \"simple identifier expected\"))\n in\n (name, expr))\n | _ ->\n raise_notrace\n (Unknown_syntax\n ( e.pexp_loc,\n \"non-optional labelled argument or record expected\" )))\n | l ->\n List.map l ~f:(fun (label, expr) ->\n match label with\n | Labelled s -> (s, expr)\n | _ ->\n raise_notrace\n (Unknown_syntax\n (expr.pexp_loc, \"non-optional labelled argument expected\"))))\n with Unknown_syntax (loc, msg) -> Unknown_syntax (loc, msg)\n\nlet mk_deriving_attr context ~prefix ~suffix =\n Attribute.declare\n (prefix ^ \"deriving\" ^ suffix)\n context\n Ast_pattern.(\n let generator_name () =\n map' (pexp_ident __) ~f:(fun loc f id ->\n f (generator_name_of_id loc id))\n in\n let generator () =\n map (generator_name ()) ~f:(fun f x -> f (x, Args []))\n ||| pack2\n (pexp_apply (generator_name ())\n (map1 (many __) ~f:parse_arguments))\n in\n let generators =\n pexp_tuple (many (generator ()))\n ||| map (generator ()) ~f:(fun f x -> f [ x ])\n in\n pstr (pstr_eval generators nil ^:: nil))\n (fun x -> x)\n\n(* +-----------------------------------------------------------------+\n | Unused warning stuff + locations check silencing |\n +-----------------------------------------------------------------+ *)\n\nlet disable_warnings_attribute warnings =\n let loc = Location.none in\n let string =\n List.sort warnings ~cmp:Int.compare\n |> List.map ~f:(fun warning -> \"-\" ^ Int.to_string warning)\n |> String.concat ~sep:\"\"\n in\n {\n attr_name = { txt = \"ocaml.warning\"; loc };\n attr_payload = PStr [ pstr_eval ~loc (estring ~loc string) [] ];\n attr_loc = loc;\n }\n\nlet inline_doc_attr =\n let loc = Location.none in\n {\n attr_name = { txt = \"ocaml.doc\"; loc };\n attr_payload = PStr [ pstr_eval ~loc (estring ~loc \"@inline\") [] ];\n attr_loc = loc;\n }\n\nlet wrap_str ~loc ~hide st =\n let include_infos = include_infos ~loc (pmod_structure ~loc st) in\n let pincl_attributes =\n if hide then [ inline_doc_attr; Merlin_helpers.hide_attribute ]\n else [ inline_doc_attr ]\n in\n [ pstr_include ~loc { include_infos with pincl_attributes } ]\n\nlet wrap_str ~loc ~hide st =\n let loc = { loc with loc_ghost = true } in\n let warnings, st =\n if keep_w32_impl () then ([], st)\n else if not !do_insert_unused_warning_attribute then\n ([], Ignore_unused_warning.add_dummy_user_for_values#structure st)\n else ([ 32 ], st)\n in\n let warnings, st =\n if\n keep_w60_impl ()\n || not (Ignore_unused_warning.binds_module_names#structure st false)\n then (warnings, st)\n else (60 :: warnings, st)\n in\n let wrap, st =\n if List.is_empty warnings then (hide, st)\n else (true, pstr_attribute ~loc (disable_warnings_attribute warnings) :: st)\n in\n if wrap then wrap_str ~loc ~hide st else st\n\nlet wrap_sig ~loc ~hide st =\n let include_infos = include_infos ~loc (pmty_signature ~loc st) in\n let pincl_attributes =\n if hide then [ inline_doc_attr; Merlin_helpers.hide_attribute ]\n else [ inline_doc_attr ]\n in\n [ psig_include ~loc { include_infos with pincl_attributes } ]\n\nlet wrap_sig ~loc ~hide sg =\n let loc = { loc with loc_ghost = true } in\n let warnings = if keep_w32_intf () then [] else [ 32 ] in\n let warnings =\n if\n keep_w60_intf ()\n || not (Ignore_unused_warning.binds_module_names#signature sg false)\n then warnings\n else 60 :: warnings\n in\n let wrap, sg =\n if List.is_empty warnings then (hide, sg)\n else (true, psig_attribute ~loc (disable_warnings_attribute warnings) :: sg)\n in\n if wrap then wrap_sig ~loc ~hide sg else sg\n\n(* +-----------------------------------------------------------------+\n | Remove attributes used by syntax extensions |\n +-----------------------------------------------------------------+ *)\n(*\nlet remove generators =\n let attributes =\n List.concat_map generators ~f:(fun (_, actual_generators, _) ->\n List.concat_map actual_generators ~f:(fun (Generator.T g) -> g.attributes))\n in\n object\n inherit Ast_traverse.map\n\n (* Don't recurse through attributes and extensions *)\n method! attribute x = x\n method! extension x = x\n\n method! label_declaration ld =\n Attribute.remove_seen Attribute.Context.label_declaration attributes ld\n\n method! constructor_declaration cd =\n Attribute.remove_seen Attribute.Context.constructor_declaration attributes cd\n end\n*)\n(* +-----------------------------------------------------------------+\n | Main expansion |\n +-----------------------------------------------------------------+ *)\n\nlet types_used_by_deriving (tds : type_declaration list) : structure_item list =\n if keep_w32_impl () then []\n else\n List.map tds ~f:(fun td ->\n let typ = Common.core_type_of_type_declaration td in\n let loc = td.ptype_loc in\n pstr_value ~loc Nonrecursive\n [\n value_binding ~loc ~pat:(ppat_any ~loc)\n ~expr:\n (pexp_fun ~loc Nolabel None\n (ppat_constraint ~loc (ppat_any ~loc) typ)\n (eunit ~loc));\n ])\n\nlet merge_generators field l =\n List.filter_map l ~f:(fun x -> x) |> List.concat |> Deriver.resolve_all field\n\nlet expand_str_type_decls ~ctxt rec_flag tds values =\n let generators = merge_generators Deriver.Field.str_type_decl values in\n (* TODO: instead of disabling the unused warning for types themselves, we\n should add a tag [@@unused]. *)\n let generated =\n types_used_by_deriving tds\n @ Generator.apply_all ~ctxt (rec_flag, tds) generators\n in\n wrap_str\n ~loc:(Expansion_context.Deriver.derived_item_loc ctxt)\n ~hide:(not @@ Expansion_context.Deriver.inline ctxt)\n generated\n\nlet expand_sig_type_decls ~ctxt rec_flag tds values =\n let generators = merge_generators Deriver.Field.sig_type_decl values in\n let generated = Generator.apply_all ~ctxt (rec_flag, tds) generators in\n wrap_sig\n ~loc:(Expansion_context.Deriver.derived_item_loc ctxt)\n ~hide:(not @@ Expansion_context.Deriver.inline ctxt)\n generated\n\nlet expand_str_module_type_decl ~ctxt mtd generators =\n let generators =\n Deriver.resolve_all Deriver.Field.str_module_type_decl generators\n in\n let generated = Generator.apply_all ~ctxt mtd generators in\n wrap_str\n ~loc:(Expansion_context.Deriver.derived_item_loc ctxt)\n ~hide:(not @@ Expansion_context.Deriver.inline ctxt)\n generated\n\nlet expand_sig_module_type_decl ~ctxt mtd generators =\n let generators =\n Deriver.resolve_all Deriver.Field.sig_module_type_decl generators\n in\n let generated = Generator.apply_all ~ctxt mtd generators in\n wrap_sig\n ~loc:(Expansion_context.Deriver.derived_item_loc ctxt)\n ~hide:(not @@ Expansion_context.Deriver.inline ctxt)\n generated\n\nlet expand_str_exception ~ctxt ec generators =\n let generators = Deriver.resolve_all Deriver.Field.str_exception generators in\n let generated = Generator.apply_all ~ctxt ec generators in\n wrap_str\n ~loc:(Expansion_context.Deriver.derived_item_loc ctxt)\n ~hide:(not @@ Expansion_context.Deriver.inline ctxt)\n generated\n\nlet expand_sig_exception ~ctxt ec generators =\n let generators = Deriver.resolve_all Deriver.Field.sig_exception generators in\n let generated = Generator.apply_all ~ctxt ec generators in\n wrap_sig\n ~loc:(Expansion_context.Deriver.derived_item_loc ctxt)\n ~hide:(not @@ Expansion_context.Deriver.inline ctxt)\n generated\n\nlet expand_str_type_ext ~ctxt te generators =\n let generators = Deriver.resolve_all Deriver.Field.str_type_ext generators in\n let generated = Generator.apply_all ~ctxt te generators in\n wrap_str\n ~loc:(Expansion_context.Deriver.derived_item_loc ctxt)\n ~hide:(not @@ Expansion_context.Deriver.inline ctxt)\n generated\n\nlet expand_sig_type_ext ~ctxt te generators =\n let generators = Deriver.resolve_all Deriver.Field.sig_type_ext generators in\n let generated = Generator.apply_all ~ctxt te generators in\n wrap_sig\n ~loc:(Expansion_context.Deriver.derived_item_loc ctxt)\n ~hide:(not @@ Expansion_context.Deriver.inline ctxt)\n generated\n\nlet rules ~typ ~expand_sig ~expand_str ~rule_str ~rule_sig ~rule_str_expect\n ~rule_sig_expect =\n let prefix = \"ppxlib.\" in\n let deriving_attr = mk_deriving_attr ~suffix:\"\" ~prefix typ in\n let deriving_attr_expect = mk_deriving_attr ~suffix:\"_inline\" ~prefix typ in\n [\n rule_sig deriving_attr expand_sig;\n rule_str deriving_attr expand_str;\n rule_str_expect deriving_attr_expect expand_str;\n rule_sig_expect deriving_attr_expect expand_sig;\n ]\n\nlet rules_type_decl =\n rules ~typ:Type_declaration ~expand_str:expand_str_type_decls\n ~expand_sig:expand_sig_type_decls\n ~rule_str:Context_free.Rule.attr_str_type_decl\n ~rule_sig:Context_free.Rule.attr_sig_type_decl\n ~rule_str_expect:Context_free.Rule.attr_str_type_decl_expect\n ~rule_sig_expect:Context_free.Rule.attr_sig_type_decl_expect\n\nlet rules_type_ext =\n rules ~typ:Type_extension ~expand_str:expand_str_type_ext\n ~expand_sig:expand_sig_type_ext\n ~rule_str:Context_free.Rule.attr_str_type_ext\n ~rule_sig:Context_free.Rule.attr_sig_type_ext\n ~rule_str_expect:Context_free.Rule.attr_str_type_ext_expect\n ~rule_sig_expect:Context_free.Rule.attr_sig_type_ext_expect\n\nlet rules_exception =\n rules ~typ:Type_exception ~expand_str:expand_str_exception\n ~expand_sig:expand_sig_exception\n ~rule_str:Context_free.Rule.attr_str_exception\n ~rule_sig:Context_free.Rule.attr_sig_exception\n ~rule_str_expect:Context_free.Rule.attr_str_exception_expect\n ~rule_sig_expect:Context_free.Rule.attr_sig_exception_expect\n\nlet rules_module_type_decl =\n rules ~typ:Module_type_declaration ~expand_str:expand_str_module_type_decl\n ~expand_sig:expand_sig_module_type_decl\n ~rule_str:Context_free.Rule.attr_str_module_type_decl\n ~rule_sig:Context_free.Rule.attr_sig_module_type_decl\n ~rule_str_expect:Context_free.Rule.attr_str_module_type_decl_expect\n ~rule_sig_expect:Context_free.Rule.attr_sig_module_type_decl_expect\n\nlet () =\n let rules =\n [ rules_type_decl; rules_type_ext; rules_exception; rules_module_type_decl ]\n |> List.concat\n in\n Driver.register_transformation \"deriving\" ~aliases:[ \"type_conv\" ] ~rules\n","open! Import\n\ntype 'a or_raise =\n | Ok of 'a\n | Error of { fail : 'a. loc:location -> 'a }\n\ntype t = (string, expression or_raise, String.comparator_witness) Map.t\n\nlet empty = Map.empty (module String)\n\nlet lookup t ~loc ~tyvar =\n match Map.find t tyvar with\n | Some (Ok expr) -> expr\n | Some (Error { fail }) -> fail ~loc\n | None -> invalid ~loc \"unbound type variable: '%s\" tyvar\n;;\n\nlet of_alist ~loc alist =\n match Map.of_alist (module String) alist with\n | `Ok t -> t\n | `Duplicate_key name -> invalid ~loc \"duplicate type parameter: '%s\" name\n;;\n\nlet create ~loc ~prefix param_list =\n let pat_list, alist =\n List.map param_list ~f:(fun ((core_type, _) as param) ->\n let loc = core_type.ptyp_loc in\n let name = get_type_param_name param in\n let pat, expr = gensym prefix loc in\n pat, (name.txt, Ok expr))\n |> List.unzip\n in\n let t = of_alist ~loc alist in\n pat_list, t\n;;\n\nlet variance_error ~loc ~tyvar ~actual ~expect =\n invalid\n ~loc\n \"misuse of type variable '%s: would confuse %s with %s in generated code; could be \\\n due to a missing or incorrect covariance/contravariance annotation\"\n tyvar\n actual\n expect\n;;\n\nlet create_with_variance ~loc ~covariant ~contravariant param_list =\n let pat_list, by_variance_list =\n List.map param_list ~f:(fun ((core_type, (variance, injectivity)) as param) ->\n let loc = core_type.ptyp_loc in\n let name = get_type_param_name param in\n match (variance, injectivity) with\n | ((NoVariance | Covariant), NoInjectivity) ->\n let pat, expr = gensym covariant loc in\n pat, `Covariant (name.txt, expr)\n | (Contravariant, NoInjectivity) ->\n let pat, expr = gensym contravariant loc in\n pat, `Contravariant (name.txt, expr)\n | (_, Injective) -> Location.raise_errorf ~loc \"Injective type parameters aren't supported.\")\n |> List.unzip\n in\n let covariant_t =\n List.map by_variance_list ~f:(function\n | `Covariant (tyvar, expr) -> tyvar, Ok expr\n | `Contravariant (tyvar, _) ->\n let fail ~loc =\n variance_error ~loc ~tyvar ~expect:covariant ~actual:contravariant\n in\n tyvar, Error { fail })\n |> of_alist ~loc\n in\n let contravariant_t =\n List.map by_variance_list ~f:(function\n | `Contravariant (tyvar, expr) -> tyvar, Ok expr\n | `Covariant (tyvar, _) ->\n let fail ~loc =\n variance_error ~loc ~tyvar ~expect:contravariant ~actual:covariant\n in\n tyvar, Error { fail })\n |> of_alist ~loc\n in\n pat_list, `Covariant covariant_t, `Contravariant contravariant_t\n;;\n","open Core_kernel\n\nmodule Chunked = struct\n (** The input for a random oracle, formed of full field elements and 'chunks'\n of fields that can be combined together into one or more field elements.\n\n The chunks are represented as [(field, length)], where\n [0 <= field < 2^length]. This allows us to efficiently combine values in\n a known range. For example,\n{[\n { field_elements= [||]; packeds= [|(x, 64); (y, 32); (z, 16)|] }\n]}\n results in the chunks being combined as [x * 2^(32+16) + y * 2^(64) + z].\n When the chunks do not fit within a single field element, they are\n greedily concatenated to form field elements, from left to right.\n This packing is performed by the [pack_to_fields] helper function.\n *)\n type 'field t =\n { field_elements : 'field array; packeds : ('field * int) array }\n [@@deriving sexp, compare]\n\n let append (t1 : _ t) (t2 : _ t) =\n { field_elements = Array.append t1.field_elements t2.field_elements\n ; packeds = Array.append t1.packeds t2.packeds\n }\n\n let field_elements (a : 'f array) : 'f t =\n { field_elements = a; packeds = [||] }\n\n let field x : _ t = field_elements [| x |]\n\n (** An input [[|(x_1, l_1); (x_2, l_2); ...|]] includes the values\n [[|x_1; x_2; ...|]] in the input, assuming that `0 <= x_1 < 2^l_1`,\n `0 <= x_2 < 2^l_2`, etc. so that multiple [x_i]s can be combined into a\n single field element when the sum of their [l_i]s are less than the size\n of the field modulus (in bits).\n *)\n let packeds a = { field_elements = [||]; packeds = a }\n\n (** [packed x = packeds [| x |]] *)\n let packed xn : _ t = packeds [| xn |]\n\n module type Field_intf = sig\n type t\n\n val size_in_bits : int\n\n val zero : t\n\n val ( + ) : t -> t -> t\n\n val ( * ) : t -> t -> t\n end\n\n (** Convert the input into a series of field elements, by concatenating\n any chunks of input that fit into a single field element.\n The concatenation is greedy, operating from left to right.\n *)\n let pack_to_fields (type t) (module F : Field_intf with type t = t)\n ~(pow2 : int -> t) { field_elements; packeds } =\n let shift_left acc n = F.( * ) acc (pow2 n) in\n let open F in\n let packed_bits =\n let xs, acc, acc_n =\n Array.fold packeds ~init:([], zero, 0)\n ~f:(fun (xs, acc, acc_n) (x, n) ->\n let n' = Int.(n + acc_n) in\n if Int.(n' < size_in_bits) then (xs, shift_left acc n + x, n')\n else (acc :: xs, x, n) )\n in\n (* if acc_n = 0, packeds was empty (or acc holds 0 bits) and we don't want to append 0 *)\n let xs = if acc_n > 0 then acc :: xs else xs in\n Array.of_list_rev xs\n in\n Array.append field_elements packed_bits\nend\n\nmodule Legacy = struct\n type ('field, 'bool) t =\n { field_elements : 'field array; bitstrings : 'bool list array }\n [@@deriving sexp, compare]\n\n let append t1 t2 =\n { field_elements = Array.append t1.field_elements t2.field_elements\n ; bitstrings = Array.append t1.bitstrings t2.bitstrings\n }\n\n let field_elements x = { field_elements = x; bitstrings = [||] }\n\n let field x = { field_elements = [| x |]; bitstrings = [||] }\n\n let bitstring x = { field_elements = [||]; bitstrings = [| x |] }\n\n let bitstrings x = { field_elements = [||]; bitstrings = x }\n\n let pack_bits ~max_size ~pack { field_elements = _; bitstrings } =\n let rec pack_full_fields rev_fields bits length =\n if length >= max_size then\n let field_bits, bits = List.split_n bits max_size in\n pack_full_fields (pack field_bits :: rev_fields) bits (length - max_size)\n else (rev_fields, bits, length)\n in\n let packed_field_elements, remaining_bits, remaining_length =\n Array.fold bitstrings ~init:([], [], 0)\n ~f:(fun (acc, bits, n) bitstring ->\n let n = n + List.length bitstring in\n let bits = bits @ bitstring in\n let acc, bits, n = pack_full_fields acc bits n in\n (acc, bits, n) )\n in\n if remaining_length = 0 then packed_field_elements\n else pack remaining_bits :: packed_field_elements\n\n let pack_to_fields ~size_in_bits ~pack { field_elements; bitstrings } =\n let max_size = size_in_bits - 1 in\n let packed_bits =\n pack_bits ~max_size ~pack { field_elements; bitstrings }\n in\n Array.append field_elements (Array.of_list_rev packed_bits)\n\n let to_bits ~unpack { field_elements; bitstrings } =\n let field_bits = Array.map ~f:unpack field_elements in\n List.concat @@ Array.to_list @@ Array.append field_bits bitstrings\n\n module Coding = struct\n (** See https://github.com/CodaProtocol/coda/blob/develop/rfcs/0038-rosetta-construction-api.md for details on schema *)\n\n (** Serialize a random oracle input with 32byte fields into bytes according to the RFC0038 specification *)\n let serialize ~string_of_field ~to_bool ~of_bool t =\n let len_to_string x =\n String.of_char_list\n Char.\n [ of_int_exn @@ ((x lsr 24) land 0xff)\n ; of_int_exn @@ ((x lsr 16) land 0xff)\n ; of_int_exn @@ ((x lsr 8) land 0xff)\n ; of_int_exn @@ (x land 0xff)\n ]\n in\n let len1 = len_to_string @@ Array.length t.field_elements in\n let fields =\n (* We only support 32byte fields *)\n let () =\n if Array.length t.field_elements > 0 then\n assert (String.length (string_of_field t.field_elements.(0)) = 32)\n else ()\n in\n Array.map t.field_elements ~f:string_of_field |> String.concat_array\n in\n let len2 =\n len_to_string\n @@ Array.sum (module Int) t.bitstrings ~f:(fun x -> List.length x)\n in\n let packed =\n pack_bits t ~max_size:8 ~pack:(fun bs ->\n let rec go i acc = function\n | [] ->\n acc\n | b :: bs ->\n go (i + 1) ((acc * 2) + if to_bool b then 1 else 0) bs\n in\n let pad =\n List.init (8 - List.length bs) ~f:(Fn.const (of_bool false))\n in\n let combined = bs @ pad in\n assert (List.length combined = 8) ;\n go 0 0 combined )\n |> List.map ~f:Char.of_int_exn\n |> List.rev |> String.of_char_list\n in\n len1 ^ fields ^ len2 ^ packed\n\n module Parser = struct\n (* TODO: Before using this too much; use a solid parser library instead or beef this one up with more debugging info *)\n\n (* The parser is a function over this monad-fail *)\n module M = Result\n\n module T = struct\n type ('a, 'e) t = char list -> ('a * char list, 'e) M.t\n\n let return a cs = M.return (a, cs)\n\n let bind : ('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t =\n fun t ~f cs ->\n let open M.Let_syntax in\n let%bind a, rest = t cs in\n f a rest\n\n let map = `Define_using_bind\n end\n\n include Monad.Make2 (T)\n\n let run p cs =\n p cs\n |> M.bind ~f:(fun (a, cs') ->\n match cs' with [] -> M.return a | _ -> M.fail `Expected_eof )\n\n let fail why _ = M.fail why\n\n let char c = function\n | c' :: cs when Char.equal c c' ->\n M.return (c', cs)\n | c' :: _ ->\n M.fail (`Unexpected_char c')\n | [] ->\n M.fail `Unexpected_eof\n\n let u8 = function\n | c :: cs ->\n M.return (c, cs)\n | [] ->\n M.fail `Unexpected_eof\n\n let u32 =\n let open Let_syntax in\n let open Char in\n let%map a = u8 and b = u8 and c = u8 and d = u8 in\n (to_int a lsl 24)\n lor (to_int b lsl 16)\n lor (to_int c lsl 8)\n lor to_int d\n\n let eof = function [] -> M.return ((), []) | _ -> M.fail `Expected_eof\n\n let take n cs =\n if List.length cs < n then M.fail `Unexpected_eof\n else M.return (List.split_n cs n)\n\n (** p zero or more times, never fails *)\n let many p =\n (fun cs ->\n let rec go xs acc =\n match p xs with\n | Ok (a, xs) ->\n go xs (a :: acc)\n | Error _ ->\n (acc, xs)\n in\n M.return @@ go cs [] )\n |> map ~f:List.rev\n\n let%test_unit \"many\" =\n [%test_eq: (char list, [ `Expected_eof ]) Result.t]\n (run (many u8) [ 'a'; 'b'; 'c' ])\n (Result.return [ 'a'; 'b'; 'c' ])\n\n (** p exactly n times *)\n let exactly n p =\n (fun cs ->\n let rec go xs acc = function\n | 0 ->\n M.return (acc, xs)\n | i ->\n let open M.Let_syntax in\n let%bind a, xs = p xs in\n go xs (a :: acc) (i - 1)\n in\n go cs [] n )\n |> map ~f:List.rev\n\n let%test_unit \"exactly\" =\n [%test_eq:\n (char list * char list, [ `Expected_eof | `Unexpected_eof ]) Result.t]\n ((exactly 3 u8) [ 'a'; 'b'; 'c'; 'd' ])\n (Result.return ([ 'a'; 'b'; 'c' ], [ 'd' ]))\n\n let return_res r cs = r |> Result.map ~f:(fun x -> (x, cs))\n end\n\n let bits_of_byte ~of_bool b =\n let b = Char.to_int b in\n let f x =\n of_bool\n ( match x with\n | 0 ->\n false\n | 1 ->\n true\n | _ ->\n failwith \"Unexpected boolean integer\" )\n in\n [ (b land (0x1 lsl 7)) lsr 7\n ; (b land (0x1 lsl 6)) lsr 6\n ; (b land (0x1 lsl 5)) lsr 5\n ; (b land (0x1 lsl 4)) lsr 4\n ; (b land (0x1 lsl 3)) lsr 3\n ; (b land (0x1 lsl 2)) lsr 2\n ; (b land (0x1 lsl 1)) lsr 1\n ; b land 0x1\n ]\n |> List.map ~f\n\n (** Deserialize bytes into a random oracle input with 32byte fields according to the RFC0038 specification *)\n let deserialize ~field_of_string ~of_bool s =\n let field =\n let open Parser.Let_syntax in\n let%bind u8x32 = Parser.take 32 in\n let s = String.of_char_list u8x32 in\n Parser.return_res (field_of_string s)\n in\n let parser =\n let open Parser.Let_syntax in\n let%bind len1 = Parser.u32 in\n let%bind fields = Parser.exactly len1 field in\n let%bind len2 = Parser.u32 in\n let%map bytes = Parser.(many u8) in\n let bits = List.concat_map ~f:(bits_of_byte ~of_bool) bytes in\n let bitstring = List.take bits len2 in\n { field_elements = Array.of_list fields; bitstrings = [| bitstring |] }\n in\n Parser.run parser s\n\n (** String of field as bits *)\n let string_of_field xs =\n List.chunks_of xs ~length:8\n |> List.map ~f:(fun xs ->\n let rec go i acc = function\n | [] ->\n acc\n | b :: bs ->\n go (i + 1) ((acc * 2) + if b then 1 else 0) bs\n in\n let pad = List.init (8 - List.length xs) ~f:(Fn.const false) in\n let combined = xs @ pad in\n assert (List.length combined = 8) ;\n go 0 0 combined )\n |> List.map ~f:Char.of_int_exn\n |> String.of_char_list\n\n (** Field of string as bits *)\n let field_of_string s ~size_in_bits =\n List.concat_map (String.to_list s) ~f:(bits_of_byte ~of_bool:Fn.id)\n |> Fn.flip List.take size_in_bits\n |> Result.return\n end\n\n (** Coding2 is an alternate binary coding setup where we pass two arrays of\n * field elements instead of a single structure to simplify manipulation\n * outside of the Mina construction API\n *\n * This is described as the second mechanism for coding Random_oracle_input in\n * RFC0038\n *\n*)\n module Coding2 = struct\n module Rendered = struct\n (* as bytes, you must hex this later *)\n type 'field t_ = { prefix : 'field array; suffix : 'field array }\n [@@deriving yojson]\n\n type t = string t_ [@@deriving yojson]\n\n let map ~f { prefix; suffix } =\n { prefix = Array.map ~f prefix; suffix = Array.map ~f suffix }\n end\n\n let string_of_field : bool list -> string = Coding.string_of_field\n\n let field_of_string = Coding.field_of_string\n\n let serialize' t ~pack =\n { Rendered.prefix = t.field_elements\n ; suffix = pack_bits ~max_size:254 ~pack t |> Array.of_list_rev\n }\n\n let serialize t ~string_of_field ~pack =\n let () =\n if Array.length t.field_elements > 0 then\n assert (String.length (string_of_field t.field_elements.(0)) = 32)\n else ()\n in\n serialize' t ~pack |> Rendered.map ~f:string_of_field\n end\n\n let%test_module \"random_oracle input\" =\n ( module struct\n let gen_field ~size_in_bits =\n let open Quickcheck.Generator in\n list_with_length size_in_bits bool\n\n let gen_input ?size_in_bits () =\n let open Quickcheck.Generator in\n let open Let_syntax in\n let%bind size_in_bits =\n size_in_bits |> Option.map ~f:return\n |> Option.value ~default:(Int.gen_incl 2 3000)\n in\n let%bind field_elements =\n (* Treat a field as a list of bools of length [size_in_bits]. *)\n list (gen_field ~size_in_bits)\n in\n let%map bitstrings = list (list bool) in\n ( size_in_bits\n , { field_elements = Array.of_list field_elements\n ; bitstrings = Array.of_list bitstrings\n } )\n\n let%test_unit \"coding2 equiv to hash directly\" =\n let size_in_bits = 255 in\n let field = gen_field ~size_in_bits in\n Quickcheck.test ~trials:300\n Quickcheck.Generator.(\n tuple2 (gen_input ~size_in_bits ()) (tuple2 field field))\n ~f:(fun ((_, input), (x, y)) ->\n let middle = [| x; y |] in\n let expected =\n append input (field_elements middle)\n |> pack_to_fields ~size_in_bits ~pack:Fn.id\n in\n let { Coding2.Rendered.prefix; suffix } =\n Coding2.serialize' input ~pack:Fn.id\n in\n let actual = Array.(concat [ prefix; middle; suffix ]) in\n [%test_eq: bool list array] expected actual )\n\n let%test_unit \"field/string partial isomorphism bitstrings\" =\n Quickcheck.test ~trials:300\n Quickcheck.Generator.(list_with_length 255 bool)\n ~f:(fun input ->\n let serialized = Coding.string_of_field input in\n let deserialized =\n Coding.field_of_string serialized ~size_in_bits:255\n in\n [%test_eq: (bool list, unit) Result.t] (input |> Result.return)\n deserialized )\n\n let%test_unit \"serialize/deserialize partial isomorphism 32byte fields\" =\n let size_in_bits = 255 in\n Quickcheck.test ~trials:3000 (gen_input ~size_in_bits ())\n ~f:(fun (_, input) ->\n let serialized =\n Coding.(\n serialize ~string_of_field ~to_bool:Fn.id ~of_bool:Fn.id input)\n in\n let deserialized =\n Coding.(\n deserialize\n (String.to_list serialized)\n ~field_of_string:(field_of_string ~size_in_bits)\n ~of_bool:Fn.id)\n in\n let normalized t =\n { t with\n bitstrings =\n ( t.bitstrings |> Array.to_list |> List.concat\n |> fun xs -> [| xs |] )\n }\n in\n assert (\n Array.for_all input.field_elements ~f:(fun el ->\n List.length el = size_in_bits ) ) ;\n Result.iter deserialized ~f:(fun x ->\n assert (\n Array.for_all x.field_elements ~f:(fun el ->\n List.length el = size_in_bits ) ) ) ;\n [%test_eq:\n ( (bool list, bool) t\n , [ `Expected_eof | `Unexpected_eof ] )\n Result.t]\n (normalized input |> Result.return)\n (deserialized |> Result.map ~f:normalized) )\n\n let%test_unit \"data is preserved by to_bits\" =\n Quickcheck.test ~trials:300 (gen_input ())\n ~f:(fun (size_in_bits, input) ->\n let bits = to_bits ~unpack:Fn.id input in\n let bools_equal = [%equal: bool list] in\n (* Fields are accumulated at the front, check them first. *)\n let bitstring_bits =\n Array.fold ~init:bits input.field_elements ~f:(fun bits field ->\n (* The next chunk of [size_in_bits] bits is for the field\n element.\n *)\n let field_bits, rest = List.split_n bits size_in_bits in\n assert (bools_equal field_bits field) ;\n rest )\n in\n (* Bits come after. *)\n let remaining_bits =\n Array.fold ~init:bitstring_bits input.bitstrings\n ~f:(fun bits bitstring ->\n (* The next bits match the bitstring. *)\n let bitstring_bits, rest =\n List.split_n bits (List.length bitstring)\n in\n assert (bools_equal bitstring_bits bitstring) ;\n rest )\n in\n (* All bits should have been consumed. *)\n assert (List.is_empty remaining_bits) )\n\n let%test_unit \"data is preserved by pack_to_fields\" =\n Quickcheck.test ~trials:300 (gen_input ())\n ~f:(fun (size_in_bits, input) ->\n let fields = pack_to_fields ~size_in_bits ~pack:Fn.id input in\n (* Fields are accumulated at the front, check them first. *)\n let fields = Array.to_list fields in\n let bitstring_fields =\n Array.fold ~init:fields input.field_elements\n ~f:(fun fields input_field ->\n (* The next field element should be the literal field element\n passed in.\n *)\n match fields with\n | [] ->\n failwith \"Too few field elements\"\n | field :: rest ->\n assert ([%equal: bool list] field input_field) ;\n rest )\n in\n (* Check that the remaining fields have the correct size. *)\n let final_field_idx = List.length bitstring_fields - 1 in\n List.iteri bitstring_fields ~f:(fun i field_bits ->\n if i < final_field_idx then\n (* This field should be densely packed, but should contain\n fewer bits than the maximum field element to ensure that it\n doesn't overflow, so we expect [size_in_bits - 1] bits for\n maximum safe density.\n *)\n assert (List.length field_bits = size_in_bits - 1)\n else (\n (* This field will be comprised of the remaining bits, up to a\n maximum of [size_in_bits - 1]. It should not be empty.\n *)\n assert (not (List.is_empty field_bits)) ;\n assert (List.length field_bits < size_in_bits) ) ) ;\n let rec go input_bitstrings packed_fields =\n match (input_bitstrings, packed_fields) with\n | [], [] ->\n (* We have consumed all bitstrings and fields in parallel, with\n no bits left over. Success.\n *)\n ()\n | [] :: input_bitstrings, packed_fields\n | input_bitstrings, [] :: packed_fields ->\n (* We have consumed the whole of an input bitstring or the whole\n of a packed field, move onto the next one.\n *)\n go input_bitstrings packed_fields\n | ( (bi :: input_bitstring) :: input_bitstrings\n , (bp :: packed_field) :: packed_fields ) ->\n (* Consume the next bit from the next input bitstring, and the\n next bit from the next packed field. They must match.\n *)\n assert (Bool.equal bi bp) ;\n go\n (input_bitstring :: input_bitstrings)\n (packed_field :: packed_fields)\n | [], _ ->\n failwith \"Packed fields contain more bits than were provided\"\n | _, [] ->\n failwith\n \"There are input bits that were not present in the packed \\\n fields\"\n in\n (* Check that the bits match between the input bitstring and the\n remaining fields.\n *)\n go (Array.to_list input.bitstrings) bitstring_fields )\n end )\nend\n","open Core_kernel\n\n[@@@warning \"-4\"] (* sexp-related fragile pattern-matching warning *)\n\n[%%versioned\nmodule Stable = struct\n module V1 = struct\n type t = Mina_wire_types.Pickles_base.Proofs_verified.V1.t = N0 | N1 | N2\n [@@deriving sexp, compare, yojson, hash, equal]\n\n let to_latest = Fn.id\n end\nend]\n\n[@@@warning \"+4\"]\n\nlet to_int : t -> int = function N0 -> 0 | N1 -> 1 | N2 -> 2\n\n(** Inside the circuit, we use two different representations for this type,\n depending on what we need it for.\n\n Sometimes, we use it for masking out a list of 2 points by taking the\n a prefix of length 0, 1, or 2. In this setting, we we will represent a value\n of this type as a sequence of 2 bits like so:\n 00: N0\n 10: N1\n 11: N2\n\n We call this a **prefix mask**.\n\n Sometimes, we use it to select something from a list of 3 values. In this\n case, we will represent a value of this type as a sequence of 3 bits like so:\n\n 100: N0\n 010: N1\n 001: N2\n\n We call this a **one-hot vector** as elsewhere.\n*)\n\ntype proofs_verified = t\n\nlet of_nat (type n) (n : n Pickles_types.Nat.t) : t =\n let open Pickles_types.Nat in\n match n with\n | Z ->\n N0\n | S Z ->\n N1\n | S (S Z) ->\n N2\n | S _ ->\n failwithf \"Proofs_verified.of_nat: got %d\" (to_int n) ()\n\nlet of_int (n : int) : t =\n match n with\n | 0 ->\n N0\n | 1 ->\n N1\n | 2 ->\n N2\n | _ ->\n failwithf \"Proofs_verified.of_int: got %d\" n ()\n\ntype 'f boolean = 'f Snarky_backendless.Cvar.t Snarky_backendless.Boolean.t\n\ntype 'a vec2 = ('a, Pickles_types.Nat.N2.n) Pickles_types.Vector.t\n\nmodule Prefix_mask = struct\n module Checked = struct\n type 'f t = 'f boolean vec2\n end\n\n let[@warning \"-40-42\"] there : proofs_verified -> bool vec2 = function\n | N0 ->\n [ false; false ]\n | N1 ->\n [ false; true ]\n | N2 ->\n [ true; true ]\n\n let[@warning \"-40-42\"] back : bool vec2 -> proofs_verified = function\n | [ false; false ] ->\n N0\n | [ false; true ] ->\n N1\n | [ true; true ] ->\n N2\n | [ true; false ] ->\n invalid_arg \"Prefix_mask.back: invalid mask [false; true]\"\n\n let typ (type f)\n (module Impl : Snarky_backendless.Snark_intf.Run with type field = f) :\n (f Checked.t, proofs_verified) Impl.Typ.t =\n let open Impl in\n Typ.transport\n (Pickles_types.Vector.typ Boolean.typ Pickles_types.Nat.N2.n)\n ~there ~back\nend\n\nmodule One_hot = struct\n module Checked = struct\n type 'f t = ('f, Pickles_types.Nat.N3.n) One_hot_vector.t\n\n let to_input (type f) (t : f t) =\n Random_oracle_input.Chunked.packeds\n (Array.map\n Pickles_types.(Vector.to_array (t :> (f boolean, Nat.N3.n) Vector.t))\n ~f:(fun b -> ((b :> f Snarky_backendless.Cvar.t), 1)) )\n end\n\n let there : proofs_verified -> int = function N0 -> 0 | N1 -> 1 | N2 -> 2\n\n let back : int -> proofs_verified = function\n | 0 ->\n N0\n | 1 ->\n N1\n | 2 ->\n N2\n | _ ->\n failwith \"Invalid mask\"\n\n let to_input ~zero ~one (t : t) =\n let one_hot =\n match t with\n | N0 ->\n [| one; zero; zero |]\n | N1 ->\n [| zero; one; zero |]\n | N2 ->\n [| zero; zero; one |]\n in\n Random_oracle_input.Chunked.packeds (Array.map one_hot ~f:(fun b -> (b, 1)))\n\n let typ (type f)\n (module Impl : Snarky_backendless.Snark_intf.Run with type field = f) :\n (f Checked.t, proofs_verified) Impl.Typ.t =\n let module M = One_hot_vector.Make (Impl) in\n let open Impl in\n Typ.transport (M.typ Pickles_types.Nat.N3.n) ~there ~back\nend\n","open Core_kernel\nopen Pickles_types\n\nlet bits ~len n = List.init len ~f:(fun i -> (n lsr i) land 1 = 1)\n\nlet max_log2_degree = 32\n\nmodule Width : sig\n [%%versioned:\n module Stable : sig\n module V1 : sig\n type t [@@deriving sexp, equal, compare, hash, yojson]\n end\n end]\n\n val of_int_exn : int -> t\n\n val to_int : t -> int\n\n val to_bits : t -> bool list\n\n val zero : t\n\n module Max = Nat.N2\n\n module Max_vector : Vector.With_version(Max).S\n\n module Max_at_most : sig\n [%%versioned:\n module Stable : sig\n module V1 : sig\n type 'a t = ('a, Max.n) At_most.t\n [@@deriving compare, sexp, yojson, hash, equal]\n end\n end]\n end\n\n module Length : Nat.Add.Intf_transparent\nend = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = char [@@deriving sexp, equal, compare, hash, yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n let zero = Char.of_int_exn 0\n\n module Max = Nat.N2\n\n (* Think about versioning here! These vector types *will* change\n serialization if the numbers above change, and so will require a new\n version number. Thus, it's important that these are modules with new\n versioned types, and not just module aliases to the corresponding vector\n implementation.\n *)\n module Max_vector = struct\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n type 'a t = 'a Vector.Vector_2.Stable.V1.t\n [@@deriving compare, yojson, sexp, hash, equal]\n end\n end]\n\n type 'a t = 'a Vector.Vector_2.t\n [@@deriving compare, yojson, sexp, hash, equal]\n\n let map = Vector.map\n\n let of_list_exn = Vector.Vector_2.of_list_exn\n\n let to_list = Vector.to_list\n end\n\n module Max_at_most = struct\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n type 'a t = 'a At_most.At_most_2.Stable.V1.t\n [@@deriving compare, yojson, sexp, hash, equal]\n end\n end]\n\n type 'a t = 'a At_most.At_most_2.t\n [@@deriving compare, yojson, sexp, hash, equal]\n end\n\n module Length = Nat.N4\n\n let to_int = Char.to_int\n\n let to_bits = Fn.compose (bits ~len:(Nat.to_int Length.n)) to_int\n\n let of_int_exn : int -> t =\n let m = Nat.to_int Max.n in\n fun n ->\n assert (n <= m) ;\n Char.of_int_exn n\nend\n\nmodule Max_branches = struct\n include Nat.N8\n module Log2 = Nat.N3\n\n let%test \"check max_branches\" = Nat.to_int n = 1 lsl Nat.to_int Log2.n\nend\n\n(* TODO: remove since it looks very much like the Domains module in the same directory *)\nmodule Domains = struct\n [@@@warning \"-40-42\"]\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n type 'a t = { h : 'a }\n [@@deriving sexp, equal, compare, hash, yojson, hlist, fields]\n end\n end]\nend\n\nmodule Repr = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type 'g t =\n { max_proofs_verified : Proofs_verified.Stable.V1.t\n ; actual_wrap_domain_size : Proofs_verified.Stable.V1.t\n ; wrap_index : 'g Plonk_verification_key_evals.Stable.V2.t\n }\n [@@deriving sexp, equal, compare, yojson]\n end\n end]\nend\n\nmodule Poly = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type ('g, 'proofs_verified, 'vk) t =\n ( 'g\n , 'proofs_verified\n , 'vk )\n Mina_wire_types.Pickles_base.Side_loaded_verification_key.Poly.V2.t =\n { max_proofs_verified : 'proofs_verified\n ; actual_wrap_domain_size : 'proofs_verified\n ; wrap_index : 'g Plonk_verification_key_evals.Stable.V2.t\n ; wrap_vk : 'vk option\n }\n [@@deriving hash]\n end\n end]\nend\n\nlet index_to_field_elements (k : 'a Plonk_verification_key_evals.t) ~g =\n let Plonk_verification_key_evals.\n { sigma_comm\n ; coefficients_comm\n ; generic_comm\n ; psm_comm\n ; complete_add_comm\n ; mul_comm\n ; emul_comm\n ; endomul_scalar_comm\n } =\n k\n in\n List.map\n ( Vector.to_list sigma_comm\n @ Vector.to_list coefficients_comm\n @ [ generic_comm\n ; psm_comm\n ; complete_add_comm\n ; mul_comm\n ; emul_comm\n ; endomul_scalar_comm\n ] )\n ~f:g\n |> Array.concat\n\nlet wrap_index_to_input (type gs f) (g : gs -> f array) t =\n Random_oracle_input.Chunked.field_elements (index_to_field_elements t ~g)\n\nlet to_input (type a) ~(field_of_int : int -> a) :\n (a * a, _, _) Poly.t -> a Random_oracle_input.Chunked.t =\n let open Random_oracle_input.Chunked in\n fun Poly.\n { max_proofs_verified\n ; actual_wrap_domain_size\n ; wrap_index\n ; wrap_vk = _\n } : _ Random_oracle_input.Chunked.t ->\n List.reduce_exn ~f:append\n [ Proofs_verified.One_hot.to_input ~zero:(field_of_int 0)\n ~one:(field_of_int 1) max_proofs_verified\n ; Proofs_verified.One_hot.to_input ~zero:(field_of_int 0)\n ~one:(field_of_int 1) actual_wrap_domain_size\n ; wrap_index_to_input\n (Fn.compose Array.of_list (fun (x, y) -> [ x; y ]))\n wrap_index\n ]\n","open Core_kernel\n\n[@@@warning \"-4\"] (* sexp-related fragile pattern-matching warning *)\n\n[%%versioned\nmodule Stable = struct\n module V1 = struct\n type t = Pow_2_roots_of_unity of int\n [@@unboxed] [@@deriving sexp, equal, compare, hash, yojson]\n\n let to_latest = Fn.id\n end\nend]\n\n[@@@warning \"+4\"]\n\ninclude Hashable.Make (Stable.Latest)\n\nlet log2_size (Pow_2_roots_of_unity k) = k\n\nlet size t = 1 lsl log2_size t\n","(** See documentation of the {!Mina_wire_types} library *)\nmodule Wire_types = Mina_wire_types.Pickles_composition_types.Branch_data\n\nmodule Make_sig (A : Wire_types.Types.S) = struct\n module type S =\n Branch_data_intf.S\n with type Domain_log2.Stable.V1.t = A.Domain_log2.V1.t\n and type Stable.V1.t = A.V1.t\nend\n\nmodule Make_str (A : Wire_types.Concrete) = struct\n (** Data specific to a branch of a proof-system that's necessary for\n finalizing the deferred-values in a wrap proof of that branch. *)\n\n module Proofs_verified = Pickles_base.Proofs_verified\n\n module Domain_log2 = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = char [@@deriving compare, sexp, yojson, hash, equal]\n\n let to_latest = Fn.id\n end\n end]\n\n let of_int_exn : int -> t = Char.of_int_exn\n\n let of_bits_msb (bs : bool list) : t =\n List.fold bs ~init:0 ~f:(fun acc b ->\n let acc = acc lsl 1 in\n if b then acc + 1 else acc )\n |> of_int_exn\n\n let of_field_exn (type f)\n (module Impl : Snarky_backendless.Snark_intf.Run with type field = f)\n (x : f) : t =\n Impl.Field.Constant.unpack x\n |> Fn.flip List.take 8 |> List.rev |> of_bits_msb\n end\n\n (* We pack this into a single field element as follows:\n First 2 bits: proofs_verified\n Next 8 bits: domain_log2 *)\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = A.V1.t =\n { proofs_verified : Proofs_verified.Stable.V1.t\n ; domain_log2 : Domain_log2.Stable.V1.t\n }\n [@@deriving hlist, compare, sexp, yojson, hash, equal]\n\n let to_latest = Fn.id\n end\n end]\n\n let length_in_bits = 10\n\n let pack (type f)\n (module Impl : Snarky_backendless.Snark_intf.Run with type field = f)\n ({ proofs_verified; domain_log2 } : t) : f =\n let open Impl.Field.Constant in\n let double x = x + x in\n let times4 x = double (double x) in\n let domain_log2 = of_int (Char.to_int domain_log2) in\n (* shift domain_log2 over by 2 bits (multiply by 4) *)\n times4 domain_log2\n + project\n (Pickles_types.Vector.to_list\n (Proofs_verified.Prefix_mask.there proofs_verified) )\n\n let unpack (type f)\n (module Impl : Snarky_backendless.Snark_intf.Run with type field = f)\n (x : f) : t =\n match Impl.Field.Constant.unpack x with\n | x0 :: x1 :: y0 :: y1 :: y2 :: y3 :: y4 :: y5 :: y6 :: y7 :: _ ->\n { proofs_verified = Proofs_verified.Prefix_mask.back [ x0; x1 ]\n ; domain_log2 =\n Domain_log2.of_bits_msb [ y7; y6; y5; y4; y3; y2; y1; y0 ]\n }\n | _ ->\n assert false\n\n module Checked = struct\n type 'f t =\n { proofs_verified_mask : 'f Proofs_verified.Prefix_mask.Checked.t\n ; domain_log2 : 'f Snarky_backendless.Cvar.t\n }\n [@@deriving hlist]\n\n let pack (type f)\n (module Impl : Snarky_backendless.Snark_intf.Run with type field = f)\n ({ proofs_verified_mask; domain_log2 } : f t) : Impl.Field.t =\n let open Impl.Field in\n let four = of_int 4 in\n (four * domain_log2)\n + pack (Pickles_types.Vector.to_list proofs_verified_mask)\n end\n\n let packed_typ (type f)\n (module Impl : Snarky_backendless.Snark_intf.Run with type field = f) =\n Impl.Typ.transport Impl.Typ.field\n ~there:(pack (module Impl))\n ~back:(unpack (module Impl))\n\n let typ (type f)\n (module Impl : Snarky_backendless.Snark_intf.Run with type field = f)\n ~(* We actually only need it to be less than 252 bits in order to pack\n the whole branch_data struct safely, but it's cheapest to check that it's\n under 16 bits *)\n (assert_16_bits : Impl.Field.t -> unit) : (f Checked.t, t) Impl.Typ.t =\n let open Impl in\n let proofs_verified_mask :\n (f Proofs_verified.Prefix_mask.Checked.t, Proofs_verified.t) Typ.t =\n Proofs_verified.Prefix_mask.typ (module Impl)\n in\n let domain_log2 : (Field.t, Domain_log2.t) Typ.t =\n let (Typ t) =\n Typ.transport Field.typ\n ~there:(fun (x : char) -> Field.Constant.of_int (Char.to_int x))\n ~back:(Domain_log2.of_field_exn (module Impl))\n in\n let check (x : Field.t) = make_checked (fun () -> assert_16_bits x) in\n Typ { t with check }\n in\n Typ.of_hlistable\n [ proofs_verified_mask; domain_log2 ]\n ~value_of_hlist:of_hlist ~value_to_hlist:to_hlist\n ~var_to_hlist:Checked.to_hlist ~var_of_hlist:Checked.of_hlist\n\n let domain { domain_log2; _ } =\n Pickles_base.Domain.Pow_2_roots_of_unity (Char.to_int domain_log2)\nend\n\ninclude Wire_types.Make (Make_sig) (Make_str)\n","[%%versioned\nmodule Stable = struct\n module V1 = struct\n type 'challenge t =\n 'challenge Mina_wire_types.Pickles_bulletproof_challenge.V1.t =\n { prechallenge : 'challenge }\n [@@deriving sexp, compare, yojson, hash, equal]\n end\nend]\n\nlet pack { prechallenge } = prechallenge\n\nlet unpack prechallenge = { prechallenge }\n\nlet map { prechallenge } ~f = { prechallenge = f prechallenge }\n\nlet typ chal =\n let there = pack in\n let back = unpack in\n let open Snarky_backendless in\n Typ.transport ~there ~back (Kimchi_backend_common.Scalar_challenge.typ chal)\n |> Typ.transport_var ~there ~back\n","open Pickles_types\nmodule Scalar_challenge = Kimchi_backend_common.Scalar_challenge\nmodule Bulletproof_challenge = Bulletproof_challenge\nmodule Branch_data = Branch_data\nmodule Digest = Digest\nmodule Spec = Spec\nmodule Opt = Plonk_types.Opt\nopen Core_kernel\n\ntype 'f impl = 'f Spec.impl\n\nlet index_to_field_elements =\n Pickles_base.Side_loaded_verification_key.index_to_field_elements\n\nmodule Zero_values = struct\n type ('chal, 'fp) single = { challenge : 'chal; scalar : 'fp }\n\n type ('chal, 'chal_var, 'fp, 'fp_var) t =\n { value : ('chal, 'fp) single; var : ('chal_var, 'fp_var) single }\nend\n\nmodule Wrap = struct\n module Proof_state = struct\n (** This module contains structures which contain the scalar-field elements that\n are required to finalize the verification of a proof that is partially verified inside\n a circuit.\n\n Each verifier circuit starts by verifying the parts of a proof involving group operations.\n At the end, there is a sequence of scalar-field computations it must perform. Instead of\n performing them directly, it exposes the values needed for those computations as a part of\n its own public-input, so that the next circuit can do them (since it will use the other curve on the cycle,\n and hence can efficiently perform computations in that scalar field). *)\n module Deferred_values = struct\n module Plonk = struct\n module Minimal = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n (** Challenges from the PLONK IOP. These, plus the evaluations that are already in the proof, are\n all that's needed to derive all the values in the [In_circuit] version below.\n\n See src/lib/pickles/plonk_checks/plonk_checks.ml for the computation of the [In_circuit] value\n from the [Minimal] value.\n *)\n type ('challenge, 'scalar_challenge, 'bool) t =\n ( 'challenge\n , 'scalar_challenge\n , 'bool )\n Mina_wire_types.Pickles_composition_types.Wrap.Proof_state\n .Deferred_values\n .Plonk\n .Minimal\n .V1\n .t =\n { alpha : 'scalar_challenge\n ; beta : 'challenge\n ; gamma : 'challenge\n ; zeta : 'scalar_challenge\n ; joint_combiner : 'scalar_challenge option\n ; feature_flags : 'bool Plonk_types.Features.Stable.V1.t\n }\n [@@deriving sexp, compare, yojson, hlist, hash, equal]\n\n let to_latest = Fn.id\n end\n end]\n\n let map_challenges t ~f ~scalar =\n { t with\n alpha = scalar t.alpha\n ; beta = f t.beta\n ; gamma = f t.gamma\n ; zeta = scalar t.zeta\n ; joint_combiner = Option.map ~f:scalar t.joint_combiner\n }\n end\n\n open Pickles_types\n\n module In_circuit = struct\n module Lookup = struct\n type 'scalar_challenge t = { joint_combiner : 'scalar_challenge }\n [@@deriving sexp, compare, yojson, hlist, hash, equal, fields]\n\n let[@warning \"-45\"] to_struct l = Hlist.HlistId.[ l.joint_combiner ]\n\n let[@warning \"-45\"] of_struct Hlist.HlistId.[ joint_combiner ] =\n { joint_combiner }\n\n let map ~f { joint_combiner } =\n { joint_combiner = f joint_combiner }\n\n let typ scalar_challenge =\n Snarky_backendless.Typ.of_hlistable ~var_to_hlist:to_hlist\n ~var_of_hlist:of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist [ scalar_challenge ]\n end\n\n (** All scalar values deferred by a verifier circuit.\n We expose them so the next guy (who can do scalar arithmetic) can check that they\n were computed correctly from the evaluations in the proof and the challenges.\n *)\n type ( 'challenge\n , 'scalar_challenge\n , 'fp\n , 'fp_opt\n , 'lookup_opt\n , 'bool )\n t =\n { alpha : 'scalar_challenge\n ; beta : 'challenge\n ; gamma : 'challenge\n ; zeta : 'scalar_challenge\n (* TODO: zeta_to_srs_length is kind of unnecessary.\n Try to get rid of it when you can.\n *)\n ; zeta_to_srs_length : 'fp\n ; zeta_to_domain_size : 'fp\n ; perm : 'fp\n (** scalar used on one of the permutation polynomial commitments. *)\n ; feature_flags : 'bool Plonk_types.Features.t\n ; lookup : 'lookup_opt\n }\n [@@deriving sexp, compare, yojson, hlist, hash, equal, fields]\n\n let map_challenges t ~f ~scalar =\n { t with\n alpha = scalar t.alpha\n ; beta = f t.beta\n ; gamma = f t.gamma\n ; zeta = scalar t.zeta\n ; lookup = Opt.map ~f:(Lookup.map ~f:scalar) t.lookup\n }\n\n let map_fields t ~f =\n { t with\n zeta_to_srs_length = f t.zeta_to_srs_length\n ; zeta_to_domain_size = f t.zeta_to_domain_size\n ; perm = f t.perm\n }\n\n let typ (type f fp)\n (module Impl : Snarky_backendless.Snark_intf.Run\n with type field = f ) ~dummy_scalar ~dummy_scalar_challenge\n ~challenge ~scalar_challenge ~bool ~feature_flags\n (fp : (fp, _, f) Snarky_backendless.Typ.t) =\n let uses_lookup =\n let { Plonk_types.Features.range_check0\n ; range_check1\n ; foreign_field_add = _ (* Doesn't use lookup *)\n ; foreign_field_mul\n ; xor\n ; rot\n ; lookup\n ; runtime_tables = _ (* Fixme *)\n } =\n feature_flags\n in\n Array.reduce_exn ~f:Opt.Flag.( ||| )\n [| range_check0\n ; range_check1\n ; foreign_field_mul\n ; xor\n ; rot\n ; lookup\n |]\n in\n Snarky_backendless.Typ.of_hlistable\n [ Scalar_challenge.typ scalar_challenge\n ; challenge\n ; challenge\n ; Scalar_challenge.typ scalar_challenge\n ; fp\n ; fp\n ; fp\n ; Plonk_types.Features.typ ~feature_flags bool\n ; Plonk_types.Opt.typ Impl.Boolean.typ uses_lookup\n ~dummy:{ joint_combiner = dummy_scalar_challenge }\n (Lookup.typ (Scalar_challenge.typ scalar_challenge))\n ]\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist\n ~value_to_hlist:to_hlist ~value_of_hlist:of_hlist\n end\n\n let to_minimal (type challenge scalar_challenge fp fp_opt lookup_opt)\n (t :\n ( challenge\n , scalar_challenge\n , fp\n , fp_opt\n , lookup_opt\n , 'bool )\n In_circuit.t )\n ~(to_option :\n lookup_opt -> scalar_challenge In_circuit.Lookup.t option ) :\n (challenge, scalar_challenge, 'bool) Minimal.t =\n { alpha = t.alpha\n ; beta = t.beta\n ; zeta = t.zeta\n ; gamma = t.gamma\n ; joint_combiner =\n Option.map (to_option t.lookup) ~f:(fun l ->\n l.In_circuit.Lookup.joint_combiner )\n ; feature_flags = t.feature_flags\n }\n end\n\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n (** All the deferred values needed, comprising values from the PLONK IOP verification,\n values from the inner-product argument, and [which_branch] which is needed to know\n the proper domain to use. *)\n type ( 'plonk\n , 'scalar_challenge\n , 'fp\n , 'bulletproof_challenges\n , 'branch_data )\n t =\n ( 'plonk\n , 'scalar_challenge\n , 'fp\n , 'bulletproof_challenges\n , 'branch_data )\n Mina_wire_types.Pickles_composition_types.Wrap.Proof_state\n .Deferred_values\n .V1\n .t =\n { plonk : 'plonk\n ; combined_inner_product : 'fp\n (** combined_inner_product = sum_{i < num_evaluation_points} sum_{j < num_polys} r^i xi^j f_j(pt_i) *)\n ; b : 'fp\n (** b = challenge_poly plonk.zeta + r * challenge_poly (domain_generrator * plonk.zeta)\n where challenge_poly(x) = \\prod_i (1 + bulletproof_challenges.(i) * x^{2^{k - 1 - i}})\n *)\n ; xi : 'scalar_challenge\n (** The challenge used for combining polynomials *)\n ; bulletproof_challenges : 'bulletproof_challenges\n (** The challenges from the inner-product argument that was partially verified. *)\n ; branch_data : 'branch_data\n (** Data specific to which step branch of the proof-system was verified *)\n }\n [@@deriving sexp, compare, yojson, hlist, hash, equal]\n\n let to_latest = Fn.id\n end\n end]\n\n type ( 'plonk\n , 'scalar_challenge\n , 'fp\n , 'bulletproof_challenges\n , 'branch_data )\n t =\n ( 'plonk\n , 'scalar_challenge\n , 'fp\n , 'bulletproof_challenges\n , 'branch_data )\n Stable.Latest.t =\n { plonk : 'plonk\n ; combined_inner_product : 'fp\n ; b : 'fp\n ; xi : 'scalar_challenge\n ; bulletproof_challenges : 'bulletproof_challenges\n ; branch_data : 'branch_data\n }\n [@@deriving sexp, compare, yojson, hlist, hash, equal]\n\n module Minimal = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type ( 'challenge\n , 'scalar_challenge\n , 'fp\n , 'bool\n , 'bulletproof_challenges\n , 'branch_data )\n t =\n ( 'challenge\n , 'scalar_challenge\n , 'fp\n , 'bool\n , 'bulletproof_challenges\n , 'branch_data )\n Mina_wire_types.Pickles_composition_types.Wrap.Proof_state\n .Deferred_values\n .Minimal\n .V1\n .t =\n { plonk :\n ( 'challenge\n , 'scalar_challenge\n , 'bool )\n Plonk.Minimal.Stable.V1.t\n ; bulletproof_challenges : 'bulletproof_challenges\n ; branch_data : 'branch_data\n }\n [@@deriving sexp, compare, yojson, hash, equal]\n end\n end]\n\n let map_challenges { plonk; bulletproof_challenges; branch_data } ~f\n ~scalar =\n { plonk = Plonk.Minimal.map_challenges ~f ~scalar plonk\n ; bulletproof_challenges\n ; branch_data\n }\n end\n\n let map_challenges\n { plonk\n ; combined_inner_product\n ; b : 'fp\n ; xi\n ; bulletproof_challenges\n ; branch_data\n } ~f:_ ~scalar =\n { xi = scalar xi\n ; combined_inner_product\n ; b\n ; plonk\n ; bulletproof_challenges\n ; branch_data\n }\n\n module In_circuit = struct\n type ( 'challenge\n , 'scalar_challenge\n , 'fp\n , 'fp_opt\n , 'lookup_opt\n , 'bulletproof_challenges\n , 'branch_data\n , 'bool )\n t =\n ( ( 'challenge\n , 'scalar_challenge\n , 'fp\n , 'fp_opt\n , 'lookup_opt\n , 'bool )\n Plonk.In_circuit.t\n , 'scalar_challenge\n , 'fp\n , 'bulletproof_challenges\n , 'branch_data )\n Stable.Latest.t\n [@@deriving sexp, compare, yojson, hash, equal]\n\n let to_hlist, of_hlist = (to_hlist, of_hlist)\n\n let typ (type f fp)\n ((module Impl) as impl :\n (module Snarky_backendless.Snark_intf.Run with type field = f) )\n ~dummy_scalar ~dummy_scalar_challenge ~challenge ~scalar_challenge\n ~feature_flags (fp : (fp, _, f) Snarky_backendless.Typ.t) index =\n Snarky_backendless.Typ.of_hlistable\n [ Plonk.In_circuit.typ impl ~dummy_scalar ~dummy_scalar_challenge\n ~challenge ~scalar_challenge ~bool:Impl.Boolean.typ\n ~feature_flags fp\n ; fp\n ; fp\n ; Scalar_challenge.typ scalar_challenge\n ; Vector.typ\n (Bulletproof_challenge.typ scalar_challenge)\n Backend.Tick.Rounds.n\n ; index\n ]\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist\n ~value_to_hlist:to_hlist ~value_of_hlist:of_hlist\n end\n\n let to_minimal\n ({ plonk\n ; combined_inner_product\n ; b\n ; xi\n ; bulletproof_challenges\n ; branch_data\n } :\n _ In_circuit.t ) ~to_option : _ Minimal.t =\n { plonk = Plonk.to_minimal ~to_option plonk\n ; bulletproof_challenges\n ; branch_data\n }\n end\n\n (** The component of the proof accumulation state that is only computed on by the\n \"wrapping\" proof system, and that can be handled opaquely by any \"step\" circuits. *)\n module Messages_for_next_wrap_proof = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type ('g1, 'bulletproof_challenges) t =\n ( 'g1\n , 'bulletproof_challenges )\n Mina_wire_types.Pickles_composition_types.Wrap.Proof_state\n .Messages_for_next_wrap_proof\n .V1\n .t =\n { challenge_polynomial_commitment : 'g1\n ; old_bulletproof_challenges : 'bulletproof_challenges\n }\n [@@deriving sexp, compare, yojson, hlist, hash, equal]\n end\n end]\n\n let to_field_elements (type g f)\n { challenge_polynomial_commitment; old_bulletproof_challenges }\n ~g1:(g1_to_field_elements : g -> f list) =\n Array.concat\n [ Vector.to_array old_bulletproof_challenges\n |> Array.concat_map ~f:Vector.to_array\n ; Array.of_list (g1_to_field_elements challenge_polynomial_commitment)\n ]\n\n let typ g1 chal ~length =\n Snarky_backendless.Typ.of_hlistable\n [ g1; Vector.typ chal length ]\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist\n end\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n type ( 'plonk\n , 'scalar_challenge\n , 'fp\n , 'messages_for_next_wrap_proof\n , 'digest\n , 'bp_chals\n , 'index )\n t =\n ( 'plonk\n , 'scalar_challenge\n , 'fp\n , 'messages_for_next_wrap_proof\n , 'digest\n , 'bp_chals\n , 'index )\n Mina_wire_types.Pickles_composition_types.Wrap.Proof_state.V1.t =\n { deferred_values :\n ( 'plonk\n , 'scalar_challenge\n , 'fp\n , 'bp_chals\n , 'index )\n Deferred_values.Stable.V1.t\n ; sponge_digest_before_evaluations : 'digest\n ; messages_for_next_wrap_proof : 'messages_for_next_wrap_proof\n (** Parts of the statement not needed by the other circuit. Represented as a hash inside the\n circuit which is then \"unhashed\". *)\n }\n [@@deriving sexp, compare, yojson, hlist, hash, equal]\n end\n end]\n\n module Minimal = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type ( 'challenge\n , 'scalar_challenge\n , 'fp\n , 'bool\n , 'messages_for_next_wrap_proof\n , 'digest\n , 'bp_chals\n , 'index )\n t =\n ( 'challenge\n , 'scalar_challenge\n , 'fp\n , 'bool\n , 'messages_for_next_wrap_proof\n , 'digest\n , 'bp_chals\n , 'index )\n Mina_wire_types.Pickles_composition_types.Wrap.Proof_state\n .Minimal\n .V1\n .t =\n { deferred_values :\n ( 'challenge\n , 'scalar_challenge\n , 'fp\n , 'bool\n , 'bp_chals\n , 'index )\n Deferred_values.Minimal.Stable.V1.t\n ; sponge_digest_before_evaluations : 'digest\n ; messages_for_next_wrap_proof : 'messages_for_next_wrap_proof\n (** Parts of the statement not needed by the other circuit. Represented as a hash inside the\n circuit which is then \"unhashed\". *)\n }\n [@@deriving sexp, compare, yojson, hash, equal]\n end\n end]\n end\n\n module In_circuit = struct\n type ( 'challenge\n , 'scalar_challenge\n , 'fp\n , 'fp_opt\n , 'lookup_opt\n , 'bool\n , 'messages_for_next_wrap_proof\n , 'digest\n , 'bp_chals\n , 'index )\n t =\n ( ( 'challenge\n , 'scalar_challenge\n , 'fp\n , 'fp_opt\n , 'lookup_opt\n , 'bool )\n Deferred_values.Plonk.In_circuit.t\n , 'scalar_challenge\n , 'fp\n , 'messages_for_next_wrap_proof\n , 'digest\n , 'bp_chals\n , 'index )\n Stable.Latest.t\n [@@deriving sexp, compare, yojson, hash, equal]\n\n let to_hlist, of_hlist = (to_hlist, of_hlist)\n\n let typ (type f fp)\n (impl : (module Snarky_backendless.Snark_intf.Run with type field = f))\n ~dummy_scalar ~dummy_scalar_challenge ~challenge ~scalar_challenge\n ~feature_flags (fp : (fp, _, f) Snarky_backendless.Typ.t)\n messages_for_next_wrap_proof digest index =\n Snarky_backendless.Typ.of_hlistable\n [ Deferred_values.In_circuit.typ impl ~dummy_scalar\n ~dummy_scalar_challenge ~challenge ~scalar_challenge\n ~feature_flags fp index\n ; digest\n ; messages_for_next_wrap_proof\n ]\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist\n end\n\n let to_minimal\n ({ deferred_values\n ; sponge_digest_before_evaluations\n ; messages_for_next_wrap_proof\n } :\n _ In_circuit.t ) ~to_option : _ Minimal.t =\n { deferred_values = Deferred_values.to_minimal ~to_option deferred_values\n ; sponge_digest_before_evaluations\n ; messages_for_next_wrap_proof\n }\n end\n\n (** The component of the proof accumulation state that is only computed on by the\n \"stepping\" proof system, and that can be handled opaquely by any \"wrap\" circuits. *)\n module Messages_for_next_step_proof = struct\n type ('g, 's, 'challenge_polynomial_commitments, 'bulletproof_challenges) t =\n { app_state : 's\n (** The actual application-level state (e.g., for Mina, this is the protocol state which contains the\n merkle root of the ledger, state related to consensus, etc.) *)\n ; dlog_plonk_index : 'g Plonk_verification_key_evals.t\n (** The verification key corresponding to the wrap-circuit for this recursive proof system.\n It gets threaded through all the circuits so that the step circuits can verify proofs against\n it.\n *)\n ; challenge_polynomial_commitments : 'challenge_polynomial_commitments\n ; old_bulletproof_challenges : 'bulletproof_challenges\n }\n [@@deriving sexp]\n\n let to_field_elements (type g f)\n { app_state\n ; dlog_plonk_index\n ; challenge_polynomial_commitments\n ; old_bulletproof_challenges\n } ~app_state:app_state_to_field_elements ~comm ~(g : g -> f list) =\n Array.concat\n [ index_to_field_elements ~g:comm dlog_plonk_index\n ; app_state_to_field_elements app_state\n ; Vector.map2 challenge_polynomial_commitments\n old_bulletproof_challenges ~f:(fun comm chals ->\n Array.append (Array.of_list (g comm)) (Vector.to_array chals) )\n |> Vector.to_list |> Array.concat\n ]\n\n let to_field_elements_without_index (type g f)\n { app_state\n ; dlog_plonk_index = _\n ; challenge_polynomial_commitments\n ; old_bulletproof_challenges\n } ~app_state:app_state_to_field_elements ~(g : g -> f list) =\n Array.concat\n [ app_state_to_field_elements app_state\n ; Vector.map2 challenge_polynomial_commitments\n old_bulletproof_challenges ~f:(fun comm chals ->\n Array.append (Array.of_list (g comm)) (Vector.to_array chals) )\n |> Vector.to_list |> Array.concat\n ]\n\n open Snarky_backendless.H_list\n\n let[@warning \"-45\"] to_hlist\n { app_state\n ; dlog_plonk_index\n ; challenge_polynomial_commitments\n ; old_bulletproof_challenges\n } =\n [ app_state\n ; dlog_plonk_index\n ; challenge_polynomial_commitments\n ; old_bulletproof_challenges\n ]\n\n let[@warning \"-45\"] of_hlist\n ([ app_state\n ; dlog_plonk_index\n ; challenge_polynomial_commitments\n ; old_bulletproof_challenges\n ] :\n (unit, _) t ) =\n { app_state\n ; dlog_plonk_index\n ; challenge_polynomial_commitments\n ; old_bulletproof_challenges\n }\n\n let typ comm g s chal proofs_verified =\n Snarky_backendless.Typ.of_hlistable\n [ s\n ; Plonk_verification_key_evals.typ comm\n ; Vector.typ g proofs_verified\n ; chal\n ]\n (* TODO: Should this really just be a vector typ of length Rounds.n ?*)\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist\n end\n\n module Lookup_parameters = struct\n (* Values needed for computing lookup parts of the verifier circuit. *)\n type ('chal, 'chal_var, 'fp, 'fp_var) t =\n { zero : ('chal, 'chal_var, 'fp, 'fp_var) Zero_values.t\n ; use : Opt.Flag.t\n }\n\n let opt_spec (type f) ((module Impl) : f impl)\n { zero = { value; var }; use } =\n Spec.T.Opt\n { inner = Struct [ Scalar Challenge ]\n ; flag = use\n ; dummy1 =\n [ Kimchi_backend_common.Scalar_challenge.create value.challenge ]\n ; dummy2 =\n [ Kimchi_backend_common.Scalar_challenge.create var.challenge ]\n ; bool = (module Impl.Boolean)\n }\n end\n\n (** This is the full statement for \"wrap\" proofs which contains\n - the application-level statement (app_state)\n - data needed to perform the final verification of the proof, which correspond\n to parts of incompletely verified proofs.\n *)\n module Statement = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type ( 'plonk\n , 'scalar_challenge\n , 'fp\n , 'messages_for_next_wrap_proof\n , 'digest\n , 'messages_for_next_step_proof\n , 'bp_chals\n , 'index )\n t =\n ( 'plonk\n , 'scalar_challenge\n , 'fp\n , 'messages_for_next_wrap_proof\n , 'digest\n , 'messages_for_next_step_proof\n , 'bp_chals\n , 'index )\n Mina_wire_types.Pickles_composition_types.Wrap.Statement.V1.t =\n { proof_state :\n ( 'plonk\n , 'scalar_challenge\n , 'fp\n , 'messages_for_next_wrap_proof\n , 'digest\n , 'bp_chals\n , 'index )\n Proof_state.Stable.V1.t\n ; messages_for_next_step_proof : 'messages_for_next_step_proof\n }\n [@@deriving compare, yojson, sexp, hash, equal]\n end\n end]\n\n module Minimal = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type ( 'challenge\n , 'scalar_challenge\n , 'fp\n , 'bool\n , 'messages_for_next_wrap_proof\n , 'digest\n , 'messages_for_next_step_proof\n , 'bp_chals\n , 'index )\n t =\n ( 'challenge\n , 'scalar_challenge\n , 'fp\n , 'bool\n , 'messages_for_next_wrap_proof\n , 'digest\n , 'messages_for_next_step_proof\n , 'bp_chals\n , 'index )\n Mina_wire_types.Pickles_composition_types.Wrap.Statement.Minimal\n .V1\n .t =\n { proof_state :\n ( 'challenge\n , 'scalar_challenge\n , 'fp\n , 'bool\n , 'messages_for_next_wrap_proof\n , 'digest\n , 'bp_chals\n , 'index )\n Proof_state.Minimal.Stable.V1.t\n ; messages_for_next_step_proof : 'messages_for_next_step_proof\n }\n [@@deriving compare, yojson, sexp, hash, equal]\n end\n end]\n end\n\n module In_circuit = struct\n type ( 'challenge\n , 'scalar_challenge\n , 'fp\n , 'fp_opt\n , 'lookup_opt\n , 'bool\n , 'messages_for_next_wrap_proof\n , 'digest\n , 'messages_for_next_step_proof\n , 'bp_chals\n , 'index )\n t =\n ( ( 'challenge\n , 'scalar_challenge\n , 'fp\n , 'fp_opt\n , 'lookup_opt\n , 'bool )\n Proof_state.Deferred_values.Plonk.In_circuit.t\n , 'scalar_challenge\n , 'fp\n , 'messages_for_next_wrap_proof\n , 'digest\n , 'messages_for_next_step_proof\n , 'bp_chals\n , 'index )\n Stable.Latest.t\n [@@deriving compare, yojson, sexp, hash, equal]\n\n (** A layout of the raw data in a statement, which is needed for\n representing it inside the circuit. *)\n let spec impl lookup feature_flags =\n let feature_flags_spec =\n let [ f1; f2; f3; f4; f5; f6; f7; f8 ] =\n (* Ensure that layout is the same *)\n Plonk_types.Features.to_data feature_flags\n in\n let constant x =\n Spec.T.Constant (x, (fun x y -> assert (Bool.equal x y)), B Bool)\n in\n let maybe_constant flag =\n match flag with\n | Plonk_types.Opt.Flag.Yes ->\n constant true\n | Plonk_types.Opt.Flag.No ->\n constant false\n | Plonk_types.Opt.Flag.Maybe ->\n Spec.T.B Bool\n in\n Spec.T.Struct\n [ maybe_constant f1\n ; maybe_constant f2\n ; maybe_constant f3\n ; maybe_constant f4\n ; maybe_constant f5\n ; maybe_constant f6\n ; maybe_constant f7\n ; maybe_constant f8\n ]\n in\n Spec.T.Struct\n [ Vector (B Field, Nat.N5.n)\n ; Vector (B Challenge, Nat.N2.n)\n ; Vector (Scalar Challenge, Nat.N3.n)\n ; Vector (B Digest, Nat.N3.n)\n ; Vector (B Bulletproof_challenge, Backend.Tick.Rounds.n)\n ; Vector (B Branch_data, Nat.N1.n)\n ; feature_flags_spec\n ; Lookup_parameters.opt_spec impl lookup\n ]\n\n (** Convert a statement (as structured data) into the flat data-based representation. *)\n let[@warning \"-45\"] to_data\n ({ proof_state =\n { deferred_values =\n { xi\n ; combined_inner_product\n ; b\n ; branch_data\n ; bulletproof_challenges\n ; plonk =\n { alpha\n ; beta\n ; gamma\n ; zeta\n ; zeta_to_srs_length\n ; zeta_to_domain_size\n ; perm\n ; feature_flags\n ; lookup\n }\n }\n ; sponge_digest_before_evaluations\n ; messages_for_next_wrap_proof\n (* messages_for_next_wrap_proof is represented as a digest (and then unhashed) inside the circuit *)\n }\n ; messages_for_next_step_proof\n (* messages_for_next_step_proof is represented as a digest inside the circuit *)\n } :\n _ t ) ~option_map ~to_opt =\n let open Vector in\n let fp =\n [ combined_inner_product\n ; b\n ; zeta_to_srs_length\n ; zeta_to_domain_size\n ; perm\n ]\n in\n let challenge = [ beta; gamma ] in\n let scalar_challenge = [ alpha; zeta; xi ] in\n let digest =\n [ sponge_digest_before_evaluations\n ; messages_for_next_wrap_proof\n ; messages_for_next_step_proof\n ]\n in\n let index = [ branch_data ] in\n Hlist.HlistId.\n [ fp\n ; challenge\n ; scalar_challenge\n ; digest\n ; bulletproof_challenges\n ; index\n ; Plonk_types.Features.to_data feature_flags\n ; option_map lookup\n ~f:Proof_state.Deferred_values.Plonk.In_circuit.Lookup.to_struct\n ]\n\n (** Construct a statement (as structured data) from the flat data-based representation. *)\n let[@warning \"-45\"] of_data\n Hlist.HlistId.\n [ fp\n ; challenge\n ; scalar_challenge\n ; digest\n ; bulletproof_challenges\n ; index\n ; feature_flags\n ; lookup\n ] ~feature_flags:flags ~option_map ~of_opt : _ t =\n let open Vector in\n let [ combined_inner_product\n ; b\n ; zeta_to_srs_length\n ; zeta_to_domain_size\n ; perm\n ] =\n fp\n in\n let [ beta; gamma ] = challenge in\n let [ alpha; zeta; xi ] = scalar_challenge in\n let [ sponge_digest_before_evaluations\n ; messages_for_next_wrap_proof\n ; messages_for_next_step_proof\n ] =\n digest\n in\n let [ branch_data ] = index in\n let feature_flags = Plonk_types.Features.of_data feature_flags in\n { proof_state =\n { deferred_values =\n { xi\n ; combined_inner_product\n ; b\n ; branch_data\n ; bulletproof_challenges\n ; plonk =\n { alpha\n ; beta\n ; gamma\n ; zeta\n ; zeta_to_srs_length\n ; zeta_to_domain_size\n ; perm\n ; feature_flags\n ; lookup =\n option_map lookup\n ~f:\n Proof_state.Deferred_values.Plonk.In_circuit.Lookup\n .of_struct\n }\n }\n ; sponge_digest_before_evaluations\n ; messages_for_next_wrap_proof\n }\n ; messages_for_next_step_proof\n }\n end\n\n let to_minimal\n ({ proof_state; messages_for_next_step_proof } : _ In_circuit.t)\n ~to_option : _ Minimal.t =\n { proof_state = Proof_state.to_minimal ~to_option proof_state\n ; messages_for_next_step_proof\n }\n end\nend\n\nmodule Step = struct\n module Plonk_polys = Nat.N10\n\n module Bulletproof = struct\n include Plonk_types.Openings.Bulletproof\n\n module Advice = struct\n (** This is data that can be computed in linear time from the proof + statement.\n\n It doesn't need to be sent on the wire, but it does need to be provided to the verifier\n *)\n type 'fq t =\n { b : 'fq\n ; combined_inner_product : 'fq (* sum_i r^i sum_j xi^j f_j(pt_i) *)\n }\n [@@deriving hlist]\n end\n end\n\n module Proof_state = struct\n module Deferred_values = struct\n module Plonk = struct\n module Minimal = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n (** Challenges from the PLONK IOP. These, plus the evaluations that are already in the proof, are\n all that's needed to derive all the values in the [In_circuit] version below.\n\n See src/lib/pickles/plonk_checks/plonk_checks.ml for the computation of the [In_circuit] value\n from the [Minimal] value.\n *)\n type ('challenge, 'scalar_challenge) t =\n { alpha : 'scalar_challenge\n ; beta : 'challenge\n ; gamma : 'challenge\n ; zeta : 'scalar_challenge\n }\n [@@deriving sexp, compare, yojson, hlist, hash, equal]\n end\n end]\n\n let to_wrap ~feature_flags { alpha; beta; gamma; zeta } :\n _ Wrap.Proof_state.Deferred_values.Plonk.Minimal.t =\n { alpha; beta; gamma; zeta; joint_combiner = None; feature_flags }\n\n let of_wrap\n ({ alpha\n ; beta\n ; gamma\n ; zeta\n ; joint_combiner = _\n ; feature_flags = _\n } :\n _ Wrap.Proof_state.Deferred_values.Plonk.Minimal.t ) =\n { alpha; beta; gamma; zeta }\n end\n\n open Pickles_types\n\n module In_circuit = struct\n (** All scalar values deferred by a verifier circuit.\n The values in [vbmul], [complete_add], [endomul], [endomul_scalar], and [perm]\n are all scalars which will have been used to scale selector polynomials during the\n computation of the linearized polynomial commitment.\n\n Then, we expose them so the next guy (who can do scalar arithmetic) can check that they\n were computed correctly from the evaluations in the proof and the challenges.\n *)\n type ('challenge, 'scalar_challenge, 'fp) t =\n { alpha : 'scalar_challenge\n ; beta : 'challenge\n ; gamma : 'challenge\n ; zeta : 'scalar_challenge\n (* TODO: zeta_to_srs_length is kind of unnecessary.\n Try to get rid of it when you can.\n *)\n ; zeta_to_srs_length : 'fp\n ; zeta_to_domain_size : 'fp\n ; perm : 'fp\n (** scalar used on one of the permutation polynomial commitments. *)\n }\n [@@deriving sexp, compare, yojson, hlist, hash, equal, fields]\n\n let to_wrap ~opt_none ~false_\n { alpha\n ; beta\n ; gamma\n ; zeta\n ; zeta_to_srs_length\n ; zeta_to_domain_size\n ; perm\n } : _ Wrap.Proof_state.Deferred_values.Plonk.In_circuit.t =\n { alpha\n ; beta\n ; gamma\n ; zeta\n ; zeta_to_srs_length\n ; zeta_to_domain_size\n ; perm\n ; feature_flags =\n { range_check0 = false_\n ; range_check1 = false_\n ; foreign_field_add = false_\n ; foreign_field_mul = false_\n ; xor = false_\n ; rot = false_\n ; lookup = false_\n ; runtime_tables = false_\n }\n ; lookup = opt_none\n }\n\n let of_wrap ~assert_none ~assert_false\n ({ alpha\n ; beta\n ; gamma\n ; zeta\n ; zeta_to_srs_length\n ; zeta_to_domain_size\n ; perm\n ; feature_flags\n ; lookup\n } :\n _ Wrap.Proof_state.Deferred_values.Plonk.In_circuit.t ) =\n let () =\n let { Plonk_types.Features.range_check0\n ; range_check1\n ; foreign_field_add\n ; foreign_field_mul\n ; xor\n ; rot\n ; lookup\n ; runtime_tables\n } =\n feature_flags\n in\n assert_false range_check0 ;\n assert_false range_check1 ;\n assert_false foreign_field_add ;\n assert_false foreign_field_mul ;\n assert_false xor ;\n assert_false rot ;\n assert_false lookup ;\n assert_false runtime_tables\n in\n assert_none lookup ;\n { alpha\n ; beta\n ; gamma\n ; zeta\n ; zeta_to_srs_length\n ; zeta_to_domain_size\n ; perm\n }\n\n let map_challenges t ~f ~scalar =\n { t with\n alpha = scalar t.alpha\n ; beta = f t.beta\n ; gamma = f t.gamma\n ; zeta = scalar t.zeta\n }\n\n let map_fields t ~f =\n { t with\n zeta_to_srs_length = f t.zeta_to_srs_length\n ; zeta_to_domain_size = f t.zeta_to_domain_size\n ; perm = f t.perm\n }\n\n let typ (type f fp) _ ~dummy_scalar ~dummy_scalar_challenge ~challenge\n ~scalar_challenge ~bool ~feature_flags\n (fp : (fp, _, f) Snarky_backendless.Typ.t) =\n Snarky_backendless.Typ.of_hlistable\n [ Scalar_challenge.typ scalar_challenge\n ; challenge\n ; challenge\n ; Scalar_challenge.typ scalar_challenge\n ; fp\n ; fp\n ; fp\n ]\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist\n ~value_to_hlist:to_hlist ~value_of_hlist:of_hlist\n end\n\n let to_minimal (type challenge scalar_challenge fp)\n (t : (challenge, scalar_challenge, fp) In_circuit.t) :\n (challenge, scalar_challenge) Minimal.t =\n { alpha = t.alpha; beta = t.beta; zeta = t.zeta; gamma = t.gamma }\n end\n\n (** All the scalar-field values needed to finalize the verification of a proof\n by checking that the correct values were used in the \"group operations\" part of the\n verifier.\n\n Consists of some evaluations of PLONK polynomials (columns, permutation aggregation, etc.)\n and the remainder are things related to the inner product argument.\n*)\n type ('plonk, 'scalar_challenge, 'fq, 'bulletproof_challenges) t_ =\n { plonk : 'plonk\n ; combined_inner_product : 'fq\n (** combined_inner_product = sum_{i < num_evaluation_points} sum_{j < num_polys} r^i xi^j f_j(pt_i) *)\n ; xi : 'scalar_challenge\n (** The challenge used for combining polynomials *)\n ; bulletproof_challenges : 'bulletproof_challenges\n (** The challenges from the inner-product argument that was partially verified. *)\n ; b : 'fq\n (** b = challenge_poly plonk.zeta + r * challenge_poly (domain_generrator * plonk.zeta)\n where challenge_poly(x) = \\prod_i (1 + bulletproof_challenges.(i) * x^{2^{k - 1 - i}})\n *)\n }\n [@@deriving sexp, compare, yojson]\n\n module Minimal = struct\n type ('challenge, 'scalar_challenge, 'fq, 'bulletproof_challenges) t =\n ( ('challenge, 'scalar_challenge) Plonk.Minimal.t\n , 'scalar_challenge\n , 'fq\n , 'bulletproof_challenges )\n t_\n [@@deriving sexp, compare, yojson]\n end\n\n module In_circuit = struct\n type ('challenge, 'scalar_challenge, 'fq, 'bulletproof_challenges) t =\n ( ('challenge, 'scalar_challenge, 'fq) Plonk.In_circuit.t\n , 'scalar_challenge\n , 'fq\n , 'bulletproof_challenges )\n t_\n [@@deriving sexp, compare, yojson]\n end\n end\n\n module Messages_for_next_wrap_proof =\n Wrap.Proof_state.Messages_for_next_wrap_proof\n module Messages_for_next_step_proof = Wrap.Messages_for_next_step_proof\n\n module Per_proof = struct\n (** For each proof that a step circuit verifies, we do not verify the whole proof.\n Specifically,\n - we defer calculations involving the \"other field\" (i.e., the scalar-field of the group\n elements involved in the proof.\n - we do not fully verify the inner-product argument as that would be O(n) and instead\n do the accumulator trick.\n\n As a result, for each proof that a step circuit verifies, we must expose some data\n related to it as part of the step circuit's statement, in order to allow those proofs\n to be fully verified eventually.\n\n This is that data. *)\n type ( 'plonk\n , 'scalar_challenge\n , 'fq\n , 'bulletproof_challenges\n , 'digest\n , 'bool )\n t_ =\n { deferred_values :\n ( 'plonk\n , 'scalar_challenge\n , 'fq\n , 'bulletproof_challenges )\n Deferred_values.t_\n (** Scalar values related to the proof *)\n ; should_finalize : 'bool\n (** We allow circuits in pickles proof systems to decide if it's OK that a proof did\n not recursively verify. In that case, when we expose the unfinalized bits, we need\n to communicate that it's OK if those bits do not \"finalize\". That's what this boolean\n is for. *)\n ; sponge_digest_before_evaluations : 'digest\n }\n [@@deriving sexp, compare, yojson]\n\n module Minimal = struct\n type ( 'challenge\n , 'scalar_challenge\n , 'fq\n , 'bulletproof_challenges\n , 'digest\n , 'bool )\n t =\n ( ('challenge, 'scalar_challenge) Deferred_values.Plonk.Minimal.t\n , 'scalar_challenge\n , 'fq\n , 'bulletproof_challenges\n , 'digest\n , 'bool )\n t_\n [@@deriving sexp, compare, yojson]\n end\n\n module In_circuit = struct\n type ( 'challenge\n , 'scalar_challenge\n , 'fq\n , 'bulletproof_challenges\n , 'digest\n , 'bool )\n t =\n ( ( 'challenge\n , 'scalar_challenge\n , 'fq )\n Deferred_values.Plonk.In_circuit.t\n , 'scalar_challenge\n , 'fq\n , 'bulletproof_challenges\n , 'digest\n , 'bool )\n t_\n [@@deriving sexp, compare, yojson]\n\n (** A layout of the raw data in this value, which is needed for\n representing it inside the circuit. *)\n let spec bp_log2 =\n Spec.T.Struct\n [ Vector (B Field, Nat.N5.n)\n ; Vector (B Digest, Nat.N1.n)\n ; Vector (B Challenge, Nat.N2.n)\n ; Vector (Scalar Challenge, Nat.N3.n)\n ; Vector (B Bulletproof_challenge, bp_log2)\n ; Vector (B Bool, Nat.N1.n)\n ]\n\n let[@warning \"-45\"] to_data\n ({ deferred_values =\n { xi\n ; bulletproof_challenges\n ; b\n ; combined_inner_product\n ; plonk =\n { alpha\n ; beta\n ; gamma\n ; zeta\n ; zeta_to_srs_length\n ; zeta_to_domain_size\n ; perm\n }\n }\n ; should_finalize\n ; sponge_digest_before_evaluations\n } :\n _ t ) =\n let open Vector in\n let fq =\n [ combined_inner_product\n ; b\n ; zeta_to_srs_length\n ; zeta_to_domain_size\n ; perm\n ]\n in\n let challenge = [ beta; gamma ] in\n let scalar_challenge = [ alpha; zeta; xi ] in\n let digest = [ sponge_digest_before_evaluations ] in\n let bool = [ should_finalize ] in\n let open Hlist.HlistId in\n [ fq\n ; digest\n ; challenge\n ; scalar_challenge\n ; bulletproof_challenges\n ; bool\n ]\n\n let[@warning \"-45\"] of_data\n Hlist.HlistId.\n [ Vector.\n [ combined_inner_product\n ; b\n ; zeta_to_srs_length\n ; zeta_to_domain_size\n ; perm\n ]\n ; Vector.[ sponge_digest_before_evaluations ]\n ; Vector.[ beta; gamma ]\n ; Vector.[ alpha; zeta; xi ]\n ; bulletproof_challenges\n ; Vector.[ should_finalize ]\n ] : _ t =\n { deferred_values =\n { xi\n ; bulletproof_challenges\n ; b\n ; combined_inner_product\n ; plonk =\n { alpha\n ; beta\n ; gamma\n ; zeta\n ; zeta_to_srs_length\n ; zeta_to_domain_size\n ; perm\n }\n }\n ; should_finalize\n ; sponge_digest_before_evaluations\n }\n end\n\n let typ impl fq ~assert_16_bits ~zero =\n let open In_circuit in\n Spec.typ impl fq ~assert_16_bits (spec Backend.Tock.Rounds.n)\n |> Snarky_backendless.Typ.transport ~there:to_data ~back:of_data\n |> Snarky_backendless.Typ.transport_var ~there:to_data ~back:of_data\n end\n\n type ('unfinalized_proofs, 'messages_for_next_step_proof) t =\n { unfinalized_proofs : 'unfinalized_proofs\n (** A vector of the \"per-proof\" structures defined above, one for each proof\n that the step-circuit partially verifies. *)\n ; messages_for_next_step_proof : 'messages_for_next_step_proof\n (** The component of the proof accumulation state that is only computed on by the\n \"stepping\" proof system, and that can be handled opaquely by any \"wrap\" circuits. *)\n }\n [@@deriving sexp, compare, yojson, hlist]\n\n let spec unfinalized_proofs messages_for_next_step_proof =\n Spec.T.Struct [ unfinalized_proofs; messages_for_next_step_proof ]\n\n include struct\n open Hlist.HlistId\n\n let _to_data { unfinalized_proofs; messages_for_next_step_proof } =\n [ Vector.map unfinalized_proofs ~f:Per_proof.In_circuit.to_data\n ; messages_for_next_step_proof\n ]\n\n let _of_data [ unfinalized_proofs; messages_for_next_step_proof ] =\n { unfinalized_proofs =\n Vector.map unfinalized_proofs ~f:Per_proof.In_circuit.of_data\n ; messages_for_next_step_proof\n }\n end [@@warning \"-45\"]\n\n let[@warning \"-60\"] typ (type n f)\n ( (module Impl : Snarky_backendless.Snark_intf.Run with type field = f)\n as impl ) zero ~assert_16_bits\n (proofs_verified :\n (Plonk_types.Opt.Flag.t Plonk_types.Features.t, n) Vector.t ) fq :\n ( ((_, _) Vector.t, _) t\n , ((_, _) Vector.t, _) t\n , _ )\n Snarky_backendless.Typ.t =\n let per_proof feature_flags =\n Per_proof.typ impl fq ~assert_16_bits ~zero\n in\n let unfinalized_proofs =\n Vector.typ' (Vector.map proofs_verified ~f:per_proof)\n in\n let messages_for_next_step_proof =\n Spec.typ impl fq ~assert_16_bits (B Spec.Digest)\n in\n Snarky_backendless.Typ.of_hlistable\n [ unfinalized_proofs; messages_for_next_step_proof ]\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist\n end\n\n module Statement = struct\n type ( 'unfinalized_proofs\n , 'messages_for_next_step_proof\n , 'messages_for_next_wrap_proof )\n t =\n { proof_state :\n ('unfinalized_proofs, 'messages_for_next_step_proof) Proof_state.t\n ; messages_for_next_wrap_proof : 'messages_for_next_wrap_proof\n (** The component of the proof accumulation state that is only computed on by the\n \"wrapping\" proof system, and that can be handled opaquely by any \"step\" circuits. *)\n }\n [@@deriving sexp, compare, yojson]\n\n let[@warning \"-45\"] to_data\n { proof_state = { unfinalized_proofs; messages_for_next_step_proof }\n ; messages_for_next_wrap_proof\n } =\n let open Hlist.HlistId in\n [ Vector.map unfinalized_proofs\n ~f:Proof_state.Per_proof.In_circuit.to_data\n ; messages_for_next_step_proof\n ; messages_for_next_wrap_proof\n ]\n\n let[@warning \"-45\"] of_data\n Hlist.HlistId.\n [ unfinalized_proofs\n ; messages_for_next_step_proof\n ; messages_for_next_wrap_proof\n ] =\n { proof_state =\n { unfinalized_proofs =\n Vector.map unfinalized_proofs\n ~f:Proof_state.Per_proof.In_circuit.of_data\n ; messages_for_next_step_proof\n }\n ; messages_for_next_wrap_proof\n }\n\n let spec proofs_verified bp_log2 =\n let per_proof = Proof_state.Per_proof.In_circuit.spec bp_log2 in\n Spec.T.Struct\n [ Vector (per_proof, proofs_verified)\n ; B Digest\n ; Vector (B Digest, proofs_verified)\n ]\n end\nend\n\nmodule Nvector = Vector.With_length\nmodule Wrap_bp_vec = Backend.Tock.Rounds_vector\nmodule Step_bp_vec = Backend.Tick.Rounds_vector\n\nmodule Challenges_vector = struct\n type 'n t =\n (Backend.Tock.Field.t Snarky_backendless.Cvar.t Wrap_bp_vec.t, 'n) Vector.t\n\n module Constant = struct\n type 'n t = (Backend.Tock.Field.t Wrap_bp_vec.t, 'n) Vector.t\n end\nend\n","(* This file is generated by gen_scalars/gen_scalars.exe. *)\n\n(* turn off fragile pattern-matching warning from sexp ppx *)\n[@@@warning \"-4\"]\n\ntype curr_or_next = Curr | Next [@@deriving hash, eq, compare, sexp]\n\nmodule Gate_type = struct\n module T = struct\n type t = Kimchi_types.gate_type =\n | Zero\n | Generic\n | Poseidon\n | CompleteAdd\n | VarBaseMul\n | EndoMul\n | EndoMulScalar\n | Lookup\n | CairoClaim\n | CairoInstruction\n | CairoFlags\n | CairoTransition\n | RangeCheck0\n | RangeCheck1\n | ForeignFieldAdd\n | ForeignFieldMul\n | Xor16\n | Rot64\n [@@deriving hash, eq, compare, sexp]\n end\n\n include Core_kernel.Hashable.Make (T)\n include T\nend\n\nmodule Lookup_pattern = struct\n module T = struct\n type t = Kimchi_types.lookup_pattern =\n | Xor\n | Lookup\n | RangeCheck\n | ForeignFieldMul\n [@@deriving hash, eq, compare, sexp]\n end\n\n include Core_kernel.Hashable.Make (T)\n include T\nend\n\nmodule Column = struct\n open Core_kernel\n\n module T = struct\n type t =\n | Witness of int\n | Index of Gate_type.t\n | Coefficient of int\n | LookupTable\n | LookupSorted of int\n | LookupAggreg\n | LookupKindIndex of Lookup_pattern.t\n | LookupRuntimeSelector\n | LookupRuntimeTable\n [@@deriving hash, eq, compare, sexp]\n end\n\n include Hashable.Make (T)\n include T\nend\n\nopen Gate_type\nopen Column\n\nmodule Env = struct\n type 'a t =\n { add : 'a -> 'a -> 'a\n ; sub : 'a -> 'a -> 'a\n ; mul : 'a -> 'a -> 'a\n ; pow : 'a * int -> 'a\n ; square : 'a -> 'a\n ; zk_polynomial : 'a\n ; omega_to_minus_3 : 'a\n ; zeta_to_n_minus_1 : 'a\n ; var : Column.t * curr_or_next -> 'a\n ; field : string -> 'a\n ; cell : 'a -> 'a\n ; alpha_pow : int -> 'a\n ; double : 'a -> 'a\n ; endo_coefficient : 'a\n ; mds : int * int -> 'a\n ; srs_length_log2 : int\n ; vanishes_on_last_4_rows : 'a\n ; joint_combiner : 'a\n ; beta : 'a\n ; gamma : 'a\n ; unnormalized_lagrange_basis : int -> 'a\n ; if_feature : Kimchi_types.feature_flag * (unit -> 'a) * (unit -> 'a) -> 'a\n }\nend\n\nmodule type S = sig\n val constant_term : 'a Env.t -> 'a\n\n val index_terms : 'a Env.t -> 'a Lazy.t Column.Table.t\nend\n\n(* The constraints are basically the same, but the literals in them differ. *)\nmodule Tick : S = struct\n let constant_term (type a)\n ({ add = ( + )\n ; sub = ( - )\n ; mul = ( * )\n ; square\n ; mds\n ; endo_coefficient\n ; pow\n ; var\n ; field\n ; cell\n ; alpha_pow\n ; double\n ; zk_polynomial = _\n ; omega_to_minus_3 = _\n ; zeta_to_n_minus_1 = _\n ; srs_length_log2 = _\n ; vanishes_on_last_4_rows\n ; joint_combiner\n ; beta\n ; gamma\n ; unnormalized_lagrange_basis\n ; if_feature\n } :\n a Env.t ) =\n let x_0 = pow (cell (var (Witness 0, Curr)), 7) in\n let x_1 = pow (cell (var (Witness 1, Curr)), 7) in\n let x_2 = pow (cell (var (Witness 2, Curr)), 7) in\n let x_3 = pow (cell (var (Witness 6, Curr)), 7) in\n let x_4 = pow (cell (var (Witness 7, Curr)), 7) in\n let x_5 = pow (cell (var (Witness 8, Curr)), 7) in\n let x_6 = pow (cell (var (Witness 9, Curr)), 7) in\n let x_7 = pow (cell (var (Witness 10, Curr)), 7) in\n let x_8 = pow (cell (var (Witness 11, Curr)), 7) in\n let x_9 = pow (cell (var (Witness 12, Curr)), 7) in\n let x_10 = pow (cell (var (Witness 13, Curr)), 7) in\n let x_11 = pow (cell (var (Witness 14, Curr)), 7) in\n let x_12 = pow (cell (var (Witness 3, Curr)), 7) in\n let x_13 = pow (cell (var (Witness 4, Curr)), 7) in\n let x_14 = pow (cell (var (Witness 5, Curr)), 7) in\n let x_15 = cell (var (Witness 7, Next)) * cell (var (Witness 7, Next)) in\n let x_16 =\n let x_15 = cell (var (Witness 7, Next)) * cell (var (Witness 7, Next)) in\n cell (var (Witness 2, Curr))\n - (x_15 - cell (var (Witness 2, Curr)) - cell (var (Witness 0, Curr)))\n in\n let x_17 =\n let x_16 =\n let x_15 =\n cell (var (Witness 7, Next)) * cell (var (Witness 7, Next))\n in\n cell (var (Witness 2, Curr))\n - (x_15 - cell (var (Witness 2, Curr)) - cell (var (Witness 0, Curr)))\n in\n double (cell (var (Witness 3, Curr)))\n - (x_16 * cell (var (Witness 7, Next)))\n in\n let x_18 = cell (var (Witness 8, Next)) * cell (var (Witness 8, Next)) in\n let x_19 =\n let x_18 = cell (var (Witness 8, Next)) * cell (var (Witness 8, Next)) in\n cell (var (Witness 7, Curr))\n - (x_18 - cell (var (Witness 7, Curr)) - cell (var (Witness 0, Curr)))\n in\n let x_20 =\n let x_19 =\n let x_18 =\n cell (var (Witness 8, Next)) * cell (var (Witness 8, Next))\n in\n cell (var (Witness 7, Curr))\n - (x_18 - cell (var (Witness 7, Curr)) - cell (var (Witness 0, Curr)))\n in\n double (cell (var (Witness 8, Curr)))\n - (x_19 * cell (var (Witness 8, Next)))\n in\n let x_21 = cell (var (Witness 9, Next)) * cell (var (Witness 9, Next)) in\n let x_22 =\n let x_21 = cell (var (Witness 9, Next)) * cell (var (Witness 9, Next)) in\n cell (var (Witness 9, Curr))\n - (x_21 - cell (var (Witness 9, Curr)) - cell (var (Witness 0, Curr)))\n in\n let x_23 =\n let x_22 =\n let x_21 =\n cell (var (Witness 9, Next)) * cell (var (Witness 9, Next))\n in\n cell (var (Witness 9, Curr))\n - (x_21 - cell (var (Witness 9, Curr)) - cell (var (Witness 0, Curr)))\n in\n double (cell (var (Witness 10, Curr)))\n - (x_22 * cell (var (Witness 9, Next)))\n in\n let x_24 = cell (var (Witness 10, Next)) * cell (var (Witness 10, Next)) in\n let x_25 =\n let x_24 =\n cell (var (Witness 10, Next)) * cell (var (Witness 10, Next))\n in\n cell (var (Witness 11, Curr))\n - (x_24 - cell (var (Witness 11, Curr)) - cell (var (Witness 0, Curr)))\n in\n let x_26 =\n let x_25 =\n let x_24 =\n cell (var (Witness 10, Next)) * cell (var (Witness 10, Next))\n in\n cell (var (Witness 11, Curr))\n - (x_24 - cell (var (Witness 11, Curr)) - cell (var (Witness 0, Curr)))\n in\n double (cell (var (Witness 12, Curr)))\n - (x_25 * cell (var (Witness 10, Next)))\n in\n let x_27 = cell (var (Witness 11, Next)) * cell (var (Witness 11, Next)) in\n let x_28 =\n let x_27 =\n cell (var (Witness 11, Next)) * cell (var (Witness 11, Next))\n in\n cell (var (Witness 13, Curr))\n - (x_27 - cell (var (Witness 13, Curr)) - cell (var (Witness 0, Curr)))\n in\n let x_29 =\n let x_28 =\n let x_27 =\n cell (var (Witness 11, Next)) * cell (var (Witness 11, Next))\n in\n cell (var (Witness 13, Curr))\n - (x_27 - cell (var (Witness 13, Curr)) - cell (var (Witness 0, Curr)))\n in\n double (cell (var (Witness 14, Curr)))\n - (x_28 * cell (var (Witness 11, Next)))\n in\n let x_30 = cell (var (Witness 2, Curr)) - cell (var (Witness 0, Curr)) in\n let x_31 = cell (var (Witness 3, Curr)) - cell (var (Witness 1, Curr)) in\n let x_32 = cell (var (Witness 0, Curr)) * cell (var (Witness 0, Curr)) in\n let x_33 =\n ( field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n + cell (var (Witness 11, Curr))\n * ( endo_coefficient\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n ) )\n * cell (var (Witness 0, Curr))\n in\n let x_34 =\n ( field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n + cell (var (Witness 13, Curr))\n * ( endo_coefficient\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n ) )\n * cell (var (Witness 0, Curr))\n in\n let x_35 = square (cell (var (Witness 9, Curr))) in\n let x_36 = square (cell (var (Witness 10, Curr))) in\n let x_37 = cell (var (Witness 4, Curr)) - cell (var (Witness 7, Curr)) in\n let x_38 = cell (var (Witness 7, Curr)) - cell (var (Witness 4, Next)) in\n let x_39 = cell (var (Witness 5, Next)) + cell (var (Witness 8, Curr)) in\n let x_40 = cell (var (Witness 8, Curr)) + cell (var (Witness 5, Curr)) in\n let x_41 =\n ( ( field\n \"0x1555555555555555555555555555555560C232FEADC45309330F104F00000001\"\n * cell (var (Witness 6, Curr))\n + field\n \"0x2000000000000000000000000000000011234C7E04A67C8DCC9698767FFFFFFE\"\n )\n * cell (var (Witness 6, Curr))\n + field\n \"0x0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB061197F56E229849987882780000002\"\n )\n * cell (var (Witness 6, Curr))\n in\n let x_42 =\n ( ( field\n \"0x1555555555555555555555555555555560C232FEADC45309330F104F00000001\"\n * cell (var (Witness 7, Curr))\n + field\n \"0x2000000000000000000000000000000011234C7E04A67C8DCC9698767FFFFFFE\"\n )\n * cell (var (Witness 7, Curr))\n + field\n \"0x0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB061197F56E229849987882780000002\"\n )\n * cell (var (Witness 7, Curr))\n in\n let x_43 =\n ( ( field\n \"0x1555555555555555555555555555555560C232FEADC45309330F104F00000001\"\n * cell (var (Witness 8, Curr))\n + field\n \"0x2000000000000000000000000000000011234C7E04A67C8DCC9698767FFFFFFE\"\n )\n * cell (var (Witness 8, Curr))\n + field\n \"0x0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB061197F56E229849987882780000002\"\n )\n * cell (var (Witness 8, Curr))\n in\n let x_44 =\n ( ( field\n \"0x1555555555555555555555555555555560C232FEADC45309330F104F00000001\"\n * cell (var (Witness 9, Curr))\n + field\n \"0x2000000000000000000000000000000011234C7E04A67C8DCC9698767FFFFFFE\"\n )\n * cell (var (Witness 9, Curr))\n + field\n \"0x0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB061197F56E229849987882780000002\"\n )\n * cell (var (Witness 9, Curr))\n in\n let x_45 =\n ( ( field\n \"0x1555555555555555555555555555555560C232FEADC45309330F104F00000001\"\n * cell (var (Witness 10, Curr))\n + field\n \"0x2000000000000000000000000000000011234C7E04A67C8DCC9698767FFFFFFE\"\n )\n * cell (var (Witness 10, Curr))\n + field\n \"0x0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB061197F56E229849987882780000002\"\n )\n * cell (var (Witness 10, Curr))\n in\n let x_46 =\n ( ( field\n \"0x1555555555555555555555555555555560C232FEADC45309330F104F00000001\"\n * cell (var (Witness 11, Curr))\n + field\n \"0x2000000000000000000000000000000011234C7E04A67C8DCC9698767FFFFFFE\"\n )\n * cell (var (Witness 11, Curr))\n + field\n \"0x0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB061197F56E229849987882780000002\"\n )\n * cell (var (Witness 11, Curr))\n in\n let x_47 =\n ( ( field\n \"0x1555555555555555555555555555555560C232FEADC45309330F104F00000001\"\n * cell (var (Witness 12, Curr))\n + field\n \"0x2000000000000000000000000000000011234C7E04A67C8DCC9698767FFFFFFE\"\n )\n * cell (var (Witness 12, Curr))\n + field\n \"0x0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB061197F56E229849987882780000002\"\n )\n * cell (var (Witness 12, Curr))\n in\n let x_48 =\n ( ( field\n \"0x1555555555555555555555555555555560C232FEADC45309330F104F00000001\"\n * cell (var (Witness 13, Curr))\n + field\n \"0x2000000000000000000000000000000011234C7E04A67C8DCC9698767FFFFFFE\"\n )\n * cell (var (Witness 13, Curr))\n + field\n \"0x0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB061197F56E229849987882780000002\"\n )\n * cell (var (Witness 13, Curr))\n in\n cell (var (Index Poseidon, Curr))\n * ( cell (var (Witness 6, Curr))\n - ( cell (var (Coefficient 0, Curr))\n + (mds (0, 0) * x_0)\n + (mds (0, 1) * x_1)\n + (mds (0, 2) * x_2) )\n + alpha_pow 1\n * ( cell (var (Witness 7, Curr))\n - ( cell (var (Coefficient 1, Curr))\n + (mds (1, 0) * x_0)\n + (mds (1, 1) * x_1)\n + (mds (1, 2) * x_2) ) )\n + alpha_pow 2\n * ( cell (var (Witness 8, Curr))\n - ( cell (var (Coefficient 2, Curr))\n + (mds (2, 0) * x_0)\n + (mds (2, 1) * x_1)\n + (mds (2, 2) * x_2) ) )\n + alpha_pow 3\n * ( cell (var (Witness 9, Curr))\n - ( cell (var (Coefficient 3, Curr))\n + (mds (0, 0) * x_3)\n + (mds (0, 1) * x_4)\n + (mds (0, 2) * x_5) ) )\n + alpha_pow 4\n * ( cell (var (Witness 10, Curr))\n - ( cell (var (Coefficient 4, Curr))\n + (mds (1, 0) * x_3)\n + (mds (1, 1) * x_4)\n + (mds (1, 2) * x_5) ) )\n + alpha_pow 5\n * ( cell (var (Witness 11, Curr))\n - ( cell (var (Coefficient 5, Curr))\n + (mds (2, 0) * x_3)\n + (mds (2, 1) * x_4)\n + (mds (2, 2) * x_5) ) )\n + alpha_pow 6\n * ( cell (var (Witness 12, Curr))\n - ( cell (var (Coefficient 6, Curr))\n + (mds (0, 0) * x_6)\n + (mds (0, 1) * x_7)\n + (mds (0, 2) * x_8) ) )\n + alpha_pow 7\n * ( cell (var (Witness 13, Curr))\n - ( cell (var (Coefficient 7, Curr))\n + (mds (1, 0) * x_6)\n + (mds (1, 1) * x_7)\n + (mds (1, 2) * x_8) ) )\n + alpha_pow 8\n * ( cell (var (Witness 14, Curr))\n - ( cell (var (Coefficient 8, Curr))\n + (mds (2, 0) * x_6)\n + (mds (2, 1) * x_7)\n + (mds (2, 2) * x_8) ) )\n + alpha_pow 9\n * ( cell (var (Witness 3, Curr))\n - ( cell (var (Coefficient 9, Curr))\n + (mds (0, 0) * x_9)\n + (mds (0, 1) * x_10)\n + (mds (0, 2) * x_11) ) )\n + alpha_pow 10\n * ( cell (var (Witness 4, Curr))\n - ( cell (var (Coefficient 10, Curr))\n + (mds (1, 0) * x_9)\n + (mds (1, 1) * x_10)\n + (mds (1, 2) * x_11) ) )\n + alpha_pow 11\n * ( cell (var (Witness 5, Curr))\n - ( cell (var (Coefficient 11, Curr))\n + (mds (2, 0) * x_9)\n + (mds (2, 1) * x_10)\n + (mds (2, 2) * x_11) ) )\n + alpha_pow 12\n * ( cell (var (Witness 0, Next))\n - ( cell (var (Coefficient 12, Curr))\n + (mds (0, 0) * x_12)\n + (mds (0, 1) * x_13)\n + (mds (0, 2) * x_14) ) )\n + alpha_pow 13\n * ( cell (var (Witness 1, Next))\n - ( cell (var (Coefficient 13, Curr))\n + (mds (1, 0) * x_12)\n + (mds (1, 1) * x_13)\n + (mds (1, 2) * x_14) ) )\n + alpha_pow 14\n * ( cell (var (Witness 2, Next))\n - ( cell (var (Coefficient 14, Curr))\n + (mds (2, 0) * x_12)\n + (mds (2, 1) * x_13)\n + (mds (2, 2) * x_14) ) ) )\n + cell (var (Index VarBaseMul, Curr))\n * ( cell (var (Witness 5, Curr))\n - ( cell (var (Witness 6, Next))\n + double\n ( cell (var (Witness 5, Next))\n + double\n ( cell (var (Witness 4, Next))\n + double\n ( cell (var (Witness 3, Next))\n + double\n ( cell (var (Witness 2, Next))\n + double (cell (var (Witness 4, Curr))) ) ) ) ) )\n + alpha_pow 1\n * ( square (cell (var (Witness 2, Next)))\n - cell (var (Witness 2, Next)) )\n + alpha_pow 2\n * ( (cell (var (Witness 2, Curr)) - cell (var (Witness 0, Curr)))\n * cell (var (Witness 7, Next))\n - ( cell (var (Witness 3, Curr))\n - ( double (cell (var (Witness 2, Next)))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * cell (var (Witness 1, Curr)) ) )\n + alpha_pow 3\n * ( (x_17 * x_17)\n - x_16 * x_16\n * ( cell (var (Witness 7, Curr))\n - cell (var (Witness 0, Curr))\n + x_15 ) )\n + alpha_pow 4\n * ( (cell (var (Witness 8, Curr)) + cell (var (Witness 3, Curr)))\n * x_16\n - (cell (var (Witness 2, Curr)) - cell (var (Witness 7, Curr)))\n * x_17 )\n + alpha_pow 5\n * ( square (cell (var (Witness 3, Next)))\n - cell (var (Witness 3, Next)) )\n + alpha_pow 6\n * ( (cell (var (Witness 7, Curr)) - cell (var (Witness 0, Curr)))\n * cell (var (Witness 8, Next))\n - ( cell (var (Witness 8, Curr))\n - ( double (cell (var (Witness 3, Next)))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * cell (var (Witness 1, Curr)) ) )\n + alpha_pow 7\n * ( (x_20 * x_20)\n - x_19 * x_19\n * ( cell (var (Witness 9, Curr))\n - cell (var (Witness 0, Curr))\n + x_18 ) )\n + alpha_pow 8\n * ( (cell (var (Witness 10, Curr)) + cell (var (Witness 8, Curr)))\n * x_19\n - (cell (var (Witness 7, Curr)) - cell (var (Witness 9, Curr)))\n * x_20 )\n + alpha_pow 9\n * ( square (cell (var (Witness 4, Next)))\n - cell (var (Witness 4, Next)) )\n + alpha_pow 10\n * ( (cell (var (Witness 9, Curr)) - cell (var (Witness 0, Curr)))\n * cell (var (Witness 9, Next))\n - ( cell (var (Witness 10, Curr))\n - ( double (cell (var (Witness 4, Next)))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * cell (var (Witness 1, Curr)) ) )\n + alpha_pow 11\n * ( (x_23 * x_23)\n - x_22 * x_22\n * ( cell (var (Witness 11, Curr))\n - cell (var (Witness 0, Curr))\n + x_21 ) )\n + alpha_pow 12\n * ( (cell (var (Witness 12, Curr)) + cell (var (Witness 10, Curr)))\n * x_22\n - (cell (var (Witness 9, Curr)) - cell (var (Witness 11, Curr)))\n * x_23 )\n + alpha_pow 13\n * ( square (cell (var (Witness 5, Next)))\n - cell (var (Witness 5, Next)) )\n + alpha_pow 14\n * ( (cell (var (Witness 11, Curr)) - cell (var (Witness 0, Curr)))\n * cell (var (Witness 10, Next))\n - ( cell (var (Witness 12, Curr))\n - ( double (cell (var (Witness 5, Next)))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * cell (var (Witness 1, Curr)) ) )\n + alpha_pow 15\n * ( (x_26 * x_26)\n - x_25 * x_25\n * ( cell (var (Witness 13, Curr))\n - cell (var (Witness 0, Curr))\n + x_24 ) )\n + alpha_pow 16\n * ( (cell (var (Witness 14, Curr)) + cell (var (Witness 12, Curr)))\n * x_25\n - (cell (var (Witness 11, Curr)) - cell (var (Witness 13, Curr)))\n * x_26 )\n + alpha_pow 17\n * ( square (cell (var (Witness 6, Next)))\n - cell (var (Witness 6, Next)) )\n + alpha_pow 18\n * ( (cell (var (Witness 13, Curr)) - cell (var (Witness 0, Curr)))\n * cell (var (Witness 11, Next))\n - ( cell (var (Witness 14, Curr))\n - ( double (cell (var (Witness 6, Next)))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * cell (var (Witness 1, Curr)) ) )\n + alpha_pow 19\n * ( (x_29 * x_29)\n - x_28 * x_28\n * ( cell (var (Witness 0, Next))\n - cell (var (Witness 0, Curr))\n + x_27 ) )\n + alpha_pow 20\n * ( (cell (var (Witness 1, Next)) + cell (var (Witness 14, Curr)))\n * x_28\n - (cell (var (Witness 13, Curr)) - cell (var (Witness 0, Next)))\n * x_29 ) )\n + cell (var (Index CompleteAdd, Curr))\n * ( (cell (var (Witness 10, Curr)) * x_30)\n - ( field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n - cell (var (Witness 7, Curr)) )\n + (alpha_pow 1 * (cell (var (Witness 7, Curr)) * x_30))\n + alpha_pow 2\n * ( cell (var (Witness 7, Curr))\n * ( double (cell (var (Witness 8, Curr)))\n * cell (var (Witness 1, Curr))\n - double x_32 - x_32 )\n + ( field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n - cell (var (Witness 7, Curr)) )\n * ((x_30 * cell (var (Witness 8, Curr))) - x_31) )\n + alpha_pow 3\n * ( cell (var (Witness 0, Curr))\n + cell (var (Witness 2, Curr))\n + cell (var (Witness 4, Curr))\n - (cell (var (Witness 8, Curr)) * cell (var (Witness 8, Curr))) )\n + alpha_pow 4\n * ( cell (var (Witness 8, Curr))\n * (cell (var (Witness 0, Curr)) - cell (var (Witness 4, Curr)))\n - cell (var (Witness 1, Curr))\n - cell (var (Witness 5, Curr)) )\n + alpha_pow 5\n * ( x_31\n * (cell (var (Witness 7, Curr)) - cell (var (Witness 6, Curr))) )\n + alpha_pow 6\n * ( (x_31 * cell (var (Witness 9, Curr)))\n - cell (var (Witness 6, Curr)) ) )\n + cell (var (Index EndoMul, Curr))\n * ( square (cell (var (Witness 11, Curr)))\n - cell (var (Witness 11, Curr))\n + alpha_pow 1\n * ( square (cell (var (Witness 12, Curr)))\n - cell (var (Witness 12, Curr)) )\n + alpha_pow 2\n * ( square (cell (var (Witness 13, Curr)))\n - cell (var (Witness 13, Curr)) )\n + alpha_pow 3\n * ( square (cell (var (Witness 14, Curr)))\n - cell (var (Witness 14, Curr)) )\n + alpha_pow 4\n * ( (x_33 - cell (var (Witness 4, Curr)))\n * cell (var (Witness 9, Curr))\n - ( ( double (cell (var (Witness 12, Curr)))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * cell (var (Witness 1, Curr))\n - cell (var (Witness 5, Curr)) ) )\n + alpha_pow 5\n * ( (double (cell (var (Witness 4, Curr))) - x_35 + x_33)\n * ((x_37 * cell (var (Witness 9, Curr))) + x_40)\n - (double (cell (var (Witness 5, Curr))) * x_37) )\n + alpha_pow 6\n * ( square x_40\n - (square x_37 * (x_35 - x_33 + cell (var (Witness 7, Curr)))) )\n + alpha_pow 7\n * ( (x_34 - cell (var (Witness 7, Curr)))\n * cell (var (Witness 10, Curr))\n - ( ( double (cell (var (Witness 14, Curr)))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * cell (var (Witness 1, Curr))\n - cell (var (Witness 8, Curr)) ) )\n + alpha_pow 8\n * ( (double (cell (var (Witness 7, Curr))) - x_36 + x_34)\n * ((x_38 * cell (var (Witness 10, Curr))) + x_39)\n - (double (cell (var (Witness 8, Curr))) * x_38) )\n + alpha_pow 9\n * ( square x_39\n - (square x_38 * (x_36 - x_34 + cell (var (Witness 4, Next)))) )\n + alpha_pow 10\n * ( double\n ( double\n ( double\n ( double (cell (var (Witness 6, Curr)))\n + cell (var (Witness 11, Curr)) )\n + cell (var (Witness 12, Curr)) )\n + cell (var (Witness 13, Curr)) )\n + cell (var (Witness 14, Curr))\n - cell (var (Witness 6, Next)) ) )\n + cell (var (Index EndoMulScalar, Curr))\n * ( double\n (double\n ( double\n (double\n ( double\n (double\n ( double\n (double\n ( double\n (double\n ( double\n (double\n ( double\n (double\n ( double\n (double\n (cell\n (var\n ( Witness 0\n , Curr ) ) ) )\n + cell\n (var\n (Witness 6, Curr) )\n ) )\n + cell (var (Witness 7, Curr))\n ) )\n + cell (var (Witness 8, Curr)) ) )\n + cell (var (Witness 9, Curr)) ) )\n + cell (var (Witness 10, Curr)) ) )\n + cell (var (Witness 11, Curr)) ) )\n + cell (var (Witness 12, Curr)) ) )\n + cell (var (Witness 13, Curr))\n - cell (var (Witness 1, Curr))\n + alpha_pow 1\n * ( double\n ( double\n ( double\n ( double\n ( double\n ( double\n ( double\n ( double (cell (var (Witness 2, Curr)))\n + x_41 )\n + x_42 )\n + x_43 )\n + x_44 )\n + x_45 )\n + x_46 )\n + x_47 )\n + x_48\n - cell (var (Witness 4, Curr)) )\n + alpha_pow 2\n * ( double\n ( double\n ( double\n ( double\n ( double\n ( double\n ( double\n ( double (cell (var (Witness 3, Curr)))\n + ( x_41\n + ( ( field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ED00000000\"\n * cell (var (Witness 6, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n )\n * cell (var (Witness 6, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ED00000000\"\n ) ) )\n + ( x_42\n + ( ( field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ED00000000\"\n * cell (var (Witness 7, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n )\n * cell (var (Witness 7, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ED00000000\"\n ) ) )\n + ( x_43\n + ( ( field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ED00000000\"\n * cell (var (Witness 8, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n )\n * cell (var (Witness 8, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ED00000000\"\n ) ) )\n + ( x_44\n + ( ( field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ED00000000\"\n * cell (var (Witness 9, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n )\n * cell (var (Witness 9, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ED00000000\"\n ) ) )\n + ( x_45\n + ( ( field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ED00000000\"\n * cell (var (Witness 10, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n )\n * cell (var (Witness 10, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ED00000000\"\n ) ) )\n + ( x_46\n + ( ( field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ED00000000\"\n * cell (var (Witness 11, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n )\n * cell (var (Witness 11, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ED00000000\"\n ) ) )\n + ( x_47\n + ( ( field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ED00000000\"\n * cell (var (Witness 12, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n )\n * cell (var (Witness 12, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ED00000000\"\n ) ) )\n + ( x_48\n + ( ( field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ED00000000\"\n * cell (var (Witness 13, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n )\n * cell (var (Witness 13, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ED00000000\"\n ) )\n - cell (var (Witness 5, Curr)) )\n + alpha_pow 3\n * ( ( ( ( cell (var (Witness 6, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ECFFFFFFFB\"\n )\n * cell (var (Witness 6, Curr))\n + field\n \"0x000000000000000000000000000000000000000000000000000000000000000B\"\n )\n * cell (var (Witness 6, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ECFFFFFFFB\"\n )\n * cell (var (Witness 6, Curr)) )\n + alpha_pow 4\n * ( ( ( ( cell (var (Witness 7, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ECFFFFFFFB\"\n )\n * cell (var (Witness 7, Curr))\n + field\n \"0x000000000000000000000000000000000000000000000000000000000000000B\"\n )\n * cell (var (Witness 7, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ECFFFFFFFB\"\n )\n * cell (var (Witness 7, Curr)) )\n + alpha_pow 5\n * ( ( ( ( cell (var (Witness 8, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ECFFFFFFFB\"\n )\n * cell (var (Witness 8, Curr))\n + field\n \"0x000000000000000000000000000000000000000000000000000000000000000B\"\n )\n * cell (var (Witness 8, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ECFFFFFFFB\"\n )\n * cell (var (Witness 8, Curr)) )\n + alpha_pow 6\n * ( ( ( ( cell (var (Witness 9, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ECFFFFFFFB\"\n )\n * cell (var (Witness 9, Curr))\n + field\n \"0x000000000000000000000000000000000000000000000000000000000000000B\"\n )\n * cell (var (Witness 9, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ECFFFFFFFB\"\n )\n * cell (var (Witness 9, Curr)) )\n + alpha_pow 7\n * ( ( ( ( cell (var (Witness 10, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ECFFFFFFFB\"\n )\n * cell (var (Witness 10, Curr))\n + field\n \"0x000000000000000000000000000000000000000000000000000000000000000B\"\n )\n * cell (var (Witness 10, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ECFFFFFFFB\"\n )\n * cell (var (Witness 10, Curr)) )\n + alpha_pow 8\n * ( ( ( ( cell (var (Witness 11, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ECFFFFFFFB\"\n )\n * cell (var (Witness 11, Curr))\n + field\n \"0x000000000000000000000000000000000000000000000000000000000000000B\"\n )\n * cell (var (Witness 11, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ECFFFFFFFB\"\n )\n * cell (var (Witness 11, Curr)) )\n + alpha_pow 9\n * ( ( ( ( cell (var (Witness 12, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ECFFFFFFFB\"\n )\n * cell (var (Witness 12, Curr))\n + field\n \"0x000000000000000000000000000000000000000000000000000000000000000B\"\n )\n * cell (var (Witness 12, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ECFFFFFFFB\"\n )\n * cell (var (Witness 12, Curr)) )\n + alpha_pow 10\n * ( ( ( ( cell (var (Witness 13, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ECFFFFFFFB\"\n )\n * cell (var (Witness 13, Curr))\n + field\n \"0x000000000000000000000000000000000000000000000000000000000000000B\"\n )\n * cell (var (Witness 13, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC094CF91B992D30ECFFFFFFFB\"\n )\n * cell (var (Witness 13, Curr)) ) )\n + if_feature\n ( RangeCheck0\n , (fun () ->\n cell (var (Index RangeCheck0, Curr))\n * ( cell (var (Witness 7, Curr))\n * ( cell (var (Witness 7, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 7, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 7, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n )\n + alpha_pow 1\n * ( cell (var (Witness 8, Curr))\n * ( cell (var (Witness 8, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 8, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 8, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 2\n * ( cell (var (Witness 9, Curr))\n * ( cell (var (Witness 9, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 9, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 9, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 3\n * ( cell (var (Witness 10, Curr))\n * ( cell (var (Witness 10, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 10, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 10, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 4\n * ( cell (var (Witness 11, Curr))\n * ( cell (var (Witness 11, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 11, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 11, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 5\n * ( cell (var (Witness 12, Curr))\n * ( cell (var (Witness 12, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 12, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 12, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 6\n * ( cell (var (Witness 13, Curr))\n * ( cell (var (Witness 13, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 13, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 13, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 7\n * ( cell (var (Witness 14, Curr))\n * ( cell (var (Witness 14, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 14, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 14, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 8\n * ( cell (var (Witness 14, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 13, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 12, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 11, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 10, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 9, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 8, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 7, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 6, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * cell (var (Witness 5, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * cell (var (Witness 4, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * cell (var (Witness 3, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * cell (var (Witness 2, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * cell (var (Witness 1, Curr))\n - cell (var (Witness 0, Curr)) )\n + alpha_pow 9\n * ( cell (var (Coefficient 0, Curr))\n * ( cell (var (Witness 1, Next))\n - ( cell (var (Witness 0, Curr))\n + field\n \"0x0000000000000000000000000000000000000000010000000000000000000000\"\n * cell (var (Witness 0, Next)) ) ) ) ) )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000000\"\n )\n + if_feature\n ( RangeCheck1\n , (fun () ->\n cell (var (Index RangeCheck1, Curr))\n * ( cell (var (Witness 2, Curr))\n * ( cell (var (Witness 2, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 2, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 2, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n )\n + alpha_pow 1\n * ( cell (var (Witness 7, Curr))\n * ( cell (var (Witness 7, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 7, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 7, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 2\n * ( cell (var (Witness 8, Curr))\n * ( cell (var (Witness 8, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 8, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 8, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 3\n * ( cell (var (Witness 9, Curr))\n * ( cell (var (Witness 9, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 9, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 9, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 4\n * ( cell (var (Witness 10, Curr))\n * ( cell (var (Witness 10, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 10, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 10, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 5\n * ( cell (var (Witness 11, Curr))\n * ( cell (var (Witness 11, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 11, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 11, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 6\n * ( cell (var (Witness 12, Curr))\n * ( cell (var (Witness 12, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 12, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 12, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 7\n * ( cell (var (Witness 13, Curr))\n * ( cell (var (Witness 13, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 13, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 13, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 8\n * ( cell (var (Witness 14, Curr))\n * ( cell (var (Witness 14, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 14, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 14, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 9\n * ( cell (var (Witness 0, Next))\n * ( cell (var (Witness 0, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 0, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 0, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 10\n * ( cell (var (Witness 1, Next))\n * ( cell (var (Witness 1, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 1, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 1, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 11\n * ( cell (var (Witness 2, Next))\n * ( cell (var (Witness 2, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 2, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 2, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 12\n * ( cell (var (Witness 7, Next))\n * ( cell (var (Witness 7, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 7, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 7, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 13\n * ( cell (var (Witness 8, Next))\n * ( cell (var (Witness 8, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 8, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 8, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 14\n * ( cell (var (Witness 9, Next))\n * ( cell (var (Witness 9, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 9, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 9, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 15\n * ( cell (var (Witness 10, Next))\n * ( cell (var (Witness 10, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 10, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 10, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 16\n * ( cell (var (Witness 11, Next))\n * ( cell (var (Witness 11, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 11, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 11, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 17\n * ( cell (var (Witness 12, Next))\n * ( cell (var (Witness 12, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 12, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 12, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 18\n * ( cell (var (Witness 13, Next))\n * ( cell (var (Witness 13, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 13, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 13, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 19\n * ( cell (var (Witness 14, Next))\n * ( cell (var (Witness 14, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 14, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 14, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 20\n * ( cell (var (Witness 14, Next))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 13, Next))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 12, Next))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 11, Next))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 10, Next))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 9, Next))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 8, Next))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 7, Next))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 2, Next))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 1, Next))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 0, Next))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 14, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 13, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 12, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 11, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 10, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 9, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 8, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 7, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 6, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * cell (var (Witness 5, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * cell (var (Witness 4, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * cell (var (Witness 3, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * cell (var (Witness 2, Curr))\n - cell (var (Witness 0, Curr)) ) ) )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000000\"\n )\n + if_feature\n ( ForeignFieldAdd\n , (fun () ->\n cell (var (Index ForeignFieldAdd, Curr))\n * ( cell (var (Witness 6, Curr))\n * ( cell (var (Witness 6, Curr))\n - cell (var (Coefficient 3, Curr)) )\n + alpha_pow 1\n * ( cell (var (Witness 7, Curr))\n * ( cell (var (Witness 7, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 7, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n ) )\n + alpha_pow 2\n * ( cell (var (Witness 0, Curr))\n + cell (var (Witness 1, Curr))\n * field\n \"0x0000000000000000000000000000000000000000010000000000000000000000\"\n + cell (var (Coefficient 3, Curr))\n * ( cell (var (Witness 3, Curr))\n + cell (var (Witness 4, Curr))\n * field\n \"0x0000000000000000000000000000000000000000010000000000000000000000\"\n )\n - cell (var (Witness 6, Curr))\n * ( cell (var (Coefficient 0, Curr))\n + cell (var (Coefficient 1, Curr))\n * field\n \"0x0000000000000000000000000000000000000000010000000000000000000000\"\n )\n - cell (var (Witness 7, Curr))\n * field\n \"0x0000000000000000000100000000000000000000000000000000000000000000\"\n - ( cell (var (Witness 0, Next))\n + cell (var (Witness 1, Next))\n * field\n \"0x0000000000000000000000000000000000000000010000000000000000000000\"\n ) )\n + alpha_pow 3\n * ( cell (var (Witness 2, Curr))\n + cell (var (Coefficient 3, Curr))\n * cell (var (Witness 5, Curr))\n - cell (var (Witness 6, Curr))\n * cell (var (Coefficient 2, Curr))\n + cell (var (Witness 7, Curr))\n - cell (var (Witness 2, Next)) ) ) )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000000\"\n )\n + if_feature\n ( ForeignFieldMul\n , (fun () ->\n cell (var (Index ForeignFieldMul, Curr))\n * ( cell (var (Witness 7, Next))\n * ( cell (var (Witness 7, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 7, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 7, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n )\n + alpha_pow 1\n * ( cell (var (Witness 11, Next))\n * ( cell (var (Witness 11, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 11, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 11, Next))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 2\n * ( (cell (var (Witness 0, Curr)) * cell (var (Witness 4, Curr)))\n + (cell (var (Witness 1, Curr)) * cell (var (Witness 3, Curr)))\n + cell (var (Witness 2, Next))\n * cell (var (Coefficient 2, Curr))\n + cell (var (Witness 3, Next))\n * cell (var (Coefficient 1, Curr))\n - ( field\n \"0x0000000000000000000000000000000000000000010000000000000000000000\"\n * ( field\n \"0x0000000000000000000000000000000000000000010000000000000000000000\"\n * cell (var (Witness 7, Next))\n + cell (var (Witness 6, Next)) )\n + cell (var (Witness 6, Curr)) ) )\n + alpha_pow 3\n * ( field\n \"0x0000000000000000000100000000000000000000000000000000000000000000\"\n * cell (var (Witness 11, Next))\n - ( cell (var (Witness 0, Curr))\n * cell (var (Witness 3, Curr))\n + cell (var (Witness 2, Next))\n * cell (var (Coefficient 1, Curr))\n + field\n \"0x0000000000000000000000000000000000000000010000000000000000000000\"\n * cell (var (Witness 6, Curr))\n - cell (var (Witness 0, Next)) ) )\n + alpha_pow 4\n * ( ( field\n \"0x0000000000000000000100000000000000000000000000000000000000000000\"\n * cell (var (Witness 2, Curr))\n + field\n \"0x0000000000000000000000000000000000000000010000000000000000000000\"\n * cell (var (Witness 1, Curr))\n + cell (var (Witness 0, Curr)) )\n * ( field\n \"0x0000000000000000000100000000000000000000000000000000000000000000\"\n * cell (var (Witness 5, Curr))\n + field\n \"0x0000000000000000000000000000000000000000010000000000000000000000\"\n * cell (var (Witness 4, Curr))\n + cell (var (Witness 3, Curr)) )\n + ( field\n \"0x0000000000000000000100000000000000000000000000000000000000000000\"\n * cell (var (Witness 4, Next))\n + field\n \"0x0000000000000000000000000000000000000000010000000000000000000000\"\n * cell (var (Witness 3, Next))\n + cell (var (Witness 2, Next)) )\n * ( field\n \"0x0000000000000000000100000000000000000000000000000000000000000000\"\n * cell (var (Coefficient 3, Curr))\n + field\n \"0x0000000000000000000000000000000000000000010000000000000000000000\"\n * cell (var (Coefficient 2, Curr))\n + cell (var (Coefficient 1, Curr)) )\n - ( field\n \"0x0000000000000000000100000000000000000000000000000000000000000000\"\n * cell (var (Witness 1, Next))\n + cell (var (Witness 0, Next)) )\n - ( field\n \"0x0000000000000000000100000000000000000000000000000000000000000000\"\n * cell (var (Witness 4, Next))\n + field\n \"0x0000000000000000000000000000000000000000010000000000000000000000\"\n * cell (var (Witness 3, Next))\n + cell (var (Witness 2, Next)) )\n * field\n \"0x3FFFFFFFFFFFFFFFFFFFFFFFFFFFFF7707E2A8D6D5688AB6E4697CECFFFFFC01\"\n )\n + alpha_pow 5\n * ( cell (var (Witness 11, Curr))\n * ( cell (var (Witness 11, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 11, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 11, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 6\n * ( cell (var (Witness 12, Curr))\n * ( cell (var (Witness 12, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 12, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 12, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 7\n * ( cell (var (Witness 13, Curr))\n * ( cell (var (Witness 13, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 13, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 13, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 8\n * ( square (cell (var (Witness 14, Curr)))\n - cell (var (Witness 14, Curr)) )\n + alpha_pow 9\n * ( field\n \"0x0000000000000000000000000000000000000000010000000000000000000000\"\n * ( cell (var (Witness 7, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * cell (var (Witness 8, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000001000000\"\n * cell (var (Witness 9, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000001000000000\"\n * cell (var (Witness 10, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000001000000000000\"\n * cell (var (Witness 8, Next))\n + field\n \"0x0000000000000000000000000000000000000000000000001000000000000000\"\n * cell (var (Witness 9, Next))\n + field\n \"0x0000000000000000000000000000000000000000000001000000000000000000\"\n * cell (var (Witness 10, Next))\n + field\n \"0x0000000000000000000000000000000000000000001000000000000000000000\"\n * cell (var (Witness 11, Curr))\n + field\n \"0x0000000000000000000000000000000000000000004000000000000000000000\"\n * cell (var (Witness 12, Curr))\n + field\n \"0x0000000000000000000000000000000000000000010000000000000000000000\"\n * cell (var (Witness 13, Curr))\n + field\n \"0x0000000000000000000000000000000000000000040000000000000000000000\"\n * cell (var (Witness 14, Curr)) )\n - ( cell (var (Witness 0, Curr))\n * cell (var (Witness 5, Curr))\n + cell (var (Witness 2, Curr))\n * cell (var (Witness 3, Curr))\n + cell (var (Witness 1, Curr))\n * cell (var (Witness 4, Curr))\n + cell (var (Witness 2, Next))\n * cell (var (Coefficient 3, Curr))\n + cell (var (Witness 4, Next))\n * cell (var (Coefficient 1, Curr))\n + cell (var (Witness 3, Next))\n * cell (var (Coefficient 2, Curr))\n + ( field\n \"0x0000000000000000000000000000000000000000010000000000000000000000\"\n * cell (var (Witness 7, Next))\n + cell (var (Witness 6, Next)) )\n + cell (var (Witness 11, Next))\n - cell (var (Witness 1, Next)) ) )\n + alpha_pow 10\n * ( cell (var (Witness 5, Next))\n - ( cell (var (Witness 4, Next))\n + field\n \"0x0000000000000000000000000000000000000000010000000000000000000000\"\n - cell (var (Coefficient 0, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n ) ) ) )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000000\"\n )\n + if_feature\n ( Xor\n , (fun () ->\n cell (var (Index Xor16, Curr))\n * ( cell (var (Witness 3, Curr))\n + cell (var (Witness 4, Curr))\n * pow\n ( field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n , 4 )\n + cell (var (Witness 5, Curr))\n * pow\n ( field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n , 8 )\n + cell (var (Witness 6, Curr))\n * pow\n ( field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n , 12 )\n + pow\n ( field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n , 16 )\n * cell (var (Witness 0, Next))\n - cell (var (Witness 0, Curr))\n + alpha_pow 1\n * ( cell (var (Witness 7, Curr))\n + cell (var (Witness 8, Curr))\n * pow\n ( field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n , 4 )\n + cell (var (Witness 9, Curr))\n * pow\n ( field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n , 8 )\n + cell (var (Witness 10, Curr))\n * pow\n ( field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n , 12 )\n + pow\n ( field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n , 16 )\n * cell (var (Witness 1, Next))\n - cell (var (Witness 1, Curr)) )\n + alpha_pow 2\n * ( cell (var (Witness 11, Curr))\n + cell (var (Witness 12, Curr))\n * pow\n ( field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n , 4 )\n + cell (var (Witness 13, Curr))\n * pow\n ( field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n , 8 )\n + cell (var (Witness 14, Curr))\n * pow\n ( field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n , 12 )\n + pow\n ( field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n , 16 )\n * cell (var (Witness 2, Next))\n - cell (var (Witness 2, Curr)) ) ) )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000000\"\n )\n + if_feature\n ( Rot\n , (fun () ->\n cell (var (Index Rot64, Curr))\n * ( cell (var (Witness 7, Curr))\n * ( cell (var (Witness 7, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 7, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 7, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n )\n + alpha_pow 1\n * ( cell (var (Witness 8, Curr))\n * ( cell (var (Witness 8, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 8, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 8, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 2\n * ( cell (var (Witness 9, Curr))\n * ( cell (var (Witness 9, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 9, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 9, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 3\n * ( cell (var (Witness 10, Curr))\n * ( cell (var (Witness 10, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 10, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 10, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 4\n * ( cell (var (Witness 11, Curr))\n * ( cell (var (Witness 11, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 11, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 11, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 5\n * ( cell (var (Witness 12, Curr))\n * ( cell (var (Witness 12, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 12, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 12, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 6\n * ( cell (var (Witness 13, Curr))\n * ( cell (var (Witness 13, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 13, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 13, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 7\n * ( cell (var (Witness 14, Curr))\n * ( cell (var (Witness 14, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( cell (var (Witness 14, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000002\"\n )\n * ( cell (var (Witness 14, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n ) )\n + alpha_pow 8\n * ( cell (var (Witness 0, Curr))\n * cell (var (Coefficient 0, Curr))\n - ( cell (var (Witness 2, Curr))\n * field\n \"0x0000000000000000000000000000000000000000000000010000000000000000\"\n + cell (var (Witness 0, Next)) ) )\n + alpha_pow 9\n * ( cell (var (Witness 1, Curr))\n - (cell (var (Witness 0, Next)) + cell (var (Witness 2, Curr)))\n )\n + alpha_pow 10\n * ( cell (var (Witness 14, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 13, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 12, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 11, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 10, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 9, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 8, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 7, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * cell (var (Witness 6, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * cell (var (Witness 5, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * cell (var (Witness 4, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000000004\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * field\n \"0x0000000000000000000000000000000000000000000000000000000000001000\"\n * cell (var (Witness 3, Curr))\n - ( cell (var (Witness 2, Curr))\n - cell (var (Coefficient 0, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000010000000000000000\"\n ) ) ) )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000000\"\n )\n + cell (var (Index Generic, Curr))\n * ( (cell (var (Coefficient 0, Curr)) * cell (var (Witness 0, Curr)))\n + (cell (var (Coefficient 1, Curr)) * cell (var (Witness 1, Curr)))\n + (cell (var (Coefficient 2, Curr)) * cell (var (Witness 2, Curr)))\n + cell (var (Coefficient 3, Curr))\n * cell (var (Witness 0, Curr))\n * cell (var (Witness 1, Curr))\n + cell (var (Coefficient 4, Curr))\n + alpha_pow 1\n * ( (cell (var (Coefficient 5, Curr)) * cell (var (Witness 3, Curr)))\n + (cell (var (Coefficient 6, Curr)) * cell (var (Witness 4, Curr)))\n + (cell (var (Coefficient 7, Curr)) * cell (var (Witness 5, Curr)))\n + cell (var (Coefficient 8, Curr))\n * cell (var (Witness 3, Curr))\n * cell (var (Witness 4, Curr))\n + cell (var (Coefficient 9, Curr)) ) )\n + if_feature\n ( LookupTables\n , (fun () ->\n alpha_pow 24\n * ( vanishes_on_last_4_rows\n * ( cell (var (LookupAggreg, Next))\n * ( if_feature\n ( LookupsPerRow 0\n , (fun () ->\n gamma\n * ( beta\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n + cell (var (LookupSorted 0, Curr))\n + (beta * cell (var (LookupSorted 0, Next))) )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( LookupsPerRow 1\n , (fun () ->\n gamma\n * ( beta\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n + cell (var (LookupSorted 1, Next))\n + (beta * cell (var (LookupSorted 1, Curr))) )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( LookupsPerRow 2\n , (fun () ->\n gamma\n * ( beta\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n + cell (var (LookupSorted 2, Curr))\n + (beta * cell (var (LookupSorted 2, Next))) )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( LookupsPerRow 3\n , (fun () ->\n gamma\n * ( beta\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n + cell (var (LookupSorted 3, Next))\n + (beta * cell (var (LookupSorted 3, Curr))) )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( LookupsPerRow 4\n , (fun () ->\n gamma\n * ( beta\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n + cell (var (LookupSorted 4, Curr))\n + (beta * cell (var (LookupSorted 4, Next))) )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n ) )\n - cell (var (LookupAggreg, Curr))\n * ( ( ( field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n - ( if_feature\n ( LookupPattern Xor\n , (fun () ->\n cell (var (LookupKindIndex Xor, Curr)) )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000000\"\n )\n + if_feature\n ( LookupPattern Lookup\n , (fun () ->\n cell (var (LookupKindIndex Lookup, Curr)) )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000000\"\n )\n + if_feature\n ( LookupPattern RangeCheck\n , (fun () ->\n cell (var (LookupKindIndex RangeCheck, Curr))\n )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000000\"\n )\n + if_feature\n ( LookupPattern ForeignFieldMul\n , (fun () ->\n cell\n (var\n (LookupKindIndex ForeignFieldMul, Curr) )\n )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000000\"\n ) ) )\n * ( if_feature\n ( LookupsPerRow 1\n , (fun () -> gamma)\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( LookupsPerRow 2\n , (fun () -> gamma)\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( LookupsPerRow 3\n , (fun () -> gamma)\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( LookupsPerRow 4\n , (fun () -> gamma)\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( ( field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n + beta )\n * if_feature\n ( LookupsPerRow 2\n , (fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n + beta )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( LookupsPerRow 3\n , (fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n + beta )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( LookupsPerRow 4\n , (fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n + beta )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n ) ) )\n + if_feature\n ( LookupPattern Xor\n , (fun () ->\n cell (var (LookupKindIndex Xor, Curr))\n * ( ( field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n + beta )\n * if_feature\n ( LookupsPerRow 2\n , (fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n + beta )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( LookupsPerRow 3\n , (fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n + beta )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( LookupsPerRow 4\n , (fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n + beta )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( gamma\n + ( joint_combiner\n * ( joint_combiner\n * cell (var (Witness 11, Curr))\n + cell (var (Witness 7, Curr)) )\n + cell (var (Witness 3, Curr)) ) )\n * ( gamma\n + ( joint_combiner\n * ( joint_combiner\n * cell (var (Witness 12, Curr))\n + cell (var (Witness 8, Curr)) )\n + cell (var (Witness 4, Curr)) ) )\n * ( gamma\n + ( joint_combiner\n * ( joint_combiner\n * cell (var (Witness 13, Curr))\n + cell (var (Witness 9, Curr)) )\n + cell (var (Witness 5, Curr)) ) )\n * ( gamma\n + ( joint_combiner\n * ( joint_combiner\n * cell (var (Witness 14, Curr))\n + cell (var (Witness 10, Curr)) )\n + cell (var (Witness 6, Curr)) ) ) ) )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000000\"\n )\n + if_feature\n ( LookupPattern Lookup\n , (fun () ->\n cell (var (LookupKindIndex Lookup, Curr))\n * ( if_feature\n ( LookupsPerRow 4\n , (fun () -> gamma)\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( ( field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n + beta )\n * if_feature\n ( LookupsPerRow 2\n , (fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n + beta )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( LookupsPerRow 3\n , (fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n + beta )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( LookupsPerRow 4\n , (fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n + beta )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n ) )\n * ( gamma\n + ( joint_combiner\n * cell (var (Witness 2, Curr))\n + cell (var (Witness 1, Curr))\n + joint_combiner\n * if_feature\n ( TableWidth 2\n , (fun () -> joint_combiner)\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( TableWidth 3\n , (fun () -> joint_combiner)\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * cell (var (Witness 0, Curr)) ) )\n * ( gamma\n + ( joint_combiner\n * cell (var (Witness 4, Curr))\n + cell (var (Witness 3, Curr))\n + joint_combiner\n * if_feature\n ( TableWidth 2\n , (fun () -> joint_combiner)\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( TableWidth 3\n , (fun () -> joint_combiner)\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * cell (var (Witness 0, Curr)) ) )\n * ( gamma\n + ( joint_combiner\n * cell (var (Witness 6, Curr))\n + cell (var (Witness 5, Curr))\n + joint_combiner\n * if_feature\n ( TableWidth 2\n , (fun () -> joint_combiner)\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( TableWidth 3\n , (fun () -> joint_combiner)\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * cell (var (Witness 0, Curr)) ) ) ) )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000000\"\n )\n + if_feature\n ( LookupPattern RangeCheck\n , (fun () ->\n cell (var (LookupKindIndex RangeCheck, Curr))\n * ( ( field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n + beta )\n * if_feature\n ( LookupsPerRow 2\n , (fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n + beta )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( LookupsPerRow 3\n , (fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n + beta )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( LookupsPerRow 4\n , (fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n + beta )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( gamma\n + ( cell (var (Witness 3, Curr))\n + joint_combiner\n * if_feature\n ( TableWidth 2\n , (fun () -> joint_combiner)\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( TableWidth 3\n , (fun () -> joint_combiner)\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n ) ) )\n * ( gamma\n + ( cell (var (Witness 4, Curr))\n + joint_combiner\n * if_feature\n ( TableWidth 2\n , (fun () -> joint_combiner)\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( TableWidth 3\n , (fun () -> joint_combiner)\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n ) ) )\n * ( gamma\n + ( cell (var (Witness 5, Curr))\n + joint_combiner\n * if_feature\n ( TableWidth 2\n , (fun () -> joint_combiner)\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( TableWidth 3\n , (fun () -> joint_combiner)\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n ) ) )\n * ( gamma\n + ( cell (var (Witness 6, Curr))\n + joint_combiner\n * if_feature\n ( TableWidth 2\n , (fun () -> joint_combiner)\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( TableWidth 3\n , (fun () -> joint_combiner)\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n ) ) ) ) )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000000\"\n )\n + if_feature\n ( LookupPattern ForeignFieldMul\n , (fun () ->\n cell (var (LookupKindIndex ForeignFieldMul, Curr))\n * ( ( field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n + beta )\n * if_feature\n ( LookupsPerRow 2\n , (fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n + beta )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( LookupsPerRow 3\n , (fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n + beta )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( LookupsPerRow 4\n , (fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n + beta )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * ( gamma\n + ( cell (var (Witness 7, Curr))\n + joint_combiner\n * if_feature\n ( TableWidth 2\n , (fun () -> joint_combiner)\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( TableWidth 3\n , (fun () -> joint_combiner)\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n ) ) )\n * ( gamma\n + ( cell (var (Witness 8, Curr))\n + joint_combiner\n * if_feature\n ( TableWidth 2\n , (fun () -> joint_combiner)\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( TableWidth 3\n , (fun () -> joint_combiner)\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n ) ) )\n * ( gamma\n + ( cell (var (Witness 9, Curr))\n + joint_combiner\n * if_feature\n ( TableWidth 2\n , (fun () -> joint_combiner)\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( TableWidth 3\n , (fun () -> joint_combiner)\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n ) ) )\n * ( gamma\n + ( cell (var (Witness 10, Curr))\n + joint_combiner\n * if_feature\n ( TableWidth 2\n , (fun () -> joint_combiner)\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * if_feature\n ( TableWidth 3\n , (fun () -> joint_combiner)\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n ) ) ) ) )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000000\"\n ) )\n * ( gamma\n * ( beta\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n + cell (var (LookupTable, Curr))\n + (beta * cell (var (LookupTable, Next))) ) ) ) )\n + alpha_pow 25\n * ( unnormalized_lagrange_basis 0\n * ( cell (var (LookupAggreg, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n ) )\n + alpha_pow 26\n * ( unnormalized_lagrange_basis (-4)\n * ( cell (var (LookupAggreg, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n ) )\n + alpha_pow 27\n * if_feature\n ( LookupsPerRow 1\n , (fun () ->\n unnormalized_lagrange_basis (-4)\n * ( cell (var (LookupSorted 0, Curr))\n - cell (var (LookupSorted 1, Curr)) ) )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000000\"\n )\n + alpha_pow 28\n * if_feature\n ( LookupsPerRow 2\n , (fun () ->\n unnormalized_lagrange_basis 0\n * ( cell (var (LookupSorted 1, Curr))\n - cell (var (LookupSorted 2, Curr)) ) )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000000\"\n )\n + alpha_pow 29\n * if_feature\n ( LookupsPerRow 3\n , (fun () ->\n unnormalized_lagrange_basis (-4)\n * ( cell (var (LookupSorted 2, Curr))\n - cell (var (LookupSorted 3, Curr)) ) )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000000\"\n )\n + alpha_pow 30\n * if_feature\n ( LookupsPerRow 4\n , (fun () ->\n unnormalized_lagrange_basis 0\n * ( cell (var (LookupSorted 3, Curr))\n - cell (var (LookupSorted 4, Curr)) ) )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000000\"\n )\n + alpha_pow 31\n * if_feature\n ( RuntimeLookupTables\n , (fun () ->\n cell (var (LookupRuntimeTable, Curr))\n * cell (var (LookupRuntimeSelector, Curr)) )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000000\"\n ) )\n , fun () ->\n field\n \"0x0000000000000000000000000000000000000000000000000000000000000000\"\n )\n\n let index_terms (type a) (_ : a Env.t) = Column.Table.of_alist_exn []\nend\n\nmodule Tock : S = struct\n let constant_term (type a)\n ({ add = ( + )\n ; sub = ( - )\n ; mul = ( * )\n ; square\n ; mds\n ; endo_coefficient\n ; pow\n ; var\n ; field\n ; cell\n ; alpha_pow\n ; double\n ; zk_polynomial = _\n ; omega_to_minus_3 = _\n ; zeta_to_n_minus_1 = _\n ; srs_length_log2 = _\n ; vanishes_on_last_4_rows = _\n ; joint_combiner = _\n ; beta = _\n ; gamma = _\n ; unnormalized_lagrange_basis = _\n ; if_feature = _\n } :\n a Env.t ) =\n let x_0 = pow (cell (var (Witness 0, Curr)), 7) in\n let x_1 = pow (cell (var (Witness 1, Curr)), 7) in\n let x_2 = pow (cell (var (Witness 2, Curr)), 7) in\n let x_3 = pow (cell (var (Witness 6, Curr)), 7) in\n let x_4 = pow (cell (var (Witness 7, Curr)), 7) in\n let x_5 = pow (cell (var (Witness 8, Curr)), 7) in\n let x_6 = pow (cell (var (Witness 9, Curr)), 7) in\n let x_7 = pow (cell (var (Witness 10, Curr)), 7) in\n let x_8 = pow (cell (var (Witness 11, Curr)), 7) in\n let x_9 = pow (cell (var (Witness 12, Curr)), 7) in\n let x_10 = pow (cell (var (Witness 13, Curr)), 7) in\n let x_11 = pow (cell (var (Witness 14, Curr)), 7) in\n let x_12 = pow (cell (var (Witness 3, Curr)), 7) in\n let x_13 = pow (cell (var (Witness 4, Curr)), 7) in\n let x_14 = pow (cell (var (Witness 5, Curr)), 7) in\n let x_15 = cell (var (Witness 7, Next)) * cell (var (Witness 7, Next)) in\n let x_16 =\n let x_15 = cell (var (Witness 7, Next)) * cell (var (Witness 7, Next)) in\n cell (var (Witness 2, Curr))\n - (x_15 - cell (var (Witness 2, Curr)) - cell (var (Witness 0, Curr)))\n in\n let x_17 =\n let x_16 =\n let x_15 =\n cell (var (Witness 7, Next)) * cell (var (Witness 7, Next))\n in\n cell (var (Witness 2, Curr))\n - (x_15 - cell (var (Witness 2, Curr)) - cell (var (Witness 0, Curr)))\n in\n double (cell (var (Witness 3, Curr)))\n - (x_16 * cell (var (Witness 7, Next)))\n in\n let x_18 = cell (var (Witness 8, Next)) * cell (var (Witness 8, Next)) in\n let x_19 =\n let x_18 = cell (var (Witness 8, Next)) * cell (var (Witness 8, Next)) in\n cell (var (Witness 7, Curr))\n - (x_18 - cell (var (Witness 7, Curr)) - cell (var (Witness 0, Curr)))\n in\n let x_20 =\n let x_19 =\n let x_18 =\n cell (var (Witness 8, Next)) * cell (var (Witness 8, Next))\n in\n cell (var (Witness 7, Curr))\n - (x_18 - cell (var (Witness 7, Curr)) - cell (var (Witness 0, Curr)))\n in\n double (cell (var (Witness 8, Curr)))\n - (x_19 * cell (var (Witness 8, Next)))\n in\n let x_21 = cell (var (Witness 9, Next)) * cell (var (Witness 9, Next)) in\n let x_22 =\n let x_21 = cell (var (Witness 9, Next)) * cell (var (Witness 9, Next)) in\n cell (var (Witness 9, Curr))\n - (x_21 - cell (var (Witness 9, Curr)) - cell (var (Witness 0, Curr)))\n in\n let x_23 =\n let x_22 =\n let x_21 =\n cell (var (Witness 9, Next)) * cell (var (Witness 9, Next))\n in\n cell (var (Witness 9, Curr))\n - (x_21 - cell (var (Witness 9, Curr)) - cell (var (Witness 0, Curr)))\n in\n double (cell (var (Witness 10, Curr)))\n - (x_22 * cell (var (Witness 9, Next)))\n in\n let x_24 = cell (var (Witness 10, Next)) * cell (var (Witness 10, Next)) in\n let x_25 =\n let x_24 =\n cell (var (Witness 10, Next)) * cell (var (Witness 10, Next))\n in\n cell (var (Witness 11, Curr))\n - (x_24 - cell (var (Witness 11, Curr)) - cell (var (Witness 0, Curr)))\n in\n let x_26 =\n let x_25 =\n let x_24 =\n cell (var (Witness 10, Next)) * cell (var (Witness 10, Next))\n in\n cell (var (Witness 11, Curr))\n - (x_24 - cell (var (Witness 11, Curr)) - cell (var (Witness 0, Curr)))\n in\n double (cell (var (Witness 12, Curr)))\n - (x_25 * cell (var (Witness 10, Next)))\n in\n let x_27 = cell (var (Witness 11, Next)) * cell (var (Witness 11, Next)) in\n let x_28 =\n let x_27 =\n cell (var (Witness 11, Next)) * cell (var (Witness 11, Next))\n in\n cell (var (Witness 13, Curr))\n - (x_27 - cell (var (Witness 13, Curr)) - cell (var (Witness 0, Curr)))\n in\n let x_29 =\n let x_28 =\n let x_27 =\n cell (var (Witness 11, Next)) * cell (var (Witness 11, Next))\n in\n cell (var (Witness 13, Curr))\n - (x_27 - cell (var (Witness 13, Curr)) - cell (var (Witness 0, Curr)))\n in\n double (cell (var (Witness 14, Curr)))\n - (x_28 * cell (var (Witness 11, Next)))\n in\n let x_30 = cell (var (Witness 2, Curr)) - cell (var (Witness 0, Curr)) in\n let x_31 = cell (var (Witness 3, Curr)) - cell (var (Witness 1, Curr)) in\n let x_32 = cell (var (Witness 0, Curr)) * cell (var (Witness 0, Curr)) in\n let x_33 =\n ( field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n + cell (var (Witness 11, Curr))\n * ( endo_coefficient\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n ) )\n * cell (var (Witness 0, Curr))\n in\n let x_34 =\n ( field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n + cell (var (Witness 13, Curr))\n * ( endo_coefficient\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n ) )\n * cell (var (Witness 0, Curr))\n in\n let x_35 = square (cell (var (Witness 9, Curr))) in\n let x_36 = square (cell (var (Witness 10, Curr))) in\n let x_37 = cell (var (Witness 4, Curr)) - cell (var (Witness 7, Curr)) in\n let x_38 = cell (var (Witness 7, Curr)) - cell (var (Witness 4, Next)) in\n let x_39 = cell (var (Witness 5, Next)) + cell (var (Witness 8, Curr)) in\n let x_40 = cell (var (Witness 8, Curr)) + cell (var (Witness 5, Curr)) in\n let x_41 =\n ( ( field\n \"0x1555555555555555555555555555555560C232FEADDC3849D96CF90B00000001\"\n * cell (var (Witness 6, Curr))\n + field\n \"0x2000000000000000000000000000000011234C7E04CA546EC62375907FFFFFFE\"\n )\n * cell (var (Witness 6, Curr))\n + field\n \"0x0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB061197F56EE1C24ECB67C8580000002\"\n )\n * cell (var (Witness 6, Curr))\n in\n let x_42 =\n ( ( field\n \"0x1555555555555555555555555555555560C232FEADDC3849D96CF90B00000001\"\n * cell (var (Witness 7, Curr))\n + field\n \"0x2000000000000000000000000000000011234C7E04CA546EC62375907FFFFFFE\"\n )\n * cell (var (Witness 7, Curr))\n + field\n \"0x0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB061197F56EE1C24ECB67C8580000002\"\n )\n * cell (var (Witness 7, Curr))\n in\n let x_43 =\n ( ( field\n \"0x1555555555555555555555555555555560C232FEADDC3849D96CF90B00000001\"\n * cell (var (Witness 8, Curr))\n + field\n \"0x2000000000000000000000000000000011234C7E04CA546EC62375907FFFFFFE\"\n )\n * cell (var (Witness 8, Curr))\n + field\n \"0x0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB061197F56EE1C24ECB67C8580000002\"\n )\n * cell (var (Witness 8, Curr))\n in\n let x_44 =\n ( ( field\n \"0x1555555555555555555555555555555560C232FEADDC3849D96CF90B00000001\"\n * cell (var (Witness 9, Curr))\n + field\n \"0x2000000000000000000000000000000011234C7E04CA546EC62375907FFFFFFE\"\n )\n * cell (var (Witness 9, Curr))\n + field\n \"0x0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB061197F56EE1C24ECB67C8580000002\"\n )\n * cell (var (Witness 9, Curr))\n in\n let x_45 =\n ( ( field\n \"0x1555555555555555555555555555555560C232FEADDC3849D96CF90B00000001\"\n * cell (var (Witness 10, Curr))\n + field\n \"0x2000000000000000000000000000000011234C7E04CA546EC62375907FFFFFFE\"\n )\n * cell (var (Witness 10, Curr))\n + field\n \"0x0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB061197F56EE1C24ECB67C8580000002\"\n )\n * cell (var (Witness 10, Curr))\n in\n let x_46 =\n ( ( field\n \"0x1555555555555555555555555555555560C232FEADDC3849D96CF90B00000001\"\n * cell (var (Witness 11, Curr))\n + field\n \"0x2000000000000000000000000000000011234C7E04CA546EC62375907FFFFFFE\"\n )\n * cell (var (Witness 11, Curr))\n + field\n \"0x0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB061197F56EE1C24ECB67C8580000002\"\n )\n * cell (var (Witness 11, Curr))\n in\n let x_47 =\n ( ( field\n \"0x1555555555555555555555555555555560C232FEADDC3849D96CF90B00000001\"\n * cell (var (Witness 12, Curr))\n + field\n \"0x2000000000000000000000000000000011234C7E04CA546EC62375907FFFFFFE\"\n )\n * cell (var (Witness 12, Curr))\n + field\n \"0x0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB061197F56EE1C24ECB67C8580000002\"\n )\n * cell (var (Witness 12, Curr))\n in\n let x_48 =\n ( ( field\n \"0x1555555555555555555555555555555560C232FEADDC3849D96CF90B00000001\"\n * cell (var (Witness 13, Curr))\n + field\n \"0x2000000000000000000000000000000011234C7E04CA546EC62375907FFFFFFE\"\n )\n * cell (var (Witness 13, Curr))\n + field\n \"0x0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB061197F56EE1C24ECB67C8580000002\"\n )\n * cell (var (Witness 13, Curr))\n in\n cell (var (Index Poseidon, Curr))\n * ( cell (var (Witness 6, Curr))\n - ( cell (var (Coefficient 0, Curr))\n + (mds (0, 0) * x_0)\n + (mds (0, 1) * x_1)\n + (mds (0, 2) * x_2) )\n + alpha_pow 1\n * ( cell (var (Witness 7, Curr))\n - ( cell (var (Coefficient 1, Curr))\n + (mds (1, 0) * x_0)\n + (mds (1, 1) * x_1)\n + (mds (1, 2) * x_2) ) )\n + alpha_pow 2\n * ( cell (var (Witness 8, Curr))\n - ( cell (var (Coefficient 2, Curr))\n + (mds (2, 0) * x_0)\n + (mds (2, 1) * x_1)\n + (mds (2, 2) * x_2) ) )\n + alpha_pow 3\n * ( cell (var (Witness 9, Curr))\n - ( cell (var (Coefficient 3, Curr))\n + (mds (0, 0) * x_3)\n + (mds (0, 1) * x_4)\n + (mds (0, 2) * x_5) ) )\n + alpha_pow 4\n * ( cell (var (Witness 10, Curr))\n - ( cell (var (Coefficient 4, Curr))\n + (mds (1, 0) * x_3)\n + (mds (1, 1) * x_4)\n + (mds (1, 2) * x_5) ) )\n + alpha_pow 5\n * ( cell (var (Witness 11, Curr))\n - ( cell (var (Coefficient 5, Curr))\n + (mds (2, 0) * x_3)\n + (mds (2, 1) * x_4)\n + (mds (2, 2) * x_5) ) )\n + alpha_pow 6\n * ( cell (var (Witness 12, Curr))\n - ( cell (var (Coefficient 6, Curr))\n + (mds (0, 0) * x_6)\n + (mds (0, 1) * x_7)\n + (mds (0, 2) * x_8) ) )\n + alpha_pow 7\n * ( cell (var (Witness 13, Curr))\n - ( cell (var (Coefficient 7, Curr))\n + (mds (1, 0) * x_6)\n + (mds (1, 1) * x_7)\n + (mds (1, 2) * x_8) ) )\n + alpha_pow 8\n * ( cell (var (Witness 14, Curr))\n - ( cell (var (Coefficient 8, Curr))\n + (mds (2, 0) * x_6)\n + (mds (2, 1) * x_7)\n + (mds (2, 2) * x_8) ) )\n + alpha_pow 9\n * ( cell (var (Witness 3, Curr))\n - ( cell (var (Coefficient 9, Curr))\n + (mds (0, 0) * x_9)\n + (mds (0, 1) * x_10)\n + (mds (0, 2) * x_11) ) )\n + alpha_pow 10\n * ( cell (var (Witness 4, Curr))\n - ( cell (var (Coefficient 10, Curr))\n + (mds (1, 0) * x_9)\n + (mds (1, 1) * x_10)\n + (mds (1, 2) * x_11) ) )\n + alpha_pow 11\n * ( cell (var (Witness 5, Curr))\n - ( cell (var (Coefficient 11, Curr))\n + (mds (2, 0) * x_9)\n + (mds (2, 1) * x_10)\n + (mds (2, 2) * x_11) ) )\n + alpha_pow 12\n * ( cell (var (Witness 0, Next))\n - ( cell (var (Coefficient 12, Curr))\n + (mds (0, 0) * x_12)\n + (mds (0, 1) * x_13)\n + (mds (0, 2) * x_14) ) )\n + alpha_pow 13\n * ( cell (var (Witness 1, Next))\n - ( cell (var (Coefficient 13, Curr))\n + (mds (1, 0) * x_12)\n + (mds (1, 1) * x_13)\n + (mds (1, 2) * x_14) ) )\n + alpha_pow 14\n * ( cell (var (Witness 2, Next))\n - ( cell (var (Coefficient 14, Curr))\n + (mds (2, 0) * x_12)\n + (mds (2, 1) * x_13)\n + (mds (2, 2) * x_14) ) ) )\n + cell (var (Index VarBaseMul, Curr))\n * ( cell (var (Witness 5, Curr))\n - ( cell (var (Witness 6, Next))\n + double\n ( cell (var (Witness 5, Next))\n + double\n ( cell (var (Witness 4, Next))\n + double\n ( cell (var (Witness 3, Next))\n + double\n ( cell (var (Witness 2, Next))\n + double (cell (var (Witness 4, Curr))) ) ) ) ) )\n + alpha_pow 1\n * ( square (cell (var (Witness 2, Next)))\n - cell (var (Witness 2, Next)) )\n + alpha_pow 2\n * ( (cell (var (Witness 2, Curr)) - cell (var (Witness 0, Curr)))\n * cell (var (Witness 7, Next))\n - ( cell (var (Witness 3, Curr))\n - ( double (cell (var (Witness 2, Next)))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * cell (var (Witness 1, Curr)) ) )\n + alpha_pow 3\n * ( (x_17 * x_17)\n - x_16 * x_16\n * ( cell (var (Witness 7, Curr))\n - cell (var (Witness 0, Curr))\n + x_15 ) )\n + alpha_pow 4\n * ( (cell (var (Witness 8, Curr)) + cell (var (Witness 3, Curr)))\n * x_16\n - (cell (var (Witness 2, Curr)) - cell (var (Witness 7, Curr)))\n * x_17 )\n + alpha_pow 5\n * ( square (cell (var (Witness 3, Next)))\n - cell (var (Witness 3, Next)) )\n + alpha_pow 6\n * ( (cell (var (Witness 7, Curr)) - cell (var (Witness 0, Curr)))\n * cell (var (Witness 8, Next))\n - ( cell (var (Witness 8, Curr))\n - ( double (cell (var (Witness 3, Next)))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * cell (var (Witness 1, Curr)) ) )\n + alpha_pow 7\n * ( (x_20 * x_20)\n - x_19 * x_19\n * ( cell (var (Witness 9, Curr))\n - cell (var (Witness 0, Curr))\n + x_18 ) )\n + alpha_pow 8\n * ( (cell (var (Witness 10, Curr)) + cell (var (Witness 8, Curr)))\n * x_19\n - (cell (var (Witness 7, Curr)) - cell (var (Witness 9, Curr)))\n * x_20 )\n + alpha_pow 9\n * ( square (cell (var (Witness 4, Next)))\n - cell (var (Witness 4, Next)) )\n + alpha_pow 10\n * ( (cell (var (Witness 9, Curr)) - cell (var (Witness 0, Curr)))\n * cell (var (Witness 9, Next))\n - ( cell (var (Witness 10, Curr))\n - ( double (cell (var (Witness 4, Next)))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * cell (var (Witness 1, Curr)) ) )\n + alpha_pow 11\n * ( (x_23 * x_23)\n - x_22 * x_22\n * ( cell (var (Witness 11, Curr))\n - cell (var (Witness 0, Curr))\n + x_21 ) )\n + alpha_pow 12\n * ( (cell (var (Witness 12, Curr)) + cell (var (Witness 10, Curr)))\n * x_22\n - (cell (var (Witness 9, Curr)) - cell (var (Witness 11, Curr)))\n * x_23 )\n + alpha_pow 13\n * ( square (cell (var (Witness 5, Next)))\n - cell (var (Witness 5, Next)) )\n + alpha_pow 14\n * ( (cell (var (Witness 11, Curr)) - cell (var (Witness 0, Curr)))\n * cell (var (Witness 10, Next))\n - ( cell (var (Witness 12, Curr))\n - ( double (cell (var (Witness 5, Next)))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * cell (var (Witness 1, Curr)) ) )\n + alpha_pow 15\n * ( (x_26 * x_26)\n - x_25 * x_25\n * ( cell (var (Witness 13, Curr))\n - cell (var (Witness 0, Curr))\n + x_24 ) )\n + alpha_pow 16\n * ( (cell (var (Witness 14, Curr)) + cell (var (Witness 12, Curr)))\n * x_25\n - (cell (var (Witness 11, Curr)) - cell (var (Witness 13, Curr)))\n * x_26 )\n + alpha_pow 17\n * ( square (cell (var (Witness 6, Next)))\n - cell (var (Witness 6, Next)) )\n + alpha_pow 18\n * ( (cell (var (Witness 13, Curr)) - cell (var (Witness 0, Curr)))\n * cell (var (Witness 11, Next))\n - ( cell (var (Witness 14, Curr))\n - ( double (cell (var (Witness 6, Next)))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * cell (var (Witness 1, Curr)) ) )\n + alpha_pow 19\n * ( (x_29 * x_29)\n - x_28 * x_28\n * ( cell (var (Witness 0, Next))\n - cell (var (Witness 0, Curr))\n + x_27 ) )\n + alpha_pow 20\n * ( (cell (var (Witness 1, Next)) + cell (var (Witness 14, Curr)))\n * x_28\n - (cell (var (Witness 13, Curr)) - cell (var (Witness 0, Next)))\n * x_29 ) )\n + cell (var (Index CompleteAdd, Curr))\n * ( (cell (var (Witness 10, Curr)) * x_30)\n - ( field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n - cell (var (Witness 7, Curr)) )\n + (alpha_pow 1 * (cell (var (Witness 7, Curr)) * x_30))\n + alpha_pow 2\n * ( cell (var (Witness 7, Curr))\n * ( double (cell (var (Witness 8, Curr)))\n * cell (var (Witness 1, Curr))\n - double x_32 - x_32 )\n + ( field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n - cell (var (Witness 7, Curr)) )\n * ((x_30 * cell (var (Witness 8, Curr))) - x_31) )\n + alpha_pow 3\n * ( cell (var (Witness 0, Curr))\n + cell (var (Witness 2, Curr))\n + cell (var (Witness 4, Curr))\n - (cell (var (Witness 8, Curr)) * cell (var (Witness 8, Curr))) )\n + alpha_pow 4\n * ( cell (var (Witness 8, Curr))\n * (cell (var (Witness 0, Curr)) - cell (var (Witness 4, Curr)))\n - cell (var (Witness 1, Curr))\n - cell (var (Witness 5, Curr)) )\n + alpha_pow 5\n * ( x_31\n * (cell (var (Witness 7, Curr)) - cell (var (Witness 6, Curr))) )\n + alpha_pow 6\n * ( (x_31 * cell (var (Witness 9, Curr)))\n - cell (var (Witness 6, Curr)) ) )\n + cell (var (Index EndoMul, Curr))\n * ( square (cell (var (Witness 11, Curr)))\n - cell (var (Witness 11, Curr))\n + alpha_pow 1\n * ( square (cell (var (Witness 12, Curr)))\n - cell (var (Witness 12, Curr)) )\n + alpha_pow 2\n * ( square (cell (var (Witness 13, Curr)))\n - cell (var (Witness 13, Curr)) )\n + alpha_pow 3\n * ( square (cell (var (Witness 14, Curr)))\n - cell (var (Witness 14, Curr)) )\n + alpha_pow 4\n * ( (x_33 - cell (var (Witness 4, Curr)))\n * cell (var (Witness 9, Curr))\n - ( ( double (cell (var (Witness 12, Curr)))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * cell (var (Witness 1, Curr))\n - cell (var (Witness 5, Curr)) ) )\n + alpha_pow 5\n * ( (double (cell (var (Witness 4, Curr))) - x_35 + x_33)\n * ((x_37 * cell (var (Witness 9, Curr))) + x_40)\n - (double (cell (var (Witness 5, Curr))) * x_37) )\n + alpha_pow 6\n * ( square x_40\n - (square x_37 * (x_35 - x_33 + cell (var (Witness 7, Curr)))) )\n + alpha_pow 7\n * ( (x_34 - cell (var (Witness 7, Curr)))\n * cell (var (Witness 10, Curr))\n - ( ( double (cell (var (Witness 14, Curr)))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n )\n * cell (var (Witness 1, Curr))\n - cell (var (Witness 8, Curr)) ) )\n + alpha_pow 8\n * ( (double (cell (var (Witness 7, Curr))) - x_36 + x_34)\n * ((x_38 * cell (var (Witness 10, Curr))) + x_39)\n - (double (cell (var (Witness 8, Curr))) * x_38) )\n + alpha_pow 9\n * ( square x_39\n - (square x_38 * (x_36 - x_34 + cell (var (Witness 4, Next)))) )\n + alpha_pow 10\n * ( double\n ( double\n ( double\n ( double (cell (var (Witness 6, Curr)))\n + cell (var (Witness 11, Curr)) )\n + cell (var (Witness 12, Curr)) )\n + cell (var (Witness 13, Curr)) )\n + cell (var (Witness 14, Curr))\n - cell (var (Witness 6, Next)) ) )\n + cell (var (Index EndoMulScalar, Curr))\n * ( double\n (double\n ( double\n (double\n ( double\n (double\n ( double\n (double\n ( double\n (double\n ( double\n (double\n ( double\n (double\n ( double\n (double\n (cell\n (var\n ( Witness 0\n , Curr ) ) ) )\n + cell\n (var\n (Witness 6, Curr) )\n ) )\n + cell (var (Witness 7, Curr))\n ) )\n + cell (var (Witness 8, Curr)) ) )\n + cell (var (Witness 9, Curr)) ) )\n + cell (var (Witness 10, Curr)) ) )\n + cell (var (Witness 11, Curr)) ) )\n + cell (var (Witness 12, Curr)) ) )\n + cell (var (Witness 13, Curr))\n - cell (var (Witness 1, Curr))\n + alpha_pow 1\n * ( double\n ( double\n ( double\n ( double\n ( double\n ( double\n ( double\n ( double (cell (var (Witness 2, Curr)))\n + x_41 )\n + x_42 )\n + x_43 )\n + x_44 )\n + x_45 )\n + x_46 )\n + x_47 )\n + x_48\n - cell (var (Witness 4, Curr)) )\n + alpha_pow 2\n * ( double\n ( double\n ( double\n ( double\n ( double\n ( double\n ( double\n ( double (cell (var (Witness 3, Curr)))\n + ( x_41\n + ( ( field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB2100000000\"\n * cell (var (Witness 6, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n )\n * cell (var (Witness 6, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB2100000000\"\n ) ) )\n + ( x_42\n + ( ( field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB2100000000\"\n * cell (var (Witness 7, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n )\n * cell (var (Witness 7, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB2100000000\"\n ) ) )\n + ( x_43\n + ( ( field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB2100000000\"\n * cell (var (Witness 8, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n )\n * cell (var (Witness 8, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB2100000000\"\n ) ) )\n + ( x_44\n + ( ( field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB2100000000\"\n * cell (var (Witness 9, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n )\n * cell (var (Witness 9, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB2100000000\"\n ) ) )\n + ( x_45\n + ( ( field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB2100000000\"\n * cell (var (Witness 10, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n )\n * cell (var (Witness 10, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB2100000000\"\n ) ) )\n + ( x_46\n + ( ( field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB2100000000\"\n * cell (var (Witness 11, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n )\n * cell (var (Witness 11, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB2100000000\"\n ) ) )\n + ( x_47\n + ( ( field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB2100000000\"\n * cell (var (Witness 12, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n )\n * cell (var (Witness 12, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB2100000000\"\n ) ) )\n + ( x_48\n + ( ( field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB2100000000\"\n * cell (var (Witness 13, Curr))\n + field\n \"0x0000000000000000000000000000000000000000000000000000000000000003\"\n )\n * cell (var (Witness 13, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB2100000000\"\n ) )\n - cell (var (Witness 5, Curr)) )\n + alpha_pow 3\n * ( ( ( ( cell (var (Witness 6, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB20FFFFFFFB\"\n )\n * cell (var (Witness 6, Curr))\n + field\n \"0x000000000000000000000000000000000000000000000000000000000000000B\"\n )\n * cell (var (Witness 6, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB20FFFFFFFB\"\n )\n * cell (var (Witness 6, Curr)) )\n + alpha_pow 4\n * ( ( ( ( cell (var (Witness 7, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB20FFFFFFFB\"\n )\n * cell (var (Witness 7, Curr))\n + field\n \"0x000000000000000000000000000000000000000000000000000000000000000B\"\n )\n * cell (var (Witness 7, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB20FFFFFFFB\"\n )\n * cell (var (Witness 7, Curr)) )\n + alpha_pow 5\n * ( ( ( ( cell (var (Witness 8, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB20FFFFFFFB\"\n )\n * cell (var (Witness 8, Curr))\n + field\n \"0x000000000000000000000000000000000000000000000000000000000000000B\"\n )\n * cell (var (Witness 8, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB20FFFFFFFB\"\n )\n * cell (var (Witness 8, Curr)) )\n + alpha_pow 6\n * ( ( ( ( cell (var (Witness 9, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB20FFFFFFFB\"\n )\n * cell (var (Witness 9, Curr))\n + field\n \"0x000000000000000000000000000000000000000000000000000000000000000B\"\n )\n * cell (var (Witness 9, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB20FFFFFFFB\"\n )\n * cell (var (Witness 9, Curr)) )\n + alpha_pow 7\n * ( ( ( ( cell (var (Witness 10, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB20FFFFFFFB\"\n )\n * cell (var (Witness 10, Curr))\n + field\n \"0x000000000000000000000000000000000000000000000000000000000000000B\"\n )\n * cell (var (Witness 10, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB20FFFFFFFB\"\n )\n * cell (var (Witness 10, Curr)) )\n + alpha_pow 8\n * ( ( ( ( cell (var (Witness 11, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB20FFFFFFFB\"\n )\n * cell (var (Witness 11, Curr))\n + field\n \"0x000000000000000000000000000000000000000000000000000000000000000B\"\n )\n * cell (var (Witness 11, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB20FFFFFFFB\"\n )\n * cell (var (Witness 11, Curr)) )\n + alpha_pow 9\n * ( ( ( ( cell (var (Witness 12, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB20FFFFFFFB\"\n )\n * cell (var (Witness 12, Curr))\n + field\n \"0x000000000000000000000000000000000000000000000000000000000000000B\"\n )\n * cell (var (Witness 12, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB20FFFFFFFB\"\n )\n * cell (var (Witness 12, Curr)) )\n + alpha_pow 10\n * ( ( ( ( cell (var (Witness 13, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB20FFFFFFFB\"\n )\n * cell (var (Witness 13, Curr))\n + field\n \"0x000000000000000000000000000000000000000000000000000000000000000B\"\n )\n * cell (var (Witness 13, Curr))\n + field\n \"0x40000000000000000000000000000000224698FC0994A8DD8C46EB20FFFFFFFB\"\n )\n * cell (var (Witness 13, Curr)) ) )\n + cell (var (Index Generic, Curr))\n * ( (cell (var (Coefficient 0, Curr)) * cell (var (Witness 0, Curr)))\n + (cell (var (Coefficient 1, Curr)) * cell (var (Witness 1, Curr)))\n + (cell (var (Coefficient 2, Curr)) * cell (var (Witness 2, Curr)))\n + cell (var (Coefficient 3, Curr))\n * cell (var (Witness 0, Curr))\n * cell (var (Witness 1, Curr))\n + cell (var (Coefficient 4, Curr))\n + alpha_pow 1\n * ( (cell (var (Coefficient 5, Curr)) * cell (var (Witness 3, Curr)))\n + (cell (var (Coefficient 6, Curr)) * cell (var (Witness 4, Curr)))\n + (cell (var (Coefficient 7, Curr)) * cell (var (Witness 5, Curr)))\n + cell (var (Coefficient 8, Curr))\n * cell (var (Witness 3, Curr))\n * cell (var (Witness 4, Curr))\n + cell (var (Coefficient 9, Curr)) ) )\n\n let index_terms (type a) (_ : a Env.t) = Column.Table.of_alist_exn []\nend\n","let commit_id = \"[DIRTY]1dc5c5bb2611b6cbfec4e231334ab6fb453b4b82\"\nlet commit_id_short = \"1dc5c5bb\"\nlet branch = \"dannywillems/add-runtime-table-cfg-to-prover-index-creation\"\nlet commit_date = \"2023-08-01T15:04:28+02:00\"\nlet marlin_commit_id = \"b0a3cb250b303791652fcab6e4a48db9e539f508\"\nlet marlin_commit_id_short = \"b0a3cb25\"\nlet marlin_commit_date = \"2023-07-26T21:20:12+01:00\"\nlet print_version () = Core_kernel.printf \"Commit %s on branch %s\\n%!\" commit_id branch\n","(* base58_check.ml : implement Base58Check algorithm\n see: https://www.oreilly.com/library/view/mastering-bitcoin-2nd/9781491954379/ch04.html#base58\n also: https://datatracker.ietf.org/doc/html/draft-msporny-base58-03\n\n the algorithm is modified for long strings, to apply encoding on chunks of the input\n*)\n\nopen Core_kernel\n\nexception Invalid_base58_checksum of string\n\nexception Invalid_base58_version_byte of (char * string)\n\nexception Invalid_base58_check_length of string\n\nexception Invalid_base58_character of string\n\n(* same as Bitcoin alphabet *)\nlet mina_alphabet =\n B58.make_alphabet \"123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz\"\n\nlet version_len = 1\n\nlet checksum_len = 4\n\nmodule Make (M : sig\n val description : string\n\n val version_byte : char\nend) =\nstruct\n let version_byte = M.version_byte\n\n let version_string = String.make 1 version_byte\n\n let max_length = 8192\n\n let compute_checksum payload =\n (* double-hash using SHA256 *)\n let open Digestif.SHA256 in\n let ctx0 = init () in\n let ctx1 = feed_string ctx0 version_string in\n let ctx2 = feed_string ctx1 payload in\n let first_hash = get ctx2 |> to_raw_string in\n let ctx3 = feed_string ctx0 first_hash in\n let second_hash = get ctx3 |> to_raw_string in\n second_hash |> String.sub ~pos:0 ~len:checksum_len\n\n (* we don't name this with _exn, we don't expect to raise an exception\n if we do, we're encoding types that shouldn't be encoded\n *)\n let encode payload =\n let len = String.length payload in\n if len > max_length then\n failwithf\n \"String is too long (%d bytes) to Base58Check-encode, max length is %d\"\n len max_length () ;\n let checksum = compute_checksum payload in\n let bytes = version_string ^ payload ^ checksum |> Bytes.of_string in\n B58.encode mina_alphabet bytes |> Bytes.to_string\n\n let decode_exn s =\n let bytes = Bytes.of_string s in\n let decoded =\n try B58.decode mina_alphabet bytes |> Bytes.to_string\n with B58.Invalid_base58_character ->\n raise (Invalid_base58_character M.description)\n in\n let len = String.length decoded in\n (* input must be at least as long as the version byte and checksum *)\n if len < version_len + checksum_len then\n raise (Invalid_base58_check_length M.description) ;\n let checksum =\n String.sub decoded\n ~pos:(String.length decoded - checksum_len)\n ~len:checksum_len\n in\n let payload =\n String.sub decoded ~pos:1 ~len:(len - version_len - checksum_len)\n in\n if not (String.equal checksum (compute_checksum payload)) then\n raise (Invalid_base58_checksum M.description) ;\n if not (Char.equal decoded.[0] version_byte) then\n raise (Invalid_base58_version_byte (decoded.[0], M.description)) ;\n payload\n\n let decode s =\n let error_str e desc =\n sprintf \"Error decoding %s\\nInvalid base58 %s in %s\" s e desc\n in\n try Ok (decode_exn s) with\n | Invalid_base58_character str ->\n Or_error.error_string (error_str \"character\" str)\n | Invalid_base58_check_length str ->\n Or_error.error_string (error_str \"check length\" str)\n | Invalid_base58_checksum str ->\n Or_error.error_string (error_str \"checksum\" str)\n | Invalid_base58_version_byte (ch, str) ->\n Or_error.error_string\n (error_str\n (sprintf \"version byte \\\\x%02X, expected \\\\x%02X\" (Char.to_int ch)\n (Char.to_int version_byte) )\n str )\nend\n\nmodule Version_bytes = Version_bytes\n\nlet%test_module \"base58check tests\" =\n ( module struct\n module Base58_check = Make (struct\n let description = \"Base58check tests\"\n\n let version_byte = '\\x53'\n end)\n\n open Base58_check\n\n let test_roundtrip payload =\n let encoded = encode payload in\n let payload' = decode_exn encoded in\n String.equal payload payload'\n\n let%test \"empty_string\" = test_roundtrip \"\"\n\n let%test \"nonempty_string\" =\n test_roundtrip \"Somewhere, over the rainbow, way up high\"\n\n let%test \"longer_string\" =\n test_roundtrip\n \"Someday, I wish upon a star, wake up where the clouds are far behind \\\n me, where trouble melts like lemon drops, High above the chimney top, \\\n that's where you'll find me\"\n\n let%test \"invalid checksum\" =\n try\n let encoded = encode \"Bluer than velvet were her eyes\" in\n let bytes = Bytes.of_string encoded in\n let len = Bytes.length bytes in\n let last_ch = Bytes.get bytes (len - 1) in\n (* change last byte to invalidate checksum *)\n let new_last_ch =\n if Char.equal last_ch '\\xFF' then '\\x00'\n else Char.of_int_exn (Char.to_int last_ch + 1)\n in\n Bytes.set bytes (len - 1) new_last_ch ;\n let encoded_bad_checksum = Bytes.to_string bytes in\n let _payload = decode_exn encoded_bad_checksum in\n false\n with Invalid_base58_checksum _ -> true\n\n let%test \"invalid length\" =\n try\n let _payload = decode_exn \"abcd\" in\n false\n with Invalid_base58_check_length _ -> true\n end )\n","module Field_intf = struct\n module type Basic = sig\n type t\n\n val ( * ) : t -> t -> t\n\n val ( + ) : t -> t -> t\n\n val ( - ) : t -> t -> t\n\n val inv_exn : t -> t\n\n val negate : t -> t\n\n val square : t -> t\n end\n\n module type Constant = sig\n include Basic\n end\n\n module type Checked = sig\n type field\n\n type bool\n\n include Basic\n\n val if_ : bool -> then_:t -> else_:t -> t\n\n val scale : t -> field -> t\n end\nend\n\nmodule type Constant_intf = sig\n type field\n\n type t\n\n val random : unit -> t\n\n val to_affine_exn : t -> field * field\n\n val of_affine : field * field -> t\n\n val ( + ) : t -> t -> t\n\n val negate : t -> t\nend\n\nmodule type Inputs_intf = sig\n module Impl : Snarky_backendless.Snark_intf.Run\n\n module F : sig\n include\n Field_intf.Checked\n with type bool := Impl.Boolean.var\n and type field := Impl.field\n\n module Constant : Field_intf.Constant\n\n val assert_square : t -> t -> unit\n\n val assert_r1cs : t -> t -> t -> unit\n\n val typ : (t, Constant.t) Impl.Typ.t\n\n val constant : Constant.t -> t\n end\n\n module Constant : Constant_intf with type field := F.Constant.t\n\n module Params : sig\n val one : F.Constant.t * F.Constant.t\n\n val group_size_in_bits : int\n\n val a : F.Constant.t\n\n val b : F.Constant.t\n end\nend\n\nmodule Make_checked (Inputs : Inputs_intf) = struct\n open Inputs\n open Impl\n\n type t = F.t * F.t\n\n let double ((ax, ay) : t) : t =\n let open F in\n (* A: 1\n B: 1\n C: 1 *)\n let x_squared = square ax in\n let lambda =\n exists typ\n ~compute:\n As_prover.(\n fun () ->\n let x_squared = read typ x_squared in\n let ay = read typ ay in\n let open F.Constant in\n (x_squared + x_squared + x_squared + Params.a) * inv_exn (ay + ay))\n in\n let bx =\n exists typ\n ~compute:\n As_prover.(\n fun () ->\n let lambda = read typ lambda in\n let ax = read typ ax in\n let open F.Constant in\n square lambda - (ax + ax))\n in\n let by =\n exists typ\n ~compute:\n As_prover.(\n fun () ->\n let lambda = read typ lambda\n and ax = read typ ax\n and ay = read typ ay\n and bx = read typ bx in\n F.Constant.((lambda * (ax - bx)) - ay))\n in\n let two = Field.Constant.of_int 2 in\n (* A: 1\n B: 1\n C: 2 *)\n assert_r1cs (F.scale lambda two) ay\n (F.scale x_squared (Field.Constant.of_int 3) + F.constant Params.a) ;\n (* A: 1\n B: 1\n C: 2\n *)\n assert_square lambda (bx + F.scale ax two) ;\n (* A: 1\n B: 2\n C: 2\n *)\n assert_r1cs lambda (ax - bx) (by + ay) ;\n (* Overall:\n A: 4\n B: 5\n C: 7 *)\n (bx, by)\n\n let add' ~div (ax, ay) (bx, by) : t =\n let open F in\n (*\n lambda * (bx - ax) = (by - ay)\n\n A: 1\n B: 2\n C: 2\n *)\n let lambda = div (by - ay) (bx - ax) in\n let cx =\n exists typ\n ~compute:\n As_prover.(\n fun () ->\n let ax = read typ ax\n and bx = read typ bx\n and lambda = read typ lambda in\n Constant.(square lambda - (ax + bx)))\n in\n\n (* lambda^2 = cx + ax + bx\n\n A: 1\n B: 1\n C: 3\n *)\n assert_square lambda F.(cx + ax + bx) ;\n let cy =\n exists typ\n ~compute:\n As_prover.(\n fun () ->\n let ax = read typ ax\n and ay = read typ ay\n and cx = read typ cx\n and lambda = read typ lambda in\n Constant.((lambda * (ax - cx)) - ay))\n in\n (* A: 1\n B: 2\n C: 2 *)\n assert_r1cs lambda (ax - cx) (cy + ay) ;\n (* Overall\n A: 2\n B: 5\n C: 7 *)\n (cx, cy)\n\n let add_exn p q = add' ~div:(fun x y -> F.(inv_exn y * x)) p q\n\n let to_affine_exn x = x\n\n let constant t =\n let x, y = Constant.to_affine_exn t in\n (F.constant x, F.constant y)\n\n let negate (x, y) = (x, F.negate y)\n\n let one =\n let x, y = Params.one in\n F.(constant x, constant y)\n\n let assert_on_curve (x, y) =\n let open F in\n let x2 = square x in\n let x3 = x2 * x in\n let ax = constant Params.a * x in\n assert_square y (x3 + ax + constant Params.b)\n\n let typ_unchecked : (t, Constant.t) Typ.t =\n Typ.transport\n Typ.(tuple2 F.typ F.typ)\n ~there:Constant.to_affine_exn ~back:Constant.of_affine\n\n let typ : (t, Constant.t) Typ.t =\n let (Typ typ_unchecked) = typ_unchecked in\n Typ\n { typ_unchecked with\n check = (fun t -> Impl.make_checked (fun () -> assert_on_curve t))\n }\n\n let if_ c ~then_:(tx, ty) ~else_:(ex, ey) =\n (F.if_ c ~then_:tx ~else_:ex, F.if_ c ~then_:ty ~else_:ey)\n\n open Bitstring_lib.Bitstring\n\n module Scalar = struct\n type t = Boolean.var Lsb_first.t\n\n let of_field = Field.unpack_full\n\n let to_field t = Field.project (Lsb_first.to_list t)\n end\n\n module type Shifted_intf = sig\n type t\n\n val zero : t\n\n val unshift_nonzero : t -> F.t * F.t\n\n val add : t -> F.t * F.t -> t\n\n val if_ : Boolean.var -> then_:t -> else_:t -> t\n end\n\n module Shifted (M : sig\n val shift : t\n end)\n () : Shifted_intf = struct\n type t = F.t * F.t\n\n let zero = M.shift\n\n let unshift_nonzero t = add_exn t (negate M.shift)\n\n let add t pt = add_exn t pt\n\n let if_ = if_\n end\n\n let shifted () =\n let shift = exists typ ~compute:(fun () -> Constant.random ()) in\n let module S =\n Shifted\n (struct\n let shift = shift\n end)\n ()\n in\n (module S : Shifted_intf)\n\n (* This doesn't have great performance because it uses add_exn. Should be optimized *)\n let scale ?init t (c : Boolean.var Bitstring_lib.Bitstring.Lsb_first.t) =\n let (module S) = shifted () in\n let c = Bitstring_lib.Bitstring.Lsb_first.to_list c in\n let rec go i bs0 acc pt =\n match bs0 with\n | [] ->\n acc\n | b :: bs ->\n let acc' =\n let add_pt = S.add acc pt in\n let don't_add_pt = acc in\n S.if_ b ~then_:add_pt ~else_:don't_add_pt\n and pt' = double pt in\n go (i + 1) bs acc' pt'\n in\n let init =\n match init with None -> S.zero | Some init -> S.(add zero init)\n in\n S.unshift_nonzero (go 0 c init t)\nend\n\nmodule type Native_base_field_inputs = sig\n (** Snarky instance to use. *)\n module Impl : Snarky_backendless.Snark_intf.Run\n\n include\n Inputs_intf\n with module Impl := Impl\n and type F.t = Impl.Field.t\n and type F.Constant.t = Impl.field\nend\n\nmodule For_native_base_field (Inputs : Native_base_field_inputs) = struct\n open Core_kernel\n open Inputs\n open Impl\n include Make_checked (Inputs)\n\n module Window_table = struct\n open Tuple_lib\n\n type t = Constant.t Quadruple.t array\n\n let window_size = 2\n\n let windows = (Params.group_size_in_bits + window_size - 1) / window_size\n\n let shift_left_by_window_size =\n let rec go i acc =\n if i = 0 then acc else go (i - 1) Constant.(acc + acc)\n in\n go window_size\n\n (* (create g).(i) = ( unrelated_base^i + 2^{window_size*i} 0 g, unrelated_base^i + 2^{window_size*i} g, unrelated_base^i + 2^{window_size*i} (2 g), unrelated_base^i + 2^{window_size*i} (3 g) ) *)\n let create ~shifts g =\n let pure_windows =\n (* pure_windows.(i) = 2^{window_size * i} ( g, 2 g, 3 g) *)\n let w0 =\n let g2 = Constant.(g + g) in\n let g3 = Constant.(g2 + g) in\n (g, g2, g3)\n in\n let a = Array.init windows ~f:(fun _ -> w0) in\n for i = 1 to windows - 1 do\n a.(i) <- Triple.map ~f:shift_left_by_window_size a.(i - 1)\n done ;\n a\n in\n Array.mapi pure_windows ~f:(fun i (a, b, c) ->\n let shift = shifts.(i) in\n Constant.(shift, shift + a, shift + b, shift + c) )\n end\n\n let pow2s g =\n let n = Window_table.windows + 1 in\n assert (n < Params.group_size_in_bits) ;\n let a = Array.init n ~f:(fun _ -> g) in\n for i = 1 to n - 1 do\n let x = a.(i - 1) in\n a.(i) <- Constant.(x + x)\n done ;\n a\n\n module Scaling_precomputation = struct\n type t =\n { base : Constant.t; shifts : Constant.t array; table : Window_table.t }\n\n let group_map =\n lazy\n (let params =\n Group_map.Params.create (module Field.Constant) Params.{ a; b }\n in\n Group_map.to_group (module Field.Constant) ~params )\n\n let string_to_bits s =\n List.concat_map (String.to_list s) ~f:(fun c ->\n let c = Char.to_int c in\n List.init 8 ~f:(fun i -> (c lsr i) land 1 = 1) )\n\n let create base =\n let unrelated_base =\n let x, y = Constant.to_affine_exn base in\n Digestif.BLAKE2S.digest_string\n Field.Constant.(to_string x ^ \",\" ^ to_string y)\n |> Digestif.BLAKE2S.to_raw_string |> string_to_bits\n |> Field.Constant.project |> Lazy.force group_map |> Constant.of_affine\n in\n let shifts = pow2s unrelated_base in\n { base; shifts; table = Window_table.create ~shifts base }\n end\n\n let add_unsafe =\n let div_unsafe x y =\n let z =\n exists Field.typ\n ~compute:\n As_prover.(fun () -> Field.Constant.( / ) (read_var x) (read_var y))\n in\n (* z = x / y <=> z * y = x *)\n assert_r1cs z y x ; z\n in\n add' ~div:div_unsafe\n\n let lookup_point (b0, b1) (t1, t2, t3, t4) =\n let b0_and_b1 = Boolean.( && ) b0 b1 in\n let lookup_one (a1, a2, a3, a4) =\n let open Field.Constant in\n let ( * ) x b = F.scale b x in\n let ( +^ ) = Field.( + ) in\n F.constant a1\n +^ ((a2 - a1) * (b0 :> Field.t))\n +^ ((a3 - a1) * (b1 :> Field.t))\n +^ ((a4 + a1 - a2 - a3) * (b0_and_b1 :> Field.t))\n in\n let x1, y1 = Constant.to_affine_exn t1\n and x2, y2 = Constant.to_affine_exn t2\n and x3, y3 = Constant.to_affine_exn t3\n and x4, y4 = Constant.to_affine_exn t4 in\n (* This is optimized for Marlin-style constraints. *)\n let seal a =\n let a' = exists Field.typ ~compute:(fun () -> As_prover.read_var a) in\n Field.Assert.equal a a' ; a'\n in\n (seal (lookup_one (x1, x2, x3, x4)), seal (lookup_one (y1, y2, y3, y4)))\n\n let rec pairs = function\n | [] ->\n []\n | x :: y :: xs ->\n (x, y) :: pairs xs\n | [ x ] ->\n [ (x, Boolean.false_) ]\n\n type shifted = { value : t; shift : Constant.t }\n\n let scale_known (pc : Scaling_precomputation.t) bs =\n let bs =\n let bs = Array.of_list bs in\n let num_bits = Array.length bs in\n Array.init\n ((Array.length bs + 1) / 2)\n ~f:(fun i ->\n let get j = if j < num_bits then bs.(j) else Boolean.false_ in\n (get (2 * i), get ((2 * i) + 1)) )\n in\n let windows_required = Array.length bs in\n let terms =\n Array.mapi bs ~f:(fun i bit_pair -> lookup_point bit_pair pc.table.(i))\n in\n let with_shifts = Array.reduce_exn terms ~f:add_unsafe in\n let shift =\n let unrelated_base = pc.shifts.(0) in\n\n (*\n 0b1111... * unrelated_base = (2^windows_required - 1) * unrelated_base\n\n is what we added and need to take away for the final result. *)\n Constant.(pc.shifts.(windows_required) + negate unrelated_base)\n in\n { value = with_shifts; shift }\n\n let unshift { value; shift } =\n add_exn value (constant (Constant.negate shift))\n\n let multiscale_known pairs =\n Array.map pairs ~f:(fun (s, g) -> scale_known g s)\n |> Array.reduce_exn ~f:(fun t1 t2 ->\n { value = add_exn t1.value t2.value\n ; shift = Constant.(t1.shift + t2.shift)\n } )\n |> unshift\n\n let scale_known pc bs = unshift (scale_known pc bs)\n\n (* b ? t : -t *)\n let conditional_negation (b : Boolean.var) (x, y) =\n let y' =\n exists Field.typ\n ~compute:\n As_prover.(\n fun () ->\n if read Boolean.typ b then read Field.typ y\n else Field.Constant.negate (read Field.typ y))\n in\n assert_r1cs y Field.((of_int 2 * (b :> Field.t)) - of_int 1) y' ;\n (x, y')\n\n let p_plus_q_plus_p ((x1, y1) : t) ((x2, y2) : t) =\n let open Field in\n let ( ! ) = As_prover.read typ in\n let lambda_1 =\n exists typ ~compute:Constant.(fun () -> (!y2 - !y1) / (!x2 - !x1))\n in\n let x3 =\n exists typ\n ~compute:Constant.(fun () -> (!lambda_1 * !lambda_1) - !x1 - !x2)\n in\n let lambda_2 =\n exists typ\n ~compute:Constant.(fun () -> (of_int 2 * !y1 / (!x1 - !x3)) - !lambda_1)\n in\n let x4 =\n exists typ\n ~compute:Constant.(fun () -> (!lambda_2 * !lambda_2) - !x3 - !x1)\n in\n let y4 =\n exists typ ~compute:Constant.(fun () -> ((!x1 - !x4) * !lambda_2) - !y1)\n in\n (* Determines lambda_1 *)\n assert_r1cs (x2 - x1) lambda_1 (y2 - y1) ;\n (* Determines x_3 *)\n assert_square lambda_1 (x1 + x2 + x3) ;\n (* Determines lambda_2 *)\n assert_r1cs (x1 - x3) (lambda_1 + lambda_2) (of_int 2 * y1) ;\n (* Determines x4 *)\n assert_square lambda_2 (x3 + x1 + x4) ;\n (* Determines y4 *)\n assert_r1cs (x1 - x4) lambda_2 (y4 + y1) ;\n (x4, y4)\n\n (* Input:\n t, r (LSB)\n\n Output:\n (2*r + 1 + 2^len(r)) t\n *)\n let scale_fast (t : Field.t * Field.t) (`Times_two_plus_1_plus_2_to_len r) :\n Field.t * Field.t =\n let n = Array.length r in\n let acc = ref (double t) in\n let () =\n for i = 0 to n - 1 do\n let q = conditional_negation r.(i) t in\n acc := p_plus_q_plus_p !acc q\n done\n in\n !acc\n\n (* Input:\n t, k (LSB)\n\n Output:\n (k + 2^{len(k) - 1}) t\n\n Based on [Daira's algorithm](https://github.com/zcash/zcash/issues/3924)\n *)\n let scale_fast t (`Plus_two_to_len_minus_1 k) =\n let m = Array.length k - 1 in\n let r = Array.init m ~f:(fun i -> k.(i + 1)) in\n let two_r_plus_1_plus_two_to_m =\n scale_fast t (`Times_two_plus_1_plus_2_to_len r)\n in\n if_ k.(0) ~then_:two_r_plus_1_plus_two_to_m\n ~else_:(add_exn two_r_plus_1_plus_two_to_m (negate t))\n\n let%test_unit \"scale_fast\" =\n let scale_constant (t, bs) =\n let rec go acc bs =\n match bs with\n | [] ->\n acc\n | b :: bs ->\n let acc = Constant.(acc + acc) in\n let acc = if b then Constant.(acc + t) else acc in\n go acc bs\n in\n let k = Array.length bs in\n go Constant.(t + negate t) (List.init k ~f:(fun i -> bs.(k - 1 - i)))\n in\n let module A = struct\n type t = Impl.Field.Constant.t * Impl.Field.Constant.t\n [@@deriving sexp, compare]\n end in\n let one = Constant.of_affine Params.one in\n [%test_eq: A.t]\n (Constant.to_affine_exn Constant.(one + negate one + one))\n Constant.(to_affine_exn one) ;\n [%test_eq: A.t]\n (Constant.to_affine_exn (scale_constant (one, [| true |])))\n Constant.(to_affine_exn one) ;\n [%test_eq: A.t]\n (Constant.to_affine_exn (scale_constant (one, [| false; true |])))\n Constant.(to_affine_exn (one + one)) ;\n [%test_eq: A.t]\n (Constant.to_affine_exn (scale_constant (one, [| true; true |])))\n Constant.(to_affine_exn (one + one + one)) ;\n [%test_eq: A.t]\n (Constant.to_affine_exn (scale_constant (one, [| false; false; true |])))\n Constant.(to_affine_exn (one + one + one + one)) ;\n [%test_eq: A.t]\n (Constant.to_affine_exn (scale_constant (one, [| true; false; true |])))\n Constant.(to_affine_exn (one + one + one + one + one)) ;\n let g = Typ.tuple2 Field.typ Field.typ in\n let two_to_the m =\n scale_constant (one, Array.init (m + 1) ~f:(fun i -> i = m))\n in\n [%test_eq: A.t]\n (Constant.to_affine_exn (two_to_the 2))\n Constant.(to_affine_exn (one + one + one + one)) ;\n let n = 4 in\n let bits = Array.init n ~f:(fun _ -> Random.bool ()) in\n Internal_Basic.Test.test_equal\n ~equal:[%eq: Field.Constant.t * Field.Constant.t]\n ~sexp_of_t:[%sexp_of: Field.Constant.t * Field.Constant.t]\n (Typ.tuple2 g (Typ.array ~length:n Boolean.typ))\n g\n (fun (t, bs) ->\n make_checked (fun () -> scale_fast t (`Plus_two_to_len_minus_1 bs)) )\n (fun (t, bs) ->\n let open Constant in\n let t = of_affine t in\n to_affine_exn (scale_constant (t, bs) + two_to_the (n - 1)) )\n (Params.one, bits)\nend\n","open Core_kernel\n\n(** The string that preceeds the JSON header, to identify the file kind before\n attempting to parse it.\n*)\nlet header_string = \"MINA_SNARK_KEYS\\n\"\n\nmodule UInt64 = struct\n (* [Unsigned_extended] depends on pickles, manually include what we need here\n to break a dependency cycle\n\n TODO: Separate [Unsigned_extended] into snark and non-snark parts.\n *)\n type t = Unsigned.UInt64.t [@@deriving ord, equal]\n\n let to_yojson x = `String (Unsigned.UInt64.to_string x)\n\n let of_yojson = function\n | `String x ->\n Or_error.try_with (fun () -> Unsigned.UInt64.of_string x)\n |> Result.map_error ~f:(fun err ->\n sprintf\n \"Snark_keys_header.UInt64.of_yojson: Could not parse string \\\n as UInt64: %s\"\n (Error.to_string_hum err) )\n | _ ->\n Error \"Snark_keys_header.UInt64.of_yojson: Expected a string\"\n\n let sexp_of_t x = Sexp.Atom (Unsigned.UInt64.to_string x)\n\n let t_of_sexp = function\n | Sexp.Atom x ->\n Unsigned.UInt64.of_string x\n | _ ->\n failwith \"Snark_keys_header.UInt64.t_of_sexp: Expected an atom\"\nend\n\nmodule Kind = struct\n (** The 'kind' of data in the file.\n For example, a step proving key for the base transaction snark may have the\n kind:\n{[\n {type_= \"step_proving_key\"; identifier= \"transaction_snark_base\"}\n|}\n *)\n type t =\n { type_ : string [@key \"type\"]\n (** Identifies the type of data that the file contains *)\n ; identifier : string\n (** Identifies the specific purpose of the file's data, in a\n human-readable format\n *)\n }\n [@@deriving yojson, sexp, ord, equal]\nend\n\nmodule Constraint_constants = struct\n module Transaction_capacity = struct\n (** Transaction pool capacity *)\n type t = Log_2 of int | Txns_per_second_x10 of int\n [@@deriving sexp, ord, equal]\n\n let to_yojson t : Yojson.Safe.t =\n match t with\n | Log_2 i ->\n `Assoc [ (\"two_to_the\", `Int i) ]\n | Txns_per_second_x10 i ->\n `Assoc [ (\"txns_per_second_x10\", `Int i) ]\n\n let of_yojson (json : Yojson.Safe.t) =\n match json with\n | `Assoc [ (\"two_to_the\", `Int i) ] ->\n Ok (Log_2 i)\n | `Assoc [ (\"txns_per_second_x10\", `Int i) ] ->\n Ok (Txns_per_second_x10 i)\n | `Assoc _ ->\n Error\n \"Snark_keys_header.Constraint_constants.Transaction_capacity.of_yojson: \\\n Expected a JSON object containing the field 'two_to_the' or \\\n 'txns_per_second_x10'\"\n | _ ->\n Error\n \"Snark_keys_header.Constraint_constants.Transaction_capacity.of_yojson: \\\n Expected a JSON object\"\n end\n\n module Fork_config = struct\n (** Fork data *)\n type t =\n { previous_state_hash : string\n ; previous_length : int\n ; previous_global_slot : int\n }\n [@@deriving yojson, sexp, ord, equal]\n\n let opt_to_yojson t : Yojson.Safe.t =\n match t with Some t -> to_yojson t | None -> `Assoc []\n\n let opt_of_yojson (json : Yojson.Safe.t) =\n match json with\n | `Assoc [] ->\n Ok None\n | _ ->\n Result.map (of_yojson json) ~f:(fun t -> Some t)\n end\n\n (** The constants used in the constraint system. *)\n type t =\n { sub_windows_per_window : int\n ; ledger_depth : int\n ; work_delay : int\n ; block_window_duration_ms : int\n ; transaction_capacity : Transaction_capacity.t\n ; pending_coinbase_depth : int\n ; coinbase_amount : UInt64.t\n ; supercharged_coinbase_factor : int\n ; account_creation_fee : UInt64.t\n ; fork :\n (Fork_config.t option\n [@to_yojson Fork_config.opt_to_yojson]\n [@of_yojson Fork_config.opt_of_yojson] )\n }\n [@@deriving yojson, sexp, ord, equal]\nend\n\nmodule Commits = struct\n (** Commit identifiers *)\n type t = { mina : string; marlin : string }\n [@@deriving yojson, sexp, ord, equal]\nend\n\nlet header_version = 1\n\n(** Header contents *)\ntype t =\n { header_version : int\n ; kind : Kind.t\n ; constraint_constants : Constraint_constants.t\n ; commits : Commits.t\n ; length : int\n ; commit_date : string\n ; constraint_system_hash : string\n ; identifying_hash : string\n }\n[@@deriving yojson, sexp, ord, equal]\n\nlet prefix = \"MINA_SNARK_KEYS\\n\"\n\nlet prefix_len = String.length prefix\n\nlet parse_prefix (lexbuf : Lexing.lexbuf) =\n let open Or_error.Let_syntax in\n Result.map_error ~f:(fun err ->\n Error.tag_arg err \"Could not read prefix\" (\"prefix\", prefix)\n [%sexp_of: string * string] )\n @@ Or_error.try_with_join (fun () ->\n (* This roughly mirrors the behavior of [Yojson.Safe.read_ident],\n except that we have a known fixed length to parse, and that it is a\n failure to read any string except the prefix. We manually update\n the lexbuf to be consistent with the output of this function.\n *)\n (* Manually step the lexbuffer forward to the [lex_curr_pos], so that\n [refill_buf] will know that we're only interested in buffer\n contents from that position onwards.\n *)\n lexbuf.lex_start_pos <- lexbuf.lex_curr_pos ;\n lexbuf.lex_last_pos <- lexbuf.lex_curr_pos ;\n lexbuf.lex_start_p <- lexbuf.lex_curr_p ;\n let%bind () =\n (* Read more if the buffer doesn't contain the whole prefix. *)\n if lexbuf.lex_buffer_len - lexbuf.lex_curr_pos >= prefix_len then\n return ()\n else if lexbuf.lex_eof_reached then\n Or_error.error_string \"Unexpected end-of-file\"\n else (\n lexbuf.refill_buff lexbuf ;\n if lexbuf.lex_buffer_len - lexbuf.lex_curr_pos >= prefix_len then\n return ()\n else if lexbuf.lex_eof_reached then\n Or_error.error_string \"Unexpected end-of-file\"\n else\n Or_error.error_string\n \"Unexpected short read: broken lexbuffer or end-of-file\" )\n in\n let read_prefix =\n Lexing.sub_lexeme lexbuf lexbuf.lex_curr_pos\n (lexbuf.lex_curr_pos + prefix_len)\n in\n let%map () =\n if String.equal prefix read_prefix then return ()\n else\n Or_error.error \"Incorrect prefix\"\n (\"read prefix\", read_prefix)\n [%sexp_of: string * string]\n in\n (* Update the positions to match our end state *)\n lexbuf.lex_curr_pos <- lexbuf.lex_curr_pos + prefix_len ;\n lexbuf.lex_last_pos <- lexbuf.lex_last_pos ;\n lexbuf.lex_curr_p <-\n { lexbuf.lex_curr_p with\n pos_bol = lexbuf.lex_curr_p.pos_bol + prefix_len\n ; pos_cnum = lexbuf.lex_curr_p.pos_cnum + prefix_len\n } ;\n (* This matches the action given by [Yojson.Safe.read_ident]. *)\n lexbuf.lex_last_action <- 1 )\n\nlet parse_lexbuf (lexbuf : Lexing.lexbuf) =\n let open Or_error.Let_syntax in\n Result.map_error ~f:(Error.tag ~tag:\"Failed to read snark key header\")\n @@ let%bind () = parse_prefix lexbuf in\n Or_error.try_with (fun () ->\n let yojson_parsebuffer = Yojson.init_lexer () in\n (* We use [read_t] here rather than one of the alternatives to avoid\n 'greedy' parsing that will attempt to continue and read the file's\n contents beyond the header.\n *)\n Yojson.Safe.read_t yojson_parsebuffer lexbuf )\n\nlet%test_module \"Check parsing of header\" =\n ( module struct\n let valid_header =\n { header_version = 1\n ; kind = { type_ = \"type\"; identifier = \"identifier\" }\n ; constraint_constants =\n { sub_windows_per_window = 4\n ; ledger_depth = 8\n ; work_delay = 1000\n ; block_window_duration_ms = 1000\n ; transaction_capacity = Log_2 3\n ; pending_coinbase_depth = 12\n ; coinbase_amount = Unsigned.UInt64.of_int 1\n ; supercharged_coinbase_factor = 1\n ; account_creation_fee = Unsigned.UInt64.of_int 1\n ; fork = None\n }\n ; commits =\n { mina = \"7e1fb2cd9138af1d0f24e78477efd40a2a0fcd07\"\n ; marlin = \"75836c41fc4947acce9c938da1b2f506843e90ed\"\n }\n ; length = 4096\n ; commit_date = \"2020-01-01 00:00:00.000000Z\"\n ; constraint_system_hash = \"ABCDEF1234567890\"\n ; identifying_hash = \"ABCDEF1234567890\"\n }\n\n let valid_header_string = Yojson.Safe.to_string (to_yojson valid_header)\n\n let valid_header_with_prefix = prefix ^ valid_header_string\n\n module Tests (Lexing : sig\n val from_string : ?with_positions:bool -> string -> Lexing.lexbuf\n end) =\n struct\n let%test \"doesn't parse without prefix\" =\n parse_lexbuf (Lexing.from_string valid_header_string)\n |> Or_error.is_error\n\n let%test \"doesn't parse with incorrect prefix\" =\n parse_lexbuf (Lexing.from_string (\"BLAH\" ^ valid_header_string))\n |> Or_error.is_error\n\n let%test \"doesn't parse with matching-length prefix\" =\n let fake_prefix = String.init prefix_len ~f:(fun _ -> 'a') in\n parse_lexbuf (Lexing.from_string (fake_prefix ^ valid_header_string))\n |> Or_error.is_error\n\n let%test \"doesn't parse with partial matching prefix\" =\n let partial_prefix =\n String.sub prefix ~pos:0 ~len:(prefix_len - 1) ^ \" \"\n in\n parse_lexbuf (Lexing.from_string (partial_prefix ^ valid_header_string))\n |> Or_error.is_error\n\n let%test \"doesn't parse with short file\" =\n parse_lexbuf (Lexing.from_string \"BLAH\") |> Or_error.is_error\n\n let%test \"doesn't parse with prefix only\" =\n parse_lexbuf (Lexing.from_string prefix) |> Or_error.is_error\n\n let%test_unit \"parses valid header with prefix\" =\n parse_lexbuf (Lexing.from_string valid_header_with_prefix)\n |> Or_error.ok_exn |> ignore\n\n let%test_unit \"parses valid header with prefix and data\" =\n parse_lexbuf\n (Lexing.from_string (valid_header_with_prefix ^ \"DATADATADATA\"))\n |> Or_error.ok_exn |> ignore\n end\n\n let%test_module \"Parsing from the start of the lexbuf\" =\n (module Tests (Lexing))\n\n let%test_module \"Parsing from part-way through a lexbuf\" =\n ( module struct\n include Tests (struct\n let from_string ?with_positions:_ str =\n let prefix = \"AAAAAAAAAA\" in\n let prefix_len = String.length prefix in\n let lexbuf = Lexing.from_string (prefix ^ str) in\n lexbuf.lex_start_pos <- 0 ;\n lexbuf.lex_curr_pos <- prefix_len ;\n lexbuf.lex_last_pos <- prefix_len ;\n lexbuf\n end)\n end )\n\n let%test_module \"Parsing with refill\" =\n ( module struct\n include Tests (struct\n let from_string ?with_positions:_ str =\n let init = ref true in\n let initial_prefix = \"AAAAAAAAAA\" in\n let initial_prefix_len = String.length initial_prefix in\n let offset = ref 0 in\n let str_len = String.length str in\n let lexbuf =\n Lexing.from_function (fun buffer length ->\n match !init with\n | true ->\n init := false ;\n (* Initial read: fill with junk up to the first character\n of the actual prefix\n *)\n Bytes.From_string.blit ~src:initial_prefix ~src_pos:0\n ~dst:buffer ~dst_pos:0 ~len:initial_prefix_len ;\n Bytes.set buffer initial_prefix_len str.[0] ;\n offset := 1 ;\n initial_prefix_len + 1\n | false ->\n (* Subsequent read: fill the rest of the buffer. *)\n let len = Int.min length (str_len - !offset) in\n if len = 0 then 0\n else (\n Bytes.From_string.blit ~src:str ~src_pos:!offset\n ~dst:buffer ~dst_pos:0 ~len ;\n offset := !offset + len ;\n len ) )\n in\n (* Load the initial content into the buffer *)\n lexbuf.refill_buff lexbuf ;\n lexbuf.lex_start_pos <- 0 ;\n lexbuf.lex_curr_pos <- initial_prefix_len ;\n lexbuf.lex_last_pos <- initial_prefix_len ;\n lexbuf\n end)\n end )\n end )\n\nlet write_with_header ~expected_max_size_log2 ~append_data header filename =\n (* In order to write the correct length here, we provide the maximum expected\n size and store that in the initial header. Once the data has been written,\n we record the length and then modify the 'length' field to hold the\n correct data.\n Happily, since the header is JSON-encoded, we can pad the calculated\n length with spaces and the header will still form a valid JSON-encoded\n object.\n This intuitively feels hacky, but the only way this can fail are if we are\n not able to write all of our data to the filesystem, or if the file is\n modified during the writing process. In either of these cases, we would\n have the same issue even if we were to pre-compute the length and do the\n write atomically.\n *)\n let length = 1 lsl expected_max_size_log2 in\n if length <= 0 then\n failwith\n \"Snark_keys_header.write_header: expected_max_size_log2 is too large, \\\n the resulting length underflows\" ;\n let header_string =\n Yojson.Safe.to_string (to_yojson { header with length })\n in\n (* We look for the \"length\" field first, to ensure that we find our length\n and not some other data that happens to match it. Due to the\n JSON-encoding, we will only find the first field named \"length\", which is\n the one that we want to modify.\n *)\n let length_offset =\n String.substr_index_exn header_string ~pattern:\"\\\"length\\\":\"\n in\n let length_string = string_of_int length in\n let length_data_offset =\n prefix_len\n + String.substr_index_exn ~pos:length_offset header_string\n ~pattern:length_string\n in\n (* We use [binary=true] to ensure that line endings aren't converted, so that\n files can be used regardless of the operating system that generated them.\n *)\n Out_channel.with_file ~binary:true filename ~f:(fun out_channel ->\n Out_channel.output_string out_channel prefix ;\n Out_channel.output_string out_channel header_string ;\n (* Newline, to allow [head -n 2 path/to/file | tail -n 1] to easily\n extract the header.\n *)\n Out_channel.output_char out_channel '\\n' ) ;\n append_data filename ;\n (* Core doesn't let us open a file without appending or truncating, so we use\n stdlib instead.\n *)\n let out_channel =\n Stdlib.open_out_gen [ Open_wronly; Open_binary ] 0 filename\n in\n let true_length = Out_channel.length out_channel |> Int.of_int64_exn in\n if true_length > length then\n failwith\n \"Snark_keys_header.write_header: 2^expected_max_size_log2 is less than \\\n the true length of the file\" ;\n let true_length_string = string_of_int true_length in\n let true_length_padding =\n String.init\n (String.length length_string - String.length true_length_string)\n ~f:(fun _ -> ' ')\n in\n (* Go to where we wrote the data *)\n Out_channel.seek out_channel (Int64.of_int length_data_offset) ;\n (* Pad with spaces *)\n Out_channel.output_string out_channel true_length_padding ;\n (* Output the true length *)\n Out_channel.output_string out_channel true_length_string ;\n Out_channel.close out_channel\n\nlet read_with_header ~read_data filename =\n let open Or_error.Let_syntax in\n Or_error.try_with_join (fun () ->\n (* We use [binary=true] to ensure that line endings aren't converted. *)\n let in_channel = In_channel.create ~binary:true filename in\n let file_length = In_channel.length in_channel |> Int.of_int64_exn in\n let lexbuf = Lexing.from_channel in_channel in\n let%bind header_json = parse_lexbuf lexbuf in\n let%bind header =\n of_yojson header_json |> Result.map_error ~f:Error.of_string\n in\n let offset = lexbuf.lex_curr_pos in\n let%bind () =\n In_channel.seek in_channel (Int64.of_int offset) ;\n match In_channel.input_char in_channel with\n | Some '\\n' ->\n Ok ()\n | None ->\n Or_error.error_string\n \"Incomplete header: the newline terminator is missing\"\n | Some c ->\n Or_error.error \"Header was not terminated by a newline character\"\n (\"character\", c) [%sexp_of: string * char]\n in\n (* Bump offset for the newline terminator *)\n let offset = offset + 1 in\n In_channel.close in_channel ;\n let%bind () =\n if header.length = file_length then Ok ()\n else\n Or_error.error\n \"Header length didn't match file length. Was the file only \\\n partially downloaded?\"\n ((\"header length\", header.length), (\"file length\", file_length))\n [%sexp_of: (string * int) * (string * int)]\n in\n let%map data = Or_error.try_with (fun () -> read_data ~offset filename) in\n (header, data) )\n","open Base\n\nlet rec sexp_to_yojson (sexp : Sexp.t) : Yojson.Safe.t =\n match sexp with\n | Atom str ->\n `String str\n | List sexps ->\n `List (List.map ~f:sexp_to_yojson sexps)\n\nlet sexp_record_to_yojson (sexp : Sexp.t) : Yojson.Safe.t =\n let fail () =\n failwith\n (Printf.sprintf\n \"sexp_record_to_yojson called on an s-expression with a non-record \\\n structure %s\"\n (Sexp.to_string_hum sexp) )\n in\n match sexp with\n | List fields ->\n `Assoc\n (List.map fields ~f:(function\n | List [ Atom label; value ] ->\n (label, sexp_to_yojson value)\n | _ ->\n fail () ) )\n | _ ->\n fail ()\n\nlet rec sexp_of_yojson (json : Yojson.Safe.t) : (Sexp.t, string) Result.t =\n match json with\n | `String str ->\n Ok (Sexp.Atom str)\n | `List jsons ->\n let rev_sexps =\n List.fold_until ~init:[] jsons ~finish:Result.return\n ~f:(fun sexps json ->\n match sexp_of_yojson json with\n | Ok sexp ->\n Continue (sexp :: sexps)\n | Error str ->\n Stop (Error str) )\n in\n Result.map ~f:(fun l -> Sexp.List (List.rev l)) rev_sexps\n | _ ->\n Error \"Error_json.sexp_of_yojson: Expected a string or a list\"\n\ntype info_data =\n | Sexp of Sexp.t\n | String of string\n | Exn of exn\n | Of_list of int option * int * Yojson.Safe.t\n\n(* Used to encode sub-lists of infos *)\n\ntype info_tag =\n { tag : string; data : Sexp.t option; loc : Source_code_position.t option }\n\ntype 'a info_repr =\n { base : 'a; rev_tags : info_tag list; backtrace : string option }\n\nlet info_repr_to_yojson (info : info_data info_repr) : Yojson.Safe.t =\n let base_pairs =\n match info.base with\n | Sexp sexp ->\n [ (\"sexp\", sexp_to_yojson sexp) ]\n | String str ->\n [ (\"string\", `String str) ]\n | Exn exn ->\n [ ( \"exn_name\"\n , `String Stdlib.Obj.Extension_constructor.(name @@ of_val exn) )\n ; (\"exn\", sexp_to_yojson (Sexplib.Conv.sexp_of_exn exn))\n ]\n | Of_list (Some trunc_after, length, json) ->\n [ (\"multiple\", json)\n ; (\"length\", `Int length)\n ; (\"truncated_after\", `Int trunc_after)\n ]\n | Of_list (None, length, json) ->\n [ (\"multiple\", json); (\"length\", `Int length) ]\n in\n let tags =\n let tag_to_json { tag; data; loc } =\n let jsons =\n match loc with\n | None ->\n []\n | Some loc ->\n [ (\"loc\", `String (Source_code_position.to_string loc)) ]\n in\n let jsons =\n match data with\n | None ->\n jsons\n | Some data ->\n (\"sexp\", sexp_to_yojson data) :: jsons\n in\n `Assoc ((\"tag\", `String tag) :: jsons)\n in\n match info.rev_tags with\n | [] ->\n []\n | _ :: _ ->\n [ (\"tags\", `List (List.rev_map ~f:tag_to_json info.rev_tags)) ]\n in\n let backtrace =\n match info.backtrace with\n | None ->\n []\n | Some backtrace ->\n (* Split backtrace at lines so that it prints nicely in errors *)\n [ ( \"backtrace\"\n , `List\n (List.map ~f:(fun s -> `String s) (String.split_lines backtrace))\n )\n ]\n in\n `Assoc (base_pairs @ tags @ backtrace)\n\n(* NOTE: Could also add a [of_yojson] version for everything except [Exn]\n (which could be converted to [String]), but it's not clear that it would\n ever be useful.\n*)\n\nlet rec info_internal_repr_to_yojson_aux (info : Info.Internal_repr.t)\n (acc : unit info_repr) : info_data info_repr =\n match info with\n | Could_not_construct sexp ->\n { acc with base = Sexp (List [ Atom \"Could_not_construct\"; sexp ]) }\n | Sexp sexp ->\n { acc with base = Sexp sexp }\n | String str ->\n { acc with base = String str }\n | Exn exn ->\n { acc with base = Exn exn }\n | Tag_sexp (tag, sexp, loc) ->\n { acc with\n base = Sexp sexp\n ; rev_tags = { tag; data = None; loc } :: acc.rev_tags\n }\n | Tag_t (tag, info) ->\n info_internal_repr_to_yojson_aux info\n { acc with rev_tags = { tag; data = None; loc = None } :: acc.rev_tags }\n | Tag_arg (tag, data, info) ->\n info_internal_repr_to_yojson_aux info\n { acc with\n rev_tags = { tag; data = Some data; loc = None } :: acc.rev_tags\n }\n | Of_list (trunc_after, infos) ->\n let rec rev_take i acc_len infos acc_infos =\n match (i, infos) with\n | _, [] ->\n (None, acc_len, acc_infos)\n | None, info :: infos ->\n let json_info = info_internal_repr_to_yojson info in\n rev_take i (acc_len + 1) infos (json_info :: acc_infos)\n | Some i, info :: infos ->\n if i > 0 then\n let json_info = info_internal_repr_to_yojson info in\n rev_take\n (Some (i - 1))\n (acc_len + 1) infos (json_info :: acc_infos)\n else (Some acc_len, acc_len + 1 + List.length infos, acc_infos)\n in\n let trunc_after, length, rev_json_infos =\n rev_take trunc_after 0 infos []\n in\n let json_infos = `List (List.rev rev_json_infos) in\n { acc with base = Of_list (trunc_after, length, json_infos) }\n | With_backtrace (info, backtrace) ->\n info_internal_repr_to_yojson_aux info\n { acc with backtrace = Some backtrace }\n\nand info_internal_repr_to_yojson (info : Info.Internal_repr.t) : Yojson.Safe.t =\n info_internal_repr_to_yojson_aux info\n { base = (); rev_tags = []; backtrace = None }\n |> info_repr_to_yojson\n\nlet info_to_yojson (info : Info.t) : Yojson.Safe.t =\n info_internal_repr_to_yojson (Info.Internal_repr.of_info info)\n\nlet error_to_yojson (err : Error.t) : Yojson.Safe.t =\n match info_to_yojson (err :> Info.t) with\n | `Assoc assocs ->\n `Assoc ((\"commit_id\", `String Mina_version.commit_id) :: assocs)\n | json ->\n `Assoc [ (\"commit_id\", `String Mina_version.commit_id); (\"error\", json) ]\n","open Core_kernel\nopen Pickles_types\nmodule Columns = Nat.N15\nmodule Columns_vec = Vector.Vector_15\nmodule Coefficients = Nat.N15\nmodule Coefficients_vec = Vector.Vector_15\nmodule Quotient_polynomial = Nat.N7\nmodule Quotient_polynomial_vec = Vector.Vector_7\nmodule Permuts_minus_1 = Nat.N6\nmodule Permuts_minus_1_vec = Vector.Vector_6\n\n[@@@warning \"-4\"]\n\nmodule Commitments = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t =\n Mina_wire_types.Pickles.Concrete_.Wrap_wire_proof.Commitments.V1.t =\n { w_comm :\n (Backend.Tick.Field.Stable.V1.t * Backend.Tick.Field.Stable.V1.t)\n Columns_vec.Stable.V1.t\n ; z_comm :\n Backend.Tick.Field.Stable.V1.t * Backend.Tick.Field.Stable.V1.t\n ; t_comm :\n (Backend.Tick.Field.Stable.V1.t * Backend.Tick.Field.Stable.V1.t)\n Quotient_polynomial_vec.Stable.V1.t\n }\n [@@deriving compare, sexp, yojson, hash, equal]\n\n [@@@warning \"+4\"]\n\n let to_latest = Fn.id\n end\n end]\n\n let to_kimchi ({ w_comm; z_comm; t_comm } : t) :\n Backend.Tock.Curve.Affine.t Plonk_types.Messages.t =\n { w_comm = Vector.map ~f:(fun x -> [| x |]) w_comm\n ; z_comm = [| z_comm |]\n ; t_comm = Array.map ~f:(fun x -> x) (Vector.to_array t_comm)\n ; lookup = None\n }\n\n let of_kimchi\n ({ w_comm; z_comm; t_comm; lookup = _ } :\n Backend.Tock.Curve.Affine.t Plonk_types.Messages.t ) : t =\n { w_comm = Vector.map ~f:(fun x -> x.(0)) w_comm\n ; z_comm = z_comm.(0)\n ; t_comm = Vector.of_array_and_length_exn t_comm Quotient_polynomial.n\n }\nend\n\n[@@@warning \"-4\"]\n\nmodule Evaluations = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t =\n Mina_wire_types.Pickles.Concrete_.Wrap_wire_proof.Evaluations.V1.t =\n { w :\n (Backend.Tock.Field.Stable.V1.t * Backend.Tock.Field.Stable.V1.t)\n Columns_vec.Stable.V1.t\n ; coefficients :\n (Backend.Tock.Field.Stable.V1.t * Backend.Tock.Field.Stable.V1.t)\n Columns_vec.Stable.V1.t\n ; z : Backend.Tock.Field.Stable.V1.t * Backend.Tock.Field.Stable.V1.t\n ; s :\n (Backend.Tock.Field.Stable.V1.t * Backend.Tock.Field.Stable.V1.t)\n Permuts_minus_1_vec.Stable.V1.t\n ; generic_selector :\n Backend.Tock.Field.Stable.V1.t * Backend.Tock.Field.Stable.V1.t\n ; poseidon_selector :\n Backend.Tock.Field.Stable.V1.t * Backend.Tock.Field.Stable.V1.t\n ; complete_add_selector :\n Backend.Tock.Field.Stable.V1.t * Backend.Tock.Field.Stable.V1.t\n ; mul_selector :\n Backend.Tock.Field.Stable.V1.t * Backend.Tock.Field.Stable.V1.t\n ; emul_selector :\n Backend.Tock.Field.Stable.V1.t * Backend.Tock.Field.Stable.V1.t\n ; endomul_scalar_selector :\n Backend.Tock.Field.Stable.V1.t * Backend.Tock.Field.Stable.V1.t\n }\n [@@deriving compare, sexp, yojson, hash, equal]\n\n [@@@warning \"+4\"]\n\n let to_latest = Fn.id\n end\n end]\n\n let to_kimchi\n ({ w\n ; coefficients\n ; z\n ; s\n ; generic_selector\n ; poseidon_selector\n ; complete_add_selector\n ; mul_selector\n ; emul_selector\n ; endomul_scalar_selector\n } :\n t ) :\n (Backend.Tock.Field.t array * Backend.Tock.Field.t array)\n Plonk_types.Evals.t =\n let conv (x, y) = ([| x |], [| y |]) in\n { w = Vector.map ~f:conv w\n ; coefficients = Vector.map ~f:conv coefficients\n ; z = conv z\n ; s = Vector.map ~f:conv s\n ; generic_selector = conv generic_selector\n ; poseidon_selector = conv poseidon_selector\n ; complete_add_selector = conv complete_add_selector\n ; mul_selector = conv mul_selector\n ; emul_selector = conv emul_selector\n ; endomul_scalar_selector = conv endomul_scalar_selector\n ; range_check0_selector = None\n ; range_check1_selector = None\n ; foreign_field_add_selector = None\n ; foreign_field_mul_selector = None\n ; xor_selector = None\n ; rot_selector = None\n ; lookup_aggregation = None\n ; lookup_table = None\n ; lookup_sorted = [ None; None; None; None; None ]\n ; runtime_lookup_table = None\n ; runtime_lookup_table_selector = None\n ; xor_lookup_selector = None\n ; lookup_gate_lookup_selector = None\n ; range_check_lookup_selector = None\n ; foreign_field_mul_lookup_selector = None\n }\n\n let of_kimchi\n ({ w\n ; coefficients\n ; z\n ; s\n ; generic_selector\n ; poseidon_selector\n ; complete_add_selector\n ; mul_selector\n ; emul_selector\n ; endomul_scalar_selector\n ; range_check0_selector = _\n ; range_check1_selector = _\n ; foreign_field_add_selector = _\n ; foreign_field_mul_selector = _\n ; xor_selector = _\n ; rot_selector = _\n ; lookup_aggregation = _\n ; lookup_table = _\n ; lookup_sorted = _\n ; runtime_lookup_table = _\n ; runtime_lookup_table_selector = _\n ; xor_lookup_selector = _\n ; lookup_gate_lookup_selector = _\n ; range_check_lookup_selector = _\n ; foreign_field_mul_lookup_selector = _\n } :\n (Backend.Tock.Field.t array * Backend.Tock.Field.t array)\n Plonk_types.Evals.t ) : t =\n let conv (x, y) = (x.(0), y.(0)) in\n { w = Vector.map ~f:conv w\n ; coefficients = Vector.map ~f:conv coefficients\n ; z = conv z\n ; s = Vector.map ~f:conv s\n ; generic_selector = conv generic_selector\n ; poseidon_selector = conv poseidon_selector\n ; complete_add_selector = conv complete_add_selector\n ; mul_selector = conv mul_selector\n ; emul_selector = conv emul_selector\n ; endomul_scalar_selector = conv endomul_scalar_selector\n }\nend\n\n[@@@warning \"-4\"]\n\n[%%versioned\nmodule Stable = struct\n module V1 = struct\n type t = Mina_wire_types.Pickles.Concrete_.Wrap_wire_proof.V1.t =\n { commitments : Commitments.Stable.V1.t\n ; evaluations : Evaluations.Stable.V1.t\n ; ft_eval1 : Backend.Tock.Field.Stable.V1.t\n ; bulletproof :\n ( Backend.Tick.Field.Stable.V1.t * Backend.Tick.Field.Stable.V1.t\n , Backend.Tock.Field.Stable.V1.t )\n Plonk_types.Openings.Bulletproof.Stable.V1.t\n (* TODO-URGENT: Validate bulletproof length on the rust side *)\n }\n [@@deriving compare, sexp, yojson, hash, equal]\n\n [@@@warning \"+4\"]\n\n let to_latest = Fn.id\n end\nend]\n\nlet to_kimchi_proof ({ commitments; bulletproof; evaluations; ft_eval1 } : t) :\n Backend.Tock.Proof.t =\n { messages = Commitments.to_kimchi commitments\n ; openings =\n { proof = bulletproof\n ; evals = Evaluations.to_kimchi evaluations\n ; ft_eval1\n }\n }\n\nlet of_kimchi_proof\n ({ messages; openings = { proof; evals; ft_eval1 } } : Backend.Tock.Proof.t)\n : t =\n { commitments = Commitments.of_kimchi messages\n ; bulletproof = proof\n ; evaluations = Evaluations.of_kimchi evals\n ; ft_eval1\n }\n","open Core_kernel\nopen Import\nmodule SC = Scalar_challenge\n\n(* Implementation of the algorithm described on page 29 of the Halo paper\n https://eprint.iacr.org/2019/1021.pdf\n*)\n\nlet num_bits = 128\n\n(* Has the side effect of checking that [scalar] fits in 128 bits. *)\nlet to_field_checked' (type f) ?(num_bits = num_bits)\n (module Impl : Snarky_backendless.Snark_intf.Run with type field = f)\n { SC.inner = (scalar : Impl.Field.t) } =\n let open Impl in\n let neg_one = Field.Constant.(negate one) in\n let a_func = function\n | 0 ->\n Field.Constant.zero\n | 1 ->\n Field.Constant.zero\n | 2 ->\n neg_one\n | 3 ->\n Field.Constant.one\n | _ ->\n raise (Invalid_argument \"a_func\")\n in\n let b_func = function\n | 0 ->\n neg_one\n | 1 ->\n Field.Constant.one\n | 2 ->\n Field.Constant.zero\n | 3 ->\n Field.Constant.zero\n | _ ->\n raise (Invalid_argument \"a_func\")\n in\n let ( !! ) = As_prover.read_var in\n (* MSB bits *)\n let bits_msb =\n lazy\n (let open Field.Constant in\n unpack !!scalar |> Fn.flip List.take num_bits |> Array.of_list_rev\n (*\n |> Array.of_list_rev_map ~f:(fun b -> if b then one else zero) *))\n in\n let nybbles_per_row = 8 in\n let bits_per_row = 2 * nybbles_per_row in\n [%test_eq: int] (num_bits mod bits_per_row) 0 ;\n let rows = num_bits / bits_per_row in\n let nybbles_by_row =\n lazy\n (Array.init rows ~f:(fun i ->\n Array.init nybbles_per_row ~f:(fun j ->\n let bit = (bits_per_row * i) + (2 * j) in\n let b0 = (Lazy.force bits_msb).(bit + 1) in\n let b1 = (Lazy.force bits_msb).(bit) in\n Bool.to_int b0 + (2 * Bool.to_int b1) ) ) )\n in\n let two = Field.of_int 2 in\n let a = ref two in\n let b = ref two in\n let n = ref Field.zero in\n let mk f = exists Field.typ ~compute:f in\n let state = ref [] in\n for i = 0 to rows - 1 do\n let n0 = !n in\n let a0 = !a in\n let b0 = !b in\n let xs =\n Array.init nybbles_per_row ~f:(fun j ->\n mk (fun () ->\n Field.Constant.of_int (Lazy.force nybbles_by_row).(i).(j) ) )\n in\n let open Field.Constant in\n let double x = x + x in\n let n8 =\n mk (fun () ->\n Array.fold xs ~init:!!n0 ~f:(fun acc x ->\n (acc |> double |> double) + !!x ) )\n in\n let a8 =\n mk (fun () ->\n Array.fold\n (Lazy.force nybbles_by_row).(i)\n ~init:!!a0\n ~f:(fun acc x -> (acc |> double) + a_func x) )\n in\n let b8 =\n mk (fun () ->\n Array.fold\n (Lazy.force nybbles_by_row).(i)\n ~init:!!b0\n ~f:(fun acc x -> (acc |> double) + b_func x) )\n in\n state :=\n { Kimchi_backend_common.Endoscale_scalar_round.a0\n ; a8\n ; b0\n ; b8\n ; n0\n ; n8\n ; x0 = xs.(0)\n ; x1 = xs.(1)\n ; x2 = xs.(2)\n ; x3 = xs.(3)\n ; x4 = xs.(4)\n ; x5 = xs.(5)\n ; x6 = xs.(6)\n ; x7 = xs.(7)\n }\n :: !state ;\n n := n8 ;\n a := a8 ;\n b := b8 ;\n ()\n done ;\n with_label __LOC__ (fun () ->\n assert_\n Snarky_backendless.Constraint.\n { annotation = Some __LOC__\n ; basic =\n Kimchi_backend_common.Plonk_constraint_system.Plonk_constraint.(\n T (EC_endoscalar { state = Array.of_list_rev !state }))\n } ) ;\n (!a, !b, !n)\n\nlet to_field_checked (type f) ?num_bits\n (module Impl : Snarky_backendless.Snark_intf.Run with type field = f) ~endo\n ({ SC.inner = (scalar : Impl.Field.t) } as s) =\n let open Impl in\n let a, b, n = to_field_checked' ?num_bits (module Impl) s in\n Field.Assert.equal n scalar ;\n Field.(scale a endo + b)\n\nlet to_field_constant (type f) ~endo\n (module F : Plonk_checks.Field_intf with type t = f) { SC.inner = c } =\n let bits = Array.of_list (Challenge.Constant.to_bits c) in\n let a = ref (F.of_int 2) in\n let b = ref (F.of_int 2) in\n let one = F.of_int 1 in\n let neg_one = F.(of_int 0 - one) in\n for i = (128 / 2) - 1 downto 0 do\n let s = if bits.(2 * i) then one else neg_one in\n (a := F.(!a + !a)) ;\n (b := F.(!b + !b)) ;\n let r_2i1 = bits.((2 * i) + 1) in\n if r_2i1 then a := F.(!a + s) else b := F.(!b + s)\n done ;\n F.((!a * endo) + !b)\n\nlet test (type f)\n (module Impl : Snarky_backendless.Snark_intf.Run with type field = f)\n ~(endo : f) =\n let open Impl in\n let module T = Internal_Basic in\n let n = 128 in\n let module Field_constant = struct\n include Field.Constant\n\n let _if_ b ~then_ ~else_ = if b then then_ () else else_ ()\n end in\n Quickcheck.test ~trials:10\n (Quickcheck.Generator.list_with_length n Bool.quickcheck_generator)\n ~f:(fun xs ->\n try\n T.Test.test_equal ~equal:Field.Constant.equal\n ~sexp_of_t:Field.Constant.sexp_of_t\n (Typ.list ~length:n Boolean.typ)\n Field.typ\n (fun s ->\n make_checked (fun () ->\n to_field_checked\n (module Impl)\n ~endo\n (SC.create (Impl.Field.pack s)) ) )\n (fun s ->\n to_field_constant\n (module Field_constant)\n ~endo\n (SC.create (Challenge.Constant.of_bits s)) )\n xs\n with e ->\n eprintf !\"Input %{sexp: bool list}\\n%!\" xs ;\n raise e )\n\nmodule Make\n (Impl : Snarky_backendless.Snark_intf.Run)\n (G : Intf.Group(Impl).S with type t = Impl.Field.t * Impl.Field.t)\n (Challenge : Challenge.S with module Impl := Impl) (Endo : sig\n val base : Impl.Field.Constant.t\n\n val scalar : G.Constant.Scalar.t\n end) =\nstruct\n open Impl\n module Scalar = G.Constant.Scalar\n\n type t = Challenge.t SC.t\n\n module Constant = struct\n type t = Challenge.Constant.t SC.t\n\n let to_field = to_field_constant ~endo:Endo.scalar (module Scalar)\n end\n\n let typ : (t, Constant.t) Typ.t = SC.typ Challenge.typ\n\n let num_bits = 128\n\n let seal = Util.seal (module Impl)\n\n let endo ?(num_bits = num_bits) t { SC.inner = (scalar : Field.t) } =\n let ( !! ) = As_prover.read_var in\n (* MSB bits *)\n let bits =\n lazy\n (let open Field.Constant in\n unpack !!scalar |> Fn.flip List.take num_bits\n |> Array.of_list_rev_map ~f:(fun b -> if b then one else zero))\n in\n let bits () = Lazy.force bits in\n let xt, yt = Tuple_lib.Double.map t ~f:seal in\n let bits_per_row = 4 in\n let rows = num_bits / bits_per_row in\n let acc =\n with_label __LOC__ (fun () ->\n let p = G.( + ) t (seal (Field.scale xt Endo.base), yt) in\n ref G.(p + p) )\n in\n let n_acc = ref Field.zero in\n let mk f = exists Field.typ ~compute:f in\n let rounds_rev = ref [] in\n for i = 0 to rows - 1 do\n let n_acc_prev = !n_acc in\n let b1 = mk (fun () -> (bits ()).(i * bits_per_row)) in\n let b2 = mk (fun () -> (bits ()).((i * bits_per_row) + 1)) in\n let b3 = mk (fun () -> (bits ()).((i * bits_per_row) + 2)) in\n let b4 = mk (fun () -> (bits ()).((i * bits_per_row) + 3)) in\n let open Field.Constant in\n let double x = x + x in\n let xp, yp = !acc in\n let xq1 = mk (fun () -> (one + ((Endo.base - one) * !!b1)) * !!xt) in\n let yq1 = mk (fun () -> (double !!b2 - one) * !!yt) in\n\n let s1 = mk (fun () -> (!!yq1 - !!yp) / (!!xq1 - !!xp)) in\n let s1_squared = mk (fun () -> square !!s1) in\n let s2 =\n mk (fun () ->\n (double !!yp / (double !!xp + !!xq1 - !!s1_squared)) - !!s1 )\n in\n\n let xr = mk (fun () -> !!xq1 + square !!s2 - !!s1_squared) in\n let yr = mk (fun () -> ((!!xp - !!xr) * !!s2) - !!yp) in\n\n let xq2 = mk (fun () -> (one + ((Endo.base - one) * !!b3)) * !!xt) in\n let yq2 = mk (fun () -> (double !!b4 - one) * !!yt) in\n let s3 = mk (fun () -> (!!yq2 - !!yr) / (!!xq2 - !!xr)) in\n let s3_squared = mk (fun () -> square !!s3) in\n let s4 =\n mk (fun () ->\n (double !!yr / (double !!xr + !!xq2 - !!s3_squared)) - !!s3 )\n in\n\n let xs = mk (fun () -> !!xq2 + square !!s4 - !!s3_squared) in\n let ys = mk (fun () -> ((!!xr - !!xs) * !!s4) - !!yr) in\n acc := (xs, ys) ;\n n_acc :=\n mk (fun () ->\n !!n_acc_prev |> double |> ( + ) !!b1 |> double |> ( + ) !!b2\n |> double |> ( + ) !!b3 |> double |> ( + ) !!b4 ) ;\n rounds_rev :=\n { Kimchi_backend_common.Endoscale_round.xt\n ; yt\n ; xp\n ; yp\n ; n_acc = n_acc_prev\n ; xr\n ; yr\n ; s1\n ; s3\n ; b1\n ; b2\n ; b3\n ; b4\n }\n :: !rounds_rev\n done ;\n let xs, ys = !acc in\n with_label __LOC__ (fun () ->\n assert_\n { annotation = Some __LOC__\n ; basic =\n Kimchi_backend_common.Plonk_constraint_system.Plonk_constraint.(\n T\n (EC_endoscale\n { xs\n ; ys\n ; n_acc = !n_acc\n ; state = Array.of_list_rev !rounds_rev\n } ))\n } ) ;\n with_label __LOC__ (fun () -> Field.Assert.equal !n_acc scalar) ;\n !acc\n\n let endo ?num_bits t s = with_label \"endo\" (fun () -> endo ?num_bits t s)\n\n let%test_unit \"endo\" =\n let module T = Internal_Basic in\n let random_point =\n let rec pt x =\n let y2 = G.Params.(T.Field.(b + (x * (a + (x * x))))) in\n if T.Field.is_square y2 then (x, T.Field.sqrt y2)\n else pt T.Field.(x + one)\n in\n G.Constant.of_affine (pt (T.Field.random ()))\n in\n let n = 128 in\n Quickcheck.test ~trials:10\n (Quickcheck.Generator.list_with_length n Bool.quickcheck_generator)\n ~f:(fun xs ->\n try\n T.Test.test_equal ~equal:G.Constant.equal\n ~sexp_of_t:G.Constant.sexp_of_t\n (Typ.tuple2 G.typ (Typ.list ~length:n Boolean.typ))\n G.typ\n (fun (g, s) ->\n make_checked (fun () -> endo g (SC.create (Field.pack s))) )\n (fun (g, s) ->\n let x =\n Constant.to_field (SC.create (Challenge.Constant.of_bits s))\n in\n G.Constant.scale g x )\n (random_point, xs)\n with e ->\n eprintf !\"Input %{sexp: bool list}\\n%!\" xs ;\n raise e )\n\n let endo_inv ((gx, gy) as g) chal =\n let res =\n exists G.typ\n ~compute:\n As_prover.(\n fun () ->\n let x = Constant.to_field (read typ chal) in\n G.Constant.scale (read G.typ g) Scalar.(one / x))\n in\n let x, y = endo res chal in\n Field.Assert.(equal gx x ; equal gy y) ;\n res\nend\n","open Pickles_types\nopen Core_kernel\nopen Import\nopen Backend\nmodule Wrap_impl = Snarky_backendless.Snark.Run.Make (Tock)\n\n(** returns [true] if the [i]th bit of [x] is set to 1 *)\nlet test_bit x i = B.(shift_right x i land one = one)\n\n(* TODO: I think there are other forbidden values as well. *)\n\n(** returns all the values that can fit in [~size_in_bits] bits and that are\n * either congruent with -2^[~size_in_bits] mod [~modulus] \n * or congruent with -2^[~size_in_bits] - 1 mod [~modulus] \n *)\nlet forbidden_shifted_values ~modulus:r ~size_in_bits =\n let two_to_n = B.(pow (of_int 2) (of_int size_in_bits)) in\n (* this function doesn't make sense if the modulus is smaller *)\n assert (B.(r < two_to_n)) ;\n let neg_two_to_n = B.(neg two_to_n) in\n let representatives x =\n let open Sequence in\n (* All values equivalent to x mod r that fit in [size_in_bits]\n many bits. *)\n let fits_in_n_bits x = B.(x < two_to_n) in\n unfold ~init:B.(x % r) ~f:(fun x -> Some (x, B.(x + r)))\n |> take_while ~f:fits_in_n_bits\n |> to_list\n in\n List.concat_map [ neg_two_to_n; B.(neg_two_to_n - one) ] ~f:representatives\n |> List.dedup_and_sort ~compare:B.compare\n\nmodule Step = struct\n module Impl = Snarky_backendless.Snark.Run.Make (Tick)\n include Impl\n module Verification_key = Tick.Verification_key\n module Proving_key = Tick.Proving_key\n\n module Keypair = struct\n type t = { pk : Proving_key.t; vk : Verification_key.t } [@@deriving fields]\n\n let create = Fields.create\n\n let generate ~prev_challenges cs =\n let open Tick.Keypair in\n let keypair = create ~prev_challenges cs in\n { pk = pk keypair; vk = vk keypair }\n end\n\n module Other_field = struct\n (* Tick.Field.t = p < q = Tock.Field.t *)\n\n module Constant = Tock.Field\n\n type t = (* Low bits, high bit *)\n Field.t * Boolean.var\n\n let forbidden_shifted_values =\n let size_in_bits = Constant.size_in_bits in\n let other_mod = Wrap_impl.Bigint.to_bignum_bigint Constant.size in\n let values = forbidden_shifted_values ~size_in_bits ~modulus:other_mod in\n let f x =\n let open Option.Let_syntax in\n let hi = test_bit x (Field.size_in_bits - 1) in\n let lo = B.shift_right x 1 in\n let%map lo =\n let modulus = Impl.Field.size in\n if B.compare modulus lo <= 0 then None\n else Some Impl.Bigint.(to_field (of_bignum_bigint lo))\n in\n (lo, hi)\n in\n values |> List.filter_map ~f\n\n let%test_unit \"preserve circuit behavior for Step\" =\n let expected_list =\n [ (\"45560315531506369815346746415080538112\", false)\n ; (\"45560315531506369815346746415080538113\", false)\n ; ( \"14474011154664524427946373126085988481727088556502330059655218120611762012161\"\n , true )\n ; ( \"14474011154664524427946373126085988481727088556502330059655218120611762012161\"\n , true )\n ]\n in\n let str_list =\n List.map forbidden_shifted_values ~f:(fun (a, b) ->\n (Tick.Field.to_string a, b) )\n in\n assert ([%equal: (string * bool) list] str_list expected_list)\n\n let typ_unchecked : (t, Constant.t) Typ.t =\n Typ.transport\n (Typ.tuple2 Field.typ Boolean.typ)\n ~there:(fun x ->\n match Tock.Field.to_bits x with\n | [] ->\n assert false\n | low :: high ->\n (Field.Constant.project high, low) )\n ~back:(fun (high, low) ->\n let high = Field.Constant.unpack high in\n Tock.Field.of_bits (low :: high) )\n\n let check t =\n let open Internal_Basic in\n let open Let_syntax in\n let equal (x1, b1) (x2, b2) =\n let%bind x_eq = Field.Checked.equal x1 (Field.Var.constant x2) in\n let b_eq = match b2 with true -> b1 | false -> Boolean.not b1 in\n Boolean.( && ) x_eq b_eq\n in\n let (Typ typ_unchecked) = typ_unchecked in\n let%bind () = typ_unchecked.check t in\n Checked.List.map forbidden_shifted_values ~f:(equal t)\n >>= Boolean.any >>| Boolean.not >>= Boolean.Assert.is_true\n\n let typ : _ Snarky_backendless.Typ.t =\n let (Typ typ_unchecked) = typ_unchecked in\n Typ { typ_unchecked with check }\n\n let _to_bits (x, b) =\n Field.unpack x ~length:(Field.size_in_bits - 1) @ [ b ]\n end\n\n module Digest = Digest.Make (Impl)\n module Challenge = Challenge.Make (Impl)\n\n let input ~proofs_verified ~wrap_rounds ~feature_flags =\n let open Types.Step.Statement in\n let spec = spec proofs_verified wrap_rounds in\n let (T (typ, f, f_inv)) =\n Spec.packed_typ\n (module Impl)\n (T\n ( Shifted_value.Type2.typ Other_field.typ_unchecked\n , (fun (Shifted_value.Type2.Shifted_value x as t) ->\n Impl.run_checked (Other_field.check x) ;\n t )\n , Fn.id ) )\n spec\n in\n let typ = Typ.transport typ ~there:to_data ~back:of_data in\n Spec.ETyp.T (typ, (fun x -> of_data (f x)), fun x -> f_inv (to_data x))\nend\n\nmodule Wrap = struct\n module Impl = Wrap_impl\n include Impl\n module Challenge = Challenge.Make (Impl)\n module Digest = Digest.Make (Impl)\n module Wrap_field = Tock.Field\n module Step_field = Tick.Field\n module Verification_key = Tock.Verification_key\n module Proving_key = Tock.Proving_key\n\n module Keypair = struct\n type t = { pk : Proving_key.t; vk : Verification_key.t } [@@deriving fields]\n\n let create = Fields.create\n\n let generate ~prev_challenges cs =\n let open Tock.Keypair in\n let keypair = create ~prev_challenges cs in\n { pk = pk keypair; vk = vk keypair }\n end\n\n module Other_field = struct\n module Constant = Tick.Field\n open Impl\n\n type t = Field.t\n\n let forbidden_shifted_values =\n let other_mod = Step.Impl.Bigint.to_bignum_bigint Constant.size in\n let size_in_bits = Constant.size_in_bits in\n let values = forbidden_shifted_values ~size_in_bits ~modulus:other_mod in\n let f x =\n let modulus = Impl.Field.size in\n if B.compare modulus x <= 0 then None\n else Some Impl.Bigint.(to_field (of_bignum_bigint x))\n in\n values |> List.filter_map ~f\n\n let%test_unit \"preserve circuit behavior for Wrap\" =\n let expected_list =\n [ \"91120631062839412180561524743370440705\"\n ; \"91120631062839412180561524743370440706\"\n ]\n in\n let str_list =\n List.map forbidden_shifted_values ~f:Wrap_field.to_string\n in\n assert ([%equal: string list] str_list expected_list)\n\n let typ_unchecked, check =\n (* Tick -> Tock *)\n let (Typ t0 as typ_unchecked) =\n Typ.transport Field.typ\n ~there:(Fn.compose Tock.Field.of_bits Tick.Field.to_bits)\n ~back:(Fn.compose Tick.Field.of_bits Tock.Field.to_bits)\n in\n let check t =\n let open Internal_Basic in\n let open Let_syntax in\n let equal x1 x2 = Field.Checked.equal x1 (Field.Var.constant x2) in\n let%bind () = t0.check t in\n Checked.List.map forbidden_shifted_values ~f:(equal t)\n >>= Boolean.any >>| Boolean.not >>= Boolean.Assert.is_true\n in\n (typ_unchecked, check)\n\n let typ : _ Snarky_backendless.Typ.t =\n let (Typ typ_unchecked) = typ_unchecked in\n Typ { typ_unchecked with check }\n\n let _to_bits x = Field.unpack x ~length:Field.size_in_bits\n end\n\n let input () =\n let lookup =\n { Types.Wrap.Lookup_parameters.use = No\n ; zero =\n { value =\n { challenge = Limb_vector.Challenge.Constant.zero\n ; scalar =\n Shifted_value.Type1.Shifted_value Other_field.Constant.zero\n }\n ; var =\n { challenge = Impl.Field.zero\n ; scalar = Shifted_value.Type1.Shifted_value Impl.Field.zero\n }\n }\n }\n in\n let fp : (Impl.Field.t, Other_field.Constant.t) Typ.t =\n Other_field.typ_unchecked\n in\n let open Types.Wrap.Statement in\n let (T (typ, f, f_inv)) =\n Spec.packed_typ\n (module Impl)\n (T\n ( Shifted_value.Type1.typ fp\n , (fun (Shifted_value x as t) ->\n Impl.run_checked (Other_field.check x) ;\n t )\n , Fn.id ) )\n (* Wrap circuit: no features needed. *)\n (In_circuit.spec (module Impl) lookup Plonk_types.Features.none)\n in\n let feature_flags = Plonk_types.Features.none in\n let typ =\n Typ.transport typ\n ~there:(In_circuit.to_data ~option_map:Option.map ~to_opt:Fn.id)\n ~back:\n (In_circuit.of_data ~feature_flags ~option_map:Option.map\n ~of_opt:Plonk_types.Opt.to_option )\n in\n Spec.ETyp.T\n ( typ\n , (fun x ->\n In_circuit.of_data ~feature_flags ~option_map:Plonk_types.Opt.map\n (f x) ~of_opt:Fn.id )\n , fun x ->\n f_inv\n (In_circuit.to_data ~option_map:Plonk_types.Opt.map x\n ~to_opt:Plonk_types.Opt.to_option_unsafe ) )\nend\n","open Core_kernel\n\nopen Kimchi_backend_common.Plonk_constraint_system.Plonk_constraint\n\nlet seal i = Tuple_lib.Double.map ~f:(Util.seal i)\n\nlet add_fast (type f)\n (module Impl : Snarky_backendless.Snark_intf.Run with type field = f)\n ?(check_finite = true) ((x1, y1) as p1) ((x2, y2) as p2) :\n Impl.Field.t * Impl.Field.t =\n let p1 = seal (module Impl) p1 in\n let p2 = seal (module Impl) p2 in\n let open Impl in\n let open Field.Constant in\n let bool b = if b then one else zero in\n let eq a b = As_prover.(equal (read_var a) (read_var b)) in\n let same_x_bool = lazy (eq x1 x2) in\n let ( ! ) = Lazy.force in\n let ( !! ) = As_prover.read_var in\n let mk f = exists Field.typ ~compute:f in\n let same_x = mk (fun () -> bool !same_x_bool) in\n let inf =\n if check_finite then Field.zero\n else mk (fun () -> bool (!same_x_bool && not (eq y1 y2)))\n in\n let inf_z =\n mk (fun () ->\n if eq y1 y2 then zero\n else if !same_x_bool then inv (!!y2 - !!y1)\n else zero )\n in\n let x21_inv =\n mk (fun () -> if !same_x_bool then zero else inv (!!x2 - !!x1))\n in\n let s =\n mk (fun () ->\n if !same_x_bool then\n let x1_squared = square !!x1 in\n let y1 = !!y1 in\n (x1_squared + x1_squared + x1_squared) / (y1 + y1)\n else (!!y2 - !!y1) / (!!x2 - !!x1) )\n in\n let x3 = mk (fun () -> square !!s - (!!x1 + !!x2)) in\n let y3 = mk (fun () -> (!!s * (!!x1 - !!x3)) - !!y1) in\n let p3 = (x3, y3) in\n with_label \"add_fast\" (fun () ->\n assert_\n { Snarky_backendless.Constraint.annotation = Some __LOC__\n ; basic =\n Kimchi_backend_common.Plonk_constraint_system.Plonk_constraint.T\n (EC_add_complete\n { p1; p2; p3; inf; same_x; slope = s; inf_z; x21_inv } )\n } ;\n p3 )\n\nmodule Make\n (Impl : Snarky_backendless.Snark_intf.Run)\n (G : Intf.Group(Impl).S with type t = Impl.Field.t * Impl.Field.t) =\nstruct\n open Impl\n\n let seal = seal (module Impl)\n\n let add_fast = add_fast (module Impl)\n\n let bits_per_chunk = 5\n\n (* Number of chunks needed to cover the given number of bits. *)\n let chunks_needed ~num_bits =\n (num_bits + (bits_per_chunk - 1)) / bits_per_chunk\n\n let scale_fast_msb_bits base\n (Pickles_types.Shifted_value.Type1.Shifted_value\n (bits_msb : Boolean.var array) ) : Field.t * Field.t =\n let ((x_base, y_base) as base) = seal base in\n let ( !! ) = As_prover.read_var in\n let mk f = exists Field.typ ~compute:f in\n (* MSB bits *)\n let num_bits = Array.length bits_msb in\n let chunks = num_bits / bits_per_chunk in\n [%test_eq: int] (num_bits mod bits_per_chunk) 0 ;\n let acc = ref (add_fast base base) in\n let n_acc = ref Field.zero in\n let rounds_rev = ref [] in\n for chunk = 0 to chunks - 1 do\n let open Field.Constant in\n let double x = x + x in\n let bs =\n Array.init bits_per_chunk ~f:(fun i ->\n (bits_msb.(Int.((chunk * bits_per_chunk) + i)) :> Field.t) )\n in\n let n_acc_prev = !n_acc in\n n_acc :=\n mk (fun () ->\n Array.fold bs ~init:!!n_acc_prev ~f:(fun acc b -> double acc + !!b) ) ;\n let accs, slopes =\n Array.fold_map bs ~init:!acc ~f:(fun (x_acc, y_acc) b ->\n let s1 =\n mk (fun () ->\n (!!y_acc - (!!y_base * (double !!b - one)))\n / (!!x_acc - !!x_base) )\n in\n let s1_squared = mk (fun () -> square !!s1) in\n let s2 =\n mk (fun () ->\n (double !!y_acc / (double !!x_acc + !!x_base - !!s1_squared))\n - !!s1 )\n in\n let x_res = mk (fun () -> !!x_base + square !!s2 - !!s1_squared) in\n let y_res = mk (fun () -> ((!!x_acc - !!x_res) * !!s2) - !!y_acc) in\n let acc' = (x_res, y_res) in\n (acc', (acc', s1)) )\n |> snd |> Array.unzip\n in\n let accs = Array.append [| !acc |] accs in\n acc := Array.last accs ;\n rounds_rev :=\n { Kimchi_backend_common.Scale_round.accs\n ; bits = bs\n ; ss = slopes\n ; n_prev = n_acc_prev\n ; n_next = !n_acc\n ; base\n }\n :: !rounds_rev\n done ;\n assert_\n { Snarky_backendless.Constraint.annotation = Some __LOC__\n ; basic =\n Kimchi_backend_common.Plonk_constraint_system.Plonk_constraint.T\n (EC_scale { state = Array.of_list_rev !rounds_rev })\n } ;\n (* TODO: Return n_acc ? *)\n !acc\n\n (*\n Computes\n\n fun (g, t) -> (2 * t + 1 + 2^len(t)) g *)\n let scale_fast_unpack base\n (Pickles_types.Shifted_value.Type1.Shifted_value (scalar : Field.t))\n ~num_bits : (Field.t * Field.t) * Boolean.var array =\n let ((x_base, y_base) as base) = seal base in\n let ( !! ) = As_prover.read_var in\n let mk f = exists Field.typ ~compute:f in\n (* MSB bits *)\n (*\n let num_bits = Field.size_in_bits in *)\n let chunks = num_bits / bits_per_chunk in\n [%test_eq: int] (num_bits mod bits_per_chunk) 0 ;\n let bits_msb =\n exists (Typ.array ~length:num_bits Field.typ) ~compute:(fun () ->\n let open Field.Constant in\n unpack !!scalar |> Fn.flip List.take num_bits\n |> Array.of_list_rev_map ~f:(fun b -> if b then one else zero) )\n in\n let acc = ref (add_fast base base) in\n let n_acc = ref Field.zero in\n let rounds_rev = ref [] in\n for chunk = 0 to chunks - 1 do\n let open Field.Constant in\n let double x = x + x in\n let bs =\n Array.init bits_per_chunk ~f:(fun i ->\n bits_msb.(Int.((chunk * bits_per_chunk) + i)) )\n in\n let n_acc_prev = !n_acc in\n n_acc :=\n mk (fun () ->\n Array.fold bs ~init:!!n_acc_prev ~f:(fun acc b -> double acc + !!b) ) ;\n let accs, slopes =\n Array.fold_map bs ~init:!acc ~f:(fun (x_acc, y_acc) b ->\n let s1 =\n mk (fun () ->\n (!!y_acc - (!!y_base * (double !!b - one)))\n / (!!x_acc - !!x_base) )\n in\n let s1_squared = mk (fun () -> square !!s1) in\n let s2 =\n mk (fun () ->\n (double !!y_acc / (double !!x_acc + !!x_base - !!s1_squared))\n - !!s1 )\n in\n let x_res = mk (fun () -> !!x_base + square !!s2 - !!s1_squared) in\n let y_res = mk (fun () -> ((!!x_acc - !!x_res) * !!s2) - !!y_acc) in\n let acc' = (x_res, y_res) in\n (acc', (acc', s1)) )\n |> snd |> Array.unzip\n in\n let accs = Array.append [| !acc |] accs in\n acc := Array.last accs ;\n rounds_rev :=\n { Kimchi_backend_common.Scale_round.accs\n ; bits = bs\n ; ss = slopes\n ; n_prev = n_acc_prev\n ; n_next = !n_acc\n ; base\n }\n :: !rounds_rev\n done ;\n assert_\n { Snarky_backendless.Constraint.annotation = Some __LOC__\n ; basic =\n Kimchi_backend_common.Plonk_constraint_system.Plonk_constraint.T\n (EC_scale { state = Array.of_list_rev !rounds_rev })\n } ;\n Field.Assert.equal !n_acc scalar ;\n let bits_lsb =\n let bs = Array.map bits_msb ~f:Boolean.Unsafe.of_cvar in\n Array.rev_inplace bs ; bs\n in\n (!acc, bits_lsb)\n\n let scale_fast_unpack base scalar ~num_bits :\n (Field.t * Field.t) * Boolean.var array =\n with_label \"scale_fast_unpack\" (fun () ->\n scale_fast_unpack base scalar ~num_bits )\n\n let scale_fast base s ~num_bits =\n let r, _bits = scale_fast_unpack base s ~num_bits in\n r\n\n module type Scalar_field_intf = sig\n module Constant : sig\n include Plonk_checks.Field_intf\n\n val to_bigint : t -> Impl.Bigint.t\n end\n\n type t = Field.t\n\n val typ : (t, Constant.t) Typ.t\n end\n\n (* Computes\n\n (g, s) -> (s + 2^{len(s) - 1})\n\n as\n\n let h = scale_fast g (s >> 1) in\n if s is odd then h else h - g\n ==\n let h = [ 2 * (s >> 1) + 1 + 2^{len(s) - 1} ] * g in\n if s is odd then h else h - g\n\n since if s is odd, then s = 2 * (s >> 1) + 1, and otherwise,\n s = 2 * (s >> 1) + 1 - 1.\n *)\n let scale_fast2 (g : G.t)\n (Pickles_types.Shifted_value.Type2.Shifted_value\n ((s_div_2 : Field.t), (s_odd : Boolean.var)) ) ~(num_bits : int) : G.t =\n let s_div_2_bits = num_bits - 1 in\n (* The number of chunks need for scaling by s_div_2. *)\n let chunks_needed = chunks_needed ~num_bits:s_div_2_bits in\n let actual_bits_used = chunks_needed * bits_per_chunk in\n let h, bits_lsb =\n scale_fast_unpack g (Shifted_value s_div_2) ~num_bits:actual_bits_used\n in\n (* Constrain the top bits of s_div_2 to be 0. *)\n with_label __LOC__ (fun () ->\n for i = s_div_2_bits to Array.length bits_lsb - 1 do\n Field.Assert.equal Field.zero (bits_lsb.(i) :> Field.t)\n done ) ;\n with_label __LOC__ (fun () ->\n G.if_ s_odd ~then_:h ~else_:(add_fast h (G.negate g)) )\n\n let scale_fast2' (type scalar_field)\n (module Scalar_field : Scalar_field_intf\n with type Constant.t = scalar_field ) g (s : Scalar_field.t) ~num_bits =\n let ((s_div_2, s_odd) as s_parts) =\n with_label __LOC__ (fun () ->\n exists\n Typ.(Scalar_field.typ * Boolean.typ)\n ~compute:\n As_prover.(\n fun () ->\n let s = read Scalar_field.typ s in\n let open Scalar_field.Constant in\n let s_odd = Bigint.test_bit (to_bigint s) 0 in\n ((if s_odd then s - one else s) / of_int 2, s_odd)) )\n in\n\n (* In this case, it's safe to use this field to compute\n\n 2 s_div_2 + b\n\n in the other field. *)\n with_label __LOC__ (fun () ->\n Field.Assert.equal Field.((of_int 2 * s_div_2) + (s_odd :> Field.t)) s ) ;\n scale_fast2 g (Pickles_types.Shifted_value.Type2.Shifted_value s_parts)\n ~num_bits\n\n let scale_fast a b = with_label __LOC__ (fun () -> scale_fast a b)\n\n let%test_module \"curve_ops\" =\n ( module struct\n module T = Internal_Basic\n\n let random_point =\n let rec pt x =\n let y2 = G.Params.(T.Field.(b + (x * (a + (x * x))))) in\n if T.Field.is_square y2 then (x, T.Field.sqrt y2)\n else pt T.Field.(x + one)\n in\n G.Constant.of_affine (pt (T.Field.of_int 0))\n\n let n = Field.size_in_bits\n\n let%test_unit \"scale fast 2\" =\n Quickcheck.test ~trials:5 Field.Constant.gen ~f:(fun s ->\n let input =\n let s_odd = T.Bigint.test_bit (T.Bigint.of_field s) 0 in\n Field.Constant.((if s_odd then s - one else s) / of_int 2, s_odd)\n in\n T.Test.test_equal ~equal:G.Constant.equal\n ~sexp_of_t:G.Constant.sexp_of_t\n (Typ.tuple2 G.typ (Typ.tuple2 Field.typ Boolean.typ))\n G.typ\n (fun (g, s) ->\n make_checked (fun () ->\n scale_fast2 ~num_bits:n g\n (Pickles_types.Shifted_value.Type2.Shifted_value s) ) )\n (fun (g, _) ->\n let x =\n let chunks_needed = chunks_needed ~num_bits:(n - 1) in\n let actual_bits_used = chunks_needed * bits_per_chunk in\n Pickles_types.Pcs_batch.pow ~one:G.Constant.Scalar.one\n ~mul:G.Constant.Scalar.( * )\n G.Constant.Scalar.(of_int 2)\n actual_bits_used\n |> G.Constant.Scalar.( + )\n (G.Constant.Scalar.project (Field.Constant.unpack s))\n in\n G.Constant.scale g x )\n (random_point, input) )\n\n let%test_unit \"scale fast\" =\n let open Pickles_types in\n let shift =\n Shifted_value.Type1.Shift.create (module G.Constant.Scalar)\n in\n Quickcheck.test ~trials:10\n Quickcheck.Generator.(\n map (list_with_length n Bool.quickcheck_generator) ~f:(fun bs ->\n Field.Constant.project bs |> Field.Constant.unpack ))\n ~f:(fun xs ->\n try\n T.Test.test_equal ~equal:G.Constant.equal\n ~sexp_of_t:G.Constant.sexp_of_t\n (Typ.tuple2 G.typ (Typ.list ~length:n Boolean.typ))\n G.typ\n (fun (g, s) ->\n make_checked (fun () ->\n scale_fast ~num_bits:n g\n (Pickles_types.Shifted_value.Type1.Shifted_value\n (Field.project s) ) ) )\n (fun (g, s) ->\n let open G.Constant.Scalar in\n let s = project s in\n let x =\n Shifted_value.Type1.to_field\n (module G.Constant.Scalar)\n ~shift (Pickles_types.Shifted_value.Type1.Shifted_value s)\n in\n G.Constant.scale g x )\n (random_point, xs)\n with e ->\n eprintf !\"Input %{sexp: bool list}\\n%!\" xs ;\n raise e )\n end )\nend\n","open Core_kernel\nopen Import\nopen Pickles_types\nopen Common\nopen Backend\n\n(* The step-proof \"reduced\" me-only contains the data of the standard me-only\n but without the wrap verification key. The purpose of this type is for sending\n step me-onlys on the wire. There is no need to send the wrap-key since everyone\n knows it. *)\nmodule Step = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type ('s, 'challenge_polynomial_commitments, 'bpcs) t =\n ( 's\n , 'challenge_polynomial_commitments\n , 'bpcs )\n Mina_wire_types\n .Pickles_reduced_messages_for_next_proof_over_same_field\n .Step\n .V1\n .t =\n { app_state : 's\n ; challenge_polynomial_commitments : 'challenge_polynomial_commitments\n ; old_bulletproof_challenges : 'bpcs\n }\n [@@deriving sexp, yojson, sexp, compare, hash, equal]\n end\n end]\n\n let prepare ~dlog_plonk_index\n { app_state\n ; challenge_polynomial_commitments\n ; old_bulletproof_challenges\n } =\n { Types.Step.Proof_state.Messages_for_next_step_proof.app_state\n ; challenge_polynomial_commitments\n ; dlog_plonk_index\n ; old_bulletproof_challenges =\n Vector.map ~f:Ipa.Step.compute_challenges old_bulletproof_challenges\n }\nend\n\nmodule Wrap = struct\n module Challenges_vector = struct\n module Vector = Pickles_types.Vector\n module Wrap_bp_vec = Import.Types.Wrap_bp_vec\n open Import\n\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V2 = struct\n type t =\n Limb_vector.Constant.Hex64.Stable.V1.t Vector.Vector_2.Stable.V1.t\n Scalar_challenge.Stable.V2.t\n Bulletproof_challenge.Stable.V1.t\n Wrap_bp_vec.Stable.V1.t\n [@@deriving sexp, compare, yojson, hash, equal]\n\n let to_latest = Fn.id\n end\n end]\n\n type t =\n Challenge.Constant.t Scalar_challenge.t Bulletproof_challenge.t\n Wrap_bp_vec.t\n [@@deriving sexp, compare, yojson, hash, equal]\n\n let (_ : (t, Stable.Latest.t) Type_equal.t) = Type_equal.T\n\n module Prepared = struct\n type t = (Tock.Field.t, Tock.Rounds.n) Vector.t\n end\n end\n\n type 'max_local_max_proofs_verified t =\n ( Tock.Inner_curve.Affine.t\n , (Challenges_vector.t, 'max_local_max_proofs_verified) Vector.t )\n Types.Wrap.Proof_state.Messages_for_next_wrap_proof.t\n\n module Prepared = struct\n type 'max_local_max_proofs_verified t =\n ( Tock.Inner_curve.Affine.t\n , (Challenges_vector.Prepared.t, 'max_local_max_proofs_verified) Vector.t\n )\n Types.Wrap.Proof_state.Messages_for_next_wrap_proof.t\n end\n\n let prepare\n ({ challenge_polynomial_commitment; old_bulletproof_challenges } : _ t) =\n { Types.Wrap.Proof_state.Messages_for_next_wrap_proof\n .challenge_polynomial_commitment\n ; old_bulletproof_challenges =\n Vector.map ~f:Ipa.Wrap.compute_challenges old_bulletproof_challenges\n }\nend\n","open Core_kernel\nopen Common\nopen Backend\nmodule Impl = Impls.Step\n\nlet _high_entropy_bits = 128\n\nlet sponge_params_constant =\n Sponge.Params.(map pasta_p_kimchi ~f:Impl.Field.Constant.of_string)\n\nlet tick_field_random_oracle ?(length = Tick.Field.size_in_bits - 1) s =\n Tick.Field.of_bits (Ro.bits_random_oracle ~length s)\n\nlet _unrelated_g =\n let group_map =\n unstage\n (group_map\n (module Tick.Field)\n ~a:Tick.Inner_curve.Params.a ~b:Tick.Inner_curve.Params.b )\n and str = Fn.compose bits_to_bytes Tick.Field.to_bits in\n fun (x, y) -> group_map (tick_field_random_oracle (str x ^ str y))\n\nopen Impl\n\n(* Debug helper to convert step circuit field element to a hex string *)\nlet read_step_circuit_field_element_as_hex fe =\n let prover_fe = As_prover.read Field.typ fe in\n Kimchi_backend.Pasta.Vesta_based_plonk.(\n Bigint.to_hex (Field.to_bigint prover_fe))\n\nmodule Other_field = struct\n type t = Tock.Field.t [@@deriving sexp]\n\n include (Tock.Field : module type of Tock.Field with type t := t)\n\n let size = Impls.Wrap.Bigint.to_bignum_bigint size\nend\n\nlet sponge_params =\n Sponge.Params.(map sponge_params_constant ~f:Impl.Field.constant)\n\n(* module Unsafe = struct\n let _unpack_unboolean ?(length = Field.size_in_bits) x =\n let res =\n exists\n (Typ.list Boolean.typ_unchecked ~length)\n ~compute:\n As_prover.(\n fun () -> List.take (Field.Constant.unpack (read_var x)) length)\n in\n Field.Assert.equal x (Field.project res) ;\n res\n end *)\n\nmodule Sponge = struct\n module Permutation =\n Sponge_inputs.Make\n (Impl)\n (struct\n include Tick_field_sponge.Inputs\n\n let params = Tick_field_sponge.params\n end)\n\n module S = Sponge.Make_debug_sponge (struct\n include Permutation\n module Circuit = Impls.Step\n\n (* Optional sponge name used in debug mode *)\n let sponge_name = \"step\"\n\n (* To enable debug mode, set environment variable [sponge_name] to \"t\", \"1\" or \"true\". *)\n let debug_helper_fn = read_step_circuit_field_element_as_hex\n end)\n\n include S\n\n let squeeze_field t = squeeze t\n\n let squeeze t = squeeze t\n\n let absorb t input =\n match input with\n | `Field x ->\n absorb t x\n | `Bits bs ->\n absorb t (Field.pack bs)\nend\n\nlet%test_unit \"sponge\" =\n let module T = Make_sponge.Test (Impl) (Tick_field_sponge.Field) (Sponge.S) in\n T.test Tick_field_sponge.params\n\n(* module Input_domain = struct\n let domain = Import.Domain.Pow_2_roots_of_unity 6\n\n let _lagrange_commitments =\n lazy\n (let domain_size = Import.Domain.size domain in\n Common.time \"lagrange\" (fun () ->\n Array.init domain_size ~f:(fun i ->\n let v =\n (Kimchi_bindings.Protocol.SRS.Fq.lagrange_commitment\n (Backend.Tock.Keypair.load_urs ())\n domain_size i )\n .unshifted\n in\n assert (Array.length v = 1) ;\n v.(0) |> Common.finite_exn ) ) )\n end *)\n\nmodule Inner_curve = struct\n module C = Kimchi_pasta.Pasta.Pallas\n\n module Inputs = struct\n module Impl = Impl\n\n module Params = struct\n include C.Params\n\n let one = C.to_affine_exn C.one\n\n let group_size_in_bits = Field.size_in_bits\n end\n\n module F = struct\n include struct\n open Impl.Field\n\n type nonrec t = t\n\n let ( * ), ( + ), ( - ), inv_exn, square, scale, if_, typ, constant =\n (( * ), ( + ), ( - ), inv, square, scale, if_, typ, constant)\n\n let negate x = scale x Constant.(negate one)\n end\n\n module Constant = struct\n open Impl.Field.Constant\n\n type nonrec t = t\n\n let ( * ), ( + ), ( - ), inv_exn, square, negate =\n (( * ), ( + ), ( - ), inv, square, negate)\n end\n\n let assert_square x y = Impl.assert_square x y\n\n let assert_r1cs x y z = Impl.assert_r1cs x y z\n end\n\n module Constant = struct\n include C.Affine\n module Scalar = Impls.Wrap.Field.Constant\n\n let scale (t : t) x : t = C.(to_affine_exn (scale (of_affine t) x))\n\n let random () = C.(to_affine_exn (random ()))\n\n let zero = Impl.Field.Constant.(zero, zero)\n\n let ( + ) t1 t2 =\n let is_zero (x, _) = Impl.Field.Constant.(equal zero x) in\n if is_zero t1 then t2\n else if is_zero t2 then t1\n else\n let r = C.(of_affine t1 + of_affine t2) in\n try C.to_affine_exn r with _ -> zero\n\n let negate x = C.(to_affine_exn (negate (of_affine x)))\n\n let to_affine_exn = Fn.id\n\n let of_affine = Fn.id\n end\n end\n\n module Params = Inputs.Params\n module Constant = Inputs.Constant\n module T = Snarky_curve.For_native_base_field (Inputs)\n\n include (\n T :\n module type of T\n with module Scaling_precomputation := T.Scaling_precomputation )\n\n module Scaling_precomputation = T.Scaling_precomputation\n\n let ( + ) t1 t2 = Plonk_curve_ops.add_fast (module Impl) t1 t2\n\n let double t = t + t\n\n let scale t bs =\n with_label __LOC__ (fun () ->\n T.scale t (Bitstring_lib.Bitstring.Lsb_first.of_list bs) )\n\n let to_field_elements (x, y) = [ x; y ]\n\n let assert_equal (x1, y1) (x2, y2) =\n Field.Assert.equal x1 x2 ; Field.Assert.equal y1 y2\n\n let scale_inv t bs =\n let res =\n exists typ\n ~compute:\n As_prover.(\n fun () ->\n C.scale\n (C.of_affine (read typ t))\n (Tock.Field.inv\n (Tock.Field.of_bits (List.map ~f:(read Boolean.typ) bs)) )\n |> C.to_affine_exn)\n in\n assert_equal t (scale res bs) ;\n res\n\n let negate = T.negate\n\n let one = T.one\n\n let if_ = T.if_\nend\n\nmodule Ops = Plonk_curve_ops.Make (Impl) (Inner_curve)\n\nlet%test_unit \"scale fast 2'\" =\n let open Impl in\n let module T = Internal_Basic in\n let module G = Inner_curve in\n let n = Field.size_in_bits in\n let module F = struct\n type t = Field.t\n\n let typ = Field.typ\n\n module Constant = struct\n include Field.Constant\n\n let to_bigint = Impl.Bigint.of_field\n end\n end in\n Quickcheck.test ~trials:5 Field.Constant.gen ~f:(fun s ->\n T.Test.test_equal ~equal:G.Constant.equal ~sexp_of_t:G.Constant.sexp_of_t\n (Typ.tuple2 G.typ Field.typ)\n G.typ\n (fun (g, s) ->\n make_checked (fun () -> Ops.scale_fast2' ~num_bits:n (module F) g s)\n )\n (fun (g, _) ->\n let x =\n let chunks_needed = Ops.chunks_needed ~num_bits:(n - 1) in\n let actual_bits_used = chunks_needed * Ops.bits_per_chunk in\n Pickles_types.Pcs_batch.pow ~one:G.Constant.Scalar.one\n ~mul:G.Constant.Scalar.( * )\n G.Constant.Scalar.(of_int 2)\n actual_bits_used\n |> G.Constant.Scalar.( + )\n (G.Constant.Scalar.project (Field.Constant.unpack s))\n in\n G.Constant.scale g x )\n (G.Constant.random (), s) )\n\nlet%test_unit \"scale fast 2 small\" =\n let open Impl in\n let module T = Internal_Basic in\n let module G = Inner_curve in\n let n = 8 in\n let module F = struct\n type t = Field.t\n\n let typ = Field.typ\n\n module Constant = struct\n include Field.Constant\n\n let to_bigint = Impl.Bigint.of_field\n end\n end in\n Quickcheck.test ~trials:5 Field.Constant.gen ~f:(fun s ->\n let s =\n Field.Constant.unpack s |> Fn.flip List.take n |> Field.Constant.project\n in\n T.Test.test_equal ~equal:G.Constant.equal ~sexp_of_t:G.Constant.sexp_of_t\n (Typ.tuple2 G.typ Field.typ)\n G.typ\n (fun (g, s) ->\n make_checked (fun () -> Ops.scale_fast2' ~num_bits:n (module F) g s)\n )\n (fun (g, _) ->\n let x =\n let chunks_needed = Ops.chunks_needed ~num_bits:(n - 1) in\n let actual_bits_used = chunks_needed * Ops.bits_per_chunk in\n Pickles_types.Pcs_batch.pow ~one:G.Constant.Scalar.one\n ~mul:G.Constant.Scalar.( * )\n G.Constant.Scalar.(of_int 2)\n actual_bits_used\n |> G.Constant.Scalar.( + )\n (G.Constant.Scalar.project (Field.Constant.unpack s))\n in\n G.Constant.scale g x )\n (G.Constant.random (), s) )\n\nmodule Generators = struct\n let h =\n lazy\n ( Kimchi_bindings.Protocol.SRS.Fq.urs_h (Backend.Tock.Keypair.load_urs ())\n |> Common.finite_exn )\nend\n","(** A verification key for a pickles proof, whose contents are not fixed within\n the verifier circuit.\n This is used to verify a proof where the verification key is determined by\n some other constraint, for example to use a verification key provided as\n input to the circuit, or loaded from an account that was chosen based upon\n the circuit inputs.\n\n Here and elsewhere, we use the terms\n * **width**:\n - the number of proofs that a proof has verified itself;\n - (equivalently) the maximum number of proofs that a proof depends upon\n directly.\n - NB: This does not include recursively-verified proofs, this only refers\n to proofs that were provided directly to pickles when the proof was\n being generated.\n * **branch**:\n - a single 'rule' or 'circuit' for which a proof can be generated, where\n a verification key verifies a proof for any of these branches.\n - It is common to have a 'base' branch and a 'recursion' branch. For\n example, the transaction snark has a 'transaction' proof that evaluates\n a single transaction and a 'merge' proof that combines two transaction\n snark proofs that prove sequential updates, each of which may be either\n a 'transaction' or a 'merge'.\n*)\n\nopen Core_kernel\nopen Pickles_types\nopen Import\nmodule V = Pickles_base.Side_loaded_verification_key\n\ninclude (\n V :\n module type of V\n with module Width := V.Width\n and module Domains := V.Domains )\n\nlet bits = V.bits\n\nlet input_size ~of_int ~add ~mul w =\n (* This should be an affine function in [a]. *)\n let size a =\n let (T (Typ typ, _conv, _conv_inv)) =\n Impls.Step.input ~proofs_verified:a ~wrap_rounds:Backend.Tock.Rounds.n\n ~feature_flags:Plonk_types.Features.none\n in\n typ.size_in_field_elements\n in\n let f0 = size Nat.N0.n in\n let slope = size Nat.N1.n - f0 in\n add (of_int f0) (mul (of_int slope) w)\n\nmodule Width : sig\n [%%versioned:\n module Stable : sig\n module V1 : sig\n type t = V.Width.Stable.V1.t\n [@@deriving sexp, equal, compare, hash, yojson]\n end\n end]\n\n open Impls.Step\n\n module Checked : sig\n type t\n\n val to_field : t -> Field.t\n\n val to_bits : t -> Boolean.var list\n end\n\n val typ : (Checked.t, t) Typ.t\n\n module Max = Nat.N2\n\n module Max_vector : Vector.With_version(Max).S\n\n module Max_at_most : sig\n [%%versioned:\n module Stable : sig\n module V1 : sig\n type 'a t = ('a, Max.n) At_most.t\n [@@deriving compare, sexp, yojson, hash, equal]\n end\n end]\n end\n\n module Length : Nat.Add.Intf_transparent\nend = struct\n include V.Width\n open Impls.Step\n\n module Checked = struct\n (* A \"width\" is represented by a 4 bit integer. *)\n type t = (Boolean.var, Length.n) Vector.t\n\n let to_field : t -> Field.t = Fn.compose Field.project Vector.to_list\n\n let to_bits = Vector.to_list\n end\n\n let typ : (Checked.t, t) Typ.t =\n Typ.transport\n (Vector.typ Boolean.typ Length.n)\n ~there:(fun x ->\n let x = to_int x in\n Vector.init Length.n ~f:(fun i -> (x lsr i) land 1 = 1) )\n ~back:(fun v ->\n Vector.foldi v ~init:0 ~f:(fun i acc b ->\n if b then acc lor (1 lsl i) else acc )\n |> of_int_exn )\nend\n\nmodule Domain = struct\n type 'a t = Pow_2_roots_of_unity of 'a [@@deriving sexp]\n\n let log2_size (Pow_2_roots_of_unity x) = x\nend\n[@@warning \"-4\"]\n\nmodule Domains = struct\n include V.Domains\n\n let _typ =\n let open Impls.Step in\n let dom =\n Typ.transport Typ.field\n ~there:(fun (Plonk_checks.Domain.Pow_2_roots_of_unity n) ->\n Field.Constant.of_int n )\n ~back:(fun _ -> assert false)\n |> Typ.transport_var\n ~there:(fun (Domain.Pow_2_roots_of_unity n) -> n)\n ~back:(fun n -> Domain.Pow_2_roots_of_unity n)\n in\n Typ.of_hlistable [ dom ] ~var_to_hlist:to_hlist ~value_to_hlist:to_hlist\n ~var_of_hlist:of_hlist ~value_of_hlist:of_hlist\nend\n\nlet max_domains =\n { Domains.h = Domain.Pow_2_roots_of_unity (Nat.to_int Backend.Tick.Rounds.n) }\n\nmodule Vk = struct\n type t = (Impls.Wrap.Verification_key.t[@sexp.opaque]) [@@deriving sexp]\n\n let hash_fold_t s _ = Unit.hash_fold_t s ()\nend\n\nmodule R = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t = Backend.Tock.Curve.Affine.Stable.V1.t Repr.Stable.V2.t\n [@@deriving sexp, equal, compare, yojson]\n\n let to_latest = Fn.id\n end\n end]\nend\n\n[%%versioned_binable\nmodule Stable = struct\n module V2 = struct\n module T = struct\n type t =\n ( Backend.Tock.Curve.Affine.t\n , Pickles_base.Proofs_verified.Stable.V1.t\n , Vk.t )\n Poly.Stable.V2.t\n [@@deriving hash]\n\n let to_latest = Fn.id\n\n let description = \"Verification key\"\n\n let version_byte = Base58_check.Version_bytes.verification_key\n\n let to_repr\n { Poly.max_proofs_verified\n ; actual_wrap_domain_size\n ; wrap_index\n ; wrap_vk = _\n } =\n { Repr.Stable.V2.max_proofs_verified\n ; actual_wrap_domain_size\n ; wrap_index\n }\n\n let of_repr\n ({ Repr.Stable.V2.max_proofs_verified\n ; actual_wrap_domain_size\n ; wrap_index = c\n } :\n R.Stable.V2.t ) : t =\n let d =\n (Common.wrap_domains\n ~proofs_verified:\n (Pickles_base.Proofs_verified.to_int actual_wrap_domain_size) )\n .h\n in\n let log2_size = Import.Domain.log2_size d in\n let public =\n let (T (input, _conv, _conv_inv)) = Impls.Wrap.input () in\n let (Typ typ) = input in\n typ.size_in_field_elements\n in\n (* we only compute the wrap_vk if the srs can be loaded *)\n let srs =\n try Some (Backend.Tock.Keypair.load_urs ()) with _ -> None\n in\n let wrap_vk =\n Option.map srs ~f:(fun srs : Impls.Wrap.Verification_key.t ->\n { domain =\n { log_size_of_group = log2_size\n ; group_gen = Backend.Tock.Field.domain_generator ~log2_size\n }\n ; max_poly_size = 1 lsl Nat.to_int Backend.Tock.Rounds.n\n ; public\n ; prev_challenges = 2 (* Due to Wrap_hack *)\n ; srs\n ; evals =\n (let g (x, y) =\n { Kimchi_types.unshifted = [| Kimchi_types.Finite (x, y) |]\n ; shifted = None\n }\n in\n { sigma_comm = Array.map ~f:g (Vector.to_array c.sigma_comm)\n ; coefficients_comm =\n Array.map ~f:g (Vector.to_array c.coefficients_comm)\n ; generic_comm = g c.generic_comm\n ; mul_comm = g c.mul_comm\n ; psm_comm = g c.psm_comm\n ; emul_comm = g c.emul_comm\n ; complete_add_comm = g c.complete_add_comm\n ; endomul_scalar_comm = g c.endomul_scalar_comm\n } )\n ; shifts = Common.tock_shifts ~log2_size\n ; lookup_index = None\n } )\n in\n { Poly.max_proofs_verified\n ; actual_wrap_domain_size\n ; wrap_index = c\n ; wrap_vk\n }\n\n (* Proxy derivers to [R.t]'s, ignoring [wrap_vk] *)\n\n let sexp_of_t t = R.sexp_of_t (to_repr t)\n\n let t_of_sexp sexp = of_repr (R.t_of_sexp sexp)\n\n let _to_yojson t = R.to_yojson (to_repr t)\n\n let _of_yojson json = Result.map ~f:of_repr (R.of_yojson json)\n\n let equal x y = R.equal (to_repr x) (to_repr y)\n\n let compare x y = R.compare (to_repr x) (to_repr y)\n\n include\n Binable.Of_binable\n (R.Stable.V2)\n (struct\n type nonrec t = t\n\n let to_binable r = to_repr r\n\n let of_binable r = of_repr r\n end)\n end\n\n include T\n include Codable.Make_base58_check (T)\n include Codable.Make_base64 (T)\n end\nend]\n\n[%%define_locally\nStable.Latest.\n ( to_base58_check\n , of_base58_check\n , of_base58_check_exn\n , to_base64\n , of_base64\n , sexp_of_t\n , t_of_sexp\n , to_yojson\n , of_yojson\n , equal\n , compare )]\n\nlet dummy : t =\n { max_proofs_verified = N2\n ; actual_wrap_domain_size = N2\n ; wrap_index =\n (let g = Backend.Tock.Curve.(to_affine_exn one) in\n { sigma_comm = Vector.init Plonk_types.Permuts.n ~f:(fun _ -> g)\n ; coefficients_comm = Vector.init Plonk_types.Columns.n ~f:(fun _ -> g)\n ; generic_comm = g\n ; psm_comm = g\n ; complete_add_comm = g\n ; mul_comm = g\n ; emul_comm = g\n ; endomul_scalar_comm = g\n } )\n ; wrap_vk = None\n }\n\nmodule Checked = struct\n open Step_main_inputs\n open Impl\n\n type t =\n { max_proofs_verified :\n Impl.field Pickles_base.Proofs_verified.One_hot.Checked.t\n (** The maximum of all of the [step_widths]. *)\n ; actual_wrap_domain_size :\n Impl.field Pickles_base.Proofs_verified.One_hot.Checked.t\n (** The actual domain size used by the wrap circuit. *)\n ; wrap_index : Inner_curve.t Plonk_verification_key_evals.t\n (** The plonk verification key for the 'wrapping' proof that this key\n is used to verify.\n *)\n }\n [@@deriving hlist, fields]\n\n (** [log_2] of the width. *)\n let _width_size = Nat.to_int Width.Length.n\n\n let to_input =\n let open Random_oracle_input.Chunked in\n fun { max_proofs_verified; actual_wrap_domain_size; wrap_index } :\n _ Random_oracle_input.Chunked.t ->\n let max_proofs_verified =\n Pickles_base.Proofs_verified.One_hot.Checked.to_input\n max_proofs_verified\n in\n let actual_wrap_domain_size =\n Pickles_base.Proofs_verified.One_hot.Checked.to_input\n actual_wrap_domain_size\n in\n List.reduce_exn ~f:append\n [ max_proofs_verified\n ; actual_wrap_domain_size\n ; wrap_index_to_input\n (Fn.compose Array.of_list Inner_curve.to_field_elements)\n wrap_index\n ]\nend\n\nlet%test_unit \"input_size\" =\n List.iter\n (List.range 0 (Nat.to_int Width.Max.n) ~stop:`inclusive ~start:`inclusive)\n ~f:(fun n ->\n [%test_eq: int]\n (input_size ~of_int:Fn.id ~add:( + ) ~mul:( * ) n)\n (let (T a) = Nat.of_int n in\n let (T (Typ typ, _conv, _conv_inv)) =\n Impls.Step.input ~proofs_verified:a\n ~wrap_rounds:Backend.Tock.Rounds.n\n ~feature_flags:Plonk_types.Features.none\n in\n typ.size_in_field_elements ) )\n\nlet typ : (Checked.t, t) Impls.Step.Typ.t =\n let open Step_main_inputs in\n let open Impl in\n Typ.of_hlistable\n [ Pickles_base.Proofs_verified.One_hot.typ (module Impls.Step)\n ; Pickles_base.Proofs_verified.One_hot.typ (module Impls.Step)\n ; Plonk_verification_key_evals.typ Inner_curve.typ\n ]\n ~var_to_hlist:Checked.to_hlist ~var_of_hlist:Checked.of_hlist\n ~value_of_hlist:(fun _ ->\n failwith \"Side_loaded_verification_key: value_of_hlist\" )\n ~value_to_hlist:(fun { Poly.wrap_index\n ; actual_wrap_domain_size\n ; max_proofs_verified\n ; _\n } ->\n [ max_proofs_verified; actual_wrap_domain_size; wrap_index ] )\n","open Core_kernel\nopen Pickles_types\nopen Import\nopen Backend\n\nlet hash_fold_array = Pickles_types.Plonk_types.hash_fold_array\n\nmodule Base = struct\n module Messages_for_next_proof_over_same_field =\n Reduced_messages_for_next_proof_over_same_field\n\n module Step = struct\n type ( 's\n , 'unfinalized_proofs\n , 'sgs\n , 'bp_chals\n , 'messages_for_next_wrap_proof\n , 'prev_evals )\n t =\n { statement :\n ( 'unfinalized_proofs\n , ('s, 'sgs, 'bp_chals) Messages_for_next_proof_over_same_field.Step.t\n , 'messages_for_next_wrap_proof )\n Types.Step.Statement.t\n ; index : int\n ; prev_evals : 'prev_evals\n ; proof : Tick.Proof.t\n }\n end\n\n module Wrap = struct\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V2 = struct\n type ('messages_for_next_wrap_proof, 'messages_for_next_step_proof) t =\n ( 'messages_for_next_wrap_proof\n , 'messages_for_next_step_proof )\n Mina_wire_types.Pickles.Concrete_.Proof.Base.Wrap.V2.t =\n { statement :\n ( Limb_vector.Constant.Hex64.Stable.V1.t\n Vector.Vector_2.Stable.V1.t\n , Limb_vector.Constant.Hex64.Stable.V1.t\n Vector.Vector_2.Stable.V1.t\n Scalar_challenge.Stable.V2.t\n , Tick.Field.Stable.V1.t Shifted_value.Type1.Stable.V1.t\n , bool\n , 'messages_for_next_wrap_proof\n , Digest.Constant.Stable.V1.t\n , 'messages_for_next_step_proof\n , Limb_vector.Constant.Hex64.Stable.V1.t\n Vector.Vector_2.Stable.V1.t\n Scalar_challenge.Stable.V2.t\n Bulletproof_challenge.Stable.V1.t\n Step_bp_vec.Stable.V1.t\n , Branch_data.Stable.V1.t )\n Types.Wrap.Statement.Minimal.Stable.V1.t\n ; prev_evals :\n ( Tick.Field.Stable.V1.t\n , Tick.Field.Stable.V1.t array )\n Plonk_types.All_evals.Stable.V1.t\n ; proof : Wrap_wire_proof.Stable.V1.t\n }\n [@@deriving compare, sexp, yojson, hash, equal]\n end\n end]\n\n type ('messages_for_next_wrap_proof, 'messages_for_next_step_proof) t =\n ( 'messages_for_next_wrap_proof\n , 'messages_for_next_step_proof )\n Stable.Latest.t =\n { statement :\n ( Challenge.Constant.t\n , Challenge.Constant.t Scalar_challenge.t\n , Tick.Field.t Shifted_value.Type1.t\n , bool\n , 'messages_for_next_wrap_proof\n , Digest.Constant.t\n , 'messages_for_next_step_proof\n , Challenge.Constant.t Scalar_challenge.t Bulletproof_challenge.t\n Step_bp_vec.t\n , Branch_data.t )\n Types.Wrap.Statement.Minimal.t\n ; prev_evals : (Tick.Field.t, Tick.Field.t array) Plonk_types.All_evals.t\n ; proof : Wrap_wire_proof.t\n }\n [@@deriving compare, sexp, yojson, hash, equal]\n end\nend\n\ntype ('s, 'mlmb, 'c) with_data =\n ('s, 'mlmb, 'c) Mina_wire_types.Pickles.Concrete_.Proof.with_data =\n | T :\n ( 'mlmb Base.Messages_for_next_proof_over_same_field.Wrap.t\n , ( 's\n , (Tock.Curve.Affine.t, 'most_recent_width) Vector.t\n , ( Challenge.Constant.t Scalar_challenge.Stable.Latest.t\n Bulletproof_challenge.t\n Step_bp_vec.t\n , 'most_recent_width )\n Vector.t )\n Base.Messages_for_next_proof_over_same_field.Step.t )\n Base.Wrap.t\n -> ('s, 'mlmb, _) with_data\n\nmodule With_data = struct\n type ('s, 'mlmb, 'w) t = ('s, 'mlmb, 'w) with_data\nend\n\ntype ('max_width, 'mlmb) t = (unit, 'mlmb, 'max_width) With_data.t\n\nlet dummy (type w h r) (_w : w Nat.t) (h : h Nat.t)\n (most_recent_width : r Nat.t) ~domain_log2 : (w, h) t =\n let open Ro in\n let g0 = Tock.Curve.(to_affine_exn one) in\n let g len = Array.create ~len g0 in\n let tick_arr len = Array.init len ~f:(fun _ -> tick ()) in\n let lengths = Commitment_lengths.create ~of_int:Fn.id in\n T\n { statement =\n { proof_state =\n { deferred_values =\n { branch_data =\n { proofs_verified =\n ( match most_recent_width with\n | Z ->\n N0\n | S Z ->\n N1\n | S (S Z) ->\n N2\n | S _ ->\n assert false )\n ; domain_log2 =\n Branch_data.Domain_log2.of_int_exn domain_log2\n }\n ; bulletproof_challenges = Dummy.Ipa.Step.challenges\n ; plonk =\n { alpha = scalar_chal ()\n ; beta = chal ()\n ; gamma = chal ()\n ; zeta = scalar_chal ()\n ; joint_combiner = None\n ; feature_flags = Plonk_types.Features.none_bool\n }\n }\n ; sponge_digest_before_evaluations =\n Digest.Constant.of_tock_field Tock.Field.zero\n ; messages_for_next_wrap_proof =\n { challenge_polynomial_commitment = Lazy.force Dummy.Ipa.Step.sg\n ; old_bulletproof_challenges =\n Vector.init h ~f:(fun _ -> Dummy.Ipa.Wrap.challenges)\n }\n }\n ; messages_for_next_step_proof =\n { app_state = ()\n ; old_bulletproof_challenges =\n (* Not sure if this should be w or h honestly ...*)\n Vector.init most_recent_width ~f:(fun _ ->\n Dummy.Ipa.Step.challenges )\n (* TODO: Should this be wrap? *)\n ; challenge_polynomial_commitments =\n Vector.init most_recent_width ~f:(fun _ ->\n Lazy.force Dummy.Ipa.Wrap.sg )\n }\n }\n ; proof =\n Wrap_wire_proof.of_kimchi_proof\n { messages =\n { w_comm = Vector.map lengths.w ~f:g\n ; z_comm = g lengths.z\n ; t_comm = g lengths.t\n ; lookup = None\n }\n ; openings =\n { proof =\n { lr =\n Array.init (Nat.to_int Tock.Rounds.n) ~f:(fun _ ->\n (g0, g0) )\n ; z_1 = Ro.tock ()\n ; z_2 = Ro.tock ()\n ; delta = g0\n ; challenge_polynomial_commitment = g0\n }\n ; evals = Dummy.evals.evals.evals\n ; ft_eval1 = Dummy.evals.ft_eval1\n }\n }\n ; prev_evals =\n (let e =\n Plonk_types.Evals.map (Evaluation_lengths.create ~of_int:Fn.id)\n ~f:(fun n -> (tick_arr n, tick_arr n))\n in\n let ex =\n { Plonk_types.All_evals.With_public_input.public_input =\n (tick (), tick ())\n ; evals = e\n }\n in\n { ft_eval1 = tick (); evals = ex } )\n }\n\nmodule Make (W : Nat.Intf) (MLMB : Nat.Intf) = struct\n module Max_proofs_verified_at_most = At_most.With_length (W)\n module MLMB_vec = Nvector (MLMB)\n\n module Repr = struct\n type t =\n ( ( Tock.Inner_curve.Affine.t\n , Reduced_messages_for_next_proof_over_same_field.Wrap.Challenges_vector\n .t\n MLMB_vec.t )\n Types.Wrap.Proof_state.Messages_for_next_wrap_proof.t\n , ( unit\n , Tock.Curve.Affine.t Max_proofs_verified_at_most.t\n , Challenge.Constant.t Scalar_challenge.t Bulletproof_challenge.t\n Step_bp_vec.t\n Max_proofs_verified_at_most.t )\n Base.Messages_for_next_proof_over_same_field.Step.t )\n Base.Wrap.t\n [@@deriving compare, sexp, yojson, hash, equal]\n end\n\n type nonrec t = (W.n, MLMB.n) t\n\n let to_repr (T t) : Repr.t =\n let lte =\n Nat.lte_exn\n (Vector.length\n t.statement.messages_for_next_step_proof\n .challenge_polynomial_commitments )\n W.n\n in\n { t with\n statement =\n { t.statement with\n messages_for_next_step_proof =\n { t.statement.messages_for_next_step_proof with\n challenge_polynomial_commitments =\n At_most.of_vector\n t.statement.messages_for_next_step_proof\n .challenge_polynomial_commitments lte\n ; old_bulletproof_challenges =\n At_most.of_vector\n t.statement.messages_for_next_step_proof\n .old_bulletproof_challenges lte\n }\n }\n }\n\n let of_repr (r : Repr.t) : t =\n let (Vector.T challenge_polynomial_commitments) =\n At_most.to_vector\n r.statement.messages_for_next_step_proof\n .challenge_polynomial_commitments\n in\n let (Vector.T old_bulletproof_challenges) =\n At_most.to_vector\n r.statement.messages_for_next_step_proof.old_bulletproof_challenges\n in\n let T =\n Nat.eq_exn\n (Vector.length challenge_polynomial_commitments)\n (Vector.length old_bulletproof_challenges)\n in\n T\n { r with\n statement =\n { r.statement with\n messages_for_next_step_proof =\n { r.statement.messages_for_next_step_proof with\n challenge_polynomial_commitments\n ; old_bulletproof_challenges\n }\n }\n }\n\n let compare t1 t2 = Repr.compare (to_repr t1) (to_repr t2)\n\n let equal t1 t2 = Repr.equal (to_repr t1) (to_repr t2)\n\n let hash_fold_t s t = Repr.hash_fold_t s (to_repr t)\n\n let hash t = Repr.hash (to_repr t)\n\n include\n Sexpable.Of_sexpable\n (Repr)\n (struct\n type nonrec t = t\n\n let to_sexpable = to_repr\n\n let of_sexpable = of_repr\n end)\n\n let to_base64 t =\n (* assume call to Nat.lte_exn does not raise with a valid instance of t *)\n let sexp = sexp_of_t t in\n (* raises only on invalid optional arguments *)\n Base64.encode_exn (Sexp.to_string sexp)\n\n let of_base64 b64 =\n match Base64.decode b64 with\n | Ok t -> (\n try Ok (t_of_sexp (Sexp.of_string t))\n with exn -> Error (Exn.to_string exn) )\n | Error (`Msg s) ->\n Error s\n\n let to_yojson_full x = Repr.to_yojson (to_repr x)\n\n let to_yojson x = `String (to_base64 x)\n\n let of_yojson = function\n | `String x ->\n of_base64 x\n | _ ->\n Error \"Invalid json for proof. Expecting base64 encoded string\"\nend\n\nmodule Proofs_verified_2 = struct\n module T = Make (Nat.N2) (Nat.N2)\n\n module Repr = struct\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V2 = struct\n type t =\n ( ( Tock.Inner_curve.Affine.Stable.V1.t\n , Reduced_messages_for_next_proof_over_same_field.Wrap\n .Challenges_vector\n .Stable\n .V2\n .t\n Vector.Vector_2.Stable.V1.t )\n Types.Wrap.Proof_state.Messages_for_next_wrap_proof.Stable.V1.t\n , ( unit\n , Tock.Curve.Affine.t At_most.At_most_2.Stable.V1.t\n , Limb_vector.Constant.Hex64.Stable.V1.t Vector.Vector_2.Stable.V1.t\n Scalar_challenge.Stable.V2.t\n Bulletproof_challenge.Stable.V1.t\n Step_bp_vec.Stable.V1.t\n At_most.At_most_2.Stable.V1.t )\n Base.Messages_for_next_proof_over_same_field.Step.Stable.V1.t )\n Base.Wrap.Stable.V2.t\n [@@deriving compare, sexp, yojson, hash, equal]\n\n let to_latest = Fn.id\n end\n end]\n\n include T.Repr\n\n (* Force the typechecker to verify that these types are equal. *)\n let (_ : (t, Stable.Latest.t) Type_equal.t) = Type_equal.T\n end\n\n [%%versioned_binable\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V2 = struct\n type t = T.t\n\n let to_latest = Fn.id\n\n include (T : module type of T with type t := t with module Repr := T.Repr)\n\n include\n Binable.Of_binable\n (Repr.Stable.V2)\n (struct\n type nonrec t = t\n\n let to_binable = to_repr\n\n let of_binable = of_repr\n end)\n end\n end]\n\n include (T : module type of T with module Repr := T.Repr)\nend\n\nmodule Proofs_verified_max = struct\n module T =\n Make\n (Side_loaded_verification_key.Width.Max)\n (Side_loaded_verification_key.Width.Max)\n\n module Repr = struct\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V2 = struct\n type t =\n ( ( Tock.Inner_curve.Affine.Stable.V1.t\n , Reduced_messages_for_next_proof_over_same_field.Wrap\n .Challenges_vector\n .Stable\n .V2\n .t\n Side_loaded_verification_key.Width.Max_vector.Stable.V1.t )\n Types.Wrap.Proof_state.Messages_for_next_wrap_proof.Stable.V1.t\n , ( unit\n , Tock.Curve.Affine.t\n Side_loaded_verification_key.Width.Max_at_most.Stable.V1.t\n , Limb_vector.Constant.Hex64.Stable.V1.t Vector.Vector_2.Stable.V1.t\n Scalar_challenge.Stable.V2.t\n Bulletproof_challenge.Stable.V1.t\n Step_bp_vec.Stable.V1.t\n Side_loaded_verification_key.Width.Max_at_most.Stable.V1.t )\n Base.Messages_for_next_proof_over_same_field.Step.Stable.V1.t )\n Base.Wrap.Stable.V2.t\n [@@deriving compare, sexp, yojson, hash, equal]\n\n let to_latest = Fn.id\n end\n end]\n\n include T.Repr\n\n (* Force the typechecker to verify that these types are equal. *)\n let (_ : (t, Stable.Latest.t) Type_equal.t) = Type_equal.T\n end\n\n [%%versioned_binable\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V2 = struct\n type t = T.t\n\n let to_latest = Fn.id\n\n include (T : module type of T with type t := t with module Repr := T.Repr)\n\n include\n Binable.Of_binable\n (Repr.Stable.V2)\n (struct\n type nonrec t = t\n\n let to_binable = to_repr\n\n let of_binable = of_repr\n end)\n end\n end]\n\n include (T : module type of T with module Repr := T.Repr)\nend\n","open Core_kernel\nopen Backend\nmodule Me = Tock\nmodule Other = Tick\nmodule Impl = Impls.Wrap\n\nlet _high_entropy_bits = 128\n\nlet sponge_params_constant =\n Sponge.Params.(map pasta_q_kimchi ~f:Impl.Field.Constant.of_string)\n\nlet field_random_oracle ?(length = Me.Field.size_in_bits - 1) s =\n Me.Field.of_bits (Ro.bits_random_oracle ~length s)\n\nlet _unrelated_g =\n let open Common in\n let group_map =\n unstage\n (group_map\n (module Me.Field)\n ~a:Me.Inner_curve.Params.a ~b:Me.Inner_curve.Params.b )\n and str = Fn.compose bits_to_bytes Me.Field.to_bits in\n fun (x, y) -> group_map (field_random_oracle (str x ^ str y))\n\nopen Impl\n\n(* Debug helper to convert wrap circuit field element to a hex string *)\nlet read_wrap_circuit_field_element_as_hex fe =\n let prover_fe = As_prover.read Field.typ fe in\n Kimchi_backend.Pasta.Pallas_based_plonk.(\n Bigint.to_hex (Field.to_bigint prover_fe))\n\nmodule Other_field = struct\n type t = Impls.Step.Field.Constant.t [@@deriving sexp]\n\n include (Tick.Field : module type of Tick.Field with type t := t)\n\n let size = Impls.Step.Bigint.to_bignum_bigint size\nend\n\nlet sponge_params =\n Sponge.Params.(map sponge_params_constant ~f:Impl.Field.constant)\n\nmodule Unsafe = struct\n let unpack_unboolean ?(length = Field.size_in_bits) x =\n let res =\n exists\n (Typ.list Boolean.typ_unchecked ~length)\n ~compute:\n As_prover.(\n fun () -> List.take (Field.Constant.unpack (read_var x)) length)\n in\n Field.Assert.equal x (Field.project res) ;\n res\nend\n\nmodule Sponge = struct\n module Permutation =\n Sponge_inputs.Make\n (Impl)\n (struct\n include Tock_field_sponge.Inputs\n\n let params = Tock_field_sponge.params\n end)\n\n module S = Sponge.Make_debug_sponge (struct\n include Permutation\n module Circuit = Impls.Wrap\n\n (* Optional sponge name used in debug mode *)\n let sponge_name = \"wrap\"\n\n (* To enable debug mode, set environment variable [sponge_name] to \"t\", \"1\" or \"true\". *)\n let debug_helper_fn = read_wrap_circuit_field_element_as_hex\n end)\n\n include S\n\n let squeeze_field = squeeze\n\n let squeeze = squeeze\nend\n\nlet%test_unit \"sponge\" =\n let module T = Make_sponge.Test (Impl) (Tock_field_sponge.Field) (Sponge.S) in\n T.test Tock_field_sponge.params\n\n(* module Input_domain = struct\n let _lagrange_commitments domain : Backend.Tock.Inner_curve.Affine.t array =\n let domain_size = Import.Domain.size domain in\n Common.time \"lagrange\" (fun () ->\n Array.init domain_size ~f:(fun i ->\n (Kimchi_bindings.Protocol.SRS.Fp.lagrange_commitment\n (Backend.Tick.Keypair.load_urs ())\n domain_size i )\n .unshifted.(0)\n |> Common.finite_exn ) )\n\n let _domain = Import.Domain.Pow_2_roots_of_unity 7\n end *)\n\nmodule Inner_curve = struct\n module C = Kimchi_pasta.Pasta.Vesta\n\n module Inputs = struct\n module Impl = Impl\n\n module Params = struct\n include C.Params\n\n let one = C.to_affine_exn C.one\n\n let group_size_in_bits = Field.size_in_bits\n end\n\n module F = struct\n include struct\n open Impl.Field\n\n type nonrec t = t\n\n let ( * ), ( + ), ( - ), inv_exn, square, scale, if_, typ, constant =\n (( * ), ( + ), ( - ), inv, square, scale, if_, typ, constant)\n\n let negate x = scale x Constant.(negate one)\n end\n\n module Constant = struct\n open Impl.Field.Constant\n\n type nonrec t = t\n\n let ( * ), ( + ), ( - ), inv_exn, square, negate =\n (( * ), ( + ), ( - ), inv, square, negate)\n end\n\n let assert_square x y = Impl.assert_square x y\n\n let assert_r1cs x y z = Impl.assert_r1cs x y z\n end\n\n module Constant = struct\n include C.Affine\n module Scalar = Impls.Step.Field.Constant\n\n let scale (t : t) (x : Scalar.t) : t =\n C.(to_affine_exn (scale (of_affine t) x))\n\n let random () : t = C.(to_affine_exn (random ()))\n\n let zero = Impl.Field.Constant.(zero, zero)\n\n let ( + ) t1 t2 : t =\n let is_zero (x, _) = Impl.Field.Constant.(equal zero x) in\n if is_zero t1 then t2\n else if is_zero t2 then t1\n else\n let r = C.(of_affine t1 + of_affine t2) in\n try C.to_affine_exn r with _ -> zero\n\n let negate x : t = C.(to_affine_exn (negate (of_affine x)))\n\n let to_affine_exn = Fn.id\n\n let of_affine = Fn.id\n end\n end\n\n module Params = Inputs.Params\n module Constant = Inputs.Constant\n module T = Snarky_curve.For_native_base_field (Inputs)\n\n include (\n T :\n module type of T\n with module Scaling_precomputation := T.Scaling_precomputation )\n\n module Scaling_precomputation = T.Scaling_precomputation\n\n let ( + ) t1 t2 = Plonk_curve_ops.add_fast (module Impl) t1 t2\n\n let double t = t + t\n\n let scale t bs =\n with_label __LOC__ (fun () ->\n T.scale t (Bitstring_lib.Bitstring.Lsb_first.of_list bs) )\n\n let to_field_elements (x, y) = [ x; y ]\n\n let assert_equal (x1, y1) (x2, y2) =\n Field.Assert.equal x1 x2 ; Field.Assert.equal y1 y2\n\n let scale_inv t bs =\n let res =\n exists typ\n ~compute:\n As_prover.(\n fun () ->\n C.scale\n (C.of_affine (read typ t))\n (Other.Field.inv\n (Other.Field.of_bits (List.map ~f:(read Boolean.typ) bs)) )\n |> C.to_affine_exn)\n in\n assert_equal t (scale res bs) ;\n res\n\n let negate = T.negate\n\n let one = T.one\n\n let if_ = T.if_\nend\n\nmodule Ops = Plonk_curve_ops.Make (Impl) (Inner_curve)\n\nmodule Generators = struct\n let h =\n lazy\n ( Kimchi_bindings.Protocol.SRS.Fp.urs_h (Backend.Tick.Keypair.load_urs ())\n |> Common.finite_exn )\nend\n","module S = Sponge\nopen Core_kernel\nopen Util\nmodule SC = Scalar_challenge\nopen Pickles_types\nopen Plonk_types\nopen Tuple_lib\nopen Import\n\n(* G is for Generic. This module is just to protect {!val:challenge_polynomial}\n below from being hidden by the included functor application at the end of\n the module, so that we can re-export it in the end. *)\nmodule G = struct\n let lookup_verification_enabled = false\n\n (* given [chals], compute\n \\prod_i (1 + chals.(i) * x^{2^{k - 1 - i}}) *)\n let challenge_polynomial (type a)\n (module M : Pickles_types.Shifted_value.Field_intf with type t = a) chals\n : (a -> a) Staged.t =\n stage (fun pt ->\n let k = Array.length chals in\n let pow_two_pows =\n let res = Array.init k ~f:(fun _ -> pt) in\n for i = 1 to k - 1 do\n let y = res.(i - 1) in\n res.(i) <- M.(y * y)\n done ;\n res\n in\n let prod f =\n let r = ref (f 0) in\n for i = 1 to k - 1 do\n r := M.(f i * !r)\n done ;\n !r\n in\n prod (fun i ->\n let idx = k - 1 - i in\n M.(one + (chals.(i) * pow_two_pows.(idx))) ) )\n\n let num_possible_domains = Nat.S Wrap_hack.Padded_length.n\n\n let all_possible_domains =\n Memo.unit (fun () ->\n Vector.init num_possible_domains ~f:(fun proofs_verified ->\n (Common.wrap_domains ~proofs_verified).h ) )\nend\n\nmodule Make\n (Inputs : Intf.Wrap_main_inputs.S\n with type Impl.field = Backend.Tock.Field.t\n and type Impl.Bigint.t = Backend.Tock.Bigint.t\n and type Inner_curve.Constant.Scalar.t = Backend.Tick.Field.t) =\nstruct\n open Inputs\n open Impl\n\n module Other_field = struct\n module Packed = struct\n module Constant = Other_field\n\n type t = Impls.Wrap.Other_field.t\n\n let typ = Impls.Wrap.Other_field.typ\n\n let _to_bits_unsafe (x : t) = Wrap_main_inputs.Unsafe.unpack_unboolean x\n\n let absorb_shifted sponge (x : t Shifted_value.Type1.t) =\n match x with Shifted_value x -> Sponge.absorb sponge x\n end\n\n module With_top_bit0 = struct\n (* When the top bit is 0, there is no need to check that this is not\n equal to one of the forbidden values. The scaling is safe. *)\n module Constant = Other_field\n\n type t = Impls.Wrap.Other_field.t\n\n let typ = Impls.Wrap.Other_field.typ_unchecked\n\n let _absorb_shifted sponge (x : t Pickles_types.Shifted_value.Type1.t) =\n match x with Shifted_value x -> Sponge.absorb sponge x\n end\n end\n\n let num_possible_domains = G.num_possible_domains\n\n let all_possible_domains = G.all_possible_domains\n\n let print_g lab (x, y) =\n if debug then\n as_prover\n As_prover.(\n fun () ->\n printf\n !\"%s: %{sexp:Backend.Tock.Field.t}, %{sexp:Backend.Tock.Field.t}\\n\\\n %!\"\n lab (read_var x) (read_var y))\n\n let _print_w lab gs =\n if Import.debug then\n Array.iteri gs ~f:(fun i (fin, g) ->\n as_prover\n As_prover.(fun () -> printf \"fin=%b %!\" (read Boolean.typ fin)) ;\n ksprintf print_g \"%s[%d]\" lab i g )\n\n let _print_chal lab x =\n if Import.debug then\n as_prover\n As_prover.(\n fun () ->\n printf \"in-snark %s:%!\" lab ;\n Field.Constant.print\n (Field.Constant.project (List.map ~f:(read Boolean.typ) x)) ;\n printf \"\\n%!\")\n\n let print_bool lab x =\n if debug then\n as_prover (fun () ->\n printf \"%s: %b\\n%!\" lab (As_prover.read Boolean.typ x) )\n\n module Challenge = Challenge.Make (Impl)\n module Digest = Digest.Make (Impl)\n module Scalar_challenge =\n SC.Make (Impl) (Inner_curve) (Challenge) (Endo.Wrap_inner_curve)\n module Ops = Plonk_curve_ops.Make (Impl) (Inner_curve)\n\n let _product m f =\n Core_kernel.List.reduce_exn (Core_kernel.List.init m ~f) ~f:Field.( * )\n\n let absorb sponge ty t =\n absorb\n ~mask_g1_opt:(fun () -> assert false)\n ~absorb_field:(Sponge.absorb sponge)\n ~g1_to_field_elements:Inner_curve.to_field_elements\n ~absorb_scalar:(Sponge.absorb sponge) ty t\n\n let scalar_to_field s =\n SC.to_field_checked (module Impl) s ~endo:Endo.Step_inner_curve.scalar\n\n let assert_n_bits ~n a =\n (* Scalar_challenge.to_field_checked has the side effect of\n checking that the input fits in n bits. *)\n ignore\n ( SC.to_field_checked\n (module Impl)\n (Import.Scalar_challenge.create a)\n ~endo:Endo.Step_inner_curve.scalar ~num_bits:n\n : Field.t )\n\n let lowest_128_bits ~constrain_low_bits x =\n let assert_128_bits = assert_n_bits ~n:128 in\n Util.lowest_128_bits ~constrain_low_bits ~assert_128_bits (module Impl) x\n\n let squeeze_challenge sponge : Field.t =\n lowest_128_bits (* I think you may not have to constrain these actually *)\n ~constrain_low_bits:true (Sponge.squeeze sponge)\n\n let squeeze_scalar sponge : Field.t Import.Scalar_challenge.t =\n (* No need to boolean constrain scalar challenges. *)\n Import.Scalar_challenge.create\n (lowest_128_bits ~constrain_low_bits:false (Sponge.squeeze sponge))\n\n let bullet_reduce sponge gammas =\n let absorb t = absorb sponge t in\n let prechallenges =\n Array.map gammas ~f:(fun gammas_i ->\n absorb (PC :: PC) gammas_i ;\n squeeze_scalar sponge )\n in\n let term_and_challenge (l, r) pre =\n let left_term = Scalar_challenge.endo_inv l pre in\n let right_term = Scalar_challenge.endo r pre in\n (Ops.add_fast left_term right_term, Bulletproof_challenge.unpack pre)\n in\n let terms, challenges =\n Array.map2_exn gammas prechallenges ~f:term_and_challenge |> Array.unzip\n in\n\n (Array.reduce_exn terms ~f:(Ops.add_fast ?check_finite:None), challenges)\n\n let equal_g g1 g2 =\n List.map2_exn ~f:Field.equal\n (Inner_curve.to_field_elements g1)\n (Inner_curve.to_field_elements g2)\n |> Boolean.all\n\n module One_hot_vector = One_hot_vector.Make (Impl)\n\n type 'a index' = 'a Plonk_verification_key_evals.t\n\n (* Mask out the given vector of indices with the given one-hot vector *)\n let choose_key :\n type n.\n n One_hot_vector.t\n -> (Inner_curve.t index', n) Vector.t\n -> Inner_curve.t index' =\n let open Tuple_lib in\n let map = Plonk_verification_key_evals.map in\n let map2 = Plonk_verification_key_evals.map2 in\n fun bs keys ->\n let open Field in\n Vector.map2\n (bs :> (Boolean.var, n) Vector.t)\n keys\n ~f:(fun b key -> map key ~f:(fun g -> Double.map g ~f:(( * ) (b :> t))))\n |> Vector.reduce_exn ~f:(map2 ~f:(Double.map2 ~f:( + )))\n |> map ~f:(fun g -> Double.map ~f:(Util.seal (module Impl)) g)\n\n (* TODO: Unify with the code in step_verifier *)\n let lagrange (type n)\n ~domain:\n ( (which_branch : n One_hot_vector.t)\n , (domains : (Domains.t, n) Vector.t) ) srs i =\n Vector.map domains ~f:(fun d ->\n let d = Int.pow 2 (Domain.log2_size d.h) in\n match[@warning \"-4\"]\n (Kimchi_bindings.Protocol.SRS.Fp.lagrange_commitment srs d i)\n .unshifted\n with\n | [| Finite g |] ->\n let g = Inner_curve.Constant.of_affine g in\n Inner_curve.constant g\n | _ ->\n assert false )\n |> Vector.map2\n (which_branch :> (Boolean.var, n) Vector.t)\n ~f:(fun b (x, y) -> Field.((b :> t) * x, (b :> t) * y))\n |> Vector.reduce_exn ~f:(Double.map2 ~f:Field.( + ))\n\n let scaled_lagrange (type n) c\n ~domain:\n ( (which_branch : n One_hot_vector.t)\n , (domains : (Domains.t, n) Vector.t) ) srs i =\n Vector.map domains ~f:(fun d ->\n let d = Int.pow 2 (Domain.log2_size d.h) in\n match[@warning \"-4\"]\n (Kimchi_bindings.Protocol.SRS.Fp.lagrange_commitment srs d i)\n .unshifted\n with\n | [| Finite g |] ->\n let g = Inner_curve.Constant.of_affine g in\n Inner_curve.Constant.scale g c |> Inner_curve.constant\n | _ ->\n assert false )\n |> Vector.map2\n (which_branch :> (Boolean.var, n) Vector.t)\n ~f:(fun b (x, y) -> Field.((b :> t) * x, (b :> t) * y))\n |> Vector.reduce_exn ~f:(Double.map2 ~f:Field.( + ))\n\n let lagrange_with_correction (type n) ~input_length\n ~domain:\n ( (which_branch : n One_hot_vector.t)\n , (domains : (Domains.t, n) Vector.t) ) srs i : Inner_curve.t Double.t =\n with_label __LOC__ (fun () ->\n let actual_shift =\n (* TODO: num_bits should maybe be input_length - 1. *)\n Ops.bits_per_chunk * Ops.chunks_needed ~num_bits:input_length\n in\n let rec pow2pow x i =\n if i = 0 then x else pow2pow Inner_curve.Constant.(x + x) (i - 1)\n in\n let base_and_correction (h : Domain.t) =\n let d = Int.pow 2 (Domain.log2_size h) in\n match[@warning \"-4\"]\n (Kimchi_bindings.Protocol.SRS.Fp.lagrange_commitment srs d i)\n .unshifted\n with\n | [| Finite g |] ->\n let open Inner_curve.Constant in\n let g = of_affine g in\n ( Inner_curve.constant g\n , Inner_curve.constant (negate (pow2pow g actual_shift)) )\n | xs ->\n failwithf \"expected commitment to have length 1. got %d\"\n (Array.length xs) ()\n in\n match domains with\n | [] ->\n assert false\n | d :: ds ->\n if Vector.for_all ds ~f:(fun d' -> Domain.equal d.h d'.h) then\n base_and_correction d.h\n else\n Vector.map domains ~f:(fun (ds : Domains.t) ->\n base_and_correction ds.h )\n |> Vector.map2\n (which_branch :> (Boolean.var, n) Vector.t)\n ~f:(fun b pr ->\n Double.map pr ~f:(fun (x, y) ->\n Field.((b :> t) * x, (b :> t) * y) ) )\n |> Vector.reduce_exn\n ~f:(Double.map2 ~f:(Double.map2 ~f:Field.( + )))\n |> Double.map ~f:(Double.map ~f:(Util.seal (module Impl))) )\n\n let _h_precomp =\n Lazy.map ~f:Inner_curve.Scaling_precomputation.create Generators.h\n\n let group_map =\n let f =\n lazy\n (let module M =\n Group_map.Bw19.Make (Field.Constant) (Field)\n (struct\n let params =\n Group_map.Bw19.Params.create\n (module Field.Constant)\n { b = Inner_curve.Params.b }\n end)\n in\n let open M in\n Snarky_group_map.Checked.wrap\n (module Impl)\n ~potential_xs\n ~y_squared:(fun ~x ->\n Field.(\n (x * x * x)\n + (constant Inner_curve.Params.a * x)\n + constant Inner_curve.Params.b) )\n |> unstage )\n in\n fun x -> Lazy.force f x\n\n module Split_commitments = struct\n module Point = struct\n type t =\n [ `Finite of Inner_curve.t\n | `Maybe_finite of Boolean.var * Inner_curve.t ]\n\n let finite : t -> Boolean.var = function\n | `Finite _ ->\n Boolean.true_\n | `Maybe_finite (b, _) ->\n b\n\n let add (p : t) (q : Inner_curve.t) =\n match p with\n | `Finite p ->\n Ops.add_fast p q\n | `Maybe_finite (finite, p) ->\n Inner_curve.if_ finite ~then_:(Ops.add_fast p q) ~else_:q\n\n let underlying = function `Finite p -> p | `Maybe_finite (_, p) -> p\n end\n\n module Curve_opt = struct\n type t = { point : Inner_curve.t; non_zero : Boolean.var }\n end\n\n let combine batch ~xi without_bound with_bound =\n let { Curve_opt.non_zero; point } =\n Pcs_batch.combine_split_commitments batch\n ~scale_and_add:(fun ~(acc : Curve_opt.t) ~xi (keep, (p : Point.t)) ->\n (* match acc.non_zero, keep with\n | false, false -> acc\n | true, false -> acc\n | false, true -> { point= p; non_zero= true }\n | true, true -> { point= p + xi * acc; non_zero= true }\n *)\n let point =\n Inner_curve.(\n if_ keep\n ~then_:\n (if_ acc.non_zero\n ~then_:(Point.add p (Scalar_challenge.endo acc.point xi))\n ~else_:\n ((* In this branch, the accumulator was zero, so there is no harm in\n putting the potentially junk underlying point here. *)\n Point.underlying p ) )\n ~else_:acc.point)\n in\n let non_zero = Boolean.(keep &&& Point.finite p ||| acc.non_zero) in\n { Curve_opt.non_zero; point } )\n ~xi\n ~init:(fun (keep, p) ->\n { non_zero = Boolean.(keep &&& Point.finite p)\n ; point = Point.underlying p\n } )\n without_bound with_bound\n in\n Boolean.Assert.is_true non_zero ;\n point\n end\n\n let scale_fast = Ops.scale_fast\n\n let check_bulletproof ~pcs_batch ~(sponge : Sponge.t)\n ~(xi : Scalar_challenge.t)\n ~(advice :\n Other_field.Packed.t Shifted_value.Type1.t\n Types.Step.Bulletproof.Advice.t )\n ~polynomials:(without_degree_bound, with_degree_bound)\n ~openings_proof:\n ({ lr; delta; z_1; z_2; challenge_polynomial_commitment } :\n ( Inner_curve.t\n , Other_field.Packed.t Shifted_value.Type1.t )\n Openings.Bulletproof.t ) =\n with_label __LOC__ (fun () ->\n Other_field.Packed.absorb_shifted sponge advice.combined_inner_product ;\n (* combined_inner_product should be equal to\n sum_i < t, r^i pows(beta_i) >\n = sum_i r^i < t, pows(beta_i) >\n\n That is checked later.\n *)\n let u =\n let t = Sponge.squeeze_field sponge in\n group_map t\n in\n let open Inner_curve in\n let combined_polynomial (* Corresponds to xi in figure 7 of WTS *) =\n Split_commitments.combine pcs_batch ~xi without_degree_bound\n with_degree_bound\n in\n let scale_fast =\n scale_fast ~num_bits:Other_field.Packed.Constant.size_in_bits\n in\n let lr_prod, challenges = bullet_reduce sponge lr in\n let p_prime =\n let uc = scale_fast u advice.combined_inner_product in\n combined_polynomial + uc\n in\n let q = p_prime + lr_prod in\n absorb sponge PC delta ;\n let c = squeeze_scalar sponge in\n (* c Q + delta = z1 (G + b U) + z2 H *)\n let lhs =\n let cq = Scalar_challenge.endo q c in\n cq + delta\n in\n let rhs =\n let b_u = scale_fast u advice.b in\n let z_1_g_plus_b_u =\n scale_fast (challenge_polynomial_commitment + b_u) z_1\n in\n let z2_h =\n scale_fast (Inner_curve.constant (Lazy.force Generators.h)) z_2\n in\n z_1_g_plus_b_u + z2_h\n in\n (`Success (equal_g lhs rhs), challenges) )\n\n module Opt = struct\n include Opt_sponge.Make (Impl) (Wrap_main_inputs.Sponge.Permutation)\n\n let challenge (s : t) : Field.t =\n lowest_128_bits (squeeze s) ~constrain_low_bits:true\n\n (* No need to boolean constrain scalar challenges. *)\n let scalar_challenge (s : t) : Scalar_challenge.t =\n Import.Scalar_challenge.create\n (lowest_128_bits (squeeze s) ~constrain_low_bits:false)\n end\n\n (* TODO: This doesn't need to be an opt sponge *)\n let absorb sponge ty t =\n Util.absorb ~absorb_field:(Opt.absorb sponge)\n ~g1_to_field_elements:(fun (b, (x, y)) -> [ (b, x); (b, y) ])\n ~absorb_scalar:(fun x -> Opt.absorb sponge (Boolean.true_, x))\n ~mask_g1_opt:(fun ((finite : Boolean.var), (x, y)) ->\n (Boolean.true_, Field.((finite :> t) * x, (finite :> t) * y)) )\n ty t\n\n module Pseudo = Pseudo.Make (Impl)\n\n let mask (type n) (lengths : (int, n) Vector.t) (choice : n One_hot_vector.t)\n : Boolean.var array =\n let max =\n Option.value_exn\n (List.max_elt ~compare:Int.compare (Vector.to_list lengths))\n in\n let length = Pseudo.choose (choice, lengths) ~f:Field.of_int in\n let (T max) = Nat.of_int max in\n Vector.to_array (ones_vector (module Impl) ~first_zero:length max)\n\n module Plonk = Types.Wrap.Proof_state.Deferred_values.Plonk\n\n (* Just for exhaustiveness over fields *)\n let iter2 ~chal ~scalar_chal\n { Plonk.Minimal.alpha = alpha_0\n ; beta = beta_0\n ; gamma = gamma_0\n ; zeta = zeta_0\n ; joint_combiner = _\n ; feature_flags = _\n }\n { Plonk.Minimal.alpha = alpha_1\n ; beta = beta_1\n ; gamma = gamma_1\n ; zeta = zeta_1\n ; joint_combiner = _\n ; feature_flags = _\n } =\n if G.lookup_verification_enabled then failwith \"Wrap_verifier.iter2:TODO\" ;\n with_label __LOC__ (fun () -> chal beta_0 beta_1) ;\n with_label __LOC__ (fun () -> chal gamma_0 gamma_1) ;\n with_label __LOC__ (fun () -> scalar_chal alpha_0 alpha_1) ;\n with_label __LOC__ (fun () -> scalar_chal zeta_0 zeta_1)\n\n let assert_eq_plonk\n (m1 : (_, Field.t Import.Scalar_challenge.t, _) Plonk.Minimal.t)\n (m2 : (_, Scalar_challenge.t, _) Plonk.Minimal.t) =\n iter2 m1 m2\n ~chal:(fun c1 c2 -> Field.Assert.equal c1 c2)\n ~scalar_chal:(fun ({ inner = t1 } : _ Import.Scalar_challenge.t)\n ({ inner = t2 } : Scalar_challenge.t) ->\n Field.Assert.equal t1 t2 )\n\n let incrementally_verify_proof (type b)\n (module Max_proofs_verified : Nat.Add.Intf with type n = b)\n ~actual_proofs_verified_mask ~step_domains ~srs\n ~verification_key:(m : _ Plonk_verification_key_evals.t) ~xi ~sponge\n ~(public_input :\n [ `Field of Field.t * Boolean.var | `Packed_bits of Field.t * int ]\n array ) ~(sg_old : (_, Max_proofs_verified.n) Vector.t) ~advice\n ~(messages : _ Messages.In_circuit.t) ~which_branch ~openings_proof\n ~(plonk : _ Types.Wrap.Proof_state.Deferred_values.Plonk.In_circuit.t) =\n let T = Max_proofs_verified.eq in\n let sg_old =\n with_label __LOC__ (fun () ->\n Vector.map2 actual_proofs_verified_mask sg_old ~f:(fun keep sg ->\n [| (keep, sg) |] ) )\n in\n with_label __LOC__ (fun () ->\n let sample () = Opt.challenge sponge in\n let sample_scalar () : Scalar_challenge.t =\n Opt.scalar_challenge sponge\n in\n let index_digest =\n with_label \"absorb verifier index\" (fun () ->\n let index_sponge = Sponge.create sponge_params in\n Array.iter\n (Types.index_to_field_elements\n ~g:(fun (z : Inputs.Inner_curve.t) ->\n List.to_array (Inner_curve.to_field_elements z) )\n m )\n ~f:(fun x -> Sponge.absorb index_sponge x) ;\n Sponge.squeeze_field index_sponge )\n in\n let without = Type.Without_degree_bound in\n let absorb_g gs =\n absorb sponge without (Array.map gs ~f:(fun g -> (Boolean.true_, g)))\n in\n absorb sponge Field (Boolean.true_, index_digest) ;\n Vector.iter ~f:(Array.iter ~f:(absorb sponge PC)) sg_old ;\n let x_hat =\n let domain = (which_branch, step_domains) in\n let public_input =\n Array.concat_map public_input ~f:(function\n | `Field (x, b) ->\n [| `Field (x, Field.size_in_bits)\n ; `Field ((b :> Field.t), 1)\n |]\n | `Packed_bits (x, n) ->\n [| `Field (x, n) |] )\n in\n let constant_part, non_constant_part =\n List.partition_map\n Array.(to_list (mapi public_input ~f:(fun i t -> (i, t))))\n ~f:(fun (i, t) ->\n match[@warning \"-4\"] t with\n | `Field (Constant c, _) ->\n First\n ( if Field.Constant.(equal zero) c then None\n else if Field.Constant.(equal one) c then\n Some (lagrange ~domain srs i)\n else\n Some\n (scaled_lagrange ~domain\n (Inner_curve.Constant.Scalar.project\n (Field.Constant.unpack c) )\n srs i ) )\n | `Field x ->\n Second (i, x) )\n in\n with_label __LOC__ (fun () ->\n let terms =\n List.map non_constant_part ~f:(fun (i, x) ->\n match x with\n | b, 1 ->\n assert_ (Constraint.boolean (b :> Field.t)) ;\n `Cond_add\n (Boolean.Unsafe.of_cvar b, lagrange ~domain srs i)\n | x, n ->\n `Add_with_correction\n ( (x, n)\n , lagrange_with_correction ~input_length:n ~domain srs\n i ) )\n in\n let correction =\n with_label __LOC__ (fun () ->\n List.reduce_exn\n (List.filter_map terms ~f:(function\n | `Cond_add _ ->\n None\n | `Add_with_correction (_, (_, corr)) ->\n Some corr ) )\n ~f:(Ops.add_fast ?check_finite:None) )\n in\n with_label __LOC__ (fun () ->\n let init =\n List.fold\n (List.filter_map ~f:Fn.id constant_part)\n ~init:correction\n ~f:(Ops.add_fast ?check_finite:None)\n in\n List.fold terms ~init ~f:(fun acc term ->\n match term with\n | `Cond_add (b, g) ->\n with_label __LOC__ (fun () ->\n Inner_curve.if_ b ~then_:(Ops.add_fast g acc)\n ~else_:acc )\n | `Add_with_correction ((x, num_bits), (g, _)) ->\n Ops.add_fast acc\n (Ops.scale_fast2'\n (module Other_field.With_top_bit0)\n g x ~num_bits ) ) ) )\n |> Inner_curve.negate\n in\n let x_hat =\n with_label \"x_hat blinding\" (fun () ->\n Ops.add_fast x_hat\n (Inner_curve.constant (Lazy.force Generators.h)) )\n in\n absorb sponge PC (Boolean.true_, x_hat) ;\n let w_comm = messages.w_comm in\n Vector.iter ~f:absorb_g w_comm ;\n let beta = sample () in\n let gamma = sample () in\n let z_comm = messages.z_comm in\n absorb_g z_comm ;\n let alpha = sample_scalar () in\n let t_comm :\n (Inputs.Impl.Field.t * Inputs.Impl.Field.t)\n Pickles_types__Plonk_types.Poly_comm.Without_degree_bound.t =\n messages.t_comm\n in\n absorb_g t_comm ;\n let zeta = sample_scalar () in\n (* At this point, we should use the previous \"bulletproof_challenges\" to\n compute to compute f(beta_1) outside the snark\n where f is the polynomial corresponding to sg_old\n *)\n let sponge =\n match sponge with\n | { state\n ; sponge_state = Squeezed n\n ; params\n ; needs_final_permute_if_empty = _\n } ->\n S.make ~state ~sponge_state:(Squeezed n) ~params\n | { sponge_state = Absorbing _; _ } ->\n assert false\n in\n let sponge_before_evaluations = Sponge.copy sponge in\n let sponge_digest_before_evaluations = Sponge.squeeze_field sponge in\n\n (* xi, r are sampled here using the other sponge. *)\n (* No need to expose the polynomial evaluations as deferred values as they're\n not needed here for the incremental verification. All we need is a_hat and\n \"combined_inner_product\".\n\n Then, in the other proof, we can witness the evaluations and check their correctness\n against \"combined_inner_product\" *)\n let sigma_comm_init, [ _ ] =\n Vector.split m.sigma_comm (snd (Permuts_minus_1.add Nat.N1.n))\n in\n let scale_fast =\n scale_fast ~num_bits:Other_field.Packed.Constant.size_in_bits\n in\n let ft_comm =\n with_label __LOC__ (fun () ->\n Common.ft_comm\n ~add:(Ops.add_fast ?check_finite:None)\n ~scale:scale_fast ~negate:Inner_curve.negate\n ~endoscale:(Scalar_challenge.endo ?num_bits:None)\n ~verification_key:m ~plonk ~alpha ~t_comm )\n in\n let bulletproof_challenges =\n (* This sponge needs to be initialized with (some derivative of)\n 1. The polynomial commitments\n 2. The combined inner product\n 3. The challenge points.\n\n It should be sufficient to fork the sponge after squeezing beta_3 and then to absorb\n the combined inner product.\n *)\n let num_commitments_without_degree_bound = Nat.N45.n in\n let without_degree_bound =\n (* sg_old\n x_hat\n ft_comm\n z_comm\n generic selector\n poseidon selector\n w_comms\n all but last sigma_comm\n *)\n Vector.append sg_old\n ( [| x_hat |] :: [| ft_comm |] :: z_comm :: [| m.generic_comm |]\n :: [| m.psm_comm |] :: [| m.complete_add_comm |]\n :: [| m.mul_comm |] :: [| m.emul_comm |]\n :: [| m.endomul_scalar_comm |]\n :: Vector.append w_comm\n (Vector.append\n (Vector.map m.coefficients_comm ~f:(fun g -> [| g |]))\n (Vector.map sigma_comm_init ~f:(fun g -> [| g |]))\n (snd Plonk_types.(Columns.add Permuts_minus_1.n)) )\n (snd\n Plonk_types.(\n Columns.add (fst (Columns.add Permuts_minus_1.n))) )\n |> Vector.map ~f:(Array.map ~f:(fun g -> (Boolean.true_, g))) )\n (snd\n (Max_proofs_verified.add num_commitments_without_degree_bound) )\n in\n check_bulletproof\n ~pcs_batch:\n (Common.dlog_pcs_batch\n (Max_proofs_verified.add num_commitments_without_degree_bound) )\n ~sponge:sponge_before_evaluations ~xi ~advice ~openings_proof\n ~polynomials:\n ( Vector.map without_degree_bound\n ~f:(Array.map ~f:(fun (keep, x) -> (keep, `Finite x)))\n , [] )\n in\n let joint_combiner =\n if G.lookup_verification_enabled then failwith \"TODO\" else None\n in\n assert_eq_plonk\n { alpha = plonk.alpha\n ; beta = plonk.beta\n ; gamma = plonk.gamma\n ; zeta = plonk.zeta\n ; joint_combiner\n ; feature_flags = plonk.feature_flags\n }\n { alpha\n ; beta\n ; gamma\n ; zeta\n ; joint_combiner\n ; feature_flags = plonk.feature_flags\n } ;\n (sponge_digest_before_evaluations, bulletproof_challenges) )\n\n let _mask_evals (type n)\n ~(lengths :\n (int, n) Pickles_types.Vector.t Pickles_types.Plonk_types.Evals.t )\n (choice : n One_hot_vector.t)\n (e : Field.t array Pickles_types.Plonk_types.Evals.t) :\n (Boolean.var * Field.t) array Pickles_types.Plonk_types.Evals.t =\n Pickles_types.Plonk_types.Evals.map2 lengths e ~f:(fun lengths e ->\n Array.zip_exn (mask lengths choice) e )\n\n let compute_challenges ~scalar chals =\n Vector.map chals ~f:(fun prechallenge ->\n scalar @@ Bulletproof_challenge.pack prechallenge )\n\n let challenge_polynomial = G.challenge_polynomial (module Field)\n\n let pow2pow (pt : Field.t) (n : int) : Field.t =\n with_label __LOC__ (fun () ->\n let rec go acc i =\n if i = 0 then acc else go (Field.square acc) (i - 1)\n in\n go pt n )\n\n let actual_evaluation (e : Field.t array) ~(pt_to_n : Field.t) : Field.t =\n with_label __LOC__ (fun () ->\n match List.rev (Array.to_list e) with\n | e :: es ->\n List.fold ~init:e es ~f:(fun acc y ->\n let acc' =\n exists Field.typ ~compute:(fun () ->\n As_prover.read_var Field.(y + (pt_to_n * acc)) )\n in\n (* acc' = y + pt_n * acc *)\n let pt_n_acc = Field.(pt_to_n * acc) in\n let open\n Kimchi_backend_common.Plonk_constraint_system.Plonk_constraint in\n (* 0 = - acc' + y + pt_n_acc *)\n let open Field.Constant in\n assert_\n { annotation = None\n ; basic =\n T\n (Basic\n { l = (one, y)\n ; r = (one, pt_n_acc)\n ; o = (negate one, acc')\n ; m = zero\n ; c = zero\n } )\n } ;\n acc' )\n | [] ->\n failwith \"empty list\" )\n\n let _shift1 =\n Pickles_types.Shifted_value.Type1.Shift.(\n map ~f:Field.constant (create (module Field.Constant)))\n\n let shift2 =\n Shifted_value.Type2.Shift.(\n map ~f:Field.constant (create (module Field.Constant)))\n\n let%test_unit \"endo scalar\" =\n SC.test (module Impl) ~endo:Endo.Step_inner_curve.scalar\n\n let map_plonk_to_field plonk =\n Types.Step.Proof_state.Deferred_values.Plonk.In_circuit.map_challenges\n ~f:(Util.seal (module Impl))\n ~scalar:scalar_to_field plonk\n |> Types.Step.Proof_state.Deferred_values.Plonk.In_circuit.map_fields\n ~f:(Shifted_value.Type2.map ~f:(Util.seal (module Impl)))\n\n module Plonk_checks = struct\n include Plonk_checks\n include Plonk_checks.Make (Shifted_value.Type2) (Plonk_checks.Scalars.Tock)\n end\n\n (* This finalizes the \"deferred values\" coming from a previous proof over the same field.\n It\n 1. Checks that [xi] and [r] where sampled correctly. I.e., by absorbing all the\n evaluation openings and then squeezing.\n 2. Checks that the \"combined inner product\" value used in the elliptic curve part of\n the opening proof was computed correctly, in terms of the evaluation openings and the\n evaluation points.\n 3. Check that the \"b\" value was computed correctly.\n 4. Perform the arithmetic checks from marlin. *)\n let finalize_other_proof (type b)\n (module Proofs_verified : Nat.Add.Intf with type n = b) ~domain ~sponge\n ~(old_bulletproof_challenges : (_, b) Vector.t)\n ({ xi; combined_inner_product; bulletproof_challenges; b; plonk } :\n ( _\n , _\n , _ Shifted_value.Type2.t\n , _ )\n Types.Step.Proof_state.Deferred_values.In_circuit.t )\n { Plonk_types.All_evals.In_circuit.ft_eval1; evals } =\n let module Plonk = Types.Step.Proof_state.Deferred_values.Plonk in\n let T = Proofs_verified.eq in\n (* You use the NEW bulletproof challenges to check b. Not the old ones. *)\n let open Field in\n let plonk = map_plonk_to_field plonk in\n let zetaw = Field.mul domain#generator plonk.zeta in\n let sg_evals1, sg_evals2 =\n let sg_olds =\n Vector.map old_bulletproof_challenges ~f:(fun chals ->\n unstage (challenge_polynomial (Vector.to_array chals)) )\n in\n let sg_evals pt = Vector.map sg_olds ~f:(fun f -> f pt) in\n (sg_evals plonk.zeta, sg_evals zetaw)\n in\n let sponge_state =\n (* Absorb bulletproof challenges *)\n let challenge_digest =\n let sponge = Sponge.create sponge_params in\n Vector.iter old_bulletproof_challenges\n ~f:(Vector.iter ~f:(Sponge.absorb sponge)) ;\n Sponge.squeeze sponge\n in\n Sponge.absorb sponge challenge_digest ;\n Sponge.absorb sponge ft_eval1 ;\n Sponge.absorb sponge (fst evals.public_input) ;\n Sponge.absorb sponge (snd evals.public_input) ;\n let xs = Evals.In_circuit.to_absorption_sequence evals.evals in\n (* This is a hacky, but much more efficient, version of the opt sponge.\n This uses the assumption that the sponge 'absorption state' will align\n after each optional absorption, letting us skip the expensive tracking\n that this would otherwise require.\n To future-proof this, we assert that the states are indeed compatible.\n *)\n List.iter xs ~f:(fun opt ->\n let absorb = Array.iter ~f:(fun x -> Sponge.absorb sponge x) in\n match opt with\n | None ->\n ()\n | Some (x1, x2) ->\n absorb x1 ; absorb x2\n | Maybe (b, (x1, x2)) ->\n (* Cache the sponge state before *)\n let sponge_state_before = sponge.sponge_state in\n let state_before = Array.copy sponge.state in\n (* Absorb the points *)\n absorb x1 ;\n absorb x2 ;\n (* Check that the sponge ends in a compatible state. *)\n ( match (sponge_state_before, sponge.sponge_state) with\n | Absorbed x, Absorbed y ->\n [%test_eq: int] x y\n | Squeezed x, Squeezed y ->\n [%test_eq: int] x y\n | Absorbed _, Squeezed _ ->\n [%test_eq: string] \"absorbed\" \"squeezed\"\n | Squeezed _, Absorbed _ ->\n [%test_eq: string] \"squeezed\" \"absorbed\" ) ;\n let state =\n Array.map2_exn sponge.state state_before ~f:(fun then_ else_ ->\n Field.if_ b ~then_ ~else_ )\n in\n sponge.state <- state ) ;\n Array.copy sponge.state\n in\n sponge.state <- sponge_state ;\n let xi_actual = squeeze_scalar sponge in\n let r_actual = squeeze_challenge sponge in\n let xi_correct =\n with_label __LOC__ (fun () ->\n let { Import.Scalar_challenge.inner = xi_actual } = xi_actual in\n let { Import.Scalar_challenge.inner = xi } = xi in\n (* Sample new sg challenge point here *)\n Field.equal xi_actual xi )\n in\n let xi = scalar_to_field xi in\n (* TODO: r actually does not need to be a scalar challenge. *)\n let r = scalar_to_field (Import.Scalar_challenge.create r_actual) in\n let plonk_minimal =\n plonk |> Plonk.to_minimal\n |> Plonk.Minimal.to_wrap\n ~feature_flags:Features.(map ~f:Boolean.var_of_value none_bool)\n in\n let combined_evals =\n let n = Common.Max_degree.wrap_log2 in\n (* TODO: zeta_n is recomputed in [env] below *)\n let zeta_n = pow2pow plonk.zeta n in\n let zetaw_n = pow2pow zetaw n in\n Evals.In_circuit.map evals.evals ~f:(fun (x0, x1) ->\n ( actual_evaluation ~pt_to_n:zeta_n x0\n , actual_evaluation ~pt_to_n:zetaw_n x1 ) )\n in\n let env =\n let module Env_bool = struct\n include Boolean\n\n type t = Boolean.var\n end in\n let module Env_field = struct\n include Field\n\n type bool = Env_bool.t\n\n let if_ (b : bool) ~then_ ~else_ =\n match Impl.Field.to_constant (b :> t) with\n | Some x ->\n (* We have a constant, only compute the branch we care about. *)\n if Impl.Field.Constant.(equal one) x then then_ () else else_ ()\n | None ->\n if_ b ~then_:(then_ ()) ~else_:(else_ ())\n end in\n Plonk_checks.scalars_env\n (module Env_bool)\n (module Env_field)\n ~srs_length_log2:Common.Max_degree.wrap_log2\n ~endo:(Impl.Field.constant Endo.Wrap_inner_curve.base)\n ~mds:sponge_params.mds\n ~field_of_hex:(fun s ->\n Kimchi_pasta.Pasta.Bigint256.of_hex_string s\n |> Kimchi_pasta.Pasta.Fq.of_bigint |> Field.constant )\n ~domain plonk_minimal combined_evals\n in\n let combined_inner_product_correct =\n let evals1, evals2 =\n All_evals.With_public_input.In_circuit.factor evals\n in\n with_label __LOC__ (fun () ->\n let ft_eval0 : Field.t =\n with_label __LOC__ (fun () ->\n Plonk_checks.ft_eval0\n (module Field)\n ~env ~domain plonk_minimal combined_evals evals1.public_input )\n in\n (* sum_i r^i sum_j xi^j f_j(beta_i) *)\n let actual_combined_inner_product =\n let combine ~ft ~sg_evals x_hat\n (e : (Field.t array, _) Evals.In_circuit.t) =\n let a =\n Evals.In_circuit.to_list e\n |> List.map ~f:(function\n | None ->\n [||]\n | Some a ->\n Array.map a ~f:(fun x -> Plonk_types.Opt.Some x)\n | Maybe (b, a) ->\n Array.map a ~f:(fun x -> Plonk_types.Opt.Maybe (b, x)) )\n in\n let sg_evals =\n Vector.map sg_evals ~f:(fun x -> [| Plonk_types.Opt.Some x |])\n |> Vector.to_list\n (* TODO: This was the code before the wrap hack was put in\n match actual_proofs_verified with\n | None ->\n Vector.map sg_olds ~f:(fun f -> [| f pt |])\n | Some proofs_verified ->\n let mask =\n ones_vector\n (module Impl)\n ~first_zero:proofs_verified (Vector.length sg_olds)\n in\n with_label __LOC__ (fun () ->\n Vector.map2 mask sg_olds ~f:(fun b f ->\n [| Field.((b :> t) * f pt) |] ) ) *)\n in\n let v =\n List.append sg_evals ([| Some x_hat |] :: [| Some ft |] :: a)\n in\n Common.combined_evaluation (module Impl) ~xi v\n in\n combine ~ft:ft_eval0 ~sg_evals:sg_evals1 evals1.public_input\n evals1.evals\n + r\n * combine ~ft:ft_eval1 ~sg_evals:sg_evals2 evals2.public_input\n evals2.evals\n in\n with_label __LOC__ (fun () ->\n equal\n (Shifted_value.Type2.to_field\n (module Field)\n ~shift:shift2 combined_inner_product )\n actual_combined_inner_product ) )\n in\n let bulletproof_challenges =\n with_label __LOC__ (fun () ->\n compute_challenges ~scalar:scalar_to_field bulletproof_challenges )\n in\n let b_correct =\n with_label __LOC__ (fun () ->\n let challenge_poly =\n unstage\n (challenge_polynomial (Vector.to_array bulletproof_challenges))\n in\n let b_actual =\n challenge_poly plonk.zeta + (r * challenge_poly zetaw)\n in\n equal\n (Shifted_value.Type2.to_field (module Field) ~shift:shift2 b)\n b_actual )\n in\n let plonk_checks_passed =\n with_label __LOC__ (fun () ->\n (* This proof is a wrap proof; no need to consider features. *)\n Plonk_checks.checked\n (module Impl)\n ~env ~shift:shift2\n (Composition_types.Step.Proof_state.Deferred_values.Plonk.In_circuit\n .to_wrap ~opt_none:Plonk_types.Opt.None ~false_:Boolean.false_\n plonk )\n combined_evals )\n in\n print_bool \"xi_correct\" xi_correct ;\n print_bool \"combined_inner_product_correct\" combined_inner_product_correct ;\n print_bool \"plonk_checks_passed\" plonk_checks_passed ;\n print_bool \"b_correct\" b_correct ;\n ( Boolean.all\n [ xi_correct\n ; b_correct\n ; combined_inner_product_correct\n ; plonk_checks_passed\n ]\n , bulletproof_challenges )\n\n let _map_challenges\n { Import.Types.Step.Proof_state.Deferred_values.plonk\n ; combined_inner_product\n ; xi\n ; bulletproof_challenges\n ; b\n } ~f ~scalar =\n { Types.Step.Proof_state.Deferred_values.plonk =\n Types.Step.Proof_state.Deferred_values.Plonk.In_circuit.map_challenges\n plonk ~f ~scalar\n ; combined_inner_product\n ; bulletproof_challenges =\n Vector.map bulletproof_challenges\n ~f:(fun (r : _ Bulletproof_challenge.t) ->\n Bulletproof_challenge.map ~f:scalar r )\n ; xi = scalar xi\n ; b\n }\nend\n\ninclude Make (Wrap_main_inputs)\n\nlet challenge_polynomial = G.challenge_polynomial\n","(* q > p *)\nopen Core_kernel\nmodule SC = Scalar_challenge\nopen Import\nopen Common\nopen Util\nopen Types.Step\nopen Pickles_types\n\nlet lookup_verification_enabled = false\n\nmodule Make\n (Inputs : Intf.Step_main_inputs.S\n with type Impl.field = Backend.Tick.Field.t\n and type Impl.Bigint.t = Backend.Tick.Bigint.t\n and type Inner_curve.Constant.Scalar.t = Backend.Tock.Field.t) =\nstruct\n open Inputs\n open Impl\n module Challenge = Challenge.Make (Impl)\n module Digest = Digest.Make (Impl)\n\n (* Other_field.size > Field.size *)\n module Other_field = struct\n let size_in_bits = Field.size_in_bits\n\n type t = Impls.Step.Other_field.t\n\n let typ = Impls.Step.Other_field.typ\n end\n\n let print_fp lab x =\n if debug then\n as_prover\n As_prover.(\n fun () ->\n printf !\"%s: %{sexp:Backend.Tick.Field.t}\\n%!\" lab (read_var x))\n\n let print_bool lab x =\n if debug then\n as_prover (fun () ->\n printf \"%s: %b\\n%!\" lab (As_prover.read Boolean.typ x) )\n\n let equal_g g1 g2 =\n List.map2_exn ~f:Field.equal\n (Inner_curve.to_field_elements g1)\n (Inner_curve.to_field_elements g2)\n |> Boolean.all\n\n let absorb sponge ty t =\n absorb\n ~absorb_field:(fun x -> Sponge.absorb sponge (`Field x))\n ~g1_to_field_elements:Inner_curve.to_field_elements\n ~absorb_scalar:(fun (x, (b : Boolean.var)) ->\n Sponge.absorb sponge (`Field x) ;\n Sponge.absorb sponge (`Bits [ b ]) )\n ~mask_g1_opt:(fun ((b : Boolean.var), (x, y)) ->\n Field.((b :> t) * x, (b :> t) * y) )\n ty t\n\n let _scalar_to_field s =\n SC.to_field_checked (module Impl) s ~endo:Endo.Wrap_inner_curve.scalar\n\n let assert_n_bits ~n a =\n (* Scalar_challenge.to_field_checked has the side effect of\n checking that the input fits in n bits. *)\n ignore\n ( SC.to_field_checked\n (module Impl)\n (Import.Scalar_challenge.create a)\n ~endo:Endo.Wrap_inner_curve.scalar ~num_bits:n\n : Field.t )\n\n let lowest_128_bits ~constrain_low_bits x =\n let assert_128_bits = assert_n_bits ~n:128 in\n Util.lowest_128_bits ~constrain_low_bits ~assert_128_bits (module Impl) x\n\n module Scalar_challenge =\n SC.Make (Impl) (Inner_curve) (Challenge) (Endo.Step_inner_curve)\n module Ops = Step_main_inputs.Ops\n\n module Inner_curve = struct\n include Inner_curve\n\n let ( + ) = Ops.add_fast\n end\n\n module Public_input_scalar = struct\n type t = Field.t\n\n let typ = Field.typ\n\n module Constant = struct\n include Field.Constant\n\n let to_bigint = Impl.Bigint.of_field\n end\n end\n\n let multiscale_known\n (ts :\n ( [ `Field of Field.t | `Packed_bits of Field.t * int ]\n * Inner_curve.Constant.t )\n array ) =\n let module F = Public_input_scalar in\n let rec pow2pow x i =\n if i = 0 then x else pow2pow Inner_curve.Constant.(x + x) (i - 1)\n in\n with_label __LOC__ (fun () ->\n let constant_part, non_constant_part =\n List.partition_map (Array.to_list ts) ~f:(fun (t, g) ->\n match[@warning \"-4\"] t with\n | `Field (Constant c) | `Packed_bits (Constant c, _) ->\n First\n ( if Field.Constant.(equal zero) c then None\n else if Field.Constant.(equal one) c then Some g\n else\n Some\n (Inner_curve.Constant.scale g\n (Inner_curve.Constant.Scalar.project\n (Field.Constant.unpack c) ) ) )\n | `Field x ->\n Second (`Field x, g)\n | `Packed_bits (x, n) ->\n Second (`Packed_bits (x, n), g) )\n in\n let add_opt xo y =\n Option.value_map xo ~default:y ~f:(fun x ->\n Inner_curve.Constant.( + ) x y )\n in\n let constant_part =\n List.filter_map constant_part ~f:Fn.id\n |> List.fold ~init:None ~f:(fun acc x -> Some (add_opt acc x))\n in\n let correction, acc =\n List.map non_constant_part ~f:(fun (s, x) ->\n let rr, n =\n match s with\n | `Packed_bits (s, n) ->\n ( Ops.scale_fast2'\n (module F)\n (Inner_curve.constant x) s ~num_bits:n\n , n )\n | `Field s ->\n ( Ops.scale_fast2'\n (module F)\n (Inner_curve.constant x) s ~num_bits:Field.size_in_bits\n , Field.size_in_bits )\n in\n let n =\n Ops.bits_per_chunk * Ops.chunks_needed ~num_bits:(n - 1)\n in\n let cc = pow2pow x n in\n (cc, rr) )\n |> List.reduce_exn ~f:(fun (a1, b1) (a2, b2) ->\n (Inner_curve.Constant.( + ) a1 a2, Inner_curve.( + ) b1 b2) )\n in\n Inner_curve.(\n acc + constant (Constant.negate correction |> add_opt constant_part)) )\n\n let squeeze_challenge sponge : Field.t =\n lowest_128_bits (Sponge.squeeze sponge) ~constrain_low_bits:true\n\n let squeeze_scalar sponge : Field.t Import.Scalar_challenge.t =\n (* No need to boolean constrain scalar challenges. *)\n Import.Scalar_challenge.create\n (lowest_128_bits ~constrain_low_bits:false (Sponge.squeeze sponge))\n\n let bullet_reduce sponge gammas =\n with_label __LOC__ (fun () ->\n let absorb t = absorb sponge t in\n let prechallenges =\n Array.map gammas ~f:(fun gammas_i ->\n absorb (PC :: PC) gammas_i ;\n squeeze_scalar sponge )\n in\n let term_and_challenge (l, r) pre =\n let left_term = Scalar_challenge.endo_inv l pre in\n let right_term = Scalar_challenge.endo r pre in\n ( Inner_curve.(left_term + right_term)\n , Bulletproof_challenge.unpack pre )\n in\n let terms, challenges =\n Array.map2_exn gammas prechallenges ~f:term_and_challenge\n |> Array.unzip\n in\n (Array.reduce_exn terms ~f:(fun x y -> Inner_curve.(x + y)), challenges) )\n\n let group_map =\n let f =\n lazy\n (let module M =\n Group_map.Bw19.Make (Field.Constant) (Field)\n (struct\n let params =\n Group_map.Bw19.Params.create\n (module Field.Constant)\n { b = Inner_curve.Params.b }\n end)\n in\n let open M in\n Snarky_group_map.Checked.wrap\n (module Impl)\n ~potential_xs\n ~y_squared:(fun ~x ->\n Field.(\n (x * x * x)\n + (constant Inner_curve.Params.a * x)\n + constant Inner_curve.Params.b) )\n |> unstage )\n in\n fun x -> Lazy.force f x\n\n let _scale_fast p s =\n with_label __LOC__ (fun () ->\n Ops.scale_fast p s ~num_bits:Field.size_in_bits )\n\n let scale_fast2 p (s : Other_field.t Shifted_value.Type2.t) =\n with_label __LOC__ (fun () ->\n Ops.scale_fast2 p s ~num_bits:Field.size_in_bits )\n\n let check_bulletproof ~pcs_batch ~(sponge : Sponge.t) ~xi\n ~(* Corresponds to y in figure 7 of WTS *)\n (* sum_i r^i sum_j xi^j f_j(beta_i) *)\n (advice : _ Bulletproof.Advice.t)\n ~polynomials:(without_degree_bound, with_degree_bound)\n ~opening:\n ({ lr; delta; z_1; z_2; challenge_polynomial_commitment } :\n (Inner_curve.t, Other_field.t Shifted_value.Type2.t) Bulletproof.t ) =\n with_label \"check_bulletproof\" (fun () ->\n absorb sponge Scalar\n ( match advice.combined_inner_product with\n | Shifted_value.Type2.Shifted_value x ->\n x ) ;\n (* a_hat should be equal to\n sum_i < t, r^i pows(beta_i) >\n = sum_i r^i < t, pows(beta_i) > *)\n let u =\n let t = Sponge.squeeze_field sponge in\n group_map t\n in\n let open Inner_curve in\n let combined_polynomial (* Corresponds to xi in figure 7 of WTS *) =\n with_label \"combined_polynomial\" (fun () ->\n Pcs_batch.combine_split_commitments pcs_batch\n ~scale_and_add:(fun ~(acc :\n [ `Maybe_finite of\n Boolean.var * Inner_curve.t\n | `Finite of Inner_curve.t ] ) ~xi p ->\n match acc with\n | `Maybe_finite (acc_is_finite, (acc : Inner_curve.t)) -> (\n match p with\n | `Maybe_finite (p_is_finite, p) ->\n let is_finite =\n Boolean.(p_is_finite ||| acc_is_finite)\n in\n let xi_acc = Scalar_challenge.endo acc xi in\n `Maybe_finite\n ( is_finite\n , if_ acc_is_finite ~then_:(p + xi_acc) ~else_:p )\n | `Finite p ->\n let xi_acc = Scalar_challenge.endo acc xi in\n `Finite\n (if_ acc_is_finite ~then_:(p + xi_acc) ~else_:p) )\n | `Finite acc ->\n let xi_acc = Scalar_challenge.endo acc xi in\n `Finite\n ( match p with\n | `Finite p ->\n p + xi_acc\n | `Maybe_finite (p_is_finite, p) ->\n if_ p_is_finite ~then_:(p + xi_acc) ~else_:xi_acc )\n )\n ~xi\n ~init:(function\n | `Finite x -> `Finite x | `Maybe_finite x -> `Maybe_finite x\n )\n (Vector.map without_degree_bound\n ~f:(Array.map ~f:(fun x -> `Finite x)) )\n (Vector.map with_degree_bound\n ~f:\n (let open Plonk_types.Poly_comm.With_degree_bound in\n fun { shifted; unshifted } ->\n let f x = `Maybe_finite x in\n { unshifted = Array.map ~f unshifted\n ; shifted = f shifted\n }) ) )\n |> function `Finite x -> x | `Maybe_finite _ -> assert false\n in\n let lr_prod, challenges = bullet_reduce sponge lr in\n let p_prime =\n let uc = scale_fast2 u advice.combined_inner_product in\n combined_polynomial + uc\n in\n let q = p_prime + lr_prod in\n absorb sponge PC delta ;\n let c = squeeze_scalar sponge in\n print_fp \"c\" c.inner ;\n (* c Q + delta = z1 (G + b U) + z2 H *)\n let lhs =\n let cq = Scalar_challenge.endo q c in\n cq + delta\n in\n let rhs =\n with_label __LOC__ (fun () ->\n let b_u = scale_fast2 u advice.b in\n let z_1_g_plus_b_u =\n scale_fast2 (challenge_polynomial_commitment + b_u) z_1\n in\n let z2_h =\n scale_fast2 (Inner_curve.constant (Lazy.force Generators.h)) z_2\n in\n z_1_g_plus_b_u + z2_h )\n in\n (`Success (equal_g lhs rhs), challenges) )\n\n let assert_eq_deferred_values\n (m1 :\n ( 'a\n , Inputs.Impl.Field.t Import.Scalar_challenge.t\n , _ )\n Types.Wrap.Proof_state.Deferred_values.Plonk.Minimal.t )\n (m2 :\n ( Inputs.Impl.Field.t\n , Inputs.Impl.Field.t Import.Scalar_challenge.t\n , _ )\n Types.Wrap.Proof_state.Deferred_values.Plonk.Minimal.t ) =\n let open Types.Wrap.Proof_state.Deferred_values.Plonk.Minimal in\n let chal c1 c2 = Field.Assert.equal c1 c2 in\n let scalar_chal\n ({ Import.Scalar_challenge.inner = t1 } : _ Import.Scalar_challenge.t)\n ({ Import.Scalar_challenge.inner = t2 } : _ Import.Scalar_challenge.t) =\n Field.Assert.equal t1 t2\n in\n with_label __LOC__ (fun () -> chal m1.beta m2.beta) ;\n with_label __LOC__ (fun () -> chal m1.gamma m2.gamma) ;\n with_label __LOC__ (fun () -> scalar_chal m1.alpha m2.alpha) ;\n with_label __LOC__ (fun () -> scalar_chal m1.zeta m2.zeta)\n\n let lagrange_commitment ~domain srs i =\n let d = Int.pow 2 (Domain.log2_size domain) in\n match[@warning \"-4\"]\n (Kimchi_bindings.Protocol.SRS.Fq.lagrange_commitment srs d i).unshifted\n with\n | [| Finite g |] ->\n Inner_curve.Constant.of_affine g\n | _ ->\n assert false\n\n module O = One_hot_vector.Make (Impl)\n open Tuple_lib\n\n let public_input_commitment_dynamic (type n) ~srs (which : n O.t)\n (domains : (Domains.t, n) Vector.t)\n ~(public_input :\n [ `Field of Field.t | `Packed_bits of Field.t * int ] array ) =\n (*\n let domains : (Domains.t, Nat.N3.n) Vector.t =\n Vector.map ~f:(fun proofs_verified -> Common.wrap_domains ~proofs_verified)\n [ 0; 1 ; 2 ]\n in *)\n let lagrange_commitment (d : Domains.t) (i : int) : Inner_curve.Constant.t =\n lagrange_commitment ~domain:d.h srs i\n in\n let select_curve_points (type k)\n ~(points_for_domain : Domains.t -> (Inner_curve.Constant.t, k) Vector.t)\n : (Inner_curve.t, k) Vector.t =\n match domains with\n | [] ->\n assert false\n | d :: ds ->\n if Vector.for_all ds ~f:(fun d' -> Domain.equal d.h d'.h) then\n Vector.map ~f:Inner_curve.constant (points_for_domain d)\n else\n Vector.map2\n (which :> (Boolean.var, n) Vector.t)\n domains\n ~f:(fun b d ->\n let points = points_for_domain d in\n Vector.map points ~f:(fun g ->\n let x, y = Inner_curve.constant g in\n Field.((b :> t) * x, (b :> t) * y) ) )\n |> Vector.reduce_exn\n ~f:(Vector.map2 ~f:(Double.map2 ~f:Field.( + )))\n |> Vector.map ~f:(Double.map ~f:(Util.seal (module Impl)))\n in\n let lagrange i =\n select_curve_points ~points_for_domain:(fun d ->\n [ lagrange_commitment d i ] )\n |> Vector.unsingleton\n in\n let lagrange_with_correction ~input_length i :\n (Inner_curve.t, Nat.N2.n) Vector.t =\n let actual_shift =\n (* TODO: num_bits should maybe be input_length - 1. *)\n Ops.bits_per_chunk * Ops.chunks_needed ~num_bits:input_length\n in\n let rec pow2pow x i =\n if i = 0 then x else pow2pow Inner_curve.Constant.(x + x) (i - 1)\n in\n select_curve_points ~points_for_domain:(fun d ->\n let g = lagrange_commitment d i in\n let open Inner_curve.Constant in\n [ g; negate (pow2pow g actual_shift) ] )\n in\n let x_hat =\n let constant_part, non_constant_part =\n List.partition_map\n (Array.to_list (Array.mapi ~f:(fun i t -> (i, t)) public_input))\n ~f:(fun (i, t) ->\n match[@warning \"-4\"] t with\n | `Field (Constant c) | `Packed_bits (Constant c, _) ->\n First\n ( if Field.Constant.(equal zero) c then None\n else if Field.Constant.(equal one) c then Some (lagrange i)\n else\n Some\n ( select_curve_points ~points_for_domain:(fun d ->\n [ Inner_curve.Constant.scale\n (lagrange_commitment d i)\n (Inner_curve.Constant.Scalar.project\n (Field.Constant.unpack c) )\n ] )\n |> Vector.unsingleton ) )\n | `Field x ->\n Second (i, (x, Public_input_scalar.Constant.size_in_bits))\n | `Packed_bits (x, n) ->\n Second (i, (x, n)) )\n in\n let terms =\n List.map non_constant_part ~f:(fun (i, x) ->\n match x with\n | b, 1 ->\n assert_ (Constraint.boolean (b :> Field.t)) ;\n `Cond_add (Boolean.Unsafe.of_cvar b, lagrange i)\n | x, n ->\n `Add_with_correction\n ((x, n), lagrange_with_correction ~input_length:n i) )\n in\n let f = Ops.add_fast ?check_finite:None in\n let correction =\n List.reduce_exn\n (List.filter_map terms ~f:(function\n | `Cond_add _ ->\n None\n | `Add_with_correction (_, [ _; corr ]) ->\n Some corr ) )\n ~f\n in\n let init =\n List.fold (List.filter_map constant_part ~f:Fn.id) ~init:correction ~f\n in\n List.fold terms ~init ~f:(fun acc term ->\n match term with\n | `Cond_add (b, g) ->\n with_label __LOC__ (fun () ->\n Inner_curve.if_ b ~then_:(Ops.add_fast g acc) ~else_:acc )\n | `Add_with_correction ((x, num_bits), [ g; _ ]) ->\n Ops.add_fast acc\n (Ops.scale_fast2' (module Public_input_scalar) g x ~num_bits) )\n |> Inner_curve.negate\n in\n x_hat\n\n let incrementally_verify_proof (type b)\n (module Proofs_verified : Nat.Add.Intf with type n = b) ~srs:_\n ~(domain :\n [ `Known of Domain.t\n | `Side_loaded of\n _ Composition_types.Branch_data.Proofs_verified.One_hot.Checked.t ]\n ) ~srs ~verification_key:(m : _ Plonk_verification_key_evals.t) ~xi\n ~sponge ~sponge_after_index\n ~(public_input :\n [ `Field of Field.t | `Packed_bits of Field.t * int ] array )\n ~(sg_old : (_, Proofs_verified.n) Vector.t) ~advice\n ~proof:({ messages; opening } : Wrap_proof.Checked.t)\n ~(plonk :\n ( _\n , _\n , _ Shifted_value.Type2.t\n , _\n , _\n , _ )\n Types.Wrap.Proof_state.Deferred_values.Plonk.In_circuit.t ) =\n with_label \"incrementally_verify_proof\" (fun () ->\n let receive ty f =\n with_label \"receive\" (fun () ->\n let x = f messages in\n absorb sponge ty x ; x )\n in\n let sample () = squeeze_challenge sponge in\n let sample_scalar () = squeeze_scalar sponge in\n let open Plonk_types.Messages.In_circuit in\n let without = Type.Without_degree_bound in\n let absorb_g gs = absorb sponge without gs in\n let index_digest =\n with_label \"absorb verifier index\" (fun () ->\n let index_sponge = Sponge.copy sponge_after_index in\n Sponge.squeeze_field index_sponge )\n in\n absorb sponge Field index_digest ;\n let sg_old : (_, Wrap_hack.Padded_length.n) Vector.t =\n Wrap_hack.Checked.pad_commitments sg_old\n in\n Vector.iter ~f:(absorb sponge PC) sg_old ;\n let x_hat =\n with_label \"x_hat\" (fun () ->\n match domain with\n | `Known domain ->\n multiscale_known\n (Array.mapi public_input ~f:(fun i x ->\n (x, lagrange_commitment ~domain srs i) ) )\n |> Inner_curve.negate\n | `Side_loaded which ->\n public_input_commitment_dynamic ~srs which\n (Vector.map\n ~f:(fun proofs_verified ->\n Common.wrap_domains ~proofs_verified )\n [ 0; 1; 2 ] )\n ~public_input )\n in\n let x_hat =\n with_label \"x_hat blinding\" (fun () ->\n Ops.add_fast x_hat\n (Inner_curve.constant (Lazy.force Generators.h)) )\n in\n absorb sponge PC x_hat ;\n let w_comm = messages.w_comm in\n Vector.iter ~f:absorb_g w_comm ;\n let beta = sample () in\n let gamma = sample () in\n let z_comm = receive without z_comm in\n let alpha = sample_scalar () in\n let t_comm = receive without t_comm in\n let zeta = sample_scalar () in\n (* At this point, we should use the previous \"bulletproof_challenges\" to\n compute to compute f(beta_1) outside the snark\n where f is the polynomial corresponding to sg_old\n *)\n let sponge_before_evaluations = Sponge.copy sponge in\n let sponge_digest_before_evaluations = Sponge.squeeze_field sponge in\n\n (* xi, r are sampled here using the other sponge. *)\n (* No need to expose the polynomial evaluations as deferred values as they're\n not needed here for the incremental verification. All we need is a_hat and\n \"combined_inner_product\".\n\n Then, in the other proof, we can witness the evaluations and check their correctness\n against \"combined_inner_product\" *)\n let sigma_comm_init, [ _ ] =\n Vector.split m.sigma_comm\n (snd (Plonk_types.Permuts_minus_1.add Nat.N1.n))\n in\n let ft_comm =\n with_label __LOC__ (fun () ->\n Common.ft_comm\n ~add:(Ops.add_fast ?check_finite:None)\n ~scale:scale_fast2 ~negate:Inner_curve.negate\n ~endoscale:(Scalar_challenge.endo ?num_bits:None)\n ~verification_key:m ~plonk ~alpha ~t_comm )\n in\n let bulletproof_challenges =\n (* This sponge needs to be initialized with (some derivative of)\n 1. The polynomial commitments\n 2. The combined inner product\n 3. The challenge points.\n\n It should be sufficient to fork the sponge after squeezing beta_3 and then to absorb\n the combined inner product.\n *)\n let num_commitments_without_degree_bound = Nat.N45.n in\n let without_degree_bound =\n Vector.append\n (Vector.map sg_old ~f:(fun g -> [| g |]))\n ( [| x_hat |] :: [| ft_comm |] :: z_comm :: [| m.generic_comm |]\n :: [| m.psm_comm |] :: [| m.complete_add_comm |]\n :: [| m.mul_comm |] :: [| m.emul_comm |]\n :: [| m.endomul_scalar_comm |]\n :: Vector.append w_comm\n (Vector.append\n (Vector.map m.coefficients_comm ~f:(fun g -> [| g |]))\n (Vector.map sigma_comm_init ~f:(fun g -> [| g |]))\n (snd Plonk_types.(Columns.add Permuts_minus_1.n)) )\n (snd\n Plonk_types.(\n Columns.add (fst (Columns.add Permuts_minus_1.n))) ) )\n (snd\n (Wrap_hack.Padded_length.add\n num_commitments_without_degree_bound ) )\n in\n with_label \"check_bulletproof\" (fun () ->\n check_bulletproof\n ~pcs_batch:\n (Common.dlog_pcs_batch\n (Wrap_hack.Padded_length.add\n num_commitments_without_degree_bound ) )\n ~sponge:sponge_before_evaluations ~xi ~advice ~opening\n ~polynomials:(without_degree_bound, []) )\n in\n let joint_combiner =\n if lookup_verification_enabled then failwith \"TODO\" else None\n in\n assert_eq_deferred_values\n { alpha = plonk.alpha\n ; beta = plonk.beta\n ; gamma = plonk.gamma\n ; zeta = plonk.zeta\n ; joint_combiner\n ; feature_flags = plonk.feature_flags\n }\n { alpha\n ; beta\n ; gamma\n ; zeta\n ; joint_combiner\n ; feature_flags = plonk.feature_flags\n } ;\n (sponge_digest_before_evaluations, bulletproof_challenges) )\n\n let compute_challenges ~scalar chals =\n with_label \"compute_challenges\" (fun () ->\n Vector.map chals ~f:(fun b -> Bulletproof_challenge.pack b |> scalar) )\n\n let challenge_polynomial = Wrap_verifier.challenge_polynomial (module Field)\n\n module Pseudo = Pseudo.Make (Impl)\n\n (* module Bounded = struct\n type t = { max : int; actual : Field.t }\n\n let _of_pseudo ((_, ns) as p : _ Pseudo.t) =\n { max = Vector.reduce_exn ~f:Int.max ns\n ; actual = Pseudo.choose p ~f:Field.of_int\n }\n end *)\n\n let vanishing_polynomial mask =\n with_label \"vanishing_polynomial\" (fun () ->\n let mask = Vector.to_array mask in\n let max = Array.length mask in\n fun x ->\n let rec go acc i =\n if i >= max then acc\n else\n let should_square = mask.(i) in\n let acc =\n Field.if_ should_square ~then_:(Field.square acc) ~else_:acc\n in\n go acc (i + 1)\n in\n Field.sub (go x 0) Field.one )\n\n let shifts ~log2_size = Common.tick_shifts ~log2_size\n\n let domain_generator ~log2_size =\n Backend.Tick.Field.domain_generator ~log2_size |> Impl.Field.constant\n\n let side_loaded_domain =\n let open Side_loaded_verification_key in\n fun ~(log2_size : Field.t) ->\n let domain ~max =\n let (T max_n) = Nat.of_int max in\n let mask = ones_vector (module Impl) max_n ~first_zero:log2_size in\n let log2_sizes =\n ( O.of_index log2_size ~length:(S max_n)\n , Vector.init (S max_n) ~f:Fn.id )\n in\n let shifts = Pseudo.Domain.shifts log2_sizes ~shifts in\n let generator = Pseudo.Domain.generator log2_sizes ~domain_generator in\n let vanishing_polynomial = vanishing_polynomial mask in\n object\n method log2_size = log2_size\n\n method vanishing_polynomial x = vanishing_polynomial x\n\n method shifts = shifts\n\n method generator = generator\n end\n in\n domain ~max:(Domain.log2_size max_domains.h)\n\n let%test_module \"side loaded domains\" =\n ( module struct\n let run k =\n let y =\n run_and_check (fun () ->\n let y = k () in\n fun () -> As_prover.read_var y )\n |> Or_error.ok_exn\n in\n y\n\n let%test_unit \"side loaded domains\" =\n let open Side_loaded_verification_key in\n let domains = [ { Domains.h = 10 }; { h = 15 } ] in\n let pt = Field.Constant.random () in\n List.iter domains ~f:(fun ds ->\n let d_unchecked =\n Plonk_checks.domain\n (module Field.Constant)\n (Pow_2_roots_of_unity ds.h) ~shifts:Common.tick_shifts\n ~domain_generator:Backend.Tick.Field.domain_generator\n in\n let checked_domain () =\n side_loaded_domain ~log2_size:(Field.of_int ds.h)\n in\n [%test_eq: Field.Constant.t]\n (d_unchecked#vanishing_polynomial pt)\n (run (fun () ->\n (checked_domain ())#vanishing_polynomial (Field.constant pt) )\n ) )\n end )\n\n (* module Split_evaluations = struct\n open Plonk_types\n\n let mask' { Bounded.max; actual } : Boolean.var array =\n let (T max) = Nat.of_int max in\n Vector.to_array (ones_vector (module Impl) ~first_zero:actual max)\n\n let mask (type n) ~(lengths : (int, n) Vector.t)\n (choice : n One_hot_vector.T(Impl).t) : Boolean.var array =\n let max =\n Option.value_exn\n (List.max_elt ~compare:Int.compare (Vector.to_list lengths))\n in\n let actual = Pseudo.choose (choice, lengths) ~f:Field.of_int in\n mask' { max; actual }\n\n let _last =\n Array.reduce_exn ~f:(fun (b_acc, x_acc) (b, x) ->\n (Boolean.(b_acc ||| b), Field.if_ b ~then_:x ~else_:x_acc) )\n\n let pow x bits_lsb =\n with_label \"pow\" (fun () ->\n let rec go acc bs =\n match bs with\n | [] ->\n acc\n | b :: bs ->\n let acc = Field.square acc in\n let acc = Field.if_ b ~then_:Field.(x * acc) ~else_:acc in\n go acc bs\n in\n go Field.one (List.rev bits_lsb) )\n\n let _mod_max_degree =\n let k = Nat.to_int Backend.Tick.Rounds.n in\n fun d ->\n let d =\n Number.of_bits\n (Field.unpack\n ~length:Pickles_base.Side_loaded_verification_key.max_log2_degree\n d )\n in\n Number.mod_pow_2 d (`Two_to_the k)\n\n let _mask_evals (type n) ~(lengths : (int, n) Vector.t Evals.t)\n (choice : n One_hot_vector.T(Impl).t) (e : Field.t array Evals.t) :\n (Boolean.var * Field.t) array Evals.t =\n Evals.map2 lengths e ~f:(fun lengths e ->\n Array.zip_exn (mask ~lengths choice) e )\n end *)\n\n let _absorb_field sponge x = Sponge.absorb sponge (`Field x)\n\n (* pt^{2^n} *)\n let pow2_pow (pt : Field.t) (n : int) : Field.t =\n with_label \"pow2_pow\" (fun () ->\n let rec go acc i =\n if i = 0 then acc else go (Field.square acc) (i - 1)\n in\n go pt n )\n\n let actual_evaluation (e : Field.t array) ~(pt_to_n : Field.t) : Field.t =\n with_label \"actual_evaluation\" (fun () ->\n match List.rev (Array.to_list e) with\n | e :: es ->\n List.fold ~init:e es ~f:(fun acc fx -> Field.(fx + (pt_to_n * acc)))\n | [] ->\n Field.zero )\n\n open Plonk_types\n\n module Opt_sponge = struct\n include Opt_sponge.Make (Impl) (Step_main_inputs.Sponge.Permutation)\n\n let _squeeze_challenge sponge : Field.t =\n lowest_128_bits (squeeze sponge) ~constrain_low_bits:true\n end\n\n let shift1 =\n Shifted_value.Type1.Shift.(\n map ~f:Field.constant (create (module Field.Constant)))\n\n let _shift2 =\n Shifted_value.Type2.Shift.(\n map ~f:Field.constant (create (module Field.Constant)))\n\n let%test_unit \"endo scalar\" =\n SC.test (module Impl) ~endo:Endo.Wrap_inner_curve.scalar\n\n module Plonk = Types.Wrap.Proof_state.Deferred_values.Plonk\n\n module Plonk_checks = struct\n include Plonk_checks\n\n include\n Plonk_checks.Make\n (Shifted_value.Type1)\n (struct\n let constant_term = Plonk_checks.Scalars.Tick.constant_term\n\n let index_terms = Plonk_checks.Scalars.Tick.index_terms\n end)\n end\n\n let domain_for_compiled (type branches)\n (domains : (Domains.t, branches) Vector.t)\n (branch_data : Impl.field Branch_data.Checked.t) :\n Field.t Plonk_checks.plonk_domain =\n let (T unique_domains) =\n List.map (Vector.to_list domains) ~f:Domains.h\n |> List.dedup_and_sort ~compare:(fun d1 d2 ->\n Int.compare (Domain.log2_size d1) (Domain.log2_size d2) )\n |> Vector.of_list\n in\n let which_log2 =\n Vector.map unique_domains ~f:(fun d ->\n Field.equal\n (Field.of_int (Domain.log2_size d))\n branch_data.domain_log2 )\n |> O.of_vector_unsafe\n (* This should be ok... think it through a little more *)\n in\n Pseudo.Domain.to_domain\n (which_log2, unique_domains)\n ~shifts ~domain_generator\n\n (* This finalizes the \"deferred values\" coming from a previous proof over the same field.\n It\n 1. Checks that [xi] and [r] where sampled correctly. I.e., by absorbing all the\n evaluation openings and then squeezing.\n 2. Checks that the \"combined inner product\" value used in the elliptic curve part of\n the opening proof was computed correctly, in terms of the evaluation openings and the\n evaluation points.\n 3. Check that the \"b\" value was computed correctly.\n 4. Perform the arithmetic checks from marlin. *)\n (* TODO: This needs to handle the fact of variable length evaluations.\n Meaning it needs opt sponge. *)\n let finalize_other_proof (type b branches)\n (module Proofs_verified : Nat.Add.Intf with type n = b)\n ~(feature_flags : Plonk_types.Opt.Flag.t Plonk_types.Features.t)\n ~(step_domains :\n [ `Known of (Domains.t, branches) Vector.t | `Side_loaded ] )\n ~(* TODO: Add \"actual proofs verified\" so that proofs don't\n carry around dummy \"old bulletproof challenges\" *)\n sponge ~(prev_challenges : (_, b) Vector.t)\n ({ xi\n ; combined_inner_product\n ; bulletproof_challenges\n ; branch_data\n ; b\n ; plonk\n } :\n ( Field.t\n , _\n , Field.t Shifted_value.Type1.t\n , _\n , _\n , _\n , Field.Constant.t Branch_data.Checked.t\n , _ )\n Types.Wrap.Proof_state.Deferred_values.In_circuit.t )\n { Plonk_types.All_evals.In_circuit.ft_eval1; evals } =\n let actual_width_mask = branch_data.proofs_verified_mask in\n let T = Proofs_verified.eq in\n (* You use the NEW bulletproof challenges to check b. Not the old ones. *)\n let scalar =\n SC.to_field_checked (module Impl) ~endo:Endo.Wrap_inner_curve.scalar\n in\n let plonk =\n Types.Wrap.Proof_state.Deferred_values.Plonk.In_circuit.map_challenges\n ~f:Fn.id ~scalar plonk\n in\n let domain =\n match step_domains with\n | `Known ds ->\n domain_for_compiled ds branch_data\n | `Side_loaded ->\n ( side_loaded_domain ~log2_size:branch_data.domain_log2\n :> _ Plonk_checks.plonk_domain )\n in\n let zetaw = Field.mul domain#generator plonk.zeta in\n let sg_olds =\n with_label \"sg_olds\" (fun () ->\n Vector.map prev_challenges ~f:(fun chals ->\n unstage (challenge_polynomial (Vector.to_array chals)) ) )\n in\n let sg_evals1, sg_evals2 =\n let sg_evals pt =\n Vector.map2\n ~f:(fun keep f -> (keep, f pt))\n (Vector.trim_front actual_width_mask\n (Nat.lte_exn Proofs_verified.n Nat.N2.n) )\n sg_olds\n in\n (sg_evals plonk.zeta, sg_evals zetaw)\n in\n let sponge_state =\n let challenge_digest =\n let opt_sponge = Opt_sponge.create sponge_params in\n Vector.iter2\n (Vector.trim_front actual_width_mask\n (Nat.lte_exn Proofs_verified.n Nat.N2.n) )\n prev_challenges\n ~f:(fun keep chals ->\n Vector.iter chals ~f:(fun chal ->\n Opt_sponge.absorb opt_sponge (keep, chal) ) ) ;\n Opt_sponge.squeeze opt_sponge\n in\n Sponge.absorb sponge (`Field challenge_digest) ;\n Sponge.absorb sponge (`Field ft_eval1) ;\n Sponge.absorb sponge (`Field (fst evals.public_input)) ;\n Sponge.absorb sponge (`Field (snd evals.public_input)) ;\n let xs = Evals.In_circuit.to_absorption_sequence evals.evals in\n (* This is a hacky, but much more efficient, version of the opt sponge.\n This uses the assumption that the sponge 'absorption state' will align\n after each optional absorption, letting us skip the expensive tracking\n that this would otherwise require.\n To future-proof this, we assert that the states are indeed compatible.\n *)\n List.iter xs ~f:(fun opt ->\n let absorb =\n Array.iter ~f:(fun x -> Sponge.absorb sponge (`Field x))\n in\n match opt with\n | None ->\n ()\n | Some (x1, x2) ->\n absorb x1 ; absorb x2\n | Maybe (b, (x1, x2)) ->\n (* Cache the sponge state before *)\n let sponge_state_before = sponge.sponge_state in\n let state_before = Array.copy sponge.state in\n (* Absorb the points *)\n absorb x1 ;\n absorb x2 ;\n (* Check that the sponge ends in a compatible state. *)\n ( match (sponge_state_before, sponge.sponge_state) with\n | Absorbed x, Absorbed y ->\n [%test_eq: int] x y\n | Squeezed x, Squeezed y ->\n [%test_eq: int] x y\n | Absorbed _, Squeezed _ ->\n [%test_eq: string] \"absorbed\" \"squeezed\"\n | Squeezed _, Absorbed _ ->\n [%test_eq: string] \"squeezed\" \"absorbed\" ) ;\n let state =\n Array.map2_exn sponge.state state_before ~f:(fun then_ else_ ->\n Field.if_ b ~then_ ~else_ )\n in\n sponge.state <- state ) ;\n Array.copy sponge.state\n in\n sponge.state <- sponge_state ;\n let squeeze () = squeeze_challenge sponge in\n let xi_actual = squeeze () in\n let r_actual = squeeze () in\n let xi_correct =\n Field.equal xi_actual\n (match xi with { Import.Scalar_challenge.inner = xi } -> xi)\n in\n let xi = scalar xi in\n let r = scalar (Import.Scalar_challenge.create r_actual) in\n let plonk_minimal =\n Plonk.to_minimal plonk ~to_option:Opt.to_option_unsafe\n in\n let combined_evals =\n let n = Int.ceil_log2 Max_degree.step in\n let zeta_n : Field.t = pow2_pow plonk.zeta n in\n let zetaw_n : Field.t = pow2_pow zetaw n in\n Evals.In_circuit.map\n ~f:(fun (x0, x1) ->\n ( actual_evaluation ~pt_to_n:zeta_n x0\n , actual_evaluation ~pt_to_n:zetaw_n x1 ) )\n evals.evals\n in\n let env =\n with_label \"scalars_env\" (fun () ->\n let module Env_bool = struct\n include Boolean\n\n type t = Boolean.var\n end in\n let module Env_field = struct\n include Field\n\n type bool = Env_bool.t\n\n let if_ (b : bool) ~then_ ~else_ =\n match Impl.Field.to_constant (b :> t) with\n | Some x ->\n (* We have a constant, only compute the branch we care about. *)\n if Impl.Field.Constant.(equal one) x then then_ ()\n else else_ ()\n | None ->\n if_ b ~then_:(then_ ()) ~else_:(else_ ())\n end in\n Plonk_checks.scalars_env\n (module Env_bool)\n (module Env_field)\n ~srs_length_log2:Common.Max_degree.step_log2\n ~endo:(Impl.Field.constant Endo.Step_inner_curve.base)\n ~mds:sponge_params.mds\n ~field_of_hex:(fun s ->\n Kimchi_pasta.Pasta.Bigint256.of_hex_string s\n |> Kimchi_pasta.Pasta.Fp.of_bigint |> Field.constant )\n ~domain plonk_minimal combined_evals )\n in\n let open Field in\n let combined_inner_product_correct =\n let evals1, evals2 =\n All_evals.With_public_input.In_circuit.factor evals\n in\n let ft_eval0 : Field.t =\n with_label \"ft_eval0\" (fun () ->\n Plonk_checks.ft_eval0\n (module Field)\n ~env ~domain plonk_minimal combined_evals evals1.public_input )\n in\n print_fp \"ft_eval0\" ft_eval0 ;\n print_fp \"ft_eval1\" ft_eval1 ;\n (* sum_i r^i sum_j xi^j f_j(beta_i) *)\n let actual_combined_inner_product =\n let combine ~ft ~sg_evals x_hat\n (e : (Field.t array, _) Evals.In_circuit.t) =\n let sg_evals =\n sg_evals |> Vector.to_list\n |> List.map ~f:(fun (keep, eval) ->\n [| Plonk_types.Opt.Maybe (keep, eval) |] )\n in\n let a =\n Evals.In_circuit.to_list e\n |> List.map ~f:(function\n | None ->\n [||]\n | Some a ->\n Array.map a ~f:(fun x -> Plonk_types.Opt.Some x)\n | Maybe (b, a) ->\n Array.map a ~f:(fun x -> Plonk_types.Opt.Maybe (b, x)) )\n in\n let v =\n List.append sg_evals ([| Some x_hat |] :: [| Some ft |] :: a)\n in\n Common.combined_evaluation (module Impl) ~xi v\n in\n with_label \"combine\" (fun () ->\n combine ~ft:ft_eval0 ~sg_evals:sg_evals1 evals1.public_input\n evals1.evals\n + r\n * combine ~ft:ft_eval1 ~sg_evals:sg_evals2 evals2.public_input\n evals2.evals )\n in\n let expected =\n Shifted_value.Type1.to_field\n (module Field)\n ~shift:shift1 combined_inner_product\n in\n print_fp \"step_main cip expected\" expected ;\n print_fp \"step_main cip actual\" actual_combined_inner_product ;\n equal expected actual_combined_inner_product\n in\n let bulletproof_challenges =\n compute_challenges ~scalar bulletproof_challenges\n in\n let b_correct =\n with_label \"b_correct\" (fun () ->\n let challenge_poly =\n unstage\n (challenge_polynomial (Vector.to_array bulletproof_challenges))\n in\n let b_actual =\n challenge_poly plonk.zeta + (r * challenge_poly zetaw)\n in\n let b_used =\n Shifted_value.Type1.to_field (module Field) ~shift:shift1 b\n in\n equal b_used b_actual )\n in\n let plonk_checks_passed =\n with_label \"plonk_checks_passed\" (fun () ->\n Plonk_checks.checked\n (module Impl)\n ~env ~shift:shift1 plonk combined_evals )\n in\n print_bool \"xi_correct\" xi_correct ;\n print_bool \"combined_inner_product_correct\" combined_inner_product_correct ;\n print_bool \"plonk_checks_passed\" plonk_checks_passed ;\n print_bool \"b_correct\" b_correct ;\n ( Boolean.all\n [ xi_correct\n ; b_correct\n ; combined_inner_product_correct\n ; plonk_checks_passed\n ]\n , bulletproof_challenges )\n\n let sponge_after_index index =\n let sponge = Sponge.create sponge_params in\n Array.iter\n (Types.index_to_field_elements\n ~g:(fun (z : Inputs.Inner_curve.t) ->\n List.to_array (Inner_curve.to_field_elements z) )\n index )\n ~f:(fun x -> Sponge.absorb sponge (`Field x)) ;\n sponge\n\n let hash_messages_for_next_step_proof (type s) ~index\n (state_to_field_elements : s -> Field.t array) =\n let open Types.Step.Proof_state.Messages_for_next_step_proof in\n let after_index = sponge_after_index index in\n stage (fun (t : _ Types.Step.Proof_state.Messages_for_next_step_proof.t) ->\n let sponge = Sponge.copy after_index in\n Array.iter\n ~f:(fun x -> Sponge.absorb sponge (`Field x))\n (to_field_elements_without_index t ~app_state:state_to_field_elements\n ~g:Inner_curve.to_field_elements ) ;\n Sponge.squeeze_field sponge )\n\n let hash_messages_for_next_step_proof_opt (type s) ~index\n (state_to_field_elements : s -> Field.t array) =\n let open Types.Step.Proof_state.Messages_for_next_step_proof in\n let after_index = sponge_after_index index in\n ( after_index\n , (* TODO: Just get rid of the proofs verified mask and always absorb in full *)\n stage (fun t ~widths:_ ~max_width:_ ~proofs_verified_mask ->\n let sponge = Sponge.copy after_index in\n let t =\n { t with\n old_bulletproof_challenges =\n Vector.map2 proofs_verified_mask t.old_bulletproof_challenges\n ~f:(fun b v -> Vector.map v ~f:(fun x -> `Opt (b, x)))\n ; challenge_polynomial_commitments =\n Vector.map2 proofs_verified_mask\n t.challenge_polynomial_commitments ~f:(fun b g -> (b, g))\n }\n in\n let not_opt x = `Not_opt x in\n let hash_inputs =\n to_field_elements_without_index t\n ~app_state:\n (Fn.compose (Array.map ~f:not_opt) state_to_field_elements)\n ~g:(fun (b, g) ->\n List.map\n ~f:(fun x -> `Opt (b, x))\n (Inner_curve.to_field_elements g) )\n in\n match\n Array.fold hash_inputs ~init:(`Not_opt sponge) ~f:(fun acc t ->\n match (acc, t) with\n | `Not_opt sponge, `Not_opt t ->\n Sponge.absorb sponge (`Field t) ;\n acc\n | `Not_opt sponge, `Opt t ->\n let sponge = Opt_sponge.of_sponge sponge in\n Opt_sponge.absorb sponge t ; `Opt sponge\n | `Opt sponge, `Opt t ->\n Opt_sponge.absorb sponge t ; acc\n | `Opt _, `Not_opt _ ->\n assert false )\n with\n | `Not_opt sponge ->\n (* This means there were no optional inputs. *)\n Sponge.squeeze_field sponge\n | `Opt sponge ->\n Opt_sponge.squeeze sponge ) )\n\n let _accumulation_verifier\n (_accumulator_verification_key : _ Types_map.For_step.t)\n _prev_accumulators _proof _new_accumulator : Boolean.var =\n Boolean.false_\n\n let verify ~proofs_verified ~is_base_case ~sg_old ~sponge_after_index\n ~lookup_parameters ~feature_flags ~(proof : Wrap_proof.Checked.t) ~srs\n ~wrap_domain ~wrap_verification_key statement\n (unfinalized :\n ( _\n , _\n , _ Shifted_value.Type2.t\n , _\n , _\n , _ )\n Types.Step.Proof_state.Per_proof.In_circuit.t ) =\n let public_input :\n [ `Field of Field.t | `Packed_bits of Field.t * int ] array =\n with_label \"pack_statement\" (fun () ->\n Spec.pack\n (module Impl)\n (Types.Wrap.Statement.In_circuit.spec\n (module Impl)\n lookup_parameters feature_flags )\n (Types.Wrap.Statement.In_circuit.to_data\n ~option_map:Plonk_types.Opt.map statement\n ~to_opt:Plonk_types.Opt.to_option_unsafe ) )\n |> Array.map ~f:(function\n | `Field (Shifted_value.Type1.Shifted_value x) ->\n `Field x\n | `Packed_bits (x, n) ->\n `Packed_bits (x, n) )\n in\n let sponge = Sponge.create sponge_params in\n let { Types.Step.Proof_state.Deferred_values.xi\n ; combined_inner_product\n ; b\n ; _\n } =\n unfinalized.deferred_values\n in\n let ( sponge_digest_before_evaluations_actual\n , (`Success bulletproof_success, bulletproof_challenges_actual) ) =\n incrementally_verify_proof ~srs proofs_verified ~srs ~domain:wrap_domain\n ~xi ~verification_key:wrap_verification_key ~sponge ~sponge_after_index\n ~public_input ~sg_old\n ~advice:{ b; combined_inner_product }\n ~proof\n ~plonk:\n (Composition_types.Step.Proof_state.Deferred_values.Plonk.In_circuit\n .to_wrap ~opt_none:Opt.None ~false_:Boolean.false_\n unfinalized.deferred_values.plonk )\n in\n with_label __LOC__ (fun () ->\n with_label __LOC__ (fun () ->\n Field.Assert.equal unfinalized.sponge_digest_before_evaluations\n sponge_digest_before_evaluations_actual ) ;\n Array.iteri\n (Vector.to_array unfinalized.deferred_values.bulletproof_challenges)\n ~f:(fun i c1 ->\n let c2 = bulletproof_challenges_actual.(i) in\n let { Import.Scalar_challenge.inner = c1 } =\n Bulletproof_challenge.pack c1\n in\n let c2 =\n Field.if_ is_base_case ~then_:c1\n ~else_:(match c2.prechallenge with { inner = c2 } -> c2)\n in\n with_label (sprintf \"%s:%d\" __LOC__ i) (fun () ->\n Field.Assert.equal c1 c2 ) ) ) ;\n bulletproof_success\nend\n\ninclude Make (Step_main_inputs)\n","open Core_kernel\n\nmodule Step = struct\n module Key = struct\n module Proving = struct\n type t =\n Type_equal.Id.Uid.t\n * Snark_keys_header.t\n * int\n * Backend.Tick.R1CS_constraint_system.t\n\n let to_string : t -> _ = function\n | _id, header, n, _h ->\n sprintf !\"step-%s-%s-%d-%s\" header.kind.type_ header.kind.identifier\n n header.identifying_hash\n end\n\n module Verification = struct\n type t = Type_equal.Id.Uid.t * Snark_keys_header.t * int * Md5.t\n [@@deriving sexp]\n\n let to_string : t -> _ = function\n | _id, header, n, _h ->\n sprintf !\"vk-step-%s-%s-%d-%s\" header.kind.type_\n header.kind.identifier n header.identifying_hash\n end\n [@@warning \"-4\"]\n end\n\n let storable =\n Key_cache.Sync.Disk_storable.simple Key.Proving.to_string\n (fun (_, header, _, cs) ~path ->\n Or_error.try_with_join (fun () ->\n let open Or_error.Let_syntax in\n let%map header_read, index =\n Snark_keys_header.read_with_header\n ~read_data:(fun ~offset ->\n Kimchi_bindings.Protocol.Index.Fp.read (Some offset)\n (Backend.Tick.Keypair.load_urs ()) )\n path\n in\n [%test_eq: int] header.header_version header_read.header_version ;\n [%test_eq: Snark_keys_header.Kind.t] header.kind header_read.kind ;\n [%test_eq: Snark_keys_header.Constraint_constants.t]\n header.constraint_constants header_read.constraint_constants ;\n [%test_eq: string] header.constraint_system_hash\n header_read.constraint_system_hash ;\n { Backend.Tick.Keypair.index; cs } ) )\n (fun (_, header, _, _) t path ->\n Or_error.try_with (fun () ->\n Snark_keys_header.write_with_header\n ~expected_max_size_log2:33 (* 8 GB should be enough *)\n ~append_data:\n (Kimchi_bindings.Protocol.Index.Fp.write (Some true)\n t.Backend.Tick.Keypair.index )\n header path ) )\n\n let vk_storable =\n Key_cache.Sync.Disk_storable.simple Key.Verification.to_string\n (fun (_, header, _, _) ~path ->\n Or_error.try_with_join (fun () ->\n let open Or_error.Let_syntax in\n let%map header_read, index =\n Snark_keys_header.read_with_header\n ~read_data:(fun ~offset path ->\n Kimchi_bindings.Protocol.VerifierIndex.Fp.read (Some offset)\n (Backend.Tick.Keypair.load_urs ())\n path )\n path\n in\n [%test_eq: int] header.header_version header_read.header_version ;\n [%test_eq: Snark_keys_header.Kind.t] header.kind header_read.kind ;\n [%test_eq: Snark_keys_header.Constraint_constants.t]\n header.constraint_constants header_read.constraint_constants ;\n [%test_eq: string] header.constraint_system_hash\n header_read.constraint_system_hash ;\n index ) )\n (fun (_, header, _, _) x path ->\n Or_error.try_with (fun () ->\n Snark_keys_header.write_with_header\n ~expected_max_size_log2:33 (* 8 GB should be enough *)\n ~append_data:\n (Kimchi_bindings.Protocol.VerifierIndex.Fp.write (Some true) x)\n header path ) )\n\n let read_or_generate ~prev_challenges cache k_p k_v typ return_typ main =\n let s_p = storable in\n let s_v = vk_storable in\n let open Impls.Step in\n let pk =\n lazy\n ( match\n Common.time \"step keypair read\" (fun () ->\n Key_cache.Sync.read cache s_p (Lazy.force k_p) )\n with\n | Ok (pk, dirty) ->\n Common.time \"step keypair create\" (fun () ->\n (Keypair.create ~pk ~vk:(Backend.Tick.Keypair.vk pk), dirty) )\n | Error _e ->\n let r =\n Common.time \"stepkeygen\" (fun () ->\n constraint_system ~input_typ:typ ~return_typ main\n |> Keypair.generate ~prev_challenges )\n in\n Timer.clock __LOC__ ;\n ignore\n ( Key_cache.Sync.write cache s_p (Lazy.force k_p) (Keypair.pk r)\n : unit Or_error.t ) ;\n (r, `Generated_something) )\n in\n let vk =\n lazy\n (let k_v = Lazy.force k_v in\n match\n Common.time \"step vk read\" (fun () ->\n Key_cache.Sync.read cache s_v k_v )\n with\n | Ok (vk, _) ->\n (vk, `Cache_hit)\n | Error _e ->\n let pk, c = Lazy.force pk in\n let vk = Keypair.vk pk in\n ignore (Key_cache.Sync.write cache s_v k_v vk : unit Or_error.t) ;\n (vk, c) )\n in\n (pk, vk)\nend\n\nmodule Wrap = struct\n module Key = struct\n module Verification = struct\n type t = Type_equal.Id.Uid.t * Snark_keys_header.t * Md5.t\n [@@deriving sexp]\n\n let equal ((_, x1, y1) : t) ((_, x2, y2) : t) =\n [%equal: unit * Md5.t] ((* TODO: *) ignore x1, y1) (ignore x2, y2)\n\n let to_string : t -> _ = function\n | _id, header, _h ->\n sprintf !\"vk-wrap-%s-%s-%s\" header.kind.type_ header.kind.identifier\n header.identifying_hash\n end\n [@@warning \"-4\"]\n\n module Proving = struct\n type t =\n Type_equal.Id.Uid.t\n * Snark_keys_header.t\n * Backend.Tock.R1CS_constraint_system.t\n\n let to_string : t -> _ = function\n | _id, header, _h ->\n sprintf !\"wrap-%s-%s-%s\" header.kind.type_ header.kind.identifier\n header.identifying_hash\n end\n end\n\n let storable =\n Key_cache.Sync.Disk_storable.simple Key.Proving.to_string\n (fun (_, header, cs) ~path ->\n Or_error.try_with_join (fun () ->\n let open Or_error.Let_syntax in\n let%map header_read, index =\n Snark_keys_header.read_with_header\n ~read_data:(fun ~offset ->\n Kimchi_bindings.Protocol.Index.Fq.read (Some offset)\n (Backend.Tock.Keypair.load_urs ()) )\n path\n in\n [%test_eq: int] header.header_version header_read.header_version ;\n [%test_eq: Snark_keys_header.Kind.t] header.kind header_read.kind ;\n [%test_eq: Snark_keys_header.Constraint_constants.t]\n header.constraint_constants header_read.constraint_constants ;\n [%test_eq: string] header.constraint_system_hash\n header_read.constraint_system_hash ;\n { Backend.Tock.Keypair.index; cs } ) )\n (fun (_, header, _) t path ->\n Or_error.try_with (fun () ->\n Snark_keys_header.write_with_header\n ~expected_max_size_log2:33 (* 8 GB should be enough *)\n ~append_data:\n (Kimchi_bindings.Protocol.Index.Fq.write (Some true) t.index)\n header path ) )\n\n let read_or_generate ~prev_challenges cache k_p k_v typ return_typ main =\n let module Vk = Verification_key in\n let open Impls.Wrap in\n let s_p = storable in\n let pk =\n lazy\n (let k = Lazy.force k_p in\n match\n Common.time \"wrap key read\" (fun () ->\n Key_cache.Sync.read cache s_p k )\n with\n | Ok (pk, d) ->\n (Keypair.create ~pk ~vk:(Backend.Tock.Keypair.vk pk), d)\n | Error _e ->\n let r =\n Common.time \"wrapkeygen\" (fun () ->\n constraint_system ~input_typ:typ ~return_typ main\n |> Keypair.generate ~prev_challenges )\n in\n ignore\n ( Key_cache.Sync.write cache s_p k (Keypair.pk r)\n : unit Or_error.t ) ;\n (r, `Generated_something) )\n in\n let vk =\n lazy\n (let k_v = Lazy.force k_v in\n let s_v =\n Key_cache.Sync.Disk_storable.simple Key.Verification.to_string\n (fun (_, header, _cs) ~path ->\n Or_error.try_with_join (fun () ->\n let open Or_error.Let_syntax in\n let%map header_read, index =\n Snark_keys_header.read_with_header\n ~read_data:(fun ~offset:_ path ->\n Binable.of_string\n (module Vk.Stable.Latest)\n (In_channel.read_all path) )\n path\n in\n [%test_eq: int] header.header_version\n header_read.header_version ;\n [%test_eq: Snark_keys_header.Kind.t] header.kind\n header_read.kind ;\n [%test_eq: Snark_keys_header.Constraint_constants.t]\n header.constraint_constants\n header_read.constraint_constants ;\n [%test_eq: string] header.constraint_system_hash\n header_read.constraint_system_hash ;\n index ) )\n (fun (_, header, _) t path ->\n Or_error.try_with (fun () ->\n Snark_keys_header.write_with_header\n ~expected_max_size_log2:33 (* 8 GB should be enough *)\n ~append_data:(fun path ->\n Out_channel.with_file ~append:true path ~f:(fun file ->\n Out_channel.output_string file\n (Binable.to_string (module Vk.Stable.Latest) t) )\n )\n header path ) )\n in\n match Key_cache.Sync.read cache s_v k_v with\n | Ok (vk, d) ->\n (vk, d)\n | Error _e ->\n let kp, _dirty = Lazy.force pk in\n let vk = Keypair.vk kp in\n let pk = Keypair.pk kp in\n let vk : Vk.t =\n { index = vk\n ; commitments =\n Kimchi_pasta.Pallas_based_plonk.Keypair.vk_commitments vk\n ; data =\n (let open Kimchi_bindings.Protocol.Index.Fq in\n { constraints = domain_d1_size pk.index })\n }\n in\n ignore (Key_cache.Sync.write cache s_v k_v vk : unit Or_error.t) ;\n let _vk = Key_cache.Sync.read cache s_v k_v in\n (vk, `Generated_something) )\n in\n (pk, vk)\nend\n","open Core_kernel\nopen Bitstring_lib\nopen Snark_bits\n\nmodule Make_snarkable (Impl : Snarky_backendless.Snark_intf.S) = struct\n open Impl\n\n module type S = sig\n type var\n\n type value\n\n val typ : (var, value) Typ.t\n end\n\n module Bits = struct\n module type Lossy =\n Bits_intf.Snarkable.Lossy\n with type ('a, 'b) typ := ('a, 'b) Typ.t\n and type 'a checked := 'a Checked.t\n and type boolean_var := Boolean.var\n\n module type Faithful =\n Bits_intf.Snarkable.Faithful\n with type ('a, 'b) typ := ('a, 'b) Typ.t\n and type 'a checked := 'a Checked.t\n and type boolean_var := Boolean.var\n\n module type Small =\n Bits_intf.Snarkable.Small\n with type ('a, 'b) typ := ('a, 'b) Typ.t\n and type 'a checked := 'a Checked.t\n and type boolean_var := Boolean.var\n and type comparison_result := Field.Checked.comparison_result\n and type field_var := Field.Var.t\n end\nend\n\nmodule Tock0 = struct\n include Crypto_params.Tock\n module Snarkable = Make_snarkable (Crypto_params.Tock)\nend\n\nmodule Tick0 = struct\n include Crypto_params.Tick\n module Snarkable = Make_snarkable (Crypto_params.Tick)\nend\n\nlet%test_unit \"group-map test\" =\n let params = Crypto_params.Tock.group_map_params () in\n let module M = Crypto_params.Tick.Run in\n Quickcheck.test ~trials:3 Tick0.Field.gen ~f:(fun t ->\n let checked_output =\n M.run_and_check (fun () ->\n let x, y =\n Snarky_group_map.Checked.to_group\n (module M)\n ~params (M.Field.constant t)\n in\n fun () -> M.As_prover.(read_var x, read_var y) )\n |> Or_error.ok_exn\n in\n let ((x, y) as actual) =\n Group_map.to_group (module Tick0.Field) ~params t\n in\n [%test_eq: Tick0.Field.t]\n Tick0.Field.(\n (x * x * x)\n + (Tick0.Inner_curve.Params.a * x)\n + Tick0.Inner_curve.Params.b)\n Tick0.Field.(y * y) ;\n [%test_eq: Tick0.Field.t * Tick0.Field.t] checked_output actual )\n\nmodule Make_inner_curve_scalar (Impl : Snark_intf.S) (Other_impl : Snark_intf.S) =\nstruct\n module T = Other_impl.Field\n\n include (\n T :\n module type of T with module Var := T.Var and module Checked := T.Checked )\n\n let of_bits = Other_impl.Field.project\n\n let length_in_bits = size_in_bits\n\n open Impl\n\n type var = Boolean.var Bitstring.Lsb_first.t\n\n let typ : (var, t) Typ.t =\n Typ.transport_var\n (Typ.transport\n (Typ.list ~length:size_in_bits Boolean.typ)\n ~there:unpack ~back:project )\n ~there:Bitstring.Lsb_first.to_list ~back:Bitstring.Lsb_first.of_list\n\n let gen : t Quickcheck.Generator.t =\n Quickcheck.Generator.map\n (Bignum_bigint.gen_incl Bignum_bigint.one\n Bignum_bigint.(Other_impl.Field.size - one) )\n ~f:(fun x -> Other_impl.Bigint.(to_field (of_bignum_bigint x)))\n\n let test_bit x i = Other_impl.Bigint.(test_bit (of_field x) i)\n\n module Checked = struct\n let equal a b =\n Bitstring_checked.equal\n (Bitstring.Lsb_first.to_list a)\n (Bitstring.Lsb_first.to_list b)\n\n let to_bits = Fn.id\n\n module Assert = struct\n let equal : var -> var -> unit Checked.t =\n fun a b ->\n Bitstring_checked.Assert.equal\n (Bitstring.Lsb_first.to_list a)\n (Bitstring.Lsb_first.to_list b)\n end\n end\nend\n\nmodule Make_inner_curve_aux (Impl : Snark_intf.S) (Other_impl : Snark_intf.S) =\nstruct\n open Impl\n\n type var = Field.Var.t * Field.Var.t\n\n module Scalar = Make_inner_curve_scalar (Impl) (Other_impl)\nend\n\nmodule Tock = struct\n include (\n Tock0 : module type of Tock0 with module Inner_curve := Tock0.Inner_curve )\n\n module Fq = Snarky_field_extensions.Field_extensions.F (Tock0)\n\n module Inner_curve = struct\n include Tock0.Inner_curve\n\n include\n Sexpable.Of_sexpable\n (struct\n type t = Field.t * Field.t [@@deriving sexp]\n end)\n (struct\n type nonrec t = t\n\n let to_sexpable = to_affine_exn\n\n let of_sexpable = of_affine\n end)\n\n include Make_inner_curve_aux (Tock0) (Tick0)\n\n module Checked = struct\n include\n Snarky_curves.Make_weierstrass_checked (Fq) (Scalar)\n (struct\n include Tock0.Inner_curve\n end)\n (Params)\n (struct\n let add = None\n end)\n\n let add_known_unsafe t x = add_unsafe t (constant x)\n end\n\n let typ = Checked.typ\n end\nend\n\nmodule Tick = struct\n include (\n Tick0 :\n module type of Tick0\n with module Field := Tick0.Field\n and module Inner_curve := Tick0.Inner_curve )\n\n module Field = struct\n include Hashable.Make (Tick0.Field)\n include Tick0.Field\n module Bits = Bits.Make_field (Tick0.Field) (Tick0.Bigint)\n\n let size_in_triples = Int.((size_in_bits + 2) / 3)\n end\n\n module Fq = Snarky_field_extensions.Field_extensions.F (Tick0)\n\n module Inner_curve = struct\n include Crypto_params.Tick.Inner_curve\n\n include\n Sexpable.Of_sexpable\n (struct\n type t = Field.t * Field.t [@@deriving sexp]\n end)\n (struct\n type nonrec t = t\n\n let to_sexpable = to_affine_exn\n\n let of_sexpable = of_affine\n end)\n\n include Make_inner_curve_aux (Tick0) (Tock0)\n\n module Checked = struct\n include\n Snarky_curves.Make_weierstrass_checked (Fq) (Scalar)\n (Crypto_params.Tick.Inner_curve)\n (Params)\n (struct\n let add =\n Some\n (fun p1 p2 ->\n Run.make_checked (fun () ->\n Pickles.Step_main_inputs.Ops.add_fast p1 p2 ) )\n end)\n\n let add_known_unsafe t x = add_unsafe t (constant x)\n end\n\n let typ = Checked.typ\n end\n\n module Util = Snark_util.Make (Tick0)\n\n let m : Run.field Snarky_backendless.Snark.m = (module Run)\n\n let make_checked c = Run.make_checked c\nend\n\n(* Let n = Tick.Field.size_in_bits.\n Let k = n - 3.\n The reason k = n - 3 is as follows. Inside [meets_target], we compare\n a value against 2^k. 2^k requires k + 1 bits. The comparison then unpacks\n a (k + 1) + 1 bit number. This number cannot overflow so it is important that\n k + 1 + 1 < n. Thus k < n - 2.\n\n However, instead of using `Field.size_in_bits - 3` we choose `Field.size_in_bits - 8`\n to clamp the easiness. To something not-to-quick on a personal laptop from mid 2010s.\n*)\nlet target_bit_length = Tick.Field.size_in_bits - 8\n\nmodule type Snark_intf = Snark_intf.S\n\nmodule Group_map = struct\n let to_group x =\n Group_map.to_group (module Tick.Field) ~params:(Tock.group_map_params ()) x\n\n module Checked = struct\n let to_group x =\n Snarky_group_map.Checked.to_group\n (module Tick.Run)\n ~params:(Tock.group_map_params ()) x\n end\nend\n","open Core_kernel\nmodule Inputs = Pickles.Tick_field_sponge.Inputs\nmodule Ocaml_permutation = Sponge.Poseidon (Inputs)\nmodule Field = Kimchi_backend.Pasta.Basic.Fp\n\nlet add_assign = Ocaml_permutation.add_assign\n\nlet copy = Ocaml_permutation.copy\n\nlet params = Kimchi_pasta_fp_poseidon.create ()\n\nlet block_cipher _params (s : Field.t array) =\n let v = Kimchi_bindings.FieldVectors.Fp.create () in\n Array.iter s ~f:(Kimchi_bindings.FieldVectors.Fp.emplace_back v) ;\n Kimchi_pasta_fp_poseidon.block_cipher params v ;\n Array.init (Array.length s) ~f:(Kimchi_bindings.FieldVectors.Fp.get v)\n\nlet%test_unit \"check rust implementation of block-cipher\" =\n let params' : Field.t Sponge.Params.t =\n Sponge.Params.(map pasta_p_kimchi ~f:Field.of_string)\n in\n let open Pickles.Impls.Step in\n let module T = Internal_Basic in\n Quickcheck.test (Quickcheck.Generator.list_with_length 3 T.Field.gen)\n ~f:(fun s ->\n let s () = Array.of_list s in\n [%test_eq: T.Field.t array]\n (Ocaml_permutation.block_cipher params' (s ()))\n (block_cipher params' (s ())) )\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\n\n[%%ifdef consensus_mechanism]\n\nopen Pickles.Impls.Step.Internal_Basic\n\n[%%else]\n\nopen Snark_params.Tick\n\n[%%endif]\n\nmodule State = struct\n include Array\n\n let map2 = map2_exn\nend\n\nmodule Input = Random_oracle_input\n\nlet params : Field.t Sponge.Params.t =\n Sponge.Params.(map pasta_p_kimchi ~f:Field.of_string)\n\nmodule Operations = struct\n let add_assign ~state i x = Field.(state.(i) <- state.(i) + x)\n\n let apply_affine_map (matrix, constants) v =\n let dotv row =\n Array.reduce_exn (Array.map2_exn row v ~f:Field.( * )) ~f:Field.( + )\n in\n let res = Array.map matrix ~f:dotv in\n Array.map2_exn res constants ~f:Field.( + )\n\n let copy a = Array.map a ~f:Fn.id\nend\n\nmodule Digest = struct\n type t = Field.t\n\n let to_bits ?length x =\n match length with\n | None ->\n Field.unpack x\n | Some length ->\n List.take (Field.unpack x) length\nend\n\ninclude Sponge.Make_hash (Random_oracle_permutation)\n\nlet update ~state = update ~state params\n\nlet hash ?init = hash ?init params\n\nlet pow2 =\n let rec pow2 acc n = if n = 0 then acc else pow2 Field.(acc + acc) (n - 1) in\n Memo.general ~hashable:Int.hashable (fun n -> pow2 Field.one n)\n\n[%%ifdef consensus_mechanism]\n\nmodule Checked = struct\n module Inputs = Pickles.Step_main_inputs.Sponge.Permutation\n\n module Digest = struct\n open Pickles.Impls.Step.Field\n\n type nonrec t = t\n\n let to_bits ?(length = Field.size_in_bits) (x : t) =\n List.take (choose_preimage_var ~length:Field.size_in_bits x) length\n end\n\n include Sponge.Make_hash (Inputs)\n\n let params = Sponge.Params.map ~f:Inputs.Field.constant params\n\n open Inputs.Field\n\n let update ~state xs = update params ~state xs\n\n let hash ?init xs =\n hash ?init:(Option.map init ~f:(State.map ~f:constant)) params xs\n\n let pack_input =\n Input.Chunked.pack_to_fields\n ~pow2:(Fn.compose Field.Var.constant pow2)\n (module Pickles.Impls.Step.Field)\n\n let digest xs = xs.(0)\nend\n\nlet read_typ ({ field_elements; packeds } : _ Input.Chunked.t) =\n let open Pickles.Impls.Step in\n let open As_prover in\n { Input.Chunked.field_elements = Array.map ~f:(read Field.typ) field_elements\n ; packeds = Array.map packeds ~f:(fun (x, i) -> (read Field.typ x, i))\n }\n\nlet read_typ' input : _ Pickles.Impls.Step.Internal_Basic.As_prover.t =\n fun _ -> read_typ input\n\n[%%endif]\n\nlet pack_input = Input.Chunked.pack_to_fields ~pow2 (module Field)\n\nlet prefix_to_field (s : string) =\n let bits_per_character = 8 in\n assert (bits_per_character * String.length s < Field.size_in_bits) ;\n Field.project Fold_lib.Fold.(to_list (string_bits (s :> string)))\n\nlet salt (s : string) = update ~state:initial_state [| prefix_to_field s |]\n\nlet%test_unit \"iterativeness\" =\n let x1 = Field.random () in\n let x2 = Field.random () in\n let x3 = Field.random () in\n let x4 = Field.random () in\n let s_full = update ~state:initial_state [| x1; x2; x3; x4 |] in\n let s_it =\n update ~state:(update ~state:initial_state [| x1; x2 |]) [| x3; x4 |]\n in\n [%test_eq: Field.t array] s_full s_it\n\n[%%ifdef consensus_mechanism]\n\nlet%test_unit \"sponge checked-unchecked\" =\n let open Pickles.Impls.Step in\n let module T = Internal_Basic in\n let x = T.Field.random () in\n let y = T.Field.random () in\n T.Test.test_equal ~equal:T.Field.equal ~sexp_of_t:T.Field.sexp_of_t\n T.Typ.(field * field)\n T.Typ.field\n (fun (x, y) -> make_checked (fun () -> Checked.hash [| x; y |]))\n (fun (x, y) -> hash [| x; y |])\n (x, y)\n\n[%%endif]\n\nmodule Legacy = struct\n module Input = Random_oracle_input.Legacy\n module State = State\n\n let params : Field.t Sponge.Params.t =\n Sponge.Params.(map pasta_p_legacy ~f:Field.of_string)\n\n module Rounds = struct\n let rounds_full = 63\n\n let initial_ark = true\n\n let rounds_partial = 0\n end\n\n module Inputs = struct\n module Field = Field\n include Rounds\n\n let alpha = 5\n\n (* Computes x^5 *)\n let to_the_alpha x =\n let open Field in\n let res = x in\n let res = res * res in\n (* x^2 *)\n let res = res * res in\n (* x^4 *)\n res * x\n\n module Operations = Operations\n end\n\n include Sponge.Make_hash (Sponge.Poseidon (Inputs))\n\n let hash ?init = hash ?init params\n\n let update ~state = update ~state params\n\n let salt (s : string) = update ~state:initial_state [| prefix_to_field s |]\n\n let pack_input =\n Input.pack_to_fields ~size_in_bits:Field.size_in_bits ~pack:Field.project\n\n module Digest = Digest\n\n [%%ifdef consensus_mechanism]\n\n module Checked = struct\n let pack_input =\n Input.pack_to_fields ~size_in_bits:Field.size_in_bits ~pack:Field.Var.pack\n\n module Digest = Checked.Digest\n\n module Inputs = struct\n include Rounds\n module Impl = Pickles.Impls.Step\n open Impl\n module Field = Field\n\n let alpha = 5\n\n (* Computes x^5 *)\n let to_the_alpha x =\n let open Field in\n let res = x in\n let res = res * res in\n (* x^2 *)\n let res = res * res in\n (* x^4 *)\n res * x\n\n module Operations = struct\n open Field\n\n let seal = Pickles.Util.seal (module Impl)\n\n let add_assign ~state i x = state.(i) <- seal (state.(i) + x)\n\n let apply_affine_map (matrix, constants) v =\n let dotv row =\n Array.reduce_exn (Array.map2_exn row v ~f:( * )) ~f:( + )\n in\n let res = Array.map matrix ~f:dotv in\n Array.map2_exn res constants ~f:(fun x c -> seal (x + c))\n\n let copy a = Array.map a ~f:Fn.id\n end\n end\n\n include Sponge.Make_hash (Sponge.Poseidon (Inputs))\n\n let params = Sponge.Params.map ~f:Inputs.Field.constant params\n\n open Inputs.Field\n\n let update ~state xs = update params ~state xs\n\n let hash ?init xs =\n hash ?init:(Option.map init ~f:(State.map ~f:constant)) params xs\n end\n\n [%%endif]\nend\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Snark_params.Tick\n\n[%%ifdef consensus_mechanism]\n\nlet parity y = Bigint.(test_bit (of_field y) 0)\n\n[%%else]\n\nlet parity y = Field.parity y\n\n[%%endif]\n\nlet gen_uncompressed =\n Quickcheck.Generator.filter_map Field.gen_uniform ~f:(fun x ->\n let open Option.Let_syntax in\n let%map y = Inner_curve.find_y x in\n (x, y) )\n\nmodule Compressed = struct\n open Compressed_poly\n\n module Arg = struct\n (* module with same type t as Stable below, to build functor argument *)\n [%%versioned\n module Stable = struct\n module V1 = struct\n [@@@with_all_version_tags]\n\n type t = ((Field.t[@version_asserted]), bool) Poly.Stable.V1.t\n\n let to_latest = Fn.id\n end\n end]\n end\n\n let compress (x, y) = { Poly.x; is_odd = parity y }\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n [@@@with_all_version_tags]\n\n module T = struct\n type t = ((Field.t[@version_asserted]), bool) Poly.Stable.V1.t\n [@@deriving equal, compare, hash]\n\n let to_latest = Fn.id\n\n module M = struct\n (* for compatibility with legacy Base58Check serialization *)\n include Arg.Stable.V1.With_all_version_tags\n\n let description = \"Non zero curve point compressed\"\n\n let version_byte =\n Base58_check.Version_bytes.non_zero_curve_point_compressed\n end\n\n module Base58 = Codable.Make_base58_check (M)\n include Base58\n\n (* sexp representation is a Base58Check string, like the yojson representation *)\n let sexp_of_t t = to_base58_check t |> Sexp.of_string\n\n let t_of_sexp sexp = Sexp.to_string sexp |> of_base58_check_exn\n end\n\n include T\n include Hashable.Make_binable (T)\n\n let gen =\n let open Quickcheck.Generator.Let_syntax in\n let%map uncompressed = gen_uncompressed in\n compress uncompressed\n end\n end]\n\n module Poly = Poly\n include Comparable.Make_binable (Stable.Latest)\n include Hashable.Make_binable (Stable.Latest)\n include Stable.Latest.Base58\n\n let to_string = to_base58_check\n\n [%%define_locally Stable.Latest.(sexp_of_t, t_of_sexp, gen)]\n\n let compress (x, y) = { Poly.x; is_odd = parity y }\n\n let empty = Poly.{ x = Field.zero; is_odd = false }\n\n let to_input { Poly.x; is_odd } =\n { Random_oracle.Input.Chunked.field_elements = [| x |]\n ; packeds = [| (Field.project [ is_odd ], 1) |]\n }\n\n let to_input_legacy { Poly.x; is_odd } =\n { Random_oracle.Input.Legacy.field_elements = [| x |]\n ; bitstrings = [| [ is_odd ] |]\n }\n\n [%%ifdef consensus_mechanism]\n\n (* snarky-dependent *)\n\n type var = (Field.Var.t, Boolean.var) Poly.t\n\n let typ : (var, t) Typ.t =\n Typ.of_hlistable [ Field.typ; Boolean.typ ] ~var_to_hlist:Poly.to_hlist\n ~var_of_hlist:Poly.of_hlist ~value_to_hlist:Poly.to_hlist\n ~value_of_hlist:Poly.of_hlist\n\n let var_of_t ({ x; is_odd } : t) : var =\n { x = Field.Var.constant x; is_odd = Boolean.var_of_value is_odd }\n\n let assert_equal (t1 : var) (t2 : var) =\n let%map () = Field.Checked.Assert.equal t1.x t2.x\n and () = Boolean.Assert.(t1.is_odd = t2.is_odd) in\n ()\n\n module Checked = struct\n let equal t1 t2 =\n let%bind x_eq = Field.Checked.equal t1.Poly.x t2.Poly.x in\n let%bind odd_eq = Boolean.equal t1.is_odd t2.is_odd in\n Boolean.(x_eq && odd_eq)\n\n let to_input ({ x; is_odd } : var) =\n { Random_oracle.Input.Chunked.field_elements = [| x |]\n ; packeds = [| ((is_odd :> Field.Var.t), 1) |]\n }\n\n let to_input_legacy = to_input_legacy\n\n let if_ cond ~then_:t1 ~else_:t2 =\n let%map x = Field.Checked.if_ cond ~then_:t1.Poly.x ~else_:t2.Poly.x\n and is_odd = Boolean.if_ cond ~then_:t1.is_odd ~else_:t2.is_odd in\n Poly.{ x; is_odd }\n\n module Assert = struct\n let equal t1 t2 =\n let%map () = Field.Checked.Assert.equal t1.Poly.x t2.Poly.x\n and () = Boolean.Assert.(t1.is_odd = t2.is_odd) in\n ()\n end\n end\n\n (* end snarky-dependent *)\n [%%endif]\nend\n\nmodule Uncompressed = struct\n let decompress ({ x; is_odd } : Compressed.t) =\n Option.map (Inner_curve.find_y x) ~f:(fun y ->\n let y_parity = parity y in\n let y = if Bool.(is_odd = y_parity) then y else Field.negate y in\n (x, y) )\n\n let decompress_exn t =\n match decompress t with\n | Some d ->\n d\n | None ->\n failwith\n (sprintf \"Compressed public key %s could not be decompressed\"\n (Yojson.Safe.to_string @@ Compressed.to_yojson t) )\n\n let of_base58_check_decompress_exn pk_str =\n let pk = Compressed.of_base58_check_exn pk_str in\n decompress_exn pk |> ignore ;\n pk\n\n let compress = Compressed.compress\n\n [%%versioned_binable\n module Stable = struct\n module V1 = struct\n [@@@with_all_version_tags]\n\n type t = Field.t * Field.t [@@deriving compare, equal, hash]\n\n let to_latest = Fn.id\n\n include\n Binable.Of_binable_without_uuid\n (Compressed.Stable.V1)\n (struct\n type nonrec t = t\n\n let of_binable = decompress_exn\n\n let to_binable = compress\n end)\n\n let gen : t Quickcheck.Generator.t = gen_uncompressed\n\n let of_bigstring bs =\n let open Or_error.Let_syntax in\n let%map elem, _ = Bigstring.read_bin_prot bs bin_reader_t in\n elem\n\n let to_bigstring elem =\n let bs =\n Bigstring.create (bin_size_t elem + Bin_prot.Utils.size_header_length)\n in\n let _ = Bigstring.write_bin_prot bs bin_writer_t elem in\n bs\n\n (* We reuse the Base58check-based yojson (de)serialization from the\n compressed representation. *)\n\n let of_yojson json =\n let open Result in\n Compressed.of_yojson json\n >>= fun compressed ->\n Result.of_option ~error:\"couldn't decompress, curve point invalid\"\n (decompress compressed)\n\n let to_yojson t = Compressed.to_yojson @@ compress t\n\n (* as for yojson, use the Base58check-based sexps from the compressed representation *)\n let sexp_of_t t = Compressed.sexp_of_t @@ compress t\n\n let t_of_sexp sexp =\n Option.value_exn (decompress @@ Compressed.t_of_sexp sexp)\n end\n end]\n\n (* so we can make sets of public keys *)\n include Comparable.Make_binable (Stable.Latest)\n\n [%%define_locally\n Stable.Latest.\n (of_bigstring, to_bigstring, sexp_of_t, t_of_sexp, to_yojson, of_yojson)]\n\n let gen : t Quickcheck.Generator.t = gen_uncompressed\n\n let ( = ) = equal\n\n let of_inner_curve_exn = Inner_curve.to_affine_exn\n\n let to_inner_curve = Inner_curve.of_affine\n\n let%test_unit \"point-compression: decompress . compress = id\" =\n Quickcheck.test gen ~f:(fun pk ->\n assert (equal (decompress_exn (compress pk)) pk) )\n\n [%%ifdef consensus_mechanism]\n\n (* snarky-dependent *)\n\n type var = Field.Var.t * Field.Var.t\n\n let assert_equal var1 var2 =\n let open Field.Checked.Assert in\n let v1_f1, v1_f2 = var1 in\n let v2_f1, v2_f2 = var2 in\n let%bind () = equal v1_f1 v2_f1 in\n let%map () = equal v1_f2 v2_f2 in\n ()\n\n let var_of_t (x, y) = (Field.Var.constant x, Field.Var.constant y)\n\n let typ : (var, t) Typ.t = Typ.(field * field)\n\n let parity_var y =\n let%map bs = Field.Checked.unpack_full y in\n List.hd_exn (Bitstring_lib.Bitstring.Lsb_first.to_list bs)\n\n let decompress_var ({ x; is_odd } as c : Compressed.var) =\n let open Let_syntax in\n let%bind y =\n exists Typ.field\n ~compute:\n As_prover.(\n map (read Compressed.typ c) ~f:(fun c -> snd (decompress_exn c)))\n in\n let%map () = Inner_curve.Checked.Assert.on_curve (x, y)\n and () = parity_var y >>= Boolean.Assert.(( = ) is_odd) in\n (x, y)\n\n let%snarkydef_ compress_var ((x, y) : var) : Compressed.var Checked.t =\n let open Compressed_poly in\n let%map is_odd = parity_var y in\n { Poly.x; is_odd }\n\n (* end snarky-dependent *)\n [%%endif]\nend\n\ninclude Uncompressed\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Snark_params.Tick\n\n[%%versioned\nmodule Stable = struct\n module V1 = struct\n [@@@with_all_version_tags]\n\n type t = (Inner_curve.Scalar.t[@version_asserted])\n [@@deriving compare, sexp]\n\n (* deriver not working, apparently *)\n let sexp_of_t = [%sexp_of: Inner_curve.Scalar.t]\n\n let t_of_sexp = [%of_sexp: Inner_curve.Scalar.t]\n\n let to_latest = Fn.id\n\n [%%ifdef consensus_mechanism]\n\n let gen =\n let open Snark_params.Tick.Inner_curve.Scalar in\n let upperbound = Bignum_bigint.(pred size |> to_string) |> of_string in\n gen_uniform_incl one upperbound\n\n [%%else]\n\n let gen = Inner_curve.Scalar.(gen_uniform_incl one (zero - one))\n\n [%%endif]\n end\nend]\n\n[%%define_locally Stable.Latest.(gen)]\n\n[%%ifdef consensus_mechanism]\n\nlet create () =\n (* This calls into libsnark which uses /dev/urandom *)\n Inner_curve.Scalar.random ()\n\n[%%else]\n\nlet create () : t =\n let open Js_of_ocaml in\n let random_bytes_32 =\n Js.Unsafe.js_expr\n {js|(function() {\n var topLevel = (typeof self === 'object' && self.self === self && self) ||\n (typeof global === 'object' && global.global === global && global) ||\n this;\n var b;\n\n if (topLevel.crypto && topLevel.crypto.getRandomValues) {\n b = new Uint8Array(32);\n topLevel.crypto.getRandomValues(b);\n } else {\n if (typeof require === 'function') {\n var crypto = require('crypto');\n if (!crypto) {\n throw 'random values not available'\n }\n b = crypto.randomBytes(32);\n } else {\n throw 'random values not available'\n }\n }\n var res = [];\n for (var i = 0; i < 32; ++i) {\n res.push(b[i]);\n }\n res[31] &= 0x3f;\n return res;\n })|js}\n in\n let x : int Js.js_array Js.t = Js.Unsafe.fun_call random_bytes_32 [||] in\n let byte_undefined () = failwith \"byte undefined\" in\n Snarkette.Pasta.Fq.of_bigint\n (Snarkette.Nat.of_bytes\n (String.init 32 ~f:(fun i ->\n Char.of_int_exn (Js.Optdef.get (Js.array_get x i) byte_undefined) )\n ) )\n\n[%%endif]\n\ninclude Comparable.Make_binable (Stable.Latest)\n\n(* for compatibility with existing private key serializations *)\nlet of_bigstring_exn =\n Binable.of_bigstring (module Stable.Latest.With_all_version_tags)\n\nlet to_bigstring =\n Binable.to_bigstring (module Stable.Latest.With_all_version_tags)\n\nmodule Base58_check = Base58_check.Make (struct\n let description = \"Private key\"\n\n let version_byte = Base58_check.Version_bytes.private_key\nend)\n\nlet to_base58_check t =\n Base58_check.encode (to_bigstring t |> Bigstring.to_string)\n\nlet of_base58_check_exn s =\n let decoded = Base58_check.decode_exn s in\n decoded |> Bigstring.of_string |> of_bigstring_exn\n\nlet sexp_of_t t = to_base58_check t |> Sexp.of_string\n\nlet t_of_sexp sexp = Sexp.to_string sexp |> of_base58_check_exn\n\nlet to_yojson t = `String (to_base58_check t)\n\nlet of_yojson = function\n | `String x -> (\n try Ok (of_base58_check_exn x) with\n | Failure str ->\n Error str\n | exn ->\n Error (\"Signature_lib.Private_key.of_yojson: \" ^ Exn.to_string exn) )\n | _ ->\n Error \"Signature_lib.Private_key.of_yojson: Expected a string\"\n","[%%import \"/src/config.mlh\"]\n\nmodule Bignum_bigint = Bigint\nopen Core_kernel\n\nmodule type Message_intf = sig\n type field\n\n type t\n\n type curve\n\n type curve_scalar\n\n val derive :\n ?signature_kind:Mina_signature_kind.t\n -> t\n -> private_key:curve_scalar\n -> public_key:curve\n -> curve_scalar\n\n val derive_for_mainnet :\n t -> private_key:curve_scalar -> public_key:curve -> curve_scalar\n\n val derive_for_testnet :\n t -> private_key:curve_scalar -> public_key:curve -> curve_scalar\n\n val hash :\n ?signature_kind:Mina_signature_kind.t\n -> t\n -> public_key:curve\n -> r:field\n -> curve_scalar\n\n val hash_for_mainnet : t -> public_key:curve -> r:field -> curve_scalar\n\n val hash_for_testnet : t -> public_key:curve -> r:field -> curve_scalar\n\n [%%ifdef consensus_mechanism]\n\n type field_var\n\n type boolean_var\n\n type var\n\n type curve_var\n\n type curve_scalar_var\n\n type _ checked\n\n val hash_checked :\n var -> public_key:curve_var -> r:field_var -> curve_scalar_var checked\n\n [%%endif]\nend\n\n[%%ifdef consensus_mechanism]\n\nmodule type S = sig\n module Impl : Snarky_backendless.Snark_intf.S\n\n open Impl\n\n type curve\n\n type curve_var\n\n type curve_scalar\n\n type curve_scalar_var\n\n module Shifted : sig\n module type S =\n Snarky_curves.Shifted_intf\n with type curve_var := curve_var\n and type boolean_var := Boolean.var\n and type 'a checked := 'a Checked.t\n end\n\n module Message :\n Message_intf\n with type boolean_var := Boolean.var\n and type curve_scalar := curve_scalar\n and type curve_scalar_var := curve_scalar_var\n and type 'a checked := 'a Checked.t\n and type curve := curve\n and type curve_var := curve_var\n and type field := Field.t\n and type field_var := Field.Var.t\n\n module Signature : sig\n type t = field * curve_scalar [@@deriving sexp]\n\n type var = Field.Var.t * curve_scalar_var\n\n val typ : (var, t) Typ.t\n end\n\n module Private_key : sig\n type t = curve_scalar [@@deriving sexp]\n end\n\n module Public_key : sig\n type t = curve [@@deriving sexp]\n\n type var = curve_var\n end\n\n module Checked : sig\n val compress : curve_var -> Boolean.var list Checked.t\n\n val verifies :\n (module Shifted.S with type t = 't)\n -> Signature.var\n -> Public_key.var\n -> Message.var\n -> Boolean.var Checked.t\n\n val assert_verifies :\n (module Shifted.S with type t = 't)\n -> Signature.var\n -> Public_key.var\n -> Message.var\n -> unit Checked.t\n end\n\n val compress : curve -> bool list\n\n val sign :\n ?signature_kind:Mina_signature_kind.t\n -> Private_key.t\n -> Message.t\n -> Signature.t\n\n val verify :\n ?signature_kind:Mina_signature_kind.t\n -> Signature.t\n -> Public_key.t\n -> Message.t\n -> bool\nend\n\nmodule Make\n (Impl : Snarky_backendless.Snark_intf.S) (Curve : sig\n open Impl\n\n module Scalar : sig\n type t [@@deriving sexp, equal]\n\n type var\n\n val typ : (var, t) Typ.t\n\n val zero : t\n\n val ( * ) : t -> t -> t\n\n val ( + ) : t -> t -> t\n\n val negate : t -> t\n\n module Checked : sig\n val to_bits : var -> Boolean.var Bitstring_lib.Bitstring.Lsb_first.t\n end\n end\n\n type t [@@deriving sexp]\n\n type var = Field.Var.t * Field.Var.t\n\n module Checked :\n Snarky_curves.Weierstrass_checked_intf\n with module Impl := Impl\n and type t = var\n and type unchecked := t\n\n val one : t\n\n val ( + ) : t -> t -> t\n\n val negate : t -> t\n\n val scale : t -> Scalar.t -> t\n\n val to_affine_exn : t -> Field.t * Field.t\n end)\n (Message : Message_intf\n with type boolean_var := Impl.Boolean.var\n and type curve_scalar_var := Curve.Scalar.var\n and type curve_scalar := Curve.Scalar.t\n and type curve := Curve.t\n and type curve_var := Curve.var\n and type field := Impl.Field.t\n and type field_var := Impl.Field.Var.t\n and type 'a checked := 'a Impl.Checked.t) :\n S\n with module Impl := Impl\n and type curve := Curve.t\n and type curve_var := Curve.var\n and type curve_scalar := Curve.Scalar.t\n and type curve_scalar_var := Curve.Scalar.var\n and module Shifted := Curve.Checked.Shifted\n and module Message := Message = struct\n open Impl\n\n module Signature = struct\n type t = Field.t * Curve.Scalar.t [@@deriving sexp]\n\n type var = Field.Var.t * Curve.Scalar.var\n\n let typ : (var, t) Typ.t = Typ.tuple2 Field.typ Curve.Scalar.typ\n end\n\n module Private_key = struct\n type t = Curve.Scalar.t [@@deriving sexp]\n end\n\n module Public_key : sig\n type t = Curve.t [@@deriving sexp]\n\n type var = Curve.var\n end =\n Curve\n\n let compress (t : Curve.t) =\n let x, _ = Curve.to_affine_exn t in\n Field.unpack x\n\n let is_even (t : Field.t) = not (Bigint.test_bit (Bigint.of_field t) 0)\n\n let sign ?signature_kind (d_prime : Private_key.t) (m : Message.t) =\n let public_key =\n (* TODO: Don't recompute this. *) Curve.scale Curve.one d_prime\n in\n (* TODO: Once we switch to implicit sign-bit we'll have to conditionally negate d_prime. *)\n let d = d_prime in\n let derive = Message.derive ?signature_kind in\n let k_prime = derive m ~public_key ~private_key:d in\n assert (not Curve.Scalar.(equal k_prime zero)) ;\n let r, ry = Curve.(to_affine_exn (scale Curve.one k_prime)) in\n let k = if is_even ry then k_prime else Curve.Scalar.negate k_prime in\n let hash = Message.hash ?signature_kind in\n let e = hash m ~public_key ~r in\n let s = Curve.Scalar.(k + (e * d)) in\n (r, s)\n\n let verify ?signature_kind ((r, s) : Signature.t) (pk : Public_key.t)\n (m : Message.t) =\n let hash = Message.hash ?signature_kind in\n let e = hash ~public_key:pk ~r m in\n let r_pt = Curve.(scale one s + negate (scale pk e)) in\n match Curve.to_affine_exn r_pt with\n | rx, ry ->\n is_even ry && Field.equal rx r\n | exception _ ->\n false\n\n [%%if call_logger]\n\n let verify s pk m =\n Mina_debug.Call_logger.record_call \"Signature_lib.Schnorr.verify\" ;\n if Random.int 1000 = 0 then (\n print_endline \"SCHNORR BACKTRACE:\" ;\n Printexc.print_backtrace stdout ) ;\n verify s pk m\n\n [%%endif]\n\n module Checked = struct\n let to_bits x =\n Field.Checked.choose_preimage_var x ~length:Field.size_in_bits\n\n let compress ((x, _) : Curve.var) = to_bits x\n\n let is_even y =\n let%map bs = Field.Checked.unpack_full y in\n Bitstring_lib.Bitstring.Lsb_first.to_list bs |> List.hd_exn |> Boolean.not\n\n (* returning r_point as a representable point ensures it is nonzero so the nonzero\n * check does not have to explicitly be performed *)\n\n let%snarkydef_ verifier (type s) ~equal ~final_check\n ((module Shifted) as shifted :\n (module Curve.Checked.Shifted.S with type t = s) )\n ((r, s) : Signature.var) (public_key : Public_key.var) (m : Message.var)\n =\n let%bind e = Message.hash_checked m ~public_key ~r in\n (* s * g - e * public_key *)\n let%bind e_pk =\n Curve.Checked.scale shifted\n (Curve.Checked.negate public_key)\n (Curve.Scalar.Checked.to_bits e)\n ~init:Shifted.zero\n in\n let%bind s_g_e_pk =\n Curve.Checked.scale_known shifted Curve.one\n (Curve.Scalar.Checked.to_bits s)\n ~init:e_pk\n in\n let%bind rx, ry = Shifted.unshift_nonzero s_g_e_pk in\n let%bind y_even = is_even ry in\n let%bind r_correct = equal r rx in\n final_check r_correct y_even\n\n let verifies s =\n verifier ~equal:Field.Checked.equal ~final_check:Boolean.( && ) s\n\n let assert_verifies s =\n verifier ~equal:Field.Checked.Assert.equal\n ~final_check:(fun () ry_even -> Boolean.Assert.is_true ry_even)\n s\n end\nend\n\n[%%else]\n\n(* nonconsensus version of the functor; yes, there's some repeated code,\n but seems difficult to abstract over the functors and signatures\n*)\n\nmodule type S = sig\n open Snark_params.Tick\n\n type curve\n\n type curve_scalar\n\n module Message :\n Message_intf\n with type curve_scalar := curve_scalar\n and type curve := curve\n and type field := Field.t\n\n module Signature : sig\n type t = Field.t * curve_scalar [@@deriving sexp]\n end\n\n module Private_key : sig\n type t = curve_scalar [@@deriving sexp]\n end\n\n module Public_key : sig\n type t = curve [@@deriving sexp]\n end\n\n val sign :\n ?signature_kind:Mina_signature_kind.t\n -> Private_key.t\n -> Message.t\n -> Signature.t\n\n val verify :\n ?signature_kind:Mina_signature_kind.t\n -> Signature.t\n -> Public_key.t\n -> Message.t\n -> bool\nend\n\nmodule Make\n (Impl : module type of Snark_params.Tick) (Curve : sig\n open Impl\n\n module Scalar : sig\n type t [@@deriving sexp, equal]\n\n val zero : t\n\n val ( * ) : t -> t -> t\n\n val ( + ) : t -> t -> t\n\n val negate : t -> t\n end\n\n type t [@@deriving sexp]\n\n val one : t\n\n val ( + ) : t -> t -> t\n\n val negate : t -> t\n\n val scale : t -> Scalar.t -> t\n\n val to_affine_exn : t -> Field.t * Field.t\n end)\n (Message : Message_intf\n with type curve := Curve.t\n and type curve_scalar := Curve.Scalar.t\n and type field := Impl.Field.t) :\n S\n with type curve := Curve.t\n and type curve_scalar := Curve.Scalar.t\n and module Message := Message = struct\n module Private_key = struct\n type t = Curve.Scalar.t [@@deriving sexp]\n end\n\n module Signature = struct\n type t = Impl.Field.t * Curve.Scalar.t [@@deriving sexp]\n end\n\n module Public_key : sig\n type t = Curve.t [@@deriving sexp]\n end =\n Curve\n\n let is_even (t : Impl.Field.t) = not @@ Impl.Field.parity t\n\n let sign ?signature_kind (d_prime : Private_key.t) m =\n let public_key =\n (* TODO: Don't recompute this. *)\n Curve.scale Curve.one d_prime\n in\n (* TODO: Once we switch to implicit sign-bit we'll have to conditionally negate d_prime. *)\n let d = d_prime in\n let derive = Message.derive ?signature_kind in\n let k_prime = derive m ~public_key ~private_key:d in\n assert (not Curve.Scalar.(equal k_prime zero)) ;\n let r, (ry : Impl.Field.t) =\n Curve.(to_affine_exn (scale Curve.one k_prime))\n in\n let k = if is_even ry then k_prime else Curve.Scalar.negate k_prime in\n let hash = Message.hash ?signature_kind in\n let e = hash m ~public_key ~r in\n let s = Curve.Scalar.(k + (e * d)) in\n (r, s)\n\n let verify ?signature_kind ((r, s) : Signature.t) (pk : Public_key.t)\n (m : Message.t) =\n let hash = Message.hash ?signature_kind in\n let e = hash ~public_key:pk ~r m in\n let r_pt = Curve.(scale one s + negate (scale pk e)) in\n match Curve.to_affine_exn r_pt with\n | rx, ry ->\n is_even ry && Impl.Field.(equal rx r)\n | exception _ ->\n false\nend\n\n[%%endif]\n\nopen Snark_params\n\nmodule Message = struct\n let network_id_mainnet = String.of_char @@ Char.of_int_exn 1\n\n let network_id_testnet = String.of_char @@ Char.of_int_exn 0\n\n let network_id_other chain_name = chain_name\n\n let network_id =\n match Mina_signature_kind.t with\n | Mainnet ->\n network_id_mainnet\n | Testnet ->\n network_id_testnet\n | Other_network chain_name ->\n network_id_other chain_name\n\n module Legacy = struct\n open Tick\n\n type t = (Field.t, bool) Random_oracle.Input.Legacy.t [@@deriving sexp]\n\n let make_derive ~network_id t ~private_key ~public_key =\n let input =\n let x, y = Tick.Inner_curve.to_affine_exn public_key in\n Random_oracle.Input.Legacy.append t\n { field_elements = [| x; y |]\n ; bitstrings =\n [| Tock.Field.unpack private_key\n ; Fold_lib.Fold.(to_list (string_bits network_id))\n |]\n }\n in\n Random_oracle.Input.Legacy.to_bits ~unpack:Field.unpack input\n |> Array.of_list |> Blake2.bits_to_string |> Blake2.digest_string\n |> Blake2.to_raw_string |> Blake2.string_to_bits |> Array.to_list\n |> Fn.flip List.take (Int.min 256 (Tock.Field.size_in_bits - 1))\n |> Tock.Field.project\n\n let derive ?(signature_kind = Mina_signature_kind.t) =\n make_derive\n ~network_id:\n ( match signature_kind with\n | Mainnet ->\n network_id_mainnet\n | Testnet ->\n network_id_testnet\n | Other_network chain_name ->\n network_id_other chain_name )\n\n let derive_for_mainnet = make_derive ~network_id:network_id_mainnet\n\n let derive_for_testnet = make_derive ~network_id:network_id_testnet\n\n let make_hash ~init t ~public_key ~r =\n let input =\n let px, py = Inner_curve.to_affine_exn public_key in\n Random_oracle.Input.Legacy.append t\n { field_elements = [| px; py; r |]; bitstrings = [||] }\n in\n let open Random_oracle.Legacy in\n hash ~init (pack_input input)\n |> Digest.to_bits ~length:Field.size_in_bits\n |> Inner_curve.Scalar.of_bits\n\n let hash ?signature_kind =\n make_hash ~init:(Hash_prefix_states.signature_legacy ?signature_kind)\n\n let hash_for_mainnet =\n make_hash ~init:Hash_prefix_states.signature_for_mainnet_legacy\n\n let hash_for_testnet =\n make_hash ~init:Hash_prefix_states.signature_for_testnet_legacy\n\n [%%ifdef consensus_mechanism]\n\n type var = (Field.Var.t, Boolean.var) Random_oracle.Input.Legacy.t\n\n let%snarkydef_ hash_checked t ~public_key ~r =\n let input =\n let px, py = public_key in\n Random_oracle.Input.Legacy.append t\n { field_elements = [| px; py; r |]; bitstrings = [||] }\n in\n make_checked (fun () ->\n let open Random_oracle.Legacy.Checked in\n hash\n ~init:(Hash_prefix_states.signature_legacy ?signature_kind:None)\n (pack_input input)\n |> Digest.to_bits ~length:Field.size_in_bits\n |> Bitstring_lib.Bitstring.Lsb_first.of_list )\n\n [%%endif]\n end\n\n module Chunked = struct\n open Tick\n\n type t = Field.t Random_oracle.Input.Chunked.t [@@deriving sexp]\n\n let make_derive ~network_id t ~private_key ~public_key =\n let input =\n let x, y = Tick.Inner_curve.to_affine_exn public_key in\n let id = Fold_lib.Fold.(to_list (string_bits network_id)) in\n Random_oracle.Input.Chunked.append t\n { field_elements =\n [| x; y; Field.project (Tock.Field.unpack private_key) |]\n ; packeds = [| (Field.project id, List.length id) |]\n }\n in\n Array.map (Random_oracle.pack_input input) ~f:Tick.Field.unpack\n |> Array.to_list |> List.concat |> Array.of_list |> Blake2.bits_to_string\n |> Blake2.digest_string |> Blake2.to_raw_string |> Blake2.string_to_bits\n |> Array.to_list\n |> Fn.flip List.take (Int.min 256 (Tock.Field.size_in_bits - 1))\n |> Tock.Field.project\n\n let derive ?(signature_kind = Mina_signature_kind.t) =\n make_derive\n ~network_id:\n ( match signature_kind with\n | Mainnet ->\n network_id_mainnet\n | Testnet ->\n network_id_testnet\n | Other_network chain_name ->\n network_id_other chain_name )\n\n let derive_for_mainnet = make_derive ~network_id:network_id_mainnet\n\n let derive_for_testnet = make_derive ~network_id:network_id_testnet\n\n let make_hash ~init t ~public_key ~r =\n let input =\n let px, py = Inner_curve.to_affine_exn public_key in\n Random_oracle.Input.Chunked.append t\n { field_elements = [| px; py; r |]; packeds = [||] }\n in\n let open Random_oracle in\n hash ~init (pack_input input)\n |> Digest.to_bits ~length:Field.size_in_bits\n |> Inner_curve.Scalar.of_bits\n\n let hash ?signature_kind =\n make_hash ~init:(Hash_prefix_states.signature ?signature_kind)\n\n let hash_for_mainnet =\n make_hash ~init:Hash_prefix_states.signature_for_mainnet\n\n let hash_for_testnet =\n make_hash ~init:Hash_prefix_states.signature_for_testnet\n\n [%%ifdef consensus_mechanism]\n\n type var = Field.Var.t Random_oracle.Input.Chunked.t\n\n let%snarkydef_ hash_checked t ~public_key ~r =\n let input =\n let px, py = public_key in\n Random_oracle.Input.Chunked.append t\n { field_elements = [| px; py; r |]; packeds = [||] }\n in\n make_checked (fun () ->\n let open Random_oracle.Checked in\n hash\n ~init:(Hash_prefix_states.signature ?signature_kind:None)\n (pack_input input)\n |> Digest.to_bits ~length:Field.size_in_bits\n |> Bitstring_lib.Bitstring.Lsb_first.of_list )\n\n [%%endif]\n end\nend\n\nmodule Legacy = Make (Tick) (Tick.Inner_curve) (Message.Legacy)\nmodule Chunked = Make (Tick) (Tick.Inner_curve) (Message.Chunked)\n\n[%%ifdef consensus_mechanism]\n\nlet gen_legacy =\n let open Quickcheck.Let_syntax in\n let%map pk = Private_key.gen and msg = Tick.Field.gen in\n (pk, Random_oracle.Input.Legacy.field_elements [| msg |])\n\nlet gen_chunked =\n let open Quickcheck.Let_syntax in\n let%map pk = Private_key.gen and msg = Tick.Field.gen in\n (pk, Random_oracle.Input.Chunked.field_elements [| msg |])\n\n(* Use for reading only. *)\nlet legacy_message_typ () : (Message.Legacy.var, Message.Legacy.t) Tick.Typ.t =\n let to_hlist { Random_oracle.Input.Legacy.field_elements; bitstrings } =\n H_list.[ field_elements; bitstrings ]\n in\n let of_hlist ([ field_elements; bitstrings ] : (unit, _) H_list.t) =\n { Random_oracle.Input.Legacy.field_elements; bitstrings }\n in\n let open Tick.Typ in\n of_hlistable\n [ array ~length:0 Tick.Field.typ\n ; array ~length:0 (list ~length:0 Tick.Boolean.typ)\n ]\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist\n\n(* Use for reading only. *)\nlet chunked_message_typ () : (Message.Chunked.var, Message.Chunked.t) Tick.Typ.t\n =\n let open Tick.Typ in\n let const_typ =\n Typ\n { check = (fun _ -> Tick.Checked.return ())\n ; var_to_fields = (fun t -> ([||], t))\n ; var_of_fields = (fun (_, t) -> t)\n ; value_to_fields = (fun t -> ([||], t))\n ; value_of_fields = (fun (_, t) -> t)\n ; size_in_field_elements = 0\n ; constraint_system_auxiliary =\n (fun () -> failwith \"Cannot create constant in constraint-system mode\")\n }\n in\n let to_hlist { Random_oracle.Input.Chunked.field_elements; packeds } =\n H_list.[ field_elements; packeds ]\n in\n let of_hlist ([ field_elements; packeds ] : (unit, _) H_list.t) =\n { Random_oracle.Input.Chunked.field_elements; packeds }\n in\n of_hlistable\n [ array ~length:0 Tick.Field.typ\n ; array ~length:0 (Tick.Field.typ * const_typ)\n ]\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist\n\nlet%test_unit \"schnorr checked + unchecked\" =\n Quickcheck.test ~trials:5 gen_legacy ~f:(fun (pk, msg) ->\n let s = Legacy.sign pk msg in\n let pubkey = Tick.Inner_curve.(scale one pk) in\n assert (Legacy.verify s pubkey msg) ;\n (Tick.Test.test_equal ~sexp_of_t:[%sexp_of: bool] ~equal:Bool.equal\n Tick.Typ.(\n tuple3 Tick.Inner_curve.typ (legacy_message_typ ())\n Legacy.Signature.typ)\n Tick.Boolean.typ\n (fun (public_key, msg, s) ->\n let open Tick.Checked in\n let%bind (module Shifted) =\n Tick.Inner_curve.Checked.Shifted.create ()\n in\n Legacy.Checked.verifies (module Shifted) s public_key msg )\n (fun _ -> true) )\n (pubkey, msg, s) )\n\nlet%test_unit \"schnorr checked + unchecked\" =\n Quickcheck.test ~trials:5 gen_chunked ~f:(fun (pk, msg) ->\n let s = Chunked.sign pk msg in\n let pubkey = Tick.Inner_curve.(scale one pk) in\n assert (Chunked.verify s pubkey msg) ;\n (Tick.Test.test_equal ~sexp_of_t:[%sexp_of: bool] ~equal:Bool.equal\n Tick.Typ.(\n tuple3 Tick.Inner_curve.typ (chunked_message_typ ())\n Chunked.Signature.typ)\n Tick.Boolean.typ\n (fun (public_key, msg, s) ->\n let open Tick.Checked in\n let%bind (module Shifted) =\n Tick.Inner_curve.Checked.Shifted.create ()\n in\n Chunked.Checked.verifies (module Shifted) s public_key msg )\n (fun _ -> true) )\n (pubkey, msg, s) )\n\n[%%endif]\n","open Core_kernel\n\n[%%versioned\nmodule Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n type t =\n { public_key : Public_key.Stable.V1.t\n ; private_key : (Private_key.Stable.V1.t[@sexp.opaque])\n }\n [@@deriving sexp]\n\n let to_latest = Fn.id\n\n let to_yojson t = Public_key.Stable.V1.to_yojson t.public_key\n end\nend]\n\nmodule T = struct\n type t = Stable.Latest.t =\n { public_key : Public_key.t; private_key : (Private_key.t[@sexp.opaque]) }\n [@@deriving sexp]\n\n let compare { public_key = pk1; private_key = _ }\n { public_key = pk2; private_key = _ } =\n Public_key.compare pk1 pk2\n\n let to_yojson = Stable.Latest.to_yojson\nend\n\ninclude T\ninclude Comparable.Make (T)\n\nlet of_private_key_exn private_key =\n let public_key = Public_key.of_private_key_exn private_key in\n { public_key; private_key }\n\nlet create () = of_private_key_exn (Private_key.create ())\n\nlet gen = Quickcheck.Generator.(map ~f:of_private_key_exn Private_key.gen)\n\nmodule And_compressed_pk = struct\n module T = struct\n type t = T.t * Public_key.Compressed.t [@@deriving sexp]\n\n let compare ({ public_key = pk1; private_key = _ }, _)\n ({ public_key = pk2; private_key = _ }, _) =\n Public_key.compare pk1 pk2\n end\n\n include T\n include Comparable.Make (T)\nend\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Snark_params.Tick\n\n[%%versioned\nmodule Stable = struct\n module V1 = struct\n type t = Sgn_type.Sgn.Stable.V1.t = Pos | Neg\n [@@deriving sexp, hash, compare, equal, yojson]\n\n let to_latest = Fn.id\n end\nend]\n\nlet gen =\n Quickcheck.Generator.map Bool.quickcheck_generator ~f:(fun b ->\n if b then Pos else Neg )\n\nlet negate = function Pos -> Neg | Neg -> Pos\n\nlet neg_one = Field.(negate one)\n\nlet to_field = function Pos -> Field.one | Neg -> neg_one\n\nlet of_field_exn x =\n if Field.equal x Field.one then Pos\n else if Field.equal x neg_one then Neg\n else failwith \"Sgn.of_field: Expected positive or negative 1\"\n\n[%%ifdef consensus_mechanism]\n\ntype var = Field.Var.t\n\nlet typ : (var, t) Typ.t =\n let open Typ in\n Typ\n { check = (fun x -> assert_r1cs x x (Field.Var.constant Field.one))\n ; var_to_fields = (fun t -> ([| t |], ()))\n ; var_of_fields = (fun (ts, ()) -> ts.(0))\n ; value_to_fields = (fun t -> ([| to_field t |], ()))\n ; value_of_fields = (fun (ts, ()) -> of_field_exn ts.(0))\n ; size_in_field_elements = 1\n ; constraint_system_auxiliary = (fun () -> ())\n }\n\nmodule Checked = struct\n let two = Field.of_int 2\n\n let neg_two = Field.negate two\n\n let one_half = Field.inv two\n\n let neg_one_half = Field.negate one_half\n\n let is_pos (v : var) =\n Boolean.Unsafe.of_cvar\n (let open Field.Checked in\n one_half * (v + Field.Var.constant Field.one))\n\n let is_neg (v : var) =\n Boolean.Unsafe.of_cvar\n (let open Field.Checked in\n neg_one_half * (v - Field.Var.constant Field.one))\n\n let pos_if_true (b : Boolean.var) =\n let open Field.Checked in\n (two * (b :> Field.Var.t)) - Field.Var.constant Field.one\n\n let neg_if_true (b : Boolean.var) =\n let open Field.Checked in\n (neg_two * (b :> Field.Var.t)) + Field.Var.constant Field.one\n\n let negate t = Field.Var.scale t neg_one\n\n let constant = Fn.compose Field.Var.constant to_field\n\n let neg = constant Neg\n\n let pos = constant Pos\n\n let if_ = Field.Checked.if_\nend\n\n[%%endif]\n","open Core_kernel\n\nmodule Tree = struct\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n type ('hash, 'account) t =\n | Account of 'account\n | Hash of 'hash\n | Node of 'hash * ('hash, 'account) t * ('hash, 'account) t\n [@@deriving equal, sexp, yojson]\n\n let rec to_latest acct_to_latest = function\n | Account acct ->\n Account (acct_to_latest acct)\n | Hash hash ->\n Hash hash\n | Node (hash, l, r) ->\n Node (hash, to_latest acct_to_latest l, to_latest acct_to_latest r)\n end\n end]\n\n type ('hash, 'account) t = ('hash, 'account) Stable.Latest.t =\n | Account of 'account\n | Hash of 'hash\n | Node of 'hash * ('hash, 'account) t * ('hash, 'account) t\n [@@deriving equal, sexp, yojson]\nend\n\nmodule T = struct\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V2 = struct\n type ('hash, 'key, 'account) t =\n { indexes : ('key * int) list\n ; depth : int\n ; tree : ('hash, 'account) Tree.Stable.V1.t\n }\n [@@deriving sexp, yojson]\n end\n end]\n\n type ('hash, 'key, 'account) t = ('hash, 'key, 'account) Stable.Latest.t =\n { indexes : ('key * int) list\n ; depth : int\n ; tree : ('hash, 'account) Tree.t\n }\n [@@deriving sexp, yojson]\nend\n\nmodule type S = sig\n type hash\n\n type account_id\n\n type account\n\n type t = (hash, account_id, account) T.t [@@deriving sexp, yojson]\n\n val of_hash : depth:int -> hash -> t\n\n val get_exn : t -> int -> account\n\n val path_exn : t -> int -> [ `Left of hash | `Right of hash ] list\n\n val set_exn : t -> int -> account -> t\n\n val find_index_exn : t -> account_id -> int\n\n val add_path :\n t -> [ `Left of hash | `Right of hash ] list -> account_id -> account -> t\n\n val iteri : t -> f:(int -> account -> unit) -> unit\n\n val merkle_root : t -> hash\n\n val depth : t -> int\nend\n\nlet tree { T.tree; _ } = tree\n\nlet of_hash ~depth h = { T.indexes = []; depth; tree = Hash h }\n\nmodule Make (Hash : sig\n type t [@@deriving equal, sexp, yojson, compare]\n\n val merge : height:int -> t -> t -> t\nend) (Account_id : sig\n type t [@@deriving equal, sexp, yojson]\nend) (Account : sig\n type t [@@deriving equal, sexp, yojson]\n\n val data_hash : t -> Hash.t\nend) : sig\n include\n S\n with type hash := Hash.t\n and type account_id := Account_id.t\n and type account := Account.t\n\n val hash : (Hash.t, Account.t) Tree.t -> Hash.t\nend = struct\n type t = (Hash.t, Account_id.t, Account.t) T.t [@@deriving sexp, yojson]\n\n let of_hash ~depth (hash : Hash.t) = of_hash ~depth hash\n\n let hash : (Hash.t, Account.t) Tree.t -> Hash.t = function\n | Account a ->\n Account.data_hash a\n | Hash h ->\n h\n | Node (h, _, _) ->\n h\n\n type index = int [@@deriving sexp, yojson]\n\n let depth { T.depth; _ } = depth\n\n let merkle_root { T.tree; _ } = hash tree\n\n let add_path depth0 tree0 path0 account =\n let rec build_tree height p =\n match p with\n | `Left h_r :: path ->\n let l = build_tree (height - 1) path in\n Tree.Node (Hash.merge ~height (hash l) h_r, l, Hash h_r)\n | `Right h_l :: path ->\n let r = build_tree (height - 1) path in\n Node (Hash.merge ~height h_l (hash r), Hash h_l, r)\n | [] ->\n assert (height = -1) ;\n Account account\n in\n let rec union height tree path =\n match (tree, path) with\n | Tree.Hash h, path ->\n let t = build_tree height path in\n [%test_result: Hash.t]\n ~message:\n \"Hashes in union are not equal, something is wrong with your \\\n ledger\"\n ~expect:h (hash t) ;\n t\n | Node (h, l, r), `Left h_r :: path ->\n assert (Hash.equal h_r (hash r)) ;\n let l = union (height - 1) l path in\n Node (h, l, r)\n | Node (h, l, r), `Right h_l :: path ->\n assert (Hash.equal h_l (hash l)) ;\n let r = union (height - 1) r path in\n Node (h, l, r)\n | Node _, [] ->\n failwith \"Path too short\"\n | Account _, _ :: _ ->\n failwith \"Path too long\"\n | Account a, [] ->\n assert (Account.equal a account) ;\n tree\n in\n union (depth0 - 1) tree0 (List.rev path0)\n\n let add_path (t : t) path account_id account =\n let index =\n List.foldi path ~init:0 ~f:(fun i acc x ->\n match x with `Right _ -> acc + (1 lsl i) | `Left _ -> acc )\n in\n { t with\n tree = add_path t.depth t.tree path account\n ; indexes = (account_id, index) :: t.indexes\n }\n\n let iteri (t : t) ~f =\n let rec go acc i tree ~f =\n match tree with\n | Tree.Account a ->\n f acc a\n | Hash _ ->\n ()\n | Node (_, l, r) ->\n go acc (i - 1) l ~f ;\n go (acc + (1 lsl i)) (i - 1) r ~f\n in\n go 0 (t.depth - 1) t.tree ~f\n\n let ith_bit idx i = (idx lsr i) land 1 = 1\n\n let find_index_exn (t : t) aid =\n match List.Assoc.find t.indexes ~equal:Account_id.equal aid with\n | Some x ->\n x\n | None ->\n failwithf\n !\"Sparse_ledger.find_index_exn: %{sexp:Account_id.t} not in %{sexp: \\\n Account_id.t list}\"\n aid\n (List.map t.indexes ~f:fst)\n ()\n\n let get_exn ({ T.tree; depth; _ } as t) idx =\n let rec go i tree =\n match (i < 0, tree) with\n | true, Tree.Account acct ->\n acct\n | false, Node (_, l, r) ->\n let go_right = ith_bit idx i in\n if go_right then go (i - 1) r else go (i - 1) l\n | _ ->\n let expected_kind = if i < 0 then \"n account\" else \" node\" in\n let kind =\n match tree with\n | Account _ ->\n \"n account\"\n | Hash _ ->\n \" hash\"\n | Node _ ->\n \" node\"\n in\n failwithf\n !\"Sparse_ledger.get: Bad index %i. Expected a%s, but got a%s at \\\n depth %i. Tree = %{sexp:t}\"\n idx expected_kind kind (depth - i) t ()\n in\n go (depth - 1) tree\n\n let set_exn (t : t) idx acct =\n let rec go i tree =\n match (i < 0, tree) with\n | true, Tree.Account _ ->\n Tree.Account acct\n | false, Node (_, l, r) ->\n let l, r =\n let go_right = ith_bit idx i in\n if go_right then (l, go (i - 1) r) else (go (i - 1) l, r)\n in\n Node (Hash.merge ~height:i (hash l) (hash r), l, r)\n | _ ->\n let expected_kind = if i < 0 then \"n account\" else \" node\" in\n let kind =\n match tree with\n | Account _ ->\n \"n account\"\n | Hash _ ->\n \" hash\"\n | Node _ ->\n \" node\"\n in\n failwithf\n \"Sparse_ledger.set: Bad index %i. Expected a%s, but got a%s at \\\n depth %i.\"\n idx expected_kind kind (t.depth - i) ()\n in\n { t with tree = go (t.depth - 1) t.tree }\n\n let path_exn { T.tree; depth; _ } idx =\n let rec go acc i tree =\n if i < 0 then acc\n else\n match tree with\n | Tree.Account _ ->\n failwithf \"Sparse_ledger.path: Bad depth at index %i.\" idx ()\n | Hash _ ->\n failwithf \"Sparse_ledger.path: Dead end at index %i.\" idx ()\n | Node (_, l, r) ->\n let go_right = ith_bit idx i in\n if go_right then go (`Right (hash l) :: acc) (i - 1) r\n else go (`Left (hash r) :: acc) (i - 1) l\n in\n go [] (depth - 1) tree\nend\n\ntype ('hash, 'key, 'account) t = ('hash, 'key, 'account) T.t [@@deriving yojson]\n\nlet%test_module \"sparse-ledger-test\" =\n ( module struct\n module Hash = struct\n type t = Core_kernel.Md5.t [@@deriving sexp, compare]\n\n let equal h1 h2 = Int.equal (compare h1 h2) 0\n\n let to_yojson md5 = `String (Core_kernel.Md5.to_hex md5)\n\n let of_yojson = function\n | `String x ->\n Or_error.try_with (fun () -> Core_kernel.Md5.of_hex_exn x)\n |> Result.map_error ~f:Error.to_string_hum\n | _ ->\n Error \"Expected a hex-encoded MD5 hash\"\n\n let merge ~height x y =\n let open Md5 in\n digest_string\n (sprintf \"sparse-ledger_%03d\" height ^ to_binary x ^ to_binary y)\n\n let gen =\n Quickcheck.Generator.map String.quickcheck_generator\n ~f:Md5.digest_string\n end\n\n module Account = struct\n module T = struct\n type t = { name : string; favorite_number : int }\n [@@deriving bin_io, equal, sexp, yojson]\n end\n\n include T\n\n let key { name; _ } = name\n\n let data_hash t = Md5.digest_string (Binable.to_string (module T) t)\n\n let gen =\n let open Quickcheck.Generator.Let_syntax in\n let%map name = String.quickcheck_generator\n and favorite_number = Int.quickcheck_generator in\n { name; favorite_number }\n end\n\n module Account_id = struct\n type t = string [@@deriving sexp, equal, yojson]\n end\n\n include Make (Hash) (Account_id) (Account)\n\n let gen =\n let open Quickcheck.Generator in\n let open Let_syntax in\n let indexes max_depth t =\n let rec go addr d = function\n | Tree.Account a ->\n [ (Account.key a, addr) ]\n | Hash _ ->\n []\n | Node (_, l, r) ->\n go addr (d - 1) l @ go (addr lor (1 lsl d)) (d - 1) r\n in\n go 0 (max_depth - 1) t\n in\n let rec prune_hash_branches = function\n | Tree.Hash h ->\n Tree.Hash h\n | Account a ->\n Account a\n | Node (h, l, r) -> (\n match (prune_hash_branches l, prune_hash_branches r) with\n | Hash _, Hash _ ->\n Hash h\n | l, r ->\n Node (h, l, r) )\n in\n let rec gen depth =\n if depth = 0 then Account.gen >>| fun a -> Tree.Account a\n else\n let t =\n let sub = gen (depth - 1) in\n let%map l = sub and r = sub in\n Tree.Node (Hash.merge ~height:(depth - 1) (hash l) (hash r), l, r)\n in\n weighted_union\n [ (1. /. 3., Hash.gen >>| fun h -> Tree.Hash h); (2. /. 3., t) ]\n in\n let%bind depth = Int.gen_incl 0 16 in\n let%map tree = gen depth >>| prune_hash_branches in\n { T.tree; depth; indexes = indexes depth tree }\n\n let%test_unit \"iteri consistent indices with t.indexes\" =\n Quickcheck.test gen ~f:(fun t ->\n let indexes = Int.Set.of_list (t.indexes |> List.map ~f:snd) in\n iteri t ~f:(fun i _ ->\n [%test_result: bool]\n ~message:\n \"Iteri index should be contained in the indexes auxillary \\\n structure\"\n ~expect:true (Int.Set.mem indexes i) ) )\n\n let%test_unit \"path_test\" =\n Quickcheck.test gen ~f:(fun t ->\n let root = { t with indexes = []; tree = Hash (merkle_root t) } in\n let t' =\n List.fold t.indexes ~init:root ~f:(fun acc (_, index) ->\n let account = get_exn t index in\n add_path acc (path_exn t index) (Account.key account) account )\n in\n assert (Tree.equal Hash.equal Account.equal t'.tree t.tree) )\n end )\n","(* coding.ml -- hex encoding/decoding for Rosetta *)\n\n[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nmodule Field = Snark_params.Tick.Field\nmodule Scalar = Snark_params.Tick.Inner_curve.Scalar\nopen Signature_lib\n\n(* see RFC 0038, section \"marshal-keys\" for a specification *)\n\nlet hex_char_to_bits4 = function\n | '0' ->\n [ false; false; false; false ]\n | '1' ->\n [ false; false; false; true ]\n | '2' ->\n [ false; false; true; false ]\n | '3' ->\n [ false; false; true; true ]\n | '4' ->\n [ false; true; false; false ]\n | '5' ->\n [ false; true; false; true ]\n | '6' ->\n [ false; true; true; false ]\n | '7' ->\n [ false; true; true; true ]\n | '8' ->\n [ true; false; false; false ]\n | '9' ->\n [ true; false; false; true ]\n | 'A' | 'a' ->\n [ true; false; true; false ]\n | 'B' | 'b' ->\n [ true; false; true; true ]\n | 'C' | 'c' ->\n [ true; true; false; false ]\n | 'D' | 'd' ->\n [ true; true; false; true ]\n | 'E' | 'e' ->\n [ true; true; true; false ]\n | 'F' | 'f' ->\n [ true; true; true; true ]\n | _ ->\n failwith \"Expected hex character\"\n\nlet bits4_to_hex_char bits =\n List.mapi bits ~f:(fun i bit -> if bit then Int.pow 2 (3 - i) else 0)\n |> List.fold ~init:0 ~f:( + )\n |> fun n ->\n let s = sprintf \"%0X\" n in\n s.[0]\n\nmodule type Packed = sig\n type t\n\n val unpack : t -> bool list\nend\n\n(* break of the bits byte by byte *)\nlet bits_by_n n bits =\n let rec go bits acc =\n if List.is_empty bits then List.rev acc\n else\n let bitsn, rest = List.split_n bits n in\n go rest (bitsn :: acc)\n in\n go bits []\n\nlet bits_by_4s = bits_by_n 4\n\nlet bits_by_8s = bits_by_n 8\n\nlet of_unpackable (type t) (module M : Packed with type t = t)\n ?(padding_bit = false) (packed : t) =\n let bits0 = M.unpack packed |> List.rev in\n assert (Mina_stdlib.List.Length.Compare.(bits0 = 255)) ;\n (* field elements, scalars are 255 bits, left-pad to get 32 bytes *)\n let bits = padding_bit :: bits0 in\n (* break of the bits byte by byte *)\n (* In our encoding, we want highest bytes at the end and lowest at the\n beginning. *)\n let bytes = bits_by_8s bits in\n let bytes' = List.rev bytes in\n let bits' = List.concat bytes' in\n let cs = List.map (bits_by_4s bits') ~f:bits4_to_hex_char in\n String.of_char_list cs\n\nlet of_field = of_unpackable (module Field)\n\nlet of_scalar = of_unpackable (module Scalar)\n\nmodule type Unpacked = sig\n type t\n\n val project : bool list -> t\nend\n\nlet pack (type t) (module M : Unpacked with type t = t) (raw : string) :\n bool * t =\n (* 256 bits = 64 hex chars *)\n assert (Int.equal (String.length raw) 64) ;\n let bits =\n String.to_list raw |> List.map ~f:hex_char_to_bits4 |> List.concat\n in\n (* In our encoding, we have highest bytes at the end and lowest at the\n beginning. *)\n let bytes = bits_by_8s bits in\n let bytes_rev = List.rev bytes in\n let bits' = List.concat bytes_rev in\n\n let padding_bit = List.hd_exn bits' in\n (* remove padding bit *)\n let bits'' = List.tl_exn bits' |> List.rev in\n (padding_bit, M.project bits'')\n\nlet to_field hex = pack (module Field) hex |> snd\n\nlet to_scalar hex = pack (module Scalar) hex |> snd\n\nlet of_public_key_compressed pk =\n let { Public_key.Compressed.Poly.x; is_odd } = pk in\n of_field ~padding_bit:is_odd x\n\nlet of_public_key pk = of_public_key_compressed (Public_key.compress pk)\n\nlet to_public_key_compressed raw =\n let is_odd, x = pack (module Field) raw in\n { Public_key.Compressed.Poly.x; is_odd }\n\nlet to_public_key raw =\n to_public_key_compressed raw |> Public_key.decompress_exn\n\n(* inline tests hard-to-impossible to setup with JS *)\n\nlet field_hex_roundtrip_test () =\n let field0 = Field.of_int 123123 in\n let hex = of_field field0 in\n let field1 = to_field hex in\n Field.equal field0 field1\n\nlet pk_roundtrip_test () =\n let pk =\n { Public_key.Compressed.Poly.x = Field.of_int 123123; is_odd = true }\n in\n let hex = of_public_key_compressed pk in\n let pk' = to_public_key_compressed hex in\n Public_key.Compressed.equal pk pk'\n\nlet hex_key_odd =\n \"fad1d3e31aede102793fb2cce62b4f1e71a214c94ce18ad5756eba67ef398390\"\n\nlet hex_key_even =\n \"7e406ca640115a8c44ece6ef5d0c56af343b1a993d8c871648ab7980ecaf8230\"\n\nlet pk_compressed_roundtrip_test hex_key () =\n let pk = to_public_key hex_key in\n let hex' = of_public_key pk in\n String.equal (String.lowercase hex_key) (String.lowercase hex')\n\nlet%test \"field_hex round-trip\" = field_hex_roundtrip_test ()\n\nlet%test \"public key round-trip\" = pk_roundtrip_test ()\n\nlet%test \"public key compressed roundtrip odd\" =\n pk_compressed_roundtrip_test hex_key_odd ()\n\nlet%test \"public key compressed roundtrip even\" =\n pk_compressed_roundtrip_test hex_key_even ()\n\n(* for running tests from JS *)\n\nlet unit_tests =\n [ (\"field-hex round-trip\", field_hex_roundtrip_test)\n ; (\"public key round-trip\", pk_roundtrip_test)\n ; ( \"public key compressed round-trip odd\"\n , pk_compressed_roundtrip_test hex_key_odd )\n ; ( \"public key compressed round-trip even\"\n , pk_compressed_roundtrip_test hex_key_even )\n ]\n\nlet run_unit_tests () =\n List.iter unit_tests ~f:(fun (name, test) ->\n printf \"Running %s test\\n%!\" name ;\n assert (test ()) )\n","(* deriving.ml -- deriving ppx for Dhall types *)\n\n(* TODO:\n deriver for signatures\n default values in records\n*)\n\nopen Core_kernel\nopen Ppxlib\n\nlet deriver = \"dhall_type\"\n\nlet field_key_attr =\n Attribute.declare (deriver ^ \".key\") Attribute.Context.Label_declaration\n Ast_pattern.(single_expr_payload (estring __))\n Fn.id\n\nlet make_lident_cmp items lident =\n List.mem items (Longident.name lident.txt) ~equal:String.equal\n\nlet is_bool_lident = make_lident_cmp [ \"bool\"; \"Bool.t\" ]\n\nlet is_int_lident = make_lident_cmp [ \"int\"; \"Int.t\" ]\n\nlet is_float_lident = make_lident_cmp [ \"float\"; \"Float.t\" ]\n\nlet is_string_lident = make_lident_cmp [ \"string\"; \"String.t\" ]\n\nlet is_option_lident = make_lident_cmp [ \"option\"; \"Option.t\" ]\n\nlet is_list_lident = make_lident_cmp [ \"list\"; \"List.t\" ]\n\nlet rec dhall_type_of_core_type core_type =\n let (module Ast_builder) = Ast_builder.make core_type.ptyp_loc in\n let open Ast_builder in\n match core_type.ptyp_desc with\n | Ptyp_constr (lident, []) when is_bool_lident lident ->\n [%expr Ppx_dhall_type.Dhall_type.Bool]\n | Ptyp_constr (lident, []) when is_int_lident lident ->\n [%expr Ppx_dhall_type.Dhall_type.Integer]\n | Ptyp_constr (lident, []) when is_float_lident lident ->\n [%expr Ppx_dhall_type.Dhall_type.Double]\n | Ptyp_constr (lident, []) when is_string_lident lident ->\n [%expr Ppx_dhall_type.Dhall_type.Text]\n | Ptyp_constr (lident, [ ty ]) when is_option_lident lident ->\n [%expr Ppx_dhall_type.Dhall_type.Optional [%e dhall_type_of_core_type ty]]\n | Ptyp_constr (lident, [ ty ]) when is_list_lident lident ->\n [%expr Ppx_dhall_type.Dhall_type.List [%e dhall_type_of_core_type ty]]\n | Ptyp_constr ({ txt = Lident id; _ }, []) ->\n evar (id ^ \"_dhall_type\")\n | Ptyp_constr ({ txt = Lident id; _ }, params) ->\n let dhall_type_fun = evar (id ^ \"_dhall_type\") in\n let args = List.map params ~f:dhall_type_of_core_type in\n eapply dhall_type_fun args\n | Ptyp_constr ({ txt = Ldot (prefix, nm); _ }, []) ->\n let mod_path = Longident.name prefix in\n if String.equal nm \"t\" then evar (mod_path ^ \".dhall_type\")\n else evar (mod_path ^ \".\" ^ nm ^ \"_dhall_type\")\n | Ptyp_constr ({ txt = Ldot (prefix, nm); _ }, params) ->\n let mod_path = Longident.name prefix in\n let dhall_type_fun =\n if String.equal nm \"t\" then evar (mod_path ^ \".dhall_type\")\n else evar (mod_path ^ \".\" ^ nm ^ \"_dhall_type\")\n in\n let args = List.map params ~f:dhall_type_of_core_type in\n eapply dhall_type_fun args\n | Ptyp_var a ->\n evar a\n | _ ->\n Location.raise_errorf ~loc:core_type.ptyp_loc \"Unsupported type\"\n\nlet dhall_variant_from_constructor_declaration ctor_decl =\n let (module Ast_builder) = Ast_builder.make ctor_decl.pcd_name.loc in\n let open Ast_builder in\n let name = estring @@ String.lowercase ctor_decl.pcd_name.txt in\n match ctor_decl.pcd_args with\n | Pcstr_tuple [] ->\n [%expr [%e name], None]\n | Pcstr_tuple [ ty ] ->\n [%expr [%e name], Some [%e dhall_type_of_core_type ty]]\n | Pcstr_tuple tys ->\n let tys_expr = elist (List.map tys ~f:dhall_type_of_core_type) in\n [%expr [%e name], Some (List [%e tys_expr])]\n | Pcstr_record _ ->\n Location.raise_errorf ~loc:ctor_decl.pcd_name.loc\n \"Records not yet supported\"\n\nlet dhall_field_from_label_declaration label_decl =\n let (module Ast_builder) = Ast_builder.make label_decl.pld_name.loc in\n let open Ast_builder in\n let name =\n match Attribute.get field_key_attr label_decl with\n | Some name ->\n estring name\n | None ->\n estring label_decl.pld_name.txt\n in\n let ty = dhall_type_of_core_type label_decl.pld_type in\n [%expr [%e name], [%e ty]]\n\nlet generate_dhall_type type_decl =\n let (module Ast_builder) = Ast_builder.make type_decl.ptype_loc in\n let open Ast_builder in\n let dhall_type =\n match type_decl.ptype_kind with\n | Ptype_abstract -> (\n match type_decl.ptype_manifest with\n | None ->\n Location.raise_errorf ~loc:type_decl.ptype_loc\n \"Abstract type declaration has no manifest (right-hand side)\"\n | Some core_type ->\n dhall_type_of_core_type core_type )\n | Ptype_variant ctor_decls ->\n [%expr\n Ppx_dhall_type.Dhall_type.Union\n [%e\n elist\n (List.map ctor_decls\n ~f:dhall_variant_from_constructor_declaration )]]\n | Ptype_record label_decls ->\n [%expr\n Ppx_dhall_type.Dhall_type.Record\n [%e\n elist (List.map label_decls ~f:dhall_field_from_label_declaration)]]\n | Ptype_open ->\n Location.raise_errorf ~loc:type_decl.ptype_loc\n \"Open types not supported\"\n in\n let ty_name =\n match type_decl.ptype_name.txt with\n | \"t\" ->\n pvar \"dhall_type\"\n | nm ->\n pvar (nm ^ \"_dhall_type\")\n in\n match type_decl.ptype_params with\n | [] ->\n [%stri let [%p ty_name] = [%e dhall_type]]\n | params ->\n let args =\n List.map params ~f:(fun (core_type, _variance) ->\n match core_type.ptyp_desc with\n | Ptyp_var a ->\n pvar a\n | _ ->\n Location.raise_errorf ~loc:type_decl.ptype_loc\n \"Type parameter not a type variable\" )\n in\n let abs = eabstract args dhall_type in\n [%stri let [%p ty_name] = [%e abs]]\n\nlet generate_dhall_types ~loc:_ ~path:_ (_rec_flag, type_decls) =\n List.map type_decls ~f:generate_dhall_type\n\nlet attributes = [ Attribute.T field_key_attr ]\n\nlet str_type_decl =\n Deriving.Generator.make_noarg ~attributes generate_dhall_types\n\nlet () = Deriving.add deriver ~str_type_decl |> Ppxlib.Deriving.ignore\n","(** Global slot span implementation *)\n\nopen Core_kernel\n\n(** See documentation of the {!Mina_wire_types} library *)\nmodule Wire_types = Mina_wire_types.Mina_numbers.Global_slot_span\n\ntype uint32 = Unsigned.uint32\n\nmodule Make_sig (A : Wire_types.Types.S) = struct\n module type S = sig\n include Global_slot_intf.S_span with type Stable.V1.t = A.V1.t\n end\nend\n\nmodule T = Nat.Make32 ()\n\nmodule Make_str (_ : Wire_types.Concrete) = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Wire_types.global_slot_span = Global_slot_span of T.Stable.V1.t\n [@@unboxed] [@@deriving hash, sexp, compare, equal, yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n let to_uint32 (Global_slot_span u32) : uint32 = u32\n\n let of_uint32 u32 : t = Global_slot_span u32\n\n module Checked = struct\n include T.Checked\n\n let constant t = constant @@ to_uint32 t\n\n let typ =\n Snark_params.Tick.Typ.transport T.Checked.typ ~there:to_uint32\n ~back:of_uint32\n end\n\n let to_string t = Unsigned.UInt32.to_string @@ to_uint32 t\n\n let of_string s = of_uint32 @@ Unsigned.UInt32.of_string s\n\n let typ = Checked.typ\n\n let gen =\n let%map.Quickcheck u32 = T.gen in\n of_uint32 u32\n\n let gen_incl t1 t2 =\n let u32_1 = to_uint32 t1 in\n let u32_2 = to_uint32 t2 in\n let%map.Quickcheck u32 = T.gen_incl u32_1 u32_2 in\n of_uint32 u32\n\n let dhall_type = Ppx_dhall_type.Dhall_type.Text\n\n let zero = of_uint32 T.zero\n\n let one = of_uint32 T.one\n\n let succ t = of_uint32 (T.succ @@ to_uint32 t)\n\n let max_value = of_uint32 Unsigned.UInt32.max_int\n\n let to_field t = T.to_field (to_uint32 t)\n\n let to_input t = T.to_input (to_uint32 t)\n\n let to_input_legacy t = T.to_input_legacy (to_uint32 t)\n\n include Comparable.Make (Stable.Latest)\n\n let add t1 t2 =\n let u32_1 = to_uint32 t1 in\n let u32_2 = to_uint32 t2 in\n let sum = T.add u32_1 u32_2 in\n of_uint32 sum\n\n let sub t1 t2 =\n let u32_1 = to_uint32 t1 in\n let u32_2 = to_uint32 t2 in\n Option.map (T.sub u32_1 u32_2) ~f:of_uint32\n\n let of_int n = of_uint32 (T.of_int n)\n\n let to_int t = T.to_int (to_uint32 t)\n\n let random () = of_uint32 (T.random ())\nend\n\ninclude Wire_types.Make (Make_sig) (Make_str)\n","(** Global slot (since genesis) implementation *)\n\nopen Core_kernel\n\n(** See documentation of the {!Mina_wire_types} library *)\nmodule Wire_types = Mina_wire_types.Mina_numbers.Global_slot_since_genesis\n\ntype uint32 = Unsigned.uint32\n\nmodule Make_sig (A : Wire_types.Types.S) = struct\n module type S = sig\n include\n Global_slot_intf.S\n with type Stable.V1.t = A.V1.t\n and type global_slot_span = Global_slot_span.t\n and type Checked.global_slot_span_checked = Global_slot_span.Checked.t\n end\nend\n\nmodule T = Nat.Make32 ()\n\nmodule Make_str (_ : Wire_types.Concrete) = struct\n module M = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Wire_types.global_slot = Since_genesis of T.Stable.V1.t\n [@@unboxed] [@@deriving hash, sexp, compare, equal, yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n module T = T\n\n let to_uint32 (Since_genesis u32) : uint32 = u32\n\n let of_uint32 u32 : t = Since_genesis u32\n end\n\n include M\n include Global_slot.Make (M)\nend\n\ninclude Wire_types.Make (Make_sig) (Make_str)\n","(** Global slot (since hard fork) implementation *)\n\nopen Core_kernel\n\n(** See documentation of the {!Mina_wire_types} library *)\nmodule Wire_types = Mina_wire_types.Mina_numbers.Global_slot_since_hard_fork\n\ntype uint32 = Unsigned.uint32\n\nmodule Make_sig (A : Wire_types.Types.S) = struct\n module type S = sig\n include\n Global_slot_intf.S\n with type Stable.V1.t = A.V1.t\n and type global_slot_span = Global_slot_span.t\n and type Checked.global_slot_span_checked = Global_slot_span.Checked.t\n end\nend\n\nmodule T = Nat.Make32 ()\n\nmodule Make_str (_ : Wire_types.Concrete) = struct\n module M = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Wire_types.global_slot = Since_hard_fork of T.Stable.V1.t\n [@@unboxed] [@@deriving hash, sexp, compare, equal, yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n module T = T\n\n let to_uint32 (Since_hard_fork u32) : uint32 = u32\n\n let of_uint32 u32 : t = Since_hard_fork u32\n end\n\n include M\n include Global_slot.Make (M)\nend\n\ninclude Wire_types.Make (Make_sig) (Make_str)\n","open Core_kernel\n\n[%%versioned\nmodule Stable = struct\n module V1 = struct\n type ('magnitude, 'sgn) t =\n ('magnitude, 'sgn) Mina_wire_types.Signed_poly.V1.t =\n { magnitude : 'magnitude; sgn : 'sgn }\n [@@deriving annot, sexp, hash, compare, equal, yojson, fields]\n end\nend]\n\nlet map ~f { magnitude; sgn } = { magnitude = f magnitude; sgn }\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Snark_bits\nopen Snark_params\nopen Tick\n\n[%%ifdef consensus_mechanism]\n\nopen Bitstring_lib\nopen Let_syntax\n\n[%%endif]\n\nopen Intf\n\n(** [Currency_oveflow] is being thrown to signal an overflow\n or underflow during conversions from [int] to currency.\n The exception contains the [int] value that caused the\n misbehaviour. *)\nexception Currency_overflow of int\n\ntype uint64 = Unsigned.uint64\n\n(** See documentation of the {!Mina_wire_types} library *)\nmodule Wire_types = Mina_wire_types.Currency\n\n(** Define the expected full signature of the module, based on the types defined\n in {!Mina_wire_types} *)\nmodule Make_sig (A : Wire_types.Types.S) = struct\n module type S =\n Intf.Full\n (* full interface defined in a separate file, as it would appear\n in the MLI *)\n with type Fee.Stable.V1.t = A.Fee.V1.t\n (* with added type equalities *)\n and type Amount.Stable.V1.t = A.Amount.V1.t\n and type Balance.Stable.V1.t = A.Balance.V1.t\nend\n\n(** Then we make the real module, which has to have a signature of type\n {!Make_sig(A)}. Here, since all types are simple type aliases, we don't need\n to use [A] in the implementation. Otherwise, we would need to add type\n equalities to the corresponding type in [A] in each type definition. *)\nmodule Make_str (A : Wire_types.Concrete) = struct\n module Signed_poly = Signed_poly\n\n [%%ifdef consensus_mechanism]\n\n module Signed_var = struct\n type 'mag repr = ('mag, Sgn.var) Signed_poly.t\n\n (* Invariant: At least one of these is Some *)\n type nonrec 'mag t =\n { repr : 'mag repr; mutable value : Field.Var.t option }\n end\n\n [%%endif]\n\n module Make (Unsigned : sig\n include Unsigned_extended.S\n\n val to_uint64 : t -> uint64\n\n val of_uint64 : uint64 -> t\n end) (M : sig\n val length : int\n end) : sig\n [%%ifdef consensus_mechanism]\n\n include\n S\n with type t = Unsigned.t\n and type var = Field.Var.t\n and type Signed.var = Field.Var.t Signed_var.t\n and type Signed.signed_fee = (Unsigned.t, Sgn.t) Signed_poly.t\n and type Signed.Checked.signed_fee_var = Field.Var.t Signed_var.t\n\n val pack_var : var -> Field.Var.t\n\n [%%else]\n\n include\n S\n with type t = Unsigned.t\n and type Signed.signed_fee := (Unsigned.t, Sgn.t) Signed_poly.t\n\n [%%endif]\n\n val scale : t -> int -> t option\n end = struct\n let max_int = Unsigned.max_int\n\n let length_in_bits = M.length\n\n type t = Unsigned.t [@@deriving sexp, compare, hash]\n\n (* can't be automatically derived *)\n let dhall_type = Ppx_dhall_type.Dhall_type.Text\n\n [%%define_locally\n Unsigned.(to_uint64, of_uint64, of_int, to_int, of_string, to_string)]\n\n let precision = 9\n\n let precision_exp = Unsigned.of_int @@ Int.pow 10 precision\n\n let to_mina_string amount =\n let rec go num_stripped_zeros num =\n let open Int in\n if num mod 10 = 0 && num <> 0 then go (num_stripped_zeros + 1) (num / 10)\n else (num_stripped_zeros, num)\n in\n\n let whole = Unsigned.div amount precision_exp in\n let remainder = Unsigned.to_int (Unsigned.rem amount precision_exp) in\n if Int.(remainder = 0) then to_string whole\n else\n let num_stripped_zeros, num = go 0 remainder in\n Printf.sprintf \"%s.%0*d\" (to_string whole)\n Int.(precision - num_stripped_zeros)\n num\n\n let of_mina_string_exn input =\n let parts = String.split ~on:'.' input in\n match parts with\n | [ whole ] ->\n of_string (whole ^ String.make precision '0')\n | [ whole; decimal ] ->\n let decimal_length = String.length decimal in\n if Int.(decimal_length > precision) then\n of_string (whole ^ String.sub decimal ~pos:0 ~len:precision)\n else\n of_string\n ( whole ^ decimal\n ^ String.make Int.(precision - decimal_length) '0' )\n | _ ->\n failwith \"Currency.of_mina_string_exn: Invalid currency input\"\n\n module Arg = struct\n type typ = t [@@deriving sexp, hash, compare]\n\n type t = typ [@@deriving sexp, hash, compare]\n\n let to_string = to_mina_string\n\n let of_string = of_mina_string_exn\n end\n\n include Codable.Make_of_string (Arg)\n include Hashable.Make (Arg)\n include Comparable.Make (Arg)\n\n let gen_incl a b : t Quickcheck.Generator.t =\n let a = Bignum_bigint.of_string Unsigned.(to_string a) in\n let b = Bignum_bigint.of_string Unsigned.(to_string b) in\n Quickcheck.Generator.map\n Bignum_bigint.(gen_incl a b)\n ~f:(fun n -> of_string (Bignum_bigint.to_string n))\n\n let gen : t Quickcheck.Generator.t =\n let m = Bignum_bigint.of_string Unsigned.(to_string max_int) in\n Quickcheck.Generator.map\n Bignum_bigint.(gen_incl zero m)\n ~f:(fun n -> of_string (Bignum_bigint.to_string n))\n\n module Vector = struct\n include M\n include Unsigned\n\n let empty = zero\n\n let get t i = Infix.((t lsr i) land one = one)\n\n let set v i b =\n if b then Infix.(v lor (one lsl i))\n else Infix.(v land lognot (one lsl i))\n end\n\n module B = Bits.Vector.Make (Vector)\n\n include (B : Bits_intf.Convertible_bits with type t := t)\n\n [%%ifdef consensus_mechanism]\n\n type var = Field.Var.t\n\n let pack_var = Fn.id\n\n let equal_var = Field.Checked.equal\n\n let m = Snark_params.Tick.m\n\n let make_checked = Snark_params.Tick.make_checked\n\n let var_to_bits_ (t : var) = Field.Checked.unpack ~length:length_in_bits t\n\n let var_to_bits t = var_to_bits_ t >>| Bitstring.Lsb_first.of_list\n\n let var_to_input (t : var) =\n Random_oracle.Input.Chunked.packed (t, length_in_bits)\n\n let var_to_input_legacy (t : var) =\n var_to_bits_ t >>| Random_oracle.Input.Legacy.bitstring\n\n let var_of_t (t : t) : var = Field.Var.constant (Field.project (to_bits t))\n\n let if_ cond ~then_ ~else_ : var Checked.t =\n Field.Checked.if_ cond ~then_ ~else_\n\n let () = assert (Int.(length_in_bits mod 16 = 0))\n\n (** UNSAFE. Take the field element formed by the final [length_in_bits] bits\n of the argument.\n\n WARNING: The returned value may be chosen arbitrarily by a malicious\n prover, and this is really only useful for the more-efficient bit\n projection. Users of this function must manually assert the relationship\n between the argument and the return value, or the circuit will be\n underconstrained.\n *)\n let image_from_bits_unsafe (t : var) =\n make_checked (fun () ->\n let _, _, actual_packed =\n Pickles.Scalar_challenge.to_field_checked' ~num_bits:length_in_bits\n m\n (Kimchi_backend_common.Scalar_challenge.create t)\n in\n actual_packed )\n\n (** [range_check t] asserts that [0 <= t < 2^length_in_bits].\n\n Any value consumed or returned by functions in this module must satisfy\n this assertion.\n *)\n let range_check t =\n let%bind actual = image_from_bits_unsafe t in\n with_label \"range_check\" (fun () -> Field.Checked.Assert.equal actual t)\n\n let seal x = make_checked (fun () -> Pickles.Util.seal Tick.m x)\n\n let modulus_as_field =\n lazy (Fn.apply_n_times ~n:length_in_bits Field.(mul (of_int 2)) Field.one)\n\n let double_modulus_as_field =\n lazy (Field.(mul (of_int 2)) (Lazy.force modulus_as_field))\n\n (** [range_check_flagged kind t] returns [t'] that fits in [length_in_bits]\n bits, and satisfies [t' = t + k * 2^length_in_bits] for some [k].\n The [`Overflow b] return value is false iff [t' = t].\n\n This function should be used when [t] was computed via addition or\n subtraction, to calculate the equivalent value that would be returned by\n overflowing or underflowing an integer with [length_in_bits] bits.\n\n The [`Add] and [`Sub] values for [kind] are specializations that use\n fewer constraints and perform fewer calculations. Any inputs that satisfy\n the invariants for [`Add] or [`Sub] will return the same value if\n [`Add_or_sub] is used instead.\n\n Invariants:\n * if [kind] is [`Add], [0 <= t < 2 * 2^length_in_bits - 1];\n * if [kind] is [`Sub], [- 2^length_in_bits < t < 2^length_in_bits];\n * if [kind] is [`Add_or_sub],\n [- 2^length_in_bits < t < 2 * 2^length_in_bits - 1].\n *)\n let range_check_flagged (kind : [ `Add | `Sub | `Add_or_sub ]) t =\n let%bind adjustment_factor =\n exists Field.typ\n ~compute:\n As_prover.(\n let%map t = read Field.typ t in\n match kind with\n | `Add ->\n if Int.(Field.compare t (Lazy.force modulus_as_field) < 0)\n then (* Within range. *)\n Field.zero\n else\n (* Overflowed. We compensate by subtracting [modulus_as_field]. *)\n Field.(negate one)\n | `Sub ->\n if Int.(Field.compare t (Lazy.force modulus_as_field) < 0)\n then (* Within range. *)\n Field.zero\n else\n (* Underflowed, but appears as an overflow because of wrapping in\n the field (that is, -1 is the largest field element, -2 is the\n second largest, etc.). Compensate by adding [modulus_as_field].\n *)\n Field.one\n | `Add_or_sub ->\n (* This case is a little more nuanced: -modulus_as_field < t <\n 2*modulus_as_field, and we need to detect which 'side of 0' we\n are. Thus, we have 3 cases:\n *)\n if Int.(Field.compare t (Lazy.force modulus_as_field) < 0)\n then\n (* 1. we are already in the desired range, no adjustment; *)\n Field.zero\n else if\n Int.(\n Field.compare t (Lazy.force double_modulus_as_field) < 0)\n then\n (* 2. we are in the range\n [modulus_as_field <= t < 2 * modulus_as_field],\n so this was an addition that overflowed, and we should\n compensate by subtracting [modulus_as_field];\n *)\n Field.(negate one)\n else\n (* 3. we are outside of either range, so this must be the\n underflow of a subtraction, and we should compensate by\n adding [modulus_as_field].\n *)\n Field.one)\n in\n let%bind out_of_range =\n match kind with\n | `Add ->\n (* 0 or -1 => 0 or 1 *)\n Boolean.of_field (Field.Var.negate adjustment_factor)\n | `Sub ->\n (* Already 0 or 1 *)\n Boolean.of_field adjustment_factor\n | `Add_or_sub ->\n (* The return flag [out_of_range] is a boolean represented by either 0\n when [t] is in range or 1 when [t] is out-of-range.\n Notice that [out_of_range = adjustment_factor^2] gives us exactly\n the desired values, and moreover we can ensure that\n [adjustment_factor] is exactly one of -1, 0 or 1 by checking that\n [out_of_range] is boolean.\n *)\n Field.Checked.mul adjustment_factor adjustment_factor\n >>= Boolean.of_field\n in\n (* [t_adjusted = t + adjustment_factor * modulus_as_field] *)\n let t_adjusted =\n let open Field.Var in\n add t (scale adjustment_factor (Lazy.force modulus_as_field))\n in\n let%bind t_adjusted = seal t_adjusted in\n let%map () = range_check t_adjusted in\n (t_adjusted, `Overflow out_of_range)\n\n let of_field (x : Field.t) : t =\n of_bits (List.take (Field.unpack x) length_in_bits)\n\n let to_field (x : t) : Field.t = Field.project (to_bits x)\n\n let typ : (var, t) Typ.t =\n let (Typ typ) = Field.typ in\n Typ.transport\n (Typ { typ with check = range_check })\n ~there:to_field ~back:of_field\n\n [%%endif]\n\n let zero = Unsigned.zero\n\n let one = Unsigned.one\n\n (* The number of nanounits in a unit. User for unit transformations. *)\n let unit_to_nano = 1_000_000_000\n\n let to_nanomina_int = to_int\n\n let to_mina_int m = to_int m / unit_to_nano\n\n let sub x y = if x < y then None else Some (Unsigned.sub x y)\n\n let sub_flagged x y =\n let z = Unsigned.sub x y in\n (z, `Underflow (x < y))\n\n let add x y =\n let z = Unsigned.add x y in\n if z < x then None else Some z\n\n let add_flagged x y =\n let z = Unsigned.add x y in\n (z, `Overflow (z < x))\n\n let add_signed_flagged x y =\n match y.Signed_poly.sgn with\n | Sgn.Pos ->\n let z, `Overflow b = add_flagged x y.Signed_poly.magnitude in\n (z, `Overflow b)\n | Sgn.Neg ->\n let z, `Underflow b = sub_flagged x y.Signed_poly.magnitude in\n (z, `Overflow b)\n\n let scale u64 i =\n if Int.(i = 0) then Some zero\n else\n let i = Unsigned.of_int i in\n let max_val = Unsigned.(div max_int i) in\n if max_val >= u64 then Some (Unsigned.mul u64 i) else None\n\n let ( + ) = add\n\n let ( - ) = sub\n\n (* The functions below are unsafe, because they could overflow or\n underflow. They perform appropriate checks to guard against this\n and either raise Currency_overflow exception or return None\n depending on the error-handling strategy.\n\n It is advisable to use nanomina and mina wherever possible and\n limit the use of _exn veriants to places where a fixed value is\n being converted and hence overflow cannot happen. *)\n let of_nanomina_int i = if Int.(i >= 0) then Some (of_int i) else None\n\n let of_mina_int i =\n Option.(of_nanomina_int i >>= Fn.flip scale unit_to_nano)\n\n let of_nanomina_int_exn i =\n match of_nanomina_int i with\n | None ->\n raise (Currency_overflow i)\n | Some m ->\n m\n\n let of_mina_int_exn i =\n match of_mina_int i with\n | None ->\n raise (Currency_overflow i)\n | Some m ->\n m\n\n type magnitude = t [@@deriving sexp, hash, compare, yojson]\n\n let to_input (t : t) =\n Random_oracle.Input.Chunked.packed\n (Field.project (to_bits t), length_in_bits)\n\n let to_input_legacy t = Random_oracle.Input.Legacy.bitstring @@ to_bits t\n\n module Signed = struct\n type ('magnitude, 'sgn) typ = ('magnitude, 'sgn) Signed_poly.t =\n { magnitude : 'magnitude; sgn : 'sgn }\n [@@deriving sexp, hash, compare, yojson, hlist]\n\n type t = (Unsigned.t, Sgn.t) Signed_poly.t [@@deriving sexp, hash, yojson]\n\n let compare : t -> t -> int =\n let cmp = [%compare: (Unsigned.t, Sgn.t) Signed_poly.t] in\n fun t1 t2 ->\n if Unsigned.(equal t1.magnitude zero && equal t2.magnitude zero) then\n 0\n else cmp t1 t2\n\n let equal : t -> t -> bool =\n let eq = [%equal: (Unsigned.t, Sgn.t) Signed_poly.t] in\n fun t1 t2 ->\n if Unsigned.(equal t1.magnitude zero && equal t2.magnitude zero) then\n true\n else eq t1 t2\n\n let is_zero (t : t) : bool = Unsigned.(equal t.magnitude zero)\n\n let is_positive (t : t) : bool =\n match t.sgn with\n | Pos ->\n not Unsigned.(equal zero t.magnitude)\n | Neg ->\n false\n\n let is_negative (t : t) : bool =\n match t.sgn with\n | Neg ->\n not Unsigned.(equal zero t.magnitude)\n | Pos ->\n false\n\n type magnitude = Unsigned.t [@@deriving sexp, compare]\n\n let create ~magnitude ~sgn =\n { magnitude\n ; sgn = (if Unsigned.(equal magnitude zero) then Sgn.Pos else sgn)\n }\n\n let sgn { sgn; _ } = sgn\n\n let magnitude { magnitude; _ } = magnitude\n\n let zero : t = { magnitude = zero; sgn = Sgn.Pos }\n\n let gen =\n Quickcheck.Generator.map2 gen Sgn.gen ~f:(fun magnitude sgn ->\n create ~magnitude ~sgn )\n\n let sgn_to_bool = function Sgn.Pos -> true | Neg -> false\n\n let to_bits ({ sgn; magnitude } : t) =\n sgn_to_bool sgn :: to_bits magnitude\n\n let to_input { sgn; magnitude } =\n Random_oracle.Input.Chunked.(\n append (to_input magnitude)\n (packed (Field.project [ sgn_to_bool sgn ], 1)))\n\n let to_input_legacy t = Random_oracle.Input.Legacy.bitstring (to_bits t)\n\n let add (x : t) (y : t) : t option =\n match (x.sgn, y.sgn) with\n | Neg, (Neg as sgn) | Pos, (Pos as sgn) ->\n let open Option.Let_syntax in\n let%map magnitude = add x.magnitude y.magnitude in\n create ~sgn ~magnitude\n | Pos, Neg | Neg, Pos ->\n let c = compare_magnitude x.magnitude y.magnitude in\n Some\n ( if Int.( < ) c 0 then\n create ~sgn:y.sgn\n ~magnitude:Unsigned.Infix.(y.magnitude - x.magnitude)\n else if Int.( > ) c 0 then\n create ~sgn:x.sgn\n ~magnitude:Unsigned.Infix.(x.magnitude - y.magnitude)\n else zero )\n\n let add_flagged (x : t) (y : t) : t * [ `Overflow of bool ] =\n match (x.sgn, y.sgn) with\n | Neg, (Neg as sgn) | Pos, (Pos as sgn) ->\n let magnitude, `Overflow b = add_flagged x.magnitude y.magnitude in\n (create ~sgn ~magnitude, `Overflow b)\n | Pos, Neg | Neg, Pos ->\n let c = compare_magnitude x.magnitude y.magnitude in\n ( ( if Int.( < ) c 0 then\n create ~sgn:y.sgn\n ~magnitude:Unsigned.Infix.(y.magnitude - x.magnitude)\n else if Int.( > ) c 0 then\n create ~sgn:x.sgn\n ~magnitude:Unsigned.Infix.(x.magnitude - y.magnitude)\n else zero )\n , `Overflow false )\n\n let negate t =\n if Unsigned.(equal zero t.magnitude) then zero\n else { t with sgn = Sgn.negate t.sgn }\n\n let of_unsigned magnitude : t = create ~magnitude ~sgn:Sgn.Pos\n\n let ( + ) = add\n\n let to_fee = Fn.id\n\n let of_fee = Fn.id\n\n [%%ifdef consensus_mechanism]\n\n type signed_fee = t\n\n let magnitude_to_field = to_field\n\n let to_field (t : t) : Field.t =\n Field.mul (Sgn.to_field t.sgn) (magnitude_to_field t.magnitude)\n\n type repr = var Signed_var.repr\n\n type nonrec var = var Signed_var.t\n\n let repr_typ : (repr, t) Typ.t =\n Typ.of_hlistable [ typ; Sgn.typ ] ~var_to_hlist:typ_to_hlist\n ~var_of_hlist:typ_of_hlist ~value_to_hlist:typ_to_hlist\n ~value_of_hlist:typ_of_hlist\n\n let typ : (var, t) Typ.t =\n Typ.transport_var repr_typ\n ~back:(fun repr -> { Signed_var.value = None; repr })\n ~there:(fun { Signed_var.repr; _ } -> repr)\n\n let create_var ~magnitude ~sgn : var =\n { repr = { magnitude; sgn }; value = None }\n\n module Checked = struct\n type t = var\n\n type signed_fee_var = t\n\n let repr (t : var) = Checked.return t.repr\n\n let value (t : var) =\n match t.value with\n | Some x ->\n Checked.return x\n | None ->\n let r = t.repr in\n let%map x =\n Field.Checked.mul (r.sgn :> Field.Var.t) r.magnitude\n in\n t.value <- Some x ;\n x\n\n let to_field_var = value\n\n let to_input t =\n let%map { magnitude; sgn } = repr t in\n let mag = var_to_input magnitude in\n Random_oracle.Input.Chunked.(\n append mag (packed ((Sgn.Checked.is_pos sgn :> Field.Var.t), 1)))\n\n let to_input_legacy t =\n let to_bits { magnitude; sgn } =\n let%map magnitude = var_to_bits_ magnitude in\n Sgn.Checked.is_pos sgn :: magnitude\n in\n repr t >>= to_bits >>| Random_oracle.Input.Legacy.bitstring\n\n let constant ({ magnitude; sgn } as t) =\n { Signed_var.repr =\n { magnitude = var_of_t magnitude; sgn = Sgn.Checked.constant sgn }\n ; value = Some (Field.Var.constant (to_field t))\n }\n\n let of_unsigned magnitude : var =\n { repr = { magnitude; sgn = Sgn.Checked.pos }\n ; value = Some magnitude\n }\n\n let negate (t : var) : var =\n { value = Option.map t.value ~f:Field.Var.negate\n ; repr =\n (let { magnitude; sgn } = t.repr in\n { magnitude; sgn = Sgn.Checked.negate sgn } )\n }\n\n let if_repr cond ~then_ ~else_ =\n let%map sgn = Sgn.Checked.if_ cond ~then_:then_.sgn ~else_:else_.sgn\n and magnitude =\n if_ cond ~then_:then_.magnitude ~else_:else_.magnitude\n in\n { sgn; magnitude }\n\n let if_ cond ~(then_ : var) ~(else_ : var) : var Checked.t =\n let%bind repr = if_repr cond ~then_:then_.repr ~else_:else_.repr in\n let%map value =\n match (then_.value, else_.value) with\n | Some v1, Some v2 ->\n Field.Checked.if_ cond ~then_:v1 ~else_:v2 >>| Option.return\n | _ ->\n return None\n in\n { Signed_var.value; repr }\n\n let sgn (t : var) =\n let%map r = repr t in\n r.sgn\n\n let magnitude (t : var) =\n let%map r = repr t in\n r.magnitude\n\n let add_flagged (x : var) (y : var) =\n let%bind xv = value x and yv = value y in\n let%bind sgn =\n exists Sgn.typ\n ~compute:\n (let open As_prover in\n let%map x = read typ x and y = read typ y in\n match add x y with\n | Some r ->\n r.sgn\n | None -> (\n match (x.sgn, y.sgn) with\n | Sgn.Neg, Sgn.Neg ->\n (* Ensure that we provide a value in the range\n [-modulus_as_field < magnitude < 2*modulus_as_field]\n for [range_check_flagged].\n *)\n Sgn.Neg\n | _ ->\n Sgn.Pos ))\n in\n let value = Field.Var.add xv yv in\n let%bind magnitude =\n Tick.Field.Checked.mul (sgn :> Field.Var.t) value\n in\n let%bind res_magnitude, `Overflow overflow =\n range_check_flagged `Add_or_sub magnitude\n in\n (* Recompute the result from [res_magnitude], since it may have been\n adjusted.\n *)\n let%map res_value =\n Field.Checked.mul (sgn :> Field.Var.t) magnitude\n in\n ( { Signed_var.repr = { magnitude = res_magnitude; sgn }\n ; value = Some res_value\n }\n , `Overflow overflow )\n\n let add (x : var) (y : var) =\n let%bind xv = value x and yv = value y in\n let%bind sgn =\n exists Sgn.typ\n ~compute:\n (let open As_prover in\n let%map x = read typ x and y = read typ y in\n Option.value_map (add x y) ~default:Sgn.Pos ~f:(fun r -> r.sgn))\n in\n let%bind res_value = seal (Field.Var.add xv yv) in\n let%bind magnitude =\n Tick.Field.Checked.mul (sgn :> Field.Var.t) res_value\n in\n let%map () = range_check magnitude in\n { Signed_var.repr = { magnitude; sgn }; value = Some res_value }\n\n let ( + ) = add\n\n let equal (t1 : var) (t2 : var) =\n let%bind t1 = value t1 and t2 = value t2 in\n Field.Checked.equal t1 t2\n\n let assert_equal (t1 : var) (t2 : var) =\n let%bind t1 = value t1 and t2 = value t2 in\n Field.Checked.Assert.equal t1 t2\n\n let to_fee = Fn.id\n\n let of_fee = Fn.id\n end\n\n [%%endif]\n end\n\n [%%ifdef consensus_mechanism]\n\n module Checked = struct\n module N = Mina_numbers.Nat.Make_checked (Unsigned) (B)\n\n type t = var\n\n let if_ = if_\n\n (* Unpacking protects against underflow *)\n let sub (x : var) (y : var) =\n let%bind res = seal (Field.Var.sub x y) in\n let%map () = range_check res in\n res\n\n let sub_flagged x y =\n let%bind z = seal (Field.Var.sub x y) in\n let%map z, `Overflow underflow = range_check_flagged `Sub z in\n (z, `Underflow underflow)\n\n let sub_or_zero x y =\n let%bind res, `Underflow underflow = sub_flagged x y in\n Field.Checked.if_ underflow ~then_:Field.(Var.constant zero) ~else_:res\n\n let assert_equal x y = Field.Checked.Assert.equal x y\n\n let equal x y = Field.Checked.equal x y\n\n let ( = ) = equal\n\n let ( < ) x y =\n let%bind diff = seal (Field.Var.sub x y) in\n (* [lt] is true iff [x - y < 0], ie. [x < y] *)\n let%map _res, `Overflow lt = range_check_flagged `Sub diff in\n lt\n\n (* x <= y iff not (y < x) *)\n let ( <= ) x y =\n let%map y_lt_x = y < x in\n Boolean.not y_lt_x\n\n (* x >= y iff y <= x *)\n let ( >= ) x y = y <= x\n\n let ( > ) x y = y < x\n\n (* Unpacking protects against overflow *)\n let add (x : var) (y : var) =\n let%bind res = seal (Field.Var.add x y) in\n let%map () = range_check res in\n res\n\n let add_flagged x y =\n let%bind z = seal (Field.Var.add x y) in\n let%map z, `Overflow overflow = range_check_flagged `Add z in\n (z, `Overflow overflow)\n\n let ( - ) = sub\n\n let ( + ) = add\n\n let add_signed (t : var) (d : Signed.var) =\n let%bind d = Signed.Checked.to_field_var d in\n let%bind res = seal (Field.Var.add t d) in\n let%map () = range_check res in\n res\n\n let add_signed_flagged (t : var) (d : Signed.var) =\n let%bind d = Signed.Checked.to_field_var d in\n let%bind res = seal (Field.Var.add t d) in\n let%map res, `Overflow overflow = range_check_flagged `Add_or_sub res in\n (res, `Overflow overflow)\n\n let scale (f : Field.Var.t) (t : var) =\n let%bind res = Field.Checked.mul t f in\n let%map () = range_check res in\n res\n\n let%test_module \"currency_test\" =\n ( module struct\n let expect_failure err c =\n if Or_error.is_ok (check c) then failwith err\n\n let expect_success err c =\n match check c with\n | Ok () ->\n ()\n | Error e ->\n Error.(raise (tag ~tag:err e))\n\n let to_bigint x = Bignum_bigint.of_string (Unsigned.to_string x)\n\n let of_bigint x = Unsigned.of_string (Bignum_bigint.to_string x)\n\n let gen_incl x y =\n Quickcheck.Generator.map ~f:of_bigint\n (Bignum_bigint.gen_incl (to_bigint x) (to_bigint y))\n\n let shrinker =\n Quickcheck.Shrinker.create (fun i ->\n Sequence.unfold ~init:i ~f:(fun i ->\n if Unsigned.equal i Unsigned.zero then None\n else\n let n = Unsigned.div i (Unsigned.of_int 10) in\n Some (n, n) ) )\n\n (* TODO: When we do something to make snarks run fast for tests, increase the trials *)\n let qc_test_fast = Quickcheck.test ~trials:100\n\n let%test_unit \"subtraction_completeness\" =\n let generator =\n let open Quickcheck.Generator.Let_syntax in\n let%bind x = gen_incl Unsigned.zero Unsigned.max_int in\n let%map y = gen_incl Unsigned.zero x in\n (x, y)\n in\n qc_test_fast generator ~f:(fun (lo, hi) ->\n expect_success\n (sprintf !\"subtraction: lo=%{Unsigned} hi=%{Unsigned}\" lo hi)\n (var_of_t lo - var_of_t hi) )\n\n let%test_unit \"subtraction_soundness\" =\n let generator =\n let open Quickcheck.Generator.Let_syntax in\n let%bind x = gen_incl Unsigned.zero Unsigned.(sub max_int one) in\n let%map y = gen_incl Unsigned.(add x one) Unsigned.max_int in\n (x, y)\n in\n qc_test_fast generator ~f:(fun (lo, hi) ->\n expect_failure\n (sprintf !\"underflow: lo=%{Unsigned} hi=%{Unsigned}\" lo hi)\n (var_of_t lo - var_of_t hi) )\n\n let%test_unit \"addition_completeness\" =\n let generator =\n let open Quickcheck.Generator.Let_syntax in\n let%bind x = gen_incl Unsigned.zero Unsigned.max_int in\n let%map y = gen_incl Unsigned.zero Unsigned.(sub max_int x) in\n (x, y)\n in\n qc_test_fast generator ~f:(fun (x, y) ->\n expect_success\n (sprintf !\"overflow: x=%{Unsigned} y=%{Unsigned}\" x y)\n (var_of_t x + var_of_t y) )\n\n let%test_unit \"addition_soundness\" =\n let generator =\n let open Quickcheck.Generator.Let_syntax in\n let%bind x = gen_incl Unsigned.one Unsigned.max_int in\n let%map y =\n gen_incl Unsigned.(add (sub max_int x) one) Unsigned.max_int\n in\n (x, y)\n in\n qc_test_fast generator ~f:(fun (x, y) ->\n expect_failure\n (sprintf !\"overflow: x=%{Unsigned} y=%{Unsigned}\" x y)\n (var_of_t x + var_of_t y) )\n\n let%test_unit \"formatting_roundtrip\" =\n let generator = gen_incl Unsigned.zero Unsigned.max_int in\n qc_test_fast generator ~shrinker ~f:(fun num ->\n match of_mina_string_exn (to_mina_string num) with\n | after_format ->\n if Unsigned.equal after_format num then ()\n else\n Error.(\n raise\n (of_string\n (sprintf\n !\"formatting: num=%{Unsigned} middle=%{String} \\\n after=%{Unsigned}\"\n num (to_mina_string num) after_format ) ))\n | exception e ->\n let err = Error.of_exn e in\n Error.(\n raise\n (tag\n ~tag:(sprintf !\"formatting: num=%{Unsigned}\" num)\n err )) )\n\n let%test_unit \"formatting_trailing_zeros\" =\n let generator = gen_incl Unsigned.zero Unsigned.max_int in\n qc_test_fast generator ~shrinker ~f:(fun num ->\n let formatted = to_mina_string num in\n let has_decimal = String.contains formatted '.' in\n let trailing_zero = String.is_suffix formatted ~suffix:\"0\" in\n if has_decimal && trailing_zero then\n Error.(\n raise\n (of_string\n (sprintf\n !\"formatting: num=%{Unsigned} formatted=%{String}\"\n num (to_mina_string num) ) )) )\n end )\n end\n\n [%%endif]\n end\n\n let currency_length = 64\n\n module Fee = struct\n module T =\n Make\n (Unsigned_extended.UInt64)\n (struct\n let length = currency_length\n end)\n\n include T\n\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n [@@@with_all_version_tags]\n\n type t = Unsigned_extended.UInt64.Stable.V1.t\n [@@deriving sexp, compare, hash, equal]\n\n [%%define_from_scope to_yojson, of_yojson, dhall_type]\n\n let to_latest = Fn.id\n end\n end]\n\n let (_ : (Signed.t, (t, Sgn.t) Signed_poly.t) Type_equal.t) = Type_equal.T\n\n let minimum_user_command_fee =\n of_mina_string_exn Mina_compile_config.minimum_user_command_fee_string\n\n let default_transaction_fee =\n of_mina_string_exn Mina_compile_config.default_transaction_fee_string\n\n let default_snark_worker_fee =\n of_mina_string_exn Mina_compile_config.default_snark_worker_fee_string\n end\n\n module Amount = struct\n (* See documentation for {!module:Mina_wire_types} *)\n module Make_sig (A : sig\n type t\n end) =\n struct\n module type S = sig\n [%%versioned:\n module Stable : sig\n module V1 : sig\n [@@@with_all_version_tags]\n\n type t = A.t [@@deriving sexp, compare, hash, equal, yojson]\n\n (* not automatically derived *)\n val dhall_type : Ppx_dhall_type.Dhall_type.t\n end\n end]\n\n [%%ifdef consensus_mechanism]\n\n (* Give a definition to var, it will be hidden at the interface level *)\n include\n Basic\n with type t := Stable.Latest.t\n and type var =\n Pickles.Impls.Step.Impl.Internal_Basic.field\n Snarky_backendless.Cvar.t\n\n [%%else]\n\n include Basic with type t := Stable.Latest.t\n\n [%%endif]\n\n include Arithmetic_intf with type t := t\n\n include Codable.S with type t := t\n\n [%%ifdef consensus_mechanism]\n\n module Signed :\n Signed_intf\n with type magnitude := t\n and type magnitude_var := var\n and type signed_fee := Fee.Signed.t\n and type Checked.signed_fee_var := Fee.Signed.Checked.t\n\n [%%else]\n\n module Signed :\n Signed_intf\n with type magnitude := t\n and type signed_fee := Fee.Signed.t\n\n [%%endif]\n\n (* TODO: Delete these functions *)\n\n val of_fee : Fee.t -> t\n\n val to_fee : t -> Fee.t\n\n val add_fee : t -> Fee.t -> t option\n\n [%%ifdef consensus_mechanism]\n\n module Checked : sig\n include\n Checked_arithmetic_intf\n with type var := var\n and type signed_var := Signed.var\n and type value := t\n\n val add_signed : var -> Signed.var -> var Checked.t\n\n val of_fee : Fee.var -> var\n\n val to_fee : var -> Fee.var\n\n val to_field : var -> Field.Var.t\n\n module Unsafe : sig\n val of_field : Field.Var.t -> t\n end\n end\n\n [%%endif]\n\n val add_signed_flagged : t -> Signed.t -> t * [ `Overflow of bool ]\n end\n end\n [@@warning \"-32\"]\n\n module Make_str (A : sig\n type t = Unsigned_extended.UInt64.Stable.V1.t\n end) : Make_sig(A).S = struct\n module T =\n Make\n (Unsigned_extended.UInt64)\n (struct\n let length = currency_length\n end)\n\n [%%ifdef consensus_mechanism]\n\n include (\n T :\n module type of T\n with type var = T.var\n and module Signed = T.Signed\n and module Checked := T.Checked )\n\n [%%else]\n\n include (T : module type of T with module Signed = T.Signed)\n\n [%%endif]\n\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n [@@@with_all_version_tags]\n\n type t = Unsigned_extended.UInt64.Stable.V1.t\n [@@deriving sexp, compare, hash, equal, yojson]\n\n [%%define_from_scope to_yojson, of_yojson, dhall_type]\n\n let to_latest = Fn.id\n end\n end]\n\n let of_fee (fee : Fee.t) : t = fee\n\n let to_fee (fee : t) : Fee.t = fee\n\n let add_fee (t : t) (fee : Fee.t) = add t (of_fee fee)\n\n [%%ifdef consensus_mechanism]\n\n module Checked = struct\n include T.Checked\n\n let of_fee (fee : Fee.var) : var = fee\n\n let to_fee (t : var) : Fee.var = t\n\n let to_field = Fn.id\n\n module Unsafe = struct\n let of_field : Field.Var.t -> var = Fn.id\n end\n end\n\n [%%endif]\n end\n\n include Make_str (struct\n type t = Unsigned_extended.UInt64.Stable.V1.t\n end)\n (*include Wire_types.Make.Amount (Make_sig) (Make_str)*)\n end\n\n module Balance = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Amount.Stable.V1.t\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n\n (* can't be automatically derived *)\n let dhall_type = Ppx_dhall_type.Dhall_type.Text\n end\n end]\n\n [%%ifdef consensus_mechanism]\n\n include (Amount : Basic with type t := t with type var = Amount.var)\n\n [%%else]\n\n include (Amount : Basic with type t := t)\n\n [%%endif]\n\n let to_amount = Fn.id\n\n let add_amount = Amount.add\n\n let add_amount_flagged = Amount.add_flagged\n\n let sub_amount = Amount.sub\n\n let sub_amount_flagged = Amount.sub_flagged\n\n let add_signed_amount_flagged = Amount.add_signed_flagged\n\n let ( + ) = add_amount\n\n let ( - ) = sub_amount\n\n [%%ifdef consensus_mechanism]\n\n module Checked = struct\n include Amount.Checked\n\n let to_field = Fn.id\n\n module Unsafe = struct\n let of_field (x : Field.Var.t) : var = x\n end\n\n let to_amount = Fn.id\n\n let add_signed_amount = add_signed\n\n let add_amount = add\n\n let sub_amount = sub\n\n let sub_amount_or_zero = sub_or_zero\n\n let add_amount_flagged = add_flagged\n\n let add_signed_amount_flagged = add_signed_flagged\n\n let sub_amount_flagged = sub_flagged\n\n let ( + ) = add_amount\n\n let ( - ) = sub_amount\n end\n\n [%%endif]\n end\n\n module Fee_rate = struct\n type t = Q.t\n\n let uint64_to_z u64 = Z.of_string @@ Unsigned.UInt64.to_string u64\n\n let uint64_of_z z = Unsigned.UInt64.of_string @@ Z.to_string z\n\n let max_uint64_z = uint64_to_z Unsigned.UInt64.max_int\n\n let fits_uint64 z =\n let open Z in\n leq zero z && leq z max_uint64_z\n\n (** check if a Q.t is in range *)\n let check_q Q.{ num; den } : bool =\n let open Z in\n fits_uint64 num && fits_int32 den\n && if equal zero den then equal zero num else true\n\n let of_q q = if check_q q then Some q else None\n\n let of_q_exn q = Option.value_exn (of_q q)\n\n let to_q = ident\n\n let make fee weight = of_q @@ Q.make (uint64_to_z fee) (Z.of_int weight)\n\n let make_exn fee weight = Option.value_exn (make fee weight)\n\n let to_uint64 Q.{ num; den } =\n if Z.(equal den Z.one) then Some (uint64_of_z num) else None\n\n let to_uint64_exn fr = Option.value_exn (to_uint64 fr)\n\n let add x y = of_q @@ Q.add x y\n\n let add_flagged x y =\n let z = Q.add x y in\n (z, `Overflow (check_q z))\n\n let sub x y = of_q @@ Q.sub x y\n\n let sub_flagged x y =\n let z = Q.sub x y in\n (z, `Underflow (check_q z))\n\n let mul x y = of_q @@ Q.mul x y\n\n let div x y = of_q @@ Q.div x y\n\n let ( + ) = add\n\n let ( - ) = sub\n\n let ( * ) = mul\n\n let scale fr s = fr * Q.of_int s\n\n let scale_exn fr s = Option.value_exn (scale fr s)\n\n let compare = Q.compare\n\n let t_of_sexp sexp =\n let open Ppx_sexp_conv_lib.Conv in\n pair_of_sexp Fee.t_of_sexp int_of_sexp sexp\n |> fun (fee, weight) -> make_exn fee weight\n\n let sexp_of_t Q.{ num = fee; den = weight } =\n let sexp_of_fee fee = Fee.sexp_of_t @@ uint64_of_z fee in\n let sexp_of_weight weight = sexp_of_int @@ Z.to_int weight in\n sexp_of_pair sexp_of_fee sexp_of_weight (fee, weight)\n\n include Comparable.Make (struct\n type nonrec t = t\n\n let compare = compare\n\n let t_of_sexp = t_of_sexp\n\n let sexp_of_t = sexp_of_t\n end)\n end\n\n let%test_module \"sub_flagged module\" =\n ( module struct\n [%%ifdef consensus_mechanism]\n\n open Tick\n\n module type Sub_flagged_S = sig\n type t\n\n type magnitude = t [@@deriving sexp, compare]\n\n type var\n\n (* TODO =\n field Snarky_backendless.Cvar.t Snarky_backendless.Boolean.t list *)\n\n val zero : t\n\n val ( - ) : t -> t -> t option\n\n val typ : (var, t) Typ.t\n\n val gen : t Quickcheck.Generator.t\n\n module Checked : sig\n val sub_flagged :\n var -> var -> (var * [ `Underflow of Boolean.var ]) Tick.Checked.t\n end\n end\n\n let run_test (module M : Sub_flagged_S) =\n let open M in\n let sub_flagged_unchecked (x, y) =\n if compare_magnitude x y < 0 then (zero, true)\n else (Option.value_exn (x - y), false)\n in\n let sub_flagged_checked =\n let f (x, y) =\n Tick.Checked.map (M.Checked.sub_flagged x y)\n ~f:(fun (r, `Underflow u) -> (r, u))\n in\n Test_util.checked_to_unchecked (Typ.tuple2 typ typ)\n (Typ.tuple2 typ Boolean.typ)\n f\n in\n Quickcheck.test ~trials:100 (Quickcheck.Generator.tuple2 gen gen)\n ~f:(fun p ->\n let m, u = sub_flagged_unchecked p in\n let m_checked, u_checked = sub_flagged_checked p in\n assert (Bool.equal u u_checked) ;\n if not u then [%test_eq: M.magnitude] m m_checked )\n\n let%test_unit \"fee sub_flagged\" = run_test (module Fee)\n\n let%test_unit \"amount sub_flagged\" = run_test (module Amount)\n\n [%%endif]\n end )\nend\n\n(** Finally, we use [Make] to create the full module where the types defined\n here and in {!Mina_wire_types} are fully unified. *)\ninclude Wire_types.Make (Make_sig) (Make_str)\n","(*\n RE - A regular expression library\n\n Copyright (C) 2001 Jerome Vouillon\n email: Jerome.Vouillon@pps.jussieu.fr\n\n This library is free software; you can redistribute it and/or\n modify it under the terms of the GNU Lesser General Public\n License as published by the Free Software Foundation, with\n linking exception; either version 2.1 of the License, or (at\n your option) any later version.\n\n This library is distributed in the hope that it will be useful,\n but WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n Lesser General Public License for more details.\n\n You should have received a copy of the GNU Lesser General Public\n License along with this library; if not, write to the Free Software\n Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n*)\n\ntype c = int\ntype t = (c * c) list\n\nlet rec union l l' =\n match l, l' with\n _, [] -> l\n | [], _ -> l'\n | (c1, c2)::r, (c1', c2')::r' ->\n if c2 + 1 < c1' then\n (c1, c2)::union r l'\n else if c2' + 1 < c1 then\n (c1', c2')::union l r'\n else if c2 < c2' then\n union r ((min c1 c1', c2')::r')\n else\n union ((min c1 c1', c2)::r) r'\n\nlet rec inter l l' =\n match l, l' with\n _, [] -> []\n | [], _ -> []\n | (c1, c2)::r, (c1', c2')::r' ->\n if c2 < c1' then\n inter r l'\n else if c2' < c1 then\n inter l r'\n else if c2 < c2' then\n (max c1 c1', c2)::inter r l'\n else\n (max c1 c1', c2')::inter l r'\n\nlet rec diff l l' =\n match l, l' with\n _, [] -> l\n | [], _ -> []\n | (c1, c2)::r, (c1', c2')::r' ->\n if c2 < c1' then\n (c1, c2)::diff r l'\n else if c2' < c1 then\n diff l r'\n else\n let r'' = if c2' < c2 then (c2' + 1, c2) :: r else r in\n if c1 < c1' then\n (c1, c1' - 1)::diff r'' r'\n else\n diff r'' r'\n\nlet single c = [c, c]\n\nlet add c l = union (single c) l\n\nlet seq c c' = if c <= c' then [c, c'] else [c', c]\n\nlet rec offset o l =\n match l with\n [] -> []\n | (c1, c2) :: r -> (c1 + o, c2 + o) :: offset o r\n\nlet empty = []\n\nlet rec mem (c : int) s =\n match s with\n [] -> false\n | (c1, c2) :: rem -> if c <= c2 then c >= c1 else mem c rem\n\n(****)\n\ntype hash = int\n\nlet rec hash_rec = function\n | [] -> 0\n | (i, j)::r -> i + 13 * j + 257 * hash_rec r\nlet hash l = (hash_rec l) land 0x3FFFFFFF\n\n(****)\n\nlet print_one ch (c1, c2) =\n if c1 = c2 then\n Format.fprintf ch \"%d\" c1\n else\n Format.fprintf ch \"%d-%d\" c1 c2\n\nlet pp = Fmt.list print_one\n\nlet rec iter t ~f =\n match t with\n | [] -> ()\n | (x, y)::xs ->\n f x y;\n iter xs ~f\n\nlet one_char = function\n | [i, j] when i = j -> Some i\n | _ -> None\n\n\nmodule CSetMap = Map.Make (struct\n type t = int * (int * int) list\n let compare (i, u) (j, v) =\n let c = compare i j in\n if c <> 0\n then c\n else compare u v\n end)\n\nlet fold_right t ~init ~f = List.fold_right f t init\n\nlet csingle c = single (Char.code c)\n\nlet cany = [0, 255]\n\nlet is_empty = function\n | [] -> true\n | _ -> false\n\nlet rec prepend s x l =\n match s, l with\n | [], _ -> l\n | _r, [] -> []\n | (_c, c') :: r, ([d, _d'], _x') :: _r' when c' < d -> prepend r x l\n | (c, c') :: r, ([d, d'], x') :: r' ->\n if c <= d then begin\n if c' < d'\n then ([d, c'], x @ x') :: prepend r x (([c' + 1, d'], x') :: r')\n else ([d, d'], x @ x') :: prepend s x r'\n end else begin\n if c > d'\n then ([d, d'], x') :: prepend s x r'\n else ([d, c - 1], x') :: prepend s x (([c, d'], x') :: r')\n end\n | _ -> assert false\n\nlet pick = function\n | [] -> invalid_arg \"Re_cset.pick\"\n | (x, _)::_ -> x\n","\nmodule MenhirBasics = struct\n \n exception Error\n \n type token = \n | SUBSCRIPTION\n | STRING of (\n# 8 \"graphql_parser/src/parser.mly\"\n (string)\n# 12 \"graphql_parser/src/parser.ml\"\n )\n | RPAREN\n | RBRACK\n | RBRACE\n | QUERY\n | ON\n | NULL\n | NAME of (\n# 5 \"graphql_parser/src/parser.mly\"\n (string)\n# 23 \"graphql_parser/src/parser.ml\"\n )\n | MUTATION\n | LPAREN\n | LBRACK\n | LBRACE\n | INT of (\n# 6 \"graphql_parser/src/parser.mly\"\n (int)\n# 32 \"graphql_parser/src/parser.ml\"\n )\n | FRAGMENT\n | FLOAT of (\n# 7 \"graphql_parser/src/parser.mly\"\n (float)\n# 38 \"graphql_parser/src/parser.ml\"\n )\n | EQUAL\n | EOF\n | ELLIPSIS\n | DOLLAR\n | COLON\n | BOOL of (\n# 9 \"graphql_parser/src/parser.mly\"\n (bool)\n# 48 \"graphql_parser/src/parser.ml\"\n )\n | BANG\n | AT\n \nend\n\ninclude MenhirBasics\n\nlet _eRR =\n MenhirBasics.Error\n\ntype _menhir_env = {\n _menhir_lexer: Lexing.lexbuf -> token;\n _menhir_lexbuf: Lexing.lexbuf;\n _menhir_token: token;\n mutable _menhir_error: bool\n}\n\nand _menhir_state = \n | MenhirState133\n | MenhirState125\n | MenhirState124\n | MenhirState119\n | MenhirState114\n | MenhirState108\n | MenhirState102\n | MenhirState100\n | MenhirState99\n | MenhirState96\n | MenhirState90\n | MenhirState89\n | MenhirState87\n | MenhirState86\n | MenhirState84\n | MenhirState81\n | MenhirState80\n | MenhirState79\n | MenhirState78\n | MenhirState71\n | MenhirState70\n | MenhirState67\n | MenhirState66\n | MenhirState65\n | MenhirState64\n | MenhirState63\n | MenhirState61\n | MenhirState59\n | MenhirState57\n | MenhirState55\n | MenhirState51\n | MenhirState44\n | MenhirState38\n | MenhirState34\n | MenhirState31\n | MenhirState29\n | MenhirState28\n | MenhirState24\n | MenhirState22\n | MenhirState21\n | MenhirState20\n | MenhirState19\n | MenhirState13\n | MenhirState12\n | MenhirState4\n | MenhirState0\n\n# 1 \"graphql_parser/src/parser.mly\"\n \nopen Ast\n\n# 119 \"graphql_parser/src/parser.ml\"\n\nlet rec _menhir_goto_nonempty_list_definition_ : _menhir_env -> 'ttv_tail -> _menhir_state -> (Ast.document) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_stack = (_menhir_stack, _menhir_s, _v) in\n match _menhir_s with\n | MenhirState0 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | EOF ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, (_1 : (Ast.document))) = _menhir_stack in\n let _v : (Ast.document) = \n# 37 \"graphql_parser/src/parser.mly\"\n ( _1 )\n# 137 \"graphql_parser/src/parser.ml\"\n in\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_1 : (Ast.document)) = _v in\n Obj.magic _1\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s)\n | MenhirState133 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let ((_menhir_stack, _menhir_s, (x : (Ast.definition))), _, (xs : (Ast.document))) = _menhir_stack in\n let _v : (Ast.document) = \n# 223 \"\"\n ( x :: xs )\n# 156 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_nonempty_list_definition_ _menhir_env _menhir_stack _menhir_s _v\n | _ ->\n _menhir_fail ()\n\nand _menhir_goto_field : _menhir_env -> 'ttv_tail -> _menhir_state -> (Ast.selection) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_1 : (Ast.selection)) = _v in\n let _v : (Ast.selection) = \n# 87 \"graphql_parser/src/parser.mly\"\n ( _1 )\n# 170 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_selection _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_goto_operation : _menhir_env -> 'ttv_tail -> _menhir_state -> (Ast.definition) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_1 : (Ast.definition)) = _v in\n let _v : (Ast.definition) = \n# 41 \"graphql_parser/src/parser.mly\"\n ( _1 )\n# 182 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_definition _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_goto_definition : _menhir_env -> 'ttv_tail -> _menhir_state -> (Ast.definition) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_stack = (_menhir_stack, _menhir_s, _v) in\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n match _tok with\n | FRAGMENT ->\n _menhir_run78 _menhir_env (Obj.magic _menhir_stack) MenhirState133\n | LBRACE ->\n _menhir_run4 _menhir_env (Obj.magic _menhir_stack) MenhirState133\n | MUTATION ->\n _menhir_run3 _menhir_env (Obj.magic _menhir_stack) MenhirState133\n | QUERY ->\n _menhir_run2 _menhir_env (Obj.magic _menhir_stack) MenhirState133\n | SUBSCRIPTION ->\n _menhir_run1 _menhir_env (Obj.magic _menhir_stack) MenhirState133\n | EOF ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, (x : (Ast.definition))) = _menhir_stack in\n let _v : (Ast.document) = \n# 221 \"\"\n ( [ x ] )\n# 209 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_nonempty_list_definition_ _menhir_env _menhir_stack _menhir_s _v\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState133\n\nand _menhir_goto_loption_selection_set_ : _menhir_env -> 'ttv_tail -> _menhir_state -> (Ast.selection list) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n match _menhir_s with\n | MenhirState67 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_6 : (Ast.selection list)) = _v in\n let (((((_menhir_stack, _menhir_s, (_1 : (string))), _), _, (_3 : (string))), _, (_4 : ((string * Ast.value) list))), _, (_5 : (Ast.directive list))) = _menhir_stack in\n let _v : (Ast.selection) = \n# 91 \"graphql_parser/src/parser.mly\"\n (\n Field {\n alias = Some _1;\n name = _3;\n arguments = _4;\n directives = _5;\n selection_set = _6;\n }\n )\n# 236 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_field _menhir_env _menhir_stack _menhir_s _v\n | MenhirState71 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_4 : (Ast.selection list)) = _v in\n let (((_menhir_stack, _menhir_s, (_1 : (string))), _, (_2 : ((string * Ast.value) list))), _, (_3 : (Ast.directive list))) = _menhir_stack in\n let _v : (Ast.selection) = \n# 101 \"graphql_parser/src/parser.mly\"\n (\n Field {\n alias = None;\n name = _1;\n arguments = _2;\n directives = _3;\n selection_set = _4;\n }\n )\n# 255 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_field _menhir_env _menhir_stack _menhir_s _v\n | _ ->\n _menhir_fail ()\n\nand _menhir_goto_nonempty_list_selection_ : _menhir_env -> 'ttv_tail -> _menhir_state -> (Ast.selection list) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_stack = (_menhir_stack, _menhir_s, _v) in\n match _menhir_s with\n | MenhirState61 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let ((_menhir_stack, _menhir_s, (x : (Ast.selection))), _, (xs : (Ast.selection list))) = _menhir_stack in\n let _v : (Ast.selection list) = \n# 223 \"\"\n ( x :: xs )\n# 272 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_nonempty_list_selection_ _menhir_env _menhir_stack _menhir_s _v\n | MenhirState4 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | RBRACE ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let ((_menhir_stack, _menhir_s), _, (_2 : (Ast.selection list))) = _menhir_stack in\n let _v : (Ast.selection list) = \n# 82 \"graphql_parser/src/parser.mly\"\n ( _2 )\n# 288 \"graphql_parser/src/parser.ml\"\n in\n (match _menhir_s with\n | MenhirState55 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_4 : (Ast.selection list)) = _v in\n let (((_menhir_stack, _menhir_s), _, (_2 : (string option))), _, (_3 : (Ast.directive list))) = _menhir_stack in\n let _v : (Ast.selection) = \n# 125 \"graphql_parser/src/parser.mly\"\n (\n InlineFragment {\n type_condition = _2;\n directives = _3;\n selection_set = _4;\n }\n )\n# 305 \"graphql_parser/src/parser.ml\"\n in\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_1 : (Ast.selection)) = _v in\n let _v : (Ast.selection) = \n# 87 \"graphql_parser/src/parser.mly\"\n ( _1 )\n# 313 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_selection _menhir_env _menhir_stack _menhir_s _v\n | MenhirState71 | MenhirState67 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (x : (Ast.selection list)) = _v in\n let _v : (Ast.selection list) = \n# 144 \"\"\n ( x )\n# 323 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_loption_selection_set_ _menhir_env _menhir_stack _menhir_s _v\n | MenhirState81 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_5 : (Ast.selection list)) = _v in\n let ((((_menhir_stack, _menhir_s), _, (_2 : (string))), _, (_3 : (string))), _, (_4 : (Ast.directive list))) = _menhir_stack in\n let _v : (Ast.definition) = \n# 45 \"graphql_parser/src/parser.mly\"\n (\n Fragment {\n name = _2;\n type_condition = _3;\n directives = _4;\n selection_set = _5;\n }\n )\n# 341 \"graphql_parser/src/parser.ml\"\n in\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_1 : (Ast.definition)) = _v in\n let _v : (Ast.definition) = \n# 41 \"graphql_parser/src/parser.mly\"\n ( _1 )\n# 349 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_definition _menhir_env _menhir_stack _menhir_s _v\n | MenhirState133 | MenhirState0 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_1 : (Ast.selection list)) = _v in\n let _v : (Ast.definition) = \n# 56 \"graphql_parser/src/parser.mly\"\n (\n Operation {\n optype = Query;\n name = None;\n variable_definitions = [];\n directives = [];\n selection_set = _1;\n }\n )\n# 367 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_operation _menhir_env _menhir_stack _menhir_s _v\n | MenhirState125 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_5 : (Ast.selection list)) = _v in\n let ((((_menhir_stack, _menhir_s, (_1 : (Ast.optype))), _, (_2 : (string option))), (_3 : (Ast.variable_definition list))), _, (_4 : (Ast.directive list))) = _menhir_stack in\n let _v : (Ast.definition) = \n# 66 \"graphql_parser/src/parser.mly\"\n (\n Operation {\n optype = _1;\n name = _2;\n variable_definitions = _3;\n directives = _4;\n selection_set = _5;\n }\n )\n# 386 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_operation _menhir_env _menhir_stack _menhir_s _v\n | _ ->\n _menhir_fail ())\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s)\n | _ ->\n _menhir_fail ()\n\nand _menhir_goto_list_const_value_ : _menhir_env -> 'ttv_tail -> _menhir_state -> (Ast.const_value list) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_stack = (_menhir_stack, _menhir_s, _v) in\n match _menhir_s with\n | MenhirState99 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | RBRACK ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let ((_menhir_stack, _menhir_s), _, (_2 : (Ast.const_value list))) = _menhir_stack in\n let _v : (Ast.const_value) = \n# 175 \"graphql_parser/src/parser.mly\"\n ( `List _2 )\n# 417 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_value_parser_const_value_ _menhir_env _menhir_stack _menhir_s _v\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s)\n | MenhirState114 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let ((_menhir_stack, _menhir_s, (x : (Ast.const_value))), _, (xs : (Ast.const_value list))) = _menhir_stack in\n let _v : (Ast.const_value list) = \n# 213 \"\"\n ( x :: xs )\n# 433 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_list_const_value_ _menhir_env _menhir_stack _menhir_s _v\n | _ ->\n _menhir_fail ()\n\nand _menhir_goto_list___anonymous_0_const_value__ : _menhir_env -> 'ttv_tail -> _menhir_state -> ((string * Ast.const_value) list) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_stack = (_menhir_stack, _menhir_s, _v) in\n match _menhir_s with\n | MenhirState108 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (((_menhir_stack, _menhir_s, (_1 : (string))), _, (_3 : (Ast.const_value))), _, (xs : ((string * Ast.const_value) list))) = _menhir_stack in\n let _v : ((string * Ast.const_value) list) = let x = \n# 176 \"graphql_parser/src/parser.mly\"\n ( _1, _3 )\n# 450 \"graphql_parser/src/parser.ml\"\n in\n \n# 213 \"\"\n ( x :: xs )\n# 455 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_list___anonymous_0_const_value__ _menhir_env _menhir_stack _menhir_s _v\n | MenhirState100 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | RBRACE ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let ((_menhir_stack, _menhir_s), _, (_2 : ((string * Ast.const_value) list))) = _menhir_stack in\n let _v : (Ast.const_value) = \n# 176 \"graphql_parser/src/parser.mly\"\n ( `Assoc _2 )\n# 471 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_value_parser_const_value_ _menhir_env _menhir_stack _menhir_s _v\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s)\n | _ ->\n _menhir_fail ()\n\nand _menhir_goto_list_value_ : _menhir_env -> 'ttv_tail -> _menhir_state -> (Ast.value list) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_stack = (_menhir_stack, _menhir_s, _v) in\n match _menhir_s with\n | MenhirState44 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let ((_menhir_stack, _menhir_s, (x : (Ast.value))), _, (xs : (Ast.value list))) = _menhir_stack in\n let _v : (Ast.value list) = \n# 213 \"\"\n ( x :: xs )\n# 494 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_list_value_ _menhir_env _menhir_stack _menhir_s _v\n | MenhirState28 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | RBRACK ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let ((_menhir_stack, _menhir_s), _, (_2 : (Ast.value list))) = _menhir_stack in\n let _v : (Ast.value) = \n# 175 \"graphql_parser/src/parser.mly\"\n ( `List _2 )\n# 510 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_value_parser_value_ _menhir_env _menhir_stack _menhir_s _v\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s)\n | _ ->\n _menhir_fail ()\n\nand _menhir_goto_list___anonymous_0_value__ : _menhir_env -> 'ttv_tail -> _menhir_state -> ((string * Ast.value) list) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_stack = (_menhir_stack, _menhir_s, _v) in\n match _menhir_s with\n | MenhirState38 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (((_menhir_stack, _menhir_s, (_1 : (string))), _, (_3 : (Ast.value))), _, (xs : ((string * Ast.value) list))) = _menhir_stack in\n let _v : ((string * Ast.value) list) = let x = \n# 176 \"graphql_parser/src/parser.mly\"\n ( _1, _3 )\n# 533 \"graphql_parser/src/parser.ml\"\n in\n \n# 213 \"\"\n ( x :: xs )\n# 538 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_list___anonymous_0_value__ _menhir_env _menhir_stack _menhir_s _v\n | MenhirState29 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | RBRACE ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let ((_menhir_stack, _menhir_s), _, (_2 : ((string * Ast.value) list))) = _menhir_stack in\n let _v : (Ast.value) = \n# 176 \"graphql_parser/src/parser.mly\"\n ( `Assoc _2 )\n# 554 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_value_parser_value_ _menhir_env _menhir_stack _menhir_s _v\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s)\n | _ ->\n _menhir_fail ()\n\nand _menhir_goto_list_argument_ : _menhir_env -> 'ttv_tail -> _menhir_state -> ((string * Ast.value) list) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_stack = (_menhir_stack, _menhir_s, _v) in\n match _menhir_s with\n | MenhirState22 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | RPAREN ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let ((_menhir_stack, _menhir_s), _, (_2 : ((string * Ast.value) list))) = _menhir_stack in\n let _v : ((string * Ast.value) list) = \n# 163 \"graphql_parser/src/parser.mly\"\n ( _2 )\n# 583 \"graphql_parser/src/parser.ml\"\n in\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (x : ((string * Ast.value) list)) = _v in\n let _v : ((string * Ast.value) list) = \n# 144 \"\"\n ( x )\n# 591 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_loption_arguments_ _menhir_env _menhir_stack _menhir_s _v\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s)\n | MenhirState51 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let ((_menhir_stack, _menhir_s, (x : (string * Ast.value))), _, (xs : ((string * Ast.value) list))) = _menhir_stack in\n let _v : ((string * Ast.value) list) = \n# 213 \"\"\n ( x :: xs )\n# 607 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_list_argument_ _menhir_env _menhir_stack _menhir_s _v\n | _ ->\n _menhir_fail ()\n\nand _menhir_reduce40 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _v : (Ast.selection list) = \n# 142 \"\"\n ( [] )\n# 618 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_loption_selection_set_ _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_goto_selection : _menhir_env -> 'ttv_tail -> _menhir_state -> (Ast.selection) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_stack = (_menhir_stack, _menhir_s, _v) in\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n match _tok with\n | BOOL _v ->\n _menhir_run14 _menhir_env (Obj.magic _menhir_stack) MenhirState61 _v\n | ELLIPSIS ->\n _menhir_run12 _menhir_env (Obj.magic _menhir_stack) MenhirState61\n | FRAGMENT ->\n _menhir_run11 _menhir_env (Obj.magic _menhir_stack) MenhirState61\n | MUTATION ->\n _menhir_run10 _menhir_env (Obj.magic _menhir_stack) MenhirState61\n | NAME _v ->\n _menhir_run9 _menhir_env (Obj.magic _menhir_stack) MenhirState61 _v\n | NULL ->\n _menhir_run8 _menhir_env (Obj.magic _menhir_stack) MenhirState61\n | ON ->\n _menhir_run7 _menhir_env (Obj.magic _menhir_stack) MenhirState61\n | QUERY ->\n _menhir_run6 _menhir_env (Obj.magic _menhir_stack) MenhirState61\n | SUBSCRIPTION ->\n _menhir_run5 _menhir_env (Obj.magic _menhir_stack) MenhirState61\n | RBRACE ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, (x : (Ast.selection))) = _menhir_stack in\n let _v : (Ast.selection list) = \n# 221 \"\"\n ( [ x ] )\n# 653 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_nonempty_list_selection_ _menhir_env _menhir_stack _menhir_s _v\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState61\n\nand _menhir_goto_list_variable_definition_ : _menhir_env -> 'ttv_tail -> _menhir_state -> (Ast.variable_definition list) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_stack = (_menhir_stack, _menhir_s, _v) in\n match _menhir_s with\n | MenhirState119 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let ((_menhir_stack, _menhir_s, (x : (Ast.variable_definition))), _, (xs : (Ast.variable_definition list))) = _menhir_stack in\n let _v : (Ast.variable_definition list) = \n# 213 \"\"\n ( x :: xs )\n# 672 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_list_variable_definition_ _menhir_env _menhir_stack _menhir_s _v\n | MenhirState86 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | RPAREN ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _, (_2 : (Ast.variable_definition list))) = _menhir_stack in\n let _v : (Ast.variable_definition list) = \n# 134 \"graphql_parser/src/parser.mly\"\n ( _2 )\n# 688 \"graphql_parser/src/parser.ml\"\n in\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (x : (Ast.variable_definition list)) = _v in\n let _v : (Ast.variable_definition list) = \n# 144 \"\"\n ( x )\n# 696 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_loption_variable_definitions_ _menhir_env _menhir_stack _v\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s)\n | _ ->\n _menhir_fail ()\n\nand _menhir_reduce30 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _v : (Ast.const_value list) = \n# 211 \"\"\n ( [] )\n# 713 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_list_const_value_ _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_reduce24 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _v : ((string * Ast.const_value) list) = \n# 211 \"\"\n ( [] )\n# 722 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_list___anonymous_0_const_value__ _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_goto_option_default_value_ : _menhir_env -> 'ttv_tail -> (Ast.const_value option) -> 'ttv_return =\n fun _menhir_env _menhir_stack _v ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_5 : (Ast.const_value option)) = _v in\n let (((_menhir_stack, _menhir_s), _, (_2 : (string))), _, (_4 : (Ast.typ))) = _menhir_stack in\n let _v : (Ast.variable_definition) = \n# 140 \"graphql_parser/src/parser.mly\"\n (\n {\n name = _2;\n typ = _4;\n default_value = _5;\n }\n )\n# 741 \"graphql_parser/src/parser.ml\"\n in\n let _menhir_stack = (_menhir_stack, _menhir_s, _v) in\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n match _tok with\n | DOLLAR ->\n _menhir_run87 _menhir_env (Obj.magic _menhir_stack) MenhirState119\n | RPAREN ->\n _menhir_reduce36 _menhir_env (Obj.magic _menhir_stack) MenhirState119\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState119\n\nand _menhir_run93 : _menhir_env -> 'ttv_tail * _menhir_state * (Ast.typ) -> 'ttv_return =\n fun _menhir_env _menhir_stack ->\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, (_1 : (Ast.typ))) = _menhir_stack in\n let _v : (Ast.typ) = \n# 151 \"graphql_parser/src/parser.mly\"\n ( NonNullType _1 )\n# 765 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_typ _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_reduce34 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _v : (Ast.value list) = \n# 211 \"\"\n ( [] )\n# 774 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_list_value_ _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_reduce26 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _v : ((string * Ast.value) list) = \n# 211 \"\"\n ( [] )\n# 783 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_list___anonymous_0_value__ _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_goto_loption_arguments_ : _menhir_env -> 'ttv_tail -> _menhir_state -> ((string * Ast.value) list) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_stack = (_menhir_stack, _menhir_s, _v) in\n match _menhir_s with\n | MenhirState21 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (((_menhir_stack, _menhir_s), _, (_2 : (string))), _, (_3 : ((string * Ast.value) list))) = _menhir_stack in\n let _v : (Ast.directive) = \n# 155 \"graphql_parser/src/parser.mly\"\n (\n {\n name = _2;\n arguments = _3;\n }\n )\n# 803 \"graphql_parser/src/parser.ml\"\n in\n let _menhir_stack = (_menhir_stack, _menhir_s, _v) in\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | AT ->\n _menhir_run20 _menhir_env (Obj.magic _menhir_stack) MenhirState57\n | BOOL _ | ELLIPSIS | FRAGMENT | LBRACE | MUTATION | NAME _ | NULL | ON | QUERY | RBRACE | SUBSCRIPTION ->\n _menhir_reduce32 _menhir_env (Obj.magic _menhir_stack) MenhirState57\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState57)\n | MenhirState65 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | AT ->\n _menhir_run20 _menhir_env (Obj.magic _menhir_stack) MenhirState66\n | BOOL _ | ELLIPSIS | FRAGMENT | LBRACE | MUTATION | NAME _ | NULL | ON | QUERY | RBRACE | SUBSCRIPTION ->\n _menhir_reduce32 _menhir_env (Obj.magic _menhir_stack) MenhirState66\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState66)\n | MenhirState63 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | AT ->\n _menhir_run20 _menhir_env (Obj.magic _menhir_stack) MenhirState70\n | BOOL _ | ELLIPSIS | FRAGMENT | LBRACE | MUTATION | NAME _ | NULL | ON | QUERY | RBRACE | SUBSCRIPTION ->\n _menhir_reduce32 _menhir_env (Obj.magic _menhir_stack) MenhirState70\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState70)\n | _ ->\n _menhir_fail ()\n\nand _menhir_reduce28 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _v : ((string * Ast.value) list) = \n# 211 \"\"\n ( [] )\n# 852 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_list_argument_ _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_goto_value_parser_const_value_ : _menhir_env -> 'ttv_tail -> _menhir_state -> (Ast.const_value) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_1 : (Ast.const_value)) = _v in\n let _v : (Ast.const_value) = \n# 183 \"graphql_parser/src/parser.mly\"\n ( _1 )\n# 864 \"graphql_parser/src/parser.ml\"\n in\n let _menhir_stack = (_menhir_stack, _menhir_s, _v) in\n match _menhir_s with\n | MenhirState102 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | BOOL _v ->\n _menhir_run14 _menhir_env (Obj.magic _menhir_stack) MenhirState108 _v\n | FRAGMENT ->\n _menhir_run11 _menhir_env (Obj.magic _menhir_stack) MenhirState108\n | MUTATION ->\n _menhir_run10 _menhir_env (Obj.magic _menhir_stack) MenhirState108\n | NAME _v ->\n _menhir_run9 _menhir_env (Obj.magic _menhir_stack) MenhirState108 _v\n | NULL ->\n _menhir_run8 _menhir_env (Obj.magic _menhir_stack) MenhirState108\n | ON ->\n _menhir_run7 _menhir_env (Obj.magic _menhir_stack) MenhirState108\n | QUERY ->\n _menhir_run6 _menhir_env (Obj.magic _menhir_stack) MenhirState108\n | SUBSCRIPTION ->\n _menhir_run5 _menhir_env (Obj.magic _menhir_stack) MenhirState108\n | RBRACE ->\n _menhir_reduce24 _menhir_env (Obj.magic _menhir_stack) MenhirState108\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState108)\n | MenhirState114 | MenhirState99 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | BOOL _v ->\n _menhir_run105 _menhir_env (Obj.magic _menhir_stack) MenhirState114 _v\n | FLOAT _v ->\n _menhir_run104 _menhir_env (Obj.magic _menhir_stack) MenhirState114 _v\n | FRAGMENT ->\n _menhir_run11 _menhir_env (Obj.magic _menhir_stack) MenhirState114\n | INT _v ->\n _menhir_run103 _menhir_env (Obj.magic _menhir_stack) MenhirState114 _v\n | LBRACE ->\n _menhir_run100 _menhir_env (Obj.magic _menhir_stack) MenhirState114\n | LBRACK ->\n _menhir_run99 _menhir_env (Obj.magic _menhir_stack) MenhirState114\n | MUTATION ->\n _menhir_run10 _menhir_env (Obj.magic _menhir_stack) MenhirState114\n | NAME _v ->\n _menhir_run27 _menhir_env (Obj.magic _menhir_stack) MenhirState114 _v\n | NULL ->\n _menhir_run98 _menhir_env (Obj.magic _menhir_stack) MenhirState114\n | QUERY ->\n _menhir_run6 _menhir_env (Obj.magic _menhir_stack) MenhirState114\n | STRING _v ->\n _menhir_run97 _menhir_env (Obj.magic _menhir_stack) MenhirState114 _v\n | SUBSCRIPTION ->\n _menhir_run5 _menhir_env (Obj.magic _menhir_stack) MenhirState114\n | RBRACK ->\n _menhir_reduce30 _menhir_env (Obj.magic _menhir_stack) MenhirState114\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState114)\n | MenhirState96 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _, (_2 : (Ast.const_value))) = _menhir_stack in\n let _v : (Ast.const_value) = \n# 137 \"graphql_parser/src/parser.mly\"\n ( _2 )\n# 937 \"graphql_parser/src/parser.ml\"\n in\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (x : (Ast.const_value)) = _v in\n let _v : (Ast.const_value option) = \n# 116 \"\"\n ( Some x )\n# 945 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_option_default_value_ _menhir_env _menhir_stack _v\n | _ ->\n _menhir_fail ()\n\nand _menhir_goto_value_parser_value_ : _menhir_env -> 'ttv_tail -> _menhir_state -> (Ast.value) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_1 : (Ast.value)) = _v in\n let _v : (Ast.value) = \n# 180 \"graphql_parser/src/parser.mly\"\n ( _1 )\n# 959 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_value _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_goto_list_directive_ : _menhir_env -> 'ttv_tail -> _menhir_state -> (Ast.directive list) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_stack = (_menhir_stack, _menhir_s, _v) in\n match _menhir_s with\n | MenhirState19 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | LBRACE ->\n _menhir_run4 _menhir_env (Obj.magic _menhir_stack) MenhirState55\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState55)\n | MenhirState57 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let ((_menhir_stack, _menhir_s, (x : (Ast.directive))), _, (xs : (Ast.directive list))) = _menhir_stack in\n let _v : (Ast.directive list) = \n# 213 \"\"\n ( x :: xs )\n# 985 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_list_directive_ _menhir_env _menhir_stack _menhir_s _v\n | MenhirState59 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (((_menhir_stack, _menhir_s), _, (_2 : (string))), _, (_3 : (Ast.directive list))) = _menhir_stack in\n let _v : (Ast.selection) = \n# 113 \"graphql_parser/src/parser.mly\"\n (\n FragmentSpread {\n name = _2;\n directives = _3;\n }\n )\n# 1000 \"graphql_parser/src/parser.ml\"\n in\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_1 : (Ast.selection)) = _v in\n let _v : (Ast.selection) = \n# 87 \"graphql_parser/src/parser.mly\"\n ( _1 )\n# 1008 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_selection _menhir_env _menhir_stack _menhir_s _v\n | MenhirState66 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | LBRACE ->\n _menhir_run4 _menhir_env (Obj.magic _menhir_stack) MenhirState67\n | BOOL _ | ELLIPSIS | FRAGMENT | MUTATION | NAME _ | NULL | ON | QUERY | RBRACE | SUBSCRIPTION ->\n _menhir_reduce40 _menhir_env (Obj.magic _menhir_stack) MenhirState67\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState67)\n | MenhirState70 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | LBRACE ->\n _menhir_run4 _menhir_env (Obj.magic _menhir_stack) MenhirState71\n | BOOL _ | ELLIPSIS | FRAGMENT | MUTATION | NAME _ | NULL | ON | QUERY | RBRACE | SUBSCRIPTION ->\n _menhir_reduce40 _menhir_env (Obj.magic _menhir_stack) MenhirState71\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState71)\n | MenhirState80 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | LBRACE ->\n _menhir_run4 _menhir_env (Obj.magic _menhir_stack) MenhirState81\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState81)\n | MenhirState124 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | LBRACE ->\n _menhir_run4 _menhir_env (Obj.magic _menhir_stack) MenhirState125\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState125)\n | _ ->\n _menhir_fail ()\n\nand _menhir_goto_loption_variable_definitions_ : _menhir_env -> 'ttv_tail -> (Ast.variable_definition list) -> 'ttv_return =\n fun _menhir_env _menhir_stack _v ->\n let _menhir_stack = (_menhir_stack, _v) in\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n match _tok with\n | AT ->\n _menhir_run20 _menhir_env (Obj.magic _menhir_stack) MenhirState124\n | LBRACE ->\n _menhir_reduce32 _menhir_env (Obj.magic _menhir_stack) MenhirState124\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState124\n\nand _menhir_reduce36 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _v : (Ast.variable_definition list) = \n# 211 \"\"\n ( [] )\n# 1083 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_list_variable_definition_ _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_run87 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _menhir_stack = (_menhir_stack, _menhir_s) in\n let _menhir_env = _menhir_discard _menhir_env in\n let _tok = _menhir_env._menhir_token in\n match _tok with\n | BOOL _v ->\n _menhir_run14 _menhir_env (Obj.magic _menhir_stack) MenhirState87 _v\n | FRAGMENT ->\n _menhir_run11 _menhir_env (Obj.magic _menhir_stack) MenhirState87\n | MUTATION ->\n _menhir_run10 _menhir_env (Obj.magic _menhir_stack) MenhirState87\n | NAME _v ->\n _menhir_run9 _menhir_env (Obj.magic _menhir_stack) MenhirState87 _v\n | NULL ->\n _menhir_run8 _menhir_env (Obj.magic _menhir_stack) MenhirState87\n | ON ->\n _menhir_run7 _menhir_env (Obj.magic _menhir_stack) MenhirState87\n | QUERY ->\n _menhir_run6 _menhir_env (Obj.magic _menhir_stack) MenhirState87\n | SUBSCRIPTION ->\n _menhir_run5 _menhir_env (Obj.magic _menhir_stack) MenhirState87\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState87\n\nand _menhir_run97 : _menhir_env -> 'ttv_tail -> _menhir_state -> (\n# 8 \"graphql_parser/src/parser.mly\"\n (string)\n# 1117 \"graphql_parser/src/parser.ml\"\n) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_1 : (\n# 8 \"graphql_parser/src/parser.mly\"\n (string)\n# 1125 \"graphql_parser/src/parser.ml\"\n )) = _v in\n let _v : (Ast.const_value) = \n# 172 \"graphql_parser/src/parser.mly\"\n ( `String _1 )\n# 1130 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_value_parser_const_value_ _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_run98 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let _v : (Ast.const_value) = \n# 169 \"graphql_parser/src/parser.mly\"\n ( `Null )\n# 1141 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_value_parser_const_value_ _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_run99 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _menhir_stack = (_menhir_stack, _menhir_s) in\n let _menhir_env = _menhir_discard _menhir_env in\n let _tok = _menhir_env._menhir_token in\n match _tok with\n | BOOL _v ->\n _menhir_run105 _menhir_env (Obj.magic _menhir_stack) MenhirState99 _v\n | FLOAT _v ->\n _menhir_run104 _menhir_env (Obj.magic _menhir_stack) MenhirState99 _v\n | FRAGMENT ->\n _menhir_run11 _menhir_env (Obj.magic _menhir_stack) MenhirState99\n | INT _v ->\n _menhir_run103 _menhir_env (Obj.magic _menhir_stack) MenhirState99 _v\n | LBRACE ->\n _menhir_run100 _menhir_env (Obj.magic _menhir_stack) MenhirState99\n | LBRACK ->\n _menhir_run99 _menhir_env (Obj.magic _menhir_stack) MenhirState99\n | MUTATION ->\n _menhir_run10 _menhir_env (Obj.magic _menhir_stack) MenhirState99\n | NAME _v ->\n _menhir_run27 _menhir_env (Obj.magic _menhir_stack) MenhirState99 _v\n | NULL ->\n _menhir_run98 _menhir_env (Obj.magic _menhir_stack) MenhirState99\n | QUERY ->\n _menhir_run6 _menhir_env (Obj.magic _menhir_stack) MenhirState99\n | STRING _v ->\n _menhir_run97 _menhir_env (Obj.magic _menhir_stack) MenhirState99 _v\n | SUBSCRIPTION ->\n _menhir_run5 _menhir_env (Obj.magic _menhir_stack) MenhirState99\n | RBRACK ->\n _menhir_reduce30 _menhir_env (Obj.magic _menhir_stack) MenhirState99\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState99\n\nand _menhir_run100 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _menhir_stack = (_menhir_stack, _menhir_s) in\n let _menhir_env = _menhir_discard _menhir_env in\n let _tok = _menhir_env._menhir_token in\n match _tok with\n | BOOL _v ->\n _menhir_run14 _menhir_env (Obj.magic _menhir_stack) MenhirState100 _v\n | FRAGMENT ->\n _menhir_run11 _menhir_env (Obj.magic _menhir_stack) MenhirState100\n | MUTATION ->\n _menhir_run10 _menhir_env (Obj.magic _menhir_stack) MenhirState100\n | NAME _v ->\n _menhir_run9 _menhir_env (Obj.magic _menhir_stack) MenhirState100 _v\n | NULL ->\n _menhir_run8 _menhir_env (Obj.magic _menhir_stack) MenhirState100\n | ON ->\n _menhir_run7 _menhir_env (Obj.magic _menhir_stack) MenhirState100\n | QUERY ->\n _menhir_run6 _menhir_env (Obj.magic _menhir_stack) MenhirState100\n | SUBSCRIPTION ->\n _menhir_run5 _menhir_env (Obj.magic _menhir_stack) MenhirState100\n | RBRACE ->\n _menhir_reduce24 _menhir_env (Obj.magic _menhir_stack) MenhirState100\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState100\n\nand _menhir_run103 : _menhir_env -> 'ttv_tail -> _menhir_state -> (\n# 6 \"graphql_parser/src/parser.mly\"\n (int)\n# 1214 \"graphql_parser/src/parser.ml\"\n) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_1 : (\n# 6 \"graphql_parser/src/parser.mly\"\n (int)\n# 1222 \"graphql_parser/src/parser.ml\"\n )) = _v in\n let _v : (Ast.const_value) = \n# 170 \"graphql_parser/src/parser.mly\"\n ( `Int _1 )\n# 1227 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_value_parser_const_value_ _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_run104 : _menhir_env -> 'ttv_tail -> _menhir_state -> (\n# 7 \"graphql_parser/src/parser.mly\"\n (float)\n# 1234 \"graphql_parser/src/parser.ml\"\n) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_1 : (\n# 7 \"graphql_parser/src/parser.mly\"\n (float)\n# 1242 \"graphql_parser/src/parser.ml\"\n )) = _v in\n let _v : (Ast.const_value) = \n# 171 \"graphql_parser/src/parser.mly\"\n ( `Float _1 )\n# 1247 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_value_parser_const_value_ _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_run105 : _menhir_env -> 'ttv_tail -> _menhir_state -> (\n# 9 \"graphql_parser/src/parser.mly\"\n (bool)\n# 1254 \"graphql_parser/src/parser.ml\"\n) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_1 : (\n# 9 \"graphql_parser/src/parser.mly\"\n (bool)\n# 1262 \"graphql_parser/src/parser.ml\"\n )) = _v in\n let _v : (Ast.const_value) = \n# 173 \"graphql_parser/src/parser.mly\"\n ( `Bool _1 )\n# 1267 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_value_parser_const_value_ _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_goto_typ : _menhir_env -> 'ttv_tail -> _menhir_state -> (Ast.typ) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_stack = (_menhir_stack, _menhir_s, _v) in\n match _menhir_s with\n | MenhirState90 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | BANG ->\n _menhir_run93 _menhir_env (Obj.magic _menhir_stack)\n | RBRACK ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let ((_menhir_stack, _menhir_s), _, (_2 : (Ast.typ))) = _menhir_stack in\n let _v : (Ast.typ) = \n# 150 \"graphql_parser/src/parser.mly\"\n ( ListType _2 )\n# 1290 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_typ _menhir_env _menhir_stack _menhir_s _v\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s)\n | MenhirState89 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | BANG ->\n _menhir_run93 _menhir_env (Obj.magic _menhir_stack)\n | EQUAL ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_env = _menhir_discard _menhir_env in\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | BOOL _v ->\n _menhir_run105 _menhir_env (Obj.magic _menhir_stack) MenhirState96 _v\n | FLOAT _v ->\n _menhir_run104 _menhir_env (Obj.magic _menhir_stack) MenhirState96 _v\n | FRAGMENT ->\n _menhir_run11 _menhir_env (Obj.magic _menhir_stack) MenhirState96\n | INT _v ->\n _menhir_run103 _menhir_env (Obj.magic _menhir_stack) MenhirState96 _v\n | LBRACE ->\n _menhir_run100 _menhir_env (Obj.magic _menhir_stack) MenhirState96\n | LBRACK ->\n _menhir_run99 _menhir_env (Obj.magic _menhir_stack) MenhirState96\n | MUTATION ->\n _menhir_run10 _menhir_env (Obj.magic _menhir_stack) MenhirState96\n | NAME _v ->\n _menhir_run27 _menhir_env (Obj.magic _menhir_stack) MenhirState96 _v\n | NULL ->\n _menhir_run98 _menhir_env (Obj.magic _menhir_stack) MenhirState96\n | QUERY ->\n _menhir_run6 _menhir_env (Obj.magic _menhir_stack) MenhirState96\n | STRING _v ->\n _menhir_run97 _menhir_env (Obj.magic _menhir_stack) MenhirState96 _v\n | SUBSCRIPTION ->\n _menhir_run5 _menhir_env (Obj.magic _menhir_stack) MenhirState96\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState96)\n | DOLLAR | RPAREN ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _v : (Ast.const_value option) = \n# 114 \"\"\n ( None )\n# 1344 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_option_default_value_ _menhir_env _menhir_stack _v\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s)\n | _ ->\n _menhir_fail ()\n\nand _menhir_run90 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _menhir_stack = (_menhir_stack, _menhir_s) in\n let _menhir_env = _menhir_discard _menhir_env in\n let _tok = _menhir_env._menhir_token in\n match _tok with\n | BOOL _v ->\n _menhir_run14 _menhir_env (Obj.magic _menhir_stack) MenhirState90 _v\n | FRAGMENT ->\n _menhir_run11 _menhir_env (Obj.magic _menhir_stack) MenhirState90\n | LBRACK ->\n _menhir_run90 _menhir_env (Obj.magic _menhir_stack) MenhirState90\n | MUTATION ->\n _menhir_run10 _menhir_env (Obj.magic _menhir_stack) MenhirState90\n | NAME _v ->\n _menhir_run9 _menhir_env (Obj.magic _menhir_stack) MenhirState90 _v\n | NULL ->\n _menhir_run8 _menhir_env (Obj.magic _menhir_stack) MenhirState90\n | ON ->\n _menhir_run7 _menhir_env (Obj.magic _menhir_stack) MenhirState90\n | QUERY ->\n _menhir_run6 _menhir_env (Obj.magic _menhir_stack) MenhirState90\n | SUBSCRIPTION ->\n _menhir_run5 _menhir_env (Obj.magic _menhir_stack) MenhirState90\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState90\n\nand _menhir_goto_value : _menhir_env -> 'ttv_tail -> _menhir_state -> (Ast.value) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_stack = (_menhir_stack, _menhir_s, _v) in\n match _menhir_s with\n | MenhirState31 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | BOOL _v ->\n _menhir_run14 _menhir_env (Obj.magic _menhir_stack) MenhirState38 _v\n | FRAGMENT ->\n _menhir_run11 _menhir_env (Obj.magic _menhir_stack) MenhirState38\n | MUTATION ->\n _menhir_run10 _menhir_env (Obj.magic _menhir_stack) MenhirState38\n | NAME _v ->\n _menhir_run9 _menhir_env (Obj.magic _menhir_stack) MenhirState38 _v\n | NULL ->\n _menhir_run8 _menhir_env (Obj.magic _menhir_stack) MenhirState38\n | ON ->\n _menhir_run7 _menhir_env (Obj.magic _menhir_stack) MenhirState38\n | QUERY ->\n _menhir_run6 _menhir_env (Obj.magic _menhir_stack) MenhirState38\n | SUBSCRIPTION ->\n _menhir_run5 _menhir_env (Obj.magic _menhir_stack) MenhirState38\n | RBRACE ->\n _menhir_reduce26 _menhir_env (Obj.magic _menhir_stack) MenhirState38\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState38)\n | MenhirState44 | MenhirState28 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | BOOL _v ->\n _menhir_run36 _menhir_env (Obj.magic _menhir_stack) MenhirState44 _v\n | DOLLAR ->\n _menhir_run34 _menhir_env (Obj.magic _menhir_stack) MenhirState44\n | FLOAT _v ->\n _menhir_run33 _menhir_env (Obj.magic _menhir_stack) MenhirState44 _v\n | FRAGMENT ->\n _menhir_run11 _menhir_env (Obj.magic _menhir_stack) MenhirState44\n | INT _v ->\n _menhir_run32 _menhir_env (Obj.magic _menhir_stack) MenhirState44 _v\n | LBRACE ->\n _menhir_run29 _menhir_env (Obj.magic _menhir_stack) MenhirState44\n | LBRACK ->\n _menhir_run28 _menhir_env (Obj.magic _menhir_stack) MenhirState44\n | MUTATION ->\n _menhir_run10 _menhir_env (Obj.magic _menhir_stack) MenhirState44\n | NAME _v ->\n _menhir_run27 _menhir_env (Obj.magic _menhir_stack) MenhirState44 _v\n | NULL ->\n _menhir_run26 _menhir_env (Obj.magic _menhir_stack) MenhirState44\n | QUERY ->\n _menhir_run6 _menhir_env (Obj.magic _menhir_stack) MenhirState44\n | STRING _v ->\n _menhir_run25 _menhir_env (Obj.magic _menhir_stack) MenhirState44 _v\n | SUBSCRIPTION ->\n _menhir_run5 _menhir_env (Obj.magic _menhir_stack) MenhirState44\n | RBRACK ->\n _menhir_reduce34 _menhir_env (Obj.magic _menhir_stack) MenhirState44\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState44)\n | MenhirState24 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let ((_menhir_stack, _menhir_s, (_1 : (string))), _, (_3 : (Ast.value))) = _menhir_stack in\n let _v : (string * Ast.value) = \n# 166 \"graphql_parser/src/parser.mly\"\n ( _1, _3 )\n# 1460 \"graphql_parser/src/parser.ml\"\n in\n let _menhir_stack = (_menhir_stack, _menhir_s, _v) in\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | BOOL _v ->\n _menhir_run14 _menhir_env (Obj.magic _menhir_stack) MenhirState51 _v\n | FRAGMENT ->\n _menhir_run11 _menhir_env (Obj.magic _menhir_stack) MenhirState51\n | MUTATION ->\n _menhir_run10 _menhir_env (Obj.magic _menhir_stack) MenhirState51\n | NAME _v ->\n _menhir_run9 _menhir_env (Obj.magic _menhir_stack) MenhirState51 _v\n | NULL ->\n _menhir_run8 _menhir_env (Obj.magic _menhir_stack) MenhirState51\n | ON ->\n _menhir_run7 _menhir_env (Obj.magic _menhir_stack) MenhirState51\n | QUERY ->\n _menhir_run6 _menhir_env (Obj.magic _menhir_stack) MenhirState51\n | SUBSCRIPTION ->\n _menhir_run5 _menhir_env (Obj.magic _menhir_stack) MenhirState51\n | RPAREN ->\n _menhir_reduce28 _menhir_env (Obj.magic _menhir_stack) MenhirState51\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState51)\n | _ ->\n _menhir_fail ()\n\nand _menhir_run25 : _menhir_env -> 'ttv_tail -> _menhir_state -> (\n# 8 \"graphql_parser/src/parser.mly\"\n (string)\n# 1495 \"graphql_parser/src/parser.ml\"\n) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_1 : (\n# 8 \"graphql_parser/src/parser.mly\"\n (string)\n# 1503 \"graphql_parser/src/parser.ml\"\n )) = _v in\n let _v : (Ast.value) = \n# 172 \"graphql_parser/src/parser.mly\"\n ( `String _1 )\n# 1508 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_value_parser_value_ _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_run26 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let _v : (Ast.value) = \n# 169 \"graphql_parser/src/parser.mly\"\n ( `Null )\n# 1519 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_value_parser_value_ _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_run27 : _menhir_env -> 'ttv_tail -> _menhir_state -> (\n# 5 \"graphql_parser/src/parser.mly\"\n (string)\n# 1526 \"graphql_parser/src/parser.ml\"\n) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_1 : (\n# 5 \"graphql_parser/src/parser.mly\"\n (string)\n# 1534 \"graphql_parser/src/parser.ml\"\n )) = _v in\n let _v : (string) = \n# 193 \"graphql_parser/src/parser.mly\"\n ( _1 )\n# 1539 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_enum_value _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_run28 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _menhir_stack = (_menhir_stack, _menhir_s) in\n let _menhir_env = _menhir_discard _menhir_env in\n let _tok = _menhir_env._menhir_token in\n match _tok with\n | BOOL _v ->\n _menhir_run36 _menhir_env (Obj.magic _menhir_stack) MenhirState28 _v\n | DOLLAR ->\n _menhir_run34 _menhir_env (Obj.magic _menhir_stack) MenhirState28\n | FLOAT _v ->\n _menhir_run33 _menhir_env (Obj.magic _menhir_stack) MenhirState28 _v\n | FRAGMENT ->\n _menhir_run11 _menhir_env (Obj.magic _menhir_stack) MenhirState28\n | INT _v ->\n _menhir_run32 _menhir_env (Obj.magic _menhir_stack) MenhirState28 _v\n | LBRACE ->\n _menhir_run29 _menhir_env (Obj.magic _menhir_stack) MenhirState28\n | LBRACK ->\n _menhir_run28 _menhir_env (Obj.magic _menhir_stack) MenhirState28\n | MUTATION ->\n _menhir_run10 _menhir_env (Obj.magic _menhir_stack) MenhirState28\n | NAME _v ->\n _menhir_run27 _menhir_env (Obj.magic _menhir_stack) MenhirState28 _v\n | NULL ->\n _menhir_run26 _menhir_env (Obj.magic _menhir_stack) MenhirState28\n | QUERY ->\n _menhir_run6 _menhir_env (Obj.magic _menhir_stack) MenhirState28\n | STRING _v ->\n _menhir_run25 _menhir_env (Obj.magic _menhir_stack) MenhirState28 _v\n | SUBSCRIPTION ->\n _menhir_run5 _menhir_env (Obj.magic _menhir_stack) MenhirState28\n | RBRACK ->\n _menhir_reduce34 _menhir_env (Obj.magic _menhir_stack) MenhirState28\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState28\n\nand _menhir_run29 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _menhir_stack = (_menhir_stack, _menhir_s) in\n let _menhir_env = _menhir_discard _menhir_env in\n let _tok = _menhir_env._menhir_token in\n match _tok with\n | BOOL _v ->\n _menhir_run14 _menhir_env (Obj.magic _menhir_stack) MenhirState29 _v\n | FRAGMENT ->\n _menhir_run11 _menhir_env (Obj.magic _menhir_stack) MenhirState29\n | MUTATION ->\n _menhir_run10 _menhir_env (Obj.magic _menhir_stack) MenhirState29\n | NAME _v ->\n _menhir_run9 _menhir_env (Obj.magic _menhir_stack) MenhirState29 _v\n | NULL ->\n _menhir_run8 _menhir_env (Obj.magic _menhir_stack) MenhirState29\n | ON ->\n _menhir_run7 _menhir_env (Obj.magic _menhir_stack) MenhirState29\n | QUERY ->\n _menhir_run6 _menhir_env (Obj.magic _menhir_stack) MenhirState29\n | SUBSCRIPTION ->\n _menhir_run5 _menhir_env (Obj.magic _menhir_stack) MenhirState29\n | RBRACE ->\n _menhir_reduce26 _menhir_env (Obj.magic _menhir_stack) MenhirState29\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState29\n\nand _menhir_run32 : _menhir_env -> 'ttv_tail -> _menhir_state -> (\n# 6 \"graphql_parser/src/parser.mly\"\n (int)\n# 1614 \"graphql_parser/src/parser.ml\"\n) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_1 : (\n# 6 \"graphql_parser/src/parser.mly\"\n (int)\n# 1622 \"graphql_parser/src/parser.ml\"\n )) = _v in\n let _v : (Ast.value) = \n# 170 \"graphql_parser/src/parser.mly\"\n ( `Int _1 )\n# 1627 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_value_parser_value_ _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_run33 : _menhir_env -> 'ttv_tail -> _menhir_state -> (\n# 7 \"graphql_parser/src/parser.mly\"\n (float)\n# 1634 \"graphql_parser/src/parser.ml\"\n) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_1 : (\n# 7 \"graphql_parser/src/parser.mly\"\n (float)\n# 1642 \"graphql_parser/src/parser.ml\"\n )) = _v in\n let _v : (Ast.value) = \n# 171 \"graphql_parser/src/parser.mly\"\n ( `Float _1 )\n# 1647 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_value_parser_value_ _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_run34 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _menhir_stack = (_menhir_stack, _menhir_s) in\n let _menhir_env = _menhir_discard _menhir_env in\n let _tok = _menhir_env._menhir_token in\n match _tok with\n | BOOL _v ->\n _menhir_run14 _menhir_env (Obj.magic _menhir_stack) MenhirState34 _v\n | FRAGMENT ->\n _menhir_run11 _menhir_env (Obj.magic _menhir_stack) MenhirState34\n | MUTATION ->\n _menhir_run10 _menhir_env (Obj.magic _menhir_stack) MenhirState34\n | NAME _v ->\n _menhir_run9 _menhir_env (Obj.magic _menhir_stack) MenhirState34 _v\n | NULL ->\n _menhir_run8 _menhir_env (Obj.magic _menhir_stack) MenhirState34\n | ON ->\n _menhir_run7 _menhir_env (Obj.magic _menhir_stack) MenhirState34\n | QUERY ->\n _menhir_run6 _menhir_env (Obj.magic _menhir_stack) MenhirState34\n | SUBSCRIPTION ->\n _menhir_run5 _menhir_env (Obj.magic _menhir_stack) MenhirState34\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState34\n\nand _menhir_run36 : _menhir_env -> 'ttv_tail -> _menhir_state -> (\n# 9 \"graphql_parser/src/parser.mly\"\n (bool)\n# 1681 \"graphql_parser/src/parser.ml\"\n) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_1 : (\n# 9 \"graphql_parser/src/parser.mly\"\n (bool)\n# 1689 \"graphql_parser/src/parser.ml\"\n )) = _v in\n let _v : (Ast.value) = \n# 173 \"graphql_parser/src/parser.mly\"\n ( `Bool _1 )\n# 1694 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_value_parser_value_ _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_reduce38 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _v : ((string * Ast.value) list) = \n# 142 \"\"\n ( [] )\n# 1703 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_loption_arguments_ _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_run22 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _menhir_stack = (_menhir_stack, _menhir_s) in\n let _menhir_env = _menhir_discard _menhir_env in\n let _tok = _menhir_env._menhir_token in\n match _tok with\n | BOOL _v ->\n _menhir_run14 _menhir_env (Obj.magic _menhir_stack) MenhirState22 _v\n | FRAGMENT ->\n _menhir_run11 _menhir_env (Obj.magic _menhir_stack) MenhirState22\n | MUTATION ->\n _menhir_run10 _menhir_env (Obj.magic _menhir_stack) MenhirState22\n | NAME _v ->\n _menhir_run9 _menhir_env (Obj.magic _menhir_stack) MenhirState22 _v\n | NULL ->\n _menhir_run8 _menhir_env (Obj.magic _menhir_stack) MenhirState22\n | ON ->\n _menhir_run7 _menhir_env (Obj.magic _menhir_stack) MenhirState22\n | QUERY ->\n _menhir_run6 _menhir_env (Obj.magic _menhir_stack) MenhirState22\n | SUBSCRIPTION ->\n _menhir_run5 _menhir_env (Obj.magic _menhir_stack) MenhirState22\n | RPAREN ->\n _menhir_reduce28 _menhir_env (Obj.magic _menhir_stack) MenhirState22\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState22\n\nand _menhir_goto_enum_value : _menhir_env -> 'ttv_tail -> _menhir_state -> (string) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n match _menhir_s with\n | MenhirState24 | MenhirState28 | MenhirState44 | MenhirState31 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_1 : (string)) = _v in\n let _v : (Ast.value) = \n# 174 \"graphql_parser/src/parser.mly\"\n ( `Enum _1 )\n# 1746 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_value_parser_value_ _menhir_env _menhir_stack _menhir_s _v\n | MenhirState96 | MenhirState114 | MenhirState99 | MenhirState102 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_1 : (string)) = _v in\n let _v : (Ast.const_value) = \n# 174 \"graphql_parser/src/parser.mly\"\n ( `Enum _1 )\n# 1756 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_value_parser_const_value_ _menhir_env _menhir_stack _menhir_s _v\n | _ ->\n _menhir_fail ()\n\nand _menhir_fail : unit -> 'a =\n fun () ->\n Printf.fprintf stderr \"Internal failure -- please contact the parser generator's developers.\\n%!\";\n assert false\n\nand _menhir_reduce32 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _v : (Ast.directive list) = \n# 211 \"\"\n ( [] )\n# 1772 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_list_directive_ _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_run20 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _menhir_stack = (_menhir_stack, _menhir_s) in\n let _menhir_env = _menhir_discard _menhir_env in\n let _tok = _menhir_env._menhir_token in\n match _tok with\n | BOOL _v ->\n _menhir_run14 _menhir_env (Obj.magic _menhir_stack) MenhirState20 _v\n | FRAGMENT ->\n _menhir_run11 _menhir_env (Obj.magic _menhir_stack) MenhirState20\n | MUTATION ->\n _menhir_run10 _menhir_env (Obj.magic _menhir_stack) MenhirState20\n | NAME _v ->\n _menhir_run9 _menhir_env (Obj.magic _menhir_stack) MenhirState20 _v\n | NULL ->\n _menhir_run8 _menhir_env (Obj.magic _menhir_stack) MenhirState20\n | ON ->\n _menhir_run7 _menhir_env (Obj.magic _menhir_stack) MenhirState20\n | QUERY ->\n _menhir_run6 _menhir_env (Obj.magic _menhir_stack) MenhirState20\n | SUBSCRIPTION ->\n _menhir_run5 _menhir_env (Obj.magic _menhir_stack) MenhirState20\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState20\n\nand _menhir_goto_option_name_ : _menhir_env -> 'ttv_tail -> _menhir_state -> (string option) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_stack = (_menhir_stack, _menhir_s, _v) in\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n match _tok with\n | LPAREN ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_env = _menhir_discard _menhir_env in\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | DOLLAR ->\n _menhir_run87 _menhir_env (Obj.magic _menhir_stack) MenhirState86\n | RPAREN ->\n _menhir_reduce36 _menhir_env (Obj.magic _menhir_stack) MenhirState86\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState86)\n | AT | LBRACE ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _v : (Ast.variable_definition list) = \n# 142 \"\"\n ( [] )\n# 1828 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_loption_variable_definitions_ _menhir_env _menhir_stack _v\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n\nand _menhir_goto_name : _menhir_env -> 'ttv_tail -> _menhir_state -> (string) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_stack = (_menhir_stack, _menhir_s, _v) in\n match _menhir_s with\n | MenhirState13 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let ((_menhir_stack, _menhir_s), _, (_2 : (string))) = _menhir_stack in\n let _v : (string) = \n# 121 \"graphql_parser/src/parser.mly\"\n ( _2 )\n# 1849 \"graphql_parser/src/parser.ml\"\n in\n let _menhir_stack = (_menhir_stack, _menhir_s, _v) in\n (match _menhir_s with\n | MenhirState12 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, (x : (string))) = _menhir_stack in\n let _v : (string option) = \n# 116 \"\"\n ( Some x )\n# 1860 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_option_type_condition_ _menhir_env _menhir_stack _menhir_s _v\n | MenhirState79 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | AT ->\n _menhir_run20 _menhir_env (Obj.magic _menhir_stack) MenhirState80\n | LBRACE ->\n _menhir_reduce32 _menhir_env (Obj.magic _menhir_stack) MenhirState80\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState80)\n | _ ->\n _menhir_fail ())\n | MenhirState20 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | LPAREN ->\n _menhir_run22 _menhir_env (Obj.magic _menhir_stack) MenhirState21\n | AT | BOOL _ | ELLIPSIS | FRAGMENT | LBRACE | MUTATION | NAME _ | NULL | ON | QUERY | RBRACE | SUBSCRIPTION ->\n _menhir_reduce38 _menhir_env (Obj.magic _menhir_stack) MenhirState21\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState21)\n | MenhirState51 | MenhirState22 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | COLON ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_env = _menhir_discard _menhir_env in\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | BOOL _v ->\n _menhir_run36 _menhir_env (Obj.magic _menhir_stack) MenhirState24 _v\n | DOLLAR ->\n _menhir_run34 _menhir_env (Obj.magic _menhir_stack) MenhirState24\n | FLOAT _v ->\n _menhir_run33 _menhir_env (Obj.magic _menhir_stack) MenhirState24 _v\n | FRAGMENT ->\n _menhir_run11 _menhir_env (Obj.magic _menhir_stack) MenhirState24\n | INT _v ->\n _menhir_run32 _menhir_env (Obj.magic _menhir_stack) MenhirState24 _v\n | LBRACE ->\n _menhir_run29 _menhir_env (Obj.magic _menhir_stack) MenhirState24\n | LBRACK ->\n _menhir_run28 _menhir_env (Obj.magic _menhir_stack) MenhirState24\n | MUTATION ->\n _menhir_run10 _menhir_env (Obj.magic _menhir_stack) MenhirState24\n | NAME _v ->\n _menhir_run27 _menhir_env (Obj.magic _menhir_stack) MenhirState24 _v\n | NULL ->\n _menhir_run26 _menhir_env (Obj.magic _menhir_stack) MenhirState24\n | QUERY ->\n _menhir_run6 _menhir_env (Obj.magic _menhir_stack) MenhirState24\n | STRING _v ->\n _menhir_run25 _menhir_env (Obj.magic _menhir_stack) MenhirState24 _v\n | SUBSCRIPTION ->\n _menhir_run5 _menhir_env (Obj.magic _menhir_stack) MenhirState24\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState24)\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s)\n | MenhirState38 | MenhirState29 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | COLON ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_env = _menhir_discard _menhir_env in\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | BOOL _v ->\n _menhir_run36 _menhir_env (Obj.magic _menhir_stack) MenhirState31 _v\n | DOLLAR ->\n _menhir_run34 _menhir_env (Obj.magic _menhir_stack) MenhirState31\n | FLOAT _v ->\n _menhir_run33 _menhir_env (Obj.magic _menhir_stack) MenhirState31 _v\n | FRAGMENT ->\n _menhir_run11 _menhir_env (Obj.magic _menhir_stack) MenhirState31\n | INT _v ->\n _menhir_run32 _menhir_env (Obj.magic _menhir_stack) MenhirState31 _v\n | LBRACE ->\n _menhir_run29 _menhir_env (Obj.magic _menhir_stack) MenhirState31\n | LBRACK ->\n _menhir_run28 _menhir_env (Obj.magic _menhir_stack) MenhirState31\n | MUTATION ->\n _menhir_run10 _menhir_env (Obj.magic _menhir_stack) MenhirState31\n | NAME _v ->\n _menhir_run27 _menhir_env (Obj.magic _menhir_stack) MenhirState31 _v\n | NULL ->\n _menhir_run26 _menhir_env (Obj.magic _menhir_stack) MenhirState31\n | QUERY ->\n _menhir_run6 _menhir_env (Obj.magic _menhir_stack) MenhirState31\n | STRING _v ->\n _menhir_run25 _menhir_env (Obj.magic _menhir_stack) MenhirState31 _v\n | SUBSCRIPTION ->\n _menhir_run5 _menhir_env (Obj.magic _menhir_stack) MenhirState31\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState31)\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s)\n | MenhirState34 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let ((_menhir_stack, _menhir_s), _, (_2 : (string))) = _menhir_stack in\n let _v : (Ast.value) = \n# 179 \"graphql_parser/src/parser.mly\"\n ( `Variable _2 )\n# 1990 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_value _menhir_env _menhir_stack _menhir_s _v\n | MenhirState4 | MenhirState61 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | COLON ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_s = MenhirState63 in\n let _menhir_stack = (_menhir_stack, _menhir_s) in\n let _menhir_env = _menhir_discard _menhir_env in\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | BOOL _v ->\n _menhir_run14 _menhir_env (Obj.magic _menhir_stack) MenhirState64 _v\n | FRAGMENT ->\n _menhir_run11 _menhir_env (Obj.magic _menhir_stack) MenhirState64\n | MUTATION ->\n _menhir_run10 _menhir_env (Obj.magic _menhir_stack) MenhirState64\n | NAME _v ->\n _menhir_run9 _menhir_env (Obj.magic _menhir_stack) MenhirState64 _v\n | NULL ->\n _menhir_run8 _menhir_env (Obj.magic _menhir_stack) MenhirState64\n | ON ->\n _menhir_run7 _menhir_env (Obj.magic _menhir_stack) MenhirState64\n | QUERY ->\n _menhir_run6 _menhir_env (Obj.magic _menhir_stack) MenhirState64\n | SUBSCRIPTION ->\n _menhir_run5 _menhir_env (Obj.magic _menhir_stack) MenhirState64\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState64)\n | LPAREN ->\n _menhir_run22 _menhir_env (Obj.magic _menhir_stack) MenhirState63\n | AT | BOOL _ | ELLIPSIS | FRAGMENT | LBRACE | MUTATION | NAME _ | NULL | ON | QUERY | RBRACE | SUBSCRIPTION ->\n _menhir_reduce38 _menhir_env (Obj.magic _menhir_stack) MenhirState63\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState63)\n | MenhirState64 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | LPAREN ->\n _menhir_run22 _menhir_env (Obj.magic _menhir_stack) MenhirState65\n | AT | BOOL _ | ELLIPSIS | FRAGMENT | LBRACE | MUTATION | NAME _ | NULL | ON | QUERY | RBRACE | SUBSCRIPTION ->\n _menhir_reduce38 _menhir_env (Obj.magic _menhir_stack) MenhirState65\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState65)\n | MenhirState87 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | COLON ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_env = _menhir_discard _menhir_env in\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | BOOL _v ->\n _menhir_run14 _menhir_env (Obj.magic _menhir_stack) MenhirState89 _v\n | FRAGMENT ->\n _menhir_run11 _menhir_env (Obj.magic _menhir_stack) MenhirState89\n | LBRACK ->\n _menhir_run90 _menhir_env (Obj.magic _menhir_stack) MenhirState89\n | MUTATION ->\n _menhir_run10 _menhir_env (Obj.magic _menhir_stack) MenhirState89\n | NAME _v ->\n _menhir_run9 _menhir_env (Obj.magic _menhir_stack) MenhirState89 _v\n | NULL ->\n _menhir_run8 _menhir_env (Obj.magic _menhir_stack) MenhirState89\n | ON ->\n _menhir_run7 _menhir_env (Obj.magic _menhir_stack) MenhirState89\n | QUERY ->\n _menhir_run6 _menhir_env (Obj.magic _menhir_stack) MenhirState89\n | SUBSCRIPTION ->\n _menhir_run5 _menhir_env (Obj.magic _menhir_stack) MenhirState89\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState89)\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s)\n | MenhirState89 | MenhirState90 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, (_1 : (string))) = _menhir_stack in\n let _v : (Ast.typ) = \n# 149 \"graphql_parser/src/parser.mly\"\n ( NamedType _1 )\n# 2091 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_typ _menhir_env _menhir_stack _menhir_s _v\n | MenhirState108 | MenhirState100 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | COLON ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_env = _menhir_discard _menhir_env in\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | BOOL _v ->\n _menhir_run105 _menhir_env (Obj.magic _menhir_stack) MenhirState102 _v\n | FLOAT _v ->\n _menhir_run104 _menhir_env (Obj.magic _menhir_stack) MenhirState102 _v\n | FRAGMENT ->\n _menhir_run11 _menhir_env (Obj.magic _menhir_stack) MenhirState102\n | INT _v ->\n _menhir_run103 _menhir_env (Obj.magic _menhir_stack) MenhirState102 _v\n | LBRACE ->\n _menhir_run100 _menhir_env (Obj.magic _menhir_stack) MenhirState102\n | LBRACK ->\n _menhir_run99 _menhir_env (Obj.magic _menhir_stack) MenhirState102\n | MUTATION ->\n _menhir_run10 _menhir_env (Obj.magic _menhir_stack) MenhirState102\n | NAME _v ->\n _menhir_run27 _menhir_env (Obj.magic _menhir_stack) MenhirState102 _v\n | NULL ->\n _menhir_run98 _menhir_env (Obj.magic _menhir_stack) MenhirState102\n | QUERY ->\n _menhir_run6 _menhir_env (Obj.magic _menhir_stack) MenhirState102\n | STRING _v ->\n _menhir_run97 _menhir_env (Obj.magic _menhir_stack) MenhirState102 _v\n | SUBSCRIPTION ->\n _menhir_run5 _menhir_env (Obj.magic _menhir_stack) MenhirState102\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState102)\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s)\n | MenhirState84 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, (x : (string))) = _menhir_stack in\n let _v : (string option) = \n# 116 \"\"\n ( Some x )\n# 2145 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_option_name_ _menhir_env _menhir_stack _menhir_s _v\n | _ ->\n _menhir_fail ()\n\nand _menhir_goto_option_type_condition_ : _menhir_env -> 'ttv_tail -> _menhir_state -> (string option) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_stack = (_menhir_stack, _menhir_s, _v) in\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n match _tok with\n | AT ->\n _menhir_run20 _menhir_env (Obj.magic _menhir_stack) MenhirState19\n | LBRACE ->\n _menhir_reduce32 _menhir_env (Obj.magic _menhir_stack) MenhirState19\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState19\n\nand _menhir_run13 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _menhir_stack = (_menhir_stack, _menhir_s) in\n let _menhir_env = _menhir_discard _menhir_env in\n let _tok = _menhir_env._menhir_token in\n match _tok with\n | BOOL _v ->\n _menhir_run14 _menhir_env (Obj.magic _menhir_stack) MenhirState13 _v\n | FRAGMENT ->\n _menhir_run11 _menhir_env (Obj.magic _menhir_stack) MenhirState13\n | MUTATION ->\n _menhir_run10 _menhir_env (Obj.magic _menhir_stack) MenhirState13\n | NAME _v ->\n _menhir_run9 _menhir_env (Obj.magic _menhir_stack) MenhirState13 _v\n | NULL ->\n _menhir_run8 _menhir_env (Obj.magic _menhir_stack) MenhirState13\n | ON ->\n _menhir_run7 _menhir_env (Obj.magic _menhir_stack) MenhirState13\n | QUERY ->\n _menhir_run6 _menhir_env (Obj.magic _menhir_stack) MenhirState13\n | SUBSCRIPTION ->\n _menhir_run5 _menhir_env (Obj.magic _menhir_stack) MenhirState13\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState13\n\nand _menhir_goto_keyword_name : _menhir_env -> 'ttv_tail -> _menhir_state -> (string) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n match _menhir_s with\n | MenhirState84 | MenhirState87 | MenhirState89 | MenhirState100 | MenhirState108 | MenhirState90 | MenhirState78 | MenhirState4 | MenhirState61 | MenhirState64 | MenhirState12 | MenhirState20 | MenhirState51 | MenhirState22 | MenhirState29 | MenhirState38 | MenhirState34 | MenhirState13 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_1 : (string)) = _v in\n let _v : (string) = \n# 199 \"graphql_parser/src/parser.mly\"\n ( _1 )\n# 2204 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_fragment_name _menhir_env _menhir_stack _menhir_s _v\n | MenhirState96 | MenhirState114 | MenhirState99 | MenhirState102 | MenhirState24 | MenhirState28 | MenhirState44 | MenhirState31 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_1 : (string)) = _v in\n let _v : (string) = \n# 193 \"graphql_parser/src/parser.mly\"\n ( _1 )\n# 2214 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_enum_value _menhir_env _menhir_stack _menhir_s _v\n | _ ->\n _menhir_fail ()\n\nand _menhir_goto_fragment_name : _menhir_env -> 'ttv_tail -> _menhir_state -> (string) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_stack = (_menhir_stack, _menhir_s, _v) in\n match _menhir_s with\n | MenhirState84 | MenhirState87 | MenhirState89 | MenhirState100 | MenhirState108 | MenhirState90 | MenhirState4 | MenhirState61 | MenhirState64 | MenhirState20 | MenhirState51 | MenhirState22 | MenhirState29 | MenhirState38 | MenhirState34 | MenhirState13 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, (_1 : (string))) = _menhir_stack in\n let _v : (string) = \n# 202 \"graphql_parser/src/parser.mly\"\n ( _1 )\n# 2231 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_name _menhir_env _menhir_stack _menhir_s _v\n | MenhirState12 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | AT ->\n _menhir_run20 _menhir_env (Obj.magic _menhir_stack) MenhirState59\n | BOOL _ | ELLIPSIS | FRAGMENT | MUTATION | NAME _ | NULL | ON | QUERY | RBRACE | SUBSCRIPTION ->\n _menhir_reduce32 _menhir_env (Obj.magic _menhir_stack) MenhirState59\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState59)\n | MenhirState78 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | ON ->\n _menhir_run13 _menhir_env (Obj.magic _menhir_stack) MenhirState79\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState79)\n | _ ->\n _menhir_fail ()\n\nand _menhir_goto_optype : _menhir_env -> 'ttv_tail -> _menhir_state -> (Ast.optype) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_stack = (_menhir_stack, _menhir_s, _v) in\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n match _tok with\n | BOOL _v ->\n _menhir_run14 _menhir_env (Obj.magic _menhir_stack) MenhirState84 _v\n | FRAGMENT ->\n _menhir_run11 _menhir_env (Obj.magic _menhir_stack) MenhirState84\n | MUTATION ->\n _menhir_run10 _menhir_env (Obj.magic _menhir_stack) MenhirState84\n | NAME _v ->\n _menhir_run9 _menhir_env (Obj.magic _menhir_stack) MenhirState84 _v\n | NULL ->\n _menhir_run8 _menhir_env (Obj.magic _menhir_stack) MenhirState84\n | ON ->\n _menhir_run7 _menhir_env (Obj.magic _menhir_stack) MenhirState84\n | QUERY ->\n _menhir_run6 _menhir_env (Obj.magic _menhir_stack) MenhirState84\n | SUBSCRIPTION ->\n _menhir_run5 _menhir_env (Obj.magic _menhir_stack) MenhirState84\n | AT | LBRACE | LPAREN ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_s = MenhirState84 in\n let _v : (string option) = \n# 114 \"\"\n ( None )\n# 2290 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_option_name_ _menhir_env _menhir_stack _menhir_s _v\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState84\n\nand _menhir_run7 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let _v : (string) = \n# 203 \"graphql_parser/src/parser.mly\"\n ( \"on\" )\n# 2305 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_name _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_run12 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _menhir_stack = (_menhir_stack, _menhir_s) in\n let _menhir_env = _menhir_discard _menhir_env in\n let _tok = _menhir_env._menhir_token in\n match _tok with\n | BOOL _v ->\n _menhir_run14 _menhir_env (Obj.magic _menhir_stack) MenhirState12 _v\n | FRAGMENT ->\n _menhir_run11 _menhir_env (Obj.magic _menhir_stack) MenhirState12\n | MUTATION ->\n _menhir_run10 _menhir_env (Obj.magic _menhir_stack) MenhirState12\n | NAME _v ->\n _menhir_run9 _menhir_env (Obj.magic _menhir_stack) MenhirState12 _v\n | NULL ->\n _menhir_run8 _menhir_env (Obj.magic _menhir_stack) MenhirState12\n | ON ->\n _menhir_run13 _menhir_env (Obj.magic _menhir_stack) MenhirState12\n | QUERY ->\n _menhir_run6 _menhir_env (Obj.magic _menhir_stack) MenhirState12\n | SUBSCRIPTION ->\n _menhir_run5 _menhir_env (Obj.magic _menhir_stack) MenhirState12\n | AT | LBRACE ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_s = MenhirState12 in\n let _v : (string option) = \n# 114 \"\"\n ( None )\n# 2337 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_option_type_condition_ _menhir_env _menhir_stack _menhir_s _v\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState12\n\nand _menhir_run5 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let _v : (string) = \n# 188 \"graphql_parser/src/parser.mly\"\n ( \"subscription\" )\n# 2352 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_keyword_name _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_run6 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let _v : (string) = \n# 186 \"graphql_parser/src/parser.mly\"\n ( \"query\" )\n# 2363 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_keyword_name _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_run8 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let _v : (string) = \n# 196 \"graphql_parser/src/parser.mly\"\n ( \"null\" )\n# 2374 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_fragment_name _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_run9 : _menhir_env -> 'ttv_tail -> _menhir_state -> (\n# 5 \"graphql_parser/src/parser.mly\"\n (string)\n# 2381 \"graphql_parser/src/parser.ml\"\n) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_1 : (\n# 5 \"graphql_parser/src/parser.mly\"\n (string)\n# 2389 \"graphql_parser/src/parser.ml\"\n )) = _v in\n let _v : (string) = \n# 199 \"graphql_parser/src/parser.mly\"\n ( _1 )\n# 2394 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_fragment_name _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_run10 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let _v : (string) = \n# 187 \"graphql_parser/src/parser.mly\"\n ( \"mutation\" )\n# 2405 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_keyword_name _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_run11 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let _v : (string) = \n# 189 \"graphql_parser/src/parser.mly\"\n ( \"fragment\" )\n# 2416 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_keyword_name _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_run14 : _menhir_env -> 'ttv_tail -> _menhir_state -> (\n# 9 \"graphql_parser/src/parser.mly\"\n (bool)\n# 2423 \"graphql_parser/src/parser.ml\"\n) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_1 : (\n# 9 \"graphql_parser/src/parser.mly\"\n (bool)\n# 2431 \"graphql_parser/src/parser.ml\"\n )) = _v in\n let _v : (string) = \n# 197 \"graphql_parser/src/parser.mly\"\n ( string_of_bool _1 )\n# 2436 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_fragment_name _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_errorcase : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n match _menhir_s with\n | MenhirState133 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState125 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState124 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let ((_menhir_stack, _menhir_s, _), _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState119 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState114 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState108 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState102 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState100 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState99 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState96 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n raise _eRR\n | MenhirState90 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState89 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState87 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState86 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n raise _eRR\n | MenhirState84 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState81 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState80 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState79 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState78 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState71 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState70 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState67 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState66 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState65 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState64 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState63 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState61 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState59 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState57 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState55 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState51 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState44 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState38 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState34 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState31 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState29 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState28 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState24 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState22 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState21 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState20 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState19 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState13 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState12 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState4 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState0 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n raise _eRR\n\nand _menhir_run1 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let _v : (Ast.optype) = \n# 79 \"graphql_parser/src/parser.mly\"\n ( Subscription )\n# 2632 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_optype _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_run2 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let _v : (Ast.optype) = \n# 77 \"graphql_parser/src/parser.mly\"\n ( Query )\n# 2643 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_optype _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_run3 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let _v : (Ast.optype) = \n# 78 \"graphql_parser/src/parser.mly\"\n ( Mutation )\n# 2654 \"graphql_parser/src/parser.ml\"\n in\n _menhir_goto_optype _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_run4 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _menhir_stack = (_menhir_stack, _menhir_s) in\n let _menhir_env = _menhir_discard _menhir_env in\n let _tok = _menhir_env._menhir_token in\n match _tok with\n | BOOL _v ->\n _menhir_run14 _menhir_env (Obj.magic _menhir_stack) MenhirState4 _v\n | ELLIPSIS ->\n _menhir_run12 _menhir_env (Obj.magic _menhir_stack) MenhirState4\n | FRAGMENT ->\n _menhir_run11 _menhir_env (Obj.magic _menhir_stack) MenhirState4\n | MUTATION ->\n _menhir_run10 _menhir_env (Obj.magic _menhir_stack) MenhirState4\n | NAME _v ->\n _menhir_run9 _menhir_env (Obj.magic _menhir_stack) MenhirState4 _v\n | NULL ->\n _menhir_run8 _menhir_env (Obj.magic _menhir_stack) MenhirState4\n | ON ->\n _menhir_run7 _menhir_env (Obj.magic _menhir_stack) MenhirState4\n | QUERY ->\n _menhir_run6 _menhir_env (Obj.magic _menhir_stack) MenhirState4\n | SUBSCRIPTION ->\n _menhir_run5 _menhir_env (Obj.magic _menhir_stack) MenhirState4\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState4\n\nand _menhir_run78 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _menhir_stack = (_menhir_stack, _menhir_s) in\n let _menhir_env = _menhir_discard _menhir_env in\n let _tok = _menhir_env._menhir_token in\n match _tok with\n | BOOL _v ->\n _menhir_run14 _menhir_env (Obj.magic _menhir_stack) MenhirState78 _v\n | FRAGMENT ->\n _menhir_run11 _menhir_env (Obj.magic _menhir_stack) MenhirState78\n | MUTATION ->\n _menhir_run10 _menhir_env (Obj.magic _menhir_stack) MenhirState78\n | NAME _v ->\n _menhir_run9 _menhir_env (Obj.magic _menhir_stack) MenhirState78 _v\n | NULL ->\n _menhir_run8 _menhir_env (Obj.magic _menhir_stack) MenhirState78\n | QUERY ->\n _menhir_run6 _menhir_env (Obj.magic _menhir_stack) MenhirState78\n | SUBSCRIPTION ->\n _menhir_run5 _menhir_env (Obj.magic _menhir_stack) MenhirState78\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState78\n\nand _menhir_discard : _menhir_env -> _menhir_env =\n fun _menhir_env ->\n let lexer = _menhir_env._menhir_lexer in\n let lexbuf = _menhir_env._menhir_lexbuf in\n let _tok = lexer lexbuf in\n {\n _menhir_lexer = lexer;\n _menhir_lexbuf = lexbuf;\n _menhir_token = _tok;\n _menhir_error = false;\n }\n\nand doc : (Lexing.lexbuf -> token) -> Lexing.lexbuf -> (Ast.document) =\n fun lexer lexbuf ->\n let _menhir_env = {\n _menhir_lexer = lexer;\n _menhir_lexbuf = lexbuf;\n _menhir_token = Obj.magic ();\n _menhir_error = false;\n } in\n Obj.magic (let _menhir_stack = ((), _menhir_env._menhir_lexbuf.Lexing.lex_curr_p) in\n let _menhir_env = _menhir_discard _menhir_env in\n let _tok = _menhir_env._menhir_token in\n match _tok with\n | FRAGMENT ->\n _menhir_run78 _menhir_env (Obj.magic _menhir_stack) MenhirState0\n | LBRACE ->\n _menhir_run4 _menhir_env (Obj.magic _menhir_stack) MenhirState0\n | MUTATION ->\n _menhir_run3 _menhir_env (Obj.magic _menhir_stack) MenhirState0\n | QUERY ->\n _menhir_run2 _menhir_env (Obj.magic _menhir_stack) MenhirState0\n | SUBSCRIPTION ->\n _menhir_run1 _menhir_env (Obj.magic _menhir_stack) MenhirState0\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState0)\n\n# 269 \"\"\n \n\n# 2754 \"graphql_parser/src/parser.ml\"\n","# 1 \"graphql_parser/src/lexer.mll\"\n \nopen Lexing\nopen Parser\n\nexception Error of string\n\n# 9 \"graphql_parser/src/lexer.ml\"\nlet __ocaml_lex_tables = {\n Lexing.lex_base =\n \"\\000\\000\\227\\255\\228\\255\\229\\255\\230\\255\\231\\255\\232\\255\\233\\255\\\n \\234\\255\\235\\255\\001\\000\\237\\255\\238\\255\\239\\255\\240\\255\\078\\000\\\n \\160\\000\\235\\000\\054\\001\\129\\001\\204\\001\\023\\002\\098\\002\\250\\255\\\n \\175\\002\\176\\002\\185\\002\\253\\255\\001\\000\\191\\000\\234\\002\\203\\002\\\n \\231\\002\\241\\002\\007\\003\\017\\003\\027\\003\\039\\003\\049\\003\\059\\003\\\n \\134\\003\\209\\003\\028\\004\\103\\004\\178\\004\\253\\004\\072\\005\\147\\005\\\n \\222\\005\\041\\006\\116\\006\\191\\006\\010\\007\\085\\007\\160\\007\\235\\007\\\n \\054\\008\\129\\008\\204\\008\\023\\009\\098\\009\\173\\009\\248\\009\\067\\010\\\n \\142\\010\\217\\010\\036\\011\\111\\011\\186\\011\\005\\012\\080\\012\\155\\012\\\n \\230\\012\\049\\013\\124\\013\\199\\013\\018\\014\\093\\014\\168\\014\\013\\000\\\n \\236\\255\\025\\015\\026\\015\\006\\015\\255\\255\\247\\255\\248\\255\\249\\255\\\n \\250\\255\\251\\255\\252\\255\\253\\255\\254\\255\";\n Lexing.lex_backtrk =\n \"\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\027\\000\\255\\255\\255\\255\\255\\255\\255\\255\\014\\000\\\n \\014\\000\\014\\000\\014\\000\\014\\000\\014\\000\\014\\000\\014\\000\\255\\255\\\n \\003\\000\\003\\000\\027\\000\\255\\255\\002\\000\\001\\000\\000\\000\\255\\255\\\n \\255\\255\\004\\000\\255\\255\\004\\000\\255\\255\\004\\000\\255\\255\\014\\000\\\n \\014\\000\\014\\000\\014\\000\\006\\000\\014\\000\\014\\000\\014\\000\\014\\000\\\n \\014\\000\\007\\000\\014\\000\\014\\000\\014\\000\\014\\000\\014\\000\\014\\000\\\n \\008\\000\\014\\000\\014\\000\\009\\000\\010\\000\\014\\000\\014\\000\\014\\000\\\n \\011\\000\\014\\000\\014\\000\\014\\000\\014\\000\\014\\000\\014\\000\\014\\000\\\n \\014\\000\\014\\000\\014\\000\\012\\000\\014\\000\\014\\000\\013\\000\\255\\255\\\n \\255\\255\\255\\255\\009\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\";\n Lexing.lex_default =\n \"\\002\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\255\\255\\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\\n \\255\\255\\255\\255\\255\\255\\000\\000\\255\\255\\029\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\000\\000\\082\\000\\082\\000\\255\\255\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\";\n Lexing.lex_trans =\n \"\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\030\\000\\027\\000\\027\\000\\000\\000\\028\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\030\\000\\014\\000\\023\\000\\029\\000\\013\\000\\000\\000\\000\\000\\000\\000\\\n \\012\\000\\011\\000\\000\\000\\000\\000\\030\\000\\026\\000\\010\\000\\079\\000\\\n \\025\\000\\024\\000\\024\\000\\024\\000\\024\\000\\024\\000\\024\\000\\024\\000\\\n \\024\\000\\024\\000\\009\\000\\080\\000\\000\\000\\008\\000\\000\\000\\000\\000\\\n \\007\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\006\\000\\000\\000\\005\\000\\000\\000\\015\\000\\\n \\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\022\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\021\\000\\020\\000\\019\\000\\\n \\015\\000\\018\\000\\015\\000\\017\\000\\016\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\004\\000\\000\\000\\003\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\000\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\255\\255\\000\\000\\000\\000\\255\\255\\000\\000\\000\\000\\000\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\\n \\001\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\076\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\015\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\065\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\000\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\061\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\\n \\000\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\015\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\060\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\015\\000\\000\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\057\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\000\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\050\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\015\\000\\000\\000\\040\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\039\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\032\\000\\032\\000\\024\\000\\\n \\024\\000\\024\\000\\024\\000\\024\\000\\024\\000\\024\\000\\024\\000\\024\\000\\\n \\024\\000\\025\\000\\024\\000\\024\\000\\024\\000\\024\\000\\024\\000\\024\\000\\\n \\024\\000\\024\\000\\024\\000\\030\\000\\031\\000\\031\\000\\038\\000\\000\\000\\\n \\038\\000\\000\\000\\000\\000\\037\\000\\037\\000\\037\\000\\037\\000\\037\\000\\\n \\037\\000\\037\\000\\037\\000\\037\\000\\037\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\030\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\031\\000\\031\\000\\030\\000\\033\\000\\\n \\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\\n \\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\\n \\033\\000\\033\\000\\033\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\036\\000\\000\\000\\036\\000\\000\\000\\034\\000\\035\\000\\\n \\035\\000\\035\\000\\035\\000\\035\\000\\035\\000\\035\\000\\035\\000\\035\\000\\\n \\035\\000\\035\\000\\035\\000\\035\\000\\035\\000\\035\\000\\035\\000\\035\\000\\\n \\035\\000\\035\\000\\035\\000\\035\\000\\035\\000\\035\\000\\035\\000\\035\\000\\\n \\035\\000\\035\\000\\035\\000\\035\\000\\035\\000\\000\\000\\034\\000\\037\\000\\\n \\037\\000\\037\\000\\037\\000\\037\\000\\037\\000\\037\\000\\037\\000\\037\\000\\\n \\037\\000\\037\\000\\037\\000\\037\\000\\037\\000\\037\\000\\037\\000\\037\\000\\\n \\037\\000\\037\\000\\037\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\015\\000\\000\\000\\044\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\000\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\041\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\015\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\042\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\015\\000\\000\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\043\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\000\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\015\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\045\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\000\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\046\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\\n \\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\047\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\015\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\048\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\000\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\049\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\015\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\015\\000\\000\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\051\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\000\\000\\\n \\052\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\015\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\053\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\000\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\054\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\\n \\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\055\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\015\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\056\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\000\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\015\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\058\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\015\\000\\000\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\059\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\000\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\015\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\000\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\062\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\\n \\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\063\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\015\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\064\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\000\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\015\\000\\000\\000\\015\\000\\066\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\015\\000\\000\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\067\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\000\\000\\\n \\015\\000\\015\\000\\068\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\015\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\069\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\000\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\070\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\\n \\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\071\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\015\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\072\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\000\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\073\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\015\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\074\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\015\\000\\000\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\075\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\000\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\015\\000\\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\077\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\000\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\078\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\000\\\n \\000\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\\n \\092\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\090\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\084\\000\\255\\255\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\091\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\089\\000\\000\\000\\000\\000\\000\\000\\088\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\087\\000\\083\\000\\255\\255\\000\\000\\\n \\086\\000\\000\\000\\085\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\255\\255\\255\\255\";\n Lexing.lex_check =\n \"\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\000\\000\\000\\000\\028\\000\\255\\255\\000\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\255\\255\\255\\255\\\n \\000\\000\\000\\000\\255\\255\\255\\255\\000\\000\\000\\000\\000\\000\\010\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\079\\000\\255\\255\\000\\000\\255\\255\\255\\255\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\000\\000\\255\\255\\000\\000\\\n \\255\\255\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\000\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\255\\255\\255\\255\\255\\255\\255\\255\\015\\000\\255\\255\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\000\\029\\000\\255\\255\\255\\255\\029\\000\\255\\255\\255\\255\\255\\255\\\n \\016\\000\\016\\000\\016\\000\\016\\000\\016\\000\\016\\000\\016\\000\\016\\000\\\n \\016\\000\\016\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\016\\000\\016\\000\\016\\000\\016\\000\\016\\000\\016\\000\\016\\000\\\n \\016\\000\\016\\000\\016\\000\\016\\000\\016\\000\\016\\000\\016\\000\\016\\000\\\n \\016\\000\\016\\000\\016\\000\\016\\000\\016\\000\\016\\000\\016\\000\\016\\000\\\n \\016\\000\\016\\000\\016\\000\\255\\255\\255\\255\\255\\255\\255\\255\\016\\000\\\n \\000\\000\\016\\000\\016\\000\\016\\000\\016\\000\\016\\000\\016\\000\\016\\000\\\n \\016\\000\\016\\000\\016\\000\\016\\000\\016\\000\\016\\000\\016\\000\\016\\000\\\n \\016\\000\\016\\000\\016\\000\\016\\000\\016\\000\\016\\000\\016\\000\\016\\000\\\n \\016\\000\\016\\000\\016\\000\\017\\000\\017\\000\\017\\000\\017\\000\\017\\000\\\n \\017\\000\\017\\000\\017\\000\\017\\000\\017\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\017\\000\\017\\000\\017\\000\\017\\000\\\n \\017\\000\\017\\000\\017\\000\\017\\000\\017\\000\\017\\000\\017\\000\\017\\000\\\n \\017\\000\\017\\000\\017\\000\\017\\000\\017\\000\\017\\000\\017\\000\\017\\000\\\n \\017\\000\\017\\000\\017\\000\\017\\000\\017\\000\\017\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\017\\000\\255\\255\\017\\000\\017\\000\\017\\000\\017\\000\\\n \\017\\000\\017\\000\\017\\000\\017\\000\\017\\000\\017\\000\\017\\000\\017\\000\\\n \\017\\000\\017\\000\\017\\000\\017\\000\\017\\000\\017\\000\\017\\000\\017\\000\\\n \\017\\000\\017\\000\\017\\000\\017\\000\\017\\000\\017\\000\\018\\000\\018\\000\\\n \\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\018\\000\\\n \\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\\n \\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\\n \\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\\n \\018\\000\\255\\255\\255\\255\\255\\255\\255\\255\\018\\000\\255\\255\\018\\000\\\n \\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\\n \\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\\n \\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\\n \\018\\000\\019\\000\\019\\000\\019\\000\\019\\000\\019\\000\\019\\000\\019\\000\\\n \\019\\000\\019\\000\\019\\000\\255\\255\\255\\255\\255\\255\\255\\255\\029\\000\\\n \\255\\255\\255\\255\\019\\000\\019\\000\\019\\000\\019\\000\\019\\000\\019\\000\\\n \\019\\000\\019\\000\\019\\000\\019\\000\\019\\000\\019\\000\\019\\000\\019\\000\\\n \\019\\000\\019\\000\\019\\000\\019\\000\\019\\000\\019\\000\\019\\000\\019\\000\\\n \\019\\000\\019\\000\\019\\000\\019\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\019\\000\\255\\255\\019\\000\\019\\000\\019\\000\\019\\000\\019\\000\\019\\000\\\n \\019\\000\\019\\000\\019\\000\\019\\000\\019\\000\\019\\000\\019\\000\\019\\000\\\n \\019\\000\\019\\000\\019\\000\\019\\000\\019\\000\\019\\000\\019\\000\\019\\000\\\n \\019\\000\\019\\000\\019\\000\\019\\000\\020\\000\\020\\000\\020\\000\\020\\000\\\n \\020\\000\\020\\000\\020\\000\\020\\000\\020\\000\\020\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\020\\000\\020\\000\\020\\000\\\n \\020\\000\\020\\000\\020\\000\\020\\000\\020\\000\\020\\000\\020\\000\\020\\000\\\n \\020\\000\\020\\000\\020\\000\\020\\000\\020\\000\\020\\000\\020\\000\\020\\000\\\n \\020\\000\\020\\000\\020\\000\\020\\000\\020\\000\\020\\000\\020\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\020\\000\\255\\255\\020\\000\\020\\000\\020\\000\\\n \\020\\000\\020\\000\\020\\000\\020\\000\\020\\000\\020\\000\\020\\000\\020\\000\\\n \\020\\000\\020\\000\\020\\000\\020\\000\\020\\000\\020\\000\\020\\000\\020\\000\\\n \\020\\000\\020\\000\\020\\000\\020\\000\\020\\000\\020\\000\\020\\000\\021\\000\\\n \\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\\n \\021\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\\n \\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\\n \\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\\n \\021\\000\\021\\000\\255\\255\\255\\255\\255\\255\\255\\255\\021\\000\\255\\255\\\n \\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\\n \\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\\n \\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\021\\000\\\n \\021\\000\\021\\000\\022\\000\\022\\000\\022\\000\\022\\000\\022\\000\\022\\000\\\n \\022\\000\\022\\000\\022\\000\\022\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\022\\000\\022\\000\\022\\000\\022\\000\\022\\000\\\n \\022\\000\\022\\000\\022\\000\\022\\000\\022\\000\\022\\000\\022\\000\\022\\000\\\n \\022\\000\\022\\000\\022\\000\\022\\000\\022\\000\\022\\000\\022\\000\\022\\000\\\n \\022\\000\\022\\000\\022\\000\\022\\000\\022\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\022\\000\\255\\255\\022\\000\\022\\000\\022\\000\\022\\000\\022\\000\\\n \\022\\000\\022\\000\\022\\000\\022\\000\\022\\000\\022\\000\\022\\000\\022\\000\\\n \\022\\000\\022\\000\\022\\000\\022\\000\\022\\000\\022\\000\\022\\000\\022\\000\\\n \\022\\000\\022\\000\\022\\000\\022\\000\\022\\000\\024\\000\\025\\000\\024\\000\\\n \\024\\000\\024\\000\\024\\000\\024\\000\\024\\000\\024\\000\\024\\000\\024\\000\\\n \\024\\000\\026\\000\\026\\000\\026\\000\\026\\000\\026\\000\\026\\000\\026\\000\\\n \\026\\000\\026\\000\\026\\000\\030\\000\\024\\000\\025\\000\\031\\000\\255\\255\\\n \\031\\000\\255\\255\\255\\255\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\\n \\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\030\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\024\\000\\025\\000\\030\\000\\032\\000\\\n \\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\\n \\032\\000\\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\\n \\033\\000\\033\\000\\033\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\034\\000\\255\\255\\034\\000\\255\\255\\033\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\035\\000\\035\\000\\035\\000\\035\\000\\035\\000\\035\\000\\035\\000\\\n \\035\\000\\035\\000\\035\\000\\036\\000\\036\\000\\036\\000\\036\\000\\036\\000\\\n \\036\\000\\036\\000\\036\\000\\036\\000\\036\\000\\255\\255\\033\\000\\037\\000\\\n \\037\\000\\037\\000\\037\\000\\037\\000\\037\\000\\037\\000\\037\\000\\037\\000\\\n \\037\\000\\038\\000\\038\\000\\038\\000\\038\\000\\038\\000\\038\\000\\038\\000\\\n \\038\\000\\038\\000\\038\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\\n \\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\039\\000\\039\\000\\039\\000\\039\\000\\\n \\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\\n \\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\\n \\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\039\\000\\255\\255\\039\\000\\039\\000\\039\\000\\039\\000\\\n \\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\\n \\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\\n \\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\040\\000\\040\\000\\\n \\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\040\\000\\\n \\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\\n \\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\\n \\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\\n \\040\\000\\255\\255\\255\\255\\255\\255\\255\\255\\040\\000\\255\\255\\040\\000\\\n \\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\\n \\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\\n \\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\\n \\040\\000\\041\\000\\041\\000\\041\\000\\041\\000\\041\\000\\041\\000\\041\\000\\\n \\041\\000\\041\\000\\041\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\041\\000\\041\\000\\041\\000\\041\\000\\041\\000\\041\\000\\\n \\041\\000\\041\\000\\041\\000\\041\\000\\041\\000\\041\\000\\041\\000\\041\\000\\\n \\041\\000\\041\\000\\041\\000\\041\\000\\041\\000\\041\\000\\041\\000\\041\\000\\\n \\041\\000\\041\\000\\041\\000\\041\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\041\\000\\255\\255\\041\\000\\041\\000\\041\\000\\041\\000\\041\\000\\041\\000\\\n \\041\\000\\041\\000\\041\\000\\041\\000\\041\\000\\041\\000\\041\\000\\041\\000\\\n \\041\\000\\041\\000\\041\\000\\041\\000\\041\\000\\041\\000\\041\\000\\041\\000\\\n \\041\\000\\041\\000\\041\\000\\041\\000\\042\\000\\042\\000\\042\\000\\042\\000\\\n \\042\\000\\042\\000\\042\\000\\042\\000\\042\\000\\042\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\042\\000\\042\\000\\042\\000\\\n \\042\\000\\042\\000\\042\\000\\042\\000\\042\\000\\042\\000\\042\\000\\042\\000\\\n \\042\\000\\042\\000\\042\\000\\042\\000\\042\\000\\042\\000\\042\\000\\042\\000\\\n \\042\\000\\042\\000\\042\\000\\042\\000\\042\\000\\042\\000\\042\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\042\\000\\255\\255\\042\\000\\042\\000\\042\\000\\\n \\042\\000\\042\\000\\042\\000\\042\\000\\042\\000\\042\\000\\042\\000\\042\\000\\\n \\042\\000\\042\\000\\042\\000\\042\\000\\042\\000\\042\\000\\042\\000\\042\\000\\\n \\042\\000\\042\\000\\042\\000\\042\\000\\042\\000\\042\\000\\042\\000\\043\\000\\\n \\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\\n \\043\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\\n \\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\\n \\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\\n \\043\\000\\043\\000\\255\\255\\255\\255\\255\\255\\255\\255\\043\\000\\255\\255\\\n \\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\\n \\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\\n \\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\043\\000\\\n \\043\\000\\043\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\\n \\044\\000\\044\\000\\044\\000\\044\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\\n \\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\\n \\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\\n \\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\044\\000\\255\\255\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\\n \\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\\n \\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\\n \\044\\000\\044\\000\\044\\000\\044\\000\\044\\000\\045\\000\\045\\000\\045\\000\\\n \\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\045\\000\\045\\000\\\n \\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\\n \\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\\n \\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\045\\000\\255\\255\\045\\000\\045\\000\\\n \\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\\n \\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\\n \\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\\n \\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\\n \\046\\000\\046\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\\n \\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\\n \\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\\n \\046\\000\\046\\000\\046\\000\\255\\255\\255\\255\\255\\255\\255\\255\\046\\000\\\n \\255\\255\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\\n \\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\\n \\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\046\\000\\\n \\046\\000\\046\\000\\046\\000\\047\\000\\047\\000\\047\\000\\047\\000\\047\\000\\\n \\047\\000\\047\\000\\047\\000\\047\\000\\047\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\047\\000\\047\\000\\047\\000\\047\\000\\\n \\047\\000\\047\\000\\047\\000\\047\\000\\047\\000\\047\\000\\047\\000\\047\\000\\\n \\047\\000\\047\\000\\047\\000\\047\\000\\047\\000\\047\\000\\047\\000\\047\\000\\\n \\047\\000\\047\\000\\047\\000\\047\\000\\047\\000\\047\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\047\\000\\255\\255\\047\\000\\047\\000\\047\\000\\047\\000\\\n \\047\\000\\047\\000\\047\\000\\047\\000\\047\\000\\047\\000\\047\\000\\047\\000\\\n \\047\\000\\047\\000\\047\\000\\047\\000\\047\\000\\047\\000\\047\\000\\047\\000\\\n \\047\\000\\047\\000\\047\\000\\047\\000\\047\\000\\047\\000\\048\\000\\048\\000\\\n \\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\048\\000\\\n \\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\\n \\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\\n \\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\\n \\048\\000\\255\\255\\255\\255\\255\\255\\255\\255\\048\\000\\255\\255\\048\\000\\\n \\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\\n \\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\\n \\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\\n \\048\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\\n \\049\\000\\049\\000\\049\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\\n \\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\\n \\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\\n \\049\\000\\049\\000\\049\\000\\049\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\049\\000\\255\\255\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\\n \\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\\n \\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\\n \\049\\000\\049\\000\\049\\000\\049\\000\\050\\000\\050\\000\\050\\000\\050\\000\\\n \\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\050\\000\\050\\000\\050\\000\\\n \\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\\n \\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\\n \\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\050\\000\\255\\255\\050\\000\\050\\000\\050\\000\\\n \\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\\n \\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\\n \\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\051\\000\\\n \\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\\n \\051\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\\n \\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\\n \\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\\n \\051\\000\\051\\000\\255\\255\\255\\255\\255\\255\\255\\255\\051\\000\\255\\255\\\n \\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\\n \\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\\n \\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\\n \\051\\000\\051\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\\n \\052\\000\\052\\000\\052\\000\\052\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\\n \\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\\n \\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\\n \\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\052\\000\\255\\255\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\\n \\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\\n \\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\\n \\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\053\\000\\053\\000\\053\\000\\\n \\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\053\\000\\053\\000\\\n \\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\\n \\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\\n \\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\053\\000\\255\\255\\053\\000\\053\\000\\\n \\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\\n \\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\\n \\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\\n \\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\\n \\054\\000\\054\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\\n \\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\\n \\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\\n \\054\\000\\054\\000\\054\\000\\255\\255\\255\\255\\255\\255\\255\\255\\054\\000\\\n \\255\\255\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\\n \\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\\n \\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\\n \\054\\000\\054\\000\\054\\000\\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\\n \\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\055\\000\\055\\000\\055\\000\\055\\000\\\n \\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\\n \\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\\n \\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\055\\000\\255\\255\\055\\000\\055\\000\\055\\000\\055\\000\\\n \\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\\n \\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\\n \\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\056\\000\\056\\000\\\n \\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\056\\000\\\n \\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\\n \\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\\n \\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\\n \\056\\000\\255\\255\\255\\255\\255\\255\\255\\255\\056\\000\\255\\255\\056\\000\\\n \\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\\n \\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\\n \\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\\n \\056\\000\\057\\000\\057\\000\\057\\000\\057\\000\\057\\000\\057\\000\\057\\000\\\n \\057\\000\\057\\000\\057\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\057\\000\\057\\000\\057\\000\\057\\000\\057\\000\\057\\000\\\n \\057\\000\\057\\000\\057\\000\\057\\000\\057\\000\\057\\000\\057\\000\\057\\000\\\n \\057\\000\\057\\000\\057\\000\\057\\000\\057\\000\\057\\000\\057\\000\\057\\000\\\n \\057\\000\\057\\000\\057\\000\\057\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\057\\000\\255\\255\\057\\000\\057\\000\\057\\000\\057\\000\\057\\000\\057\\000\\\n \\057\\000\\057\\000\\057\\000\\057\\000\\057\\000\\057\\000\\057\\000\\057\\000\\\n \\057\\000\\057\\000\\057\\000\\057\\000\\057\\000\\057\\000\\057\\000\\057\\000\\\n \\057\\000\\057\\000\\057\\000\\057\\000\\058\\000\\058\\000\\058\\000\\058\\000\\\n \\058\\000\\058\\000\\058\\000\\058\\000\\058\\000\\058\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\058\\000\\058\\000\\058\\000\\\n \\058\\000\\058\\000\\058\\000\\058\\000\\058\\000\\058\\000\\058\\000\\058\\000\\\n \\058\\000\\058\\000\\058\\000\\058\\000\\058\\000\\058\\000\\058\\000\\058\\000\\\n \\058\\000\\058\\000\\058\\000\\058\\000\\058\\000\\058\\000\\058\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\058\\000\\255\\255\\058\\000\\058\\000\\058\\000\\\n \\058\\000\\058\\000\\058\\000\\058\\000\\058\\000\\058\\000\\058\\000\\058\\000\\\n \\058\\000\\058\\000\\058\\000\\058\\000\\058\\000\\058\\000\\058\\000\\058\\000\\\n \\058\\000\\058\\000\\058\\000\\058\\000\\058\\000\\058\\000\\058\\000\\059\\000\\\n \\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\\n \\059\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\\n \\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\\n \\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\\n \\059\\000\\059\\000\\255\\255\\255\\255\\255\\255\\255\\255\\059\\000\\255\\255\\\n \\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\\n \\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\\n \\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\059\\000\\\n \\059\\000\\059\\000\\060\\000\\060\\000\\060\\000\\060\\000\\060\\000\\060\\000\\\n \\060\\000\\060\\000\\060\\000\\060\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\060\\000\\060\\000\\060\\000\\060\\000\\060\\000\\\n \\060\\000\\060\\000\\060\\000\\060\\000\\060\\000\\060\\000\\060\\000\\060\\000\\\n \\060\\000\\060\\000\\060\\000\\060\\000\\060\\000\\060\\000\\060\\000\\060\\000\\\n \\060\\000\\060\\000\\060\\000\\060\\000\\060\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\060\\000\\255\\255\\060\\000\\060\\000\\060\\000\\060\\000\\060\\000\\\n \\060\\000\\060\\000\\060\\000\\060\\000\\060\\000\\060\\000\\060\\000\\060\\000\\\n \\060\\000\\060\\000\\060\\000\\060\\000\\060\\000\\060\\000\\060\\000\\060\\000\\\n \\060\\000\\060\\000\\060\\000\\060\\000\\060\\000\\061\\000\\061\\000\\061\\000\\\n \\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\061\\000\\061\\000\\\n \\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\\n \\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\\n \\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\061\\000\\255\\255\\061\\000\\061\\000\\\n \\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\\n \\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\\n \\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\\n \\062\\000\\062\\000\\062\\000\\062\\000\\062\\000\\062\\000\\062\\000\\062\\000\\\n \\062\\000\\062\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\062\\000\\062\\000\\062\\000\\062\\000\\062\\000\\062\\000\\062\\000\\\n \\062\\000\\062\\000\\062\\000\\062\\000\\062\\000\\062\\000\\062\\000\\062\\000\\\n \\062\\000\\062\\000\\062\\000\\062\\000\\062\\000\\062\\000\\062\\000\\062\\000\\\n \\062\\000\\062\\000\\062\\000\\255\\255\\255\\255\\255\\255\\255\\255\\062\\000\\\n \\255\\255\\062\\000\\062\\000\\062\\000\\062\\000\\062\\000\\062\\000\\062\\000\\\n \\062\\000\\062\\000\\062\\000\\062\\000\\062\\000\\062\\000\\062\\000\\062\\000\\\n \\062\\000\\062\\000\\062\\000\\062\\000\\062\\000\\062\\000\\062\\000\\062\\000\\\n \\062\\000\\062\\000\\062\\000\\063\\000\\063\\000\\063\\000\\063\\000\\063\\000\\\n \\063\\000\\063\\000\\063\\000\\063\\000\\063\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\063\\000\\063\\000\\063\\000\\063\\000\\\n \\063\\000\\063\\000\\063\\000\\063\\000\\063\\000\\063\\000\\063\\000\\063\\000\\\n \\063\\000\\063\\000\\063\\000\\063\\000\\063\\000\\063\\000\\063\\000\\063\\000\\\n \\063\\000\\063\\000\\063\\000\\063\\000\\063\\000\\063\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\063\\000\\255\\255\\063\\000\\063\\000\\063\\000\\063\\000\\\n \\063\\000\\063\\000\\063\\000\\063\\000\\063\\000\\063\\000\\063\\000\\063\\000\\\n \\063\\000\\063\\000\\063\\000\\063\\000\\063\\000\\063\\000\\063\\000\\063\\000\\\n \\063\\000\\063\\000\\063\\000\\063\\000\\063\\000\\063\\000\\064\\000\\064\\000\\\n \\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\064\\000\\\n \\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\\n \\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\\n \\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\\n \\064\\000\\255\\255\\255\\255\\255\\255\\255\\255\\064\\000\\255\\255\\064\\000\\\n \\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\\n \\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\\n \\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\\n \\064\\000\\065\\000\\065\\000\\065\\000\\065\\000\\065\\000\\065\\000\\065\\000\\\n \\065\\000\\065\\000\\065\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\065\\000\\065\\000\\065\\000\\065\\000\\065\\000\\065\\000\\\n \\065\\000\\065\\000\\065\\000\\065\\000\\065\\000\\065\\000\\065\\000\\065\\000\\\n \\065\\000\\065\\000\\065\\000\\065\\000\\065\\000\\065\\000\\065\\000\\065\\000\\\n \\065\\000\\065\\000\\065\\000\\065\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\065\\000\\255\\255\\065\\000\\065\\000\\065\\000\\065\\000\\065\\000\\065\\000\\\n \\065\\000\\065\\000\\065\\000\\065\\000\\065\\000\\065\\000\\065\\000\\065\\000\\\n \\065\\000\\065\\000\\065\\000\\065\\000\\065\\000\\065\\000\\065\\000\\065\\000\\\n \\065\\000\\065\\000\\065\\000\\065\\000\\066\\000\\066\\000\\066\\000\\066\\000\\\n \\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\066\\000\\066\\000\\066\\000\\\n \\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\\n \\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\\n \\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\066\\000\\255\\255\\066\\000\\066\\000\\066\\000\\\n \\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\\n \\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\\n \\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\067\\000\\\n \\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\\n \\067\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\\n \\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\\n \\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\\n \\067\\000\\067\\000\\255\\255\\255\\255\\255\\255\\255\\255\\067\\000\\255\\255\\\n \\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\\n \\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\\n \\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\\n \\067\\000\\067\\000\\068\\000\\068\\000\\068\\000\\068\\000\\068\\000\\068\\000\\\n \\068\\000\\068\\000\\068\\000\\068\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\068\\000\\068\\000\\068\\000\\068\\000\\068\\000\\\n \\068\\000\\068\\000\\068\\000\\068\\000\\068\\000\\068\\000\\068\\000\\068\\000\\\n \\068\\000\\068\\000\\068\\000\\068\\000\\068\\000\\068\\000\\068\\000\\068\\000\\\n \\068\\000\\068\\000\\068\\000\\068\\000\\068\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\068\\000\\255\\255\\068\\000\\068\\000\\068\\000\\068\\000\\068\\000\\\n \\068\\000\\068\\000\\068\\000\\068\\000\\068\\000\\068\\000\\068\\000\\068\\000\\\n \\068\\000\\068\\000\\068\\000\\068\\000\\068\\000\\068\\000\\068\\000\\068\\000\\\n \\068\\000\\068\\000\\068\\000\\068\\000\\068\\000\\069\\000\\069\\000\\069\\000\\\n \\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\069\\000\\069\\000\\\n \\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\\n \\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\\n \\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\069\\000\\255\\255\\069\\000\\069\\000\\\n \\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\\n \\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\\n \\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\\n \\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\\n \\070\\000\\070\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\\n \\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\\n \\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\\n \\070\\000\\070\\000\\070\\000\\255\\255\\255\\255\\255\\255\\255\\255\\070\\000\\\n \\255\\255\\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\\n \\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\\n \\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\\n \\070\\000\\070\\000\\070\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\\n \\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\071\\000\\071\\000\\071\\000\\071\\000\\\n \\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\\n \\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\\n \\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\071\\000\\255\\255\\071\\000\\071\\000\\071\\000\\071\\000\\\n \\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\\n \\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\\n \\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\072\\000\\072\\000\\\n \\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\072\\000\\\n \\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\\n \\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\\n \\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\\n \\072\\000\\255\\255\\255\\255\\255\\255\\255\\255\\072\\000\\255\\255\\072\\000\\\n \\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\\n \\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\\n \\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\072\\000\\\n \\072\\000\\073\\000\\073\\000\\073\\000\\073\\000\\073\\000\\073\\000\\073\\000\\\n \\073\\000\\073\\000\\073\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\073\\000\\073\\000\\073\\000\\073\\000\\073\\000\\073\\000\\\n \\073\\000\\073\\000\\073\\000\\073\\000\\073\\000\\073\\000\\073\\000\\073\\000\\\n \\073\\000\\073\\000\\073\\000\\073\\000\\073\\000\\073\\000\\073\\000\\073\\000\\\n \\073\\000\\073\\000\\073\\000\\073\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\073\\000\\255\\255\\073\\000\\073\\000\\073\\000\\073\\000\\073\\000\\073\\000\\\n \\073\\000\\073\\000\\073\\000\\073\\000\\073\\000\\073\\000\\073\\000\\073\\000\\\n \\073\\000\\073\\000\\073\\000\\073\\000\\073\\000\\073\\000\\073\\000\\073\\000\\\n \\073\\000\\073\\000\\073\\000\\073\\000\\074\\000\\074\\000\\074\\000\\074\\000\\\n \\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\074\\000\\074\\000\\074\\000\\\n \\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\\n \\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\\n \\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\074\\000\\255\\255\\074\\000\\074\\000\\074\\000\\\n \\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\\n \\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\\n \\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\075\\000\\\n \\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\\n \\075\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\\n \\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\\n \\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\\n \\075\\000\\075\\000\\255\\255\\255\\255\\255\\255\\255\\255\\075\\000\\255\\255\\\n \\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\\n \\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\\n \\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\\n \\075\\000\\075\\000\\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\\n \\076\\000\\076\\000\\076\\000\\076\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\\n \\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\\n \\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\\n \\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\076\\000\\255\\255\\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\\n \\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\\n \\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\\n \\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\077\\000\\077\\000\\077\\000\\\n \\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\077\\000\\077\\000\\\n \\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\\n \\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\\n \\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\077\\000\\255\\255\\077\\000\\077\\000\\\n \\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\\n \\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\\n \\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\\n \\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\\n \\078\\000\\078\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\\n \\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\\n \\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\\n \\078\\000\\078\\000\\078\\000\\255\\255\\255\\255\\255\\255\\255\\255\\078\\000\\\n \\255\\255\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\\n \\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\\n \\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\\n \\078\\000\\078\\000\\078\\000\\081\\000\\082\\000\\255\\255\\081\\000\\082\\000\\\n \\083\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\083\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\081\\000\\082\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\083\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\083\\000\\255\\255\\255\\255\\255\\255\\083\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\083\\000\\081\\000\\082\\000\\255\\255\\\n \\083\\000\\255\\255\\083\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\081\\000\\082\\000\";\n Lexing.lex_base_code =\n \"\";\n Lexing.lex_backtrk_code =\n \"\";\n Lexing.lex_default_code =\n \"\";\n Lexing.lex_trans_code =\n \"\";\n Lexing.lex_check_code =\n \"\";\n Lexing.lex_code =\n \"\";\n}\n\nlet rec token lexbuf =\n __ocaml_lex_token_rec lexbuf 0\nand __ocaml_lex_token_rec lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 21 \"graphql_parser/src/lexer.mll\"\n ( token lexbuf )\n# 1105 \"graphql_parser/src/lexer.ml\"\n\n | 1 ->\n# 22 \"graphql_parser/src/lexer.mll\"\n ( token lexbuf )\n# 1110 \"graphql_parser/src/lexer.ml\"\n\n | 2 ->\n# 23 \"graphql_parser/src/lexer.mll\"\n ( new_line lexbuf; token lexbuf )\n# 1115 \"graphql_parser/src/lexer.ml\"\n\n | 3 ->\n# 25 \"graphql_parser/src/lexer.mll\"\n ( INT (int_of_string (lexeme lexbuf)) )\n# 1120 \"graphql_parser/src/lexer.ml\"\n\n | 4 ->\n# 26 \"graphql_parser/src/lexer.mll\"\n ( FLOAT (float_of_string (lexeme lexbuf)) )\n# 1125 \"graphql_parser/src/lexer.ml\"\n\n | 5 ->\n# 27 \"graphql_parser/src/lexer.mll\"\n ( read_string (Buffer.create 17) lexbuf )\n# 1130 \"graphql_parser/src/lexer.ml\"\n\n | 6 ->\n# 29 \"graphql_parser/src/lexer.mll\"\n ( BOOL false )\n# 1135 \"graphql_parser/src/lexer.ml\"\n\n | 7 ->\n# 30 \"graphql_parser/src/lexer.mll\"\n ( FRAGMENT )\n# 1140 \"graphql_parser/src/lexer.ml\"\n\n | 8 ->\n# 31 \"graphql_parser/src/lexer.mll\"\n ( MUTATION )\n# 1145 \"graphql_parser/src/lexer.ml\"\n\n | 9 ->\n# 32 \"graphql_parser/src/lexer.mll\"\n ( NULL )\n# 1150 \"graphql_parser/src/lexer.ml\"\n\n | 10 ->\n# 33 \"graphql_parser/src/lexer.mll\"\n ( ON )\n# 1155 \"graphql_parser/src/lexer.ml\"\n\n | 11 ->\n# 34 \"graphql_parser/src/lexer.mll\"\n ( QUERY )\n# 1160 \"graphql_parser/src/lexer.ml\"\n\n | 12 ->\n# 35 \"graphql_parser/src/lexer.mll\"\n ( SUBSCRIPTION )\n# 1165 \"graphql_parser/src/lexer.ml\"\n\n | 13 ->\n# 36 \"graphql_parser/src/lexer.mll\"\n ( BOOL true )\n# 1170 \"graphql_parser/src/lexer.ml\"\n\n | 14 ->\n# 37 \"graphql_parser/src/lexer.mll\"\n ( NAME (lexeme lexbuf) )\n# 1175 \"graphql_parser/src/lexer.ml\"\n\n | 15 ->\n# 39 \"graphql_parser/src/lexer.mll\"\n ( BANG )\n# 1180 \"graphql_parser/src/lexer.ml\"\n\n | 16 ->\n# 40 \"graphql_parser/src/lexer.mll\"\n ( DOLLAR )\n# 1185 \"graphql_parser/src/lexer.ml\"\n\n | 17 ->\n# 41 \"graphql_parser/src/lexer.mll\"\n ( LPAREN )\n# 1190 \"graphql_parser/src/lexer.ml\"\n\n | 18 ->\n# 42 \"graphql_parser/src/lexer.mll\"\n ( RPAREN )\n# 1195 \"graphql_parser/src/lexer.ml\"\n\n | 19 ->\n# 43 \"graphql_parser/src/lexer.mll\"\n ( ELLIPSIS )\n# 1200 \"graphql_parser/src/lexer.ml\"\n\n | 20 ->\n# 44 \"graphql_parser/src/lexer.mll\"\n ( COLON )\n# 1205 \"graphql_parser/src/lexer.ml\"\n\n | 21 ->\n# 45 \"graphql_parser/src/lexer.mll\"\n ( EQUAL )\n# 1210 \"graphql_parser/src/lexer.ml\"\n\n | 22 ->\n# 46 \"graphql_parser/src/lexer.mll\"\n ( AT )\n# 1215 \"graphql_parser/src/lexer.ml\"\n\n | 23 ->\n# 47 \"graphql_parser/src/lexer.mll\"\n ( LBRACK )\n# 1220 \"graphql_parser/src/lexer.ml\"\n\n | 24 ->\n# 48 \"graphql_parser/src/lexer.mll\"\n ( RBRACK )\n# 1225 \"graphql_parser/src/lexer.ml\"\n\n | 25 ->\n# 49 \"graphql_parser/src/lexer.mll\"\n ( LBRACE )\n# 1230 \"graphql_parser/src/lexer.ml\"\n\n | 26 ->\n# 50 \"graphql_parser/src/lexer.mll\"\n ( RBRACE )\n# 1235 \"graphql_parser/src/lexer.ml\"\n\n | 27 ->\n# 51 \"graphql_parser/src/lexer.mll\"\n ( raise (Error (\"Unexpected char: \" ^ Lexing.lexeme lexbuf)) )\n# 1240 \"graphql_parser/src/lexer.ml\"\n\n | 28 ->\n# 52 \"graphql_parser/src/lexer.mll\"\n ( EOF )\n# 1245 \"graphql_parser/src/lexer.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_token_rec lexbuf __ocaml_lex_state\n\nand read_string buf lexbuf =\n __ocaml_lex_read_string_rec buf lexbuf 81\nand __ocaml_lex_read_string_rec buf lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 55 \"graphql_parser/src/lexer.mll\"\n ( STRING (Buffer.contents buf) )\n# 1257 \"graphql_parser/src/lexer.ml\"\n\n | 1 ->\n# 56 \"graphql_parser/src/lexer.mll\"\n ( Buffer.add_char buf '\"'; read_string buf lexbuf )\n# 1262 \"graphql_parser/src/lexer.ml\"\n\n | 2 ->\n# 57 \"graphql_parser/src/lexer.mll\"\n ( Buffer.add_char buf '\\\\'; read_string buf lexbuf )\n# 1267 \"graphql_parser/src/lexer.ml\"\n\n | 3 ->\n# 58 \"graphql_parser/src/lexer.mll\"\n ( Buffer.add_char buf '/'; read_string buf lexbuf )\n# 1272 \"graphql_parser/src/lexer.ml\"\n\n | 4 ->\n# 59 \"graphql_parser/src/lexer.mll\"\n ( Buffer.add_char buf '\\b'; read_string buf lexbuf )\n# 1277 \"graphql_parser/src/lexer.ml\"\n\n | 5 ->\n# 60 \"graphql_parser/src/lexer.mll\"\n ( Buffer.add_char buf '\\012'; read_string buf lexbuf )\n# 1282 \"graphql_parser/src/lexer.ml\"\n\n | 6 ->\n# 61 \"graphql_parser/src/lexer.mll\"\n ( Buffer.add_char buf '\\n'; read_string buf lexbuf )\n# 1287 \"graphql_parser/src/lexer.ml\"\n\n | 7 ->\n# 62 \"graphql_parser/src/lexer.mll\"\n ( Buffer.add_char buf '\\r'; read_string buf lexbuf )\n# 1292 \"graphql_parser/src/lexer.ml\"\n\n | 8 ->\n# 63 \"graphql_parser/src/lexer.mll\"\n ( Buffer.add_char buf '\\t'; read_string buf lexbuf )\n# 1297 \"graphql_parser/src/lexer.ml\"\n\n | 9 ->\n# 65 \"graphql_parser/src/lexer.mll\"\n (\n Buffer.add_string buf (lexeme lexbuf);\n read_string buf lexbuf\n )\n# 1305 \"graphql_parser/src/lexer.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_read_string_rec buf lexbuf __ocaml_lex_state\n\n;;\n\n","(* Helper modules *)\nmodule List = struct\n include List\n let assoc_exn = assoc\n let assoc x ys = try Some (assoc_exn x ys) with Not_found -> None\n\n let find_exn = find\n let find cond xs = try Some (find_exn cond xs) with Not_found -> None\n\n module Result = struct\n let rec join ?(memo=[]) = function\n | [] -> Ok (List.rev memo)\n | (Error _ as err)::_ -> err\n | (Ok x)::xs -> join ~memo:(x::memo) xs\n\n let all f xs =\n List.map f xs |> join\n end\nend\n\nmodule Option = struct\n let map x ~f = match x with None -> None | Some y -> Some (f y)\nend\n\n(* IO *)\nmodule type IO = sig\n type +'a t\n\n val return : 'a -> 'a t\n val bind : 'a t -> ('a -> 'b t) -> 'b t\n\n module Stream : sig\n type +'a io\n type 'a t\n\n val map : 'a t -> ('a -> 'b io) -> 'b t\n val iter : 'a t -> ('a -> unit io) -> unit io\n val close : 'a t -> unit\n end with type 'a io := 'a t\nend\n\n(* Field_error *)\nmodule type Field_error = sig\n type t\n val message_of_field_error : t -> string\n val extensions_of_field_error : t -> (string * Yojson.Basic.json [@warning \"-3\"]) list option\nend\n\n(* Schema *)\nmodule Make (Io : IO) (Field_error: Field_error) = struct\n module Io = struct\n include Io\n\n let map x ~f = bind x (fun x' -> return (f x'))\n let ok x = Io.return (Ok x)\n let error x = Io.return (Error x)\n\n let rec all = function\n | [] -> Io.return []\n | x::xs ->\n bind (all xs) (fun xs' ->\n map x ~f:(fun x' -> x'::xs')\n )\n\n module Result = struct\n let bind x f = bind x (function Ok x' -> f x' | Error _ as err -> Io.return err)\n let map_error x ~f = map x ~f:(function Ok _ as ok -> ok | Error err -> Error (f err))\n let map x ~f = map x ~f:(function Ok x' -> Ok (f x') | Error _ as err -> err)\n end\n\n let rec map_s ?(memo=[]) f = function\n | [] -> Io.return (List.rev memo)\n | x::xs ->\n bind (f x) (fun x' -> map_s ~memo:(x'::memo) f xs)\n\n let map_p f xs = List.map f xs |> all\n\n module Infix = struct\n let (>>|) x f = map x ~f\n let (>>=?) = Result.bind\n end\n end\n\n module StringMap = struct\n include Map.Make(String)\n exception Missing_key of string\n let find_exn key t = try find key t with Not_found -> raise (Missing_key key)\n let find k t = try Some (find_exn k t) with Missing_key _ -> None\n end\n\n module StringSet = Set.Make(String)\n\n type field_error = Field_error.t\n\n type variable_map = Graphql_parser.const_value StringMap.t\n\n type deprecated =\n | NotDeprecated\n | Deprecated of string option\n\n type 'a enum_value = {\n name : string;\n doc : string option;\n deprecated : deprecated;\n value : 'a;\n }\n\n type json = Yojson.Basic.json [@warning \"-3\"]\n\n let enum_value ?doc ?(deprecated=NotDeprecated) name ~value =\n { name; doc; deprecated; value; }\n\n let id : 'a. 'a -> 'a = fun x -> x\n\n module Arg = struct\n open Rresult\n\n type _ arg_typ =\n | Scalar : {\n name : string;\n doc : string option;\n coerce : Graphql_parser.const_value -> ('a, string) result;\n } -> 'a option arg_typ\n | Object : {\n name : string;\n doc : string option;\n fields : ('a, 'b) arg_list;\n coerce : 'b;\n } -> 'a option arg_typ\n | Enum : {\n name : string;\n doc : string option;\n values : 'a enum_value list;\n } -> 'a option arg_typ\n | List : 'a arg_typ -> 'a list option arg_typ\n | NonNullable : 'a option arg_typ -> 'a arg_typ\n and _ arg =\n | Arg : {\n name : string;\n doc : string option;\n typ : 'a arg_typ;\n } -> 'a arg\n | DefaultArg : {\n name : string;\n doc : string option;\n typ : 'a option arg_typ;\n default : 'a;\n } -> 'a arg\n and (_, _) arg_list =\n | [] : ('a, 'a) arg_list\n | (::) : 'a arg * ('b, 'c) arg_list -> ('b, 'a -> 'c) arg_list\n\n let arg ?doc name ~typ =\n Arg { name; doc; typ }\n\n let arg' ?doc name ~typ ~default =\n DefaultArg { name; doc; typ; default }\n\n let scalar ?doc name ~coerce =\n Scalar { name; doc; coerce }\n\n let enum ?doc name ~values =\n Enum { name; doc; values }\n\n let obj ?doc name ~fields ~coerce =\n Object { name; doc; fields; coerce }\n\n let rec string_of_const_value : Graphql_parser.const_value -> string = function\n | `Null -> \"null\"\n | `Int i -> string_of_int i\n | `Float f -> string_of_float f\n | `String s -> Printf.sprintf \"\\\"%s\\\"\" s\n | `Bool b -> string_of_bool b\n | `Enum e -> e\n | `List l ->\n let values = List.map (fun i -> string_of_const_value i) l in\n Printf.sprintf \"[%s]\" (String.concat \", \" values)\n | `Assoc a ->\n let values =\n List.map\n (fun (k, v) ->\n Printf.sprintf \"%s: %s\" k (string_of_const_value v) )\n a\n in\n Printf.sprintf \"{%s}\" (String.concat \", \" values)\n\n let rec string_of_arg_typ : type a. a arg_typ -> string = function\n | Scalar a -> a.name\n | Object a -> a.name\n | Enum a -> a.name\n | List a -> Printf.sprintf \"[%s]\" (string_of_arg_typ a)\n | NonNullable a -> Printf.sprintf \"%s!\" (string_of_arg_typ a)\n\n let eval_arg_error ?(field_type=\"field\") ~field_name ~arg_name arg_typ value =\n let found_str =\n match value with\n | Some v -> Printf.sprintf \"found %s\" (string_of_const_value v)\n | None -> \"but not provided\"\n in\n Printf.sprintf \"Argument `%s` of type `%s` expected on %s `%s`, %s.\"\n arg_name\n (string_of_arg_typ arg_typ)\n field_type\n field_name\n found_str\n\n (* Built-in argument types *)\n let int = Scalar {\n name = \"Int\";\n doc = None;\n coerce = function\n | `Int n -> Ok n\n | _ -> Error \"Invalid int\"\n }\n\n let string = Scalar {\n name = \"String\";\n doc = None;\n coerce = function\n | `String s -> Ok s\n | _ -> Error \"Invalid string\"\n }\n\n let float = Scalar {\n name = \"Float\";\n doc = None;\n coerce = function\n | `Float f -> Ok f\n | `Int n -> Ok (float_of_int n)\n | _ -> Error \"Invalid float\"\n }\n\n let bool = Scalar {\n name = \"Boolean\";\n doc = None;\n coerce = function\n | `Bool b -> Ok b\n | _ -> Error \"Invalid boolean\"\n }\n\n let guid = Scalar {\n name = \"ID\";\n doc = None;\n coerce = function\n | `String s -> Ok s\n | `Int n -> Ok (string_of_int n)\n | _ -> Error \"Invalid ID\"\n }\n\n let non_null typ = NonNullable typ\n let list typ = List typ\n\n let rec value_to_const_value variable_map = function\n | `Null -> `Null\n | `Int _ as i -> i\n | `Float _ as f -> f\n | `String _ as s -> s\n | `Bool _ as b -> b\n | `Enum _ as e -> e\n | `Variable v -> StringMap.find_exn v variable_map\n | `List xs -> `List (List.map (value_to_const_value variable_map) xs)\n | `Assoc props ->\n let props' = List.map (fun (name, value) -> name, value_to_const_value variable_map value) props in\n `Assoc props'\n\n let rec eval_arglist\n : type a b. variable_map\n -> ?field_type:string\n -> field_name:string\n -> (a, b) arg_list\n -> (string * Graphql_parser.value) list\n -> b\n -> (a, string) result =\n fun variable_map ?field_type ~field_name arglist key_values f ->\n match arglist with\n | [] -> Ok f\n | (DefaultArg arg)::arglist' ->\n let arglist'' = (Arg { name = arg.name; doc = arg.doc; typ = arg.typ })::arglist' in\n eval_arglist variable_map ?field_type ~field_name arglist'' key_values (function\n | None -> f arg.default\n | Some value -> f value\n )\n | (Arg arg)::arglist' ->\n try\n let value = List.assoc arg.name key_values in\n let const_value = Option.map value ~f:(value_to_const_value variable_map) in\n eval_arg variable_map ?field_type ~field_name ~arg_name:arg.name arg.typ const_value >>= fun coerced ->\n eval_arglist variable_map ?field_type ~field_name arglist' key_values (f coerced)\n with StringMap.Missing_key key -> Error (Format.sprintf \"Missing variable `%s`\" key)\n\n and eval_arg\n : type a. variable_map\n -> ?field_type:string\n -> field_name:string\n -> arg_name:string\n -> a arg_typ\n -> Graphql_parser.const_value option\n -> (a, string) result =\n fun variable_map ?field_type ~field_name ~arg_name typ value ->\n match (typ, value) with\n | NonNullable _, None -> Error (eval_arg_error ?field_type ~field_name ~arg_name typ value)\n | NonNullable _, Some `Null -> Error (eval_arg_error ?field_type ~field_name ~arg_name typ value)\n | Scalar _, None -> Ok None\n | Scalar _, Some `Null -> Ok None\n | Object _, None -> Ok None\n | Object _, Some `Null -> Ok None\n | List _, None -> Ok None\n | List _, Some `Null -> Ok None\n | Enum _, None -> Ok None\n | Enum _, Some `Null -> Ok None\n | Scalar s, Some value ->\n begin match (s.coerce value) with\n | Ok coerced -> Ok (Some coerced)\n | Error _ -> Error (eval_arg_error ?field_type ~field_name ~arg_name typ (Some value))\n end\n | Object o, Some value ->\n begin match value with\n | `Assoc props ->\n let props' = (props :> (string * Graphql_parser.value) list) in\n eval_arglist variable_map ?field_type ~field_name o.fields props' o.coerce >>| fun coerced ->\n Some coerced\n | _ -> Error (eval_arg_error ?field_type ~field_name ~arg_name typ (Some value))\n end\n | List typ, Some value ->\n begin match value with\n | `List values ->\n let option_values = List.map (fun x -> Some x) values in\n List.Result.all (eval_arg variable_map ?field_type ~field_name ~arg_name typ) option_values >>| fun coerced ->\n Some coerced\n | value -> eval_arg variable_map ?field_type ~field_name ~arg_name typ (Some value) >>| fun coerced ->\n (Some [coerced] : a)\n end\n | NonNullable typ, value ->\n eval_arg variable_map ?field_type ~field_name ~arg_name typ value >>= (function\n | Some value -> Ok value\n | None -> Error (eval_arg_error ?field_type ~field_name ~arg_name typ None))\n | Enum e, Some value ->\n begin match value with\n | `Enum v\n | `String v ->\n begin match List.find (fun enum_value -> enum_value.name = v) e.values with\n | Some enum_value -> Ok (Some enum_value.value)\n | None -> Error (Printf.sprintf \"Invalid enum value for argument `%s` on field `%s`\" arg_name field_name)\n end\n | _ -> Error (Printf.sprintf \"Expected enum for argument `%s` on field `%s`\" arg_name field_name)\n end\n end\n\n (* Schema data types *)\n type 'a scalar = {\n name : string;\n doc : string option;\n coerce : 'a -> json;\n }\n\n type 'a enum = {\n name : string;\n doc : string option;\n values : 'a enum_value list;\n }\n\n type fragment_map = Graphql_parser.fragment StringMap.t\n type 'ctx resolve_info = {\n ctx : 'ctx;\n field : Graphql_parser.field;\n fragments : fragment_map;\n variables : variable_map;\n }\n\n type ('ctx, 'src) obj = {\n name : string;\n doc : string option;\n fields : ('ctx, 'src) field list Lazy.t;\n abstracts : abstract list ref;\n }\n and (_, _) field =\n Field : {\n name : string;\n doc : string option;\n deprecated : deprecated;\n typ : ('ctx, 'out) typ;\n args : ('a, 'args) Arg.arg_list;\n resolve : 'ctx resolve_info -> 'src -> 'args;\n lift : 'a -> ('out, field_error) result Io.t;\n } -> ('ctx, 'src) field\n and (_, _) typ =\n | Object : ('ctx, 'src) obj -> ('ctx, 'src option) typ\n | List : ('ctx, 'src) typ -> ('ctx, 'src list option) typ\n | NonNullable : ('ctx, 'src option) typ -> ('ctx, 'src) typ\n | Scalar : 'src scalar -> ('ctx, 'src option) typ\n | Enum : 'src enum -> ('ctx, 'src option) typ\n | Abstract : abstract -> ('ctx, ('ctx, 'a) abstract_value option) typ\n and any_typ =\n | AnyTyp : (_, _) typ -> any_typ\n | AnyArgTyp : _ Arg.arg_typ -> any_typ\n and abstract = {\n name : string;\n doc : string option;\n kind : [`Union | `Interface of abstract_field list Lazy.t];\n mutable types : any_typ list;\n }\n and abstract_field =\n AbstractField : (_, _) field -> abstract_field\n and ('ctx, 'a) abstract_value =\n AbstractValue : ('ctx, 'src option) typ * 'src -> ('ctx, 'a) abstract_value\n\n type 'ctx subscription_field =\n SubscriptionField : {\n name : string;\n doc : string option;\n deprecated : deprecated;\n typ : ('ctx, 'out) typ;\n args : (('out Io.Stream.t, field_error) result Io.t, 'args) Arg.arg_list;\n resolve : 'ctx resolve_info -> 'args;\n } -> 'ctx subscription_field\n\n type 'ctx subscription_obj = {\n name : string;\n doc : string option;\n fields : 'ctx subscription_field list;\n }\n\n type ('ctx, 'a) abstract_typ = ('ctx, ('ctx, 'a) abstract_value option) typ\n\n type directive_location = [\n | `Query\n | `Mutation\n | `Subscription\n | `Field\n | `Fragment_definition\n | `Fragment_spread\n | `Inline_fragment\n | `Variable_definition\n ]\n\n type directive =\n Directive : {\n name : string;\n doc : string option;\n locations : directive_location list;\n args : ([ `Skip | `Include ], 'args) Arg.arg_list;\n resolve : 'args;\n } -> directive\n\n type 'ctx schema = {\n query : ('ctx, unit) obj;\n mutation : ('ctx, unit) obj option;\n subscription : 'ctx subscription_obj option;\n }\n\n let schema ?(mutation_name=\"mutation\")\n ?mutations\n ?(subscription_name=\"subscription\")\n ?subscriptions\n ?(query_name=\"query\")\n fields = {\n query = {\n name = query_name;\n doc = None;\n abstracts = ref [];\n fields = lazy fields;\n };\n mutation = Option.map mutations ~f:(fun fields ->\n {\n name = mutation_name;\n doc = None;\n abstracts = ref [];\n fields = lazy fields;\n }\n );\n subscription = Option.map subscriptions ~f:(fun fields ->\n {\n name = subscription_name;\n doc = None;\n fields;\n }\n )\n }\n\n (* Constructor functions *)\n let obj ?doc name ~fields =\n let rec o = Object { name; doc; fields = lazy (fields o); abstracts = ref []} in\n o\n\n let field ?doc ?(deprecated=NotDeprecated) name ~typ ~args ~resolve =\n Field { name; doc; deprecated; typ; args; resolve; lift = Io.ok }\n\n let io_field ?doc ?(deprecated=NotDeprecated) name ~typ ~args ~resolve =\n Field { name; doc; deprecated; typ; args; resolve; lift = id }\n\n let abstract_field ?doc ?(deprecated=NotDeprecated) name ~typ ~args =\n AbstractField (Field { lift = Io.ok; name; doc; deprecated; typ; args; resolve = Obj.magic () })\n\n let subscription_field ?doc ?(deprecated=NotDeprecated) name ~typ ~args ~resolve =\n SubscriptionField { name; doc; deprecated; typ; args; resolve }\n\n let enum ?doc name ~values =\n Enum { name; doc; values }\n\n let scalar ?doc name ~coerce =\n Scalar { name; doc; coerce }\n\n let list typ =\n List typ\n\n let non_null typ =\n NonNullable typ\n\n let union ?doc name =\n Abstract { name; doc; types = []; kind = `Union }\n\n let interface ?doc name ~fields =\n let rec i = Abstract { name; doc; types = []; kind = `Interface (lazy (fields i)) } in\n i\n\n let add_type abstract_typ typ =\n match (abstract_typ, typ) with\n | Abstract a, Object o ->\n (* TODO add subtype check here *)\n a.types <- (AnyTyp typ)::a.types;\n o.abstracts := a :: !(o.abstracts);\n fun src -> AbstractValue (typ, src)\n | _ ->\n invalid_arg \"Arguments must be Interface/Union and Object\"\n\n let obj_of_subscription_obj {name; doc; fields} =\n let fields = List.map\n (fun (SubscriptionField {name; doc; deprecated; typ; args; resolve}) ->\n Field { lift = Obj.magic (); name; doc; deprecated; typ; args; resolve = (fun ctx () -> resolve ctx) })\n fields\n in\n { name; doc; abstracts = ref []; fields = lazy fields }\n\n (* Built-in scalars *)\n let int : 'ctx. ('ctx, int option) typ = Scalar {\n name = \"Int\";\n doc = None;\n coerce = fun i -> `Int i;\n }\n\n let string : 'ctx. ('ctx, string option) typ = Scalar {\n name = \"String\";\n doc = None;\n coerce = fun s ->`String s;\n }\n\n let bool : 'ctx. ('ctx, bool option) typ = Scalar {\n name = \"Boolean\";\n doc = None;\n coerce = fun b -> `Bool b;\n }\n\n let float : 'ctx. ('ctx, float option) typ = Scalar {\n name = \"Float\";\n doc = None;\n coerce = fun f -> `Float f;\n }\n\n let guid : 'ctx. ('ctx, string option) typ = Scalar {\n name = \"ID\";\n doc = None;\n coerce = fun x -> `String x;\n }\n\n (* Mandatory directives: skip and include *)\n let skip_directive = Directive {\n name = \"skip\";\n doc = Some \"Directs the executor to skip this field or fragment when the `if` argument is true.\";\n locations = [`Field; `Fragment_spread; `Inline_fragment];\n args = Arg.[\n arg \"if\" ~doc:\"Skipped when true.\" ~typ:(non_null bool)\n ];\n resolve = function\n | true -> `Skip\n | false -> `Include\n }\n\n let include_directive = Directive {\n name = \"include\";\n doc = Some \"Directs the executor to include this field or fragment only when the `if` argument is true.\";\n locations = [`Field; `Fragment_spread; `Inline_fragment];\n args = Arg.[\n arg \"if\" ~doc:\"Included when true.\" ~typ:(non_null bool)\n ];\n resolve = function\n | true -> `Include\n | false -> `Skip\n }\n\nmodule Introspection = struct\n (* any_typ, any_field and any_arg hide type parameters to avoid scope escaping errors *)\n type any_field =\n | AnyField : (_, _) field -> any_field\n | AnyArgField : _ Arg.arg -> any_field\n type any_arg = AnyArg : _ Arg.arg -> any_arg\n type any_enum_value = AnyEnumValue : _ enum_value -> any_enum_value\n\n let unless_visited (result, visited) name f =\n if StringSet.mem name visited then\n result, visited\n else\n f (result, visited)\n\n (* Extracts all types contained in a single type *)\n let rec types : type ctx src. ?memo:(any_typ list * StringSet.t) -> (ctx, src) typ -> (any_typ list * StringSet.t) = fun ?(memo=([], StringSet.empty)) typ ->\n match typ with\n | List typ -> types ~memo typ\n | NonNullable typ -> types ~memo typ\n | Scalar s as scalar ->\n unless_visited memo s.name (fun (result, visited) ->\n (AnyTyp scalar)::result, StringSet.add s.name visited\n )\n | Enum e as enum ->\n unless_visited memo e.name (fun (result, visited) ->\n (AnyTyp enum)::result, StringSet.add e.name visited\n )\n | Object o as obj ->\n unless_visited memo o.name (fun (result, visited) ->\n let result' = (AnyTyp obj)::result in\n let visited' = StringSet.add o.name visited in\n let reducer = fun memo (Field f) ->\n let memo' = types ~memo f.typ in\n arg_list_types memo' f.args\n in\n List.fold_left reducer (result', visited') (Lazy.force o.fields)\n )\n | Abstract a as abstract ->\n unless_visited memo a.name (fun (result, visited) ->\n let result' = (AnyTyp abstract)::result in\n let visited' = StringSet.add a.name visited in\n List.fold_left (fun memo typ -> match typ with\n | AnyTyp typ -> types ~memo typ\n | AnyArgTyp _ -> failwith \"Abstracts can't have argument types\")\n (result', visited') a.types\n )\n\n and arg_types : type a. (any_typ list * StringSet.t) -> a Arg.arg_typ -> (any_typ list * StringSet.t) = fun memo argtyp ->\n match argtyp with\n | Arg.List typ -> arg_types memo typ\n | Arg.NonNullable typ -> arg_types memo typ\n | Arg.Scalar s as scalar ->\n unless_visited memo s.name (fun (result, visited) ->\n (AnyArgTyp scalar)::result, StringSet.add s.name visited\n )\n | Arg.Enum e as enum ->\n unless_visited memo e.name (fun (result, visited) ->\n (AnyArgTyp enum)::result, StringSet.add e.name visited\n )\n | Arg.Object o as obj ->\n unless_visited memo o.name (fun (result, visited) ->\n let memo' = (AnyArgTyp obj)::result, StringSet.add o.name visited in\n arg_list_types memo' o.fields\n )\n and arg_list_types : type a b. (any_typ list * StringSet.t) -> (a, b) Arg.arg_list -> (any_typ list * StringSet.t) = fun memo arglist ->\n let open Arg in\n match arglist with\n | [] -> memo\n | arg::args ->\n let memo' = match arg with\n | Arg a -> arg_types memo a.typ\n | DefaultArg a -> arg_types memo a.typ\n in arg_list_types memo' args\n\n let types_of_schema s =\n let types, _ =\n List.fold_left\n (fun memo op ->\n match op with\n | None -> memo\n | Some op -> types ~memo (Object op))\n ([], StringSet.empty)\n [Some s.query; s.mutation; Option.map s.subscription ~f:obj_of_subscription_obj]\n in\n types\n\n let rec args_to_list : type a b. ?memo:any_arg list -> (a, b) Arg.arg_list -> any_arg list = fun ?memo:(memo=[]) arglist ->\n let open Arg in\n match arglist with\n | [] ->\n memo\n | arg::args ->\n let memo' = List.cons (AnyArg arg) memo in\n args_to_list ~memo:memo' args\n\n let no_abstracts = ref []\n\n let __type_kind = Enum {\n name = \"__TypeKind\";\n doc = None;\n values = [\n {\n name=\"SCALAR\";\n doc=None;\n deprecated=NotDeprecated;\n value=`Scalar;\n };\n {\n name=\"OBJECT\";\n doc=None;\n deprecated=NotDeprecated;\n value=`Object;\n };\n {\n name=\"INTERFACE\";\n doc=None;\n deprecated=NotDeprecated;\n value=`Interface;\n };\n {\n name=\"UNION\";\n doc=None;\n deprecated=NotDeprecated;\n value=`Union;\n };\n {\n name=\"ENUM\";\n doc=None;\n deprecated=NotDeprecated;\n value=`Enum;\n };\n {\n name=\"INPUT_OBJECT\";\n doc=None;\n deprecated=NotDeprecated;\n value=`InputObject;\n };\n {\n name=\"LIST\";\n doc=None;\n deprecated=NotDeprecated;\n value=`List;\n };\n {\n name=\"NON_NULL\";\n doc=None;\n deprecated=NotDeprecated;\n value=`NonNull;\n };\n ]\n }\n\n let __enum_value : 'ctx. ('ctx, any_enum_value option) typ = Object {\n name = \"__EnumValue\";\n doc = None;\n abstracts = no_abstracts;\n fields = lazy [\n Field {\n name = \"name\";\n doc = None;\n deprecated = NotDeprecated;\n typ = NonNullable string;\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ (AnyEnumValue enum_value) -> enum_value.name;\n };\n Field {\n name = \"description\";\n doc = None;\n deprecated = NotDeprecated;\n typ = string;\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ (AnyEnumValue enum_value) -> enum_value.doc;\n };\n Field {\n name = \"isDeprecated\";\n doc = None;\n deprecated = NotDeprecated;\n typ = NonNullable bool;\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ (AnyEnumValue enum_value) -> enum_value.deprecated <> NotDeprecated;\n };\n Field {\n name = \"deprecationReason\";\n doc = None;\n deprecated = NotDeprecated;\n typ = string;\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ (AnyEnumValue enum_value) ->\n match enum_value.deprecated with\n | Deprecated reason -> reason\n | NotDeprecated -> None\n }\n ]\n }\n\n let rec __input_value : 'ctx. ('ctx, any_arg option) typ = Object {\n name = \"__InputValue\";\n doc = None;\n abstracts = no_abstracts;\n fields = lazy [\n Field {\n name = \"name\";\n doc = None;\n deprecated = NotDeprecated;\n typ = NonNullable string;\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ (AnyArg arg) -> match arg with\n | Arg.DefaultArg a -> a.name\n | Arg.Arg a -> a.name\n };\n Field {\n name = \"description\";\n doc = None;\n deprecated = NotDeprecated;\n typ = string;\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ (AnyArg arg) -> match arg with\n | Arg.DefaultArg a -> a.doc\n | Arg.Arg a -> a.doc\n };\n Field {\n name = \"type\";\n doc = None;\n deprecated = NotDeprecated;\n typ = NonNullable __type;\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ (AnyArg arg) -> match arg with\n | Arg.DefaultArg a -> AnyArgTyp a.typ\n | Arg.Arg a -> AnyArgTyp a.typ\n };\n Field {\n name = \"defaultValue\";\n doc = None;\n deprecated = NotDeprecated;\n typ = string;\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ (AnyArg _) -> None\n }\n ]\n }\n\n and __type : 'ctx . ('ctx, any_typ option) typ = Object {\n name = \"__Type\";\n doc = None;\n abstracts = no_abstracts;\n fields = lazy [\n Field {\n name = \"kind\";\n doc = None;\n deprecated = NotDeprecated;\n typ = NonNullable __type_kind;\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ t -> match t with\n | AnyTyp (Object _) -> `Object\n | AnyTyp (Abstract { kind = `Union; _ }) -> `Union\n | AnyTyp (Abstract { kind = `Interface _; _ }) -> `Interface\n | AnyTyp (List _) -> `List\n | AnyTyp (Scalar _) -> `Scalar\n | AnyTyp (Enum _) -> `Enum\n | AnyTyp (NonNullable _) -> `NonNull\n | AnyArgTyp (Arg.Object _) -> `InputObject\n | AnyArgTyp (Arg.List _) -> `List\n | AnyArgTyp (Arg.Scalar _) -> `Scalar\n | AnyArgTyp (Arg.Enum _) -> `Enum\n | AnyArgTyp (Arg.NonNullable _) -> `NonNull\n };\n Field {\n name = \"name\";\n doc = None;\n deprecated = NotDeprecated;\n typ = string;\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ t -> match t with\n | AnyTyp (Object o) -> Some o.name\n | AnyTyp (Scalar s) -> Some s.name\n | AnyTyp (Enum e) -> Some e.name\n | AnyTyp (Abstract a) -> Some a.name\n | AnyArgTyp (Arg.Object o) -> Some o.name\n | AnyArgTyp (Arg.Scalar s) -> Some s.name\n | AnyArgTyp (Arg.Enum e) -> Some e.name\n | _ -> None;\n };\n Field {\n name = \"description\";\n doc = None;\n deprecated = NotDeprecated;\n typ = string;\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ t -> match t with\n | AnyTyp (Object o) -> o.doc\n | AnyTyp (Scalar s) -> s.doc\n | AnyTyp (Enum e) -> e.doc\n | AnyTyp (Abstract a) -> a.doc\n | AnyArgTyp (Arg.Object o) -> o.doc\n | AnyArgTyp (Arg.Scalar s) -> s.doc\n | AnyArgTyp (Arg.Enum e) -> e.doc\n | _ -> None\n };\n Field {\n name = \"fields\";\n doc = None;\n deprecated = NotDeprecated;\n typ = List (NonNullable __field);\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ t -> match t with\n | AnyTyp (Object o) ->\n Some (List.map (fun f -> AnyField f) (Lazy.force o.fields))\n | AnyTyp (Abstract { kind = `Interface fields; _ }) ->\n Some (List.map (fun (AbstractField f) -> AnyField f) (Lazy.force fields))\n | AnyArgTyp (Arg.Object o) ->\n let arg_list = args_to_list o.fields in\n Some (List.map (fun (AnyArg f) -> AnyArgField f) arg_list)\n | _ -> None\n };\n Field {\n name = \"interfaces\";\n doc = None;\n deprecated = NotDeprecated;\n typ = List (NonNullable __type);\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ t -> match t with\n | AnyTyp (Object o) ->\n let interfaces = List.filter (function | { kind = `Interface _; _} -> true | _ -> false) !(o.abstracts) in\n Some (List.map (fun i -> AnyTyp (Abstract i)) interfaces)\n | _ -> None\n };\n Field {\n name = \"possibleTypes\";\n doc = None;\n deprecated = NotDeprecated;\n typ = List (NonNullable __type);\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ t -> match t with\n | AnyTyp (Abstract a) ->\n Some a.types\n | _ -> None\n };\n Field {\n name = \"ofType\";\n doc = None;\n deprecated = NotDeprecated;\n typ = __type;\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ t -> match t with\n | AnyTyp (NonNullable typ) -> Some (AnyTyp typ)\n | AnyTyp (List typ) -> Some (AnyTyp typ)\n | AnyArgTyp (Arg.NonNullable typ) -> Some (AnyArgTyp typ)\n | AnyArgTyp (Arg.List typ) -> Some (AnyArgTyp typ)\n | _ -> None\n };\n Field {\n name = \"inputFields\";\n doc = None;\n deprecated = NotDeprecated;\n typ = List (NonNullable __input_value);\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ t -> match t with\n | AnyArgTyp (Arg.Object o) ->\n Some (args_to_list o.fields)\n | _ -> None\n };\n Field {\n name = \"enumValues\";\n doc = None;\n deprecated = NotDeprecated;\n typ = List (NonNullable __enum_value);\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ t -> match t with\n | AnyTyp (Enum e) -> Some (List.map (fun x -> AnyEnumValue x) e.values)\n | AnyArgTyp (Arg.Enum e) -> Some (List.map (fun x -> AnyEnumValue x) e.values)\n | _ -> None\n }\n ]\n }\n\n and __field : 'ctx. ('ctx, any_field option) typ = Object {\n name = \"__Field\";\n doc = None;\n abstracts = no_abstracts;\n fields = lazy [\n Field {\n name = \"name\";\n doc = None;\n deprecated = NotDeprecated;\n typ = NonNullable string;\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ f -> match f with\n | AnyField (Field f) -> f.name\n | AnyArgField (Arg.Arg a) -> a.name\n | AnyArgField (Arg.DefaultArg a) -> a.name\n };\n Field {\n name = \"description\";\n doc = None;\n deprecated = NotDeprecated;\n typ = string;\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ f -> match f with\n | AnyField (Field f) -> f.doc\n | AnyArgField (Arg.Arg a) -> a.doc\n | AnyArgField (Arg.DefaultArg a) -> a.doc\n };\n Field {\n name = \"args\";\n doc = None;\n deprecated = NotDeprecated;\n typ = NonNullable (List (NonNullable __input_value));\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ f -> match f with\n | AnyField (Field f) -> args_to_list f.args\n | AnyArgField _ -> []\n };\n Field {\n name = \"type\";\n doc = None;\n deprecated = NotDeprecated;\n typ = NonNullable __type;\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ f -> match f with\n | AnyField (Field f) -> AnyTyp f.typ\n | AnyArgField (Arg.Arg a) -> AnyArgTyp a.typ\n | AnyArgField (Arg.DefaultArg a) -> AnyArgTyp a.typ\n };\n Field {\n name = \"isDeprecated\";\n doc = None;\n deprecated = NotDeprecated;\n typ = NonNullable bool;\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ f -> match f with\n | AnyField (Field { deprecated = Deprecated _; _ }) -> true\n | _ -> false\n };\n Field {\n name = \"deprecationReason\";\n doc = None;\n deprecated = NotDeprecated;\n typ = string;\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ f -> match f with\n | AnyField (Field { deprecated = Deprecated reason; _ }) -> reason\n | _ -> None\n }\n ]\n }\n\n let __directive_location = Enum {\n name = \"__DirectiveLocation\";\n doc = None;\n values = [\n {\n name=\"QUERY\";\n doc=None;\n deprecated=NotDeprecated;\n value=`Query;\n };\n {\n name=\"MUTATION\";\n doc=None;\n deprecated=NotDeprecated;\n value=`Mutation;\n };\n {\n name=\"SUBSCRIPTION\";\n doc=None;\n deprecated=NotDeprecated;\n value=`Subscription;\n };\n {\n name=\"FIELD\";\n doc=None;\n deprecated=NotDeprecated;\n value=`Field;\n };\n {\n name=\"FRAGMENT_DEFINITION\";\n doc=None;\n deprecated=NotDeprecated;\n value=`Fragment_definition;\n };\n {\n name=\"FRAGMENT_SPREAD\";\n doc=None;\n deprecated=NotDeprecated;\n value=`Fragment_spread;\n };\n {\n name=\"INLINE_FRAGMENT\";\n doc=None;\n deprecated=NotDeprecated;\n value=`Inline_fragment;\n };\n {\n name=\"VARIABLE_DEFINITION\";\n doc=None;\n deprecated=NotDeprecated;\n value=`Variable_definition;\n };\n ]\n }\n\n let __directive = Object {\n name = \"__Directive\";\n doc = None;\n abstracts = no_abstracts;\n fields = lazy [\n Field {\n name = \"name\";\n doc = None;\n deprecated = NotDeprecated;\n typ = NonNullable string;\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ (Directive d) -> d.name\n };\n Field {\n name = \"description\";\n doc = None;\n deprecated = NotDeprecated;\n typ = string;\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ (Directive d) -> d.doc\n };\n Field {\n name = \"locations\";\n doc = None;\n deprecated = NotDeprecated;\n typ = NonNullable (List (NonNullable __directive_location));\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ (Directive d) -> d.locations\n };\n Field {\n name = \"args\";\n doc = None;\n deprecated = NotDeprecated;\n typ = NonNullable (List (NonNullable __input_value));\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ (Directive d) -> args_to_list d.args\n }\n ]\n }\n\n let __schema : 'ctx. ('ctx, ('ctx schema * any_typ list) option) typ = Object {\n name = \"__Schema\";\n doc = None;\n abstracts = no_abstracts;\n fields = lazy [\n Field {\n name = \"types\";\n doc = None;\n deprecated = NotDeprecated;\n typ = NonNullable (List (NonNullable __type));\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ (_schema, types) -> types\n };\n Field {\n name = \"queryType\";\n doc = None;\n deprecated = NotDeprecated;\n typ = NonNullable __type;\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ (schema, _types) -> AnyTyp (Object schema.query)\n };\n Field {\n name = \"mutationType\";\n doc = None;\n deprecated = NotDeprecated;\n typ = __type;\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ (schema, _types) -> Option.map schema.mutation ~f:(fun mut -> AnyTyp (Object mut))\n };\n Field {\n name = \"subscriptionType\";\n doc = None;\n deprecated = NotDeprecated;\n typ = __type;\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ (schema, _types) ->\n Option.map schema.subscription ~f:(fun subs -> AnyTyp (Object (obj_of_subscription_obj subs)))\n };\n Field {\n name = \"directives\";\n doc = None;\n deprecated = NotDeprecated;\n typ = NonNullable (List (NonNullable __directive));\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ _ -> []\n }\n ]\n }\n\n let add_built_in_fields schema =\n let types = types_of_schema schema in\n let schema_field = Field {\n name = \"__schema\";\n doc = None;\n deprecated = NotDeprecated;\n typ = NonNullable __schema;\n args = Arg.[];\n lift = Io.ok;\n resolve = fun _ _ -> (schema, types)\n } in\n let type_field = Field {\n name = \"__type\";\n doc = None;\n deprecated = NotDeprecated;\n typ = __type;\n args = Arg.[arg \"name\" ~typ:(non_null string)];\n lift = Io.ok;\n resolve = fun _ _ name ->\n List.find (fun typ ->\n match typ with\n | AnyTyp (Object o) -> o.name = name\n | AnyTyp (Scalar s) -> s.name = name\n | AnyTyp (Enum e) -> e.name = name\n | AnyTyp (Abstract a) -> a.name = name\n | AnyTyp (List _) -> false\n | AnyTyp (NonNullable _) -> false\n | AnyArgTyp (Arg.Object o) -> o.name = name\n | AnyArgTyp (Arg.Scalar s) -> s.name = name\n | AnyArgTyp (Arg.Enum e) -> e.name = name\n | AnyArgTyp (Arg.List _) -> false\n | AnyArgTyp (Arg.NonNullable _) -> false\n ) types\n } in\n let fields = lazy (schema_field::type_field::(Lazy.force schema.query.fields)) in\n { schema with query = { schema.query with fields } }\nend\n\n (* Execution *)\n type variables = (string * Graphql_parser.const_value) list\n type execution_order = Serial | Parallel\n type 'ctx execution_context = {\n variables : variable_map;\n fragments : fragment_map;\n ctx : 'ctx;\n }\n\n type path = [`String of string | `Int of int] list\n type error = field_error * path\n\n type resolve_error = [\n | `Resolve_error of error\n | `Argument_error of string\n | `Validation_error of string\n ]\n\n type execute_error = [\n resolve_error\n | `Mutations_not_configured\n | `Subscriptions_not_configured\n | `No_operation_found\n | `Operation_name_required\n | `Operation_not_found\n ]\n\n type 'a response = ('a, json) result\n\n let matches_type_condition type_condition (obj : ('ctx, 'src) obj) =\n obj.name = type_condition ||\n List.exists (fun (abstract : abstract) -> abstract.name = type_condition) !(obj.abstracts)\n\n let rec should_include_field ctx (directives : Graphql_parser.directive list) =\n match directives with\n | [] -> Ok true\n | { name = \"skip\"; arguments }::rest ->\n eval_directive ctx skip_directive arguments rest\n | { name = \"include\"; arguments }::rest ->\n eval_directive ctx include_directive arguments rest\n | { name; _ }::_ ->\n let err = Format.sprintf \"Unknown directive: %s\" name in\n Error err\n\n and eval_directive ctx (Directive { name; args; resolve; _ }) arguments rest =\n let open Rresult in\n Arg.eval_arglist ctx.variables ~field_type:\"directive\" ~field_name:name args arguments resolve >>= function\n | `Skip -> Ok false\n | `Include -> should_include_field ctx rest\n\n let alias_or_name : Graphql_parser.field -> string = fun field ->\n match field.alias with\n | Some alias -> alias\n | None -> field.name\n\n let rec merge_selections ?(memo=[]) = function\n | [] -> List.rev memo\n | field::fields ->\n let id = alias_or_name field in\n let matching, rest = List.partition (fun field' -> id = (alias_or_name field')) fields in\n let selection_sets = List.map (fun (field : Graphql_parser.field) -> field.selection_set) (field::matching) in\n let selection_set = List.concat selection_sets in\n merge_selections ~memo:({field with selection_set}::memo) rest\n\n let rec collect_fields : 'ctx execution_context -> ('ctx, 'src) obj -> Graphql_parser.selection list -> (Graphql_parser.field list, string) result =\n fun ctx obj fields ->\n let open Rresult in\n List.map (function\n | Graphql_parser.Field field ->\n should_include_field ctx field.directives >>| fun include_field ->\n if include_field then [field] else []\n | Graphql_parser.FragmentSpread spread ->\n begin match StringMap.find spread.name ctx.fragments with\n | Some { directives; type_condition; selection_set; _ }\n when matches_type_condition type_condition obj ->\n should_include_field ctx directives >>= fun include_field ->\n if include_field then\n collect_fields ctx obj selection_set\n else Ok []\n | _ -> Ok []\n end\n | Graphql_parser.InlineFragment fragment ->\n let matches_type_condition = match fragment.type_condition with\n | None -> true\n | Some condition -> matches_type_condition condition obj\n in\n if matches_type_condition then\n should_include_field ctx fragment.directives >>= fun include_field ->\n if include_field then\n collect_fields ctx obj fragment.selection_set\n else Ok []\n else\n Ok []\n ) fields\n |> List.Result.join\n |> Rresult.R.map List.concat\n |> Rresult.R.map merge_selections\n\n let field_from_object : ('ctx, 'src) obj -> string -> ('ctx, 'src) field option = fun obj field_name ->\n List.find (fun (Field field) -> field.name = field_name) (Lazy.force obj.fields)\n\n let field_from_subscription_object = fun obj field_name ->\n List.find (fun (SubscriptionField field) -> field.name = field_name) obj.fields\n\n let coerce_or_null : 'a option -> ('a -> (json * error list, 'b) result Io.t) -> (json * error list, 'b) result Io.t =\n fun src f ->\n match src with\n | None -> Io.ok (`Null, [])\n | Some src' -> f src'\n\n let map_fields_with_order = function\n | Serial -> Io.map_s ~memo:[]\n | Parallel -> Io.map_p\n\n let error_to_json ?path ?extensions msg =\n let props = match path with\n | Some path -> [\"path\", `List (List.rev path :> json list)]\n | None -> []\n in\n let extension_props = match extensions with\n | None\n | Some [] -> []\n | Some extensions -> [\"extensions\", `Assoc extensions]\n in\n (`Assoc ((\"message\", `String msg)::(List.append props extension_props)) : json)\n\n let error_response ?data ?path ?extensions msg =\n let errors = \"errors\", `List [\n error_to_json ?path ?extensions msg\n ]\n in\n let data = match data with\n | None -> []\n | Some data -> [\"data\", data]\n in\n `Assoc (errors :: data)\n\n let rec present : type ctx src. ctx execution_context -> src -> Graphql_parser.field -> (ctx, src) typ -> path -> (json * error list, [> resolve_error]) result Io.t =\n fun ctx src query_field typ path ->\n match typ with\n | Scalar s -> coerce_or_null src (fun x -> Io.ok (s.coerce x, []))\n | List t ->\n coerce_or_null src (fun src' ->\n List.mapi (fun i x -> present ctx x query_field t ((`Int i)::path)) src'\n |> Io.all\n |> Io.map ~f:List.Result.join\n |> Io.Result.map ~f:(fun xs -> (`List (List.map fst xs), List.map snd xs |> List.concat))\n )\n | NonNullable t -> present ctx (Some src) query_field t path\n | Object o ->\n coerce_or_null src (fun src' ->\n match collect_fields ctx o query_field.selection_set with\n | Ok fields -> resolve_fields ctx src' o fields path\n | Error e -> Io.error (`Argument_error e))\n | Enum e ->\n coerce_or_null src (fun src' ->\n match List.find (fun enum_value -> src' == enum_value.value) e.values with\n | Some enum_value -> Io.ok (`String enum_value.name, [])\n | None -> Io.ok (`Null, [])\n )\n | Abstract _ ->\n coerce_or_null src (fun (AbstractValue (typ', src')) ->\n present ctx (Some src') query_field typ' path\n )\n\n and resolve_field : type ctx src. ctx execution_context -> src -> Graphql_parser.field -> (ctx, src) field -> path -> ((string * json) * error list, [> resolve_error]) result Io.t =\n fun ctx src query_field (Field field) path ->\n let open Io.Infix in\n let name = alias_or_name query_field in\n let path' = (`String name)::path in\n let resolve_info = {\n ctx = ctx.ctx;\n field = query_field;\n fragments = ctx.fragments;\n variables = ctx.variables;\n } in\n let resolver = field.resolve resolve_info src in\n match Arg.eval_arglist ctx.variables ~field_name:field.name field.args query_field.arguments resolver with\n | Ok unlifted_value ->\n let lifted_value =\n field.lift unlifted_value\n |> Io.Result.map_error ~f:(fun err -> `Resolve_error (err, path')) >>=? fun resolved ->\n present ctx resolved query_field field.typ path'\n in\n lifted_value >>| (function\n | Ok (value, errors) ->\n Ok ((name, value), errors)\n | Error (`Argument_error _)\n | Error (`Validation_error _) as error ->\n error\n | Error (`Resolve_error err) as error ->\n match field.typ with\n | NonNullable _ ->\n error\n | _ ->\n Ok ((name, `Null), [err])\n )\n | Error err ->\n Io.error (`Argument_error err)\n\n and resolve_fields : type ctx src. ctx execution_context -> ?execution_order:execution_order -> src -> (ctx, src) obj -> Graphql_parser.field list -> path -> (json * error list, [> resolve_error]) result Io.t =\n fun ctx ?execution_order:(execution_order=Parallel) src obj fields path ->\n map_fields_with_order execution_order (fun (query_field : Graphql_parser.field) ->\n let name = alias_or_name query_field in\n if query_field.name = \"__typename\" then\n Io.ok ((name, `String obj.name), [])\n else\n match field_from_object obj query_field.name with\n | Some field ->\n resolve_field ctx src query_field field path\n | None ->\n let err = Printf.sprintf \"Field '%s' is not defined on type '%s'\" query_field.name obj.name in\n Io.error (`Validation_error err)\n ) fields\n |> Io.map ~f:List.Result.join\n |> Io.Result.map ~f:(fun xs -> (`Assoc (List.map fst xs), List.map snd xs |> List.concat))\n\n let data_to_json = function\n | data, [] -> `Assoc [\"data\", data]\n | data, errors ->\n let errors = List.map\n (fun (field_error, path) ->\n let extensions = Field_error.extensions_of_field_error field_error in\n let msg = Field_error.message_of_field_error field_error in\n error_to_json ~path ?extensions msg)\n errors\n in\n `Assoc [\n \"errors\", `List errors;\n \"data\", data;\n ]\n\n let to_response = function\n | Ok _ as res -> res\n | Error `No_operation_found ->\n Error (error_response \"No operation found\")\n | Error `Operation_not_found ->\n Error (error_response \"Operation not found\")\n | Error `Operation_name_required ->\n Error (error_response \"Operation name required\")\n | Error `Subscriptions_not_configured ->\n Error (error_response \"Subscriptions not configured\")\n | Error `Mutations_not_configured ->\n Error (error_response \"Mutations not configured\")\n | Error (`Validation_error msg) ->\n Error (error_response msg)\n | Error (`Argument_error msg) ->\n Error (error_response ~data:`Null msg)\n | Error (`Resolve_error (field_error, path)) ->\n let extensions = Field_error.extensions_of_field_error field_error in\n let msg = Field_error.message_of_field_error field_error in\n Error (error_response ~data:`Null ~path ?extensions msg)\n\n let subscribe : type ctx. ctx execution_context -> ctx subscription_field -> Graphql_parser.field -> (json response Io.Stream.t, [> resolve_error]) result Io.t\n =\n fun ctx (SubscriptionField subs_field) field ->\n let open Io.Infix in\n let name = alias_or_name field in\n let path = [`String name] in\n let resolve_info = {\n ctx = ctx.ctx;\n field;\n fragments = ctx.fragments;\n variables = ctx.variables\n } in\n let resolver = subs_field.resolve resolve_info in\n match Arg.eval_arglist ctx.variables ~field_name:subs_field.name subs_field.args field.arguments resolver with\n | Ok result ->\n result\n |> Io.Result.map ~f:(fun source_stream ->\n Io.Stream.map source_stream (fun value ->\n present ctx value field subs_field.typ path\n |> Io.Result.map ~f:(fun (data, errors) ->\n data_to_json (`Assoc [name, data], errors)\n )\n >>| to_response\n )\n )\n |> Io.Result.map_error ~f:(fun err ->\n `Resolve_error (err, path)\n )\n | Error err -> Io.error (`Argument_error err)\n\n let execute_operation : 'ctx schema -> 'ctx execution_context -> Graphql_parser.operation -> ([ `Response of json | `Stream of json response Io.Stream.t], [> execute_error]) result Io.t =\n fun schema ctx operation ->\n let open Io.Infix in\n match operation.optype with\n | Graphql_parser.Query ->\n let query = schema.query in\n Io.return (collect_fields ctx query operation.selection_set)\n |> Io.Result.map_error ~f:(fun e -> `Argument_error e) >>=? fun fields ->\n (resolve_fields ctx () query fields [] : (json * error list, resolve_error) result Io.t :> (json * error list, [> execute_error]) result Io.t)\n |> Io.Result.map ~f:(fun data_errs -> `Response (data_to_json data_errs))\n | Graphql_parser.Mutation ->\n begin match schema.mutation with\n | None -> Io.error `Mutations_not_configured\n | Some mut ->\n Io.return (collect_fields ctx mut operation.selection_set)\n |> Io.Result.map_error ~f:(fun e -> `Argument_error e) >>=? fun fields ->\n (resolve_fields ~execution_order:Serial ctx () mut fields [] : (json * error list, resolve_error) result Io.t :> (json * error list, [> execute_error]) result Io.t)\n |> Io.Result.map ~f:(fun data_errs -> `Response (data_to_json data_errs))\n end\n | Graphql_parser.Subscription ->\n begin match schema.subscription with\n | None -> Io.error `Subscriptions_not_configured\n | Some subs ->\n Io.return (collect_fields ctx (obj_of_subscription_obj subs) operation.selection_set)\n |> Io.Result.map_error ~f:(fun e -> `Argument_error e) >>=? fun fields ->\n begin match fields with\n | [field] ->\n (match field_from_subscription_object subs field.name with\n | Some subscription_field ->\n (subscribe ctx subscription_field field : ((json, json) result Io.Stream.t, resolve_error) result Io.t :> ((json, json) result Io.Stream.t, [> execute_error]) result Io.t)\n |> Io.Result.map ~f:(fun stream -> `Stream stream)\n | None -> Io.ok (`Response (`Assoc [(alias_or_name field, `Null)])))\n (* see http://facebook.github.io/graphql/June2018/#sec-Response-root-field *)\n | _ -> Io.error (`Validation_error \"Subscriptions only allow exactly one selection for the operation.\")\n end\n end\n\n let collect_fragments doc =\n List.fold_left (fun memo -> function\n | Graphql_parser.Operation _ -> memo\n | Graphql_parser.Fragment f -> StringMap.add f.name f memo\n ) StringMap.empty doc\n\n exception FragmentCycle of string list\n let rec validate_fragments fragment_map =\n try\n StringMap.iter (fun name _ ->\n validate_fragment fragment_map StringSet.empty name\n ) fragment_map;\n Ok fragment_map\n with FragmentCycle fragment_names ->\n let cycle = String.concat \", \" fragment_names in\n let err = Format.sprintf \"Fragment cycle detected: %s\" cycle in\n Error (`Validation_error err)\n\n and validate_fragment (fragment_map : fragment_map) visited name =\n match StringMap.find name fragment_map with\n | None -> ()\n | Some fragment when StringSet.mem fragment.name visited ->\n raise (FragmentCycle (StringSet.elements visited))\n | Some fragment ->\n let visited' = StringSet.add fragment.name visited in\n List.iter (validate_fragment_selection fragment_map visited') fragment.selection_set\n\n and validate_fragment_selection fragment_map visited selection =\n match selection with\n | Graphql_parser.Field field ->\n List.iter (validate_fragment_selection fragment_map visited) field.selection_set\n | InlineFragment inline_fragment ->\n List.iter (validate_fragment_selection fragment_map visited) inline_fragment.selection_set\n | FragmentSpread fragment_spread ->\n validate_fragment fragment_map visited fragment_spread.name\n\n let collect_and_validate_fragments doc =\n let fragments = collect_fragments doc in\n validate_fragments fragments\n\n let collect_operations doc =\n List.fold_left (fun memo -> function\n | Graphql_parser.Operation op -> op::memo\n | Graphql_parser.Fragment _ -> memo\n ) [] doc\n\n let select_operation ?operation_name doc =\n let operations = collect_operations doc in\n match operation_name, operations with\n | _, [] -> Error `No_operation_found\n | None, [op] -> Ok op\n | None, _::_ -> Error `Operation_name_required\n | Some name, ops ->\n try\n Ok (List.find_exn (fun op -> op.Graphql_parser.name = Some name) ops)\n with Not_found ->\n Error `Operation_not_found\n\n let execute schema ctx ?variables:(variables=[]) ?operation_name doc =\n let open Io.Infix in\n let execute' schema ctx doc =\n Io.return (collect_and_validate_fragments doc) >>=? fun fragments ->\n let schema' = Introspection.add_built_in_fields schema in\n Io.return (select_operation ?operation_name doc) >>=? fun op ->\n let default_variables = List.fold_left (fun memo { Graphql_parser.name; default_value; _ } ->\n match default_value with\n | None -> memo\n | Some value -> StringMap.add name value memo\n ) StringMap.empty op.variable_definitions in\n let variables = List.fold_left (fun memo (name, value) -> StringMap.add name value memo) default_variables variables in\n let execution_ctx = { fragments; ctx; variables } in\n execute_operation schema' execution_ctx op\n in\n execute' schema ctx doc >>| to_response\nend\n","open Core_kernel\n\nmodule Annotations = struct\n module Utils = struct\n let find xs key =\n List.find ~f:(fun (k', _) -> String.equal key k') xs |> Option.map ~f:snd\n\n let find_string xs key =\n find xs key |> Option.join |> Option.map ~f:(fun s -> String.strip s)\n\n let find_bool xs key =\n find xs key\n |> Option.map ~f:(fun _ -> true)\n |> Option.value ~default:false\n end\n\n module Top = struct\n (** Top comment *)\n type t = { name : string; doc : string option }\n [@@deriving annot, sexp, compare, equal]\n\n open Utils\n\n let of_annots ~name t_toplevel_annots =\n let xs = t_toplevel_annots () in\n { name; doc = find_string xs \"ocaml.doc\" }\n\n let%test_unit \"top annots parse\" =\n let t = of_annots ~name:\"Top\" t_toplevel_annots in\n [%test_eq: t] t { name = \"Top\"; doc = Some \"Top comment\" }\n end\n\n module Fields = struct\n module T = struct\n type t =\n { name : string option\n ; doc : string option [@name \"document\"]\n ; skip : bool [@skip]\n ; deprecated : string option [@depr \"foo\"] (** this is deprecated *)\n }\n [@@deriving annot, sexp, compare, equal]\n end\n\n type t = string -> T.t\n\n open Utils\n\n let of_annots t_fields_annots field =\n let xs = t_fields_annots field in\n let s = find_string xs in\n let b = find_bool xs in\n { T.name = s \"name\"\n ; doc = s \"ocaml.doc\"\n ; skip = b \"skip\"\n ; deprecated = s \"depr\"\n }\n\n let%test_unit \"field annots parse\" =\n let annots = of_annots T.t_fields_annots in\n [%test_eq: T.t] (annots \"doc\")\n { name = Some \"document\"; doc = None; skip = false; deprecated = None } ;\n [%test_eq: T.t] (annots \"skip\")\n { name = None; doc = None; skip = true; deprecated = None } ;\n [%test_eq: T.t] (annots \"deprecated\")\n { name = None\n ; doc = Some \"this is deprecated\"\n ; skip = false\n ; deprecated = Some \"foo\"\n }\n end\nend\n\n(** Rewrites underscore_case to camelCase. Note: Keeps leading underscores. *)\nlet under_to_camel s =\n (* take all the underscores *)\n let prefix_us =\n String.take_while s ~f:(function '_' -> true | _ -> false)\n in\n (* remove them from the original *)\n let rest = String.substr_replace_first ~pattern:prefix_us ~with_:\"\" s in\n let ws = String.split rest ~on:'_' in\n let result =\n match ws with\n | [] ->\n \"\"\n | w :: ws ->\n (* capitalize each word separated by underscores *)\n w :: (ws |> List.map ~f:String.capitalize) |> String.concat ?sep:None\n in\n (* add the leading underscoes back *)\n String.concat [ prefix_us; result ]\n\nlet%test_unit \"under_to_camel works as expected\" =\n let open Core_kernel in\n [%test_eq: string] \"fooHello\" (under_to_camel \"foo_hello\") ;\n [%test_eq: string] \"fooHello\" (under_to_camel \"foo_hello___\") ;\n [%test_eq: string] \"_fooHello\" (under_to_camel \"_foo_hello__\")\n\n(** Like Field.name but rewrites underscore_case to camelCase. *)\nlet name_under_to_camel f = Fieldslib.Field.name f |> under_to_camel\n\nlet introspection_query_raw =\n {graphql|\n query IntrospectionQuery {\n __schema {\n queryType { name }\n mutationType { name }\n subscriptionType { name }\n types {\n ...FullType\n }\n directives {\n name\n description\n locations\n args {\n ...InputValue\n }\n }\n }\n }\n fragment FullType on __Type {\n kind\n name\n description\n fields(includeDeprecated: true) {\n name\n description\n args {\n ...InputValue\n }\n type {\n ...TypeRef\n }\n isDeprecated\n deprecationReason\n }\n inputFields {\n ...InputValue\n }\n interfaces {\n ...TypeRef\n }\n enumValues(includeDeprecated: true) {\n name\n description\n isDeprecated\n deprecationReason\n }\n possibleTypes {\n ...TypeRef\n }\n }\n fragment InputValue on __InputValue {\n name\n description\n type { ...TypeRef }\n defaultValue\n }\n fragment TypeRef on __Type {\n kind\n name\n ofType {\n kind\n name\n ofType {\n kind\n name\n ofType {\n kind\n name\n ofType {\n kind\n name\n ofType {\n kind\n name\n ofType {\n kind\n name\n ofType {\n kind\n name\n }\n }\n }\n }\n }\n }\n }\n }\n |graphql}\n","open Core_kernel\nopen Fieldslib\n\nmodule Graphql_raw = struct\n module Make (Schema : Graphql_intf.Schema) = struct\n module Args = struct\n module Input = struct\n type ('row, 'result, 'ty, 'nullable) t =\n < graphql_arg : (unit -> 'ty Schema.Arg.arg_typ) ref\n ; nullable_graphql_arg : (unit -> 'nullable Schema.Arg.arg_typ) ref\n ; map : ('ty -> 'result) ref\n ; skip : bool ref\n ; .. >\n as\n 'row\n end\n\n module Acc = struct\n module T = struct\n type ('ty, 'fields) t_inner =\n { graphql_arg_fields : ('ty, 'fields) Schema.Arg.arg_list\n ; graphql_arg_coerce : 'fields\n }\n\n type 'ty t = Init | Acc : ('ty, 'fields) t_inner -> 'ty t\n end\n\n type ('row, 'result, 'ty, 'nullable) t =\n < graphql_arg_accumulator : 'result T.t ref ; .. > as 'row\n constraint\n ('row, 'c, 'ty, 'nullable) t =\n ('row, 'c, 'ty, 'nullable) Input.t\n end\n\n module Creator = struct\n type ('row, 'c, 'ty, 'nullable) t = < .. > as 'row\n constraint\n ('row, 'c, 'ty, 'nullable) t =\n ('row, 'c, 'ty, 'nullable) Input.t\n end\n\n module Output = struct\n type ('row, 'c, 'ty, 'nullable) t = < .. > as 'row\n constraint\n ('row, 'c, 'ty, 'nullable) t =\n ('row, 'c, 'ty, 'nullable) Input.t\n end\n\n let add_field (type f f' ty ty' nullable1 nullable2) ?skip_data\n ~t_fields_annots :\n ('f_row, f', f, nullable1) Input.t\n -> ([< `Read | `Set_and_create ], _, _) Field.t_with_perm\n -> ('row, ty', ty, nullable2) Acc.t\n -> (('row, ty', ty, nullable2) Creator.t -> f')\n * ('row_after, ty', ty, nullable2) Acc.t =\n fun f_input field acc ->\n let annotations =\n Fields_derivers.Annotations.Fields.of_annots t_fields_annots\n (Field.name field)\n in\n let ref_as_pipe = ref None in\n let name =\n Option.value annotations.name\n ~default:(Fields_derivers.name_under_to_camel field)\n in\n let () =\n let inner_acc = acc#graphql_arg_accumulator in\n if annotations.skip || !(f_input#skip) then ()\n else\n let arg =\n Schema.Arg.arg name ?doc:annotations.doc\n ~typ:(!(f_input#graphql_arg) ())\n in\n match !inner_acc with\n | Init ->\n inner_acc :=\n Acc\n { graphql_arg_coerce =\n (fun x ->\n ref_as_pipe := Some x ;\n !(acc#graphql_creator) acc )\n ; graphql_arg_fields = [ arg ]\n }\n | Acc { graphql_arg_fields; graphql_arg_coerce } -> (\n match graphql_arg_fields with\n | [] ->\n inner_acc :=\n Acc\n { graphql_arg_coerce =\n (fun x ->\n ref_as_pipe := Some x ;\n !(acc#graphql_creator) acc )\n ; graphql_arg_fields = [ arg ]\n }\n | _ ->\n inner_acc :=\n Acc\n { graphql_arg_coerce =\n (fun x ->\n ref_as_pipe := Some x ;\n graphql_arg_coerce )\n ; graphql_arg_fields = arg :: graphql_arg_fields\n } )\n in\n ( (fun _creator_input ->\n !(f_input#map)\n @@\n if annotations.skip || !(f_input#skip) then\n match skip_data with\n | Some data ->\n data\n | None ->\n failwith\n \"If you are skipping a field but intend on building this \\\n field, you must provide skip_data to add_field!\"\n else Option.value_exn !ref_as_pipe )\n , acc )\n\n let finish name ~t_toplevel_annots (type ty result nullable) :\n (('row, result, ty, nullable) Input.t -> result)\n * ('row, result, ty, nullable) Acc.t\n -> _ Output.t =\n fun (creator, acc) ->\n let annotations =\n Fields_derivers.Annotations.Top.of_annots ~name t_toplevel_annots\n in\n acc#graphql_creator := creator ;\n (acc#graphql_arg :=\n fun () ->\n match !(acc#graphql_arg_accumulator) with\n | Init ->\n failwith \"Graphql args need at least one field\"\n | Acc { graphql_arg_fields; graphql_arg_coerce } ->\n (* TODO: Figure out why the typechecker doesn't like this\n * expression and remove Obj.magic. *)\n Obj.magic\n @@ Schema.Arg.(\n obj ?doc:annotations.doc\n (annotations.name ^ \"Input\")\n ~fields:graphql_arg_fields ~coerce:graphql_arg_coerce\n |> non_null) ) ;\n (acc#nullable_graphql_arg :=\n fun () ->\n match !(acc#graphql_arg_accumulator) with\n | Init ->\n failwith \"Graphql args need at least one field\"\n | Acc { graphql_arg_fields; graphql_arg_coerce } ->\n (* TODO: See above *)\n Obj.magic\n @@ Schema.Arg.(\n obj ?doc:annotations.doc\n (annotations.name ^ \"Input\")\n ~fields:graphql_arg_fields ~coerce:graphql_arg_coerce)\n ) ;\n acc\n\n let skip obj =\n obj#skip := true ;\n (obj#graphql_arg :=\n fun () ->\n failwith \"Unexpected: This obj#graphql_arg should be skipped\" ) ;\n obj#map := Fn.id ;\n obj#graphql_arg_accumulator := !(obj#graphql_arg_accumulator) ;\n (obj#nullable_graphql_arg :=\n fun () ->\n failwith \"Unexpected: This obj#graphql_arg should be skipped\" ) ;\n obj\n\n let int obj =\n (obj#graphql_arg := fun () -> Schema.Arg.(non_null int)) ;\n obj#map := Fn.id ;\n obj#graphql_arg_accumulator := !(obj#graphql_arg_accumulator) ;\n (obj#nullable_graphql_arg := fun () -> Schema.Arg.int) ;\n obj\n\n let string obj =\n (obj#graphql_arg := fun () -> Schema.Arg.(non_null string)) ;\n obj#map := Fn.id ;\n obj#graphql_arg_accumulator := !(obj#graphql_arg_accumulator) ;\n (obj#nullable_graphql_arg := fun () -> Schema.Arg.string) ;\n obj\n\n let bool obj =\n (obj#graphql_arg := fun () -> Schema.Arg.(non_null bool)) ;\n obj#map := Fn.id ;\n obj#graphql_arg_accumulator := !(obj#graphql_arg_accumulator) ;\n (obj#nullable_graphql_arg := fun () -> Schema.Arg.bool) ;\n obj\n\n let list x obj : (_, 'result list, 'input_type list, _) Input.t =\n (obj#graphql_arg :=\n fun () -> Schema.Arg.(non_null (list (!(x#graphql_arg) ()))) ) ;\n obj#map := List.map ~f:!(x#map) ;\n obj#graphql_arg_accumulator := !(x#graphql_arg_accumulator) ;\n (obj#nullable_graphql_arg :=\n fun () -> Schema.Arg.(list (!(x#graphql_arg) ())) ) ;\n obj\n\n let option (x : (_, 'result, 'input_type, _) Input.t) obj =\n obj#graphql_arg := !(x#nullable_graphql_arg) ;\n obj#nullable_graphql_arg := !(x#nullable_graphql_arg) ;\n obj#map := Option.map ~f:!(x#map) ;\n obj#graphql_arg_accumulator := !(x#graphql_arg_accumulator) ;\n obj\n\n let map ~(f : 'c -> 'd) (x : (_, 'c, 'input_type, _) Input.t) obj :\n (_, 'd, 'input_type, _) Input.t =\n obj#graphql_arg := !(x#graphql_arg) ;\n (obj#map := fun a -> f (!(x#map) a)) ;\n obj#nullable_graphql_arg := !(x#nullable_graphql_arg) ;\n obj#graphql_arg_accumulator := !(x#graphql_arg_accumulator) ;\n obj\n end\n\n module Fields = struct\n module Input = struct\n module T = struct\n type 'input_type t =\n { run : 'ctx. unit -> ('ctx, 'input_type) Schema.typ }\n end\n\n type ('input_type, 'a, 'c, 'nullable) t =\n < graphql_fields : 'input_type T.t ref\n ; contramap : ('c -> 'input_type) ref\n ; nullable_graphql_fields : 'nullable T.t ref\n ; .. >\n as\n 'a\n end\n\n module Accumulator = struct\n module T = struct\n type 'input_type t =\n { run : 'ctx. unit -> ('ctx, 'input_type) Schema.field option }\n end\n\n (** thunks generating the schema in reverse *)\n type ('input_type, 'a, 'c, 'nullable) t =\n < graphql_fields_accumulator : 'c T.t list ref ; .. > as 'a\n constraint\n ('input_type, 'a, 'c, 'nullable) t =\n ('input_type, 'a, 'c, 'nullable) Input.t\n end\n\n let add_field (type f input_type orig nullable c' nullable')\n ~t_fields_annots :\n (orig, 'a, f, nullable) Input.t\n -> ([< `Read | `Set_and_create ], c', f) Fieldslib.Field.t_with_perm\n -> (input_type, 'row2, c', nullable') Accumulator.t\n -> (_ -> f) * (input_type, 'row2, c', nullable') Accumulator.t =\n fun t_field field acc ->\n let annotations =\n Fields_derivers.Annotations.Fields.of_annots t_fields_annots\n (Field.name field)\n in\n let rest = !(acc#graphql_fields_accumulator) in\n acc#graphql_fields_accumulator :=\n { Accumulator.T.run =\n (fun () ->\n if annotations.skip || !(t_field#skip) then None\n else\n Schema.field\n (Option.value annotations.name\n ~default:(Fields_derivers.name_under_to_camel field) )\n ~args:Schema.Arg.[]\n ?doc:annotations.doc\n ~deprecated:\n ( Option.map annotations.deprecated ~f:(fun msg ->\n Schema.Deprecated (Some msg) )\n |> Option.value ~default:Schema.NotDeprecated )\n ~typ:(!(t_field#graphql_fields).Input.T.run ())\n ~resolve:(fun _ x ->\n !(t_field#contramap) (Field.get field x) )\n |> Option.return )\n }\n :: rest ;\n ((fun _ -> failwith \"Unused\"), acc)\n\n let finish name ~t_toplevel_annots ((_creator, obj) : 'u * _ Accumulator.t)\n : _ Input.t =\n let annotations =\n Fields_derivers.Annotations.Top.of_annots ~name t_toplevel_annots\n in\n let graphql_fields_accumulator = !(obj#graphql_fields_accumulator) in\n let graphql_fields =\n { Input.T.run =\n (fun () ->\n Schema.obj annotations.name ?doc:annotations.doc\n ~fields:(fun _ ->\n List.rev\n @@ List.filter_map graphql_fields_accumulator ~f:(fun g ->\n g.Accumulator.T.run () ) )\n |> Schema.non_null )\n }\n in\n let nullable_graphql_fields =\n { Input.T.run =\n (fun () ->\n Schema.obj annotations.name ?doc:annotations.doc\n ~fields:(fun _ ->\n List.rev\n @@ List.filter_map graphql_fields_accumulator ~f:(fun g ->\n g.Accumulator.T.run () ) ) )\n }\n in\n obj#graphql_fields := graphql_fields ;\n obj#nullable_graphql_fields := nullable_graphql_fields ;\n obj#contramap := Fn.id ;\n obj\n\n let skip obj =\n (obj#graphql_fields :=\n Input.T.\n { run =\n (fun () ->\n failwith\n \"Unexpected: This obj#graphql_fields should be skipped\" )\n } ) ;\n obj#contramap := Fn.id ;\n obj#graphql_fields_accumulator := !(obj#graphql_fields_accumulator) ;\n (obj#nullable_graphql_fields :=\n Input.T.\n { run =\n (fun () ->\n failwith\n \"Unexpected: This obj#nullable_graphql_fields should be \\\n skipped\" )\n } ) ;\n obj\n\n let int obj =\n (obj#graphql_fields :=\n Input.T.{ run = (fun () -> Schema.(non_null int)) } ) ;\n obj#contramap := Fn.id ;\n obj#graphql_fields_accumulator := !(obj#graphql_fields_accumulator) ;\n (obj#nullable_graphql_fields := Input.T.{ run = (fun () -> Schema.int) }) ;\n obj\n\n let string obj =\n (obj#graphql_fields :=\n Input.T.{ run = (fun () -> Schema.(non_null string)) } ) ;\n obj#contramap := Fn.id ;\n obj#graphql_fields_accumulator := !(obj#graphql_fields_accumulator) ;\n (obj#nullable_graphql_fields :=\n Input.T.{ run = (fun () -> Schema.string) } ) ;\n obj\n\n let bool obj =\n (obj#graphql_fields :=\n Input.T.{ run = (fun () -> Schema.(non_null bool)) } ) ;\n obj#contramap := Fn.id ;\n obj#graphql_fields_accumulator := !(obj#graphql_fields_accumulator) ;\n (obj#nullable_graphql_fields :=\n Input.T.{ run = (fun () -> Schema.bool) } ) ;\n obj\n\n let list x obj : ('input_type list, _, _, _) Input.t =\n (obj#graphql_fields :=\n Input.T.\n { run =\n (fun () ->\n Schema.(non_null (list (!(x#graphql_fields).run ()))) )\n } ) ;\n obj#contramap := List.map ~f:!(x#contramap) ;\n obj#graphql_fields_accumulator := !(x#graphql_fields_accumulator) ;\n (obj#nullable_graphql_fields :=\n Input.T.\n { run = (fun () -> Schema.(list (!(x#graphql_fields).run ()))) } ) ;\n obj\n\n let option (x : ('input_type, 'b, 'c, 'nullable) Input.t) obj :\n ('input_type option, _, 'c option, _) Input.t =\n obj#graphql_fields := !(x#nullable_graphql_fields) ;\n obj#nullable_graphql_fields := !(x#nullable_graphql_fields) ;\n obj#contramap := Option.map ~f:!(x#contramap) ;\n obj#graphql_fields_accumulator := !(x#graphql_fields_accumulator) ;\n obj\n\n let contramap ~(f : 'd -> 'c)\n (x : ('input_type, 'b, 'c, 'nullable) Input.t) obj :\n ('input_type, _, 'd, _) Input.t =\n obj#graphql_fields := !(x#graphql_fields) ;\n (obj#contramap := fun a -> !(x#contramap) (f a)) ;\n obj#nullable_graphql_fields := !(x#nullable_graphql_fields) ;\n obj#graphql_fields_accumulator := !(x#graphql_fields_accumulator) ;\n obj\n end\n\n let rec arg_to_yojson_rec (arg : Graphql_parser.const_value) : Yojson.Safe.t\n =\n match arg with\n | `Null ->\n `Null\n | `Int x ->\n `Int x\n | `Float x ->\n `Float x\n | `String x ->\n `String x\n | `Bool x ->\n `Bool x\n | `Enum x ->\n `String x\n | `List x ->\n `List (List.map x ~f:arg_to_yojson_rec)\n | `Assoc x ->\n `Assoc\n (List.map x ~f:(fun (key, value) -> (key, arg_to_yojson_rec value)))\n\n let arg_to_yojson arg : (Yojson.Safe.t, string) result =\n Ok (arg_to_yojson_rec arg)\n end\nend\n\nmodule Graphql_query = struct\n module Input = struct\n type 'a t = < graphql_query : string option ref ; .. > as 'a\n end\n\n module Accumulator = struct\n type 'a t =\n < graphql_query_accumulator : (string * string option) option list ref\n ; .. >\n as\n 'a\n constraint 'a t = 'a Input.t\n end\n\n let add_field ~t_fields_annots :\n 'a Input.t -> 'field -> 'obj -> 'creator * 'obj =\n fun t_field field acc_obj ->\n let annotations =\n Fields_derivers.Annotations.Fields.of_annots t_fields_annots\n (Field.name field)\n in\n let rest = !(acc_obj#graphql_query_accumulator) in\n acc_obj#graphql_query_accumulator :=\n ( if annotations.skip || !(t_field#skip) then None\n else\n Some\n ( Option.value annotations.name\n ~default:(Fields_derivers.name_under_to_camel field)\n , !(t_field#graphql_query) ) )\n :: rest ;\n ((fun _ -> failwith \"unused\"), acc_obj)\n\n let finish (_creator, obj) =\n let graphql_query_accumulator = !(obj#graphql_query_accumulator) in\n obj#graphql_query :=\n Some\n (sprintf \"{\\n%s\\n}\"\n ( List.filter_map graphql_query_accumulator\n ~f:\n (Option.map ~f:(fun (k, v) ->\n match v with None -> k | Some v -> sprintf \"%s %s\" k v )\n )\n |> List.rev |> String.concat ~sep:\"\\n\" ) ) ;\n obj\n\n let scalar obj =\n obj#graphql_query := None ;\n obj\n\n let skip obj = scalar obj\n\n let int obj = scalar obj\n\n let string obj = scalar obj\n\n let bool obj = scalar obj\n\n (* nullable and lists of things are projected to the inner thing ONLY IF inner\n * projectable. *)\n let wrapped x obj =\n obj#graphql_query := !(x#graphql_query) ;\n obj\n\n let option x obj = wrapped x obj\n\n let list x obj = wrapped x obj\n\n let inner_query obj = !(obj#graphql_query)\nend\n\nmodule IO = struct\n include Async_kernel.Deferred\n\n let bind x f = bind x ~f\n\n module Stream = struct\n type 'a t = 'a Async_kernel.Pipe.Reader.t\n\n let map t f =\n Async_kernel.Pipe.map' t ~f:(fun q ->\n Async_kernel.Deferred.Queue.map q ~f )\n\n let iter t f = Async_kernel.Pipe.iter t ~f\n\n let close = Async_kernel.Pipe.close_read\n end\nend\n\nmodule Field_error = struct\n type t = string\n\n let message_of_field_error t = t\n\n let extensions_of_field_error _t = None\nend\n\nmodule Schema = Graphql_schema.Make (IO) (Field_error)\nmodule Graphql = Graphql_raw.Make (Schema)\n\nmodule Test = struct\n let parse_query str =\n match Graphql_parser.parse str with\n | Ok res ->\n res\n | Error err ->\n failwith err\n\n let introspection_query () =\n parse_query Fields_derivers.introspection_query_raw\nend\n\nlet%test_module \"Test\" =\n ( module struct\n (* Pure -- just like Graphql libraries functor application *)\n module IO = struct\n type +'a t = 'a\n\n let bind t f = f t\n\n let return t = t\n\n module Stream = struct\n type 'a t = 'a Seq.t\n\n let map t f = Seq.map f t\n\n let iter t f = Seq.iter f t\n\n let close _t = ()\n end\n end\n\n module Schema = Graphql_schema.Make (IO) (Field_error)\n module Graphql = Graphql_raw.Make (Schema)\n module Graphql_fields = Graphql.Fields\n module Graphql_args = Graphql.Args\n\n let deriver (type a b c d) () :\n < contramap : (a -> b) ref\n ; graphql_fields : c Graphql_fields.Input.T.t ref\n ; nullable_graphql_fields : d Graphql_fields.Input.T.t ref\n ; .. >\n as\n 'row =\n (* We have to declare these outside of the object, otherwise the method\n * will create a new ref each time it is called. *)\n let open Graphql_fields in\n let graphql_fields =\n ref Input.T.{ run = (fun () -> failwith \"unimplemented1\") }\n in\n let graphql_arg = ref (fun () -> failwith \"unimplemented2\") in\n let contramap = ref (fun _ -> failwith \"unimplemented3\") in\n let map = ref (fun _ -> failwith \"unimplemented4\") in\n let nullable_graphql_fields =\n ref Input.T.{ run = (fun () -> failwith \"unimplemented5\") }\n in\n let nullable_graphql_arg = ref (fun () -> failwith \"unimplemented6\") in\n let graphql_fields_accumulator = ref [] in\n let graphql_arg_accumulator = ref Graphql_args.Acc.T.Init in\n let graphql_creator = ref (fun _ -> failwith \"unimplemented7\") in\n let graphql_query = ref None in\n let graphql_query_accumulator = ref [] in\n let skip = ref false in\n object\n method skip = skip\n\n method graphql_fields = graphql_fields\n\n method graphql_arg = graphql_arg\n\n method contramap = contramap\n\n method map = map\n\n method nullable_graphql_fields = nullable_graphql_fields\n\n method nullable_graphql_arg = nullable_graphql_arg\n\n method graphql_fields_accumulator = graphql_fields_accumulator\n\n method graphql_arg_accumulator = graphql_arg_accumulator\n\n method graphql_creator = graphql_creator\n\n method graphql_query = graphql_query\n\n method graphql_query_accumulator = graphql_query_accumulator\n end\n\n let o () = deriver ()\n\n let raw_server ?(print = false) q c =\n let schema = Schema.(schema [ q ] ~mutations:[] ~subscriptions:[]) in\n let res = Schema.execute schema () c in\n match res with\n | Ok (`Response data) ->\n if print then Yojson.Basic.pretty_print Format.std_formatter data ;\n data |> Yojson.Basic.to_string\n | Error err ->\n failwithf \"Unexpected error: %s\" (Yojson.Basic.to_string err) ()\n | _ ->\n failwith \"Unexpected response\"\n\n let query_schema typ v =\n Schema.(\n field \"query\" ~typ:(non_null typ)\n ~args:Arg.[]\n ~doc:\"sample query\"\n ~resolve:(fun _ _ -> v))\n\n let query_for_all typ v str =\n raw_server (query_schema typ v) (Test.parse_query str)\n\n let hit_server ?print q = raw_server ?print q (Test.introspection_query ())\n\n let hit_server_query (typ : _ Schema.typ) v =\n hit_server (query_schema typ v)\n\n let hit_server_args (arg_typ : 'a Schema.Arg.arg_typ) =\n hit_server\n Schema.(\n field \"args\" ~typ:(non_null int)\n ~args:Arg.[ arg \"input\" ~typ:arg_typ ]\n ~doc:\"sample args query\"\n ~resolve:(fun _ _ _ -> 0))\n\n module T1 = struct\n (** T1 is foo *)\n type t =\n { foo_hello : int option\n ; skipped : int [@skip]\n ; bar : string list [@name \"bar1\"]\n }\n [@@deriving annot, fields]\n\n let _v = { foo_hello = Some 1; skipped = 0; bar = [ \"baz1\"; \"baz2\" ] }\n\n let doc = \"T1 is foo\"\n\n let manual_typ =\n Schema.(\n obj \"T1\" ~doc ~fields:(fun _ ->\n [ field \"fooHello\"\n ~args:Arg.[]\n ~typ:int\n ~resolve:(fun _ t -> t.foo_hello)\n ; field \"bar1\"\n ~args:Arg.[]\n ~typ:(non_null (list (non_null string)))\n ~resolve:(fun _ t -> t.bar)\n ] ))\n\n let derived init =\n let open Graphql_fields in\n let ( !. ) x fd acc = add_field ~t_fields_annots (x (o ())) fd acc in\n Fields.make_creator init\n ~foo_hello:!.(option @@ int @@ o ())\n ~skipped:!.skip\n ~bar:!.(list @@ string @@ o ())\n |> finish \"T1\" ~t_toplevel_annots\n\n module Args = struct\n let manual_typ =\n Schema.Arg.(\n obj \"T1Input\" ~doc\n ~fields:\n [ arg \"bar1\" ~typ:(non_null (list (non_null string)))\n ; arg \"fooHello\" ~typ:int\n ]\n ~coerce:(fun bar foo_hello -> { bar; skipped = 0; foo_hello }))\n\n let derived init =\n let open Graphql_args in\n let ( !. ) ?skip_data x fd acc =\n add_field ?skip_data ~t_fields_annots (x (o ())) fd acc\n in\n Fields.make_creator init\n ~foo_hello:!.(option @@ int @@ o ())\n ~skipped:(( !. ) ~skip_data:0 skip)\n ~bar:!.(list @@ string @@ o ())\n |> finish \"T1\" ~t_toplevel_annots\n end\n\n module Query = struct\n let derived init =\n let open Graphql_query in\n let ( !. ) x fd acc = add_field ~t_fields_annots (x (o ())) fd acc in\n Fields.make_creator init\n ~foo_hello:!.(option @@ int @@ o ())\n ~skipped:!.skip\n ~bar:!.(list @@ string @@ o ())\n |> finish\n end\n end\n\n module Or_ignore_test = struct\n type 'a t = Check of 'a | Ignore\n\n let of_option = function None -> Ignore | Some x -> Check x\n\n let to_option = function Ignore -> None | Check x -> Some x\n\n let derived (x : ('input_type, 'b, 'c, _) Graphql_fields.Input.t) init :\n (_, _, 'c t, _) Graphql_fields.Input.t =\n let open Graphql_fields in\n let opt = option x (o ()) in\n contramap ~f:to_option opt init\n\n module Args = struct\n let derived (x : ('row1, 'c, 'input_type, _) Graphql_args.Input.t) init\n : ('row2, 'c t, 'input_type option, _) Graphql_args.Input.t =\n let open Graphql_args in\n let opt = option x (o ()) in\n map ~f:of_option opt init\n end\n\n module Query = struct\n let derived x init =\n let open Graphql_query in\n option x init\n end\n end\n\n module T2 = struct\n type t = { foo : T1.t Or_ignore_test.t } [@@deriving annot, fields]\n\n let v1 =\n { foo =\n Check\n { T1.foo_hello = Some 1; skipped = 0; bar = [ \"baz1\"; \"baz2\" ] }\n }\n\n let v2 = { foo = Ignore }\n\n let manual_typ =\n Schema.(\n obj \"T2\" ?doc:None ~fields:(fun _ ->\n [ field \"foo\"\n ~args:Arg.[]\n ~typ:T1.manual_typ\n ~resolve:(fun _ t -> Or_ignore_test.to_option t.foo)\n ] ))\n\n let derived init =\n let open Graphql_fields in\n let ( !. ) x fd acc = add_field ~t_fields_annots (x (o ())) fd acc in\n Fields.make_creator init\n ~foo:!.(Or_ignore_test.derived @@ T1.derived @@ o ())\n |> finish \"T2\" ~t_toplevel_annots\n\n module Args = struct\n let manual_typ =\n Schema.Arg.(\n obj \"T2Input\" ?doc:None\n ~fields:[ arg \"foo\" ~typ:T1.Args.manual_typ ]\n ~coerce:(fun foo -> Or_ignore_test.of_option foo))\n\n let derived init =\n let open Graphql_args in\n let ( !. ) x fd acc = add_field ~t_fields_annots (x (o ())) fd acc in\n Fields.make_creator init\n ~foo:!.(Or_ignore_test.Args.derived @@ T1.Args.derived @@ o ())\n |> finish \"T2\" ~t_toplevel_annots\n end\n\n module Query = struct\n let manual =\n {|\n {\n foo {\n fooHello\n bar1\n }\n }\n |}\n\n let derived init =\n let open Graphql_query in\n let ( !. ) x fd acc = add_field ~t_fields_annots (x (o ())) fd acc in\n Fields.make_creator init\n ~foo:!.(Or_ignore_test.Query.derived @@ T1.Query.derived @@ o ())\n |> finish\n end\n end\n\n let%test_unit \"T2 fold\" =\n let open Graphql_fields in\n let generated_typ =\n let typ_input = T2.(option @@ derived @@ o ()) (o ()) in\n !(typ_input#graphql_fields).run ()\n in\n [%test_eq: string]\n (hit_server_query generated_typ T2.v1)\n (hit_server_query T2.manual_typ T2.v1) ;\n [%test_eq: string]\n (hit_server_query generated_typ T2.v2)\n (hit_server_query T2.manual_typ T2.v2)\n\n let%test_unit \"T2 unfold\" =\n let open Graphql_args in\n let generated_arg_typ =\n let obj = T2.(option @@ Args.derived @@ o ()) (o ()) in\n !(obj#graphql_arg) ()\n in\n [%test_eq: string]\n (hit_server_args generated_arg_typ)\n (hit_server_args T2.Args.manual_typ)\n\n let%test_unit \"T2 query expected & parses\" =\n let open Graphql_fields in\n let generated_typ =\n let typ_input = T2.(option @@ derived @@ o ()) (o ()) in\n !(typ_input#graphql_fields).run ()\n in\n let open Graphql_query in\n let generated_query =\n T2.Query.(option @@ derived @@ o ()) (o ())\n |> inner_query |> Option.value_exn\n in\n let prefix = \"query TestQuery { query\" in\n let suffix = \"}\" in\n [%test_eq: string]\n (query_for_all generated_typ T2.v1 (prefix ^ generated_query ^ suffix))\n (query_for_all generated_typ T2.v1 (prefix ^ T2.Query.manual ^ suffix))\n end )\n","open Core_kernel\nopen Fieldslib\n\nmodule To_yojson = struct\n module Input = struct\n type ('input_type, 'a, 'c) t =\n < to_json : ('input_type -> Yojson.Safe.t) ref\n ; contramap : ('c -> 'input_type) ref\n ; skip : bool ref\n ; .. >\n as\n 'a\n end\n\n module Accumulator = struct\n type ('input_type, 'a, 'c) t =\n < to_json_accumulator :\n (string * ('input_type -> Yojson.Safe.t)) option list ref\n ; .. >\n as\n 'a\n constraint ('input_type, 'a, 'c) t = ('input_type, 'a, 'c) Input.t\n end\n\n let add_field ~t_fields_annots t_field field acc =\n let annotations =\n Fields_derivers.Annotations.Fields.of_annots t_fields_annots\n (Field.name field)\n in\n let rest = !(acc#to_json_accumulator) in\n acc#to_json_accumulator :=\n ( if annotations.skip || !(t_field#skip) then None\n else\n ( Option.value annotations.name\n ~default:(Fields_derivers.name_under_to_camel field)\n , fun x -> !(t_field#to_json) (!(t_field#contramap) (Field.get field x))\n )\n |> Option.return )\n :: rest ;\n ((fun _ -> failwith \"Unused\"), acc)\n\n let finish (_creator, obj) =\n let to_json_accumulator = !(obj#to_json_accumulator) in\n obj#contramap := Fn.id ;\n (obj#to_json :=\n fun t ->\n `Assoc\n ( List.filter_map to_json_accumulator\n ~f:(Option.map ~f:(fun (name, f) -> (name, f t)))\n |> List.rev ) ) ;\n obj\n\n let skip obj =\n obj#skip := true ;\n obj#contramap := Fn.id ;\n (obj#to_json :=\n fun _ -> failwith \"Unexpected: This obj#to_json should be skipped\" ) ;\n obj\n\n let int obj =\n obj#contramap := Fn.id ;\n (obj#to_json := fun x -> `Int x) ;\n obj\n\n let string obj =\n obj#contramap := Fn.id ;\n (obj#to_json := fun x -> `String x) ;\n obj\n\n let bool obj =\n obj#contramap := Fn.id ;\n (obj#to_json := fun x -> `Bool x) ;\n obj\n\n let list x obj =\n obj#contramap := List.map ~f:!(x#contramap) ;\n (obj#to_json := fun a -> `List (List.map ~f:!(x#to_json) a)) ;\n obj\n\n let option x obj =\n obj#contramap := Option.map ~f:!(x#contramap) ;\n (obj#to_json :=\n fun a_opt -> match a_opt with Some a -> !(x#to_json) a | None -> `Null ) ;\n obj\n\n let contramap ~f x obj =\n (obj#contramap := fun a -> !(x#contramap) (f a)) ;\n obj#to_json := !(x#to_json) ;\n obj\nend\n\nmodule Of_yojson = struct\n module Input = struct\n type ('input_type, 'a, 'c) t =\n < of_json : (Yojson.Safe.t -> 'input_type) ref\n ; map : ('input_type -> 'c) ref\n ; skip : bool ref\n ; .. >\n as\n 'a\n end\n\n module Creator = struct\n type ('input_type, 'a, 'c) t =\n < of_json_creator : Yojson.Safe.t String.Map.t ref ; .. > as 'a\n constraint ('input_type, 'a, 'c) t = ('input_type, 'a, 'c) Input.t\n end\n\n exception Field_not_found of string\n\n let add_field ?skip_data ~t_fields_annots :\n ('t, 'a, 'c) Input.t -> 'field -> 'obj -> 'creator * 'obj =\n fun t_field field acc_obj ->\n let annotations =\n Fields_derivers.Annotations.Fields.of_annots t_fields_annots\n (Field.name field)\n in\n let creator finished_obj =\n let map = !(finished_obj#of_json_creator) in\n !(t_field#map)\n ( if annotations.skip || !(t_field#skip) then\n match skip_data with\n | Some x ->\n x\n | None ->\n failwith\n \"If you are skipping a field in of_json but intend on building \\\n this field, you must provide skip_data to add_field!\"\n else\n !(t_field#of_json)\n (let name =\n Option.value annotations.name\n ~default:(Fields_derivers.name_under_to_camel field)\n in\n match Map.find map name with\n | None ->\n raise (Field_not_found name)\n | Some x ->\n x ) )\n in\n (creator, acc_obj)\n\n exception Json_not_object\n\n let finish (creator, obj) =\n let of_json json =\n match json with\n | `Assoc pairs ->\n obj#of_json_creator := String.Map.of_alist_exn pairs ;\n creator obj\n | _ ->\n raise Json_not_object\n in\n obj#map := Fn.id ;\n obj#of_json := of_json ;\n obj\n\n exception Invalid_json_scalar of [ `Int | `String | `Bool | `List ]\n\n let skip obj =\n obj#contramap := Fn.id ;\n (obj#of_json :=\n fun _ -> failwith \"Unexpected: This obj#of_json should be skipped\" ) ;\n obj\n\n let int obj =\n (obj#of_json :=\n function `Int x -> x | _ -> raise (Invalid_json_scalar `Int) ) ;\n obj#map := Fn.id ;\n obj\n\n let string obj =\n (obj#of_json :=\n function `String x -> x | _ -> raise (Invalid_json_scalar `String) ) ;\n obj#map := Fn.id ;\n obj\n\n let bool obj =\n (obj#of_json :=\n function `Bool x -> x | _ -> raise (Invalid_json_scalar `Bool) ) ;\n obj#map := Fn.id ;\n obj\n\n let list x obj =\n (obj#of_json :=\n function\n | `List xs ->\n List.map xs ~f:!(x#of_json)\n | _ ->\n raise (Invalid_json_scalar `List) ) ;\n obj#map := List.map ~f:!(x#map) ;\n obj\n\n let option x obj =\n (obj#of_json :=\n function `Null -> None | other -> Some (!(x#of_json) other) ) ;\n obj#map := Option.map ~f:!(x#map) ;\n obj\n\n let map ~f x obj =\n (obj#map := fun a -> f (!(x#map) a)) ;\n obj#of_json := !(x#of_json) ;\n obj\nend\n\nlet%test_module \"Test\" =\n ( module struct\n type t = { foo_hello : int; skipped : int [@skip]; bar : string list }\n [@@deriving annot, fields]\n\n let v = { foo_hello = 1; skipped = 0; bar = [ \"baz1\"; \"baz2\" ] }\n\n let m =\n {json|{ fooHello: 1, bar: [\"baz1\", \"baz2\"] }|json}\n |> Yojson.Safe.from_string\n\n module Yojson_version = struct\n type t = { foo_hello : int [@key \"fooHello\"]; bar : string list }\n [@@deriving yojson]\n\n let v = { foo_hello = 1; bar = [ \"baz1\"; \"baz2\" ] }\n end\n\n let deriver () =\n let to_json = ref (fun _ -> failwith \"unimplemented\") in\n let of_json = ref (fun _ -> failwith \"unimplemented\") in\n let to_json_accumulator = ref [] in\n let of_json_creator = ref String.Map.empty in\n let map = ref Fn.id in\n let contramap = ref Fn.id in\n let skip = ref false in\n object\n method skip = skip\n\n method to_json = to_json\n\n method map = map\n\n method contramap = contramap\n\n method of_json = of_json\n\n method to_json_accumulator = to_json_accumulator\n\n method of_json_creator = of_json_creator\n end\n\n let o () = deriver ()\n\n (* Explanation: Fields.make_creator roughly executes the following code:\n\n let make_creator ~foo_hello ~bar obj =\n (* Fieldslib.Field is actually a little more complicated *)\n let field_foo = Field { name = \"foo_hello\" ; getter = (fun o -> o.foo_hello) } in\n let field_bar = Field { name = \"bar\"; getter = (fun o -> o.bar) } in\n let creator_foo, obj = foo_hello field_foo obj in\n let creator_bar, obj = bar field_bar obj in\n let creator finished_obj =\n { foo_hello = creator_foo finished_obj ; bar = creator_bar finished_obj }\n in\n (creator, obj)\n *)\n\n let to_json obj =\n let open To_yojson in\n let ( !. ) x fd acc = add_field ~t_fields_annots (x @@ o ()) fd acc in\n Fields.make_creator obj ~foo_hello:!.int ~skipped:!.skip\n ~bar:!.(list @@ string @@ o ())\n |> finish\n\n let of_json obj =\n let open Of_yojson in\n let ( !. ) ?skip_data x fd acc =\n add_field ?skip_data ~t_fields_annots (x @@ o ()) fd acc\n in\n Fields.make_creator obj ~foo_hello:!.int\n ~skipped:(( !. ) ~skip_data:0 skip)\n ~bar:!.(list @@ string @@ o ())\n |> finish\n\n let both_json obj =\n let _a = to_json obj in\n let _b = of_json obj in\n obj\n\n let full_derivers = both_json @@ o ()\n\n let%test_unit \"folding creates a yojson object we expect (modulo camel \\\n casing)\" =\n [%test_eq: string]\n (Yojson_version.to_yojson Yojson_version.v |> Yojson.Safe.to_string)\n (!(full_derivers#to_json) v |> Yojson.Safe.to_string)\n\n let%test_unit \"unfolding creates a yojson object we expect\" =\n let expected =\n Yojson_version.of_yojson m |> Result.ok |> Option.value_exn\n in\n let actual = !(full_derivers#of_json) m in\n [%test_eq: string list] expected.bar actual.bar ;\n [%test_eq: int] expected.foo_hello actual.foo_hello\n\n let%test_unit \"round trip\" =\n [%test_eq: string]\n ( !(full_derivers#to_json) (!(full_derivers#of_json) m)\n |> Yojson.Safe.to_string )\n (m |> Yojson.Safe.to_string)\n end )\n","open Core_kernel\n\n[%%versioned\nmodule Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n type ('a, 'h) t = ('a, 'h) Mina_wire_types.With_hash.V1.t =\n { data : 'a; hash : 'h }\n [@@deriving annot, sexp, equal, compare, hash, yojson, fields]\n\n let to_latest data_latest hash_latest { data; hash } =\n { data = data_latest data; hash = hash_latest hash }\n end\nend]\n\ntype ('a, 'h) t = ('a, 'h) Stable.Latest.t = { data : 'a; hash : 'h }\n[@@deriving annot, sexp, equal, compare, hash, yojson]\n\nlet data { data; _ } = data\n\nlet hash { hash; _ } = hash\n\nlet map t ~f = { t with data = f t.data }\n\nlet map_hash t ~f = { t with hash = f t.hash }\n\nlet of_data data ~hash_data = { data; hash = hash_data data }\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nmodule Field = Snark_params.Tick.Field\n\nmodule Make (Schema : Graphql_intf.Schema) = struct\n module Graphql = Fields_derivers_graphql.Graphql_raw.Make (Schema)\n\n let derivers () =\n let graphql_fields =\n ref Graphql.Fields.Input.T.{ run = (fun () -> failwith \"unimplemented\") }\n in\n let nullable_graphql_fields =\n ref Graphql.Fields.Input.T.{ run = (fun () -> failwith \"unimplemented\") }\n in\n let graphql_fields_accumulator = ref [] in\n let graphql_arg = ref (fun () -> failwith \"unimplemented\") in\n let nullable_graphql_arg = ref (fun () -> failwith \"unimplemented\") in\n let graphql_arg_accumulator = ref Graphql.Args.Acc.T.Init in\n let graphql_creator = ref (fun _ -> failwith \"unimplemented\") in\n let graphql_query = ref None in\n let graphql_query_accumulator = ref [] in\n\n let to_json = ref (fun _ -> failwith \"unimplemented\") in\n let of_json = ref (fun _ -> failwith \"unimplemented\") in\n let to_json_accumulator = ref [] in\n let of_json_creator = ref String.Map.empty in\n\n let js_layout = ref (`Assoc []) in\n let js_layout_accumulator = ref [] in\n\n let contramap = ref (fun _ -> failwith \"unimplemented\") in\n let map = ref (fun _ -> failwith \"unimplemented\") in\n\n let skip = ref false in\n\n object\n method skip = skip\n\n method graphql_fields = graphql_fields\n\n method nullable_graphql_fields = nullable_graphql_fields\n\n method graphql_fields_accumulator = graphql_fields_accumulator\n\n method graphql_arg = graphql_arg\n\n method nullable_graphql_arg = nullable_graphql_arg\n\n method graphql_arg_accumulator = graphql_arg_accumulator\n\n method graphql_creator = graphql_creator\n\n method graphql_query = graphql_query\n\n method graphql_query_accumulator = graphql_query_accumulator\n\n method to_json = to_json\n\n method of_json = of_json\n\n method to_json_accumulator = to_json_accumulator\n\n method of_json_creator = of_json_creator\n\n method js_layout = js_layout\n\n method js_layout_accumulator = js_layout_accumulator\n\n method contramap = contramap\n\n method map = map\n end\n\n let o () = derivers ()\n\n module Unified_input = struct\n type 'a t = < .. > as 'a\n constraint 'a = _ Fields_derivers_json.To_yojson.Input.t\n constraint 'a = _ Fields_derivers_json.Of_yojson.Input.t\n constraint 'a = _ Graphql.Fields.Input.t\n constraint 'a = _ Graphql.Args.Input.t\n constraint 'a = _ Fields_derivers_graphql.Graphql_query.Input.t\n constraint 'a = _ Fields_derivers_js.Js_layout.Input.t\n end\n\n let yojson obj ?doc ~name ~js_type ~map ~contramap : _ Unified_input.t =\n (obj#graphql_fields :=\n let open Schema in\n Graphql.Fields.Input.T.\n { run =\n (fun () ->\n scalar name ?doc ~coerce:Yojson.Safe.to_basic |> non_null )\n } ) ;\n\n (obj#nullable_graphql_fields :=\n let open Schema in\n Graphql.Fields.Input.T.\n { run = (fun () -> scalar name ?doc ~coerce:Yojson.Safe.to_basic) } ) ;\n\n (obj#graphql_arg :=\n fun () ->\n Schema.Arg.scalar name ?doc ~coerce:Graphql.arg_to_yojson\n |> Schema.Arg.non_null ) ;\n\n (obj#nullable_graphql_arg :=\n fun () -> Schema.Arg.scalar name ?doc ~coerce:Graphql.arg_to_yojson ) ;\n\n obj#to_json := Fn.id ;\n\n obj#of_json := Fn.id ;\n\n obj#contramap := contramap ;\n\n obj#map := map ;\n\n obj#js_layout := Fields_derivers_js.Js_layout.leaf_type js_type ;\n\n Fields_derivers_graphql.Graphql_query.scalar obj\n\n let invalid_scalar_to_string = function\n | `Uint ->\n \"Uint\"\n | `Field ->\n \"Field\"\n | `Token_id ->\n \"Token_id\"\n | `Public_key ->\n \"Public_key\"\n | `Amount ->\n \"Amount\"\n | `Balance ->\n \"Balance\"\n | `Unit ->\n \"Unit\"\n | `Proof ->\n \"Proof\"\n | `Verification_key ->\n \"Verification_key\"\n | `Signature ->\n \"Signature\"\n\n let raise_invalid_scalar t s =\n failwith (\"Invalid rich scalar: \" ^ invalid_scalar_to_string t ^ \" \" ^ s)\n\n let except ~f v (x : string) = try f x with _ -> raise_invalid_scalar v x\n\n let iso_string ?doc ~name ~js_type obj ~(to_string : 'a -> string)\n ~(of_string : string -> 'a) =\n yojson obj ?doc ~name ~js_type\n ~map:(function\n | `String x ->\n of_string x\n | _ ->\n raise (Fields_derivers_json.Of_yojson.Invalid_json_scalar `String)\n )\n ~contramap:(fun x -> `String (to_string x))\n\n let uint64 obj : _ Unified_input.t =\n iso_string obj\n ~doc:\"Unsigned 64-bit integer represented as a string in base10\"\n ~name:\"UInt64\" ~js_type:UInt64 ~to_string:Unsigned.UInt64.to_string\n ~of_string:(except ~f:Unsigned.UInt64.of_string `Uint)\n\n let uint32 obj : _ Unified_input.t =\n iso_string obj\n ~doc:\"Unsigned 32-bit integer represented as a string in base10\"\n ~name:\"UInt32\" ~js_type:UInt32 ~to_string:Unsigned.UInt32.to_string\n ~of_string:(except ~f:Unsigned.UInt32.of_string `Uint)\n\n let field obj : _ Unified_input.t =\n iso_string obj ~name:\"Field\" ~js_type:Field\n ~doc:\"String representing an Fp Field element\" ~to_string:Field.to_string\n ~of_string:(except ~f:Field.of_string `Field)\n\n let public_key obj : _ Unified_input.t =\n iso_string obj ~name:\"PublicKey\" ~js_type:PublicKey\n ~doc:\"String representing a public key in base58\"\n ~to_string:Signature_lib.Public_key.Compressed.to_string\n ~of_string:\n (except ~f:Signature_lib.Public_key.Compressed.of_base58_check_exn\n `Public_key )\n\n let skip obj : _ Unified_input.t =\n let _a = Graphql.Fields.skip obj in\n let _b = Graphql.Args.skip obj in\n let _c = Fields_derivers_json.To_yojson.skip obj in\n let _d = Fields_derivers_graphql.Graphql_query.skip obj in\n let _e = Fields_derivers_js.Js_layout.skip obj in\n Fields_derivers_json.Of_yojson.skip obj\n\n let js_only (js_layout : _ Fields_derivers_js.Js_layout.Input.t -> 'a) obj :\n _ Unified_input.t =\n let _a = Graphql.Fields.skip obj in\n let _b = Graphql.Args.skip obj in\n let _c = Fields_derivers_json.To_yojson.skip obj in\n let _d = Fields_derivers_graphql.Graphql_query.skip obj in\n let _e = js_layout obj in\n Fields_derivers_json.Of_yojson.skip obj\n\n let js_leaf leaf obj =\n js_only Fields_derivers_js.Js_layout.(of_layout @@ leaf_type leaf) obj\n\n let js_record entries obj =\n js_only (Fields_derivers_js.Js_layout.record entries) obj\n\n let int obj : _ Unified_input.t =\n let _a = Graphql.Fields.int obj in\n let _b = Graphql.Args.int obj in\n let _c = Fields_derivers_json.To_yojson.int obj in\n let _d = Fields_derivers_graphql.Graphql_query.int obj in\n let _e = Fields_derivers_js.Js_layout.int obj in\n Fields_derivers_json.Of_yojson.int obj\n\n let string obj : _ Unified_input.t =\n let _a = Graphql.Fields.string obj in\n let _b = Graphql.Args.string obj in\n let _c = Fields_derivers_json.To_yojson.string obj in\n let _d = Fields_derivers_graphql.Graphql_query.string obj in\n let _e = Fields_derivers_js.Js_layout.string obj in\n Fields_derivers_json.Of_yojson.string obj\n\n let bool obj : _ Unified_input.t =\n let _a = Graphql.Fields.bool obj in\n let _b = Graphql.Args.bool obj in\n let _c = Fields_derivers_json.To_yojson.bool obj in\n let _d = Fields_derivers_graphql.Graphql_query.bool obj in\n let _e = Fields_derivers_js.Js_layout.bool obj in\n Fields_derivers_json.Of_yojson.bool obj\n\n let global_slot_since_genesis obj =\n iso_string obj ~name:\"GlobalSlotSinceGenesis\" ~js_type:UInt32\n ~to_string:Mina_numbers.Global_slot_since_genesis.to_string\n ~of_string:\n (except ~f:Mina_numbers.Global_slot_since_genesis.of_string `Uint)\n\n let global_slot_since_hard_fork obj =\n iso_string obj ~name:\"GlobalSlotSinceHardFork\" ~js_type:UInt32\n ~to_string:Mina_numbers.Global_slot_since_hard_fork.to_string\n ~of_string:\n (except ~f:Mina_numbers.Global_slot_since_hard_fork.of_string `Uint)\n\n let global_slot_span obj =\n iso_string obj ~name:\"GlobalSlotSpan\" ~js_type:UInt32\n ~to_string:Mina_numbers.Global_slot_span.to_string\n ~of_string:(except ~f:Mina_numbers.Global_slot_span.of_string `Uint)\n\n let amount obj =\n iso_string obj ~name:\"CurrencyAmount\" ~js_type:UInt64\n ~to_string:Currency.Amount.to_string\n ~of_string:(except ~f:Currency.Amount.of_string `Amount)\n\n let balance obj =\n iso_string obj ~name:\"Balance\" ~js_type:UInt64\n ~to_string:Currency.Balance.to_string\n ~of_string:(except ~f:Currency.Balance.of_string `Balance)\n\n let option (x : _ Unified_input.t) ~js_type obj : _ Unified_input.t =\n let _a = Graphql.Fields.option x obj in\n let _b = Graphql.Args.option x obj in\n let _c = Fields_derivers_json.To_yojson.option x obj in\n let _d = Fields_derivers_graphql.Graphql_query.option x obj in\n let _e = Fields_derivers_js.Js_layout.option ~js_type x obj in\n Fields_derivers_json.Of_yojson.option x obj\n\n let list ?(static_length : int option) (x : _ Unified_input.t) obj :\n _ Unified_input.t =\n let _a = Graphql.Fields.list x obj in\n let _b = Graphql.Args.list x obj in\n let _c = Fields_derivers_json.To_yojson.list x obj in\n let _d = Fields_derivers_graphql.Graphql_query.list x obj in\n let _e = Fields_derivers_js.Js_layout.list ?static_length x obj in\n Fields_derivers_json.Of_yojson.list x obj\n\n let iso ~map ~contramap (x : _ Unified_input.t) obj : _ Unified_input.t =\n let _a = Graphql.Fields.contramap ~f:contramap x obj in\n let _b = Graphql.Args.map ~f:map x obj in\n let _c = Fields_derivers_json.To_yojson.contramap ~f:contramap x obj in\n let _d = Fields_derivers_graphql.Graphql_query.wrapped x obj in\n let _e = Fields_derivers_js.Js_layout.wrapped x obj in\n Fields_derivers_json.Of_yojson.map ~f:map x obj\n\n let iso_record ~of_record ~to_record record_deriver obj =\n iso ~map:of_record ~contramap:to_record (record_deriver @@ o ()) obj\n\n let array inner obj : _ Unified_input.t =\n iso ~map:Array.of_list ~contramap:Array.to_list\n ((list @@ inner @@ o ()) (o ()))\n obj\n\n let add_field ?skip_data ~t_fields_annots (x : _ Unified_input.t) fd acc =\n let _, acc' = Graphql.Fields.add_field ~t_fields_annots x fd acc in\n let c1, acc'' =\n Graphql.Args.add_field ?skip_data ~t_fields_annots x fd acc'\n in\n let _, acc''' =\n Fields_derivers_json.To_yojson.add_field ~t_fields_annots x fd acc''\n in\n let c2, acc'''' =\n Fields_derivers_json.Of_yojson.add_field ?skip_data ~t_fields_annots x fd\n acc'''\n in\n let _, acc''''' =\n Fields_derivers_graphql.Graphql_query.add_field ~t_fields_annots x fd\n acc''''\n in\n let _, acc'''''' =\n Fields_derivers_js.Js_layout.add_field ~t_fields_annots x fd acc'''''\n in\n ((function `Left x -> c1 x | `Right x -> c2 x), acc'''''')\n\n let ( !. ) ?skip_data x fd acc = add_field ?skip_data (x @@ o ()) fd acc\n\n let finish name ~t_toplevel_annots (f, acc) =\n let _a =\n Graphql.Fields.finish name ~t_toplevel_annots ((fun x -> f (`Left x)), acc)\n in\n let _b =\n Graphql.Args.finish name ~t_toplevel_annots ((fun x -> f (`Left x)), acc)\n in\n let _c =\n Fields_derivers_json.To_yojson.finish ((fun x -> f (`Right x)), acc)\n in\n let _d =\n Fields_derivers_graphql.Graphql_query.finish ((fun x -> f (`Left x)), acc)\n in\n let _e =\n Fields_derivers_js.Js_layout.finish name ~t_toplevel_annots\n ((fun x -> f (`Left x)), acc)\n in\n Fields_derivers_json.Of_yojson.finish ((fun x -> f (`Right x)), acc)\n\n let needs_custom_js ~js_type ~name deriver obj =\n Fields_derivers_js.Js_layout.needs_custom_js ~name\n (js_type @@ o ())\n (deriver obj)\n\n let balance_change obj =\n let sign_to_string = function\n | Sgn.Pos ->\n \"Positive\"\n | Sgn.Neg ->\n \"Negative\"\n in\n let sign_of_string = function\n | \"Positive\" ->\n Sgn.Pos\n | \"Negative\" ->\n Sgn.Neg\n | _ ->\n failwith \"impossible\"\n in\n let sign_deriver =\n iso_string ~name:\"Sign\" ~js_type:Sign ~to_string:sign_to_string\n ~of_string:sign_of_string\n in\n let ( !. ) = ( !. ) ~t_fields_annots:Currency.Signed_poly.t_fields_annots in\n Currency.Signed_poly.Fields.make_creator obj ~magnitude:!.amount\n ~sgn:!.sign_deriver\n |> finish \"BalanceChange\"\n ~t_toplevel_annots:Currency.Signed_poly.t_toplevel_annots\n\n let to_json obj x = !(obj#to_json) @@ !(obj#contramap) x\n\n let of_json obj x = !(obj#map) @@ !(obj#of_json) x\n\n let js_layout deriver = !((deriver @@ o ())#js_layout)\n\n let typ obj = !(obj#graphql_fields).Graphql.Fields.Input.T.run ()\n\n let arg_typ obj = !(obj#graphql_arg) ()\n\n let inner_query obj = Fields_derivers_graphql.Graphql_query.inner_query obj\n\n let rec json_to_safe : Yojson.Basic.t -> Yojson.Safe.t = function\n | `Assoc kv ->\n `Assoc (List.map kv ~f:(fun (k, v) -> (k, json_to_safe v)))\n | `Bool b ->\n `Bool b\n | `Float f ->\n `Float f\n | `Int i ->\n `Int i\n | `List xs ->\n `List (List.map xs ~f:json_to_safe)\n | `Null ->\n `Null\n | `String s ->\n `String s\n\n (* TODO: remove this or move to a %test_module once the deriver code is stable *)\n (* Can be used to print the graphql schema, like this:\n Fields_derivers_zkapps.Test.print_schema full ;\n *)\n module Test = struct\n module M = struct\n let ( let* ) = Schema.Io.bind\n\n let return = Schema.Io.return\n end\n\n let print_schema (full : _ Unified_input.t) =\n let typ = !(full#graphql_fields).run () in\n let query_top_level =\n Schema.(\n field \"query\" ~typ:(non_null typ)\n ~args:Arg.[]\n ~doc:\"sample query\"\n ~resolve:(fun _ _ -> ()))\n in\n let schema =\n Schema.(schema [ query_top_level ] ~mutations:[] ~subscriptions:[])\n in\n let res : 'a Schema.Io.t =\n Schema.execute schema ()\n (Fields_derivers_graphql.Test.introspection_query ())\n in\n let open Schema.Io in\n bind res (function\n | Ok (`Response data) ->\n data |> Yojson.Basic.to_string |> printf \"%s\" |> return\n | _ ->\n failwith \"Unexpected response\" )\n\n module Loop = struct\n let rec json_to_string_gql : Yojson.Safe.t -> string = function\n | `Assoc kv ->\n sprintf \"{\\n%s\\n}\"\n ( List.map kv ~f:(fun (k, v) ->\n sprintf \"%s: %s\"\n (Fields_derivers.under_to_camel k)\n (json_to_string_gql v) )\n |> String.concat ~sep:\",\\n\" )\n | `List xs ->\n sprintf \"[\\n%s\\n]\"\n (List.map xs ~f:json_to_string_gql |> String.concat ~sep:\",\\n\")\n | x ->\n Yojson.Safe.to_string x\n\n let arg_query json =\n Printf.sprintf\n {graphql|query LoopIn {\n arg(\n input : %s\n )\n }|graphql}\n (json_to_string_gql json)\n\n let out_query keys =\n Printf.sprintf\n {graphql|\n query LoopOut {\n out %s\n }\n |graphql}\n keys\n\n let run deriver (a : 'a) =\n let schema =\n let in_schema : ('a option ref, unit) Schema.field =\n Schema.(\n field \"arg\" ~typ:(non_null int)\n ~args:Arg.[ arg \"input\" ~typ:(arg_typ deriver) ]\n ~doc:\"sample args query\"\n ~resolve:(fun { ctx; _ } () (input : 'a) ->\n ctx := Some input ;\n 0 ))\n in\n let out_schema : ('a option ref, unit) Schema.field =\n Schema.(\n field \"out\" ~typ:(typ deriver)\n ~args:Arg.[]\n ~doc:\"sample query\"\n ~resolve:(fun { ctx; _ } () -> Option.value_exn !ctx))\n in\n Schema.(\n schema [ in_schema; out_schema ] ~mutations:[] ~subscriptions:[])\n in\n let ctx = ref None in\n let open M in\n let run_query q =\n let x = Graphql_parser.parse q in\n match x with\n | Ok res ->\n Schema.execute schema ctx res\n | Error err ->\n failwithf \"Failed to parse query: %s %s\" q err ()\n in\n (* send json in *)\n let* () =\n let json = to_json deriver a in\n let q = arg_query json in\n let* res = run_query q in\n match res with\n | Ok (`Response _) ->\n return @@ ()\n | Error e ->\n failwithf \"Unexpected response in: %s\"\n (e |> Yojson.Basic.to_string)\n ()\n | _ ->\n failwith \"Unexpected stream in\"\n in\n (* get query *)\n let inner_query =\n Option.value_exn\n (Fields_derivers_graphql.Graphql_query.inner_query deriver)\n in\n (* read json out *)\n let* a' =\n let* res = run_query (out_query inner_query) in\n match res with\n | Ok (`Response json) ->\n let unwrap k json =\n match json with\n | `Assoc kv ->\n List.Assoc.find_exn kv ~equal:String.equal k\n | _ ->\n failwithf \"Expected wrapping %s\" k ()\n in\n let inner = json |> unwrap \"data\" |> unwrap \"out\" in\n of_json deriver (json_to_safe inner) |> return\n | Error e ->\n failwithf \"Unexpected response out: %s\"\n (e |> Yojson.Basic.to_string)\n ()\n | _ ->\n failwith \"Unexpected stream out\"\n in\n [%test_eq: string]\n (Yojson.Safe.to_string (to_json deriver a))\n (Yojson.Safe.to_string (to_json deriver a')) ;\n return ()\n end\n end\nend\n\nmodule Derivers = Make (Fields_derivers_graphql.Schema)\ninclude Derivers\nmodule Js_layout = Fields_derivers_js.Js_layout\n\n[%%ifdef consensus_mechanism]\n\nlet proof obj : _ Unified_input.t =\n let of_string s =\n match Pickles.Side_loaded.Proof.of_base64 s with\n | Ok proof ->\n proof\n | Error _err ->\n raise_invalid_scalar `Proof s\n in\n iso_string obj ~name:\"ZkappProof\" ~js_type:String\n ~to_string:Pickles.Side_loaded.Proof.to_base64 ~of_string\n\nlet verification_key_with_hash obj =\n let verification_key obj =\n let of_string s =\n match Pickles.Side_loaded.Verification_key.of_base64 s with\n | Ok vk ->\n vk\n | Error _err ->\n raise_invalid_scalar `Verification_key s\n in\n Pickles.Side_loaded.Verification_key.(\n iso_string obj ~name:\"VerificationKey\" ~js_type:String\n ~to_string:to_base64 ~of_string ~doc:\"Verification key in Base64 format\")\n in\n let ( !. ) =\n ( !. ) ~t_fields_annots:With_hash.Stable.Latest.t_fields_annots\n in\n With_hash.Stable.Latest.Fields.make_creator ~data:!.verification_key\n ~hash:!.field obj\n |> finish \"VerificationKeyWithHash\"\n ~t_toplevel_annots:With_hash.Stable.Latest.t_toplevel_annots\n\nlet%test_unit \"verification key with hash, roundtrip json\" =\n let open Pickles.Side_loaded.Verification_key in\n (* we do this because the dummy doesn't have a wrap_vk on it *)\n let data = dummy |> to_base58_check |> of_base58_check_exn in\n let v = { With_hash.data; hash = Field.one } in\n let o = verification_key_with_hash @@ o () in\n [%test_eq: (t, Field.t) With_hash.t] v (of_json o (to_json o v))\n\n[%%endif]\n\nlet%test_module \"Test\" =\n ( module struct\n module IO = struct\n type +'a t = 'a\n\n let bind t f = f t\n\n let return t = t\n\n module Stream = struct\n type 'a t = 'a Seq.t\n\n let map t f = Seq.map f t\n\n let iter t f = Seq.iter f t\n\n let close _t = ()\n end\n end\n\n module Field_error = struct\n type t = string\n\n let message_of_field_error t = t\n\n let extensions_of_field_error _t = None\n end\n\n module Schema = Graphql_schema.Make (IO) (Field_error)\n module Derivers = Make (Schema)\n include Derivers\n module Public_key = Signature_lib.Public_key.Compressed\n\n module Or_ignore_test = struct\n type 'a t = Check of 'a | Ignore [@@deriving compare, sexp, equal]\n\n let of_option = function None -> Ignore | Some x -> Check x\n\n let to_option = function Ignore -> None | Check x -> Some x\n\n let to_yojson a x = [%to_yojson: 'a option] a (to_option x)\n\n let of_yojson a x = Result.map ~f:of_option ([%of_yojson: 'a option] a x)\n\n let derived inner init =\n iso ~map:of_option ~contramap:to_option\n ((option ~js_type:Flagged_option @@ inner @@ o ()) (o ()))\n init\n end\n\n module V = struct\n type t =\n { foo : int\n ; foo1 : Unsigned_extended.UInt64.t\n ; bar : Unsigned_extended.UInt64.t Or_ignore_test.t\n ; baz : Unsigned_extended.UInt32.t list\n }\n [@@deriving annot, compare, sexp, equal, fields, yojson]\n\n let v =\n { foo = 1\n ; foo1 = Unsigned.UInt64.of_int 10\n ; bar = Or_ignore_test.Check (Unsigned.UInt64.of_int 10)\n ; baz = Unsigned.UInt32.[ of_int 11; of_int 12 ]\n }\n\n let ( !. ) = ( !. ) ~t_fields_annots\n\n let derivers obj =\n Fields.make_creator obj ~foo:!.int ~foo1:!.uint64\n ~bar:!.(Or_ignore_test.derived uint64)\n ~baz:!.(list @@ uint32 @@ o ())\n |> finish \"V\" ~t_toplevel_annots\n end\n\n let v1 = V.derivers @@ o ()\n\n let%test_unit \"full roundtrips\" = Test.Loop.run v1 V.v\n\n module V2 = struct\n type t = { field : Field.t; nothing : unit [@skip] }\n [@@deriving annot, compare, sexp, equal, fields]\n\n let v = { field = Field.of_int 10; nothing = () }\n\n let derivers obj =\n let open Derivers in\n let ( !. ) ?skip_data = ( !. ) ?skip_data ~t_fields_annots in\n Fields.make_creator obj ~field:!.field\n ~nothing:(( !. ) ~skip_data:() skip)\n |> finish \"V2\" ~t_toplevel_annots\n end\n\n let v2 = V2.derivers @@ Derivers.o ()\n\n let%test_unit \"to_json'\" =\n let open Derivers in\n [%test_eq: string]\n (Yojson.Safe.to_string (to_json v2 V2.v))\n {|{\"field\":\"10\"}|}\n\n let%test_unit \"roundtrip json'\" =\n let open Derivers in\n [%test_eq: V2.t] (of_json v2 (to_json v2 V2.v)) V2.v\n\n module V3 = struct\n type t = { public_key : Public_key.t }\n [@@deriving annot, compare, sexp, equal, fields]\n\n let v =\n { public_key =\n Public_key.of_base58_check_exn\n \"B62qoTqMG41DFgkyQmY2Pos1x671Gfzs9k8NKqUdSg7wQasEV6qnXQP\"\n }\n\n let derivers obj =\n let open Derivers in\n let ( !. ) = ( !. ) ~t_fields_annots in\n Fields.make_creator obj ~public_key:!.public_key\n |> finish \"V3\" ~t_toplevel_annots\n end\n\n let v3 = V3.derivers @@ Derivers.o ()\n\n let%test_unit \"to_json'\" =\n let open Derivers in\n [%test_eq: string]\n (Yojson.Safe.to_string (to_json v3 V3.v))\n {|{\"publicKey\":\"B62qoTqMG41DFgkyQmY2Pos1x671Gfzs9k8NKqUdSg7wQasEV6qnXQP\"}|}\n\n let%test_unit \"roundtrip json'\" =\n let open Derivers in\n [%test_eq: V3.t] (of_json v3 (to_json v3 V3.v)) V3.v\n end )\n","(* state_hash.ml -- defines the type for the protocol state hash *)\n\n[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Snark_params.Tick\n\ninclude Data_hash.Make_full_size (struct\n let version_byte = Base58_check.Version_bytes.state_hash\n\n let description = \"State hash\"\nend)\n\nlet dummy = of_hash Outside_hash_image.t\n\n[%%ifdef consensus_mechanism]\n\nlet zero = dummy\n\n[%%else]\n\n(* in the nonconsensus world, we don't have the Pedersen machinery available,\n so just inline the value for zero\n*)\nlet zero = Field.of_string \"0\"\n\n[%%endif]\n\nlet raw_hash_bytes = to_bytes\n\nlet to_bytes = `Use_to_base58_check_or_raw_hash_bytes\n\nlet to_decimal_string = to_decimal_string\n\nlet of_decimal_string = of_decimal_string\n\n(* Data hash versioned boilerplate below *)\n\n[%%versioned\nmodule Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n module T = struct\n type t = (Field.t[@version_asserted]) [@@deriving sexp, compare, hash]\n end\n\n include T\n\n let to_latest = Fn.id\n\n [%%define_from_scope to_yojson, of_yojson]\n\n include Comparable.Make (T)\n include Hashable.Make_binable (T)\n end\nend]\n\nlet (_ : (t, Stable.Latest.t) Type_equal.t) = Type_equal.T\n\nlet deriver obj =\n Fields_derivers_zkapps.(\n iso_string ~name:\"StateHash\" ~js_type:Field ~to_string:to_base58_check\n ~of_string:of_base58_check_exn\n |> needs_custom_js ~name:\"StateHash\" ~js_type:field)\n obj\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\n\nmodule Proof_level = struct\n type t = Full | Check | None [@@deriving bin_io_unversioned, equal]\n\n let to_string = function Full -> \"full\" | Check -> \"check\" | None -> \"none\"\n\n let of_string = function\n | \"full\" ->\n Full\n | \"check\" ->\n Check\n | \"none\" ->\n None\n | s ->\n failwithf \"unrecognised proof level %s\" s ()\n\n [%%inject \"compiled\", proof_level]\n\n let compiled = of_string compiled\n\n let for_unit_tests = Check\nend\n\nmodule Fork_constants = struct\n type t =\n { previous_state_hash : Pickles.Backend.Tick.Field.Stable.Latest.t\n ; previous_length : Mina_numbers.Length.Stable.Latest.t\n ; previous_global_slot :\n Mina_numbers.Global_slot_since_genesis.Stable.Latest.t\n }\n [@@deriving bin_io_unversioned, sexp, equal, compare, yojson]\nend\n\n(** Constants that affect the constraint systems for proofs (and thus also key\n generation).\n\n Care must be taken to ensure that these match against the proving/\n verification keys when [proof_level=Full], otherwise generated proofs will\n be invalid.\n*)\nmodule Constraint_constants = struct\n type t =\n { sub_windows_per_window : int\n ; ledger_depth : int\n ; work_delay : int\n ; block_window_duration_ms : int\n ; transaction_capacity_log_2 : int\n ; pending_coinbase_depth : int\n ; coinbase_amount : Currency.Amount.Stable.Latest.t\n ; supercharged_coinbase_factor : int\n ; account_creation_fee : Currency.Fee.Stable.Latest.t\n ; fork : Fork_constants.t option\n }\n [@@deriving bin_io_unversioned, sexp, equal, compare, yojson]\n\n let to_snark_keys_header (t : t) : Snark_keys_header.Constraint_constants.t =\n { sub_windows_per_window = t.sub_windows_per_window\n ; ledger_depth = t.ledger_depth\n ; work_delay = t.work_delay\n ; block_window_duration_ms = t.block_window_duration_ms\n ; transaction_capacity = Log_2 t.transaction_capacity_log_2\n ; pending_coinbase_depth = t.pending_coinbase_depth\n ; coinbase_amount = Currency.Amount.to_uint64 t.coinbase_amount\n ; supercharged_coinbase_factor = t.supercharged_coinbase_factor\n ; account_creation_fee = Currency.Fee.to_uint64 t.account_creation_fee\n ; fork =\n ( match t.fork with\n | Some { previous_length; previous_state_hash; previous_global_slot } ->\n Some\n { previous_length = Unsigned.UInt32.to_int previous_length\n ; previous_state_hash =\n Pickles.Backend.Tick.Field.to_string previous_state_hash\n ; previous_global_slot =\n Unsigned.UInt32.to_int\n (Mina_numbers.Global_slot_since_genesis.to_uint32\n previous_global_slot )\n }\n | None ->\n None )\n }\n\n (* Generate the compile-time constraint constants, using a signature to hide\n the optcomp constants that we import.\n *)\n include (\n struct\n [%%ifdef consensus_mechanism]\n\n [%%inject \"sub_windows_per_window\", sub_windows_per_window]\n\n [%%else]\n\n (* Invalid value, this should not be used by nonconsensus nodes. *)\n let sub_windows_per_window = -1\n\n [%%endif]\n\n [%%inject \"ledger_depth\", ledger_depth]\n\n [%%inject \"coinbase_amount_string\", coinbase]\n\n [%%inject \"account_creation_fee_string\", account_creation_fee_int]\n\n (** All the proofs before the last [work_delay] blocks must be\n completed to add transactions. [work_delay] is the minimum number\n of blocks and will increase if the throughput is less.\n - If [work_delay = 0], all the work that was added to the scan\n state in the previous block is expected to be completed and\n included in the current block if any transactions/coinbase are to\n be included.\n - [work_delay >= 1] means that there's at least two block times for\n completing the proofs.\n *)\n\n [%%inject \"work_delay\", scan_state_work_delay]\n\n [%%inject \"block_window_duration_ms\", block_window_duration]\n\n [%%if scan_state_with_tps_goal]\n\n [%%inject \"tps_goal_x10\", scan_state_tps_goal_x10]\n\n let max_coinbases = 2\n\n (* block_window_duration is in milliseconds, so divide by 1000 divide\n by 10 again because we have tps * 10\n *)\n let max_user_commands_per_block =\n tps_goal_x10 * block_window_duration_ms / (1000 * 10)\n\n (** Log of the capacity of transactions per transition.\n - 1 will only work if we don't have prover fees.\n - 2 will work with prover fees, but not if we want a transaction\n included in every block.\n - At least 3 ensures a transaction per block and the staged-ledger\n unit tests pass.\n *)\n let transaction_capacity_log_2 =\n 1\n + Core_kernel.Int.ceil_log2 (max_user_commands_per_block + max_coinbases)\n\n [%%else]\n\n [%%inject\n \"transaction_capacity_log_2\", scan_state_transaction_capacity_log_2]\n\n [%%endif]\n\n [%%inject \"supercharged_coinbase_factor\", supercharged_coinbase_factor]\n\n let pending_coinbase_depth =\n Core_kernel.Int.ceil_log2\n (((transaction_capacity_log_2 + 1) * (work_delay + 1)) + 1)\n\n [%%ifndef fork_previous_length]\n\n let fork = None\n\n [%%else]\n\n [%%inject \"fork_previous_length\", fork_previous_length]\n\n [%%inject \"fork_previous_state_hash\", fork_previous_state_hash]\n\n [%%inject \"fork_previous_global_slot\", fork_previous_global_slot]\n\n let fork =\n Some\n { Fork_constants.previous_length =\n Mina_numbers.Length.of_int fork_previous_length\n ; previous_state_hash =\n Data_hash_lib.State_hash.of_base58_check_exn\n fork_previous_state_hash\n ; previous_global_slot =\n Mina_numbers.Global_slot_since_genesis.of_int\n fork_previous_global_slot\n }\n\n [%%endif]\n\n let compiled =\n { sub_windows_per_window\n ; ledger_depth\n ; work_delay\n ; block_window_duration_ms\n ; transaction_capacity_log_2\n ; pending_coinbase_depth\n ; coinbase_amount =\n Currency.Amount.of_mina_string_exn coinbase_amount_string\n ; supercharged_coinbase_factor\n ; account_creation_fee =\n Currency.Fee.of_mina_string_exn account_creation_fee_string\n ; fork\n }\n end :\n sig\n val compiled : t\n end )\n\n let for_unit_tests = compiled\nend\n\n(*Constants that can be specified for generating the base proof (that are not required for key-generation) in runtime_genesis_ledger.exe and that can be configured at runtime.\n The types are defined such that this module doesn't depend on any of the coda libraries (except blake2 and module_version) to avoid dependency cycles.\n TODO: #4659 move key generation to runtime_genesis_ledger.exe to include scan_state constants, consensus constants (c and block_window_duration) and ledger depth here*)\n\nlet genesis_timestamp_of_string str =\n let default_zone = Time.Zone.of_utc_offset ~hours:(-8) in\n Time.of_string_gen\n ~find_zone:(fun _ -> assert false)\n ~default_zone:(fun () -> default_zone)\n str\n\nlet of_time t = Time.to_span_since_epoch t |> Time.Span.to_ms |> Int64.of_float\n\nlet validate_time time_str =\n match\n Result.try_with (fun () ->\n Option.value_map ~default:(Time.now ()) ~f:genesis_timestamp_of_string\n time_str )\n with\n | Ok time ->\n Ok (of_time time)\n | Error _ ->\n Error\n \"Invalid timestamp. Please specify timestamp in \\\"%Y-%m-%d \\\n %H:%M:%S%z\\\". For example, \\\"2019-01-30 12:00:00-0800\\\" for UTC-08:00 \\\n timezone\"\n\nlet genesis_timestamp_to_string time =\n Int64.to_float time |> Time.Span.of_ms |> Time.of_span_since_epoch\n |> Time.to_string_iso8601_basic ~zone:(Time.Zone.of_utc_offset ~hours:(-8))\n\n(*Protocol constants required for consensus and snarks. Consensus constants is generated using these*)\nmodule Protocol = struct\n module Poly = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type ('length, 'delta, 'genesis_state_timestamp) t =\n ( 'length\n , 'delta\n , 'genesis_state_timestamp )\n Mina_wire_types.Genesis_constants.Protocol.Poly.V1.t =\n { k : 'length\n ; slots_per_epoch : 'length\n ; slots_per_sub_window : 'length\n ; delta : 'delta\n ; genesis_state_timestamp : 'genesis_state_timestamp\n }\n [@@deriving equal, ord, hash, sexp, yojson, hlist, fields]\n end\n end]\n end\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = (int, int, (Int64.t[@version_asserted])) Poly.Stable.V1.t\n [@@deriving equal, ord, hash]\n\n let to_latest = Fn.id\n\n let to_yojson (t : t) =\n `Assoc\n [ (\"k\", `Int t.k)\n ; (\"slots_per_epoch\", `Int t.slots_per_epoch)\n ; (\"slots_per_sub_window\", `Int t.slots_per_sub_window)\n ; (\"delta\", `Int t.delta)\n ; ( \"genesis_state_timestamp\"\n , `String\n (Time.to_string_abs\n (Time.of_span_since_epoch\n (Time.Span.of_ms\n (Int64.to_float t.genesis_state_timestamp) ) )\n ~zone:Time.Zone.utc ) )\n ]\n\n let of_yojson = function\n | `Assoc\n [ (\"k\", `Int k)\n ; (\"slots_per_epoch\", `Int slots_per_epoch)\n ; (\"slots_per_sub_window\", `Int slots_per_sub_window)\n ; (\"delta\", `Int delta)\n ; (\"genesis_state_timestamp\", `String time_str)\n ] -> (\n match validate_time time_str with\n | Ok genesis_state_timestamp ->\n Ok\n { Poly.k\n ; slots_per_epoch\n ; slots_per_sub_window\n ; delta\n ; genesis_state_timestamp\n }\n | Error e ->\n Error (sprintf !\"Genesis_constants.Protocol.of_yojson: %s\" e) )\n | _ ->\n Error \"Genesis_constants.Protocol.of_yojson: unexpected JSON\"\n\n let t_of_sexp _ = failwith \"t_of_sexp: not implemented\"\n\n let sexp_of_t (t : t) =\n let module T = struct\n type t = (int, int, string) Poly.Stable.V1.t [@@deriving sexp]\n end in\n let t' : T.t =\n { k = t.k\n ; delta = t.delta\n ; slots_per_epoch = t.slots_per_epoch\n ; slots_per_sub_window = t.slots_per_sub_window\n ; genesis_state_timestamp =\n Time.to_string_abs\n (Time.of_span_since_epoch\n (Time.Span.of_ms (Int64.to_float t.genesis_state_timestamp)) )\n ~zone:Time.Zone.utc\n }\n in\n T.sexp_of_t t'\n end\n end]\n\n [%%define_locally Stable.Latest.(to_yojson)]\nend\n\nmodule T = struct\n (* bin_io is for printing chain id inputs *)\n type t =\n { protocol : Protocol.Stable.Latest.t\n ; txpool_max_size : int\n ; num_accounts : int option\n ; zkapp_proof_update_cost : float\n ; zkapp_signed_single_update_cost : float\n ; zkapp_signed_pair_update_cost : float\n ; zkapp_transaction_cost_limit : float\n ; max_event_elements : int\n ; max_action_elements : int\n }\n [@@deriving to_yojson, sexp_of, bin_io_unversioned]\n\n let hash (t : t) =\n let str =\n ( List.map\n (* TODO: *)\n [ t.protocol.k\n ; t.protocol.slots_per_epoch\n ; t.protocol.slots_per_sub_window\n ; t.protocol.delta\n ; t.txpool_max_size\n ]\n ~f:Int.to_string\n |> String.concat ~sep:\"\" )\n ^ Time.to_string_abs ~zone:Time.Zone.utc\n (Time.of_span_since_epoch\n (Time.Span.of_ms\n (Int64.to_float t.protocol.genesis_state_timestamp) ) )\n in\n Blake2.digest_string str |> Blake2.to_hex\nend\n\ninclude T\n\n[%%inject \"genesis_state_timestamp_string\", genesis_state_timestamp]\n\n[%%inject \"k\", k]\n\n[%%inject \"slots_per_epoch\", slots_per_epoch]\n\n[%%inject \"slots_per_sub_window\", slots_per_sub_window]\n\n[%%inject \"delta\", delta]\n\n[%%inject \"pool_max_size\", pool_max_size]\n\nlet compiled : t =\n { protocol =\n { k\n ; slots_per_epoch\n ; slots_per_sub_window\n ; delta\n ; genesis_state_timestamp =\n genesis_timestamp_of_string genesis_state_timestamp_string |> of_time\n }\n ; txpool_max_size = pool_max_size\n ; num_accounts = None\n ; zkapp_proof_update_cost = Mina_compile_config.zkapp_proof_update_cost\n ; zkapp_signed_single_update_cost =\n Mina_compile_config.zkapp_signed_single_update_cost\n ; zkapp_signed_pair_update_cost =\n Mina_compile_config.zkapp_signed_pair_update_cost\n ; zkapp_transaction_cost_limit =\n Mina_compile_config.zkapp_transaction_cost_limit\n ; max_event_elements = Mina_compile_config.max_event_elements\n ; max_action_elements = Mina_compile_config.max_action_elements\n }\n\nlet for_unit_tests = compiled\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Snark_params\nopen Tick\nopen Unsigned_extended\nopen Snark_bits\n\n(** See documentation of the {!Mina_wire_types} library *)\nmodule Wire_types = Mina_wire_types.Block_time\n\nmodule Make_sig (A : Wire_types.Types.S) = struct\n module type S = Intf.S with type Time.t = A.V1.t\nend\n\nmodule Make_str (_ : Wire_types.Concrete) = struct\n module Time = struct\n (* Milliseconds since epoch *)\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = UInt64.Stable.V1.t\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n\n module T = struct\n type typ = t [@@deriving sexp, compare, hash]\n\n type t = typ [@@deriving sexp, compare, hash]\n end\n\n include Hashable.Make (T)\n end\n end]\n\n let max_value = UInt64.max_int\n\n let zero = UInt64.zero\n\n module Controller = struct\n [%%if time_offsets]\n\n type t = unit -> Time.Span.t [@@deriving sexp]\n\n (* NB: All instances are identical by construction (see basic below). *)\n let equal _ _ = true\n\n (* NB: All instances are identical by construction (see basic below). *)\n let compare _ _ = 0\n\n let time_offset = ref None\n\n let setting_enabled = ref None\n\n let disable_setting_offset () = setting_enabled := Some false\n\n let enable_setting_offset () =\n match !setting_enabled with\n | None ->\n setting_enabled := Some true\n | Some true ->\n ()\n | Some false ->\n failwith\n \"Cannot enable time offset mutations; it has been explicitly \\\n disabled\"\n\n let set_time_offset offset =\n match !setting_enabled with\n | Some true ->\n time_offset := Some offset\n | None | Some false ->\n failwith \"Cannot mutate the time offset\"\n\n let create offset = offset\n\n let basic ~logger:_ () =\n match !time_offset with\n | Some offset ->\n offset\n | None ->\n let offset =\n let env = \"MINA_TIME_OFFSET\" in\n let env_offset =\n match Core_kernel.Sys.getenv_opt env with\n | Some tm ->\n Int.of_string tm\n | None ->\n let default = 0 in\n eprintf\n \"Environment variable %s not found, using default of %d\\n\\\n %!\"\n env default ;\n default\n in\n Core_kernel.Time.Span.of_int_sec env_offset\n in\n time_offset := Some offset ;\n offset\n\n let get_time_offset ~logger = basic ~logger ()\n\n [%%else]\n\n type t = unit [@@deriving sexp, equal, compare]\n\n let create () = ()\n\n let basic ~logger:_ = ()\n\n let disable_setting_offset () = ()\n\n let enable_setting_offset () = ()\n\n let set_time_offset _ = failwith \"Cannot mutate the time offset\"\n\n let get_time_offset _ = Core_kernel.Time.Span.of_int_sec 0\n\n [%%endif]\n end\n\n module B = Bits\n module Bits = Bits.UInt64\n include B.Snarkable.UInt64 (Tick)\n module N = Mina_numbers.Nat.Make_checked (UInt64) (Bits)\n\n let to_input (t : t) =\n Random_oracle_input.Chunked.packed\n (Tick.Field.project (Bits.to_bits t), 64)\n\n module Checked = struct\n type t = N.var\n\n module Unsafe = N.Unsafe\n\n let to_input (t : t) = N.to_input t\n\n let to_field = N.to_field\n\n [%%define_locally N.(typ, ( = ), ( <= ), ( >= ), ( < ), ( > ))]\n end\n\n module Span = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = UInt64.Stable.V1.t\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n module Bits = B.UInt64\n include B.Snarkable.UInt64 (Tick)\n\n let of_time_span s = UInt64.of_int64 (Int64.of_float (Time.Span.to_ms s))\n\n let to_time_span s = Time.Span.of_ms (Int64.to_float (UInt64.to_int64 s))\n\n let to_time_ns_span s =\n Time_ns.Span.of_ms (Int64.to_float (UInt64.to_int64 s))\n\n let of_time_ns_span ns : t =\n let int64_ns = ns |> Time_ns.Span.to_int63_ns |> Int63.to_int64 in\n (* convert to milliseconds *)\n Int64.(int64_ns / 1_000_000L) |> UInt64.of_int64\n\n let to_string_hum s = to_time_ns_span s |> Time_ns.Span.to_string_hum\n\n let to_ms = UInt64.to_int64\n\n let of_ms = UInt64.of_int64\n\n [%%define_locally UInt64.Infix.(( + ), ( - ), ( * ))]\n\n [%%define_locally UInt64.(( < ), ( > ), ( = ), ( <= ), ( >= ), min, zero)]\n\n let to_input = to_input\n\n module Checked = Checked\n end\n\n include Comparable.Make (Stable.Latest)\n include Hashable.Make (Stable.Latest)\n\n let of_time t =\n UInt64.of_int64\n (Int64.of_float (Time.Span.to_ms (Time.to_span_since_epoch t)))\n\n (* TODO: Time.t can't hold the full uint64 range, so this can fail for large t *)\n let to_time_exn t =\n let t_int64 = UInt64.to_int64 t in\n if Int64.(t_int64 < zero) then failwith \"converting to negative timestamp\" ;\n Time.of_span_since_epoch (Time.Span.of_ms (Int64.to_float t_int64))\n\n [%%if time_offsets]\n\n let now offset = of_time (Time.sub (Time.now ()) (offset ()))\n\n [%%else]\n\n let now _ = of_time (Time.now ())\n\n [%%endif]\n\n let field_var_to_unpacked (x : Tick.Field.Var.t) =\n Tick.Field.Checked.unpack ~length:64 x\n\n let epoch = of_time Time.epoch\n\n let add x y = UInt64.add x y\n\n let diff x y = UInt64.sub x y\n\n let sub x y = UInt64.sub x y\n\n let to_span_since_epoch t = diff t epoch\n\n let of_span_since_epoch s = UInt64.add s epoch\n\n let diff_checked x y =\n let pack = Tick.Field.Var.project in\n Span.unpack_var Tick.Field.Checked.(pack x - pack y)\n\n let modulus t span = UInt64.rem t span\n\n let unpacked_to_number var =\n let bits = Span.Unpacked.var_to_bits var in\n Number.of_bits (bits :> Boolean.var list)\n\n let to_int64 = Fn.compose Span.to_ms to_span_since_epoch\n\n let of_int64 = Fn.compose of_span_since_epoch Span.of_ms\n\n let of_uint64 : UInt64.t -> t = of_span_since_epoch\n\n let to_uint64 : t -> UInt64.t = to_span_since_epoch\n\n (* TODO: this can fail if the input has more than 63 bits, because it would be serialized to a negative number string *)\n let to_string_exn t =\n let t_int64 = UInt64.to_int64 t in\n if Int64.(t_int64 < zero) then failwith \"converting to negative timestamp\" ;\n Int64.to_string t_int64\n\n let of_time_ns ns : t =\n let int64_ns = ns |> Time_ns.to_int63_ns_since_epoch |> Int63.to_int64 in\n (* convert to milliseconds *)\n Int64.(int64_ns / 1_000_000L) |> UInt64.of_int64\n\n [%%if time_offsets]\n\n let to_system_time (offset : Controller.t) (t : t) =\n of_span_since_epoch\n Span.(to_span_since_epoch t + of_time_span (offset ()))\n\n [%%else]\n\n let to_system_time (_offset : Controller.t) (t : t) = t\n\n [%%endif]\n\n let to_string_system_time_exn (offset : Controller.t) (t : t) : string =\n to_system_time offset t |> to_string_exn\n\n let of_string_exn string =\n Int64.of_string string |> Span.of_ms |> of_span_since_epoch\n\n let gen_incl time_beginning time_end =\n let open Quickcheck.Let_syntax in\n let time_beginning_int64 = to_int64 time_beginning in\n let time_end_int64 = to_int64 time_end in\n let%map int64_time_span =\n Int64.(gen_incl time_beginning_int64 time_end_int64)\n in\n of_span_since_epoch @@ Span.of_ms int64_time_span\n\n let gen =\n let open Quickcheck.Let_syntax in\n let%map int64_time_span = Int64.(gen_incl zero max_value) in\n of_span_since_epoch @@ Span.of_ms int64_time_span\n end\n\n include Time\n module Timeout = Timeout_lib.Make (Time)\nend\n\ninclude Wire_types.Make (Make_sig) (Make_str)\n","open Core_kernel\nopen Async_kernel\n\n[%%versioned\nmodule Stable = struct\n module V1 = struct\n type 'a t = [ `One of 'a | `Two of 'a * 'a ]\n [@@deriving equal, compare, hash, sexp, yojson]\n\n let to_latest a_latest = function\n | `One x ->\n `One (a_latest x)\n | `Two (x, y) ->\n `Two (a_latest x, a_latest y)\n\n let of_latest a_latest = function\n | `One x ->\n let open Result.Let_syntax in\n let%map x = a_latest x in\n `One x\n | `Two (x, y) ->\n let open Result.Let_syntax in\n let%map x = a_latest x and y = a_latest y in\n `Two (x, y)\n end\nend]\n\nlet length = function `One _ -> 1 | `Two _ -> 2\n\nlet to_list = function `One a -> [ a ] | `Two (a, b) -> [ a; b ]\n\nlet to_numbered_list = function\n | `One a ->\n [ (0, a) ]\n | `Two (a, b) ->\n [ (0, a); (1, b) ]\n\nlet group_sequence : 'a Sequence.t -> 'a t Sequence.t =\n fun to_group ->\n Sequence.unfold ~init:to_group ~f:(fun acc ->\n match Sequence.next acc with\n | None ->\n None\n | Some (a, rest_1) -> (\n match Sequence.next rest_1 with\n | None ->\n Some (`One a, Sequence.empty)\n | Some (b, rest_2) ->\n Some (`Two (a, b), rest_2) ) )\n\nlet group_list : 'a list -> 'a t list =\n fun xs -> xs |> Sequence.of_list |> group_sequence |> Sequence.to_list\n\nlet zip : 'a t -> 'b t -> ('a * 'b) t Or_error.t =\n fun a b ->\n match (a, b) with\n | `One a1, `One b1 ->\n Ok (`One (a1, b1))\n | `Two (a1, a2), `Two (b1, b2) ->\n Ok (`Two ((a1, b1), (a2, b2)))\n | _ ->\n Or_error.error_string \"One_or_two.zip mismatched\"\n\nlet zip_exn : 'a t -> 'b t -> ('a * 'b) t =\n fun a b -> Or_error.ok_exn @@ zip a b\n\nmodule Monadic2 (M : Monad.S2) :\n Intfs.Monadic2 with type ('a, 'e) m := ('a, 'e) M.t = struct\n let sequence : ('a, 'e) M.t t -> ('a t, 'e) M.t = function\n | `One def ->\n M.map def ~f:(fun x -> `One x)\n | `Two (def1, def2) ->\n let open M.Let_syntax in\n let%bind a = def1 in\n let%map b = def2 in\n `Two (a, b)\n\n let map : 'a t -> f:('a -> ('b, 'e) M.t) -> ('b t, 'e) M.t =\n fun t ~f ->\n (* We could use sequence here, but this approach saves us computation in the\n Result and option monads when the first component of a `Two fails. *)\n match t with\n | `One a ->\n M.map ~f:(fun x -> `One x) (f a)\n | `Two (a, b) ->\n let open M.Let_syntax in\n let%bind a' = f a in\n let%map b' = f b in\n `Two (a', b')\n\n let fold :\n 'a t\n -> init:'accum\n -> f:('accum -> 'a -> ('accum, 'e) M.t)\n -> ('accum, 'e) M.t =\n fun t ~init ~f ->\n match t with\n | `One a ->\n f init a\n | `Two (a, b) ->\n M.bind (f init a) ~f:(fun x -> f x b)\nend\n\nmodule Monadic (M : Monad.S) : Intfs.Monadic with type 'a m := 'a M.t =\n Monadic2 (Base__.Monad_intf.S_to_S2 (M))\n\nmodule Deferred_result = Monadic2 (Deferred.Result)\nmodule Ident = Monadic (Monad.Ident)\nmodule Deferred = Monadic (Deferred)\nmodule Option = Monadic (Option)\nmodule Or_error = Monadic (Or_error)\n\nlet map = Ident.map\n\nlet fold = Ident.fold\n\nlet iter t ~f = match t with `One a -> f a | `Two (a, b) -> f a ; f b\n\nlet fold_until ~init ~f ~finish t =\n Container.fold_until ~fold ~init ~f ~finish t\n\nlet gen inner_gen =\n Quickcheck.Generator.(\n union\n [ map inner_gen ~f:(fun x -> `One x)\n ; map (tuple2 inner_gen inner_gen) ~f:(fun pair -> `Two pair)\n ])\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Mina_base_import\n\n(** See documentation of the {!Mina_wire_types} library *)\nmodule Wire_types = Mina_wire_types.Mina_base.Account_id\n\nmodule Make_sig (A : Wire_types.Types.S) = struct\n module type S =\n Account_id_intf.S\n with type Digest.Stable.V1.t = A.Digest.V1.t\n and type Stable.V2.t = A.V2.t\nend\n\nmodule Make_str (_ : Wire_types.Concrete) = struct\n let invalid = (Public_key.Compressed.empty, Pickles.Backend.Tick.Field.zero)\n\n module Digest = struct\n [%%ifdef consensus_mechanism]\n\n let of_bigstring_exn =\n Binable.of_bigstring (module Pickles.Backend.Tick.Field.Stable.Latest)\n\n let to_bigstring =\n Binable.to_bigstring (module Pickles.Backend.Tick.Field.Stable.Latest)\n\n [%%else]\n\n let of_bigstring_exn =\n Binable.of_bigstring (module Snark_params.Tick.Field.Stable.Latest)\n\n let to_bigstring =\n Binable.to_bigstring (module Snark_params.Tick.Field.Stable.Latest)\n\n [%%endif]\n\n module Base58_check = Base58_check.Make (struct\n let description = \"Token ID\"\n\n let version_byte = Base58_check.Version_bytes.token_id_key\n end)\n\n let to_base58_check t : string =\n Base58_check.encode (to_bigstring t |> Bigstring.to_string)\n\n let of_base58_check_exn (s : string) =\n let decoded = Base58_check.decode_exn s in\n decoded |> Bigstring.of_string |> of_bigstring_exn\n\n let to_string = to_base58_check\n\n let of_string = of_base58_check_exn\n\n let of_field = Fn.id\n\n let to_field_unsafe = Fn.id\n\n [%%ifdef consensus_mechanism]\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Pickles.Backend.Tick.Field.Stable.V1.t\n [@@deriving sexp, equal, compare, hash]\n\n let to_yojson (t : t) : Yojson.Safe.t = `String (to_string t)\n\n let of_yojson (j : Yojson.Safe.t) : (t, string) result =\n try Ok (of_string (Yojson.Safe.Util.to_string j))\n with e -> Error (Exn.to_string e)\n\n let to_latest = Fn.id\n end\n end]\n\n [%%else]\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Snark_params.Tick.Field.Stable.V1.t\n [@@deriving sexp, equal, compare, hash]\n\n let to_yojson (t : t) : Yojson.Safe.t = `String (to_string t)\n\n let of_yojson (j : Yojson.Safe.t) : (t, string) result =\n try Ok (of_string (Yojson.Safe.Util.to_string j))\n with e -> Error (Exn.to_string e)\n\n let to_latest = Fn.id\n end\n end]\n\n [%%endif]\n\n [%%define_locally Stable.Latest.(of_yojson, to_yojson)]\n\n module Binables = struct\n include Comparable.Make_binable (Stable.Latest)\n include Hashable.Make_binable (Stable.Latest)\n end\n\n include Binables\n\n let to_input : t -> _ Random_oracle_input.Chunked.t =\n Random_oracle_input.Chunked.field\n\n (* Just matters that this no one can find a preimage to this with poseidon.\n Chose 1 for consistency for the old uint64 based token IDs *)\n let default : t = Snark_params.Tick.Field.one\n\n let gen : t Quickcheck.Generator.t = Snark_params.Tick.Field.gen\n\n let gen_non_default =\n Quickcheck.Generator.filter gen ~f:(fun x -> not (equal x default))\n\n [%%ifdef consensus_mechanism]\n\n module Checked = struct\n open Pickles.Impls.Step\n\n type t = Field.t\n\n let to_input : t -> _ Random_oracle_input.Chunked.t =\n Random_oracle_input.Chunked.field\n\n let constant : Stable.Latest.t -> t = Field.constant\n\n let equal : t -> t -> Boolean.var = Field.equal\n\n let if_ = Field.if_\n\n let of_field = Fn.id\n\n let to_field_unsafe = Fn.id\n\n module Assert = struct\n let equal : t -> t -> unit = Field.Assert.equal\n end\n end\n\n let typ = Snark_params.Tick.Field.typ\n\n [%%endif]\n end\n\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t = Public_key.Compressed.Stable.V1.t * Digest.Stable.V1.t\n [@@deriving sexp, equal, compare, hash, yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n let create key tid = (key, tid)\n\n let empty : t = (Public_key.Compressed.empty, Digest.default)\n\n let public_key (key, _tid) = key\n\n let of_public_key (pk : Public_key.t) =\n create (Public_key.compress pk) Digest.default\n\n let token_id (_key, id) = id\n\n let to_input ((key, tid) : t) =\n Random_oracle_input.Chunked.(\n append (Public_key.Compressed.to_input key) (field tid))\n\n let derive_token_id ~(owner : t) : Digest.t =\n Random_oracle.hash ~init:Hash_prefix.derive_token_id\n (Random_oracle.pack_input (to_input owner))\n\n let gen =\n let open Quickcheck.Let_syntax in\n let%map key = Public_key.Compressed.gen and tid = Digest.gen in\n (key, tid)\n\n include Comparable.Make_binable (Stable.Latest)\n include Hashable.Make_binable (Stable.Latest)\n\n let to_input ((key, tid) : t) =\n Random_oracle.Input.Chunked.append\n (Public_key.Compressed.to_input key)\n (Digest.to_input tid)\n\n [%%ifdef consensus_mechanism]\n\n type var = Public_key.Compressed.var * Digest.Checked.t\n\n let typ = Snarky_backendless.Typ.(Public_key.Compressed.typ * Digest.typ)\n\n let var_of_t ((key, tid) : t) =\n ( Public_key.Compressed.var_of_t key\n , Snark_params.Tick.Field.Var.constant tid )\n\n module Checked = struct\n open Snark_params\n open Tick\n\n let create key tid = (key, tid)\n\n let public_key (key, _tid) = key\n\n let token_id (_key, tid) = tid\n\n let to_input ((key, tid) : var) =\n let tid = Digest.Checked.to_input tid in\n Random_oracle.Input.Chunked.append\n (Public_key.Compressed.Checked.to_input key)\n tid\n\n let derive_token_id ~(owner : var) : Digest.Checked.t =\n Random_oracle.Checked.hash ~init:Hash_prefix.derive_token_id\n (Random_oracle.Checked.pack_input (to_input owner))\n\n let equal (pk1, tid1) (pk2, tid2) =\n let%bind pk_equal = Public_key.Compressed.Checked.equal pk1 pk2 in\n let%bind tid_equal = Snark_params.Tick.Field.Checked.equal tid1 tid2 in\n Tick.Boolean.(pk_equal && tid_equal)\n\n let if_ b ~then_:(pk_then, tid_then) ~else_:(pk_else, tid_else) =\n let%bind pk =\n Public_key.Compressed.Checked.if_ b ~then_:pk_then ~else_:pk_else\n in\n let%map tid =\n Snark_params.Tick.Field.Checked.if_ b ~then_:tid_then ~else_:tid_else\n in\n (pk, tid)\n end\n\n [%%endif]\nend\n\ninclude Wire_types.Make (Make_sig) (Make_str)\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Snark_params\nopen Tick\nopen Currency\nopen Mina_numbers\n\n(* A timed account is an account, which releases its balance to be spent\n gradually. The process of releasing frozen funds is defined as follows.\n Until the cliff_time global slot is reached, the initial_minimum_balance\n of mina is frozen and cannot be spent. At the cliff slot, cliff_amount\n is released and initial_minimum_balance is effectively lowered by that\n amount. Next, every vesting_period number of slots, vesting_increment\n is released, further decreasing the current minimum balance. At some\n point minimum balance drops to 0, and after that the account behaves\n like an untimed one. *)\nmodule Poly = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type ('slot, 'slot_span, 'balance, 'amount) t =\n | Untimed\n | Timed of\n { initial_minimum_balance : 'balance\n ; cliff_time : 'slot\n ; cliff_amount : 'amount\n ; vesting_period : 'slot_span\n ; vesting_increment : 'amount\n }\n [@@deriving sexp, equal, hash, compare, yojson]\n end\n end]\nend\n\n[%%versioned\nmodule Stable = struct\n module V2 = struct\n type t =\n ( Global_slot_since_genesis.Stable.V1.t\n , Global_slot_span.Stable.V1.t\n , Balance.Stable.V1.t\n , Amount.Stable.V1.t )\n Poly.Stable.V2.t\n [@@deriving sexp, equal, hash, compare, yojson]\n\n let to_latest = Fn.id\n end\nend]\n\ntype ('slot, 'slot_span, 'balance, 'amount) tt =\n ('slot, 'slot_span, 'balance, 'amount) Poly.t =\n | Untimed\n | Timed of\n { initial_minimum_balance : 'balance\n ; cliff_time : 'slot\n ; cliff_amount : 'amount\n ; vesting_period : 'slot_span\n ; vesting_increment : 'amount\n }\n[@@deriving sexp, equal, hash, compare, yojson]\n\nmodule As_record = struct\n type ('bool, 'slot, 'slot_span, 'balance, 'amount) t =\n { is_timed : 'bool\n ; initial_minimum_balance : 'balance\n ; cliff_time : 'slot\n ; cliff_amount : 'amount\n ; vesting_period : 'slot_span\n ; vesting_increment : 'amount\n }\n [@@deriving equal, hlist, fields, annot]\n\n let deriver obj =\n let open Fields_derivers_zkapps.Derivers in\n let ( !. ) = ( !. ) ~t_fields_annots in\n Fields.make_creator obj ~is_timed:!.bool ~initial_minimum_balance:!.balance\n ~cliff_time:!.global_slot_since_genesis\n ~cliff_amount:!.amount ~vesting_period:!.global_slot_span\n ~vesting_increment:!.amount\n |> finish \"AccountTiming\" ~t_toplevel_annots\nend\n\ntype as_record =\n ( bool\n , Global_slot_since_genesis.Stable.V1.t\n , Global_slot_span.Stable.V1.t\n , Balance.Stable.V1.t\n , Amount.Stable.V1.t )\n As_record.t\n\n(* convert sum type to record format, useful for to_bits and typ *)\nlet to_record t =\n match t with\n | Untimed ->\n let slot_unused = Global_slot_since_genesis.zero in\n let slot_span_one = Global_slot_span.(succ zero) in\n let balance_unused = Balance.zero in\n let amount_unused = Amount.zero in\n { As_record.is_timed = false\n ; initial_minimum_balance = balance_unused\n ; cliff_time = slot_unused\n ; cliff_amount = amount_unused\n ; vesting_period = slot_span_one (* avoid division by zero *)\n ; vesting_increment = amount_unused\n }\n | Timed\n { initial_minimum_balance\n ; cliff_time\n ; cliff_amount\n ; vesting_period\n ; vesting_increment\n } ->\n { is_timed = true\n ; initial_minimum_balance\n ; cliff_time\n ; cliff_amount\n ; vesting_period\n ; vesting_increment\n }\n\nlet of_record\n { As_record.is_timed\n ; initial_minimum_balance\n ; cliff_time\n ; cliff_amount\n ; vesting_period\n ; vesting_increment\n } : t =\n if is_timed then\n Timed\n { initial_minimum_balance\n ; cliff_time\n ; cliff_amount\n ; vesting_period\n ; vesting_increment\n }\n else Untimed\n\nlet of_record (r : as_record) : t =\n if r.is_timed then\n Timed\n { initial_minimum_balance = r.initial_minimum_balance\n ; cliff_time = r.cliff_time\n ; cliff_amount = r.cliff_amount\n ; vesting_period = r.vesting_period\n ; vesting_increment = r.vesting_increment\n }\n else Untimed\n\nlet to_input t =\n let As_record.\n { is_timed\n ; initial_minimum_balance\n ; cliff_time\n ; cliff_amount\n ; vesting_period\n ; vesting_increment\n } =\n to_record t\n in\n let open Random_oracle_input.Chunked in\n Array.reduce_exn ~f:append\n [| packed ((if is_timed then Field.one else Field.zero), 1)\n ; Balance.to_input initial_minimum_balance\n ; Global_slot_since_genesis.to_input cliff_time\n ; Amount.to_input cliff_amount\n ; Global_slot_span.to_input vesting_period\n ; Amount.to_input vesting_increment\n |]\n\n[%%ifdef consensus_mechanism]\n\ntype var =\n ( Boolean.var\n , Global_slot_since_genesis.Checked.var\n , Global_slot_span.Checked.var\n , Balance.var\n , Amount.var )\n As_record.t\n\nlet var_to_input\n As_record.\n { is_timed : Boolean.var\n ; initial_minimum_balance\n ; cliff_time\n ; cliff_amount\n ; vesting_period\n ; vesting_increment\n } =\n let open Random_oracle_input.Chunked in\n Array.reduce_exn ~f:append\n [| packed ((is_timed :> Field.Var.t), 1)\n ; Balance.var_to_input initial_minimum_balance\n ; Global_slot_since_genesis.Checked.to_input cliff_time\n ; Amount.var_to_input cliff_amount\n ; Global_slot_span.Checked.to_input vesting_period\n ; Amount.var_to_input vesting_increment\n |]\n\nlet var_of_t (t : t) : var =\n let { As_record.is_timed\n ; initial_minimum_balance\n ; cliff_time\n ; cliff_amount\n ; vesting_period\n ; vesting_increment\n } =\n to_record t\n in\n { is_timed = Boolean.var_of_value is_timed\n ; initial_minimum_balance = Balance.var_of_t initial_minimum_balance\n ; cliff_time = Global_slot_since_genesis.Checked.constant cliff_time\n ; cliff_amount = Amount.var_of_t cliff_amount\n ; vesting_period = Global_slot_span.Checked.constant vesting_period\n ; vesting_increment = Amount.var_of_t vesting_increment\n }\n\nlet untimed_var = var_of_t Untimed\n\nlet typ : (var, t) Typ.t =\n (* because we represent the types t (a sum type) and var (a record) differently,\n we can't use the trick, used elsewhere, of polymorphic to_hlist and of_hlist\n functions to handle both types\n *)\n let value_of_hlist :\n ( unit\n , Boolean.value\n -> Balance.t\n -> Global_slot_since_genesis.t\n -> Amount.t\n -> Global_slot_span.t\n -> Amount.t\n -> unit )\n H_list.t\n -> t =\n let open H_list in\n fun [ is_timed\n ; initial_minimum_balance\n ; cliff_time\n ; cliff_amount\n ; vesting_period\n ; vesting_increment\n ] ->\n if is_timed then\n Timed\n { initial_minimum_balance\n ; cliff_time\n ; cliff_amount\n ; vesting_period\n ; vesting_increment\n }\n else Untimed\n in\n let value_to_hlist (t : t) =\n let As_record.\n { is_timed\n ; initial_minimum_balance\n ; cliff_time\n ; cliff_amount\n ; vesting_period\n ; vesting_increment\n } =\n to_record t\n in\n H_list.\n [ is_timed\n ; initial_minimum_balance\n ; cliff_time\n ; cliff_amount\n ; vesting_period\n ; vesting_increment\n ]\n in\n let var_of_hlist = As_record.of_hlist in\n let var_to_hlist = As_record.to_hlist in\n Typ.of_hlistable\n [ Boolean.typ\n ; Balance.typ\n ; Global_slot_since_genesis.typ\n ; Amount.typ\n ; Global_slot_span.typ\n ; Amount.typ\n ]\n ~var_to_hlist ~var_of_hlist ~value_to_hlist ~value_of_hlist\n\n(* we can't use the generic if_ with the above typ, because Global_slot_since_genesis.typ doesn't work correctly with it\n so we define a custom if_\n*)\nlet if_ b ~(then_ : var) ~(else_ : var) =\n let%bind is_timed =\n Boolean.if_ b ~then_:then_.is_timed ~else_:else_.is_timed\n in\n let%bind initial_minimum_balance =\n Balance.Checked.if_ b ~then_:then_.initial_minimum_balance\n ~else_:else_.initial_minimum_balance\n in\n let%bind cliff_time =\n Global_slot_since_genesis.Checked.if_ b ~then_:then_.cliff_time\n ~else_:else_.cliff_time\n in\n let%bind cliff_amount =\n Amount.Checked.if_ b ~then_:then_.cliff_amount ~else_:else_.cliff_amount\n in\n let%bind vesting_period =\n Global_slot_span.Checked.if_ b ~then_:then_.vesting_period\n ~else_:else_.vesting_period\n in\n let%map vesting_increment =\n Amount.Checked.if_ b ~then_:then_.vesting_increment\n ~else_:else_.vesting_increment\n in\n { As_record.is_timed\n ; initial_minimum_balance\n ; cliff_time\n ; cliff_amount\n ; vesting_period\n ; vesting_increment\n }\n\nlet deriver obj =\n let open Fields_derivers_zkapps in\n iso_record ~to_record ~of_record As_record.deriver obj\n\n[%%endif]\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Snark_params.Tick\n\nmodule Poly = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n [@@@with_all_version_tags]\n\n type ('field, 'scalar) t = 'field * 'scalar\n [@@deriving sexp, compare, equal, hash]\n end\n end]\nend\n\n[%%versioned\nmodule Stable = struct\n module V1 = struct\n [@@@with_all_version_tags]\n\n type t =\n ( (Field.t[@version_asserted])\n , (Inner_curve.Scalar.t[@version_asserted]) )\n Poly.Stable.V1.t\n [@@deriving sexp, compare, equal, hash]\n\n module Codable_arg = struct\n (* version tag for compatibility with pre-Berkeley hard fork\n Base58Check-serialized signatures\n *)\n type t =\n (Field.t, Inner_curve.Scalar.t) Poly.Stable.V1.With_all_version_tags.t\n [@@deriving bin_io_unversioned]\n\n let description = \"Signature\"\n\n let version_byte = Base58_check.Version_bytes.signature\n end\n\n (* Base58Check encodes t *)\n let (_ : (t, Codable_arg.t) Type_equal.t) = Type_equal.T\n\n include Codable.Make_base58_check (Codable_arg)\n\n let to_latest = Fn.id\n\n let gen = Quickcheck.Generator.tuple2 Field.gen Inner_curve.Scalar.gen\n end\nend]\n\nlet dummy = (Field.one, Inner_curve.Scalar.one)\n\nlet gen = Stable.Latest.gen\n\nmodule Raw = struct\n open Rosetta_coding.Coding\n\n let encode (field, scalar) = of_field field ^ of_scalar scalar\n\n let decode raw =\n let len = String.length raw in\n let field_len = len / 2 in\n let field_enc = String.sub raw ~pos:0 ~len:field_len in\n let scalar_enc = String.sub raw ~pos:field_len ~len:field_len in\n try Some (to_field field_enc, to_scalar scalar_enc) with _ -> None\nend\n\n[%%ifdef consensus_mechanism]\n\ntype var = Field.Var.t * Inner_curve.Scalar.var\n\n[%%endif]\n\n[%%define_locally\nStable.Latest.\n (of_base58_check_exn, of_base58_check, of_yojson, to_yojson, to_base58_check)]\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\n\n(* TODO: temporary hack *)\n[%%ifdef consensus_mechanism]\n\n[%%versioned\nmodule Stable = struct\n module V2 = struct\n type t = Mina_wire_types.Mina_base.Control.V2.t =\n | Proof of Pickles.Side_loaded.Proof.Stable.V2.t\n | Signature of Signature.Stable.V1.t\n | None_given\n [@@deriving sexp, equal, yojson, hash, compare]\n\n let to_latest = Fn.id\n end\nend]\n\n(* lazy, to prevent spawning Rust threads at startup, which prevents daemonization *)\nlet gen_with_dummies : t Quickcheck.Generator.t =\n let gen =\n lazy\n (Quickcheck.Generator.of_list\n (let dummy_proof =\n let n2 = Pickles_types.Nat.N2.n in\n let proof = Pickles.Proof.dummy n2 n2 n2 ~domain_log2:15 in\n Proof proof\n in\n let dummy_signature = Signature Signature.dummy in\n [ dummy_proof; dummy_signature; None_given ] ) )\n in\n Quickcheck.Generator.create (fun ~size ~random ->\n Quickcheck.Generator.generate (Lazy.force gen) ~size ~random )\n\n[%%else]\n\n[%%versioned\nmodule Stable = struct\n module V2 = struct\n type t = Proof of unit | Signature of Signature.Stable.V1.t | None_given\n [@@deriving sexp, equal, yojson, hash, compare]\n\n let to_latest = Fn.id\n end\n\n module V1 = struct\n type t =\n | Proof of unit\n | Signature of Signature.Stable.V1.t\n | Both of { signature : Signature.Stable.V1.t; proof : unit }\n | None_given\n [@@deriving sexp, equal, yojson, hash, compare]\n\n let to_latest : t -> V2.t = function\n | Proof proof ->\n Proof proof\n | Signature signature ->\n Signature signature\n | None_given ->\n None_given\n | Both _ ->\n failwith\n \"Control.Stable.V1.to_latest: Both variant is no longer supported\"\n end\nend]\n\n[%%endif]\n\nmodule Tag = struct\n type t = Signature | Proof | None_given [@@deriving equal, compare, sexp]\n\n let gen = Quickcheck.Generator.of_list [ Proof; Signature; None_given ]\n\n let to_string = function\n | Signature ->\n \"Signature\"\n | Proof ->\n \"Proof\"\n | None_given ->\n \"None_given\"\n\n let of_string_exn = function\n | \"Signature\" ->\n Signature\n | \"Proof\" ->\n Proof\n | \"None_given\" ->\n None_given\n | s ->\n failwithf \"String %s does not denote a control tag\" s ()\nend\n\nlet tag : t -> Tag.t = function\n | Proof _ ->\n Proof\n | Signature _ ->\n Signature\n | None_given ->\n None_given\n\n[%%ifdef consensus_mechanism]\n\nlet dummy_of_tag : Tag.t -> t = function\n | Proof ->\n let n2 = Pickles_types.Nat.N2.n in\n let proof = Pickles.Proof.dummy n2 n2 n2 ~domain_log2:15 in\n Proof proof\n | Signature ->\n Signature Signature.dummy\n | None_given ->\n None_given\n\nlet signature_deriver obj =\n Fields_derivers_zkapps.Derivers.iso_string obj ~name:\"Signature\"\n ~js_type:String ~to_string:Signature.to_base58_check\n ~of_string:\n (Fields_derivers_zkapps.except ~f:Signature.of_base58_check_exn `Signature)\n\nmodule As_record = struct\n type t =\n { proof : Pickles.Side_loaded.Proof.t option\n ; signature : Signature.t option\n }\n [@@deriving annot, fields]\n\n let deriver obj =\n let open Fields_derivers_zkapps in\n let ( !. ) = ( !. ) ~t_fields_annots in\n Fields.make_creator obj\n ~proof:!.(option ~js_type:Or_undefined @@ proof @@ o ())\n ~signature:!.(option ~js_type:Or_undefined @@ signature_deriver @@ o ())\n |> finish \"Control\" ~t_toplevel_annots\nend\n\nlet to_record = function\n | Proof p ->\n { As_record.proof = Some p; signature = None }\n | Signature s ->\n { proof = None; signature = Some s }\n | None_given ->\n { proof = None; signature = None }\n\nlet of_record = function\n | { As_record.proof = Some p; _ } ->\n Proof p\n | { signature = Some s; _ } ->\n Signature s\n | _ ->\n None_given\n\nlet deriver obj =\n Fields_derivers_zkapps.Derivers.iso_record ~of_record ~to_record\n As_record.deriver obj\n\nlet%test_unit \"json rountrip\" =\n let module Fd = Fields_derivers_zkapps.Derivers in\n let full = deriver (Fd.o ()) in\n let control = dummy_of_tag Proof in\n [%test_eq: t] control (control |> Fd.to_json full |> Fd.of_json full)\n\n[%%endif]\n","(* payment_payload.ml *)\n\n[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Signature_lib\nmodule Amount = Currency.Amount\nmodule Fee = Currency.Fee\n\nmodule Poly = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type ('public_key, 'amount) t =\n ( 'public_key\n , 'amount )\n Mina_wire_types.Mina_base.Payment_payload.Poly.V2.t =\n { receiver_pk : 'public_key; amount : 'amount }\n [@@deriving equal, sexp, hash, yojson, compare, hlist]\n end\n\n module V1 = struct\n [@@@with_all_version_tags]\n\n type ('public_key, 'token_id, 'amount) t =\n { source_pk : 'public_key\n ; receiver_pk : 'public_key\n ; token_id : 'token_id\n ; amount : 'amount\n }\n [@@deriving equal, sexp, hash, yojson, compare, hlist]\n end\n end]\nend\n\n[%%versioned\nmodule Stable = struct\n module V2 = struct\n type t =\n (Public_key.Compressed.Stable.V1.t, Amount.Stable.V1.t) Poly.Stable.V2.t\n [@@deriving equal, sexp, hash, compare, yojson]\n\n let to_latest = Fn.id\n end\n\n module V1 = struct\n [@@@with_all_version_tags]\n\n type t =\n ( Public_key.Compressed.Stable.V1.t\n , Token_id.Stable.V1.t\n , Amount.Stable.V1.t )\n Poly.Stable.V1.t\n [@@deriving equal, sexp, hash, compare, yojson]\n\n (* don't need to coerce old payments to new ones *)\n let to_latest _ = failwith \"Not implemented\"\n end\nend]\n\nlet dummy =\n Poly.{ receiver_pk = Public_key.Compressed.empty; amount = Amount.zero }\n\n[%%ifdef consensus_mechanism]\n\ntype var = (Public_key.Compressed.var, Amount.var) Poly.t\n\nlet var_of_t ({ receiver_pk; amount } : t) : var =\n { receiver_pk = Public_key.Compressed.var_of_t receiver_pk\n ; amount = Amount.var_of_t amount\n }\n\n[%%endif]\n\nlet gen_aux max_amount =\n let open Quickcheck.Generator.Let_syntax in\n let%bind receiver_pk = Public_key.Compressed.gen in\n let%map amount = Amount.gen_incl Amount.zero max_amount in\n Poly.{ receiver_pk; amount }\n\nlet gen max_amount = gen_aux max_amount\n\nlet gen_default_token max_amount = gen_aux max_amount\n","open Core_kernel\nopen Snark_params.Tick\n\ninclude Data_hash.Make_full_size (struct\n let description = \"Ledger hash\"\n\n let version_byte = Base58_check.Version_bytes.ledger_hash\nend)\n\n(* Data hash versioned boilerplate below *)\n\n[%%versioned\nmodule Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n module T = struct\n type t = (Field.t[@version_asserted]) [@@deriving sexp, compare, hash]\n end\n\n include T\n\n let to_latest = Fn.id\n\n [%%define_from_scope to_yojson, of_yojson]\n\n include Comparable.Make (T)\n include Hashable.Make_binable (T)\n end\nend]\n\nlet (_ : (t, Stable.Latest.t) Type_equal.t) = Type_equal.T\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Mina_base_util\n\n[%%ifdef consensus_mechanism]\n\nopen Snark_params.Tick\n\n[%%endif]\n\nmodule Frozen_ledger_hash = Frozen_ledger_hash0\nmodule Ledger_hash = Ledger_hash0\n\n(* Semantically this type represents a function\n { has_valid_signature: bool; has_valid_proof: bool } -> bool\n\n These are all of them:\n 00 01 10 11 | intuitive definition | Make sense\n 0 0 0 0 | Impossible | yes\n 0 0 0 1 | Both | yes\n 0 0 1 0 | Proof and not signature | no\n 0 0 1 1 | Proof | yes\n 0 1 0 0 | Signature and not proof | no\n 0 1 0 1 | Signature | yes\n 0 1 1 0 | Exactly one | no\n 0 1 1 1 | Either | yes\n 1 0 0 0 | Neither | no\n 1 0 0 1 | Neither or both | no\n 1 0 1 0 | Neither or proof, not both | no\n ...\n 1 1 1 1 | None | yes\n\n The ones marked as \"not making sense\" don't make sense because it is pointless\n to demand a signature failed to verify since you can always make a failing signature\n or proof.\n\n The ones that make sense are\n 0 0 0 0 | Impossible | yes\n 0 0 0 1 | Both | yes\n 0 0 1 1 | Proof | yes\n 0 1 0 1 | Signature | yes\n 0 1 1 1 | Either | yes\n 1 1 1 1 | None | yes\n\n \"Making sense\" can be captured by the idea that these are the *increasing*\n boolean functions on the type { has_valid_signature: bool; has_valid_proof: bool }.\n*)\nmodule Auth_required = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t = Mina_wire_types.Mina_base.Permissions.Auth_required.V2.t =\n | None\n | Either\n | Proof\n | Signature\n | Impossible (* Both and either can both be subsumed in verification key.\n It is good to have \"Either\" as a separate thing to spare the owner from\n having to make a proof instead of a signature. Both, I'm not sure if there's\n a good justification for. *)\n [@@deriving sexp, equal, compare, hash, yojson, enum]\n\n let to_latest = Fn.id\n end\n end]\n\n let from ~auth_tag : t =\n match auth_tag with\n | Control.Tag.Proof ->\n Proof\n | Signature ->\n Signature\n | None_given ->\n None\n\n (* permissions such that [check permission (Proof _)] is true *)\n let gen_for_proof_authorization : t Quickcheck.Generator.t =\n Quickcheck.Generator.of_list [ None; Either; Proof ]\n\n (* permissions such that [check permission (Signature _)] is true *)\n let gen_for_signature_authorization : t Quickcheck.Generator.t =\n Quickcheck.Generator.of_list [ None; Either; Signature ]\n\n (* permissions such that [check permission None_given] is true *)\n let gen_for_none_given_authorization : t Quickcheck.Generator.t =\n Quickcheck.Generator.return None\n\n let to_string = function\n | None ->\n \"None\"\n | Either ->\n \"Either\"\n | Proof ->\n \"Proof\"\n | Signature ->\n \"Signature\"\n | Impossible ->\n \"Impossible\"\n\n let of_string = function\n | \"None\" ->\n Stable.Latest.None\n | \"Either\" ->\n Either\n | \"Proof\" ->\n Proof\n | \"Signature\" ->\n Signature\n | \"Impossible\" ->\n Impossible\n | _ ->\n failwith \"auth_required_of_string: unknown variant\"\n\n (* The encoding is chosen so that it is easy to write this function\n\n let spec_eval t ~signature_verifies =\n let impossible = (constant t && not (signature_sufficient t)) in\n let result =\n not impossible &&\n ( (signature_verifies && signature_sufficient t)\n || not (signature_necessary t) )\n in\n { result; proof_must_verify= not (signature_sufficient t) } *)\n\n (* Here is the mapping between our type and the bits\n { constant: bool\n ; signature_necessary: bool\n ; signature_sufficient: bool\n }\n\n Not constant\n Signature not necessary\n Signature not sufficient\n Proof\n Signature sufficient\n Either\n Signature necessary\n Signature not sufficient\n Both\n Signature sufficient\n Signature\n\n Constant\n Signature not sufficient\n Impossible\n Signature sufficient\n None\n *)\n module Encoding = struct\n type 'bool t =\n { constant : 'bool\n ; signature_necessary : 'bool\n ; signature_sufficient : 'bool\n }\n [@@deriving hlist, fields]\n\n let to_input ~field_of_bool t =\n let [ x; y; z ] = to_hlist t in\n let bs = [| x; y; z |] in\n Random_oracle.Input.Chunked.packeds\n (Array.map bs ~f:(fun b -> (field_of_bool b, 1)))\n\n let map t ~f =\n { constant = f t.constant\n ; signature_necessary = f t.signature_necessary\n ; signature_sufficient = f t.signature_sufficient\n }\n\n let _ = map\n\n [%%ifdef consensus_mechanism]\n\n let if_ b ~then_:t ~else_:e =\n let open Pickles.Impls.Step in\n { constant = Boolean.if_ b ~then_:t.constant ~else_:e.constant\n ; signature_necessary =\n Boolean.if_ b ~then_:t.signature_necessary\n ~else_:e.signature_necessary\n ; signature_sufficient =\n Boolean.if_ b ~then_:t.signature_sufficient\n ~else_:e.signature_sufficient\n }\n\n [%%endif]\n end\n\n let encode : t -> bool Encoding.t = function\n | Impossible ->\n { constant = true\n ; signature_necessary = true\n ; signature_sufficient = false\n }\n | None ->\n { constant = true\n ; signature_necessary = false\n ; signature_sufficient = true\n }\n | Proof ->\n { constant = false\n ; signature_necessary = false\n ; signature_sufficient = false\n }\n | Signature ->\n { constant = false\n ; signature_necessary = true\n ; signature_sufficient = true\n }\n | Either ->\n { constant = false\n ; signature_necessary = false\n ; signature_sufficient = true\n }\n\n let decode : bool Encoding.t -> t = function\n | { constant = true; signature_necessary = _; signature_sufficient = false }\n ->\n Impossible\n | { constant = true; signature_necessary = _; signature_sufficient = true }\n ->\n None\n | { constant = false\n ; signature_necessary = false\n ; signature_sufficient = false\n } ->\n Proof\n | { constant = false\n ; signature_necessary = true\n ; signature_sufficient = true\n } ->\n Signature\n | { constant = false\n ; signature_necessary = false\n ; signature_sufficient = true\n } ->\n Either\n | { constant = false\n ; signature_necessary = true\n ; signature_sufficient = false\n } ->\n failwith\n \"Permissions.decode: Found encoding of Both, but Both is not an \\\n exposed option\"\n\n let%test_unit \"decode encode\" =\n List.iter [ Impossible; Proof; Signature; Either ] ~f:(fun t ->\n [%test_eq: t] t (decode (encode t)) )\n\n [%%ifdef consensus_mechanism]\n\n module Checked = struct\n type t = Boolean.var Encoding.t\n\n let if_ = Encoding.if_\n\n let to_input : t -> _ =\n Encoding.to_input ~field_of_bool:(fun (b : Boolean.var) ->\n (b :> Field.Var.t) )\n\n let constant t = Encoding.map (encode t) ~f:Boolean.var_of_value\n\n let eval_no_proof\n ({ constant; signature_necessary = _; signature_sufficient } : t)\n ~signature_verifies =\n (* ways authorization can succeed when no proof is present:\n - None\n {constant= true; signature_necessary= _; signature_sufficient= true}\n - Either && signature_verifies\n {constant= false; signature_necessary= false; signature_sufficient= true}\n - Signature && signature_verifies\n {constant= false; signature_necessary= true; signature_sufficient= true}\n *)\n let open Pickles.Impls.Step.Boolean in\n signature_sufficient\n &&& (constant ||| ((not constant) &&& signature_verifies))\n\n let eval_proof ({ constant; signature_necessary; signature_sufficient } : t)\n =\n (* ways authorization can succeed if a proof is present:\n - None\n {constant= true; signature_necessary= _; signature_sufficient= true}\n - Either\n {constant= false; signature_necessary= false; signature_sufficient= true}\n - Proof\n {constant= false; signature_necessary= false; signature_sufficient= false}\n *)\n let open Pickles.Impls.Step.Boolean in\n let impossible = constant &&& not signature_sufficient in\n (not signature_necessary) &&& not impossible\n\n let spec_eval ({ constant; signature_necessary; signature_sufficient } : t)\n ~signature_verifies =\n let open Pickles.Impls.Step.Boolean in\n let impossible = constant &&& not signature_sufficient in\n let result =\n (not impossible)\n &&& ( signature_verifies &&& signature_sufficient\n ||| not signature_necessary )\n in\n let didn't_fail_yet = result in\n (* If the transaction already failed to verify, we don't need to assert\n that the proof should verify. *)\n (result, `proof_must_verify (didn't_fail_yet &&& not signature_sufficient))\n end\n\n let typ =\n let t =\n let open Encoding in\n Typ.of_hlistable\n [ Boolean.typ; Boolean.typ; Boolean.typ ]\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist\n in\n Typ.transport t ~there:encode ~back:decode\n\n [%%endif]\n\n let to_input x = Encoding.to_input (encode x) ~field_of_bool\n\n let check (t : t) (c : Control.Tag.t) =\n match (t, c) with\n | Impossible, _ ->\n false\n | None, _ ->\n true\n | Proof, Proof ->\n true\n | Signature, Signature ->\n true\n (* The signatures and proofs have already been checked by this point. *)\n | Either, (Proof | Signature) ->\n true\n | Signature, Proof ->\n false\n | Proof, Signature ->\n false\n | (Proof | Signature | Either), None_given ->\n false\nend\n\nmodule Poly = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type 'controller t =\n 'controller Mina_wire_types.Mina_base.Permissions.Poly.V2.t =\n { edit_state : 'controller\n ; access : 'controller\n ; send : 'controller\n ; receive : 'controller\n ; set_delegate : 'controller\n ; set_permissions : 'controller\n ; set_verification_key : 'controller\n ; set_zkapp_uri : 'controller\n ; edit_action_state : 'controller\n ; set_token_symbol : 'controller\n ; increment_nonce : 'controller\n ; set_voting_for : 'controller\n ; set_timing : 'controller\n }\n [@@deriving annot, sexp, equal, compare, hash, yojson, hlist, fields]\n end\n end]\n\n let to_input controller t =\n let f mk acc field = mk (Core_kernel.Field.get field t) :: acc in\n Stable.Latest.Fields.fold ~init:[] ~edit_state:(f controller)\n ~send:(f controller) ~set_delegate:(f controller)\n ~set_permissions:(f controller) ~set_verification_key:(f controller)\n ~receive:(f controller) ~set_zkapp_uri:(f controller)\n ~edit_action_state:(f controller) ~set_token_symbol:(f controller)\n ~increment_nonce:(f controller) ~set_voting_for:(f controller)\n ~set_timing:(f controller) ~access:(f controller)\n |> List.rev\n |> List.reduce_exn ~f:Random_oracle.Input.Chunked.append\nend\n\n[%%versioned\nmodule Stable = struct\n module V2 = struct\n type t = Auth_required.Stable.V2.t Poly.Stable.V2.t\n [@@deriving sexp, equal, compare, hash, yojson]\n\n let to_latest = Fn.id\n end\nend]\n\nlet gen ~auth_tag : t Quickcheck.Generator.t =\n let auth_required_gen =\n (* for Auth_required permissions p, choose such that [check p authorization] is true *)\n match auth_tag with\n | Control.Tag.Proof ->\n Auth_required.gen_for_proof_authorization\n | Signature ->\n Auth_required.gen_for_signature_authorization\n | None_given ->\n Auth_required.gen_for_none_given_authorization\n in\n let open Quickcheck.Generator.Let_syntax in\n let%bind edit_state = auth_required_gen in\n let%bind send = auth_required_gen in\n let%bind receive = auth_required_gen in\n let%bind set_delegate = auth_required_gen in\n let%bind set_permissions = auth_required_gen in\n let%bind set_verification_key = auth_required_gen in\n let%bind set_zkapp_uri = auth_required_gen in\n let%bind edit_action_state = auth_required_gen in\n let%bind set_token_symbol = auth_required_gen in\n let%bind increment_nonce = auth_required_gen in\n let%bind set_voting_for = auth_required_gen in\n let%bind set_timing = auth_required_gen in\n let%bind access =\n (* Access permission is significantly more restrictive, do not arbitrarily\n set it when tests may not be intending to exercise it.\n *)\n Auth_required.gen_for_none_given_authorization\n in\n return\n { Poly.edit_state\n ; send\n ; receive\n ; set_delegate\n ; set_permissions\n ; set_verification_key\n ; set_zkapp_uri\n ; edit_action_state\n ; set_token_symbol\n ; increment_nonce\n ; set_voting_for\n ; set_timing\n ; access\n }\n\n[%%ifdef consensus_mechanism]\n\nmodule Checked = struct\n type t = Auth_required.Checked.t Poly.Stable.Latest.t\n\n let to_input (x : t) = Poly.to_input Auth_required.Checked.to_input x\n\n let if_ b ~then_ ~else_ =\n let g cond f =\n cond b\n ~then_:(Core_kernel.Field.get f then_)\n ~else_:(Core_kernel.Field.get f else_)\n in\n let c = g Auth_required.Checked.if_ in\n Poly.Fields.map ~edit_state:c ~send:c ~receive:c ~set_delegate:c\n ~set_permissions:c ~set_verification_key:c ~set_zkapp_uri:c\n ~edit_action_state:c ~set_token_symbol:c ~increment_nonce:c\n ~set_voting_for:c ~set_timing:c ~access:c\n\n let constant (t : Stable.Latest.t) : t =\n let open Core_kernel.Field in\n let a f = Auth_required.Checked.constant (get f t) in\n Poly.Fields.map ~edit_state:a ~send:a ~receive:a ~set_delegate:a\n ~set_permissions:a ~set_verification_key:a ~set_zkapp_uri:a\n ~edit_action_state:a ~set_token_symbol:a ~increment_nonce:a\n ~set_voting_for:a ~set_timing:a ~access:a\nend\n\nlet typ =\n let open Poly.Stable.Latest in\n Typ.of_hlistable\n [ Auth_required.typ\n ; Auth_required.typ\n ; Auth_required.typ\n ; Auth_required.typ\n ; Auth_required.typ\n ; Auth_required.typ\n ; Auth_required.typ\n ; Auth_required.typ\n ; Auth_required.typ\n ; Auth_required.typ\n ; Auth_required.typ\n ; Auth_required.typ\n ; Auth_required.typ\n ]\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist\n\n[%%endif]\n\nlet to_input (x : t) = Poly.to_input Auth_required.to_input x\n\nlet user_default : t =\n { edit_state = Signature\n ; send = Signature\n ; receive = None\n ; set_delegate = Signature\n ; set_permissions = Signature\n ; set_verification_key = Signature\n ; set_zkapp_uri = Signature\n ; edit_action_state = Signature\n ; set_token_symbol = Signature\n ; increment_nonce = Signature\n ; set_voting_for = Signature\n ; set_timing = Signature\n ; access = None\n }\n\nlet empty : t =\n { edit_state = None\n ; send = None\n ; receive = None\n ; access = None\n ; set_delegate = None\n ; set_permissions = None\n ; set_verification_key = None\n ; set_zkapp_uri = None\n ; edit_action_state = None\n ; set_token_symbol = None\n ; increment_nonce = None\n ; set_voting_for = None\n ; set_timing = None\n }\n\n(* deriving-fields-related stuff *)\n\nlet auth_required =\n Fields_derivers_zkapps.Derivers.iso_string ~name:\"AuthRequired\"\n ~js_type:(Custom \"AuthRequired\") ~doc:\"Kind of authorization required\"\n ~to_string:Auth_required.to_string ~of_string:Auth_required.of_string\n\nlet deriver obj =\n let open Fields_derivers_zkapps.Derivers in\n let ( !. ) = ( !. ) ~t_fields_annots:Poly.t_fields_annots in\n Poly.Fields.make_creator obj ~edit_state:!.auth_required ~send:!.auth_required\n ~receive:!.auth_required ~set_delegate:!.auth_required\n ~set_permissions:!.auth_required ~set_verification_key:!.auth_required\n ~set_zkapp_uri:!.auth_required ~edit_action_state:!.auth_required\n ~set_token_symbol:!.auth_required ~increment_nonce:!.auth_required\n ~set_voting_for:!.auth_required ~set_timing:!.auth_required\n ~access:!.auth_required\n |> finish \"Permissions\" ~t_toplevel_annots:Poly.t_toplevel_annots\n\nlet%test_unit \"json roundtrip\" =\n let open Fields_derivers_zkapps.Derivers in\n let full = o () in\n let _a = deriver full in\n [%test_eq: t] user_default (user_default |> to_json full |> of_json full)\n\nlet%test_unit \"json value\" =\n let open Fields_derivers_zkapps.Derivers in\n let full = o () in\n let _a = deriver full in\n [%test_eq: string]\n (user_default |> to_json full |> Yojson.Safe.to_string)\n ( {json|{\n editState: \"Signature\",\n access: \"None\",\n send: \"Signature\",\n receive: \"None\",\n setDelegate: \"Signature\",\n setPermissions: \"Signature\",\n setVerificationKey: \"Signature\",\n setZkappUri: \"Signature\",\n editActionState: \"Signature\",\n setTokenSymbol: \"Signature\",\n incrementNonce: \"Signature\",\n setVotingFor: \"Signature\",\n setTiming: \"Signature\"\n }|json}\n |> Yojson.Safe.from_string |> Yojson.Safe.to_string )\n","(* signed_command_memo.ml *)\n\n[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Snark_params\n\n(** See documentation of the {!Mina_wire_types} library *)\nmodule Wire_types = Mina_wire_types.Mina_base.Signed_command_memo\n\nmodule Make_sig (A : Wire_types.Types.S) = struct\n module type S = Signed_command_memo_intf.S with type t = A.V1.t\nend\n\nmodule Make_str (_ : Wire_types.Concrete) = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n [@@@with_all_version_tags]\n\n type t = string [@@deriving sexp, equal, compare, hash]\n\n let to_latest = Fn.id\n\n module Base58_check = Base58_check.Make (struct\n let description = \"User command memo\"\n\n let version_byte = Base58_check.Version_bytes.user_command_memo\n end)\n\n let to_base58_check (memo : t) : string = Base58_check.encode memo\n\n let of_base58_check (s : string) : t Or_error.t = Base58_check.decode s\n\n let of_base58_check_exn (s : string) : t = Base58_check.decode_exn s\n\n module T = struct\n type nonrec t = t\n\n let to_string = to_base58_check\n\n let of_string = of_base58_check_exn\n end\n\n include Codable.Make_of_string (T)\n end\n end]\n\n [%%define_locally\n Stable.Latest.\n (to_yojson, of_yojson, to_base58_check, of_base58_check, of_base58_check_exn)]\n\n exception Too_long_user_memo_input\n\n exception Too_long_digestible_string\n\n let max_digestible_string_length = 1000\n\n (* 0th byte is a tag to distinguish digests from other data\n 1st byte is length, always 32 for digests\n bytes 2 to 33 are data, 0-right-padded if length is less than 32\n *)\n\n let digest_tag = '\\x00'\n\n let bytes_tag = '\\x01'\n\n let tag_index = 0\n\n let length_index = 1\n\n let digest_length = Blake2.digest_size_in_bytes\n\n let digest_length_byte = Char.of_int_exn digest_length\n\n (* +2 for tag and length bytes *)\n let memo_length = digest_length + 2\n\n let max_input_length = digest_length\n\n let tag (memo : t) = memo.[tag_index]\n\n let length memo = Char.to_int memo.[length_index]\n\n let is_bytes memo = Char.equal (tag memo) bytes_tag\n\n let is_digest memo = Char.equal (tag memo) digest_tag\n\n let is_valid memo =\n Int.(String.length memo = memo_length)\n &&\n let length = length memo in\n if is_digest memo then Int.(length = digest_length)\n else\n Char.equal (tag memo) bytes_tag\n && Int.(length <= digest_length)\n &&\n let padded =\n String.sub memo ~pos:(length + 2) ~len:(digest_length - length)\n in\n String.for_all padded ~f:(Char.equal '\\x00')\n\n let create_by_digesting_string_exn s =\n if Int.(String.length s > max_digestible_string_length) then\n raise Too_long_digestible_string ;\n let digest = Blake2.(to_raw_string (digest_string s)) in\n String.init memo_length ~f:(fun ndx ->\n if Int.(ndx = tag_index) then digest_tag\n else if Int.(ndx = length_index) then digest_length_byte\n else digest.[ndx - 2] )\n\n let create_by_digesting_string (s : string) =\n try Ok (create_by_digesting_string_exn s)\n with Too_long_digestible_string ->\n Or_error.error_string \"create_by_digesting_string: string too long\"\n\n module type Memoable = sig\n type t\n\n val length : t -> int\n\n val get : t -> int -> char\n end\n\n let create_from_value_exn (type t) (module M : Memoable with type t = t)\n (value : t) =\n let len = M.length value in\n if Int.(len > max_input_length) then raise Too_long_user_memo_input ;\n String.init memo_length ~f:(fun ndx ->\n if Int.(ndx = tag_index) then bytes_tag\n else if Int.(ndx = length_index) then Char.of_int_exn len\n else if Int.(ndx < len + 2) then M.get value (ndx - 2)\n else '\\x00' )\n\n let create_from_bytes_exn bytes = create_from_value_exn (module Bytes) bytes\n\n let create_from_bytes bytes =\n try Ok (create_from_bytes_exn bytes)\n with Too_long_user_memo_input ->\n Or_error.error_string\n (sprintf \"create_from_bytes: length exceeds %d\" max_input_length)\n\n let create_from_string_exn s = create_from_value_exn (module String) s\n\n let create_from_string s =\n try Ok (create_from_string_exn s)\n with Too_long_user_memo_input ->\n Or_error.error_string\n (sprintf \"create_from_string: length exceeds %d\" max_input_length)\n\n let dummy = (create_by_digesting_string_exn \"\" :> t)\n\n let empty = create_from_string_exn \"\"\n\n type raw = Digest of string | Bytes of string\n\n let to_raw_exn memo =\n let tag = tag memo in\n if Char.equal tag digest_tag then Digest (to_base58_check memo)\n else if Char.equal tag bytes_tag then\n let len = length memo in\n Bytes (String.init len ~f:(fun idx -> memo.[idx - 2]))\n else failwithf \"Unknown memo tag %c\" tag ()\n\n let to_raw_bytes_exn memo =\n match to_raw_exn memo with\n | Digest _ ->\n failwith \"Cannot convert a digest to raw bytes\"\n | Bytes str ->\n str\n\n let of_raw_exn = function\n | Digest base58_check ->\n of_base58_check_exn base58_check\n | Bytes str ->\n of_base58_check_exn str\n\n let fold_bits t =\n { Fold_lib.Fold.fold =\n (fun ~init ~f ->\n let n = 8 * String.length t in\n let rec go acc i =\n if i = n then acc\n else\n let b = (Char.to_int t.[i / 8] lsr (i mod 8)) land 1 = 1 in\n go (f acc b) (i + 1)\n in\n go init 0 )\n }\n\n let to_bits t = Fold_lib.Fold.to_list (fold_bits t)\n\n let gen =\n Quickcheck.Generator.map String.quickcheck_generator\n ~f:create_by_digesting_string_exn\n\n let hash memo =\n Random_oracle.hash ~init:Hash_prefix.zkapp_memo\n (Random_oracle.Legacy.pack_input\n (Random_oracle_input.Legacy.bitstring (to_bits memo)) )\n\n let to_plaintext (memo : t) : string Or_error.t =\n if is_bytes memo then Ok (String.sub memo ~pos:2 ~len:(length memo))\n else Error (Error.of_string \"Memo does not contain text bytes\")\n\n let to_digest (memo : t) : string Or_error.t =\n if is_digest memo then Ok (String.sub memo ~pos:2 ~len:digest_length)\n else Error (Error.of_string \"Memo does not contain a digest\")\n\n let to_string_hum (memo : t) =\n match to_plaintext memo with\n | Ok text ->\n text\n | Error _ -> (\n match to_digest memo with\n | Ok digest ->\n sprintf \"0x%s\" (Hex.encode digest)\n | Error _ ->\n \"(Invalid memo, neither text nor a digest)\" )\n\n [%%ifdef consensus_mechanism]\n\n module Boolean = Tick.Boolean\n module Typ = Tick.Typ\n\n (* the code below is much the same as in Random_oracle.Digest; tag and length bytes\n make it a little different\n *)\n\n module Checked = struct\n type unchecked = t\n\n type t = Boolean.var array\n\n let constant unchecked =\n assert (Int.(String.length (unchecked :> string) = memo_length)) ;\n Array.map\n (Blake2.string_to_bits (unchecked :> string))\n ~f:Boolean.var_of_value\n end\n\n let length_in_bits = 8 * memo_length\n\n let typ : (Checked.t, t) Typ.t =\n Typ.transport\n (Typ.array ~length:length_in_bits Boolean.typ)\n ~there:(fun (t : t) -> Blake2.string_to_bits (t :> string))\n ~back:(fun bs -> (Blake2.bits_to_string bs :> t))\n\n [%%endif]\n\n let deriver obj =\n Fields_derivers_zkapps.iso_string obj ~name:\"Memo\" ~js_type:String\n ~to_string:to_base58_check ~of_string:of_base58_check_exn\n\n let%test_module \"user_command_memo\" =\n ( module struct\n let data memo = String.sub memo ~pos:(length_index + 1) ~len:(length memo)\n\n let%test \"digest string\" =\n let s = \"this is a string\" in\n let memo = create_by_digesting_string_exn s in\n is_valid memo\n\n let%test \"digest too-long string\" =\n let s =\n String.init (max_digestible_string_length + 1) ~f:(fun _ -> '\\xFF')\n in\n try\n let (_ : t) = create_by_digesting_string_exn s in\n false\n with Too_long_digestible_string -> true\n\n let%test \"memo from string\" =\n let s = \"time and tide wait for no one\" in\n let memo = create_from_string_exn s in\n is_valid memo && String.equal s (data memo)\n\n let%test \"memo from too-long string\" =\n let s = String.init (max_input_length + 1) ~f:(fun _ -> '\\xFF') in\n try\n let (_ : t) = create_from_string_exn s in\n false\n with Too_long_user_memo_input -> true\n\n [%%ifdef consensus_mechanism]\n\n let%test_unit \"typ is identity\" =\n let s = \"this is a string\" in\n let memo = create_by_digesting_string_exn s in\n let read_constant = function\n | Snarky_backendless.Cvar.Constant x ->\n x\n | _ ->\n assert false\n in\n let (Typ typ) = typ in\n let memo_var =\n memo |> typ.value_to_fields\n |> (fun (arr, aux) ->\n ( Array.map arr ~f:(fun x -> Snarky_backendless.Cvar.Constant x)\n , aux ) )\n |> typ.var_of_fields\n in\n let memo_read =\n memo_var |> typ.var_to_fields\n |> (fun (arr, aux) ->\n (Array.map arr ~f:(fun x -> read_constant x), aux) )\n |> typ.value_of_fields\n in\n [%test_eq: string] memo memo_read\n\n [%%endif]\n end )\nend\n\ninclude Wire_types.Make (Make_sig) (Make_str)\n","(* stake_delegation.ml *)\n\nopen Core_kernel\nopen Signature_lib\n\n[%%versioned\nmodule Stable = struct\n module V2 = struct\n [@@@with_all_version_tags]\n\n type t = Mina_wire_types.Mina_base.Stake_delegation.V2.t =\n | Set_delegate of { new_delegate : Public_key.Compressed.Stable.V1.t }\n [@@deriving compare, equal, sexp, hash, yojson]\n\n let to_latest = Fn.id\n end\n\n module V1 = struct\n [@@@with_all_version_tags]\n\n type t = Mina_wire_types.Mina_base.Stake_delegation.V1.t =\n | Set_delegate of\n { delegator : Public_key.Compressed.Stable.V1.t\n ; new_delegate : Public_key.Compressed.Stable.V1.t\n }\n [@@deriving compare, equal, sexp, hash, yojson]\n\n let to_latest (Set_delegate { delegator = _; new_delegate }) =\n V2.Set_delegate { new_delegate }\n end\nend]\n\nlet receiver_pk = function Set_delegate { new_delegate } -> new_delegate\n\nlet receiver = function\n | Set_delegate { new_delegate } ->\n Account_id.create new_delegate Token_id.default\n\nlet gen =\n Quickcheck.Generator.map Public_key.Compressed.gen ~f:(fun k ->\n Set_delegate { new_delegate = k } )\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\n\nmodule Failure = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t = Mina_wire_types.Mina_base.Transaction_status.Failure.V2.t =\n | Predicate [@value 1]\n | Source_not_present\n | Receiver_not_present\n | Amount_insufficient_to_create_account\n | Cannot_pay_creation_fee_in_token\n | Source_insufficient_balance\n | Source_minimum_balance_violation\n | Receiver_already_exists\n | Token_owner_not_caller\n | Overflow\n | Global_excess_overflow\n | Local_excess_overflow\n | Local_supply_increase_overflow\n | Global_supply_increase_overflow\n | Signed_command_on_zkapp_account\n | Zkapp_account_not_present\n | Update_not_permitted_balance\n | Update_not_permitted_access\n | Update_not_permitted_timing\n | Update_not_permitted_delegate\n | Update_not_permitted_app_state\n | Update_not_permitted_verification_key\n | Update_not_permitted_action_state\n | Update_not_permitted_zkapp_uri\n | Update_not_permitted_token_symbol\n | Update_not_permitted_permissions\n | Update_not_permitted_nonce\n | Update_not_permitted_voting_for\n | Zkapp_command_replay_check_failed\n | Fee_payer_nonce_must_increase\n | Fee_payer_must_be_signed\n | Account_balance_precondition_unsatisfied\n | Account_nonce_precondition_unsatisfied\n | Account_receipt_chain_hash_precondition_unsatisfied\n | Account_delegate_precondition_unsatisfied\n | Account_action_state_precondition_unsatisfied\n | Account_app_state_precondition_unsatisfied of int\n | Account_proved_state_precondition_unsatisfied\n | Account_is_new_precondition_unsatisfied\n | Protocol_state_precondition_unsatisfied\n | Unexpected_verification_key_hash\n | Valid_while_precondition_unsatisfied\n | Incorrect_nonce\n | Invalid_fee_excess\n | Cancelled\n [@@deriving sexp, yojson, equal, compare, variants, hash]\n\n let to_latest = Fn.id\n end\n end]\n\n module Collection = struct\n module Display = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = (int * Stable.V2.t list) list\n [@@deriving equal, compare, yojson, sexp, hash]\n\n let to_latest = Fn.id\n end\n end]\n end\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Stable.V2.t list list\n [@@deriving equal, compare, yojson, sexp, hash]\n\n let to_latest = Fn.id\n end\n end]\n\n let to_display t : Display.t =\n let _, display =\n List.fold_left t ~init:(0, []) ~f:(fun (index, acc) bucket ->\n if List.is_empty bucket then (index + 1, acc)\n else (index + 1, (index, bucket) :: acc) )\n in\n display\n\n let empty = []\n\n let of_single_failure f : t = [ [ f ] ]\n\n let is_empty : t -> bool = Fn.compose List.is_empty List.concat\n end\n\n type failure = t\n\n let failure_min = min\n\n let failure_max = max\n\n let all =\n let add acc var = var.Variantslib.Variant.constructor :: acc in\n Variants.fold ~init:[] ~predicate:add ~source_not_present:add\n ~receiver_not_present:add ~amount_insufficient_to_create_account:add\n ~cannot_pay_creation_fee_in_token:add ~source_insufficient_balance:add\n ~source_minimum_balance_violation:add ~receiver_already_exists:add\n ~token_owner_not_caller:add ~overflow:add ~global_excess_overflow:add\n ~local_excess_overflow:add ~local_supply_increase_overflow:add\n ~global_supply_increase_overflow:add ~signed_command_on_zkapp_account:add\n ~zkapp_account_not_present:add ~update_not_permitted_balance:add\n ~update_not_permitted_timing:add ~update_not_permitted_access:add\n ~update_not_permitted_delegate:add ~update_not_permitted_app_state:add\n ~update_not_permitted_verification_key:add\n ~update_not_permitted_action_state:add ~update_not_permitted_zkapp_uri:add\n ~update_not_permitted_token_symbol:add\n ~update_not_permitted_permissions:add ~update_not_permitted_nonce:add\n ~update_not_permitted_voting_for:add\n ~zkapp_command_replay_check_failed:add ~fee_payer_nonce_must_increase:add\n ~fee_payer_must_be_signed:add\n ~account_balance_precondition_unsatisfied:add\n ~account_nonce_precondition_unsatisfied:add\n ~account_receipt_chain_hash_precondition_unsatisfied:add\n ~account_delegate_precondition_unsatisfied:add\n ~account_action_state_precondition_unsatisfied:add\n ~account_app_state_precondition_unsatisfied:(fun acc var ->\n List.init 8 ~f:var.constructor @ acc )\n ~account_proved_state_precondition_unsatisfied:add\n ~account_is_new_precondition_unsatisfied:add\n ~protocol_state_precondition_unsatisfied:add\n ~valid_while_precondition_unsatisfied:add\n ~unexpected_verification_key_hash:add ~incorrect_nonce:add\n ~invalid_fee_excess:add ~cancelled:add\n\n let gen = Quickcheck.Generator.of_list all\n\n let to_string = function\n | Predicate ->\n \"Predicate\"\n | Source_not_present ->\n \"Source_not_present\"\n | Receiver_not_present ->\n \"Receiver_not_present\"\n | Amount_insufficient_to_create_account ->\n \"Amount_insufficient_to_create_account\"\n | Cannot_pay_creation_fee_in_token ->\n \"Cannot_pay_creation_fee_in_token\"\n | Source_insufficient_balance ->\n \"Source_insufficient_balance\"\n | Source_minimum_balance_violation ->\n \"Source_minimum_balance_violation\"\n | Receiver_already_exists ->\n \"Receiver_already_exists\"\n | Token_owner_not_caller ->\n \"Token_owner_not_caller\"\n | Overflow ->\n \"Overflow\"\n | Global_excess_overflow ->\n \"Global_excess_overflow\"\n | Local_excess_overflow ->\n \"Local_excess_overflow\"\n | Local_supply_increase_overflow ->\n \"Local_supply_increase_overflow\"\n | Global_supply_increase_overflow ->\n \"Global_supply_increase_overflow\"\n | Signed_command_on_zkapp_account ->\n \"Signed_command_on_zkapp_account\"\n | Zkapp_account_not_present ->\n \"Zkapp_account_not_present\"\n | Update_not_permitted_balance ->\n \"Update_not_permitted_balance\"\n | Update_not_permitted_access ->\n \"Update_not_permitted_access\"\n | Update_not_permitted_timing ->\n \"Update_not_permitted_timing\"\n | Update_not_permitted_delegate ->\n \"update_not_permitted_delegate\"\n | Update_not_permitted_app_state ->\n \"Update_not_permitted_app_state\"\n | Update_not_permitted_verification_key ->\n \"Update_not_permitted_verification_key\"\n | Update_not_permitted_action_state ->\n \"Update_not_permitted_action_state\"\n | Update_not_permitted_zkapp_uri ->\n \"Update_not_permitted_zkapp_uri\"\n | Update_not_permitted_token_symbol ->\n \"Update_not_permitted_token_symbol\"\n | Update_not_permitted_permissions ->\n \"Update_not_permitted_permissions\"\n | Update_not_permitted_nonce ->\n \"Update_not_permitted_nonce\"\n | Update_not_permitted_voting_for ->\n \"Update_not_permitted_voting_for\"\n | Zkapp_command_replay_check_failed ->\n \"Zkapp_command_replay_check_failed\"\n | Fee_payer_nonce_must_increase ->\n \"Fee_payer_nonce_must_increase\"\n | Fee_payer_must_be_signed ->\n \"Fee_payer_must_be_signed\"\n | Account_balance_precondition_unsatisfied ->\n \"Account_balance_precondition_unsatisfied\"\n | Account_nonce_precondition_unsatisfied ->\n \"Account_nonce_precondition_unsatisfied\"\n | Account_receipt_chain_hash_precondition_unsatisfied ->\n \"Account_receipt_chain_hash_precondition_unsatisfied\"\n | Account_delegate_precondition_unsatisfied ->\n \"Account_delegate_precondition_unsatisfied\"\n | Account_action_state_precondition_unsatisfied ->\n \"Account_action_state_precondition_unsatisfied\"\n | Account_app_state_precondition_unsatisfied i ->\n sprintf \"Account_app_state_%i_precondition_unsatisfied\" i\n | Account_proved_state_precondition_unsatisfied ->\n \"Account_proved_state_precondition_unsatisfied\"\n | Account_is_new_precondition_unsatisfied ->\n \"Account_is_new_precondition_unsatisfied\"\n | Protocol_state_precondition_unsatisfied ->\n \"Protocol_state_precondition_unsatisfied\"\n | Valid_while_precondition_unsatisfied ->\n \"Valid_while_precondition_unsatisfied\"\n | Unexpected_verification_key_hash ->\n \"Unexpected_verification_key_hash\"\n | Incorrect_nonce ->\n \"Incorrect_nonce\"\n | Invalid_fee_excess ->\n \"Invalid_fee_excess\"\n | Cancelled ->\n \"Cancelled\"\n\n let of_string = function\n | \"Predicate\" ->\n Ok Predicate\n | \"Source_not_present\" ->\n Ok Source_not_present\n | \"Receiver_not_present\" ->\n Ok Receiver_not_present\n | \"Amount_insufficient_to_create_account\" ->\n Ok Amount_insufficient_to_create_account\n | \"Cannot_pay_creation_fee_in_token\" ->\n Ok Cannot_pay_creation_fee_in_token\n | \"Source_insufficient_balance\" ->\n Ok Source_insufficient_balance\n | \"Source_minimum_balance_violation\" ->\n Ok Source_minimum_balance_violation\n | \"Receiver_already_exists\" ->\n Ok Receiver_already_exists\n | \"Token_owner_not_caller\" ->\n Ok Token_owner_not_caller\n | \"Overflow\" ->\n Ok Overflow\n | \"Global_excess_overflow\" ->\n Ok Global_excess_overflow\n | \"Local_excess_overflow\" ->\n Ok Local_excess_overflow\n | \"Local_supply_increase_overflow\" ->\n Ok Local_supply_increase_overflow\n | \"Global_supply_increase_overflow\" ->\n Ok Global_supply_increase_overflow\n | \"Signed_command_on_zkapp_account\" ->\n Ok Signed_command_on_zkapp_account\n | \"Zkapp_account_not_present\" ->\n Ok Zkapp_account_not_present\n | \"Update_not_permitted_balance\" ->\n Ok Update_not_permitted_balance\n | \"Update_not_permitted_access\" ->\n Ok Update_not_permitted_access\n | \"Update_not_permitted_timing\" ->\n Ok Update_not_permitted_timing\n | \"update_not_permitted_delegate\" ->\n Ok Update_not_permitted_delegate\n | \"Update_not_permitted_app_state\" ->\n Ok Update_not_permitted_app_state\n | \"Update_not_permitted_verification_key\" ->\n Ok Update_not_permitted_verification_key\n | \"Update_not_permitted_action_state\" ->\n Ok Update_not_permitted_action_state\n | \"Update_not_permitted_zkapp_uri\" ->\n Ok Update_not_permitted_zkapp_uri\n | \"Update_not_permitted_token_symbol\" ->\n Ok Update_not_permitted_token_symbol\n | \"Update_not_permitted_permissions\" ->\n Ok Update_not_permitted_permissions\n | \"Update_not_permitted_nonce\" ->\n Ok Update_not_permitted_nonce\n | \"Update_not_permitted_voting_for\" ->\n Ok Update_not_permitted_voting_for\n | \"Zkapp_command_replay_check_failed\" ->\n Ok Zkapp_command_replay_check_failed\n | \"Fee_payer_nonce_must_increase\" ->\n Ok Fee_payer_nonce_must_increase\n | \"Fee_payer_must_be_signed\" ->\n Ok Fee_payer_must_be_signed\n | \"Account_balance_precondition_unsatisfied\" ->\n Ok Account_balance_precondition_unsatisfied\n | \"Account_nonce_precondition_unsatisfied\" ->\n Ok Account_nonce_precondition_unsatisfied\n | \"Account_receipt_chain_hash_precondition_unsatisfied\" ->\n Ok Account_receipt_chain_hash_precondition_unsatisfied\n | \"Account_delegate_precondition_unsatisfied\" ->\n Ok Account_delegate_precondition_unsatisfied\n | \"Account_action_state_precondition_unsatisfied\" ->\n Ok Account_action_state_precondition_unsatisfied\n | \"Account_proved_state_precondition_unsatisfied\" ->\n Ok Account_proved_state_precondition_unsatisfied\n | \"Account_is_new_precondition_unsatisfied\" ->\n Ok Account_is_new_precondition_unsatisfied\n | \"Protocol_state_precondition_unsatisfied\" ->\n Ok Protocol_state_precondition_unsatisfied\n | \"Valid_while_precondition_unsatisfied\" ->\n Ok Valid_while_precondition_unsatisfied\n | \"Unexpected_verification_key_hash\" ->\n Ok Unexpected_verification_key_hash\n | \"Incorrect_nonce\" ->\n Ok Incorrect_nonce\n | \"Invalid_fee_excess\" ->\n Ok Invalid_fee_excess\n | \"Cancelled\" ->\n Ok Cancelled\n | str -> (\n let res =\n List.find_map\n ~f:(fun (prefix, suffix, parse) ->\n Option.try_with (fun () ->\n assert (\n String.length str\n >= String.length prefix + String.length suffix ) ;\n for i = 0 to String.length prefix - 1 do\n assert (Char.equal prefix.[i] str.[i])\n done ;\n let offset = String.length str - String.length suffix in\n for i = 0 to String.length suffix - 1 do\n assert (Char.equal suffix.[i] str.[offset + i])\n done ;\n parse\n (String.sub str ~pos:(String.length prefix)\n ~len:(offset - String.length prefix) ) ) )\n [ ( \"Account_app_state_\"\n , \"_precondition_unsatisfied\"\n , fun str ->\n Account_app_state_precondition_unsatisfied (int_of_string str)\n )\n ]\n in\n match res with\n | Some res ->\n Ok res\n | None ->\n Error \"Transaction_status.Failure.of_string: Unknown value\" )\n\n let%test_unit \"of_string(to_string) roundtrip\" =\n List.iter all ~f:(fun failure ->\n [%test_eq: (t, string) Result.t]\n (of_string (to_string failure))\n (Ok failure) )\n\n let describe = function\n | Predicate ->\n \"A predicate failed\"\n | Source_not_present ->\n \"The source account does not exist\"\n | Receiver_not_present ->\n \"The receiver account does not exist\"\n | Amount_insufficient_to_create_account ->\n \"Cannot create account: transaction amount is smaller than the account \\\n creation fee\"\n | Cannot_pay_creation_fee_in_token ->\n \"Cannot create account: account creation fees cannot be paid in \\\n non-default tokens\"\n | Source_insufficient_balance ->\n \"The source account has an insufficient balance\"\n | Source_minimum_balance_violation ->\n \"The source account requires a minimum balance\"\n | Receiver_already_exists ->\n \"Attempted to create an account that already exists\"\n | Token_owner_not_caller ->\n \"An account update used a non-default token but its caller was not the \\\n token owner\"\n | Overflow ->\n \"The resulting balance is too large to store\"\n | Global_excess_overflow ->\n \"The resulting global fee excess is too large to store\"\n | Local_excess_overflow ->\n \"The resulting local fee excess is too large to store\"\n | Local_supply_increase_overflow ->\n \"The resulting local supply increase is too large to store\"\n | Global_supply_increase_overflow ->\n \"The resulting global supply increase is too large to store\"\n | Signed_command_on_zkapp_account ->\n \"The source of a signed command cannot be a snapp account\"\n | Zkapp_account_not_present ->\n \"A zkApp account does not exist\"\n | Update_not_permitted_balance ->\n \"The authentication for an account didn't allow the requested update \\\n to its balance\"\n | Update_not_permitted_access ->\n \"The authentication for an account didn't allow it to be accessed\"\n | Update_not_permitted_timing ->\n \"The authentication for an account didn't allow the requested update \\\n to its timing\"\n | Update_not_permitted_delegate ->\n \"The authentication for an account didn't allow the requested update \\\n to its delegate\"\n | Update_not_permitted_app_state ->\n \"The authentication for an account didn't allow the requested update \\\n to its app state\"\n | Update_not_permitted_verification_key ->\n \"The authentication for an account didn't allow the requested update \\\n to its verification key\"\n | Update_not_permitted_action_state ->\n \"The authentication for an account didn't allow the requested update \\\n to its action state\"\n | Update_not_permitted_zkapp_uri ->\n \"The authentication for an account didn't allow the requested update \\\n to its snapp URI\"\n | Update_not_permitted_token_symbol ->\n \"The authentication for an account didn't allow the requested update \\\n to its token symbol\"\n | Update_not_permitted_permissions ->\n \"The authentication for an account didn't allow the requested update \\\n to its permissions\"\n | Update_not_permitted_nonce ->\n \"The authentication for an account didn't allow the requested update \\\n to its nonce\"\n | Update_not_permitted_voting_for ->\n \"The authentication for an account didn't allow the requested update \\\n to its voted-for state hash\"\n | Zkapp_command_replay_check_failed ->\n \"Check to avoid replays failed. The account update must increment \\\n nonce or use full commitment if the authorization is a signature\"\n | Fee_payer_nonce_must_increase ->\n \"Fee payer account update must increment its nonce\"\n | Fee_payer_must_be_signed ->\n \"Fee payer account update must have a valid signature\"\n | Account_balance_precondition_unsatisfied ->\n \"The account update's account balance precondition was unsatisfied\"\n | Account_nonce_precondition_unsatisfied ->\n \"The account update's account nonce precondition was unsatisfied\"\n | Account_receipt_chain_hash_precondition_unsatisfied ->\n \"The account update's account receipt-chain hash precondition was \\\n unsatisfied\"\n | Account_delegate_precondition_unsatisfied ->\n \"The account update's account delegate precondition was unsatisfied\"\n | Account_action_state_precondition_unsatisfied ->\n \"The account update's account action state precondition was unsatisfied\"\n | Account_app_state_precondition_unsatisfied i ->\n sprintf\n \"The account update's account app state (%i) precondition was \\\n unsatisfied\"\n i\n | Account_proved_state_precondition_unsatisfied ->\n \"The account update's account proved state precondition was unsatisfied\"\n | Account_is_new_precondition_unsatisfied ->\n \"The account update's account is-new state precondition was unsatisfied\"\n | Protocol_state_precondition_unsatisfied ->\n \"The account update's protocol state precondition unsatisfied\"\n | Valid_while_precondition_unsatisfied ->\n \"The account update's valid-until precondition was unsatisfied\"\n | Unexpected_verification_key_hash ->\n \"The account update's verification key hash does not match the \\\n verification key in the ledger account\"\n | Incorrect_nonce ->\n \"Incorrect nonce\"\n | Invalid_fee_excess ->\n \"Fee excess from zkapp_command transaction more than the transaction \\\n fees\"\n | Cancelled ->\n \"The account update is cancelled because there's a failure in the \\\n zkApp transaction\"\nend\n\n[%%versioned\nmodule Stable = struct\n module V2 = struct\n type t = Mina_wire_types.Mina_base.Transaction_status.V2.t =\n | Applied\n | Failed of Failure.Collection.Stable.V1.t\n [@@deriving sexp, yojson, equal, compare]\n\n let to_latest = Fn.id\n end\nend]\n","(* transaction_union_tag.ml *)\n\n[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\n\n[%%ifdef consensus_mechanism]\n\nopen Snark_params.Tick\n\n[%%else]\n\nopen Mina_base_import\n\n[%%endif]\n\ntype t = Payment | Stake_delegation | Fee_transfer | Coinbase\n[@@deriving enum, equal, sexp]\n\nlet to_string = function\n | Payment ->\n \"payment\"\n | Stake_delegation ->\n \"delegation\"\n | Fee_transfer ->\n \"fee-transfer\"\n | Coinbase ->\n \"coinbase\"\n\nlet gen =\n Quickcheck.Generator.map (Int.gen_incl min max) ~f:(fun i ->\n Option.value_exn (of_enum i) )\n\nmodule Bits = struct\n type t = bool * bool * bool [@@deriving equal]\n\n let of_int i : t =\n let test_mask mask = i land mask = mask in\n (test_mask 0b100, test_mask 0b10, test_mask 0b1)\n\n let of_t x = of_int (to_enum x)\n\n let payment = of_t Payment\n\n let stake_delegation = of_t Stake_delegation\n\n let fee_transfer = of_t Fee_transfer\n\n let coinbase = of_t Coinbase\n\n let to_bits (b1, b2, b3) = [ b1; b2; b3 ]\n\n let to_input_legacy t = Random_oracle.Input.Legacy.bitstring (to_bits t)\n\n [%%ifdef consensus_mechanism]\n\n type var = Boolean.var * Boolean.var * Boolean.var\n\n let typ = Typ.tuple3 Boolean.typ Boolean.typ Boolean.typ\n\n let constant (b1, b2, b3) =\n Boolean.(var_of_value b1, var_of_value b2, var_of_value b3)\n\n [%%endif]\nend\n\nmodule Unpacked = struct\n (* Invariant: exactly one of the tag identifiers must be true. *)\n module Poly = struct\n type 'bool t =\n { is_payment : 'bool\n ; is_stake_delegation : 'bool\n ; is_fee_transfer : 'bool\n ; is_coinbase : 'bool\n ; is_user_command : 'bool\n }\n [@@deriving equal, hlist]\n\n [%%ifdef consensus_mechanism]\n\n let typ (bool : ('bool_var, 'bool) Typ.t) : ('bool_var t, 'bool t) Typ.t =\n Typ.of_hlistable\n [ bool; bool; bool; bool; bool ]\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist\n\n [%%endif]\n end\n\n type t = bool Poly.t [@@deriving equal]\n\n (* An invalid value with all types empty. Do not use directly. *)\n let empty : t =\n { is_payment = false\n ; is_stake_delegation = false\n ; is_fee_transfer = false\n ; is_coinbase = false\n ; is_user_command = false\n }\n\n let payment = { empty with is_payment = true; is_user_command = true }\n\n let stake_delegation =\n { empty with is_stake_delegation = true; is_user_command = true }\n\n let fee_transfer =\n { empty with is_fee_transfer = true; is_user_command = false }\n\n let coinbase = { empty with is_coinbase = true; is_user_command = false }\n\n let of_bits_t (bits : Bits.t) : t =\n match\n List.Assoc.find ~equal:Bits.equal\n [ (Bits.payment, payment)\n ; (Bits.stake_delegation, stake_delegation)\n ; (Bits.fee_transfer, fee_transfer)\n ; (Bits.coinbase, coinbase)\n ]\n bits\n with\n | Some t ->\n t\n | None ->\n raise (Invalid_argument \"Transaction_union_tag.Unpacked.of_bits_t\")\n\n let to_bits_t (t : t) : Bits.t =\n match\n List.Assoc.find ~equal\n [ (payment, Bits.payment)\n ; (stake_delegation, Bits.stake_delegation)\n ; (fee_transfer, Bits.fee_transfer)\n ; (coinbase, Bits.coinbase)\n ]\n t\n with\n | Some bits ->\n bits\n | None ->\n raise (Invalid_argument \"Transaction_union_tag.Unpacked.to_bits_t\")\n\n [%%ifdef consensus_mechanism]\n\n type var = Boolean.var Poly.t\n\n let to_bits_var\n ({ is_payment\n ; is_stake_delegation\n ; is_fee_transfer\n ; is_coinbase\n ; is_user_command = _\n } :\n var ) =\n (* For each bit, compute the sum of all the tags for which that bit is true\n in its bit representation.\n\n Since we have the invariant that exactly one tag identifier is true,\n exactly the bits in that tag's bit representation will be true in the\n resulting bits.\n *)\n let b1, b2, b3 =\n List.fold\n ~init:Field.(Var.(constant zero, constant zero, constant zero))\n [ (Bits.payment, is_payment)\n ; (Bits.stake_delegation, is_stake_delegation)\n ; (Bits.fee_transfer, is_fee_transfer)\n ; (Bits.coinbase, is_coinbase)\n ]\n ~f:(fun (acc1, acc2, acc3) ((bit1, bit2, bit3), bool_var) ->\n let add_if_true bit acc =\n if bit then Field.Var.add acc (bool_var :> Field.Var.t) else acc\n in\n (add_if_true bit1 acc1, add_if_true bit2 acc2, add_if_true bit3 acc3)\n )\n in\n Boolean.Unsafe.(of_cvar b1, of_cvar b2, of_cvar b3)\n\n let typ : (var, t) Typ.t =\n let (Typ base_typ) = Poly.typ Boolean.typ in\n Typ\n { base_typ with\n check =\n (fun ( { is_payment\n ; is_stake_delegation\n ; is_fee_transfer\n ; is_coinbase\n ; is_user_command\n } as t ) ->\n let open Checked.Let_syntax in\n let%bind () = base_typ.check t in\n let%bind () =\n [%with_label_ \"Only one tag is set\"] (fun () ->\n Boolean.Assert.exactly_one\n [ is_payment\n ; is_stake_delegation\n ; is_fee_transfer\n ; is_coinbase\n ] )\n in\n [%with_label_ \"User command flag is correctly set\"] (fun () ->\n Boolean.Assert.exactly_one\n [ is_user_command; is_fee_transfer; is_coinbase ] ) )\n }\n\n let constant\n ({ is_payment\n ; is_stake_delegation\n ; is_fee_transfer\n ; is_coinbase\n ; is_user_command\n } :\n t ) : var =\n { is_payment = Boolean.var_of_value is_payment\n ; is_stake_delegation = Boolean.var_of_value is_stake_delegation\n ; is_fee_transfer = Boolean.var_of_value is_fee_transfer\n ; is_coinbase = Boolean.var_of_value is_coinbase\n ; is_user_command = Boolean.var_of_value is_user_command\n }\n\n let is_payment ({ is_payment; _ } : var) = is_payment\n\n let is_stake_delegation ({ is_stake_delegation; _ } : var) =\n is_stake_delegation\n\n let is_fee_transfer ({ is_fee_transfer; _ } : var) = is_fee_transfer\n\n let is_coinbase ({ is_coinbase; _ } : var) = is_coinbase\n\n let is_user_command ({ is_user_command; _ } : var) = is_user_command\n\n let to_bits t = Bits.to_bits (to_bits_var t)\n\n let to_input_legacy t = Random_oracle.Input.Legacy.bitstring (to_bits t)\n\n [%%endif]\nend\n\nlet unpacked_t_of_t = function\n | Payment ->\n Unpacked.payment\n | Stake_delegation ->\n Unpacked.stake_delegation\n | Fee_transfer ->\n Unpacked.fee_transfer\n | Coinbase ->\n Unpacked.coinbase\n\nlet to_bits tag = Bits.to_bits (Unpacked.to_bits_t (unpacked_t_of_t tag))\n\nlet to_input_legacy tag = Random_oracle.Input.Legacy.bitstring (to_bits tag)\n\n[%%ifdef consensus_mechanism]\n\nlet t_of_unpacked_t (unpacked : Unpacked.t) : t =\n match\n List.Assoc.find ~equal:Unpacked.equal\n [ (Unpacked.payment, Payment)\n ; (Unpacked.stake_delegation, Stake_delegation)\n ; (Unpacked.fee_transfer, Fee_transfer)\n ; (Unpacked.coinbase, Coinbase)\n ]\n unpacked\n with\n | Some t ->\n t\n | None ->\n raise (Invalid_argument \"Transaction_union_tag.t_of_unpacked_t\")\n\nlet bits_t_of_t tag = Unpacked.to_bits_t (unpacked_t_of_t tag)\n\nlet t_of_bits_t tag = t_of_unpacked_t (Unpacked.of_bits_t tag)\n\nlet unpacked_of_t tag = Unpacked.constant (unpacked_t_of_t tag)\n\nlet bits_of_t tag = Bits.constant (bits_t_of_t tag)\n\nlet unpacked_typ =\n Typ.transport Unpacked.typ ~there:unpacked_t_of_t ~back:t_of_unpacked_t\n\nlet bits_typ = Typ.transport Bits.typ ~there:bits_t_of_t ~back:t_of_bits_t\n\nlet%test_module \"predicates\" =\n ( module struct\n let test_predicate checked unchecked =\n let checked x = Checked.return (checked x) in\n for i = min to max do\n Test_util.test_equal unpacked_typ Boolean.typ checked unchecked\n (Option.value_exn (of_enum i))\n done\n\n let one_of xs t = List.mem xs ~equal t\n\n let%test_unit \"is_payment\" =\n test_predicate Unpacked.is_payment (equal Payment)\n\n let%test_unit \"is_stake_delegation\" =\n test_predicate Unpacked.is_stake_delegation (equal Stake_delegation)\n\n let%test_unit \"is_fee_transfer\" =\n test_predicate Unpacked.is_fee_transfer (equal Fee_transfer)\n\n let%test_unit \"is_coinbase\" =\n test_predicate Unpacked.is_coinbase (equal Coinbase)\n\n let%test_unit \"is_user_command\" =\n test_predicate Unpacked.is_user_command\n (one_of [ Payment; Stake_delegation ])\n\n let%test_unit \"not_user_command\" =\n test_predicate\n (fun x -> Boolean.not (Unpacked.is_user_command x))\n (one_of [ Fee_transfer; Coinbase ])\n\n let%test_unit \"bit_representation\" =\n for i = min to max do\n Test_util.test_equal unpacked_typ Bits.typ\n (Fn.compose Checked.return Unpacked.to_bits_var)\n bits_t_of_t\n (Option.value_exn (of_enum i))\n done\n end )\n\n[%%endif]\n","(* user_command_payload.ml *)\n\n[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Snark_params.Tick\nopen Signature_lib\nmodule Memo = Signed_command_memo\nmodule Account_nonce = Mina_numbers.Account_nonce\nmodule Global_slot_since_genesis = Mina_numbers.Global_slot_since_genesis\nmodule Global_slot_legacy = Mina_numbers.Global_slot_legacy\n\n(* This represents the random oracle input corresponding to the old form of the token\n ID, which was a 64-bit integer. The default token id was the number 1.\n\n The corresponding random oracle input is still needed for signing non-snapp\n transactions to maintain compatibility with the old transaction format.\n*)\nmodule Legacy_token_id = struct\n let default : (Field.t, bool) Random_oracle_input.Legacy.t =\n let one = true :: List.init 63 ~f:(fun _ -> false) in\n Random_oracle_input.Legacy.bitstring one\n\n [%%ifdef consensus_mechanism]\n\n let default_checked : (Field.Var.t, Boolean.var) Random_oracle_input.Legacy.t\n =\n { field_elements = Array.map default.field_elements ~f:Field.Var.constant\n ; bitstrings =\n Array.map default.bitstrings ~f:(List.map ~f:Boolean.var_of_value)\n }\n\n [%%endif]\nend\n\nmodule Common = struct\n module Poly = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type ('fee, 'public_key, 'nonce, 'global_slot, 'memo) t =\n ( 'fee\n , 'public_key\n , 'nonce\n , 'global_slot\n , 'memo )\n Mina_wire_types.Mina_base.Signed_command_payload.Common.Poly.V2.t =\n { fee : 'fee\n ; fee_payer_pk : 'public_key\n ; nonce : 'nonce\n ; valid_until : 'global_slot\n ; memo : 'memo\n }\n [@@deriving compare, equal, sexp, hash, yojson, hlist]\n end\n\n module V1 = struct\n [@@@with_all_version_tags]\n\n type ('fee, 'public_key, 'token_id, 'nonce, 'global_slot, 'memo) t =\n { fee : 'fee\n ; fee_token : 'token_id\n ; fee_payer_pk : 'public_key\n ; nonce : 'nonce\n ; valid_until : 'global_slot\n ; memo : 'memo\n }\n [@@deriving compare, equal, sexp, hash, yojson, hlist]\n end\n end]\n end\n\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t =\n ( Currency.Fee.Stable.V1.t\n , Public_key.Compressed.Stable.V1.t\n , Account_nonce.Stable.V1.t\n , Global_slot_since_genesis.Stable.V1.t\n , Memo.Stable.V1.t )\n Poly.Stable.V2.t\n [@@deriving compare, equal, sexp, hash, yojson]\n\n let to_latest = Fn.id\n end\n\n module V1 = struct\n [@@@with_all_version_tags]\n\n type t =\n ( Currency.Fee.Stable.V1.t\n , Public_key.Compressed.Stable.V1.t\n , Token_id.Stable.V1.t\n , Account_nonce.Stable.V1.t\n , Global_slot_legacy.Stable.V1.t\n , Memo.Stable.V1.t )\n Poly.Stable.V1.t\n [@@deriving compare, equal, sexp, hash, yojson]\n\n let to_latest _ = failwith \"Not implemented\"\n end\n end]\n\n let to_input_legacy ({ fee; fee_payer_pk; nonce; valid_until; memo } : t) =\n let bitstring = Random_oracle.Input.Legacy.bitstring in\n Array.reduce_exn ~f:Random_oracle.Input.Legacy.append\n [| Currency.Fee.to_input_legacy fee\n ; Legacy_token_id.default\n ; Public_key.Compressed.to_input_legacy fee_payer_pk\n ; Account_nonce.to_input_legacy nonce\n ; Global_slot_since_genesis.to_input_legacy valid_until\n ; bitstring (Memo.to_bits memo)\n |]\n\n let gen : t Quickcheck.Generator.t =\n let open Quickcheck.Generator.Let_syntax in\n let%map fee = Currency.Fee.gen\n and fee_payer_pk = Public_key.Compressed.gen\n and nonce = Account_nonce.gen\n and valid_until = Global_slot_since_genesis.gen\n and memo =\n let%bind is_digest = Bool.quickcheck_generator in\n if is_digest then\n String.gen_with_length Memo.max_digestible_string_length\n Char.quickcheck_generator\n >>| Memo.create_by_digesting_string_exn\n else\n String.gen_with_length Memo.max_input_length Char.quickcheck_generator\n >>| Memo.create_from_string_exn\n in\n Poly.{ fee; fee_payer_pk; nonce; valid_until; memo }\n\n [%%ifdef consensus_mechanism]\n\n type var =\n ( Currency.Fee.var\n , Public_key.Compressed.var\n , Account_nonce.Checked.t\n , Global_slot_since_genesis.Checked.t\n , Memo.Checked.t )\n Poly.t\n\n let typ =\n Typ.of_hlistable\n [ Currency.Fee.typ\n ; Public_key.Compressed.typ\n ; Account_nonce.typ\n ; Global_slot_since_genesis.typ\n ; Memo.typ\n ]\n ~var_to_hlist:Poly.to_hlist ~var_of_hlist:Poly.of_hlist\n ~value_to_hlist:Poly.to_hlist ~value_of_hlist:Poly.of_hlist\n\n module Checked = struct\n let constant ({ fee; fee_payer_pk; nonce; valid_until; memo } : t) : var =\n { fee = Currency.Fee.var_of_t fee\n ; fee_payer_pk = Public_key.Compressed.var_of_t fee_payer_pk\n ; nonce = Account_nonce.Checked.constant nonce\n ; memo = Memo.Checked.constant memo\n ; valid_until = Global_slot_since_genesis.Checked.constant valid_until\n }\n\n let to_input_legacy ({ fee; fee_payer_pk; nonce; valid_until; memo } : var)\n =\n let%map nonce = Account_nonce.Checked.to_input_legacy nonce\n and valid_until =\n Global_slot_since_genesis.Checked.to_input_legacy valid_until\n and fee = Currency.Fee.var_to_input_legacy fee in\n let fee_token = Legacy_token_id.default_checked in\n Array.reduce_exn ~f:Random_oracle.Input.Legacy.append\n [| fee\n ; fee_token\n ; Public_key.Compressed.Checked.to_input_legacy fee_payer_pk\n ; nonce\n ; valid_until\n ; Random_oracle.Input.Legacy.bitstring\n (Array.to_list (memo :> Boolean.var array))\n |]\n end\n\n [%%endif]\nend\n\nmodule Body = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t = Mina_wire_types.Mina_base.Signed_command_payload.Body.V2.t =\n | Payment of Payment_payload.Stable.V2.t\n | Stake_delegation of Stake_delegation.Stable.V2.t\n [@@deriving sexp, compare, equal, sexp, hash, yojson]\n\n let to_latest = Fn.id\n end\n\n module V1 = struct\n [@@@with_all_version_tags]\n\n type t =\n | Payment of Payment_payload.Stable.V1.t\n | Stake_delegation of Stake_delegation.Stable.V1.t\n (* omitting token commands, none were ever created\n such omission doesn't affect serialization/Base58Check of payments, delegations\n *)\n [@@deriving sexp, compare, equal, sexp, hash, yojson]\n\n let to_latest _ = failwith \"Not implemented\"\n end\n end]\n\n module Tag = Transaction_union_tag\n\n let gen max_amount =\n let open Quickcheck.Generator in\n map\n (variant2 (Payment_payload.gen max_amount) Stake_delegation.gen)\n ~f:(function `A p -> Payment p | `B d -> Stake_delegation d)\n\n let receiver_pk (t : t) =\n match t with\n | Payment payload ->\n payload.receiver_pk\n | Stake_delegation payload ->\n Stake_delegation.receiver_pk payload\n\n let token (_ : t) = Token_id.default\n\n let receiver t =\n match t with\n | Payment payload ->\n Account_id.create payload.receiver_pk Token_id.default\n | Stake_delegation payload ->\n Stake_delegation.receiver payload\n\n let tag = function\n | Payment _ ->\n Transaction_union_tag.Payment\n | Stake_delegation _ ->\n Transaction_union_tag.Stake_delegation\nend\n\nmodule Poly = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n [@@@with_all_version_tags]\n\n type ('common, 'body) t =\n ( 'common\n , 'body )\n Mina_wire_types.Mina_base.Signed_command_payload.Poly.V1.t =\n { common : 'common; body : 'body }\n [@@deriving equal, sexp, hash, yojson, compare, hlist]\n\n let of_latest common_latest body_latest { common; body } =\n let open Result.Let_syntax in\n let%map common = common_latest common and body = body_latest body in\n { common; body }\n end\n end]\nend\n\n[%%versioned\nmodule Stable = struct\n module V2 = struct\n type t = (Common.Stable.V2.t, Body.Stable.V2.t) Poly.Stable.V1.t\n [@@deriving compare, equal, sexp, hash, yojson]\n\n let to_latest = Fn.id\n end\n\n module V1 = struct\n [@@@with_all_version_tags]\n\n type t = (Common.Stable.V1.t, Body.Stable.V1.t) Poly.Stable.V1.t\n [@@deriving compare, equal, sexp, hash, yojson]\n\n (* don't need to coerce old transactions to newer version *)\n let to_latest _ = failwith \"Not implemented\"\n end\nend]\n\nlet create ~fee ~fee_payer_pk ~nonce ~valid_until ~memo ~body : t =\n { common =\n { fee\n ; fee_payer_pk\n ; nonce\n ; valid_until =\n Option.value valid_until ~default:Global_slot_since_genesis.max_value\n ; memo\n }\n ; body\n }\n\nlet fee (t : t) = t.common.fee\n\nlet fee_token (_ : t) = Token_id.default\n\nlet fee_payer_pk (t : t) = t.common.fee_payer_pk\n\nlet fee_payer (t : t) = Account_id.create t.common.fee_payer_pk Token_id.default\n\nlet nonce (t : t) = t.common.nonce\n\nlet valid_until (t : t) = t.common.valid_until\n\nlet memo (t : t) = t.common.memo\n\nlet body (t : t) = t.body\n\nlet receiver_pk (t : t) = Body.receiver_pk t.body\n\nlet receiver (t : t) = Body.receiver t.body\n\nlet token (t : t) = Body.token t.body\n\nlet tag (t : t) = Body.tag t.body\n\nlet amount (t : t) =\n match t.body with\n | Payment payload ->\n Some payload.Payment_payload.Poly.amount\n | Stake_delegation _ ->\n None\n\nlet fee_excess (t : t) =\n Fee_excess.of_single (fee_token t, Currency.Fee.Signed.of_unsigned (fee t))\n\nlet account_access_statuses (t : t) (status : Transaction_status.t) =\n match status with\n | Applied ->\n List.map\n [ fee_payer t; receiver t ]\n ~f:(fun acct_id -> (acct_id, `Accessed))\n | Failed _ ->\n (fee_payer t, `Accessed)\n :: List.map [ receiver t ] ~f:(fun acct_id -> (acct_id, `Not_accessed))\n\nlet dummy : t =\n { common =\n { fee = Currency.Fee.zero\n ; fee_payer_pk = Public_key.Compressed.empty\n ; nonce = Account_nonce.zero\n ; valid_until = Global_slot_since_genesis.max_value\n ; memo = Memo.dummy\n }\n ; body = Payment Payment_payload.dummy\n }\n\nlet gen =\n let open Quickcheck.Generator.Let_syntax in\n let%bind common = Common.gen in\n let max_amount =\n Currency.Amount.(sub max_int (of_fee common.fee))\n |> Option.value_exn ?here:None ?error:None ?message:None\n in\n let%map body = Body.gen max_amount in\n Poly.{ common; body }\n\n(** This module defines a weight for each payload component *)\nmodule Weight = struct\n let payment (_payment_payload : Payment_payload.t) : int = 1\n\n let stake_delegation (_stake_delegation : Stake_delegation.t) : int = 1\n\n let of_body : Body.t -> int = function\n | Payment payment_payload ->\n payment payment_payload\n | Stake_delegation stake_delegation_payload ->\n stake_delegation stake_delegation_payload\nend\n\nlet weight (signed_command_payload : t) : int =\n body signed_command_payload |> Weight.of_body\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Mina_base_import\nopen Mina_numbers\n\n(** See documentation of the {!Mina_wire_types} library *)\nmodule Wire_types = Mina_wire_types.Mina_base.Signed_command\n\nmodule Make_sig (A : Wire_types.Types.S) = struct\n module type S =\n Signed_command_intf.Full\n with type With_valid_signature.Stable.Latest.t =\n A.With_valid_signature.V2.t\nend\n\nmodule Make_str (_ : Wire_types.Concrete) = struct\n module Fee = Currency.Fee\n module Payload = Signed_command_payload\n\n module Poly = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n [@@@with_all_version_tags]\n\n type ('payload, 'pk, 'signature) t =\n ( 'payload\n , 'pk\n , 'signature )\n Mina_wire_types.Mina_base.Signed_command.Poly.V1.t =\n { payload : 'payload; signer : 'pk; signature : 'signature }\n [@@deriving compare, sexp, hash, yojson, equal]\n end\n end]\n end\n\n [%%versioned\n module Stable = struct\n [@@@with_top_version_tag]\n\n (* DO NOT DELETE VERSIONS!\n so we can always get transaction hashes from old transaction ids\n the version linter should be checking this\n\n IF YOU CREATE A NEW VERSION:\n update Transaction_hash.hash_of_transaction_id to handle it\n add hash_signed_command_vn for that version\n *)\n\n module V2 = struct\n type t =\n ( Payload.Stable.V2.t\n , Public_key.Stable.V1.t\n , Signature.Stable.V1.t )\n Poly.Stable.V1.t\n [@@deriving compare, sexp, hash, yojson]\n\n let to_latest = Fn.id\n\n module T = struct\n (* can't use nonrec + deriving *)\n type typ = t [@@deriving compare, sexp, hash]\n\n type t = typ [@@deriving compare, sexp, hash]\n end\n\n include Comparable.Make (T)\n include Hashable.Make (T)\n\n let account_access_statuses ({ payload; _ } : t) status =\n Payload.account_access_statuses payload status\n\n let accounts_referenced (t : t) =\n List.map (account_access_statuses t Applied)\n ~f:(fun (acct_id, _status) -> acct_id)\n end\n\n module V1 = struct\n [@@@with_all_version_tags]\n\n type t =\n ( Payload.Stable.V1.t\n , Public_key.Stable.V1.t\n , Signature.Stable.V1.t )\n Poly.Stable.V1.t\n [@@deriving compare, sexp, hash, yojson]\n\n let to_latest ({ payload; signer; signature } : t) : Latest.t =\n let payload : Signed_command_payload.t =\n let valid_until =\n Global_slot_legacy.to_uint32 payload.common.valid_until\n |> Global_slot_since_genesis.of_uint32\n in\n let common : Signed_command_payload.Common.t =\n { fee = payload.common.fee\n ; fee_payer_pk = payload.common.fee_payer_pk\n ; nonce = payload.common.nonce\n ; valid_until\n ; memo = payload.common.memo\n }\n in\n let body : Signed_command_payload.Body.t =\n match payload.body with\n | Payment payment_payload ->\n let payload' : Payment_payload.t =\n { receiver_pk = payment_payload.receiver_pk\n ; amount = payment_payload.amount\n }\n in\n Payment payload'\n | Stake_delegation stake_delegation_payload ->\n Stake_delegation\n (Stake_delegation.Stable.V1.to_latest stake_delegation_payload)\n in\n { common; body }\n in\n { payload; signer; signature }\n end\n end]\n\n (* type of signed commands, pre-Berkeley hard fork *)\n type t_v1 = Stable.V1.t\n\n let (_ : (t, (Payload.t, Public_key.t, Signature.t) Poly.t) Type_equal.t) =\n Type_equal.T\n\n include (Stable.Latest : module type of Stable.Latest with type t := t)\n\n let payload Poly.{ payload; _ } = payload\n\n let fee = Fn.compose Payload.fee payload\n\n let nonce = Fn.compose Payload.nonce payload\n\n (* for filtering *)\n let minimum_fee = Currency.Fee.minimum_user_command_fee\n\n let has_insufficient_fee t = Currency.Fee.(fee t < minimum_fee)\n\n let signer { Poly.signer; _ } = signer\n\n let fee_token (_ : t) = Token_id.default\n\n let fee_payer_pk ({ payload; _ } : t) = Payload.fee_payer_pk payload\n\n let fee_payer ({ payload; _ } : t) = Payload.fee_payer payload\n\n let fee_excess ({ payload; _ } : t) = Payload.fee_excess payload\n\n let token ({ payload; _ } : t) = Payload.token payload\n\n let receiver_pk ({ payload; _ } : t) = Payload.receiver_pk payload\n\n let receiver ({ payload; _ } : t) = Payload.receiver payload\n\n let amount = Fn.compose Payload.amount payload\n\n let memo = Fn.compose Payload.memo payload\n\n let valid_until = Fn.compose Payload.valid_until payload\n\n let tag ({ payload; _ } : t) = Payload.tag payload\n\n let tag_string (t : t) =\n match t.payload.body with\n | Payment _ ->\n \"payment\"\n | Stake_delegation _ ->\n \"delegation\"\n\n let to_input_legacy (payload : Payload.t) =\n Transaction_union_payload.(\n to_input_legacy (of_user_command_payload payload))\n\n let sign_payload ?signature_kind (private_key : Signature_lib.Private_key.t)\n (payload : Payload.t) : Signature.t =\n Signature_lib.Schnorr.Legacy.sign ?signature_kind private_key\n (to_input_legacy payload)\n\n let sign ?signature_kind (kp : Signature_keypair.t) (payload : Payload.t) : t\n =\n { payload\n ; signer = kp.public_key\n ; signature = sign_payload ?signature_kind kp.private_key payload\n }\n\n module For_tests = struct\n (* Pretend to sign a command. Much faster than actually signing. *)\n let fake_sign ?signature_kind:_ (kp : Signature_keypair.t)\n (payload : Payload.t) : t =\n { payload; signer = kp.public_key; signature = Signature.dummy }\n end\n\n module Gen = struct\n let gen_inner (sign' : Signature_lib.Keypair.t -> Payload.t -> t) ~key_gen\n ?(nonce = Account_nonce.zero) ~fee_range create_body =\n let open Quickcheck.Generator.Let_syntax in\n let min_fee = Fee.to_nanomina_int Currency.Fee.minimum_user_command_fee in\n let max_fee = min_fee + fee_range in\n let%bind (signer : Signature_keypair.t), (receiver : Signature_keypair.t)\n =\n key_gen\n and fee =\n Int.gen_incl min_fee max_fee >>| Currency.Fee.of_nanomina_int_exn\n and memo = String.quickcheck_generator in\n let%map body = create_body signer receiver in\n let payload : Payload.t =\n Payload.create ~fee\n ~fee_payer_pk:(Public_key.compress signer.public_key)\n ~nonce ~valid_until:None\n ~memo:(Signed_command_memo.create_by_digesting_string_exn memo)\n ~body\n in\n sign' signer payload\n\n let with_random_participants ~keys ~gen =\n let key_gen = Quickcheck_lib.gen_pair @@ Quickcheck_lib.of_array keys in\n gen ~key_gen\n\n module Payment = struct\n let gen_inner (sign' : Signature_lib.Keypair.t -> Payload.t -> t) ~key_gen\n ?nonce ?(min_amount = 1) ~max_amount ~fee_range () =\n gen_inner sign' ~key_gen ?nonce ~fee_range\n @@ fun { public_key = signer; _ } { public_key = receiver; _ } ->\n let open Quickcheck.Generator.Let_syntax in\n let%map amount =\n Int.gen_incl min_amount max_amount\n >>| Currency.Amount.of_nanomina_int_exn\n in\n Signed_command_payload.Body.Payment\n { receiver_pk = Public_key.compress receiver; amount }\n\n let gen ?(sign_type = `Fake) =\n match sign_type with\n | `Fake ->\n gen_inner For_tests.fake_sign\n | `Real ->\n gen_inner sign\n\n let gen_with_random_participants ?sign_type ~keys ?nonce ?min_amount\n ~max_amount ~fee_range =\n with_random_participants ~keys ~gen:(fun ~key_gen ->\n gen ?sign_type ~key_gen ?nonce ?min_amount ~max_amount ~fee_range )\n end\n\n module Stake_delegation = struct\n let gen ~key_gen ?nonce ~fee_range () =\n gen_inner For_tests.fake_sign ~key_gen ?nonce ~fee_range\n (fun { public_key = signer; _ } { public_key = new_delegate; _ } ->\n Quickcheck.Generator.return\n @@ Signed_command_payload.Body.Stake_delegation\n (Set_delegate\n { new_delegate = Public_key.compress new_delegate } ) )\n\n let gen_with_random_participants ~keys ?nonce ~fee_range =\n with_random_participants ~keys ~gen:(gen ?nonce ~fee_range)\n end\n\n let payment = Payment.gen\n\n let payment_with_random_participants = Payment.gen_with_random_participants\n\n let stake_delegation = Stake_delegation.gen\n\n let stake_delegation_with_random_participants =\n Stake_delegation.gen_with_random_participants\n\n let sequence :\n ?length:int\n -> ?sign_type:[ `Fake | `Real ]\n -> ( Signature_lib.Keypair.t\n * Currency.Amount.t\n * Mina_numbers.Account_nonce.t\n * Account_timing.t )\n array\n -> t list Quickcheck.Generator.t =\n fun ?length ?(sign_type = `Fake) account_info ->\n let open Quickcheck.Generator in\n let open Quickcheck.Generator.Let_syntax in\n let%bind n_commands =\n Option.value_map length ~default:small_non_negative_int ~f:return\n in\n if Int.(n_commands = 0) then return []\n else\n let n_accounts = Array.length account_info in\n let%bind command_senders, currency_splits =\n (* How many commands will be issued from each account? *)\n (let%bind command_splits =\n Quickcheck_lib.gen_division n_commands n_accounts\n in\n let command_splits' = Array.of_list command_splits in\n (* List of payment senders in the final order. *)\n let%bind command_senders =\n Quickcheck_lib.shuffle\n @@ List.concat_mapi command_splits ~f:(fun idx cmds ->\n List.init cmds ~f:(Fn.const idx) )\n in\n (* within the accounts, how will the currency be split into separate\n payments? *)\n let%bind currency_splits =\n Quickcheck_lib.init_gen_array\n ~f:(fun i ->\n let%bind spend_all = bool in\n let _, balance, _, _ = account_info.(i) in\n let amount_to_spend =\n if spend_all then balance\n else\n Currency.Amount.of_nanomina_int_exn\n (Currency.Amount.to_nanomina_int balance / 2)\n in\n Quickcheck_lib.gen_division_currency amount_to_spend\n command_splits'.(i) )\n n_accounts\n in\n return (command_senders, currency_splits) )\n |> (* We need to ensure each command has enough currency for a fee of 2\n or more, so it'll be enough to buy the requisite transaction\n snarks. It's important that the backtracking from filter goes and\n redraws command_splits as well as currency_splits, so we don't get\n stuck in a situation where it's very unlikely for the predicate to\n pass. *)\n Quickcheck.Generator.filter ~f:(fun (_, splits) ->\n Array.for_all splits ~f:(fun split ->\n List.for_all split ~f:(fun amt ->\n Currency.Amount.(amt >= of_mina_int_exn 2) ) ) )\n in\n let account_nonces =\n Array.map ~f:(fun (_, _, nonce, _) -> nonce) account_info\n in\n let uncons_exn = function\n | [] ->\n failwith \"uncons_exn\"\n | x :: xs ->\n (x, xs)\n in\n Quickcheck_lib.map_gens command_senders ~f:(fun sender ->\n let this_split, rest_splits = uncons_exn currency_splits.(sender) in\n let sender_pk, _, _, _ = account_info.(sender) in\n currency_splits.(sender) <- rest_splits ;\n let nonce = account_nonces.(sender) in\n account_nonces.(sender) <- Account_nonce.succ nonce ;\n let%bind fee =\n (* use of_string here because json_of_ocaml won't handle\n equivalent integer constants\n *)\n Currency.Fee.(\n gen_incl (of_string \"6000000000\")\n (min (of_string \"10000000000\")\n (Currency.Amount.to_fee this_split) ))\n in\n let amount =\n Option.value_exn Currency.Amount.(this_split - of_fee fee)\n in\n let%bind receiver =\n map ~f:(fun idx ->\n let kp, _, _, _ = account_info.(idx) in\n Public_key.compress kp.public_key )\n @@ Int.gen_uniform_incl 0 (n_accounts - 1)\n in\n let memo = Signed_command_memo.dummy in\n let payload =\n let sender_pk = Public_key.compress sender_pk.public_key in\n Payload.create ~fee ~fee_payer_pk:sender_pk ~valid_until:None\n ~nonce ~memo\n ~body:(Payment { receiver_pk = receiver; amount })\n in\n let sign' =\n match sign_type with\n | `Fake ->\n For_tests.fake_sign\n | `Real ->\n sign\n in\n return @@ sign' sender_pk payload )\n end\n\n module With_valid_signature = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t = Stable.V2.t [@@deriving sexp, equal, yojson, hash]\n\n let to_latest = Stable.V2.to_latest\n\n let compare = Stable.V2.compare\n\n let equal = Stable.V2.equal\n\n module Gen = Gen\n end\n end]\n\n module Gen = Stable.Latest.Gen\n include Comparable.Make (Stable.Latest)\n end\n\n let to_valid_unsafe t =\n `If_this_is_used_it_should_have_a_comment_justifying_it t\n\n (* so we can deserialize Base58Check transaction ids created before Berkeley hard fork *)\n module V1_all_tagged = struct\n include Stable.V1.With_all_version_tags\n\n let description = \"Signed command\"\n\n let version_byte = Base58_check.Version_bytes.signed_command_v1\n end\n\n let of_base58_check_exn_v1, to_base58_check_v1 =\n let module Base58_check_v1 = Codable.Make_base58_check (V1_all_tagged) in\n Base58_check_v1.(of_base58_check, to_base58_check)\n\n (* give transaction ids have version tag *)\n include Codable.Make_base64 (Stable.Latest.With_top_version_tag)\n\n let check_signature ?signature_kind ({ payload; signer; signature } : t) =\n Signature_lib.Schnorr.Legacy.verify ?signature_kind signature\n (Snark_params.Tick.Inner_curve.of_affine signer)\n (to_input_legacy payload)\n\n let public_keys t =\n let fee_payer = fee_payer_pk t in\n let receiver = receiver_pk t in\n [ fee_payer; receiver ]\n\n let check_valid_keys t =\n List.for_all (public_keys t) ~f:(fun pk ->\n Option.is_some (Public_key.decompress pk) )\n\n let create_with_signature_checked ?signature_kind signature signer payload =\n let open Option.Let_syntax in\n let%bind signer = Public_key.decompress signer in\n let t = Poly.{ payload; signature; signer } in\n Option.some_if (check_signature ?signature_kind t && check_valid_keys t) t\n\n let gen_test =\n let open Quickcheck.Let_syntax in\n let%bind keys =\n Quickcheck.Generator.list_with_length 2 Signature_keypair.gen\n in\n Gen.payment_with_random_participants ~sign_type:`Real\n ~keys:(Array.of_list keys) ~max_amount:10000 ~fee_range:1000 ()\n\n let%test_unit \"completeness\" =\n Quickcheck.test ~trials:20 gen_test ~f:(fun t -> assert (check_signature t))\n\n let%test_unit \"json\" =\n Quickcheck.test ~trials:20 ~sexp_of:sexp_of_t gen_test ~f:(fun t ->\n assert (Codable.For_tests.check_encoding (module Stable.Latest) ~equal t) )\n\n (* return type is `t option` here, interface coerces that to `With_valid_signature.t option` *)\n let check t = Option.some_if (check_signature t && check_valid_keys t) t\n\n (* return type is `t option` here, interface coerces that to `With_valid_signature.t option` *)\n let check_only_for_signature t = Option.some_if (check_signature t) t\n\n let forget_check t = t\n\n let filter_by_participant user_commands public_key =\n List.filter user_commands ~f:(fun user_command ->\n Core_kernel.List.exists\n (accounts_referenced user_command)\n ~f:\n (Fn.compose\n (Public_key.Compressed.equal public_key)\n Account_id.public_key ) )\n\n let%test \"latest signed command version\" =\n (* if this test fails, update `Transaction_hash.hash_of_transaction_id`\n for latest version, then update this test\n *)\n Int.equal Stable.Latest.version 2\nend\n\ninclude Wire_types.Make (Make_sig) (Make_str)\n","(* receipt.ml *)\n\n[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nmodule B58_lib = Base58_check\nopen Snark_params.Tick\n\nmodule Signed_command_elt = struct\n type t = Signed_command_payload of Signed_command.Payload.t\nend\n\nmodule Zkapp_command_elt = struct\n type t = Zkapp_command_commitment of Random_oracle.Digest.t\nend\n\nmodule Chain_hash = struct\n include Data_hash.Make_full_size (struct\n let description = \"Receipt chain hash\"\n\n let version_byte = Base58_check.Version_bytes.receipt_chain_hash\n end)\n\n (* Data hash versioned boilerplate below *)\n\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n module T = struct\n type t = (Field.t[@version_asserted]) [@@deriving sexp, compare, hash]\n end\n\n include T\n\n let to_latest = Fn.id\n\n [%%define_from_scope to_yojson, of_yojson]\n\n include Comparable.Make (T)\n include Hashable.Make_binable (T)\n end\n end]\n\n let (_ : (t, Stable.Latest.t) Type_equal.t) = Type_equal.T\n\n let equal = Stable.Latest.equal\n\n let empty = of_hash Random_oracle.(salt \"CodaReceiptEmpty\" |> digest)\n\n let cons_signed_command_payload (e : Signed_command_elt.t) (t : t) =\n let open Random_oracle.Legacy in\n let x =\n match e with\n | Signed_command_payload payload ->\n Transaction_union_payload.(\n to_input_legacy (of_user_command_payload payload))\n in\n Input.(append x (field (t :> Field.t)))\n |> pack_input\n |> hash ~init:Hash_prefix.receipt_chain_signed_command\n |> of_hash\n\n (* prepend account_update index computed by Zkapp_command_logic.apply *)\n let cons_zkapp_command_commitment (index : Mina_numbers.Index.t)\n (e : Zkapp_command_elt.t) (t : t) =\n let open Random_oracle in\n let x =\n match e with Zkapp_command_commitment s -> Input.Chunked.field s\n in\n let index_input = Mina_numbers.Index.to_input index in\n Input.Chunked.(append index_input (append x (field (t :> Field.t))))\n |> pack_input\n |> hash ~init:Hash_prefix.receipt_chain_zkapp_command\n |> of_hash\n\n [%%if defined consensus_mechanism]\n\n module Checked = struct\n module Signed_command_elt = struct\n type t = Signed_command_payload of Transaction_union_payload.var\n end\n\n module Zkapp_command_elt = struct\n type t = Zkapp_command_commitment of Random_oracle.Checked.Digest.t\n end\n\n let constant (t : t) =\n var_of_hash_packed (Field.Var.constant (t :> Field.t))\n\n type t = var\n\n let equal t1 t2 = equal_var t1 t2\n\n let if_ = if_\n\n let cons_signed_command_payload (e : Signed_command_elt.t) t =\n let open Random_oracle.Legacy in\n let%bind x =\n match e with\n | Signed_command_payload payload ->\n let%map payload =\n Transaction_union_payload.Checked.to_input_legacy payload\n in\n payload\n in\n make_checked (fun () ->\n Checked.hash ~init:Hash_prefix.receipt_chain_signed_command\n (Checked.pack_input Input.(append x (field (var_to_hash_packed t))))\n |> var_of_hash_packed )\n\n (* prepend account_update index *)\n let cons_zkapp_command_commitment (index : Mina_numbers.Index.Checked.t)\n (e : Zkapp_command_elt.t) (t : t) =\n let open Random_oracle in\n let%bind x =\n match e with\n | Zkapp_command_commitment s ->\n Let_syntax.return (Input.Chunked.field s)\n in\n let index_input = Mina_numbers.Index.Checked.to_input index in\n make_checked (fun () ->\n Checked.hash ~init:Hash_prefix.receipt_chain_zkapp_command\n (Checked.pack_input\n Input.Chunked.(\n append index_input (append x (field (var_to_hash_packed t)))) )\n |> var_of_hash_packed )\n end\n\n [%%endif]\nend\n","open Core_kernel\nopen Snark_params.Tick\n\ninclude Data_hash.Make_full_size (struct\n let description = \"State body hash\"\n\n let version_byte = Base58_check.Version_bytes.state_body_hash\nend)\n\nlet dummy = of_hash Outside_hash_image.t\n\n(* Data hash versioned boilerplate below *)\n\n[%%versioned\nmodule Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n module T = struct\n type t = (Field.t[@version_asserted]) [@@deriving sexp, compare, hash]\n end\n\n include T\n\n let to_latest = Fn.id\n\n [%%define_from_scope to_yojson, of_yojson]\n\n include Comparable.Make (T)\n include Hashable.Make_binable (T)\n end\nend]\n\nlet (_ : (t, Stable.Latest.t) Type_equal.t) = Type_equal.T\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\n\nlet field_of_bool = Mina_base_util.field_of_bool\n\n[%%ifdef consensus_mechanism]\n\nopen Snark_params.Tick\nopen Signature_lib\n\n[%%endif]\n\nlet int_to_bits ~length x = List.init length ~f:(fun i -> (x lsr i) land 1 = 1)\n\nlet int_of_bits =\n List.foldi ~init:0 ~f:(fun i acc b -> if b then acc lor (1 lsl i) else acc)\n\nmodule Transition = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type 'a t = { prev : 'a; next : 'a }\n [@@deriving hlist, sexp, equal, yojson, hash, compare]\n end\n end]\n\n let to_input { prev; next } ~f =\n Random_oracle_input.Chunked.append (f prev) (f next)\n\n [%%ifdef consensus_mechanism]\n\n let typ t =\n Typ.of_hlistable [ t; t ] ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist\n ~value_to_hlist:to_hlist ~value_of_hlist:of_hlist\n\n [%%endif]\nend\n\nmodule Flagged_data = struct\n type ('flag, 'a) t = { flag : 'flag; data : 'a } [@@deriving hlist, fields]\n\n [%%ifdef consensus_mechanism]\n\n let typ flag t =\n Typ.of_hlistable [ flag; t ] ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist\n ~value_to_hlist:to_hlist ~value_of_hlist:of_hlist\n\n [%%endif]\n\n let to_input' { flag; data } ~flag:f ~data:d =\n Random_oracle_input.Chunked.(append (f flag) (d data))\nend\n\nmodule Flagged_option = struct\n type ('bool, 'a) t = { is_some : 'bool; data : 'a } [@@deriving hlist, fields]\n\n let to_input' ~field_of_bool { is_some; data } ~f =\n Random_oracle_input.Chunked.(\n append (packed (field_of_bool is_some, 1)) (f data))\n\n let to_input { is_some; data } ~default ~f =\n let data = if is_some then data else default in\n to_input' { is_some; data } ~f\n\n let of_option t ~default =\n match t with\n | None ->\n { is_some = false; data = default }\n | Some data ->\n { is_some = true; data }\n\n let to_option { is_some; data } = Option.some_if is_some data\n\n let map ~f { is_some; data } = { is_some; data = f data }\n\n [%%ifdef consensus_mechanism]\n\n let if_ ~(if_ : 'b -> then_:'var -> else_:'var -> 'var) b ~then_ ~else_ =\n { is_some =\n Run.run_checked\n (Boolean.if_ b ~then_:then_.is_some ~else_:else_.is_some)\n ; data = if_ b ~then_:then_.data ~else_:else_.data\n }\n\n let typ t =\n Typ.of_hlistable [ Boolean.typ; t ] ~var_to_hlist:to_hlist\n ~var_of_hlist:of_hlist ~value_to_hlist:to_hlist ~value_of_hlist:of_hlist\n\n let option_typ ~default t =\n Typ.transport (typ t) ~there:(of_option ~default) ~back:to_option\n\n [%%endif]\nend\n\nmodule Set_or_keep = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type 'a t = 'a Mina_wire_types.Mina_base.Zkapp_basic.Set_or_keep.V1.t =\n | Set of 'a\n | Keep\n [@@deriving sexp, equal, compare, hash, yojson]\n end\n end]\n\n let map t ~f = match t with Keep -> Keep | Set x -> Set (f x)\n\n let to_option = function Set x -> Some x | Keep -> None\n\n let of_option = function Some x -> Set x | None -> Keep\n\n let set_or_keep t x = match t with Keep -> x | Set y -> y\n\n let is_set = function Set _ -> true | _ -> false\n\n let is_keep = function Keep -> true | _ -> false\n\n let deriver inner obj =\n let open Fields_derivers_zkapps.Derivers in\n iso ~map:of_option ~contramap:to_option\n ((option ~js_type:Flagged_option @@ inner @@ o ()) (o ()))\n obj\n\n let gen gen_a =\n let open Quickcheck.Let_syntax in\n (* with equal probability, return a Set or a Keep *)\n let%bind b = Quickcheck.Generator.bool in\n if b then\n let%bind a = gen_a in\n return (Set a)\n else return Keep\n\n [%%ifdef consensus_mechanism]\n\n module Checked : sig\n type 'a t\n\n val is_keep : _ t -> Boolean.var\n\n val is_set : _ t -> Boolean.var\n\n val set_or_keep :\n if_:(Boolean.var -> then_:'a -> else_:'a -> 'a) -> 'a t -> 'a -> 'a\n\n val data : 'a t -> 'a\n\n val typ :\n dummy:'a -> ('a_var, 'a) Typ.t -> ('a_var t, 'a Stable.Latest.t) Typ.t\n\n val optional_typ :\n to_option:('new_value -> 'value option)\n -> of_option:('value option -> 'new_value)\n -> ('var, 'new_value) Typ.t\n -> ('var t, 'value Stable.Latest.t) Typ.t\n\n val map : f:('a -> 'b) -> 'a t -> 'b t\n\n val to_input :\n 'a t\n -> f:('a -> Field.Var.t Random_oracle_input.Chunked.t)\n -> Field.Var.t Random_oracle_input.Chunked.t\n\n val set : 'a -> 'a t\n\n val keep : dummy:'a -> 'a t\n\n val make_unsafe : Boolean.var -> 'a -> 'a t\n end = struct\n type 'a t = (Boolean.var, 'a) Flagged_option.t\n\n let set_or_keep ~if_ ({ is_some; data } : _ t) x =\n if_ is_some ~then_:data ~else_:x\n\n let data = Flagged_option.data\n\n let is_set = Flagged_option.is_some\n\n let is_keep x = Boolean.not (Flagged_option.is_some x)\n\n let map = Flagged_option.map\n\n let typ ~dummy t =\n Typ.transport\n (Flagged_option.option_typ ~default:dummy t)\n ~there:to_option ~back:of_option\n\n let optional_typ (type new_value value var) :\n to_option:(new_value -> value option)\n -> of_option:(value option -> new_value)\n -> (var, new_value) Typ.t\n -> (var t, value Stable.Latest.t) Typ.t =\n fun ~to_option ~of_option t ->\n Typ.transport (Flagged_option.typ t)\n ~there:(function\n | Set x ->\n { Flagged_option.is_some = true; data = of_option (Some x) }\n | Keep ->\n { Flagged_option.is_some = false; data = of_option None } )\n ~back:(function\n | { Flagged_option.is_some = true; data = x } ->\n Set (Option.value_exn (to_option x))\n | { Flagged_option.is_some = false; data = _ } ->\n Keep )\n\n let to_input (t : _ t) ~f =\n Flagged_option.to_input' t ~f ~field_of_bool:(fun (b : Boolean.var) ->\n (b :> Field.Var.t) )\n\n let make_unsafe is_keep data = { Flagged_option.is_some = is_keep; data }\n\n let set data = { Flagged_option.is_some = Boolean.true_; data }\n\n let keep ~dummy = { Flagged_option.is_some = Boolean.false_; data = dummy }\n end\n\n let typ = Checked.typ\n\n let optional_typ = Checked.optional_typ\n\n [%%endif]\n\n let to_input t ~dummy:default ~f =\n Flagged_option.to_input ~default ~f ~field_of_bool\n (Flagged_option.of_option ~default (to_option t))\nend\n\nmodule Or_ignore = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type 'a t = 'a Mina_wire_types.Mina_base.Zkapp_basic.Or_ignore.V1.t =\n | Check of 'a\n | Ignore\n [@@deriving sexp, equal, compare, hash, yojson]\n end\n end]\n\n let gen gen_a =\n let open Quickcheck.Let_syntax in\n (* choose constructor *)\n let%bind b = Quickcheck.Generator.bool in\n if b then\n let%map a = gen_a in\n Check a\n else return Ignore\n\n let to_option = function Ignore -> None | Check x -> Some x\n\n let of_option = function None -> Ignore | Some x -> Check x\n\n let deriver_base ~js_type inner obj =\n let open Fields_derivers_zkapps.Derivers in\n iso ~map:of_option ~contramap:to_option\n ((option ~js_type @@ inner @@ o ()) (o ()))\n obj\n\n let deriver inner obj = deriver_base ~js_type:Flagged_option inner obj\n\n let deriver_interval inner obj ~range_max =\n deriver_base ~js_type:(Closed_interval range_max) inner obj\n\n [%%ifdef consensus_mechanism]\n\n module Checked : sig\n type 'a t\n\n val typ :\n ignore:'a -> ('a_var, 'a) Typ.t -> ('a_var t, 'a Stable.Latest.t) Typ.t\n\n val to_input :\n 'a t\n -> f:('a -> Field.Var.t Random_oracle_input.Chunked.t)\n -> Field.Var.t Random_oracle_input.Chunked.t\n\n val check : 'a t -> f:('a -> Boolean.var) -> Boolean.var\n\n val map : f:('a -> 'b) -> 'a t -> 'b t\n\n val data : 'a t -> 'a\n\n val is_check : 'a t -> Boolean.var\n\n val make_unsafe : Boolean.var -> 'a -> 'a t\n end = struct\n type 'a t = (Boolean.var, 'a) Flagged_option.t\n\n let to_input t ~f =\n Flagged_option.to_input' t ~f ~field_of_bool:(fun (b : Boolean.var) ->\n (b :> Field.Var.t) )\n\n let check { Flagged_option.is_some; data } ~f =\n Pickles.Impls.Step.Boolean.(any [ not is_some; f data ])\n\n let map = Flagged_option.map\n\n let data = Flagged_option.data\n\n let is_check = Flagged_option.is_some\n\n let typ (type a_var a) ~ignore (t : (a_var, a) Typ.t) =\n Typ.transport\n (Flagged_option.option_typ ~default:ignore t)\n ~there:to_option ~back:of_option\n\n let make_unsafe is_ignore data =\n { Flagged_option.is_some = is_ignore; data }\n end\n\n let typ = Checked.typ\n\n [%%endif]\nend\n\nmodule Account_state = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Empty | Non_empty | Any\n [@@deriving sexp, equal, yojson, hash, compare, enum]\n\n let to_latest = Fn.id\n end\n end]\n\n module Encoding = struct\n type 'b t = { any : 'b; empty : 'b } [@@deriving hlist]\n\n let to_input ~field_of_bool { any; empty } =\n Random_oracle_input.Chunked.packeds\n [| (field_of_bool any, 1); (field_of_bool empty, 1) |]\n end\n\n let encode : t -> bool Encoding.t = function\n | Empty ->\n { any = false; empty = true }\n | Non_empty ->\n { any = false; empty = false }\n | Any ->\n { any = true; empty = false }\n\n let decode : bool Encoding.t -> t = function\n | { any = false; empty = true } ->\n Empty\n | { any = false; empty = false } ->\n Non_empty\n | { any = true; empty = false } | { any = true; empty = true } ->\n Any\n\n let to_input (x : t) = Encoding.to_input ~field_of_bool (encode x)\n\n let check (t : t) (x : [ `Empty | `Non_empty ]) =\n match (t, x) with\n | Any, _ | Non_empty, `Non_empty | Empty, `Empty ->\n Ok ()\n | _ ->\n Or_error.error_string \"Bad account_type\"\n\n [%%ifdef consensus_mechanism]\n\n module Checked = struct\n open Pickles.Impls.Step\n\n type t = Boolean.var Encoding.t\n\n let to_input (t : t) =\n Encoding.to_input t ~field_of_bool:(fun (b : Boolean.var) ->\n (b :> Field.t) )\n\n let check (t : t) ~is_empty =\n Boolean.(\n any [ t.any; t.empty && is_empty; (not t.empty) && not is_empty ])\n end\n\n let typ : (Checked.t, t) Typ.t =\n let open Encoding in\n Typ.of_hlistable\n [ Boolean.typ; Boolean.typ ]\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist\n |> Typ.transport ~there:encode ~back:decode\n\n [%%endif]\nend\n\n[%%ifdef consensus_mechanism]\n\nmodule F = Pickles.Backend.Tick.Field\n\n[%%else]\n\nmodule F = Snark_params.Tick.Field\n\n[%%endif]\n\nmodule F_map = struct\n include Hashable.Make (F)\n include Comparable.Make (F)\nend\n\nlet invalid_public_key : Public_key.Compressed.t =\n { x = F.zero; is_odd = false }\n\nlet%test \"invalid_public_key is invalid\" =\n Option.is_none (Public_key.decompress invalid_public_key)\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Snark_params.Tick\nopen Zkapp_basic\n\nmodule Event = struct\n (* Arbitrary hash input, encoding determined by the zkApp's developer. *)\n type t = Field.t array [@@deriving compare, sexp]\n\n let hash (x : t) = Random_oracle.hash ~init:Hash_prefix_states.zkapp_event x\n\n [%%ifdef consensus_mechanism]\n\n type var = Field.Var.t array\n\n let hash_var (x : Field.Var.t array) =\n Random_oracle.Checked.hash ~init:Hash_prefix_states.zkapp_event x\n\n [%%endif]\n\n let gen : t Quickcheck.Generator.t =\n let open Quickcheck in\n Generator.map ~f:Array.of_list @@ Generator.list Field.gen\nend\n\nmodule Make_events (Inputs : sig\n val salt_phrase : string\n\n val hash_prefix : field Random_oracle.State.t\n\n val deriver_name : string\nend) =\nstruct\n type t = Event.t list [@@deriving compare, sexp]\n\n let empty_hash = Random_oracle.(salt Inputs.salt_phrase |> digest)\n\n let push_hash acc hash =\n Random_oracle.hash ~init:Inputs.hash_prefix [| acc; hash |]\n\n let push_event acc event = push_hash acc (Event.hash event)\n\n let hash (x : t) =\n (* fold_right so the empty hash is used at the end of the events *)\n List.fold_right ~init:empty_hash ~f:(Fn.flip push_event) x\n\n [%%ifdef consensus_mechanism]\n\n type var = t Data_as_hash.t\n\n let typ = Data_as_hash.typ ~hash\n\n let var_to_input (x : var) = Data_as_hash.to_input x\n\n let to_input (x : t) = Random_oracle_input.Chunked.field (hash x)\n\n let push_to_data_as_hash (events : var) (e : Event.var) : var =\n let open Run in\n let res =\n exists typ ~compute:(fun () ->\n let tl = As_prover.read typ events in\n let hd =\n As_prover.read (Typ.array ~length:(Array.length e) Field.typ) e\n in\n hd :: tl )\n in\n Field.Assert.equal\n (Random_oracle.Checked.hash ~init:Inputs.hash_prefix\n [| Data_as_hash.hash events; Event.hash_var e |] )\n (Data_as_hash.hash res) ;\n res\n\n let empty_stack_msg = \"Attempted to pop an empty stack\"\n\n let pop_from_data_as_hash (events : var) : Event.t Data_as_hash.t * var =\n let open Run in\n let hd, tl =\n exists\n Typ.(Data_as_hash.typ ~hash:Event.hash * typ)\n ~compute:(fun () ->\n match As_prover.read typ events with\n | [] ->\n failwith empty_stack_msg\n | event :: events ->\n (event, events) )\n in\n Field.Assert.equal\n (Random_oracle.Checked.hash ~init:Inputs.hash_prefix\n [| Data_as_hash.hash tl; Data_as_hash.hash hd |] )\n (Data_as_hash.hash events) ;\n (hd, tl)\n\n [%%endif]\n\n let deriver obj =\n let open Fields_derivers_zkapps in\n let events = list @@ array field (o ()) in\n needs_custom_js\n ~js_type:(Data_as_hash.deriver events)\n ~name:Inputs.deriver_name events obj\nend\n\nmodule Events = struct\n include Make_events (struct\n let salt_phrase = \"MinaZkappEventsEmpty\"\n\n let hash_prefix = Hash_prefix_states.zkapp_events\n\n let deriver_name = \"Events\"\n end)\nend\n\nmodule Actions = struct\n include Make_events (struct\n let salt_phrase = \"MinaZkappActionsEmpty\"\n\n let hash_prefix = Hash_prefix_states.zkapp_actions\n\n let deriver_name = \"Actions\"\n end)\n\n let is_empty_var (e : var) =\n Snark_params.Tick.Field.(\n Checked.equal (Data_as_hash.hash e) (Var.constant empty_hash))\n\n let empty_state_element =\n let salt_phrase = \"MinaZkappActionStateEmptyElt\" in\n Random_oracle.(salt salt_phrase |> digest)\n\n let push_events (acc : Field.t) (events : t) : Field.t =\n push_hash acc (hash events)\n\n [%%ifdef consensus_mechanism]\n\n let push_events_checked (x : Field.Var.t) (e : var) : Field.Var.t =\n Random_oracle.Checked.hash ~init:Hash_prefix_states.zkapp_actions\n [| x; Data_as_hash.hash e |]\n\n [%%endif]\nend\n\nmodule Zkapp_uri = struct\n [%%versioned_binable\n module Stable = struct\n module V1 = struct\n module T = struct\n type t = string [@@deriving sexp, equal, compare, hash, yojson]\n\n let to_latest = Fn.id\n\n let max_length = 255\n\n let check (x : t) = assert (String.length x <= max_length)\n\n let t_of_sexp sexp =\n let res = t_of_sexp sexp in\n check res ; res\n\n let of_yojson json =\n let res = of_yojson json in\n Result.bind res ~f:(fun res ->\n Result.try_with (fun () -> check res)\n |> Result.map ~f:(Fn.const res)\n |> Result.map_error\n ~f:(Fn.const \"Zkapp_uri.of_yojson: symbol is too long\") )\n end\n\n include T\n\n include\n Binable.Of_binable_without_uuid\n (Core_kernel.String.Stable.V1)\n (struct\n type t = string\n\n let to_binable = Fn.id\n\n let of_binable x = check x ; x\n end)\n end\n end]\n\n [%%define_locally\n Stable.Latest.\n (sexp_of_t, t_of_sexp, equal, to_yojson, of_yojson, max_length, check)]\nend\n\nmodule Poly = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type ('app_state, 'vk, 'zkapp_version, 'field, 'slot, 'bool, 'zkapp_uri) t =\n { app_state : 'app_state\n ; verification_key : 'vk\n ; zkapp_version : 'zkapp_version\n ; action_state : 'field Pickles_types.Vector.Vector_5.Stable.V1.t\n ; last_action_slot : 'slot\n ; proved_state : 'bool\n ; zkapp_uri : 'zkapp_uri\n }\n [@@deriving sexp, equal, compare, hash, yojson, hlist, fields, annot]\n end\n end]\nend\n\ntype ('app_state, 'vk, 'zkapp_version, 'field, 'slot, 'bool, 'zkapp_uri) t_ =\n ('app_state, 'vk, 'zkapp_version, 'field, 'slot, 'bool, 'zkapp_uri) Poly.t =\n { app_state : 'app_state\n ; verification_key : 'vk\n ; zkapp_version : 'zkapp_version\n ; action_state : 'field Pickles_types.Vector.Vector_5.t\n ; last_action_slot : 'slot\n ; proved_state : 'bool\n ; zkapp_uri : 'zkapp_uri\n }\n\n[%%versioned\nmodule Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V2 = struct\n type t =\n ( Zkapp_state.Value.Stable.V1.t\n , Verification_key_wire.Stable.V1.t option\n , Mina_numbers.Zkapp_version.Stable.V1.t\n , F.Stable.V1.t\n , Mina_numbers.Global_slot_since_genesis.Stable.V1.t\n , bool\n , Zkapp_uri.Stable.V1.t )\n Poly.Stable.V2.t\n [@@deriving sexp, equal, compare, hash, yojson]\n\n let to_latest = Fn.id\n end\nend]\n\ntype t =\n ( Zkapp_state.Value.t\n , Verification_key_wire.t option\n , Mina_numbers.Zkapp_version.t\n , F.t\n , Mina_numbers.Global_slot_since_genesis.t\n , bool\n , Zkapp_uri.t )\n Poly.t\n[@@deriving sexp, equal, compare, hash, yojson]\n\nlet (_ : (t, Stable.Latest.t) Type_equal.t) = Type_equal.T\n\n[%%ifdef consensus_mechanism]\n\nmodule Checked = struct\n type t =\n ( Pickles.Impls.Step.Field.t Zkapp_state.V.t\n , ( Boolean.var\n , (Side_loaded_verification_key.t option, Field.t) With_hash.t\n Data_as_hash.t )\n Flagged_option.t\n , Mina_numbers.Zkapp_version.Checked.t\n , Pickles.Impls.Step.Field.t\n , Mina_numbers.Global_slot_since_genesis.Checked.t\n , Boolean.var\n , string Data_as_hash.t )\n Poly.t\n\n open Pickles_types\n\n let to_input' (t : _ Poly.t) :\n Snark_params.Tick.Field.Var.t Random_oracle.Input.Chunked.t =\n let open Random_oracle.Input.Chunked in\n let f mk acc field = mk (Core_kernel.Field.get field t) :: acc in\n let app_state v =\n Random_oracle.Input.Chunked.field_elements (Vector.to_array v)\n in\n Poly.Fields.fold ~init:[] ~app_state:(f app_state)\n ~verification_key:(f field)\n ~zkapp_version:(f Mina_numbers.Zkapp_version.Checked.to_input)\n ~action_state:(f app_state)\n ~last_action_slot:\n (f Mina_numbers.Global_slot_since_genesis.Checked.to_input)\n ~proved_state:\n (f (fun (b : Boolean.var) ->\n Random_oracle.Input.Chunked.packed ((b :> Field.Var.t), 1) ) )\n ~zkapp_uri:(f field)\n |> List.reduce_exn ~f:append\n\n let to_input (t : t) =\n to_input'\n { t with\n verification_key = Data_as_hash.hash t.verification_key.data\n ; zkapp_uri = Data_as_hash.hash t.zkapp_uri\n }\n\n let digest_vk t =\n Random_oracle.Checked.(\n hash ~init:Hash_prefix_states.side_loaded_vk\n (pack_input (Pickles.Side_loaded.Verification_key.Checked.to_input t)))\n\n let digest t =\n Random_oracle.Checked.(\n hash ~init:Hash_prefix_states.zkapp_account (pack_input (to_input t)))\n\n let digest' t =\n Random_oracle.Checked.(\n hash ~init:Hash_prefix_states.zkapp_account (pack_input (to_input' t)))\nend\n\n[%%define_locally Verification_key_wire.(digest_vk, dummy_vk_hash)]\n\n(* This preimage cannot be attained by any string, due to the trailing [true]\n added below.\n*)\nlet zkapp_uri_non_preimage =\n lazy (Random_oracle_input.Chunked.field_elements [| Field.zero; Field.zero |])\n\nlet hash_zkapp_uri_opt (zkapp_uri_opt : string option) =\n let input =\n match zkapp_uri_opt with\n | Some zkapp_uri ->\n (* We use [length*8 + 1] to pass a final [true] after the end of the\n string, to ensure that trailing null bytes don't alias in the hash\n preimage.\n *)\n let bits = Array.create ~len:((String.length zkapp_uri * 8) + 1) true in\n String.foldi zkapp_uri ~init:() ~f:(fun i () c ->\n let c = Char.to_int c in\n (* Insert the bits into [bits], LSB order. *)\n for j = 0 to 7 do\n (* [Int.test_bit c j] *)\n bits.((i * 8) + j) <- Int.bit_and c (1 lsl j) <> 0\n done ) ;\n Random_oracle_input.Chunked.packeds\n (Array.map ~f:(fun b -> (field_of_bool b, 1)) bits)\n | None ->\n Lazy.force zkapp_uri_non_preimage\n in\n Random_oracle.pack_input input\n |> Random_oracle.hash ~init:Hash_prefix_states.zkapp_uri\n\nlet hash_zkapp_uri (zkapp_uri : string) = hash_zkapp_uri_opt (Some zkapp_uri)\n\nlet typ : (Checked.t, t) Typ.t =\n let open Poly in\n Typ.of_hlistable\n [ Zkapp_state.typ Field.typ\n ; Flagged_option.option_typ\n ~default:{ With_hash.data = None; hash = dummy_vk_hash () }\n (Data_as_hash.typ ~hash:With_hash.hash)\n |> Typ.transport\n ~there:(Option.map ~f:(With_hash.map ~f:Option.some))\n ~back:\n (Option.map ~f:(With_hash.map ~f:(fun x -> Option.value_exn x)))\n ; Mina_numbers.Zkapp_version.typ\n ; Pickles_types.Vector.typ Field.typ Pickles_types.Nat.N5.n\n ; Mina_numbers.Global_slot_since_genesis.typ\n ; Boolean.typ\n ; Data_as_hash.typ ~hash:hash_zkapp_uri\n ]\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist\n\n[%%endif]\n\nlet zkapp_uri_to_input zkapp_uri =\n Random_oracle.Input.Chunked.field @@ hash_zkapp_uri zkapp_uri\n\nlet to_input (t : t) : _ Random_oracle.Input.Chunked.t =\n let open Random_oracle.Input.Chunked in\n let f mk acc field = mk (Core_kernel.Field.get field t) :: acc in\n let app_state v =\n Random_oracle.Input.Chunked.field_elements (Pickles_types.Vector.to_array v)\n in\n Poly.Fields.fold ~init:[] ~app_state:(f app_state)\n ~verification_key:\n (f\n (Fn.compose field\n (Option.value_map ~default:(dummy_vk_hash ()) ~f:With_hash.hash) ) )\n ~zkapp_version:(f Mina_numbers.Zkapp_version.to_input)\n ~action_state:(f app_state)\n ~last_action_slot:(f Mina_numbers.Global_slot_since_genesis.to_input)\n ~proved_state:\n (f (fun b -> Random_oracle.Input.Chunked.packed (field_of_bool b, 1)))\n ~zkapp_uri:(f zkapp_uri_to_input)\n |> List.reduce_exn ~f:append\n\nlet default : _ Poly.t =\n (* These are the permissions of a \"user\"/\"non zkapp\" account. *)\n { app_state =\n Pickles_types.Vector.init Zkapp_state.Max_state_size.n ~f:(fun _ ->\n F.zero )\n ; verification_key = None\n ; zkapp_version = Mina_numbers.Zkapp_version.zero\n ; action_state =\n (let empty = Actions.empty_state_element in\n [ empty; empty; empty; empty; empty ] )\n ; last_action_slot = Mina_numbers.Global_slot_since_genesis.zero\n ; proved_state = false\n ; zkapp_uri = \"\"\n }\n\nlet digest (t : t) =\n Random_oracle.(\n hash ~init:Hash_prefix_states.zkapp_account (pack_input (to_input t)))\n\nlet default_digest = lazy (digest default)\n\nlet hash_zkapp_account_opt' = function\n | None ->\n Lazy.force default_digest\n | Some (a : t) ->\n digest a\n\nlet action_state_deriver obj =\n let open Fields_derivers_zkapps.Derivers in\n let list_5 = list ~static_length:5 (field @@ o ()) in\n let open Pickles_types.Vector.Vector_5 in\n iso ~map:of_list_exn ~contramap:to_list (list_5 (o ())) obj\n\nlet deriver obj =\n let open Fields_derivers_zkapps in\n let ( !. ) = ( !. ) ~t_fields_annots:Poly.t_fields_annots in\n finish \"ZkappAccount\" ~t_toplevel_annots:Poly.t_toplevel_annots\n @@ Poly.Fields.make_creator\n ~app_state:!.(Zkapp_state.deriver field)\n ~verification_key:\n !.(option ~js_type:Or_undefined (verification_key_with_hash @@ o ()))\n ~zkapp_version:!.uint32 ~action_state:!.action_state_deriver\n ~last_action_slot:!.global_slot_since_genesis\n ~proved_state:!.bool ~zkapp_uri:!.string obj\n\nlet gen_uri =\n let open Quickcheck in\n let open Generator.Let_syntax in\n let%bind parts =\n String.gen_with_length 8 Char.gen_alphanum |> Generator.list_with_length 3\n in\n let%map domain = Generator.of_list [ \"com\"; \"org\"; \"net\"; \"info\" ] in\n Printf.sprintf \"https://%s.%s\" (String.concat ~sep:\".\" parts) domain\n\nlet gen : t Quickcheck.Generator.t =\n let open Quickcheck in\n let open Generator.Let_syntax in\n let app_state =\n Pickles_types.Vector.init Zkapp_state.Max_state_size.n ~f:(fun _ ->\n F.random () )\n in\n let%bind zkapp_version = Mina_numbers.Zkapp_version.gen in\n let%bind seq_state = Generator.list_with_length 5 Field.gen in\n let%bind last_sequence_slot = Mina_numbers.Global_slot_since_genesis.gen in\n let%map zkapp_uri = gen_uri in\n let five = Pickles_types.Nat.(S (S (S (S (S Z))))) in\n { app_state\n ; verification_key = None\n ; zkapp_version\n ; action_state = Pickles_types.(Vector.of_list_and_length_exn seq_state five)\n ; last_action_slot = Mina_numbers.Global_slot_since_genesis.zero\n ; proved_state = false\n ; zkapp_uri\n }\n","(* account.ml *)\n\n[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Mina_base_util\nopen Snark_params\nopen Tick\nopen Currency\nopen Mina_numbers\nopen Fold_lib\nopen Mina_base_import\n\nmodule Index = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n module T = struct\n type t = int [@@deriving to_yojson, sexp, hash, compare]\n end\n\n include T\n\n let to_latest = Fn.id\n\n include Hashable.Make_binable (T)\n end\n end]\n\n include Hashable.Make_binable (Stable.Latest)\n\n let to_int = Int.to_int\n\n let gen ~ledger_depth = Int.gen_incl 0 ((1 lsl ledger_depth) - 1)\n\n module Vector = struct\n include Int\n\n let empty = zero\n\n let get t i = (t lsr i) land 1 = 1\n\n let set v i b = if b then v lor (one lsl i) else v land lnot (one lsl i)\n end\n\n let to_bits ~ledger_depth t = List.init ledger_depth ~f:(Vector.get t)\n\n let of_bits = List.foldi ~init:Vector.empty ~f:(fun i t b -> Vector.set t i b)\n\n let to_input ~ledger_depth x =\n List.map (to_bits ~ledger_depth x) ~f:(fun b -> (field_of_bool b, 1))\n |> List.to_array |> Random_oracle.Input.Chunked.packeds\n\n let fold_bits ~ledger_depth t =\n { Fold.fold =\n (fun ~init ~f ->\n let rec go acc i =\n if i = ledger_depth then acc else go (f acc (Vector.get t i)) (i + 1)\n in\n go init 0 )\n }\n\n let fold ~ledger_depth t =\n Fold.group3 ~default:false (fold_bits ~ledger_depth t)\n\n [%%ifdef consensus_mechanism]\n\n module Unpacked = struct\n type var = Tick.Boolean.var list\n\n type value = Vector.t\n\n let to_input x =\n List.map x ~f:(fun (b : Boolean.var) -> ((b :> Field.Var.t), 1))\n |> List.to_array |> Random_oracle.Input.Chunked.packeds\n\n let typ ~ledger_depth : (var, value) Tick.Typ.t =\n Typ.transport\n (Typ.list ~length:ledger_depth Boolean.typ)\n ~there:(to_bits ~ledger_depth) ~back:of_bits\n end\n\n [%%endif]\nend\n\nmodule Nonce = Account_nonce\n\nmodule Token_symbol = struct\n [%%versioned_binable\n module Stable = struct\n module V1 = struct\n module T = struct\n type t = string [@@deriving sexp, equal, compare, hash, yojson]\n\n let to_latest = Fn.id\n\n let max_length = 6\n\n let check (x : t) = assert (String.length x <= max_length)\n\n let t_of_sexp sexp =\n let res = t_of_sexp sexp in\n check res ; res\n\n let of_yojson json =\n let res = of_yojson json in\n Result.bind res ~f:(fun res ->\n Result.try_with (fun () -> check res)\n |> Result.map ~f:(Fn.const res)\n |> Result.map_error\n ~f:(Fn.const \"Token_symbol.of_yojson: symbol is too long\") )\n end\n\n include T\n\n include\n Binable.Of_binable_without_uuid\n (Core_kernel.String.Stable.V1)\n (struct\n type t = string\n\n let to_binable = Fn.id\n\n let of_binable x = check x ; x\n end)\n end\n end]\n\n [%%define_locally\n Stable.Latest.\n (sexp_of_t, t_of_sexp, equal, to_yojson, of_yojson, max_length, check)]\n\n let default = \"\"\n\n (* 48 = max_length * 8 *)\n module Num_bits = Pickles_types.Nat.N48\n\n let num_bits = Pickles_types.Nat.to_int Num_bits.n\n\n let to_bits (x : t) =\n Pickles_types.Vector.init Num_bits.n ~f:(fun i ->\n let byte_index = i / 8 in\n if byte_index < String.length x then\n let c = x.[byte_index] |> Char.to_int in\n c land (1 lsl (i mod 8)) <> 0\n else false )\n\n let of_bits x : t =\n let c, j, chars =\n Pickles_types.Vector.fold x ~init:(0, 0, []) ~f:(fun (c, j, chars) x ->\n let c = c lor ((if x then 1 else 0) lsl j) in\n if j = 7 then (0, 0, Char.of_int_exn c :: chars) else (c, j + 1, chars) )\n in\n assert (c = 0) ;\n assert (j = 0) ;\n let chars = List.drop_while ~f:(fun c -> Char.to_int c = 0) chars in\n String.of_char_list (List.rev chars)\n\n let to_field (x : t) : Field.t =\n Field.project (Pickles_types.Vector.to_list (to_bits x))\n\n let to_input (x : t) =\n Random_oracle_input.Chunked.packed (to_field x, num_bits)\n\n [%%ifdef consensus_mechanism]\n\n type var = Field.Var.t\n\n let range_check (t : var) =\n let%bind actual =\n make_checked (fun () ->\n let _, _, actual_packed =\n Pickles.Scalar_challenge.to_field_checked' ~num_bits m\n (Kimchi_backend_common.Scalar_challenge.create t)\n in\n actual_packed )\n in\n Field.Checked.Assert.equal t actual\n\n let var_of_value x =\n Pickles_types.Vector.map ~f:Boolean.var_of_value (to_bits x)\n\n let of_field (x : Field.t) : t =\n of_bits\n (Pickles_types.Vector.of_list_and_length_exn\n (List.take (Field.unpack x) num_bits)\n Num_bits.n )\n\n let typ : (var, t) Typ.t =\n let (Typ typ) = Field.typ in\n Typ.transport\n (Typ { typ with check = range_check })\n ~there:to_field ~back:of_field\n\n let var_to_input (x : var) = Random_oracle_input.Chunked.packed (x, num_bits)\n\n let if_ = Tick.Run.Field.if_\n\n [%%endif]\nend\n\n(* the `token_symbol` describes a token id owned by the account id\n from this account, not the token id used by this account\n*)\nmodule Poly = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type ( 'pk\n , 'id\n , 'token_symbol\n , 'amount\n , 'nonce\n , 'receipt_chain_hash\n , 'delegate\n , 'state_hash\n , 'timing\n , 'permissions\n , 'zkapp_opt )\n t =\n { public_key : 'pk\n ; token_id : 'id\n ; token_symbol : 'token_symbol\n ; balance : 'amount\n ; nonce : 'nonce\n ; receipt_chain_hash : 'receipt_chain_hash\n ; delegate : 'delegate\n ; voting_for : 'state_hash\n ; timing : 'timing\n ; permissions : 'permissions\n ; zkapp : 'zkapp_opt\n }\n [@@deriving sexp, equal, compare, hash, yojson, fields, hlist, annot]\n\n let to_latest = Fn.id\n end\n end]\nend\n\nlet token = Poly.token_id\n\nmodule Key = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Public_key.Compressed.Stable.V1.t\n [@@deriving sexp, equal, hash, compare, yojson]\n\n let to_latest = Fn.id\n end\n end]\nend\n\nmodule Identifier = Account_id\n\ntype key = Key.t [@@deriving sexp, equal, hash, compare, yojson]\n\nmodule Timing = Account_timing\n\nmodule Binable_arg = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t =\n ( Public_key.Compressed.Stable.V1.t\n , Token_id.Stable.V2.t\n , Token_symbol.Stable.V1.t\n , Balance.Stable.V1.t\n , Nonce.Stable.V1.t\n , Receipt.Chain_hash.Stable.V1.t\n , Public_key.Compressed.Stable.V1.t option\n , State_hash.Stable.V1.t\n , Timing.Stable.V2.t\n , Permissions.Stable.V2.t\n , Zkapp_account.Stable.V2.t option )\n (* TODO: Cache the digest of this? *)\n Poly.Stable.V2.t\n [@@deriving sexp, equal, hash, compare, yojson]\n\n let to_latest = Fn.id\n\n let public_key (t : t) : key = t.public_key\n end\n end]\nend\n\nlet check = Fn.id\n\n[%%versioned_binable\nmodule Stable = struct\n module V2 = struct\n type t = Binable_arg.Stable.V2.t\n [@@deriving sexp, equal, hash, compare, yojson]\n\n include\n Binable.Of_binable_without_uuid\n (Binable_arg.Stable.V2)\n (struct\n type nonrec t = t\n\n let to_binable = check\n\n let of_binable = check\n end)\n\n let to_latest = Fn.id\n\n let public_key (t : t) : key = t.public_key\n end\nend]\n\n[%%define_locally Stable.Latest.(public_key)]\n\nlet identifier ({ public_key; token_id; _ } : t) =\n Account_id.create public_key token_id\n\ntype value =\n ( Public_key.Compressed.t\n , Token_id.t\n , Token_symbol.t\n , Balance.t\n , Nonce.t\n , Receipt.Chain_hash.t\n , Public_key.Compressed.t option\n , State_hash.t\n , Timing.t\n , Permissions.t\n , Zkapp_account.t option )\n Poly.t\n[@@deriving sexp]\n\nlet key_gen = Public_key.Compressed.gen\n\nlet initialize account_id : t =\n let public_key = Account_id.public_key account_id in\n let token_id = Account_id.token_id account_id in\n let delegate =\n (* Only allow delegation if this account is for the default token. *)\n if Token_id.(equal default token_id) then Some public_key else None\n in\n { public_key\n ; token_id\n ; token_symbol = \"\"\n ; balance = Balance.zero\n ; nonce = Nonce.zero\n ; receipt_chain_hash = Receipt.Chain_hash.empty\n ; delegate\n ; voting_for = State_hash.dummy\n ; timing = Timing.Untimed\n ; permissions = Permissions.user_default\n ; zkapp = None\n }\n\nlet hash_zkapp_account_opt = function\n | None ->\n Lazy.force Zkapp_account.default_digest\n | Some (a : Zkapp_account.t) ->\n Zkapp_account.digest a\n\nlet delegate_opt = Option.value ~default:Public_key.Compressed.empty\n\nlet to_input (t : t) =\n let open Random_oracle.Input.Chunked in\n let f mk acc field = mk (Core_kernel.Field.get field t) :: acc in\n Poly.Fields.fold ~init:[]\n ~public_key:(f Public_key.Compressed.to_input)\n ~token_id:(f Token_id.to_input) ~balance:(f Balance.to_input)\n ~token_symbol:(f Token_symbol.to_input) ~nonce:(f Nonce.to_input)\n ~receipt_chain_hash:(f Receipt.Chain_hash.to_input)\n ~delegate:(f (Fn.compose Public_key.Compressed.to_input delegate_opt))\n ~voting_for:(f State_hash.to_input) ~timing:(f Timing.to_input)\n ~zkapp:(f (Fn.compose field hash_zkapp_account_opt))\n ~permissions:(f Permissions.to_input)\n |> List.reduce_exn ~f:append\n\nlet crypto_hash_prefix = Hash_prefix.account\n\nlet crypto_hash t =\n Random_oracle.hash ~init:crypto_hash_prefix\n (Random_oracle.pack_input (to_input t))\n\n[%%ifdef consensus_mechanism]\n\ntype var =\n ( Public_key.Compressed.var\n , Token_id.Checked.t\n , Token_symbol.var\n , Balance.var\n , Nonce.Checked.t\n , Receipt.Chain_hash.var\n , Public_key.Compressed.var\n , State_hash.var\n , Timing.var\n , Permissions.Checked.t\n (* TODO: This is a hack that lets us avoid unhashing zkApp accounts when we don't need to *)\n , Field.Var.t * Zkapp_account.t option As_prover.Ref.t )\n Poly.t\n\nlet identifier_of_var ({ public_key; token_id; _ } : var) =\n Account_id.Checked.create public_key token_id\n\nlet typ' zkapp =\n Typ.of_hlistable\n [ Public_key.Compressed.typ\n ; Token_id.typ\n ; Token_symbol.typ\n ; Balance.typ\n ; Nonce.typ\n ; Receipt.Chain_hash.typ\n ; Typ.transport Public_key.Compressed.typ ~there:delegate_opt\n ~back:(fun delegate ->\n if Public_key.Compressed.(equal empty) delegate then None\n else Some delegate )\n ; State_hash.typ\n ; Timing.typ\n ; Permissions.typ\n ; zkapp\n ]\n ~var_to_hlist:Poly.to_hlist ~var_of_hlist:Poly.of_hlist\n ~value_to_hlist:Poly.to_hlist ~value_of_hlist:Poly.of_hlist\n\nlet typ : (var, value) Typ.t =\n let zkapp :\n ( Field.Var.t * Zkapp_account.t option As_prover.Ref.t\n , Zkapp_account.t option )\n Typ.t =\n let account :\n (Zkapp_account.t option As_prover.Ref.t, Zkapp_account.t option) Typ.t =\n Typ.Internal.ref ()\n in\n Typ.(Field.typ * account)\n |> Typ.transport ~there:(fun x -> (hash_zkapp_account_opt x, x)) ~back:snd\n in\n typ' zkapp\n\nlet var_of_t\n ({ public_key\n ; token_id\n ; token_symbol\n ; balance\n ; nonce\n ; receipt_chain_hash\n ; delegate\n ; voting_for\n ; timing\n ; permissions\n ; zkapp\n } :\n value ) =\n { Poly.public_key = Public_key.Compressed.var_of_t public_key\n ; token_id = Token_id.Checked.constant token_id\n ; token_symbol = Token_symbol.var_of_value token_symbol\n ; balance = Balance.var_of_t balance\n ; nonce = Nonce.Checked.constant nonce\n ; receipt_chain_hash = Receipt.Chain_hash.var_of_t receipt_chain_hash\n ; delegate = Public_key.Compressed.var_of_t (delegate_opt delegate)\n ; voting_for = State_hash.var_of_t voting_for\n ; timing = Timing.var_of_t timing\n ; permissions = Permissions.Checked.constant permissions\n ; zkapp = Field.Var.constant (hash_zkapp_account_opt zkapp)\n }\n\nmodule Checked = struct\n module Unhashed = struct\n type t =\n ( Public_key.Compressed.var\n , Token_id.Checked.t\n , Token_symbol.var\n , Balance.var\n , Nonce.Checked.t\n , Receipt.Chain_hash.var\n , Public_key.Compressed.var\n , State_hash.var\n , Timing.var\n , Permissions.Checked.t\n , Zkapp_account.Checked.t )\n Poly.t\n\n let typ : (t, Stable.Latest.t) Typ.t =\n typ'\n (Typ.transport Zkapp_account.typ\n ~there:(fun t -> Option.value t ~default:Zkapp_account.default)\n ~back:(fun t -> Some t) )\n end\n\n let to_input (t : var) =\n let f mk acc field = mk (Core_kernel.Field.get field t) :: acc in\n let open Random_oracle.Input.Chunked in\n List.reduce_exn ~f:append\n (Poly.Fields.fold ~init:[]\n ~zkapp:(f (fun (x, _) -> field x))\n ~permissions:(f Permissions.Checked.to_input)\n ~public_key:(f Public_key.Compressed.Checked.to_input)\n ~token_id:(f Token_id.Checked.to_input)\n ~token_symbol:(f Token_symbol.var_to_input)\n ~balance:(f Balance.var_to_input) ~nonce:(f Nonce.Checked.to_input)\n ~receipt_chain_hash:(f Receipt.Chain_hash.var_to_input)\n ~delegate:(f Public_key.Compressed.Checked.to_input)\n ~voting_for:(f State_hash.var_to_input)\n ~timing:(f Timing.var_to_input) )\n\n let digest t =\n make_checked (fun () ->\n Random_oracle.Checked.(\n hash ~init:crypto_hash_prefix (pack_input (to_input t))) )\n\n let balance_upper_bound = Bignum_bigint.(one lsl Balance.length_in_bits)\n\n let amount_upper_bound = Bignum_bigint.(one lsl Amount.length_in_bits)\n\n let min_balance_at_slot ~global_slot ~cliff_time ~cliff_amount\n ~(vesting_period : Mina_numbers.Global_slot_span.Checked.var)\n ~vesting_increment ~initial_minimum_balance =\n let%bind before_cliff =\n Global_slot_since_genesis.Checked.(global_slot < cliff_time)\n in\n let%bind else_branch =\n make_checked (fun () ->\n let _, (slot_diff : Mina_numbers.Global_slot_span.Checked.var) =\n Tick.Run.run_checked\n (Global_slot_since_genesis.Checked.diff_or_zero global_slot\n cliff_time )\n in\n let cliff_decrement = cliff_amount in\n let min_balance_less_cliff_decrement =\n Tick.Run.run_checked\n (Balance.Checked.sub_amount_or_zero initial_minimum_balance\n cliff_decrement )\n in\n let (num_periods : Mina_numbers.Global_slot_span.Checked.var), _ =\n Tick.Run.run_checked\n (Global_slot_span.Checked.div_mod slot_diff vesting_period)\n in\n let vesting_decrement =\n Tick.Run.Field.mul\n (Global_slot_span.Checked.to_field num_periods)\n (Amount.pack_var vesting_increment)\n in\n let min_balance_less_cliff_and_vesting_decrements =\n Tick.Run.run_checked\n (Balance.Checked.sub_amount_or_zero\n min_balance_less_cliff_decrement\n Amount.(Checked.Unsafe.of_field vesting_decrement) )\n in\n min_balance_less_cliff_and_vesting_decrements )\n in\n Balance.Checked.if_ before_cliff ~then_:initial_minimum_balance\n ~else_:else_branch\n\n let has_locked_tokens ~global_slot (t : var) =\n let open Timing.As_record in\n let { is_timed = _\n ; initial_minimum_balance\n ; cliff_time\n ; cliff_amount\n ; vesting_period\n ; vesting_increment\n } =\n t.timing\n in\n let%bind cur_min_balance =\n min_balance_at_slot ~global_slot ~initial_minimum_balance ~cliff_time\n ~cliff_amount ~vesting_period ~vesting_increment\n in\n let%map zero_min_balance =\n Balance.equal_var Balance.(var_of_t zero) cur_min_balance\n in\n (*Note: Untimed accounts will always have zero min balance*)\n Boolean.not zero_min_balance\n\n let has_permission ?signature_verifies ~to_ (account : var) =\n let signature_verifies =\n match signature_verifies with\n | Some signature_verifies ->\n signature_verifies\n | None -> (\n match to_ with\n | `Send ->\n Boolean.true_\n | `Receive ->\n Boolean.false_\n | `Set_delegate ->\n Boolean.true_\n | `Increment_nonce ->\n Boolean.true_\n | `Access ->\n failwith\n \"Account.Checked.has_permission: signature_verifies argument \\\n must be given for access permission\" )\n in\n match to_ with\n | `Send ->\n Permissions.Auth_required.Checked.eval_no_proof account.permissions.send\n ~signature_verifies\n | `Receive ->\n Permissions.Auth_required.Checked.eval_no_proof\n account.permissions.receive ~signature_verifies\n | `Set_delegate ->\n Permissions.Auth_required.Checked.eval_no_proof\n account.permissions.set_delegate ~signature_verifies\n | `Increment_nonce ->\n Permissions.Auth_required.Checked.eval_no_proof\n account.permissions.increment_nonce ~signature_verifies\n | `Access ->\n Permissions.Auth_required.Checked.eval_no_proof\n account.permissions.access ~signature_verifies\nend\n\n[%%endif]\n\nlet digest = crypto_hash\n\nlet empty =\n { Poly.public_key = Public_key.Compressed.empty\n ; token_id = Token_id.default\n ; token_symbol = Token_symbol.default\n ; balance = Balance.zero\n ; nonce = Nonce.zero\n ; receipt_chain_hash = Receipt.Chain_hash.empty\n ; delegate = None\n ; voting_for = State_hash.dummy\n ; timing = Timing.Untimed\n ; permissions =\n Permissions.user_default\n (* TODO: This should maybe be Permissions.empty *)\n ; zkapp = None\n }\n\nlet empty_digest = digest empty\n\nlet create account_id balance =\n let public_key = Account_id.public_key account_id in\n let token_id = Account_id.token_id account_id in\n let delegate =\n (* Only allow delegation if this account is for the default token. *)\n if Token_id.(equal default) token_id then Some public_key else None\n in\n { Poly.public_key\n ; token_id\n ; token_symbol = Token_symbol.default\n ; balance\n ; nonce = Nonce.zero\n ; receipt_chain_hash = Receipt.Chain_hash.empty\n ; delegate\n ; voting_for = State_hash.dummy\n ; timing = Timing.Untimed\n ; permissions = Permissions.user_default\n ; zkapp = None\n }\n\nlet create_timed account_id balance ~initial_minimum_balance ~cliff_time\n ~cliff_amount ~vesting_period ~vesting_increment =\n if Global_slot_span.(equal vesting_period zero) then\n Or_error.errorf\n !\"Error creating timed account for account id %{sexp: Account_id.t}: \\\n vesting period must be greater than zero\"\n account_id\n else\n let public_key = Account_id.public_key account_id in\n let token_id = Account_id.token_id account_id in\n let delegate =\n (* Only allow delegation if this account is for the default token. *)\n if Token_id.(equal default) token_id then Some public_key else None\n in\n Or_error.return\n { Poly.public_key\n ; token_id\n ; token_symbol = Token_symbol.default\n ; balance\n ; nonce = Nonce.zero\n ; receipt_chain_hash = Receipt.Chain_hash.empty\n ; delegate\n ; voting_for = State_hash.dummy\n ; zkapp = None\n ; permissions = Permissions.user_default\n ; timing =\n Timing.Timed\n { initial_minimum_balance\n ; cliff_time\n ; cliff_amount\n ; vesting_period\n ; vesting_increment\n }\n }\n\n(* no vesting after cliff time + 1 slot *)\nlet create_time_locked public_key balance ~initial_minimum_balance ~cliff_time =\n create_timed public_key balance ~initial_minimum_balance ~cliff_time\n ~vesting_period:Global_slot_span.(succ zero)\n ~vesting_increment:initial_minimum_balance\n\nlet initial_minimum_balance Poly.{ timing; _ } =\n match timing with\n | Timing.Untimed ->\n None\n | Timed t ->\n Some t.initial_minimum_balance\n\nlet cliff_time Poly.{ timing; _ } =\n match timing with Timing.Untimed -> None | Timed t -> Some t.cliff_time\n\nlet cliff_amount Poly.{ timing; _ } =\n match timing with Timing.Untimed -> None | Timed t -> Some t.cliff_amount\n\nlet vesting_increment Poly.{ timing } =\n match timing with\n | Timing.Untimed ->\n None\n | Timed t ->\n Some t.vesting_increment\n\nlet vesting_period Poly.{ timing; _ } =\n match timing with Timing.Untimed -> None | Timed t -> Some t.vesting_period\n\nlet min_balance_at_slot ~global_slot ~cliff_time ~cliff_amount ~vesting_period\n ~vesting_increment ~initial_minimum_balance =\n let open Unsigned in\n if Global_slot_since_genesis.(global_slot < cliff_time) then\n initial_minimum_balance\n (* If vesting period is zero then everything vests immediately at the cliff *)\n else if Global_slot_span.(equal vesting_period zero) then Balance.zero\n else\n match Balance.(initial_minimum_balance - cliff_amount) with\n | None ->\n Balance.zero\n | Some min_balance_past_cliff -> (\n (* take advantage of fact that global slots are uint32's *)\n let num_periods =\n UInt32.(\n let global_slot_u32 =\n Global_slot_since_genesis.to_uint32 global_slot\n in\n let cliff_time_u32 =\n Global_slot_since_genesis.to_uint32 cliff_time\n in\n let vesting_period_u32 =\n Global_slot_span.to_uint32 vesting_period\n in\n Infix.((global_slot_u32 - cliff_time_u32) / vesting_period_u32)\n |> to_int64 |> UInt64.of_int64)\n in\n let vesting_decrement =\n let vesting_increment = Amount.to_uint64 vesting_increment in\n if\n try\n UInt64.(compare Infix.(max_int / num_periods) vesting_increment)\n < 0\n with Division_by_zero -> false\n then\n (* The vesting decrement will overflow, use [max_int] instead. *)\n UInt64.max_int |> Amount.of_uint64\n else\n UInt64.Infix.(num_periods * vesting_increment) |> Amount.of_uint64\n in\n match Balance.(min_balance_past_cliff - vesting_decrement) with\n | None ->\n Balance.zero\n | Some amt ->\n amt )\n\nlet incremental_balance_between_slots ~start_slot ~end_slot ~cliff_time\n ~cliff_amount ~vesting_period ~vesting_increment ~initial_minimum_balance :\n Unsigned.UInt64.t =\n let open Unsigned in\n if Global_slot_since_genesis.(end_slot <= start_slot) then UInt64.zero\n else\n let min_balance_at_start_slot =\n min_balance_at_slot ~global_slot:start_slot ~cliff_time ~cliff_amount\n ~vesting_period ~vesting_increment ~initial_minimum_balance\n |> Balance.to_amount |> Amount.to_uint64\n in\n let min_balance_at_end_slot =\n min_balance_at_slot ~global_slot:end_slot ~cliff_time ~cliff_amount\n ~vesting_period ~vesting_increment ~initial_minimum_balance\n |> Balance.to_amount |> Amount.to_uint64\n in\n UInt64.Infix.(min_balance_at_start_slot - min_balance_at_end_slot)\n\nlet has_locked_tokens ~global_slot (account : t) =\n match account.timing with\n | Untimed ->\n false\n | Timed\n { initial_minimum_balance\n ; cliff_time\n ; cliff_amount\n ; vesting_period\n ; vesting_increment\n } ->\n let curr_min_balance =\n min_balance_at_slot ~global_slot ~cliff_time ~cliff_amount\n ~vesting_period ~vesting_increment ~initial_minimum_balance\n in\n Balance.(curr_min_balance > zero)\n\nlet final_vesting_slot ~initial_minimum_balance ~cliff_time ~cliff_amount\n ~vesting_period ~vesting_increment =\n let open Unsigned in\n let to_vest =\n Balance.(initial_minimum_balance - cliff_amount)\n |> Option.value_map ~default:UInt64.zero ~f:Balance.to_uint64\n in\n let vest_incr = Amount.to_uint64 vesting_increment in\n let periods =\n let open UInt64 in\n let open Infix in\n (to_vest / vest_incr)\n + if equal (rem to_vest vest_incr) zero then zero else one\n in\n let open UInt32 in\n let open Infix in\n Global_slot_since_genesis.of_uint32\n @@ Global_slot_since_genesis.to_uint32 cliff_time\n + (UInt64.to_uint32 periods * Global_slot_span.to_uint32 vesting_period)\n\nlet timing_final_vesting_slot = function\n | Timing.Untimed ->\n Global_slot_since_genesis.zero\n | Timed\n { initial_minimum_balance\n ; cliff_time\n ; cliff_amount\n ; vesting_period\n ; vesting_increment\n } ->\n final_vesting_slot ~initial_minimum_balance ~cliff_time ~cliff_amount\n ~vesting_period ~vesting_increment\n\nlet has_permission ~control ~to_ (account : t) =\n match to_ with\n | `Access ->\n Permissions.Auth_required.check account.permissions.access control\n | `Send ->\n Permissions.Auth_required.check account.permissions.send control\n | `Receive ->\n Permissions.Auth_required.check account.permissions.receive control\n | `Set_delegate ->\n Permissions.Auth_required.check account.permissions.set_delegate control\n | `Increment_nonce ->\n Permissions.Auth_required.check account.permissions.increment_nonce\n control\n\n(** [true] iff account has permissions set that enable them to transfer Mina (assuming the command is signed) *)\nlet has_permission_to_send account =\n has_permission ~control:Control.Tag.Signature ~to_:`Access account\n && has_permission ~control:Control.Tag.Signature ~to_:`Send account\n\n(** [true] iff account has permissions set that enable them to receive Mina *)\nlet has_permission_to_receive account =\n has_permission ~control:Control.Tag.None_given ~to_:`Access account\n && has_permission ~control:Control.Tag.None_given ~to_:`Receive account\n\n(** [true] iff account has permissions set that enable them to set their delegate (assuming the command is signed) *)\nlet has_permission_to_set_delegate account =\n has_permission ~control:Control.Tag.Signature ~to_:`Access account\n && has_permission ~control:Control.Tag.Signature ~to_:`Set_delegate account\n\n(** [true] iff account has permissions set that enable them to increment their nonce (assuming the command is signed) *)\nlet has_permission_to_increment_nonce account =\n has_permission ~control:Control.Tag.Signature ~to_:`Access account\n && has_permission ~control:Control.Tag.Signature ~to_:`Increment_nonce account\n\nlet liquid_balance_at_slot ~global_slot (account : t) =\n match account.timing with\n | Untimed ->\n account.balance\n | Timed\n { initial_minimum_balance\n ; cliff_time\n ; cliff_amount\n ; vesting_period\n ; vesting_increment\n } ->\n Balance.sub_amount account.balance\n (Balance.to_amount\n (min_balance_at_slot ~global_slot ~cliff_time ~cliff_amount\n ~vesting_period ~vesting_increment ~initial_minimum_balance ) )\n |> Option.value_exn\n\nlet gen : t Quickcheck.Generator.t =\n let open Quickcheck.Let_syntax in\n let%bind public_key = Public_key.Compressed.gen in\n let%bind token_id = Token_id.gen in\n let%map balance = Currency.Balance.gen in\n create (Account_id.create public_key token_id) balance\n\nlet gen_with_constrained_balance ~low ~high : t Quickcheck.Generator.t =\n let open Quickcheck.Let_syntax in\n let%bind public_key = Public_key.Compressed.gen in\n let%bind token_id = Token_id.gen in\n let%map balance = Currency.Balance.gen_incl low high in\n create (Account_id.create public_key token_id) balance\n\nlet gen_any_vesting_range =\n let open Quickcheck.Generator.Let_syntax in\n let open Global_slot_since_genesis in\n (* vesting period must be at least one to avoid division by zero *)\n let%bind vesting_period = Int.gen_incl 1 1000 >>| Global_slot_span.of_int in\n let%bind vesting_end = gen_incl (of_int 1) max_value in\n let%map cliff_time = gen_incl (of_int 1) vesting_end in\n (cliff_time, vesting_end, vesting_period)\n\nlet gen_with_vesting_period vesting_period =\n let open Quickcheck.Generator.Let_syntax in\n let open Global_slot_since_genesis in\n let min_vesting_end =\n Global_slot_span.(succ vesting_period |> to_uint32)\n |> Global_slot_since_genesis.of_uint32\n in\n let%bind vesting_end = gen_incl min_vesting_end max_value in\n let max_cliff_time = Option.value_exn @@ sub vesting_end vesting_period in\n let%map cliff_time = gen_incl (of_int 1) max_cliff_time in\n (cliff_time, vesting_end, vesting_period)\n\nlet gen_vesting_details ~(cliff_time : Global_slot_since_genesis.t)\n ~(vesting_end : Global_slot_since_genesis.t)\n ~(vesting_period : Global_slot_span.t) (initial_minimum_balance : Balance.t)\n : Timing.as_record Quickcheck.Generator.t =\n let open Unsigned in\n let open Quickcheck in\n let open Generator.Let_syntax in\n let vesting_slots =\n let open Global_slot_since_genesis in\n let open UInt32.Infix in\n to_uint32 vesting_end - to_uint32 cliff_time\n in\n (* We need to arrange vesting schedule so that all funds are vested before the\n maximum global slot, which is 2 ^ 32. *)\n let vesting_periods_count =\n Unsigned.UInt32.div vesting_slots\n (Global_slot_span.to_uint32 vesting_period)\n |> UInt64.of_uint32\n in\n let max_cliff_amt =\n Balance.(initial_minimum_balance - Amount.of_uint64 vesting_periods_count)\n |> Option.value_map ~f:Balance.to_amount ~default:Amount.zero\n in\n let%map cliff_amount =\n if UInt64.(compare vesting_periods_count zero) > 0 then\n Amount.(gen_incl zero max_cliff_amt)\n else return @@ Balance.to_amount initial_minimum_balance\n in\n let to_vest =\n Balance.(initial_minimum_balance - cliff_amount)\n |> Option.value_map ~default:Unsigned.UInt64.zero ~f:Balance.to_uint64\n in\n let vesting_increment =\n if Unsigned.UInt64.(equal vesting_periods_count zero) then Amount.one\n (* This value does not matter anyway. *)\n else\n let vi = UInt64.Infix.(to_vest / vesting_periods_count) in\n let rnd = UInt64.Infix.(to_vest mod vesting_periods_count) in\n (if UInt64.(compare rnd zero) > 0 then UInt64.succ vi else vi)\n |> Amount.of_uint64\n in\n { Timing.As_record.is_timed = true\n ; initial_minimum_balance\n ; cliff_time\n ; cliff_amount\n ; vesting_period\n ; vesting_increment\n }\n\nlet gen_timing (account_balance : Balance.t) =\n let open Quickcheck.Generator.Let_syntax in\n let%bind initial_minimum_balance = Balance.(gen_incl one account_balance)\n and cliff_time, vesting_end, vesting_period = gen_any_vesting_range in\n gen_vesting_details ~vesting_period ~cliff_time ~vesting_end\n initial_minimum_balance\n\nlet gen_timing_at_least_one_vesting_period (account_balance : Balance.t) =\n let open Quickcheck.Generator.Let_syntax in\n let%bind initial_minimum_balance = Balance.(gen_incl one account_balance)\n (* vesting period must be at least one to avoid division by zero *)\n and cliff_time, vesting_end, vesting_period =\n gen_with_vesting_period @@ Global_slot_span.of_int 2\n in\n gen_vesting_details ~vesting_period ~cliff_time ~vesting_end\n initial_minimum_balance\n\nlet gen_timed : t Quickcheck.Generator.t =\n let open Quickcheck in\n let open Generator.Let_syntax in\n let%bind account =\n gen_with_constrained_balance ~low:Balance.one ~high:Balance.max_int\n in\n let%map timing = gen_timing account.balance in\n { account with timing = Timing.of_record timing }\n\nlet deriver obj =\n let open Fields_derivers_zkapps in\n let ( !. ) = ( !. ) ~t_fields_annots:Poly.t_fields_annots in\n let receipt_chain_hash =\n needs_custom_js ~js_type:field ~name:\"ReceiptChainHash\" field\n in\n finish \"Account\" ~t_toplevel_annots:Poly.t_toplevel_annots\n @@ Poly.Fields.make_creator ~public_key:!.public_key\n ~token_id:!.Token_id.deriver ~token_symbol:!.string ~balance:!.balance\n ~nonce:!.uint32 ~receipt_chain_hash:!.receipt_chain_hash\n ~delegate:!.(option ~js_type:Or_undefined (public_key @@ o ()))\n ~voting_for:!.field ~timing:!.Timing.deriver\n ~permissions:!.Permissions.deriver\n ~zkapp:!.(option ~js_type:Or_undefined (Zkapp_account.deriver @@ o ()))\n obj\n","open Core_kernel\nopen Currency\nopen Snark_params.Tick\n\nmodule Poly = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type ('ledger_hash, 'amount) t =\n ( 'ledger_hash\n , 'amount )\n Mina_wire_types.Mina_base.Epoch_ledger.Poly.V1.t =\n { hash : 'ledger_hash; total_currency : 'amount }\n [@@deriving annot, sexp, equal, compare, hash, yojson, hlist, fields]\n end\n end]\nend\n\nmodule Value = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t =\n (Frozen_ledger_hash0.Stable.V1.t, Amount.Stable.V1.t) Poly.Stable.V1.t\n [@@deriving sexp, equal, compare, hash, yojson]\n\n let to_latest = Fn.id\n end\n end]\nend\n\nlet to_input ({ hash; total_currency } : Value.t) =\n Random_oracle_input.Chunked.(\n append (field (hash :> Field.t)) (Amount.to_input total_currency))\n\ntype var = (Frozen_ledger_hash0.var, Amount.var) Poly.t\n\nlet typ : (var, Value.t) Typ.t =\n Typ.of_hlistable\n [ Frozen_ledger_hash0.typ; Amount.typ ]\n ~var_to_hlist:Poly.to_hlist ~var_of_hlist:Poly.of_hlist\n ~value_to_hlist:Poly.to_hlist ~value_of_hlist:Poly.of_hlist\n\nlet var_to_input ({ Poly.hash; total_currency } : var) =\n let total_currency = Amount.var_to_input total_currency in\n Random_oracle_input.Chunked.(\n append (field (Frozen_ledger_hash0.var_to_hash_packed hash)) total_currency)\n\nlet if_ cond ~(then_ : (Frozen_ledger_hash0.var, Amount.var) Poly.t)\n ~(else_ : (Frozen_ledger_hash0.var, Amount.var) Poly.t) =\n let open Checked.Let_syntax in\n let%map hash =\n Frozen_ledger_hash0.if_ cond ~then_:then_.hash ~else_:else_.hash\n and total_currency =\n Amount.Checked.if_ cond ~then_:then_.total_currency\n ~else_:else_.total_currency\n in\n { Poly.hash; total_currency }\n","open Core_kernel\n\ninclude Data_hash.Make_full_size (struct\n let version_byte = Base58_check.Version_bytes.epoch_seed\n\n let description = \"Epoch Seed\"\nend)\n\n[%%versioned\nmodule Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n module T = struct\n type t = (Snark_params.Tick.Field.t[@version_asserted])\n [@@deriving sexp, compare, hash]\n end\n\n include T\n\n let to_latest = Fn.id\n\n [%%define_from_scope to_yojson, of_yojson]\n\n include Comparable.Make (T)\n include Hashable.Make_binable (T)\n end\nend]\n\nlet _f () : (Stable.Latest.t, t) Type_equal.t = Type_equal.T\n","open Core_kernel\nopen Mina_numbers\n\nmodule Poly = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type ( 'epoch_ledger\n , 'epoch_seed\n , 'start_checkpoint\n , 'lock_checkpoint\n , 'length )\n t =\n ( 'epoch_ledger\n , 'epoch_seed\n , 'start_checkpoint\n , 'lock_checkpoint\n , 'length )\n Mina_wire_types.Mina_base.Epoch_data.Poly.V1.t =\n { ledger : 'epoch_ledger\n ; seed : 'epoch_seed\n ; start_checkpoint : 'start_checkpoint\n (* The lock checkpoint is the hash of the latest state in the seed update range, not including\n the current state. *)\n ; lock_checkpoint : 'lock_checkpoint\n ; epoch_length : 'length\n }\n [@@deriving annot, hlist, sexp, equal, compare, hash, yojson, fields]\n end\n end]\nend\n\ntype var =\n ( Epoch_ledger.var\n , Epoch_seed.var\n , State_hash.var\n , State_hash.var\n , Length.Checked.t )\n Poly.t\n\nlet if_ cond ~(then_ : var) ~(else_ : var) =\n let open Snark_params.Tick.Checked.Let_syntax in\n let%map ledger = Epoch_ledger.if_ cond ~then_:then_.ledger ~else_:else_.ledger\n and seed = Epoch_seed.if_ cond ~then_:then_.seed ~else_:else_.seed\n and start_checkpoint =\n State_hash.if_ cond ~then_:then_.start_checkpoint\n ~else_:else_.start_checkpoint\n and lock_checkpoint =\n State_hash.if_ cond ~then_:then_.lock_checkpoint\n ~else_:else_.lock_checkpoint\n and epoch_length =\n Length.Checked.if_ cond ~then_:then_.epoch_length ~else_:else_.epoch_length\n in\n { Poly.ledger; seed; start_checkpoint; lock_checkpoint; epoch_length }\n\nmodule Value = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t =\n ( Epoch_ledger.Value.Stable.V1.t\n , Epoch_seed.Stable.V1.t\n , State_hash.Stable.V1.t\n , State_hash.Stable.V1.t\n , Length.Stable.V1.t )\n Poly.Stable.V1.t\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n end\n end]\nend\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\n\n[%%ifdef consensus_mechanism]\n\nopen Snark_params.Tick\n\n[%%endif]\n\nopen Signature_lib\nmodule A = Account\nopen Mina_numbers\nopen Currency\nopen Zkapp_basic\nopen Pickles_types\nmodule Impl = Pickles.Impls.Step\n\nmodule Closed_interval = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type 'a t =\n 'a Mina_wire_types.Mina_base.Zkapp_precondition.Closed_interval.V1.t =\n { lower : 'a; upper : 'a }\n [@@deriving annot, sexp, equal, compare, hash, yojson, hlist, fields]\n end\n end]\n\n let gen gen_a compare_a =\n let open Quickcheck.Let_syntax in\n let%bind a1 = gen_a in\n let%map a2 = gen_a in\n if compare_a a1 a2 <= 0 then { lower = a1; upper = a2 }\n else { lower = a2; upper = a1 }\n\n let to_input { lower; upper } ~f =\n Random_oracle_input.Chunked.append (f lower) (f upper)\n\n let typ x =\n Typ.of_hlistable [ x; x ] ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist\n ~value_to_hlist:to_hlist ~value_of_hlist:of_hlist\n\n let deriver ~name inner obj =\n let open Fields_derivers_zkapps.Derivers in\n let ( !. ) = ( !. ) ~t_fields_annots in\n Fields.make_creator obj ~lower:!.inner ~upper:!.inner\n |> finish (name ^ \"Interval\") ~t_toplevel_annots\n\n let%test_module \"ClosedInterval\" =\n ( module struct\n module IntClosedInterval = struct\n type t_ = int t [@@deriving sexp, equal, compare]\n\n (* Note: nonrec doesn't work with ppx-deriving *)\n type t = t_ [@@deriving sexp, equal, compare]\n\n let v = { lower = 10; upper = 100 }\n end\n\n let%test_unit \"roundtrip json\" =\n let open Fields_derivers_zkapps.Derivers in\n let full = o () in\n let _a : _ Unified_input.t = deriver ~name:\"Int\" int full in\n [%test_eq: IntClosedInterval.t]\n (!(full#of_json) (!(full#to_json) IntClosedInterval.v))\n IntClosedInterval.v\n end )\nend\n\nlet assert_ b e = if b then Ok () else Or_error.error_string e\n\n(* Proofs are produced against a predicate on the protocol state. For the\n transaction to go through, the predicate must be satisfied of the protocol\n state at the time of transaction application. *)\nmodule Numeric = struct\n module Tc = struct\n type ('var, 'a) t =\n { zero : 'a\n ; max_value : 'a\n ; compare : 'a -> 'a -> int\n ; equal : 'a -> 'a -> bool\n ; typ : ('var, 'a) Typ.t\n ; to_input : 'a -> F.t Random_oracle_input.Chunked.t\n ; to_input_checked : 'var -> Field.Var.t Random_oracle_input.Chunked.t\n ; lte_checked : 'var -> 'var -> Boolean.var\n ; eq_checked : 'var -> 'var -> Boolean.var\n }\n\n let run f x y = Impl.run_checked (f x y)\n\n let ( !! ) f = Fn.compose Impl.run_checked f\n\n let length =\n Length.\n { zero\n ; max_value\n ; compare\n ; lte_checked = run Checked.( <= )\n ; eq_checked = run Checked.( = )\n ; equal\n ; typ\n ; to_input\n ; to_input_checked = Checked.to_input\n }\n\n let amount =\n Currency.Amount.\n { zero\n ; max_value = max_int\n ; compare\n ; lte_checked = run Checked.( <= )\n ; eq_checked = run Checked.( = )\n ; equal\n ; typ\n ; to_input\n ; to_input_checked = var_to_input\n }\n\n let balance =\n Currency.Balance.\n { zero\n ; max_value = max_int\n ; compare\n ; lte_checked = run Checked.( <= )\n ; eq_checked = run Checked.( = )\n ; equal\n ; typ\n ; to_input\n ; to_input_checked = var_to_input\n }\n\n let nonce =\n Account_nonce.\n { zero\n ; max_value\n ; compare\n ; lte_checked = run Checked.( <= )\n ; eq_checked = run Checked.( = )\n ; equal\n ; typ\n ; to_input\n ; to_input_checked = Checked.to_input\n }\n\n let global_slot =\n Global_slot_since_genesis.\n { zero\n ; max_value\n ; compare\n ; lte_checked = run Checked.( <= )\n ; eq_checked = run Checked.( = )\n ; equal\n ; typ\n ; to_input\n ; to_input_checked = Checked.to_input\n }\n end\n\n open Tc\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n type 'a t = 'a Closed_interval.Stable.V1.t Or_ignore.Stable.V1.t\n [@@deriving sexp, equal, yojson, hash, compare]\n end\n end]\n\n let deriver name inner range_max obj =\n let closed_interval obj' = Closed_interval.deriver ~name inner obj' in\n Or_ignore.deriver_interval ~range_max closed_interval obj\n\n module Derivers = struct\n open Fields_derivers_zkapps.Derivers\n\n let range_uint32 =\n Unsigned_extended.UInt32.(to_string zero, to_string max_int)\n\n let range_uint64 =\n Unsigned_extended.UInt64.(to_string zero, to_string max_int)\n\n let block_time_inner obj =\n let ( ^^ ) = Fn.compose in\n iso_string ~name:\"BlockTime\" ~js_type:UInt64\n ~of_string:(Block_time.of_uint64 ^^ Unsigned_extended.UInt64.of_string)\n ~to_string:(Unsigned_extended.UInt64.to_string ^^ Block_time.to_uint64)\n obj\n\n let nonce obj = deriver \"Nonce\" uint32 range_uint32 obj\n\n let balance obj = deriver \"Balance\" balance range_uint64 obj\n\n let amount obj = deriver \"CurrencyAmount\" amount range_uint64 obj\n\n let length obj = deriver \"Length\" uint32 range_uint32 obj\n\n let global_slot_since_genesis obj =\n deriver \"GlobalSlotSinceGenesis\" global_slot_since_genesis range_uint32\n obj\n\n let block_time obj = deriver \"BlockTime\" block_time_inner range_uint64 obj\n end\n\n let%test_module \"Numeric\" =\n ( module struct\n module Int_numeric = struct\n type t_ = int t [@@deriving sexp, equal, compare]\n\n (* Note: nonrec doesn't work with ppx-deriving *)\n type t = t_ [@@deriving sexp, equal, compare]\n end\n\n module T = struct\n type t = { foo : Int_numeric.t }\n [@@deriving annot, sexp, equal, compare, fields]\n\n let v : t =\n { foo = Or_ignore.Check { Closed_interval.lower = 10; upper = 100 } }\n\n let deriver obj =\n let open Fields_derivers_zkapps.Derivers in\n let ( !. ) = ( !. ) ~t_fields_annots in\n Fields.make_creator obj ~foo:!.(deriver \"Int\" int (\"0\", \"1000\"))\n |> finish \"T\" ~t_toplevel_annots\n end\n\n let%test_unit \"roundtrip json\" =\n let open Fields_derivers_zkapps.Derivers in\n let full = o () in\n let _a : _ Unified_input.t = T.deriver full in\n [%test_eq: T.t] (of_json full (to_json full T.v)) T.v\n end )\n\n let gen gen_a compare_a = Or_ignore.gen (Closed_interval.gen gen_a compare_a)\n\n let to_input { zero; max_value; to_input; _ } (t : 'a t) =\n Flagged_option.to_input'\n ~f:(Closed_interval.to_input ~f:to_input)\n ~field_of_bool\n ( match t with\n | Ignore ->\n { is_some = false\n ; data = { Closed_interval.lower = zero; upper = max_value }\n }\n | Check x ->\n { is_some = true; data = x } )\n\n module Checked = struct\n type 'a t = 'a Closed_interval.t Or_ignore.Checked.t\n\n let to_input { to_input_checked; _ } (t : 'a t) =\n Or_ignore.Checked.to_input t\n ~f:(Closed_interval.to_input ~f:to_input_checked)\n\n open Impl\n\n let check { lte_checked = ( <= ); _ } (t : 'a t) (x : 'a) =\n Or_ignore.Checked.check t ~f:(fun { lower; upper } ->\n Boolean.all [ lower <= x; x <= upper ] )\n\n let is_constant { eq_checked = ( = ); _ } (t : 'a t) =\n let is_constant ({ lower; upper } : _ Closed_interval.t) =\n lower = upper\n in\n Boolean.( &&& )\n (Or_ignore.Checked.is_check t)\n (is_constant (Or_ignore.Checked.data t))\n end\n\n let typ { zero; max_value; typ; _ } =\n Or_ignore.typ (Closed_interval.typ typ)\n ~ignore:{ Closed_interval.lower = zero; upper = max_value }\n\n let check ~label { compare; _ } (t : 'a t) (x : 'a) =\n match t with\n | Ignore ->\n Ok ()\n | Check { lower; upper } ->\n if compare lower x <= 0 && compare x upper <= 0 then Ok ()\n else Or_error.errorf \"Bounds check failed: %s\" label\n\n let is_constant { equal = ( = ); _ } (t : 'a t) =\n match t with Ignore -> false | Check { lower; upper } -> lower = upper\nend\n\nmodule Eq_data = struct\n include Or_ignore\n\n module Tc = struct\n type ('var, 'a) t =\n { equal : 'a -> 'a -> bool\n ; equal_checked : 'var -> 'var -> Boolean.var\n ; default : 'a\n ; typ : ('var, 'a) Typ.t\n ; to_input : 'a -> F.t Random_oracle_input.Chunked.t\n ; to_input_checked : 'var -> Field.Var.t Random_oracle_input.Chunked.t\n }\n\n let run f x y = Impl.run_checked (f x y)\n\n let field =\n let open Random_oracle_input.Chunked in\n Field.\n { typ\n ; equal\n ; equal_checked = run Checked.equal\n ; default = zero\n ; to_input = field\n ; to_input_checked = field\n }\n\n let action_state =\n let open Random_oracle_input.Chunked in\n lazy\n Field.\n { typ\n ; equal\n ; equal_checked = run Checked.equal\n ; default = Zkapp_account.Actions.empty_state_element\n ; to_input = field\n ; to_input_checked = field\n }\n\n let boolean =\n let open Random_oracle_input.Chunked in\n Boolean.\n { typ\n ; equal = Bool.equal\n ; equal_checked = run equal\n ; default = false\n ; to_input = (fun b -> packed (field_of_bool b, 1))\n ; to_input_checked =\n (fun (b : Boolean.var) -> packed ((b :> Field.Var.t), 1))\n }\n\n let receipt_chain_hash =\n Receipt.Chain_hash.\n { field with\n to_input_checked = var_to_input\n ; typ\n ; equal\n ; equal_checked = run equal_var\n }\n\n let ledger_hash =\n Ledger_hash.\n { field with\n to_input_checked = var_to_input\n ; typ\n ; equal\n ; equal_checked = run equal_var\n }\n\n let frozen_ledger_hash =\n Frozen_ledger_hash.\n { field with\n to_input_checked = var_to_input\n ; typ\n ; equal\n ; equal_checked = run equal_var\n }\n\n let state_hash =\n State_hash.\n { field with\n to_input_checked = var_to_input\n ; typ\n ; equal\n ; equal_checked = run equal_var\n }\n\n let token_id =\n Token_id.\n { default\n ; to_input_checked = Checked.to_input\n ; to_input\n ; typ\n ; equal\n ; equal_checked = Checked.equal\n }\n\n let epoch_seed =\n Epoch_seed.\n { field with\n to_input_checked = var_to_input\n ; typ\n ; equal\n ; equal_checked = run equal_var\n }\n\n let public_key () =\n Public_key.Compressed.\n { default = invalid_public_key\n ; to_input\n ; to_input_checked = Checked.to_input\n ; equal_checked = run Checked.equal\n ; typ\n ; equal\n }\n end\n\n let to_input { Tc.default; to_input; _ } (t : _ t) =\n Flagged_option.to_input' ~f:to_input ~field_of_bool\n ( match t with\n | Ignore ->\n { is_some = false; data = default }\n | Check data ->\n { is_some = true; data } )\n\n let to_input_checked { Tc.to_input_checked; _ } (t : _ Checked.t) =\n Checked.to_input t ~f:to_input_checked\n\n let check_checked { Tc.equal_checked; _ } (t : 'a Checked.t) (x : 'a) =\n Checked.check t ~f:(equal_checked x)\n\n let check ?(label = \"\") { Tc.equal; _ } (t : 'a t) (x : 'a) =\n match t with\n | Ignore ->\n Ok ()\n | Check y ->\n if equal x y then Ok ()\n else Or_error.errorf \"Equality check failed: %s\" label\n\n let typ { Tc.default = ignore; typ = t; _ } = typ ~ignore t\nend\n\nmodule Hash = Eq_data\n\nmodule Leaf_typs = struct\n let public_key () =\n Public_key.Compressed.(Or_ignore.typ ~ignore:invalid_public_key typ)\n\n open Eq_data.Tc\n\n let field = Eq_data.typ field\n\n let receipt_chain_hash = Hash.typ receipt_chain_hash\n\n let ledger_hash = Hash.typ ledger_hash\n\n let frozen_ledger_hash = Hash.typ frozen_ledger_hash\n\n let state_hash = Hash.typ state_hash\n\n open Numeric.Tc\n\n let length = Numeric.typ length\n\n let amount = Numeric.typ amount\n\n let balance = Numeric.typ balance\n\n let nonce = Numeric.typ nonce\n\n let global_slot = Numeric.typ global_slot\n\n let token_id = Hash.typ token_id\nend\n\nmodule Account = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t = Mina_wire_types.Mina_base.Zkapp_precondition.Account.V2.t =\n { balance : Balance.Stable.V1.t Numeric.Stable.V1.t\n ; nonce : Account_nonce.Stable.V1.t Numeric.Stable.V1.t\n ; receipt_chain_hash : Receipt.Chain_hash.Stable.V1.t Hash.Stable.V1.t\n ; delegate : Public_key.Compressed.Stable.V1.t Eq_data.Stable.V1.t\n ; state : F.Stable.V1.t Eq_data.Stable.V1.t Zkapp_state.V.Stable.V1.t\n ; action_state : F.Stable.V1.t Eq_data.Stable.V1.t\n ; proved_state : bool Eq_data.Stable.V1.t\n ; is_new : bool Eq_data.Stable.V1.t\n }\n [@@deriving annot, hlist, sexp, equal, yojson, hash, compare, fields]\n\n let to_latest = Fn.id\n end\n end]\n\n let gen : t Quickcheck.Generator.t =\n let open Quickcheck.Let_syntax in\n let%bind balance = Numeric.gen Balance.gen Balance.compare in\n let%bind nonce = Numeric.gen Account_nonce.gen Account_nonce.compare in\n let%bind receipt_chain_hash = Or_ignore.gen Receipt.Chain_hash.gen in\n let%bind delegate = Eq_data.gen Public_key.Compressed.gen in\n let%bind state =\n let%bind fields =\n let field_gen = Snark_params.Tick.Field.gen in\n Quickcheck.Generator.list_with_length 8 (Or_ignore.gen field_gen)\n in\n (* won't raise because length is correct *)\n Quickcheck.Generator.return (Zkapp_state.V.of_list_exn fields)\n in\n let%bind action_state =\n let%bind n = Int.gen_uniform_incl Int.min_value Int.max_value in\n let field_gen = Quickcheck.Generator.return (F.of_int n) in\n Or_ignore.gen field_gen\n in\n let%bind proved_state = Or_ignore.gen Quickcheck.Generator.bool in\n let%map is_new = Or_ignore.gen Quickcheck.Generator.bool in\n { balance\n ; nonce\n ; receipt_chain_hash\n ; delegate\n ; state\n ; action_state\n ; proved_state\n ; is_new\n }\n\n let accept : t =\n { balance = Ignore\n ; nonce = Ignore\n ; receipt_chain_hash = Ignore\n ; delegate = Ignore\n ; state =\n Vector.init Zkapp_state.Max_state_size.n ~f:(fun _ -> Or_ignore.Ignore)\n ; action_state = Ignore\n ; proved_state = Ignore\n ; is_new = Ignore\n }\n\n let is_accept : t -> bool = equal accept\n\n let deriver obj =\n let open Fields_derivers_zkapps in\n let ( !. ) = ( !. ) ~t_fields_annots in\n let action_state =\n needs_custom_js ~js_type:field ~name:\"ActionState\" field\n in\n Fields.make_creator obj ~balance:!.Numeric.Derivers.balance\n ~nonce:!.Numeric.Derivers.nonce\n ~receipt_chain_hash:!.(Or_ignore.deriver field)\n ~delegate:!.(Or_ignore.deriver public_key)\n ~state:!.(Zkapp_state.deriver @@ Or_ignore.deriver field)\n ~action_state:!.(Or_ignore.deriver action_state)\n ~proved_state:!.(Or_ignore.deriver bool)\n ~is_new:!.(Or_ignore.deriver bool)\n |> finish \"AccountPrecondition\" ~t_toplevel_annots\n\n let%test_unit \"json roundtrip\" =\n let b = Balance.of_nanomina_int_exn 1000 in\n let predicate : t =\n { accept with\n balance = Or_ignore.Check { Closed_interval.lower = b; upper = b }\n ; action_state = Or_ignore.Check (Field.of_int 99)\n ; proved_state = Or_ignore.Check true\n }\n in\n let module Fd = Fields_derivers_zkapps.Derivers in\n let full = deriver (Fd.o ()) in\n [%test_eq: t] predicate (predicate |> Fd.to_json full |> Fd.of_json full)\n\n let to_input\n ({ balance\n ; nonce\n ; receipt_chain_hash\n ; delegate\n ; state\n ; action_state\n ; proved_state\n ; is_new\n } :\n t ) =\n let open Random_oracle_input.Chunked in\n List.reduce_exn ~f:append\n [ Numeric.(to_input Tc.balance balance)\n ; Numeric.(to_input Tc.nonce nonce)\n ; Hash.(to_input Tc.receipt_chain_hash receipt_chain_hash)\n ; Eq_data.(to_input (Tc.public_key ()) delegate)\n ; Vector.reduce_exn ~f:append\n (Vector.map state ~f:Eq_data.(to_input Tc.field))\n ; Eq_data.(to_input (Lazy.force Tc.action_state)) action_state\n ; Eq_data.(to_input Tc.boolean) proved_state\n ; Eq_data.(to_input Tc.boolean) is_new\n ]\n\n let digest t =\n Random_oracle.(\n hash ~init:Hash_prefix.zkapp_precondition_account\n (pack_input (to_input t)))\n\n module Checked = struct\n type t =\n { balance : Balance.var Numeric.Checked.t\n ; nonce : Account_nonce.Checked.t Numeric.Checked.t\n ; receipt_chain_hash : Receipt.Chain_hash.var Hash.Checked.t\n ; delegate : Public_key.Compressed.var Eq_data.Checked.t\n ; state : Field.Var.t Eq_data.Checked.t Zkapp_state.V.t\n ; action_state : Field.Var.t Eq_data.Checked.t\n ; proved_state : Boolean.var Eq_data.Checked.t\n ; is_new : Boolean.var Eq_data.Checked.t\n }\n [@@deriving hlist]\n\n let to_input\n ({ balance\n ; nonce\n ; receipt_chain_hash\n ; delegate\n ; state\n ; action_state\n ; proved_state\n ; is_new\n } :\n t ) =\n let open Random_oracle_input.Chunked in\n List.reduce_exn ~f:append\n [ Numeric.(Checked.to_input Tc.balance balance)\n ; Numeric.(Checked.to_input Tc.nonce nonce)\n ; Hash.(to_input_checked Tc.receipt_chain_hash receipt_chain_hash)\n ; Eq_data.(to_input_checked (Tc.public_key ()) delegate)\n ; Vector.reduce_exn ~f:append\n (Vector.map state ~f:Eq_data.(to_input_checked Tc.field))\n ; Eq_data.(to_input_checked (Lazy.force Tc.action_state)) action_state\n ; Eq_data.(to_input_checked Tc.boolean) proved_state\n ; Eq_data.(to_input_checked Tc.boolean) is_new\n ]\n\n open Impl\n\n let checks ~new_account\n { balance\n ; nonce\n ; receipt_chain_hash\n ; delegate\n ; state\n ; action_state\n ; proved_state\n ; is_new\n } (a : Account.Checked.Unhashed.t) =\n [ ( Transaction_status.Failure.Account_balance_precondition_unsatisfied\n , Numeric.(Checked.check Tc.balance balance a.balance) )\n ; ( Transaction_status.Failure.Account_nonce_precondition_unsatisfied\n , Numeric.(Checked.check Tc.nonce nonce a.nonce) )\n ; ( Transaction_status.Failure\n .Account_receipt_chain_hash_precondition_unsatisfied\n , Eq_data.(\n check_checked Tc.receipt_chain_hash receipt_chain_hash\n a.receipt_chain_hash) )\n ; ( Transaction_status.Failure.Account_delegate_precondition_unsatisfied\n , Eq_data.(check_checked (Tc.public_key ()) delegate a.delegate) )\n ]\n @ [ ( Transaction_status.Failure\n .Account_action_state_precondition_unsatisfied\n , Boolean.any\n Vector.(\n to_list\n (map a.zkapp.action_state\n ~f:\n Eq_data.(\n check_checked (Lazy.force Tc.action_state) action_state) ))\n )\n ]\n @ ( Vector.(\n to_list\n (map2 state a.zkapp.app_state ~f:Eq_data.(check_checked Tc.field)))\n |> List.mapi ~f:(fun i check ->\n let failure =\n Transaction_status.Failure\n .Account_app_state_precondition_unsatisfied\n i\n in\n (failure, check) ) )\n @ [ ( Transaction_status.Failure\n .Account_proved_state_precondition_unsatisfied\n , Eq_data.(check_checked Tc.boolean proved_state a.zkapp.proved_state)\n )\n ]\n @ [ ( Transaction_status.Failure.Account_is_new_precondition_unsatisfied\n , Eq_data.(check_checked Tc.boolean is_new new_account) )\n ]\n\n let check ~new_account ~check t a =\n List.iter\n ~f:(fun (failure, passed) -> check failure passed)\n (checks ~new_account t a)\n\n let digest (t : t) =\n Random_oracle.Checked.(\n hash ~init:Hash_prefix.zkapp_precondition_account\n (pack_input (to_input t)))\n end\n\n let typ () : (Checked.t, t) Typ.t =\n let open Leaf_typs in\n Typ.of_hlistable\n [ balance\n ; nonce\n ; receipt_chain_hash\n ; public_key ()\n ; Zkapp_state.typ (Or_ignore.typ Field.typ ~ignore:Field.zero)\n ; Or_ignore.typ Field.typ\n ~ignore:Zkapp_account.Actions.empty_state_element\n ; Or_ignore.typ Boolean.typ ~ignore:false\n ; Or_ignore.typ Boolean.typ ~ignore:false\n ]\n ~var_to_hlist:Checked.to_hlist ~var_of_hlist:Checked.of_hlist\n ~value_to_hlist:to_hlist ~value_of_hlist:of_hlist\n\n let checks ~new_account\n { balance\n ; nonce\n ; receipt_chain_hash\n ; delegate\n ; state\n ; action_state\n ; proved_state\n ; is_new\n } (a : Account.t) =\n [ ( Transaction_status.Failure.Account_balance_precondition_unsatisfied\n , Numeric.(check ~label:\"balance\" Tc.balance balance a.balance) )\n ; ( Transaction_status.Failure.Account_nonce_precondition_unsatisfied\n , Numeric.(check ~label:\"nonce\" Tc.nonce nonce a.nonce) )\n ; ( Transaction_status.Failure\n .Account_receipt_chain_hash_precondition_unsatisfied\n , Eq_data.(\n check ~label:\"receipt_chain_hash\" Tc.receipt_chain_hash\n receipt_chain_hash a.receipt_chain_hash) )\n ; ( Transaction_status.Failure.Account_delegate_precondition_unsatisfied\n , let tc = Eq_data.Tc.public_key () in\n Eq_data.(\n check ~label:\"delegate\" tc delegate\n (Option.value ~default:tc.default a.delegate)) )\n ]\n @\n let zkapp = Option.value ~default:Zkapp_account.default a.zkapp in\n [ ( Transaction_status.Failure.Account_action_state_precondition_unsatisfied\n , match\n List.find (Vector.to_list zkapp.action_state) ~f:(fun state ->\n Eq_data.(\n check (Lazy.force Tc.action_state) ~label:\"\" action_state state)\n |> Or_error.is_ok )\n with\n | None ->\n Error (Error.createf \"Action state mismatch\")\n | Some _ ->\n Ok () )\n ]\n @ List.mapi\n Vector.(to_list (zip state zkapp.app_state))\n ~f:(fun i (c, v) ->\n let failure =\n Transaction_status.Failure\n .Account_app_state_precondition_unsatisfied\n i\n in\n (failure, Eq_data.(check Tc.field ~label:(sprintf \"state[%d]\" i) c v))\n )\n @ [ ( Transaction_status.Failure\n .Account_proved_state_precondition_unsatisfied\n , Eq_data.(\n check ~label:\"proved_state\" Tc.boolean proved_state\n zkapp.proved_state) )\n ]\n @ [ ( Transaction_status.Failure.Account_is_new_precondition_unsatisfied\n , Eq_data.(check ~label:\"is_new\" Tc.boolean is_new new_account) )\n ]\n\n let check ~new_account ~check t a =\n List.iter\n ~f:(fun (failure, res) -> check failure (Result.is_ok res))\n (checks ~new_account t a)\nend\n\nmodule Protocol_state = struct\n (* On each numeric field, you may assert a range\n On each hash field, you may assert an equality\n *)\n\n module Epoch_data = struct\n module Poly = Epoch_data.Poly\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n (* TODO: Not sure if this should be frozen ledger hash or not *)\n type t =\n ( ( Frozen_ledger_hash.Stable.V1.t Hash.Stable.V1.t\n , Currency.Amount.Stable.V1.t Numeric.Stable.V1.t )\n Epoch_ledger.Poly.Stable.V1.t\n , Epoch_seed.Stable.V1.t Hash.Stable.V1.t\n , State_hash.Stable.V1.t Hash.Stable.V1.t\n , State_hash.Stable.V1.t Hash.Stable.V1.t\n , Length.Stable.V1.t Numeric.Stable.V1.t )\n Poly.Stable.V1.t\n [@@deriving sexp, equal, yojson, hash, compare]\n\n let to_latest = Fn.id\n end\n end]\n\n let deriver obj =\n let open Fields_derivers_zkapps.Derivers in\n let ledger obj' =\n let ( !. ) =\n ( !. ) ~t_fields_annots:Epoch_ledger.Poly.t_fields_annots\n in\n Epoch_ledger.Poly.Fields.make_creator obj'\n ~hash:!.(Or_ignore.deriver field)\n ~total_currency:!.Numeric.Derivers.amount\n |> finish \"EpochLedgerPrecondition\"\n ~t_toplevel_annots:Epoch_ledger.Poly.t_toplevel_annots\n in\n let ( !. ) = ( !. ) ~t_fields_annots:Poly.t_fields_annots in\n Poly.Fields.make_creator obj ~ledger:!.ledger\n ~seed:!.(Or_ignore.deriver field)\n ~start_checkpoint:!.(Or_ignore.deriver field)\n ~lock_checkpoint:!.(Or_ignore.deriver field)\n ~epoch_length:!.Numeric.Derivers.length\n |> finish \"EpochDataPrecondition\"\n ~t_toplevel_annots:Poly.t_toplevel_annots\n\n let%test_unit \"json roundtrip\" =\n let f = Or_ignore.Check Field.one in\n let u = Length.zero in\n let a = Amount.zero in\n let predicate : t =\n { Poly.ledger =\n { Epoch_ledger.Poly.hash = f\n ; total_currency =\n Or_ignore.Check { Closed_interval.lower = a; upper = a }\n }\n ; seed = f\n ; start_checkpoint = f\n ; lock_checkpoint = f\n ; epoch_length =\n Or_ignore.Check { Closed_interval.lower = u; upper = u }\n }\n in\n let module Fd = Fields_derivers_zkapps.Derivers in\n let full = deriver (Fd.o ()) in\n [%test_eq: t] predicate (predicate |> Fd.to_json full |> Fd.of_json full)\n\n let gen : t Quickcheck.Generator.t =\n let open Quickcheck.Let_syntax in\n let%bind ledger =\n let%bind hash = Hash.gen Frozen_ledger_hash0.gen in\n let%map total_currency = Numeric.gen Amount.gen Amount.compare in\n { Epoch_ledger.Poly.hash; total_currency }\n in\n let%bind seed = Hash.gen Epoch_seed.gen in\n let%bind start_checkpoint = Hash.gen State_hash.gen in\n let%bind lock_checkpoint = Hash.gen State_hash.gen in\n let min_epoch_length = 8 in\n let max_epoch_length = Genesis_constants.slots_per_epoch in\n let%map epoch_length =\n Numeric.gen\n (Length.gen_incl\n (Length.of_int min_epoch_length)\n (Length.of_int max_epoch_length) )\n Length.compare\n in\n { Poly.ledger; seed; start_checkpoint; lock_checkpoint; epoch_length }\n\n let to_input\n ({ ledger = { hash; total_currency }\n ; seed\n ; start_checkpoint\n ; lock_checkpoint\n ; epoch_length\n } :\n t ) =\n let open Random_oracle.Input.Chunked in\n List.reduce_exn ~f:append\n [ Hash.(to_input Tc.frozen_ledger_hash hash)\n ; Numeric.(to_input Tc.amount total_currency)\n ; Hash.(to_input Tc.epoch_seed seed)\n ; Hash.(to_input Tc.state_hash start_checkpoint)\n ; Hash.(to_input Tc.state_hash lock_checkpoint)\n ; Numeric.(to_input Tc.length epoch_length)\n ]\n\n module Checked = struct\n type t =\n ( ( Frozen_ledger_hash.var Hash.Checked.t\n , Currency.Amount.var Numeric.Checked.t )\n Epoch_ledger.Poly.t\n , Epoch_seed.var Hash.Checked.t\n , State_hash.var Hash.Checked.t\n , State_hash.var Hash.Checked.t\n , Length.Checked.t Numeric.Checked.t )\n Poly.t\n\n let to_input\n ({ ledger = { hash; total_currency }\n ; seed\n ; start_checkpoint\n ; lock_checkpoint\n ; epoch_length\n } :\n t ) =\n let open Random_oracle.Input.Chunked in\n List.reduce_exn ~f:append\n [ Hash.(to_input_checked Tc.frozen_ledger_hash hash)\n ; Numeric.(Checked.to_input Tc.amount total_currency)\n ; Hash.(to_input_checked Tc.epoch_seed seed)\n ; Hash.(to_input_checked Tc.state_hash start_checkpoint)\n ; Hash.(to_input_checked Tc.state_hash lock_checkpoint)\n ; Numeric.(Checked.to_input Tc.length epoch_length)\n ]\n end\n end\n\n module Poly = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type ( 'snarked_ledger_hash\n , 'length\n , 'global_slot\n , 'amount\n , 'epoch_data )\n t =\n ( 'snarked_ledger_hash\n , 'length\n , 'global_slot\n , 'amount\n , 'epoch_data )\n Mina_wire_types.Mina_base.Zkapp_precondition.Protocol_state.Poly\n .V1\n .t =\n { (* TODO:\n We should include staged ledger hash again! It only changes once per\n block. *)\n snarked_ledger_hash : 'snarked_ledger_hash\n ; blockchain_length : 'length\n (* TODO: This previously had epoch_count but I removed it as I believe it is redundant\n with global_slot_since_hard_fork.\n\n epoch_count in [a, b]\n\n should be equivalent to\n\n global_slot_since_hard_fork in [slots_per_epoch * a, slots_per_epoch * b]\n\n TODO: Now that we removed global_slot_since_hard_fork, maybe we want to add epoch_count back\n *)\n ; min_window_density : 'length\n ; total_currency : 'amount\n ; global_slot_since_genesis : 'global_slot\n ; staking_epoch_data : 'epoch_data\n ; next_epoch_data : 'epoch_data\n }\n [@@deriving annot, hlist, sexp, equal, yojson, hash, compare, fields]\n end\n end]\n end\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t =\n ( Frozen_ledger_hash.Stable.V1.t Hash.Stable.V1.t\n , Length.Stable.V1.t Numeric.Stable.V1.t\n , Global_slot_since_genesis.Stable.V1.t Numeric.Stable.V1.t\n , Currency.Amount.Stable.V1.t Numeric.Stable.V1.t\n , Epoch_data.Stable.V1.t )\n Poly.Stable.V1.t\n [@@deriving sexp, equal, yojson, hash, compare]\n\n let to_latest = Fn.id\n end\n end]\n\n let deriver obj =\n let open Fields_derivers_zkapps.Derivers in\n let ( !. ) ?skip_data =\n ( !. ) ?skip_data ~t_fields_annots:Poly.t_fields_annots\n in\n Poly.Fields.make_creator obj\n ~snarked_ledger_hash:!.(Or_ignore.deriver field)\n ~blockchain_length:!.Numeric.Derivers.length\n ~min_window_density:!.Numeric.Derivers.length\n ~total_currency:!.Numeric.Derivers.amount\n ~global_slot_since_genesis:!.Numeric.Derivers.global_slot_since_genesis\n ~staking_epoch_data:!.Epoch_data.deriver\n ~next_epoch_data:!.Epoch_data.deriver\n |> finish \"NetworkPrecondition\" ~t_toplevel_annots:Poly.t_toplevel_annots\n\n let gen : t Quickcheck.Generator.t =\n let open Quickcheck.Let_syntax in\n (* TODO: pass in ledger hash, next available token *)\n let snarked_ledger_hash = Zkapp_basic.Or_ignore.Ignore in\n let%bind blockchain_length = Numeric.gen Length.gen Length.compare in\n let max_min_window_density =\n Genesis_constants.for_unit_tests.protocol.slots_per_sub_window\n * Genesis_constants.Constraint_constants.compiled.sub_windows_per_window\n - 1\n |> Length.of_int\n in\n let%bind min_window_density =\n Numeric.gen\n (Length.gen_incl Length.zero max_min_window_density)\n Length.compare\n in\n let%bind total_currency =\n Numeric.gen Currency.Amount.gen Currency.Amount.compare\n in\n let%bind global_slot_since_genesis =\n Numeric.gen Global_slot_since_genesis.gen\n Global_slot_since_genesis.compare\n in\n let%bind staking_epoch_data = Epoch_data.gen in\n let%map next_epoch_data = Epoch_data.gen in\n { Poly.snarked_ledger_hash\n ; blockchain_length\n ; min_window_density\n ; total_currency\n ; global_slot_since_genesis\n ; staking_epoch_data\n ; next_epoch_data\n }\n\n let to_input\n ({ snarked_ledger_hash\n ; blockchain_length\n ; min_window_density\n ; total_currency\n ; global_slot_since_genesis\n ; staking_epoch_data\n ; next_epoch_data\n } :\n t ) =\n let open Random_oracle.Input.Chunked in\n let length = Numeric.(to_input Tc.length) in\n List.reduce_exn ~f:append\n [ Hash.(to_input Tc.field snarked_ledger_hash)\n ; length blockchain_length\n ; length min_window_density\n ; Numeric.(to_input Tc.amount total_currency)\n ; Numeric.(to_input Tc.global_slot global_slot_since_genesis)\n ; Epoch_data.to_input staking_epoch_data\n ; Epoch_data.to_input next_epoch_data\n ]\n\n let digest t =\n Random_oracle.(\n hash ~init:Hash_prefix.zkapp_precondition_protocol_state\n (pack_input (to_input t)))\n\n module View = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t =\n ( Frozen_ledger_hash.Stable.V1.t\n , Length.Stable.V1.t\n , Global_slot_since_genesis.Stable.V1.t\n , Currency.Amount.Stable.V1.t\n , ( ( Frozen_ledger_hash.Stable.V1.t\n , Currency.Amount.Stable.V1.t )\n Epoch_ledger.Poly.Stable.V1.t\n , Epoch_seed.Stable.V1.t\n , State_hash.Stable.V1.t\n , State_hash.Stable.V1.t\n , Length.Stable.V1.t )\n Epoch_data.Poly.Stable.V1.t )\n Poly.Stable.V1.t\n [@@deriving sexp, equal, yojson, hash, compare]\n\n let to_latest = Fn.id\n end\n end]\n\n module Checked = struct\n type t =\n ( Frozen_ledger_hash.var\n , Length.Checked.t\n , Global_slot_since_genesis.Checked.t\n , Currency.Amount.var\n , ( (Frozen_ledger_hash.var, Currency.Amount.var) Epoch_ledger.Poly.t\n , Epoch_seed.var\n , State_hash.var\n , State_hash.var\n , Length.Checked.t )\n Epoch_data.Poly.t )\n Poly.t\n end\n\n let epoch_data_deriver obj =\n let open Fields_derivers_zkapps.Derivers in\n let ledger obj' =\n let ( !. ) =\n ( !. ) ~t_fields_annots:Epoch_ledger.Poly.t_fields_annots\n in\n Epoch_ledger.Poly.Fields.make_creator obj' ~hash:!.field\n ~total_currency:!.amount\n |> finish \"EpochLedger\"\n ~t_toplevel_annots:Epoch_ledger.Poly.t_toplevel_annots\n in\n let ( !. ) = ( !. ) ~t_fields_annots:Epoch_data.Poly.t_fields_annots in\n Epoch_data.Poly.Fields.make_creator obj ~ledger:!.ledger ~seed:!.field\n ~start_checkpoint:!.field ~lock_checkpoint:!.field\n ~epoch_length:!.uint32\n |> finish \"EpochData\" ~t_toplevel_annots:Epoch_data.Poly.t_toplevel_annots\n\n let deriver obj =\n let open Fields_derivers_zkapps.Derivers in\n let ( !. ) ?skip_data =\n ( !. ) ?skip_data ~t_fields_annots:Poly.t_fields_annots\n in\n Poly.Fields.make_creator obj ~snarked_ledger_hash:!.field\n ~blockchain_length:!.uint32 ~min_window_density:!.uint32\n ~total_currency:!.amount\n ~global_slot_since_genesis:!.global_slot_since_genesis\n ~staking_epoch_data:!.epoch_data_deriver\n ~next_epoch_data:!.epoch_data_deriver\n |> finish \"NetworkView\" ~t_toplevel_annots:Poly.t_toplevel_annots\n end\n\n module Checked = struct\n type t =\n ( Frozen_ledger_hash.var Hash.Checked.t\n , Length.Checked.t Numeric.Checked.t\n , Global_slot_since_genesis.Checked.t Numeric.Checked.t\n , Currency.Amount.var Numeric.Checked.t\n , Epoch_data.Checked.t )\n Poly.Stable.Latest.t\n\n let to_input\n ({ snarked_ledger_hash\n ; blockchain_length\n ; min_window_density\n ; total_currency\n ; global_slot_since_genesis\n ; staking_epoch_data\n ; next_epoch_data\n } :\n t ) =\n let open Random_oracle.Input.Chunked in\n let length = Numeric.(Checked.to_input Tc.length) in\n List.reduce_exn ~f:append\n [ Hash.(to_input_checked Tc.frozen_ledger_hash snarked_ledger_hash)\n ; length blockchain_length\n ; length min_window_density\n ; Numeric.(Checked.to_input Tc.amount total_currency)\n ; Numeric.(Checked.to_input Tc.global_slot global_slot_since_genesis)\n ; Epoch_data.Checked.to_input staking_epoch_data\n ; Epoch_data.Checked.to_input next_epoch_data\n ]\n\n let digest t =\n Random_oracle.Checked.(\n hash ~init:Hash_prefix.zkapp_precondition_protocol_state\n (pack_input (to_input t)))\n\n let check\n (* Bind all the fields explicity so we make sure they are all used. *)\n ({ snarked_ledger_hash\n ; blockchain_length\n ; min_window_density\n ; total_currency\n ; global_slot_since_genesis\n ; staking_epoch_data\n ; next_epoch_data\n } :\n t ) (s : View.Checked.t) =\n let open Impl in\n let epoch_ledger ({ hash; total_currency } : _ Epoch_ledger.Poly.t)\n (t : Epoch_ledger.var) =\n [ Hash.(check_checked Tc.frozen_ledger_hash) hash t.hash\n ; Numeric.(Checked.check Tc.amount) total_currency t.total_currency\n ]\n in\n let epoch_data\n ({ ledger; seed; start_checkpoint; lock_checkpoint; epoch_length } :\n _ Epoch_data.Poly.t ) (t : _ Epoch_data.Poly.t) =\n ignore seed ;\n epoch_ledger ledger t.ledger\n @ [ Hash.(check_checked Tc.state_hash)\n start_checkpoint t.start_checkpoint\n ; Hash.(check_checked Tc.state_hash) lock_checkpoint t.lock_checkpoint\n ; Numeric.(Checked.check Tc.length) epoch_length t.epoch_length\n ]\n in\n Boolean.all\n ( [ Hash.(check_checked Tc.ledger_hash)\n snarked_ledger_hash s.snarked_ledger_hash\n ; Numeric.(Checked.check Tc.length)\n blockchain_length s.blockchain_length\n ; Numeric.(Checked.check Tc.length)\n min_window_density s.min_window_density\n ; Numeric.(Checked.check Tc.amount) total_currency s.total_currency\n ; Numeric.(Checked.check Tc.global_slot)\n global_slot_since_genesis s.global_slot_since_genesis\n ]\n @ epoch_data staking_epoch_data s.staking_epoch_data\n @ epoch_data next_epoch_data s.next_epoch_data )\n end\n\n let typ : (Checked.t, Stable.Latest.t) Typ.t =\n let open Poly.Stable.Latest in\n let frozen_ledger_hash = Hash.(typ Tc.frozen_ledger_hash) in\n let state_hash = Hash.(typ Tc.state_hash) in\n let epoch_seed = Hash.(typ Tc.epoch_seed) in\n let length = Numeric.(typ Tc.length) in\n let amount = Numeric.(typ Tc.amount) in\n let global_slot = Numeric.(typ Tc.global_slot) in\n let epoch_data =\n let epoch_ledger =\n let open Epoch_ledger.Poly in\n Typ.of_hlistable\n [ frozen_ledger_hash; amount ]\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist\n in\n let open Epoch_data.Poly in\n Typ.of_hlistable\n [ epoch_ledger; epoch_seed; state_hash; state_hash; length ]\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist\n in\n Typ.of_hlistable\n [ frozen_ledger_hash\n ; length\n ; length\n ; amount\n ; global_slot\n ; epoch_data\n ; epoch_data\n ]\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist\n\n let epoch_data : Epoch_data.t =\n { ledger = { hash = Ignore; total_currency = Ignore }\n ; seed = Ignore\n ; start_checkpoint = Ignore\n ; lock_checkpoint = Ignore\n ; epoch_length = Ignore\n }\n\n let accept : t =\n { snarked_ledger_hash = Ignore\n ; blockchain_length = Ignore\n ; min_window_density = Ignore\n ; total_currency = Ignore\n ; global_slot_since_genesis = Ignore\n ; staking_epoch_data = epoch_data\n ; next_epoch_data = epoch_data\n }\n\n let valid_until time : t =\n { snarked_ledger_hash = Ignore\n ; blockchain_length = Ignore\n ; min_window_density = Ignore\n ; total_currency = Ignore\n ; global_slot_since_genesis = Check time\n ; staking_epoch_data = epoch_data\n ; next_epoch_data = epoch_data\n }\n\n let%test_unit \"json roundtrip\" =\n let predicate : t = accept in\n let module Fd = Fields_derivers_zkapps.Derivers in\n let full = deriver (Fd.o ()) in\n [%test_eq: t] predicate (predicate |> Fd.to_json full |> Fd.of_json full)\n\n let check\n (* Bind all the fields explicity so we make sure they are all used. *)\n ({ snarked_ledger_hash\n ; blockchain_length\n ; min_window_density\n ; total_currency\n ; global_slot_since_genesis\n ; staking_epoch_data\n ; next_epoch_data\n } :\n t ) (s : View.t) =\n let open Or_error.Let_syntax in\n let epoch_ledger ({ hash; total_currency } : _ Epoch_ledger.Poly.t)\n (t : Epoch_ledger.Value.t) =\n let%bind () =\n Hash.(check ~label:\"epoch_ledger_hash\" Tc.frozen_ledger_hash)\n hash t.hash\n in\n let%map () =\n Numeric.(check ~label:\"epoch_ledger_total_currency\" Tc.amount)\n total_currency t.total_currency\n in\n ()\n in\n let epoch_data label\n ({ ledger; seed; start_checkpoint; lock_checkpoint; epoch_length } :\n _ Epoch_data.Poly.t ) (t : _ Epoch_data.Poly.t) =\n let l s = sprintf \"%s_%s\" label s in\n let%bind () = epoch_ledger ledger t.ledger in\n ignore seed ;\n let%bind () =\n Hash.(check ~label:(l \"start_check_point\") Tc.state_hash)\n start_checkpoint t.start_checkpoint\n in\n let%bind () =\n Hash.(check ~label:(l \"lock_check_point\") Tc.state_hash)\n lock_checkpoint t.lock_checkpoint\n in\n let%map () =\n Numeric.(check ~label:\"epoch_length\" Tc.length)\n epoch_length t.epoch_length\n in\n ()\n in\n let%bind () =\n Hash.(check ~label:\"snarked_ledger_hash\" Tc.ledger_hash)\n snarked_ledger_hash s.snarked_ledger_hash\n in\n let%bind () =\n Numeric.(check ~label:\"blockchain_length\" Tc.length)\n blockchain_length s.blockchain_length\n in\n let%bind () =\n Numeric.(check ~label:\"min_window_density\" Tc.length)\n min_window_density s.min_window_density\n in\n (* TODO: Decide whether to expose this *)\n let%bind () =\n Numeric.(check ~label:\"total_currency\" Tc.amount)\n total_currency s.total_currency\n in\n let%bind () =\n Numeric.(check ~label:\"global_slot_since_genesis\" Tc.global_slot)\n global_slot_since_genesis s.global_slot_since_genesis\n in\n let%bind () =\n epoch_data \"staking_epoch_data\" staking_epoch_data s.staking_epoch_data\n in\n let%map () =\n epoch_data \"next_epoch_data\" next_epoch_data s.next_epoch_data\n in\n ()\nend\n\nmodule Valid_while = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Global_slot_since_genesis.Stable.V1.t Numeric.Stable.V1.t\n [@@deriving sexp, equal, yojson, hash, compare]\n\n let to_latest = Fn.id\n end\n end]\n\n let deriver = Numeric.Derivers.global_slot_since_genesis\n\n let gen =\n Numeric.gen Global_slot_since_genesis.gen Global_slot_since_genesis.compare\n\n let typ = Numeric.(typ Tc.global_slot)\n\n let to_input valid_while = Numeric.(to_input Tc.global_slot valid_while)\n\n let check (valid_while : t) global_slot =\n Numeric.(check ~label:\"valid_while_precondition\" Tc.global_slot)\n valid_while global_slot\n\n module Checked = struct\n type t = Global_slot_since_genesis.Checked.t Numeric.Checked.t\n\n let check (valid_while : t) global_slot =\n Numeric.(Checked.check Tc.global_slot) valid_while global_slot\n\n let to_input valid_while =\n Numeric.(Checked.to_input Tc.global_slot valid_while)\n end\nend\n\nmodule Account_type = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = User | Zkapp | None | Any\n [@@deriving sexp, equal, yojson, hash, compare]\n\n let to_latest = Fn.id\n end\n end]\n\n let check (t : t) (a : A.t option) =\n match (a, t) with\n | _, Any ->\n Ok ()\n | None, None ->\n Ok ()\n | None, _ ->\n Or_error.error_string \"expected account_type = None\"\n | Some a, User ->\n assert_ (Option.is_none a.zkapp) \"expected account_type = User\"\n | Some a, Zkapp ->\n assert_ (Option.is_some a.zkapp) \"expected account_type = Zkapp\"\n | Some _, None ->\n Or_error.error_string \"no second account allowed\"\n\n let to_bits = function\n | User ->\n [ true; false ]\n | Zkapp ->\n [ false; true ]\n | None ->\n [ false; false ]\n | Any ->\n [ true; true ]\n\n let of_bits = function\n | [ user; zkapp ] -> (\n match (user, zkapp) with\n | true, false ->\n User\n | false, true ->\n Zkapp\n | false, false ->\n None\n | true, true ->\n Any )\n | _ ->\n assert false\n\n let to_input x =\n let open Random_oracle_input.Chunked in\n Array.reduce_exn ~f:append\n (Array.of_list_map (to_bits x) ~f:(fun b -> packed (field_of_bool b, 1)))\n\n module Checked = struct\n type t = { user : Boolean.var; zkapp : Boolean.var } [@@deriving hlist]\n\n let to_input { user; zkapp } =\n let open Random_oracle_input.Chunked in\n Array.reduce_exn ~f:append\n (Array.map [| user; zkapp |] ~f:(fun b ->\n packed ((b :> Field.Var.t), 1) ) )\n\n let constant =\n let open Boolean in\n function\n | User ->\n { user = true_; zkapp = false_ }\n | Zkapp ->\n { user = false_; zkapp = true_ }\n | None ->\n { user = false_; zkapp = false_ }\n | Any ->\n { user = true_; zkapp = true_ }\n\n (* TODO: Write a unit test for these. *)\n let snapp_allowed t = t.zkapp\n\n let user_allowed t = t.user\n end\n\n let typ =\n let open Checked in\n Typ.of_hlistable\n [ Boolean.typ; Boolean.typ ]\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist\n ~value_to_hlist:(function\n | User ->\n [ true; false ]\n | Zkapp ->\n [ false; true ]\n | None ->\n [ false; false ]\n | Any ->\n [ true; true ] )\n ~value_of_hlist:(fun [ user; zkapp ] ->\n match (user, zkapp) with\n | true, false ->\n User\n | false, true ->\n Zkapp\n | false, false ->\n None\n | true, true ->\n Any )\nend\n\nmodule Other = struct\n module Poly = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type ('account, 'account_transition, 'vk) t =\n { predicate : 'account\n ; account_transition : 'account_transition\n ; account_vk : 'vk\n }\n [@@deriving hlist, sexp, equal, yojson, hash, compare]\n end\n end]\n end\n\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t =\n ( Account.Stable.V2.t\n , Account_state.Stable.V1.t Transition.Stable.V1.t\n , F.Stable.V1.t Hash.Stable.V1.t )\n Poly.Stable.V1.t\n [@@deriving sexp, equal, yojson, hash, compare]\n\n let to_latest = Fn.id\n end\n end]\n\n module Checked = struct\n type t =\n ( Account.Checked.t\n , Account_state.Checked.t Transition.t\n , Field.Var.t Or_ignore.Checked.t )\n Poly.Stable.Latest.t\n\n let to_input ({ predicate; account_transition; account_vk } : t) =\n let open Random_oracle_input.Chunked in\n List.reduce_exn ~f:append\n [ Account.Checked.to_input predicate\n ; Transition.to_input ~f:Account_state.Checked.to_input\n account_transition\n ; Hash.(to_input_checked Tc.field) account_vk\n ]\n end\n\n let to_input ({ predicate; account_transition; account_vk } : t) =\n let open Random_oracle_input.Chunked in\n List.reduce_exn ~f:append\n [ Account.to_input predicate\n ; Transition.to_input ~f:Account_state.to_input account_transition\n ; Hash.(to_input Tc.field) account_vk\n ]\n\n let typ () =\n let open Poly in\n Typ.of_hlistable\n [ Account.typ (); Transition.typ Account_state.typ; Hash.(typ Tc.field) ]\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist\n\n let accept : t =\n { predicate = Account.accept\n ; account_transition = { prev = Any; next = Any }\n ; account_vk = Ignore\n }\nend\n\nmodule Poly = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type ('account, 'protocol_state, 'other, 'pk) t =\n { self_predicate : 'account\n ; other : 'other\n ; fee_payer : 'pk\n ; protocol_state_predicate : 'protocol_state\n }\n [@@deriving hlist, sexp, equal, yojson, hash, compare]\n\n let to_latest = Fn.id\n end\n end]\n\n let typ spec =\n let open Stable.Latest in\n Typ.of_hlistable spec ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist\n ~value_to_hlist:to_hlist ~value_of_hlist:of_hlist\nend\n\n[%%versioned\nmodule Stable = struct\n module V2 = struct\n type t =\n ( Account.Stable.V2.t\n , Protocol_state.Stable.V1.t\n , Other.Stable.V2.t\n , Public_key.Compressed.Stable.V1.t Eq_data.Stable.V1.t )\n Poly.Stable.V1.t\n [@@deriving sexp, equal, yojson, hash, compare]\n\n let to_latest = Fn.id\n end\nend]\n\nmodule Digested = F\n\nlet to_input ({ self_predicate; other; fee_payer; protocol_state_predicate } : t)\n =\n let open Random_oracle_input.Chunked in\n List.reduce_exn ~f:append\n [ Account.to_input self_predicate\n ; Other.to_input other\n ; Eq_data.(to_input (Tc.public_key ())) fee_payer\n ; Protocol_state.to_input protocol_state_predicate\n ]\n\nlet digest t =\n Random_oracle.(\n hash ~init:Hash_prefix.zkapp_precondition (pack_input (to_input t)))\n\nlet accept : t =\n { self_predicate = Account.accept\n ; other = Other.accept\n ; fee_payer = Ignore\n ; protocol_state_predicate = Protocol_state.accept\n }\n\nmodule Checked = struct\n type t =\n ( Account.Checked.t\n , Protocol_state.Checked.t\n , Other.Checked.t\n , Public_key.Compressed.var Or_ignore.Checked.t )\n Poly.Stable.Latest.t\n\n let to_input\n ({ self_predicate; other; fee_payer; protocol_state_predicate } : t) =\n let open Random_oracle_input.Chunked in\n List.reduce_exn ~f:append\n [ Account.Checked.to_input self_predicate\n ; Other.Checked.to_input other\n ; Eq_data.(to_input_checked (Tc.public_key ())) fee_payer\n ; Protocol_state.Checked.to_input protocol_state_predicate\n ]\n\n let digest t =\n Random_oracle.Checked.(\n hash ~init:Hash_prefix.zkapp_precondition (pack_input (to_input t)))\nend\n\nlet typ () : (Checked.t, Stable.Latest.t) Typ.t =\n Poly.typ\n [ Account.typ ()\n ; Other.typ ()\n ; Eq_data.(typ (Tc.public_key ()))\n ; Protocol_state.typ\n ]\n","open Snark_params\nopen Tick\n\ntype 'a t = Field.Var.t * 'a As_prover.Ref.t\n\nlet hash (x, _) = x\n\nlet ref (_, x) = x\n\nlet typ ~hash =\n Typ.transport\n Typ.(Field.typ * Internal.ref ())\n ~there:(fun s -> (hash s, s))\n ~back:(fun (_, s) -> s)\n\nlet optional_typ ~hash ~non_preimage ~dummy_value =\n Typ.transport\n Typ.(Field.typ * Internal.ref ())\n ~there:(function\n | None -> (non_preimage, dummy_value) | Some s -> (hash s, s) )\n ~back:(fun (_, s) -> Some s)\n\nlet to_input (x, _) = Random_oracle_input.Chunked.field x\n\nlet if_ b ~then_ ~else_ =\n let open Run in\n let hash = Field.if_ b ~then_:(fst then_) ~else_:(fst else_) in\n let ref =\n As_prover.Ref.create\n As_prover.(\n fun () ->\n let ref = if read Boolean.typ b then snd then_ else snd else_ in\n As_prover.Ref.get ref)\n in\n (hash, ref)\n\nlet make_unsafe hash ref : 'a t = (hash, ref)\n\nmodule As_record = struct\n (* it's OK that hash is a Field.t (not a var), bc this is just annotation for the deriver *)\n type 'a t = { data : 'a; hash : Field.t } [@@deriving annot, fields]\nend\n\nlet deriver inner obj =\n let open Fields_derivers_zkapps in\n let ( !. ) = ( !. ) ~t_fields_annots:As_record.t_fields_annots in\n As_record.Fields.make_creator obj ~data:!.inner ~hash:!.field\n |> finish \"Events\" ~t_toplevel_annots:As_record.t_toplevel_annots\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Mina_base_util\n\n[%%ifdef consensus_mechanism]\n\nopen Snark_params.Tick\n\n[%%endif]\n\nopen Signature_lib\nmodule Impl = Pickles.Impls.Step\nopen Mina_numbers\nopen Currency\nopen Pickles_types\nmodule Digest = Random_oracle.Digest\n\nmodule type Type = sig\n type t\nend\n\nmodule Authorization_kind = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n (* TODO: yojson for Field.t in snarky (#12591) *)\n type t =\n Mina_wire_types.Mina_base.Account_update.Authorization_kind.V1.t =\n | Signature\n | Proof of\n (Field.t\n [@version_asserted]\n [@to_yojson fun t -> `String (Snark_params.Tick.Field.to_string t)]\n [@of_yojson\n function\n | `String s ->\n let field = Snark_params.Tick.Field.of_string s in\n let s' = Snark_params.Tick.Field.to_string field in\n if String.equal s s' then Ok field\n else Error \"Invalid JSON for field\"\n | _ ->\n Error \"expected JSON string\"] )\n | None_given\n [@@deriving sexp, equal, yojson, hash, compare]\n\n let to_latest = Fn.id\n end\n end]\n\n module Structured = struct\n type t =\n { is_signed : bool\n ; is_proved : bool\n ; verification_key_hash : Snark_params.Tick.Field.t\n }\n [@@deriving hlist, annot, fields]\n\n let to_input ({ is_signed; is_proved; verification_key_hash } : t) =\n let f x = if x then Field.one else Field.zero in\n Random_oracle_input.Chunked.append\n (Random_oracle_input.Chunked.packeds\n [| (f is_signed, 1); (f is_proved, 1) |] )\n (Random_oracle_input.Chunked.field verification_key_hash)\n\n [%%ifdef consensus_mechanism]\n\n module Checked = struct\n type t =\n { is_signed : Boolean.var\n ; is_proved : Boolean.var\n ; verification_key_hash : Snark_params.Tick.Field.Var.t\n }\n [@@deriving hlist]\n\n let to_input { is_signed; is_proved; verification_key_hash } =\n let f (x : Boolean.var) = (x :> Field.Var.t) in\n Random_oracle_input.Chunked.append\n (Random_oracle_input.Chunked.packeds\n [| (f is_signed, 1); (f is_proved, 1) |] )\n (Random_oracle_input.Chunked.field verification_key_hash)\n end\n\n let typ =\n Typ.of_hlistable ~var_to_hlist:Checked.to_hlist\n ~var_of_hlist:Checked.of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist\n [ Boolean.typ; Boolean.typ; Field.typ ]\n\n let deriver obj =\n let open Fields_derivers_zkapps in\n let open Fields in\n let ( !. ) = ( !. ) ~t_fields_annots in\n let verification_key_hash =\n needs_custom_js ~js_type:field ~name:\"VerificationKeyHash\" field\n in\n Fields.make_creator obj ~is_signed:!.bool ~is_proved:!.bool\n ~verification_key_hash:!.verification_key_hash\n |> finish \"AuthorizationKindStructured\" ~t_toplevel_annots\n\n [%%endif]\n end\n\n let to_control_tag : t -> Control.Tag.t = function\n | None_given ->\n None_given\n | Signature ->\n Signature\n | Proof _ ->\n Proof\n\n let to_structured : t -> Structured.t = function\n | None_given ->\n { is_signed = false\n ; is_proved = false\n ; verification_key_hash = Zkapp_account.dummy_vk_hash ()\n }\n | Signature ->\n { is_signed = true\n ; is_proved = false\n ; verification_key_hash = Zkapp_account.dummy_vk_hash ()\n }\n | Proof verification_key_hash ->\n { is_signed = false; is_proved = true; verification_key_hash }\n\n let of_structured_exn : Structured.t -> t = function\n | { is_signed = false; is_proved = false; _ } ->\n None_given\n | { is_signed = true; is_proved = false; _ } ->\n Signature\n | { is_signed = false; is_proved = true; verification_key_hash } ->\n Proof verification_key_hash\n | { is_signed = true; is_proved = true; _ } ->\n failwith \"Invalid authorization kind\"\n\n let gen =\n let%bind.Quickcheck vk_hash = Field.gen in\n Quickcheck.Generator.of_list [ None_given; Signature; Proof vk_hash ]\n\n let deriver obj =\n let open Fields_derivers_zkapps in\n iso_record ~to_record:to_structured ~of_record:of_structured_exn\n Structured.deriver obj\n\n let to_input x = Structured.to_input (to_structured x)\n\n [%%ifdef consensus_mechanism]\n\n module Checked = Structured.Checked\n\n let typ =\n Structured.typ |> Typ.transport ~there:to_structured ~back:of_structured_exn\n\n [%%endif]\nend\n\nmodule May_use_token = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Mina_wire_types.Mina_base.Account_update.May_use_token.V1.t =\n | No\n (** No permission to use any token other than the default Mina\n token.\n *)\n | Parents_own_token\n (** Has permission to use the token owned by the direct parent of\n this account update, which may be inherited by child account\n updates.\n *)\n | Inherit_from_parent\n (** Inherit the token permission available to the parent. *)\n [@@deriving sexp, equal, yojson, hash, compare]\n\n let to_latest = Fn.id\n end\n end]\n\n let gen =\n Quickcheck.Generator.of_list [ No; Parents_own_token; Inherit_from_parent ]\n\n let to_string = function\n | No ->\n \"No\"\n | Parents_own_token ->\n \"ParentsOwnToken\"\n | Inherit_from_parent ->\n \"InheritFromParent\"\n\n let of_string = function\n | \"No\" ->\n No\n | \"ParentsOwnToken\" ->\n Parents_own_token\n | \"InheritFromParent\" ->\n Inherit_from_parent\n | s ->\n failwithf \"Invalid call type: %s\" s ()\n\n let parents_own_token = function Parents_own_token -> true | _ -> false\n\n let inherit_from_parent = function Inherit_from_parent -> true | _ -> false\n\n module As_record : sig\n type variant = t\n\n type 'bool t\n\n val parents_own_token : 'bool t -> 'bool\n\n val inherit_from_parent : 'bool t -> 'bool\n\n val map : f:('a -> 'b) -> 'a t -> 'b t\n\n val to_hlist : 'bool t -> (unit, 'bool -> 'bool -> unit) H_list.t\n\n val of_hlist : (unit, 'bool -> 'bool -> unit) H_list.t -> 'bool t\n\n val to_input :\n field_of_bool:('a -> 'b) -> 'a t -> 'b Random_oracle_input.Chunked.t\n\n val typ : (Snark_params.Tick.Boolean.var t, bool t) Snark_params.Tick.Typ.t\n\n val equal :\n and_:('bool -> 'bool -> 'bool)\n -> equal:('a -> 'a -> 'bool)\n -> 'a t\n -> 'a t\n -> 'bool\n\n val to_variant : bool t -> variant\n\n val of_variant : variant -> bool t\n\n (* TODO: Create an alias for this type *)\n val deriver :\n ( bool t\n , ( ( ( bool t\n , ( bool t\n , ( bool t\n , ( ( bool t\n , ( bool t\n , ( bool t\n , ( (< contramap : (bool t -> bool t) Core_kernel.ref\n ; graphql_arg :\n ( unit\n -> bool t\n Fields_derivers_graphql.Schema.Arg\n .arg_typ )\n Core_kernel.ref\n ; graphql_arg_accumulator :\n bool t\n Fields_derivers_zkapps.Derivers.Graphql.Args\n .Acc\n .T\n .t\n Core_kernel.ref\n ; graphql_creator :\n ( ( ( 'a\n , bool t\n , bool t\n , 'b )\n Fields_derivers_zkapps.Derivers\n .Graphql\n .Args\n .Output\n .t\n , bool t\n , bool t\n , 'b )\n Fields_derivers_zkapps.Derivers.Graphql\n .Args\n .Input\n .t\n -> bool t )\n Core_kernel.ref\n ; graphql_fields :\n bool t\n Fields_derivers_zkapps.Derivers.Graphql\n .Fields\n .Input\n .T\n .t\n Core_kernel.ref\n ; graphql_fields_accumulator :\n bool t\n Fields_derivers_zkapps.Derivers.Graphql\n .Fields\n .Accumulator\n .T\n .t\n list\n Core_kernel.ref\n ; graphql_query : string option Core_kernel.ref\n ; graphql_query_accumulator :\n (Core_kernel.String.t * string option)\n option\n list\n Core_kernel.ref\n ; js_layout :\n [> `Assoc of (string * Yojson.Safe.t) list ]\n Core_kernel.ref\n ; js_layout_accumulator :\n Fields_derivers_zkapps__.Fields_derivers_js\n .Js_layout\n .Accumulator\n .field\n option\n list\n Core_kernel.ref\n ; map : (bool t -> bool t) Core_kernel.ref\n ; nullable_graphql_arg :\n ( unit\n -> 'b\n Fields_derivers_graphql.Schema.Arg\n .arg_typ )\n Core_kernel.ref\n ; nullable_graphql_fields :\n bool t option\n Fields_derivers_zkapps.Derivers.Graphql\n .Fields\n .Input\n .T\n .t\n Core_kernel.ref\n ; of_json :\n (Yojson.Safe.t -> bool t) Core_kernel.ref\n ; of_json_creator :\n Yojson.Safe.t Core_kernel.String.Map.t\n Core_kernel.ref\n ; skip : bool Core_kernel.ref\n ; to_json :\n (bool t -> Yojson.Safe.t) Core_kernel.ref\n ; to_json_accumulator :\n ( Core_kernel.String.t\n * (bool t -> Yojson.Safe.t) )\n option\n list\n Core_kernel.ref\n ; .. >\n as\n 'a )\n Fields_derivers_zkapps__.Fields_derivers_js\n .Js_layout\n .Input\n .t\n Fields_derivers_graphql.Graphql_query.Input.t\n , bool t\n , bool t\n , 'b )\n Fields_derivers_zkapps.Derivers.Graphql.Args.Input\n .t\n , bool t\n , bool t option )\n Fields_derivers_zkapps.Derivers.Graphql.Fields.Input\n .t\n , bool t )\n Fields_derivers_json.Of_yojson.Input.t\n , bool t )\n Fields_derivers_json.To_yojson.Input.t\n Fields_derivers_zkapps.Unified_input.t\n Fields_derivers_zkapps__.Fields_derivers_js.Js_layout\n .Input\n .t\n Fields_derivers_graphql.Graphql_query.Input.t\n , bool t\n , bool t\n , 'b )\n Fields_derivers_zkapps.Derivers.Graphql.Args.Input.t\n , bool t\n , bool t option )\n Fields_derivers_zkapps.Derivers.Graphql.Fields.Input.t\n , bool t )\n Fields_derivers_json.Of_yojson.Input.t\n , bool t )\n Fields_derivers_json.To_yojson.Input.t\n Fields_derivers_zkapps.Unified_input.t\n , bool t\n , bool t\n , 'b )\n Fields_derivers_zkapps.Derivers.Graphql.Args.Input.t\n , bool t\n , bool t\n , 'b )\n Fields_derivers_zkapps.Derivers.Graphql.Args.Acc.t\n , bool t\n , bool t option )\n Fields_derivers_zkapps.Derivers.Graphql.Fields.Accumulator.t\n -> ( bool t\n , ( bool t\n , ( bool t\n , ( 'a Fields_derivers_zkapps__.Fields_derivers_js.Js_layout.Input.t\n Fields_derivers_graphql.Graphql_query.Input.t\n , bool t\n , bool t\n , 'b )\n Fields_derivers_zkapps.Derivers.Graphql.Args.Input.t\n , bool t\n , bool t option )\n Fields_derivers_zkapps.Derivers.Graphql.Fields.Input.t\n , bool t )\n Fields_derivers_json.Of_yojson.Input.t\n , bool t )\n Fields_derivers_json.To_yojson.Input.t\n Fields_derivers_zkapps.Unified_input.t\n end = struct\n type variant = t\n\n type 'bool t =\n { (* NB: call is implicit. *)\n parents_own_token : 'bool\n ; inherit_from_parent : 'bool\n }\n [@@deriving annot, hlist, fields]\n\n let map ~f { parents_own_token; inherit_from_parent } =\n { parents_own_token = f parents_own_token\n ; inherit_from_parent = f inherit_from_parent\n }\n\n let typ : _ Typ.t =\n let open Snark_params.Tick in\n let (Typ typ) =\n Typ.of_hlistable\n [ Boolean.typ; Boolean.typ ]\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist\n in\n Typ\n { typ with\n check =\n (fun ({ parents_own_token; inherit_from_parent } as x) ->\n let open Checked in\n let%bind () = typ.check x in\n let sum =\n Field.Var.(\n add (parents_own_token :> t) (inherit_from_parent :> t))\n in\n (* Assert boolean; we should really have a helper for this\n somewhere.\n *)\n let%bind sum_squared = Field.Checked.mul sum sum in\n Field.Checked.Assert.equal sum sum_squared )\n }\n\n let to_input ~field_of_bool { parents_own_token; inherit_from_parent } =\n Array.reduce_exn ~f:Random_oracle_input.Chunked.append\n [| Random_oracle_input.Chunked.packed\n (field_of_bool parents_own_token, 1)\n ; Random_oracle_input.Chunked.packed\n (field_of_bool inherit_from_parent, 1)\n |]\n\n let equal ~and_ ~equal\n { parents_own_token = parents_own_token1\n ; inherit_from_parent = inherit_from_parent1\n }\n { parents_own_token = parents_own_token2\n ; inherit_from_parent = inherit_from_parent2\n } =\n and_\n (equal parents_own_token1 parents_own_token2)\n (equal inherit_from_parent1 inherit_from_parent2)\n\n let to_variant = function\n | { parents_own_token = false; inherit_from_parent = false } ->\n No\n | { parents_own_token = true; inherit_from_parent = false } ->\n Parents_own_token\n | { parents_own_token = false; inherit_from_parent = true } ->\n Inherit_from_parent\n | _ ->\n failwith \"May_use_token.to_variant: More than one boolean flag is set\"\n\n let of_variant = function\n | No ->\n { parents_own_token = false; inherit_from_parent = false }\n | Parents_own_token ->\n { parents_own_token = true; inherit_from_parent = false }\n | Inherit_from_parent ->\n { parents_own_token = false; inherit_from_parent = true }\n\n let deriver obj : _ Fields_derivers_zkapps.Unified_input.t =\n let open Fields_derivers_zkapps.Derivers in\n let ( !. ) = ( !. ) ~t_fields_annots in\n Fields.make_creator obj ~parents_own_token:!.bool\n ~inherit_from_parent:!.bool\n |> finish \"MayUseToken\" ~t_toplevel_annots\n end\n\n let quickcheck_generator = gen\n\n let deriver obj =\n let open Fields_derivers_zkapps in\n iso_record ~of_record:As_record.to_variant ~to_record:As_record.of_variant\n As_record.deriver obj\n\n module Checked = struct\n type t = Boolean.var As_record.t\n\n let parents_own_token = As_record.parents_own_token\n\n let inherit_from_parent = As_record.inherit_from_parent\n\n let constant x =\n As_record.map ~f:Boolean.var_of_value @@ As_record.of_variant x\n\n let to_input (x : t) =\n As_record.to_input\n ~field_of_bool:(fun (x : Boolean.var) -> (x :> Field.Var.t))\n x\n\n let equal x y =\n As_record.equal ~equal:Run.Boolean.equal ~and_:Run.Boolean.( &&& ) x y\n\n let assert_equal x y =\n As_record.equal ~equal:Run.Boolean.Assert.( = ) ~and_:(fun _ _ -> ()) x y\n end\n\n let to_input x = As_record.to_input ~field_of_bool (As_record.of_variant x)\n\n let typ : (Checked.t, t) Typ.t =\n As_record.typ\n |> Typ.transport ~there:As_record.of_variant ~back:As_record.to_variant\nend\n\nmodule Update = struct\n module Timing_info = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t =\n Mina_wire_types.Mina_base.Account_update.Update.Timing_info.V1.t =\n { initial_minimum_balance : Balance.Stable.V1.t\n ; cliff_time : Global_slot_since_genesis.Stable.V1.t\n ; cliff_amount : Amount.Stable.V1.t\n ; vesting_period : Global_slot_span.Stable.V1.t\n ; vesting_increment : Amount.Stable.V1.t\n }\n [@@deriving annot, compare, equal, sexp, hash, yojson, hlist, fields]\n\n let to_latest = Fn.id\n end\n end]\n\n type value = t\n\n let gen =\n let open Quickcheck.Let_syntax in\n let%bind initial_minimum_balance = Balance.gen in\n let%bind cliff_time = Global_slot_since_genesis.gen in\n let%bind cliff_amount =\n Amount.gen_incl Amount.zero (Balance.to_amount initial_minimum_balance)\n in\n let%bind vesting_period =\n Global_slot_span.gen_incl\n Global_slot_span.(succ zero)\n (Global_slot_span.of_int 10)\n in\n let%map vesting_increment =\n Amount.gen_incl Amount.one (Amount.of_nanomina_int_exn 100)\n in\n { initial_minimum_balance\n ; cliff_time\n ; cliff_amount\n ; vesting_period\n ; vesting_increment\n }\n\n let to_input (t : t) =\n List.reduce_exn ~f:Random_oracle_input.Chunked.append\n [ Balance.to_input t.initial_minimum_balance\n ; Global_slot_since_genesis.to_input t.cliff_time\n ; Amount.to_input t.cliff_amount\n ; Global_slot_span.to_input t.vesting_period\n ; Amount.to_input t.vesting_increment\n ]\n\n let dummy =\n let slot_unused = Global_slot_since_genesis.zero in\n let slot_span_unused = Global_slot_span.zero in\n let balance_unused = Balance.zero in\n let amount_unused = Amount.zero in\n { initial_minimum_balance = balance_unused\n ; cliff_time = slot_unused\n ; cliff_amount = amount_unused\n ; vesting_period = slot_span_unused\n ; vesting_increment = amount_unused\n }\n\n let to_account_timing (t : t) : Account_timing.t =\n Timed\n { initial_minimum_balance = t.initial_minimum_balance\n ; cliff_time = t.cliff_time\n ; cliff_amount = t.cliff_amount\n ; vesting_period = t.vesting_period\n ; vesting_increment = t.vesting_increment\n }\n\n let of_account_timing (t : Account_timing.t) : t option =\n match t with\n | Untimed ->\n None\n | Timed t ->\n Some\n { initial_minimum_balance = t.initial_minimum_balance\n ; cliff_time = t.cliff_time\n ; cliff_amount = t.cliff_amount\n ; vesting_period = t.vesting_period\n ; vesting_increment = t.vesting_increment\n }\n\n module Checked = struct\n type t =\n { initial_minimum_balance : Balance.Checked.t\n ; cliff_time : Global_slot_since_genesis.Checked.t\n ; cliff_amount : Amount.Checked.t\n ; vesting_period : Global_slot_span.Checked.t\n ; vesting_increment : Amount.Checked.t\n }\n [@@deriving hlist]\n\n let constant (t : value) : t =\n { initial_minimum_balance = Balance.var_of_t t.initial_minimum_balance\n ; cliff_time = Global_slot_since_genesis.Checked.constant t.cliff_time\n ; cliff_amount = Amount.var_of_t t.cliff_amount\n ; vesting_period = Global_slot_span.Checked.constant t.vesting_period\n ; vesting_increment = Amount.var_of_t t.vesting_increment\n }\n\n let to_input\n ({ initial_minimum_balance\n ; cliff_time\n ; cliff_amount\n ; vesting_period\n ; vesting_increment\n } :\n t ) =\n List.reduce_exn ~f:Random_oracle_input.Chunked.append\n [ Balance.var_to_input initial_minimum_balance\n ; Global_slot_since_genesis.Checked.to_input cliff_time\n ; Amount.var_to_input cliff_amount\n ; Global_slot_span.Checked.to_input vesting_period\n ; Amount.var_to_input vesting_increment\n ]\n\n let to_account_timing (t : t) : Account_timing.var =\n { is_timed = Boolean.true_\n ; initial_minimum_balance = t.initial_minimum_balance\n ; cliff_time = t.cliff_time\n ; cliff_amount = t.cliff_amount\n ; vesting_period = t.vesting_period\n ; vesting_increment = t.vesting_increment\n }\n\n let of_account_timing (t : Account_timing.var) : t =\n { initial_minimum_balance = t.initial_minimum_balance\n ; cliff_time = t.cliff_time\n ; cliff_amount = t.cliff_amount\n ; vesting_period = t.vesting_period\n ; vesting_increment = t.vesting_increment\n }\n end\n\n let typ : (Checked.t, t) Typ.t =\n Typ.of_hlistable\n [ Balance.typ\n ; Global_slot_since_genesis.typ\n ; Amount.typ\n ; Global_slot_span.typ\n ; Amount.typ\n ]\n ~var_to_hlist:Checked.to_hlist ~var_of_hlist:Checked.of_hlist\n ~value_to_hlist:to_hlist ~value_of_hlist:of_hlist\n\n let deriver obj =\n let open Fields_derivers_zkapps.Derivers in\n let ( !. ) = ( !. ) ~t_fields_annots in\n Fields.make_creator obj ~initial_minimum_balance:!.balance\n ~cliff_time:!.global_slot_since_genesis\n ~cliff_amount:!.amount ~vesting_period:!.global_slot_span\n ~vesting_increment:!.amount\n |> finish \"Timing\" ~t_toplevel_annots\n end\n\n open Zkapp_basic\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n (* TODO: Have to check that the public key is not = Public_key.Compressed.empty here. *)\n type t = Mina_wire_types.Mina_base.Account_update.Update.V1.t =\n { app_state :\n F.Stable.V1.t Set_or_keep.Stable.V1.t Zkapp_state.V.Stable.V1.t\n ; delegate : Public_key.Compressed.Stable.V1.t Set_or_keep.Stable.V1.t\n ; verification_key :\n Verification_key_wire.Stable.V1.t Set_or_keep.Stable.V1.t\n ; permissions : Permissions.Stable.V2.t Set_or_keep.Stable.V1.t\n ; zkapp_uri : string Set_or_keep.Stable.V1.t\n ; token_symbol :\n Account.Token_symbol.Stable.V1.t Set_or_keep.Stable.V1.t\n ; timing : Timing_info.Stable.V1.t Set_or_keep.Stable.V1.t\n ; voting_for : State_hash.Stable.V1.t Set_or_keep.Stable.V1.t\n }\n [@@deriving annot, compare, equal, sexp, hash, yojson, fields, hlist]\n\n let to_latest = Fn.id\n end\n end]\n\n let gen ?(token_account = false) ?(zkapp_account = false) ?vk\n ?permissions_auth () : t Quickcheck.Generator.t =\n let open Quickcheck.Let_syntax in\n let%bind app_state =\n let%bind fields =\n let field_gen = Snark_params.Tick.Field.gen in\n Quickcheck.Generator.list_with_length 8 (Set_or_keep.gen field_gen)\n in\n (* won't raise because length is correct *)\n Quickcheck.Generator.return (Zkapp_state.V.of_list_exn fields)\n in\n let%bind delegate =\n if not token_account then Set_or_keep.gen Public_key.Compressed.gen\n else return Set_or_keep.Keep\n in\n let%bind verification_key =\n if zkapp_account then\n Set_or_keep.gen\n (Quickcheck.Generator.return\n ( match vk with\n | None ->\n let data = Pickles.Side_loaded.Verification_key.dummy in\n let hash = Zkapp_account.digest_vk data in\n { With_hash.data; hash }\n | Some vk ->\n vk ) )\n else return Set_or_keep.Keep\n in\n let%bind permissions =\n match permissions_auth with\n | None ->\n return Set_or_keep.Keep\n | Some auth_tag ->\n let%map permissions = Permissions.gen ~auth_tag in\n Set_or_keep.Set permissions\n in\n let%bind zkapp_uri =\n let uri_gen =\n Quickcheck.Generator.of_list\n [ \"https://www.example.com\"\n ; \"https://www.minaprotocol.com\"\n ; \"https://www.gurgle.com\"\n ; \"https://faceplant.com\"\n ]\n in\n Set_or_keep.gen uri_gen\n in\n let%bind token_symbol =\n let token_gen =\n Quickcheck.Generator.of_list\n [ \"MINA\"; \"TOKEN1\"; \"TOKEN2\"; \"TOKEN3\"; \"TOKEN4\"; \"TOKEN5\" ]\n in\n Set_or_keep.gen token_gen\n in\n let%bind voting_for = Set_or_keep.gen Field.gen in\n (* a new account for the Account_update.t is in the ledger when we use\n this generated update in tests, so the timing must be Keep\n *)\n let timing = Set_or_keep.Keep in\n return\n ( { app_state\n ; delegate\n ; verification_key\n ; permissions\n ; zkapp_uri\n ; token_symbol\n ; timing\n ; voting_for\n }\n : t )\n\n module Checked = struct\n open Pickles.Impls.Step\n\n type t =\n { app_state : Field.t Set_or_keep.Checked.t Zkapp_state.V.t\n ; delegate : Public_key.Compressed.var Set_or_keep.Checked.t\n ; verification_key :\n ( Boolean.var\n , ( Side_loaded_verification_key.t option\n , Field.Constant.t )\n With_hash.t\n Data_as_hash.t )\n Zkapp_basic.Flagged_option.t\n Set_or_keep.Checked.t\n ; permissions : Permissions.Checked.t Set_or_keep.Checked.t\n ; zkapp_uri : string Data_as_hash.t Set_or_keep.Checked.t\n ; token_symbol : Account.Token_symbol.var Set_or_keep.Checked.t\n ; timing : Timing_info.Checked.t Set_or_keep.Checked.t\n ; voting_for : State_hash.var Set_or_keep.Checked.t\n }\n [@@deriving hlist]\n\n let to_input\n ({ app_state\n ; delegate\n ; verification_key\n ; permissions\n ; zkapp_uri\n ; token_symbol\n ; timing\n ; voting_for\n } :\n t ) =\n let open Random_oracle_input.Chunked in\n List.reduce_exn ~f:append\n [ Zkapp_state.to_input app_state\n ~f:(Set_or_keep.Checked.to_input ~f:field)\n ; Set_or_keep.Checked.to_input delegate\n ~f:Public_key.Compressed.Checked.to_input\n ; Set_or_keep.Checked.to_input verification_key ~f:(fun x ->\n field (Data_as_hash.hash x.data) )\n ; Set_or_keep.Checked.to_input permissions\n ~f:Permissions.Checked.to_input\n ; Set_or_keep.Checked.to_input zkapp_uri ~f:Data_as_hash.to_input\n ; Set_or_keep.Checked.to_input token_symbol\n ~f:Account.Token_symbol.var_to_input\n ; Set_or_keep.Checked.to_input timing ~f:Timing_info.Checked.to_input\n ; Set_or_keep.Checked.to_input voting_for ~f:State_hash.var_to_input\n ]\n end\n\n let noop : t =\n { app_state =\n Vector.init Zkapp_state.Max_state_size.n ~f:(fun _ -> Set_or_keep.Keep)\n ; delegate = Keep\n ; verification_key = Keep\n ; permissions = Keep\n ; zkapp_uri = Keep\n ; token_symbol = Keep\n ; timing = Keep\n ; voting_for = Keep\n }\n\n let dummy = noop\n\n let to_input\n ({ app_state\n ; delegate\n ; verification_key\n ; permissions\n ; zkapp_uri\n ; token_symbol\n ; timing\n ; voting_for\n } :\n t ) =\n let open Random_oracle_input.Chunked in\n List.reduce_exn ~f:append\n [ Zkapp_state.to_input app_state\n ~f:(Set_or_keep.to_input ~dummy:Field.zero ~f:field)\n ; Set_or_keep.to_input delegate\n ~dummy:(Zkapp_precondition.Eq_data.Tc.public_key ()).default\n ~f:Public_key.Compressed.to_input\n ; Set_or_keep.to_input\n (Set_or_keep.map verification_key ~f:With_hash.hash)\n ~dummy:Field.zero ~f:field\n ; Set_or_keep.to_input permissions ~dummy:Permissions.empty\n ~f:Permissions.to_input\n ; Set_or_keep.to_input\n (Set_or_keep.map ~f:Zkapp_account.hash_zkapp_uri zkapp_uri)\n ~dummy:(Zkapp_account.hash_zkapp_uri_opt None)\n ~f:field\n ; Set_or_keep.to_input token_symbol ~dummy:Account.Token_symbol.default\n ~f:Account.Token_symbol.to_input\n ; Set_or_keep.to_input timing ~dummy:Timing_info.dummy\n ~f:Timing_info.to_input\n ; Set_or_keep.to_input voting_for ~dummy:State_hash.dummy\n ~f:State_hash.to_input\n ]\n\n let typ () : (Checked.t, t) Typ.t =\n let open Pickles.Impls.Step in\n Typ.of_hlistable\n [ Zkapp_state.typ (Set_or_keep.typ ~dummy:Field.Constant.zero Field.typ)\n ; Set_or_keep.typ ~dummy:Public_key.Compressed.empty\n Public_key.Compressed.typ\n ; Set_or_keep.optional_typ\n (Data_as_hash.typ ~hash:With_hash.hash)\n ~to_option:(function\n | { With_hash.data = Some data; hash } ->\n Some { With_hash.data; hash }\n | { With_hash.data = None; _ } ->\n None )\n ~of_option:(function\n | Some { With_hash.data; hash } ->\n { With_hash.data = Some data; hash }\n | None ->\n { With_hash.data = None; hash = Field.Constant.zero } )\n |> Typ.transport_var\n ~there:\n (Set_or_keep.Checked.map\n ~f:(fun { Zkapp_basic.Flagged_option.data; _ } -> data) )\n ~back:(fun x ->\n Set_or_keep.Checked.map x ~f:(fun data ->\n { Zkapp_basic.Flagged_option.data\n ; is_some = Set_or_keep.Checked.is_set x\n } ) )\n ; Set_or_keep.typ ~dummy:Permissions.empty Permissions.typ\n ; Set_or_keep.optional_typ\n (Data_as_hash.optional_typ ~hash:Zkapp_account.hash_zkapp_uri\n ~non_preimage:(Zkapp_account.hash_zkapp_uri_opt None)\n ~dummy_value:\"\" )\n ~to_option:Fn.id ~of_option:Fn.id\n ; Set_or_keep.typ ~dummy:Account.Token_symbol.default\n Account.Token_symbol.typ\n ; Set_or_keep.typ ~dummy:Timing_info.dummy Timing_info.typ\n ; Set_or_keep.typ ~dummy:State_hash.dummy State_hash.typ\n ]\n ~var_to_hlist:Checked.to_hlist ~var_of_hlist:Checked.of_hlist\n ~value_to_hlist:to_hlist ~value_of_hlist:of_hlist\n\n let deriver obj =\n let open Fields_derivers_zkapps in\n let ( !. ) = ( !. ) ~t_fields_annots in\n let zkapp_uri =\n needs_custom_js\n ~js_type:(Data_as_hash.deriver string)\n ~name:\"ZkappUri\" string\n in\n let token_symbol =\n needs_custom_js\n ~js_type:\n (js_record\n [ (\"symbol\", js_layout string); (\"field\", js_layout field) ] )\n ~name:\"TokenSymbol\" string\n in\n finish \"AccountUpdateModification\" ~t_toplevel_annots\n @@ Fields.make_creator\n ~app_state:!.(Zkapp_state.deriver @@ Set_or_keep.deriver field)\n ~delegate:!.(Set_or_keep.deriver public_key)\n ~verification_key:!.(Set_or_keep.deriver verification_key_with_hash)\n ~permissions:!.(Set_or_keep.deriver Permissions.deriver)\n ~zkapp_uri:!.(Set_or_keep.deriver zkapp_uri)\n ~token_symbol:!.(Set_or_keep.deriver token_symbol)\n ~timing:!.(Set_or_keep.deriver Timing_info.deriver)\n ~voting_for:!.(Set_or_keep.deriver State_hash.deriver)\n obj\nend\n\nmodule Events = Zkapp_account.Events\nmodule Actions = Zkapp_account.Actions\n\nmodule Account_precondition = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t =\n Mina_wire_types.Mina_base.Account_update.Account_precondition.V1.t =\n | Full of Zkapp_precondition.Account.Stable.V2.t\n | Nonce of Account.Nonce.Stable.V1.t\n | Accept\n [@@deriving sexp, yojson, hash]\n\n let to_latest = Fn.id\n\n let to_full = function\n | Full s ->\n s\n | Nonce n ->\n { Zkapp_precondition.Account.accept with\n nonce = Check { lower = n; upper = n }\n }\n | Accept ->\n Zkapp_precondition.Account.accept\n\n let equal p q = Zkapp_precondition.Account.equal (to_full p) (to_full q)\n\n let compare p q =\n Zkapp_precondition.Account.compare (to_full p) (to_full q)\n end\n end]\n\n [%%define_locally Stable.Latest.(to_full, equal, compare)]\n\n let gen : t Quickcheck.Generator.t =\n Quickcheck.Generator.variant3 Zkapp_precondition.Account.gen\n Account.Nonce.gen Unit.quickcheck_generator\n |> Quickcheck.Generator.map ~f:(function\n | `A x ->\n Full x\n | `B x ->\n Nonce x\n | `C () ->\n Accept )\n\n let of_full (p : Zkapp_precondition.Account.t) =\n let module A = Zkapp_precondition.Account in\n if A.equal p A.accept then Accept\n else\n match p.nonce with\n | Ignore ->\n Full p\n | Check { lower; upper } as n ->\n if\n A.equal p { A.accept with nonce = n }\n && Account.Nonce.equal lower upper\n then Nonce lower\n else Full p\n\n module Tag = struct\n type t = Full | Nonce | Accept [@@deriving equal, compare, sexp, yojson]\n end\n\n let tag : t -> Tag.t = function\n | Full _ ->\n Full\n | Nonce _ ->\n Nonce\n | Accept ->\n Accept\n\n let deriver obj =\n let open Fields_derivers_zkapps.Derivers in\n iso_record ~of_record:of_full ~to_record:to_full\n Zkapp_precondition.Account.deriver obj\n\n let digest (t : t) =\n let digest x =\n Random_oracle.(\n hash ~init:Hash_prefix_states.account_update_account_precondition\n (pack_input x))\n in\n to_full t |> Zkapp_precondition.Account.to_input |> digest\n\n module Checked = struct\n type t = Zkapp_precondition.Account.Checked.t\n\n let digest (t : t) =\n let digest x =\n Random_oracle.Checked.(\n hash ~init:Hash_prefix_states.account_update_account_precondition\n (pack_input x))\n in\n Zkapp_precondition.Account.Checked.to_input t |> digest\n\n let nonce (t : t) = t.nonce\n end\n\n let typ () : (Zkapp_precondition.Account.Checked.t, t) Typ.t =\n Typ.transport (Zkapp_precondition.Account.typ ()) ~there:to_full\n ~back:(fun s -> Full s)\n\n let nonce = function\n | Full { nonce; _ } ->\n nonce\n | Nonce nonce ->\n Check { lower = nonce; upper = nonce }\n | Accept ->\n Ignore\nend\n\nmodule Preconditions = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Mina_wire_types.Mina_base.Account_update.Preconditions.V1.t =\n { network : Zkapp_precondition.Protocol_state.Stable.V1.t\n ; account : Account_precondition.Stable.V1.t\n ; valid_while :\n Mina_numbers.Global_slot_since_genesis.Stable.V1.t\n Zkapp_precondition.Numeric.Stable.V1.t\n }\n [@@deriving annot, sexp, equal, yojson, hash, hlist, compare, fields]\n\n let to_latest = Fn.id\n end\n end]\n\n let deriver obj =\n let open Fields_derivers_zkapps.Derivers in\n let ( !. ) = ( !. ) ~t_fields_annots in\n Fields.make_creator obj\n ~network:!.Zkapp_precondition.Protocol_state.deriver\n ~account:!.Account_precondition.deriver\n ~valid_while:!.Zkapp_precondition.Valid_while.deriver\n |> finish \"Preconditions\" ~t_toplevel_annots\n\n let to_input ({ network; account; valid_while } : t) =\n List.reduce_exn ~f:Random_oracle_input.Chunked.append\n [ Zkapp_precondition.Protocol_state.to_input network\n ; Zkapp_precondition.Account.to_input\n (Account_precondition.to_full account)\n ; Zkapp_precondition.Valid_while.to_input valid_while\n ]\n\n let gen =\n let open Quickcheck.Generator.Let_syntax in\n let%map network = Zkapp_precondition.Protocol_state.gen\n and account = Account_precondition.gen\n and valid_while = Zkapp_precondition.Valid_while.gen in\n { network; account; valid_while }\n\n module Checked = struct\n module Type_of_var (V : sig\n type var\n end) =\n struct\n type t = V.var\n end\n\n module Int_as_prover_ref = struct\n type t = int As_prover.Ref.t\n end\n\n type t =\n { network : Zkapp_precondition.Protocol_state.Checked.t\n ; account : Account_precondition.Checked.t\n ; valid_while : Zkapp_precondition.Valid_while.Checked.t\n }\n [@@deriving annot, hlist, fields]\n\n let to_input ({ network; account; valid_while } : t) =\n List.reduce_exn ~f:Random_oracle_input.Chunked.append\n [ Zkapp_precondition.Protocol_state.Checked.to_input network\n ; Zkapp_precondition.Account.Checked.to_input account\n ; Zkapp_precondition.Valid_while.Checked.to_input valid_while\n ]\n end\n\n let typ () : (Checked.t, t) Typ.t =\n Typ.of_hlistable\n [ Zkapp_precondition.Protocol_state.typ\n ; Account_precondition.typ ()\n ; Zkapp_precondition.Valid_while.typ\n ]\n ~var_to_hlist:Checked.to_hlist ~var_of_hlist:Checked.of_hlist\n ~value_to_hlist:to_hlist ~value_of_hlist:of_hlist\n\n let accept =\n { network = Zkapp_precondition.Protocol_state.accept\n ; account = Account_precondition.Accept\n ; valid_while = Ignore\n }\nend\n\nmodule Body = struct\n (* Why isn't this derived automatically? *)\n let hash_fold_array f init x = Array.fold ~init ~f x\n\n module Events' = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Pickles.Backend.Tick.Field.Stable.V1.t array list\n [@@deriving sexp, equal, hash, compare, yojson]\n\n let to_latest = Fn.id\n end\n end]\n end\n\n module Graphql_repr = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t =\n { public_key : Public_key.Compressed.Stable.V1.t\n ; token_id : Token_id.Stable.V2.t\n ; update : Update.Stable.V1.t\n ; balance_change :\n (Amount.Stable.V1.t, Sgn.Stable.V1.t) Signed_poly.Stable.V1.t\n ; increment_nonce : bool\n ; events : Events'.Stable.V1.t\n ; actions : Events'.Stable.V1.t\n ; call_data : Pickles.Backend.Tick.Field.Stable.V1.t\n ; call_depth : int\n ; preconditions : Preconditions.Stable.V1.t\n ; use_full_commitment : bool\n ; implicit_account_creation_fee : bool\n ; may_use_token : May_use_token.Stable.V1.t\n ; authorization_kind : Authorization_kind.Stable.V1.t\n }\n [@@deriving annot, sexp, equal, yojson, hash, compare, fields]\n\n let to_latest = Fn.id\n end\n end]\n\n let deriver obj =\n let open Fields_derivers_zkapps in\n let ( !. ) = ( !. ) ~t_fields_annots in\n Fields.make_creator obj ~public_key:!.public_key ~update:!.Update.deriver\n ~token_id:!.Token_id.deriver ~balance_change:!.balance_change\n ~increment_nonce:!.bool ~events:!.Events.deriver\n ~actions:!.Actions.deriver ~call_data:!.field\n ~preconditions:!.Preconditions.deriver ~use_full_commitment:!.bool\n ~implicit_account_creation_fee:!.bool\n ~may_use_token:!.May_use_token.deriver ~call_depth:!.int\n ~authorization_kind:!.Authorization_kind.deriver\n |> finish \"AccountUpdateBody\" ~t_toplevel_annots\n\n let dummy : t =\n { public_key = Public_key.Compressed.empty\n ; update = Update.dummy\n ; token_id = Token_id.default\n ; balance_change = Amount.Signed.zero\n ; increment_nonce = false\n ; events = []\n ; actions = []\n ; call_data = Field.zero\n ; call_depth = 0\n ; preconditions = Preconditions.accept\n ; use_full_commitment = false\n ; implicit_account_creation_fee = false\n ; may_use_token = No\n ; authorization_kind = None_given\n }\n end\n\n module Simple = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t =\n { public_key : Public_key.Compressed.Stable.V1.t\n ; token_id : Token_id.Stable.V2.t\n ; update : Update.Stable.V1.t\n ; balance_change :\n (Amount.Stable.V1.t, Sgn.Stable.V1.t) Signed_poly.Stable.V1.t\n ; increment_nonce : bool\n ; events : Events'.Stable.V1.t\n ; actions : Events'.Stable.V1.t\n ; call_data : Pickles.Backend.Tick.Field.Stable.V1.t\n ; call_depth : int\n ; preconditions : Preconditions.Stable.V1.t\n ; use_full_commitment : bool\n ; implicit_account_creation_fee : bool\n ; may_use_token : May_use_token.Stable.V1.t\n ; authorization_kind : Authorization_kind.Stable.V1.t\n }\n [@@deriving annot, sexp, equal, yojson, hash, compare, fields]\n\n let to_latest = Fn.id\n end\n end]\n end\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Mina_wire_types.Mina_base.Account_update.Body.V1.t =\n { public_key : Public_key.Compressed.Stable.V1.t\n ; token_id : Token_id.Stable.V2.t\n ; update : Update.Stable.V1.t\n ; balance_change :\n (Amount.Stable.V1.t, Sgn.Stable.V1.t) Signed_poly.Stable.V1.t\n ; increment_nonce : bool\n ; events : Events'.Stable.V1.t\n ; actions : Events'.Stable.V1.t\n ; call_data : Pickles.Backend.Tick.Field.Stable.V1.t\n ; preconditions : Preconditions.Stable.V1.t\n ; use_full_commitment : bool\n ; implicit_account_creation_fee : bool\n ; may_use_token : May_use_token.Stable.V1.t\n ; authorization_kind : Authorization_kind.Stable.V1.t\n }\n [@@deriving annot, sexp, equal, yojson, hash, hlist, compare, fields]\n\n let to_latest = Fn.id\n end\n end]\n\n let of_simple (p : Simple.t) : t =\n { public_key = p.public_key\n ; token_id = p.token_id\n ; update = p.update\n ; balance_change = p.balance_change\n ; increment_nonce = p.increment_nonce\n ; events = p.events\n ; actions = p.actions\n ; call_data = p.call_data\n ; preconditions = p.preconditions\n ; use_full_commitment = p.use_full_commitment\n ; implicit_account_creation_fee = p.implicit_account_creation_fee\n ; may_use_token = p.may_use_token\n ; authorization_kind = p.authorization_kind\n }\n\n let of_graphql_repr\n ({ public_key\n ; token_id\n ; update\n ; balance_change\n ; increment_nonce\n ; events\n ; actions\n ; call_data\n ; preconditions\n ; use_full_commitment\n ; implicit_account_creation_fee\n ; may_use_token\n ; call_depth = _\n ; authorization_kind\n } :\n Graphql_repr.t ) : t =\n { public_key\n ; token_id\n ; update\n ; balance_change\n ; increment_nonce\n ; events\n ; actions\n ; call_data\n ; preconditions\n ; use_full_commitment\n ; implicit_account_creation_fee\n ; may_use_token\n ; authorization_kind\n }\n\n let to_graphql_repr\n ({ public_key\n ; token_id\n ; update\n ; balance_change\n ; increment_nonce\n ; events\n ; actions\n ; call_data\n ; preconditions\n ; use_full_commitment\n ; implicit_account_creation_fee\n ; may_use_token\n ; authorization_kind\n } :\n t ) ~call_depth : Graphql_repr.t =\n { Graphql_repr.public_key\n ; token_id\n ; update\n ; balance_change\n ; increment_nonce\n ; events\n ; actions\n ; call_data\n ; preconditions\n ; use_full_commitment\n ; implicit_account_creation_fee\n ; may_use_token\n ; call_depth\n ; authorization_kind\n }\n\n module Fee_payer = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Mina_wire_types.Mina_base.Account_update.Body.Fee_payer.V1.t =\n { public_key : Public_key.Compressed.Stable.V1.t\n ; fee : Fee.Stable.V1.t\n ; valid_until : Global_slot_since_genesis.Stable.V1.t option\n [@name \"validUntil\"]\n ; nonce : Account_nonce.Stable.V1.t\n }\n [@@deriving annot, sexp, equal, yojson, hash, compare, hlist, fields]\n\n let to_latest = Fn.id\n end\n end]\n\n let gen : t Quickcheck.Generator.t =\n let open Quickcheck.Generator.Let_syntax in\n let%map public_key = Public_key.Compressed.gen\n and fee = Currency.Fee.gen\n and valid_until =\n Option.quickcheck_generator Global_slot_since_genesis.gen\n and nonce = Account.Nonce.gen in\n { public_key; fee; valid_until; nonce }\n\n let dummy : t =\n { public_key = Public_key.Compressed.empty\n ; fee = Fee.zero\n ; valid_until = None\n ; nonce = Account_nonce.zero\n }\n\n let deriver obj =\n let open Fields_derivers_zkapps in\n let fee obj =\n iso_string obj ~name:\"Fee\" ~js_type:UInt64 ~to_string:Fee.to_string\n ~of_string:Fee.of_string\n in\n let ( !. ) ?skip_data = ( !. ) ?skip_data ~t_fields_annots in\n Fields.make_creator obj ~public_key:!.public_key ~fee:!.fee\n ~valid_until:\n !.Fields_derivers_zkapps.Derivers.(\n option ~js_type:Or_undefined @@ global_slot_since_genesis @@ o ())\n ~nonce:!.uint32\n |> finish \"FeePayerBody\" ~t_toplevel_annots\n end\n\n let of_fee_payer (t : Fee_payer.t) : t =\n { public_key = t.public_key\n ; token_id = Token_id.default\n ; update = Update.noop\n ; balance_change =\n { Signed_poly.sgn = Sgn.Neg; magnitude = Amount.of_fee t.fee }\n ; increment_nonce = true\n ; events = []\n ; actions = []\n ; call_data = Field.zero\n ; preconditions =\n { Preconditions.network =\n (let valid_until =\n Option.value ~default:Global_slot_since_genesis.max_value\n t.valid_until\n in\n { Zkapp_precondition.Protocol_state.accept with\n global_slot_since_genesis =\n Check\n { lower = Global_slot_since_genesis.zero\n ; upper = valid_until\n }\n } )\n ; account = Account_precondition.Nonce t.nonce\n ; valid_while = Ignore\n }\n ; use_full_commitment = true\n ; implicit_account_creation_fee = true\n ; may_use_token = No\n ; authorization_kind = Signature\n }\n\n let to_simple_fee_payer (t : Fee_payer.t) : Simple.t =\n { public_key = t.public_key\n ; token_id = Token_id.default\n ; update = Update.noop\n ; balance_change =\n { Signed_poly.sgn = Sgn.Neg; magnitude = Amount.of_fee t.fee }\n ; increment_nonce = true\n ; events = []\n ; actions = []\n ; call_data = Field.zero\n ; preconditions =\n { Preconditions.network =\n (let valid_until =\n Option.value ~default:Global_slot_since_genesis.max_value\n t.valid_until\n in\n { Zkapp_precondition.Protocol_state.accept with\n global_slot_since_genesis =\n Check\n { lower = Global_slot_since_genesis.zero\n ; upper = valid_until\n }\n } )\n ; account = Account_precondition.Nonce t.nonce\n ; valid_while = Ignore\n }\n ; use_full_commitment = true\n ; implicit_account_creation_fee = true\n ; may_use_token = No\n ; call_depth = 0\n ; authorization_kind = Signature\n }\n\n let to_fee_payer_exn (t : t) : Fee_payer.t =\n let { public_key\n ; token_id = _\n ; update = _\n ; balance_change\n ; increment_nonce = _\n ; events = _\n ; actions = _\n ; call_data = _\n ; preconditions\n ; use_full_commitment = _\n ; may_use_token = _\n ; authorization_kind = _\n } =\n t\n in\n let fee =\n Currency.Fee.of_uint64\n (balance_change.magnitude |> Currency.Amount.to_uint64)\n in\n let nonce =\n match preconditions.account with\n | Nonce nonce ->\n Mina_numbers.Account_nonce.of_uint32 nonce\n | Full _ | Accept ->\n failwith \"Expected a nonce for fee payer account precondition\"\n in\n let valid_until =\n match preconditions.network.global_slot_since_genesis with\n | Ignore ->\n None\n | Check { upper; _ } ->\n Some upper\n in\n { public_key; fee; valid_until; nonce }\n\n module Checked = struct\n module Type_of_var (V : sig\n type var\n end) =\n struct\n type t = V.var\n end\n\n module Int_as_prover_ref = struct\n type t = int As_prover.Ref.t\n end\n\n type t =\n { public_key : Public_key.Compressed.var\n ; token_id : Token_id.Checked.t\n ; update : Update.Checked.t\n ; balance_change : Amount.Signed.var\n ; increment_nonce : Boolean.var\n ; events : Events.var\n ; actions : Actions.var\n ; call_data : Field.Var.t\n ; preconditions : Preconditions.Checked.t\n ; use_full_commitment : Boolean.var\n ; implicit_account_creation_fee : Boolean.var\n ; may_use_token : May_use_token.Checked.t\n ; authorization_kind : Authorization_kind.Checked.t\n }\n [@@deriving annot, hlist, fields]\n\n let to_input\n ({ public_key\n ; token_id\n ; update\n ; balance_change\n ; increment_nonce\n ; events\n ; actions\n ; call_data\n ; preconditions\n ; use_full_commitment\n ; implicit_account_creation_fee\n ; may_use_token\n ; authorization_kind\n } :\n t ) =\n List.reduce_exn ~f:Random_oracle_input.Chunked.append\n [ Public_key.Compressed.Checked.to_input public_key\n ; Token_id.Checked.to_input token_id\n ; Update.Checked.to_input update\n ; Snark_params.Tick.Run.run_checked\n (Amount.Signed.Checked.to_input balance_change)\n ; Random_oracle_input.Chunked.packed\n ((increment_nonce :> Field.Var.t), 1)\n ; Events.var_to_input events\n ; Actions.var_to_input actions\n ; Random_oracle_input.Chunked.field call_data\n ; Preconditions.Checked.to_input preconditions\n ; Random_oracle_input.Chunked.packed\n ((use_full_commitment :> Field.Var.t), 1)\n ; Random_oracle_input.Chunked.packed\n ((implicit_account_creation_fee :> Field.Var.t), 1)\n ; May_use_token.Checked.to_input may_use_token\n ; Authorization_kind.Checked.to_input authorization_kind\n ]\n\n let digest (t : t) =\n Random_oracle.Checked.(\n hash ~init:Hash_prefix.zkapp_body (pack_input (to_input t)))\n end\n\n let typ () : (Checked.t, t) Typ.t =\n Typ.of_hlistable\n [ Public_key.Compressed.typ\n ; Token_id.typ\n ; Update.typ ()\n ; Amount.Signed.typ\n ; Boolean.typ\n ; Events.typ\n ; Actions.typ\n ; Field.typ\n ; Preconditions.typ ()\n ; Impl.Boolean.typ\n ; Impl.Boolean.typ\n ; May_use_token.typ\n ; Authorization_kind.typ\n ]\n ~var_to_hlist:Checked.to_hlist ~var_of_hlist:Checked.of_hlist\n ~value_to_hlist:to_hlist ~value_of_hlist:of_hlist\n\n let dummy : t =\n { public_key = Public_key.Compressed.empty\n ; update = Update.dummy\n ; token_id = Token_id.default\n ; balance_change = Amount.Signed.zero\n ; increment_nonce = false\n ; events = []\n ; actions = []\n ; call_data = Field.zero\n ; preconditions = Preconditions.accept\n ; use_full_commitment = false\n ; implicit_account_creation_fee = true\n ; may_use_token = No\n ; authorization_kind = None_given\n }\n\n let to_input\n ({ public_key\n ; update\n ; token_id\n ; balance_change\n ; increment_nonce\n ; events\n ; actions\n ; call_data\n ; preconditions\n ; use_full_commitment\n ; implicit_account_creation_fee\n ; may_use_token\n ; authorization_kind\n } :\n t ) =\n List.reduce_exn ~f:Random_oracle_input.Chunked.append\n [ Public_key.Compressed.to_input public_key\n ; Token_id.to_input token_id\n ; Update.to_input update\n ; Amount.Signed.to_input balance_change\n ; Random_oracle_input.Chunked.packed (field_of_bool increment_nonce, 1)\n ; Events.to_input events\n ; Actions.to_input actions\n ; Random_oracle_input.Chunked.field call_data\n ; Preconditions.to_input preconditions\n ; Random_oracle_input.Chunked.packed (field_of_bool use_full_commitment, 1)\n ; Random_oracle_input.Chunked.packed\n (field_of_bool implicit_account_creation_fee, 1)\n ; May_use_token.to_input may_use_token\n ; Authorization_kind.to_input authorization_kind\n ]\n\n let digest (t : t) =\n Random_oracle.(hash ~init:Hash_prefix.zkapp_body (pack_input (to_input t)))\n\n module Digested = struct\n type t = Random_oracle.Digest.t\n\n module Checked = struct\n type t = Random_oracle.Checked.Digest.t\n end\n end\n\n let gen =\n let open Quickcheck.Generator.Let_syntax in\n let%map public_key = Public_key.Compressed.gen\n and token_id = Token_id.gen\n and update = Update.gen ()\n and balance_change = Currency.Amount.Signed.gen\n and increment_nonce = Quickcheck.Generator.bool\n and events = return []\n and actions = return []\n and call_data = Field.gen\n and preconditions = Preconditions.gen\n and use_full_commitment = Quickcheck.Generator.bool\n and implicit_account_creation_fee = Quickcheck.Generator.bool\n and may_use_token = May_use_token.gen\n and authorization_kind = Authorization_kind.gen in\n { public_key\n ; token_id\n ; update\n ; balance_change\n ; increment_nonce\n ; events\n ; actions\n ; call_data\n ; preconditions\n ; use_full_commitment\n ; implicit_account_creation_fee\n ; may_use_token\n ; authorization_kind\n }\n\n let gen_with_events_and_actions =\n let open Quickcheck.Generator.Let_syntax in\n let%map public_key = Public_key.Compressed.gen\n and token_id = Token_id.gen\n and update = Update.gen ()\n and balance_change = Currency.Amount.Signed.gen\n and increment_nonce = Quickcheck.Generator.bool\n and events = return [ [| Field.zero |]; [| Field.zero |] ]\n and actions = return [ [| Field.zero |]; [| Field.zero |] ]\n and call_data = Field.gen\n and preconditions = Preconditions.gen\n and use_full_commitment = Quickcheck.Generator.bool\n and implicit_account_creation_fee = Quickcheck.Generator.bool\n and may_use_token = May_use_token.gen\n and authorization_kind = Authorization_kind.gen in\n { public_key\n ; token_id\n ; update\n ; balance_change\n ; increment_nonce\n ; events\n ; actions\n ; call_data\n ; preconditions\n ; use_full_commitment\n ; implicit_account_creation_fee\n ; may_use_token\n ; authorization_kind\n }\nend\n\nmodule T = struct\n module Graphql_repr = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n (** An account update in a zkApp transaction *)\n type t =\n { body : Body.Graphql_repr.Stable.V1.t\n ; authorization : Control.Stable.V2.t\n }\n [@@deriving annot, sexp, equal, yojson, hash, compare, fields]\n\n let to_latest = Fn.id\n end\n end]\n\n let deriver obj =\n let open Fields_derivers_zkapps.Derivers in\n let ( !. ) = ( !. ) ~t_fields_annots in\n Fields.make_creator obj\n ~body:!.Body.Graphql_repr.deriver\n ~authorization:!.Control.deriver\n |> finish \"ZkappAccountUpdate\" ~t_toplevel_annots\n end\n\n module Simple = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t =\n { body : Body.Simple.Stable.V1.t\n ; authorization : Control.Stable.V2.t\n }\n [@@deriving annot, sexp, equal, yojson, hash, compare, fields]\n\n let to_latest = Fn.id\n end\n end]\n end\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n (** A account_update to a zkApp transaction *)\n type t = Mina_wire_types.Mina_base.Account_update.V1.t =\n { body : Body.Stable.V1.t; authorization : Control.Stable.V2.t }\n [@@deriving annot, sexp, equal, yojson, hash, compare, fields]\n\n let to_latest = Fn.id\n end\n end]\n\n let of_graphql_repr ({ body; authorization } : Graphql_repr.t) : t =\n { authorization; body = Body.of_graphql_repr body }\n\n let to_graphql_repr ({ body; authorization } : t) ~call_depth : Graphql_repr.t\n =\n { authorization; body = Body.to_graphql_repr ~call_depth body }\n\n let gen : t Quickcheck.Generator.t =\n let open Quickcheck.Generator.Let_syntax in\n let%map body = Body.gen and authorization = Control.gen_with_dummies in\n { body; authorization }\n\n let gen_with_events_and_actions : t Quickcheck.Generator.t =\n let open Quickcheck.Generator.Let_syntax in\n let%map body = Body.gen_with_events_and_actions\n and authorization = Control.gen_with_dummies in\n { body; authorization }\n\n let quickcheck_generator : t Quickcheck.Generator.t = gen\n\n let quickcheck_observer : t Quickcheck.Observer.t =\n Quickcheck.Observer.of_hash (module Stable.Latest)\n\n let quickcheck_shrinker : t Quickcheck.Shrinker.t =\n Quickcheck.Shrinker.empty ()\n\n let of_simple (p : Simple.t) : t =\n { body = Body.of_simple p.body; authorization = p.authorization }\n\n let digest (t : t) = Body.digest t.body\n\n module Checked = struct\n type t = Body.Checked.t\n\n let digest (t : t) = Body.Checked.digest t\n end\nend\n\nmodule Fee_payer = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Mina_wire_types.Mina_base.Account_update.Fee_payer.V1.t =\n { body : Body.Fee_payer.Stable.V1.t\n ; authorization : Signature.Stable.V1.t\n }\n [@@deriving annot, sexp, equal, yojson, hash, compare, fields]\n\n let to_latest = Fn.id\n end\n end]\n\n let gen : t Quickcheck.Generator.t =\n let open Quickcheck.Let_syntax in\n let%map body = Body.Fee_payer.gen in\n let authorization = Signature.dummy in\n { body; authorization }\n\n let quickcheck_generator : t Quickcheck.Generator.t = gen\n\n let quickcheck_observer : t Quickcheck.Observer.t =\n Quickcheck.Observer.of_hash (module Stable.Latest)\n\n let quickcheck_shrinker : t Quickcheck.Shrinker.t =\n Quickcheck.Shrinker.empty ()\n\n let account_id (t : t) : Account_id.t =\n Account_id.create t.body.public_key Token_id.default\n\n let to_account_update (t : t) : T.t =\n { authorization = Control.Signature t.authorization\n ; body = Body.of_fee_payer t.body\n }\n\n let deriver obj =\n let open Fields_derivers_zkapps.Derivers in\n let ( !. ) = ( !. ) ~t_fields_annots in\n Fields.make_creator obj ~body:!.Body.Fee_payer.deriver\n ~authorization:!.Control.signature_deriver\n |> finish \"ZkappFeePayer\" ~t_toplevel_annots\nend\n\ninclude T\n\nlet account_id (t : t) : Account_id.t =\n Account_id.create t.body.public_key t.body.token_id\n\nlet verification_key_update_to_option (t : t) :\n Verification_key_wire.t option Zkapp_basic.Set_or_keep.t =\n Zkapp_basic.Set_or_keep.map ~f:Option.some t.body.update.verification_key\n\nlet of_fee_payer ({ body; authorization } : Fee_payer.t) : t =\n { authorization = Signature authorization; body = Body.of_fee_payer body }\n\n(** The change in balance to apply to the target account of this account_update.\n When this is negative, the amount will be withdrawn from the account and\n made available to later zkapp_command in the same transaction.\n When this is positive, the amount will be deposited into the account from\n the funds made available by previous zkapp_command in the same transaction.\n*)\nlet balance_change (t : t) : Amount.Signed.t = t.body.balance_change\n\nlet protocol_state_precondition (t : t) : Zkapp_precondition.Protocol_state.t =\n t.body.preconditions.network\n\nlet valid_while_precondition (t : t) :\n Mina_numbers.Global_slot_since_genesis.t Zkapp_precondition.Numeric.t =\n t.body.preconditions.valid_while\n\nlet public_key (t : t) : Public_key.Compressed.t = t.body.public_key\n\nlet token_id (t : t) : Token_id.t = t.body.token_id\n\nlet use_full_commitment (t : t) : bool = t.body.use_full_commitment\n\nlet implicit_account_creation_fee (t : t) : bool =\n t.body.implicit_account_creation_fee\n\nlet increment_nonce (t : t) : bool = t.body.increment_nonce\n","open Core_kernel\n\n[%%versioned\nmodule Stable = struct\n module V1 = struct\n type ('a, 'field) t =\n ('a, 'field) Mina_wire_types.Mina_base.With_stack_hash.V1.t =\n { elt : 'a; stack_hash : 'field }\n [@@deriving sexp, compare, equal, hash, yojson, fields, quickcheck]\n end\nend]\n\nlet map t ~f = { t with elt = f t.elt }\n","open Core_kernel\n\n[%%versioned\nmodule Stable = struct\n module V2 = struct\n type 'a t = 'a Mina_wire_types.Mina_base.With_status.V2.t =\n { data : 'a; status : Transaction_status.Stable.V2.t }\n [@@deriving sexp, yojson, equal, compare, fields]\n\n let to_latest data_latest (t : _ t) =\n { data = data_latest t.data; status = t.status }\n end\nend]\n\nlet map ~f { data; status } = { data = f data; status }\n\nlet map_opt ~f { data; status } =\n Option.map (f data) ~f:(fun data -> { data; status })\n\nlet map_result ~f { data; status } =\n Result.map (f data) ~f:(fun data -> { data; status })\n","open Core_kernel\nopen Signature_lib\n\nmodule Call_forest = struct\n let empty = Outside_hash_image.t\n\n module Tree = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type ('account_update, 'account_update_digest, 'digest) t =\n ( 'account_update\n , 'account_update_digest\n , 'digest )\n Mina_wire_types.Mina_base.Zkapp_command.Call_forest.Tree.V1.t =\n { account_update : 'account_update\n ; account_update_digest : 'account_update_digest\n ; calls :\n ( ('account_update, 'account_update_digest, 'digest) t\n , 'digest )\n With_stack_hash.Stable.V1.t\n list\n }\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n let rec fold_forest (ts : (_ t, _) With_stack_hash.t list) ~f ~init =\n List.fold ts ~init ~f:(fun acc { elt; stack_hash = _ } ->\n fold elt ~init:acc ~f )\n\n and fold { account_update; calls; account_update_digest = _ } ~f ~init =\n fold_forest calls ~f ~init:(f init account_update)\n\n let rec fold_forest2_exn (ts1 : (_ t, _) With_stack_hash.t list)\n (ts2 : (_ t, _) With_stack_hash.t list) ~f ~init =\n List.fold2_exn ts1 ts2 ~init\n ~f:(fun\n acc\n { elt = elt1; stack_hash = _ }\n { elt = elt2; stack_hash = _ }\n -> fold2_exn elt1 elt2 ~init:acc ~f )\n\n and fold2_exn\n { account_update = account_update1\n ; calls = calls1\n ; account_update_digest = _\n }\n { account_update = account_update2\n ; calls = calls2\n ; account_update_digest = _\n } ~f ~init =\n fold_forest2_exn calls1 calls2 ~f\n ~init:(f init account_update1 account_update2)\n\n let iter_forest2_exn ts1 ts2 ~f =\n fold_forest2_exn ts1 ts2 ~init:() ~f:(fun () p1 p2 -> f p1 p2)\n\n let iter2_exn ts1 ts2 ~f =\n fold2_exn ts1 ts2 ~init:() ~f:(fun () p1 p2 -> f p1 p2)\n\n let rec mapi_with_trees' ~i (t : _ t) ~f =\n let account_update = f i t.account_update t in\n let l, calls = mapi_forest_with_trees' ~i:(i + 1) t.calls ~f in\n ( l\n , { calls\n ; account_update\n ; account_update_digest = t.account_update_digest\n } )\n\n and mapi_forest_with_trees' ~i x ~f =\n let rec go i acc = function\n | [] ->\n (i, List.rev acc)\n | t :: ts ->\n let l, elt' = mapi_with_trees' ~i ~f (With_stack_hash.elt t) in\n go l (With_stack_hash.map t ~f:(fun _ -> elt') :: acc) ts\n in\n go i [] x\n\n let mapi_with_trees t ~f = mapi_with_trees' ~i:0 t ~f |> snd\n\n let mapi_forest_with_trees t ~f = mapi_forest_with_trees' ~i:0 t ~f |> snd\n\n let mapi' ~i t ~f =\n mapi_with_trees' ~i t ~f:(fun i account_update _ -> f i account_update)\n\n let mapi_forest' ~i t ~f =\n mapi_forest_with_trees' ~i t ~f:(fun i account_update _ ->\n f i account_update )\n\n let rec deferred_mapi_with_trees' ~i (t : _ t) ~f =\n let open Async_kernel.Deferred.Let_syntax in\n let%bind l, calls =\n deferred_mapi_forest_with_trees' ~i:(i + 1) t.calls ~f\n in\n let%map account_update = f i t.account_update t in\n ( l\n , { calls\n ; account_update\n ; account_update_digest = t.account_update_digest\n } )\n\n and deferred_mapi_forest_with_trees' ~i x ~f =\n let open Async_kernel.Deferred.Let_syntax in\n let rec go i acc = function\n | [] ->\n return (i, List.rev acc)\n | t :: ts ->\n let%bind l, elt' =\n deferred_mapi_with_trees' ~i ~f (With_stack_hash.elt t)\n in\n go l (With_stack_hash.map t ~f:(fun _ -> elt') :: acc) ts\n in\n go i [] x\n\n let map_forest ~f t = mapi_forest' ~i:0 ~f:(fun _ x -> f x) t |> snd\n\n let mapi_forest ~f t = mapi_forest' ~i:0 ~f t |> snd\n\n let deferred_map_forest ~f t =\n let open Async_kernel.Deferred in\n deferred_mapi_forest_with_trees' ~i:0 ~f:(fun _ x -> f x) t >>| snd\n\n let deferred_mapi_forest ~f t =\n let open Async_kernel.Deferred in\n deferred_mapi_forest_with_trees' ~i:0 ~f t >>| snd\n\n let hash { account_update = _; calls; account_update_digest } =\n let stack_hash =\n match calls with [] -> empty | e :: _ -> e.stack_hash\n in\n Random_oracle.hash ~init:Hash_prefix_states.account_update_node\n [| account_update_digest; stack_hash |]\n end\n\n type ('a, 'b, 'c) tree = ('a, 'b, 'c) Tree.t\n\n module type Digest_intf = sig\n module Account_update : sig\n include Digest_intf.S\n\n module Checked : sig\n include Digest_intf.S_checked\n\n val create : Account_update.Checked.t -> t\n\n val create_body : Account_update.Body.Checked.t -> t\n end\n\n include Digest_intf.S_aux with type t := t and type checked := Checked.t\n\n val create : Account_update.t -> t\n\n val create_body : Account_update.Body.t -> t\n end\n\n module rec Forest : sig\n include Digest_intf.S\n\n module Checked : sig\n include Digest_intf.S_checked\n\n val empty : t\n\n val cons : Tree.Checked.t -> t -> t\n end\n\n include Digest_intf.S_aux with type t := t and type checked := Checked.t\n\n val empty : t\n\n val cons : Tree.t -> Forest.t -> Forest.t\n end\n\n and Tree : sig\n include Digest_intf.S\n\n module Checked : sig\n include Digest_intf.S_checked\n\n val create :\n account_update:Account_update.Checked.t\n -> calls:Forest.Checked.t\n -> Tree.Checked.t\n end\n\n include Digest_intf.S_aux with type t := t and type checked := Checked.t\n\n val create : (_, Account_update.t, Forest.t) tree -> Tree.t\n end\n end\n\n module Make_digest_sig\n (T : Mina_wire_types.Mina_base.Zkapp_command.Digest_types.S) =\n struct\n module type S =\n Digest_intf\n with type Account_update.Stable.V1.t = T.Account_update.V1.t\n and type Forest.Stable.V1.t = T.Forest.V1.t\n end\n\n module Make_digest_str\n (T : Mina_wire_types.Mina_base.Zkapp_command.Digest_concrete) :\n Make_digest_sig(T).S = struct\n module M = struct\n open Pickles.Impls.Step.Field\n module Checked = Pickles.Impls.Step.Field\n\n let typ = typ\n\n let constant = constant\n end\n\n module Account_update = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Kimchi_backend.Pasta.Basic.Fp.Stable.V1.t\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n include M\n\n module Checked = struct\n include Checked\n\n let create = Account_update.Checked.digest\n\n let create_body = Account_update.Body.Checked.digest\n end\n\n let create : Account_update.t -> t = Account_update.digest\n\n let create_body : Account_update.Body.t -> t = Account_update.Body.digest\n end\n\n module Forest = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Kimchi_backend.Pasta.Basic.Fp.Stable.V1.t\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n include M\n\n module Checked = struct\n include Checked\n\n let empty = constant empty\n\n let cons hash h_tl =\n Random_oracle.Checked.hash\n ~init:Hash_prefix_states.account_update_cons [| hash; h_tl |]\n end\n\n let empty = empty\n\n let cons hash h_tl =\n Random_oracle.hash ~init:Hash_prefix_states.account_update_cons\n [| hash; h_tl |]\n end\n\n module Tree = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Kimchi_backend.Pasta.Basic.Fp.Stable.V1.t\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n include M\n\n module Checked = struct\n include Checked\n\n let create ~(account_update : Account_update.Checked.t)\n ~(calls : Forest.Checked.t) =\n Random_oracle.Checked.hash\n ~init:Hash_prefix_states.account_update_node\n [| (account_update :> t); (calls :> t) |]\n end\n\n let create ({ account_update = _; calls; account_update_digest } : _ tree)\n =\n let stack_hash =\n match calls with [] -> empty | e :: _ -> e.stack_hash\n in\n Random_oracle.hash ~init:Hash_prefix_states.account_update_node\n [| account_update_digest; stack_hash |]\n end\n end\n\n module Digest =\n Mina_wire_types.Mina_base.Zkapp_command.Digest_make\n (Make_digest_sig)\n (Make_digest_str)\n\n let fold = Tree.fold_forest\n\n let iteri t ~(f : int -> 'a -> unit) : unit =\n let (_ : int) = fold t ~init:0 ~f:(fun acc x -> f acc x ; acc + 1) in\n ()\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n type ('account_update, 'account_update_digest, 'digest) t =\n ( ('account_update, 'account_update_digest, 'digest) Tree.Stable.V1.t\n , 'digest )\n With_stack_hash.Stable.V1.t\n list\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n module Shape = struct\n module I = struct\n type t = int\n\n let quickcheck_shrinker = Quickcheck.Shrinker.empty ()\n\n let quickcheck_generator = [%quickcheck.generator: int]\n\n let quickcheck_observer = [%quickcheck.observer: int]\n end\n\n type t = Node of (I.t * t) list [@@deriving quickcheck]\n end\n\n let rec shape (t : _ t) : Shape.t =\n Node (List.mapi t ~f:(fun i { elt; stack_hash = _ } -> (i, shape elt.calls)))\n\n let match_up (type a b) (xs : a list) (ys : (int * b) list) : (a * b) list =\n let rec go i_curr xs ys =\n match (xs, ys) with\n | [], [] ->\n []\n | x :: xs', (i, y) :: ys' ->\n if i_curr = i then (x, y) :: go (i_curr + 1) xs' ys'\n else if i_curr < i then go (i_curr + 1) xs' ys'\n else assert false\n | [], _ :: _ ->\n assert false\n | _ :: _, [] ->\n []\n in\n go 0 xs ys\n\n let rec mask (t : ('p, 'h1, unit) t) (Node shape : Shape.t) :\n ('p, 'h1, unit) t =\n List.map (match_up t shape)\n ~f:(fun ({ With_stack_hash.elt = t_sub; stack_hash = () }, shape_sub) ->\n { With_stack_hash.elt =\n { t_sub with calls = mask t_sub.calls shape_sub }\n ; stack_hash = ()\n } )\n\n let rec of_account_updates_map ~(f : 'p1 -> 'p2)\n ~(account_update_depth : 'p1 -> int) (account_updates : 'p1 list) :\n ('p2, unit, unit) t =\n match account_updates with\n | [] ->\n []\n | p :: ps ->\n let depth = account_update_depth p in\n let children, siblings =\n List.split_while ps ~f:(fun p' -> account_update_depth p' > depth)\n in\n { With_stack_hash.elt =\n { Tree.account_update = f p\n ; account_update_digest = ()\n ; calls = of_account_updates_map ~f ~account_update_depth children\n }\n ; stack_hash = ()\n }\n :: of_account_updates_map ~f ~account_update_depth siblings\n\n let of_account_updates ~account_update_depth account_updates =\n of_account_updates_map ~f:Fn.id ~account_update_depth account_updates\n\n let to_account_updates_map ~f (xs : _ t) =\n let rec collect depth (xs : _ t) acc =\n match xs with\n | [] ->\n acc\n | { elt = { account_update; calls; account_update_digest = _ }\n ; stack_hash = _\n }\n :: xs ->\n f ~depth account_update :: acc\n |> collect (depth + 1) calls\n |> collect depth xs\n in\n List.rev (collect 0 xs [])\n\n let to_account_updates xs =\n to_account_updates_map ~f:(fun ~depth:_ account_update -> account_update) xs\n\n let hd_account_update (xs : _ t) =\n match xs with\n | [] ->\n None\n | { elt = { account_update; calls = _; account_update_digest = _ }\n ; stack_hash = _\n }\n :: _ ->\n Some account_update\n\n let map = Tree.map_forest\n\n let mapi = Tree.mapi_forest\n\n let mapi_with_trees = Tree.mapi_forest_with_trees\n\n let deferred_mapi = Tree.deferred_mapi_forest\n\n let to_zkapp_command_with_hashes_list (xs : _ t) =\n let rec collect (xs : _ t) acc =\n match xs with\n | [] ->\n acc\n | { elt = { account_update; calls; account_update_digest = _ }\n ; stack_hash\n }\n :: xs ->\n (account_update, stack_hash) :: acc |> collect calls |> collect xs\n in\n List.rev (collect xs [])\n\n let hash_cons hash h_tl =\n Random_oracle.hash ~init:Hash_prefix_states.account_update_cons\n [| hash; h_tl |]\n\n let hash = function\n | [] ->\n Digest.Forest.empty\n | x :: _ ->\n With_stack_hash.stack_hash x\n\n let cons_tree tree (forest : _ t) : _ t =\n { elt = tree\n ; stack_hash = Digest.Forest.cons (Digest.Tree.create tree) (hash forest)\n }\n :: forest\n\n let cons_aux (type p) ~(digest_account_update : p -> _) ?(calls = [])\n (account_update : p) (xs : _ t) : _ t =\n let account_update_digest = digest_account_update account_update in\n let tree : _ Tree.t = { account_update; account_update_digest; calls } in\n cons_tree tree xs\n\n let cons ?calls (account_update : Account_update.t) xs =\n cons_aux ~digest_account_update:Digest.Account_update.create ?calls\n account_update xs\n\n let rec accumulate_hashes ~hash_account_update (xs : _ t) =\n let go = accumulate_hashes ~hash_account_update in\n match xs with\n | [] ->\n []\n | { elt = { account_update; calls; account_update_digest = _ }\n ; stack_hash = _\n }\n :: xs ->\n let calls = go calls in\n let xs = go xs in\n let node =\n { Tree.account_update\n ; calls\n ; account_update_digest = hash_account_update account_update\n }\n in\n let node_hash = Digest.Tree.create node in\n { elt = node; stack_hash = Digest.Forest.cons node_hash (hash xs) }\n :: xs\n\n let accumulate_hashes' (type a b) (xs : (Account_update.t, a, b) t) :\n (Account_update.t, Digest.Account_update.t, Digest.Forest.t) t =\n let hash_account_update (p : Account_update.t) =\n Digest.Account_update.create p\n in\n accumulate_hashes ~hash_account_update xs\n\n let accumulate_hashes_predicated xs =\n accumulate_hashes ~hash_account_update:Digest.Account_update.create xs\n\n module With_hashes_and_data = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type 'data t =\n ( Account_update.Stable.V1.t * 'data\n , Digest.Account_update.Stable.V1.t\n , Digest.Forest.Stable.V1.t )\n Stable.V1.t\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n let empty = Digest.Forest.empty\n\n let hash_account_update ((p : Account_update.t), _) =\n Digest.Account_update.create p\n\n let accumulate_hashes xs : _ t = accumulate_hashes ~hash_account_update xs\n\n let of_zkapp_command_simple_list (xs : (Account_update.Simple.t * 'a) list)\n : _ t =\n of_account_updates xs\n ~account_update_depth:(fun ((p : Account_update.Simple.t), _) ->\n p.body.call_depth )\n |> map ~f:(fun (p, x) -> (Account_update.of_simple p, x))\n |> accumulate_hashes\n\n let of_account_updates (xs : (Account_update.Graphql_repr.t * 'a) list) :\n _ t =\n of_account_updates_map\n ~account_update_depth:(fun ((p : Account_update.Graphql_repr.t), _) ->\n p.body.call_depth )\n ~f:(fun (p, x) -> (Account_update.of_graphql_repr p, x))\n xs\n |> accumulate_hashes\n\n let to_account_updates (x : _ t) = to_account_updates x\n\n let to_zkapp_command_with_hashes_list (x : _ t) =\n to_zkapp_command_with_hashes_list x\n\n let account_updates_hash' xs = of_account_updates xs |> hash\n\n let account_updates_hash xs =\n List.map ~f:(fun x -> (x, ())) xs |> account_updates_hash'\n end\n\n module With_hashes = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t =\n ( Account_update.Stable.V1.t\n , Digest.Account_update.Stable.V1.t\n , Digest.Forest.Stable.V1.t )\n Stable.V1.t\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n let empty = Digest.Forest.empty\n\n let hash_account_update (p : Account_update.t) =\n Digest.Account_update.create p\n\n let accumulate_hashes xs : t = accumulate_hashes ~hash_account_update xs\n\n let of_zkapp_command_simple_list (xs : Account_update.Simple.t list) : t =\n of_account_updates xs\n ~account_update_depth:(fun (p : Account_update.Simple.t) ->\n p.body.call_depth )\n |> map ~f:Account_update.of_simple\n |> accumulate_hashes\n\n let of_account_updates (xs : Account_update.Graphql_repr.t list) : t =\n of_account_updates_map\n ~account_update_depth:(fun (p : Account_update.Graphql_repr.t) ->\n p.body.call_depth )\n ~f:(fun p -> Account_update.of_graphql_repr p)\n xs\n |> accumulate_hashes\n\n let to_account_updates (x : t) = to_account_updates x\n\n let to_zkapp_command_with_hashes_list (x : t) =\n to_zkapp_command_with_hashes_list x\n\n let account_updates_hash' xs = of_account_updates xs |> hash\n\n let account_updates_hash xs =\n List.map ~f:(fun x -> x) xs |> account_updates_hash'\n end\n\n let is_empty : _ t -> bool = List.is_empty\n\n let to_list (type p) (t : (p, _, _) t) : p list =\n List.rev @@ fold t ~init:[] ~f:(fun acc p -> p :: acc)\n\n let exists (type p) (t : (p, _, _) t) ~(f : p -> bool) : bool =\n with_return (fun { return } ->\n fold t ~init:() ~f:(fun () p -> if f p then return true else ()) ;\n false )\nend\n\nmodule Graphql_repr = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t =\n { fee_payer : Account_update.Fee_payer.Stable.V1.t\n ; account_updates : Account_update.Graphql_repr.Stable.V1.t list\n ; memo : Signed_command_memo.Stable.V1.t\n }\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n end\n end]\nend\n\nmodule Simple = struct\n (* For easily constructing values *)\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t =\n { fee_payer : Account_update.Fee_payer.Stable.V1.t\n ; account_updates : Account_update.Simple.Stable.V1.t list\n ; memo : Signed_command_memo.Stable.V1.t\n }\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n end\n end]\nend\n\nmodule Digest = Call_forest.Digest\n\nmodule T = struct\n [%%versioned_binable\n module Stable = struct\n [@@@with_top_version_tag]\n\n (* DO NOT DELETE VERSIONS!\n so we can always get transaction hashes from old transaction ids\n the version linter should be checking this\n\n IF YOU CREATE A NEW VERSION:\n update Transaction_hash.hash_of_transaction_id to handle it\n add hash_zkapp_command_vn for that version\n *)\n\n module V1 = struct\n type t = Mina_wire_types.Mina_base.Zkapp_command.V1.t =\n { fee_payer : Account_update.Fee_payer.Stable.V1.t\n ; account_updates :\n ( Account_update.Stable.V1.t\n , Digest.Account_update.Stable.V1.t\n , Digest.Forest.Stable.V1.t )\n Call_forest.Stable.V1.t\n ; memo : Signed_command_memo.Stable.V1.t\n }\n [@@deriving annot, sexp, compare, equal, hash, yojson, fields]\n\n let to_latest = Fn.id\n\n module Wire = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t =\n { fee_payer : Account_update.Fee_payer.Stable.V1.t\n ; account_updates :\n ( Account_update.Stable.V1.t\n , unit\n , unit )\n Call_forest.Stable.V1.t\n ; memo : Signed_command_memo.Stable.V1.t\n }\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n let check (t : t) : unit =\n List.iter t.account_updates ~f:(fun p ->\n assert (\n Account_update.May_use_token.equal\n p.elt.account_update.body.may_use_token No ) )\n\n let of_graphql_repr (t : Graphql_repr.t) : t =\n { fee_payer = t.fee_payer\n ; memo = t.memo\n ; account_updates =\n Call_forest.of_account_updates_map t.account_updates\n ~f:Account_update.of_graphql_repr\n ~account_update_depth:(fun (p : Account_update.Graphql_repr.t)\n -> p.body.call_depth )\n }\n\n let to_graphql_repr (t : t) : Graphql_repr.t =\n { fee_payer = t.fee_payer\n ; memo = t.memo\n ; account_updates =\n t.account_updates\n |> Call_forest.to_account_updates_map\n ~f:(fun ~depth account_update ->\n Account_update.to_graphql_repr account_update\n ~call_depth:depth )\n }\n\n let gen =\n let open Quickcheck.Generator in\n let open Let_syntax in\n let gen_call_forest =\n fixed_point (fun self ->\n let%bind calls_length = small_non_negative_int in\n list_with_length calls_length\n (let%map account_update = Account_update.gen\n and calls = self in\n { With_stack_hash.stack_hash = ()\n ; elt =\n { Call_forest.Tree.account_update\n ; account_update_digest = ()\n ; calls\n }\n } ) )\n in\n let open Quickcheck.Let_syntax in\n let%map fee_payer = Account_update.Fee_payer.gen\n and account_updates = gen_call_forest\n and memo = Signed_command_memo.gen in\n { fee_payer; account_updates; memo }\n\n let shrinker : t Quickcheck.Shrinker.t =\n Quickcheck.Shrinker.create (fun t ->\n let shape = Call_forest.shape t.account_updates in\n Sequence.map\n (Quickcheck.Shrinker.shrink\n Call_forest.Shape.quickcheck_shrinker shape )\n ~f:(fun shape' ->\n { t with\n account_updates = Call_forest.mask t.account_updates shape'\n } ) )\n end\n\n let of_wire (w : Wire.t) : t =\n { fee_payer = w.fee_payer\n ; memo = w.memo\n ; account_updates =\n w.account_updates\n |> Call_forest.accumulate_hashes\n ~hash_account_update:(fun (p : Account_update.t) ->\n Digest.Account_update.create p )\n }\n\n let to_wire (t : t) : Wire.t =\n let rec forget_hashes = List.map ~f:forget_hash\n and forget_hash = function\n | { With_stack_hash.stack_hash = _\n ; elt =\n { Call_forest.Tree.account_update\n ; account_update_digest = _\n ; calls\n }\n } ->\n { With_stack_hash.stack_hash = ()\n ; elt =\n { Call_forest.Tree.account_update\n ; account_update_digest = ()\n ; calls = forget_hashes calls\n }\n }\n in\n { fee_payer = t.fee_payer\n ; memo = t.memo\n ; account_updates = forget_hashes t.account_updates\n }\n\n include\n Binable.Of_binable_without_uuid\n (Wire.Stable.V1)\n (struct\n type nonrec t = t\n\n let of_binable t = Wire.check t ; of_wire t\n\n let to_binable = to_wire\n end)\n end\n end]\nend\n\ninclude T\n\n[%%define_locally Stable.Latest.(of_wire, to_wire)]\n\n[%%define_locally Stable.Latest.Wire.(gen)]\n\nlet of_simple (w : Simple.t) : t =\n { fee_payer = w.fee_payer\n ; memo = w.memo\n ; account_updates =\n Call_forest.of_account_updates w.account_updates\n ~account_update_depth:(fun (p : Account_update.Simple.t) ->\n p.body.call_depth )\n |> Call_forest.map ~f:Account_update.of_simple\n |> Call_forest.accumulate_hashes\n ~hash_account_update:(fun (p : Account_update.t) ->\n Digest.Account_update.create p )\n }\n\nlet to_simple (t : t) : Simple.t =\n { fee_payer = t.fee_payer\n ; memo = t.memo\n ; account_updates =\n t.account_updates\n |> Call_forest.to_account_updates_map\n ~f:(fun ~depth { Account_update.body = b; authorization } ->\n { Account_update.Simple.authorization\n ; body =\n { public_key = b.public_key\n ; token_id = b.token_id\n ; update = b.update\n ; balance_change = b.balance_change\n ; increment_nonce = b.increment_nonce\n ; events = b.events\n ; actions = b.actions\n ; call_data = b.call_data\n ; preconditions = b.preconditions\n ; use_full_commitment = b.use_full_commitment\n ; implicit_account_creation_fee =\n b.implicit_account_creation_fee\n ; may_use_token = b.may_use_token\n ; call_depth = depth\n ; authorization_kind = b.authorization_kind\n }\n } )\n }\n\nlet all_account_updates (t : t) : _ Call_forest.t =\n let p = t.fee_payer in\n let body = Account_update.Body.of_fee_payer p.body in\n let fee_payer : Account_update.t =\n let p = t.fee_payer in\n { authorization = Control.Signature p.authorization; body }\n in\n Call_forest.cons fee_payer t.account_updates\n\nlet fee (t : t) : Currency.Fee.t = t.fee_payer.body.fee\n\nlet fee_payer_account_update ({ fee_payer; _ } : t) = fee_payer\n\nlet applicable_at_nonce (t : t) : Account.Nonce.t =\n (fee_payer_account_update t).body.nonce\n\nlet target_nonce_on_success (t : t) : Account.Nonce.t =\n let base_nonce = Account.Nonce.succ (applicable_at_nonce t) in\n let fee_payer_pubkey = t.fee_payer.body.public_key in\n let fee_payer_account_update_increments =\n List.count (Call_forest.to_list t.account_updates) ~f:(fun p ->\n Public_key.Compressed.equal p.body.public_key fee_payer_pubkey\n && p.body.increment_nonce )\n in\n Account.Nonce.add base_nonce\n (Account.Nonce.of_int fee_payer_account_update_increments)\n\nlet nonce_increments (t : t) : int Public_key.Compressed.Map.t =\n let base_increments =\n Public_key.Compressed.Map.of_alist_exn [ (t.fee_payer.body.public_key, 1) ]\n in\n List.fold_left (Call_forest.to_list t.account_updates) ~init:base_increments\n ~f:(fun incr_map account_update ->\n if account_update.body.increment_nonce then\n Map.update incr_map account_update.body.public_key\n ~f:(Option.value_map ~default:1 ~f:(( + ) 1))\n else incr_map )\n\nlet fee_token (_t : t) = Token_id.default\n\nlet fee_payer (t : t) =\n Account_id.create t.fee_payer.body.public_key (fee_token t)\n\nlet extract_vks (t : t) : Verification_key_wire.t List.t =\n account_updates t\n |> Call_forest.fold ~init:[] ~f:(fun acc (p : Account_update.t) ->\n match Account_update.verification_key_update_to_option p with\n | Zkapp_basic.Set_or_keep.Set (Some vk) ->\n vk :: acc\n | _ ->\n acc )\n\nlet account_updates_list (t : t) : Account_update.t list =\n Call_forest.fold t.account_updates ~init:[] ~f:(Fn.flip List.cons) |> List.rev\n\nlet all_account_updates_list (t : t) : Account_update.t list =\n Call_forest.fold t.account_updates\n ~init:[ Account_update.of_fee_payer (fee_payer_account_update t) ]\n ~f:(Fn.flip List.cons)\n |> List.rev\n\nlet fee_excess (t : t) =\n Fee_excess.of_single (fee_token t, Currency.Fee.Signed.of_unsigned (fee t))\n\n(* always `Accessed` for fee payer *)\nlet account_access_statuses (t : t) (status : Transaction_status.t) =\n let init = [ (fee_payer t, `Accessed) ] in\n let status_sym =\n match status with Applied -> `Accessed | Failed _ -> `Not_accessed\n in\n Call_forest.fold t.account_updates ~init ~f:(fun acc p ->\n (Account_update.account_id p, status_sym) :: acc )\n |> List.rev |> List.stable_dedup\n\nlet accounts_referenced (t : t) =\n List.map (account_access_statuses t Applied) ~f:(fun (acct_id, _status) ->\n acct_id )\n\nlet fee_payer_pk (t : t) = t.fee_payer.body.public_key\n\nlet value_if b ~then_ ~else_ = if b then then_ else else_\n\nmodule Virtual = struct\n module Bool = struct\n type t = bool\n\n let true_ = true\n\n let assert_ _ = ()\n\n let equal = Bool.equal\n\n let not = not\n\n let ( || ) = ( || )\n\n let ( && ) = ( && )\n end\n\n module Unit = struct\n type t = unit\n\n let if_ = value_if\n end\n\n module Ledger = Unit\n module Account = Unit\n\n module Amount = struct\n open Currency.Amount\n\n type nonrec t = t\n\n let if_ = value_if\n\n module Signed = Signed\n\n let zero = zero\n\n let ( - ) (x1 : t) (x2 : t) : Signed.t =\n Option.value_exn Signed.(of_unsigned x1 + negate (of_unsigned x2))\n\n let ( + ) (x1 : t) (x2 : t) : t = Option.value_exn (add x1 x2)\n\n let add_signed (x1 : t) (x2 : Signed.t) : t =\n let y = Option.value_exn Signed.(of_unsigned x1 + x2) in\n match y.sgn with Pos -> y.magnitude | Neg -> failwith \"add_signed\"\n end\n\n module Token_id = struct\n include Token_id\n\n let if_ = value_if\n end\n\n module Zkapp_command = struct\n type t = Account_update.t list\n\n let if_ = value_if\n\n type account_update = Account_update.t\n\n let empty = []\n\n let is_empty = List.is_empty\n\n let pop (t : t) = match t with [] -> failwith \"pop\" | p :: t -> (p, t)\n end\nend\n\nlet check_authorization (p : Account_update.t) : unit Or_error.t =\n match (p.authorization, p.body.authorization_kind) with\n | None_given, None_given | Proof _, Proof _ | Signature _, Signature ->\n Ok ()\n | _ ->\n let err =\n let expected =\n Account_update.Authorization_kind.to_control_tag\n p.body.authorization_kind\n in\n let got = Control.tag p.authorization in\n Error.create \"Authorization kind does not match the authorization\"\n [ (\"expected\", expected); (\"got\", got) ]\n [%sexp_of: (string * Control.Tag.t) list]\n in\n Error err\n\nmodule Verifiable : sig\n [%%versioned:\n module Stable : sig\n module V1 : sig\n type t = private\n { fee_payer : Account_update.Fee_payer.Stable.V1.t\n ; account_updates :\n ( Side_loaded_verification_key.Stable.V2.t\n , Zkapp_basic.F.Stable.V1.t )\n With_hash.Stable.V1.t\n option\n Call_forest.With_hashes_and_data.Stable.V1.t\n ; memo : Signed_command_memo.Stable.V1.t\n }\n [@@deriving sexp, compare, equal, hash, yojson]\n\n val to_latest : t -> t\n end\n end]\n\n val find_vk_via_ledger :\n ledger:'a\n -> get:('a -> 'b -> Account.t option)\n -> location_of_account:('a -> Account_id.t -> 'b option)\n -> Zkapp_basic.F.t\n -> Account_id.t\n -> (Verification_key_wire.t, Error.t) Result.t\n\n val create :\n T.t\n -> status:Transaction_status.t\n -> find_vk:\n ( Zkapp_basic.F.t\n -> Account_id.t\n -> (Verification_key_wire.t, Error.t) Result.t )\n -> t Or_error.t\n\n module Any : sig\n (** creates verifiables from a list of commands that caches verification\n keys and permits _any_ vks that have been seen earlier in the list. *)\n val create_all :\n T.t With_status.t list\n -> find_vk:\n ( Zkapp_basic.F.t\n -> Account_id.t\n -> (Verification_key_wire.t, Error.t) Result.t )\n -> t With_status.t list Or_error.t\n end\n\n module Last : sig\n (** creates verifiables from a list of commands that caches verification\n keys and permits only the _last_ vk that has been seen earlier in the\n list. *)\n val create_all :\n T.t With_status.t list\n -> find_vk:\n ( Zkapp_basic.F.t\n -> Account_id.t\n -> (Verification_key_wire.t, Error.t) Result.t )\n -> t With_status.t list Or_error.t\n end\nend = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t =\n { fee_payer : Account_update.Fee_payer.Stable.V1.t\n ; account_updates :\n ( Side_loaded_verification_key.Stable.V2.t\n , Zkapp_basic.F.Stable.V1.t )\n With_hash.Stable.V1.t\n option\n Call_forest.With_hashes_and_data.Stable.V1.t\n ; memo : Signed_command_memo.Stable.V1.t\n }\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n let ok_if_vk_hash_expected ~got ~expected =\n if not @@ Zkapp_basic.F.equal (With_hash.hash got) expected then\n Error\n (Error.create \"Expected vk hash doesn't match hash in vk we received\"\n [ (\"expected_vk_hash\", expected)\n ; (\"got_vk_hash\", With_hash.hash got)\n ]\n [%sexp_of: (string * Zkapp_basic.F.t) list] )\n else Ok got\n\n let find_vk_via_ledger ~ledger ~get ~location_of_account expected_vk_hash\n account_id =\n match\n let open Option.Let_syntax in\n let%bind location = location_of_account ledger account_id in\n let%bind (account : Account.t) = get ledger location in\n let%bind zkapp = account.zkapp in\n zkapp.verification_key\n with\n | Some vk ->\n ok_if_vk_hash_expected ~got:vk ~expected:expected_vk_hash\n | None ->\n let err =\n Error.create \"No verification key found for proved account update\"\n (\"account_id\", account_id) [%sexp_of: string * Account_id.t]\n in\n Error err\n\n (* Ensures that there's a verification_key available for all account_updates\n * and creates a valid command associating the correct keys with each\n * account_id.\n *\n * If an account_update replaces the verification_key (or deletes it),\n * subsequent account_updates use the replaced key instead of looking in the\n * ledger for the key (ie set by a previous transaction).\n *)\n let create ({ fee_payer; account_updates; memo } : T.t)\n ~(status : Transaction_status.t) ~find_vk : t Or_error.t =\n With_return.with_return (fun { return } ->\n let tbl = Account_id.Table.create () in\n let vks_overridden =\n (* Keep track of the verification keys that have been set so far\n during this transaction.\n *)\n ref Account_id.Map.empty\n in\n let account_updates =\n Call_forest.map account_updates ~f:(fun p ->\n let account_id = Account_update.account_id p in\n let vks_overriden' =\n match Account_update.verification_key_update_to_option p with\n | Zkapp_basic.Set_or_keep.Set vk_next ->\n Account_id.Map.set !vks_overridden ~key:account_id\n ~data:vk_next\n | Zkapp_basic.Set_or_keep.Keep ->\n !vks_overridden\n in\n let () =\n match check_authorization p with\n | Ok () ->\n ()\n | Error _ as err ->\n return err\n in\n match\n ( p.body.authorization_kind\n , phys_equal status Transaction_status.Applied )\n with\n | Proof vk_hash, true -> (\n let prioritized_vk =\n (* only lookup _past_ vk setting, ie exclude the new one we\n * potentially set in this account_update (use the non-'\n * vks_overrided) . *)\n match Account_id.Map.find !vks_overridden account_id with\n | Some (Some vk) -> (\n match\n ok_if_vk_hash_expected ~got:vk ~expected:vk_hash\n with\n | Ok vk ->\n Some vk\n | Error err ->\n return (Error err) )\n | Some None ->\n (* we explicitly have erased the key *)\n let err =\n Error.create\n \"No verification key found for proved account \\\n update: the verification key was removed by a \\\n previous account update\"\n (\"account_id\", account_id)\n [%sexp_of: string * Account_id.t]\n in\n return (Error err)\n | None -> (\n (* we haven't set anything; lookup the vk in the fallback *)\n match find_vk vk_hash account_id with\n | Error e ->\n return (Error e)\n | Ok vk ->\n Some vk )\n in\n match prioritized_vk with\n | Some prioritized_vk ->\n Account_id.Table.update tbl account_id ~f:(fun _ ->\n With_hash.hash prioritized_vk ) ;\n (* return the updated overrides *)\n vks_overridden := vks_overriden' ;\n (p, Some prioritized_vk)\n | None ->\n (* The transaction failed, so we allow the vk to be missing. *)\n (p, None) )\n | _ ->\n vks_overridden := vks_overriden' ;\n (p, None) )\n in\n Ok { fee_payer; account_updates; memo } )\n\n module Map_cache = struct\n type 'a t = 'a Zkapp_basic.F_map.Map.t\n\n let empty = Zkapp_basic.F_map.Map.empty\n\n let find = Zkapp_basic.F_map.Map.find\n\n let set = Zkapp_basic.F_map.Map.set\n end\n\n module Singleton_cache = struct\n type 'a t = (Zkapp_basic.F.t * 'a) option\n\n let empty = None\n\n let find t key =\n match t with\n | None ->\n None\n | Some (k, v) ->\n if Zkapp_basic.F.equal key k then Some v else None\n\n let set _ ~key ~data = Some (key, data)\n end\n\n module Make_create_all (Cache : sig\n type 'a t\n\n val empty : 'a t\n\n val find : 'a t -> Zkapp_basic.F.t -> 'a option\n\n val set : 'a t -> key:Zkapp_basic.F.t -> data:'a -> 'a t\n end) =\n struct\n let create_all (cmds : T.t With_status.t list)\n ~(find_vk :\n Zkapp_basic.F.t\n -> Account_id.t\n -> (Verification_key_wire.t, Error.t) Result.t ) :\n t With_status.t list Or_error.t =\n Or_error.try_with (fun () ->\n snd (* remove the helper cache we folded with *)\n (List.fold_map cmds ~init:Cache.empty\n ~f:(fun\n (running_cache : Verification_key_wire.t Cache.t)\n { data = cmd; status }\n ->\n let verified_cmd : t =\n create cmd ~status ~find_vk:(fun vk_hash account_id ->\n (* first we check if there's anything in the running\n cache within this chunk so far *)\n match Cache.find running_cache vk_hash with\n | None ->\n (* before falling back to the find_vk *)\n find_vk vk_hash account_id\n | Some vk ->\n Ok vk )\n |> Or_error.ok_exn\n in\n let running_cache' =\n List.fold (extract_vks cmd) ~init:running_cache\n ~f:(fun acc vk ->\n Cache.set acc ~key:(With_hash.hash vk) ~data:vk )\n in\n (running_cache', { With_status.data = verified_cmd; status }) )\n ) )\n end\n\n module Any = struct\n include Make_create_all (Map_cache)\n end\n\n module Last = struct\n include Make_create_all (Singleton_cache)\n end\nend\n\nlet of_verifiable (t : Verifiable.t) : t =\n { fee_payer = t.fee_payer\n ; account_updates = Call_forest.map t.account_updates ~f:fst\n ; memo = t.memo\n }\n\nmodule Transaction_commitment = struct\n module Stable = Kimchi_backend.Pasta.Basic.Fp.Stable\n\n type t = (Stable.Latest.t[@deriving sexp])\n\n let sexp_of_t = Stable.Latest.sexp_of_t\n\n let t_of_sexp = Stable.Latest.t_of_sexp\n\n let empty = Outside_hash_image.t\n\n let typ = Snark_params.Tick.Field.typ\n\n let create ~(account_updates_hash : Digest.Forest.t) : t =\n (account_updates_hash :> t)\n\n let create_complete (t : t) ~memo_hash\n ~(fee_payer_hash : Digest.Account_update.t) =\n Random_oracle.hash ~init:Hash_prefix.account_update_cons\n [| memo_hash; (fee_payer_hash :> t); t |]\n\n module Checked = struct\n type t = Pickles.Impls.Step.Field.t\n\n let create ~(account_updates_hash : Digest.Forest.Checked.t) =\n (account_updates_hash :> t)\n\n let create_complete (t : t) ~memo_hash\n ~(fee_payer_hash : Digest.Account_update.Checked.t) =\n Random_oracle.Checked.hash ~init:Hash_prefix.account_update_cons\n [| memo_hash; (fee_payer_hash :> t); t |]\n end\nend\n\nlet account_updates_hash (t : t) = Call_forest.hash t.account_updates\n\nlet commitment (t : t) : Transaction_commitment.t =\n Transaction_commitment.create ~account_updates_hash:(account_updates_hash t)\n\n(** This module defines weights for each component of a `Zkapp_command.t` element. *)\nmodule Weight = struct\n let account_update : Account_update.t -> int = fun _ -> 1\n\n let fee_payer (_fp : Account_update.Fee_payer.t) : int = 1\n\n let account_updates : (Account_update.t, _, _) Call_forest.t -> int =\n Call_forest.fold ~init:0 ~f:(fun acc p -> acc + account_update p)\n\n let memo : Signed_command_memo.t -> int = fun _ -> 0\nend\n\nlet weight (zkapp_command : t) : int =\n let { fee_payer; account_updates; memo } = zkapp_command in\n List.sum\n (module Int)\n ~f:Fn.id\n [ Weight.fee_payer fee_payer\n ; Weight.account_updates account_updates\n ; Weight.memo memo\n ]\n\nmodule type Valid_intf = sig\n [%%versioned:\n module Stable : sig\n module V1 : sig\n type t = private { zkapp_command : T.Stable.V1.t }\n [@@deriving sexp, compare, equal, hash, yojson]\n end\n end]\n\n val to_valid_unsafe :\n T.t -> [> `If_this_is_used_it_should_have_a_comment_justifying_it of t ]\n\n val to_valid :\n T.t\n -> status:Transaction_status.t\n -> find_vk:\n ( Zkapp_basic.F.t\n -> Account_id.t\n -> (Verification_key_wire.t, Error.t) Result.t )\n -> t Or_error.t\n\n val of_verifiable : Verifiable.t -> t\n\n val forget : t -> T.t\nend\n\nmodule Valid :\n Valid_intf\n with type Stable.V1.t = Mina_wire_types.Mina_base.Zkapp_command.Valid.V1.t =\nstruct\n module S = Stable\n\n module Verification_key_hash = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Zkapp_basic.F.Stable.V1.t\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n end\n end]\n end\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Mina_wire_types.Mina_base.Zkapp_command.Valid.V1.t =\n { zkapp_command : S.V1.t }\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n let create zkapp_command : t = { zkapp_command }\n\n let of_verifiable (t : Verifiable.t) : t = { zkapp_command = of_verifiable t }\n\n let to_valid_unsafe (t : T.t) :\n [> `If_this_is_used_it_should_have_a_comment_justifying_it of t ] =\n `If_this_is_used_it_should_have_a_comment_justifying_it (create t)\n\n let forget (t : t) : T.t = t.zkapp_command\n\n let to_valid (t : T.t) ~status ~find_vk : t Or_error.t =\n Verifiable.create t ~status ~find_vk |> Or_error.map ~f:of_verifiable\nend\n\n[%%define_locally Stable.Latest.(of_yojson, to_yojson)]\n\n(* so transaction ids have a version tag *)\ninclude Codable.Make_base64 (Stable.Latest.With_top_version_tag)\n\ntype account_updates =\n (Account_update.t, Digest.Account_update.t, Digest.Forest.t) Call_forest.t\n\nlet account_updates_deriver obj =\n let of_zkapp_command_with_depth (ps : Account_update.Graphql_repr.t list) :\n account_updates =\n Call_forest.of_account_updates ps\n ~account_update_depth:(fun (p : Account_update.Graphql_repr.t) ->\n p.body.call_depth )\n |> Call_forest.map ~f:Account_update.of_graphql_repr\n |> Call_forest.accumulate_hashes'\n and to_zkapp_command_with_depth (ps : account_updates) :\n Account_update.Graphql_repr.t list =\n ps\n |> Call_forest.to_account_updates_map ~f:(fun ~depth p ->\n Account_update.to_graphql_repr ~call_depth:depth p )\n in\n let open Fields_derivers_zkapps.Derivers in\n let inner = (list @@ Account_update.Graphql_repr.deriver @@ o ()) @@ o () in\n iso ~map:of_zkapp_command_with_depth ~contramap:to_zkapp_command_with_depth\n inner obj\n\nlet deriver obj =\n let open Fields_derivers_zkapps.Derivers in\n let ( !. ) = ( !. ) ~t_fields_annots in\n Fields.make_creator obj\n ~fee_payer:!.Account_update.Fee_payer.deriver\n ~account_updates:!.account_updates_deriver\n ~memo:!.Signed_command_memo.deriver\n |> finish \"ZkappCommand\" ~t_toplevel_annots\n\nlet arg_typ () = Fields_derivers_zkapps.(arg_typ (deriver @@ Derivers.o ()))\n\nlet typ () = Fields_derivers_zkapps.(typ (deriver @@ Derivers.o ()))\n\nlet to_json x = Fields_derivers_zkapps.(to_json (deriver @@ Derivers.o ())) x\n\nlet of_json x = Fields_derivers_zkapps.(of_json (deriver @@ Derivers.o ())) x\n\nlet account_updates_of_json x =\n Fields_derivers_zkapps.(\n of_json\n ((list @@ Account_update.Graphql_repr.deriver @@ o ()) @@ derivers ()))\n x\n\nlet zkapp_command_to_json x =\n Fields_derivers_zkapps.(to_json (deriver @@ derivers ())) x\n\nlet arg_query_string x =\n Fields_derivers_zkapps.Test.Loop.json_to_string_gql @@ to_json x\n\nlet dummy =\n let account_update : Account_update.t =\n { body = Account_update.Body.dummy\n ; authorization = Control.dummy_of_tag Signature\n }\n in\n let fee_payer : Account_update.Fee_payer.t =\n { body = Account_update.Body.Fee_payer.dummy\n ; authorization = Signature.dummy\n }\n in\n { fee_payer\n ; account_updates = Call_forest.cons account_update []\n ; memo = Signed_command_memo.empty\n }\n\nmodule Make_update_group (Input : sig\n type global_state\n\n type local_state\n\n type spec\n\n type connecting_ledger_hash\n\n val zkapp_segment_of_controls : Control.t list -> spec\nend) : sig\n module Zkapp_command_intermediate_state : sig\n type state = { global : Input.global_state; local : Input.local_state }\n\n type t =\n { kind : [ `Same | `New | `Two_new ]\n ; spec : Input.spec\n ; state_before : state\n ; state_after : state\n ; connecting_ledger : Input.connecting_ledger_hash\n }\n end\n\n val group_by_zkapp_command_rev :\n t list\n -> (Input.global_state * Input.local_state * Input.connecting_ledger_hash)\n list\n list\n -> Zkapp_command_intermediate_state.t list\nend = struct\n open Input\n\n module Zkapp_command_intermediate_state = struct\n type state = { global : global_state; local : local_state }\n\n type t =\n { kind : [ `Same | `New | `Two_new ]\n ; spec : spec\n ; state_before : state\n ; state_after : state\n ; connecting_ledger : connecting_ledger_hash\n }\n end\n\n (** [group_by_zkapp_command_rev zkapp_commands stmtss] identifies before/after pairs of\n statements, corresponding to account updates for each zkapp_command in [zkapp_commands] which minimize the\n number of snark proofs needed to prove all of the zkapp_command.\n\n This function is intended to take multiple zkapp transactions as\n its input, which is then converted to a [Account_update.t list list] using\n [List.map ~f:Zkapp_command.zkapp_command]. The [stmtss] argument should\n be a list of the same length, with 1 more state than the number of\n zkapp_command for each transaction.\n\n For example, two transactions made up of zkapp_command [[p1; p2; p3]] and\n [[p4; p5]] should have the statements [[[s0; s1; s2; s3]; [s3; s4; s5]]],\n where each [s_n] is the state after applying [p_n] on top of [s_{n-1}], and\n where [s0] is the initial state before any of the transactions have been\n applied.\n\n Each pair is also identified with one of [`Same], [`New], or [`Two_new],\n indicating that the next one ([`New]) or next two ([`Two_new]) [Zkapp_command.t]s\n will need to be passed as part of the snark witness while applying that\n pair.\n *)\n let group_by_zkapp_command_rev (zkapp_commands : t list)\n (stmtss : (global_state * local_state * connecting_ledger_hash) list list)\n : Zkapp_command_intermediate_state.t list =\n let intermediate_state ~kind ~spec ~before ~after =\n let global_before, local_before, _ = before in\n let global_after, local_after, connecting_ledger = after in\n { Zkapp_command_intermediate_state.kind\n ; spec\n ; state_before = { global = global_before; local = local_before }\n ; state_after = { global = global_after; local = local_after }\n ; connecting_ledger\n }\n in\n let zkapp_account_updatess =\n []\n :: List.map zkapp_commands ~f:(fun (zkapp_command : t) ->\n all_account_updates_list zkapp_command )\n in\n let rec group_by_zkapp_command_rev\n (zkapp_commands : Account_update.t list list) stmtss acc =\n match (zkapp_commands, stmtss) with\n | ([] | [ [] ]), [ _ ] ->\n (* We've associated statements with all given zkapp_command. *)\n acc\n | [ [ { authorization = a1; _ } ] ], [ [ before; after ] ] ->\n (* There are no later zkapp_command to pair this one with. Prove it on its\n own.\n *)\n intermediate_state ~kind:`Same\n ~spec:(zkapp_segment_of_controls [ a1 ])\n ~before ~after\n :: acc\n | [ []; [ { authorization = a1; _ } ] ], [ [ _ ]; [ before; after ] ] ->\n (* This account_update is part of a new transaction, and there are no later\n zkapp_command to pair it with. Prove it on its own.\n *)\n intermediate_state ~kind:`New\n ~spec:(zkapp_segment_of_controls [ a1 ])\n ~before ~after\n :: acc\n | ( ({ authorization = Proof _ as a1; _ } :: zkapp_command)\n :: zkapp_commands\n , (before :: (after :: _ as stmts)) :: stmtss ) ->\n (* This account_update contains a proof, don't pair it with other account updates. *)\n group_by_zkapp_command_rev\n (zkapp_command :: zkapp_commands)\n (stmts :: stmtss)\n ( intermediate_state ~kind:`Same\n ~spec:(zkapp_segment_of_controls [ a1 ])\n ~before ~after\n :: acc )\n | ( []\n :: ({ authorization = Proof _ as a1; _ } :: zkapp_command)\n :: zkapp_commands\n , [ _ ] :: (before :: (after :: _ as stmts)) :: stmtss ) ->\n (* This account_update is part of a new transaction, and contains a proof, don't\n pair it with other account updates.\n *)\n group_by_zkapp_command_rev\n (zkapp_command :: zkapp_commands)\n (stmts :: stmtss)\n ( intermediate_state ~kind:`New\n ~spec:(zkapp_segment_of_controls [ a1 ])\n ~before ~after\n :: acc )\n | ( ({ authorization = a1; _ }\n :: ({ authorization = Proof _; _ } :: _ as zkapp_command) )\n :: zkapp_commands\n , (before :: (after :: _ as stmts)) :: stmtss ) ->\n (* The next account_update contains a proof, don't pair it with this account_update. *)\n group_by_zkapp_command_rev\n (zkapp_command :: zkapp_commands)\n (stmts :: stmtss)\n ( intermediate_state ~kind:`Same\n ~spec:(zkapp_segment_of_controls [ a1 ])\n ~before ~after\n :: acc )\n | ( ({ authorization = a1; _ } :: ([] as zkapp_command))\n :: (({ authorization = Proof _; _ } :: _) :: _ as zkapp_commands)\n , (before :: (after :: _ as stmts)) :: stmtss ) ->\n (* The next account_update is in the next transaction and contains a proof,\n don't pair it with this account_update.\n *)\n group_by_zkapp_command_rev\n (zkapp_command :: zkapp_commands)\n (stmts :: stmtss)\n ( intermediate_state ~kind:`Same\n ~spec:(zkapp_segment_of_controls [ a1 ])\n ~before ~after\n :: acc )\n | ( ({ authorization = (Signature _ | None_given) as a1; _ }\n :: { authorization = (Signature _ | None_given) as a2; _ }\n :: zkapp_command )\n :: zkapp_commands\n , (before :: _ :: (after :: _ as stmts)) :: stmtss ) ->\n (* The next two zkapp_command do not contain proofs, and are within the same\n transaction. Pair them.\n Ok to get \"use_full_commitment\" of [a1] because neither of them\n contain a proof.\n *)\n group_by_zkapp_command_rev\n (zkapp_command :: zkapp_commands)\n (stmts :: stmtss)\n ( intermediate_state ~kind:`Same\n ~spec:(zkapp_segment_of_controls [ a1; a2 ])\n ~before ~after\n :: acc )\n | ( []\n :: ({ authorization = a1; _ }\n :: ({ authorization = Proof _; _ } :: _ as zkapp_command) )\n :: zkapp_commands\n , [ _ ] :: (before :: (after :: _ as stmts)) :: stmtss ) ->\n (* This account_update is in the next transaction, and the next account_update contains a\n proof, don't pair it with this account_update.\n *)\n group_by_zkapp_command_rev\n (zkapp_command :: zkapp_commands)\n (stmts :: stmtss)\n ( intermediate_state ~kind:`New\n ~spec:(zkapp_segment_of_controls [ a1 ])\n ~before ~after\n :: acc )\n | ( []\n :: ({ authorization = (Signature _ | None_given) as a1; _ }\n :: { authorization = (Signature _ | None_given) as a2; _ }\n :: zkapp_command )\n :: zkapp_commands\n , [ _ ] :: (before :: _ :: (after :: _ as stmts)) :: stmtss ) ->\n (* The next two zkapp_command do not contain proofs, and are within the same\n new transaction. Pair them.\n Ok to get \"use_full_commitment\" of [a1] because neither of them\n contain a proof.\n *)\n group_by_zkapp_command_rev\n (zkapp_command :: zkapp_commands)\n (stmts :: stmtss)\n ( intermediate_state ~kind:`New\n ~spec:(zkapp_segment_of_controls [ a1; a2 ])\n ~before ~after\n :: acc )\n | ( [ { authorization = (Signature _ | None_given) as a1; _ } ]\n :: ({ authorization = (Signature _ | None_given) as a2; _ }\n :: zkapp_command )\n :: zkapp_commands\n , (before :: _after1) :: (_before2 :: (after :: _ as stmts)) :: stmtss )\n ->\n (* The next two zkapp_command do not contain proofs, and the second is within\n a new transaction. Pair them.\n Ok to get \"use_full_commitment\" of [a1] because neither of them\n contain a proof.\n *)\n group_by_zkapp_command_rev\n (zkapp_command :: zkapp_commands)\n (stmts :: stmtss)\n ( intermediate_state ~kind:`New\n ~spec:(zkapp_segment_of_controls [ a1; a2 ])\n ~before ~after\n :: acc )\n | ( []\n :: ({ authorization = a1; _ } :: zkapp_command)\n :: (({ authorization = Proof _; _ } :: _) :: _ as zkapp_commands)\n , [ _ ] :: (before :: ([ after ] as stmts)) :: (_ :: _ as stmtss) ) ->\n (* The next transaction contains a proof, and this account_update is in a new\n transaction, don't pair it with the next account_update.\n *)\n group_by_zkapp_command_rev\n (zkapp_command :: zkapp_commands)\n (stmts :: stmtss)\n ( intermediate_state ~kind:`New\n ~spec:(zkapp_segment_of_controls [ a1 ])\n ~before ~after\n :: acc )\n | ( []\n :: [ { authorization = (Signature _ | None_given) as a1; _ } ]\n :: ({ authorization = (Signature _ | None_given) as a2; _ }\n :: zkapp_command )\n :: zkapp_commands\n , [ _ ]\n :: [ before; _after1 ]\n :: (_before2 :: (after :: _ as stmts)) :: stmtss ) ->\n (* The next two zkapp_command do not contain proofs, the first is within a\n new transaction, and the second is within another new transaction.\n Pair them.\n Ok to get \"use_full_commitment\" of [a1] because neither of them\n contain a proof.\n *)\n group_by_zkapp_command_rev\n (zkapp_command :: zkapp_commands)\n (stmts :: stmtss)\n ( intermediate_state ~kind:`Two_new\n ~spec:(zkapp_segment_of_controls [ a1; a2 ])\n ~before ~after\n :: acc )\n | [ [ { authorization = a1; _ } ] ], (before :: after :: _) :: _ ->\n (* This account_update is the final account_update given. Prove it on its own. *)\n intermediate_state ~kind:`Same\n ~spec:(zkapp_segment_of_controls [ a1 ])\n ~before ~after\n :: acc\n | ( [] :: [ { authorization = a1; _ } ] :: [] :: _\n , [ _ ] :: (before :: after :: _) :: _ ) ->\n (* This account_update is the final account_update given, in a new transaction. Prove it\n on its own.\n *)\n intermediate_state ~kind:`New\n ~spec:(zkapp_segment_of_controls [ a1 ])\n ~before ~after\n :: acc\n | _, [] ->\n failwith \"group_by_zkapp_command_rev: No statements remaining\"\n | ([] | [ [] ]), _ ->\n failwith \"group_by_zkapp_command_rev: Unmatched statements remaining\"\n | [] :: _, [] :: _ ->\n failwith\n \"group_by_zkapp_command_rev: No final statement for current \\\n transaction\"\n | [] :: _, (_ :: _ :: _) :: _ ->\n failwith\n \"group_by_zkapp_command_rev: Unmatched statements for current \\\n transaction\"\n | [] :: [ _ ] :: _, [ _ ] :: (_ :: _ :: _ :: _) :: _ ->\n failwith\n \"group_by_zkapp_command_rev: Unmatched statements for next \\\n transaction\"\n | [ []; [ _ ] ], [ _ ] :: [ _; _ ] :: _ :: _ ->\n failwith\n \"group_by_zkapp_command_rev: Unmatched statements after next \\\n transaction\"\n | (_ :: _) :: _, ([] | [ _ ]) :: _ | (_ :: _ :: _) :: _, [ _; _ ] :: _ ->\n failwith\n \"group_by_zkapp_command_rev: Too few statements remaining for the \\\n current transaction\"\n | ([] | [ _ ]) :: [] :: _, _ ->\n failwith\n \"group_by_zkapp_command_rev: The next transaction has no \\\n zkapp_command\"\n | [] :: (_ :: _) :: _, _ :: ([] | [ _ ]) :: _\n | [] :: (_ :: _ :: _) :: _, _ :: [ _; _ ] :: _ ->\n failwith\n \"group_by_zkapp_command_rev: Too few statements remaining for the \\\n next transaction\"\n | [ _ ] :: (_ :: _) :: _, _ :: ([] | [ _ ]) :: _ ->\n failwith\n \"group_by_zkapp_command_rev: Too few statements remaining for the \\\n next transaction\"\n | [] :: [ _ ] :: (_ :: _) :: _, _ :: _ :: ([] | [ _ ]) :: _ ->\n failwith\n \"group_by_zkapp_command_rev: Too few statements remaining for the \\\n transaction after next\"\n | ([] | [ _ ]) :: (_ :: _) :: _, [ _ ] ->\n failwith\n \"group_by_zkapp_command_rev: No statements given for the next \\\n transaction\"\n | [] :: [ _ ] :: (_ :: _) :: _, [ _; _ :: _ :: _ ] ->\n failwith\n \"group_by_zkapp_command_rev: No statements given for transaction \\\n after next\"\n in\n group_by_zkapp_command_rev zkapp_account_updatess stmtss []\nend\n\n(*Transaction_snark.Zkapp_command_segment.Basic.t*)\ntype possible_segments = Proved | Signed_single | Signed_pair\n\nmodule Update_group = Make_update_group (struct\n type local_state = unit\n\n type global_state = unit\n\n type connecting_ledger_hash = unit\n\n type spec = possible_segments\n\n let zkapp_segment_of_controls controls : spec =\n match controls with\n | [ Control.Proof _ ] ->\n Proved\n | [ (Control.Signature _ | Control.None_given) ] ->\n Signed_single\n | [ Control.(Signature _ | None_given); Control.(Signature _ | None_given) ]\n ->\n Signed_pair\n | _ ->\n failwith \"zkapp_segment_of_controls: Unsupported combination\"\nend)\n\nlet zkapp_cost ~proof_segments ~signed_single_segments ~signed_pair_segments\n ~(genesis_constants : Genesis_constants.t) () =\n (*10.26*np + 10.08*n2 + 9.14*n1 < 69.45*)\n let proof_cost = genesis_constants.zkapp_proof_update_cost in\n let signed_pair_cost = genesis_constants.zkapp_signed_pair_update_cost in\n let signed_single_cost = genesis_constants.zkapp_signed_single_update_cost in\n Float.(\n (proof_cost * of_int proof_segments)\n + (signed_pair_cost * of_int signed_pair_segments)\n + (signed_single_cost * of_int signed_single_segments))\n\n(* Zkapp_command transactions are filtered using this predicate\n - when adding to the transaction pool\n - in incoming blocks\n*)\nlet valid_size ~(genesis_constants : Genesis_constants.t) (t : t) :\n unit Or_error.t =\n let events_elements events =\n List.fold events ~init:0 ~f:(fun acc event -> acc + Array.length event)\n in\n let all_updates, num_event_elements, num_action_elements =\n Call_forest.fold t.account_updates\n ~init:([ Account_update.of_fee_payer (fee_payer_account_update t) ], 0, 0)\n ~f:(fun (acc, num_event_elements, num_action_elements)\n (account_update : Account_update.t) ->\n let account_update_evs_elements =\n events_elements account_update.body.events\n in\n let account_update_seq_evs_elements =\n events_elements account_update.body.actions\n in\n ( account_update :: acc\n , num_event_elements + account_update_evs_elements\n , num_action_elements + account_update_seq_evs_elements ) )\n |> fun (updates, ev, sev) -> (List.rev updates, ev, sev)\n in\n let groups =\n Update_group.group_by_zkapp_command_rev [ t ]\n ( [ ((), (), ()) ]\n :: [ ((), (), ()) :: List.map all_updates ~f:(fun _ -> ((), (), ())) ] )\n in\n let proof_segments, signed_single_segments, signed_pair_segments =\n List.fold ~init:(0, 0, 0) groups\n ~f:(fun (proof_segments, signed_singles, signed_pairs) { spec; _ } ->\n match spec with\n | Proved ->\n (proof_segments + 1, signed_singles, signed_pairs)\n | Signed_single ->\n (proof_segments, signed_singles + 1, signed_pairs)\n | Signed_pair ->\n (proof_segments, signed_singles, signed_pairs + 1) )\n in\n let cost_limit = genesis_constants.zkapp_transaction_cost_limit in\n let max_event_elements = genesis_constants.max_event_elements in\n let max_action_elements = genesis_constants.max_action_elements in\n let zkapp_cost_within_limit =\n Float.(\n zkapp_cost ~proof_segments ~signed_single_segments ~signed_pair_segments\n ~genesis_constants ()\n < cost_limit)\n in\n let valid_event_elements = num_event_elements <= max_event_elements in\n let valid_action_elements = num_action_elements <= max_action_elements in\n if zkapp_cost_within_limit && valid_event_elements && valid_action_elements\n then Ok ()\n else\n let proof_zkapp_command_err =\n if zkapp_cost_within_limit then None\n else Some (sprintf \"zkapp transaction too expensive\")\n in\n let events_err =\n if valid_event_elements then None\n else\n Some\n (sprintf \"too many event elements (%d, max allowed is %d)\"\n num_event_elements max_event_elements )\n in\n let actions_err =\n if valid_action_elements then None\n else\n Some\n (sprintf \"too many sequence event elements (%d, max allowed is %d)\"\n num_action_elements max_action_elements )\n in\n let err_msg =\n List.filter\n [ proof_zkapp_command_err; events_err; actions_err ]\n ~f:Option.is_some\n |> List.map ~f:(fun opt -> Option.value_exn opt)\n |> String.concat ~sep:\"; \"\n in\n Error (Error.of_string err_msg)\n\nlet has_zero_vesting_period t =\n Call_forest.exists t.account_updates ~f:(fun p ->\n match p.body.update.timing with\n | Keep ->\n false\n | Set { vesting_period; _ } ->\n Mina_numbers.Global_slot_span.(equal zero) vesting_period )\n\nlet get_transaction_commitments (zkapp_command : t) =\n let memo_hash = Signed_command_memo.hash zkapp_command.memo in\n let fee_payer_hash =\n Account_update.of_fee_payer zkapp_command.fee_payer\n |> Digest.Account_update.create\n in\n let account_updates_hash = account_updates_hash zkapp_command in\n let txn_commitment = Transaction_commitment.create ~account_updates_hash in\n let full_txn_commitment =\n Transaction_commitment.create_complete txn_commitment ~memo_hash\n ~fee_payer_hash\n in\n (txn_commitment, full_txn_commitment)\n\nlet inner_query =\n lazy\n (Option.value_exn ~message:\"Invariant: All projectable derivers are Some\"\n Fields_derivers_zkapps.(inner_query (deriver @@ Derivers.o ())) )\n\nmodule For_tests = struct\n let replace_vks t vk =\n { t with\n account_updates =\n Call_forest.map t.account_updates ~f:(fun (p : Account_update.t) ->\n { p with\n body =\n { p.body with\n update =\n { p.body.update with\n verification_key =\n (* replace dummy vks in vk Setting *)\n ( match p.body.update.verification_key with\n | Set _vk ->\n Set vk\n | Keep ->\n Keep )\n }\n ; authorization_kind =\n (* replace dummy vk hashes in authorization kind *)\n ( match p.body.authorization_kind with\n | Proof _vk_hash ->\n Proof (With_hash.hash vk)\n | ak ->\n ak )\n }\n } )\n }\nend\n\nlet%test \"latest zkApp version\" =\n (* if this test fails, update `Transaction_hash.hash_of_transaction_id`\n for latest version, then update this test\n *)\n Stable.Latest.version = 1\n","open Core_kernel\n\nmodule Poly = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type ('u, 's) t =\n ('u, 's) Mina_wire_types.Mina_base.User_command.Poly.V2.t =\n | Signed_command of 'u\n | Zkapp_command of 's\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n end\n\n module V1 = struct\n type ('u, 's) t = Signed_command of 'u | Snapp_command of 's\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest : _ t -> _ V2.t = function\n | Signed_command x ->\n Signed_command x\n | Snapp_command _ ->\n failwith \"Snapp_command\"\n end\n end]\nend\n\ntype ('u, 's) t_ = ('u, 's) Poly.Stable.Latest.t =\n | Signed_command of 'u\n | Zkapp_command of 's\n\nmodule Gen_make (C : Signed_command_intf.Gen_intf) = struct\n let to_signed_command f =\n Quickcheck.Generator.map f ~f:(fun c -> Signed_command c)\n\n open C.Gen\n\n let payment ?sign_type ~key_gen ?nonce ~max_amount ~fee_range () =\n to_signed_command\n (payment ?sign_type ~key_gen ?nonce ~max_amount ~fee_range ())\n\n let payment_with_random_participants ?sign_type ~keys ?nonce ~max_amount\n ~fee_range () =\n to_signed_command\n (payment_with_random_participants ?sign_type ~keys ?nonce ~max_amount\n ~fee_range () )\n\n let stake_delegation ~key_gen ?nonce ~fee_range () =\n to_signed_command (stake_delegation ~key_gen ?nonce ~fee_range ())\n\n let stake_delegation_with_random_participants ~keys ?nonce ~fee_range () =\n to_signed_command\n (stake_delegation_with_random_participants ~keys ?nonce ~fee_range ())\n\n let sequence ?length ?sign_type a =\n Quickcheck.Generator.map\n (sequence ?length ?sign_type a)\n ~f:(List.map ~f:(fun c -> Signed_command c))\nend\n\nmodule Gen = Gen_make (Signed_command)\n\nlet gen_signed =\n let module G = Signed_command.Gen in\n let open Quickcheck.Let_syntax in\n let%bind keys =\n Quickcheck.Generator.list_with_length 2\n Mina_base_import.Signature_keypair.gen\n in\n G.payment_with_random_participants ~sign_type:`Real ~keys:(Array.of_list keys)\n ~max_amount:10000 ~fee_range:1000 ()\n\nlet gen = Gen.to_signed_command gen_signed\n\n[%%versioned\nmodule Stable = struct\n module V2 = struct\n type t =\n (Signed_command.Stable.V2.t, Zkapp_command.Stable.V1.t) Poly.Stable.V2.t\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n end\nend]\n\nlet to_base64 : t -> string = function\n | Signed_command sc ->\n Signed_command.to_base64 sc\n | Zkapp_command zc ->\n Zkapp_command.to_base64 zc\n\nlet of_base64 s : t Or_error.t =\n match Signed_command.of_base64 s with\n | Ok sc ->\n Ok (Signed_command sc)\n | Error err1 -> (\n match Zkapp_command.of_base64 s with\n | Ok zc ->\n Ok (Zkapp_command zc)\n | Error err2 ->\n Error\n (Error.of_string\n (sprintf\n \"Could decode Base64 neither to signed command (%s), nor to \\\n zkApp (%s)\"\n (Error.to_string_hum err1) (Error.to_string_hum err2) ) ) )\n\n(*\ninclude Allocation_functor.Make.Versioned_v1.Full_compare_eq_hash (struct\n let id = \"user_command\"\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t =\n (Signed_command.Stable.V1.t, Snapp_command.Stable.V1.t) Poly.Stable.V1.t\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n\n type 'a creator : Signed_command.t -> Snapp_command.t -> 'a\n\n let create cmd1 cmd2 = (cmd1, cmd2)\n end\n end]\nend)\n*)\n\nmodule Zero_one_or_two = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type 'a t = [ `Zero | `One of 'a | `Two of 'a * 'a ]\n [@@deriving sexp, compare, equal, hash, yojson]\n end\n end]\nend\n\nmodule Verifiable = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t =\n ( Signed_command.Stable.V2.t\n , Zkapp_command.Verifiable.Stable.V1.t )\n Poly.Stable.V2.t\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n let fee_payer (t : t) =\n match t with\n | Signed_command x ->\n Signed_command.fee_payer x\n | Zkapp_command p ->\n Account_update.Fee_payer.account_id p.fee_payer\nend\n\nlet to_verifiable (t : t) ~status ~find_vk : Verifiable.t Or_error.t =\n match t with\n | Signed_command c ->\n Ok (Signed_command c)\n | Zkapp_command cmd ->\n Zkapp_command.Verifiable.create ~status ~find_vk cmd\n |> Or_error.map ~f:(fun cmd -> Zkapp_command cmd)\n\nmodule Make_to_all_verifiable (Strategy : sig\n val create_all :\n Zkapp_command.t With_status.t list\n -> find_vk:\n ( Zkapp_basic.F.t\n -> Account_id.t\n -> (Verification_key_wire.t, Error.t) Result.t )\n -> Zkapp_command.Verifiable.t With_status.t list Or_error.t\nend) =\nstruct\n let to_all_verifiable (ts : t With_status.t list) ~find_vk :\n Verifiable.t With_status.t list Or_error.t =\n let open Or_error.Let_syntax in\n (* First we tag everything with its index *)\n let its = List.mapi ts ~f:(fun i x -> (i, x)) in\n (* then we partition out the zkapp commands *)\n let izk_cmds, is_cmds =\n List.partition_map its ~f:(fun (i, cmd) ->\n match cmd.data with\n | Zkapp_command c ->\n First (i, { cmd with data = c })\n | Signed_command c ->\n Second (i, { cmd with data = c }) )\n in\n (* then unzip the indices *)\n let ixs, zk_cmds = List.unzip izk_cmds in\n (* then we verify the zkapp commands *)\n let%map vzk_cmds = Strategy.create_all ~find_vk zk_cmds in\n (* rezip indices *)\n let ivzk_cmds = List.zip_exn ixs vzk_cmds in\n (* Put them back in with a sort by index (un-partition) *)\n let ivs =\n List.map is_cmds ~f:(fun (i, cmd) ->\n (i, { cmd with data = Signed_command cmd.data }) )\n @ List.map ivzk_cmds ~f:(fun (i, cmd) ->\n (i, { cmd with data = Zkapp_command cmd.data }) )\n |> List.sort ~compare:(fun (i, _) (j, _) -> i - j)\n in\n (* Drop the indices *)\n List.unzip ivs |> snd\nend\n\nmodule Any = struct\n include Make_to_all_verifiable (Zkapp_command.Verifiable.Any)\nend\n\nmodule Last = struct\n include Make_to_all_verifiable (Zkapp_command.Verifiable.Last)\nend\n\nlet of_verifiable (t : Verifiable.t) : t =\n match t with\n | Signed_command x ->\n Signed_command x\n | Zkapp_command p ->\n Zkapp_command (Zkapp_command.of_verifiable p)\n\nlet fee : t -> Currency.Fee.t = function\n | Signed_command x ->\n Signed_command.fee x\n | Zkapp_command p ->\n Zkapp_command.fee p\n\n(* for filtering *)\nlet minimum_fee = Currency.Fee.minimum_user_command_fee\n\nlet has_insufficient_fee t = Currency.Fee.(fee t < minimum_fee)\n\n(* always `Accessed` for fee payer *)\nlet accounts_accessed (t : t) (status : Transaction_status.t) :\n (Account_id.t * [ `Accessed | `Not_accessed ]) list =\n match t with\n | Signed_command x ->\n Signed_command.account_access_statuses x status\n | Zkapp_command ps ->\n Zkapp_command.account_access_statuses ps status\n\nlet accounts_referenced (t : t) =\n List.map (accounts_accessed t Applied) ~f:(fun (acct_id, _status) -> acct_id)\n\nlet fee_payer (t : t) =\n match t with\n | Signed_command x ->\n Signed_command.fee_payer x\n | Zkapp_command p ->\n Zkapp_command.fee_payer p\n\n(** The application nonce is the nonce of the fee payer at which a user command can be applied. *)\nlet applicable_at_nonce (t : t) =\n match t with\n | Signed_command x ->\n Signed_command.nonce x\n | Zkapp_command p ->\n Zkapp_command.applicable_at_nonce p\n\nlet expected_target_nonce t = Account.Nonce.succ (applicable_at_nonce t)\n\nlet extract_vks : t -> Verification_key_wire.t List.t = function\n | Signed_command _ ->\n []\n | Zkapp_command cmd ->\n Zkapp_command.extract_vks cmd\n\n(** The target nonce is what the nonce of the fee payer will be after a user command is successfully applied. *)\nlet target_nonce_on_success (t : t) =\n match t with\n | Signed_command x ->\n Account.Nonce.succ (Signed_command.nonce x)\n | Zkapp_command p ->\n Zkapp_command.target_nonce_on_success p\n\nlet fee_token (t : t) =\n match t with\n | Signed_command x ->\n Signed_command.fee_token x\n | Zkapp_command x ->\n Zkapp_command.fee_token x\n\nlet valid_until (t : t) =\n match t with\n | Signed_command x ->\n Signed_command.valid_until x\n | Zkapp_command { fee_payer; _ } -> (\n match fee_payer.Account_update.Fee_payer.body.valid_until with\n | Some valid_until ->\n valid_until\n | None ->\n Mina_numbers.Global_slot_since_genesis.max_value )\n\nmodule Valid = struct\n type t_ = t\n\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t =\n ( Signed_command.With_valid_signature.Stable.V2.t\n , Zkapp_command.Valid.Stable.V1.t )\n Poly.Stable.V2.t\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n module Gen = Gen_make (Signed_command.With_valid_signature)\nend\n\nlet check_verifiable (t : Verifiable.t) : Valid.t Or_error.t =\n match t with\n | Signed_command x -> (\n match Signed_command.check x with\n | Some c ->\n Ok (Signed_command c)\n | None ->\n Or_error.error_string \"Invalid signature\" )\n | Zkapp_command p ->\n Ok (Zkapp_command (Zkapp_command.Valid.of_verifiable p))\n\nlet check ~status ~find_vk (t : t) : Valid.t Or_error.t =\n to_verifiable ~status ~find_vk t |> Or_error.bind ~f:check_verifiable\n\nlet forget_check (t : Valid.t) : t =\n match t with\n | Zkapp_command x ->\n Zkapp_command (Zkapp_command.Valid.forget x)\n | Signed_command c ->\n Signed_command (c :> Signed_command.t)\n\nlet to_valid_unsafe (t : t) =\n `If_this_is_used_it_should_have_a_comment_justifying_it\n ( match t with\n | Zkapp_command x ->\n let (`If_this_is_used_it_should_have_a_comment_justifying_it x) =\n Zkapp_command.Valid.to_valid_unsafe x\n in\n Zkapp_command x\n | Signed_command x ->\n (* This is safe due to being immediately wrapped again. *)\n let (`If_this_is_used_it_should_have_a_comment_justifying_it x) =\n Signed_command.to_valid_unsafe x\n in\n Signed_command x )\n\nlet filter_by_participant (commands : t list) public_key =\n List.filter commands ~f:(fun user_command ->\n Core_kernel.List.exists\n (accounts_referenced user_command)\n ~f:\n (Fn.compose\n (Signature_lib.Public_key.Compressed.equal public_key)\n Account_id.public_key ) )\n\n(* A metric on user commands that should correspond roughly to resource costs\n for validation/application *)\nlet weight : t -> int = function\n | Signed_command signed_command ->\n Signed_command.payload signed_command |> Signed_command_payload.weight\n | Zkapp_command zkapp_command ->\n Zkapp_command.weight zkapp_command\n\n(* Fee per weight unit *)\nlet fee_per_wu (user_command : Stable.Latest.t) : Currency.Fee_rate.t =\n (*TODO: return Or_error*)\n Currency.Fee_rate.make_exn (fee user_command) (weight user_command)\n\nlet valid_size ~genesis_constants = function\n | Signed_command _ ->\n Ok ()\n | Zkapp_command zkapp_command ->\n Zkapp_command.valid_size ~genesis_constants zkapp_command\n\nlet has_zero_vesting_period = function\n | Signed_command _ ->\n false\n | Zkapp_command p ->\n Zkapp_command.has_zero_vesting_period p\n\nmodule Well_formedness_error = struct\n (* syntactically-evident errors such that a user command can never succeed *)\n type t =\n | Insufficient_fee\n | Zero_vesting_period\n | Zkapp_too_big of (Error.t[@to_yojson Error_json.error_to_yojson])\n [@@deriving compare, to_yojson]\n\n let to_string = function\n | Insufficient_fee ->\n \"Insufficient fee\"\n | Zero_vesting_period ->\n \"Zero vesting period\"\n | Zkapp_too_big err ->\n sprintf \"Zkapp too big (%s)\" (Error.to_string_hum err)\nend\n\nlet check_well_formedness ~genesis_constants t :\n (unit, Well_formedness_error.t list) result =\n let preds =\n let open Well_formedness_error in\n [ (has_insufficient_fee, Insufficient_fee)\n ; (has_zero_vesting_period, Zero_vesting_period)\n ]\n in\n let errs0 =\n List.fold preds ~init:[] ~f:(fun acc (f, err) ->\n if f t then err :: acc else acc )\n in\n let errs =\n match valid_size ~genesis_constants t with\n | Ok () ->\n errs0\n | Error err ->\n Zkapp_too_big err :: errs0\n in\n if List.is_empty errs then Ok () else Error errs\n","open Core_kernel\nopen Mina_base_import\n\n(** See documentation of the {!Mina_wire_types} library *)\nmodule Wire_types = Mina_wire_types.Mina_base.Fee_transfer\n\nmodule Make_sig (A : Wire_types.Types.S) = struct\n module type S =\n Fee_transfer_intf.Full\n with type Single.Stable.V2.t = A.Single.V2.t\n and type Stable.V2.t = A.V2.t\nend\n\nmodule Make_str (A : Wire_types.Concrete) = struct\n module Single = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t = A.Single.V2.t =\n { receiver_pk : Public_key.Compressed.Stable.V1.t\n ; fee : Currency.Fee.Stable.V1.t\n ; fee_token : Token_id.Stable.V2.t\n }\n [@@deriving sexp, compare, equal, yojson, hash]\n\n let to_latest = Fn.id\n\n let description = \"Fee transfer Single\"\n\n let version_byte = Base58_check.Version_bytes.fee_transfer_single\n end\n end]\n\n include Comparable.Make (Stable.Latest)\n module Base58_check = Codable.Make_base58_check (Stable.Latest)\n\n [%%define_locally\n Base58_check.(to_base58_check, of_base58_check, of_base58_check_exn)]\n\n let create ~receiver_pk ~fee ~fee_token = { receiver_pk; fee; fee_token }\n\n let receiver_pk { receiver_pk; _ } = receiver_pk\n\n let receiver { receiver_pk; fee_token; _ } =\n Account_id.create receiver_pk fee_token\n\n let fee { fee; _ } = fee\n\n let fee_token { fee_token; _ } = fee_token\n\n module Gen = struct\n let with_random_receivers ?(min_fee = 0) ~max_fee ~token keys :\n t Quickcheck.Generator.t =\n let open Quickcheck.Generator.Let_syntax in\n let%map receiver_pk =\n let open Signature_lib in\n Quickcheck_lib.of_array keys\n >>| fun keypair -> Public_key.compress keypair.Keypair.public_key\n and fee =\n Int.gen_incl min_fee max_fee >>| Currency.Fee.of_nanomina_int_exn\n and fee_token = token in\n { receiver_pk; fee; fee_token }\n end\n end\n\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t = Single.Stable.V2.t One_or_two.Stable.V1.t\n [@@deriving sexp, compare, equal, yojson, hash]\n\n let to_latest = Fn.id\n end\n end]\n\n type single = Single.t =\n { receiver_pk : Public_key.Compressed.t\n ; fee : Currency.Fee.t\n ; fee_token : Token_id.t\n }\n [@@deriving sexp, compare, yojson, hash]\n\n let to_singles = Fn.id\n\n let of_singles = function\n | `One _ as t ->\n Or_error.return t\n | `Two (one, two) as t ->\n if Token_id.equal one.fee_token two.fee_token then Or_error.return t\n else\n (* Necessary invariant for the transaction snark: we should never have\n fee excesses in multiple tokens simultaneously.\n *)\n Or_error.errorf\n !\"Cannot combine single fee transfers with incompatible tokens: \\\n %{sexp: Token_id.t} <> %{sexp: Token_id.t}\"\n one.fee_token two.fee_token\n\n let create one two =\n let singles =\n match two with None -> `One one | Some two -> `Two (one, two)\n in\n of_singles singles\n\n let create_single ~receiver_pk ~fee ~fee_token =\n `One (Single.create ~receiver_pk ~fee ~fee_token)\n\n include Comparable.Make (Stable.Latest)\n\n let fee_excess ft =\n ft\n |> One_or_two.map ~f:(fun { fee_token; fee; _ } ->\n (fee_token, Currency.Fee.Signed.(negate (of_unsigned fee))) )\n |> Fee_excess.of_one_or_two\n\n let receiver_pks t =\n One_or_two.to_list (One_or_two.map ~f:Single.receiver_pk t)\n\n let receivers t = One_or_two.to_list (One_or_two.map ~f:Single.receiver t)\n\n (* This must match [Transaction_union].\n TODO: enforce this.\n *)\n let fee_payer_pk ft =\n match ft with\n | `One ft ->\n Single.receiver_pk ft\n | `Two (_, ft) ->\n Single.receiver_pk ft\n\n let fee_token = Single.fee_token\n\n let fee_tokens = One_or_two.map ~f:Single.fee_token\n\n let map = One_or_two.map\n\n let fold = One_or_two.fold\n\n let to_list = One_or_two.to_list\n\n let to_numbered_list = One_or_two.to_numbered_list\nend\n\ninclude Wire_types.Make (Make_sig) (Make_str)\n","open Core_kernel\nopen Mina_base_import\n\n(** See documentation of the {!Mina_wire_types} library *)\nmodule Wire_types = Mina_wire_types.Mina_base.Coinbase_fee_transfer\n\nmodule Make_sig (A : Wire_types.Types.S) = struct\n module type S = Coinbase_fee_transfer_intf.Full with type Stable.V1.t = A.V1.t\nend\n\nmodule Make_str (A : Wire_types.Concrete) = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = A.V1.t =\n { receiver_pk : Public_key.Compressed.Stable.V1.t\n ; fee : Currency.Fee.Stable.V1.t\n }\n [@@deriving sexp, compare, equal, yojson, hash]\n\n let to_latest = Fn.id\n\n let description = \"Coinbase fee transfer\"\n\n let version_byte = Base58_check.Version_bytes.fee_transfer_single\n end\n end]\n\n let create ~receiver_pk ~fee = { receiver_pk; fee }\n\n include Comparable.Make (Stable.Latest)\n module Base58_check = Codable.Make_base58_check (Stable.Latest)\n\n [%%define_locally\n Base58_check.(to_base58_check, of_base58_check, of_base58_check_exn)]\n\n let receiver_pk { receiver_pk; _ } = receiver_pk\n\n let receiver { receiver_pk; _ } =\n Account_id.create receiver_pk Token_id.default\n\n let fee { fee; _ } = fee\n\n let to_fee_transfer { receiver_pk; fee } =\n Fee_transfer.Single.create ~receiver_pk ~fee ~fee_token:Token_id.default\n\n module Gen = struct\n let gen ?(min_fee = Currency.Fee.zero) max_fee : t Quickcheck.Generator.t =\n let open Quickcheck.Generator.Let_syntax in\n let%bind receiver_pk = Public_key.Compressed.gen in\n let%map fee = Currency.Fee.gen_incl min_fee max_fee in\n { receiver_pk; fee }\n\n let with_random_receivers ~keys ?(min_fee = Currency.Fee.zero)\n coinbase_amount : t Quickcheck.Generator.t =\n let open Quickcheck.Generator.Let_syntax in\n let max_fee = Currency.Amount.to_fee coinbase_amount in\n let%map receiver_pk =\n let open Signature_lib in\n Quickcheck_lib.of_array keys\n >>| fun keypair -> Public_key.compress keypair.Keypair.public_key\n and fee = Currency.Fee.gen_incl min_fee max_fee in\n { receiver_pk; fee }\n end\nend\n\ninclude Wire_types.Make (Make_sig) (Make_str)\n","open Core_kernel\nopen Mina_base_import\n\n(** See documentation of the {!Mina_wire_types} library *)\nmodule Wire_types = Mina_wire_types.Mina_base.Coinbase\n\nmodule Make_sig (A : Wire_types.Types.S) = struct\n module type S = Coinbase_intf.Full with type Stable.V1.t = A.V1.t\nend\n\nmodule Make_str (A : Wire_types.Concrete) = struct\n module Fee_transfer = Coinbase_fee_transfer\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = A.V1.t =\n { receiver : Public_key.Compressed.Stable.V1.t\n ; amount : Currency.Amount.Stable.V1.t\n ; fee_transfer : Fee_transfer.Stable.V1.t option\n }\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n\n let description = \"Coinbase\"\n\n let version_byte = Base58_check.Version_bytes.coinbase\n end\n end]\n\n module Base58_check = Codable.Make_base58_check (Stable.Latest)\n\n [%%define_locally\n Base58_check.(to_base58_check, of_base58_check, of_base58_check_exn)]\n\n let receiver_pk t = t.receiver\n\n let receiver t = Account_id.create t.receiver Token_id.default\n\n (* This must match [Transaction_union].\n TODO: enforce this.\n *)\n let fee_payer_pk cb =\n match cb.fee_transfer with None -> cb.receiver | Some ft -> ft.receiver_pk\n\n let amount t = t.amount\n\n let fee_transfer t = t.fee_transfer\n\n let account_access_statuses t (status : Transaction_status.t) =\n let access_status =\n match status with Applied -> `Accessed | Failed _ -> `Not_accessed\n in\n let account_ids =\n receiver t\n :: List.map ~f:Fee_transfer.receiver (Option.to_list t.fee_transfer)\n in\n List.map account_ids ~f:(fun acct_id -> (acct_id, access_status))\n\n let accounts_referenced t =\n List.map (account_access_statuses t Transaction_status.Applied)\n ~f:(fun (acct_id, _status) -> acct_id)\n\n let is_valid { amount; fee_transfer; _ } =\n match fee_transfer with\n | None ->\n true\n | Some { fee; _ } ->\n Currency.Amount.(of_fee fee <= amount)\n\n let create ~amount ~receiver ~fee_transfer =\n let t = { receiver; amount; fee_transfer } in\n if is_valid t then\n let adjusted_fee_transfer =\n Option.bind fee_transfer ~f:(fun fee_transfer ->\n Option.some_if\n (not\n (Public_key.Compressed.equal receiver\n (Fee_transfer.receiver_pk fee_transfer) ) )\n fee_transfer )\n in\n Ok { t with fee_transfer = adjusted_fee_transfer }\n else Or_error.error_string \"Coinbase.create: invalid coinbase\"\n\n let expected_supply_increase { receiver = _; amount; fee_transfer } =\n match fee_transfer with\n | None ->\n Ok amount\n | Some { fee; _ } ->\n Currency.Amount.sub amount (Currency.Amount.of_fee fee)\n |> Option.value_map\n ~f:(fun _ -> Ok amount)\n ~default:(Or_error.error_string \"Coinbase underflow\")\n\n let fee_excess t =\n Or_error.map (expected_supply_increase t) ~f:(fun _increase ->\n Fee_excess.empty )\n\n module Gen = struct\n let gen ~(constraint_constants : Genesis_constants.Constraint_constants.t) =\n let open Quickcheck.Let_syntax in\n let%bind receiver = Public_key.Compressed.gen in\n let%bind supercharged_coinbase = Quickcheck.Generator.bool in\n let%bind amount =\n let max_amount = constraint_constants.coinbase_amount in\n (* amount should be at least the account creation fee to pay for the creation of coinbase receiver and the fee transfer receiver below *)\n let min_amount =\n Option.value_exn\n (Currency.Fee.scale constraint_constants.account_creation_fee 2)\n |> Currency.Amount.of_fee\n in\n let%map amount = Currency.Amount.(gen_incl min_amount max_amount) in\n if supercharged_coinbase then\n Option.value_exn\n (Currency.Amount.scale amount\n constraint_constants.supercharged_coinbase_factor )\n else amount\n in\n (* keep account-creation fee for the coinbase-receiver *)\n let max_fee =\n Option.value_exn\n (Currency.Fee.sub\n (Currency.Amount.to_fee amount)\n constraint_constants.account_creation_fee )\n in\n let min_fee = constraint_constants.account_creation_fee in\n let%map fee_transfer =\n Option.quickcheck_generator (Fee_transfer.Gen.gen ~min_fee max_fee)\n in\n let fee_transfer =\n match fee_transfer with\n | Some { Fee_transfer.receiver_pk; _ }\n when Public_key.Compressed.equal receiver receiver_pk ->\n (* Erase fee transfer, to mirror [create]. *)\n None\n | _ ->\n fee_transfer\n in\n ( { receiver; amount; fee_transfer }\n , `Supercharged_coinbase supercharged_coinbase )\n\n let with_random_receivers ~keys ~min_amount ~max_amount ~fee_transfer =\n let open Quickcheck.Let_syntax in\n let%bind receiver =\n let open Signature_lib in\n Quickcheck_lib.of_array keys\n >>| fun keypair -> Public_key.compress keypair.Keypair.public_key\n and amount =\n Int.gen_incl min_amount max_amount\n >>| Currency.Amount.of_nanomina_int_exn\n in\n let%map fee_transfer =\n Option.quickcheck_generator (fee_transfer ~coinbase_amount:amount)\n in\n let fee_transfer =\n match fee_transfer with\n | Some { Fee_transfer.receiver_pk; _ }\n when Public_key.Compressed.equal receiver receiver_pk ->\n (* Erase fee transfer, to mirror [create]. *)\n None\n | _ ->\n fee_transfer\n in\n { receiver; amount; fee_transfer }\n end\nend\n\ninclude Wire_types.Make (Make_sig) (Make_str)\n","open Core_kernel\nopen Mina_base_import\nopen Snarky_backendless\nopen Snark_params\nopen Snark_params.Tick\nopen Let_syntax\nopen Currency\n\n(* A pending coinbase is basically a Merkle tree of \"stacks\", each of which contains two hashes. The first hash\n is computed from the components in the coinbase via a \"push\" operation. The second hash, a protocol\n state hash, is computed from the state *body* hash in the coinbase.\n The \"add_coinbase\" operation takes a coinbase, retrieves the latest stack, or creates a new one, and does\n a push.\n\n A pending coinbase also contains a stack id, used to determine the chronology of stacks, so we can know\n which is the oldest, and which is the newest stack.\n\n The name \"stack\" here is a misnomer: see issue #3226\n*)\nmodule Wire_types = Mina_wire_types.Mina_base.Pending_coinbase\n\nmodule Make_sig (A : Wire_types.Types.S) = struct\n module type S =\n Pending_coinbase_intf.S\n with type State_stack.Stable.V1.t = A.State_stack.V1.t\n and type Stack_versioned.Stable.V1.t = A.Stack_versioned.V1.t\n and type Hash.t = A.Hash_builder.V1.t\n and type Hash_versioned.Stable.V1.t = A.Hash_versioned.V1.t\nend\n\nmodule Make_str (A : Wire_types.Concrete) = struct\n module Coinbase_data = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Public_key.Compressed.Stable.V1.t * Amount.Stable.V1.t\n [@@deriving sexp, to_yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n let of_coinbase (cb : Coinbase.t) : t = (cb.receiver, cb.amount)\n\n type var = Public_key.Compressed.var * Amount.var\n\n let var_of_t ((public_key, amount) : t) =\n (Public_key.Compressed.var_of_t public_key, Amount.var_of_t amount)\n\n let to_input (pk, amount) =\n let open Random_oracle.Input.Chunked in\n List.reduce_exn ~f:append\n [ Public_key.Compressed.to_input pk; Amount.to_input amount ]\n\n module Checked = struct\n let to_input (public_key, amount) =\n let open Random_oracle.Input.Chunked in\n List.reduce_exn ~f:append\n [ Public_key.Compressed.Checked.to_input public_key\n ; Amount.var_to_input amount\n ]\n end\n\n let typ : (var, t) Typ.t =\n let of_hlist\n : 'public_key 'amount.\n (unit, 'public_key -> 'amount -> unit) H_list.t\n -> 'public_key * 'amount =\n let open H_list in\n fun [ public_key; amount ] -> (public_key, amount)\n in\n let to_hlist (public_key, amount) = H_list.[ public_key; amount ] in\n Typ.of_hlistable\n [ Public_key.Compressed.typ; Amount.typ ]\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist\n\n let empty = (Public_key.Compressed.empty, Amount.zero)\n\n let genesis = empty\n end\n\n module Stack_id : sig\n [%%versioned:\n module Stable : sig\n module V1 : sig\n type t [@@deriving sexp, yojson, compare, equal]\n end\n end]\n\n val of_int : int -> t\n\n val to_int : t -> int\n\n val zero : t\n\n val incr_by_one : t -> t Or_error.t\n\n val to_string : t -> string\n\n val ( > ) : t -> t -> bool\n end = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = int [@@deriving sexp, yojson, compare, equal]\n\n let to_latest = Fn.id\n end\n end]\n\n [%%define_locally Int.(( > ), to_string, zero, to_int, of_int, equal)]\n\n let incr_by_one t1 =\n let t2 = t1 + 1 in\n if t2 < t1 then Or_error.error_string \"Stack_id overflow\" else Ok t2\n end\n\n module type Data_hash_intf = sig\n type t = private Field.t [@@deriving sexp, compare, equal, yojson, hash]\n\n type var\n\n val var_of_t : t -> var\n\n val typ : (var, t) Typ.t\n\n val var_to_hash_packed : var -> Field.Var.t\n\n val equal_var : var -> var -> Boolean.var Tick.Checked.t\n\n val to_bytes : t -> string\n\n val to_bits : t -> bool list\n\n val to_base58_check : t -> string\n\n val of_base58_check_exn : string -> t\n\n val gen : t Quickcheck.Generator.t\n end\n\n (* a coinbase stack has two components, data and a state_hash\n we create modules for each component\n *)\n\n module Coinbase_stack = struct\n include Data_hash.Make_full_size (struct\n let description = \"Coinbase stack data\"\n\n let version_byte = Base58_check.Version_bytes.coinbase_stack_data\n end)\n\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n module T = struct\n type t = (Field.t[@version_asserted]) [@@deriving sexp, compare, hash]\n end\n\n include T\n\n let to_latest = Fn.id\n\n [%%define_from_scope to_yojson, of_yojson]\n\n include Comparable.Make (T)\n include Hashable.Make_binable (T)\n end\n end]\n\n let (_ : (t, Stable.Latest.t) Type_equal.t) = Type_equal.T\n\n let push (h : t) cb =\n let coinbase = Coinbase_data.of_coinbase cb in\n let open Random_oracle in\n hash ~init:Hash_prefix.coinbase_stack\n (pack_input\n (Input.Chunked.append (Coinbase_data.to_input coinbase) (to_input h)) )\n |> of_hash\n\n let empty = Random_oracle.salt \"CoinbaseStack\" |> Random_oracle.digest\n\n module Checked = struct\n type t = var\n\n let push (h : t) (cb : Coinbase_data.var) =\n let open Random_oracle.Checked in\n make_checked (fun () ->\n hash ~init:Hash_prefix.coinbase_stack\n (pack_input\n (Random_oracle.Input.Chunked.append\n (Coinbase_data.Checked.to_input cb)\n (var_to_input h) ) )\n |> var_of_hash_packed )\n\n let check_merge (_, t1) (s2, _) = equal_var t1 s2\n\n let if_ = if_\n end\n end\n\n module Stack_hash = struct\n include Data_hash.Make_full_size (struct\n let description = \"Coinbase stack hash\"\n\n let version_byte = Base58_check.Version_bytes.coinbase_stack_hash\n end)\n\n (* Data hash versioned boilerplate below *)\n\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n module T = struct\n type t = (Field.t[@version_asserted]) [@@deriving sexp, compare, hash]\n end\n\n include T\n\n let to_latest = Fn.id\n\n [%%define_from_scope to_yojson, of_yojson]\n\n include Comparable.Make (T)\n include Hashable.Make_binable (T)\n end\n end]\n\n let (_ : (t, Stable.Latest.t) Type_equal.t) = Type_equal.T\n\n let dummy = of_hash Outside_hash_image.t\n end\n\n (*Stack of protocol state body hashes*)\n module State_stack = struct\n module Poly = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type 'stack_hash t = 'stack_hash A.State_stack.Poly.V1.t =\n { init : 'stack_hash; curr : 'stack_hash }\n [@@deriving sexp, compare, hash, yojson, equal, hlist]\n end\n end]\n end\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Stack_hash.Stable.V1.t Poly.Stable.V1.t\n [@@deriving sexp, compare, hash, equal, yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n type var = Stack_hash.var Poly.t\n\n let gen : t Quickcheck.Generator.t =\n let open Quickcheck.Generator.Let_syntax in\n let%map init, curr =\n Quickcheck.Generator.tuple2 Stack_hash.gen Stack_hash.gen\n in\n { Poly.init; curr }\n\n let to_input (t : t) =\n Random_oracle.Input.Chunked.append\n (Stack_hash.to_input t.init)\n (Stack_hash.to_input t.curr)\n\n let var_to_input (t : var) =\n Random_oracle.Input.Chunked.append\n (Stack_hash.var_to_input t.init)\n (Stack_hash.var_to_input t.curr)\n\n let var_of_t (t : t) =\n { Poly.init = Stack_hash.var_of_t t.init\n ; curr = Stack_hash.var_of_t t.curr\n }\n\n let typ : (var, t) Typ.t =\n Snark_params.Tick.Typ.of_hlistable\n [ Stack_hash.typ; Stack_hash.typ ]\n ~var_to_hlist:Poly.to_hlist ~var_of_hlist:Poly.of_hlist\n ~value_to_hlist:Poly.to_hlist ~value_of_hlist:Poly.of_hlist\n\n let to_bits (t : t) = Stack_hash.to_bits t.init @ Stack_hash.to_bits t.curr\n\n let to_bytes (t : t) =\n Stack_hash.to_bytes t.init ^ Stack_hash.to_bytes t.curr\n\n let equal_var (v1 : var) (v2 : var) =\n let open Tick.Checked.Let_syntax in\n let%bind b1 = Stack_hash.equal_var v1.init v2.init in\n let%bind b2 = Stack_hash.equal_var v1.curr v2.curr in\n Boolean.(b1 && b2)\n\n let if_ (cond : Tick0.Boolean.var) ~(then_ : var) ~(else_ : var) :\n var Tick0.Checked.t =\n let%bind init = Stack_hash.if_ cond ~then_:then_.init ~else_:else_.init in\n let%map curr = Stack_hash.if_ cond ~then_:then_.curr ~else_:else_.curr in\n { Poly.init; curr }\n\n let push (t : t) (state_body_hash : State_body_hash.t)\n (global_slot : Mina_numbers.Global_slot_since_genesis.t) : t =\n (* this is the same computation for combining state hashes and state body hashes as\n `Protocol_state.hash_abstract', not available here because it would create\n a module dependency cycle\n *)\n { t with\n curr =\n Random_oracle.hash ~init:Hash_prefix.protocol_state\n [| (t.curr :> Field.t)\n ; (state_body_hash :> Field.t)\n ; Mina_numbers.Global_slot_since_genesis.to_field global_slot\n |]\n |> Stack_hash.of_hash\n }\n\n let empty : t = { Poly.init = Stack_hash.dummy; curr = Stack_hash.dummy }\n\n let create ~init = { Poly.init; curr = init }\n\n module Checked = struct\n type t = var\n\n let push (t : t) (state_body_hash : State_body_hash.var)\n (global_slot : Mina_numbers.Global_slot_since_genesis.Checked.var) =\n make_checked (fun () ->\n let curr =\n Random_oracle.Checked.hash ~init:Hash_prefix.protocol_state\n [| Stack_hash.var_to_hash_packed t.curr\n ; State_body_hash.var_to_hash_packed state_body_hash\n ; Mina_numbers.Global_slot_since_genesis.Checked.to_field\n global_slot\n |]\n |> Stack_hash.var_of_hash_packed\n in\n { t with curr } )\n\n let check_merge (s1, t1) (s2, t2) =\n (*state stacks are updated for every transaction in transaction snark but\n only once for every blockchain snark. Therefore, source stacks (and\n target stacks) will be equal for transactions in the same block*)\n let%bind eq_src = equal_var s1 s2\n and eq_target = equal_var t1 t2\n and correct_transition = equal_var t1 s2 in\n let%bind same_update = Boolean.(eq_src &&& eq_target) in\n Boolean.any [ same_update; correct_transition ]\n end\n end\n\n (* Pending coinbase hash *)\n module Hash_builder = struct\n include Data_hash.Make_full_size (struct\n let description = \"Pending coinbase hash builder\"\n\n let version_byte = Base58_check.Version_bytes.receipt_chain_hash\n end)\n\n (* Data hash versioned boilerplate below *)\n\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n module T = struct\n type t = (Field.t[@version_asserted]) [@@deriving sexp, compare, hash]\n end\n\n include T\n\n let to_latest = Fn.id\n\n [%%define_from_scope to_yojson, of_yojson]\n\n include Comparable.Make (T)\n include Hashable.Make_binable (T)\n end\n end]\n\n let (_ : (t, Stable.Latest.t) Type_equal.t) = Type_equal.T\n\n let merge ~height (h1 : t) (h2 : t) =\n Random_oracle.hash\n ~init:(Hash_prefix.coinbase_merkle_tree height)\n [| (h1 :> field); (h2 :> field) |]\n |> of_hash\n\n let empty_hash =\n Random_oracle.(digest (salt \"PendingCoinbaseMerkleTree\")) |> of_hash\n\n let of_digest = Fn.compose Fn.id of_hash\n end\n\n module Update = struct\n module Action = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t =\n | Update_none\n | Update_one\n | Update_two_coinbase_in_first\n | Update_two_coinbase_in_second\n [@@deriving equal, sexp, to_yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n type var = Boolean.var * Boolean.var\n\n let to_bits = function\n | Update_none ->\n (false, false)\n | Update_one ->\n (true, false)\n | Update_two_coinbase_in_first ->\n (false, true)\n | Update_two_coinbase_in_second ->\n (true, true)\n\n let of_bits = function\n | false, false ->\n Update_none\n | true, false ->\n Update_one\n | false, true ->\n Update_two_coinbase_in_first\n | true, true ->\n Update_two_coinbase_in_second\n\n let var_of_t t =\n let x, y = to_bits t in\n Boolean.(var_of_value x, var_of_value y)\n\n let typ =\n Typ.transport\n Typ.(Boolean.typ * Boolean.typ)\n ~there:to_bits ~back:of_bits\n\n module Checked = struct\n let no_update (b0, b1) = Boolean.((not b0) &&& not b1)\n\n let update_two_stacks_coinbase_in_first (b0, b1) =\n Boolean.((not b0) &&& b1)\n\n let update_two_stacks_coinbase_in_second (b0, b1) = Boolean.(b0 &&& b1)\n end\n end\n\n module Poly = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type ('action, 'coinbase_amount) t =\n { action : 'action; coinbase_amount : 'coinbase_amount }\n [@@deriving sexp, to_yojson, hlist]\n end\n end]\n end\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = (Action.Stable.V1.t, Amount.Stable.V1.t) Poly.Stable.V1.t\n [@@deriving sexp, to_yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n [%%define_locally Poly.(to_hlist, of_hlist)]\n\n type var = (Action.var, Amount.var) Poly.t\n\n let typ =\n let open Snark_params.Tick.Typ in\n of_hlistable ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist\n ~value_to_hlist:to_hlist ~value_of_hlist:of_hlist\n [ Action.typ; Amount.typ ]\n\n let genesis : t =\n { coinbase_amount = Currency.Amount.zero; action = Action.Update_none }\n\n let var_of_t (t : t) : var =\n { action = Action.var_of_t t.action\n ; coinbase_amount = Amount.var_of_t t.coinbase_amount\n }\n end\n\n (* Sparse_ledger.Make is applied more than once in the code, so\n it can't make assumptions about the internal structure of its module\n arguments. Therefore, for modules with a bin_io type passed to the functor,\n that type cannot be in a version module hierarchy. We build the required\n modules for Hash and Stack.\n *)\n\n module Stack_versioned = struct\n module Poly = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type ('data_stack, 'state_stack) t =\n ('data_stack, 'state_stack) A.Stack_versioned.Poly.V1.t =\n { data : 'data_stack; state : 'state_stack }\n [@@deriving yojson, hash, sexp, equal, compare]\n end\n end]\n end\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t =\n (Coinbase_stack.Stable.V1.t, State_stack.Stable.V1.t) Poly.Stable.V1.t\n [@@deriving equal, yojson, hash, sexp, compare]\n\n let to_latest = Fn.id\n end\n end]\n end\n\n module Hash_versioned = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Hash_builder.Stable.V1.t\n [@@deriving equal, compare, sexp, yojson, hash]\n\n let to_latest = Fn.id\n end\n end]\n end\n\n module Merkle_tree_versioned = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t =\n ( Hash_versioned.Stable.V1.t\n , Stack_id.Stable.V1.t\n , Stack_versioned.Stable.V1.t )\n Sparse_ledger_lib.Sparse_ledger.T.Stable.V2.t\n [@@deriving sexp, to_yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n let (_ :\n ( t\n , ( Hash_versioned.t\n , Stack_id.t\n , Stack_versioned.t )\n Sparse_ledger_lib.Sparse_ledger.T.t )\n Type_equal.t ) =\n Type_equal.T\n end\n\n module T = struct\n (* Total number of stacks *)\n let max_coinbase_stack_count ~depth = Int.pow 2 depth\n\n let chain if_ b ~then_ ~else_ =\n let%bind then_ = then_ and else_ = else_ in\n if_ b ~then_ ~else_\n\n (*pair of coinbase and state stacks*)\n module Stack = struct\n module Poly = struct\n type ('data_stack, 'state_stack) t =\n ('data_stack, 'state_stack) Stack_versioned.Poly.t =\n { data : 'data_stack; state : 'state_stack }\n [@@deriving yojson, hash, sexp, compare, hlist]\n end\n\n type t = Stack_versioned.t [@@deriving yojson, equal, compare, sexp, hash]\n\n let (_ : (t, (Coinbase_stack.t, State_stack.t) Poly.t) Type_equal.t) =\n Type_equal.T\n\n type var = (Coinbase_stack.var, State_stack.var) Poly.t\n\n let to_input ({ data; state } : t) =\n Random_oracle.Input.Chunked.append\n (Coinbase_stack.to_input data)\n (State_stack.to_input state)\n\n let data_hash t =\n Random_oracle.(\n hash ~init:Hash_prefix_states.coinbase_stack (pack_input (to_input t)))\n |> Hash_builder.of_digest\n\n let var_to_input ({ data; state } : var) =\n Random_oracle.Input.Chunked.append\n (Coinbase_stack.var_to_input data)\n (State_stack.var_to_input state)\n\n let hash_var (t : var) =\n make_checked (fun () ->\n Random_oracle.Checked.(\n hash ~init:Hash_prefix_states.coinbase_stack\n (pack_input (var_to_input t))) )\n\n let var_of_t t =\n { Poly.data = Coinbase_stack.var_of_t t.Poly.data\n ; state = State_stack.var_of_t t.state\n }\n\n let gen =\n let open Base_quickcheck.Generator.Let_syntax in\n let%bind data = Coinbase_stack.gen in\n let%map state = State_stack.gen in\n { Poly.data; state }\n\n let typ : (var, t) Typ.t =\n Snark_params.Tick.Typ.of_hlistable\n [ Coinbase_stack.typ; State_stack.typ ]\n ~var_to_hlist:Poly.to_hlist ~var_of_hlist:Poly.of_hlist\n ~value_to_hlist:Poly.to_hlist ~value_of_hlist:Poly.of_hlist\n\n let num_pad_bits =\n let len = List.length Coinbase_stack.(to_bits empty) in\n (3 - (len mod 3)) mod 3\n\n (* pad to match the triple representation *)\n let pad_bits = List.init num_pad_bits ~f:(fun _ -> false)\n\n let to_bits t =\n Coinbase_stack.to_bits t.Poly.data\n @ pad_bits\n @ State_stack.to_bits t.Poly.state\n\n let to_bytes t =\n Coinbase_stack.to_bytes t.Poly.data ^ State_stack.to_bytes t.Poly.state\n\n let equal_var var1 var2 =\n let open Tick.Checked.Let_syntax in\n let%bind b1 = Coinbase_stack.equal_var var1.Poly.data var2.Poly.data in\n let%bind b2 = State_stack.equal_var var1.Poly.state var2.Poly.state in\n let open Tick0.Boolean in\n b1 &&& b2\n\n let empty =\n { Poly.data = Coinbase_stack.empty; state = State_stack.empty }\n\n let create_with (t : t) =\n { empty with state = State_stack.create ~init:t.state.curr }\n\n let equal_state_hash t1 t2 = State_stack.equal t1.Poly.state t2.Poly.state\n\n let equal_data t1 t2 = Coinbase_stack.equal t1.Poly.data t2.Poly.data\n\n let connected ?(prev : t option = None) ~first ~second () =\n let coinbase_stack_connected =\n (*same as old stack or second could be a new stack with empty data*)\n equal_data first second\n || Coinbase_stack.(equal empty second.Poly.data)\n in\n let state_stack_connected =\n (*1. same as old stack or\n 2. new stack initialized with the stack state of last block. Not possible to know this unless we track all the stack states because they are updated once per block (init=curr)\n 3. [second] could be a new stack initialized with the latest state of [first] or\n 4. [second] starts from the previous state of [first]. This is not available in either [first] or [second] *)\n equal_state_hash first second\n || Stack_hash.equal second.state.init second.state.curr\n || Stack_hash.equal first.state.curr second.state.curr\n || Option.value_map prev ~default:true ~f:(fun prev ->\n Stack_hash.equal prev.state.curr second.state.curr )\n in\n coinbase_stack_connected && state_stack_connected\n\n let push_coinbase (cb : Coinbase.t) t =\n let data = Coinbase_stack.push t.Poly.data cb in\n { t with data }\n\n let push_state (state_body_hash : State_body_hash.t)\n (global_slot : Mina_numbers.Global_slot_since_genesis.t) (t : t) =\n { t with state = State_stack.push t.state state_body_hash global_slot }\n\n let if_ (cond : Tick0.Boolean.var) ~(then_ : var) ~(else_ : var) :\n var Tick0.Checked.t =\n let%bind data =\n Coinbase_stack.Checked.if_ cond ~then_:then_.data ~else_:else_.data\n in\n let%map state =\n State_stack.if_ cond ~then_:then_.state ~else_:else_.state\n in\n { Poly.data; state }\n\n module Checked = struct\n type t = var\n\n let push_coinbase (coinbase : Coinbase_data.var) (t : t) :\n t Tick0.Checked.t =\n let%map data = Coinbase_stack.Checked.push t.data coinbase in\n { t with data }\n\n let push_state (state_body_hash : State_body_hash.var)\n (global_slot : Mina_numbers.Global_slot_since_genesis.Checked.var)\n (t : t) =\n let%map state =\n State_stack.Checked.push t.state state_body_hash global_slot\n in\n { t with state }\n\n let check_merge ~transition1:((s, t) : t * t)\n ~transition2:((s', t') : t * t) : Boolean.var Tick0.Checked.t =\n let%bind valid_coinbase_stacks =\n Coinbase_stack.Checked.check_merge (s.data, t.data)\n (s'.data, t'.data)\n in\n let%bind valid_state_stacks =\n State_stack.Checked.check_merge (s.state, t.state)\n (s'.state, t'.state)\n in\n Boolean.(valid_coinbase_stacks && valid_state_stacks)\n\n let empty = var_of_t empty\n\n let create_with (t : var) =\n { empty with state = State_stack.create ~init:t.state.init }\n\n let if_ = if_\n end\n end\n\n module Hash = struct\n type t = Hash_builder.t constraint t = Hash_versioned.t\n [@@deriving equal, compare, sexp, yojson, hash]\n\n type var = Hash_builder.var\n\n [%%define_locally\n Hash_builder.\n ( of_digest\n , merge\n , empty_hash\n , gen\n , to_bits\n , to_bytes\n , equal_var\n , var_of_t\n , var_of_hash_packed\n , var_to_hash_packed\n , to_base58_check\n , of_base58_check_exn\n , typ )]\n end\n\n module Merkle_tree = struct\n type t = Merkle_tree_versioned.t [@@deriving sexp, to_yojson]\n\n let (_ :\n ( t\n , (Hash.t, Stack_id.t, Stack.t) Sparse_ledger_lib.Sparse_ledger.T.t\n )\n Type_equal.t ) =\n Type_equal.T\n\n module M = Sparse_ledger_lib.Sparse_ledger.Make (Hash) (Stack_id) (Stack)\n\n [%%define_locally\n M.\n ( of_hash\n , get_exn\n , path_exn\n , set_exn\n , find_index_exn\n , add_path\n , merkle_root )]\n end\n\n module Checked = struct\n type var = Hash.var\n\n module Merkle_tree =\n Snarky_backendless.Merkle_tree.Checked\n (Tick)\n (struct\n type value = Field.t\n\n type var = Field.Var.t\n\n let typ = Field.typ\n\n let merge ~height h1 h2 =\n Tick.make_checked (fun () ->\n Random_oracle.Checked.hash\n ~init:(Hash_prefix.coinbase_merkle_tree height)\n [| h1; h2 |] )\n\n let assert_equal h1 h2 = Field.Checked.Assert.equal h1 h2\n\n let if_ = Field.Checked.if_\n end)\n (struct\n include Stack\n\n type value = t [@@deriving sexp]\n\n let hash var = hash_var var\n end)\n\n module Path = Merkle_tree.Path\n\n type path = Path.value\n\n module Address = struct\n include Merkle_tree.Address\n end\n\n type _ Request.t +=\n | Coinbase_stack_path : Address.value -> path Request.t\n | Get_coinbase_stack : Address.value -> (Stack.t * path) Request.t\n | Set_coinbase_stack : Address.value * Stack.t -> unit Request.t\n | Set_oldest_coinbase_stack : Address.value * Stack.t -> unit Request.t\n | Find_index_of_newest_stacks :\n Update.Action.t\n -> (Address.value * Address.value) Request.t\n | Find_index_of_oldest_stack : Address.value Request.t\n | Get_previous_stack : State_stack.t Request.t\n\n let reraise_merkle_requests (With { request; respond }) =\n match request with\n | Merkle_tree.Get_path addr ->\n respond (Delegate (Coinbase_stack_path addr))\n | Merkle_tree.Set (addr, stack) ->\n respond (Delegate (Set_coinbase_stack (addr, stack)))\n | Merkle_tree.Get_element addr ->\n respond (Delegate (Get_coinbase_stack addr))\n | _ ->\n unhandled\n\n let get ~depth t addr =\n handle\n (fun () -> Merkle_tree.get_req ~depth (Hash.var_to_hash_packed t) addr)\n reraise_merkle_requests\n\n let%snarkydef_ add_coinbase\n ~(constraint_constants : Genesis_constants.Constraint_constants.t) t\n ({ action; coinbase_amount = amount } : Update.var) ~coinbase_receiver\n ~supercharge_coinbase state_body_hash global_slot =\n let depth = constraint_constants.pending_coinbase_depth in\n let%bind addr1, addr2 =\n request_witness\n Typ.(Address.typ ~depth * Address.typ ~depth)\n As_prover.(\n map (read Update.Action.typ action) ~f:(fun act ->\n Find_index_of_newest_stacks act ))\n in\n let equal_to_zero x = Amount.(equal_var x (var_of_t zero)) in\n let%bind no_update = Update.Action.Checked.no_update action in\n let update_state_stack (stack : Stack.var) =\n (*get previous stack to carry-forward the stack of state body hashes*)\n let%bind previous_state_stack =\n request_witness State_stack.typ\n As_prover.(map (return ()) ~f:(fun () -> Get_previous_stack))\n in\n let stack_initialized = { stack with state = previous_state_stack } in\n let%bind stack_with_state_hash =\n Stack.Checked.push_state state_body_hash global_slot\n stack_initialized\n in\n (*Always update the state body hash unless there are no transactions in this block*)\n Stack.Checked.if_ no_update ~then_:stack ~else_:stack_with_state_hash\n in\n let update_stack1 stack =\n let%bind stack = update_state_stack stack in\n let%bind total_coinbase_amount =\n let coinbase_amount =\n Currency.Amount.var_of_t constraint_constants.coinbase_amount\n in\n let supercharged_coinbase =\n let amt =\n Option.value_exn\n (Currency.Amount.scale constraint_constants.coinbase_amount\n constraint_constants.supercharged_coinbase_factor )\n in\n Currency.Amount.var_of_t amt\n in\n Currency.Amount.Checked.if_ supercharge_coinbase\n ~then_:supercharged_coinbase ~else_:coinbase_amount\n in\n let%bind rem_amount =\n Currency.Amount.Checked.sub total_coinbase_amount amount\n in\n let%bind no_coinbase_in_this_stack =\n Update.Action.Checked.update_two_stacks_coinbase_in_second action\n in\n let%bind amount1_equal_to_zero = equal_to_zero amount in\n let%bind amount2_equal_to_zero = equal_to_zero rem_amount in\n (*if no update then coinbase amount has to be zero*)\n let%bind () =\n with_label __LOC__ (fun () ->\n let%bind check =\n Boolean.equal no_update amount1_equal_to_zero\n in\n Boolean.Assert.is_true check )\n in\n let%bind no_coinbase =\n Boolean.(no_update ||| no_coinbase_in_this_stack)\n in\n (* TODO: Optimize here since we are pushing twice to the same stack *)\n let%bind stack_with_amount1 =\n Stack.Checked.push_coinbase (coinbase_receiver, amount) stack\n in\n let%bind stack_with_amount2 =\n Stack.Checked.push_coinbase\n (coinbase_receiver, rem_amount)\n stack_with_amount1\n in\n chain Stack.if_ no_coinbase ~then_:(return stack)\n ~else_:\n (Stack.if_ amount2_equal_to_zero ~then_:stack_with_amount1\n ~else_:stack_with_amount2 )\n in\n (*This is for the second stack for when transactions in a block occupy\n two trees of the scan state; the second tree will carry-forward the state\n stack from the previous block, push the new state, and may or may not have a coinbase*)\n let update_stack2 (init_stack : Stack.var) (stack0 : Stack.var) =\n let%bind add_coinbase =\n Update.Action.Checked.update_two_stacks_coinbase_in_second action\n in\n let%bind update_state =\n let%bind update_second_stack =\n Update.Action.Checked.update_two_stacks_coinbase_in_first action\n in\n Boolean.(update_second_stack ||| add_coinbase)\n in\n let%bind stack =\n let%bind stack_with_state =\n Stack.Checked.push_state state_body_hash global_slot\n { stack0 with\n state =\n State_stack.create ~init:init_stack.Stack.Poly.state.curr\n }\n in\n Stack.if_ update_state ~then_:stack_with_state ~else_:stack0\n in\n let%bind stack_with_coinbase =\n Stack.Checked.push_coinbase (coinbase_receiver, amount) stack\n in\n Stack.if_ add_coinbase ~then_:stack_with_coinbase ~else_:stack\n in\n (*update the first stack*)\n let%bind root', `Old prev, `New _updated_stack1 =\n handle\n (fun () ->\n Merkle_tree.fetch_and_update_req ~depth\n (Hash.var_to_hash_packed t)\n addr1 ~f:update_stack1 )\n reraise_merkle_requests\n in\n (*update the second stack*)\n let%map root, _, _ =\n handle\n (fun () ->\n Merkle_tree.fetch_and_update_req ~depth root' addr2\n ~f:(update_stack2 prev) )\n reraise_merkle_requests\n in\n Hash.var_of_hash_packed root\n\n let%snarkydef_ pop_coinbases\n ~(constraint_constants : Genesis_constants.Constraint_constants.t) t\n ~proof_emitted =\n let depth = constraint_constants.pending_coinbase_depth in\n let%bind addr =\n request_witness (Address.typ ~depth)\n As_prover.(map (return ()) ~f:(fun _ -> Find_index_of_oldest_stack))\n in\n let%bind prev, prev_path =\n request_witness\n Typ.(Stack.typ * Path.typ ~depth)\n As_prover.(\n map\n (read (Address.typ ~depth) addr)\n ~f:(fun a -> Get_coinbase_stack a))\n in\n let stack_hash = Stack.hash_var in\n let%bind prev_entry_hash = stack_hash prev in\n let%bind () =\n Merkle_tree.implied_root prev_entry_hash addr prev_path\n >>= Field.Checked.Assert.equal (Hash.var_to_hash_packed t)\n in\n let%bind next =\n Stack.if_ proof_emitted ~then_:Stack.Checked.empty ~else_:prev\n in\n let%bind next_entry_hash = stack_hash next in\n let%bind () =\n perform\n (let open As_prover in\n let open Let_syntax in\n let%map addr = read (Address.typ ~depth) addr\n and next = read Stack.typ next in\n Set_oldest_coinbase_stack (addr, next))\n in\n let%map new_root =\n Merkle_tree.implied_root next_entry_hash addr prev_path\n in\n (Hash.var_of_hash_packed new_root, prev)\n end\n\n module Poly = struct\n type ('tree, 'stack_id) t = ('tree, 'stack_id) A.Poly.t =\n { tree : 'tree; pos_list : 'stack_id list; new_pos : 'stack_id }\n [@@deriving sexp, to_yojson]\n end\n\n type t = (Merkle_tree.t, Stack_id.t) Poly.t [@@deriving sexp, to_yojson]\n\n let init_hash = Stack.data_hash Stack.empty\n\n let hash_at_level =\n let cached = ref [| init_hash |] in\n fun i ->\n let len = Array.length !cached in\n ( if i >= len then\n let cur_hash = ref (Array.last !cached) in\n cached :=\n Array.append !cached\n (Array.init\n (i + 1 - len)\n ~f:(fun i ->\n cur_hash :=\n Hash.merge ~height:(i + len - 1) !cur_hash !cur_hash ;\n !cur_hash ) ) ) ;\n !cached.(i)\n\n let create_exn' ~depth () =\n let rec create_path height path key =\n if height < 0 then path\n else\n let hash = hash_at_level height in\n create_path (height - 1)\n ((if key mod 2 = 0 then `Left hash else `Right hash) :: path)\n (key / 2)\n in\n let rec make_tree t key =\n if Stack_id.( > ) key (Stack_id.of_int @@ (Int.pow 2 depth - 1)) then t\n else\n let path = create_path (depth - 1) [] (Stack_id.to_int key) in\n make_tree\n (Merkle_tree.add_path t path key Stack.empty)\n (Or_error.ok_exn (Stack_id.incr_by_one key))\n in\n let root_hash = hash_at_level depth in\n { Poly.tree =\n make_tree (Merkle_tree.of_hash ~depth root_hash) Stack_id.zero\n ; pos_list = []\n ; new_pos = Stack_id.zero\n }\n\n [%%define_locally Or_error.(try_with)]\n\n let create ~depth () = try_with (fun () -> create_exn' ~depth ())\n\n let merkle_root (t : t) = Merkle_tree.merkle_root t.tree\n\n let get_stack (t : t) index =\n try_with (fun () -> Merkle_tree.get_exn t.tree index)\n\n let path (t : t) index =\n try_with (fun () -> Merkle_tree.path_exn t.tree index)\n\n let find_index (t : t) key =\n try_with (fun () -> Merkle_tree.find_index_exn t.tree key)\n\n let next_index ~depth (t : t) =\n if\n Stack_id.equal t.new_pos\n (Stack_id.of_int (max_coinbase_stack_count ~depth - 1))\n then Ok Stack_id.zero\n else Stack_id.incr_by_one t.new_pos\n\n let next_stack_id ~depth t ~is_new_stack =\n if is_new_stack then next_index ~depth t else Ok t.new_pos\n\n let incr_index ~depth (t : t) ~is_new_stack =\n let open Or_error.Let_syntax in\n if is_new_stack then\n let%map new_pos = next_index ~depth t in\n { t with pos_list = t.new_pos :: t.pos_list; new_pos }\n else Ok t\n\n let set_stack ~depth (t : t) index stack ~is_new_stack =\n let open Or_error.Let_syntax in\n let%bind tree =\n try_with (fun () -> Merkle_tree.set_exn t.tree index stack)\n in\n incr_index ~depth { t with tree } ~is_new_stack\n\n let latest_stack_id (t : t) ~is_new_stack =\n if is_new_stack then t.new_pos\n else match List.hd t.pos_list with Some x -> x | None -> Stack_id.zero\n\n let curr_stack_id (t : t) = List.hd t.pos_list\n\n let current_stack t =\n let prev_stack_id =\n Option.value ~default:Stack_id.zero (curr_stack_id t)\n in\n Or_error.try_with (fun () ->\n let index = Merkle_tree.find_index_exn t.tree prev_stack_id in\n Merkle_tree.get_exn t.tree index )\n\n let latest_stack (t : t) ~is_new_stack =\n let open Or_error.Let_syntax in\n let key = latest_stack_id t ~is_new_stack in\n let%bind res =\n Or_error.try_with (fun () ->\n let index = Merkle_tree.find_index_exn t.tree key in\n Merkle_tree.get_exn t.tree index )\n in\n if is_new_stack then\n let%map prev_stack = current_stack t in\n { res with state = State_stack.create ~init:prev_stack.state.curr }\n else Ok res\n\n let oldest_stack_id (t : t) = List.last t.pos_list\n\n let remove_oldest_stack_id t =\n match List.rev t with\n | [] ->\n Or_error.error_string \"No coinbase stack-with-state-hash to pop\"\n | x :: xs ->\n Ok (x, List.rev xs)\n\n let oldest_stack t =\n let open Or_error.Let_syntax in\n let key = Option.value ~default:Stack_id.zero (oldest_stack_id t) in\n let%bind index = find_index t key in\n get_stack t index\n\n let update_stack' ~depth t ~(f : Stack.t -> Stack.t) ~is_new_stack =\n let open Or_error.Let_syntax in\n let key = latest_stack_id t ~is_new_stack in\n let%bind stack_index = find_index t key in\n let%bind stack_before = get_stack t stack_index in\n let stack_after = f stack_before in\n (* state hash in \"after\" stack becomes previous state hash at top level *)\n set_stack ~depth t stack_index stack_after ~is_new_stack\n\n let add_coinbase ~depth t ~coinbase ~is_new_stack =\n update_stack' ~depth t ~f:(Stack.push_coinbase coinbase) ~is_new_stack\n\n let add_state ~depth t state_body_hash global_slot ~is_new_stack =\n update_stack' ~depth t\n ~f:(Stack.push_state state_body_hash global_slot)\n ~is_new_stack\n\n let update_coinbase_stack ~depth (t : t) stack ~is_new_stack =\n update_stack' ~depth t ~f:(fun _ -> stack) ~is_new_stack\n\n let remove_coinbase_stack ~depth (t : t) =\n let open Or_error.Let_syntax in\n let%bind oldest_stack, remaining = remove_oldest_stack_id t.pos_list in\n let%bind stack_index = find_index t oldest_stack in\n let%bind stack = get_stack t stack_index in\n let%map t' =\n set_stack ~depth t stack_index Stack.empty ~is_new_stack:false\n in\n (stack, { t' with pos_list = remaining })\n\n let hash_extra ({ pos_list; new_pos; _ } : t) =\n let h = Digestif.SHA256.init () in\n let h =\n Digestif.SHA256.feed_string h\n (List.fold pos_list ~init:\"\" ~f:(fun s a -> s ^ Stack_id.to_string a))\n in\n let h = Digestif.SHA256.feed_string h (Stack_id.to_string new_pos) in\n Digestif.SHA256.(get h |> to_raw_string)\n\n let handler ~depth (t : t) ~is_new_stack =\n let pending_coinbase = ref t in\n let coinbase_stack_path_exn idx =\n List.map\n (path !pending_coinbase idx |> Or_error.ok_exn)\n ~f:(function `Left h -> h | `Right h -> h)\n in\n stage (fun (With { request; respond }) ->\n match request with\n | Checked.Coinbase_stack_path idx ->\n let path =\n (coinbase_stack_path_exn idx :> Random_oracle.Digest.t list)\n in\n respond (Provide path)\n | Checked.Find_index_of_oldest_stack ->\n let stack_id =\n Option.value ~default:Stack_id.zero\n (oldest_stack_id !pending_coinbase)\n in\n let index =\n find_index !pending_coinbase stack_id |> Or_error.ok_exn\n in\n respond (Provide index)\n | Checked.Find_index_of_newest_stacks _action ->\n let index1 =\n let stack_id =\n latest_stack_id !pending_coinbase ~is_new_stack\n in\n find_index !pending_coinbase stack_id |> Or_error.ok_exn\n in\n let index2 =\n let stack_id =\n match\n next_stack_id ~depth !pending_coinbase ~is_new_stack\n with\n | Ok id ->\n id\n | _ ->\n Stack_id.zero\n in\n find_index !pending_coinbase stack_id |> Or_error.ok_exn\n in\n respond @@ Provide (index1, index2)\n | Checked.Get_coinbase_stack idx ->\n let elt = get_stack !pending_coinbase idx |> Or_error.ok_exn in\n let path =\n (coinbase_stack_path_exn idx :> Random_oracle.Digest.t list)\n in\n respond (Provide (elt, path))\n | Checked.Set_coinbase_stack (idx, stack) ->\n pending_coinbase :=\n set_stack ~depth !pending_coinbase idx stack ~is_new_stack\n |> Or_error.ok_exn ;\n respond (Provide ())\n | Checked.Set_oldest_coinbase_stack (idx, stack) ->\n pending_coinbase :=\n set_stack ~depth !pending_coinbase idx stack ~is_new_stack:false\n |> Or_error.ok_exn ;\n respond (Provide ())\n | Checked.Get_previous_stack ->\n let prev_state =\n if is_new_stack then\n let stack =\n current_stack !pending_coinbase |> Or_error.ok_exn\n in\n { State_stack.Poly.init = stack.state.curr\n ; curr = stack.state.curr\n }\n else\n let stack =\n latest_stack !pending_coinbase ~is_new_stack\n |> Or_error.ok_exn\n in\n stack.state\n in\n respond (Provide prev_state)\n | _ ->\n unhandled )\n end\n\n include T\n\n module Poly_versioned = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type ('tree, 'stack_id) t = ('tree, 'stack_id) T.Poly.t =\n { tree : 'tree; pos_list : 'stack_id list; new_pos : 'stack_id }\n [@@deriving sexp, to_yojson]\n end\n end]\n end\n\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V2 = struct\n type t =\n ( Merkle_tree_versioned.Stable.V2.t\n , Stack_id.Stable.V1.t )\n Poly_versioned.Stable.V1.t\n [@@deriving sexp, to_yojson]\n\n let (_ : (t, T.t) Type_equal.t) = Type_equal.T\n\n let to_latest = Fn.id\n end\n end]\n\n let (_ : (t, Stable.Latest.t) Type_equal.t) = Type_equal.T\n\n let%test_unit \"add stack + remove stack = initial tree \" =\n let constraint_constants =\n Genesis_constants.Constraint_constants.for_unit_tests\n in\n let depth = constraint_constants.pending_coinbase_depth in\n let coinbases_gen =\n Quickcheck.Generator.list_non_empty\n (Coinbase.Gen.gen ~constraint_constants)\n in\n let pending_coinbases = ref (create ~depth () |> Or_error.ok_exn) in\n Quickcheck.test coinbases_gen ~trials:50 ~f:(fun cbs ->\n Run_in_thread.block_on_async_exn (fun () ->\n let is_new_stack = ref true in\n let init = merkle_root !pending_coinbases in\n let after_adding =\n List.fold cbs ~init:!pending_coinbases\n ~f:(fun acc (coinbase, _) ->\n let t =\n add_coinbase ~depth acc ~coinbase\n ~is_new_stack:!is_new_stack\n |> Or_error.ok_exn\n in\n is_new_stack := false ;\n t )\n in\n let _, after_del =\n remove_coinbase_stack ~depth after_adding |> Or_error.ok_exn\n in\n pending_coinbases := after_del ;\n assert (Hash.equal (merkle_root after_del) init) ;\n Async_kernel.Deferred.return () ) )\n\n module type Pending_coinbase_intf = sig\n type t [@@deriving sexp]\n\n val add_coinbase :\n depth:int -> t -> coinbase:Coinbase.t -> is_new_stack:bool -> t Or_error.t\n\n val add_state :\n depth:int\n -> t\n -> State_body_hash.t\n -> Mina_numbers.Global_slot_since_genesis.t\n -> is_new_stack:bool\n -> t Or_error.t\n end\n\n let add_coinbase_with_zero_checks (type t)\n (module T : Pending_coinbase_intf with type t = t) (t : t)\n ~(constraint_constants : Genesis_constants.Constraint_constants.t)\n ~coinbase ~supercharged_coinbase ~state_body_hash ~global_slot\n ~is_new_stack =\n let depth = constraint_constants.pending_coinbase_depth in\n if Amount.equal coinbase.Coinbase.amount Amount.zero then t\n else\n let max_coinbase_amount =\n if supercharged_coinbase then\n Option.value_exn\n (Currency.Amount.scale constraint_constants.coinbase_amount\n constraint_constants.supercharged_coinbase_factor )\n else constraint_constants.coinbase_amount\n in\n let coinbase' =\n Coinbase.create\n ~amount:\n (Option.value_exn (Amount.sub max_coinbase_amount coinbase.amount))\n ~receiver:coinbase.receiver ~fee_transfer:None\n |> Or_error.ok_exn\n in\n let t_with_state =\n T.add_state ~depth t state_body_hash global_slot ~is_new_stack\n |> Or_error.ok_exn\n in\n (*add coinbase to the same stack*)\n let interim_tree =\n T.add_coinbase ~depth t_with_state ~coinbase ~is_new_stack:false\n |> Or_error.ok_exn\n in\n if Amount.equal coinbase'.amount Amount.zero then interim_tree\n else\n T.add_coinbase ~depth interim_tree ~coinbase:coinbase'\n ~is_new_stack:false\n |> Or_error.ok_exn\n\n let%test_unit \"Checked_stack = Unchecked_stack\" =\n let open Quickcheck in\n let constraint_constants =\n Genesis_constants.Constraint_constants.for_unit_tests\n in\n test ~trials:20\n (Generator.tuple2 Stack.gen (Coinbase.Gen.gen ~constraint_constants))\n ~f:(fun (base, (cb, _supercharged_coinbase)) ->\n let coinbase_data = Coinbase_data.of_coinbase cb in\n let unchecked = Stack.push_coinbase cb base in\n let checked =\n let comp =\n let open Snark_params.Tick in\n let cb_var = Coinbase_data.(var_of_t coinbase_data) in\n let%map res =\n Stack.Checked.push_coinbase cb_var (Stack.var_of_t base)\n in\n As_prover.read Stack.typ res\n in\n Or_error.ok_exn (run_and_check comp)\n in\n assert (Stack.equal unchecked checked) )\n\n let%test_unit \"Checked_tree = Unchecked_tree\" =\n let open Quickcheck in\n let constraint_constants =\n Genesis_constants.Constraint_constants.for_unit_tests\n in\n let depth = constraint_constants.pending_coinbase_depth in\n let pending_coinbases = create ~depth () |> Or_error.ok_exn in\n test ~trials:20\n (Generator.tuple3\n (Coinbase.Gen.gen ~constraint_constants)\n State_body_hash.gen Mina_numbers.Global_slot_since_genesis.gen )\n ~f:(fun ( (coinbase, `Supercharged_coinbase supercharged_coinbase)\n , state_body_hash\n , global_slot ) ->\n let amount = coinbase.amount in\n let is_new_stack, action =\n Currency.Amount.(\n if equal coinbase.amount zero then (true, Update.Action.Update_none)\n else (true, Update_one))\n in\n let unchecked =\n add_coinbase_with_zero_checks ~constraint_constants\n (module T)\n pending_coinbases ~coinbase ~is_new_stack ~state_body_hash\n ~global_slot ~supercharged_coinbase\n in\n (* inside the `open' below, Checked means something else, so define this function *)\n let f_add_coinbase = Checked.add_coinbase ~constraint_constants in\n let checked_merkle_root =\n let comp =\n let open Snark_params.Tick in\n let amount_var = Amount.var_of_t amount in\n let action_var = Update.Action.var_of_t action in\n let coinbase_receiver_var =\n Public_key.Compressed.var_of_t coinbase.receiver\n in\n let supercharge_coinbase_var =\n Boolean.var_of_value supercharged_coinbase\n in\n let state_body_hash_var =\n State_body_hash.var_of_t state_body_hash\n in\n let global_slot_var =\n Mina_numbers.Global_slot_since_genesis.Checked.constant\n global_slot\n in\n let%map result =\n handle\n (fun () ->\n f_add_coinbase\n (Hash.var_of_t (merkle_root pending_coinbases))\n { Update.Poly.action = action_var\n ; coinbase_amount = amount_var\n }\n ~coinbase_receiver:coinbase_receiver_var\n ~supercharge_coinbase:supercharge_coinbase_var\n state_body_hash_var global_slot_var )\n (unstage (handler ~depth pending_coinbases ~is_new_stack))\n in\n As_prover.read Hash.typ result\n in\n Or_error.ok_exn (run_and_check comp)\n in\n assert (Hash.equal (merkle_root unchecked) checked_merkle_root) )\n\n let%test_unit \"Checked_tree = Unchecked_tree after pop\" =\n let open Quickcheck in\n let constraint_constants =\n Genesis_constants.Constraint_constants.for_unit_tests\n in\n let depth = constraint_constants.pending_coinbase_depth in\n test ~trials:20\n (Generator.tuple3\n (Coinbase.Gen.gen ~constraint_constants)\n State_body_hash.gen Mina_numbers.Global_slot_since_genesis.gen )\n ~f:(fun ( (coinbase, `Supercharged_coinbase supercharged_coinbase)\n , state_body_hash\n , global_slot ) ->\n let pending_coinbases = create ~depth () |> Or_error.ok_exn in\n let amount = coinbase.amount in\n let action =\n Currency.Amount.(\n if equal coinbase.amount zero then Update.Action.Update_none\n else Update_one)\n in\n let unchecked =\n add_coinbase_with_zero_checks ~constraint_constants\n (module T)\n pending_coinbases ~coinbase ~is_new_stack:true ~state_body_hash\n ~global_slot ~supercharged_coinbase\n in\n (* inside the `open' below, Checked means something else, so define these functions *)\n let f_add_coinbase = Checked.add_coinbase ~constraint_constants in\n let f_pop_coinbase = Checked.pop_coinbases ~constraint_constants in\n let checked_merkle_root =\n let comp =\n let open Snark_params.Tick in\n let amount_var = Amount.var_of_t amount in\n let action_var = Update.Action.(var_of_t action) in\n let coinbase_receiver_var =\n Public_key.Compressed.var_of_t coinbase.receiver\n in\n let supercharge_coinbase_var =\n Boolean.var_of_value supercharged_coinbase\n in\n let state_body_hash_var =\n State_body_hash.var_of_t state_body_hash\n in\n let global_slot_var =\n Mina_numbers.Global_slot_since_genesis.Checked.constant\n global_slot\n in\n let%map result =\n handle\n (fun () ->\n f_add_coinbase\n (Hash.var_of_t (merkle_root pending_coinbases))\n { Update.Poly.action = action_var\n ; coinbase_amount = amount_var\n }\n ~coinbase_receiver:coinbase_receiver_var\n ~supercharge_coinbase:supercharge_coinbase_var\n state_body_hash_var global_slot_var )\n (unstage (handler ~depth pending_coinbases ~is_new_stack:true))\n in\n As_prover.read Hash.typ result\n in\n Or_error.ok_exn (run_and_check comp)\n in\n assert (Hash.equal (merkle_root unchecked) checked_merkle_root) ;\n (*deleting the coinbase stack we just created. therefore if there was no update then don't try to delete*)\n let proof_emitted = not Update.Action.(equal action Update_none) in\n let unchecked_after_pop =\n if proof_emitted then\n remove_coinbase_stack ~depth unchecked |> Or_error.ok_exn |> snd\n else unchecked\n in\n let checked_merkle_root_after_pop =\n let comp =\n let open Snark_params.Tick in\n let%map current, _previous =\n handle\n (fun () ->\n f_pop_coinbase ~proof_emitted:Boolean.true_\n (Hash.var_of_t checked_merkle_root) )\n (unstage (handler ~depth unchecked ~is_new_stack:false))\n in\n As_prover.read Hash.typ current\n in\n Or_error.ok_exn (run_and_check comp)\n in\n assert (\n Hash.equal\n (merkle_root unchecked_after_pop)\n checked_merkle_root_after_pop ) )\n\n let%test_unit \"push and pop multiple stacks\" =\n let open Quickcheck in\n let module Pending_coinbase = T in\n let constraint_constants =\n { Genesis_constants.Constraint_constants.for_unit_tests with\n pending_coinbase_depth = 3\n }\n in\n let depth = constraint_constants.pending_coinbase_depth in\n let t_of_coinbases t = function\n | [] ->\n let t' =\n Pending_coinbase.incr_index ~depth t ~is_new_stack:true\n |> Or_error.ok_exn\n in\n (Pending_coinbase.Stack.empty, t')\n | ( (initial_coinbase, _supercharged_coinbase)\n , state_body_hash\n , global_slot )\n :: coinbases ->\n let t' =\n Pending_coinbase.add_state ~depth t state_body_hash global_slot\n ~is_new_stack:true\n |> Or_error.ok_exn\n |> Pending_coinbase.add_coinbase ~depth ~coinbase:initial_coinbase\n ~is_new_stack:false\n |> Or_error.ok_exn\n in\n let updated =\n List.fold coinbases ~init:t'\n ~f:(fun\n pending_coinbases\n ( (coinbase, `Supercharged_coinbase supercharged_coinbase)\n , state_body_hash\n , global_slot )\n ->\n add_coinbase_with_zero_checks ~constraint_constants\n (module Pending_coinbase)\n pending_coinbases ~coinbase ~is_new_stack:false\n ~state_body_hash ~global_slot ~supercharged_coinbase )\n in\n let new_stack =\n Or_error.ok_exn\n @@ Pending_coinbase.latest_stack updated ~is_new_stack:false\n in\n (new_stack, updated)\n in\n (* Create pending coinbase stacks from coinbase lists and add it to the pending coinbase merkle tree *)\n let add coinbase_lists pending_coinbases =\n List.fold ~init:([], pending_coinbases) coinbase_lists\n ~f:(fun (stacks, pc) coinbases ->\n let new_stack, pc = t_of_coinbases pc coinbases in\n (new_stack :: stacks, pc) )\n in\n (* remove the oldest stack and check if that's the expected one *)\n let remove_check t expected_stack =\n let popped_stack, updated_pending_coinbases =\n Pending_coinbase.remove_coinbase_stack ~depth t |> Or_error.ok_exn\n in\n assert (Pending_coinbase.Stack.equal_data popped_stack expected_stack) ;\n updated_pending_coinbases\n in\n let add_remove_check coinbase_lists =\n let max_coinbase_stack_count =\n Pending_coinbase.max_coinbase_stack_count ~depth\n in\n let pending_coinbases = Pending_coinbase.create_exn' ~depth () in\n let rec go coinbase_lists pc =\n if List.is_empty coinbase_lists then ()\n else\n let coinbase_lists' =\n List.take coinbase_lists max_coinbase_stack_count\n in\n let added_stacks, pending_coinbases_updated =\n add coinbase_lists' pc\n in\n let pending_coinbases' =\n List.fold ~init:pending_coinbases_updated (List.rev added_stacks)\n ~f:(fun pc expected_stack -> remove_check pc expected_stack)\n in\n let remaining_lists =\n List.drop coinbase_lists max_coinbase_stack_count\n in\n go remaining_lists pending_coinbases'\n in\n go coinbase_lists pending_coinbases\n in\n let coinbase_lists_gen =\n Quickcheck.Generator.(\n list\n (list\n (Generator.tuple3\n (Coinbase.Gen.gen ~constraint_constants)\n State_body_hash.gen Mina_numbers.Global_slot_since_genesis.gen ) ))\n in\n test ~trials:100 coinbase_lists_gen ~f:add_remove_check\nend\n\ninclude Wire_types.Make (Make_sig) (Make_str)\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Mina_base_util\nopen Fold_lib\nopen Snark_params.Tick\nmodule Wire_types = Mina_wire_types.Mina_base.Staged_ledger_hash\n\nmodule Make_sig (A : Wire_types.Types.S) = struct\n module type S =\n Staged_ledger_hash_intf.Full\n with type Aux_hash.t = A.Aux_hash.t\n and type Pending_coinbase_aux.t = A.Pending_coinbase_aux.V1.t\n and type t = A.V1.t\n and type Stable.V1.t = A.V1.t\nend\n\nmodule Make_str (A : Wire_types.Concrete) = struct\n module Aux_hash = struct\n let length_in_bits = 256\n\n let length_in_bytes = length_in_bits / 8\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = string [@@deriving sexp, equal, compare, hash]\n\n let to_latest = Fn.id\n\n module Base58_check = Base58_check.Make (struct\n let description = \"Aux hash\"\n\n let version_byte =\n Base58_check.Version_bytes.staged_ledger_hash_aux_hash\n end)\n\n let to_base58_check s = Base58_check.encode s\n\n let of_base58_check_exn s = Base58_check.decode_exn s\n\n let to_yojson s = `String (to_base58_check s)\n\n let of_yojson = function\n | `String s -> (\n match Base58_check.decode s with\n | Error e ->\n Error\n (sprintf \"Aux_hash.of_yojson, bad Base58Check:%s\"\n (Error.to_string_hum e) )\n | Ok x ->\n Ok x )\n | _ ->\n Error \"Aux_hash.of_yojson expected `String\"\n end\n end]\n\n [%%define_locally\n Stable.Latest.\n ( to_yojson\n , of_yojson\n , to_base58_check\n , of_base58_check_exn\n , compare\n , sexp_of_t )]\n\n let of_bytes = Fn.id\n\n let to_bytes = Fn.id\n\n let dummy : t = String.init length_in_bytes ~f:(fun _ -> '\\000')\n\n let of_sha256 : Digestif.SHA256.t -> t =\n Fn.compose of_bytes Digestif.SHA256.to_raw_string\n\n let gen : t Quickcheck.Generator.t =\n let char_generator =\n Base_quickcheck.Generator.of_list\n [ '0'\n ; '1'\n ; '2'\n ; '3'\n ; '4'\n ; '5'\n ; '6'\n ; '7'\n ; '8'\n ; '9'\n ; 'A'\n ; 'B'\n ; 'C'\n ; 'D'\n ; 'E'\n ; 'F'\n ]\n in\n String.gen_with_length (length_in_bytes * 2) char_generator\n |> Quickcheck.Generator.map\n ~f:(Fn.compose of_sha256 Digestif.SHA256.of_hex)\n end\n\n module Pending_coinbase_aux = struct\n let length_in_bits = 256\n\n let length_in_bytes = length_in_bits / 8\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = string [@@deriving sexp, equal, compare, hash]\n\n let to_latest = Fn.id\n\n module Base58_check = Base58_check.Make (struct\n let description = \"Pending coinbase aux\"\n\n let version_byte =\n Base58_check.Version_bytes.staged_ledger_hash_pending_coinbase_aux\n end)\n\n let to_base58_check s = Base58_check.encode s\n\n let of_base58_check_exn s = Base58_check.decode_exn s\n\n let to_yojson s = `String (to_base58_check s)\n\n let of_yojson = function\n | `String s -> (\n match Base58_check.decode s with\n | Ok x ->\n Ok x\n | Error e ->\n Error\n (sprintf\n \"Pending_coinbase_aux.of_yojson, bad Base58Check:%s\"\n (Error.to_string_hum e) ) )\n | _ ->\n Error \"Pending_coinbase_aux.of_yojson expected `String\"\n end\n end]\n\n [%%define_locally\n Stable.Latest.(to_yojson, of_yojson, to_base58_check, of_base58_check_exn)]\n\n let dummy : t = String.init length_in_bytes ~f:(fun _ -> '\\000')\n end\n\n module Non_snark = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = A.Non_snark.V1.t =\n { ledger_hash : Ledger_hash.Stable.V1.t\n ; aux_hash : Aux_hash.Stable.V1.t\n ; pending_coinbase_aux : Pending_coinbase_aux.Stable.V1.t\n }\n [@@deriving sexp, equal, compare, hash, yojson, fields]\n\n let to_latest = Fn.id\n end\n end]\n\n type value = t [@@deriving sexp, compare, hash, yojson]\n\n let dummy : t Lazy.t =\n lazy\n { ledger_hash = Ledger_hash.empty_hash\n ; aux_hash = Aux_hash.dummy\n ; pending_coinbase_aux = Pending_coinbase_aux.dummy\n }\n\n let genesis ~genesis_ledger_hash : t =\n { ledger_hash = genesis_ledger_hash\n ; aux_hash = Aux_hash.dummy\n ; pending_coinbase_aux = Pending_coinbase_aux.dummy\n }\n\n type var = Boolean.var list\n\n let length_in_bits = 256\n\n let digest ({ ledger_hash; aux_hash; pending_coinbase_aux } : t) =\n let h = Digestif.SHA256.init () in\n let h =\n Digestif.SHA256.feed_string h (Ledger_hash.to_bytes ledger_hash)\n in\n let h = Digestif.SHA256.feed_string h aux_hash in\n let h = Digestif.SHA256.feed_string h pending_coinbase_aux in\n Digestif.SHA256.(get h |> to_raw_string)\n\n let fold t = Fold.string_bits (digest t)\n\n let to_input t =\n let open Random_oracle.Input.Chunked in\n Array.reduce_exn ~f:append\n (Array.of_list_map\n (Fold.to_list (fold t))\n ~f:(fun b -> packed (field_of_bool b, 1)) )\n\n let ledger_hash ({ ledger_hash; _ } : t) = ledger_hash\n\n let aux_hash ({ aux_hash; _ } : t) = aux_hash\n\n let of_ledger_aux_coinbase_hash aux_hash ledger_hash pending_coinbase_aux :\n t =\n { aux_hash; ledger_hash; pending_coinbase_aux }\n\n let var_to_input (t : var) =\n let open Random_oracle.Input.Chunked in\n Array.reduce_exn ~f:append\n (Array.of_list_map t ~f:(fun b -> packed ((b :> Field.Var.t), 1)))\n\n let var_of_t t : var =\n List.map (Fold.to_list @@ fold t) ~f:Boolean.var_of_value\n\n [%%if proof_level = \"check\"]\n\n let warn_improper_transport () = ()\n\n [%%else]\n\n let warn_improper_transport () =\n printf \"WARNING: improperly transporting staged-ledger-hash\\n\"\n\n [%%endif]\n\n let typ : (var, value) Typ.t =\n Typ.transport (Typ.list ~length:length_in_bits Boolean.typ)\n ~there:(Fn.compose Fold.to_list fold) ~back:(fun _ ->\n (* If we put a failwith here, we lose the ability to printf-inspect\n * anything that uses staged-ledger-hashes from within Checked\n * computations. It's useful when debugging to dump the protocol state\n * and so we can just lie here instead. *)\n warn_improper_transport () ; Lazy.force dummy )\n end\n\n module Poly = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type ('non_snark, 'pending_coinbase_hash) t =\n ('non_snark, 'pending_coinbase_hash) A.Poly.V1.t =\n { non_snark : 'non_snark\n ; pending_coinbase_hash : 'pending_coinbase_hash\n }\n [@@deriving sexp, equal, compare, hash, yojson, hlist]\n end\n end]\n end\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n (** Staged ledger hash has two parts\n 1) merkle root of the pending coinbases\n 2) ledger hash, aux hash, and the FIFO order of the coinbase stacks(Non snark).\n Only part 1 is required for blockchain snark computation and therefore the remaining fields of the staged ledger are grouped together as \"Non_snark\"\n *)\n type t =\n ( Non_snark.Stable.V1.t\n , Pending_coinbase.Hash_versioned.Stable.V1.t )\n Poly.Stable.V1.t\n [@@deriving sexp, equal, compare, hash, yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n type ('a, 'b) t_ = ('a, 'b) Poly.t\n\n type value = t [@@deriving sexp, equal, compare, hash]\n\n type var = (Non_snark.var, Pending_coinbase.Hash.var) t_\n\n include Hashable.Make (Stable.Latest)\n\n let ledger_hash ({ non_snark; _ } : t) = Non_snark.ledger_hash non_snark\n\n let aux_hash ({ non_snark; _ } : t) = Non_snark.aux_hash non_snark\n\n let pending_coinbase_aux ({ non_snark; _ } : t) =\n Non_snark.pending_coinbase_aux non_snark\n\n let pending_coinbase_hash ({ pending_coinbase_hash; _ } : t) =\n pending_coinbase_hash\n\n let pending_coinbase_hash_var ({ pending_coinbase_hash; _ } : var) =\n pending_coinbase_hash\n\n let of_aux_ledger_and_coinbase_hash aux_hash ledger_hash pending_coinbase : t\n =\n { non_snark =\n Non_snark.of_ledger_aux_coinbase_hash aux_hash ledger_hash\n (Pending_coinbase.hash_extra pending_coinbase)\n ; pending_coinbase_hash = Pending_coinbase.merkle_root pending_coinbase\n }\n\n let genesis ~(constraint_constants : Genesis_constants.Constraint_constants.t)\n ~genesis_ledger_hash : t =\n let pending_coinbase =\n Pending_coinbase.create ~depth:constraint_constants.pending_coinbase_depth\n ()\n |> Or_error.ok_exn\n in\n { non_snark = Non_snark.genesis ~genesis_ledger_hash\n ; pending_coinbase_hash = Pending_coinbase.merkle_root pending_coinbase\n }\n\n let var_of_t ({ pending_coinbase_hash; non_snark } : t) : var =\n let non_snark = Non_snark.var_of_t non_snark in\n let pending_coinbase_hash =\n Pending_coinbase.Hash.var_of_t pending_coinbase_hash\n in\n { non_snark; pending_coinbase_hash }\n\n let to_input ({ non_snark; pending_coinbase_hash } : t) =\n Random_oracle.Input.Chunked.(\n append\n (Non_snark.to_input non_snark)\n (field (pending_coinbase_hash :> Field.t)))\n\n let var_to_input ({ non_snark; pending_coinbase_hash } : var) =\n Random_oracle.Input.Chunked.(\n append\n (Non_snark.var_to_input non_snark)\n (field (Pending_coinbase.Hash.var_to_hash_packed pending_coinbase_hash)))\n\n let typ : (var, t) Typ.t =\n Typ.of_hlistable\n [ Non_snark.typ; Pending_coinbase.Hash.typ ]\n ~var_to_hlist:Poly.to_hlist ~var_of_hlist:Poly.of_hlist\n ~value_to_hlist:Poly.to_hlist ~value_of_hlist:Poly.of_hlist\nend\n\ninclude Wire_types.Make (Make_sig) (Make_str)\n","open Core_kernel\nopen Mina_base_util\nopen Mina_base_import\nmodule Wire_types = Mina_wire_types.Mina_base.Sok_message\n\nmodule Make_sig (A : Wire_types.Types.S) = struct\n module type S = Sok_message_intf.Full with type Digest.t = A.Digest.V1.t\nend\n\nmodule Make_str (A : Wire_types.Concrete) = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t =\n { fee : Currency.Fee.Stable.V1.t\n ; prover : Public_key.Compressed.Stable.V1.t\n }\n [@@deriving sexp, yojson, equal, compare]\n\n let to_latest = Fn.id\n end\n end]\n\n let create ~fee ~prover = Stable.Latest.{ fee; prover }\n\n module Digest = struct\n let length_in_bytes = Blake2.digest_size_in_bytes\n\n [%%versioned_binable\n module Stable = struct\n module V1 = struct\n type t = string [@@deriving sexp, hash, compare, equal, yojson]\n\n let to_latest = Fn.id\n\n include\n Binable.Of_binable_without_uuid\n (Core_kernel.String.Stable.V1)\n (struct\n type nonrec t = t\n\n let to_binable = Fn.id\n\n let of_binable s =\n assert (String.length s = length_in_bytes) ;\n s\n end)\n\n open Snark_params.Tick\n\n let to_input t =\n Random_oracle.Input.Chunked.packeds\n (Array.of_list_map\n Fold_lib.Fold.(to_list (string_bits t))\n ~f:(fun b -> (field_of_bool b, 1)) )\n\n let typ =\n Typ.array ~length:Blake2.digest_size_in_bits Boolean.typ\n |> Typ.transport ~there:Blake2.string_to_bits\n ~back:Blake2.bits_to_string\n end\n end]\n\n module Checked = struct\n open Snark_params.Tick\n\n type t = Boolean.var array\n\n let to_input (t : t) =\n Random_oracle.Input.Chunked.packeds\n (Array.map t ~f:(fun b -> ((b :> Field.Var.t), 1)))\n end\n\n [%%define_locally Stable.Latest.(to_input, typ)]\n\n let default = String.init length_in_bytes ~f:(fun _ -> '\\000')\n end\n\n let digest t =\n Blake2.to_raw_string\n (Blake2.digest_string (Binable.to_string (module Stable.Latest) t))\nend\n\ninclude Wire_types.Make (Make_sig) (Make_str)\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Snark_params.Tick\nmodule T = Mina_numbers.Length\n\n(*constants actually required for blockchain snark*)\n(* k\n ,c\n ,slots_per_epoch\n ,slots_per_sub_window\n ,sub_windows_per_window\n ,checkpoint_window_size_in_slots\n ,block_window_duration_ms*)\n\nmodule Poly = Genesis_constants.Protocol.Poly\n\nmodule Value = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t =\n (T.Stable.V1.t, T.Stable.V1.t, Block_time.Stable.V1.t) Poly.Stable.V1.t\n [@@deriving equal, ord, hash, sexp, yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n let gen : t Quickcheck.Generator.t =\n let open Quickcheck.Let_syntax in\n let%bind k = Int.gen_incl 1 5000 in\n let%bind delta = Int.gen_incl 0 5000 in\n let%bind slots_per_epoch = Int.gen_incl k (8 * k) >>| ( * ) 3 >>| T.of_int\n and slots_per_sub_window = Int.gen_incl 1 ((k + 9) / 9) in\n (*TODO: Bug -> Block_time.(to_time x |> of_time) != x for certain values.\n Eg: 34702788243129 <--> 34702788243128, 8094 <--> 8093*)\n let%bind ms = Int64.(gen_log_uniform_incl 0L 9999999999999L) in\n let end_time = Block_time.of_int64 999999999999999L in\n let%map genesis_state_timestamp =\n Block_time.(gen_incl (of_int64 ms) end_time)\n in\n { Poly.k = T.of_int k\n ; delta = T.of_int delta\n ; slots_per_epoch\n ; slots_per_sub_window = T.of_int slots_per_sub_window\n ; genesis_state_timestamp\n }\nend\n\ntype value = Value.t\n\nlet value_of_t (t : Genesis_constants.Protocol.t) : value =\n { k = T.of_int t.k\n ; delta = T.of_int t.delta\n ; slots_per_epoch = T.of_int t.slots_per_epoch\n ; slots_per_sub_window = T.of_int t.slots_per_sub_window\n ; genesis_state_timestamp = Block_time.of_int64 t.genesis_state_timestamp\n }\n\nlet t_of_value (v : value) : Genesis_constants.Protocol.t =\n { k = T.to_int v.k\n ; delta = T.to_int v.delta\n ; slots_per_epoch = T.to_int v.slots_per_epoch\n ; slots_per_sub_window = T.to_int v.slots_per_sub_window\n ; genesis_state_timestamp = Block_time.to_int64 v.genesis_state_timestamp\n }\n\nlet to_input (t : value) =\n Array.reduce_exn ~f:Random_oracle.Input.Chunked.append\n [| T.to_input t.k\n ; T.to_input t.delta\n ; T.to_input t.slots_per_epoch\n ; T.to_input t.slots_per_sub_window\n ; Block_time.to_input t.genesis_state_timestamp\n |]\n\n[%%if defined consensus_mechanism]\n\ntype var = (T.Checked.t, T.Checked.t, Block_time.Checked.t) Poly.t\n\nlet typ =\n Typ.of_hlistable\n [ T.Checked.typ\n ; T.Checked.typ\n ; T.Checked.typ\n ; T.Checked.typ\n ; Block_time.Checked.typ\n ]\n ~var_to_hlist:Poly.to_hlist ~var_of_hlist:Poly.of_hlist\n ~value_to_hlist:Poly.to_hlist ~value_of_hlist:Poly.of_hlist\n\nlet var_to_input (var : var) =\n let k = T.Checked.to_input var.k\n and delta = T.Checked.to_input var.delta\n and slots_per_epoch = T.Checked.to_input var.slots_per_epoch\n and slots_per_sub_window = T.Checked.to_input var.slots_per_sub_window in\n let genesis_state_timestamp =\n Block_time.Checked.to_input var.genesis_state_timestamp\n in\n Array.reduce_exn ~f:Random_oracle.Input.Chunked.append\n [| k\n ; delta\n ; slots_per_epoch\n ; slots_per_sub_window\n ; genesis_state_timestamp\n |]\n\nlet%test_unit \"value = var\" =\n let compiled = Genesis_constants.for_unit_tests.protocol in\n let test protocol_constants =\n let open Snarky_backendless in\n let p_var =\n let%map p = exists typ ~compute:(As_prover0.return protocol_constants) in\n As_prover0.read typ p\n in\n let res = Or_error.ok_exn (run_and_check p_var) in\n [%test_eq: Value.t] res protocol_constants ;\n [%test_eq: Value.t] protocol_constants\n (t_of_value protocol_constants |> value_of_t)\n in\n Quickcheck.test ~trials:100 Value.gen\n ~examples:[ value_of_t compiled ]\n ~f:test\n\n[%%endif]\n","open Core_kernel\nopen Signature_lib\n\n[%%versioned\nmodule Stable = struct\n module V1 = struct\n type t = Mina_wire_types.Mina_base.Fee_with_prover.V1.t =\n { fee : Currency.Fee.Stable.V1.t\n ; prover : Public_key.Compressed.Stable.V1.t\n }\n [@@deriving sexp, yojson, hash]\n\n let to_latest = Fn.id\n\n module T = struct\n type typ = t [@@deriving sexp]\n\n type t = typ [@@deriving sexp]\n\n (* TODO: Compare in a better way than with public key, like in transaction pool *)\n let compare t1 t2 =\n let r = Currency.Fee.compare t1.fee t2.fee in\n if Int.( <> ) r 0 then r\n else Public_key.Compressed.compare t1.prover t2.prover\n end\n\n include Comparable.Make (T)\n end\nend]\n\ninclude Comparable.Make (Stable.V1.T)\n\nlet gen =\n Quickcheck.Generator.map2 Currency.Fee.gen Public_key.Compressed.gen\n ~f:(fun fee prover -> { fee; prover })\n","open Core_kernel\nopen Mina_base\n\nmodule Poly = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type 'command t = 'command Mina_wire_types.Mina_transaction.Poly.V2.t =\n | Command of 'command\n | Fee_transfer of Fee_transfer.Stable.V2.t\n | Coinbase of Coinbase.Stable.V1.t\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n\n let map t ~f =\n match t with\n | Command x ->\n Command (f x)\n | Fee_transfer x ->\n Fee_transfer x\n | Coinbase x ->\n Coinbase x\n end\n end]\nend\n\nmodule Valid = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t = User_command.Valid.Stable.V2.t Poly.Stable.V2.t\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n include Hashable.Make (Stable.Latest)\n include Comparable.Make (Stable.Latest)\nend\n\n[%%versioned\nmodule Stable = struct\n module V2 = struct\n type t = User_command.Stable.V2.t Poly.Stable.V2.t\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n end\nend]\n\ninclude Hashable.Make (Stable.Latest)\ninclude Comparable.Make (Stable.Latest)\n\ntype 'command t_ = 'command Poly.t =\n | Command of 'command\n | Fee_transfer of Fee_transfer.t\n | Coinbase of Coinbase.t\n\nlet to_valid_unsafe :\n t -> [ `If_this_is_used_it_should_have_a_comment_justifying_it of Valid.t ]\n = function\n | Command t ->\n let (`If_this_is_used_it_should_have_a_comment_justifying_it t') =\n User_command.to_valid_unsafe t\n in\n `If_this_is_used_it_should_have_a_comment_justifying_it (Command t')\n | Fee_transfer t ->\n `If_this_is_used_it_should_have_a_comment_justifying_it (Fee_transfer t)\n | Coinbase t ->\n `If_this_is_used_it_should_have_a_comment_justifying_it (Coinbase t)\n\nlet forget : Valid.t -> t = function\n | Command t ->\n Command (User_command.forget_check t)\n | Fee_transfer t ->\n Fee_transfer t\n | Coinbase t ->\n Coinbase t\n\nlet fee_excess : t -> Fee_excess.t Or_error.t = function\n | Command (Signed_command t) ->\n Ok (Signed_command.fee_excess t)\n | Command (Zkapp_command ps) ->\n Ok (Zkapp_command.fee_excess ps)\n | Fee_transfer t ->\n Fee_transfer.fee_excess t\n | Coinbase t ->\n Coinbase.fee_excess t\n\nlet expected_supply_increase = function\n | Command _ | Fee_transfer _ ->\n Ok Currency.Amount.zero\n | Coinbase t ->\n Coinbase.expected_supply_increase t\n\nlet public_keys (t : t) =\n let account_ids =\n match t with\n | Command (Signed_command cmd) ->\n Signed_command.accounts_referenced cmd\n | Command (Zkapp_command t) ->\n Zkapp_command.accounts_referenced t\n | Fee_transfer ft ->\n Fee_transfer.receivers ft\n | Coinbase cb ->\n Coinbase.accounts_referenced cb\n in\n List.map account_ids ~f:Account_id.public_key\n\nlet account_access_statuses (t : t) (status : Transaction_status.t) =\n match t with\n | Command (Signed_command cmd) ->\n Signed_command.account_access_statuses cmd status\n | Command (Zkapp_command t) ->\n Zkapp_command.account_access_statuses t status\n | Fee_transfer ft ->\n assert (Transaction_status.equal Applied status) ;\n List.map (Fee_transfer.receivers ft) ~f:(fun acct_id ->\n (acct_id, `Accessed) )\n | Coinbase cb ->\n Coinbase.account_access_statuses cb status\n\nlet accounts_referenced (t : t) =\n List.map (account_access_statuses t Applied) ~f:(fun (acct_id, _status) ->\n acct_id )\n\nlet fee_payer_pk (t : t) =\n match t with\n | Command (Signed_command cmd) ->\n Signed_command.fee_payer_pk cmd\n | Command (Zkapp_command t) ->\n Zkapp_command.fee_payer_pk t\n | Fee_transfer ft ->\n Fee_transfer.fee_payer_pk ft\n | Coinbase cb ->\n Coinbase.fee_payer_pk cb\n\nlet valid_size ~genesis_constants (t : t) =\n match t with\n | Command cmd ->\n User_command.valid_size ~genesis_constants cmd\n | Fee_transfer _ | Coinbase _ ->\n Ok ()\n\nlet check_well_formedness ~genesis_constants (t : t) =\n match t with\n | Command cmd ->\n User_command.check_well_formedness ~genesis_constants cmd\n | Fee_transfer _ | Coinbase _ ->\n Ok ()\n","open Core_kernel\nopen Mina_base\n\n[%%import \"/src/config.mlh\"]\n\nmodule T = struct\n include Blake2.Make ()\nend\n\ninclude T\n\nmodule Base58_check = Codable.Make_base58_check (struct\n type t = Stable.Latest.t [@@deriving bin_io_unversioned]\n\n let version_byte = Base58_check.Version_bytes.transaction_hash\n\n let description = \"Transaction hash\"\nend)\n\n[%%define_locally\nBase58_check.(of_base58_check, of_base58_check_exn, to_base58_check)]\n\nlet to_yojson t = `String (to_base58_check t)\n\nlet of_yojson = function\n | `String str ->\n Result.map_error (of_base58_check str) ~f:(fun _ ->\n \"Transaction_hash.of_yojson: Error decoding string from base58_check \\\n format\" )\n | _ ->\n Error \"Transaction_hash.of_yojson: Expected a string\"\n\nlet ( hash_signed_command_v1\n , hash_signed_command\n , hash_zkapp_command\n , hash_coinbase\n , hash_fee_transfer ) =\n let mk_hasher (type a) (module M : Bin_prot.Binable.S with type t = a)\n (cmd : a) =\n cmd |> Binable.to_string (module M) |> digest_string\n in\n let signed_cmd_hasher_v1 =\n mk_hasher\n ( module struct\n include Signed_command.Stable.V1\n end )\n in\n let signed_cmd_hasher = mk_hasher (module Signed_command.Stable.Latest) in\n let zkapp_cmd_hasher = mk_hasher (module Zkapp_command.Stable.Latest) in\n (* replace actual signatures, proofs with dummies for hashing, so we can\n reproduce the transaction hashes if signatures, proofs omitted in\n archive db\n *)\n let hash_signed_command_v1 (cmd : Signed_command.Stable.V1.t) =\n let cmd_dummy_signature = { cmd with signature = Signature.dummy } in\n signed_cmd_hasher_v1 cmd_dummy_signature\n in\n let hash_signed_command (cmd : Signed_command.t) =\n let cmd_dummy_signature = { cmd with signature = Signature.dummy } in\n signed_cmd_hasher cmd_dummy_signature\n in\n let hash_zkapp_command (cmd : Zkapp_command.t) =\n let cmd_dummy_signatures_and_proofs =\n { cmd with\n fee_payer = { cmd.fee_payer with authorization = Signature.dummy }\n ; account_updates =\n Zkapp_command.Call_forest.map cmd.account_updates\n ~f:(fun (acct_update : Account_update.t) ->\n let dummy_auth =\n match acct_update.authorization with\n | Control.Proof _ ->\n Control.Proof Proof.transaction_dummy\n | Control.Signature _ ->\n Control.Signature Signature.dummy\n | Control.None_given ->\n Control.None_given\n in\n { acct_update with authorization = dummy_auth } )\n }\n in\n zkapp_cmd_hasher cmd_dummy_signatures_and_proofs\n in\n (* no signatures to replace for internal commands *)\n let hash_coinbase = mk_hasher (module Mina_base.Coinbase.Stable.Latest) in\n let hash_fee_transfer =\n mk_hasher (module Fee_transfer.Single.Stable.Latest)\n in\n ( hash_signed_command_v1\n , hash_signed_command\n , hash_zkapp_command\n , hash_coinbase\n , hash_fee_transfer )\n\n[%%ifdef consensus_mechanism]\n\nlet hash_command cmd =\n match cmd with\n | User_command.Signed_command s ->\n hash_signed_command s\n | User_command.Zkapp_command p ->\n hash_zkapp_command p\n\nlet hash_signed_command_v2 = hash_signed_command\n\nlet hash_of_transaction_id (transaction_id : string) : t Or_error.t =\n (* A transaction id might be:\n - original Base58Check transaction ids of signed commands (Signed_command.V1.t), or\n - a Base64 encoding of signed commands and zkApps (Signed_command.Vn.t, for n >= 2,\n or Zkapp_command.Vm.t, for m >= 1)\n\n For the Base64 case, the Bin_prot serialization leads with a version tag\n *)\n match Signed_command.of_base58_check_exn_v1 transaction_id with\n | Ok cmd_v1 ->\n Ok (hash_signed_command_v1 cmd_v1)\n | Error _ -> (\n match Base64.decode transaction_id with\n | Ok s -> (\n let len = String.length s in\n let buf = Bin_prot.Common.create_buf len in\n Bin_prot.Common.blit_string_buf s buf ~len ;\n let pos_ref = ref 0 in\n let version = Bin_prot.Std.bin_read_int ~pos_ref buf in\n match version with\n | 1 -> (\n (* must be a zkApp command *)\n try\n let cmd = Zkapp_command.Stable.Latest.bin_read_t ~pos_ref buf in\n Ok (hash_zkapp_command cmd)\n with _ ->\n Or_error.error_string\n \"Could not decode serialized zkApp command (version 1)\" )\n | 2 -> (\n (* must be a signed command, until there's a V2 for zkApp commands *)\n try\n let cmd = Signed_command.Stable.V2.bin_read_t ~pos_ref buf in\n Ok (hash_signed_command_v2 cmd)\n with _ ->\n Or_error.error_string\n \"Could not decode serialized signed command (version 2)\" )\n | _ ->\n Or_error.error_string\n (sprintf\n \"Transaction hashing not implemented for command with \\\n version %d\"\n version ) )\n | Error _ ->\n Or_error.error_string\n \"Could not decode transaction id as either Base58Check or Base64\" )\n\nmodule User_command_with_valid_signature = struct\n type hash = T.t [@@deriving sexp, compare, hash]\n\n let hash_to_yojson = to_yojson\n\n let hash_of_yojson = of_yojson\n\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t =\n ( (User_command.Valid.Stable.V2.t[@hash.ignore])\n , (T.Stable.V1.t[@to_yojson hash_to_yojson]) )\n With_hash.Stable.V1.t\n [@@deriving sexp, hash, to_yojson]\n\n let to_latest = Fn.id\n\n (* Compare only on hashes, comparing on the data too would be slower and\n add no value.\n *)\n let compare (x : t) (y : t) = T.compare x.hash y.hash\n end\n end]\n\n let create (c : User_command.Valid.t) : t =\n { data = c; hash = hash_command (User_command.forget_check c) }\n\n let data ({ data; _ } : t) = data\n\n let command ({ data; _ } : t) = User_command.forget_check data\n\n let hash ({ hash; _ } : t) = hash\n\n let forget_check ({ data; hash } : t) =\n { With_hash.data = User_command.forget_check data; hash }\n\n include Comparable.Make (Stable.Latest)\n\n let make data hash : t = { data; hash }\nend\n\nmodule User_command = struct\n type hash = T.t [@@deriving sexp, compare, hash]\n\n let hash_to_yojson = to_yojson\n\n let hash_of_yojson = of_yojson\n\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t =\n ( (User_command.Stable.V2.t[@hash.ignore])\n , (T.Stable.V1.t[@to_yojson hash_to_yojson]) )\n With_hash.Stable.V1.t\n [@@deriving sexp, hash, to_yojson]\n\n let to_latest = Fn.id\n\n (* Compare only on hashes, comparing on the data too would be slower and\n add no value.\n *)\n let compare (x : t) (y : t) = T.compare x.hash y.hash\n end\n end]\n\n let create (c : User_command.t) : t = { data = c; hash = hash_command c }\n\n let data ({ data; _ } : t) = data\n\n let command ({ data; _ } : t) = data\n\n let hash ({ hash; _ } : t) = hash\n\n let of_checked ({ data; hash } : User_command_with_valid_signature.t) : t =\n { With_hash.data = User_command.forget_check data; hash }\n\n include Comparable.Make (Stable.Latest)\nend\n\nlet%test_module \"Transaction hashes\" =\n ( module struct\n let run_test ~transaction_id ~expected_hash =\n let hash =\n match hash_of_transaction_id transaction_id with\n | Ok hash ->\n to_base58_check hash\n | Error err ->\n failwithf \"Error getting hash: %s\" (Error.to_string_hum err) ()\n in\n String.equal hash expected_hash\n\n let%test \"signed command v1 hash from transaction id\" =\n let transaction_id =\n \"BD421DxjdoLimeUh4RA4FEvHdDn6bfxyMVWiWUwbYzQkqhNUv8B5M4gCSREpu9mVueBYoHYWkwB8BMf6iS2jjV8FffvPGkuNeczBfY7YRwLuUGBRCQJ3ktFBrNuu4abqgkYhXmcS2xyzoSGxHbXkJRAokTwjQ9HP6TLSeXz9qa92nJaTeccMnkoZBmEitsZWWnTCMqDc6rhN4Z9UMpg4wzdPMwNJvLRuJBD14Dd5pR84KBoY9rrnv66rHPc4m2hH9QSEt4aEJC76BQ446pHN9ZLmyhrk28f5xZdBmYxp3hV13fJEJ3Gv1XqJMBqFxRhzCVGoKDbLAaNRb5F1u1WxTzJu5n4cMMDEYydGEpNirY2PKQqHkR8gEqjXRTkpZzP8G19qT\"\n in\n let expected_hash =\n \"5JuV53FPXad1QLC46z7wsou9JjjYP87qaUeryscZqLUMmLSg8j2n\"\n in\n run_test ~transaction_id ~expected_hash\n\n let%test \"signed command v2 hash from transaction id\" =\n let transaction_id =\n \"Av0IlDV3VklWpVXVRQr7cidImXn8E9nqCAxPjuyUNZ2pu3pJJxkBAAD//yIAIKTVOZ2q1qG1KT11p6844pWJ3fQug1XGnzv2S3N73azIABXhN3d+nO04Y7YqBul1CY5CEq9o34KWvfcB8IWep3kkAf60JFZJVqVV1UUK+3InSJl5/BPZ6ggMT47slDWdqbt6SScZAQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=\"\n in\n let expected_hash =\n \"5JvBt4173K3t7gQSpFoMGtbtZuYWPSg29cWad5pnnRd9BnAowoqY\"\n in\n run_test ~transaction_id ~expected_hash\n\n (* To regenerate:\n * Run dune in this library's directory\n dune utop src/lib/transaction\n * Generate a zkapp transaction:\n let txn = let txn = Mina_base.Zkapp_command.dummy in {txn with account_updates = Mina_base.Zkapp_command.Call_forest.map txn.account_updates ~f:(fun x -> {x with Mina_base.Account_update.authorization= Proof Mina_base.Proof.blockchain_dummy})};;\n * Print the transaction:\n Core_kernel.Out_channel.with_file \"txn_id\" ~f:(fun file -> Out_channel.output_string file (Core_kernel.Binable.to_string (module Mina_base.User_command.Stable.V2) (Zkapp_command txn) |> Base64.encode |> (function Ok x -> x | Error _ -> \"\")));;\n * Get the hash:\n Mina_transaction.Transaction_hash.(hash_command (Zkapp_command txn) |> to_base58_check);;\n *)\n\n let%test \"zkApp v1 hash from transaction id\" =\n let transaction_id =\n \"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\"\n in\n let expected_hash =\n \"5Jv9H3FWr4Uepj8FWhpMQErTaxuXUuk6zGeVziMSCZM5rdaTvY3B\"\n in\n run_test ~transaction_id ~expected_hash\n end )\n\n[%%endif]\n","open Core_kernel\nopen Mina_base\nopen Currency\nopen Signature_lib\nopen Mina_transaction\nmodule Zkapp_command_logic = Zkapp_command_logic\nmodule Global_slot_since_genesis = Mina_numbers.Global_slot_since_genesis\n\nmodule Transaction_applied = struct\n module UC = Signed_command\n\n module Signed_command_applied = struct\n module Common = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t =\n { user_command : Signed_command.Stable.V2.t With_status.Stable.V2.t\n }\n [@@deriving sexp, to_yojson]\n\n let to_latest = Fn.id\n end\n end]\n end\n\n module Body = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t =\n | Payment of { new_accounts : Account_id.Stable.V2.t list }\n | Stake_delegation of\n { previous_delegate : Public_key.Compressed.Stable.V1.t option }\n | Failed\n [@@deriving sexp, to_yojson]\n\n let to_latest = Fn.id\n end\n end]\n end\n\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t = { common : Common.Stable.V2.t; body : Body.Stable.V2.t }\n [@@deriving sexp, to_yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n let new_accounts (t : t) =\n match t.body with\n | Payment { new_accounts; _ } ->\n new_accounts\n | Stake_delegation _ | Failed ->\n []\n end\n\n module Zkapp_command_applied = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t =\n { accounts :\n (Account_id.Stable.V2.t * Account.Stable.V2.t option) list\n ; command : Zkapp_command.Stable.V1.t With_status.Stable.V2.t\n ; new_accounts : Account_id.Stable.V2.t list\n }\n [@@deriving sexp, to_yojson]\n\n let to_latest = Fn.id\n end\n end]\n end\n\n module Command_applied = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t =\n | Signed_command of Signed_command_applied.Stable.V2.t\n | Zkapp_command of Zkapp_command_applied.Stable.V1.t\n [@@deriving sexp, to_yojson]\n\n let to_latest = Fn.id\n end\n end]\n end\n\n module Fee_transfer_applied = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t =\n { fee_transfer : Fee_transfer.Stable.V2.t With_status.Stable.V2.t\n ; new_accounts : Account_id.Stable.V2.t list\n ; burned_tokens : Currency.Amount.Stable.V1.t\n }\n [@@deriving sexp, to_yojson]\n\n let to_latest = Fn.id\n end\n end]\n end\n\n module Coinbase_applied = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t =\n { coinbase : Coinbase.Stable.V1.t With_status.Stable.V2.t\n ; new_accounts : Account_id.Stable.V2.t list\n ; burned_tokens : Currency.Amount.Stable.V1.t\n }\n [@@deriving sexp, to_yojson]\n\n let to_latest = Fn.id\n end\n end]\n end\n\n module Varying = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t =\n | Command of Command_applied.Stable.V2.t\n | Fee_transfer of Fee_transfer_applied.Stable.V2.t\n | Coinbase of Coinbase_applied.Stable.V2.t\n [@@deriving sexp, to_yojson]\n\n let to_latest = Fn.id\n end\n end]\n end\n\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t =\n { previous_hash : Ledger_hash.Stable.V1.t\n ; varying : Varying.Stable.V2.t\n }\n [@@deriving sexp, to_yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n let burned_tokens : t -> Currency.Amount.t =\n fun { varying; _ } ->\n match varying with\n | Command _ ->\n Currency.Amount.zero\n | Fee_transfer f ->\n f.burned_tokens\n | Coinbase c ->\n c.burned_tokens\n\n let new_accounts : t -> Account_id.t list =\n fun { varying; _ } ->\n match varying with\n | Command c -> (\n match c with\n | Signed_command sc ->\n Signed_command_applied.new_accounts sc\n | Zkapp_command zc ->\n zc.new_accounts )\n | Fee_transfer f ->\n f.new_accounts\n | Coinbase c ->\n c.new_accounts\n\n let supply_increase : t -> Currency.Amount.Signed.t Or_error.t =\n fun t ->\n let open Or_error.Let_syntax in\n let burned_tokens = Currency.Amount.Signed.of_unsigned (burned_tokens t) in\n let account_creation_fees =\n let account_creation_fee_int =\n Genesis_constants.Constraint_constants.compiled.account_creation_fee\n |> Currency.Fee.to_nanomina_int\n in\n let num_accounts_created = List.length @@ new_accounts t in\n (* int type is OK, no danger of overflow *)\n Currency.Amount.(\n Signed.of_unsigned\n @@ of_nanomina_int_exn (account_creation_fee_int * num_accounts_created))\n in\n let txn : Transaction.t =\n match t.varying with\n | Command\n (Signed_command { common = { user_command = { data; _ }; _ }; _ }) ->\n Command (Signed_command data)\n | Command (Zkapp_command c) ->\n Command (Zkapp_command c.command.data)\n | Fee_transfer f ->\n Fee_transfer f.fee_transfer.data\n | Coinbase c ->\n Coinbase c.coinbase.data\n in\n let%bind expected_supply_increase =\n Transaction.expected_supply_increase txn\n in\n let rec process_decreases total = function\n | [] ->\n Some total\n | amt :: amts ->\n let%bind.Option sum =\n Currency.Amount.Signed.(add @@ negate amt) total\n in\n process_decreases sum amts\n in\n let total =\n process_decreases\n (Currency.Amount.Signed.of_unsigned expected_supply_increase)\n [ burned_tokens; account_creation_fees ]\n in\n Option.value_map total ~default:(Or_error.error_string \"overflow\")\n ~f:(fun v -> Ok v)\n\n let transaction_with_status : t -> Transaction.t With_status.t =\n fun { varying; _ } ->\n match varying with\n | Command (Signed_command uc) ->\n With_status.map uc.common.user_command ~f:(fun cmd ->\n Transaction.Command (User_command.Signed_command cmd) )\n | Command (Zkapp_command s) ->\n With_status.map s.command ~f:(fun c ->\n Transaction.Command (User_command.Zkapp_command c) )\n | Fee_transfer f ->\n With_status.map f.fee_transfer ~f:(fun f -> Transaction.Fee_transfer f)\n | Coinbase c ->\n With_status.map c.coinbase ~f:(fun c -> Transaction.Coinbase c)\n\n let transaction_status : t -> Transaction_status.t =\n fun { varying; _ } ->\n match varying with\n | Command\n (Signed_command { common = { user_command = { status; _ }; _ }; _ }) ->\n status\n | Command (Zkapp_command c) ->\n c.command.status\n | Fee_transfer f ->\n f.fee_transfer.status\n | Coinbase c ->\n c.coinbase.status\nend\n\nmodule type S = sig\n type ledger\n\n type location\n\n module Transaction_applied : sig\n module Signed_command_applied : sig\n module Common : sig\n type t = Transaction_applied.Signed_command_applied.Common.t =\n { user_command : Signed_command.t With_status.t }\n [@@deriving sexp]\n end\n\n module Body : sig\n type t = Transaction_applied.Signed_command_applied.Body.t =\n | Payment of { new_accounts : Account_id.t list }\n | Stake_delegation of\n { previous_delegate : Public_key.Compressed.t option }\n | Failed\n [@@deriving sexp]\n end\n\n type t = Transaction_applied.Signed_command_applied.t =\n { common : Common.t; body : Body.t }\n [@@deriving sexp]\n end\n\n module Zkapp_command_applied : sig\n type t = Transaction_applied.Zkapp_command_applied.t =\n { accounts : (Account_id.t * Account.t option) list\n ; command : Zkapp_command.t With_status.t\n ; new_accounts : Account_id.t list\n }\n [@@deriving sexp]\n end\n\n module Command_applied : sig\n type t = Transaction_applied.Command_applied.t =\n | Signed_command of Signed_command_applied.t\n | Zkapp_command of Zkapp_command_applied.t\n [@@deriving sexp]\n end\n\n module Fee_transfer_applied : sig\n type t = Transaction_applied.Fee_transfer_applied.t =\n { fee_transfer : Fee_transfer.t With_status.t\n ; new_accounts : Account_id.t list\n ; burned_tokens : Currency.Amount.t\n }\n [@@deriving sexp]\n end\n\n module Coinbase_applied : sig\n type t = Transaction_applied.Coinbase_applied.t =\n { coinbase : Coinbase.t With_status.t\n ; new_accounts : Account_id.t list\n ; burned_tokens : Currency.Amount.t\n }\n [@@deriving sexp]\n end\n\n module Varying : sig\n type t = Transaction_applied.Varying.t =\n | Command of Command_applied.t\n | Fee_transfer of Fee_transfer_applied.t\n | Coinbase of Coinbase_applied.t\n [@@deriving sexp]\n end\n\n type t = Transaction_applied.t =\n { previous_hash : Ledger_hash.t; varying : Varying.t }\n [@@deriving sexp]\n\n val burned_tokens : t -> Currency.Amount.t\n\n val supply_increase : t -> Currency.Amount.Signed.t Or_error.t\n\n val transaction : t -> Transaction.t With_status.t\n\n val transaction_status : t -> Transaction_status.t\n end\n\n module Global_state : sig\n type t =\n { first_pass_ledger : ledger\n ; second_pass_ledger : ledger\n ; fee_excess : Amount.Signed.t\n ; supply_increase : Amount.Signed.t\n ; protocol_state : Zkapp_precondition.Protocol_state.View.t\n ; block_global_slot : Mina_numbers.Global_slot_since_genesis.t\n (* Slot of block when the transaction is applied. NOTE: This is at least 1 slot after the protocol_state's view, which is for the *previous* slot. *)\n }\n end\n\n module Transaction_partially_applied : sig\n module Zkapp_command_partially_applied : sig\n type t =\n { command : Zkapp_command.t\n ; previous_hash : Ledger_hash.t\n ; original_first_pass_account_states :\n (Account_id.t * (location * Account.t) option) list\n ; constraint_constants : Genesis_constants.Constraint_constants.t\n ; state_view : Zkapp_precondition.Protocol_state.View.t\n ; global_state : Global_state.t\n ; local_state :\n ( Stack_frame.value\n , Stack_frame.value list\n , Amount.Signed.t\n , ledger\n , bool\n , Zkapp_command.Transaction_commitment.t\n , Mina_numbers.Index.t\n , Transaction_status.Failure.Collection.t )\n Zkapp_command_logic.Local_state.t\n }\n end\n\n type 'applied fully_applied =\n { previous_hash : Ledger_hash.t; applied : 'applied }\n\n type t =\n | Signed_command of\n Transaction_applied.Signed_command_applied.t fully_applied\n | Zkapp_command of Zkapp_command_partially_applied.t\n | Fee_transfer of Transaction_applied.Fee_transfer_applied.t fully_applied\n | Coinbase of Transaction_applied.Coinbase_applied.t fully_applied\n\n val command : t -> Transaction.t\n end\n\n val apply_user_command :\n constraint_constants:Genesis_constants.Constraint_constants.t\n -> txn_global_slot:Global_slot_since_genesis.t\n -> ledger\n -> Signed_command.With_valid_signature.t\n -> Transaction_applied.Signed_command_applied.t Or_error.t\n\n val apply_user_command_unchecked :\n constraint_constants:Genesis_constants.Constraint_constants.t\n -> txn_global_slot:Global_slot_since_genesis.t\n -> ledger\n -> Signed_command.t\n -> Transaction_applied.Signed_command_applied.t Or_error.t\n\n val update_action_state :\n Snark_params.Tick.Field.t Pickles_types.Vector.Vector_5.t\n -> Zkapp_account.Actions.t\n -> txn_global_slot:Global_slot_since_genesis.t\n -> last_action_slot:Global_slot_since_genesis.t\n -> Snark_params.Tick.Field.t Pickles_types.Vector.Vector_5.t\n * Global_slot_since_genesis.t\n\n val apply_zkapp_command_unchecked :\n constraint_constants:Genesis_constants.Constraint_constants.t\n -> global_slot:Mina_numbers.Global_slot_since_genesis.t\n -> state_view:Zkapp_precondition.Protocol_state.View.t\n -> ledger\n -> Zkapp_command.t\n -> ( Transaction_applied.Zkapp_command_applied.t\n * ( ( Stack_frame.value\n , Stack_frame.value list\n , Amount.Signed.t\n , ledger\n , bool\n , Zkapp_command.Transaction_commitment.t\n , Mina_numbers.Index.t\n , Transaction_status.Failure.Collection.t )\n Zkapp_command_logic.Local_state.t\n * Amount.Signed.t ) )\n Or_error.t\n\n (** Apply all zkapp_command within a zkapp_command transaction. This behaves as\n [apply_zkapp_command_unchecked], except that the [~init] and [~f] arguments\n are provided to allow for the accumulation of the intermediate states.\n\n Invariant: [f] is always applied at least once, so it is valid to use an\n [_ option] as the initial state and call [Option.value_exn] on the\n accumulated result.\n\n This can be used to collect the intermediate states to make them\n available for snark work. In particular, since the transaction snark has\n a cap on the number of zkapp_command of each kind that may be included, we can\n use this to retrieve the (source, target) pairs for each batch of\n zkapp_command to include in the snark work spec / transaction snark witness.\n *)\n val apply_zkapp_command_unchecked_aux :\n constraint_constants:Genesis_constants.Constraint_constants.t\n -> global_slot:Mina_numbers.Global_slot_since_genesis.t\n -> state_view:Zkapp_precondition.Protocol_state.View.t\n -> init:'acc\n -> f:\n ( 'acc\n -> Global_state.t\n * ( Stack_frame.value\n , Stack_frame.value list\n , Amount.Signed.t\n , ledger\n , bool\n , Zkapp_command.Transaction_commitment.t\n , Mina_numbers.Index.t\n , Transaction_status.Failure.Collection.t )\n Zkapp_command_logic.Local_state.t\n -> 'acc )\n -> ?fee_excess:Amount.Signed.t\n -> ?supply_increase:Amount.Signed.t\n -> ledger\n -> Zkapp_command.t\n -> (Transaction_applied.Zkapp_command_applied.t * 'acc) Or_error.t\n\n val apply_zkapp_command_first_pass_aux :\n constraint_constants:Genesis_constants.Constraint_constants.t\n -> global_slot:Mina_numbers.Global_slot_since_genesis.t\n -> state_view:Zkapp_precondition.Protocol_state.View.t\n -> init:'acc\n -> f:\n ( 'acc\n -> Global_state.t\n * ( Stack_frame.value\n , Stack_frame.value list\n , Amount.Signed.t\n , ledger\n , bool\n , Zkapp_command.Transaction_commitment.t\n , Mina_numbers.Index.t\n , Transaction_status.Failure.Collection.t )\n Zkapp_command_logic.Local_state.t\n -> 'acc )\n -> ?fee_excess:Amount.Signed.t\n -> ?supply_increase:Amount.Signed.t\n -> ledger\n -> Zkapp_command.t\n -> (Transaction_partially_applied.Zkapp_command_partially_applied.t * 'acc)\n Or_error.t\n\n val apply_zkapp_command_second_pass_aux :\n init:'acc\n -> f:\n ( 'acc\n -> Global_state.t\n * ( Stack_frame.value\n , Stack_frame.value list\n , Amount.Signed.t\n , ledger\n , bool\n , Zkapp_command.Transaction_commitment.t\n , Mina_numbers.Index.t\n , Transaction_status.Failure.Collection.t )\n Zkapp_command_logic.Local_state.t\n -> 'acc )\n -> ledger\n -> Transaction_partially_applied.Zkapp_command_partially_applied.t\n -> (Transaction_applied.Zkapp_command_applied.t * 'acc) Or_error.t\n\n val apply_fee_transfer :\n constraint_constants:Genesis_constants.Constraint_constants.t\n -> txn_global_slot:Global_slot_since_genesis.t\n -> ledger\n -> Fee_transfer.t\n -> Transaction_applied.Fee_transfer_applied.t Or_error.t\n\n val apply_coinbase :\n constraint_constants:Genesis_constants.Constraint_constants.t\n -> txn_global_slot:Global_slot_since_genesis.t\n -> ledger\n -> Coinbase.t\n -> Transaction_applied.Coinbase_applied.t Or_error.t\n\n val apply_transaction_first_pass :\n constraint_constants:Genesis_constants.Constraint_constants.t\n -> global_slot:Global_slot_since_genesis.t\n -> txn_state_view:Zkapp_precondition.Protocol_state.View.t\n -> ledger\n -> Transaction.t\n -> Transaction_partially_applied.t Or_error.t\n\n val apply_transaction_second_pass :\n ledger\n -> Transaction_partially_applied.t\n -> Transaction_applied.t Or_error.t\n\n val apply_transactions :\n constraint_constants:Genesis_constants.Constraint_constants.t\n -> global_slot:Mina_numbers.Global_slot_since_genesis.t\n -> txn_state_view:Zkapp_precondition.Protocol_state.View.t\n -> ledger\n -> Transaction.t list\n -> Transaction_applied.t list Or_error.t\n\n val has_locked_tokens :\n global_slot:Global_slot_since_genesis.t\n -> account_id:Account_id.t\n -> ledger\n -> bool Or_error.t\n\n module For_tests : sig\n val validate_timing_with_min_balance :\n account:Account.t\n -> txn_amount:Amount.t\n -> txn_global_slot:Global_slot_since_genesis.t\n -> (Account.Timing.t * [> `Min_balance of Balance.t ]) Or_error.t\n\n val validate_timing :\n account:Account.t\n -> txn_amount:Amount.t\n -> txn_global_slot:Global_slot_since_genesis.t\n -> Account.Timing.t Or_error.t\n end\nend\n\n(* tags for timing validation errors *)\nlet nsf_tag = \"nsf\"\n\nlet min_balance_tag = \"minbal\"\n\nlet timing_error_to_user_command_status err =\n match Error.Internal_repr.of_info err with\n | Tag_t (tag, _) when String.equal tag nsf_tag ->\n Transaction_status.Failure.Source_insufficient_balance\n | Tag_t (tag, _) when String.equal tag min_balance_tag ->\n Transaction_status.Failure.Source_minimum_balance_violation\n | _ ->\n failwith \"Unexpected timed account validation error\"\n\n(** [validate_timing_with_min_balance' ~account ~txn_amount ~txn_global_slot]\n returns a tuple of 3 values:\n * [[`Insufficient_balance of bool | `Invalid_timing of bool]] encodes\n possible errors, with the invariant that the return value is always\n [`Invalid_timing false] if there was no error.\n - [`Insufficient_balance true] results if [txn_amount] is larger than the\n balance held in [account].\n - [`Invalid_timing true] results if [txn_amount] is larger than the\n balance available in [account] at global slot [txn_global_slot].\n * [Timing.t], the new timing for [account] calculated at [txn_global_slot].\n * [[`Min_balance of Balance.t]] returns the computed available balance at\n [txn_global_slot].\n - NOTE: We skip this calculation if the error is\n [`Insufficient_balance true]. In this scenario, this value MUST NOT be\n used, as it contains an incorrect placeholder value.\n*)\nlet validate_timing_with_min_balance' ~account ~txn_amount ~txn_global_slot =\n let open Account.Poly in\n let open Account.Timing.Poly in\n match account.timing with\n | Untimed -> (\n (* no time restrictions *)\n match Balance.(account.balance - txn_amount) with\n | None ->\n (`Insufficient_balance true, Untimed, `Min_balance Balance.zero)\n | _ ->\n (`Invalid_timing false, Untimed, `Min_balance Balance.zero) )\n | Timed\n { initial_minimum_balance\n ; cliff_time\n ; cliff_amount\n ; vesting_period\n ; vesting_increment\n } ->\n let invalid_balance, invalid_timing, curr_min_balance =\n let account_balance = account.balance in\n match Balance.(account_balance - txn_amount) with\n | None ->\n (* NB: The [initial_minimum_balance] here is the incorrect value,\n but:\n * we don't use it anywhere in this error case; and\n * we don't want to waste time computing it if it will be unused.\n *)\n (true, false, initial_minimum_balance)\n | Some proposed_new_balance ->\n let curr_min_balance =\n Account.min_balance_at_slot ~global_slot:txn_global_slot\n ~cliff_time ~cliff_amount ~vesting_period ~vesting_increment\n ~initial_minimum_balance\n in\n if Balance.(proposed_new_balance < curr_min_balance) then\n (false, true, curr_min_balance)\n else (false, false, curr_min_balance)\n in\n (* once the calculated minimum balance becomes zero, the account becomes untimed *)\n let possibly_error =\n if invalid_balance then `Insufficient_balance invalid_balance\n else `Invalid_timing invalid_timing\n in\n if Balance.(curr_min_balance > zero) then\n (possibly_error, account.timing, `Min_balance curr_min_balance)\n else (possibly_error, Untimed, `Min_balance Balance.zero)\n\nlet validate_timing_with_min_balance ~account ~txn_amount ~txn_global_slot =\n let open Or_error.Let_syntax in\n let nsf_error kind =\n Or_error.errorf\n !\"For %s account, the requested transaction for amount %{sexp: Amount.t} \\\n at global slot %{sexp: Global_slot_since_genesis.t}, the balance \\\n %{sexp: Balance.t} is insufficient\"\n kind txn_amount txn_global_slot account.Account.Poly.balance\n |> Or_error.tag ~tag:nsf_tag\n in\n let min_balance_error min_balance =\n Or_error.errorf\n !\"For timed account, the requested transaction for amount %{sexp: \\\n Amount.t} at global slot %{sexp: Global_slot_since_genesis.t}, \\\n applying the transaction would put the balance below the calculated \\\n minimum balance of %{sexp: Balance.t}\"\n txn_amount txn_global_slot min_balance\n |> Or_error.tag ~tag:min_balance_tag\n in\n let possibly_error, timing, (`Min_balance curr_min_balance as min_balance) =\n validate_timing_with_min_balance' ~account ~txn_amount ~txn_global_slot\n in\n match possibly_error with\n | `Insufficient_balance true ->\n nsf_error \"timed\"\n | `Invalid_timing true ->\n min_balance_error curr_min_balance\n | `Insufficient_balance false ->\n failwith \"Broken invariant in validate_timing_with_min_balance'\"\n | `Invalid_timing false ->\n return (timing, min_balance)\n\nlet validate_timing ~account ~txn_amount ~txn_global_slot =\n let open Result.Let_syntax in\n let%map timing, `Min_balance _ =\n validate_timing_with_min_balance ~account ~txn_amount ~txn_global_slot\n in\n timing\n\nmodule Make (L : Ledger_intf.S) :\n S with type ledger := L.t and type location := L.location = struct\n open L\n\n let error s = Or_error.errorf \"Ledger.apply_transaction: %s\" s\n\n let error_opt e = Option.value_map ~default:(error e) ~f:Or_error.return\n\n let get_with_location ledger account_id =\n match location_of_account ledger account_id with\n | Some location -> (\n match get ledger location with\n | Some account ->\n Ok (`Existing location, account)\n | None ->\n failwith \"Ledger location with no account\" )\n | None ->\n Ok (`New, Account.create account_id Balance.zero)\n\n let set_with_location ledger location account =\n match location with\n | `Existing location ->\n Ok (set ledger location account)\n | `New ->\n create_new_account ledger (Account.identifier account) account\n\n let add_amount balance amount =\n error_opt \"overflow\" (Balance.add_amount balance amount)\n\n let sub_amount balance amount =\n error_opt \"insufficient funds\" (Balance.sub_amount balance amount)\n\n let sub_account_creation_fee\n ~(constraint_constants : Genesis_constants.Constraint_constants.t) action\n amount =\n let fee = constraint_constants.account_creation_fee in\n if Ledger_intf.equal_account_state action `Added then\n error_opt\n (sprintf\n !\"Error subtracting account creation fee %{sexp: Currency.Fee.t}; \\\n transaction amount %{sexp: Currency.Amount.t} insufficient\"\n fee amount )\n Amount.(sub amount (of_fee fee))\n else Ok amount\n\n let check b = ksprintf (fun s -> if b then Ok () else Or_error.error_string s)\n\n let validate_nonces txn_nonce account_nonce =\n check\n (Account.Nonce.equal account_nonce txn_nonce)\n !\"Nonce in account %{sexp: Account.Nonce.t} different from nonce in \\\n transaction %{sexp: Account.Nonce.t}\"\n account_nonce txn_nonce\n\n let validate_time ~valid_until ~current_global_slot =\n check\n Global_slot_since_genesis.(current_global_slot <= valid_until)\n !\"Current global slot %{sexp: Global_slot_since_genesis.t} greater than \\\n transaction expiry slot %{sexp: Global_slot_since_genesis.t}\"\n current_global_slot valid_until\n\n module Transaction_applied = struct\n include Transaction_applied\n\n let transaction : t -> Transaction.t With_status.t =\n fun { varying; _ } ->\n match varying with\n | Command (Signed_command uc) ->\n With_status.map uc.common.user_command ~f:(fun cmd ->\n Transaction.Command (User_command.Signed_command cmd) )\n | Command (Zkapp_command s) ->\n With_status.map s.command ~f:(fun c ->\n Transaction.Command (User_command.Zkapp_command c) )\n | Fee_transfer f ->\n With_status.map f.fee_transfer ~f:(fun f ->\n Transaction.Fee_transfer f )\n | Coinbase c ->\n With_status.map c.coinbase ~f:(fun c -> Transaction.Coinbase c)\n\n let transaction_status : t -> Transaction_status.t =\n fun { varying; _ } ->\n match varying with\n | Command\n (Signed_command { common = { user_command = { status; _ }; _ }; _ })\n ->\n status\n | Command (Zkapp_command c) ->\n c.command.status\n | Fee_transfer f ->\n f.fee_transfer.status\n | Coinbase c ->\n c.coinbase.status\n end\n\n let get_new_accounts action pk =\n if Ledger_intf.equal_account_state action `Added then [ pk ] else []\n\n let has_locked_tokens ~global_slot ~account_id ledger =\n let open Or_error.Let_syntax in\n let%map _, account = get_with_location ledger account_id in\n Account.has_locked_tokens ~global_slot account\n\n let failure (e : Transaction_status.Failure.t) = e\n\n let incr_balance (acct : Account.t) amt =\n match add_amount acct.balance amt with\n | Ok balance ->\n Ok { acct with balance }\n | Error _ ->\n Result.fail (failure Overflow)\n\n (* Helper function for [apply_user_command_unchecked] *)\n let pay_fee' ~command ~nonce ~fee_payer ~fee ~ledger ~current_global_slot =\n let open Or_error.Let_syntax in\n (* Fee-payer information *)\n let%bind location, account = get_with_location ledger fee_payer in\n let%bind () =\n match location with\n | `Existing _ ->\n return ()\n | `New ->\n Or_error.errorf \"The fee-payer account does not exist\"\n in\n let fee = Amount.of_fee fee in\n let%bind balance = sub_amount account.balance fee in\n let%bind () = validate_nonces nonce account.nonce in\n let%map timing =\n validate_timing ~txn_amount:fee ~txn_global_slot:current_global_slot\n ~account\n in\n ( location\n , { account with\n balance\n ; nonce = Account.Nonce.succ account.nonce\n ; receipt_chain_hash =\n Receipt.Chain_hash.cons_signed_command_payload command\n account.receipt_chain_hash\n ; timing\n } )\n\n (* Helper function for [apply_user_command_unchecked] *)\n let pay_fee ~user_command ~signer_pk ~ledger ~current_global_slot =\n let open Or_error.Let_syntax in\n (* Fee-payer information *)\n let nonce = Signed_command.nonce user_command in\n let fee_payer = Signed_command.fee_payer user_command in\n let%bind () =\n let fee_token = Signed_command.fee_token user_command in\n let%bind () =\n (* TODO: Enable multi-sig. *)\n if\n Public_key.Compressed.equal\n (Account_id.public_key fee_payer)\n signer_pk\n then return ()\n else\n Or_error.errorf\n \"Cannot pay fees from a public key that did not sign the \\\n transaction\"\n in\n let%map () =\n (* TODO: Remove this check and update the transaction snark once we have\n an exchange rate mechanism. See issue #4447.\n *)\n if Token_id.equal fee_token Token_id.default then return ()\n else\n Or_error.errorf\n \"Cannot create transactions with fee_token different from the \\\n default\"\n in\n ()\n in\n let%map loc, account' =\n pay_fee' ~command:(Signed_command_payload user_command.payload) ~nonce\n ~fee_payer\n ~fee:(Signed_command.fee user_command)\n ~ledger ~current_global_slot\n in\n (loc, account')\n\n (* someday: It would probably be better if we didn't modify the receipt chain hash\n in the case that the sender is equal to the receiver, but it complicates the SNARK, so\n we don't for now. *)\n let apply_user_command_unchecked\n ~(constraint_constants : Genesis_constants.Constraint_constants.t)\n ~txn_global_slot ledger\n ({ payload; signer; signature = _ } as user_command : Signed_command.t) =\n let open Or_error.Let_syntax in\n let signer_pk = Public_key.compress signer in\n let current_global_slot = txn_global_slot in\n let%bind () =\n validate_time\n ~valid_until:(Signed_command.valid_until user_command)\n ~current_global_slot\n in\n (* Fee-payer information *)\n let fee_payer = Signed_command.fee_payer user_command in\n let%bind fee_payer_location, fee_payer_account =\n pay_fee ~user_command ~signer_pk ~ledger ~current_global_slot\n in\n let%bind () =\n if Account.has_permission_to_send fee_payer_account then Ok ()\n else\n Or_error.error_string\n Transaction_status.Failure.(describe Update_not_permitted_balance)\n in\n let%bind () =\n if Account.has_permission_to_increment_nonce fee_payer_account then Ok ()\n else\n Or_error.error_string\n Transaction_status.Failure.(describe Update_not_permitted_nonce)\n in\n (* Charge the fee. This must happen, whether or not the command itself\n succeeds, to ensure that the network is compensated for processing this\n command.\n *)\n let%bind () =\n set_with_location ledger fee_payer_location fee_payer_account\n in\n let receiver = Signed_command.receiver user_command in\n let exception Reject of Error.t in\n let ok_or_reject = function Ok x -> x | Error err -> raise (Reject err) in\n let compute_updates () =\n let open Result.Let_syntax in\n (* Compute the necessary changes to apply the command, failing if any of\n the conditions are not met.\n *)\n match payload.body with\n | Stake_delegation _ ->\n let receiver_location, _receiver_account =\n (* Check that receiver account exists. *)\n get_with_location ledger receiver |> ok_or_reject\n in\n let%bind () =\n match receiver_location with\n | `Existing _ ->\n return ()\n | `New ->\n Result.fail Transaction_status.Failure.Receiver_not_present\n in\n let%bind () =\n Result.ok_if_true\n (Account.has_permission_to_set_delegate fee_payer_account)\n ~error:Transaction_status.Failure.Update_not_permitted_delegate\n in\n let previous_delegate = fee_payer_account.delegate in\n (* Timing is always valid, but we need to record any switch from\n timed to untimed here to stay in sync with the snark.\n *)\n let%map fee_payer_account =\n let%map timing =\n validate_timing ~txn_amount:Amount.zero\n ~txn_global_slot:current_global_slot ~account:fee_payer_account\n |> Result.map_error ~f:timing_error_to_user_command_status\n in\n { fee_payer_account with\n delegate = Some (Account_id.public_key receiver)\n ; timing\n }\n in\n ( [ (fee_payer_location, fee_payer_account) ]\n , Transaction_applied.Signed_command_applied.Body.Stake_delegation\n { previous_delegate } )\n | Payment { amount; _ } ->\n let%bind fee_payer_account =\n let ret =\n let%bind balance =\n Result.map_error (sub_amount fee_payer_account.balance amount)\n ~f:(fun _ ->\n Transaction_status.Failure.Source_insufficient_balance )\n in\n let%map timing =\n validate_timing ~txn_amount:amount\n ~txn_global_slot:current_global_slot\n ~account:fee_payer_account\n |> Result.map_error ~f:timing_error_to_user_command_status\n in\n { fee_payer_account with balance; timing }\n in\n (* Don't accept transactions with insufficient balance from the fee-payer.\n TODO: eliminate this condition and accept transaction with failed status\n *)\n match ret with\n | Ok x ->\n Ok x\n | Error failure ->\n raise\n (Reject\n (Error.createf \"%s\"\n (Transaction_status.Failure.describe failure) ) )\n in\n let receiver_location, receiver_account =\n if Account_id.equal fee_payer receiver then\n (fee_payer_location, fee_payer_account)\n else get_with_location ledger receiver |> ok_or_reject\n in\n let%bind () =\n Result.ok_if_true\n (Account.has_permission_to_send fee_payer_account)\n ~error:Transaction_status.Failure.Update_not_permitted_balance\n in\n let%bind () =\n Result.ok_if_true\n (Account.has_permission_to_receive receiver_account)\n ~error:Transaction_status.Failure.Update_not_permitted_balance\n in\n (* Charge the account creation fee. *)\n let%bind receiver_amount =\n match receiver_location with\n | `Existing _ ->\n return amount\n | `New ->\n (* Subtract the creation fee from the transaction amount. *)\n sub_account_creation_fee ~constraint_constants `Added amount\n |> Result.map_error ~f:(fun _ ->\n Transaction_status.Failure\n .Amount_insufficient_to_create_account )\n in\n let%map receiver_account =\n incr_balance receiver_account receiver_amount\n in\n let new_accounts =\n match receiver_location with\n | `Existing _ ->\n []\n | `New ->\n [ receiver ]\n in\n let updated_accounts =\n if Account_id.equal fee_payer receiver then\n (* [receiver_account] at this point has all the updates*)\n [ (receiver_location, receiver_account) ]\n else\n [ (receiver_location, receiver_account)\n ; (fee_payer_location, fee_payer_account)\n ]\n in\n ( updated_accounts\n , Transaction_applied.Signed_command_applied.Body.Payment\n { new_accounts } )\n in\n match compute_updates () with\n | Ok (located_accounts, applied_body) ->\n (* Update the ledger. *)\n let%bind () =\n List.fold located_accounts ~init:(Ok ())\n ~f:(fun acc (location, account) ->\n let%bind () = acc in\n set_with_location ledger location account )\n in\n let applied_common : Transaction_applied.Signed_command_applied.Common.t\n =\n { user_command = { data = user_command; status = Applied } }\n in\n return\n ( { common = applied_common; body = applied_body }\n : Transaction_applied.Signed_command_applied.t )\n | Error failure ->\n (* Do not update the ledger. Except for the fee payer which is already updated *)\n let applied_common : Transaction_applied.Signed_command_applied.Common.t\n =\n { user_command =\n { data = user_command\n ; status =\n Failed\n (Transaction_status.Failure.Collection.of_single_failure\n failure )\n }\n }\n in\n return\n ( { common = applied_common; body = Failed }\n : Transaction_applied.Signed_command_applied.t )\n | exception Reject err ->\n (* TODO: These transactions should never reach this stage, this error\n should be fatal.\n *)\n Error err\n\n let apply_user_command ~constraint_constants ~txn_global_slot ledger\n (user_command : Signed_command.With_valid_signature.t) =\n apply_user_command_unchecked ~constraint_constants ~txn_global_slot ledger\n (Signed_command.forget_check user_command)\n\n module Global_state = struct\n type t =\n { first_pass_ledger : L.t\n ; second_pass_ledger : L.t\n ; fee_excess : Amount.Signed.t\n ; supply_increase : Amount.Signed.t\n ; protocol_state : Zkapp_precondition.Protocol_state.View.t\n ; block_global_slot : Global_slot_since_genesis.t\n }\n\n let first_pass_ledger { first_pass_ledger; _ } =\n L.create_masked first_pass_ledger\n\n let set_first_pass_ledger ~should_update t ledger =\n if should_update then L.apply_mask t.first_pass_ledger ~masked:ledger ;\n t\n\n let second_pass_ledger { second_pass_ledger; _ } =\n L.create_masked second_pass_ledger\n\n let set_second_pass_ledger ~should_update t ledger =\n if should_update then L.apply_mask t.second_pass_ledger ~masked:ledger ;\n t\n\n let fee_excess { fee_excess; _ } = fee_excess\n\n let set_fee_excess t fee_excess = { t with fee_excess }\n\n let supply_increase { supply_increase; _ } = supply_increase\n\n let set_supply_increase t supply_increase = { t with supply_increase }\n\n let block_global_slot { block_global_slot; _ } = block_global_slot\n end\n\n module Transaction_partially_applied = struct\n module Zkapp_command_partially_applied = struct\n type t =\n { command : Zkapp_command.t\n ; previous_hash : Ledger_hash.t\n ; original_first_pass_account_states :\n (Account_id.t * (location * Account.t) option) list\n ; constraint_constants : Genesis_constants.Constraint_constants.t\n ; state_view : Zkapp_precondition.Protocol_state.View.t\n ; global_state : Global_state.t\n ; local_state :\n ( Stack_frame.value\n , Stack_frame.value list\n , Amount.Signed.t\n , L.t\n , bool\n , Zkapp_command.Transaction_commitment.t\n , Mina_numbers.Index.t\n , Transaction_status.Failure.Collection.t )\n Zkapp_command_logic.Local_state.t\n }\n end\n\n type 'applied fully_applied =\n { previous_hash : Ledger_hash.t; applied : 'applied }\n\n (* TODO: lift previous_hash up in the types *)\n type t =\n | Signed_command of\n Transaction_applied.Signed_command_applied.t fully_applied\n | Zkapp_command of Zkapp_command_partially_applied.t\n | Fee_transfer of Transaction_applied.Fee_transfer_applied.t fully_applied\n | Coinbase of Transaction_applied.Coinbase_applied.t fully_applied\n\n let command (t : t) : Transaction.t =\n match t with\n | Signed_command s ->\n Transaction.Command\n (User_command.Signed_command s.applied.common.user_command.data)\n | Zkapp_command z ->\n Command (User_command.Zkapp_command z.command)\n | Fee_transfer f ->\n Fee_transfer f.applied.fee_transfer.data\n | Coinbase c ->\n Coinbase c.applied.coinbase.data\n end\n\n module Inputs = struct\n let with_label ~label:_ f = f ()\n\n let value_if b ~then_ ~else_ = if b then then_ else else_\n\n module Global_state = Global_state\n\n module Field = struct\n type t = Snark_params.Tick.Field.t\n\n let if_ = value_if\n\n let equal = Snark_params.Tick.Field.equal\n end\n\n module Bool = struct\n type t = bool\n\n module Assert = struct\n let is_true ~pos b =\n try assert b\n with Assert_failure _ ->\n let file, line, col, _ecol = pos in\n raise (Assert_failure (file, line, col))\n\n let any ~pos bs = List.exists ~f:Fn.id bs |> is_true ~pos\n end\n\n let if_ = value_if\n\n let true_ = true\n\n let false_ = false\n\n let equal = Bool.equal\n\n let not = not\n\n let ( ||| ) = ( || )\n\n let ( &&& ) = ( && )\n\n let display b ~label = sprintf \"%s: %b\" label b\n\n let all = List.for_all ~f:Fn.id\n\n type failure_status = Transaction_status.Failure.t option\n\n type failure_status_tbl = Transaction_status.Failure.Collection.t\n\n let is_empty t = List.join t |> List.is_empty\n\n let assert_with_failure_status_tbl ~pos b failure_status_tbl =\n let file, line, col, ecol = pos in\n if (not b) && not (is_empty failure_status_tbl) then\n (* Raise a more useful error message if we have a failure\n description. *)\n let failure_msg =\n Yojson.Safe.to_string\n @@ Transaction_status.Failure.Collection.Display.to_yojson\n @@ Transaction_status.Failure.Collection.to_display\n failure_status_tbl\n in\n Error.raise @@ Error.of_string\n @@ sprintf \"File %S, line %d, characters %d-%d: %s\" file line col ecol\n failure_msg\n else\n try assert b\n with Assert_failure _ -> raise (Assert_failure (file, line, col))\n end\n\n module Account_id = struct\n include Account_id\n\n let if_ = value_if\n end\n\n module Ledger = struct\n type t = L.t\n\n let if_ = value_if\n\n let empty = L.empty\n\n type inclusion_proof = [ `Existing of location | `New ]\n\n let get_account p l =\n let loc, acct =\n Or_error.ok_exn (get_with_location l (Account_update.account_id p))\n in\n (acct, loc)\n\n let set_account l (a, loc) =\n Or_error.ok_exn (set_with_location l loc a) ;\n l\n\n let check_inclusion _ledger (_account, _loc) = ()\n\n let check_account public_key token_id\n ((account, loc) : Account.t * inclusion_proof) =\n assert (Public_key.Compressed.equal public_key account.public_key) ;\n assert (Token_id.equal token_id account.token_id) ;\n match loc with `Existing _ -> `Is_new false | `New -> `Is_new true\n end\n\n module Transaction_commitment = struct\n type t = Field.t\n\n let empty = Zkapp_command.Transaction_commitment.empty\n\n let commitment ~account_updates =\n let account_updates_hash =\n Mina_base.Zkapp_command.Call_forest.hash account_updates\n in\n Zkapp_command.Transaction_commitment.create ~account_updates_hash\n\n let full_commitment ~account_update ~memo_hash ~commitment =\n (* when called from Zkapp_command_logic.apply, the account_update is the fee payer *)\n let fee_payer_hash =\n Zkapp_command.Digest.Account_update.create account_update\n in\n Zkapp_command.Transaction_commitment.create_complete commitment\n ~memo_hash ~fee_payer_hash\n\n let if_ = value_if\n end\n\n module Index = struct\n type t = Mina_numbers.Index.t\n\n let zero, succ = Mina_numbers.Index.(zero, succ)\n\n let if_ = value_if\n end\n\n module Public_key = struct\n type t = Public_key.Compressed.t\n\n let if_ = value_if\n end\n\n module Controller = struct\n type t = Permissions.Auth_required.t\n\n let if_ = value_if\n\n let check ~proof_verifies ~signature_verifies perm =\n (* Invariant: We either have a proof, a signature, or neither. *)\n assert (not (proof_verifies && signature_verifies)) ;\n let tag =\n if proof_verifies then Control.Tag.Proof\n else if signature_verifies then Control.Tag.Signature\n else Control.Tag.None_given\n in\n Permissions.Auth_required.check perm tag\n end\n\n module Global_slot_since_genesis = struct\n include Mina_numbers.Global_slot_since_genesis\n\n let if_ = value_if\n end\n\n module Global_slot_span = struct\n include Mina_numbers.Global_slot_span\n\n let if_ = value_if\n end\n\n module Nonce = struct\n type t = Account.Nonce.t\n\n let if_ = value_if\n\n let succ = Account.Nonce.succ\n end\n\n module Receipt_chain_hash = struct\n type t = Receipt.Chain_hash.t\n\n module Elt = struct\n type t = Receipt.Zkapp_command_elt.t\n\n let of_transaction_commitment tc =\n Receipt.Zkapp_command_elt.Zkapp_command_commitment tc\n end\n\n let cons_zkapp_command_commitment =\n Receipt.Chain_hash.cons_zkapp_command_commitment\n\n let if_ = value_if\n end\n\n module State_hash = struct\n include State_hash\n\n let if_ = value_if\n end\n\n module Timing = struct\n type t = Account_update.Update.Timing_info.t option\n\n let if_ = value_if\n\n let vesting_period (t : t) =\n match t with\n | Some t ->\n t.vesting_period\n | None ->\n (Account_timing.to_record Untimed).vesting_period\n end\n\n module Balance = struct\n include Balance\n\n let if_ = value_if\n end\n\n module Verification_key = struct\n type t = (Side_loaded_verification_key.t, Field.t) With_hash.t option\n\n let if_ = value_if\n end\n\n module Verification_key_hash = struct\n type t = Field.t option\n\n let equal vk1 vk2 = Option.equal Field.equal vk1 vk2\n end\n\n module Actions = struct\n type t = Zkapp_account.Actions.t\n\n let is_empty = List.is_empty\n\n let push_events = Account_update.Actions.push_events\n end\n\n module Zkapp_uri = struct\n type t = string\n\n let if_ = value_if\n end\n\n module Token_symbol = struct\n type t = Account.Token_symbol.t\n\n let if_ = value_if\n end\n\n module Account = struct\n include Account\n\n module Permissions = struct\n let access : t -> Controller.t = fun a -> a.permissions.access\n\n let edit_state : t -> Controller.t = fun a -> a.permissions.edit_state\n\n let send : t -> Controller.t = fun a -> a.permissions.send\n\n let receive : t -> Controller.t = fun a -> a.permissions.receive\n\n let set_delegate : t -> Controller.t =\n fun a -> a.permissions.set_delegate\n\n let set_permissions : t -> Controller.t =\n fun a -> a.permissions.set_permissions\n\n let set_verification_key : t -> Controller.t =\n fun a -> a.permissions.set_verification_key\n\n let set_zkapp_uri : t -> Controller.t =\n fun a -> a.permissions.set_zkapp_uri\n\n let edit_action_state : t -> Controller.t =\n fun a -> a.permissions.edit_action_state\n\n let set_token_symbol : t -> Controller.t =\n fun a -> a.permissions.set_token_symbol\n\n let increment_nonce : t -> Controller.t =\n fun a -> a.permissions.increment_nonce\n\n let set_voting_for : t -> Controller.t =\n fun a -> a.permissions.set_voting_for\n\n let set_timing : t -> Controller.t = fun a -> a.permissions.set_timing\n\n type t = Permissions.t\n\n let if_ = value_if\n end\n\n type timing = Account_update.Update.Timing_info.t option\n\n let timing (a : t) : timing =\n Account_update.Update.Timing_info.of_account_timing a.timing\n\n let set_timing (a : t) (timing : timing) : t =\n { a with\n timing =\n Option.value_map ~default:Account_timing.Untimed\n ~f:Account_update.Update.Timing_info.to_account_timing timing\n }\n\n let is_timed (a : t) =\n match a.timing with Account_timing.Untimed -> false | _ -> true\n\n let set_token_id (a : t) (id : Token_id.t) : t = { a with token_id = id }\n\n let balance (a : t) : Balance.t = a.balance\n\n let set_balance (balance : Balance.t) (a : t) : t = { a with balance }\n\n let check_timing ~txn_global_slot account =\n let invalid_timing, timing, _ =\n validate_timing_with_min_balance' ~txn_amount:Amount.zero\n ~txn_global_slot ~account\n in\n ( invalid_timing\n , Account_update.Update.Timing_info.of_account_timing timing )\n\n let receipt_chain_hash (a : t) : Receipt.Chain_hash.t =\n a.receipt_chain_hash\n\n let set_receipt_chain_hash (a : t) hash =\n { a with receipt_chain_hash = hash }\n\n let make_zkapp (a : t) =\n let zkapp =\n match a.zkapp with\n | None ->\n Some Zkapp_account.default\n | Some _ as zkapp ->\n zkapp\n in\n { a with zkapp }\n\n let unmake_zkapp (a : t) : t =\n let zkapp =\n match a.zkapp with\n | None ->\n None\n | Some zkapp ->\n if Zkapp_account.(equal default zkapp) then None else Some zkapp\n in\n { a with zkapp }\n\n let get_zkapp (a : t) = Option.value_exn a.zkapp\n\n let set_zkapp (a : t) ~f : t = { a with zkapp = Option.map a.zkapp ~f }\n\n let proved_state (a : t) = (get_zkapp a).proved_state\n\n let set_proved_state proved_state (a : t) =\n set_zkapp a ~f:(fun zkapp -> { zkapp with proved_state })\n\n let app_state (a : t) = (get_zkapp a).app_state\n\n let set_app_state app_state (a : t) =\n set_zkapp a ~f:(fun zkapp -> { zkapp with app_state })\n\n let register_verification_key (_ : t) = ()\n\n let verification_key (a : t) = (get_zkapp a).verification_key\n\n let set_verification_key verification_key (a : t) =\n set_zkapp a ~f:(fun zkapp -> { zkapp with verification_key })\n\n let verification_key_hash (a : t) =\n match a.zkapp with\n | None ->\n None\n | Some zkapp ->\n Option.map zkapp.verification_key ~f:With_hash.hash\n\n let last_action_slot (a : t) = (get_zkapp a).last_action_slot\n\n let set_last_action_slot last_action_slot (a : t) =\n set_zkapp a ~f:(fun zkapp -> { zkapp with last_action_slot })\n\n let action_state (a : t) = (get_zkapp a).action_state\n\n let set_action_state action_state (a : t) =\n set_zkapp a ~f:(fun zkapp -> { zkapp with action_state })\n\n let zkapp_uri (a : t) =\n Option.value_map a.zkapp ~default:\"\" ~f:(fun zkapp -> zkapp.zkapp_uri)\n\n let set_zkapp_uri zkapp_uri (a : t) : t =\n { a with\n zkapp = Option.map a.zkapp ~f:(fun zkapp -> { zkapp with zkapp_uri })\n }\n\n let token_symbol (a : t) = a.token_symbol\n\n let set_token_symbol token_symbol (a : t) = { a with token_symbol }\n\n let public_key (a : t) = a.public_key\n\n let set_public_key public_key (a : t) = { a with public_key }\n\n let delegate (a : t) = Account.delegate_opt a.delegate\n\n let set_delegate delegate (a : t) =\n let delegate =\n if Signature_lib.Public_key.Compressed.(equal empty) delegate then\n None\n else Some delegate\n in\n { a with delegate }\n\n let nonce (a : t) = a.nonce\n\n let set_nonce nonce (a : t) = { a with nonce }\n\n let voting_for (a : t) = a.voting_for\n\n let set_voting_for voting_for (a : t) = { a with voting_for }\n\n let permissions (a : t) = a.permissions\n\n let set_permissions permissions (a : t) = { a with permissions }\n end\n\n module Amount = struct\n open Currency.Amount\n\n type unsigned = t\n\n type t = unsigned\n\n let if_ = value_if\n\n module Signed = struct\n include Signed\n\n let if_ = value_if\n\n (* Correctness of these functions hinges on the fact that zero is\n only ever expressed as {sgn = Pos; magnitude = zero}. Sadly, this\n is not guaranteed by the module's signature, as it's internal\n structure is exposed. Create function never produces this unwanted\n value, but the type's internal structure is still exposed, so it's\n possible theoretically to obtain it.\n\n For the moment, however, there is some consolation in the fact that\n addition never produces negative zero, even if it was one of its\n arguments. For that reason the risk of this function misbehaving is\n minimal and can probably be safely ignored. *)\n let is_non_neg (t : t) = Sgn.equal t.sgn Pos\n\n let is_neg (t : t) = Sgn.equal t.sgn Neg\n end\n\n let zero = zero\n\n let equal = equal\n\n let add_flagged = add_flagged\n\n let add_signed_flagged (x1 : t) (x2 : Signed.t) : t * [ `Overflow of bool ]\n =\n let y, `Overflow b = Signed.(add_flagged (of_unsigned x1) x2) in\n match y.sgn with\n | Pos ->\n (y.magnitude, `Overflow b)\n | Neg ->\n (* We want to capture the accurate value so that this will match\n with the values in the snarked logic.\n *)\n let magnitude =\n Amount.to_uint64 y.magnitude\n |> Unsigned.UInt64.(mul (sub zero one))\n |> Amount.of_uint64\n in\n (magnitude, `Overflow true)\n\n let of_constant_fee = of_fee\n end\n\n module Token_id = struct\n include Token_id\n\n let if_ = value_if\n end\n\n module Protocol_state_precondition = struct\n include Zkapp_precondition.Protocol_state\n end\n\n module Valid_while_precondition = struct\n include Zkapp_precondition.Valid_while\n end\n\n module Account_update = struct\n include Account_update\n\n module Account_precondition = struct\n include Account_update.Account_precondition\n\n let nonce (t : Account_update.t) = nonce t.body.preconditions.account\n end\n\n type 'a or_ignore = 'a Zkapp_basic.Or_ignore.t\n\n type call_forest = Zkapp_call_forest.t\n\n type transaction_commitment = Transaction_commitment.t\n\n let may_use_parents_own_token (p : t) =\n May_use_token.parents_own_token p.body.may_use_token\n\n let may_use_token_inherited_from_parent (p : t) =\n May_use_token.inherit_from_parent p.body.may_use_token\n\n let check_authorization ~will_succeed:_ ~commitment:_ ~calls:_\n (account_update : t) =\n (* The transaction's validity should already have been checked before\n this point.\n *)\n match account_update.authorization with\n | Signature _ ->\n (`Proof_verifies false, `Signature_verifies true)\n | Proof _ ->\n (`Proof_verifies true, `Signature_verifies false)\n | None_given ->\n (`Proof_verifies false, `Signature_verifies false)\n\n let is_proved (account_update : t) =\n match account_update.body.authorization_kind with\n | Proof _ ->\n true\n | Signature | None_given ->\n false\n\n let is_signed (account_update : t) =\n match account_update.body.authorization_kind with\n | Signature ->\n true\n | Proof _ | None_given ->\n false\n\n let verification_key_hash (p : t) =\n match p.body.authorization_kind with\n | Proof vk_hash ->\n Some vk_hash\n | _ ->\n None\n\n module Update = struct\n open Zkapp_basic\n\n type 'a set_or_keep = 'a Zkapp_basic.Set_or_keep.t\n\n let timing (account_update : t) : Account.timing set_or_keep =\n Set_or_keep.map ~f:Option.some account_update.body.update.timing\n\n let app_state (account_update : t) =\n account_update.body.update.app_state\n\n let verification_key (account_update : t) =\n Zkapp_basic.Set_or_keep.map ~f:Option.some\n account_update.body.update.verification_key\n\n let actions (account_update : t) = account_update.body.actions\n\n let zkapp_uri (account_update : t) =\n account_update.body.update.zkapp_uri\n\n let token_symbol (account_update : t) =\n account_update.body.update.token_symbol\n\n let delegate (account_update : t) = account_update.body.update.delegate\n\n let voting_for (account_update : t) =\n account_update.body.update.voting_for\n\n let permissions (account_update : t) =\n account_update.body.update.permissions\n end\n end\n\n module Set_or_keep = struct\n include Zkapp_basic.Set_or_keep\n\n let set_or_keep ~if_:_ t x = set_or_keep t x\n end\n\n module Opt = struct\n type 'a t = 'a option\n\n let is_some = Option.is_some\n\n let map = Option.map\n\n let or_default ~if_ x ~default =\n if_ (is_some x) ~then_:(Option.value ~default x) ~else_:default\n\n let or_exn x = Option.value_exn x\n end\n\n module Stack (Elt : sig\n type t\n end) =\n struct\n type t = Elt.t list\n\n let if_ = value_if\n\n let empty () = []\n\n let is_empty = List.is_empty\n\n let pop_exn : t -> Elt.t * t = function\n | [] ->\n failwith \"pop_exn\"\n | x :: xs ->\n (x, xs)\n\n let pop : t -> (Elt.t * t) option = function\n | x :: xs ->\n Some (x, xs)\n | _ ->\n None\n\n let push x ~onto : t = x :: onto\n end\n\n module Call_forest = Zkapp_call_forest\n\n module Stack_frame = struct\n include Stack_frame\n\n type t = value\n\n let if_ = Zkapp_command.value_if\n\n let make = Stack_frame.make\n end\n\n module Call_stack = Stack (Stack_frame)\n\n module Local_state = struct\n type t =\n ( Stack_frame.t\n , Call_stack.t\n , Amount.Signed.t\n , Ledger.t\n , Bool.t\n , Transaction_commitment.t\n , Index.t\n , Bool.failure_status_tbl )\n Zkapp_command_logic.Local_state.t\n\n let add_check (t : t) failure b =\n let failure_status_tbl =\n match t.failure_status_tbl with\n | hd :: tl when not b ->\n (failure :: hd) :: tl\n | old_failure_status_tbl ->\n old_failure_status_tbl\n in\n { t with failure_status_tbl; success = t.success && b }\n\n let update_failure_status_tbl (t : t) failure_status b =\n match failure_status with\n | None ->\n { t with success = t.success && b }\n | Some failure ->\n add_check t failure b\n\n let add_new_failure_status_bucket (t : t) =\n { t with failure_status_tbl = [] :: t.failure_status_tbl }\n end\n\n module Nonce_precondition = struct\n let is_constant =\n Zkapp_precondition.Numeric.is_constant\n Zkapp_precondition.Numeric.Tc.nonce\n end\n end\n\n module Env = struct\n open Inputs\n\n type t =\n < account_update : Account_update.t\n ; zkapp_command : Zkapp_command.t\n ; account : Account.t\n ; ledger : Ledger.t\n ; amount : Amount.t\n ; signed_amount : Amount.Signed.t\n ; bool : Bool.t\n ; token_id : Token_id.t\n ; global_state : Global_state.t\n ; inclusion_proof : [ `Existing of location | `New ]\n ; local_state :\n ( Stack_frame.t\n , Call_stack.t\n , Amount.Signed.t\n , L.t\n , bool\n , Transaction_commitment.t\n , Index.t\n , Transaction_status.Failure.Collection.t )\n Zkapp_command_logic.Local_state.t\n ; protocol_state_precondition : Zkapp_precondition.Protocol_state.t\n ; valid_while_precondition : Zkapp_precondition.Valid_while.t\n ; transaction_commitment : Transaction_commitment.t\n ; full_transaction_commitment : Transaction_commitment.t\n ; field : Snark_params.Tick.Field.t\n ; failure : Transaction_status.Failure.t option >\n\n let perform ~constraint_constants:_ (type r)\n (eff : (r, t) Zkapp_command_logic.Eff.t) : r =\n match eff with\n | Check_valid_while_precondition (valid_while, global_state) ->\n Zkapp_precondition.Valid_while.check valid_while\n global_state.block_global_slot\n |> Or_error.is_ok\n | Check_protocol_state_precondition (pred, global_state) -> (\n Zkapp_precondition.Protocol_state.check pred\n global_state.protocol_state\n |> fun or_err -> match or_err with Ok () -> true | Error _ -> false )\n | Check_account_precondition\n (account_update, account, new_account, local_state) -> (\n match account_update.body.preconditions.account with\n | Accept ->\n local_state\n | Nonce n ->\n let nonce_matches = Account.Nonce.equal account.nonce n in\n Inputs.Local_state.add_check local_state\n Account_nonce_precondition_unsatisfied nonce_matches\n | Full precondition_account ->\n let local_state = ref local_state in\n let check failure b =\n local_state :=\n Inputs.Local_state.add_check !local_state failure b\n in\n Zkapp_precondition.Account.check ~new_account ~check\n precondition_account account ;\n !local_state )\n | Init_account { account_update = _; account = a } ->\n a\n end\n\n module M = Zkapp_command_logic.Make (Inputs)\n\n let update_action_state action_state actions ~txn_global_slot\n ~last_action_slot =\n let action_state', last_action_slot' =\n M.update_action_state action_state actions ~txn_global_slot\n ~last_action_slot\n in\n (action_state', last_action_slot')\n\n (* apply zkapp command fee payer's while stubbing out the second pass ledger\n CAUTION: If you use the intermediate local states, you MUST update the\n [will_succeed] field to [false] if the [status] is [Failed].*)\n let apply_zkapp_command_first_pass_aux (type user_acc) ~constraint_constants\n ~global_slot ~(state_view : Zkapp_precondition.Protocol_state.View.t)\n ~(init : user_acc) ~f\n ?((* TODO: can this be ripped out from here? *)\n fee_excess = Amount.Signed.zero)\n ?((* TODO: is the right? is it never used for zkapps? *)\n supply_increase = Amount.Signed.zero) (ledger : L.t)\n (command : Zkapp_command.t) :\n ( Transaction_partially_applied.Zkapp_command_partially_applied.t\n * user_acc )\n Or_error.t =\n let open Or_error.Let_syntax in\n let previous_hash = merkle_root ledger in\n let original_first_pass_account_states =\n let id = Zkapp_command.fee_payer command in\n [ ( id\n , Option.Let_syntax.(\n let%bind loc = L.location_of_account ledger id in\n let%map a = L.get ledger loc in\n (loc, a)) )\n ]\n in\n let perform eff = Env.perform ~constraint_constants eff in\n let initial_state :\n Inputs.Global_state.t * _ Zkapp_command_logic.Local_state.t =\n ( { protocol_state = state_view\n ; first_pass_ledger = ledger\n ; second_pass_ledger =\n (* We stub out the second_pass_ledger initially, and then poke the\n correct value in place after the first pass is finished.\n *)\n L.empty ~depth:0 ()\n ; fee_excess\n ; supply_increase\n ; block_global_slot = global_slot\n }\n , { stack_frame =\n ({ calls = []\n ; caller = Token_id.default\n ; caller_caller = Token_id.default\n } : Inputs.Stack_frame.t)\n ; call_stack = []\n ; transaction_commitment = Inputs.Transaction_commitment.empty\n ; full_transaction_commitment = Inputs.Transaction_commitment.empty\n ; excess = Currency.Amount.(Signed.of_unsigned zero)\n ; supply_increase = Currency.Amount.(Signed.of_unsigned zero)\n ; ledger = L.empty ~depth:0 ()\n ; success = true\n ; account_update_index = Inputs.Index.zero\n ; failure_status_tbl = []\n ; will_succeed = true\n } )\n in\n let user_acc = f init initial_state in\n let account_updates = Zkapp_command.all_account_updates command in\n let%map global_state, local_state =\n Or_error.try_with (fun () ->\n M.start ~constraint_constants\n { account_updates\n ; memo_hash = Signed_command_memo.hash command.memo\n ; will_succeed =\n (* It's always valid to set this value to true, and it will\n have no effect outside of the snark.\n *)\n true\n }\n { perform } initial_state )\n in\n ( { Transaction_partially_applied.Zkapp_command_partially_applied.command\n ; previous_hash\n ; original_first_pass_account_states\n ; constraint_constants\n ; state_view\n ; global_state\n ; local_state\n }\n , user_acc )\n\n let apply_zkapp_command_first_pass ~constraint_constants ~global_slot\n ~(state_view : Zkapp_precondition.Protocol_state.View.t)\n ?((* TODO: can this be ripped out from here? *)\n fee_excess = Amount.Signed.zero)\n ?((* TODO: is the right? is it never used for zkapps? *)\n supply_increase = Amount.Signed.zero) (ledger : L.t)\n (command : Zkapp_command.t) :\n Transaction_partially_applied.Zkapp_command_partially_applied.t Or_error.t\n =\n let open Or_error.Let_syntax in\n let%map partial_stmt, _user_acc =\n apply_zkapp_command_first_pass_aux ~constraint_constants ~global_slot\n ~state_view ~fee_excess ~supply_increase ledger command ~init:None\n ~f:(fun _acc state -> Some state)\n in\n partial_stmt\n\n let apply_zkapp_command_second_pass_aux (type user_acc) ~(init : user_acc) ~f\n ledger\n (c : Transaction_partially_applied.Zkapp_command_partially_applied.t) :\n (Transaction_applied.Zkapp_command_applied.t * user_acc) Or_error.t =\n let open Or_error.Let_syntax in\n let perform eff =\n Env.perform ~constraint_constants:c.constraint_constants eff\n in\n let original_account_states =\n (*get the original states of all the accounts in each pass.\n If an account updated in the first pass is referenced in account\n updates, then retain the value before first pass application*)\n (* IMPORTANT: this account list must be sorted by Account_id in increasing order,\n if this ordering changes the scan state hash will be affected and made\n incompatible. *)\n Account_id.Map.to_alist ~key_order:`Increasing\n @@ List.fold ~init:Account_id.Map.empty\n ~f:(fun account_states (id, acc_opt) ->\n Account_id.Map.update account_states id\n ~f:(Option.value ~default:acc_opt) )\n ( c.original_first_pass_account_states\n @ List.map (Zkapp_command.accounts_referenced c.command)\n ~f:(fun id ->\n ( id\n , Option.Let_syntax.(\n let%bind loc = L.location_of_account ledger id in\n let%map a = L.get ledger loc in\n (loc, a)) ) ) )\n in\n let rec step_all (user_acc : user_acc)\n ( (g_state : Inputs.Global_state.t)\n , (l_state : _ Zkapp_command_logic.Local_state.t) ) :\n (user_acc * Transaction_status.Failure.Collection.t) Or_error.t =\n if List.is_empty l_state.stack_frame.Stack_frame.calls then\n Ok (user_acc, l_state.failure_status_tbl)\n else\n let%bind states =\n Or_error.try_with (fun () ->\n M.step ~constraint_constants:c.constraint_constants { perform }\n (g_state, l_state) )\n in\n step_all (f user_acc states) states\n in\n let account_states_after_fee_payer =\n (*To check if the accounts remain unchanged in the event the transaction\n fails. First pass updates will remain even if the transaction fails to\n apply zkapp account updates*)\n List.map (Zkapp_command.accounts_referenced c.command) ~f:(fun id ->\n ( id\n , Option.Let_syntax.(\n let%bind loc = L.location_of_account ledger id in\n let%map a = L.get ledger loc in\n (loc, a)) ) )\n in\n let accounts () =\n List.map original_account_states\n ~f:(Tuple2.map_snd ~f:(Option.map ~f:snd))\n in\n (* Warning: This is an abstraction leak / hack.\n Here, we update global second pass ledger to be the input ledger, and\n then update the local ledger to be the input ledger *IF AND ONLY IF*\n there are more transaction segments to be processed in this pass.\n\n TODO: Remove this, and uplift the logic into the call in staged ledger.\n *)\n let global_state = { c.global_state with second_pass_ledger = ledger } in\n let local_state =\n if List.is_empty c.local_state.stack_frame.Stack_frame.calls then\n (* Don't mess with the local state; we've already finished the\n transaction after the fee payer.\n *)\n c.local_state\n else\n (* Install the ledger that should already be in the local state, but\n may not be in some situations depending on who the caller is.\n *)\n { c.local_state with\n ledger = Global_state.second_pass_ledger global_state\n }\n in\n let start = (global_state, local_state) in\n match step_all (f init start) start with\n | Error e ->\n Error e\n | Ok (user_acc, reversed_failure_status_tbl) ->\n let failure_status_tbl = List.rev reversed_failure_status_tbl in\n let account_ids_originally_not_in_ledger =\n List.filter_map original_account_states\n ~f:(fun (acct_id, loc_and_acct) ->\n if Option.is_none loc_and_acct then Some acct_id else None )\n in\n let successfully_applied =\n Transaction_status.Failure.Collection.is_empty failure_status_tbl\n in\n (* if the zkapp command fails in at least 1 account update,\n then all the account updates would be cancelled except\n the fee payer one\n *)\n let failure_status_tbl =\n if successfully_applied then failure_status_tbl\n else\n List.mapi failure_status_tbl ~f:(fun idx fs ->\n if idx > 0 && List.is_empty fs then\n [ Transaction_status.Failure.Cancelled ]\n else fs )\n in\n (* accounts not originally in ledger, now present in ledger *)\n let new_accounts =\n List.filter account_ids_originally_not_in_ledger ~f:(fun acct_id ->\n Option.is_some @@ L.location_of_account ledger acct_id )\n in\n let valid_result =\n Ok\n ( { Transaction_applied.Zkapp_command_applied.accounts = accounts ()\n ; command =\n { With_status.data = c.command\n ; status =\n ( if successfully_applied then Applied\n else Failed failure_status_tbl )\n }\n ; new_accounts\n }\n , user_acc )\n in\n if successfully_applied then valid_result\n else\n let other_account_update_accounts_unchanged =\n List.fold_until account_states_after_fee_payer ~init:true\n ~f:(fun acc (_, loc_opt) ->\n match\n let open Option.Let_syntax in\n let%bind loc, a = loc_opt in\n let%bind a' = L.get ledger loc in\n Option.some_if (not (Account.equal a a')) ()\n with\n | None ->\n Continue acc\n | Some _ ->\n Stop false )\n ~finish:Fn.id\n in\n (* Other zkapp_command failed, therefore, updates in those should not get applied *)\n if\n List.is_empty new_accounts\n && other_account_update_accounts_unchanged\n then valid_result\n else\n Or_error.error_string\n \"Zkapp_command application failed but new accounts created or \\\n some of the other account_update updates applied\"\n\n let apply_zkapp_command_second_pass ledger c :\n Transaction_applied.Zkapp_command_applied.t Or_error.t =\n let open Or_error.Let_syntax in\n let%map x, () =\n apply_zkapp_command_second_pass_aux ~init:() ~f:Fn.const ledger c\n in\n x\n\n let apply_zkapp_command_unchecked_aux ~constraint_constants ~global_slot\n ~state_view ~init ~f ?fee_excess ?supply_increase ledger command =\n let open Or_error.Let_syntax in\n apply_zkapp_command_first_pass_aux ~constraint_constants ~global_slot\n ~state_view ?fee_excess ?supply_increase ledger command ~init ~f\n >>= fun (partial_stmt, user_acc) ->\n apply_zkapp_command_second_pass_aux ~init:user_acc ~f ledger partial_stmt\n\n let apply_zkapp_command_unchecked ~constraint_constants ~global_slot\n ~state_view ledger command =\n let open Or_error.Let_syntax in\n apply_zkapp_command_first_pass ~constraint_constants ~global_slot\n ~state_view ledger command\n >>= apply_zkapp_command_second_pass_aux ledger ~init:None\n ~f:(fun _acc (global_state, local_state) ->\n Some (local_state, global_state.fee_excess) )\n |> Result.map ~f:(fun (account_update_applied, state_res) ->\n (account_update_applied, Option.value_exn state_res) )\n\n let update_timing_when_no_deduction ~txn_global_slot account =\n validate_timing ~txn_amount:Amount.zero ~txn_global_slot ~account\n\n let has_permission_to_receive ~ledger receiver_account_id :\n Account.t\n * Ledger_intf.account_state\n * [> `Has_permission_to_receive of bool ] =\n let init_account = Account.initialize receiver_account_id in\n match location_of_account ledger receiver_account_id with\n | None ->\n (* new account, check that default permissions allow receiving *)\n ( init_account\n , `Added\n , `Has_permission_to_receive\n (Account.has_permission_to_receive init_account) )\n | Some loc -> (\n match get ledger loc with\n | None ->\n failwith \"Ledger location with no account\"\n | Some receiver_account ->\n ( receiver_account\n , `Existed\n , `Has_permission_to_receive\n (Account.has_permission_to_receive receiver_account) ) )\n\n let no_failure = []\n\n let update_failed =\n [ Transaction_status.Failure.Update_not_permitted_balance ]\n\n let empty = Transaction_status.Failure.Collection.empty\n\n let single_failure =\n Transaction_status.Failure.Collection.of_single_failure\n Update_not_permitted_balance\n\n let append_entry f (s : Transaction_status.Failure.Collection.t) :\n Transaction_status.Failure.Collection.t =\n match s with [] -> [ f ] | h :: t -> h :: f :: t\n\n (*Structure of the failure status:\n I. Only one fee transfer in the transaction (`One) and it fails:\n [[failure]]\n II. Two fee transfers in the transaction (`Two)-\n Both fee transfers fail:\n [[failure-of-first-fee-transfer]; [failure-of-second-fee-transfer]]\n First succeeds and second one fails:\n [[];[failure-of-second-fee-transfer]]\n First fails and second succeeds:\n [[failure-of-first-fee-transfer];[]]\n *)\n let process_fee_transfer t (transfer : Fee_transfer.t) ~modify_balance\n ~modify_timing =\n let open Or_error.Let_syntax in\n (* TODO(#4555): Allow token_id to vary from default. *)\n let%bind () =\n if\n List.for_all\n ~f:Token_id.(equal default)\n (One_or_two.to_list (Fee_transfer.fee_tokens transfer))\n then return ()\n else Or_error.errorf \"Cannot pay fees in non-default tokens.\"\n in\n match Fee_transfer.to_singles transfer with\n | `One ft ->\n let account_id = Fee_transfer.Single.receiver ft in\n let a, action, `Has_permission_to_receive can_receive =\n has_permission_to_receive ~ledger:t account_id\n in\n let%bind timing = modify_timing a in\n let%bind balance = modify_balance action account_id a.balance ft.fee in\n if can_receive then (\n let%map _action, a, loc = get_or_create t account_id in\n let new_accounts = get_new_accounts action account_id in\n set t loc { a with balance; timing } ;\n (new_accounts, empty, Currency.Amount.zero) )\n else Ok ([], single_failure, Currency.Amount.of_fee ft.fee)\n | `Two (ft1, ft2) ->\n let account_id1 = Fee_transfer.Single.receiver ft1 in\n let a1, action1, `Has_permission_to_receive can_receive1 =\n has_permission_to_receive ~ledger:t account_id1\n in\n let account_id2 = Fee_transfer.Single.receiver ft2 in\n if Account_id.equal account_id1 account_id2 then\n let%bind fee = error_opt \"overflow\" (Fee.add ft1.fee ft2.fee) in\n let%bind timing = modify_timing a1 in\n let%bind balance =\n modify_balance action1 account_id1 a1.balance fee\n in\n if can_receive1 then (\n let%map _action1, a1, l1 = get_or_create t account_id1 in\n let new_accounts1 = get_new_accounts action1 account_id1 in\n set t l1 { a1 with balance; timing } ;\n (new_accounts1, empty, Currency.Amount.zero) )\n else\n (*failure for each fee transfer single*)\n Ok\n ( []\n , append_entry update_failed single_failure\n , Currency.Amount.of_fee fee )\n else\n let a2, action2, `Has_permission_to_receive can_receive2 =\n has_permission_to_receive ~ledger:t account_id2\n in\n let%bind balance1 =\n modify_balance action1 account_id1 a1.balance ft1.fee\n in\n (*Note: Not updating the timing field of a1 to avoid additional check in transactions snark (check_timing for \"receiver\"). This is OK because timing rules will not be violated when balance increases and will be checked whenever an amount is deducted from the account. (#5973)*)\n let%bind timing2 = modify_timing a2 in\n let%bind balance2 =\n modify_balance action2 account_id2 a2.balance ft2.fee\n in\n let%bind new_accounts1, failures, burned_tokens1 =\n if can_receive1 then (\n let%map _action1, a1, l1 = get_or_create t account_id1 in\n let new_accounts1 = get_new_accounts action1 account_id1 in\n set t l1 { a1 with balance = balance1 } ;\n ( new_accounts1\n , append_entry no_failure empty\n , Currency.Amount.zero ) )\n else Ok ([], single_failure, Currency.Amount.of_fee ft1.fee)\n in\n let%bind new_accounts2, failures', burned_tokens2 =\n if can_receive2 then (\n let%map _action2, a2, l2 = get_or_create t account_id2 in\n let new_accounts2 = get_new_accounts action2 account_id2 in\n set t l2 { a2 with balance = balance2; timing = timing2 } ;\n ( new_accounts2\n , append_entry no_failure failures\n , Currency.Amount.zero ) )\n else\n Ok\n ( []\n , append_entry update_failed failures\n , Currency.Amount.of_fee ft2.fee )\n in\n let%map burned_tokens =\n error_opt \"burned tokens overflow\"\n (Currency.Amount.add burned_tokens1 burned_tokens2)\n in\n (new_accounts1 @ new_accounts2, failures', burned_tokens)\n\n let apply_fee_transfer ~constraint_constants ~txn_global_slot t transfer =\n let open Or_error.Let_syntax in\n let%map new_accounts, failures, burned_tokens =\n process_fee_transfer t transfer\n ~modify_balance:(fun action _ b f ->\n let%bind amount =\n let amount = Amount.of_fee f in\n sub_account_creation_fee ~constraint_constants action amount\n in\n add_amount b amount )\n ~modify_timing:(fun acc ->\n update_timing_when_no_deduction ~txn_global_slot acc )\n in\n let ft_with_status =\n if Transaction_status.Failure.Collection.is_empty failures then\n { With_status.data = transfer; status = Applied }\n else { data = transfer; status = Failed failures }\n in\n Transaction_applied.Fee_transfer_applied.\n { fee_transfer = ft_with_status; new_accounts; burned_tokens }\n\n (*Structure of the failure status:\n I. No fee transfer and coinbase transfer fails: [[failure]]\n II. With fee transfer-\n Both fee transfer and coinbase fails:\n [[failure-of-fee-transfer]; [failure-of-coinbase]]\n Fee transfer succeeds and coinbase fails:\n [[];[failure-of-coinbase]]\n Fee transfer fails and coinbase succeeds:\n [[failure-of-fee-transfer];[]]\n *)\n let apply_coinbase ~constraint_constants ~txn_global_slot t\n (* TODO: Better system needed for making atomic changes. Could use a monad. *)\n ({ receiver; fee_transfer; amount = coinbase_amount } as cb : Coinbase.t)\n =\n let open Or_error.Let_syntax in\n let%bind ( receiver_reward\n , new_accounts1\n , transferee_update\n , transferee_timing_prev\n , failures1\n , burned_tokens1 ) =\n match fee_transfer with\n | None ->\n return (coinbase_amount, [], None, None, empty, Currency.Amount.zero)\n | Some ({ receiver_pk = transferee; fee } as ft) ->\n assert (not @@ Public_key.Compressed.equal transferee receiver) ;\n let transferee_id = Coinbase.Fee_transfer.receiver ft in\n let fee = Amount.of_fee fee in\n let%bind receiver_reward =\n error_opt \"Coinbase fee transfer too large\"\n (Amount.sub coinbase_amount fee)\n in\n let transferee_account, action, `Has_permission_to_receive can_receive\n =\n has_permission_to_receive ~ledger:t transferee_id\n in\n let new_accounts = get_new_accounts action transferee_id in\n let%bind timing =\n update_timing_when_no_deduction ~txn_global_slot transferee_account\n in\n let%bind balance =\n let%bind amount =\n sub_account_creation_fee ~constraint_constants action fee\n in\n add_amount transferee_account.balance amount\n in\n if can_receive then\n let%map _action, transferee_account, transferee_location =\n get_or_create t transferee_id\n in\n ( receiver_reward\n , new_accounts\n , Some\n ( transferee_location\n , { transferee_account with balance; timing } )\n , Some transferee_account.timing\n , append_entry no_failure empty\n , Currency.Amount.zero )\n else return (receiver_reward, [], None, None, single_failure, fee)\n in\n let receiver_id = Account_id.create receiver Token_id.default in\n let receiver_account, action2, `Has_permission_to_receive can_receive =\n has_permission_to_receive ~ledger:t receiver_id\n in\n let new_accounts2 = get_new_accounts action2 receiver_id in\n (* Note: Updating coinbase receiver timing only if there is no fee transfer.\n This is so as to not add any extra constraints in transaction snark for checking\n \"receiver\" timings. This is OK because timing rules will not be violated when\n balance increases and will be checked whenever an amount is deducted from the\n account (#5973)\n *)\n let%bind coinbase_receiver_timing =\n match transferee_timing_prev with\n | None ->\n let%map new_receiver_timing =\n update_timing_when_no_deduction ~txn_global_slot receiver_account\n in\n new_receiver_timing\n | Some _timing ->\n Ok receiver_account.timing\n in\n let%bind receiver_balance =\n let%bind amount =\n sub_account_creation_fee ~constraint_constants action2 receiver_reward\n in\n add_amount receiver_account.balance amount\n in\n let%bind failures, burned_tokens2 =\n if can_receive then (\n let%map _action2, receiver_account, receiver_location =\n get_or_create t receiver_id\n in\n set t receiver_location\n { receiver_account with\n balance = receiver_balance\n ; timing = coinbase_receiver_timing\n } ;\n (append_entry no_failure failures1, Currency.Amount.zero) )\n else return (append_entry update_failed failures1, receiver_reward)\n in\n Option.iter transferee_update ~f:(fun (l, a) -> set t l a) ;\n let%map burned_tokens =\n error_opt \"burned tokens overflow\"\n (Amount.add burned_tokens1 burned_tokens2)\n in\n let coinbase_with_status =\n if Transaction_status.Failure.Collection.is_empty failures then\n { With_status.data = cb; status = Applied }\n else { With_status.data = cb; status = Failed failures }\n in\n Transaction_applied.Coinbase_applied.\n { coinbase = coinbase_with_status\n ; new_accounts = new_accounts1 @ new_accounts2\n ; burned_tokens\n }\n\n let apply_transaction_first_pass ~constraint_constants ~global_slot\n ~(txn_state_view : Zkapp_precondition.Protocol_state.View.t) ledger\n (t : Transaction.t) : Transaction_partially_applied.t Or_error.t =\n let open Or_error.Let_syntax in\n let previous_hash = merkle_root ledger in\n let txn_global_slot = global_slot in\n match t with\n | Command (Signed_command txn) ->\n let%map applied =\n apply_user_command_unchecked ~constraint_constants ~txn_global_slot\n ledger txn\n in\n Transaction_partially_applied.Signed_command { previous_hash; applied }\n | Command (Zkapp_command txn) ->\n let%map partially_applied =\n apply_zkapp_command_first_pass ~global_slot ~state_view:txn_state_view\n ~constraint_constants ledger txn\n in\n Transaction_partially_applied.Zkapp_command partially_applied\n | Fee_transfer t ->\n let%map applied =\n apply_fee_transfer ~constraint_constants ~txn_global_slot ledger t\n in\n Transaction_partially_applied.Fee_transfer { previous_hash; applied }\n | Coinbase t ->\n let%map applied =\n apply_coinbase ~constraint_constants ~txn_global_slot ledger t\n in\n Transaction_partially_applied.Coinbase { previous_hash; applied }\n\n let apply_transaction_second_pass ledger (t : Transaction_partially_applied.t)\n : Transaction_applied.t Or_error.t =\n let open Or_error.Let_syntax in\n let open Transaction_applied in\n match t with\n | Signed_command { previous_hash; applied } ->\n return\n { previous_hash; varying = Varying.Command (Signed_command applied) }\n | Zkapp_command partially_applied ->\n (* TODO: either here or in second phase of apply, need to update the prior global state statement for the fee payer segment to add the second phase ledger at the end *)\n let%map applied =\n apply_zkapp_command_second_pass ledger partially_applied\n in\n { previous_hash = partially_applied.previous_hash\n ; varying = Varying.Command (Zkapp_command applied)\n }\n | Fee_transfer { previous_hash; applied } ->\n return { previous_hash; varying = Varying.Fee_transfer applied }\n | Coinbase { previous_hash; applied } ->\n return { previous_hash; varying = Varying.Coinbase applied }\n\n let apply_transactions ~constraint_constants ~global_slot ~txn_state_view\n ledger txns =\n let open Or_error in\n Mina_stdlib.Result.List.map txns\n ~f:\n (apply_transaction_first_pass ~constraint_constants ~global_slot\n ~txn_state_view ledger )\n >>= Mina_stdlib.Result.List.map ~f:(apply_transaction_second_pass ledger)\n\n module For_tests = struct\n let validate_timing_with_min_balance = validate_timing_with_min_balance\n\n let validate_timing = validate_timing\n end\nend\n\nmodule For_tests = struct\n open Mina_numbers\n open Currency\n\n module Account_without_receipt_chain_hash = struct\n type t =\n ( Public_key.Compressed.t\n , Token_id.t\n , Account.Token_symbol.t\n , Balance.t\n , Account_nonce.t\n , unit\n , Public_key.Compressed.t option\n , State_hash.t\n , Account_timing.t\n , Permissions.t\n , Zkapp_account.t option )\n Account.Poly.t\n [@@deriving sexp, compare]\n end\n\n let min_init_balance = Int64.of_string \"8000000000\"\n\n let max_init_balance = Int64.of_string \"8000000000000\"\n\n let num_accounts = 10\n\n let num_transactions = 10\n\n let depth = Int.ceil_log2 (num_accounts + num_transactions)\n\n module Init_ledger = struct\n type t = (Keypair.t * int64) array [@@deriving sexp]\n\n let init ?(zkapp = true) (type l) (module L : Ledger_intf.S with type t = l)\n (init_ledger : t) (l : L.t) =\n Array.iter init_ledger ~f:(fun (kp, amount) ->\n let _tag, account, loc =\n L.get_or_create l\n (Account_id.create\n (Public_key.compress kp.public_key)\n Token_id.default )\n |> Or_error.ok_exn\n in\n let permissions : Permissions.t =\n { edit_state = Either\n ; send = Either\n ; receive = None\n ; set_delegate = Either\n ; set_permissions = Either\n ; set_verification_key = Either\n ; set_zkapp_uri = Either\n ; edit_action_state = Either\n ; set_token_symbol = Either\n ; increment_nonce = Either\n ; set_voting_for = Either\n ; access = None\n ; set_timing = Either\n }\n in\n let zkapp =\n if zkapp then\n Some\n { Zkapp_account.default with\n verification_key =\n Some\n { With_hash.hash = Zkapp_basic.F.zero\n ; data = Side_loaded_verification_key.dummy\n }\n }\n else None\n in\n L.set l loc\n { account with\n balance =\n Currency.Balance.of_uint64 (Unsigned.UInt64.of_int64 amount)\n ; permissions\n ; zkapp\n } )\n\n let gen () : t Quickcheck.Generator.t =\n let tbl = Public_key.Compressed.Hash_set.create () in\n let open Quickcheck.Generator in\n let open Let_syntax in\n let rec go acc n =\n if n = 0 then return (Array.of_list acc)\n else\n let%bind kp =\n filter Keypair.gen ~f:(fun kp ->\n not (Hash_set.mem tbl (Public_key.compress kp.public_key)) )\n and amount = Int64.gen_incl min_init_balance max_init_balance in\n Hash_set.add tbl (Public_key.compress kp.public_key) ;\n go ((kp, amount) :: acc) (n - 1)\n in\n go [] num_accounts\n end\n\n module Transaction_spec = struct\n type t =\n { fee : Currency.Fee.t\n ; sender : Keypair.t * Account_nonce.t\n ; receiver : Public_key.Compressed.t\n ; amount : Currency.Amount.t\n }\n [@@deriving sexp]\n\n let gen ~(init_ledger : Init_ledger.t) ~nonces =\n let pk ((kp : Keypair.t), _) = Public_key.compress kp.public_key in\n let open Quickcheck.Let_syntax in\n let%bind receiver_is_new = Bool.quickcheck_generator in\n let gen_index () = Int.gen_incl 0 (Array.length init_ledger - 1) in\n let%bind receiver_index =\n if receiver_is_new then return None else gen_index () >>| Option.return\n in\n let%bind receiver =\n match receiver_index with\n | None ->\n Public_key.Compressed.gen\n | Some i ->\n return (pk init_ledger.(i))\n in\n let%bind sender =\n let%map i =\n match receiver_index with\n | None ->\n gen_index ()\n | Some j ->\n Quickcheck.Generator.filter (gen_index ()) ~f:(( <> ) j)\n in\n fst init_ledger.(i)\n in\n let gen_amount () =\n Currency.Amount.(\n gen_incl\n (of_nanomina_int_exn 1_000_000)\n (of_nanomina_int_exn 100_000_000))\n in\n let gen_fee () =\n Currency.Fee.(\n gen_incl\n (of_nanomina_int_exn 1_000_000)\n (of_nanomina_int_exn 100_000_000))\n in\n let nonce : Account_nonce.t = Map.find_exn nonces sender in\n let%bind fee = gen_fee () in\n let%bind amount = gen_amount () in\n let nonces =\n Map.set nonces ~key:sender ~data:(Account_nonce.succ nonce)\n in\n let spec = { fee; amount; receiver; sender = (sender, nonce) } in\n return (spec, nonces)\n end\n\n module Test_spec = struct\n type t = { init_ledger : Init_ledger.t; specs : Transaction_spec.t list }\n [@@deriving sexp]\n\n let mk_gen ?(num_transactions = num_transactions) () =\n let open Quickcheck.Let_syntax in\n let%bind init_ledger = Init_ledger.gen () in\n let%bind specs =\n let rec go acc n nonces =\n if n = 0 then return (List.rev acc)\n else\n let%bind spec, nonces = Transaction_spec.gen ~init_ledger ~nonces in\n go (spec :: acc) (n - 1) nonces\n in\n go [] num_transactions\n (Keypair.Map.of_alist_exn\n (List.map (Array.to_list init_ledger) ~f:(fun (pk, _) ->\n (pk, Account_nonce.zero) ) ) )\n in\n return { init_ledger; specs }\n\n let gen = mk_gen ~num_transactions ()\n end\n\n let command_send\n { Transaction_spec.fee; sender = sender, sender_nonce; receiver; amount }\n : Signed_command.t =\n let sender_pk = Public_key.compress sender.public_key in\n Signed_command.sign sender\n { common =\n { fee\n ; fee_payer_pk = sender_pk\n ; nonce = sender_nonce\n ; valid_until = Global_slot_since_genesis.max_value\n ; memo = Signed_command_memo.dummy\n }\n ; body = Payment { receiver_pk = receiver; amount }\n }\n |> Signed_command.forget_check\n\n let account_update_send ?(use_full_commitment = true)\n ?(double_sender_nonce = true)\n { Transaction_spec.fee; sender = sender, sender_nonce; receiver; amount }\n : Zkapp_command.t =\n let sender_pk = Public_key.compress sender.public_key in\n let actual_nonce =\n (* Here, we double the spec'd nonce, because we bump the nonce a second\n time for the 'sender' part of the payment.\n *)\n (* TODO: We should make bumping the nonce for signed zkapp_command optional,\n flagged by a field in the account_update (but always true for the fee payer).\n\n This would also allow us to prevent replays of snapp proofs, by\n allowing them to bump their nonce.\n *)\n if double_sender_nonce then\n sender_nonce |> Account.Nonce.to_uint32\n |> Unsigned.UInt32.(mul (of_int 2))\n |> Account.Nonce.to_uint32\n else sender_nonce\n in\n let zkapp_command : Zkapp_command.Simple.t =\n { fee_payer =\n { Account_update.Fee_payer.body =\n { public_key = sender_pk\n ; fee\n ; valid_until = None\n ; nonce = actual_nonce\n }\n (* Real signature added in below *)\n ; authorization = Signature.dummy\n }\n ; account_updates =\n [ { body =\n { public_key = sender_pk\n ; update = Account_update.Update.noop\n ; token_id = Token_id.default\n ; balance_change = Amount.Signed.(negate (of_unsigned amount))\n ; increment_nonce = double_sender_nonce\n ; events = []\n ; actions = []\n ; call_data = Snark_params.Tick.Field.zero\n ; call_depth = 0\n ; preconditions =\n { Account_update.Preconditions.network =\n Zkapp_precondition.Protocol_state.accept\n ; account = Accept\n ; valid_while = Ignore\n }\n ; may_use_token = No\n ; use_full_commitment\n ; implicit_account_creation_fee = true\n ; authorization_kind =\n ( if use_full_commitment then Signature\n else Proof Zkapp_basic.F.zero )\n }\n ; authorization =\n ( if use_full_commitment then Signature Signature.dummy\n else Proof Mina_base.Proof.transaction_dummy )\n }\n ; { body =\n { public_key = receiver\n ; update = Account_update.Update.noop\n ; token_id = Token_id.default\n ; balance_change = Amount.Signed.of_unsigned amount\n ; increment_nonce = false\n ; events = []\n ; actions = []\n ; call_data = Snark_params.Tick.Field.zero\n ; call_depth = 0\n ; preconditions =\n { Account_update.Preconditions.network =\n Zkapp_precondition.Protocol_state.accept\n ; account = Accept\n ; valid_while = Ignore\n }\n ; may_use_token = No\n ; use_full_commitment = false\n ; implicit_account_creation_fee = true\n ; authorization_kind = None_given\n }\n ; authorization = None_given\n }\n ]\n ; memo = Signed_command_memo.empty\n }\n in\n let zkapp_command = Zkapp_command.of_simple zkapp_command in\n let commitment = Zkapp_command.commitment zkapp_command in\n let full_commitment =\n Zkapp_command.Transaction_commitment.create_complete commitment\n ~memo_hash:(Signed_command_memo.hash zkapp_command.memo)\n ~fee_payer_hash:\n (Zkapp_command.Digest.Account_update.create\n (Account_update.of_fee_payer zkapp_command.fee_payer) )\n in\n let account_updates_signature =\n let c = if use_full_commitment then full_commitment else commitment in\n Schnorr.Chunked.sign sender.private_key\n (Random_oracle.Input.Chunked.field c)\n in\n let account_updates =\n Zkapp_command.Call_forest.map zkapp_command.account_updates\n ~f:(fun (account_update : Account_update.t) ->\n match account_update.body.authorization_kind with\n | Signature ->\n { account_update with\n authorization = Control.Signature account_updates_signature\n }\n | _ ->\n account_update )\n in\n let signature =\n Schnorr.Chunked.sign sender.private_key\n (Random_oracle.Input.Chunked.field full_commitment)\n in\n { zkapp_command with\n fee_payer = { zkapp_command.fee_payer with authorization = signature }\n ; account_updates\n }\n\n let test_eq (type l) (module L : Ledger_intf.S with type t = l) accounts\n (l1 : L.t) (l2 : L.t) =\n List.map accounts ~f:(fun a ->\n Or_error.try_with (fun () ->\n let mismatch () =\n failwithf\n !\"One ledger had the account %{sexp:Account_id.t} but the \\\n other did not\"\n a ()\n in\n let hide_rc (a : _ Account.Poly.t) =\n { a with receipt_chain_hash = () }\n in\n match L.(location_of_account l1 a, location_of_account l2 a) with\n | None, None ->\n ()\n | Some _, None | None, Some _ ->\n mismatch ()\n | Some x1, Some x2 -> (\n match L.(get l1 x1, get l2 x2) with\n | None, None ->\n ()\n | Some _, None | None, Some _ ->\n mismatch ()\n | Some a1, Some a2 ->\n [%test_eq: Account_without_receipt_chain_hash.t]\n (hide_rc a1) (hide_rc a2) ) ) )\n |> Or_error.combine_errors_unit\n\n let txn_global_slot = Global_slot_since_genesis.zero\n\n let iter_err ts ~f =\n List.fold_until ts\n ~finish:(fun () -> Ok ())\n ~init:()\n ~f:(fun () t ->\n match f t with Error e -> Stop (Error e) | Ok _ -> Continue () )\n\n let view : Zkapp_precondition.Protocol_state.View.t =\n let h = Frozen_ledger_hash.empty_hash in\n let len = Length.zero in\n let a = Currency.Amount.zero in\n let epoch_data =\n { Epoch_data.Poly.ledger =\n { Epoch_ledger.Poly.hash = h; total_currency = a }\n ; seed = h\n ; start_checkpoint = h\n ; lock_checkpoint = h\n ; epoch_length = len\n }\n in\n { snarked_ledger_hash = h\n ; blockchain_length = len\n ; min_window_density = len\n ; total_currency = a\n ; global_slot_since_genesis = txn_global_slot\n ; staking_epoch_data = epoch_data\n ; next_epoch_data = epoch_data\n }\n\n (* Quickcheck generator for Zkapp_command.t, derived from Test_spec generator *)\n let gen_zkapp_command_from_test_spec =\n let open Quickcheck.Let_syntax in\n let%bind use_full_commitment = Bool.quickcheck_generator in\n match%map Test_spec.mk_gen ~num_transactions:1 () with\n | { specs = [ spec ]; _ } ->\n account_update_send ~use_full_commitment spec\n | { specs; _ } ->\n failwithf \"gen_zkapp_command_from_test_spec: expected one spec, got %d\"\n (List.length specs) ()\nend\n","open Core_kernel\nmodule Js = Js_of_ocaml.Js\nmodule Impl = Pickles.Impls.Step\nmodule Other_impl = Pickles.Impls.Wrap\nmodule Field = Impl.Field\nmodule Account_update = Mina_base.Account_update\nmodule Zkapp_command = Mina_base.Zkapp_command\n\n(* Test - functions that have a ts implementation, exposed for ts-ml consistency tests *)\n\nmodule Encoding = struct\n (* arbitrary base58_check encoding *)\n let binary_string_to_base58_check bin_string (version_byte : int) :\n Js.js_string Js.t =\n let module T = struct\n let version_byte = Char.of_int_exn version_byte\n\n let description = \"any\"\n end in\n let module B58 = Base58_check.Make (T) in\n bin_string |> B58.encode |> Js.string\n\n let binary_string_of_base58_check (base58 : Js.js_string Js.t)\n (version_byte : int) =\n let module T = struct\n let version_byte = Char.of_int_exn version_byte\n\n let description = \"any\"\n end in\n let module B58 = Base58_check.Make (T) in\n base58 |> Js.to_string |> B58.decode_exn\n\n (* base58 encoding of some transaction types *)\n let public_key_to_base58 (pk : Signature_lib.Public_key.Compressed.t) :\n Js.js_string Js.t =\n pk |> Signature_lib.Public_key.Compressed.to_base58_check |> Js.string\n\n let public_key_of_base58 (pk_base58 : Js.js_string Js.t) :\n Signature_lib.Public_key.Compressed.t =\n pk_base58 |> Js.to_string\n |> Signature_lib.Public_key.Compressed.of_base58_check_exn\n\n let private_key_to_base58 (sk : Other_impl.field) : Js.js_string Js.t =\n sk |> Signature_lib.Private_key.to_base58_check |> Js.string\n\n let private_key_of_base58 (sk_base58 : Js.js_string Js.t) : Other_impl.field =\n sk_base58 |> Js.to_string |> Signature_lib.Private_key.of_base58_check_exn\n\n let token_id_to_base58 (field : Impl.field) : Js.js_string Js.t =\n field |> Mina_base.Account_id.Digest.of_field\n |> Mina_base.Account_id.Digest.to_string |> Js.string\n\n let token_id_of_base58 (field : Js.js_string Js.t) : Impl.field =\n Mina_base.Account_id.Digest.to_field_unsafe\n @@ Mina_base.Account_id.Digest.of_string @@ Js.to_string field\n\n let memo_to_base58 (memo : Js.js_string Js.t) : Js.js_string Js.t =\n Js.string @@ Mina_base.Signed_command_memo.to_base58_check\n @@ Mina_base.Signed_command_memo.create_from_string_exn @@ Js.to_string memo\n\n let memo_hash_base58 (memo_base58 : Js.js_string Js.t) : Impl.field =\n memo_base58 |> Js.to_string\n |> Mina_base.Signed_command_memo.of_base58_check_exn\n |> Mina_base.Signed_command_memo.hash\nend\n\nmodule Token_id = struct\n let derive pk token =\n let account_id =\n Mina_base.Account_id.create pk (Mina_base.Token_id.of_field token)\n in\n Mina_base.Account_id.derive_token_id ~owner:account_id\n |> Mina_base.Token_id.to_field_unsafe\n\n let derive_checked pk token =\n let account_id =\n Mina_base.Account_id.Checked.create pk\n (Mina_base.Token_id.Checked.of_field token)\n in\n Mina_base.Account_id.Checked.derive_token_id ~owner:account_id\n |> Mina_base.Account_id.Digest.Checked.to_field_unsafe\nend\n\n(* deriver *)\nlet account_update_of_json, _account_update_to_json =\n let deriver =\n Account_update.Graphql_repr.deriver @@ Fields_derivers_zkapps.Derivers.o ()\n in\n let account_update_of_json (account_update : Js.js_string Js.t) :\n Account_update.t =\n Fields_derivers_zkapps.of_json deriver\n (account_update |> Js.to_string |> Yojson.Safe.from_string)\n |> Account_update.of_graphql_repr\n in\n let account_update_to_json (account_update : Account_update.t) :\n Js.js_string Js.t =\n Fields_derivers_zkapps.to_json deriver\n (Account_update.to_graphql_repr account_update ~call_depth:0)\n |> Yojson.Safe.to_string |> Js.string\n in\n (account_update_of_json, account_update_to_json)\n\nlet body_of_json =\n let body_deriver =\n Mina_base.Account_update.Body.Graphql_repr.deriver\n @@ Fields_derivers_zkapps.o ()\n in\n let body_of_json json =\n json\n |> Fields_derivers_zkapps.of_json body_deriver\n |> Account_update.Body.of_graphql_repr\n in\n body_of_json\n\nmodule Poseidon = struct\n let hash_to_group (xs : Impl.field array) =\n let input = Random_oracle.hash xs in\n Snark_params.Group_map.to_group input\nend\n\nmodule Signature = struct\n let sign_field_element (x : Impl.field) (key : Other_impl.field)\n (is_mainnet : bool Js.t) =\n let network_id =\n Mina_signature_kind.(if Js.to_bool is_mainnet then Mainnet else Testnet)\n in\n Signature_lib.Schnorr.Chunked.sign ~signature_kind:network_id key\n (Random_oracle.Input.Chunked.field x)\n |> Mina_base.Signature.to_base58_check |> Js.string\n\n let dummy_signature () =\n Mina_base.Signature.(dummy |> to_base58_check) |> Js.string\nend\n\nmodule To_fields = struct\n (* helper function to check whether the fields we produce from JS are correct *)\n let fields_of_json\n (typ : ('var, 'value, Field.Constant.t, 'tmp) Impl.Internal_Basic.Typ.typ)\n of_json (json : Js.js_string Js.t) : Impl.field array =\n let json = json |> Js.to_string |> Yojson.Safe.from_string in\n let value = of_json json in\n let (Typ typ) = typ in\n let fields, _ = typ.value_to_fields value in\n fields\n\n let account_update =\n fields_of_json (Mina_base.Account_update.Body.typ ()) body_of_json\nend\n\nmodule Hash_from_json = struct\n let account_update (p : Js.js_string Js.t) =\n p |> account_update_of_json |> Account_update.digest\n\n let transaction_commitments (tx_json : Js.js_string Js.t) =\n let tx =\n Zkapp_command.of_json @@ Yojson.Safe.from_string @@ Js.to_string tx_json\n in\n let commitment = Zkapp_command.commitment tx in\n let fee_payer = Account_update.of_fee_payer tx.fee_payer in\n let fee_payer_hash = Zkapp_command.Digest.Account_update.create fee_payer in\n let full_commitment =\n Zkapp_command.Transaction_commitment.create_complete commitment\n ~memo_hash:(Mina_base.Signed_command_memo.hash tx.memo)\n ~fee_payer_hash\n in\n object%js\n val commitment = commitment\n\n val fullCommitment = full_commitment\n\n val feePayerHash = (fee_payer_hash :> Impl.field)\n end\n\n let zkapp_public_input (tx_json : Js.js_string Js.t)\n (account_update_index : int) =\n let tx =\n Zkapp_command.of_json @@ Yojson.Safe.from_string @@ Js.to_string tx_json\n in\n let account_update = List.nth_exn tx.account_updates account_update_index in\n object%js\n val accountUpdate =\n (account_update.elt.account_update_digest :> Impl.field)\n\n val calls =\n (Zkapp_command.Call_forest.hash account_update.elt.calls :> Impl.field)\n end\nend\n\nmodule Hash_input = struct\n type random_oracle_input = Impl.field Random_oracle_input.Chunked.t\n\n let pack_input (input : random_oracle_input) : Impl.field array =\n Random_oracle.pack_input input\n\n (* hash inputs for various account_update subtypes *)\n let timing_input (json : Js.js_string Js.t) : random_oracle_input =\n let deriver = Account_update.Update.Timing_info.deriver in\n let json = json |> Js.to_string |> Yojson.Safe.from_string in\n let value = Fields_derivers_zkapps.(of_json (deriver @@ o ()) json) in\n let input = Account_update.Update.Timing_info.to_input value in\n input\n\n let permissions_input (json : Js.js_string Js.t) : random_oracle_input =\n let deriver = Mina_base.Permissions.deriver in\n let json = json |> Js.to_string |> Yojson.Safe.from_string in\n let value = Fields_derivers_zkapps.(of_json (deriver @@ o ()) json) in\n let input = Mina_base.Permissions.to_input value in\n input\n\n let update_input (json : Js.js_string Js.t) : random_oracle_input =\n let deriver = Account_update.Update.deriver in\n let json = json |> Js.to_string |> Yojson.Safe.from_string in\n let value = Fields_derivers_zkapps.(of_json (deriver @@ o ()) json) in\n let input = Account_update.Update.to_input value in\n input\n\n let account_precondition_input (json : Js.js_string Js.t) :\n random_oracle_input =\n let deriver = Mina_base.Zkapp_precondition.Account.deriver in\n let json = json |> Js.to_string |> Yojson.Safe.from_string in\n let value = Fields_derivers_zkapps.(of_json (deriver @@ o ()) json) in\n let input = Mina_base.Zkapp_precondition.Account.to_input value in\n input\n\n let network_precondition_input (json : Js.js_string Js.t) :\n random_oracle_input =\n let deriver = Mina_base.Zkapp_precondition.Protocol_state.deriver in\n let json = json |> Js.to_string |> Yojson.Safe.from_string in\n let value = Fields_derivers_zkapps.(of_json (deriver @@ o ()) json) in\n let input = Mina_base.Zkapp_precondition.Protocol_state.to_input value in\n input\n\n let body_input (json : Js.js_string Js.t) : random_oracle_input =\n let json = json |> Js.to_string |> Yojson.Safe.from_string in\n let value = body_of_json json in\n let input = Account_update.Body.to_input value in\n input\nend\n\nmodule Transaction_hash = struct\n module Signed_command = Mina_base.Signed_command\n module Signed_command_payload = Mina_base.Signed_command_payload\n\n let ok_exn result =\n let open Ppx_deriving_yojson_runtime.Result in\n match result with Ok c -> c | Error e -> failwith (\"not ok: \" ^ e)\n\n let keypair () = Signature_lib.Keypair.create ()\n\n let hash_payment (command : Js.js_string Js.t) =\n let command : Signed_command.t =\n command |> Js.to_string |> Yojson.Safe.from_string\n |> Signed_command.of_yojson |> ok_exn\n in\n Mina_transaction.Transaction_hash.(\n command |> hash_signed_command |> to_base58_check |> Js.string)\n\n let hash_payment_v1 (command : Js.js_string Js.t) =\n let command : Signed_command.t_v1 =\n command |> Js.to_string |> Yojson.Safe.from_string\n |> Signed_command.Stable.V1.of_yojson |> ok_exn\n in\n let b58 = Signed_command.to_base58_check_v1 command in\n Mina_transaction.Transaction_hash.(b58 |> digest_string |> to_base58_check)\n |> Js.string\n\n let serialize_common (command : Js.js_string Js.t) =\n let command : Signed_command_payload.Common.t =\n command |> Js.to_string |> Yojson.Safe.from_string\n |> Signed_command_payload.Common.of_yojson |> ok_exn\n in\n Binable.to_bigstring\n (module Signed_command_payload.Common.Stable.Latest)\n command\n\n let serialize_payment (command : Js.js_string Js.t) =\n let command : Signed_command.t =\n command |> Js.to_string |> Yojson.Safe.from_string\n |> Signed_command.of_yojson |> ok_exn\n in\n Binable.to_bigstring (module Signed_command.Stable.Latest) command\n\n let serialize_payment_v1 (command : Js.js_string Js.t) =\n let command : Signed_command.t_v1 =\n command |> Js.to_string |> Yojson.Safe.from_string\n |> Signed_command.Stable.V1.of_yojson |> ok_exn\n in\n Signed_command.to_base58_check_v1 command |> Js.string\n\n let example_payment =\n let kp = keypair () in\n let payload : Signed_command_payload.t =\n { Signed_command_payload.dummy with\n common =\n { Signed_command_payload.dummy.common with\n fee_payer_pk = Signature_lib.Public_key.compress kp.public_key\n }\n }\n in\n let payment = Signed_command.sign kp payload in\n (payment :> Signed_command.t)\n |> Signed_command.to_yojson |> Yojson.Safe.to_string |> Js.string\nend\n\nlet test =\n object%js\n val encoding =\n let open Encoding in\n object%js\n val toBase58 = binary_string_to_base58_check\n\n val ofBase58 = binary_string_of_base58_check\n\n method publicKeyToBase58 = public_key_to_base58\n\n method publicKeyOfBase58 = public_key_of_base58\n\n method privateKeyToBase58 = private_key_to_base58\n\n method privateKeyOfBase58 = private_key_of_base58\n\n method tokenIdToBase58 = token_id_to_base58\n\n method tokenIdOfBase58 = token_id_of_base58\n\n method memoToBase58 = memo_to_base58\n\n method memoHashBase58 = memo_hash_base58\n end\n\n val tokenId =\n object%js\n method derive = Token_id.derive\n\n method deriveChecked = Token_id.derive_checked\n end\n\n val poseidon =\n object%js\n val hashToGroup = Poseidon.hash_to_group\n end\n\n val signature =\n object%js\n method signFieldElement = Signature.sign_field_element\n\n val dummySignature = Signature.dummy_signature\n end\n\n val fieldsFromJson =\n object%js\n method accountUpdate = To_fields.account_update\n end\n\n val hashFromJson =\n object%js\n method accountUpdate = Hash_from_json.account_update\n\n method transactionCommitments = Hash_from_json.transaction_commitments\n\n method zkappPublicInput = Hash_from_json.zkapp_public_input\n end\n\n val hashInputFromJson =\n let open Hash_input in\n object%js\n val packInput = pack_input\n\n val timing = timing_input\n\n val permissions = permissions_input\n\n val accountPrecondition = account_precondition_input\n\n val networkPrecondition = network_precondition_input\n\n val update = update_input\n\n val body = body_input\n end\n\n val transactionHash =\n let open Transaction_hash in\n object%js\n method hashPayment = hash_payment\n\n method hashPaymentV1 = hash_payment_v1\n\n method serializeCommon = serialize_common\n\n method serializePayment = serialize_payment\n\n method serializePaymentV1 = serialize_payment_v1\n\n method examplePayment = example_payment\n end\n end\n","open Core_kernel\nmodule Js = Js_of_ocaml.Js\nmodule Impl = Pickles.Impls.Step\nmodule Field = Impl.Field\nmodule Boolean = Impl.Boolean\nmodule Typ = Impl.Typ\n\nmodule Public_input = struct\n type t = Field.t array\n\n module Constant = struct\n type t = Field.Constant.t array\n end\nend\n\ntype 'a statement = 'a array * 'a array\n\nmodule Statement = struct\n type t = Field.t statement\n\n module Constant = struct\n type t = Field.Constant.t statement\n end\nend\n\nlet public_input_typ (i : int) = Typ.array ~length:i Field.typ\n\nlet statement_typ (input_size : int) (output_size : int) =\n Typ.(array ~length:input_size Field.typ * array ~length:output_size Field.typ)\n\ntype ('prev_proof, 'proof) js_prover =\n Public_input.Constant.t\n -> 'prev_proof array\n -> (Public_input.Constant.t * 'proof) Promise_js_helpers.js_promise\n\nlet dummy_constraints =\n let module Inner_curve = Kimchi_pasta.Pasta.Pallas in\n let module Step_main_inputs = Pickles.Step_main_inputs in\n let inner_curve_typ : (Field.t * Field.t, Inner_curve.t) Typ.t =\n Typ.transport Step_main_inputs.Inner_curve.typ\n ~there:Inner_curve.to_affine_exn ~back:Inner_curve.of_affine\n in\n fun () ->\n let x =\n Impl.exists Field.typ ~compute:(fun () -> Field.Constant.of_int 3)\n in\n let g = Impl.exists inner_curve_typ ~compute:(fun _ -> Inner_curve.one) in\n ignore\n ( Pickles.Scalar_challenge.to_field_checked'\n (module Impl)\n ~num_bits:16\n (Kimchi_backend_common.Scalar_challenge.create x)\n : Field.t * Field.t * Field.t ) ;\n ignore\n ( Step_main_inputs.Ops.scale_fast g ~num_bits:5 (Shifted_value x)\n : Step_main_inputs.Inner_curve.t ) ;\n ignore\n ( Pickles.Step_verifier.Scalar_challenge.endo g ~num_bits:4\n (Kimchi_backend_common.Scalar_challenge.create x)\n : Field.t * Field.t )\n\ntype pickles_rule_js =\n < identifier : Js.js_string Js.t Js.prop\n ; main :\n ( Public_input.t\n -> < publicOutput : Public_input.t Js.prop\n ; previousStatements : Statement.t array Js.prop\n ; shouldVerify : Boolean.var array Js.prop >\n Js.t )\n Js.prop\n ; proofsToVerify :\n < isSelf : bool Js.t Js.prop ; tag : Js.Unsafe.any Js.t Js.prop > Js.t\n array\n Js.prop >\n Js.t\n\nmodule Choices = struct\n open Pickles_types\n open Hlist\n\n module Prevs = struct\n type ('var, 'value, 'width, 'height) t =\n | Prevs :\n ( self:('var, 'value, 'width, 'height) Pickles.Tag.t\n -> ('prev_var, 'prev_values, 'widths, 'heights) H4.T(Pickles.Tag).t\n )\n -> ('var, 'value, 'width, 'height) t\n\n let of_rule (rule : pickles_rule_js) =\n let js_prevs = rule##.proofsToVerify in\n let rec get_tags (Prevs prevs) index =\n if index < 0 then Prevs prevs\n else\n let js_tag = Array.get js_prevs index in\n (* We introduce new opaque types to make sure that the type in the tag\n doesn't escape into the environment or have other ill effects.\n *)\n let module Types = struct\n type var\n\n type value\n\n type width\n\n type height\n end in\n let open Types in\n let to_tag ~self tag : (var, value, width, height) Pickles.Tag.t =\n (* The magic here isn't ideal, but it's safe enough if we immediately\n hide it behind [Types].\n *)\n if Js.to_bool tag##.isSelf then Obj.magic self\n else Obj.magic tag##.tag\n in\n let tag = to_tag js_tag in\n let prevs ~self : _ H4.T(Pickles.Tag).t = tag ~self :: prevs ~self in\n get_tags (Prevs prevs) (index - 1)\n in\n get_tags (Prevs (fun ~self:_ -> [])) (Array.length js_prevs - 1)\n end\n\n module Inductive_rule = struct\n type ( 'var\n , 'value\n , 'width\n , 'height\n , 'arg_var\n , 'arg_value\n , 'ret_var\n , 'ret_value\n , 'auxiliary_var\n , 'auxiliary_value )\n t =\n | Rule :\n ( self:('var, 'value, 'width, 'height) Pickles.Tag.t\n -> ( 'prev_vars\n , 'prev_values\n , 'widths\n , 'heights\n , 'arg_var\n , 'arg_value\n , 'ret_var\n , 'ret_value\n , 'auxiliary_var\n , 'auxiliary_value )\n Pickles.Inductive_rule.t )\n -> ( 'var\n , 'value\n , 'width\n , 'height\n , 'arg_var\n , 'arg_value\n , 'ret_var\n , 'ret_value\n , 'auxiliary_var\n , 'auxiliary_value )\n t\n\n let rec should_verifys :\n type prev_vars prev_values widths heights.\n int\n -> (prev_vars, prev_values, widths, heights) H4.T(Pickles.Tag).t\n -> Boolean.var array\n -> prev_vars H1.T(E01(Pickles.Inductive_rule.B)).t =\n fun index tags should_verifys_js ->\n match tags with\n | [] ->\n []\n | _ :: tags ->\n let js_bool = Array.get should_verifys_js index in\n let should_verifys =\n should_verifys (index + 1) tags should_verifys_js\n in\n js_bool :: should_verifys\n\n let should_verifys tags should_verifys_js =\n should_verifys 0 tags should_verifys_js\n\n let get_typ ~public_input_size ~public_output_size\n (type a1 a2 a3 a4 width height) (tag : (a1, a2, a3, a4) Pickles.Tag.t)\n (self :\n ( Public_input.t * Public_input.t\n , Public_input.Constant.t * Public_input.Constant.t\n , width\n , height )\n Pickles.Tag.t ) =\n match Type_equal.Id.same_witness tag.id self.id with\n | None ->\n Pickles.Types_map.public_input tag\n | Some T ->\n statement_typ public_input_size public_output_size\n\n let rec prev_statements :\n type prev_vars prev_values widths heights width height.\n public_input_size:int\n -> public_output_size:int\n -> self:\n ( Public_input.t * Public_input.t\n , Public_input.Constant.t * Public_input.Constant.t\n , width\n , height )\n Pickles.Tag.t\n -> int\n -> (prev_vars, prev_values, widths, heights) H4.T(Pickles.Tag).t\n -> Statement.t array\n -> prev_vars H1.T(Id).t =\n fun ~public_input_size ~public_output_size ~self i tags statements ->\n match tags with\n | [] ->\n []\n | tag :: tags ->\n let (Typ typ) =\n get_typ ~public_input_size ~public_output_size tag self\n in\n let input, output = Array.get statements i in\n let fields = Array.concat [ input; output ] in\n let aux = typ.constraint_system_auxiliary () in\n let statement = typ.var_of_fields (fields, aux) in\n statement\n :: prev_statements ~public_input_size ~public_output_size ~self\n (i + 1) tags statements\n\n let prev_statements ~public_input_size ~public_output_size ~self tags\n statements =\n prev_statements ~public_input_size ~public_output_size ~self 0 tags\n statements\n\n type _ Snarky_backendless.Request.t +=\n | Get_prev_proof : int -> _ Pickles.Proof.t Snarky_backendless.Request.t\n\n let create ~public_input_size ~public_output_size (rule : pickles_rule_js) :\n ( _\n , _\n , _\n , _\n , Public_input.t\n , Public_input.Constant.t\n , Public_input.t\n , Public_input.Constant.t\n , unit\n , unit )\n t =\n let (Prevs prevs) = Prevs.of_rule rule in\n Rule\n (fun ~(self :\n ( Field.t array * Field.t array\n , Impl.field array * Impl.field array\n , 'b3\n , 'b4 )\n Pickles.Tag.t ) ->\n let prevs = prevs ~self in\n { Pickles.Inductive_rule.identifier = Js.to_string rule##.identifier\n ; feature_flags = Pickles_types.Plonk_types.Features.none_bool\n ; prevs\n ; main =\n (fun { public_input } ->\n dummy_constraints () ;\n let result = rule##.main public_input in\n let public_output = result##.publicOutput in\n let previous_proofs_should_verify =\n should_verifys prevs result##.shouldVerify\n in\n let previous_public_inputs =\n prev_statements ~public_input_size ~public_output_size ~self\n prevs\n result##.previousStatements\n in\n let previous_proof_statements =\n let rec go :\n type prev_vars prev_values widths heights.\n int\n -> prev_vars H1.T(Id).t\n -> prev_vars H1.T(E01(Pickles.Inductive_rule.B)).t\n -> ( prev_vars\n , prev_values\n , widths\n , heights )\n H4.T(Pickles.Tag).t\n -> ( prev_vars\n , widths )\n H2.T(Pickles.Inductive_rule.Previous_proof_statement).t\n =\n fun i public_inputs should_verifys tags ->\n match (public_inputs, should_verifys, tags) with\n | [], [], [] ->\n []\n | ( public_input :: public_inputs\n , proof_must_verify :: should_verifys\n , _tag :: tags ) ->\n let proof =\n Impl.exists (Impl.Typ.Internal.ref ())\n ~request:(fun () -> Get_prev_proof i)\n in\n { public_input; proof; proof_must_verify }\n :: go (i + 1) public_inputs should_verifys tags\n in\n go 0 previous_public_inputs previous_proofs_should_verify\n prevs\n in\n { previous_proof_statements\n ; public_output\n ; auxiliary_output = ()\n } )\n } )\n end\n\n type ( 'var\n , 'value\n , 'width\n , 'height\n , 'arg_var\n , 'arg_value\n , 'ret_var\n , 'ret_value\n , 'auxiliary_var\n , 'auxiliary_value )\n t =\n | Choices :\n ( self:('var, 'value, 'width, 'height) Pickles.Tag.t\n -> ( 'prev_vars\n , 'prev_values\n , 'widths\n , 'heights\n , 'arg_var\n , 'arg_value\n , 'ret_var\n , 'ret_value\n , 'auxiliary_var\n , 'auxiliary_value )\n H4_6.T(Pickles.Inductive_rule).t )\n -> ( 'var\n , 'value\n , 'width\n , 'height\n , 'arg_var\n , 'arg_value\n , 'ret_var\n , 'ret_value\n , 'auxiliary_var\n , 'auxiliary_value )\n t\n\n let of_js ~public_input_size ~public_output_size js_rules =\n let rec get_rules (Choices rules) index :\n ( _\n , _\n , _\n , _\n , Public_input.t\n , Public_input.Constant.t\n , Public_input.t\n , Public_input.Constant.t\n , unit\n , unit )\n t =\n if index < 0 then Choices rules\n else\n let (Rule rule) =\n Inductive_rule.create ~public_input_size ~public_output_size\n (Array.get js_rules index)\n in\n let rules ~self : _ H4_6.T(Pickles.Inductive_rule).t =\n rule ~self :: rules ~self\n in\n get_rules (Choices rules) (index - 1)\n in\n get_rules (Choices (fun ~self:_ -> [])) (Array.length js_rules - 1)\nend\n\ntype proof = (Pickles_types.Nat.N0.n, Pickles_types.Nat.N0.n) Pickles.Proof.t\n\nmodule Public_inputs_with_proofs =\n Pickles_types.Hlist.H3.T (Pickles.Statement_with_proof)\n\nlet nat_modules_list : (module Pickles_types.Nat.Intf) list =\n let open Pickles_types.Nat in\n [ (module N0)\n ; (module N1)\n ; (module N2)\n ; (module N3)\n ; (module N4)\n ; (module N5)\n ; (module N6)\n ; (module N7)\n ; (module N8)\n ; (module N9)\n ; (module N10)\n ; (module N11)\n ; (module N12)\n ; (module N13)\n ; (module N14)\n ; (module N15)\n ; (module N16)\n ; (module N17)\n ; (module N18)\n ; (module N19)\n ; (module N20)\n ]\n\nlet nat_add_modules_list : (module Pickles_types.Nat.Add.Intf) list =\n let open Pickles_types.Nat in\n [ (module N0)\n ; (module N1)\n ; (module N2)\n ; (module N3)\n ; (module N4)\n ; (module N5)\n ; (module N6)\n ; (module N7)\n ; (module N8)\n ; (module N9)\n ; (module N10)\n ; (module N11)\n ; (module N12)\n ; (module N13)\n ; (module N14)\n ; (module N15)\n ; (module N16)\n ; (module N17)\n ; (module N18)\n ; (module N19)\n ; (module N20)\n ]\n\nlet nat_module (i : int) : (module Pickles_types.Nat.Intf) =\n List.nth_exn nat_modules_list i\n\nlet nat_add_module (i : int) : (module Pickles_types.Nat.Add.Intf) =\n List.nth_exn nat_add_modules_list i\n\nlet name = \"smart-contract\"\n\nlet constraint_constants =\n (* TODO these are dummy values *)\n { Snark_keys_header.Constraint_constants.sub_windows_per_window = 0\n ; ledger_depth = 0\n ; work_delay = 0\n ; block_window_duration_ms = 0\n ; transaction_capacity = Log_2 0\n ; pending_coinbase_depth = 0\n ; coinbase_amount = Unsigned.UInt64.of_int 0\n ; supercharged_coinbase_factor = 0\n ; account_creation_fee = Unsigned.UInt64.of_int 0\n ; fork = None\n }\n\nlet pickles_compile (choices : pickles_rule_js array)\n (signature :\n < publicInputSize : int Js.prop\n ; publicOutputSize : int Js.prop\n ; overrideWrapDomain : int Js.optdef_prop >\n Js.t ) =\n (* translate number of branches and recursively verified proofs from JS *)\n let branches = Array.length choices in\n let max_proofs =\n let choices = choices |> Array.to_list in\n List.map choices ~f:(fun c -> c##.proofsToVerify |> Array.length)\n |> List.max_elt ~compare |> Option.value ~default:0\n in\n let (module Branches) = nat_module branches in\n let (module Max_proofs_verified) = nat_add_module max_proofs in\n\n (* translate method circuits from JS *)\n let public_input_size = signature##.publicInputSize in\n let public_output_size = signature##.publicOutputSize in\n let override_wrap_domain =\n Js.Optdef.to_option signature##.overrideWrapDomain\n |> Option.map ~f:Pickles_base.Proofs_verified.of_int\n in\n let (Choices choices) =\n Choices.of_js ~public_input_size ~public_output_size choices\n in\n\n (* call into Pickles *)\n let tag, _cache, p, provers =\n Pickles.compile_promise () ?override_wrap_domain ~choices\n ~public_input:\n (Input_and_output\n ( public_input_typ public_input_size\n , public_input_typ public_output_size ) )\n ~auxiliary_typ:Typ.unit\n ~branches:(module Branches)\n ~max_proofs_verified:(module Max_proofs_verified)\n ~name ~constraint_constants\n in\n\n (* translate returned prover and verify functions to JS *)\n let module Proof = (val p) in\n let to_js_prover prover : ('prev_proof, Proof.t) js_prover =\n let prove (public_input : Public_input.Constant.t)\n (prevs : 'prev_proof array) =\n let handler (Snarky_backendless.Request.With { request; respond }) =\n match request with\n | Choices.Inductive_rule.Get_prev_proof i ->\n respond (Provide (Obj.magic (Array.get prevs i)))\n | _ ->\n respond Unhandled\n in\n prover ?handler:(Some handler) public_input\n |> Promise.map ~f:(fun (output, _, proof) -> (output, proof))\n |> Promise_js_helpers.to_js\n in\n prove\n in\n let rec to_js_provers :\n type a b c.\n ( a\n , b\n , c\n , Public_input.Constant.t\n , (Public_input.Constant.t * unit * Proof.t) Promise.t )\n Pickles.Provers.t\n -> ('prev_proof, Proof.t) js_prover list = function\n | [] ->\n []\n | p :: ps ->\n to_js_prover p :: to_js_provers ps\n in\n let provers : (_, Proof.t) js_prover array =\n provers |> to_js_provers |> Array.of_list\n in\n let verify (statement : Statement.Constant.t) (proof : _ Pickles.Proof.t) =\n Proof.verify_promise [ (statement, proof) ]\n |> Promise.map ~f:(fun x -> Js.bool (Or_error.is_ok x))\n |> Promise_js_helpers.to_js\n in\n object%js\n val provers = Obj.magic provers\n\n val verify = Obj.magic verify\n\n val tag = Obj.magic tag\n\n method getVerificationKey =\n let vk = Pickles.Side_loaded.Verification_key.of_compiled tag in\n let data = Pickles.Side_loaded.Verification_key.to_base64 vk in\n let hash = Mina_base.Zkapp_account.digest_vk vk in\n (data |> Js.string, hash)\n end\n\nmodule Proof0 = Pickles.Proof.Make (Pickles_types.Nat.N0) (Pickles_types.Nat.N0)\nmodule Proof1 = Pickles.Proof.Make (Pickles_types.Nat.N1) (Pickles_types.Nat.N1)\nmodule Proof2 = Pickles.Proof.Make (Pickles_types.Nat.N2) (Pickles_types.Nat.N2)\n\ntype some_proof = Proof0 of Proof0.t | Proof1 of Proof1.t | Proof2 of Proof2.t\n\nlet proof_to_base64 = function\n | Proof0 proof ->\n Proof0.to_base64 proof |> Js.string\n | Proof1 proof ->\n Proof1.to_base64 proof |> Js.string\n | Proof2 proof ->\n Proof2.to_base64 proof |> Js.string\n\nlet proof_of_base64 str i : some_proof =\n let str = Js.to_string str in\n match i with\n | 0 ->\n Proof0 (Proof0.of_base64 str |> Result.ok_or_failwith)\n | 1 ->\n Proof1 (Proof1.of_base64 str |> Result.ok_or_failwith)\n | 2 ->\n Proof2 (Proof2.of_base64 str |> Result.ok_or_failwith)\n | _ ->\n failwith \"invalid proof index\"\n\nlet verify (statement : Statement.Constant.t) (proof : proof)\n (vk : Js.js_string Js.t) =\n let i, o = statement in\n let typ = statement_typ (Array.length i) (Array.length o) in\n let proof = Pickles.Side_loaded.Proof.of_proof proof in\n let vk =\n match Pickles.Side_loaded.Verification_key.of_base64 (Js.to_string vk) with\n | Ok vk_ ->\n vk_\n | Error err ->\n failwithf \"Could not decode base64 verification key: %s\"\n (Error.to_string_hum err) ()\n in\n Pickles.Side_loaded.verify_promise ~typ [ (vk, statement, proof) ]\n |> Promise.map ~f:(fun x -> Js.bool (Or_error.is_ok x))\n |> Promise_js_helpers.to_js\n\nlet dummy_base64_proof () =\n let n2 = Pickles_types.Nat.N2.n in\n let proof = Pickles.Proof.dummy n2 n2 n2 ~domain_log2:15 in\n Proof2.to_base64 proof |> Js.string\n\nlet dummy_verification_key () =\n let vk = Pickles.Side_loaded.Verification_key.dummy in\n let data = Pickles.Side_loaded.Verification_key.to_base64 vk in\n let hash = Mina_base.Zkapp_account.digest_vk vk in\n (data |> Js.string, hash)\n\nlet pickles =\n object%js\n val compile = pickles_compile\n\n val verify = verify\n\n val dummyBase64Proof = dummy_base64_proof\n\n val dummyVerificationKey = dummy_verification_key\n\n val proofToBase64 = proof_to_base64\n\n val proofOfBase64 = proof_of_base64\n\n val proofToBase64Transaction =\n fun (proof : proof) ->\n proof |> Pickles.Side_loaded.Proof.of_proof\n |> Pickles.Side_loaded.Proof.to_base64 |> Js.string\n end\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Benoit Vaugon, ENSTA *)\n(* *)\n(* Copyright 2014 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* Padding position. *)\ntype padty =\n | Left (* Text is left justified ('-' option). *)\n | Right (* Text is right justified (no '-' option). *)\n | Zeros (* Text is right justified by zeros (see '0' option). *)\n\n(***)\n\n(* Integer conversion. *)\ntype int_conv =\n | Int_d | Int_pd | Int_sd (* %d | %+d | % d *)\n | Int_i | Int_pi | Int_si (* %i | %+i | % i *)\n | Int_x | Int_Cx (* %x | %#x *)\n | Int_X | Int_CX (* %X | %#X *)\n | Int_o | Int_Co (* %o | %#o *)\n | Int_u (* %u *)\n | Int_Cd | Int_Ci | Int_Cu (* %#d | %#i | %#u *)\n\n(* Float conversion. *)\ntype float_flag_conv =\n | Float_flag_ (* %[feEgGFhH] *)\n | Float_flag_p (* %+[feEgGFhH] *)\n | Float_flag_s (* % [feEgGFhH] *)\ntype float_kind_conv =\n | Float_f (* %f | %+f | % f *)\n | Float_e (* %e | %+e | % e *)\n | Float_E (* %E | %+E | % E *)\n | Float_g (* %g | %+g | % g *)\n | Float_G (* %G | %+G | % G *)\n | Float_F (* %F | %+F | % F *)\n | Float_h (* %h | %+h | % h *)\n | Float_H (* %H | %+H | % H *)\n | Float_CF (* %#F| %+#F| % #F *)\ntype float_conv = float_flag_conv * float_kind_conv\n\n(***)\n\n(* Char sets (see %[...]) are bitmaps implemented as 32-char strings. *)\ntype char_set = string\n\n(***)\n\n(* Counter used in Scanf. *)\ntype counter =\n | Line_counter (* %l *)\n | Char_counter (* %n *)\n | Token_counter (* %N, %L *)\n\n(***)\n\n(* Padding of strings and numbers. *)\ntype ('a, 'b) padding =\n (* No padding (ex: \"%d\") *)\n | No_padding : ('a, 'a) padding\n (* Literal padding (ex: \"%8d\") *)\n | Lit_padding : padty * int -> ('a, 'a) padding\n (* Padding as extra argument (ex: \"%*d\") *)\n | Arg_padding : padty -> (int -> 'a, 'a) padding\n\n(* Some formats, such as %_d,\n only accept an optional number as padding option (no extra argument) *)\ntype pad_option = int option\n\n(* Precision of floats and '0'-padding of integers. *)\ntype ('a, 'b) precision =\n (* No precision (ex: \"%f\") *)\n | No_precision : ('a, 'a) precision\n (* Literal precision (ex: \"%.3f\") *)\n | Lit_precision : int -> ('a, 'a) precision\n (* Precision as extra argument (ex: \"%.*f\") *)\n | Arg_precision : (int -> 'a, 'a) precision\n\n(* Some formats, such as %_f,\n only accept an optional number as precision option (no extra argument) *)\ntype prec_option = int option\n\n(* see the Custom format combinator *)\ntype ('a, 'b, 'c) custom_arity =\n | Custom_zero : ('a, string, 'a) custom_arity\n | Custom_succ : ('a, 'b, 'c) custom_arity ->\n ('a, 'x -> 'b, 'x -> 'c) custom_arity\n\n(***)\n\n(* Relational format types\n\nIn the first format+gadts implementation, the type for %(..%) in the\nfmt GADT was as follows:\n\n| Format_subst : (* %(...%) *)\n pad_option * ('d1, 'q1, 'd2, 'q2) reader_nb_unifier *\n ('x, 'b, 'c, 'd1, 'q1, 'u) fmtty *\n ('u, 'b, 'c, 'q1, 'e1, 'f) fmt ->\n (('x, 'b, 'c, 'd2, 'q2, 'u) format6 -> 'x, 'b, 'c, 'd1, 'e1, 'f) fmt\n\nNotice that the 'u parameter in 'f position in the format argument\n(('x, .., 'u) format6 -> ..) is equal to the 'u parameter in 'a\nposition in the format tail (('u, .., 'f) fmt). This means that the\ntype of the expected format parameter depends of where the %(...%)\nare in the format string:\n\n # Printf.printf \"%(%)\"\n - : (unit, out_channel, unit, '_a, '_a, unit)\n CamlinternalFormatBasics.format6 -> unit\n = \n # Printf.printf \"%(%)%d\"\n - : (int -> unit, out_channel, unit, '_a, '_a, int -> unit)\n CamlinternalFormatBasics.format6 -> int -> unit\n = \n\nOn the contrary, the legacy typer gives a clever type that does not\ndepend on the position of %(..%) in the format string. For example,\n%(%) will have the polymorphic type ('a, 'b, 'c, 'd, 'd, 'a): it can\nbe concatenated to any format type, and only enforces the constraint\nthat its 'a and 'f parameters are equal (no format arguments) and 'd\nand 'e are equal (no reader argument).\n\nThe weakening of this parameter type in the GADT version broke user\ncode (in fact it essentially made %(...%) unusable except at the last\nposition of a format). In particular, the following would not work\nanymore:\n\n fun sep ->\n Format.printf \"foo%(%)bar%(%)baz\" sep sep\n\nAs the type-checker would require two *incompatible* types for the %(%)\nin different positions.\n\nThe solution to regain a general type for %(..%) is to generalize this\ntechnique, not only on the 'd, 'e parameters, but on all six\nparameters of a format: we introduce a \"relational\" type\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel\nwhose values are proofs that ('a1, .., 'f1) and ('a2, .., 'f2) morally\ncorrespond to the same format type: 'a1 is obtained from 'f1,'b1,'c1\nin the exact same way that 'a2 is obtained from 'f2,'b2,'c2, etc.\n\nFor example, the relation between two format types beginning with a Char\nparameter is as follows:\n\n| Char_ty : (* %c *)\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->\n (char -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n char -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel\n\nIn the general case, the term structure of fmtty_rel is (almost[1])\nisomorphic to the fmtty of the previous implementation: every\nconstructor is re-read with a binary, relational type, instead of the\nprevious unary typing. fmtty can then be re-defined as the diagonal of\nfmtty_rel:\n\n type ('a, 'b, 'c, 'd, 'e, 'f) fmtty =\n ('a, 'b, 'c, 'd, 'e, 'f,\n 'a, 'b, 'c, 'd, 'e, 'f) fmtty_rel\n\nOnce we have this fmtty_rel type in place, we can give the more\ngeneral type to %(...%):\n\n| Format_subst : (* %(...%) *)\n pad_option *\n ('g, 'h, 'i, 'j, 'k, 'l,\n 'g2, 'b, 'c, 'j2, 'd, 'a) fmtty_rel *\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n (('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'g2, 'b, 'c, 'j2, 'e, 'f) fmt\n\nWe accept any format (('g, 'h, 'i, 'j, 'k, 'l) format6) (this is\ncompletely unrelated to the type of the current format), but also\nrequire a proof that this format is in relation to another format that\nis concatenable to the format tail. When executing a %(...%) format\n(in camlinternalFormat.ml:make_printf or scanf.ml:make_scanf), we\ntranstype the format along this relation using the 'recast' function\nto transpose between related format types.\n\n val recast :\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1) fmt\n -> ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel\n -> ('a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmt\n\nNOTE [1]: the typing of Format_subst_ty requires not one format type, but\ntwo, one to establish the link between the format argument and the\nfirst six parameters, and the other for the link between the format\nargument and the last six parameters.\n\n| Format_subst_ty : (* %(...%) *)\n ('g, 'h, 'i, 'j, 'k, 'l,\n 'g1, 'b1, 'c1, 'j1, 'd1, 'a1) fmtty_rel *\n ('g, 'h, 'i, 'j, 'k, 'l,\n 'g2, 'b2, 'c2, 'j2, 'd2, 'a2) fmtty_rel *\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->\n (('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'g1, 'b1, 'c1, 'j1, 'e1, 'f1,\n ('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'g2, 'b2, 'c2, 'j2, 'e2, 'f2) fmtty_rel\n\nWhen we generate a format AST, we generate exactly the same witness\nfor both relations, and the witness-conversion functions in\ncamlinternalFormat do rely on this invariant. For example, the\nfunction that proves that the relation is transitive\n\n val trans :\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel\n -> ('a2, 'b2, 'c2, 'd2, 'e2, 'f2,\n 'a3, 'b3, 'c3, 'd3, 'e3, 'f3) fmtty_rel\n -> ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a3, 'b3, 'c3, 'd3, 'e3, 'f3) fmtty_rel\n\ndoes assume that the two inputs have exactly the same term structure\n(and is only every used for argument witnesses of the\nFormat_subst_ty constructor).\n*)\n\n(* Type of a block used by the Format pretty-printer. *)\ntype block_type =\n | Pp_hbox (* Horizontal block no line breaking *)\n | Pp_vbox (* Vertical block each break leads to a new line *)\n | Pp_hvbox (* Horizontal-vertical block: same as vbox, except if this block\n is small enough to fit on a single line *)\n | Pp_hovbox (* Horizontal or Vertical block: breaks lead to new line\n only when necessary to print the content of the block *)\n | Pp_box (* Horizontal or Indent block: breaks lead to new line\n only when necessary to print the content of the block, or\n when it leads to a new indentation of the current line *)\n | Pp_fits (* Internal usage: when a block fits on a single line *)\n\n(* Formatting element used by the Format pretty-printer. *)\ntype formatting_lit =\n | Close_box (* @] *)\n | Close_tag (* @} *)\n | Break of string * int * int (* @, | @ | @; | @;<> *)\n | FFlush (* @? *)\n | Force_newline (* @\\n *)\n | Flush_newline (* @. *)\n | Magic_size of string * int (* @ *)\n | Escaped_at (* @@ *)\n | Escaped_percent (* @%% *)\n | Scan_indic of char (* @X *)\n\n(* Formatting element used by the Format pretty-printer. *)\ntype ('a, 'b, 'c, 'd, 'e, 'f) formatting_gen =\n | Open_tag : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> (* @{ *)\n ('a, 'b, 'c, 'd, 'e, 'f) formatting_gen\n | Open_box : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> (* @[ *)\n ('a, 'b, 'c, 'd, 'e, 'f) formatting_gen\n\n(***)\n\n(* List of format type elements. *)\n(* In particular used to represent %(...%) and %{...%} contents. *)\nand ('a, 'b, 'c, 'd, 'e, 'f) fmtty =\n ('a, 'b, 'c, 'd, 'e, 'f,\n 'a, 'b, 'c, 'd, 'e, 'f) fmtty_rel\nand ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel =\n | Char_ty : (* %c *)\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->\n (char -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n char -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel\n | String_ty : (* %s *)\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->\n (string -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n string -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel\n | Int_ty : (* %d *)\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->\n (int -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n int -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel\n | Int32_ty : (* %ld *)\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->\n (int32 -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n int32 -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel\n | Nativeint_ty : (* %nd *)\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->\n (nativeint -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n nativeint -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel\n | Int64_ty : (* %Ld *)\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->\n (int64 -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n int64 -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel\n | Float_ty : (* %f *)\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->\n (float -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n float -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel\n | Bool_ty : (* %B *)\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->\n (bool -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n bool -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel\n\n | Format_arg_ty : (* %{...%} *)\n ('g, 'h, 'i, 'j, 'k, 'l) fmtty *\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->\n (('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n ('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2)\n fmtty_rel\n | Format_subst_ty : (* %(...%) *)\n ('g, 'h, 'i, 'j, 'k, 'l,\n 'g1, 'b1, 'c1, 'j1, 'd1, 'a1) fmtty_rel *\n ('g, 'h, 'i, 'j, 'k, 'l,\n 'g2, 'b2, 'c2, 'j2, 'd2, 'a2) fmtty_rel *\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->\n (('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'g1, 'b1, 'c1, 'j1, 'e1, 'f1,\n ('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'g2, 'b2, 'c2, 'j2, 'e2, 'f2)\n fmtty_rel\n\n (* Printf and Format specific constructors. *)\n | Alpha_ty : (* %a *)\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->\n (('b1 -> 'x -> 'c1) -> 'x -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n ('b2 -> 'x -> 'c2) -> 'x -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel\n | Theta_ty : (* %t *)\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->\n (('b1 -> 'c1) -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n ('b2 -> 'c2) -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel\n | Any_ty : (* Used for custom formats *)\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->\n ('x -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'x -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel\n\n (* Scanf specific constructor. *)\n | Reader_ty : (* %r *)\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->\n ('x -> 'a1, 'b1, 'c1, ('b1 -> 'x) -> 'd1, 'e1, 'f1,\n 'x -> 'a2, 'b2, 'c2, ('b2 -> 'x) -> 'd2, 'e2, 'f2) fmtty_rel\n | Ignored_reader_ty : (* %_r *)\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->\n ('a1, 'b1, 'c1, ('b1 -> 'x) -> 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, ('b2 -> 'x) -> 'd2, 'e2, 'f2) fmtty_rel\n\n | End_of_fmtty :\n ('f1, 'b1, 'c1, 'd1, 'd1, 'f1,\n 'f2, 'b2, 'c2, 'd2, 'd2, 'f2) fmtty_rel\n\n(***)\n\n(* List of format elements. *)\nand ('a, 'b, 'c, 'd, 'e, 'f) fmt =\n | Char : (* %c *)\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n (char -> 'a, 'b, 'c, 'd, 'e, 'f) fmt\n | Caml_char : (* %C *)\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n (char -> 'a, 'b, 'c, 'd, 'e, 'f) fmt\n | String : (* %s *)\n ('x, string -> 'a) padding * ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('x, 'b, 'c, 'd, 'e, 'f) fmt\n | Caml_string : (* %S *)\n ('x, string -> 'a) padding * ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('x, 'b, 'c, 'd, 'e, 'f) fmt\n | Int : (* %[dixXuo] *)\n int_conv * ('x, 'y) padding * ('y, int -> 'a) precision *\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('x, 'b, 'c, 'd, 'e, 'f) fmt\n | Int32 : (* %l[dixXuo] *)\n int_conv * ('x, 'y) padding * ('y, int32 -> 'a) precision *\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('x, 'b, 'c, 'd, 'e, 'f) fmt\n | Nativeint : (* %n[dixXuo] *)\n int_conv * ('x, 'y) padding * ('y, nativeint -> 'a) precision *\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('x, 'b, 'c, 'd, 'e, 'f) fmt\n | Int64 : (* %L[dixXuo] *)\n int_conv * ('x, 'y) padding * ('y, int64 -> 'a) precision *\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('x, 'b, 'c, 'd, 'e, 'f) fmt\n | Float : (* %[feEgGFhH] *)\n float_conv * ('x, 'y) padding * ('y, float -> 'a) precision *\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('x, 'b, 'c, 'd, 'e, 'f) fmt\n | Bool : (* %[bB] *)\n ('x, bool -> 'a) padding * ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('x, 'b, 'c, 'd, 'e, 'f) fmt\n | Flush : (* %! *)\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('a, 'b, 'c, 'd, 'e, 'f) fmt\n\n | String_literal : (* abc *)\n string * ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('a, 'b, 'c, 'd, 'e, 'f) fmt\n | Char_literal : (* x *)\n char * ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('a, 'b, 'c, 'd, 'e, 'f) fmt\n\n | Format_arg : (* %{...%} *)\n pad_option * ('g, 'h, 'i, 'j, 'k, 'l) fmtty *\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n (('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'a, 'b, 'c, 'd, 'e, 'f) fmt\n | Format_subst : (* %(...%) *)\n pad_option *\n ('g, 'h, 'i, 'j, 'k, 'l,\n 'g2, 'b, 'c, 'j2, 'd, 'a) fmtty_rel *\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n (('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'g2, 'b, 'c, 'j2, 'e, 'f) fmt\n\n (* Printf and Format specific constructor. *)\n | Alpha : (* %a *)\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n (('b -> 'x -> 'c) -> 'x -> 'a, 'b, 'c, 'd, 'e, 'f) fmt\n | Theta : (* %t *)\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n (('b -> 'c) -> 'a, 'b, 'c, 'd, 'e, 'f) fmt\n\n (* Format specific constructor: *)\n | Formatting_lit : (* @_ *)\n formatting_lit * ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('a, 'b, 'c, 'd, 'e, 'f) fmt\n | Formatting_gen : (* @_ *)\n ('a1, 'b, 'c, 'd1, 'e1, 'f1) formatting_gen *\n ('f1, 'b, 'c, 'e1, 'e2, 'f2) fmt -> ('a1, 'b, 'c, 'd1, 'e2, 'f2) fmt\n\n (* Scanf specific constructors: *)\n | Reader : (* %r *)\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('x -> 'a, 'b, 'c, ('b -> 'x) -> 'd, 'e, 'f) fmt\n | Scan_char_set : (* %[...] *)\n pad_option * char_set * ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n (string -> 'a, 'b, 'c, 'd, 'e, 'f) fmt\n | Scan_get_counter : (* %[nlNL] *)\n counter * ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n (int -> 'a, 'b, 'c, 'd, 'e, 'f) fmt\n | Scan_next_char : (* %0c *)\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n (char -> 'a, 'b, 'c, 'd, 'e, 'f) fmt\n | Ignored_param : (* %_ *)\n ('a, 'b, 'c, 'd, 'y, 'x) ignored * ('x, 'b, 'c, 'y, 'e, 'f) fmt ->\n ('a, 'b, 'c, 'd, 'e, 'f) fmt\n\n (* Custom printing format (PR#6452, GPR#140)\n\n We include a type Custom of \"custom converters\", where an\n arbitrary function can be used to convert one or more\n arguments. There is no syntax for custom converters, it is only\n intended for custom processors that wish to rely on the\n stdlib-defined format GADTs.\n\n For instance a pre-processor could choose to interpret strings\n prefixed with [\"!\"] as format strings where [%{{ ... }}] is\n a special form to pass a to_string function, so that one could\n write:\n\n {[\n type t = { x : int; y : int }\n\n let string_of_t t = Printf.sprintf \"{ x = %d; y = %d }\" t.x t.y\n\n Printf.printf !\"t = %{{string_of_t}}\" { x = 42; y = 42 }\n ]}\n *)\n | Custom :\n ('a, 'x, 'y) custom_arity * (unit -> 'x) * ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('y, 'b, 'c, 'd, 'e, 'f) fmt\n\n (* end of a format specification *)\n | End_of_format :\n ('f, 'b, 'c, 'e, 'e, 'f) fmt\n\n(***)\n\n(* Type for ignored parameters (see \"%_\"). *)\nand ('a, 'b, 'c, 'd, 'e, 'f) ignored =\n | Ignored_char : (* %_c *)\n ('a, 'b, 'c, 'd, 'd, 'a) ignored\n | Ignored_caml_char : (* %_C *)\n ('a, 'b, 'c, 'd, 'd, 'a) ignored\n | Ignored_string : (* %_s *)\n pad_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored\n | Ignored_caml_string : (* %_S *)\n pad_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored\n | Ignored_int : (* %_d *)\n int_conv * pad_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored\n | Ignored_int32 : (* %_ld *)\n int_conv * pad_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored\n | Ignored_nativeint : (* %_nd *)\n int_conv * pad_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored\n | Ignored_int64 : (* %_Ld *)\n int_conv * pad_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored\n | Ignored_float : (* %_f *)\n pad_option * prec_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored\n | Ignored_bool : (* %_B *)\n pad_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored\n | Ignored_format_arg : (* %_{...%} *)\n pad_option * ('g, 'h, 'i, 'j, 'k, 'l) fmtty ->\n ('a, 'b, 'c, 'd, 'd, 'a) ignored\n | Ignored_format_subst : (* %_(...%) *)\n pad_option * ('a, 'b, 'c, 'd, 'e, 'f) fmtty ->\n ('a, 'b, 'c, 'd, 'e, 'f) ignored\n | Ignored_reader : (* %_r *)\n ('a, 'b, 'c, ('b -> 'x) -> 'd, 'd, 'a) ignored\n | Ignored_scan_char_set : (* %_[...] *)\n pad_option * char_set -> ('a, 'b, 'c, 'd, 'd, 'a) ignored\n | Ignored_scan_get_counter : (* %_[nlNL] *)\n counter -> ('a, 'b, 'c, 'd, 'd, 'a) ignored\n | Ignored_scan_next_char : (* %_0c *)\n ('a, 'b, 'c, 'd, 'd, 'a) ignored\n\nand ('a, 'b, 'c, 'd, 'e, 'f) format6 =\n Format of ('a, 'b, 'c, 'd, 'e, 'f) fmt * string\n\nlet rec erase_rel : type a b c d e f g h i j k l .\n (a, b, c, d, e, f,\n g, h, i, j, k, l) fmtty_rel -> (a, b, c, d, e, f) fmtty\n= function\n | Char_ty rest ->\n Char_ty (erase_rel rest)\n | String_ty rest ->\n String_ty (erase_rel rest)\n | Int_ty rest ->\n Int_ty (erase_rel rest)\n | Int32_ty rest ->\n Int32_ty (erase_rel rest)\n | Int64_ty rest ->\n Int64_ty (erase_rel rest)\n | Nativeint_ty rest ->\n Nativeint_ty (erase_rel rest)\n | Float_ty rest ->\n Float_ty (erase_rel rest)\n | Bool_ty rest ->\n Bool_ty (erase_rel rest)\n | Format_arg_ty (ty, rest) ->\n Format_arg_ty (ty, erase_rel rest)\n | Format_subst_ty (ty1, _ty2, rest) ->\n Format_subst_ty (ty1, ty1, erase_rel rest)\n | Alpha_ty rest ->\n Alpha_ty (erase_rel rest)\n | Theta_ty rest ->\n Theta_ty (erase_rel rest)\n | Any_ty rest ->\n Any_ty (erase_rel rest)\n | Reader_ty rest ->\n Reader_ty (erase_rel rest)\n | Ignored_reader_ty rest ->\n Ignored_reader_ty (erase_rel rest)\n | End_of_fmtty -> End_of_fmtty\n\n(******************************************************************************)\n (* Format type concatenation *)\n\n(* Concatenate two format types. *)\n(* Used by:\n * reader_nb_unifier_of_fmtty to count readers in an fmtty,\n * Scanf.take_fmtty_format_readers to extract readers inside %(...%),\n * CamlinternalFormat.fmtty_of_ignored_format to extract format type. *)\n\n(*\nlet rec concat_fmtty : type a b c d e f g h .\n (a, b, c, d, e, f) fmtty ->\n (f, b, c, e, g, h) fmtty ->\n (a, b, c, d, g, h) fmtty =\n*)\nlet rec concat_fmtty :\n type a1 b1 c1 d1 e1 f1\n a2 b2 c2 d2 e2 f2\n g1 j1 g2 j2\n .\n (g1, b1, c1, j1, d1, a1,\n g2, b2, c2, j2, d2, a2) fmtty_rel ->\n (a1, b1, c1, d1, e1, f1,\n a2, b2, c2, d2, e2, f2) fmtty_rel ->\n (g1, b1, c1, j1, e1, f1,\n g2, b2, c2, j2, e2, f2) fmtty_rel =\nfun fmtty1 fmtty2 -> match fmtty1 with\n | Char_ty rest ->\n Char_ty (concat_fmtty rest fmtty2)\n | String_ty rest ->\n String_ty (concat_fmtty rest fmtty2)\n | Int_ty rest ->\n Int_ty (concat_fmtty rest fmtty2)\n | Int32_ty rest ->\n Int32_ty (concat_fmtty rest fmtty2)\n | Nativeint_ty rest ->\n Nativeint_ty (concat_fmtty rest fmtty2)\n | Int64_ty rest ->\n Int64_ty (concat_fmtty rest fmtty2)\n | Float_ty rest ->\n Float_ty (concat_fmtty rest fmtty2)\n | Bool_ty rest ->\n Bool_ty (concat_fmtty rest fmtty2)\n | Alpha_ty rest ->\n Alpha_ty (concat_fmtty rest fmtty2)\n | Theta_ty rest ->\n Theta_ty (concat_fmtty rest fmtty2)\n | Any_ty rest ->\n Any_ty (concat_fmtty rest fmtty2)\n | Reader_ty rest ->\n Reader_ty (concat_fmtty rest fmtty2)\n | Ignored_reader_ty rest ->\n Ignored_reader_ty (concat_fmtty rest fmtty2)\n | Format_arg_ty (ty, rest) ->\n Format_arg_ty (ty, concat_fmtty rest fmtty2)\n | Format_subst_ty (ty1, ty2, rest) ->\n Format_subst_ty (ty1, ty2, concat_fmtty rest fmtty2)\n | End_of_fmtty -> fmtty2\n\n(******************************************************************************)\n (* Format concatenation *)\n\n(* Concatenate two formats. *)\nlet rec concat_fmt : type a b c d e f g h .\n (a, b, c, d, e, f) fmt ->\n (f, b, c, e, g, h) fmt ->\n (a, b, c, d, g, h) fmt =\nfun fmt1 fmt2 -> match fmt1 with\n | String (pad, rest) ->\n String (pad, concat_fmt rest fmt2)\n | Caml_string (pad, rest) ->\n Caml_string (pad, concat_fmt rest fmt2)\n\n | Int (iconv, pad, prec, rest) ->\n Int (iconv, pad, prec, concat_fmt rest fmt2)\n | Int32 (iconv, pad, prec, rest) ->\n Int32 (iconv, pad, prec, concat_fmt rest fmt2)\n | Nativeint (iconv, pad, prec, rest) ->\n Nativeint (iconv, pad, prec, concat_fmt rest fmt2)\n | Int64 (iconv, pad, prec, rest) ->\n Int64 (iconv, pad, prec, concat_fmt rest fmt2)\n | Float (fconv, pad, prec, rest) ->\n Float (fconv, pad, prec, concat_fmt rest fmt2)\n\n | Char (rest) ->\n Char (concat_fmt rest fmt2)\n | Caml_char rest ->\n Caml_char (concat_fmt rest fmt2)\n | Bool (pad, rest) ->\n Bool (pad, concat_fmt rest fmt2)\n | Alpha rest ->\n Alpha (concat_fmt rest fmt2)\n | Theta rest ->\n Theta (concat_fmt rest fmt2)\n | Custom (arity, f, rest) ->\n Custom (arity, f, concat_fmt rest fmt2)\n | Reader rest ->\n Reader (concat_fmt rest fmt2)\n | Flush rest ->\n Flush (concat_fmt rest fmt2)\n\n | String_literal (str, rest) ->\n String_literal (str, concat_fmt rest fmt2)\n | Char_literal (chr, rest) ->\n Char_literal (chr, concat_fmt rest fmt2)\n\n | Format_arg (pad, fmtty, rest) ->\n Format_arg (pad, fmtty, concat_fmt rest fmt2)\n | Format_subst (pad, fmtty, rest) ->\n Format_subst (pad, fmtty, concat_fmt rest fmt2)\n\n | Scan_char_set (width_opt, char_set, rest) ->\n Scan_char_set (width_opt, char_set, concat_fmt rest fmt2)\n | Scan_get_counter (counter, rest) ->\n Scan_get_counter (counter, concat_fmt rest fmt2)\n | Scan_next_char (rest) ->\n Scan_next_char (concat_fmt rest fmt2)\n | Ignored_param (ign, rest) ->\n Ignored_param (ign, concat_fmt rest fmt2)\n\n | Formatting_lit (fmting_lit, rest) ->\n Formatting_lit (fmting_lit, concat_fmt rest fmt2)\n | Formatting_gen (fmting_gen, rest) ->\n Formatting_gen (fmting_gen, concat_fmt rest fmt2)\n\n | End_of_format ->\n fmt2\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Gabriel Scherer, projet Partout, INRIA Paris-Saclay *)\n(* *)\n(* Copyright 2020 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* CamlinternalAtomic is a dependency of Stdlib, so it is compiled with\n -nopervasives. *)\nexternal ( == ) : 'a -> 'a -> bool = \"%eq\"\nexternal ( + ) : int -> int -> int = \"%addint\"\nexternal ignore : 'a -> unit = \"%ignore\"\n\n(* We are not reusing ('a ref) directly to make it easier to reason\n about atomicity if we wish to: even in a sequential implementation,\n signals and other asynchronous callbacks might break atomicity. *)\ntype 'a t = {mutable v: 'a}\n\nlet make v = {v}\nlet get r = r.v\nlet set r v = r.v <- v\n\n(* The following functions are set to never be inlined: Flambda is\n allowed to move surrounding code inside the critical section,\n including allocations. *)\n\nlet[@inline never] exchange r v =\n (* BEGIN ATOMIC *)\n let cur = r.v in\n r.v <- v;\n (* END ATOMIC *)\n cur\n\nlet[@inline never] compare_and_set r seen v =\n (* BEGIN ATOMIC *)\n let cur = r.v in\n if cur == seen then (\n r.v <- v;\n (* END ATOMIC *)\n true\n ) else\n false\n\nlet[@inline never] fetch_and_add r n =\n (* BEGIN ATOMIC *)\n let cur = r.v in\n r.v <- (cur + n);\n (* END ATOMIC *)\n cur\n\nlet incr r = ignore (fetch_and_add r 1)\nlet decr r = ignore (fetch_and_add r (-1))\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* Exceptions *)\n\nexternal register_named_value : string -> 'a -> unit\n = \"caml_register_named_value\"\n\nlet () =\n (* for runtime/fail_nat.c *)\n register_named_value \"Pervasives.array_bound_error\"\n (Invalid_argument \"index out of bounds\")\n\nexternal raise : exn -> 'a = \"%raise\"\nexternal raise_notrace : exn -> 'a = \"%raise_notrace\"\n\nlet failwith s = raise(Failure s)\nlet invalid_arg s = raise(Invalid_argument s)\n\nexception Exit\nexception Match_failure = Match_failure\nexception Assert_failure = Assert_failure\nexception Invalid_argument = Invalid_argument\nexception Failure = Failure\nexception Not_found = Not_found\nexception Out_of_memory = Out_of_memory\nexception Stack_overflow = Stack_overflow\nexception Sys_error = Sys_error\nexception End_of_file = End_of_file\nexception Division_by_zero = Division_by_zero\nexception Sys_blocked_io = Sys_blocked_io\nexception Undefined_recursive_module = Undefined_recursive_module\n\n(* Composition operators *)\n\nexternal ( |> ) : 'a -> ('a -> 'b) -> 'b = \"%revapply\"\nexternal ( @@ ) : ('a -> 'b) -> 'a -> 'b = \"%apply\"\n\n(* Debugging *)\n\nexternal __LOC__ : string = \"%loc_LOC\"\nexternal __FILE__ : string = \"%loc_FILE\"\nexternal __LINE__ : int = \"%loc_LINE\"\nexternal __MODULE__ : string = \"%loc_MODULE\"\nexternal __POS__ : string * int * int * int = \"%loc_POS\"\nexternal __FUNCTION__ : string = \"%loc_FUNCTION\"\n\nexternal __LOC_OF__ : 'a -> string * 'a = \"%loc_LOC\"\nexternal __LINE_OF__ : 'a -> int * 'a = \"%loc_LINE\"\nexternal __POS_OF__ : 'a -> (string * int * int * int) * 'a = \"%loc_POS\"\n\n(* Comparisons *)\n\nexternal ( = ) : 'a -> 'a -> bool = \"%equal\"\nexternal ( <> ) : 'a -> 'a -> bool = \"%notequal\"\nexternal ( < ) : 'a -> 'a -> bool = \"%lessthan\"\nexternal ( > ) : 'a -> 'a -> bool = \"%greaterthan\"\nexternal ( <= ) : 'a -> 'a -> bool = \"%lessequal\"\nexternal ( >= ) : 'a -> 'a -> bool = \"%greaterequal\"\nexternal compare : 'a -> 'a -> int = \"%compare\"\n\nlet min x y = if x <= y then x else y\nlet max x y = if x >= y then x else y\n\nexternal ( == ) : 'a -> 'a -> bool = \"%eq\"\nexternal ( != ) : 'a -> 'a -> bool = \"%noteq\"\n\n(* Boolean operations *)\n\nexternal not : bool -> bool = \"%boolnot\"\nexternal ( & ) : bool -> bool -> bool = \"%sequand\"\nexternal ( && ) : bool -> bool -> bool = \"%sequand\"\nexternal ( or ) : bool -> bool -> bool = \"%sequor\"\nexternal ( || ) : bool -> bool -> bool = \"%sequor\"\n\n(* Integer operations *)\n\nexternal ( ~- ) : int -> int = \"%negint\"\nexternal ( ~+ ) : int -> int = \"%identity\"\nexternal succ : int -> int = \"%succint\"\nexternal pred : int -> int = \"%predint\"\nexternal ( + ) : int -> int -> int = \"%addint\"\nexternal ( - ) : int -> int -> int = \"%subint\"\nexternal ( * ) : int -> int -> int = \"%mulint\"\nexternal ( / ) : int -> int -> int = \"%divint\"\nexternal ( mod ) : int -> int -> int = \"%modint\"\n\nlet abs x = if x >= 0 then x else -x\n\nexternal ( land ) : int -> int -> int = \"%andint\"\nexternal ( lor ) : int -> int -> int = \"%orint\"\nexternal ( lxor ) : int -> int -> int = \"%xorint\"\n\nlet lnot x = x lxor (-1)\n\nexternal ( lsl ) : int -> int -> int = \"%lslint\"\nexternal ( lsr ) : int -> int -> int = \"%lsrint\"\nexternal ( asr ) : int -> int -> int = \"%asrint\"\n\nlet max_int = (-1) lsr 1\nlet min_int = max_int + 1\n\n(* Floating-point operations *)\n\nexternal ( ~-. ) : float -> float = \"%negfloat\"\nexternal ( ~+. ) : float -> float = \"%identity\"\nexternal ( +. ) : float -> float -> float = \"%addfloat\"\nexternal ( -. ) : float -> float -> float = \"%subfloat\"\nexternal ( *. ) : float -> float -> float = \"%mulfloat\"\nexternal ( /. ) : float -> float -> float = \"%divfloat\"\nexternal ( ** ) : float -> float -> float = \"caml_power_float\" \"pow\"\n [@@unboxed] [@@noalloc]\nexternal exp : float -> float = \"caml_exp_float\" \"exp\" [@@unboxed] [@@noalloc]\nexternal expm1 : float -> float = \"caml_expm1_float\" \"caml_expm1\"\n [@@unboxed] [@@noalloc]\nexternal acos : float -> float = \"caml_acos_float\" \"acos\"\n [@@unboxed] [@@noalloc]\nexternal asin : float -> float = \"caml_asin_float\" \"asin\"\n [@@unboxed] [@@noalloc]\nexternal atan : float -> float = \"caml_atan_float\" \"atan\"\n [@@unboxed] [@@noalloc]\nexternal atan2 : float -> float -> float = \"caml_atan2_float\" \"atan2\"\n [@@unboxed] [@@noalloc]\nexternal hypot : float -> float -> float\n = \"caml_hypot_float\" \"caml_hypot\" [@@unboxed] [@@noalloc]\nexternal cos : float -> float = \"caml_cos_float\" \"cos\" [@@unboxed] [@@noalloc]\nexternal cosh : float -> float = \"caml_cosh_float\" \"cosh\"\n [@@unboxed] [@@noalloc]\nexternal acosh : float -> float = \"caml_acosh_float\" \"caml_acosh\"\n [@@unboxed] [@@noalloc]\nexternal log : float -> float = \"caml_log_float\" \"log\" [@@unboxed] [@@noalloc]\nexternal log10 : float -> float = \"caml_log10_float\" \"log10\"\n [@@unboxed] [@@noalloc]\nexternal log1p : float -> float = \"caml_log1p_float\" \"caml_log1p\"\n [@@unboxed] [@@noalloc]\nexternal sin : float -> float = \"caml_sin_float\" \"sin\" [@@unboxed] [@@noalloc]\nexternal sinh : float -> float = \"caml_sinh_float\" \"sinh\"\n [@@unboxed] [@@noalloc]\nexternal asinh : float -> float = \"caml_asinh_float\" \"caml_asinh\"\n [@@unboxed] [@@noalloc]\nexternal sqrt : float -> float = \"caml_sqrt_float\" \"sqrt\"\n [@@unboxed] [@@noalloc]\nexternal tan : float -> float = \"caml_tan_float\" \"tan\" [@@unboxed] [@@noalloc]\nexternal tanh : float -> float = \"caml_tanh_float\" \"tanh\"\n [@@unboxed] [@@noalloc]\nexternal atanh : float -> float = \"caml_atanh_float\" \"caml_atanh\"\n [@@unboxed] [@@noalloc]\nexternal ceil : float -> float = \"caml_ceil_float\" \"ceil\"\n [@@unboxed] [@@noalloc]\nexternal floor : float -> float = \"caml_floor_float\" \"floor\"\n [@@unboxed] [@@noalloc]\nexternal abs_float : float -> float = \"%absfloat\"\nexternal copysign : float -> float -> float\n = \"caml_copysign_float\" \"caml_copysign\"\n [@@unboxed] [@@noalloc]\nexternal mod_float : float -> float -> float = \"caml_fmod_float\" \"fmod\"\n [@@unboxed] [@@noalloc]\nexternal frexp : float -> float * int = \"caml_frexp_float\"\nexternal ldexp : (float [@unboxed]) -> (int [@untagged]) -> (float [@unboxed]) =\n \"caml_ldexp_float\" \"caml_ldexp_float_unboxed\" [@@noalloc]\nexternal modf : float -> float * float = \"caml_modf_float\"\nexternal float : int -> float = \"%floatofint\"\nexternal float_of_int : int -> float = \"%floatofint\"\nexternal truncate : float -> int = \"%intoffloat\"\nexternal int_of_float : float -> int = \"%intoffloat\"\nexternal float_of_bits : int64 -> float\n = \"caml_int64_float_of_bits\" \"caml_int64_float_of_bits_unboxed\"\n [@@unboxed] [@@noalloc]\nlet infinity =\n float_of_bits 0x7F_F0_00_00_00_00_00_00L\nlet neg_infinity =\n float_of_bits 0xFF_F0_00_00_00_00_00_00L\nlet nan =\n float_of_bits 0x7F_F0_00_00_00_00_00_01L\nlet max_float =\n float_of_bits 0x7F_EF_FF_FF_FF_FF_FF_FFL\nlet min_float =\n float_of_bits 0x00_10_00_00_00_00_00_00L\nlet epsilon_float =\n float_of_bits 0x3C_B0_00_00_00_00_00_00L\n\ntype fpclass =\n FP_normal\n | FP_subnormal\n | FP_zero\n | FP_infinite\n | FP_nan\nexternal classify_float : (float [@unboxed]) -> fpclass =\n \"caml_classify_float\" \"caml_classify_float_unboxed\" [@@noalloc]\n\n(* String and byte sequence operations -- more in modules String and Bytes *)\n\nexternal string_length : string -> int = \"%string_length\"\nexternal bytes_length : bytes -> int = \"%bytes_length\"\nexternal bytes_create : int -> bytes = \"caml_create_bytes\"\nexternal string_blit : string -> int -> bytes -> int -> int -> unit\n = \"caml_blit_string\" [@@noalloc]\nexternal bytes_blit : bytes -> int -> bytes -> int -> int -> unit\n = \"caml_blit_bytes\" [@@noalloc]\nexternal bytes_unsafe_to_string : bytes -> string = \"%bytes_to_string\"\n\nlet ( ^ ) s1 s2 =\n let l1 = string_length s1 and l2 = string_length s2 in\n let s = bytes_create (l1 + l2) in\n string_blit s1 0 s 0 l1;\n string_blit s2 0 s l1 l2;\n bytes_unsafe_to_string s\n\n(* Character operations -- more in module Char *)\n\nexternal int_of_char : char -> int = \"%identity\"\nexternal unsafe_char_of_int : int -> char = \"%identity\"\nlet char_of_int n =\n if n < 0 || n > 255 then invalid_arg \"char_of_int\" else unsafe_char_of_int n\n\n(* Unit operations *)\n\nexternal ignore : 'a -> unit = \"%ignore\"\n\n(* Pair operations *)\n\nexternal fst : 'a * 'b -> 'a = \"%field0\"\nexternal snd : 'a * 'b -> 'b = \"%field1\"\n\n(* References *)\n\ntype 'a ref = { mutable contents : 'a }\nexternal ref : 'a -> 'a ref = \"%makemutable\"\nexternal ( ! ) : 'a ref -> 'a = \"%field0\"\nexternal ( := ) : 'a ref -> 'a -> unit = \"%setfield0\"\nexternal incr : int ref -> unit = \"%incr\"\nexternal decr : int ref -> unit = \"%decr\"\n\n(* Result type *)\n\ntype ('a,'b) result = Ok of 'a | Error of 'b\n\n(* String conversion functions *)\n\nexternal format_int : string -> int -> string = \"caml_format_int\"\nexternal format_float : string -> float -> string = \"caml_format_float\"\n\nlet string_of_bool b =\n if b then \"true\" else \"false\"\nlet bool_of_string = function\n | \"true\" -> true\n | \"false\" -> false\n | _ -> invalid_arg \"bool_of_string\"\n\nlet bool_of_string_opt = function\n | \"true\" -> Some true\n | \"false\" -> Some false\n | _ -> None\n\nlet string_of_int n =\n format_int \"%d\" n\n\nexternal int_of_string : string -> int = \"caml_int_of_string\"\n\nlet int_of_string_opt s =\n (* TODO: provide this directly as a non-raising primitive. *)\n try Some (int_of_string s)\n with Failure _ -> None\n\nexternal string_get : string -> int -> char = \"%string_safe_get\"\n\nlet valid_float_lexem s =\n let l = string_length s in\n let rec loop i =\n if i >= l then s ^ \".\" else\n match string_get s i with\n | '0' .. '9' | '-' -> loop (i + 1)\n | _ -> s\n in\n loop 0\n\nlet string_of_float f = valid_float_lexem (format_float \"%.12g\" f)\n\nexternal float_of_string : string -> float = \"caml_float_of_string\"\n\nlet float_of_string_opt s =\n (* TODO: provide this directly as a non-raising primitive. *)\n try Some (float_of_string s)\n with Failure _ -> None\n\n(* List operations -- more in module List *)\n\nlet rec ( @ ) l1 l2 =\n match l1 with\n [] -> l2\n | hd :: tl -> hd :: (tl @ l2)\n\n(* I/O operations *)\n\ntype in_channel\ntype out_channel\n\nexternal open_descriptor_out : int -> out_channel\n = \"caml_ml_open_descriptor_out\"\nexternal open_descriptor_in : int -> in_channel = \"caml_ml_open_descriptor_in\"\n\nlet stdin = open_descriptor_in 0\nlet stdout = open_descriptor_out 1\nlet stderr = open_descriptor_out 2\n\n(* General output functions *)\n\ntype open_flag =\n Open_rdonly | Open_wronly | Open_append\n | Open_creat | Open_trunc | Open_excl\n | Open_binary | Open_text | Open_nonblock\n\nexternal open_desc : string -> open_flag list -> int -> int = \"caml_sys_open\"\n\nexternal set_out_channel_name: out_channel -> string -> unit =\n \"caml_ml_set_channel_name\"\n\nlet open_out_gen mode perm name =\n let c = open_descriptor_out(open_desc name mode perm) in\n set_out_channel_name c name;\n c\n\nlet open_out name =\n open_out_gen [Open_wronly; Open_creat; Open_trunc; Open_text] 0o666 name\n\nlet open_out_bin name =\n open_out_gen [Open_wronly; Open_creat; Open_trunc; Open_binary] 0o666 name\n\nexternal flush : out_channel -> unit = \"caml_ml_flush\"\n\nexternal out_channels_list : unit -> out_channel list\n = \"caml_ml_out_channels_list\"\n\nlet flush_all () =\n let rec iter = function\n [] -> ()\n | a::l ->\n begin try\n flush a\n with Sys_error _ ->\n () (* ignore channels closed during a preceding flush. *)\n end;\n iter l\n in iter (out_channels_list ())\n\nexternal unsafe_output : out_channel -> bytes -> int -> int -> unit\n = \"caml_ml_output_bytes\"\nexternal unsafe_output_string : out_channel -> string -> int -> int -> unit\n = \"caml_ml_output\"\n\nexternal output_char : out_channel -> char -> unit = \"caml_ml_output_char\"\n\nlet output_bytes oc s =\n unsafe_output oc s 0 (bytes_length s)\n\nlet output_string oc s =\n unsafe_output_string oc s 0 (string_length s)\n\nlet output oc s ofs len =\n if ofs < 0 || len < 0 || ofs > bytes_length s - len\n then invalid_arg \"output\"\n else unsafe_output oc s ofs len\n\nlet output_substring oc s ofs len =\n if ofs < 0 || len < 0 || ofs > string_length s - len\n then invalid_arg \"output_substring\"\n else unsafe_output_string oc s ofs len\n\nexternal output_byte : out_channel -> int -> unit = \"caml_ml_output_char\"\nexternal output_binary_int : out_channel -> int -> unit = \"caml_ml_output_int\"\n\nexternal marshal_to_channel : out_channel -> 'a -> unit list -> unit\n = \"caml_output_value\"\nlet output_value chan v = marshal_to_channel chan v []\n\nexternal seek_out : out_channel -> int -> unit = \"caml_ml_seek_out\"\nexternal pos_out : out_channel -> int = \"caml_ml_pos_out\"\nexternal out_channel_length : out_channel -> int = \"caml_ml_channel_size\"\nexternal close_out_channel : out_channel -> unit = \"caml_ml_close_channel\"\nlet close_out oc = flush oc; close_out_channel oc\nlet close_out_noerr oc =\n (try flush oc with _ -> ());\n (try close_out_channel oc with _ -> ())\nexternal set_binary_mode_out : out_channel -> bool -> unit\n = \"caml_ml_set_binary_mode\"\n\n(* General input functions *)\n\nexternal set_in_channel_name: in_channel -> string -> unit =\n \"caml_ml_set_channel_name\"\n\nlet open_in_gen mode perm name =\n let c = open_descriptor_in(open_desc name mode perm) in\n set_in_channel_name c name;\n c\n\nlet open_in name =\n open_in_gen [Open_rdonly; Open_text] 0 name\n\nlet open_in_bin name =\n open_in_gen [Open_rdonly; Open_binary] 0 name\n\nexternal input_char : in_channel -> char = \"caml_ml_input_char\"\n\nexternal unsafe_input : in_channel -> bytes -> int -> int -> int\n = \"caml_ml_input\"\n\nlet input ic s ofs len =\n if ofs < 0 || len < 0 || ofs > bytes_length s - len\n then invalid_arg \"input\"\n else unsafe_input ic s ofs len\n\nlet rec unsafe_really_input ic s ofs len =\n if len <= 0 then () else begin\n let r = unsafe_input ic s ofs len in\n if r = 0\n then raise End_of_file\n else unsafe_really_input ic s (ofs + r) (len - r)\n end\n\nlet really_input ic s ofs len =\n if ofs < 0 || len < 0 || ofs > bytes_length s - len\n then invalid_arg \"really_input\"\n else unsafe_really_input ic s ofs len\n\nlet really_input_string ic len =\n let s = bytes_create len in\n really_input ic s 0 len;\n bytes_unsafe_to_string s\n\nexternal input_scan_line : in_channel -> int = \"caml_ml_input_scan_line\"\n\nlet input_line chan =\n let rec build_result buf pos = function\n [] -> buf\n | hd :: tl ->\n let len = bytes_length hd in\n bytes_blit hd 0 buf (pos - len) len;\n build_result buf (pos - len) tl in\n let rec scan accu len =\n let n = input_scan_line chan in\n if n = 0 then begin (* n = 0: we are at EOF *)\n match accu with\n [] -> raise End_of_file\n | _ -> build_result (bytes_create len) len accu\n end else if n > 0 then begin (* n > 0: newline found in buffer *)\n let res = bytes_create (n - 1) in\n ignore (unsafe_input chan res 0 (n - 1));\n ignore (input_char chan); (* skip the newline *)\n match accu with\n [] -> res\n | _ -> let len = len + n - 1 in\n build_result (bytes_create len) len (res :: accu)\n end else begin (* n < 0: newline not found *)\n let beg = bytes_create (-n) in\n ignore(unsafe_input chan beg 0 (-n));\n scan (beg :: accu) (len - n)\n end\n in bytes_unsafe_to_string (scan [] 0)\n\nexternal input_byte : in_channel -> int = \"caml_ml_input_char\"\nexternal input_binary_int : in_channel -> int = \"caml_ml_input_int\"\nexternal input_value : in_channel -> 'a = \"caml_input_value\"\nexternal seek_in : in_channel -> int -> unit = \"caml_ml_seek_in\"\nexternal pos_in : in_channel -> int = \"caml_ml_pos_in\"\nexternal in_channel_length : in_channel -> int = \"caml_ml_channel_size\"\nexternal close_in : in_channel -> unit = \"caml_ml_close_channel\"\nlet close_in_noerr ic = (try close_in ic with _ -> ())\nexternal set_binary_mode_in : in_channel -> bool -> unit\n = \"caml_ml_set_binary_mode\"\n\n(* Output functions on standard output *)\n\nlet print_char c = output_char stdout c\nlet print_string s = output_string stdout s\nlet print_bytes s = output_bytes stdout s\nlet print_int i = output_string stdout (string_of_int i)\nlet print_float f = output_string stdout (string_of_float f)\nlet print_endline s =\n output_string stdout s; output_char stdout '\\n'; flush stdout\nlet print_newline () = output_char stdout '\\n'; flush stdout\n\n(* Output functions on standard error *)\n\nlet prerr_char c = output_char stderr c\nlet prerr_string s = output_string stderr s\nlet prerr_bytes s = output_bytes stderr s\nlet prerr_int i = output_string stderr (string_of_int i)\nlet prerr_float f = output_string stderr (string_of_float f)\nlet prerr_endline s =\n output_string stderr s; output_char stderr '\\n'; flush stderr\nlet prerr_newline () = output_char stderr '\\n'; flush stderr\n\n(* Input functions on standard input *)\n\nlet read_line () = flush stdout; input_line stdin\nlet read_int () = int_of_string(read_line())\nlet read_int_opt () = int_of_string_opt(read_line())\nlet read_float () = float_of_string(read_line())\nlet read_float_opt () = float_of_string_opt(read_line())\n\n(* Operations on large files *)\n\nmodule LargeFile =\n struct\n external seek_out : out_channel -> int64 -> unit = \"caml_ml_seek_out_64\"\n external pos_out : out_channel -> int64 = \"caml_ml_pos_out_64\"\n external out_channel_length : out_channel -> int64\n = \"caml_ml_channel_size_64\"\n external seek_in : in_channel -> int64 -> unit = \"caml_ml_seek_in_64\"\n external pos_in : in_channel -> int64 = \"caml_ml_pos_in_64\"\n external in_channel_length : in_channel -> int64 = \"caml_ml_channel_size_64\"\n end\n\n(* Formats *)\n\ntype ('a, 'b, 'c, 'd, 'e, 'f) format6\n = ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.format6\n = Format of ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.fmt\n * string\n\ntype ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'c, 'c, 'd) format6\n\ntype ('a, 'b, 'c) format = ('a, 'b, 'c, 'c) format4\n\nlet string_of_format (Format (_fmt, str)) = str\n\nexternal format_of_string :\n ('a, 'b, 'c, 'd, 'e, 'f) format6 ->\n ('a, 'b, 'c, 'd, 'e, 'f) format6 = \"%identity\"\n\nlet ( ^^ ) (Format (fmt1, str1)) (Format (fmt2, str2)) =\n Format (CamlinternalFormatBasics.concat_fmt fmt1 fmt2,\n str1 ^ \"%,\" ^ str2)\n\n(* Miscellaneous *)\n\nexternal sys_exit : int -> 'a = \"caml_sys_exit\"\n\nlet exit_function = CamlinternalAtomic.make flush_all\n\nlet rec at_exit f =\n let module Atomic = CamlinternalAtomic in\n (* MPR#7253, MPR#7796: make sure \"f\" is executed only once *)\n let f_yet_to_run = Atomic.make true in\n let old_exit = Atomic.get exit_function in\n let new_exit () =\n if Atomic.compare_and_set f_yet_to_run true false then f () ;\n old_exit ()\n in\n let success = Atomic.compare_and_set exit_function old_exit new_exit in\n if not success then at_exit f\n\nlet do_at_exit () = (CamlinternalAtomic.get exit_function) ()\n\nlet exit retcode =\n do_at_exit ();\n sys_exit retcode\n\nlet _ = register_named_value \"Pervasives.do_at_exit\" do_at_exit\n\nexternal major : unit -> unit = \"caml_gc_major\"\nexternal naked_pointers_checked : unit -> bool\n = \"caml_sys_const_naked_pointers_checked\"\nlet () = if naked_pointers_checked () then at_exit major\n\n(*MODULE_ALIASES*)\nmodule Arg = Arg\nmodule Array = Array\nmodule ArrayLabels = ArrayLabels\nmodule Atomic = Atomic\nmodule Bigarray = Bigarray\nmodule Bool = Bool\nmodule Buffer = Buffer\nmodule Bytes = Bytes\nmodule BytesLabels = BytesLabels\nmodule Callback = Callback\nmodule Char = Char\nmodule Complex = Complex\nmodule Digest = Digest\nmodule Either = Either\nmodule Ephemeron = Ephemeron\nmodule Filename = Filename\nmodule Float = Float\nmodule Format = Format\nmodule Fun = Fun\nmodule Gc = Gc\nmodule Genlex = Genlex\nmodule Hashtbl = Hashtbl\nmodule In_channel = In_channel\nmodule Int = Int\nmodule Int32 = Int32\nmodule Int64 = Int64\nmodule Lazy = Lazy\nmodule Lexing = Lexing\nmodule List = List\nmodule ListLabels = ListLabels\nmodule Map = Map\nmodule Marshal = Marshal\nmodule MoreLabels = MoreLabels\nmodule Nativeint = Nativeint\nmodule Obj = Obj\nmodule Oo = Oo\nmodule Option = Option\nmodule Out_channel = Out_channel\nmodule Parsing = Parsing\nmodule Pervasives = Pervasives\nmodule Printexc = Printexc\nmodule Printf = Printf\nmodule Queue = Queue\nmodule Random = Random\nmodule Result = Result\nmodule Scanf = Scanf\nmodule Seq = Seq\nmodule Set = Set\nmodule Stack = Stack\nmodule StdLabels = StdLabels\nmodule Stream = Stream\nmodule String = String\nmodule StringLabels = StringLabels\nmodule Sys = Sys\nmodule Uchar = Uchar\nmodule Unit = Unit\nmodule Weak = Weak\n","(** This module is the toplevel of the Base library; it's what you get when you write\n [open Base].\n\n\n The goal of Base is both to be a more complete standard library, with richer APIs,\n and to be more consistent in its design. For instance, in the standard library\n some things have modules and others don't; in Base, everything is a module.\n\n Base extends some modules and data structures from the standard library, like [Array],\n [Buffer], [Bytes], [Char], [Hashtbl], [Int32], [Int64], [Lazy], [List], [Map],\n [Nativeint], [Printf], [Random], [Set], [String], [Sys], and [Uchar]. One key\n difference is that Base doesn't use exceptions as much as the standard library and\n instead makes heavy use of the [Result] type, as in:\n\n {[ type ('a,'b) result = Ok of 'a | Error of 'b ]}\n\n Base also adds entirely new modules, most notably:\n\n - [Comparable], [Comparator], and [Comparisons] in lieu of polymorphic compare.\n - [Container], which provides a consistent interface across container-like data\n structures (arrays, lists, strings).\n - [Result], [Error], and [Or_error], supporting the or-error pattern.\n\n The recommended way to use Base is to build with [-open Base]. Files compiled this\n way will have the environment described in this file as their initial environment.\n*)\n\n(*_ We hide this from the web docs because the line wrapping is bad, making it\n pretty much inscrutable. *)\n(**/**)\n\n(* The intent is to shadow all of INRIA's standard library. Modules below would cause\n compilation errors without being removed from [Shadow_stdlib] before inclusion. *)\n\ninclude (\n Shadow_stdlib :\n module type of struct\n include Shadow_stdlib\n end\n (* Modules defined in Base *)\n with module Array := Shadow_stdlib.Array\n with module Atomic := Shadow_stdlib.Atomic\n with module Bool := Shadow_stdlib.Bool\n with module Buffer := Shadow_stdlib.Buffer\n with module Bytes := Shadow_stdlib.Bytes\n with module Char := Shadow_stdlib.Char\n with module Either := Shadow_stdlib.Either\n with module Float := Shadow_stdlib.Float\n with module Hashtbl := Shadow_stdlib.Hashtbl\n with module In_channel := Shadow_stdlib.In_channel\n with module Int := Shadow_stdlib.Int\n with module Int32 := Shadow_stdlib.Int32\n with module Int64 := Shadow_stdlib.Int64\n with module Lazy := Shadow_stdlib.Lazy\n with module List := Shadow_stdlib.List\n with module Map := Shadow_stdlib.Map\n with module Nativeint := Shadow_stdlib.Nativeint\n with module Option := Shadow_stdlib.Option\n with module Out_channel := Shadow_stdlib.Out_channel\n with module Printf := Shadow_stdlib.Printf\n with module Queue := Shadow_stdlib.Queue\n with module Random := Shadow_stdlib.Random\n with module Result := Shadow_stdlib.Result\n with module Set := Shadow_stdlib.Set\n with module Stack := Shadow_stdlib.Stack\n with module String := Shadow_stdlib.String\n with module Sys := Shadow_stdlib.Sys\n with module Uchar := Shadow_stdlib.Uchar\n with module Unit := Shadow_stdlib.Unit\n (* Support for generated lexers *)\n with module Lexing := Shadow_stdlib.Lexing\n with type ('a, 'b, 'c) format := ('a, 'b, 'c) format\n with type ('a, 'b, 'c, 'd) format4 := ('a, 'b, 'c, 'd) format4\n with type ('a, 'b, 'c, 'd, 'e, 'f) format6 := ('a, 'b, 'c, 'd, 'e, 'f) format6\n with type 'a ref := 'a ref) [@ocaml.warning \"-3\"]\n\n(**/**)\n\nopen! Import\nmodule Applicative = Applicative\nmodule Array = Array\nmodule Avltree = Avltree\nmodule Backtrace = Backtrace\nmodule Binary_search = Binary_search\nmodule Binary_searchable = Binary_searchable\nmodule Blit = Blit\nmodule Bool = Bool\nmodule Buffer = Buffer\nmodule Bytes = Bytes\nmodule Char = Char\nmodule Comparable = Comparable\nmodule Comparator = Comparator\nmodule Comparisons = Comparisons\nmodule Container = Container\nmodule Either = Either\nmodule Equal = Equal\nmodule Error = Error\nmodule Exn = Exn\nmodule Field = Field\nmodule Float = Float\nmodule Floatable = Floatable\nmodule Fn = Fn\nmodule Formatter = Formatter\nmodule Hash = Hash\nmodule Hash_set = Hash_set\nmodule Hashable = Hashable\nmodule Hasher = Hasher\nmodule Hashtbl = Hashtbl\nmodule Identifiable = Identifiable\nmodule Indexed_container = Indexed_container\nmodule Info = Info\nmodule Int = Int\nmodule Int_conversions = Int_conversions\nmodule Int32 = Int32\nmodule Int63 = Int63\nmodule Int64 = Int64\nmodule Intable = Intable\nmodule Int_math = Int_math\nmodule Invariant = Invariant\nmodule Lazy = Lazy\nmodule List = List\nmodule Map = Map\nmodule Maybe_bound = Maybe_bound\nmodule Monad = Monad\nmodule Nativeint = Nativeint\nmodule Nothing = Nothing\nmodule Option = Option\nmodule Option_array = Option_array\nmodule Or_error = Or_error\nmodule Ordered_collection_common = Ordered_collection_common\nmodule Ordering = Ordering\nmodule Poly = Poly\nmodule Polymorphic_compare = Poly [@@deprecated \"[since 2018-11] use [Poly] instead\"]\n\nmodule Popcount = Popcount\n[@@deprecated \"[since 2018-10] use [popcount] functions in the individual int modules\"]\n\nmodule Pretty_printer = Pretty_printer\nmodule Printf = Printf\nmodule Linked_queue = Linked_queue\nmodule Queue = Queue\nmodule Random = Random\nmodule Ref = Ref\nmodule Result = Result\nmodule Sequence = Sequence\nmodule Set = Set\nmodule Sexpable = Sexpable\nmodule Sign = Sign\nmodule Sign_or_nan = Sign_or_nan\nmodule Source_code_position = Source_code_position\nmodule Stack = Stack\nmodule Staged = Staged\nmodule String = String\nmodule Stringable = Stringable\nmodule Sys = Sys\nmodule T = T\nmodule Type_equal = Type_equal\nmodule Uniform_array = Uniform_array\nmodule Unit = Unit\nmodule Uchar = Uchar\nmodule Validate = Validate\nmodule Variant = Variant\nmodule With_return = With_return\nmodule Word_size = Word_size\n\n(* Avoid a level of indirection for uses of the signatures defined in [T]. *)\ninclude T\n\n(* This is a hack so that odoc creates better documentation. *)\nmodule Sexp = struct\n include Sexp_with_comparable (** @inline *)\nend\n\n(**/**)\n\nmodule Exported_for_specific_uses = struct\n module Fieldslib = Fieldslib\n module Ppx_hash_lib = Ppx_hash_lib\n module Sexplib = Sexplib\n module Variantslib = Variantslib\n module Ppx_compare_lib = Ppx_compare_lib\n module Ppx_sexp_conv_lib = Ppx_sexp_conv_lib\n\n let am_testing = am_testing\nend\n\n(**/**)\n\nmodule Export = struct\n include Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.Builtin\n\n (* [deriving hash] is missing for [array] and [ref] since these types are mutable. *)\n type 'a array = 'a Array.t [@@deriving_inline compare, equal, sexp, sexp_grammar]\n\n let compare_array : 'a. ('a -> 'a -> int) -> 'a array -> 'a array -> int =\n Array.compare\n ;;\n\n let equal_array : 'a. ('a -> 'a -> bool) -> 'a array -> 'a array -> bool = Array.equal\n\n let array_of_sexp :\n 'a. (Ppx_sexp_conv_lib.Sexp.t -> 'a) -> Ppx_sexp_conv_lib.Sexp.t -> 'a array\n =\n Array.t_of_sexp\n ;;\n\n let sexp_of_array :\n 'a. ('a -> Ppx_sexp_conv_lib.Sexp.t) -> 'a array -> Ppx_sexp_conv_lib.Sexp.t\n =\n Array.sexp_of_t\n ;;\n\n let (array_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group) =\n { implicit_vars = [ \"Array.t\" ]\n ; ggid = \"r\\177A\\255~\\129%\\178\\226\\196g\\165\\t\\232\\204\\001\"\n ; types =\n [ \"array\", Explicit_bind ([ \"a\" ], Apply (Implicit_var 0, [ Explicit_var 0 ])) ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ Array.t_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"base.ml.Export\"\n }\n in\n let (array_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"array\", _the_group)\n in\n array_sexp_grammar\n ;;\n\n [@@@end]\n\n type bool = Bool.t [@@deriving_inline compare, equal, hash, sexp, sexp_grammar]\n\n let compare_bool = (Bool.compare : bool -> bool -> int)\n let equal_bool = (Bool.equal : bool -> bool -> bool)\n\n let (hash_fold_bool :\n Ppx_hash_lib.Std.Hash.state -> bool -> Ppx_hash_lib.Std.Hash.state)\n =\n Bool.hash_fold_t\n\n and (hash_bool : bool -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func = Bool.hash in\n fun x -> func x\n ;;\n\n let bool_of_sexp = (Bool.t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> bool)\n let sexp_of_bool = (Bool.sexp_of_t : bool -> Ppx_sexp_conv_lib.Sexp.t)\n\n let (bool_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group) =\n { implicit_vars = [ \"Bool.t\" ]\n ; ggid = \"{\\171\\239\\166\\219\\128\\005\\201\\192$\\149\\202\\251?\\186\\164\"\n ; types = [ \"bool\", Implicit_var 0 ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ Bool.t_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"base.ml.Export\"\n }\n in\n let (bool_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"bool\", _the_group)\n in\n bool_sexp_grammar\n ;;\n\n [@@@end]\n\n type char = Char.t [@@deriving_inline compare, equal, hash, sexp, sexp_grammar]\n\n let compare_char = (Char.compare : char -> char -> int)\n let equal_char = (Char.equal : char -> char -> bool)\n\n let (hash_fold_char :\n Ppx_hash_lib.Std.Hash.state -> char -> Ppx_hash_lib.Std.Hash.state)\n =\n Char.hash_fold_t\n\n and (hash_char : char -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func = Char.hash in\n fun x -> func x\n ;;\n\n let char_of_sexp = (Char.t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> char)\n let sexp_of_char = (Char.sexp_of_t : char -> Ppx_sexp_conv_lib.Sexp.t)\n\n let (char_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group) =\n { implicit_vars = [ \"Char.t\" ]\n ; ggid = \"H\\140\\243\\204Y\\222\\191d\\000@\\024Md\\028\\147>\"\n ; types = [ \"char\", Implicit_var 0 ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ Char.t_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"base.ml.Export\"\n }\n in\n let (char_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"char\", _the_group)\n in\n char_sexp_grammar\n ;;\n\n [@@@end]\n\n type exn = Exn.t [@@deriving_inline sexp_of]\n\n let sexp_of_exn = (Exn.sexp_of_t : exn -> Ppx_sexp_conv_lib.Sexp.t)\n\n [@@@end]\n\n type float = Float.t [@@deriving_inline compare, equal, hash, sexp, sexp_grammar]\n\n let compare_float = (Float.compare : float -> float -> int)\n let equal_float = (Float.equal : float -> float -> bool)\n\n let (hash_fold_float :\n Ppx_hash_lib.Std.Hash.state -> float -> Ppx_hash_lib.Std.Hash.state)\n =\n Float.hash_fold_t\n\n and (hash_float : float -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func = Float.hash in\n fun x -> func x\n ;;\n\n let float_of_sexp = (Float.t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> float)\n let sexp_of_float = (Float.sexp_of_t : float -> Ppx_sexp_conv_lib.Sexp.t)\n\n let (float_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group) =\n { implicit_vars = [ \"Float.t\" ]\n ; ggid = \"\\190E\\020\\242\\249\\135C\\240+\\214\\226\\143Ip\\217\\223\"\n ; types = [ \"float\", Implicit_var 0 ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ Float.t_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"base.ml.Export\"\n }\n in\n let (float_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"float\", _the_group)\n in\n float_sexp_grammar\n ;;\n\n [@@@end]\n\n type int = Int.t [@@deriving_inline compare, equal, hash, sexp, sexp_grammar]\n\n let compare_int = (Int.compare : int -> int -> int)\n let equal_int = (Int.equal : int -> int -> bool)\n\n let (hash_fold_int : Ppx_hash_lib.Std.Hash.state -> int -> Ppx_hash_lib.Std.Hash.state)\n =\n Int.hash_fold_t\n\n and (hash_int : int -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func = Int.hash in\n fun x -> func x\n ;;\n\n let int_of_sexp = (Int.t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> int)\n let sexp_of_int = (Int.sexp_of_t : int -> Ppx_sexp_conv_lib.Sexp.t)\n\n let (int_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group) =\n { implicit_vars = [ \"Int.t\" ]\n ; ggid = \"\\159\\159\\197^\\165]\\236\\165\\229\\165R8\\169\\225H\\020\"\n ; types = [ \"int\", Implicit_var 0 ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ Int.t_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"base.ml.Export\"\n }\n in\n let (int_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"int\", _the_group)\n in\n int_sexp_grammar\n ;;\n\n [@@@end]\n\n type int32 = Int32.t [@@deriving_inline compare, equal, hash, sexp, sexp_grammar]\n\n let compare_int32 = (Int32.compare : int32 -> int32 -> int)\n let equal_int32 = (Int32.equal : int32 -> int32 -> bool)\n\n let (hash_fold_int32 :\n Ppx_hash_lib.Std.Hash.state -> int32 -> Ppx_hash_lib.Std.Hash.state)\n =\n Int32.hash_fold_t\n\n and (hash_int32 : int32 -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func = Int32.hash in\n fun x -> func x\n ;;\n\n let int32_of_sexp = (Int32.t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> int32)\n let sexp_of_int32 = (Int32.sexp_of_t : int32 -> Ppx_sexp_conv_lib.Sexp.t)\n\n let (int32_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group) =\n { implicit_vars = [ \"Int32.t\" ]\n ; ggid = \"9\\153\\000*L5O+l\\018\\179b\\198\\248\\026\\177\"\n ; types = [ \"int32\", Implicit_var 0 ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ Int32.t_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"base.ml.Export\"\n }\n in\n let (int32_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"int32\", _the_group)\n in\n int32_sexp_grammar\n ;;\n\n [@@@end]\n\n type int64 = Int64.t [@@deriving_inline compare, equal, hash, sexp, sexp_grammar]\n\n let compare_int64 = (Int64.compare : int64 -> int64 -> int)\n let equal_int64 = (Int64.equal : int64 -> int64 -> bool)\n\n let (hash_fold_int64 :\n Ppx_hash_lib.Std.Hash.state -> int64 -> Ppx_hash_lib.Std.Hash.state)\n =\n Int64.hash_fold_t\n\n and (hash_int64 : int64 -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func = Int64.hash in\n fun x -> func x\n ;;\n\n let int64_of_sexp = (Int64.t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> int64)\n let sexp_of_int64 = (Int64.sexp_of_t : int64 -> Ppx_sexp_conv_lib.Sexp.t)\n\n let (int64_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group) =\n { implicit_vars = [ \"Int64.t\" ]\n ; ggid = \"r\\153\\022\\135\\131L\\155\\236\\235CKa\\197o\\248^\"\n ; types = [ \"int64\", Implicit_var 0 ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ Int64.t_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"base.ml.Export\"\n }\n in\n let (int64_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"int64\", _the_group)\n in\n int64_sexp_grammar\n ;;\n\n [@@@end]\n\n type 'a list = 'a List.t [@@deriving_inline compare, equal, hash, sexp, sexp_grammar]\n\n let compare_list : 'a. ('a -> 'a -> int) -> 'a list -> 'a list -> int = List.compare\n let equal_list : 'a. ('a -> 'a -> bool) -> 'a list -> 'a list -> bool = List.equal\n\n let hash_fold_list :\n 'a. (Ppx_hash_lib.Std.Hash.state -> 'a -> Ppx_hash_lib.Std.Hash.state)\n -> Ppx_hash_lib.Std.Hash.state -> 'a list -> Ppx_hash_lib.Std.Hash.state\n =\n List.hash_fold_t\n ;;\n\n let list_of_sexp :\n 'a. (Ppx_sexp_conv_lib.Sexp.t -> 'a) -> Ppx_sexp_conv_lib.Sexp.t -> 'a list\n =\n List.t_of_sexp\n ;;\n\n let sexp_of_list :\n 'a. ('a -> Ppx_sexp_conv_lib.Sexp.t) -> 'a list -> Ppx_sexp_conv_lib.Sexp.t\n =\n List.sexp_of_t\n ;;\n\n let (list_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group) =\n { implicit_vars = [ \"List.t\" ]\n ; ggid = \"\\144\\022 nativeint -> int)\n let equal_nativeint = (Nativeint.equal : nativeint -> nativeint -> bool)\n\n let (hash_fold_nativeint :\n Ppx_hash_lib.Std.Hash.state -> nativeint -> Ppx_hash_lib.Std.Hash.state)\n =\n Nativeint.hash_fold_t\n\n and (hash_nativeint : nativeint -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func = Nativeint.hash in\n fun x -> func x\n ;;\n\n let nativeint_of_sexp = (Nativeint.t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> nativeint)\n let sexp_of_nativeint = (Nativeint.sexp_of_t : nativeint -> Ppx_sexp_conv_lib.Sexp.t)\n\n let (nativeint_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group) =\n { implicit_vars = [ \"Nativeint.t\" ]\n ; ggid = \"\\019\\184AE\\023\\\\->1fcm\\002\\254\\196\\129\"\n ; types = [ \"nativeint\", Implicit_var 0 ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ Nativeint.t_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"base.ml.Export\"\n }\n in\n let (nativeint_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"nativeint\", _the_group)\n in\n nativeint_sexp_grammar\n ;;\n\n [@@@end]\n\n type 'a option = 'a Option.t\n [@@deriving_inline compare, equal, hash, sexp, sexp_grammar]\n\n let compare_option : 'a. ('a -> 'a -> int) -> 'a option -> 'a option -> int =\n Option.compare\n ;;\n\n let equal_option : 'a. ('a -> 'a -> bool) -> 'a option -> 'a option -> bool =\n Option.equal\n ;;\n\n let hash_fold_option :\n 'a. (Ppx_hash_lib.Std.Hash.state -> 'a -> Ppx_hash_lib.Std.Hash.state)\n -> Ppx_hash_lib.Std.Hash.state -> 'a option -> Ppx_hash_lib.Std.Hash.state\n =\n Option.hash_fold_t\n ;;\n\n let option_of_sexp :\n 'a. (Ppx_sexp_conv_lib.Sexp.t -> 'a) -> Ppx_sexp_conv_lib.Sexp.t -> 'a option\n =\n Option.t_of_sexp\n ;;\n\n let sexp_of_option :\n 'a. ('a -> Ppx_sexp_conv_lib.Sexp.t) -> 'a option -> Ppx_sexp_conv_lib.Sexp.t\n =\n Option.sexp_of_t\n ;;\n\n let (option_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group) =\n { implicit_vars = [ \"Option.t\" ]\n ; ggid = \"\\242@\\255j`*d\\203\\161\\182\\021\\175\\236\\146x\\217\"\n ; types =\n [ \"option\", Explicit_bind ([ \"a\" ], Apply (Implicit_var 0, [ Explicit_var 0 ]))\n ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ Option.t_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"base.ml.Export\"\n }\n in\n let (option_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"option\", _the_group)\n in\n option_sexp_grammar\n ;;\n\n [@@@end]\n\n type 'a ref = 'a Ref.t [@@deriving_inline compare, equal, sexp, sexp_grammar]\n\n let compare_ref : 'a. ('a -> 'a -> int) -> 'a ref -> 'a ref -> int = Ref.compare\n let equal_ref : 'a. ('a -> 'a -> bool) -> 'a ref -> 'a ref -> bool = Ref.equal\n\n let ref_of_sexp :\n 'a. (Ppx_sexp_conv_lib.Sexp.t -> 'a) -> Ppx_sexp_conv_lib.Sexp.t -> 'a ref\n =\n Ref.t_of_sexp\n ;;\n\n let sexp_of_ref :\n 'a. ('a -> Ppx_sexp_conv_lib.Sexp.t) -> 'a ref -> Ppx_sexp_conv_lib.Sexp.t\n =\n Ref.sexp_of_t\n ;;\n\n let (ref_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group) =\n { implicit_vars = [ \"Ref.t\" ]\n ; ggid = \"\\185\\246\\012[\\001\\197\\230\\192y=\\b\\199\\141\\248\\020\\012\"\n ; types =\n [ \"ref\", Explicit_bind ([ \"a\" ], Apply (Implicit_var 0, [ Explicit_var 0 ])) ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ Ref.t_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"base.ml.Export\"\n }\n in\n let (ref_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"ref\", _the_group)\n in\n ref_sexp_grammar\n ;;\n\n [@@@end]\n\n type string = String.t [@@deriving_inline compare, equal, hash, sexp, sexp_grammar]\n\n let compare_string = (String.compare : string -> string -> int)\n let equal_string = (String.equal : string -> string -> bool)\n\n let (hash_fold_string :\n Ppx_hash_lib.Std.Hash.state -> string -> Ppx_hash_lib.Std.Hash.state)\n =\n String.hash_fold_t\n\n and (hash_string : string -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func = String.hash in\n fun x -> func x\n ;;\n\n let string_of_sexp = (String.t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> string)\n let sexp_of_string = (String.sexp_of_t : string -> Ppx_sexp_conv_lib.Sexp.t)\n\n let (string_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group) =\n { implicit_vars = [ \"String.t\" ]\n ; ggid = \"\\141\\195]\\143\\139/M\\t\\159\\t\\152\\214g\\198\\023\\176\"\n ; types = [ \"string\", Implicit_var 0 ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ String.t_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"base.ml.Export\"\n }\n in\n let (string_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"string\", _the_group)\n in\n string_sexp_grammar\n ;;\n\n [@@@end]\n\n type bytes = Bytes.t [@@deriving_inline compare, equal, sexp, sexp_grammar]\n\n let compare_bytes = (Bytes.compare : bytes -> bytes -> int)\n let equal_bytes = (Bytes.equal : bytes -> bytes -> bool)\n let bytes_of_sexp = (Bytes.t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> bytes)\n let sexp_of_bytes = (Bytes.sexp_of_t : bytes -> Ppx_sexp_conv_lib.Sexp.t)\n\n let (bytes_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group) =\n { implicit_vars = [ \"Bytes.t\" ]\n ; ggid = \"\\015\\153L1\\012\\241\\015\\252\\150\\000\\191\\127Jb#3\"\n ; types = [ \"bytes\", Implicit_var 0 ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ Bytes.t_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"base.ml.Export\"\n }\n in\n let (bytes_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"bytes\", _the_group)\n in\n bytes_sexp_grammar\n ;;\n\n [@@@end]\n\n type unit = Unit.t [@@deriving_inline compare, equal, hash, sexp, sexp_grammar]\n\n let compare_unit = (Unit.compare : unit -> unit -> int)\n let equal_unit = (Unit.equal : unit -> unit -> bool)\n\n let (hash_fold_unit :\n Ppx_hash_lib.Std.Hash.state -> unit -> Ppx_hash_lib.Std.Hash.state)\n =\n Unit.hash_fold_t\n\n and (hash_unit : unit -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func = Unit.hash in\n fun x -> func x\n ;;\n\n let unit_of_sexp = (Unit.t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> unit)\n let sexp_of_unit = (Unit.sexp_of_t : unit -> Ppx_sexp_conv_lib.Sexp.t)\n\n let (unit_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group) =\n { implicit_vars = [ \"Unit.t\" ]\n ; ggid = \"=\\005 \\134\\187\\\"64\\197S\\19256,\\031l\"\n ; types = [ \"unit\", Implicit_var 0 ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ Unit.t_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"base.ml.Export\"\n }\n in\n let (unit_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"unit\", _the_group)\n in\n unit_sexp_grammar\n ;;\n\n [@@@end]\n\n (** Format stuff *)\n\n type nonrec ('a, 'b, 'c) format = ('a, 'b, 'c) format\n type nonrec ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'd) format4\n type nonrec ('a, 'b, 'c, 'd, 'e, 'f) format6 = ('a, 'b, 'c, 'd, 'e, 'f) format6\n\n (** {2 Sexp}\n\n Exporting the ad-hoc types that are recognized by [ppx_sexp_*] converters.\n [sexp_array], [sexp_list], and [sexp_option] allow a record field to be absent when\n converting from a sexp, and if absent, the field will take a default value of the\n appropriate type:\n\n {v\n sexp_array [||]\n sexp_bool false\n sexp_list []\n sexp_option None\n v}\n\n [sexp_opaque] causes the conversion to sexp to produce the atom [].\n\n For more documentation, see sexplib/README.md. *)\n\n type 'a sexp_array = 'a array\n [@@deprecated \"[since 2019-03] use [@sexp.array] instead\"]\n\n type 'a sexp_list = 'a list [@@deprecated \"[since 2019-03] use [@sexp.list] instead\"]\n type 'a sexp_opaque = 'a [@@deprecated \"[since 2019-03] use [@sexp.opaque] instead\"]\n\n type 'a sexp_option = 'a option\n [@@deprecated \"[since 2019-03] use [@sexp.option] instead\"]\n\n (** List operators *)\n\n include List.Infix\n\n (** Int operators and comparisons *)\n\n include Int.O\n include Int_replace_polymorphic_compare\n\n (** Float operators *)\n\n include Float.O_dot\n\n (* This is declared as an external to be optimized away in more contexts. *)\n\n (** Reverse application operator. [x |> g |> f] is equivalent to [f (g (x))]. *)\n external ( |> ) : 'a -> ('a -> 'b) -> 'b = \"%revapply\"\n\n (** Application operator. [g @@ f @@ x] is equivalent to [g (f (x))]. *)\n external ( @@ ) : ('a -> 'b) -> 'a -> 'b = \"%apply\"\n\n (** Boolean operations *)\n\n (* These need to be declared as an external to get the lazy behavior *)\n external ( && ) : bool -> bool -> bool = \"%sequand\"\n external ( || ) : bool -> bool -> bool = \"%sequor\"\n external not : bool -> bool = \"%boolnot\"\n\n (* This must be declared as an external for the warnings to work properly. *)\n external ignore : _ -> unit = \"%ignore\"\n\n (** Common string operations *)\n let ( ^ ) = String.( ^ )\n\n (** Reference operations *)\n\n (* Declared as an externals so that the compiler skips the caml_modify when possible and\n to keep reference unboxing working *)\n external ( ! ) : 'a ref -> 'a = \"%field0\"\n external ref : 'a -> 'a ref = \"%makemutable\"\n external ( := ) : 'a ref -> 'a -> unit = \"%setfield0\"\n\n (** Pair operations *)\n\n let fst = fst\n let snd = snd\n\n (** Exceptions stuff *)\n\n (* Declared as an external so that the compiler may rewrite '%raise' as '%reraise'. *)\n external raise : exn -> _ = \"%raise\"\n\n let failwith = failwith\n let invalid_arg = invalid_arg\n let raise_s = Error.raise_s\n\n (** Misc *)\n\n let phys_equal = phys_equal\n\n external force : 'a Lazy.t -> 'a = \"%lazy_force\"\nend\n\ninclude Export\n\ninclude Container_intf.Export (** @inline *)\n\nexception Not_found_s = Not_found_s\n\n(* We perform these side effects here because we want them to run for any code that uses\n [Base]. If this were in another module in [Base] that was not used in some program,\n then the side effects might not be run in that program. This will run as long as the\n program refers to at least one value directly in [Base]; referring to values in\n [Base.Bool], for example, is not sufficient. *)\nlet () = Backtrace.initialize_module ()\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(** The OCaml Standard library.\n\n This module is automatically opened at the beginning of each\n compilation. All components of this module can therefore be\n referred by their short name, without prefixing them by [Stdlib].\n\n It particular, it provides the basic operations over the built-in\n types (numbers, booleans, byte sequences, strings, exceptions,\n references, lists, arrays, input-output channels, ...) and the\n {{!modules}standard library modules}.\n*)\n\n(** {1 Exceptions} *)\n\nexternal raise : exn -> 'a = \"%raise\"\n(** Raise the given exception value *)\n\nexternal raise_notrace : exn -> 'a = \"%raise_notrace\"\n(** A faster version [raise] which does not record the backtrace.\n @since 4.02.0\n*)\n\nval invalid_arg : string -> 'a\n(** Raise exception [Invalid_argument] with the given string. *)\n\nval failwith : string -> 'a\n(** Raise exception [Failure] with the given string. *)\n\nexception Exit\n(** The [Exit] exception is not raised by any library function. It is\n provided for use in your programs. *)\n\nexception Match_failure of (string * int * int)\n [@ocaml.warn_on_literal_pattern]\n(** Exception raised when none of the cases of a pattern-matching\n apply. The arguments are the location of the match keyword in the\n source code (file name, line number, column number). *)\n\nexception Assert_failure of (string * int * int)\n [@ocaml.warn_on_literal_pattern]\n(** Exception raised when an assertion fails. The arguments are the\n location of the assert keyword in the source code (file name, line\n number, column number). *)\n\nexception Invalid_argument of string\n [@ocaml.warn_on_literal_pattern]\n(** Exception raised by library functions to signal that the given\n arguments do not make sense. The string gives some information to\n the programmer. As a general rule, this exception should not be\n caught, it denotes a programming error and the code should be\n modified not to trigger it. *)\n\nexception Failure of string\n [@ocaml.warn_on_literal_pattern]\n(** Exception raised by library functions to signal that they are\n undefined on the given arguments. The string is meant to give some\n information to the programmer; you must not pattern match on the\n string literal because it may change in future versions (use\n Failure _ instead). *)\n\nexception Not_found\n(** Exception raised by search functions when the desired object could\n not be found. *)\n\nexception Out_of_memory\n(** Exception raised by the garbage collector when there is\n insufficient memory to complete the computation. (Not reliable for\n allocations on the minor heap.) *)\n\nexception Stack_overflow\n(** Exception raised by the bytecode interpreter when the evaluation\n stack reaches its maximal size. This often indicates infinite or\n excessively deep recursion in the user's program.\n\n Before 4.10, it was not fully implemented by the native-code\n compiler. *)\n\nexception Sys_error of string\n [@ocaml.warn_on_literal_pattern]\n(** Exception raised by the input/output functions to report an\n operating system error. The string is meant to give some\n information to the programmer; you must not pattern match on the\n string literal because it may change in future versions (use\n Sys_error _ instead). *)\n\nexception End_of_file\n(** Exception raised by input functions to signal that the end of file\n has been reached. *)\n\nexception Division_by_zero\n(** Exception raised by integer division and remainder operations when\n their second argument is zero. *)\n\nexception Sys_blocked_io\n(** A special case of Sys_error raised when no I/O is possible on a\n non-blocking I/O channel. *)\n\nexception Undefined_recursive_module of (string * int * int)\n [@ocaml.warn_on_literal_pattern]\n(** Exception raised when an ill-founded recursive module definition\n is evaluated. The arguments are the location of the definition in\n the source code (file name, line number, column number). *)\n\n(** {1 Comparisons} *)\n\nexternal ( = ) : 'a -> 'a -> bool = \"%equal\"\n(** [e1 = e2] tests for structural equality of [e1] and [e2].\n Mutable structures (e.g. references and arrays) are equal\n if and only if their current contents are structurally equal,\n even if the two mutable objects are not the same physical object.\n Equality between functional values raises [Invalid_argument].\n Equality between cyclic data structures may not terminate.\n Left-associative operator, see {!Ocaml_operators} for more information. *)\n\nexternal ( <> ) : 'a -> 'a -> bool = \"%notequal\"\n(** Negation of {!Stdlib.( = )}.\n Left-associative operator, see {!Ocaml_operators} for more information.\n*)\n\nexternal ( < ) : 'a -> 'a -> bool = \"%lessthan\"\n(** See {!Stdlib.( >= )}.\n Left-associative operator, see {!Ocaml_operators} for more information.\n*)\n\nexternal ( > ) : 'a -> 'a -> bool = \"%greaterthan\"\n(** See {!Stdlib.( >= )}.\n Left-associative operator, see {!Ocaml_operators} for more information.\n*)\n\nexternal ( <= ) : 'a -> 'a -> bool = \"%lessequal\"\n(** See {!Stdlib.( >= )}.\n Left-associative operator, see {!Ocaml_operators} for more information.\n*)\n\nexternal ( >= ) : 'a -> 'a -> bool = \"%greaterequal\"\n(** Structural ordering functions. These functions coincide with\n the usual orderings over integers, characters, strings, byte sequences\n and floating-point numbers, and extend them to a\n total ordering over all types.\n The ordering is compatible with [( = )]. As in the case\n of [( = )], mutable structures are compared by contents.\n Comparison between functional values raises [Invalid_argument].\n Comparison between cyclic structures may not terminate.\n Left-associative operator, see {!Ocaml_operators} for more information.\n*)\n\nexternal compare : 'a -> 'a -> int = \"%compare\"\n(** [compare x y] returns [0] if [x] is equal to [y],\n a negative integer if [x] is less than [y], and a positive integer\n if [x] is greater than [y]. The ordering implemented by [compare]\n is compatible with the comparison predicates [=], [<] and [>]\n defined above, with one difference on the treatment of the float value\n {!Stdlib.nan}. Namely, the comparison predicates treat [nan]\n as different from any other float value, including itself;\n while [compare] treats [nan] as equal to itself and less than any\n other float value. This treatment of [nan] ensures that [compare]\n defines a total ordering relation.\n\n [compare] applied to functional values may raise [Invalid_argument].\n [compare] applied to cyclic structures may not terminate.\n\n The [compare] function can be used as the comparison function\n required by the {!Set.Make} and {!Map.Make} functors, as well as\n the {!List.sort} and {!Array.sort} functions. *)\n\nval min : 'a -> 'a -> 'a\n(** Return the smaller of the two arguments.\n The result is unspecified if one of the arguments contains\n the float value [nan]. *)\n\nval max : 'a -> 'a -> 'a\n(** Return the greater of the two arguments.\n The result is unspecified if one of the arguments contains\n the float value [nan]. *)\n\nexternal ( == ) : 'a -> 'a -> bool = \"%eq\"\n(** [e1 == e2] tests for physical equality of [e1] and [e2].\n On mutable types such as references, arrays, byte sequences, records with\n mutable fields and objects with mutable instance variables,\n [e1 == e2] is true if and only if physical modification of [e1]\n also affects [e2].\n On non-mutable types, the behavior of [( == )] is\n implementation-dependent; however, it is guaranteed that\n [e1 == e2] implies [compare e1 e2 = 0].\n Left-associative operator, see {!Ocaml_operators} for more information.\n*)\n\nexternal ( != ) : 'a -> 'a -> bool = \"%noteq\"\n(** Negation of {!Stdlib.( == )}.\n Left-associative operator, see {!Ocaml_operators} for more information.\n*)\n\n\n(** {1 Boolean operations} *)\n\nexternal not : bool -> bool = \"%boolnot\"\n(** The boolean negation. *)\n\nexternal ( && ) : bool -> bool -> bool = \"%sequand\"\n(** The boolean 'and'. Evaluation is sequential, left-to-right:\n in [e1 && e2], [e1] is evaluated first, and if it returns [false],\n [e2] is not evaluated at all.\n Right-associative operator, see {!Ocaml_operators} for more information.\n*)\n\nexternal ( & ) : bool -> bool -> bool = \"%sequand\"\n [@@ocaml.deprecated \"Use (&&) instead.\"]\n(** @deprecated {!Stdlib.( && )} should be used instead.\n Right-associative operator, see {!Ocaml_operators} for more information.\n*)\n\nexternal ( || ) : bool -> bool -> bool = \"%sequor\"\n(** The boolean 'or'. Evaluation is sequential, left-to-right:\n in [e1 || e2], [e1] is evaluated first, and if it returns [true],\n [e2] is not evaluated at all.\n Right-associative operator, see {!Ocaml_operators} for more information.\n*)\n\nexternal ( or ) : bool -> bool -> bool = \"%sequor\"\n [@@ocaml.deprecated \"Use (||) instead.\"]\n(** @deprecated {!Stdlib.( || )} should be used instead.\n Right-associative operator, see {!Ocaml_operators} for more information.\n*)\n\n(** {1 Debugging} *)\n\nexternal __LOC__ : string = \"%loc_LOC\"\n(** [__LOC__] returns the location at which this expression appears in\n the file currently being parsed by the compiler, with the standard\n error format of OCaml: \"File %S, line %d, characters %d-%d\".\n @since 4.02.0\n*)\n\nexternal __FILE__ : string = \"%loc_FILE\"\n(** [__FILE__] returns the name of the file currently being\n parsed by the compiler.\n @since 4.02.0\n*)\n\nexternal __LINE__ : int = \"%loc_LINE\"\n(** [__LINE__] returns the line number at which this expression\n appears in the file currently being parsed by the compiler.\n @since 4.02.0\n*)\n\nexternal __MODULE__ : string = \"%loc_MODULE\"\n(** [__MODULE__] returns the module name of the file being\n parsed by the compiler.\n @since 4.02.0\n*)\n\nexternal __POS__ : string * int * int * int = \"%loc_POS\"\n(** [__POS__] returns a tuple [(file,lnum,cnum,enum)], corresponding\n to the location at which this expression appears in the file\n currently being parsed by the compiler. [file] is the current\n filename, [lnum] the line number, [cnum] the character position in\n the line and [enum] the last character position in the line.\n @since 4.02.0\n *)\n\nexternal __FUNCTION__ : string = \"%loc_FUNCTION\"\n(** [__FUNCTION__] returns the name of the current function or method, including\n any enclosing modules or classes.\n\n @since 4.12.0 *)\n\nexternal __LOC_OF__ : 'a -> string * 'a = \"%loc_LOC\"\n(** [__LOC_OF__ expr] returns a pair [(loc, expr)] where [loc] is the\n location of [expr] in the file currently being parsed by the\n compiler, with the standard error format of OCaml: \"File %S, line\n %d, characters %d-%d\".\n @since 4.02.0\n*)\n\nexternal __LINE_OF__ : 'a -> int * 'a = \"%loc_LINE\"\n(** [__LINE_OF__ expr] returns a pair [(line, expr)], where [line] is the\n line number at which the expression [expr] appears in the file\n currently being parsed by the compiler.\n @since 4.02.0\n *)\n\nexternal __POS_OF__ : 'a -> (string * int * int * int) * 'a = \"%loc_POS\"\n(** [__POS_OF__ expr] returns a pair [(loc,expr)], where [loc] is a\n tuple [(file,lnum,cnum,enum)] corresponding to the location at\n which the expression [expr] appears in the file currently being\n parsed by the compiler. [file] is the current filename, [lnum] the\n line number, [cnum] the character position in the line and [enum]\n the last character position in the line.\n @since 4.02.0\n *)\n\n(** {1 Composition operators} *)\n\nexternal ( |> ) : 'a -> ('a -> 'b) -> 'b = \"%revapply\"\n(** Reverse-application operator: [x |> f |> g] is exactly equivalent\n to [g (f (x))].\n Left-associative operator, see {!Ocaml_operators} for more information.\n @since 4.01\n*)\n\nexternal ( @@ ) : ('a -> 'b) -> 'a -> 'b = \"%apply\"\n(** Application operator: [g @@ f @@ x] is exactly equivalent to\n [g (f (x))].\n Right-associative operator, see {!Ocaml_operators} for more information.\n @since 4.01\n*)\n\n(** {1 Integer arithmetic} *)\n\n(** Integers are [Sys.int_size] bits wide.\n All operations are taken modulo 2{^[Sys.int_size]}.\n They do not fail on overflow. *)\n\nexternal ( ~- ) : int -> int = \"%negint\"\n(** Unary negation. You can also write [- e] instead of [~- e].\n Unary operator, see {!Ocaml_operators} for more information.\n*)\n\n\nexternal ( ~+ ) : int -> int = \"%identity\"\n(** Unary addition. You can also write [+ e] instead of [~+ e].\n Unary operator, see {!Ocaml_operators} for more information.\n @since 3.12.0\n*)\n\nexternal succ : int -> int = \"%succint\"\n(** [succ x] is [x + 1]. *)\n\nexternal pred : int -> int = \"%predint\"\n(** [pred x] is [x - 1]. *)\n\nexternal ( + ) : int -> int -> int = \"%addint\"\n(** Integer addition.\n Left-associative operator, see {!Ocaml_operators} for more information.\n*)\n\nexternal ( - ) : int -> int -> int = \"%subint\"\n(** Integer subtraction.\n Left-associative operator, , see {!Ocaml_operators} for more information.\n*)\n\nexternal ( * ) : int -> int -> int = \"%mulint\"\n(** Integer multiplication.\n Left-associative operator, see {!Ocaml_operators} for more information.\n*)\n\nexternal ( / ) : int -> int -> int = \"%divint\"\n(** Integer division.\n Integer division rounds the real quotient of its arguments towards zero.\n More precisely, if [x >= 0] and [y > 0], [x / y] is the greatest integer\n less than or equal to the real quotient of [x] by [y]. Moreover,\n [(- x) / y = x / (- y) = - (x / y)].\n Left-associative operator, see {!Ocaml_operators} for more information.\n\n @raise Division_by_zero if the second argument is 0.\n*)\n\nexternal ( mod ) : int -> int -> int = \"%modint\"\n(** Integer remainder. If [y] is not zero, the result\n of [x mod y] satisfies the following properties:\n [x = (x / y) * y + x mod y] and\n [abs(x mod y) <= abs(y) - 1].\n If [y = 0], [x mod y] raises [Division_by_zero].\n Note that [x mod y] is negative only if [x < 0].\n Left-associative operator, see {!Ocaml_operators} for more information.\n\n @raise Division_by_zero if [y] is zero.\n*)\n\nval abs : int -> int\n(** Return the absolute value of the argument. Note that this may be\n negative if the argument is [min_int]. *)\n\nval max_int : int\n(** The greatest representable integer. *)\n\nval min_int : int\n(** The smallest representable integer. *)\n\n\n(** {2 Bitwise operations} *)\n\nexternal ( land ) : int -> int -> int = \"%andint\"\n(** Bitwise logical and.\n Left-associative operator, see {!Ocaml_operators} for more information.\n*)\n\nexternal ( lor ) : int -> int -> int = \"%orint\"\n(** Bitwise logical or.\n Left-associative operator, see {!Ocaml_operators} for more information.\n*)\n\nexternal ( lxor ) : int -> int -> int = \"%xorint\"\n(** Bitwise logical exclusive or.\n Left-associative operator, see {!Ocaml_operators} for more information.\n*)\n\nval lnot : int -> int\n(** Bitwise logical negation. *)\n\nexternal ( lsl ) : int -> int -> int = \"%lslint\"\n(** [n lsl m] shifts [n] to the left by [m] bits.\n The result is unspecified if [m < 0] or [m > Sys.int_size].\n Right-associative operator, see {!Ocaml_operators} for more information.\n*)\n\nexternal ( lsr ) : int -> int -> int = \"%lsrint\"\n(** [n lsr m] shifts [n] to the right by [m] bits.\n This is a logical shift: zeroes are inserted regardless of\n the sign of [n].\n The result is unspecified if [m < 0] or [m > Sys.int_size].\n Right-associative operator, see {!Ocaml_operators} for more information.\n*)\n\nexternal ( asr ) : int -> int -> int = \"%asrint\"\n(** [n asr m] shifts [n] to the right by [m] bits.\n This is an arithmetic shift: the sign bit of [n] is replicated.\n The result is unspecified if [m < 0] or [m > Sys.int_size].\n Right-associative operator, see {!Ocaml_operators} for more information.\n*)\n\n(** {1 Floating-point arithmetic}\n\n OCaml's floating-point numbers follow the\n IEEE 754 standard, using double precision (64 bits) numbers.\n Floating-point operations never raise an exception on overflow,\n underflow, division by zero, etc. Instead, special IEEE numbers\n are returned as appropriate, such as [infinity] for [1.0 /. 0.0],\n [neg_infinity] for [-1.0 /. 0.0], and [nan] ('not a number')\n for [0.0 /. 0.0]. These special numbers then propagate through\n floating-point computations as expected: for instance,\n [1.0 /. infinity] is [0.0], basic arithmetic operations\n ([+.], [-.], [*.], [/.]) with [nan] as an argument return [nan], ...\n*)\n\nexternal ( ~-. ) : float -> float = \"%negfloat\"\n(** Unary negation. You can also write [-. e] instead of [~-. e].\n Unary operator, see {!Ocaml_operators} for more information.\n*)\n\nexternal ( ~+. ) : float -> float = \"%identity\"\n(** Unary addition. You can also write [+. e] instead of [~+. e].\n Unary operator, see {!Ocaml_operators} for more information.\n @since 3.12.0\n*)\n\nexternal ( +. ) : float -> float -> float = \"%addfloat\"\n(** Floating-point addition.\n Left-associative operator, see {!Ocaml_operators} for more information.\n*)\n\nexternal ( -. ) : float -> float -> float = \"%subfloat\"\n(** Floating-point subtraction.\n Left-associative operator, see {!Ocaml_operators} for more information.\n*)\n\nexternal ( *. ) : float -> float -> float = \"%mulfloat\"\n(** Floating-point multiplication.\n Left-associative operator, see {!Ocaml_operators} for more information.\n*)\n\nexternal ( /. ) : float -> float -> float = \"%divfloat\"\n(** Floating-point division.\n Left-associative operator, see {!Ocaml_operators} for more information.\n*)\n\nexternal ( ** ) : float -> float -> float = \"caml_power_float\" \"pow\"\n [@@unboxed] [@@noalloc]\n(** Exponentiation.\n Right-associative operator, see {!Ocaml_operators} for more information.\n*)\n\nexternal sqrt : float -> float = \"caml_sqrt_float\" \"sqrt\"\n [@@unboxed] [@@noalloc]\n(** Square root. *)\n\nexternal exp : float -> float = \"caml_exp_float\" \"exp\" [@@unboxed] [@@noalloc]\n(** Exponential. *)\n\nexternal log : float -> float = \"caml_log_float\" \"log\" [@@unboxed] [@@noalloc]\n(** Natural logarithm. *)\n\nexternal log10 : float -> float = \"caml_log10_float\" \"log10\"\n [@@unboxed] [@@noalloc]\n(** Base 10 logarithm. *)\n\nexternal expm1 : float -> float = \"caml_expm1_float\" \"caml_expm1\"\n [@@unboxed] [@@noalloc]\n(** [expm1 x] computes [exp x -. 1.0], giving numerically-accurate results\n even if [x] is close to [0.0].\n @since 3.12.0\n*)\n\nexternal log1p : float -> float = \"caml_log1p_float\" \"caml_log1p\"\n [@@unboxed] [@@noalloc]\n(** [log1p x] computes [log(1.0 +. x)] (natural logarithm),\n giving numerically-accurate results even if [x] is close to [0.0].\n @since 3.12.0\n*)\n\nexternal cos : float -> float = \"caml_cos_float\" \"cos\" [@@unboxed] [@@noalloc]\n(** Cosine. Argument is in radians. *)\n\nexternal sin : float -> float = \"caml_sin_float\" \"sin\" [@@unboxed] [@@noalloc]\n(** Sine. Argument is in radians. *)\n\nexternal tan : float -> float = \"caml_tan_float\" \"tan\" [@@unboxed] [@@noalloc]\n(** Tangent. Argument is in radians. *)\n\nexternal acos : float -> float = \"caml_acos_float\" \"acos\"\n [@@unboxed] [@@noalloc]\n(** Arc cosine. The argument must fall within the range [[-1.0, 1.0]].\n Result is in radians and is between [0.0] and [pi]. *)\n\nexternal asin : float -> float = \"caml_asin_float\" \"asin\"\n [@@unboxed] [@@noalloc]\n(** Arc sine. The argument must fall within the range [[-1.0, 1.0]].\n Result is in radians and is between [-pi/2] and [pi/2]. *)\n\nexternal atan : float -> float = \"caml_atan_float\" \"atan\"\n [@@unboxed] [@@noalloc]\n(** Arc tangent.\n Result is in radians and is between [-pi/2] and [pi/2]. *)\n\nexternal atan2 : float -> float -> float = \"caml_atan2_float\" \"atan2\"\n [@@unboxed] [@@noalloc]\n(** [atan2 y x] returns the arc tangent of [y /. x]. The signs of [x]\n and [y] are used to determine the quadrant of the result.\n Result is in radians and is between [-pi] and [pi]. *)\n\nexternal hypot : float -> float -> float = \"caml_hypot_float\" \"caml_hypot\"\n [@@unboxed] [@@noalloc]\n(** [hypot x y] returns [sqrt(x *. x + y *. y)], that is, the length\n of the hypotenuse of a right-angled triangle with sides of length\n [x] and [y], or, equivalently, the distance of the point [(x,y)]\n to origin. If one of [x] or [y] is infinite, returns [infinity]\n even if the other is [nan].\n @since 4.00.0 *)\n\nexternal cosh : float -> float = \"caml_cosh_float\" \"cosh\"\n [@@unboxed] [@@noalloc]\n(** Hyperbolic cosine. Argument is in radians. *)\n\nexternal sinh : float -> float = \"caml_sinh_float\" \"sinh\"\n [@@unboxed] [@@noalloc]\n(** Hyperbolic sine. Argument is in radians. *)\n\nexternal tanh : float -> float = \"caml_tanh_float\" \"tanh\"\n [@@unboxed] [@@noalloc]\n(** Hyperbolic tangent. Argument is in radians. *)\n\nexternal acosh : float -> float = \"caml_acosh_float\" \"caml_acosh\"\n [@@unboxed] [@@noalloc]\n(** Hyperbolic arc cosine. The argument must fall within the range\n [[1.0, inf]].\n Result is in radians and is between [0.0] and [inf].\n\n @since 4.13.0\n*)\n\nexternal asinh : float -> float = \"caml_asinh_float\" \"caml_asinh\"\n [@@unboxed] [@@noalloc]\n(** Hyperbolic arc sine. The argument and result range over the entire\n real line.\n Result is in radians.\n\n @since 4.13.0\n*)\n\nexternal atanh : float -> float = \"caml_atanh_float\" \"caml_atanh\"\n [@@unboxed] [@@noalloc]\n(** Hyperbolic arc tangent. The argument must fall within the range\n [[-1.0, 1.0]].\n Result is in radians and ranges over the entire real line.\n\n @since 4.13.0\n*)\n\nexternal ceil : float -> float = \"caml_ceil_float\" \"ceil\"\n [@@unboxed] [@@noalloc]\n(** Round above to an integer value.\n [ceil f] returns the least integer value greater than or equal to [f].\n The result is returned as a float. *)\n\nexternal floor : float -> float = \"caml_floor_float\" \"floor\"\n [@@unboxed] [@@noalloc]\n(** Round below to an integer value.\n [floor f] returns the greatest integer value less than or\n equal to [f].\n The result is returned as a float. *)\n\nexternal abs_float : float -> float = \"%absfloat\"\n(** [abs_float f] returns the absolute value of [f]. *)\n\nexternal copysign : float -> float -> float\n = \"caml_copysign_float\" \"caml_copysign\"\n [@@unboxed] [@@noalloc]\n(** [copysign x y] returns a float whose absolute value is that of [x]\n and whose sign is that of [y]. If [x] is [nan], returns [nan].\n If [y] is [nan], returns either [x] or [-. x], but it is not\n specified which.\n @since 4.00.0 *)\n\nexternal mod_float : float -> float -> float = \"caml_fmod_float\" \"fmod\"\n [@@unboxed] [@@noalloc]\n(** [mod_float a b] returns the remainder of [a] with respect to\n [b]. The returned value is [a -. n *. b], where [n]\n is the quotient [a /. b] rounded towards zero to an integer. *)\n\nexternal frexp : float -> float * int = \"caml_frexp_float\"\n(** [frexp f] returns the pair of the significant\n and the exponent of [f]. When [f] is zero, the\n significant [x] and the exponent [n] of [f] are equal to\n zero. When [f] is non-zero, they are defined by\n [f = x *. 2 ** n] and [0.5 <= x < 1.0]. *)\n\n\nexternal ldexp : (float [@unboxed]) -> (int [@untagged]) -> (float [@unboxed]) =\n \"caml_ldexp_float\" \"caml_ldexp_float_unboxed\" [@@noalloc]\n(** [ldexp x n] returns [x *. 2 ** n]. *)\n\nexternal modf : float -> float * float = \"caml_modf_float\"\n(** [modf f] returns the pair of the fractional and integral\n part of [f]. *)\n\nexternal float : int -> float = \"%floatofint\"\n(** Same as {!Stdlib.float_of_int}. *)\n\nexternal float_of_int : int -> float = \"%floatofint\"\n(** Convert an integer to floating-point. *)\n\nexternal truncate : float -> int = \"%intoffloat\"\n(** Same as {!Stdlib.int_of_float}. *)\n\nexternal int_of_float : float -> int = \"%intoffloat\"\n(** Truncate the given floating-point number to an integer.\n The result is unspecified if the argument is [nan] or falls outside the\n range of representable integers. *)\n\nval infinity : float\n(** Positive infinity. *)\n\nval neg_infinity : float\n(** Negative infinity. *)\n\nval nan : float\n(** A special floating-point value denoting the result of an\n undefined operation such as [0.0 /. 0.0]. Stands for\n 'not a number'. Any floating-point operation with [nan] as\n argument returns [nan] as result. As for floating-point comparisons,\n [=], [<], [<=], [>] and [>=] return [false] and [<>] returns [true]\n if one or both of their arguments is [nan]. *)\n\nval max_float : float\n(** The largest positive finite value of type [float]. *)\n\nval min_float : float\n(** The smallest positive, non-zero, non-denormalized value of type [float]. *)\n\nval epsilon_float : float\n(** The difference between [1.0] and the smallest exactly representable\n floating-point number greater than [1.0]. *)\n\ntype fpclass =\n FP_normal (** Normal number, none of the below *)\n | FP_subnormal (** Number very close to 0.0, has reduced precision *)\n | FP_zero (** Number is 0.0 or -0.0 *)\n | FP_infinite (** Number is positive or negative infinity *)\n | FP_nan (** Not a number: result of an undefined operation *)\n(** The five classes of floating-point numbers, as determined by\n the {!Stdlib.classify_float} function. *)\n\nexternal classify_float : (float [@unboxed]) -> fpclass =\n \"caml_classify_float\" \"caml_classify_float_unboxed\" [@@noalloc]\n(** Return the class of the given floating-point number:\n normal, subnormal, zero, infinite, or not a number. *)\n\n\n(** {1 String operations}\n\n More string operations are provided in module {!String}.\n*)\n\nval ( ^ ) : string -> string -> string\n(** String concatenation.\n Right-associative operator, see {!Ocaml_operators} for more information.\n\n @raise Invalid_argument if the result is longer then\n than {!Sys.max_string_length} bytes.\n*)\n\n(** {1 Character operations}\n\n More character operations are provided in module {!Char}.\n*)\n\nexternal int_of_char : char -> int = \"%identity\"\n(** Return the ASCII code of the argument. *)\n\nval char_of_int : int -> char\n(** Return the character with the given ASCII code.\n @raise Invalid_argument if the argument is\n outside the range 0--255. *)\n\n\n(** {1 Unit operations} *)\n\nexternal ignore : 'a -> unit = \"%ignore\"\n(** Discard the value of its argument and return [()].\n For instance, [ignore(f x)] discards the result of\n the side-effecting function [f]. It is equivalent to\n [f x; ()], except that the latter may generate a\n compiler warning; writing [ignore(f x)] instead\n avoids the warning. *)\n\n\n(** {1 String conversion functions} *)\n\nval string_of_bool : bool -> string\n(** Return the string representation of a boolean. As the returned values\n may be shared, the user should not modify them directly.\n*)\n\nval bool_of_string_opt: string -> bool option\n(** Convert the given string to a boolean.\n\n Return [None] if the string is not [\"true\"] or [\"false\"].\n @since 4.05\n*)\n\nval bool_of_string : string -> bool\n(** Same as {!Stdlib.bool_of_string_opt}, but raise\n [Invalid_argument \"bool_of_string\"] instead of returning [None]. *)\n\nval string_of_int : int -> string\n(** Return the string representation of an integer, in decimal. *)\n\nval int_of_string_opt: string -> int option\n(** Convert the given string to an integer.\n The string is read in decimal (by default, or if the string\n begins with [0u]), in hexadecimal (if it begins with [0x] or\n [0X]), in octal (if it begins with [0o] or [0O]), or in binary\n (if it begins with [0b] or [0B]).\n\n The [0u] prefix reads the input as an unsigned integer in the range\n [[0, 2*max_int+1]]. If the input exceeds {!max_int}\n it is converted to the signed integer\n [min_int + input - max_int - 1].\n\n The [_] (underscore) character can appear anywhere in the string\n and is ignored.\n\n Return [None] if the given string is not a valid representation of an\n integer, or if the integer represented exceeds the range of integers\n representable in type [int].\n @since 4.05\n*)\n\nexternal int_of_string : string -> int = \"caml_int_of_string\"\n(** Same as {!Stdlib.int_of_string_opt}, but raise\n [Failure \"int_of_string\"] instead of returning [None]. *)\n\nval string_of_float : float -> string\n(** Return the string representation of a floating-point number. *)\n\nval float_of_string_opt: string -> float option\n(** Convert the given string to a float. The string is read in decimal\n (by default) or in hexadecimal (marked by [0x] or [0X]).\n\n The format of decimal floating-point numbers is\n [ [-] dd.ddd (e|E) [+|-] dd ], where [d] stands for a decimal digit.\n\n The format of hexadecimal floating-point numbers is\n [ [-] 0(x|X) hh.hhh (p|P) [+|-] dd ], where [h] stands for an\n hexadecimal digit and [d] for a decimal digit.\n\n In both cases, at least one of the integer and fractional parts must be\n given; the exponent part is optional.\n\n The [_] (underscore) character can appear anywhere in the string\n and is ignored.\n\n Depending on the execution platforms, other representations of\n floating-point numbers can be accepted, but should not be relied upon.\n\n Return [None] if the given string is not a valid representation of a float.\n @since 4.05\n*)\n\nexternal float_of_string : string -> float = \"caml_float_of_string\"\n(** Same as {!Stdlib.float_of_string_opt}, but raise\n [Failure \"float_of_string\"] instead of returning [None]. *)\n\n(** {1 Pair operations} *)\n\nexternal fst : 'a * 'b -> 'a = \"%field0\"\n(** Return the first component of a pair. *)\n\nexternal snd : 'a * 'b -> 'b = \"%field1\"\n(** Return the second component of a pair. *)\n\n\n(** {1 List operations}\n\n More list operations are provided in module {!List}.\n*)\n\nval ( @ ) : 'a list -> 'a list -> 'a list\n(** List concatenation. Not tail-recursive (length of the first argument).\n Right-associative operator, see {!Ocaml_operators} for more information.\n*)\n\n(** {1 Input/output}\n Note: all input/output functions can raise [Sys_error] when the system\n calls they invoke fail. *)\n\ntype in_channel\n(** The type of input channel. *)\n\ntype out_channel\n(** The type of output channel. *)\n\nval stdin : in_channel\n(** The standard input for the process. *)\n\nval stdout : out_channel\n(** The standard output for the process. *)\n\nval stderr : out_channel\n(** The standard error output for the process. *)\n\n\n(** {2 Output functions on standard output} *)\n\nval print_char : char -> unit\n(** Print a character on standard output. *)\n\nval print_string : string -> unit\n(** Print a string on standard output. *)\n\nval print_bytes : bytes -> unit\n(** Print a byte sequence on standard output.\n @since 4.02.0 *)\n\nval print_int : int -> unit\n(** Print an integer, in decimal, on standard output. *)\n\nval print_float : float -> unit\n(** Print a floating-point number, in decimal, on standard output. *)\n\nval print_endline : string -> unit\n(** Print a string, followed by a newline character, on\n standard output and flush standard output. *)\n\nval print_newline : unit -> unit\n(** Print a newline character on standard output, and flush\n standard output. This can be used to simulate line\n buffering of standard output. *)\n\n\n(** {2 Output functions on standard error} *)\n\nval prerr_char : char -> unit\n(** Print a character on standard error. *)\n\nval prerr_string : string -> unit\n(** Print a string on standard error. *)\n\nval prerr_bytes : bytes -> unit\n(** Print a byte sequence on standard error.\n @since 4.02.0 *)\n\nval prerr_int : int -> unit\n(** Print an integer, in decimal, on standard error. *)\n\nval prerr_float : float -> unit\n(** Print a floating-point number, in decimal, on standard error. *)\n\nval prerr_endline : string -> unit\n(** Print a string, followed by a newline character on standard\n error and flush standard error. *)\n\nval prerr_newline : unit -> unit\n(** Print a newline character on standard error, and flush\n standard error. *)\n\n\n(** {2 Input functions on standard input} *)\n\nval read_line : unit -> string\n(** Flush standard output, then read characters from standard input\n until a newline character is encountered.\n\n Return the string of all characters read, without the newline character\n at the end.\n\n @raise End_of_file if the end of the file is reached at the beginning of\n line.\n*)\n\nval read_int_opt: unit -> int option\n(** Flush standard output, then read one line from standard input\n and convert it to an integer.\n\n Return [None] if the line read is not a valid representation of an integer.\n @since 4.05\n*)\n\nval read_int : unit -> int\n(** Same as {!Stdlib.read_int_opt}, but raise [Failure \"int_of_string\"]\n instead of returning [None]. *)\n\nval read_float_opt: unit -> float option\n(** Flush standard output, then read one line from standard input\n and convert it to a floating-point number.\n\n Return [None] if the line read is not a valid representation of a\n floating-point number.\n @since 4.05.0\n*)\n\nval read_float : unit -> float\n(** Same as {!Stdlib.read_float_opt}, but raise [Failure \"float_of_string\"]\n instead of returning [None]. *)\n\n\n(** {2 General output functions} *)\n\ntype open_flag =\n Open_rdonly (** open for reading. *)\n | Open_wronly (** open for writing. *)\n | Open_append (** open for appending: always write at end of file. *)\n | Open_creat (** create the file if it does not exist. *)\n | Open_trunc (** empty the file if it already exists. *)\n | Open_excl (** fail if Open_creat and the file already exists. *)\n | Open_binary (** open in binary mode (no conversion). *)\n | Open_text (** open in text mode (may perform conversions). *)\n | Open_nonblock (** open in non-blocking mode. *)\n(** Opening modes for {!Stdlib.open_out_gen} and\n {!Stdlib.open_in_gen}. *)\n\nval open_out : string -> out_channel\n(** Open the named file for writing, and return a new output channel\n on that file, positioned at the beginning of the file. The\n file is truncated to zero length if it already exists. It\n is created if it does not already exists. *)\n\nval open_out_bin : string -> out_channel\n(** Same as {!Stdlib.open_out}, but the file is opened in binary mode,\n so that no translation takes place during writes. On operating\n systems that do not distinguish between text mode and binary\n mode, this function behaves like {!Stdlib.open_out}. *)\n\nval open_out_gen : open_flag list -> int -> string -> out_channel\n(** [open_out_gen mode perm filename] opens the named file for writing,\n as described above. The extra argument [mode]\n specifies the opening mode. The extra argument [perm] specifies\n the file permissions, in case the file must be created.\n {!Stdlib.open_out} and {!Stdlib.open_out_bin} are special\n cases of this function. *)\n\nval flush : out_channel -> unit\n(** Flush the buffer associated with the given output channel,\n performing all pending writes on that channel.\n Interactive programs must be careful about flushing standard\n output and standard error at the right time. *)\n\nval flush_all : unit -> unit\n(** Flush all open output channels; ignore errors. *)\n\nval output_char : out_channel -> char -> unit\n(** Write the character on the given output channel. *)\n\nval output_string : out_channel -> string -> unit\n(** Write the string on the given output channel. *)\n\nval output_bytes : out_channel -> bytes -> unit\n(** Write the byte sequence on the given output channel.\n @since 4.02.0 *)\n\nval output : out_channel -> bytes -> int -> int -> unit\n(** [output oc buf pos len] writes [len] characters from byte sequence [buf],\n starting at offset [pos], to the given output channel [oc].\n @raise Invalid_argument if [pos] and [len] do not\n designate a valid range of [buf]. *)\n\nval output_substring : out_channel -> string -> int -> int -> unit\n(** Same as [output] but take a string as argument instead of\n a byte sequence.\n @since 4.02.0 *)\n\nval output_byte : out_channel -> int -> unit\n(** Write one 8-bit integer (as the single character with that code)\n on the given output channel. The given integer is taken modulo\n 256. *)\n\nval output_binary_int : out_channel -> int -> unit\n(** Write one integer in binary format (4 bytes, big-endian)\n on the given output channel.\n The given integer is taken modulo 2{^32}.\n The only reliable way to read it back is through the\n {!Stdlib.input_binary_int} function. The format is compatible across\n all machines for a given version of OCaml. *)\n\nval output_value : out_channel -> 'a -> unit\n(** Write the representation of a structured value of any type\n to a channel. Circularities and sharing inside the value\n are detected and preserved. The object can be read back,\n by the function {!Stdlib.input_value}. See the description of module\n {!Marshal} for more information. {!Stdlib.output_value} is equivalent\n to {!Marshal.to_channel} with an empty list of flags. *)\n\nval seek_out : out_channel -> int -> unit\n(** [seek_out chan pos] sets the current writing position to [pos]\n for channel [chan]. This works only for regular files. On\n files of other kinds (such as terminals, pipes and sockets),\n the behavior is unspecified. *)\n\nval pos_out : out_channel -> int\n(** Return the current writing position for the given channel. Does\n not work on channels opened with the [Open_append] flag (returns\n unspecified results).\n For files opened in text mode under Windows, the returned position\n is approximate (owing to end-of-line conversion); in particular,\n saving the current position with [pos_out], then going back to\n this position using [seek_out] will not work. For this\n programming idiom to work reliably and portably, the file must be\n opened in binary mode. *)\n\nval out_channel_length : out_channel -> int\n(** Return the size (number of characters) of the regular file\n on which the given channel is opened. If the channel is opened\n on a file that is not a regular file, the result is meaningless. *)\n\nval close_out : out_channel -> unit\n(** Close the given channel, flushing all buffered write operations.\n Output functions raise a [Sys_error] exception when they are\n applied to a closed output channel, except [close_out] and [flush],\n which do nothing when applied to an already closed channel.\n Note that [close_out] may raise [Sys_error] if the operating\n system signals an error when flushing or closing. *)\n\nval close_out_noerr : out_channel -> unit\n(** Same as [close_out], but ignore all errors. *)\n\nval set_binary_mode_out : out_channel -> bool -> unit\n(** [set_binary_mode_out oc true] sets the channel [oc] to binary\n mode: no translations take place during output.\n [set_binary_mode_out oc false] sets the channel [oc] to text\n mode: depending on the operating system, some translations\n may take place during output. For instance, under Windows,\n end-of-lines will be translated from [\\n] to [\\r\\n].\n This function has no effect under operating systems that\n do not distinguish between text mode and binary mode. *)\n\n\n(** {2 General input functions} *)\n\nval open_in : string -> in_channel\n(** Open the named file for reading, and return a new input channel\n on that file, positioned at the beginning of the file. *)\n\nval open_in_bin : string -> in_channel\n(** Same as {!Stdlib.open_in}, but the file is opened in binary mode,\n so that no translation takes place during reads. On operating\n systems that do not distinguish between text mode and binary\n mode, this function behaves like {!Stdlib.open_in}. *)\n\nval open_in_gen : open_flag list -> int -> string -> in_channel\n(** [open_in_gen mode perm filename] opens the named file for reading,\n as described above. The extra arguments\n [mode] and [perm] specify the opening mode and file permissions.\n {!Stdlib.open_in} and {!Stdlib.open_in_bin} are special\n cases of this function. *)\n\nval input_char : in_channel -> char\n(** Read one character from the given input channel.\n @raise End_of_file if there are no more characters to read. *)\n\nval input_line : in_channel -> string\n(** Read characters from the given input channel, until a\n newline character is encountered. Return the string of\n all characters read, without the newline character at the end.\n @raise End_of_file if the end of the file is reached\n at the beginning of line. *)\n\nval input : in_channel -> bytes -> int -> int -> int\n(** [input ic buf pos len] reads up to [len] characters from\n the given channel [ic], storing them in byte sequence [buf], starting at\n character number [pos].\n It returns the actual number of characters read, between 0 and\n [len] (inclusive).\n A return value of 0 means that the end of file was reached.\n A return value between 0 and [len] exclusive means that\n not all requested [len] characters were read, either because\n no more characters were available at that time, or because\n the implementation found it convenient to do a partial read;\n [input] must be called again to read the remaining characters,\n if desired. (See also {!Stdlib.really_input} for reading\n exactly [len] characters.)\n Exception [Invalid_argument \"input\"] is raised if [pos] and [len]\n do not designate a valid range of [buf]. *)\n\nval really_input : in_channel -> bytes -> int -> int -> unit\n(** [really_input ic buf pos len] reads [len] characters from channel [ic],\n storing them in byte sequence [buf], starting at character number [pos].\n @raise End_of_file if the end of file is reached before [len]\n characters have been read.\n @raise Invalid_argument if\n [pos] and [len] do not designate a valid range of [buf]. *)\n\nval really_input_string : in_channel -> int -> string\n(** [really_input_string ic len] reads [len] characters from channel [ic]\n and returns them in a new string.\n @raise End_of_file if the end of file is reached before [len]\n characters have been read.\n @since 4.02.0 *)\n\nval input_byte : in_channel -> int\n(** Same as {!Stdlib.input_char}, but return the 8-bit integer representing\n the character.\n @raise End_of_file if the end of file was reached. *)\n\nval input_binary_int : in_channel -> int\n(** Read an integer encoded in binary format (4 bytes, big-endian)\n from the given input channel. See {!Stdlib.output_binary_int}.\n @raise End_of_file if the end of file was reached while reading the\n integer. *)\n\nval input_value : in_channel -> 'a\n(** Read the representation of a structured value, as produced\n by {!Stdlib.output_value}, and return the corresponding value.\n This function is identical to {!Marshal.from_channel};\n see the description of module {!Marshal} for more information,\n in particular concerning the lack of type safety. *)\n\nval seek_in : in_channel -> int -> unit\n(** [seek_in chan pos] sets the current reading position to [pos]\n for channel [chan]. This works only for regular files. On\n files of other kinds, the behavior is unspecified. *)\n\nval pos_in : in_channel -> int\n(** Return the current reading position for the given channel. For\n files opened in text mode under Windows, the returned position is\n approximate (owing to end-of-line conversion); in particular,\n saving the current position with [pos_in], then going back to this\n position using [seek_in] will not work. For this programming\n idiom to work reliably and portably, the file must be opened in\n binary mode. *)\n\nval in_channel_length : in_channel -> int\n(** Return the size (number of characters) of the regular file\n on which the given channel is opened. If the channel is opened\n on a file that is not a regular file, the result is meaningless.\n The returned size does not take into account the end-of-line\n translations that can be performed when reading from a channel\n opened in text mode. *)\n\nval close_in : in_channel -> unit\n(** Close the given channel. Input functions raise a [Sys_error]\n exception when they are applied to a closed input channel,\n except [close_in], which does nothing when applied to an already\n closed channel. *)\n\nval close_in_noerr : in_channel -> unit\n(** Same as [close_in], but ignore all errors. *)\n\nval set_binary_mode_in : in_channel -> bool -> unit\n(** [set_binary_mode_in ic true] sets the channel [ic] to binary\n mode: no translations take place during input.\n [set_binary_mode_out ic false] sets the channel [ic] to text\n mode: depending on the operating system, some translations\n may take place during input. For instance, under Windows,\n end-of-lines will be translated from [\\r\\n] to [\\n].\n This function has no effect under operating systems that\n do not distinguish between text mode and binary mode. *)\n\n\n(** {2 Operations on large files} *)\n\nmodule LargeFile :\n sig\n val seek_out : out_channel -> int64 -> unit\n val pos_out : out_channel -> int64\n val out_channel_length : out_channel -> int64\n val seek_in : in_channel -> int64 -> unit\n val pos_in : in_channel -> int64\n val in_channel_length : in_channel -> int64\n end\n(** Operations on large files.\n This sub-module provides 64-bit variants of the channel functions\n that manipulate file positions and file sizes. By representing\n positions and sizes by 64-bit integers (type [int64]) instead of\n regular integers (type [int]), these alternate functions allow\n operating on files whose sizes are greater than [max_int]. *)\n\n(** {1 References} *)\n\ntype 'a ref = { mutable contents : 'a }\n(** The type of references (mutable indirection cells) containing\n a value of type ['a]. *)\n\nexternal ref : 'a -> 'a ref = \"%makemutable\"\n(** Return a fresh reference containing the given value. *)\n\nexternal ( ! ) : 'a ref -> 'a = \"%field0\"\n(** [!r] returns the current contents of reference [r].\n Equivalent to [fun r -> r.contents].\n Unary operator, see {!Ocaml_operators} for more information.\n*)\n\nexternal ( := ) : 'a ref -> 'a -> unit = \"%setfield0\"\n(** [r := a] stores the value of [a] in reference [r].\n Equivalent to [fun r v -> r.contents <- v].\n Right-associative operator, see {!Ocaml_operators} for more information.\n*)\n\nexternal incr : int ref -> unit = \"%incr\"\n(** Increment the integer contained in the given reference.\n Equivalent to [fun r -> r := succ !r]. *)\n\nexternal decr : int ref -> unit = \"%decr\"\n(** Decrement the integer contained in the given reference.\n Equivalent to [fun r -> r := pred !r]. *)\n\n(** {1 Result type} *)\n\n(** @since 4.03.0 *)\ntype ('a,'b) result = Ok of 'a | Error of 'b\n\n(** {1 Operations on format strings} *)\n\n(** Format strings are character strings with special lexical conventions\n that defines the functionality of formatted input/output functions. Format\n strings are used to read data with formatted input functions from module\n {!Scanf} and to print data with formatted output functions from modules\n {!Printf} and {!Format}.\n\n Format strings are made of three kinds of entities:\n - {e conversions specifications}, introduced by the special character ['%']\n followed by one or more characters specifying what kind of argument to\n read or print,\n - {e formatting indications}, introduced by the special character ['@']\n followed by one or more characters specifying how to read or print the\n argument,\n - {e plain characters} that are regular characters with usual lexical\n conventions. Plain characters specify string literals to be read in the\n input or printed in the output.\n\n There is an additional lexical rule to escape the special characters ['%']\n and ['@'] in format strings: if a special character follows a ['%']\n character, it is treated as a plain character. In other words, [\"%%\"] is\n considered as a plain ['%'] and [\"%@\"] as a plain ['@'].\n\n For more information about conversion specifications and formatting\n indications available, read the documentation of modules {!Scanf},\n {!Printf} and {!Format}.\n*)\n\n(** Format strings have a general and highly polymorphic type\n [('a, 'b, 'c, 'd, 'e, 'f) format6].\n The two simplified types, [format] and [format4] below are\n included for backward compatibility with earlier releases of\n OCaml.\n\n The meaning of format string type parameters is as follows:\n\n - ['a] is the type of the parameters of the format for formatted output\n functions ([printf]-style functions);\n ['a] is the type of the values read by the format for formatted input\n functions ([scanf]-style functions).\n\n - ['b] is the type of input source for formatted input functions and the\n type of output target for formatted output functions.\n For [printf]-style functions from module {!Printf}, ['b] is typically\n [out_channel];\n for [printf]-style functions from module {!Format}, ['b] is typically\n {!type:Format.formatter};\n for [scanf]-style functions from module {!Scanf}, ['b] is typically\n {!Scanf.Scanning.in_channel}.\n\n Type argument ['b] is also the type of the first argument given to\n user's defined printing functions for [%a] and [%t] conversions,\n and user's defined reading functions for [%r] conversion.\n\n - ['c] is the type of the result of the [%a] and [%t] printing\n functions, and also the type of the argument transmitted to the\n first argument of [kprintf]-style functions or to the\n [kscanf]-style functions.\n\n - ['d] is the type of parameters for the [scanf]-style functions.\n\n - ['e] is the type of the receiver function for the [scanf]-style functions.\n\n - ['f] is the final result type of a formatted input/output function\n invocation: for the [printf]-style functions, it is typically [unit];\n for the [scanf]-style functions, it is typically the result type of the\n receiver function.\n*)\n\ntype ('a, 'b, 'c, 'd, 'e, 'f) format6 =\n ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.format6\n\ntype ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'c, 'c, 'd) format6\n\ntype ('a, 'b, 'c) format = ('a, 'b, 'c, 'c) format4\n\nval string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string\n(** Converts a format string into a string. *)\n\nexternal format_of_string :\n ('a, 'b, 'c, 'd, 'e, 'f) format6 ->\n ('a, 'b, 'c, 'd, 'e, 'f) format6 = \"%identity\"\n(** [format_of_string s] returns a format string read from the string\n literal [s].\n Note: [format_of_string] can not convert a string argument that is not a\n literal. If you need this functionality, use the more general\n {!Scanf.format_from_string} function.\n*)\n\nval ( ^^ ) :\n ('a, 'b, 'c, 'd, 'e, 'f) format6 ->\n ('f, 'b, 'c, 'e, 'g, 'h) format6 ->\n ('a, 'b, 'c, 'd, 'g, 'h) format6\n(** [f1 ^^ f2] catenates format strings [f1] and [f2]. The result is a\n format string that behaves as the concatenation of format strings [f1] and\n [f2]: in case of formatted output, it accepts arguments from [f1], then\n arguments from [f2]; in case of formatted input, it returns results from\n [f1], then results from [f2].\n Right-associative operator, see {!Ocaml_operators} for more information.\n*)\n\n(** {1 Program termination} *)\n\nval exit : int -> 'a\n(** Terminate the process, returning the given status code\n to the operating system: usually 0 to indicate no errors,\n and a small positive integer to indicate failure.\n All open output channels are flushed with [flush_all].\n An implicit [exit 0] is performed each time a program\n terminates normally. An implicit [exit 2] is performed if the program\n terminates early because of an uncaught exception. *)\n\nval at_exit : (unit -> unit) -> unit\n(** Register the given function to be called at program termination\n time. The functions registered with [at_exit] will be called when\n the program does any of the following:\n - executes {!Stdlib.exit}\n - terminates, either normally or because of an uncaught\n exception\n - executes the C function [caml_shutdown].\n The functions are called in 'last in, first out' order: the\n function most recently added with [at_exit] is called first. *)\n\n(**/**)\n\n(* The following is for system use only. Do not call directly. *)\n\nval valid_float_lexem : string -> string\n\nval unsafe_really_input : in_channel -> bytes -> int -> int -> unit\n\nval do_at_exit : unit -> unit\n\n(**/**)\n\n(** {1:modules Standard library modules } *)\n\n(*MODULE_ALIASES*)\nmodule Arg = Arg\nmodule Array = Array\nmodule ArrayLabels = ArrayLabels\nmodule Atomic = Atomic\nmodule Bigarray = Bigarray\nmodule Bool = Bool\nmodule Buffer = Buffer\nmodule Bytes = Bytes\nmodule BytesLabels = BytesLabels\nmodule Callback = Callback\nmodule Char = Char\nmodule Complex = Complex\nmodule Digest = Digest\nmodule Either = Either\nmodule Ephemeron = Ephemeron\nmodule Filename = Filename\nmodule Float = Float\nmodule Format = Format\nmodule Fun = Fun\nmodule Gc = Gc\nmodule Genlex = Genlex\n[@@deprecated \"Use the camlp-streams library instead.\"]\nmodule Hashtbl = Hashtbl\nmodule In_channel = In_channel\nmodule Int = Int\nmodule Int32 = Int32\nmodule Int64 = Int64\nmodule Lazy = Lazy\nmodule Lexing = Lexing\nmodule List = List\nmodule ListLabels = ListLabels\nmodule Map = Map\nmodule Marshal = Marshal\nmodule MoreLabels = MoreLabels\nmodule Nativeint = Nativeint\nmodule Obj = Obj\nmodule Oo = Oo\nmodule Option = Option\nmodule Out_channel = Out_channel\nmodule Parsing = Parsing\nmodule Pervasives = Pervasives\n[@@deprecated \"Use Stdlib instead.\\n\\\n\\n\\\nIf you need to stay compatible with OCaml < 4.07, you can use the \\n\\\nstdlib-shims library: https://github.com/ocaml/stdlib-shims\"]\nmodule Printexc = Printexc\nmodule Printf = Printf\nmodule Queue = Queue\nmodule Random = Random\nmodule Result = Result\nmodule Scanf = Scanf\nmodule Seq = Seq\nmodule Set = Set\nmodule Stack = Stack\nmodule StdLabels = StdLabels\nmodule Stream = Stream\n[@@deprecated \"Use the camlp-streams library instead.\"]\nmodule String = String\nmodule StringLabels = StringLabels\nmodule Sys = Sys\nmodule Uchar = Uchar\nmodule Unit = Unit\nmodule Weak = Weak\n","(** An interface to use for int-like types, e.g., {{!Base.Int}[Int]} and\n {{!Base.Int64}[Int64]}. *)\n\nopen! Import\n\nmodule type Round = sig\n type t\n\n (** [round] rounds an int to a multiple of a given [to_multiple_of] argument, according\n to a direction [dir], with default [dir] being [`Nearest]. [round] will raise if\n [to_multiple_of <= 0]. If the result overflows (too far positive or too far\n negative), [round] returns an incorrect result.\n\n {v\n | `Down | rounds toward Int.neg_infinity |\n | `Up | rounds toward Int.infinity |\n | `Nearest | rounds to the nearest multiple, or `Up in case of a tie |\n | `Zero | rounds toward zero |\n v}\n\n Here are some examples for [round ~to_multiple_of:10] for each direction:\n\n {v\n | `Down | {10 .. 19} --> 10 | { 0 ... 9} --> 0 | {-10 ... -1} --> -10 |\n | `Up | { 1 .. 10} --> 10 | {-9 ... 0} --> 0 | {-19 .. -10} --> -10 |\n | `Zero | {10 .. 19} --> 10 | {-9 ... 9} --> 0 | {-19 .. -10} --> -10 |\n | `Nearest | { 5 .. 14} --> 10 | {-5 ... 4} --> 0 | {-15 ... -6} --> -10 |\n v}\n\n For convenience and performance, there are variants of [round] with [dir]\n hard-coded. If you are writing performance-critical code you should use these. *)\n\n val round : ?dir:[ `Zero | `Nearest | `Up | `Down ] -> t -> to_multiple_of:t -> t\n val round_towards_zero : t -> to_multiple_of:t -> t\n val round_down : t -> to_multiple_of:t -> t\n val round_up : t -> to_multiple_of:t -> t\n val round_nearest : t -> to_multiple_of:t -> t\nend\n\nmodule type Hexable = sig\n type t\n\n module Hex : sig\n type nonrec t = t [@@deriving_inline sexp, compare, hash]\n\n include Ppx_sexp_conv_lib.Sexpable.S with type t := t\n\n val compare : t -> t -> int\n val hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state\n val hash : t -> Ppx_hash_lib.Std.Hash.hash_value\n\n [@@@end]\n\n include Stringable.S with type t := t\n\n val to_string_hum : ?delimiter:char -> t -> string\n end\nend\n\nmodule type S_common = sig\n type t [@@deriving_inline sexp, sexp_grammar]\n\n include Ppx_sexp_conv_lib.Sexpable.S with type t := t\n\n val t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t\n\n [@@@end]\n\n include Floatable.S with type t := t\n include Intable.S with type t := t\n include Identifiable.S with type t := t\n include Comparable.With_zero with type t := t\n include Invariant.S with type t := t\n include Hexable with type t := t\n\n (** [delimiter] is an underscore by default. *)\n val to_string_hum : ?delimiter:char -> t -> string\n\n (** {2 Infix operators and constants} *)\n\n val zero : t\n val one : t\n val minus_one : t\n val ( + ) : t -> t -> t\n val ( - ) : t -> t -> t\n val ( * ) : t -> t -> t\n\n (** Integer exponentiation *)\n val ( ** ) : t -> t -> t\n\n (** Negation *)\n\n val neg : t -> t\n val ( ~- ) : t -> t\n\n (** There are two pairs of integer division and remainder functions, [/%] and [%], and\n [/] and [rem]. They both satisfy the same equation relating the quotient and the\n remainder:\n\n {[\n x = (x /% y) * y + (x % y);\n x = (x / y) * y + (rem x y);\n ]}\n\n The functions return the same values if [x] and [y] are positive. They all raise\n if [y = 0].\n\n The functions differ if [x < 0] or [y < 0].\n\n If [y < 0], then [%] and [/%] raise, whereas [/] and [rem] do not.\n\n [x % y] always returns a value between 0 and [y - 1], even when [x < 0]. On the\n other hand, [rem x y] returns a negative value if and only if [x < 0]; that value\n satisfies [abs (rem x y) <= abs y - 1]. *)\n\n val ( /% ) : t -> t -> t\n val ( % ) : t -> t -> t\n val ( / ) : t -> t -> t\n val rem : t -> t -> t\n\n (** Float division of integers. *)\n val ( // ) : t -> t -> float\n\n (** Same as [bit_and]. *)\n val ( land ) : t -> t -> t\n\n (** Same as [bit_or]. *)\n val ( lor ) : t -> t -> t\n\n (** Same as [bit_xor]. *)\n val ( lxor ) : t -> t -> t\n\n (** Same as [bit_not]. *)\n val lnot : t -> t\n\n (** Same as [shift_left]. *)\n val ( lsl ) : t -> int -> t\n\n (** Same as [shift_right]. *)\n val ( asr ) : t -> int -> t\n\n (** {2 Other common functions} *)\n\n include Round with type t := t\n\n (** Returns the absolute value of the argument. May be negative if the input is\n [min_value]. *)\n val abs : t -> t\n\n (** {2 Successor and predecessor functions} *)\n\n val succ : t -> t\n val pred : t -> t\n\n (** {2 Exponentiation} *)\n\n (** [pow base exponent] returns [base] raised to the power of [exponent]. It is OK if\n [base <= 0]. [pow] raises if [exponent < 0], or an integer overflow would occur. *)\n val pow : t -> t -> t\n\n (** {2 Bit-wise logical operations } *)\n\n (** These are identical to [land], [lor], etc. except they're not infix and have\n different names. *)\n val bit_and : t -> t -> t\n\n val bit_or : t -> t -> t\n val bit_xor : t -> t -> t\n val bit_not : t -> t\n\n (** Returns the number of 1 bits in the binary representation of the input. *)\n val popcount : t -> int\n\n (** {2 Bit-shifting operations }\n\n The results are unspecified for negative shifts and shifts [>= num_bits]. *)\n\n (** Shifts left, filling in with zeroes. *)\n val shift_left : t -> int -> t\n\n (** Shifts right, preserving the sign of the input. *)\n val shift_right : t -> int -> t\n\n (** {2 Increment and decrement functions for integer references } *)\n\n val decr : t ref -> unit\n val incr : t ref -> unit\n\n (** {2 Conversion functions to related integer types} *)\n\n val of_int32_exn : int32 -> t\n val to_int32_exn : t -> int32\n val of_int64_exn : int64 -> t\n val to_int64 : t -> int64\n val of_nativeint_exn : nativeint -> t\n val to_nativeint_exn : t -> nativeint\n\n (** [of_float_unchecked] truncates the given floating point number to an integer,\n rounding towards zero.\n The result is unspecified if the argument is nan or falls outside the range\n of representable integers. *)\n val of_float_unchecked : float -> t\nend\n\nmodule type Operators_unbounded = sig\n type t\n\n val ( + ) : t -> t -> t\n val ( - ) : t -> t -> t\n val ( * ) : t -> t -> t\n val ( / ) : t -> t -> t\n val ( ~- ) : t -> t\n val ( ** ) : t -> t -> t\n\n include Comparisons.Infix with type t := t\n\n val abs : t -> t\n val neg : t -> t\n val zero : t\n val ( % ) : t -> t -> t\n val ( /% ) : t -> t -> t\n val ( // ) : t -> t -> float\n val ( land ) : t -> t -> t\n val ( lor ) : t -> t -> t\n val ( lxor ) : t -> t -> t\n val lnot : t -> t\n val ( lsl ) : t -> int -> t\n val ( asr ) : t -> int -> t\nend\n\nmodule type Operators = sig\n include Operators_unbounded\n\n val ( lsr ) : t -> int -> t\nend\n\n(** [S_unbounded] is a generic interface for unbounded integers, e.g. [Bignum.Bigint].\n [S_unbounded] is a restriction of [S] (below) that omits values that depend on\n fixed-size integers. *)\nmodule type S_unbounded = sig\n include S_common (** @inline *)\n\n (** A sub-module designed to be opened to make working with ints more convenient. *)\n module O : Operators_unbounded with type t := t\nend\n\n(** [S] is a generic interface for fixed-size integers. *)\nmodule type S = sig\n include S_common (** @inline *)\n\n (** The number of bits available in this integer type. Note that the integer\n representations are signed. *)\n val num_bits : int\n\n (** The largest representable integer. *)\n val max_value : t\n\n (** The smallest representable integer. *)\n val min_value : t\n\n (** Same as [shift_right_logical]. *)\n val ( lsr ) : t -> int -> t\n\n (** Shifts right, filling in with zeroes, which will not preserve the sign of the\n input. *)\n val shift_right_logical : t -> int -> t\n\n (** [ceil_pow2 x] returns the smallest power of 2 that is greater than or equal to [x].\n The implementation may only be called for [x > 0]. Example: [ceil_pow2 17 = 32] *)\n val ceil_pow2 : t -> t\n\n (** [floor_pow2 x] returns the largest power of 2 that is less than or equal to [x]. The\n implementation may only be called for [x > 0]. Example: [floor_pow2 17 = 16] *)\n val floor_pow2 : t -> t\n\n (** [ceil_log2 x] returns the ceiling of log-base-2 of [x], and raises if [x <= 0]. *)\n val ceil_log2 : t -> int\n\n (** [floor_log2 x] returns the floor of log-base-2 of [x], and raises if [x <= 0]. *)\n val floor_log2 : t -> int\n\n (** [is_pow2 x] returns true iff [x] is a power of 2. [is_pow2] raises if [x <= 0]. *)\n val is_pow2 : t -> bool\n\n (** Returns the number of leading zeros in the binary representation of the input, as an\n integer between 0 and one less than [num_bits].\n\n The results are unspecified for [t = 0]. *)\n val clz : t -> int\n\n (** Returns the number of trailing zeros in the binary representation of the input, as\n an integer between 0 and one less than [num_bits].\n\n The results are unspecified for [t = 0]. *)\n val ctz : t -> int\n\n (** A sub-module designed to be opened to make working with ints more convenient. *)\n module O : Operators with type t := t\nend\n\ninclude (\nstruct\n (** Various functors whose type-correctness ensures desired relationships between\n interfaces. *)\n\n module Check_O_contained_in_S (M : S) : module type of M.O = M\n module Check_O_contained_in_S_unbounded (M : S_unbounded) : module type of M.O = M\n module Check_S_unbounded_in_S (M : S) : S_unbounded = M\nend :\nsig end)\n\nmodule type Int_without_module_types = sig\n include S with type t = int\n\n (** [max_value_30_bits = 2^30 - 1]. It is useful for writing tests that work on both\n 64-bit and 32-bit platforms. *)\n val max_value_30_bits : t\n\n (** {2 Conversion functions} *)\n\n val of_int : int -> t\n val to_int : t -> int\n val of_int32 : int32 -> t option\n val to_int32 : t -> int32 option\n val of_int64 : int64 -> t option\n val of_nativeint : nativeint -> t option\n val to_nativeint : t -> nativeint\n\n (** {3 Truncating conversions}\n\n These functions return the least-significant bits of the input. In cases\n where optional conversions return [Some x], truncating conversions return [x]. *)\n\n val of_int32_trunc : int32 -> t\n val to_int32_trunc : t -> int32\n val of_int64_trunc : int64 -> t\n val of_nativeint_trunc : nativeint -> t\n\n (** {2 Byte swap operations}\n\n Byte swap operations reverse the order of bytes in an integer. For\n example, {!Int32.bswap32} reorders the bottom 32 bits (or 4 bytes),\n turning [0x1122_3344] to [0x4433_2211]. Byte swap functions exposed by\n Base use OCaml primitives to generate assembly instructions to perform\n the relevant byte swaps.\n\n For a more extensive list of byteswap functions, see {!Int32} and\n {!Int64}.\n *)\n\n (** Byte swaps bottom 16 bits (2 bytes). The values of the remaining bytes\n are undefined. *)\n val bswap16 : t -> t\n\n (**/**)\n\n (*_ See the Jane Street Style Guide for an explanation of [Private] submodules:\n\n https://opensource.janestreet.com/standards/#private-submodules *)\n module Private : sig\n (*_ For ../bench/bench_int.ml *)\n module O_F : sig\n val ( % ) : int -> int -> int\n val ( /% ) : int -> int -> int\n val ( // ) : int -> int -> float\n end\n end\nend\n\n(** OCaml's native integer type.\n\n The number of bits in an integer is platform dependent, being 31-bits on a 32-bit\n platform, and 63-bits on a 64-bit platform. [int] is a signed integer type. [int]s\n are also subject to overflow, meaning that [Int.max_value + 1 = Int.min_value].\n\n [int]s always fit in a machine word. *)\nmodule type Int = sig\n include Int_without_module_types\n\n (** {2 Module types specifying integer operations.} *)\n module type Hexable = Hexable\n\n module type Int_without_module_types = Int_without_module_types\n module type Operators = Operators\n module type Operators_unbounded = Operators_unbounded\n module type Round = Round\n module type S = S\n module type S_common = S_common\n module type S_unbounded = S_unbounded\nend\n","open! Import\n\n(* Open replace_polymorphic_compare after including functor instantiations so they do not\n shadow its definitions. This is here so that efficient versions of the comparison\n functions are available within this module. *)\nopen! Float_replace_polymorphic_compare\n\nlet ceil = Caml.ceil\nlet floor = Caml.floor\nlet mod_float = Caml.mod_float\nlet modf = Caml.modf\nlet float_of_string = Caml.float_of_string\nlet nan = Caml.nan\nlet infinity = Caml.infinity\nlet neg_infinity = Caml.neg_infinity\nlet max_finite_value = Caml.max_float\nlet epsilon_float = Caml.epsilon_float\nlet classify_float = Caml.classify_float\nlet abs_float = Caml.abs_float\nlet ( ** ) = Caml.( ** )\n\n(* The bits of INRIA's [Pervasives] that we just want to expose in [Float]. Most are\n already deprecated in [Pervasives], and eventually all of them should be. *)\ninclude (\n Caml :\n sig\n external frexp : float -> float * int = \"caml_frexp_float\"\n\n external ldexp\n : (float[@unboxed])\n -> (int[@untagged])\n -> (float[@unboxed])\n = \"caml_ldexp_float\" \"caml_ldexp_float_unboxed\"\n [@@noalloc]\n\n external log10 : float -> float = \"caml_log10_float\" \"log10\"\n [@@unboxed] [@@noalloc]\n\n external expm1 : float -> float = \"caml_expm1_float\" \"caml_expm1\"\n [@@unboxed] [@@noalloc]\n\n external log1p : float -> float = \"caml_log1p_float\" \"caml_log1p\"\n [@@unboxed] [@@noalloc]\n\n external copysign : float -> float -> float = \"caml_copysign_float\" \"caml_copysign\"\n [@@unboxed] [@@noalloc]\n\n external cos : float -> float = \"caml_cos_float\" \"cos\" [@@unboxed] [@@noalloc]\n external sin : float -> float = \"caml_sin_float\" \"sin\" [@@unboxed] [@@noalloc]\n external tan : float -> float = \"caml_tan_float\" \"tan\" [@@unboxed] [@@noalloc]\n external acos : float -> float = \"caml_acos_float\" \"acos\" [@@unboxed] [@@noalloc]\n external asin : float -> float = \"caml_asin_float\" \"asin\" [@@unboxed] [@@noalloc]\n external atan : float -> float = \"caml_atan_float\" \"atan\" [@@unboxed] [@@noalloc]\n\n external atan2 : float -> float -> float = \"caml_atan2_float\" \"atan2\"\n [@@unboxed] [@@noalloc]\n\n external hypot : float -> float -> float = \"caml_hypot_float\" \"caml_hypot\"\n [@@unboxed] [@@noalloc]\n\n external cosh : float -> float = \"caml_cosh_float\" \"cosh\" [@@unboxed] [@@noalloc]\n external sinh : float -> float = \"caml_sinh_float\" \"sinh\" [@@unboxed] [@@noalloc]\n external tanh : float -> float = \"caml_tanh_float\" \"tanh\" [@@unboxed] [@@noalloc]\n external sqrt : float -> float = \"caml_sqrt_float\" \"sqrt\" [@@unboxed] [@@noalloc]\n external exp : float -> float = \"caml_exp_float\" \"exp\" [@@unboxed] [@@noalloc]\n external log : float -> float = \"caml_log_float\" \"log\" [@@unboxed] [@@noalloc]\n end)\n\n(* We need this indirection because these are exposed as \"val\" instead of \"external\" *)\nlet frexp = frexp\nlet ldexp = ldexp\nlet is_nan x = (x : float) <> x\n\n(* An order-preserving bijection between all floats except for NaNs, and 99.95% of\n int64s.\n\n Note we don't distinguish 0. and -0. as separate values here, they both map to 0L, which\n maps back to 0.\n\n This should work both on little-endian and high-endian CPUs. Wikipedia says: \"on\n modern standard computers (i.e., implementing IEEE 754), one may in practice safely\n assume that the endianness is the same for floating point numbers as for integers\"\n (http://en.wikipedia.org/wiki/Endianness#Floating-point_and_endianness).\n*)\nlet to_int64_preserve_order t =\n if is_nan t\n then None\n else if t = 0.\n then (* also includes -0. *)\n Some 0L\n else if t > 0.\n then Some (Caml.Int64.bits_of_float t)\n else Some (Caml.Int64.neg (Caml.Int64.bits_of_float (-.t)))\n;;\n\nlet to_int64_preserve_order_exn x = Option.value_exn (to_int64_preserve_order x)\n\nlet of_int64_preserve_order x =\n if Int64_replace_polymorphic_compare.( >= ) x 0L\n then Caml.Int64.float_of_bits x\n else ~-.(Caml.Int64.float_of_bits (Caml.Int64.neg x))\n;;\n\nlet one_ulp dir t =\n match to_int64_preserve_order t with\n | None -> Caml.nan\n | Some x ->\n of_int64_preserve_order\n (Caml.Int64.add\n x\n (match dir with\n | `Up -> 1L\n | `Down -> -1L))\n;;\n\n(* [upper_bound_for_int] and [lower_bound_for_int] are for calculating the max/min float\n that fits in a given-size integer when rounded towards 0 (using [int_of_float]).\n\n max_int/min_int depend on [num_bits], e.g. +/- 2^30, +/- 2^62 if 31-bit, 63-bit\n (respectively) while float is IEEE standard for double (52 significant bits).\n\n In all cases, we want to guarantee that\n [lower_bound_for_int <= x <= upper_bound_for_int]\n iff [int_of_float x] fits in an int with [num_bits] bits.\n\n [2 ** (num_bits - 1)] is the first float greater that max_int, we use the preceding\n float as upper bound.\n\n [- (2 ** (num_bits - 1))] is equal to min_int.\n For lower bound we look for the smallest float [f] satisfying [f > min_int - 1] so that\n [f] rounds toward zero to [min_int]\n\n So in particular we will have:\n [lower_bound_for_int x <= - (2 ** (1-x))]\n [upper_bound_for_int x < 2 ** (1-x) ]\n*)\nlet upper_bound_for_int num_bits =\n let exp = Caml.float_of_int (num_bits - 1) in\n one_ulp `Down (2. ** exp)\n;;\n\nlet is_x_minus_one_exact x =\n (* [x = x -. 1.] does not work with x87 floating point arithmetic backend (which is used\n on 32-bit ocaml) because of 80-bit register precision of intermediate computations.\n\n An alternative way of computing this: [x -. one_ulp `Down x <= 1.] is also prone to\n the same precision issues: you need to make sure [x] is 64-bit.\n *)\n let open Int64_replace_polymorphic_compare in\n not (Caml.Int64.bits_of_float x = Caml.Int64.bits_of_float (x -. 1.))\n;;\n\nlet lower_bound_for_int num_bits =\n let exp = Caml.float_of_int (num_bits - 1) in\n let min_int_as_float = ~-.(2. ** exp) in\n let open Int_replace_polymorphic_compare in\n if num_bits - 1 < 53 (* 53 = #bits in the float's mantissa with sign included *)\n then (\n (* The smallest float that rounds towards zero to [min_int] is\n [min_int - 1 + epsilon] *)\n assert (is_x_minus_one_exact min_int_as_float);\n one_ulp `Up (min_int_as_float -. 1.))\n else (\n (* [min_int_as_float] is already the smallest float [f] satisfying [f > min_int - 1]. *)\n assert (not (is_x_minus_one_exact min_int_as_float));\n min_int_as_float)\n;;\n\n(* Float clamping is structured slightly differently than clamping for other types, so\n that we get the behavior of [clamp_unchecked nan ~min ~max = nan] (for any [min] and\n [max]) for free.\n*)\nlet clamp_unchecked (t : float) ~min ~max =\n if t < min then min else if max < t then max else t\n;;\n\nlet box =\n (* Prevent potential constant folding of [+. 0.] in the near ocamlopt future. *)\n let x = Sys0.opaque_identity 0. in\n fun f -> f +. x\n;;\n\n(* Include type-specific [Replace_polymorphic_compare] at the end, after\n including functor application that could shadow its definitions. This is\n here so that efficient versions of the comparison functions are exported by\n this module. *)\ninclude Float_replace_polymorphic_compare\n","open Core_kernel\nopen Import\nopen Deferred_std\nmodule Stream = Async_stream\n\nlet show_debug_messages = ref false\nlet check_invariant = ref false\n\nmodule Flushed_result = struct\n type t =\n [ `Ok\n | `Reader_closed\n ]\n [@@deriving compare, sexp_of]\n\n let equal = [%compare.equal: t]\n\n let combine (l : t Deferred.t list) =\n let%map l = Deferred.all l in\n match List.mem l `Reader_closed ~equal with\n | true -> `Reader_closed\n | false -> `Ok\n ;;\nend\n\n(* A [Consumer.t] acts as the monitor of some process that reads values from a pipe and\n processes them, allowing that process:\n - to communicate that it has taken responsibility for the values\n - to signal when it has finished with the values to interested parties (via\n [downstream_flushed])\n\n It is used in two steps:\n\n 1. calling [Consumer.start] at the point where the consumer takes values out of the\n Pipe via [read] or [read'].\n\n 2. calling [Consumer.values_sent_downstream].\n\n By calling [values_sent_downstream] one asserts that the [downstream_flushed] function\n supplied to [create] will now wait for this value.\n\n If no [Consumer.t] is supplied when a value is read then the value is defined to be\n flushed at that time. *)\nmodule Consumer : sig\n type t [@@deriving sexp_of]\n\n include Invariant.S with type t := t\n\n val create\n : pipe_id:int\n -> downstream_flushed:(unit -> Flushed_result.t Deferred.t)\n -> t\n\n val pipe_id : t -> int\n val start : t -> unit\n val values_sent_downstream : t -> unit\n val values_sent_downstream_and_flushed : t -> Flushed_result.t Deferred.t\nend = struct\n type t =\n { pipe_id : int\n ; (* [values_read] reflects whether values the consumer has read from the pipe have been\n sent downstream or if not, holds an ivar that is to be filled when they are. *)\n mutable values_read :\n [ `Have_been_sent_downstream | `Have_not_been_sent_downstream of unit Ivar.t ]\n ; (* [downstream_flushed ()] returns when all prior values that the consumer has\n passed downstream have been flushed all the way down the chain of pipes. *)\n downstream_flushed : unit -> Flushed_result.t Deferred.t\n }\n [@@deriving fields, sexp_of]\n\n let invariant t : unit =\n try\n let check f field = f (Field.get field t) in\n Fields.iter\n ~pipe_id:ignore\n ~values_read:\n (check (function\n | `Have_been_sent_downstream -> ()\n | `Have_not_been_sent_downstream ivar -> assert (Ivar.is_empty ivar)))\n ~downstream_flushed:ignore\n with\n | exn ->\n raise_s [%message \"Pipe.Consumer.invariant failed\" (exn : exn) ~pipe:(t : t)]\n ;;\n\n let create ~pipe_id ~downstream_flushed =\n { pipe_id; values_read = `Have_been_sent_downstream; downstream_flushed }\n ;;\n\n let start t =\n match t.values_read with\n | `Have_not_been_sent_downstream _ -> ()\n | `Have_been_sent_downstream ->\n t.values_read <- `Have_not_been_sent_downstream (Ivar.create ())\n ;;\n\n let values_sent_downstream t =\n match t.values_read with\n | `Have_been_sent_downstream -> ()\n | `Have_not_been_sent_downstream ivar ->\n Ivar.fill ivar ();\n t.values_read <- `Have_been_sent_downstream\n ;;\n\n let values_sent_downstream_and_flushed t =\n match t.values_read with\n | `Have_been_sent_downstream -> t.downstream_flushed ()\n | `Have_not_been_sent_downstream when_sent_downstream ->\n let%bind () = Ivar.read when_sent_downstream in\n t.downstream_flushed ()\n ;;\nend\n\nmodule Blocked_read = struct\n (* A [Blocked_read.t] represents a blocked read attempt. If someone reads from an empty\n pipe, they enqueue a [Blocked_read.t] in the queue of [blocked_reads]. Later, when\n values are written to a pipe, that will cause some number of blocked reads to be\n filled, first come first serve. The blocked-read constructor specifies how many\n values a read should consume from the pipe when it gets its turn.\n\n If a pipe is closed, then all blocked reads will be filled with [`Eof]. *)\n type 'a wants =\n | Zero of [ `Eof | `Ok ] Ivar.t\n | One of [ `Eof | `Ok of 'a ] Ivar.t\n | At_most of int * [ `Eof | `Ok of 'a Queue.t ] Ivar.t\n [@@deriving sexp_of]\n\n type 'a t =\n { wants : 'a wants\n ; consumer : Consumer.t option\n }\n [@@deriving fields, sexp_of]\n\n let invariant t : unit =\n try\n let check f field = f (Field.get field t) in\n Fields.iter\n ~wants:\n (check (function\n | Zero _ | One _ -> ()\n | At_most (i, _) -> assert (i > 0)))\n ~consumer:\n (check (function\n | None -> ()\n | Some consumer -> Consumer.invariant consumer))\n with\n | exn ->\n raise_s [%message \"Pipe.Blocked_read.invariant failed\" (exn : exn) ~pipe:(t : _ t)]\n ;;\n\n let create wants consumer = { wants; consumer }\n\n let is_empty t =\n match t.wants with\n | Zero i -> Ivar.is_empty i\n | One i -> Ivar.is_empty i\n | At_most (_, i) -> Ivar.is_empty i\n ;;\n\n let fill_with_eof t =\n match t.wants with\n | Zero i -> Ivar.fill i `Eof\n | One i -> Ivar.fill i `Eof\n | At_most (_, i) -> Ivar.fill i `Eof\n ;;\nend\n\nmodule Blocked_flush = struct\n (* A [Blocked_flush.t] represents a blocked flush operation, which can be enabled by a\n future read. If someone does [flushed p] on a pipe, that blocks until everything\n that's currently in the pipe at that point has drained out of the pipe. When we call\n [flushed], it records the total amount of data that has been written so far in\n [fill_when_num_values_read]. We fill the [Flush.t] with [`Ok] when this amount of\n data has been read from the pipe.\n\n A [Blocked_flush.t] can also be filled with [`Reader_closed], which happens when the\n reader end of the pipe is closed, and we are thus sure that the unread elements\n preceding the flush will never be read. *)\n type t =\n { fill_when_num_values_read : int\n ; ready : [ `Ok | `Reader_closed ] Ivar.t\n }\n [@@deriving fields, sexp_of]\n\n let fill t v = Ivar.fill t.ready v\nend\n\ntype ('a, 'phantom) t =\n { (* [id] is an integer used to distinguish pipes when debugging. *)\n id : int Sexp_hidden_in_test.t\n ; (* [info] is user-provided arbitrary sexp, for debugging purposes. *)\n mutable info : Sexp.t option [@sexp.option]\n ; (* [buffer] holds values written to the pipe that have not yet been read. *)\n mutable buffer : 'a Queue.t\n ; (* [size_budget] governs pushback on writers to the pipe.\n\n There is *no* invariant that [Queue.length buffer <= size_budget]. There is no\n hard upper bound on the number of elements that can be stuffed into the [buffer].\n This is due to the way we handle writes. When we do a write, all of the values\n written are immediately enqueued into [buffer]. After the write, if [Queue.length\n buffer <= t.size_budget], then the writer will be notified to continue writing.\n After the write, if [length t > t.size_budget], then the write will block until the\n pipe is under budget. *)\n mutable size_budget : int\n ; (* [pushback] is used to give feedback to writers about whether they should write to\n the pipe. [pushback] is full iff [length t <= t.size_budget || is_closed t]. *)\n mutable pushback : unit Ivar.t\n ; (* [num_values_read] keeps track of the total number of values that have been read\n from the pipe. We do not have to worry about overflow in [num_values_read]. You'd\n need to write 2^62 elements to the pipe, which would take about 146 years, at a\n flow rate of 1 size-unit/nanosecond. *)\n mutable num_values_read : int\n ; (* [blocked_flushes] holds flushes whose preceding elements have not been completely\n read. For each blocked flush, the number of elements that need to be read from the\n pipe in order to fill the flush is :\n\n fill_when_num_values_read - num_values_read\n\n Keeping the data in this form allows us to change a single field(num_values_read)\n when we consume values instead of having to iterate over the whole queue of\n flushes. *)\n blocked_flushes : Blocked_flush.t Queue.t\n ; (* [blocked_reads] holds reads that are waiting on data to be written to the pipe. *)\n blocked_reads : 'a Blocked_read.t Queue.t\n ; (* [closed] is filled when we close the write end of the pipe. *)\n closed : unit Ivar.t\n ; (* [read_closed] is filled when we close the read end of the pipe. *)\n read_closed : unit Ivar.t\n ; (* [consumers] is a list of all consumers that may be handling values read from the\n pipe. *)\n mutable consumers : Consumer.t list\n ; (* [upstream_flusheds] has a function for each pipe immediately upstream of this one.\n That function walks to the head(s) of the upstream pipe, and calls\n [downstream_flushed] on the head(s). See the definition of [upstream_flushed]\n below. *)\n upstream_flusheds : (unit -> Flushed_result.t Deferred.t) Bag.t\n }\n[@@deriving fields, sexp_of]\n\ntype ('a, 'phantom) pipe = ('a, 'phantom) t [@@deriving sexp_of]\n\nlet hash t = Hashtbl.hash t.id\nlet equal (t1 : (_, _) t) t2 = phys_equal t1 t2\nlet compare t1 t2 = Int.compare t1.id t2.id\nlet is_closed t = Ivar.is_full t.closed\nlet is_read_closed t = Ivar.is_full t.read_closed\nlet closed t = Ivar.read t.closed\nlet pushback t = Ivar.read t.pushback\nlet length t = Queue.length t.buffer\nlet is_empty t = length t = 0\n\nlet invariant t : unit =\n try\n let check f field = f (Field.get field t) in\n Fields.iter\n ~id:ignore\n ~info:ignore\n ~buffer:ignore\n ~size_budget:(check (fun size_budget -> assert (size_budget >= 0)))\n ~pushback:\n (check (fun pushback ->\n assert (\n Bool.equal\n (Ivar.is_full pushback)\n (length t <= t.size_budget || is_closed t))))\n ~num_values_read:ignore\n ~blocked_flushes:\n (check (fun blocked_flushes ->\n Queue.iter blocked_flushes ~f:(fun (f : Blocked_flush.t) ->\n assert (f.fill_when_num_values_read > t.num_values_read));\n assert (\n List.is_sorted\n ~compare:Int.compare\n (List.map\n (Queue.to_list blocked_flushes)\n ~f:Blocked_flush.fill_when_num_values_read));\n if is_empty t then assert (Queue.is_empty blocked_flushes)))\n ~blocked_reads:\n (check (fun blocked_reads ->\n (* If data is available, no one is waiting for it. This would need to change if\n we ever implement [read_exactly] as an atomic operation. *)\n if not (is_empty t) then assert (Queue.is_empty blocked_reads);\n Queue.iter blocked_reads ~f:(fun read ->\n Blocked_read.invariant read;\n assert (Blocked_read.is_empty read));\n (* You never block trying to read a closed pipe. *)\n if is_closed t then assert (Queue.is_empty blocked_reads)))\n ~closed:ignore\n ~read_closed:ignore\n ~consumers:\n (check (fun l ->\n List.iter l ~f:(fun consumer ->\n Consumer.invariant consumer;\n assert (Consumer.pipe_id consumer = t.id))))\n ~upstream_flusheds:ignore\n with\n | exn -> raise_s [%message \"Pipe.invariant failed\" (exn : exn) ~pipe:(t : (_, _) t)]\n;;\n\nmodule Reader = struct\n type phantom [@@deriving sexp_of]\n type 'a t = ('a, phantom) pipe [@@deriving sexp_of]\n\n let invariant = invariant\nend\n\nmodule Writer = struct\n type phantom [@@deriving sexp_of]\n type 'a t = ('a, phantom) pipe [@@deriving sexp_of]\n\n let invariant = invariant\nend\n\nlet id_ref = ref 0\n\nlet create_internal ~info ~initial_buffer =\n incr id_ref;\n let t =\n { id = !id_ref\n ; info\n ; closed = Ivar.create ()\n ; read_closed = Ivar.create ()\n ;\n size_budget = 0\n ; pushback = Ivar.create ()\n ; buffer = initial_buffer\n ; num_values_read = 0\n ; blocked_flushes = Queue.create ()\n ; blocked_reads = Queue.create ()\n ; consumers = []\n ; upstream_flusheds = Bag.create ()\n }\n in\n t\n;;\n\nlet create ?info () =\n let t = create_internal ~info ~initial_buffer:(Queue.create ()) in\n (* initially, the pipe does not pushback *)\n Ivar.fill t.pushback ();\n if !check_invariant then invariant t;\n t, t\n;;\n\nlet update_pushback t =\n if length t <= t.size_budget || is_closed t\n then Ivar.fill_if_empty t.pushback ()\n else if Ivar.is_full t.pushback\n then t.pushback <- Ivar.create ()\n;;\n\nlet close t =\n if !show_debug_messages then eprints \"close\" t [%sexp_of: (_, _) t];\n if !check_invariant then invariant t;\n if not (is_closed t)\n then (\n Ivar.fill t.closed ();\n if is_empty t\n then (\n Queue.iter t.blocked_reads ~f:Blocked_read.fill_with_eof;\n Queue.clear t.blocked_reads);\n update_pushback t)\n;;\n\nlet close_read t =\n if !show_debug_messages then eprints \"close_read\" t [%sexp_of: (_, _) t];\n if !check_invariant then invariant t;\n if not (is_read_closed t)\n then (\n Ivar.fill t.read_closed ();\n Queue.iter t.blocked_flushes ~f:(fun flush ->\n Blocked_flush.fill flush `Reader_closed);\n Queue.clear t.blocked_flushes;\n Queue.clear t.buffer;\n update_pushback t;\n (* we just cleared the buffer, so may need to fill [t.pushback] *)\n close t)\n;;\n\nlet create_reader_not_close_on_exception f =\n let r, w = create () in\n upon (f w) (fun () -> close w);\n r\n;;\n\nlet create_reader ~close_on_exception f =\n if not close_on_exception\n then create_reader_not_close_on_exception f\n else (\n let r, w = create () in\n don't_wait_for\n (Monitor.protect\n (fun () -> f w)\n ~finally:(fun () ->\n close w;\n return ()));\n r)\n;;\n\nlet create_writer f =\n let r, w = create () in\n don't_wait_for\n (Monitor.protect\n (fun () -> f r)\n ~finally:(fun () ->\n close_read r;\n return ()));\n w\n;;\n\nlet values_were_read t consumer =\n Option.iter consumer ~f:Consumer.start;\n let rec loop () =\n match Queue.peek t.blocked_flushes with\n | None -> ()\n | Some flush ->\n if t.num_values_read >= flush.fill_when_num_values_read\n then (\n ignore (Queue.dequeue_exn t.blocked_flushes : Blocked_flush.t);\n (match consumer with\n | None -> Blocked_flush.fill flush `Ok\n | Some consumer ->\n upon\n (Consumer.values_sent_downstream_and_flushed consumer)\n (fun flush_result -> Blocked_flush.fill flush flush_result));\n loop ())\n in\n loop ()\n;;\n\n(* [consume_all t] reads all the elements in [t]. *)\nlet consume_all t consumer =\n let result = t.buffer in\n t.buffer <- Queue.create ();\n t.num_values_read <- t.num_values_read + Queue.length result;\n values_were_read t consumer;\n update_pushback t;\n result\n;;\n\nlet consume_one t consumer =\n assert (length t >= 1);\n let result = Queue.dequeue_exn t.buffer in\n t.num_values_read <- t.num_values_read + 1;\n values_were_read t consumer;\n update_pushback t;\n result\n;;\n\nlet consume t ~max_queue_length consumer =\n assert (max_queue_length >= 0);\n if max_queue_length >= length t\n then consume_all t consumer\n else (\n t.num_values_read <- t.num_values_read + max_queue_length;\n values_were_read t consumer;\n let result = Queue.create ~capacity:max_queue_length () in\n Queue.blit_transfer ~src:t.buffer ~dst:result ~len:max_queue_length ();\n update_pushback t;\n result)\n;;\n\nlet set_size_budget t size_budget =\n if size_budget < 0 then raise_s [%message \"negative size_budget\" (size_budget : int)];\n t.size_budget <- size_budget;\n update_pushback t\n;;\n\nlet fill_blocked_reads t =\n while (not (Queue.is_empty t.blocked_reads)) && not (is_empty t) do\n let blocked_read = Queue.dequeue_exn t.blocked_reads in\n let consumer = blocked_read.consumer in\n match blocked_read.wants with\n | Zero ivar -> Ivar.fill ivar `Ok\n | One ivar -> Ivar.fill ivar (`Ok (consume_one t consumer))\n | At_most (max_queue_length, ivar) ->\n Ivar.fill ivar (`Ok (consume t ~max_queue_length consumer))\n done\n;;\n\n(* checks all invariants, calls a passed in f to handle a write, then updates reads and\n pushback *)\nlet start_write t =\n if !show_debug_messages then eprints \"write\" t [%sexp_of: (_, _) t];\n if !check_invariant then invariant t;\n if is_closed t then raise_s [%message \"write to closed pipe\" ~pipe:(t : (_, _) t)]\n;;\n\nlet finish_write t =\n fill_blocked_reads t;\n update_pushback t\n;;\n\nlet transfer_in_without_pushback t ~from =\n start_write t;\n Queue.blit_transfer ~src:from ~dst:t.buffer ();\n finish_write t\n;;\n\nlet transfer_in t ~from =\n transfer_in_without_pushback t ~from;\n pushback t\n;;\n\nlet copy_in_without_pushback t ~from =\n start_write t;\n Queue.iter from ~f:(fun x -> Queue.enqueue t.buffer x);\n finish_write t\n;;\n\n(* [write'] is used internally *)\nlet write' t q = transfer_in t ~from:q\n\nlet write_without_pushback t value =\n start_write t;\n Queue.enqueue t.buffer value;\n finish_write t\n;;\n\nlet write t value =\n write_without_pushback t value;\n pushback t\n;;\n\nlet write_when_ready t ~f =\n let%map () = pushback t in\n if is_closed t then `Closed else `Ok (f (fun x -> write_without_pushback t x))\n;;\n\nlet write_if_open t x = if not (is_closed t) then write t x else return ()\n\nlet write_without_pushback_if_open t x =\n if not (is_closed t) then write_without_pushback t x\n;;\n\nlet ensure_consumer_matches ?consumer t =\n match consumer with\n | None -> ()\n | Some consumer ->\n if t.id <> Consumer.pipe_id consumer\n then\n raise_s\n [%message\n \"Attempt to use consumer with wrong pipe\"\n (consumer : Consumer.t)\n ~pipe:(t : _ Reader.t)]\n;;\n\nlet start_read ?consumer t label =\n if !show_debug_messages then eprints label t [%sexp_of: (_, _) t];\n if !check_invariant then invariant t;\n ensure_consumer_matches t ?consumer\n;;\n\nlet gen_read_now ?consumer t consume =\n start_read t \"read_now\" ?consumer;\n if is_empty t\n then if is_closed t then `Eof else `Nothing_available\n else (\n assert (Queue.is_empty t.blocked_reads);\n (* from [invariant] and [not (is_empty t)] *)\n `Ok (consume t consumer))\n;;\n\nlet get_max_queue_length ~max_queue_length =\n match max_queue_length with\n | None -> Int.max_value\n | Some max_queue_length ->\n if max_queue_length <= 0\n then raise_s [%message \"max_queue_length <= 0\" (max_queue_length : int)];\n max_queue_length\n;;\n\nlet read_now' ?consumer ?max_queue_length t =\n let max_queue_length = get_max_queue_length ~max_queue_length in\n gen_read_now t ?consumer (fun t consumer -> consume t ~max_queue_length consumer)\n;;\n\nlet read_now ?consumer t = gen_read_now t ?consumer consume_one\nlet peek t = Queue.peek t.buffer\n\nlet clear t =\n match read_now' t with\n | `Eof | `Nothing_available | `Ok _ -> ()\n;;\n\nlet read' ?consumer ?max_queue_length t =\n let max_queue_length = get_max_queue_length ~max_queue_length in\n start_read t \"read'\" ?consumer;\n match read_now' t ?consumer ~max_queue_length with\n | (`Ok _ | `Eof) as r -> return r\n | `Nothing_available ->\n Deferred.create (fun ivar ->\n Queue.enqueue\n t.blocked_reads\n (Blocked_read.create (At_most (max_queue_length, ivar)) consumer))\n;;\n\nlet read ?consumer t =\n start_read t \"read\" ?consumer;\n if is_empty t\n then\n if is_closed t\n then return `Eof\n else\n Deferred.create (fun ivar ->\n Queue.enqueue t.blocked_reads (Blocked_read.(create (One ivar)) consumer))\n else (\n assert (Queue.is_empty t.blocked_reads);\n return (`Ok (consume_one t consumer)))\n;;\n\nlet values_available t =\n start_read t \"values_available\";\n if not (is_empty t)\n then return `Ok\n else if is_closed t\n then return `Eof\n else (\n match Queue.last t.blocked_reads with\n | Some { consumer = None; wants = Zero ivar } ->\n (* This case is an optimization for multiple calls to [values_available] in\n sequence. It causes them to all share the same ivar, rather than allocate\n an ivar per call. *)\n Ivar.read ivar\n | _ ->\n Deferred.create (fun ivar ->\n Queue.enqueue t.blocked_reads (Blocked_read.(create (Zero ivar)) None)))\n;;\n\nlet read_choice t = choice (values_available t) (fun (_ : [ `Ok | `Eof ]) -> read_now t)\n\nlet read_choice_single_consumer_exn t here =\n Deferred.Choice.map (read_choice t) ~f:(function\n | (`Ok _ | `Eof) as x -> x\n | `Nothing_available ->\n raise_s\n [%message\n \"Pipe.read_choice_single_consumer_exn: choice was enabled but pipe is \\\n empty; this is likely due to a race condition with one or more other \\\n consumers\"\n (here : Source_code_position.t)])\n;;\n\n(* [read_exactly t ~num_values] loops, getting you all [num_values] items, up\n to EOF. *)\nlet read_exactly ?consumer t ~num_values =\n start_read t \"read_exactly\" ?consumer;\n if num_values <= 0\n then raise_s [%message \"Pipe.read_exactly got num_values <= 0\" (num_values : int)];\n Deferred.create (fun finish ->\n let result = Queue.create () in\n let rec loop () =\n let already_read = Queue.length result in\n assert (already_read <= num_values);\n if already_read = num_values\n then Ivar.fill finish (`Exactly result)\n else\n read' ?consumer t ~max_queue_length:(num_values - already_read)\n >>> function\n | `Eof -> Ivar.fill finish (if already_read = 0 then `Eof else `Fewer result)\n | `Ok q ->\n Queue.blit_transfer ~src:q ~dst:result ();\n loop ()\n in\n loop ())\n;;\n\nlet downstream_flushed t =\n if is_empty t\n then\n if List.is_empty t.consumers\n then return `Ok\n else\n Flushed_result.combine\n (List.map t.consumers ~f:Consumer.values_sent_downstream_and_flushed)\n else\n (* [t] might be closed. But the read end can't be closed, because if it were, then\n [t] would be empty. If the write end is closed but not the read end, then we want\n to enqueue a blocked flush because the enqueued values may get read. *)\n Deferred.create (fun ready ->\n Queue.enqueue\n t.blocked_flushes\n { fill_when_num_values_read = t.num_values_read + length t; ready })\n;;\n\n(* In practice, along with [Link.create] and [add_upstream_flushed], [upstream_flushed]\n traverses the graph of linked pipes up to the heads and then calls [downstream_flushed]\n on them. *)\nlet upstream_flushed t =\n if Bag.is_empty t.upstream_flusheds\n then downstream_flushed t\n else\n Bag.to_list t.upstream_flusheds\n |> List.map ~f:(fun f -> f ())\n |> Flushed_result.combine\n;;\n\nlet add_upstream_flushed t upstream_flushed =\n Bag.add t.upstream_flusheds upstream_flushed\n;;\n\nlet add_consumer t ~downstream_flushed =\n let consumer = Consumer.create ~pipe_id:t.id ~downstream_flushed in\n t.consumers <- consumer :: t.consumers;\n consumer\n;;\n\n(* A [Link.t] links flushing of two pipes together. *)\nmodule Link : sig\n type t\n\n val create : upstream:(_, _) pipe -> downstream:(_, _) pipe -> t\n val consumer : t -> Consumer.t\n\n (* [unlink_upstream] removes downstream's reference to upstream. *)\n\n val unlink_upstream : t -> unit\nend = struct\n type ('a, 'b) unpacked =\n { downstream : ('a, 'b) t\n ; consumer : Consumer.t\n ; upstream_flusheds_bag_elt : (unit -> Flushed_result.t Deferred.t) Bag.Elt.t\n }\n\n type t = T : (_, _) unpacked -> t\n\n let consumer (T t) = t.consumer\n\n let create ~upstream ~downstream =\n T\n { downstream\n ; consumer =\n add_consumer upstream ~downstream_flushed:(fun () ->\n downstream_flushed downstream)\n ; upstream_flusheds_bag_elt =\n add_upstream_flushed downstream (fun () -> upstream_flushed upstream)\n }\n ;;\n\n let unlink_upstream (T t) =\n Bag.remove t.downstream.upstream_flusheds t.upstream_flusheds_bag_elt\n ;;\nend\n\nmodule Flushed = struct\n type t =\n | Consumer of Consumer.t\n | When_value_processed\n | When_value_read\n [@@deriving sexp_of]\nend\n\nlet fold_gen\n (read_now : ?consumer:Consumer.t -> _ Reader.t -> _)\n ?(flushed = Flushed.When_value_read)\n t\n ~init\n ~f\n =\n let consumer =\n match flushed with\n | When_value_read -> None\n | Consumer consumer -> Some consumer\n | When_value_processed ->\n (* The fact that \"no consumer\" behaves different from \"trivial consumer\" is weird,\n but that's how the consumer machinery works. *)\n Some (add_consumer t ~downstream_flushed:(fun () -> return `Ok))\n in\n if !check_invariant then invariant t;\n ensure_consumer_matches t ?consumer;\n Deferred.create (fun finished ->\n (* We do [return () >>>] to ensure that [f] is only called asynchronously. *)\n return ()\n >>> fun () ->\n let rec loop b =\n match read_now t ?consumer with\n | `Eof -> Ivar.fill finished b\n | `Ok v -> f b v continue\n | `Nothing_available -> values_available t >>> fun _ -> loop b\n and continue b =\n Option.iter consumer ~f:Consumer.values_sent_downstream;\n loop b\n in\n loop init)\n;;\n\nlet fold' ?flushed ?max_queue_length t ~init ~f =\n fold_gen (read_now' ?max_queue_length) ?flushed t ~init ~f:(fun b q loop ->\n f b q >>> loop)\n;;\n\nlet fold ?flushed t ~init ~f =\n fold_gen read_now ?flushed t ~init ~f:(fun b a loop -> f b a >>> loop)\n;;\n\nlet fold_without_pushback ?consumer t ~init ~f =\n fold_gen\n read_now\n t\n ~init\n ~f:(fun b a loop -> loop (f b a))\n ?flushed:\n (match consumer with\n | None -> None\n | Some c -> Some (Consumer c))\n;;\n\nlet with_error_to_current_monitor ?(continue_on_error = false) f a =\n if not continue_on_error\n then f a\n else (\n match%map Monitor.try_with (fun () -> f a) with\n | Ok () -> ()\n | Error exn -> Monitor.send_exn (Monitor.current ()) (Monitor.extract_exn exn))\n;;\n\nlet iter' ?continue_on_error ?flushed ?max_queue_length t ~f =\n fold' ?max_queue_length ?flushed t ~init:() ~f:(fun () q ->\n with_error_to_current_monitor ?continue_on_error f q)\n;;\n\nlet iter ?continue_on_error ?flushed t ~f =\n fold_gen read_now ?flushed t ~init:() ~f:(fun () a loop ->\n with_error_to_current_monitor ?continue_on_error f a >>> fun () -> loop ())\n;;\n\n(* [iter_without_pushback] is a common case, so we implement it in an optimized manner,\n rather than via [iter]. The implementation reads only one element at a time, so that\n if [f] closes [t] or raises, no more elements will be read. *)\nlet iter_without_pushback\n ?consumer\n ?(continue_on_error = false)\n ?max_iterations_per_job\n t\n ~f\n =\n ensure_consumer_matches t ?consumer;\n let max_iterations_per_job =\n match max_iterations_per_job with\n | None -> Int.max_value\n | Some max_iterations_per_job ->\n if max_iterations_per_job <= 0\n then\n raise_s\n [%message\n \"iter_without_pushback got non-positive max_iterations_per_job\"\n (max_iterations_per_job : int)];\n max_iterations_per_job\n in\n let f =\n if not continue_on_error\n then f\n else\n fun a ->\n try f a with\n | exn -> Monitor.send_exn (Monitor.current ()) exn\n in\n Deferred.create (fun finished ->\n (* We do [return () >>>] to ensure that [f] is only called asynchronously. *)\n return ()\n >>> fun () ->\n let rec start () = loop ~remaining:max_iterations_per_job\n and loop ~remaining =\n if remaining = 0\n then return () >>> fun () -> start ()\n else (\n match read_now t ?consumer with\n | `Eof -> Ivar.fill finished ()\n | `Ok a ->\n f a;\n loop ~remaining:(remaining - 1)\n | `Nothing_available -> values_available t >>> fun _ -> start ())\n in\n start ())\n;;\n\nlet drain t = iter' t ~f:(fun _ -> return ())\nlet drain_and_count t = fold' t ~init:0 ~f:(fun sum q -> return (sum + Queue.length q))\n\nlet read_all input =\n let result = Queue.create () in\n let%map () =\n iter' input ~f:(fun q ->\n Queue.blit_transfer ~src:q ~dst:result ();\n return ())\n in\n result\n;;\n\nlet to_list r = read_all r >>| Queue.to_list\n\nlet to_stream_deprecated t =\n Stream.create (fun tail ->\n iter_without_pushback t ~f:(fun x -> Tail.extend tail x)\n >>> fun () -> Tail.close_exn tail)\n;;\n\n(* The implementation of [of_stream_deprecated] does as much batching as possible. It\n grabs as many items as are available into an internal queue. Once it has grabbed\n everything, it writes it to the pipe and then blocks waiting for the next element from\n the stream.\n\n There's no possibility that we'll starve the pipe reading an endless stream, just\n accumulating the elements into our private queue forever without ever writing them\n downstream to the pipe. Why? because while we're running, the stream-producer *isn't*\n running -- there are no Async block points in the queue-accumulator loop. So the\n queue-accumulator loop will eventually catch up to the current stream tail, at which\n point we'll do the pipe-write and then block on the stream... thus giving the\n stream-producer a chance to make more elements.\n\n One can't implement [of_stream] using [Stream.iter] or [Stream.iter'] because you\n need to be able to stop early when the consumer closes the pipe. Also, using either\n of those would entail significantly more deferred overhead, whereas the below\n implementation uses a deferred only when it needs to wait for data from the stream. *)\nlet of_stream_deprecated s =\n let r, w = create () in\n let q = Queue.create () in\n let transfer () =\n if not (Queue.is_empty q)\n then\n (* Can not pushback on the stream, so ignore the pushback on the pipe. *)\n don't_wait_for (write' w q)\n in\n let rec loop s =\n assert (not (is_closed w));\n let next_deferred = Stream.next s in\n match Deferred.peek next_deferred with\n | Some next -> loop_next next\n | None ->\n transfer ();\n upon next_deferred check_closed_loop_next\n and check_closed_loop_next next = if not (is_closed w) then loop_next next\n and loop_next = function\n | Nil ->\n transfer ();\n close w\n | Cons (x, s) ->\n Queue.enqueue q x;\n loop s\n in\n loop s;\n r\n;;\n\nlet transfer_gen\n (read_now : ?consumer:Consumer.t -> _ Reader.t -> _)\n write\n input\n output\n ~f\n =\n if !check_invariant\n then (\n invariant input;\n invariant output);\n let link = Link.create ~upstream:input ~downstream:output in\n let consumer = Link.consumer link in\n (* When we're done with [input], we unlink to remove pointers from\n [output] to [input], which would cause a space leak if we had single long-lived\n output into which we transfer lots of short-lived inputs. *)\n let unlink () = Link.unlink_upstream link in\n Deferred.create (fun result ->\n (* We do [return () >>>] to ensure that [f] is only called asynchronously. *)\n return ()\n >>> fun () ->\n let output_closed () =\n close_read input;\n unlink ();\n Ivar.fill result ()\n in\n let rec loop () =\n if is_closed output\n then output_closed ()\n else (\n match read_now input ~consumer with\n | `Eof ->\n unlink ();\n Ivar.fill result ()\n | `Ok x -> f x continue\n | `Nothing_available ->\n choose\n [ choice (values_available input) ignore; choice (closed output) ignore ]\n >>> fun () -> loop ())\n and continue y =\n if is_closed output\n then output_closed ()\n else (\n let pushback = write output y in\n Consumer.values_sent_downstream consumer;\n pushback >>> fun () -> loop ())\n in\n loop ())\n;;\n\nlet transfer' ?max_queue_length input output ~f =\n transfer_gen (read_now' ?max_queue_length) write' input output ~f:(fun q k ->\n f q >>> k)\n;;\n\nlet transfer input output ~f =\n transfer_gen read_now write input output ~f:(fun a k -> k (f a))\n;;\n\nlet transfer_id ?max_queue_length input output =\n transfer_gen (read_now' ?max_queue_length) write' input output ~f:(fun q k -> k q)\n;;\n\nlet map_gen read write input ~f =\n let info = Option.map input.info ~f:(fun info -> [%sexp Mapped (info : Sexp.t)]) in\n let result, output = create ?info () in\n upon (transfer_gen read write input output ~f) (fun () -> close output);\n result\n;;\n\nlet map' ?max_queue_length input ~f =\n map_gen (read_now' ?max_queue_length) write' input ~f:(fun q k -> f q >>> k)\n;;\n\nlet map input ~f = map_gen read_now write input ~f:(fun a k -> k (f a))\n\nlet filter_map' ?max_queue_length input ~f =\n map' ?max_queue_length input ~f:(fun q -> Deferred.Queue.filter_map q ~f)\n;;\n\nlet filter_map ?max_queue_length input ~f =\n map_gen (read_now' ?max_queue_length) write' input ~f:(fun q k ->\n k (Queue.filter_map q ~f:(fun x -> if is_read_closed input then None else f x)))\n;;\n\nlet folding_filter_map' ?max_queue_length input ~init ~f =\n let accum = ref init in\n filter_map' ?max_queue_length input ~f:(fun x ->\n let%map a, x = f !accum x in\n accum := a;\n x)\n;;\n\nlet folding_filter_map ?max_queue_length input ~init ~f =\n let accum = ref init in\n filter_map ?max_queue_length input ~f:(fun x ->\n let a, x = f !accum x in\n accum := a;\n x)\n;;\n\nlet folding_map ?max_queue_length input ~init ~f =\n folding_filter_map ?max_queue_length input ~init ~f:(fun accum a ->\n let accum, b = f accum a in\n accum, Some b)\n;;\n\nlet filter input ~f = filter_map input ~f:(fun x -> if f x then Some x else None)\n\nlet of_list l =\n let t = create_internal ~info:None ~initial_buffer:(Queue.of_list l) in\n Ivar.fill t.closed ();\n update_pushback t;\n t\n;;\n\nlet empty () = of_list []\n\nlet singleton x =\n let reader, writer = create () in\n write_without_pushback writer x;\n close writer;\n reader\n;;\n\nlet unfold ~init:s ~f =\n (* To get some batching, we run the continuation immediately if the deferred is\n determined. However, we always check for pushback. Because size budget can't be\n infinite, the below loop is guaranteed to eventually yield to the scheduler. *)\n let ( >>=~ ) d f =\n match Deferred.peek d with\n | None -> d >>= f\n | Some x -> f x\n in\n create_reader ~close_on_exception:false (fun writer ->\n let rec loop s =\n f s\n >>=~ function\n | None -> return ()\n | Some (a, s) ->\n if is_closed writer then return () else write writer a >>=~ fun () -> loop s\n in\n loop s)\n;;\n\nlet of_sequence sequence =\n create_reader ~close_on_exception:false (fun writer ->\n let rec enqueue_n sequence i =\n if i <= 0\n then sequence\n else (\n match Sequence.next sequence with\n | None -> sequence\n | Some (a, sequence) ->\n Queue.enqueue writer.buffer a;\n enqueue_n sequence (i - 1))\n in\n let rec loop sequence =\n if is_closed writer || Sequence.is_empty sequence\n then return ()\n else (\n start_write writer;\n let sequence = enqueue_n sequence (1 + writer.size_budget - length writer) in\n finish_write writer;\n let%bind () = pushback writer in\n loop sequence)\n in\n loop sequence)\n;;\n\ntype 'a to_sequence_elt =\n | Value of 'a\n | Wait_for : _ Deferred.t -> _ to_sequence_elt\n\nlet to_sequence t =\n Sequence.unfold ~init:() ~f:(fun () ->\n match read_now t with\n | `Eof -> None\n | `Ok a -> Some (Value a, ())\n | `Nothing_available -> Some (Wait_for (values_available t), ()))\n;;\n\nlet interleave_pipe inputs =\n let output, output_writer = create ~info:[%sexp \"Pipe.interleave\"] () in\n (* We keep a reference count of all the pipes that [interleave_pipe] is managing;\n [inputs] counts as one. When the reference count drops to zero, we know that all\n pipes are closed and we can close [output_writer]. *)\n let num_pipes_remaining = ref 1 in\n let decr_num_pipes_remaining () =\n decr num_pipes_remaining;\n if !num_pipes_remaining = 0 then close output_writer\n in\n don't_wait_for\n (let%map () =\n iter_without_pushback inputs ~f:(fun input ->\n incr num_pipes_remaining;\n don't_wait_for\n (let%map () = transfer_id input output_writer in\n decr_num_pipes_remaining ()))\n in\n decr_num_pipes_remaining ());\n (* for [inputs] *)\n output\n;;\n\nlet interleave inputs =\n if !check_invariant then List.iter inputs ~f:invariant;\n interleave_pipe (of_list inputs)\n;;\n\nlet merge inputs ~compare =\n match inputs with\n | [] -> empty ()\n | [ input ] -> input\n | inputs ->\n let module Heap = Pairing_heap in\n let r, w = create () in\n upon (closed w) (fun () -> List.iter inputs ~f:close_read);\n let heap = Heap.create ~cmp:(fun (a1, _) (a2, _) -> compare a1 a2) () in\n let handle_read input eof_or_ok =\n match eof_or_ok with\n | `Eof -> ()\n | `Ok v -> Heap.add heap (v, input)\n in\n let rec pop_heap_and_loop () =\n (* At this point, all inputs not at Eof occur in [heap] exactly once, so we know\n what the next output element is. [pop_heap_and_loop] repeatedly takes elements\n from the inputs as long as it has one from each input. This is done\n synchronously to avoid the cost of a deferred for each element of the output --\n there's no need to pushback since that is only moving elements from one pipe to\n another. As soon as [pop_heap_and_loop] can't get an element from some input, it\n waits on pushback from the output, since it has to wait on the input anyway.\n This also prevents [merge] from consuming inputs at a rate faster than its output\n is consumed. *)\n match Heap.pop heap with\n | None -> close w\n | Some (v, input) ->\n if not (is_closed w)\n then (\n write_without_pushback w v;\n if Heap.length heap = 0\n then upon (transfer_id input w) (fun () -> close w)\n else (\n match read_now input with\n | (`Eof | `Ok _) as x ->\n handle_read input x;\n pop_heap_and_loop ()\n | `Nothing_available ->\n pushback w\n >>> fun () ->\n read input\n >>> fun x ->\n handle_read input x;\n pop_heap_and_loop ()))\n in\n let initial_push =\n Deferred.List.iter inputs ~f:(fun input ->\n let%map x = read input in\n handle_read input x)\n in\n upon initial_push pop_heap_and_loop;\n r\n;;\n\nlet concat_pipe inputs =\n let r =\n create_reader_not_close_on_exception (fun w ->\n let link = Link.create ~upstream:inputs ~downstream:w in\n let consumer = Link.consumer link in\n iter ~flushed:(Consumer consumer) inputs ~f:(fun input -> transfer_id input w))\n in\n upon (closed r) (fun () -> close inputs);\n r\n;;\n\nlet concat inputs =\n create_reader_not_close_on_exception (fun w ->\n Deferred.List.iter inputs ~f:(fun input -> transfer_id input w))\n;;\n\nlet fork t ~pushback_uses =\n let reader0, writer0 = create () in\n let reader1, writer1 = create () in\n let some_reader_was_closed = ref false in\n let consumer =\n add_consumer t ~downstream_flushed:(fun () ->\n let some_reader_was_closed = !some_reader_was_closed in\n match%map\n Flushed_result.combine\n [ downstream_flushed writer0; downstream_flushed writer1 ]\n with\n | `Reader_closed -> `Reader_closed\n | `Ok ->\n (* In this case, there could have been no pending items in [writer0] nor in\n [writer1], in which case we could have had a closed pipe that missed some\n writes, but [Flushed_result.combine] would still have returned [`Ok] *)\n if some_reader_was_closed then `Reader_closed else `Ok)\n in\n don't_wait_for\n (let still_open = [ writer0; writer1 ] in\n let filter_open still_open =\n (* Only call [filter] and reallocate list if something will get filtered *)\n if not (List.exists still_open ~f:is_closed)\n then still_open\n else (\n some_reader_was_closed := true;\n let still_open = List.filter still_open ~f:(fun w -> not (is_closed w)) in\n if List.is_empty still_open then close t;\n still_open)\n in\n let%bind still_open =\n fold' t ~flushed:(Consumer consumer) ~init:still_open ~f:(fun still_open queue ->\n let still_open = filter_open still_open in\n if List.is_empty still_open\n then return []\n else (\n let%map () =\n match pushback_uses with\n | `Fast_consumer_only -> Deferred.any (List.map still_open ~f:pushback)\n | `Both_consumers -> Deferred.all_unit (List.map still_open ~f:pushback)\n in\n let still_open = filter_open still_open in\n List.iter still_open ~f:(fun w -> copy_in_without_pushback w ~from:queue);\n still_open))\n in\n List.iter still_open ~f:close;\n return ());\n reader0, reader1\n;;\n\nlet set_info t info = set_info t (Some info)\n","open! Import\nmodule Int = Int0\nmodule Sys = Sys0\n\nlet convert_failure x a b to_string =\n Printf.failwithf\n \"conversion from %s to %s failed: %s is out of range\"\n a\n b\n (to_string x)\n ()\n[@@cold] [@@inline never] [@@local never] [@@specialise never]\n;;\n\nlet num_bits_int = Sys.int_size_in_bits\nlet num_bits_int32 = 32\nlet num_bits_int64 = 64\nlet num_bits_nativeint = Word_size.num_bits Word_size.word_size\nlet () = assert (num_bits_int = 63 || num_bits_int = 31 || num_bits_int = 32)\nlet min_int32 = Caml.Int32.min_int\nlet max_int32 = Caml.Int32.max_int\nlet min_int64 = Caml.Int64.min_int\nlet max_int64 = Caml.Int64.max_int\nlet min_nativeint = Caml.Nativeint.min_int\nlet max_nativeint = Caml.Nativeint.max_int\nlet int_to_string = Caml.string_of_int\nlet int32_to_string = Caml.Int32.to_string\nlet int64_to_string = Caml.Int64.to_string\nlet nativeint_to_string = Caml.Nativeint.to_string\n\n(* int <-> int32 *)\n\nlet int_to_int32_failure x = convert_failure x \"int\" \"int32\" int_to_string\nlet int32_to_int_failure x = convert_failure x \"int32\" \"int\" int32_to_string\nlet int32_to_int_trunc = Caml.Int32.to_int\nlet int_to_int32_trunc = Caml.Int32.of_int\n\nlet int_is_representable_as_int32 =\n if num_bits_int <= num_bits_int32\n then fun _ -> true\n else (\n let min = int32_to_int_trunc min_int32 in\n let max = int32_to_int_trunc max_int32 in\n fun x -> compare_int min x <= 0 && compare_int x max <= 0)\n;;\n\nlet int32_is_representable_as_int =\n if num_bits_int32 <= num_bits_int\n then fun _ -> true\n else (\n let min = int_to_int32_trunc Int.min_value in\n let max = int_to_int32_trunc Int.max_value in\n fun x -> compare_int32 min x <= 0 && compare_int32 x max <= 0)\n;;\n\nlet int_to_int32 x =\n if int_is_representable_as_int32 x then Some (int_to_int32_trunc x) else None\n;;\n\nlet int32_to_int x =\n if int32_is_representable_as_int x then Some (int32_to_int_trunc x) else None\n;;\n\nlet int_to_int32_exn x =\n if int_is_representable_as_int32 x\n then int_to_int32_trunc x\n else int_to_int32_failure x\n;;\n\nlet int32_to_int_exn x =\n if int32_is_representable_as_int x\n then int32_to_int_trunc x\n else int32_to_int_failure x\n;;\n\n(* int <-> int64 *)\n\nlet int64_to_int_failure x = convert_failure x \"int64\" \"int\" int64_to_string\nlet () = assert (num_bits_int < num_bits_int64)\nlet int_to_int64 = Caml.Int64.of_int\nlet int64_to_int_trunc = Caml.Int64.to_int\n\nlet int64_is_representable_as_int =\n let min = int_to_int64 Int.min_value in\n let max = int_to_int64 Int.max_value in\n fun x -> compare_int64 min x <= 0 && compare_int64 x max <= 0\n;;\n\nlet int64_to_int x =\n if int64_is_representable_as_int x then Some (int64_to_int_trunc x) else None\n;;\n\nlet int64_to_int_exn x =\n if int64_is_representable_as_int x\n then int64_to_int_trunc x\n else int64_to_int_failure x\n;;\n\n(* int <-> nativeint *)\n\nlet nativeint_to_int_failure x = convert_failure x \"nativeint\" \"int\" nativeint_to_string\nlet () = assert (num_bits_int <= num_bits_nativeint)\nlet int_to_nativeint = Caml.Nativeint.of_int\nlet nativeint_to_int_trunc = Caml.Nativeint.to_int\n\nlet nativeint_is_representable_as_int =\n if num_bits_nativeint <= num_bits_int\n then fun _ -> true\n else (\n let min = int_to_nativeint Int.min_value in\n let max = int_to_nativeint Int.max_value in\n fun x -> compare_nativeint min x <= 0 && compare_nativeint x max <= 0)\n;;\n\nlet nativeint_to_int x =\n if nativeint_is_representable_as_int x then Some (nativeint_to_int_trunc x) else None\n;;\n\nlet nativeint_to_int_exn x =\n if nativeint_is_representable_as_int x\n then nativeint_to_int_trunc x\n else nativeint_to_int_failure x\n;;\n\n(* int32 <-> int64 *)\n\nlet int64_to_int32_failure x = convert_failure x \"int64\" \"int32\" int64_to_string\nlet () = assert (num_bits_int32 < num_bits_int64)\nlet int32_to_int64 = Caml.Int64.of_int32\nlet int64_to_int32_trunc = Caml.Int64.to_int32\n\nlet int64_is_representable_as_int32 =\n let min = int32_to_int64 min_int32 in\n let max = int32_to_int64 max_int32 in\n fun x -> compare_int64 min x <= 0 && compare_int64 x max <= 0\n;;\n\nlet int64_to_int32 x =\n if int64_is_representable_as_int32 x then Some (int64_to_int32_trunc x) else None\n;;\n\nlet int64_to_int32_exn x =\n if int64_is_representable_as_int32 x\n then int64_to_int32_trunc x\n else int64_to_int32_failure x\n;;\n\n(* int32 <-> nativeint *)\n\nlet nativeint_to_int32_failure x =\n convert_failure x \"nativeint\" \"int32\" nativeint_to_string\n;;\n\nlet () = assert (num_bits_int32 <= num_bits_nativeint)\nlet int32_to_nativeint = Caml.Nativeint.of_int32\nlet nativeint_to_int32_trunc = Caml.Nativeint.to_int32\n\nlet nativeint_is_representable_as_int32 =\n if num_bits_nativeint <= num_bits_int32\n then fun _ -> true\n else (\n let min = int32_to_nativeint min_int32 in\n let max = int32_to_nativeint max_int32 in\n fun x -> compare_nativeint min x <= 0 && compare_nativeint x max <= 0)\n;;\n\nlet nativeint_to_int32 x =\n if nativeint_is_representable_as_int32 x\n then Some (nativeint_to_int32_trunc x)\n else None\n;;\n\nlet nativeint_to_int32_exn x =\n if nativeint_is_representable_as_int32 x\n then nativeint_to_int32_trunc x\n else nativeint_to_int32_failure x\n;;\n\n(* int64 <-> nativeint *)\n\nlet int64_to_nativeint_failure x = convert_failure x \"int64\" \"nativeint\" int64_to_string\nlet () = assert (num_bits_int64 >= num_bits_nativeint)\nlet int64_to_nativeint_trunc = Caml.Int64.to_nativeint\nlet nativeint_to_int64 = Caml.Int64.of_nativeint\n\nlet int64_is_representable_as_nativeint =\n if num_bits_int64 <= num_bits_nativeint\n then fun _ -> true\n else (\n let min = nativeint_to_int64 min_nativeint in\n let max = nativeint_to_int64 max_nativeint in\n fun x -> compare_int64 min x <= 0 && compare_int64 x max <= 0)\n;;\n\nlet int64_to_nativeint x =\n if int64_is_representable_as_nativeint x\n then Some (int64_to_nativeint_trunc x)\n else None\n;;\n\nlet int64_to_nativeint_exn x =\n if int64_is_representable_as_nativeint x\n then int64_to_nativeint_trunc x\n else int64_to_nativeint_failure x\n;;\n\n(* int64 <-> int63 *)\n\nlet int64_to_int63_failure x = convert_failure x \"int64\" \"int63\" int64_to_string\n\nlet int64_is_representable_as_int63 =\n let min = Caml.Int64.shift_right min_int64 1 in\n let max = Caml.Int64.shift_right max_int64 1 in\n fun x -> compare_int64 min x <= 0 && compare_int64 x max <= 0\n;;\n\nlet int64_fit_on_int63_exn x =\n if int64_is_representable_as_int63 x then () else int64_to_int63_failure x\n;;\n\n(* string conversions *)\n\nlet insert_delimiter_every input ~delimiter ~chars_per_delimiter =\n let input_length = String.length input in\n if input_length <= chars_per_delimiter\n then input\n else (\n let has_sign =\n match input.[0] with\n | '+' | '-' -> true\n | _ -> false\n in\n let num_digits = if has_sign then input_length - 1 else input_length in\n let num_delimiters = (num_digits - 1) / chars_per_delimiter in\n let output_length = input_length + num_delimiters in\n let output = Bytes.create output_length in\n let input_pos = ref (input_length - 1) in\n let output_pos = ref (output_length - 1) in\n let num_chars_until_delimiter = ref chars_per_delimiter in\n let first_digit_pos = if has_sign then 1 else 0 in\n while !input_pos >= first_digit_pos do\n if !num_chars_until_delimiter = 0\n then (\n Bytes.set output !output_pos delimiter;\n decr output_pos;\n num_chars_until_delimiter := chars_per_delimiter);\n Bytes.set output !output_pos input.[!input_pos];\n decr input_pos;\n decr output_pos;\n decr num_chars_until_delimiter\n done;\n if has_sign then Bytes.set output 0 input.[0];\n Bytes.unsafe_to_string ~no_mutation_while_string_reachable:output)\n;;\n\nlet insert_delimiter input ~delimiter =\n insert_delimiter_every input ~delimiter ~chars_per_delimiter:3\n;;\n\nlet insert_underscores input = insert_delimiter input ~delimiter:'_'\nlet sexp_of_int_style = Sexp.of_int_style\n\nmodule Make (I : sig\n type t\n\n val to_string : t -> string\n end) =\nstruct\n open I\n\n let chars_per_delimiter = 3\n\n let to_string_hum ?(delimiter = '_') t =\n insert_delimiter_every (to_string t) ~delimiter ~chars_per_delimiter\n ;;\n\n let sexp_of_t t =\n let s = to_string t in\n Sexp.Atom\n (match !sexp_of_int_style with\n | `Underscores -> insert_delimiter_every s ~chars_per_delimiter ~delimiter:'_'\n | `No_underscores -> s)\n ;;\nend\n\nmodule Make_hex (I : sig\n type t [@@deriving_inline compare, hash]\n\n val compare : t -> t -> int\n val hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state\n val hash : t -> Ppx_hash_lib.Std.Hash.hash_value\n\n [@@@end]\n\n val to_string : t -> string\n val of_string : string -> t\n val zero : t\n val ( < ) : t -> t -> bool\n val neg : t -> t\n val module_name : string\n end) =\nstruct\n module T_hex = struct\n type t = I.t [@@deriving_inline compare, hash]\n\n let compare = (I.compare : t -> t -> int)\n\n let (hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state) =\n I.hash_fold_t\n\n and (hash : t -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func = I.hash in\n fun x -> func x\n ;;\n\n [@@@end]\n\n let chars_per_delimiter = 4\n\n let to_string' ?delimiter t =\n let make_suffix =\n match delimiter with\n | None -> I.to_string\n | Some delimiter ->\n fun t -> insert_delimiter_every (I.to_string t) ~delimiter ~chars_per_delimiter\n in\n if I.( < ) t I.zero then \"-0x\" ^ make_suffix (I.neg t) else \"0x\" ^ make_suffix t\n ;;\n\n let to_string t = to_string' t ?delimiter:None\n let to_string_hum ?(delimiter = '_') t = to_string' t ~delimiter\n\n let invalid str =\n Printf.failwithf \"%s.of_string: invalid input %S\" I.module_name str ()\n ;;\n\n let of_string_with_delimiter str =\n I.of_string (String.filter str ~f:(fun c -> Char.( <> ) c '_'))\n ;;\n\n let of_string str =\n let module L = Hex_lexer in\n let lex = Caml.Lexing.from_string str in\n let result = Option.try_with (fun () -> L.parse_hex lex) in\n if lex.lex_curr_pos = lex.lex_buffer_len\n then (\n match result with\n | None -> invalid str\n | Some (Neg body) -> I.neg (of_string_with_delimiter body)\n | Some (Pos body) -> of_string_with_delimiter body)\n else invalid str\n ;;\n end\n\n module Hex = struct\n include T_hex\n include Sexpable.Of_stringable (T_hex)\n end\nend\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* An alias for the type of lists. *)\ntype 'a t = 'a list = [] | (::) of 'a * 'a list\n\n(* List operations *)\n\nlet rec length_aux len = function\n [] -> len\n | _::l -> length_aux (len + 1) l\n\nlet length l = length_aux 0 l\n\nlet cons a l = a::l\n\nlet hd = function\n [] -> failwith \"hd\"\n | a::_ -> a\n\nlet tl = function\n [] -> failwith \"tl\"\n | _::l -> l\n\nlet nth l n =\n if n < 0 then invalid_arg \"List.nth\" else\n let rec nth_aux l n =\n match l with\n | [] -> failwith \"nth\"\n | a::l -> if n = 0 then a else nth_aux l (n-1)\n in nth_aux l n\n\nlet nth_opt l n =\n if n < 0 then invalid_arg \"List.nth\" else\n let rec nth_aux l n =\n match l with\n | [] -> None\n | a::l -> if n = 0 then Some a else nth_aux l (n-1)\n in nth_aux l n\n\nlet append = (@)\n\nlet rec rev_append l1 l2 =\n match l1 with\n [] -> l2\n | a :: l -> rev_append l (a :: l2)\n\nlet rev l = rev_append l []\n\nlet rec init_tailrec_aux acc i n f =\n if i >= n then acc\n else init_tailrec_aux (f i :: acc) (i+1) n f\n\nlet rec init_aux i n f =\n if i >= n then []\n else\n let r = f i in\n r :: init_aux (i+1) n f\n\nlet rev_init_threshold =\n match Sys.backend_type with\n | Sys.Native | Sys.Bytecode -> 10_000\n (* We don't know the size of the stack, better be safe and assume it's\n small. *)\n | Sys.Other _ -> 50\n\nlet init len f =\n if len < 0 then invalid_arg \"List.init\" else\n if len > rev_init_threshold then rev (init_tailrec_aux [] 0 len f)\n else init_aux 0 len f\n\nlet rec flatten = function\n [] -> []\n | l::r -> l @ flatten r\n\nlet concat = flatten\n\nlet rec map f = function\n [] -> []\n | a::l -> let r = f a in r :: map f l\n\nlet rec mapi i f = function\n [] -> []\n | a::l -> let r = f i a in r :: mapi (i + 1) f l\n\nlet mapi f l = mapi 0 f l\n\nlet rev_map f l =\n let rec rmap_f accu = function\n | [] -> accu\n | a::l -> rmap_f (f a :: accu) l\n in\n rmap_f [] l\n\n\nlet rec iter f = function\n [] -> ()\n | a::l -> f a; iter f l\n\nlet rec iteri i f = function\n [] -> ()\n | a::l -> f i a; iteri (i + 1) f l\n\nlet iteri f l = iteri 0 f l\n\nlet rec fold_left f accu l =\n match l with\n [] -> accu\n | a::l -> fold_left f (f accu a) l\n\nlet rec fold_right f l accu =\n match l with\n [] -> accu\n | a::l -> f a (fold_right f l accu)\n\nlet rec map2 f l1 l2 =\n match (l1, l2) with\n ([], []) -> []\n | (a1::l1, a2::l2) -> let r = f a1 a2 in r :: map2 f l1 l2\n | (_, _) -> invalid_arg \"List.map2\"\n\nlet rev_map2 f l1 l2 =\n let rec rmap2_f accu l1 l2 =\n match (l1, l2) with\n | ([], []) -> accu\n | (a1::l1, a2::l2) -> rmap2_f (f a1 a2 :: accu) l1 l2\n | (_, _) -> invalid_arg \"List.rev_map2\"\n in\n rmap2_f [] l1 l2\n\n\nlet rec iter2 f l1 l2 =\n match (l1, l2) with\n ([], []) -> ()\n | (a1::l1, a2::l2) -> f a1 a2; iter2 f l1 l2\n | (_, _) -> invalid_arg \"List.iter2\"\n\nlet rec fold_left2 f accu l1 l2 =\n match (l1, l2) with\n ([], []) -> accu\n | (a1::l1, a2::l2) -> fold_left2 f (f accu a1 a2) l1 l2\n | (_, _) -> invalid_arg \"List.fold_left2\"\n\nlet rec fold_right2 f l1 l2 accu =\n match (l1, l2) with\n ([], []) -> accu\n | (a1::l1, a2::l2) -> f a1 a2 (fold_right2 f l1 l2 accu)\n | (_, _) -> invalid_arg \"List.fold_right2\"\n\nlet rec for_all p = function\n [] -> true\n | a::l -> p a && for_all p l\n\nlet rec exists p = function\n [] -> false\n | a::l -> p a || exists p l\n\nlet rec for_all2 p l1 l2 =\n match (l1, l2) with\n ([], []) -> true\n | (a1::l1, a2::l2) -> p a1 a2 && for_all2 p l1 l2\n | (_, _) -> invalid_arg \"List.for_all2\"\n\nlet rec exists2 p l1 l2 =\n match (l1, l2) with\n ([], []) -> false\n | (a1::l1, a2::l2) -> p a1 a2 || exists2 p l1 l2\n | (_, _) -> invalid_arg \"List.exists2\"\n\nlet rec mem x = function\n [] -> false\n | a::l -> compare a x = 0 || mem x l\n\nlet rec memq x = function\n [] -> false\n | a::l -> a == x || memq x l\n\nlet rec assoc x = function\n [] -> raise Not_found\n | (a,b)::l -> if compare a x = 0 then b else assoc x l\n\nlet rec assoc_opt x = function\n [] -> None\n | (a,b)::l -> if compare a x = 0 then Some b else assoc_opt x l\n\nlet rec assq x = function\n [] -> raise Not_found\n | (a,b)::l -> if a == x then b else assq x l\n\nlet rec assq_opt x = function\n [] -> None\n | (a,b)::l -> if a == x then Some b else assq_opt x l\n\nlet rec mem_assoc x = function\n | [] -> false\n | (a, _) :: l -> compare a x = 0 || mem_assoc x l\n\nlet rec mem_assq x = function\n | [] -> false\n | (a, _) :: l -> a == x || mem_assq x l\n\nlet rec remove_assoc x = function\n | [] -> []\n | (a, _ as pair) :: l ->\n if compare a x = 0 then l else pair :: remove_assoc x l\n\nlet rec remove_assq x = function\n | [] -> []\n | (a, _ as pair) :: l -> if a == x then l else pair :: remove_assq x l\n\nlet rec find p = function\n | [] -> raise Not_found\n | x :: l -> if p x then x else find p l\n\nlet rec find_opt p = function\n | [] -> None\n | x :: l -> if p x then Some x else find_opt p l\n\nlet rec find_map f = function\n | [] -> None\n | x :: l ->\n begin match f x with\n | Some _ as result -> result\n | None -> find_map f l\n end\n\nlet find_all p =\n let rec find accu = function\n | [] -> rev accu\n | x :: l -> if p x then find (x :: accu) l else find accu l in\n find []\n\nlet filter = find_all\n\nlet filteri p l =\n let rec aux i acc = function\n | [] -> rev acc\n | x::l -> aux (i + 1) (if p i x then x::acc else acc) l\n in\n aux 0 [] l\n\nlet filter_map f =\n let rec aux accu = function\n | [] -> rev accu\n | x :: l ->\n match f x with\n | None -> aux accu l\n | Some v -> aux (v :: accu) l\n in\n aux []\n\nlet concat_map f l =\n let rec aux f acc = function\n | [] -> rev acc\n | x :: l ->\n let xs = f x in\n aux f (rev_append xs acc) l\n in aux f [] l\n\nlet fold_left_map f accu l =\n let rec aux accu l_accu = function\n | [] -> accu, rev l_accu\n | x :: l ->\n let accu, x = f accu x in\n aux accu (x :: l_accu) l in\n aux accu [] l\n\nlet partition p l =\n let rec part yes no = function\n | [] -> (rev yes, rev no)\n | x :: l -> if p x then part (x :: yes) no l else part yes (x :: no) l in\n part [] [] l\n\nlet partition_map p l =\n let rec part left right = function\n | [] -> (rev left, rev right)\n | x :: l ->\n begin match p x with\n | Either.Left v -> part (v :: left) right l\n | Either.Right v -> part left (v :: right) l\n end\n in\n part [] [] l\n\nlet rec split = function\n [] -> ([], [])\n | (x,y)::l ->\n let (rx, ry) = split l in (x::rx, y::ry)\n\nlet rec combine l1 l2 =\n match (l1, l2) with\n ([], []) -> []\n | (a1::l1, a2::l2) -> (a1, a2) :: combine l1 l2\n | (_, _) -> invalid_arg \"List.combine\"\n\n(** sorting *)\n\nlet rec merge cmp l1 l2 =\n match l1, l2 with\n | [], l2 -> l2\n | l1, [] -> l1\n | h1 :: t1, h2 :: t2 ->\n if cmp h1 h2 <= 0\n then h1 :: merge cmp t1 l2\n else h2 :: merge cmp l1 t2\n\n\nlet stable_sort cmp l =\n let rec rev_merge l1 l2 accu =\n match l1, l2 with\n | [], l2 -> rev_append l2 accu\n | l1, [] -> rev_append l1 accu\n | h1::t1, h2::t2 ->\n if cmp h1 h2 <= 0\n then rev_merge t1 l2 (h1::accu)\n else rev_merge l1 t2 (h2::accu)\n in\n let rec rev_merge_rev l1 l2 accu =\n match l1, l2 with\n | [], l2 -> rev_append l2 accu\n | l1, [] -> rev_append l1 accu\n | h1::t1, h2::t2 ->\n if cmp h1 h2 > 0\n then rev_merge_rev t1 l2 (h1::accu)\n else rev_merge_rev l1 t2 (h2::accu)\n in\n let rec sort n l =\n match n, l with\n | 2, x1 :: x2 :: tl ->\n let s = if cmp x1 x2 <= 0 then [x1; x2] else [x2; x1] in\n (s, tl)\n | 3, x1 :: x2 :: x3 :: tl ->\n let s =\n if cmp x1 x2 <= 0 then\n if cmp x2 x3 <= 0 then [x1; x2; x3]\n else if cmp x1 x3 <= 0 then [x1; x3; x2]\n else [x3; x1; x2]\n else if cmp x1 x3 <= 0 then [x2; x1; x3]\n else if cmp x2 x3 <= 0 then [x2; x3; x1]\n else [x3; x2; x1]\n in\n (s, tl)\n | n, l ->\n let n1 = n asr 1 in\n let n2 = n - n1 in\n let s1, l2 = rev_sort n1 l in\n let s2, tl = rev_sort n2 l2 in\n (rev_merge_rev s1 s2 [], tl)\n and rev_sort n l =\n match n, l with\n | 2, x1 :: x2 :: tl ->\n let s = if cmp x1 x2 > 0 then [x1; x2] else [x2; x1] in\n (s, tl)\n | 3, x1 :: x2 :: x3 :: tl ->\n let s =\n if cmp x1 x2 > 0 then\n if cmp x2 x3 > 0 then [x1; x2; x3]\n else if cmp x1 x3 > 0 then [x1; x3; x2]\n else [x3; x1; x2]\n else if cmp x1 x3 > 0 then [x2; x1; x3]\n else if cmp x2 x3 > 0 then [x2; x3; x1]\n else [x3; x2; x1]\n in\n (s, tl)\n | n, l ->\n let n1 = n asr 1 in\n let n2 = n - n1 in\n let s1, l2 = sort n1 l in\n let s2, tl = sort n2 l2 in\n (rev_merge s1 s2 [], tl)\n in\n let len = length l in\n if len < 2 then l else fst (sort len l)\n\n\nlet sort = stable_sort\nlet fast_sort = stable_sort\n\n(* Note: on a list of length between about 100000 (depending on the minor\n heap size and the type of the list) and Sys.max_array_size, it is\n actually faster to use the following, but it might also use more memory\n because the argument list cannot be deallocated incrementally.\n\n Also, there seems to be a bug in this code or in the\n implementation of obj_truncate.\n\nexternal obj_truncate : 'a array -> int -> unit = \"caml_obj_truncate\"\n\nlet array_to_list_in_place a =\n let l = Array.length a in\n let rec loop accu n p =\n if p <= 0 then accu else begin\n if p = n then begin\n obj_truncate a p;\n loop (a.(p-1) :: accu) (n-1000) (p-1)\n end else begin\n loop (a.(p-1) :: accu) n (p-1)\n end\n end\n in\n loop [] (l-1000) l\n\n\nlet stable_sort cmp l =\n let a = Array.of_list l in\n Array.stable_sort cmp a;\n array_to_list_in_place a\n\n*)\n\n\n(** sorting + removing duplicates *)\n\nlet sort_uniq cmp l =\n let rec rev_merge l1 l2 accu =\n match l1, l2 with\n | [], l2 -> rev_append l2 accu\n | l1, [] -> rev_append l1 accu\n | h1::t1, h2::t2 ->\n let c = cmp h1 h2 in\n if c = 0 then rev_merge t1 t2 (h1::accu)\n else if c < 0\n then rev_merge t1 l2 (h1::accu)\n else rev_merge l1 t2 (h2::accu)\n in\n let rec rev_merge_rev l1 l2 accu =\n match l1, l2 with\n | [], l2 -> rev_append l2 accu\n | l1, [] -> rev_append l1 accu\n | h1::t1, h2::t2 ->\n let c = cmp h1 h2 in\n if c = 0 then rev_merge_rev t1 t2 (h1::accu)\n else if c > 0\n then rev_merge_rev t1 l2 (h1::accu)\n else rev_merge_rev l1 t2 (h2::accu)\n in\n let rec sort n l =\n match n, l with\n | 2, x1 :: x2 :: tl ->\n let s =\n let c = cmp x1 x2 in\n if c = 0 then [x1] else if c < 0 then [x1; x2] else [x2; x1]\n in\n (s, tl)\n | 3, x1 :: x2 :: x3 :: tl ->\n let s =\n let c = cmp x1 x2 in\n if c = 0 then\n let c = cmp x2 x3 in\n if c = 0 then [x2] else if c < 0 then [x2; x3] else [x3; x2]\n else if c < 0 then\n let c = cmp x2 x3 in\n if c = 0 then [x1; x2]\n else if c < 0 then [x1; x2; x3]\n else\n let c = cmp x1 x3 in\n if c = 0 then [x1; x2]\n else if c < 0 then [x1; x3; x2]\n else [x3; x1; x2]\n else\n let c = cmp x1 x3 in\n if c = 0 then [x2; x1]\n else if c < 0 then [x2; x1; x3]\n else\n let c = cmp x2 x3 in\n if c = 0 then [x2; x1]\n else if c < 0 then [x2; x3; x1]\n else [x3; x2; x1]\n in\n (s, tl)\n | n, l ->\n let n1 = n asr 1 in\n let n2 = n - n1 in\n let s1, l2 = rev_sort n1 l in\n let s2, tl = rev_sort n2 l2 in\n (rev_merge_rev s1 s2 [], tl)\n and rev_sort n l =\n match n, l with\n | 2, x1 :: x2 :: tl ->\n let s =\n let c = cmp x1 x2 in\n if c = 0 then [x1] else if c > 0 then [x1; x2] else [x2; x1]\n in\n (s, tl)\n | 3, x1 :: x2 :: x3 :: tl ->\n let s =\n let c = cmp x1 x2 in\n if c = 0 then\n let c = cmp x2 x3 in\n if c = 0 then [x2] else if c > 0 then [x2; x3] else [x3; x2]\n else if c > 0 then\n let c = cmp x2 x3 in\n if c = 0 then [x1; x2]\n else if c > 0 then [x1; x2; x3]\n else\n let c = cmp x1 x3 in\n if c = 0 then [x1; x2]\n else if c > 0 then [x1; x3; x2]\n else [x3; x1; x2]\n else\n let c = cmp x1 x3 in\n if c = 0 then [x2; x1]\n else if c > 0 then [x2; x1; x3]\n else\n let c = cmp x2 x3 in\n if c = 0 then [x2; x1]\n else if c > 0 then [x2; x3; x1]\n else [x3; x2; x1]\n in\n (s, tl)\n | n, l ->\n let n1 = n asr 1 in\n let n2 = n - n1 in\n let s1, l2 = sort n1 l in\n let s2, tl = sort n2 l2 in\n (rev_merge s1 s2 [], tl)\n in\n let len = length l in\n if len < 2 then l else fst (sort len l)\n\n\nlet rec compare_lengths l1 l2 =\n match l1, l2 with\n | [], [] -> 0\n | [], _ -> -1\n | _, [] -> 1\n | _ :: l1, _ :: l2 -> compare_lengths l1 l2\n;;\n\nlet rec compare_length_with l n =\n match l with\n | [] ->\n if n = 0 then 0 else\n if n > 0 then -1 else 1\n | _ :: l ->\n if n <= 0 then 1 else\n compare_length_with l (n-1)\n;;\n\n(** {1 Comparison} *)\n\n(* Note: we are *not* shortcutting the list by using\n [List.compare_lengths] first; this may be slower on long lists\n immediately start with distinct elements. It is also incorrect for\n [compare] below, and it is better (principle of least surprise) to\n use the same approach for both functions. *)\nlet rec equal eq l1 l2 =\n match l1, l2 with\n | [], [] -> true\n | [], _::_ | _::_, [] -> false\n | a1::l1, a2::l2 -> eq a1 a2 && equal eq l1 l2\n\nlet rec compare cmp l1 l2 =\n match l1, l2 with\n | [], [] -> 0\n | [], _::_ -> -1\n | _::_, [] -> 1\n | a1::l1, a2::l2 ->\n let c = cmp a1 a2 in\n if c <> 0 then c\n else compare cmp l1 l2\n\n(** {1 Iterators} *)\n\nlet to_seq l =\n let rec aux l () = match l with\n | [] -> Seq.Nil\n | x :: tail -> Seq.Cons (x, aux tail)\n in\n aux l\n\nlet of_seq seq =\n let rec direct depth seq : _ list =\n if depth=0\n then\n Seq.fold_left (fun acc x -> x::acc) [] seq\n |> rev (* tailrec *)\n else match seq() with\n | Seq.Nil -> []\n | Seq.Cons (x, next) -> x :: direct (depth-1) next\n in\n direct 500 seq\n","include Base\ninclude Ppxlib\ninclude Ast_builder.Default\n\n(* errors and error messages *)\n\nlet ( ^^ ) = Caml.( ^^ )\nlet error ~loc fmt = Location.raise_errorf ~loc (\"ppx_quickcheck: \" ^^ fmt)\nlet invalid ~loc fmt = error ~loc (\"invalid syntax: \" ^^ fmt)\nlet unsupported ~loc fmt = error ~loc (\"unsupported: \" ^^ fmt)\nlet internal_error ~loc fmt = error ~loc (\"internal error: \" ^^ fmt)\n\nlet short_string_of_core_type core_type =\n match core_type.ptyp_desc with\n | Ptyp_any -> \"wildcard type\"\n | Ptyp_var _ -> \"type variable\"\n | Ptyp_arrow _ -> \"function type\"\n | Ptyp_tuple _ -> \"tuple type\"\n | Ptyp_constr _ -> \"type name\"\n | Ptyp_object _ -> \"object type\"\n | Ptyp_class _ -> \"class type\"\n | Ptyp_alias _ -> \"type variable alias\"\n | Ptyp_variant _ -> \"polymorphic variant\"\n | Ptyp_poly _ -> \"explicit polymorphic type\"\n | Ptyp_package _ -> \"first-class module type\"\n | Ptyp_extension _ -> \"ppx extension type\"\n;;\n\n(* little syntax helpers *)\n\nlet loc_map { loc; txt } ~f = { loc; txt = f txt }\nlet lident_loc = loc_map ~f:lident\n\nlet prefixed_type_name prefix type_name =\n match type_name with\n | \"t\" -> prefix\n | _ -> prefix ^ \"_\" ^ type_name\n;;\n\nlet generator_name type_name = prefixed_type_name \"quickcheck_generator\" type_name\nlet observer_name type_name = prefixed_type_name \"quickcheck_observer\" type_name\nlet shrinker_name type_name = prefixed_type_name \"quickcheck_shrinker\" type_name\nlet pname { loc; txt } ~f = pvar ~loc (f txt)\nlet ename { loc; txt } ~f = evar ~loc (f txt)\nlet pgenerator = pname ~f:generator_name\nlet pobserver = pname ~f:observer_name\nlet pshrinker = pname ~f:shrinker_name\nlet egenerator = ename ~f:generator_name\nlet eobserver = ename ~f:observer_name\nlet eshrinker = ename ~f:shrinker_name\n\nlet ptuple ~loc list =\n match list with\n | [] -> [%pat? ()]\n | [ pat ] -> pat\n | _ -> ppat_tuple ~loc list\n;;\n\n(* creating (probably-)unique symbols for generated code *)\n\nlet gensym prefix loc =\n let loc = { loc with loc_ghost = true } in\n let sym = gen_symbol ~prefix:(\"_\" ^ prefix) () in\n pvar ~loc sym, evar ~loc sym\n;;\n\nlet gensyms prefix loc_list = List.map loc_list ~f:(gensym prefix) |> List.unzip\n\nlet gensymss prefix loc_list_list =\n List.map loc_list_list ~f:(gensyms prefix) |> List.unzip\n;;\n\n(* expression to create a higher order function that maps from function with one kind of\n argument label to another *)\n\nlet fn_map_label ~loc ~from ~to_ =\n let f_pat, f_expr = gensym \"f\" loc in\n let x_pat, x_expr = gensym \"x\" loc in\n pexp_fun\n ~loc\n Nolabel\n None\n f_pat\n (pexp_fun ~loc to_ None x_pat (pexp_apply ~loc f_expr [ from, x_expr ]))\n;;\n","(* [Sys0] defines functions that are primitives or can be simply defined in\n terms of [Caml.Sys]. [Sys0] is intended to completely express the part of\n [Caml.Sys] that [Base] uses -- no other file in Base other than sys.ml\n should use [Caml.Sys]. [Sys0] has few dependencies, and so is available\n early in Base's build order. All Base files that need to use these\n functions and come before [Base.Sys] in build order should do\n [module Sys = Sys0]. Defining [module Sys = Sys0] is also necessary because\n it prevents ocamldep from mistakenly causing a file to depend on [Base.Sys]. *)\n\nopen! Import0\n\ntype backend_type = Caml.Sys.backend_type =\n | Native\n | Bytecode\n | Other of string\n\nlet backend_type = Caml.Sys.backend_type\nlet interactive = Caml.Sys.interactive\nlet os_type = Caml.Sys.os_type\nlet unix = Caml.Sys.unix\nlet win32 = Caml.Sys.win32\nlet cygwin = Caml.Sys.cygwin\nlet word_size_in_bits = Caml.Sys.word_size\nlet int_size_in_bits = Caml.Sys.int_size\nlet big_endian = Caml.Sys.big_endian\nlet max_string_length = Caml.Sys.max_string_length\nlet max_array_length = Caml.Sys.max_array_length\nlet runtime_variant = Caml.Sys.runtime_variant\nlet runtime_parameters = Caml.Sys.runtime_parameters\nlet argv = Caml.Sys.argv\nlet get_argv () = Caml.Sys.argv\nlet ocaml_version = Caml.Sys.ocaml_version\nlet enable_runtime_warnings = Caml.Sys.enable_runtime_warnings\nlet runtime_warnings_enabled = Caml.Sys.runtime_warnings_enabled\n\nlet getenv_exn var =\n try Caml.Sys.getenv var with\n | Caml.Not_found ->\n Printf.failwithf \"Sys.getenv_exn: environment variable %s is not set\" var ()\n;;\n\nlet getenv var =\n match Caml.Sys.getenv var with\n | x -> Some x\n | exception Caml.Not_found -> None\n;;\n\nexternal opaque_identity : 'a -> 'a = \"%opaque\"\n\nexception Break = Caml.Sys.Break\n","(* Write_ml: writing values to the binary protocol using (mostly) OCaml. *)\n\n(* Note: the code is this file is carefully written to avoid unnecessary allocations. When\n touching this code, be sure to run the benchmarks to check for regressions. *)\n\nopen Bigarray\nopen Common\n\ntype 'a writer = buf -> pos:pos -> 'a -> pos\ntype ('a, 'b) writer1 = 'a writer -> 'b writer\ntype ('a, 'b, 'c) writer2 = 'a writer -> ('b, 'c) writer1\ntype ('a, 'b, 'c, 'd) writer3 = 'a writer -> ('b, 'c, 'd) writer2\n\nexternal unsafe_set : buf -> int -> char -> unit = \"%caml_ba_unsafe_set_1\"\nexternal unsafe_set8 : buf -> int -> int -> unit = \"%caml_ba_unsafe_set_1\"\nexternal unsafe_set16 : buf -> int -> int -> unit = \"%caml_bigstring_set16u\"\nexternal unsafe_set32 : buf -> int -> int32 -> unit = \"%caml_bigstring_set32u\"\nexternal unsafe_set64 : buf -> int -> int64 -> unit = \"%caml_bigstring_set64u\"\nexternal bswap16 : int -> int = \"%bswap16\"\nexternal bswap32 : int32 -> int32 = \"%bswap_int32\"\nexternal bswap64 : int64 -> int64 = \"%bswap_int64\"\n\n(*$ open Bin_prot_cinaps $*)\n\nlet code_NEG_INT8 = (*$ Code.char NEG_INT8 *) '\\xff' (*$*)\n\nlet code_INT16 = (*$ Code.char INT16 *) '\\xfe' (*$*)\n\nlet code_INT32 = (*$ Code.char INT32 *) '\\xfd' (*$*)\n\nlet code_INT64 = (*$ Code.char INT64 *) '\\xfc' (*$*)\n\nlet arch_sixtyfour = Sys.word_size = 64\nlet arch_big_endian = Sys.big_endian\n\nlet unsafe_set16be =\n if arch_big_endian\n then unsafe_set16\n else fun buf pos x -> unsafe_set16 buf pos (bswap16 x)\n;;\n\nlet unsafe_set32be =\n if arch_big_endian\n then unsafe_set32\n else fun buf pos x -> unsafe_set32 buf pos (bswap32 x)\n;;\n\nlet unsafe_set64be =\n if arch_big_endian\n then unsafe_set64\n else fun buf pos x -> unsafe_set64 buf pos (bswap64 x)\n;;\n\nlet unsafe_set16le =\n if arch_big_endian\n then fun buf pos x -> unsafe_set16 buf pos (bswap16 x)\n else unsafe_set16\n;;\n\nlet unsafe_set32le =\n if arch_big_endian\n then fun buf pos x -> unsafe_set32 buf pos (bswap32 x)\n else unsafe_set32\n;;\n\nlet unsafe_set64le =\n if arch_big_endian\n then fun buf pos x -> unsafe_set64 buf pos (bswap64 x)\n else unsafe_set64\n;;\n\nlet bin_write_unit buf ~pos () =\n assert_pos pos;\n check_pos buf pos;\n unsafe_set buf pos '\\000';\n pos + 1\n;;\n\nlet bin_write_bool buf ~pos b =\n assert_pos pos;\n check_pos buf pos;\n unsafe_set buf pos (if b then '\\001' else '\\000');\n pos + 1\n;;\n\nlet all_bin_write_small_int buf pos n =\n check_pos buf pos;\n unsafe_set8 buf pos n;\n pos + 1\n;;\n\nlet all_bin_write_neg_int8 buf pos n =\n let next = pos + 2 in\n check_next buf next;\n unsafe_set buf pos code_NEG_INT8;\n unsafe_set8 buf (pos + 1) n;\n next\n;;\n\nlet all_bin_write_int16 buf pos n =\n let next = pos + 3 in\n check_next buf next;\n unsafe_set buf pos code_INT16;\n unsafe_set16le buf (pos + 1) n;\n next\n;;\n\nlet all_bin_write_int32 buf pos n =\n let next = pos + 5 in\n check_next buf next;\n unsafe_set buf pos code_INT32;\n unsafe_set32le buf (pos + 1) n;\n next\n[@@inline]\n;;\n\nlet all_bin_write_int64 buf pos n =\n let next = pos + 9 in\n check_next buf next;\n unsafe_set buf pos code_INT64;\n unsafe_set64le buf (pos + 1) n;\n next\n[@@inline]\n;;\n\nlet bin_write_char buf ~pos c =\n assert_pos pos;\n check_pos buf pos;\n unsafe_set buf pos c;\n pos + 1\n;;\n\nlet bin_write_int buf ~pos n =\n assert_pos pos;\n if n >= 0\n then\n if n < 0x00000080\n then all_bin_write_small_int buf pos n\n else if n < 0x00008000\n then all_bin_write_int16 buf pos n\n else if arch_sixtyfour && n >= 1 lsl 31\n then all_bin_write_int64 buf pos (Int64.of_int n)\n else all_bin_write_int32 buf pos (Int32.of_int n)\n else if n >= -0x00000080\n then all_bin_write_neg_int8 buf pos n\n else if n >= -0x00008000\n then all_bin_write_int16 buf pos n\n else if arch_sixtyfour && n < -(1 lsl 31)\n then all_bin_write_int64 buf pos (Int64.of_int n)\n else all_bin_write_int32 buf pos (Int32.of_int n)\n;;\n\nlet bin_write_nat0 buf ~pos nat0 =\n assert_pos pos;\n let n = (nat0 : Nat0.t :> int) in\n if n < 0x00000080\n then all_bin_write_small_int buf pos n\n else if n < 0x00010000\n then all_bin_write_int16 buf pos n\n else if arch_sixtyfour && n >= 1 lsl 32\n then all_bin_write_int64 buf pos (Int64.of_int n)\n else all_bin_write_int32 buf pos (Int32.of_int n)\n;;\n\nlet bin_write_string buf ~pos str =\n let len = String.length str in\n let plen = Nat0.unsafe_of_int len in\n let new_pos = bin_write_nat0 buf ~pos plen in\n let next = new_pos + len in\n check_next buf next;\n (* TODO: optimize for small strings *)\n unsafe_blit_string_buf ~src_pos:0 str ~dst_pos:new_pos buf ~len;\n next\n;;\n\nlet bin_write_bytes buf ~pos str =\n let len = Bytes.length str in\n let plen = Nat0.unsafe_of_int len in\n let new_pos = bin_write_nat0 buf ~pos plen in\n let next = new_pos + len in\n check_next buf next;\n (* TODO: optimize for small bytes *)\n unsafe_blit_bytes_buf ~src_pos:0 str ~dst_pos:new_pos buf ~len;\n next\n;;\n\nlet bin_write_float buf ~pos x =\n assert_pos pos;\n let next = pos + 8 in\n check_next buf next;\n unsafe_set64le buf pos (Int64.bits_of_float x);\n next\n[@@inline]\n;;\n\nlet bin_write_int32 =\n if arch_sixtyfour\n then fun [@inline] buf ~pos n -> bin_write_int buf ~pos (Int32.to_int n)\n else\n fun [@inline] buf ~pos n ->\n if n >= 0x00008000l || n < -0x00008000l\n then (\n assert_pos pos;\n all_bin_write_int32 buf pos n)\n else bin_write_int buf ~pos (Int32.to_int n)\n;;\n\nlet bin_write_int64 buf ~pos n =\n if n >= 0x80000000L || n < -0x80000000L\n then (\n assert_pos pos;\n all_bin_write_int64 buf pos n)\n else if arch_sixtyfour\n then bin_write_int buf ~pos (Int64.to_int n)\n else if n >= 0x00008000L || n < -0x00008000L\n then (\n assert_pos pos;\n all_bin_write_int32 buf pos (Int64.to_int32 n))\n else bin_write_int buf ~pos (Int64.to_int n)\n[@@inline]\n;;\n\nlet bin_write_nativeint buf ~pos n =\n if arch_sixtyfour\n && (n >= (* 0x80000000n *) Nativeint.shift_left 1n 31\n || n < (* -0x80000000n *) Nativeint.neg (Nativeint.shift_left 1n 31))\n then (\n assert_pos pos;\n all_bin_write_int64 buf pos (Int64.of_nativeint n))\n else if ((not arch_sixtyfour) && n >= 0x8000n) || n < -0x8000n\n then (\n assert_pos pos;\n all_bin_write_int32 buf pos (Nativeint.to_int32 n))\n else bin_write_int buf ~pos (Nativeint.to_int n)\n[@@inline]\n;;\n\nlet bin_write_ref bin_write_el buf ~pos r = bin_write_el buf ~pos !r\n\nlet bin_write_lazy bin_write_el buf ~pos lv =\n let v = Lazy.force lv in\n bin_write_el buf ~pos v\n;;\n\nlet bin_write_option bin_write_el buf ~pos = function\n | None -> bin_write_bool buf ~pos false\n | Some v ->\n let next = bin_write_bool buf ~pos true in\n bin_write_el buf ~pos:next v\n;;\n\nlet bin_write_pair bin_write_a bin_write_b buf ~pos (a, b) =\n let next = bin_write_a buf ~pos a in\n bin_write_b buf ~pos:next b\n;;\n\nlet bin_write_triple bin_write_a bin_write_b bin_write_c buf ~pos (a, b, c) =\n let next1 = bin_write_a buf ~pos a in\n let next2 = bin_write_b buf ~pos:next1 b in\n bin_write_c buf ~pos:next2 c\n;;\n\nlet bin_write_list bin_write_el buf ~pos lst =\n let rec loop els_pos = function\n | [] -> els_pos\n | h :: t ->\n let new_els_pos = bin_write_el buf ~pos:els_pos h in\n loop new_els_pos t\n in\n let len = Nat0.unsafe_of_int (List.length lst) in\n let els_pos = bin_write_nat0 buf ~pos len in\n loop els_pos lst\n;;\n\nlet bin_write_float_array buf ~pos a =\n let len = Array.length a in\n let plen = Nat0.unsafe_of_int len in\n let pos = bin_write_nat0 buf ~pos plen in\n let size = len * 8 in\n let next = pos + size in\n check_next buf next;\n unsafe_blit_float_array_buf a buf ~src_pos:0 ~dst_pos:pos ~len;\n next\n;;\n\nlet bin_write_array_loop bin_write_el buf ~els_pos ~n ar =\n let els_pos_ref = ref els_pos in\n for i = 0 to n - 1 do\n els_pos_ref := bin_write_el buf ~pos:!els_pos_ref (Array.unsafe_get ar i)\n done;\n !els_pos_ref\n;;\n\nlet bin_write_array (type a) bin_write_el buf ~pos ar =\n if (Obj.magic (bin_write_el : a writer) : float writer) == bin_write_float\n then bin_write_float_array buf ~pos (Obj.magic (ar : a array) : float array)\n else (\n let n = Array.length ar in\n let pn = Nat0.unsafe_of_int n in\n let els_pos = bin_write_nat0 buf ~pos pn in\n bin_write_array_loop bin_write_el buf ~els_pos ~n ar)\n;;\n\nlet bin_write_hashtbl bin_write_key bin_write_val buf ~pos htbl =\n let len = Hashtbl.length htbl in\n let plen = Nat0.unsafe_of_int len in\n let els_pos = bin_write_nat0 buf ~pos plen in\n let cnt_ref = ref 0 in\n let coll_htbl k v els_pos =\n incr cnt_ref;\n let new_els_pos = bin_write_key buf ~pos:els_pos k in\n bin_write_val buf ~pos:new_els_pos v\n in\n let res_pos = Hashtbl.fold coll_htbl htbl els_pos in\n if !cnt_ref <> len then raise_concurrent_modification \"bin_write_hashtbl\";\n res_pos\n;;\n\nexternal buf_of_vec32 : vec32 -> buf = \"%identity\"\nexternal buf_of_vec64 : vec64 -> buf = \"%identity\"\nexternal buf_of_mat32 : mat32 -> buf = \"%identity\"\nexternal buf_of_mat64 : mat64 -> buf = \"%identity\"\n\nlet bin_write_float32_vec buf ~pos v =\n let len = Array1.dim v in\n let plen = Nat0.unsafe_of_int len in\n let pos = bin_write_nat0 buf ~pos plen in\n let size = len * 4 in\n let next = pos + size in\n check_next buf next;\n unsafe_blit_buf ~src:(buf_of_vec32 v) ~src_pos:0 ~dst:buf ~dst_pos:pos ~len:size;\n next\n;;\n\nlet bin_write_float64_vec buf ~pos v =\n let len = Array1.dim v in\n let plen = Nat0.unsafe_of_int len in\n let pos = bin_write_nat0 buf ~pos plen in\n let size = len * 8 in\n let next = pos + size in\n check_next buf next;\n unsafe_blit_buf ~src:(buf_of_vec64 v) ~src_pos:0 ~dst:buf ~dst_pos:pos ~len:size;\n next\n;;\n\nlet bin_write_vec = bin_write_float64_vec\n\nlet bin_write_float32_mat buf ~pos m =\n let len1 = Array2.dim1 m in\n let len2 = Array2.dim2 m in\n let pos = bin_write_nat0 buf ~pos (Nat0.unsafe_of_int len1) in\n let pos = bin_write_nat0 buf ~pos (Nat0.unsafe_of_int len2) in\n let size = len1 * len2 * 4 in\n let next = pos + size in\n check_next buf next;\n unsafe_blit_buf ~src:(buf_of_mat32 m) ~src_pos:0 ~dst:buf ~dst_pos:pos ~len:size;\n next\n;;\n\nlet bin_write_float64_mat buf ~pos m =\n let len1 = Array2.dim1 m in\n let len2 = Array2.dim2 m in\n let pos = bin_write_nat0 buf ~pos (Nat0.unsafe_of_int len1) in\n let pos = bin_write_nat0 buf ~pos (Nat0.unsafe_of_int len2) in\n let size = len1 * len2 * 8 in\n let next = pos + size in\n check_next buf next;\n unsafe_blit_buf ~src:(buf_of_mat64 m) ~src_pos:0 ~dst:buf ~dst_pos:pos ~len:size;\n next\n;;\n\nlet bin_write_mat = bin_write_float64_mat\n\nlet bin_write_bigstring buf ~pos s =\n let len = Array1.dim s in\n let plen = Nat0.unsafe_of_int len in\n let pos = bin_write_nat0 buf ~pos plen in\n let next = pos + len in\n check_next buf next;\n unsafe_blit_buf ~src:s ~src_pos:0 ~dst:buf ~dst_pos:pos ~len;\n next\n;;\n\nlet bin_write_variant_int buf ~pos x =\n assert_pos pos;\n let next = pos + 4 in\n check_next buf next;\n unsafe_set32le buf pos (Int32.logor (Int32.shift_left (Int32.of_int x) 1) 1l);\n next\n;;\n\nlet bin_write_int_8bit buf ~pos n =\n assert_pos pos;\n check_pos buf pos;\n unsafe_set8 buf pos n;\n pos + 1\n;;\n\nlet bin_write_int_16bit buf ~pos n =\n assert_pos pos;\n let next = pos + 2 in\n check_next buf next;\n unsafe_set16le buf pos n;\n next\n;;\n\nlet bin_write_int_32bit buf ~pos n =\n assert_pos pos;\n let next = pos + 4 in\n check_next buf next;\n unsafe_set32le buf pos (Int32.of_int n);\n next\n;;\n\nlet bin_write_int_64bit buf ~pos n =\n assert_pos pos;\n let next = pos + 8 in\n check_next buf next;\n unsafe_set64le buf pos (Int64.of_int n);\n next\n;;\n\nlet bin_write_int64_bits buf ~pos n =\n assert_pos pos;\n let next = pos + 8 in\n check_next buf next;\n unsafe_set64le buf pos n;\n next\n;;\n\nlet bin_write_network16_int buf ~pos n =\n assert_pos pos;\n let next = pos + 2 in\n check_next buf next;\n unsafe_set16be buf pos n;\n next\n;;\n\nlet bin_write_network32_int buf ~pos n =\n assert_pos pos;\n let next = pos + 4 in\n check_next buf next;\n unsafe_set32be buf pos (Int32.of_int n);\n next\n;;\n\nlet bin_write_network32_int32 buf ~pos n =\n assert_pos pos;\n let next = pos + 4 in\n check_next buf next;\n unsafe_set32be buf pos n;\n next\n;;\n\nlet bin_write_network64_int buf ~pos n =\n assert_pos pos;\n let next = pos + 8 in\n check_next buf next;\n unsafe_set64be buf pos (Int64.of_int n);\n next\n;;\n\nlet bin_write_network64_int64 buf ~pos n =\n assert_pos pos;\n let next = pos + 8 in\n check_next buf next;\n unsafe_set64be buf pos n;\n next\n;;\n\nlet bin_write_array_no_length bin_write_el buf ~pos ar =\n bin_write_array_loop bin_write_el buf ~els_pos:pos ~n:(Array.length ar) ar\n;;\n\nexternal unsafe_string_get32 : string -> int -> int32 = \"%caml_string_get32u\"\nexternal unsafe_string_get64 : string -> int -> int64 = \"%caml_string_get64u\"\n\nlet bin_write_md5 buf ~pos x =\n let x = Md5_lib.to_binary x in\n assert (String.length x = 16);\n assert_pos pos;\n let next = pos + 16 in\n check_next buf next;\n if arch_sixtyfour\n then (\n let a = unsafe_string_get64 x 0 in\n let b = unsafe_string_get64 x 8 in\n unsafe_set64 buf pos a;\n unsafe_set64 buf (pos + 8) b)\n else (\n let a = unsafe_string_get32 x 0 in\n let b = unsafe_string_get32 x 4 in\n let c = unsafe_string_get32 x 8 in\n let d = unsafe_string_get32 x 12 in\n unsafe_set32 buf pos a;\n unsafe_set32 buf (pos + 4) b;\n unsafe_set32 buf (pos + 8) c;\n unsafe_set32 buf (pos + 12) d);\n next\n;;\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Damien Doligez, projet Para, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1997 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* Internals of forcing lazy values. *)\n\ntype 'a t = 'a lazy_t\n\nexception Undefined\n\nlet raise_undefined = Obj.repr (fun () -> raise Undefined)\n\nexternal make_forward : Obj.t -> Obj.t -> unit = \"caml_obj_make_forward\"\n\n(* Assume [blk] is a block with tag lazy *)\nlet force_lazy_block (blk : 'arg lazy_t) =\n let closure = (Obj.obj (Obj.field (Obj.repr blk) 0) : unit -> 'arg) in\n Obj.set_field (Obj.repr blk) 0 raise_undefined;\n try\n let result = closure () in\n make_forward (Obj.repr blk) (Obj.repr result);\n result\n with e ->\n Obj.set_field (Obj.repr blk) 0 (Obj.repr (fun () -> raise e));\n raise e\n\n\n(* Assume [blk] is a block with tag lazy *)\nlet force_val_lazy_block (blk : 'arg lazy_t) =\n let closure = (Obj.obj (Obj.field (Obj.repr blk) 0) : unit -> 'arg) in\n Obj.set_field (Obj.repr blk) 0 raise_undefined;\n let result = closure () in\n make_forward (Obj.repr blk) (Obj.repr result);\n result\n\n\n(* [force] is not used, since [Lazy.force] is declared as a primitive\n whose code inlines the tag tests of its argument, except when afl\n instrumentation is turned on. *)\n\nlet force (lzv : 'arg lazy_t) =\n (* Using [Sys.opaque_identity] prevents two potential problems:\n - If the value is known to have Forward_tag, then its tag could have\n changed during GC, so that information must be forgotten (see GPR#713\n and issue #7301)\n - If the value is known to be immutable, then if the compiler\n cannot prove that the last branch is not taken it will issue a\n warning 59 (modification of an immutable value) *)\n let lzv = Sys.opaque_identity lzv in\n let x = Obj.repr lzv in\n let t = Obj.tag x in\n if t = Obj.forward_tag then (Obj.obj (Obj.field x 0) : 'arg) else\n if t <> Obj.lazy_tag then (Obj.obj x : 'arg)\n else force_lazy_block lzv\n\n\nlet force_val (lzv : 'arg lazy_t) =\n let x = Obj.repr lzv in\n let t = Obj.tag x in\n if t = Obj.forward_tag then (Obj.obj (Obj.field x 0) : 'arg) else\n if t <> Obj.lazy_tag then (Obj.obj x : 'arg)\n else force_val_lazy_block lzv\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Damien Doligez, projet Para, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1997 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* Module [Lazy]: deferred computations *)\n\n\n(*\n WARNING: some purple magic is going on here. Do not take this file\n as an example of how to program in OCaml.\n*)\n\n\n(* We make use of two special tags provided by the runtime:\n [lazy_tag] and [forward_tag].\n\n A value of type ['a Lazy.t] can be one of three things:\n 1. A block of size 1 with tag [lazy_tag]. Its field is a closure of\n type [unit -> 'a] that computes the value.\n 2. A block of size 1 with tag [forward_tag]. Its field is the value\n of type ['a] that was computed.\n 3. Anything else except a float. This has type ['a] and is the value\n that was computed.\n Exceptions are stored in format (1).\n The GC will magically change things from (2) to (3) according to its\n fancy.\n\n If OCaml was configured with the -flat-float-array option (which is\n currently the default), the following is also true:\n We cannot use representation (3) for a [float Lazy.t] because\n [caml_make_array] assumes that only a [float] value can have tag\n [Double_tag].\n\n We have to use the built-in type constructor [lazy_t] to\n let the compiler implement the special typing and compilation\n rules for the [lazy] keyword.\n*)\n\ntype 'a t = 'a CamlinternalLazy.t\n\nexception Undefined = CamlinternalLazy.Undefined\n\nexternal make_forward : 'a -> 'a lazy_t = \"caml_lazy_make_forward\"\n\nexternal force : 'a t -> 'a = \"%lazy_force\"\n\n\nlet force_val = CamlinternalLazy.force_val\n\nlet from_fun (f : unit -> 'arg) =\n let x = Obj.new_block Obj.lazy_tag 1 in\n Obj.set_field x 0 (Obj.repr f);\n (Obj.obj x : 'arg t)\n\nlet from_val (v : 'arg) =\n let t = Obj.tag (Obj.repr v) in\n if t = Obj.forward_tag || t = Obj.lazy_tag || t = Obj.double_tag then begin\n make_forward v\n end else begin\n (Obj.magic v : 'arg t)\n end\n\n\nlet is_val (l : 'arg t) = Obj.tag (Obj.repr l) <> Obj.lazy_tag\n\nlet lazy_from_fun = from_fun\n\nlet lazy_from_val = from_val\n\nlet lazy_is_val = is_val\n\n\nlet map f x =\n lazy (f (force x))\n\nlet map_val f x =\n if is_val x\n then lazy_from_val (f (force x))\n else lazy (f (force x))\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Simon Cruanes *)\n(* *)\n(* Copyright 2017 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* Module [Seq]: functional iterators *)\n\ntype +'a node =\n | Nil\n | Cons of 'a * 'a t\n\nand 'a t = unit -> 'a node\n\nlet empty () = Nil\n\nlet return x () = Cons (x, empty)\n\nlet cons x next () = Cons (x, next)\n\nlet rec append seq1 seq2 () =\n match seq1() with\n | Nil -> seq2()\n | Cons (x, next) -> Cons (x, append next seq2)\n\nlet rec map f seq () = match seq() with\n | Nil -> Nil\n | Cons (x, next) -> Cons (f x, map f next)\n\nlet rec filter_map f seq () = match seq() with\n | Nil -> Nil\n | Cons (x, next) ->\n match f x with\n | None -> filter_map f next ()\n | Some y -> Cons (y, filter_map f next)\n\nlet rec filter f seq () = match seq() with\n | Nil -> Nil\n | Cons (x, next) ->\n if f x\n then Cons (x, filter f next)\n else filter f next ()\n\nlet rec concat seq () = match seq () with\n | Nil -> Nil\n | Cons (x, next) ->\n append x (concat next) ()\n\nlet rec flat_map f seq () = match seq () with\n | Nil -> Nil\n | Cons (x, next) ->\n append (f x) (flat_map f next) ()\n\nlet concat_map = flat_map\n\nlet rec fold_left f acc seq =\n match seq () with\n | Nil -> acc\n | Cons (x, next) ->\n let acc = f acc x in\n fold_left f acc next\n\nlet rec iter f seq =\n match seq () with\n | Nil -> ()\n | Cons (x, next) ->\n f x;\n iter f next\n\nlet rec unfold f u () =\n match f u with\n | None -> Nil\n | Some (x, u') -> Cons (x, unfold f u')\n\nlet is_empty xs =\n match xs() with\n | Nil ->\n true\n | Cons (_, _) ->\n false\n\nlet uncons xs =\n match xs() with\n | Cons (x, xs) ->\n Some (x, xs)\n | Nil ->\n None\n\n\n\nlet rec length_aux accu xs =\n match xs() with\n | Nil ->\n accu\n | Cons (_, xs) ->\n length_aux (accu + 1) xs\n\nlet[@inline] length xs =\n length_aux 0 xs\n\nlet rec iteri_aux f i xs =\n match xs() with\n | Nil ->\n ()\n | Cons (x, xs) ->\n f i x;\n iteri_aux f (i+1) xs\n\nlet[@inline] iteri f xs =\n iteri_aux f 0 xs\n\nlet rec fold_lefti_aux f accu i xs =\n match xs() with\n | Nil ->\n accu\n | Cons (x, xs) ->\n let accu = f accu i x in\n fold_lefti_aux f accu (i+1) xs\n\nlet[@inline] fold_lefti f accu xs =\n fold_lefti_aux f accu 0 xs\n\nlet rec for_all p xs =\n match xs() with\n | Nil ->\n true\n | Cons (x, xs) ->\n p x && for_all p xs\n\nlet rec exists p xs =\n match xs() with\n | Nil ->\n false\n | Cons (x, xs) ->\n p x || exists p xs\n\nlet rec find p xs =\n match xs() with\n | Nil ->\n None\n | Cons (x, xs) ->\n if p x then Some x else find p xs\n\nlet rec find_map f xs =\n match xs() with\n | Nil ->\n None\n | Cons (x, xs) ->\n match f x with\n | None ->\n find_map f xs\n | Some _ as result ->\n result\n\n(* [iter2], [fold_left2], [for_all2], [exists2], [map2], [zip] work also in\n the case where the two sequences have different lengths. They stop as soon\n as one sequence is exhausted. Their behavior is slightly asymmetric: when\n [xs] is empty, they do not force [ys]; however, when [ys] is empty, [xs] is\n forced, even though the result of the function application [xs()] turns out\n to be useless. *)\n\nlet rec iter2 f xs ys =\n match xs() with\n | Nil ->\n ()\n | Cons (x, xs) ->\n match ys() with\n | Nil ->\n ()\n | Cons (y, ys) ->\n f x y;\n iter2 f xs ys\n\nlet rec fold_left2 f accu xs ys =\n match xs() with\n | Nil ->\n accu\n | Cons (x, xs) ->\n match ys() with\n | Nil ->\n accu\n | Cons (y, ys) ->\n let accu = f accu x y in\n fold_left2 f accu xs ys\n\nlet rec for_all2 f xs ys =\n match xs() with\n | Nil ->\n true\n | Cons (x, xs) ->\n match ys() with\n | Nil ->\n true\n | Cons (y, ys) ->\n f x y && for_all2 f xs ys\n\nlet rec exists2 f xs ys =\n match xs() with\n | Nil ->\n false\n | Cons (x, xs) ->\n match ys() with\n | Nil ->\n false\n | Cons (y, ys) ->\n f x y || exists2 f xs ys\n\nlet rec equal eq xs ys =\n match xs(), ys() with\n | Nil, Nil ->\n true\n | Cons (x, xs), Cons (y, ys) ->\n eq x y && equal eq xs ys\n | Nil, Cons (_, _)\n | Cons (_, _), Nil ->\n false\n\nlet rec compare cmp xs ys =\n match xs(), ys() with\n | Nil, Nil ->\n 0\n | Cons (x, xs), Cons (y, ys) ->\n let c = cmp x y in\n if c <> 0 then c else compare cmp xs ys\n | Nil, Cons (_, _) ->\n -1\n | Cons (_, _), Nil ->\n +1\n\n\n\n(* [init_aux f i j] is the sequence [f i, ..., f (j-1)]. *)\n\nlet rec init_aux f i j () =\n if i < j then begin\n Cons (f i, init_aux f (i + 1) j)\n end\n else\n Nil\n\nlet init n f =\n if n < 0 then\n invalid_arg \"Seq.init\"\n else\n init_aux f 0 n\n\nlet rec repeat x () =\n Cons (x, repeat x)\n\nlet rec forever f () =\n Cons (f(), forever f)\n\n(* This preliminary definition of [cycle] requires the sequence [xs]\n to be nonempty. Applying it to an empty sequence would produce a\n sequence that diverges when it is forced. *)\n\nlet rec cycle_nonempty xs () =\n append xs (cycle_nonempty xs) ()\n\n(* [cycle xs] checks whether [xs] is empty and, if so, returns an empty\n sequence. Otherwise, [cycle xs] produces one copy of [xs] followed\n with the infinite sequence [cycle_nonempty xs]. Thus, the nonemptiness\n check is performed just once. *)\n\nlet cycle xs () =\n match xs() with\n | Nil ->\n Nil\n | Cons (x, xs') ->\n Cons (x, append xs' (cycle_nonempty xs))\n\n(* [iterate1 f x] is the sequence [f x, f (f x), ...].\n It is equivalent to [tail (iterate f x)].\n [iterate1] is used as a building block in the definition of [iterate]. *)\n\nlet rec iterate1 f x () =\n let y = f x in\n Cons (y, iterate1 f y)\n\n(* [iterate f x] is the sequence [x, f x, ...]. *)\n\n(* The reason why we give this slightly indirect definition of [iterate],\n as opposed to the more naive definition that may come to mind, is that\n we are careful to avoid evaluating [f x] until this function call is\n actually necessary. The naive definition (not shown here) computes the\n second argument of the sequence, [f x], when the first argument is\n requested by the user. *)\n\nlet iterate f x =\n cons x (iterate1 f x)\n\n\n\nlet rec mapi_aux f i xs () =\n match xs() with\n | Nil ->\n Nil\n | Cons (x, xs) ->\n Cons (f i x, mapi_aux f (i+1) xs)\n\nlet[@inline] mapi f xs =\n mapi_aux f 0 xs\n\n(* [tail_scan f s xs] is equivalent to [tail (scan f s xs)].\n [tail_scan] is used as a building block in the definition of [scan]. *)\n\n(* This slightly indirect definition of [scan] is meant to avoid computing\n elements too early; see the above comment about [iterate1] and [iterate]. *)\n\nlet rec tail_scan f s xs () =\n match xs() with\n | Nil ->\n Nil\n | Cons (x, xs) ->\n let s = f s x in\n Cons (s, tail_scan f s xs)\n\nlet scan f s xs =\n cons s (tail_scan f s xs)\n\n(* [take] is defined in such a way that [take 0 xs] returns [empty]\n immediately, without allocating any memory. *)\n\nlet rec take_aux n xs =\n if n = 0 then\n empty\n else\n fun () ->\n match xs() with\n | Nil ->\n Nil\n | Cons (x, xs) ->\n Cons (x, take_aux (n-1) xs)\n\nlet take n xs =\n if n < 0 then invalid_arg \"Seq.take\";\n take_aux n xs\n\n(* [force_drop n xs] is equivalent to [drop n xs ()].\n [force_drop n xs] requires [n > 0].\n [force_drop] is used as a building block in the definition of [drop]. *)\n\nlet rec force_drop n xs =\n match xs() with\n | Nil ->\n Nil\n | Cons (_, xs) ->\n let n = n - 1 in\n if n = 0 then\n xs()\n else\n force_drop n xs\n\n(* [drop] is defined in such a way that [drop 0 xs] returns [xs] immediately,\n without allocating any memory. *)\n\nlet drop n xs =\n if n < 0 then invalid_arg \"Seq.drop\"\n else if n = 0 then\n xs\n else\n fun () ->\n force_drop n xs\n\nlet rec take_while p xs () =\n match xs() with\n | Nil ->\n Nil\n | Cons (x, xs) ->\n if p x then Cons (x, take_while p xs) else Nil\n\nlet rec drop_while p xs () =\n match xs() with\n | Nil ->\n Nil\n | Cons (x, xs) as node ->\n if p x then drop_while p xs () else node\n\nlet rec group eq xs () =\n match xs() with\n | Nil ->\n Nil\n | Cons (x, xs) ->\n Cons (cons x (take_while (eq x) xs), group eq (drop_while (eq x) xs))\n\nexception Forced_twice\n\nmodule Suspension = struct\n\n type 'a suspension =\n unit -> 'a\n\n (* Conversions. *)\n\n let to_lazy : 'a suspension -> 'a Lazy.t =\n Lazy.from_fun\n (* fun s -> lazy (s()) *)\n\n let from_lazy (s : 'a Lazy.t) : 'a suspension =\n fun () -> Lazy.force s\n\n (* [memoize] turns an arbitrary suspension into a persistent suspension. *)\n\n let memoize (s : 'a suspension) : 'a suspension =\n from_lazy (to_lazy s)\n\n (* [failure] is a suspension that fails when forced. *)\n\n let failure : _ suspension =\n fun () ->\n (* A suspension created by [once] has been forced twice. *)\n raise Forced_twice\n\n (* If [f] is a suspension, then [once f] is a suspension that can be forced\n at most once. If it is forced more than once, then [Forced_twice] is\n raised. *)\n\n let once (f : 'a suspension) : 'a suspension =\n let action = CamlinternalAtomic.make f in\n fun () ->\n (* Get the function currently stored in [action], and write the\n function [failure] in its place, so the next access will result\n in a call to [failure()]. *)\n let f = CamlinternalAtomic.exchange action failure in\n f()\n\nend (* Suspension *)\n\nlet rec memoize xs =\n Suspension.memoize (fun () ->\n match xs() with\n | Nil ->\n Nil\n | Cons (x, xs) ->\n Cons (x, memoize xs)\n )\n\nlet rec once xs =\n Suspension.once (fun () ->\n match xs() with\n | Nil ->\n Nil\n | Cons (x, xs) ->\n Cons (x, once xs)\n )\n\n\nlet rec zip xs ys () =\n match xs() with\n | Nil ->\n Nil\n | Cons (x, xs) ->\n match ys() with\n | Nil ->\n Nil\n | Cons (y, ys) ->\n Cons ((x, y), zip xs ys)\n\nlet rec map2 f xs ys () =\n match xs() with\n | Nil ->\n Nil\n | Cons (x, xs) ->\n match ys() with\n | Nil ->\n Nil\n | Cons (y, ys) ->\n Cons (f x y, map2 f xs ys)\n\nlet rec interleave xs ys () =\n match xs() with\n | Nil ->\n ys()\n | Cons (x, xs) ->\n Cons (x, interleave ys xs)\n\n(* [sorted_merge1l cmp x xs ys] is equivalent to\n [sorted_merge cmp (cons x xs) ys].\n\n [sorted_merge1r cmp xs y ys] is equivalent to\n [sorted_merge cmp xs (cons y ys)].\n\n [sorted_merge1 cmp x xs y ys] is equivalent to\n [sorted_merge cmp (cons x xs) (cons y ys)].\n\n These three functions are used as building blocks in the definition\n of [sorted_merge]. *)\n\nlet rec sorted_merge1l cmp x xs ys () =\n match ys() with\n | Nil ->\n Cons (x, xs)\n | Cons (y, ys) ->\n sorted_merge1 cmp x xs y ys\n\nand sorted_merge1r cmp xs y ys () =\n match xs() with\n | Nil ->\n Cons (y, ys)\n | Cons (x, xs) ->\n sorted_merge1 cmp x xs y ys\n\nand sorted_merge1 cmp x xs y ys =\n if cmp x y <= 0 then\n Cons (x, sorted_merge1r cmp xs y ys)\n else\n Cons (y, sorted_merge1l cmp x xs ys)\n\nlet sorted_merge cmp xs ys () =\n match xs(), ys() with\n | Nil, Nil ->\n Nil\n | Nil, c\n | c, Nil ->\n c\n | Cons (x, xs), Cons (y, ys) ->\n sorted_merge1 cmp x xs y ys\n\n\nlet rec map_fst xys () =\n match xys() with\n | Nil ->\n Nil\n | Cons ((x, _), xys) ->\n Cons (x, map_fst xys)\n\nlet rec map_snd xys () =\n match xys() with\n | Nil ->\n Nil\n | Cons ((_, y), xys) ->\n Cons (y, map_snd xys)\n\nlet unzip xys =\n map_fst xys, map_snd xys\n\nlet split =\n unzip\n\n(* [filter_map_find_left_map f xs] is equivalent to\n [filter_map Either.find_left (map f xs)]. *)\n\nlet rec filter_map_find_left_map f xs () =\n match xs() with\n | Nil ->\n Nil\n | Cons (x, xs) ->\n match f x with\n | Either.Left y ->\n Cons (y, filter_map_find_left_map f xs)\n | Either.Right _ ->\n filter_map_find_left_map f xs ()\n\nlet rec filter_map_find_right_map f xs () =\n match xs() with\n | Nil ->\n Nil\n | Cons (x, xs) ->\n match f x with\n | Either.Left _ ->\n filter_map_find_right_map f xs ()\n | Either.Right z ->\n Cons (z, filter_map_find_right_map f xs)\n\nlet partition_map f xs =\n filter_map_find_left_map f xs,\n filter_map_find_right_map f xs\n\nlet partition p xs =\n filter p xs, filter (fun x -> not (p x)) xs\n\n(* If [xss] is a matrix (a sequence of rows), then [peel xss] is a pair of\n the first column (a sequence of elements) and of the remainder of the\n matrix (a sequence of shorter rows). These two sequences have the same\n length. The rows of the matrix [xss] are not required to have the same\n length. An empty row is ignored. *)\n\n(* Because [peel] uses [unzip], its argument must be persistent. The same\n remark applies to [transpose], [diagonals], [product], etc. *)\n\nlet peel xss =\n unzip (filter_map uncons xss)\n\nlet rec transpose xss () =\n let heads, tails = peel xss in\n if is_empty heads then begin\n assert (is_empty tails);\n Nil\n end\n else\n Cons (heads, transpose tails)\n\n(* The internal function [diagonals] takes an extra argument, [remainders],\n which contains the remainders of the rows that have already been\n discovered. *)\n\nlet rec diagonals remainders xss () =\n match xss() with\n | Cons (xs, xss) ->\n begin match xs() with\n | Cons (x, xs) ->\n (* We discover a new nonempty row [x :: xs]. Thus, the next diagonal\n is [x :: heads]: this diagonal begins with [x] and continues with\n the first element of every row in [remainders]. In the recursive\n call, the argument [remainders] is instantiated with [xs ::\n tails], which means that we have one more remaining row, [xs],\n and that we keep the tails of the pre-existing remaining rows. *)\n let heads, tails = peel remainders in\n Cons (cons x heads, diagonals (cons xs tails) xss)\n | Nil ->\n (* We discover a new empty row. In this case, the new diagonal is\n just [heads], and [remainders] is instantiated with just [tails],\n as we do not have one more remaining row. *)\n let heads, tails = peel remainders in\n Cons (heads, diagonals tails xss)\n end\n | Nil ->\n (* There are no more rows to be discovered. There remains to exhaust\n the remaining rows. *)\n transpose remainders ()\n\n(* If [xss] is a matrix (a sequence of rows), then [diagonals xss] is\n the sequence of its diagonals.\n\n The first diagonal contains just the first element of the\n first row. The second diagonal contains the first element of the\n second row and the second element of the first row; and so on.\n This kind of diagonal is in fact sometimes known as an antidiagonal.\n\n - Every diagonal is a finite sequence.\n - The rows of the matrix [xss] are not required to have the same length.\n - The matrix [xss] is not required to be finite (in either direction).\n - The matrix [xss] must be persistent. *)\n\nlet diagonals xss =\n diagonals empty xss\n\nlet map_product f xs ys =\n concat (diagonals (\n map (fun x ->\n map (fun y ->\n f x y\n ) ys\n ) xs\n ))\n\nlet product xs ys =\n map_product (fun x y -> (x, y)) xs ys\n\nlet of_dispenser it =\n let rec c () =\n match it() with\n | None ->\n Nil\n | Some x ->\n Cons (x, c)\n in\n c\n\nlet to_dispenser xs =\n let s = ref xs in\n fun () ->\n match (!s)() with\n | Nil ->\n None\n | Cons (x, xs) ->\n s := xs;\n Some x\n\n\n\nlet rec ints i () =\n Cons (i, ints (i + 1))\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* The OCaml programmers *)\n(* *)\n(* Copyright 2018 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\ntype 'a t = 'a option = None | Some of 'a\n\nlet none = None\nlet some v = Some v\nlet value o ~default = match o with Some v -> v | None -> default\nlet get = function Some v -> v | None -> invalid_arg \"option is None\"\nlet bind o f = match o with None -> None | Some v -> f v\nlet join = function Some o -> o | None -> None\nlet map f o = match o with None -> None | Some v -> Some (f v)\nlet fold ~none ~some = function Some v -> some v | None -> none\nlet iter f = function Some v -> f v | None -> ()\nlet is_none = function None -> true | Some _ -> false\nlet is_some = function None -> false | Some _ -> true\n\nlet equal eq o0 o1 = match o0, o1 with\n| Some v0, Some v1 -> eq v0 v1\n| None, None -> true\n| _ -> false\n\nlet compare cmp o0 o1 = match o0, o1 with\n| Some v0, Some v1 -> cmp v0 v1\n| None, None -> 0\n| None, Some _ -> -1\n| Some _, None -> 1\n\nlet to_result ~none = function None -> Error none | Some v -> Ok v\nlet to_list = function None -> [] | Some v -> [v]\nlet to_seq = function None -> Seq.empty | Some v -> Seq.return v\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* The OCaml programmers *)\n(* *)\n(* Copyright 2018 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\ntype ('a, 'e) t = ('a, 'e) result = Ok of 'a | Error of 'e\n\nlet ok v = Ok v\nlet error e = Error e\nlet value r ~default = match r with Ok v -> v | Error _ -> default\nlet get_ok = function Ok v -> v | Error _ -> invalid_arg \"result is Error _\"\nlet get_error = function Error e -> e | Ok _ -> invalid_arg \"result is Ok _\"\nlet bind r f = match r with Ok v -> f v | Error _ as e -> e\nlet join = function Ok r -> r | Error _ as e -> e\nlet map f = function Ok v -> Ok (f v) | Error _ as e -> e\nlet map_error f = function Error e -> Error (f e) | Ok _ as v -> v\nlet fold ~ok ~error = function Ok v -> ok v | Error e -> error e\nlet iter f = function Ok v -> f v | Error _ -> ()\nlet iter_error f = function Error e -> f e | Ok _ -> ()\nlet is_ok = function Ok _ -> true | Error _ -> false\nlet is_error = function Error _ -> true | Ok _ -> false\n\nlet equal ~ok ~error r0 r1 = match r0, r1 with\n| Ok v0, Ok v1 -> ok v0 v1\n| Error e0, Error e1 -> error e0 e1\n| _, _ -> false\n\nlet compare ~ok ~error r0 r1 = match r0, r1 with\n| Ok v0, Ok v1 -> ok v0 v1\n| Error e0, Error e1 -> error e0 e1\n| Ok _, Error _ -> -1\n| Error _, Ok _ -> 1\n\nlet to_option = function Ok v -> Some v | Error _ -> None\nlet to_list = function Ok v -> [v] | Error _ -> []\nlet to_seq = function Ok v -> Seq.return v | Error _ -> Seq.empty\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* Character operations *)\n\nexternal code: char -> int = \"%identity\"\nexternal unsafe_chr: int -> char = \"%identity\"\n\nlet chr n =\n if n < 0 || n > 255 then invalid_arg \"Char.chr\" else unsafe_chr n\n\nexternal bytes_create: int -> bytes = \"caml_create_bytes\"\nexternal bytes_unsafe_set : bytes -> int -> char -> unit\n = \"%bytes_unsafe_set\"\nexternal unsafe_to_string : bytes -> string = \"%bytes_to_string\"\n\nlet escaped = function\n | '\\'' -> \"\\\\'\"\n | '\\\\' -> \"\\\\\\\\\"\n | '\\n' -> \"\\\\n\"\n | '\\t' -> \"\\\\t\"\n | '\\r' -> \"\\\\r\"\n | '\\b' -> \"\\\\b\"\n | ' ' .. '~' as c ->\n let s = bytes_create 1 in\n bytes_unsafe_set s 0 c;\n unsafe_to_string s\n | c ->\n let n = code c in\n let s = bytes_create 4 in\n bytes_unsafe_set s 0 '\\\\';\n bytes_unsafe_set s 1 (unsafe_chr (48 + n / 100));\n bytes_unsafe_set s 2 (unsafe_chr (48 + (n / 10) mod 10));\n bytes_unsafe_set s 3 (unsafe_chr (48 + n mod 10));\n unsafe_to_string s\n\nlet lowercase = function\n | 'A' .. 'Z'\n | '\\192' .. '\\214'\n | '\\216' .. '\\222' as c ->\n unsafe_chr(code c + 32)\n | c -> c\n\nlet uppercase = function\n | 'a' .. 'z'\n | '\\224' .. '\\246'\n | '\\248' .. '\\254' as c ->\n unsafe_chr(code c - 32)\n | c -> c\n\nlet lowercase_ascii = function\n | 'A' .. 'Z' as c -> unsafe_chr(code c + 32)\n | c -> c\n\nlet uppercase_ascii = function\n | 'a' .. 'z' as c -> unsafe_chr(code c - 32)\n | c -> c\n\ntype t = char\n\nlet compare c1 c2 = code c1 - code c2\nlet equal (c1: t) (c2: t) = compare c1 c2 = 0\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* The OCaml programmers *)\n(* *)\n(* Copyright 2018 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\ntype t = int\n\nlet zero = 0\nlet one = 1\nlet minus_one = -1\nexternal neg : int -> int = \"%negint\"\nexternal add : int -> int -> int = \"%addint\"\nexternal sub : int -> int -> int = \"%subint\"\nexternal mul : int -> int -> int = \"%mulint\"\nexternal div : int -> int -> int = \"%divint\"\nexternal rem : int -> int -> int = \"%modint\"\nexternal succ : int -> int = \"%succint\"\nexternal pred : int -> int = \"%predint\"\nlet abs x = if x >= 0 then x else -x\nlet max_int = (-1) lsr 1\nlet min_int = max_int + 1\nexternal logand : int -> int -> int = \"%andint\"\nexternal logor : int -> int -> int = \"%orint\"\nexternal logxor : int -> int -> int = \"%xorint\"\nlet lognot x = logxor x (-1)\nexternal shift_left : int -> int -> int = \"%lslint\"\nexternal shift_right : int -> int -> int = \"%asrint\"\nexternal shift_right_logical : int -> int -> int = \"%lsrint\"\nlet equal : int -> int -> bool = ( = )\nlet compare : int -> int -> int = Stdlib.compare\nlet min x y : t = if x <= y then x else y\nlet max x y : t = if x >= y then x else y\nexternal to_float : int -> float = \"%floatofint\"\nexternal of_float : float -> int = \"%intoffloat\"\n\n(*\nexternal int_of_string : string -> int = \"caml_int_of_string\"\nlet of_string s = try Some (int_of_string s) with Failure _ -> None\n*)\n\nexternal format_int : string -> int -> string = \"caml_format_int\"\nlet to_string x = format_int \"%d\" x\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* Byte sequence operations *)\n\n(* WARNING: Some functions in this file are duplicated in string.ml for\n efficiency reasons. When you modify the one in this file you need to\n modify its duplicate in string.ml.\n These functions have a \"duplicated\" comment above their definition.\n*)\n\nexternal length : bytes -> int = \"%bytes_length\"\nexternal string_length : string -> int = \"%string_length\"\nexternal get : bytes -> int -> char = \"%bytes_safe_get\"\nexternal set : bytes -> int -> char -> unit = \"%bytes_safe_set\"\nexternal create : int -> bytes = \"caml_create_bytes\"\nexternal unsafe_get : bytes -> int -> char = \"%bytes_unsafe_get\"\nexternal unsafe_set : bytes -> int -> char -> unit = \"%bytes_unsafe_set\"\nexternal unsafe_fill : bytes -> int -> int -> char -> unit\n = \"caml_fill_bytes\" [@@noalloc]\nexternal unsafe_to_string : bytes -> string = \"%bytes_to_string\"\nexternal unsafe_of_string : string -> bytes = \"%bytes_of_string\"\n\nexternal unsafe_blit : bytes -> int -> bytes -> int -> int -> unit\n = \"caml_blit_bytes\" [@@noalloc]\nexternal unsafe_blit_string : string -> int -> bytes -> int -> int -> unit\n = \"caml_blit_string\" [@@noalloc]\n\nlet make n c =\n let s = create n in\n unsafe_fill s 0 n c;\n s\n\nlet init n f =\n let s = create n in\n for i = 0 to n - 1 do\n unsafe_set s i (f i)\n done;\n s\n\nlet empty = create 0\n\nlet copy s =\n let len = length s in\n let r = create len in\n unsafe_blit s 0 r 0 len;\n r\n\nlet to_string b = unsafe_to_string (copy b)\nlet of_string s = copy (unsafe_of_string s)\n\nlet sub s ofs len =\n if ofs < 0 || len < 0 || ofs > length s - len\n then invalid_arg \"String.sub / Bytes.sub\"\n else begin\n let r = create len in\n unsafe_blit s ofs r 0 len;\n r\n end\n\nlet sub_string b ofs len = unsafe_to_string (sub b ofs len)\n\n(* addition with an overflow check *)\nlet (++) a b =\n let c = a + b in\n match a < 0, b < 0, c < 0 with\n | true , true , false\n | false, false, true -> invalid_arg \"Bytes.extend\" (* overflow *)\n | _ -> c\n\nlet extend s left right =\n let len = length s ++ left ++ right in\n let r = create len in\n let (srcoff, dstoff) = if left < 0 then -left, 0 else 0, left in\n let cpylen = Int.min (length s - srcoff) (len - dstoff) in\n if cpylen > 0 then unsafe_blit s srcoff r dstoff cpylen;\n r\n\nlet fill s ofs len c =\n if ofs < 0 || len < 0 || ofs > length s - len\n then invalid_arg \"String.fill / Bytes.fill\"\n else unsafe_fill s ofs len c\n\nlet blit s1 ofs1 s2 ofs2 len =\n if len < 0 || ofs1 < 0 || ofs1 > length s1 - len\n || ofs2 < 0 || ofs2 > length s2 - len\n then invalid_arg \"Bytes.blit\"\n else unsafe_blit s1 ofs1 s2 ofs2 len\n\nlet blit_string s1 ofs1 s2 ofs2 len =\n if len < 0 || ofs1 < 0 || ofs1 > string_length s1 - len\n || ofs2 < 0 || ofs2 > length s2 - len\n then invalid_arg \"String.blit / Bytes.blit_string\"\n else unsafe_blit_string s1 ofs1 s2 ofs2 len\n\n(* duplicated in string.ml *)\nlet iter f a =\n for i = 0 to length a - 1 do f(unsafe_get a i) done\n\n(* duplicated in string.ml *)\nlet iteri f a =\n for i = 0 to length a - 1 do f i (unsafe_get a i) done\n\nlet ensure_ge (x:int) y = if x >= y then x else invalid_arg \"Bytes.concat\"\n\nlet rec sum_lengths acc seplen = function\n | [] -> acc\n | hd :: [] -> length hd + acc\n | hd :: tl -> sum_lengths (ensure_ge (length hd + seplen + acc) acc) seplen tl\n\nlet rec unsafe_blits dst pos sep seplen = function\n [] -> dst\n | hd :: [] ->\n unsafe_blit hd 0 dst pos (length hd); dst\n | hd :: tl ->\n unsafe_blit hd 0 dst pos (length hd);\n unsafe_blit sep 0 dst (pos + length hd) seplen;\n unsafe_blits dst (pos + length hd + seplen) sep seplen tl\n\nlet concat sep = function\n [] -> empty\n | l -> let seplen = length sep in\n unsafe_blits\n (create (sum_lengths 0 seplen l))\n 0 sep seplen l\n\nlet cat s1 s2 =\n let l1 = length s1 in\n let l2 = length s2 in\n let r = create (l1 + l2) in\n unsafe_blit s1 0 r 0 l1;\n unsafe_blit s2 0 r l1 l2;\n r\n\n\nexternal char_code: char -> int = \"%identity\"\nexternal char_chr: int -> char = \"%identity\"\n\nlet is_space = function\n | ' ' | '\\012' | '\\n' | '\\r' | '\\t' -> true\n | _ -> false\n\nlet trim s =\n let len = length s in\n let i = ref 0 in\n while !i < len && is_space (unsafe_get s !i) do\n incr i\n done;\n let j = ref (len - 1) in\n while !j >= !i && is_space (unsafe_get s !j) do\n decr j\n done;\n if !j >= !i then\n sub s !i (!j - !i + 1)\n else\n empty\n\nlet escaped s =\n let n = ref 0 in\n for i = 0 to length s - 1 do\n n := !n +\n (match unsafe_get s i with\n | '\\\"' | '\\\\' | '\\n' | '\\t' | '\\r' | '\\b' -> 2\n | ' ' .. '~' -> 1\n | _ -> 4)\n done;\n if !n = length s then copy s else begin\n let s' = create !n in\n n := 0;\n for i = 0 to length s - 1 do\n begin match unsafe_get s i with\n | ('\\\"' | '\\\\') as c ->\n unsafe_set s' !n '\\\\'; incr n; unsafe_set s' !n c\n | '\\n' ->\n unsafe_set s' !n '\\\\'; incr n; unsafe_set s' !n 'n'\n | '\\t' ->\n unsafe_set s' !n '\\\\'; incr n; unsafe_set s' !n 't'\n | '\\r' ->\n unsafe_set s' !n '\\\\'; incr n; unsafe_set s' !n 'r'\n | '\\b' ->\n unsafe_set s' !n '\\\\'; incr n; unsafe_set s' !n 'b'\n | (' ' .. '~') as c -> unsafe_set s' !n c\n | c ->\n let a = char_code c in\n unsafe_set s' !n '\\\\';\n incr n;\n unsafe_set s' !n (char_chr (48 + a / 100));\n incr n;\n unsafe_set s' !n (char_chr (48 + (a / 10) mod 10));\n incr n;\n unsafe_set s' !n (char_chr (48 + a mod 10));\n end;\n incr n\n done;\n s'\n end\n\nlet map f s =\n let l = length s in\n if l = 0 then s else begin\n let r = create l in\n for i = 0 to l - 1 do unsafe_set r i (f (unsafe_get s i)) done;\n r\n end\n\nlet mapi f s =\n let l = length s in\n if l = 0 then s else begin\n let r = create l in\n for i = 0 to l - 1 do unsafe_set r i (f i (unsafe_get s i)) done;\n r\n end\n\nlet fold_left f x a =\n let r = ref x in\n for i = 0 to length a - 1 do\n r := f !r (unsafe_get a i)\n done;\n !r\n\nlet fold_right f a x =\n let r = ref x in\n for i = length a - 1 downto 0 do\n r := f (unsafe_get a i) !r\n done;\n !r\n\nlet exists p s =\n let n = length s in\n let rec loop i =\n if i = n then false\n else if p (unsafe_get s i) then true\n else loop (succ i) in\n loop 0\n\nlet for_all p s =\n let n = length s in\n let rec loop i =\n if i = n then true\n else if p (unsafe_get s i) then loop (succ i)\n else false in\n loop 0\n\nlet uppercase_ascii s = map Char.uppercase_ascii s\nlet lowercase_ascii s = map Char.lowercase_ascii s\n\nlet apply1 f s =\n if length s = 0 then s else begin\n let r = copy s in\n unsafe_set r 0 (f(unsafe_get s 0));\n r\n end\n\nlet capitalize_ascii s = apply1 Char.uppercase_ascii s\nlet uncapitalize_ascii s = apply1 Char.lowercase_ascii s\n\n(* duplicated in string.ml *)\nlet starts_with ~prefix s =\n let len_s = length s\n and len_pre = length prefix in\n let rec aux i =\n if i = len_pre then true\n else if unsafe_get s i <> unsafe_get prefix i then false\n else aux (i + 1)\n in len_s >= len_pre && aux 0\n\n(* duplicated in string.ml *)\nlet ends_with ~suffix s =\n let len_s = length s\n and len_suf = length suffix in\n let diff = len_s - len_suf in\n let rec aux i =\n if i = len_suf then true\n else if unsafe_get s (diff + i) <> unsafe_get suffix i then false\n else aux (i + 1)\n in diff >= 0 && aux 0\n\n(* duplicated in string.ml *)\nlet rec index_rec s lim i c =\n if i >= lim then raise Not_found else\n if unsafe_get s i = c then i else index_rec s lim (i + 1) c\n\n(* duplicated in string.ml *)\nlet index s c = index_rec s (length s) 0 c\n\n(* duplicated in string.ml *)\nlet rec index_rec_opt s lim i c =\n if i >= lim then None else\n if unsafe_get s i = c then Some i else index_rec_opt s lim (i + 1) c\n\n(* duplicated in string.ml *)\nlet index_opt s c = index_rec_opt s (length s) 0 c\n\n(* duplicated in string.ml *)\nlet index_from s i c =\n let l = length s in\n if i < 0 || i > l then invalid_arg \"String.index_from / Bytes.index_from\" else\n index_rec s l i c\n\n(* duplicated in string.ml *)\nlet index_from_opt s i c =\n let l = length s in\n if i < 0 || i > l then\n invalid_arg \"String.index_from_opt / Bytes.index_from_opt\"\n else\n index_rec_opt s l i c\n\n(* duplicated in string.ml *)\nlet rec rindex_rec s i c =\n if i < 0 then raise Not_found else\n if unsafe_get s i = c then i else rindex_rec s (i - 1) c\n\n(* duplicated in string.ml *)\nlet rindex s c = rindex_rec s (length s - 1) c\n\n(* duplicated in string.ml *)\nlet rindex_from s i c =\n if i < -1 || i >= length s then\n invalid_arg \"String.rindex_from / Bytes.rindex_from\"\n else\n rindex_rec s i c\n\n(* duplicated in string.ml *)\nlet rec rindex_rec_opt s i c =\n if i < 0 then None else\n if unsafe_get s i = c then Some i else rindex_rec_opt s (i - 1) c\n\n(* duplicated in string.ml *)\nlet rindex_opt s c = rindex_rec_opt s (length s - 1) c\n\n(* duplicated in string.ml *)\nlet rindex_from_opt s i c =\n if i < -1 || i >= length s then\n invalid_arg \"String.rindex_from_opt / Bytes.rindex_from_opt\"\n else\n rindex_rec_opt s i c\n\n\n(* duplicated in string.ml *)\nlet contains_from s i c =\n let l = length s in\n if i < 0 || i > l then\n invalid_arg \"String.contains_from / Bytes.contains_from\"\n else\n try ignore (index_rec s l i c); true with Not_found -> false\n\n\n(* duplicated in string.ml *)\nlet contains s c = contains_from s 0 c\n\n(* duplicated in string.ml *)\nlet rcontains_from s i c =\n if i < 0 || i >= length s then\n invalid_arg \"String.rcontains_from / Bytes.rcontains_from\"\n else\n try ignore (rindex_rec s i c); true with Not_found -> false\n\n\ntype t = bytes\n\nlet compare (x: t) (y: t) = Stdlib.compare x y\nexternal equal : t -> t -> bool = \"caml_bytes_equal\" [@@noalloc]\n\n(* duplicated in string.ml *)\nlet split_on_char sep s =\n let r = ref [] in\n let j = ref (length s) in\n for i = length s - 1 downto 0 do\n if unsafe_get s i = sep then begin\n r := sub s (i + 1) (!j - i - 1) :: !r;\n j := i\n end\n done;\n sub s 0 !j :: !r\n\n(* Deprecated functions implemented via other deprecated functions *)\n[@@@ocaml.warning \"-3\"]\nlet uppercase s = map Char.uppercase s\nlet lowercase s = map Char.lowercase s\n\nlet capitalize s = apply1 Char.uppercase s\nlet uncapitalize s = apply1 Char.lowercase s\n\n(** {1 Iterators} *)\n\nlet to_seq s =\n let rec aux i () =\n if i = length s then Seq.Nil\n else\n let x = get s i in\n Seq.Cons (x, aux (i+1))\n in\n aux 0\n\nlet to_seqi s =\n let rec aux i () =\n if i = length s then Seq.Nil\n else\n let x = get s i in\n Seq.Cons ((i,x), aux (i+1))\n in\n aux 0\n\nlet of_seq i =\n let n = ref 0 in\n let buf = ref (make 256 '\\000') in\n let resize () =\n (* resize *)\n let new_len = Int.min (2 * length !buf) Sys.max_string_length in\n if length !buf = new_len then failwith \"Bytes.of_seq: cannot grow bytes\";\n let new_buf = make new_len '\\000' in\n blit !buf 0 new_buf 0 !n;\n buf := new_buf\n in\n Seq.iter\n (fun c ->\n if !n = length !buf then resize();\n set !buf !n c;\n incr n)\n i;\n sub !buf 0 !n\n\n(** {6 Binary encoding/decoding of integers} *)\n\n(* The get_ functions are all duplicated in string.ml *)\n\nexternal unsafe_get_uint8 : bytes -> int -> int = \"%bytes_unsafe_get\"\nexternal unsafe_get_uint16_ne : bytes -> int -> int = \"%caml_bytes_get16u\"\nexternal get_uint8 : bytes -> int -> int = \"%bytes_safe_get\"\nexternal get_uint16_ne : bytes -> int -> int = \"%caml_bytes_get16\"\nexternal get_int32_ne : bytes -> int -> int32 = \"%caml_bytes_get32\"\nexternal get_int64_ne : bytes -> int -> int64 = \"%caml_bytes_get64\"\n\nexternal unsafe_set_uint8 : bytes -> int -> int -> unit = \"%bytes_unsafe_set\"\nexternal unsafe_set_uint16_ne : bytes -> int -> int -> unit\n = \"%caml_bytes_set16u\"\nexternal set_int8 : bytes -> int -> int -> unit = \"%bytes_safe_set\"\nexternal set_int16_ne : bytes -> int -> int -> unit = \"%caml_bytes_set16\"\nexternal set_int32_ne : bytes -> int -> int32 -> unit = \"%caml_bytes_set32\"\nexternal set_int64_ne : bytes -> int -> int64 -> unit = \"%caml_bytes_set64\"\nexternal swap16 : int -> int = \"%bswap16\"\nexternal swap32 : int32 -> int32 = \"%bswap_int32\"\nexternal swap64 : int64 -> int64 = \"%bswap_int64\"\n\nlet unsafe_get_uint16_le b i =\n if Sys.big_endian\n then swap16 (unsafe_get_uint16_ne b i)\n else unsafe_get_uint16_ne b i\n\nlet unsafe_get_uint16_be b i =\n if Sys.big_endian\n then unsafe_get_uint16_ne b i\n else swap16 (unsafe_get_uint16_ne b i)\n\nlet get_int8 b i =\n ((get_uint8 b i) lsl (Sys.int_size - 8)) asr (Sys.int_size - 8)\n\nlet get_uint16_le b i =\n if Sys.big_endian then swap16 (get_uint16_ne b i)\n else get_uint16_ne b i\n\nlet get_uint16_be b i =\n if not Sys.big_endian then swap16 (get_uint16_ne b i)\n else get_uint16_ne b i\n\nlet get_int16_ne b i =\n ((get_uint16_ne b i) lsl (Sys.int_size - 16)) asr (Sys.int_size - 16)\n\nlet get_int16_le b i =\n ((get_uint16_le b i) lsl (Sys.int_size - 16)) asr (Sys.int_size - 16)\n\nlet get_int16_be b i =\n ((get_uint16_be b i) lsl (Sys.int_size - 16)) asr (Sys.int_size - 16)\n\nlet get_int32_le b i =\n if Sys.big_endian then swap32 (get_int32_ne b i)\n else get_int32_ne b i\n\nlet get_int32_be b i =\n if not Sys.big_endian then swap32 (get_int32_ne b i)\n else get_int32_ne b i\n\nlet get_int64_le b i =\n if Sys.big_endian then swap64 (get_int64_ne b i)\n else get_int64_ne b i\n\nlet get_int64_be b i =\n if not Sys.big_endian then swap64 (get_int64_ne b i)\n else get_int64_ne b i\n\nlet unsafe_set_uint16_le b i x =\n if Sys.big_endian\n then unsafe_set_uint16_ne b i (swap16 x)\n else unsafe_set_uint16_ne b i x\n\nlet unsafe_set_uint16_be b i x =\n if Sys.big_endian\n then unsafe_set_uint16_ne b i x else\n unsafe_set_uint16_ne b i (swap16 x)\n\nlet set_int16_le b i x =\n if Sys.big_endian then set_int16_ne b i (swap16 x)\n else set_int16_ne b i x\n\nlet set_int16_be b i x =\n if not Sys.big_endian then set_int16_ne b i (swap16 x)\n else set_int16_ne b i x\n\nlet set_int32_le b i x =\n if Sys.big_endian then set_int32_ne b i (swap32 x)\n else set_int32_ne b i x\n\nlet set_int32_be b i x =\n if not Sys.big_endian then set_int32_ne b i (swap32 x)\n else set_int32_ne b i x\n\nlet set_int64_le b i x =\n if Sys.big_endian then set_int64_ne b i (swap64 x)\n else set_int64_ne b i x\n\nlet set_int64_be b i x =\n if not Sys.big_endian then set_int64_ne b i (swap64 x)\n else set_int64_ne b i x\n\nlet set_uint8 = set_int8\nlet set_uint16_ne = set_int16_ne\nlet set_uint16_be = set_int16_be\nlet set_uint16_le = set_int16_le\n\n(* UTF codecs and validations *)\n\nlet dec_invalid = Uchar.utf_decode_invalid\nlet[@inline] dec_ret n u = Uchar.utf_decode n (Uchar.unsafe_of_int u)\n\n(* In case of decoding error, if we error on the first byte, we\n consume the byte, otherwise we consume the [n] bytes preceeding\n the erroring byte.\n\n This means that if a client uses decodes without caring about\n validity it naturally replace bogus data with Uchar.rep according\n to the WHATWG Encoding standard. Other schemes are possible by\n consulting the number of used bytes on invalid decodes. For more\n details see https://hsivonen.fi/broken-utf-8/\n\n For this reason in [get_utf_8_uchar] we gradually check the next\n byte is available rather than doing it immediately after the\n first byte. Contrast with [is_valid_utf_8]. *)\n\n(* UTF-8 *)\n\nlet[@inline] not_in_x80_to_xBF b = b lsr 6 <> 0b10\nlet[@inline] not_in_xA0_to_xBF b = b lsr 5 <> 0b101\nlet[@inline] not_in_x80_to_x9F b = b lsr 5 <> 0b100\nlet[@inline] not_in_x90_to_xBF b = b < 0x90 || 0xBF < b\nlet[@inline] not_in_x80_to_x8F b = b lsr 4 <> 0x8\n\nlet[@inline] utf_8_uchar_2 b0 b1 =\n ((b0 land 0x1F) lsl 6) lor\n ((b1 land 0x3F))\n\nlet[@inline] utf_8_uchar_3 b0 b1 b2 =\n ((b0 land 0x0F) lsl 12) lor\n ((b1 land 0x3F) lsl 6) lor\n ((b2 land 0x3F))\n\nlet[@inline] utf_8_uchar_4 b0 b1 b2 b3 =\n ((b0 land 0x07) lsl 18) lor\n ((b1 land 0x3F) lsl 12) lor\n ((b2 land 0x3F) lsl 6) lor\n ((b3 land 0x3F))\n\nlet get_utf_8_uchar b i =\n let b0 = get_uint8 b i in (* raises if [i] is not a valid index. *)\n let get = unsafe_get_uint8 in\n let max = length b - 1 in\n match Char.unsafe_chr b0 with (* See The Unicode Standard, Table 3.7 *)\n | '\\x00' .. '\\x7F' -> dec_ret 1 b0\n | '\\xC2' .. '\\xDF' ->\n let i = i + 1 in if i > max then dec_invalid 1 else\n let b1 = get b i in if not_in_x80_to_xBF b1 then dec_invalid 1 else\n dec_ret 2 (utf_8_uchar_2 b0 b1)\n | '\\xE0' ->\n let i = i + 1 in if i > max then dec_invalid 1 else\n let b1 = get b i in if not_in_xA0_to_xBF b1 then dec_invalid 1 else\n let i = i + 1 in if i > max then dec_invalid 2 else\n let b2 = get b i in if not_in_x80_to_xBF b2 then dec_invalid 2 else\n dec_ret 3 (utf_8_uchar_3 b0 b1 b2)\n | '\\xE1' .. '\\xEC' | '\\xEE' .. '\\xEF' ->\n let i = i + 1 in if i > max then dec_invalid 1 else\n let b1 = get b i in if not_in_x80_to_xBF b1 then dec_invalid 1 else\n let i = i + 1 in if i > max then dec_invalid 2 else\n let b2 = get b i in if not_in_x80_to_xBF b2 then dec_invalid 2 else\n dec_ret 3 (utf_8_uchar_3 b0 b1 b2)\n | '\\xED' ->\n let i = i + 1 in if i > max then dec_invalid 1 else\n let b1 = get b i in if not_in_x80_to_x9F b1 then dec_invalid 1 else\n let i = i + 1 in if i > max then dec_invalid 2 else\n let b2 = get b i in if not_in_x80_to_xBF b2 then dec_invalid 2 else\n dec_ret 3 (utf_8_uchar_3 b0 b1 b2)\n | '\\xF0' ->\n let i = i + 1 in if i > max then dec_invalid 1 else\n let b1 = get b i in if not_in_x90_to_xBF b1 then dec_invalid 1 else\n let i = i + 1 in if i > max then dec_invalid 2 else\n let b2 = get b i in if not_in_x80_to_xBF b2 then dec_invalid 2 else\n let i = i + 1 in if i > max then dec_invalid 3 else\n let b3 = get b i in if not_in_x80_to_xBF b3 then dec_invalid 3 else\n dec_ret 4 (utf_8_uchar_4 b0 b1 b2 b3)\n | '\\xF1' .. '\\xF3' ->\n let i = i + 1 in if i > max then dec_invalid 1 else\n let b1 = get b i in if not_in_x80_to_xBF b1 then dec_invalid 1 else\n let i = i + 1 in if i > max then dec_invalid 2 else\n let b2 = get b i in if not_in_x80_to_xBF b2 then dec_invalid 2 else\n let i = i + 1 in if i > max then dec_invalid 3 else\n let b3 = get b i in if not_in_x80_to_xBF b3 then dec_invalid 3 else\n dec_ret 4 (utf_8_uchar_4 b0 b1 b2 b3)\n | '\\xF4' ->\n let i = i + 1 in if i > max then dec_invalid 1 else\n let b1 = get b i in if not_in_x80_to_x8F b1 then dec_invalid 1 else\n let i = i + 1 in if i > max then dec_invalid 2 else\n let b2 = get b i in if not_in_x80_to_xBF b2 then dec_invalid 2 else\n let i = i + 1 in if i > max then dec_invalid 3 else\n let b3 = get b i in if not_in_x80_to_xBF b3 then dec_invalid 3 else\n dec_ret 4 (utf_8_uchar_4 b0 b1 b2 b3)\n | _ -> dec_invalid 1\n\nlet set_utf_8_uchar b i u =\n let set = unsafe_set_uint8 in\n let max = length b - 1 in\n match Uchar.to_int u with\n | u when u < 0 -> assert false\n | u when u <= 0x007F ->\n set_uint8 b i u;\n 1\n | u when u <= 0x07FF ->\n let last = i + 1 in\n if last > max then 0 else\n (set_uint8 b i (0xC0 lor (u lsr 6));\n set b last (0x80 lor (u land 0x3F));\n 2)\n | u when u <= 0xFFFF ->\n let last = i + 2 in\n if last > max then 0 else\n (set_uint8 b i (0xE0 lor (u lsr 12));\n set b (i + 1) (0x80 lor ((u lsr 6) land 0x3F));\n set b last (0x80 lor (u land 0x3F));\n 3)\n | u when u <= 0x10FFFF ->\n let last = i + 3 in\n if last > max then 0 else\n (set_uint8 b i (0xF0 lor (u lsr 18));\n set b (i + 1) (0x80 lor ((u lsr 12) land 0x3F));\n set b (i + 2) (0x80 lor ((u lsr 6) land 0x3F));\n set b last (0x80 lor (u land 0x3F));\n 4)\n | _ -> assert false\n\nlet is_valid_utf_8 b =\n let rec loop max b i =\n if i > max then true else\n let get = unsafe_get_uint8 in\n match Char.unsafe_chr (get b i) with\n | '\\x00' .. '\\x7F' -> loop max b (i + 1)\n | '\\xC2' .. '\\xDF' ->\n let last = i + 1 in\n if last > max\n || not_in_x80_to_xBF (get b last)\n then false\n else loop max b (last + 1)\n | '\\xE0' ->\n let last = i + 2 in\n if last > max\n || not_in_xA0_to_xBF (get b (i + 1))\n || not_in_x80_to_xBF (get b last)\n then false\n else loop max b (last + 1)\n | '\\xE1' .. '\\xEC' | '\\xEE' .. '\\xEF' ->\n let last = i + 2 in\n if last > max\n || not_in_x80_to_xBF (get b (i + 1))\n || not_in_x80_to_xBF (get b last)\n then false\n else loop max b (last + 1)\n | '\\xED' ->\n let last = i + 2 in\n if last > max\n || not_in_x80_to_x9F (get b (i + 1))\n || not_in_x80_to_xBF (get b last)\n then false\n else loop max b (last + 1)\n | '\\xF0' ->\n let last = i + 3 in\n if last > max\n || not_in_x90_to_xBF (get b (i + 1))\n || not_in_x80_to_xBF (get b (i + 2))\n || not_in_x80_to_xBF (get b last)\n then false\n else loop max b (last + 1)\n | '\\xF1' .. '\\xF3' ->\n let last = i + 3 in\n if last > max\n || not_in_x80_to_xBF (get b (i + 1))\n || not_in_x80_to_xBF (get b (i + 2))\n || not_in_x80_to_xBF (get b last)\n then false\n else loop max b (last + 1)\n | '\\xF4' ->\n let last = i + 3 in\n if last > max\n || not_in_x80_to_x8F (get b (i + 1))\n || not_in_x80_to_xBF (get b (i + 2))\n || not_in_x80_to_xBF (get b last)\n then false\n else loop max b (last + 1)\n | _ -> false\n in\n loop (length b - 1) b 0\n\n(* UTF-16BE *)\n\nlet get_utf_16be_uchar b i =\n let get = unsafe_get_uint16_be in\n let max = length b - 1 in\n if i < 0 || i > max then invalid_arg \"index out of bounds\" else\n if i = max then dec_invalid 1 else\n match get b i with\n | u when u < 0xD800 || u > 0xDFFF -> dec_ret 2 u\n | u when u > 0xDBFF -> dec_invalid 2\n | hi -> (* combine [hi] with a low surrogate *)\n let last = i + 3 in\n if last > max then dec_invalid (max - i + 1) else\n match get b (i + 2) with\n | u when u < 0xDC00 || u > 0xDFFF -> dec_invalid 2 (* retry here *)\n | lo ->\n let u = (((hi land 0x3FF) lsl 10) lor (lo land 0x3FF)) + 0x10000 in\n dec_ret 4 u\n\nlet set_utf_16be_uchar b i u =\n let set = unsafe_set_uint16_be in\n let max = length b - 1 in\n if i < 0 || i > max then invalid_arg \"index out of bounds\" else\n match Uchar.to_int u with\n | u when u < 0 -> assert false\n | u when u <= 0xFFFF ->\n let last = i + 1 in\n if last > max then 0 else (set b i u; 2)\n | u when u <= 0x10FFFF ->\n let last = i + 3 in\n if last > max then 0 else\n let u' = u - 0x10000 in\n let hi = (0xD800 lor (u' lsr 10)) in\n let lo = (0xDC00 lor (u' land 0x3FF)) in\n set b i hi; set b (i + 2) lo; 4\n | _ -> assert false\n\nlet is_valid_utf_16be b =\n let rec loop max b i =\n let get = unsafe_get_uint16_be in\n if i > max then true else\n if i = max then false else\n match get b i with\n | u when u < 0xD800 || u > 0xDFFF -> loop max b (i + 2)\n | u when u > 0xDBFF -> false\n | _hi ->\n let last = i + 3 in\n if last > max then false else\n match get b (i + 2) with\n | u when u < 0xDC00 || u > 0xDFFF -> false\n | _lo -> loop max b (i + 4)\n in\n loop (length b - 1) b 0\n\n(* UTF-16LE *)\n\nlet get_utf_16le_uchar b i =\n let get = unsafe_get_uint16_le in\n let max = length b - 1 in\n if i < 0 || i > max then invalid_arg \"index out of bounds\" else\n if i = max then dec_invalid 1 else\n match get b i with\n | u when u < 0xD800 || u > 0xDFFF -> dec_ret 2 u\n | u when u > 0xDBFF -> dec_invalid 2\n | hi -> (* combine [hi] with a low surrogate *)\n let last = i + 3 in\n if last > max then dec_invalid (max - i + 1) else\n match get b (i + 2) with\n | u when u < 0xDC00 || u > 0xDFFF -> dec_invalid 2 (* retry here *)\n | lo ->\n let u = (((hi land 0x3FF) lsl 10) lor (lo land 0x3FF)) + 0x10000 in\n dec_ret 4 u\n\nlet set_utf_16le_uchar b i u =\n let set = unsafe_set_uint16_le in\n let max = length b - 1 in\n if i < 0 || i > max then invalid_arg \"index out of bounds\" else\n match Uchar.to_int u with\n | u when u < 0 -> assert false\n | u when u <= 0xFFFF ->\n let last = i + 1 in\n if last > max then 0 else (set b i u; 2)\n | u when u <= 0x10FFFF ->\n let last = i + 3 in\n if last > max then 0 else\n let u' = u - 0x10000 in\n let hi = (0xD800 lor (u' lsr 10)) in\n let lo = (0xDC00 lor (u' land 0x3FF)) in\n set b i hi; set b (i + 2) lo; 4\n | _ -> assert false\n\nlet is_valid_utf_16le b =\n let rec loop max b i =\n let get = unsafe_get_uint16_le in\n if i > max then true else\n if i = max then false else\n match get b i with\n | u when u < 0xD800 || u > 0xDFFF -> loop max b (i + 2)\n | u when u > 0xDBFF -> false\n | _hi ->\n let last = i + 3 in\n if last > max then false else\n match get b (i + 2) with\n | u when u < 0xDC00 || u > 0xDFFF -> false\n | _lo -> loop max b (i + 4)\n in\n loop (length b - 1) b 0\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Damien Doligez, projet Gallium, INRIA Rocquencourt *)\n(* *)\n(* Copyright 2014 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* String operations, based on byte sequence operations *)\n\n(* WARNING: Some functions in this file are duplicated in bytes.ml for\n efficiency reasons. When you modify the one in this file you need to\n modify its duplicate in bytes.ml.\n These functions have a \"duplicated\" comment above their definition.\n*)\n\nexternal length : string -> int = \"%string_length\"\nexternal get : string -> int -> char = \"%string_safe_get\"\nexternal set : bytes -> int -> char -> unit = \"%string_safe_set\"\nexternal create : int -> bytes = \"caml_create_string\"\nexternal unsafe_get : string -> int -> char = \"%string_unsafe_get\"\nexternal unsafe_set : bytes -> int -> char -> unit = \"%string_unsafe_set\"\nexternal unsafe_blit : string -> int -> bytes -> int -> int -> unit\n = \"caml_blit_string\" [@@noalloc]\nexternal unsafe_fill : bytes -> int -> int -> char -> unit\n = \"caml_fill_string\" [@@noalloc]\n\nmodule B = Bytes\n\nlet bts = B.unsafe_to_string\nlet bos = B.unsafe_of_string\n\nlet make n c =\n B.make n c |> bts\nlet init n f =\n B.init n f |> bts\nlet empty = \"\"\nlet copy s =\n B.copy (bos s) |> bts\nlet of_bytes = B.to_string\nlet to_bytes = B.of_string\nlet sub s ofs len =\n B.sub (bos s) ofs len |> bts\nlet fill =\n B.fill\nlet blit =\n B.blit_string\n\nlet ensure_ge (x:int) y = if x >= y then x else invalid_arg \"String.concat\"\n\nlet rec sum_lengths acc seplen = function\n | [] -> acc\n | hd :: [] -> length hd + acc\n | hd :: tl -> sum_lengths (ensure_ge (length hd + seplen + acc) acc) seplen tl\n\nlet rec unsafe_blits dst pos sep seplen = function\n [] -> dst\n | hd :: [] ->\n unsafe_blit hd 0 dst pos (length hd); dst\n | hd :: tl ->\n unsafe_blit hd 0 dst pos (length hd);\n unsafe_blit sep 0 dst (pos + length hd) seplen;\n unsafe_blits dst (pos + length hd + seplen) sep seplen tl\n\nlet concat sep = function\n [] -> \"\"\n | l -> let seplen = length sep in bts @@\n unsafe_blits\n (B.create (sum_lengths 0 seplen l))\n 0 sep seplen l\n\nlet cat = ( ^ )\n\n(* duplicated in bytes.ml *)\nlet iter f s =\n for i = 0 to length s - 1 do f (unsafe_get s i) done\n\n(* duplicated in bytes.ml *)\nlet iteri f s =\n for i = 0 to length s - 1 do f i (unsafe_get s i) done\n\nlet map f s =\n B.map f (bos s) |> bts\nlet mapi f s =\n B.mapi f (bos s) |> bts\nlet fold_right f x a =\n B.fold_right f (bos x) a\nlet fold_left f a x =\n B.fold_left f a (bos x)\nlet exists f s =\n B.exists f (bos s)\nlet for_all f s =\n B.for_all f (bos s)\n\n(* Beware: we cannot use B.trim or B.escape because they always make a\n copy, but String.mli spells out some cases where we are not allowed\n to make a copy. *)\n\nlet is_space = function\n | ' ' | '\\012' | '\\n' | '\\r' | '\\t' -> true\n | _ -> false\n\nlet trim s =\n if s = \"\" then s\n else if is_space (unsafe_get s 0) || is_space (unsafe_get s (length s - 1))\n then bts (B.trim (bos s))\n else s\n\nlet escaped s =\n let rec escape_if_needed s n i =\n if i >= n then s else\n match unsafe_get s i with\n | '\\\"' | '\\\\' | '\\000'..'\\031' | '\\127'.. '\\255' ->\n bts (B.escaped (bos s))\n | _ -> escape_if_needed s n (i+1)\n in\n escape_if_needed s (length s) 0\n\n(* duplicated in bytes.ml *)\nlet rec index_rec s lim i c =\n if i >= lim then raise Not_found else\n if unsafe_get s i = c then i else index_rec s lim (i + 1) c\n\n(* duplicated in bytes.ml *)\nlet index s c = index_rec s (length s) 0 c\n\n(* duplicated in bytes.ml *)\nlet rec index_rec_opt s lim i c =\n if i >= lim then None else\n if unsafe_get s i = c then Some i else index_rec_opt s lim (i + 1) c\n\n(* duplicated in bytes.ml *)\nlet index_opt s c = index_rec_opt s (length s) 0 c\n\n(* duplicated in bytes.ml *)\nlet index_from s i c =\n let l = length s in\n if i < 0 || i > l then invalid_arg \"String.index_from / Bytes.index_from\" else\n index_rec s l i c\n\n(* duplicated in bytes.ml *)\nlet index_from_opt s i c =\n let l = length s in\n if i < 0 || i > l then\n invalid_arg \"String.index_from_opt / Bytes.index_from_opt\"\n else\n index_rec_opt s l i c\n\n(* duplicated in bytes.ml *)\nlet rec rindex_rec s i c =\n if i < 0 then raise Not_found else\n if unsafe_get s i = c then i else rindex_rec s (i - 1) c\n\n(* duplicated in bytes.ml *)\nlet rindex s c = rindex_rec s (length s - 1) c\n\n(* duplicated in bytes.ml *)\nlet rindex_from s i c =\n if i < -1 || i >= length s then\n invalid_arg \"String.rindex_from / Bytes.rindex_from\"\n else\n rindex_rec s i c\n\n(* duplicated in bytes.ml *)\nlet rec rindex_rec_opt s i c =\n if i < 0 then None else\n if unsafe_get s i = c then Some i else rindex_rec_opt s (i - 1) c\n\n(* duplicated in bytes.ml *)\nlet rindex_opt s c = rindex_rec_opt s (length s - 1) c\n\n(* duplicated in bytes.ml *)\nlet rindex_from_opt s i c =\n if i < -1 || i >= length s then\n invalid_arg \"String.rindex_from_opt / Bytes.rindex_from_opt\"\n else\n rindex_rec_opt s i c\n\n(* duplicated in bytes.ml *)\nlet contains_from s i c =\n let l = length s in\n if i < 0 || i > l then\n invalid_arg \"String.contains_from / Bytes.contains_from\"\n else\n try ignore (index_rec s l i c); true with Not_found -> false\n\n(* duplicated in bytes.ml *)\nlet contains s c = contains_from s 0 c\n\n(* duplicated in bytes.ml *)\nlet rcontains_from s i c =\n if i < 0 || i >= length s then\n invalid_arg \"String.rcontains_from / Bytes.rcontains_from\"\n else\n try ignore (rindex_rec s i c); true with Not_found -> false\n\nlet uppercase_ascii s =\n B.uppercase_ascii (bos s) |> bts\nlet lowercase_ascii s =\n B.lowercase_ascii (bos s) |> bts\nlet capitalize_ascii s =\n B.capitalize_ascii (bos s) |> bts\nlet uncapitalize_ascii s =\n B.uncapitalize_ascii (bos s) |> bts\n\n(* duplicated in bytes.ml *)\nlet starts_with ~prefix s =\n let len_s = length s\n and len_pre = length prefix in\n let rec aux i =\n if i = len_pre then true\n else if unsafe_get s i <> unsafe_get prefix i then false\n else aux (i + 1)\n in len_s >= len_pre && aux 0\n\n(* duplicated in bytes.ml *)\nlet ends_with ~suffix s =\n let len_s = length s\n and len_suf = length suffix in\n let diff = len_s - len_suf in\n let rec aux i =\n if i = len_suf then true\n else if unsafe_get s (diff + i) <> unsafe_get suffix i then false\n else aux (i + 1)\n in diff >= 0 && aux 0\n\n(* duplicated in bytes.ml *)\nlet split_on_char sep s =\n let r = ref [] in\n let j = ref (length s) in\n for i = length s - 1 downto 0 do\n if unsafe_get s i = sep then begin\n r := sub s (i + 1) (!j - i - 1) :: !r;\n j := i\n end\n done;\n sub s 0 !j :: !r\n\n(* Deprecated functions implemented via other deprecated functions *)\n[@@@ocaml.warning \"-3\"]\nlet uppercase s =\n B.uppercase (bos s) |> bts\nlet lowercase s =\n B.lowercase (bos s) |> bts\nlet capitalize s =\n B.capitalize (bos s) |> bts\nlet uncapitalize s =\n B.uncapitalize (bos s) |> bts\n\ntype t = string\n\nlet compare (x: t) (y: t) = Stdlib.compare x y\nexternal equal : string -> string -> bool = \"caml_string_equal\" [@@noalloc]\n\n(** {1 Iterators} *)\n\nlet to_seq s = bos s |> B.to_seq\n\nlet to_seqi s = bos s |> B.to_seqi\n\nlet of_seq g = B.of_seq g |> bts\n\n(* UTF decoders and validators *)\n\nlet get_utf_8_uchar s i = B.get_utf_8_uchar (bos s) i\nlet is_valid_utf_8 s = B.is_valid_utf_8 (bos s)\n\nlet get_utf_16be_uchar s i = B.get_utf_16be_uchar (bos s) i\nlet is_valid_utf_16be s = B.is_valid_utf_16be (bos s)\n\nlet get_utf_16le_uchar s i = B.get_utf_16le_uchar (bos s) i\nlet is_valid_utf_16le s = B.is_valid_utf_16le (bos s)\n\n(** {6 Binary encoding/decoding of integers} *)\n\nexternal get_uint8 : string -> int -> int = \"%string_safe_get\"\nexternal get_uint16_ne : string -> int -> int = \"%caml_string_get16\"\nexternal get_int32_ne : string -> int -> int32 = \"%caml_string_get32\"\nexternal get_int64_ne : string -> int -> int64 = \"%caml_string_get64\"\n\nlet get_int8 s i = B.get_int8 (bos s) i\nlet get_uint16_le s i = B.get_uint16_le (bos s) i\nlet get_uint16_be s i = B.get_uint16_be (bos s) i\nlet get_int16_ne s i = B.get_int16_ne (bos s) i\nlet get_int16_le s i = B.get_int16_le (bos s) i\nlet get_int16_be s i = B.get_int16_be (bos s) i\nlet get_int32_le s i = B.get_int32_le (bos s) i\nlet get_int32_be s i = B.get_int32_be (bos s) i\nlet get_int64_le s i = B.get_int64_le (bos s) i\nlet get_int64_be s i = B.get_int64_be (bos s) i\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1997 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\ntype extern_flags =\n No_sharing\n | Closures\n | Compat_32\n(* note: this type definition is used in 'runtime/debugger.c' *)\n\nexternal to_channel: out_channel -> 'a -> extern_flags list -> unit\n = \"caml_output_value\"\nexternal to_bytes: 'a -> extern_flags list -> bytes\n = \"caml_output_value_to_bytes\"\nexternal to_string: 'a -> extern_flags list -> string\n = \"caml_output_value_to_string\"\nexternal to_buffer_unsafe:\n bytes -> int -> int -> 'a -> extern_flags list -> int\n = \"caml_output_value_to_buffer\"\n\nlet to_buffer buff ofs len v flags =\n if ofs < 0 || len < 0 || ofs > Bytes.length buff - len\n then invalid_arg \"Marshal.to_buffer: substring out of bounds\"\n else to_buffer_unsafe buff ofs len v flags\n\n(* The functions below use byte sequences as input, never using any\n mutation. It makes sense to use non-mutated [bytes] rather than\n [string], because we really work with sequences of bytes, not\n a text representation.\n*)\n\nexternal from_channel: in_channel -> 'a = \"caml_input_value\"\nexternal from_bytes_unsafe: bytes -> int -> 'a = \"caml_input_value_from_bytes\"\nexternal data_size_unsafe: bytes -> int -> int = \"caml_marshal_data_size\"\n\nlet header_size = 20\nlet data_size buff ofs =\n if ofs < 0 || ofs > Bytes.length buff - header_size\n then invalid_arg \"Marshal.data_size\"\n else data_size_unsafe buff ofs\nlet total_size buff ofs = header_size + data_size buff ofs\n\nlet from_bytes buff ofs =\n if ofs < 0 || ofs > Bytes.length buff - header_size\n then invalid_arg \"Marshal.from_bytes\"\n else begin\n let len = data_size_unsafe buff ofs in\n if ofs > Bytes.length buff - (header_size + len)\n then invalid_arg \"Marshal.from_bytes\"\n else from_bytes_unsafe buff ofs\n end\n\nlet from_string buff ofs =\n (* Bytes.unsafe_of_string is safe here, as the produced byte\n sequence is never mutated *)\n from_bytes (Bytes.unsafe_of_string buff) ofs\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* An alias for the type of arrays. *)\ntype 'a t = 'a array\n\n(* Array operations *)\n\nexternal length : 'a array -> int = \"%array_length\"\nexternal get: 'a array -> int -> 'a = \"%array_safe_get\"\nexternal set: 'a array -> int -> 'a -> unit = \"%array_safe_set\"\nexternal unsafe_get: 'a array -> int -> 'a = \"%array_unsafe_get\"\nexternal unsafe_set: 'a array -> int -> 'a -> unit = \"%array_unsafe_set\"\nexternal make: int -> 'a -> 'a array = \"caml_make_vect\"\nexternal create: int -> 'a -> 'a array = \"caml_make_vect\"\nexternal unsafe_sub : 'a array -> int -> int -> 'a array = \"caml_array_sub\"\nexternal append_prim : 'a array -> 'a array -> 'a array = \"caml_array_append\"\nexternal concat : 'a array list -> 'a array = \"caml_array_concat\"\nexternal unsafe_blit :\n 'a array -> int -> 'a array -> int -> int -> unit = \"caml_array_blit\"\nexternal unsafe_fill :\n 'a array -> int -> int -> 'a -> unit = \"caml_array_fill\"\nexternal create_float: int -> float array = \"caml_make_float_vect\"\nlet make_float = create_float\n\nmodule Floatarray = struct\n external create : int -> floatarray = \"caml_floatarray_create\"\n external length : floatarray -> int = \"%floatarray_length\"\n external get : floatarray -> int -> float = \"%floatarray_safe_get\"\n external set : floatarray -> int -> float -> unit = \"%floatarray_safe_set\"\n external unsafe_get : floatarray -> int -> float = \"%floatarray_unsafe_get\"\n external unsafe_set : floatarray -> int -> float -> unit\n = \"%floatarray_unsafe_set\"\nend\n\nlet init l f =\n if l = 0 then [||] else\n if l < 0 then invalid_arg \"Array.init\"\n (* See #6575. We could also check for maximum array size, but this depends\n on whether we create a float array or a regular one... *)\n else\n let res = create l (f 0) in\n for i = 1 to pred l do\n unsafe_set res i (f i)\n done;\n res\n\nlet make_matrix sx sy init =\n let res = create sx [||] in\n for x = 0 to pred sx do\n unsafe_set res x (create sy init)\n done;\n res\n\nlet create_matrix = make_matrix\n\nlet copy a =\n let l = length a in if l = 0 then [||] else unsafe_sub a 0 l\n\nlet append a1 a2 =\n let l1 = length a1 in\n if l1 = 0 then copy a2\n else if length a2 = 0 then unsafe_sub a1 0 l1\n else append_prim a1 a2\n\nlet sub a ofs len =\n if ofs < 0 || len < 0 || ofs > length a - len\n then invalid_arg \"Array.sub\"\n else unsafe_sub a ofs len\n\nlet fill a ofs len v =\n if ofs < 0 || len < 0 || ofs > length a - len\n then invalid_arg \"Array.fill\"\n else unsafe_fill a ofs len v\n\nlet blit a1 ofs1 a2 ofs2 len =\n if len < 0 || ofs1 < 0 || ofs1 > length a1 - len\n || ofs2 < 0 || ofs2 > length a2 - len\n then invalid_arg \"Array.blit\"\n else unsafe_blit a1 ofs1 a2 ofs2 len\n\nlet iter f a =\n for i = 0 to length a - 1 do f(unsafe_get a i) done\n\nlet iter2 f a b =\n if length a <> length b then\n invalid_arg \"Array.iter2: arrays must have the same length\"\n else\n for i = 0 to length a - 1 do f (unsafe_get a i) (unsafe_get b i) done\n\nlet map f a =\n let l = length a in\n if l = 0 then [||] else begin\n let r = create l (f(unsafe_get a 0)) in\n for i = 1 to l - 1 do\n unsafe_set r i (f(unsafe_get a i))\n done;\n r\n end\n\nlet map2 f a b =\n let la = length a in\n let lb = length b in\n if la <> lb then\n invalid_arg \"Array.map2: arrays must have the same length\"\n else begin\n if la = 0 then [||] else begin\n let r = create la (f (unsafe_get a 0) (unsafe_get b 0)) in\n for i = 1 to la - 1 do\n unsafe_set r i (f (unsafe_get a i) (unsafe_get b i))\n done;\n r\n end\n end\n\nlet iteri f a =\n for i = 0 to length a - 1 do f i (unsafe_get a i) done\n\nlet mapi f a =\n let l = length a in\n if l = 0 then [||] else begin\n let r = create l (f 0 (unsafe_get a 0)) in\n for i = 1 to l - 1 do\n unsafe_set r i (f i (unsafe_get a i))\n done;\n r\n end\n\nlet to_list a =\n let rec tolist i res =\n if i < 0 then res else tolist (i - 1) (unsafe_get a i :: res) in\n tolist (length a - 1) []\n\n(* Cannot use List.length here because the List module depends on Array. *)\nlet rec list_length accu = function\n | [] -> accu\n | _::t -> list_length (succ accu) t\n\nlet of_list = function\n [] -> [||]\n | hd::tl as l ->\n let a = create (list_length 0 l) hd in\n let rec fill i = function\n [] -> a\n | hd::tl -> unsafe_set a i hd; fill (i+1) tl in\n fill 1 tl\n\nlet fold_left f x a =\n let r = ref x in\n for i = 0 to length a - 1 do\n r := f !r (unsafe_get a i)\n done;\n !r\n\nlet fold_left_map f acc input_array =\n let len = length input_array in\n if len = 0 then (acc, [||]) else begin\n let acc, elt = f acc (unsafe_get input_array 0) in\n let output_array = create len elt in\n let acc = ref acc in\n for i = 1 to len - 1 do\n let acc', elt = f !acc (unsafe_get input_array i) in\n acc := acc';\n unsafe_set output_array i elt;\n done;\n !acc, output_array\n end\n\nlet fold_right f a x =\n let r = ref x in\n for i = length a - 1 downto 0 do\n r := f (unsafe_get a i) !r\n done;\n !r\n\nlet exists p a =\n let n = length a in\n let rec loop i =\n if i = n then false\n else if p (unsafe_get a i) then true\n else loop (succ i) in\n loop 0\n\nlet for_all p a =\n let n = length a in\n let rec loop i =\n if i = n then true\n else if p (unsafe_get a i) then loop (succ i)\n else false in\n loop 0\n\nlet for_all2 p l1 l2 =\n let n1 = length l1\n and n2 = length l2 in\n if n1 <> n2 then invalid_arg \"Array.for_all2\"\n else let rec loop i =\n if i = n1 then true\n else if p (unsafe_get l1 i) (unsafe_get l2 i) then loop (succ i)\n else false in\n loop 0\n\nlet exists2 p l1 l2 =\n let n1 = length l1\n and n2 = length l2 in\n if n1 <> n2 then invalid_arg \"Array.exists2\"\n else let rec loop i =\n if i = n1 then false\n else if p (unsafe_get l1 i) (unsafe_get l2 i) then true\n else loop (succ i) in\n loop 0\n\nlet mem x a =\n let n = length a in\n let rec loop i =\n if i = n then false\n else if compare (unsafe_get a i) x = 0 then true\n else loop (succ i) in\n loop 0\n\nlet memq x a =\n let n = length a in\n let rec loop i =\n if i = n then false\n else if x == (unsafe_get a i) then true\n else loop (succ i) in\n loop 0\n\nlet find_opt p a =\n let n = length a in\n let rec loop i =\n if i = n then None\n else\n let x = unsafe_get a i in\n if p x then Some x\n else loop (succ i)\n in\n loop 0\n\nlet find_map f a =\n let n = length a in\n let rec loop i =\n if i = n then None\n else\n match f (unsafe_get a i) with\n | None -> loop (succ i)\n | Some _ as r -> r\n in\n loop 0\n\nlet split x =\n if x = [||] then [||], [||]\n else begin\n let a0, b0 = unsafe_get x 0 in\n let n = length x in\n let a = create n a0 in\n let b = create n b0 in\n for i = 1 to n - 1 do\n let ai, bi = unsafe_get x i in\n unsafe_set a i ai;\n unsafe_set b i bi\n done;\n a, b\n end\n\nlet combine a b =\n let na = length a in\n let nb = length b in\n if na <> nb then invalid_arg \"Array.combine\";\n if na = 0 then [||]\n else begin\n let x = create na (unsafe_get a 0, unsafe_get b 0) in\n for i = 1 to na - 1 do\n unsafe_set x i (unsafe_get a i, unsafe_get b i)\n done;\n x\n end\n\nexception Bottom of int\nlet sort cmp a =\n let maxson l i =\n let i31 = i+i+i+1 in\n let x = ref i31 in\n if i31+2 < l then begin\n if cmp (get a i31) (get a (i31+1)) < 0 then x := i31+1;\n if cmp (get a !x) (get a (i31+2)) < 0 then x := i31+2;\n !x\n end else\n if i31+1 < l && cmp (get a i31) (get a (i31+1)) < 0\n then i31+1\n else if i31 < l then i31 else raise (Bottom i)\n in\n let rec trickledown l i e =\n let j = maxson l i in\n if cmp (get a j) e > 0 then begin\n set a i (get a j);\n trickledown l j e;\n end else begin\n set a i e;\n end;\n in\n let trickle l i e = try trickledown l i e with Bottom i -> set a i e in\n let rec bubbledown l i =\n let j = maxson l i in\n set a i (get a j);\n bubbledown l j\n in\n let bubble l i = try bubbledown l i with Bottom i -> i in\n let rec trickleup i e =\n let father = (i - 1) / 3 in\n assert (i <> father);\n if cmp (get a father) e < 0 then begin\n set a i (get a father);\n if father > 0 then trickleup father e else set a 0 e;\n end else begin\n set a i e;\n end;\n in\n let l = length a in\n for i = (l + 1) / 3 - 1 downto 0 do trickle l i (get a i); done;\n for i = l - 1 downto 2 do\n let e = (get a i) in\n set a i (get a 0);\n trickleup (bubble i 0) e;\n done;\n if l > 1 then (let e = (get a 1) in set a 1 (get a 0); set a 0 e)\n\n\nlet cutoff = 5\nlet stable_sort cmp a =\n let merge src1ofs src1len src2 src2ofs src2len dst dstofs =\n let src1r = src1ofs + src1len and src2r = src2ofs + src2len in\n let rec loop i1 s1 i2 s2 d =\n if cmp s1 s2 <= 0 then begin\n set dst d s1;\n let i1 = i1 + 1 in\n if i1 < src1r then\n loop i1 (get a i1) i2 s2 (d + 1)\n else\n blit src2 i2 dst (d + 1) (src2r - i2)\n end else begin\n set dst d s2;\n let i2 = i2 + 1 in\n if i2 < src2r then\n loop i1 s1 i2 (get src2 i2) (d + 1)\n else\n blit a i1 dst (d + 1) (src1r - i1)\n end\n in loop src1ofs (get a src1ofs) src2ofs (get src2 src2ofs) dstofs;\n in\n let isortto srcofs dst dstofs len =\n for i = 0 to len - 1 do\n let e = (get a (srcofs + i)) in\n let j = ref (dstofs + i - 1) in\n while (!j >= dstofs && cmp (get dst !j) e > 0) do\n set dst (!j + 1) (get dst !j);\n decr j;\n done;\n set dst (!j + 1) e;\n done;\n in\n let rec sortto srcofs dst dstofs len =\n if len <= cutoff then isortto srcofs dst dstofs len else begin\n let l1 = len / 2 in\n let l2 = len - l1 in\n sortto (srcofs + l1) dst (dstofs + l1) l2;\n sortto srcofs a (srcofs + l2) l1;\n merge (srcofs + l2) l1 dst (dstofs + l1) l2 dst dstofs;\n end;\n in\n let l = length a in\n if l <= cutoff then isortto 0 a 0 l else begin\n let l1 = l / 2 in\n let l2 = l - l1 in\n let t = make l2 (get a 0) in\n sortto l1 t 0 l2;\n sortto 0 a l2 l1;\n merge l2 l1 t 0 l2 a 0;\n end\n\n\nlet fast_sort = stable_sort\n\n(** {1 Iterators} *)\n\nlet to_seq a =\n let rec aux i () =\n if i < length a\n then\n let x = unsafe_get a i in\n Seq.Cons (x, aux (i+1))\n else Seq.Nil\n in\n aux 0\n\nlet to_seqi a =\n let rec aux i () =\n if i < length a\n then\n let x = unsafe_get a i in\n Seq.Cons ((i,x), aux (i+1))\n else Seq.Nil\n in\n aux 0\n\nlet of_rev_list = function\n [] -> [||]\n | hd::tl as l ->\n let len = list_length 0 l in\n let a = create len hd in\n let rec fill i = function\n [] -> a\n | hd::tl -> unsafe_set a i hd; fill (i-1) tl\n in\n fill (len-2) tl\n\nlet of_seq i =\n let l = Seq.fold_left (fun acc x -> x::acc) [] i in\n of_rev_list l\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* Module [Int32]: 32-bit integers *)\n\nexternal neg : int32 -> int32 = \"%int32_neg\"\nexternal add : int32 -> int32 -> int32 = \"%int32_add\"\nexternal sub : int32 -> int32 -> int32 = \"%int32_sub\"\nexternal mul : int32 -> int32 -> int32 = \"%int32_mul\"\nexternal div : int32 -> int32 -> int32 = \"%int32_div\"\nexternal rem : int32 -> int32 -> int32 = \"%int32_mod\"\nexternal logand : int32 -> int32 -> int32 = \"%int32_and\"\nexternal logor : int32 -> int32 -> int32 = \"%int32_or\"\nexternal logxor : int32 -> int32 -> int32 = \"%int32_xor\"\nexternal shift_left : int32 -> int -> int32 = \"%int32_lsl\"\nexternal shift_right : int32 -> int -> int32 = \"%int32_asr\"\nexternal shift_right_logical : int32 -> int -> int32 = \"%int32_lsr\"\nexternal of_int : int -> int32 = \"%int32_of_int\"\nexternal to_int : int32 -> int = \"%int32_to_int\"\nexternal of_float : float -> int32\n = \"caml_int32_of_float\" \"caml_int32_of_float_unboxed\"\n [@@unboxed] [@@noalloc]\nexternal to_float : int32 -> float\n = \"caml_int32_to_float\" \"caml_int32_to_float_unboxed\"\n [@@unboxed] [@@noalloc]\nexternal bits_of_float : float -> int32\n = \"caml_int32_bits_of_float\" \"caml_int32_bits_of_float_unboxed\"\n [@@unboxed] [@@noalloc]\nexternal float_of_bits : int32 -> float\n = \"caml_int32_float_of_bits\" \"caml_int32_float_of_bits_unboxed\"\n [@@unboxed] [@@noalloc]\n\nlet zero = 0l\nlet one = 1l\nlet minus_one = -1l\nlet succ n = add n 1l\nlet pred n = sub n 1l\nlet abs n = if n >= 0l then n else neg n\nlet min_int = 0x80000000l\nlet max_int = 0x7FFFFFFFl\nlet lognot n = logxor n (-1l)\n\nlet unsigned_to_int =\n match Sys.word_size with\n | 32 ->\n let max_int = of_int Stdlib.max_int in\n fun n ->\n if compare zero n <= 0 && compare n max_int <= 0 then\n Some (to_int n)\n else\n None\n | 64 ->\n (* So that it compiles in 32-bit *)\n let mask = 0xFFFF lsl 16 lor 0xFFFF in\n fun n -> Some (to_int n land mask)\n | _ ->\n assert false\n\nexternal format : string -> int32 -> string = \"caml_int32_format\"\nlet to_string n = format \"%d\" n\n\nexternal of_string : string -> int32 = \"caml_int32_of_string\"\n\nlet of_string_opt s =\n (* TODO: expose a non-raising primitive directly. *)\n try Some (of_string s)\n with Failure _ -> None\n\ntype t = int32\n\nlet compare (x: t) (y: t) = Stdlib.compare x y\nlet equal (x: t) (y: t) = compare x y = 0\n\nlet unsigned_compare n m =\n compare (sub n min_int) (sub m min_int)\n\nlet min x y : t = if x <= y then x else y\nlet max x y : t = if x >= y then x else y\n\n(* Unsigned division from signed division of the same\n bitness. See Warren Jr., Henry S. (2013). Hacker's Delight (2 ed.), Sec 9-3.\n*)\nlet unsigned_div n d =\n if d < zero then\n if unsigned_compare n d < 0 then zero else one\n else\n let q = shift_left (div (shift_right_logical n 1) d) 1 in\n let r = sub n (mul q d) in\n if unsigned_compare r d >= 0 then succ q else q\n\nlet unsigned_rem n d =\n sub n (mul (unsigned_div n d) d)\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* Module [Nativeint]: processor-native integers *)\n\nexternal neg: nativeint -> nativeint = \"%nativeint_neg\"\nexternal add: nativeint -> nativeint -> nativeint = \"%nativeint_add\"\nexternal sub: nativeint -> nativeint -> nativeint = \"%nativeint_sub\"\nexternal mul: nativeint -> nativeint -> nativeint = \"%nativeint_mul\"\nexternal div: nativeint -> nativeint -> nativeint = \"%nativeint_div\"\nexternal rem: nativeint -> nativeint -> nativeint = \"%nativeint_mod\"\nexternal logand: nativeint -> nativeint -> nativeint = \"%nativeint_and\"\nexternal logor: nativeint -> nativeint -> nativeint = \"%nativeint_or\"\nexternal logxor: nativeint -> nativeint -> nativeint = \"%nativeint_xor\"\nexternal shift_left: nativeint -> int -> nativeint = \"%nativeint_lsl\"\nexternal shift_right: nativeint -> int -> nativeint = \"%nativeint_asr\"\nexternal shift_right_logical: nativeint -> int -> nativeint = \"%nativeint_lsr\"\nexternal of_int: int -> nativeint = \"%nativeint_of_int\"\nexternal to_int: nativeint -> int = \"%nativeint_to_int\"\nexternal of_float : float -> nativeint\n = \"caml_nativeint_of_float\" \"caml_nativeint_of_float_unboxed\"\n [@@unboxed] [@@noalloc]\nexternal to_float : nativeint -> float\n = \"caml_nativeint_to_float\" \"caml_nativeint_to_float_unboxed\"\n [@@unboxed] [@@noalloc]\nexternal of_int32: int32 -> nativeint = \"%nativeint_of_int32\"\nexternal to_int32: nativeint -> int32 = \"%nativeint_to_int32\"\n\nlet zero = 0n\nlet one = 1n\nlet minus_one = -1n\nlet succ n = add n 1n\nlet pred n = sub n 1n\nlet abs n = if n >= 0n then n else neg n\nlet size = Sys.word_size\nlet min_int = shift_left 1n (size - 1)\nlet max_int = sub min_int 1n\nlet lognot n = logxor n (-1n)\n\nlet unsigned_to_int =\n let max_int = of_int Stdlib.max_int in\n fun n ->\n if compare zero n <= 0 && compare n max_int <= 0 then\n Some (to_int n)\n else\n None\n\nexternal format : string -> nativeint -> string = \"caml_nativeint_format\"\nlet to_string n = format \"%d\" n\n\nexternal of_string: string -> nativeint = \"caml_nativeint_of_string\"\n\nlet of_string_opt s =\n (* TODO: expose a non-raising primitive directly. *)\n try Some (of_string s)\n with Failure _ -> None\n\ntype t = nativeint\n\nlet compare (x: t) (y: t) = Stdlib.compare x y\nlet equal (x: t) (y: t) = compare x y = 0\n\nlet unsigned_compare n m =\n compare (sub n min_int) (sub m min_int)\n\nlet min x y : t = if x <= y then x else y\nlet max x y : t = if x >= y then x else y\n\n(* Unsigned division from signed division of the same\n bitness. See Warren Jr., Henry S. (2013). Hacker's Delight (2 ed.), Sec 9-3.\n*)\nlet unsigned_div n d =\n if d < zero then\n if unsigned_compare n d < 0 then zero else one\n else\n let q = shift_left (div (shift_right_logical n 1) d) 1 in\n let r = sub n (mul q d) in\n if unsigned_compare r d >= 0 then succ q else q\n\nlet unsigned_rem n d =\n sub n (mul (unsigned_div n d) d)\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* The parsing engine *)\n\nopen Lexing\n\n(* Internal interface to the parsing engine *)\n\ntype parser_env =\n { mutable s_stack : int array; (* States *)\n mutable v_stack : Obj.t array; (* Semantic attributes *)\n mutable symb_start_stack : position array; (* Start positions *)\n mutable symb_end_stack : position array; (* End positions *)\n mutable stacksize : int; (* Size of the stacks *)\n mutable stackbase : int; (* Base sp for current parse *)\n mutable curr_char : int; (* Last token read *)\n mutable lval : Obj.t; (* Its semantic attribute *)\n mutable symb_start : position; (* Start pos. of the current symbol*)\n mutable symb_end : position; (* End pos. of the current symbol *)\n mutable asp : int; (* The stack pointer for attributes *)\n mutable rule_len : int; (* Number of rhs items in the rule *)\n mutable rule_number : int; (* Rule number to reduce by *)\n mutable sp : int; (* Saved sp for parse_engine *)\n mutable state : int; (* Saved state for parse_engine *)\n mutable errflag : int } (* Saved error flag for parse_engine *)\n[@@warning \"-unused-field\"]\n\ntype parse_tables =\n { actions : (parser_env -> Obj.t) array;\n transl_const : int array;\n transl_block : int array;\n lhs : string;\n len : string;\n defred : string;\n dgoto : string;\n sindex : string;\n rindex : string;\n gindex : string;\n tablesize : int;\n table : string;\n check : string;\n error_function : string -> unit;\n names_const : string;\n names_block : string }\n\nexception YYexit of Obj.t\nexception Parse_error\n\ntype parser_input =\n Start\n | Token_read\n | Stacks_grown_1\n | Stacks_grown_2\n | Semantic_action_computed\n | Error_detected\n\ntype parser_output =\n Read_token\n | Raise_parse_error\n | Grow_stacks_1\n | Grow_stacks_2\n | Compute_semantic_action\n | Call_error_function\n\n(* to avoid warnings *)\nlet _ = [Read_token; Raise_parse_error; Grow_stacks_1; Grow_stacks_2;\n Compute_semantic_action; Call_error_function]\n\nexternal parse_engine :\n parse_tables -> parser_env -> parser_input -> Obj.t -> parser_output\n = \"caml_parse_engine\"\n\nexternal set_trace: bool -> bool\n = \"caml_set_parser_trace\"\n\nlet env =\n { s_stack = Array.make 100 0;\n v_stack = Array.make 100 (Obj.repr ());\n symb_start_stack = Array.make 100 dummy_pos;\n symb_end_stack = Array.make 100 dummy_pos;\n stacksize = 100;\n stackbase = 0;\n curr_char = 0;\n lval = Obj.repr ();\n symb_start = dummy_pos;\n symb_end = dummy_pos;\n asp = 0;\n rule_len = 0;\n rule_number = 0;\n sp = 0;\n state = 0;\n errflag = 0 }\n\nlet grow_stacks() =\n let oldsize = env.stacksize in\n let newsize = oldsize * 2 in\n let new_s = Array.make newsize 0\n and new_v = Array.make newsize (Obj.repr ())\n and new_start = Array.make newsize dummy_pos\n and new_end = Array.make newsize dummy_pos in\n Array.blit env.s_stack 0 new_s 0 oldsize;\n env.s_stack <- new_s;\n Array.blit env.v_stack 0 new_v 0 oldsize;\n env.v_stack <- new_v;\n Array.blit env.symb_start_stack 0 new_start 0 oldsize;\n env.symb_start_stack <- new_start;\n Array.blit env.symb_end_stack 0 new_end 0 oldsize;\n env.symb_end_stack <- new_end;\n env.stacksize <- newsize\n\nlet clear_parser() =\n Array.fill env.v_stack 0 env.stacksize (Obj.repr ());\n env.lval <- Obj.repr ()\n\nlet current_lookahead_fun = ref (fun (_ : Obj.t) -> false)\n\nlet yyparse tables start lexer lexbuf =\n let rec loop cmd arg =\n match parse_engine tables env cmd arg with\n Read_token ->\n let t = Obj.repr(lexer lexbuf) in\n env.symb_start <- lexbuf.lex_start_p;\n env.symb_end <- lexbuf.lex_curr_p;\n loop Token_read t\n | Raise_parse_error ->\n raise Parse_error\n | Compute_semantic_action ->\n let (action, value) =\n try\n (Semantic_action_computed, tables.actions.(env.rule_number) env)\n with Parse_error ->\n (Error_detected, Obj.repr ()) in\n loop action value\n | Grow_stacks_1 ->\n grow_stacks(); loop Stacks_grown_1 (Obj.repr ())\n | Grow_stacks_2 ->\n grow_stacks(); loop Stacks_grown_2 (Obj.repr ())\n | Call_error_function ->\n tables.error_function \"syntax error\";\n loop Error_detected (Obj.repr ()) in\n let init_asp = env.asp\n and init_sp = env.sp\n and init_stackbase = env.stackbase\n and init_state = env.state\n and init_curr_char = env.curr_char\n and init_lval = env.lval\n and init_errflag = env.errflag in\n env.stackbase <- env.sp + 1;\n env.curr_char <- start;\n env.symb_end <- lexbuf.lex_curr_p;\n try\n loop Start (Obj.repr ())\n with exn ->\n let curr_char = env.curr_char in\n env.asp <- init_asp;\n env.sp <- init_sp;\n env.stackbase <- init_stackbase;\n env.state <- init_state;\n env.curr_char <- init_curr_char;\n env.lval <- init_lval;\n env.errflag <- init_errflag;\n match exn with\n YYexit v ->\n Obj.magic v\n | _ ->\n current_lookahead_fun :=\n (fun tok ->\n if Obj.is_block tok\n then tables.transl_block.(Obj.tag tok) = curr_char\n else tables.transl_const.(Obj.magic tok) = curr_char);\n raise exn\n\nlet peek_val env n =\n Obj.magic env.v_stack.(env.asp - n)\n\nlet symbol_start_pos () =\n let rec loop i =\n if i <= 0 then env.symb_end_stack.(env.asp)\n else begin\n let st = env.symb_start_stack.(env.asp - i + 1) in\n let en = env.symb_end_stack.(env.asp - i + 1) in\n if st <> en then st else loop (i - 1)\n end\n in\n loop env.rule_len\n\nlet symbol_end_pos () = env.symb_end_stack.(env.asp)\nlet rhs_start_pos n = env.symb_start_stack.(env.asp - (env.rule_len - n))\nlet rhs_end_pos n = env.symb_end_stack.(env.asp - (env.rule_len - n))\n\nlet symbol_start () = (symbol_start_pos ()).pos_cnum\nlet symbol_end () = (symbol_end_pos ()).pos_cnum\nlet rhs_start n = (rhs_start_pos n).pos_cnum\nlet rhs_end n = (rhs_end_pos n).pos_cnum\n\nlet is_current_lookahead tok =\n (!current_lookahead_fun)(Obj.repr tok)\n\nlet parse_error (_ : string) = ()\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* Sets over ordered types *)\n\nmodule type OrderedType =\n sig\n type t\n val compare: t -> t -> int\n end\n\nmodule type S =\n sig\n type elt\n type t\n val empty: t\n val is_empty: t -> bool\n val mem: elt -> t -> bool\n val add: elt -> t -> t\n val singleton: elt -> t\n val remove: elt -> t -> t\n val union: t -> t -> t\n val inter: t -> t -> t\n val disjoint: t -> t -> bool\n val diff: t -> t -> t\n val compare: t -> t -> int\n val equal: t -> t -> bool\n val subset: t -> t -> bool\n val iter: (elt -> unit) -> t -> unit\n val map: (elt -> elt) -> t -> t\n val fold: (elt -> 'a -> 'a) -> t -> 'a -> 'a\n val for_all: (elt -> bool) -> t -> bool\n val exists: (elt -> bool) -> t -> bool\n val filter: (elt -> bool) -> t -> t\n val filter_map: (elt -> elt option) -> t -> t\n val partition: (elt -> bool) -> t -> t * t\n val cardinal: t -> int\n val elements: t -> elt list\n val min_elt: t -> elt\n val min_elt_opt: t -> elt option\n val max_elt: t -> elt\n val max_elt_opt: t -> elt option\n val choose: t -> elt\n val choose_opt: t -> elt option\n val split: elt -> t -> t * bool * t\n val find: elt -> t -> elt\n val find_opt: elt -> t -> elt option\n val find_first: (elt -> bool) -> t -> elt\n val find_first_opt: (elt -> bool) -> t -> elt option\n val find_last: (elt -> bool) -> t -> elt\n val find_last_opt: (elt -> bool) -> t -> elt option\n val of_list: elt list -> t\n val to_seq_from : elt -> t -> elt Seq.t\n val to_seq : t -> elt Seq.t\n val to_rev_seq : t -> elt Seq.t\n val add_seq : elt Seq.t -> t -> t\n val of_seq : elt Seq.t -> t\n end\n\nmodule Make(Ord: OrderedType) =\n struct\n type elt = Ord.t\n type t = Empty | Node of {l:t; v:elt; r:t; h:int}\n\n (* Sets are represented by balanced binary trees (the heights of the\n children differ by at most 2 *)\n\n let height = function\n Empty -> 0\n | Node {h} -> h\n\n (* Creates a new node with left son l, value v and right son r.\n We must have all elements of l < v < all elements of r.\n l and r must be balanced and | height l - height r | <= 2.\n Inline expansion of height for better speed. *)\n\n let create l v r =\n let hl = match l with Empty -> 0 | Node {h} -> h in\n let hr = match r with Empty -> 0 | Node {h} -> h in\n Node{l; v; r; h=(if hl >= hr then hl + 1 else hr + 1)}\n\n (* Same as create, but performs one step of rebalancing if necessary.\n Assumes l and r balanced and | height l - height r | <= 3.\n Inline expansion of create for better speed in the most frequent case\n where no rebalancing is required. *)\n\n let bal l v r =\n let hl = match l with Empty -> 0 | Node {h} -> h in\n let hr = match r with Empty -> 0 | Node {h} -> h in\n if hl > hr + 2 then begin\n match l with\n Empty -> invalid_arg \"Set.bal\"\n | Node{l=ll; v=lv; r=lr} ->\n if height ll >= height lr then\n create ll lv (create lr v r)\n else begin\n match lr with\n Empty -> invalid_arg \"Set.bal\"\n | Node{l=lrl; v=lrv; r=lrr}->\n create (create ll lv lrl) lrv (create lrr v r)\n end\n end else if hr > hl + 2 then begin\n match r with\n Empty -> invalid_arg \"Set.bal\"\n | Node{l=rl; v=rv; r=rr} ->\n if height rr >= height rl then\n create (create l v rl) rv rr\n else begin\n match rl with\n Empty -> invalid_arg \"Set.bal\"\n | Node{l=rll; v=rlv; r=rlr} ->\n create (create l v rll) rlv (create rlr rv rr)\n end\n end else\n Node{l; v; r; h=(if hl >= hr then hl + 1 else hr + 1)}\n\n (* Insertion of one element *)\n\n let rec add x = function\n Empty -> Node{l=Empty; v=x; r=Empty; h=1}\n | Node{l; v; r} as t ->\n let c = Ord.compare x v in\n if c = 0 then t else\n if c < 0 then\n let ll = add x l in\n if l == ll then t else bal ll v r\n else\n let rr = add x r in\n if r == rr then t else bal l v rr\n\n let singleton x = Node{l=Empty; v=x; r=Empty; h=1}\n\n (* Beware: those two functions assume that the added v is *strictly*\n smaller (or bigger) than all the present elements in the tree; it\n does not test for equality with the current min (or max) element.\n Indeed, they are only used during the \"join\" operation which\n respects this precondition.\n *)\n\n let rec add_min_element x = function\n | Empty -> singleton x\n | Node {l; v; r} ->\n bal (add_min_element x l) v r\n\n let rec add_max_element x = function\n | Empty -> singleton x\n | Node {l; v; r} ->\n bal l v (add_max_element x r)\n\n (* Same as create and bal, but no assumptions are made on the\n relative heights of l and r. *)\n\n let rec join l v r =\n match (l, r) with\n (Empty, _) -> add_min_element v r\n | (_, Empty) -> add_max_element v l\n | (Node{l=ll; v=lv; r=lr; h=lh}, Node{l=rl; v=rv; r=rr; h=rh}) ->\n if lh > rh + 2 then bal ll lv (join lr v r) else\n if rh > lh + 2 then bal (join l v rl) rv rr else\n create l v r\n\n (* Smallest and greatest element of a set *)\n\n let rec min_elt = function\n Empty -> raise Not_found\n | Node{l=Empty; v} -> v\n | Node{l} -> min_elt l\n\n let rec min_elt_opt = function\n Empty -> None\n | Node{l=Empty; v} -> Some v\n | Node{l} -> min_elt_opt l\n\n let rec max_elt = function\n Empty -> raise Not_found\n | Node{v; r=Empty} -> v\n | Node{r} -> max_elt r\n\n let rec max_elt_opt = function\n Empty -> None\n | Node{v; r=Empty} -> Some v\n | Node{r} -> max_elt_opt r\n\n (* Remove the smallest element of the given set *)\n\n let rec remove_min_elt = function\n Empty -> invalid_arg \"Set.remove_min_elt\"\n | Node{l=Empty; r} -> r\n | Node{l; v; r} -> bal (remove_min_elt l) v r\n\n (* Merge two trees l and r into one.\n All elements of l must precede the elements of r.\n Assume | height l - height r | <= 2. *)\n\n let merge t1 t2 =\n match (t1, t2) with\n (Empty, t) -> t\n | (t, Empty) -> t\n | (_, _) -> bal t1 (min_elt t2) (remove_min_elt t2)\n\n (* Merge two trees l and r into one.\n All elements of l must precede the elements of r.\n No assumption on the heights of l and r. *)\n\n let concat t1 t2 =\n match (t1, t2) with\n (Empty, t) -> t\n | (t, Empty) -> t\n | (_, _) -> join t1 (min_elt t2) (remove_min_elt t2)\n\n (* Splitting. split x s returns a triple (l, present, r) where\n - l is the set of elements of s that are < x\n - r is the set of elements of s that are > x\n - present is false if s contains no element equal to x,\n or true if s contains an element equal to x. *)\n\n let rec split x = function\n Empty ->\n (Empty, false, Empty)\n | Node{l; v; r} ->\n let c = Ord.compare x v in\n if c = 0 then (l, true, r)\n else if c < 0 then\n let (ll, pres, rl) = split x l in (ll, pres, join rl v r)\n else\n let (lr, pres, rr) = split x r in (join l v lr, pres, rr)\n\n (* Implementation of the set operations *)\n\n let empty = Empty\n\n let is_empty = function Empty -> true | _ -> false\n\n let rec mem x = function\n Empty -> false\n | Node{l; v; r} ->\n let c = Ord.compare x v in\n c = 0 || mem x (if c < 0 then l else r)\n\n let rec remove x = function\n Empty -> Empty\n | (Node{l; v; r} as t) ->\n let c = Ord.compare x v in\n if c = 0 then merge l r\n else\n if c < 0 then\n let ll = remove x l in\n if l == ll then t\n else bal ll v r\n else\n let rr = remove x r in\n if r == rr then t\n else bal l v rr\n\n let rec union s1 s2 =\n match (s1, s2) with\n (Empty, t2) -> t2\n | (t1, Empty) -> t1\n | (Node{l=l1; v=v1; r=r1; h=h1}, Node{l=l2; v=v2; r=r2; h=h2}) ->\n if h1 >= h2 then\n if h2 = 1 then add v2 s1 else begin\n let (l2, _, r2) = split v1 s2 in\n join (union l1 l2) v1 (union r1 r2)\n end\n else\n if h1 = 1 then add v1 s2 else begin\n let (l1, _, r1) = split v2 s1 in\n join (union l1 l2) v2 (union r1 r2)\n end\n\n let rec inter s1 s2 =\n match (s1, s2) with\n (Empty, _) -> Empty\n | (_, Empty) -> Empty\n | (Node{l=l1; v=v1; r=r1}, t2) ->\n match split v1 t2 with\n (l2, false, r2) ->\n concat (inter l1 l2) (inter r1 r2)\n | (l2, true, r2) ->\n join (inter l1 l2) v1 (inter r1 r2)\n\n (* Same as split, but compute the left and right subtrees\n only if the pivot element is not in the set. The right subtree\n is computed on demand. *)\n\n type split_bis =\n | Found\n | NotFound of t * (unit -> t)\n\n let rec split_bis x = function\n Empty ->\n NotFound (Empty, (fun () -> Empty))\n | Node{l; v; r; _} ->\n let c = Ord.compare x v in\n if c = 0 then Found\n else if c < 0 then\n match split_bis x l with\n | Found -> Found\n | NotFound (ll, rl) -> NotFound (ll, (fun () -> join (rl ()) v r))\n else\n match split_bis x r with\n | Found -> Found\n | NotFound (lr, rr) -> NotFound (join l v lr, rr)\n\n let rec disjoint s1 s2 =\n match (s1, s2) with\n (Empty, _) | (_, Empty) -> true\n | (Node{l=l1; v=v1; r=r1}, t2) ->\n if s1 == s2 then false\n else match split_bis v1 t2 with\n NotFound(l2, r2) -> disjoint l1 l2 && disjoint r1 (r2 ())\n | Found -> false\n\n let rec diff s1 s2 =\n match (s1, s2) with\n (Empty, _) -> Empty\n | (t1, Empty) -> t1\n | (Node{l=l1; v=v1; r=r1}, t2) ->\n match split v1 t2 with\n (l2, false, r2) ->\n join (diff l1 l2) v1 (diff r1 r2)\n | (l2, true, r2) ->\n concat (diff l1 l2) (diff r1 r2)\n\n type enumeration = End | More of elt * t * enumeration\n\n let rec cons_enum s e =\n match s with\n Empty -> e\n | Node{l; v; r} -> cons_enum l (More(v, r, e))\n\n let rec compare_aux e1 e2 =\n match (e1, e2) with\n (End, End) -> 0\n | (End, _) -> -1\n | (_, End) -> 1\n | (More(v1, r1, e1), More(v2, r2, e2)) ->\n let c = Ord.compare v1 v2 in\n if c <> 0\n then c\n else compare_aux (cons_enum r1 e1) (cons_enum r2 e2)\n\n let compare s1 s2 =\n compare_aux (cons_enum s1 End) (cons_enum s2 End)\n\n let equal s1 s2 =\n compare s1 s2 = 0\n\n let rec subset s1 s2 =\n match (s1, s2) with\n Empty, _ ->\n true\n | _, Empty ->\n false\n | Node {l=l1; v=v1; r=r1}, (Node {l=l2; v=v2; r=r2} as t2) ->\n let c = Ord.compare v1 v2 in\n if c = 0 then\n subset l1 l2 && subset r1 r2\n else if c < 0 then\n subset (Node {l=l1; v=v1; r=Empty; h=0}) l2 && subset r1 t2\n else\n subset (Node {l=Empty; v=v1; r=r1; h=0}) r2 && subset l1 t2\n\n let rec iter f = function\n Empty -> ()\n | Node{l; v; r} -> iter f l; f v; iter f r\n\n let rec fold f s accu =\n match s with\n Empty -> accu\n | Node{l; v; r} -> fold f r (f v (fold f l accu))\n\n let rec for_all p = function\n Empty -> true\n | Node{l; v; r} -> p v && for_all p l && for_all p r\n\n let rec exists p = function\n Empty -> false\n | Node{l; v; r} -> p v || exists p l || exists p r\n\n let rec filter p = function\n Empty -> Empty\n | (Node{l; v; r}) as t ->\n (* call [p] in the expected left-to-right order *)\n let l' = filter p l in\n let pv = p v in\n let r' = filter p r in\n if pv then\n if l==l' && r==r' then t else join l' v r'\n else concat l' r'\n\n let rec partition p = function\n Empty -> (Empty, Empty)\n | Node{l; v; r} ->\n (* call [p] in the expected left-to-right order *)\n let (lt, lf) = partition p l in\n let pv = p v in\n let (rt, rf) = partition p r in\n if pv\n then (join lt v rt, concat lf rf)\n else (concat lt rt, join lf v rf)\n\n let rec cardinal = function\n Empty -> 0\n | Node{l; r} -> cardinal l + 1 + cardinal r\n\n let rec elements_aux accu = function\n Empty -> accu\n | Node{l; v; r} -> elements_aux (v :: elements_aux accu r) l\n\n let elements s =\n elements_aux [] s\n\n let choose = min_elt\n\n let choose_opt = min_elt_opt\n\n let rec find x = function\n Empty -> raise Not_found\n | Node{l; v; r} ->\n let c = Ord.compare x v in\n if c = 0 then v\n else find x (if c < 0 then l else r)\n\n let rec find_first_aux v0 f = function\n Empty ->\n v0\n | Node{l; v; r} ->\n if f v then\n find_first_aux v f l\n else\n find_first_aux v0 f r\n\n let rec find_first f = function\n Empty ->\n raise Not_found\n | Node{l; v; r} ->\n if f v then\n find_first_aux v f l\n else\n find_first f r\n\n let rec find_first_opt_aux v0 f = function\n Empty ->\n Some v0\n | Node{l; v; r} ->\n if f v then\n find_first_opt_aux v f l\n else\n find_first_opt_aux v0 f r\n\n let rec find_first_opt f = function\n Empty ->\n None\n | Node{l; v; r} ->\n if f v then\n find_first_opt_aux v f l\n else\n find_first_opt f r\n\n let rec find_last_aux v0 f = function\n Empty ->\n v0\n | Node{l; v; r} ->\n if f v then\n find_last_aux v f r\n else\n find_last_aux v0 f l\n\n let rec find_last f = function\n Empty ->\n raise Not_found\n | Node{l; v; r} ->\n if f v then\n find_last_aux v f r\n else\n find_last f l\n\n let rec find_last_opt_aux v0 f = function\n Empty ->\n Some v0\n | Node{l; v; r} ->\n if f v then\n find_last_opt_aux v f r\n else\n find_last_opt_aux v0 f l\n\n let rec find_last_opt f = function\n Empty ->\n None\n | Node{l; v; r} ->\n if f v then\n find_last_opt_aux v f r\n else\n find_last_opt f l\n\n let rec find_opt x = function\n Empty -> None\n | Node{l; v; r} ->\n let c = Ord.compare x v in\n if c = 0 then Some v\n else find_opt x (if c < 0 then l else r)\n\n let try_join l v r =\n (* [join l v r] can only be called when (elements of l < v <\n elements of r); use [try_join l v r] when this property may\n not hold, but you hope it does hold in the common case *)\n if (l = Empty || Ord.compare (max_elt l) v < 0)\n && (r = Empty || Ord.compare v (min_elt r) < 0)\n then join l v r\n else union l (add v r)\n\n let rec map f = function\n | Empty -> Empty\n | Node{l; v; r} as t ->\n (* enforce left-to-right evaluation order *)\n let l' = map f l in\n let v' = f v in\n let r' = map f r in\n if l == l' && v == v' && r == r' then t\n else try_join l' v' r'\n\n let try_concat t1 t2 =\n match (t1, t2) with\n (Empty, t) -> t\n | (t, Empty) -> t\n | (_, _) -> try_join t1 (min_elt t2) (remove_min_elt t2)\n\n let rec filter_map f = function\n | Empty -> Empty\n | Node{l; v; r} as t ->\n (* enforce left-to-right evaluation order *)\n let l' = filter_map f l in\n let v' = f v in\n let r' = filter_map f r in\n begin match v' with\n | Some v' ->\n if l == l' && v == v' && r == r' then t\n else try_join l' v' r'\n | None ->\n try_concat l' r'\n end\n\n let of_sorted_list l =\n let rec sub n l =\n match n, l with\n | 0, l -> Empty, l\n | 1, x0 :: l -> Node {l=Empty; v=x0; r=Empty; h=1}, l\n | 2, x0 :: x1 :: l ->\n Node{l=Node{l=Empty; v=x0; r=Empty; h=1}; v=x1; r=Empty; h=2}, l\n | 3, x0 :: x1 :: x2 :: l ->\n Node{l=Node{l=Empty; v=x0; r=Empty; h=1}; v=x1;\n r=Node{l=Empty; v=x2; r=Empty; h=1}; h=2}, l\n | n, l ->\n let nl = n / 2 in\n let left, l = sub nl l in\n match l with\n | [] -> assert false\n | mid :: l ->\n let right, l = sub (n - nl - 1) l in\n create left mid right, l\n in\n fst (sub (List.length l) l)\n\n let of_list l =\n match l with\n | [] -> empty\n | [x0] -> singleton x0\n | [x0; x1] -> add x1 (singleton x0)\n | [x0; x1; x2] -> add x2 (add x1 (singleton x0))\n | [x0; x1; x2; x3] -> add x3 (add x2 (add x1 (singleton x0)))\n | [x0; x1; x2; x3; x4] -> add x4 (add x3 (add x2 (add x1 (singleton x0))))\n | _ -> of_sorted_list (List.sort_uniq Ord.compare l)\n\n let add_seq i m =\n Seq.fold_left (fun s x -> add x s) m i\n\n let of_seq i = add_seq i empty\n\n let rec seq_of_enum_ c () = match c with\n | End -> Seq.Nil\n | More (x, t, rest) -> Seq.Cons (x, seq_of_enum_ (cons_enum t rest))\n\n let to_seq c = seq_of_enum_ (cons_enum c End)\n\n let rec snoc_enum s e =\n match s with\n Empty -> e\n | Node{l; v; r} -> snoc_enum r (More(v, l, e))\n\n let rec rev_seq_of_enum_ c () = match c with\n | End -> Seq.Nil\n | More (x, t, rest) -> Seq.Cons (x, rev_seq_of_enum_ (snoc_enum t rest))\n\n let to_rev_seq c = rev_seq_of_enum_ (snoc_enum c End)\n\n let to_seq_from low s =\n let rec aux low s c = match s with\n | Empty -> c\n | Node {l; r; v; _} ->\n begin match Ord.compare v low with\n | 0 -> More (v, r, c)\n | n when n<0 -> aux low r c\n | _ -> aux low l (More (v, r, c))\n end\n in\n seq_of_enum_ (aux low s End)\n end\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nmodule type OrderedType =\n sig\n type t\n val compare: t -> t -> int\n end\n\nmodule type S =\n sig\n type key\n type !+'a t\n val empty: 'a t\n val is_empty: 'a t -> bool\n val mem: key -> 'a t -> bool\n val add: key -> 'a -> 'a t -> 'a t\n val update: key -> ('a option -> 'a option) -> 'a t -> 'a t\n val singleton: key -> 'a -> 'a t\n val remove: key -> 'a t -> 'a t\n val merge:\n (key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t\n val union: (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t\n val compare: ('a -> 'a -> int) -> 'a t -> 'a t -> int\n val equal: ('a -> 'a -> bool) -> 'a t -> 'a t -> bool\n val iter: (key -> 'a -> unit) -> 'a t -> unit\n val fold: (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b\n val for_all: (key -> 'a -> bool) -> 'a t -> bool\n val exists: (key -> 'a -> bool) -> 'a t -> bool\n val filter: (key -> 'a -> bool) -> 'a t -> 'a t\n val filter_map: (key -> 'a -> 'b option) -> 'a t -> 'b t\n val partition: (key -> 'a -> bool) -> 'a t -> 'a t * 'a t\n val cardinal: 'a t -> int\n val bindings: 'a t -> (key * 'a) list\n val min_binding: 'a t -> (key * 'a)\n val min_binding_opt: 'a t -> (key * 'a) option\n val max_binding: 'a t -> (key * 'a)\n val max_binding_opt: 'a t -> (key * 'a) option\n val choose: 'a t -> (key * 'a)\n val choose_opt: 'a t -> (key * 'a) option\n val split: key -> 'a t -> 'a t * 'a option * 'a t\n val find: key -> 'a t -> 'a\n val find_opt: key -> 'a t -> 'a option\n val find_first: (key -> bool) -> 'a t -> key * 'a\n val find_first_opt: (key -> bool) -> 'a t -> (key * 'a) option\n val find_last: (key -> bool) -> 'a t -> key * 'a\n val find_last_opt: (key -> bool) -> 'a t -> (key * 'a) option\n val map: ('a -> 'b) -> 'a t -> 'b t\n val mapi: (key -> 'a -> 'b) -> 'a t -> 'b t\n val to_seq : 'a t -> (key * 'a) Seq.t\n val to_rev_seq : 'a t -> (key * 'a) Seq.t\n val to_seq_from : key -> 'a t -> (key * 'a) Seq.t\n val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t\n val of_seq : (key * 'a) Seq.t -> 'a t\n end\n\nmodule Make(Ord: OrderedType) = struct\n\n type key = Ord.t\n\n type 'a t =\n Empty\n | Node of {l:'a t; v:key; d:'a; r:'a t; h:int}\n\n let height = function\n Empty -> 0\n | Node {h} -> h\n\n let create l x d r =\n let hl = height l and hr = height r in\n Node{l; v=x; d; r; h=(if hl >= hr then hl + 1 else hr + 1)}\n\n let singleton x d = Node{l=Empty; v=x; d; r=Empty; h=1}\n\n let bal l x d r =\n let hl = match l with Empty -> 0 | Node {h} -> h in\n let hr = match r with Empty -> 0 | Node {h} -> h in\n if hl > hr + 2 then begin\n match l with\n Empty -> invalid_arg \"Map.bal\"\n | Node{l=ll; v=lv; d=ld; r=lr} ->\n if height ll >= height lr then\n create ll lv ld (create lr x d r)\n else begin\n match lr with\n Empty -> invalid_arg \"Map.bal\"\n | Node{l=lrl; v=lrv; d=lrd; r=lrr}->\n create (create ll lv ld lrl) lrv lrd (create lrr x d r)\n end\n end else if hr > hl + 2 then begin\n match r with\n Empty -> invalid_arg \"Map.bal\"\n | Node{l=rl; v=rv; d=rd; r=rr} ->\n if height rr >= height rl then\n create (create l x d rl) rv rd rr\n else begin\n match rl with\n Empty -> invalid_arg \"Map.bal\"\n | Node{l=rll; v=rlv; d=rld; r=rlr} ->\n create (create l x d rll) rlv rld (create rlr rv rd rr)\n end\n end else\n Node{l; v=x; d; r; h=(if hl >= hr then hl + 1 else hr + 1)}\n\n let empty = Empty\n\n let is_empty = function Empty -> true | _ -> false\n\n let rec add x data = function\n Empty ->\n Node{l=Empty; v=x; d=data; r=Empty; h=1}\n | Node {l; v; d; r; h} as m ->\n let c = Ord.compare x v in\n if c = 0 then\n if d == data then m else Node{l; v=x; d=data; r; h}\n else if c < 0 then\n let ll = add x data l in\n if l == ll then m else bal ll v d r\n else\n let rr = add x data r in\n if r == rr then m else bal l v d rr\n\n let rec find x = function\n Empty ->\n raise Not_found\n | Node {l; v; d; r} ->\n let c = Ord.compare x v in\n if c = 0 then d\n else find x (if c < 0 then l else r)\n\n let rec find_first_aux v0 d0 f = function\n Empty ->\n (v0, d0)\n | Node {l; v; d; r} ->\n if f v then\n find_first_aux v d f l\n else\n find_first_aux v0 d0 f r\n\n let rec find_first f = function\n Empty ->\n raise Not_found\n | Node {l; v; d; r} ->\n if f v then\n find_first_aux v d f l\n else\n find_first f r\n\n let rec find_first_opt_aux v0 d0 f = function\n Empty ->\n Some (v0, d0)\n | Node {l; v; d; r} ->\n if f v then\n find_first_opt_aux v d f l\n else\n find_first_opt_aux v0 d0 f r\n\n let rec find_first_opt f = function\n Empty ->\n None\n | Node {l; v; d; r} ->\n if f v then\n find_first_opt_aux v d f l\n else\n find_first_opt f r\n\n let rec find_last_aux v0 d0 f = function\n Empty ->\n (v0, d0)\n | Node {l; v; d; r} ->\n if f v then\n find_last_aux v d f r\n else\n find_last_aux v0 d0 f l\n\n let rec find_last f = function\n Empty ->\n raise Not_found\n | Node {l; v; d; r} ->\n if f v then\n find_last_aux v d f r\n else\n find_last f l\n\n let rec find_last_opt_aux v0 d0 f = function\n Empty ->\n Some (v0, d0)\n | Node {l; v; d; r} ->\n if f v then\n find_last_opt_aux v d f r\n else\n find_last_opt_aux v0 d0 f l\n\n let rec find_last_opt f = function\n Empty ->\n None\n | Node {l; v; d; r} ->\n if f v then\n find_last_opt_aux v d f r\n else\n find_last_opt f l\n\n let rec find_opt x = function\n Empty ->\n None\n | Node {l; v; d; r} ->\n let c = Ord.compare x v in\n if c = 0 then Some d\n else find_opt x (if c < 0 then l else r)\n\n let rec mem x = function\n Empty ->\n false\n | Node {l; v; r} ->\n let c = Ord.compare x v in\n c = 0 || mem x (if c < 0 then l else r)\n\n let rec min_binding = function\n Empty -> raise Not_found\n | Node {l=Empty; v; d} -> (v, d)\n | Node {l} -> min_binding l\n\n let rec min_binding_opt = function\n Empty -> None\n | Node {l=Empty; v; d} -> Some (v, d)\n | Node {l}-> min_binding_opt l\n\n let rec max_binding = function\n Empty -> raise Not_found\n | Node {v; d; r=Empty} -> (v, d)\n | Node {r} -> max_binding r\n\n let rec max_binding_opt = function\n Empty -> None\n | Node {v; d; r=Empty} -> Some (v, d)\n | Node {r} -> max_binding_opt r\n\n let rec remove_min_binding = function\n Empty -> invalid_arg \"Map.remove_min_elt\"\n | Node {l=Empty; r} -> r\n | Node {l; v; d; r} -> bal (remove_min_binding l) v d r\n\n let merge t1 t2 =\n match (t1, t2) with\n (Empty, t) -> t\n | (t, Empty) -> t\n | (_, _) ->\n let (x, d) = min_binding t2 in\n bal t1 x d (remove_min_binding t2)\n\n let rec remove x = function\n Empty ->\n Empty\n | (Node {l; v; d; r} as m) ->\n let c = Ord.compare x v in\n if c = 0 then merge l r\n else if c < 0 then\n let ll = remove x l in if l == ll then m else bal ll v d r\n else\n let rr = remove x r in if r == rr then m else bal l v d rr\n\n let rec update x f = function\n Empty ->\n begin match f None with\n | None -> Empty\n | Some data -> Node{l=Empty; v=x; d=data; r=Empty; h=1}\n end\n | Node {l; v; d; r; h} as m ->\n let c = Ord.compare x v in\n if c = 0 then begin\n match f (Some d) with\n | None -> merge l r\n | Some data ->\n if d == data then m else Node{l; v=x; d=data; r; h}\n end else if c < 0 then\n let ll = update x f l in\n if l == ll then m else bal ll v d r\n else\n let rr = update x f r in\n if r == rr then m else bal l v d rr\n\n let rec iter f = function\n Empty -> ()\n | Node {l; v; d; r} ->\n iter f l; f v d; iter f r\n\n let rec map f = function\n Empty ->\n Empty\n | Node {l; v; d; r; h} ->\n let l' = map f l in\n let d' = f d in\n let r' = map f r in\n Node{l=l'; v; d=d'; r=r'; h}\n\n let rec mapi f = function\n Empty ->\n Empty\n | Node {l; v; d; r; h} ->\n let l' = mapi f l in\n let d' = f v d in\n let r' = mapi f r in\n Node{l=l'; v; d=d'; r=r'; h}\n\n let rec fold f m accu =\n match m with\n Empty -> accu\n | Node {l; v; d; r} ->\n fold f r (f v d (fold f l accu))\n\n let rec for_all p = function\n Empty -> true\n | Node {l; v; d; r} -> p v d && for_all p l && for_all p r\n\n let rec exists p = function\n Empty -> false\n | Node {l; v; d; r} -> p v d || exists p l || exists p r\n\n (* Beware: those two functions assume that the added k is *strictly*\n smaller (or bigger) than all the present keys in the tree; it\n does not test for equality with the current min (or max) key.\n\n Indeed, they are only used during the \"join\" operation which\n respects this precondition.\n *)\n\n let rec add_min_binding k x = function\n | Empty -> singleton k x\n | Node {l; v; d; r} ->\n bal (add_min_binding k x l) v d r\n\n let rec add_max_binding k x = function\n | Empty -> singleton k x\n | Node {l; v; d; r} ->\n bal l v d (add_max_binding k x r)\n\n (* Same as create and bal, but no assumptions are made on the\n relative heights of l and r. *)\n\n let rec join l v d r =\n match (l, r) with\n (Empty, _) -> add_min_binding v d r\n | (_, Empty) -> add_max_binding v d l\n | (Node{l=ll; v=lv; d=ld; r=lr; h=lh},\n Node{l=rl; v=rv; d=rd; r=rr; h=rh}) ->\n if lh > rh + 2 then bal ll lv ld (join lr v d r) else\n if rh > lh + 2 then bal (join l v d rl) rv rd rr else\n create l v d r\n\n (* Merge two trees l and r into one.\n All elements of l must precede the elements of r.\n No assumption on the heights of l and r. *)\n\n let concat t1 t2 =\n match (t1, t2) with\n (Empty, t) -> t\n | (t, Empty) -> t\n | (_, _) ->\n let (x, d) = min_binding t2 in\n join t1 x d (remove_min_binding t2)\n\n let concat_or_join t1 v d t2 =\n match d with\n | Some d -> join t1 v d t2\n | None -> concat t1 t2\n\n let rec split x = function\n Empty ->\n (Empty, None, Empty)\n | Node {l; v; d; r} ->\n let c = Ord.compare x v in\n if c = 0 then (l, Some d, r)\n else if c < 0 then\n let (ll, pres, rl) = split x l in (ll, pres, join rl v d r)\n else\n let (lr, pres, rr) = split x r in (join l v d lr, pres, rr)\n\n let rec merge f s1 s2 =\n match (s1, s2) with\n (Empty, Empty) -> Empty\n | (Node {l=l1; v=v1; d=d1; r=r1; h=h1}, _) when h1 >= height s2 ->\n let (l2, d2, r2) = split v1 s2 in\n concat_or_join (merge f l1 l2) v1 (f v1 (Some d1) d2) (merge f r1 r2)\n | (_, Node {l=l2; v=v2; d=d2; r=r2}) ->\n let (l1, d1, r1) = split v2 s1 in\n concat_or_join (merge f l1 l2) v2 (f v2 d1 (Some d2)) (merge f r1 r2)\n | _ ->\n assert false\n\n let rec union f s1 s2 =\n match (s1, s2) with\n | (Empty, s) | (s, Empty) -> s\n | (Node {l=l1; v=v1; d=d1; r=r1; h=h1},\n Node {l=l2; v=v2; d=d2; r=r2; h=h2}) ->\n if h1 >= h2 then\n let (l2, d2, r2) = split v1 s2 in\n let l = union f l1 l2 and r = union f r1 r2 in\n match d2 with\n | None -> join l v1 d1 r\n | Some d2 -> concat_or_join l v1 (f v1 d1 d2) r\n else\n let (l1, d1, r1) = split v2 s1 in\n let l = union f l1 l2 and r = union f r1 r2 in\n match d1 with\n | None -> join l v2 d2 r\n | Some d1 -> concat_or_join l v2 (f v2 d1 d2) r\n\n let rec filter p = function\n Empty -> Empty\n | Node {l; v; d; r} as m ->\n (* call [p] in the expected left-to-right order *)\n let l' = filter p l in\n let pvd = p v d in\n let r' = filter p r in\n if pvd then if l==l' && r==r' then m else join l' v d r'\n else concat l' r'\n\n let rec filter_map f = function\n Empty -> Empty\n | Node {l; v; d; r} ->\n (* call [f] in the expected left-to-right order *)\n let l' = filter_map f l in\n let fvd = f v d in\n let r' = filter_map f r in\n begin match fvd with\n | Some d' -> join l' v d' r'\n | None -> concat l' r'\n end\n\n let rec partition p = function\n Empty -> (Empty, Empty)\n | Node {l; v; d; r} ->\n (* call [p] in the expected left-to-right order *)\n let (lt, lf) = partition p l in\n let pvd = p v d in\n let (rt, rf) = partition p r in\n if pvd\n then (join lt v d rt, concat lf rf)\n else (concat lt rt, join lf v d rf)\n\n type 'a enumeration = End | More of key * 'a * 'a t * 'a enumeration\n\n let rec cons_enum m e =\n match m with\n Empty -> e\n | Node {l; v; d; r} -> cons_enum l (More(v, d, r, e))\n\n let compare cmp m1 m2 =\n let rec compare_aux e1 e2 =\n match (e1, e2) with\n (End, End) -> 0\n | (End, _) -> -1\n | (_, End) -> 1\n | (More(v1, d1, r1, e1), More(v2, d2, r2, e2)) ->\n let c = Ord.compare v1 v2 in\n if c <> 0 then c else\n let c = cmp d1 d2 in\n if c <> 0 then c else\n compare_aux (cons_enum r1 e1) (cons_enum r2 e2)\n in compare_aux (cons_enum m1 End) (cons_enum m2 End)\n\n let equal cmp m1 m2 =\n let rec equal_aux e1 e2 =\n match (e1, e2) with\n (End, End) -> true\n | (End, _) -> false\n | (_, End) -> false\n | (More(v1, d1, r1, e1), More(v2, d2, r2, e2)) ->\n Ord.compare v1 v2 = 0 && cmp d1 d2 &&\n equal_aux (cons_enum r1 e1) (cons_enum r2 e2)\n in equal_aux (cons_enum m1 End) (cons_enum m2 End)\n\n let rec cardinal = function\n Empty -> 0\n | Node {l; r} -> cardinal l + 1 + cardinal r\n\n let rec bindings_aux accu = function\n Empty -> accu\n | Node {l; v; d; r} -> bindings_aux ((v, d) :: bindings_aux accu r) l\n\n let bindings s =\n bindings_aux [] s\n\n let choose = min_binding\n\n let choose_opt = min_binding_opt\n\n let add_seq i m =\n Seq.fold_left (fun m (k,v) -> add k v m) m i\n\n let of_seq i = add_seq i empty\n\n let rec seq_of_enum_ c () = match c with\n | End -> Seq.Nil\n | More (k,v,t,rest) -> Seq.Cons ((k,v), seq_of_enum_ (cons_enum t rest))\n\n let to_seq m =\n seq_of_enum_ (cons_enum m End)\n\n let rec snoc_enum s e =\n match s with\n Empty -> e\n | Node{l; v; d; r} -> snoc_enum r (More(v, d, l, e))\n\n let rec rev_seq_of_enum_ c () = match c with\n | End -> Seq.Nil\n | More (k,v,t,rest) ->\n Seq.Cons ((k,v), rev_seq_of_enum_ (snoc_enum t rest))\n\n let to_rev_seq c =\n rev_seq_of_enum_ (snoc_enum c End)\n\n let to_seq_from low m =\n let rec aux low m c = match m with\n | Empty -> c\n | Node {l; v; d; r; _} ->\n begin match Ord.compare v low with\n | 0 -> More (v, d, r, c)\n | n when n<0 -> aux low r c\n | _ -> aux low l (More (v, d, r, c))\n end\n in\n seq_of_enum_ (aux low m End)\nend\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\ntype 'a t = { mutable c : 'a list; mutable len : int; }\n\nexception Empty\n\nlet create () = { c = []; len = 0; }\n\nlet clear s = s.c <- []; s.len <- 0\n\nlet copy s = { c = s.c; len = s.len; }\n\nlet push x s = s.c <- x :: s.c; s.len <- s.len + 1\n\nlet pop s =\n match s.c with\n | hd::tl -> s.c <- tl; s.len <- s.len - 1; hd\n | [] -> raise Empty\n\nlet pop_opt s =\n match s.c with\n | hd::tl -> s.c <- tl; s.len <- s.len - 1; Some hd\n | [] -> None\n\nlet top s =\n match s.c with\n | hd::_ -> hd\n | [] -> raise Empty\n\nlet top_opt s =\n match s.c with\n | hd::_ -> Some hd\n | [] -> None\n\nlet is_empty s = (s.c = [])\n\nlet length s = s.len\n\nlet iter f s = List.iter f s.c\n\nlet fold f acc s = List.fold_left f acc s.c\n\n(** {1 Iterators} *)\n\nlet to_seq s = List.to_seq s.c\n\nlet add_seq q i = Seq.iter (fun x -> push x q) i\n\nlet of_seq g =\n let s = create() in\n add_seq s g;\n s\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Francois Pottier, projet Cristal, INRIA Rocquencourt *)\n(* Jeremie Dimino, Jane Street Europe *)\n(* *)\n(* Copyright 2002 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nexception Empty\n\ntype 'a cell =\n | Nil\n | Cons of { content: 'a; mutable next: 'a cell }\n\ntype 'a t = {\n mutable length: int;\n mutable first: 'a cell;\n mutable last: 'a cell\n}\n\nlet create () = {\n length = 0;\n first = Nil;\n last = Nil\n}\n\nlet clear q =\n q.length <- 0;\n q.first <- Nil;\n q.last <- Nil\n\nlet add x q =\n let cell = Cons {\n content = x;\n next = Nil\n } in\n match q.last with\n | Nil ->\n q.length <- 1;\n q.first <- cell;\n q.last <- cell\n | Cons last ->\n q.length <- q.length + 1;\n last.next <- cell;\n q.last <- cell\n\nlet push =\n add\n\nlet peek q =\n match q.first with\n | Nil -> raise Empty\n | Cons { content } -> content\n\nlet peek_opt q =\n match q.first with\n | Nil -> None\n | Cons { content } -> Some content\n\nlet top =\n peek\n\nlet take q =\n match q.first with\n | Nil -> raise Empty\n | Cons { content; next = Nil } ->\n clear q;\n content\n | Cons { content; next } ->\n q.length <- q.length - 1;\n q.first <- next;\n content\n\nlet take_opt q =\n match q.first with\n | Nil -> None\n | Cons { content; next = Nil } ->\n clear q;\n Some content\n | Cons { content; next } ->\n q.length <- q.length - 1;\n q.first <- next;\n Some content\n\nlet pop =\n take\n\nlet copy =\n let rec copy q_res prev cell =\n match cell with\n | Nil -> q_res.last <- prev; q_res\n | Cons { content; next } ->\n let res = Cons { content; next = Nil } in\n begin match prev with\n | Nil -> q_res.first <- res\n | Cons p -> p.next <- res\n end;\n copy q_res res next\n in\n fun q -> copy { length = q.length; first = Nil; last = Nil } Nil q.first\n\nlet is_empty q =\n q.length = 0\n\nlet length q =\n q.length\n\nlet iter =\n let rec iter f cell =\n match cell with\n | Nil -> ()\n | Cons { content; next } ->\n f content;\n iter f next\n in\n fun f q -> iter f q.first\n\nlet fold =\n let rec fold f accu cell =\n match cell with\n | Nil -> accu\n | Cons { content; next } ->\n let accu = f accu content in\n fold f accu next\n in\n fun f accu q -> fold f accu q.first\n\nlet transfer q1 q2 =\n if q1.length > 0 then\n match q2.last with\n | Nil ->\n q2.length <- q1.length;\n q2.first <- q1.first;\n q2.last <- q1.last;\n clear q1\n | Cons last ->\n q2.length <- q2.length + q1.length;\n last.next <- q1.first;\n q2.last <- q1.last;\n clear q1\n\n(** {1 Iterators} *)\n\nlet to_seq q =\n let rec aux c () = match c with\n | Nil -> Seq.Nil\n | Cons { content=x; next; } -> Seq.Cons (x, aux next)\n in\n aux q.first\n\nlet add_seq q i = Seq.iter (fun x -> push x q) i\n\nlet of_seq g =\n let q = create() in\n add_seq q g;\n q\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Pierre Weis and Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1999 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* Extensible buffers *)\n\ntype t =\n {mutable buffer : bytes;\n mutable position : int;\n mutable length : int;\n initial_buffer : bytes}\n(* Invariants: all parts of the code preserve the invariants that:\n - [0 <= b.position <= b.length]\n - [b.length = Bytes.length b.buffer]\n\n Note in particular that [b.position = b.length] is legal,\n it means that the buffer is full and will have to be extended\n before any further addition. *)\n\nlet create n =\n let n = if n < 1 then 1 else n in\n let n = if n > Sys.max_string_length then Sys.max_string_length else n in\n let s = Bytes.create n in\n {buffer = s; position = 0; length = n; initial_buffer = s}\n\nlet contents b = Bytes.sub_string b.buffer 0 b.position\nlet to_bytes b = Bytes.sub b.buffer 0 b.position\n\nlet sub b ofs len =\n if ofs < 0 || len < 0 || ofs > b.position - len\n then invalid_arg \"Buffer.sub\"\n else Bytes.sub_string b.buffer ofs len\n\n\nlet blit src srcoff dst dstoff len =\n if len < 0 || srcoff < 0 || srcoff > src.position - len\n || dstoff < 0 || dstoff > (Bytes.length dst) - len\n then invalid_arg \"Buffer.blit\"\n else\n Bytes.unsafe_blit src.buffer srcoff dst dstoff len\n\n\nlet nth b ofs =\n if ofs < 0 || ofs >= b.position then\n invalid_arg \"Buffer.nth\"\n else Bytes.unsafe_get b.buffer ofs\n\n\nlet length b = b.position\n\nlet clear b = b.position <- 0\n\nlet reset b =\n b.position <- 0;\n b.buffer <- b.initial_buffer;\n b.length <- Bytes.length b.buffer\n\n(* [resize b more] ensures that [b.position + more <= b.length] holds\n by dynamically extending [b.buffer] if necessary -- and thus\n increasing [b.length].\n\n In particular, after [resize b more] is called, a direct access of\n size [more] at [b.position] will always be in-bounds, so that\n (unsafe_{get,set}) may be used for performance.\n*)\nlet resize b more =\n let old_pos = b.position in\n let old_len = b.length in\n let new_len = ref old_len in\n while old_pos + more > !new_len do new_len := 2 * !new_len done;\n if !new_len > Sys.max_string_length then begin\n if old_pos + more <= Sys.max_string_length\n then new_len := Sys.max_string_length\n else failwith \"Buffer.add: cannot grow buffer\"\n end;\n let new_buffer = Bytes.create !new_len in\n (* PR#6148: let's keep using [blit] rather than [unsafe_blit] in\n this tricky function that is slow anyway. *)\n Bytes.blit b.buffer 0 new_buffer 0 b.position;\n b.buffer <- new_buffer;\n b.length <- !new_len;\n assert (b.position + more <= b.length);\n assert (old_pos + more <= b.length);\n ()\n (* Note: there are various situations (preemptive threads, signals and\n gc finalizers) where OCaml code may be run asynchronously; in\n particular, there may be a race with another user of [b], changing\n its mutable fields in the middle of the [resize] call. The Buffer\n module does not provide any correctness guarantee if that happens,\n but we must still ensure that the datastructure invariants hold for\n memory-safety -- as we plan to use [unsafe_{get,set}].\n\n There are two potential allocation points in this function,\n [ref] and [Bytes.create], but all reads and writes to the fields\n of [b] happen before both of them or after both of them.\n\n We therefore assume that [b.position] may change at these allocations,\n and check that the [b.position + more <= b.length] postcondition\n holds for both values of [b.position], before or after the function\n is called. More precisely, the following invariants must hold if the\n function returns correctly, in addition to the usual buffer invariants:\n - [old(b.position) + more <= new(b.length)]\n - [new(b.position) + more <= new(b.length)]\n - [old(b.length) <= new(b.length)]\n\n Note: [b.position + more <= old(b.length)] does *not*\n hold in general, as it is precisely the case where you need\n to call [resize] to increase [b.length].\n\n Note: [assert] above does not mean that we know the conditions\n always hold, but that the function may return correctly\n only if they hold.\n\n Note: the other functions in this module does not need\n to be checked with this level of scrutiny, given that they\n read/write the buffer immediately after checking that\n [b.position + more <= b.length] hold or calling [resize].\n *)\n\nlet add_char b c =\n let pos = b.position in\n if pos >= b.length then resize b 1;\n Bytes.unsafe_set b.buffer pos c;\n b.position <- pos + 1\n\nlet uchar_utf_8_byte_length_max = 4\nlet uchar_utf_16_byte_length_max = 4\n\nlet rec add_utf_8_uchar b u =\n let pos = b.position in\n if pos >= b.length then resize b uchar_utf_8_byte_length_max;\n let n = Bytes.set_utf_8_uchar b.buffer pos u in\n if n = 0\n then (resize b uchar_utf_8_byte_length_max; add_utf_8_uchar b u)\n else (b.position <- pos + n)\n\nlet rec add_utf_16be_uchar b u =\n let pos = b.position in\n if pos >= b.length then resize b uchar_utf_16_byte_length_max;\n let n = Bytes.set_utf_16be_uchar b.buffer pos u in\n if n = 0\n then (resize b uchar_utf_16_byte_length_max; add_utf_16be_uchar b u)\n else (b.position <- pos + n)\n\nlet rec add_utf_16le_uchar b u =\n let pos = b.position in\n if pos >= b.length then resize b uchar_utf_16_byte_length_max;\n let n = Bytes.set_utf_16le_uchar b.buffer pos u in\n if n = 0\n then (resize b uchar_utf_16_byte_length_max; add_utf_16le_uchar b u)\n else (b.position <- pos + n)\n\nlet add_substring b s offset len =\n if offset < 0 || len < 0 || offset > String.length s - len\n then invalid_arg \"Buffer.add_substring/add_subbytes\";\n let new_position = b.position + len in\n if new_position > b.length then resize b len;\n Bytes.unsafe_blit_string s offset b.buffer b.position len;\n b.position <- new_position\n\nlet add_subbytes b s offset len =\n add_substring b (Bytes.unsafe_to_string s) offset len\n\nlet add_string b s =\n let len = String.length s in\n let new_position = b.position + len in\n if new_position > b.length then resize b len;\n Bytes.unsafe_blit_string s 0 b.buffer b.position len;\n b.position <- new_position\n\nlet add_bytes b s = add_string b (Bytes.unsafe_to_string s)\n\nlet add_buffer b bs =\n add_subbytes b bs.buffer 0 bs.position\n\n(* this (private) function could move into the standard library *)\nlet really_input_up_to ic buf ofs len =\n let rec loop ic buf ~already_read ~ofs ~to_read =\n if to_read = 0 then already_read\n else begin\n let r = input ic buf ofs to_read in\n if r = 0 then already_read\n else begin\n let already_read = already_read + r in\n let ofs = ofs + r in\n let to_read = to_read - r in\n loop ic buf ~already_read ~ofs ~to_read\n end\n end\n in loop ic buf ~already_read:0 ~ofs ~to_read:len\n\n\nlet unsafe_add_channel_up_to b ic len =\n if b.position + len > b.length then resize b len;\n let n = really_input_up_to ic b.buffer b.position len in\n (* The assertion below may fail in weird scenario where\n threaded/finalizer code, run asynchronously during the\n [really_input_up_to] call, races on the buffer; we don't ensure\n correctness in this case, but need to preserve the invariants for\n memory-safety (see discussion of [resize]). *)\n assert (b.position + n <= b.length);\n b.position <- b.position + n;\n n\n\nlet add_channel b ic len =\n if len < 0 || len > Sys.max_string_length then (* PR#5004 *)\n invalid_arg \"Buffer.add_channel\";\n let n = unsafe_add_channel_up_to b ic len in\n (* It is intentional that a consumer catching End_of_file\n will see the data written (see #6719, #7136). *)\n if n < len then raise End_of_file;\n ()\n\nlet output_buffer oc b =\n output oc b.buffer 0 b.position\n\nlet closing = function\n | '(' -> ')'\n | '{' -> '}'\n | _ -> assert false\n\n(* opening and closing: open and close characters, typically ( and )\n k: balance of opening and closing chars\n s: the string where we are searching\n start: the index where we start the search. *)\nlet advance_to_closing opening closing k s start =\n let rec advance k i lim =\n if i >= lim then raise Not_found else\n if s.[i] = opening then advance (k + 1) (i + 1) lim else\n if s.[i] = closing then\n if k = 0 then i else advance (k - 1) (i + 1) lim\n else advance k (i + 1) lim in\n advance k start (String.length s)\n\nlet advance_to_non_alpha s start =\n let rec advance i lim =\n if i >= lim then lim else\n match s.[i] with\n | 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' -> advance (i + 1) lim\n | _ -> i in\n advance start (String.length s)\n\n(* We are just at the beginning of an ident in s, starting at start. *)\nlet find_ident s start lim =\n if start >= lim then raise Not_found else\n match s.[start] with\n (* Parenthesized ident ? *)\n | '(' | '{' as c ->\n let new_start = start + 1 in\n let stop = advance_to_closing c (closing c) 0 s new_start in\n String.sub s new_start (stop - start - 1), stop + 1\n (* Regular ident *)\n | _ ->\n let stop = advance_to_non_alpha s (start + 1) in\n String.sub s start (stop - start), stop\n\n(* Substitute $ident, $(ident), or ${ident} in s,\n according to the function mapping f. *)\nlet add_substitute b f s =\n let lim = String.length s in\n let rec subst previous i =\n if i < lim then begin\n match s.[i] with\n | '$' as current when previous = '\\\\' ->\n add_char b current;\n subst ' ' (i + 1)\n | '$' ->\n let j = i + 1 in\n let ident, next_i = find_ident s j lim in\n add_string b (f ident);\n subst ' ' next_i\n | current when previous == '\\\\' ->\n add_char b '\\\\';\n add_char b current;\n subst ' ' (i + 1)\n | '\\\\' as current ->\n subst current (i + 1)\n | current ->\n add_char b current;\n subst current (i + 1)\n end else\n if previous = '\\\\' then add_char b previous in\n subst ' ' 0\n\nlet truncate b len =\n if len < 0 || len > length b then\n invalid_arg \"Buffer.truncate\"\n else\n b.position <- len\n\n(** {1 Iterators} *)\n\nlet to_seq b =\n let rec aux i () =\n (* Note that b.position is not a constant and cannot be lifted out of aux *)\n if i >= b.position then Seq.Nil\n else\n let x = Bytes.unsafe_get b.buffer i in\n Seq.Cons (x, aux (i+1))\n in\n aux 0\n\nlet to_seqi b =\n let rec aux i () =\n (* Note that b.position is not a constant and cannot be lifted out of aux *)\n if i >= b.position then Seq.Nil\n else\n let x = Bytes.unsafe_get b.buffer i in\n Seq.Cons ((i,x), aux (i+1))\n in\n aux 0\n\nlet add_seq b seq = Seq.iter (add_char b) seq\n\nlet of_seq i =\n let b = create 32 in\n add_seq b i;\n b\n\n(** {6 Binary encoding of integers} *)\n\nexternal unsafe_set_int8 : bytes -> int -> int -> unit = \"%bytes_unsafe_set\"\nexternal unsafe_set_int16 : bytes -> int -> int -> unit = \"%caml_bytes_set16u\"\nexternal unsafe_set_int32 : bytes -> int -> int32 -> unit = \"%caml_bytes_set32u\"\nexternal unsafe_set_int64 : bytes -> int -> int64 -> unit = \"%caml_bytes_set64u\"\nexternal swap16 : int -> int = \"%bswap16\"\nexternal swap32 : int32 -> int32 = \"%bswap_int32\"\nexternal swap64 : int64 -> int64 = \"%bswap_int64\"\n\n\nlet add_int8 b x =\n let new_position = b.position + 1 in\n if new_position > b.length then resize b 1;\n unsafe_set_int8 b.buffer b.position x;\n b.position <- new_position\n\nlet add_int16_ne b x =\n let new_position = b.position + 2 in\n if new_position > b.length then resize b 2;\n unsafe_set_int16 b.buffer b.position x;\n b.position <- new_position\n\nlet add_int32_ne b x =\n let new_position = b.position + 4 in\n if new_position > b.length then resize b 4;\n unsafe_set_int32 b.buffer b.position x;\n b.position <- new_position\n\nlet add_int64_ne b x =\n let new_position = b.position + 8 in\n if new_position > b.length then resize b 8;\n unsafe_set_int64 b.buffer b.position x;\n b.position <- new_position\n\nlet add_int16_le b x =\n add_int16_ne b (if Sys.big_endian then swap16 x else x)\n\nlet add_int16_be b x =\n add_int16_ne b (if Sys.big_endian then x else swap16 x)\n\nlet add_int32_le b x =\n add_int32_ne b (if Sys.big_endian then swap32 x else x)\n\nlet add_int32_be b x =\n add_int32_ne b (if Sys.big_endian then x else swap32 x)\n\nlet add_int64_le b x =\n add_int64_ne b (if Sys.big_endian then swap64 x else x)\n\nlet add_int64_be b x =\n add_int64_ne b (if Sys.big_endian then x else swap64 x)\n\nlet add_uint8 = add_int8\nlet add_uint16_ne = add_int16_ne\nlet add_uint16_le = add_int16_le\nlet add_uint16_be = add_int16_be\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy and Pierre Weis, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nopen CamlinternalFormatBasics\nopen CamlinternalFormat\n\nlet kfprintf k o (Format (fmt, _)) =\n make_printf (fun acc -> output_acc o acc; k o) End_of_acc fmt\nlet kbprintf k b (Format (fmt, _)) =\n make_printf (fun acc -> bufput_acc b acc; k b) End_of_acc fmt\nlet ikfprintf k oc (Format (fmt, _)) =\n make_iprintf k oc fmt\nlet ikbprintf = ikfprintf\n\nlet fprintf oc fmt = kfprintf ignore oc fmt\nlet bprintf b fmt = kbprintf ignore b fmt\nlet ifprintf oc fmt = ikfprintf ignore oc fmt\nlet ibprintf b fmt = ikbprintf ignore b fmt\nlet printf fmt = fprintf stdout fmt\nlet eprintf fmt = fprintf stderr fmt\n\nlet ksprintf k (Format (fmt, _)) =\n let k' acc =\n let buf = Buffer.create 64 in\n strput_acc buf acc;\n k (Buffer.contents buf) in\n make_printf k' End_of_acc fmt\n\nlet sprintf fmt = ksprintf (fun s -> s) fmt\n\nlet kprintf = ksprintf\n","open! Base\n\nmodule Bigstring0 = struct\n type t =\n ( char\n , Stdlib.Bigarray.int8_unsigned_elt\n , Stdlib.Bigarray.c_layout )\n Stdlib.Bigarray.Array1.t\nend\n\nmodule Array1 = struct\n type ('a, 'b, 'c) t = ('a, 'b, 'c) Stdlib.Bigarray.Array1.t\n\n external get : ('a, 'b, 'c) t -> int -> 'a = \"%caml_ba_ref_1\"\n external set : ('a, 'b, 'c) t -> int -> 'a -> unit = \"%caml_ba_set_1\"\n external unsafe_get : ('a, 'b, 'c) t -> int -> 'a = \"%caml_ba_unsafe_ref_1\"\n external unsafe_set : ('a, 'b, 'c) t -> int -> 'a -> unit = \"%caml_ba_unsafe_set_1\"\n external dim : ('a, 'b, 'c) t -> int = \"%caml_ba_dim_1\"\nend\n\ninclude Bigstring0\n\nexternal aux_create\n : max_mem_waiting_gc_in_bytes:int\n -> size:int\n -> t\n = \"bigstring_alloc\"\n\nlet sprintf = Printf.sprintf\n\n(* One needs to use [Caml.Sys.word_size] so that its value is known at compile-time. *)\nlet arch_sixtyfour = Caml.Sys.word_size = 64\nlet arch_big_endian = Caml.Sys.big_endian\nlet not_on_32bit = Caml.Sys.word_size > 32\n\nlet create ?max_mem_waiting_gc_in_bytes size =\n let max_mem_waiting_gc_in_bytes =\n Option.value max_mem_waiting_gc_in_bytes ~default:(-1)\n in\n (* This check is important because [aux_create ~size:(-1)] raises [Out_of_memory], which\n could be confusing during debugging. *)\n if size < 0 then invalid_arg (sprintf \"create: size = %d < 0\" size);\n aux_create ~max_mem_waiting_gc_in_bytes ~size\n;;\n\nlet length = Array1.dim\n\nexternal is_mmapped : t -> bool = \"bigstring_is_mmapped_stub\" [@@noalloc]\n\nlet init n ~f =\n let t = create n in\n for i = 0 to n - 1 do\n t.{i} <- f i\n done;\n t\n;;\n\nlet check_args ~loc ~pos ~len (bstr : t) =\n if pos < 0 then invalid_arg (loc ^ \": pos < 0\");\n if len < 0 then invalid_arg (loc ^ \": len < 0\");\n let bstr_len = length bstr in\n (* Be careful with overflow! We could have bogons like [pos = Int.max_value] or [len =\n Int.max_value] passed by the user. *)\n if bstr_len - pos < len\n then invalid_arg (sprintf \"Bigstring.%s: length(bstr) < pos + len\" loc)\n;;\n\nlet get_opt_len bstr ~pos = function\n | Some len -> len\n | None -> length bstr - pos\n;;\n\n(* Blitting *)\n\nexternal unsafe_blit\n : src:t\n -> src_pos:int\n -> dst:t\n -> dst_pos:int\n -> len:int\n -> unit\n = \"bigstring_blit_stub\"\n[@@noalloc]\n\n(* Exposing the external version of get/set supports better inlining. *)\nexternal get : t -> int -> char = \"%caml_ba_ref_1\"\nexternal set : t -> int -> char -> unit = \"%caml_ba_set_1\"\n\nmodule Bigstring_sequence = struct\n type nonrec t = t\n\n let create ~len = create len\n let length = length\nend\n\nmodule Bytes_sequence = struct\n type t = bytes\n\n let create ~len = Bytes.create len\n let length = Bytes.length\nend\n\ninclude Blit.Make (struct\n include Bigstring_sequence\n\n let unsafe_blit = unsafe_blit\n end)\n\nmodule From_bytes =\n Blit.Make_distinct\n (Bytes_sequence)\n (struct\n external unsafe_blit\n : src:bytes\n -> src_pos:int\n -> dst:t\n -> dst_pos:int\n -> len:int\n -> unit\n = \"bigstring_blit_bytes_bigstring_stub\"\n [@@noalloc]\n\n include Bigstring_sequence\n end)\n\nmodule To_bytes =\n Blit.Make_distinct\n (Bigstring_sequence)\n (struct\n external unsafe_blit\n : src:t\n -> src_pos:int\n -> dst:bytes\n -> dst_pos:int\n -> len:int\n -> unit\n = \"bigstring_blit_bigstring_bytes_stub\"\n [@@noalloc]\n\n include Bytes_sequence\n end)\n\nmodule From_string =\n Blit.Make_distinct\n (struct\n type t = string\n\n let length = String.length\n end)\n (struct\n external unsafe_blit\n : src:string\n -> src_pos:int\n -> dst:t\n -> dst_pos:int\n -> len:int\n -> unit\n = \"bigstring_blit_string_bigstring_stub\"\n [@@noalloc]\n\n include Bigstring_sequence\n end)\n\nmodule To_string = struct\n include To_bytes\n include Blit.Make_to_string (Bigstring0) (To_bytes)\nend\n\nlet of_string = From_string.subo\nlet of_bytes = From_bytes.subo\nlet to_string = To_string.subo\nlet to_bytes = To_bytes.subo\nlet sexp_of_t t = Sexp.Atom (to_string t)\n\nlet t_of_sexp : Sexp.t -> t = function\n | Atom str -> of_string str\n | List _ as sexp ->\n Sexplib0.Sexp_conv.of_sexp_error \"bigstring_of_sexp: atom needed\" sexp\n;;\n\nlet copy t : t = sub t ~pos:0 ~len:(length t)\n\nlet concat =\n let append ~src ~dst ~dst_pos_ref =\n let len = length src in\n let src_pos = 0 in\n let dst_pos = !dst_pos_ref in\n blit ~dst ~dst_pos ~src ~src_pos ~len;\n dst_pos_ref := dst_pos + len\n in\n fun ?sep list ->\n match list with\n | [] -> create 0\n | head :: tail ->\n let head_len = length head in\n let sep_len = Option.value_map sep ~f:length ~default:0 in\n let tail_count = List.length tail in\n let len =\n head_len + (sep_len * tail_count) + List.sum (module Int) tail ~f:length\n in\n let dst = create len in\n let dst_pos_ref = ref 0 in\n append ~src:head ~dst ~dst_pos_ref;\n List.iter tail ~f:(fun src ->\n (match sep with\n | None -> ()\n | Some sep -> append ~src:sep ~dst ~dst_pos_ref);\n append ~src ~dst ~dst_pos_ref);\n assert (!dst_pos_ref = len);\n dst\n;;\n\nexternal unsafe_memset\n : t\n -> pos:int\n -> len:int\n -> char\n -> unit\n = \"bigstring_memset_stub\"\n[@@noalloc]\n\nlet memset t ~pos ~len c =\n Ordered_collection_common.check_pos_len_exn ~pos ~len ~total_length:(length t);\n unsafe_memset t ~pos ~len c\n;;\n\n(* Comparison *)\n\nexternal unsafe_memcmp\n : t\n -> pos1:int\n -> t\n -> pos2:int\n -> len:int\n -> int\n = \"bigstring_memcmp_stub\"\n[@@noalloc]\n\nlet memcmp t1 ~pos1 t2 ~pos2 ~len =\n Ordered_collection_common.check_pos_len_exn ~pos:pos1 ~len ~total_length:(length t1);\n Ordered_collection_common.check_pos_len_exn ~pos:pos2 ~len ~total_length:(length t2);\n unsafe_memcmp t1 ~pos1 t2 ~pos2 ~len\n;;\n\nlet compare t1 t2 =\n if phys_equal t1 t2\n then 0\n else (\n let len1 = length t1 in\n let len2 = length t2 in\n let len = Int.min len1 len2 in\n match unsafe_memcmp t1 ~pos1:0 t2 ~pos2:0 ~len with\n | 0 -> if len1 < len2 then -1 else if len1 > len2 then 1 else 0\n | n -> n)\n;;\n\nexternal internalhash_fold_bigstring\n : Hash.state\n -> t\n -> Hash.state\n = \"internalhash_fold_bigstring\"\n[@@noalloc]\n\nlet _making_sure_the_C_binding_takes_an_int (x : Hash.state) = (x :> int)\nlet hash_fold_t = internalhash_fold_bigstring\nlet hash = Ppx_hash_lib.Std.Hash.of_fold hash_fold_t\n\ntype t_frozen = t [@@deriving compare, hash, sexp]\n\nlet equal t1 t2 =\n if phys_equal t1 t2\n then true\n else (\n let len1 = length t1 in\n let len2 = length t2 in\n Int.equal len1 len2 && Int.equal (unsafe_memcmp t1 ~pos1:0 t2 ~pos2:0 ~len:len1) 0)\n;;\n\n(* Search *)\n\nexternal unsafe_find : t -> char -> pos:int -> len:int -> int = \"bigstring_find\"\n[@@noalloc]\n\nlet find ?(pos = 0) ?len chr bstr =\n let len = get_opt_len bstr ~pos len in\n check_args ~loc:\"find\" ~pos ~len bstr;\n let res = unsafe_find bstr chr ~pos ~len in\n if res < 0 then None else Some res\n;;\n\n(* vim: set filetype=ocaml : *)\n\n(* Binary-packing like accessors *)\n\nexternal int32_of_int : int -> int32 = \"%int32_of_int\"\nexternal int32_to_int : int32 -> int = \"%int32_to_int\"\nexternal int64_of_int : int -> int64 = \"%int64_of_int\"\nexternal int64_to_int : int64 -> int = \"%int64_to_int\"\nexternal swap16 : int -> int = \"%bswap16\"\nexternal swap32 : int32 -> int32 = \"%bswap_int32\"\nexternal swap64 : int64 -> int64 = \"%bswap_int64\"\nexternal unsafe_get_16 : t -> int -> int = \"%caml_bigstring_get16u\"\nexternal unsafe_get_32 : t -> int -> int32 = \"%caml_bigstring_get32u\"\nexternal unsafe_get_64 : t -> int -> int64 = \"%caml_bigstring_get64u\"\nexternal unsafe_set_16 : t -> int -> int -> unit = \"%caml_bigstring_set16u\"\nexternal unsafe_set_32 : t -> int -> int32 -> unit = \"%caml_bigstring_set32u\"\nexternal unsafe_set_64 : t -> int -> int64 -> unit = \"%caml_bigstring_set64u\"\n\nlet get_16 (t : t) (pos : int) : int =\n check_args ~loc:\"get_16\" ~pos ~len:2 t;\n unsafe_get_16 t pos\n;;\n\nlet get_32 (t : t) (pos : int) : int32 =\n check_args ~loc:\"get_32\" ~pos ~len:4 t;\n unsafe_get_32 t pos\n;;\n\nlet get_64 (t : t) (pos : int) : int64 =\n check_args ~loc:\"get_64\" ~pos ~len:8 t;\n unsafe_get_64 t pos\n;;\n\nlet set_16_trunc (t : t) (pos : int) (v : int) : unit =\n check_args ~loc:\"set_16\" ~pos ~len:2 t;\n unsafe_set_16 t pos v\n;;\n\nlet set_32 (t : t) (pos : int) (v : int32) : unit =\n check_args ~loc:\"set_32\" ~pos ~len:4 t;\n unsafe_set_32 t pos v\n;;\n\nlet set_64 (t : t) (pos : int) (v : int64) : unit =\n check_args ~loc:\"set_64\" ~pos ~len:8 t;\n unsafe_set_64 t pos v\n;;\n\nlet sign_extend_16 u = (u lsl (Int.num_bits - 16)) asr (Int.num_bits - 16)\n\nlet check_valid_uint16 x ~loc =\n if x < 0 || x > 0xFFFF\n then invalid_arg (sprintf \"%s: %d is not a valid unsigned 16-bit integer\" loc x)\n;;\n\nlet check_valid_int16 x ~loc =\n if x < -0x8000 || x > 0x7FFF\n then invalid_arg (sprintf \"%s: %d is not a valid (signed) 16-bit integer\" loc x)\n;;\n\nlet check_valid_uint8 x ~loc =\n if x < 0 || x > 0xFF\n then invalid_arg (sprintf \"%s: %d is not a valid unsigned 8-bit integer\" loc x)\n;;\n\nlet check_valid_int8 x ~loc =\n if x < -0x80 || x > 0x7F\n then invalid_arg (sprintf \"%s: %d is not a valid (signed) 8-bit integer\" loc x)\n;;\n\nlet check_valid_int32 =\n if not arch_sixtyfour\n then fun _ ~loc:_ -> ()\n else\n fun x ~loc ->\n if x >= -1 lsl 31 && x < 1 lsl 31\n then ()\n else invalid_arg (sprintf \"%s: %d is not a valid (signed) 32-bit integer\" loc x)\n;;\n\nlet check_valid_uint32 =\n if not arch_sixtyfour\n then\n fun x ~loc ->\n if x >= 0\n then ()\n else invalid_arg (sprintf \"%s: %d is not a valid unsigned 32-bit integer\" loc x)\n else\n fun x ~loc ->\n if x >= 0 && x < 1 lsl 32\n then ()\n else invalid_arg (sprintf \"%s: %d is not a valid unsigned 32-bit integer\" loc x)\n;;\n\nlet check_valid_uint64 x ~loc =\n if x >= 0\n then ()\n else invalid_arg (sprintf \"%s: %d is not a valid unsigned 64-bit integer\" loc x)\n;;\n\nlet unsafe_read_int16 t ~pos = sign_extend_16 (unsafe_get_16 t pos)\nlet unsafe_read_int16_swap t ~pos = sign_extend_16 (swap16 (unsafe_get_16 t pos))\nlet unsafe_write_int16 t ~pos x = unsafe_set_16 t pos x\nlet unsafe_write_int16_swap t ~pos x = unsafe_set_16 t pos (swap16 x)\nlet read_int16 t ~pos = sign_extend_16 (get_16 t pos)\nlet read_int16_swap t ~pos = sign_extend_16 (swap16 (get_16 t pos))\n\nlet write_int16_exn t ~pos x =\n check_valid_int16 x ~loc:\"Bigstring.write_int16\";\n set_16_trunc t pos x\n;;\n\nlet write_int16_swap_exn t ~pos x =\n (* Omit \"_swap\" from the error message it's bi-endian. *)\n check_valid_int16 x ~loc:\"Bigstring.write_int16\";\n set_16_trunc t pos (swap16 x)\n;;\n\nlet unsafe_read_uint16 t ~pos = unsafe_get_16 t pos\nlet unsafe_read_uint16_swap t ~pos = swap16 (unsafe_get_16 t pos)\nlet unsafe_write_uint16 t ~pos x = unsafe_set_16 t pos x\nlet unsafe_write_uint16_swap t ~pos x = unsafe_set_16 t pos (swap16 x)\nlet read_uint16 t ~pos = get_16 t pos\nlet read_uint16_swap t ~pos = swap16 (get_16 t pos)\n\nlet write_uint16_exn t ~pos x =\n check_valid_uint16 x ~loc:\"Bigstring.write_uint16\";\n set_16_trunc t pos x\n;;\n\nlet write_uint16_swap_exn t ~pos x =\n (* Omit \"_swap\" from the error message it's bi-endian. *)\n check_valid_uint16 x ~loc:\"Bigstring.write_uint16\";\n set_16_trunc t pos (swap16 x)\n;;\n\nlet unsafe_read_int32_int t ~pos = int32_to_int (unsafe_get_32 t pos)\nlet unsafe_read_int32_int_swap t ~pos = int32_to_int (swap32 (unsafe_get_32 t pos))\nlet unsafe_read_int32 t ~pos = unsafe_get_32 t pos\nlet unsafe_read_int32_swap t ~pos = swap32 (unsafe_get_32 t pos)\nlet unsafe_write_int32 t ~pos x = unsafe_set_32 t pos x\nlet unsafe_write_int32_swap t ~pos x = unsafe_set_32 t pos (swap32 x)\nlet unsafe_write_int32_int t ~pos x = unsafe_set_32 t pos (int32_of_int x)\nlet unsafe_write_int32_int_swap t ~pos x = unsafe_set_32 t pos (swap32 (int32_of_int x))\nlet read_int32_int t ~pos = int32_to_int (get_32 t pos)\nlet read_int32_int_swap t ~pos = int32_to_int (swap32 (get_32 t pos))\nlet read_int32 t ~pos = get_32 t pos\nlet read_int32_swap t ~pos = swap32 (get_32 t pos)\nlet write_int32 t ~pos x = set_32 t pos x\nlet write_int32_swap t ~pos x = set_32 t pos (swap32 x)\n\nlet write_int32_int_exn t ~pos x =\n check_valid_int32 x ~loc:\"Bigstring.write_int32_int\";\n set_32 t pos (int32_of_int x)\n;;\n\nlet write_int32_int_swap_exn t ~pos x =\n (* Omit \"_swap\" from the error message it's bi-endian. *)\n check_valid_int32 x ~loc:\"Bigstring.write_int32_int\";\n set_32 t pos (swap32 (int32_of_int x))\n;;\n\nlet unsafe_read_int64_int t ~pos = int64_to_int (unsafe_get_64 t pos)\nlet unsafe_read_int64_int_swap t ~pos = int64_to_int (swap64 (unsafe_get_64 t pos))\nlet unsafe_read_int64 t ~pos = unsafe_get_64 t pos\nlet unsafe_read_int64_swap t ~pos = swap64 (unsafe_get_64 t pos)\nlet unsafe_write_int64 t ~pos x = unsafe_set_64 t pos x\nlet unsafe_write_int64_swap t ~pos x = unsafe_set_64 t pos (swap64 x)\nlet unsafe_write_int64_int t ~pos x = unsafe_set_64 t pos (int64_of_int x)\nlet unsafe_write_int64_int_swap t ~pos x = unsafe_set_64 t pos (swap64 (int64_of_int x))\nlet read_int64_int t ~pos = int64_to_int (get_64 t pos)\nlet read_int64_int_swap t ~pos = int64_to_int (swap64 (get_64 t pos))\nlet read_int64 t ~pos = get_64 t pos\nlet read_int64_swap t ~pos = swap64 (get_64 t pos)\nlet write_int64 t ~pos x = set_64 t pos x\nlet write_int64_swap t ~pos x = set_64 t pos (swap64 x)\nlet write_int64_int t ~pos x = set_64 t pos (int64_of_int x)\nlet write_int64_int_swap t ~pos x = set_64 t pos (swap64 (int64_of_int x))\n\nlet unsafe_get_int16_be =\n if arch_big_endian then unsafe_read_int16 else unsafe_read_int16_swap\n;;\n\nlet unsafe_get_int16_le =\n if arch_big_endian then unsafe_read_int16_swap else unsafe_read_int16\n;;\n\nlet unsafe_get_uint16_be =\n if arch_big_endian then unsafe_read_uint16 else unsafe_read_uint16_swap\n;;\n\nlet unsafe_get_uint16_le =\n if arch_big_endian then unsafe_read_uint16_swap else unsafe_read_uint16\n;;\n\nlet get_int16_be = if arch_big_endian then read_int16 else read_int16_swap\nlet get_int16_le = if arch_big_endian then read_int16_swap else read_int16\nlet get_uint16_be = if arch_big_endian then read_uint16 else read_uint16_swap\nlet get_uint16_le = if arch_big_endian then read_uint16_swap else read_uint16\n\nlet unsafe_set_int16_be =\n if arch_big_endian then unsafe_write_int16 else unsafe_write_int16_swap\n;;\n\nlet unsafe_set_int16_le =\n if arch_big_endian then unsafe_write_int16_swap else unsafe_write_int16\n;;\n\nlet unsafe_set_uint16_be =\n if arch_big_endian then unsafe_write_uint16 else unsafe_write_uint16_swap\n;;\n\nlet unsafe_set_uint16_le =\n if arch_big_endian then unsafe_write_uint16_swap else unsafe_write_uint16\n;;\n\nlet set_int16_be_exn = if arch_big_endian then write_int16_exn else write_int16_swap_exn\nlet set_int16_le_exn = if arch_big_endian then write_int16_swap_exn else write_int16_exn\n\nlet set_uint16_be_exn =\n if arch_big_endian then write_uint16_exn else write_uint16_swap_exn\n;;\n\nlet set_uint16_le_exn =\n if arch_big_endian then write_uint16_swap_exn else write_uint16_exn\n;;\n\nlet unsafe_get_int32_t_be =\n if arch_big_endian then unsafe_read_int32 else unsafe_read_int32_swap\n;;\n\nlet unsafe_get_int32_t_le =\n if arch_big_endian then unsafe_read_int32_swap else unsafe_read_int32\n;;\n\nlet unsafe_set_int32_t_be =\n if arch_big_endian then unsafe_write_int32 else unsafe_write_int32_swap\n;;\n\nlet unsafe_set_int32_t_le =\n if arch_big_endian then unsafe_write_int32_swap else unsafe_write_int32\n;;\n\nlet get_int32_t_be = if arch_big_endian then read_int32 else read_int32_swap\nlet get_int32_t_le = if arch_big_endian then read_int32_swap else read_int32\nlet set_int32_t_be = if arch_big_endian then write_int32 else write_int32_swap\nlet set_int32_t_le = if arch_big_endian then write_int32_swap else write_int32\n\nlet unsafe_get_int32_be =\n if arch_big_endian then unsafe_read_int32_int else unsafe_read_int32_int_swap\n;;\n\nlet unsafe_get_int32_le =\n if arch_big_endian then unsafe_read_int32_int_swap else unsafe_read_int32_int\n;;\n\nlet unsafe_set_int32_be =\n if arch_big_endian then unsafe_write_int32_int else unsafe_write_int32_int_swap\n;;\n\nlet unsafe_set_int32_le =\n if arch_big_endian then unsafe_write_int32_int_swap else unsafe_write_int32_int\n;;\n\nlet get_int32_be = if arch_big_endian then read_int32_int else read_int32_int_swap\nlet get_int32_le = if arch_big_endian then read_int32_int_swap else read_int32_int\n\nlet set_int32_be_exn =\n if arch_big_endian then write_int32_int_exn else write_int32_int_swap_exn\n;;\n\nlet set_int32_le_exn =\n if arch_big_endian then write_int32_int_swap_exn else write_int32_int_exn\n;;\n\nlet unsafe_get_int64_be_trunc =\n if arch_big_endian then unsafe_read_int64_int else unsafe_read_int64_int_swap\n;;\n\nlet unsafe_get_int64_le_trunc =\n if arch_big_endian then unsafe_read_int64_int_swap else unsafe_read_int64_int\n;;\n\nlet unsafe_set_int64_be =\n if arch_big_endian then unsafe_write_int64_int else unsafe_write_int64_int_swap\n;;\n\nlet unsafe_set_int64_le =\n if arch_big_endian then unsafe_write_int64_int_swap else unsafe_write_int64_int\n;;\n\nlet get_int64_be_trunc = if arch_big_endian then read_int64_int else read_int64_int_swap\nlet get_int64_le_trunc = if arch_big_endian then read_int64_int_swap else read_int64_int\nlet set_int64_be = if arch_big_endian then write_int64_int else write_int64_int_swap\nlet set_int64_le = if arch_big_endian then write_int64_int_swap else write_int64_int\n\nlet unsafe_get_int64_t_be =\n if arch_big_endian then unsafe_read_int64 else unsafe_read_int64_swap\n;;\n\nlet unsafe_get_int64_t_le =\n if arch_big_endian then unsafe_read_int64_swap else unsafe_read_int64\n;;\n\nlet unsafe_set_int64_t_be =\n if arch_big_endian then unsafe_write_int64 else unsafe_write_int64_swap\n;;\n\nlet unsafe_set_int64_t_le =\n if arch_big_endian then unsafe_write_int64_swap else unsafe_write_int64\n;;\n\nlet get_int64_t_be = if arch_big_endian then read_int64 else read_int64_swap\nlet get_int64_t_le = if arch_big_endian then read_int64_swap else read_int64\nlet set_int64_t_be = if arch_big_endian then write_int64 else write_int64_swap\nlet set_int64_t_le = if arch_big_endian then write_int64_swap else write_int64\n\nlet int64_conv_error () =\n failwith \"unsafe_read_int64: value cannot be represented unboxed!\"\n;;\n\nlet uint64_conv_error () =\n failwith \"unsafe_read_uint64: value cannot be represented unboxed!\"\n;;\n\n(* [Poly] is required so that we can compare unboxed [int64]. *)\nlet int64_to_int_exn n =\n if arch_sixtyfour\n then\n if Poly.(n >= -0x4000_0000_0000_0000L && n < 0x4000_0000_0000_0000L)\n then int64_to_int n\n else int64_conv_error ()\n else if Poly.(n >= -0x0000_0000_4000_0000L && n < 0x0000_0000_4000_0000L)\n then int64_to_int n\n else int64_conv_error ()\n;;\n\nlet uint64_to_int_exn n =\n if arch_sixtyfour\n then\n if Poly.(n >= 0L && n < 0x4000_0000_0000_0000L)\n then int64_to_int n\n else uint64_conv_error ()\n else if Poly.(n >= 0L && n < 0x0000_0000_4000_0000L)\n then int64_to_int n\n else uint64_conv_error ()\n;;\n\nlet unsafe_get_int64_be_exn t ~pos = int64_to_int_exn (unsafe_get_int64_t_be t ~pos)\nlet unsafe_get_int64_le_exn t ~pos = int64_to_int_exn (unsafe_get_int64_t_le t ~pos)\nlet get_int64_be_exn t ~pos = int64_to_int_exn (get_int64_t_be t ~pos)\nlet get_int64_le_exn t ~pos = int64_to_int_exn (get_int64_t_le t ~pos)\nlet unsafe_get_uint64_be_exn t ~pos = uint64_to_int_exn (unsafe_get_int64_t_be t ~pos)\nlet unsafe_get_uint64_le_exn t ~pos = uint64_to_int_exn (unsafe_get_int64_t_le t ~pos)\nlet get_uint64_be_exn t ~pos = uint64_to_int_exn (get_int64_t_be t ~pos)\nlet get_uint64_le_exn t ~pos = uint64_to_int_exn (get_int64_t_le t ~pos)\nlet unsafe_set_uint64_be = unsafe_set_int64_be\nlet unsafe_set_uint64_le = unsafe_set_int64_le\n\nlet set_uint64_be_exn t ~pos n =\n check_valid_uint64 ~loc:\"Bigstring.set_uint64_be_exn\" n;\n set_int64_be t ~pos n\n;;\n\nlet set_uint64_le_exn t ~pos n =\n check_valid_uint64 ~loc:\"Bigstring.set_uint64_le_exn\" n;\n set_int64_le t ~pos n\n;;\n\n(* Type annotations on the [t]s are important here: in order for the compiler to generate\n optimized code, it needs to know the fully instantiated type of the bigarray. This is\n because the type of the bigarray encodes the element kind and the layout of the\n bigarray. Without the annotation the compiler generates a C call to the generic access\n functions. *)\nlet unsafe_set_uint8 (t : t) ~pos n = Array1.unsafe_set t pos (Char.unsafe_of_int n)\n\nlet unsafe_set_int8 (t : t) ~pos n =\n (* In all the set functions where there are these tests, it looks like the test could be\n removed, since they are only changing the values of the bytes that are not\n written. *)\n let n = if n < 0 then n + 256 else n in\n Array1.unsafe_set t pos (Char.unsafe_of_int n)\n;;\n\nlet unsafe_get_uint8 (t : t) ~pos = Char.to_int (Array1.unsafe_get t pos)\n\nlet unsafe_get_int8 (t : t) ~pos =\n let n = Char.to_int (Array1.unsafe_get t pos) in\n if n >= 128 then n - 256 else n\n;;\n\nlet set_uint8_exn (t : t) ~pos n =\n check_valid_uint8 ~loc:\"Bigstring.set_uint8_exn\" n;\n Array1.set t pos (Char.unsafe_of_int n)\n;;\n\nlet set_int8_exn (t : t) ~pos n =\n check_valid_int8 ~loc:\"Bigstring.set_int8_exn\" n;\n let n = if n < 0 then n + 256 else n in\n Array1.set t pos (Char.unsafe_of_int n)\n;;\n\nlet get_uint8 (t : t) ~pos = Char.to_int (Array1.get t pos)\n\nlet get_int8 (t : t) ~pos =\n let n = Char.to_int (Array1.get t pos) in\n if n >= 128 then n - 256 else n\n;;\n\nlet unsafe_set_uint32_le t ~pos n =\n let n = if not_on_32bit && n >= 1 lsl 31 then n - (1 lsl 32) else n in\n unsafe_set_int32_le t ~pos n\n;;\n\nlet unsafe_set_uint32_be t ~pos n =\n let n = if not_on_32bit && n >= 1 lsl 31 then n - (1 lsl 32) else n in\n unsafe_set_int32_be t ~pos n\n;;\n\nlet unsafe_get_uint32_le t ~pos =\n let n = unsafe_get_int32_le t ~pos in\n if not_on_32bit && n < 0 then n + (1 lsl 32) else n\n;;\n\nlet unsafe_get_uint32_be t ~pos =\n let n = unsafe_get_int32_be t ~pos in\n if not_on_32bit && n < 0 then n + (1 lsl 32) else n\n;;\n\nlet set_uint32_le_exn t ~pos n =\n check_valid_uint32 ~loc:\"Bigstring.set_uint32_le_exn\" n;\n let n = if not_on_32bit && n >= 1 lsl 31 then n - (1 lsl 32) else n in\n set_int32_le_exn t ~pos n\n;;\n\nlet set_uint32_be_exn t ~pos n =\n check_valid_uint32 ~loc:\"Bigstring.set_uint32_be_exn\" n;\n let n = if not_on_32bit && n >= 1 lsl 31 then n - (1 lsl 32) else n in\n set_int32_be_exn t ~pos n\n;;\n\nlet get_uint32_le t ~pos =\n let n = get_int32_le t ~pos in\n if not_on_32bit && n < 0 then n + (1 lsl 32) else n\n;;\n\nlet get_uint32_be t ~pos =\n let n = get_int32_be t ~pos in\n if not_on_32bit && n < 0 then n + (1 lsl 32) else n\n;;\n\nmodule Private = struct\n let sign_extend_16 = sign_extend_16\nend\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Damien Doligez, projet Para, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\ntype key = string\ntype doc = string\ntype usage_msg = string\ntype anon_fun = (string -> unit)\n\ntype spec =\n | Unit of (unit -> unit) (* Call the function with unit argument *)\n | Bool of (bool -> unit) (* Call the function with a bool argument *)\n | Set of bool ref (* Set the reference to true *)\n | Clear of bool ref (* Set the reference to false *)\n | String of (string -> unit) (* Call the function with a string argument *)\n | Set_string of string ref (* Set the reference to the string argument *)\n | Int of (int -> unit) (* Call the function with an int argument *)\n | Set_int of int ref (* Set the reference to the int argument *)\n | Float of (float -> unit) (* Call the function with a float argument *)\n | Set_float of float ref (* Set the reference to the float argument *)\n | Tuple of spec list (* Take several arguments according to the\n spec list *)\n | Symbol of string list * (string -> unit)\n (* Take one of the symbols as argument and\n call the function with the symbol. *)\n | Rest of (string -> unit) (* Stop interpreting keywords and call the\n function with each remaining argument *)\n | Rest_all of (string list -> unit)\n (* Stop interpreting keywords and call the\n function with all remaining arguments. *)\n | Expand of (string -> string array) (* If the remaining arguments to process\n are of the form\n [[\"-foo\"; \"arg\"] @ rest] where \"foo\"\n is registered as [Expand f], then the\n arguments [f \"arg\" @ rest] are\n processed. Only allowed in\n [parse_and_expand_argv_dynamic]. *)\n\nexception Bad of string\nexception Help of string\n\ntype error =\n | Unknown of string\n | Wrong of string * string * string (* option, actual, expected *)\n | Missing of string\n | Message of string\n\nexception Stop of error (* used internally *)\n\nopen Printf\n\nlet rec assoc3 x l =\n match l with\n | [] -> raise Not_found\n | (y1, y2, _) :: _ when y1 = x -> y2\n | _ :: t -> assoc3 x t\n\n\nlet split s =\n let i = String.index s '=' in\n let len = String.length s in\n String.sub s 0 i, String.sub s (i+1) (len-(i+1))\n\n\nlet make_symlist prefix sep suffix l =\n match l with\n | [] -> \"\"\n | h::t -> (List.fold_left (fun x y -> x ^ sep ^ y) (prefix ^ h) t) ^ suffix\n\n\nlet print_spec buf (key, spec, doc) =\n if String.length doc > 0 then\n match spec with\n | Symbol (l, _) ->\n bprintf buf \" %s %s%s\\n\" key (make_symlist \"{\" \"|\" \"}\" l) doc\n | _ ->\n bprintf buf \" %s %s\\n\" key doc\n\n\nlet help_action () = raise (Stop (Unknown \"-help\"))\n\nlet add_help speclist =\n let add1 =\n try ignore (assoc3 \"-help\" speclist); []\n with Not_found ->\n [\"-help\", Unit help_action, \" Display this list of options\"]\n and add2 =\n try ignore (assoc3 \"--help\" speclist); []\n with Not_found ->\n [\"--help\", Unit help_action, \" Display this list of options\"]\n in\n speclist @ (add1 @ add2)\n\n\nlet usage_b buf speclist errmsg =\n bprintf buf \"%s\\n\" errmsg;\n List.iter (print_spec buf) (add_help speclist)\n\n\nlet usage_string speclist errmsg =\n let b = Buffer.create 200 in\n usage_b b speclist errmsg;\n Buffer.contents b\n\n\nlet usage speclist errmsg =\n eprintf \"%s\" (usage_string speclist errmsg)\n\n\nlet current = ref 0\n\nlet bool_of_string_opt x =\n try Some (bool_of_string x)\n with Invalid_argument _ -> None\n\nlet int_of_string_opt x =\n try Some (int_of_string x)\n with Failure _ -> None\n\nlet float_of_string_opt x =\n try Some (float_of_string x)\n with Failure _ -> None\n\nlet parse_and_expand_argv_dynamic_aux allow_expand current argv speclist anonfun\n errmsg =\n let initpos = !current in\n let convert_error error =\n (* convert an internal error to a Bad/Help exception\n *or* add the program name as a prefix and the usage message as a suffix\n to an user-raised Bad exception.\n *)\n let b = Buffer.create 200 in\n let progname =\n if initpos < (Array.length !argv) then !argv.(initpos) else \"(?)\" in\n begin match error with\n | Unknown \"-help\" -> ()\n | Unknown \"--help\" -> ()\n | Unknown s ->\n bprintf b \"%s: unknown option '%s'.\\n\" progname s\n | Missing s ->\n bprintf b \"%s: option '%s' needs an argument.\\n\" progname s\n | Wrong (opt, arg, expected) ->\n bprintf b \"%s: wrong argument '%s'; option '%s' expects %s.\\n\"\n progname arg opt expected\n | Message s -> (* user error message *)\n bprintf b \"%s: %s.\\n\" progname s\n end;\n usage_b b !speclist errmsg;\n if error = Unknown \"-help\" || error = Unknown \"--help\"\n then Help (Buffer.contents b)\n else Bad (Buffer.contents b)\n in\n incr current;\n while !current < (Array.length !argv) do\n begin try\n let s = !argv.(!current) in\n if String.length s >= 1 && s.[0] = '-' then begin\n let action, follow =\n try assoc3 s !speclist, None\n with Not_found ->\n try\n let keyword, arg = split s in\n assoc3 keyword !speclist, Some arg\n with Not_found -> raise (Stop (Unknown s))\n in\n let no_arg () =\n match follow with\n | None -> ()\n | Some arg -> raise (Stop (Wrong (s, arg, \"no argument\"))) in\n let get_arg () =\n match follow with\n | None ->\n if !current + 1 < (Array.length !argv) then !argv.(!current + 1)\n else raise (Stop (Missing s))\n | Some arg -> arg\n in\n let consume_arg () =\n match follow with\n | None -> incr current\n | Some _ -> ()\n in\n let rec treat_action = function\n | Unit f -> no_arg (); f ();\n | Bool f ->\n let arg = get_arg () in\n begin match bool_of_string_opt arg with\n | None -> raise (Stop (Wrong (s, arg, \"a boolean\")))\n | Some s -> f s\n end;\n consume_arg ();\n | Set r -> no_arg (); r := true;\n | Clear r -> no_arg (); r := false;\n | String f ->\n let arg = get_arg () in\n f arg;\n consume_arg ();\n | Symbol (symb, f) ->\n let arg = get_arg () in\n if List.mem arg symb then begin\n f arg;\n consume_arg ();\n end else begin\n raise (Stop (Wrong (s, arg, \"one of: \"\n ^ (make_symlist \"\" \" \" \"\" symb))))\n end\n | Set_string r ->\n r := get_arg ();\n consume_arg ();\n | Int f ->\n let arg = get_arg () in\n begin match int_of_string_opt arg with\n | None -> raise (Stop (Wrong (s, arg, \"an integer\")))\n | Some x -> f x\n end;\n consume_arg ();\n | Set_int r ->\n let arg = get_arg () in\n begin match int_of_string_opt arg with\n | None -> raise (Stop (Wrong (s, arg, \"an integer\")))\n | Some x -> r := x\n end;\n consume_arg ();\n | Float f ->\n let arg = get_arg () in\n begin match float_of_string_opt arg with\n | None -> raise (Stop (Wrong (s, arg, \"a float\")))\n | Some x -> f x\n end;\n consume_arg ();\n | Set_float r ->\n let arg = get_arg () in\n begin match float_of_string_opt arg with\n | None -> raise (Stop (Wrong (s, arg, \"a float\")))\n | Some x -> r := x\n end;\n consume_arg ();\n | Tuple specs ->\n no_arg ();\n List.iter treat_action specs;\n | Rest f ->\n no_arg ();\n while !current < (Array.length !argv) - 1 do\n f !argv.(!current + 1);\n consume_arg ();\n done;\n | Rest_all f ->\n no_arg ();\n let acc = ref [] in\n while !current < Array.length !argv - 1 do\n acc := !argv.(!current + 1) :: !acc;\n consume_arg ();\n done;\n f (List.rev !acc)\n | Expand f ->\n if not allow_expand then\n raise (Invalid_argument \"Arg.Expand is is only allowed with \\\n Arg.parse_and_expand_argv_dynamic\");\n let arg = get_arg () in\n let newarg = f arg in\n consume_arg ();\n let before = Array.sub !argv 0 (!current + 1)\n and after =\n Array.sub !argv (!current + 1)\n ((Array.length !argv) - !current - 1) in\n argv:= Array.concat [before;newarg;after];\n in\n treat_action action end\n else anonfun s\n with | Bad m -> raise (convert_error (Message m));\n | Stop e -> raise (convert_error e);\n end;\n incr current\n done\n\nlet parse_and_expand_argv_dynamic current argv speclist anonfun errmsg =\n parse_and_expand_argv_dynamic_aux true current argv speclist anonfun errmsg\n\nlet parse_argv_dynamic ?(current=current) argv speclist anonfun errmsg =\n parse_and_expand_argv_dynamic_aux false current (ref argv) speclist anonfun\n errmsg\n\n\nlet parse_argv ?(current=current) argv speclist anonfun errmsg =\n parse_argv_dynamic ~current:current argv (ref speclist) anonfun errmsg\n\n\nlet parse l f msg =\n try\n parse_argv Sys.argv l f msg\n with\n | Bad msg -> eprintf \"%s\" msg; exit 2\n | Help msg -> printf \"%s\" msg; exit 0\n\n\nlet parse_dynamic l f msg =\n try\n parse_argv_dynamic Sys.argv l f msg\n with\n | Bad msg -> eprintf \"%s\" msg; exit 2\n | Help msg -> printf \"%s\" msg; exit 0\n\nlet parse_expand l f msg =\n try\n let argv = ref Sys.argv in\n let spec = ref l in\n let current = ref (!current) in\n parse_and_expand_argv_dynamic current argv spec f msg\n with\n | Bad msg -> eprintf \"%s\" msg; exit 2\n | Help msg -> printf \"%s\" msg; exit 0\n\n\nlet second_word s =\n let len = String.length s in\n let rec loop n =\n if n >= len then len\n else if s.[n] = ' ' then loop (n+1)\n else n\n in\n match String.index s '\\t' with\n | n -> loop (n+1)\n | exception Not_found ->\n begin match String.index s ' ' with\n | n -> loop (n+1)\n | exception Not_found -> len\n end\n\n\nlet max_arg_len cur (kwd, spec, doc) =\n match spec with\n | Symbol _ -> Int.max cur (String.length kwd)\n | _ -> Int.max cur (String.length kwd + second_word doc)\n\n\nlet replace_leading_tab s =\n let seen = ref false in\n String.map (function '\\t' when not !seen -> seen := true; ' ' | c -> c) s\n\nlet add_padding len ksd =\n match ksd with\n | (_, _, \"\") ->\n (* Do not pad undocumented options, so that they still don't show up when\n * run through [usage] or [parse]. *)\n ksd\n | (kwd, (Symbol _ as spec), msg) ->\n let cutcol = second_word msg in\n let spaces = String.make ((Int.max 0 (len - cutcol)) + 3) ' ' in\n (kwd, spec, \"\\n\" ^ spaces ^ replace_leading_tab msg)\n | (kwd, spec, msg) ->\n let cutcol = second_word msg in\n let kwd_len = String.length kwd in\n let diff = len - kwd_len - cutcol in\n if diff <= 0 then\n (kwd, spec, replace_leading_tab msg)\n else\n let spaces = String.make diff ' ' in\n let prefix = String.sub (replace_leading_tab msg) 0 cutcol in\n let suffix = String.sub msg cutcol (String.length msg - cutcol) in\n (kwd, spec, prefix ^ spaces ^ suffix)\n\n\nlet align ?(limit=max_int) speclist =\n let completed = add_help speclist in\n let len = List.fold_left max_arg_len 0 completed in\n let len = Int.min len limit in\n List.map (add_padding len) completed\n\nlet trim_cr s =\n let len = String.length s in\n if len > 0 && String.get s (len - 1) = '\\r' then\n String.sub s 0 (len - 1)\n else\n s\n\nlet read_aux trim sep file =\n let ic = open_in_bin file in\n let buf = Buffer.create 200 in\n let words = ref [] in\n let stash () =\n let word = Buffer.contents buf in\n let word = if trim then trim_cr word else word in\n words := word :: !words;\n Buffer.clear buf\n in\n begin\n try while true do\n let c = input_char ic in\n if c = sep then stash () else Buffer.add_char buf c\n done\n with End_of_file -> ()\n end;\n if Buffer.length buf > 0 then stash ();\n close_in ic;\n Array.of_list (List.rev !words)\n\nlet read_arg = read_aux true '\\n'\n\nlet read_arg0 = read_aux false '\\x00'\n\nlet write_aux sep file args =\n let oc = open_out_bin file in\n Array.iter (fun s -> fprintf oc \"%s%c\" s sep) args;\n close_out oc\n\nlet write_arg = write_aux '\\n'\n\nlet write_arg0 = write_aux '\\x00'\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* The OCaml programmers *)\n(* *)\n(* Copyright 2018 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nexternal id : 'a -> 'a = \"%identity\"\nlet const c _ = c\nlet flip f x y = f y x\nlet negate p v = not (p v)\n\nexception Finally_raised of exn\n\nlet () = Printexc.register_printer @@ function\n| Finally_raised exn -> Some (\"Fun.Finally_raised: \" ^ Printexc.to_string exn)\n| _ -> None\n\nlet protect ~(finally : unit -> unit) work =\n let finally_no_exn () =\n try finally () with e ->\n let bt = Printexc.get_raw_backtrace () in\n Printexc.raise_with_backtrace (Finally_raised e) bt\n in\n match work () with\n | result -> finally_no_exn () ; result\n | exception work_exn ->\n let work_bt = Printexc.get_raw_backtrace () in\n finally_no_exn () ;\n Printexc.raise_with_backtrace work_exn work_bt\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* Message digest (MD5) *)\n\ntype t = string\n\nlet compare = String.compare\nlet equal = String.equal\n\nexternal unsafe_string: string -> int -> int -> t = \"caml_md5_string\"\nexternal channel: in_channel -> int -> t = \"caml_md5_chan\"\n\nlet string str =\n unsafe_string str 0 (String.length str)\n\nlet bytes b = string (Bytes.unsafe_to_string b)\n\nlet substring str ofs len =\n if ofs < 0 || len < 0 || ofs > String.length str - len\n then invalid_arg \"Digest.substring\"\n else unsafe_string str ofs len\n\nlet subbytes b ofs len = substring (Bytes.unsafe_to_string b) ofs len\n\nlet file filename =\n let ic = open_in_bin filename in\n match channel ic (-1) with\n | d -> close_in ic; d\n | exception e -> close_in ic; raise e\n\nlet output chan digest =\n output_string chan digest\n\nlet input chan = really_input_string chan 16\n\nlet char_hex n =\n Char.unsafe_chr (n + if n < 10 then Char.code '0' else (Char.code 'a' - 10))\n\nlet to_hex d =\n if String.length d <> 16 then invalid_arg \"Digest.to_hex\";\n let result = Bytes.create 32 in\n for i = 0 to 15 do\n let x = Char.code d.[i] in\n Bytes.unsafe_set result (i*2) (char_hex (x lsr 4));\n Bytes.unsafe_set result (i*2+1) (char_hex (x land 0x0f));\n done;\n Bytes.unsafe_to_string result\n\nlet from_hex s =\n if String.length s <> 32 then invalid_arg \"Digest.from_hex\";\n let digit c =\n match c with\n | '0'..'9' -> Char.code c - Char.code '0'\n | 'A'..'F' -> Char.code c - Char.code 'A' + 10\n | 'a'..'f' -> Char.code c - Char.code 'a' + 10\n | _ -> raise (Invalid_argument \"Digest.from_hex\")\n in\n let byte i = digit s.[i] lsl 4 + digit s.[i+1] in\n let result = Bytes.create 16 in\n for i = 0 to 15 do\n Bytes.set result i (Char.chr (byte (2 * i)));\n done;\n Bytes.unsafe_to_string result\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Damien Doligez, projet Para, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* Pseudo-random number generator\n This is a lagged-Fibonacci F(55, 24, +) with a modified addition\n function to enhance the mixing of bits.\n If we use normal addition, the low-order bit fails tests 1 and 7\n of the Diehard test suite, and bits 1 and 2 also fail test 7.\n If we use multiplication as suggested by Marsaglia, it doesn't fare\n much better.\n By mixing the bits of one of the numbers before addition (XOR the\n 5 high-order bits into the low-order bits), we get a generator that\n passes all the Diehard tests.\n*)\n\nexternal random_seed: unit -> int array = \"caml_sys_random_seed\"\n\nmodule State = struct\n\n type t = { st : int array; mutable idx : int }\n\n let new_state () = { st = Array.make 55 0; idx = 0 }\n let assign st1 st2 =\n Array.blit st2.st 0 st1.st 0 55;\n st1.idx <- st2.idx\n\n\n let full_init s seed =\n let combine accu x = Digest.string (accu ^ Int.to_string x) in\n let extract d =\n Char.code d.[0] + (Char.code d.[1] lsl 8) + (Char.code d.[2] lsl 16)\n + (Char.code d.[3] lsl 24)\n in\n let seed = if Array.length seed = 0 then [| 0 |] else seed in\n let l = Array.length seed in\n for i = 0 to 54 do\n s.st.(i) <- i;\n done;\n let accu = ref \"x\" in\n for i = 0 to 54 + Int.max 55 l do\n let j = i mod 55 in\n let k = i mod l in\n accu := combine !accu seed.(k);\n s.st.(j) <- (s.st.(j) lxor extract !accu) land 0x3FFFFFFF; (* PR#5575 *)\n done;\n s.idx <- 0\n\n\n let make seed =\n let result = new_state () in\n full_init result seed;\n result\n\n\n let make_self_init () = make (random_seed ())\n\n let copy s =\n let result = new_state () in\n assign result s;\n result\n\n\n (* Returns 30 random bits as an integer 0 <= x < 1073741824 *)\n let bits s =\n s.idx <- (s.idx + 1) mod 55;\n let curval = s.st.(s.idx) in\n let newval = s.st.((s.idx + 24) mod 55)\n + (curval lxor ((curval lsr 25) land 0x1F)) in\n let newval30 = newval land 0x3FFFFFFF in (* PR#5575 *)\n s.st.(s.idx) <- newval30;\n newval30\n\n\n let rec intaux s n =\n let r = bits s in\n let v = r mod n in\n if r - v > 0x3FFFFFFF - n + 1 then intaux s n else v\n\n let int s bound =\n if bound > 0x3FFFFFFF || bound <= 0\n then invalid_arg \"Random.int\"\n else intaux s bound\n\n let rec int63aux s n =\n let max_int_32 = (1 lsl 30) + 0x3FFFFFFF in (* 0x7FFFFFFF *)\n let b1 = bits s in\n let b2 = bits s in\n let (r, max_int) =\n if n <= max_int_32 then\n (* 31 random bits on both 64-bit OCaml and JavaScript.\n Use upper 15 bits of b1 and 16 bits of b2. *)\n let bpos =\n (((b2 land 0x3FFFC000) lsl 1) lor (b1 lsr 15))\n in\n (bpos, max_int_32)\n else\n let b3 = bits s in\n (* 62 random bits on 64-bit OCaml; unreachable on JavaScript.\n Use upper 20 bits of b1 and 21 bits of b2 and b3. *)\n let bpos =\n ((((b3 land 0x3FFFFE00) lsl 12) lor (b2 lsr 9)) lsl 20)\n lor (b1 lsr 10)\n in\n (bpos, max_int)\n in\n let v = r mod n in\n if r - v > max_int - n + 1 then int63aux s n else v\n\n let full_int s bound =\n if bound <= 0 then\n invalid_arg \"Random.full_int\"\n else if bound > 0x3FFFFFFF then\n int63aux s bound\n else\n intaux s bound\n\n\n let rec int32aux s n =\n let b1 = Int32.of_int (bits s) in\n let b2 = Int32.shift_left (Int32.of_int (bits s land 1)) 30 in\n let r = Int32.logor b1 b2 in\n let v = Int32.rem r n in\n if Int32.sub r v > Int32.add (Int32.sub Int32.max_int n) 1l\n then int32aux s n\n else v\n\n let int32 s bound =\n if bound <= 0l\n then invalid_arg \"Random.int32\"\n else int32aux s bound\n\n\n let rec int64aux s n =\n let b1 = Int64.of_int (bits s) in\n let b2 = Int64.shift_left (Int64.of_int (bits s)) 30 in\n let b3 = Int64.shift_left (Int64.of_int (bits s land 7)) 60 in\n let r = Int64.logor b1 (Int64.logor b2 b3) in\n let v = Int64.rem r n in\n if Int64.sub r v > Int64.add (Int64.sub Int64.max_int n) 1L\n then int64aux s n\n else v\n\n let int64 s bound =\n if bound <= 0L\n then invalid_arg \"Random.int64\"\n else int64aux s bound\n\n\n let nativeint =\n if Nativeint.size = 32\n then fun s bound -> Nativeint.of_int32 (int32 s (Nativeint.to_int32 bound))\n else fun s bound -> Int64.to_nativeint (int64 s (Int64.of_nativeint bound))\n\n\n (* Returns a float 0 <= x <= 1 with at most 60 bits of precision. *)\n let rawfloat s =\n let scale = 1073741824.0 (* 2^30 *)\n and r1 = Stdlib.float (bits s)\n and r2 = Stdlib.float (bits s)\n in (r1 /. scale +. r2) /. scale\n\n\n let float s bound = rawfloat s *. bound\n\n let bool s = (bits s land 1 = 0)\n\n let bits32 s =\n let b1 = Int32.(shift_right_logical (of_int (bits s)) 14) in (* 16 bits *)\n let b2 = Int32.(shift_right_logical (of_int (bits s)) 14) in (* 16 bits *)\n Int32.(logor b1 (shift_left b2 16))\n\n let bits64 s =\n let b1 = Int64.(shift_right_logical (of_int (bits s)) 9) in (* 21 bits *)\n let b2 = Int64.(shift_right_logical (of_int (bits s)) 9) in (* 21 bits *)\n let b3 = Int64.(shift_right_logical (of_int (bits s)) 8) in (* 22 bits *)\n Int64.(logor b1 (logor (shift_left b2 21) (shift_left b3 42)))\n\n let nativebits =\n if Nativeint.size = 32\n then fun s -> Nativeint.of_int32 (bits32 s)\n else fun s -> Int64.to_nativeint (bits64 s)\n\nend\n\n(* This is the state you get with [init 27182818] and then applying\n the \"land 0x3FFFFFFF\" filter to them. See #5575, #5793, #5977. *)\nlet default = {\n State.st = [|\n 0x3ae2522b; 0x1d8d4634; 0x15b4fad0; 0x18b14ace; 0x12f8a3c4; 0x3b086c47;\n 0x16d467d6; 0x101d91c7; 0x321df177; 0x0176c193; 0x1ff72bf1; 0x1e889109;\n 0x0b464b18; 0x2b86b97c; 0x0891da48; 0x03137463; 0x085ac5a1; 0x15d61f2f;\n 0x3bced359; 0x29c1c132; 0x3a86766e; 0x366d8c86; 0x1f5b6222; 0x3ce1b59f;\n 0x2ebf78e1; 0x27cd1b86; 0x258f3dc3; 0x389a8194; 0x02e4c44c; 0x18c43f7d;\n 0x0f6e534f; 0x1e7df359; 0x055d0b7e; 0x10e84e7e; 0x126198e4; 0x0e7722cb;\n 0x1cbede28; 0x3391b964; 0x3d40e92a; 0x0c59933d; 0x0b8cd0b7; 0x24efff1c;\n 0x2803fdaa; 0x08ebc72e; 0x0f522e32; 0x05398edc; 0x2144a04c; 0x0aef3cbd;\n 0x01ad4719; 0x35b93cd6; 0x2a559d4f; 0x1e6fd768; 0x26e27f36; 0x186f18c3;\n 0x2fbf967a;\n |];\n State.idx = 0;\n}\n\nlet bits () = State.bits default\nlet int bound = State.int default bound\nlet full_int bound = State.full_int default bound\nlet int32 bound = State.int32 default bound\nlet nativeint bound = State.nativeint default bound\nlet int64 bound = State.int64 default bound\nlet float scale = State.float default scale\nlet bool () = State.bool default\nlet bits32 () = State.bits32 default\nlet bits64 () = State.bits64 default\nlet nativebits () = State.nativebits default\n\nlet full_init seed = State.full_init default seed\nlet init seed = State.full_init default [| seed |]\nlet self_init () = full_init (random_seed())\n\n(* Manipulating the current state. *)\n\nlet get_state () = State.copy default\nlet set_state s = State.assign default s\n\n(********************\n\n(* Test functions. Not included in the library.\n The [chisquare] function should be called with n > 10r.\n It returns a triple (low, actual, high).\n If low <= actual <= high, the [g] function passed the test,\n otherwise it failed.\n\n Some results:\n\ninit 27182818; chisquare int 100000 1000\ninit 27182818; chisquare int 100000 100\ninit 27182818; chisquare int 100000 5000\ninit 27182818; chisquare int 1000000 1000\ninit 27182818; chisquare int 100000 1024\ninit 299792643; chisquare int 100000 1024\ninit 14142136; chisquare int 100000 1024\ninit 27182818; init_diff 1024; chisquare diff 100000 1024\ninit 27182818; init_diff 100; chisquare diff 100000 100\ninit 27182818; init_diff2 1024; chisquare diff2 100000 1024\ninit 27182818; init_diff2 100; chisquare diff2 100000 100\ninit 14142136; init_diff2 100; chisquare diff2 100000 100\ninit 299792643; init_diff2 100; chisquare diff2 100000 100\n- : float * float * float = (936.754446796632465, 997.5, 1063.24555320336754)\n# - : float * float * float = (80., 89.7400000000052387, 120.)\n# - : float * float * float = (4858.57864376269, 5045.5, 5141.42135623731)\n# - : float * float * float =\n(936.754446796632465, 944.805999999982305, 1063.24555320336754)\n# - : float * float * float = (960., 1019.19744000000355, 1088.)\n# - : float * float * float = (960., 1059.31776000000536, 1088.)\n# - : float * float * float = (960., 1039.98463999999512, 1088.)\n# - : float * float * float = (960., 1054.38207999999577, 1088.)\n# - : float * float * float = (80., 90.096000000005, 120.)\n# - : float * float * float = (960., 1076.78720000000612, 1088.)\n# - : float * float * float = (80., 85.1760000000067521, 120.)\n# - : float * float * float = (80., 85.2160000000003492, 120.)\n# - : float * float * float = (80., 80.6220000000030268, 120.)\n\n*)\n\n(* Return the sum of the squares of v[i0,i1[ *)\nlet rec sumsq v i0 i1 =\n if i0 >= i1 then 0.0\n else if i1 = i0 + 1 then Stdlib.float v.(i0) *. Stdlib.float v.(i0)\n else sumsq v i0 ((i0+i1)/2) +. sumsq v ((i0+i1)/2) i1\n\n\nlet chisquare g n r =\n if n <= 10 * r then invalid_arg \"chisquare\";\n let f = Array.make r 0 in\n for i = 1 to n do\n let t = g r in\n f.(t) <- f.(t) + 1\n done;\n let t = sumsq f 0 r\n and r = Stdlib.float r\n and n = Stdlib.float n in\n let sr = 2.0 *. sqrt r in\n (r -. sr, (r *. t /. n) -. n, r +. sr)\n\n\n(* This is to test for linear dependencies between successive random numbers.\n*)\nlet st = ref 0\nlet init_diff r = st := int r\nlet diff r =\n let x1 = !st\n and x2 = int r\n in\n st := x2;\n if x1 >= x2 then\n x1 - x2\n else\n r + x1 - x2\n\n\nlet st1 = ref 0\nand st2 = ref 0\n\n\n(* This is to test for quadratic dependencies between successive random\n numbers.\n*)\nlet init_diff2 r = st1 := int r; st2 := int r\nlet diff2 r =\n let x1 = !st1\n and x2 = !st2\n and x3 = int r\n in\n st1 := x2;\n st2 := x3;\n (x3 - x2 - x2 + x1 + 2*r) mod r\n\n\n********************)\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* Hash tables *)\n\n(* We do dynamic hashing, and resize the table and rehash the elements\n when buckets become too long. *)\n\ntype ('a, 'b) t =\n { mutable size: int; (* number of entries *)\n mutable data: ('a, 'b) bucketlist array; (* the buckets *)\n seed: int; (* for randomization *)\n mutable initial_size: int; (* initial array size *)\n }\n\nand ('a, 'b) bucketlist =\n Empty\n | Cons of { mutable key: 'a;\n mutable data: 'b;\n mutable next: ('a, 'b) bucketlist }\n\n(* The sign of initial_size encodes the fact that a traversal is\n ongoing or not.\n\n This disables the efficient in place implementation of resizing.\n*)\n\nlet ongoing_traversal h =\n Obj.size (Obj.repr h) < 4 (* compatibility with old hash tables *)\n || h.initial_size < 0\n\nlet flip_ongoing_traversal h =\n h.initial_size <- - h.initial_size\n\n(* To pick random seeds if requested *)\n\nlet randomized_default =\n let params =\n try Sys.getenv \"OCAMLRUNPARAM\" with Not_found ->\n try Sys.getenv \"CAMLRUNPARAM\" with Not_found -> \"\" in\n String.contains params 'R'\n\nlet randomized = ref randomized_default\n\nlet randomize () = randomized := true\nlet is_randomized () = !randomized\n\nlet prng = lazy (Random.State.make_self_init())\n\n(* Functions which appear before the functorial interface must either be\n independent of the hash function or take it as a parameter (see #2202 and\n code below the functor definitions. *)\n\n(* Creating a fresh, empty table *)\n\nlet rec power_2_above x n =\n if x >= n then x\n else if x * 2 > Sys.max_array_length then x\n else power_2_above (x * 2) n\n\nlet create ?(random = !randomized) initial_size =\n let s = power_2_above 16 initial_size in\n let seed = if random then Random.State.bits (Lazy.force prng) else 0 in\n { initial_size = s; size = 0; seed = seed; data = Array.make s Empty }\n\nlet clear h =\n if h.size > 0 then begin\n h.size <- 0;\n Array.fill h.data 0 (Array.length h.data) Empty\n end\n\nlet reset h =\n let len = Array.length h.data in\n if Obj.size (Obj.repr h) < 4 (* compatibility with old hash tables *)\n || len = abs h.initial_size then\n clear h\n else begin\n h.size <- 0;\n h.data <- Array.make (abs h.initial_size) Empty\n end\n\nlet copy_bucketlist = function\n | Empty -> Empty\n | Cons {key; data; next} ->\n let rec loop prec = function\n | Empty -> ()\n | Cons {key; data; next} ->\n let r = Cons {key; data; next} in\n begin match prec with\n | Empty -> assert false\n | Cons prec -> prec.next <- r\n end;\n loop r next\n in\n let r = Cons {key; data; next} in\n loop r next;\n r\n\nlet copy h = { h with data = Array.map copy_bucketlist h.data }\n\nlet length h = h.size\n\nlet insert_all_buckets indexfun inplace odata ndata =\n let nsize = Array.length ndata in\n let ndata_tail = Array.make nsize Empty in\n let rec insert_bucket = function\n | Empty -> ()\n | Cons {key; data; next} as cell ->\n let cell =\n if inplace then cell\n else Cons {key; data; next = Empty}\n in\n let nidx = indexfun key in\n begin match ndata_tail.(nidx) with\n | Empty -> ndata.(nidx) <- cell;\n | Cons tail -> tail.next <- cell;\n end;\n ndata_tail.(nidx) <- cell;\n insert_bucket next\n in\n for i = 0 to Array.length odata - 1 do\n insert_bucket odata.(i)\n done;\n if inplace then\n for i = 0 to nsize - 1 do\n match ndata_tail.(i) with\n | Empty -> ()\n | Cons tail -> tail.next <- Empty\n done\n\nlet resize indexfun h =\n let odata = h.data in\n let osize = Array.length odata in\n let nsize = osize * 2 in\n if nsize < Sys.max_array_length then begin\n let ndata = Array.make nsize Empty in\n let inplace = not (ongoing_traversal h) in\n h.data <- ndata; (* so that indexfun sees the new bucket count *)\n insert_all_buckets (indexfun h) inplace odata ndata\n end\n\nlet iter f h =\n let rec do_bucket = function\n | Empty ->\n ()\n | Cons{key; data; next} ->\n f key data; do_bucket next in\n let old_trav = ongoing_traversal h in\n if not old_trav then flip_ongoing_traversal h;\n try\n let d = h.data in\n for i = 0 to Array.length d - 1 do\n do_bucket d.(i)\n done;\n if not old_trav then flip_ongoing_traversal h;\n with exn when not old_trav ->\n flip_ongoing_traversal h;\n raise exn\n\nlet rec filter_map_inplace_bucket f h i prec = function\n | Empty ->\n begin match prec with\n | Empty -> h.data.(i) <- Empty\n | Cons c -> c.next <- Empty\n end\n | (Cons ({key; data; next} as c)) as slot ->\n begin match f key data with\n | None ->\n h.size <- h.size - 1;\n filter_map_inplace_bucket f h i prec next\n | Some data ->\n begin match prec with\n | Empty -> h.data.(i) <- slot\n | Cons c -> c.next <- slot\n end;\n c.data <- data;\n filter_map_inplace_bucket f h i slot next\n end\n\nlet filter_map_inplace f h =\n let d = h.data in\n let old_trav = ongoing_traversal h in\n if not old_trav then flip_ongoing_traversal h;\n try\n for i = 0 to Array.length d - 1 do\n filter_map_inplace_bucket f h i Empty h.data.(i)\n done;\n if not old_trav then flip_ongoing_traversal h\n with exn when not old_trav ->\n flip_ongoing_traversal h;\n raise exn\n\nlet fold f h init =\n let rec do_bucket b accu =\n match b with\n Empty ->\n accu\n | Cons{key; data; next} ->\n do_bucket next (f key data accu) in\n let old_trav = ongoing_traversal h in\n if not old_trav then flip_ongoing_traversal h;\n try\n let d = h.data in\n let accu = ref init in\n for i = 0 to Array.length d - 1 do\n accu := do_bucket d.(i) !accu\n done;\n if not old_trav then flip_ongoing_traversal h;\n !accu\n with exn when not old_trav ->\n flip_ongoing_traversal h;\n raise exn\n\ntype statistics = {\n num_bindings: int;\n num_buckets: int;\n max_bucket_length: int;\n bucket_histogram: int array\n}\n\nlet rec bucket_length accu = function\n | Empty -> accu\n | Cons{next} -> bucket_length (accu + 1) next\n\nlet stats h =\n let mbl =\n Array.fold_left (fun m b -> Int.max m (bucket_length 0 b)) 0 h.data in\n let histo = Array.make (mbl + 1) 0 in\n Array.iter\n (fun b ->\n let l = bucket_length 0 b in\n histo.(l) <- histo.(l) + 1)\n h.data;\n { num_bindings = h.size;\n num_buckets = Array.length h.data;\n max_bucket_length = mbl;\n bucket_histogram = histo }\n\n(** {1 Iterators} *)\n\nlet to_seq tbl =\n (* capture current array, so that even if the table is resized we\n keep iterating on the same array *)\n let tbl_data = tbl.data in\n (* state: index * next bucket to traverse *)\n let rec aux i buck () = match buck with\n | Empty ->\n if i = Array.length tbl_data\n then Seq.Nil\n else aux(i+1) tbl_data.(i) ()\n | Cons {key; data; next} ->\n Seq.Cons ((key, data), aux i next)\n in\n aux 0 Empty\n\nlet to_seq_keys m = Seq.map fst (to_seq m)\n\nlet to_seq_values m = Seq.map snd (to_seq m)\n\n(* Functorial interface *)\n\nmodule type HashedType =\n sig\n type t\n val equal: t -> t -> bool\n val hash: t -> int\n end\n\nmodule type SeededHashedType =\n sig\n type t\n val equal: t -> t -> bool\n val hash: int -> t -> int\n end\n\nmodule type S =\n sig\n type key\n type !'a t\n val create: int -> 'a t\n val clear : 'a t -> unit\n val reset : 'a t -> unit\n val copy: 'a t -> 'a t\n val add: 'a t -> key -> 'a -> unit\n val remove: 'a t -> key -> unit\n val find: 'a t -> key -> 'a\n val find_opt: 'a t -> key -> 'a option\n val find_all: 'a t -> key -> 'a list\n val replace : 'a t -> key -> 'a -> unit\n val mem : 'a t -> key -> bool\n val iter: (key -> 'a -> unit) -> 'a t -> unit\n val filter_map_inplace: (key -> 'a -> 'a option) -> 'a t -> unit\n val fold: (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b\n val length: 'a t -> int\n val stats: 'a t -> statistics\n val to_seq : 'a t -> (key * 'a) Seq.t\n val to_seq_keys : _ t -> key Seq.t\n val to_seq_values : 'a t -> 'a Seq.t\n val add_seq : 'a t -> (key * 'a) Seq.t -> unit\n val replace_seq : 'a t -> (key * 'a) Seq.t -> unit\n val of_seq : (key * 'a) Seq.t -> 'a t\n end\n\nmodule type SeededS =\n sig\n type key\n type !'a t\n val create : ?random:bool -> int -> 'a t\n val clear : 'a t -> unit\n val reset : 'a t -> unit\n val copy : 'a t -> 'a t\n val add : 'a t -> key -> 'a -> unit\n val remove : 'a t -> key -> unit\n val find : 'a t -> key -> 'a\n val find_opt: 'a t -> key -> 'a option\n val find_all : 'a t -> key -> 'a list\n val replace : 'a t -> key -> 'a -> unit\n val mem : 'a t -> key -> bool\n val iter : (key -> 'a -> unit) -> 'a t -> unit\n val filter_map_inplace: (key -> 'a -> 'a option) -> 'a t -> unit\n val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b\n val length : 'a t -> int\n val stats: 'a t -> statistics\n val to_seq : 'a t -> (key * 'a) Seq.t\n val to_seq_keys : _ t -> key Seq.t\n val to_seq_values : 'a t -> 'a Seq.t\n val add_seq : 'a t -> (key * 'a) Seq.t -> unit\n val replace_seq : 'a t -> (key * 'a) Seq.t -> unit\n val of_seq : (key * 'a) Seq.t -> 'a t\n end\n\nmodule MakeSeeded(H: SeededHashedType): (SeededS with type key = H.t) =\n struct\n type key = H.t\n type 'a hashtbl = (key, 'a) t\n type 'a t = 'a hashtbl\n let create = create\n let clear = clear\n let reset = reset\n let copy = copy\n\n let key_index h key =\n (H.hash h.seed key) land (Array.length h.data - 1)\n\n let add h key data =\n let i = key_index h key in\n let bucket = Cons{key; data; next=h.data.(i)} in\n h.data.(i) <- bucket;\n h.size <- h.size + 1;\n if h.size > Array.length h.data lsl 1 then resize key_index h\n\n let rec remove_bucket h i key prec = function\n | Empty ->\n ()\n | (Cons {key=k; next}) as c ->\n if H.equal k key\n then begin\n h.size <- h.size - 1;\n match prec with\n | Empty -> h.data.(i) <- next\n | Cons c -> c.next <- next\n end\n else remove_bucket h i key c next\n\n let remove h key =\n let i = key_index h key in\n remove_bucket h i key Empty h.data.(i)\n\n let rec find_rec key = function\n | Empty ->\n raise Not_found\n | Cons{key=k; data; next} ->\n if H.equal key k then data else find_rec key next\n\n let find h key =\n match h.data.(key_index h key) with\n | Empty -> raise Not_found\n | Cons{key=k1; data=d1; next=next1} ->\n if H.equal key k1 then d1 else\n match next1 with\n | Empty -> raise Not_found\n | Cons{key=k2; data=d2; next=next2} ->\n if H.equal key k2 then d2 else\n match next2 with\n | Empty -> raise Not_found\n | Cons{key=k3; data=d3; next=next3} ->\n if H.equal key k3 then d3 else find_rec key next3\n\n let rec find_rec_opt key = function\n | Empty ->\n None\n | Cons{key=k; data; next} ->\n if H.equal key k then Some data else find_rec_opt key next\n\n let find_opt h key =\n match h.data.(key_index h key) with\n | Empty -> None\n | Cons{key=k1; data=d1; next=next1} ->\n if H.equal key k1 then Some d1 else\n match next1 with\n | Empty -> None\n | Cons{key=k2; data=d2; next=next2} ->\n if H.equal key k2 then Some d2 else\n match next2 with\n | Empty -> None\n | Cons{key=k3; data=d3; next=next3} ->\n if H.equal key k3 then Some d3 else find_rec_opt key next3\n\n let find_all h key =\n let rec find_in_bucket = function\n | Empty ->\n []\n | Cons{key=k; data=d; next} ->\n if H.equal k key\n then d :: find_in_bucket next\n else find_in_bucket next in\n find_in_bucket h.data.(key_index h key)\n\n let rec replace_bucket key data = function\n | Empty ->\n true\n | Cons ({key=k; next} as slot) ->\n if H.equal k key\n then (slot.key <- key; slot.data <- data; false)\n else replace_bucket key data next\n\n let replace h key data =\n let i = key_index h key in\n let l = h.data.(i) in\n if replace_bucket key data l then begin\n h.data.(i) <- Cons{key; data; next=l};\n h.size <- h.size + 1;\n if h.size > Array.length h.data lsl 1 then resize key_index h\n end\n\n let mem h key =\n let rec mem_in_bucket = function\n | Empty ->\n false\n | Cons{key=k; next} ->\n H.equal k key || mem_in_bucket next in\n mem_in_bucket h.data.(key_index h key)\n\n let add_seq tbl i =\n Seq.iter (fun (k,v) -> add tbl k v) i\n\n let replace_seq tbl i =\n Seq.iter (fun (k,v) -> replace tbl k v) i\n\n let of_seq i =\n let tbl = create 16 in\n replace_seq tbl i;\n tbl\n\n let iter = iter\n let filter_map_inplace = filter_map_inplace\n let fold = fold\n let length = length\n let stats = stats\n let to_seq = to_seq\n let to_seq_keys = to_seq_keys\n let to_seq_values = to_seq_values\n end\n\nmodule Make(H: HashedType): (S with type key = H.t) =\n struct\n include MakeSeeded(struct\n type t = H.t\n let equal = H.equal\n let hash (_seed: int) x = H.hash x\n end)\n let create sz = create ~random:false sz\n let of_seq i =\n let tbl = create 16 in\n replace_seq tbl i;\n tbl\n end\n\n(* Polymorphic hash function-based tables *)\n(* Code included below the functorial interface to guard against accidental\n use - see #2202 *)\n\nexternal seeded_hash_param :\n int -> int -> int -> 'a -> int = \"caml_hash\" [@@noalloc]\n\nlet hash x = seeded_hash_param 10 100 0 x\nlet hash_param n1 n2 x = seeded_hash_param n1 n2 0 x\nlet seeded_hash seed x = seeded_hash_param 10 100 seed x\n\nlet key_index h key =\n if Obj.size (Obj.repr h) >= 4\n then (seeded_hash_param 10 100 h.seed key) land (Array.length h.data - 1)\n else invalid_arg \"Hashtbl: unsupported hash table format\"\n\nlet add h key data =\n let i = key_index h key in\n let bucket = Cons{key; data; next=h.data.(i)} in\n h.data.(i) <- bucket;\n h.size <- h.size + 1;\n if h.size > Array.length h.data lsl 1 then resize key_index h\n\nlet rec remove_bucket h i key prec = function\n | Empty ->\n ()\n | (Cons {key=k; next}) as c ->\n if compare k key = 0\n then begin\n h.size <- h.size - 1;\n match prec with\n | Empty -> h.data.(i) <- next\n | Cons c -> c.next <- next\n end\n else remove_bucket h i key c next\n\nlet remove h key =\n let i = key_index h key in\n remove_bucket h i key Empty h.data.(i)\n\nlet rec find_rec key = function\n | Empty ->\n raise Not_found\n | Cons{key=k; data; next} ->\n if compare key k = 0 then data else find_rec key next\n\nlet find h key =\n match h.data.(key_index h key) with\n | Empty -> raise Not_found\n | Cons{key=k1; data=d1; next=next1} ->\n if compare key k1 = 0 then d1 else\n match next1 with\n | Empty -> raise Not_found\n | Cons{key=k2; data=d2; next=next2} ->\n if compare key k2 = 0 then d2 else\n match next2 with\n | Empty -> raise Not_found\n | Cons{key=k3; data=d3; next=next3} ->\n if compare key k3 = 0 then d3 else find_rec key next3\n\nlet rec find_rec_opt key = function\n | Empty ->\n None\n | Cons{key=k; data; next} ->\n if compare key k = 0 then Some data else find_rec_opt key next\n\nlet find_opt h key =\n match h.data.(key_index h key) with\n | Empty -> None\n | Cons{key=k1; data=d1; next=next1} ->\n if compare key k1 = 0 then Some d1 else\n match next1 with\n | Empty -> None\n | Cons{key=k2; data=d2; next=next2} ->\n if compare key k2 = 0 then Some d2 else\n match next2 with\n | Empty -> None\n | Cons{key=k3; data=d3; next=next3} ->\n if compare key k3 = 0 then Some d3 else find_rec_opt key next3\n\nlet find_all h key =\n let rec find_in_bucket = function\n | Empty ->\n []\n | Cons{key=k; data; next} ->\n if compare k key = 0\n then data :: find_in_bucket next\n else find_in_bucket next in\n find_in_bucket h.data.(key_index h key)\n\nlet rec replace_bucket key data = function\n | Empty ->\n true\n | Cons ({key=k; next} as slot) ->\n if compare k key = 0\n then (slot.key <- key; slot.data <- data; false)\n else replace_bucket key data next\n\nlet replace h key data =\n let i = key_index h key in\n let l = h.data.(i) in\n if replace_bucket key data l then begin\n h.data.(i) <- Cons{key; data; next=l};\n h.size <- h.size + 1;\n if h.size > Array.length h.data lsl 1 then resize key_index h\n end\n\nlet mem h key =\n let rec mem_in_bucket = function\n | Empty ->\n false\n | Cons{key=k; next} ->\n compare k key = 0 || mem_in_bucket next in\n mem_in_bucket h.data.(key_index h key)\n\nlet add_seq tbl i =\n Seq.iter (fun (k,v) -> add tbl k v) i\n\nlet replace_seq tbl i =\n Seq.iter (fun (k,v) -> replace tbl k v) i\n\nlet of_seq i =\n let tbl = create 16 in\n replace_seq tbl i;\n tbl\n\nlet rebuild ?(random = !randomized) h =\n let s = power_2_above 16 (Array.length h.data) in\n let seed =\n if random then Random.State.bits (Lazy.force prng)\n else if Obj.size (Obj.repr h) >= 4 then h.seed\n else 0 in\n let h' = {\n size = h.size;\n data = Array.make s Empty;\n seed = seed;\n initial_size = if Obj.size (Obj.repr h) >= 4 then h.initial_size else s\n } in\n insert_all_buckets (key_index h') false h.data h'.data;\n h'\n","open! Import\n\nlet poly_equal a b =\n let module Poly = struct\n type t = T : _ -> t\n end in\n Stdppx.Poly.equal (Poly.T a) (Poly.T b)\n\nmodule Context = struct\n type 'a t =\n | Label_declaration : label_declaration t\n | Constructor_declaration : constructor_declaration t\n | Type_declaration : type_declaration t\n | Type_exception : type_exception t\n | Type_extension : type_extension t\n | Extension_constructor : extension_constructor t\n | Pattern : pattern t\n | Core_type : core_type t\n | Expression : expression t\n | Value_description : value_description t\n | Class_type : class_type t\n | Class_type_field : class_type_field t\n | Class_infos : _ class_infos t\n | Class_expr : class_expr t\n | Class_field : class_field t\n | Module_type : module_type t\n | Module_declaration : module_declaration t\n | Module_type_declaration : module_type_declaration t\n | Module_substitution : module_substitution t\n | Open_description : open_description t\n | Open_declaration : open_declaration t\n | Include_infos : _ include_infos t\n | Module_expr : module_expr t\n | Value_binding : value_binding t\n | Module_binding : module_binding t\n | Pstr_eval : structure_item t\n | Pstr_extension : structure_item t\n | Psig_extension : signature_item t\n | Rtag : row_field t\n | Object_type_field : object_field t\n\n let label_declaration = Label_declaration\n let constructor_declaration = Constructor_declaration\n let type_declaration = Type_declaration\n let type_extension = Type_extension\n let type_exception = Type_exception\n let extension_constructor = Extension_constructor\n let pattern = Pattern\n let core_type = Core_type\n let expression = Expression\n let value_description = Value_description\n let class_type = Class_type\n let class_type_field = Class_type_field\n let class_infos = Class_infos\n let class_expr = Class_expr\n let class_field = Class_field\n let module_type = Module_type\n let module_declaration = Module_declaration\n let module_type_declaration = Module_type_declaration\n let open_description = Open_description\n let include_infos = Include_infos\n let module_expr = Module_expr\n let value_binding = Value_binding\n let module_binding = Module_binding\n let pstr_eval = Pstr_eval\n let pstr_extension = Pstr_extension\n let psig_extension = Psig_extension\n let rtag = Rtag\n let object_type_field = Object_type_field\n\n let get_pstr_eval st =\n match st.pstr_desc with\n | Pstr_eval (e, l) -> (e, l)\n | _ -> failwith \"Attribute.Context.get_pstr_eval\"\n\n let get_pstr_extension st =\n match st.pstr_desc with\n | Pstr_extension (e, l) -> (e, l)\n | _ -> failwith \"Attribute.Context.get_pstr_extension\"\n\n let get_psig_extension st =\n match st.psig_desc with\n | Psig_extension (e, l) -> (e, l)\n | _ -> failwith \"Attribute.Context.get_psig_extension\"\n\n let get_attributes : type a. a t -> a -> attributes =\n fun t x ->\n match t with\n | Label_declaration -> x.pld_attributes\n | Constructor_declaration -> x.pcd_attributes\n | Type_declaration -> x.ptype_attributes\n | Type_extension -> x.ptyext_attributes\n | Type_exception -> x.ptyexn_attributes\n | Extension_constructor -> x.pext_attributes\n | Pattern -> x.ppat_attributes\n | Core_type -> x.ptyp_attributes\n | Expression -> x.pexp_attributes\n | Value_description -> x.pval_attributes\n | Class_type -> x.pcty_attributes\n | Class_type_field -> x.pctf_attributes\n | Class_infos -> x.pci_attributes\n | Class_expr -> x.pcl_attributes\n | Class_field -> x.pcf_attributes\n | Module_type -> x.pmty_attributes\n | Module_declaration -> x.pmd_attributes\n | Module_type_declaration -> x.pmtd_attributes\n | Module_substitution -> x.pms_attributes\n | Open_description -> x.popen_attributes\n | Open_declaration -> x.popen_attributes\n | Include_infos -> x.pincl_attributes\n | Module_expr -> x.pmod_attributes\n | Value_binding -> x.pvb_attributes\n | Module_binding -> x.pmb_attributes\n | Pstr_eval -> snd (get_pstr_eval x)\n | Pstr_extension -> snd (get_pstr_extension x)\n | Psig_extension -> snd (get_psig_extension x)\n | Rtag -> x.prf_attributes\n | Object_type_field -> x.pof_attributes\n\n let set_attributes : type a. a t -> a -> attributes -> a =\n fun t x attrs ->\n match t with\n | Label_declaration -> { x with pld_attributes = attrs }\n | Constructor_declaration -> { x with pcd_attributes = attrs }\n | Type_declaration -> { x with ptype_attributes = attrs }\n | Type_extension -> { x with ptyext_attributes = attrs }\n | Type_exception -> { x with ptyexn_attributes = attrs }\n | Extension_constructor -> { x with pext_attributes = attrs }\n | Pattern -> { x with ppat_attributes = attrs }\n | Core_type -> { x with ptyp_attributes = attrs }\n | Expression -> { x with pexp_attributes = attrs }\n | Value_description -> { x with pval_attributes = attrs }\n | Class_type -> { x with pcty_attributes = attrs }\n | Class_type_field -> { x with pctf_attributes = attrs }\n | Class_infos -> { x with pci_attributes = attrs }\n | Class_expr -> { x with pcl_attributes = attrs }\n | Class_field -> { x with pcf_attributes = attrs }\n | Module_type -> { x with pmty_attributes = attrs }\n | Module_declaration -> { x with pmd_attributes = attrs }\n | Module_type_declaration -> { x with pmtd_attributes = attrs }\n | Module_substitution -> { x with pms_attributes = attrs }\n | Open_description -> { x with popen_attributes = attrs }\n | Open_declaration -> { x with popen_attributes = attrs }\n | Include_infos -> { x with pincl_attributes = attrs }\n | Module_expr -> { x with pmod_attributes = attrs }\n | Value_binding -> { x with pvb_attributes = attrs }\n | Module_binding -> { x with pmb_attributes = attrs }\n | Pstr_eval ->\n { x with pstr_desc = Pstr_eval (get_pstr_eval x |> fst, attrs) }\n | Pstr_extension ->\n {\n x with\n pstr_desc = Pstr_extension (get_pstr_extension x |> fst, attrs);\n }\n | Psig_extension ->\n {\n x with\n psig_desc = Psig_extension (get_psig_extension x |> fst, attrs);\n }\n | Rtag -> { x with prf_attributes = attrs }\n | Object_type_field -> { x with pof_attributes = attrs }\n\n let desc : type a. a t -> string = function\n | Label_declaration -> \"label declaration\"\n | Constructor_declaration -> \"constructor declaration\"\n | Type_declaration -> \"type declaration\"\n | Type_extension -> \"type extension\"\n | Type_exception -> \"type exception\"\n | Extension_constructor -> \"extension constructor\"\n | Pattern -> \"pattern\"\n | Core_type -> \"core type\"\n | Expression -> \"expression\"\n | Value_description -> \"value\"\n | Class_type -> \"class type\"\n | Class_type_field -> \"class type field\"\n | Class_infos -> \"class declaration\"\n | Class_expr -> \"class expression\"\n | Class_field -> \"class field\"\n | Module_type -> \"module type\"\n | Module_declaration -> \"module declaration\"\n | Module_type_declaration -> \"module type declaration\"\n | Module_substitution -> \"module substitution\"\n | Open_description -> \"open\"\n | Open_declaration -> \"open\"\n | Include_infos -> \"include\"\n | Module_expr -> \"module expression\"\n | Value_binding -> \"value binding\"\n | Module_binding -> \"module binding\"\n | Pstr_eval -> \"toplevel expression\"\n | Pstr_extension -> \"toplevel extension\"\n | Psig_extension -> \"toplevel signature extension\"\n | Rtag -> \"polymorphic variant tag\"\n | Object_type_field -> \"object type field\"\n\n (*\n let pattern : type a b c d. a t\n -> (attributes, b, c) Ast_pattern.t\n -> (a, c, d) Ast_pattern.t\n -> (a, b, d) Ast_pattern.t = function\n | Label_declaration -> Ast_pattern.pld_attributes\n | Constructor_declaration -> Ast_pattern.pcd_attributes\n | Type_declaration -> Ast_pattern.ptype_attributes\n | Type_extension -> Ast_pattern.ptyext_attributes\n | Extension_constructor -> Ast_pattern.pext_attributes\n*)\n\n let equal : _ t -> _ t -> bool = poly_equal\nend\n\nmodule Floating_context = struct\n type 'a t =\n | Structure_item : structure_item t\n | Signature_item : signature_item t\n | Class_field : class_field t\n | Class_type_field : class_type_field t\n\n let structure_item = Structure_item\n let signature_item = Signature_item\n let class_field = Class_field\n let class_type_field = Class_type_field\n\n let get_attribute_if_is_floating_node : type a. a t -> a -> attribute option =\n fun t x ->\n match (t, x) with\n | Structure_item, { pstr_desc = Pstr_attribute a; _ } -> Some a\n | Signature_item, { psig_desc = Psig_attribute a; _ } -> Some a\n | Class_field, { pcf_desc = Pcf_attribute a; _ } -> Some a\n | Class_type_field, { pctf_desc = Pctf_attribute a; _ } -> Some a\n | _ -> None\n\n let get_attribute t x =\n match get_attribute_if_is_floating_node t x with\n | Some a -> a\n | None -> failwith \"Attribute.Floating.Context.get_attribute\"\n\n let replace_by_dummy : type a. a t -> a -> a =\n let dummy_ext = ({ txt = \"\"; loc = Location.none }, PStr []) in\n fun t x ->\n match t with\n | Structure_item -> { x with pstr_desc = Pstr_extension (dummy_ext, []) }\n | Signature_item -> { x with psig_desc = Psig_extension (dummy_ext, []) }\n | Class_field -> { x with pcf_desc = Pcf_extension dummy_ext }\n | Class_type_field -> { x with pctf_desc = Pctf_extension dummy_ext }\n\n let desc : type a. a t -> string = function\n | Structure_item -> \"structure item\"\n | Signature_item -> \"signature item\"\n | Class_field -> \"class field\"\n | Class_type_field -> \"class type field\"\n\n let equal : _ t -> _ t -> bool = poly_equal\nend\n\ntype packed_context =\n | On_item : _ Context.t -> packed_context\n | Floating : _ Floating_context.t -> packed_context\n\ntype _ payload_parser =\n | Payload_parser :\n (payload, 'a, 'b) Ast_pattern.t * (name_loc:Location.t -> 'a)\n -> 'b payload_parser\n\ntype ('a, 'b) t = {\n name : Name.Pattern.t;\n context : 'a Context.t;\n payload : 'b payload_parser;\n}\n\ntype packed = T : (_, _) t -> packed\n\nlet name t = Name.Pattern.name t.name\nlet context t = t.context\n\nlet registrar =\n Name.Registrar.create ~kind:\"attribute\" ~current_file:__FILE__\n ~string_of_context:(function\n | On_item t -> Some (Context.desc t)\n | Floating t -> Some (Floating_context.desc t ^ \" (floating)\"))\n\nlet declare_with_name_loc name context pattern k =\n Name.Registrar.register ~kind:`Attribute registrar (On_item context) name;\n {\n name = Name.Pattern.make name;\n context;\n payload = Payload_parser (pattern, k);\n }\n\nlet declare name context pattern k =\n declare_with_name_loc name context pattern (fun ~name_loc:_ -> k)\n\nmodule Attribute_table = Caml.Hashtbl.Make (struct\n type t = string loc\n\n let hash : t -> int = Hashtbl.hash\n let equal : t -> t -> bool = Poly.equal\nend)\n\nlet not_seen = Attribute_table.create 128\nlet mark_as_seen { attr_name; _ } = Attribute_table.remove not_seen attr_name\nlet mark_as_handled_manually = mark_as_seen\n\nlet explicitly_drop =\n object\n inherit Ast_traverse.iter\n method! attribute = mark_as_seen\n end\n\nlet get_internal =\n let rec find_best_match t attributes longest_match =\n match attributes with\n | [] -> longest_match\n | ({ attr_name = name; _ } as attr) :: rest ->\n if Name.Pattern.matches t.name name.txt then\n match longest_match with\n | None -> find_best_match t rest (Some attr)\n | Some { attr_name = name'; _ } ->\n let len = String.length name.txt in\n let len' = String.length name'.txt in\n if len > len' then find_best_match t rest (Some attr)\n else if len < len' then find_best_match t rest longest_match\n else Location.raise_errorf ~loc:name.loc \"Duplicated attribute\"\n else find_best_match t rest longest_match\n in\n fun t attributes -> find_best_match t attributes None\n\nlet convert ?(do_mark_as_seen = true) pattern attr =\n if do_mark_as_seen then mark_as_seen attr;\n let (Payload_parser (pattern, k)) = pattern in\n Ast_pattern.parse pattern\n (Common.loc_of_payload attr)\n attr.attr_payload\n (k ~name_loc:attr.attr_name.loc)\n\nlet get t ?mark_as_seen:do_mark_as_seen x =\n let attrs = Context.get_attributes t.context x in\n match get_internal t attrs with\n | None -> None\n | Some attr -> Some (convert t.payload attr ?do_mark_as_seen)\n\nlet consume t x =\n let attrs = Context.get_attributes t.context x in\n match get_internal t attrs with\n | None -> None\n | Some attr ->\n let attrs = List.filter attrs ~f:(fun attr' -> not (attr == attr')) in\n let x = Context.set_attributes t.context x attrs in\n Some (x, convert t.payload attr)\n\nlet remove_seen (type a) (context : a Context.t) packeds (x : a) =\n let attrs = Context.get_attributes context x in\n let matched =\n let rec loop acc = function\n | [] -> acc\n | T t :: rest ->\n if Context.equal t.context context then\n match get_internal t attrs with\n | None -> loop acc rest\n | Some attr ->\n let name = attr.attr_name in\n if Attribute_table.mem not_seen name then loop acc rest\n else loop (attr :: acc) rest\n else loop acc rest\n in\n loop [] packeds\n in\n let attrs =\n List.filter attrs ~f:(fun attr' -> not (List.memq ~set:matched attr'))\n in\n Context.set_attributes context x attrs\n\nlet pattern t p =\n let f = Ast_pattern.to_func p in\n Ast_pattern.of_func (fun ctx loc x k ->\n match consume t x with\n | None -> f ctx loc x (k None)\n | Some (x, v) -> f ctx loc x (k (Some v)))\n\nmodule Floating = struct\n module Context = Floating_context\n\n type ('a, 'b) t = {\n name : Name.Pattern.t;\n context : 'a Context.t;\n payload : 'b payload_parser;\n }\n\n let name t = Name.Pattern.name t.name\n\n let declare name context pattern k =\n Name.Registrar.register ~kind:`Attribute registrar (Floating context) name;\n {\n name = Name.Pattern.make name;\n context;\n payload = Payload_parser (pattern, fun ~name_loc:_ -> k);\n }\n\n let convert ts x =\n match ts with\n | [] -> None\n | { context; _ } :: _ -> (\n assert (List.for_all ts ~f:(fun t -> Context.equal t.context context));\n let attr = Context.get_attribute context x in\n let name = attr.attr_name in\n match\n List.filter ts ~f:(fun t -> Name.Pattern.matches t.name name.txt)\n with\n | [] -> None\n | [ t ] -> Some (convert t.payload attr)\n | l ->\n Location.raise_errorf ~loc:name.loc\n \"Multiple match for floating attributes: %s\"\n (String.concat ~sep:\", \"\n (List.map l ~f:(fun t -> Name.Pattern.name t.name))))\nend\n\nlet check_attribute registrar context name =\n if\n (not\n (Name.Whitelisted.is_whitelisted ~kind:`Attribute name.txt\n || Name.ignore_checks name.txt))\n && Attribute_table.mem not_seen name\n then\n let white_list = Name.Whitelisted.get_attribute_list () in\n Name.Registrar.raise_errorf registrar context ~white_list\n \"Attribute `%s' was not used\" name\n\nlet check_unused =\n object (self)\n inherit Ast_traverse.iter as super\n\n method! attribute { attr_name = name; _ } =\n Location.raise_errorf ~loc:name.loc\n \"attribute not expected here, Ppxlib.Attribute needs updating!\"\n\n method private check_node : type a. a Context.t -> a -> a =\n fun context node ->\n let attrs = Context.get_attributes context node in\n match attrs with\n | [] -> node\n | _ ->\n List.iter attrs\n ~f:(fun ({ attr_name = name; attr_payload = payload; _ } as attr)\n ->\n self#payload payload;\n check_attribute registrar (On_item context) name;\n (* If we allow the attribute to pass through, mark it as seen *)\n mark_as_seen attr);\n Context.set_attributes context node []\n\n method private check_floating : type a. a Floating.Context.t -> a -> a =\n fun context node ->\n match\n Floating.Context.get_attribute_if_is_floating_node context node\n with\n | None -> node\n | Some ({ attr_name = name; attr_payload = payload; _ } as attr) ->\n self#payload payload;\n check_attribute registrar (Floating context) name;\n mark_as_seen attr;\n Floating.Context.replace_by_dummy context node\n\n method! label_declaration x =\n super#label_declaration (self#check_node Label_declaration x)\n\n method! constructor_declaration x =\n super#constructor_declaration (self#check_node Constructor_declaration x)\n\n method! type_declaration x =\n super#type_declaration (self#check_node Type_declaration x)\n\n method! type_extension x =\n super#type_extension (self#check_node Type_extension x)\n\n method! type_exception x =\n super#type_exception (self#check_node Type_exception x)\n\n method! extension_constructor x =\n super#extension_constructor (self#check_node Extension_constructor x)\n\n method! pattern x = super#pattern (self#check_node Pattern x)\n method! core_type x = super#core_type (self#check_node Core_type x)\n method! expression x = super#expression (self#check_node Expression x)\n\n method! value_description x =\n super#value_description (self#check_node Value_description x)\n\n method! class_type x = super#class_type (self#check_node Class_type x)\n\n method! class_infos f x =\n super#class_infos f (self#check_node Class_infos x)\n\n method! class_expr x = super#class_expr (self#check_node Class_expr x)\n method! module_type x = super#module_type (self#check_node Module_type x)\n\n method! module_declaration x =\n super#module_declaration (self#check_node Module_declaration x)\n\n method! module_type_declaration x =\n super#module_type_declaration (self#check_node Module_type_declaration x)\n\n method! open_description x =\n super#open_description (self#check_node Open_description x)\n\n method! open_declaration x =\n super#open_declaration (self#check_node Open_declaration x)\n\n method! include_infos f x =\n super#include_infos f (self#check_node Include_infos x)\n\n method! module_expr x = super#module_expr (self#check_node Module_expr x)\n\n method! value_binding x =\n super#value_binding (self#check_node Value_binding x)\n\n method! module_binding x =\n super#module_binding (self#check_node Module_binding x)\n\n method! class_field x =\n let x = self#check_node Class_field x in\n let x = self#check_floating Class_field x in\n super#class_field x\n\n method! class_type_field x =\n let x = self#check_node Class_type_field x in\n let x = self#check_floating Class_type_field x in\n super#class_type_field x\n\n method! row_field x =\n let x =\n match x.prf_desc with Rtag _ -> self#check_node Rtag x | _ -> x\n in\n super#row_field x\n\n method! core_type_desc x =\n let x =\n match x with\n | Ptyp_object (fields, closed_flag) ->\n let fields =\n List.map fields ~f:(self#check_node Object_type_field)\n in\n Ptyp_object (fields, closed_flag)\n | _ -> x\n in\n super#core_type_desc x\n\n method! structure_item item =\n let item = self#check_floating Structure_item item in\n let item =\n match item.pstr_desc with\n | Pstr_eval _ -> self#check_node Pstr_eval item\n | Pstr_extension _ -> self#check_node Pstr_extension item\n | _ -> item\n in\n super#structure_item item\n\n method! signature_item item =\n let item = self#check_floating Signature_item item in\n let item =\n match item.psig_desc with\n | Psig_extension _ -> self#check_node Psig_extension item\n | _ -> item\n in\n super#signature_item item\n end\n\nlet reset_checks () = Attribute_table.clear not_seen\n\nlet collect =\n object\n inherit Ast_traverse.iter as super\n\n method! attribute ({ attr_name = name; attr_payload = payload; _ } as attr)\n =\n let loc = Common.loc_of_attribute attr in\n super#payload payload;\n Attribute_table.add not_seen name loc\n end\n\nlet check_all_seen () =\n let fail name loc =\n let txt = name.txt in\n if not (Name.ignore_checks txt) then\n Location.raise_errorf ~loc \"Attribute `%s' was silently dropped\" txt\n in\n Attribute_table.iter fail not_seen\n\nlet remove_attributes_present_in table =\n object\n inherit Ast_traverse.iter as super\n\n method! attribute { attr_name = name; attr_payload = payload; _ } =\n super#payload payload;\n Attribute_table.remove table name\n end\n\nlet copy_of_not_seen () =\n let copy = Attribute_table.create (Attribute_table.length not_seen) in\n Attribute_table.iter (Attribute_table.add copy) not_seen;\n copy\n\nlet dropped_so_far_structure st =\n let table = copy_of_not_seen () in\n (remove_attributes_present_in table)#structure st;\n Attribute_table.fold\n (fun name loc acc -> { txt = name.txt; loc } :: acc)\n table []\n\nlet dropped_so_far_signature sg =\n let table = copy_of_not_seen () in\n (remove_attributes_present_in table)#signature sg;\n Attribute_table.fold\n (fun name loc acc -> { txt = name.txt; loc } :: acc)\n table []\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Pierre Weis, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* A pretty-printing facility and definition of formatters for 'parallel'\n (i.e. unrelated or independent) pretty-printing on multiple out channels. *)\n\n(*\n The pretty-printing engine internal data structures.\n*)\n\nlet id x = x\n\n(* A devoted type for sizes to avoid confusion\n between sizes and mere integers. *)\nmodule Size : sig\n type t\n\n val to_int : t -> int\n val of_int : int -> t\n val zero : t\n val unknown : t\n val is_known : t -> bool\nend = struct\n type t = int\n\n let to_int = id\n let of_int = id\n let zero = 0\n let unknown = -1\n let is_known n = n >= 0\nend\n\n\n\n(* The pretty-printing boxes definition:\n a pretty-printing box is either\n - hbox: horizontal box (no line splitting)\n - vbox: vertical box (every break hint splits the line)\n - hvbox: horizontal/vertical box\n (the box behaves as an horizontal box if it fits on\n the current line, otherwise the box behaves as a vertical box)\n - hovbox: horizontal or vertical compacting box\n (the box is compacting material, printing as much material as possible\n on every lines)\n - box: horizontal or vertical compacting box with enhanced box structure\n (the box behaves as an horizontal or vertical box but break hints split\n the line if splitting would move to the left)\n*)\ntype box_type = CamlinternalFormatBasics.block_type =\n | Pp_hbox | Pp_vbox | Pp_hvbox | Pp_hovbox | Pp_box | Pp_fits\n\n\n(* The pretty-printing tokens definition:\n are either text to print or pretty printing\n elements that drive indentation and line splitting. *)\ntype pp_token =\n | Pp_text of string (* normal text *)\n | Pp_break of { (* complete break *)\n fits: string * int * string; (* line is not split *)\n breaks: string * int * string; (* line is split *)\n }\n | Pp_tbreak of int * int (* go to next tabulation *)\n | Pp_stab (* set a tabulation *)\n | Pp_begin of int * box_type (* beginning of a box *)\n | Pp_end (* end of a box *)\n | Pp_tbegin of tbox (* beginning of a tabulation box *)\n | Pp_tend (* end of a tabulation box *)\n | Pp_newline (* to force a newline inside a box *)\n | Pp_if_newline (* to do something only if this very\n line has been broken *)\n | Pp_open_tag of stag (* opening a tag name *)\n | Pp_close_tag (* closing the most recently open tag *)\n\nand stag = ..\n\nand tbox = Pp_tbox of int list ref (* Tabulation box *)\n\ntype tag = string\ntype stag += String_tag of tag\n\n\n(* The pretty-printer queue:\n pretty-printing material is not written in the output as soon as emitted;\n instead, the material is simply recorded in the pretty-printer queue,\n until the enclosing box has a known computed size and proper splitting\n decisions can be made.\n\n The pretty-printer queue contains formatting elements to be printed.\n Each formatting element is a tuple (size, token, length), where\n - length is the declared length of the token,\n - size is effective size of the token when it is printed\n (size is set when the size of the box is known, so that size of break\n hints are definitive). *)\ntype pp_queue_elem = {\n mutable size : Size.t;\n token : pp_token;\n length : int;\n}\n\n\n(* The pretty-printer queue definition. *)\ntype pp_queue = pp_queue_elem Queue.t\n\n(* The pretty-printer scanning stack. *)\n\n(* The pretty-printer scanning stack: scanning element definition. *)\ntype pp_scan_elem = {\n left_total : int; (* Value of pp_left_total when the element was enqueued. *)\n queue_elem : pp_queue_elem\n}\n\n(* The pretty-printer formatting stack:\n the formatting stack contains the description of all the currently active\n boxes; the pretty-printer formatting stack is used to split the lines\n while printing tokens. *)\n\n(* The pretty-printer formatting stack: formatting stack element definition.\n Each stack element describes a pretty-printing box. *)\ntype pp_format_elem = { box_type : box_type; width : int }\n\n(* The formatter definition.\n Each formatter value is a pretty-printer instance with all its\n machinery. *)\ntype formatter = {\n (* The pretty-printer scanning stack. *)\n pp_scan_stack : pp_scan_elem Stack.t;\n (* The pretty-printer formatting stack. *)\n pp_format_stack : pp_format_elem Stack.t;\n pp_tbox_stack : tbox Stack.t;\n (* The pretty-printer semantics tag stack. *)\n pp_tag_stack : stag Stack.t;\n pp_mark_stack : stag Stack.t;\n (* Value of right margin. *)\n mutable pp_margin : int;\n (* Minimal space left before margin, when opening a box. *)\n mutable pp_min_space_left : int;\n (* Maximum value of indentation:\n no box can be opened further. *)\n mutable pp_max_indent : int;\n (* Space remaining on the current line. *)\n mutable pp_space_left : int;\n (* Current value of indentation. *)\n mutable pp_current_indent : int;\n (* True when the line has been broken by the pretty-printer. *)\n mutable pp_is_new_line : bool;\n (* Total width of tokens already printed. *)\n mutable pp_left_total : int;\n (* Total width of tokens ever put in queue. *)\n mutable pp_right_total : int;\n (* Current number of open boxes. *)\n mutable pp_curr_depth : int;\n (* Maximum number of boxes which can be simultaneously open. *)\n mutable pp_max_boxes : int;\n (* Ellipsis string. *)\n mutable pp_ellipsis : string;\n (* Output function. *)\n mutable pp_out_string : string -> int -> int -> unit;\n (* Flushing function. *)\n mutable pp_out_flush : unit -> unit;\n (* Output of new lines. *)\n mutable pp_out_newline : unit -> unit;\n (* Output of break hints spaces. *)\n mutable pp_out_spaces : int -> unit;\n (* Output of indentation of new lines. *)\n mutable pp_out_indent : int -> unit;\n (* Are tags printed ? *)\n mutable pp_print_tags : bool;\n (* Are tags marked ? *)\n mutable pp_mark_tags : bool;\n (* Find opening and closing markers of tags. *)\n mutable pp_mark_open_tag : stag -> string;\n mutable pp_mark_close_tag : stag -> string;\n mutable pp_print_open_tag : stag -> unit;\n mutable pp_print_close_tag : stag -> unit;\n (* The pretty-printer queue. *)\n pp_queue : pp_queue;\n}\n\n\n(* The formatter specific tag handling functions. *)\ntype formatter_stag_functions = {\n mark_open_stag : stag -> string;\n mark_close_stag : stag -> string;\n print_open_stag : stag -> unit;\n print_close_stag : stag -> unit;\n}\n\n\n(* The formatter functions to output material. *)\ntype formatter_out_functions = {\n out_string : string -> int -> int -> unit;\n out_flush : unit -> unit;\n out_newline : unit -> unit;\n out_spaces : int -> unit;\n out_indent : int -> unit;\n}\n\n\n(*\n\n Auxiliaries and basic functions.\n\n*)\n\n(* Enter a token in the pretty-printer queue. *)\nlet pp_enqueue state token =\n state.pp_right_total <- state.pp_right_total + token.length;\n Queue.add token state.pp_queue\n\n\nlet pp_clear_queue state =\n state.pp_left_total <- 1; state.pp_right_total <- 1;\n Queue.clear state.pp_queue\n\n\n(* Pp_infinity: large value for default tokens size.\n\n Pp_infinity is documented as being greater than 1e10; to avoid\n confusion about the word 'greater', we choose pp_infinity greater\n than 1e10 + 1; for correct handling of tests in the algorithm,\n pp_infinity must be even one more than 1e10 + 1; let's stand on the\n safe side by choosing 1.e10+10.\n\n Pp_infinity could probably be 1073741823 that is 2^30 - 1, that is\n the minimal upper bound for integers; now that max_int is defined,\n this limit could also be defined as max_int - 1.\n\n However, before setting pp_infinity to something around max_int, we\n must carefully double-check all the integer arithmetic operations\n that involve pp_infinity, since any overflow would wreck havoc the\n pretty-printing algorithm's invariants. Given that this arithmetic\n correctness check is difficult and error prone and given that 1e10\n + 1 is in practice large enough, there is no need to attempt to set\n pp_infinity to the theoretically maximum limit. It is not worth the\n burden ! *)\nlet pp_infinity = 1000000010\n\n(* Output functions for the formatter. *)\nlet pp_output_string state s = state.pp_out_string s 0 (String.length s)\nand pp_output_newline state = state.pp_out_newline ()\nand pp_output_spaces state n = state.pp_out_spaces n\nand pp_output_indent state n = state.pp_out_indent n\n\n(* Format a textual token *)\nlet format_pp_text state size text =\n state.pp_space_left <- state.pp_space_left - size;\n pp_output_string state text;\n state.pp_is_new_line <- false\n\n(* Format a string by its length, if not empty *)\nlet format_string state s =\n if s <> \"\" then format_pp_text state (String.length s) s\n\n(* To format a break, indenting a new line. *)\nlet break_new_line state (before, offset, after) width =\n format_string state before;\n pp_output_newline state;\n state.pp_is_new_line <- true;\n let indent = state.pp_margin - width + offset in\n (* Don't indent more than pp_max_indent. *)\n let real_indent = Int.min state.pp_max_indent indent in\n state.pp_current_indent <- real_indent;\n state.pp_space_left <- state.pp_margin - state.pp_current_indent;\n pp_output_indent state state.pp_current_indent;\n format_string state after\n\n\n(* To force a line break inside a box: no offset is added. *)\nlet break_line state width = break_new_line state (\"\", 0, \"\") width\n\n(* To format a break that fits on the current line. *)\nlet break_same_line state (before, width, after) =\n format_string state before;\n state.pp_space_left <- state.pp_space_left - width;\n pp_output_spaces state width;\n format_string state after\n\n\n(* To indent no more than pp_max_indent, if one tries to open a box\n beyond pp_max_indent, then the box is rejected on the left\n by simulating a break. *)\nlet pp_force_break_line state =\n match Stack.top_opt state.pp_format_stack with\n | None -> pp_output_newline state\n | Some { box_type; width } ->\n if width > state.pp_space_left then\n match box_type with\n | Pp_fits | Pp_hbox -> ()\n | Pp_vbox | Pp_hvbox | Pp_hovbox | Pp_box -> break_line state width\n\n\n(* To skip a token, if the previous line has been broken. *)\nlet pp_skip_token state =\n match Queue.take_opt state.pp_queue with\n | None -> () (* print_if_newline must have been the last printing command *)\n | Some { size; length; _ } ->\n state.pp_left_total <- state.pp_left_total - length;\n state.pp_space_left <- state.pp_space_left + Size.to_int size\n\n\n(*\n\n The main pretty printing functions.\n\n*)\n\n(* Formatting a token with a given size. *)\nlet format_pp_token state size = function\n\n | Pp_text s ->\n format_pp_text state size s\n\n | Pp_begin (off, ty) ->\n let insertion_point = state.pp_margin - state.pp_space_left in\n if insertion_point > state.pp_max_indent then\n (* can not open a box right there. *)\n begin pp_force_break_line state end;\n let width = state.pp_space_left - off in\n let box_type =\n match ty with\n | Pp_vbox -> Pp_vbox\n | Pp_hbox | Pp_hvbox | Pp_hovbox | Pp_box | Pp_fits ->\n if size > state.pp_space_left then ty else Pp_fits in\n Stack.push { box_type; width } state.pp_format_stack\n\n | Pp_end ->\n Stack.pop_opt state.pp_format_stack |> ignore\n\n | Pp_tbegin (Pp_tbox _ as tbox) ->\n Stack.push tbox state.pp_tbox_stack\n\n | Pp_tend ->\n Stack.pop_opt state.pp_tbox_stack |> ignore\n\n | Pp_stab ->\n begin match Stack.top_opt state.pp_tbox_stack with\n | None -> () (* No open tabulation box. *)\n | Some (Pp_tbox tabs) ->\n let rec add_tab n = function\n | [] -> [n]\n | x :: l as ls -> if n < x then n :: ls else x :: add_tab n l in\n tabs := add_tab (state.pp_margin - state.pp_space_left) !tabs\n end\n\n | Pp_tbreak (n, off) ->\n let insertion_point = state.pp_margin - state.pp_space_left in\n begin match Stack.top_opt state.pp_tbox_stack with\n | None -> () (* No open tabulation box. *)\n | Some (Pp_tbox tabs) ->\n let tab =\n match !tabs with\n | [] -> insertion_point\n | first :: _ ->\n let rec find = function\n | head :: tail ->\n if head >= insertion_point then head else find tail\n | [] -> first in\n find !tabs in\n let offset = tab - insertion_point in\n if offset >= 0\n then break_same_line state (\"\", offset + n, \"\")\n else break_new_line state (\"\", tab + off, \"\") state.pp_margin\n end\n\n | Pp_newline ->\n begin match Stack.top_opt state.pp_format_stack with\n | None -> pp_output_newline state (* No open box. *)\n | Some { width; _} -> break_line state width\n end\n\n | Pp_if_newline ->\n if state.pp_current_indent != state.pp_margin - state.pp_space_left\n then pp_skip_token state\n\n | Pp_break { fits; breaks } ->\n let before, off, _ = breaks in\n begin match Stack.top_opt state.pp_format_stack with\n | None -> () (* No open box. *)\n | Some { box_type; width } ->\n begin match box_type with\n | Pp_hovbox ->\n if size + String.length before > state.pp_space_left\n then break_new_line state breaks width\n else break_same_line state fits\n | Pp_box ->\n (* Have the line just been broken here ? *)\n if state.pp_is_new_line then break_same_line state fits else\n if size + String.length before > state.pp_space_left\n then break_new_line state breaks width else\n (* break the line here leads to new indentation ? *)\n if state.pp_current_indent > state.pp_margin - width + off\n then break_new_line state breaks width\n else break_same_line state fits\n | Pp_hvbox -> break_new_line state breaks width\n | Pp_fits -> break_same_line state fits\n | Pp_vbox -> break_new_line state breaks width\n | Pp_hbox -> break_same_line state fits\n end\n end\n\n | Pp_open_tag tag_name ->\n let marker = state.pp_mark_open_tag tag_name in\n pp_output_string state marker;\n Stack.push tag_name state.pp_mark_stack\n\n | Pp_close_tag ->\n begin match Stack.pop_opt state.pp_mark_stack with\n | None -> () (* No more tag to close. *)\n | Some tag_name ->\n let marker = state.pp_mark_close_tag tag_name in\n pp_output_string state marker\n end\n\n\n(* Print if token size is known else printing is delayed.\n Printing is delayed when the text waiting in the queue requires\n more room to format than exists on the current line. *)\nlet rec advance_left state =\n match Queue.peek_opt state.pp_queue with\n | None -> () (* No tokens to print *)\n | Some { size; token; length } ->\n let pending_count = state.pp_right_total - state.pp_left_total in\n if Size.is_known size || pending_count >= state.pp_space_left then begin\n Queue.take state.pp_queue |> ignore; (* Not empty: we peek into it *)\n let size = if Size.is_known size then Size.to_int size else pp_infinity in\n format_pp_token state size token;\n state.pp_left_total <- length + state.pp_left_total;\n (advance_left [@tailcall]) state\n end\n\n\n(* To enqueue a token : try to advance. *)\nlet enqueue_advance state tok = pp_enqueue state tok; advance_left state\n\n\n(* To enqueue strings. *)\nlet enqueue_string_as state size s =\n enqueue_advance state { size; token = Pp_text s; length = Size.to_int size }\n\n\nlet enqueue_string state s =\n enqueue_string_as state (Size.of_int (String.length s)) s\n\n\n(* Routines for scan stack\n determine size of boxes. *)\n\n(* The scan_stack is never empty. *)\nlet initialize_scan_stack stack =\n Stack.clear stack;\n let queue_elem = { size = Size.unknown; token = Pp_text \"\"; length = 0 } in\n Stack.push { left_total = -1; queue_elem } stack\n\n(* Setting the size of boxes on scan stack:\n if ty = true then size of break is set else size of box is set;\n in each case pp_scan_stack is popped.\n\n Note:\n Pattern matching on scan stack is exhaustive, since scan_stack is never\n empty.\n Pattern matching on token in scan stack is also exhaustive,\n since scan_push is used on breaks and opening of boxes. *)\nlet set_size state ty =\n match Stack.top_opt state.pp_scan_stack with\n | None -> () (* scan_stack is never empty. *)\n | Some { left_total; queue_elem } ->\n let size = Size.to_int queue_elem.size in\n (* test if scan stack contains any data that is not obsolete. *)\n if left_total < state.pp_left_total then\n initialize_scan_stack state.pp_scan_stack\n else\n match queue_elem.token with\n | Pp_break _ | Pp_tbreak (_, _) ->\n if ty then begin\n queue_elem.size <- Size.of_int (state.pp_right_total + size);\n Stack.pop_opt state.pp_scan_stack |> ignore\n end\n | Pp_begin (_, _) ->\n if not ty then begin\n queue_elem.size <- Size.of_int (state.pp_right_total + size);\n Stack.pop_opt state.pp_scan_stack |> ignore\n end\n | Pp_text _ | Pp_stab | Pp_tbegin _ | Pp_tend | Pp_end\n | Pp_newline | Pp_if_newline | Pp_open_tag _ | Pp_close_tag ->\n () (* scan_push is only used for breaks and boxes. *)\n\n\n(* Push a token on pretty-printer scanning stack.\n If b is true set_size is called. *)\nlet scan_push state b token =\n pp_enqueue state token;\n if b then set_size state true;\n let elem = { left_total = state.pp_right_total; queue_elem = token } in\n Stack.push elem state.pp_scan_stack\n\n\n(* To open a new box :\n the user may set the depth bound pp_max_boxes\n any text nested deeper is printed as the ellipsis string. *)\nlet pp_open_box_gen state indent br_ty =\n state.pp_curr_depth <- state.pp_curr_depth + 1;\n if state.pp_curr_depth < state.pp_max_boxes then\n let size = Size.of_int (- state.pp_right_total) in\n let elem = { size; token = Pp_begin (indent, br_ty); length = 0 } in\n scan_push state false elem else\n if state.pp_curr_depth = state.pp_max_boxes\n then enqueue_string state state.pp_ellipsis\n\n\n(* The box which is always open. *)\nlet pp_open_sys_box state = pp_open_box_gen state 0 Pp_hovbox\n\n(* Close a box, setting sizes of its sub boxes. *)\nlet pp_close_box state () =\n if state.pp_curr_depth > 1 then\n begin\n if state.pp_curr_depth < state.pp_max_boxes then\n begin\n pp_enqueue state { size = Size.zero; token = Pp_end; length = 0 };\n set_size state true; set_size state false\n end;\n state.pp_curr_depth <- state.pp_curr_depth - 1;\n end\n\n\n(* Open a tag, pushing it on the tag stack. *)\nlet pp_open_stag state tag_name =\n if state.pp_print_tags then\n begin\n Stack.push tag_name state.pp_tag_stack;\n state.pp_print_open_tag tag_name\n end;\n if state.pp_mark_tags then\n let token = Pp_open_tag tag_name in\n pp_enqueue state { size = Size.zero; token; length = 0 }\n\n\n(* Close a tag, popping it from the tag stack. *)\nlet pp_close_stag state () =\n if state.pp_mark_tags then\n pp_enqueue state { size = Size.zero; token = Pp_close_tag; length = 0 };\n if state.pp_print_tags then\n match Stack.pop_opt state.pp_tag_stack with\n | None -> () (* No more tag to close. *)\n | Some tag_name ->\n state.pp_print_close_tag tag_name\n\nlet pp_open_tag state s = pp_open_stag state (String_tag s)\nlet pp_close_tag state () = pp_close_stag state ()\n\nlet pp_set_print_tags state b = state.pp_print_tags <- b\nlet pp_set_mark_tags state b = state.pp_mark_tags <- b\nlet pp_get_print_tags state () = state.pp_print_tags\nlet pp_get_mark_tags state () = state.pp_mark_tags\nlet pp_set_tags state b =\n pp_set_print_tags state b; pp_set_mark_tags state b\n\n\n(* Handling tag handling functions: get/set functions. *)\nlet pp_get_formatter_stag_functions state () = {\n mark_open_stag = state.pp_mark_open_tag;\n mark_close_stag = state.pp_mark_close_tag;\n print_open_stag = state.pp_print_open_tag;\n print_close_stag = state.pp_print_close_tag;\n}\n\n\nlet pp_set_formatter_stag_functions state {\n mark_open_stag = mot;\n mark_close_stag = mct;\n print_open_stag = pot;\n print_close_stag = pct;\n } =\n state.pp_mark_open_tag <- mot;\n state.pp_mark_close_tag <- mct;\n state.pp_print_open_tag <- pot;\n state.pp_print_close_tag <- pct\n\n\n(* Initialize pretty-printer. *)\nlet pp_rinit state =\n pp_clear_queue state;\n initialize_scan_stack state.pp_scan_stack;\n Stack.clear state.pp_format_stack;\n Stack.clear state.pp_tbox_stack;\n Stack.clear state.pp_tag_stack;\n Stack.clear state.pp_mark_stack;\n state.pp_current_indent <- 0;\n state.pp_curr_depth <- 0;\n state.pp_space_left <- state.pp_margin;\n pp_open_sys_box state\n\nlet clear_tag_stack state =\n Stack.iter (fun _ -> pp_close_tag state ()) state.pp_tag_stack\n\n\n(* Flushing pretty-printer queue. *)\nlet pp_flush_queue state b =\n clear_tag_stack state;\n while state.pp_curr_depth > 1 do\n pp_close_box state ()\n done;\n state.pp_right_total <- pp_infinity;\n advance_left state;\n if b then pp_output_newline state;\n pp_rinit state\n\n(*\n\n Procedures to format values and use boxes.\n\n*)\n\n(* To format a string. *)\nlet pp_print_as_size state size s =\n if state.pp_curr_depth < state.pp_max_boxes\n then enqueue_string_as state size s\n\n\nlet pp_print_as state isize s =\n pp_print_as_size state (Size.of_int isize) s\n\n\nlet pp_print_string state s =\n pp_print_as state (String.length s) s\n\nlet pp_print_bytes state s =\n pp_print_as state (Bytes.length s) (Bytes.to_string s)\n\n(* To format an integer. *)\nlet pp_print_int state i = pp_print_string state (Int.to_string i)\n\n(* To format a float. *)\nlet pp_print_float state f = pp_print_string state (string_of_float f)\n\n(* To format a boolean. *)\nlet pp_print_bool state b = pp_print_string state (string_of_bool b)\n\n(* To format a char. *)\nlet pp_print_char state c =\n pp_print_as state 1 (String.make 1 c)\n\n\n(* Opening boxes. *)\nlet pp_open_hbox state () = pp_open_box_gen state 0 Pp_hbox\nand pp_open_vbox state indent = pp_open_box_gen state indent Pp_vbox\n\nand pp_open_hvbox state indent = pp_open_box_gen state indent Pp_hvbox\nand pp_open_hovbox state indent = pp_open_box_gen state indent Pp_hovbox\nand pp_open_box state indent = pp_open_box_gen state indent Pp_box\n\n\n(* Printing queued text.\n\n [pp_print_flush] prints all pending items in the pretty-printer queue and\n then flushes the low level output device of the formatter to actually\n display printing material.\n\n [pp_print_newline] behaves as [pp_print_flush] after printing an additional\n new line. *)\nlet pp_print_newline state () =\n pp_flush_queue state true; state.pp_out_flush ()\nand pp_print_flush state () =\n pp_flush_queue state false; state.pp_out_flush ()\n\n\n(* To get a newline when one does not want to close the current box. *)\nlet pp_force_newline state () =\n if state.pp_curr_depth < state.pp_max_boxes then\n enqueue_advance state { size = Size.zero; token = Pp_newline; length = 0 }\n\n\n(* To format something, only in case the line has just been broken. *)\nlet pp_print_if_newline state () =\n if state.pp_curr_depth < state.pp_max_boxes then\n enqueue_advance state\n { size = Size.zero; token = Pp_if_newline; length = 0 }\n\n\n(* Generalized break hint that allows printing strings before/after\n same-line offset (width) or new-line offset *)\nlet pp_print_custom_break state ~fits ~breaks =\n let before, width, after = fits in\n if state.pp_curr_depth < state.pp_max_boxes then\n let size = Size.of_int (- state.pp_right_total) in\n let token = Pp_break { fits; breaks } in\n let length = String.length before + width + String.length after in\n let elem = { size; token; length } in\n scan_push state true elem\n\n(* Printing break hints:\n A break hint indicates where a box may be broken.\n If line is broken then offset is added to the indentation of the current\n box else (the value of) width blanks are printed. *)\nlet pp_print_break state width offset =\n pp_print_custom_break state\n ~fits:(\"\", width, \"\") ~breaks:(\"\", offset, \"\")\n\n\n(* Print a space :\n a space is a break hint that prints a single space if the break does not\n split the line;\n a cut is a break hint that prints nothing if the break does not split the\n line. *)\nlet pp_print_space state () = pp_print_break state 1 0\nand pp_print_cut state () = pp_print_break state 0 0\n\n\n(* Tabulation boxes. *)\nlet pp_open_tbox state () =\n state.pp_curr_depth <- state.pp_curr_depth + 1;\n if state.pp_curr_depth < state.pp_max_boxes then\n let size = Size.zero in\n let elem = { size; token = Pp_tbegin (Pp_tbox (ref [])); length = 0 } in\n enqueue_advance state elem\n\n\n(* Close a tabulation box. *)\nlet pp_close_tbox state () =\n if state.pp_curr_depth > 1 then\n begin\n if state.pp_curr_depth < state.pp_max_boxes then\n let elem = { size = Size.zero; token = Pp_tend; length = 0 } in\n enqueue_advance state elem;\n state.pp_curr_depth <- state.pp_curr_depth - 1\n end\n\n\n(* Print a tabulation break. *)\nlet pp_print_tbreak state width offset =\n if state.pp_curr_depth < state.pp_max_boxes then\n let size = Size.of_int (- state.pp_right_total) in\n let elem = { size; token = Pp_tbreak (width, offset); length = width } in\n scan_push state true elem\n\n\nlet pp_print_tab state () = pp_print_tbreak state 0 0\n\nlet pp_set_tab state () =\n if state.pp_curr_depth < state.pp_max_boxes then\n let elem = { size = Size.zero; token = Pp_stab; length = 0 } in\n enqueue_advance state elem\n\n\n(*\n\n Procedures to control the pretty-printers\n\n*)\n\n(* Set_max_boxes. *)\nlet pp_set_max_boxes state n = if n > 1 then state.pp_max_boxes <- n\n\n(* To know the current maximum number of boxes allowed. *)\nlet pp_get_max_boxes state () = state.pp_max_boxes\n\nlet pp_over_max_boxes state () = state.pp_curr_depth = state.pp_max_boxes\n\n(* Ellipsis. *)\nlet pp_set_ellipsis_text state s = state.pp_ellipsis <- s\nand pp_get_ellipsis_text state () = state.pp_ellipsis\n\n\n(* To set the margin of pretty-printer. *)\nlet pp_limit n =\n if n < pp_infinity then n else pred pp_infinity\n\n\n(* Internal pretty-printer functions. *)\nlet pp_set_min_space_left state n =\n if n >= 1 then\n let n = pp_limit n in\n state.pp_min_space_left <- n;\n state.pp_max_indent <- state.pp_margin - state.pp_min_space_left;\n pp_rinit state\n\n\n(* Initially, we have :\n pp_max_indent = pp_margin - pp_min_space_left, and\n pp_space_left = pp_margin. *)\nlet pp_set_max_indent state n =\n if n > 1 then\n pp_set_min_space_left state (state.pp_margin - n)\n\n\nlet pp_get_max_indent state () = state.pp_max_indent\n\nlet pp_set_margin state n =\n if n >= 1 then\n let n = pp_limit n in\n state.pp_margin <- n;\n let new_max_indent =\n (* Try to maintain max_indent to its actual value. *)\n if state.pp_max_indent <= state.pp_margin\n then state.pp_max_indent else\n (* If possible maintain pp_min_space_left to its actual value,\n if this leads to a too small max_indent, take half of the\n new margin, if it is greater than 1. *)\n Int.max (Int.max (state.pp_margin - state.pp_min_space_left)\n (state.pp_margin / 2)) 1 in\n (* Rebuild invariants. *)\n pp_set_max_indent state new_max_indent\n\n\n(** Geometry functions and types *)\ntype geometry = { max_indent:int; margin: int}\n\nlet validate_geometry {margin; max_indent} =\n if max_indent < 2 then\n Error \"max_indent < 2\"\n else if margin <= max_indent then\n Error \"margin <= max_indent\"\n else Ok ()\n\nlet check_geometry geometry =\n match validate_geometry geometry with\n | Ok () -> true\n | Error _ -> false\n\nlet pp_get_margin state () = state.pp_margin\n\nlet pp_set_full_geometry state {margin; max_indent} =\n pp_set_margin state margin;\n pp_set_max_indent state max_indent;\n ()\n\nlet pp_set_geometry state ~max_indent ~margin =\n let geometry = { max_indent; margin } in\n match validate_geometry geometry with\n | Error msg ->\n raise (Invalid_argument (\"Format.pp_set_geometry: \" ^ msg))\n | Ok () ->\n pp_set_full_geometry state geometry\n\nlet pp_safe_set_geometry state ~max_indent ~margin =\n let geometry = { max_indent; margin } in\n match validate_geometry geometry with\n | Error _msg ->\n ()\n | Ok () ->\n pp_set_full_geometry state geometry\n\nlet pp_get_geometry state () =\n { margin = pp_get_margin state (); max_indent = pp_get_max_indent state () }\n\nlet pp_update_geometry state update =\n let geometry = pp_get_geometry state () in\n pp_set_full_geometry state (update geometry)\n\n(* Setting a formatter basic output functions. *)\nlet pp_set_formatter_out_functions state {\n out_string = f;\n out_flush = g;\n out_newline = h;\n out_spaces = i;\n out_indent = j;\n } =\n state.pp_out_string <- f;\n state.pp_out_flush <- g;\n state.pp_out_newline <- h;\n state.pp_out_spaces <- i;\n state.pp_out_indent <- j\n\nlet pp_get_formatter_out_functions state () = {\n out_string = state.pp_out_string;\n out_flush = state.pp_out_flush;\n out_newline = state.pp_out_newline;\n out_spaces = state.pp_out_spaces;\n out_indent = state.pp_out_indent;\n}\n\n\n(* Setting a formatter basic string output and flush functions. *)\nlet pp_set_formatter_output_functions state f g =\n state.pp_out_string <- f; state.pp_out_flush <- g\n\nlet pp_get_formatter_output_functions state () =\n (state.pp_out_string, state.pp_out_flush)\n\n\n(* The default function to output new lines. *)\nlet display_newline state () = state.pp_out_string \"\\n\" 0 1\n\n(* The default function to output spaces. *)\nlet blank_line = String.make 80 ' '\nlet rec display_blanks state n =\n if n > 0 then\n if n <= 80 then state.pp_out_string blank_line 0 n else\n begin\n state.pp_out_string blank_line 0 80;\n display_blanks state (n - 80)\n end\n\n\n(* The default function to output indentation of new lines. *)\nlet display_indent = display_blanks\n\n(* Setting a formatter basic output functions as printing to a given\n [Pervasive.out_channel] value. *)\nlet pp_set_formatter_out_channel state oc =\n state.pp_out_string <- output_substring oc;\n state.pp_out_flush <- (fun () -> flush oc);\n state.pp_out_newline <- display_newline state;\n state.pp_out_spaces <- display_blanks state;\n state.pp_out_indent <- display_indent state\n\n(*\n\n Defining specific formatters\n\n*)\n\nlet default_pp_mark_open_tag = function\n | String_tag s -> \"<\" ^ s ^ \">\"\n | _ -> \"\"\nlet default_pp_mark_close_tag = function\n | String_tag s -> \"\"\n | _ -> \"\"\n\nlet default_pp_print_open_tag = ignore\nlet default_pp_print_close_tag = ignore\n\n(* Building a formatter given its basic output functions.\n Other fields get reasonable default values. *)\nlet pp_make_formatter f g h i j =\n (* The initial state of the formatter contains a dummy box. *)\n let pp_queue = Queue.create () in\n let sys_tok =\n { size = Size.unknown; token = Pp_begin (0, Pp_hovbox); length = 0 } in\n Queue.add sys_tok pp_queue;\n let scan_stack = Stack.create () in\n initialize_scan_stack scan_stack;\n Stack.push { left_total = 1; queue_elem = sys_tok } scan_stack;\n let pp_margin = 78\n and pp_min_space_left = 10 in\n {\n pp_scan_stack = scan_stack;\n pp_format_stack = Stack.create ();\n pp_tbox_stack = Stack.create ();\n pp_tag_stack = Stack.create ();\n pp_mark_stack = Stack.create ();\n pp_margin = pp_margin;\n pp_min_space_left = pp_min_space_left;\n pp_max_indent = pp_margin - pp_min_space_left;\n pp_space_left = pp_margin;\n pp_current_indent = 0;\n pp_is_new_line = true;\n pp_left_total = 1;\n pp_right_total = 1;\n pp_curr_depth = 1;\n pp_max_boxes = max_int;\n pp_ellipsis = \".\";\n pp_out_string = f;\n pp_out_flush = g;\n pp_out_newline = h;\n pp_out_spaces = i;\n pp_out_indent = j;\n pp_print_tags = false;\n pp_mark_tags = false;\n pp_mark_open_tag = default_pp_mark_open_tag;\n pp_mark_close_tag = default_pp_mark_close_tag;\n pp_print_open_tag = default_pp_print_open_tag;\n pp_print_close_tag = default_pp_print_close_tag;\n pp_queue = pp_queue;\n }\n\n\n(* Build a formatter out of its out functions. *)\nlet formatter_of_out_functions out_funs =\n pp_make_formatter\n out_funs.out_string\n out_funs.out_flush\n out_funs.out_newline\n out_funs.out_spaces\n out_funs.out_indent\n\n\n(* Make a formatter with default functions to output spaces,\n indentation, and new lines. *)\nlet make_formatter output flush =\n let ppf = pp_make_formatter output flush ignore ignore ignore in\n ppf.pp_out_newline <- display_newline ppf;\n ppf.pp_out_spaces <- display_blanks ppf;\n ppf.pp_out_indent <- display_indent ppf;\n ppf\n\n\n(* Make a formatter writing to a given [Pervasive.out_channel] value. *)\nlet formatter_of_out_channel oc =\n make_formatter (output_substring oc) (fun () -> flush oc)\n\n\n(* Make a formatter writing to a given [Buffer.t] value. *)\nlet formatter_of_buffer b =\n make_formatter (Buffer.add_substring b) ignore\n\n\n(* Allocating buffer for pretty-printing purposes.\n Default buffer size is pp_buffer_size or 512.\n*)\nlet pp_buffer_size = 512\nlet pp_make_buffer () = Buffer.create pp_buffer_size\n\n(* The standard (shared) buffer. *)\nlet stdbuf = pp_make_buffer ()\n\n(* Predefined formatters standard formatter to print\n to [Stdlib.stdout], [Stdlib.stderr], and {!stdbuf}. *)\nlet std_formatter = formatter_of_out_channel Stdlib.stdout\nand err_formatter = formatter_of_out_channel Stdlib.stderr\nand str_formatter = formatter_of_buffer stdbuf\n\n\n(* [flush_buffer_formatter buf ppf] flushes formatter [ppf],\n then returns the contents of buffer [buf] that is reset.\n Formatter [ppf] is supposed to print to buffer [buf], otherwise this\n function is not really useful. *)\nlet flush_buffer_formatter buf ppf =\n pp_flush_queue ppf false;\n let s = Buffer.contents buf in\n Buffer.reset buf;\n s\n\n\n(* Flush [str_formatter] and get the contents of [stdbuf]. *)\nlet flush_str_formatter () = flush_buffer_formatter stdbuf str_formatter\n\n(*\n Symbolic pretty-printing\n*)\n\n(*\n Symbolic pretty-printing is pretty-printing with no low level output.\n\n When using a symbolic formatter, all regular pretty-printing activities\n occur but output material is symbolic and stored in a buffer of output\n items. At the end of pretty-printing, flushing the output buffer allows\n post-processing of symbolic output before low level output operations.\n*)\n\ntype symbolic_output_item =\n | Output_flush\n | Output_newline\n | Output_string of string\n | Output_spaces of int\n | Output_indent of int\n\ntype symbolic_output_buffer = {\n mutable symbolic_output_contents : symbolic_output_item list;\n}\n\nlet make_symbolic_output_buffer () =\n { symbolic_output_contents = [] }\n\nlet clear_symbolic_output_buffer sob =\n sob.symbolic_output_contents <- []\n\nlet get_symbolic_output_buffer sob =\n List.rev sob.symbolic_output_contents\n\nlet flush_symbolic_output_buffer sob =\n let items = get_symbolic_output_buffer sob in\n clear_symbolic_output_buffer sob;\n items\n\nlet add_symbolic_output_item sob item =\n sob.symbolic_output_contents <- item :: sob.symbolic_output_contents\n\nlet formatter_of_symbolic_output_buffer sob =\n let symbolic_flush sob () =\n add_symbolic_output_item sob Output_flush\n and symbolic_newline sob () =\n add_symbolic_output_item sob Output_newline\n and symbolic_string sob s i n =\n add_symbolic_output_item sob (Output_string (String.sub s i n))\n and symbolic_spaces sob n =\n add_symbolic_output_item sob (Output_spaces n)\n and symbolic_indent sob n =\n add_symbolic_output_item sob (Output_indent n) in\n\n let f = symbolic_string sob\n and g = symbolic_flush sob\n and h = symbolic_newline sob\n and i = symbolic_spaces sob\n and j = symbolic_indent sob in\n pp_make_formatter f g h i j\n\n(*\n\n Basic functions on the 'standard' formatter\n (the formatter that prints to [Stdlib.stdout]).\n\n*)\n\nlet open_hbox = pp_open_hbox std_formatter\nand open_vbox = pp_open_vbox std_formatter\nand open_hvbox = pp_open_hvbox std_formatter\nand open_hovbox = pp_open_hovbox std_formatter\nand open_box = pp_open_box std_formatter\nand close_box = pp_close_box std_formatter\nand open_tag = pp_open_tag std_formatter\nand close_tag = pp_close_tag std_formatter\nand open_stag = pp_open_stag std_formatter\nand close_stag = pp_close_stag std_formatter\nand print_as = pp_print_as std_formatter\nand print_string = pp_print_string std_formatter\nand print_bytes = pp_print_bytes std_formatter\nand print_int = pp_print_int std_formatter\nand print_float = pp_print_float std_formatter\nand print_char = pp_print_char std_formatter\nand print_bool = pp_print_bool std_formatter\nand print_break = pp_print_break std_formatter\nand print_cut = pp_print_cut std_formatter\nand print_space = pp_print_space std_formatter\nand force_newline = pp_force_newline std_formatter\nand print_flush = pp_print_flush std_formatter\nand print_newline = pp_print_newline std_formatter\nand print_if_newline = pp_print_if_newline std_formatter\n\nand open_tbox = pp_open_tbox std_formatter\nand close_tbox = pp_close_tbox std_formatter\nand print_tbreak = pp_print_tbreak std_formatter\n\nand set_tab = pp_set_tab std_formatter\nand print_tab = pp_print_tab std_formatter\n\nand set_margin = pp_set_margin std_formatter\nand get_margin = pp_get_margin std_formatter\n\nand set_max_indent = pp_set_max_indent std_formatter\nand get_max_indent = pp_get_max_indent std_formatter\n\nand set_geometry = pp_set_geometry std_formatter\nand safe_set_geometry = pp_safe_set_geometry std_formatter\nand get_geometry = pp_get_geometry std_formatter\nand update_geometry = pp_update_geometry std_formatter\n\nand set_max_boxes = pp_set_max_boxes std_formatter\nand get_max_boxes = pp_get_max_boxes std_formatter\nand over_max_boxes = pp_over_max_boxes std_formatter\n\nand set_ellipsis_text = pp_set_ellipsis_text std_formatter\nand get_ellipsis_text = pp_get_ellipsis_text std_formatter\n\nand set_formatter_out_channel =\n pp_set_formatter_out_channel std_formatter\n\nand set_formatter_out_functions =\n pp_set_formatter_out_functions std_formatter\nand get_formatter_out_functions =\n pp_get_formatter_out_functions std_formatter\n\nand set_formatter_output_functions =\n pp_set_formatter_output_functions std_formatter\nand get_formatter_output_functions =\n pp_get_formatter_output_functions std_formatter\n\nand set_formatter_stag_functions =\n pp_set_formatter_stag_functions std_formatter\nand get_formatter_stag_functions =\n pp_get_formatter_stag_functions std_formatter\nand set_print_tags =\n pp_set_print_tags std_formatter\nand get_print_tags =\n pp_get_print_tags std_formatter\nand set_mark_tags =\n pp_set_mark_tags std_formatter\nand get_mark_tags =\n pp_get_mark_tags std_formatter\nand set_tags =\n pp_set_tags std_formatter\n\n\n(* Convenience functions *)\n\n(* To format a list *)\nlet rec pp_print_list ?(pp_sep = pp_print_cut) pp_v ppf = function\n | [] -> ()\n | [v] -> pp_v ppf v\n | v :: vs ->\n pp_v ppf v;\n pp_sep ppf ();\n pp_print_list ~pp_sep pp_v ppf vs\n\n(* To format a sequence *)\nlet rec pp_print_seq_in ~pp_sep pp_v ppf seq =\n match seq () with\n | Seq.Nil -> ()\n | Seq.Cons (v, seq) ->\n pp_sep ppf ();\n pp_v ppf v;\n pp_print_seq_in ~pp_sep pp_v ppf seq\n\nlet pp_print_seq ?(pp_sep = pp_print_cut) pp_v ppf seq =\n match seq () with\n | Seq.Nil -> ()\n | Seq.Cons (v, seq) ->\n pp_v ppf v;\n pp_print_seq_in ~pp_sep pp_v ppf seq\n\n(* To format free-flowing text *)\nlet pp_print_text ppf s =\n let len = String.length s in\n let left = ref 0 in\n let right = ref 0 in\n let flush () =\n pp_print_string ppf (String.sub s !left (!right - !left));\n incr right; left := !right;\n in\n while (!right <> len) do\n match s.[!right] with\n | '\\n' ->\n flush ();\n pp_force_newline ppf ()\n | ' ' ->\n flush (); pp_print_space ppf ()\n (* there is no specific support for '\\t'\n as it is unclear what a right semantics would be *)\n | _ -> incr right\n done;\n if !left <> len then flush ()\n\nlet pp_print_option ?(none = fun _ () -> ()) pp_v ppf = function\n| None -> none ppf ()\n| Some v -> pp_v ppf v\n\nlet pp_print_result ~ok ~error ppf = function\n| Ok v -> ok ppf v\n| Error e -> error ppf e\n\nlet pp_print_either ~left ~right ppf = function\n| Either.Left l -> left ppf l\n| Either.Right r -> right ppf r\n\n (**************************************************************)\n\nlet compute_tag output tag_acc =\n let buf = Buffer.create 16 in\n let ppf = formatter_of_buffer buf in\n output ppf tag_acc;\n pp_print_flush ppf ();\n let len = Buffer.length buf in\n if len < 2 then Buffer.contents buf\n else Buffer.sub buf 1 (len - 2)\n\n (**************************************************************\n\n Defining continuations to be passed as arguments of\n CamlinternalFormat.make_printf.\n\n **************************************************************)\n\nopen CamlinternalFormatBasics\nopen CamlinternalFormat\n\n(* Interpret a formatting entity on a formatter. *)\nlet output_formatting_lit ppf fmting_lit = match fmting_lit with\n | Close_box -> pp_close_box ppf ()\n | Close_tag -> pp_close_tag ppf ()\n | Break (_, width, offset) -> pp_print_break ppf width offset\n | FFlush -> pp_print_flush ppf ()\n | Force_newline -> pp_force_newline ppf ()\n | Flush_newline -> pp_print_newline ppf ()\n | Magic_size (_, _) -> ()\n | Escaped_at -> pp_print_char ppf '@'\n | Escaped_percent -> pp_print_char ppf '%'\n | Scan_indic c -> pp_print_char ppf '@'; pp_print_char ppf c\n\n(* Recursively output an \"accumulator\" containing a reversed list of\n printing entities (string, char, flus, ...) in an output_stream. *)\n(* Differ from Printf.output_acc by the interpretation of formatting. *)\n(* Used as a continuation of CamlinternalFormat.make_printf. *)\nlet rec output_acc ppf acc = match acc with\n | Acc_string_literal (Acc_formatting_lit (p, Magic_size (_, size)), s)\n | Acc_data_string (Acc_formatting_lit (p, Magic_size (_, size)), s) ->\n output_acc ppf p;\n pp_print_as_size ppf (Size.of_int size) s;\n | Acc_char_literal (Acc_formatting_lit (p, Magic_size (_, size)), c)\n | Acc_data_char (Acc_formatting_lit (p, Magic_size (_, size)), c) ->\n output_acc ppf p;\n pp_print_as_size ppf (Size.of_int size) (String.make 1 c);\n | Acc_formatting_lit (p, f) ->\n output_acc ppf p;\n output_formatting_lit ppf f;\n | Acc_formatting_gen (p, Acc_open_tag acc') ->\n output_acc ppf p;\n pp_open_stag ppf (String_tag (compute_tag output_acc acc'))\n | Acc_formatting_gen (p, Acc_open_box acc') ->\n output_acc ppf p;\n let (indent, bty) = open_box_of_string (compute_tag output_acc acc') in\n pp_open_box_gen ppf indent bty\n | Acc_string_literal (p, s)\n | Acc_data_string (p, s) -> output_acc ppf p; pp_print_string ppf s;\n | Acc_char_literal (p, c)\n | Acc_data_char (p, c) -> output_acc ppf p; pp_print_char ppf c;\n | Acc_delay (p, f) -> output_acc ppf p; f ppf;\n | Acc_flush p -> output_acc ppf p; pp_print_flush ppf ();\n | Acc_invalid_arg (p, msg) -> output_acc ppf p; invalid_arg msg;\n | End_of_acc -> ()\n\n(* Recursively output an \"accumulator\" containing a reversed list of\n printing entities (string, char, flus, ...) in a buffer. *)\n(* Differ from Printf.bufput_acc by the interpretation of formatting. *)\n(* Used as a continuation of CamlinternalFormat.make_printf. *)\nlet rec strput_acc ppf acc = match acc with\n | Acc_string_literal (Acc_formatting_lit (p, Magic_size (_, size)), s)\n | Acc_data_string (Acc_formatting_lit (p, Magic_size (_, size)), s) ->\n strput_acc ppf p;\n pp_print_as_size ppf (Size.of_int size) s;\n | Acc_char_literal (Acc_formatting_lit (p, Magic_size (_, size)), c)\n | Acc_data_char (Acc_formatting_lit (p, Magic_size (_, size)), c) ->\n strput_acc ppf p;\n pp_print_as_size ppf (Size.of_int size) (String.make 1 c);\n | Acc_delay (Acc_formatting_lit (p, Magic_size (_, size)), f) ->\n strput_acc ppf p;\n pp_print_as_size ppf (Size.of_int size) (f ());\n | Acc_formatting_lit (p, f) ->\n strput_acc ppf p;\n output_formatting_lit ppf f;\n | Acc_formatting_gen (p, Acc_open_tag acc') ->\n strput_acc ppf p;\n pp_open_stag ppf (String_tag (compute_tag strput_acc acc'))\n | Acc_formatting_gen (p, Acc_open_box acc') ->\n strput_acc ppf p;\n let (indent, bty) = open_box_of_string (compute_tag strput_acc acc') in\n pp_open_box_gen ppf indent bty\n | Acc_string_literal (p, s)\n | Acc_data_string (p, s) -> strput_acc ppf p; pp_print_string ppf s;\n | Acc_char_literal (p, c)\n | Acc_data_char (p, c) -> strput_acc ppf p; pp_print_char ppf c;\n | Acc_delay (p, f) -> strput_acc ppf p; pp_print_string ppf (f ());\n | Acc_flush p -> strput_acc ppf p; pp_print_flush ppf ();\n | Acc_invalid_arg (p, msg) -> strput_acc ppf p; invalid_arg msg;\n | End_of_acc -> ()\n\n(*\n\n Defining [fprintf] and various flavors of [fprintf].\n\n*)\n\nlet kfprintf k ppf (Format (fmt, _)) =\n make_printf\n (fun acc -> output_acc ppf acc; k ppf)\n End_of_acc fmt\n\nand ikfprintf k ppf (Format (fmt, _)) =\n make_iprintf k ppf fmt\n\nlet ifprintf _ppf (Format (fmt, _)) =\n make_iprintf ignore () fmt\n\nlet fprintf ppf = kfprintf ignore ppf\nlet printf fmt = fprintf std_formatter fmt\nlet eprintf fmt = fprintf err_formatter fmt\n\nlet kdprintf k (Format (fmt, _)) =\n make_printf\n (fun acc -> k (fun ppf -> output_acc ppf acc))\n End_of_acc fmt\n\nlet dprintf fmt = kdprintf (fun i -> i) fmt\n\nlet ksprintf k (Format (fmt, _)) =\n let b = pp_make_buffer () in\n let ppf = formatter_of_buffer b in\n let k acc =\n strput_acc ppf acc;\n k (flush_buffer_formatter b ppf) in\n make_printf k End_of_acc fmt\n\n\nlet sprintf fmt = ksprintf id fmt\n\nlet kasprintf k (Format (fmt, _)) =\n let b = pp_make_buffer () in\n let ppf = formatter_of_buffer b in\n let k acc =\n output_acc ppf acc;\n k (flush_buffer_formatter b ppf) in\n make_printf k End_of_acc fmt\n\n\nlet asprintf fmt = kasprintf id fmt\n\n(* Flushing standard formatters at end of execution. *)\n\nlet flush_standard_formatters () =\n pp_print_flush std_formatter ();\n pp_print_flush err_formatter ()\n\nlet () = at_exit flush_standard_formatters\n\n(*\n\n Deprecated stuff.\n\n*)\n\n(* Deprecated : subsumed by pp_set_formatter_out_functions *)\nlet pp_set_all_formatter_output_functions state\n ~out:f ~flush:g ~newline:h ~spaces:i =\n pp_set_formatter_output_functions state f g;\n state.pp_out_newline <- h;\n state.pp_out_spaces <- i\n\n(* Deprecated : subsumed by pp_get_formatter_out_functions *)\nlet pp_get_all_formatter_output_functions state () =\n (state.pp_out_string, state.pp_out_flush,\n state.pp_out_newline, state.pp_out_spaces)\n\n\n(* Deprecated : subsumed by set_formatter_out_functions *)\nlet set_all_formatter_output_functions =\n pp_set_all_formatter_output_functions std_formatter\n\n\n(* Deprecated : subsumed by get_formatter_out_functions *)\nlet get_all_formatter_output_functions =\n pp_get_all_formatter_output_functions std_formatter\n\n\n(* Deprecated : error prone function, do not use it.\n This function is neither compositional nor incremental, since it flushes\n the pretty-printer queue at each call.\n To get the same functionality, define a formatter of your own writing to\n the buffer argument, as in\n let ppf = formatter_of_buffer b\n then use {!fprintf ppf} as usual. *)\nlet bprintf b (Format (fmt, _) : ('a, formatter, unit) format) =\n let ppf = formatter_of_buffer b in\n let k acc = output_acc ppf acc; pp_flush_queue ppf false in\n make_printf k End_of_acc fmt\n\n\n(* Deprecated : alias for ksprintf. *)\nlet kprintf = ksprintf\n\n\n\n(* Deprecated tag functions *)\n\ntype formatter_tag_functions = {\n mark_open_tag : tag -> string;\n mark_close_tag : tag -> string;\n print_open_tag : tag -> unit;\n print_close_tag : tag -> unit;\n}\n\n\nlet pp_set_formatter_tag_functions state {\n mark_open_tag = mot;\n mark_close_tag = mct;\n print_open_tag = pot;\n print_close_tag = pct;\n } =\n let stringify f e = function String_tag s -> f s | _ -> e in\n state.pp_mark_open_tag <- stringify mot \"\";\n state.pp_mark_close_tag <- stringify mct \"\";\n state.pp_print_open_tag <- stringify pot ();\n state.pp_print_close_tag <- stringify pct ()\n\nlet pp_get_formatter_tag_functions fmt () =\n let funs = pp_get_formatter_stag_functions fmt () in\n let mark_open_tag s = funs.mark_open_stag (String_tag s) in\n let mark_close_tag s = funs.mark_close_stag (String_tag s) in\n let print_open_tag s = funs.print_open_stag (String_tag s) in\n let print_close_tag s = funs.print_close_stag (String_tag s) in\n {mark_open_tag; mark_close_tag; print_open_tag; print_close_tag}\n\nlet set_formatter_tag_functions =\n pp_set_formatter_tag_functions std_formatter\nand get_formatter_tag_functions =\n pp_get_formatter_tag_functions std_formatter\n","(** Very small tooling for format printers. *)\n\ninclude Format\n\ntype 'a t = Format.formatter -> 'a -> unit\n\n(* Only in the stdlib since 4.02, so we copy. *)\nlet rec list ?(pp_sep = pp_print_cut) pp ppf = function\n | [] -> ()\n | [v] -> pp ppf v\n | v :: vs ->\n pp ppf v;\n pp_sep ppf ();\n list ~pp_sep pp ppf vs\n\n(* want this name to make sure we don't use pp_print_list from stdlib\n accidentally *)\nlet pp_print_list = list\n\nlet str = pp_print_string\nlet sexp fmt s pp x = fprintf fmt \"@[<3>(%s@ %a)@]\" s pp x\nlet pair pp1 pp2 fmt (v1,v2) =\n pp1 fmt v1; pp_print_space fmt () ; pp2 fmt v2\nlet triple pp1 pp2 pp3 fmt (v1, v2, v3) =\n pp1 fmt v1; pp_print_space fmt () ;\n pp2 fmt v2; pp_print_space fmt () ;\n pp3 fmt v3\nlet int = pp_print_int\nlet optint fmt = function\n | None -> ()\n | Some i -> fprintf fmt \"@ %d\" i\n\nlet quote fmt s = Format.fprintf fmt \"\\\"%s\\\"\" s\n\nlet pp_olist pp_elem fmt =\n Format.fprintf fmt \"@[<3>[@ %a@ ]@]\"\n (pp_print_list\n ~pp_sep:(fun fmt () -> fprintf fmt \";@ \")\n pp_elem)\n\nlet pp_str_list = pp_olist quote\n\nlet to_to_string pp x =\n let b = Buffer.create 16 in\n let fmt = Format.formatter_of_buffer b in\n pp fmt x;\n Buffer.contents b\n","\nmodule Pmark = struct\n type t = int\n let equal (x : int) (y : int) = x = y\n let compare (x : int) (y : int) = compare x y\n let r = ref 0\n let gen () = incr r ; !r\n\n let pp = Format.pp_print_int\nend\n\ninclude Pmark\nmodule Set = Set.Make(Pmark)\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Pierre Weis, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 2002 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nopen CamlinternalFormatBasics\nopen CamlinternalFormat\n\n(* alias to avoid warning for ambiguity between\n Stdlib.format6\n and CamlinternalFormatBasics.format6\n\n (the former is in fact an alias for the latter,\n but the ambiguity warning doesn't care)\n*)\ntype ('a, 'b, 'c, 'd, 'e, 'f) format6 =\n ('a, 'b, 'c, 'd, 'e, 'f) Stdlib.format6\n\n\n(* The run-time library for scanners. *)\n\n(* Scanning buffers. *)\nmodule type SCANNING = sig\n\n type in_channel\n\n type scanbuf = in_channel\n\n type file_name = string\n\n val stdin : in_channel\n (* The scanning buffer reading from [Stdlib.stdin].\n [stdib] is equivalent to [Scanning.from_channel Stdlib.stdin]. *)\n\n val stdib : in_channel\n (* An alias for [Scanf.stdin], the scanning buffer reading from\n [Stdlib.stdin]. *)\n\n val next_char : scanbuf -> char\n (* [Scanning.next_char ib] advance the scanning buffer for\n one character.\n If no more character can be read, sets a end of file condition and\n returns '\\000'. *)\n\n val invalidate_current_char : scanbuf -> unit\n (* [Scanning.invalidate_current_char ib] mark the current_char as already\n scanned. *)\n\n val peek_char : scanbuf -> char\n (* [Scanning.peek_char ib] returns the current char available in\n the buffer or reads one if necessary (when the current character is\n already scanned).\n If no character can be read, sets an end of file condition and\n returns '\\000'. *)\n\n val checked_peek_char : scanbuf -> char\n (* Same as [Scanning.peek_char] above but always returns a valid char or\n fails: instead of returning a null char when the reading method of the\n input buffer has reached an end of file, the function raises exception\n [End_of_file]. *)\n\n val store_char : int -> scanbuf -> char -> int\n (* [Scanning.store_char lim ib c] adds [c] to the token buffer\n of the scanning buffer [ib]. It also advances the scanning buffer for\n one character and returns [lim - 1], indicating the new limit for the\n length of the current token. *)\n\n val skip_char : int -> scanbuf -> int\n (* [Scanning.skip_char lim ib] ignores the current character. *)\n\n val ignore_char : int -> scanbuf -> int\n (* [Scanning.ignore_char ib lim] ignores the current character and\n decrements the limit. *)\n\n val token : scanbuf -> string\n (* [Scanning.token ib] returns the string stored into the token\n buffer of the scanning buffer: it returns the token matched by the\n format. *)\n\n val reset_token : scanbuf -> unit\n (* [Scanning.reset_token ib] resets the token buffer of\n the given scanning buffer. *)\n\n val char_count : scanbuf -> int\n (* [Scanning.char_count ib] returns the number of characters\n read so far from the given buffer. *)\n\n val line_count : scanbuf -> int\n (* [Scanning.line_count ib] returns the number of new line\n characters read so far from the given buffer. *)\n\n val token_count : scanbuf -> int\n (* [Scanning.token_count ib] returns the number of tokens read\n so far from [ib]. *)\n\n val eof : scanbuf -> bool\n (* [Scanning.eof ib] returns the end of input condition\n of the given buffer. *)\n\n val end_of_input : scanbuf -> bool\n (* [Scanning.end_of_input ib] tests the end of input condition\n of the given buffer (if no char has ever been read, an attempt to\n read one is performed). *)\n\n val beginning_of_input : scanbuf -> bool\n (* [Scanning.beginning_of_input ib] tests the beginning of input\n condition of the given buffer. *)\n\n val name_of_input : scanbuf -> string\n (* [Scanning.name_of_input ib] returns the name of the character\n source for input buffer [ib]. *)\n\n val open_in : file_name -> in_channel\n val open_in_bin : file_name -> in_channel\n val from_file : file_name -> in_channel\n val from_file_bin : file_name -> in_channel\n val from_string : string -> in_channel\n val from_function : (unit -> char) -> in_channel\n val from_channel : Stdlib.in_channel -> in_channel\n\n val close_in : in_channel -> unit\n\n val memo_from_channel : Stdlib.in_channel -> in_channel\n (* Obsolete. *)\n\nend\n\n\nmodule Scanning : SCANNING = struct\n\n (* The run-time library for scanf. *)\n\n type file_name = string\n\n type in_channel_name =\n | From_channel of Stdlib.in_channel\n | From_file of file_name * Stdlib.in_channel\n | From_function\n | From_string\n\n\n type in_channel = {\n mutable ic_eof : bool;\n mutable ic_current_char : char;\n mutable ic_current_char_is_valid : bool;\n mutable ic_char_count : int;\n mutable ic_line_count : int;\n mutable ic_token_count : int;\n ic_get_next_char : unit -> char;\n ic_token_buffer : Buffer.t;\n ic_input_name : in_channel_name;\n }\n\n\n type scanbuf = in_channel\n\n let null_char = '\\000'\n\n (* Reads a new character from input buffer.\n Next_char never fails, even in case of end of input:\n it then simply sets the end of file condition. *)\n let next_char ib =\n try\n let c = ib.ic_get_next_char () in\n ib.ic_current_char <- c;\n ib.ic_current_char_is_valid <- true;\n ib.ic_char_count <- succ ib.ic_char_count;\n if c = '\\n' then ib.ic_line_count <- succ ib.ic_line_count;\n c with\n | End_of_file ->\n let c = null_char in\n ib.ic_current_char <- c;\n ib.ic_current_char_is_valid <- false;\n ib.ic_eof <- true;\n c\n\n\n let peek_char ib =\n if ib.ic_current_char_is_valid\n then ib.ic_current_char\n else next_char ib\n\n\n (* Returns a valid current char for the input buffer. In particular\n no irrelevant null character (as set by [next_char] in case of end\n of input) is returned, since [End_of_file] is raised when\n [next_char] sets the end of file condition while trying to read a\n new character. *)\n let checked_peek_char ib =\n let c = peek_char ib in\n if ib.ic_eof then raise End_of_file;\n c\n\n\n let end_of_input ib =\n ignore (peek_char ib);\n ib.ic_eof\n\n\n let eof ib = ib.ic_eof\n\n let beginning_of_input ib = ib.ic_char_count = 0\n\n let name_of_input ib =\n match ib.ic_input_name with\n | From_channel _ic -> \"unnamed Stdlib input channel\"\n | From_file (fname, _ic) -> fname\n | From_function -> \"unnamed function\"\n | From_string -> \"unnamed character string\"\n\n\n let char_count ib =\n if ib.ic_current_char_is_valid\n then ib.ic_char_count - 1\n else ib.ic_char_count\n\n\n let line_count ib = ib.ic_line_count\n\n let reset_token ib = Buffer.reset ib.ic_token_buffer\n\n let invalidate_current_char ib = ib.ic_current_char_is_valid <- false\n\n let token ib =\n let token_buffer = ib.ic_token_buffer in\n let tok = Buffer.contents token_buffer in\n Buffer.clear token_buffer;\n ib.ic_token_count <- succ ib.ic_token_count;\n tok\n\n\n let token_count ib = ib.ic_token_count\n\n let skip_char width ib =\n invalidate_current_char ib;\n width\n\n\n let ignore_char width ib = skip_char (width - 1) ib\n\n let store_char width ib c =\n Buffer.add_char ib.ic_token_buffer c;\n ignore_char width ib\n\n\n let default_token_buffer_size = 1024\n\n let create iname next = {\n ic_eof = false;\n ic_current_char = null_char;\n ic_current_char_is_valid = false;\n ic_char_count = 0;\n ic_line_count = 0;\n ic_token_count = 0;\n ic_get_next_char = next;\n ic_token_buffer = Buffer.create default_token_buffer_size;\n ic_input_name = iname;\n }\n\n\n let from_string s =\n let i = ref 0 in\n let len = String.length s in\n let next () =\n if !i >= len then raise End_of_file else\n let c = s.[!i] in\n incr i;\n c in\n create From_string next\n\n\n let from_function = create From_function\n\n (* Scanning from an input channel. *)\n\n (* Position of the problem:\n\n We cannot prevent the scanning mechanism to use one lookahead character,\n if needed by the semantics of the format string specifications (e.g. a\n trailing 'skip space' specification in the format string); in this case,\n the mandatory lookahead character is indeed read from the input and not\n used to return the token read. It is thus mandatory to be able to store\n an unused lookahead character somewhere to get it as the first character\n of the next scan.\n\n To circumvent this problem, all the scanning functions get a low level\n input buffer argument where they store the lookahead character when\n needed; additionally, the input buffer is the only source of character of\n a scanner. The [scanbuf] input buffers are defined in module {!Scanning}.\n\n Now we understand that it is extremely important that related and\n successive calls to scanners indeed read from the same input buffer.\n In effect, if a scanner [scan1] is reading from [ib1] and stores an\n unused lookahead character [c1] into its input buffer [ib1], then\n another scanner [scan2] not reading from the same buffer [ib1] will miss\n the character [c1], seemingly vanished in the air from the point of view\n of [scan2].\n\n This mechanism works perfectly to read from strings, from files, and from\n functions, since in those cases, allocating two buffers reading from the\n same source is unnatural.\n\n Still, there is a difficulty in the case of scanning from an input\n channel. In effect, when scanning from an input channel [ic], this channel\n may not have been allocated from within this library. Hence, it may be\n shared (two functions of the user's program may successively read from\n [ic]). This is highly error prone since, one of the function may seek the\n input channel, while the other function has still an unused lookahead\n character in its input buffer. In conclusion, you should never mix direct\n low level reading and high level scanning from the same input channel.\n\n *)\n\n (* Perform bufferized input to improve efficiency. *)\n let file_buffer_size = ref 1024\n\n (* The scanner closes the input channel at end of input. *)\n let scan_close_at_end ic = Stdlib.close_in ic; raise End_of_file\n\n (* The scanner does not close the input channel at end of input:\n it just raises [End_of_file]. *)\n let scan_raise_at_end _ic = raise End_of_file\n\n let from_ic scan_close_ic iname ic =\n let len = !file_buffer_size in\n let buf = Bytes.create len in\n let i = ref 0 in\n let lim = ref 0 in\n let eof = ref false in\n let next () =\n if !i < !lim then begin let c = Bytes.get buf !i in incr i; c end else\n if !eof then raise End_of_file else begin\n lim := input ic buf 0 len;\n if !lim = 0 then begin eof := true; scan_close_ic ic end else begin\n i := 1;\n Bytes.get buf 0\n end\n end in\n create iname next\n\n\n let from_ic_close_at_end = from_ic scan_close_at_end\n let from_ic_raise_at_end = from_ic scan_raise_at_end\n\n (* The scanning buffer reading from [Stdlib.stdin].\n One could try to define [stdib] as a scanning buffer reading a character\n at a time (no bufferization at all), but unfortunately the top-level\n interaction would be wrong. This is due to some kind of\n 'race condition' when reading from [Stdlib.stdin],\n since the interactive compiler and [Scanf.scanf] will simultaneously\n read the material they need from [Stdlib.stdin]; then, confusion\n will result from what should be read by the top-level and what should be\n read by [Scanf.scanf].\n This is even more complicated by the one character lookahead that\n [Scanf.scanf] is sometimes obliged to maintain: the lookahead character\n will be available for the next [Scanf.scanf] entry, seemingly coming from\n nowhere.\n Also no [End_of_file] is raised when reading from stdin: if not enough\n characters have been read, we simply ask to read more. *)\n let stdin =\n from_ic scan_raise_at_end\n (From_file (\"-\", Stdlib.stdin)) Stdlib.stdin\n\n\n let stdib = stdin\n\n let open_in_file open_in fname =\n match fname with\n | \"-\" -> stdin\n | fname ->\n let ic = open_in fname in\n from_ic_close_at_end (From_file (fname, ic)) ic\n\n\n let open_in = open_in_file Stdlib.open_in\n let open_in_bin = open_in_file Stdlib.open_in_bin\n\n let from_file = open_in\n let from_file_bin = open_in_bin\n\n let from_channel ic =\n from_ic_raise_at_end (From_channel ic) ic\n\n\n let close_in ib =\n match ib.ic_input_name with\n | From_channel ic ->\n Stdlib.close_in ic\n | From_file (_fname, ic) -> Stdlib.close_in ic\n | From_function | From_string -> ()\n\n\n (*\n Obsolete: a memo [from_channel] version to build a [Scanning.in_channel]\n scanning buffer out of a [Stdlib.in_channel].\n This function was used to try to preserve the scanning\n semantics for the (now obsolete) function [fscanf].\n Given that all scanner must read from a [Scanning.in_channel] scanning\n buffer, [fscanf] must read from one!\n More precisely, given [ic], all successive calls [fscanf ic] must read\n from the same scanning buffer.\n This obliged this library to allocated scanning buffers that were\n not properly garbage collectable, hence leading to memory leaks.\n If you need to read from a [Stdlib.in_channel] input channel\n [ic], simply define a [Scanning.in_channel] formatted input channel as in\n [let ib = Scanning.from_channel ic], then use [Scanf.bscanf ib] as usual.\n *)\n let memo_from_ic =\n let memo = ref [] in\n (fun scan_close_ic ic ->\n try List.assq ic !memo with\n | Not_found ->\n let ib =\n from_ic scan_close_ic (From_channel ic) ic in\n memo := (ic, ib) :: !memo;\n ib)\n\n\n (* Obsolete: see {!memo_from_ic} above. *)\n let memo_from_channel = memo_from_ic scan_raise_at_end\n\nend\n\n\n(* Formatted input functions. *)\n\ntype ('a, 'b, 'c, 'd) scanner =\n ('a, Scanning.in_channel, 'b, 'c, 'a -> 'd, 'd) format6 -> 'c\n\n\n(* Reporting errors. *)\nexception Scan_failure of string\n\nlet bad_input s = raise (Scan_failure s)\n\nlet bad_input_escape c =\n bad_input (Printf.sprintf \"illegal escape character %C\" c)\n\n\nlet bad_token_length message =\n bad_input\n (Printf.sprintf\n \"scanning of %s failed: \\\n the specified length was too short for token\"\n message)\n\n\nlet bad_end_of_input message =\n bad_input\n (Printf.sprintf\n \"scanning of %s failed: \\\n premature end of file occurred before end of token\"\n message)\n\n\nlet bad_float () =\n bad_input \"no dot or exponent part found in float token\"\n\n\nlet bad_hex_float () =\n bad_input \"not a valid float in hexadecimal notation\"\n\n\nlet character_mismatch_err c ci =\n Printf.sprintf \"looking for %C, found %C\" c ci\n\n\nlet character_mismatch c ci =\n bad_input (character_mismatch_err c ci)\n\n\nlet rec skip_whites ib =\n let c = Scanning.peek_char ib in\n if not (Scanning.eof ib) then begin\n match c with\n | ' ' | '\\t' | '\\n' | '\\r' ->\n Scanning.invalidate_current_char ib; skip_whites ib\n | _ -> ()\n end\n\n\n(* Checking that [c] is indeed in the input, then skips it.\n In this case, the character [c] has been explicitly specified in the\n format as being mandatory in the input; hence we should fail with\n [End_of_file] in case of end_of_input.\n (Remember that [Scan_failure] is raised only when (we can prove by\n evidence) that the input does not match the format string given. We must\n thus differentiate [End_of_file] as an error due to lack of input, and\n [Scan_failure] which is due to provably wrong input. I am not sure this is\n worth the burden: it is complex and somehow subliminal; should be clearer\n to fail with Scan_failure \"Not enough input to complete scanning\"!)\n\n That's why, waiting for a better solution, we use checked_peek_char here.\n We are also careful to treat \"\\r\\n\" in the input as an end of line marker:\n it always matches a '\\n' specification in the input format string. *)\nlet rec check_char ib c =\n match c with\n | ' ' -> skip_whites ib\n | '\\n' -> check_newline ib\n | c -> check_this_char ib c\n\nand check_this_char ib c =\n let ci = Scanning.checked_peek_char ib in\n if ci = c then Scanning.invalidate_current_char ib else\n character_mismatch c ci\n\nand check_newline ib =\n let ci = Scanning.checked_peek_char ib in\n match ci with\n | '\\n' -> Scanning.invalidate_current_char ib\n | '\\r' -> Scanning.invalidate_current_char ib; check_this_char ib '\\n'\n | _ -> character_mismatch '\\n' ci\n\n\n(* Extracting tokens from the output token buffer. *)\n\nlet token_char ib = (Scanning.token ib).[0]\n\nlet token_string = Scanning.token\n\nlet token_bool ib =\n match Scanning.token ib with\n | \"true\" -> true\n | \"false\" -> false\n | s -> bad_input (Printf.sprintf \"invalid boolean '%s'\" s)\n\n\n(* The type of integer conversions. *)\ntype integer_conversion =\n | B_conversion (* Unsigned binary conversion *)\n | D_conversion (* Signed decimal conversion *)\n | I_conversion (* Signed integer conversion *)\n | O_conversion (* Unsigned octal conversion *)\n | U_conversion (* Unsigned decimal conversion *)\n | X_conversion (* Unsigned hexadecimal conversion *)\n\n\nlet integer_conversion_of_char = function\n | 'b' -> B_conversion\n | 'd' -> D_conversion\n | 'i' -> I_conversion\n | 'o' -> O_conversion\n | 'u' -> U_conversion\n | 'x' | 'X' -> X_conversion\n | _ -> assert false\n\n\n(* Extract an integer literal token.\n Since the functions Stdlib.*int*_of_string do not accept a leading +,\n we skip it if necessary. *)\nlet token_int_literal conv ib =\n let tok =\n match conv with\n | D_conversion | I_conversion -> Scanning.token ib\n | U_conversion -> \"0u\" ^ Scanning.token ib\n | O_conversion -> \"0o\" ^ Scanning.token ib\n | X_conversion -> \"0x\" ^ Scanning.token ib\n | B_conversion -> \"0b\" ^ Scanning.token ib in\n let l = String.length tok in\n if l = 0 || tok.[0] <> '+' then tok else String.sub tok 1 (l - 1)\n\n\n(* All the functions that convert a string to a number raise the exception\n Failure when the conversion is not possible.\n This exception is then trapped in [kscanf]. *)\nlet token_int conv ib = int_of_string (token_int_literal conv ib)\n\nlet token_float ib = float_of_string (Scanning.token ib)\n\n(* To scan native ints, int32 and int64 integers.\n We cannot access to conversions to/from strings for those types,\n Nativeint.of_string, Int32.of_string, and Int64.of_string,\n since those modules are not available to [Scanf].\n However, we can bind and use the corresponding primitives that are\n available in the runtime. *)\nexternal nativeint_of_string : string -> nativeint\n = \"caml_nativeint_of_string\"\n\nexternal int32_of_string : string -> int32\n = \"caml_int32_of_string\"\n\nexternal int64_of_string : string -> int64\n = \"caml_int64_of_string\"\n\n\nlet token_nativeint conv ib = nativeint_of_string (token_int_literal conv ib)\nlet token_int32 conv ib = int32_of_string (token_int_literal conv ib)\nlet token_int64 conv ib = int64_of_string (token_int_literal conv ib)\n\n(* Scanning numbers. *)\n\n(* Digits scanning functions suppose that one character has been checked and\n is available, since they return at end of file with the currently found\n token selected.\n\n Put it in another way, the digits scanning functions scan for a possibly\n empty sequence of digits, (hence, a successful scanning from one of those\n functions does not imply that the token is a well-formed number: to get a\n true number, it is mandatory to check that at least one valid digit is\n available before calling one of the digit scanning functions). *)\n\n(* The decimal case is treated especially for optimization purposes. *)\nlet rec scan_decimal_digit_star width ib =\n if width = 0 then width else\n let c = Scanning.peek_char ib in\n if Scanning.eof ib then width else\n match c with\n | '0' .. '9' as c ->\n let width = Scanning.store_char width ib c in\n scan_decimal_digit_star width ib\n | '_' ->\n let width = Scanning.ignore_char width ib in\n scan_decimal_digit_star width ib\n | _ -> width\n\n\nlet scan_decimal_digit_plus width ib =\n if width = 0 then bad_token_length \"decimal digits\" else\n let c = Scanning.checked_peek_char ib in\n match c with\n | '0' .. '9' ->\n let width = Scanning.store_char width ib c in\n scan_decimal_digit_star width ib\n | c ->\n bad_input (Printf.sprintf \"character %C is not a decimal digit\" c)\n\n\n(* To scan numbers from other bases, we use a predicate argument to\n scan digits. *)\nlet scan_digit_star digitp width ib =\n let rec scan_digits width ib =\n if width = 0 then width else\n let c = Scanning.peek_char ib in\n if Scanning.eof ib then width else\n match c with\n | c when digitp c ->\n let width = Scanning.store_char width ib c in\n scan_digits width ib\n | '_' ->\n let width = Scanning.ignore_char width ib in\n scan_digits width ib\n | _ -> width in\n scan_digits width ib\n\n\nlet scan_digit_plus basis digitp width ib =\n (* Ensure we have got enough width left,\n and read at least one digit. *)\n if width = 0 then bad_token_length \"digits\" else\n let c = Scanning.checked_peek_char ib in\n if digitp c then\n let width = Scanning.store_char width ib c in\n scan_digit_star digitp width ib\n else\n bad_input (Printf.sprintf \"character %C is not a valid %s digit\" c basis)\n\n\nlet is_binary_digit = function\n | '0' .. '1' -> true\n | _ -> false\n\n\nlet scan_binary_int = scan_digit_plus \"binary\" is_binary_digit\n\nlet is_octal_digit = function\n | '0' .. '7' -> true\n | _ -> false\n\n\nlet scan_octal_int = scan_digit_plus \"octal\" is_octal_digit\n\nlet is_hexa_digit = function\n | '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' -> true\n | _ -> false\n\n\nlet scan_hexadecimal_int = scan_digit_plus \"hexadecimal\" is_hexa_digit\n\n(* Scan a decimal integer. *)\nlet scan_unsigned_decimal_int = scan_decimal_digit_plus\n\nlet scan_sign width ib =\n let c = Scanning.checked_peek_char ib in\n match c with\n | '+' -> Scanning.store_char width ib c\n | '-' -> Scanning.store_char width ib c\n | _ -> width\n\n\nlet scan_optionally_signed_decimal_int width ib =\n let width = scan_sign width ib in\n scan_unsigned_decimal_int width ib\n\n\n(* Scan an unsigned integer that could be given in any (common) basis.\n If digits are prefixed by one of 0x, 0X, 0o, or 0b, the number is\n assumed to be written respectively in hexadecimal, hexadecimal,\n octal, or binary. *)\nlet scan_unsigned_int width ib =\n match Scanning.checked_peek_char ib with\n | '0' as c ->\n let width = Scanning.store_char width ib c in\n if width = 0 then width else\n let c = Scanning.peek_char ib in\n if Scanning.eof ib then width else\n begin match c with\n | 'x' | 'X' -> scan_hexadecimal_int (Scanning.store_char width ib c) ib\n | 'o' -> scan_octal_int (Scanning.store_char width ib c) ib\n | 'b' -> scan_binary_int (Scanning.store_char width ib c) ib\n | _ -> scan_decimal_digit_star width ib end\n | _ -> scan_unsigned_decimal_int width ib\n\n\nlet scan_optionally_signed_int width ib =\n let width = scan_sign width ib in\n scan_unsigned_int width ib\n\n\nlet scan_int_conversion conv width ib =\n match conv with\n | B_conversion -> scan_binary_int width ib\n | D_conversion -> scan_optionally_signed_decimal_int width ib\n | I_conversion -> scan_optionally_signed_int width ib\n | O_conversion -> scan_octal_int width ib\n | U_conversion -> scan_unsigned_decimal_int width ib\n | X_conversion -> scan_hexadecimal_int width ib\n\n\n(* Scanning floating point numbers. *)\n\n(* Fractional part is optional and can be reduced to 0 digits. *)\nlet scan_fractional_part width ib =\n if width = 0 then width else\n let c = Scanning.peek_char ib in\n if Scanning.eof ib then width else\n match c with\n | '0' .. '9' as c ->\n scan_decimal_digit_star (Scanning.store_char width ib c) ib\n | _ -> width\n\n\n(* Exp part is optional and can be reduced to 0 digits. *)\nlet scan_exponent_part width ib =\n if width = 0 then width else\n let c = Scanning.peek_char ib in\n if Scanning.eof ib then width else\n match c with\n | 'e' | 'E' as c ->\n scan_optionally_signed_decimal_int (Scanning.store_char width ib c) ib\n | _ -> width\n\n\n(* Scan the integer part of a floating point number, (not using the\n OCaml lexical convention since the integer part can be empty):\n an optional sign, followed by a possibly empty sequence of decimal\n digits (e.g. -.1). *)\nlet scan_integer_part width ib =\n let width = scan_sign width ib in\n scan_decimal_digit_star width ib\n\n\n(*\n For the time being we have (as found in scanf.mli):\n the field width is composed of an optional integer literal\n indicating the maximal width of the token to read.\n Unfortunately, the type-checker let the user write an optional precision,\n since this is valid for printf format strings.\n\n Thus, the next step for Scanf is to support a full width and precision\n indication, more or less similar to the one for printf, possibly extended\n to the specification of a [max, min] range for the width of the token read\n for strings. Something like the following spec for scanf.mli:\n\n The optional [width] is an integer indicating the maximal\n width of the token read. For instance, [%6d] reads an integer,\n having at most 6 characters.\n\n The optional [precision] is a dot [.] followed by an integer:\n\n - in the floating point number conversions ([%f], [%e], [%g], [%F], [%E],\n and [%F] conversions, the [precision] indicates the maximum number of\n digits that may follow the decimal point. For instance, [%.4f] reads a\n [float] with at most 4 fractional digits,\n\n - in the string conversions ([%s], [%S], [%\\[ range \\]]), and in the\n integer number conversions ([%i], [%d], [%u], [%x], [%o], and their\n [int32], [int64], and [native_int] correspondent), the [precision]\n indicates the required minimum width of the token read,\n\n - on all other conversions, the width and precision specify the [max, min]\n range for the width of the token read.\n*)\nlet scan_float width precision ib =\n let width = scan_integer_part width ib in\n if width = 0 then width, precision else\n let c = Scanning.peek_char ib in\n if Scanning.eof ib then width, precision else\n match c with\n | '.' ->\n let width = Scanning.store_char width ib c in\n let precision = Int.min width precision in\n let width = width - (precision - scan_fractional_part precision ib) in\n scan_exponent_part width ib, precision\n | _ ->\n scan_exponent_part width ib, precision\n\n\nlet check_case_insensitive_string width ib error str =\n let lowercase c =\n match c with\n | 'A' .. 'Z' ->\n char_of_int (int_of_char c - int_of_char 'A' + int_of_char 'a')\n | _ -> c in\n let len = String.length str in\n let width = ref width in\n for i = 0 to len - 1 do\n let c = Scanning.peek_char ib in\n if lowercase c <> lowercase str.[i] then error ();\n if !width = 0 then error ();\n width := Scanning.store_char !width ib c;\n done;\n !width\n\n\nlet scan_hex_float width precision ib =\n if width = 0 || Scanning.end_of_input ib then bad_hex_float ();\n let width = scan_sign width ib in\n if width = 0 || Scanning.end_of_input ib then bad_hex_float ();\n match Scanning.peek_char ib with\n | '0' as c -> (\n let width = Scanning.store_char width ib c in\n if width = 0 || Scanning.end_of_input ib then bad_hex_float ();\n let width = check_case_insensitive_string width ib bad_hex_float \"x\" in\n if width = 0 || Scanning.end_of_input ib then width else\n let width = match Scanning.peek_char ib with\n | '.' | 'p' | 'P' -> width\n | _ -> scan_hexadecimal_int width ib in\n if width = 0 || Scanning.end_of_input ib then width else\n let width = match Scanning.peek_char ib with\n | '.' as c -> (\n let width = Scanning.store_char width ib c in\n if width = 0 || Scanning.end_of_input ib then width else\n match Scanning.peek_char ib with\n | 'p' | 'P' -> width\n | _ ->\n let precision = Int.min width precision in\n width - (precision - scan_hexadecimal_int precision ib)\n )\n | _ -> width in\n if width = 0 || Scanning.end_of_input ib then width else\n match Scanning.peek_char ib with\n | 'p' | 'P' as c ->\n let width = Scanning.store_char width ib c in\n if width = 0 || Scanning.end_of_input ib then bad_hex_float ();\n scan_optionally_signed_decimal_int width ib\n | _ -> width\n )\n | 'n' | 'N' as c ->\n let width = Scanning.store_char width ib c in\n if width = 0 || Scanning.end_of_input ib then bad_hex_float ();\n check_case_insensitive_string width ib bad_hex_float \"an\"\n | 'i' | 'I' as c ->\n let width = Scanning.store_char width ib c in\n if width = 0 || Scanning.end_of_input ib then bad_hex_float ();\n check_case_insensitive_string width ib bad_hex_float \"nfinity\"\n | _ -> bad_hex_float ()\n\n\nlet scan_caml_float_rest width precision ib =\n if width = 0 || Scanning.end_of_input ib then bad_float ();\n let width = scan_decimal_digit_star width ib in\n if width = 0 || Scanning.end_of_input ib then bad_float ();\n let c = Scanning.peek_char ib in\n match c with\n | '.' ->\n let width = Scanning.store_char width ib c in\n (* The effective width available for scanning the fractional part is\n the minimum of declared precision and width left. *)\n let precision = Int.min width precision in\n (* After scanning the fractional part with [precision] provisional width,\n [width_precision] is left. *)\n let width_precision = scan_fractional_part precision ib in\n (* Hence, scanning the fractional part took exactly\n [precision - width_precision] chars. *)\n let frac_width = precision - width_precision in\n (* And new provisional width is [width - width_precision. *)\n let width = width - frac_width in\n scan_exponent_part width ib\n | 'e' | 'E' ->\n scan_exponent_part width ib\n | _ -> bad_float ()\n\n\nlet scan_caml_float width precision ib =\n if width = 0 || Scanning.end_of_input ib then bad_float ();\n let width = scan_sign width ib in\n if width = 0 || Scanning.end_of_input ib then bad_float ();\n match Scanning.peek_char ib with\n | '0' as c -> (\n let width = Scanning.store_char width ib c in\n if width = 0 || Scanning.end_of_input ib then bad_float ();\n match Scanning.peek_char ib with\n | 'x' | 'X' as c -> (\n let width = Scanning.store_char width ib c in\n if width = 0 || Scanning.end_of_input ib then bad_float ();\n let width = scan_hexadecimal_int width ib in\n if width = 0 || Scanning.end_of_input ib then bad_float ();\n let width = match Scanning.peek_char ib with\n | '.' as c -> (\n let width = Scanning.store_char width ib c in\n if width = 0 || Scanning.end_of_input ib then width else\n match Scanning.peek_char ib with\n | 'p' | 'P' -> width\n | _ ->\n let precision = Int.min width precision in\n width - (precision - scan_hexadecimal_int precision ib)\n )\n | 'p' | 'P' -> width\n | _ -> bad_float () in\n if width = 0 || Scanning.end_of_input ib then width else\n match Scanning.peek_char ib with\n | 'p' | 'P' as c ->\n let width = Scanning.store_char width ib c in\n if width = 0 || Scanning.end_of_input ib then bad_hex_float ();\n scan_optionally_signed_decimal_int width ib\n | _ -> width\n )\n | _ ->\n scan_caml_float_rest width precision ib\n )\n | '1' .. '9' as c ->\n let width = Scanning.store_char width ib c in\n if width = 0 || Scanning.end_of_input ib then bad_float ();\n scan_caml_float_rest width precision ib\n(* Special case of nan and infinity:\n | 'i' ->\n | 'n' ->\n*)\n | _ -> bad_float ()\n\n\n(* Scan a regular string:\n stops when encountering a space, if no scanning indication has been given;\n otherwise, stops when encountering the characters in the scanning\n indication [stp].\n It also stops at end of file or when the maximum number of characters has\n been read. *)\nlet scan_string stp width ib =\n let rec loop width =\n if width = 0 then width else\n let c = Scanning.peek_char ib in\n if Scanning.eof ib then width else\n match stp with\n | Some c' when c = c' -> Scanning.skip_char width ib\n | Some _ -> loop (Scanning.store_char width ib c)\n | None ->\n match c with\n | ' ' | '\\t' | '\\n' | '\\r' -> width\n | _ -> loop (Scanning.store_char width ib c) in\n loop width\n\n\n(* Scan a char: peek strictly one character in the input, whatsoever. *)\nlet scan_char width ib =\n (* The case width = 0 could not happen here, since it is tested before\n calling scan_char, in the main scanning function.\n if width = 0 then bad_token_length \"a character\" else *)\n Scanning.store_char width ib (Scanning.checked_peek_char ib)\n\n\nlet char_for_backslash = function\n | 'n' -> '\\010'\n | 'r' -> '\\013'\n | 'b' -> '\\008'\n | 't' -> '\\009'\n | c -> c\n\n\n(* The integer value corresponding to the facial value of a valid\n decimal digit character. *)\nlet decimal_value_of_char c = int_of_char c - int_of_char '0'\n\nlet char_for_decimal_code c0 c1 c2 =\n let c =\n 100 * decimal_value_of_char c0 +\n 10 * decimal_value_of_char c1 +\n decimal_value_of_char c2 in\n if c < 0 || c > 255 then\n bad_input\n (Printf.sprintf\n \"bad character decimal encoding \\\\%c%c%c\" c0 c1 c2) else\n char_of_int c\n\n\n(* The integer value corresponding to the facial value of a valid\n hexadecimal digit character. *)\nlet hexadecimal_value_of_char c =\n let d = int_of_char c in\n (* Could also be:\n if d <= int_of_char '9' then d - int_of_char '0' else\n if d <= int_of_char 'F' then 10 + d - int_of_char 'A' else\n if d <= int_of_char 'f' then 10 + d - int_of_char 'a' else assert false\n *)\n if d >= int_of_char 'a' then\n d - 87 (* 10 + int_of_char c - int_of_char 'a' *) else\n if d >= int_of_char 'A' then\n d - 55 (* 10 + int_of_char c - int_of_char 'A' *) else\n d - int_of_char '0'\n\n\nlet char_for_hexadecimal_code c1 c2 =\n let c =\n 16 * hexadecimal_value_of_char c1 +\n hexadecimal_value_of_char c2 in\n if c < 0 || c > 255 then\n bad_input\n (Printf.sprintf \"bad character hexadecimal encoding \\\\%c%c\" c1 c2) else\n char_of_int c\n\n\n(* Called in particular when encountering '\\\\' as starter of a char.\n Stops before the corresponding '\\''. *)\nlet check_next_char message width ib =\n if width = 0 then bad_token_length message else\n let c = Scanning.peek_char ib in\n if Scanning.eof ib then bad_end_of_input message else\n c\n\n\nlet check_next_char_for_char = check_next_char \"a Char\"\nlet check_next_char_for_string = check_next_char \"a String\"\n\nlet scan_backslash_char width ib =\n match check_next_char_for_char width ib with\n | '\\\\' | '\\'' | '\\\"' | 'n' | 't' | 'b' | 'r' as c ->\n Scanning.store_char width ib (char_for_backslash c)\n | '0' .. '9' as c ->\n let get_digit () =\n let c = Scanning.next_char ib in\n match c with\n | '0' .. '9' as c -> c\n | c -> bad_input_escape c in\n let c0 = c in\n let c1 = get_digit () in\n let c2 = get_digit () in\n Scanning.store_char (width - 2) ib (char_for_decimal_code c0 c1 c2)\n | 'x' ->\n let get_digit () =\n let c = Scanning.next_char ib in\n match c with\n | '0' .. '9' | 'A' .. 'F' | 'a' .. 'f' as c -> c\n | c -> bad_input_escape c in\n let c1 = get_digit () in\n let c2 = get_digit () in\n Scanning.store_char (width - 2) ib (char_for_hexadecimal_code c1 c2)\n | c ->\n bad_input_escape c\n\n\n(* Scan a character (an OCaml token). *)\nlet scan_caml_char width ib =\n\n let rec find_start width =\n match Scanning.checked_peek_char ib with\n | '\\'' -> find_char (Scanning.ignore_char width ib)\n | c -> character_mismatch '\\'' c\n\n and find_char width =\n match check_next_char_for_char width ib with\n | '\\\\' ->\n find_stop (scan_backslash_char (Scanning.ignore_char width ib) ib)\n | c ->\n find_stop (Scanning.store_char width ib c)\n\n and find_stop width =\n match check_next_char_for_char width ib with\n | '\\'' -> Scanning.ignore_char width ib\n | c -> character_mismatch '\\'' c in\n\n find_start width\n\n\n(* Scan a delimited string (an OCaml token). *)\nlet scan_caml_string width ib =\n\n let rec find_start width =\n match Scanning.checked_peek_char ib with\n | '\\\"' -> find_stop (Scanning.ignore_char width ib)\n | c -> character_mismatch '\\\"' c\n\n and find_stop width =\n match check_next_char_for_string width ib with\n | '\\\"' -> Scanning.ignore_char width ib\n | '\\\\' -> scan_backslash (Scanning.ignore_char width ib)\n | c -> find_stop (Scanning.store_char width ib c)\n\n and scan_backslash width =\n match check_next_char_for_string width ib with\n | '\\r' -> skip_newline (Scanning.ignore_char width ib)\n | '\\n' -> skip_spaces (Scanning.ignore_char width ib)\n | _ -> find_stop (scan_backslash_char width ib)\n\n and skip_newline width =\n match check_next_char_for_string width ib with\n | '\\n' -> skip_spaces (Scanning.ignore_char width ib)\n | _ -> find_stop (Scanning.store_char width ib '\\r')\n\n and skip_spaces width =\n match check_next_char_for_string width ib with\n | ' ' -> skip_spaces (Scanning.ignore_char width ib)\n | _ -> find_stop width in\n\n find_start width\n\n\n(* Scan a boolean (an OCaml token). *)\nlet scan_bool ib =\n let c = Scanning.checked_peek_char ib in\n let m =\n match c with\n | 't' -> 4\n | 'f' -> 5\n | c ->\n bad_input\n (Printf.sprintf \"the character %C cannot start a boolean\" c) in\n scan_string None m ib\n\n\n(* Scan a string containing elements in char_set and terminated by scan_indic\n if provided. *)\nlet scan_chars_in_char_set char_set scan_indic width ib =\n let rec scan_chars i stp =\n let c = Scanning.peek_char ib in\n if i > 0 && not (Scanning.eof ib) &&\n is_in_char_set char_set c &&\n int_of_char c <> stp then\n let _ = Scanning.store_char max_int ib c in\n scan_chars (i - 1) stp in\n match scan_indic with\n | None -> scan_chars width (-1);\n | Some c ->\n scan_chars width (int_of_char c);\n if not (Scanning.eof ib) then\n let ci = Scanning.peek_char ib in\n if c = ci\n then Scanning.invalidate_current_char ib\n else character_mismatch c ci\n\n\n(* The global error report function for [Scanf]. *)\nlet scanf_bad_input ib = function\n | Scan_failure s | Failure s ->\n let i = Scanning.char_count ib in\n bad_input (Printf.sprintf \"scanf: bad input at char number %i: %s\" i s)\n | x -> raise x\n\n\n(* Get the content of a counter from an input buffer. *)\nlet get_counter ib counter =\n match counter with\n | Line_counter -> Scanning.line_count ib\n | Char_counter -> Scanning.char_count ib\n | Token_counter -> Scanning.token_count ib\n\n\n(* Compute the width of a padding option (see \"%42{\" and \"%123(\"). *)\nlet width_of_pad_opt pad_opt = match pad_opt with\n | None -> max_int\n | Some width -> width\n\n\nlet stopper_of_formatting_lit fmting =\n if fmting = Escaped_percent then '%', \"\" else\n let str = string_of_formatting_lit fmting in\n let stp = str.[1] in\n let sub_str = String.sub str 2 (String.length str - 2) in\n stp, sub_str\n\n\n(******************************************************************************)\n (* Reader management *)\n\n(* A call to take_format_readers on a format is evaluated into functions\n taking readers as arguments and aggregate them into an heterogeneous list *)\n(* When all readers are taken, finally pass the list of the readers to the\n continuation k. *)\nlet rec take_format_readers : type a c d e f .\n ((d, e) heter_list -> e) -> (a, Scanning.in_channel, c, d, e, f) fmt ->\n d =\nfun k fmt -> match fmt with\n | Reader fmt_rest ->\n fun reader ->\n let new_k readers_rest = k (Cons (reader, readers_rest)) in\n take_format_readers new_k fmt_rest\n | Char rest -> take_format_readers k rest\n | Caml_char rest -> take_format_readers k rest\n | String (_, rest) -> take_format_readers k rest\n | Caml_string (_, rest) -> take_format_readers k rest\n | Int (_, _, _, rest) -> take_format_readers k rest\n | Int32 (_, _, _, rest) -> take_format_readers k rest\n | Nativeint (_, _, _, rest) -> take_format_readers k rest\n | Int64 (_, _, _, rest) -> take_format_readers k rest\n | Float (_, _, _, rest) -> take_format_readers k rest\n | Bool (_, rest) -> take_format_readers k rest\n | Alpha rest -> take_format_readers k rest\n | Theta rest -> take_format_readers k rest\n | Flush rest -> take_format_readers k rest\n | String_literal (_, rest) -> take_format_readers k rest\n | Char_literal (_, rest) -> take_format_readers k rest\n | Custom (_, _, rest) -> take_format_readers k rest\n\n | Scan_char_set (_, _, rest) -> take_format_readers k rest\n | Scan_get_counter (_, rest) -> take_format_readers k rest\n | Scan_next_char rest -> take_format_readers k rest\n\n | Formatting_lit (_, rest) -> take_format_readers k rest\n | Formatting_gen (Open_tag (Format (fmt, _)), rest) ->\n take_format_readers k (concat_fmt fmt rest)\n | Formatting_gen (Open_box (Format (fmt, _)), rest) ->\n take_format_readers k (concat_fmt fmt rest)\n\n | Format_arg (_, _, rest) -> take_format_readers k rest\n | Format_subst (_, fmtty, rest) ->\n take_fmtty_format_readers k (erase_rel (symm fmtty)) rest\n | Ignored_param (ign, rest) -> take_ignored_format_readers k ign rest\n\n | End_of_format -> k Nil\n\n(* Take readers associated to an fmtty coming from a Format_subst \"%(...%)\". *)\nand take_fmtty_format_readers : type x y a c d e f .\n ((d, e) heter_list -> e) -> (a, Scanning.in_channel, c, d, x, y) fmtty ->\n (y, Scanning.in_channel, c, x, e, f) fmt -> d =\nfun k fmtty fmt -> match fmtty with\n | Reader_ty fmt_rest ->\n fun reader ->\n let new_k readers_rest = k (Cons (reader, readers_rest)) in\n take_fmtty_format_readers new_k fmt_rest fmt\n | Ignored_reader_ty fmt_rest ->\n fun reader ->\n let new_k readers_rest = k (Cons (reader, readers_rest)) in\n take_fmtty_format_readers new_k fmt_rest fmt\n | Char_ty rest -> take_fmtty_format_readers k rest fmt\n | String_ty rest -> take_fmtty_format_readers k rest fmt\n | Int_ty rest -> take_fmtty_format_readers k rest fmt\n | Int32_ty rest -> take_fmtty_format_readers k rest fmt\n | Nativeint_ty rest -> take_fmtty_format_readers k rest fmt\n | Int64_ty rest -> take_fmtty_format_readers k rest fmt\n | Float_ty rest -> take_fmtty_format_readers k rest fmt\n | Bool_ty rest -> take_fmtty_format_readers k rest fmt\n | Alpha_ty rest -> take_fmtty_format_readers k rest fmt\n | Theta_ty rest -> take_fmtty_format_readers k rest fmt\n | Any_ty rest -> take_fmtty_format_readers k rest fmt\n | Format_arg_ty (_, rest) -> take_fmtty_format_readers k rest fmt\n | End_of_fmtty -> take_format_readers k fmt\n | Format_subst_ty (ty1, ty2, rest) ->\n let ty = trans (symm ty1) ty2 in\n take_fmtty_format_readers k (concat_fmtty ty rest) fmt\n\n(* Take readers associated to an ignored parameter. *)\nand take_ignored_format_readers : type x y a c d e f .\n ((d, e) heter_list -> e) -> (a, Scanning.in_channel, c, d, x, y) ignored ->\n (y, Scanning.in_channel, c, x, e, f) fmt -> d =\nfun k ign fmt -> match ign with\n | Ignored_reader ->\n fun reader ->\n let new_k readers_rest = k (Cons (reader, readers_rest)) in\n take_format_readers new_k fmt\n | Ignored_char -> take_format_readers k fmt\n | Ignored_caml_char -> take_format_readers k fmt\n | Ignored_string _ -> take_format_readers k fmt\n | Ignored_caml_string _ -> take_format_readers k fmt\n | Ignored_int (_, _) -> take_format_readers k fmt\n | Ignored_int32 (_, _) -> take_format_readers k fmt\n | Ignored_nativeint (_, _) -> take_format_readers k fmt\n | Ignored_int64 (_, _) -> take_format_readers k fmt\n | Ignored_float (_, _) -> take_format_readers k fmt\n | Ignored_bool _ -> take_format_readers k fmt\n | Ignored_format_arg _ -> take_format_readers k fmt\n | Ignored_format_subst (_, fmtty) -> take_fmtty_format_readers k fmtty fmt\n | Ignored_scan_char_set _ -> take_format_readers k fmt\n | Ignored_scan_get_counter _ -> take_format_readers k fmt\n | Ignored_scan_next_char -> take_format_readers k fmt\n\n(******************************************************************************)\n (* Generic scanning *)\n\n(* Make a generic scanning function. *)\n(* Scan a stream according to a format and readers obtained by\n take_format_readers, and aggregate scanned values into an\n heterogeneous list. *)\n(* Return the heterogeneous list of scanned values. *)\nlet rec make_scanf : type a c d e f.\n Scanning.in_channel -> (a, Scanning.in_channel, c, d, e, f) fmt ->\n (d, e) heter_list -> (a, f) heter_list =\nfun ib fmt readers -> match fmt with\n | Char rest ->\n let _ = scan_char 0 ib in\n let c = token_char ib in\n Cons (c, make_scanf ib rest readers)\n | Caml_char rest ->\n let _ = scan_caml_char 0 ib in\n let c = token_char ib in\n Cons (c, make_scanf ib rest readers)\n\n | String (pad, Formatting_lit (fmting_lit, rest)) ->\n let stp, str = stopper_of_formatting_lit fmting_lit in\n let scan width _ ib = scan_string (Some stp) width ib in\n let str_rest = String_literal (str, rest) in\n pad_prec_scanf ib str_rest readers pad No_precision scan token_string\n | String (pad, Formatting_gen (Open_tag (Format (fmt', _)), rest)) ->\n let scan width _ ib = scan_string (Some '{') width ib in\n pad_prec_scanf ib (concat_fmt fmt' rest) readers pad No_precision scan\n token_string\n | String (pad, Formatting_gen (Open_box (Format (fmt', _)), rest)) ->\n let scan width _ ib = scan_string (Some '[') width ib in\n pad_prec_scanf ib (concat_fmt fmt' rest) readers pad No_precision scan\n token_string\n | String (pad, rest) ->\n let scan width _ ib = scan_string None width ib in\n pad_prec_scanf ib rest readers pad No_precision scan token_string\n\n | Caml_string (pad, rest) ->\n let scan width _ ib = scan_caml_string width ib in\n pad_prec_scanf ib rest readers pad No_precision scan token_string\n | Int (iconv, pad, prec, rest) ->\n let c = integer_conversion_of_char (char_of_iconv iconv) in\n let scan width _ ib = scan_int_conversion c width ib in\n pad_prec_scanf ib rest readers pad prec scan (token_int c)\n | Int32 (iconv, pad, prec, rest) ->\n let c = integer_conversion_of_char (char_of_iconv iconv) in\n let scan width _ ib = scan_int_conversion c width ib in\n pad_prec_scanf ib rest readers pad prec scan (token_int32 c)\n | Nativeint (iconv, pad, prec, rest) ->\n let c = integer_conversion_of_char (char_of_iconv iconv) in\n let scan width _ ib = scan_int_conversion c width ib in\n pad_prec_scanf ib rest readers pad prec scan (token_nativeint c)\n | Int64 (iconv, pad, prec, rest) ->\n let c = integer_conversion_of_char (char_of_iconv iconv) in\n let scan width _ ib = scan_int_conversion c width ib in\n pad_prec_scanf ib rest readers pad prec scan (token_int64 c)\n | Float ((_, (Float_F | Float_CF)), pad, prec, rest) ->\n pad_prec_scanf ib rest readers pad prec scan_caml_float token_float\n | Float ((_, (Float_f | Float_e | Float_E | Float_g | Float_G)),\n pad, prec, rest) ->\n pad_prec_scanf ib rest readers pad prec scan_float token_float\n | Float ((_, (Float_h | Float_H)), pad, prec, rest) ->\n pad_prec_scanf ib rest readers pad prec scan_hex_float token_float\n | Bool (pad, rest) ->\n let scan _ _ ib = scan_bool ib in\n pad_prec_scanf ib rest readers pad No_precision scan token_bool\n | Alpha _ ->\n invalid_arg \"scanf: bad conversion \\\"%a\\\"\"\n | Theta _ ->\n invalid_arg \"scanf: bad conversion \\\"%t\\\"\"\n | Custom _ ->\n invalid_arg \"scanf: bad conversion \\\"%?\\\" (custom converter)\"\n | Reader fmt_rest ->\n begin match readers with\n | Cons (reader, readers_rest) ->\n let x = reader ib in\n Cons (x, make_scanf ib fmt_rest readers_rest)\n | Nil ->\n invalid_arg \"scanf: missing reader\"\n end\n | Flush rest ->\n if Scanning.end_of_input ib then make_scanf ib rest readers\n else bad_input \"end of input not found\"\n\n | String_literal (str, rest) ->\n String.iter (check_char ib) str;\n make_scanf ib rest readers\n | Char_literal (chr, rest) ->\n check_char ib chr;\n make_scanf ib rest readers\n\n | Format_arg (pad_opt, fmtty, rest) ->\n let _ = scan_caml_string (width_of_pad_opt pad_opt) ib in\n let s = token_string ib in\n let fmt =\n try format_of_string_fmtty s fmtty\n with Failure msg -> bad_input msg\n in\n Cons (fmt, make_scanf ib rest readers)\n | Format_subst (pad_opt, fmtty, rest) ->\n let _ = scan_caml_string (width_of_pad_opt pad_opt) ib in\n let s = token_string ib in\n let fmt, fmt' =\n try\n let Fmt_EBB fmt = fmt_ebb_of_string s in\n let Fmt_EBB fmt' = fmt_ebb_of_string s in\n (* TODO: find a way to avoid reparsing twice *)\n\n (* TODO: these type-checks below *can* fail because of type\n ambiguity in presence of ignored-readers: \"%_r%d\" and \"%d%_r\"\n are typed in the same way.\n\n # Scanf.sscanf \"\\\"%_r%d\\\"3\" \"%(%d%_r%)\" ignore\n (fun fmt n -> string_of_format fmt, n)\n Exception: CamlinternalFormat.Type_mismatch.\n\n We should properly catch this exception.\n *)\n type_format fmt (erase_rel fmtty),\n type_format fmt' (erase_rel (symm fmtty))\n with Failure msg -> bad_input msg\n in\n Cons (Format (fmt, s),\n make_scanf ib (concat_fmt fmt' rest) readers)\n\n | Scan_char_set (width_opt, char_set, Formatting_lit (fmting_lit, rest)) ->\n let stp, str = stopper_of_formatting_lit fmting_lit in\n let width = width_of_pad_opt width_opt in\n scan_chars_in_char_set char_set (Some stp) width ib;\n let s = token_string ib in\n let str_rest = String_literal (str, rest) in\n Cons (s, make_scanf ib str_rest readers)\n | Scan_char_set (width_opt, char_set, rest) ->\n let width = width_of_pad_opt width_opt in\n scan_chars_in_char_set char_set None width ib;\n let s = token_string ib in\n Cons (s, make_scanf ib rest readers)\n | Scan_get_counter (counter, rest) ->\n let count = get_counter ib counter in\n Cons (count, make_scanf ib rest readers)\n | Scan_next_char rest ->\n let c = Scanning.checked_peek_char ib in\n Cons (c, make_scanf ib rest readers)\n\n | Formatting_lit (formatting_lit, rest) ->\n String.iter (check_char ib) (string_of_formatting_lit formatting_lit);\n make_scanf ib rest readers\n | Formatting_gen (Open_tag (Format (fmt', _)), rest) ->\n check_char ib '@'; check_char ib '{';\n make_scanf ib (concat_fmt fmt' rest) readers\n | Formatting_gen (Open_box (Format (fmt', _)), rest) ->\n check_char ib '@'; check_char ib '[';\n make_scanf ib (concat_fmt fmt' rest) readers\n\n | Ignored_param (ign, rest) ->\n let Param_format_EBB fmt' = param_format_of_ignored_format ign rest in\n begin match make_scanf ib fmt' readers with\n | Cons (_, arg_rest) -> arg_rest\n | Nil -> assert false\n end\n\n | End_of_format ->\n Nil\n\n(* Case analysis on padding and precision. *)\n(* Reject formats containing \"%*\" or \"%.*\". *)\n(* Pass padding and precision to the generic scanner `scan'. *)\nand pad_prec_scanf : type a c d e f x y z t .\n Scanning.in_channel -> (a, Scanning.in_channel, c, d, e, f) fmt ->\n (d, e) heter_list -> (x, y) padding -> (y, z -> a) precision ->\n (int -> int -> Scanning.in_channel -> t) ->\n (Scanning.in_channel -> z) ->\n (x, f) heter_list =\nfun ib fmt readers pad prec scan token -> match pad, prec with\n | No_padding, No_precision ->\n let _ = scan max_int max_int ib in\n let x = token ib in\n Cons (x, make_scanf ib fmt readers)\n | No_padding, Lit_precision p ->\n let _ = scan max_int p ib in\n let x = token ib in\n Cons (x, make_scanf ib fmt readers)\n | Lit_padding ((Right | Zeros), w), No_precision ->\n let _ = scan w max_int ib in\n let x = token ib in\n Cons (x, make_scanf ib fmt readers)\n | Lit_padding ((Right | Zeros), w), Lit_precision p ->\n let _ = scan w p ib in\n let x = token ib in\n Cons (x, make_scanf ib fmt readers)\n | Lit_padding (Left, _), _ ->\n invalid_arg \"scanf: bad conversion \\\"%-\\\"\"\n | Lit_padding ((Right | Zeros), _), Arg_precision ->\n invalid_arg \"scanf: bad conversion \\\"%*\\\"\"\n | Arg_padding _, _ ->\n invalid_arg \"scanf: bad conversion \\\"%*\\\"\"\n | No_padding, Arg_precision ->\n invalid_arg \"scanf: bad conversion \\\"%*\\\"\"\n\n(******************************************************************************)\n (* Defining [scanf] and various flavors of [scanf] *)\n\ntype 'a kscanf_result = Args of 'a | Exc of exn\n\nlet kscanf ib ef (Format (fmt, str)) =\n let rec apply : type a b . a -> (a, b) heter_list -> b =\n fun f args -> match args with\n | Cons (x, r) -> apply (f x) r\n | Nil -> f\n in\n let k readers f =\n Scanning.reset_token ib;\n match try Args (make_scanf ib fmt readers) with\n | (Scan_failure _ | Failure _ | End_of_file) as exc -> Exc exc\n | Invalid_argument msg ->\n invalid_arg (msg ^ \" in format \\\"\" ^ String.escaped str ^ \"\\\"\")\n with\n | Args args -> apply f args\n | Exc exc -> ef ib exc\n in\n take_format_readers k fmt\n\n(***)\n\nlet kbscanf = kscanf\nlet bscanf ib fmt = kbscanf ib scanf_bad_input fmt\n\nlet ksscanf s ef fmt = kbscanf (Scanning.from_string s) ef fmt\nlet sscanf s fmt = kbscanf (Scanning.from_string s) scanf_bad_input fmt\n\nlet scanf fmt = kscanf Scanning.stdib scanf_bad_input fmt\n\n(***)\n\n(* Scanning format strings. *)\nlet bscanf_format :\n Scanning.in_channel -> ('a, 'b, 'c, 'd, 'e, 'f) format6 ->\n (('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g) -> 'g =\n fun ib format f ->\n let _ = scan_caml_string max_int ib in\n let str = token_string ib in\n let fmt' =\n try format_of_string_format str format\n with Failure msg -> bad_input msg in\n f fmt'\n\n\nlet sscanf_format :\n string -> ('a, 'b, 'c, 'd, 'e, 'f) format6 ->\n (('a, 'b, 'c, 'd, 'e, 'f) format6 -> 'g) -> 'g =\n fun s format f -> bscanf_format (Scanning.from_string s) format f\n\n\nlet format_from_string s fmt =\n sscanf_format (\"\\\"\" ^ String.escaped s ^ \"\\\"\") fmt (fun x -> x)\n\n\nlet unescaped s =\n sscanf (\"\\\"\" ^ s ^ \"\\\"\") \"%S%!\" (fun x -> x)\n\n\n(* Deprecated *)\nlet kfscanf ic ef fmt = kbscanf (Scanning.memo_from_channel ic) ef fmt\nlet fscanf ic fmt = kscanf (Scanning.memo_from_channel ic) scanf_bad_input fmt\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* Registering OCaml values with the C runtime for later callbacks *)\n\nexternal register_named_value : string -> Obj.t -> unit\n = \"caml_register_named_value\"\n\nlet register name v =\n register_named_value name (Obj.repr v)\n\nlet register_exception name (exn : exn) =\n let exn = Obj.repr exn in\n let slot = if Obj.tag exn = Obj.object_tag then exn else Obj.field exn 0 in\n register_named_value name slot\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 2004 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\ntype shape =\n | Function\n | Lazy\n | Class\n | Module of shape array\n | Value of Obj.t\n\nlet rec init_mod_field modu i loc shape =\n let init =\n match shape with\n | Function ->\n let rec fn (x : 'a) =\n let fn' : 'a -> 'b = Obj.obj (Obj.field modu i) in\n if fn == fn' then\n raise (Undefined_recursive_module loc)\n else\n fn' x in\n Obj.repr fn\n | Lazy ->\n let rec l =\n lazy (\n let l' = Obj.obj (Obj.field modu i) in\n if l == l' then\n raise (Undefined_recursive_module loc)\n else\n Lazy.force l') in\n Obj.repr l\n | Class ->\n Obj.repr (CamlinternalOO.dummy_class loc)\n | Module comps ->\n Obj.repr (init_mod_block loc comps)\n | Value v -> v\n in\n Obj.set_field modu i init\n\nand init_mod_block loc comps =\n let length = Array.length comps in\n let modu = Obj.new_block 0 length in\n for i = 0 to length - 1 do\n init_mod_field modu i loc comps.(i)\n done;\n modu\n\nlet init_mod loc shape =\n match shape with\n | Module comps ->\n Obj.repr (init_mod_block loc comps)\n | _ -> failwith \"CamlinternalMod.init_mod: not a module\"\n\nlet rec update_mod_field modu i shape n =\n match shape with\n | Function | Lazy ->\n Obj.set_field modu i n\n | Value _ ->\n () (* the value is already there *)\n | Class ->\n assert (Obj.tag n = 0 && Obj.size n = 4);\n let cl = Obj.field modu i in\n for j = 0 to 3 do\n Obj.set_field cl j (Obj.field n j)\n done\n | Module comps ->\n update_mod_block comps (Obj.field modu i) n\n\nand update_mod_block comps o n =\n assert (Obj.tag n = 0 && Obj.size n >= Array.length comps);\n for i = 0 to Array.length comps - 1 do\n update_mod_field o i comps.(i) (Obj.field n i)\n done\n\nlet update_mod shape o n =\n match shape with\n | Module comps ->\n update_mod_block comps o n\n | _ -> failwith \"CamlinternalMod.update_mod: not a module\"\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Manuel Serrano et Xavier Leroy, INRIA Rocquencourt *)\n(* *)\n(* Copyright 2000 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* Module [Bigarray]: large, multi-dimensional, numerical arrays *)\n\n(* These types in must be kept in sync with the tables in\n ../typing/typeopt.ml *)\n\ntype float32_elt = Float32_elt\ntype float64_elt = Float64_elt\ntype int8_signed_elt = Int8_signed_elt\ntype int8_unsigned_elt = Int8_unsigned_elt\ntype int16_signed_elt = Int16_signed_elt\ntype int16_unsigned_elt = Int16_unsigned_elt\ntype int32_elt = Int32_elt\ntype int64_elt = Int64_elt\ntype int_elt = Int_elt\ntype nativeint_elt = Nativeint_elt\ntype complex32_elt = Complex32_elt\ntype complex64_elt = Complex64_elt\n\ntype ('a, 'b) kind =\n Float32 : (float, float32_elt) kind\n | Float64 : (float, float64_elt) kind\n | Int8_signed : (int, int8_signed_elt) kind\n | Int8_unsigned : (int, int8_unsigned_elt) kind\n | Int16_signed : (int, int16_signed_elt) kind\n | Int16_unsigned : (int, int16_unsigned_elt) kind\n | Int32 : (int32, int32_elt) kind\n | Int64 : (int64, int64_elt) kind\n | Int : (int, int_elt) kind\n | Nativeint : (nativeint, nativeint_elt) kind\n | Complex32 : (Complex.t, complex32_elt) kind\n | Complex64 : (Complex.t, complex64_elt) kind\n | Char : (char, int8_unsigned_elt) kind\n\ntype c_layout = C_layout_typ\ntype fortran_layout = Fortran_layout_typ (**)\n\ntype 'a layout =\n C_layout: c_layout layout\n | Fortran_layout: fortran_layout layout\n\n(* Keep those constants in sync with the caml_ba_kind enumeration\n in bigarray.h *)\n\nlet float32 = Float32\nlet float64 = Float64\nlet int8_signed = Int8_signed\nlet int8_unsigned = Int8_unsigned\nlet int16_signed = Int16_signed\nlet int16_unsigned = Int16_unsigned\nlet int32 = Int32\nlet int64 = Int64\nlet int = Int\nlet nativeint = Nativeint\nlet complex32 = Complex32\nlet complex64 = Complex64\nlet char = Char\n\nlet kind_size_in_bytes : type a b. (a, b) kind -> int = function\n | Float32 -> 4\n | Float64 -> 8\n | Int8_signed -> 1\n | Int8_unsigned -> 1\n | Int16_signed -> 2\n | Int16_unsigned -> 2\n | Int32 -> 4\n | Int64 -> 8\n | Int -> Sys.word_size / 8\n | Nativeint -> Sys.word_size / 8\n | Complex32 -> 8\n | Complex64 -> 16\n | Char -> 1\n\n(* Keep those constants in sync with the caml_ba_layout enumeration\n in bigarray.h *)\n\nlet c_layout = C_layout\nlet fortran_layout = Fortran_layout\n\nmodule Genarray = struct\n type (!'a, !'b, !'c) t\n external create: ('a, 'b) kind -> 'c layout -> int array -> ('a, 'b, 'c) t\n = \"caml_ba_create\"\n external get: ('a, 'b, 'c) t -> int array -> 'a\n = \"caml_ba_get_generic\"\n external set: ('a, 'b, 'c) t -> int array -> 'a -> unit\n = \"caml_ba_set_generic\"\n\n let rec cloop arr idx f col max =\n if col = Array.length idx then set arr idx (f idx)\n else for j = 0 to pred max.(col) do\n idx.(col) <- j;\n cloop arr idx f (succ col) max\n done\n let rec floop arr idx f col max =\n if col < 0 then set arr idx (f idx)\n else for j = 1 to max.(col) do\n idx.(col) <- j;\n floop arr idx f (pred col) max\n done\n let init (type t) kind (layout : t layout) dims f =\n let arr = create kind layout dims in\n match Array.length dims, layout with\n | 0, _ -> arr\n | dlen, C_layout -> cloop arr (Array.make dlen 0) f 0 dims; arr\n | dlen, Fortran_layout -> floop arr (Array.make dlen 1) f (pred dlen) dims;\n arr\n\n external num_dims: ('a, 'b, 'c) t -> int = \"caml_ba_num_dims\"\n external nth_dim: ('a, 'b, 'c) t -> int -> int = \"caml_ba_dim\"\n let dims a =\n let n = num_dims a in\n let d = Array.make n 0 in\n for i = 0 to n-1 do d.(i) <- nth_dim a i done;\n d\n\n external kind: ('a, 'b, 'c) t -> ('a, 'b) kind = \"caml_ba_kind\"\n external layout: ('a, 'b, 'c) t -> 'c layout = \"caml_ba_layout\"\n external change_layout: ('a, 'b, 'c) t -> 'd layout -> ('a, 'b, 'd) t\n = \"caml_ba_change_layout\"\n\n let size_in_bytes arr =\n (kind_size_in_bytes (kind arr)) * (Array.fold_left ( * ) 1 (dims arr))\n\n external sub_left: ('a, 'b, c_layout) t -> int -> int -> ('a, 'b, c_layout) t\n = \"caml_ba_sub\"\n external sub_right: ('a, 'b, fortran_layout) t -> int -> int ->\n ('a, 'b, fortran_layout) t\n = \"caml_ba_sub\"\n external slice_left: ('a, 'b, c_layout) t -> int array ->\n ('a, 'b, c_layout) t\n = \"caml_ba_slice\"\n external slice_right: ('a, 'b, fortran_layout) t -> int array ->\n ('a, 'b, fortran_layout) t\n = \"caml_ba_slice\"\n external blit: ('a, 'b, 'c) t -> ('a, 'b, 'c) t -> unit\n = \"caml_ba_blit\"\n external fill: ('a, 'b, 'c) t -> 'a -> unit = \"caml_ba_fill\"\nend\n\nmodule Array0 = struct\n type (!'a, !'b, !'c) t = ('a, 'b, 'c) Genarray.t\n let create kind layout =\n Genarray.create kind layout [||]\n let get arr = Genarray.get arr [||]\n let set arr = Genarray.set arr [||]\n external kind: ('a, 'b, 'c) t -> ('a, 'b) kind = \"caml_ba_kind\"\n external layout: ('a, 'b, 'c) t -> 'c layout = \"caml_ba_layout\"\n\n external change_layout: ('a, 'b, 'c) t -> 'd layout -> ('a, 'b, 'd) t\n = \"caml_ba_change_layout\"\n\n let size_in_bytes arr = kind_size_in_bytes (kind arr)\n\n external blit: ('a, 'b, 'c) t -> ('a, 'b, 'c) t -> unit = \"caml_ba_blit\"\n external fill: ('a, 'b, 'c) t -> 'a -> unit = \"caml_ba_fill\"\n\n let of_value kind layout v =\n let a = create kind layout in\n set a v;\n a\n let init = of_value\nend\n\nmodule Array1 = struct\n type (!'a, !'b, !'c) t = ('a, 'b, 'c) Genarray.t\n let create kind layout dim =\n Genarray.create kind layout [|dim|]\n external get: ('a, 'b, 'c) t -> int -> 'a = \"%caml_ba_ref_1\"\n external set: ('a, 'b, 'c) t -> int -> 'a -> unit = \"%caml_ba_set_1\"\n external unsafe_get: ('a, 'b, 'c) t -> int -> 'a = \"%caml_ba_unsafe_ref_1\"\n external unsafe_set: ('a, 'b, 'c) t -> int -> 'a -> unit\n = \"%caml_ba_unsafe_set_1\"\n external dim: ('a, 'b, 'c) t -> int = \"%caml_ba_dim_1\"\n external kind: ('a, 'b, 'c) t -> ('a, 'b) kind = \"caml_ba_kind\"\n external layout: ('a, 'b, 'c) t -> 'c layout = \"caml_ba_layout\"\n\n external change_layout: ('a, 'b, 'c) t -> 'd layout -> ('a, 'b, 'd) t\n = \"caml_ba_change_layout\"\n\n let size_in_bytes arr =\n (kind_size_in_bytes (kind arr)) * (dim arr)\n\n external sub: ('a, 'b, 'c) t -> int -> int -> ('a, 'b, 'c) t = \"caml_ba_sub\"\n let slice (type t) (a : (_, _, t) Genarray.t) n =\n match layout a with\n | C_layout -> (Genarray.slice_left a [|n|] : (_, _, t) Genarray.t)\n | Fortran_layout -> (Genarray.slice_right a [|n|]: (_, _, t) Genarray.t)\n external blit: ('a, 'b, 'c) t -> ('a, 'b, 'c) t -> unit = \"caml_ba_blit\"\n external fill: ('a, 'b, 'c) t -> 'a -> unit = \"caml_ba_fill\"\n let c_init arr dim f =\n for i = 0 to pred dim do unsafe_set arr i (f i) done\n let fortran_init arr dim f =\n for i = 1 to dim do unsafe_set arr i (f i) done\n let init (type t) kind (layout : t layout) dim f =\n let arr = create kind layout dim in\n match layout with\n | C_layout -> c_init arr dim f; arr\n | Fortran_layout -> fortran_init arr dim f; arr\n let of_array (type t) kind (layout: t layout) data =\n let ba = create kind layout (Array.length data) in\n let ofs =\n match layout with\n C_layout -> 0\n | Fortran_layout -> 1\n in\n for i = 0 to Array.length data - 1 do unsafe_set ba (i + ofs) data.(i) done;\n ba\nend\n\nmodule Array2 = struct\n type (!'a, !'b, !'c) t = ('a, 'b, 'c) Genarray.t\n let create kind layout dim1 dim2 =\n Genarray.create kind layout [|dim1; dim2|]\n external get: ('a, 'b, 'c) t -> int -> int -> 'a = \"%caml_ba_ref_2\"\n external set: ('a, 'b, 'c) t -> int -> int -> 'a -> unit = \"%caml_ba_set_2\"\n external unsafe_get: ('a, 'b, 'c) t -> int -> int -> 'a\n = \"%caml_ba_unsafe_ref_2\"\n external unsafe_set: ('a, 'b, 'c) t -> int -> int -> 'a -> unit\n = \"%caml_ba_unsafe_set_2\"\n external dim1: ('a, 'b, 'c) t -> int = \"%caml_ba_dim_1\"\n external dim2: ('a, 'b, 'c) t -> int = \"%caml_ba_dim_2\"\n external kind: ('a, 'b, 'c) t -> ('a, 'b) kind = \"caml_ba_kind\"\n external layout: ('a, 'b, 'c) t -> 'c layout = \"caml_ba_layout\"\n\n external change_layout: ('a, 'b, 'c) t -> 'd layout -> ('a, 'b, 'd) t\n = \"caml_ba_change_layout\"\n\n let size_in_bytes arr =\n (kind_size_in_bytes (kind arr)) * (dim1 arr) * (dim2 arr)\n\n external sub_left: ('a, 'b, c_layout) t -> int -> int -> ('a, 'b, c_layout) t\n = \"caml_ba_sub\"\n external sub_right:\n ('a, 'b, fortran_layout) t -> int -> int -> ('a, 'b, fortran_layout) t\n = \"caml_ba_sub\"\n let slice_left a n = Genarray.slice_left a [|n|]\n let slice_right a n = Genarray.slice_right a [|n|]\n external blit: ('a, 'b, 'c) t -> ('a, 'b, 'c) t -> unit = \"caml_ba_blit\"\n external fill: ('a, 'b, 'c) t -> 'a -> unit = \"caml_ba_fill\"\n let c_init arr dim1 dim2 f =\n for i = 0 to pred dim1 do\n for j = 0 to pred dim2 do\n unsafe_set arr i j (f i j)\n done\n done\n let fortran_init arr dim1 dim2 f =\n for j = 1 to dim2 do\n for i = 1 to dim1 do\n unsafe_set arr i j (f i j)\n done\n done\n let init (type t) kind (layout : t layout) dim1 dim2 f =\n let arr = create kind layout dim1 dim2 in\n match layout with\n | C_layout -> c_init arr dim1 dim2 f; arr\n | Fortran_layout -> fortran_init arr dim1 dim2 f; arr\n let of_array (type t) kind (layout: t layout) data =\n let dim1 = Array.length data in\n let dim2 = if dim1 = 0 then 0 else Array.length data.(0) in\n let ba = create kind layout dim1 dim2 in\n let ofs =\n match layout with\n C_layout -> 0\n | Fortran_layout -> 1\n in\n for i = 0 to dim1 - 1 do\n let row = data.(i) in\n if Array.length row <> dim2 then\n invalid_arg(\"Bigarray.Array2.of_array: non-rectangular data\");\n for j = 0 to dim2 - 1 do\n unsafe_set ba (i + ofs) (j + ofs) row.(j)\n done\n done;\n ba\nend\n\nmodule Array3 = struct\n type (!'a, !'b, !'c) t = ('a, 'b, 'c) Genarray.t\n let create kind layout dim1 dim2 dim3 =\n Genarray.create kind layout [|dim1; dim2; dim3|]\n external get: ('a, 'b, 'c) t -> int -> int -> int -> 'a = \"%caml_ba_ref_3\"\n external set: ('a, 'b, 'c) t -> int -> int -> int -> 'a -> unit\n = \"%caml_ba_set_3\"\n external unsafe_get: ('a, 'b, 'c) t -> int -> int -> int -> 'a\n = \"%caml_ba_unsafe_ref_3\"\n external unsafe_set: ('a, 'b, 'c) t -> int -> int -> int -> 'a -> unit\n = \"%caml_ba_unsafe_set_3\"\n external dim1: ('a, 'b, 'c) t -> int = \"%caml_ba_dim_1\"\n external dim2: ('a, 'b, 'c) t -> int = \"%caml_ba_dim_2\"\n external dim3: ('a, 'b, 'c) t -> int = \"%caml_ba_dim_3\"\n external kind: ('a, 'b, 'c) t -> ('a, 'b) kind = \"caml_ba_kind\"\n external layout: ('a, 'b, 'c) t -> 'c layout = \"caml_ba_layout\"\n\n external change_layout: ('a, 'b, 'c) t -> 'd layout -> ('a, 'b, 'd) t\n = \"caml_ba_change_layout\"\n\n let size_in_bytes arr =\n (kind_size_in_bytes (kind arr)) * (dim1 arr) * (dim2 arr) * (dim3 arr)\n\n external sub_left: ('a, 'b, c_layout) t -> int -> int -> ('a, 'b, c_layout) t\n = \"caml_ba_sub\"\n external sub_right:\n ('a, 'b, fortran_layout) t -> int -> int -> ('a, 'b, fortran_layout) t\n = \"caml_ba_sub\"\n let slice_left_1 a n m = Genarray.slice_left a [|n; m|]\n let slice_right_1 a n m = Genarray.slice_right a [|n; m|]\n let slice_left_2 a n = Genarray.slice_left a [|n|]\n let slice_right_2 a n = Genarray.slice_right a [|n|]\n external blit: ('a, 'b, 'c) t -> ('a, 'b, 'c) t -> unit = \"caml_ba_blit\"\n external fill: ('a, 'b, 'c) t -> 'a -> unit = \"caml_ba_fill\"\n let c_init arr dim1 dim2 dim3 f =\n for i = 0 to pred dim1 do\n for j = 0 to pred dim2 do\n for k = 0 to pred dim3 do\n unsafe_set arr i j k (f i j k)\n done\n done\n done\n let fortran_init arr dim1 dim2 dim3 f =\n for k = 1 to dim3 do\n for j = 1 to dim2 do\n for i = 1 to dim1 do\n unsafe_set arr i j k (f i j k)\n done\n done\n done\n let init (type t) kind (layout : t layout) dim1 dim2 dim3 f =\n let arr = create kind layout dim1 dim2 dim3 in\n match layout with\n | C_layout -> c_init arr dim1 dim2 dim3 f; arr\n | Fortran_layout -> fortran_init arr dim1 dim2 dim3 f; arr\n let of_array (type t) kind (layout: t layout) data =\n let dim1 = Array.length data in\n let dim2 = if dim1 = 0 then 0 else Array.length data.(0) in\n let dim3 = if dim2 = 0 then 0 else Array.length data.(0).(0) in\n let ba = create kind layout dim1 dim2 dim3 in\n let ofs =\n match layout with\n C_layout -> 0\n | Fortran_layout -> 1\n in\n for i = 0 to dim1 - 1 do\n let row = data.(i) in\n if Array.length row <> dim2 then\n invalid_arg(\"Bigarray.Array3.of_array: non-cubic data\");\n for j = 0 to dim2 - 1 do\n let col = row.(j) in\n if Array.length col <> dim3 then\n invalid_arg(\"Bigarray.Array3.of_array: non-cubic data\");\n for k = 0 to dim3 - 1 do\n unsafe_set ba (i + ofs) (j + ofs) (k + ofs) col.(k)\n done\n done\n done;\n ba\nend\n\nexternal genarray_of_array0: ('a, 'b, 'c) Array0.t -> ('a, 'b, 'c) Genarray.t\n = \"%identity\"\nexternal genarray_of_array1: ('a, 'b, 'c) Array1.t -> ('a, 'b, 'c) Genarray.t\n = \"%identity\"\nexternal genarray_of_array2: ('a, 'b, 'c) Array2.t -> ('a, 'b, 'c) Genarray.t\n = \"%identity\"\nexternal genarray_of_array3: ('a, 'b, 'c) Array3.t -> ('a, 'b, 'c) Genarray.t\n = \"%identity\"\nlet array0_of_genarray a =\n if Genarray.num_dims a = 0 then a\n else invalid_arg \"Bigarray.array0_of_genarray\"\nlet array1_of_genarray a =\n if Genarray.num_dims a = 1 then a\n else invalid_arg \"Bigarray.array1_of_genarray\"\nlet array2_of_genarray a =\n if Genarray.num_dims a = 2 then a\n else invalid_arg \"Bigarray.array2_of_genarray\"\nlet array3_of_genarray a =\n if Genarray.num_dims a = 3 then a\n else invalid_arg \"Bigarray.array3_of_genarray\"\n\nexternal reshape:\n ('a, 'b, 'c) Genarray.t -> int array -> ('a, 'b, 'c) Genarray.t\n = \"caml_ba_reshape\"\nlet reshape_0 a = reshape a [||]\nlet reshape_1 a dim1 = reshape a [|dim1|]\nlet reshape_2 a dim1 dim2 = reshape a [|dim1;dim2|]\nlet reshape_3 a dim1 dim2 dim3 = reshape a [|dim1;dim2;dim3|]\n\n(* Force caml_ba_get_{1,2,3,N} to be linked in, since we don't refer\n to those primitives directly in this file *)\n\nlet _ =\n let _ = Genarray.get in\n let _ = Array1.get in\n let _ = Array2.get in\n let _ = Array3.get in\n ()\n\n[@@@ocaml.warning \"-32\"]\nexternal get1: unit -> unit = \"caml_ba_get_1\"\nexternal get2: unit -> unit = \"caml_ba_get_2\"\nexternal get3: unit -> unit = \"caml_ba_get_3\"\nexternal set1: unit -> unit = \"caml_ba_set_1\"\nexternal set2: unit -> unit = \"caml_ba_set_2\"\nexternal set3: unit -> unit = \"caml_ba_set_3\"\n","(** Why allocate a ref instead of storing the int directly?\n\n We generate many more sexp grammars than actually get used, so we prefer to defer the\n id until we need it. The compiler can optimize away allocations that nobody touches.\n*)\n\ntype t = int Lazy.t\n\nlet create =\n let next = ref 0 in\n fun () -> lazy (\n (* As long as we don't give up the global Ocaml runtime lock by allocating, we can\n treat the read and write as atomic. See \"20.12.2 Parallel execution of long-running\n C code\" in the 4.09 manual. *)\n let id = !next in\n next := id + 1;\n id)\n\nlet force (t : t) = Lazy.force t\n\nlet compare a b = compare (force a) (force b)\n","[@@@ocaml.warning \"-3\"]\n\n(* blit_string doesn't exist in [StdLabels.Bytes]... *)\nlet bytes_blit_string ~src ~src_pos ~dst ~dst_pos ~len =\n Bytes.blit_string src src_pos dst dst_pos len\n\nopen StdLabels\nopen Format\n\n(** Type of S-expressions *)\ntype t = Atom of string | List of t list\n\nlet sexp_of_t t = t\nlet t_of_sexp t = t\nlet t_sexp_grammar = Raw_grammar.Inline Any\n\nlet rec compare_list a b =\n match a, b with\n | [] , [] -> 0\n | [] , _ -> -1\n | _ , [] -> 1\n | x::xs, y::ys ->\n let res = compare x y in\n if res <> 0 then res\n else compare_list xs ys\n\nand compare a b =\n if a == b then\n 0\n else\n match a, b with\n | Atom a, Atom b -> String.compare a b\n | Atom _, _ -> -1\n | _, Atom _ -> 1\n | List a, List b -> compare_list a b\n\nlet equal a b = compare a b = 0\n\nexception Not_found_s of t\n\nexception Of_sexp_error of exn * t\n\nmodule Printing = struct\n (* Default indentation level for human-readable conversions *)\n\n let default_indent = ref 1\n\n (* Escaping of strings used as atoms in S-expressions *)\n\n let must_escape str =\n let len = String.length str in\n len = 0 ||\n let rec loop str ix =\n match str.[ix] with\n | '\"' | '(' | ')' | ';' | '\\\\' -> true\n | '|' -> ix > 0 && let next = ix - 1 in Char.equal str.[next] '#' || loop str next\n | '#' -> ix > 0 && let next = ix - 1 in Char.equal str.[next] '|' || loop str next\n | '\\000' .. '\\032' | '\\127' .. '\\255' -> true\n | _ -> ix > 0 && loop str (ix - 1)\n in\n loop str (len - 1)\n\n let escaped s =\n let n = ref 0 in\n for i = 0 to String.length s - 1 do\n n := !n +\n (match String.unsafe_get s i with\n | '\\\"' | '\\\\' | '\\n' | '\\t' | '\\r' | '\\b' -> 2\n | ' ' .. '~' -> 1\n | _ -> 4)\n done;\n if !n = String.length s then s else begin\n let s' = Bytes.create !n in\n n := 0;\n for i = 0 to String.length s - 1 do\n begin match String.unsafe_get s i with\n | ('\\\"' | '\\\\') as c ->\n Bytes.unsafe_set s' !n '\\\\'; incr n; Bytes.unsafe_set s' !n c\n | '\\n' ->\n Bytes.unsafe_set s' !n '\\\\'; incr n; Bytes.unsafe_set s' !n 'n'\n | '\\t' ->\n Bytes.unsafe_set s' !n '\\\\'; incr n; Bytes.unsafe_set s' !n 't'\n | '\\r' ->\n Bytes.unsafe_set s' !n '\\\\'; incr n; Bytes.unsafe_set s' !n 'r'\n | '\\b' ->\n Bytes.unsafe_set s' !n '\\\\'; incr n; Bytes.unsafe_set s' !n 'b'\n | (' ' .. '~') as c -> Bytes.unsafe_set s' !n c\n | c ->\n let a = Char.code c in\n Bytes.unsafe_set s' !n '\\\\';\n incr n;\n Bytes.unsafe_set s' !n (Char.chr (48 + a / 100));\n incr n;\n Bytes.unsafe_set s' !n (Char.chr (48 + (a / 10) mod 10));\n incr n;\n Bytes.unsafe_set s' !n (Char.chr (48 + a mod 10));\n end;\n incr n\n done;\n Bytes.unsafe_to_string s'\n end\n\n let esc_str str =\n let estr = escaped str in\n let elen = String.length estr in\n let res = Bytes.create (elen + 2) in\n bytes_blit_string ~src:estr ~src_pos:0 ~dst:res ~dst_pos:1 ~len:elen;\n Bytes.unsafe_set res 0 '\"';\n Bytes.unsafe_set res (elen + 1) '\"';\n Bytes.unsafe_to_string res\n\n let index_of_newline str start =\n try Some (String.index_from str start '\\n')\n with Not_found -> None\n\n let get_substring str index end_pos_opt =\n let end_pos =\n match end_pos_opt with\n | None -> String.length str\n | Some end_pos -> end_pos\n in\n String.sub str ~pos:index ~len:(end_pos - index)\n\n let is_one_line str =\n match index_of_newline str 0 with\n | None -> true\n | Some index -> index + 1 = String.length str\n\n let pp_hum_maybe_esc_str ppf str =\n if not (must_escape str) then\n pp_print_string ppf str\n else if is_one_line str then\n pp_print_string ppf (esc_str str)\n else begin\n let rec loop index =\n let next_newline = index_of_newline str index in\n let next_line = get_substring str index next_newline in\n pp_print_string ppf (escaped next_line);\n match next_newline with\n | None -> ()\n | Some newline_index ->\n pp_print_string ppf \"\\\\\";\n pp_force_newline ppf ();\n pp_print_string ppf \"\\\\n\";\n loop (newline_index + 1)\n in\n pp_open_box ppf 0;\n (* the leading space is to line up the lines *)\n pp_print_string ppf \" \\\"\";\n loop 0;\n pp_print_string ppf \"\\\"\";\n pp_close_box ppf ();\n end\n\n let mach_maybe_esc_str str =\n if must_escape str then esc_str str else str\n\n (* Output of S-expressions to formatters *)\n\n let rec pp_hum_indent indent ppf = function\n | Atom str -> pp_hum_maybe_esc_str ppf str\n | List (h :: t) ->\n pp_open_box ppf indent;\n pp_print_string ppf \"(\";\n pp_hum_indent indent ppf h;\n pp_hum_rest indent ppf t\n | List [] -> pp_print_string ppf \"()\"\n\n and pp_hum_rest indent ppf = function\n | h :: t ->\n pp_print_space ppf ();\n pp_hum_indent indent ppf h;\n pp_hum_rest indent ppf t\n | [] ->\n pp_print_string ppf \")\";\n pp_close_box ppf ()\n\n let rec pp_mach_internal may_need_space ppf = function\n | Atom str ->\n let str' = mach_maybe_esc_str str in\n let new_may_need_space = str' == str in\n if may_need_space && new_may_need_space then pp_print_string ppf \" \";\n pp_print_string ppf str';\n new_may_need_space\n | List (h :: t) ->\n pp_print_string ppf \"(\";\n let may_need_space = pp_mach_internal false ppf h in\n pp_mach_rest may_need_space ppf t;\n false\n | List [] -> pp_print_string ppf \"()\"; false\n\n and pp_mach_rest may_need_space ppf = function\n | h :: t ->\n let may_need_space = pp_mach_internal may_need_space ppf h in\n pp_mach_rest may_need_space ppf t\n | [] -> pp_print_string ppf \")\"\n\n let pp_hum ppf sexp = pp_hum_indent !default_indent ppf sexp\n\n let pp_mach ppf sexp = ignore (pp_mach_internal false ppf sexp)\n let pp = pp_mach\n\n (* Sexp size *)\n\n let rec size_loop (v, c as acc) = function\n | Atom str -> v + 1, c + String.length str\n | List lst -> List.fold_left lst ~init:acc ~f:size_loop\n\n let size sexp = size_loop (0, 0) sexp\n\n (* Buffer conversions *)\n\n let to_buffer_hum ~buf ?(indent = !default_indent) sexp =\n let ppf = Format.formatter_of_buffer buf in\n Format.fprintf ppf \"%a@?\" (pp_hum_indent indent) sexp\n\n let to_buffer_mach ~buf sexp =\n let rec loop may_need_space = function\n | Atom str ->\n let str' = mach_maybe_esc_str str in\n let new_may_need_space = str' == str in\n if may_need_space && new_may_need_space then Buffer.add_char buf ' ';\n Buffer.add_string buf str';\n new_may_need_space\n | List (h :: t) ->\n Buffer.add_char buf '(';\n let may_need_space = loop false h in\n loop_rest may_need_space t;\n false\n | List [] -> Buffer.add_string buf \"()\"; false\n and loop_rest may_need_space = function\n | h :: t ->\n let may_need_space = loop may_need_space h in\n loop_rest may_need_space t\n | [] -> Buffer.add_char buf ')' in\n ignore (loop false sexp)\n\n let to_buffer = to_buffer_mach\n\n let to_buffer_gen ~buf ~add_char ~add_string sexp =\n let rec loop may_need_space = function\n | Atom str ->\n let str' = mach_maybe_esc_str str in\n let new_may_need_space = str' == str in\n if may_need_space && new_may_need_space then add_char buf ' ';\n add_string buf str';\n new_may_need_space\n | List (h :: t) ->\n add_char buf '(';\n let may_need_space = loop false h in\n loop_rest may_need_space t;\n false\n | List [] -> add_string buf \"()\"; false\n and loop_rest may_need_space = function\n | h :: t ->\n let may_need_space = loop may_need_space h in\n loop_rest may_need_space t\n | [] -> add_char buf ')' in\n ignore (loop false sexp)\n\n (* The maximum size of a thing on the minor heap is 256 words.\n Previously, this size of the returned buffer here was 4096 bytes, which\n caused the Buffer to be allocated on the *major* heap every time.\n\n According to a simple benchmark by Ron, we can improve performance for\n small s-expressions by a factor of ~4 if we only allocate 1024 bytes\n (128 words + some small overhead) worth of buffer initially. And one\n can argue that if it's free to allocate strings smaller than 256 words,\n large s-expressions requiring larger expensive buffers won't notice\n the extra two doublings from 1024 bytes to 2048 and 4096. And especially\n performance-sensitive applications to always pass in a larger buffer to\n use. *)\n let buffer () = Buffer.create 1024\n\n (* String conversions *)\n\n let to_string_hum ?indent = function\n | Atom str when (match index_of_newline str 0 with None -> true | Some _ -> false) ->\n mach_maybe_esc_str str\n | sexp ->\n let buf = buffer () in\n to_buffer_hum ?indent sexp ~buf;\n Buffer.contents buf\n\n let to_string_mach = function\n | Atom str -> mach_maybe_esc_str str\n | sexp ->\n let buf = buffer () in\n to_buffer_mach sexp ~buf;\n Buffer.contents buf\n\n let to_string = to_string_mach\nend\ninclude Printing\n\nlet of_float_style : [ `Underscores | `No_underscores ] ref = ref `No_underscores\nlet of_int_style : [ `Underscores | `No_underscores ] ref = ref `No_underscores\n\nmodule Private = struct\n include Printing\n\n module Raw_grammar = struct\n include Raw_grammar\n\n module Builtin = struct\n let unit_sexp_grammar = Inline (List [])\n let bool_sexp_grammar = Inline (Atom Bool)\n let string_sexp_grammar = Inline (Atom String)\n let bytes_sexp_grammar = string_sexp_grammar\n let char_sexp_grammar = Inline (Atom Char)\n let int_sexp_grammar = Inline (Atom Int)\n let float_sexp_grammar = Inline (Atom Float)\n let int32_sexp_grammar = Inline (Atom Int)\n let int64_sexp_grammar = Inline (Atom Int)\n let nativeint_sexp_grammar = Inline (Atom Int)\n let ref_sexp_grammar = Inline (Explicit_bind ([ \"'a\" ], Explicit_var 0))\n let lazy_t_sexp_grammar = Inline (Explicit_bind ([ \"'a\" ], Explicit_var 0))\n let option_sexp_grammar = Inline (Explicit_bind ([ \"'a\" ], Option (Explicit_var 0)))\n\n let list_sexp_grammar =\n Inline (Explicit_bind ([ \"'a\" ], List [ Many (Explicit_var 0) ]))\n ;;\n\n let array_sexp_grammar = list_sexp_grammar\n end\n\n let empty_sexp_grammar = Inline (Union [])\n let opaque_sexp_grammar = empty_sexp_grammar\n let fun_sexp_grammar = empty_sexp_grammar\n let tuple2_sexp_grammar =\n Inline\n (Explicit_bind\n ([ \"'a\"; \"'b\" ], List [ One (Explicit_var 0); One (Explicit_var 1) ]))\n ;;\n end\nend\n\nlet message name fields =\n let rec conv_fields = function\n | [] -> []\n | (fname, fsexp) :: rest ->\n match fname with\n | \"\" -> fsexp :: conv_fields rest\n | _ -> List [ Atom fname; fsexp ] :: conv_fields rest\n in\n List (Atom name :: conv_fields fields)\n","(* Utility Module for S-expression Conversions *)\nlet polymorphic_compare = compare\nopen StdLabels\nopen MoreLabels\nopen Printf\nopen Sexp\n\ntype sexp_bool = bool\ntype 'a sexp_option = 'a option\ntype 'a sexp_list = 'a list\ntype 'a sexp_array = 'a array\ntype 'a sexp_opaque = 'a\n\n(* Conversion of OCaml-values to S-expressions *)\nexternal format_float : string -> float -> string = \"caml_format_float\"\n\n(* '%.17g' is guaranteed to be round-trippable.\n\n '%.15g' will be round-trippable and not have noise at the last digit or two for a float\n which was converted from a decimal (string) with <= 15 significant digits. So it's\n worth trying first to avoid things like \"3.1400000000000001\".\n\n See comment above [to_string_round_trippable] in {!Core_kernel.Float} for\n detailed explanation and examples. *)\nlet default_string_of_float =\n ref (fun x ->\n let y = format_float \"%.15G\" x in\n if (float_of_string y) = x then\n y\n else\n format_float \"%.17G\" x)\n;;\n\nlet read_old_option_format = ref true\nlet write_old_option_format = ref true\n\nlet list_map f l = List.rev (List.rev_map l ~f)\n\nlet sexp_of_unit () = List []\nlet sexp_of_bool b = Atom (string_of_bool b)\nlet sexp_of_string str = Atom str\nlet sexp_of_bytes bytes = Atom (Bytes.to_string bytes)\nlet sexp_of_char c = Atom (String.make 1 c)\nlet sexp_of_int n = Atom (string_of_int n)\nlet sexp_of_float n = Atom (!default_string_of_float n)\nlet sexp_of_int32 n = Atom (Int32.to_string n)\nlet sexp_of_int64 n = Atom (Int64.to_string n)\nlet sexp_of_nativeint n = Atom (Nativeint.to_string n)\nlet sexp_of_ref sexp_of__a rf = sexp_of__a !rf\nlet sexp_of_lazy_t sexp_of__a lv = sexp_of__a (Lazy.force lv)\n\nlet sexp_of_option sexp_of__a = function\n | Some x when !write_old_option_format -> List [sexp_of__a x]\n | Some x -> List [Atom \"some\"; sexp_of__a x]\n | None when !write_old_option_format -> List []\n | None -> Atom \"none\"\n\nlet sexp_of_pair sexp_of__a sexp_of__b (a, b) =\n List [sexp_of__a a; sexp_of__b b]\n\nlet sexp_of_triple sexp_of__a sexp_of__b sexp_of__c (a, b, c) =\n List [sexp_of__a a; sexp_of__b b; sexp_of__c c]\n\n(* List.rev (List.rev_map ...) is tail recursive, the OCaml standard\n library List.map is NOT. *)\nlet sexp_of_list sexp_of__a lst = List (List.rev (List.rev_map lst ~f:sexp_of__a))\n\nlet sexp_of_array sexp_of__a ar =\n let lst_ref = ref [] in\n for i = Array.length ar - 1 downto 0 do\n lst_ref := sexp_of__a ar.(i) :: !lst_ref\n done;\n List !lst_ref\n\nlet sexp_of_hashtbl sexp_of_key sexp_of_val htbl =\n let coll ~key:k ~data:v acc = List [sexp_of_key k; sexp_of_val v] :: acc in\n List (Hashtbl.fold htbl ~init:[] ~f:coll)\n\nlet sexp_of_opaque _ = Atom \"\"\nlet sexp_of_fun _ = Atom \"\"\n\n\n(* Exception converter registration and lookup *)\n\nmodule Exn_converter = struct\n (* These exception registration functions assume that context-switches\n cannot happen unless there is an allocation. It is reasonable to expect\n that this will remain true for the foreseeable future. That way we\n avoid using mutexes and thus a dependency on the threads library. *)\n\n (* Fast and automatic exception registration *)\n\n module Int = struct\n type t = int\n\n let compare t1 t2 = polymorphic_compare (t1 : int) t2\n end\n\n module Exn_ids = Map.Make (Int)\n\n module Obj = struct\n module Extension_constructor = struct\n [@@@ocaml.warning \"-3\"]\n type t = extension_constructor\n let id = Obj.extension_id\n let of_val = Obj.extension_constructor\n end\n end\n\n let exn_id_map\n : (Obj.Extension_constructor.t, exn -> Sexp.t) Ephemeron.K1.t Exn_ids.t ref =\n ref Exn_ids.empty\n\n (* [Obj.extension_id] works on both the exception itself, and the extension slot of the\n exception. *)\n let rec clean_up_handler (slot : Obj.Extension_constructor.t) =\n let id = Obj.Extension_constructor.id slot in\n let old_exn_id_map = !exn_id_map in\n let new_exn_id_map = Exn_ids.remove id old_exn_id_map in\n (* This trick avoids mutexes and should be fairly efficient *)\n if !exn_id_map != old_exn_id_map then\n clean_up_handler slot\n else\n exn_id_map := new_exn_id_map\n\n (* Ephemerons are used so that [sexp_of_exn] closure don't keep the\n extension_constructor live. *)\n let add ?(finalise = true) extension_constructor sexp_of_exn =\n let id = Obj.Extension_constructor.id extension_constructor in\n let rec loop () =\n let old_exn_id_map = !exn_id_map in\n let ephe = Ephemeron.K1.create () in\n Ephemeron.K1.set_data ephe sexp_of_exn;\n Ephemeron.K1.set_key ephe extension_constructor;\n let new_exn_id_map = Exn_ids.add old_exn_id_map ~key:id ~data:ephe in\n (* This trick avoids mutexes and should be fairly efficient *)\n if !exn_id_map != old_exn_id_map then\n loop ()\n else begin\n exn_id_map := new_exn_id_map;\n if finalise then\n try\n Gc.finalise clean_up_handler extension_constructor\n with Invalid_argument _ ->\n (* Pre-allocated extension constructors cannot be finalised *)\n ()\n end\n in\n loop ()\n\n let add_auto ?finalise exn sexp_of_exn =\n add ?finalise (Obj.Extension_constructor.of_val exn) sexp_of_exn\n\n let find_auto exn =\n let id = Obj.Extension_constructor.id (Obj.Extension_constructor.of_val exn) in\n match Exn_ids.find id !exn_id_map with\n | exception Not_found -> None\n | ephe ->\n match Ephemeron.K1.get_data ephe with\n | None -> None\n | Some sexp_of_exn -> Some (sexp_of_exn exn)\n\n\n module For_unit_tests_only = struct\n let size () = Exn_ids.fold !exn_id_map ~init:0 ~f:(fun ~key:_ ~data:ephe acc ->\n match Ephemeron.K1.get_data ephe with\n | None -> acc\n | Some _ -> acc + 1\n )\n end\n\nend\n\nlet sexp_of_exn_opt exn = Exn_converter.find_auto exn\n\n\nlet sexp_of_exn exn =\n match sexp_of_exn_opt exn with\n | None -> List [Atom (Printexc.to_string exn)]\n | Some sexp -> sexp\n\nlet exn_to_string e = Sexp.to_string_hum (sexp_of_exn e)\n\n(* {[exception Blah [@@deriving sexp]]} generates a call to the function\n [Exn_converter.add] defined in this file. So we are guaranted that as soon as we\n mark an exception as sexpable, this module will be linked in and this printer will be\n registered, which is what we want. *)\nlet () =\n Printexc.register_printer (fun exn ->\n match sexp_of_exn_opt exn with\n | None -> None\n | Some sexp ->\n Some (Sexp.to_string_hum ~indent:2 sexp))\n\n(* Conversion of S-expressions to OCaml-values *)\n\nexception Of_sexp_error = Sexp.Of_sexp_error\n\nlet record_check_extra_fields = ref true\n\nlet of_sexp_error_exn exc sexp = raise (Of_sexp_error (exc, sexp))\n\nlet of_sexp_error what sexp = raise (Of_sexp_error (Failure what, sexp))\n\nlet unit_of_sexp sexp = match sexp with\n | List [] -> ()\n | Atom _ | List _ -> of_sexp_error \"unit_of_sexp: empty list needed\" sexp\n\nlet bool_of_sexp sexp = match sexp with\n | Atom (\"true\" | \"True\") -> true\n | Atom (\"false\" | \"False\") -> false\n | Atom _ -> of_sexp_error \"bool_of_sexp: unknown string\" sexp\n | List _ -> of_sexp_error \"bool_of_sexp: atom needed\" sexp\n\nlet string_of_sexp sexp = match sexp with\n | Atom str -> str\n | List _ -> of_sexp_error \"string_of_sexp: atom needed\" sexp\n\nlet bytes_of_sexp sexp = match sexp with\n | Atom str -> Bytes.of_string str\n | List _ -> of_sexp_error \"bytes_of_sexp: atom needed\" sexp\n\n\nlet char_of_sexp sexp = match sexp with\n | Atom str ->\n if String.length str <> 1 then\n of_sexp_error\n \"char_of_sexp: atom string must contain one character only\" sexp;\n str.[0]\n | List _ -> of_sexp_error \"char_of_sexp: atom needed\" sexp\n\nlet int_of_sexp sexp = match sexp with\n | Atom str ->\n (try int_of_string str\n with exc -> of_sexp_error (\"int_of_sexp: \" ^ exn_to_string exc) sexp)\n | List _ -> of_sexp_error \"int_of_sexp: atom needed\" sexp\n\nlet float_of_sexp sexp = match sexp with\n | Atom str ->\n (try float_of_string str\n with exc ->\n of_sexp_error (\"float_of_sexp: \" ^ exn_to_string exc) sexp)\n | List _ -> of_sexp_error \"float_of_sexp: atom needed\" sexp\n\nlet int32_of_sexp sexp = match sexp with\n | Atom str ->\n (try Int32.of_string str\n with exc ->\n of_sexp_error (\"int32_of_sexp: \" ^ exn_to_string exc) sexp)\n | List _ -> of_sexp_error \"int32_of_sexp: atom needed\" sexp\n\nlet int64_of_sexp sexp = match sexp with\n | Atom str ->\n (try Int64.of_string str\n with exc ->\n of_sexp_error (\"int64_of_sexp: \" ^ exn_to_string exc) sexp)\n | List _ -> of_sexp_error \"int64_of_sexp: atom needed\" sexp\n\nlet nativeint_of_sexp sexp = match sexp with\n | Atom str ->\n (try Nativeint.of_string str\n with exc ->\n of_sexp_error (\"nativeint_of_sexp: \" ^ exn_to_string exc) sexp)\n | List _ -> of_sexp_error \"nativeint_of_sexp: atom needed\" sexp\n\nlet ref_of_sexp a__of_sexp sexp = ref (a__of_sexp sexp)\nlet lazy_t_of_sexp a__of_sexp sexp = Lazy.from_val (a__of_sexp sexp)\n\nlet option_of_sexp a__of_sexp sexp =\n if !read_old_option_format then\n match sexp with\n | List [] | Atom (\"none\" | \"None\") -> None\n | List [el] | List [Atom (\"some\" | \"Some\"); el] -> Some (a__of_sexp el)\n | List _ ->\n of_sexp_error \"option_of_sexp: list must represent optional value\" sexp\n | Atom _ -> of_sexp_error \"option_of_sexp: only none can be atom\" sexp\n else\n match sexp with\n | Atom (\"none\" | \"None\") -> None\n | List [Atom (\"some\" | \"Some\"); el] -> Some (a__of_sexp el)\n | Atom _ -> of_sexp_error \"option_of_sexp: only none can be atom\" sexp\n | List _ -> of_sexp_error \"option_of_sexp: list must be (some el)\" sexp\n\nlet pair_of_sexp a__of_sexp b__of_sexp sexp = match sexp with\n | List [a_sexp; b_sexp] ->\n let a = a__of_sexp a_sexp in\n let b = b__of_sexp b_sexp in\n a, b\n | List _ ->\n of_sexp_error\n \"pair_of_sexp: list must contain exactly two elements only\" sexp\n | Atom _ -> of_sexp_error \"pair_of_sexp: list needed\" sexp\n\nlet triple_of_sexp a__of_sexp b__of_sexp c__of_sexp sexp = match sexp with\n | List [a_sexp; b_sexp; c_sexp] ->\n let a = a__of_sexp a_sexp in\n let b = b__of_sexp b_sexp in\n let c = c__of_sexp c_sexp in\n a, b, c\n | List _ ->\n of_sexp_error\n \"triple_of_sexp: list must contain exactly three elements only\" sexp\n | Atom _ -> of_sexp_error \"triple_of_sexp: list needed\" sexp\n\nlet list_of_sexp a__of_sexp sexp = match sexp with\n | List lst ->\n let rev_lst = List.rev_map lst ~f:a__of_sexp in\n List.rev rev_lst\n | Atom _ -> of_sexp_error \"list_of_sexp: list needed\" sexp\n\nlet array_of_sexp a__of_sexp sexp = match sexp with\n | List [] -> [||]\n | List (h :: t) ->\n let len = List.length t + 1 in\n let res = Array.make len (a__of_sexp h) in\n let rec loop i = function\n | [] -> res\n | h :: t -> res.(i) <- a__of_sexp h; loop (i + 1) t in\n loop 1 t\n | Atom _ -> of_sexp_error \"array_of_sexp: list needed\" sexp\n\nlet hashtbl_of_sexp key_of_sexp val_of_sexp sexp = match sexp with\n | List lst ->\n let htbl = Hashtbl.create 0 in\n let act = function\n | List [k_sexp; v_sexp] ->\n Hashtbl.add htbl ~key:(key_of_sexp k_sexp) ~data:(val_of_sexp v_sexp)\n | List _ | Atom _ ->\n of_sexp_error \"hashtbl_of_sexp: tuple list needed\" sexp\n in\n List.iter lst ~f:act;\n htbl\n | Atom _ -> of_sexp_error \"hashtbl_of_sexp: list needed\" sexp\n\nlet opaque_of_sexp sexp =\n of_sexp_error \"opaque_of_sexp: cannot convert opaque values\" sexp\n\nlet fun_of_sexp sexp =\n of_sexp_error \"fun_of_sexp: cannot convert function values\" sexp\n\n(* Registering default exception printers *)\n\nlet get_flc_error name (file, line, chr) =\n Atom (sprintf \"%s %s:%d:%d\" name file line chr)\n\nlet () =\n List.iter\n ~f:(fun (extension_constructor, handler) -> Exn_converter.add ~finalise:false extension_constructor handler)\n [\n (\n [%extension_constructor Assert_failure],\n (function\n | Assert_failure arg -> get_flc_error \"Assert_failure\" arg\n | _ -> assert false)\n );(\n [%extension_constructor Exit],\n (function\n | Exit -> Atom \"Exit\"\n | _ -> assert false)\n );(\n [%extension_constructor End_of_file],\n (function\n | End_of_file -> Atom \"End_of_file\"\n | _ -> assert false)\n );(\n [%extension_constructor Failure],\n (function\n | Failure arg -> List [Atom \"Failure\"; Atom arg ]\n | _ -> assert false)\n );(\n [%extension_constructor Not_found],\n (function\n | Not_found -> Atom \"Not_found\"\n | _ -> assert false)\n );(\n [%extension_constructor Invalid_argument],\n (function\n | Invalid_argument arg -> List [Atom \"Invalid_argument\"; Atom arg ]\n | _ -> assert false)\n );(\n [%extension_constructor Match_failure],\n (function\n | Match_failure arg -> get_flc_error \"Match_failure\" arg\n | _ -> assert false)\n );(\n [%extension_constructor Not_found_s],\n (function\n | Not_found_s arg -> List [Atom \"Not_found_s\"; arg ]\n | _ -> assert false)\n );(\n [%extension_constructor Sys_error],\n (function\n | Sys_error arg -> List [Atom \"Sys_error\"; Atom arg ]\n | _ -> assert false)\n );(\n [%extension_constructor Arg.Help],\n (function\n | Arg.Help arg -> List [Atom \"Arg.Help\"; Atom arg ]\n | _ -> assert false)\n );(\n [%extension_constructor Arg.Bad],\n (function\n | Arg.Bad arg -> List [Atom \"Arg.Bad\"; Atom arg ]\n | _ -> assert false)\n );(\n [%extension_constructor Lazy.Undefined],\n (function\n | Lazy.Undefined -> Atom \"Lazy.Undefined\"\n | _ -> assert false)\n );(\n [%extension_constructor Parsing.Parse_error],\n (function\n | Parsing.Parse_error -> Atom \"Parsing.Parse_error\"\n | _ -> assert false)\n );(\n [%extension_constructor Queue.Empty],\n (function\n | Queue.Empty -> Atom \"Queue.Empty\"\n | _ -> assert false)\n );(\n [%extension_constructor Scanf.Scan_failure],\n (function\n | Scanf.Scan_failure arg -> List [Atom \"Scanf.Scan_failure\"; Atom arg ]\n | _ -> assert false)\n );(\n [%extension_constructor Stack.Empty],\n (function\n | Stack.Empty -> Atom \"Stack.Empty\"\n | _ -> assert false)\n );(\n [%extension_constructor Stream.Failure],\n (function\n | Stream.Failure -> Atom \"Stream.Failure\"\n | _ -> assert false)\n );(\n [%extension_constructor Stream.Error],\n (function\n | Stream.Error arg -> List [Atom \"Stream.Error\"; Atom arg ]\n | _ -> assert false)\n );(\n [%extension_constructor Sys.Break],\n (function\n | Sys.Break -> Atom \"Sys.Break\"\n | _ -> assert false)\n );(\n [%extension_constructor Of_sexp_error],\n (function\n | Of_sexp_error (exc, sexp) ->\n List [Atom \"Sexplib.Conv.Of_sexp_error\"; sexp_of_exn exc; sexp]\n | _ -> assert false)\n );\n ]\n\nexternal ignore : _ -> unit = \"%ignore\"\nexternal ( = ) : 'a -> 'a -> bool = \"%equal\"\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Damien Doligez, projet Para, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1997 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n[@@@ocaml.warning \"-32\"]\n\nmodule type SeededS = sig\n\n type key\n type !'a t\n val create : ?random (*thwart tools/sync_stdlib_docs*) : bool -> int -> 'a t\n val clear : 'a t -> unit\n val reset : 'a t -> unit\n val copy : 'a t -> 'a t\n val add : 'a t -> key -> 'a -> unit\n val remove : 'a t -> key -> unit\n val find : 'a t -> key -> 'a\n val find_opt : 'a t -> key -> 'a option\n val find_all : 'a t -> key -> 'a list\n val replace : 'a t -> key -> 'a -> unit\n val mem : 'a t -> key -> bool\n val iter : (key -> 'a -> unit) -> 'a t -> unit\n [@@alert old_ephemeron_api \"This function won't be available in 5.0\"]\n val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit\n [@@alert old_ephemeron_api \"This function won't be available in 5.0\"]\n val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b\n [@@alert old_ephemeron_api \"This function won't be available in 5.0\"]\n val length : 'a t -> int\n val stats : 'a t -> Hashtbl.statistics\n val to_seq : 'a t -> (key * 'a) Seq.t\n [@@alert old_ephemeron_api \"This function won't be available in 5.0\"]\n val to_seq_keys : _ t -> key Seq.t\n [@@alert old_ephemeron_api \"This function won't be available in 5.0\"]\n val to_seq_values : 'a t -> 'a Seq.t\n [@@alert old_ephemeron_api \"This function won't be available in 5.0\"]\n val add_seq : 'a t -> (key * 'a) Seq.t -> unit\n val replace_seq : 'a t -> (key * 'a) Seq.t -> unit\n val of_seq : (key * 'a) Seq.t -> 'a t\n val clean: 'a t -> unit\n val stats_alive: 'a t -> Hashtbl.statistics\n (** same as {!stats} but only count the alive bindings *)\nend\n\nmodule type S = sig\n\n type key\n type !'a t\n val create : int -> 'a t\n val clear : 'a t -> unit\n val reset : 'a t -> unit\n val copy : 'a t -> 'a t\n val add : 'a t -> key -> 'a -> unit\n val remove : 'a t -> key -> unit\n val find : 'a t -> key -> 'a\n val find_opt : 'a t -> key -> 'a option\n val find_all : 'a t -> key -> 'a list\n val replace : 'a t -> key -> 'a -> unit\n val mem : 'a t -> key -> bool\n val iter : (key -> 'a -> unit) -> 'a t -> unit\n [@@alert old_ephemeron_api \"This function won't be available in 5.0\"]\n val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit\n [@@alert old_ephemeron_api \"This function won't be available in 5.0\"]\n val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b\n [@@alert old_ephemeron_api \"This function won't be available in 5.0\"]\n val length : 'a t -> int\n val stats : 'a t -> Hashtbl.statistics\n val to_seq : 'a t -> (key * 'a) Seq.t\n [@@alert old_ephemeron_api \"This function won't be available in 5.0\"]\n val to_seq_keys : _ t -> key Seq.t\n [@@alert old_ephemeron_api \"This function won't be available in 5.0\"]\n val to_seq_values : 'a t -> 'a Seq.t\n [@@alert old_ephemeron_api \"This function won't be available in 5.0\"]\n val add_seq : 'a t -> (key * 'a) Seq.t -> unit\n val replace_seq : 'a t -> (key * 'a) Seq.t -> unit\n val of_seq : (key * 'a) Seq.t -> 'a t\n val clean: 'a t -> unit\n val stats_alive: 'a t -> Hashtbl.statistics\n (** same as {!stats} but only count the alive bindings *)\nend\n\nmodule GenHashTable = struct\n\n type equal =\n | ETrue | EFalse\n | EDead (** the garbage collector reclaimed the data *)\n\n module MakeSeeded(H: sig\n type t\n type 'a container\n val create: t -> 'a -> 'a container\n val hash: int -> t -> int\n val equal: 'a container -> t -> equal\n val get_data: 'a container -> 'a option\n val get_key: 'a container -> t option\n val set_key_data: 'a container -> t -> 'a -> unit\n val check_key: 'a container -> bool\n end) : SeededS with type key = H.t\n = struct\n\n type 'a t =\n { mutable size: int; (* number of entries *)\n mutable data: 'a bucketlist array; (* the buckets *)\n seed: int; (* for randomization *)\n initial_size: int; (* initial array size *)\n }\n\n and 'a bucketlist =\n | Empty\n | Cons of int (* hash of the key *) * 'a H.container * 'a bucketlist\n\n (** the hash of the key is kept in order to test the equality of the hash\n before the key. Same reason as for Weak.Make *)\n\n type key = H.t\n\n let rec power_2_above x n =\n if x >= n then x\n else if x * 2 > Sys.max_array_length then x\n else power_2_above (x * 2) n\n\n let prng = lazy (Random.State.make_self_init())\n\n let create ?(random = (Hashtbl.is_randomized ())) initial_size =\n let s = power_2_above 16 initial_size in\n let seed = if random then Random.State.bits (Lazy.force prng) else 0 in\n { initial_size = s; size = 0; seed = seed; data = Array.make s Empty }\n\n let clear h =\n h.size <- 0;\n let len = Array.length h.data in\n for i = 0 to len - 1 do\n h.data.(i) <- Empty\n done\n\n let reset h =\n let len = Array.length h.data in\n if len = h.initial_size then\n clear h\n else begin\n h.size <- 0;\n h.data <- Array.make h.initial_size Empty\n end\n\n let copy h = { h with data = Array.copy h.data }\n\n let key_index h hkey =\n hkey land (Array.length h.data - 1)\n\n let clean h =\n let rec do_bucket = function\n | Empty ->\n Empty\n | Cons(_, c, rest) when not (H.check_key c) ->\n h.size <- h.size - 1;\n do_bucket rest\n | Cons(hkey, c, rest) ->\n Cons(hkey, c, do_bucket rest)\n in\n let d = h.data in\n for i = 0 to Array.length d - 1 do\n d.(i) <- do_bucket d.(i)\n done\n\n (** resize is the only function to do the actual cleaning of dead keys\n (remove does it just because it could).\n\n The goal is to:\n\n - not resize infinitely when the actual number of alive keys is\n bounded but keys are continuously added. That would happen if\n this function always resize.\n - not call this function after each addition, that would happen if this\n function don't resize even when only one key is dead.\n\n So the algorithm:\n - clean the keys before resizing\n - if the number of remaining keys is less than half the size of the\n array, don't resize.\n - if it is more, resize.\n\n The second problem remains if the table reaches {!Sys.max_array_length}.\n\n *)\n let resize h =\n let odata = h.data in\n let osize = Array.length odata in\n let nsize = osize * 2 in\n clean h;\n if nsize < Sys.max_array_length && h.size >= osize lsr 1 then begin\n let ndata = Array.make nsize Empty in\n h.data <- ndata; (* so that key_index sees the new bucket count *)\n let rec insert_bucket = function\n Empty -> ()\n | Cons(hkey, data, rest) ->\n insert_bucket rest; (* preserve original order of elements *)\n let nidx = key_index h hkey in\n ndata.(nidx) <- Cons(hkey, data, ndata.(nidx)) in\n for i = 0 to osize - 1 do\n insert_bucket odata.(i)\n done\n end\n\n let add h key info =\n let hkey = H.hash h.seed key in\n let i = key_index h hkey in\n let container = H.create key info in\n let bucket = Cons(hkey, container, h.data.(i)) in\n h.data.(i) <- bucket;\n h.size <- h.size + 1;\n if h.size > Array.length h.data lsl 1 then resize h\n\n let remove h key =\n let hkey = H.hash h.seed key in\n let rec remove_bucket = function\n | Empty -> Empty\n | Cons(hk, c, next) when hkey = hk ->\n begin match H.equal c key with\n | ETrue -> h.size <- h.size - 1; next\n | EFalse -> Cons(hk, c, remove_bucket next)\n | EDead ->\n (* The dead key is automatically removed. It is acceptable\n for this function since it already removes a binding *)\n h.size <- h.size - 1;\n remove_bucket next\n end\n | Cons(hk,c,next) -> Cons(hk, c, remove_bucket next) in\n let i = key_index h hkey in\n h.data.(i) <- remove_bucket h.data.(i)\n\n (** {!find} don't remove dead keys because it would be surprising for\n the user that a read-only function mutates the state (eg. concurrent\n access). Same for {!iter}, {!fold}, {!mem}.\n *)\n let rec find_rec key hkey = function\n | Empty ->\n raise Not_found\n | Cons(hk, c, rest) when hkey = hk ->\n begin match H.equal c key with\n | ETrue ->\n begin match H.get_data c with\n | None ->\n (* This case is not impossible because the gc can run between\n H.equal and H.get_data *)\n find_rec key hkey rest\n | Some d -> d\n end\n | EFalse -> find_rec key hkey rest\n | EDead ->\n find_rec key hkey rest\n end\n | Cons(_, _, rest) ->\n find_rec key hkey rest\n\n let find h key =\n let hkey = H.hash h.seed key in\n (* TODO inline 3 iterations *)\n find_rec key hkey (h.data.(key_index h hkey))\n\n let rec find_rec_opt key hkey = function\n | Empty ->\n None\n | Cons(hk, c, rest) when hkey = hk ->\n begin match H.equal c key with\n | ETrue ->\n begin match H.get_data c with\n | None ->\n (* This case is not impossible because the gc can run between\n H.equal and H.get_data *)\n find_rec_opt key hkey rest\n | Some _ as d -> d\n end\n | EFalse -> find_rec_opt key hkey rest\n | EDead ->\n find_rec_opt key hkey rest\n end\n | Cons(_, _, rest) ->\n find_rec_opt key hkey rest\n\n let find_opt h key =\n let hkey = H.hash h.seed key in\n (* TODO inline 3 iterations *)\n find_rec_opt key hkey (h.data.(key_index h hkey))\n\n let find_all h key =\n let hkey = H.hash h.seed key in\n let rec find_in_bucket = function\n | Empty -> []\n | Cons(hk, c, rest) when hkey = hk ->\n begin match H.equal c key with\n | ETrue -> begin match H.get_data c with\n | None ->\n find_in_bucket rest\n | Some d -> d::find_in_bucket rest\n end\n | EFalse -> find_in_bucket rest\n | EDead ->\n find_in_bucket rest\n end\n | Cons(_, _, rest) ->\n find_in_bucket rest in\n find_in_bucket h.data.(key_index h hkey)\n\n\n let replace h key info =\n let hkey = H.hash h.seed key in\n let rec replace_bucket = function\n | Empty -> raise Not_found\n | Cons(hk, c, next) when hkey = hk ->\n begin match H.equal c key with\n | ETrue -> H.set_key_data c key info\n | EFalse | EDead -> replace_bucket next\n end\n | Cons(_,_,next) -> replace_bucket next\n in\n let i = key_index h hkey in\n let l = h.data.(i) in\n try\n replace_bucket l\n with Not_found ->\n let container = H.create key info in\n h.data.(i) <- Cons(hkey, container, l);\n h.size <- h.size + 1;\n if h.size > Array.length h.data lsl 1 then resize h\n\n let mem h key =\n let hkey = H.hash h.seed key in\n let rec mem_in_bucket = function\n | Empty ->\n false\n | Cons(hk, c, rest) when hk = hkey ->\n begin match H.equal c key with\n | ETrue -> true\n | EFalse | EDead -> mem_in_bucket rest\n end\n | Cons(_hk, _c, rest) -> mem_in_bucket rest in\n mem_in_bucket h.data.(key_index h hkey)\n\n let iter f h =\n let rec do_bucket = function\n | Empty ->\n ()\n | Cons(_, c, rest) ->\n begin match H.get_key c, H.get_data c with\n | None, _ | _, None -> ()\n | Some k, Some d -> f k d\n end; do_bucket rest in\n let d = h.data in\n for i = 0 to Array.length d - 1 do\n do_bucket d.(i)\n done\n\n let fold f h init =\n let rec do_bucket b accu =\n match b with\n Empty ->\n accu\n | Cons(_, c, rest) ->\n let accu = begin match H.get_key c, H.get_data c with\n | None, _ | _, None -> accu\n | Some k, Some d -> f k d accu\n end in\n do_bucket rest accu in\n let d = h.data in\n let accu = ref init in\n for i = 0 to Array.length d - 1 do\n accu := do_bucket d.(i) !accu\n done;\n !accu\n\n let filter_map_inplace f h =\n let rec do_bucket = function\n | Empty ->\n Empty\n | Cons(hk, c, rest) ->\n match H.get_key c, H.get_data c with\n | None, _ | _, None ->\n do_bucket rest\n | Some k, Some d ->\n match f k d with\n | None ->\n do_bucket rest\n | Some new_d ->\n H.set_key_data c k new_d;\n Cons(hk, c, do_bucket rest)\n in\n let d = h.data in\n for i = 0 to Array.length d - 1 do\n d.(i) <- do_bucket d.(i)\n done\n\n let length h = h.size\n\n let rec bucket_length accu = function\n | Empty -> accu\n | Cons(_, _, rest) -> bucket_length (accu + 1) rest\n\n let stats h =\n let mbl =\n Array.fold_left (fun m b -> Int.max m (bucket_length 0 b)) 0 h.data in\n let histo = Array.make (mbl + 1) 0 in\n Array.iter\n (fun b ->\n let l = bucket_length 0 b in\n histo.(l) <- histo.(l) + 1)\n h.data;\n { Hashtbl.num_bindings = h.size;\n num_buckets = Array.length h.data;\n max_bucket_length = mbl;\n bucket_histogram = histo }\n\n let rec bucket_length_alive accu = function\n | Empty -> accu\n | Cons(_, c, rest) when H.check_key c ->\n bucket_length_alive (accu + 1) rest\n | Cons(_, _, rest) -> bucket_length_alive accu rest\n\n let stats_alive h =\n let size = ref 0 in\n let mbl =\n Array.fold_left\n (fun m b -> Int.max m (bucket_length_alive 0 b)) 0 h.data\n in\n let histo = Array.make (mbl + 1) 0 in\n Array.iter\n (fun b ->\n let l = bucket_length_alive 0 b in\n size := !size + l;\n histo.(l) <- histo.(l) + 1)\n h.data;\n { Hashtbl.num_bindings = !size;\n num_buckets = Array.length h.data;\n max_bucket_length = mbl;\n bucket_histogram = histo }\n\n let to_seq tbl =\n (* capture current array, so that even if the table is resized we\n keep iterating on the same array *)\n let tbl_data = tbl.data in\n (* state: index * next bucket to traverse *)\n let rec aux i buck () = match buck with\n | Empty ->\n if i = Array.length tbl_data\n then Seq.Nil\n else aux(i+1) tbl_data.(i) ()\n | Cons (_, c, next) ->\n begin match H.get_key c, H.get_data c with\n | None, _ | _, None -> aux i next ()\n | Some key, Some data ->\n Seq.Cons ((key, data), aux i next)\n end\n in\n aux 0 Empty\n\n let to_seq_keys m = Seq.map fst (to_seq m)\n\n let to_seq_values m = Seq.map snd (to_seq m)\n\n let add_seq tbl i =\n Seq.iter (fun (k,v) -> add tbl k v) i\n\n let replace_seq tbl i =\n Seq.iter (fun (k,v) -> replace tbl k v) i\n\n let of_seq i =\n let tbl = create 16 in\n replace_seq tbl i;\n tbl\n\n end\nend\n\nmodule ObjEph = Obj.Ephemeron\n\nlet _obj_opt : Obj.t option -> 'a option = fun x ->\n match x with\n | None -> x\n | Some v -> Some (Obj.obj v)\n\n(** The previous function is typed so this one is also correct *)\nlet obj_opt : Obj.t option -> 'a option = fun x -> Obj.magic x\n\n\nmodule K1 = struct\n type ('k,'d) t = ObjEph.t\n\n let create () : ('k,'d) t = ObjEph.create 1\n\n let get_key (t:('k,'d) t) : 'k option = obj_opt (ObjEph.get_key t 0)\n let get_key_copy (t:('k,'d) t) : 'k option = obj_opt (ObjEph.get_key_copy t 0)\n let set_key (t:('k,'d) t) (k:'k) : unit = ObjEph.set_key t 0 (Obj.repr k)\n let unset_key (t:('k,'d) t) : unit = ObjEph.unset_key t 0\n let check_key (t:('k,'d) t) : bool = ObjEph.check_key t 0\n\n let blit_key (t1:('k,'d) t) (t2:('k,'d) t): unit =\n ObjEph.blit_key t1 0 t2 0 1\n\n let get_data (t:('k,'d) t) : 'd option = obj_opt (ObjEph.get_data t)\n let get_data_copy (t:('k,'d) t) : 'd option = obj_opt (ObjEph.get_data_copy t)\n let set_data (t:('k,'d) t) (d:'d) : unit = ObjEph.set_data t (Obj.repr d)\n let unset_data (t:('k,'d) t) : unit = ObjEph.unset_data t\n let check_data (t:('k,'d) t) : bool = ObjEph.check_data t\n let blit_data (t1:(_,'d) t) (t2:(_,'d) t) : unit = ObjEph.blit_data t1 t2\n\n let make key data =\n let eph = create () in\n set_data eph data;\n set_key eph key;\n eph\n\n let query eph key =\n match get_key eph with\n | None -> None\n | Some k when k == key -> get_data eph\n | Some _ -> None\n\n module MakeSeeded (H:Hashtbl.SeededHashedType) =\n GenHashTable.MakeSeeded(struct\n type 'a container = (H.t,'a) t\n type t = H.t\n let create k d =\n let c = create () in\n set_data c d;\n set_key c k;\n c\n let hash = H.hash\n let equal c k =\n (* {!get_key_copy} is not used because the equality of the user can be\n the physical equality *)\n match get_key c with\n | None -> GenHashTable.EDead\n | Some k' ->\n if H.equal k k' then GenHashTable.ETrue else GenHashTable.EFalse\n let get_data = get_data\n let get_key = get_key\n let set_key_data c k d =\n unset_data c;\n set_key c k;\n set_data c d\n let check_key = check_key\n end)\n\n module Make(H: Hashtbl.HashedType): (S with type key = H.t) =\n struct\n include MakeSeeded(struct\n type t = H.t\n let equal = H.equal\n let hash (_seed: int) x = H.hash x\n end)\n let create sz = create ~random:false sz\n let of_seq i =\n let tbl = create 16 in\n replace_seq tbl i;\n tbl\n end\n\n module Bucket = struct\n\n type nonrec ('k, 'd) t = ('k, 'd) t list ref\n let k1_make = make\n let make () = ref []\n let add b k d = b := k1_make k d :: !b\n\n let test_key k e =\n match get_key e with\n | Some x when x == k -> true\n | _ -> false\n\n let remove b k =\n let rec loop l acc =\n match l with\n | [] -> ()\n | h :: t when test_key k h -> b := List.rev_append acc t\n | h :: t -> loop t (h :: acc)\n in\n loop !b []\n\n let find b k =\n match List.find_opt (test_key k) !b with\n | Some e -> get_data e\n | None -> None\n\n let length b = List.length !b\n let clear b = b := []\n\n end\n\nend\n\nmodule K2 = struct\n type ('k1, 'k2, 'd) t = ObjEph.t\n\n let create () : ('k1,'k2,'d) t = ObjEph.create 2\n\n let get_key1 (t:('k1,'k2,'d) t) : 'k1 option = obj_opt (ObjEph.get_key t 0)\n let get_key1_copy (t:('k1,'k2,'d) t) : 'k1 option =\n obj_opt (ObjEph.get_key_copy t 0)\n let set_key1 (t:('k1,'k2,'d) t) (k:'k1) : unit =\n ObjEph.set_key t 0 (Obj.repr k)\n let unset_key1 (t:('k1,'k2,'d) t) : unit = ObjEph.unset_key t 0\n let check_key1 (t:('k1,'k2,'d) t) : bool = ObjEph.check_key t 0\n\n let get_key2 (t:('k1,'k2,'d) t) : 'k2 option = obj_opt (ObjEph.get_key t 1)\n let get_key2_copy (t:('k1,'k2,'d) t) : 'k2 option =\n obj_opt (ObjEph.get_key_copy t 1)\n let set_key2 (t:('k1,'k2,'d) t) (k:'k2) : unit =\n ObjEph.set_key t 1 (Obj.repr k)\n let unset_key2 (t:('k1,'k2,'d) t) : unit = ObjEph.unset_key t 1\n let check_key2 (t:('k1,'k2,'d) t) : bool = ObjEph.check_key t 1\n\n\n let blit_key1 (t1:('k1,_,_) t) (t2:('k1,_,_) t) : unit =\n ObjEph.blit_key t1 0 t2 0 1\n let blit_key2 (t1:(_,'k2,_) t) (t2:(_,'k2,_) t) : unit =\n ObjEph.blit_key t1 1 t2 1 1\n let blit_key12 (t1:('k1,'k2,_) t) (t2:('k1,'k2,_) t) : unit =\n ObjEph.blit_key t1 0 t2 0 2\n\n let get_data (t:('k1,'k2,'d) t) : 'd option = obj_opt (ObjEph.get_data t)\n let get_data_copy (t:('k1,'k2,'d) t) : 'd option =\n obj_opt (ObjEph.get_data_copy t)\n let set_data (t:('k1,'k2,'d) t) (d:'d) : unit =\n ObjEph.set_data t (Obj.repr d)\n let unset_data (t:('k1,'k2,'d) t) : unit = ObjEph.unset_data t\n let check_data (t:('k1,'k2,'d) t) : bool = ObjEph.check_data t\n let blit_data (t1:(_,_,'d) t) (t2:(_,_,'d) t) : unit = ObjEph.blit_data t1 t2\n\n let make key1 key2 data =\n let eph = create () in\n set_data eph data;\n set_key1 eph key1;\n set_key2 eph key2;\n ignore (Sys.opaque_identity key1);\n eph\n\n let query eph key1 key2 =\n match get_key1 eph with\n | None -> None\n | Some k when k == key1 ->\n begin match get_key2 eph with\n | None -> None\n | Some k when k == key2 -> get_data eph\n | Some _ -> None\n end\n | Some _ -> None\n\n module MakeSeeded\n (H1:Hashtbl.SeededHashedType)\n (H2:Hashtbl.SeededHashedType) =\n GenHashTable.MakeSeeded(struct\n type 'a container = (H1.t,H2.t,'a) t\n type t = H1.t * H2.t\n let create (k1,k2) d =\n let c = create () in\n set_data c d;\n set_key1 c k1; set_key2 c k2;\n c\n let hash seed (k1,k2) =\n H1.hash seed k1 + H2.hash seed k2 * 65599\n let equal c (k1,k2) =\n match get_key1 c, get_key2 c with\n | None, _ | _ , None -> GenHashTable.EDead\n | Some k1', Some k2' ->\n if H1.equal k1 k1' && H2.equal k2 k2'\n then GenHashTable.ETrue else GenHashTable.EFalse\n let get_data = get_data\n let get_key c =\n match get_key1 c, get_key2 c with\n | None, _ | _ , None -> None\n | Some k1', Some k2' -> Some (k1', k2')\n let set_key_data c (k1,k2) d =\n unset_data c;\n set_key1 c k1; set_key2 c k2;\n set_data c d\n let check_key c = check_key1 c && check_key2 c\n end)\n\n module Make(H1: Hashtbl.HashedType)(H2: Hashtbl.HashedType):\n (S with type key = H1.t * H2.t) =\n struct\n include MakeSeeded\n (struct\n type t = H1.t\n let equal = H1.equal\n let hash (_seed: int) x = H1.hash x\n end)\n (struct\n type t = H2.t\n let equal = H2.equal\n let hash (_seed: int) x = H2.hash x\n end)\n let create sz = create ~random:false sz\n let of_seq i =\n let tbl = create 16 in\n replace_seq tbl i;\n tbl\n end\n\n module Bucket = struct\n\n type nonrec ('k1, 'k2, 'd) t = ('k1, 'k2, 'd) t list ref\n let k2_make = make\n let make () = ref []\n let add b k1 k2 d = b := k2_make k1 k2 d :: !b\n\n let test_keys k1 k2 e =\n match get_key1 e, get_key2 e with\n | Some x1, Some x2 when x1 == k1 && x2 == k2 -> true\n | _ -> false\n\n let remove b k1 k2 =\n let rec loop l acc =\n match l with\n | [] -> ()\n | h :: t when test_keys k1 k2 h -> b := List.rev_append acc t\n | h :: t -> loop t (h :: acc)\n in\n loop !b []\n\n let find b k1 k2 =\n match List.find_opt (test_keys k1 k2) !b with\n | Some e -> get_data e\n | None -> None\n\n let length b = List.length !b\n let clear b = b := []\n\n end\n\nend\n\nmodule Kn = struct\n type ('k,'d) t = ObjEph.t\n\n let create n : ('k,'d) t = ObjEph.create n\n let length (k:('k,'d) t) : int = ObjEph.length k\n\n let get_key (t:('k,'d) t) (n:int) : 'k option = obj_opt (ObjEph.get_key t n)\n let get_key_copy (t:('k,'d) t) (n:int) : 'k option =\n obj_opt (ObjEph.get_key_copy t n)\n let set_key (t:('k,'d) t) (n:int) (k:'k) : unit =\n ObjEph.set_key t n (Obj.repr k)\n let unset_key (t:('k,'d) t) (n:int) : unit = ObjEph.unset_key t n\n let check_key (t:('k,'d) t) (n:int) : bool = ObjEph.check_key t n\n\n let blit_key (t1:('k,'d) t) (o1:int) (t2:('k,'d) t) (o2:int) (l:int) : unit =\n ObjEph.blit_key t1 o1 t2 o2 l\n\n let get_data (t:('k,'d) t) : 'd option = obj_opt (ObjEph.get_data t)\n let get_data_copy (t:('k,'d) t) : 'd option = obj_opt (ObjEph.get_data_copy t)\n let set_data (t:('k,'d) t) (d:'d) : unit = ObjEph.set_data t (Obj.repr d)\n let unset_data (t:('k,'d) t) : unit = ObjEph.unset_data t\n let check_data (t:('k,'d) t) : bool = ObjEph.check_data t\n let blit_data (t1:(_,'d) t) (t2:(_,'d) t) : unit = ObjEph.blit_data t1 t2\n\n let make keys data =\n let l = Array.length keys in\n let eph = create l in\n set_data eph data;\n for i = 0 to l - 1 do set_key eph i keys.(i) done;\n eph\n\n let query eph keys =\n let l = length eph in\n try\n if l <> Array.length keys then raise Exit;\n for i = 0 to l - 1 do\n match get_key eph i with\n | None -> raise Exit\n | Some k when k == keys.(i) -> ()\n | Some _ -> raise Exit\n done;\n get_data eph\n with Exit -> None\n\n module MakeSeeded (H:Hashtbl.SeededHashedType) =\n GenHashTable.MakeSeeded(struct\n type 'a container = (H.t,'a) t\n type t = H.t array\n let create k d =\n let c = create (Array.length k) in\n set_data c d;\n for i=0 to Array.length k -1 do\n set_key c i k.(i);\n done;\n c\n let hash seed k =\n let h = ref 0 in\n for i=0 to Array.length k -1 do\n h := H.hash seed k.(i) * 65599 + !h;\n done;\n !h\n let equal c k =\n let len = Array.length k in\n let len' = length c in\n if len != len' then GenHashTable.EFalse\n else\n let rec equal_array k c i =\n if i < 0 then GenHashTable.ETrue\n else\n match get_key c i with\n | None -> GenHashTable.EDead\n | Some ki ->\n if H.equal k.(i) ki\n then equal_array k c (i-1)\n else GenHashTable.EFalse\n in\n equal_array k c (len-1)\n let get_data = get_data\n let get_key c =\n let len = length c in\n if len = 0 then Some [||]\n else\n match get_key c 0 with\n | None -> None\n | Some k0 ->\n let rec fill a i =\n if i < 1 then Some a\n else\n match get_key c i with\n | None -> None\n | Some ki ->\n a.(i) <- ki;\n fill a (i-1)\n in\n let a = Array.make len k0 in\n fill a (len-1)\n let set_key_data c k d =\n unset_data c;\n for i=0 to Array.length k -1 do\n set_key c i k.(i);\n done;\n set_data c d\n let check_key c =\n let rec check c i =\n i < 0 || (check_key c i && check c (i-1)) in\n check c (length c - 1)\n end)\n\n module Make(H: Hashtbl.HashedType): (S with type key = H.t array) =\n struct\n include MakeSeeded(struct\n type t = H.t\n let equal = H.equal\n let hash (_seed: int) x = H.hash x\n end)\n let create sz = create ~random:false sz\n let of_seq i =\n let tbl = create 16 in\n replace_seq tbl i;\n tbl\n end\n\n module Bucket = struct\n\n type nonrec ('k, 'd) t = ('k, 'd) t list ref\n let kn_make = make\n let make () = ref []\n let add b k d = b := kn_make k d :: !b\n\n let test_keys k e =\n try\n if length e <> Array.length k then raise Exit;\n for i = 0 to Array.length k - 1 do\n match get_key e i with\n | Some x when x == k.(i) -> ()\n | _ -> raise Exit\n done;\n true\n with Exit -> false\n\n let remove b k =\n let rec loop l acc =\n match l with\n | [] -> ()\n | h :: t when test_keys k h -> b := List.rev_append acc t\n | h :: t -> loop t (h :: acc)\n in\n loop !b []\n\n let find b k =\n match List.find_opt (test_keys k) !b with\n | Some e -> get_data e\n | None -> None\n\n let length b = List.length !b\n let clear b = b := []\n\n end\n\nend\n","open! Import\nopen Std_internal\n\nlet randomize span ~percent ~scale =\n let mult = Percent.to_mult percent in\n if Float.( < ) mult 0. || Float.( > ) mult 1.\n then\n raise_s\n [%message \"Span.randomize: percent is out of range [0x, 1x]\" (percent : Percent.t)];\n let factor = Random.float_range (1. -. mult) (Float.one_ulp `Up (1. +. mult)) in\n scale span factor\n;;\n\nlet format_decimal n tenths units =\n assert (tenths >= 0 && tenths < 10);\n if n < 10 && tenths <> 0\n then sprintf \"%d.%d%s\" n tenths units\n else sprintf \"%d%s\" n units\n;;\n\nlet short_string ~sign ~hr ~min ~sec ~ms ~us ~ns =\n let s =\n if hr >= 24\n then format_decimal (hr / 24) (Int.of_float (Float.of_int (hr % 24) /. 2.4)) \"d\"\n else if hr > 0\n then format_decimal hr (min / 6) \"h\"\n else if min > 0\n then format_decimal min (sec / 6) \"m\"\n else if sec > 0\n then format_decimal sec (ms / 100) \"s\"\n else if ms > 0\n then format_decimal ms (us / 100) \"ms\"\n else if us > 0\n then format_decimal us (ns / 100) \"us\"\n else sprintf \"%ins\" ns\n in\n match (sign : Sign.t) with\n | Neg -> \"-\" ^ s\n | Zero | Pos -> s\n;;\n","(* This module is included in [Import]. It is aimed at modules that define the standard\n combinators for [sexp_of], [of_sexp], [compare] and [hash] and are included in\n [Import]. *)\n\ninclude (\n Shadow_stdlib :\n module type of struct\n include Shadow_stdlib\n end\n with type 'a ref := 'a ref\n with type ('a, 'b, 'c) format := ('a, 'b, 'c) format\n with type ('a, 'b, 'c, 'd) format4 := ('a, 'b, 'c, 'd) format4\n with type ('a, 'b, 'c, 'd, 'e, 'f) format6 := ('a, 'b, 'c, 'd, 'e, 'f) format6\n (* These modules are redefined in Base *)\n with module Array := Shadow_stdlib.Array\n with module Atomic := Shadow_stdlib.Atomic\n with module Bool := Shadow_stdlib.Bool\n with module Buffer := Shadow_stdlib.Buffer\n with module Bytes := Shadow_stdlib.Bytes\n with module Char := Shadow_stdlib.Char\n with module Either := Shadow_stdlib.Either\n with module Float := Shadow_stdlib.Float\n with module Hashtbl := Shadow_stdlib.Hashtbl\n with module Int := Shadow_stdlib.Int\n with module Int32 := Shadow_stdlib.Int32\n with module Int64 := Shadow_stdlib.Int64\n with module Lazy := Shadow_stdlib.Lazy\n with module List := Shadow_stdlib.List\n with module Map := Shadow_stdlib.Map\n with module Nativeint := Shadow_stdlib.Nativeint\n with module Option := Shadow_stdlib.Option\n with module Printf := Shadow_stdlib.Printf\n with module Queue := Shadow_stdlib.Queue\n with module Random := Shadow_stdlib.Random\n with module Result := Shadow_stdlib.Result\n with module Set := Shadow_stdlib.Set\n with module Stack := Shadow_stdlib.Stack\n with module String := Shadow_stdlib.String\n with module Sys := Shadow_stdlib.Sys\n with module Uchar := Shadow_stdlib.Uchar\n with module Unit := Shadow_stdlib.Unit) [@ocaml.warning \"-3\"]\n\ntype 'a ref = 'a Caml.ref = { mutable contents : 'a }\n\n(* Reshuffle [Caml] so that we choose the modules using labels when available. *)\nmodule Caml = struct\n\n module Arg = Caml.Arg (** @canonical Caml.Arg *)\n\n module Array = Caml.StdLabels.Array (** @canonical Caml.StdLabels.Array *)\n\n module Bool = Caml.Bool (** @canonical Caml.Bool *)\n\n module Buffer = Caml.Buffer (** @canonical Caml.Buffer *)\n\n module Bytes = Caml.StdLabels.Bytes (** @canonical Caml.StdLabels.Bytes *)\n\n module Char = Caml.Char (** @canonical Caml.Char *)\n\n module Ephemeron = Caml.Ephemeron (** @canonical Caml.Ephemeron *)\n\n module Float = Caml.Float (** @canonical Caml.Float *)\n\n module Format = Caml.Format (** @canonical Caml.Format *)\n\n module Fun = Caml.Fun (** @canonical Caml.Fun *)\n\n module Gc = Caml.Gc (** @canonical Caml.Gc *)\n\n module Hashtbl = Caml.MoreLabels.Hashtbl (** @canonical Caml.MoreLabels.Hashtbl *)\n\n module Int32 = Caml.Int32 (** @canonical Caml.Int32 *)\n\n module Int = Caml.Int (** @canonical Caml.Int *)\n\n module Int64 = Caml.Int64 (** @canonical Caml.Int64 *)\n\n module Lazy = Caml.Lazy (** @canonical Caml.Lazy *)\n\n module Lexing = Caml.Lexing (** @canonical Caml.Lexing *)\n\n module List = Caml.StdLabels.List (** @canonical Caml.StdLabels.List *)\n\n module Map = Caml.MoreLabels.Map (** @canonical Caml.MoreLabels.Map *)\n\n module Nativeint = Caml.Nativeint (** @canonical Caml.Nativeint *)\n\n module Obj = Caml.Obj (** @canonical Caml.Obj *)\n\n module Option = Caml.Option (** @canonical Caml.Option *)\n\n module Parsing = Caml.Parsing (** @canonical Caml.Parsing *)\n\n module Printexc = Caml.Printexc (** @canonical Caml.Printexc *)\n\n module Printf = Caml.Printf (** @canonical Caml.Printf *)\n\n module Queue = Caml.Queue (** @canonical Caml.Queue *)\n\n module Random = Caml.Random (** @canonical Caml.Random *)\n\n module Result = Caml.Result (** @canonical Caml.Result *)\n\n module Scanf = Caml.Scanf (** @canonical Caml.Scanf *)\n\n module Seq = Caml.Seq (** @canonical Caml.Seq *)\n\n module Set = Caml.MoreLabels.Set (** @canonical Caml.MoreLabels.Set *)\n\n module Stack = Caml.Stack (** @canonical Caml.Stack *)\n\n module Stream = Caml.Stream [@ocaml.warning \"-3\"] (** @canonical Caml.Stream *)\n\n module String = Caml.StdLabels.String (** @canonical Caml.StdLabels.String *)\n\n module Sys = Caml.Sys (** @canonical Caml.Sys *)\n\n module Uchar = Caml.Uchar (** @canonical Caml.Uchar *)\n\n module Unit = Caml.Unit (** @canonical Caml.Unit *)\n\n include Pervasives [@ocaml.warning \"-3\"]\n\n exception Not_found = Caml.Not_found\nend\n\nexternal ( |> ) : 'a -> ('a -> 'b) -> 'b = \"%revapply\"\n\n(* These need to be declared as an external to get the lazy behavior *)\nexternal ( && ) : bool -> bool -> bool = \"%sequand\"\nexternal ( || ) : bool -> bool -> bool = \"%sequor\"\nexternal not : bool -> bool = \"%boolnot\"\n\n(* We use [Obj.magic] here as other implementations generate a conditional jump and the\n performance difference is noticeable. *)\nlet bool_to_int (x : bool) : int = Caml.Obj.magic x\n\n(* This need to be declared as an external for the warnings to work properly *)\nexternal ignore : _ -> unit = \"%ignore\"\n\nlet ( != ) = Caml.( != )\nlet ( * ) = Caml.( * )\nlet ( ** ) = Caml.( ** )\nlet ( *. ) = Caml.( *. )\nlet ( + ) = Caml.( + )\nlet ( +. ) = Caml.( +. )\nlet ( - ) = Caml.( - )\nlet ( -. ) = Caml.( -. )\nlet ( / ) = Caml.( / )\nlet ( /. ) = Caml.( /. )\n\nmodule Poly = Poly0 (** @canonical Base.Poly *)\n\nmodule Int_replace_polymorphic_compare = struct\n let ( < ) (x : int) y = Poly.( < ) x y\n let ( <= ) (x : int) y = Poly.( <= ) x y\n let ( <> ) (x : int) y = Poly.( <> ) x y\n let ( = ) (x : int) y = Poly.( = ) x y\n let ( > ) (x : int) y = Poly.( > ) x y\n let ( >= ) (x : int) y = Poly.( >= ) x y\n let compare (x : int) y = bool_to_int (x > y) - bool_to_int (x < y)\n let ascending (x : int) y = compare x y\n let descending (x : int) y = compare y x\n let equal (x : int) y = Poly.equal x y\n let max (x : int) y = if x >= y then x else y\n let min (x : int) y = if x <= y then x else y\nend\n\ninclude Int_replace_polymorphic_compare\n\nmodule Int32_replace_polymorphic_compare = struct\n let ( < ) (x : Caml.Int32.t) y = Poly.( < ) x y\n let ( <= ) (x : Caml.Int32.t) y = Poly.( <= ) x y\n let ( <> ) (x : Caml.Int32.t) y = Poly.( <> ) x y\n let ( = ) (x : Caml.Int32.t) y = Poly.( = ) x y\n let ( > ) (x : Caml.Int32.t) y = Poly.( > ) x y\n let ( >= ) (x : Caml.Int32.t) y = Poly.( >= ) x y\n let ascending (x : Caml.Int32.t) y = Poly.ascending x y\n let descending (x : Caml.Int32.t) y = Poly.descending x y\n let compare (x : Caml.Int32.t) y = Poly.compare x y\n let equal (x : Caml.Int32.t) y = Poly.equal x y\n let max (x : Caml.Int32.t) y = if x >= y then x else y\n let min (x : Caml.Int32.t) y = if x <= y then x else y\nend\n\nmodule Int64_replace_polymorphic_compare = struct\n let ( < ) (x : Caml.Int64.t) y = Poly.( < ) x y\n let ( <= ) (x : Caml.Int64.t) y = Poly.( <= ) x y\n let ( <> ) (x : Caml.Int64.t) y = Poly.( <> ) x y\n let ( = ) (x : Caml.Int64.t) y = Poly.( = ) x y\n let ( > ) (x : Caml.Int64.t) y = Poly.( > ) x y\n let ( >= ) (x : Caml.Int64.t) y = Poly.( >= ) x y\n let ascending (x : Caml.Int64.t) y = Poly.ascending x y\n let descending (x : Caml.Int64.t) y = Poly.descending x y\n let compare (x : Caml.Int64.t) y = Poly.compare x y\n let equal (x : Caml.Int64.t) y = Poly.equal x y\n let max (x : Caml.Int64.t) y = if x >= y then x else y\n let min (x : Caml.Int64.t) y = if x <= y then x else y\nend\n\nmodule Nativeint_replace_polymorphic_compare = struct\n let ( < ) (x : Caml.Nativeint.t) y = Poly.( < ) x y\n let ( <= ) (x : Caml.Nativeint.t) y = Poly.( <= ) x y\n let ( <> ) (x : Caml.Nativeint.t) y = Poly.( <> ) x y\n let ( = ) (x : Caml.Nativeint.t) y = Poly.( = ) x y\n let ( > ) (x : Caml.Nativeint.t) y = Poly.( > ) x y\n let ( >= ) (x : Caml.Nativeint.t) y = Poly.( >= ) x y\n let ascending (x : Caml.Nativeint.t) y = Poly.ascending x y\n let descending (x : Caml.Nativeint.t) y = Poly.descending x y\n let compare (x : Caml.Nativeint.t) y = Poly.compare x y\n let equal (x : Caml.Nativeint.t) y = Poly.equal x y\n let max (x : Caml.Nativeint.t) y = if x >= y then x else y\n let min (x : Caml.Nativeint.t) y = if x <= y then x else y\nend\n\nmodule Bool_replace_polymorphic_compare = struct\n let ( < ) (x : bool) y = Poly.( < ) x y\n let ( <= ) (x : bool) y = Poly.( <= ) x y\n let ( <> ) (x : bool) y = Poly.( <> ) x y\n let ( = ) (x : bool) y = Poly.( = ) x y\n let ( > ) (x : bool) y = Poly.( > ) x y\n let ( >= ) (x : bool) y = Poly.( >= ) x y\n let ascending (x : bool) y = Poly.ascending x y\n let descending (x : bool) y = Poly.descending x y\n let compare (x : bool) y = Poly.compare x y\n let equal (x : bool) y = Poly.equal x y\n let max (x : bool) y = if x >= y then x else y\n let min (x : bool) y = if x <= y then x else y\nend\n\nmodule Char_replace_polymorphic_compare = struct\n let ( < ) (x : char) y = Poly.( < ) x y\n let ( <= ) (x : char) y = Poly.( <= ) x y\n let ( <> ) (x : char) y = Poly.( <> ) x y\n let ( = ) (x : char) y = Poly.( = ) x y\n let ( > ) (x : char) y = Poly.( > ) x y\n let ( >= ) (x : char) y = Poly.( >= ) x y\n let ascending (x : char) y = Poly.ascending x y\n let descending (x : char) y = Poly.descending x y\n let compare (x : char) y = Poly.compare x y\n let equal (x : char) y = Poly.equal x y\n let max (x : char) y = if x >= y then x else y\n let min (x : char) y = if x <= y then x else y\nend\n\nmodule Uchar_replace_polymorphic_compare = struct\n let i x = Caml.Uchar.to_int x\n let ( < ) (x : Caml.Uchar.t) y = Int_replace_polymorphic_compare.( < ) (i x) (i y)\n let ( <= ) (x : Caml.Uchar.t) y = Int_replace_polymorphic_compare.( <= ) (i x) (i y)\n let ( <> ) (x : Caml.Uchar.t) y = Int_replace_polymorphic_compare.( <> ) (i x) (i y)\n let ( = ) (x : Caml.Uchar.t) y = Int_replace_polymorphic_compare.( = ) (i x) (i y)\n let ( > ) (x : Caml.Uchar.t) y = Int_replace_polymorphic_compare.( > ) (i x) (i y)\n let ( >= ) (x : Caml.Uchar.t) y = Int_replace_polymorphic_compare.( >= ) (i x) (i y)\n\n let ascending (x : Caml.Uchar.t) y =\n Int_replace_polymorphic_compare.ascending (i x) (i y)\n ;;\n\n let descending (x : Caml.Uchar.t) y =\n Int_replace_polymorphic_compare.descending (i x) (i y)\n ;;\n\n let compare (x : Caml.Uchar.t) y = Int_replace_polymorphic_compare.compare (i x) (i y)\n let equal (x : Caml.Uchar.t) y = Int_replace_polymorphic_compare.equal (i x) (i y)\n let max (x : Caml.Uchar.t) y = if x >= y then x else y\n let min (x : Caml.Uchar.t) y = if x <= y then x else y\nend\n\nmodule Float_replace_polymorphic_compare = struct\n let ( < ) (x : float) y = Poly.( < ) x y\n let ( <= ) (x : float) y = Poly.( <= ) x y\n let ( <> ) (x : float) y = Poly.( <> ) x y\n let ( = ) (x : float) y = Poly.( = ) x y\n let ( > ) (x : float) y = Poly.( > ) x y\n let ( >= ) (x : float) y = Poly.( >= ) x y\n let ascending (x : float) y = Poly.ascending x y\n let descending (x : float) y = Poly.descending x y\n let compare (x : float) y = Poly.compare x y\n let equal (x : float) y = Poly.equal x y\n let max (x : float) y = if x >= y then x else y\n let min (x : float) y = if x <= y then x else y\nend\n\nmodule String_replace_polymorphic_compare = struct\n let ( < ) (x : string) y = Poly.( < ) x y\n let ( <= ) (x : string) y = Poly.( <= ) x y\n let ( <> ) (x : string) y = Poly.( <> ) x y\n let ( = ) (x : string) y = Poly.( = ) x y\n let ( > ) (x : string) y = Poly.( > ) x y\n let ( >= ) (x : string) y = Poly.( >= ) x y\n let ascending (x : string) y = Poly.ascending x y\n let descending (x : string) y = Poly.descending x y\n let compare (x : string) y = Poly.compare x y\n let equal (x : string) y = Poly.equal x y\n let max (x : string) y = if x >= y then x else y\n let min (x : string) y = if x <= y then x else y\nend\n\nmodule Bytes_replace_polymorphic_compare = struct\n let ( < ) (x : bytes) y = Poly.( < ) x y\n let ( <= ) (x : bytes) y = Poly.( <= ) x y\n let ( <> ) (x : bytes) y = Poly.( <> ) x y\n let ( = ) (x : bytes) y = Poly.( = ) x y\n let ( > ) (x : bytes) y = Poly.( > ) x y\n let ( >= ) (x : bytes) y = Poly.( >= ) x y\n let ascending (x : bytes) y = Poly.ascending x y\n let descending (x : bytes) y = Poly.descending x y\n let compare (x : bytes) y = Poly.compare x y\n let equal (x : bytes) y = Poly.equal x y\n let max (x : bytes) y = if x >= y then x else y\n let min (x : bytes) y = if x <= y then x else y\nend\n\n(* This needs to be defined as an external so that the compiler can specialize it as a\n direct set or caml_modify *)\nexternal ( := ) : 'a ref -> 'a -> unit = \"%setfield0\"\n\n(* These need to be defined as an external otherwise the compiler won't unbox\n references *)\nexternal ( ! ) : 'a ref -> 'a = \"%field0\"\nexternal ref : 'a -> 'a ref = \"%makemutable\"\n\nlet ( @ ) = Caml.( @ )\nlet ( ^ ) = Caml.( ^ )\nlet ( ~- ) = Caml.( ~- )\nlet ( ~-. ) = Caml.( ~-. )\nlet ( asr ) = Caml.( asr )\nlet ( land ) = Caml.( land )\nlet lnot = Caml.lnot\nlet ( lor ) = Caml.( lor )\nlet ( lsl ) = Caml.( lsl )\nlet ( lsr ) = Caml.( lsr )\nlet ( lxor ) = Caml.( lxor )\nlet ( mod ) = Caml.( mod )\nlet abs = Caml.abs\nlet failwith = Caml.failwith\nlet fst = Caml.fst\nlet invalid_arg = Caml.invalid_arg\nlet snd = Caml.snd\n\n(* [raise] needs to be defined as an external as the compiler automatically replaces\n '%raise' by '%reraise' when appropriate. *)\nexternal raise : exn -> _ = \"%raise\"\n\nlet phys_equal = Caml.( == )\nlet decr = Caml.decr\nlet incr = Caml.incr\n\n(* used by sexp_conv, which float0 depends on through option *)\nlet float_of_string = Caml.float_of_string\n\n(* [am_testing] is used in a few places to behave differently when in testing mode, such\n as in [random.ml]. [am_testing] is implemented using [Base_am_testing], a weak C/js\n primitive that returns [false], but when linking an inline-test-runner executable, is\n overridden by another primitive that returns [true]. *)\nexternal am_testing : unit -> bool = \"Base_am_testing\"\n\nlet am_testing = am_testing ()\n","open! Import0\ninclude Caml.Printf\n\n(** failwith, invalid_arg, and exit accepting printf's format. *)\n\nlet failwithf fmt = ksprintf (fun s () -> failwith s) fmt\nlet invalid_argf fmt = ksprintf (fun s () -> invalid_arg s) fmt\n","(* [Array0] defines array functions that are primitives or can be simply defined in terms\n of [Caml.Array]. [Array0] is intended to completely express the part of [Caml.Array]\n that [Base] uses -- no other file in Base other than array0.ml should use [Caml.Array].\n [Array0] has few dependencies, and so is available early in Base's build order. All\n Base files that need to use arrays and come before [Base.Array] in build order should\n do [module Array = Array0]. This includes uses of subscript syntax ([x.(i)], [x.(i) <-\n e]), which the OCaml parser desugars into calls to [Array.get] and [Array.set].\n Defining [module Array = Array0] is also necessary because it prevents ocamldep from\n mistakenly causing a file to depend on [Base.Array]. *)\n\nopen! Import0\nmodule Sys = Sys0\n\nlet invalid_argf = Printf.invalid_argf\n\nmodule Array = struct\n external create : int -> 'a -> 'a array = \"caml_make_vect\"\n external get : 'a array -> int -> 'a = \"%array_safe_get\"\n external length : 'a array -> int = \"%array_length\"\n external set : 'a array -> int -> 'a -> unit = \"%array_safe_set\"\n external unsafe_get : 'a array -> int -> 'a = \"%array_unsafe_get\"\n external unsafe_set : 'a array -> int -> 'a -> unit = \"%array_unsafe_set\"\nend\n\ninclude Array\n\nlet max_length = Sys.max_array_length\n\nlet create ~len x =\n try create len x with\n | Invalid_argument _ -> invalid_argf \"Array.create ~len:%d: invalid length\" len ()\n;;\n\nlet append = Caml.Array.append\nlet blit = Caml.Array.blit\nlet concat = Caml.Array.concat\nlet copy = Caml.Array.copy\nlet fill = Caml.Array.fill\nlet init = Caml.Array.init\nlet make_matrix = Caml.Array.make_matrix\nlet of_list = Caml.Array.of_list\nlet sub = Caml.Array.sub\nlet to_list = Caml.Array.to_list\n\n(* These are eta expanded in order to permute parameter order to follow Base\n conventions. *)\nlet fold t ~init ~f = Caml.Array.fold_left t ~init ~f\nlet fold_right t ~f ~init = Caml.Array.fold_right t ~f ~init\nlet iter t ~f = Caml.Array.iter t ~f\nlet iteri t ~f = Caml.Array.iteri t ~f\nlet map t ~f = Caml.Array.map t ~f\nlet mapi t ~f = Caml.Array.mapi t ~f\nlet stable_sort t ~compare = Caml.Array.stable_sort t ~cmp:compare\n\nlet swap t i j =\n let tmp = t.(i) in\n t.(i) <- t.(j);\n t.(j) <- tmp\n;;\n","(* [Char0] defines char functions that are primitives or can be simply defined in terms of\n [Caml.Char]. [Char0] is intended to completely express the part of [Caml.Char] that\n [Base] uses -- no other file in Base other than char0.ml should use [Caml.Char].\n [Char0] has few dependencies, and so is available early in Base's build order. All\n Base files that need to use chars and come before [Base.Char] in build order should do\n [module Char = Char0]. Defining [module Char = Char0] is also necessary because it\n prevents ocamldep from mistakenly causing a file to depend on [Base.Char]. *)\n\nopen! Import0\n\nlet failwithf = Printf.failwithf\nlet escaped = Caml.Char.escaped\nlet lowercase = Caml.Char.lowercase_ascii\nlet to_int = Caml.Char.code\nlet unsafe_of_int = Caml.Char.unsafe_chr\nlet uppercase = Caml.Char.uppercase_ascii\n\n(* We use our own range test when converting integers to chars rather than\n calling [Caml.Char.chr] because it's simple and it saves us a function call\n and the try-with (exceptions cost, especially in the world with backtraces). *)\nlet int_is_ok i = 0 <= i && i <= 255\nlet min_value = unsafe_of_int 0\nlet max_value = unsafe_of_int 255\nlet of_int i = if int_is_ok i then Some (unsafe_of_int i) else None\n\nlet of_int_exn i =\n if int_is_ok i\n then unsafe_of_int i\n else failwithf \"Char.of_int_exn got integer out of range: %d\" i ()\n;;\n\nlet equal (t1 : char) t2 = Poly.equal t1 t2\n","(* [List0] defines list functions that are primitives or can be simply defined in terms of\n [Caml.List]. [List0] is intended to completely express the part of [Caml.List] that\n [Base] uses -- no other file in Base other than list0.ml should use [Caml.List].\n [List0] has few dependencies, and so is available early in Base's build order. All\n Base files that need to use lists and come before [Base.List] in build order should do\n [module List = List0]. Defining [module List = List0] is also necessary because it\n prevents ocamldep from mistakenly causing a file to depend on [Base.List]. *)\n\nopen! Import0\n\nlet hd_exn = Caml.List.hd\nlet length = Caml.List.length\nlet rev_append = Caml.List.rev_append\nlet tl_exn = Caml.List.tl\nlet unzip = Caml.List.split\n\n(* These are eta expanded in order to permute parameter order to follow Base\n conventions. *)\nlet exists t ~f = Caml.List.exists t ~f\nlet exists2_ok l1 l2 ~f = Caml.List.exists2 l1 l2 ~f\nlet fold t ~init ~f = Caml.List.fold_left t ~f ~init\nlet fold2_ok l1 l2 ~init ~f = Caml.List.fold_left2 l1 l2 ~init ~f\nlet for_all t ~f = Caml.List.for_all t ~f\nlet for_all2_ok l1 l2 ~f = Caml.List.for_all2 l1 l2 ~f\nlet iter t ~f = Caml.List.iter t ~f\nlet iter2_ok l1 l2 ~f = Caml.List.iter2 l1 l2 ~f\nlet nontail_map t ~f = Caml.List.map t ~f\nlet nontail_mapi t ~f = Caml.List.mapi t ~f\nlet partition t ~f = Caml.List.partition t ~f\nlet rev_map t ~f = Caml.List.rev_map t ~f\nlet rev_map2_ok l1 l2 ~f = Caml.List.rev_map2 l1 l2 ~f\nlet sort l ~compare = Caml.List.sort l ~cmp:compare\nlet stable_sort l ~compare = Caml.List.stable_sort l ~cmp:compare\n\nlet rev = function\n | ([] | [ _ ]) as res -> res\n | x :: y :: rest -> rev_append rest [ y; x ]\n;;\n","open Core_kernel\n\nmodule type S = sig\n type 'a t = private 'a list\n\n include Container.S1 with type 'a t := 'a t\n\n val of_list : 'a list -> 'a t\n\n val init : int -> f:(int -> 'a) -> 'a t\n\n val map : 'a t -> f:('a -> 'b) -> 'b t\n\n val pad : padding_length:int -> zero:'a -> 'a t -> 'a t\nend\n\nmodule T = struct\n include List\n\n let of_list = Fn.id\nend\n\nmodule Msb_first = struct\n include T\n\n let of_lsb_first = List.rev\n\n let pad ~padding_length ~zero xs =\n List.init padding_length ~f:(fun _ -> zero) @ xs\nend\n\nmodule Lsb_first = struct\n include T\n\n let of_msb_first = List.rev\n\n let pad ~padding_length ~zero xs =\n xs @ List.init padding_length ~f:(fun _ -> zero)\nend\n\nlet pad_to_triple_list ~default xs =\n let rec go acc = function\n | [] ->\n List.rev acc\n | [ x1 ] ->\n List.rev ((x1, default, default) :: acc)\n | [ x1; x2 ] ->\n List.rev ((x1, x2, default) :: acc)\n | x1 :: x2 :: x3 :: xs ->\n go ((x1, x2, x3) :: acc) xs\n in\n go [] xs\n","(*\n This is the interface to the runtime support for [ppx_hash].\n\n The [ppx_hash] syntax extension supports: [@@deriving hash] and [%hash_fold: TYPE] and\n [%hash: TYPE]\n\n For type [t] a function [hash_fold_t] of type [Hash.state -> t -> Hash.state] is\n generated.\n\n The generated [hash_fold_] function is compositional, following the structure of the\n type; allowing user overrides at every level. This is in contrast to ocaml's builtin\n polymorphic hashing [Hashtbl.hash] which ignores user overrides.\n\n The generator also provides a direct hash-function [hash] (named [hash_] when !=\n \"t\") of type: [t -> Hash.hash_value].\n\n The folding hash function can be accessed as [%hash_fold: TYPE]\n The direct hash function can be accessed as [%hash: TYPE]\n*)\n\nopen! Import0\nmodule Array = Array0\nmodule Char = Char0\nmodule Int = Int0\nmodule List = List0\ninclude Hash_intf\n\n(** Builtin folding-style hash functions, abstracted over [Hash_intf.S] *)\nmodule Folding (Hash : Hash_intf.S) :\n Hash_intf.Builtin_intf\n with type state = Hash.state\n and type hash_value = Hash.hash_value = struct\n type state = Hash.state\n type hash_value = Hash.hash_value\n type 'a folder = state -> 'a -> state\n\n let hash_fold_unit s () = s\n let hash_fold_int = Hash.fold_int\n let hash_fold_int64 = Hash.fold_int64\n let hash_fold_float = Hash.fold_float\n let hash_fold_string = Hash.fold_string\n let as_int f s x = hash_fold_int s (f x)\n\n (* This ignores the sign bit on 32-bit architectures, but it's unlikely to lead to\n frequent collisions (min_value colliding with 0 is the most likely one). *)\n let hash_fold_int32 = as_int Caml.Int32.to_int\n let hash_fold_char = as_int Char.to_int\n\n let hash_fold_bool =\n as_int (function\n | true -> 1\n | false -> 0)\n ;;\n\n let hash_fold_nativeint s x = hash_fold_int64 s (Caml.Int64.of_nativeint x)\n\n let hash_fold_option hash_fold_elem s = function\n | None -> hash_fold_int s 0\n | Some x -> hash_fold_elem (hash_fold_int s 1) x\n ;;\n\n let rec hash_fold_list_body hash_fold_elem s list =\n match list with\n | [] -> s\n | x :: xs -> hash_fold_list_body hash_fold_elem (hash_fold_elem s x) xs\n ;;\n\n let hash_fold_list hash_fold_elem s list =\n (* The [length] of the list must be incorporated into the hash-state so values of\n types such as [unit list] - ([], [()], [();()],..) are hashed differently. *)\n (* The [length] must come before the elements to avoid a violation of the rule\n enforced by Perfect_hash. *)\n let s = hash_fold_int s (List.length list) in\n let s = hash_fold_list_body hash_fold_elem s list in\n s\n ;;\n\n let hash_fold_lazy_t hash_fold_elem s x = hash_fold_elem s (Caml.Lazy.force x)\n let hash_fold_ref_frozen hash_fold_elem s x = hash_fold_elem s !x\n\n let rec hash_fold_array_frozen_i hash_fold_elem s array i =\n if i = Array.length array\n then s\n else (\n let e = Array.unsafe_get array i in\n hash_fold_array_frozen_i hash_fold_elem (hash_fold_elem s e) array (i + 1))\n ;;\n\n let hash_fold_array_frozen hash_fold_elem s array =\n hash_fold_array_frozen_i\n (* [length] must be incorporated for arrays, as it is for lists. See comment above *)\n hash_fold_elem\n (hash_fold_int s (Array.length array))\n array\n 0\n ;;\n\n (* the duplication here is because we think\n ocaml can't eliminate indirect function calls otherwise. *)\n let hash_nativeint x =\n Hash.get_hash_value (hash_fold_nativeint (Hash.reset (Hash.alloc ())) x)\n ;;\n\n let hash_int64 x = Hash.get_hash_value (hash_fold_int64 (Hash.reset (Hash.alloc ())) x)\n let hash_int32 x = Hash.get_hash_value (hash_fold_int32 (Hash.reset (Hash.alloc ())) x)\n let hash_char x = Hash.get_hash_value (hash_fold_char (Hash.reset (Hash.alloc ())) x)\n let hash_int x = Hash.get_hash_value (hash_fold_int (Hash.reset (Hash.alloc ())) x)\n let hash_bool x = Hash.get_hash_value (hash_fold_bool (Hash.reset (Hash.alloc ())) x)\n\n let hash_string x =\n Hash.get_hash_value (hash_fold_string (Hash.reset (Hash.alloc ())) x)\n ;;\n\n let hash_float x = Hash.get_hash_value (hash_fold_float (Hash.reset (Hash.alloc ())) x)\n let hash_unit x = Hash.get_hash_value (hash_fold_unit (Hash.reset (Hash.alloc ())) x)\nend\n\nmodule F (Hash : Hash_intf.S) :\n Hash_intf.Full\n with type hash_value = Hash.hash_value\n and type state = Hash.state\n and type seed = Hash.seed = struct\n include Hash\n\n type 'a folder = state -> 'a -> state\n\n let create ?seed () = reset ?seed (alloc ())\n let of_fold hash_fold_t t = get_hash_value (hash_fold_t (create ()) t)\n\n module Builtin = Folding (Hash)\n\n let run ?seed folder x =\n Hash.get_hash_value (folder (Hash.reset ?seed (Hash.alloc ())) x)\n ;;\nend\n\nmodule Internalhash : sig\n include\n Hash_intf.S\n with type state = Base_internalhash_types.state\n (* We give a concrete type for [state], albeit only partially exposed (see\n Base_internalhash_types), so that it unifies with the same type in [Base_boot],\n and to allow optimizations for the immediate type. *)\n and type seed = Base_internalhash_types.seed\n and type hash_value = Base_internalhash_types.hash_value\n\n external fold_int64 : state -> int64 -> state = \"Base_internalhash_fold_int64\"\n [@@noalloc]\n\n external fold_int : state -> int -> state = \"Base_internalhash_fold_int\" [@@noalloc]\n\n external fold_float : state -> float -> state = \"Base_internalhash_fold_float\"\n [@@noalloc]\n\n external fold_string : state -> string -> state = \"Base_internalhash_fold_string\"\n [@@noalloc]\n\n external get_hash_value : state -> hash_value = \"Base_internalhash_get_hash_value\"\n [@@noalloc]\nend = struct\n let description = \"internalhash\"\n\n include Base_internalhash_types\n\n let alloc () = create_seeded 0\n let reset ?(seed = 0) _t = create_seeded seed\n\n module For_tests = struct\n let compare_state (a : state) (b : state) = compare (a :> int) (b :> int)\n let state_to_string (state : state) = Int.to_string (state :> int)\n end\nend\n\nmodule T = struct\n include Internalhash\n\n type 'a folder = state -> 'a -> state\n\n let create ?seed () = reset ?seed (alloc ())\n let run ?seed folder x = get_hash_value (folder (reset ?seed (alloc ())) x)\n let of_fold hash_fold_t t = get_hash_value (hash_fold_t (create ()) t)\n\n module Builtin = struct\n module Folding = Folding (Internalhash)\n\n include (\n Folding :\n Hash_intf.Builtin_hash_fold_intf\n with type state := state\n and type 'a folder := 'a folder)\n\n let hash_nativeint = Folding.hash_nativeint\n let hash_int64 = Folding.hash_int64\n let hash_int32 = Folding.hash_int32\n let hash_string = Folding.hash_string\n\n (* [Folding] provides some default implementations for the [hash_*] functions below,\n but they are inefficient for some use-cases because of the use of the [hash_fold]\n functions. At this point, the [hash_value] type has been fixed to [int], so this\n module can provide specialized implementations. *)\n\n let hash_char = Char0.to_int\n\n (* This hash was chosen from here: https://gist.github.com/badboy/6267743\n\n It attempts to fulfill the primary goals of a non-cryptographic hash function:\n\n - a bit change in the input should change ~1/2 of the output bits\n - the output should be uniformly distributed across the output range\n - inputs that are close to each other shouldn't lead to outputs that are close to\n each other.\n - all bits of the input are used in generating the output\n\n In our case we also want it to be fast, non-allocating, and inlinable. *)\n let[@inline always] hash_int (t : int) =\n let t = lnot t + (t lsl 21) in\n let t = t lxor (t lsr 24) in\n let t = t + (t lsl 3) + (t lsl 8) in\n let t = t lxor (t lsr 14) in\n let t = t + (t lsl 2) + (t lsl 4) in\n let t = t lxor (t lsr 28) in\n t + (t lsl 31)\n ;;\n\n let hash_bool x = if x then 1 else 0\n\n external hash_float : float -> int = \"Base_hash_double\" [@@noalloc]\n\n let hash_unit () = 0\n end\nend\n\ninclude T\n","open Import0\n\nlet phys_equal = phys_equal\n\nexternal polymorphic_compare : 'a -> 'a -> int = \"%compare\"\nexternal polymorphic_equal : 'a -> 'a -> bool = \"%equal\"\nexternal ( && ) : bool -> bool -> bool = \"%sequand\"\n\nlet compare_abstract ~type_name _ _ =\n Printf.ksprintf\n failwith\n \"Compare called on the type %s, which is abstract in an implementation.\"\n type_name\n;;\n\nlet equal_abstract ~type_name _ _ =\n Printf.ksprintf\n failwith\n \"Equal called on the type %s, which is abstract in an implementation.\"\n type_name\n;;\n\ntype 'a compare = 'a -> 'a -> int\ntype 'a equal = 'a -> 'a -> bool\n\nmodule Builtin = struct\n let compare_bool : bool compare = Poly.compare\n let compare_char : char compare = Poly.compare\n let compare_float : float compare = Poly.compare\n let compare_int : int compare = Poly.compare\n let compare_int32 : int32 compare = Poly.compare\n let compare_int64 : int64 compare = Poly.compare\n let compare_nativeint : nativeint compare = Poly.compare\n let compare_string : string compare = Poly.compare\n let compare_unit : unit compare = Poly.compare\n\n let compare_array compare_elt a b =\n if phys_equal a b\n then 0\n else (\n let len_a = Array0.length a in\n let len_b = Array0.length b in\n let ret = compare len_a len_b in\n if ret <> 0\n then ret\n else (\n let rec loop i =\n if i = len_a\n then 0\n else (\n let l = Array0.unsafe_get a i\n and r = Array0.unsafe_get b i in\n let res = compare_elt l r in\n if res <> 0 then res else loop (i + 1))\n in\n loop 0))\n ;;\n\n let rec compare_list compare_elt a b =\n match a, b with\n | [], [] -> 0\n | [], _ -> -1\n | _, [] -> 1\n | x :: xs, y :: ys ->\n let res = compare_elt x y in\n if res <> 0 then res else compare_list compare_elt xs ys\n ;;\n\n let compare_option compare_elt a b =\n match a, b with\n | None, None -> 0\n | None, Some _ -> -1\n | Some _, None -> 1\n | Some a, Some b -> compare_elt a b\n ;;\n\n let compare_ref compare_elt a b = compare_elt !a !b\n let equal_bool : bool equal = Poly.equal\n let equal_char : char equal = Poly.equal\n let equal_int : int equal = Poly.equal\n let equal_int32 : int32 equal = Poly.equal\n let equal_int64 : int64 equal = Poly.equal\n let equal_nativeint : nativeint equal = Poly.equal\n let equal_string : string equal = Poly.equal\n let equal_unit : unit equal = Poly.equal\n\n (* [Poly.equal] is IEEE compliant, which is not what we want here. *)\n let equal_float x y = equal_int (compare_float x y) 0\n\n let equal_array equal_elt a b =\n phys_equal a b\n ||\n let len_a = Array0.length a in\n let len_b = Array0.length b in\n equal len_a len_b\n &&\n let rec loop i =\n i = len_a\n ||\n let l = Array0.unsafe_get a i\n and r = Array0.unsafe_get b i in\n equal_elt l r && loop (i + 1)\n in\n loop 0\n ;;\n\n let rec equal_list equal_elt a b =\n match a, b with\n | [], [] -> true\n | [], _ | _, [] -> false\n | x :: xs, y :: ys -> equal_elt x y && equal_list equal_elt xs ys\n ;;\n\n let equal_option equal_elt a b =\n match a, b with\n | None, None -> true\n | None, Some _ | Some _, None -> false\n | Some a, Some b -> equal_elt a b\n ;;\n\n let equal_ref equal_elt a b = equal_elt !a !b\nend\n","(* [String0] defines string functions that are primitives or can be simply defined in\n terms of [Caml.String]. [String0] is intended to completely express the part of\n [Caml.String] that [Base] uses -- no other file in Base other than string0.ml should\n use [Caml.String]. [String0] has few dependencies, and so is available early in Base's\n build order.\n\n All Base files that need to use strings, including the subscript syntax\n [x.(i)] or [x.(i) <- e] which the OCaml parser desugars into calls to\n [String], and come before [Base.String] in build order should do\n\n {[\n module String = String0\n ]}\n\n Defining [module String = String0] is also necessary because it prevents\n ocamldep from mistakenly causing a file to depend on [Base.String]. *)\n\nopen! Import0\nmodule Sys = Sys0\n\nmodule String = struct\n external get : string -> int -> char = \"%string_safe_get\"\n external length : string -> int = \"%string_length\"\n external unsafe_get : string -> int -> char = \"%string_unsafe_get\"\n\n include Bytes_set_primitives\nend\n\ninclude String\n\nlet max_length = Sys.max_string_length\nlet ( ^ ) = ( ^ )\nlet capitalize = Caml.String.capitalize_ascii\nlet compare = Caml.String.compare\nlet[@warning \"-3\"] copy = Caml.String.copy\nlet escaped = Caml.String.escaped\nlet lowercase = Caml.String.lowercase_ascii\nlet make = Caml.String.make\nlet sub = Caml.String.sub\nlet uncapitalize = Caml.String.uncapitalize_ascii\nlet unsafe_blit = Caml.String.unsafe_blit\nlet uppercase = Caml.String.uppercase_ascii\n\nlet concat ?(sep = \"\") l =\n match l with\n | [] -> \"\"\n (* The stdlib does not specialize this case because it could break existing projects. *)\n | [ x ] -> x\n | l -> Caml.String.concat ~sep l\n;;\n\n(* These are eta expanded in order to permute parameter order to follow Base\n conventions. *)\nlet iter t ~f = Caml.String.iter t ~f\n","open Hash.Builtin\nopen Ppx_compare_lib.Builtin\nmodule List = List0\nmodule String = String0\ninclude (Sexplib0.Sexp : module type of Sexplib0.Sexp with type t := Sexplib0.Sexp.t)\n\n(** Type of S-expressions *)\ntype t = Sexplib0.Sexp.t =\n | Atom of string\n | List of t list\n[@@deriving_inline compare, hash]\n\nlet rec compare =\n (fun a__001_ b__002_ ->\n if Ppx_compare_lib.phys_equal a__001_ b__002_\n then 0\n else (\n match a__001_, b__002_ with\n | Atom _a__003_, Atom _b__004_ -> compare_string _a__003_ _b__004_\n | Atom _, _ -> -1\n | _, Atom _ -> 1\n | List _a__005_, List _b__006_ -> compare_list compare _a__005_ _b__006_)\n : t -> t -> int)\n;;\n\nlet rec (hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state) =\n (fun hsv arg ->\n match arg with\n | Atom _a0 ->\n let hsv = Ppx_hash_lib.Std.Hash.fold_int hsv 0 in\n let hsv = hsv in\n hash_fold_string hsv _a0\n | List _a0 ->\n let hsv = Ppx_hash_lib.Std.Hash.fold_int hsv 1 in\n let hsv = hsv in\n hash_fold_list hash_fold_t hsv _a0\n : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state)\n\nand (hash : t -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func arg =\n Ppx_hash_lib.Std.Hash.get_hash_value\n (let hsv = Ppx_hash_lib.Std.Hash.create () in\n hash_fold_t hsv arg)\n in\n fun x -> func x\n;;\n\n[@@@end]\n\nlet of_string = ()\nlet invariant (_ : t) = ()\n","open! Import\ninclude Sexplib0.Sexpable\n\nmodule Of_sexpable\n (Sexpable : S) (M : sig\n type t\n\n val to_sexpable : t -> Sexpable.t\n val of_sexpable : Sexpable.t -> t\n end) : S with type t := M.t = struct\n let t_of_sexp sexp =\n let s = Sexpable.t_of_sexp sexp in\n try M.of_sexpable s with\n | exn -> of_sexp_error_exn exn sexp\n ;;\n\n let sexp_of_t t = Sexpable.sexp_of_t (M.to_sexpable t)\nend\n\nmodule Of_sexpable1\n (Sexpable : S1) (M : sig\n type 'a t\n\n val to_sexpable : 'a t -> 'a Sexpable.t\n val of_sexpable : 'a Sexpable.t -> 'a t\n end) : S1 with type 'a t := 'a M.t = struct\n let t_of_sexp a_of_sexp sexp =\n let s = Sexpable.t_of_sexp a_of_sexp sexp in\n try M.of_sexpable s with\n | exn -> of_sexp_error_exn exn sexp\n ;;\n\n let sexp_of_t sexp_of_a t = Sexpable.sexp_of_t sexp_of_a (M.to_sexpable t)\nend\n\nmodule Of_sexpable2\n (Sexpable : S2) (M : sig\n type ('a, 'b) t\n\n val to_sexpable : ('a, 'b) t -> ('a, 'b) Sexpable.t\n val of_sexpable : ('a, 'b) Sexpable.t -> ('a, 'b) t\n end) : S2 with type ('a, 'b) t := ('a, 'b) M.t = struct\n let t_of_sexp a_of_sexp b_of_sexp sexp =\n let s = Sexpable.t_of_sexp a_of_sexp b_of_sexp sexp in\n try M.of_sexpable s with\n | exn -> of_sexp_error_exn exn sexp\n ;;\n\n let sexp_of_t sexp_of_a sexp_of_b t =\n Sexpable.sexp_of_t sexp_of_a sexp_of_b (M.to_sexpable t)\n ;;\nend\n\nmodule Of_sexpable3\n (Sexpable : S3) (M : sig\n type ('a, 'b, 'c) t\n\n val to_sexpable : ('a, 'b, 'c) t -> ('a, 'b, 'c) Sexpable.t\n val of_sexpable : ('a, 'b, 'c) Sexpable.t -> ('a, 'b, 'c) t\n end) : S3 with type ('a, 'b, 'c) t := ('a, 'b, 'c) M.t = struct\n let t_of_sexp a_of_sexp b_of_sexp c_of_sexp sexp =\n let s = Sexpable.t_of_sexp a_of_sexp b_of_sexp c_of_sexp sexp in\n try M.of_sexpable s with\n | exn -> of_sexp_error_exn exn sexp\n ;;\n\n let sexp_of_t sexp_of_a sexp_of_b sexp_of_c t =\n Sexpable.sexp_of_t sexp_of_a sexp_of_b sexp_of_c (M.to_sexpable t)\n ;;\nend\n\nmodule Of_stringable (M : Stringable.S) : S with type t := M.t = struct\n let t_of_sexp sexp =\n match sexp with\n | Sexp.Atom s ->\n (try M.of_string s with\n | exn -> of_sexp_error_exn exn sexp)\n | Sexp.List _ ->\n of_sexp_error\n \"Sexpable.Of_stringable.t_of_sexp expected an atom, but got a list\"\n sexp\n ;;\n\n let sexp_of_t t = Sexp.Atom (M.to_string t)\nend\n","open! Import\nmodule Sys = Sys0\n\ntype t =\n | W32\n | W64\n[@@deriving_inline sexp_of]\n\nlet sexp_of_t =\n (function\n | W32 -> Ppx_sexp_conv_lib.Sexp.Atom \"W32\"\n | W64 -> Ppx_sexp_conv_lib.Sexp.Atom \"W64\"\n : t -> Ppx_sexp_conv_lib.Sexp.t)\n;;\n\n[@@@end]\n\nlet num_bits = function\n | W32 -> 32\n | W64 -> 64\n;;\n\nlet word_size =\n match Sys.word_size_in_bits with\n | 32 -> W32\n | 64 -> W64\n | _ -> failwith \"unknown word size\"\n;;\n","open! Import\n\nlet r = ref [ \"Base.Sexp.pp_hum\" ]\nlet all () = !r\nlet register p = r := p :: !r\n\nmodule type S = sig\n type t\n\n val pp : Formatter.t -> t -> unit\nend\n\nmodule Register_pp (M : sig\n include S\n\n val module_name : string\n end) =\nstruct\n include M\n\n let () = register (M.module_name ^ \".pp\")\nend\n\nmodule Register (M : sig\n type t\n\n val module_name : string\n val to_string : t -> string\n end) =\n Register_pp (struct\n include M\n\n let pp formatter t = Caml.Format.pp_print_string formatter (M.to_string t)\n end)\n","(** [Core_kernel] greatly expands the functionality available in Base while still\n remaining platform-agnostic. Core_kernel changes more frequently (i.e., is less\n stable) than Base.\n\n Some modules are mere extensions of their counterparts in Base, usually adding generic\n functionality by including functors that make them binable, comparable, sexpable,\n blitable, etc. The bulk of Core_kernel, though, is modules providing entirely new\n functionality. *)\n\nopen! Import\n\n\nmodule Applicative = Applicative\nmodule Arg = Arg\nmodule Array = Array\nmodule Avltree = Avltree\nmodule Backtrace = Backtrace\nmodule Bag = Bag\nmodule Bigbuffer = Bigbuffer\nmodule Bigstring = Bigstring\nmodule Bigsubstring = Bigsubstring\nmodule Bin_prot = Core_bin_prot\nmodule Binable = Binable\nmodule Binary_search = Binary_search\nmodule Binary_searchable = Binary_searchable\nmodule Blang = Blang\nmodule Blit = Blit\nmodule Bool = Bool\nmodule Bounded_index = Bounded_index\nmodule Buffer = Base.Buffer\nmodule Byte_units = Byte_units\nmodule Bytes = Bytes\nmodule Caml = Caml\nmodule Char = Char\nmodule Command = Command\nmodule Comparable = Comparable\nmodule Comparator = Comparator\nmodule Comparisons = Comparisons\nmodule Container = Container\nmodule Container_intf = Container_intf\nmodule Continue_or_stop = Continue_or_stop\nmodule Core_kernel_stable = Stable\nmodule Date = Date\nmodule Day_of_week = Day_of_week\nmodule Debug = Debug\nmodule Deque = Deque\nmodule Deriving_hash = Deriving_hash\nmodule Digest = Md5 [@@ocaml.deprecated \"[since 2017-05] Use Md5 instead.\"]\nmodule Doubly_linked = Doubly_linked\nmodule Either = Either\nmodule Ephemeron = Ephemeron\nmodule Equal = Equal\nmodule Error = Error\nmodule Exn = Base.Exn\nmodule Expect_test_config = Expect_test_config\nmodule Fdeque = Fdeque\nmodule Field = Field\nmodule Filename = Filename\nmodule Float = Float\nmodule Float_with_finite_only_serialization = Float_with_finite_only_serialization\nmodule Floatable = Floatable\nmodule Fn = Fn\nmodule Formatter = Formatter\nmodule Fqueue = Fqueue\nmodule Gc = Gc\nmodule Hash = Hash\nmodule Hash_queue = Hash_queue\nmodule Hash_set = Hash_set\nmodule Hashable = Hashable\nmodule Hashtbl = Hashtbl\nmodule Hashtbl_intf = Hashtbl_intf\nmodule Heap_block = Heap_block\nmodule Hexdump = Hexdump\nmodule Hexdump_intf = Hexdump_intf\nmodule Host_and_port = Host_and_port\nmodule Identifiable = Identifiable\nmodule Immediate_option = Immediate_option\nmodule Immediate_option_intf = Immediate_option_intf\nmodule In_channel = In_channel\nmodule Info = Info\nmodule Int = Int\nmodule Int32 = Int32\nmodule Int63 = Int63\nmodule Int64 = Int64\nmodule Int_conversions = Int_conversions\nmodule Int_intf = Int_intf\nmodule Int_math = Int_math\nmodule Intable = Intable\nmodule Interfaces = Interfaces\nmodule Invariant = Invariant\nmodule Lazy = Lazy\nmodule Linked_queue = Linked_queue\nmodule List = List\nmodule Map = Map\nmodule Map_intf = Map_intf\nmodule Maybe_bound = Maybe_bound\nmodule Md5 = Md5\nmodule Memo = Memo\nmodule Monad = Monad\nmodule Month = Month\nmodule Nativeint = Nativeint\nmodule No_polymorphic_compare = No_polymorphic_compare\nmodule Nothing = Nothing\nmodule Only_in_test = Only_in_test\nmodule Option = Option\nmodule Option_array = Option_array\nmodule Optional_syntax = Optional_syntax\nmodule Optional_syntax_intf = Optional_syntax_intf\nmodule Or_error = Or_error\nmodule Ordered_collection_common = Ordered_collection_common\nmodule Ordering = Ordering\nmodule Out_channel = Out_channel\nmodule Percent = Percent\nmodule Perms = Perms\nmodule Pid = Pid\nmodule Poly = Poly\nmodule Polymorphic_compare = Poly [@@deprecated \"[since 2018-11] use [Poly] instead\"]\n\nmodule Popcount = Base.Popcount\n[@@warning \"-3\"]\n[@@deprecated \"[since 2018-10] use [popcount] functions in individual int modules\"]\n\nmodule Pretty_printer = Pretty_printer\nmodule Printexc = Printexc\nmodule Printf = Printf\nmodule Queue = Queue\nmodule Quickcheck = Quickcheck\nmodule Quickcheck_intf = Quickcheck_intf\nmodule Quickcheckable = Quickcheckable\nmodule Random = Base.Random\nmodule Ref = Ref\nmodule Result = Result\nmodule Robustly_comparable = Robustly_comparable\nmodule Sequence = Sequence\nmodule Set = Set\nmodule Set_intf = Set_intf\nmodule Set_once = Set_once\nmodule Sexp_maybe = Sexp.Sexp_maybe\n\nmodule Sexp = Sexp\nmodule Sexpable = Sexpable\nmodule Sign = Sign\nmodule Sign_or_nan = Sign_or_nan\nmodule Source_code_position = Source_code_position\nmodule Splittable_random = Splittable_random\nmodule Stable_comparable = Stable_comparable\nmodule Stable_unit_test = Stable_unit_test\nmodule Stack = Stack\nmodule Staged = Base.Staged\nmodule String = String\nmodule String_id = String_id\nmodule Stringable = Stringable\nmodule Substring = Substring\nmodule Substring_intf = Substring_intf\nmodule Sys = Sys\nmodule Time = Time_float\nmodule Time_ns = Time_ns\nmodule Tuple = Tuple\nmodule Tuple2 = Tuple.T2\nmodule Tuple3 = Tuple.T3\nmodule Type_equal = Type_equal\nmodule Type_immediacy = Type_immediacy\nmodule Uchar = Uchar\nmodule Uniform_array = Uniform_array\nmodule Union_find = Union_find\nmodule Unique_id = Unique_id\nmodule Unit = Unit\nmodule Unit_of_time = Unit_of_time\nmodule Univ_map = Univ_map\n\nmodule Unix = struct end\n[@@deprecated\n \"[since 2020-03] Core_kernel shadows Unix. Use Core.Unix, which overrides some of \\\n Unix's behavior. If necessary, Unix is available and unshadowed as Caml_unix.\"]\n\nmodule Validate = Validate\nmodule Validated = Validated\nmodule Variant = Variant\nmodule Weak = Weak\nmodule With_return = With_return\nmodule Word_size = Word_size\n\nmodule type Unique_id = Unique_id.Id\n\ninclude T (** @open *)\n\ninclude Std_internal\ninclude Not_found\n\n(** {2 Top-level values} *)\n\ntype 'a _maybe_bound = 'a Maybe_bound.t =\n | Incl of 'a\n | Excl of 'a\n | Unbounded\n\nlet am_running_inline_test = am_running_inline_test\nlet am_running_test = am_running_test\nlet does_raise = Exn.does_raise\nlet sec = Time_float.Span.of_sec\n\n(** We perform these side effects here because we want them to run for any code that uses\n [Core_kernel]. If this were in another module in [Core_kernel] that was not used in\n some program, then the side effects might not be run in that program. This will run\n as long as the program refers to at least one value directly in [Std_kernel];\n referring to values in [Std_kernel.Bool], for example, is not sufficient. *)\nlet () = Exn.initialize_module ()\n\n(** To be used in implementing Core, but not by end users. *)\nmodule Core_kernel_private = struct\n module Digit_string_helpers = Digit_string_helpers\n module Time_zone = Zone\n module Ofday_helpers = Ofday_helpers\n module Span_float = Span_float\n\n module Bigbuffer_internal = Bigbuffer_internal\n module Stable_internal = Stable_internal\n module Std_internal = Std_internal\n\n module Time_ns_alternate_sexp = Time_ns_alternate_sexp\nend\n","(* belongs in Common, but moved here to avoid circular dependencies *)\n\nopen! Import\n\ntype 'a return = { return : 'b. 'a -> 'b } [@@unboxed]\n\nlet with_return (type a) f =\n let module M = struct\n (* Raised to indicate ~return was called. Local so that the exception is tied to a\n particular call of [with_return]. *)\n exception Return of a\n end\n in\n let is_alive = ref true in\n let return a =\n if not !is_alive\n then failwith \"use of [return] from a [with_return] that already returned\";\n Exn.raise_without_backtrace (M.Return a)\n in\n try\n let a = f { return } in\n is_alive := false;\n a\n with\n | exn ->\n is_alive := false;\n (match exn with\n | M.Return a -> a\n | _ -> raise exn)\n;;\n\nlet with_return_option f =\n with_return (fun return ->\n f { return = (fun a -> return.return (Some a)) };\n None)\n;;\n\nlet prepend { return } ~f = { return = (fun x -> return (f x)) }\n","open! Import\nmodule List = List0\ninclude Monad_intf\n\nmodule type Basic_general = sig\n type ('a, 'i, 'j, 'd, 'e) t\n\n val bind\n : ('a, 'i, 'j, 'd, 'e) t\n -> f:('a -> ('b, 'j, 'k, 'd, 'e) t)\n -> ('b, 'i, 'k, 'd, 'e) t\n\n val map\n : [ `Define_using_bind\n | `Custom of ('a, 'i, 'j, 'd, 'e) t -> f:('a -> 'b) -> ('b, 'i, 'j, 'd, 'e) t\n ]\n\n val return : 'a -> ('a, 'i, 'i, 'd, 'e) t\nend\n\nmodule Make_general (M : Basic_general) = struct\n let bind = M.bind\n let return = M.return\n let map_via_bind ma ~f = M.bind ma ~f:(fun a -> M.return (f a))\n\n let map =\n match M.map with\n | `Define_using_bind -> map_via_bind\n | `Custom x -> x\n ;;\n\n module Monad_infix = struct\n let ( >>= ) t f = bind t ~f\n let ( >>| ) t f = map t ~f\n end\n\n include Monad_infix\n\n module Let_syntax = struct\n let return = return\n\n include Monad_infix\n\n module Let_syntax = struct\n let return = return\n let bind = bind\n let map = map\n let both a b = a >>= fun a -> b >>| fun b -> a, b\n\n module Open_on_rhs = struct end\n end\n end\n\n let join t = t >>= fun t' -> t'\n let ignore_m t = map t ~f:(fun _ -> ())\n\n let all =\n let rec loop vs = function\n | [] -> return (List.rev vs)\n | t :: ts -> t >>= fun v -> loop (v :: vs) ts\n in\n fun ts -> loop [] ts\n ;;\n\n let rec all_unit = function\n | [] -> return ()\n | t :: ts -> t >>= fun () -> all_unit ts\n ;;\nend\n\nmodule Make_indexed (M : Basic_indexed) :\n S_indexed with type ('a, 'i, 'j) t := ('a, 'i, 'j) M.t = Make_general (struct\n type ('a, 'i, 'j, 'd, 'e) t = ('a, 'i, 'j) M.t\n\n include (M : Basic_indexed with type ('a, 'b, 'c) t := ('a, 'b, 'c) M.t)\n end)\n\nmodule Make3 (M : Basic3) : S3 with type ('a, 'd, 'e) t := ('a, 'd, 'e) M.t =\n Make_general (struct\n type ('a, 'i, 'j, 'd, 'e) t = ('a, 'd, 'e) M.t\n\n include (M : Basic3 with type ('a, 'b, 'c) t := ('a, 'b, 'c) M.t)\n end)\n\nmodule Make2 (M : Basic2) : S2 with type ('a, 'd) t := ('a, 'd) M.t =\n Make_general (struct\n type ('a, 'i, 'j, 'd, 'e) t = ('a, 'd) M.t\n\n include (M : Basic2 with type ('a, 'b) t := ('a, 'b) M.t)\n end)\n\nmodule Make (M : Basic) : S with type 'a t := 'a M.t = Make_general (struct\n type ('a, 'i, 'j, 'd, 'e) t = 'a M.t\n\n include (M : Basic with type 'a t := 'a M.t)\n end)\n\nmodule Ident = struct\n type 'a t = 'a\n\n include Make (struct\n type nonrec 'a t = 'a t\n\n let bind a ~f = f a\n let return a = a\n let map = `Custom (fun a ~f -> f a)\n end)\nend\n","open! Import\n\ntype ('a, 'witness) t =\n { compare : 'a -> 'a -> int\n ; sexp_of_t : 'a -> Sexp.t\n }\n\ntype ('a, 'b) comparator = ('a, 'b) t\n\nmodule type S = sig\n type t\n type comparator_witness\n\n val comparator : (t, comparator_witness) comparator\nend\n\nmodule type S1 = sig\n type 'a t\n type comparator_witness\n\n val comparator : ('a t, comparator_witness) comparator\nend\n\nmodule type S_fc = sig\n type comparable_t\n\n include S with type t := comparable_t\nend\n\nlet make (type t) ~compare ~sexp_of_t =\n (module struct\n type comparable_t = t\n type comparator_witness\n\n let comparator = { compare; sexp_of_t }\n end : S_fc\n with type comparable_t = t)\n;;\n\nmodule S_to_S1 (S : S) = struct\n type 'a t = S.t\n type comparator_witness = S.comparator_witness\n\n open S\n\n let comparator = comparator\nend\n\nmodule Make (M : sig\n type t [@@deriving_inline compare, sexp_of]\n\n val compare : t -> t -> int\n val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t\n\n [@@@end]\n end) =\nstruct\n include M\n\n type comparator_witness\n\n let comparator = M.{ compare; sexp_of_t }\nend\n\nmodule Make1 (M : sig\n type 'a t\n\n val compare : 'a t -> 'a t -> int\n val sexp_of_t : 'a t -> Sexp.t\n end) =\nstruct\n type comparator_witness\n\n let comparator = M.{ compare; sexp_of_t }\nend\n\nmodule Poly = struct\n type 'a t = 'a\n\n include Make1 (struct\n type 'a t = 'a\n\n let compare = Poly.compare\n let sexp_of_t _ = Sexp.Atom \"_\"\n end)\nend\n\nmodule type Derived = sig\n type 'a t\n type 'cmp comparator_witness\n\n val comparator : ('a, 'cmp) comparator -> ('a t, 'cmp comparator_witness) comparator\nend\n\nmodule Derived (M : sig\n type 'a t [@@deriving_inline compare, sexp_of]\n\n val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int\n val sexp_of_t : ('a -> Ppx_sexp_conv_lib.Sexp.t) -> 'a t -> Ppx_sexp_conv_lib.Sexp.t\n\n [@@@end]\n end) =\nstruct\n type 'cmp comparator_witness\n\n let comparator a =\n { compare = M.compare a.compare; sexp_of_t = M.sexp_of_t a.sexp_of_t }\n ;;\nend\n\nmodule type Derived2 = sig\n type ('a, 'b) t\n type ('cmp_a, 'cmp_b) comparator_witness\n\n val comparator\n : ('a, 'cmp_a) comparator\n -> ('b, 'cmp_b) comparator\n -> (('a, 'b) t, ('cmp_a, 'cmp_b) comparator_witness) comparator\nend\n\nmodule Derived2 (M : sig\n type ('a, 'b) t [@@deriving_inline compare, sexp_of]\n\n val compare : ('a -> 'a -> int) -> ('b -> 'b -> int) -> ('a, 'b) t -> ('a, 'b) t -> int\n\n val sexp_of_t\n : ('a -> Ppx_sexp_conv_lib.Sexp.t)\n -> ('b -> Ppx_sexp_conv_lib.Sexp.t)\n -> ('a, 'b) t\n -> Ppx_sexp_conv_lib.Sexp.t\n\n [@@@end]\n end) =\nstruct\n type ('cmp_a, 'cmp_b) comparator_witness\n\n let comparator a b =\n { compare = M.compare a.compare b.compare\n ; sexp_of_t = M.sexp_of_t a.sexp_of_t b.sexp_of_t\n }\n ;;\nend\n\nmodule type Derived_phantom = sig\n type ('a, 'b) t\n type 'cmp comparator_witness\n\n val comparator\n : ('a, 'cmp) comparator\n -> (('a, _) t, 'cmp comparator_witness) comparator\nend\n\nmodule Derived_phantom (M : sig\n type ('a, 'b) t\n\n val compare : ('a -> 'a -> int) -> ('a, 'b) t -> ('a, 'b) t -> int\n val sexp_of_t : ('a -> Sexp.t) -> ('a, _) t -> Sexp.t\n end) =\nstruct\n type 'cmp_a comparator_witness\n\n let comparator a =\n { compare = M.compare a.compare; sexp_of_t = M.sexp_of_t a.sexp_of_t }\n ;;\nend\n","(* The type [t] should be abstract to make the fset and set functions unavailable\n for private types at the level of types (and not by putting None in the field).\n Unfortunately, making the type abstract means that when creating fields (through\n a [create] function) value restriction kicks in. This is worked around by instead\n not making the type abstract, but forcing anyone breaking the abstraction to use\n the [For_generated_code] module, making it obvious to any reader that something ugly\n is going on.\n t_with_perm (and derivatives) is the type that users really use. It is a constructor\n because:\n 1. it makes type errors more readable (less aliasing)\n 2. the typer in ocaml 4.01 allows this:\n\n {[\n module A = struct\n type t = {a : int}\n end\n type t = A.t\n let f (x : t) = x.a\n ]}\n\n (although with Warning 40: a is used out of scope)\n which means that if [t_with_perm] was really an alias on [For_generated_code.t],\n people could say [t.setter] and break the abstraction with no indication that\n something ugly is going on in the source code.\n The warning is (I think) for people who want to make their code compatible with\n previous versions of ocaml, so we may very well turn it off.\n\n The type t_with_perm could also have been a [unit -> For_generated_code.t] to work\n around value restriction and then [For_generated_code.t] would have been a proper\n abstract type, but it looks like it could impact performance (for example, a fold on a\n record type with 40 fields would actually allocate the 40 [For_generated_code.t]'s at\n every single fold.) *)\n\nmodule For_generated_code = struct\n type ('perm, 'record, 'field) t =\n { force_variance : 'perm -> unit\n ; (* force [t] to be contravariant in ['perm], because phantom type variables on\n concrete types don't work that well otherwise (using :> can remove them easily) *)\n name : string\n ; setter : ('record -> 'field -> unit) option\n ; getter : 'record -> 'field\n ; fset : 'record -> 'field -> 'record\n }\n\n let opaque_identity = Sys0.opaque_identity\nend\n\ntype ('perm, 'record, 'field) t_with_perm =\n | Field of ('perm, 'record, 'field) For_generated_code.t\n[@@unboxed]\n\ntype ('record, 'field) t = ([ `Read | `Set_and_create ], 'record, 'field) t_with_perm\ntype ('record, 'field) readonly_t = ([ `Read ], 'record, 'field) t_with_perm\n\nlet name (Field field) = field.name\nlet get (Field field) r = field.getter r\nlet fset (Field field) r v = field.fset r v\nlet setter (Field field) = field.setter\n\ntype ('perm, 'record, 'result) user =\n { f : 'field. ('perm, 'record, 'field) t_with_perm -> 'result }\n\nlet map (Field field) r ~f = field.fset r (f (field.getter r))\n\nlet updater (Field field) =\n match field.setter with\n | None -> None\n | Some setter -> Some (fun r ~f -> setter r (f (field.getter r)))\n;;\n","open! Import\nmodule Int = Int0\nmodule String = String0\n\nmodule T = struct\n type t = Caml.Lexing.position =\n { pos_fname : string\n ; pos_lnum : int\n ; pos_bol : int\n ; pos_cnum : int\n }\n [@@deriving_inline compare, hash, sexp]\n\n let compare =\n (fun a__001_ b__002_ ->\n if Ppx_compare_lib.phys_equal a__001_ b__002_\n then 0\n else (\n match compare_string a__001_.pos_fname b__002_.pos_fname with\n | 0 ->\n (match compare_int a__001_.pos_lnum b__002_.pos_lnum with\n | 0 ->\n (match compare_int a__001_.pos_bol b__002_.pos_bol with\n | 0 -> compare_int a__001_.pos_cnum b__002_.pos_cnum\n | n -> n)\n | n -> n)\n | n -> n)\n : t -> t -> int)\n ;;\n\n let (hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state) =\n fun hsv arg ->\n let hsv =\n let hsv =\n let hsv =\n let hsv = hsv in\n hash_fold_string hsv arg.pos_fname\n in\n hash_fold_int hsv arg.pos_lnum\n in\n hash_fold_int hsv arg.pos_bol\n in\n hash_fold_int hsv arg.pos_cnum\n ;;\n\n let (hash : t -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func arg =\n Ppx_hash_lib.Std.Hash.get_hash_value\n (let hsv = Ppx_hash_lib.Std.Hash.create () in\n hash_fold_t hsv arg)\n in\n fun x -> func x\n ;;\n\n let t_of_sexp =\n (let _tp_loc = \"source_code_position0.ml.T.t\" in\n function\n | Ppx_sexp_conv_lib.Sexp.List field_sexps as sexp ->\n let pos_fname_field = ref Ppx_sexp_conv_lib.Option.None\n and pos_lnum_field = ref Ppx_sexp_conv_lib.Option.None\n and pos_bol_field = ref Ppx_sexp_conv_lib.Option.None\n and pos_cnum_field = ref Ppx_sexp_conv_lib.Option.None\n and duplicates = ref []\n and extra = ref [] in\n let rec iter = function\n | Ppx_sexp_conv_lib.Sexp.List\n (Ppx_sexp_conv_lib.Sexp.Atom field_name :: (([] | [ _ ]) as _field_sexps))\n :: tail ->\n let _field_sexp () =\n match _field_sexps with\n | [ x ] -> x\n | [] -> Ppx_sexp_conv_lib.Conv_error.record_only_pairs_expected _tp_loc sexp\n | _ -> assert false\n in\n (match field_name with\n | \"pos_fname\" ->\n (match !pos_fname_field with\n | Ppx_sexp_conv_lib.Option.None ->\n let _field_sexp = _field_sexp () in\n let fvalue = string_of_sexp _field_sexp in\n pos_fname_field := Ppx_sexp_conv_lib.Option.Some fvalue\n | Ppx_sexp_conv_lib.Option.Some _ -> duplicates := field_name :: !duplicates)\n | \"pos_lnum\" ->\n (match !pos_lnum_field with\n | Ppx_sexp_conv_lib.Option.None ->\n let _field_sexp = _field_sexp () in\n let fvalue = int_of_sexp _field_sexp in\n pos_lnum_field := Ppx_sexp_conv_lib.Option.Some fvalue\n | Ppx_sexp_conv_lib.Option.Some _ -> duplicates := field_name :: !duplicates)\n | \"pos_bol\" ->\n (match !pos_bol_field with\n | Ppx_sexp_conv_lib.Option.None ->\n let _field_sexp = _field_sexp () in\n let fvalue = int_of_sexp _field_sexp in\n pos_bol_field := Ppx_sexp_conv_lib.Option.Some fvalue\n | Ppx_sexp_conv_lib.Option.Some _ -> duplicates := field_name :: !duplicates)\n | \"pos_cnum\" ->\n (match !pos_cnum_field with\n | Ppx_sexp_conv_lib.Option.None ->\n let _field_sexp = _field_sexp () in\n let fvalue = int_of_sexp _field_sexp in\n pos_cnum_field := Ppx_sexp_conv_lib.Option.Some fvalue\n | Ppx_sexp_conv_lib.Option.Some _ -> duplicates := field_name :: !duplicates)\n | _ ->\n if !Ppx_sexp_conv_lib.Conv.record_check_extra_fields\n then extra := field_name :: !extra\n else ());\n iter tail\n | ((Ppx_sexp_conv_lib.Sexp.Atom _ | Ppx_sexp_conv_lib.Sexp.List _) as sexp) :: _\n -> Ppx_sexp_conv_lib.Conv_error.record_only_pairs_expected _tp_loc sexp\n | [] -> ()\n in\n iter field_sexps;\n (match !duplicates with\n | _ :: _ ->\n Ppx_sexp_conv_lib.Conv_error.record_duplicate_fields _tp_loc !duplicates sexp\n | [] ->\n (match !extra with\n | _ :: _ -> Ppx_sexp_conv_lib.Conv_error.record_extra_fields _tp_loc !extra sexp\n | [] ->\n (match !pos_fname_field, !pos_lnum_field, !pos_bol_field, !pos_cnum_field with\n | ( Ppx_sexp_conv_lib.Option.Some pos_fname_value\n , Ppx_sexp_conv_lib.Option.Some pos_lnum_value\n , Ppx_sexp_conv_lib.Option.Some pos_bol_value\n , Ppx_sexp_conv_lib.Option.Some pos_cnum_value ) ->\n { pos_fname = pos_fname_value\n ; pos_lnum = pos_lnum_value\n ; pos_bol = pos_bol_value\n ; pos_cnum = pos_cnum_value\n }\n | _ ->\n Ppx_sexp_conv_lib.Conv_error.record_undefined_elements\n _tp_loc\n sexp\n [ ( Ppx_sexp_conv_lib.Conv.( = )\n !pos_fname_field\n Ppx_sexp_conv_lib.Option.None\n , \"pos_fname\" )\n ; ( Ppx_sexp_conv_lib.Conv.( = )\n !pos_lnum_field\n Ppx_sexp_conv_lib.Option.None\n , \"pos_lnum\" )\n ; ( Ppx_sexp_conv_lib.Conv.( = )\n !pos_bol_field\n Ppx_sexp_conv_lib.Option.None\n , \"pos_bol\" )\n ; ( Ppx_sexp_conv_lib.Conv.( = )\n !pos_cnum_field\n Ppx_sexp_conv_lib.Option.None\n , \"pos_cnum\" )\n ])))\n | Ppx_sexp_conv_lib.Sexp.Atom _ as sexp ->\n Ppx_sexp_conv_lib.Conv_error.record_list_instead_atom _tp_loc sexp\n : Ppx_sexp_conv_lib.Sexp.t -> t)\n ;;\n\n let sexp_of_t =\n (function\n | { pos_fname = v_pos_fname\n ; pos_lnum = v_pos_lnum\n ; pos_bol = v_pos_bol\n ; pos_cnum = v_pos_cnum\n } ->\n let bnds = [] in\n let bnds =\n let arg = sexp_of_int v_pos_cnum in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"pos_cnum\"; arg ]\n :: bnds\n in\n let bnds =\n let arg = sexp_of_int v_pos_bol in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"pos_bol\"; arg ]\n :: bnds\n in\n let bnds =\n let arg = sexp_of_int v_pos_lnum in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"pos_lnum\"; arg ]\n :: bnds\n in\n let bnds =\n let arg = sexp_of_string v_pos_fname in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"pos_fname\"; arg ]\n :: bnds\n in\n Ppx_sexp_conv_lib.Sexp.List bnds\n : t -> Ppx_sexp_conv_lib.Sexp.t)\n ;;\n\n [@@@end]\nend\n\ninclude T\ninclude Comparator.Make (T)\n\n(* This is the same function as Ppx_here.lift_position_as_string. *)\nlet make_location_string ~pos_fname ~pos_lnum ~pos_cnum ~pos_bol =\n String.concat\n [ pos_fname; \":\"; Int.to_string pos_lnum; \":\"; Int.to_string (pos_cnum - pos_bol) ]\n;;\n\nlet to_string { Caml.Lexing.pos_fname; pos_lnum; pos_cnum; pos_bol } =\n make_location_string ~pos_fname ~pos_lnum ~pos_cnum ~pos_bol\n;;\n\nlet sexp_of_t t = Sexp.Atom (to_string t)\n","open! Import\ninclude List0\n\nlet is_empty = function\n | [] -> true\n | _ -> false\n;;\n\nlet partition_map t ~f =\n let rec loop t fst snd =\n match t with\n | [] -> rev fst, rev snd\n | x :: t ->\n (match (f x : _ Either0.t) with\n | First y -> loop t (y :: fst) snd\n | Second y -> loop t fst (y :: snd))\n in\n loop t [] []\n;;\n","open! Import\nmodule Either = Either0\n\ntype ('a, 'b) t = ('a, 'b) Caml.result =\n | Ok of 'a\n | Error of 'b\n[@@deriving_inline sexp, compare, equal, hash]\n\nlet t_of_sexp\n : type a b.\n (Ppx_sexp_conv_lib.Sexp.t -> a)\n -> (Ppx_sexp_conv_lib.Sexp.t -> b)\n -> Ppx_sexp_conv_lib.Sexp.t\n -> (a, b) t\n =\n let _tp_loc = \"result.ml.t\" in\n fun _of_a _of_b -> function\n | Ppx_sexp_conv_lib.Sexp.List\n (Ppx_sexp_conv_lib.Sexp.Atom ((\"ok\" | \"Ok\") as _tag) :: sexp_args) as _sexp ->\n (match sexp_args with\n | [ v0 ] ->\n let v0 = _of_a v0 in\n Ok v0\n | _ -> Ppx_sexp_conv_lib.Conv_error.stag_incorrect_n_args _tp_loc _tag _sexp)\n | Ppx_sexp_conv_lib.Sexp.List\n (Ppx_sexp_conv_lib.Sexp.Atom ((\"error\" | \"Error\") as _tag) :: sexp_args) as _sexp\n ->\n (match sexp_args with\n | [ v0 ] ->\n let v0 = _of_b v0 in\n Error v0\n | _ -> Ppx_sexp_conv_lib.Conv_error.stag_incorrect_n_args _tp_loc _tag _sexp)\n | Ppx_sexp_conv_lib.Sexp.Atom (\"ok\" | \"Ok\") as sexp ->\n Ppx_sexp_conv_lib.Conv_error.stag_takes_args _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.Atom (\"error\" | \"Error\") as sexp ->\n Ppx_sexp_conv_lib.Conv_error.stag_takes_args _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.List (Ppx_sexp_conv_lib.Sexp.List _ :: _) as sexp ->\n Ppx_sexp_conv_lib.Conv_error.nested_list_invalid_sum _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.List [] as sexp ->\n Ppx_sexp_conv_lib.Conv_error.empty_list_invalid_sum _tp_loc sexp\n | sexp -> Ppx_sexp_conv_lib.Conv_error.unexpected_stag _tp_loc sexp\n;;\n\nlet sexp_of_t\n : type a b.\n (a -> Ppx_sexp_conv_lib.Sexp.t)\n -> (b -> Ppx_sexp_conv_lib.Sexp.t)\n -> (a, b) t\n -> Ppx_sexp_conv_lib.Sexp.t\n =\n fun _of_a _of_b -> function\n | Ok v0 ->\n let v0 = _of_a v0 in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"Ok\"; v0 ]\n | Error v0 ->\n let v0 = _of_b v0 in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"Error\"; v0 ]\n;;\n\nlet compare :\n 'a 'b. ('a -> 'a -> int) -> ('b -> 'b -> int) -> ('a, 'b) t -> ('a, 'b) t -> int\n =\n fun _cmp__a _cmp__b a__001_ b__002_ ->\n if Ppx_compare_lib.phys_equal a__001_ b__002_\n then 0\n else (\n match a__001_, b__002_ with\n | Ok _a__003_, Ok _b__004_ -> _cmp__a _a__003_ _b__004_\n | Ok _, _ -> -1\n | _, Ok _ -> 1\n | Error _a__005_, Error _b__006_ -> _cmp__b _a__005_ _b__006_)\n;;\n\nlet equal :\n 'a 'b. ('a -> 'a -> bool) -> ('b -> 'b -> bool) -> ('a, 'b) t -> ('a, 'b) t -> bool\n =\n fun _cmp__a _cmp__b a__007_ b__008_ ->\n if Ppx_compare_lib.phys_equal a__007_ b__008_\n then true\n else (\n match a__007_, b__008_ with\n | Ok _a__009_, Ok _b__010_ -> _cmp__a _a__009_ _b__010_\n | Ok _, _ -> false\n | _, Ok _ -> false\n | Error _a__011_, Error _b__012_ -> _cmp__b _a__011_ _b__012_)\n;;\n\nlet hash_fold_t\n : type a b.\n (Ppx_hash_lib.Std.Hash.state -> a -> Ppx_hash_lib.Std.Hash.state)\n -> (Ppx_hash_lib.Std.Hash.state -> b -> Ppx_hash_lib.Std.Hash.state)\n -> Ppx_hash_lib.Std.Hash.state\n -> (a, b) t\n -> Ppx_hash_lib.Std.Hash.state\n =\n fun _hash_fold_a _hash_fold_b hsv arg ->\n match arg with\n | Ok _a0 ->\n let hsv = Ppx_hash_lib.Std.Hash.fold_int hsv 0 in\n let hsv = hsv in\n _hash_fold_a hsv _a0\n | Error _a0 ->\n let hsv = Ppx_hash_lib.Std.Hash.fold_int hsv 1 in\n let hsv = hsv in\n _hash_fold_b hsv _a0\n;;\n\n[@@@end]\n\ninclude Monad.Make2 (struct\n type nonrec ('a, 'b) t = ('a, 'b) t\n\n let bind x ~f =\n match x with\n | Error _ as x -> x\n | Ok x -> f x\n ;;\n\n let map x ~f =\n match x with\n | Error _ as x -> x\n | Ok x -> Ok (f x)\n ;;\n\n let map = `Custom map\n let return x = Ok x\n end)\n\nlet invariant check_ok check_error t =\n match t with\n | Ok ok -> check_ok ok\n | Error error -> check_error error\n;;\n\nlet fail x = Error x\nlet failf format = Printf.ksprintf fail format\n\nlet map_error t ~f =\n match t with\n | Ok _ as x -> x\n | Error x -> Error (f x)\n;;\n\nlet is_ok = function\n | Ok _ -> true\n | Error _ -> false\n;;\n\nlet is_error = function\n | Ok _ -> false\n | Error _ -> true\n;;\n\nlet ok = function\n | Ok x -> Some x\n | Error _ -> None\n;;\n\nlet error = function\n | Ok _ -> None\n | Error x -> Some x\n;;\n\nlet of_option opt ~error =\n match opt with\n | Some x -> Ok x\n | None -> Error error\n;;\n\nlet iter v ~f =\n match v with\n | Ok x -> f x\n | Error _ -> ()\n;;\n\nlet iter_error v ~f =\n match v with\n | Ok _ -> ()\n | Error x -> f x\n;;\n\nlet to_either : _ t -> _ Either.t = function\n | Ok x -> First x\n | Error x -> Second x\n;;\n\nlet of_either : _ Either.t -> _ t = function\n | First x -> Ok x\n | Second x -> Error x\n;;\n\nlet ok_if_true bool ~error = if bool then Ok () else Error error\n\nlet try_with f =\n try Ok (f ()) with\n | exn -> Error exn\n;;\n\nlet ok_exn = function\n | Ok x -> x\n | Error exn -> raise exn\n;;\n\nlet ok_or_failwith = function\n | Ok x -> x\n | Error str -> failwith str\n;;\n\nmodule Export = struct\n type ('ok, 'err) _result = ('ok, 'err) t =\n | Ok of 'ok\n | Error of 'err\n\n let is_error = is_error\n let is_ok = is_ok\nend\n\nlet combine t1 t2 ~ok ~err =\n match t1, t2 with\n | Ok _, Error e | Error e, Ok _ -> Error e\n | Ok ok1, Ok ok2 -> Ok (ok ok1 ok2)\n | Error err1, Error err2 -> Error (err err1 err2)\n;;\n\nlet combine_errors l =\n let ok, errs = List1.partition_map l ~f:to_either in\n match errs with\n | [] -> Ok ok\n | _ :: _ -> Error errs\n;;\n\nlet combine_errors_unit l = map (combine_errors l) ~f:(fun (_ : unit list) -> ())\n\n(* deprecated binding for export only *)\nlet ok_fst = to_either\n","(** Provides generic signatures for container data structures.\n\n These signatures include functions ([iter], [fold], [exists], [for_all], ...) that\n you would expect to find in any container. Used by including [Container.S0] or\n [Container.S1] in the signature for every container-like data structure ([Array],\n [List], [String], ...) to ensure a consistent interface. *)\n\nopen! Import\n\nmodule Export = struct\n (** [Continue_or_stop.t] is used by the [f] argument to [fold_until] in order to\n indicate whether folding should continue, or stop early. *)\n module Continue_or_stop = struct\n type ('a, 'b) t =\n | Continue of 'a\n | Stop of 'b\n end\nend\n\ninclude Export\n\nmodule type Summable = sig\n type t\n\n (** The result of summing no values. *)\n val zero : t\n\n (** An operation that combines two [t]'s and handles [zero + x] by just returning [x],\n as well as in the symmetric case. *)\n val ( + ) : t -> t -> t\nend\n\n(** Signature for monomorphic container, e.g., string. *)\nmodule type S0 = sig\n type t\n type elt\n\n (** Checks whether the provided element is there, using equality on [elt]s. *)\n val mem : t -> elt -> bool\n\n val length : t -> int\n val is_empty : t -> bool\n\n (** [iter] must allow exceptions raised in [f] to escape, terminating the iteration\n cleanly. The same holds for all functions below taking an [f]. *)\n val iter : t -> f:(elt -> unit) -> unit\n\n (** [fold t ~init ~f] returns [f (... f (f (f init e1) e2) e3 ...) en], where [e1..en]\n are the elements of [t]. *)\n val fold : t -> init:'accum -> f:('accum -> elt -> 'accum) -> 'accum\n\n (** [fold_result t ~init ~f] is a short-circuiting version of [fold] that runs in the\n [Result] monad. If [f] returns an [Error _], that value is returned without any\n additional invocations of [f]. *)\n val fold_result\n : t\n -> init:'accum\n -> f:('accum -> elt -> ('accum, 'e) Result.t)\n -> ('accum, 'e) Result.t\n\n (** [fold_until t ~init ~f ~finish] is a short-circuiting version of [fold]. If [f]\n returns [Stop _] the computation ceases and results in that value. If [f] returns\n [Continue _], the fold will proceed. If [f] never returns [Stop _], the final result\n is computed by [finish].\n\n Example:\n\n {[\n type maybe_negative =\n | Found_negative of int\n | All_nonnegative of { sum : int }\n\n (** [first_neg_or_sum list] returns the first negative number in [list], if any,\n otherwise returns the sum of the list. *)\n let first_neg_or_sum =\n List.fold_until ~init:0\n ~f:(fun sum x ->\n if x < 0\n then Stop (Found_negative x)\n else Continue (sum + x))\n ~finish:(fun sum -> All_nonnegative { sum })\n ;;\n\n let x = first_neg_or_sum [1; 2; 3; 4; 5]\n val x : maybe_negative = All_nonnegative {sum = 15}\n\n let y = first_neg_or_sum [1; 2; -3; 4; 5]\n val y : maybe_negative = Found_negative -3\n ]} *)\n val fold_until\n : t\n -> init:'accum\n -> f:('accum -> elt -> ('accum, 'final) Continue_or_stop.t)\n -> finish:('accum -> 'final)\n -> 'final\n\n (** Returns [true] if and only if there exists an element for which the provided\n function evaluates to [true]. This is a short-circuiting operation. *)\n val exists : t -> f:(elt -> bool) -> bool\n\n (** Returns [true] if and only if the provided function evaluates to [true] for all\n elements. This is a short-circuiting operation. *)\n val for_all : t -> f:(elt -> bool) -> bool\n\n (** Returns the number of elements for which the provided function evaluates to true. *)\n val count : t -> f:(elt -> bool) -> int\n\n (** Returns the sum of [f i] for all [i] in the container. *)\n val sum : (module Summable with type t = 'sum) -> t -> f:(elt -> 'sum) -> 'sum\n\n (** Returns as an [option] the first element for which [f] evaluates to true. *)\n val find : t -> f:(elt -> bool) -> elt option\n\n (** Returns the first evaluation of [f] that returns [Some], and returns [None] if there\n is no such element. *)\n val find_map : t -> f:(elt -> 'a option) -> 'a option\n\n val to_list : t -> elt list\n val to_array : t -> elt array\n\n (** Returns a min (resp. max) element from the collection using the provided [compare]\n function. In case of a tie, the first element encountered while traversing the\n collection is returned. The implementation uses [fold] so it has the same\n complexity as [fold]. Returns [None] iff the collection is empty. *)\n val min_elt : t -> compare:(elt -> elt -> int) -> elt option\n\n val max_elt : t -> compare:(elt -> elt -> int) -> elt option\nend\n\nmodule type S0_phantom = sig\n type elt\n type 'a t\n\n (** Checks whether the provided element is there, using equality on [elt]s. *)\n val mem : _ t -> elt -> bool\n\n val length : _ t -> int\n val is_empty : _ t -> bool\n val iter : _ t -> f:(elt -> unit) -> unit\n\n (** [fold t ~init ~f] returns [f (... f (f (f init e1) e2) e3 ...) en], where [e1..en]\n are the elements of [t]. *)\n val fold : _ t -> init:'accum -> f:('accum -> elt -> 'accum) -> 'accum\n\n (** [fold_result t ~init ~f] is a short-circuiting version of [fold] that runs in the\n [Result] monad. If [f] returns an [Error _], that value is returned without any\n additional invocations of [f]. *)\n val fold_result\n : _ t\n -> init:'accum\n -> f:('accum -> elt -> ('accum, 'e) Result.t)\n -> ('accum, 'e) Result.t\n\n (** [fold_until t ~init ~f ~finish] is a short-circuiting version of [fold]. If [f]\n returns [Stop _] the computation ceases and results in that value. If [f] returns\n [Continue _], the fold will proceed. If [f] never returns [Stop _], the final result\n is computed by [finish].\n\n Example:\n\n {[\n type maybe_negative =\n | Found_negative of int\n | All_nonnegative of { sum : int }\n\n (** [first_neg_or_sum list] returns the first negative number in [list], if any,\n otherwise returns the sum of the list. *)\n let first_neg_or_sum =\n List.fold_until ~init:0\n ~f:(fun sum x ->\n if x < 0\n then Stop (Found_negative x)\n else Continue (sum + x))\n ~finish:(fun sum -> All_nonnegative { sum })\n ;;\n\n let x = first_neg_or_sum [1; 2; 3; 4; 5]\n val x : maybe_negative = All_nonnegative {sum = 15}\n\n let y = first_neg_or_sum [1; 2; -3; 4; 5]\n val y : maybe_negative = Found_negative -3\n ]} *)\n val fold_until\n : _ t\n -> init:'accum\n -> f:('accum -> elt -> ('accum, 'final) Continue_or_stop.t)\n -> finish:('accum -> 'final)\n -> 'final\n\n (** Returns [true] if and only if there exists an element for which the provided\n function evaluates to [true]. This is a short-circuiting operation. *)\n val exists : _ t -> f:(elt -> bool) -> bool\n\n (** Returns [true] if and only if the provided function evaluates to [true] for all\n elements. This is a short-circuiting operation. *)\n val for_all : _ t -> f:(elt -> bool) -> bool\n\n (** Returns the number of elements for which the provided function evaluates to true. *)\n val count : _ t -> f:(elt -> bool) -> int\n\n (** Returns the sum of [f i] for all [i] in the container. The order in which the\n elements will be summed is unspecified. *)\n val sum : (module Summable with type t = 'sum) -> _ t -> f:(elt -> 'sum) -> 'sum\n\n (** Returns as an [option] the first element for which [f] evaluates to true. *)\n val find : _ t -> f:(elt -> bool) -> elt option\n\n (** Returns the first evaluation of [f] that returns [Some], and returns [None] if there\n is no such element. *)\n val find_map : _ t -> f:(elt -> 'a option) -> 'a option\n\n val to_list : _ t -> elt list\n val to_array : _ t -> elt array\n\n (** Returns a min (resp max) element from the collection using the provided [compare]\n function, or [None] if the collection is empty. In case of a tie, the first element\n encountered while traversing the collection is returned. *)\n val min_elt : _ t -> compare:(elt -> elt -> int) -> elt option\n\n val max_elt : _ t -> compare:(elt -> elt -> int) -> elt option\nend\n\n(** Signature for polymorphic container, e.g., ['a list] or ['a array]. *)\nmodule type S1 = sig\n type 'a t\n\n (** Checks whether the provided element is there, using [equal]. *)\n val mem : 'a t -> 'a -> equal:('a -> 'a -> bool) -> bool\n\n val length : 'a t -> int\n val is_empty : 'a t -> bool\n val iter : 'a t -> f:('a -> unit) -> unit\n\n (** [fold t ~init ~f] returns [f (... f (f (f init e1) e2) e3 ...) en], where [e1..en]\n are the elements of [t] *)\n val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum\n\n (** [fold_result t ~init ~f] is a short-circuiting version of [fold] that runs in the\n [Result] monad. If [f] returns an [Error _], that value is returned without any\n additional invocations of [f]. *)\n val fold_result\n : 'a t\n -> init:'accum\n -> f:('accum -> 'a -> ('accum, 'e) Result.t)\n -> ('accum, 'e) Result.t\n\n (** [fold_until t ~init ~f ~finish] is a short-circuiting version of [fold]. If [f]\n returns [Stop _] the computation ceases and results in that value. If [f] returns\n [Continue _], the fold will proceed. If [f] never returns [Stop _], the final result\n is computed by [finish].\n\n Example:\n\n {[\n type maybe_negative =\n | Found_negative of int\n | All_nonnegative of { sum : int }\n\n (** [first_neg_or_sum list] returns the first negative number in [list], if any,\n otherwise returns the sum of the list. *)\n let first_neg_or_sum =\n List.fold_until ~init:0\n ~f:(fun sum x ->\n if x < 0\n then Stop (Found_negative x)\n else Continue (sum + x))\n ~finish:(fun sum -> All_nonnegative { sum })\n ;;\n\n let x = first_neg_or_sum [1; 2; 3; 4; 5]\n val x : maybe_negative = All_nonnegative {sum = 15}\n\n let y = first_neg_or_sum [1; 2; -3; 4; 5]\n val y : maybe_negative = Found_negative -3\n ]} *)\n val fold_until\n : 'a t\n -> init:'accum\n -> f:('accum -> 'a -> ('accum, 'final) Continue_or_stop.t)\n -> finish:('accum -> 'final)\n -> 'final\n\n (** Returns [true] if and only if there exists an element for which the provided\n function evaluates to [true]. This is a short-circuiting operation. *)\n val exists : 'a t -> f:('a -> bool) -> bool\n\n (** Returns [true] if and only if the provided function evaluates to [true] for all\n elements. This is a short-circuiting operation. *)\n val for_all : 'a t -> f:('a -> bool) -> bool\n\n (** Returns the number of elements for which the provided function evaluates to true. *)\n val count : 'a t -> f:('a -> bool) -> int\n\n (** Returns the sum of [f i] for all [i] in the container. *)\n val sum : (module Summable with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum\n\n (** Returns as an [option] the first element for which [f] evaluates to true. *)\n val find : 'a t -> f:('a -> bool) -> 'a option\n\n (** Returns the first evaluation of [f] that returns [Some], and returns [None] if there\n is no such element. *)\n val find_map : 'a t -> f:('a -> 'b option) -> 'b option\n\n val to_list : 'a t -> 'a list\n val to_array : 'a t -> 'a array\n\n (** Returns a minimum (resp maximum) element from the collection using the provided\n [compare] function, or [None] if the collection is empty. In case of a tie, the first\n element encountered while traversing the collection is returned. The implementation\n uses [fold] so it has the same complexity as [fold]. *)\n val min_elt : 'a t -> compare:('a -> 'a -> int) -> 'a option\n\n val max_elt : 'a t -> compare:('a -> 'a -> int) -> 'a option\nend\n\nmodule type S1_phantom_invariant = sig\n type ('a, 'phantom) t\n\n (** Checks whether the provided element is there, using [equal]. *)\n val mem : ('a, _) t -> 'a -> equal:('a -> 'a -> bool) -> bool\n\n val length : (_, _) t -> int\n val is_empty : (_, _) t -> bool\n val iter : ('a, _) t -> f:('a -> unit) -> unit\n\n (** [fold t ~init ~f] returns [f (... f (f (f init e1) e2) e3 ...) en], where [e1..en]\n are the elements of [t]. *)\n val fold : ('a, _) t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum\n\n (** [fold_result t ~init ~f] is a short-circuiting version of [fold] that runs in the\n [Result] monad. If [f] returns an [Error _], that value is returned without any\n additional invocations of [f]. *)\n val fold_result\n : ('a, _) t\n -> init:'accum\n -> f:('accum -> 'a -> ('accum, 'e) Result.t)\n -> ('accum, 'e) Result.t\n\n (** [fold_until t ~init ~f ~finish] is a short-circuiting version of [fold]. If [f]\n returns [Stop _] the computation ceases and results in that value. If [f] returns\n [Continue _], the fold will proceed. If [f] never returns [Stop _], the final result\n is computed by [finish].\n\n Example:\n\n {[\n type maybe_negative =\n | Found_negative of int\n | All_nonnegative of { sum : int }\n\n (** [first_neg_or_sum list] returns the first negative number in [list], if any,\n otherwise returns the sum of the list. *)\n let first_neg_or_sum =\n List.fold_until ~init:0\n ~f:(fun sum x ->\n if x < 0\n then Stop (Found_negative x)\n else Continue (sum + x))\n ~finish:(fun sum -> All_nonnegative { sum })\n ;;\n\n let x = first_neg_or_sum [1; 2; 3; 4; 5]\n val x : maybe_negative = All_nonnegative {sum = 15}\n\n let y = first_neg_or_sum [1; 2; -3; 4; 5]\n val y : maybe_negative = Found_negative -3\n ]} *)\n val fold_until\n : ('a, _) t\n -> init:'accum\n -> f:('accum -> 'a -> ('accum, 'final) Continue_or_stop.t)\n -> finish:('accum -> 'final)\n -> 'final\n\n (** Returns [true] if and only if there exists an element for which the provided\n function evaluates to [true]. This is a short-circuiting operation. *)\n val exists : ('a, _) t -> f:('a -> bool) -> bool\n\n (** Returns [true] if and only if the provided function evaluates to [true] for all\n elements. This is a short-circuiting operation. *)\n val for_all : ('a, _) t -> f:('a -> bool) -> bool\n\n (** Returns the number of elements for which the provided function evaluates to true. *)\n val count : ('a, _) t -> f:('a -> bool) -> int\n\n (** Returns the sum of [f i] for all [i] in the container. *)\n val sum : (module Summable with type t = 'sum) -> ('a, _) t -> f:('a -> 'sum) -> 'sum\n\n (** Returns as an [option] the first element for which [f] evaluates to true. *)\n val find : ('a, _) t -> f:('a -> bool) -> 'a option\n\n (** Returns the first evaluation of [f] that returns [Some], and returns [None] if there\n is no such element. *)\n val find_map : ('a, _) t -> f:('a -> 'b option) -> 'b option\n\n val to_list : ('a, _) t -> 'a list\n val to_array : ('a, _) t -> 'a array\n\n (** Returns a min (resp max) element from the collection using the provided [compare]\n function. In case of a tie, the first element encountered while traversing the\n collection is returned. The implementation uses [fold] so it has the same complexity\n as [fold]. Returns [None] iff the collection is empty. *)\n val min_elt : ('a, _) t -> compare:('a -> 'a -> int) -> 'a option\n\n val max_elt : ('a, _) t -> compare:('a -> 'a -> int) -> 'a option\nend\n\nmodule type S1_phantom = sig\n type ('a, +'phantom) t\n\n include S1_phantom_invariant with type ('a, 'phantom) t := ('a, 'phantom) t\nend\n\nmodule type Generic = sig\n type 'a t\n type 'a elt\n\n val length : _ t -> int\n val is_empty : _ t -> bool\n val iter : 'a t -> f:('a elt -> unit) -> unit\n val fold : 'a t -> init:'accum -> f:('accum -> 'a elt -> 'accum) -> 'accum\n\n val fold_result\n : 'a t\n -> init:'accum\n -> f:('accum -> 'a elt -> ('accum, 'e) Result.t)\n -> ('accum, 'e) Result.t\n\n val fold_until\n : 'a t\n -> init:'accum\n -> f:('accum -> 'a elt -> ('accum, 'final) Continue_or_stop.t)\n -> finish:('accum -> 'final)\n -> 'final\n\n val exists : 'a t -> f:('a elt -> bool) -> bool\n val for_all : 'a t -> f:('a elt -> bool) -> bool\n val count : 'a t -> f:('a elt -> bool) -> int\n val sum : (module Summable with type t = 'sum) -> 'a t -> f:('a elt -> 'sum) -> 'sum\n val find : 'a t -> f:('a elt -> bool) -> 'a elt option\n val find_map : 'a t -> f:('a elt -> 'b option) -> 'b option\n val to_list : 'a t -> 'a elt list\n val to_array : 'a t -> 'a elt array\n val min_elt : 'a t -> compare:('a elt -> 'a elt -> int) -> 'a elt option\n val max_elt : 'a t -> compare:('a elt -> 'a elt -> int) -> 'a elt option\nend\n\nmodule type Generic_phantom = sig\n type ('a, 'phantom) t\n type 'a elt\n\n val length : (_, _) t -> int\n val is_empty : (_, _) t -> bool\n val iter : ('a, _) t -> f:('a elt -> unit) -> unit\n val fold : ('a, _) t -> init:'accum -> f:('accum -> 'a elt -> 'accum) -> 'accum\n\n val fold_result\n : ('a, _) t\n -> init:'accum\n -> f:('accum -> 'a elt -> ('accum, 'e) Result.t)\n -> ('accum, 'e) Result.t\n\n val fold_until\n : ('a, _) t\n -> init:'accum\n -> f:('accum -> 'a elt -> ('accum, 'final) Continue_or_stop.t)\n -> finish:('accum -> 'final)\n -> 'final\n\n val exists : ('a, _) t -> f:('a elt -> bool) -> bool\n val for_all : ('a, _) t -> f:('a elt -> bool) -> bool\n val count : ('a, _) t -> f:('a elt -> bool) -> int\n\n val sum\n : (module Summable with type t = 'sum)\n -> ('a, _) t\n -> f:('a elt -> 'sum)\n -> 'sum\n\n val find : ('a, _) t -> f:('a elt -> bool) -> 'a elt option\n val find_map : ('a, _) t -> f:('a elt -> 'b option) -> 'b option\n val to_list : ('a, _) t -> 'a elt list\n val to_array : ('a, _) t -> 'a elt array\n val min_elt : ('a, _) t -> compare:('a elt -> 'a elt -> int) -> 'a elt option\n val max_elt : ('a, _) t -> compare:('a elt -> 'a elt -> int) -> 'a elt option\nend\n\nmodule type Make_gen_arg = sig\n type 'a t\n type 'a elt\n\n val fold : 'a t -> init:'accum -> f:('accum -> 'a elt -> 'accum) -> 'accum\n\n (** The [iter] argument to [Container.Make] specifies how to implement the\n container's [iter] function. [`Define_using_fold] means to define [iter]\n via:\n\n {[\n iter t ~f = Container.iter ~fold t ~f\n ]}\n\n [`Custom] overrides the default implementation, presumably with something more\n efficient. Several other functions returned by [Container.Make] are defined in\n terms of [iter], so passing in a more efficient [iter] will improve their efficiency\n as well. *)\n val iter : [ `Define_using_fold | `Custom of 'a t -> f:('a elt -> unit) -> unit ]\n\n (** The [length] argument to [Container.Make] specifies how to implement the\n container's [length] function. [`Define_using_fold] means to define\n [length] via:\n\n {[\n length t ~f = Container.length ~fold t ~f\n ]}\n\n [`Custom] overrides the default implementation, presumably with something more\n efficient. Several other functions returned by [Container.Make] are defined in\n terms of [length], so passing in a more efficient [length] will improve their\n efficiency as well. *)\n val length : [ `Define_using_fold | `Custom of 'a t -> int ]\nend\n\nmodule type Make_arg = Make_gen_arg with type 'a elt := 'a Monad.Ident.t\n\nmodule type Make0_arg = sig\n module Elt : sig\n type t\n\n val equal : t -> t -> bool\n end\n\n type t\n\n val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum\n val iter : [ `Define_using_fold | `Custom of t -> f:(Elt.t -> unit) -> unit ]\n val length : [ `Define_using_fold | `Custom of t -> int ]\nend\n\nmodule type Container = sig\n include module type of struct\n include Export\n end\n\n module type S0 = S0\n module type S0_phantom = S0_phantom\n module type S1 = S1\n module type S1_phantom_invariant = S1_phantom_invariant\n module type S1_phantom = S1_phantom\n module type Generic = Generic\n module type Generic_phantom = Generic_phantom\n module type Summable = Summable\n\n (** Generic definitions of container operations in terms of [fold].\n\n E.g.: [iter ~fold t ~f = fold t ~init:() ~f:(fun () a -> f a)]. *)\n\n type ('t, 'a, 'accum) fold = 't -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum\n type ('t, 'a) iter = 't -> f:('a -> unit) -> unit\n type 't length = 't -> int\n\n val iter : fold:('t, 'a, unit) fold -> ('t, 'a) iter\n val count : fold:('t, 'a, int) fold -> 't -> f:('a -> bool) -> int\n\n val min_elt\n : fold:('t, 'a, 'a option) fold\n -> 't\n -> compare:('a -> 'a -> int)\n -> 'a option\n\n val max_elt\n : fold:('t, 'a, 'a option) fold\n -> 't\n -> compare:('a -> 'a -> int)\n -> 'a option\n\n val length : fold:('t, _, int) fold -> 't -> int\n val to_list : fold:('t, 'a, 'a list) fold -> 't -> 'a list\n\n val sum\n : fold:('t, 'a, 'sum) fold\n -> (module Summable with type t = 'sum)\n -> 't\n -> f:('a -> 'sum)\n -> 'sum\n\n val fold_result\n : fold:('t, 'a, 'b) fold\n -> init:'b\n -> f:('b -> 'a -> ('b, 'e) Result.t)\n -> 't\n -> ('b, 'e) Result.t\n\n val fold_until\n : fold:('t, 'a, 'b) fold\n -> init:'b\n -> f:('b -> 'a -> ('b, 'final) Continue_or_stop.t)\n -> finish:('b -> 'final)\n -> 't\n -> 'final\n\n (** Generic definitions of container operations in terms of [iter] and [length]. *)\n val is_empty : iter:('t, 'a) iter -> 't -> bool\n\n val exists : iter:('t, 'a) iter -> 't -> f:('a -> bool) -> bool\n val for_all : iter:('t, 'a) iter -> 't -> f:('a -> bool) -> bool\n val find : iter:('t, 'a) iter -> 't -> f:('a -> bool) -> 'a option\n val find_map : iter:('t, 'a) iter -> 't -> f:('a -> 'b option) -> 'b option\n val to_array : length:'t length -> iter:('t, 'a) iter -> 't -> 'a array\n\n (** The idiom for using [Container.Make] is to bind the resulting module and to\n explicitly import each of the functions that one wants:\n\n {[\n module C = Container.Make (struct ... end)\n let count = C.count\n let exists = C.exists\n let find = C.find\n (* ... *)\n ]}\n\n This is preferable to:\n\n {[\n include Container.Make (struct ... end)\n ]}\n\n because the [include] makes it too easy to shadow specialized implementations of\n container functions ([length] being a common one).\n\n [Container.Make0] is like [Container.Make], but for monomorphic containers like\n [string]. *)\n module Make (T : Make_arg) : S1 with type 'a t := 'a T.t\n\n module Make0 (T : Make0_arg) : S0 with type t := T.t and type elt := T.Elt.t\nend\n","open! Import\nmodule Array = Array0\nmodule List = List0\ninclude Container_intf\n\nlet with_return = With_return.with_return\n\ntype ('t, 'a, 'accum) fold = 't -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum\ntype ('t, 'a) iter = 't -> f:('a -> unit) -> unit\ntype 't length = 't -> int\n\nlet iter ~fold t ~f = fold t ~init:() ~f:(fun () a -> f a)\nlet count ~fold t ~f = fold t ~init:0 ~f:(fun n a -> if f a then n + 1 else n)\n\nlet sum (type a) ~fold (module M : Summable with type t = a) t ~f =\n fold t ~init:M.zero ~f:(fun n a -> M.( + ) n (f a))\n;;\n\nlet fold_result ~fold ~init ~f t =\n with_return (fun { return } ->\n Result.Ok\n (fold t ~init ~f:(fun acc item ->\n match f acc item with\n | Result.Ok x -> x\n | Error _ as e -> return e)))\n;;\n\nlet fold_until ~fold ~init ~f ~finish t =\n with_return (fun { return } ->\n finish\n (fold t ~init ~f:(fun acc item ->\n match f acc item with\n | Continue_or_stop.Continue x -> x\n | Stop x -> return x)))\n;;\n\nlet min_elt ~fold t ~compare =\n fold t ~init:None ~f:(fun acc elt ->\n match acc with\n | None -> Some elt\n | Some min -> if compare min elt > 0 then Some elt else acc)\n;;\n\nlet max_elt ~fold t ~compare =\n fold t ~init:None ~f:(fun acc elt ->\n match acc with\n | None -> Some elt\n | Some max -> if compare max elt < 0 then Some elt else acc)\n;;\n\nlet length ~fold c = fold c ~init:0 ~f:(fun acc _ -> acc + 1)\n\nlet is_empty ~iter c =\n with_return (fun r ->\n iter c ~f:(fun _ -> r.return false);\n true)\n;;\n\nlet exists ~iter c ~f =\n with_return (fun r ->\n iter c ~f:(fun x -> if f x then r.return true);\n false)\n;;\n\nlet for_all ~iter c ~f =\n with_return (fun r ->\n iter c ~f:(fun x -> if not (f x) then r.return false);\n true)\n;;\n\nlet find_map ~iter t ~f =\n with_return (fun r ->\n iter t ~f:(fun x ->\n match f x with\n | None -> ()\n | Some _ as res -> r.return res);\n None)\n;;\n\nlet find ~iter c ~f =\n with_return (fun r ->\n iter c ~f:(fun x -> if f x then r.return (Some x));\n None)\n;;\n\nlet to_list ~fold c = List.rev (fold c ~init:[] ~f:(fun acc x -> x :: acc))\n\nlet to_array ~length ~iter c =\n let array = ref [||] in\n let i = ref 0 in\n iter c ~f:(fun x ->\n if !i = 0 then array := Array.create ~len:(length c) x;\n !array.(!i) <- x;\n incr i);\n !array\n;;\n\nmodule Make_gen (T : Make_gen_arg) : sig\n include Generic with type 'a t := 'a T.t with type 'a elt := 'a T.elt\nend = struct\n let fold = T.fold\n\n let iter =\n match T.iter with\n | `Custom iter -> iter\n | `Define_using_fold -> fun t ~f -> iter ~fold t ~f\n ;;\n\n let length =\n match T.length with\n | `Custom length -> length\n | `Define_using_fold -> fun t -> length ~fold t\n ;;\n\n let is_empty t = is_empty ~iter t\n let sum m t = sum ~fold m t\n let count t ~f = count ~fold t ~f\n let exists t ~f = exists ~iter t ~f\n let for_all t ~f = for_all ~iter t ~f\n let find_map t ~f = find_map ~iter t ~f\n let find t ~f = find ~iter t ~f\n let to_list t = to_list ~fold t\n let to_array t = to_array ~length ~iter t\n let min_elt t ~compare = min_elt ~fold t ~compare\n let max_elt t ~compare = max_elt ~fold t ~compare\n let fold_result t ~init ~f = fold_result t ~fold ~init ~f\n let fold_until t ~init ~f ~finish = fold_until t ~fold ~init ~f ~finish\nend\n\nmodule Make (T : Make_arg) = struct\n include Make_gen (struct\n include T\n\n type 'a elt = 'a\n end)\n\n let mem t a ~equal = exists t ~f:(equal a)\nend\n\nmodule Make0 (T : Make0_arg) = struct\n include Make_gen (struct\n include (T : Make0_arg with type t := T.t with module Elt := T.Elt)\n\n type 'a t = T.t\n type 'a elt = T.Elt.t\n end)\n\n let mem t elt = exists t ~f:(T.Elt.equal elt)\nend\n\nopen T\n\n\n(* The following functors exist as a consistency check among all the various [S?]\n interfaces. They ensure that each particular [S?] is an instance of a more generic\n signature. *)\nmodule Check\n (T : T1)\n (Elt : T1)\n (M : Generic with type 'a t := 'a T.t with type 'a elt := 'a Elt.t) =\nstruct end\n\nmodule Check_S0 (M : S0) =\n Check\n (struct\n type 'a t = M.t\n end)\n (struct\n type 'a t = M.elt\n end)\n (M)\n\nmodule Check_S0_phantom (M : S0_phantom) =\n Check\n (struct\n type 'a t = 'a M.t\n end)\n (struct\n type 'a t = M.elt\n end)\n (M)\n\nmodule Check_S1 (M : S1) =\n Check\n (struct\n type 'a t = 'a M.t\n end)\n (struct\n type 'a t = 'a\n end)\n (M)\n\ntype phantom\n\nmodule Check_S1_phantom (M : S1_phantom) =\n Check\n (struct\n type 'a t = ('a, phantom) M.t\n end)\n (struct\n type 'a t = 'a\n end)\n (M)\n\nmodule Check_S1_phantom_invariant (M : S1_phantom_invariant) =\n Check\n (struct\n type 'a t = ('a, phantom) M.t\n end)\n (struct\n type 'a t = 'a\n end)\n (M)\n","open! Import\n\ntype 'a t = 'a lazy_t [@@deriving_inline sexp]\n\nlet t_of_sexp : 'a. (Ppx_sexp_conv_lib.Sexp.t -> 'a) -> Ppx_sexp_conv_lib.Sexp.t -> 'a t =\n lazy_t_of_sexp\n;;\n\nlet sexp_of_t : 'a. ('a -> Ppx_sexp_conv_lib.Sexp.t) -> 'a t -> Ppx_sexp_conv_lib.Sexp.t =\n sexp_of_lazy_t\n;;\n\n[@@@end]\n\ninclude (Caml.Lazy : module type of Caml.Lazy with type 'a t := 'a t)\n\nlet map t ~f = lazy (f (force t))\n\nlet compare compare_a t1 t2 =\n if phys_equal t1 t2 then 0 else compare_a (force t1) (force t2)\n;;\n\nlet hash_fold_t = Hash.Builtin.hash_fold_lazy_t\n\ninclude Monad.Make (struct\n type nonrec 'a t = 'a t\n\n let return x = from_val x\n let bind t ~f = lazy (force (f (force t)))\n let map = map\n let map = `Custom map\n end)\n\nmodule T_unforcing = struct\n type nonrec 'a t = 'a t\n\n let sexp_of_t sexp_of_a t =\n if is_val t then sexp_of_a (force t) else sexp_of_string \"\"\n ;;\nend\n","open! Import\n\nmodule type Basic = sig\n type 'a t\n\n val bind : 'a t -> f:('a -> 'b t) -> 'b t\n val return : 'a -> 'a t\n\n (** The following identities ought to hold (for some value of =):\n\n - [return x >>= f = f x]\n - [t >>= fun x -> return x = t]\n - [(t >>= f) >>= g = t >>= fun x -> (f x >>= g)]\n\n Note: [>>=] is the infix notation for [bind]) *)\n\n (** The [map] argument to [Monad.Make] says how to implement the monad's [map] function.\n [`Define_using_bind] means to define [map t ~f = bind t ~f:(fun a -> return (f a))].\n [`Custom] overrides the default implementation, presumably with something more\n efficient.\n\n Some other functions returned by [Monad.Make] are defined in terms of [map], so\n passing in a more efficient [map] will improve their efficiency as well. *)\n val map : [ `Define_using_bind | `Custom of 'a t -> f:('a -> 'b) -> 'b t ]\nend\n\nmodule type Infix = sig\n type 'a t\n\n (** [t >>= f] returns a computation that sequences the computations represented by two\n monad elements. The resulting computation first does [t] to yield a value [v], and\n then runs the computation returned by [f v]. *)\n val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t\n\n (** [t >>| f] is [t >>= (fun a -> return (f a))]. *)\n val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t\nend\n\n(** Opening a module of this type allows one to use the [%bind] and [%map] syntax\n extensions defined by ppx_let, and brings [return] into scope. *)\nmodule type Syntax = sig\n type 'a t\n\n module Let_syntax : sig\n (** These are convenient to have in scope when programming with a monad: *)\n\n val return : 'a -> 'a t\n\n include Infix with type 'a t := 'a t\n\n module Let_syntax : sig\n val return : 'a -> 'a t\n val bind : 'a t -> f:('a -> 'b t) -> 'b t\n val map : 'a t -> f:('a -> 'b) -> 'b t\n val both : 'a t -> 'b t -> ('a * 'b) t\n\n module Open_on_rhs : sig end\n end\n end\nend\n\nmodule type S_without_syntax = sig\n type 'a t\n\n include Infix with type 'a t := 'a t\n module Monad_infix : Infix with type 'a t := 'a t\n\n (** [bind t ~f] = [t >>= f] *)\n val bind : 'a t -> f:('a -> 'b t) -> 'b t\n\n (** [return v] returns the (trivial) computation that returns v. *)\n val return : 'a -> 'a t\n\n (** [map t ~f] is t >>| f. *)\n val map : 'a t -> f:('a -> 'b) -> 'b t\n\n (** [join t] is [t >>= (fun t' -> t')]. *)\n val join : 'a t t -> 'a t\n\n (** [ignore_m t] is [map t ~f:(fun _ -> ())]. [ignore_m] used to be called [ignore],\n but we decided that was a bad name, because it shadowed the widely used\n [Caml.ignore]. Some monads still do [let ignore = ignore_m] for historical\n reasons. *)\n val ignore_m : 'a t -> unit t\n\n val all : 'a t list -> 'a list t\n\n (** Like [all], but ensures that every monadic value in the list produces a unit value,\n all of which are discarded rather than being collected into a list. *)\n val all_unit : unit t list -> unit t\nend\n\nmodule type S = sig\n type 'a t\n\n include S_without_syntax with type 'a t := 'a t\n include Syntax with type 'a t := 'a t\nend\n\n(** Multi parameter monad. The second parameter gets unified across all the computation.\n This is used to encode monads working on a multi parameter data structure like\n ([('a,'b) result]). *)\nmodule type Basic2 = sig\n type ('a, 'e) t\n\n val bind : ('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t\n val map : [ `Define_using_bind | `Custom of ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t ]\n val return : 'a -> ('a, _) t\nend\n\n(** Same as Infix, except the monad type has two arguments. The second is always just\n passed through. *)\nmodule type Infix2 = sig\n type ('a, 'e) t\n\n val ( >>= ) : ('a, 'e) t -> ('a -> ('b, 'e) t) -> ('b, 'e) t\n val ( >>| ) : ('a, 'e) t -> ('a -> 'b) -> ('b, 'e) t\nend\n\nmodule type Syntax2 = sig\n type ('a, 'e) t\n\n module Let_syntax : sig\n val return : 'a -> ('a, _) t\n\n include Infix2 with type ('a, 'e) t := ('a, 'e) t\n\n module Let_syntax : sig\n val return : 'a -> ('a, _) t\n val bind : ('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t\n val map : ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t\n val both : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t\n\n module Open_on_rhs : sig end\n end\n end\nend\n\n(** The same as S except the monad type has two arguments. The second is always just\n passed through. *)\nmodule type S2 = sig\n type ('a, 'e) t\n\n include Infix2 with type ('a, 'e) t := ('a, 'e) t\n include Syntax2 with type ('a, 'e) t := ('a, 'e) t\n module Monad_infix : Infix2 with type ('a, 'e) t := ('a, 'e) t\n\n val bind : ('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t\n val return : 'a -> ('a, _) t\n val map : ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t\n val join : (('a, 'e) t, 'e) t -> ('a, 'e) t\n val ignore_m : (_, 'e) t -> (unit, 'e) t\n val all : ('a, 'e) t list -> ('a list, 'e) t\n val all_unit : (unit, 'e) t list -> (unit, 'e) t\nend\n\n(** Multi parameter monad. The second and third parameters get unified across all the\n computation. *)\nmodule type Basic3 = sig\n type ('a, 'd, 'e) t\n\n val bind : ('a, 'd, 'e) t -> f:('a -> ('b, 'd, 'e) t) -> ('b, 'd, 'e) t\n\n val map\n : [ `Define_using_bind | `Custom of ('a, 'd, 'e) t -> f:('a -> 'b) -> ('b, 'd, 'e) t ]\n\n val return : 'a -> ('a, _, _) t\nend\n\n(** Same as Infix, except the monad type has three arguments. The second and third are\n always just passed through. *)\nmodule type Infix3 = sig\n type ('a, 'd, 'e) t\n\n val ( >>= ) : ('a, 'd, 'e) t -> ('a -> ('b, 'd, 'e) t) -> ('b, 'd, 'e) t\n val ( >>| ) : ('a, 'd, 'e) t -> ('a -> 'b) -> ('b, 'd, 'e) t\nend\n\nmodule type Syntax3 = sig\n type ('a, 'd, 'e) t\n\n module Let_syntax : sig\n val return : 'a -> ('a, _, _) t\n\n include Infix3 with type ('a, 'd, 'e) t := ('a, 'd, 'e) t\n\n module Let_syntax : sig\n val return : 'a -> ('a, _, _) t\n val bind : ('a, 'd, 'e) t -> f:('a -> ('b, 'd, 'e) t) -> ('b, 'd, 'e) t\n val map : ('a, 'd, 'e) t -> f:('a -> 'b) -> ('b, 'd, 'e) t\n val both : ('a, 'd, 'e) t -> ('b, 'd, 'e) t -> ('a * 'b, 'd, 'e) t\n\n module Open_on_rhs : sig end\n end\n end\nend\n\n(** The same as S except the monad type has three arguments. The second and third are\n always just passed through. *)\nmodule type S3 = sig\n type ('a, 'd, 'e) t\n\n include Infix3 with type ('a, 'd, 'e) t := ('a, 'd, 'e) t\n include Syntax3 with type ('a, 'd, 'e) t := ('a, 'd, 'e) t\n module Monad_infix : Infix3 with type ('a, 'd, 'e) t := ('a, 'd, 'e) t\n\n val bind : ('a, 'd, 'e) t -> f:('a -> ('b, 'd, 'e) t) -> ('b, 'd, 'e) t\n val return : 'a -> ('a, _, _) t\n val map : ('a, 'd, 'e) t -> f:('a -> 'b) -> ('b, 'd, 'e) t\n val join : (('a, 'd, 'e) t, 'd, 'e) t -> ('a, 'd, 'e) t\n val ignore_m : (_, 'd, 'e) t -> (unit, 'd, 'e) t\n val all : ('a, 'd, 'e) t list -> ('a list, 'd, 'e) t\n val all_unit : (unit, 'd, 'e) t list -> (unit, 'd, 'e) t\nend\n\n(** Indexed monad, in the style of Atkey. The second and third parameters are composed\n across all computation. To see this more clearly, you can look at the type of bind:\n\n {[\n val bind : ('a, 'i, 'j) t -> f:('a -> ('b, 'j, 'k) t) -> ('b, 'i, 'k) t\n ]}\n\n and isolate some of the type variables to see their individual behaviors:\n\n {[\n val bind : 'a -> f:('a -> 'b ) -> 'b\n val bind : 'i, 'j -> 'j, 'k -> 'i, 'k\n ]}\n\n For more information on Atkey-style indexed monads, see:\n\n {v\n Parameterised Notions of Computation\n Robert Atkey\n http://bentnib.org/paramnotions-jfp.pdf\n v} *)\nmodule type Basic_indexed = sig\n type ('a, 'i, 'j) t\n\n val bind : ('a, 'i, 'j) t -> f:('a -> ('b, 'j, 'k) t) -> ('b, 'i, 'k) t\n\n val map\n : [ `Define_using_bind | `Custom of ('a, 'i, 'j) t -> f:('a -> 'b) -> ('b, 'i, 'j) t ]\n\n val return : 'a -> ('a, 'i, 'i) t\nend\n\n(** Same as Infix, except the monad type has three arguments. The second and third are\n compose across all computation. *)\nmodule type Infix_indexed = sig\n type ('a, 'i, 'j) t\n\n val ( >>= ) : ('a, 'i, 'j) t -> ('a -> ('b, 'j, 'k) t) -> ('b, 'i, 'k) t\n val ( >>| ) : ('a, 'i, 'j) t -> ('a -> 'b) -> ('b, 'i, 'j) t\nend\n\nmodule type Syntax_indexed = sig\n type ('a, 'i, 'j) t\n\n module Let_syntax : sig\n val return : 'a -> ('a, 'i, 'i) t\n\n include Infix_indexed with type ('a, 'i, 'j) t := ('a, 'i, 'j) t\n\n module Let_syntax : sig\n val return : 'a -> ('a, 'i, 'i) t\n val bind : ('a, 'i, 'j) t -> f:('a -> ('b, 'j, 'k) t) -> ('b, 'i, 'k) t\n val map : ('a, 'i, 'j) t -> f:('a -> 'b) -> ('b, 'i, 'j) t\n val both : ('a, 'i, 'j) t -> ('b, 'j, 'k) t -> ('a * 'b, 'i, 'k) t\n\n module Open_on_rhs : sig end\n end\n end\nend\n\n(** The same as S except the monad type has three arguments. The second and third are\n composed across all computation. *)\nmodule type S_indexed = sig\n type ('a, 'i, 'j) t\n\n include Infix_indexed with type ('a, 'i, 'j) t := ('a, 'i, 'j) t\n include Syntax_indexed with type ('a, 'i, 'j) t := ('a, 'i, 'j) t\n module Monad_infix : Infix_indexed with type ('a, 'i, 'j) t := ('a, 'i, 'j) t\n\n val bind : ('a, 'i, 'j) t -> f:('a -> ('b, 'j, 'k) t) -> ('b, 'i, 'k) t\n val return : 'a -> ('a, 'i, 'i) t\n val map : ('a, 'i, 'j) t -> f:('a -> 'b) -> ('b, 'i, 'j) t\n val join : (('a, 'j, 'k) t, 'i, 'j) t -> ('a, 'i, 'k) t\n val ignore_m : (_, 'i, 'j) t -> (unit, 'i, 'j) t\n val all : ('a, 'i, 'i) t list -> ('a list, 'i, 'i) t\n val all_unit : (unit, 'i, 'i) t list -> (unit, 'i, 'i) t\nend\n\nmodule S_to_S2 (X : S) : S2 with type ('a, 'e) t = 'a X.t = struct\n type ('a, 'e) t = 'a X.t\n\n include (X : S with type 'a t := 'a X.t)\nend\n\nmodule S2_to_S3 (X : S2) : S3 with type ('a, 'd, 'e) t = ('a, 'd) X.t = struct\n type ('a, 'd, 'e) t = ('a, 'd) X.t\n\n include (X : S2 with type ('a, 'd) t := ('a, 'd) X.t)\nend\n\nmodule S_to_S_indexed (X : S) : S_indexed with type ('a, 'i, 'j) t = 'a X.t = struct\n type ('a, 'i, 'j) t = 'a X.t\n\n include (X : S with type 'a t := 'a X.t)\nend\n\nmodule S2_to_S (X : S2) : S with type 'a t = ('a, unit) X.t = struct\n type 'a t = ('a, unit) X.t\n\n include (X : S2 with type ('a, 'e) t := ('a, 'e) X.t)\nend\n\nmodule S3_to_S2 (X : S3) : S2 with type ('a, 'e) t = ('a, 'e, unit) X.t = struct\n type ('a, 'e) t = ('a, 'e, unit) X.t\n\n include (X : S3 with type ('a, 'd, 'e) t := ('a, 'd, 'e) X.t)\nend\n\nmodule S_indexed_to_S2 (X : S_indexed) : S2 with type ('a, 'e) t = ('a, 'e, 'e) X.t =\nstruct\n type ('a, 'e) t = ('a, 'e, 'e) X.t\n\n include (X : S_indexed with type ('a, 'i, 'j) t := ('a, 'i, 'j) X.t)\nend\n\nmodule type Monad = sig\n (** A monad is an abstraction of the concept of sequencing of computations. A value of\n type ['a monad] represents a computation that returns a value of type ['a]. *)\n\n module type Basic = Basic\n module type Basic2 = Basic2\n module type Basic3 = Basic3\n module type Basic_indexed = Basic_indexed\n module type Infix = Infix\n module type Infix2 = Infix2\n module type Infix3 = Infix3\n module type Infix_indexed = Infix_indexed\n module type Syntax = Syntax\n module type Syntax2 = Syntax2\n module type Syntax3 = Syntax3\n module type Syntax_indexed = Syntax_indexed\n module type S_without_syntax = S_without_syntax\n module type S = S\n module type S2 = S2\n module type S3 = S3\n module type S_indexed = S_indexed\n\n module Make (X : Basic) : S with type 'a t := 'a X.t\n module Make2 (X : Basic2) : S2 with type ('a, 'e) t := ('a, 'e) X.t\n module Make3 (X : Basic3) : S3 with type ('a, 'd, 'e) t := ('a, 'd, 'e) X.t\n\n module Make_indexed (X : Basic_indexed) :\n S_indexed with type ('a, 'd, 'e) t := ('a, 'd, 'e) X.t\n\n module Ident : S with type 'a t = 'a\nend\n","open! Import\n\nlet const c _ = c\n\nexternal ignore : _ -> unit = \"%ignore\"\n\n(* this has the same behavior as [Caml.ignore] *)\n\nlet non f x = not (f x)\n\nlet forever f =\n let rec forever () =\n f ();\n forever ()\n in\n try forever () with\n | e -> e\n;;\n\nexternal id : 'a -> 'a = \"%identity\"\nexternal ( |> ) : 'a -> ('a -> 'b) -> 'b = \"%revapply\"\n\n(* The typical use case for these functions is to pass in functional arguments and get\n functions as a result. *)\nlet compose f g x = f (g x)\nlet flip f x y = f y x\nlet rec apply_n_times ~n f x = if n <= 0 then x else apply_n_times ~n:(n - 1) f (f x)\n","open! Import\nmodule Array = Array0\nmodule Either = Either0\n\n\ninclude List1\n\n(* This itself includes [List0]. *)\n\nlet invalid_argf = Printf.invalid_argf\n\nmodule T = struct\n type 'a t = 'a list [@@deriving_inline sexp, sexp_grammar]\n\n let t_of_sexp :\n 'a. (Ppx_sexp_conv_lib.Sexp.t -> 'a) -> Ppx_sexp_conv_lib.Sexp.t -> 'a t\n =\n list_of_sexp\n ;;\n\n let sexp_of_t :\n 'a. ('a -> Ppx_sexp_conv_lib.Sexp.t) -> 'a t -> Ppx_sexp_conv_lib.Sexp.t\n =\n sexp_of_list\n ;;\n\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group) =\n { implicit_vars = [ \"list\" ]\n ; ggid = \"j\\132);\\135qH\\158\\135\\222H\\001\\007\\004\\158\\218\"\n ; types =\n [ \"t\", Explicit_bind ([ \"a\" ], Apply (Implicit_var 0, [ Explicit_var 0 ])) ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ list_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"list.ml.T\"\n }\n in\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"t\", _the_group)\n in\n t_sexp_grammar\n ;;\n\n [@@@end]\nend\n\nmodule Or_unequal_lengths = struct\n type 'a t =\n | Ok of 'a\n | Unequal_lengths\n [@@deriving_inline compare, sexp_of]\n\n let compare : 'a. ('a -> 'a -> int) -> 'a t -> 'a t -> int =\n fun _cmp__a a__001_ b__002_ ->\n if Ppx_compare_lib.phys_equal a__001_ b__002_\n then 0\n else (\n match a__001_, b__002_ with\n | Ok _a__003_, Ok _b__004_ -> _cmp__a _a__003_ _b__004_\n | Ok _, _ -> -1\n | _, Ok _ -> 1\n | Unequal_lengths, Unequal_lengths -> 0)\n ;;\n\n let sexp_of_t\n : type a. (a -> Ppx_sexp_conv_lib.Sexp.t) -> a t -> Ppx_sexp_conv_lib.Sexp.t\n =\n fun _of_a -> function\n | Ok v0 ->\n let v0 = _of_a v0 in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"Ok\"; v0 ]\n | Unequal_lengths -> Ppx_sexp_conv_lib.Sexp.Atom \"Unequal_lengths\"\n ;;\n\n [@@@end]\nend\n\ninclude T\n\nlet invariant f t = iter t ~f\nlet of_list t = t\n\nlet range' ~compare ~stride ?(start = `inclusive) ?(stop = `exclusive) start_i stop_i =\n let next_i = stride start_i in\n let order x y = Ordering.of_int (compare x y) in\n let raise_stride_cannot_return_same_value () =\n invalid_arg \"List.range': stride function cannot return the same value\"\n in\n let initial_stride_order =\n match order start_i next_i with\n | Equal -> raise_stride_cannot_return_same_value ()\n | Less -> `Less\n | Greater -> `Greater\n in\n let rec loop i accum =\n let i_to_stop_order = order i stop_i in\n match i_to_stop_order, initial_stride_order with\n | Less, `Less | Greater, `Greater ->\n (* haven't yet reached [stop_i]. Continue. *)\n let next_i = stride i in\n (match order i next_i, initial_stride_order with\n | Equal, _ -> raise_stride_cannot_return_same_value ()\n | Less, `Greater | Greater, `Less ->\n invalid_arg \"List.range': stride function cannot change direction\"\n | Less, `Less | Greater, `Greater -> loop next_i (i :: accum))\n | Less, `Greater | Greater, `Less ->\n (* stepped past [stop_i]. Finished. *)\n accum\n | Equal, _ ->\n (* reached [stop_i]. Finished. *)\n (match stop with\n | `inclusive -> i :: accum\n | `exclusive -> accum)\n in\n let start_i =\n match start with\n | `inclusive -> start_i\n | `exclusive -> next_i\n in\n rev (loop start_i [])\n;;\n\nlet range ?(stride = 1) ?(start = `inclusive) ?(stop = `exclusive) start_i stop_i =\n if stride = 0 then invalid_arg \"List.range: stride must be non-zero\";\n range' ~compare ~stride:(fun x -> x + stride) ~start ~stop start_i stop_i\n;;\n\nlet hd t =\n match t with\n | [] -> None\n | x :: _ -> Some x\n;;\n\nlet tl t =\n match t with\n | [] -> None\n | _ :: t' -> Some t'\n;;\n\nlet nth t n =\n if n < 0\n then None\n else (\n let rec nth_aux t n =\n match t with\n | [] -> None\n | a :: t -> if n = 0 then Some a else nth_aux t (n - 1)\n in\n nth_aux t n)\n;;\n\nlet nth_exn t n =\n match nth t n with\n | None -> invalid_argf \"List.nth_exn %d called on list of length %d\" n (length t) ()\n | Some a -> a\n;;\n\nlet unordered_append l1 l2 =\n match l1, l2 with\n | [], l | l, [] -> l\n | _ -> rev_append l1 l2\n;;\n\nlet check_length2_exn name l1 l2 =\n let n1 = length l1 in\n let n2 = length l2 in\n if n1 <> n2 then invalid_argf \"length mismatch in %s: %d <> %d\" name n1 n2 ()\n;;\n\nlet check_length3_exn name l1 l2 l3 =\n let n1 = length l1 in\n let n2 = length l2 in\n let n3 = length l3 in\n if n1 <> n2 || n2 <> n3\n then invalid_argf \"length mismatch in %s: %d <> %d || %d <> %d\" name n1 n2 n2 n3 ()\n;;\n\nlet check_length2 l1 l2 ~f =\n if length l1 <> length l2 then Or_unequal_lengths.Unequal_lengths else Ok (f l1 l2)\n;;\n\nlet check_length3 l1 l2 l3 ~f =\n let n1 = length l1 in\n let n2 = length l2 in\n let n3 = length l3 in\n if n1 <> n2 || n2 <> n3 then Or_unequal_lengths.Unequal_lengths else Ok (f l1 l2 l3)\n;;\n\nlet iter2 l1 l2 ~f = check_length2 l1 l2 ~f:(iter2_ok ~f)\n\nlet iter2_exn l1 l2 ~f =\n check_length2_exn \"iter2_exn\" l1 l2;\n iter2_ok l1 l2 ~f\n;;\n\nlet rev_map2 l1 l2 ~f = check_length2 l1 l2 ~f:(rev_map2_ok ~f)\n\nlet rev_map2_exn l1 l2 ~f =\n check_length2_exn \"rev_map2_exn\" l1 l2;\n rev_map2_ok l1 l2 ~f\n;;\n\nlet fold2 l1 l2 ~init ~f = check_length2 l1 l2 ~f:(fold2_ok ~init ~f)\n\nlet fold2_exn l1 l2 ~init ~f =\n check_length2_exn \"fold2_exn\" l1 l2;\n fold2_ok l1 l2 ~init ~f\n;;\n\nlet for_all2 l1 l2 ~f = check_length2 l1 l2 ~f:(for_all2_ok ~f)\n\nlet for_all2_exn l1 l2 ~f =\n check_length2_exn \"for_all2_exn\" l1 l2;\n for_all2_ok l1 l2 ~f\n;;\n\nlet exists2 l1 l2 ~f = check_length2 l1 l2 ~f:(exists2_ok ~f)\n\nlet exists2_exn l1 l2 ~f =\n check_length2_exn \"exists2_exn\" l1 l2;\n exists2_ok l1 l2 ~f\n;;\n\nlet mem t a ~equal =\n let rec loop equal a = function\n | [] -> false\n | b :: bs -> equal a b || loop equal a bs\n in\n loop equal a t\n;;\n\n(* This is a copy of the code from the standard library, with an extra eta-expansion to\n avoid creating partial closures (showed up for [filter]) in profiling). *)\nlet rev_filter t ~f =\n let rec find ~f accu = function\n | [] -> accu\n | x :: l -> if f x then find ~f (x :: accu) l else find ~f accu l\n in\n find ~f [] t\n;;\n\nlet filter t ~f = rev (rev_filter t ~f)\n\nlet find_map t ~f =\n let rec loop = function\n | [] -> None\n | x :: l ->\n (match f x with\n | None -> loop l\n | Some _ as r -> r)\n in\n loop t\n;;\n\nlet find_map_exn =\n let not_found = Not_found_s (Atom \"List.find_map_exn: not found\") in\n let find_map_exn t ~f =\n match find_map t ~f with\n | None -> raise not_found\n | Some x -> x\n in\n (* named to preserve symbol in compiled binary *)\n find_map_exn\n;;\n\nlet find t ~f =\n let rec loop = function\n | [] -> None\n | x :: l -> if f x then Some x else loop l\n in\n loop t\n;;\n\nlet find_exn =\n let not_found = Not_found_s (Atom \"List.find_exn: not found\") in\n let rec find_exn t ~f =\n match t with\n | [] -> raise not_found\n | x :: t -> if f x then x else find_exn t ~f\n in\n (* named to preserve symbol in compiled binary *)\n find_exn\n;;\n\nlet findi t ~f =\n let rec loop i t =\n match t with\n | [] -> None\n | x :: l -> if f i x then Some (i, x) else loop (i + 1) l\n in\n loop 0 t\n;;\n\nlet find_mapi t ~f =\n let rec loop i t =\n match t with\n | [] -> None\n | x :: l ->\n (match f i x with\n | Some _ as result -> result\n | None -> loop (i + 1) l)\n in\n loop 0 t\n;;\n\nlet find_mapi_exn =\n let not_found = Not_found_s (Atom \"List.find_mapi_exn: not found\") in\n let find_mapi_exn t ~f =\n match find_mapi t ~f with\n | None -> raise not_found\n | Some x -> x\n in\n (* named to preserve symbol in compiled binary *)\n find_mapi_exn\n;;\n\nlet for_alli t ~f =\n let rec loop i t =\n match t with\n | [] -> true\n | hd :: tl -> f i hd && loop (i + 1) tl\n in\n loop 0 t\n;;\n\nlet existsi t ~f =\n let rec loop i t =\n match t with\n | [] -> false\n | hd :: tl -> f i hd || loop (i + 1) tl\n in\n loop 0 t\n;;\n\n(** For the container interface. *)\nlet fold_left = fold\n\nlet to_array = Array.of_list\nlet to_list t = t\n\n(** Tail recursive versions of standard [List] module *)\n\nlet slow_append l1 l2 = rev_append (rev l1) l2\n\n(* There are a few optimized list operations here, including append and map. There are\n basically two optimizations in play: loop unrolling, and dynamic switching between\n stack and heap allocation.\n\n The loop-unrolling is straightforward, we just unroll 5 levels of the loop. This makes\n each iteration faster, and also reduces the number of stack frames consumed per list\n element.\n\n The dynamic switching is done by counting the number of stack frames, and then\n switching to the \"slow\" implementation when we exceed a given limit. This means that\n short lists use the fast stack-allocation method, and long lists use a slower one that\n doesn't require stack space. *)\nlet rec count_append l1 l2 count =\n match l2 with\n | [] -> l1\n | _ ->\n (match l1 with\n | [] -> l2\n | [ x1 ] -> x1 :: l2\n | [ x1; x2 ] -> x1 :: x2 :: l2\n | [ x1; x2; x3 ] -> x1 :: x2 :: x3 :: l2\n | [ x1; x2; x3; x4 ] -> x1 :: x2 :: x3 :: x4 :: l2\n | x1 :: x2 :: x3 :: x4 :: x5 :: tl ->\n x1\n :: x2\n :: x3\n :: x4\n :: x5\n :: (if count > 1000 then slow_append tl l2 else count_append tl l2 (count + 1)))\n;;\n\nlet append l1 l2 = count_append l1 l2 0\nlet slow_map l ~f = rev (rev_map l ~f)\n\nlet rec count_map ~f l ctr =\n match l with\n | [] -> []\n | [ x1 ] ->\n let f1 = f x1 in\n [ f1 ]\n | [ x1; x2 ] ->\n let f1 = f x1 in\n let f2 = f x2 in\n [ f1; f2 ]\n | [ x1; x2; x3 ] ->\n let f1 = f x1 in\n let f2 = f x2 in\n let f3 = f x3 in\n [ f1; f2; f3 ]\n | [ x1; x2; x3; x4 ] ->\n let f1 = f x1 in\n let f2 = f x2 in\n let f3 = f x3 in\n let f4 = f x4 in\n [ f1; f2; f3; f4 ]\n | x1 :: x2 :: x3 :: x4 :: x5 :: tl ->\n let f1 = f x1 in\n let f2 = f x2 in\n let f3 = f x3 in\n let f4 = f x4 in\n let f5 = f x5 in\n f1\n :: f2\n :: f3\n :: f4\n :: f5\n :: (if ctr > 1000 then slow_map ~f tl else count_map ~f tl (ctr + 1))\n;;\n\nlet map l ~f = count_map ~f l 0\n\nlet folding_map t ~init ~f =\n let acc = ref init in\n map t ~f:(fun x ->\n let new_acc, y = f !acc x in\n acc := new_acc;\n y)\n;;\n\nlet fold_map t ~init ~f =\n let acc = ref init in\n let result =\n map t ~f:(fun x ->\n let new_acc, y = f !acc x in\n acc := new_acc;\n y)\n in\n !acc, result\n;;\n\nlet ( >>| ) l f = map l ~f\nlet map2_ok l1 l2 ~f = rev (rev_map2_ok l1 l2 ~f)\nlet map2 l1 l2 ~f = check_length2 l1 l2 ~f:(map2_ok ~f)\n\nlet map2_exn l1 l2 ~f =\n check_length2_exn \"map2_exn\" l1 l2;\n map2_ok l1 l2 ~f\n;;\n\nlet rev_map3_ok l1 l2 l3 ~f =\n let rec loop l1 l2 l3 ac =\n match l1, l2, l3 with\n | [], [], [] -> ac\n | x1 :: l1, x2 :: l2, x3 :: l3 -> loop l1 l2 l3 (f x1 x2 x3 :: ac)\n | _ -> assert false\n in\n loop l1 l2 l3 []\n;;\n\nlet rev_map3 l1 l2 l3 ~f = check_length3 l1 l2 l3 ~f:(rev_map3_ok ~f)\n\nlet rev_map3_exn l1 l2 l3 ~f =\n check_length3_exn \"rev_map3_exn\" l1 l2 l3;\n rev_map3_ok l1 l2 l3 ~f\n;;\n\nlet map3_ok l1 l2 l3 ~f = rev (rev_map3_ok l1 l2 l3 ~f)\nlet map3 l1 l2 l3 ~f = check_length3 l1 l2 l3 ~f:(map3_ok ~f)\n\nlet map3_exn l1 l2 l3 ~f =\n check_length3_exn \"map3_exn\" l1 l2 l3;\n map3_ok l1 l2 l3 ~f\n;;\n\nlet rec rev_map_append l1 l2 ~f =\n match l1 with\n | [] -> l2\n | h :: t -> rev_map_append ~f t (f h :: l2)\n;;\n\nlet fold_right l ~f ~init =\n match l with\n | [] -> init (* avoid the allocation of [~f] below *)\n | _ -> fold ~f:(fun a b -> f b a) ~init (rev l)\n;;\n\nlet unzip list =\n let rec loop list l1 l2 =\n match list with\n | [] -> rev l1, rev l2\n | (x, y) :: tl -> loop tl (x :: l1) (y :: l2)\n in\n loop list [] []\n;;\n\nlet unzip3 list =\n let rec loop list l1 l2 l3 =\n match list with\n | [] -> rev l1, rev l2, rev l3\n | (x, y, z) :: tl -> loop tl (x :: l1) (y :: l2) (z :: l3)\n in\n loop list [] [] []\n;;\n\nlet zip_exn l1 l2 =\n check_length2_exn \"zip_exn\" l1 l2;\n map2_ok ~f:(fun a b -> a, b) l1 l2\n;;\n\nlet zip l1 l2 = map2 ~f:(fun a b -> a, b) l1 l2\n\n(** Additional list operations *)\n\nlet rev_mapi l ~f =\n let rec loop i acc = function\n | [] -> acc\n | h :: t -> loop (i + 1) (f i h :: acc) t\n in\n loop 0 [] l\n;;\n\nlet mapi l ~f = rev (rev_mapi l ~f)\n\nlet folding_mapi t ~init ~f =\n let acc = ref init in\n mapi t ~f:(fun i x ->\n let new_acc, y = f i !acc x in\n acc := new_acc;\n y)\n;;\n\nlet fold_mapi t ~init ~f =\n let acc = ref init in\n let result =\n mapi t ~f:(fun i x ->\n let new_acc, y = f i !acc x in\n acc := new_acc;\n y)\n in\n !acc, result\n;;\n\nlet iteri l ~f =\n ignore\n (fold l ~init:0 ~f:(fun i x ->\n f i x;\n i + 1)\n : int)\n;;\n\nlet foldi t ~init ~f =\n snd (fold t ~init:(0, init) ~f:(fun (i, acc) v -> i + 1, f i acc v))\n;;\n\nlet filteri l ~f =\n rev (foldi l ~f:(fun pos acc x -> if f pos x then x :: acc else acc) ~init:[])\n;;\n\nlet reduce l ~f =\n match l with\n | [] -> None\n | hd :: tl -> Some (fold ~init:hd ~f tl)\n;;\n\nlet reduce_exn l ~f =\n match reduce l ~f with\n | None -> invalid_arg \"List.reduce_exn\"\n | Some v -> v\n;;\n\nlet reduce_balanced l ~f =\n (* Call the \"size\" of a value the number of list elements that have been combined into\n it via calls to [f]. We proceed by using [f] to combine elements in the accumulator\n of the same size until we can't combine any more, then getting a new element from the\n input list and repeating.\n\n With this strategy, in the accumulator:\n - we only ever have elements of sizes a power of two\n - we never have more than one element of each size\n - the sum of all the element sizes is equal to the number of elements consumed\n\n These conditions enforce that list of elements of each size is precisely the binary\n expansion of the number of elements consumed: if you've consumed 13 = 0b1101\n elements, you have one element of size 8, one of size 4, and one of size 1. Hence\n when a new element comes along, the number of combinings you need to do is the number\n of trailing 1s in the binary expansion of [num], the number of elements that have\n already gone into the accumulator. The accumulator is in ascending order of size, so\n the next element to combine with is always the head of the list. *)\n let rec step_accum num acc x =\n if num land 1 = 0\n then x :: acc\n else (\n match acc with\n | [] -> assert false\n (* New elements from later in the input list go on the front of the accumulator, so\n the accumulator is in reverse order wrt the original list order, hence [f y x]\n instead of [f x y]. *)\n | y :: ys -> step_accum (num asr 1) ys (f y x))\n in\n (* Experimentally, inlining [foldi] and unrolling this loop a few times can reduce\n runtime down to a third and allocation to 1/16th or so in the microbenchmarks below.\n However, in most use cases [f] is likely to be expensive (otherwise why do you care\n about the order of reduction?) so the overhead of this function itself doesn't really\n matter. If you come up with a use-case where it does, then that's something you might\n want to try: see hg log -pr 49ef065f429d. *)\n match foldi l ~init:[] ~f:step_accum with\n | [] -> None\n | x :: xs -> Some (fold xs ~init:x ~f:(fun x y -> f y x))\n;;\n\nlet reduce_balanced_exn l ~f =\n match reduce_balanced l ~f with\n | None -> invalid_arg \"List.reduce_balanced_exn\"\n | Some v -> v\n;;\n\nlet groupi l ~break =\n let groups =\n foldi l ~init:[] ~f:(fun i acc x ->\n match acc with\n | [] -> [ [ x ] ]\n | current_group :: tl ->\n if break i (hd_exn current_group) x\n then [ x ] :: current_group :: tl (* start new group *)\n else (x :: current_group) :: tl)\n (* extend current group *)\n in\n match groups with\n | [] -> []\n | l -> rev_map l ~f:rev\n;;\n\nlet group l ~break = groupi l ~break:(fun _ x y -> break x y)\n\nlet concat_map l ~f =\n let rec aux acc = function\n | [] -> rev acc\n | hd :: tl -> aux (rev_append (f hd) acc) tl\n in\n aux [] l\n;;\n\nlet concat_mapi l ~f =\n let rec aux cont acc = function\n | [] -> rev acc\n | hd :: tl -> aux (cont + 1) (rev_append (f cont hd) acc) tl\n in\n aux 0 [] l\n;;\n\nlet merge l1 l2 ~compare =\n let rec loop acc l1 l2 =\n match l1, l2 with\n | [], l2 -> rev_append acc l2\n | l1, [] -> rev_append acc l1\n | h1 :: t1, h2 :: t2 ->\n if compare h1 h2 <= 0 then loop (h1 :: acc) t1 l2 else loop (h2 :: acc) l1 t2\n in\n loop [] l1 l2\n;;\n\ninclude struct\n (* We are explicit about what we import from the general Monad functor so that we don't\n accidentally rebind more efficient list-specific functions. *)\n module Monad = Monad.Make (struct\n type 'a t = 'a list\n\n let bind x ~f = concat_map x ~f\n let map = `Custom map\n let return x = [ x ]\n end)\n\n open Monad\n module Monad_infix = Monad_infix\n module Let_syntax = Let_syntax\n\n let ignore_m = ignore_m\n let join = join\n let bind = bind\n let ( >>= ) t f = bind t ~f\n let return = return\n let all = all\n let all_unit = all_unit\nend\n\n(** returns final element of list *)\nlet rec last_exn list =\n match list with\n | [ x ] -> x\n | _ :: tl -> last_exn tl\n | [] -> invalid_arg \"List.last\"\n;;\n\n(** optionally returns final element of list *)\nlet rec last list =\n match list with\n | [ x ] -> Some x\n | _ :: tl -> last tl\n | [] -> None\n;;\n\nlet rec is_prefix list ~prefix ~equal =\n match prefix with\n | [] -> true\n | hd :: tl ->\n (match list with\n | [] -> false\n | hd' :: tl' -> equal hd hd' && is_prefix tl' ~prefix:tl ~equal)\n;;\n\nlet find_consecutive_duplicate t ~equal =\n match t with\n | [] -> None\n | a1 :: t ->\n let rec loop a1 t =\n match t with\n | [] -> None\n | a2 :: t -> if equal a1 a2 then Some (a1, a2) else loop a2 t\n in\n loop a1 t\n;;\n\n(* returns list without adjacent duplicates *)\nlet remove_consecutive_duplicates ?(which_to_keep = `Last) list ~equal =\n let rec loop to_keep accum = function\n | [] -> to_keep :: accum\n | hd :: tl ->\n if equal hd to_keep\n then (\n let to_keep =\n match which_to_keep with\n | `First -> to_keep\n | `Last -> hd\n in\n loop to_keep accum tl)\n else loop hd (to_keep :: accum) tl\n in\n match list with\n | [] -> []\n | hd :: tl -> rev (loop hd [] tl)\n;;\n\n(** returns sorted version of list with duplicates removed *)\nlet dedup_and_sort ~compare list =\n match list with\n | [] | [ _ ] -> list (* performance hack *)\n | _ ->\n let equal x x' = compare x x' = 0 in\n let sorted = sort ~compare list in\n remove_consecutive_duplicates ~equal sorted\n;;\n\nlet find_a_dup ~compare l =\n let sorted = sort ~compare l in\n let rec loop l =\n match l with\n | [] | [ _ ] -> None\n | hd1 :: (hd2 :: _ as tl) -> if compare hd1 hd2 = 0 then Some hd1 else loop tl\n in\n loop sorted\n;;\n\nlet contains_dup ~compare lst =\n match find_a_dup ~compare lst with\n | Some _ -> true\n | None -> false\n;;\n\nlet find_all_dups ~compare l =\n (* We add this reversal, so we can skip a [rev] at the end. We could skip\n [rev] anyway since we don not give any ordering guarantees, but it is\n nice to get results in natural order. *)\n let compare a b = -1 * compare a b in\n let sorted = sort ~compare l in\n (* Walk the list and record the first of each consecutive run of identical elements *)\n let rec loop sorted prev ~already_recorded acc =\n match sorted with\n | [] -> acc\n | hd :: tl ->\n if compare prev hd <> 0\n then loop tl hd ~already_recorded:false acc\n else if already_recorded\n then loop tl hd ~already_recorded:true acc\n else loop tl hd ~already_recorded:true (hd :: acc)\n in\n match sorted with\n | [] -> []\n | hd :: tl -> loop tl hd ~already_recorded:false []\n;;\n\nlet count t ~f = Container.count ~fold t ~f\nlet sum m t ~f = Container.sum ~fold m t ~f\nlet min_elt t ~compare = Container.min_elt ~fold t ~compare\nlet max_elt t ~compare = Container.max_elt ~fold t ~compare\n\nlet counti t ~f =\n foldi t ~init:0 ~f:(fun idx count a -> if f idx a then count + 1 else count)\n;;\n\nlet init n ~f =\n if n < 0 then invalid_argf \"List.init %d\" n ();\n let rec loop i accum =\n assert (i >= 0);\n if i = 0 then accum else loop (i - 1) (f (i - 1) :: accum)\n in\n loop n []\n;;\n\nlet rev_filter_map l ~f =\n let rec loop l accum =\n match l with\n | [] -> accum\n | hd :: tl ->\n (match f hd with\n | Some x -> loop tl (x :: accum)\n | None -> loop tl accum)\n in\n loop l []\n;;\n\nlet filter_map l ~f = rev (rev_filter_map l ~f)\n\nlet rev_filter_mapi l ~f =\n let rec loop i l accum =\n match l with\n | [] -> accum\n | hd :: tl ->\n (match f i hd with\n | Some x -> loop (i + 1) tl (x :: accum)\n | None -> loop (i + 1) tl accum)\n in\n loop 0 l []\n;;\n\nlet filter_mapi l ~f = rev (rev_filter_mapi l ~f)\nlet filter_opt l = filter_map l ~f:Fn.id\n\nlet partition3_map t ~f =\n let rec loop t fst snd trd =\n match t with\n | [] -> rev fst, rev snd, rev trd\n | x :: t ->\n (match f x with\n | `Fst y -> loop t (y :: fst) snd trd\n | `Snd y -> loop t fst (y :: snd) trd\n | `Trd y -> loop t fst snd (y :: trd))\n in\n loop t [] [] []\n;;\n\nlet partition_tf t ~f =\n let f x : _ Either.t = if f x then First x else Second x in\n partition_map t ~f\n;;\n\nlet partition_result t = partition_map t ~f:Result.to_either\n\nmodule Assoc = struct\n type ('a, 'b) t = ('a * 'b) list [@@deriving_inline sexp]\n\n let t_of_sexp :\n 'a 'b. (Ppx_sexp_conv_lib.Sexp.t -> 'a) -> (Ppx_sexp_conv_lib.Sexp.t -> 'b)\n -> Ppx_sexp_conv_lib.Sexp.t -> ('a, 'b) t\n =\n let _tp_loc = \"list.ml.Assoc.t\" in\n fun _of_a _of_b t ->\n list_of_sexp\n (function\n | Ppx_sexp_conv_lib.Sexp.List [ v0; v1 ] ->\n let v0 = _of_a v0\n and v1 = _of_b v1 in\n v0, v1\n | sexp -> Ppx_sexp_conv_lib.Conv_error.tuple_of_size_n_expected _tp_loc 2 sexp)\n t\n ;;\n\n let sexp_of_t :\n 'a 'b. ('a -> Ppx_sexp_conv_lib.Sexp.t) -> ('b -> Ppx_sexp_conv_lib.Sexp.t)\n -> ('a, 'b) t -> Ppx_sexp_conv_lib.Sexp.t\n =\n fun _of_a _of_b v ->\n sexp_of_list\n (function\n | v0, v1 ->\n let v0 = _of_a v0\n and v1 = _of_b v1 in\n Ppx_sexp_conv_lib.Sexp.List [ v0; v1 ])\n v\n ;;\n\n [@@@end]\n\n let find t ~equal key =\n match find t ~f:(fun (key', _) -> equal key key') with\n | None -> None\n | Some x -> Some (snd x)\n ;;\n\n let find_exn =\n let not_found = Not_found_s (Atom \"List.Assoc.find_exn: not found\") in\n let find_exn t ~equal key =\n match find t key ~equal with\n | None -> raise not_found\n | Some value -> value\n in\n (* named to preserve symbol in compiled binary *)\n find_exn\n ;;\n\n let mem t ~equal key =\n match find t ~equal key with\n | None -> false\n | Some _ -> true\n ;;\n\n let remove t ~equal key = filter t ~f:(fun (key', _) -> not (equal key key'))\n\n let add t ~equal key value =\n (* the remove doesn't change the map semantics, but keeps the list small *)\n (key, value) :: remove t ~equal key\n ;;\n\n let inverse t = map t ~f:(fun (x, y) -> y, x)\n let map t ~f = map t ~f:(fun (key, value) -> key, f value)\nend\n\nlet sub l ~pos ~len =\n (* We use [pos > length l - len] rather than [pos + len > length l] to avoid the\n possibility of overflow. *)\n if pos < 0 || len < 0 || pos > length l - len then invalid_arg \"List.sub\";\n rev\n (foldi l ~init:[] ~f:(fun i acc el ->\n if i >= pos && i < pos + len then el :: acc else acc))\n;;\n\nlet split_n t_orig n =\n if n <= 0\n then [], t_orig\n else (\n let rec loop n t accum =\n if n = 0\n then rev accum, t\n else (\n match t with\n | [] -> t_orig, [] (* in this case, t_orig = rev accum *)\n | hd :: tl -> loop (n - 1) tl (hd :: accum))\n in\n loop n t_orig [])\n;;\n\n(* copied from [split_n] to avoid allocating a tuple *)\nlet take t_orig n =\n if n <= 0\n then []\n else (\n let rec loop n t accum =\n if n = 0\n then rev accum\n else (\n match t with\n | [] -> t_orig\n | hd :: tl -> loop (n - 1) tl (hd :: accum))\n in\n loop n t_orig [])\n;;\n\nlet rec drop t n =\n match t with\n | _ :: tl when n > 0 -> drop tl (n - 1)\n | t -> t\n;;\n\nlet chunks_of l ~length =\n if length <= 0\n then invalid_argf \"List.chunks_of: Expected length > 0, got %d\" length ();\n let rec aux of_length acc l =\n match l with\n | [] -> rev acc\n | _ :: _ ->\n let sublist, l = split_n l length in\n aux of_length (sublist :: acc) l\n in\n aux length [] l\n;;\n\nlet split_while xs ~f =\n let rec loop acc = function\n | hd :: tl when f hd -> loop (hd :: acc) tl\n | t -> rev acc, t\n in\n loop [] xs\n;;\n\n(* copied from [split_while] to avoid allocating a tuple *)\nlet take_while xs ~f =\n let rec loop acc = function\n | hd :: tl when f hd -> loop (hd :: acc) tl\n | _ -> rev acc\n in\n loop [] xs\n;;\n\nlet rec drop_while t ~f =\n match t with\n | hd :: tl when f hd -> drop_while tl ~f\n | t -> t\n;;\n\nlet drop_last t =\n match rev t with\n | [] -> None\n | _ :: lst -> Some (rev lst)\n;;\n\nlet drop_last_exn t =\n match drop_last t with\n | None -> failwith \"List.drop_last_exn: empty list\"\n | Some lst -> lst\n;;\n\nlet cartesian_product list1 list2 =\n if is_empty list2\n then []\n else (\n let rec loop l1 l2 accum =\n match l1 with\n | [] -> accum\n | hd :: tl -> loop tl l2 (rev_append (map ~f:(fun x -> hd, x) l2) accum)\n in\n rev (loop list1 list2 []))\n;;\n\nlet concat l = fold_right l ~init:[] ~f:append\nlet concat_no_order l = fold l ~init:[] ~f:(fun acc l -> rev_append l acc)\nlet cons x l = x :: l\n\nlet is_sorted l ~compare =\n let rec loop l =\n match l with\n | [] | [ _ ] -> true\n | x1 :: (x2 :: _ as rest) -> compare x1 x2 <= 0 && loop rest\n in\n loop l\n;;\n\nlet is_sorted_strictly l ~compare =\n let rec loop l =\n match l with\n | [] | [ _ ] -> true\n | x1 :: (x2 :: _ as rest) -> compare x1 x2 < 0 && loop rest\n in\n loop l\n;;\n\nmodule Infix = struct\n let ( @ ) = append\nend\n\nlet permute ?(random_state = Random.State.default) list =\n match list with\n (* special cases to speed things up in trivial cases *)\n | [] | [ _ ] -> list\n | [ x; y ] -> if Random.State.bool random_state then [ y; x ] else list\n | _ ->\n let arr = Array.of_list list in\n Array_permute.permute arr ~random_state;\n Array.to_list arr\n;;\n\nlet random_element_exn ?(random_state = Random.State.default) list =\n if is_empty list\n then failwith \"List.random_element_exn: empty list\"\n else nth_exn list (Random.State.int random_state (length list))\n;;\n\nlet random_element ?(random_state = Random.State.default) list =\n try Some (random_element_exn ~random_state list) with\n | _ -> None\n;;\n\nlet rec compare cmp a b =\n match a, b with\n | [], [] -> 0\n | [], _ -> -1\n | _, [] -> 1\n | x :: xs, y :: ys ->\n let n = cmp x y in\n if n = 0 then compare cmp xs ys else n\n;;\n\nlet hash_fold_t = hash_fold_list\n\nlet equal equal t1 t2 =\n let rec loop ~equal t1 t2 =\n match t1, t2 with\n | [], [] -> true\n | x1 :: t1, x2 :: t2 -> equal x1 x2 && loop ~equal t1 t2\n | _ -> false\n in\n loop ~equal t1 t2\n;;\n\nlet transpose =\n let rec transpose_aux t rev_columns =\n match\n partition_map t ~f:(function\n | [] -> Second ()\n | x :: xs -> First (x, xs))\n with\n | _ :: _, _ :: _ -> None\n | [], _ -> Some (rev_append rev_columns [])\n | heads_and_tails, [] ->\n let column, trimmed_rows = unzip heads_and_tails in\n transpose_aux trimmed_rows (column :: rev_columns)\n in\n fun t -> transpose_aux t []\n;;\n\nexception Transpose_got_lists_of_different_lengths of int list [@@deriving_inline sexp]\n\nlet () =\n Ppx_sexp_conv_lib.Conv.Exn_converter.add\n [%extension_constructor Transpose_got_lists_of_different_lengths]\n (function\n | Transpose_got_lists_of_different_lengths v0 ->\n let v0 = sexp_of_list sexp_of_int v0 in\n Ppx_sexp_conv_lib.Sexp.List\n [ Ppx_sexp_conv_lib.Sexp.Atom\n \"list.ml.Transpose_got_lists_of_different_lengths\"\n ; v0\n ]\n | _ -> assert false)\n;;\n\n[@@@end]\n\nlet transpose_exn l =\n match transpose l with\n | Some l -> l\n | None -> raise (Transpose_got_lists_of_different_lengths (map l ~f:length))\n;;\n\nlet intersperse t ~sep =\n match t with\n | [] -> []\n | x :: xs -> x :: fold_right xs ~init:[] ~f:(fun y acc -> sep :: y :: acc)\n;;\n\nlet fold_result t ~init ~f = Container.fold_result ~fold ~init ~f t\nlet fold_until t ~init ~f = Container.fold_until ~fold ~init ~f t\n\nlet is_suffix list ~suffix ~equal:equal_elt =\n let list_len = length list in\n let suffix_len = length suffix in\n list_len >= suffix_len && equal equal_elt (drop list (list_len - suffix_len)) suffix\n;;\n","open! Import\n\ntype t =\n | Less\n | Equal\n | Greater\n[@@deriving_inline compare, hash, enumerate, sexp]\n\nlet compare = (Ppx_compare_lib.polymorphic_compare : t -> t -> int)\n\nlet (hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state) =\n (fun hsv arg ->\n match arg with\n | Less -> Ppx_hash_lib.Std.Hash.fold_int hsv 0\n | Equal -> Ppx_hash_lib.Std.Hash.fold_int hsv 1\n | Greater -> Ppx_hash_lib.Std.Hash.fold_int hsv 2\n : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state)\n;;\n\nlet (hash : t -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func arg =\n Ppx_hash_lib.Std.Hash.get_hash_value\n (let hsv = Ppx_hash_lib.Std.Hash.create () in\n hash_fold_t hsv arg)\n in\n fun x -> func x\n;;\n\nlet all = ([ Less; Equal; Greater ] : t list)\n\nlet t_of_sexp =\n (let _tp_loc = \"ordering.ml.t\" in\n function\n | Ppx_sexp_conv_lib.Sexp.Atom (\"less\" | \"Less\") -> Less\n | Ppx_sexp_conv_lib.Sexp.Atom (\"equal\" | \"Equal\") -> Equal\n | Ppx_sexp_conv_lib.Sexp.Atom (\"greater\" | \"Greater\") -> Greater\n | Ppx_sexp_conv_lib.Sexp.List (Ppx_sexp_conv_lib.Sexp.Atom (\"less\" | \"Less\") :: _) as\n sexp -> Ppx_sexp_conv_lib.Conv_error.stag_no_args _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.List (Ppx_sexp_conv_lib.Sexp.Atom (\"equal\" | \"Equal\") :: _)\n as sexp -> Ppx_sexp_conv_lib.Conv_error.stag_no_args _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.List\n (Ppx_sexp_conv_lib.Sexp.Atom (\"greater\" | \"Greater\") :: _) as sexp ->\n Ppx_sexp_conv_lib.Conv_error.stag_no_args _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.List (Ppx_sexp_conv_lib.Sexp.List _ :: _) as sexp ->\n Ppx_sexp_conv_lib.Conv_error.nested_list_invalid_sum _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.List [] as sexp ->\n Ppx_sexp_conv_lib.Conv_error.empty_list_invalid_sum _tp_loc sexp\n | sexp -> Ppx_sexp_conv_lib.Conv_error.unexpected_stag _tp_loc sexp\n : Ppx_sexp_conv_lib.Sexp.t -> t)\n;;\n\nlet sexp_of_t =\n (function\n | Less -> Ppx_sexp_conv_lib.Sexp.Atom \"Less\"\n | Equal -> Ppx_sexp_conv_lib.Sexp.Atom \"Equal\"\n | Greater -> Ppx_sexp_conv_lib.Sexp.Atom \"Greater\"\n : t -> Ppx_sexp_conv_lib.Sexp.t)\n;;\n\n[@@@end]\n\nlet equal a b = compare a b = 0\n\nmodule Export = struct\n type _ordering = t =\n | Less\n | Equal\n | Greater\nend\n\nlet of_int n = if n < 0 then Less else if n = 0 then Equal else Greater\n\nlet to_int = function\n | Less -> -1\n | Equal -> 0\n | Greater -> 1\n;;\n","open! Import\ninclude Applicative_intf\n\n(** This module serves mostly as a partial check that [S2] and [S] are in sync, but\n actually calling it is occasionally useful. *)\nmodule S_to_S2 (X : S) : S2 with type ('a, 'e) t = 'a X.t = struct\n type ('a, 'e) t = 'a X.t\n\n include (X : S with type 'a t := 'a X.t)\nend\n\nmodule S2_to_S (X : S2) : S with type 'a t = ('a, unit) X.t = struct\n type 'a t = ('a, unit) X.t\n\n include (X : S2 with type ('a, 'e) t := ('a, 'e) X.t)\nend\n\nmodule S2_to_S3 (X : S2) : S3 with type ('a, 'd, 'e) t = ('a, 'd) X.t = struct\n type ('a, 'd, 'e) t = ('a, 'd) X.t\n\n include (X : S2 with type ('a, 'd) t := ('a, 'd) X.t)\nend\n\nmodule S3_to_S2 (X : S3) : S2 with type ('a, 'd) t = ('a, 'd, unit) X.t = struct\n type ('a, 'd) t = ('a, 'd, unit) X.t\n\n include (X : S3 with type ('a, 'd, 'e) t := ('a, 'd, 'e) X.t)\nend\n\n(* These functors serve only to check that the signatures for various Foo and Foo2 module\n types don't drift apart over time.\n*)\nmodule Check_compatibility = struct\n module Applicative_infix_to_Applicative_infix2 (X : Applicative_infix) :\n Applicative_infix2 with type ('a, 'e) t = 'a X.t = struct\n type ('a, 'e) t = 'a X.t\n\n include (X : Applicative_infix with type 'a t := 'a X.t)\n end\n\n module Applicative_infix2_to_Applicative_infix (X : Applicative_infix2) :\n Applicative_infix with type 'a t = ('a, unit) X.t = struct\n type 'a t = ('a, unit) X.t\n\n include (X : Applicative_infix2 with type ('a, 'e) t := ('a, 'e) X.t)\n end\n\n module Applicative_infix2_to_Applicative_infix3 (X : Applicative_infix2) :\n Applicative_infix3 with type ('a, 'd, 'e) t = ('a, 'd) X.t = struct\n type ('a, 'd, 'e) t = ('a, 'd) X.t\n\n include (X : Applicative_infix2 with type ('a, 'd) t := ('a, 'd) X.t)\n end\n\n module Applicative_infix3_to_Applicative_infix2 (X : Applicative_infix3) :\n Applicative_infix2 with type ('a, 'd) t = ('a, 'd, unit) X.t = struct\n type ('a, 'd) t = ('a, 'd, unit) X.t\n\n include (X : Applicative_infix3 with type ('a, 'd, 'e) t := ('a, 'd, 'e) X.t)\n end\n\n module Let_syntax_to_Let_syntax2 (X : Let_syntax) :\n Let_syntax2 with type ('a, 'e) t = 'a X.t = struct\n type ('a, 'e) t = 'a X.t\n\n include (X : Let_syntax with type 'a t := 'a X.t)\n end\n\n module Let_syntax2_to_Let_syntax (X : Let_syntax2) :\n Let_syntax with type 'a t = ('a, unit) X.t = struct\n type 'a t = ('a, unit) X.t\n\n include (X : Let_syntax2 with type ('a, 'e) t := ('a, 'e) X.t)\n end\n\n module Let_syntax2_to_Let_syntax3 (X : Let_syntax2) :\n Let_syntax3 with type ('a, 'd, 'e) t = ('a, 'd) X.t = struct\n type ('a, 'd, 'e) t = ('a, 'd) X.t\n\n include (X : Let_syntax2 with type ('a, 'd) t := ('a, 'd) X.t)\n end\n\n module Let_syntax3_to_Let_syntax2 (X : Let_syntax3) :\n Let_syntax2 with type ('a, 'd) t = ('a, 'd, unit) X.t = struct\n type ('a, 'd) t = ('a, 'd, unit) X.t\n\n include (X : Let_syntax3 with type ('a, 'd, 'e) t := ('a, 'd, 'e) X.t)\n end\nend\n\nmodule Make3 (X : Basic3) : S3 with type ('a, 'd, 'e) t := ('a, 'd, 'e) X.t = struct\n include X\n\n let ( <*> ) = apply\n let derived_map t ~f = return f <*> t\n\n let map =\n match X.map with\n | `Define_using_apply -> derived_map\n | `Custom x -> x\n ;;\n\n let ( >>| ) t f = map t ~f\n let map2 ta tb ~f = map ~f ta <*> tb\n let map3 ta tb tc ~f = map ~f ta <*> tb <*> tc\n let all ts = List.fold_right ts ~init:(return []) ~f:(map2 ~f:(fun x xs -> x :: xs))\n let both ta tb = map2 ta tb ~f:(fun a b -> a, b)\n let ( *> ) u v = return (fun () y -> y) <*> u <*> v\n let ( <* ) u v = return (fun x () -> x) <*> u <*> v\n let all_unit ts = List.fold ts ~init:(return ()) ~f:( *> )\n\n module Applicative_infix = struct\n let ( <*> ) = ( <*> )\n let ( *> ) = ( *> )\n let ( <* ) = ( <* )\n let ( >>| ) = ( >>| )\n end\nend\n\nmodule Make2 (X : Basic2) : S2 with type ('a, 'e) t := ('a, 'e) X.t = Make3 (struct\n type ('a, 'd, 'e) t = ('a, 'd) X.t\n\n include (X : Basic2 with type ('a, 'e) t := ('a, 'e) X.t)\n end)\n\nmodule Make (X : Basic) : S with type 'a t := 'a X.t = Make2 (struct\n type ('a, 'e) t = 'a X.t\n\n include (X : Basic with type 'a t := 'a X.t)\n end)\n\nmodule Make_let_syntax3\n (X : For_let_syntax3) (Intf : sig\n module type S\n end)\n (Impl : Intf.S) =\nstruct\n module Let_syntax = struct\n include X\n\n module Let_syntax = struct\n include X\n module Open_on_rhs = Impl\n end\n end\nend\n\nmodule Make_let_syntax2\n (X : For_let_syntax2) (Intf : sig\n module type S\n end)\n (Impl : Intf.S) =\n Make_let_syntax3\n (struct\n type ('a, 'd, _) t = ('a, 'd) X.t\n\n include (X : For_let_syntax2 with type ('a, 'e) t := ('a, 'e) X.t)\n end)\n (Intf)\n (Impl)\n\nmodule Make_let_syntax\n (X : For_let_syntax) (Intf : sig\n module type S\n end)\n (Impl : Intf.S) =\n Make_let_syntax2\n (struct\n type ('a, _) t = 'a X.t\n\n include (X : For_let_syntax with type 'a t := 'a X.t)\n end)\n (Intf)\n (Impl)\n\nmodule Make3_using_map2 (X : Basic3_using_map2) = Make3 (struct\n include X\n\n let apply tf tx = map2 tf tx ~f:(fun f x -> f x)\n\n let map =\n match map with\n | `Custom map -> `Custom map\n | `Define_using_map2 -> `Define_using_apply\n ;;\n end)\n\nmodule Make2_using_map2 (X : Basic2_using_map2) :\n S2 with type ('a, 'e) t := ('a, 'e) X.t = Make3_using_map2 (struct\n type ('a, 'd, 'e) t = ('a, 'd) X.t\n\n include (X : Basic2_using_map2 with type ('a, 'e) t := ('a, 'e) X.t)\n end)\n\nmodule Make_using_map2 (X : Basic_using_map2) : S with type 'a t := 'a X.t =\n Make2_using_map2 (struct\n type ('a, 'e) t = 'a X.t\n\n include (X : Basic_using_map2 with type 'a t := 'a X.t)\n end)\n\nmodule Of_monad2 (M : Monad.S2) : S2 with type ('a, 'e) t := ('a, 'e) M.t = Make2 (struct\n type ('a, 'e) t = ('a, 'e) M.t\n\n let return = M.return\n let apply mf mx = M.bind mf ~f:(fun f -> M.map mx ~f)\n let map = `Custom M.map\n end)\n\nmodule Of_monad (M : Monad.S) : S with type 'a t := 'a M.t = Of_monad2 (struct\n type ('a, _) t = 'a M.t\n\n include (M : Monad.S with type 'a t := 'a M.t)\n end)\n\nmodule Compose (F : S) (G : S) : S with type 'a t = 'a F.t G.t = struct\n type 'a t = 'a F.t G.t\n\n include Make (struct\n type nonrec 'a t = 'a t\n\n let return a = G.return (F.return a)\n let apply tf tx = G.apply (G.map ~f:F.apply tf) tx\n let custom_map t ~f = G.map ~f:(F.map ~f) t\n let map = `Custom custom_map\n end)\nend\n\nmodule Pair (F : S) (G : S) : S with type 'a t = 'a F.t * 'a G.t = struct\n type 'a t = 'a F.t * 'a G.t\n\n include Make (struct\n type nonrec 'a t = 'a t\n\n let return a = F.return a, G.return a\n let apply tf tx = F.apply (fst tf) (fst tx), G.apply (snd tf) (snd tx)\n let custom_map t ~f = F.map ~f (fst t), G.map ~f (snd t)\n let map = `Custom custom_map\n end)\nend\n","(* This module is trying to minimize dependencies on modules in Core, so as to allow\n [Info], [Error], and [Or_error] to be used in as many places as possible. Please avoid\n adding new dependencies. *)\n\nopen! Import\ninclude Info_intf\nmodule String = String0\n\nmodule Message = struct\n type t =\n | Could_not_construct of Sexp.t\n | String of string\n | Exn of exn\n | Sexp of Sexp.t\n | Tag_sexp of string * Sexp.t * Source_code_position0.t option\n | Tag_t of string * t\n | Tag_arg of string * Sexp.t * t\n | Of_list of int option * t list\n | With_backtrace of t * string (* backtrace *)\n [@@deriving_inline sexp_of]\n\n let rec sexp_of_t =\n (function\n | Could_not_construct v0 ->\n let v0 = Sexp.sexp_of_t v0 in\n Ppx_sexp_conv_lib.Sexp.List\n [ Ppx_sexp_conv_lib.Sexp.Atom \"Could_not_construct\"; v0 ]\n | String v0 ->\n let v0 = sexp_of_string v0 in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"String\"; v0 ]\n | Exn v0 ->\n let v0 = sexp_of_exn v0 in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"Exn\"; v0 ]\n | Sexp v0 ->\n let v0 = Sexp.sexp_of_t v0 in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"Sexp\"; v0 ]\n | Tag_sexp (v0, v1, v2) ->\n let v0 = sexp_of_string v0\n and v1 = Sexp.sexp_of_t v1\n and v2 = sexp_of_option Source_code_position0.sexp_of_t v2 in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"Tag_sexp\"; v0; v1; v2 ]\n | Tag_t (v0, v1) ->\n let v0 = sexp_of_string v0\n and v1 = sexp_of_t v1 in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"Tag_t\"; v0; v1 ]\n | Tag_arg (v0, v1, v2) ->\n let v0 = sexp_of_string v0\n and v1 = Sexp.sexp_of_t v1\n and v2 = sexp_of_t v2 in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"Tag_arg\"; v0; v1; v2 ]\n | Of_list (v0, v1) ->\n let v0 = sexp_of_option sexp_of_int v0\n and v1 = sexp_of_list sexp_of_t v1 in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"Of_list\"; v0; v1 ]\n | With_backtrace (v0, v1) ->\n let v0 = sexp_of_t v0\n and v1 = sexp_of_string v1 in\n Ppx_sexp_conv_lib.Sexp.List\n [ Ppx_sexp_conv_lib.Sexp.Atom \"With_backtrace\"; v0; v1 ]\n : t -> Ppx_sexp_conv_lib.Sexp.t)\n ;;\n\n [@@@end]\n\n let rec to_strings_hum t ac =\n (* We use [Sexp.to_string_mach], despite the fact that we are implementing\n [to_strings_hum], because we want the info to fit on a single line, and once we've\n had to resort to sexps, the message is going to start not looking so pretty\n anyway. *)\n match t with\n | Could_not_construct sexp ->\n \"could not construct info: \" :: Sexp.to_string_mach sexp :: ac\n | String string -> string :: ac\n | Exn exn -> Sexp.to_string_mach (Exn.sexp_of_t exn) :: ac\n | Sexp sexp -> Sexp.to_string_mach sexp :: ac\n | Tag_sexp (tag, sexp, _) -> tag :: \": \" :: Sexp.to_string_mach sexp :: ac\n | Tag_t (tag, t) -> tag :: \": \" :: to_strings_hum t ac\n | Tag_arg (tag, sexp, t) ->\n let body = Sexp.to_string_mach sexp :: \": \" :: to_strings_hum t ac in\n if String.length tag = 0 then body else tag :: \": \" :: body\n | With_backtrace (t, backtrace) ->\n to_strings_hum t (\"\\nBacktrace:\\n\" :: backtrace :: ac)\n | Of_list (trunc_after, ts) ->\n let ts =\n match trunc_after with\n | None -> ts\n | Some max ->\n let n = List.length ts in\n if n <= max\n then ts\n else List.take ts max @ [ String (Printf.sprintf \"and %d more info\" (n - max)) ]\n in\n List.fold (List.rev ts) ~init:ac ~f:(fun ac t ->\n to_strings_hum t (if List.is_empty ac then ac else \"; \" :: ac))\n ;;\n\n let to_string_hum_deprecated t = String.concat (to_strings_hum t [])\n\n let rec to_sexps_hum t ac =\n match t with\n | Could_not_construct _ as t -> sexp_of_t t :: ac\n | String string -> Atom string :: ac\n | Exn exn -> Exn.sexp_of_t exn :: ac\n | Sexp sexp -> sexp :: ac\n | Tag_sexp (tag, sexp, here) ->\n List\n (Atom tag\n :: sexp\n ::\n (match here with\n | None -> []\n | Some here -> [ Source_code_position0.sexp_of_t here ]))\n :: ac\n | Tag_t (tag, t) -> List (Atom tag :: to_sexps_hum t []) :: ac\n | Tag_arg (tag, sexp, t) ->\n let body = sexp :: to_sexps_hum t [] in\n if String.length tag = 0 then List body :: ac else List (Atom tag :: body) :: ac\n | With_backtrace (t, backtrace) ->\n Sexp.List [ to_sexp_hum t; Sexp.Atom backtrace ] :: ac\n | Of_list (_, ts) ->\n List.fold (List.rev ts) ~init:ac ~f:(fun ac t -> to_sexps_hum t ac)\n\n and to_sexp_hum t =\n match to_sexps_hum t [] with\n | [ sexp ] -> sexp\n | sexps -> Sexp.List sexps\n ;;\n\n (* We use [protect] to guard against exceptions raised by user-supplied functions, so\n that failure to produce one part of an info doesn't interfere with other parts. *)\n let protect f =\n try f () with\n | exn -> Could_not_construct (Exn.sexp_of_t exn)\n ;;\n\n let of_info info = protect (fun () -> Lazy.force info)\n let to_info t = lazy t\nend\n\nopen Message\n\ntype t = Message.t Lazy.t\n\nlet invariant _ = ()\nlet to_message = Message.of_info\nlet of_message = Message.to_info\n\n(* It is OK to use [Message.to_sexp_hum], which is not stable, because [t_of_sexp] below\n can handle any sexp. *)\nlet sexp_of_t t = Message.to_sexp_hum (to_message t)\nlet t_of_sexp sexp = lazy (Message.Sexp sexp)\nlet compare t1 t2 = Sexp.compare (sexp_of_t t1) (sexp_of_t t2)\nlet equal t1 t2 = Sexp.equal (sexp_of_t t1) (sexp_of_t t2)\nlet hash_fold_t state t = Sexp.hash_fold_t state (sexp_of_t t)\nlet hash t = Hash.run hash_fold_t t\n\nlet to_string_hum t =\n match to_message t with\n | String s -> s\n | message -> Sexp.to_string_hum (Message.to_sexp_hum message)\n;;\n\nlet to_string_hum_deprecated t = Message.to_string_hum_deprecated (to_message t)\nlet to_string_mach t = Sexp.to_string_mach (sexp_of_t t)\nlet of_lazy l = lazy (protect (fun () -> String (Lazy.force l)))\nlet of_lazy_t lazy_t = Lazy.join lazy_t\nlet of_string message = Lazy.from_val (String message)\nlet createf format = Printf.ksprintf of_string format\nlet of_thunk f = lazy (protect (fun () -> String (f ())))\n\nlet create ?here ?strict tag x sexp_of_x =\n match strict with\n | None -> lazy (protect (fun () -> Tag_sexp (tag, sexp_of_x x, here)))\n | Some () -> of_message (Tag_sexp (tag, sexp_of_x x, here))\n;;\n\nlet create_s sexp = Lazy.from_val (Sexp sexp)\nlet tag t ~tag = lazy (Tag_t (tag, to_message t))\nlet tag_s t ~tag = lazy (protect (fun () -> Tag_arg (\"\", tag, to_message t)))\n\nlet tag_arg t tag x sexp_of_x =\n lazy (protect (fun () -> Tag_arg (tag, sexp_of_x x, to_message t)))\n;;\n\nlet of_list ?trunc_after ts = lazy (Of_list (trunc_after, List.map ts ~f:to_message))\n\nexception Exn of t\n\nlet () =\n (* We install a custom exn-converter rather than use\n [exception Exn of t [@@deriving_inline sexp] ... [@@@end]] to eliminate the extra\n wrapping of \"(Exn ...)\". *)\n Sexplib.Conv.Exn_converter.add [%extension_constructor Exn] (function\n | Exn t -> sexp_of_t t\n | _ ->\n (* Reaching this branch indicates a bug in sexplib. *)\n assert false)\n;;\n\nlet to_exn t =\n if not (Lazy.is_val t)\n then Exn t\n else (\n match Lazy.force t with\n | Message.Exn exn -> exn\n | _ -> Exn t)\n;;\n\nlet of_exn ?backtrace exn =\n let backtrace =\n match backtrace with\n | None -> None\n | Some `Get -> Some (Caml.Printexc.get_backtrace ())\n | Some (`This s) -> Some s\n in\n match exn, backtrace with\n | Exn t, None -> t\n | Exn t, Some backtrace -> lazy (With_backtrace (to_message t, backtrace))\n | _, None -> Lazy.from_val (Message.Exn exn)\n | _, Some backtrace -> lazy (With_backtrace (Sexp (Exn.sexp_of_t exn), backtrace))\n;;\n\ninclude Pretty_printer.Register_pp (struct\n type nonrec t = t\n\n let module_name = \"Base.Info\"\n let pp ppf t = Caml.Format.pp_print_string ppf (to_string_hum t)\n end)\n\nmodule Internal_repr = Message\n\n","(* This module is trying to minimize dependencies on modules in Core, so as to allow\n [Error] and [Or_error] to be used in various places. Please avoid adding new\n dependencies. *)\n\nopen! Import\ninclude Info\n\nlet raise t = raise (to_exn t)\nlet raise_s sexp = raise (create_s sexp)\nlet to_info t = t\nlet of_info t = t\n\ninclude Pretty_printer.Register_pp (struct\n type nonrec t = t\n\n let module_name = \"Base.Error\"\n let pp = pp\n end)\n","open! Import\ninclude Invariant_intf\n\nlet raise_s = Error.raise_s\n\nlet invariant here t sexp_of_t f : unit =\n try f () with\n | exn ->\n raise_s\n (Sexp.message\n \"invariant failed\"\n [ \"\", Source_code_position0.sexp_of_t here\n ; \"exn\", sexp_of_exn exn\n ; \"\", sexp_of_t t\n ])\n;;\n\nlet check_field t f field =\n try f (Field.get field t) with\n | exn ->\n raise_s\n (Sexp.message\n \"problem with field\"\n [ \"field\", sexp_of_string (Field.name field); \"exn\", sexp_of_exn exn ])\n;;\n","open! Import\n\ntype 'a t =\n | Incl of 'a\n | Excl of 'a\n | Unbounded\n[@@deriving_inline enumerate, sexp]\n\nlet all : 'a. 'a list -> 'a t list =\n fun _all_of_a ->\n Ppx_enumerate_lib.List.append\n (let rec map l acc =\n match l with\n | [] -> Ppx_enumerate_lib.List.rev acc\n | enumerate__001_ :: l -> map l (Incl enumerate__001_ :: acc)\n in\n map _all_of_a [])\n (Ppx_enumerate_lib.List.append\n (let rec map l acc =\n match l with\n | [] -> Ppx_enumerate_lib.List.rev acc\n | enumerate__002_ :: l -> map l (Excl enumerate__002_ :: acc)\n in\n map _all_of_a [])\n [ Unbounded ])\n;;\n\nlet t_of_sexp\n : type a. (Ppx_sexp_conv_lib.Sexp.t -> a) -> Ppx_sexp_conv_lib.Sexp.t -> a t\n =\n let _tp_loc = \"maybe_bound.ml.t\" in\n fun _of_a -> function\n | Ppx_sexp_conv_lib.Sexp.List\n (Ppx_sexp_conv_lib.Sexp.Atom ((\"incl\" | \"Incl\") as _tag) :: sexp_args) as _sexp\n ->\n (match sexp_args with\n | [ v0 ] ->\n let v0 = _of_a v0 in\n Incl v0\n | _ -> Ppx_sexp_conv_lib.Conv_error.stag_incorrect_n_args _tp_loc _tag _sexp)\n | Ppx_sexp_conv_lib.Sexp.List\n (Ppx_sexp_conv_lib.Sexp.Atom ((\"excl\" | \"Excl\") as _tag) :: sexp_args) as _sexp\n ->\n (match sexp_args with\n | [ v0 ] ->\n let v0 = _of_a v0 in\n Excl v0\n | _ -> Ppx_sexp_conv_lib.Conv_error.stag_incorrect_n_args _tp_loc _tag _sexp)\n | Ppx_sexp_conv_lib.Sexp.Atom (\"unbounded\" | \"Unbounded\") -> Unbounded\n | Ppx_sexp_conv_lib.Sexp.Atom (\"incl\" | \"Incl\") as sexp ->\n Ppx_sexp_conv_lib.Conv_error.stag_takes_args _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.Atom (\"excl\" | \"Excl\") as sexp ->\n Ppx_sexp_conv_lib.Conv_error.stag_takes_args _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.List\n (Ppx_sexp_conv_lib.Sexp.Atom (\"unbounded\" | \"Unbounded\") :: _) as sexp ->\n Ppx_sexp_conv_lib.Conv_error.stag_no_args _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.List (Ppx_sexp_conv_lib.Sexp.List _ :: _) as sexp ->\n Ppx_sexp_conv_lib.Conv_error.nested_list_invalid_sum _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.List [] as sexp ->\n Ppx_sexp_conv_lib.Conv_error.empty_list_invalid_sum _tp_loc sexp\n | sexp -> Ppx_sexp_conv_lib.Conv_error.unexpected_stag _tp_loc sexp\n;;\n\nlet sexp_of_t\n : type a. (a -> Ppx_sexp_conv_lib.Sexp.t) -> a t -> Ppx_sexp_conv_lib.Sexp.t\n =\n fun _of_a -> function\n | Incl v0 ->\n let v0 = _of_a v0 in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"Incl\"; v0 ]\n | Excl v0 ->\n let v0 = _of_a v0 in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"Excl\"; v0 ]\n | Unbounded -> Ppx_sexp_conv_lib.Sexp.Atom \"Unbounded\"\n;;\n\n[@@@end]\n\ntype interval_comparison =\n | Below_lower_bound\n | In_range\n | Above_upper_bound\n[@@deriving_inline sexp, compare, hash]\n\nlet interval_comparison_of_sexp =\n (let _tp_loc = \"maybe_bound.ml.interval_comparison\" in\n function\n | Ppx_sexp_conv_lib.Sexp.Atom (\"below_lower_bound\" | \"Below_lower_bound\") ->\n Below_lower_bound\n | Ppx_sexp_conv_lib.Sexp.Atom (\"in_range\" | \"In_range\") -> In_range\n | Ppx_sexp_conv_lib.Sexp.Atom (\"above_upper_bound\" | \"Above_upper_bound\") ->\n Above_upper_bound\n | Ppx_sexp_conv_lib.Sexp.List\n (Ppx_sexp_conv_lib.Sexp.Atom (\"below_lower_bound\" | \"Below_lower_bound\") :: _) as\n sexp -> Ppx_sexp_conv_lib.Conv_error.stag_no_args _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.List\n (Ppx_sexp_conv_lib.Sexp.Atom (\"in_range\" | \"In_range\") :: _) as sexp ->\n Ppx_sexp_conv_lib.Conv_error.stag_no_args _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.List\n (Ppx_sexp_conv_lib.Sexp.Atom (\"above_upper_bound\" | \"Above_upper_bound\") :: _) as\n sexp -> Ppx_sexp_conv_lib.Conv_error.stag_no_args _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.List (Ppx_sexp_conv_lib.Sexp.List _ :: _) as sexp ->\n Ppx_sexp_conv_lib.Conv_error.nested_list_invalid_sum _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.List [] as sexp ->\n Ppx_sexp_conv_lib.Conv_error.empty_list_invalid_sum _tp_loc sexp\n | sexp -> Ppx_sexp_conv_lib.Conv_error.unexpected_stag _tp_loc sexp\n : Ppx_sexp_conv_lib.Sexp.t -> interval_comparison)\n;;\n\nlet sexp_of_interval_comparison =\n (function\n | Below_lower_bound -> Ppx_sexp_conv_lib.Sexp.Atom \"Below_lower_bound\"\n | In_range -> Ppx_sexp_conv_lib.Sexp.Atom \"In_range\"\n | Above_upper_bound -> Ppx_sexp_conv_lib.Sexp.Atom \"Above_upper_bound\"\n : interval_comparison -> Ppx_sexp_conv_lib.Sexp.t)\n;;\n\nlet compare_interval_comparison =\n (Ppx_compare_lib.polymorphic_compare\n : interval_comparison -> interval_comparison -> int)\n;;\n\nlet (hash_fold_interval_comparison :\n Ppx_hash_lib.Std.Hash.state -> interval_comparison -> Ppx_hash_lib.Std.Hash.state)\n =\n (fun hsv arg ->\n match arg with\n | Below_lower_bound -> Ppx_hash_lib.Std.Hash.fold_int hsv 0\n | In_range -> Ppx_hash_lib.Std.Hash.fold_int hsv 1\n | Above_upper_bound -> Ppx_hash_lib.Std.Hash.fold_int hsv 2\n : Ppx_hash_lib.Std.Hash.state -> interval_comparison -> Ppx_hash_lib.Std.Hash.state)\n;;\n\nlet (hash_interval_comparison : interval_comparison -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func arg =\n Ppx_hash_lib.Std.Hash.get_hash_value\n (let hsv = Ppx_hash_lib.Std.Hash.create () in\n hash_fold_interval_comparison hsv arg)\n in\n fun x -> func x\n;;\n\n[@@@end]\n\nlet map t ~f =\n match t with\n | Incl incl -> Incl (f incl)\n | Excl excl -> Excl (f excl)\n | Unbounded -> Unbounded\n;;\n\nlet is_lower_bound t ~of_:a ~compare =\n match t with\n | Incl incl -> compare incl a <= 0\n | Excl excl -> compare excl a < 0\n | Unbounded -> true\n;;\n\nlet is_upper_bound t ~of_:a ~compare =\n match t with\n | Incl incl -> compare a incl <= 0\n | Excl excl -> compare a excl < 0\n | Unbounded -> true\n;;\n\nlet bounds_crossed ~lower ~upper ~compare =\n match lower with\n | Unbounded -> false\n | Incl lower | Excl lower ->\n (match upper with\n | Unbounded -> false\n | Incl upper | Excl upper -> compare lower upper > 0)\n;;\n\nlet check_interval_exn ~lower ~upper ~compare =\n if bounds_crossed ~lower ~upper ~compare\n then failwith \"Maybe_bound.compare_to_interval_exn: lower bound > upper bound\"\n;;\n\nlet compare_to_interval_exn ~lower ~upper a ~compare =\n check_interval_exn ~lower ~upper ~compare;\n if not (is_lower_bound lower ~of_:a ~compare)\n then Below_lower_bound\n else if not (is_upper_bound upper ~of_:a ~compare)\n then Above_upper_bound\n else In_range\n;;\n\nlet interval_contains_exn ~lower ~upper a ~compare =\n match compare_to_interval_exn ~lower ~upper a ~compare with\n | In_range -> true\n | Below_lower_bound | Above_upper_bound -> false\n;;\n","open! Import\n\ntype 'a t = ('a, Error.t) Result.t [@@deriving_inline compare, equal, hash, sexp]\n\nlet compare : 'a. ('a -> 'a -> int) -> 'a t -> 'a t -> int =\n fun _cmp__a a__001_ b__002_ -> Result.compare _cmp__a Error.compare a__001_ b__002_\n;;\n\nlet equal : 'a. ('a -> 'a -> bool) -> 'a t -> 'a t -> bool =\n fun _cmp__a a__007_ b__008_ -> Result.equal _cmp__a Error.equal a__007_ b__008_\n;;\n\nlet hash_fold_t :\n 'a. (Ppx_hash_lib.Std.Hash.state -> 'a -> Ppx_hash_lib.Std.Hash.state)\n -> Ppx_hash_lib.Std.Hash.state -> 'a t -> Ppx_hash_lib.Std.Hash.state\n =\n fun _hash_fold_a hsv arg -> Result.hash_fold_t _hash_fold_a Error.hash_fold_t hsv arg\n;;\n\nlet t_of_sexp : 'a. (Ppx_sexp_conv_lib.Sexp.t -> 'a) -> Ppx_sexp_conv_lib.Sexp.t -> 'a t =\n let _tp_loc = \"or_error.ml.t\" in\n fun _of_a t -> Result.t_of_sexp _of_a Error.t_of_sexp t\n;;\n\nlet sexp_of_t : 'a. ('a -> Ppx_sexp_conv_lib.Sexp.t) -> 'a t -> Ppx_sexp_conv_lib.Sexp.t =\n fun _of_a v -> Result.sexp_of_t _of_a Error.sexp_of_t v\n;;\n\n[@@@end]\n\nlet invariant invariant_a t =\n match t with\n | Ok a -> invariant_a a\n | Error error -> Error.invariant error\n;;\n\ninclude (\n Result :\n Monad.S2\n with type ('a, 'b) t := ('a, 'b) Result.t\n with module Let_syntax := Result.Let_syntax)\n\ninclude Applicative.Make (struct\n type nonrec 'a t = 'a t\n\n let return = return\n\n let apply f x =\n Result.combine f x ~ok:(fun f x -> f x) ~err:(fun e1 e2 -> Error.of_list [ e1; e2 ])\n ;;\n\n let map = `Custom map\n end)\n\nmodule Let_syntax = struct\n let return = return\n\n include Monad_infix\n\n module Let_syntax = struct\n let return = return\n let map = map\n let bind = bind\n let both = both\n\n (* from Applicative.Make *)\n module Open_on_rhs = struct end\n end\nend\n\nlet ok = Result.ok\nlet is_ok = Result.is_ok\nlet is_error = Result.is_error\n\nlet try_with ?(backtrace = false) f =\n try Ok (f ()) with\n | exn -> Error (Error.of_exn exn ?backtrace:(if backtrace then Some `Get else None))\n;;\n\nlet try_with_join ?backtrace f = join (try_with ?backtrace f)\n\nlet ok_exn = function\n | Ok x -> x\n | Error err -> Error.raise err\n;;\n\nlet of_exn ?backtrace exn = Error (Error.of_exn ?backtrace exn)\n\nlet of_exn_result ?backtrace = function\n | Ok _ as z -> z\n | Error exn -> of_exn ?backtrace exn\n;;\n\nlet error ?strict message a sexp_of_a = Error (Error.create ?strict message a sexp_of_a)\nlet error_s sexp = Error (Error.create_s sexp)\nlet error_string message = Error (Error.of_string message)\nlet errorf format = Printf.ksprintf error_string format\nlet tag t ~tag = Result.map_error t ~f:(Error.tag ~tag)\nlet tag_s t ~tag = Result.map_error t ~f:(Error.tag_s ~tag)\n\nlet tag_arg t message a sexp_of_a =\n Result.map_error t ~f:(fun e -> Error.tag_arg e message a sexp_of_a)\n;;\n\nlet unimplemented s = error \"unimplemented\" s sexp_of_string\nlet combine_errors l = Result.map_error (Result.combine_errors l) ~f:Error.of_list\nlet combine_errors_unit l = Result.map (combine_errors l) ~f:(fun (_ : unit list) -> ())\n\nlet filter_ok_at_least_one l =\n let ok, errs = List.partition_map l ~f:Result.to_either in\n match ok with\n | [] -> Error (Error.of_list errs)\n | _ -> Ok ok\n;;\n\nlet find_ok l =\n match List.find_map l ~f:Result.ok with\n | Some x -> Ok x\n | None ->\n Error\n (Error.of_list\n (List.map l ~f:(function\n | Ok _ -> assert false\n | Error err -> err)))\n;;\n\nlet find_map_ok l ~f =\n With_return.with_return (fun { return } ->\n Error\n (Error.of_list\n (List.map l ~f:(fun elt ->\n match f elt with\n | Ok _ as x -> return x\n | Error err -> err))))\n;;\n\nlet map = Result.map\nlet iter = Result.iter\nlet iter_error = Result.iter_error\n","open! Import\ninclude Comparable_intf\n\nmodule Validate (T : sig\n type t [@@deriving_inline compare, sexp_of]\n\n val compare : t -> t -> int\n val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t\n\n [@@@end]\n end) : Validate with type t := T.t = struct\n module V = Validate\n open Maybe_bound\n\n let to_string t = Sexp.to_string (T.sexp_of_t t)\n\n let validate_bound ~min ~max t =\n V.bounded ~name:to_string ~lower:min ~upper:max ~compare:T.compare t\n ;;\n\n let validate_lbound ~min t = validate_bound ~min ~max:Unbounded t\n let validate_ubound ~max t = validate_bound ~max ~min:Unbounded t\nend\n\nmodule With_zero (T : sig\n type t [@@deriving_inline compare]\n\n val compare : t -> t -> int\n\n [@@@end]\n\n val zero : t\n\n include Validate with type t := t\n end) =\nstruct\n open T\n\n (* Preallocate the interesting bounds to minimize allocation in the implementations of\n [validate_*]. *)\n let excl_zero = Maybe_bound.Excl zero\n let incl_zero = Maybe_bound.Incl zero\n let validate_positive t = validate_lbound ~min:excl_zero t\n let validate_non_negative t = validate_lbound ~min:incl_zero t\n let validate_negative t = validate_ubound ~max:excl_zero t\n let validate_non_positive t = validate_ubound ~max:incl_zero t\n let is_positive t = compare t zero > 0\n let is_non_negative t = compare t zero >= 0\n let is_negative t = compare t zero < 0\n let is_non_positive t = compare t zero <= 0\n let sign t = Sign0.of_int (compare t zero)\nend\n\nmodule Validate_with_zero (T : sig\n type t [@@deriving_inline compare, sexp_of]\n\n val compare : t -> t -> int\n val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t\n\n [@@@end]\n\n val zero : t\n end) =\nstruct\n module V = Validate (T)\n include V\n\n include With_zero (struct\n include T\n include V\n end)\nend\n\nmodule Poly (T : sig\n type t [@@deriving_inline sexp_of]\n\n val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t\n\n [@@@end]\n end) =\nstruct\n module Replace_polymorphic_compare = struct\n type t = T.t [@@deriving_inline sexp_of]\n\n let sexp_of_t = (T.sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t)\n\n [@@@end]\n\n include Poly\n end\n\n include Poly\n\n let between t ~low ~high = low <= t && t <= high\n let clamp_unchecked t ~min ~max = if t < min then min else if t <= max then t else max\n\n let clamp_exn t ~min ~max =\n assert (min <= max);\n clamp_unchecked t ~min ~max\n ;;\n\n let clamp t ~min ~max =\n if min > max\n then\n Or_error.error_s\n (Sexp.message\n \"clamp requires [min <= max]\"\n [ \"min\", T.sexp_of_t min; \"max\", T.sexp_of_t max ])\n else Ok (clamp_unchecked t ~min ~max)\n ;;\n\n module C = struct\n include T\n include Comparator.Make (Replace_polymorphic_compare)\n end\n\n include C\n\n include Validate (struct\n type nonrec t = t [@@deriving_inline compare, sexp_of]\n\n let compare = (compare : t -> t -> int)\n let sexp_of_t = (sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t)\n\n [@@@end]\n end)\nend\n\nlet gt cmp a b = cmp a b > 0\nlet lt cmp a b = cmp a b < 0\nlet geq cmp a b = cmp a b >= 0\nlet leq cmp a b = cmp a b <= 0\nlet equal cmp a b = cmp a b = 0\nlet not_equal cmp a b = cmp a b <> 0\nlet min cmp t t' = if leq cmp t t' then t else t'\nlet max cmp t t' = if geq cmp t t' then t else t'\n\nmodule Infix (T : sig\n type t [@@deriving_inline compare]\n\n val compare : t -> t -> int\n\n [@@@end]\n end) : Infix with type t := T.t = struct\n let ( > ) a b = gt T.compare a b\n let ( < ) a b = lt T.compare a b\n let ( >= ) a b = geq T.compare a b\n let ( <= ) a b = leq T.compare a b\n let ( = ) a b = equal T.compare a b\n let ( <> ) a b = not_equal T.compare a b\nend\n\nmodule Polymorphic_compare (T : sig\n type t [@@deriving_inline compare]\n\n val compare : t -> t -> int\n\n [@@@end]\n end) : Polymorphic_compare with type t := T.t = struct\n include Infix (T)\n\n let compare = T.compare\n let equal = ( = )\n let min t t' = min compare t t'\n let max t t' = max compare t t'\nend\n\nmodule Make_using_comparator (T : sig\n type t [@@deriving_inline sexp_of]\n\n val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t\n\n [@@@end]\n\n include Comparator.S with type t := t\n end) : S with type t := T.t and type comparator_witness = T.comparator_witness = struct\n module T = struct\n include T\n\n let compare = comparator.compare\n end\n\n include T\n module Replace_polymorphic_compare = Polymorphic_compare (T)\n include Replace_polymorphic_compare\n\n let ascending = compare\n let descending t t' = compare t' t\n let between t ~low ~high = low <= t && t <= high\n let clamp_unchecked t ~min ~max = if t < min then min else if t <= max then t else max\n\n let clamp_exn t ~min ~max =\n assert (min <= max);\n clamp_unchecked t ~min ~max\n ;;\n\n let clamp t ~min ~max =\n if min > max\n then\n Or_error.error_s\n (Sexp.message\n \"clamp requires [min <= max]\"\n [ \"min\", T.sexp_of_t min; \"max\", T.sexp_of_t max ])\n else Ok (clamp_unchecked t ~min ~max)\n ;;\n\n include Validate (T)\nend\n\nmodule Make (T : sig\n type t [@@deriving_inline compare, sexp_of]\n\n val compare : t -> t -> int\n val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t\n\n [@@@end]\n end) =\n Make_using_comparator (struct\n include T\n include Comparator.Make (T)\n end)\n\nmodule Inherit (C : sig\n type t [@@deriving_inline compare]\n\n val compare : t -> t -> int\n\n [@@@end]\n end) (T : sig\n type t [@@deriving_inline sexp_of]\n\n val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t\n\n [@@@end]\n\n val component : t -> C.t\n end) =\n Make (struct\n type t = T.t [@@deriving_inline sexp_of]\n\n let sexp_of_t = (T.sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t)\n\n [@@@end]\n\n let compare t t' = C.compare (T.component t) (T.component t')\n end)\n\n(* compare [x] and [y] lexicographically using functions in the list [cmps] *)\nlet lexicographic cmps x y =\n let rec loop = function\n | cmp :: cmps ->\n let res = cmp x y in\n if res = 0 then loop cmps else res\n | [] -> 0\n in\n loop cmps\n;;\n\nlet lift cmp ~f x y = cmp (f x) (f y)\nlet reverse cmp x y = cmp y x\n","open! Import\n\nmodule type S = sig\n type t [@@deriving_inline hash, sexp]\n\n val hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state\n val hash : t -> Ppx_hash_lib.Std.Hash.hash_value\n\n include Ppx_sexp_conv_lib.Sexpable.S with type t := t\n\n [@@@end]\n\n include Stringable.S with type t := t\n include Comparable.S with type t := t\n include Pretty_printer.S with type t := t\nend\n\nmodule Make (T : sig\n type t [@@deriving_inline compare, hash, sexp]\n\n val compare : t -> t -> int\n val hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state\n val hash : t -> Ppx_hash_lib.Std.Hash.hash_value\n\n include Ppx_sexp_conv_lib.Sexpable.S with type t := t\n\n [@@@end]\n\n include Stringable.S with type t := t\n\n val module_name : string\n end) =\nstruct\n include T\n include Comparable.Make (T)\n include Pretty_printer.Register (T)\nend\n\nmodule Make_using_comparator (T : sig\n type t [@@deriving_inline hash, sexp]\n\n val hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state\n val hash : t -> Ppx_hash_lib.Std.Hash.hash_value\n\n include Ppx_sexp_conv_lib.Sexpable.S with type t := t\n\n [@@@end]\n\n include Comparator.S with type t := t\n include Stringable.S with type t := t\n\n val module_name : string\n end) =\nstruct\n include T\n include Comparable.Make_using_comparator (T)\n include Pretty_printer.Register (T)\nend\n","open! Import\n\nmodule type Infix = Base.Comparable.Infix\nmodule type Polymorphic_compare = Base.Comparable.Polymorphic_compare\nmodule type Validate = Base.Comparable.Validate\nmodule type With_zero = Base.Comparable.With_zero\n\nmodule type S_common = sig\n include Base.Comparable.S\n module Replace_polymorphic_compare : Polymorphic_compare with type t := t\nend\n\n(** Usage example:\n\n {[\n module Foo : sig\n type t = ...\n include Comparable.S with type t := t\n end\n ]}\n\n Then use [Comparable.Make] in the struct (see comparable.mli for an example). *)\n\nmodule type S_plain = sig\n include S_common\n\n module Map :\n Map.S_plain with type Key.t = t with type Key.comparator_witness = comparator_witness\n\n module Set :\n Set.S_plain with type Elt.t = t with type Elt.comparator_witness = comparator_witness\nend\n\nmodule type S = sig\n include S_common\n\n module Map :\n Map.S with type Key.t = t with type Key.comparator_witness = comparator_witness\n\n module Set :\n Set.S with type Elt.t = t with type Elt.comparator_witness = comparator_witness\nend\n\nmodule type Map_and_set_binable = sig\n type t\n\n include Comparator.S with type t := t\n\n module Map :\n Map.S_binable\n with type Key.t = t\n with type Key.comparator_witness = comparator_witness\n\n module Set :\n Set.S_binable\n with type Elt.t = t\n with type Elt.comparator_witness = comparator_witness\nend\n\nmodule type S_binable = sig\n include S_common\n\n include\n Map_and_set_binable\n with type t := t\n with type comparator_witness := comparator_witness\nend\n\n","open! Import\n\nmodule T = struct\n type t = unit [@@deriving_inline enumerate, hash, sexp, sexp_grammar]\n\n let all = ([ () ] : t list)\n\n let (hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state) =\n hash_fold_unit\n\n and (hash : t -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func = hash_unit in\n fun x -> func x\n ;;\n\n let t_of_sexp = (unit_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t)\n let sexp_of_t = (sexp_of_unit : t -> Ppx_sexp_conv_lib.Sexp.t)\n\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group) =\n { implicit_vars = [ \"unit\" ]\n ; ggid = \"\\146e\\023\\249\\235eE\\139c\\132W\\195\\137\\129\\235\\025\"\n ; types = [ \"t\", Implicit_var 0 ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ unit_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"unit.ml.T\"\n }\n in\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"t\", _the_group)\n in\n t_sexp_grammar\n ;;\n\n [@@@end]\n\n let compare _ _ = 0\n\n let of_string = function\n | \"()\" -> ()\n | _ -> failwith \"Base.Unit.of_string: () expected\"\n ;;\n\n let to_string () = \"()\"\n let module_name = \"Base.Unit\"\nend\n\ninclude T\ninclude Identifiable.Make (T)\n\nlet invariant () = ()\n","open! Import\n\nlet invalid_argf = Printf.invalid_argf\n\nlet slow_check_pos_len_exn ~pos ~len ~total_length =\n if pos < 0 then invalid_argf \"Negative position: %d\" pos ();\n if len < 0 then invalid_argf \"Negative length: %d\" len ();\n (* We use [pos > total_length - len] rather than [pos + len > total_length] to avoid the\n possibility of overflow. *)\n if pos > total_length - len\n then invalid_argf \"pos + len past end: %d + %d > %d\" pos len total_length ()\n[@@cold] [@@inline never] [@@local never] [@@specialise never]\n;;\n\nlet check_pos_len_exn ~pos ~len ~total_length =\n (* This is better than [slow_check_pos_len_exn] for two reasons:\n\n - much less inlined code\n - only one conditional jump\n\n The reason it works is that checking [< 0] is testing the highest order bit, so\n [a < 0 || b < 0] is the same as [a lor b < 0].\n\n [pos + len] can overflow, so [pos > total_length - len] is not equivalent to\n [total_length - len - pos < 0], we need to test for [pos + len] overflow as\n well. *)\n let stop = pos + len in\n if pos lor len lor stop lor (total_length - stop) < 0\n then slow_check_pos_len_exn ~pos ~len ~total_length\n;;\n\nlet get_pos_len_exn ?(pos = 0) ?len () ~total_length =\n let len =\n match len with\n | Some i -> i\n | None -> total_length - pos\n in\n check_pos_len_exn ~pos ~len ~total_length;\n pos, len\n;;\n\nlet get_pos_len ?pos ?len () ~total_length =\n try Result.Ok (get_pos_len_exn () ?pos ?len ~total_length) with\n | Invalid_argument s -> Or_error.error_string s\n;;\n\nmodule Private = struct\n let slow_check_pos_len_exn = slow_check_pos_len_exn\nend\n","open! Import\n\n(* These functions implement a search for the first (resp. last) element\n satisfying a predicate, assuming that the predicate is increasing on\n the container, meaning that, if the container is [u1...un], there exists a\n k such that p(u1)=....=p(uk) = false and p(uk+1)=....=p(un)= true.\n If this k = 1 (resp n), find_last_not_satisfying (resp find_first_satisfying)\n will return None. *)\n\nlet rec linear_search_first_satisfying t ~get ~lo ~hi ~pred =\n if lo > hi\n then None\n else if pred (get t lo)\n then Some lo\n else linear_search_first_satisfying t ~get ~lo:(lo + 1) ~hi ~pred\n;;\n\n(* Takes a container [t], a predicate [pred] and two indices [lo < hi], such that\n [pred] is increasing on [t] between [lo] and [hi].\n\n return a range (lo, hi) where:\n - lo and hi are close enough together for a linear search\n - If [pred] is not constantly [false] on [t] between [lo] and [hi], the first element\n on which [pred] is [true] is between [lo] and [hi]. *)\n(* Invariant: the first element satisfying [pred], if it exists is between [lo] and [hi] *)\nlet rec find_range_near_first_satisfying t ~get ~lo ~hi ~pred =\n (* Warning: this function will not terminate if the constant (currently 8) is\n set <= 1 *)\n if hi - lo <= 8\n then lo, hi\n else (\n let mid = lo + ((hi - lo) / 2) in\n if pred (get t mid)\n (* INVARIANT check: it means the first satisfying element is between [lo] and [mid] *)\n then\n find_range_near_first_satisfying t ~get ~lo ~hi:mid ~pred\n (* INVARIANT check: it means the first satisfying element, if it exists,\n is between [mid+1] and [hi] *)\n else find_range_near_first_satisfying t ~get ~lo:(mid + 1) ~hi ~pred)\n;;\n\nlet find_first_satisfying ?pos ?len t ~get ~length ~pred =\n let pos, len =\n Ordered_collection_common.get_pos_len_exn () ?pos ?len ~total_length:(length t)\n in\n let lo = pos in\n let hi = pos + len - 1 in\n let lo, hi = find_range_near_first_satisfying t ~get ~lo ~hi ~pred in\n linear_search_first_satisfying t ~get ~lo ~hi ~pred\n;;\n\n(* Takes an array with shape [true,...true,false,...false] (i.e., the _reverse_ of what\n is described above) and returns the index of the last true or None if there are no\n true*)\nlet find_last_satisfying ?pos ?len t ~pred ~get ~length =\n let pos, len =\n Ordered_collection_common.get_pos_len_exn () ?pos ?len ~total_length:(length t)\n in\n if len = 0\n then None\n else (\n (* The last satisfying is the one just before the first not satisfying *)\n match find_first_satisfying ~pos ~len t ~get ~length ~pred:(Fn.non pred) with\n | None -> Some (pos + len - 1)\n (* This means that all elements satisfy pred.\n There is at least an element as (len > 0) *)\n | Some i when i = pos -> None (* no element satisfies pred *)\n | Some i -> Some (i - 1))\n;;\n\nlet binary_search ?pos ?len t ~length ~get ~compare how v =\n match how with\n | `Last_strictly_less_than ->\n find_last_satisfying ?pos ?len t ~get ~length ~pred:(fun x -> compare x v < 0)\n | `Last_less_than_or_equal_to ->\n find_last_satisfying ?pos ?len t ~get ~length ~pred:(fun x -> compare x v <= 0)\n | `First_equal_to ->\n (match\n find_first_satisfying ?pos ?len t ~get ~length ~pred:(fun x -> compare x v >= 0)\n with\n | Some x when compare (get t x) v = 0 -> Some x\n | None | Some _ -> None)\n | `Last_equal_to ->\n (match\n find_last_satisfying ?pos ?len t ~get ~length ~pred:(fun x -> compare x v <= 0)\n with\n | Some x when compare (get t x) v = 0 -> Some x\n | None | Some _ -> None)\n | `First_greater_than_or_equal_to ->\n find_first_satisfying ?pos ?len t ~get ~length ~pred:(fun x -> compare x v >= 0)\n | `First_strictly_greater_than ->\n find_first_satisfying ?pos ?len t ~get ~length ~pred:(fun x -> compare x v > 0)\n;;\n\nlet binary_search_segmented ?pos ?len t ~length ~get ~segment_of how =\n let is_left x =\n match segment_of x with\n | `Left -> true\n | `Right -> false\n in\n let is_right x = not (is_left x) in\n match how with\n | `Last_on_left -> find_last_satisfying ?pos ?len t ~length ~get ~pred:is_left\n | `First_on_right -> find_first_satisfying ?pos ?len t ~length ~get ~pred:is_right\n;;\n","open! Import\ninclude Binary_searchable_intf\n\nmodule type Arg = sig\n type 'a elt\n type 'a t\n\n val get : 'a t -> int -> 'a elt\n val length : _ t -> int\nend\n\nmodule Make_gen (T : Arg) = struct\n let get = T.get\n let length = T.length\n\n let binary_search ?pos ?len t ~compare how v =\n Binary_search.binary_search ?pos ?len t ~get ~length ~compare how v\n ;;\n\n let binary_search_segmented ?pos ?len t ~segment_of how =\n Binary_search.binary_search_segmented ?pos ?len t ~get ~length ~segment_of how\n ;;\nend\n\nmodule Make (T : Indexable) = Make_gen (struct\n type 'a elt = T.elt\n type 'a t = T.t\n\n include (T : Indexable with type elt := T.elt with type t := T.t)\n end)\n\nmodule Make1 (T : Indexable1) = Make_gen (struct\n type 'a elt = 'a\n type 'a t = 'a T.t\n\n let get = T.get\n let length = T.length\n end)\n","(* [Bytes0] defines string functions that are primitives or can be simply\n defined in terms of [Caml.Bytes]. [Bytes0] is intended to completely express\n the part of [Caml.Bytes] that [Base] uses -- no other file in Base other\n than bytes0.ml should use [Caml.Bytes]. [Bytes0] has few dependencies, and\n so is available early in Base's build order.\n\n All Base files that need to use strings and come before [Base.Bytes] in\n build order should do:\n\n {[\n module Bytes = Bytes0\n ]}\n\n Defining [module Bytes = Bytes0] is also necessary because it prevents\n ocamldep from mistakenly causing a file to depend on [Base.Bytes]. *)\n\nopen! Import0\nmodule Sys = Sys0\n\nmodule Primitives = struct\n external get : bytes -> int -> char = \"%bytes_safe_get\"\n external length : bytes -> int = \"%bytes_length\"\n external unsafe_get : bytes -> int -> char = \"%bytes_unsafe_get\"\n\n include Bytes_set_primitives\n\n (* [unsafe_blit_string] is not exported in the [stdlib] so we export it here *)\n external unsafe_blit_string\n : src:string\n -> src_pos:int\n -> dst:bytes\n -> dst_pos:int\n -> len:int\n -> unit\n = \"caml_blit_string\"\n [@@noalloc]\nend\n\ninclude Primitives\n\nlet max_length = Sys.max_string_length\nlet blit = Caml.Bytes.blit\nlet blit_string = Caml.Bytes.blit_string\nlet compare = Caml.Bytes.compare\nlet copy = Caml.Bytes.copy\nlet create = Caml.Bytes.create\nlet fill = Caml.Bytes.fill\nlet make = Caml.Bytes.make\nlet map = Caml.Bytes.map\nlet mapi = Caml.Bytes.mapi\nlet sub = Caml.Bytes.sub\nlet unsafe_blit = Caml.Bytes.unsafe_blit\nlet to_string = Caml.Bytes.to_string\nlet of_string = Caml.Bytes.of_string\n\nlet unsafe_to_string ~no_mutation_while_string_reachable:s =\n Caml.Bytes.unsafe_to_string s\n;;\n\nlet unsafe_of_string_promise_no_mutation = Caml.Bytes.unsafe_of_string\n","open! Import\ninclude Blit_intf\n\nmodule type Sequence_gen = sig\n type 'a t\n\n val length : _ t -> int\nend\n\nmodule Make_gen\n (Src : Sequence_gen) (Dst : sig\n include Sequence_gen\n\n val create_like : len:int -> 'a Src.t -> 'a t\n val unsafe_blit : ('a Src.t, 'a t) blit\n end) =\nstruct\n let unsafe_blit = Dst.unsafe_blit\n\n let blit ~src ~src_pos ~dst ~dst_pos ~len =\n Ordered_collection_common.check_pos_len_exn\n ~pos:src_pos\n ~len\n ~total_length:(Src.length src);\n Ordered_collection_common.check_pos_len_exn\n ~pos:dst_pos\n ~len\n ~total_length:(Dst.length dst);\n if len > 0 then unsafe_blit ~src ~src_pos ~dst ~dst_pos ~len\n ;;\n\n let blito\n ~src\n ?(src_pos = 0)\n ?(src_len = Src.length src - src_pos)\n ~dst\n ?(dst_pos = 0)\n ()\n =\n blit ~src ~src_pos ~len:src_len ~dst ~dst_pos\n ;;\n\n (* [sub] and [subo] ensure that every position of the created sequence is populated by\n an element of the source array. Thus every element of [dst] below is well\n defined. *)\n let sub src ~pos ~len =\n Ordered_collection_common.check_pos_len_exn ~pos ~len ~total_length:(Src.length src);\n let dst = Dst.create_like ~len src in\n if len > 0 then unsafe_blit ~src ~src_pos:pos ~dst ~dst_pos:0 ~len;\n dst\n ;;\n\n let subo ?(pos = 0) ?len src =\n sub\n src\n ~pos\n ~len:\n (match len with\n | Some i -> i\n | None -> Src.length src - pos)\n ;;\nend\n\nmodule Make1 (Sequence : sig\n include Sequence_gen\n\n val create_like : len:int -> 'a t -> 'a t\n val unsafe_blit : ('a t, 'a t) blit\n end) =\n Make_gen (Sequence) (Sequence)\n\nmodule Make1_generic (Sequence : Sequence1) = Make_gen (Sequence) (Sequence)\n\nmodule Make (Sequence : sig\n include Sequence\n\n val create : len:int -> t\n val unsafe_blit : (t, t) blit\n end) =\nstruct\n module Sequence = struct\n type 'a t = Sequence.t\n\n open Sequence\n\n let create_like ~len _ = create ~len\n let length = length\n let unsafe_blit = unsafe_blit\n end\n\n include Make_gen (Sequence) (Sequence)\nend\n\nmodule Make_distinct\n (Src : Sequence) (Dst : sig\n include Sequence\n\n val create : len:int -> t\n val unsafe_blit : (Src.t, t) blit\n end) =\n Make_gen\n (struct\n type 'a t = Src.t\n\n open Src\n\n let length = length\n end)\n (struct\n type 'a t = Dst.t\n\n open Dst\n\n let length = length\n let create_like ~len _ = create ~len\n let unsafe_blit = unsafe_blit\n end)\n\nmodule Make_to_string (T : sig\n type t\n end)\n (To_bytes : S_distinct with type src := T.t with type dst := bytes) =\nstruct\n open To_bytes\n\n let sub src ~pos ~len =\n Bytes0.unsafe_to_string ~no_mutation_while_string_reachable:(sub src ~pos ~len)\n ;;\n\n let subo ?pos ?len src =\n Bytes0.unsafe_to_string ~no_mutation_while_string_reachable:(subo ?pos ?len src)\n ;;\nend\n","open! Import\n\ntype 'a t = 'a option =\n | None\n | Some of 'a\n\ninclude (\nstruct\n type 'a t = 'a option [@@deriving_inline compare, hash, sexp, sexp_grammar]\n\n let compare : 'a. ('a -> 'a -> int) -> 'a t -> 'a t -> int = compare_option\n\n let hash_fold_t :\n 'a. (Ppx_hash_lib.Std.Hash.state -> 'a -> Ppx_hash_lib.Std.Hash.state)\n -> Ppx_hash_lib.Std.Hash.state -> 'a t -> Ppx_hash_lib.Std.Hash.state\n =\n hash_fold_option\n ;;\n\n let t_of_sexp :\n 'a. (Ppx_sexp_conv_lib.Sexp.t -> 'a) -> Ppx_sexp_conv_lib.Sexp.t -> 'a t\n =\n option_of_sexp\n ;;\n\n let sexp_of_t :\n 'a. ('a -> Ppx_sexp_conv_lib.Sexp.t) -> 'a t -> Ppx_sexp_conv_lib.Sexp.t\n =\n sexp_of_option\n ;;\n\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group)\n =\n { implicit_vars = [ \"option\" ]\n ; ggid = \"j\\132);\\135qH\\158\\135\\222H\\001\\007\\004\\158\\218\"\n ; types =\n [ \"t\", Explicit_bind ([ \"a\" ], Apply (Implicit_var 0, [ Explicit_var 0 ])) ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ option_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"option.ml\"\n }\n in\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"t\", _the_group)\n in\n t_sexp_grammar\n ;;\n\n [@@@end]\nend :\nsig\n type 'a t = 'a option [@@deriving_inline compare, hash, sexp, sexp_grammar]\n\n val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int\n\n val hash_fold_t\n : (Ppx_hash_lib.Std.Hash.state -> 'a -> Ppx_hash_lib.Std.Hash.state)\n -> Ppx_hash_lib.Std.Hash.state\n -> 'a t\n -> Ppx_hash_lib.Std.Hash.state\n\n include Ppx_sexp_conv_lib.Sexpable.S1 with type 'a t := 'a t\n\n val t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t\n\n [@@@end]\nend\nwith type 'a t := 'a t)\n\nlet is_none = function\n | None -> true\n | _ -> false\n;;\n\nlet is_some = function\n | Some _ -> true\n | _ -> false\n;;\n\nlet value_map o ~default ~f =\n match o with\n | Some x -> f x\n | None -> default\n;;\n\nlet iter o ~f =\n match o with\n | None -> ()\n | Some a -> f a\n;;\n\nlet invariant f t = iter t ~f\n\nlet map2 o1 o2 ~f =\n match o1, o2 with\n | Some a1, Some a2 -> Some (f a1 a2)\n | _ -> None\n;;\n\nlet call x ~f =\n match f with\n | None -> ()\n | Some f -> f x\n;;\n\nlet value t ~default =\n match t with\n | None -> default\n | Some x -> x\n;;\n\nlet value_exn ?here ?error ?message t =\n match t with\n | Some x -> x\n | None ->\n let error =\n match here, error, message with\n | None, None, None -> Error.of_string \"Option.value_exn None\"\n | None, None, Some m -> Error.of_string m\n | None, Some e, None -> e\n | None, Some e, Some m -> Error.tag e ~tag:m\n | Some p, None, None ->\n Error.create \"Option.value_exn\" p Source_code_position0.sexp_of_t\n | Some p, None, Some m -> Error.create m p Source_code_position0.sexp_of_t\n | Some p, Some e, _ ->\n Error.create\n (value message ~default:\"\")\n (e, p)\n (sexp_of_pair Error.sexp_of_t Source_code_position0.sexp_of_t)\n in\n Error.raise error\n;;\n\nlet to_array t =\n match t with\n | None -> [||]\n | Some x -> [| x |]\n;;\n\nlet to_list t =\n match t with\n | None -> []\n | Some x -> [ x ]\n;;\n\nlet min_elt t ~compare:_ = t\nlet max_elt t ~compare:_ = t\n\nlet sum (type a) (module M : Container.Summable with type t = a) t ~f =\n match t with\n | None -> M.zero\n | Some x -> f x\n;;\n\nlet for_all t ~f =\n match t with\n | None -> true\n | Some x -> f x\n;;\n\nlet exists t ~f =\n match t with\n | None -> false\n | Some x -> f x\n;;\n\nlet mem t a ~equal =\n match t with\n | None -> false\n | Some a' -> equal a a'\n;;\n\nlet length t =\n match t with\n | None -> 0\n | Some _ -> 1\n;;\n\nlet is_empty = is_none\n\nlet fold t ~init ~f =\n match t with\n | None -> init\n | Some x -> f init x\n;;\n\nlet count t ~f =\n match t with\n | None -> 0\n | Some a -> if f a then 1 else 0\n;;\n\nlet find t ~f =\n match t with\n | None -> None\n | Some x -> if f x then Some x else None\n;;\n\nlet find_map t ~f =\n match t with\n | None -> None\n | Some a -> f a\n;;\n\nlet equal f t t' =\n match t, t' with\n | None, None -> true\n | Some x, Some x' -> f x x'\n | _ -> false\n;;\n\nlet some x = Some x\n\nlet both x y =\n match x, y with\n | Some a, Some b -> Some (a, b)\n | _ -> None\n;;\n\nlet first_some x y =\n match x with\n | Some _ -> x\n | None -> y\n;;\n\nlet some_if cond x = if cond then Some x else None\n\nlet merge a b ~f =\n match a, b with\n | None, x | x, None -> x\n | Some a, Some b -> Some (f a b)\n;;\n\nlet filter t ~f =\n match t with\n | Some v as o when f v -> o\n | _ -> None\n;;\n\nlet try_with f =\n match f () with\n | x -> Some x\n | exception _ -> None\n;;\n\nlet try_with_join f =\n match f () with\n | x -> x\n | exception _ -> None\n;;\n\ninclude Monad.Make (struct\n type 'a t = 'a option\n\n let return x = Some x\n\n let map t ~f =\n match t with\n | None -> None\n | Some a -> Some (f a)\n ;;\n\n let map = `Custom map\n\n let bind o ~f =\n match o with\n | None -> None\n | Some x -> f x\n ;;\n end)\n\nlet fold_result t ~init ~f = Container.fold_result ~fold ~init ~f t\nlet fold_until t ~init ~f = Container.fold_until ~fold ~init ~f t\n\nlet validate ~none ~some t =\n let module V = Validate in\n match t with\n | None -> V.name \"none\" (V.protect none ())\n | Some x -> V.name \"some\" (V.protect some x)\n;;\n","open! Import\ninclude Either_intf\nmodule Array = Array0\nmodule List = List0\ninclude Either0\n\nlet swap = function\n | First x -> Second x\n | Second x -> First x\n;;\n\nlet is_first = function\n | First _ -> true\n | Second _ -> false\n;;\n\nlet is_second = function\n | First _ -> false\n | Second _ -> true\n;;\n\nlet value (First x | Second x) = x\n\nlet value_map t ~first ~second =\n match t with\n | First x -> first x\n | Second x -> second x\n;;\n\nlet iter = value_map\n\nlet map t ~first ~second =\n match t with\n | First x -> First (first x)\n | Second x -> Second (second x)\n;;\n\nlet first x = First x\nlet second x = Second x\n\nlet equal eq1 eq2 t1 t2 =\n match t1, t2 with\n | First x, First y -> eq1 x y\n | Second x, Second y -> eq2 x y\n | First _, Second _ | Second _, First _ -> false\n;;\n\nlet invariant f s = function\n | First x -> f x\n | Second y -> s y\n;;\n\nmodule Make_focused (M : sig\n type (+'a, +'b) t\n\n val return : 'a -> ('a, _) t\n val other : 'b -> (_, 'b) t\n val either : ('a, 'b) t -> return:('a -> 'c) -> other:('b -> 'c) -> 'c\n\n val combine\n : ('a, 'd) t\n -> ('b, 'd) t\n -> f:('a -> 'b -> 'c)\n -> other:('d -> 'd -> 'd)\n -> ('c, 'd) t\n\n val bind : ('a, 'b) t -> f:('a -> ('c, 'b) t) -> ('c, 'b) t\n end) =\nstruct\n include M\n open With_return\n\n let map t ~f = bind t ~f:(fun x -> return (f x))\n\n include Monad.Make2 (struct\n type nonrec ('a, 'b) t = ('a, 'b) t\n\n let return = return\n let bind = bind\n let map = `Custom map\n end)\n\n module App = Applicative.Make2 (struct\n type nonrec ('a, 'b) t = ('a, 'b) t\n\n let return = return\n let apply t1 t2 = bind t1 ~f:(fun f -> bind t2 ~f:(fun x -> return (f x)))\n let map = `Custom map\n end)\n\n include App\n\n let combine_all =\n let rec other_loop f acc = function\n | [] -> other acc\n | t :: ts ->\n either\n t\n ~return:(fun _ -> other_loop f acc ts)\n ~other:(fun o -> other_loop f (f acc o) ts)\n in\n let rec return_loop f acc = function\n | [] -> return (List.rev acc)\n | t :: ts ->\n either\n t\n ~return:(fun x -> return_loop f (x :: acc) ts)\n ~other:(fun o -> other_loop f o ts)\n in\n fun ts ~f -> return_loop f [] ts\n ;;\n\n let combine_all_unit =\n let rec other_loop f acc = function\n | [] -> other acc\n | t :: ts ->\n either\n t\n ~return:(fun () -> other_loop f acc ts)\n ~other:(fun o -> other_loop f (f acc o) ts)\n in\n let rec return_loop f = function\n | [] -> return ()\n | t :: ts ->\n either t ~return:(fun () -> return_loop f ts) ~other:(fun o -> other_loop f o ts)\n in\n fun ts ~f -> return_loop f ts\n ;;\n\n let to_option t = either t ~return:Option.some ~other:(fun _ -> None)\n let value t ~default = either t ~return:Fn.id ~other:(fun _ -> default)\n\n let with_return f =\n with_return (fun ret -> other (f (With_return.prepend ret ~f:return)))\n ;;\nend\n\nmodule First = Make_focused (struct\n type nonrec ('a, 'b) t = ('a, 'b) t\n\n let return = first\n let other = second\n\n let either t ~return ~other =\n match t with\n | First x -> return x\n | Second y -> other y\n ;;\n\n let combine t1 t2 ~f ~other =\n match t1, t2 with\n | First x, First y -> First (f x y)\n | Second x, Second y -> Second (other x y)\n | Second x, _ | _, Second x -> Second x\n ;;\n\n let bind t ~f =\n match t with\n | First x -> f x\n (* Reuse the value in order to avoid allocation. *)\n | Second _ as y -> y\n ;;\n end)\n\nmodule Second = Make_focused (struct\n type nonrec ('a, 'b) t = ('b, 'a) t\n\n let return = second\n let other = first\n\n let either t ~return ~other =\n match t with\n | Second y -> return y\n | First x -> other x\n ;;\n\n let combine t1 t2 ~f ~other =\n match t1, t2 with\n | Second x, Second y -> Second (f x y)\n | First x, First y -> First (other x y)\n | First x, _ | _, First x -> First x\n ;;\n\n let bind t ~f =\n match t with\n | Second x -> f x\n (* Reuse the value in order to avoid allocation, like [First.bind] above. *)\n | First _ as y -> y\n ;;\n end)\n\nmodule Export = struct\n type ('f, 's) _either = ('f, 's) t =\n | First of 'f\n | Second of 's\nend\n","include Indexed_container_intf\n\nlet with_return = With_return.with_return\n\nlet iteri ~fold t ~f =\n ignore\n (fold t ~init:0 ~f:(fun i x ->\n f i x;\n i + 1)\n : int)\n;;\n\nlet foldi ~fold t ~init ~f =\n let i = ref 0 in\n fold t ~init ~f:(fun acc v ->\n let acc = f !i acc v in\n i := !i + 1;\n acc)\n;;\n\nlet counti ~foldi t ~f = foldi t ~init:0 ~f:(fun i n a -> if f i a then n + 1 else n)\n\nlet existsi ~iteri c ~f =\n with_return (fun r ->\n iteri c ~f:(fun i x -> if f i x then r.return true);\n false)\n;;\n\nlet for_alli ~iteri c ~f =\n with_return (fun r ->\n iteri c ~f:(fun i x -> if not (f i x) then r.return false);\n true)\n;;\n\nlet find_mapi ~iteri t ~f =\n with_return (fun r ->\n iteri t ~f:(fun i x ->\n match f i x with\n | None -> ()\n | Some _ as res -> r.return res);\n None)\n;;\n\nlet findi ~iteri c ~f =\n with_return (fun r ->\n iteri c ~f:(fun i x -> if f i x then r.return (Some (i, x)));\n None)\n;;\n\nmodule Make (T : Make_arg) : S1 with type 'a t := 'a T.t = struct\n include Container.Make (T)\n\n let iteri =\n match T.iteri with\n | `Custom iteri -> iteri\n | `Define_using_fold -> fun t ~f -> iteri ~fold t ~f\n ;;\n\n let foldi =\n match T.foldi with\n | `Custom foldi -> foldi\n | `Define_using_fold -> fun t ~init ~f -> foldi ~fold t ~init ~f\n ;;\n\n let counti t ~f = counti ~foldi t ~f\n let existsi t ~f = existsi ~iteri t ~f\n let for_alli t ~f = for_alli ~iteri t ~f\n let find_mapi t ~f = find_mapi ~iteri t ~f\n let findi t ~f = findi ~iteri t ~f\nend\n","open! Import\nopen Container_intf.Export\nmodule Array = Array0\nmodule List = List1\n\nmodule Step = struct\n (* 'a is an item in the sequence, 's is the state that will produce the remainder of\n the sequence *)\n type ('a, 's) t =\n | Done\n | Skip of 's\n | Yield of 'a * 's\n [@@deriving_inline sexp_of]\n\n let sexp_of_t\n : type a s.\n (a -> Ppx_sexp_conv_lib.Sexp.t)\n -> (s -> Ppx_sexp_conv_lib.Sexp.t)\n -> (a, s) t\n -> Ppx_sexp_conv_lib.Sexp.t\n =\n fun _of_a _of_s -> function\n | Done -> Ppx_sexp_conv_lib.Sexp.Atom \"Done\"\n | Skip v0 ->\n let v0 = _of_s v0 in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"Skip\"; v0 ]\n | Yield (v0, v1) ->\n let v0 = _of_a v0\n and v1 = _of_s v1 in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"Yield\"; v0; v1 ]\n ;;\n\n [@@@end]\nend\n\nopen Step\n\n(* 'a is an item in the sequence, 's is the state that will produce the remainder of the\n sequence *)\ntype +_ t = Sequence : 's * ('s -> ('a, 's) Step.t) -> 'a t\ntype 'a sequence = 'a t\n\nmodule Expert = struct\n let next_step (Sequence (s, f)) =\n match f s with\n | Done -> Done\n | Skip s -> Skip (Sequence (s, f))\n | Yield (a, s) -> Yield (a, Sequence (s, f))\n ;;\n\n let delayed_fold_step s ~init ~f ~finish =\n let rec loop s next finish f acc =\n match next s with\n | Done -> finish acc\n | Skip s -> f acc None ~k:(loop s next finish f)\n | Yield (a, s) -> f acc (Some a) ~k:(loop s next finish f)\n in\n match s with\n | Sequence (s, next) -> loop s next finish f init\n ;;\nend\n\nlet unfold_step ~init ~f = Sequence (init, f)\n\nlet unfold ~init ~f =\n unfold_step ~init ~f:(fun s ->\n match f s with\n | None -> Step.Done\n | Some (a, s) -> Step.Yield (a, s))\n;;\n\nlet unfold_with s ~init ~f =\n match s with\n | Sequence (s, next) ->\n Sequence\n ( (init, s)\n , fun (seed, s) ->\n match next s with\n | Done -> Done\n | Skip s -> Skip (seed, s)\n | Yield (a, s) ->\n (match f seed a with\n | Done -> Done\n | Skip seed -> Skip (seed, s)\n | Yield (a, seed) -> Yield (a, (seed, s))) )\n;;\n\nlet unfold_with_and_finish s ~init ~running_step ~inner_finished ~finishing_step =\n match s with\n | Sequence (s, next) ->\n Sequence\n ( `Inner_running (init, s)\n , fun state ->\n match state with\n | `Inner_running (state, inner_state) ->\n (match next inner_state with\n | Done -> Skip (`Inner_finished (inner_finished state))\n | Skip inner_state -> Skip (`Inner_running (state, inner_state))\n | Yield (x, inner_state) ->\n (match running_step state x with\n | Done -> Done\n | Skip state -> Skip (`Inner_running (state, inner_state))\n | Yield (y, state) -> Yield (y, `Inner_running (state, inner_state))))\n | `Inner_finished state ->\n (match finishing_step state with\n | Done -> Done\n | Skip state -> Skip (`Inner_finished state)\n | Yield (y, state) -> Yield (y, `Inner_finished state)) )\n;;\n\nlet of_list l =\n unfold_step ~init:l ~f:(function\n | [] -> Done\n | x :: l -> Yield (x, l))\n;;\n\n\nlet fold t ~init ~f =\n let rec loop seed v next f =\n match next seed with\n | Done -> v\n | Skip s -> loop s v next f\n | Yield (a, s) -> loop s (f v a) next f\n in\n match t with\n | Sequence (seed, next) -> loop seed init next f\n;;\n\nlet to_list_rev t = fold t ~init:[] ~f:(fun l x -> x :: l)\n\n\nlet to_list (Sequence (s, next)) =\n let safe_to_list t = List.rev (to_list_rev t) in\n let rec to_list s next i =\n if i = 0\n then safe_to_list (Sequence (s, next))\n else (\n match next s with\n | Done -> []\n | Skip s -> to_list s next i\n | Yield (a, s) -> a :: to_list s next (i - 1))\n in\n to_list s next 500\n;;\n\nlet sexp_of_t sexp_of_a t = sexp_of_list sexp_of_a (to_list t)\n\nlet range ?(stride = 1) ?(start = `inclusive) ?(stop = `exclusive) start_v stop_v =\n let step =\n match stop with\n | `inclusive when stride >= 0 ->\n fun i -> if i > stop_v then Done else Yield (i, i + stride)\n | `inclusive -> fun i -> if i < stop_v then Done else Yield (i, i + stride)\n | `exclusive when stride >= 0 ->\n fun i -> if i >= stop_v then Done else Yield (i, i + stride)\n | `exclusive -> fun i -> if i <= stop_v then Done else Yield (i, i + stride)\n in\n let init =\n match start with\n | `inclusive -> start_v\n | `exclusive -> start_v + stride\n in\n unfold_step ~init ~f:step\n;;\n\nlet of_lazy t_lazy =\n unfold_step ~init:t_lazy ~f:(fun t_lazy ->\n let (Sequence (s, next)) = Lazy.force t_lazy in\n match next s with\n | Done -> Done\n | Skip s ->\n Skip\n (let v = Sequence (s, next) in\n lazy v)\n | Yield (x, s) ->\n Yield\n ( x\n , let v = Sequence (s, next) in\n lazy v ))\n;;\n\nlet map t ~f =\n match t with\n | Sequence (seed, next) ->\n Sequence\n ( seed\n , fun seed ->\n match next seed with\n | Done -> Done\n | Skip s -> Skip s\n | Yield (a, s) -> Yield (f a, s) )\n;;\n\nlet mapi t ~f =\n match t with\n | Sequence (s, next) ->\n Sequence\n ( (0, s)\n , fun (i, s) ->\n match next s with\n | Done -> Done\n | Skip s -> Skip (i, s)\n | Yield (a, s) -> Yield (f i a, (i + 1, s)) )\n;;\n\nlet folding_map t ~init ~f =\n unfold_with t ~init ~f:(fun acc x ->\n let acc, x = f acc x in\n Yield (x, acc))\n;;\n\nlet folding_mapi t ~init ~f =\n unfold_with t ~init:(0, init) ~f:(fun (i, acc) x ->\n let acc, x = f i acc x in\n Yield (x, (i + 1, acc)))\n;;\n\nlet filter t ~f =\n match t with\n | Sequence (seed, next) ->\n Sequence\n ( seed\n , fun seed ->\n match next seed with\n | Done -> Done\n | Skip s -> Skip s\n | Yield (a, s) when f a -> Yield (a, s)\n | Yield (_, s) -> Skip s )\n;;\n\nlet filteri t ~f =\n map ~f:snd (filter (mapi t ~f:(fun i s -> i, s)) ~f:(fun (i, s) -> f i s))\n;;\n\nlet length t =\n let rec loop i s next =\n match next s with\n | Done -> i\n | Skip s -> loop i s next\n | Yield (_, s) -> loop (i + 1) s next\n in\n match t with\n | Sequence (seed, next) -> loop 0 seed next\n;;\n\nlet to_list_rev_with_length t = fold t ~init:([], 0) ~f:(fun (l, i) x -> x :: l, i + 1)\n\nlet to_array t =\n let l, len = to_list_rev_with_length t in\n match l with\n | [] -> [||]\n | x :: l ->\n let a = Array.create ~len x in\n let rec loop i l =\n match l with\n | [] -> assert (i = -1)\n | x :: l ->\n a.(i) <- x;\n loop (i - 1) l\n in\n loop (len - 2) l;\n a\n;;\n\nlet find t ~f =\n let rec loop s next f =\n match next s with\n | Done -> None\n | Yield (a, _) when f a -> Some a\n | Yield (_, s) | Skip s -> loop s next f\n in\n match t with\n | Sequence (seed, next) -> loop seed next f\n;;\n\nlet find_map t ~f =\n let rec loop s next f =\n match next s with\n | Done -> None\n | Yield (a, s) ->\n (match f a with\n | None -> loop s next f\n | some_b -> some_b)\n | Skip s -> loop s next f\n in\n match t with\n | Sequence (seed, next) -> loop seed next f\n;;\n\n\nlet find_mapi t ~f =\n let rec loop s next f i =\n match next s with\n | Done -> None\n | Yield (a, s) ->\n (match f i a with\n | None -> loop s next f (i + 1)\n | some_b -> some_b)\n | Skip s -> loop s next f i\n in\n match t with\n | Sequence (seed, next) -> loop seed next f 0\n;;\n\nlet for_all t ~f =\n let rec loop s next f =\n match next s with\n | Done -> true\n | Yield (a, _) when not (f a) -> false\n | Yield (_, s) | Skip s -> loop s next f\n in\n match t with\n | Sequence (seed, next) -> loop seed next f\n;;\n\nlet for_alli t ~f =\n let rec loop s next f i =\n match next s with\n | Done -> true\n | Yield (a, _) when not (f i a) -> false\n | Yield (_, s) -> loop s next f (i + 1)\n | Skip s -> loop s next f i\n in\n match t with\n | Sequence (seed, next) -> loop seed next f 0\n;;\n\nlet exists t ~f =\n let rec loop s next f =\n match next s with\n | Done -> false\n | Yield (a, _) when f a -> true\n | Yield (_, s) | Skip s -> loop s next f\n in\n match t with\n | Sequence (seed, next) -> loop seed next f\n;;\n\nlet existsi t ~f =\n let rec loop s next f i =\n match next s with\n | Done -> false\n | Yield (a, _) when f i a -> true\n | Yield (_, s) -> loop s next f (i + 1)\n | Skip s -> loop s next f i\n in\n match t with\n | Sequence (seed, next) -> loop seed next f 0\n;;\n\nlet iter t ~f =\n let rec loop seed next f =\n match next seed with\n | Done -> ()\n | Skip s -> loop s next f\n | Yield (a, s) ->\n f a;\n loop s next f\n in\n match t with\n | Sequence (seed, next) -> loop seed next f\n;;\n\nlet is_empty t =\n let rec loop s next =\n match next s with\n | Done -> true\n | Skip s -> loop s next\n | Yield _ -> false\n in\n match t with\n | Sequence (seed, next) -> loop seed next\n;;\n\nlet mem t a ~equal =\n let rec loop s next a =\n match next s with\n | Done -> false\n | Yield (b, _) when equal a b -> true\n | Yield (_, s) | Skip s -> loop s next a\n in\n match t with\n | Sequence (seed, next) -> loop seed next a\n;;\n\nlet empty = Sequence ((), fun () -> Done)\n\nlet bind t ~f =\n unfold_step\n ~f:(function\n | Sequence (seed, next), rest ->\n (match next seed with\n | Done ->\n (match rest with\n | Sequence (seed, next) ->\n (match next seed with\n | Done -> Done\n | Skip s -> Skip (empty, Sequence (s, next))\n | Yield (a, s) -> Skip (f a, Sequence (s, next))))\n | Skip s -> Skip (Sequence (s, next), rest)\n | Yield (a, s) -> Yield (a, (Sequence (s, next), rest))))\n ~init:(empty, t)\n;;\n\nlet return x =\n unfold_step ~init:(Some x) ~f:(function\n | None -> Done\n | Some x -> Yield (x, None))\n;;\n\ninclude Monad.Make (struct\n type nonrec 'a t = 'a t\n\n let map = `Custom map\n let bind = bind\n let return = return\n end)\n\nlet nth s n =\n if n < 0\n then None\n else (\n let rec loop i s next =\n match next s with\n | Done -> None\n | Skip s -> loop i s next\n | Yield (a, s) -> if phys_equal i 0 then Some a else loop (i - 1) s next\n in\n match s with\n | Sequence (s, next) -> loop n s next)\n;;\n\nlet nth_exn s n =\n if n < 0\n then invalid_arg \"Sequence.nth\"\n else (\n match nth s n with\n | None -> failwith \"Sequence.nth\"\n | Some x -> x)\n;;\n\nmodule Merge_with_duplicates_element = struct\n type ('a, 'b) t =\n | Left of 'a\n | Right of 'b\n | Both of 'a * 'b\n [@@deriving_inline compare, hash, sexp]\n\n let compare :\n 'a 'b. ('a -> 'a -> int) -> ('b -> 'b -> int) -> ('a, 'b) t -> ('a, 'b) t -> int\n =\n fun _cmp__a _cmp__b a__001_ b__002_ ->\n if Ppx_compare_lib.phys_equal a__001_ b__002_\n then 0\n else (\n match a__001_, b__002_ with\n | Left _a__003_, Left _b__004_ -> _cmp__a _a__003_ _b__004_\n | Left _, _ -> -1\n | _, Left _ -> 1\n | Right _a__005_, Right _b__006_ -> _cmp__b _a__005_ _b__006_\n | Right _, _ -> -1\n | _, Right _ -> 1\n | Both (_a__007_, _a__009_), Both (_b__008_, _b__010_) ->\n (match _cmp__a _a__007_ _b__008_ with\n | 0 -> _cmp__b _a__009_ _b__010_\n | n -> n))\n ;;\n\n let hash_fold_t\n : type a b.\n (Ppx_hash_lib.Std.Hash.state -> a -> Ppx_hash_lib.Std.Hash.state)\n -> (Ppx_hash_lib.Std.Hash.state -> b -> Ppx_hash_lib.Std.Hash.state)\n -> Ppx_hash_lib.Std.Hash.state\n -> (a, b) t\n -> Ppx_hash_lib.Std.Hash.state\n =\n fun _hash_fold_a _hash_fold_b hsv arg ->\n match arg with\n | Left _a0 ->\n let hsv = Ppx_hash_lib.Std.Hash.fold_int hsv 0 in\n let hsv = hsv in\n _hash_fold_a hsv _a0\n | Right _a0 ->\n let hsv = Ppx_hash_lib.Std.Hash.fold_int hsv 1 in\n let hsv = hsv in\n _hash_fold_b hsv _a0\n | Both (_a0, _a1) ->\n let hsv = Ppx_hash_lib.Std.Hash.fold_int hsv 2 in\n let hsv =\n let hsv = hsv in\n _hash_fold_a hsv _a0\n in\n _hash_fold_b hsv _a1\n ;;\n\n let t_of_sexp\n : type a b.\n (Ppx_sexp_conv_lib.Sexp.t -> a)\n -> (Ppx_sexp_conv_lib.Sexp.t -> b)\n -> Ppx_sexp_conv_lib.Sexp.t\n -> (a, b) t\n =\n let _tp_loc = \"sequence.ml.Merge_with_duplicates_element.t\" in\n fun _of_a _of_b -> function\n | Ppx_sexp_conv_lib.Sexp.List\n (Ppx_sexp_conv_lib.Sexp.Atom ((\"left\" | \"Left\") as _tag) :: sexp_args) as _sexp\n ->\n (match sexp_args with\n | [ v0 ] ->\n let v0 = _of_a v0 in\n Left v0\n | _ -> Ppx_sexp_conv_lib.Conv_error.stag_incorrect_n_args _tp_loc _tag _sexp)\n | Ppx_sexp_conv_lib.Sexp.List\n (Ppx_sexp_conv_lib.Sexp.Atom ((\"right\" | \"Right\") as _tag) :: sexp_args) as\n _sexp ->\n (match sexp_args with\n | [ v0 ] ->\n let v0 = _of_b v0 in\n Right v0\n | _ -> Ppx_sexp_conv_lib.Conv_error.stag_incorrect_n_args _tp_loc _tag _sexp)\n | Ppx_sexp_conv_lib.Sexp.List\n (Ppx_sexp_conv_lib.Sexp.Atom ((\"both\" | \"Both\") as _tag) :: sexp_args) as _sexp\n ->\n (match sexp_args with\n | [ v0; v1 ] ->\n let v0 = _of_a v0\n and v1 = _of_b v1 in\n Both (v0, v1)\n | _ -> Ppx_sexp_conv_lib.Conv_error.stag_incorrect_n_args _tp_loc _tag _sexp)\n | Ppx_sexp_conv_lib.Sexp.Atom (\"left\" | \"Left\") as sexp ->\n Ppx_sexp_conv_lib.Conv_error.stag_takes_args _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.Atom (\"right\" | \"Right\") as sexp ->\n Ppx_sexp_conv_lib.Conv_error.stag_takes_args _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.Atom (\"both\" | \"Both\") as sexp ->\n Ppx_sexp_conv_lib.Conv_error.stag_takes_args _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.List (Ppx_sexp_conv_lib.Sexp.List _ :: _) as sexp ->\n Ppx_sexp_conv_lib.Conv_error.nested_list_invalid_sum _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.List [] as sexp ->\n Ppx_sexp_conv_lib.Conv_error.empty_list_invalid_sum _tp_loc sexp\n | sexp -> Ppx_sexp_conv_lib.Conv_error.unexpected_stag _tp_loc sexp\n ;;\n\n let sexp_of_t\n : type a b.\n (a -> Ppx_sexp_conv_lib.Sexp.t)\n -> (b -> Ppx_sexp_conv_lib.Sexp.t)\n -> (a, b) t\n -> Ppx_sexp_conv_lib.Sexp.t\n =\n fun _of_a _of_b -> function\n | Left v0 ->\n let v0 = _of_a v0 in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"Left\"; v0 ]\n | Right v0 ->\n let v0 = _of_b v0 in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"Right\"; v0 ]\n | Both (v0, v1) ->\n let v0 = _of_a v0\n and v1 = _of_b v1 in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"Both\"; v0; v1 ]\n ;;\n\n [@@@end]\nend\n\nlet merge_with_duplicates (Sequence (s1, next1)) (Sequence (s2, next2)) ~compare =\n let unshadowed_compare = compare in\n let open Merge_with_duplicates_element in\n let next = function\n | Skip s1, s2 -> Skip (next1 s1, s2)\n | s1, Skip s2 -> Skip (s1, next2 s2)\n | (Yield (a, s1') as s1), (Yield (b, s2') as s2) ->\n let comparison = unshadowed_compare a b in\n if comparison < 0\n then Yield (Left a, (Skip s1', s2))\n else if comparison = 0\n then Yield (Both (a, b), (Skip s1', Skip s2'))\n else Yield (Right b, (s1, Skip s2'))\n | Done, Done -> Done\n | Yield (a, s1), Done -> Yield (Left a, (Skip s1, Done))\n | Done, Yield (b, s2) -> Yield (Right b, (Done, Skip s2))\n in\n Sequence ((Skip s1, Skip s2), next)\n;;\n\nlet merge s1 s2 ~compare =\n map (merge_with_duplicates s1 s2 ~compare) ~f:(function\n | Left x | Right x | Both (x, _) -> x)\n;;\n\nlet hd s =\n let rec loop s next =\n match next s with\n | Done -> None\n | Skip s -> loop s next\n | Yield (a, _) -> Some a\n in\n match s with\n | Sequence (s, next) -> loop s next\n;;\n\nlet hd_exn s =\n match hd s with\n | None -> failwith \"hd_exn\"\n | Some a -> a\n;;\n\nlet tl s =\n let rec loop s next =\n match next s with\n | Done -> None\n | Skip s -> loop s next\n | Yield (_, a) -> Some a\n in\n match s with\n | Sequence (s, next) ->\n (match loop s next with\n | None -> None\n | Some s -> Some (Sequence (s, next)))\n;;\n\nlet tl_eagerly_exn s =\n match tl s with\n | None -> failwith \"Sequence.tl_exn\"\n | Some s -> s\n;;\n\nlet lift_identity next s =\n match next s with\n | Done -> Done\n | Skip s -> Skip (`Identity s)\n | Yield (a, s) -> Yield (a, `Identity s)\n;;\n\nlet next s =\n let rec loop s next =\n match next s with\n | Done -> None\n | Skip s -> loop s next\n | Yield (a, s) -> Some (a, Sequence (s, next))\n in\n match s with\n | Sequence (s, next) -> loop s next\n;;\n\nlet filter_opt s =\n match s with\n | Sequence (s, next) ->\n Sequence\n ( s\n , fun s ->\n match next s with\n | Done -> Done\n | Skip s -> Skip s\n | Yield (None, s) -> Skip s\n | Yield (Some a, s) -> Yield (a, s) )\n;;\n\nlet filter_map s ~f = filter_opt (map s ~f)\nlet filter_mapi s ~f = filter_map (mapi s ~f:(fun i s -> i, s)) ~f:(fun (i, s) -> f i s)\n\nlet split_n s n =\n let rec loop s i accum next =\n if i <= 0\n then List.rev accum, Sequence (s, next)\n else (\n match next s with\n | Done -> List.rev accum, empty\n | Skip s -> loop s i accum next\n | Yield (a, s) -> loop s (i - 1) (a :: accum) next)\n in\n match s with\n | Sequence (s, next) -> loop s n [] next\n;;\n\nlet chunks_exn t n =\n if n <= 0\n then invalid_arg \"Sequence.chunks_exn\"\n else\n unfold_step ~init:t ~f:(fun t ->\n match split_n t n with\n | [], _empty -> Done\n | (_ :: _ as xs), t -> Yield (xs, t))\n;;\n\nlet findi s ~f = find (mapi s ~f:(fun i s -> i, s)) ~f:(fun (i, s) -> f i s)\n\nlet find_exn s ~f =\n match find s ~f with\n | None -> failwith \"Sequence.find_exn\"\n | Some x -> x\n;;\n\nlet append s1 s2 =\n match s1, s2 with\n | Sequence (s1, next1), Sequence (s2, next2) ->\n Sequence\n ( `First_list s1\n , function\n | `First_list s1 ->\n (match next1 s1 with\n | Done -> Skip (`Second_list s2)\n | Skip s1 -> Skip (`First_list s1)\n | Yield (a, s1) -> Yield (a, `First_list s1))\n | `Second_list s2 ->\n (match next2 s2 with\n | Done -> Done\n | Skip s2 -> Skip (`Second_list s2)\n | Yield (a, s2) -> Yield (a, `Second_list s2)) )\n;;\n\nlet concat_map s ~f = bind s ~f\nlet concat s = concat_map s ~f:Fn.id\nlet concat_mapi s ~f = concat_map (mapi s ~f:(fun i s -> i, s)) ~f:(fun (i, s) -> f i s)\n\nlet zip (Sequence (s1, next1)) (Sequence (s2, next2)) =\n let next = function\n | Yield (a, s1), Yield (b, s2) -> Yield ((a, b), (Skip s1, Skip s2))\n | Done, _ | _, Done -> Done\n | Skip s1, s2 -> Skip (next1 s1, s2)\n | s1, Skip s2 -> Skip (s1, next2 s2)\n in\n Sequence ((Skip s1, Skip s2), next)\n;;\n\nlet zip_full (Sequence (s1, next1)) (Sequence (s2, next2)) =\n let next = function\n | Yield (a, s1), Yield (b, s2) -> Yield (`Both (a, b), (Skip s1, Skip s2))\n | Done, Done -> Done\n | Skip s1, s2 -> Skip (next1 s1, s2)\n | s1, Skip s2 -> Skip (s1, next2 s2)\n | Done, Yield (b, s2) -> Yield (`Right b, (Done, next2 s2))\n | Yield (a, s1), Done -> Yield (`Left a, (next1 s1, Done))\n in\n Sequence ((Skip s1, Skip s2), next)\n;;\n\nlet bounded_length (Sequence (seed, next)) ~at_most =\n let rec loop i seed next =\n if i > at_most\n then `Greater\n else (\n match next seed with\n | Done -> `Is i\n | Skip seed -> loop i seed next\n | Yield (_, seed) -> loop (i + 1) seed next)\n in\n loop 0 seed next\n;;\n\nlet length_is_bounded_by ?(min = -1) ?max t =\n let length_is_at_least (Sequence (s, next)) =\n let rec loop s acc =\n if acc >= min\n then true\n else (\n match next s with\n | Done -> false\n | Skip s -> loop s acc\n | Yield (_, s) -> loop s (acc + 1))\n in\n loop s 0\n in\n match max with\n | None -> length_is_at_least t\n | Some max ->\n (match bounded_length t ~at_most:max with\n | `Is len when len >= min -> true\n | _ -> false)\n;;\n\nlet iteri s ~f = iter (mapi s ~f:(fun i s -> i, s)) ~f:(fun (i, s) -> f i s)\n\nlet foldi s ~init ~f =\n fold ~init (mapi s ~f:(fun i s -> i, s)) ~f:(fun acc (i, s) -> f i acc s)\n;;\n\nlet reduce s ~f =\n match next s with\n | None -> None\n | Some (a, s) -> Some (fold s ~init:a ~f)\n;;\n\nlet reduce_exn s ~f =\n match reduce s ~f with\n | None -> failwith \"Sequence.reduce_exn\"\n | Some res -> res\n;;\n\nlet group (Sequence (s, next)) ~break =\n unfold_step\n ~init:(Some ([], s))\n ~f:(function\n | None -> Done\n | Some (acc, s) ->\n (match acc, next s with\n | _, Skip s -> Skip (Some (acc, s))\n | [], Done -> Done\n | acc, Done -> Yield (List.rev acc, None)\n | [], Yield (cur, s) -> Skip (Some ([ cur ], s))\n | (prev :: _ as acc), Yield (cur, s) ->\n if break prev cur\n then Yield (List.rev acc, Some ([ cur ], s))\n else Skip (Some (cur :: acc, s))))\n;;\n\nlet find_consecutive_duplicate (Sequence (s, next)) ~equal =\n let rec loop last_elt s =\n match next s with\n | Done -> None\n | Skip s -> loop last_elt s\n | Yield (a, s) ->\n (match last_elt with\n | Some b when equal a b -> Some (b, a)\n | None | Some _ -> loop (Some a) s)\n in\n loop None s\n;;\n\nlet remove_consecutive_duplicates s ~equal =\n unfold_with s ~init:None ~f:(fun prev a ->\n match prev with\n | Some b when equal a b -> Skip (Some a)\n | None | Some _ -> Yield (a, Some a))\n;;\n\nlet count s ~f = length (filter s ~f)\nlet counti t ~f = length (filteri t ~f)\nlet sum m t ~f = Container.sum ~fold m t ~f\nlet min_elt t ~compare = Container.min_elt ~fold t ~compare\nlet max_elt t ~compare = Container.max_elt ~fold t ~compare\n\nlet init n ~f =\n unfold_step ~init:0 ~f:(fun i -> if i >= n then Done else Yield (f i, i + 1))\n;;\n\nlet sub s ~pos ~len =\n if pos < 0 || len < 0 then failwith \"Sequence.sub\";\n match s with\n | Sequence (s, next) ->\n Sequence\n ( (0, s)\n , fun (i, s) ->\n if i - pos >= len\n then Done\n else (\n match next s with\n | Done -> Done\n | Skip s -> Skip (i, s)\n | Yield (a, s) when i >= pos -> Yield (a, (i + 1, s))\n | Yield (_, s) -> Skip (i + 1, s)) )\n;;\n\nlet take s len =\n if len < 0 then failwith \"Sequence.take\";\n match s with\n | Sequence (s, next) ->\n Sequence\n ( (0, s)\n , fun (i, s) ->\n if i >= len\n then Done\n else (\n match next s with\n | Done -> Done\n | Skip s -> Skip (i, s)\n | Yield (a, s) -> Yield (a, (i + 1, s))) )\n;;\n\nlet drop s len =\n if len < 0 then failwith \"Sequence.drop\";\n match s with\n | Sequence (s, next) ->\n Sequence\n ( (0, s)\n , fun (i, s) ->\n match next s with\n | Done -> Done\n | Skip s -> Skip (i, s)\n | Yield (a, s) when i >= len -> Yield (a, (i + 1, s))\n | Yield (_, s) -> Skip (i + 1, s) )\n;;\n\nlet take_while s ~f =\n match s with\n | Sequence (s, next) ->\n Sequence\n ( s\n , fun s ->\n match next s with\n | Done -> Done\n | Skip s -> Skip s\n | Yield (a, s) when f a -> Yield (a, s)\n | Yield (_, _) -> Done )\n;;\n\nlet drop_while s ~f =\n match s with\n | Sequence (s, next) ->\n Sequence\n ( `Dropping s\n , function\n | `Dropping s ->\n (match next s with\n | Done -> Done\n | Skip s -> Skip (`Dropping s)\n | Yield (a, s) when f a -> Skip (`Dropping s)\n | Yield (a, s) -> Yield (a, `Identity s))\n | `Identity s -> lift_identity next s )\n;;\n\nlet shift_right s x =\n match s with\n | Sequence (seed, next) ->\n Sequence\n ( `Consing (seed, x)\n , function\n | `Consing (seed, x) -> Yield (x, `Identity seed)\n | `Identity s -> lift_identity next s )\n;;\n\nlet shift_right_with_list s l = append (of_list l) s\nlet shift_left = drop\n\nmodule Infix = struct\n let ( @ ) = append\nend\n\nlet intersperse s ~sep =\n match s with\n | Sequence (s, next) ->\n Sequence\n ( `Init s\n , function\n | `Init s ->\n (match next s with\n | Done -> Done\n | Skip s -> Skip (`Init s)\n | Yield (a, s) -> Yield (a, `Running s))\n | `Running s ->\n (match next s with\n | Done -> Done\n | Skip s -> Skip (`Running s)\n | Yield (a, s) -> Yield (sep, `Putting (a, s)))\n | `Putting (a, s) -> Yield (a, `Running s) )\n;;\n\nlet repeat x = unfold_step ~init:x ~f:(fun x -> Yield (x, x))\n\nlet cycle_list_exn xs =\n if List.is_empty xs then invalid_arg \"Sequence.cycle_list_exn\";\n let s = of_list xs in\n concat_map ~f:(fun () -> s) (repeat ())\n;;\n\nlet cartesian_product sa sb = concat_map sa ~f:(fun a -> zip (repeat a) sb)\nlet singleton x = return x\n\nlet delayed_fold s ~init ~f ~finish =\n Expert.delayed_fold_step s ~init ~finish ~f:(fun acc option ~k ->\n match option with\n | None -> k acc\n | Some a -> f acc a ~k)\n;;\n\nlet fold_m ~bind ~return t ~init ~f =\n Expert.delayed_fold_step\n t\n ~init\n ~f:(fun acc option ~k ->\n match option with\n | None -> bind (return acc) ~f:k\n | Some a -> bind (f acc a) ~f:k)\n ~finish:return\n;;\n\nlet iter_m ~bind ~return t ~f =\n Expert.delayed_fold_step\n t\n ~init:()\n ~f:(fun () option ~k ->\n match option with\n | None -> bind (return ()) ~f:k\n | Some a -> bind (f a) ~f:k)\n ~finish:return\n;;\n\nlet fold_until s ~init ~f ~finish =\n let rec loop s next f acc =\n match next s with\n | Done -> finish acc\n | Skip s -> loop s next f acc\n | Yield (a, s) ->\n (match (f acc a : ('a, 'b) Continue_or_stop.t) with\n | Stop x -> x\n | Continue acc -> loop s next f acc)\n in\n match s with\n | Sequence (s, next) -> loop s next f init\n;;\n\nlet fold_result s ~init ~f =\n let rec loop s next f acc =\n match next s with\n | Done -> Result.return acc\n | Skip s -> loop s next f acc\n | Yield (a, s) ->\n (match (f acc a : (_, _) Result.t) with\n | Error _ as e -> e\n | Ok acc -> loop s next f acc)\n in\n match s with\n | Sequence (s, next) -> loop s next f init\n;;\n\nlet force_eagerly t = of_list (to_list t)\n\nlet memoize (type a) (Sequence (s, next)) =\n let module M = struct\n type t = T of (a, t) Step.t Lazy.t\n end\n in\n let rec memoize s = M.T (lazy (find_step s))\n and find_step s =\n match next s with\n | Done -> Done\n | Skip s -> find_step s\n | Yield (a, s) -> Yield (a, memoize s)\n in\n Sequence (memoize s, fun (M.T l) -> Lazy.force l)\n;;\n\nlet drop_eagerly s len =\n let rec loop i ~len s next =\n if i >= len\n then Sequence (s, next)\n else (\n match next s with\n | Done -> empty\n | Skip s -> loop i ~len s next\n | Yield (_, s) -> loop (i + 1) ~len s next)\n in\n match s with\n | Sequence (s, next) -> loop 0 ~len s next\n;;\n\nlet drop_while_option (Sequence (s, next)) ~f =\n let rec loop s =\n match next s with\n | Done -> None\n | Skip s -> loop s\n | Yield (x, s) -> if f x then loop s else Some (x, Sequence (s, next))\n in\n loop s\n;;\n\nlet compare compare_a t1 t2 =\n With_return.with_return (fun r ->\n iter (zip_full t1 t2) ~f:(function\n | `Left _ -> r.return 1\n | `Right _ -> r.return (-1)\n | `Both (v1, v2) ->\n let c = compare_a v1 v2 in\n if c <> 0 then r.return c);\n 0)\n;;\n\nlet equal equal_a t1 t2 =\n for_all (zip_full t1 t2) ~f:(function\n | `Both (a1, a2) -> equal_a a1 a2\n | `Left _ | `Right _ -> false)\n;;\n\nlet round_robin list =\n let next (todo_stack, done_stack) =\n match todo_stack with\n | Sequence (s, f) :: todo_stack ->\n (match f s with\n | Yield (x, s) -> Yield (x, (todo_stack, Sequence (s, f) :: done_stack))\n | Skip s -> Skip (Sequence (s, f) :: todo_stack, done_stack)\n | Done -> Skip (todo_stack, done_stack))\n | [] -> if List.is_empty done_stack then Done else Skip (List.rev done_stack, [])\n in\n let state = list, [] in\n Sequence (state, next)\n;;\n\nlet interleave (Sequence (s1, f1)) =\n let next (todo_stack, done_stack, s1) =\n match todo_stack with\n | Sequence (s2, f2) :: todo_stack ->\n (match f2 s2 with\n | Yield (x, s2) -> Yield (x, (todo_stack, Sequence (s2, f2) :: done_stack, s1))\n | Skip s2 -> Skip (todo_stack, Sequence (s2, f2) :: done_stack, s1)\n | Done -> Skip (todo_stack, done_stack, s1))\n | [] ->\n (match f1 s1, done_stack with\n | Yield (t, s1), _ -> Skip (List.rev (t :: done_stack), [], s1)\n | Skip s1, _ -> Skip (List.rev done_stack, [], s1)\n | Done, _ :: _ -> Skip (List.rev done_stack, [], s1)\n | Done, [] -> Done)\n in\n let state = [], [], s1 in\n Sequence (state, next)\n;;\n\nlet interleaved_cartesian_product s1 s2 =\n map s1 ~f:(fun x1 -> map s2 ~f:(fun x2 -> x1, x2)) |> interleave\n;;\n\nlet of_seq (seq : _ Caml.Seq.t) =\n unfold_step ~init:seq ~f:(fun seq ->\n match seq () with\n | Nil -> Done\n | Cons (hd, tl) -> Yield (hd, tl))\n;;\n\nlet to_seq (Sequence (state, next)) =\n let rec loop state =\n match next state with\n | Done -> Caml.Seq.Nil\n | Skip state -> loop state\n | Yield (hd, state) -> Caml.Seq.Cons (hd, fun () -> loop state)\n in\n fun () -> loop state\n;;\n\nmodule Generator = struct\n type 'elt steps = Wrap of ('elt, unit -> 'elt steps) Step.t\n\n let unwrap (Wrap step) = step\n\n module T = struct\n type ('a, 'elt) t = ('a -> 'elt steps) -> 'elt steps\n\n let return x k = k x\n\n let bind m ~f k =\n m (fun a ->\n let m' = f a in\n m' k)\n ;;\n\n let map m ~f k = m (fun a -> k (f a))\n let map = `Custom map\n end\n\n include T\n include Monad.Make2 (T)\n\n let yield e k = Wrap (Yield (e, k))\n let to_steps t = t (fun () -> Wrap Done)\n\n let of_sequence sequence =\n delayed_fold\n sequence\n ~init:()\n ~f:(fun () x ~k f -> Wrap (Yield (x, fun () -> k () f)))\n ~finish:return\n ;;\n\n let run t =\n let init () = to_steps t in\n let f thunk = unwrap (thunk ()) in\n unfold_step ~init ~f\n ;;\nend\n","open! Import\ninclude Array0\nmodule Int = Int0\n\ntype 'a t = 'a array [@@deriving_inline compare, sexp, sexp_grammar]\n\nlet compare : 'a. ('a -> 'a -> int) -> 'a t -> 'a t -> int = compare_array\n\nlet t_of_sexp : 'a. (Ppx_sexp_conv_lib.Sexp.t -> 'a) -> Ppx_sexp_conv_lib.Sexp.t -> 'a t =\n array_of_sexp\n;;\n\nlet sexp_of_t : 'a. ('a -> Ppx_sexp_conv_lib.Sexp.t) -> 'a t -> Ppx_sexp_conv_lib.Sexp.t =\n sexp_of_array\n;;\n\nlet (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group) =\n { implicit_vars = [ \"array\" ]\n ; ggid = \"j\\132);\\135qH\\158\\135\\222H\\001\\007\\004\\158\\218\"\n ; types = [ \"t\", Explicit_bind ([ \"a\" ], Apply (Implicit_var 0, [ Explicit_var 0 ])) ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ array_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"array.ml\"\n }\n in\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"t\", _the_group)\n in\n t_sexp_grammar\n;;\n\n[@@@end]\n\n(* This module implements a new in-place, constant heap sorting algorithm to replace the\n one used by the standard libraries. Its only purpose is to be faster (hopefully\n strictly faster) than the base sort and stable_sort.\n\n At a high level the algorithm is:\n - pick two pivot points by:\n - pick 5 arbitrary elements from the array\n - sort them within the array\n - take the elements on either side of the middle element of the sort as the pivots\n - sort the array with:\n - all elements less than pivot1 to the left (range 1)\n - all elements >= pivot1 and <= pivot2 in the middle (range 2)\n - all elements > pivot2 to the right (range 3)\n - if pivot1 and pivot2 are equal, then the middle range is sorted, so ignore it\n - recurse into range 1, 2 (if pivot1 and pivot2 are unequal), and 3\n - during recursion there are two inflection points:\n - if the size of the current range is small, use insertion sort to sort it\n - if the stack depth is large, sort the range with heap-sort to avoid n^2 worst-case\n behavior\n\n See the following for more information:\n - \"Dual-Pivot Quicksort\" by Vladimir Yaroslavskiy.\n Available at\n http://www.kriche.com.ar/root/programming/spaceTimeComplexity/DualPivotQuicksort.pdf\n - \"Quicksort is Optimal\" by Sedgewick and Bentley.\n Slides at http://www.cs.princeton.edu/~rs/talks/QuicksortIsOptimal.pdf\n - http://www.sorting-algorithms.com/quick-sort-3-way *)\n\nmodule Sort = struct\n (* For the sake of speed we could use unsafe get/set throughout, but speed tests don't\n show a significant improvement. *)\n let get = get\n let set = set\n\n let swap arr i j =\n let tmp = get arr i in\n set arr i (get arr j);\n set arr j tmp\n ;;\n\n module type Sort = sig\n val sort\n : 'a t\n -> compare:('a -> 'a -> int)\n -> left:int (* leftmost index of sub-array to sort *)\n -> right:int (* rightmost index of sub-array to sort *)\n -> unit\n end\n\n (* http://en.wikipedia.org/wiki/Insertion_sort *)\n module Insertion_sort : Sort = struct\n let sort arr ~compare ~left ~right =\n (* loop invariant:\n [arr] is sorted from [left] to [pos - 1], inclusive *)\n for pos = left + 1 to right do\n (* loop invariants:\n 1. the subarray arr[left .. i-1] is sorted\n 2. the subarray arr[i+1 .. pos] is sorted and contains only elements > v\n 3. arr[i] may be thought of as containing v\n\n Note that this does not allocate a closure, but is left in the for\n loop for the readability of the documentation. *)\n let rec loop arr ~left ~compare i v =\n let i_next = i - 1 in\n if i_next >= left && compare (get arr i_next) v > 0\n then (\n set arr i (get arr i_next);\n loop arr ~left ~compare i_next v)\n else i\n in\n let v = get arr pos in\n let final_pos = loop arr ~left ~compare pos v in\n set arr final_pos v\n done\n ;;\n end\n\n (* http://en.wikipedia.org/wiki/Heapsort *)\n module Heap_sort : Sort = struct\n (* loop invariant:\n root's children are both either roots of max-heaps or > right *)\n let rec heapify arr ~compare root ~left ~right =\n let relative_root = root - left in\n let left_child = (2 * relative_root) + left + 1 in\n let right_child = (2 * relative_root) + left + 2 in\n let largest =\n if left_child <= right && compare (get arr left_child) (get arr root) > 0\n then left_child\n else root\n in\n let largest =\n if right_child <= right && compare (get arr right_child) (get arr largest) > 0\n then right_child\n else largest\n in\n if largest <> root\n then (\n swap arr root largest;\n heapify arr ~compare largest ~left ~right)\n ;;\n\n let build_heap arr ~compare ~left ~right =\n (* Elements in the second half of the array are already heaps of size 1. We move\n through the first half of the array from back to front examining the element at\n hand, and the left and right children, fixing the heap property as we go. *)\n for i = (left + right) / 2 downto left do\n heapify arr ~compare i ~left ~right\n done\n ;;\n\n let sort arr ~compare ~left ~right =\n build_heap arr ~compare ~left ~right;\n (* loop invariants:\n 1. the subarray arr[left ... i] is a max-heap H\n 2. the subarray arr[i+1 ... right] is sorted (call it S)\n 3. every element of H is less than every element of S *)\n for i = right downto left + 1 do\n swap arr left i;\n heapify arr ~compare left ~left ~right:(i - 1)\n done\n ;;\n end\n\n (* http://en.wikipedia.org/wiki/Introsort *)\n module Intro_sort : sig\n include Sort\n\n val five_element_sort\n : 'a t\n -> compare:('a -> 'a -> int)\n -> int\n -> int\n -> int\n -> int\n -> int\n -> unit\n end = struct\n let five_element_sort arr ~compare m1 m2 m3 m4 m5 =\n let compare_and_swap i j =\n if compare (get arr i) (get arr j) > 0 then swap arr i j\n in\n (* Optimal 5-element sorting network:\n\n {v\n 1--o-----o-----o--------------1\n | | |\n 2--o-----|--o--|-----o--o-----2\n | | | | |\n 3--------o--o--|--o--|--o-----3\n | | |\n 4-----o--------o--o--|-----o--4\n | | |\n 5-----o--------------o-----o--5\n v} *)\n compare_and_swap m1 m2;\n compare_and_swap m4 m5;\n compare_and_swap m1 m3;\n compare_and_swap m2 m3;\n compare_and_swap m1 m4;\n compare_and_swap m3 m4;\n compare_and_swap m2 m5;\n compare_and_swap m2 m3;\n compare_and_swap m4 m5\n ;;\n\n (* choose pivots for the array by sorting 5 elements and examining the center three\n elements. The goal is to choose two pivots that will either:\n - break the range up into 3 even partitions\n or\n - eliminate a commonly appearing element by sorting it into the center partition\n by itself\n To this end we look at the center 3 elements of the 5 and return pairs of equal\n elements or the widest range *)\n let choose_pivots arr ~compare ~left ~right =\n let sixth = (right - left) / 6 in\n let m1 = left + sixth in\n let m2 = m1 + sixth in\n let m3 = m2 + sixth in\n let m4 = m3 + sixth in\n let m5 = m4 + sixth in\n five_element_sort arr ~compare m1 m2 m3 m4 m5;\n let m2_val = get arr m2 in\n let m3_val = get arr m3 in\n let m4_val = get arr m4 in\n if compare m2_val m3_val = 0\n then m2_val, m3_val, true\n else if compare m3_val m4_val = 0\n then m3_val, m4_val, true\n else m2_val, m4_val, false\n ;;\n\n let dual_pivot_partition arr ~compare ~left ~right =\n let pivot1, pivot2, pivots_equal = choose_pivots arr ~compare ~left ~right in\n (* loop invariants:\n 1. left <= l < r <= right\n 2. l <= p <= r\n 3. l <= x < p implies arr[x] >= pivot1\n and arr[x] <= pivot2\n 4. left <= x < l implies arr[x] < pivot1\n 5. r < x <= right implies arr[x] > pivot2 *)\n let rec loop l p r =\n let pv = get arr p in\n if compare pv pivot1 < 0\n then (\n swap arr p l;\n cont (l + 1) (p + 1) r)\n else if compare pv pivot2 > 0\n then (\n (* loop invariants: same as those of the outer loop *)\n let rec scan_backwards r =\n if r > p && compare (get arr r) pivot2 > 0 then scan_backwards (r - 1) else r\n in\n let r = scan_backwards r in\n swap arr r p;\n cont l p (r - 1))\n else cont l (p + 1) r\n and cont l p r = if p > r then l, r else loop l p r in\n let l, r = cont left left right in\n l, r, pivots_equal\n ;;\n\n let rec intro_sort arr ~max_depth ~compare ~left ~right =\n let len = right - left + 1 in\n (* This takes care of some edge cases, such as left > right or very short arrays,\n since Insertion_sort.sort handles these cases properly. Thus we don't need to\n make sure that left and right are valid in recursive calls. *)\n if len <= 32\n then Insertion_sort.sort arr ~compare ~left ~right\n else if max_depth < 0\n then Heap_sort.sort arr ~compare ~left ~right\n else (\n let max_depth = max_depth - 1 in\n let l, r, middle_sorted = dual_pivot_partition arr ~compare ~left ~right in\n intro_sort arr ~max_depth ~compare ~left ~right:(l - 1);\n if not middle_sorted then intro_sort arr ~max_depth ~compare ~left:l ~right:r;\n intro_sort arr ~max_depth ~compare ~left:(r + 1) ~right)\n ;;\n\n let log10_of_3 = Caml.log10 3.\n let log3 x = Caml.log10 x /. log10_of_3\n\n let sort arr ~compare ~left ~right =\n let len = right - left + 1 in\n let heap_sort_switch_depth =\n (* with perfect 3-way partitioning, this is the recursion depth *)\n Int.of_float (log3 (Int.to_float len))\n in\n intro_sort arr ~max_depth:heap_sort_switch_depth ~compare ~left ~right\n ;;\n end\nend\n\nlet sort ?pos ?len arr ~compare =\n let pos, len =\n Ordered_collection_common.get_pos_len_exn () ?pos ?len ~total_length:(length arr)\n in\n Sort.Intro_sort.sort arr ~compare ~left:pos ~right:(pos + len - 1)\n;;\n\nlet to_array t = t\nlet is_empty t = length t = 0\n\nlet is_sorted t ~compare =\n let rec is_sorted_loop t ~compare i =\n if i < 1\n then true\n else compare t.(i - 1) t.(i) <= 0 && is_sorted_loop t ~compare (i - 1)\n in\n is_sorted_loop t ~compare (length t - 1)\n;;\n\nlet is_sorted_strictly t ~compare =\n let rec is_sorted_strictly_loop t ~compare i =\n if i < 1\n then true\n else compare t.(i - 1) t.(i) < 0 && is_sorted_strictly_loop t ~compare (i - 1)\n in\n is_sorted_strictly_loop t ~compare (length t - 1)\n;;\n\nlet folding_map t ~init ~f =\n let acc = ref init in\n map t ~f:(fun x ->\n let new_acc, y = f !acc x in\n acc := new_acc;\n y)\n;;\n\nlet fold_map t ~init ~f =\n let acc = ref init in\n let result =\n map t ~f:(fun x ->\n let new_acc, y = f !acc x in\n acc := new_acc;\n y)\n in\n !acc, result\n;;\n\nlet fold_result t ~init ~f = Container.fold_result ~fold ~init ~f t\nlet fold_until t ~init ~f = Container.fold_until ~fold ~init ~f t\nlet count t ~f = Container.count ~fold t ~f\nlet sum m t ~f = Container.sum ~fold m t ~f\nlet min_elt t ~compare = Container.min_elt ~fold t ~compare\nlet max_elt t ~compare = Container.max_elt ~fold t ~compare\n\nlet foldi t ~init ~f =\n let rec foldi_loop t i ac ~f =\n if i = length t then ac else foldi_loop t (i + 1) (f i ac t.(i)) ~f\n in\n foldi_loop t 0 init ~f\n;;\n\nlet folding_mapi t ~init ~f =\n let acc = ref init in\n mapi t ~f:(fun i x ->\n let new_acc, y = f i !acc x in\n acc := new_acc;\n y)\n;;\n\nlet fold_mapi t ~init ~f =\n let acc = ref init in\n let result =\n mapi t ~f:(fun i x ->\n let new_acc, y = f i !acc x in\n acc := new_acc;\n y)\n in\n !acc, result\n;;\n\nlet counti t ~f =\n foldi t ~init:0 ~f:(fun idx count a -> if f idx a then count + 1 else count)\n;;\n\nlet concat_map t ~f = concat (to_list (map ~f t))\nlet concat_mapi t ~f = concat (to_list (mapi ~f t))\n\nlet rev_inplace t =\n let i = ref 0 in\n let j = ref (length t - 1) in\n while !i < !j do\n swap t !i !j;\n incr i;\n decr j\n done\n;;\n\nlet of_list_rev l =\n match l with\n | [] -> [||]\n | a :: l ->\n let len = 1 + List.length l in\n let t = create ~len a in\n let r = ref l in\n (* We start at [len - 2] because we already put [a] at [t.(len - 1)]. *)\n for i = len - 2 downto 0 do\n match !r with\n | [] -> assert false\n | a :: l ->\n t.(i) <- a;\n r := l\n done;\n t\n;;\n\n(* [of_list_map] and [of_list_rev_map] are based on functions from the OCaml\n distribution. *)\n\nlet of_list_map xs ~f =\n match xs with\n | [] -> [||]\n | hd :: tl ->\n let a = create ~len:(1 + List.length tl) (f hd) in\n let rec fill i = function\n | [] -> a\n | hd :: tl ->\n unsafe_set a i (f hd);\n fill (i + 1) tl\n in\n fill 1 tl\n;;\n\nlet of_list_mapi xs ~f =\n match xs with\n | [] -> [||]\n | hd :: tl ->\n let a = create ~len:(1 + List.length tl) (f 0 hd) in\n let rec fill a i = function\n | [] -> a\n | hd :: tl ->\n unsafe_set a i (f i hd);\n fill a (i + 1) tl\n in\n fill a 1 tl\n;;\n\nlet of_list_rev_map xs ~f =\n let t = of_list_map xs ~f in\n rev_inplace t;\n t\n;;\n\nlet of_list_rev_mapi xs ~f =\n let t = of_list_mapi xs ~f in\n rev_inplace t;\n t\n;;\n\nlet filter_mapi t ~f =\n let r = ref [||] in\n let k = ref 0 in\n for i = 0 to length t - 1 do\n match f i (unsafe_get t i) with\n | None -> ()\n | Some a ->\n if !k = 0 then r := create ~len:(length t) a;\n unsafe_set !r !k a;\n incr k\n done;\n if !k = length t then !r else if !k > 0 then sub ~pos:0 ~len:!k !r else [||]\n;;\n\nlet filter_map t ~f = filter_mapi t ~f:(fun _i a -> f a)\nlet filter_opt t = filter_map t ~f:Fn.id\n\nlet raise_length_mismatch name n1 n2 =\n invalid_argf \"length mismatch in %s: %d <> %d\" name n1 n2 ()\n[@@cold] [@@inline never] [@@local never] [@@specialise never]\n;;\n\nlet check_length2_exn name t1 t2 =\n let n1 = length t1 in\n let n2 = length t2 in\n if n1 <> n2 then raise_length_mismatch name n1 n2\n;;\n\nlet iter2_exn t1 t2 ~f =\n check_length2_exn \"Array.iter2_exn\" t1 t2;\n iteri t1 ~f:(fun i x1 -> f x1 t2.(i))\n;;\n\nlet map2_exn t1 t2 ~f =\n check_length2_exn \"Array.map2_exn\" t1 t2;\n init (length t1) ~f:(fun i -> f t1.(i) t2.(i))\n;;\n\nlet fold2_exn t1 t2 ~init ~f =\n check_length2_exn \"Array.fold2_exn\" t1 t2;\n foldi t1 ~init ~f:(fun i ac x -> f ac x t2.(i))\n;;\n\nlet filter t ~f = filter_map t ~f:(fun x -> if f x then Some x else None)\nlet filteri t ~f = filter_mapi t ~f:(fun i x -> if f i x then Some x else None)\n\nlet exists t ~f =\n let rec exists_loop t ~f i =\n if i < 0 then false else f t.(i) || exists_loop t ~f (i - 1)\n in\n exists_loop t ~f (length t - 1)\n;;\n\nlet existsi t ~f =\n let rec existsi_loop t ~f i =\n if i < 0 then false else f i t.(i) || existsi_loop t ~f (i - 1)\n in\n existsi_loop t ~f (length t - 1)\n;;\n\nlet mem t a ~equal = exists t ~f:(equal a)\n\nlet for_all t ~f =\n let rec for_all_loop t ~f i =\n if i < 0 then true else f t.(i) && for_all_loop t ~f (i - 1)\n in\n for_all_loop t ~f (length t - 1)\n;;\n\nlet for_alli t ~f =\n let rec for_alli_loop t ~f i =\n if i < 0 then true else f i t.(i) && for_alli_loop t ~f (i - 1)\n in\n for_alli_loop t ~f (length t - 1)\n;;\n\nlet exists2_exn t1 t2 ~f =\n let rec exists2_exn_loop t1 t2 ~f i =\n if i < 0 then false else f t1.(i) t2.(i) || exists2_exn_loop t1 t2 ~f (i - 1)\n in\n check_length2_exn \"Array.exists2_exn\" t1 t2;\n exists2_exn_loop t1 t2 ~f (length t1 - 1)\n;;\n\nlet for_all2_exn t1 t2 ~f =\n let rec for_all2_loop t1 t2 ~f i =\n if i < 0 then true else f t1.(i) t2.(i) && for_all2_loop t1 t2 ~f (i - 1)\n in\n check_length2_exn \"Array.for_all2_exn\" t1 t2;\n for_all2_loop t1 t2 ~f (length t1 - 1)\n;;\n\nlet equal equal t1 t2 = length t1 = length t2 && for_all2_exn t1 t2 ~f:equal\n\n\nlet map_inplace t ~f =\n for i = 0 to length t - 1 do\n t.(i) <- f t.(i)\n done\n;;\n\nlet findi t ~f =\n let rec findi_loop t ~f ~length i =\n if i >= length\n then None\n else if f i t.(i)\n then Some (i, t.(i))\n else findi_loop t ~f ~length (i + 1)\n in\n let length = length t in\n findi_loop t ~f ~length 0\n;;\n\nlet findi_exn =\n let not_found = Not_found_s (Atom \"Array.findi_exn: not found\") in\n let findi_exn t ~f =\n match findi t ~f with\n | None -> raise not_found\n | Some x -> x\n in\n (* named to preserve symbol in compiled binary *)\n findi_exn\n;;\n\nlet find_exn =\n let not_found = Not_found_s (Atom \"Array.find_exn: not found\") in\n let find_exn t ~f =\n match findi t ~f:(fun _i x -> f x) with\n | None -> raise not_found\n | Some (_i, x) -> x\n in\n (* named to preserve symbol in compiled binary *)\n find_exn\n;;\n\nlet find t ~f = Option.map (findi t ~f:(fun _i x -> f x)) ~f:(fun (_i, x) -> x)\n\nlet find_map t ~f =\n let rec find_map_loop t ~f ~length i =\n if i >= length\n then None\n else (\n match f t.(i) with\n | None -> find_map_loop t ~f ~length (i + 1)\n | Some _ as res -> res)\n in\n let length = length t in\n find_map_loop t ~f ~length 0\n;;\n\nlet find_map_exn =\n let not_found = Not_found_s (Atom \"Array.find_map_exn: not found\") in\n let find_map_exn t ~f =\n match find_map t ~f with\n | None -> raise not_found\n | Some x -> x\n in\n (* named to preserve symbol in compiled binary *)\n find_map_exn\n;;\n\nlet find_mapi t ~f =\n let rec find_mapi_loop t ~f ~length i =\n if i >= length\n then None\n else (\n match f i t.(i) with\n | None -> find_mapi_loop t ~f ~length (i + 1)\n | Some _ as res -> res)\n in\n let length = length t in\n find_mapi_loop t ~f ~length 0\n;;\n\nlet find_mapi_exn =\n let not_found = Not_found_s (Atom \"Array.find_mapi_exn: not found\") in\n let find_mapi_exn t ~f =\n match find_mapi t ~f with\n | None -> raise not_found\n | Some x -> x\n in\n (* named to preserve symbol in compiled binary *)\n find_mapi_exn\n;;\n\nlet find_consecutive_duplicate t ~equal =\n let n = length t in\n if n <= 1\n then None\n else (\n let result = ref None in\n let i = ref 1 in\n let prev = ref t.(0) in\n while !i < n do\n let cur = t.(!i) in\n if equal cur !prev\n then (\n result := Some (!prev, cur);\n i := n)\n else (\n prev := cur;\n incr i)\n done;\n !result)\n;;\n\nlet reduce t ~f =\n if length t = 0\n then None\n else (\n let r = ref t.(0) in\n for i = 1 to length t - 1 do\n r := f !r t.(i)\n done;\n Some !r)\n;;\n\nlet reduce_exn t ~f =\n match reduce t ~f with\n | None -> invalid_arg \"Array.reduce_exn\"\n | Some v -> v\n;;\n\nlet permute = Array_permute.permute\n\nlet random_element_exn ?(random_state = Random.State.default) t =\n if is_empty t\n then failwith \"Array.random_element_exn: empty array\"\n else t.(Random.State.int random_state (length t))\n;;\n\nlet random_element ?(random_state = Random.State.default) t =\n try Some (random_element_exn ~random_state t) with\n | _ -> None\n;;\n\nlet zip t1 t2 =\n if length t1 <> length t2 then None else Some (map2_exn t1 t2 ~f:(fun x1 x2 -> x1, x2))\n;;\n\nlet zip_exn t1 t2 =\n if length t1 <> length t2\n then failwith \"Array.zip_exn\"\n else map2_exn t1 t2 ~f:(fun x1 x2 -> x1, x2)\n;;\n\nlet unzip t =\n let n = length t in\n if n = 0\n then [||], [||]\n else (\n let x, y = t.(0) in\n let res1 = create ~len:n x in\n let res2 = create ~len:n y in\n for i = 1 to n - 1 do\n let x, y = t.(i) in\n res1.(i) <- x;\n res2.(i) <- y\n done;\n res1, res2)\n;;\n\nlet sorted_copy t ~compare =\n let t1 = copy t in\n sort t1 ~compare;\n t1\n;;\n\nlet partitioni_tf t ~f =\n let both = mapi t ~f:(fun i x -> if f i x then Either.First x else Either.Second x) in\n let trues =\n filter_map both ~f:(function\n | First x -> Some x\n | Second _ -> None)\n in\n let falses =\n filter_map both ~f:(function\n | First _ -> None\n | Second x -> Some x)\n in\n trues, falses\n;;\n\nlet partition_tf t ~f = partitioni_tf t ~f:(fun _i x -> f x)\nlet last t = t.(length t - 1)\n\n(* Convert to a sequence but does not attempt to protect against modification\n in the array. *)\nlet to_sequence_mutable t =\n Sequence.unfold_step ~init:0 ~f:(fun i ->\n if i >= length t then Sequence.Step.Done else Sequence.Step.Yield (t.(i), i + 1))\n;;\n\nlet to_sequence t = to_sequence_mutable (copy t)\n\nlet cartesian_product t1 t2 =\n if is_empty t1 || is_empty t2\n then [||]\n else (\n let n1 = length t1 in\n let n2 = length t2 in\n let t = create ~len:(n1 * n2) (t1.(0), t2.(0)) in\n let r = ref 0 in\n for i1 = 0 to n1 - 1 do\n for i2 = 0 to n2 - 1 do\n t.(!r) <- (t1.(i1), t2.(i2));\n incr r\n done\n done;\n t)\n;;\n\nlet transpose tt =\n if length tt = 0\n then Some [||]\n else (\n let width = length tt in\n let depth = length tt.(0) in\n if exists tt ~f:(fun t -> length t <> depth)\n then None\n else Some (init depth ~f:(fun d -> init width ~f:(fun w -> tt.(w).(d)))))\n;;\n\nlet transpose_exn tt =\n match transpose tt with\n | None -> invalid_arg \"Array.transpose_exn\"\n | Some tt' -> tt'\n;;\n\ninclude Binary_searchable.Make1 (struct\n type nonrec 'a t = 'a t\n\n let get = get\n let length = length\n end)\n\ninclude Blit.Make1 (struct\n type nonrec 'a t = 'a t\n\n let length = length\n\n let create_like ~len t =\n if len = 0\n then [||]\n else (\n assert (length t > 0);\n create ~len t.(0))\n ;;\n\n let unsafe_blit = blit\n end)\n\nlet invariant invariant_a t = iter t ~f:invariant_a\n\nmodule Private = struct\n module Sort = Sort\nend\n","open! Import\nmodule Int = Int0\nmodule String = String0\nmodule Array = Array0\n\n(* We maintain the property that all values of type [t] do not have the tag\n [double_array_tag]. Some functions below assume this in order to avoid testing the\n tag, and will segfault if this property doesn't hold. *)\ntype t = Caml.Obj.t array\n\nlet invariant t = assert (Caml.Obj.tag (Caml.Obj.repr t) <> Caml.Obj.double_array_tag)\nlet length = Array.length\nlet swap t i j = Array.swap t i j\n\nlet sexp_of_t t =\n Sexp.Atom\n (String.concat ~sep:\"\" [ \"\" ])\n;;\n\nlet zero_obj = Caml.Obj.repr (0 : int)\n\n(* We call [Array.create] with a value that is not a float so that the array doesn't get\n tagged with [Double_array_tag]. *)\nlet create_zero ~len = Array.create ~len zero_obj\n\nlet create ~len x =\n (* If we can, use [Array.create] directly. *)\n if Caml.Obj.tag x <> Caml.Obj.double_tag\n then Array.create ~len x\n else (\n (* Otherwise use [create_zero] and set the contents *)\n let t = create_zero ~len in\n let x = Sys.opaque_identity x in\n for i = 0 to len - 1 do\n Array.unsafe_set t i x\n done;\n t)\n;;\n\nlet empty = [||]\n\ntype not_a_float =\n | Not_a_float_0\n | Not_a_float_1 of int\n\nlet _not_a_float_0 = Not_a_float_0\nlet _not_a_float_1 = Not_a_float_1 42\n\nlet get t i =\n (* Make the compiler believe [t] is an array not containing floats so it does not check\n if [t] is tagged with [Double_array_tag]. It is NOT ok to use [int array] since (if\n this function is inlined and the array contains in-heap boxed values) wrong register\n typing may result, leading to a failure to register necessary GC roots. *)\n Caml.Obj.repr ((Caml.Obj.magic (t : t) : not_a_float array).(i) : not_a_float)\n;;\n\nlet[@inline always] unsafe_get t i =\n (* Make the compiler believe [t] is an array not containing floats so it does not check\n if [t] is tagged with [Double_array_tag]. *)\n Caml.Obj.repr\n (Array.unsafe_get (Caml.Obj.magic (t : t) : not_a_float array) i : not_a_float)\n;;\n\nlet[@inline always] unsafe_set_with_caml_modify t i obj =\n (* Same comment as [unsafe_get]. Sys.opaque_identity prevents the compiler from\n potentially wrongly guessing the type of the array based on the type of element, that\n is prevent the implication: (Obj.tag obj = Obj.double_tag) => (Obj.tag t =\n Obj.double_array_tag) which flambda has tried in the past (at least that's assuming\n the compiler respects Sys.opaque_identity, which is not always the case). *)\n Array.unsafe_set\n (Caml.Obj.magic (t : t) : not_a_float array)\n i\n (Caml.Obj.obj (Sys.opaque_identity obj) : not_a_float)\n;;\n\nlet[@inline always] unsafe_set_int_assuming_currently_int t i int =\n (* This skips [caml_modify], which is OK if both the old and new values are integers. *)\n Array.unsafe_set (Caml.Obj.magic (t : t) : int array) i (Sys.opaque_identity int)\n;;\n\n(* For [set] and [unsafe_set], if a pointer is involved, we first do a physical-equality\n test to see if the pointer is changing. If not, we don't need to do the [set], which\n saves a call to [caml_modify]. We think this physical-equality test is worth it\n because it is very cheap (both values are already available from the [is_int] test)\n and because [caml_modify] is expensive. *)\n\nlet set t i obj =\n (* We use [get] first but then we use [Array.unsafe_set] since we know that [i] is\n valid. *)\n let old_obj = get t i in\n if Caml.Obj.is_int old_obj && Caml.Obj.is_int obj\n then unsafe_set_int_assuming_currently_int t i (Caml.Obj.obj obj : int)\n else if not (phys_equal old_obj obj)\n then unsafe_set_with_caml_modify t i obj\n;;\n\nlet[@inline always] unsafe_set t i obj =\n let old_obj = unsafe_get t i in\n if Caml.Obj.is_int old_obj && Caml.Obj.is_int obj\n then unsafe_set_int_assuming_currently_int t i (Caml.Obj.obj obj : int)\n else if not (phys_equal old_obj obj)\n then unsafe_set_with_caml_modify t i obj\n;;\n\nlet[@inline always] unsafe_set_omit_phys_equal_check t i obj =\n let old_obj = unsafe_get t i in\n if Caml.Obj.is_int old_obj && Caml.Obj.is_int obj\n then unsafe_set_int_assuming_currently_int t i (Caml.Obj.obj obj : int)\n else unsafe_set_with_caml_modify t i obj\n;;\n\nlet singleton obj = create ~len:1 obj\n\n(* Pre-condition: t.(i) is an integer. *)\nlet unsafe_set_assuming_currently_int t i obj =\n if Caml.Obj.is_int obj\n then unsafe_set_int_assuming_currently_int t i (Caml.Obj.obj obj : int)\n else\n (* [t.(i)] is an integer and [obj] is not, so we do not need to check if they are\n equal. *)\n unsafe_set_with_caml_modify t i obj\n;;\n\nlet unsafe_set_int t i int =\n let old_obj = unsafe_get t i in\n if Caml.Obj.is_int old_obj\n then unsafe_set_int_assuming_currently_int t i int\n else unsafe_set_with_caml_modify t i (Caml.Obj.repr int)\n;;\n\nlet unsafe_clear_if_pointer t i =\n let old_obj = unsafe_get t i in\n if not (Caml.Obj.is_int old_obj) then unsafe_set_with_caml_modify t i (Caml.Obj.repr 0)\n;;\n\n(** [unsafe_blit] is like [Array.blit], except it uses our own for-loop to avoid\n caml_modify when possible. Its performance is still not comparable to a memcpy. *)\nlet unsafe_blit ~src ~src_pos ~dst ~dst_pos ~len =\n (* When [phys_equal src dst], we need to check whether [dst_pos < src_pos] and have the\n for loop go in the right direction so that we don't overwrite data that we still need\n to read. When [not (phys_equal src dst)], doing this is harmless. From a\n memory-performance perspective, it doesn't matter whether one loops up or down.\n Constant-stride access, forward or backward, should be indistinguishable (at least on\n an intel i7). So, we don't do a check for [phys_equal src dst] and always loop up in\n that case. *)\n if dst_pos < src_pos\n then\n for i = 0 to len - 1 do\n unsafe_set dst (dst_pos + i) (unsafe_get src (src_pos + i))\n done\n else\n for i = len - 1 downto 0 do\n unsafe_set dst (dst_pos + i) (unsafe_get src (src_pos + i))\n done\n;;\n\ninclude Blit.Make (struct\n type nonrec t = t\n\n let create = create_zero\n let length = length\n let unsafe_blit = unsafe_blit\n end)\n\nlet copy src =\n let dst = create_zero ~len:(length src) in\n blito ~src ~dst ();\n dst\n;;\n","open! Import\n\n(* WARNING:\n We use non-memory-safe things throughout the [Trusted] module.\n Most of it is only safe in combination with the type signature (e.g. exposing\n [val copy : 'a t -> 'b t] would be a big mistake). *)\nmodule Trusted : sig\n type 'a t\n\n val empty : 'a t\n val unsafe_create_uninitialized : len:int -> 'a t\n val create_obj_array : len:int -> 'a t\n val create : len:int -> 'a -> 'a t\n val singleton : 'a -> 'a t\n val get : 'a t -> int -> 'a\n val set : 'a t -> int -> 'a -> unit\n val swap : _ t -> int -> int -> unit\n val unsafe_get : 'a t -> int -> 'a\n val unsafe_set : 'a t -> int -> 'a -> unit\n val unsafe_set_omit_phys_equal_check : 'a t -> int -> 'a -> unit\n val unsafe_set_int : 'a t -> int -> int -> unit\n val unsafe_set_int_assuming_currently_int : 'a t -> int -> int -> unit\n val unsafe_set_assuming_currently_int : 'a t -> int -> 'a -> unit\n val length : 'a t -> int\n val unsafe_blit : ('a t, 'a t) Blit.blit\n val copy : 'a t -> 'a t\n val unsafe_clear_if_pointer : _ t -> int -> unit\nend = struct\n type 'a t = Obj_array.t\n\n let empty = Obj_array.empty\n let unsafe_create_uninitialized ~len = Obj_array.create_zero ~len\n let create_obj_array ~len = Obj_array.create_zero ~len\n let create ~len x = Obj_array.create ~len (Caml.Obj.repr x)\n let singleton x = Obj_array.singleton (Caml.Obj.repr x)\n let swap t i j = Obj_array.swap t i j\n let get arr i = Caml.Obj.obj (Obj_array.get arr i)\n let set arr i x = Obj_array.set arr i (Caml.Obj.repr x)\n let unsafe_get arr i = Caml.Obj.obj (Obj_array.unsafe_get arr i)\n let unsafe_set arr i x = Obj_array.unsafe_set arr i (Caml.Obj.repr x)\n let unsafe_set_int arr i x = Obj_array.unsafe_set_int arr i x\n\n let unsafe_set_int_assuming_currently_int arr i x =\n Obj_array.unsafe_set_int_assuming_currently_int arr i x\n ;;\n\n let unsafe_set_assuming_currently_int arr i x =\n Obj_array.unsafe_set_assuming_currently_int arr i (Caml.Obj.repr x)\n ;;\n\n let length = Obj_array.length\n let unsafe_blit = Obj_array.unsafe_blit\n let copy = Obj_array.copy\n\n let unsafe_set_omit_phys_equal_check t i x =\n Obj_array.unsafe_set_omit_phys_equal_check t i (Caml.Obj.repr x)\n ;;\n\n let unsafe_clear_if_pointer = Obj_array.unsafe_clear_if_pointer\nend\n\ninclude Trusted\n\nlet invariant t = assert (Caml.Obj.tag (Caml.Obj.repr t) <> Caml.Obj.double_array_tag)\n\nlet init l ~f =\n if l < 0\n then invalid_arg \"Uniform_array.init\"\n else (\n let res = unsafe_create_uninitialized ~len:l in\n for i = 0 to l - 1 do\n unsafe_set res i (f i)\n done;\n res)\n;;\n\nlet of_array arr = init ~f:(Array.unsafe_get arr) (Array.length arr)\nlet map a ~f = init ~f:(fun i -> f (unsafe_get a i)) (length a)\n\nlet iter a ~f =\n for i = 0 to length a - 1 do\n f (unsafe_get a i)\n done\n;;\n\nlet iteri a ~f =\n for i = 0 to length a - 1 do\n f i (unsafe_get a i)\n done\n;;\n\nlet to_list t = List.init ~f:(get t) (length t)\n\nlet of_list l =\n let len = List.length l in\n let res = unsafe_create_uninitialized ~len in\n List.iteri l ~f:(fun i x -> set res i x);\n res\n;;\n\n(* It is not safe for [to_array] to be the identity function because we have code that\n relies on [float array]s being unboxed, for example in [bin_write_array]. *)\nlet to_array t = Array.init (length t) ~f:(fun i -> unsafe_get t i)\n\nlet exists t ~f =\n let rec loop t ~f i =\n if i < 0 then false else f (unsafe_get t i) || loop t ~f (i - 1)\n in\n loop t ~f (length t - 1)\n;;\n\nlet map2_exn t1 t2 ~f =\n let len = length t1 in\n if length t2 <> len then invalid_arg \"Array.map2_exn\";\n init len ~f:(fun i -> f (unsafe_get t1 i) (unsafe_get t2 i))\n;;\n\ninclude Sexpable.Of_sexpable1\n (Array)\n (struct\n type nonrec 'a t = 'a t\n\n let to_sexpable = to_array\n let of_sexpable = of_array\n end)\n\ninclude Blit.Make1 (struct\n type nonrec 'a t = 'a t\n\n let length = length\n\n let create_like ~len t =\n if len = 0\n then empty\n else (\n assert (length t > 0);\n create ~len (get t 0))\n ;;\n\n let unsafe_blit = unsafe_blit\n end)\n\nlet fold t ~init ~f =\n let r = ref init in\n for i = 0 to length t - 1 do\n r := f !r (unsafe_get t i)\n done;\n !r\n;;\n\nlet min_elt t ~compare = Container.min_elt ~fold t ~compare\nlet max_elt t ~compare = Container.max_elt ~fold t ~compare\n","open! Import\nmodule Array = Array0\nmodule String = String0\ninclude Char0\n\nmodule T = struct\n type t = char [@@deriving_inline compare, hash, sexp, sexp_grammar]\n\n let compare = (compare_char : t -> t -> int)\n\n let (hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state) =\n hash_fold_char\n\n and (hash : t -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func = hash_char in\n fun x -> func x\n ;;\n\n let t_of_sexp = (char_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t)\n let sexp_of_t = (sexp_of_char : t -> Ppx_sexp_conv_lib.Sexp.t)\n\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group) =\n { implicit_vars = [ \"char\" ]\n ; ggid = \"\\146e\\023\\249\\235eE\\139c\\132W\\195\\137\\129\\235\\025\"\n ; types = [ \"t\", Implicit_var 0 ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ char_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"char.ml.T\"\n }\n in\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"t\", _the_group)\n in\n t_sexp_grammar\n ;;\n\n [@@@end]\n\n let to_string t = String.make 1 t\n\n let of_string s =\n match String.length s with\n | 1 -> s.[0]\n | _ -> failwithf \"Char.of_string: %S\" s ()\n ;;\nend\n\ninclude T\n\ninclude Identifiable.Make (struct\n include T\n\n let module_name = \"Base.Char\"\n end)\n\n(* Open replace_polymorphic_compare after including functor instantiations so they do not\n shadow its definitions. This is here so that efficient versions of the comparison\n functions are available within this module. *)\nopen! Char_replace_polymorphic_compare\n\nlet invariant (_ : t) = ()\nlet all = Array.init 256 ~f:unsafe_of_int |> Array.to_list\n\nlet is_lowercase = function\n | 'a' .. 'z' -> true\n | _ -> false\n;;\n\nlet is_uppercase = function\n | 'A' .. 'Z' -> true\n | _ -> false\n;;\n\nlet is_print = function\n | ' ' .. '~' -> true\n | _ -> false\n;;\n\nlet is_whitespace = function\n | '\\t' | '\\n' | '\\011' (* vertical tab *) | '\\012' (* form feed *) | '\\r' | ' ' -> true\n | _ -> false\n;;\n\nlet is_digit = function\n | '0' .. '9' -> true\n | _ -> false\n;;\n\nlet is_alpha = function\n | 'a' .. 'z' | 'A' .. 'Z' -> true\n | _ -> false\n;;\n\n(* Writing these out, instead of calling [is_alpha] and [is_digit], reduces\n runtime by approx. 30% *)\nlet is_alphanum = function\n | 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' -> true\n | _ -> false\n;;\n\nlet get_digit_unsafe t = to_int t - to_int '0'\n\nlet get_digit_exn t =\n if is_digit t\n then get_digit_unsafe t\n else failwithf \"Char.get_digit_exn %C: not a digit\" t ()\n;;\n\nlet get_digit t = if is_digit t then Some (get_digit_unsafe t) else None\n\nmodule O = struct\n let ( >= ) = ( >= )\n let ( <= ) = ( <= )\n let ( = ) = ( = )\n let ( > ) = ( > )\n let ( < ) = ( < )\n let ( <> ) = ( <> )\nend\n\nmodule Caseless = struct\n module T = struct\n type t = char [@@deriving_inline sexp]\n\n let t_of_sexp = (char_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t)\n let sexp_of_t = (sexp_of_char : t -> Ppx_sexp_conv_lib.Sexp.t)\n\n [@@@end]\n\n let compare c1 c2 = compare (lowercase c1) (lowercase c2)\n let hash_fold_t state t = hash_fold_char state (lowercase t)\n let hash t = Hash.run hash_fold_t t\n end\n\n include T\n include Comparable.Make (T)\nend\n\n(* Include type-specific [Replace_polymorphic_compare] at the end, after\n including functor application that could shadow its definitions. This is\n here so that efficient versions of the comparison functions are exported by\n this module. *)\ninclude Char_replace_polymorphic_compare\n","open! Import\nmodule Array = Array0\nmodule Bytes = Bytes0\ninclude String0\n\nlet invalid_argf = Printf.invalid_argf\nlet raise_s = Error.raise_s\nlet stage = Staged.stage\n\nmodule T = struct\n type t = string [@@deriving_inline hash, sexp, sexp_grammar]\n\n let (hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state) =\n hash_fold_string\n\n and (hash : t -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func = hash_string in\n fun x -> func x\n ;;\n\n let t_of_sexp = (string_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t)\n let sexp_of_t = (sexp_of_string : t -> Ppx_sexp_conv_lib.Sexp.t)\n\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group) =\n { implicit_vars = [ \"string\" ]\n ; ggid = \"\\146e\\023\\249\\235eE\\139c\\132W\\195\\137\\129\\235\\025\"\n ; types = [ \"t\", Implicit_var 0 ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ string_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"string.ml.T\"\n }\n in\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"t\", _the_group)\n in\n t_sexp_grammar\n ;;\n\n [@@@end]\n\n let compare = compare\nend\n\ninclude T\ninclude Comparator.Make (T)\n\ntype elt = char\n\nlet invariant (_ : t) = ()\n\n(* This is copied/adapted from 'blit.ml'.\n [sub], [subo] could be implemented using [Blit.Make(Bytes)] plus unsafe casts to/from\n string but were inlined here to avoid using [Bytes.unsafe_of_string] as much as possible.\n*)\nlet sub src ~pos ~len =\n if pos = 0 && len = String.length src\n then src\n else (\n Ordered_collection_common.check_pos_len_exn ~pos ~len ~total_length:(length src);\n let dst = Bytes.create len in\n if len > 0 then Bytes.unsafe_blit_string ~src ~src_pos:pos ~dst ~dst_pos:0 ~len;\n Bytes.unsafe_to_string ~no_mutation_while_string_reachable:dst)\n;;\n\nlet subo ?(pos = 0) ?len src =\n sub\n src\n ~pos\n ~len:\n (match len with\n | Some i -> i\n | None -> length src - pos)\n;;\n\nlet rec contains_unsafe t ~pos ~end_ char =\n pos < end_\n && (Char.equal (unsafe_get t pos) char || contains_unsafe t ~pos:(pos + 1) ~end_ char)\n;;\n\nlet contains ?(pos = 0) ?len t char =\n let total_length = String.length t in\n let len = Option.value len ~default:(total_length - pos) in\n Ordered_collection_common.check_pos_len_exn ~pos ~len ~total_length;\n contains_unsafe t ~pos ~end_:(pos + len) char\n;;\n\nlet is_empty t = length t = 0\n\nlet rec index_from_exn_internal string ~pos ~len ~not_found char =\n if pos >= len\n then raise not_found\n else if Char.equal (unsafe_get string pos) char\n then pos\n else index_from_exn_internal string ~pos:(pos + 1) ~len ~not_found char\n;;\n\nlet index_exn_internal t ~not_found char =\n index_from_exn_internal t ~pos:0 ~len:(length t) ~not_found char\n;;\n\nlet index_exn =\n let not_found = Not_found_s (Atom \"String.index_exn: not found\") in\n let index_exn t char = index_exn_internal t ~not_found char in\n (* named to preserve symbol in compiled binary *)\n index_exn\n;;\n\nlet index_from_exn =\n let not_found = Not_found_s (Atom \"String.index_from_exn: not found\") in\n let index_from_exn t pos char =\n let len = length t in\n if pos < 0 || pos > len\n then invalid_arg \"String.index_from_exn\"\n else index_from_exn_internal t ~pos ~len ~not_found char\n in\n (* named to preserve symbol in compiled binary *)\n index_from_exn\n;;\n\nlet rec rindex_from_exn_internal string ~pos ~len ~not_found char =\n if pos < 0\n then raise not_found\n else if Char.equal (unsafe_get string pos) char\n then pos\n else rindex_from_exn_internal string ~pos:(pos - 1) ~len ~not_found char\n;;\n\nlet rindex_exn_internal t ~not_found char =\n let len = length t in\n rindex_from_exn_internal t ~pos:(len - 1) ~len ~not_found char\n;;\n\nlet rindex_exn =\n let not_found = Not_found_s (Atom \"String.rindex_exn: not found\") in\n let rindex_exn t char = rindex_exn_internal t ~not_found char in\n (* named to preserve symbol in compiled binary *)\n rindex_exn\n;;\n\nlet rindex_from_exn =\n let not_found = Not_found_s (Atom \"String.rindex_from_exn: not found\") in\n let rindex_from_exn t pos char =\n let len = length t in\n if pos < -1 || pos >= len\n then invalid_arg \"String.rindex_from_exn\"\n else rindex_from_exn_internal t ~pos ~len ~not_found char\n in\n (* named to preserve symbol in compiled binary *)\n rindex_from_exn\n;;\n\nlet index t char =\n try Some (index_exn t char) with\n | Not_found_s _ | Caml.Not_found -> None\n;;\n\nlet rindex t char =\n try Some (rindex_exn t char) with\n | Not_found_s _ | Caml.Not_found -> None\n;;\n\nlet index_from t pos char =\n try Some (index_from_exn t pos char) with\n | Not_found_s _ | Caml.Not_found -> None\n;;\n\nlet rindex_from t pos char =\n try Some (rindex_from_exn t pos char) with\n | Not_found_s _ | Caml.Not_found -> None\n;;\n\nmodule Search_pattern0 = struct\n type t =\n { pattern : string\n ; case_sensitive : bool\n ; kmp_array : int array\n }\n\n let sexp_of_t { pattern; case_sensitive; kmp_array = _ } : Sexp.t =\n List\n [ List [ Atom \"pattern\"; sexp_of_string pattern ]\n ; List [ Atom \"case_sensitive\"; sexp_of_bool case_sensitive ]\n ]\n ;;\n\n let pattern t = t.pattern\n let case_sensitive t = t.case_sensitive\n\n (* Find max number of matched characters at [next_text_char], given the current\n [matched_chars]. Try to extend the current match, if chars don't match, try to match\n fewer chars. If chars match then extend the match. *)\n let kmp_internal_loop ~matched_chars ~next_text_char ~pattern ~kmp_array ~char_equal =\n let matched_chars = ref matched_chars in\n while\n !matched_chars > 0\n && not (char_equal next_text_char (unsafe_get pattern !matched_chars))\n do\n matched_chars := Array.unsafe_get kmp_array (!matched_chars - 1)\n done;\n if char_equal next_text_char (unsafe_get pattern !matched_chars)\n then matched_chars := !matched_chars + 1;\n !matched_chars\n ;;\n\n let get_char_equal ~case_sensitive =\n match case_sensitive with\n | true -> Char.equal\n | false -> Char.Caseless.equal\n ;;\n\n (* Classic KMP pre-processing of the pattern: build the int array, which, for each i,\n contains the length of the longest non-trivial prefix of s which is equal to a suffix\n ending at s.[i] *)\n let create pattern ~case_sensitive =\n let n = length pattern in\n let kmp_array = Array.create ~len:n (-1) in\n if n > 0\n then (\n let char_equal = get_char_equal ~case_sensitive in\n Array.unsafe_set kmp_array 0 0;\n let matched_chars = ref 0 in\n for i = 1 to n - 1 do\n matched_chars\n := kmp_internal_loop\n ~matched_chars:!matched_chars\n ~next_text_char:(unsafe_get pattern i)\n ~pattern\n ~kmp_array\n ~char_equal;\n Array.unsafe_set kmp_array i !matched_chars\n done);\n { pattern; case_sensitive; kmp_array }\n ;;\n\n (* Classic KMP: use the pre-processed pattern to optimize look-behinds on non-matches.\n We return int to avoid allocation in [index_exn]. -1 means no match. *)\n let index_internal ?(pos = 0) { pattern; case_sensitive; kmp_array } ~in_:text =\n if pos < 0 || pos > length text - length pattern\n then -1\n else (\n let char_equal = get_char_equal ~case_sensitive in\n let j = ref pos in\n let matched_chars = ref 0 in\n let k = length pattern in\n let n = length text in\n while !j < n && !matched_chars < k do\n let next_text_char = unsafe_get text !j in\n matched_chars\n := kmp_internal_loop\n ~matched_chars:!matched_chars\n ~next_text_char\n ~pattern\n ~kmp_array\n ~char_equal;\n j := !j + 1\n done;\n if !matched_chars = k then !j - k else -1)\n ;;\n\n let matches t str = index_internal t ~in_:str >= 0\n\n let index ?pos t ~in_ =\n let p = index_internal ?pos t ~in_ in\n if p < 0 then None else Some p\n ;;\n\n let index_exn ?pos t ~in_ =\n let p = index_internal ?pos t ~in_ in\n if p >= 0\n then p\n else\n raise_s\n (Sexp.message \"Substring not found\" [ \"substring\", sexp_of_string t.pattern ])\n ;;\n\n let index_all { pattern; case_sensitive; kmp_array } ~may_overlap ~in_:text =\n if length pattern = 0\n then List.init (1 + length text) ~f:Fn.id\n else (\n let char_equal = get_char_equal ~case_sensitive in\n let matched_chars = ref 0 in\n let k = length pattern in\n let n = length text in\n let found = ref [] in\n for j = 0 to n do\n if !matched_chars = k\n then (\n found := (j - k) :: !found;\n (* we just found a match in the previous iteration *)\n match may_overlap with\n | true -> matched_chars := Array.unsafe_get kmp_array (k - 1)\n | false -> matched_chars := 0);\n if j < n\n then (\n let next_text_char = unsafe_get text j in\n matched_chars\n := kmp_internal_loop\n ~matched_chars:!matched_chars\n ~next_text_char\n ~pattern\n ~kmp_array\n ~char_equal)\n done;\n List.rev !found)\n ;;\n\n let replace_first ?pos t ~in_:s ~with_ =\n match index ?pos t ~in_:s with\n | None -> s\n | Some i ->\n let len_s = length s in\n let len_t = length t.pattern in\n let len_with = length with_ in\n let dst = Bytes.create (len_s + len_with - len_t) in\n Bytes.blit_string ~src:s ~src_pos:0 ~dst ~dst_pos:0 ~len:i;\n Bytes.blit_string ~src:with_ ~src_pos:0 ~dst ~dst_pos:i ~len:len_with;\n Bytes.blit_string\n ~src:s\n ~src_pos:(i + len_t)\n ~dst\n ~dst_pos:(i + len_with)\n ~len:(len_s - i - len_t);\n Bytes.unsafe_to_string ~no_mutation_while_string_reachable:dst\n ;;\n\n\n let replace_all t ~in_:s ~with_ =\n let matches = index_all t ~may_overlap:false ~in_:s in\n match matches with\n | [] -> s\n | _ :: _ ->\n let len_s = length s in\n let len_t = length t.pattern in\n let len_with = length with_ in\n let num_matches = List.length matches in\n let dst = Bytes.create (len_s + ((len_with - len_t) * num_matches)) in\n let next_dst_pos = ref 0 in\n let next_src_pos = ref 0 in\n List.iter matches ~f:(fun i ->\n let len = i - !next_src_pos in\n Bytes.blit_string\n ~src:s\n ~src_pos:!next_src_pos\n ~dst\n ~dst_pos:!next_dst_pos\n ~len;\n Bytes.blit_string\n ~src:with_\n ~src_pos:0\n ~dst\n ~dst_pos:(!next_dst_pos + len)\n ~len:len_with;\n next_dst_pos := !next_dst_pos + len + len_with;\n next_src_pos := !next_src_pos + len + len_t);\n Bytes.blit_string\n ~src:s\n ~src_pos:!next_src_pos\n ~dst\n ~dst_pos:!next_dst_pos\n ~len:(len_s - !next_src_pos);\n Bytes.unsafe_to_string ~no_mutation_while_string_reachable:dst\n ;;\n\n module Private = struct\n type public = t\n\n type nonrec t = t =\n { pattern : string\n ; case_sensitive : bool\n ; kmp_array : int array\n }\n [@@deriving_inline equal, sexp_of]\n\n let equal =\n (fun a__001_ b__002_ ->\n if Ppx_compare_lib.phys_equal a__001_ b__002_\n then true\n else\n Ppx_compare_lib.( && )\n (equal_string a__001_.pattern b__002_.pattern)\n (Ppx_compare_lib.( && )\n (equal_bool a__001_.case_sensitive b__002_.case_sensitive)\n (equal_array equal_int a__001_.kmp_array b__002_.kmp_array))\n : t -> t -> bool)\n ;;\n\n let sexp_of_t =\n (function\n | { pattern = v_pattern\n ; case_sensitive = v_case_sensitive\n ; kmp_array = v_kmp_array\n } ->\n let bnds = [] in\n let bnds =\n let arg = sexp_of_array sexp_of_int v_kmp_array in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"kmp_array\"; arg ]\n :: bnds\n in\n let bnds =\n let arg = sexp_of_bool v_case_sensitive in\n Ppx_sexp_conv_lib.Sexp.List\n [ Ppx_sexp_conv_lib.Sexp.Atom \"case_sensitive\"; arg ]\n :: bnds\n in\n let bnds =\n let arg = sexp_of_string v_pattern in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"pattern\"; arg ]\n :: bnds\n in\n Ppx_sexp_conv_lib.Sexp.List bnds\n : t -> Ppx_sexp_conv_lib.Sexp.t)\n ;;\n\n [@@@end]\n\n let representation = Fn.id\n end\nend\n\nmodule Search_pattern_helper = struct\n module Search_pattern = Search_pattern0\nend\n\nopen Search_pattern_helper\n\nlet substr_index_gen ~case_sensitive ?pos t ~pattern =\n Search_pattern.index ?pos (Search_pattern.create ~case_sensitive pattern) ~in_:t\n;;\n\nlet substr_index_exn_gen ~case_sensitive ?pos t ~pattern =\n Search_pattern.index_exn ?pos (Search_pattern.create ~case_sensitive pattern) ~in_:t\n;;\n\nlet substr_index_all_gen ~case_sensitive t ~may_overlap ~pattern =\n Search_pattern.index_all\n (Search_pattern.create ~case_sensitive pattern)\n ~may_overlap\n ~in_:t\n;;\n\nlet substr_replace_first_gen ~case_sensitive ?pos t ~pattern =\n Search_pattern.replace_first\n ?pos\n (Search_pattern.create ~case_sensitive pattern)\n ~in_:t\n;;\n\nlet substr_replace_all_gen ~case_sensitive t ~pattern =\n Search_pattern.replace_all (Search_pattern.create ~case_sensitive pattern) ~in_:t\n;;\n\nlet is_substring_gen ~case_sensitive t ~substring =\n Option.is_some (substr_index_gen t ~pattern:substring ~case_sensitive)\n;;\n\nlet substr_index = substr_index_gen ~case_sensitive:true\nlet substr_index_exn = substr_index_exn_gen ~case_sensitive:true\nlet substr_index_all = substr_index_all_gen ~case_sensitive:true\nlet substr_replace_first = substr_replace_first_gen ~case_sensitive:true\nlet substr_replace_all = substr_replace_all_gen ~case_sensitive:true\nlet is_substring = is_substring_gen ~case_sensitive:true\n\nlet is_substring_at_gen =\n let rec loop ~str ~str_pos ~sub ~sub_pos ~sub_len ~char_equal =\n if sub_pos = sub_len\n then true\n else if char_equal (unsafe_get str str_pos) (unsafe_get sub sub_pos)\n then\n loop ~str ~str_pos:(str_pos + 1) ~sub ~sub_pos:(sub_pos + 1) ~sub_len ~char_equal\n else false\n in\n fun str ~pos:str_pos ~substring:sub ~char_equal ->\n let str_len = length str in\n let sub_len = length sub in\n if str_pos < 0 || str_pos > str_len\n then\n invalid_argf\n \"String.is_substring_at: invalid index %d for string of length %d\"\n str_pos\n str_len\n ();\n str_pos + sub_len <= str_len\n && loop ~str ~str_pos ~sub ~sub_pos:0 ~sub_len ~char_equal\n;;\n\nlet is_suffix_gen string ~suffix ~char_equal =\n let string_len = length string in\n let suffix_len = length suffix in\n string_len >= suffix_len\n && is_substring_at_gen\n string\n ~pos:(string_len - suffix_len)\n ~substring:suffix\n ~char_equal\n;;\n\nlet is_prefix_gen string ~prefix ~char_equal =\n let string_len = length string in\n let prefix_len = length prefix in\n string_len >= prefix_len\n && is_substring_at_gen string ~pos:0 ~substring:prefix ~char_equal\n;;\n\nmodule Caseless = struct\n module T = struct\n type t = string [@@deriving_inline sexp]\n\n let t_of_sexp = (string_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t)\n let sexp_of_t = (sexp_of_string : t -> Ppx_sexp_conv_lib.Sexp.t)\n\n [@@@end]\n\n let char_compare_caseless c1 c2 =\n Char.compare (Char.lowercase c1) (Char.lowercase c2)\n ;;\n\n let rec compare_loop ~pos ~string1 ~len1 ~string2 ~len2 =\n if pos = len1\n then if pos = len2 then 0 else -1\n else if pos = len2\n then 1\n else (\n let c =\n char_compare_caseless (unsafe_get string1 pos) (unsafe_get string2 pos)\n in\n match c with\n | 0 -> compare_loop ~pos:(pos + 1) ~string1 ~len1 ~string2 ~len2\n | _ -> c)\n ;;\n\n let compare string1 string2 =\n if phys_equal string1 string2\n then 0\n else\n compare_loop\n ~pos:0\n ~string1\n ~len1:(String.length string1)\n ~string2\n ~len2:(String.length string2)\n ;;\n\n let hash_fold_t state t =\n let len = length t in\n let state = ref (hash_fold_int state len) in\n for pos = 0 to len - 1 do\n state := hash_fold_char !state (Char.lowercase (unsafe_get t pos))\n done;\n !state\n ;;\n\n let hash t = Hash.run hash_fold_t t\n let is_suffix s ~suffix = is_suffix_gen s ~suffix ~char_equal:Char.Caseless.equal\n let is_prefix s ~prefix = is_prefix_gen s ~prefix ~char_equal:Char.Caseless.equal\n let substr_index = substr_index_gen ~case_sensitive:false\n let substr_index_exn = substr_index_exn_gen ~case_sensitive:false\n let substr_index_all = substr_index_all_gen ~case_sensitive:false\n let substr_replace_first = substr_replace_first_gen ~case_sensitive:false\n let substr_replace_all = substr_replace_all_gen ~case_sensitive:false\n let is_substring = is_substring_gen ~case_sensitive:false\n let is_substring_at = is_substring_at_gen ~char_equal:Char.Caseless.equal\n end\n\n include T\n include Comparable.Make (T)\nend\n\nlet of_string = Fn.id\nlet to_string = Fn.id\n\nlet init n ~f =\n if n < 0 then invalid_argf \"String.init %d\" n ();\n let t = Bytes.create n in\n for i = 0 to n - 1 do\n Bytes.set t i (f i)\n done;\n Bytes.unsafe_to_string ~no_mutation_while_string_reachable:t\n;;\n\nlet to_list s =\n let rec loop acc i = if i < 0 then acc else loop (s.[i] :: acc) (i - 1) in\n loop [] (length s - 1)\n;;\n\nlet to_list_rev s =\n let len = length s in\n let rec loop acc i = if i = len then acc else loop (s.[i] :: acc) (i + 1) in\n loop [] 0\n;;\n\nlet rev t =\n let len = length t in\n let res = Bytes.create len in\n for i = 0 to len - 1 do\n unsafe_set res i (unsafe_get t (len - 1 - i))\n done;\n Bytes.unsafe_to_string ~no_mutation_while_string_reachable:res\n;;\n\n(** Efficient string splitting *)\n\nlet lsplit2_exn =\n let not_found = Not_found_s (Atom \"String.lsplit2_exn: not found\") in\n let lsplit2_exn line ~on:delim =\n let pos = index_exn_internal line ~not_found delim in\n sub line ~pos:0 ~len:pos, sub line ~pos:(pos + 1) ~len:(length line - pos - 1)\n in\n (* named to preserve symbol in compiled binary *)\n lsplit2_exn\n;;\n\nlet rsplit2_exn =\n let not_found = Not_found_s (Atom \"String.rsplit2_exn: not found\") in\n let rsplit2_exn line ~on:delim =\n let pos = rindex_exn_internal line ~not_found delim in\n sub line ~pos:0 ~len:pos, sub line ~pos:(pos + 1) ~len:(length line - pos - 1)\n in\n (* named to preserve symbol in compiled binary *)\n rsplit2_exn\n;;\n\nlet lsplit2 line ~on =\n try Some (lsplit2_exn line ~on) with\n | Not_found_s _ | Caml.Not_found -> None\n;;\n\nlet rsplit2 line ~on =\n try Some (rsplit2_exn line ~on) with\n | Not_found_s _ | Caml.Not_found -> None\n;;\n\nlet rec char_list_mem l (c : char) =\n match l with\n | [] -> false\n | hd :: tl -> Char.equal hd c || char_list_mem tl c\n;;\n\nlet split_gen str ~on =\n let is_delim =\n match on with\n | `char c' -> fun c -> Char.equal c c'\n | `char_list l -> fun c -> char_list_mem l c\n in\n let len = length str in\n let rec loop acc last_pos pos =\n if pos = -1\n then sub str ~pos:0 ~len:last_pos :: acc\n else if is_delim str.[pos]\n then (\n let pos1 = pos + 1 in\n let sub_str = sub str ~pos:pos1 ~len:(last_pos - pos1) in\n loop (sub_str :: acc) pos (pos - 1))\n else loop acc last_pos (pos - 1)\n in\n loop [] len (len - 1)\n;;\n\nlet split str ~on = split_gen str ~on:(`char on)\nlet split_on_chars str ~on:chars = split_gen str ~on:(`char_list chars)\n\nlet split_lines =\n let back_up_at_newline ~t ~pos ~eol =\n pos := !pos - if !pos > 0 && Char.equal t.[!pos - 1] '\\r' then 2 else 1;\n eol := !pos + 1\n in\n fun t ->\n let n = length t in\n if n = 0\n then []\n else (\n (* Invariant: [-1 <= pos < eol]. *)\n let pos = ref (n - 1) in\n let eol = ref n in\n let ac = ref [] in\n (* We treat the end of the string specially, because if the string ends with a\n newline, we don't want an extra empty string at the end of the output. *)\n if Char.equal t.[!pos] '\\n' then back_up_at_newline ~t ~pos ~eol;\n while !pos >= 0 do\n if Char.( <> ) t.[!pos] '\\n'\n then decr pos\n else (\n (* Because [pos < eol], we know that [start <= eol]. *)\n let start = !pos + 1 in\n ac := sub t ~pos:start ~len:(!eol - start) :: !ac;\n back_up_at_newline ~t ~pos ~eol)\n done;\n sub t ~pos:0 ~len:!eol :: !ac)\n;;\n\nlet is_suffix s ~suffix = is_suffix_gen s ~suffix ~char_equal:Char.equal\nlet is_prefix s ~prefix = is_prefix_gen s ~prefix ~char_equal:Char.equal\n\nlet is_substring_at s ~pos ~substring =\n is_substring_at_gen s ~pos ~substring ~char_equal:Char.equal\n;;\n\nlet wrap_sub_n t n ~name ~pos ~len ~on_error =\n if n < 0\n then invalid_arg (name ^ \" expecting nonnegative argument\")\n else (\n try sub t ~pos ~len with\n | _ -> on_error)\n;;\n\nlet drop_prefix t n =\n wrap_sub_n ~name:\"drop_prefix\" t n ~pos:n ~len:(length t - n) ~on_error:\"\"\n;;\n\nlet drop_suffix t n =\n wrap_sub_n ~name:\"drop_suffix\" t n ~pos:0 ~len:(length t - n) ~on_error:\"\"\n;;\n\nlet prefix t n = wrap_sub_n ~name:\"prefix\" t n ~pos:0 ~len:n ~on_error:t\nlet suffix t n = wrap_sub_n ~name:\"suffix\" t n ~pos:(length t - n) ~len:n ~on_error:t\n\nlet lfindi ?(pos = 0) t ~f =\n let n = length t in\n let rec loop i = if i = n then None else if f i t.[i] then Some i else loop (i + 1) in\n loop pos\n;;\n\nlet find t ~f =\n match lfindi t ~f:(fun _ c -> f c) with\n | None -> None\n | Some i -> Some t.[i]\n;;\n\nlet find_map t ~f =\n let n = length t in\n let rec loop i =\n if i = n\n then None\n else (\n match f t.[i] with\n | None -> loop (i + 1)\n | Some _ as res -> res)\n in\n loop 0\n;;\n\nlet rfindi ?pos t ~f =\n let rec loop i = if i < 0 then None else if f i t.[i] then Some i else loop (i - 1) in\n let pos =\n match pos with\n | Some pos -> pos\n | None -> length t - 1\n in\n loop pos\n;;\n\nlet last_non_drop ~drop t = rfindi t ~f:(fun _ c -> not (drop c))\n\nlet rstrip ?(drop = Char.is_whitespace) t =\n match last_non_drop t ~drop with\n | None -> \"\"\n | Some i -> if i = length t - 1 then t else prefix t (i + 1)\n;;\n\nlet first_non_drop ~drop t = lfindi t ~f:(fun _ c -> not (drop c))\n\nlet lstrip ?(drop = Char.is_whitespace) t =\n match first_non_drop t ~drop with\n | None -> \"\"\n | Some 0 -> t\n | Some n -> drop_prefix t n\n;;\n\n(* [strip t] could be implemented as [lstrip (rstrip t)]. The implementation\n below saves (at least) a factor of two allocation, by only allocating the\n final result. This also saves some amount of time. *)\nlet strip ?(drop = Char.is_whitespace) t =\n let length = length t in\n if length = 0 || not (drop t.[0] || drop t.[length - 1])\n then t\n else (\n match first_non_drop t ~drop with\n | None -> \"\"\n | Some first ->\n (match last_non_drop t ~drop with\n | None -> assert false\n | Some last -> sub t ~pos:first ~len:(last - first + 1)))\n;;\n\nlet mapi t ~f =\n let l = length t in\n let t' = Bytes.create l in\n for i = 0 to l - 1 do\n Bytes.unsafe_set t' i (f i t.[i])\n done;\n Bytes.unsafe_to_string ~no_mutation_while_string_reachable:t'\n;;\n\n(* repeated code to avoid requiring an extra allocation for a closure on each call. *)\nlet map t ~f =\n let l = length t in\n let t' = Bytes.create l in\n for i = 0 to l - 1 do\n Bytes.unsafe_set t' i (f t.[i])\n done;\n Bytes.unsafe_to_string ~no_mutation_while_string_reachable:t'\n;;\n\nlet to_array s = Array.init (length s) ~f:(fun i -> s.[i])\n\nlet exists =\n let rec loop s i ~len ~f = i < len && (f s.[i] || loop s (i + 1) ~len ~f) in\n fun s ~f -> loop s 0 ~len:(length s) ~f\n;;\n\nlet for_all =\n let rec loop s i ~len ~f = i = len || (f s.[i] && loop s (i + 1) ~len ~f) in\n fun s ~f -> loop s 0 ~len:(length s) ~f\n;;\n\nlet fold t ~init ~f =\n let n = length t in\n let rec loop i ac = if i = n then ac else loop (i + 1) (f ac t.[i]) in\n loop 0 init\n;;\n\nlet foldi t ~init ~f =\n let n = length t in\n let rec loop i ac = if i = n then ac else loop (i + 1) (f i ac t.[i]) in\n loop 0 init\n;;\n\nlet count t ~f = Container.count ~fold t ~f\nlet sum m t ~f = Container.sum ~fold m t ~f\nlet min_elt t = Container.min_elt ~fold t\nlet max_elt t = Container.max_elt ~fold t\nlet fold_result t ~init ~f = Container.fold_result ~fold ~init ~f t\nlet fold_until t ~init ~f = Container.fold_until ~fold ~init ~f t\n\nlet mem =\n let rec loop t c ~pos:i ~len =\n i < len && (Char.equal c (unsafe_get t i) || loop t c ~pos:(i + 1) ~len)\n in\n fun t c -> loop t c ~pos:0 ~len:(length t)\n;;\n\nlet tr ~target ~replacement s =\n if Char.equal target replacement\n then s\n else if mem s target\n then map s ~f:(fun c -> if Char.equal c target then replacement else c)\n else s\n;;\n\nlet tr_multi ~target ~replacement =\n if is_empty target\n then stage Fn.id\n else if is_empty replacement\n then invalid_arg \"tr_multi replacement is empty string\"\n else (\n match Bytes_tr.tr_create_map ~target ~replacement with\n | None -> stage Fn.id\n | Some tr_map ->\n stage (fun s ->\n if exists s ~f:(fun c -> Char.( <> ) c (unsafe_get tr_map (Char.to_int c)))\n then map s ~f:(fun c -> unsafe_get tr_map (Char.to_int c))\n else s))\n;;\n\n(* fast version, if we ever need it:\n {[\n let concat_array ~sep ar =\n let ar_len = Array.length ar in\n if ar_len = 0 then \"\"\n else\n let sep_len = length sep in\n let res_len_ref = ref (sep_len * (ar_len - 1)) in\n for i = 0 to ar_len - 1 do\n res_len_ref := !res_len_ref + length ar.(i)\n done;\n let res = create !res_len_ref in\n let str_0 = ar.(0) in\n let len_0 = length str_0 in\n blit ~src:str_0 ~src_pos:0 ~dst:res ~dst_pos:0 ~len:len_0;\n let pos_ref = ref len_0 in\n for i = 1 to ar_len - 1 do\n let pos = !pos_ref in\n blit ~src:sep ~src_pos:0 ~dst:res ~dst_pos:pos ~len:sep_len;\n let new_pos = pos + sep_len in\n let str_i = ar.(i) in\n let len_i = length str_i in\n blit ~src:str_i ~src_pos:0 ~dst:res ~dst_pos:new_pos ~len:len_i;\n pos_ref := new_pos + len_i\n done;\n res\n ]} *)\n\nlet concat_array ?sep ar = concat ?sep (Array.to_list ar)\nlet concat_map ?sep s ~f = concat_array ?sep (Array.map (to_array s) ~f)\n\n(* [filter t f] is implemented by the following algorithm.\n\n Let [n = length t].\n\n 1. Find the lowest [i] such that [not (f t.[i])].\n\n 2. If there is no such [i], then return [t].\n\n 3. If there is such an [i], allocate a string, [out], to hold the result. [out] has\n length [n - 1], which is the maximum possible output size given that there is at least\n one character not satisfying [f].\n\n 4. Copy characters at indices 0 ... [i - 1] from [t] to [out].\n\n 5. Walk through characters at indices [i+1] ... [n-1] of [t], copying those that\n satisfy [f] from [t] to [out].\n\n 6. If we completely filled [out], then return it. If not, return the prefix of [out]\n that we did fill in.\n\n This algorithm has the property that it doesn't allocate a new string if there's\n nothing to filter, which is a common case. *)\nlet filter t ~f =\n let n = length t in\n let i = ref 0 in\n while !i < n && f t.[!i] do\n incr i\n done;\n if !i = n\n then t\n else (\n let out = Bytes.create (n - 1) in\n Bytes.blit_string ~src:t ~src_pos:0 ~dst:out ~dst_pos:0 ~len:!i;\n let out_pos = ref !i in\n incr i;\n while !i < n do\n let c = t.[!i] in\n if f c\n then (\n Bytes.set out !out_pos c;\n incr out_pos);\n incr i\n done;\n let out = Bytes.unsafe_to_string ~no_mutation_while_string_reachable:out in\n if !out_pos = n - 1 then out else sub out ~pos:0 ~len:!out_pos)\n;;\n\nlet chop_prefix s ~prefix =\n if is_prefix s ~prefix then Some (drop_prefix s (length prefix)) else None\n;;\n\nlet chop_prefix_if_exists s ~prefix =\n if is_prefix s ~prefix then drop_prefix s (length prefix) else s\n;;\n\nlet chop_prefix_exn s ~prefix =\n match chop_prefix s ~prefix with\n | Some str -> str\n | None -> invalid_argf \"String.chop_prefix_exn %S %S\" s prefix ()\n;;\n\nlet chop_suffix s ~suffix =\n if is_suffix s ~suffix then Some (drop_suffix s (length suffix)) else None\n;;\n\nlet chop_suffix_if_exists s ~suffix =\n if is_suffix s ~suffix then drop_suffix s (length suffix) else s\n;;\n\nlet chop_suffix_exn s ~suffix =\n match chop_suffix s ~suffix with\n | Some str -> str\n | None -> invalid_argf \"String.chop_suffix_exn %S %S\" s suffix ()\n;;\n\n(* There used to be a custom implementation that was faster for very short strings\n (peaking at 40% faster for 4-6 char long strings).\n This new function is around 20% faster than the default hash function, but slower\n than the previous custom implementation. However, the new OCaml function is well\n behaved, and this implementation is less likely to diverge from the default OCaml\n implementation does, which is a desirable property. (The only way to avoid the\n divergence is to expose the macro redefined in hash_stubs.c in the hash.h header of\n the OCaml compiler.) *)\nmodule Hash = struct\n external hash : string -> int = \"Base_hash_string\" [@@noalloc]\nend\n\n(* [include Hash] to make the [external] version override the [hash] from\n [Hashable.Make_binable], so that we get a little bit of a speedup by exposing it as\n external in the mli. *)\nlet _ = hash\n\ninclude Hash\ninclude Comparable.Validate (T)\n\n(* for interactive top-levels -- modules deriving from String should have String's pretty\n printer. *)\nlet pp = Caml.Format.pp_print_string\nlet of_char c = make 1 c\n\nlet of_char_list l =\n let t = Bytes.create (List.length l) in\n List.iteri l ~f:(fun i c -> Bytes.set t i c);\n Bytes.unsafe_to_string ~no_mutation_while_string_reachable:t\n;;\n\nmodule Escaping = struct\n (* If this is changed, make sure to update [escape], which attempts to ensure all the\n invariants checked here. *)\n let build_and_validate_escapeworthy_map escapeworthy_map escape_char func =\n let escapeworthy_map =\n if List.Assoc.mem escapeworthy_map ~equal:Char.equal escape_char\n then escapeworthy_map\n else (escape_char, escape_char) :: escapeworthy_map\n in\n let arr = Array.create ~len:256 (-1) in\n let vals = Array.create ~len:256 false in\n let rec loop = function\n | [] -> Ok arr\n | (c_from, c_to) :: l ->\n let k, v =\n match func with\n | `Escape -> Char.to_int c_from, c_to\n | `Unescape -> Char.to_int c_to, c_from\n in\n if arr.(k) <> -1 || vals.(Char.to_int v)\n then\n Or_error.error_s\n (Sexp.message\n \"escapeworthy_map not one-to-one\"\n [ \"c_from\", sexp_of_char c_from\n ; \"c_to\", sexp_of_char c_to\n ; ( \"escapeworthy_map\"\n , sexp_of_list (sexp_of_pair sexp_of_char sexp_of_char) escapeworthy_map\n )\n ])\n else (\n arr.(k) <- Char.to_int v;\n vals.(Char.to_int v) <- true;\n loop l)\n in\n loop escapeworthy_map\n ;;\n\n let escape_gen ~escapeworthy_map ~escape_char =\n match build_and_validate_escapeworthy_map escapeworthy_map escape_char `Escape with\n | Error _ as x -> x\n | Ok escapeworthy ->\n Ok\n (fun src ->\n (* calculate a list of (index of char to escape * escaped char) first, the order\n is from tail to head *)\n let to_escape_len = ref 0 in\n let to_escape =\n foldi src ~init:[] ~f:(fun i acc c ->\n match escapeworthy.(Char.to_int c) with\n | -1 -> acc\n | n ->\n (* (index of char to escape * escaped char) *)\n incr to_escape_len;\n (i, Char.unsafe_of_int n) :: acc)\n in\n match to_escape with\n | [] -> src\n | _ ->\n (* [to_escape] divide [src] to [List.length to_escape + 1] pieces separated by\n the chars to escape.\n\n Lets take\n {[\n escape_gen_exn\n ~escapeworthy_map:[('a', 'A'); ('b', 'B'); ('c', 'C')]\n ~escape_char:'_'\n ]}\n for example, and assume the string to escape is\n\n \"000a111b222c333\"\n\n then [to_escape] is [(11, 'C'); (7, 'B'); (3, 'A')].\n\n Then we create a [dst] of length [length src + 3] to store the\n result, copy piece \"333\" to [dst] directly, then copy '_' and 'C' to [dst];\n then move on to next; after 3 iterations, copy piece \"000\" and we are done.\n\n Finally the result will be\n\n \"000_A111_B222_C333\" *)\n let src_len = length src in\n let dst_len = src_len + !to_escape_len in\n let dst = Bytes.create dst_len in\n let rec loop last_idx last_dst_pos = function\n | [] ->\n (* copy \"000\" at last *)\n Bytes.blit_string ~src ~src_pos:0 ~dst ~dst_pos:0 ~len:last_idx\n | (idx, escaped_char) :: to_escape ->\n (*[idx] = the char to escape*)\n (* take first iteration for example *)\n (* calculate length of \"333\", minus 1 because we don't copy 'c' *)\n let len = last_idx - idx - 1 in\n (* set the dst_pos to copy to *)\n let dst_pos = last_dst_pos - len in\n (* copy \"333\", set [src_pos] to [idx + 1] to skip 'c' *)\n Bytes.blit_string ~src ~src_pos:(idx + 1) ~dst ~dst_pos ~len;\n (* backoff [dst_pos] by 2 to copy '_' and 'C' *)\n let dst_pos = dst_pos - 2 in\n Bytes.set dst dst_pos escape_char;\n Bytes.set dst (dst_pos + 1) escaped_char;\n loop idx dst_pos to_escape\n in\n (* set [last_dst_pos] and [last_idx] to length of [dst] and [src] first *)\n loop src_len dst_len to_escape;\n Bytes.unsafe_to_string ~no_mutation_while_string_reachable:dst)\n ;;\n\n let escape_gen_exn ~escapeworthy_map ~escape_char =\n Or_error.ok_exn (escape_gen ~escapeworthy_map ~escape_char) |> stage\n ;;\n\n let escape ~escapeworthy ~escape_char =\n (* For [escape_gen_exn], we don't know how to fix invalid escapeworthy_map so we have\n to raise exception; but in this case, we know how to fix duplicated elements in\n escapeworthy list, so we just fix it instead of raising exception to make this\n function easier to use. *)\n let escapeworthy_map =\n escapeworthy\n |> List.dedup_and_sort ~compare:Char.compare\n |> List.map ~f:(fun c -> c, c)\n in\n escape_gen_exn ~escapeworthy_map ~escape_char\n ;;\n\n (* In an escaped string, any char is either `Escaping, `Escaped or `Literal. For\n example, the escape statuses of chars in string \"a_a__\" with escape_char = '_' are\n\n a : `Literal\n _ : `Escaping\n a : `Escaped\n _ : `Escaping\n _ : `Escaped\n\n [update_escape_status str ~escape_char i previous_status] gets escape status of\n str.[i] basing on escape status of str.[i - 1] *)\n let update_escape_status str ~escape_char i = function\n | `Escaping -> `Escaped\n | `Literal | `Escaped ->\n if Char.equal str.[i] escape_char then `Escaping else `Literal\n ;;\n\n let unescape_gen ~escapeworthy_map ~escape_char =\n match build_and_validate_escapeworthy_map escapeworthy_map escape_char `Unescape with\n | Error _ as x -> x\n | Ok escapeworthy ->\n Ok\n (fun src ->\n (* Continue the example in [escape_gen_exn], now we unescape\n\n \"000_A111_B222_C333\"\n\n back to\n\n \"000a111b222c333\"\n\n Then [to_unescape] is [14; 9; 4], which is indexes of '_'s.\n\n Then we create a string [dst] to store the result, copy \"333\" to it, then copy\n 'c', then move on to next iteration. After 3 iterations copy \"000\" and we are\n done. *)\n (* indexes of escape chars *)\n let to_unescape =\n let rec loop i status acc =\n if i >= length src\n then acc\n else (\n let status = update_escape_status src ~escape_char i status in\n loop\n (i + 1)\n status\n (match status with\n | `Escaping -> i :: acc\n | `Escaped | `Literal -> acc))\n in\n loop 0 `Literal []\n in\n match to_unescape with\n | [] -> src\n | idx :: to_unescape' ->\n let dst = Bytes.create (length src - List.length to_unescape) in\n let rec loop last_idx last_dst_pos = function\n | [] ->\n (* copy \"000\" at last *)\n Bytes.blit_string ~src ~src_pos:0 ~dst ~dst_pos:0 ~len:last_idx\n | idx :: to_unescape ->\n (* [idx] = index of escaping char *)\n (* take 1st iteration as example, calculate the length of \"333\", minus 2 to\n skip '_C' *)\n let len = last_idx - idx - 2 in\n (* point [dst_pos] to the position to copy \"333\" to *)\n let dst_pos = last_dst_pos - len in\n (* copy \"333\" *)\n Bytes.blit_string ~src ~src_pos:(idx + 2) ~dst ~dst_pos ~len;\n (* backoff [dst_pos] by 1 to copy 'c' *)\n let dst_pos = dst_pos - 1 in\n Bytes.set\n dst\n dst_pos\n (match escapeworthy.(Char.to_int src.[idx + 1]) with\n | -1 -> src.[idx + 1]\n | n -> Char.unsafe_of_int n);\n (* update [last_dst_pos] and [last_idx] *)\n loop idx dst_pos to_unescape\n in\n if idx < length src - 1\n then\n (* set [last_dst_pos] and [last_idx] to length of [dst] and [src] *)\n loop (length src) (Bytes.length dst) to_unescape\n else\n (* for escaped string ending with an escaping char like \"000_\", just ignore\n the last escaping char *)\n loop (length src - 1) (Bytes.length dst) to_unescape';\n Bytes.unsafe_to_string ~no_mutation_while_string_reachable:dst)\n ;;\n\n let unescape_gen_exn ~escapeworthy_map ~escape_char =\n Or_error.ok_exn (unescape_gen ~escapeworthy_map ~escape_char) |> stage\n ;;\n\n let unescape ~escape_char = unescape_gen_exn ~escapeworthy_map:[] ~escape_char\n\n let preceding_escape_chars str ~escape_char pos =\n let rec loop p cnt =\n if p < 0 || Char.( <> ) str.[p] escape_char then cnt else loop (p - 1) (cnt + 1)\n in\n loop (pos - 1) 0\n ;;\n\n (* In an escaped string, any char is either `Escaping, `Escaped or `Literal. For\n example, the escape statuses of chars in string \"a_a__\" with escape_char = '_' are\n\n a : `Literal\n _ : `Escaping\n a : `Escaped\n _ : `Escaping\n _ : `Escaped\n\n [update_escape_status str ~escape_char i previous_status] gets escape status of\n str.[i] basing on escape status of str.[i - 1] *)\n let update_escape_status str ~escape_char i = function\n | `Escaping -> `Escaped\n | `Literal | `Escaped ->\n if Char.equal str.[i] escape_char then `Escaping else `Literal\n ;;\n\n let escape_status str ~escape_char pos =\n let odd = preceding_escape_chars str ~escape_char pos mod 2 = 1 in\n match odd, Char.equal str.[pos] escape_char with\n | true, (true | false) -> `Escaped\n | false, true -> `Escaping\n | false, false -> `Literal\n ;;\n\n let check_bound str pos function_name =\n if pos >= length str || pos < 0\n then invalid_argf \"%s: out of bounds\" function_name ()\n ;;\n\n let is_char_escaping str ~escape_char pos =\n check_bound str pos \"is_char_escaping\";\n match escape_status str ~escape_char pos with\n | `Escaping -> true\n | `Escaped | `Literal -> false\n ;;\n\n let is_char_escaped str ~escape_char pos =\n check_bound str pos \"is_char_escaped\";\n match escape_status str ~escape_char pos with\n | `Escaped -> true\n | `Escaping | `Literal -> false\n ;;\n\n let is_char_literal str ~escape_char pos =\n check_bound str pos \"is_char_literal\";\n match escape_status str ~escape_char pos with\n | `Literal -> true\n | `Escaped | `Escaping -> false\n ;;\n\n let index_from str ~escape_char pos char =\n check_bound str pos \"index_from\";\n let rec loop i status =\n if i >= pos\n && (match status with\n | `Literal -> true\n | `Escaped | `Escaping -> false)\n && Char.equal str.[i] char\n then Some i\n else (\n let i = i + 1 in\n if i >= length str\n then None\n else loop i (update_escape_status str ~escape_char i status))\n in\n loop pos (escape_status str ~escape_char pos)\n ;;\n\n let index_from_exn str ~escape_char pos char =\n match index_from str ~escape_char pos char with\n | None ->\n raise_s\n (Sexp.message\n \"index_from_exn: not found\"\n [ \"str\", sexp_of_t str\n ; \"escape_char\", sexp_of_char escape_char\n ; \"pos\", sexp_of_int pos\n ; \"char\", sexp_of_char char\n ])\n | Some pos -> pos\n ;;\n\n let index str ~escape_char char = index_from str ~escape_char 0 char\n let index_exn str ~escape_char char = index_from_exn str ~escape_char 0 char\n\n let rindex_from str ~escape_char pos char =\n check_bound str pos \"rindex_from\";\n (* if the target char is the same as [escape_char], we have no way to determine which\n escape_char is literal, so just return None *)\n if Char.equal char escape_char\n then None\n else (\n let rec loop pos =\n if pos < 0\n then None\n else (\n let escape_chars = preceding_escape_chars str ~escape_char pos in\n if escape_chars mod 2 = 0 && Char.equal str.[pos] char\n then Some pos\n else loop (pos - escape_chars - 1))\n in\n loop pos)\n ;;\n\n let rindex_from_exn str ~escape_char pos char =\n match rindex_from str ~escape_char pos char with\n | None ->\n raise_s\n (Sexp.message\n \"rindex_from_exn: not found\"\n [ \"str\", sexp_of_t str\n ; \"escape_char\", sexp_of_char escape_char\n ; \"pos\", sexp_of_int pos\n ; \"char\", sexp_of_char char\n ])\n | Some pos -> pos\n ;;\n\n let rindex str ~escape_char char =\n if is_empty str then None else rindex_from str ~escape_char (length str - 1) char\n ;;\n\n let rindex_exn str ~escape_char char =\n rindex_from_exn str ~escape_char (length str - 1) char\n ;;\n\n (* [split_gen str ~escape_char ~on] works similarly to [String.split_gen], with an\n additional requirement: only split on literal chars, not escaping or escaped *)\n let split_gen str ~escape_char ~on =\n let is_delim =\n match on with\n | `char c' -> fun c -> Char.equal c c'\n | `char_list l -> fun c -> char_list_mem l c\n in\n let len = length str in\n let rec loop acc status last_pos pos =\n if pos = len\n then List.rev (sub str ~pos:last_pos ~len:(len - last_pos) :: acc)\n else (\n let status = update_escape_status str ~escape_char pos status in\n if (match status with\n | `Literal -> true\n | `Escaped | `Escaping -> false)\n && is_delim str.[pos]\n then (\n let sub_str = sub str ~pos:last_pos ~len:(pos - last_pos) in\n loop (sub_str :: acc) status (pos + 1) (pos + 1))\n else loop acc status last_pos (pos + 1))\n in\n loop [] `Literal 0 0\n ;;\n\n let split str ~on = split_gen str ~on:(`char on)\n let split_on_chars str ~on:chars = split_gen str ~on:(`char_list chars)\n\n let split_at str pos =\n sub str ~pos:0 ~len:pos, sub str ~pos:(pos + 1) ~len:(length str - pos - 1)\n ;;\n\n let lsplit2 str ~on ~escape_char =\n Option.map (index str ~escape_char on) ~f:(fun x -> split_at str x)\n ;;\n\n let rsplit2 str ~on ~escape_char =\n Option.map (rindex str ~escape_char on) ~f:(fun x -> split_at str x)\n ;;\n\n let lsplit2_exn str ~on ~escape_char = split_at str (index_exn str ~escape_char on)\n let rsplit2_exn str ~on ~escape_char = split_at str (rindex_exn str ~escape_char on)\n\n (* [last_non_drop_literal] and [first_non_drop_literal] are either both [None] or both\n [Some]. If [Some], then the former is >= the latter. *)\n let last_non_drop_literal ~drop ~escape_char t =\n rfindi t ~f:(fun i c ->\n (not (drop c))\n || is_char_escaping t ~escape_char i\n || is_char_escaped t ~escape_char i)\n ;;\n\n let first_non_drop_literal ~drop ~escape_char t =\n lfindi t ~f:(fun i c ->\n (not (drop c))\n || is_char_escaping t ~escape_char i\n || is_char_escaped t ~escape_char i)\n ;;\n\n let rstrip_literal ?(drop = Char.is_whitespace) t ~escape_char =\n match last_non_drop_literal t ~drop ~escape_char with\n | None -> \"\"\n | Some i -> if i = length t - 1 then t else prefix t (i + 1)\n ;;\n\n let lstrip_literal ?(drop = Char.is_whitespace) t ~escape_char =\n match first_non_drop_literal t ~drop ~escape_char with\n | None -> \"\"\n | Some 0 -> t\n | Some n -> drop_prefix t n\n ;;\n\n (* [strip t] could be implemented as [lstrip (rstrip t)]. The implementation\n below saves (at least) a factor of two allocation, by only allocating the\n final result. This also saves some amount of time. *)\n let strip_literal ?(drop = Char.is_whitespace) t ~escape_char =\n let length = length t in\n (* performance hack: avoid copying [t] in common cases *)\n if length = 0 || not (drop t.[0] || drop t.[length - 1])\n then t\n else (\n match first_non_drop_literal t ~drop ~escape_char with\n | None -> \"\"\n | Some first ->\n (match last_non_drop_literal t ~drop ~escape_char with\n | None -> assert false\n | Some last -> sub t ~pos:first ~len:(last - first + 1)))\n ;;\nend\n\n(* Open replace_polymorphic_compare after including functor instantiations so they do not\n shadow its definitions. This is here so that efficient versions of the comparison\n functions are available within this module. *)\nopen! String_replace_polymorphic_compare\n\nlet between t ~low ~high = low <= t && t <= high\nlet clamp_unchecked t ~min ~max = if t < min then min else if t <= max then t else max\n\nlet clamp_exn t ~min ~max =\n assert (min <= max);\n clamp_unchecked t ~min ~max\n;;\n\nlet clamp t ~min ~max =\n if min > max\n then\n Or_error.error_s\n (Sexp.message\n \"clamp requires [min <= max]\"\n [ \"min\", T.sexp_of_t min; \"max\", T.sexp_of_t max ])\n else Ok (clamp_unchecked t ~min ~max)\n;;\n\n(* Override [Search_pattern] with default case-sensitivity argument at the end of the\n file, so that call sites above are forced to supply case-sensitivity explicitly. *)\nmodule Search_pattern = struct\n include Search_pattern0\n\n let create ?(case_sensitive = true) pattern = create pattern ~case_sensitive\nend\n\n(* Include type-specific [Replace_polymorphic_compare] at the end, after\n including functor application that could shadow its definitions. This is\n here so that efficient versions of the comparison functions are exported by\n this module. *)\ninclude String_replace_polymorphic_compare\n","open! Import\nmodule Array = Array0\n\nlet stage = Staged.stage\n\nmodule T = struct\n type t = bytes [@@deriving_inline sexp, sexp_grammar]\n\n let t_of_sexp = (bytes_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t)\n let sexp_of_t = (sexp_of_bytes : t -> Ppx_sexp_conv_lib.Sexp.t)\n\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group) =\n { implicit_vars = [ \"bytes\" ]\n ; ggid = \"\\146e\\023\\249\\235eE\\139c\\132W\\195\\137\\129\\235\\025\"\n ; types = [ \"t\", Implicit_var 0 ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ bytes_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"bytes.ml.T\"\n }\n in\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"t\", _the_group)\n in\n t_sexp_grammar\n ;;\n\n [@@@end]\n\n include Bytes0\n\n let module_name = \"Base.Bytes\"\n let pp fmt t = Caml.Format.fprintf fmt \"%S\" (to_string t)\nend\n\ninclude T\n\nmodule To_bytes = Blit.Make (struct\n include T\n\n let create ~len = create len\n end)\n\ninclude To_bytes\ninclude Comparator.Make (T)\ninclude Comparable.Validate (T)\ninclude Pretty_printer.Register_pp (T)\n\n(* Open replace_polymorphic_compare after including functor instantiations so they do not\n shadow its definitions. This is here so that efficient versions of the comparison\n functions are available within this module. *)\nopen! Bytes_replace_polymorphic_compare\nmodule To_string = Blit.Make_to_string (T) (To_bytes)\n\nmodule From_string =\n Blit.Make_distinct\n (struct\n type t = string\n\n let length = String.length\n end)\n (struct\n type nonrec t = t\n\n let create ~len = create len\n let length = length\n let unsafe_blit = unsafe_blit_string\n end)\n\nlet invariant (_ : t) = ()\n\nlet init n ~f =\n if Int_replace_polymorphic_compare.( < ) n 0\n then Printf.invalid_argf \"Bytes.init %d\" n ();\n let t = create n in\n for i = 0 to n - 1 do\n unsafe_set t i (f i)\n done;\n t\n;;\n\nlet of_char_list l =\n let t = create (List.length l) in\n List.iteri l ~f:(fun i c -> set t i c);\n t\n;;\n\nlet to_list t =\n let rec loop t i acc =\n if Int_replace_polymorphic_compare.( < ) i 0\n then acc\n else loop t (i - 1) (unsafe_get t i :: acc)\n in\n loop t (length t - 1) []\n;;\n\nlet to_array t = Array.init (length t) ~f:(fun i -> unsafe_get t i)\nlet map t ~f = map t ~f\nlet mapi t ~f = mapi t ~f\n\nlet fold =\n let rec loop t ~f ~len ~pos acc =\n if Int_replace_polymorphic_compare.equal pos len\n then acc\n else loop t ~f ~len ~pos:(pos + 1) (f acc (unsafe_get t pos))\n in\n fun t ~init ~f -> loop t ~f ~len:(length t) ~pos:0 init\n;;\n\nlet foldi =\n let rec loop t ~f ~len ~pos acc =\n if Int_replace_polymorphic_compare.equal pos len\n then acc\n else loop t ~f ~len ~pos:(pos + 1) (f pos acc (unsafe_get t pos))\n in\n fun t ~init ~f -> loop t ~f ~len:(length t) ~pos:0 init\n;;\n\nlet tr ~target ~replacement s =\n for i = 0 to length s - 1 do\n if Char.equal (unsafe_get s i) target then unsafe_set s i replacement\n done\n;;\n\nlet tr_multi ~target ~replacement =\n if Int_replace_polymorphic_compare.( = ) (String.length target) 0\n then stage ignore\n else if Int_replace_polymorphic_compare.( = ) (String.length replacement) 0\n then invalid_arg \"tr_multi: replacement is the empty string\"\n else (\n match Bytes_tr.tr_create_map ~target ~replacement with\n | None -> stage ignore\n | Some tr_map ->\n stage (fun s ->\n for i = 0 to length s - 1 do\n unsafe_set s i (String.unsafe_get tr_map (Char.to_int (unsafe_get s i)))\n done))\n;;\n\nlet between t ~low ~high = low <= t && t <= high\nlet clamp_unchecked t ~min ~max = if t < min then min else if t <= max then t else max\n\nlet clamp_exn t ~min ~max =\n assert (min <= max);\n clamp_unchecked t ~min ~max\n;;\n\nlet clamp t ~min ~max =\n if min > max\n then\n Or_error.error_s\n (Sexp.message\n \"clamp requires [min <= max]\"\n [ \"min\", T.sexp_of_t min; \"max\", T.sexp_of_t max ])\n else Ok (clamp_unchecked t ~min ~max)\n;;\n\nlet contains ?pos ?len t char =\n let pos, len =\n Ordered_collection_common.get_pos_len_exn () ?pos ?len ~total_length:(length t)\n in\n let last = pos + len in\n let rec loop i =\n Int_replace_polymorphic_compare.( < ) i last\n && (Char.equal (get t i) char || loop (i + 1))\n in\n loop pos\n;;\n\n(* Include type-specific [Replace_polymorphic_compare] at the end, after\n including functor application that could shadow its definitions. This is\n here so that efficient versions of the comparison functions are exported by\n this module. *)\ninclude Bytes_replace_polymorphic_compare\n","(* This file was autogenerated by ../generate/generate_pow_overflow_bounds.exe *)\n\nopen! Import\n\nmodule Array = Array0\n\n(* We have to use Int64.to_int_exn instead of int constants to make\n sure that file can be preprocessed on 32-bit machines. *)\n\nlet overflow_bound_max_int32_value : int32 =\n 2147483647l\n\nlet int32_positive_overflow_bounds : int32 array =\n [| 2147483647l\n ; 2147483647l\n ; 46340l\n ; 1290l\n ; 215l\n ; 73l\n ; 35l\n ; 21l\n ; 14l\n ; 10l\n ; 8l\n ; 7l\n ; 5l\n ; 5l\n ; 4l\n ; 4l\n ; 3l\n ; 3l\n ; 3l\n ; 3l\n ; 2l\n ; 2l\n ; 2l\n ; 2l\n ; 2l\n ; 2l\n ; 2l\n ; 2l\n ; 2l\n ; 2l\n ; 2l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n ; 1l\n |]\n\nlet overflow_bound_max_int_value : int =\n (-1) lsr 1\n\nlet int_positive_overflow_bounds : int array =\n match Int_conversions.num_bits_int with\n | 32 -> Array.map int32_positive_overflow_bounds ~f:Caml.Int32.to_int\n | 63 ->\n [| Caml.Int64.to_int 4611686018427387903L\n ; Caml.Int64.to_int 4611686018427387903L\n ; Caml.Int64.to_int 2147483647L\n ; 1664510\n ; 46340\n ; 5404\n ; 1290\n ; 463\n ; 215\n ; 118\n ; 73\n ; 49\n ; 35\n ; 27\n ; 21\n ; 17\n ; 14\n ; 12\n ; 10\n ; 9\n ; 8\n ; 7\n ; 7\n ; 6\n ; 5\n ; 5\n ; 5\n ; 4\n ; 4\n ; 4\n ; 4\n ; 3\n ; 3\n ; 3\n ; 3\n ; 3\n ; 3\n ; 3\n ; 3\n ; 3\n ; 2\n ; 2\n ; 2\n ; 2\n ; 2\n ; 2\n ; 2\n ; 2\n ; 2\n ; 2\n ; 2\n ; 2\n ; 2\n ; 2\n ; 2\n ; 2\n ; 2\n ; 2\n ; 2\n ; 2\n ; 2\n ; 2\n ; 1\n ; 1\n |]\n | 31 ->\n [| 1073741823\n ; 1073741823\n ; 32767\n ; 1023\n ; 181\n ; 63\n ; 31\n ; 19\n ; 13\n ; 10\n ; 7\n ; 6\n ; 5\n ; 4\n ; 4\n ; 3\n ; 3\n ; 3\n ; 3\n ; 2\n ; 2\n ; 2\n ; 2\n ; 2\n ; 2\n ; 2\n ; 2\n ; 2\n ; 2\n ; 2\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n ; 1\n |]\n | _ -> assert false\n\nlet overflow_bound_max_int63_on_int64_value : int64 =\n 4611686018427387903L\n\nlet int63_on_int64_positive_overflow_bounds : int64 array =\n [| 4611686018427387903L\n ; 4611686018427387903L\n ; 2147483647L\n ; 1664510L\n ; 46340L\n ; 5404L\n ; 1290L\n ; 463L\n ; 215L\n ; 118L\n ; 73L\n ; 49L\n ; 35L\n ; 27L\n ; 21L\n ; 17L\n ; 14L\n ; 12L\n ; 10L\n ; 9L\n ; 8L\n ; 7L\n ; 7L\n ; 6L\n ; 5L\n ; 5L\n ; 5L\n ; 4L\n ; 4L\n ; 4L\n ; 4L\n ; 3L\n ; 3L\n ; 3L\n ; 3L\n ; 3L\n ; 3L\n ; 3L\n ; 3L\n ; 3L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 1L\n ; 1L\n |]\n\nlet overflow_bound_max_int64_value : int64 =\n 9223372036854775807L\n\nlet int64_positive_overflow_bounds : int64 array =\n [| 9223372036854775807L\n ; 9223372036854775807L\n ; 3037000499L\n ; 2097151L\n ; 55108L\n ; 6208L\n ; 1448L\n ; 511L\n ; 234L\n ; 127L\n ; 78L\n ; 52L\n ; 38L\n ; 28L\n ; 22L\n ; 18L\n ; 15L\n ; 13L\n ; 11L\n ; 9L\n ; 8L\n ; 7L\n ; 7L\n ; 6L\n ; 6L\n ; 5L\n ; 5L\n ; 5L\n ; 4L\n ; 4L\n ; 4L\n ; 4L\n ; 3L\n ; 3L\n ; 3L\n ; 3L\n ; 3L\n ; 3L\n ; 3L\n ; 3L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 2L\n ; 1L\n |]\n\nlet int64_negative_overflow_bounds : int64 array =\n [| -9223372036854775807L\n ; -9223372036854775807L\n ; -3037000499L\n ; -2097151L\n ; -55108L\n ; -6208L\n ; -1448L\n ; -511L\n ; -234L\n ; -127L\n ; -78L\n ; -52L\n ; -38L\n ; -28L\n ; -22L\n ; -18L\n ; -15L\n ; -13L\n ; -11L\n ; -9L\n ; -8L\n ; -7L\n ; -7L\n ; -6L\n ; -6L\n ; -5L\n ; -5L\n ; -5L\n ; -4L\n ; -4L\n ; -4L\n ; -4L\n ; -3L\n ; -3L\n ; -3L\n ; -3L\n ; -3L\n ; -3L\n ; -3L\n ; -3L\n ; -2L\n ; -2L\n ; -2L\n ; -2L\n ; -2L\n ; -2L\n ; -2L\n ; -2L\n ; -2L\n ; -2L\n ; -2L\n ; -2L\n ; -2L\n ; -2L\n ; -2L\n ; -2L\n ; -2L\n ; -2L\n ; -2L\n ; -2L\n ; -2L\n ; -2L\n ; -2L\n ; -1L\n |]\n","open! Import\n\nlet invalid_argf = Printf.invalid_argf\nlet negative_exponent () = Printf.invalid_argf \"exponent can not be negative\" ()\nlet overflow () = Printf.invalid_argf \"integer overflow in pow\" ()\n\n(* To implement [int64_pow], we use C code rather than OCaml to eliminate allocation. *)\nexternal int_math_int_pow : int -> int -> int = \"Base_int_math_int_pow_stub\" [@@noalloc]\nexternal int_math_int64_pow : int64 -> int64 -> int64 = \"Base_int_math_int64_pow_stub\"\n\nlet int_pow base exponent =\n if exponent < 0 then negative_exponent ();\n if abs base > 1\n && (exponent > 63\n || abs base > Pow_overflow_bounds.int_positive_overflow_bounds.(exponent))\n then overflow ();\n int_math_int_pow base exponent\n;;\n\nmodule Int64_with_comparisons = struct\n include Caml.Int64\n\n external ( < ) : int64 -> int64 -> bool = \"%lessthan\"\n external ( > ) : int64 -> int64 -> bool = \"%greaterthan\"\n external ( >= ) : int64 -> int64 -> bool = \"%greaterequal\"\nend\n\n(* we don't do [abs] in int64 case to avoid allocation *)\nlet int64_pow base exponent =\n let open Int64_with_comparisons in\n if exponent < 0L then negative_exponent ();\n if (base > 1L || base < -1L)\n && (exponent > 63L\n || (base >= 0L\n && base > Pow_overflow_bounds.int64_positive_overflow_bounds.(to_int exponent)\n )\n || (base < 0L\n && base < Pow_overflow_bounds.int64_negative_overflow_bounds.(to_int exponent)\n ))\n then overflow ();\n int_math_int64_pow base exponent\n;;\n\nlet int63_pow_on_int64 base exponent =\n let open Int64_with_comparisons in\n if exponent < 0L then negative_exponent ();\n if abs base > 1L\n && (exponent > 63L\n || abs base\n > Pow_overflow_bounds.int63_on_int64_positive_overflow_bounds.(to_int exponent)\n )\n then overflow ();\n int_math_int64_pow base exponent\n;;\n\nmodule type Make_arg = sig\n type t\n\n include Floatable.S with type t := t\n include Stringable.S with type t := t\n\n val ( + ) : t -> t -> t\n val ( - ) : t -> t -> t\n val ( * ) : t -> t -> t\n val ( / ) : t -> t -> t\n val ( ~- ) : t -> t\n\n include Comparisons.Infix with type t := t\n\n val abs : t -> t\n val neg : t -> t\n val zero : t\n val of_int_exn : int -> t\n val rem : t -> t -> t\nend\n\nmodule Make (X : Make_arg) = struct\n open X\n\n let ( % ) x y =\n if y <= zero\n then\n invalid_argf\n \"%s %% %s in core_int.ml: modulus should be positive\"\n (to_string x)\n (to_string y)\n ();\n let rval = X.rem x y in\n if rval < zero then rval + y else rval\n ;;\n\n let one = of_int_exn 1\n\n let ( /% ) x y =\n if y <= zero\n then\n invalid_argf\n \"%s /%% %s in core_int.ml: divisor should be positive\"\n (to_string x)\n (to_string y)\n ();\n if x < zero then ((x + one) / y) - one else x / y\n ;;\n\n (** float division of integers *)\n let ( // ) x y = to_float x /. to_float y\n\n let round_down i ~to_multiple_of:modulus = i - (i % modulus)\n\n let round_up i ~to_multiple_of:modulus =\n let remainder = i % modulus in\n if remainder = zero then i else i + modulus - remainder\n ;;\n\n let round_towards_zero i ~to_multiple_of =\n if i = zero\n then zero\n else if i > zero\n then round_down i ~to_multiple_of\n else round_up i ~to_multiple_of\n ;;\n\n let round_nearest i ~to_multiple_of:modulus =\n let remainder = i % modulus in\n let modulus_minus_remainder = modulus - remainder in\n if modulus_minus_remainder <= remainder\n then i + modulus_minus_remainder\n else i - remainder\n ;;\n\n let round ?(dir = `Nearest) i ~to_multiple_of =\n match dir with\n | `Nearest -> round_nearest i ~to_multiple_of\n | `Down -> round_down i ~to_multiple_of\n | `Up -> round_up i ~to_multiple_of\n | `Zero -> round_towards_zero i ~to_multiple_of\n ;;\nend\n\nmodule Private = struct\n let int_pow = int_pow\n let int64_pow = int64_pow\n let int63_pow_on_int64 = int63_pow_on_int64\n\n module Pow_overflow_bounds = Pow_overflow_bounds\nend\n","open! Import\ninclude Int_intf\ninclude Int0\n\nmodule T = struct\n type t = int [@@deriving_inline hash, sexp, sexp_grammar]\n\n let (hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state) =\n hash_fold_int\n\n and (hash : t -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func = hash_int in\n fun x -> func x\n ;;\n\n let t_of_sexp = (int_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t)\n let sexp_of_t = (sexp_of_int : t -> Ppx_sexp_conv_lib.Sexp.t)\n\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group) =\n { implicit_vars = [ \"int\" ]\n ; ggid = \"\\146e\\023\\249\\235eE\\139c\\132W\\195\\137\\129\\235\\025\"\n ; types = [ \"t\", Implicit_var 0 ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ int_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"int.ml.T\"\n }\n in\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"t\", _the_group)\n in\n t_sexp_grammar\n ;;\n\n [@@@end]\n\n let compare x y = Int_replace_polymorphic_compare.compare x y\n\n let of_string s =\n try of_string s with\n | _ -> Printf.failwithf \"Int.of_string: %S\" s ()\n ;;\n\n let to_string = to_string\nend\n\nlet num_bits = Int_conversions.num_bits_int\nlet float_lower_bound = Float0.lower_bound_for_int num_bits\nlet float_upper_bound = Float0.upper_bound_for_int num_bits\nlet to_float = Caml.float_of_int\nlet of_float_unchecked = Caml.int_of_float\n\nlet of_float f =\n if Float_replace_polymorphic_compare.( >= ) f float_lower_bound\n && Float_replace_polymorphic_compare.( <= ) f float_upper_bound\n then Caml.int_of_float f\n else\n Printf.invalid_argf\n \"Int.of_float: argument (%f) is out of range or NaN\"\n (Float0.box f)\n ()\n;;\n\nlet zero = 0\nlet one = 1\nlet minus_one = -1\n\ninclude T\ninclude Comparator.Make (T)\n\ninclude Comparable.Validate_with_zero (struct\n include T\n\n let zero = zero\n end)\n\nmodule Conv = Int_conversions\ninclude Conv.Make (T)\n\ninclude Conv.Make_hex (struct\n open Int_replace_polymorphic_compare\n\n type t = int [@@deriving_inline compare, hash]\n\n let compare = (compare_int : t -> t -> int)\n\n let (hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state) =\n hash_fold_int\n\n and (hash : t -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func = hash_int in\n fun x -> func x\n ;;\n\n [@@@end]\n\n let zero = zero\n let neg = ( ~- )\n let ( < ) = ( < )\n let to_string i = Printf.sprintf \"%x\" i\n let of_string s = Caml.Scanf.sscanf s \"%x\" Fn.id\n let module_name = \"Base.Int.Hex\"\n end)\n\ninclude Pretty_printer.Register (struct\n type nonrec t = t\n\n let to_string = to_string\n let module_name = \"Base.Int\"\n end)\n\n(* Open replace_polymorphic_compare after including functor instantiations so\n they do not shadow its definitions. This is here so that efficient versions\n of the comparison functions are available within this module. *)\nopen! Int_replace_polymorphic_compare\n\nlet invariant (_ : t) = ()\nlet between t ~low ~high = low <= t && t <= high\nlet clamp_unchecked t ~min ~max = if t < min then min else if t <= max then t else max\n\nlet clamp_exn t ~min ~max =\n assert (min <= max);\n clamp_unchecked t ~min ~max\n;;\n\nlet clamp t ~min ~max =\n if min > max\n then\n Or_error.error_s\n (Sexp.message\n \"clamp requires [min <= max]\"\n [ \"min\", T.sexp_of_t min; \"max\", T.sexp_of_t max ])\n else Ok (clamp_unchecked t ~min ~max)\n;;\n\nlet pred i = i - 1\nlet succ i = i + 1\nlet to_int i = i\nlet to_int_exn = to_int\nlet of_int i = i\nlet of_int_exn = of_int\nlet max_value = Caml.max_int\nlet min_value = Caml.min_int\nlet max_value_30_bits = 0x3FFF_FFFF\nlet of_int32 = Conv.int32_to_int\nlet of_int32_exn = Conv.int32_to_int_exn\nlet of_int32_trunc = Conv.int32_to_int_trunc\nlet to_int32 = Conv.int_to_int32\nlet to_int32_exn = Conv.int_to_int32_exn\nlet to_int32_trunc = Conv.int_to_int32_trunc\nlet of_int64 = Conv.int64_to_int\nlet of_int64_exn = Conv.int64_to_int_exn\nlet of_int64_trunc = Conv.int64_to_int_trunc\nlet to_int64 = Conv.int_to_int64\nlet of_nativeint = Conv.nativeint_to_int\nlet of_nativeint_exn = Conv.nativeint_to_int_exn\nlet of_nativeint_trunc = Conv.nativeint_to_int_trunc\nlet to_nativeint = Conv.int_to_nativeint\nlet to_nativeint_exn = to_nativeint\nlet abs x = abs x\nlet ( + ) x y = x + y\nlet ( - ) x y = x - y\nlet ( * ) x y = x * y\nlet ( / ) x y = x / y\nlet neg x = -x\nlet ( ~- ) = neg\n\n(* note that rem is not same as % *)\nlet rem a b = a mod b\nlet incr = Caml.incr\nlet decr = Caml.decr\nlet shift_right a b = a asr b\nlet shift_right_logical a b = a lsr b\nlet shift_left a b = a lsl b\nlet bit_not a = lnot a\nlet bit_or a b = a lor b\nlet bit_and a b = a land b\nlet bit_xor a b = a lxor b\nlet pow = Int_math.Private.int_pow\nlet ( ** ) b e = pow b e\n\nmodule Pow2 = struct\n open! Import\n module Sys = Sys0\n\n let raise_s = Error.raise_s\n\n let non_positive_argument () =\n Printf.invalid_argf \"argument must be strictly positive\" ()\n ;;\n\n\n (** \"ceiling power of 2\" - Least power of 2 greater than or equal to x. *)\n let ceil_pow2 x =\n if x <= 0 then non_positive_argument ();\n let x = x - 1 in\n let x = x lor (x lsr 1) in\n let x = x lor (x lsr 2) in\n let x = x lor (x lsr 4) in\n let x = x lor (x lsr 8) in\n let x = x lor (x lsr 16) in\n (* The next line is superfluous on 32-bit architectures, but it's faster to do it\n anyway than to branch *)\n let x = x lor (x lsr 32) in\n x + 1\n ;;\n\n (** \"floor power of 2\" - Largest power of 2 less than or equal to x. *)\n let floor_pow2 x =\n if x <= 0 then non_positive_argument ();\n let x = x lor (x lsr 1) in\n let x = x lor (x lsr 2) in\n let x = x lor (x lsr 4) in\n let x = x lor (x lsr 8) in\n let x = x lor (x lsr 16) in\n (* The next line is superfluous on 32-bit architectures, but it's faster to do it\n anyway than to branch *)\n let x = x lor (x lsr 32) in\n x - (x lsr 1)\n ;;\n\n let is_pow2 x =\n if x <= 0 then non_positive_argument ();\n x land (x - 1) = 0\n ;;\n\n (* C stubs for int clz and ctz to use the CLZ/BSR/CTZ/BSF instruction where possible *)\n external clz\n : (* Note that we pass the tagged int here. See int_math_stubs.c for details on why\n this is correct. *)\n int\n -> (int[@untagged])\n = \"Base_int_math_int_clz\" \"Base_int_math_int_clz_untagged\"\n [@@noalloc]\n\n external ctz\n : (int[@untagged])\n -> (int[@untagged])\n = \"Base_int_math_int_ctz\" \"Base_int_math_int_ctz_untagged\"\n [@@noalloc]\n\n (** Hacker's Delight Second Edition p106 *)\n let floor_log2 i =\n if i <= 0\n then\n raise_s (Sexp.message \"[Int.floor_log2] got invalid input\" [ \"\", sexp_of_int i ]);\n num_bits - 1 - clz i\n ;;\n\n let ceil_log2 i =\n if i <= 0\n then raise_s (Sexp.message \"[Int.ceil_log2] got invalid input\" [ \"\", sexp_of_int i ]);\n if i = 1 then 0 else num_bits - clz (i - 1)\n ;;\nend\n\ninclude Pow2\n\n(* This is already defined by Comparable.Validate_with_zero, but Sign.of_int is\n more direct. *)\nlet sign = Sign.of_int\nlet popcount = Popcount.int_popcount\n\nmodule Pre_O = struct\n let ( + ) = ( + )\n let ( - ) = ( - )\n let ( * ) = ( * )\n let ( / ) = ( / )\n let ( ~- ) = ( ~- )\n let ( ** ) = ( ** )\n\n include (Int_replace_polymorphic_compare : Comparisons.Infix with type t := t)\n\n let abs = abs\n let neg = neg\n let zero = zero\n let of_int_exn = of_int_exn\nend\n\nmodule O = struct\n include Pre_O\n\n module F = Int_math.Make (struct\n type nonrec t = t\n\n include Pre_O\n\n let rem = rem\n let to_float = to_float\n let of_float = of_float\n let of_string = T.of_string\n let to_string = T.to_string\n end)\n\n include F\n\n external bswap16 : int -> int = \"%bswap16\"\n\n (* These inlined versions of (%), (/%), and (//) perform better than their functorized\n counterparts in [F] (see benchmarks below).\n\n The reason these functions are inlined in [Int] but not in any of the other integer\n modules is that they existed in [Int] and [Int] alone prior to the introduction of\n the [Int_math.Make] functor, and we didn't want to degrade their performance.\n\n We won't pre-emptively do the same for new functions, unless someone cares, on a case\n by case fashion. *)\n\n let ( % ) x y =\n if y <= zero\n then\n Printf.invalid_argf\n \"%s %% %s in core_int.ml: modulus should be positive\"\n (to_string x)\n (to_string y)\n ();\n let rval = rem x y in\n if rval < zero then rval + y else rval\n ;;\n\n let ( /% ) x y =\n if y <= zero\n then\n Printf.invalid_argf\n \"%s /%% %s in core_int.ml: divisor should be positive\"\n (to_string x)\n (to_string y)\n ();\n if x < zero then ((x + one) / y) - one else x / y\n ;;\n\n let ( // ) x y = to_float x /. to_float y\n let ( land ) = ( land )\n let ( lor ) = ( lor )\n let ( lxor ) = ( lxor )\n let lnot = lnot\n let ( lsl ) = ( lsl )\n let ( asr ) = ( asr )\n let ( lsr ) = ( lsr )\nend\n\ninclude O\n\n(* [Int] and [Int.O] agree value-wise *)\n\nmodule Private = struct\n module O_F = O.F\nend\n\n(* Include type-specific [Replace_polymorphic_compare] at the end, after including functor\n application that could shadow its definitions. This is here so that efficient versions\n of the comparison functions are exported by this module. *)\ninclude Int_replace_polymorphic_compare\n","open! Import\n\ntype ('a, 'b) t = T : ('a, 'a) t [@@deriving_inline sexp_of]\n\nlet sexp_of_t\n : type a b.\n (a -> Ppx_sexp_conv_lib.Sexp.t)\n -> (b -> Ppx_sexp_conv_lib.Sexp.t)\n -> (a, b) t\n -> Ppx_sexp_conv_lib.Sexp.t\n =\n fun _of_a _of_b -> function\n | T -> Ppx_sexp_conv_lib.Sexp.Atom \"T\"\n;;\n\n[@@@end]\n\ntype ('a, 'b) equal = ('a, 'b) t\n\nlet refl = T\nlet sym (type a b) (T : (a, b) t) : (b, a) t = T\nlet trans (type a b c) (T : (a, b) t) (T : (b, c) t) : (a, c) t = T\nlet conv (type a b) (T : (a, b) t) (a : a) : b = a\n\nmodule Lift (X : sig\n type 'a t\n end) =\nstruct\n let lift (type a b) (T : (a, b) t) : (a X.t, b X.t) t = T\nend\n\nmodule Lift2 (X : sig\n type ('a1, 'a2) t\n end) =\nstruct\n let lift (type a1 b1 a2 b2) (T : (a1, b1) t) (T : (a2, b2) t)\n : ((a1, a2) X.t, (b1, b2) X.t) t\n =\n T\n ;;\nend\n\nmodule Lift3 (X : sig\n type ('a1, 'a2, 'a3) t\n end) =\nstruct\n let lift (type a1 b1 a2 b2 a3 b3) (T : (a1, b1) t) (T : (a2, b2) t) (T : (a3, b3) t)\n : ((a1, a2, a3) X.t, (b1, b2, b3) X.t) t\n =\n T\n ;;\nend\n\nlet detuple2 (type a1 a2 b1 b2) (T : (a1 * a2, b1 * b2) t) : (a1, b1) t * (a2, b2) t =\n T, T\n;;\n\nlet tuple2 (type a1 a2 b1 b2) (T : (a1, b1) t) (T : (a2, b2) t) : (a1 * a2, b1 * b2) t =\n T\n;;\n\nmodule type Injective = sig\n type 'a t\n\n val strip : ('a t, 'b t) equal -> ('a, 'b) equal\nend\n\nmodule type Injective2 = sig\n type ('a1, 'a2) t\n\n val strip : (('a1, 'a2) t, ('b1, 'b2) t) equal -> ('a1, 'b1) equal * ('a2, 'b2) equal\nend\n\nmodule Composition_preserves_injectivity (M1 : Injective) (M2 : Injective) = struct\n type 'a t = 'a M1.t M2.t\n\n let strip e = M1.strip (M2.strip e)\nend\n\nmodule Obj = struct\n module Extension_constructor = struct\n [@@@ocaml.warning \"-3\"]\n\n let id = Caml.Obj.extension_id\n let of_val = Caml.Obj.extension_constructor\n end\nend\n\nmodule Id = struct\n module Uid = Int\n\n module Witness = struct\n module Key = struct\n type _ t = ..\n type type_witness_int = [ `type_witness of int ] [@@deriving_inline sexp_of]\n\n let sexp_of_type_witness_int =\n (function\n | `type_witness v0 ->\n Ppx_sexp_conv_lib.Sexp.List\n [ Ppx_sexp_conv_lib.Sexp.Atom \"type_witness\"; sexp_of_int v0 ]\n : type_witness_int -> Ppx_sexp_conv_lib.Sexp.t)\n ;;\n\n [@@@end]\n\n let sexp_of_t _sexp_of_a t =\n `type_witness (Obj.Extension_constructor.id (Obj.Extension_constructor.of_val t))\n |> sexp_of_type_witness_int\n ;;\n end\n\n module type S = sig\n type t\n type _ Key.t += Key : t Key.t\n end\n\n type 'a t = (module S with type t = 'a)\n\n let sexp_of_t (type a) sexp_of_a (module M : S with type t = a) =\n M.Key |> Key.sexp_of_t sexp_of_a\n ;;\n\n let create (type t) () =\n let module M = struct\n type nonrec t = t\n type _ Key.t += Key : t Key.t\n end\n in\n (module M : S with type t = t)\n ;;\n\n let uid (type a) (module M : S with type t = a) =\n Obj.Extension_constructor.id (Obj.Extension_constructor.of_val M.Key)\n ;;\n\n (* We want a constant allocated once that [same] can return whenever it gets the same\n witnesses. If we write the constant inside the body of [same], the native-code\n compiler will do the right thing and lift it out. But for clarity and robustness,\n we do it ourselves. *)\n let some_t = Some T\n\n let same (type a b) (a : a t) (b : b t) : (a, b) equal option =\n let module A = (val a : S with type t = a) in\n let module B = (val b : S with type t = b) in\n match A.Key with\n | B.Key -> some_t\n | _ -> None\n ;;\n end\n\n\n type 'a t =\n { witness : 'a Witness.t\n ; name : string\n ; to_sexp : 'a -> Sexp.t\n }\n\n let sexp_of_t _ { witness; name; to_sexp } : Sexp.t =\n if am_testing\n then Atom name\n else\n List\n [ List [ Atom \"name\"; Atom name ]\n ; List [ Atom \"witness\"; witness |> Witness.sexp_of_t to_sexp ]\n ]\n ;;\n\n let to_sexp t = t.to_sexp\n let name t = t.name\n let create ~name to_sexp = { witness = Witness.create (); name; to_sexp }\n let uid t = Witness.uid t.witness\n let hash t = uid t\n let hash_fold_t s t = hash_fold_int s (uid t)\n let same_witness t1 t2 = Witness.same t1.witness t2.witness\n let same t1 t2 = Option.is_some (same_witness t1 t2)\n\n let same_witness_exn t1 t2 =\n match same_witness t1 t2 with\n | Some w -> w\n | None ->\n Error.raise_s\n (Sexp.message\n \"Type_equal.Id.same_witness_exn got different ids\"\n [ ( \"\"\n , sexp_of_pair (sexp_of_t sexp_of_opaque) (sexp_of_t sexp_of_opaque) (t1, t2)\n )\n ])\n ;;\nend\n","open! Import\nopen Std_internal\ninclude Univ_map_intf\nmodule Uid = Type_equal.Id.Uid\n\nmodule Make1\n (Key : Key) (Data : sig\n type ('s, 'a) t [@@deriving sexp_of]\n end) =\nstruct\n (* A wrapper for the [Key] module that adds a dynamic check to [Key.to_type_id].\n\n It's a bug if the user-provided [Key.to_type_id] gives different type ids on\n different calls. Because this check should be fairly cheap, we do it dynamically to\n avoid subtler problems later.\n\n Of course, we're not checking truly pathological things like the provided\n [Key.to_type_id] only changes the value it returns on every third call...\n *)\n module Key = struct\n type 'a t = 'a Key.t [@@deriving sexp_of]\n\n (* test-friendly sexp conversion *)\n let sexp_of_type_id type_id =\n [%sexp\n { name = (Type_equal.Id.name type_id : string)\n ; uid =\n ((if am_running_inline_test\n then Sexp.Atom \"\"\n else Type_equal.Id.Uid.sexp_of_t (Type_equal.Id.uid type_id)) : Sexp.t)\n }]\n ;;\n\n let to_type_id key =\n let type_id1 = Key.to_type_id key in\n let type_id2 = Key.to_type_id key in\n if Type_equal.Id.same type_id1 type_id2\n then type_id1\n else\n raise_s\n [%message\n \"[Key.to_type_id] must not provide different type ids when called on the \\\n same input\"\n (key : _ Key.t)\n (type_id1 : type_id)\n (type_id2 : type_id)]\n ;;\n end\n\n type ('s, 'a) data = ('s, 'a) Data.t\n\n let name_of_key key = Type_equal.Id.name (Key.to_type_id key)\n let uid_of_key key = Type_equal.Id.uid (Key.to_type_id key)\n\n module Packed = struct\n type 's t = T : 'a Key.t * ('s, 'a) Data.t -> 's t\n\n let sexp_of_t sexp_of_a (T (key, data)) =\n Data.sexp_of_t sexp_of_a (Type_equal.Id.to_sexp (Key.to_type_id key)) data\n ;;\n\n let type_id_name (T (key, _)) = name_of_key key\n let type_id_uid (T (key, _)) = uid_of_key key\n end\n\n type 's t = 's Packed.t Uid.Map.t\n\n let sexp_of_t sexp_of_a t =\n Map.data t\n |> List.map ~f:(fun u -> Packed.type_id_name u, u)\n |> List.sort ~compare:(fun (a, _) (b, _) -> String.compare a b)\n |> [%sexp_of: (string * a Packed.t) list]\n ;;\n\n let invariant (t : _ t) =\n Invariant.invariant [%here] t [%sexp_of: _ t] (fun () ->\n Map.iteri t ~f:(fun ~key ~data ->\n assert (Uid.equal key (Packed.type_id_uid data))))\n ;;\n\n let set t key data = Map.set t ~key:(uid_of_key key) ~data:(Packed.T (key, data))\n let mem_by_id t id = Map.mem t id\n let mem t key = mem_by_id t (uid_of_key key)\n let remove_by_id t id = Map.remove t id\n let remove t key = remove_by_id t (uid_of_key key)\n let empty = Uid.Map.empty\n let is_empty = Map.is_empty\n\n let find (type b) t (key : b Key.t) =\n match Map.find t (uid_of_key key) with\n | None -> None\n | Some (Packed.T (key', value)) ->\n (* cannot raise -- see [invariant] *)\n let Type_equal.T =\n Type_equal.Id.same_witness_exn (Key.to_type_id key) (Key.to_type_id key')\n in\n Some (value : (_, b) Data.t)\n ;;\n\n let find_exn t key =\n match find t key with\n | Some data -> data\n | None -> failwithf \"Univ_map.find_exn on unknown key %s\" (name_of_key key) ()\n ;;\n\n let add t key data = if mem t key then `Duplicate else `Ok (set t key data)\n\n let add_exn t key data =\n match add t key data with\n | `Ok t -> t\n | `Duplicate -> failwithf \"Univ_map.add_exn on existing key %s\" (name_of_key key) ()\n ;;\n\n let change_exn t key ~f:update =\n match find t key with\n | Some data -> set t key (update data)\n | None -> failwithf \"Univ_map.change_exn on unknown key %s\" (name_of_key key) ()\n ;;\n\n let change t key ~f:update =\n let orig = find t key in\n let next = update orig in\n match next with\n | Some data -> set t key data\n | None -> if Option.is_none orig then t else remove t key\n ;;\n\n let update t key ~f = change t key ~f:(fun data -> Some (f data))\n let to_alist t = Map.data t\n\n let of_alist_exn t =\n Uid.Map.of_alist_exn (List.map t ~f:(fun p -> Packed.type_id_uid p, p))\n ;;\nend\n\nmodule Make\n (Key : Key) (Data : sig\n type 'a t [@@deriving sexp_of]\n end) =\nstruct\n module M =\n Make1\n (Key)\n (struct\n type (_, 'a) t = 'a Data.t [@@deriving sexp_of]\n end)\n\n type t = unit M.t [@@deriving sexp_of]\n\n module Key = Key\n\n type 'a data = 'a Data.t\n\n let invariant = M.invariant\n let empty = M.empty\n let is_empty = M.is_empty\n let set = M.set\n let mem = M.mem\n let mem_by_id = M.mem_by_id\n let find = M.find\n let find_exn = M.find_exn\n let add = M.add\n let add_exn = M.add_exn\n let change = M.change\n let change_exn = M.change_exn\n let update = M.update\n let remove = M.remove\n let remove_by_id = M.remove_by_id\n\n module Packed = struct\n type t = T : 'a Key.t * 'a Data.t -> t\n end\n\n let to_alist t =\n List.map (M.to_alist t) ~f:(function M.Packed.T (key, data) -> Packed.T (key, data))\n ;;\n\n let of_alist_exn t =\n M.of_alist_exn\n (List.map t ~f:(function Packed.T (key, data) -> M.Packed.T (key, data)))\n ;;\nend\n\nmodule Merge\n (Key : Key)\n (Input1_data : Data1)\n (Input2_data : Data1)\n (Output_data : Data1) =\nstruct\n type 's f =\n { f :\n 'a. key:'a Key.t\n -> [ `Left of ('s, 'a) Input1_data.t\n | `Right of ('s, 'a) Input2_data.t\n | `Both of ('s, 'a) Input1_data.t * ('s, 'a) Input2_data.t\n ] -> ('s, 'a) Output_data.t option\n }\n\n module Output = Make1 (Key) (Output_data)\n\n let merge\n (type s)\n (t1 : s Make1(Key)(Input1_data).t)\n (t2 : s Make1(Key)(Input2_data).t)\n ~f:{ f }\n =\n let f ~key merge_result =\n Option.map (f ~key merge_result) ~f:(fun data -> Output.Packed.T (key, data))\n in\n Map.merge t1 t2 ~f:(fun ~key:_ ->\n function\n | `Left (T (key, data)) -> f ~key (`Left data)\n | `Right (T (key, data)) -> f ~key (`Right data)\n | `Both (T (left_key, left_data), T (right_key, right_data)) ->\n (* Can't raise due to the invariant *)\n let Type_equal.T =\n Type_equal.Id.same_witness_exn\n (Key.to_type_id left_key)\n (Key.to_type_id right_key)\n in\n f ~key:left_key (`Both (left_data, right_data)))\n ;;\nend\n\nmodule Type_id_key = struct\n type 'a t = 'a Type_equal.Id.t [@@deriving sexp_of]\n\n let to_type_id = Fn.id\nend\n\ninclude (\n Make\n (Type_id_key)\n (struct\n type 'a t = 'a [@@deriving sexp_of]\n end) :\n S with type 'a data = 'a and module Key := Type_id_key)\n\nmodule Key = Type_equal.Id\n\nmodule With_default = struct\n module Key = struct\n type 'a t =\n { key : 'a Type_equal.Id.t\n ; default : 'a\n }\n\n let create ~default ~name sexp_of =\n { default; key = Type_equal.Id.create ~name sexp_of }\n ;;\n\n let id t = t.key\n end\n\n let find t { Key.key; default } = Option.value ~default (find t key)\n let set t { Key.key; default = _ } v = set t key v\n let change t k ~f:update = set t k (update (find t k))\nend\n\nmodule With_fold = struct\n module Key = struct\n type ('a, 'b) t =\n { key : 'b With_default.Key.t\n ; f : 'b -> 'a -> 'b\n }\n\n let create ~init ~f ~name sexp_of =\n { f; key = With_default.Key.create ~default:init ~name sexp_of }\n ;;\n\n let id t = With_default.Key.id t.key\n end\n\n let find t { Key.key; f = _ } = With_default.find t key\n let set t { Key.key; f = _ } v = With_default.set t key v\n let change t { Key.key; f = _ } ~f:update = With_default.change t key ~f:update\n let add t { Key.key; f } v = With_default.change t key ~f:(fun acc -> f acc v)\nend\n\nmodule Multi = struct\n open With_fold\n\n module Key = struct\n type 'a t = ('a, 'a list) Key.t\n\n let create ~name sexp_of =\n Key.create ~init:[] ~f:(fun xs x -> x :: xs) ~name (List.sexp_of_t sexp_of)\n ;;\n\n let id = With_fold.Key.id\n end\n\n let set = set\n let find = find\n let add = add\n let change = change\nend\n","open! Import\n\n(** ['a Cheap_option.t] is like ['a option], but it doesn't box [some _] values.\n\n There are several things that are unsafe about it:\n\n - [float t array] (or any array-backed container) is not memory-safe\n because float array optimization is incompatible with unboxed option\n optimization. You have to use [Uniform_array.t] instead of [array].\n\n - Nested options (['a t t]) don't work. They are believed to be\n memory-safe, but not parametric.\n\n - A record with [float t]s in it should be safe, but it's only [t] being\n abstract that gives you safety. If the compiler was smart enough to peek\n through the module signature then it could decide to construct a float\n array instead. *)\nmodule Cheap_option = struct\n (* This is taken from core_kernel. Rather than expose it in the public\n interface of base, just keep a copy around here. *)\n let phys_same (type a b) (a : a) (b : b) = phys_equal a (Caml.Obj.magic b : a)\n\n module T0 : sig\n type 'a t\n\n val none : _ t\n val some : 'a -> 'a t\n val is_none : _ t -> bool\n val is_some : _ t -> bool\n val value_exn : 'a t -> 'a\n val value_unsafe : 'a t -> 'a\n end = struct\n type +'a t\n\n (* Being a pointer, no one outside this module can construct a value that is\n [phys_same] as this one.\n\n It would be simpler to use this value as [none], but we use an immediate instead\n because it lets us avoid caml_modify when setting to [none], making certain\n benchmarks significantly faster (e.g. ../bench/array_queue.exe).\n\n this code is duplicated in Moption, and if we find yet another place where we want\n it we should reconsider making it shared. *)\n let none_substitute : _ t = Caml.Obj.obj (Caml.Obj.new_block Caml.Obj.abstract_tag 1)\n\n let none : _ t =\n (* The number was produced by\n [< /dev/urandom tr -c -d '1234567890abcdef' | head -c 16].\n\n The idea is that a random number will have lower probability to collide with\n anything than any number we can choose ourselves.\n\n We are using a polymorphic variant instead of an integer constant because there\n is a compiler bug where it wrongly assumes that the result of [if _ then c else\n y] is not a pointer if [c] is an integer compile-time constant. This is being\n fixed in https://github.com/ocaml/ocaml/pull/555. The \"memory corruption\" test\n below demonstrates the issue. *)\n Caml.Obj.magic `x6e8ee3478e1d7449\n ;;\n\n let is_none x = phys_equal x none\n let is_some x = not (phys_equal x none)\n\n let some (type a) (x : a) : a t =\n if phys_same x none then none_substitute else Caml.Obj.magic x\n ;;\n\n let value_unsafe (type a) (x : a t) : a =\n if phys_equal x none_substitute then Caml.Obj.magic none else Caml.Obj.magic x\n ;;\n\n let value_exn x =\n if is_some x\n then value_unsafe x\n else failwith \"Option_array.get_some_exn: the element is [None]\"\n ;;\n end\n\n module T1 = struct\n include T0\n\n let of_option = function\n | None -> none\n | Some x -> some x\n ;;\n\n let to_option x = if is_some x then Some (value_unsafe x) else None\n let to_sexpable = to_option\n let of_sexpable = of_option\n end\n\n include T1\n include Sexpable.Of_sexpable1 (Option) (T1)\nend\n\ntype 'a t = 'a Cheap_option.t Uniform_array.t [@@deriving_inline sexp]\n\nlet t_of_sexp : 'a. (Ppx_sexp_conv_lib.Sexp.t -> 'a) -> Ppx_sexp_conv_lib.Sexp.t -> 'a t =\n let _tp_loc = \"option_array.ml.t\" in\n fun _of_a t -> Uniform_array.t_of_sexp (Cheap_option.t_of_sexp _of_a) t\n;;\n\nlet sexp_of_t : 'a. ('a -> Ppx_sexp_conv_lib.Sexp.t) -> 'a t -> Ppx_sexp_conv_lib.Sexp.t =\n fun _of_a v -> Uniform_array.sexp_of_t (Cheap_option.sexp_of_t _of_a) v\n;;\n\n[@@@end]\n\nlet empty = Uniform_array.empty\nlet create ~len = Uniform_array.create ~len Cheap_option.none\nlet init n ~f = Uniform_array.init n ~f:(fun i -> Cheap_option.of_option (f i))\nlet init_some n ~f = Uniform_array.init n ~f:(fun i -> Cheap_option.some (f i))\nlet length = Uniform_array.length\nlet get t i = Cheap_option.to_option (Uniform_array.get t i)\nlet get_some_exn t i = Cheap_option.value_exn (Uniform_array.get t i)\nlet is_none t i = Cheap_option.is_none (Uniform_array.get t i)\nlet is_some t i = Cheap_option.is_some (Uniform_array.get t i)\nlet set t i x = Uniform_array.set t i (Cheap_option.of_option x)\nlet set_some t i x = Uniform_array.set t i (Cheap_option.some x)\nlet set_none t i = Uniform_array.set t i Cheap_option.none\nlet swap t i j = Uniform_array.swap t i j\nlet unsafe_get t i = Cheap_option.to_option (Uniform_array.unsafe_get t i)\nlet unsafe_get_some_exn t i = Cheap_option.value_exn (Uniform_array.unsafe_get t i)\n\nlet unsafe_get_some_assuming_some t i =\n Cheap_option.value_unsafe (Uniform_array.unsafe_get t i)\n;;\n\nlet unsafe_is_some t i = Cheap_option.is_some (Uniform_array.unsafe_get t i)\nlet unsafe_set t i x = Uniform_array.unsafe_set t i (Cheap_option.of_option x)\nlet unsafe_set_some t i x = Uniform_array.unsafe_set t i (Cheap_option.some x)\nlet unsafe_set_none t i = Uniform_array.unsafe_set t i Cheap_option.none\n\nlet clear t =\n for i = 0 to length t - 1 do\n unsafe_set_none t i\n done\n;;\n\ninclude Blit.Make1_generic (struct\n type nonrec 'a t = 'a t\n\n let length = length\n let create_like ~len _ = create ~len\n let unsafe_blit = Uniform_array.unsafe_blit\n end)\n\nlet copy = Uniform_array.copy\n\nmodule For_testing = struct\n module Unsafe_cheap_option = Cheap_option\nend\n","open! Import\ninclude Stack_intf\n\nlet raise_s = Error.raise_s\n\n(* This implementation is similar to [Deque] in that it uses an array of ['a] and\n a mutable [int] to indicate what in the array is used. We choose to implement [Stack]\n directly rather than on top of [Deque] for performance reasons. E.g. a simple\n microbenchmark shows that push/pop is about 20% faster. *)\ntype 'a t =\n { mutable length : int\n ; mutable elts : 'a Option_array.t\n }\n[@@deriving_inline sexp_of]\n\nlet sexp_of_t : 'a. ('a -> Ppx_sexp_conv_lib.Sexp.t) -> 'a t -> Ppx_sexp_conv_lib.Sexp.t =\n fun _of_a -> function\n | { length = v_length; elts = v_elts } ->\n let bnds = [] in\n let bnds =\n let arg = Option_array.sexp_of_t _of_a v_elts in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"elts\"; arg ] :: bnds\n in\n let bnds =\n let arg = sexp_of_int v_length in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"length\"; arg ] :: bnds\n in\n Ppx_sexp_conv_lib.Sexp.List bnds\n;;\n\n[@@@end]\n\nlet sexp_of_t_internal = sexp_of_t\nlet sexp_of_t = `Rebound_later\nlet _ = sexp_of_t\nlet capacity t = Option_array.length t.elts\n\nlet invariant invariant_a ({ length; elts } as t) : unit =\n try\n assert (0 <= length && length <= Option_array.length elts);\n for i = 0 to length - 1 do\n invariant_a (Option_array.get_some_exn elts i)\n done;\n (* We maintain the invariant that unused elements are unset to avoid a space\n leak. *)\n for i = length to Option_array.length elts - 1 do\n assert (not (Option_array.is_some elts i))\n done\n with\n | exn ->\n raise_s\n (Sexp.message\n \"Stack.invariant failed\"\n [ \"exn\", exn |> Exn.sexp_of_t; \"stack\", t |> sexp_of_t_internal sexp_of_opaque ])\n;;\n\nlet create (type a) () : a t = { length = 0; elts = Option_array.empty }\nlet length t = t.length\nlet is_empty t = length t = 0\n\n(* The order in which elements are visited has been chosen so as to be backwards\n compatible with both [Linked_stack] and [Caml.Stack] *)\nlet fold t ~init ~f =\n let r = ref init in\n for i = t.length - 1 downto 0 do\n r := f !r (Option_array.get_some_exn t.elts i)\n done;\n !r\n;;\n\nlet iter t ~f =\n for i = t.length - 1 downto 0 do\n f (Option_array.get_some_exn t.elts i)\n done\n;;\n\nmodule C = Container.Make (struct\n type nonrec 'a t = 'a t\n\n let fold = fold\n let iter = `Custom iter\n let length = `Custom length\n end)\n\nlet mem = C.mem\nlet exists = C.exists\nlet for_all = C.for_all\nlet count = C.count\nlet sum = C.sum\nlet find = C.find\nlet find_map = C.find_map\nlet to_list = C.to_list\nlet to_array = C.to_array\nlet min_elt = C.min_elt\nlet max_elt = C.max_elt\nlet fold_result = C.fold_result\nlet fold_until = C.fold_until\n\nlet of_list (type a) (l : a list) =\n if List.is_empty l\n then create ()\n else (\n let length = List.length l in\n let elts = Option_array.create ~len:(2 * length) in\n let r = ref l in\n for i = length - 1 downto 0 do\n match !r with\n | [] -> assert false\n | a :: l ->\n Option_array.set_some elts i a;\n r := l\n done;\n { length; elts })\n;;\n\nlet sexp_of_t sexp_of_a t = List.sexp_of_t sexp_of_a (to_list t)\nlet t_of_sexp a_of_sexp sexp = of_list (List.t_of_sexp a_of_sexp sexp)\n\nlet resize t size =\n let arr = Option_array.create ~len:size in\n Option_array.blit ~src:t.elts ~dst:arr ~src_pos:0 ~dst_pos:0 ~len:t.length;\n t.elts <- arr\n;;\n\nlet set_capacity t new_capacity =\n let new_capacity = max new_capacity (length t) in\n if new_capacity <> capacity t then resize t new_capacity\n;;\n\nlet push t a =\n if t.length = Option_array.length t.elts then resize t (2 * (t.length + 1));\n Option_array.set_some t.elts t.length a;\n t.length <- t.length + 1\n;;\n\nlet pop_nonempty t =\n let i = t.length - 1 in\n let result = Option_array.get_some_exn t.elts i in\n Option_array.set_none t.elts i;\n t.length <- i;\n result\n;;\n\nlet pop_error = Error.of_string \"Stack.pop of empty stack\"\nlet pop t = if is_empty t then None else Some (pop_nonempty t)\nlet pop_exn t = if is_empty t then Error.raise pop_error else pop_nonempty t\nlet top_nonempty t = Option_array.get_some_exn t.elts (t.length - 1)\nlet top_error = Error.of_string \"Stack.top of empty stack\"\nlet top t = if is_empty t then None else Some (top_nonempty t)\nlet top_exn t = if is_empty t then Error.raise top_error else top_nonempty t\nlet copy { length; elts } = { length; elts = Option_array.copy elts }\n\nlet clear t =\n if t.length > 0\n then (\n for i = 0 to t.length - 1 do\n Option_array.set_none t.elts i\n done;\n t.length <- 0)\n;;\n\nlet until_empty t f =\n let rec loop () =\n if t.length > 0\n then (\n f (pop_nonempty t);\n loop ())\n in\n loop ()\n;;\n\nlet singleton x =\n let t = create () in\n push t x;\n t\n;;\n","(***********************************************************************)\n(* *)\n(* Objective Caml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. All rights reserved. This file is distributed *)\n(* under the terms of the Apache 2.0 license. See ../THIRD-PARTY.txt *)\n(* for details. *)\n(* *)\n(***********************************************************************)\n\n(* Sets over ordered types *)\n\nopen! Import\ninclude Set_intf\n\nlet with_return = With_return.with_return\n\n\nmodule Tree0 = struct\n type 'a t =\n | Empty\n (* (Leaf x) is the same as (Node (Empty, x, Empty, 1, 1)) but uses less space. *)\n | Leaf of 'a\n (* first int is height, second is sub-tree size *)\n | Node of 'a t * 'a * 'a t * int * int\n\n type 'a tree = 'a t\n\n (* Sets are represented by balanced binary trees (the heights of the children differ by\n at most 2. *)\n let height = function\n | Empty -> 0\n | Leaf _ -> 1\n | Node (_, _, _, h, _) -> h\n ;;\n\n let length = function\n | Empty -> 0\n | Leaf _ -> 1\n | Node (_, _, _, _, s) -> s\n ;;\n\n let invariants =\n let in_range lower upper compare_elt v =\n (match lower with\n | None -> true\n | Some lower -> compare_elt lower v < 0)\n &&\n match upper with\n | None -> true\n | Some upper -> compare_elt v upper < 0\n in\n let rec loop lower upper compare_elt t =\n match t with\n | Empty -> true\n | Leaf v -> in_range lower upper compare_elt v\n | Node (l, v, r, h, n) ->\n let hl = height l\n and hr = height r in\n abs (hl - hr) <= 2\n && h = max hl hr + 1\n && n = length l + length r + 1\n && in_range lower upper compare_elt v\n && loop lower (Some v) compare_elt l\n && loop (Some v) upper compare_elt r\n in\n fun t ~compare_elt -> loop None None compare_elt t\n ;;\n\n let is_empty = function\n | Empty -> true\n | Leaf _ | Node _ -> false\n ;;\n\n (* Creates a new node with left son l, value v and right son r.\n We must have all elements of l < v < all elements of r.\n l and r must be balanced and | height l - height r | <= 2.\n Inline expansion of height for better speed. *)\n\n let create l v r =\n let hl =\n match l with\n | Empty -> 0\n | Leaf _ -> 1\n | Node (_, _, _, h, _) -> h\n in\n let hr =\n match r with\n | Empty -> 0\n | Leaf _ -> 1\n | Node (_, _, _, h, _) -> h\n in\n let h = if hl >= hr then hl + 1 else hr + 1 in\n if h = 1\n then Leaf v\n else (\n let sl =\n match l with\n | Empty -> 0\n | Leaf _ -> 1\n | Node (_, _, _, _, s) -> s\n in\n let sr =\n match r with\n | Empty -> 0\n | Leaf _ -> 1\n | Node (_, _, _, _, s) -> s\n in\n Node (l, v, r, h, sl + sr + 1))\n ;;\n\n (* We must call [f] with increasing indexes, because the bin_prot reader in\n Core_kernel.Set needs it. *)\n let of_increasing_iterator_unchecked ~len ~f =\n let rec loop n ~f i =\n match n with\n | 0 -> Empty\n | 1 ->\n let k = f i in\n Leaf k\n | 2 ->\n let kl = f i in\n let k = f (i + 1) in\n create (Leaf kl) k Empty\n | 3 ->\n let kl = f i in\n let k = f (i + 1) in\n let kr = f (i + 2) in\n create (Leaf kl) k (Leaf kr)\n | n ->\n let left_length = n lsr 1 in\n let right_length = n - left_length - 1 in\n let left = loop left_length ~f i in\n let k = f (i + left_length) in\n let right = loop right_length ~f (i + left_length + 1) in\n create left k right\n in\n loop len ~f 0\n ;;\n\n let of_sorted_array_unchecked array ~compare_elt =\n let array_length = Array.length array in\n let next =\n (* We don't check if the array is sorted or keys are duplicated, because that\n checking is slower than the whole [of_sorted_array] function *)\n if array_length < 2 || compare_elt array.(0) array.(1) < 0\n then fun i -> array.(i)\n else fun i -> array.(array_length - 1 - i)\n in\n of_increasing_iterator_unchecked ~len:array_length ~f:next\n ;;\n\n let of_sorted_array array ~compare_elt =\n match array with\n | [||] | [| _ |] -> Result.Ok (of_sorted_array_unchecked array ~compare_elt)\n | _ ->\n with_return (fun r ->\n let increasing =\n match compare_elt array.(0) array.(1) with\n | 0 ->\n r.return (Or_error.error_string \"of_sorted_array: duplicated elements\")\n | i -> i < 0\n in\n for i = 1 to Array.length array - 2 do\n match compare_elt array.(i) array.(i + 1) with\n | 0 ->\n r.return (Or_error.error_string \"of_sorted_array: duplicated elements\")\n | i ->\n if Poly.( <> ) (i < 0) increasing\n then\n r.return\n (Or_error.error_string \"of_sorted_array: elements are not ordered\")\n done;\n Result.Ok (of_sorted_array_unchecked array ~compare_elt))\n ;;\n\n (* Same as create, but performs one step of rebalancing if necessary.\n Assumes l and r balanced and | height l - height r | <= 3.\n Inline expansion of create for better speed in the most frequent case\n where no rebalancing is required. *)\n\n let bal l v r =\n let hl =\n match l with\n | Empty -> 0\n | Leaf _ -> 1\n | Node (_, _, _, h, _) -> h\n in\n let hr =\n match r with\n | Empty -> 0\n | Leaf _ -> 1\n | Node (_, _, _, h, _) -> h\n in\n if hl > hr + 2\n then (\n match l with\n | Empty -> assert false\n | Leaf _ -> assert false (* because h(l)>h(r)+2 and h(leaf)=1 *)\n | Node (ll, lv, lr, _, _) ->\n if height ll >= height lr\n then create ll lv (create lr v r)\n else (\n match lr with\n | Empty -> assert false\n | Leaf lrv ->\n assert (is_empty ll);\n create (create ll lv Empty) lrv (create Empty v r)\n | Node (lrl, lrv, lrr, _, _) -> create (create ll lv lrl) lrv (create lrr v r)))\n else if hr > hl + 2\n then (\n match r with\n | Empty -> assert false\n | Leaf rv -> create (create l v Empty) rv Empty\n | Node (rl, rv, rr, _, _) ->\n if height rr >= height rl\n then create (create l v rl) rv rr\n else (\n match rl with\n | Empty -> assert false\n | Leaf rlv ->\n assert (is_empty rr);\n create (create l v Empty) rlv (create Empty rv rr)\n | Node (rll, rlv, rlr, _, _) -> create (create l v rll) rlv (create rlr rv rr)))\n else (\n let h = if hl >= hr then hl + 1 else hr + 1 in\n let sl =\n match l with\n | Empty -> 0\n | Leaf _ -> 1\n | Node (_, _, _, _, s) -> s\n in\n let sr =\n match r with\n | Empty -> 0\n | Leaf _ -> 1\n | Node (_, _, _, _, s) -> s\n in\n if h = 1 then Leaf v else Node (l, v, r, h, sl + sr + 1))\n ;;\n\n (* Insertion of one element *)\n\n exception Same\n\n let add t x ~compare_elt =\n let rec aux = function\n | Empty -> Leaf x\n | Leaf v ->\n let c = compare_elt x v in\n if c = 0\n then raise Same\n else if c < 0\n then bal (Leaf x) v Empty\n else bal Empty v (Leaf x)\n | Node (l, v, r, _, _) ->\n let c = compare_elt x v in\n if c = 0 then raise Same else if c < 0 then bal (aux l) v r else bal l v (aux r)\n in\n try aux t with\n | Same -> t\n ;;\n\n (* Same as create and bal, but no assumptions are made on the relative heights of l and\n r. *)\n let rec join l v r ~compare_elt =\n match l, r with\n | Empty, _ -> add r v ~compare_elt\n | _, Empty -> add l v ~compare_elt\n | Leaf lv, _ -> add (add r v ~compare_elt) lv ~compare_elt\n | _, Leaf rv -> add (add l v ~compare_elt) rv ~compare_elt\n | Node (ll, lv, lr, lh, _), Node (rl, rv, rr, rh, _) ->\n if lh > rh + 2\n then bal ll lv (join lr v r ~compare_elt)\n else if rh > lh + 2\n then bal (join l v rl ~compare_elt) rv rr\n else create l v r\n ;;\n\n (* Smallest and greatest element of a set *)\n let rec min_elt = function\n | Empty -> None\n | Leaf v | Node (Empty, v, _, _, _) -> Some v\n | Node (l, _, _, _, _) -> min_elt l\n ;;\n\n exception Set_min_elt_exn_of_empty_set [@@deriving_inline sexp]\n\n let () =\n Ppx_sexp_conv_lib.Conv.Exn_converter.add\n [%extension_constructor Set_min_elt_exn_of_empty_set]\n (function\n | Set_min_elt_exn_of_empty_set ->\n Ppx_sexp_conv_lib.Sexp.Atom \"set.ml.Tree0.Set_min_elt_exn_of_empty_set\"\n | _ -> assert false)\n ;;\n\n [@@@end]\n\n exception Set_max_elt_exn_of_empty_set [@@deriving_inline sexp]\n\n let () =\n Ppx_sexp_conv_lib.Conv.Exn_converter.add\n [%extension_constructor Set_max_elt_exn_of_empty_set]\n (function\n | Set_max_elt_exn_of_empty_set ->\n Ppx_sexp_conv_lib.Sexp.Atom \"set.ml.Tree0.Set_max_elt_exn_of_empty_set\"\n | _ -> assert false)\n ;;\n\n [@@@end]\n\n let min_elt_exn t =\n match min_elt t with\n | None -> raise Set_min_elt_exn_of_empty_set\n | Some v -> v\n ;;\n\n let fold_until t ~init ~f ~finish =\n let rec fold_until_helper ~f t acc =\n match t with\n | Empty -> Continue_or_stop.Continue acc\n | Leaf value -> f acc value\n | Node (left, value, right, _, _) ->\n (match fold_until_helper ~f left acc with\n | Stop _a as x -> x\n | Continue acc ->\n (match f acc value with\n | Stop _a as x -> x\n | Continue a -> fold_until_helper ~f right a))\n in\n match fold_until_helper ~f t init with\n | Continue x -> finish x\n | Stop x -> x\n ;;\n\n let rec max_elt = function\n | Empty -> None\n | Leaf v | Node (_, v, Empty, _, _) -> Some v\n | Node (_, _, r, _, _) -> max_elt r\n ;;\n\n let max_elt_exn t =\n match max_elt t with\n | None -> raise Set_max_elt_exn_of_empty_set\n | Some v -> v\n ;;\n\n (* Remove the smallest element of the given set *)\n\n let rec remove_min_elt = function\n | Empty -> invalid_arg \"Set.remove_min_elt\"\n | Leaf _ -> Empty\n | Node (Empty, _, r, _, _) -> r\n | Node (l, v, r, _, _) -> bal (remove_min_elt l) v r\n ;;\n\n (* Merge two trees l and r into one. All elements of l must precede the elements of r.\n Assume | height l - height r | <= 2. *)\n let merge t1 t2 =\n match t1, t2 with\n | Empty, t -> t\n | t, Empty -> t\n | _, _ -> bal t1 (min_elt_exn t2) (remove_min_elt t2)\n ;;\n\n (* Merge two trees l and r into one. All elements of l must precede the elements of r.\n No assumption on the heights of l and r. *)\n let concat t1 t2 ~compare_elt =\n match t1, t2 with\n | Empty, t | t, Empty -> t\n | _, _ -> join t1 (min_elt_exn t2) (remove_min_elt t2) ~compare_elt\n ;;\n\n let split t x ~compare_elt =\n let rec split t =\n match t with\n | Empty -> Empty, None, Empty\n | Leaf v ->\n let c = compare_elt x v in\n if c = 0\n then Empty, Some v, Empty\n else if c < 0\n then Empty, None, Leaf v\n else Leaf v, None, Empty\n | Node (l, v, r, _, _) ->\n let c = compare_elt x v in\n if c = 0\n then l, Some v, r\n else if c < 0\n then (\n let ll, maybe_elt, rl = split l in\n ll, maybe_elt, join rl v r ~compare_elt)\n else (\n let lr, maybe_elt, rr = split r in\n join l v lr ~compare_elt, maybe_elt, rr)\n in\n split t\n ;;\n\n (* Implementation of the set operations *)\n\n let empty = Empty\n\n let rec mem t x ~compare_elt =\n match t with\n | Empty -> false\n | Leaf v ->\n let c = compare_elt x v in\n c = 0\n | Node (l, v, r, _, _) ->\n let c = compare_elt x v in\n c = 0 || mem (if c < 0 then l else r) x ~compare_elt\n ;;\n\n let singleton x = Leaf x\n\n let remove t x ~compare_elt =\n let rec aux t =\n match t with\n | Empty -> raise Same\n | Leaf v -> if compare_elt x v = 0 then Empty else raise Same\n | Node (l, v, r, _, _) ->\n let c = compare_elt x v in\n if c = 0 then merge l r else if c < 0 then bal (aux l) v r else bal l v (aux r)\n in\n try aux t with\n | Same -> t\n ;;\n\n let remove_index t i ~compare_elt:_ =\n let rec aux t i =\n match t with\n | Empty -> raise Same\n | Leaf _ -> if i = 0 then Empty else raise Same\n | Node (l, v, r, _, _) ->\n let l_size = length l in\n let c = Poly.compare i l_size in\n if c = 0\n then merge l r\n else if c < 0\n then bal (aux l i) v r\n else bal l v (aux r (i - l_size - 1))\n in\n try aux t i with\n | Same -> t\n ;;\n\n let union s1 s2 ~compare_elt =\n let rec union s1 s2 =\n if phys_equal s1 s2\n then s1\n else (\n match s1, s2 with\n | Empty, t | t, Empty -> t\n | Leaf v1, _ -> union (Node (Empty, v1, Empty, 1, 1)) s2\n | _, Leaf v2 -> union s1 (Node (Empty, v2, Empty, 1, 1))\n | Node (l1, v1, r1, h1, _), Node (l2, v2, r2, h2, _) ->\n if h1 >= h2\n then\n if h2 = 1\n then add s1 v2 ~compare_elt\n else (\n let l2, _, r2 = split s2 v1 ~compare_elt in\n join (union l1 l2) v1 (union r1 r2) ~compare_elt)\n else if h1 = 1\n then add s2 v1 ~compare_elt\n else (\n let l1, _, r1 = split s1 v2 ~compare_elt in\n join (union l1 l2) v2 (union r1 r2) ~compare_elt))\n in\n union s1 s2\n ;;\n\n let union_list ~comparator ~to_tree xs =\n let compare_elt = comparator.Comparator.compare in\n List.fold xs ~init:empty ~f:(fun ac x -> union ac (to_tree x) ~compare_elt)\n ;;\n\n let inter s1 s2 ~compare_elt =\n let rec inter s1 s2 =\n if phys_equal s1 s2\n then s1\n else (\n match s1, s2 with\n | Empty, _ | _, Empty -> Empty\n | (Leaf elt as singleton), other_set | other_set, (Leaf elt as singleton) ->\n if mem other_set elt ~compare_elt then singleton else Empty\n | Node (l1, v1, r1, _, _), t2 ->\n (match split t2 v1 ~compare_elt with\n | l2, None, r2 -> concat (inter l1 l2) (inter r1 r2) ~compare_elt\n | l2, Some v1, r2 -> join (inter l1 l2) v1 (inter r1 r2) ~compare_elt))\n in\n inter s1 s2\n ;;\n\n let diff s1 s2 ~compare_elt =\n let rec diff s1 s2 =\n if phys_equal s1 s2\n then Empty\n else (\n match s1, s2 with\n | Empty, _ -> Empty\n | t1, Empty -> t1\n | Leaf v1, t2 -> diff (Node (Empty, v1, Empty, 1, 1)) t2\n | Node (l1, v1, r1, _, _), t2 ->\n (match split t2 v1 ~compare_elt with\n | l2, None, r2 -> join (diff l1 l2) v1 (diff r1 r2) ~compare_elt\n | l2, Some _, r2 -> concat (diff l1 l2) (diff r1 r2) ~compare_elt))\n in\n diff s1 s2\n ;;\n\n module Enum = struct\n type increasing\n type decreasing\n\n type ('a, 'direction) t =\n | End\n | More of 'a * 'a tree * ('a, 'direction) t\n\n let rec cons s (e : (_, increasing) t) : (_, increasing) t =\n match s with\n | Empty -> e\n | Leaf v -> More (v, Empty, e)\n | Node (l, v, r, _, _) -> cons l (More (v, r, e))\n ;;\n\n let rec cons_right s (e : (_, decreasing) t) : (_, decreasing) t =\n match s with\n | Empty -> e\n | Leaf v -> More (v, Empty, e)\n | Node (l, v, r, _, _) -> cons_right r (More (v, l, e))\n ;;\n\n let of_set s : (_, increasing) t = cons s End\n let of_set_right s : (_, decreasing) t = cons_right s End\n\n let starting_at_increasing t key compare : (_, increasing) t =\n let rec loop t e =\n match t with\n | Empty -> e\n | Leaf v -> loop (Node (Empty, v, Empty, 1, 1)) e\n | Node (_, v, r, _, _) when compare v key < 0 -> loop r e\n | Node (l, v, r, _, _) -> loop l (More (v, r, e))\n in\n loop t End\n ;;\n\n let starting_at_decreasing t key compare : (_, decreasing) t =\n let rec loop t e =\n match t with\n | Empty -> e\n | Leaf v -> loop (Node (Empty, v, Empty, 1, 1)) e\n | Node (l, v, _, _, _) when compare v key > 0 -> loop l e\n | Node (l, v, r, _, _) -> loop r (More (v, l, e))\n in\n loop t End\n ;;\n\n let compare compare_elt e1 e2 =\n let rec loop e1 e2 =\n match e1, e2 with\n | End, End -> 0\n | End, _ -> -1\n | _, End -> 1\n | More (v1, r1, e1), More (v2, r2, e2) ->\n let c = compare_elt v1 v2 in\n if c <> 0\n then c\n else if phys_equal r1 r2\n then loop e1 e2\n else loop (cons r1 e1) (cons r2 e2)\n in\n loop e1 e2\n ;;\n\n let rec iter ~f = function\n | End -> ()\n | More (a, tree, enum) ->\n f a;\n iter (cons tree enum) ~f\n ;;\n\n let iter2 compare_elt t1 t2 ~f =\n let rec loop t1 t2 =\n match t1, t2 with\n | End, End -> ()\n | End, _ -> iter t2 ~f:(fun a -> f (`Right a))\n | _, End -> iter t1 ~f:(fun a -> f (`Left a))\n | More (a1, tree1, enum1), More (a2, tree2, enum2) ->\n let compare_result = compare_elt a1 a2 in\n if compare_result = 0\n then (\n f (`Both (a1, a2));\n loop (cons tree1 enum1) (cons tree2 enum2))\n else if compare_result < 0\n then (\n f (`Left a1);\n loop (cons tree1 enum1) t2)\n else (\n f (`Right a2);\n loop t1 (cons tree2 enum2))\n in\n loop t1 t2\n ;;\n\n let symmetric_diff t1 t2 ~compare_elt =\n let step state : ((_, _) Either.t, _) Sequence.Step.t =\n match state with\n | End, End -> Done\n | End, More (elt, tree, enum) -> Yield (Second elt, (End, cons tree enum))\n | More (elt, tree, enum), End -> Yield (First elt, (cons tree enum, End))\n | (More (a1, tree1, enum1) as left), (More (a2, tree2, enum2) as right) ->\n let compare_result = compare_elt a1 a2 in\n if compare_result = 0\n then (\n let next_state =\n if phys_equal tree1 tree2\n then enum1, enum2\n else cons tree1 enum1, cons tree2 enum2\n in\n Skip next_state)\n else if compare_result < 0\n then Yield (First a1, (cons tree1 enum1, right))\n else Yield (Second a2, (left, cons tree2 enum2))\n in\n Sequence.unfold_step ~init:(of_set t1, of_set t2) ~f:step\n ;;\n end\n\n let to_sequence_increasing comparator ~from_elt t =\n let next enum =\n match enum with\n | Enum.End -> Sequence.Step.Done\n | Enum.More (k, t, e) -> Sequence.Step.Yield (k, Enum.cons t e)\n in\n let init =\n match from_elt with\n | None -> Enum.of_set t\n | Some key -> Enum.starting_at_increasing t key comparator.Comparator.compare\n in\n Sequence.unfold_step ~init ~f:next\n ;;\n\n let to_sequence_decreasing comparator ~from_elt t =\n let next enum =\n match enum with\n | Enum.End -> Sequence.Step.Done\n | Enum.More (k, t, e) -> Sequence.Step.Yield (k, Enum.cons_right t e)\n in\n let init =\n match from_elt with\n | None -> Enum.of_set_right t\n | Some key -> Enum.starting_at_decreasing t key comparator.Comparator.compare\n in\n Sequence.unfold_step ~init ~f:next\n ;;\n\n let to_sequence\n comparator\n ?(order = `Increasing)\n ?greater_or_equal_to\n ?less_or_equal_to\n t\n =\n let inclusive_bound side t bound =\n let compare_elt = comparator.Comparator.compare in\n let l, maybe, r = split t bound ~compare_elt in\n let t = side (l, r) in\n match maybe with\n | None -> t\n | Some elt -> add t elt ~compare_elt\n in\n match order with\n | `Increasing ->\n let t = Option.fold less_or_equal_to ~init:t ~f:(inclusive_bound fst) in\n to_sequence_increasing comparator ~from_elt:greater_or_equal_to t\n | `Decreasing ->\n let t = Option.fold greater_or_equal_to ~init:t ~f:(inclusive_bound snd) in\n to_sequence_decreasing comparator ~from_elt:less_or_equal_to t\n ;;\n\n\n let rec find_first_satisfying t ~f =\n match t with\n | Empty -> None\n | Leaf v -> if f v then Some v else None\n | Node (l, v, r, _, _) ->\n if f v\n then (\n match find_first_satisfying l ~f with\n | None -> Some v\n | Some _ as x -> x)\n else find_first_satisfying r ~f\n ;;\n\n let rec find_last_satisfying t ~f =\n match t with\n | Empty -> None\n | Leaf v -> if f v then Some v else None\n | Node (l, v, r, _, _) ->\n if f v\n then (\n match find_last_satisfying r ~f with\n | None -> Some v\n | Some _ as x -> x)\n else find_last_satisfying l ~f\n ;;\n\n let binary_search t ~compare how v =\n match how with\n | `Last_strictly_less_than -> find_last_satisfying t ~f:(fun x -> compare x v < 0)\n | `Last_less_than_or_equal_to ->\n find_last_satisfying t ~f:(fun x -> compare x v <= 0)\n | `First_equal_to ->\n (match find_first_satisfying t ~f:(fun x -> compare x v >= 0) with\n | Some x as elt when compare x v = 0 -> elt\n | None | Some _ -> None)\n | `Last_equal_to ->\n (match find_last_satisfying t ~f:(fun x -> compare x v <= 0) with\n | Some x as elt when compare x v = 0 -> elt\n | None | Some _ -> None)\n | `First_greater_than_or_equal_to ->\n find_first_satisfying t ~f:(fun x -> compare x v >= 0)\n | `First_strictly_greater_than ->\n find_first_satisfying t ~f:(fun x -> compare x v > 0)\n ;;\n\n let binary_search_segmented t ~segment_of how =\n let is_left x =\n match segment_of x with\n | `Left -> true\n | `Right -> false\n in\n let is_right x = not (is_left x) in\n match how with\n | `Last_on_left -> find_last_satisfying t ~f:is_left\n | `First_on_right -> find_first_satisfying t ~f:is_right\n ;;\n\n let merge_to_sequence\n comparator\n ?(order = `Increasing)\n ?greater_or_equal_to\n ?less_or_equal_to\n t\n t'\n =\n Sequence.merge_with_duplicates\n (to_sequence comparator ~order ?greater_or_equal_to ?less_or_equal_to t)\n (to_sequence comparator ~order ?greater_or_equal_to ?less_or_equal_to t')\n ~compare:\n (match order with\n | `Increasing -> comparator.compare\n | `Decreasing -> Fn.flip comparator.compare)\n ;;\n\n let compare compare_elt s1 s2 =\n Enum.compare compare_elt (Enum.of_set s1) (Enum.of_set s2)\n ;;\n\n let iter2 s1 s2 ~compare_elt = Enum.iter2 compare_elt (Enum.of_set s1) (Enum.of_set s2)\n let equal s1 s2 ~compare_elt = compare compare_elt s1 s2 = 0\n\n let is_subset s1 ~of_:s2 ~compare_elt =\n let rec is_subset s1 ~of_:s2 =\n match s1, s2 with\n | Empty, _ -> true\n | _, Empty -> false\n | Leaf v1, t2 -> mem t2 v1 ~compare_elt\n | Node (l1, v1, r1, _, _), Leaf v2 ->\n (match l1, r1 with\n | Empty, Empty ->\n (* This case shouldn't occur in practice because we should have constructed\n a Leaf rather than a Node with two Empty subtrees *)\n compare_elt v1 v2 = 0\n | _, _ -> false)\n | Node (l1, v1, r1, _, _), (Node (l2, v2, r2, _, _) as t2) ->\n let c = compare_elt v1 v2 in\n if c = 0\n then\n phys_equal s1 s2 || (is_subset l1 ~of_:l2 && is_subset r1 ~of_:r2)\n (* Note that height and size don't matter here. *)\n else if c < 0\n then is_subset (Node (l1, v1, Empty, 0, 0)) ~of_:l2 && is_subset r1 ~of_:t2\n else is_subset (Node (Empty, v1, r1, 0, 0)) ~of_:r2 && is_subset l1 ~of_:t2\n in\n is_subset s1 ~of_:s2\n ;;\n\n let rec are_disjoint s1 s2 ~compare_elt =\n match s1, s2 with\n | Empty, _ | _, Empty -> true\n | Leaf elt, other_set | other_set, Leaf elt -> not (mem other_set elt ~compare_elt)\n | Node (l1, v1, r1, _, _), t2 ->\n if phys_equal s1 s2\n then false\n else (\n match split t2 v1 ~compare_elt with\n | l2, None, r2 ->\n are_disjoint l1 l2 ~compare_elt && are_disjoint r1 r2 ~compare_elt\n | _, Some _, _ -> false)\n ;;\n\n let iter t ~f =\n let rec iter = function\n | Empty -> ()\n | Leaf v -> f v\n | Node (l, v, r, _, _) ->\n iter l;\n f v;\n iter r\n in\n iter t\n ;;\n\n let symmetric_diff = Enum.symmetric_diff\n\n let rec fold s ~init:accu ~f =\n match s with\n | Empty -> accu\n | Leaf v -> f accu v\n | Node (l, v, r, _, _) -> fold ~f r ~init:(f (fold ~f l ~init:accu) v)\n ;;\n\n let hash_fold_t_ignoring_structure hash_fold_elem state t =\n fold t ~init:(hash_fold_int state (length t)) ~f:hash_fold_elem\n ;;\n\n let count t ~f = Container.count ~fold t ~f\n let sum m t ~f = Container.sum ~fold m t ~f\n\n let rec fold_right s ~init:accu ~f =\n match s with\n | Empty -> accu\n | Leaf v -> f v accu\n | Node (l, v, r, _, _) -> fold_right ~f l ~init:(f v (fold_right ~f r ~init:accu))\n ;;\n\n let rec for_all t ~f:p =\n match t with\n | Empty -> true\n | Leaf v -> p v\n | Node (l, v, r, _, _) -> p v && for_all ~f:p l && for_all ~f:p r\n ;;\n\n let rec exists t ~f:p =\n match t with\n | Empty -> false\n | Leaf v -> p v\n | Node (l, v, r, _, _) -> p v || exists ~f:p l || exists ~f:p r\n ;;\n\n let filter s ~f:p ~compare_elt =\n let rec filt accu = function\n | Empty -> accu\n | Leaf v -> if p v then add accu v ~compare_elt else accu\n | Node (l, v, r, _, _) ->\n filt (filt (if p v then add accu v ~compare_elt else accu) l) r\n in\n filt Empty s\n ;;\n\n let filter_map s ~f:p ~compare_elt =\n let rec filt accu = function\n | Empty -> accu\n | Leaf v ->\n (match p v with\n | None -> accu\n | Some v -> add accu v ~compare_elt)\n | Node (l, v, r, _, _) ->\n filt\n (filt\n (match p v with\n | None -> accu\n | Some v -> add accu v ~compare_elt)\n l)\n r\n in\n filt Empty s\n ;;\n\n let partition_tf s ~f:p ~compare_elt =\n let rec part ((t, f) as accu) = function\n | Empty -> accu\n | Leaf v -> if p v then add t v ~compare_elt, f else t, add f v ~compare_elt\n | Node (l, v, r, _, _) ->\n part\n (part (if p v then add t v ~compare_elt, f else t, add f v ~compare_elt) l)\n r\n in\n part (Empty, Empty) s\n ;;\n\n let rec elements_aux accu = function\n | Empty -> accu\n | Leaf v -> v :: accu\n | Node (l, v, r, _, _) -> elements_aux (v :: elements_aux accu r) l\n ;;\n\n let elements s = elements_aux [] s\n\n let choose t =\n match t with\n | Empty -> None\n | Leaf v -> Some v\n | Node (_, v, _, _, _) -> Some v\n ;;\n\n let choose_exn =\n let not_found = Not_found_s (Atom \"Set.choose_exn: empty set\") in\n let choose_exn t =\n match choose t with\n | None -> raise not_found\n | Some v -> v\n in\n (* named to preserve symbol in compiled binary *)\n choose_exn\n ;;\n\n let of_list lst ~compare_elt =\n List.fold lst ~init:empty ~f:(fun t x -> add t x ~compare_elt)\n ;;\n\n let to_list s = elements s\n\n let of_array a ~compare_elt =\n Array.fold a ~init:empty ~f:(fun t x -> add t x ~compare_elt)\n ;;\n\n (* faster but equivalent to [Array.of_list (to_list t)] *)\n let to_array = function\n | Empty -> [||]\n | Leaf v -> [| v |]\n | Node (l, v, r, _, s) ->\n let res = Array.create ~len:s v in\n let pos_ref = ref 0 in\n let rec loop = function\n (* Invariant: on entry and on exit to [loop], !pos_ref is the next\n available cell in the array. *)\n | Empty -> ()\n | Leaf v ->\n res.(!pos_ref) <- v;\n incr pos_ref\n | Node (l, v, r, _, _) ->\n loop l;\n res.(!pos_ref) <- v;\n incr pos_ref;\n loop r\n in\n loop l;\n (* res.(!pos_ref) is already initialized (by Array.create ~len:above). *)\n incr pos_ref;\n loop r;\n res\n ;;\n\n let map t ~f ~compare_elt = fold t ~init:empty ~f:(fun t x -> add t (f x) ~compare_elt)\n\n let group_by set ~equiv ~compare_elt =\n let rec loop set equiv_classes =\n if is_empty set\n then equiv_classes\n else (\n let x = choose_exn set in\n let equiv_x, not_equiv_x =\n partition_tf set ~f:(fun elt -> phys_equal x elt || equiv x elt) ~compare_elt\n in\n loop not_equiv_x (equiv_x :: equiv_classes))\n in\n loop set []\n ;;\n\n let rec find t ~f =\n match t with\n | Empty -> None\n | Leaf v -> if f v then Some v else None\n | Node (l, v, r, _, _) ->\n if f v\n then Some v\n else (\n match find l ~f with\n | None -> find r ~f\n | Some _ as r -> r)\n ;;\n\n let rec find_map t ~f =\n match t with\n | Empty -> None\n | Leaf v -> f v\n | Node (l, v, r, _, _) ->\n (match f v with\n | Some _ as r -> r\n | None ->\n (match find_map l ~f with\n | None -> find_map r ~f\n | Some _ as r -> r))\n ;;\n\n let find_exn t ~f =\n match find t ~f with\n | None -> failwith \"Set.find_exn failed to find a matching element\"\n | Some e -> e\n ;;\n\n let rec nth t i =\n match t with\n | Empty -> None\n | Leaf v -> if i = 0 then Some v else None\n | Node (l, v, r, _, s) ->\n if i >= s\n then None\n else (\n let l_size = length l in\n let c = Poly.compare i l_size in\n if c < 0 then nth l i else if c = 0 then Some v else nth r (i - l_size - 1))\n ;;\n\n let stable_dedup_list xs ~compare_elt =\n let rec loop xs leftovers already_seen =\n match xs with\n | [] -> List.rev leftovers\n | hd :: tl ->\n if mem already_seen hd ~compare_elt\n then loop tl leftovers already_seen\n else loop tl (hd :: leftovers) (add already_seen hd ~compare_elt)\n in\n loop xs [] empty\n ;;\n\n let t_of_sexp_direct a_of_sexp sexp ~compare_elt =\n match sexp with\n | Sexp.List lst ->\n let elt_lst = List.map lst ~f:a_of_sexp in\n let set = of_list elt_lst ~compare_elt in\n if length set = List.length lst\n then set\n else (\n let set = ref empty in\n List.iter2_exn lst elt_lst ~f:(fun el_sexp el ->\n if mem !set el ~compare_elt\n then of_sexp_error \"Set.t_of_sexp: duplicate element in set\" el_sexp\n else set := add !set el ~compare_elt);\n assert false)\n | sexp -> of_sexp_error \"Set.t_of_sexp: list needed\" sexp\n ;;\n\n let sexp_of_t sexp_of_a t =\n Sexp.List (fold_right t ~init:[] ~f:(fun el acc -> sexp_of_a el :: acc))\n ;;\n\n module Named = struct\n type nonrec ('a, 'cmp) t =\n { tree : 'a t\n ; name : string\n }\n\n let is_subset (subset : _ t) ~of_:(superset : _ t) ~sexp_of_elt ~compare_elt =\n let invalid_elements = diff subset.tree superset.tree ~compare_elt in\n if is_empty invalid_elements\n then Ok ()\n else (\n let invalid_elements_sexp = sexp_of_t sexp_of_elt invalid_elements in\n Or_error.error_s\n (Sexp.message\n (subset.name ^ \" is not a subset of \" ^ superset.name)\n [ \"invalid_elements\", invalid_elements_sexp ]))\n ;;\n\n let equal s1 s2 ~sexp_of_elt ~compare_elt =\n Or_error.combine_errors_unit\n [ is_subset s1 ~of_:s2 ~sexp_of_elt ~compare_elt\n ; is_subset s2 ~of_:s1 ~sexp_of_elt ~compare_elt\n ]\n ;;\n end\nend\n\ntype ('a, 'comparator) t =\n { (* [comparator] is the first field so that polymorphic equality fails on a map due\n to the functional value in the comparator.\n Note that this does not affect polymorphic [compare]: that still produces\n nonsense. *)\n comparator : ('a, 'comparator) Comparator.t\n ; tree : 'a Tree0.t\n }\n\ntype ('a, 'comparator) tree = 'a Tree0.t\n\nlet like { tree = _; comparator } tree = { tree; comparator }\nlet compare_elt t = t.comparator.Comparator.compare\n\nmodule Accessors = struct\n let comparator t = t.comparator\n let invariants t = Tree0.invariants t.tree ~compare_elt:(compare_elt t)\n let length t = Tree0.length t.tree\n let is_empty t = Tree0.is_empty t.tree\n let elements t = Tree0.elements t.tree\n let min_elt t = Tree0.min_elt t.tree\n let min_elt_exn t = Tree0.min_elt_exn t.tree\n let max_elt t = Tree0.max_elt t.tree\n let max_elt_exn t = Tree0.max_elt_exn t.tree\n let choose t = Tree0.choose t.tree\n let choose_exn t = Tree0.choose_exn t.tree\n let to_list t = Tree0.to_list t.tree\n let to_array t = Tree0.to_array t.tree\n let fold t ~init ~f = Tree0.fold t.tree ~init ~f\n let fold_until t ~init ~f = Tree0.fold_until t.tree ~init ~f\n let fold_right t ~init ~f = Tree0.fold_right t.tree ~init ~f\n let fold_result t ~init ~f = Container.fold_result ~fold ~init ~f t\n let iter t ~f = Tree0.iter t.tree ~f\n let iter2 a b ~f = Tree0.iter2 a.tree b.tree ~f ~compare_elt:(compare_elt a)\n let exists t ~f = Tree0.exists t.tree ~f\n let for_all t ~f = Tree0.for_all t.tree ~f\n let count t ~f = Tree0.count t.tree ~f\n let sum m t ~f = Tree0.sum m t.tree ~f\n let find t ~f = Tree0.find t.tree ~f\n let find_exn t ~f = Tree0.find_exn t.tree ~f\n let find_map t ~f = Tree0.find_map t.tree ~f\n let mem t a = Tree0.mem t.tree a ~compare_elt:(compare_elt t)\n let filter t ~f = like t (Tree0.filter t.tree ~f ~compare_elt:(compare_elt t))\n let add t a = like t (Tree0.add t.tree a ~compare_elt:(compare_elt t))\n let remove t a = like t (Tree0.remove t.tree a ~compare_elt:(compare_elt t))\n let union t1 t2 = like t1 (Tree0.union t1.tree t2.tree ~compare_elt:(compare_elt t1))\n let inter t1 t2 = like t1 (Tree0.inter t1.tree t2.tree ~compare_elt:(compare_elt t1))\n let diff t1 t2 = like t1 (Tree0.diff t1.tree t2.tree ~compare_elt:(compare_elt t1))\n\n let symmetric_diff t1 t2 =\n Tree0.symmetric_diff t1.tree t2.tree ~compare_elt:(compare_elt t1)\n ;;\n\n let compare_direct t1 t2 = Tree0.compare (compare_elt t1) t1.tree t2.tree\n let equal t1 t2 = Tree0.equal t1.tree t2.tree ~compare_elt:(compare_elt t1)\n\n let is_subset t ~of_ =\n Tree0.is_subset t.tree ~of_:of_.tree ~compare_elt:(compare_elt t)\n ;;\n\n let are_disjoint t1 t2 =\n Tree0.are_disjoint t1.tree t2.tree ~compare_elt:(compare_elt t1)\n ;;\n\n module Named = struct\n type nonrec ('a, 'cmp) t =\n { set : ('a, 'cmp) t\n ; name : string\n }\n\n let to_named_tree { set; name } = { Tree0.Named.tree = set.tree; name }\n\n let is_subset (subset : (_, _) t) ~of_:(superset : (_, _) t) =\n Tree0.Named.is_subset\n (to_named_tree subset)\n ~of_:(to_named_tree superset)\n ~compare_elt:(compare_elt subset.set)\n ~sexp_of_elt:subset.set.comparator.sexp_of_t\n ;;\n\n let equal t1 t2 =\n Or_error.combine_errors_unit [ is_subset t1 ~of_:t2; is_subset t2 ~of_:t1 ]\n ;;\n end\n\n let partition_tf t ~f =\n let tree_t, tree_f = Tree0.partition_tf t.tree ~f ~compare_elt:(compare_elt t) in\n like t tree_t, like t tree_f\n ;;\n\n let split t a =\n let tree1, b, tree2 = Tree0.split t.tree a ~compare_elt:(compare_elt t) in\n like t tree1, b, like t tree2\n ;;\n\n let group_by t ~equiv =\n List.map (Tree0.group_by t.tree ~equiv ~compare_elt:(compare_elt t)) ~f:(like t)\n ;;\n\n let nth t i = Tree0.nth t.tree i\n\n let remove_index t i =\n like t (Tree0.remove_index t.tree i ~compare_elt:(compare_elt t))\n ;;\n\n let sexp_of_t sexp_of_a _ t = Tree0.sexp_of_t sexp_of_a t.tree\n\n let to_sequence ?order ?greater_or_equal_to ?less_or_equal_to t =\n Tree0.to_sequence t.comparator ?order ?greater_or_equal_to ?less_or_equal_to t.tree\n ;;\n\n let binary_search t ~compare how v = Tree0.binary_search t.tree ~compare how v\n\n let binary_search_segmented t ~segment_of how =\n Tree0.binary_search_segmented t.tree ~segment_of how\n ;;\n\n let merge_to_sequence ?order ?greater_or_equal_to ?less_or_equal_to t t' =\n Tree0.merge_to_sequence\n t.comparator\n ?order\n ?greater_or_equal_to\n ?less_or_equal_to\n t.tree\n t'.tree\n ;;\n\n let hash_fold_direct hash_fold_key state t =\n Tree0.hash_fold_t_ignoring_structure hash_fold_key state t.tree\n ;;\nend\n\ninclude Accessors\n\nlet compare _ _ t1 t2 = compare_direct t1 t2\n\nmodule Tree = struct\n type ('a, 'comparator) t = ('a, 'comparator) tree\n\n let ce comparator = comparator.Comparator.compare\n\n let t_of_sexp_direct ~comparator a_of_sexp sexp =\n Tree0.t_of_sexp_direct ~compare_elt:(ce comparator) a_of_sexp sexp\n ;;\n\n let empty_without_value_restriction = Tree0.empty\n let empty ~comparator:_ = empty_without_value_restriction\n let singleton ~comparator:_ e = Tree0.singleton e\n let length t = Tree0.length t\n let invariants ~comparator t = Tree0.invariants t ~compare_elt:(ce comparator)\n let is_empty t = Tree0.is_empty t\n let elements t = Tree0.elements t\n let min_elt t = Tree0.min_elt t\n let min_elt_exn t = Tree0.min_elt_exn t\n let max_elt t = Tree0.max_elt t\n let max_elt_exn t = Tree0.max_elt_exn t\n let choose t = Tree0.choose t\n let choose_exn t = Tree0.choose_exn t\n let to_list t = Tree0.to_list t\n let to_array t = Tree0.to_array t\n let iter t ~f = Tree0.iter t ~f\n let exists t ~f = Tree0.exists t ~f\n let for_all t ~f = Tree0.for_all t ~f\n let count t ~f = Tree0.count t ~f\n let sum m t ~f = Tree0.sum m t ~f\n let find t ~f = Tree0.find t ~f\n let find_exn t ~f = Tree0.find_exn t ~f\n let find_map t ~f = Tree0.find_map t ~f\n let fold t ~init ~f = Tree0.fold t ~init ~f\n let fold_until t ~init ~f = Tree0.fold_until t ~init ~f\n let fold_right t ~init ~f = Tree0.fold_right t ~init ~f\n let map ~comparator t ~f = Tree0.map t ~f ~compare_elt:(ce comparator)\n let filter ~comparator t ~f = Tree0.filter t ~f ~compare_elt:(ce comparator)\n let filter_map ~comparator t ~f = Tree0.filter_map t ~f ~compare_elt:(ce comparator)\n\n let partition_tf ~comparator t ~f =\n Tree0.partition_tf t ~f ~compare_elt:(ce comparator)\n ;;\n\n let iter2 ~comparator a b ~f = Tree0.iter2 a b ~f ~compare_elt:(ce comparator)\n let mem ~comparator t a = Tree0.mem t a ~compare_elt:(ce comparator)\n let add ~comparator t a = Tree0.add t a ~compare_elt:(ce comparator)\n let remove ~comparator t a = Tree0.remove t a ~compare_elt:(ce comparator)\n let union ~comparator t1 t2 = Tree0.union t1 t2 ~compare_elt:(ce comparator)\n let inter ~comparator t1 t2 = Tree0.inter t1 t2 ~compare_elt:(ce comparator)\n let diff ~comparator t1 t2 = Tree0.diff t1 t2 ~compare_elt:(ce comparator)\n\n let symmetric_diff ~comparator t1 t2 =\n Tree0.symmetric_diff t1 t2 ~compare_elt:(ce comparator)\n ;;\n\n let compare_direct ~comparator t1 t2 = Tree0.compare (ce comparator) t1 t2\n let equal ~comparator t1 t2 = Tree0.equal t1 t2 ~compare_elt:(ce comparator)\n let is_subset ~comparator t ~of_ = Tree0.is_subset t ~of_ ~compare_elt:(ce comparator)\n\n let are_disjoint ~comparator t1 t2 =\n Tree0.are_disjoint t1 t2 ~compare_elt:(ce comparator)\n ;;\n\n let of_list ~comparator l = Tree0.of_list l ~compare_elt:(ce comparator)\n let of_array ~comparator a = Tree0.of_array a ~compare_elt:(ce comparator)\n\n let of_sorted_array_unchecked ~comparator a =\n Tree0.of_sorted_array_unchecked a ~compare_elt:(ce comparator)\n ;;\n\n let of_increasing_iterator_unchecked ~comparator:_ ~len ~f =\n Tree0.of_increasing_iterator_unchecked ~len ~f\n ;;\n\n let of_sorted_array ~comparator a =\n Tree0.of_sorted_array a ~compare_elt:(ce comparator)\n ;;\n\n let union_list ~comparator l = Tree0.union_list l ~to_tree:Fn.id ~comparator\n\n let stable_dedup_list ~comparator xs =\n Tree0.stable_dedup_list xs ~compare_elt:(ce comparator)\n ;;\n\n let group_by ~comparator t ~equiv =\n Tree0.group_by t ~equiv ~compare_elt:(ce comparator)\n ;;\n\n let split ~comparator t a = Tree0.split t a ~compare_elt:(ce comparator)\n let nth t i = Tree0.nth t i\n let remove_index ~comparator t i = Tree0.remove_index t i ~compare_elt:(ce comparator)\n let sexp_of_t sexp_of_a _ t = Tree0.sexp_of_t sexp_of_a t\n let to_tree t = t\n let of_tree ~comparator:_ t = t\n\n let to_sequence ~comparator ?order ?greater_or_equal_to ?less_or_equal_to t =\n Tree0.to_sequence comparator ?order ?greater_or_equal_to ?less_or_equal_to t\n ;;\n\n let binary_search ~comparator:_ t ~compare how v = Tree0.binary_search t ~compare how v\n\n let binary_search_segmented ~comparator:_ t ~segment_of how =\n Tree0.binary_search_segmented t ~segment_of how\n ;;\n\n let merge_to_sequence ~comparator ?order ?greater_or_equal_to ?less_or_equal_to t t' =\n Tree0.merge_to_sequence comparator ?order ?greater_or_equal_to ?less_or_equal_to t t'\n ;;\n\n let fold_result t ~init ~f = Container.fold_result ~fold ~init ~f t\n\n module Named = struct\n include Tree0.Named\n\n let is_subset ~comparator t1 ~of_:t2 =\n Tree0.Named.is_subset\n t1\n ~of_:t2\n ~compare_elt:(ce comparator)\n ~sexp_of_elt:comparator.Comparator.sexp_of_t\n ;;\n\n let equal ~comparator t1 t2 =\n Tree0.Named.equal\n t1\n t2\n ~compare_elt:(ce comparator)\n ~sexp_of_elt:comparator.Comparator.sexp_of_t\n ;;\n end\nend\n\nmodule Using_comparator = struct\n type nonrec ('elt, 'cmp) t = ('elt, 'cmp) t\n\n include Accessors\n\n let to_tree t = t.tree\n let of_tree ~comparator tree = { comparator; tree }\n\n let t_of_sexp_direct ~comparator a_of_sexp sexp =\n of_tree\n ~comparator\n (Tree0.t_of_sexp_direct ~compare_elt:comparator.compare a_of_sexp sexp)\n ;;\n\n let empty ~comparator = { comparator; tree = Tree0.empty }\n\n module Empty_without_value_restriction (Elt : Comparator.S1) = struct\n let empty = { comparator = Elt.comparator; tree = Tree0.empty }\n end\n\n let singleton ~comparator e = { comparator; tree = Tree0.singleton e }\n\n let union_list ~comparator l =\n of_tree ~comparator (Tree0.union_list ~comparator ~to_tree l)\n ;;\n\n let of_sorted_array_unchecked ~comparator array =\n let tree =\n Tree0.of_sorted_array_unchecked array ~compare_elt:comparator.Comparator.compare\n in\n { comparator; tree }\n ;;\n\n let of_increasing_iterator_unchecked ~comparator ~len ~f =\n of_tree ~comparator (Tree0.of_increasing_iterator_unchecked ~len ~f)\n ;;\n\n let of_sorted_array ~comparator array =\n Or_error.Monad_infix.(\n Tree0.of_sorted_array array ~compare_elt:comparator.Comparator.compare\n >>| fun tree -> { comparator; tree })\n ;;\n\n let of_list ~comparator l =\n { comparator; tree = Tree0.of_list l ~compare_elt:comparator.Comparator.compare }\n ;;\n\n let of_array ~comparator a =\n { comparator; tree = Tree0.of_array a ~compare_elt:comparator.Comparator.compare }\n ;;\n\n let stable_dedup_list ~comparator xs =\n Tree0.stable_dedup_list xs ~compare_elt:comparator.Comparator.compare\n ;;\n\n let map ~comparator t ~f =\n { comparator; tree = Tree0.map t.tree ~f ~compare_elt:comparator.Comparator.compare }\n ;;\n\n let filter_map ~comparator t ~f =\n { comparator\n ; tree = Tree0.filter_map t.tree ~f ~compare_elt:comparator.Comparator.compare\n }\n ;;\n\n module Tree = Tree\nend\n\ntype ('elt, 'cmp) comparator =\n (module Comparator.S with type t = 'elt and type comparator_witness = 'cmp)\n\nlet comparator_s (type k cmp) t : (k, cmp) comparator =\n (module struct\n type t = k\n type comparator_witness = cmp\n\n let comparator = t.comparator\n end)\n;;\n\nlet to_comparator (type elt cmp) ((module M) : (elt, cmp) comparator) = M.comparator\nlet empty m = Using_comparator.empty ~comparator:(to_comparator m)\nlet singleton m a = Using_comparator.singleton ~comparator:(to_comparator m) a\nlet union_list m a = Using_comparator.union_list ~comparator:(to_comparator m) a\n\nlet of_sorted_array_unchecked m a =\n Using_comparator.of_sorted_array_unchecked ~comparator:(to_comparator m) a\n;;\n\nlet of_increasing_iterator_unchecked m ~len ~f =\n Using_comparator.of_increasing_iterator_unchecked ~comparator:(to_comparator m) ~len ~f\n;;\n\nlet of_sorted_array m a =\n Using_comparator.of_sorted_array ~comparator:(to_comparator m) a\n;;\n\nlet of_list m a = Using_comparator.of_list ~comparator:(to_comparator m) a\nlet of_array m a = Using_comparator.of_array ~comparator:(to_comparator m) a\n\nlet stable_dedup_list m a =\n Using_comparator.stable_dedup_list ~comparator:(to_comparator m) a\n;;\n\nlet map m a ~f = Using_comparator.map ~comparator:(to_comparator m) a ~f\nlet filter_map m a ~f = Using_comparator.filter_map ~comparator:(to_comparator m) a ~f\n\nmodule M (Elt : sig\n type t\n type comparator_witness\n end) =\nstruct\n type nonrec t = (Elt.t, Elt.comparator_witness) t\nend\n\nmodule type Sexp_of_m = sig\n type t [@@deriving_inline sexp_of]\n\n val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t\n\n [@@@end]\nend\n\nmodule type M_of_sexp = sig\n type t [@@deriving_inline of_sexp]\n\n val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t\n\n [@@@end]\n\n include Comparator.S with type t := t\nend\n\nmodule type Compare_m = sig end\nmodule type Equal_m = sig end\nmodule type Hash_fold_m = Hasher.S\n\nlet sexp_of_m__t (type elt) (module Elt : Sexp_of_m with type t = elt) t =\n sexp_of_t Elt.sexp_of_t (fun _ -> Sexp.Atom \"_\") t\n;;\n\nlet m__t_of_sexp\n (type elt cmp)\n (module Elt : M_of_sexp with type t = elt and type comparator_witness = cmp)\n sexp\n =\n Using_comparator.t_of_sexp_direct ~comparator:Elt.comparator Elt.t_of_sexp sexp\n;;\n\nlet compare_m__t (module Elt : Compare_m) t1 t2 = compare_direct t1 t2\nlet equal_m__t (module Elt : Equal_m) t1 t2 = equal t1 t2\n\nlet hash_fold_m__t (type elt) (module Elt : Hash_fold_m with type t = elt) state =\n hash_fold_direct Elt.hash_fold_t state\n;;\n\nlet hash_m__t folder t =\n let state = hash_fold_m__t folder (Hash.create ()) t in\n Hash.get_hash_value state\n;;\n\nmodule Poly = struct\n type comparator_witness = Comparator.Poly.comparator_witness\n type nonrec ('elt, 'cmp) set = ('elt, comparator_witness) t\n type nonrec 'elt t = ('elt, comparator_witness) t\n type nonrec 'elt tree = ('elt, comparator_witness) tree\n type nonrec 'elt named = ('elt, comparator_witness) Named.t\n\n include Accessors\n\n let comparator = Comparator.Poly.comparator\n\n include Using_comparator.Empty_without_value_restriction (Comparator.Poly)\n\n let singleton a = Using_comparator.singleton ~comparator a\n let union_list a = Using_comparator.union_list ~comparator a\n\n let of_sorted_array_unchecked a =\n Using_comparator.of_sorted_array_unchecked ~comparator a\n ;;\n\n let of_increasing_iterator_unchecked ~len ~f =\n Using_comparator.of_increasing_iterator_unchecked ~comparator ~len ~f\n ;;\n\n let of_sorted_array a = Using_comparator.of_sorted_array ~comparator a\n let of_list a = Using_comparator.of_list ~comparator a\n let of_array a = Using_comparator.of_array ~comparator a\n let stable_dedup_list a = Using_comparator.stable_dedup_list ~comparator a\n let map a ~f = Using_comparator.map ~comparator a ~f\n let filter_map a ~f = Using_comparator.filter_map ~comparator a ~f\n let of_tree tree = { comparator; tree }\n let to_tree t = t.tree\nend\n","open! Import\nopen! T\n\nmodule type Elt_plain = sig\n type t [@@deriving_inline compare, sexp_of]\n\n val compare : t -> t -> int\n val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t\n\n [@@@end]\nend\n\nmodule Without_comparator = Map_intf.Without_comparator\nmodule With_comparator = Map_intf.With_comparator\nmodule With_first_class_module = Map_intf.With_first_class_module\ninclude Container_intf.Export\nmodule Merge_to_sequence_element = Sequence.Merge_with_duplicates_element\n\nmodule type Accessors_generic = sig\n include Container.Generic_phantom\n\n type ('a, 'cmp) tree\n\n (** The [options] type is used to make [Accessors_generic] flexible as to whether a\n comparator is required to be passed to certain functions. *)\n type ('a, 'cmp, 'z) options\n\n type 'cmp cmp\n\n val invariants : ('a, 'cmp, ('a, 'cmp) t -> bool) options\n\n (** override [Container]'s [mem] *)\n val mem : ('a, 'cmp, ('a, 'cmp) t -> 'a elt -> bool) options\n\n val add : ('a, 'cmp, ('a, 'cmp) t -> 'a elt -> ('a, 'cmp) t) options\n val remove : ('a, 'cmp, ('a, 'cmp) t -> 'a elt -> ('a, 'cmp) t) options\n val union : ('a, 'cmp, ('a, 'cmp) t -> ('a, 'cmp) t -> ('a, 'cmp) t) options\n val inter : ('a, 'cmp, ('a, 'cmp) t -> ('a, 'cmp) t -> ('a, 'cmp) t) options\n val diff : ('a, 'cmp, ('a, 'cmp) t -> ('a, 'cmp) t -> ('a, 'cmp) t) options\n\n val symmetric_diff\n : ( 'a\n , 'cmp\n , ('a, 'cmp) t -> ('a, 'cmp) t -> ('a elt, 'a elt) Either.t Sequence.t )\n options\n\n val compare_direct : ('a, 'cmp, ('a, 'cmp) t -> ('a, 'cmp) t -> int) options\n val equal : ('a, 'cmp, ('a, 'cmp) t -> ('a, 'cmp) t -> bool) options\n val is_subset : ('a, 'cmp, ('a, 'cmp) t -> of_:('a, 'cmp) t -> bool) options\n val are_disjoint : ('a, 'cmp, ('a, 'cmp) t -> ('a, 'cmp) t -> bool) options\n\n type ('a, 'cmp) named\n\n module Named : sig\n val is_subset\n : ('a, 'cmp, ('a, 'cmp) named -> of_:('a, 'cmp) named -> unit Or_error.t) options\n\n val equal\n : ('a, 'cmp, ('a, 'cmp) named -> ('a, 'cmp) named -> unit Or_error.t) options\n end\n\n val fold_until\n : ('a, _) t\n -> init:'b\n -> f:('b -> 'a elt -> ('b, 'final) Continue_or_stop.t)\n -> finish:('b -> 'final)\n -> 'final\n\n val fold_right : ('a, _) t -> init:'b -> f:('a elt -> 'b -> 'b) -> 'b\n\n val iter2\n : ( 'a\n , 'cmp\n , ('a, 'cmp) t\n -> ('a, 'cmp) t\n -> f:([ `Left of 'a elt | `Right of 'a elt | `Both of 'a elt * 'a elt ] -> unit)\n -> unit )\n options\n\n val filter : ('a, 'cmp, ('a, 'cmp) t -> f:('a elt -> bool) -> ('a, 'cmp) t) options\n\n val partition_tf\n : ( 'a\n , 'cmp\n , ('a, 'cmp) t -> f:('a elt -> bool) -> ('a, 'cmp) t * ('a, 'cmp) t )\n options\n\n val elements : ('a, _) t -> 'a elt list\n val min_elt : ('a, _) t -> 'a elt option\n val min_elt_exn : ('a, _) t -> 'a elt\n val max_elt : ('a, _) t -> 'a elt option\n val max_elt_exn : ('a, _) t -> 'a elt\n val choose : ('a, _) t -> 'a elt option\n val choose_exn : ('a, _) t -> 'a elt\n\n val split\n : ( 'a\n , 'cmp\n , ('a, 'cmp) t -> 'a elt -> ('a, 'cmp) t * 'a elt option * ('a, 'cmp) t )\n options\n\n val group_by\n : ( 'a\n , 'cmp\n , ('a, 'cmp) t -> equiv:('a elt -> 'a elt -> bool) -> ('a, 'cmp) t list )\n options\n\n val find_exn : ('a, _) t -> f:('a elt -> bool) -> 'a elt\n val nth : ('a, _) t -> int -> 'a elt option\n val remove_index : ('a, 'cmp, ('a, 'cmp) t -> int -> ('a, 'cmp) t) options\n val to_tree : ('a, 'cmp) t -> ('a elt, 'cmp) tree\n\n val to_sequence\n : ( 'a\n , 'cmp\n , ?order:[ `Increasing | `Decreasing ]\n -> ?greater_or_equal_to:'a elt\n -> ?less_or_equal_to:'a elt\n -> ('a, 'cmp) t\n -> 'a elt Sequence.t )\n options\n\n val binary_search\n : ( 'a\n , 'cmp\n , ('a, 'cmp) t\n -> compare:('a elt -> 'key -> int)\n -> [ `Last_strictly_less_than\n | `Last_less_than_or_equal_to\n | `Last_equal_to\n | `First_equal_to\n | `First_greater_than_or_equal_to\n | `First_strictly_greater_than\n ]\n -> 'key\n -> 'a elt option )\n options\n\n val binary_search_segmented\n : ( 'a\n , 'cmp\n , ('a, 'cmp) t\n -> segment_of:('a elt -> [ `Left | `Right ])\n -> [ `Last_on_left | `First_on_right ]\n -> 'a elt option )\n options\n\n val merge_to_sequence\n : ( 'a\n , 'cmp\n , ?order:[ `Increasing | `Decreasing ]\n -> ?greater_or_equal_to:'a elt\n -> ?less_or_equal_to:'a elt\n -> ('a, 'cmp) t\n -> ('a, 'cmp) t\n -> ('a elt, 'a elt) Merge_to_sequence_element.t Sequence.t )\n options\nend\n\nmodule type Accessors0 = sig\n include Container.S0\n\n type tree\n type comparator_witness\n\n val invariants : t -> bool\n val mem : t -> elt -> bool\n val add : t -> elt -> t\n val remove : t -> elt -> t\n val union : t -> t -> t\n val inter : t -> t -> t\n val diff : t -> t -> t\n val symmetric_diff : t -> t -> (elt, elt) Either.t Sequence.t\n val compare_direct : t -> t -> int\n val equal : t -> t -> bool\n val is_subset : t -> of_:t -> bool\n val are_disjoint : t -> t -> bool\n\n type named\n\n module Named : sig\n val is_subset : named -> of_:named -> unit Or_error.t\n val equal : named -> named -> unit Or_error.t\n end\n\n val fold_until\n : t\n -> init:'b\n -> f:('b -> elt -> ('b, 'final) Continue_or_stop.t)\n -> finish:('b -> 'final)\n -> 'final\n\n val fold_right : t -> init:'b -> f:(elt -> 'b -> 'b) -> 'b\n\n val iter2\n : t\n -> t\n -> f:([ `Left of elt | `Right of elt | `Both of elt * elt ] -> unit)\n -> unit\n\n val filter : t -> f:(elt -> bool) -> t\n val partition_tf : t -> f:(elt -> bool) -> t * t\n val elements : t -> elt list\n val min_elt : t -> elt option\n val min_elt_exn : t -> elt\n val max_elt : t -> elt option\n val max_elt_exn : t -> elt\n val choose : t -> elt option\n val choose_exn : t -> elt\n val split : t -> elt -> t * elt option * t\n val group_by : t -> equiv:(elt -> elt -> bool) -> t list\n val find_exn : t -> f:(elt -> bool) -> elt\n val nth : t -> int -> elt option\n val remove_index : t -> int -> t\n val to_tree : t -> tree\n\n val to_sequence\n : ?order:[ `Increasing | `Decreasing ]\n -> ?greater_or_equal_to:elt\n -> ?less_or_equal_to:elt\n -> t\n -> elt Sequence.t\n\n val binary_search\n : t\n -> compare:(elt -> 'key -> int)\n -> [ `Last_strictly_less_than\n | `Last_less_than_or_equal_to\n | `Last_equal_to\n | `First_equal_to\n | `First_greater_than_or_equal_to\n | `First_strictly_greater_than\n ]\n -> 'key\n -> elt option\n\n val binary_search_segmented\n : t\n -> segment_of:(elt -> [ `Left | `Right ])\n -> [ `Last_on_left | `First_on_right ]\n -> elt option\n\n val merge_to_sequence\n : ?order:[ `Increasing | `Decreasing ]\n -> ?greater_or_equal_to:elt\n -> ?less_or_equal_to:elt\n -> t\n -> t\n -> (elt, elt) Merge_to_sequence_element.t Sequence.t\nend\n\nmodule type Accessors1 = sig\n include Container.S1\n\n type 'a tree\n type comparator_witness\n\n val invariants : _ t -> bool\n val mem : 'a t -> 'a -> bool\n val add : 'a t -> 'a -> 'a t\n val remove : 'a t -> 'a -> 'a t\n val union : 'a t -> 'a t -> 'a t\n val inter : 'a t -> 'a t -> 'a t\n val diff : 'a t -> 'a t -> 'a t\n val symmetric_diff : 'a t -> 'a t -> ('a, 'a) Either.t Sequence.t\n val compare_direct : 'a t -> 'a t -> int\n val equal : 'a t -> 'a t -> bool\n val is_subset : 'a t -> of_:'a t -> bool\n val are_disjoint : 'a t -> 'a t -> bool\n\n type 'a named\n\n module Named : sig\n val is_subset : 'a named -> of_:'a named -> unit Or_error.t\n val equal : 'a named -> 'a named -> unit Or_error.t\n end\n\n val fold_until\n : 'a t\n -> init:'b\n -> f:('b -> 'a -> ('b, 'final) Continue_or_stop.t)\n -> finish:('b -> 'final)\n -> 'final\n\n val fold_right : 'a t -> init:'b -> f:('a -> 'b -> 'b) -> 'b\n\n val iter2\n : 'a t\n -> 'a t\n -> f:([ `Left of 'a | `Right of 'a | `Both of 'a * 'a ] -> unit)\n -> unit\n\n val filter : 'a t -> f:('a -> bool) -> 'a t\n val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t\n val elements : 'a t -> 'a list\n val min_elt : 'a t -> 'a option\n val min_elt_exn : 'a t -> 'a\n val max_elt : 'a t -> 'a option\n val max_elt_exn : 'a t -> 'a\n val choose : 'a t -> 'a option\n val choose_exn : 'a t -> 'a\n val split : 'a t -> 'a -> 'a t * 'a option * 'a t\n val group_by : 'a t -> equiv:('a -> 'a -> bool) -> 'a t list\n val find_exn : 'a t -> f:('a -> bool) -> 'a\n val nth : 'a t -> int -> 'a option\n val remove_index : 'a t -> int -> 'a t\n val to_tree : 'a t -> 'a tree\n\n val to_sequence\n : ?order:[ `Increasing | `Decreasing ]\n -> ?greater_or_equal_to:'a\n -> ?less_or_equal_to:'a\n -> 'a t\n -> 'a Sequence.t\n\n val binary_search\n : 'a t\n -> compare:('a -> 'key -> int)\n -> [ `Last_strictly_less_than\n | `Last_less_than_or_equal_to\n | `Last_equal_to\n | `First_equal_to\n | `First_greater_than_or_equal_to\n | `First_strictly_greater_than\n ]\n -> 'key\n -> 'a option\n\n val binary_search_segmented\n : 'a t\n -> segment_of:('a -> [ `Left | `Right ])\n -> [ `Last_on_left | `First_on_right ]\n -> 'a option\n\n val merge_to_sequence\n : ?order:[ `Increasing | `Decreasing ]\n -> ?greater_or_equal_to:'a\n -> ?less_or_equal_to:'a\n -> 'a t\n -> 'a t\n -> ('a, 'a) Merge_to_sequence_element.t Sequence.t\nend\n\nmodule type Accessors2 = sig\n include Container.S1_phantom_invariant\n\n type ('a, 'cmp) tree\n\n val invariants : (_, _) t -> bool\n val mem : ('a, _) t -> 'a -> bool\n val add : ('a, 'cmp) t -> 'a -> ('a, 'cmp) t\n val remove : ('a, 'cmp) t -> 'a -> ('a, 'cmp) t\n val union : ('a, 'cmp) t -> ('a, 'cmp) t -> ('a, 'cmp) t\n val inter : ('a, 'cmp) t -> ('a, 'cmp) t -> ('a, 'cmp) t\n val diff : ('a, 'cmp) t -> ('a, 'cmp) t -> ('a, 'cmp) t\n val symmetric_diff : ('a, 'cmp) t -> ('a, 'cmp) t -> ('a, 'a) Either.t Sequence.t\n val compare_direct : ('a, 'cmp) t -> ('a, 'cmp) t -> int\n val equal : ('a, 'cmp) t -> ('a, 'cmp) t -> bool\n val is_subset : ('a, 'cmp) t -> of_:('a, 'cmp) t -> bool\n val are_disjoint : ('a, 'cmp) t -> ('a, 'cmp) t -> bool\n\n type ('a, 'cmp) named\n\n module Named : sig\n val is_subset : ('a, 'cmp) named -> of_:('a, 'cmp) named -> unit Or_error.t\n val equal : ('a, 'cmp) named -> ('a, 'cmp) named -> unit Or_error.t\n end\n\n val fold_until\n : ('a, _) t\n -> init:'b\n -> f:('b -> 'a -> ('b, 'final) Continue_or_stop.t)\n -> finish:('b -> 'final)\n -> 'final\n\n val fold_right : ('a, _) t -> init:'b -> f:('a -> 'b -> 'b) -> 'b\n\n val iter2\n : ('a, 'cmp) t\n -> ('a, 'cmp) t\n -> f:([ `Left of 'a | `Right of 'a | `Both of 'a * 'a ] -> unit)\n -> unit\n\n val filter : ('a, 'cmp) t -> f:('a -> bool) -> ('a, 'cmp) t\n val partition_tf : ('a, 'cmp) t -> f:('a -> bool) -> ('a, 'cmp) t * ('a, 'cmp) t\n val elements : ('a, _) t -> 'a list\n val min_elt : ('a, _) t -> 'a option\n val min_elt_exn : ('a, _) t -> 'a\n val max_elt : ('a, _) t -> 'a option\n val max_elt_exn : ('a, _) t -> 'a\n val choose : ('a, _) t -> 'a option\n val choose_exn : ('a, _) t -> 'a\n val split : ('a, 'cmp) t -> 'a -> ('a, 'cmp) t * 'a option * ('a, 'cmp) t\n val group_by : ('a, 'cmp) t -> equiv:('a -> 'a -> bool) -> ('a, 'cmp) t list\n val find_exn : ('a, _) t -> f:('a -> bool) -> 'a\n val nth : ('a, _) t -> int -> 'a option\n val remove_index : ('a, 'cmp) t -> int -> ('a, 'cmp) t\n val to_tree : ('a, 'cmp) t -> ('a, 'cmp) tree\n\n val to_sequence\n : ?order:[ `Increasing | `Decreasing ]\n -> ?greater_or_equal_to:'a\n -> ?less_or_equal_to:'a\n -> ('a, 'cmp) t\n -> 'a Sequence.t\n\n val binary_search\n : ('a, 'cmp) t\n -> compare:('a -> 'key -> int)\n -> [ `Last_strictly_less_than\n | `Last_less_than_or_equal_to\n | `Last_equal_to\n | `First_equal_to\n | `First_greater_than_or_equal_to\n | `First_strictly_greater_than\n ]\n -> 'key\n -> 'a option\n\n val binary_search_segmented\n : ('a, 'cmp) t\n -> segment_of:('a -> [ `Left | `Right ])\n -> [ `Last_on_left | `First_on_right ]\n -> 'a option\n\n val merge_to_sequence\n : ?order:[ `Increasing | `Decreasing ]\n -> ?greater_or_equal_to:'a\n -> ?less_or_equal_to:'a\n -> ('a, 'cmp) t\n -> ('a, 'cmp) t\n -> ('a, 'a) Merge_to_sequence_element.t Sequence.t\nend\n\nmodule type Accessors2_with_comparator = sig\n include Container.S1_phantom_invariant\n\n type ('a, 'cmp) tree\n\n val invariants : comparator:('a, 'cmp) Comparator.t -> ('a, 'cmp) t -> bool\n val mem : comparator:('a, 'cmp) Comparator.t -> ('a, 'cmp) t -> 'a -> bool\n val add : comparator:('a, 'cmp) Comparator.t -> ('a, 'cmp) t -> 'a -> ('a, 'cmp) t\n val remove : comparator:('a, 'cmp) Comparator.t -> ('a, 'cmp) t -> 'a -> ('a, 'cmp) t\n\n val union\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'cmp) t\n -> ('a, 'cmp) t\n -> ('a, 'cmp) t\n\n val inter\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'cmp) t\n -> ('a, 'cmp) t\n -> ('a, 'cmp) t\n\n val diff\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'cmp) t\n -> ('a, 'cmp) t\n -> ('a, 'cmp) t\n\n val symmetric_diff\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'cmp) t\n -> ('a, 'cmp) t\n -> ('a, 'a) Either.t Sequence.t\n\n val compare_direct\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'cmp) t\n -> ('a, 'cmp) t\n -> int\n\n val equal : comparator:('a, 'cmp) Comparator.t -> ('a, 'cmp) t -> ('a, 'cmp) t -> bool\n\n val is_subset\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'cmp) t\n -> of_:('a, 'cmp) t\n -> bool\n\n val are_disjoint\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'cmp) t\n -> ('a, 'cmp) t\n -> bool\n\n type ('a, 'cmp) named\n\n module Named : sig\n val is_subset\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'cmp) named\n -> of_:('a, 'cmp) named\n -> unit Or_error.t\n\n val equal\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'cmp) named\n -> ('a, 'cmp) named\n -> unit Or_error.t\n end\n\n val fold_until\n : ('a, _) t\n -> init:'accum\n -> f:('accum -> 'a -> ('accum, 'final) Continue_or_stop.t)\n -> finish:('accum -> 'final)\n -> 'final\n\n val fold_right : ('a, _) t -> init:'accum -> f:('a -> 'accum -> 'accum) -> 'accum\n\n val iter2\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'cmp) t\n -> ('a, 'cmp) t\n -> f:([ `Left of 'a | `Right of 'a | `Both of 'a * 'a ] -> unit)\n -> unit\n\n val filter\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'cmp) t\n -> f:('a -> bool)\n -> ('a, 'cmp) t\n\n val partition_tf\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'cmp) t\n -> f:('a -> bool)\n -> ('a, 'cmp) t * ('a, 'cmp) t\n\n val elements : ('a, _) t -> 'a list\n val min_elt : ('a, _) t -> 'a option\n val min_elt_exn : ('a, _) t -> 'a\n val max_elt : ('a, _) t -> 'a option\n val max_elt_exn : ('a, _) t -> 'a\n val choose : ('a, _) t -> 'a option\n val choose_exn : ('a, _) t -> 'a\n\n val split\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'cmp) t\n -> 'a\n -> ('a, 'cmp) t * 'a option * ('a, 'cmp) t\n\n val group_by\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'cmp) t\n -> equiv:('a -> 'a -> bool)\n -> ('a, 'cmp) t list\n\n val find_exn : ('a, _) t -> f:('a -> bool) -> 'a\n val nth : ('a, _) t -> int -> 'a option\n\n val remove_index\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'cmp) t\n -> int\n -> ('a, 'cmp) t\n\n val to_tree : ('a, 'cmp) t -> ('a, 'cmp) tree\n\n val to_sequence\n : comparator:('a, 'cmp) Comparator.t\n -> ?order:[ `Increasing | `Decreasing ]\n -> ?greater_or_equal_to:'a\n -> ?less_or_equal_to:'a\n -> ('a, 'cmp) t\n -> 'a Sequence.t\n\n val binary_search\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'cmp) t\n -> compare:('a -> 'key -> int)\n -> [ `Last_strictly_less_than\n | `Last_less_than_or_equal_to\n | `Last_equal_to\n | `First_equal_to\n | `First_greater_than_or_equal_to\n | `First_strictly_greater_than\n ]\n -> 'key\n -> 'a option\n\n val binary_search_segmented\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'cmp) t\n -> segment_of:('a -> [ `Left | `Right ])\n -> [ `Last_on_left | `First_on_right ]\n -> 'a option\n\n val merge_to_sequence\n : comparator:('a, 'cmp) Comparator.t\n -> ?order:[ `Increasing | `Decreasing ]\n -> ?greater_or_equal_to:'a\n -> ?less_or_equal_to:'a\n -> ('a, 'cmp) t\n -> ('a, 'cmp) t\n -> ('a, 'a) Merge_to_sequence_element.t Sequence.t\nend\n\n(** Consistency checks (same as in [Container]). *)\nmodule Check_accessors\n (T : T2)\n (Tree : T2)\n (Elt : T1)\n (Named : T2)\n (Cmp : T1)\n (Options : T3)\n (M : Accessors_generic\n with type ('a, 'b, 'c) options := ('a, 'b, 'c) Options.t\n with type ('a, 'b) t := ('a, 'b) T.t\n with type ('a, 'b) tree := ('a, 'b) Tree.t\n with type 'a elt := 'a Elt.t\n with type 'cmp cmp := 'cmp Cmp.t\n with type ('a, 'b) named := ('a, 'b) Named.t) =\nstruct end\n\nmodule Check_accessors0 (M : Accessors0) =\n Check_accessors\n (struct\n type ('a, 'b) t = M.t\n end)\n (struct\n type ('a, 'b) t = M.tree\n end)\n (struct\n type 'a t = M.elt\n end)\n (struct\n type ('a, 'b) t = M.named\n end)\n (struct\n type 'a t = M.comparator_witness\n end)\n (Without_comparator)\n (M)\n\nmodule Check_accessors1 (M : Accessors1) =\n Check_accessors\n (struct\n type ('a, 'b) t = 'a M.t\n end)\n (struct\n type ('a, 'b) t = 'a M.tree\n end)\n (struct\n type 'a t = 'a\n end)\n (struct\n type ('a, 'b) t = 'a M.named\n end)\n (struct\n type 'a t = M.comparator_witness\n end)\n (Without_comparator)\n (M)\n\nmodule Check_accessors2 (M : Accessors2) =\n Check_accessors\n (struct\n type ('a, 'b) t = ('a, 'b) M.t\n end)\n (struct\n type ('a, 'b) t = ('a, 'b) M.tree\n end)\n (struct\n type 'a t = 'a\n end)\n (struct\n type ('a, 'b) t = ('a, 'b) M.named\n end)\n (struct\n type 'a t = 'a\n end)\n (Without_comparator)\n (M)\n\nmodule Check_accessors2_with_comparator (M : Accessors2_with_comparator) =\n Check_accessors\n (struct\n type ('a, 'b) t = ('a, 'b) M.t\n end)\n (struct\n type ('a, 'b) t = ('a, 'b) M.tree\n end)\n (struct\n type 'a t = 'a\n end)\n (struct\n type ('a, 'b) t = ('a, 'b) M.named\n end)\n (struct\n type 'a t = 'a\n end)\n (With_comparator)\n (M)\n\nmodule type Creators_generic = sig\n type ('a, 'cmp) t\n type ('a, 'cmp) set\n type ('a, 'cmp) tree\n type 'a elt\n type ('a, 'cmp, 'z) options\n type 'cmp cmp\n\n val empty : ('a, 'cmp, ('a, 'cmp) t) options\n val singleton : ('a, 'cmp, 'a elt -> ('a, 'cmp) t) options\n val union_list : ('a, 'cmp, ('a, 'cmp) t list -> ('a, 'cmp) t) options\n val of_list : ('a, 'cmp, 'a elt list -> ('a, 'cmp) t) options\n val of_array : ('a, 'cmp, 'a elt array -> ('a, 'cmp) t) options\n val of_sorted_array : ('a, 'cmp, 'a elt array -> ('a, 'cmp) t Or_error.t) options\n val of_sorted_array_unchecked : ('a, 'cmp, 'a elt array -> ('a, 'cmp) t) options\n\n val of_increasing_iterator_unchecked\n : ('a, 'cmp, len:int -> f:(int -> 'a elt) -> ('a, 'cmp) t) options\n\n val stable_dedup_list : ('a, _, 'a elt list -> 'a elt list) options\n\n (** The types of [map] and [filter_map] are subtle. The input set, [('a, _) set],\n reflects the fact that these functions take a set of *any* type, with any\n comparator, while the output set, [('b, 'cmp) t], reflects that the output set has\n the particular ['cmp] of the creation function. The comparator can come in one of\n three ways, depending on which set module is used\n\n - [Set.map] -- comparator comes as an argument\n - [Set.Poly.map] -- comparator is polymorphic comparison\n - [Foo.Set.map] -- comparator is [Foo.comparator] *)\n val map : ('b, 'cmp, ('a, _) set -> f:('a -> 'b elt) -> ('b, 'cmp) t) options\n\n val filter_map\n : ('b, 'cmp, ('a, _) set -> f:('a -> 'b elt option) -> ('b, 'cmp) t) options\n\n val of_tree : ('a, 'cmp, ('a elt, 'cmp) tree -> ('a, 'cmp) t) options\nend\n\nmodule type Creators0 = sig\n type ('a, 'cmp) set\n type t\n type tree\n type elt\n type comparator_witness\n\n val empty : t\n val singleton : elt -> t\n val union_list : t list -> t\n val of_list : elt list -> t\n val of_array : elt array -> t\n val of_sorted_array : elt array -> t Or_error.t\n val of_sorted_array_unchecked : elt array -> t\n val of_increasing_iterator_unchecked : len:int -> f:(int -> elt) -> t\n val stable_dedup_list : elt list -> elt list\n val map : ('a, _) set -> f:('a -> elt) -> t\n val filter_map : ('a, _) set -> f:('a -> elt option) -> t\n val of_tree : tree -> t\nend\n\nmodule type Creators1 = sig\n type ('a, 'cmp) set\n type 'a t\n type 'a tree\n type comparator_witness\n\n val empty : 'a t\n val singleton : 'a -> 'a t\n val union_list : 'a t list -> 'a t\n val of_list : 'a list -> 'a t\n val of_array : 'a array -> 'a t\n val of_sorted_array : 'a array -> 'a t Or_error.t\n val of_sorted_array_unchecked : 'a array -> 'a t\n val of_increasing_iterator_unchecked : len:int -> f:(int -> 'a) -> 'a t\n val stable_dedup_list : 'a list -> 'a list\n val map : ('a, _) set -> f:('a -> 'b) -> 'b t\n val filter_map : ('a, _) set -> f:('a -> 'b option) -> 'b t\n val of_tree : 'a tree -> 'a t\nend\n\nmodule type Creators2 = sig\n type ('a, 'cmp) set\n type ('a, 'cmp) t\n type ('a, 'cmp) tree\n\n val empty : ('a, 'cmp) t\n val singleton : 'a -> ('a, 'cmp) t\n val union_list : ('a, 'cmp) t list -> ('a, 'cmp) t\n val of_list : 'a list -> ('a, 'cmp) t\n val of_array : 'a array -> ('a, 'cmp) t\n val of_sorted_array : 'a array -> ('a, 'cmp) t Or_error.t\n val of_sorted_array_unchecked : 'a array -> ('a, 'cmp) t\n val of_increasing_iterator_unchecked : len:int -> f:(int -> 'a) -> ('a, 'cmp) t\n val stable_dedup_list : 'a list -> 'a list\n val map : ('a, _) set -> f:('a -> 'b) -> ('b, 'cmp) t\n val filter_map : ('a, _) set -> f:('a -> 'b option) -> ('b, 'cmp) t\n val of_tree : ('a, 'cmp) tree -> ('a, 'cmp) t\nend\n\nmodule type Creators2_with_comparator = sig\n type ('a, 'cmp) set\n type ('a, 'cmp) t\n type ('a, 'cmp) tree\n\n val empty : comparator:('a, 'cmp) Comparator.t -> ('a, 'cmp) t\n val singleton : comparator:('a, 'cmp) Comparator.t -> 'a -> ('a, 'cmp) t\n\n val union_list\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'cmp) t list\n -> ('a, 'cmp) t\n\n val of_list : comparator:('a, 'cmp) Comparator.t -> 'a list -> ('a, 'cmp) t\n val of_array : comparator:('a, 'cmp) Comparator.t -> 'a array -> ('a, 'cmp) t\n\n val of_sorted_array\n : comparator:('a, 'cmp) Comparator.t\n -> 'a array\n -> ('a, 'cmp) t Or_error.t\n\n val of_sorted_array_unchecked\n : comparator:('a, 'cmp) Comparator.t\n -> 'a array\n -> ('a, 'cmp) t\n\n val of_increasing_iterator_unchecked\n : comparator:('a, 'cmp) Comparator.t\n -> len:int\n -> f:(int -> 'a)\n -> ('a, 'cmp) t\n\n val stable_dedup_list : comparator:('a, 'cmp) Comparator.t -> 'a list -> 'a list\n\n val map\n : comparator:('b, 'cmp) Comparator.t\n -> ('a, _) set\n -> f:('a -> 'b)\n -> ('b, 'cmp) t\n\n val filter_map\n : comparator:('b, 'cmp) Comparator.t\n -> ('a, _) set\n -> f:('a -> 'b option)\n -> ('b, 'cmp) t\n\n val of_tree : comparator:('a, 'cmp) Comparator.t -> ('a, 'cmp) tree -> ('a, 'cmp) t\nend\n\nmodule Check_creators\n (T : T2)\n (Tree : T2)\n (Elt : T1)\n (Cmp : T1)\n (Options : T3)\n (M : Creators_generic\n with type ('a, 'b, 'c) options := ('a, 'b, 'c) Options.t\n with type ('a, 'b) t := ('a, 'b) T.t\n with type ('a, 'b) tree := ('a, 'b) Tree.t\n with type 'a elt := 'a Elt.t\n with type 'cmp cmp := 'cmp Cmp.t) =\nstruct end\n\nmodule Check_creators0 (M : Creators0) =\n Check_creators\n (struct\n type ('a, 'b) t = M.t\n end)\n (struct\n type ('a, 'b) t = M.tree\n end)\n (struct\n type 'a t = M.elt\n end)\n (struct\n type 'cmp t = M.comparator_witness\n end)\n (Without_comparator)\n (M)\n\nmodule Check_creators1 (M : Creators1) =\n Check_creators\n (struct\n type ('a, 'b) t = 'a M.t\n end)\n (struct\n type ('a, 'b) t = 'a M.tree\n end)\n (struct\n type 'a t = 'a\n end)\n (struct\n type 'cmp t = M.comparator_witness\n end)\n (Without_comparator)\n (M)\n\nmodule Check_creators2 (M : Creators2) =\n Check_creators\n (struct\n type ('a, 'b) t = ('a, 'b) M.t\n end)\n (struct\n type ('a, 'b) t = ('a, 'b) M.tree\n end)\n (struct\n type 'a t = 'a\n end)\n (struct\n type 'cmp t = 'cmp\n end)\n (Without_comparator)\n (M)\n\nmodule Check_creators2_with_comparator (M : Creators2_with_comparator) =\n Check_creators\n (struct\n type ('a, 'b) t = ('a, 'b) M.t\n end)\n (struct\n type ('a, 'b) t = ('a, 'b) M.tree\n end)\n (struct\n type 'a t = 'a\n end)\n (struct\n type 'cmp t = 'cmp\n end)\n (With_comparator)\n (M)\n\nmodule type Creators_and_accessors_generic = sig\n include Accessors_generic\n\n include\n Creators_generic\n with type ('a, 'b, 'c) options := ('a, 'b, 'c) options\n with type ('a, 'b) t := ('a, 'b) t\n with type ('a, 'b) tree := ('a, 'b) tree\n with type 'a elt := 'a elt\n with type 'cmp cmp := 'cmp cmp\nend\n\nmodule type Creators_and_accessors0 = sig\n include Accessors0\n\n include\n Creators0\n with type t := t\n with type tree := tree\n with type elt := elt\n with type comparator_witness := comparator_witness\nend\n\nmodule type Creators_and_accessors1 = sig\n include Accessors1\n\n include\n Creators1\n with type 'a t := 'a t\n with type 'a tree := 'a tree\n with type comparator_witness := comparator_witness\nend\n\nmodule type Creators_and_accessors2 = sig\n include Accessors2\n\n include\n Creators2 with type ('a, 'b) t := ('a, 'b) t with type ('a, 'b) tree := ('a, 'b) tree\nend\n\nmodule type Creators_and_accessors2_with_comparator = sig\n include Accessors2_with_comparator\n\n include\n Creators2_with_comparator\n with type ('a, 'b) t := ('a, 'b) t\n with type ('a, 'b) tree := ('a, 'b) tree\nend\n\nmodule type S_poly = Creators_and_accessors1\n\nmodule type For_deriving = sig\n type ('a, 'b) t\n\n module type Sexp_of_m = sig\n type t [@@deriving_inline sexp_of]\n\n val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t\n\n [@@@end]\n end\n\n module type M_of_sexp = sig\n type t [@@deriving_inline of_sexp]\n\n val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t\n\n [@@@end]\n\n include Comparator.S with type t := t\n end\n\n module type Compare_m = sig end\n module type Equal_m = sig end\n module type Hash_fold_m = Hasher.S\n\n val sexp_of_m__t : (module Sexp_of_m with type t = 'elt) -> ('elt, 'cmp) t -> Sexp.t\n\n val m__t_of_sexp\n : (module M_of_sexp with type t = 'elt and type comparator_witness = 'cmp)\n -> Sexp.t\n -> ('elt, 'cmp) t\n\n val compare_m__t : (module Compare_m) -> ('elt, 'cmp) t -> ('elt, 'cmp) t -> int\n val equal_m__t : (module Equal_m) -> ('elt, 'cmp) t -> ('elt, 'cmp) t -> bool\n\n val hash_fold_m__t\n : (module Hash_fold_m with type t = 'elt)\n -> Hash.state\n -> ('elt, _) t\n -> Hash.state\n\n val hash_m__t : (module Hash_fold_m with type t = 'elt) -> ('elt, _) t -> int\nend\n\nmodule type Set = sig\n (** This module defines the [Set] module for [Base]. Functions that construct a set take\n as an argument the comparator for the element type. *)\n\n (** The type of a set. The first type parameter identifies the type of the element, and\n the second identifies the comparator, which determines the comparison function that\n is used for ordering elements in this set. Many operations (e.g., {!union}),\n require that they be passed sets with the same element type and the same comparator\n type. *)\n type ('elt, 'cmp) t [@@deriving_inline compare]\n\n val compare\n : ('elt -> 'elt -> int)\n -> ('cmp -> 'cmp -> int)\n -> ('elt, 'cmp) t\n -> ('elt, 'cmp) t\n -> int\n\n [@@@end]\n\n type ('k, 'cmp) comparator =\n (module Comparator.S with type t = 'k and type comparator_witness = 'cmp)\n\n (** Tests internal invariants of the set data structure. Returns true on success. *)\n val invariants : (_, _) t -> bool\n\n (** Returns a first-class module that can be used to build other map/set/etc\n with the same notion of comparison. *)\n val comparator_s : ('a, 'cmp) t -> ('a, 'cmp) comparator\n\n val comparator : ('a, 'cmp) t -> ('a, 'cmp) Comparator.t\n\n (** Creates an empty set based on the provided comparator. *)\n val empty : ('a, 'cmp) comparator -> ('a, 'cmp) t\n\n (** Creates a set based on the provided comparator that contains only the provided\n element. *)\n val singleton : ('a, 'cmp) comparator -> 'a -> ('a, 'cmp) t\n\n (** Returns the cardinality of the set. [O(1)]. *)\n val length : (_, _) t -> int\n\n (** [is_empty t] is [true] iff [t] is empty. [O(1)]. *)\n val is_empty : (_, _) t -> bool\n\n (** [mem t a] returns [true] iff [a] is in [t]. [O(log n)]. *)\n val mem : ('a, _) t -> 'a -> bool\n\n (** [add t a] returns a new set with [a] added to [t], or returns [t] if [mem t a].\n [O(log n)]. *)\n val add : ('a, 'cmp) t -> 'a -> ('a, 'cmp) t\n\n (** [remove t a] returns a new set with [a] removed from [t] if [mem t a], or returns [t]\n otherwise. [O(log n)]. *)\n val remove : ('a, 'cmp) t -> 'a -> ('a, 'cmp) t\n\n (** [union t1 t2] returns the union of the two sets. [O(length t1 + length t2)]. *)\n val union : ('a, 'cmp) t -> ('a, 'cmp) t -> ('a, 'cmp) t\n\n (** [union c list] returns the union of all the sets in [list]. The\n [comparator] argument is required for the case where [list] is empty.\n [O(max(List.length list, n log n))], where [n] is the sum of sizes of the input sets. *)\n val union_list : ('a, 'cmp) comparator -> ('a, 'cmp) t list -> ('a, 'cmp) t\n\n (** [inter t1 t2] computes the intersection of sets [t1] and [t2]. [O(length t1 +\n length t2)]. *)\n val inter : ('a, 'cmp) t -> ('a, 'cmp) t -> ('a, 'cmp) t\n\n (** [diff t1 t2] computes the set difference [t1 - t2], i.e., the set containing all\n elements in [t1] that are not in [t2]. [O(length t1 + length t2)]. *)\n val diff : ('a, 'cmp) t -> ('a, 'cmp) t -> ('a, 'cmp) t\n\n (** [symmetric_diff t1 t2] returns a sequence of changes between [t1] and [t2]. It is\n intended to be efficient in the case where [t1] and [t2] share a large amount of\n structure. *)\n val symmetric_diff : ('a, 'cmp) t -> ('a, 'cmp) t -> ('a, 'a) Either.t Sequence.t\n\n (** [compare_direct t1 t2] compares the sets [t1] and [t2]. It returns the same result\n as [compare], but unlike compare, doesn't require arguments to be passed in for the\n type parameters of the set. [O(length t1 + length t2)]. *)\n val compare_direct : ('a, 'cmp) t -> ('a, 'cmp) t -> int\n\n (** Hash function: a building block to use when hashing data structures containing sets in\n them. [hash_fold_direct hash_fold_key] is compatible with [compare_direct] iff\n [hash_fold_key] is compatible with [(comparator s).compare] of the set [s] being\n hashed. *)\n val hash_fold_direct : 'a Hash.folder -> ('a, 'cmp) t Hash.folder\n\n (** [equal t1 t2] returns [true] iff the two sets have the same elements. [O(length t1 +\n length t2)] *)\n val equal : ('a, 'cmp) t -> ('a, 'cmp) t -> bool\n\n (** [exists t ~f] returns [true] iff there exists an [a] in [t] for which [f a]. [O(n)],\n but returns as soon as it finds an [a] for which [f a]. *)\n val exists : ('a, _) t -> f:('a -> bool) -> bool\n\n (** [for_all t ~f] returns [true] iff for all [a] in [t], [f a]. [O(n)], but returns as\n soon as it finds an [a] for which [not (f a)]. *)\n val for_all : ('a, _) t -> f:('a -> bool) -> bool\n\n (** [count t] returns the number of elements of [t] for which [f] returns [true].\n [O(n)]. *)\n val count : ('a, _) t -> f:('a -> bool) -> int\n\n (** [sum t] returns the sum of [f t] for each [t] in the set.\n [O(n)]. *)\n val sum\n : (module Container.Summable with type t = 'sum)\n -> ('a, _) t\n -> f:('a -> 'sum)\n -> 'sum\n\n (** [find t f] returns an element of [t] for which [f] returns true, with no guarantee as\n to which element is returned. [O(n)], but returns as soon as a suitable element is\n found. *)\n val find : ('a, _) t -> f:('a -> bool) -> 'a option\n\n (** [find_map t f] returns [b] for some [a] in [t] for which [f a = Some b]. If no such\n [a] exists, then [find] returns [None]. [O(n)], but returns as soon as a suitable\n element is found. *)\n val find_map : ('a, _) t -> f:('a -> 'b option) -> 'b option\n\n (** Like [find], but throws an exception on failure. *)\n val find_exn : ('a, _) t -> f:('a -> bool) -> 'a\n\n (** [nth t i] returns the [i]th smallest element of [t], in [O(log n)] time. The\n smallest element has [i = 0]. Returns [None] if [i < 0] or [i >= length t]. *)\n val nth : ('a, _) t -> int -> 'a option\n\n (** [remove_index t i] returns a version of [t] with the [i]th smallest element removed,\n in [O(log n)] time. The smallest element has [i = 0]. Returns [t] if [i < 0] or\n [i >= length t]. *)\n val remove_index : ('a, 'cmp) t -> int -> ('a, 'cmp) t\n\n (** [is_subset t1 ~of_:t2] returns true iff [t1] is a subset of [t2]. *)\n val is_subset : ('a, 'cmp) t -> of_:('a, 'cmp) t -> bool\n\n (** [are_disjoint t1 t2] returns [true] iff [is_empty (inter t1 t2)], but is more\n efficient. *)\n val are_disjoint : ('a, 'cmp) t -> ('a, 'cmp) t -> bool\n\n (** [Named] allows the validation of subset and equality relationships between sets. A\n [Named.t] is a record of a set and a name, where the name is used in error messages,\n and [Named.is_subset] and [Named.equal] validate subset and equality relationships\n respectively.\n\n The error message for, e.g.,\n {[\n Named.is_subset { set = set1; name = \"set1\" } ~of_:{set = set2; name = \"set2\" }\n ]}\n\n looks like\n {v\n (\"set1 is not a subset of set2\" (invalid_elements (...elements of set1 - set2...)))\n v}\n\n so [name] should be a noun phrase that doesn't sound awkward in the above error\n message. Even though it adds verbosity, choosing [name]s that start with the phrase\n \"the set of\" often makes the error message sound more natural.\n *)\n module Named : sig\n type nonrec ('a, 'cmp) t =\n { set : ('a, 'cmp) t\n ; name : string\n }\n\n (** [is_subset t1 ~of_:t2] returns [Ok ()] if [t1] is a subset of [t2] and a\n human-readable error otherwise. *)\n val is_subset : ('a, 'cmp) t -> of_:('a, 'cmp) t -> unit Or_error.t\n\n (** [equal t1 t2] returns [Ok ()] if [t1] is equal to [t2] and a human-readable\n error otherwise. *)\n val equal : ('a, 'cmp) t -> ('a, 'cmp) t -> unit Or_error.t\n end\n\n (** The list or array given to [of_list] and [of_array] need not be sorted. *)\n val of_list : ('a, 'cmp) comparator -> 'a list -> ('a, 'cmp) t\n\n val of_array : ('a, 'cmp) comparator -> 'a array -> ('a, 'cmp) t\n\n (** [to_list] and [to_array] produce sequences sorted in ascending order according to the\n comparator. *)\n val to_list : ('a, _) t -> 'a list\n\n val to_array : ('a, _) t -> 'a array\n\n (** Create set from sorted array. The input must be sorted (either in ascending or\n descending order as given by the comparator) and contain no duplicates, otherwise the\n result is an error. The complexity of this function is [O(n)]. *)\n val of_sorted_array : ('a, 'cmp) comparator -> 'a array -> ('a, 'cmp) t Or_error.t\n\n (** Similar to [of_sorted_array], but without checking the input array. *)\n val of_sorted_array_unchecked : ('a, 'cmp) comparator -> 'a array -> ('a, 'cmp) t\n\n (** [of_increasing_iterator_unchecked c ~len ~f] behaves like [of_sorted_array_unchecked c\n (Array.init len ~f)], with the additional restriction that a decreasing order is not\n supported. The advantage is not requiring you to allocate an intermediate array. [f]\n will be called with 0, 1, ... [len - 1], in order. *)\n val of_increasing_iterator_unchecked\n : ('a, 'cmp) comparator\n -> len:int\n -> f:(int -> 'a)\n -> ('a, 'cmp) t\n\n (** [stable_dedup_list] is here rather than in the [List] module because the\n implementation relies crucially on sets, and because doing so allows one to avoid uses\n of polymorphic comparison by instantiating the functor at a different implementation\n of [Comparator] and using the resulting [stable_dedup_list]. *)\n val stable_dedup_list : ('a, _) comparator -> 'a list -> 'a list\n\n (** [map c t ~f] returns a new set created by applying [f] to every element in\n [t]. The returned set is based on the provided [comparator]. [O(n log n)]. *)\n val map : ('b, 'cmp) comparator -> ('a, _) t -> f:('a -> 'b) -> ('b, 'cmp) t\n\n (** Like {!map}, except elements for which [f] returns [None] will be dropped. *)\n val filter_map\n : ('b, 'cmp) comparator\n -> ('a, _) t\n -> f:('a -> 'b option)\n -> ('b, 'cmp) t\n\n (** [filter t ~f] returns the subset of [t] for which [f] evaluates to true. [O(n log\n n)]. *)\n val filter : ('a, 'cmp) t -> f:('a -> bool) -> ('a, 'cmp) t\n\n (** [fold t ~init ~f] folds over the elements of the set from smallest to largest. *)\n val fold : ('a, _) t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum\n\n (** [fold_result ~init ~f] folds over the elements of the set from smallest to\n largest, short circuiting the fold if [f accum x] is an [Error _] *)\n val fold_result\n : ('a, _) t\n -> init:'accum\n -> f:('accum -> 'a -> ('accum, 'e) Result.t)\n -> ('accum, 'e) Result.t\n\n (** [fold_until t ~init ~f] is a short-circuiting version of [fold]. If [f]\n returns [Stop _] the computation ceases and results in that value. If [f] returns\n [Continue _], the fold will proceed. *)\n val fold_until\n : ('a, _) t\n -> init:'accum\n -> f:('accum -> 'a -> ('accum, 'final) Continue_or_stop.t)\n -> finish:('accum -> 'final)\n -> 'final\n\n\n (** Like {!fold}, except that it goes from the largest to the smallest element. *)\n val fold_right : ('a, _) t -> init:'accum -> f:('a -> 'accum -> 'accum) -> 'accum\n\n (** [iter t ~f] calls [f] on every element of [t], going in order from the smallest to\n largest. *)\n val iter : ('a, _) t -> f:('a -> unit) -> unit\n\n (** Iterate two sets side by side. Complexity is [O(m+n)] where [m] and [n] are the sizes\n of the two input sets. As an example, with the inputs [0; 1] and [1; 2], [f] will be\n called with [`Left 0]; [`Both (1, 1)]; and [`Right 2]. *)\n val iter2\n : ('a, 'cmp) t\n -> ('a, 'cmp) t\n -> f:([ `Left of 'a | `Right of 'a | `Both of 'a * 'a ] -> unit)\n -> unit\n\n (** if [a, b = partition_tf set ~f] then [a] is the elements on which [f] produced [true],\n and [b] is the elements on which [f] produces [false]. *)\n val partition_tf : ('a, 'cmp) t -> f:('a -> bool) -> ('a, 'cmp) t * ('a, 'cmp) t\n\n (** Same as {!to_list}. *)\n val elements : ('a, _) t -> 'a list\n\n (** Returns the smallest element of the set. [O(log n)]. *)\n val min_elt : ('a, _) t -> 'a option\n\n (** Like {!min_elt}, but throws an exception when given an empty set. *)\n val min_elt_exn : ('a, _) t -> 'a\n\n (** Returns the largest element of the set. [O(log n)]. *)\n val max_elt : ('a, _) t -> 'a option\n\n (** Like {!max_elt}, but throws an exception when given an empty set. *)\n val max_elt_exn : ('a, _) t -> 'a\n\n (** returns an arbitrary element, or [None] if the set is empty. *)\n val choose : ('a, _) t -> 'a option\n\n (** Like {!choose}, but throws an exception on an empty set. *)\n val choose_exn : ('a, _) t -> 'a\n\n (** [split t x] produces a triple [(t1, maybe_x, t2)] where [t1] is the set of elements\n strictly less than [x], [maybe_x] is the member (if any) of [t] which compares equal\n to [x], and [t2] is the set of elements strictly larger than [x]. *)\n val split : ('a, 'cmp) t -> 'a -> ('a, 'cmp) t * 'a option * ('a, 'cmp) t\n\n (** if [equiv] is an equivalence predicate, then [group_by set ~equiv] produces a list\n of equivalence classes (i.e., a set-theoretic quotient). E.g.,\n\n {[\n let chars = Set.of_list ['A'; 'a'; 'b'; 'c'] in\n let equiv c c' = Char.equal (Char.uppercase c) (Char.uppercase c') in\n group_by chars ~equiv\n ]}\n\n produces:\n\n {[\n [Set.of_list ['A';'a']; Set.singleton 'b'; Set.singleton 'c']\n ]}\n\n [group_by] runs in O(n^2) time, so if you have a comparison function, it's usually\n much faster to use [Set.of_list]. *)\n val group_by : ('a, 'cmp) t -> equiv:('a -> 'a -> bool) -> ('a, 'cmp) t list\n\n (** [to_sequence t] converts the set [t] to a sequence of the elements between\n [greater_or_equal_to] and [less_or_equal_to] inclusive in the order indicated by\n [order]. If [greater_or_equal_to > less_or_equal_to] the sequence is empty. Cost is\n O(log n) up front and amortized O(1) for each element produced. *)\n val to_sequence\n : ?order:[ `Increasing (** default *) | `Decreasing ]\n -> ?greater_or_equal_to:'a\n -> ?less_or_equal_to:'a\n -> ('a, 'cmp) t\n -> 'a Sequence.t\n\n (** [binary_search t ~compare which elt] returns the element in [t] specified by\n [compare] and [which], if one exists.\n\n [t] must be sorted in increasing order according to [compare], where [compare] and\n [elt] divide [t] into three (possibly empty) segments:\n\n {v\n | < elt | = elt | > elt |\n v}\n\n [binary_search] returns an element on the boundary of segments as specified by\n [which]. See the diagram below next to the [which] variants.\n\n [binary_search] does not check that [compare] orders [t], and behavior is\n unspecified if [compare] doesn't order [t]. Behavior is also unspecified if\n [compare] mutates [t]. *)\n val binary_search\n : ('a, 'cmp) t\n -> compare:('a -> 'key -> int)\n -> [ `Last_strictly_less_than (** {v | < elt X | v} *)\n | `Last_less_than_or_equal_to (** {v | <= elt X | v} *)\n | `Last_equal_to (** {v | = elt X | v} *)\n | `First_equal_to (** {v | X = elt | v} *)\n | `First_greater_than_or_equal_to (** {v | X >= elt | v} *)\n | `First_strictly_greater_than (** {v | X > elt | v} *)\n ]\n -> 'key\n -> 'a option\n\n (** [binary_search_segmented t ~segment_of which] takes a [segment_of] function that\n divides [t] into two (possibly empty) segments:\n\n {v\n | segment_of elt = `Left | segment_of elt = `Right |\n v}\n\n [binary_search_segmented] returns the element on the boundary of the segments as\n specified by [which]: [`Last_on_left] yields the last element of the left segment,\n while [`First_on_right] yields the first element of the right segment. It returns\n [None] if the segment is empty.\n\n [binary_search_segmented] does not check that [segment_of] segments [t] as in the\n diagram, and behavior is unspecified if [segment_of] doesn't segment [t]. Behavior\n is also unspecified if [segment_of] mutates [t]. *)\n val binary_search_segmented\n : ('a, 'cmp) t\n -> segment_of:('a -> [ `Left | `Right ])\n -> [ `Last_on_left | `First_on_right ]\n -> 'a option\n\n (** Produces the elements of the two sets between [greater_or_equal_to] and\n [less_or_equal_to] in [order], noting whether each element appears in the left set,\n the right set, or both. In the both case, both elements are returned, in case the\n caller can distinguish between elements that are equal to the sets' comparator. Runs\n in O(length t + length t'). *)\n module Merge_to_sequence_element : sig\n type ('a, 'b) t = ('a, 'b) Sequence.Merge_with_duplicates_element.t =\n | Left of 'a\n | Right of 'b\n | Both of 'a * 'b\n [@@deriving_inline compare, sexp]\n\n val compare\n : ('a -> 'a -> int)\n -> ('b -> 'b -> int)\n -> ('a, 'b) t\n -> ('a, 'b) t\n -> int\n\n include Ppx_sexp_conv_lib.Sexpable.S2 with type ('a, 'b) t := ('a, 'b) t\n\n [@@@end]\n end\n\n val merge_to_sequence\n : ?order:[ `Increasing (** default *) | `Decreasing ]\n -> ?greater_or_equal_to:'a\n -> ?less_or_equal_to:'a\n -> ('a, 'cmp) t\n -> ('a, 'cmp) t\n -> ('a, 'a) Merge_to_sequence_element.t Sequence.t\n\n (** [M] is meant to be used in combination with OCaml applicative functor types:\n\n {[\n type string_set = Set.M(String).t\n ]}\n\n which stands for:\n\n {[\n type string_set = (String.t, String.comparator_witness) Set.t\n ]}\n\n The point is that [Set.M(String).t] supports deriving, whereas the second syntax\n doesn't (because there is no such thing as, say, String.sexp_of_comparator_witness,\n instead you would want to pass the comparator directly). *)\n module M (Elt : sig\n type t\n type comparator_witness\n end) : sig\n type nonrec t = (Elt.t, Elt.comparator_witness) t\n end\n\n include For_deriving with type ('a, 'b) t := ('a, 'b) t\n\n (** A polymorphic Set. *)\n module Poly : S_poly with type 'elt t = ('elt, Comparator.Poly.comparator_witness) t\n\n (** Using comparator is a similar interface as the toplevel of [Set], except the functions\n take a [~comparator:('elt, 'cmp) Comparator.t] where the functions at the toplevel of\n [Set] takes a [('elt, 'cmp) comparator]. *)\n module Using_comparator : sig\n type nonrec ('elt, 'cmp) t = ('elt, 'cmp) t [@@deriving_inline sexp_of]\n\n val sexp_of_t\n : ('elt -> Ppx_sexp_conv_lib.Sexp.t)\n -> ('cmp -> Ppx_sexp_conv_lib.Sexp.t)\n -> ('elt, 'cmp) t\n -> Ppx_sexp_conv_lib.Sexp.t\n\n [@@@end]\n\n val t_of_sexp_direct\n : comparator:('elt, 'cmp) Comparator.t\n -> (Sexp.t -> 'elt)\n -> Sexp.t\n -> ('elt, 'cmp) t\n\n module Tree : sig\n (** A [Tree.t] contains just the tree data structure that a set is based on, without\n including the comparator. Accordingly, any operation on a [Tree.t] must also take\n as an argument the corresponding comparator. *)\n type ('a, 'cmp) t [@@deriving_inline sexp_of]\n\n val sexp_of_t\n : ('a -> Ppx_sexp_conv_lib.Sexp.t)\n -> ('cmp -> Ppx_sexp_conv_lib.Sexp.t)\n -> ('a, 'cmp) t\n -> Ppx_sexp_conv_lib.Sexp.t\n\n [@@@end]\n\n val t_of_sexp_direct\n : comparator:('elt, 'cmp) Comparator.t\n -> (Sexp.t -> 'elt)\n -> Sexp.t\n -> ('elt, 'cmp) t\n\n module Named : sig\n type nonrec ('a, 'cmp) t =\n { tree : ('a, 'cmp) t\n ; name : string\n }\n\n val is_subset\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'cmp) t\n -> of_:('a, 'cmp) t\n -> unit Or_error.t\n\n val equal\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'cmp) t\n -> ('a, 'cmp) t\n -> unit Or_error.t\n end\n\n include\n Creators_and_accessors2_with_comparator\n with type ('a, 'b) set := ('a, 'b) t\n with type ('a, 'b) t := ('a, 'b) t\n with type ('a, 'b) tree := ('a, 'b) t\n with type ('a, 'b) named := ('a, 'b) Named.t\n with module Named := Named\n\n val empty_without_value_restriction : (_, _) t\n end\n\n include\n Accessors2\n with type ('a, 'b) t := ('a, 'b) t\n with type ('a, 'b) tree := ('a, 'b) Tree.t\n with type ('a, 'b) named := ('a, 'b) Named.t\n\n include\n Creators2_with_comparator\n with type ('a, 'b) t := ('a, 'b) t\n with type ('a, 'b) tree := ('a, 'b) Tree.t\n with type ('a, 'b) set := ('a, 'b) t\n\n val comparator : ('a, 'cmp) t -> ('a, 'cmp) Comparator.t\n val hash_fold_direct : 'elt Hash.folder -> ('elt, 'cmp) t Hash.folder\n\n module Empty_without_value_restriction (Elt : Comparator.S1) : sig\n val empty : ('a Elt.t, Elt.comparator_witness) t\n end\n end\n\n (** {2 Modules and module types for extending [Set]}\n\n For use in extensions of Base, like [Core_kernel]. *)\n\n module With_comparator = With_comparator\n module With_first_class_module = With_first_class_module\n module Without_comparator = Without_comparator\n\n module type For_deriving = For_deriving\n module type S_poly = S_poly\n module type Accessors0 = Accessors0\n module type Accessors1 = Accessors1\n module type Accessors2 = Accessors2\n module type Accessors2_with_comparator = Accessors2_with_comparator\n module type Accessors_generic = Accessors_generic\n module type Creators0 = Creators0\n module type Creators1 = Creators1\n module type Creators2 = Creators2\n module type Creators2_with_comparator = Creators2_with_comparator\n module type Creators_and_accessors0 = Creators_and_accessors0\n module type Creators_and_accessors1 = Creators_and_accessors1\n module type Creators_and_accessors2 = Creators_and_accessors2\n\n module type Creators_and_accessors2_with_comparator =\n Creators_and_accessors2_with_comparator\n\n module type Creators_generic = Creators_generic\n module type Elt_plain = Elt_plain\nend\n","open! Import\n\n\n(* [t] stores the [t.length] queue elements at consecutive increasing indices of [t.elts],\n mod the capacity of [t], which is [Option_array.length t.elts]. The capacity is\n required to be a power of two (user-requested capacities are rounded up to the nearest\n power), so that mod can quickly be computed using [land t.mask], where [t.mask =\n capacity t - 1]. So, queue element [i] is at [t.elts.( (t.front + i) land t.mask )].\n\n [num_mutations] is used to detect modification during iteration. *)\ntype 'a t =\n { mutable num_mutations : int\n ; mutable front : int\n ; mutable mask : int\n ; mutable length : int\n ; mutable elts : 'a Option_array.t\n }\n[@@deriving_inline sexp_of]\n\nlet sexp_of_t : 'a. ('a -> Ppx_sexp_conv_lib.Sexp.t) -> 'a t -> Ppx_sexp_conv_lib.Sexp.t =\n fun _of_a -> function\n | { num_mutations = v_num_mutations\n ; front = v_front\n ; mask = v_mask\n ; length = v_length\n ; elts = v_elts\n } ->\n let bnds = [] in\n let bnds =\n let arg = Option_array.sexp_of_t _of_a v_elts in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"elts\"; arg ] :: bnds\n in\n let bnds =\n let arg = sexp_of_int v_length in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"length\"; arg ] :: bnds\n in\n let bnds =\n let arg = sexp_of_int v_mask in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"mask\"; arg ] :: bnds\n in\n let bnds =\n let arg = sexp_of_int v_front in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"front\"; arg ] :: bnds\n in\n let bnds =\n let arg = sexp_of_int v_num_mutations in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"num_mutations\"; arg ]\n :: bnds\n in\n Ppx_sexp_conv_lib.Sexp.List bnds\n;;\n\n[@@@end]\n\nmodule type S = Queue_intf.S\n\nlet inc_num_mutations t = t.num_mutations <- t.num_mutations + 1\nlet capacity t = t.mask + 1\nlet elts_index t i = (t.front + i) land t.mask\nlet unsafe_get t i = Option_array.unsafe_get_some_exn t.elts (elts_index t i)\nlet unsafe_is_set t i = Option_array.unsafe_is_some t.elts (elts_index t i)\nlet unsafe_set t i a = Option_array.unsafe_set_some t.elts (elts_index t i) a\nlet unsafe_unset t i = Option_array.unsafe_set_none t.elts (elts_index t i)\n\nlet check_index_exn t i =\n if i < 0 || i >= t.length\n then\n Error.raise_s\n (Sexp.message\n \"Queue index out of bounds\"\n [ \"index\", i |> Int.sexp_of_t; \"length\", t.length |> Int.sexp_of_t ])\n;;\n\nlet get t i =\n check_index_exn t i;\n unsafe_get t i\n;;\n\nlet set t i a =\n check_index_exn t i;\n inc_num_mutations t;\n unsafe_set t i a\n;;\n\nlet is_empty t = t.length = 0\nlet length { length; _ } = length\n\nlet ensure_no_mutation t num_mutations =\n if t.num_mutations <> num_mutations\n then\n Error.raise_s\n (Sexp.message\n \"mutation of queue during iteration\"\n [ \"\", t |> sexp_of_t (fun _ -> Sexp.Atom \"_\") ])\n;;\n\nlet compare =\n let rec unsafe_compare_from compare_elt pos ~t1 ~t2 ~len1 ~len2 ~mut1 ~mut2 =\n match pos = len1, pos = len2 with\n | true, true -> 0\n | true, false -> -1\n | false, true -> 1\n | false, false ->\n let x = compare_elt (unsafe_get t1 pos) (unsafe_get t2 pos) in\n ensure_no_mutation t1 mut1;\n ensure_no_mutation t2 mut2;\n (match x with\n | 0 -> unsafe_compare_from compare_elt (pos + 1) ~t1 ~t2 ~len1 ~len2 ~mut1 ~mut2\n | n -> n)\n in\n fun compare_elt t1 t2 ->\n if phys_equal t1 t2\n then 0\n else\n unsafe_compare_from\n compare_elt\n 0\n ~t1\n ~t2\n ~len1:t1.length\n ~len2:t2.length\n ~mut1:t1.num_mutations\n ~mut2:t2.num_mutations\n;;\n\nlet equal =\n let rec unsafe_equal_from equal_elt pos ~t1 ~t2 ~mut1 ~mut2 ~len =\n pos = len\n ||\n let b = equal_elt (unsafe_get t1 pos) (unsafe_get t2 pos) in\n ensure_no_mutation t1 mut1;\n ensure_no_mutation t2 mut2;\n b && unsafe_equal_from equal_elt (pos + 1) ~t1 ~t2 ~mut1 ~mut2 ~len\n in\n fun equal_elt t1 t2 ->\n phys_equal t1 t2\n ||\n let len1 = t1.length in\n let len2 = t2.length in\n len1 = len2\n && unsafe_equal_from\n equal_elt\n 0\n ~t1\n ~t2\n ~len:len1\n ~mut1:t1.num_mutations\n ~mut2:t2.num_mutations\n;;\n\nlet invariant invariant_a t =\n let { num_mutations; mask = _; elts; front; length } = t in\n assert (front >= 0);\n assert (front < capacity t);\n let capacity = capacity t in\n assert (capacity = Option_array.length elts);\n assert (capacity >= 1);\n assert (Int.is_pow2 capacity);\n assert (length >= 0);\n assert (length <= capacity);\n for i = 0 to capacity - 1 do\n if i < t.length\n then (\n invariant_a (unsafe_get t i);\n ensure_no_mutation t num_mutations)\n else assert (not (unsafe_is_set t i))\n done\n;;\n\nlet create (type a) ?capacity () : a t =\n let capacity =\n match capacity with\n | None -> 1\n | Some capacity ->\n if capacity < 0\n then\n Error.raise_s\n (Sexp.message\n \"cannot have queue with negative capacity\"\n [ \"capacity\", capacity |> Int.sexp_of_t ])\n else if capacity = 0\n then 1\n else Int.ceil_pow2 capacity\n in\n { num_mutations = 0\n ; front = 0\n ; mask = capacity - 1\n ; length = 0\n ; elts = Option_array.create ~len:capacity\n }\n;;\n\nlet blit_to_array ~src dst =\n assert (src.length <= Option_array.length dst);\n let front_len = Int.min src.length (capacity src - src.front) in\n let rest_len = src.length - front_len in\n Option_array.blit ~len:front_len ~src:src.elts ~src_pos:src.front ~dst ~dst_pos:0;\n Option_array.blit ~len:rest_len ~src:src.elts ~src_pos:0 ~dst ~dst_pos:front_len\n;;\n\nlet set_capacity t desired_capacity =\n (* We allow arguments less than 1 to [set_capacity], but translate them to 1 to simplify\n the code that relies on the array length being a power of 2. *)\n inc_num_mutations t;\n let new_capacity = Int.ceil_pow2 (max 1 (max desired_capacity t.length)) in\n if new_capacity <> capacity t\n then (\n let dst = Option_array.create ~len:new_capacity in\n blit_to_array ~src:t dst;\n t.front <- 0;\n t.mask <- new_capacity - 1;\n t.elts <- dst)\n;;\n\nlet enqueue t a =\n inc_num_mutations t;\n if t.length = capacity t then set_capacity t (2 * t.length);\n unsafe_set t t.length a;\n t.length <- t.length + 1\n;;\n\nlet dequeue_nonempty t =\n inc_num_mutations t;\n let elts = t.elts in\n let front = t.front in\n let res = Option_array.get_some_exn elts front in\n Option_array.set_none elts front;\n t.front <- elts_index t 1;\n t.length <- t.length - 1;\n res\n;;\n\nlet dequeue_exn t = if is_empty t then raise Caml.Queue.Empty else dequeue_nonempty t\nlet dequeue t = if is_empty t then None else Some (dequeue_nonempty t)\nlet front_nonempty t = Option_array.unsafe_get_some_exn t.elts t.front\nlet last_nonempty t = unsafe_get t (t.length - 1)\nlet peek t = if is_empty t then None else Some (front_nonempty t)\nlet peek_exn t = if is_empty t then raise Caml.Queue.Empty else front_nonempty t\nlet last t = if is_empty t then None else Some (last_nonempty t)\nlet last_exn t = if is_empty t then raise Caml.Queue.Empty else last_nonempty t\n\nlet clear t =\n inc_num_mutations t;\n if t.length > 0\n then (\n for i = 0 to t.length - 1 do\n unsafe_unset t i\n done;\n t.length <- 0;\n t.front <- 0)\n;;\n\nlet blit_transfer ~src ~dst ?len () =\n inc_num_mutations src;\n inc_num_mutations dst;\n let len =\n match len with\n | None -> src.length\n | Some len ->\n if len < 0\n then\n Error.raise_s\n (Sexp.message\n \"Queue.blit_transfer: negative length\"\n [ \"length\", len |> Int.sexp_of_t ]);\n min len src.length\n in\n if len > 0\n then (\n set_capacity dst (max (capacity dst) (dst.length + len));\n let dst_start = dst.front + dst.length in\n for i = 0 to len - 1 do\n (* This is significantly faster than simply [enqueue dst (dequeue_nonempty src)] *)\n let src_i = (src.front + i) land src.mask in\n let dst_i = (dst_start + i) land dst.mask in\n Option_array.unsafe_set_some\n dst.elts\n dst_i\n (Option_array.unsafe_get_some_exn src.elts src_i);\n Option_array.unsafe_set_none src.elts src_i\n done;\n dst.length <- dst.length + len;\n src.front <- (src.front + len) land src.mask;\n src.length <- src.length - len)\n;;\n\nlet enqueue_all t l =\n (* Traversing the list up front to compute its length is probably (but not definitely)\n better than doubling the underlying array size several times for large queues. *)\n set_capacity t (Int.max (capacity t) (t.length + List.length l));\n List.iter l ~f:(fun x -> enqueue t x)\n;;\n\nlet fold t ~init ~f =\n if t.length = 0\n then init\n else (\n let num_mutations = t.num_mutations in\n let r = ref init in\n for i = 0 to t.length - 1 do\n r := f !r (unsafe_get t i);\n ensure_no_mutation t num_mutations\n done;\n !r)\n;;\n\nlet foldi t ~init ~f =\n let i = ref 0 in\n fold t ~init ~f:(fun acc a ->\n let acc = f !i acc a in\n i := !i + 1;\n acc)\n;;\n\n\n(* [iter] is implemented directly because implementing it in terms of [fold] is\n slower. *)\nlet iter t ~f =\n let num_mutations = t.num_mutations in\n for i = 0 to t.length - 1 do\n f (unsafe_get t i);\n ensure_no_mutation t num_mutations\n done\n;;\n\nlet iteri t ~f =\n let num_mutations = t.num_mutations in\n for i = 0 to t.length - 1 do\n f i (unsafe_get t i);\n ensure_no_mutation t num_mutations\n done\n;;\n\nmodule C = Indexed_container.Make (struct\n type nonrec 'a t = 'a t\n\n let fold = fold\n let iter = `Custom iter\n let length = `Custom length\n let foldi = `Custom foldi\n let iteri = `Custom iteri\n end)\n\nlet count = C.count\nlet exists = C.exists\nlet find = C.find\nlet find_map = C.find_map\nlet fold_result = C.fold_result\nlet fold_until = C.fold_until\nlet for_all = C.for_all\nlet max_elt = C.max_elt\nlet mem = C.mem\nlet min_elt = C.min_elt\nlet sum = C.sum\nlet to_list = C.to_list\nlet counti = C.counti\nlet existsi = C.existsi\nlet find_mapi = C.find_mapi\nlet findi = C.findi\nlet for_alli = C.for_alli\n\n\n(* For [concat_map], [filter_map], and [filter], we don't create [t_result] with [t]'s\n capacity because we have no idea how many elements [t_result] will ultimately hold. *)\nlet concat_map t ~f =\n let t_result = create () in\n iter t ~f:(fun a -> List.iter (f a) ~f:(fun b -> enqueue t_result b));\n t_result\n;;\n\nlet concat_mapi t ~f =\n let t_result = create () in\n iteri t ~f:(fun i a -> List.iter (f i a) ~f:(fun b -> enqueue t_result b));\n t_result\n;;\n\nlet filter_map t ~f =\n let t_result = create () in\n iter t ~f:(fun a ->\n match f a with\n | None -> ()\n | Some b -> enqueue t_result b);\n t_result\n;;\n\nlet filter_mapi t ~f =\n let t_result = create () in\n iteri t ~f:(fun i a ->\n match f i a with\n | None -> ()\n | Some b -> enqueue t_result b);\n t_result\n;;\n\nlet filter t ~f =\n let t_result = create () in\n iter t ~f:(fun a -> if f a then enqueue t_result a);\n t_result\n;;\n\nlet filteri t ~f =\n let t_result = create () in\n iteri t ~f:(fun i a -> if f i a then enqueue t_result a);\n t_result\n;;\n\nlet filter_inplace t ~f =\n let t2 = filter t ~f in\n clear t;\n blit_transfer ~src:t2 ~dst:t ()\n;;\n\nlet filteri_inplace t ~f =\n let t2 = filteri t ~f in\n clear t;\n blit_transfer ~src:t2 ~dst:t ()\n;;\n\nlet copy src =\n let dst = create ~capacity:src.length () in\n blit_to_array ~src dst.elts;\n dst.length <- src.length;\n dst\n;;\n\nlet of_list l =\n (* Traversing the list up front to compute its length is probably (but not definitely)\n better than doubling the underlying array size several times for large queues. *)\n let t = create ~capacity:(List.length l) () in\n List.iter l ~f:(fun x -> enqueue t x);\n t\n;;\n\n(* The queue [t] returned by [create] will have [t.length = 0], [t.front = 0], and\n [capacity t = Int.ceil_pow2 len]. So, we only have to set [t.length] to [len] after\n the blit to maintain all the invariants: [t.length] is equal to the number of elements\n in the queue, [t.front] is the array index of the first element in the queue, and\n [capacity t = Option_array.length t.elts]. *)\nlet init len ~f =\n if len < 0\n then\n Error.raise_s\n (Sexp.message \"Queue.init: negative length\" [ \"length\", len |> Int.sexp_of_t ]);\n let t = create ~capacity:len () in\n assert (Option_array.length t.elts >= len);\n for i = 0 to len - 1 do\n Option_array.unsafe_set_some t.elts i (f i)\n done;\n t.length <- len;\n t\n;;\n\nlet of_array a = init (Array.length a) ~f:(Array.unsafe_get a)\nlet to_array t = Array.init t.length ~f:(fun i -> unsafe_get t i)\n\nlet map ta ~f =\n let num_mutations = ta.num_mutations in\n let tb = create ~capacity:ta.length () in\n tb.length <- ta.length;\n for i = 0 to ta.length - 1 do\n let b = f (unsafe_get ta i) in\n ensure_no_mutation ta num_mutations;\n Option_array.unsafe_set_some tb.elts i b\n done;\n tb\n;;\n\nlet mapi t ~f =\n let i = ref 0 in\n map t ~f:(fun a ->\n let result = f !i a in\n i := !i + 1;\n result)\n;;\n\nlet singleton x =\n let t = create () in\n enqueue t x;\n t\n;;\n\nlet sexp_of_t sexp_of_a t = to_list t |> List.sexp_of_t sexp_of_a\nlet t_of_sexp a_of_sexp sexp = List.t_of_sexp a_of_sexp sexp |> of_list\n","open! Import\n\nmodule T = struct\n type t = |\n\n let unreachable_code = function\n | (_ : t) -> .\n ;;\n\n let all = []\n let hash_fold_t _ t = unreachable_code t\n let hash = unreachable_code\n let compare a _ = unreachable_code a\n let sexp_of_t = unreachable_code\n let t_of_sexp sexp = Sexplib.Conv_error.empty_type \"Base.Nothing.t\" sexp\n let to_string = unreachable_code\n let of_string (_ : string) = failwith \"Base.Nothing.of_string: not supported\"\nend\n\ninclude T\n\ninclude Identifiable.Make (struct\n include T\n\n let module_name = \"Base.Nothing\"\n end)\n","(** [never_returns] should be used as the return type of functions that don't return and\n might block forever, rather than ['a] or [_]. This forces callers of such functions\n to have a call to [never_returns] at the call site, which makes it clear to readers\n what's going on. We do not intend to use this type for functions such as [failwithf]\n that always raise an exception. *)\n\nopen! Import\n\ntype never_returns = Nothing.t [@@deriving sexp_of]\n\nlet never_returns = Nothing.unreachable_code\n","open! Import\nopen! Caml.Nativeint\ninclude Nativeint_replace_polymorphic_compare\n\nmodule T = struct\n type t = nativeint [@@deriving_inline hash, sexp, sexp_grammar]\n\n let (hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state) =\n hash_fold_nativeint\n\n and (hash : t -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func = hash_nativeint in\n fun x -> func x\n ;;\n\n let t_of_sexp = (nativeint_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t)\n let sexp_of_t = (sexp_of_nativeint : t -> Ppx_sexp_conv_lib.Sexp.t)\n\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group) =\n { implicit_vars = [ \"nativeint\" ]\n ; ggid = \"\\146e\\023\\249\\235eE\\139c\\132W\\195\\137\\129\\235\\025\"\n ; types = [ \"t\", Implicit_var 0 ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ nativeint_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"nativeint.ml.T\"\n }\n in\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"t\", _the_group)\n in\n t_sexp_grammar\n ;;\n\n [@@@end]\n\n let compare = Nativeint_replace_polymorphic_compare.compare\n let to_string = to_string\n let of_string = of_string\nend\n\ninclude T\ninclude Comparator.Make (T)\n\ninclude Comparable.Validate_with_zero (struct\n include T\n\n let zero = zero\n end)\n\nmodule Conv = Int_conversions\ninclude Conv.Make (T)\n\ninclude Conv.Make_hex (struct\n open Nativeint_replace_polymorphic_compare\n\n type t = nativeint [@@deriving_inline compare, hash]\n\n let compare = (compare_nativeint : t -> t -> int)\n\n let (hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state) =\n hash_fold_nativeint\n\n and (hash : t -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func = hash_nativeint in\n fun x -> func x\n ;;\n\n [@@@end]\n\n let zero = zero\n let neg = neg\n let ( < ) = ( < )\n let to_string i = Printf.sprintf \"%nx\" i\n let of_string s = Caml.Scanf.sscanf s \"%nx\" Fn.id\n let module_name = \"Base.Nativeint.Hex\"\n end)\n\ninclude Pretty_printer.Register (struct\n type nonrec t = t\n\n let to_string = to_string\n let module_name = \"Base.Nativeint\"\n end)\n\n(* Open replace_polymorphic_compare after including functor instantiations so they do not\n shadow its definitions. This is here so that efficient versions of the comparison\n functions are available within this module. *)\nopen! Nativeint_replace_polymorphic_compare\n\nlet invariant (_ : t) = ()\nlet num_bits = Word_size.num_bits Word_size.word_size\nlet float_lower_bound = Float0.lower_bound_for_int num_bits\nlet float_upper_bound = Float0.upper_bound_for_int num_bits\nlet shift_right_logical = shift_right_logical\nlet shift_right = shift_right\nlet shift_left = shift_left\nlet bit_not = lognot\nlet bit_xor = logxor\nlet bit_or = logor\nlet bit_and = logand\nlet min_value = min_int\nlet max_value = max_int\nlet abs = abs\nlet pred = pred\nlet succ = succ\nlet rem = rem\nlet neg = neg\nlet minus_one = minus_one\nlet one = one\nlet zero = zero\nlet to_float = to_float\nlet of_float_unchecked = of_float\n\nlet of_float f =\n if Float_replace_polymorphic_compare.( >= ) f float_lower_bound\n && Float_replace_polymorphic_compare.( <= ) f float_upper_bound\n then of_float f\n else\n Printf.invalid_argf\n \"Nativeint.of_float: argument (%f) is out of range or NaN\"\n (Float0.box f)\n ()\n;;\n\nmodule Pow2 = struct\n open! Import\n open Nativeint_replace_polymorphic_compare\n module Sys = Sys0\n\n let raise_s = Error.raise_s\n\n let non_positive_argument () =\n Printf.invalid_argf \"argument must be strictly positive\" ()\n ;;\n\n let ( lor ) = Caml.Nativeint.logor\n let ( lsr ) = Caml.Nativeint.shift_right_logical\n let ( land ) = Caml.Nativeint.logand\n\n (** \"ceiling power of 2\" - Least power of 2 greater than or equal to x. *)\n let ceil_pow2 (x : nativeint) =\n if x <= 0n then non_positive_argument ();\n let x = Caml.Nativeint.pred x in\n let x = x lor (x lsr 1) in\n let x = x lor (x lsr 2) in\n let x = x lor (x lsr 4) in\n let x = x lor (x lsr 8) in\n let x = x lor (x lsr 16) in\n (* The next line is superfluous on 32-bit architectures, but it's faster to do it\n anyway than to branch *)\n let x = x lor (x lsr 32) in\n Caml.Nativeint.succ x\n ;;\n\n (** \"floor power of 2\" - Largest power of 2 less than or equal to x. *)\n let floor_pow2 x =\n if x <= 0n then non_positive_argument ();\n let x = x lor (x lsr 1) in\n let x = x lor (x lsr 2) in\n let x = x lor (x lsr 4) in\n let x = x lor (x lsr 8) in\n let x = x lor (x lsr 16) in\n let x = x lor (x lsr 32) in\n Caml.Nativeint.sub x (x lsr 1)\n ;;\n\n let is_pow2 x =\n if x <= 0n then non_positive_argument ();\n x land Caml.Nativeint.pred x = 0n\n ;;\n\n (* C stubs for nativeint clz and ctz to use the CLZ/BSR/CTZ/BSF instruction where possible *)\n external clz\n : (nativeint[@unboxed])\n -> (int[@untagged])\n = \"Base_int_math_nativeint_clz\" \"Base_int_math_nativeint_clz_unboxed\"\n [@@noalloc]\n\n external ctz\n : (nativeint[@unboxed])\n -> (int[@untagged])\n = \"Base_int_math_nativeint_ctz\" \"Base_int_math_nativeint_ctz_unboxed\"\n [@@noalloc]\n\n (** Hacker's Delight Second Edition p106 *)\n let floor_log2 i =\n if Poly.( <= ) i Caml.Nativeint.zero\n then\n raise_s\n (Sexp.message\n \"[Nativeint.floor_log2] got invalid input\"\n [ \"\", sexp_of_nativeint i ]);\n num_bits - 1 - clz i\n ;;\n\n (** Hacker's Delight Second Edition p106 *)\n let ceil_log2 i =\n if Poly.( <= ) i Caml.Nativeint.zero\n then\n raise_s\n (Sexp.message\n \"[Nativeint.ceil_log2] got invalid input\"\n [ \"\", sexp_of_nativeint i ]);\n if Caml.Nativeint.equal i Caml.Nativeint.one\n then 0\n else num_bits - clz (Caml.Nativeint.pred i)\n ;;\nend\n\ninclude Pow2\n\nlet between t ~low ~high = low <= t && t <= high\nlet clamp_unchecked t ~min ~max = if t < min then min else if t <= max then t else max\n\nlet clamp_exn t ~min ~max =\n assert (min <= max);\n clamp_unchecked t ~min ~max\n;;\n\nlet clamp t ~min ~max =\n if min > max\n then\n Or_error.error_s\n (Sexp.message\n \"clamp requires [min <= max]\"\n [ \"min\", T.sexp_of_t min; \"max\", T.sexp_of_t max ])\n else Ok (clamp_unchecked t ~min ~max)\n;;\n\nlet ( / ) = div\nlet ( * ) = mul\nlet ( - ) = sub\nlet ( + ) = add\nlet ( ~- ) = neg\nlet incr r = r := !r + one\nlet decr r = r := !r - one\nlet of_nativeint t = t\nlet of_nativeint_exn = of_nativeint\nlet to_nativeint t = t\nlet to_nativeint_exn = to_nativeint\nlet popcount = Popcount.nativeint_popcount\nlet of_int = Conv.int_to_nativeint\nlet of_int_exn = of_int\nlet to_int = Conv.nativeint_to_int\nlet to_int_exn = Conv.nativeint_to_int_exn\nlet to_int_trunc = Conv.nativeint_to_int_trunc\nlet of_int32 = Conv.int32_to_nativeint\nlet of_int32_exn = of_int32\nlet to_int32 = Conv.nativeint_to_int32\nlet to_int32_exn = Conv.nativeint_to_int32_exn\nlet to_int32_trunc = Conv.nativeint_to_int32_trunc\nlet of_int64 = Conv.int64_to_nativeint\nlet of_int64_exn = Conv.int64_to_nativeint_exn\nlet of_int64_trunc = Conv.int64_to_nativeint_trunc\nlet to_int64 = Conv.nativeint_to_int64\nlet pow b e = of_int_exn (Int_math.Private.int_pow (to_int_exn b) (to_int_exn e))\nlet ( ** ) b e = pow b e\n\nmodule Pre_O = struct\n let ( + ) = ( + )\n let ( - ) = ( - )\n let ( * ) = ( * )\n let ( / ) = ( / )\n let ( ~- ) = ( ~- )\n let ( ** ) = ( ** )\n\n include (Nativeint_replace_polymorphic_compare : Comparisons.Infix with type t := t)\n\n let abs = abs\n let neg = neg\n let zero = zero\n let of_int_exn = of_int_exn\nend\n\nmodule O = struct\n include Pre_O\n\n include Int_math.Make (struct\n type nonrec t = t\n\n include Pre_O\n\n let rem = rem\n let to_float = to_float\n let of_float = of_float\n let of_string = T.of_string\n let to_string = T.to_string\n end)\n\n let ( land ) = bit_and\n let ( lor ) = bit_or\n let ( lxor ) = bit_xor\n let lnot = bit_not\n let ( lsl ) = shift_left\n let ( asr ) = shift_right\n let ( lsr ) = shift_right_logical\nend\n\ninclude O\n\n(* [Nativeint] and [Nativeint.O] agree value-wise *)\n\n(* Include type-specific [Replace_polymorphic_compare] at the end, after\n including functor application that could shadow its definitions. This is\n here so that efficient versions of the comparison functions are exported by\n this module. *)\ninclude Nativeint_replace_polymorphic_compare\n\nexternal bswap : t -> t = \"%bswap_native\"\n","(***********************************************************************)\n(* *)\n(* Objective Caml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. All rights reserved. This file is distributed *)\n(* under the terms of the Apache 2.0 license. See ../THIRD-PARTY.txt *)\n(* for details. *)\n(* *)\n(***********************************************************************)\n\nopen! Import\nmodule List = List0\n\ninclude (\n Map_intf :\n sig\n module Or_duplicate = Map_intf.Or_duplicate\n module Continue_or_stop = Map_intf.Continue_or_stop\n module With_comparator = Map_intf.With_comparator\n module With_first_class_module = Map_intf.With_first_class_module\n module Without_comparator = Map_intf.Without_comparator\n\n (* The module susbstitutions below are needed for older versions of OCaml\n (before 4.07), because back then [module type of] did not keep module\n aliases. *)\n\n include module type of struct\n include Map_intf\n end\n with module Finished_or_unfinished := Map_intf.Finished_or_unfinished\n and module Or_duplicate := Or_duplicate\n and module Continue_or_stop := Continue_or_stop\n and module With_comparator := With_comparator\n and module With_first_class_module := With_first_class_module\n and module Without_comparator := Without_comparator\n end)\n\nmodule Finished_or_unfinished = struct\n include Map_intf.Finished_or_unfinished\n\n (* These two functions are tested in [test_map.ml] to make sure our use of\n [Caml.Obj.magic] is correct and safe. *)\n let of_continue_or_stop : Continue_or_stop.t -> t = Caml.Obj.magic\n let to_continue_or_stop : t -> Continue_or_stop.t = Caml.Obj.magic\nend\n\nlet with_return = With_return.with_return\n\nexception Duplicate [@@deriving_inline sexp]\n\nlet () =\n Ppx_sexp_conv_lib.Conv.Exn_converter.add [%extension_constructor Duplicate] (function\n | Duplicate -> Ppx_sexp_conv_lib.Sexp.Atom \"map.ml.Duplicate\"\n | _ -> assert false)\n;;\n\n[@@@end]\n\nmodule Tree0 = struct\n type ('k, 'v) t =\n | Empty\n | Leaf of 'k * 'v\n | Node of ('k, 'v) t * 'k * 'v * ('k, 'v) t * int\n\n type ('k, 'v) tree = ('k, 'v) t\n\n let height = function\n | Empty -> 0\n | Leaf _ -> 1\n | Node (_, _, _, _, h) -> h\n ;;\n\n let invariants =\n let in_range lower upper compare_key k =\n (match lower with\n | None -> true\n | Some lower -> compare_key lower k < 0)\n &&\n match upper with\n | None -> true\n | Some upper -> compare_key k upper < 0\n in\n let rec loop lower upper compare_key t =\n match t with\n | Empty -> true\n | Leaf (k, _) -> in_range lower upper compare_key k\n | Node (l, k, _, r, h) ->\n let hl = height l\n and hr = height r in\n abs (hl - hr) <= 2\n && h = max hl hr + 1\n && in_range lower upper compare_key k\n && loop lower (Some k) compare_key l\n && loop (Some k) upper compare_key r\n in\n fun t ~compare_key -> loop None None compare_key t\n ;;\n\n (* precondition: |height(l) - height(r)| <= 2 *)\n let create l x d r =\n let hl = height l\n and hr = height r in\n if hl = 0 && hr = 0\n then Leaf (x, d)\n else Node (l, x, d, r, if hl >= hr then hl + 1 else hr + 1)\n ;;\n\n let singleton key data = Leaf (key, data)\n\n (* We must call [f] with increasing indexes, because the bin_prot reader in\n Core_kernel.Map needs it. *)\n let of_increasing_iterator_unchecked ~len ~f =\n let rec loop n ~f i : (_, _) t =\n match n with\n | 0 -> Empty\n | 1 ->\n let k, v = f i in\n Leaf (k, v)\n | 2 ->\n let kl, vl = f i in\n let k, v = f (i + 1) in\n Node (Leaf (kl, vl), k, v, Empty, 2)\n | 3 ->\n let kl, vl = f i in\n let k, v = f (i + 1) in\n let kr, vr = f (i + 2) in\n Node (Leaf (kl, vl), k, v, Leaf (kr, vr), 2)\n | n ->\n let left_length = n lsr 1 in\n let right_length = n - left_length - 1 in\n let left = loop left_length ~f i in\n let k, v = f (i + left_length) in\n let right = loop right_length ~f (i + left_length + 1) in\n create left k v right\n in\n loop len ~f 0\n ;;\n\n let of_sorted_array_unchecked array ~compare_key =\n let array_length = Array.length array in\n let next =\n if array_length < 2\n ||\n let k0, _ = array.(0) in\n let k1, _ = array.(1) in\n compare_key k0 k1 < 0\n then fun i -> array.(i)\n else fun i -> array.(array_length - 1 - i)\n in\n of_increasing_iterator_unchecked ~len:array_length ~f:next, array_length\n ;;\n\n let of_sorted_array array ~compare_key =\n match array with\n | [||] | [| _ |] -> Result.Ok (of_sorted_array_unchecked array ~compare_key)\n | _ ->\n with_return (fun r ->\n let increasing =\n match compare_key (fst array.(0)) (fst array.(1)) with\n | 0 ->\n r.return (Or_error.error_string \"of_sorted_array: duplicated elements\")\n | i -> i < 0\n in\n for i = 1 to Array.length array - 2 do\n match compare_key (fst array.(i)) (fst array.(i + 1)) with\n | 0 ->\n r.return (Or_error.error_string \"of_sorted_array: duplicated elements\")\n | i ->\n if Poly.( <> ) (i < 0) increasing\n then\n r.return\n (Or_error.error_string \"of_sorted_array: elements are not ordered\")\n done;\n Result.Ok (of_sorted_array_unchecked array ~compare_key))\n ;;\n\n (* precondition: |height(l) - height(r)| <= 3 *)\n let bal l x d r =\n let hl = height l in\n let hr = height r in\n if hl > hr + 2\n then (\n match l with\n | Empty -> invalid_arg \"Map.bal\"\n | Leaf _ -> assert false (* height(Leaf) = 1 && 1 is not larger than hr + 2 *)\n | Node (ll, lv, ld, lr, _) ->\n if height ll >= height lr\n then create ll lv ld (create lr x d r)\n else (\n match lr with\n | Empty -> invalid_arg \"Map.bal\"\n | Leaf (lrv, lrd) ->\n create (create ll lv ld Empty) lrv lrd (create Empty x d r)\n | Node (lrl, lrv, lrd, lrr, _) ->\n create (create ll lv ld lrl) lrv lrd (create lrr x d r)))\n else if hr > hl + 2\n then (\n match r with\n | Empty -> invalid_arg \"Map.bal\"\n | Leaf _ -> assert false (* height(Leaf) = 1 && 1 is not larger than hl + 2 *)\n | Node (rl, rv, rd, rr, _) ->\n if height rr >= height rl\n then create (create l x d rl) rv rd rr\n else (\n match rl with\n | Empty -> invalid_arg \"Map.bal\"\n | Leaf (rlv, rld) ->\n create (create l x d Empty) rlv rld (create Empty rv rd rr)\n | Node (rll, rlv, rld, rlr, _) ->\n create (create l x d rll) rlv rld (create rlr rv rd rr)))\n else create l x d r\n ;;\n\n let empty = Empty\n\n let is_empty = function\n | Empty -> true\n | _ -> false\n ;;\n\n let raise_key_already_present ~key ~sexp_of_key =\n Error.raise_s\n (Sexp.message \"[Map.add_exn] got key already present\" [ \"key\", key |> sexp_of_key ])\n ;;\n\n module Add_or_set = struct\n type t =\n | Add_exn_internal\n | Add_exn\n | Set\n end\n\n\n let rec find_and_add_or_set\n t\n ~length\n ~key:x\n ~data\n ~compare_key\n ~sexp_of_key\n ~(add_or_set : Add_or_set.t)\n =\n match t with\n | Empty -> Leaf (x, data), length + 1\n | Leaf (v, d) ->\n let c = compare_key x v in\n if c = 0\n then (\n match add_or_set with\n | Add_exn_internal -> Exn.raise_without_backtrace Duplicate\n | Add_exn -> raise_key_already_present ~key:x ~sexp_of_key\n | Set -> Leaf (x, data), length)\n else if c < 0\n then Node (Leaf (x, data), v, d, Empty, 2), length + 1\n else Node (Empty, v, d, Leaf (x, data), 2), length + 1\n | Node (l, v, d, r, h) ->\n let c = compare_key x v in\n if c = 0\n then (\n match add_or_set with\n | Add_exn_internal -> Exn.raise_without_backtrace Duplicate\n | Add_exn -> raise_key_already_present ~key:x ~sexp_of_key\n | Set -> Node (l, x, data, r, h), length)\n else if c < 0\n then (\n let l, length =\n find_and_add_or_set\n ~length\n ~key:x\n ~data\n l\n ~compare_key\n ~sexp_of_key\n ~add_or_set\n in\n bal l v d r, length)\n else (\n let r, length =\n find_and_add_or_set\n ~length\n ~key:x\n ~data\n r\n ~compare_key\n ~sexp_of_key\n ~add_or_set\n in\n bal l v d r, length)\n ;;\n\n let add_exn t ~length ~key ~data ~compare_key ~sexp_of_key =\n find_and_add_or_set\n t\n ~length\n ~key\n ~data\n ~compare_key\n ~sexp_of_key\n ~add_or_set:Add_exn\n ;;\n\n let add_exn_internal t ~length ~key ~data ~compare_key ~sexp_of_key =\n find_and_add_or_set\n t\n ~length\n ~key\n ~data\n ~compare_key\n ~sexp_of_key\n ~add_or_set:Add_exn_internal\n ;;\n\n let set t ~length ~key ~data ~compare_key =\n find_and_add_or_set\n t\n ~length\n ~key\n ~data\n ~compare_key\n ~sexp_of_key:(fun _ -> List [])\n ~add_or_set:Set\n ;;\n\n let set' t key data ~compare_key = fst (set t ~length:0 ~key ~data ~compare_key)\n\n module Build_increasing = struct\n module Fragment = struct\n type nonrec ('k, 'v) t =\n { left_subtree : ('k, 'v) t\n ; key : 'k\n ; data : 'v\n }\n\n let singleton_to_tree_exn = function\n | { left_subtree = Empty; key; data } -> singleton key data\n | _ -> failwith \"Map.singleton_to_tree_exn: not a singleton\"\n ;;\n\n let singleton ~key ~data = { left_subtree = Empty; key; data }\n\n (* precondition: |height(l.left_subtree) - height(r)| <= 2,\n max_key(l) < min_key(r)\n *)\n let collapse l r = create l.left_subtree l.key l.data r\n\n (* precondition: |height(l.left_subtree) - height(r.left_subtree)| <= 2,\n max_key(l) < min_key(r)\n *)\n let join l r = { r with left_subtree = collapse l r.left_subtree }\n let max_key t = t.key\n end\n\n (** Build trees from singletons in a balanced way by using skew binary encoding.\n Each level contains trees of the same height, consecutive levels have consecutive\n heights. There are no gaps. The first level are single keys.\n *)\n type ('k, 'v) t =\n | Zero of unit\n (* [unit] to make pattern matching faster *)\n | One of ('k, 'v) t * ('k, 'v) Fragment.t\n | Two of ('k, 'v) t * ('k, 'v) Fragment.t * ('k, 'v) Fragment.t\n\n let empty = Zero ()\n\n let add_unchecked =\n let rec go t x =\n match t with\n | Zero () -> One (t, x)\n | One (t, y) -> Two (t, y, x)\n | Two (t, z, y) -> One (go t (Fragment.join z y), x)\n in\n fun t ~key ~data -> go t (Fragment.singleton ~key ~data)\n ;;\n\n let to_tree =\n let rec go t r =\n match t with\n | Zero () -> r\n | One (t, l) -> go t (Fragment.collapse l r)\n | Two (t, ll, l) -> go t (Fragment.collapse (Fragment.join ll l) r)\n in\n function\n | Zero () -> Empty\n | One (t, r) -> go t (Fragment.singleton_to_tree_exn r)\n | Two (t, l, r) -> go (One (t, l)) (Fragment.singleton_to_tree_exn r)\n ;;\n\n let max_key = function\n | Zero () -> None\n | One (_, r) | Two (_, _, r) -> Some (Fragment.max_key r)\n ;;\n end\n\n let of_increasing_sequence seq ~compare_key =\n with_return (fun { return } ->\n let builder, length =\n Sequence.fold\n seq\n ~init:(Build_increasing.empty, 0)\n ~f:(fun (builder, length) (key, data) ->\n match Build_increasing.max_key builder with\n | Some prev_key when compare_key prev_key key >= 0 ->\n return\n (Or_error.error_string \"of_increasing_sequence: non-increasing key\")\n | _ -> Build_increasing.add_unchecked builder ~key ~data, length + 1)\n in\n Ok (Build_increasing.to_tree builder, length))\n ;;\n\n (* Like [bal] but allows any difference in height between [l] and [r].\n\n O(|height l - height r|) *)\n let rec join l k d r ~compare_key =\n match l, r with\n | Empty, _ -> set' r k d ~compare_key\n | _, Empty -> set' l k d ~compare_key\n | Leaf (lk, ld), _ -> set' (set' r k d ~compare_key) lk ld ~compare_key\n | _, Leaf (rk, rd) -> set' (set' l k d ~compare_key) rk rd ~compare_key\n | Node (ll, lk, ld, lr, lh), Node (rl, rk, rd, rr, rh) ->\n (* [bal] requires height difference <= 3. *)\n if lh > rh + 3\n (* [height lr >= height r],\n therefore [height (join lr k d r ...)] is [height rl + 1] or [height rl]\n therefore the height difference with [ll] will be <= 3 *)\n then bal ll lk ld (join lr k d r ~compare_key)\n else if rh > lh + 3\n then bal (join l k d rl ~compare_key) rk rd rr\n else bal l k d r\n ;;\n\n let rec split t x ~compare_key =\n match t with\n | Empty -> Empty, None, Empty\n | Leaf (k, d) ->\n let cmp = compare_key x k in\n if cmp = 0\n then Empty, Some (k, d), Empty\n else if cmp < 0\n then Empty, None, t\n else t, None, Empty\n | Node (l, k, d, r, _) ->\n let cmp = compare_key x k in\n if cmp = 0\n then l, Some (k, d), r\n else if cmp < 0\n then (\n let ll, maybe, lr = split l x ~compare_key in\n ll, maybe, join lr k d r ~compare_key)\n else (\n let rl, maybe, rr = split r x ~compare_key in\n join l k d rl ~compare_key, maybe, rr)\n ;;\n\n let split_and_reinsert_boundary t ~into x ~compare_key =\n let left, boundary_opt, right = split t x ~compare_key in\n match boundary_opt with\n | None -> left, right\n | Some (key, data) ->\n let insert_into tree = fst (set tree ~key ~data ~length:0 ~compare_key) in\n (match into with\n | `Left -> insert_into left, right\n | `Right -> left, insert_into right)\n ;;\n\n let split_range\n t\n ~(lower_bound : 'a Maybe_bound.t)\n ~(upper_bound : 'a Maybe_bound.t)\n ~compare_key\n =\n if Maybe_bound.bounds_crossed\n ~compare:compare_key\n ~lower:lower_bound\n ~upper:upper_bound\n then empty, empty, empty\n else (\n let left, mid_and_right =\n match lower_bound with\n | Unbounded -> empty, t\n | Incl lb -> split_and_reinsert_boundary ~into:`Right t lb ~compare_key\n | Excl lb -> split_and_reinsert_boundary ~into:`Left t lb ~compare_key\n in\n let mid, right =\n match upper_bound with\n | Unbounded -> mid_and_right, empty\n | Incl lb ->\n split_and_reinsert_boundary ~into:`Left mid_and_right lb ~compare_key\n | Excl lb ->\n split_and_reinsert_boundary ~into:`Right mid_and_right lb ~compare_key\n in\n left, mid, right)\n ;;\n\n let rec find t x ~compare_key =\n match t with\n | Empty -> None\n | Leaf (v, d) -> if compare_key x v = 0 then Some d else None\n | Node (l, v, d, r, _) ->\n let c = compare_key x v in\n if c = 0 then Some d else find (if c < 0 then l else r) x ~compare_key\n ;;\n\n let add_multi t ~length ~key ~data ~compare_key =\n let data = data :: Option.value (find t key ~compare_key) ~default:[] in\n set ~length ~key ~data t ~compare_key\n ;;\n\n let find_multi t x ~compare_key =\n match find t x ~compare_key with\n | None -> []\n | Some l -> l\n ;;\n\n let find_exn =\n let if_not_found key ~sexp_of_key =\n raise (Not_found_s (List [ Atom \"Map.find_exn: not found\"; sexp_of_key key ]))\n in\n let rec find_exn t x ~compare_key ~sexp_of_key =\n match t with\n | Empty -> if_not_found x ~sexp_of_key\n | Leaf (v, d) -> if compare_key x v = 0 then d else if_not_found x ~sexp_of_key\n | Node (l, v, d, r, _) ->\n let c = compare_key x v in\n if c = 0\n then d\n else find_exn (if c < 0 then l else r) x ~compare_key ~sexp_of_key\n in\n (* named to preserve symbol in compiled binary *)\n find_exn\n ;;\n\n let mem t x ~compare_key = Option.is_some (find t x ~compare_key)\n\n let rec min_elt = function\n | Empty -> None\n | Leaf (k, d) -> Some (k, d)\n | Node (Empty, k, d, _, _) -> Some (k, d)\n | Node (l, _, _, _, _) -> min_elt l\n ;;\n\n exception Map_min_elt_exn_of_empty_map [@@deriving_inline sexp]\n\n let () =\n Ppx_sexp_conv_lib.Conv.Exn_converter.add\n [%extension_constructor Map_min_elt_exn_of_empty_map]\n (function\n | Map_min_elt_exn_of_empty_map ->\n Ppx_sexp_conv_lib.Sexp.Atom \"map.ml.Tree0.Map_min_elt_exn_of_empty_map\"\n | _ -> assert false)\n ;;\n\n [@@@end]\n\n exception Map_max_elt_exn_of_empty_map [@@deriving_inline sexp]\n\n let () =\n Ppx_sexp_conv_lib.Conv.Exn_converter.add\n [%extension_constructor Map_max_elt_exn_of_empty_map]\n (function\n | Map_max_elt_exn_of_empty_map ->\n Ppx_sexp_conv_lib.Sexp.Atom \"map.ml.Tree0.Map_max_elt_exn_of_empty_map\"\n | _ -> assert false)\n ;;\n\n [@@@end]\n\n let min_elt_exn t =\n match min_elt t with\n | None -> raise Map_min_elt_exn_of_empty_map\n | Some v -> v\n ;;\n\n let rec max_elt = function\n | Empty -> None\n | Leaf (k, d) -> Some (k, d)\n | Node (_, k, d, Empty, _) -> Some (k, d)\n | Node (_, _, _, r, _) -> max_elt r\n ;;\n\n let max_elt_exn t =\n match max_elt t with\n | None -> raise Map_max_elt_exn_of_empty_map\n | Some v -> v\n ;;\n\n let rec remove_min_elt t =\n match t with\n | Empty -> invalid_arg \"Map.remove_min_elt\"\n | Leaf _ -> Empty\n | Node (Empty, _, _, r, _) -> r\n | Node (l, x, d, r, _) -> bal (remove_min_elt l) x d r\n ;;\n\n let append ~lower_part ~upper_part ~compare_key =\n match max_elt lower_part, min_elt upper_part with\n | None, _ -> `Ok upper_part\n | _, None -> `Ok lower_part\n | Some (max_lower, _), Some (min_upper, v) when compare_key max_lower min_upper < 0\n ->\n let upper_part_without_min = remove_min_elt upper_part in\n `Ok (join ~compare_key lower_part min_upper v upper_part_without_min)\n | _ -> `Overlapping_key_ranges\n ;;\n\n let fold_range_inclusive =\n (* This assumes that min <= max, which is checked by the outer function. *)\n let rec go t ~min ~max ~init ~f ~compare_key =\n match t with\n | Empty -> init\n | Leaf (k, d) ->\n if compare_key k min < 0 || compare_key k max > 0\n then (* k < min || k > max *)\n init\n else f ~key:k ~data:d init\n | Node (l, k, d, r, _) ->\n let c_min = compare_key k min in\n if c_min < 0\n then\n (* if k < min, then this node and its left branch are outside our range *)\n go r ~min ~max ~init ~f ~compare_key\n else if c_min = 0\n then\n (* if k = min, then this node's left branch is outside our range *)\n go r ~min ~max ~init:(f ~key:k ~data:d init) ~f ~compare_key\n else (\n (* k > min *)\n let z = go l ~min ~max ~init ~f ~compare_key in\n let c_max = compare_key k max in\n (* if k > max, we're done *)\n if c_max > 0\n then z\n else (\n let z = f ~key:k ~data:d z in\n (* if k = max, then we fold in this one last value and we're done *)\n if c_max = 0 then z else go r ~min ~max ~init:z ~f ~compare_key))\n in\n fun t ~min ~max ~init ~f ~compare_key ->\n if compare_key min max <= 0 then go t ~min ~max ~init ~f ~compare_key else init\n ;;\n\n let range_to_alist t ~min ~max ~compare_key =\n List.rev\n (fold_range_inclusive\n t\n ~min\n ~max\n ~init:[]\n ~f:(fun ~key ~data l -> (key, data) :: l)\n ~compare_key)\n ;;\n\n let concat_unchecked t1 t2 =\n match t1, t2 with\n | Empty, t -> t\n | t, Empty -> t\n | _, _ ->\n let x, d = min_elt_exn t2 in\n bal t1 x d (remove_min_elt t2)\n ;;\n\n let rec remove t x ~length ~compare_key =\n match t with\n | Empty -> Empty, length\n | Leaf (v, _) -> if compare_key x v = 0 then Empty, length - 1 else t, length\n | Node (l, v, d, r, _) ->\n let c = compare_key x v in\n if c = 0\n then concat_unchecked l r, length - 1\n else if c < 0\n then (\n let l, length = remove l x ~length ~compare_key in\n bal l v d r, length)\n else (\n let r, length = remove r x ~length ~compare_key in\n bal l v d r, length)\n ;;\n\n (* Use exception to avoid tree-rebuild in no-op case *)\n exception Change_no_op\n\n let change t key ~f ~length ~compare_key =\n let rec change_core t key f =\n match t with\n | Empty ->\n (match f None with\n | None -> raise Change_no_op (* equivalent to returning: Empty *)\n | Some data -> Leaf (key, data), length + 1)\n | Leaf (v, d) ->\n let c = compare_key key v in\n if c = 0\n then (\n match f (Some d) with\n | None -> Empty, length - 1\n | Some d' -> Leaf (v, d'), length)\n else if c < 0\n then (\n let l, length = change_core Empty key f in\n bal l v d Empty, length)\n else (\n let r, length = change_core Empty key f in\n bal Empty v d r, length)\n | Node (l, v, d, r, h) ->\n let c = compare_key key v in\n if c = 0\n then (\n match f (Some d) with\n | None -> concat_unchecked l r, length - 1\n | Some data -> Node (l, key, data, r, h), length)\n else if c < 0\n then (\n let l, length = change_core l key f in\n bal l v d r, length)\n else (\n let r, length = change_core r key f in\n bal l v d r, length)\n in\n try change_core t key f with\n | Change_no_op -> t, length\n ;;\n\n let update t key ~f ~length ~compare_key =\n let rec update_core t key f =\n match t with\n | Empty ->\n let data = f None in\n Leaf (key, data), length + 1\n | Leaf (v, d) ->\n let c = compare_key key v in\n if c = 0\n then (\n let d' = f (Some d) in\n Leaf (v, d'), length)\n else if c < 0\n then (\n let l, length = update_core Empty key f in\n bal l v d Empty, length)\n else (\n let r, length = update_core Empty key f in\n bal Empty v d r, length)\n | Node (l, v, d, r, h) ->\n let c = compare_key key v in\n if c = 0\n then (\n let data = f (Some d) in\n Node (l, key, data, r, h), length)\n else if c < 0\n then (\n let l, length = update_core l key f in\n bal l v d r, length)\n else (\n let r, length = update_core r key f in\n bal l v d r, length)\n in\n update_core t key f\n ;;\n\n let remove_multi t key ~length ~compare_key =\n change t key ~length ~compare_key ~f:(function\n | None | Some ([] | [ _ ]) -> None\n | Some (_ :: (_ :: _ as non_empty_tail)) -> Some non_empty_tail)\n ;;\n\n let rec iter_keys t ~f =\n match t with\n | Empty -> ()\n | Leaf (v, _) -> f v\n | Node (l, v, _, r, _) ->\n iter_keys ~f l;\n f v;\n iter_keys ~f r\n ;;\n\n let rec iter t ~f =\n match t with\n | Empty -> ()\n | Leaf (_, d) -> f d\n | Node (l, _, d, r, _) ->\n iter ~f l;\n f d;\n iter ~f r\n ;;\n\n let rec iteri t ~f =\n match t with\n | Empty -> ()\n | Leaf (v, d) -> f ~key:v ~data:d\n | Node (l, v, d, r, _) ->\n iteri ~f l;\n f ~key:v ~data:d;\n iteri ~f r\n ;;\n\n let iteri_until =\n let rec iteri_until_loop t ~f : Continue_or_stop.t =\n match t with\n | Empty -> Continue\n | Leaf (v, d) -> f ~key:v ~data:d\n | Node (l, v, d, r, _) ->\n (match iteri_until_loop ~f l with\n | Stop -> Stop\n | Continue ->\n (match f ~key:v ~data:d with\n | Stop -> Stop\n | Continue -> iteri_until_loop ~f r))\n in\n fun t ~f -> Finished_or_unfinished.of_continue_or_stop (iteri_until_loop t ~f)\n ;;\n\n let rec map t ~f =\n match t with\n | Empty -> Empty\n | Leaf (v, d) -> Leaf (v, f d)\n | Node (l, v, d, r, h) ->\n let l' = map ~f l in\n let d' = f d in\n let r' = map ~f r in\n Node (l', v, d', r', h)\n ;;\n\n let rec mapi t ~f =\n match t with\n | Empty -> Empty\n | Leaf (v, d) -> Leaf (v, f ~key:v ~data:d)\n | Node (l, v, d, r, h) ->\n let l' = mapi ~f l in\n let d' = f ~key:v ~data:d in\n let r' = mapi ~f r in\n Node (l', v, d', r', h)\n ;;\n\n let rec fold t ~init:accu ~f =\n match t with\n | Empty -> accu\n | Leaf (v, d) -> f ~key:v ~data:d accu\n | Node (l, v, d, r, _) -> fold ~f r ~init:(f ~key:v ~data:d (fold ~f l ~init:accu))\n ;;\n\n let rec fold_right t ~init:accu ~f =\n match t with\n | Empty -> accu\n | Leaf (v, d) -> f ~key:v ~data:d accu\n | Node (l, v, d, r, _) ->\n fold_right ~f l ~init:(f ~key:v ~data:d (fold_right ~f r ~init:accu))\n ;;\n\n let filter_keys t ~f ~compare_key =\n fold ~init:(Empty, 0) t ~f:(fun ~key ~data (accu, length) ->\n if f key then set ~length ~key ~data accu ~compare_key else accu, length)\n ;;\n\n\n let filter t ~f ~compare_key =\n fold ~init:(Empty, 0) t ~f:(fun ~key ~data (accu, length) ->\n if f data then set ~length ~key ~data accu ~compare_key else accu, length)\n ;;\n\n let filteri t ~f ~compare_key =\n fold ~init:(Empty, 0) t ~f:(fun ~key ~data (accu, length) ->\n if f ~key ~data then set ~length ~key ~data accu ~compare_key else accu, length)\n ;;\n\n let filter_map t ~f ~compare_key =\n fold ~init:(Empty, 0) t ~f:(fun ~key ~data (accu, length) ->\n match f data with\n | None -> accu, length\n | Some b -> set ~length ~key ~data:b accu ~compare_key)\n ;;\n\n let filter_mapi t ~f ~compare_key =\n fold ~init:(Empty, 0) t ~f:(fun ~key ~data (accu, length) ->\n match f ~key ~data with\n | None -> accu, length\n | Some b -> set ~length ~key ~data:b accu ~compare_key)\n ;;\n\n let partition_mapi t ~f ~compare_key =\n fold\n t\n ~init:((Empty, 0), (Empty, 0))\n ~f:(fun ~key ~data (pair1, pair2) ->\n match (f ~key ~data : _ Either.t) with\n | First x ->\n let t, length = pair1 in\n set t ~key ~data:x ~compare_key ~length, pair2\n | Second y ->\n let t, length = pair2 in\n pair1, set t ~key ~data:y ~compare_key ~length)\n ;;\n\n let partition_map t ~f ~compare_key =\n partition_mapi t ~compare_key ~f:(fun ~key:_ ~data -> f data)\n ;;\n\n let partitioni_tf t ~f ~compare_key =\n partition_mapi t ~compare_key ~f:(fun ~key ~data ->\n if f ~key ~data then First data else Second data)\n ;;\n\n let partition_tf t ~f ~compare_key =\n partition_mapi t ~compare_key ~f:(fun ~key:_ ~data ->\n if f data then First data else Second data)\n ;;\n\n module Enum = struct\n type increasing\n type decreasing\n\n type ('k, 'v, 'direction) t =\n | End\n | More of 'k * 'v * ('k, 'v) tree * ('k, 'v, 'direction) t\n\n let rec cons t (e : (_, _, increasing) t) : (_, _, increasing) t =\n match t with\n | Empty -> e\n | Leaf (v, d) -> More (v, d, Empty, e)\n | Node (l, v, d, r, _) -> cons l (More (v, d, r, e))\n ;;\n\n let rec cons_right t (e : (_, _, decreasing) t) : (_, _, decreasing) t =\n match t with\n | Empty -> e\n | Leaf (v, d) -> More (v, d, Empty, e)\n | Node (l, v, d, r, _) -> cons_right r (More (v, d, l, e))\n ;;\n\n let of_tree tree : (_, _, increasing) t = cons tree End\n let of_tree_right tree : (_, _, decreasing) t = cons_right tree End\n\n let starting_at_increasing t key compare : (_, _, increasing) t =\n let rec loop t e =\n match t with\n | Empty -> e\n | Leaf (v, d) -> loop (Node (Empty, v, d, Empty, 1)) e\n | Node (_, v, _, r, _) when compare v key < 0 -> loop r e\n | Node (l, v, d, r, _) -> loop l (More (v, d, r, e))\n in\n loop t End\n ;;\n\n let starting_at_decreasing t key compare : (_, _, decreasing) t =\n let rec loop t e =\n match t with\n | Empty -> e\n | Leaf (v, d) -> loop (Node (Empty, v, d, Empty, 1)) e\n | Node (l, v, _, _, _) when compare v key > 0 -> loop l e\n | Node (l, v, d, r, _) -> loop r (More (v, d, l, e))\n in\n loop t End\n ;;\n\n let compare compare_key compare_data t1 t2 =\n let rec loop t1 t2 =\n match t1, t2 with\n | End, End -> 0\n | End, _ -> -1\n | _, End -> 1\n | More (v1, d1, r1, e1), More (v2, d2, r2, e2) ->\n let c = compare_key v1 v2 in\n if c <> 0\n then c\n else (\n let c = compare_data d1 d2 in\n if c <> 0\n then c\n else if phys_equal r1 r2\n then loop e1 e2\n else loop (cons r1 e1) (cons r2 e2))\n in\n loop t1 t2\n ;;\n\n let equal compare_key data_equal t1 t2 =\n let rec loop t1 t2 =\n match t1, t2 with\n | End, End -> true\n | End, _ | _, End -> false\n | More (v1, d1, r1, e1), More (v2, d2, r2, e2) ->\n compare_key v1 v2 = 0\n && data_equal d1 d2\n && if phys_equal r1 r2 then loop e1 e2 else loop (cons r1 e1) (cons r2 e2)\n in\n loop t1 t2\n ;;\n\n let rec fold ~init ~f = function\n | End -> init\n | More (key, data, tree, enum) ->\n let next = f ~key ~data init in\n fold (cons tree enum) ~init:next ~f\n ;;\n\n let fold2 compare_key t1 t2 ~init ~f =\n let rec loop t1 t2 curr =\n match t1, t2 with\n | End, End -> curr\n | End, _ ->\n fold t2 ~init:curr ~f:(fun ~key ~data acc -> f ~key ~data:(`Right data) acc)\n | _, End ->\n fold t1 ~init:curr ~f:(fun ~key ~data acc -> f ~key ~data:(`Left data) acc)\n | More (k1, v1, tree1, enum1), More (k2, v2, tree2, enum2) ->\n let compare_result = compare_key k1 k2 in\n if compare_result = 0\n then (\n let next = f ~key:k1 ~data:(`Both (v1, v2)) curr in\n loop (cons tree1 enum1) (cons tree2 enum2) next)\n else if compare_result < 0\n then (\n let next = f ~key:k1 ~data:(`Left v1) curr in\n loop (cons tree1 enum1) t2 next)\n else (\n let next = f ~key:k2 ~data:(`Right v2) curr in\n loop t1 (cons tree2 enum2) next)\n in\n loop t1 t2 init\n ;;\n\n let symmetric_diff t1 t2 ~compare_key ~data_equal =\n let step state =\n match state with\n | End, End -> Sequence.Step.Done\n | End, More (key, data, tree, enum) ->\n Sequence.Step.Yield ((key, `Right data), (End, cons tree enum))\n | More (key, data, tree, enum), End ->\n Sequence.Step.Yield ((key, `Left data), (cons tree enum, End))\n | (More (k1, v1, tree1, enum1) as left), (More (k2, v2, tree2, enum2) as right)\n ->\n let compare_result = compare_key k1 k2 in\n if compare_result = 0\n then (\n let next_state =\n if phys_equal tree1 tree2\n then enum1, enum2\n else cons tree1 enum1, cons tree2 enum2\n in\n if data_equal v1 v2\n then Sequence.Step.Skip next_state\n else Sequence.Step.Yield ((k1, `Unequal (v1, v2)), next_state))\n else if compare_result < 0\n then Sequence.Step.Yield ((k1, `Left v1), (cons tree1 enum1, right))\n else Sequence.Step.Yield ((k2, `Right v2), (left, cons tree2 enum2))\n in\n Sequence.unfold_step ~init:(of_tree t1, of_tree t2) ~f:step\n ;;\n\n let fold_symmetric_diff t1 t2 ~compare_key ~data_equal ~init ~f =\n let add acc k v = f acc (k, `Right v) in\n let remove acc k v = f acc (k, `Left v) in\n let rec loop left right acc =\n match left, right with\n | End, enum -> fold enum ~init:acc ~f:(fun ~key ~data acc -> add acc key data)\n | enum, End -> fold enum ~init:acc ~f:(fun ~key ~data acc -> remove acc key data)\n | (More (k1, v1, tree1, enum1) as left), (More (k2, v2, tree2, enum2) as right)\n ->\n let compare_result = compare_key k1 k2 in\n if compare_result = 0\n then (\n let acc = if data_equal v1 v2 then acc else f acc (k1, `Unequal (v1, v2)) in\n if phys_equal tree1 tree2\n then loop enum1 enum2 acc\n else loop (cons tree1 enum1) (cons tree2 enum2) acc)\n else if compare_result < 0\n then (\n let acc = remove acc k1 v1 in\n loop (cons tree1 enum1) right acc)\n else (\n let acc = add acc k2 v2 in\n loop left (cons tree2 enum2) acc)\n in\n loop (of_tree t1) (of_tree t2) init\n ;;\n end\n\n let to_sequence_increasing comparator ~from_key t =\n let next enum =\n match enum with\n | Enum.End -> Sequence.Step.Done\n | Enum.More (k, v, t, e) -> Sequence.Step.Yield ((k, v), Enum.cons t e)\n in\n let init =\n match from_key with\n | None -> Enum.of_tree t\n | Some key -> Enum.starting_at_increasing t key comparator.Comparator.compare\n in\n Sequence.unfold_step ~init ~f:next\n ;;\n\n let to_sequence_decreasing comparator ~from_key t =\n let next enum =\n match enum with\n | Enum.End -> Sequence.Step.Done\n | Enum.More (k, v, t, e) -> Sequence.Step.Yield ((k, v), Enum.cons_right t e)\n in\n let init =\n match from_key with\n | None -> Enum.of_tree_right t\n | Some key -> Enum.starting_at_decreasing t key comparator.Comparator.compare\n in\n Sequence.unfold_step ~init ~f:next\n ;;\n\n let to_sequence\n comparator\n ?(order = `Increasing_key)\n ?keys_greater_or_equal_to\n ?keys_less_or_equal_to\n t\n =\n let inclusive_bound side t bound =\n let compare_key = comparator.Comparator.compare in\n let l, maybe, r = split t bound ~compare_key in\n let t = side (l, r) in\n match maybe with\n | None -> t\n | Some (key, data) -> set' t key data ~compare_key\n in\n match order with\n | `Increasing_key ->\n let t = Option.fold keys_less_or_equal_to ~init:t ~f:(inclusive_bound fst) in\n to_sequence_increasing comparator ~from_key:keys_greater_or_equal_to t\n | `Decreasing_key ->\n let t = Option.fold keys_greater_or_equal_to ~init:t ~f:(inclusive_bound snd) in\n to_sequence_decreasing comparator ~from_key:keys_less_or_equal_to t\n ;;\n\n let compare compare_key compare_data t1 t2 =\n Enum.compare compare_key compare_data (Enum.of_tree t1) (Enum.of_tree t2)\n ;;\n\n let equal compare_key compare_data t1 t2 =\n Enum.equal compare_key compare_data (Enum.of_tree t1) (Enum.of_tree t2)\n ;;\n\n let iter2 t1 t2 ~f ~compare_key =\n Enum.fold2\n compare_key\n (Enum.of_tree t1)\n (Enum.of_tree t2)\n ~init:()\n ~f:(fun ~key ~data () -> f ~key ~data)\n ;;\n\n let fold2 t1 t2 ~init ~f ~compare_key =\n Enum.fold2 compare_key (Enum.of_tree t1) (Enum.of_tree t2) ~f ~init\n ;;\n\n let symmetric_diff = Enum.symmetric_diff\n\n let fold_symmetric_diff t1 t2 ~compare_key ~data_equal ~init ~f =\n (* [Enum.fold_diffs] is a correct implementation of this function, but is considerably\n slower, as we have to allocate quite a lot of state to track enumeration of a tree.\n Avoid if we can.\n *)\n let slow x y ~init =\n Enum.fold_symmetric_diff x y ~compare_key ~data_equal ~f ~init\n in\n let add acc k v = f acc (k, `Right v) in\n let remove acc k v = f acc (k, `Left v) in\n let delta acc k v v' =\n if data_equal v v' then acc else f acc (k, `Unequal (v, v'))\n in\n (* If two trees have the same structure at the root (and the same key, if they're\n [Node]s) we can trivially diff each subpart in obvious ways. *)\n let rec loop t t' acc =\n if phys_equal t t'\n then acc\n else (\n match t, t' with\n | Empty, new_vals ->\n fold new_vals ~init:acc ~f:(fun ~key ~data acc -> add acc key data)\n | old_vals, Empty ->\n fold old_vals ~init:acc ~f:(fun ~key ~data acc -> remove acc key data)\n | Leaf (k, v), Leaf (k', v') ->\n (match compare_key k k' with\n | x when x = 0 -> delta acc k v v'\n | x when x < 0 ->\n let acc = remove acc k v in\n add acc k' v'\n | _ (* when x > 0 *) ->\n let acc = add acc k' v' in\n remove acc k v)\n | Node (l, k, v, r, _), Node (l', k', v', r', _) when compare_key k k' = 0 ->\n let acc = loop l l' acc in\n let acc = delta acc k v v' in\n loop r r' acc\n (* Our roots aren't the same key. Fallback to the slow mode. Trees with small\n diffs will only do this on very small parts of the tree (hopefully - if the\n overall root is rebalanced, we'll eat the whole cost, unfortunately.) *)\n | Node _, Node _ | Node _, Leaf _ | Leaf _, Node _ -> slow t t' ~init:acc)\n in\n loop t1 t2 init\n ;;\n\n let rec length = function\n | Empty -> 0\n | Leaf _ -> 1\n | Node (l, _, _, r, _) -> length l + length r + 1\n ;;\n\n let hash_fold_t_ignoring_structure hash_fold_key hash_fold_data state t =\n fold\n t\n ~init:(hash_fold_int state (length t))\n ~f:(fun ~key ~data state -> hash_fold_data (hash_fold_key state key) data)\n ;;\n\n let keys t = fold_right ~f:(fun ~key ~data:_ list -> key :: list) t ~init:[]\n let data t = fold_right ~f:(fun ~key:_ ~data list -> data :: list) t ~init:[]\n\n module type Foldable = sig\n val name : string\n\n type 'a t\n\n val fold : 'a t -> init:'b -> f:('b -> 'a -> 'b) -> 'b\n end\n\n module Of_foldable (M : Foldable) = struct\n let of_foldable_fold foldable ~init ~f ~compare_key =\n M.fold foldable ~init:(empty, 0) ~f:(fun (accum, length) (key, data) ->\n let prev_data =\n match find accum key ~compare_key with\n | None -> init\n | Some prev -> prev\n in\n let data = f prev_data data in\n set accum ~length ~key ~data ~compare_key)\n ;;\n\n let of_foldable_reduce foldable ~f ~compare_key =\n M.fold foldable ~init:(empty, 0) ~f:(fun (accum, length) (key, data) ->\n let new_data =\n match find accum key ~compare_key with\n | None -> data\n | Some prev -> f prev data\n in\n set accum ~length ~key ~data:new_data ~compare_key)\n ;;\n\n let of_foldable foldable ~compare_key =\n with_return (fun r ->\n let map =\n M.fold foldable ~init:(empty, 0) ~f:(fun (t, length) (key, data) ->\n let ((_, length') as acc) = set ~length ~key ~data t ~compare_key in\n if length = length' then r.return (`Duplicate_key key) else acc)\n in\n `Ok map)\n ;;\n\n let of_foldable_or_error foldable ~comparator =\n match of_foldable foldable ~compare_key:comparator.Comparator.compare with\n | `Ok x -> Result.Ok x\n | `Duplicate_key key ->\n Or_error.error\n (\"Map.of_\" ^ M.name ^ \"_or_error: duplicate key\")\n key\n comparator.sexp_of_t\n ;;\n\n let of_foldable_exn foldable ~comparator =\n match of_foldable foldable ~compare_key:comparator.Comparator.compare with\n | `Ok x -> x\n | `Duplicate_key key ->\n Error.create\n (\"Map.of_\" ^ M.name ^ \"_exn: duplicate key\")\n key\n comparator.sexp_of_t\n |> Error.raise\n ;;\n end\n\n module Of_alist = Of_foldable (struct\n let name = \"alist\"\n\n type 'a t = 'a list\n\n let fold = List.fold\n end)\n\n let of_alist_fold = Of_alist.of_foldable_fold\n let of_alist_reduce = Of_alist.of_foldable_reduce\n let of_alist = Of_alist.of_foldable\n let of_alist_or_error = Of_alist.of_foldable_or_error\n let of_alist_exn = Of_alist.of_foldable_exn\n\n (* Reverse the input, then fold from left to right. The resulting map uses the first\n instance of each key from the input list. The relative ordering of elements in each\n output list is the same as in the input list. *)\n let of_foldable_multi foldable ~fold ~compare_key =\n let alist = fold foldable ~init:[] ~f:(fun l x -> x :: l) in\n of_alist_fold alist ~init:[] ~f:(fun l x -> x :: l) ~compare_key\n ;;\n\n let of_alist_multi alist ~compare_key =\n of_foldable_multi alist ~fold:List.fold ~compare_key\n ;;\n\n module Of_sequence = Of_foldable (struct\n let name = \"sequence\"\n\n type 'a t = 'a Sequence.t\n\n let fold = Sequence.fold\n end)\n\n let of_sequence_fold = Of_sequence.of_foldable_fold\n let of_sequence_reduce = Of_sequence.of_foldable_reduce\n let of_sequence = Of_sequence.of_foldable\n let of_sequence_or_error = Of_sequence.of_foldable_or_error\n let of_sequence_exn = Of_sequence.of_foldable_exn\n\n let of_sequence_multi sequence ~compare_key =\n of_foldable_multi sequence ~fold:Sequence.fold ~compare_key\n ;;\n\n let for_all t ~f =\n with_return (fun r ->\n iter t ~f:(fun data -> if not (f data) then r.return false);\n true)\n ;;\n\n let for_alli t ~f =\n with_return (fun r ->\n iteri t ~f:(fun ~key ~data -> if not (f ~key ~data) then r.return false);\n true)\n ;;\n\n let exists t ~f =\n with_return (fun r ->\n iter t ~f:(fun data -> if f data then r.return true);\n false)\n ;;\n\n let existsi t ~f =\n with_return (fun r ->\n iteri t ~f:(fun ~key ~data -> if f ~key ~data then r.return true);\n false)\n ;;\n\n let count t ~f =\n fold t ~init:0 ~f:(fun ~key:_ ~data acc -> if f data then acc + 1 else acc)\n ;;\n\n let counti t ~f =\n fold t ~init:0 ~f:(fun ~key ~data acc -> if f ~key ~data then acc + 1 else acc)\n ;;\n\n let to_alist ?(key_order = `Increasing) t =\n match key_order with\n | `Increasing -> fold_right t ~init:[] ~f:(fun ~key ~data x -> (key, data) :: x)\n | `Decreasing -> fold t ~init:[] ~f:(fun ~key ~data x -> (key, data) :: x)\n ;;\n\n let merge t1 t2 ~f ~compare_key =\n let elts = Uniform_array.unsafe_create_uninitialized ~len:(length t1 + length t2) in\n let i = ref 0 in\n iter2 t1 t2 ~compare_key ~f:(fun ~key ~data:values ->\n match f ~key values with\n | Some value ->\n Uniform_array.set elts !i (key, value);\n incr i\n | None -> ());\n let len = !i in\n let get i = Uniform_array.get elts i in\n let tree = of_increasing_iterator_unchecked ~len ~f:get in\n tree, len\n ;;\n\n module Closest_key_impl = struct\n (* [marker] and [repackage] allow us to create \"logical\" options without actually\n allocating any options. Passing [Found key value] to a function is equivalent to\n passing [Some (key, value)]; passing [Missing () ()] is equivalent to passing\n [None]. *)\n type ('k, 'v, 'k_opt, 'v_opt) marker =\n | Missing : ('k, 'v, unit, unit) marker\n | Found : ('k, 'v, 'k, 'v) marker\n\n let repackage\n (type k v k_opt v_opt)\n (marker : (k, v, k_opt, v_opt) marker)\n (k : k_opt)\n (v : v_opt)\n : (k * v) option\n =\n match marker with\n | Missing -> None\n | Found -> Some (k, v)\n ;;\n\n (* The type signature is explicit here to allow polymorphic recursion. *)\n let rec loop :\n 'k 'v 'k_opt 'v_opt. ('k, 'v) tree\n -> [ `Greater_or_equal_to | `Greater_than | `Less_or_equal_to | `Less_than ]\n -> 'k -> compare_key:('k -> 'k -> int) -> ('k, 'v, 'k_opt, 'v_opt) marker\n -> 'k_opt -> 'v_opt -> ('k * 'v) option\n =\n fun t dir k ~compare_key found_marker found_key found_value ->\n match t with\n | Empty -> repackage found_marker found_key found_value\n | Leaf (k', v') ->\n let c = compare_key k' k in\n if match dir with\n | `Greater_or_equal_to -> c >= 0\n | `Greater_than -> c > 0\n | `Less_or_equal_to -> c <= 0\n | `Less_than -> c < 0\n then Some (k', v')\n else repackage found_marker found_key found_value\n | Node (l, k', v', r, _) ->\n let c = compare_key k' k in\n if c = 0\n then (\n (* This is a base case (no recursive call). *)\n match dir with\n | `Greater_or_equal_to | `Less_or_equal_to -> Some (k', v')\n | `Greater_than ->\n if is_empty r\n then repackage found_marker found_key found_value\n else min_elt r\n | `Less_than ->\n if is_empty l\n then repackage found_marker found_key found_value\n else max_elt l)\n else (\n (* We are guaranteed here that k' <> k. *)\n (* This is the only recursive case. *)\n match dir with\n | `Greater_or_equal_to | `Greater_than ->\n if c > 0\n then loop l dir k ~compare_key Found k' v'\n else loop r dir k ~compare_key found_marker found_key found_value\n | `Less_or_equal_to | `Less_than ->\n if c < 0\n then loop r dir k ~compare_key Found k' v'\n else loop l dir k ~compare_key found_marker found_key found_value)\n ;;\n\n let closest_key t dir k ~compare_key = loop t dir k ~compare_key Missing () ()\n end\n\n let closest_key = Closest_key_impl.closest_key\n\n let rec rank t k ~compare_key =\n match t with\n | Empty -> None\n | Leaf (k', _) -> if compare_key k' k = 0 then Some 0 else None\n | Node (l, k', _, r, _) ->\n let c = compare_key k' k in\n if c = 0\n then Some (length l)\n else if c > 0\n then rank l k ~compare_key\n else Option.map (rank r k ~compare_key) ~f:(fun rank -> rank + 1 + length l)\n ;;\n\n (* this could be implemented using [Sequence] interface but the following implementation\n allocates only 2 words and doesn't require write-barrier *)\n let rec nth' num_to_search = function\n | Empty -> None\n | Leaf (k, v) ->\n if !num_to_search = 0\n then Some (k, v)\n else (\n decr num_to_search;\n None)\n | Node (l, k, v, r, _) ->\n (match nth' num_to_search l with\n | Some _ as some -> some\n | None ->\n if !num_to_search = 0\n then Some (k, v)\n else (\n decr num_to_search;\n nth' num_to_search r))\n ;;\n\n let nth t n = nth' (ref n) t\n\n\n let rec find_first_satisfying t ~f =\n match t with\n | Empty -> None\n | Leaf (k, v) -> if f ~key:k ~data:v then Some (k, v) else None\n | Node (l, k, v, r, _) ->\n if f ~key:k ~data:v\n then (\n match find_first_satisfying l ~f with\n | None -> Some (k, v)\n | Some _ as x -> x)\n else find_first_satisfying r ~f\n ;;\n\n let rec find_last_satisfying t ~f =\n match t with\n | Empty -> None\n | Leaf (k, v) -> if f ~key:k ~data:v then Some (k, v) else None\n | Node (l, k, v, r, _) ->\n if f ~key:k ~data:v\n then (\n match find_last_satisfying r ~f with\n | None -> Some (k, v)\n | Some _ as x -> x)\n else find_last_satisfying l ~f\n ;;\n\n let binary_search t ~compare how v =\n match how with\n | `Last_strictly_less_than ->\n find_last_satisfying t ~f:(fun ~key ~data -> compare ~key ~data v < 0)\n | `Last_less_than_or_equal_to ->\n find_last_satisfying t ~f:(fun ~key ~data -> compare ~key ~data v <= 0)\n | `First_equal_to ->\n (match\n find_first_satisfying t ~f:(fun ~key ~data -> compare ~key ~data v >= 0)\n with\n | Some (key, data) as pair when compare ~key ~data v = 0 -> pair\n | None | Some _ -> None)\n | `Last_equal_to ->\n (match find_last_satisfying t ~f:(fun ~key ~data -> compare ~key ~data v <= 0) with\n | Some (key, data) as pair when compare ~key ~data v = 0 -> pair\n | None | Some _ -> None)\n | `First_greater_than_or_equal_to ->\n find_first_satisfying t ~f:(fun ~key ~data -> compare ~key ~data v >= 0)\n | `First_strictly_greater_than ->\n find_first_satisfying t ~f:(fun ~key ~data -> compare ~key ~data v > 0)\n ;;\n\n let binary_search_segmented t ~segment_of how =\n let is_left ~key ~data =\n match segment_of ~key ~data with\n | `Left -> true\n | `Right -> false\n in\n let is_right ~key ~data = not (is_left ~key ~data) in\n match how with\n | `Last_on_left -> find_last_satisfying t ~f:is_left\n | `First_on_right -> find_first_satisfying t ~f:is_right\n ;;\n\n type ('k, 'v) acc =\n { mutable bad_key : 'k option\n ; mutable map_length : ('k, 'v) t * int\n }\n\n let of_iteri ~iteri ~compare_key =\n let acc = { bad_key = None; map_length = empty, 0 } in\n iteri ~f:(fun ~key ~data ->\n let map, length = acc.map_length in\n let ((_, length') as pair) = set ~length ~key ~data map ~compare_key in\n if length = length' && Option.is_none acc.bad_key\n then acc.bad_key <- Some key\n else acc.map_length <- pair);\n match acc.bad_key with\n | None -> `Ok acc.map_length\n | Some key -> `Duplicate_key key\n ;;\n\n let t_of_sexp_direct key_of_sexp value_of_sexp sexp ~(comparator : _ Comparator.t) =\n let alist = list_of_sexp (pair_of_sexp key_of_sexp value_of_sexp) sexp in\n let compare_key = comparator.compare in\n match of_alist alist ~compare_key with\n | `Ok v -> v\n | `Duplicate_key k ->\n (* find the sexp of a duplicate key, so the error is narrowed to a key and not\n the whole map *)\n let alist_sexps = list_of_sexp (pair_of_sexp Fn.id Fn.id) sexp in\n let found_first_k = ref false in\n List.iter2_ok alist alist_sexps ~f:(fun (k2, _) (k2_sexp, _) ->\n if compare_key k k2 = 0\n then\n if !found_first_k\n then of_sexp_error \"Map.t_of_sexp_direct: duplicate key\" k2_sexp\n else found_first_k := true);\n assert false\n ;;\n\n let sexp_of_t sexp_of_key sexp_of_value t =\n let f ~key ~data acc = Sexp.List [ sexp_of_key key; sexp_of_value data ] :: acc in\n Sexp.List (fold_right ~f t ~init:[])\n ;;\n\n let combine_errors t ~compare_key ~sexp_of_key =\n let oks, (error_tree, _) = partition_map t ~compare_key ~f:Result.to_either in\n if is_empty error_tree\n then Ok oks\n else Or_error.error_s (sexp_of_t sexp_of_key Error.sexp_of_t error_tree)\n ;;\nend\n\ntype ('k, 'v, 'comparator) t =\n { (* [comparator] is the first field so that polymorphic equality fails on a map due\n to the functional value in the comparator.\n Note that this does not affect polymorphic [compare]: that still produces\n nonsense. *)\n comparator : ('k, 'comparator) Comparator.t\n ; tree : ('k, 'v) Tree0.t\n ; length : int\n }\n\ntype ('k, 'v, 'comparator) tree = ('k, 'v) Tree0.t\n\nlet compare_key t = t.comparator.Comparator.compare\n\n\nlet like { tree = _; length = _; comparator } (tree, length) =\n { tree; length; comparator }\n;;\n\nlet like2 x (y, z) = like x y, like x z\nlet with_same_length { tree = _; comparator; length } tree = { tree; comparator; length }\nlet of_tree ~comparator tree = { tree; comparator; length = Tree0.length tree }\n\n(* Exposing this function would make it very easy for the invariants\n of this module to be broken. *)\nlet of_tree_unsafe ~comparator ~length tree = { tree; comparator; length }\n\nmodule Accessors = struct\n let comparator t = t.comparator\n let to_tree t = t.tree\n let invariants t = Tree0.invariants t.tree ~compare_key:(compare_key t)\n let is_empty t = Tree0.is_empty t.tree\n let length t = t.length\n\n let set t ~key ~data =\n like t (Tree0.set t.tree ~length:t.length ~key ~data ~compare_key:(compare_key t))\n ;;\n\n let add_exn t ~key ~data =\n like\n t\n (Tree0.add_exn\n t.tree\n ~length:t.length\n ~key\n ~data\n ~compare_key:(compare_key t)\n ~sexp_of_key:t.comparator.sexp_of_t)\n ;;\n\n let add_exn_internal t ~key ~data =\n like\n t\n (Tree0.add_exn_internal\n t.tree\n ~length:t.length\n ~key\n ~data\n ~compare_key:(compare_key t)\n ~sexp_of_key:t.comparator.sexp_of_t)\n ;;\n\n let add t ~key ~data =\n match add_exn_internal t ~key ~data with\n | result -> `Ok result\n | exception Duplicate -> `Duplicate\n ;;\n\n let add_multi t ~key ~data =\n like\n t\n (Tree0.add_multi t.tree ~length:t.length ~key ~data ~compare_key:(compare_key t))\n ;;\n\n let remove_multi t key =\n like t (Tree0.remove_multi t.tree ~length:t.length key ~compare_key:(compare_key t))\n ;;\n\n let find_multi t key = Tree0.find_multi t.tree key ~compare_key:(compare_key t)\n\n let change t key ~f =\n like t (Tree0.change t.tree key ~f ~length:t.length ~compare_key:(compare_key t))\n ;;\n\n let update t key ~f =\n like t (Tree0.update t.tree key ~f ~length:t.length ~compare_key:(compare_key t))\n ;;\n\n let find_exn t key =\n Tree0.find_exn\n t.tree\n key\n ~compare_key:(compare_key t)\n ~sexp_of_key:t.comparator.sexp_of_t\n ;;\n\n let find t key = Tree0.find t.tree key ~compare_key:(compare_key t)\n\n let remove t key =\n like t (Tree0.remove t.tree key ~length:t.length ~compare_key:(compare_key t))\n ;;\n\n let mem t key = Tree0.mem t.tree key ~compare_key:(compare_key t)\n let iter_keys t ~f = Tree0.iter_keys t.tree ~f\n let iter t ~f = Tree0.iter t.tree ~f\n let iteri t ~f = Tree0.iteri t.tree ~f\n let iteri_until t ~f = Tree0.iteri_until t.tree ~f\n let iter2 t1 t2 ~f = Tree0.iter2 t1.tree t2.tree ~f ~compare_key:(compare_key t1)\n let map t ~f = with_same_length t (Tree0.map t.tree ~f)\n let mapi t ~f = with_same_length t (Tree0.mapi t.tree ~f)\n let fold t ~init ~f = Tree0.fold t.tree ~f ~init\n let fold_right t ~init ~f = Tree0.fold_right t.tree ~f ~init\n\n let fold2 t1 t2 ~init ~f =\n Tree0.fold2 t1.tree t2.tree ~init ~f ~compare_key:(compare_key t1)\n ;;\n\n let filter_keys t ~f =\n like t (Tree0.filter_keys t.tree ~f ~compare_key:(compare_key t))\n ;;\n\n let filter t ~f = like t (Tree0.filter t.tree ~f ~compare_key:(compare_key t))\n let filteri t ~f = like t (Tree0.filteri t.tree ~f ~compare_key:(compare_key t))\n let filter_map t ~f = like t (Tree0.filter_map t.tree ~f ~compare_key:(compare_key t))\n\n let filter_mapi t ~f =\n like t (Tree0.filter_mapi t.tree ~f ~compare_key:(compare_key t))\n ;;\n\n let partition_mapi t ~f =\n like2 t (Tree0.partition_mapi t.tree ~f ~compare_key:(compare_key t))\n ;;\n\n let partition_map t ~f =\n like2 t (Tree0.partition_map t.tree ~f ~compare_key:(compare_key t))\n ;;\n\n let partitioni_tf t ~f =\n like2 t (Tree0.partitioni_tf t.tree ~f ~compare_key:(compare_key t))\n ;;\n\n let partition_tf t ~f =\n like2 t (Tree0.partition_tf t.tree ~f ~compare_key:(compare_key t))\n ;;\n\n let combine_errors t =\n Or_error.map\n ~f:(like t)\n (Tree0.combine_errors\n t.tree\n ~compare_key:(compare_key t)\n ~sexp_of_key:t.comparator.sexp_of_t)\n ;;\n\n let compare_direct compare_data t1 t2 =\n Tree0.compare (compare_key t1) compare_data t1.tree t2.tree\n ;;\n\n let equal compare_data t1 t2 =\n Tree0.equal (compare_key t1) compare_data t1.tree t2.tree\n ;;\n\n let keys t = Tree0.keys t.tree\n let data t = Tree0.data t.tree\n let to_alist ?key_order t = Tree0.to_alist ?key_order t.tree\n let validate ~name f t = Validate.alist ~name f (to_alist t)\n let validatei ~name f t = Validate.list ~name:(Fn.compose name fst) f (to_alist t)\n\n let symmetric_diff t1 t2 ~data_equal =\n Tree0.symmetric_diff t1.tree t2.tree ~compare_key:(compare_key t1) ~data_equal\n ;;\n\n let fold_symmetric_diff t1 t2 ~data_equal ~init ~f =\n Tree0.fold_symmetric_diff\n t1.tree\n t2.tree\n ~compare_key:(compare_key t1)\n ~data_equal\n ~init\n ~f\n ;;\n\n let merge t1 t2 ~f =\n like t1 (Tree0.merge t1.tree t2.tree ~f ~compare_key:(compare_key t1))\n ;;\n\n let min_elt t = Tree0.min_elt t.tree\n let min_elt_exn t = Tree0.min_elt_exn t.tree\n let max_elt t = Tree0.max_elt t.tree\n let max_elt_exn t = Tree0.max_elt_exn t.tree\n let for_all t ~f = Tree0.for_all t.tree ~f\n let for_alli t ~f = Tree0.for_alli t.tree ~f\n let exists t ~f = Tree0.exists t.tree ~f\n let existsi t ~f = Tree0.existsi t.tree ~f\n let count t ~f = Tree0.count t.tree ~f\n let counti t ~f = Tree0.counti t.tree ~f\n\n let split t k =\n let l, maybe, r = Tree0.split t.tree k ~compare_key:(compare_key t) in\n let comparator = comparator t in\n (* Try to traverse the least amount possible to calculate the length,\n using height as a heuristic. *)\n let both_len = if Option.is_some maybe then t.length - 1 else t.length in\n if Tree0.height l < Tree0.height r\n then (\n let l = of_tree l ~comparator in\n l, maybe, of_tree_unsafe r ~comparator ~length:(both_len - length l))\n else (\n let r = of_tree r ~comparator in\n of_tree_unsafe l ~comparator ~length:(both_len - length r), maybe, r)\n ;;\n\n let subrange t ~lower_bound ~upper_bound =\n let left, mid, right =\n Tree0.split_range t.tree ~lower_bound ~upper_bound ~compare_key:(compare_key t)\n in\n (* Try to traverse the least amount possible to calculate the length,\n using height as a heuristic. *)\n let outer_joined_height =\n let h_l = Tree0.height left\n and h_r = Tree0.height right in\n if h_l = h_r then h_l + 1 else max h_l h_r\n in\n if outer_joined_height < Tree0.height mid\n then (\n let mid_length = t.length - (Tree0.length left + Tree0.length right) in\n of_tree_unsafe mid ~comparator:(comparator t) ~length:mid_length)\n else of_tree mid ~comparator:(comparator t)\n ;;\n\n let append ~lower_part ~upper_part =\n match\n Tree0.append\n ~compare_key:(compare_key lower_part)\n ~lower_part:lower_part.tree\n ~upper_part:upper_part.tree\n with\n | `Ok tree ->\n `Ok\n (of_tree_unsafe\n tree\n ~comparator:(comparator lower_part)\n ~length:(lower_part.length + upper_part.length))\n | `Overlapping_key_ranges -> `Overlapping_key_ranges\n ;;\n\n let fold_range_inclusive t ~min ~max ~init ~f =\n Tree0.fold_range_inclusive t.tree ~min ~max ~init ~f ~compare_key:(compare_key t)\n ;;\n\n let range_to_alist t ~min ~max =\n Tree0.range_to_alist t.tree ~min ~max ~compare_key:(compare_key t)\n ;;\n\n let closest_key t dir key =\n Tree0.closest_key t.tree dir key ~compare_key:(compare_key t)\n ;;\n\n let nth t n = Tree0.nth t.tree n\n let nth_exn t n = Option.value_exn (nth t n)\n let rank t key = Tree0.rank t.tree key ~compare_key:(compare_key t)\n let sexp_of_t sexp_of_k sexp_of_v _ t = Tree0.sexp_of_t sexp_of_k sexp_of_v t.tree\n\n let to_sequence ?order ?keys_greater_or_equal_to ?keys_less_or_equal_to t =\n Tree0.to_sequence\n t.comparator\n ?order\n ?keys_greater_or_equal_to\n ?keys_less_or_equal_to\n t.tree\n ;;\n\n let binary_search t ~compare how v = Tree0.binary_search t.tree ~compare how v\n\n let binary_search_segmented t ~segment_of how =\n Tree0.binary_search_segmented t.tree ~segment_of how\n ;;\n\n let hash_fold_direct hash_fold_key hash_fold_data state t =\n Tree0.hash_fold_t_ignoring_structure hash_fold_key hash_fold_data state t.tree\n ;;\nend\n\n(* [0] is used as the [length] argument everywhere in this module, since trees do not\n have their lengths stored at the root, unlike maps. The values are discarded always. *)\nmodule Tree = struct\n type ('k, 'v, 'comparator) t = ('k, 'v, 'comparator) tree\n\n let empty_without_value_restriction = Tree0.empty\n let empty ~comparator:_ = empty_without_value_restriction\n let of_tree ~comparator:_ tree = tree\n let singleton ~comparator:_ k v = Tree0.singleton k v\n\n let of_sorted_array_unchecked ~comparator array =\n fst\n (Tree0.of_sorted_array_unchecked array ~compare_key:comparator.Comparator.compare)\n ;;\n\n let of_sorted_array ~comparator array =\n Tree0.of_sorted_array array ~compare_key:comparator.Comparator.compare\n |> Or_error.map ~f:fst\n ;;\n\n let of_alist ~comparator alist =\n match Tree0.of_alist alist ~compare_key:comparator.Comparator.compare with\n | `Duplicate_key _ as d -> d\n | `Ok (tree, _size) -> `Ok tree\n ;;\n\n let of_alist_or_error ~comparator alist =\n Tree0.of_alist_or_error alist ~comparator |> Or_error.map ~f:fst\n ;;\n\n let of_alist_exn ~comparator alist = fst (Tree0.of_alist_exn alist ~comparator)\n\n let of_alist_multi ~comparator alist =\n fst (Tree0.of_alist_multi alist ~compare_key:comparator.Comparator.compare)\n ;;\n\n let of_alist_fold ~comparator alist ~init ~f =\n fst (Tree0.of_alist_fold alist ~init ~f ~compare_key:comparator.Comparator.compare)\n ;;\n\n let of_alist_reduce ~comparator alist ~f =\n fst (Tree0.of_alist_reduce alist ~f ~compare_key:comparator.Comparator.compare)\n ;;\n\n let of_iteri ~comparator ~iteri =\n match Tree0.of_iteri ~iteri ~compare_key:comparator.Comparator.compare with\n | `Ok (tree, _size) -> `Ok tree\n | `Duplicate_key _ as d -> d\n ;;\n\n let of_increasing_iterator_unchecked ~comparator:_required_by_intf ~len ~f =\n Tree0.of_increasing_iterator_unchecked ~len ~f\n ;;\n\n let of_increasing_sequence ~comparator seq =\n Or_error.map\n ~f:fst\n (Tree0.of_increasing_sequence seq ~compare_key:comparator.Comparator.compare)\n ;;\n\n let of_sequence ~comparator seq =\n match Tree0.of_sequence seq ~compare_key:comparator.Comparator.compare with\n | `Duplicate_key _ as d -> d\n | `Ok (tree, _size) -> `Ok tree\n ;;\n\n let of_sequence_or_error ~comparator seq =\n Tree0.of_sequence_or_error seq ~comparator |> Or_error.map ~f:fst\n ;;\n\n let of_sequence_exn ~comparator seq = fst (Tree0.of_sequence_exn seq ~comparator)\n\n let of_sequence_multi ~comparator seq =\n fst (Tree0.of_sequence_multi seq ~compare_key:comparator.Comparator.compare)\n ;;\n\n let of_sequence_fold ~comparator seq ~init ~f =\n fst (Tree0.of_sequence_fold seq ~init ~f ~compare_key:comparator.Comparator.compare)\n ;;\n\n let of_sequence_reduce ~comparator seq ~f =\n fst (Tree0.of_sequence_reduce seq ~f ~compare_key:comparator.Comparator.compare)\n ;;\n\n let to_tree t = t\n\n let invariants ~comparator t =\n Tree0.invariants t ~compare_key:comparator.Comparator.compare\n ;;\n\n let is_empty t = Tree0.is_empty t\n let length t = Tree0.length t\n\n let set ~comparator t ~key ~data =\n fst (Tree0.set t ~key ~data ~length:0 ~compare_key:comparator.Comparator.compare)\n ;;\n\n let add_exn ~comparator t ~key ~data =\n fst\n (Tree0.add_exn\n t\n ~key\n ~data\n ~length:0\n ~compare_key:comparator.Comparator.compare\n ~sexp_of_key:comparator.sexp_of_t)\n ;;\n\n let add ~comparator t ~key ~data =\n try `Ok (add_exn t ~comparator ~key ~data) with\n | _ -> `Duplicate\n ;;\n\n let add_multi ~comparator t ~key ~data =\n Tree0.add_multi t ~key ~data ~length:0 ~compare_key:comparator.Comparator.compare\n |> fst\n ;;\n\n let remove_multi ~comparator t key =\n Tree0.remove_multi t key ~length:0 ~compare_key:comparator.Comparator.compare |> fst\n ;;\n\n let find_multi ~comparator t key =\n Tree0.find_multi t key ~compare_key:comparator.Comparator.compare\n ;;\n\n let change ~comparator t key ~f =\n fst (Tree0.change t key ~f ~length:0 ~compare_key:comparator.Comparator.compare)\n ;;\n\n let update ~comparator t key ~f =\n change ~comparator t key ~f:(fun data -> Some (f data))\n ;;\n\n let find_exn ~comparator t key =\n Tree0.find_exn\n t\n key\n ~compare_key:comparator.Comparator.compare\n ~sexp_of_key:comparator.Comparator.sexp_of_t\n ;;\n\n let find ~comparator t key =\n Tree0.find t key ~compare_key:comparator.Comparator.compare\n ;;\n\n let remove ~comparator t key =\n fst (Tree0.remove t key ~length:0 ~compare_key:comparator.Comparator.compare)\n ;;\n\n let mem ~comparator t key = Tree0.mem t key ~compare_key:comparator.Comparator.compare\n let iter_keys t ~f = Tree0.iter_keys t ~f\n let iter t ~f = Tree0.iter t ~f\n let iteri t ~f = Tree0.iteri t ~f\n let iteri_until t ~f = Tree0.iteri_until t ~f\n\n let iter2 ~comparator t1 t2 ~f =\n Tree0.iter2 t1 t2 ~f ~compare_key:comparator.Comparator.compare\n ;;\n\n let map t ~f = Tree0.map t ~f\n let mapi t ~f = Tree0.mapi t ~f\n let fold t ~init ~f = Tree0.fold t ~f ~init\n let fold_right t ~init ~f = Tree0.fold_right t ~f ~init\n\n let fold2 ~comparator t1 t2 ~init ~f =\n Tree0.fold2 t1 t2 ~init ~f ~compare_key:comparator.Comparator.compare\n ;;\n\n let filter_keys ~comparator t ~f =\n fst (Tree0.filter_keys t ~f ~compare_key:comparator.Comparator.compare)\n ;;\n\n let filter ~comparator t ~f =\n fst (Tree0.filter t ~f ~compare_key:comparator.Comparator.compare)\n ;;\n\n let filteri ~comparator t ~f =\n fst (Tree0.filteri t ~f ~compare_key:comparator.Comparator.compare)\n ;;\n\n let filter_map ~comparator t ~f =\n fst (Tree0.filter_map t ~f ~compare_key:comparator.Comparator.compare)\n ;;\n\n let filter_mapi ~comparator t ~f =\n fst (Tree0.filter_mapi t ~f ~compare_key:comparator.Comparator.compare)\n ;;\n\n let partition_mapi ~comparator t ~f =\n let (a, _), (b, _) =\n Tree0.partition_mapi t ~f ~compare_key:comparator.Comparator.compare\n in\n a, b\n ;;\n\n let partition_map ~comparator t ~f =\n let (a, _), (b, _) =\n Tree0.partition_map t ~f ~compare_key:comparator.Comparator.compare\n in\n a, b\n ;;\n\n let partitioni_tf ~comparator t ~f =\n let (a, _), (b, _) =\n Tree0.partitioni_tf t ~f ~compare_key:comparator.Comparator.compare\n in\n a, b\n ;;\n\n let partition_tf ~comparator t ~f =\n let (a, _), (b, _) =\n Tree0.partition_tf t ~f ~compare_key:comparator.Comparator.compare\n in\n a, b\n ;;\n\n let combine_errors ~comparator t =\n Or_error.map\n ~f:fst\n (Tree0.combine_errors\n t\n ~compare_key:comparator.Comparator.compare\n ~sexp_of_key:comparator.Comparator.sexp_of_t)\n ;;\n\n let compare_direct ~comparator compare_data t1 t2 =\n Tree0.compare comparator.Comparator.compare compare_data t1 t2\n ;;\n\n let equal ~comparator compare_data t1 t2 =\n Tree0.equal comparator.Comparator.compare compare_data t1 t2\n ;;\n\n let keys t = Tree0.keys t\n let data t = Tree0.data t\n let to_alist ?key_order t = Tree0.to_alist ?key_order t\n let validate ~name f t = Validate.alist ~name f (to_alist t)\n let validatei ~name f t = Validate.list ~name:(Fn.compose name fst) f (to_alist t)\n\n let symmetric_diff ~comparator t1 t2 ~data_equal =\n Tree0.symmetric_diff t1 t2 ~compare_key:comparator.Comparator.compare ~data_equal\n ;;\n\n let fold_symmetric_diff ~comparator t1 t2 ~data_equal ~init ~f =\n Tree0.fold_symmetric_diff\n t1\n t2\n ~compare_key:comparator.Comparator.compare\n ~data_equal\n ~init\n ~f\n ;;\n\n let merge ~comparator t1 t2 ~f =\n fst (Tree0.merge t1 t2 ~f ~compare_key:comparator.Comparator.compare)\n ;;\n\n let min_elt t = Tree0.min_elt t\n let min_elt_exn t = Tree0.min_elt_exn t\n let max_elt t = Tree0.max_elt t\n let max_elt_exn t = Tree0.max_elt_exn t\n let for_all t ~f = Tree0.for_all t ~f\n let for_alli t ~f = Tree0.for_alli t ~f\n let exists t ~f = Tree0.exists t ~f\n let existsi t ~f = Tree0.existsi t ~f\n let count t ~f = Tree0.count t ~f\n let counti t ~f = Tree0.counti t ~f\n let split ~comparator t k = Tree0.split t k ~compare_key:comparator.Comparator.compare\n\n let append ~comparator ~lower_part ~upper_part =\n Tree0.append ~lower_part ~upper_part ~compare_key:comparator.Comparator.compare\n ;;\n\n let subrange ~comparator t ~lower_bound ~upper_bound =\n let _, ret, _ =\n Tree0.split_range\n t\n ~lower_bound\n ~upper_bound\n ~compare_key:comparator.Comparator.compare\n in\n ret\n ;;\n\n let fold_range_inclusive ~comparator t ~min ~max ~init ~f =\n Tree0.fold_range_inclusive\n t\n ~min\n ~max\n ~init\n ~f\n ~compare_key:comparator.Comparator.compare\n ;;\n\n let range_to_alist ~comparator t ~min ~max =\n Tree0.range_to_alist t ~min ~max ~compare_key:comparator.Comparator.compare\n ;;\n\n let closest_key ~comparator t dir key =\n Tree0.closest_key t dir key ~compare_key:comparator.Comparator.compare\n ;;\n\n let nth ~comparator:_ t n = Tree0.nth t n\n let nth_exn ~comparator t n = Option.value_exn (nth ~comparator t n)\n\n let rank ~comparator t key =\n Tree0.rank t key ~compare_key:comparator.Comparator.compare\n ;;\n\n let sexp_of_t sexp_of_k sexp_of_v _ t = Tree0.sexp_of_t sexp_of_k sexp_of_v t\n\n let t_of_sexp_direct ~comparator k_of_sexp v_of_sexp sexp =\n fst (Tree0.t_of_sexp_direct k_of_sexp v_of_sexp sexp ~comparator)\n ;;\n\n let to_sequence ~comparator ?order ?keys_greater_or_equal_to ?keys_less_or_equal_to t =\n Tree0.to_sequence\n comparator\n ?order\n ?keys_greater_or_equal_to\n ?keys_less_or_equal_to\n t\n ;;\n\n let binary_search ~comparator:_ t ~compare how v = Tree0.binary_search t ~compare how v\n\n let binary_search_segmented ~comparator:_ t ~segment_of how =\n Tree0.binary_search_segmented t ~segment_of how\n ;;\nend\n\nmodule Using_comparator = struct\n type nonrec ('k, 'v, 'cmp) t = ('k, 'v, 'cmp) t\n\n include Accessors\n\n let empty ~comparator = { tree = Tree0.empty; comparator; length = 0 }\n let singleton ~comparator k v = { comparator; tree = Tree0.singleton k v; length = 1 }\n let of_tree0 ~comparator (tree, length) = { comparator; tree; length }\n let of_tree ~comparator tree = of_tree0 ~comparator (tree, Tree0.length tree)\n let to_tree = to_tree\n\n let of_sorted_array_unchecked ~comparator array =\n of_tree0\n ~comparator\n (Tree0.of_sorted_array_unchecked array ~compare_key:comparator.Comparator.compare)\n ;;\n\n let of_sorted_array ~comparator array =\n Or_error.map\n (Tree0.of_sorted_array array ~compare_key:comparator.Comparator.compare)\n ~f:(fun tree -> of_tree0 ~comparator tree)\n ;;\n\n let of_alist ~comparator alist =\n match Tree0.of_alist alist ~compare_key:comparator.Comparator.compare with\n | `Ok (tree, length) -> `Ok { comparator; tree; length }\n | `Duplicate_key _ as z -> z\n ;;\n\n let of_alist_or_error ~comparator alist =\n Result.map (Tree0.of_alist_or_error alist ~comparator) ~f:(fun tree ->\n of_tree0 ~comparator tree)\n ;;\n\n let of_alist_exn ~comparator alist =\n of_tree0 ~comparator (Tree0.of_alist_exn alist ~comparator)\n ;;\n\n let of_alist_multi ~comparator alist =\n of_tree0\n ~comparator\n (Tree0.of_alist_multi alist ~compare_key:comparator.Comparator.compare)\n ;;\n\n let of_alist_fold ~comparator alist ~init ~f =\n of_tree0\n ~comparator\n (Tree0.of_alist_fold alist ~init ~f ~compare_key:comparator.Comparator.compare)\n ;;\n\n let of_alist_reduce ~comparator alist ~f =\n of_tree0\n ~comparator\n (Tree0.of_alist_reduce alist ~f ~compare_key:comparator.Comparator.compare)\n ;;\n\n let of_iteri ~comparator ~iteri =\n match Tree0.of_iteri ~compare_key:comparator.Comparator.compare ~iteri with\n | `Ok tree_length -> `Ok (of_tree0 ~comparator tree_length)\n | `Duplicate_key _ as z -> z\n ;;\n\n let of_increasing_iterator_unchecked ~comparator ~len ~f =\n of_tree0 ~comparator (Tree0.of_increasing_iterator_unchecked ~len ~f, len)\n ;;\n\n let of_increasing_sequence ~comparator seq =\n Or_error.map\n ~f:(of_tree0 ~comparator)\n (Tree0.of_increasing_sequence seq ~compare_key:comparator.Comparator.compare)\n ;;\n\n let of_sequence ~comparator seq =\n match Tree0.of_sequence seq ~compare_key:comparator.Comparator.compare with\n | `Ok (tree, length) -> `Ok { comparator; tree; length }\n | `Duplicate_key _ as z -> z\n ;;\n\n let of_sequence_or_error ~comparator seq =\n Result.map (Tree0.of_sequence_or_error seq ~comparator) ~f:(fun tree ->\n of_tree0 ~comparator tree)\n ;;\n\n let of_sequence_exn ~comparator seq =\n of_tree0 ~comparator (Tree0.of_sequence_exn seq ~comparator)\n ;;\n\n let of_sequence_multi ~comparator seq =\n of_tree0\n ~comparator\n (Tree0.of_sequence_multi seq ~compare_key:comparator.Comparator.compare)\n ;;\n\n let of_sequence_fold ~comparator seq ~init ~f =\n of_tree0\n ~comparator\n (Tree0.of_sequence_fold seq ~init ~f ~compare_key:comparator.Comparator.compare)\n ;;\n\n let of_sequence_reduce ~comparator seq ~f =\n of_tree0\n ~comparator\n (Tree0.of_sequence_reduce seq ~f ~compare_key:comparator.Comparator.compare)\n ;;\n\n let t_of_sexp_direct ~comparator k_of_sexp v_of_sexp sexp =\n of_tree0 ~comparator (Tree0.t_of_sexp_direct k_of_sexp v_of_sexp sexp ~comparator)\n ;;\n\n module Empty_without_value_restriction (K : Comparator.S1) = struct\n let empty = { tree = Tree0.empty; comparator = K.comparator; length = 0 }\n end\n\n module Tree = Tree\nend\n\ninclude Accessors\n\ntype ('k, 'cmp) comparator =\n (module Comparator.S with type t = 'k and type comparator_witness = 'cmp)\n\nlet comparator_s (type k cmp) t : (k, cmp) comparator =\n (module struct\n type t = k\n type comparator_witness = cmp\n\n let comparator = t.comparator\n end)\n;;\n\nlet to_comparator (type k cmp) ((module M) : (k, cmp) comparator) = M.comparator\nlet empty m = Using_comparator.empty ~comparator:(to_comparator m)\nlet singleton m a = Using_comparator.singleton ~comparator:(to_comparator m) a\nlet of_alist m a = Using_comparator.of_alist ~comparator:(to_comparator m) a\n\nlet of_alist_or_error m a =\n Using_comparator.of_alist_or_error ~comparator:(to_comparator m) a\n;;\n\nlet of_alist_exn m a = Using_comparator.of_alist_exn ~comparator:(to_comparator m) a\nlet of_alist_multi m a = Using_comparator.of_alist_multi ~comparator:(to_comparator m) a\n\nlet of_alist_fold m a ~init ~f =\n Using_comparator.of_alist_fold ~comparator:(to_comparator m) a ~init ~f\n;;\n\nlet of_alist_reduce m a ~f =\n Using_comparator.of_alist_reduce ~comparator:(to_comparator m) a ~f\n;;\n\nlet of_sorted_array_unchecked m a =\n Using_comparator.of_sorted_array_unchecked ~comparator:(to_comparator m) a\n;;\n\nlet of_sorted_array m a =\n Using_comparator.of_sorted_array ~comparator:(to_comparator m) a\n;;\n\nlet of_iteri m ~iteri = Using_comparator.of_iteri ~iteri ~comparator:(to_comparator m)\n\nlet of_increasing_iterator_unchecked m ~len ~f =\n Using_comparator.of_increasing_iterator_unchecked ~len ~f ~comparator:(to_comparator m)\n;;\n\nlet of_increasing_sequence m seq =\n Using_comparator.of_increasing_sequence ~comparator:(to_comparator m) seq\n;;\n\nlet of_sequence m s = Using_comparator.of_sequence ~comparator:(to_comparator m) s\n\nlet of_sequence_or_error m s =\n Using_comparator.of_sequence_or_error ~comparator:(to_comparator m) s\n;;\n\nlet of_sequence_exn m s =\n Using_comparator.of_sequence_exn ~comparator:(to_comparator m) s\n;;\n\nlet of_sequence_multi m s =\n Using_comparator.of_sequence_multi ~comparator:(to_comparator m) s\n;;\n\nlet of_sequence_fold m s ~init ~f =\n Using_comparator.of_sequence_fold ~comparator:(to_comparator m) s ~init ~f\n;;\n\nlet of_sequence_reduce m s ~f =\n Using_comparator.of_sequence_reduce ~comparator:(to_comparator m) s ~f\n;;\n\nmodule M (K : sig\n type t\n type comparator_witness\n end) =\nstruct\n type nonrec 'v t = (K.t, 'v, K.comparator_witness) t\nend\n\nmodule type Sexp_of_m = sig\n type t [@@deriving_inline sexp_of]\n\n val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t\n\n [@@@end]\nend\n\nmodule type M_of_sexp = sig\n type t [@@deriving_inline of_sexp]\n\n val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t\n\n [@@@end]\n\n include Comparator.S with type t := t\nend\n\nmodule type Compare_m = sig end\nmodule type Equal_m = sig end\nmodule type Hash_fold_m = Hasher.S\n\nlet sexp_of_m__t (type k) (module K : Sexp_of_m with type t = k) sexp_of_v t =\n sexp_of_t K.sexp_of_t sexp_of_v (fun _ -> Sexp.Atom \"_\") t\n;;\n\nlet m__t_of_sexp\n (type k cmp)\n (module K : M_of_sexp with type t = k and type comparator_witness = cmp)\n v_of_sexp\n sexp\n =\n Using_comparator.t_of_sexp_direct ~comparator:K.comparator K.t_of_sexp v_of_sexp sexp\n;;\n\nlet m__t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t =\n Inline\n (Explicit_bind\n ( [ \"'k\"; \"'v\" ]\n , Apply\n ( Grammar list_sexp_grammar\n , [ Apply\n ( Grammar Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.tuple2_sexp_grammar\n , [ Explicit_var 0; Explicit_var 1 ] )\n ] ) ))\n;;\n\nlet compare_m__t (module K : Compare_m) compare_v t1 t2 = compare_direct compare_v t1 t2\nlet equal_m__t (module K : Equal_m) equal_v t1 t2 = equal equal_v t1 t2\n\nlet hash_fold_m__t (type k) (module K : Hash_fold_m with type t = k) hash_fold_v state =\n hash_fold_direct K.hash_fold_t hash_fold_v state\n;;\n\nlet merge_skewed t1 t2 ~combine =\n let t1, t2, combine =\n if length t2 <= length t1\n then t1, t2, combine\n else t2, t1, fun ~key v1 v2 -> combine ~key v2 v1\n in\n fold t2 ~init:t1 ~f:(fun ~key ~data:v2 t1 ->\n change t1 key ~f:(function\n | None -> Some v2\n | Some v1 -> Some (combine ~key v1 v2)))\n;;\n\nmodule Poly = struct\n type nonrec ('k, 'v) t = ('k, 'v, Comparator.Poly.comparator_witness) t\n type nonrec ('k, 'v) tree = ('k, 'v) Tree0.t\n type comparator_witness = Comparator.Poly.comparator_witness\n\n include Accessors\n\n let comparator = Comparator.Poly.comparator\n let of_tree tree = { tree; comparator; length = Tree0.length tree }\n\n include Using_comparator.Empty_without_value_restriction (Comparator.Poly)\n\n let singleton a = Using_comparator.singleton ~comparator a\n let of_alist a = Using_comparator.of_alist ~comparator a\n let of_alist_or_error a = Using_comparator.of_alist_or_error ~comparator a\n let of_alist_exn a = Using_comparator.of_alist_exn ~comparator a\n let of_alist_multi a = Using_comparator.of_alist_multi ~comparator a\n let of_alist_fold a ~init ~f = Using_comparator.of_alist_fold ~comparator a ~init ~f\n let of_alist_reduce a ~f = Using_comparator.of_alist_reduce ~comparator a ~f\n\n let of_sorted_array_unchecked a =\n Using_comparator.of_sorted_array_unchecked ~comparator a\n ;;\n\n let of_sorted_array a = Using_comparator.of_sorted_array ~comparator a\n let of_iteri ~iteri = Using_comparator.of_iteri ~iteri ~comparator\n\n let of_increasing_iterator_unchecked ~len ~f =\n Using_comparator.of_increasing_iterator_unchecked ~len ~f ~comparator\n ;;\n\n let of_increasing_sequence seq =\n Using_comparator.of_increasing_sequence ~comparator seq\n ;;\n\n let of_sequence s = Using_comparator.of_sequence ~comparator s\n let of_sequence_or_error s = Using_comparator.of_sequence_or_error ~comparator s\n let of_sequence_exn s = Using_comparator.of_sequence_exn ~comparator s\n let of_sequence_multi s = Using_comparator.of_sequence_multi ~comparator s\n\n let of_sequence_fold s ~init ~f =\n Using_comparator.of_sequence_fold ~comparator s ~init ~f\n ;;\n\n let of_sequence_reduce s ~f = Using_comparator.of_sequence_reduce ~comparator s ~f\nend\n","open! Import\nopen! T\n\nmodule Or_duplicate = struct\n type 'a t =\n [ `Ok of 'a\n | `Duplicate\n ]\n [@@deriving_inline sexp_of]\n\n let sexp_of_t :\n 'a. ('a -> Ppx_sexp_conv_lib.Sexp.t) -> 'a t -> Ppx_sexp_conv_lib.Sexp.t\n =\n fun _of_a -> function\n | `Ok v0 -> Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"Ok\"; _of_a v0 ]\n | `Duplicate -> Ppx_sexp_conv_lib.Sexp.Atom \"Duplicate\"\n ;;\n\n [@@@end]\nend\n\nmodule Without_comparator = struct\n type ('key, 'cmp, 'z) t = 'z\nend\n\nmodule With_comparator = struct\n type ('key, 'cmp, 'z) t = comparator:('key, 'cmp) Comparator.t -> 'z\nend\n\nmodule With_first_class_module = struct\n type ('key, 'cmp, 'z) t =\n (module Comparator.S with type t = 'key and type comparator_witness = 'cmp) -> 'z\nend\n\nmodule Symmetric_diff_element = struct\n type ('k, 'v) t = 'k * [ `Left of 'v | `Right of 'v | `Unequal of 'v * 'v ]\n [@@deriving_inline compare, sexp]\n\n let compare :\n 'k 'v. ('k -> 'k -> int) -> ('v -> 'v -> int) -> ('k, 'v) t -> ('k, 'v) t -> int\n =\n fun _cmp__k _cmp__v a__001_ b__002_ ->\n let t__003_, t__004_ = a__001_ in\n let t__005_, t__006_ = b__002_ in\n match _cmp__k t__003_ t__005_ with\n | 0 ->\n if Ppx_compare_lib.phys_equal t__004_ t__006_\n then 0\n else (\n match t__004_, t__006_ with\n | `Left _left__007_, `Left _right__008_ -> _cmp__v _left__007_ _right__008_\n | `Right _left__009_, `Right _right__010_ -> _cmp__v _left__009_ _right__010_\n | `Unequal _left__011_, `Unequal _right__012_ ->\n let t__013_, t__014_ = _left__011_ in\n let t__015_, t__016_ = _right__012_ in\n (match _cmp__v t__013_ t__015_ with\n | 0 -> _cmp__v t__014_ t__016_\n | n -> n)\n | x, y -> Ppx_compare_lib.polymorphic_compare x y)\n | n -> n\n ;;\n\n let t_of_sexp :\n 'k 'v. (Ppx_sexp_conv_lib.Sexp.t -> 'k) -> (Ppx_sexp_conv_lib.Sexp.t -> 'v)\n -> Ppx_sexp_conv_lib.Sexp.t -> ('k, 'v) t\n =\n let _tp_loc = \"map_intf.ml.Symmetric_diff_element.t\" in\n fun _of_k _of_v -> function\n | Ppx_sexp_conv_lib.Sexp.List [ v0; v1 ] ->\n let v0 = _of_k v0\n and v1 =\n (fun sexp ->\n try\n match sexp with\n | Ppx_sexp_conv_lib.Sexp.Atom atom as _sexp ->\n (match atom with\n | \"Left\" -> Ppx_sexp_conv_lib.Conv_error.ptag_takes_args _tp_loc _sexp\n | \"Right\" -> Ppx_sexp_conv_lib.Conv_error.ptag_takes_args _tp_loc _sexp\n | \"Unequal\" -> Ppx_sexp_conv_lib.Conv_error.ptag_takes_args _tp_loc _sexp\n | _ -> Ppx_sexp_conv_lib.Conv_error.no_variant_match ())\n | Ppx_sexp_conv_lib.Sexp.List\n (Ppx_sexp_conv_lib.Sexp.Atom atom :: sexp_args) as _sexp ->\n (match atom with\n | \"Left\" as _tag ->\n (match sexp_args with\n | [ v0 ] ->\n let v0 = _of_v v0 in\n `Left v0\n | _ ->\n Ppx_sexp_conv_lib.Conv_error.ptag_incorrect_n_args _tp_loc _tag _sexp)\n | \"Right\" as _tag ->\n (match sexp_args with\n | [ v0 ] ->\n let v0 = _of_v v0 in\n `Right v0\n | _ ->\n Ppx_sexp_conv_lib.Conv_error.ptag_incorrect_n_args _tp_loc _tag _sexp)\n | \"Unequal\" as _tag ->\n (match sexp_args with\n | [ v0 ] ->\n let v0 =\n match v0 with\n | Ppx_sexp_conv_lib.Sexp.List [ v0; v1 ] ->\n let v0 = _of_v v0\n and v1 = _of_v v1 in\n v0, v1\n | sexp ->\n Ppx_sexp_conv_lib.Conv_error.tuple_of_size_n_expected\n _tp_loc\n 2\n sexp\n in\n `Unequal v0\n | _ ->\n Ppx_sexp_conv_lib.Conv_error.ptag_incorrect_n_args _tp_loc _tag _sexp)\n | _ -> Ppx_sexp_conv_lib.Conv_error.no_variant_match ())\n | Ppx_sexp_conv_lib.Sexp.List (Ppx_sexp_conv_lib.Sexp.List _ :: _) as sexp\n -> Ppx_sexp_conv_lib.Conv_error.nested_list_invalid_poly_var _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.List [] as sexp ->\n Ppx_sexp_conv_lib.Conv_error.empty_list_invalid_poly_var _tp_loc sexp\n with\n | Ppx_sexp_conv_lib.Conv_error.No_variant_match ->\n Ppx_sexp_conv_lib.Conv_error.no_matching_variant_found _tp_loc sexp)\n v1\n in\n v0, v1\n | sexp -> Ppx_sexp_conv_lib.Conv_error.tuple_of_size_n_expected _tp_loc 2 sexp\n ;;\n\n let sexp_of_t :\n 'k 'v. ('k -> Ppx_sexp_conv_lib.Sexp.t) -> ('v -> Ppx_sexp_conv_lib.Sexp.t)\n -> ('k, 'v) t -> Ppx_sexp_conv_lib.Sexp.t\n =\n fun _of_k _of_v -> function\n | v0, v1 ->\n let v0 = _of_k v0\n and v1 =\n match v1 with\n | `Left v0 ->\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"Left\"; _of_v v0 ]\n | `Right v0 ->\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"Right\"; _of_v v0 ]\n | `Unequal v0 ->\n Ppx_sexp_conv_lib.Sexp.List\n [ Ppx_sexp_conv_lib.Sexp.Atom \"Unequal\"\n ; (let v0, v1 = v0 in\n let v0 = _of_v v0\n and v1 = _of_v v1 in\n Ppx_sexp_conv_lib.Sexp.List [ v0; v1 ])\n ]\n in\n Ppx_sexp_conv_lib.Sexp.List [ v0; v1 ]\n ;;\n\n [@@@end]\nend\n\nmodule Continue_or_stop = struct\n type t =\n | Continue\n | Stop\n [@@deriving_inline compare, enumerate, equal, sexp_of]\n\n let compare = (Ppx_compare_lib.polymorphic_compare : t -> t -> int)\n let all = ([ Continue; Stop ] : t list)\n let equal = (Ppx_compare_lib.polymorphic_equal : t -> t -> bool)\n\n let sexp_of_t =\n (function\n | Continue -> Ppx_sexp_conv_lib.Sexp.Atom \"Continue\"\n | Stop -> Ppx_sexp_conv_lib.Sexp.Atom \"Stop\"\n : t -> Ppx_sexp_conv_lib.Sexp.t)\n ;;\n\n [@@@end]\nend\n\nmodule Finished_or_unfinished = struct\n type t =\n | Finished\n | Unfinished\n [@@deriving_inline compare, enumerate, equal, sexp_of]\n\n let compare = (Ppx_compare_lib.polymorphic_compare : t -> t -> int)\n let all = ([ Finished; Unfinished ] : t list)\n let equal = (Ppx_compare_lib.polymorphic_equal : t -> t -> bool)\n\n let sexp_of_t =\n (function\n | Finished -> Ppx_sexp_conv_lib.Sexp.Atom \"Finished\"\n | Unfinished -> Ppx_sexp_conv_lib.Sexp.Atom \"Unfinished\"\n : t -> Ppx_sexp_conv_lib.Sexp.t)\n ;;\n\n [@@@end]\nend\n\nmodule type Accessors_generic = sig\n type ('a, 'b, 'cmp) t\n type ('a, 'b, 'cmp) tree\n type 'a key\n type 'cmp cmp\n type ('a, 'cmp, 'z) options\n\n val invariants : ('k, 'cmp, ('k, 'v, 'cmp) t -> bool) options\n val is_empty : (_, _, _) t -> bool\n val length : (_, _, _) t -> int\n\n val add\n : ( 'k\n , 'cmp\n , ('k, 'v, 'cmp) t -> key:'k key -> data:'v -> ('k, 'v, 'cmp) t Or_duplicate.t )\n options\n\n val add_exn\n : ('k, 'cmp, ('k, 'v, 'cmp) t -> key:'k key -> data:'v -> ('k, 'v, 'cmp) t) options\n\n val set\n : ('k, 'cmp, ('k, 'v, 'cmp) t -> key:'k key -> data:'v -> ('k, 'v, 'cmp) t) options\n\n val add_multi\n : ( 'k\n , 'cmp\n , ('k, 'v list, 'cmp) t -> key:'k key -> data:'v -> ('k, 'v list, 'cmp) t )\n options\n\n val remove_multi\n : ('k, 'cmp, ('k, 'v list, 'cmp) t -> 'k key -> ('k, 'v list, 'cmp) t) options\n\n val find_multi : ('k, 'cmp, ('k, 'v list, 'cmp) t -> 'k key -> 'v list) options\n\n val change\n : ( 'k\n , 'cmp\n , ('k, 'v, 'cmp) t -> 'k key -> f:('v option -> 'v option) -> ('k, 'v, 'cmp) t )\n options\n\n val update\n : ( 'k\n , 'cmp\n , ('k, 'v, 'cmp) t -> 'k key -> f:('v option -> 'v) -> ('k, 'v, 'cmp) t )\n options\n\n val find : ('k, 'cmp, ('k, 'v, 'cmp) t -> 'k key -> 'v option) options\n val find_exn : ('k, 'cmp, ('k, 'v, 'cmp) t -> 'k key -> 'v) options\n val remove : ('k, 'cmp, ('k, 'v, 'cmp) t -> 'k key -> ('k, 'v, 'cmp) t) options\n val mem : ('k, 'cmp, ('k, _, 'cmp) t -> 'k key -> bool) options\n val iter_keys : ('k, _, _) t -> f:('k key -> unit) -> unit\n val iter : (_, 'v, _) t -> f:('v -> unit) -> unit\n val iteri : ('k, 'v, _) t -> f:(key:'k key -> data:'v -> unit) -> unit\n\n val iteri_until\n : ('k, 'v, _) t\n -> f:(key:'k key -> data:'v -> Continue_or_stop.t)\n -> Finished_or_unfinished.t\n\n val iter2\n : ( 'k\n , 'cmp\n , ('k, 'v1, 'cmp) t\n -> ('k, 'v2, 'cmp) t\n -> f:(key:'k key\n -> data:[ `Left of 'v1 | `Right of 'v2 | `Both of 'v1 * 'v2 ]\n -> unit)\n -> unit )\n options\n\n val map : ('k, 'v1, 'cmp) t -> f:('v1 -> 'v2) -> ('k, 'v2, 'cmp) t\n val mapi : ('k, 'v1, 'cmp) t -> f:(key:'k key -> data:'v1 -> 'v2) -> ('k, 'v2, 'cmp) t\n val fold : ('k, 'v, _) t -> init:'a -> f:(key:'k key -> data:'v -> 'a -> 'a) -> 'a\n\n val fold_right\n : ('k, 'v, _) t\n -> init:'a\n -> f:(key:'k key -> data:'v -> 'a -> 'a)\n -> 'a\n\n val fold2\n : ( 'k\n , 'cmp\n , ('k, 'v1, 'cmp) t\n -> ('k, 'v2, 'cmp) t\n -> init:'a\n -> f:(key:'k key\n -> data:[ `Left of 'v1 | `Right of 'v2 | `Both of 'v1 * 'v2 ]\n -> 'a\n -> 'a)\n -> 'a )\n options\n\n val filter_keys\n : ('k, 'cmp, ('k, 'v, 'cmp) t -> f:('k key -> bool) -> ('k, 'v, 'cmp) t) options\n\n val filter : ('k, 'cmp, ('k, 'v, 'cmp) t -> f:('v -> bool) -> ('k, 'v, 'cmp) t) options\n\n val filteri\n : ( 'k\n , 'cmp\n , ('k, 'v, 'cmp) t -> f:(key:'k key -> data:'v -> bool) -> ('k, 'v, 'cmp) t )\n options\n\n val filter_map\n : ('k, 'cmp, ('k, 'v1, 'cmp) t -> f:('v1 -> 'v2 option) -> ('k, 'v2, 'cmp) t) options\n\n val filter_mapi\n : ( 'k\n , 'cmp\n , ('k, 'v1, 'cmp) t\n -> f:(key:'k key -> data:'v1 -> 'v2 option)\n -> ('k, 'v2, 'cmp) t )\n options\n\n val partition_mapi\n : ( 'k\n , 'cmp\n , ('k, 'v1, 'cmp) t\n -> f:(key:'k key -> data:'v1 -> ('v2, 'v3) Either.t)\n -> ('k, 'v2, 'cmp) t * ('k, 'v3, 'cmp) t )\n options\n\n val partition_map\n : ( 'k\n , 'cmp\n , ('k, 'v1, 'cmp) t\n -> f:('v1 -> ('v2, 'v3) Either.t)\n -> ('k, 'v2, 'cmp) t * ('k, 'v3, 'cmp) t )\n options\n\n val partitioni_tf\n : ( 'k\n , 'cmp\n , ('k, 'v, 'cmp) t\n -> f:(key:'k key -> data:'v -> bool)\n -> ('k, 'v, 'cmp) t * ('k, 'v, 'cmp) t )\n options\n\n val partition_tf\n : ( 'k\n , 'cmp\n , ('k, 'v, 'cmp) t -> f:('v -> bool) -> ('k, 'v, 'cmp) t * ('k, 'v, 'cmp) t )\n options\n\n val combine_errors\n : ('k, 'cmp, ('k, 'v Or_error.t, 'cmp) t -> ('k, 'v, 'cmp) t Or_error.t) options\n\n val compare_direct\n : ( 'k\n , 'cmp\n , ('v -> 'v -> int) -> ('k, 'v, 'cmp) t -> ('k, 'v, 'cmp) t -> int )\n options\n\n val equal\n : ( 'k\n , 'cmp\n , ('v -> 'v -> bool) -> ('k, 'v, 'cmp) t -> ('k, 'v, 'cmp) t -> bool )\n options\n\n val keys : ('k, _, _) t -> 'k key list\n val data : (_, 'v, _) t -> 'v list\n\n val to_alist\n : ?key_order:[ `Increasing | `Decreasing ]\n -> ('k, 'v, _) t\n -> ('k key * 'v) list\n\n val validate\n : name:('k key -> string)\n -> 'v Validate.check\n -> ('k, 'v, _) t Validate.check\n\n val validatei\n : name:('k key -> string)\n -> ('k key * 'v) Validate.check\n -> ('k, 'v, _) t Validate.check\n\n val merge\n : ( 'k\n , 'cmp\n , ('k, 'v1, 'cmp) t\n -> ('k, 'v2, 'cmp) t\n -> f:(key:'k key\n -> [ `Left of 'v1 | `Right of 'v2 | `Both of 'v1 * 'v2 ]\n -> 'v3 option)\n -> ('k, 'v3, 'cmp) t )\n options\n\n val symmetric_diff\n : ( 'k\n , 'cmp\n , ('k, 'v, 'cmp) t\n -> ('k, 'v, 'cmp) t\n -> data_equal:('v -> 'v -> bool)\n -> ('k key, 'v) Symmetric_diff_element.t Sequence.t )\n options\n\n val fold_symmetric_diff\n : ( 'k\n , 'cmp\n , ('k, 'v, 'cmp) t\n -> ('k, 'v, 'cmp) t\n -> data_equal:('v -> 'v -> bool)\n -> init:'a\n -> f:('a -> ('k key, 'v) Symmetric_diff_element.t -> 'a)\n -> 'a )\n options\n\n val min_elt : ('k, 'v, _) t -> ('k key * 'v) option\n val min_elt_exn : ('k, 'v, _) t -> 'k key * 'v\n val max_elt : ('k, 'v, _) t -> ('k key * 'v) option\n val max_elt_exn : ('k, 'v, _) t -> 'k key * 'v\n val for_all : ('k, 'v, _) t -> f:('v -> bool) -> bool\n val for_alli : ('k, 'v, _) t -> f:(key:'k key -> data:'v -> bool) -> bool\n val exists : ('k, 'v, _) t -> f:('v -> bool) -> bool\n val existsi : ('k, 'v, _) t -> f:(key:'k key -> data:'v -> bool) -> bool\n val count : ('k, 'v, _) t -> f:('v -> bool) -> int\n val counti : ('k, 'v, _) t -> f:(key:'k key -> data:'v -> bool) -> int\n\n val split\n : ( 'k\n , 'cmp\n , ('k, 'v, 'cmp) t\n -> 'k key\n -> ('k, 'v, 'cmp) t * ('k key * 'v) option * ('k, 'v, 'cmp) t )\n options\n\n val append\n : ( 'k\n , 'cmp\n , lower_part:('k, 'v, 'cmp) t\n -> upper_part:('k, 'v, 'cmp) t\n -> [ `Ok of ('k, 'v, 'cmp) t | `Overlapping_key_ranges ] )\n options\n\n val subrange\n : ( 'k\n , 'cmp\n , ('k, 'v, 'cmp) t\n -> lower_bound:'k key Maybe_bound.t\n -> upper_bound:'k key Maybe_bound.t\n -> ('k, 'v, 'cmp) t )\n options\n\n val fold_range_inclusive\n : ( 'k\n , 'cmp\n , ('k, 'v, 'cmp) t\n -> min:'k key\n -> max:'k key\n -> init:'a\n -> f:(key:'k key -> data:'v -> 'a -> 'a)\n -> 'a )\n options\n\n val range_to_alist\n : ( 'k\n , 'cmp\n , ('k, 'v, 'cmp) t -> min:'k key -> max:'k key -> ('k key * 'v) list )\n options\n\n val closest_key\n : ( 'k\n , 'cmp\n , ('k, 'v, 'cmp) t\n -> [ `Greater_or_equal_to | `Greater_than | `Less_or_equal_to | `Less_than ]\n -> 'k key\n -> ('k key * 'v) option )\n options\n\n val nth : ('k, 'cmp, ('k, 'v, 'cmp) t -> int -> ('k key * 'v) option) options\n val nth_exn : ('k, 'cmp, ('k, 'v, 'cmp) t -> int -> 'k key * 'v) options\n val rank : ('k, 'cmp, ('k, _, 'cmp) t -> 'k key -> int option) options\n val to_tree : ('k, 'v, 'cmp) t -> ('k key, 'v, 'cmp) tree\n\n val to_sequence\n : ( 'k\n , 'cmp\n , ?order:[ `Increasing_key | `Decreasing_key ]\n -> ?keys_greater_or_equal_to:'k key\n -> ?keys_less_or_equal_to:'k key\n -> ('k, 'v, 'cmp) t\n -> ('k key * 'v) Sequence.t )\n options\n\n val binary_search\n : ( 'k\n , 'cmp\n , ('k, 'v, 'cmp) t\n -> compare:(key:'k key -> data:'v -> 'key -> int)\n -> [ `Last_strictly_less_than\n | `Last_less_than_or_equal_to\n | `Last_equal_to\n | `First_equal_to\n | `First_greater_than_or_equal_to\n | `First_strictly_greater_than\n ]\n -> 'key\n -> ('k key * 'v) option )\n options\n\n val binary_search_segmented\n : ( 'k\n , 'cmp\n , ('k, 'v, 'cmp) t\n -> segment_of:(key:'k key -> data:'v -> [ `Left | `Right ])\n -> [ `Last_on_left | `First_on_right ]\n -> ('k key * 'v) option )\n options\nend\n\nmodule type Accessors1 = sig\n type 'a t\n type 'a tree\n type key\n type comparator_witness\n\n val invariants : _ t -> bool\n val is_empty : _ t -> bool\n val length : _ t -> int\n val add : 'a t -> key:key -> data:'a -> 'a t Or_duplicate.t\n val add_exn : 'a t -> key:key -> data:'a -> 'a t\n val set : 'a t -> key:key -> data:'a -> 'a t\n val add_multi : 'a list t -> key:key -> data:'a -> 'a list t\n val remove_multi : 'a list t -> key -> 'a list t\n val find_multi : 'a list t -> key -> 'a list\n val change : 'a t -> key -> f:('a option -> 'a option) -> 'a t\n val update : 'a t -> key -> f:('a option -> 'a) -> 'a t\n val find : 'a t -> key -> 'a option\n val find_exn : 'a t -> key -> 'a\n val remove : 'a t -> key -> 'a t\n val mem : _ t -> key -> bool\n val iter_keys : _ t -> f:(key -> unit) -> unit\n val iter : 'a t -> f:('a -> unit) -> unit\n val iteri : 'a t -> f:(key:key -> data:'a -> unit) -> unit\n\n val iteri_until\n : 'a t\n -> f:(key:key -> data:'a -> Continue_or_stop.t)\n -> Finished_or_unfinished.t\n\n val iter2\n : 'a t\n -> 'b t\n -> f:(key:key -> data:[ `Left of 'a | `Right of 'b | `Both of 'a * 'b ] -> unit)\n -> unit\n\n val map : 'a t -> f:('a -> 'b) -> 'b t\n val mapi : 'a t -> f:(key:key -> data:'a -> 'b) -> 'b t\n val fold : 'a t -> init:'b -> f:(key:key -> data:'a -> 'b -> 'b) -> 'b\n val fold_right : 'a t -> init:'b -> f:(key:key -> data:'a -> 'b -> 'b) -> 'b\n\n val fold2\n : 'a t\n -> 'b t\n -> init:'c\n -> f:(key:key -> data:[ `Left of 'a | `Right of 'b | `Both of 'a * 'b ] -> 'c -> 'c)\n -> 'c\n\n val filter_keys : 'a t -> f:(key -> bool) -> 'a t\n val filter : 'a t -> f:('a -> bool) -> 'a t\n val filteri : 'a t -> f:(key:key -> data:'a -> bool) -> 'a t\n val filter_map : 'a t -> f:('a -> 'b option) -> 'b t\n val filter_mapi : 'a t -> f:(key:key -> data:'a -> 'b option) -> 'b t\n val partition_mapi : 'a t -> f:(key:key -> data:'a -> ('b, 'c) Either.t) -> 'b t * 'c t\n val partition_map : 'a t -> f:('a -> ('b, 'c) Either.t) -> 'b t * 'c t\n val partitioni_tf : 'a t -> f:(key:key -> data:'a -> bool) -> 'a t * 'a t\n val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t\n val combine_errors : 'a Or_error.t t -> 'a t Or_error.t\n val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int\n val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool\n val keys : _ t -> key list\n val data : 'a t -> 'a list\n val to_alist : ?key_order:[ `Increasing | `Decreasing ] -> 'a t -> (key * 'a) list\n val validate : name:(key -> string) -> 'a Validate.check -> 'a t Validate.check\n\n val validatei\n : name:(key -> string)\n -> (key * 'a) Validate.check\n -> 'a t Validate.check\n\n val merge\n : 'a t\n -> 'b t\n -> f:(key:key -> [ `Left of 'a | `Right of 'b | `Both of 'a * 'b ] -> 'c option)\n -> 'c t\n\n val symmetric_diff\n : 'a t\n -> 'a t\n -> data_equal:('a -> 'a -> bool)\n -> (key, 'a) Symmetric_diff_element.t Sequence.t\n\n val fold_symmetric_diff\n : 'a t\n -> 'a t\n -> data_equal:('a -> 'a -> bool)\n -> init:'c\n -> f:('c -> (key, 'a) Symmetric_diff_element.t -> 'c)\n -> 'c\n\n val min_elt : 'a t -> (key * 'a) option\n val min_elt_exn : 'a t -> key * 'a\n val max_elt : 'a t -> (key * 'a) option\n val max_elt_exn : 'a t -> key * 'a\n val for_all : 'a t -> f:('a -> bool) -> bool\n val for_alli : 'a t -> f:(key:key -> data:'a -> bool) -> bool\n val exists : 'a t -> f:('a -> bool) -> bool\n val existsi : 'a t -> f:(key:key -> data:'a -> bool) -> bool\n val count : 'a t -> f:('a -> bool) -> int\n val counti : 'a t -> f:(key:key -> data:'a -> bool) -> int\n val split : 'a t -> key -> 'a t * (key * 'a) option * 'a t\n\n val append\n : lower_part:'a t\n -> upper_part:'a t\n -> [ `Ok of 'a t | `Overlapping_key_ranges ]\n\n val subrange\n : 'a t\n -> lower_bound:key Maybe_bound.t\n -> upper_bound:key Maybe_bound.t\n -> 'a t\n\n val fold_range_inclusive\n : 'a t\n -> min:key\n -> max:key\n -> init:'b\n -> f:(key:key -> data:'a -> 'b -> 'b)\n -> 'b\n\n val range_to_alist : 'a t -> min:key -> max:key -> (key * 'a) list\n\n val closest_key\n : 'a t\n -> [ `Greater_or_equal_to | `Greater_than | `Less_or_equal_to | `Less_than ]\n -> key\n -> (key * 'a) option\n\n val nth : 'a t -> int -> (key * 'a) option\n val nth_exn : 'a t -> int -> key * 'a\n val rank : _ t -> key -> int option\n val to_tree : 'a t -> 'a tree\n\n val to_sequence\n : ?order:[ `Increasing_key | `Decreasing_key ]\n -> ?keys_greater_or_equal_to:key\n -> ?keys_less_or_equal_to:key\n -> 'a t\n -> (key * 'a) Sequence.t\n\n val binary_search\n : 'a t\n -> compare:(key:key -> data:'a -> 'key -> int)\n -> [ `Last_strictly_less_than\n | `Last_less_than_or_equal_to\n | `Last_equal_to\n | `First_equal_to\n | `First_greater_than_or_equal_to\n | `First_strictly_greater_than\n ]\n -> 'key\n -> (key * 'a) option\n\n val binary_search_segmented\n : 'a t\n -> segment_of:(key:key -> data:'a -> [ `Left | `Right ])\n -> [ `Last_on_left | `First_on_right ]\n -> (key * 'a) option\nend\n\nmodule type Accessors2 = sig\n type ('a, 'b) t\n type ('a, 'b) tree\n type comparator_witness\n\n val invariants : (_, _) t -> bool\n val is_empty : (_, _) t -> bool\n val length : (_, _) t -> int\n val add : ('a, 'b) t -> key:'a -> data:'b -> ('a, 'b) t Or_duplicate.t\n val add_exn : ('a, 'b) t -> key:'a -> data:'b -> ('a, 'b) t\n val set : ('a, 'b) t -> key:'a -> data:'b -> ('a, 'b) t\n val add_multi : ('a, 'b list) t -> key:'a -> data:'b -> ('a, 'b list) t\n val remove_multi : ('a, 'b list) t -> 'a -> ('a, 'b list) t\n val find_multi : ('a, 'b list) t -> 'a -> 'b list\n val change : ('a, 'b) t -> 'a -> f:('b option -> 'b option) -> ('a, 'b) t\n val update : ('a, 'b) t -> 'a -> f:('b option -> 'b) -> ('a, 'b) t\n val find : ('a, 'b) t -> 'a -> 'b option\n val find_exn : ('a, 'b) t -> 'a -> 'b\n val remove : ('a, 'b) t -> 'a -> ('a, 'b) t\n val mem : ('a, 'b) t -> 'a -> bool\n val iter_keys : ('a, _) t -> f:('a -> unit) -> unit\n val iter : (_, 'b) t -> f:('b -> unit) -> unit\n val iteri : ('a, 'b) t -> f:(key:'a -> data:'b -> unit) -> unit\n\n val iteri_until\n : ('a, 'b) t\n -> f:(key:'a -> data:'b -> Continue_or_stop.t)\n -> Finished_or_unfinished.t\n\n val iter2\n : ('a, 'b) t\n -> ('a, 'c) t\n -> f:(key:'a -> data:[ `Left of 'b | `Right of 'c | `Both of 'b * 'c ] -> unit)\n -> unit\n\n val map : ('a, 'b) t -> f:('b -> 'c) -> ('a, 'c) t\n val mapi : ('a, 'b) t -> f:(key:'a -> data:'b -> 'c) -> ('a, 'c) t\n val fold : ('a, 'b) t -> init:'c -> f:(key:'a -> data:'b -> 'c -> 'c) -> 'c\n val fold_right : ('a, 'b) t -> init:'c -> f:(key:'a -> data:'b -> 'c -> 'c) -> 'c\n\n val fold2\n : ('a, 'b) t\n -> ('a, 'c) t\n -> init:'d\n -> f:(key:'a -> data:[ `Left of 'b | `Right of 'c | `Both of 'b * 'c ] -> 'd -> 'd)\n -> 'd\n\n val filter_keys : ('a, 'b) t -> f:('a -> bool) -> ('a, 'b) t\n val filter : ('a, 'b) t -> f:('b -> bool) -> ('a, 'b) t\n val filteri : ('a, 'b) t -> f:(key:'a -> data:'b -> bool) -> ('a, 'b) t\n val filter_map : ('a, 'b) t -> f:('b -> 'c option) -> ('a, 'c) t\n val filter_mapi : ('a, 'b) t -> f:(key:'a -> data:'b -> 'c option) -> ('a, 'c) t\n\n val partition_mapi\n : ('a, 'b) t\n -> f:(key:'a -> data:'b -> ('c, 'd) Either.t)\n -> ('a, 'c) t * ('a, 'd) t\n\n val partition_map\n : ('a, 'b) t\n -> f:('b -> ('c, 'd) Either.t)\n -> ('a, 'c) t * ('a, 'd) t\n\n val partitioni_tf\n : ('a, 'b) t\n -> f:(key:'a -> data:'b -> bool)\n -> ('a, 'b) t * ('a, 'b) t\n\n val partition_tf : ('a, 'b) t -> f:('b -> bool) -> ('a, 'b) t * ('a, 'b) t\n val combine_errors : ('a, 'b Or_error.t) t -> ('a, 'b) t Or_error.t\n val compare_direct : ('b -> 'b -> int) -> ('a, 'b) t -> ('a, 'b) t -> int\n val equal : ('b -> 'b -> bool) -> ('a, 'b) t -> ('a, 'b) t -> bool\n val keys : ('a, _) t -> 'a list\n val data : (_, 'b) t -> 'b list\n val to_alist : ?key_order:[ `Increasing | `Decreasing ] -> ('a, 'b) t -> ('a * 'b) list\n val validate : name:('a -> string) -> 'b Validate.check -> ('a, 'b) t Validate.check\n\n val validatei\n : name:('a -> string)\n -> ('a * 'b) Validate.check\n -> ('a, 'b) t Validate.check\n\n val merge\n : ('a, 'b) t\n -> ('a, 'c) t\n -> f:(key:'a -> [ `Left of 'b | `Right of 'c | `Both of 'b * 'c ] -> 'd option)\n -> ('a, 'd) t\n\n val symmetric_diff\n : ('a, 'b) t\n -> ('a, 'b) t\n -> data_equal:('b -> 'b -> bool)\n -> ('a, 'b) Symmetric_diff_element.t Sequence.t\n\n val fold_symmetric_diff\n : ('a, 'b) t\n -> ('a, 'b) t\n -> data_equal:('b -> 'b -> bool)\n -> init:'c\n -> f:('c -> ('a, 'b) Symmetric_diff_element.t -> 'c)\n -> 'c\n\n val min_elt : ('a, 'b) t -> ('a * 'b) option\n val min_elt_exn : ('a, 'b) t -> 'a * 'b\n val max_elt : ('a, 'b) t -> ('a * 'b) option\n val max_elt_exn : ('a, 'b) t -> 'a * 'b\n val for_all : (_, 'b) t -> f:('b -> bool) -> bool\n val for_alli : ('a, 'b) t -> f:(key:'a -> data:'b -> bool) -> bool\n val exists : (_, 'b) t -> f:('b -> bool) -> bool\n val existsi : ('a, 'b) t -> f:(key:'a -> data:'b -> bool) -> bool\n val count : (_, 'b) t -> f:('b -> bool) -> int\n val counti : ('a, 'b) t -> f:(key:'a -> data:'b -> bool) -> int\n val split : ('a, 'b) t -> 'a -> ('a, 'b) t * ('a * 'b) option * ('a, 'b) t\n\n val append\n : lower_part:('a, 'b) t\n -> upper_part:('a, 'b) t\n -> [ `Ok of ('a, 'b) t | `Overlapping_key_ranges ]\n\n val subrange\n : ('a, 'b) t\n -> lower_bound:'a Maybe_bound.t\n -> upper_bound:'a Maybe_bound.t\n -> ('a, 'b) t\n\n val fold_range_inclusive\n : ('a, 'b) t\n -> min:'a\n -> max:'a\n -> init:'c\n -> f:(key:'a -> data:'b -> 'c -> 'c)\n -> 'c\n\n val range_to_alist : ('a, 'b) t -> min:'a -> max:'a -> ('a * 'b) list\n\n val closest_key\n : ('a, 'b) t\n -> [ `Greater_or_equal_to | `Greater_than | `Less_or_equal_to | `Less_than ]\n -> 'a\n -> ('a * 'b) option\n\n val nth : ('a, 'b) t -> int -> ('a * 'b) option\n val nth_exn : ('a, 'b) t -> int -> 'a * 'b\n val rank : ('a, _) t -> 'a -> int option\n val to_tree : ('a, 'b) t -> ('a, 'b) tree\n\n val to_sequence\n : ?order:[ `Increasing_key | `Decreasing_key ]\n -> ?keys_greater_or_equal_to:'a\n -> ?keys_less_or_equal_to:'a\n -> ('a, 'b) t\n -> ('a * 'b) Sequence.t\n\n val binary_search\n : ('k, 'v) t\n -> compare:(key:'k -> data:'v -> 'key -> int)\n -> [ `Last_strictly_less_than\n | `Last_less_than_or_equal_to\n | `Last_equal_to\n | `First_equal_to\n | `First_greater_than_or_equal_to\n | `First_strictly_greater_than\n ]\n -> 'key\n -> ('k * 'v) option\n\n val binary_search_segmented\n : ('k, 'v) t\n -> segment_of:(key:'k -> data:'v -> [ `Left | `Right ])\n -> [ `Last_on_left | `First_on_right ]\n -> ('k * 'v) option\nend\n\nmodule type Accessors3 = sig\n type ('a, 'b, 'cmp) t\n type ('a, 'b, 'cmp) tree\n\n val invariants : (_, _, _) t -> bool\n val is_empty : (_, _, _) t -> bool\n val length : (_, _, _) t -> int\n val add : ('a, 'b, 'cmp) t -> key:'a -> data:'b -> ('a, 'b, 'cmp) t Or_duplicate.t\n val add_exn : ('a, 'b, 'cmp) t -> key:'a -> data:'b -> ('a, 'b, 'cmp) t\n val set : ('a, 'b, 'cmp) t -> key:'a -> data:'b -> ('a, 'b, 'cmp) t\n val add_multi : ('a, 'b list, 'cmp) t -> key:'a -> data:'b -> ('a, 'b list, 'cmp) t\n val remove_multi : ('a, 'b list, 'cmp) t -> 'a -> ('a, 'b list, 'cmp) t\n val find_multi : ('a, 'b list, 'cmp) t -> 'a -> 'b list\n val change : ('a, 'b, 'cmp) t -> 'a -> f:('b option -> 'b option) -> ('a, 'b, 'cmp) t\n val update : ('a, 'b, 'cmp) t -> 'a -> f:('b option -> 'b) -> ('a, 'b, 'cmp) t\n val find : ('a, 'b, 'cmp) t -> 'a -> 'b option\n val find_exn : ('a, 'b, 'cmp) t -> 'a -> 'b\n val remove : ('a, 'b, 'cmp) t -> 'a -> ('a, 'b, 'cmp) t\n val mem : ('a, 'b, 'cmp) t -> 'a -> bool\n val iter_keys : ('a, _, 'cmp) t -> f:('a -> unit) -> unit\n val iter : (_, 'b, 'cmp) t -> f:('b -> unit) -> unit\n val iteri : ('a, 'b, 'cmp) t -> f:(key:'a -> data:'b -> unit) -> unit\n\n val iteri_until\n : ('a, 'b, 'cmp) t\n -> f:(key:'a -> data:'b -> Continue_or_stop.t)\n -> Finished_or_unfinished.t\n\n val iter2\n : ('a, 'b, 'cmp) t\n -> ('a, 'c, 'cmp) t\n -> f:(key:'a -> data:[ `Left of 'b | `Right of 'c | `Both of 'b * 'c ] -> unit)\n -> unit\n\n val map : ('a, 'b, 'cmp) t -> f:('b -> 'c) -> ('a, 'c, 'cmp) t\n val mapi : ('a, 'b, 'cmp) t -> f:(key:'a -> data:'b -> 'c) -> ('a, 'c, 'cmp) t\n val fold : ('a, 'b, _) t -> init:'c -> f:(key:'a -> data:'b -> 'c -> 'c) -> 'c\n val fold_right : ('a, 'b, _) t -> init:'c -> f:(key:'a -> data:'b -> 'c -> 'c) -> 'c\n\n val fold2\n : ('a, 'b, 'cmp) t\n -> ('a, 'c, 'cmp) t\n -> init:'d\n -> f:(key:'a -> data:[ `Left of 'b | `Right of 'c | `Both of 'b * 'c ] -> 'd -> 'd)\n -> 'd\n\n val filter_keys : ('a, 'b, 'cmp) t -> f:('a -> bool) -> ('a, 'b, 'cmp) t\n val filter : ('a, 'b, 'cmp) t -> f:('b -> bool) -> ('a, 'b, 'cmp) t\n val filteri : ('a, 'b, 'cmp) t -> f:(key:'a -> data:'b -> bool) -> ('a, 'b, 'cmp) t\n val filter_map : ('a, 'b, 'cmp) t -> f:('b -> 'c option) -> ('a, 'c, 'cmp) t\n\n val filter_mapi\n : ('a, 'b, 'cmp) t\n -> f:(key:'a -> data:'b -> 'c option)\n -> ('a, 'c, 'cmp) t\n\n val partition_mapi\n : ('a, 'b, 'cmp) t\n -> f:(key:'a -> data:'b -> ('c, 'd) Either.t)\n -> ('a, 'c, 'cmp) t * ('a, 'd, 'cmp) t\n\n val partition_map\n : ('a, 'b, 'cmp) t\n -> f:('b -> ('c, 'd) Either.t)\n -> ('a, 'c, 'cmp) t * ('a, 'd, 'cmp) t\n\n val partitioni_tf\n : ('a, 'b, 'cmp) t\n -> f:(key:'a -> data:'b -> bool)\n -> ('a, 'b, 'cmp) t * ('a, 'b, 'cmp) t\n\n val partition_tf\n : ('a, 'b, 'cmp) t\n -> f:('b -> bool)\n -> ('a, 'b, 'cmp) t * ('a, 'b, 'cmp) t\n\n val combine_errors : ('a, 'b Or_error.t, 'cmp) t -> ('a, 'b, 'cmp) t Or_error.t\n val compare_direct : ('b -> 'b -> int) -> ('a, 'b, 'cmp) t -> ('a, 'b, 'cmp) t -> int\n val equal : ('b -> 'b -> bool) -> ('a, 'b, 'cmp) t -> ('a, 'b, 'cmp) t -> bool\n val keys : ('a, _, _) t -> 'a list\n val data : (_, 'b, _) t -> 'b list\n\n val to_alist\n : ?key_order:[ `Increasing | `Decreasing ]\n -> ('a, 'b, _) t\n -> ('a * 'b) list\n\n val validate : name:('a -> string) -> 'b Validate.check -> ('a, 'b, _) t Validate.check\n\n val validatei\n : name:('a -> string)\n -> ('a * 'b) Validate.check\n -> ('a, 'b, _) t Validate.check\n\n val merge\n : ('a, 'b, 'cmp) t\n -> ('a, 'c, 'cmp) t\n -> f:(key:'a -> [ `Left of 'b | `Right of 'c | `Both of 'b * 'c ] -> 'd option)\n -> ('a, 'd, 'cmp) t\n\n val symmetric_diff\n : ('a, 'b, 'cmp) t\n -> ('a, 'b, 'cmp) t\n -> data_equal:('b -> 'b -> bool)\n -> ('a, 'b) Symmetric_diff_element.t Sequence.t\n\n val fold_symmetric_diff\n : ('a, 'b, 'cmp) t\n -> ('a, 'b, 'cmp) t\n -> data_equal:('b -> 'b -> bool)\n -> init:'c\n -> f:('c -> ('a, 'b) Symmetric_diff_element.t -> 'c)\n -> 'c\n\n val min_elt : ('a, 'b, 'cmp) t -> ('a * 'b) option\n val min_elt_exn : ('a, 'b, 'cmp) t -> 'a * 'b\n val max_elt : ('a, 'b, 'cmp) t -> ('a * 'b) option\n val max_elt_exn : ('a, 'b, 'cmp) t -> 'a * 'b\n val for_all : (_, 'b, _) t -> f:('b -> bool) -> bool\n val for_alli : ('a, 'b, _) t -> f:(key:'a -> data:'b -> bool) -> bool\n val exists : (_, 'b, _) t -> f:('b -> bool) -> bool\n val existsi : ('a, 'b, _) t -> f:(key:'a -> data:'b -> bool) -> bool\n val count : (_, 'b, _) t -> f:('b -> bool) -> int\n val counti : ('a, 'b, _) t -> f:(key:'a -> data:'b -> bool) -> int\n\n val split\n : ('k, 'v, 'cmp) t\n -> 'k\n -> ('k, 'v, 'cmp) t * ('k * 'v) option * ('k, 'v, 'cmp) t\n\n val append\n : lower_part:('k, 'v, 'cmp) t\n -> upper_part:('k, 'v, 'cmp) t\n -> [ `Ok of ('k, 'v, 'cmp) t | `Overlapping_key_ranges ]\n\n val subrange\n : ('k, 'v, 'cmp) t\n -> lower_bound:'k Maybe_bound.t\n -> upper_bound:'k Maybe_bound.t\n -> ('k, 'v, 'cmp) t\n\n val fold_range_inclusive\n : ('a, 'b, _) t\n -> min:'a\n -> max:'a\n -> init:'c\n -> f:(key:'a -> data:'b -> 'c -> 'c)\n -> 'c\n\n val range_to_alist : ('a, 'b, _) t -> min:'a -> max:'a -> ('a * 'b) list\n\n val closest_key\n : ('a, 'b, _) t\n -> [ `Greater_or_equal_to | `Greater_than | `Less_or_equal_to | `Less_than ]\n -> 'a\n -> ('a * 'b) option\n\n val nth : ('a, 'b, _) t -> int -> ('a * 'b) option\n val nth_exn : ('a, 'b, _) t -> int -> 'a * 'b\n val rank : ('a, _, _) t -> 'a -> int option\n val to_tree : ('a, 'b, 'cmp) t -> ('a, 'b, 'cmp) tree\n\n val to_sequence\n : ?order:[ `Increasing_key | `Decreasing_key ]\n -> ?keys_greater_or_equal_to:'a\n -> ?keys_less_or_equal_to:'a\n -> ('a, 'b, _) t\n -> ('a * 'b) Sequence.t\n\n val binary_search\n : ('k, 'v, _) t\n -> compare:(key:'k -> data:'v -> 'key -> int)\n -> [ `Last_strictly_less_than\n | `Last_less_than_or_equal_to\n | `Last_equal_to\n | `First_equal_to\n | `First_greater_than_or_equal_to\n | `First_strictly_greater_than\n ]\n -> 'key\n -> ('k * 'v) option\n\n val binary_search_segmented\n : ('k, 'v, _) t\n -> segment_of:(key:'k -> data:'v -> [ `Left | `Right ])\n -> [ `Last_on_left | `First_on_right ]\n -> ('k * 'v) option\nend\n\nmodule type Accessors3_with_comparator = sig\n type ('a, 'b, 'cmp) t\n type ('a, 'b, 'cmp) tree\n\n val invariants : comparator:('a, 'cmp) Comparator.t -> ('a, 'b, 'cmp) t -> bool\n val is_empty : ('a, 'b, 'cmp) t -> bool\n val length : ('a, 'b, 'cmp) t -> int\n\n val add\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b, 'cmp) t\n -> key:'a\n -> data:'b\n -> ('a, 'b, 'cmp) t Or_duplicate.t\n\n val add_exn\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b, 'cmp) t\n -> key:'a\n -> data:'b\n -> ('a, 'b, 'cmp) t\n\n val set\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b, 'cmp) t\n -> key:'a\n -> data:'b\n -> ('a, 'b, 'cmp) t\n\n val add_multi\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b list, 'cmp) t\n -> key:'a\n -> data:'b\n -> ('a, 'b list, 'cmp) t\n\n val remove_multi\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b list, 'cmp) t\n -> 'a\n -> ('a, 'b list, 'cmp) t\n\n val find_multi\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b list, 'cmp) t\n -> 'a\n -> 'b list\n\n val change\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b, 'cmp) t\n -> 'a\n -> f:('b option -> 'b option)\n -> ('a, 'b, 'cmp) t\n\n val update\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b, 'cmp) t\n -> 'a\n -> f:('b option -> 'b)\n -> ('a, 'b, 'cmp) t\n\n val find : comparator:('a, 'cmp) Comparator.t -> ('a, 'b, 'cmp) t -> 'a -> 'b option\n val find_exn : comparator:('a, 'cmp) Comparator.t -> ('a, 'b, 'cmp) t -> 'a -> 'b\n\n val remove\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b, 'cmp) t\n -> 'a\n -> ('a, 'b, 'cmp) t\n\n val mem : comparator:('a, 'cmp) Comparator.t -> ('a, 'b, 'cmp) t -> 'a -> bool\n val iter_keys : ('a, _, 'cmp) t -> f:('a -> unit) -> unit\n val iter : (_, 'b, 'cmp) t -> f:('b -> unit) -> unit\n val iteri : ('a, 'b, 'cmp) t -> f:(key:'a -> data:'b -> unit) -> unit\n\n val iteri_until\n : ('a, 'b, 'cmp) t\n -> f:(key:'a -> data:'b -> Continue_or_stop.t)\n -> Finished_or_unfinished.t\n\n val iter2\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b, 'cmp) t\n -> ('a, 'c, 'cmp) t\n -> f:(key:'a -> data:[ `Left of 'b | `Right of 'c | `Both of 'b * 'c ] -> unit)\n -> unit\n\n val map : ('a, 'b, 'cmp) t -> f:('b -> 'c) -> ('a, 'c, 'cmp) t\n val mapi : ('a, 'b, 'cmp) t -> f:(key:'a -> data:'b -> 'c) -> ('a, 'c, 'cmp) t\n val fold : ('a, 'b, _) t -> init:'c -> f:(key:'a -> data:'b -> 'c -> 'c) -> 'c\n val fold_right : ('a, 'b, _) t -> init:'c -> f:(key:'a -> data:'b -> 'c -> 'c) -> 'c\n\n val fold2\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b, 'cmp) t\n -> ('a, 'c, 'cmp) t\n -> init:'d\n -> f:(key:'a -> data:[ `Left of 'b | `Right of 'c | `Both of 'b * 'c ] -> 'd -> 'd)\n -> 'd\n\n val filter_keys\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b, 'cmp) t\n -> f:('a -> bool)\n -> ('a, 'b, 'cmp) t\n\n val filter\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b, 'cmp) t\n -> f:('b -> bool)\n -> ('a, 'b, 'cmp) t\n\n val filteri\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b, 'cmp) t\n -> f:(key:'a -> data:'b -> bool)\n -> ('a, 'b, 'cmp) t\n\n val filter_map\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b, 'cmp) t\n -> f:('b -> 'c option)\n -> ('a, 'c, 'cmp) t\n\n val filter_mapi\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b, 'cmp) t\n -> f:(key:'a -> data:'b -> 'c option)\n -> ('a, 'c, 'cmp) t\n\n val partition_mapi\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b, 'cmp) t\n -> f:(key:'a -> data:'b -> ('c, 'd) Either.t)\n -> ('a, 'c, 'cmp) t * ('a, 'd, 'cmp) t\n\n val partition_map\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b, 'cmp) t\n -> f:('b -> ('c, 'd) Either.t)\n -> ('a, 'c, 'cmp) t * ('a, 'd, 'cmp) t\n\n val partitioni_tf\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b, 'cmp) t\n -> f:(key:'a -> data:'b -> bool)\n -> ('a, 'b, 'cmp) t * ('a, 'b, 'cmp) t\n\n val partition_tf\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b, 'cmp) t\n -> f:('b -> bool)\n -> ('a, 'b, 'cmp) t * ('a, 'b, 'cmp) t\n\n val combine_errors\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b Or_error.t, 'cmp) t\n -> ('a, 'b, 'cmp) t Or_error.t\n\n val compare_direct\n : comparator:('a, 'cmp) Comparator.t\n -> ('b -> 'b -> int)\n -> ('a, 'b, 'cmp) t\n -> ('a, 'b, 'cmp) t\n -> int\n\n val equal\n : comparator:('a, 'cmp) Comparator.t\n -> ('b -> 'b -> bool)\n -> ('a, 'b, 'cmp) t\n -> ('a, 'b, 'cmp) t\n -> bool\n\n val keys : ('a, _, _) t -> 'a list\n val data : (_, 'b, _) t -> 'b list\n\n val to_alist\n : ?key_order:[ `Increasing | `Decreasing ]\n -> ('a, 'b, _) t\n -> ('a * 'b) list\n\n val validate : name:('a -> string) -> 'b Validate.check -> ('a, 'b, _) t Validate.check\n\n val validatei\n : name:('a -> string)\n -> ('a * 'b) Validate.check\n -> ('a, 'b, _) t Validate.check\n\n val merge\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b, 'cmp) t\n -> ('a, 'c, 'cmp) t\n -> f:(key:'a -> [ `Left of 'b | `Right of 'c | `Both of 'b * 'c ] -> 'd option)\n -> ('a, 'd, 'cmp) t\n\n val symmetric_diff\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b, 'cmp) t\n -> ('a, 'b, 'cmp) t\n -> data_equal:('b -> 'b -> bool)\n -> ('a, 'b) Symmetric_diff_element.t Sequence.t\n\n val fold_symmetric_diff\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b, 'cmp) t\n -> ('a, 'b, 'cmp) t\n -> data_equal:('b -> 'b -> bool)\n -> init:'c\n -> f:('c -> ('a, 'b) Symmetric_diff_element.t -> 'c)\n -> 'c\n\n val min_elt : ('a, 'b, 'cmp) t -> ('a * 'b) option\n val min_elt_exn : ('a, 'b, 'cmp) t -> 'a * 'b\n val max_elt : ('a, 'b, 'cmp) t -> ('a * 'b) option\n val max_elt_exn : ('a, 'b, 'cmp) t -> 'a * 'b\n val for_all : ('a, 'b, 'cmp) t -> f:('b -> bool) -> bool\n val for_alli : ('a, 'b, 'cmp) t -> f:(key:'a -> data:'b -> bool) -> bool\n val exists : ('a, 'b, 'cmp) t -> f:('b -> bool) -> bool\n val existsi : ('a, 'b, 'cmp) t -> f:(key:'a -> data:'b -> bool) -> bool\n val count : ('a, 'b, 'cmp) t -> f:('b -> bool) -> int\n val counti : ('a, 'b, 'cmp) t -> f:(key:'a -> data:'b -> bool) -> int\n\n val split\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b, 'cmp) t\n -> 'a\n -> ('a, 'b, 'cmp) t * ('a * 'b) option * ('a, 'b, 'cmp) t\n\n val append\n : comparator:('a, 'cmp) Comparator.t\n -> lower_part:('a, 'b, 'cmp) t\n -> upper_part:('a, 'b, 'cmp) t\n -> [ `Ok of ('a, 'b, 'cmp) t | `Overlapping_key_ranges ]\n\n val subrange\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b, 'cmp) t\n -> lower_bound:'a Maybe_bound.t\n -> upper_bound:'a Maybe_bound.t\n -> ('a, 'b, 'cmp) t\n\n val fold_range_inclusive\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b, 'cmp) t\n -> min:'a\n -> max:'a\n -> init:'c\n -> f:(key:'a -> data:'b -> 'c -> 'c)\n -> 'c\n\n val range_to_alist\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b, 'cmp) t\n -> min:'a\n -> max:'a\n -> ('a * 'b) list\n\n val closest_key\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b, 'cmp) t\n -> [ `Greater_or_equal_to | `Greater_than | `Less_or_equal_to | `Less_than ]\n -> 'a\n -> ('a * 'b) option\n\n val nth\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b, 'cmp) t\n -> int\n -> ('a * 'b) option\n\n val nth_exn : comparator:('a, 'cmp) Comparator.t -> ('a, 'b, 'cmp) t -> int -> 'a * 'b\n val rank : comparator:('a, 'cmp) Comparator.t -> ('a, 'b, 'cmp) t -> 'a -> int option\n val to_tree : ('a, 'b, 'cmp) t -> ('a, 'b, 'cmp) tree\n\n val to_sequence\n : comparator:('a, 'cmp) Comparator.t\n -> ?order:[ `Increasing_key | `Decreasing_key ]\n -> ?keys_greater_or_equal_to:'a\n -> ?keys_less_or_equal_to:'a\n -> ('a, 'b, 'cmp) t\n -> ('a * 'b) Sequence.t\n\n val binary_search\n : comparator:('k, 'cmp) Comparator.t\n -> ('k, 'v, 'cmp) t\n -> compare:(key:'k -> data:'v -> 'key -> int)\n -> [ `Last_strictly_less_than\n | `Last_less_than_or_equal_to\n | `Last_equal_to\n | `First_equal_to\n | `First_greater_than_or_equal_to\n | `First_strictly_greater_than\n ]\n -> 'key\n -> ('k * 'v) option\n\n val binary_search_segmented\n : comparator:('k, 'cmp) Comparator.t\n -> ('k, 'v, 'cmp) t\n -> segment_of:(key:'k -> data:'v -> [ `Left | `Right ])\n -> [ `Last_on_left | `First_on_right ]\n -> ('k * 'v) option\nend\n\n(** Consistency checks (same as in [Container]). *)\nmodule Check_accessors\n (T : T3)\n (Tree : T3)\n (Key : T1)\n (Cmp : T1)\n (Options : T3)\n (M : Accessors_generic\n with type ('a, 'b, 'c) options := ('a, 'b, 'c) Options.t\n with type ('a, 'b, 'c) t := ('a, 'b, 'c) T.t\n with type ('a, 'b, 'c) tree := ('a, 'b, 'c) Tree.t\n with type 'a key := 'a Key.t\n with type 'cmp cmp := 'cmp Cmp.t) =\nstruct end\n\nmodule Check_accessors1 (M : Accessors1) =\n Check_accessors\n (struct\n type ('a, 'b, 'c) t = 'b M.t\n end)\n (struct\n type ('a, 'b, 'c) t = 'b M.tree\n end)\n (struct\n type 'a t = M.key\n end)\n (struct\n type 'a t = M.comparator_witness\n end)\n (Without_comparator)\n (M)\n\nmodule Check_accessors2 (M : Accessors2) =\n Check_accessors\n (struct\n type ('a, 'b, 'c) t = ('a, 'b) M.t\n end)\n (struct\n type ('a, 'b, 'c) t = ('a, 'b) M.tree\n end)\n (struct\n type 'a t = 'a\n end)\n (struct\n type 'a t = M.comparator_witness\n end)\n (Without_comparator)\n (M)\n\nmodule Check_accessors3 (M : Accessors3) =\n Check_accessors\n (struct\n type ('a, 'b, 'c) t = ('a, 'b, 'c) M.t\n end)\n (struct\n type ('a, 'b, 'c) t = ('a, 'b, 'c) M.tree\n end)\n (struct\n type 'a t = 'a\n end)\n (struct\n type 'a t = 'a\n end)\n (Without_comparator)\n (M)\n\nmodule Check_accessors3_with_comparator (M : Accessors3_with_comparator) =\n Check_accessors\n (struct\n type ('a, 'b, 'c) t = ('a, 'b, 'c) M.t\n end)\n (struct\n type ('a, 'b, 'c) t = ('a, 'b, 'c) M.tree\n end)\n (struct\n type 'a t = 'a\n end)\n (struct\n type 'a t = 'a\n end)\n (With_comparator)\n (M)\n\nmodule type Creators_generic = sig\n type ('k, 'v, 'cmp) t\n type ('k, 'v, 'cmp) tree\n type 'k key\n type ('a, 'cmp, 'z) options\n type 'cmp cmp\n\n val empty : ('k, 'cmp, ('k, _, 'cmp) t) options\n val singleton : ('k, 'cmp, 'k key -> 'v -> ('k, 'v, 'cmp) t) options\n\n val of_sorted_array\n : ('k, 'cmp, ('k key * 'v) array -> ('k, 'v, 'cmp) t Or_error.t) options\n\n val of_sorted_array_unchecked\n : ('k, 'cmp, ('k key * 'v) array -> ('k, 'v, 'cmp) t) options\n\n val of_increasing_iterator_unchecked\n : ('k, 'cmp, len:int -> f:(int -> 'k key * 'v) -> ('k, 'v, 'cmp) t) options\n\n val of_alist\n : ( 'k\n , 'cmp\n , ('k key * 'v) list -> [ `Ok of ('k, 'v, 'cmp) t | `Duplicate_key of 'k key ] )\n options\n\n val of_alist_or_error\n : ('k, 'cmp, ('k key * 'v) list -> ('k, 'v, 'cmp) t Or_error.t) options\n\n val of_alist_exn : ('k, 'cmp, ('k key * 'v) list -> ('k, 'v, 'cmp) t) options\n val of_alist_multi : ('k, 'cmp, ('k key * 'v) list -> ('k, 'v list, 'cmp) t) options\n\n val of_alist_fold\n : ( 'k\n , 'cmp\n , ('k key * 'v1) list -> init:'v2 -> f:('v2 -> 'v1 -> 'v2) -> ('k, 'v2, 'cmp) t )\n options\n\n val of_alist_reduce\n : ('k, 'cmp, ('k key * 'v) list -> f:('v -> 'v -> 'v) -> ('k, 'v, 'cmp) t) options\n\n val of_increasing_sequence\n : ('k, 'cmp, ('k key * 'v) Sequence.t -> ('k, 'v, 'cmp) t Or_error.t) options\n\n val of_sequence\n : ( 'k\n , 'cmp\n , ('k key * 'v) Sequence.t -> [ `Ok of ('k, 'v, 'cmp) t | `Duplicate_key of 'k key ]\n )\n options\n\n val of_sequence_or_error\n : ('k, 'cmp, ('k key * 'v) Sequence.t -> ('k, 'v, 'cmp) t Or_error.t) options\n\n val of_sequence_exn : ('k, 'cmp, ('k key * 'v) Sequence.t -> ('k, 'v, 'cmp) t) options\n\n val of_sequence_multi\n : ('k, 'cmp, ('k key * 'v) Sequence.t -> ('k, 'v list, 'cmp) t) options\n\n val of_sequence_fold\n : ( 'k\n , 'cmp\n , ('k key * 'v1) Sequence.t\n -> init:'v2\n -> f:('v2 -> 'v1 -> 'v2)\n -> ('k, 'v2, 'cmp) t )\n options\n\n val of_sequence_reduce\n : ( 'k\n , 'cmp\n , ('k key * 'v) Sequence.t -> f:('v -> 'v -> 'v) -> ('k, 'v, 'cmp) t )\n options\n\n val of_iteri\n : ( 'k\n , 'cmp\n , iteri:(f:(key:'k key -> data:'v -> unit) -> unit)\n -> [ `Ok of ('k, 'v, 'cmp) t | `Duplicate_key of 'k key ] )\n options\n\n val of_tree : ('k, 'cmp, ('k key, 'v, 'cmp) tree -> ('k, 'v, 'cmp) t) options\nend\n\nmodule type Creators1 = sig\n type 'a t\n type 'a tree\n type key\n type comparator_witness\n\n val empty : _ t\n val singleton : key -> 'a -> 'a t\n val of_alist : (key * 'a) list -> [ `Ok of 'a t | `Duplicate_key of key ]\n val of_alist_or_error : (key * 'a) list -> 'a t Or_error.t\n val of_alist_exn : (key * 'a) list -> 'a t\n val of_alist_multi : (key * 'a) list -> 'a list t\n val of_alist_fold : (key * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t\n val of_alist_reduce : (key * 'a) list -> f:('a -> 'a -> 'a) -> 'a t\n val of_sorted_array : (key * 'a) array -> 'a t Or_error.t\n val of_sorted_array_unchecked : (key * 'a) array -> 'a t\n val of_increasing_iterator_unchecked : len:int -> f:(int -> key * 'a) -> 'a t\n val of_increasing_sequence : (key * 'a) Sequence.t -> 'a t Or_error.t\n val of_sequence : (key * 'a) Sequence.t -> [ `Ok of 'a t | `Duplicate_key of key ]\n val of_sequence_or_error : (key * 'a) Sequence.t -> 'a t Or_error.t\n val of_sequence_exn : (key * 'a) Sequence.t -> 'a t\n val of_sequence_multi : (key * 'a) Sequence.t -> 'a list t\n val of_sequence_fold : (key * 'a) Sequence.t -> init:'b -> f:('b -> 'a -> 'b) -> 'b t\n val of_sequence_reduce : (key * 'a) Sequence.t -> f:('a -> 'a -> 'a) -> 'a t\n\n val of_iteri\n : iteri:(f:(key:key -> data:'v -> unit) -> unit)\n -> [ `Ok of 'v t | `Duplicate_key of key ]\n\n val of_tree : 'a tree -> 'a t\nend\n\nmodule type Creators2 = sig\n type ('a, 'b) t\n type ('a, 'b) tree\n type comparator_witness\n\n val empty : (_, _) t\n val singleton : 'a -> 'b -> ('a, 'b) t\n val of_alist : ('a * 'b) list -> [ `Ok of ('a, 'b) t | `Duplicate_key of 'a ]\n val of_alist_or_error : ('a * 'b) list -> ('a, 'b) t Or_error.t\n val of_alist_exn : ('a * 'b) list -> ('a, 'b) t\n val of_alist_multi : ('a * 'b) list -> ('a, 'b list) t\n val of_alist_fold : ('a * 'b) list -> init:'c -> f:('c -> 'b -> 'c) -> ('a, 'c) t\n val of_alist_reduce : ('a * 'b) list -> f:('b -> 'b -> 'b) -> ('a, 'b) t\n val of_sorted_array : ('a * 'b) array -> ('a, 'b) t Or_error.t\n val of_sorted_array_unchecked : ('a * 'b) array -> ('a, 'b) t\n val of_increasing_iterator_unchecked : len:int -> f:(int -> 'a * 'b) -> ('a, 'b) t\n val of_increasing_sequence : ('a * 'b) Sequence.t -> ('a, 'b) t Or_error.t\n val of_sequence : ('a * 'b) Sequence.t -> [ `Ok of ('a, 'b) t | `Duplicate_key of 'a ]\n val of_sequence_or_error : ('a * 'b) Sequence.t -> ('a, 'b) t Or_error.t\n val of_sequence_exn : ('a * 'b) Sequence.t -> ('a, 'b) t\n val of_sequence_multi : ('a * 'b) Sequence.t -> ('a, 'b list) t\n\n val of_sequence_fold\n : ('a * 'b) Sequence.t\n -> init:'c\n -> f:('c -> 'b -> 'c)\n -> ('a, 'c) t\n\n val of_sequence_reduce : ('a * 'b) Sequence.t -> f:('b -> 'b -> 'b) -> ('a, 'b) t\n\n val of_iteri\n : iteri:(f:(key:'a -> data:'b -> unit) -> unit)\n -> [ `Ok of ('a, 'b) t | `Duplicate_key of 'a ]\n\n val of_tree : ('a, 'b) tree -> ('a, 'b) t\nend\n\nmodule type Creators3_with_comparator = sig\n type ('a, 'b, 'cmp) t\n type ('a, 'b, 'cmp) tree\n\n val empty : comparator:('a, 'cmp) Comparator.t -> ('a, _, 'cmp) t\n val singleton : comparator:('a, 'cmp) Comparator.t -> 'a -> 'b -> ('a, 'b, 'cmp) t\n\n val of_alist\n : comparator:('a, 'cmp) Comparator.t\n -> ('a * 'b) list\n -> [ `Ok of ('a, 'b, 'cmp) t | `Duplicate_key of 'a ]\n\n val of_alist_or_error\n : comparator:('a, 'cmp) Comparator.t\n -> ('a * 'b) list\n -> ('a, 'b, 'cmp) t Or_error.t\n\n val of_alist_exn\n : comparator:('a, 'cmp) Comparator.t\n -> ('a * 'b) list\n -> ('a, 'b, 'cmp) t\n\n val of_alist_multi\n : comparator:('a, 'cmp) Comparator.t\n -> ('a * 'b) list\n -> ('a, 'b list, 'cmp) t\n\n val of_alist_fold\n : comparator:('a, 'cmp) Comparator.t\n -> ('a * 'b) list\n -> init:'c\n -> f:('c -> 'b -> 'c)\n -> ('a, 'c, 'cmp) t\n\n val of_alist_reduce\n : comparator:('a, 'cmp) Comparator.t\n -> ('a * 'b) list\n -> f:('b -> 'b -> 'b)\n -> ('a, 'b, 'cmp) t\n\n val of_sorted_array\n : comparator:('a, 'cmp) Comparator.t\n -> ('a * 'b) array\n -> ('a, 'b, 'cmp) t Or_error.t\n\n val of_sorted_array_unchecked\n : comparator:('a, 'cmp) Comparator.t\n -> ('a * 'b) array\n -> ('a, 'b, 'cmp) t\n\n val of_increasing_iterator_unchecked\n : comparator:('a, 'cmp) Comparator.t\n -> len:int\n -> f:(int -> 'a * 'b)\n -> ('a, 'b, 'cmp) t\n\n val of_increasing_sequence\n : comparator:('a, 'cmp) Comparator.t\n -> ('a * 'b) Sequence.t\n -> ('a, 'b, 'cmp) t Or_error.t\n\n val of_sequence\n : comparator:('a, 'cmp) Comparator.t\n -> ('a * 'b) Sequence.t\n -> [ `Ok of ('a, 'b, 'cmp) t | `Duplicate_key of 'a ]\n\n val of_sequence_or_error\n : comparator:('a, 'cmp) Comparator.t\n -> ('a * 'b) Sequence.t\n -> ('a, 'b, 'cmp) t Or_error.t\n\n val of_sequence_exn\n : comparator:('a, 'cmp) Comparator.t\n -> ('a * 'b) Sequence.t\n -> ('a, 'b, 'cmp) t\n\n val of_sequence_multi\n : comparator:('a, 'cmp) Comparator.t\n -> ('a * 'b) Sequence.t\n -> ('a, 'b list, 'cmp) t\n\n val of_sequence_fold\n : comparator:('a, 'cmp) Comparator.t\n -> ('a * 'b) Sequence.t\n -> init:'c\n -> f:('c -> 'b -> 'c)\n -> ('a, 'c, 'cmp) t\n\n val of_sequence_reduce\n : comparator:('a, 'cmp) Comparator.t\n -> ('a * 'b) Sequence.t\n -> f:('b -> 'b -> 'b)\n -> ('a, 'b, 'cmp) t\n\n val of_iteri\n : comparator:('a, 'cmp) Comparator.t\n -> iteri:(f:(key:'a -> data:'b -> unit) -> unit)\n -> [ `Ok of ('a, 'b, 'cmp) t | `Duplicate_key of 'a ]\n\n val of_tree\n : comparator:('a, 'cmp) Comparator.t\n -> ('a, 'b, 'cmp) tree\n -> ('a, 'b, 'cmp) t\nend\n\nmodule Check_creators\n (T : T3)\n (Tree : T3)\n (Key : T1)\n (Cmp : T1)\n (Options : T3)\n (M : Creators_generic\n with type ('a, 'b, 'c) options := ('a, 'b, 'c) Options.t\n with type ('a, 'b, 'c) t := ('a, 'b, 'c) T.t\n with type ('a, 'b, 'c) tree := ('a, 'b, 'c) Tree.t\n with type 'a key := 'a Key.t\n with type 'a cmp := 'a Cmp.t) =\nstruct end\n\nmodule Check_creators1 (M : Creators1) =\n Check_creators\n (struct\n type ('a, 'b, 'c) t = 'b M.t\n end)\n (struct\n type ('a, 'b, 'c) t = 'b M.tree\n end)\n (struct\n type 'a t = M.key\n end)\n (struct\n type 'a t = M.comparator_witness\n end)\n (Without_comparator)\n (M)\n\nmodule Check_creators2 (M : Creators2) =\n Check_creators\n (struct\n type ('a, 'b, 'c) t = ('a, 'b) M.t\n end)\n (struct\n type ('a, 'b, 'c) t = ('a, 'b) M.tree\n end)\n (struct\n type 'a t = 'a\n end)\n (struct\n type 'a t = M.comparator_witness\n end)\n (Without_comparator)\n (M)\n\nmodule Check_creators3_with_comparator (M : Creators3_with_comparator) =\n Check_creators\n (struct\n type ('a, 'b, 'c) t = ('a, 'b, 'c) M.t\n end)\n (struct\n type ('a, 'b, 'c) t = ('a, 'b, 'c) M.tree\n end)\n (struct\n type 'a t = 'a\n end)\n (struct\n type 'a t = 'a\n end)\n (With_comparator)\n (M)\n\nmodule type Creators_and_accessors_generic = sig\n include Creators_generic\n\n include\n Accessors_generic\n with type ('a, 'b, 'c) t := ('a, 'b, 'c) t\n with type ('a, 'b, 'c) tree := ('a, 'b, 'c) tree\n with type 'a key := 'a key\n with type 'a cmp := 'a cmp\n with type ('a, 'b, 'c) options := ('a, 'b, 'c) options\nend\n\nmodule type Creators_and_accessors1 = sig\n include Creators1\n\n include\n Accessors1\n with type 'a t := 'a t\n with type 'a tree := 'a tree\n with type key := key\n with type comparator_witness := comparator_witness\nend\n\nmodule type Creators_and_accessors2 = sig\n include Creators2\n\n include\n Accessors2\n with type ('a, 'b) t := ('a, 'b) t\n with type ('a, 'b) tree := ('a, 'b) tree\n with type comparator_witness := comparator_witness\nend\n\nmodule type Creators_and_accessors3_with_comparator = sig\n include Creators3_with_comparator\n\n include\n Accessors3_with_comparator\n with type ('a, 'b, 'c) t := ('a, 'b, 'c) t\n with type ('a, 'b, 'c) tree := ('a, 'b, 'c) tree\nend\n\nmodule type S_poly = Creators_and_accessors2\n\nmodule type For_deriving = sig\n type ('a, 'b, 'c) t\n\n module type Sexp_of_m = sig\n type t [@@deriving_inline sexp_of]\n\n val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t\n\n [@@@end]\n end\n\n module type M_of_sexp = sig\n type t [@@deriving_inline of_sexp]\n\n val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t\n\n [@@@end]\n\n include Comparator.S with type t := t\n end\n\n module type Compare_m = sig end\n module type Equal_m = sig end\n module type Hash_fold_m = Hasher.S\n\n val sexp_of_m__t\n : (module Sexp_of_m with type t = 'k)\n -> ('v -> Sexp.t)\n -> ('k, 'v, 'cmp) t\n -> Sexp.t\n\n val m__t_of_sexp\n : (module M_of_sexp with type t = 'k and type comparator_witness = 'cmp)\n -> (Sexp.t -> 'v)\n -> Sexp.t\n -> ('k, 'v, 'cmp) t\n\n val m__t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t\n\n val compare_m__t\n : (module Compare_m)\n -> ('v -> 'v -> int)\n -> ('k, 'v, 'cmp) t\n -> ('k, 'v, 'cmp) t\n -> int\n\n val equal_m__t\n : (module Equal_m)\n -> ('v -> 'v -> bool)\n -> ('k, 'v, 'cmp) t\n -> ('k, 'v, 'cmp) t\n -> bool\n\n val hash_fold_m__t\n : (module Hash_fold_m with type t = 'k)\n -> (Hash.state -> 'v -> Hash.state)\n -> Hash.state\n -> ('k, 'v, _) t\n -> Hash.state\nend\n\nmodule type Map = sig\n (** [Map] is a functional data structure (balanced binary tree) implementing finite maps\n over a totally-ordered domain, called a \"key\". *)\n\n type ('key, +'value, 'cmp) t\n\n module Or_duplicate = Or_duplicate\n module Continue_or_stop = Continue_or_stop\n\n module Finished_or_unfinished : sig\n type t = Finished_or_unfinished.t =\n | Finished\n | Unfinished\n [@@deriving_inline compare, enumerate, equal, sexp_of]\n\n val compare : t -> t -> int\n val all : t list\n val equal : t -> t -> bool\n val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t\n\n [@@@end]\n\n (** Maps [Continue] to [Finished] and [Stop] to [Unfinished]. *)\n val of_continue_or_stop : Continue_or_stop.t -> t\n\n (** Maps [Finished] to [Continue] and [Unfinished] to [Stop]. *)\n val to_continue_or_stop : t -> Continue_or_stop.t\n end\n\n type ('k, 'cmp) comparator =\n (module Comparator.S with type t = 'k and type comparator_witness = 'cmp)\n\n (** Test if the invariants of the internal AVL search tree hold. *)\n val invariants : (_, _, _) t -> bool\n\n (** Returns a first-class module that can be used to build other map/set/etc.\n with the same notion of comparison. *)\n val comparator_s : ('a, _, 'cmp) t -> ('a, 'cmp) comparator\n\n val comparator : ('a, _, 'cmp) t -> ('a, 'cmp) Comparator.t\n\n (** The empty map. *)\n val empty : ('a, 'cmp) comparator -> ('a, 'b, 'cmp) t\n\n (** A map with one (key, data) pair. *)\n val singleton : ('a, 'cmp) comparator -> 'a -> 'b -> ('a, 'b, 'cmp) t\n\n (** Creates a map from an association list with unique keys. *)\n val of_alist\n : ('a, 'cmp) comparator\n -> ('a * 'b) list\n -> [ `Ok of ('a, 'b, 'cmp) t | `Duplicate_key of 'a ]\n\n (** Creates a map from an association list with unique keys, returning an error if\n duplicate ['a] keys are found. *)\n val of_alist_or_error\n : ('a, 'cmp) comparator\n -> ('a * 'b) list\n -> ('a, 'b, 'cmp) t Or_error.t\n\n (** Creates a map from an association list with unique keys, raising an exception if\n duplicate ['a] keys are found. *)\n val of_alist_exn : ('a, 'cmp) comparator -> ('a * 'b) list -> ('a, 'b, 'cmp) t\n\n (** Creates a map from an association list with possibly repeated keys. The values in\n the map for a given key appear in the same order as they did in the association\n list. *)\n val of_alist_multi : ('a, 'cmp) comparator -> ('a * 'b) list -> ('a, 'b list, 'cmp) t\n\n (** Combines an association list into a map, folding together bound values with common\n keys. *)\n val of_alist_fold\n : ('a, 'cmp) comparator\n -> ('a * 'b) list\n -> init:'c\n -> f:('c -> 'b -> 'c)\n -> ('a, 'c, 'cmp) t\n\n (** Combines an association list into a map, reducing together bound values with common\n keys. *)\n val of_alist_reduce\n : ('a, 'cmp) comparator\n -> ('a * 'b) list\n -> f:('b -> 'b -> 'b)\n -> ('a, 'b, 'cmp) t\n\n (** [of_iteri ~iteri] behaves like [of_alist], except that instead of taking a concrete\n data structure, it takes an iteration function. For instance, to convert a string table\n into a map: [of_iteri (module String) ~f:(Hashtbl.iteri table)]. It is faster than\n adding the elements one by one. *)\n val of_iteri\n : ('a, 'cmp) comparator\n -> iteri:(f:(key:'a -> data:'b -> unit) -> unit)\n -> [ `Ok of ('a, 'b, 'cmp) t | `Duplicate_key of 'a ]\n\n (** Creates a map from a sorted array of key-data pairs. The input array must be sorted\n (either in ascending or descending order), as given by the relevant comparator, and\n must not contain duplicate keys. If either of these conditions does not hold,\n an error is returned. *)\n val of_sorted_array\n : ('a, 'cmp) comparator\n -> ('a * 'b) array\n -> ('a, 'b, 'cmp) t Or_error.t\n\n (** Like [of_sorted_array] except that it returns a map with broken invariants when an\n [Error] would have been returned. *)\n val of_sorted_array_unchecked\n : ('a, 'cmp) comparator\n -> ('a * 'b) array\n -> ('a, 'b, 'cmp) t\n\n (** [of_increasing_iterator_unchecked c ~len ~f] behaves like [of_sorted_array_unchecked c\n (Array.init len ~f)], with the additional restriction that a decreasing order is not\n supported. The advantage is not requiring you to allocate an intermediate array. [f]\n will be called with 0, 1, ... [len - 1], in order. *)\n val of_increasing_iterator_unchecked\n : ('a, 'cmp) comparator\n -> len:int\n -> f:(int -> 'a * 'b)\n -> ('a, 'b, 'cmp) t\n\n (** [of_increasing_sequence c seq] behaves like [of_sorted_array c (Sequence.to_array\n seq)], but does not allocate the intermediate array.\n\n The sequence will be folded over once, and the additional time complexity is {e O(n)}.\n *)\n val of_increasing_sequence\n : ('k, 'cmp) comparator\n -> ('k * 'v) Sequence.t\n -> ('k, 'v, 'cmp) t Or_error.t\n\n (** Creates a map from an association sequence with unique keys.\n\n [of_sequence c seq] behaves like [of_alist c (Sequence.to_list seq)] but\n does not allocate the intermediate list.\n\n If your sequence is increasing, use [of_increasing_sequence].\n *)\n val of_sequence\n : ('k, 'cmp) comparator\n -> ('k * 'v) Sequence.t\n -> [ `Ok of ('k, 'v, 'cmp) t | `Duplicate_key of 'k ]\n\n (** Creates a map from an association sequence with unique keys, returning an error if\n duplicate ['a] keys are found.\n\n [of_sequence_or_error c seq] behaves like [of_alist_or_error c (Sequence.to_list seq)]\n but does not allocate the intermediate list.\n *)\n val of_sequence_or_error\n : ('a, 'cmp) comparator\n -> ('a * 'b) Sequence.t\n -> ('a, 'b, 'cmp) t Or_error.t\n\n (** Creates a map from an association sequence with unique keys, raising an exception if\n duplicate ['a] keys are found.\n\n [of_sequence_exn c seq] behaves like [of_alist_exn c (Sequence.to_list seq)] but\n does not allocate the intermediate list.\n *)\n val of_sequence_exn : ('a, 'cmp) comparator -> ('a * 'b) Sequence.t -> ('a, 'b, 'cmp) t\n\n (** Creates a map from an association sequence with possibly repeated keys. The values in\n the map for a given key appear in the same order as they did in the association\n list.\n\n [of_sequence_multi c seq] behaves like [of_alist_exn c (Sequence.to_list seq)] but\n does not allocate the intermediate list.\n *)\n val of_sequence_multi\n : ('a, 'cmp) comparator\n -> ('a * 'b) Sequence.t\n -> ('a, 'b list, 'cmp) t\n\n (** Combines an association sequence into a map, folding together bound values with common\n keys.\n\n [of_sequence_fold c seq ~init ~f] behaves like [of_alist_fold c (Sequence.to_list seq) ~init ~f]\n but does not allocate the intermediate list.\n *)\n val of_sequence_fold\n : ('a, 'cmp) comparator\n -> ('a * 'b) Sequence.t\n -> init:'c\n -> f:('c -> 'b -> 'c)\n -> ('a, 'c, 'cmp) t\n\n (** Combines an association sequence into a map, reducing together bound values with common\n keys.\n\n [of_sequence_reduce c seq ~f] behaves like [of_alist_reduce c (Sequence.to_list seq) ~f]\n but does not allocate the intermediate list. *)\n val of_sequence_reduce\n : ('a, 'cmp) comparator\n -> ('a * 'b) Sequence.t\n -> f:('b -> 'b -> 'b)\n -> ('a, 'b, 'cmp) t\n\n (** Tests whether a map is empty. *)\n val is_empty : (_, _, _) t -> bool\n\n (** [length map] returns the number of elements in [map]. O(1), but [Tree.length] is\n O(n). *)\n val length : (_, _, _) t -> int\n\n (** Returns a new map with the specified new binding; if the key was already bound, its\n previous binding disappears. *)\n val set : ('k, 'v, 'cmp) t -> key:'k -> data:'v -> ('k, 'v, 'cmp) t\n\n (** [add t ~key ~data] adds a new entry to [t] mapping [key] to [data] and returns [`Ok]\n with the new map, or if [key] is already present in [t], returns [`Duplicate]. *)\n val add : ('k, 'v, 'cmp) t -> key:'k -> data:'v -> ('k, 'v, 'cmp) t Or_duplicate.t\n\n val add_exn : ('k, 'v, 'cmp) t -> key:'k -> data:'v -> ('k, 'v, 'cmp) t\n\n (** If [key] is not present then add a singleton list, otherwise, cons data onto the\n head of the existing list. *)\n val add_multi : ('k, 'v list, 'cmp) t -> key:'k -> data:'v -> ('k, 'v list, 'cmp) t\n\n (** If the key is present, then remove its head element; if the result is empty, remove\n the key. *)\n val remove_multi : ('k, 'v list, 'cmp) t -> 'k -> ('k, 'v list, 'cmp) t\n\n (** Returns the value bound to the given key, or the empty list if there is none. *)\n val find_multi : ('k, 'v list, 'cmp) t -> 'k -> 'v list\n\n (** [change t key ~f] returns a new map [m] that is the same as [t] on all keys except\n for [key], and whose value for [key] is defined by [f], i.e., [find m key = f (find\n t key)]. *)\n val change : ('k, 'v, 'cmp) t -> 'k -> f:('v option -> 'v option) -> ('k, 'v, 'cmp) t\n\n (** [update t key ~f] is [change t key ~f:(fun o -> Some (f o))]. *)\n val update : ('k, 'v, 'cmp) t -> 'k -> f:('v option -> 'v) -> ('k, 'v, 'cmp) t\n\n\n (** Returns [Some value] bound to the given key, or [None] if none exists. *)\n val find : ('k, 'v, 'cmp) t -> 'k -> 'v option\n\n (** Returns the value bound to the given key, raising [Caml.Not_found] or [Not_found_s]\n if none exists. *)\n val find_exn : ('k, 'v, 'cmp) t -> 'k -> 'v\n\n (** Returns a new map with any binding for the key in question removed. *)\n val remove : ('k, 'v, 'cmp) t -> 'k -> ('k, 'v, 'cmp) t\n\n (** [mem map key] tests whether [map] contains a binding for [key]. *)\n val mem : ('k, _, 'cmp) t -> 'k -> bool\n\n val iter_keys : ('k, _, _) t -> f:('k -> unit) -> unit\n val iter : (_, 'v, _) t -> f:('v -> unit) -> unit\n val iteri : ('k, 'v, _) t -> f:(key:'k -> data:'v -> unit) -> unit\n\n (** Iterates until the first time [f] returns [Stop]. If [f] returns [Stop], the final\n result is [Unfinished]. Otherwise, the final result is [Finished]. *)\n val iteri_until\n : ('k, 'v, _) t\n -> f:(key:'k -> data:'v -> Continue_or_stop.t)\n -> Finished_or_unfinished.t\n\n (** Iterates two maps side by side. The complexity of this function is O(M + N). If two\n inputs are [[(0, a); (1, a)]] and [[(1, b); (2, b)]], [f] will be called with [[(0,\n `Left a); (1, `Both (a, b)); (2, `Right b)]]. *)\n val iter2\n : ('k, 'v1, 'cmp) t\n -> ('k, 'v2, 'cmp) t\n -> f:(key:'k -> data:[ `Left of 'v1 | `Right of 'v2 | `Both of 'v1 * 'v2 ] -> unit)\n -> unit\n\n (** Returns a new map with bound values replaced by [f] applied to the bound values.*)\n val map : ('k, 'v1, 'cmp) t -> f:('v1 -> 'v2) -> ('k, 'v2, 'cmp) t\n\n (** Like [map], but the passed function takes both [key] and [data] as arguments. *)\n val mapi : ('k, 'v1, 'cmp) t -> f:(key:'k -> data:'v1 -> 'v2) -> ('k, 'v2, 'cmp) t\n\n (** Folds over keys and data in the map in increasing order of [key]. *)\n val fold : ('k, 'v, _) t -> init:'a -> f:(key:'k -> data:'v -> 'a -> 'a) -> 'a\n\n (** Folds over keys and data in the map in decreasing order of [key]. *)\n val fold_right : ('k, 'v, _) t -> init:'a -> f:(key:'k -> data:'v -> 'a -> 'a) -> 'a\n\n (** Folds over two maps side by side, like [iter2]. *)\n val fold2\n : ('k, 'v1, 'cmp) t\n -> ('k, 'v2, 'cmp) t\n -> init:'a\n -> f:(key:'k\n -> data:[ `Left of 'v1 | `Right of 'v2 | `Both of 'v1 * 'v2 ]\n -> 'a\n -> 'a)\n -> 'a\n\n (** [filter], [filteri], [filter_keys], [filter_map], and [filter_mapi] run in O(n * lg\n n) time; they simply accumulate each key & data pair retained by [f] into a new map\n using [add]. *)\n val filter_keys : ('k, 'v, 'cmp) t -> f:('k -> bool) -> ('k, 'v, 'cmp) t\n\n val filter : ('k, 'v, 'cmp) t -> f:('v -> bool) -> ('k, 'v, 'cmp) t\n val filteri : ('k, 'v, 'cmp) t -> f:(key:'k -> data:'v -> bool) -> ('k, 'v, 'cmp) t\n\n (** Returns a new map with bound values filtered by [f] applied to the bound values. *)\n val filter_map : ('k, 'v1, 'cmp) t -> f:('v1 -> 'v2 option) -> ('k, 'v2, 'cmp) t\n\n (** Like [filter_map], but the passed function takes both [key] and [data] as\n arguments. *)\n val filter_mapi\n : ('k, 'v1, 'cmp) t\n -> f:(key:'k -> data:'v1 -> 'v2 option)\n -> ('k, 'v2, 'cmp) t\n\n (** [partition_mapi t ~f] returns two new [t]s, with each key in [t] appearing in\n exactly one of the resulting maps depending on its mapping in [f]. *)\n val partition_mapi\n : ('k, 'v1, 'cmp) t\n -> f:(key:'k -> data:'v1 -> ('v2, 'v3) Either.t)\n -> ('k, 'v2, 'cmp) t * ('k, 'v3, 'cmp) t\n\n (** [partition_map t ~f = partition_mapi t ~f:(fun ~key:_ ~data -> f data)] *)\n val partition_map\n : ('k, 'v1, 'cmp) t\n -> f:('v1 -> ('v2, 'v3) Either.t)\n -> ('k, 'v2, 'cmp) t * ('k, 'v3, 'cmp) t\n\n (**\n {[\n partitioni_tf t ~f\n =\n partition_mapi t ~f:(fun ~key ~data ->\n if f ~key ~data\n then First data\n else Second data)\n ]} *)\n val partitioni_tf\n : ('k, 'v, 'cmp) t\n -> f:(key:'k -> data:'v -> bool)\n -> ('k, 'v, 'cmp) t * ('k, 'v, 'cmp) t\n\n (** [partition_tf t ~f = partitioni_tf t ~f:(fun ~key:_ ~data -> f data)] *)\n val partition_tf\n : ('k, 'v, 'cmp) t\n -> f:('v -> bool)\n -> ('k, 'v, 'cmp) t * ('k, 'v, 'cmp) t\n\n (** Produces [Ok] of a map including all keys if all data is [Ok], or an [Error]\n including all errors otherwise. *)\n val combine_errors : ('k, 'v Or_error.t, 'cmp) t -> ('k, 'v, 'cmp) t Or_error.t\n\n (** Returns a total ordering between maps. The first argument is a total ordering used\n to compare data associated with equal keys in the two maps. *)\n val compare_direct : ('v -> 'v -> int) -> ('k, 'v, 'cmp) t -> ('k, 'v, 'cmp) t -> int\n\n (** Hash function: a building block to use when hashing data structures containing maps in\n them. [hash_fold_direct hash_fold_key] is compatible with [compare_direct] iff\n [hash_fold_key] is compatible with [(comparator m).compare] of the map [m] being\n hashed. *)\n val hash_fold_direct : 'k Hash.folder -> 'v Hash.folder -> ('k, 'v, 'cmp) t Hash.folder\n\n (** [equal cmp m1 m2] tests whether the maps [m1] and [m2] are equal, that is, contain\n the same keys and associate each key with the same value. [cmp] is the equality\n predicate used to compare the values associated with the keys. *)\n val equal : ('v -> 'v -> bool) -> ('k, 'v, 'cmp) t -> ('k, 'v, 'cmp) t -> bool\n\n (** Returns a list of the keys in the given map. *)\n val keys : ('k, _, _) t -> 'k list\n\n (** Returns a list of the data in the given map. *)\n val data : (_, 'v, _) t -> 'v list\n\n (** Creates an association list from the given map. *)\n val to_alist\n : ?key_order:[ `Increasing | `Decreasing ] (** default is [`Increasing] *)\n -> ('k, 'v, _) t\n -> ('k * 'v) list\n\n val validate : name:('k -> string) -> 'v Validate.check -> ('k, 'v, _) t Validate.check\n\n val validatei\n : name:('k -> string)\n -> ('k * 'v) Validate.check\n -> ('k, 'v, _) t Validate.check\n\n (** {2 Additional operations on maps} *)\n\n (** Merges two maps. The runtime is O(length(t1) + length(t2)). You shouldn't use this\n function to merge a list of maps; consider using [merge_skewed] instead. *)\n val merge\n : ('k, 'v1, 'cmp) t\n -> ('k, 'v2, 'cmp) t\n -> f:(key:'k -> [ `Left of 'v1 | `Right of 'v2 | `Both of 'v1 * 'v2 ] -> 'v3 option)\n -> ('k, 'v3, 'cmp) t\n\n (** A special case of [merge], [merge_skewed t1 t2] is a map containing all the\n bindings of [t1] and [t2]. Bindings that appear in both [t1] and [t2] are\n combined into a single value using the [combine] function. In a call\n [combine ~key v1 v2], the value [v1] comes from [t1] and [v2] from [t2].\n\n The runtime of [merge_skewed] is [O(l1 * log(l2))], where [l1] is the length\n of the smaller map and [l2] the length of the larger map. This is likely to\n be faster than [merge] when one of the maps is a lot smaller, or when you\n merge a list of maps. *)\n val merge_skewed\n : ('k, 'v, 'cmp) t\n -> ('k, 'v, 'cmp) t\n -> combine:(key:'k -> 'v -> 'v -> 'v)\n -> ('k, 'v, 'cmp) t\n\n module Symmetric_diff_element : sig\n type ('k, 'v) t = 'k * [ `Left of 'v | `Right of 'v | `Unequal of 'v * 'v ]\n [@@deriving_inline compare, sexp]\n\n val compare\n : ('k -> 'k -> int)\n -> ('v -> 'v -> int)\n -> ('k, 'v) t\n -> ('k, 'v) t\n -> int\n\n include Ppx_sexp_conv_lib.Sexpable.S2 with type ('k, 'v) t := ('k, 'v) t\n\n [@@@end]\n end\n\n (** [symmetric_diff t1 t2 ~data_equal] returns a list of changes between [t1] and [t2].\n It is intended to be efficient in the case where [t1] and [t2] share a large amount\n of structure. The keys in the output sequence will be in sorted order.\n\n It is assumed that [data_equal] is at least as equating as physical equality: that\n [phys_equal x y] implies [data_equal x y]. Otherwise, [symmetric_diff] may behave in\n unexpected ways. For example, with [~data_equal:(fun _ _ -> false)] it is NOT\n necessarily the case the resulting change sequence will contain an element\n [(k, `Unequal _)] for every key [k] shared by both maps.\n\n Warning: Float equality violates this property! [phys_equal Float.nan Float.nan] is\n true, but [Float.(=) Float.nan Float.nan] is false. *)\n val symmetric_diff\n : ('k, 'v, 'cmp) t\n -> ('k, 'v, 'cmp) t\n -> data_equal:('v -> 'v -> bool)\n -> ('k, 'v) Symmetric_diff_element.t Sequence.t\n\n (** [fold_symmetric_diff t1 t2 ~data_equal] folds across an implicit sequence of changes\n between [t1] and [t2], in sorted order by keys. Equivalent to\n [Sequence.fold (symmetric_diff t1 t2 ~data_equal)], and more efficient. *)\n val fold_symmetric_diff\n : ('k, 'v, 'cmp) t\n -> ('k, 'v, 'cmp) t\n -> data_equal:('v -> 'v -> bool)\n -> init:'a\n -> f:('a -> ('k, 'v) Symmetric_diff_element.t -> 'a)\n -> 'a\n\n (** [min_elt map] returns [Some (key, data)] pair corresponding to the minimum key in\n [map], or [None] if empty. *)\n val min_elt : ('k, 'v, _) t -> ('k * 'v) option\n\n val min_elt_exn : ('k, 'v, _) t -> 'k * 'v\n\n (** [max_elt map] returns [Some (key, data)] pair corresponding to the maximum key in\n [map], or [None] if [map] is empty. *)\n val max_elt : ('k, 'v, _) t -> ('k * 'v) option\n\n val max_elt_exn : ('k, 'v, _) t -> 'k * 'v\n\n (** These functions have the same semantics as similar functions in [List]. *)\n\n val for_all : ('k, 'v, _) t -> f:('v -> bool) -> bool\n val for_alli : ('k, 'v, _) t -> f:(key:'k -> data:'v -> bool) -> bool\n val exists : ('k, 'v, _) t -> f:('v -> bool) -> bool\n val existsi : ('k, 'v, _) t -> f:(key:'k -> data:'v -> bool) -> bool\n val count : ('k, 'v, _) t -> f:('v -> bool) -> int\n val counti : ('k, 'v, _) t -> f:(key:'k -> data:'v -> bool) -> int\n\n\n (** [split t key] returns a map of keys strictly less than [key], the mapping of [key] if\n any, and a map of keys strictly greater than [key].\n\n Runtime is O(m + log n), where n is the size of the input map and m is the size of\n the smaller of the two output maps. The O(m) term is due to the need to calculate\n the length of the output maps. *)\n val split\n : ('k, 'v, 'cmp) t\n -> 'k\n -> ('k, 'v, 'cmp) t * ('k * 'v) option * ('k, 'v, 'cmp) t\n\n (** [append ~lower_part ~upper_part] returns [`Ok map] where [map] contains all the\n [(key, value)] pairs from the two input maps if all the keys from [lower_part] are\n less than all the keys from [upper_part]. Otherwise it returns\n [`Overlapping_key_ranges].\n\n Runtime is O(log n) where n is the size of the larger input map. This can be\n significantly faster than [Map.merge] or repeated [Map.add].\n\n {[\n assert (match Map.append ~lower_part ~upper_part with\n | `Ok whole_map ->\n Map.to_alist whole_map\n = List.append (to_alist lower_part) (to_alist upper_part)\n | `Overlapping_key_ranges -> true);\n ]} *)\n val append\n : lower_part:('k, 'v, 'cmp) t\n -> upper_part:('k, 'v, 'cmp) t\n -> [ `Ok of ('k, 'v, 'cmp) t | `Overlapping_key_ranges ]\n\n (** [subrange t ~lower_bound ~upper_bound] returns a map containing all the entries from\n [t] whose keys lie inside the interval indicated by [~lower_bound] and\n [~upper_bound]. If this interval is empty, an empty map is returned.\n\n Runtime is O(m + log n), where n is the size of the input map and m is the size of\n the output map. The O(m) term is due to the need to calculate the length of the\n output map. *)\n val subrange\n : ('k, 'v, 'cmp) t\n -> lower_bound:'k Maybe_bound.t\n -> upper_bound:'k Maybe_bound.t\n -> ('k, 'v, 'cmp) t\n\n (** [fold_range_inclusive t ~min ~max ~init ~f] folds [f] (with initial value [~init])\n over all keys (and their associated values) that are in the range [[min, max]]\n (inclusive). *)\n val fold_range_inclusive\n : ('k, 'v, 'cmp) t\n -> min:'k\n -> max:'k\n -> init:'a\n -> f:(key:'k -> data:'v -> 'a -> 'a)\n -> 'a\n\n (** [range_to_alist t ~min ~max] returns an associative list of the elements whose keys\n lie in [[min, max]] (inclusive), with the smallest key being at the head of the\n list. *)\n val range_to_alist : ('k, 'v, 'cmp) t -> min:'k -> max:'k -> ('k * 'v) list\n\n (** [closest_key t dir k] returns the [(key, value)] pair in [t] with [key] closest to\n [k] that satisfies the given inequality bound.\n\n For example, [closest_key t `Less_than k] would be the pair with the closest key to\n [k] where [key < k].\n\n [to_sequence] can be used to get the same results as [closest_key]. It is less\n efficient for individual lookups but more efficient for finding many elements starting\n at some value. *)\n val closest_key\n : ('k, 'v, 'cmp) t\n -> [ `Greater_or_equal_to | `Greater_than | `Less_or_equal_to | `Less_than ]\n -> 'k\n -> ('k * 'v) option\n\n (** [nth t n] finds the (key, value) pair of rank n (i.e., such that there are exactly n\n keys strictly less than the found key), if one exists. O(log(length t) + n) time. *)\n val nth : ('k, 'v, _) t -> int -> ('k * 'v) option\n\n val nth_exn : ('k, 'v, _) t -> int -> 'k * 'v\n\n (** [rank t k] If [k] is in [t], returns the number of keys strictly less than [k] in\n [t], and [None] otherwise. *)\n val rank : ('k, 'v, 'cmp) t -> 'k -> int option\n\n\n\n (** [to_sequence ?order ?keys_greater_or_equal_to ?keys_less_or_equal_to t]\n gives a sequence of key-value pairs between [keys_less_or_equal_to] and\n [keys_greater_or_equal_to] inclusive, presented in [order]. If\n [keys_greater_or_equal_to > keys_less_or_equal_to], the sequence is\n empty.\n\n When neither [keys_greater_or_equal_to] nor [keys_less_or_equal_to] are\n provided, the cost is O(log n) up front and amortized O(1) to produce\n each element. If either is provided (and is used by the order parameter\n provided), then the the cost is O(n) up front, and amortized O(1) to\n produce each element. *)\n val to_sequence\n : ?order:[ `Increasing_key (** default *) | `Decreasing_key ]\n -> ?keys_greater_or_equal_to:'k\n -> ?keys_less_or_equal_to:'k\n -> ('k, 'v, 'cmp) t\n -> ('k * 'v) Sequence.t\n\n (** [binary_search t ~compare which elt] returns the [(key, value)] pair in [t]\n specified by [compare] and [which], if one exists.\n\n [t] must be sorted in increasing order according to [compare], where [compare] and\n [elt] divide [t] into three (possibly empty) segments:\n\n {v\n | < elt | = elt | > elt |\n v}\n\n [binary_search] returns an element on the boundary of segments as specified by\n [which]. See the diagram below next to the [which] variants.\n\n [binary_search] does not check that [compare] orders [t], and behavior is\n unspecified if [compare] doesn't order [t]. Behavior is also unspecified if\n [compare] mutates [t]. *)\n val binary_search\n : ('k, 'v, 'cmp) t\n -> compare:(key:'k -> data:'v -> 'key -> int)\n -> [ `Last_strictly_less_than (** {v | < elt X | v} *)\n | `Last_less_than_or_equal_to (** {v | <= elt X | v} *)\n | `Last_equal_to (** {v | = elt X | v} *)\n | `First_equal_to (** {v | X = elt | v} *)\n | `First_greater_than_or_equal_to (** {v | X >= elt | v} *)\n | `First_strictly_greater_than (** {v | X > elt | v} *)\n ]\n -> 'key\n -> ('k * 'v) option\n\n (** [binary_search_segmented t ~segment_of which] takes a [segment_of] function that\n divides [t] into two (possibly empty) segments:\n\n {v\n | segment_of elt = `Left | segment_of elt = `Right |\n v}\n\n [binary_search_segmented] returns the [(key, value)] pair on the boundary of the\n segments as specified by [which]: [`Last_on_left] yields the last element of the\n left segment, while [`First_on_right] yields the first element of the right segment.\n It returns [None] if the segment is empty.\n\n [binary_search_segmented] does not check that [segment_of] segments [t] as in the\n diagram, and behavior is unspecified if [segment_of] doesn't segment [t]. Behavior\n is also unspecified if [segment_of] mutates [t]. *)\n val binary_search_segmented\n : ('k, 'v, 'cmp) t\n -> segment_of:(key:'k -> data:'v -> [ `Left | `Right ])\n -> [ `Last_on_left | `First_on_right ]\n -> ('k * 'v) option\n\n (** [M] is meant to be used in combination with OCaml applicative functor types:\n\n {[\n type string_to_int_map = int Map.M(String).t\n ]}\n\n which stands for:\n\n {[\n type string_to_int_map = (String.t, int, String.comparator_witness) Map.t\n ]}\n\n The point is that [int Map.M(String).t] supports deriving, whereas the second syntax\n doesn't (because there is no such thing as, say, [String.sexp_of_comparator_witness]\n -- instead you would want to pass the comparator directly).\n\n In addition, when using [@@deriving], the requirements on the key module are only\n those needed to satisfy what you are trying to derive on the map itself. Say you\n write:\n\n {[\n type t = int Map.M(X).t [@@deriving hash]\n ]}\n\n then this will be well typed exactly if [X] contains at least:\n - a type [t] with no parameters\n - a comparator witness\n - a [hash_fold_t] function with the right type *)\n module M (K : sig\n type t\n type comparator_witness\n end) : sig\n type nonrec 'v t = (K.t, 'v, K.comparator_witness) t\n end\n\n include For_deriving with type ('key, 'value, 'cmp) t := ('key, 'value, 'cmp) t\n\n (** A polymorphic Map. *)\n module Poly :\n S_poly\n with type ('key, +'value) t = ('key, 'value, Comparator.Poly.comparator_witness) t\n\n (** [Using_comparator] is a similar interface as the toplevel of [Map], except the\n functions take a [~comparator:('k, 'cmp) Comparator.t], whereas the functions at the\n toplevel of [Map] take a [('k, 'cmp) comparator]. *)\n module Using_comparator : sig\n type nonrec ('k, +'v, 'cmp) t = ('k, 'v, 'cmp) t [@@deriving_inline sexp_of]\n\n val sexp_of_t\n : ('k -> Ppx_sexp_conv_lib.Sexp.t)\n -> ('v -> Ppx_sexp_conv_lib.Sexp.t)\n -> ('cmp -> Ppx_sexp_conv_lib.Sexp.t)\n -> ('k, 'v, 'cmp) t\n -> Ppx_sexp_conv_lib.Sexp.t\n\n [@@@end]\n\n val t_of_sexp_direct\n : comparator:('k, 'cmp) Comparator.t\n -> (Sexp.t -> 'k)\n -> (Sexp.t -> 'v)\n -> Sexp.t\n -> ('k, 'v, 'cmp) t\n\n module Tree : sig\n type ('k, +'v, 'cmp) t [@@deriving_inline sexp_of]\n\n val sexp_of_t\n : ('k -> Ppx_sexp_conv_lib.Sexp.t)\n -> ('v -> Ppx_sexp_conv_lib.Sexp.t)\n -> ('cmp -> Ppx_sexp_conv_lib.Sexp.t)\n -> ('k, 'v, 'cmp) t\n -> Ppx_sexp_conv_lib.Sexp.t\n\n [@@@end]\n\n val t_of_sexp_direct\n : comparator:('k, 'cmp) Comparator.t\n -> (Sexp.t -> 'k)\n -> (Sexp.t -> 'v)\n -> Sexp.t\n -> ('k, 'v, 'cmp) t\n\n include\n Creators_and_accessors3_with_comparator\n with type ('a, 'b, 'c) t := ('a, 'b, 'c) t\n with type ('a, 'b, 'c) tree := ('a, 'b, 'c) t\n\n val empty_without_value_restriction : (_, _, _) t\n end\n\n include\n Accessors3\n with type ('a, 'b, 'c) t := ('a, 'b, 'c) t\n with type ('a, 'b, 'c) tree := ('a, 'b, 'c) Tree.t\n\n include\n Creators3_with_comparator\n with type ('a, 'b, 'c) t := ('a, 'b, 'c) t\n with type ('a, 'b, 'c) tree := ('a, 'b, 'c) Tree.t\n\n val comparator : ('a, _, 'cmp) t -> ('a, 'cmp) Comparator.t\n\n val hash_fold_direct\n : 'k Hash.folder\n -> 'v Hash.folder\n -> ('k, 'v, 'cmp) t Hash.folder\n\n (** To get around the value restriction, apply the functor and include it. You\n can see an example of this in the [Poly] submodule below. *)\n module Empty_without_value_restriction (K : Comparator.S1) : sig\n val empty : ('a K.t, 'v, K.comparator_witness) t\n end\n end\n\n\n (** {2 Modules and module types for extending [Map]}\n\n For use in extensions of Base, like [Core_kernel]. *)\n\n module With_comparator = With_comparator\n module With_first_class_module = With_first_class_module\n module Without_comparator = Without_comparator\n\n module type For_deriving = For_deriving\n module type S_poly = S_poly\n module type Accessors1 = Accessors1\n module type Accessors2 = Accessors2\n module type Accessors3 = Accessors3\n module type Accessors3_with_comparator = Accessors3_with_comparator\n module type Accessors_generic = Accessors_generic\n module type Creators1 = Creators1\n module type Creators2 = Creators2\n module type Creators3_with_comparator = Creators3_with_comparator\n module type Creators_and_accessors1 = Creators_and_accessors1\n module type Creators_and_accessors2 = Creators_and_accessors2\n\n module type Creators_and_accessors3_with_comparator =\n Creators_and_accessors3_with_comparator\n\n module type Creators_and_accessors_generic = Creators_and_accessors_generic\n module type Creators_generic = Creators_generic\nend\n","open! Import\nopen! Caml.Int64\n\nmodule T = struct\n type t = int64 [@@deriving_inline hash, sexp, sexp_grammar]\n\n let (hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state) =\n hash_fold_int64\n\n and (hash : t -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func = hash_int64 in\n fun x -> func x\n ;;\n\n let t_of_sexp = (int64_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t)\n let sexp_of_t = (sexp_of_int64 : t -> Ppx_sexp_conv_lib.Sexp.t)\n\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group) =\n { implicit_vars = [ \"int64\" ]\n ; ggid = \"\\146e\\023\\249\\235eE\\139c\\132W\\195\\137\\129\\235\\025\"\n ; types = [ \"t\", Implicit_var 0 ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ int64_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"int64.ml.T\"\n }\n in\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"t\", _the_group)\n in\n t_sexp_grammar\n ;;\n\n [@@@end]\n\n let compare = Int64_replace_polymorphic_compare.compare\n let to_string = to_string\n let of_string = of_string\nend\n\ninclude T\ninclude Comparator.Make (T)\n\nlet num_bits = 64\nlet float_lower_bound = Float0.lower_bound_for_int num_bits\nlet float_upper_bound = Float0.upper_bound_for_int num_bits\nlet float_of_bits = float_of_bits\nlet bits_of_float = bits_of_float\nlet shift_right_logical = shift_right_logical\nlet shift_right = shift_right\nlet shift_left = shift_left\nlet bit_not = lognot\nlet bit_xor = logxor\nlet bit_or = logor\nlet bit_and = logand\nlet min_value = min_int\nlet max_value = max_int\nlet abs = abs\nlet pred = pred\nlet succ = succ\nlet pow = Int_math.Private.int64_pow\nlet rem = rem\nlet neg = neg\nlet minus_one = minus_one\nlet one = one\nlet zero = zero\nlet to_float = to_float\nlet of_float_unchecked = Caml.Int64.of_float\n\nlet of_float f =\n if Float_replace_polymorphic_compare.( >= ) f float_lower_bound\n && Float_replace_polymorphic_compare.( <= ) f float_upper_bound\n then Caml.Int64.of_float f\n else\n Printf.invalid_argf\n \"Int64.of_float: argument (%f) is out of range or NaN\"\n (Float0.box f)\n ()\n;;\n\nlet ( ** ) b e = pow b e\n\nexternal bswap64 : t -> t = \"%bswap_int64\"\n\nlet[@inline always] bswap16 x = Caml.Int64.shift_right_logical (bswap64 x) 48\n\nlet[@inline always] bswap32 x =\n (* This is strictly better than coercing to an int32 to perform byteswap. Coercing\n from an int32 will add unnecessary shift operations to sign extend the number\n appropriately.\n *)\n Caml.Int64.shift_right_logical (bswap64 x) 32\n;;\n\nlet[@inline always] bswap48 x = Caml.Int64.shift_right_logical (bswap64 x) 16\n\ninclude Comparable.Validate_with_zero (struct\n include T\n\n let zero = zero\n end)\n\n(* Open replace_polymorphic_compare after including functor instantiations so they do not\n shadow its definitions. This is here so that efficient versions of the comparison\n functions are available within this module. *)\nopen Int64_replace_polymorphic_compare\n\nlet invariant (_ : t) = ()\nlet between t ~low ~high = low <= t && t <= high\nlet clamp_unchecked t ~min ~max = if t < min then min else if t <= max then t else max\n\nlet clamp_exn t ~min ~max =\n assert (min <= max);\n clamp_unchecked t ~min ~max\n;;\n\nlet clamp t ~min ~max =\n if min > max\n then\n Or_error.error_s\n (Sexp.message\n \"clamp requires [min <= max]\"\n [ \"min\", T.sexp_of_t min; \"max\", T.sexp_of_t max ])\n else Ok (clamp_unchecked t ~min ~max)\n;;\n\nlet ( / ) = div\nlet ( * ) = mul\nlet ( - ) = sub\nlet ( + ) = add\nlet ( ~- ) = neg\nlet incr r = r := !r + one\nlet decr r = r := !r - one\nlet of_int64 t = t\nlet of_int64_exn = of_int64\nlet to_int64 t = t\nlet popcount = Popcount.int64_popcount\n\nmodule Conv = Int_conversions\n\nlet of_int = Conv.int_to_int64\nlet of_int_exn = of_int\nlet to_int = Conv.int64_to_int\nlet to_int_exn = Conv.int64_to_int_exn\nlet to_int_trunc = Conv.int64_to_int_trunc\nlet of_int32 = Conv.int32_to_int64\nlet of_int32_exn = of_int32\nlet to_int32 = Conv.int64_to_int32\nlet to_int32_exn = Conv.int64_to_int32_exn\nlet to_int32_trunc = Conv.int64_to_int32_trunc\nlet of_nativeint = Conv.nativeint_to_int64\nlet of_nativeint_exn = of_nativeint\nlet to_nativeint = Conv.int64_to_nativeint\nlet to_nativeint_exn = Conv.int64_to_nativeint_exn\nlet to_nativeint_trunc = Conv.int64_to_nativeint_trunc\n\nmodule Pow2 = struct\n open! Import\n open Int64_replace_polymorphic_compare\n module Sys = Sys0\n\n let raise_s = Error.raise_s\n\n let non_positive_argument () =\n Printf.invalid_argf \"argument must be strictly positive\" ()\n ;;\n\n let ( lor ) = Caml.Int64.logor\n let ( lsr ) = Caml.Int64.shift_right_logical\n let ( land ) = Caml.Int64.logand\n\n (** \"ceiling power of 2\" - Least power of 2 greater than or equal to x. *)\n let ceil_pow2 x =\n if x <= Caml.Int64.zero then non_positive_argument ();\n let x = Caml.Int64.pred x in\n let x = x lor (x lsr 1) in\n let x = x lor (x lsr 2) in\n let x = x lor (x lsr 4) in\n let x = x lor (x lsr 8) in\n let x = x lor (x lsr 16) in\n let x = x lor (x lsr 32) in\n Caml.Int64.succ x\n ;;\n\n (** \"floor power of 2\" - Largest power of 2 less than or equal to x. *)\n let floor_pow2 x =\n if x <= Caml.Int64.zero then non_positive_argument ();\n let x = x lor (x lsr 1) in\n let x = x lor (x lsr 2) in\n let x = x lor (x lsr 4) in\n let x = x lor (x lsr 8) in\n let x = x lor (x lsr 16) in\n let x = x lor (x lsr 32) in\n Caml.Int64.sub x (x lsr 1)\n ;;\n\n let is_pow2 x =\n if x <= Caml.Int64.zero then non_positive_argument ();\n x land Caml.Int64.pred x = Caml.Int64.zero\n ;;\n\n (* C stubs for int clz and ctz to use the CLZ/BSR/CTZ/BSF instruction where possible *)\n external clz\n : (int64[@unboxed])\n -> (int[@untagged])\n = \"Base_int_math_int64_clz\" \"Base_int_math_int64_clz_unboxed\"\n [@@noalloc]\n\n external ctz\n : (int64[@unboxed])\n -> (int[@untagged])\n = \"Base_int_math_int64_ctz\" \"Base_int_math_int64_ctz_unboxed\"\n [@@noalloc]\n\n (** Hacker's Delight Second Edition p106 *)\n let floor_log2 i =\n if i <= Caml.Int64.zero\n then\n raise_s\n (Sexp.message \"[Int64.floor_log2] got invalid input\" [ \"\", sexp_of_int64 i ]);\n num_bits - 1 - clz i\n ;;\n\n (** Hacker's Delight Second Edition p106 *)\n let ceil_log2 i =\n if Poly.( <= ) i Caml.Int64.zero\n then\n raise_s\n (Sexp.message \"[Int64.ceil_log2] got invalid input\" [ \"\", sexp_of_int64 i ]);\n if Caml.Int64.equal i Caml.Int64.one then 0 else num_bits - clz (Caml.Int64.pred i)\n ;;\nend\n\ninclude Pow2\ninclude Conv.Make (T)\n\ninclude Conv.Make_hex (struct\n type t = int64 [@@deriving_inline compare, hash]\n\n let compare = (compare_int64 : t -> t -> int)\n\n let (hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state) =\n hash_fold_int64\n\n and (hash : t -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func = hash_int64 in\n fun x -> func x\n ;;\n\n [@@@end]\n\n let zero = zero\n let neg = ( ~- )\n let ( < ) = ( < )\n let to_string i = Printf.sprintf \"%Lx\" i\n let of_string s = Caml.Scanf.sscanf s \"%Lx\" Fn.id\n let module_name = \"Base.Int64.Hex\"\n end)\n\ninclude Pretty_printer.Register (struct\n type nonrec t = t\n\n let to_string = to_string\n let module_name = \"Base.Int64\"\n end)\n\nmodule Pre_O = struct\n let ( + ) = ( + )\n let ( - ) = ( - )\n let ( * ) = ( * )\n let ( / ) = ( / )\n let ( ~- ) = ( ~- )\n let ( ** ) = ( ** )\n\n include (Int64_replace_polymorphic_compare : Comparisons.Infix with type t := t)\n\n let abs = abs\n let neg = neg\n let zero = zero\n let of_int_exn = of_int_exn\nend\n\nmodule O = struct\n include Pre_O\n\n include Int_math.Make (struct\n type nonrec t = t\n\n include Pre_O\n\n let rem = rem\n let to_float = to_float\n let of_float = of_float\n let of_string = T.of_string\n let to_string = T.to_string\n end)\n\n let ( land ) = bit_and\n let ( lor ) = bit_or\n let ( lxor ) = bit_xor\n let lnot = bit_not\n let ( lsl ) = shift_left\n let ( asr ) = shift_right\n let ( lsr ) = shift_right_logical\nend\n\ninclude O\n\n(* [Int64] and [Int64.O] agree value-wise *)\n\n(* Include type-specific [Replace_polymorphic_compare] at the end, after\n including functor application that could shadow its definitions. This is\n here so that efficient versions of the comparison functions are exported by\n this module. *)\ninclude Int64_replace_polymorphic_compare\n","open! Import\n\nlet invalid_argf = Printf.invalid_argf\n\nmodule T = struct\n type t = bool [@@deriving_inline compare, enumerate, hash, sexp, sexp_grammar]\n\n let compare = (compare_bool : t -> t -> int)\n let all = ([ false; true ] : t list)\n\n let (hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state) =\n hash_fold_bool\n\n and (hash : t -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func = hash_bool in\n fun x -> func x\n ;;\n\n let t_of_sexp = (bool_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t)\n let sexp_of_t = (sexp_of_bool : t -> Ppx_sexp_conv_lib.Sexp.t)\n\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group) =\n { implicit_vars = [ \"bool\" ]\n ; ggid = \"\\146e\\023\\249\\235eE\\139c\\132W\\195\\137\\129\\235\\025\"\n ; types = [ \"t\", Implicit_var 0 ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ bool_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"bool.ml.T\"\n }\n in\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"t\", _the_group)\n in\n t_sexp_grammar\n ;;\n\n [@@@end]\n\n let of_string = function\n | \"true\" -> true\n | \"false\" -> false\n | s -> invalid_argf \"Bool.of_string: expected true or false but got %s\" s ()\n ;;\n\n let to_string = Caml.string_of_bool\nend\n\ninclude T\ninclude Comparator.Make (T)\ninclude Comparable.Validate (T)\n\ninclude Pretty_printer.Register (struct\n type nonrec t = t\n\n let to_string = to_string\n let module_name = \"Base.Bool\"\n end)\n\n(* Open replace_polymorphic_compare after including functor instantiations so they do not\n shadow its definitions. This is here so that efficient versions of the comparison\n functions are available within this module. *)\nopen! Bool_replace_polymorphic_compare\n\nlet invariant (_ : t) = ()\nlet between t ~low ~high = low <= t && t <= high\nlet clamp_unchecked t ~min ~max = if t < min then min else if t <= max then t else max\n\nlet clamp_exn t ~min ~max =\n assert (min <= max);\n clamp_unchecked t ~min ~max\n;;\n\nlet clamp t ~min ~max =\n if min > max\n then\n Or_error.error_s\n (Sexp.message\n \"clamp requires [min <= max]\"\n [ \"min\", T.sexp_of_t min; \"max\", T.sexp_of_t max ])\n else Ok (clamp_unchecked t ~min ~max)\n;;\n\nlet to_int x = bool_to_int x\n\nmodule Non_short_circuiting = struct\n (* We don't expose this, since we don't want to break the invariant mentioned below of\n (to_int true = 1) and (to_int false = 0). *)\n let unsafe_of_int (x : int) : bool = Caml.Obj.magic x\n let ( || ) a b = unsafe_of_int (to_int a lor to_int b)\n let ( && ) a b = unsafe_of_int (to_int a land to_int b)\nend\n\n(* We do this as a direct assert on the theory that it's a cheap thing to test and a\n really core invariant that we never expect to break, and we should be happy for a\n program to fail immediately if this is violated. *)\nlet () = assert (Poly.( = ) (to_int true) 1 && Poly.( = ) (to_int false) 0)\n\n(* Include type-specific [Replace_polymorphic_compare] at the end, after\n including functor application that could shadow its definitions. This is\n here so that efficient versions of the comparison functions are exported by\n this module. *)\ninclude Bool_replace_polymorphic_compare\n","open! Import\nopen! Caml.Int32\n\nmodule T = struct\n type t = int32 [@@deriving_inline hash, sexp, sexp_grammar]\n\n let (hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state) =\n hash_fold_int32\n\n and (hash : t -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func = hash_int32 in\n fun x -> func x\n ;;\n\n let t_of_sexp = (int32_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t)\n let sexp_of_t = (sexp_of_int32 : t -> Ppx_sexp_conv_lib.Sexp.t)\n\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group) =\n { implicit_vars = [ \"int32\" ]\n ; ggid = \"\\146e\\023\\249\\235eE\\139c\\132W\\195\\137\\129\\235\\025\"\n ; types = [ \"t\", Implicit_var 0 ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ int32_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"int32.ml.T\"\n }\n in\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"t\", _the_group)\n in\n t_sexp_grammar\n ;;\n\n [@@@end]\n\n let compare (x : t) y = compare x y\n let to_string = to_string\n let of_string = of_string\nend\n\ninclude T\ninclude Comparator.Make (T)\n\nlet num_bits = 32\nlet float_lower_bound = Float0.lower_bound_for_int num_bits\nlet float_upper_bound = Float0.upper_bound_for_int num_bits\nlet float_of_bits = float_of_bits\nlet bits_of_float = bits_of_float\nlet shift_right_logical = shift_right_logical\nlet shift_right = shift_right\nlet shift_left = shift_left\nlet bit_not = lognot\nlet bit_xor = logxor\nlet bit_or = logor\nlet bit_and = logand\nlet min_value = min_int\nlet max_value = max_int\nlet abs = abs\nlet pred = pred\nlet succ = succ\nlet rem = rem\nlet neg = neg\nlet minus_one = minus_one\nlet one = one\nlet zero = zero\nlet compare = compare\nlet to_float = to_float\nlet of_float_unchecked = of_float\n\nlet of_float f =\n if Float_replace_polymorphic_compare.( >= ) f float_lower_bound\n && Float_replace_polymorphic_compare.( <= ) f float_upper_bound\n then of_float f\n else\n Printf.invalid_argf\n \"Int32.of_float: argument (%f) is out of range or NaN\"\n (Float0.box f)\n ()\n;;\n\ninclude Comparable.Validate_with_zero (struct\n include T\n\n let zero = zero\n end)\n\nmodule Infix_compare = struct\n open Poly\n\n let ( >= ) (x : t) y = x >= y\n let ( <= ) (x : t) y = x <= y\n let ( = ) (x : t) y = x = y\n let ( > ) (x : t) y = x > y\n let ( < ) (x : t) y = x < y\n let ( <> ) (x : t) y = x <> y\nend\n\nmodule Compare = struct\n include Infix_compare\n\n let compare = compare\n let ascending = compare\n let descending x y = compare y x\n let min (x : t) y = if x < y then x else y\n let max (x : t) y = if x > y then x else y\n let equal (x : t) y = x = y\n let between t ~low ~high = low <= t && t <= high\n let clamp_unchecked t ~min ~max = if t < min then min else if t <= max then t else max\n\n let clamp_exn t ~min ~max =\n assert (min <= max);\n clamp_unchecked t ~min ~max\n ;;\n\n let clamp t ~min ~max =\n if min > max\n then\n Or_error.error_s\n (Sexp.message\n \"clamp requires [min <= max]\"\n [ \"min\", T.sexp_of_t min; \"max\", T.sexp_of_t max ])\n else Ok (clamp_unchecked t ~min ~max)\n ;;\nend\n\ninclude Compare\n\nlet invariant (_ : t) = ()\nlet ( / ) = div\nlet ( * ) = mul\nlet ( - ) = sub\nlet ( + ) = add\nlet ( ~- ) = neg\nlet incr r = r := !r + one\nlet decr r = r := !r - one\nlet of_int32 t = t\nlet of_int32_exn = of_int32\nlet to_int32 t = t\nlet to_int32_exn = to_int32\nlet popcount = Popcount.int32_popcount\n\nmodule Conv = Int_conversions\n\nlet of_int = Conv.int_to_int32\nlet of_int_exn = Conv.int_to_int32_exn\nlet of_int_trunc = Conv.int_to_int32_trunc\nlet to_int = Conv.int32_to_int\nlet to_int_exn = Conv.int32_to_int_exn\nlet to_int_trunc = Conv.int32_to_int_trunc\nlet of_int64 = Conv.int64_to_int32\nlet of_int64_exn = Conv.int64_to_int32_exn\nlet of_int64_trunc = Conv.int64_to_int32_trunc\nlet to_int64 = Conv.int32_to_int64\nlet of_nativeint = Conv.nativeint_to_int32\nlet of_nativeint_exn = Conv.nativeint_to_int32_exn\nlet of_nativeint_trunc = Conv.nativeint_to_int32_trunc\nlet to_nativeint = Conv.int32_to_nativeint\nlet to_nativeint_exn = to_nativeint\nlet pow b e = of_int_exn (Int_math.Private.int_pow (to_int_exn b) (to_int_exn e))\nlet ( ** ) b e = pow b e\n\nexternal bswap32 : t -> t = \"%bswap_int32\"\n\nlet bswap16 x = Caml.Int32.shift_right_logical (bswap32 x) 16\n\nmodule Pow2 = struct\n open! Import\n open Int32_replace_polymorphic_compare\n module Sys = Sys0\n\n let raise_s = Error.raise_s\n\n let non_positive_argument () =\n Printf.invalid_argf \"argument must be strictly positive\" ()\n ;;\n\n let ( lor ) = Caml.Int32.logor\n let ( lsr ) = Caml.Int32.shift_right_logical\n let ( land ) = Caml.Int32.logand\n\n (** \"ceiling power of 2\" - Least power of 2 greater than or equal to x. *)\n let ceil_pow2 x =\n if x <= Caml.Int32.zero then non_positive_argument ();\n let x = Caml.Int32.pred x in\n let x = x lor (x lsr 1) in\n let x = x lor (x lsr 2) in\n let x = x lor (x lsr 4) in\n let x = x lor (x lsr 8) in\n let x = x lor (x lsr 16) in\n Caml.Int32.succ x\n ;;\n\n (** \"floor power of 2\" - Largest power of 2 less than or equal to x. *)\n let floor_pow2 x =\n if x <= Caml.Int32.zero then non_positive_argument ();\n let x = x lor (x lsr 1) in\n let x = x lor (x lsr 2) in\n let x = x lor (x lsr 4) in\n let x = x lor (x lsr 8) in\n let x = x lor (x lsr 16) in\n Caml.Int32.sub x (x lsr 1)\n ;;\n\n let is_pow2 x =\n if x <= Caml.Int32.zero then non_positive_argument ();\n x land Caml.Int32.pred x = Caml.Int32.zero\n ;;\n\n (* C stubs for int32 clz and ctz to use the CLZ/BSR/CTZ/BSF instruction where possible *)\n external clz\n : (int32[@unboxed])\n -> (int[@untagged])\n = \"Base_int_math_int32_clz\" \"Base_int_math_int32_clz_unboxed\"\n [@@noalloc]\n\n external ctz\n : (int32[@unboxed])\n -> (int[@untagged])\n = \"Base_int_math_int32_ctz\" \"Base_int_math_int32_ctz_unboxed\"\n [@@noalloc]\n\n (** Hacker's Delight Second Edition p106 *)\n let floor_log2 i =\n if i <= Caml.Int32.zero\n then\n raise_s\n (Sexp.message \"[Int32.floor_log2] got invalid input\" [ \"\", sexp_of_int32 i ]);\n num_bits - 1 - clz i\n ;;\n\n (** Hacker's Delight Second Edition p106 *)\n let ceil_log2 i =\n if i <= Caml.Int32.zero\n then\n raise_s\n (Sexp.message \"[Int32.ceil_log2] got invalid input\" [ \"\", sexp_of_int32 i ]);\n (* The [i = 1] check is needed because clz(0) is undefined *)\n if Caml.Int32.equal i Caml.Int32.one then 0 else num_bits - clz (Caml.Int32.pred i)\n ;;\nend\n\ninclude Pow2\ninclude Conv.Make (T)\n\ninclude Conv.Make_hex (struct\n type t = int32 [@@deriving_inline compare, hash]\n\n let compare = (compare_int32 : t -> t -> int)\n\n let (hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state) =\n hash_fold_int32\n\n and (hash : t -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func = hash_int32 in\n fun x -> func x\n ;;\n\n [@@@end]\n\n let zero = zero\n let neg = ( ~- )\n let ( < ) = ( < )\n let to_string i = Printf.sprintf \"%lx\" i\n let of_string s = Caml.Scanf.sscanf s \"%lx\" Fn.id\n let module_name = \"Base.Int32.Hex\"\n end)\n\ninclude Pretty_printer.Register (struct\n type nonrec t = t\n\n let to_string = to_string\n let module_name = \"Base.Int32\"\n end)\n\nmodule Pre_O = struct\n let ( + ) = ( + )\n let ( - ) = ( - )\n let ( * ) = ( * )\n let ( / ) = ( / )\n let ( ~- ) = ( ~- )\n let ( ** ) = ( ** )\n\n include (Compare : Comparisons.Infix with type t := t)\n\n let abs = abs\n let neg = neg\n let zero = zero\n let of_int_exn = of_int_exn\nend\n\nmodule O = struct\n include Pre_O\n\n include Int_math.Make (struct\n type nonrec t = t\n\n include Pre_O\n\n let rem = rem\n let to_float = to_float\n let of_float = of_float\n let of_string = T.of_string\n let to_string = T.to_string\n end)\n\n let ( land ) = bit_and\n let ( lor ) = bit_or\n let ( lxor ) = bit_xor\n let lnot = bit_not\n let ( lsl ) = shift_left\n let ( asr ) = shift_right\n let ( lsr ) = shift_right_logical\nend\n\ninclude O\n\n(* [Int32] and [Int32.O] agree value-wise *)\n","open! Import\n\nlet raise_s = Error.raise_s\n\nmodule Repr = Int63_emul.Repr\n\n(* In a world where the compiler would understand [@@immediate64] attributes on type\n declarations, this module is how one would produce a [type t] with this attribute. *)\nmodule Immediate64 : sig\n module type Non_immediate = sig\n type t\n end\n\n module type Immediate = sig\n type t [@@immediate]\n end\n\n module Make (Immediate : Immediate) (Non_immediate : Non_immediate) : sig\n type t [@@immediate64]\n\n type 'a repr =\n | Immediate : Immediate.t repr\n | Non_immediate : Non_immediate.t repr\n\n val repr : t repr\n end\nend = struct\n module type Non_immediate = sig\n type t\n end\n\n module type Immediate = sig\n type t [@@immediate]\n end\n\n module Make (Immediate : Immediate) (Non_immediate : Non_immediate) = struct\n type t [@@immediate64]\n\n type 'a repr =\n | Immediate : Immediate.t repr\n | Non_immediate : Non_immediate.t repr\n\n let repr =\n match Word_size.word_size with\n | W64 -> (Caml.Obj.magic Immediate : t repr)\n | W32 -> (Caml.Obj.magic Non_immediate : t repr)\n ;;\n end\nend\n\ninclude Immediate64.Make (Int) (Int63_emul)\n\nmodule Backend = struct\n module type S = sig\n type t\n\n include Int_intf.S with type t := t\n\n val of_int : int -> t\n val to_int : t -> int option\n val to_int_trunc : t -> int\n val of_int32 : int32 -> t\n val to_int32 : t -> Int32.t option\n val to_int32_trunc : t -> Int32.t\n val of_int64 : Int64.t -> t option\n val of_int64_trunc : Int64.t -> t\n val of_nativeint : nativeint -> t option\n val to_nativeint : t -> nativeint option\n val of_nativeint_trunc : nativeint -> t\n val to_nativeint_trunc : t -> nativeint\n val of_float_unchecked : float -> t\n val repr : (t, t) Int63_emul.Repr.t\n val bswap16 : t -> t\n val bswap32 : t -> t\n val bswap48 : t -> t\n end\n with type t := t\n\n module Native = struct\n include Int\n\n let to_int x = Some x\n let to_int_trunc x = x\n\n (* [of_int32_exn] is a safe operation on platforms with 64-bit word sizes. *)\n let of_int32 = of_int32_exn\n let to_nativeint_trunc x = to_nativeint x\n let to_nativeint x = Some (to_nativeint x)\n let repr = Int63_emul.Repr.Int\n let bswap32 t = Int64.to_int_trunc (Int64.bswap32 (Int64.of_int t))\n let bswap48 t = Int64.to_int_trunc (Int64.bswap48 (Int64.of_int t))\n end\n\n let impl : (module S) =\n match repr with\n | Immediate -> (module Native : S)\n | Non_immediate -> (module Int63_emul : S)\n ;;\nend\n\ninclude (val Backend.impl : Backend.S)\n\nmodule Overflow_exn = struct\n let ( + ) t u =\n let sum = t + u in\n if bit_or (bit_xor t u) (bit_xor t (bit_not sum)) < zero\n then sum\n else\n raise_s\n (Sexp.message\n \"( + ) overflow\"\n [ \"t\", sexp_of_t t; \"u\", sexp_of_t u; \"sum\", sexp_of_t sum ])\n ;;\n\n let ( - ) t u =\n let diff = t - u in\n let pos_diff = t > u in\n if t <> u && Bool.( <> ) pos_diff (is_positive diff)\n then\n raise_s\n (Sexp.message\n \"( - ) overflow\"\n [ \"t\", sexp_of_t t; \"u\", sexp_of_t u; \"diff\", sexp_of_t diff ])\n else diff\n ;;\n\n let abs t = if t = min_value then failwith \"abs overflow\" else abs t\n let neg t = if t = min_value then failwith \"neg overflow\" else neg t\nend\n\nlet () = assert (Int.( = ) num_bits 63)\n\nlet random_of_int ?(state = Random.State.default) bound =\n of_int (Random.State.int state (to_int_exn bound))\n;;\n\nlet random_of_int64 ?(state = Random.State.default) bound =\n of_int64_exn (Random.State.int64 state (to_int64 bound))\n;;\n\nlet random =\n match Word_size.word_size with\n | W64 -> random_of_int\n | W32 -> random_of_int64\n;;\n\nlet random_incl_of_int ?(state = Random.State.default) lo hi =\n of_int (Random.State.int_incl state (to_int_exn lo) (to_int_exn hi))\n;;\n\nlet random_incl_of_int64 ?(state = Random.State.default) lo hi =\n of_int64_exn (Random.State.int64_incl state (to_int64 lo) (to_int64 hi))\n;;\n\nlet random_incl =\n match Word_size.word_size with\n | W64 -> random_incl_of_int\n | W32 -> random_incl_of_int64\n;;\n\nlet floor_log2 t =\n match Word_size.word_size with\n | W64 -> t |> to_int_exn |> Int.floor_log2\n | W32 ->\n if t <= zero\n then raise_s (Sexp.message \"[Int.floor_log2] got invalid input\" [ \"\", sexp_of_t t ]);\n let floor_log2 = ref (Int.( - ) num_bits 2) in\n while equal zero (bit_and t (shift_left one !floor_log2)) do\n floor_log2 := Int.( - ) !floor_log2 1\n done;\n !floor_log2\n;;\n\nmodule Private = struct\n module Repr = Repr\n\n let repr = repr\n\n module Emul = Int63_emul\nend\n","open! Import\ninclude Hashtbl_intf\n\nmodule type Key = Key.S\n\nlet with_return = With_return.with_return\nlet hash_param = Hashable.hash_param\nlet hash = Hashable.hash\nlet raise_s = Error.raise_s\n\ntype ('k, 'v) t =\n { mutable table : ('k, 'v) Avltree.t array\n ; mutable length : int\n (* [recently_added] is the reference passed to [Avltree.add]. We put it in the hash\n table to avoid allocating it at every [set]. *)\n ; recently_added : bool ref\n ; growth_allowed : bool\n ; hashable : 'k Hashable.t\n ; mutable mutation_allowed : bool (* Set during all iteration operations *)\n }\n\ntype 'a key = 'a\n\nlet sexp_of_key t = t.hashable.Hashable.sexp_of_t\nlet compare_key t = t.hashable.Hashable.compare\n\nlet ensure_mutation_allowed t =\n if not t.mutation_allowed\n then failwith \"Hashtbl: mutation not allowed during iteration\"\n;;\n\nlet without_mutating t f =\n if t.mutation_allowed\n then (\n t.mutation_allowed <- false;\n match f () with\n | x ->\n t.mutation_allowed <- true;\n x\n | exception exn ->\n t.mutation_allowed <- true;\n raise exn)\n else f ()\n;;\n\n(** Internally use a maximum size that is a power of 2. Reverses the above to find the\n floor power of 2 below the system max array length *)\nlet max_table_length = Int.floor_pow2 Array.max_length\n\n(* The default size is chosen to be 0 (as opposed to 128 as it was before) because:\n - 128 can create substantial memory overhead (x10) when creating many tables, most\n of which are not big (say, if you have a hashtbl of hashtbl). And memory overhead is\n not that easy to profile.\n - if a hashtbl is going to grow, it's not clear why 128 is markedly better than other\n sizes (if you going to stick 1000 elements, you're going to grow the hashtable once\n or twice anyway)\n - in other languages (like rust, python, and apparently go), the default is also a\n small size. *)\nlet create ?(growth_allowed = true) ?(size = 0) ~hashable () =\n let size = Int.min (Int.max 1 size) max_table_length in\n let size = Int.ceil_pow2 size in\n { table = Array.create ~len:size Avltree.empty\n ; length = 0\n ; growth_allowed\n ; recently_added = ref false\n ; hashable\n ; mutation_allowed = true\n }\n;;\n\n(** Supplemental hash. This may not be necessary, it is intended as a defense against poor\n hash functions, for which the power of 2 sized table will be especially sensitive.\n With some testing we may choose to add it, but this table is designed to be robust to\n collisions, and in most of my testing this degrades performance. *)\nlet _supplemental_hash h =\n let h = h lxor ((h lsr 20) lxor (h lsr 12)) in\n h lxor (h lsr 7) lxor (h lsr 4)\n;;\n\nlet slot t key =\n let hash = t.hashable.Hashable.hash key in\n (* this is always non-negative because we do [land] with non-negative number *)\n hash land (Array.length t.table - 1)\n;;\n\nlet add_worker t ~replace ~key ~data =\n let i = slot t key in\n let root = t.table.(i) in\n let added = t.recently_added in\n added := false;\n let new_root =\n (* The avl tree might replace the value [replace=true] or do nothing [replace=false]\n to the entry, in that case the table did not get bigger, so we should not\n increment length, we pass in the bool ref t.added so that it can tell us whether\n it added or replaced. We do it this way to avoid extra allocation. Since the bool\n is an immediate it does not go through the write barrier. *)\n Avltree.add ~replace root ~compare:(compare_key t) ~added ~key ~data\n in\n if !added then t.length <- t.length + 1;\n (* This little optimization saves a caml_modify when the tree\n hasn't been rebalanced. *)\n if not (phys_equal new_root root) then t.table.(i) <- new_root\n;;\n\nlet maybe_resize_table t =\n let len = Array.length t.table in\n let should_grow = t.length > len in\n if should_grow && t.growth_allowed\n then (\n let new_array_length = Int.min (len * 2) max_table_length in\n if new_array_length > len\n then (\n let new_table = Array.create ~len:new_array_length Avltree.empty in\n let old_table = t.table in\n t.table <- new_table;\n t.length <- 0;\n let f ~key ~data = add_worker ~replace:true t ~key ~data in\n for i = 0 to Array.length old_table - 1 do\n Avltree.iter old_table.(i) ~f\n done))\n;;\n\nlet set t ~key ~data =\n ensure_mutation_allowed t;\n add_worker ~replace:true t ~key ~data;\n maybe_resize_table t\n;;\n\nlet add t ~key ~data =\n ensure_mutation_allowed t;\n add_worker ~replace:false t ~key ~data;\n if !(t.recently_added)\n then (\n maybe_resize_table t;\n `Ok)\n else `Duplicate\n;;\n\nlet add_exn t ~key ~data =\n match add t ~key ~data with\n | `Ok -> ()\n | `Duplicate ->\n let sexp_of_key = sexp_of_key t in\n let error = Error.create \"Hashtbl.add_exn got key already present\" key sexp_of_key in\n Error.raise error\n;;\n\nlet clear t =\n ensure_mutation_allowed t;\n for i = 0 to Array.length t.table - 1 do\n t.table.(i) <- Avltree.empty\n done;\n t.length <- 0\n;;\n\nlet find_and_call t key ~if_found ~if_not_found =\n (* with a good hash function these first two cases will be the overwhelming majority,\n and Avltree.find is recursive, so it can't be inlined, so doing this avoids a\n function call in most cases. *)\n match t.table.(slot t key) with\n | Avltree.Empty -> if_not_found key\n | Avltree.Leaf { key = k; value = v } ->\n if compare_key t k key = 0 then if_found v else if_not_found key\n | tree ->\n Avltree.find_and_call tree ~compare:(compare_key t) key ~if_found ~if_not_found\n;;\n\nlet find_and_call1 t key ~a ~if_found ~if_not_found =\n match t.table.(slot t key) with\n | Avltree.Empty -> if_not_found key a\n | Avltree.Leaf { key = k; value = v } ->\n if compare_key t k key = 0 then if_found v a else if_not_found key a\n | tree ->\n Avltree.find_and_call1 tree ~compare:(compare_key t) key ~a ~if_found ~if_not_found\n;;\n\nlet find_and_call2 t key ~a ~b ~if_found ~if_not_found =\n match t.table.(slot t key) with\n | Avltree.Empty -> if_not_found key a b\n | Avltree.Leaf { key = k; value = v } ->\n if compare_key t k key = 0 then if_found v a b else if_not_found key a b\n | tree ->\n Avltree.find_and_call2\n tree\n ~compare:(compare_key t)\n key\n ~a\n ~b\n ~if_found\n ~if_not_found\n;;\n\nlet findi_and_call t key ~if_found ~if_not_found =\n (* with a good hash function these first two cases will be the overwhelming majority,\n and Avltree.find is recursive, so it can't be inlined, so doing this avoids a\n function call in most cases. *)\n match t.table.(slot t key) with\n | Avltree.Empty -> if_not_found key\n | Avltree.Leaf { key = k; value = v } ->\n if compare_key t k key = 0 then if_found ~key:k ~data:v else if_not_found key\n | tree ->\n Avltree.findi_and_call tree ~compare:(compare_key t) key ~if_found ~if_not_found\n;;\n\nlet findi_and_call1 t key ~a ~if_found ~if_not_found =\n match t.table.(slot t key) with\n | Avltree.Empty -> if_not_found key a\n | Avltree.Leaf { key = k; value = v } ->\n if compare_key t k key = 0 then if_found ~key:k ~data:v a else if_not_found key a\n | tree ->\n Avltree.findi_and_call1 tree ~compare:(compare_key t) key ~a ~if_found ~if_not_found\n;;\n\nlet findi_and_call2 t key ~a ~b ~if_found ~if_not_found =\n match t.table.(slot t key) with\n | Avltree.Empty -> if_not_found key a b\n | Avltree.Leaf { key = k; value = v } ->\n if compare_key t k key = 0 then if_found ~key:k ~data:v a b else if_not_found key a b\n | tree ->\n Avltree.findi_and_call2\n tree\n ~compare:(compare_key t)\n key\n ~a\n ~b\n ~if_found\n ~if_not_found\n;;\n\nlet find =\n let if_found v = Some v in\n let if_not_found _ = None in\n fun t key -> find_and_call t key ~if_found ~if_not_found\n;;\n\nlet mem t key =\n match t.table.(slot t key) with\n | Avltree.Empty -> false\n | Avltree.Leaf { key = k; value = _ } -> compare_key t k key = 0\n | tree -> Avltree.mem tree ~compare:(compare_key t) key\n;;\n\nlet remove t key =\n ensure_mutation_allowed t;\n let i = slot t key in\n let root = t.table.(i) in\n let added_or_removed = t.recently_added in\n added_or_removed := false;\n let new_root =\n Avltree.remove root ~removed:added_or_removed ~compare:(compare_key t) key\n in\n if not (phys_equal root new_root) then t.table.(i) <- new_root;\n if !added_or_removed then t.length <- t.length - 1\n;;\n\nlet length t = t.length\nlet is_empty t = length t = 0\n\nlet fold t ~init ~f =\n if length t = 0\n then init\n else (\n let n = Array.length t.table in\n let acc = ref init in\n let m = t.mutation_allowed in\n match\n t.mutation_allowed <- false;\n for i = 0 to n - 1 do\n match Array.unsafe_get t.table i with\n | Avltree.Empty -> ()\n | Avltree.Leaf { key; value = data } -> acc := f ~key ~data !acc\n | bucket -> acc := Avltree.fold bucket ~init:!acc ~f\n done\n with\n | () ->\n t.mutation_allowed <- m;\n !acc\n | exception exn ->\n t.mutation_allowed <- m;\n raise exn)\n;;\n\nlet iteri t ~f =\n if t.length = 0\n then ()\n else (\n let n = Array.length t.table in\n let m = t.mutation_allowed in\n match\n t.mutation_allowed <- false;\n for i = 0 to n - 1 do\n match Array.unsafe_get t.table i with\n | Avltree.Empty -> ()\n | Avltree.Leaf { key; value = data } -> f ~key ~data\n | bucket -> Avltree.iter bucket ~f\n done\n with\n | () -> t.mutation_allowed <- m\n | exception exn ->\n t.mutation_allowed <- m;\n raise exn)\n;;\n\nlet iter t ~f = iteri t ~f:(fun ~key:_ ~data -> f data)\nlet iter_keys t ~f = iteri t ~f:(fun ~key ~data:_ -> f key)\n\nlet rec choose_nonempty table i =\n let avltree = table.(i) in\n if Avltree.is_empty avltree\n then choose_nonempty table (i + 1)\n else Avltree.choose_exn avltree\n;;\n\nlet choose_exn t =\n if t.length = 0 then raise_s (Sexp.message \"[Hashtbl.choose_exn] of empty hashtbl\" []);\n choose_nonempty t.table 0\n;;\n\nlet choose t = if is_empty t then None else Some (choose_nonempty t.table 0)\n\nlet invariant invariant_key invariant_data t =\n for i = 0 to Array.length t.table - 1 do\n Avltree.invariant t.table.(i) ~compare:(compare_key t)\n done;\n let real_len =\n fold t ~init:0 ~f:(fun ~key ~data i ->\n invariant_key key;\n invariant_data data;\n i + 1)\n in\n assert (real_len = t.length)\n;;\n\nlet find_exn =\n let if_found v _ = v in\n let if_not_found k t =\n raise\n (Not_found_s (List [ Atom \"Hashtbl.find_exn: not found\"; t.hashable.sexp_of_t k ]))\n in\n let find_exn t key = find_and_call1 t key ~a:t ~if_found ~if_not_found in\n (* named to preserve symbol in compiled binary *)\n find_exn\n;;\n\nlet existsi t ~f =\n with_return (fun r ->\n iteri t ~f:(fun ~key ~data -> if f ~key ~data then r.return true);\n false)\n;;\n\nlet exists t ~f = existsi t ~f:(fun ~key:_ ~data -> f data)\nlet for_alli t ~f = not (existsi t ~f:(fun ~key ~data -> not (f ~key ~data)))\nlet for_all t ~f = not (existsi t ~f:(fun ~key:_ ~data -> not (f data)))\n\nlet counti t ~f =\n fold t ~init:0 ~f:(fun ~key ~data acc -> if f ~key ~data then acc + 1 else acc)\n;;\n\nlet count t ~f =\n fold t ~init:0 ~f:(fun ~key:_ ~data acc -> if f data then acc + 1 else acc)\n;;\n\nlet mapi t ~f =\n let new_t =\n create ~growth_allowed:t.growth_allowed ~hashable:t.hashable ~size:t.length ()\n in\n iteri t ~f:(fun ~key ~data -> set new_t ~key ~data:(f ~key ~data));\n new_t\n;;\n\nlet map t ~f = mapi t ~f:(fun ~key:_ ~data -> f data)\nlet copy t = map t ~f:Fn.id\n\nlet filter_mapi t ~f =\n let new_t =\n create ~growth_allowed:t.growth_allowed ~hashable:t.hashable ~size:t.length ()\n in\n iteri t ~f:(fun ~key ~data ->\n match f ~key ~data with\n | Some new_data -> set new_t ~key ~data:new_data\n | None -> ());\n new_t\n;;\n\nlet filter_map t ~f = filter_mapi t ~f:(fun ~key:_ ~data -> f data)\n\nlet filteri t ~f =\n filter_mapi t ~f:(fun ~key ~data -> if f ~key ~data then Some data else None)\n;;\n\nlet filter t ~f = filteri t ~f:(fun ~key:_ ~data -> f data)\nlet filter_keys t ~f = filteri t ~f:(fun ~key ~data:_ -> f key)\n\nlet partition_mapi t ~f =\n let t0 =\n create ~growth_allowed:t.growth_allowed ~hashable:t.hashable ~size:t.length ()\n in\n let t1 =\n create ~growth_allowed:t.growth_allowed ~hashable:t.hashable ~size:t.length ()\n in\n iteri t ~f:(fun ~key ~data ->\n match (f ~key ~data : _ Either.t) with\n | First new_data -> set t0 ~key ~data:new_data\n | Second new_data -> set t1 ~key ~data:new_data);\n t0, t1\n;;\n\nlet partition_map t ~f = partition_mapi t ~f:(fun ~key:_ ~data -> f data)\n\nlet partitioni_tf t ~f =\n partition_mapi t ~f:(fun ~key ~data ->\n if f ~key ~data then First data else Second data)\n;;\n\nlet partition_tf t ~f = partitioni_tf t ~f:(fun ~key:_ ~data -> f data)\n\nlet find_or_add t id ~default =\n match find t id with\n | Some x -> x\n | None ->\n let default = default () in\n set t ~key:id ~data:default;\n default\n;;\n\nlet findi_or_add t id ~default =\n match find t id with\n | Some x -> x\n | None ->\n let default = default id in\n set t ~key:id ~data:default;\n default\n;;\n\n(* Some hashtbl implementations may be able to perform this more efficiently than two\n separate lookups *)\nlet find_and_remove t id =\n let result = find t id in\n if Option.is_some result then remove t id;\n result\n;;\n\n\nlet change t id ~f =\n match f (find t id) with\n | None -> remove t id\n | Some data -> set t ~key:id ~data\n;;\n\nlet update t id ~f = set t ~key:id ~data:(f (find t id))\n\nlet incr_by ~remove_if_zero t key by =\n if remove_if_zero\n then\n change t key ~f:(fun opt ->\n match by + Option.value opt ~default:0 with\n | 0 -> None\n | n -> Some n)\n else\n update t key ~f:(function\n | None -> by\n | Some i -> by + i)\n;;\n\nlet incr ?(by = 1) ?(remove_if_zero = false) t key = incr_by ~remove_if_zero t key by\nlet decr ?(by = 1) ?(remove_if_zero = false) t key = incr_by ~remove_if_zero t key (-by)\n\nlet add_multi t ~key ~data =\n update t key ~f:(function\n | None -> [ data ]\n | Some l -> data :: l)\n;;\n\nlet remove_multi t key =\n match find t key with\n | None -> ()\n | Some [] | Some [ _ ] -> remove t key\n | Some (_ :: tl) -> set t ~key ~data:tl\n;;\n\nlet find_multi t key =\n match find t key with\n | None -> []\n | Some l -> l\n;;\n\nlet create_mapped ?growth_allowed ?size ~hashable ~get_key ~get_data rows =\n let size =\n match size with\n | Some s -> s\n | None -> List.length rows\n in\n let res = create ?growth_allowed ~hashable ~size () in\n let dupes = ref [] in\n List.iter rows ~f:(fun r ->\n let key = get_key r in\n let data = get_data r in\n if mem res key then dupes := key :: !dupes else set res ~key ~data);\n match !dupes with\n | [] -> `Ok res\n | keys -> `Duplicate_keys (List.dedup_and_sort ~compare:hashable.Hashable.compare keys)\n;;\n\nlet create_mapped_multi ?growth_allowed ?size ~hashable ~get_key ~get_data rows =\n let size =\n match size with\n | Some s -> s\n | None -> List.length rows\n in\n let res = create ?growth_allowed ~size ~hashable () in\n List.iter rows ~f:(fun r ->\n let key = get_key r in\n let data = get_data r in\n add_multi res ~key ~data);\n res\n;;\n\nlet of_alist ?growth_allowed ?size ~hashable lst =\n match create_mapped ?growth_allowed ?size ~hashable ~get_key:fst ~get_data:snd lst with\n | `Ok t -> `Ok t\n | `Duplicate_keys k -> `Duplicate_key (List.hd_exn k)\n;;\n\nlet of_alist_report_all_dups ?growth_allowed ?size ~hashable lst =\n create_mapped ?growth_allowed ?size ~hashable ~get_key:fst ~get_data:snd lst\n;;\n\nlet of_alist_or_error ?growth_allowed ?size ~hashable lst =\n match of_alist ?growth_allowed ?size ~hashable lst with\n | `Ok v -> Result.Ok v\n | `Duplicate_key key ->\n let sexp_of_key = hashable.Hashable.sexp_of_t in\n Or_error.error \"Hashtbl.of_alist_exn: duplicate key\" key sexp_of_key\n;;\n\nlet of_alist_exn ?growth_allowed ?size ~hashable lst =\n match of_alist_or_error ?growth_allowed ?size ~hashable lst with\n | Result.Ok v -> v\n | Result.Error e -> Error.raise e\n;;\n\nlet of_alist_multi ?growth_allowed ?size ~hashable lst =\n create_mapped_multi ?growth_allowed ?size ~hashable ~get_key:fst ~get_data:snd lst\n;;\n\nlet to_alist t = fold ~f:(fun ~key ~data list -> (key, data) :: list) ~init:[] t\n\nlet sexp_of_t sexp_of_key sexp_of_data t =\n t\n |> to_alist\n |> List.sort ~compare:(fun (k1, _) (k2, _) -> t.hashable.compare k1 k2)\n |> sexp_of_list (sexp_of_pair sexp_of_key sexp_of_data)\n;;\n\nlet t_of_sexp ~hashable k_of_sexp d_of_sexp sexp =\n let alist = list_of_sexp (pair_of_sexp k_of_sexp d_of_sexp) sexp in\n match of_alist ~hashable alist ~size:(List.length alist) with\n | `Ok v -> v\n | `Duplicate_key k ->\n (* find the sexp of a duplicate key, so the error is narrowed to a key and not\n the whole map *)\n let alist_sexps = list_of_sexp (pair_of_sexp Fn.id Fn.id) sexp in\n let found_first_k = ref false in\n List.iter2_exn alist alist_sexps ~f:(fun (k2, _) (k2_sexp, _) ->\n if hashable.compare k k2 = 0\n then\n if !found_first_k\n then of_sexp_error \"Hashtbl.t_of_sexp: duplicate key\" k2_sexp\n else found_first_k := true);\n assert false\n;;\n\nlet validate ~name f t = Validate.alist ~name f (to_alist t)\nlet keys t = fold t ~init:[] ~f:(fun ~key ~data:_ acc -> key :: acc)\nlet data t = fold ~f:(fun ~key:_ ~data list -> data :: list) ~init:[] t\n\nlet add_to_groups groups ~get_key ~get_data ~combine ~rows =\n List.iter rows ~f:(fun row ->\n let key = get_key row in\n let data = get_data row in\n let data =\n match find groups key with\n | None -> data\n | Some old -> combine old data\n in\n set groups ~key ~data)\n;;\n\nlet group ?growth_allowed ?size ~hashable ~get_key ~get_data ~combine rows =\n let res = create ?growth_allowed ?size ~hashable () in\n add_to_groups res ~get_key ~get_data ~combine ~rows;\n res\n;;\n\nlet create_with_key ?growth_allowed ?size ~hashable ~get_key rows =\n create_mapped ?growth_allowed ?size ~hashable ~get_key ~get_data:Fn.id rows\n;;\n\nlet create_with_key_or_error ?growth_allowed ?size ~hashable ~get_key rows =\n match create_with_key ?growth_allowed ?size ~hashable ~get_key rows with\n | `Ok t -> Result.Ok t\n | `Duplicate_keys keys ->\n let sexp_of_key = hashable.Hashable.sexp_of_t in\n Or_error.error_s\n (Sexp.message\n \"Hashtbl.create_with_key: duplicate keys\"\n [ \"keys\", sexp_of_list sexp_of_key keys ])\n;;\n\nlet create_with_key_exn ?growth_allowed ?size ~hashable ~get_key rows =\n Or_error.ok_exn\n (create_with_key_or_error ?growth_allowed ?size ~hashable ~get_key rows)\n;;\n\nlet merge =\n let maybe_set t ~key ~f d =\n match f ~key d with\n | None -> ()\n | Some v -> set t ~key ~data:v\n in\n fun t_left t_right ~f ->\n if not (Hashable.equal t_left.hashable t_right.hashable)\n then invalid_arg \"Hashtbl.merge: different 'hashable' values\";\n let new_t =\n create\n ~growth_allowed:t_left.growth_allowed\n ~hashable:t_left.hashable\n ~size:t_left.length\n ()\n in\n without_mutating t_left (fun () ->\n without_mutating t_right (fun () ->\n iteri t_left ~f:(fun ~key ~data:left ->\n match find t_right key with\n | None -> maybe_set new_t ~key ~f (`Left left)\n | Some right -> maybe_set new_t ~key ~f (`Both (left, right)));\n iteri t_right ~f:(fun ~key ~data:right ->\n match find t_left key with\n | None -> maybe_set new_t ~key ~f (`Right right)\n | Some _ -> ()\n (* already done above *))));\n new_t\n;;\n\nlet merge_into ~src ~dst ~f =\n iteri src ~f:(fun ~key ~data ->\n let dst_data = find dst key in\n let action = without_mutating dst (fun () -> f ~key data dst_data) in\n match (action : _ Merge_into_action.t) with\n | Remove -> remove dst key\n | Set_to data ->\n (match dst_data with\n | None -> set dst ~key ~data\n | Some dst_data -> if not (phys_equal dst_data data) then set dst ~key ~data))\n;;\n\nlet filteri_inplace t ~f =\n let to_remove =\n fold t ~init:[] ~f:(fun ~key ~data ac -> if f ~key ~data then ac else key :: ac)\n in\n List.iter to_remove ~f:(fun key -> remove t key)\n;;\n\nlet filter_inplace t ~f = filteri_inplace t ~f:(fun ~key:_ ~data -> f data)\nlet filter_keys_inplace t ~f = filteri_inplace t ~f:(fun ~key ~data:_ -> f key)\n\nlet filter_mapi_inplace t ~f =\n let map_results =\n fold t ~init:[] ~f:(fun ~key ~data ac -> (key, f ~key ~data) :: ac)\n in\n List.iter map_results ~f:(fun (key, result) ->\n match result with\n | None -> remove t key\n | Some data -> set t ~key ~data)\n;;\n\nlet filter_map_inplace t ~f = filter_mapi_inplace t ~f:(fun ~key:_ ~data -> f data)\n\nlet mapi_inplace t ~f =\n ensure_mutation_allowed t;\n without_mutating t (fun () -> Array.iter t.table ~f:(Avltree.mapi_inplace ~f))\n;;\n\nlet map_inplace t ~f = mapi_inplace t ~f:(fun ~key:_ ~data -> f data)\n\nlet equal equal t t' =\n length t = length t'\n && with_return (fun r ->\n without_mutating t' (fun () ->\n iteri t ~f:(fun ~key ~data ->\n match find t' key with\n | None -> r.return false\n | Some data' -> if not (equal data data') then r.return false));\n true)\n;;\n\nlet similar = equal\n\nmodule Accessors = struct\n let invariant = invariant\n let choose = choose\n let choose_exn = choose_exn\n let clear = clear\n let copy = copy\n let remove = remove\n let set = set\n let add = add\n let add_exn = add_exn\n let change = change\n let update = update\n let add_multi = add_multi\n let remove_multi = remove_multi\n let find_multi = find_multi\n let mem = mem\n let iter_keys = iter_keys\n let iter = iter\n let iteri = iteri\n let exists = exists\n let existsi = existsi\n let for_all = for_all\n let for_alli = for_alli\n let count = count\n let counti = counti\n let fold = fold\n let length = length\n let is_empty = is_empty\n let map = map\n let mapi = mapi\n let filter_map = filter_map\n let filter_mapi = filter_mapi\n let filter_keys = filter_keys\n let filter = filter\n let filteri = filteri\n let partition_map = partition_map\n let partition_mapi = partition_mapi\n let partition_tf = partition_tf\n let partitioni_tf = partitioni_tf\n let find_or_add = find_or_add\n let findi_or_add = findi_or_add\n let find = find\n let find_exn = find_exn\n let find_and_call = find_and_call\n let find_and_call1 = find_and_call1\n let find_and_call2 = find_and_call2\n let findi_and_call = findi_and_call\n let findi_and_call1 = findi_and_call1\n let findi_and_call2 = findi_and_call2\n let find_and_remove = find_and_remove\n let to_alist = to_alist\n let validate = validate\n let merge = merge\n let merge_into = merge_into\n let keys = keys\n let data = data\n let filter_keys_inplace = filter_keys_inplace\n let filter_inplace = filter_inplace\n let filteri_inplace = filteri_inplace\n let map_inplace = map_inplace\n let mapi_inplace = mapi_inplace\n let filter_map_inplace = filter_map_inplace\n let filter_mapi_inplace = filter_mapi_inplace\n let equal = equal\n let similar = similar\n let incr = incr\n let decr = decr\n let sexp_of_key = sexp_of_key\nend\n\nmodule Creators (Key : sig\n type 'a t\n\n val hashable : 'a t Hashable.t\n end) : sig\n type ('a, 'b) t_ = ('a Key.t, 'b) t\n\n val t_of_sexp : (Sexp.t -> 'a Key.t) -> (Sexp.t -> 'b) -> Sexp.t -> ('a, 'b) t_\n\n include\n Creators_generic\n with type ('a, 'b) t := ('a, 'b) t_\n with type 'a key := 'a Key.t\n with type ('key, 'data, 'a) create_options :=\n ('key, 'data, 'a) create_options_without_first_class_module\nend = struct\n let hashable = Key.hashable\n\n type ('a, 'b) t_ = ('a Key.t, 'b) t\n\n let create ?growth_allowed ?size () = create ?growth_allowed ?size ~hashable ()\n let of_alist ?growth_allowed ?size l = of_alist ?growth_allowed ~hashable ?size l\n\n let of_alist_report_all_dups ?growth_allowed ?size l =\n of_alist_report_all_dups ?growth_allowed ~hashable ?size l\n ;;\n\n let of_alist_or_error ?growth_allowed ?size l =\n of_alist_or_error ?growth_allowed ~hashable ?size l\n ;;\n\n let of_alist_exn ?growth_allowed ?size l =\n of_alist_exn ?growth_allowed ~hashable ?size l\n ;;\n\n let t_of_sexp k_of_sexp d_of_sexp sexp = t_of_sexp ~hashable k_of_sexp d_of_sexp sexp\n\n let of_alist_multi ?growth_allowed ?size l =\n of_alist_multi ?growth_allowed ~hashable ?size l\n ;;\n\n let create_mapped ?growth_allowed ?size ~get_key ~get_data l =\n create_mapped ?growth_allowed ~hashable ?size ~get_key ~get_data l\n ;;\n\n let create_with_key ?growth_allowed ?size ~get_key l =\n create_with_key ?growth_allowed ~hashable ?size ~get_key l\n ;;\n\n let create_with_key_or_error ?growth_allowed ?size ~get_key l =\n create_with_key_or_error ?growth_allowed ~hashable ?size ~get_key l\n ;;\n\n let create_with_key_exn ?growth_allowed ?size ~get_key l =\n create_with_key_exn ?growth_allowed ~hashable ?size ~get_key l\n ;;\n\n let group ?growth_allowed ?size ~get_key ~get_data ~combine l =\n group ?growth_allowed ~hashable ?size ~get_key ~get_data ~combine l\n ;;\nend\n\nmodule Poly = struct\n type nonrec ('a, 'b) t = ('a, 'b) t\n type 'a key = 'a\n\n let hashable = Hashable.poly\n\n include Creators (struct\n type 'a t = 'a\n\n let hashable = hashable\n end)\n\n include Accessors\n\n let sexp_of_t = sexp_of_t\nend\n\nmodule Private = struct\n module type Creators_generic = Creators_generic\n module type Hashable = Hashable.Hashable\n\n type nonrec ('key, 'data, 'z) create_options_without_first_class_module =\n ('key, 'data, 'z) create_options_without_first_class_module\n\n let hashable t = t.hashable\nend\n\nlet create ?growth_allowed ?size m =\n create ~hashable:(Hashable.of_key m) ?growth_allowed ?size ()\n;;\n\nlet of_alist ?growth_allowed ?size m l =\n of_alist ~hashable:(Hashable.of_key m) ?growth_allowed ?size l\n;;\n\nlet of_alist_report_all_dups ?growth_allowed ?size m l =\n of_alist_report_all_dups ~hashable:(Hashable.of_key m) ?growth_allowed ?size l\n;;\n\nlet of_alist_or_error ?growth_allowed ?size m l =\n of_alist_or_error ~hashable:(Hashable.of_key m) ?growth_allowed ?size l\n;;\n\nlet of_alist_exn ?growth_allowed ?size m l =\n of_alist_exn ~hashable:(Hashable.of_key m) ?growth_allowed ?size l\n;;\n\nlet of_alist_multi ?growth_allowed ?size m l =\n of_alist_multi ~hashable:(Hashable.of_key m) ?growth_allowed ?size l\n;;\n\nlet create_mapped ?growth_allowed ?size m ~get_key ~get_data l =\n create_mapped ~hashable:(Hashable.of_key m) ?growth_allowed ?size ~get_key ~get_data l\n;;\n\nlet create_with_key ?growth_allowed ?size m ~get_key l =\n create_with_key ~hashable:(Hashable.of_key m) ?growth_allowed ?size ~get_key l\n;;\n\nlet create_with_key_or_error ?growth_allowed ?size m ~get_key l =\n create_with_key_or_error ~hashable:(Hashable.of_key m) ?growth_allowed ?size ~get_key l\n;;\n\nlet create_with_key_exn ?growth_allowed ?size m ~get_key l =\n create_with_key_exn ~hashable:(Hashable.of_key m) ?growth_allowed ?size ~get_key l\n;;\n\nlet group ?growth_allowed ?size m ~get_key ~get_data ~combine l =\n group ~hashable:(Hashable.of_key m) ?growth_allowed ?size ~get_key ~get_data ~combine l\n;;\n\nlet hashable_s t = Hashable.to_key t.hashable\n\nmodule M (K : T.T) = struct\n type nonrec 'v t = (K.t, 'v) t\nend\n\nmodule type Sexp_of_m = sig\n type t [@@deriving_inline sexp_of]\n\n val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t\n\n [@@@end]\nend\n\nmodule type M_of_sexp = sig\n type t [@@deriving_inline of_sexp]\n\n val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t\n\n [@@@end]\n\n include Key.S with type t := t\nend\n\nlet sexp_of_m__t (type k) (module K : Sexp_of_m with type t = k) sexp_of_v t =\n sexp_of_t K.sexp_of_t sexp_of_v t\n;;\n\nlet m__t_of_sexp (type k) (module K : M_of_sexp with type t = k) v_of_sexp sexp =\n t_of_sexp ~hashable:(Hashable.of_key (module K)) K.t_of_sexp v_of_sexp sexp\n;;\n\n(* typechecking this code is a compile-time test that [Creators] is a specialization of\n [Creators_generic]. *)\nmodule Check : sig end = struct\n module Make_creators_check\n (Type : T.T2)\n (Key : T.T1)\n (Options : T.T3)\n (M : Creators_generic\n with type ('a, 'b) t := ('a, 'b) Type.t\n with type 'a key := 'a Key.t\n with type ('a, 'b, 'z) create_options := ('a, 'b, 'z) Options.t) =\n struct end\n\n module Check_creators_is_specialization_of_creators_generic (M : Creators) =\n Make_creators_check\n (struct\n type ('a, 'b) t = ('a, 'b) M.t\n end)\n (struct\n type 'a t = 'a\n end)\n (struct\n type ('a, 'b, 'z) t = ('a, 'b, 'z) create_options\n end)\n (struct\n include M\n\n let create ?growth_allowed ?size m () = create ?growth_allowed ?size m\n end)\nend\n","open! Import\n\nmodule Key = struct\n module type S = sig\n type t [@@deriving_inline compare, sexp_of]\n\n val compare : t -> t -> int\n val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t\n\n [@@@end]\n\n (** Two [t]s that [compare] equal must have equal hashes for the hashtable\n to behave properly. *)\n val hash : t -> int\n end\n\n type 'a t = (module S with type t = 'a)\nend\n\nmodule Merge_into_action = struct\n type 'a t =\n | Remove\n | Set_to of 'a\nend\n\nmodule type Accessors = sig\n (** {2 Accessors} *)\n\n type ('a, 'b) t\n type 'a key\n\n val sexp_of_key : ('a, _) t -> 'a key -> Sexp.t\n val clear : (_, _) t -> unit\n val copy : ('a, 'b) t -> ('a, 'b) t\n\n (** Attempting to modify ([set], [remove], etc.) the hashtable during iteration ([fold],\n [iter], [iter_keys], [iteri]) will raise an exception. *)\n val fold : ('a, 'b) t -> init:'c -> f:(key:'a key -> data:'b -> 'c -> 'c) -> 'c\n\n val iter_keys : ('a, _) t -> f:('a key -> unit) -> unit\n val iter : (_, 'b) t -> f:('b -> unit) -> unit\n\n (** Iterates over both keys and values.\n\n Example:\n\n {v\n let h = Hashtbl.of_alist_exn (module Int) [(1, 4); (5, 6)] in\n Hashtbl.iteri h ~f:(fun ~key ~data ->\n print_endline (Printf.sprintf \"%d-%d\" key data));;\n 1-4\n 5-6\n - : unit = ()\n v} *)\n val iteri : ('a, 'b) t -> f:(key:'a key -> data:'b -> unit) -> unit\n\n val existsi : ('a, 'b) t -> f:(key:'a key -> data:'b -> bool) -> bool\n val exists : (_, 'b) t -> f:('b -> bool) -> bool\n val for_alli : ('a, 'b) t -> f:(key:'a key -> data:'b -> bool) -> bool\n val for_all : (_, 'b) t -> f:('b -> bool) -> bool\n val counti : ('a, 'b) t -> f:(key:'a key -> data:'b -> bool) -> int\n val count : (_, 'b) t -> f:('b -> bool) -> int\n val length : (_, _) t -> int\n val is_empty : (_, _) t -> bool\n val mem : ('a, _) t -> 'a key -> bool\n val remove : ('a, _) t -> 'a key -> unit\n val choose : ('a, 'b) t -> ('a key * 'b) option\n val choose_exn : ('a, 'b) t -> 'a key * 'b\n\n (** Sets the given [key] to [data]. *)\n val set : ('a, 'b) t -> key:'a key -> data:'b -> unit\n\n (** [add] and [add_exn] leave the table unchanged if the key was already present. *)\n val add : ('a, 'b) t -> key:'a key -> data:'b -> [ `Ok | `Duplicate ]\n\n val add_exn : ('a, 'b) t -> key:'a key -> data:'b -> unit\n\n (** [change t key ~f] changes [t]'s value for [key] to be [f (find t key)]. *)\n val change : ('a, 'b) t -> 'a key -> f:('b option -> 'b option) -> unit\n\n (** [update t key ~f] is [change t key ~f:(fun o -> Some (f o))]. *)\n val update : ('a, 'b) t -> 'a key -> f:('b option -> 'b) -> unit\n\n (** [map t f] returns a new table with values replaced by the result of applying [f]\n to the current values.\n\n Example:\n\n {v\n let h = Hashtbl.of_alist_exn (module Int) [(1, 4); (5, 6)] in\n let h' = Hashtbl.map h ~f:(fun x -> x * 2) in\n Hashtbl.to_alist h';;\n - : (int * int) list = [(5, 12); (1, 8)]\n v} *)\n val map : ('a, 'b) t -> f:('b -> 'c) -> ('a, 'c) t\n\n (** Like [map], but the function [f] takes both key and data as arguments. *)\n val mapi : ('a, 'b) t -> f:(key:'a key -> data:'b -> 'c) -> ('a, 'c) t\n\n (** Returns a new table by filtering the given table's values by [f]: the keys for which\n [f] applied to the current value returns [Some] are kept, and those for which it\n returns [None] are discarded.\n\n Example:\n\n {v\n let h = Hashtbl.of_alist_exn (module Int) [(1, 4); (5, 6)] in\n Hashtbl.filter_map h ~f:(fun x -> if x > 5 then Some x else None)\n |> Hashtbl.to_alist;;\n - : (int * int) list = [(5, 6)]\n v} *)\n val filter_map : ('a, 'b) t -> f:('b -> 'c option) -> ('a, 'c) t\n\n (** Like [filter_map], but the function [f] takes both key and data as arguments. *)\n val filter_mapi : ('a, 'b) t -> f:(key:'a key -> data:'b -> 'c option) -> ('a, 'c) t\n\n val filter_keys : ('a, 'b) t -> f:('a key -> bool) -> ('a, 'b) t\n val filter : ('a, 'b) t -> f:('b -> bool) -> ('a, 'b) t\n val filteri : ('a, 'b) t -> f:(key:'a key -> data:'b -> bool) -> ('a, 'b) t\n\n (** Returns new tables with bound values partitioned by [f] applied to the bound\n values. *)\n val partition_map\n : ('a, 'b) t\n -> f:('b -> ('c, 'd) Either.t)\n -> ('a, 'c) t * ('a, 'd) t\n\n (** Like [partition_map], but the function [f] takes both key and data as arguments. *)\n val partition_mapi\n : ('a, 'b) t\n -> f:(key:'a key -> data:'b -> ('c, 'd) Either.t)\n -> ('a, 'c) t * ('a, 'd) t\n\n (** Returns a pair of tables [(t1, t2)], where [t1] contains all the elements of the\n initial table which satisfy the predicate [f], and [t2] contains the rest. *)\n val partition_tf : ('a, 'b) t -> f:('b -> bool) -> ('a, 'b) t * ('a, 'b) t\n\n (** Like [partition_tf], but the function [f] takes both key and data as arguments. *)\n val partitioni_tf\n : ('a, 'b) t\n -> f:(key:'a key -> data:'b -> bool)\n -> ('a, 'b) t * ('a, 'b) t\n\n (** [find_or_add t k ~default] returns the data associated with key [k] if it is in the\n table [t], and otherwise assigns [k] the value returned by [default ()]. *)\n val find_or_add : ('a, 'b) t -> 'a key -> default:(unit -> 'b) -> 'b\n\n (** Like [find_or_add] but [default] takes the key as an argument. *)\n val findi_or_add : ('a, 'b) t -> 'a key -> default:('a key -> 'b) -> 'b\n\n (** [find t k] returns [Some] (the current binding) of [k] in [t], or [None] if no such\n binding exists. *)\n val find : ('a, 'b) t -> 'a key -> 'b option\n\n (** [find_exn t k] returns the current binding of [k] in [t], or raises [Caml.Not_found]\n or [Not_found_s] if no such binding exists. *)\n val find_exn : ('a, 'b) t -> 'a key -> 'b\n\n (** [find_and_call t k ~if_found ~if_not_found]\n\n is equivalent to:\n\n [match find t k with Some v -> if_found v | None -> if_not_found k]\n\n except that it doesn't allocate the option. *)\n val find_and_call\n : ('a, 'b) t\n -> 'a key\n -> if_found:('b -> 'c)\n -> if_not_found:('a key -> 'c)\n -> 'c\n\n (** Just like [find_and_call], but takes an extra argument which is passed to [if_found]\n and [if_not_found], so that the client code can avoid allocating closures or using\n refs to pass this additional information. This function is only useful in code\n which tries to minimize heap allocation. *)\n val find_and_call1\n : ('a, 'b) t\n -> 'a key\n -> a:'d\n -> if_found:('b -> 'd -> 'c)\n -> if_not_found:('a key -> 'd -> 'c)\n -> 'c\n\n val find_and_call2\n : ('a, 'b) t\n -> 'a key\n -> a:'d\n -> b:'e\n -> if_found:('b -> 'd -> 'e -> 'c)\n -> if_not_found:('a key -> 'd -> 'e -> 'c)\n -> 'c\n\n val findi_and_call\n : ('a, 'b) t\n -> 'a key\n -> if_found:(key:'a key -> data:'b -> 'c)\n -> if_not_found:('a key -> 'c)\n -> 'c\n\n val findi_and_call1\n : ('a, 'b) t\n -> 'a key\n -> a:'d\n -> if_found:(key:'a key -> data:'b -> 'd -> 'c)\n -> if_not_found:('a key -> 'd -> 'c)\n -> 'c\n\n val findi_and_call2\n : ('a, 'b) t\n -> 'a key\n -> a:'d\n -> b:'e\n -> if_found:(key:'a key -> data:'b -> 'd -> 'e -> 'c)\n -> if_not_found:('a key -> 'd -> 'e -> 'c)\n -> 'c\n\n (** [find_and_remove t k] returns Some (the current binding) of k in t and removes it,\n or None is no such binding exists. *)\n val find_and_remove : ('a, 'b) t -> 'a key -> 'b option\n\n (** Merges two hashtables.\n\n The result of [merge f h1 h2] has as keys the set of all [k] in the union of the\n sets of keys of [h1] and [h2] for which [d(k)] is not None, where:\n\n d(k) =\n - [f ~key:k (`Left d1)]\n if [k] in [h1] maps to d1, and [h2] does not have data for [k];\n\n - [f ~key:k (`Right d2)]\n if [k] in [h2] maps to d2, and [h1] does not have data for [k];\n\n - [f ~key:k (`Both (d1, d2))]\n otherwise, where [k] in [h1] maps to [d1] and [k] in [h2] maps to [d2].\n\n Each key [k] is mapped to a single piece of data [x], where [d(k) = Some x].\n\n Example:\n\n {v\n let h1 = Hashtbl.of_alist_exn (module Int) [(1, 5); (2, 3232)] in\n let h2 = Hashtbl.of_alist_exn (module Int) [(1, 3)] in\n Hashtbl.merge h1 h2 ~f:(fun ~key:_ -> function\n | `Left x -> Some (`Left x)\n | `Right x -> Some (`Right x)\n | `Both (x, y) -> if x=y then None else Some (`Both (x,y))\n ) |> Hashtbl.to_alist;;\n - : (int * [> `Both of int * int | `Left of int | `Right of int ]) list =\n [(2, `Left 3232); (1, `Both (5, 3))]\n v} *)\n val merge\n : ('k, 'a) t\n -> ('k, 'b) t\n -> f:(key:'k key -> [ `Left of 'a | `Right of 'b | `Both of 'a * 'b ] -> 'c option)\n -> ('k, 'c) t\n\n\n (** Every [key] in [src] will be removed or set in [dst] according to the return value\n of [f]. *)\n val merge_into\n : src:('k, 'a) t\n -> dst:('k, 'b) t\n -> f:(key:'k key -> 'a -> 'b option -> 'b Merge_into_action.t)\n -> unit\n\n (** Returns the list of all keys for given hashtable. *)\n val keys : ('a, _) t -> 'a key list\n\n (** Returns the list of all data for given hashtable. *)\n val data : (_, 'b) t -> 'b list\n\n (** [filter_inplace t ~f] removes all the elements from [t] that don't satisfy [f]. *)\n val filter_keys_inplace : ('a, _) t -> f:('a key -> bool) -> unit\n\n val filter_inplace : (_, 'b) t -> f:('b -> bool) -> unit\n val filteri_inplace : ('a, 'b) t -> f:(key:'a key -> data:'b -> bool) -> unit\n\n (** [map_inplace t ~f] applies [f] to all elements in [t], transforming them in\n place. *)\n val map_inplace : (_, 'b) t -> f:('b -> 'b) -> unit\n\n val mapi_inplace : ('a, 'b) t -> f:(key:'a key -> data:'b -> 'b) -> unit\n\n (** [filter_map_inplace] combines the effects of [map_inplace] and [filter_inplace]. *)\n val filter_map_inplace : (_, 'b) t -> f:('b -> 'b option) -> unit\n\n val filter_mapi_inplace : ('a, 'b) t -> f:(key:'a key -> data:'b -> 'b option) -> unit\n\n (** [equal f t1 t2] and [similar f t1 t2] both return true iff [t1] and [t2] have the\n same keys and for all keys [k], [f (find_exn t1 k) (find_exn t2 k)]. [equal] and\n [similar] only differ in their types. *)\n val equal : ('b -> 'b -> bool) -> ('a, 'b) t -> ('a, 'b) t -> bool\n\n val similar : ('b1 -> 'b2 -> bool) -> ('a, 'b1) t -> ('a, 'b2) t -> bool\n\n (** Returns the list of all (key, data) pairs for given hashtable. *)\n val to_alist : ('a, 'b) t -> ('a key * 'b) list\n\n val validate\n : name:('a key -> string)\n -> 'b Validate.check\n -> ('a, 'b) t Validate.check\n\n\n (** [remove_if_zero]'s default is [false]. *)\n val incr : ?by:int -> ?remove_if_zero:bool -> ('a, int) t -> 'a key -> unit\n\n val decr : ?by:int -> ?remove_if_zero:bool -> ('a, int) t -> 'a key -> unit\nend\n\nmodule type Multi = sig\n type ('a, 'b) t\n type 'a key\n\n (** [add_multi t ~key ~data] if [key] is present in the table then cons\n [data] on the list, otherwise add [key] with a single element list. *)\n val add_multi : ('a, 'b list) t -> key:'a key -> data:'b -> unit\n\n (** [remove_multi t key] updates the table, removing the head of the list bound to\n [key]. If the list has only one element (or is empty) then the binding is\n removed. *)\n val remove_multi : ('a, _ list) t -> 'a key -> unit\n\n (** [find_multi t key] returns the empty list if [key] is not present in the table,\n returns [t]'s values for [key] otherwise. *)\n val find_multi : ('a, 'b list) t -> 'a key -> 'b list\nend\n\ntype ('key, 'data, 'z) create_options =\n ?growth_allowed:bool (** defaults to [true] *)\n -> ?size:int (** initial size -- default 0 *)\n -> 'key Key.t\n -> 'z\n\ntype ('key, 'data, 'z) create_options_without_first_class_module =\n ?growth_allowed:bool (** defaults to [true] *)\n -> ?size:int (** initial size -- default 0 *)\n -> 'z\n\nmodule type Creators_generic = sig\n type ('a, 'b) t\n type 'a key\n type ('key, 'data, 'z) create_options\n\n val create : ('a key, 'b, unit -> ('a, 'b) t) create_options\n\n\n val of_alist\n : ( 'a key\n , 'b\n , ('a key * 'b) list -> [ `Ok of ('a, 'b) t | `Duplicate_key of 'a key ] )\n create_options\n\n val of_alist_report_all_dups\n : ( 'a key\n , 'b\n , ('a key * 'b) list -> [ `Ok of ('a, 'b) t | `Duplicate_keys of 'a key list ] )\n create_options\n\n val of_alist_or_error\n : ('a key, 'b, ('a key * 'b) list -> ('a, 'b) t Or_error.t) create_options\n\n val of_alist_exn : ('a key, 'b, ('a key * 'b) list -> ('a, 'b) t) create_options\n\n val of_alist_multi\n : ('a key, 'b list, ('a key * 'b) list -> ('a, 'b list) t) create_options\n\n\n (** {[ create_mapped get_key get_data [x1,...,xn]\n = of_alist [get_key x1, get_data x1; ...; get_key xn, get_data xn] ]} *)\n val create_mapped\n : ( 'a key\n , 'b\n , get_key:('r -> 'a key)\n -> get_data:('r -> 'b)\n -> 'r list\n -> [ `Ok of ('a, 'b) t | `Duplicate_keys of 'a key list ] )\n create_options\n\n\n (** {[ create_with_key ~get_key [x1,...,xn]\n = of_alist [get_key x1, x1; ...; get_key xn, xn] ]} *)\n val create_with_key\n : ( 'a key\n , 'r\n , get_key:('r -> 'a key)\n -> 'r list\n -> [ `Ok of ('a, 'r) t | `Duplicate_keys of 'a key list ] )\n create_options\n\n val create_with_key_or_error\n : ( 'a key\n , 'r\n , get_key:('r -> 'a key) -> 'r list -> ('a, 'r) t Or_error.t )\n create_options\n\n val create_with_key_exn\n : ('a key, 'r, get_key:('r -> 'a key) -> 'r list -> ('a, 'r) t) create_options\n\n\n val group\n : ( 'a key\n , 'b\n , get_key:('r -> 'a key)\n -> get_data:('r -> 'b)\n -> combine:('b -> 'b -> 'b)\n -> 'r list\n -> ('a, 'b) t )\n create_options\nend\n\nmodule type Creators = sig\n type ('a, 'b) t\n\n (** {2 Creators} *)\n\n (** The module you pass to [create] must have a type that is hashable, sexpable, and\n comparable.\n\n Example:\n\n {v\n Hashtbl.create (module Int);;\n - : (int, '_a) Hashtbl.t = ;;\n v} *)\n val create\n : ?growth_allowed:bool (** defaults to [true] *)\n -> ?size:int (** initial size -- default 0 *)\n -> 'a Key.t\n -> ('a, 'b) t\n\n (** Example:\n\n {v\n Hashtbl.of_alist (module Int) [(3, \"something\"); (2, \"whatever\")]\n - : [ `Duplicate_key of int | `Ok of (int, string) Hashtbl.t ] = `Ok \n v} *)\n val of_alist\n : ?growth_allowed:bool (** defaults to [true] *)\n -> ?size:int (** initial size -- default 0 *)\n -> 'a Key.t\n -> ('a * 'b) list\n -> [ `Ok of ('a, 'b) t | `Duplicate_key of 'a ]\n\n (** Whereas [of_alist] will report [Duplicate_key] no matter how many dups there are in\n your list, [of_alist_report_all_dups] will report each and every duplicate entry.\n\n For example:\n\n {v\n Hashtbl.of_alist (module Int) [(1, \"foo\"); (1, \"bar\"); (2, \"foo\"); (2, \"bar\")];;\n - : [ `Duplicate_key of int | `Ok of (int, string) Hashtbl.t ] = `Duplicate_key 1\n\n Hashtbl.of_alist_report_all_dups (module Int) [(1, \"foo\"); (1, \"bar\"); (2, \"foo\"); (2, \"bar\")];;\n - : [ `Duplicate_keys of int list | `Ok of (int, string) Hashtbl.t ] = `Duplicate_keys [1; 2]\n v} *)\n val of_alist_report_all_dups\n : ?growth_allowed:bool (** defaults to [true] *)\n -> ?size:int (** initial size -- default 0 *)\n -> 'a Key.t\n -> ('a * 'b) list\n -> [ `Ok of ('a, 'b) t | `Duplicate_keys of 'a list ]\n\n val of_alist_or_error\n : ?growth_allowed:bool (** defaults to [true] *)\n -> ?size:int (** initial size -- default 0 *)\n -> 'a Key.t\n -> ('a * 'b) list\n -> ('a, 'b) t Or_error.t\n\n val of_alist_exn\n : ?growth_allowed:bool (** defaults to [true] *)\n -> ?size:int (** initial size -- default 0 *)\n -> 'a Key.t\n -> ('a * 'b) list\n -> ('a, 'b) t\n\n (** Creates a {{!Multi} \"multi\"} hashtable, i.e., a hashtable where each key points to a\n list potentially containing multiple values. So instead of short-circuiting with a\n [`Duplicate_key] variant on duplicates, as in [of_alist], [of_alist_multi] folds\n those values into a list for the given key:\n\n {v\n let h = Hashtbl.of_alist_multi (module Int) [(1, \"a\"); (1, \"b\"); (2, \"c\"); (2, \"d\")];;\n val h : (int, string list) Hashtbl.t = \n\n Hashtbl.find_exn h 1;;\n - : string list = [\"b\"; \"a\"]\n v} *)\n val of_alist_multi\n : ?growth_allowed:bool (** defaults to [true] *)\n -> ?size:int (** initial size -- default 0 *)\n -> 'a Key.t\n -> ('a * 'b) list\n -> ('a, 'b list) t\n\n (** Applies the [get_key] and [get_data] functions to the ['r list] to create the\n initial keys and values, respectively, for the new hashtable.\n\n {[ create_mapped get_key get_data [x1;...;xn]\n = of_alist [get_key x1, get_data x1; ...; get_key xn, get_data xn]\n ]}\n\n Example:\n\n {v\n let h =\n Hashtbl.create_mapped (module Int)\n ~get_key:(fun x -> x)\n ~get_data:(fun x -> x + 1)\n [1; 2; 3];;\n val h : [ `Duplicate_keys of int list | `Ok of (int, int) Hashtbl.t ] = `Ok \n\n let h =\n match h with\n | `Ok x -> x\n | `Duplicate_keys _ -> failwith \"\"\n in\n Hashtbl.find_exn h 1;;\n - : int = 2\n v} *)\n val create_mapped\n : ?growth_allowed:bool (** defaults to [true] *)\n -> ?size:int (** initial size -- default 0 *)\n -> 'a Key.t\n -> get_key:('r -> 'a)\n -> get_data:('r -> 'b)\n -> 'r list\n -> [ `Ok of ('a, 'b) t | `Duplicate_keys of 'a list ]\n\n (** {[ create_with_key ~get_key [x1;...;xn]\n = of_alist [get_key x1, x1; ...; get_key xn, xn] ]} *)\n val create_with_key\n : ?growth_allowed:bool (** defaults to [true] *)\n -> ?size:int (** initial size -- default 0 *)\n -> 'a Key.t\n -> get_key:('r -> 'a)\n -> 'r list\n -> [ `Ok of ('a, 'r) t | `Duplicate_keys of 'a list ]\n\n val create_with_key_or_error\n : ?growth_allowed:bool (** defaults to [true] *)\n -> ?size:int (** initial size -- default 0 *)\n -> 'a Key.t\n -> get_key:('r -> 'a)\n -> 'r list\n -> ('a, 'r) t Or_error.t\n\n val create_with_key_exn\n : ?growth_allowed:bool (** defaults to [true] *)\n -> ?size:int (** initial size -- default 0 *)\n -> 'a Key.t\n -> get_key:('r -> 'a)\n -> 'r list\n -> ('a, 'r) t\n\n (** Like [create_mapped], applies the [get_key] and [get_data] functions to the ['r\n list] to create the initial keys and values, respectively, for the new hashtable --\n and then, like [add_multi], folds together values belonging to the same keys. Here,\n though, the function used for the folding is given by [combine] (instead of just\n being a [cons]).\n\n Example:\n\n {v\n Hashtbl.group (module Int)\n ~get_key:(fun x -> x / 2)\n ~get_data:(fun x -> x)\n ~combine:(fun x y -> x * y)\n [ 1; 2; 3; 4]\n |> Hashtbl.to_alist;;\n - : (int * int) list = [(2, 4); (1, 6); (0, 1)]\n v} *)\n val group\n : ?growth_allowed:bool (** defaults to [true] *)\n -> ?size:int (** initial size -- default 0 *)\n -> 'a Key.t\n -> get_key:('r -> 'a)\n -> get_data:('r -> 'b)\n -> combine:('b -> 'b -> 'b)\n -> 'r list\n -> ('a, 'b) t\nend\n\nmodule type S_without_submodules = sig\n val hash : 'a -> int\n val hash_param : int -> int -> 'a -> int\n\n type ('a, 'b) t\n\n (** We provide a [sexp_of_t] but not a [t_of_sexp] for this type because one needs to be\n explicit about the hash and comparison functions used when creating a hashtable.\n Note that [Hashtbl.Poly.t] does have [[@@deriving sexp]], and uses OCaml's built-in\n polymorphic comparison and and polymorphic hashing. *)\n val sexp_of_t : ('a -> Sexp.t) -> ('b -> Sexp.t) -> ('a, 'b) t -> Sexp.t\n\n include Creators with type ('a, 'b) t := ('a, 'b) t (** @inline *)\n\n include\n Accessors with type ('a, 'b) t := ('a, 'b) t with type 'a key = 'a\n (** @inline *)\n\n\n include\n Multi with type ('a, 'b) t := ('a, 'b) t with type 'a key := 'a key\n (** @inline *)\n\n val hashable_s : ('key, _) t -> 'key Key.t\n\n include Invariant.S2 with type ('a, 'b) t := ('a, 'b) t\nend\n\nmodule type S_poly = sig\n type ('a, 'b) t [@@deriving_inline sexp]\n\n include Ppx_sexp_conv_lib.Sexpable.S2 with type ('a, 'b) t := ('a, 'b) t\n\n [@@@end]\n\n val hashable : 'a Hashable.t\n\n include Invariant.S2 with type ('a, 'b) t := ('a, 'b) t\n\n include\n Creators_generic\n with type ('a, 'b) t := ('a, 'b) t\n with type 'a key = 'a\n with type ('key, 'data, 'z) create_options :=\n ('key, 'data, 'z) create_options_without_first_class_module\n\n include Accessors with type ('a, 'b) t := ('a, 'b) t with type 'a key := 'a key\n include Multi with type ('a, 'b) t := ('a, 'b) t with type 'a key := 'a key\nend\n\nmodule type For_deriving = sig\n type ('k, 'v) t\n\n module type Sexp_of_m = sig\n type t [@@deriving_inline sexp_of]\n\n val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t\n\n [@@@end]\n end\n\n module type M_of_sexp = sig\n type t [@@deriving_inline of_sexp]\n\n val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t\n\n [@@@end]\n\n include Key.S with type t := t\n end\n\n val sexp_of_m__t\n : (module Sexp_of_m with type t = 'k)\n -> ('v -> Sexp.t)\n -> ('k, 'v) t\n -> Sexp.t\n\n val m__t_of_sexp\n : (module M_of_sexp with type t = 'k)\n -> (Sexp.t -> 'v)\n -> Sexp.t\n -> ('k, 'v) t\nend\n\nmodule type Hashtbl = sig\n (** A hash table is a mutable data structure implementing a map between keys and values.\n It supports constant-time lookup and in-place modification.\n\n {1 Usage}\n\n As a simple example, we'll create a hash table with string keys using the\n {{!create}[create]} constructor, which expects a module defining the key's type:\n\n {[\n let h = Hashtbl.create (module String);;\n val h : (string, '_a) Hashtbl.t = \n ]}\n\n We can set the values of individual keys with {{!set}[set]}. If the key already has\n a value, it will be overwritten.\n\n {v\n Hashtbl.set h ~key:\"foo\" ~data:5;;\n - : unit = ()\n\n Hashtbl.set h ~key:\"foo\" ~data:6;;\n - : unit = ()\n\n Hashtbl.set h ~key:\"bar\" ~data:6;;\n - : unit = ()\n v}\n\n We can access values by key, or dump all of the hash table's data:\n\n {v\n Hashtbl.find h \"foo\";;\n - : int option = Some 6\n\n Hashtbl.find_exn h \"foo\";;\n - : int = 6\n\n Hashtbl.to_alist h;;\n - : (string * int) list = [(\"foo\", 6); (\"bar\", 6)]\n v}\n\n {{!change}[change]} lets us change a key's value by applying the given function:\n\n {v\n Hashtbl.change h \"foo\" (fun x ->\n match x with\n | Some x -> Some (x * 2)\n | None -> None\n );;\n - : unit = ()\n\n Hashtbl.to_alist h;;\n - : (string * int) list = [(\"foo\", 12); (\"bar\", 6)]\n v}\n\n\n We can use {{!merge}[merge]} to merge two hashtables with fine-grained control over\n how we choose values when a key is present in the first (\"left\") hashtable, the\n second (\"right\"), or both. Here, we'll cons the values when both hashtables have a\n key:\n\n {v\n let h1 = Hashtbl.of_alist_exn (module Int) [(1, 5); (2, 3232)] in\n let h2 = Hashtbl.of_alist_exn (module Int) [(1, 3)] in\n Hashtbl.merge h1 h2 ~f:(fun ~key:_ -> function\n | `Left x -> Some (`Left x)\n | `Right x -> Some (`Right x)\n | `Both (x, y) -> if x=y then None else Some (`Both (x,y))\n ) |> Hashtbl.to_alist;;\n - : (int * [> `Both of int * int | `Left of int | `Right of int ]) list =\n [(2, `Left 3232); (1, `Both (5, 3))]\n v}\n\n {1 Interface} *)\n\n include S_without_submodules (** @inline *)\n\n module type Accessors = Accessors\n module type Creators = Creators\n module type Key = Key.S [@@deprecated \"[since 2019-03] Use [Hashtbl.Key.S]\"]\n module type Multi = Multi\n module type S_poly = S_poly\n module type S_without_submodules = S_without_submodules\n module type For_deriving = For_deriving\n\n module Key = Key\n module Merge_into_action = Merge_into_action\n\n type nonrec ('key, 'data, 'z) create_options = ('key, 'data, 'z) create_options\n\n module Creators (Key : sig\n type 'a t\n\n val hashable : 'a t Hashable.t\n end) : sig\n type ('a, 'b) t_ = ('a Key.t, 'b) t\n\n val t_of_sexp : (Sexp.t -> 'a Key.t) -> (Sexp.t -> 'b) -> Sexp.t -> ('a, 'b) t_\n\n include\n Creators_generic\n with type ('a, 'b) t := ('a, 'b) t_\n with type 'a key := 'a Key.t\n with type ('key, 'data, 'a) create_options :=\n ('key, 'data, 'a) create_options_without_first_class_module\n end\n\n module Poly : S_poly with type ('a, 'b) t = ('a, 'b) t\n\n (** [M] is meant to be used in combination with OCaml applicative functor types:\n\n {[\n type string_to_int_table = int Hashtbl.M(String).t\n ]}\n\n which stands for:\n\n {[\n type string_to_int_table = (String.t, int) Hashtbl.t\n ]}\n\n The point is that [int Hashtbl.M(String).t] supports deriving, whereas the second\n syntax doesn't (because [t_of_sexp] doesn't know what comparison/hash function to\n use). *)\n module M (K : T.T) : sig\n type nonrec 'v t = (K.t, 'v) t\n end\n\n include For_deriving with type ('a, 'b) t := ('a, 'b) t\n\n (**/**)\n\n (*_ See the Jane Street Style Guide for an explanation of [Private] submodules:\n\n https://opensource.janestreet.com/standards/#private-submodules *)\n module Private : sig\n module type Creators_generic = Creators_generic\n\n type nonrec ('key, 'data, 'z) create_options_without_first_class_module =\n ('key, 'data, 'z) create_options_without_first_class_module\n\n val hashable : ('key, _) t -> 'key Hashable.t\n end\nend\n","open! Import\n\nmodule type Key = sig\n type t [@@deriving_inline compare, sexp_of]\n\n val compare : t -> t -> int\n val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t\n\n [@@@end]\n\n (** Values returned by [hash] must be non-negative. An exception will be raised in the\n case that [hash] returns a negative value. *)\n val hash : t -> int\nend\n\nmodule Hashable = struct\n type 'a t =\n { hash : 'a -> int\n ; compare : 'a -> 'a -> int\n ; sexp_of_t : 'a -> Sexp.t\n }\n\n (** This function is sound but not complete, meaning that if it returns [true] then it's\n safe to use the two interchangeably. If it's [false], you have no guarantees. For\n example:\n\n {[\n > utop\n open Core;;\n let equal (a : 'a Hashtbl_intf.Hashable.t) b =\n phys_equal a b\n || (phys_equal a.hash b.hash\n && phys_equal a.compare b.compare\n && phys_equal a.sexp_of_t b.sexp_of_t)\n ;;\n let a = Hashtbl_intf.Hashable.{ hash; compare; sexp_of_t = Int.sexp_of_t };;\n let b = Hashtbl_intf.Hashable.{ hash; compare; sexp_of_t = Int.sexp_of_t };;\n equal a b;; (* false?! *)\n ]}\n *)\n let equal a b =\n phys_equal a b\n || (phys_equal a.hash b.hash\n && phys_equal a.compare b.compare\n && phys_equal a.sexp_of_t b.sexp_of_t)\n ;;\n\n let hash_param = Caml.Hashtbl.hash_param\n let hash = Caml.Hashtbl.hash\n let poly = { hash; compare = Poly.compare; sexp_of_t = (fun _ -> Sexp.Atom \"_\") }\n\n let of_key (type a) (module Key : Key with type t = a) =\n { hash = Key.hash; compare = Key.compare; sexp_of_t = Key.sexp_of_t }\n ;;\n\n let to_key (type a) { hash; compare; sexp_of_t } =\n (module struct\n type t = a\n\n let hash = hash\n let compare = compare\n let sexp_of_t = sexp_of_t\n end : Key\n with type t = a)\n ;;\nend\n\ninclude Hashable\n\nmodule type Hashable = sig\n type 'a t = 'a Hashable.t =\n { hash : 'a -> int\n ; compare : 'a -> 'a -> int\n ; sexp_of_t : 'a -> Sexp.t\n }\n\n val equal : 'a t -> 'a t -> bool\n val poly : 'a t\n val of_key : (module Key with type t = 'a) -> 'a t\n val to_key : 'a t -> (module Key with type t = 'a)\n val hash_param : int -> int -> 'a -> int\n val hash : 'a -> int\nend\n","(* A few small things copied from other parts of Base because they depend on us, so we\n can't use them. *)\n\nopen! Import\n\nlet raise_s = Error.raise_s\n\nmodule Int = struct\n type t = int\n\n let max (x : t) y = if x > y then x else y\nend\n\n(* Its important that Empty have no args. It's tempting to make this type a record\n (e.g. to hold the compare function), but a lot of memory is saved by Empty being an\n immediate, since all unused buckets in the hashtbl don't use any memory (besides the\n array cell) *)\ntype ('k, 'v) t =\n | Empty\n | Node of\n { mutable left : ('k, 'v) t\n ; key : 'k\n ; mutable value : 'v\n ; mutable height : int\n ; mutable right : ('k, 'v) t\n }\n | Leaf of\n { key : 'k\n ; mutable value : 'v\n }\n\nlet empty = Empty\n\nlet is_empty = function\n | Empty -> true\n | Leaf _ | Node _ -> false\n;;\n\nlet height = function\n | Empty -> 0\n | Leaf _ -> 1\n | Node { left = _; key = _; value = _; height; right = _ } -> height\n;;\n\nlet invariant compare =\n let legal_left_key key = function\n | Empty -> ()\n | Leaf { key = left_key; value = _ }\n | Node { left = _; key = left_key; value = _; height = _; right = _ } ->\n assert (compare left_key key < 0)\n in\n let legal_right_key key = function\n | Empty -> ()\n | Leaf { key = right_key; value = _ }\n | Node { left = _; key = right_key; value = _; height = _; right = _ } ->\n assert (compare right_key key > 0)\n in\n let rec inv = function\n | Empty | Leaf _ -> ()\n | Node { left; key = k; value = _; height = h; right } ->\n let hl, hr = height left, height right in\n inv left;\n inv right;\n legal_left_key k left;\n legal_right_key k right;\n assert (h = Int.max hl hr + 1);\n assert (abs (hl - hr) <= 2)\n in\n inv\n;;\n\nlet invariant t ~compare = invariant compare t\n\n(* In the following comments,\n 't is balanced' means that 'invariant t' does not\n raise an exception. This implies of course that each node's height field is\n correct.\n 't is balanceable' means that height of the left and right subtrees of t\n differ by at most 3. *)\n\n(* @pre: left and right subtrees have correct heights\n @post: output has the correct height *)\nlet update_height = function\n | Node ({ left; key = _; value = _; height = old_height; right } as x) ->\n let new_height = Int.max (height left) (height right) + 1 in\n if new_height <> old_height then x.height <- new_height\n | Empty | Leaf _ -> assert false\n;;\n\n(* @pre: left and right subtrees are balanced\n @pre: tree is balanceable\n @post: output is balanced (in particular, height is correct) *)\nlet balance tree =\n match tree with\n | Empty | Leaf _ -> tree\n | Node ({ left; key = _; value = _; height = _; right } as root_node) ->\n let hl = height left\n and hr = height right in\n (* + 2 is critically important, lowering it to 1 will break the Leaf\n assumptions in the code below, and will force us to promote leaf nodes in\n the balance routine. It's also faster, since it will balance less often.\n Note that the following code is delicate. The update_height calls must\n occur in the correct order, since update_height assumes its children have\n the correct heights. *)\n if hl > hr + 2\n then (\n match left with\n (* It cannot be a leaf, because even if right is empty, a leaf\n is only height 1 *)\n | Empty | Leaf _ -> assert false\n | Node\n ({ left = left_node_left\n ; key = _\n ; value = _\n ; height = _\n ; right = left_node_right\n } as left_node) ->\n if height left_node_left >= height left_node_right\n then (\n root_node.left <- left_node_right;\n left_node.right <- tree;\n update_height tree;\n update_height left;\n left)\n else (\n (* if right is a leaf, then left must be empty. That means\n height is 2. Even if hr is empty we still can't get here. *)\n match left_node_right with\n | Empty | Leaf _ -> assert false\n | Node\n ({ left = lr_left; key = _; value = _; height = _; right = lr_right } as\n lr_node) ->\n left_node.right <- lr_left;\n root_node.left <- lr_right;\n lr_node.right <- tree;\n lr_node.left <- left;\n update_height left;\n update_height tree;\n update_height left_node_right;\n left_node_right))\n else if hr > hl + 2\n then (\n (* see above for an explanation of why right cannot be a leaf *)\n match right with\n | Empty | Leaf _ -> assert false\n | Node\n ({ left = right_node_left\n ; key = _\n ; value = _\n ; height = _\n ; right = right_node_right\n } as right_node) ->\n if height right_node_right >= height right_node_left\n then (\n root_node.right <- right_node_left;\n right_node.left <- tree;\n update_height tree;\n update_height right;\n right)\n else (\n (* see above for an explanation of why this cannot be a leaf *)\n match right_node_left with\n | Empty | Leaf _ -> assert false\n | Node\n ({ left = rl_left; key = _; value = _; height = _; right = rl_right } as\n rl_node) ->\n right_node.left <- rl_right;\n root_node.right <- rl_left;\n rl_node.left <- tree;\n rl_node.right <- right;\n update_height right;\n update_height tree;\n update_height right_node_left;\n right_node_left))\n else (\n update_height tree;\n tree)\n;;\n\n(* @pre: tree is balanceable\n @pre: abs (height (right node) - height (balance tree)) <= 3\n @post: result is balanceable *)\n\n(* @pre: tree is balanceable\n @pre: abs (height (right node) - height (balance tree)) <= 3\n @post: result is balanceable *)\nlet set_left node tree =\n let tree = balance tree in\n match node with\n | Node ({ left; key = _; value = _; height = _; right = _ } as r) ->\n if phys_equal left tree then () else r.left <- tree;\n update_height node\n | _ -> assert false\n;;\n\n(* @pre: tree is balanceable\n @pre: abs (height (left node) - height (balance tree)) <= 3\n @post: result is balanceable *)\nlet set_right node tree =\n let tree = balance tree in\n match node with\n | Node ({ left = _; key = _; value = _; height = _; right } as r) ->\n if phys_equal right tree then () else r.right <- tree;\n update_height node\n | _ -> assert false\n;;\n\n(* @pre: t is balanced.\n @post: result is balanced, with new node inserted\n @post: !added = true iff the shape of the input tree changed. *)\nlet add =\n let rec add t replace added compare k v =\n match t with\n | Empty ->\n added := true;\n Leaf { key = k; value = v }\n | Leaf ({ key = k'; value = _ } as r) ->\n let c = compare k' k in\n (* This compare is reversed on purpose, we are pretending\n that the leaf was just inserted instead of the other way\n round, that way we only allocate one node. *)\n if c = 0\n then (\n added := false;\n if replace then r.value <- v;\n t)\n else (\n added := true;\n if c < 0\n then Node { left = t; key = k; value = v; height = 2; right = Empty }\n else Node { left = Empty; key = k; value = v; height = 2; right = t })\n | Node ({ left; key = k'; value = _; height = _; right } as r) ->\n let c = compare k k' in\n if c = 0\n then (\n added := false;\n if replace then r.value <- v)\n else if c < 0\n then set_left t (add left replace added compare k v)\n else set_right t (add right replace added compare k v);\n t\n in\n fun t ~replace ~compare ~added ~key ~data ->\n let t = add t replace added compare key data in\n if !added then balance t else t\n;;\n\nlet rec first t =\n match t with\n | Empty -> None\n | Leaf { key = k; value = v }\n | Node { left = Empty; key = k; value = v; height = _; right = _ } -> Some (k, v)\n | Node { left = l; key = _; value = _; height = _; right = _ } -> first l\n;;\n\nlet rec last t =\n match t with\n | Empty -> None\n | Leaf { key = k; value = v }\n | Node { left = _; key = k; value = v; height = _; right = Empty } -> Some (k, v)\n | Node { left = _; key = _; value = _; height = _; right = r } -> last r\n;;\n\n\nlet[@inline always] rec findi_and_call_impl\n t\n ~compare\n k\n arg1\n arg2\n ~call_if_found\n ~call_if_not_found\n ~if_found\n ~if_not_found\n =\n match t with\n | Empty -> call_if_not_found ~if_not_found k arg1 arg2\n | Leaf { key = k'; value = v } ->\n if compare k k' = 0\n then call_if_found ~if_found ~key:k' ~data:v arg1 arg2\n else call_if_not_found ~if_not_found k arg1 arg2\n | Node { left; key = k'; value = v; height = _; right } ->\n let c = compare k k' in\n if c = 0\n then call_if_found ~if_found ~key:k' ~data:v arg1 arg2\n else\n findi_and_call_impl\n (if c < 0 then left else right)\n ~compare\n k\n arg1\n arg2\n ~call_if_found\n ~call_if_not_found\n ~if_found\n ~if_not_found\n;;\n\nlet find_and_call =\n let call_if_found ~if_found ~key:_ ~data () () = if_found data in\n let call_if_not_found ~if_not_found key () () = if_not_found key in\n fun t ~compare k ~if_found ~if_not_found ->\n findi_and_call_impl\n t\n ~compare\n k\n ()\n ()\n ~call_if_found\n ~call_if_not_found\n ~if_found\n ~if_not_found\n;;\n\nlet findi_and_call =\n let call_if_found ~if_found ~key ~data () () = if_found ~key ~data in\n let call_if_not_found ~if_not_found key () () = if_not_found key in\n fun t ~compare k ~if_found ~if_not_found ->\n findi_and_call_impl\n t\n ~compare\n k\n ()\n ()\n ~call_if_found\n ~call_if_not_found\n ~if_found\n ~if_not_found\n;;\n\nlet find_and_call1 =\n let call_if_found ~if_found ~key:_ ~data arg () = if_found data arg in\n let call_if_not_found ~if_not_found key arg () = if_not_found key arg in\n fun t ~compare k ~a ~if_found ~if_not_found ->\n findi_and_call_impl\n t\n ~compare\n k\n a\n ()\n ~call_if_found\n ~call_if_not_found\n ~if_found\n ~if_not_found\n;;\n\nlet findi_and_call1 =\n let call_if_found ~if_found ~key ~data arg () = if_found ~key ~data arg in\n let call_if_not_found ~if_not_found key arg () = if_not_found key arg in\n fun t ~compare k ~a ~if_found ~if_not_found ->\n findi_and_call_impl\n t\n ~compare\n k\n a\n ()\n ~call_if_found\n ~call_if_not_found\n ~if_found\n ~if_not_found\n;;\n\nlet find_and_call2 =\n let call_if_found ~if_found ~key:_ ~data arg1 arg2 = if_found data arg1 arg2 in\n let call_if_not_found ~if_not_found key arg1 arg2 = if_not_found key arg1 arg2 in\n fun t ~compare k ~a ~b ~if_found ~if_not_found ->\n findi_and_call_impl\n t\n ~compare\n k\n a\n b\n ~call_if_found\n ~call_if_not_found\n ~if_found\n ~if_not_found\n;;\n\nlet findi_and_call2 =\n let call_if_found ~if_found ~key ~data arg1 arg2 = if_found ~key ~data arg1 arg2 in\n let call_if_not_found ~if_not_found key arg1 arg2 = if_not_found key arg1 arg2 in\n fun t ~compare k ~a ~b ~if_found ~if_not_found ->\n findi_and_call_impl\n t\n ~compare\n k\n a\n b\n ~call_if_found\n ~call_if_not_found\n ~if_found\n ~if_not_found\n;;\n\nlet find =\n let if_found v = Some v in\n let if_not_found _ = None in\n fun t ~compare k -> find_and_call t ~compare k ~if_found ~if_not_found\n;;\n\nlet mem =\n let if_found _ = true in\n let if_not_found _ = false in\n fun t ~compare k -> find_and_call t ~compare k ~if_found ~if_not_found\n;;\n\nlet remove =\n let rec min_elt tree =\n match tree with\n | Empty -> Empty\n | Leaf _ -> tree\n | Node { left = Empty; key = _; value = _; height = _; right = _ } -> tree\n | Node { left; key = _; value = _; height = _; right = _ } -> min_elt left\n in\n let rec remove_min_elt tree =\n match tree with\n | Empty -> assert false\n | Leaf _ -> Empty (* This must be the root *)\n | Node { left = Empty; key = _; value = _; height = _; right } -> right\n | Node { left = Leaf _; key = k; value = v; height = _; right = Empty } ->\n Leaf { key = k; value = v }\n | Node { left = Leaf _; key = _; value = _; height = _; right = _ } as node ->\n set_left node Empty;\n tree\n | Node { left; key = _; value = _; height = _; right = _ } as node ->\n set_left node (remove_min_elt left);\n tree\n in\n let merge t1 t2 =\n match t1, t2 with\n | Empty, t -> t\n | t, Empty -> t\n | _, _ ->\n let tree = min_elt t2 in\n (match tree with\n | Empty -> assert false\n | Leaf { key = k; value = v } ->\n let t2 = balance (remove_min_elt t2) in\n Node\n { left = t1\n ; key = k\n ; value = v\n ; height = Int.max (height t1) (height t2) + 1\n ; right = t2\n }\n | Node _ as node ->\n set_right node (remove_min_elt t2);\n set_left node t1;\n node)\n in\n let rec remove t removed compare k =\n match t with\n | Empty ->\n removed := false;\n Empty\n | Leaf { key = k'; value = _ } ->\n if compare k k' = 0\n then (\n removed := true;\n Empty)\n else (\n removed := false;\n t)\n | Node { left; key = k'; value = _; height = _; right } ->\n let c = compare k k' in\n if c = 0\n then (\n removed := true;\n merge left right)\n else if c < 0\n then (\n set_left t (remove left removed compare k);\n t)\n else (\n set_right t (remove right removed compare k);\n t)\n in\n fun t ~removed ~compare k -> balance (remove t removed compare k)\n;;\n\nlet rec fold t ~init ~f =\n match t with\n | Empty -> init\n | Leaf { key; value = data } -> f ~key ~data init\n | Node\n { left = Leaf { key = lkey; value = ldata }\n ; key\n ; value = data\n ; height = _\n ; right = Leaf { key = rkey; value = rdata }\n } -> f ~key:rkey ~data:rdata (f ~key ~data (f ~key:lkey ~data:ldata init))\n | Node\n { left = Leaf { key = lkey; value = ldata }\n ; key\n ; value = data\n ; height = _\n ; right = Empty\n } -> f ~key ~data (f ~key:lkey ~data:ldata init)\n | Node\n { left = Empty\n ; key\n ; value = data\n ; height = _\n ; right = Leaf { key = rkey; value = rdata }\n } -> f ~key:rkey ~data:rdata (f ~key ~data init)\n | Node\n { left; key; value = data; height = _; right = Leaf { key = rkey; value = rdata } }\n -> f ~key:rkey ~data:rdata (f ~key ~data (fold left ~init ~f))\n | Node\n { left = Leaf { key = lkey; value = ldata }; key; value = data; height = _; right }\n -> fold right ~init:(f ~key ~data (f ~key:lkey ~data:ldata init)) ~f\n | Node { left; key; value = data; height = _; right } ->\n fold right ~init:(f ~key ~data (fold left ~init ~f)) ~f\n;;\n\nlet rec iter t ~f =\n match t with\n | Empty -> ()\n | Leaf { key; value = data } -> f ~key ~data\n | Node { left; key; value = data; height = _; right } ->\n iter left ~f;\n f ~key ~data;\n iter right ~f\n;;\n\nlet rec mapi_inplace t ~f =\n match t with\n | Empty -> ()\n | Leaf ({ key; value } as t) -> t.value <- f ~key ~data:value\n | Node ({ left; key; value; height = _; right } as t) ->\n mapi_inplace ~f left;\n t.value <- f ~key ~data:value;\n mapi_inplace ~f right\n;;\n\nlet choose_exn = function\n | Empty -> raise_s (Sexp.message \"[Avltree.choose_exn] of empty hashtbl\" [])\n | Leaf { key; value; _ } | Node { key; value; _ } -> key, value\n;;\n","open! Import\nmodule Key = Hashtbl_intf.Key\n\nmodule type Accessors = sig\n include Container.Generic\n\n (** override [Container.Generic.mem] *)\n val mem : 'a t -> 'a -> bool\n\n (** preserves the equality function *)\n val copy : 'a t -> 'a t\n\n val add : 'a t -> 'a -> unit\n\n (** [strict_add t x] returns [Ok ()] if the [x] was not in [t], or an [Error] if it\n was. *)\n val strict_add : 'a t -> 'a -> unit Or_error.t\n\n val strict_add_exn : 'a t -> 'a -> unit\n val remove : 'a t -> 'a -> unit\n\n (** [strict_remove t x] returns [Ok ()] if the [x] was in [t], or an [Error] if it\n was not. *)\n val strict_remove : 'a t -> 'a -> unit Or_error.t\n\n val strict_remove_exn : 'a t -> 'a -> unit\n val clear : 'a t -> unit\n val equal : 'a t -> 'a t -> bool\n val filter : 'a t -> f:('a -> bool) -> 'a t\n val filter_inplace : 'a t -> f:('a -> bool) -> unit\n\n (** [inter t1 t2] computes the set intersection of [t1] and [t2]. Runs in O(min(length\n t1, length t2)). Behavior is undefined if [t1] and [t2] don't have the same\n equality function. *)\n val inter : 'key t -> 'key t -> 'key t\n\n val union : 'a t -> 'a t -> 'a t\n val diff : 'a t -> 'a t -> 'a t\n val of_hashtbl_keys : ('a, _) Hashtbl.t -> 'a t\n val to_hashtbl : 'key t -> f:('key -> 'data) -> ('key, 'data) Hashtbl.t\nend\n\ntype ('key, 'z) create_options = ('key, unit, 'z) Hashtbl_intf.create_options\n\ntype ('key, 'z) create_options_without_first_class_module =\n ('key, unit, 'z) Hashtbl_intf.create_options_without_first_class_module\n\nmodule type Creators = sig\n type 'a t\n\n val create\n : ?growth_allowed:bool (** defaults to [true] *)\n -> ?size:int (** initial size -- default 0 *)\n -> 'a Key.t\n -> 'a t\n\n val of_list\n : ?growth_allowed:bool (** defaults to [true] *)\n -> ?size:int (** initial size -- default 0 *)\n -> 'a Key.t\n -> 'a list\n -> 'a t\nend\n\nmodule type Creators_generic = sig\n type 'a t\n type 'a elt\n type ('a, 'z) create_options\n\n val create : ('a, unit -> 'a t) create_options\n val of_list : ('a, 'a elt list -> 'a t) create_options\nend\n\nmodule Check = struct\n module Make_creators_check\n (Type : T.T1)\n (Elt : T.T1)\n (Options : T.T2)\n (M : Creators_generic\n with type 'a t := 'a Type.t\n with type 'a elt := 'a Elt.t\n with type ('a, 'z) create_options := ('a, 'z) Options.t) =\n struct end\n\n module Check_creators_is_specialization_of_creators_generic (M : Creators) =\n Make_creators_check\n (struct\n type 'a t = 'a M.t\n end)\n (struct\n type 'a t = 'a\n end)\n (struct\n type ('a, 'z) t = ('a, 'z) create_options\n end)\n (struct\n include M\n\n let create ?growth_allowed ?size m () = create ?growth_allowed ?size m\n end)\nend\n\nmodule type Hash_set = sig\n type 'a t [@@deriving_inline sexp_of]\n\n val sexp_of_t : ('a -> Ppx_sexp_conv_lib.Sexp.t) -> 'a t -> Ppx_sexp_conv_lib.Sexp.t\n\n [@@@end]\n\n (** We use [[@@deriving sexp_of]] but not [[@@deriving sexp]] because we want people to be\n explicit about the hash and comparison functions used when creating hashtables. One\n can use [Hash_set.Poly.t], which does have [[@@deriving sexp]], to use polymorphic\n comparison and hashing. *)\n\n module Key = Key\n\n module type Creators = Creators\n module type Creators_generic = Creators_generic\n\n type nonrec ('key, 'z) create_options = ('key, 'z) create_options\n\n include Creators with type 'a t := 'a t (** @open *)\n\n module type Accessors = Accessors\n\n include Accessors with type 'a t := 'a t with type 'a elt = 'a (** @open *)\n\n val hashable_s : 'key t -> 'key Key.t\n\n type nonrec ('key, 'z) create_options_without_first_class_module =\n ('key, 'z) create_options_without_first_class_module\n\n (** A hash set that uses polymorphic comparison *)\n module Poly : sig\n type nonrec 'a t = 'a t [@@deriving_inline sexp]\n\n include Ppx_sexp_conv_lib.Sexpable.S1 with type 'a t := 'a t\n\n [@@@end]\n\n include\n Creators_generic\n with type 'a t := 'a t\n with type 'a elt = 'a\n with type ('key, 'z) create_options :=\n ('key, 'z) create_options_without_first_class_module\n\n include Accessors with type 'a t := 'a t with type 'a elt := 'a elt\n end\n\n (** [M] is meant to be used in combination with OCaml applicative functor types:\n\n {[\n type string_hash_set = Hash_set.M(String).t\n ]}\n\n which stands for:\n\n {[\n type string_hash_set = (String.t, int) Hash_set.t\n ]}\n\n The point is that [Hash_set.M(String).t] supports deriving, whereas the second\n syntax doesn't (because [t_of_sexp] doesn't know what comparison/hash function to\n use). *)\n module M (Elt : T.T) : sig\n type nonrec t = Elt.t t\n end\n\n module type Sexp_of_m = sig\n type t [@@deriving_inline sexp_of]\n\n val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t\n\n [@@@end]\n end\n\n module type M_of_sexp = sig\n type t [@@deriving_inline of_sexp]\n\n val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t\n\n [@@@end]\n\n include Hashtbl_intf.Key.S with type t := t\n end\n\n val sexp_of_m__t : (module Sexp_of_m with type t = 'elt) -> 'elt t -> Sexp.t\n val m__t_of_sexp : (module M_of_sexp with type t = 'elt) -> Sexp.t -> 'elt t\n\n module Creators (Elt : sig\n type 'a t\n\n val hashable : 'a t Hashable.t\n end) : sig\n type 'a t_ = 'a Elt.t t\n\n val t_of_sexp : (Sexp.t -> 'a Elt.t) -> Sexp.t -> 'a t_\n\n include\n Creators_generic\n with type 'a t := 'a t_\n with type 'a elt := 'a Elt.t\n with type ('elt, 'z) create_options :=\n ('elt, 'z) create_options_without_first_class_module\n end\n\n (**/**)\n\n (*_ See the Jane Street Style Guide for an explanation of [Private] submodules:\n\n https://opensource.janestreet.com/standards/#private-submodules *)\n module Private : sig\n val hashable : 'a t -> 'a Hashable.t\n end\nend\n","open! Import\ninclude Hash_set_intf\n\nlet hashable_s = Hashtbl.hashable_s\nlet hashable = Hashtbl.Private.hashable\nlet poly_hashable = Hashtbl.Poly.hashable\nlet with_return = With_return.with_return\n\ntype 'a t = ('a, unit) Hashtbl.t\ntype 'a hash_set = 'a t\ntype 'a elt = 'a\n\nmodule Accessors = struct\n let hashable = hashable\n let clear = Hashtbl.clear\n let length = Hashtbl.length\n let mem = Hashtbl.mem\n let is_empty t = Hashtbl.is_empty t\n\n let find_map t ~f =\n with_return (fun r ->\n Hashtbl.iter_keys t ~f:(fun elt ->\n match f elt with\n | None -> ()\n | Some _ as o -> r.return o);\n None)\n ;;\n\n let find t ~f = find_map t ~f:(fun a -> if f a then Some a else None)\n let add t k = Hashtbl.set t ~key:k ~data:()\n\n let strict_add t k =\n if mem t k\n then Or_error.error_string \"element already exists\"\n else (\n Hashtbl.set t ~key:k ~data:();\n Result.Ok ())\n ;;\n\n let strict_add_exn t k = Or_error.ok_exn (strict_add t k)\n let remove = Hashtbl.remove\n\n let strict_remove t k =\n if mem t k\n then (\n remove t k;\n Result.Ok ())\n else Or_error.error \"element not in set\" k (Hashtbl.sexp_of_key t)\n ;;\n\n let strict_remove_exn t k = Or_error.ok_exn (strict_remove t k)\n let fold t ~init ~f = Hashtbl.fold t ~init ~f:(fun ~key ~data:() acc -> f acc key)\n let iter t ~f = Hashtbl.iter_keys t ~f\n let count t ~f = Container.count ~fold t ~f\n let sum m t ~f = Container.sum ~fold m t ~f\n let min_elt t ~compare = Container.min_elt ~fold t ~compare\n let max_elt t ~compare = Container.max_elt ~fold t ~compare\n let fold_result t ~init ~f = Container.fold_result ~fold ~init ~f t\n let fold_until t ~init ~f = Container.fold_until ~fold ~init ~f t\n let to_list = Hashtbl.keys\n\n let sexp_of_t sexp_of_e t =\n sexp_of_list sexp_of_e (to_list t |> List.sort ~compare:(hashable t).compare)\n ;;\n\n let to_array t =\n let len = length t in\n let index = ref (len - 1) in\n fold t ~init:[||] ~f:(fun acc key ->\n if Array.length acc = 0\n then Array.create ~len key\n else (\n index := !index - 1;\n acc.(!index) <- key;\n acc))\n ;;\n\n let exists t ~f = Hashtbl.existsi t ~f:(fun ~key ~data:() -> f key)\n let for_all t ~f = not (Hashtbl.existsi t ~f:(fun ~key ~data:() -> not (f key)))\n let equal t1 t2 = Hashtbl.equal (fun () () -> true) t1 t2\n let copy t = Hashtbl.copy t\n let filter t ~f = Hashtbl.filteri t ~f:(fun ~key ~data:() -> f key)\n let union t1 t2 = Hashtbl.merge t1 t2 ~f:(fun ~key:_ _ -> Some ())\n let diff t1 t2 = filter t1 ~f:(fun key -> not (Hashtbl.mem t2 key))\n\n let inter t1 t2 =\n let smaller, larger = if length t1 > length t2 then t2, t1 else t1, t2 in\n Hashtbl.filteri smaller ~f:(fun ~key ~data:() -> Hashtbl.mem larger key)\n ;;\n\n let filter_inplace t ~f =\n let to_remove = fold t ~init:[] ~f:(fun ac x -> if f x then ac else x :: ac) in\n List.iter to_remove ~f:(fun x -> remove t x)\n ;;\n\n let of_hashtbl_keys hashtbl = Hashtbl.map hashtbl ~f:ignore\n let to_hashtbl t ~f = Hashtbl.mapi t ~f:(fun ~key ~data:() -> f key)\nend\n\ninclude Accessors\n\nlet create ?growth_allowed ?size m = Hashtbl.create ?growth_allowed ?size m\n\nlet of_list ?growth_allowed ?size m l =\n let size =\n match size with\n | Some x -> x\n | None -> List.length l\n in\n let t = Hashtbl.create ?growth_allowed ~size m in\n List.iter l ~f:(fun k -> add t k);\n t\n;;\n\nlet t_of_sexp m e_of_sexp sexp =\n match sexp with\n | Sexp.Atom _ -> of_sexp_error \"Hash_set.t_of_sexp requires a list\" sexp\n | Sexp.List list ->\n let t = create m ~size:(List.length list) in\n List.iter list ~f:(fun sexp ->\n let e = e_of_sexp sexp in\n match strict_add t e with\n | Ok () -> ()\n | Error _ -> of_sexp_error \"Hash_set.t_of_sexp got a duplicate element\" sexp);\n t\n;;\n\nmodule Creators (Elt : sig\n type 'a t\n\n val hashable : 'a t Hashable.t\n end) : sig\n type 'a t_ = 'a Elt.t t\n\n val t_of_sexp : (Sexp.t -> 'a Elt.t) -> Sexp.t -> 'a t_\n\n include\n Creators_generic\n with type 'a t := 'a t_\n with type 'a elt := 'a Elt.t\n with type ('elt, 'z) create_options :=\n ('elt, 'z) create_options_without_first_class_module\nend = struct\n type 'a t_ = 'a Elt.t t\n\n let create ?growth_allowed ?size () =\n create ?growth_allowed ?size (Hashable.to_key Elt.hashable)\n ;;\n\n let of_list ?growth_allowed ?size l =\n of_list ?growth_allowed ?size (Hashable.to_key Elt.hashable) l\n ;;\n\n let t_of_sexp e_of_sexp sexp = t_of_sexp (Hashable.to_key Elt.hashable) e_of_sexp sexp\nend\n\nmodule Poly = struct\n type 'a t = 'a hash_set\n type 'a elt = 'a\n\n let hashable = poly_hashable\n\n include Creators (struct\n type 'a t = 'a\n\n let hashable = hashable\n end)\n\n include Accessors\n\n let sexp_of_t = sexp_of_t\nend\n\nmodule M (Elt : T.T) = struct\n type nonrec t = Elt.t t\nend\n\nmodule type Sexp_of_m = sig\n type t [@@deriving_inline sexp_of]\n\n val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t\n\n [@@@end]\nend\n\nmodule type M_of_sexp = sig\n type t [@@deriving_inline of_sexp]\n\n val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t\n\n [@@@end]\n\n include Hashtbl_intf.Key.S with type t := t\nend\n\nlet sexp_of_m__t (type elt) (module Elt : Sexp_of_m with type t = elt) t =\n sexp_of_t Elt.sexp_of_t t\n;;\n\nlet m__t_of_sexp (type elt) (module Elt : M_of_sexp with type t = elt) sexp =\n t_of_sexp (module Elt) Elt.t_of_sexp sexp\n;;\n\nmodule Private = struct\n let hashable = Hashtbl.Private.hashable\nend\n","open! Import\nopen! Printf\nmodule Bytes = Bytes0\ninclude Float0\n\nlet raise_s = Error.raise_s\n\nmodule T = struct\n type t = float [@@deriving_inline hash, sexp, sexp_grammar]\n\n let (hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state) =\n hash_fold_float\n\n and (hash : t -> Ppx_hash_lib.Std.Hash.hash_value) =\n let func = hash_float in\n fun x -> func x\n ;;\n\n let t_of_sexp = (float_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t)\n let sexp_of_t = (sexp_of_float : t -> Ppx_sexp_conv_lib.Sexp.t)\n\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n let (_the_generic_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.generic_group) =\n { implicit_vars = [ \"float\" ]\n ; ggid = \"\\146e\\023\\249\\235eE\\139c\\132W\\195\\137\\129\\235\\025\"\n ; types = [ \"t\", Implicit_var 0 ]\n }\n in\n let (_the_group : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.group) =\n { gid = Ppx_sexp_conv_lib.Lazy_group_id.create ()\n ; apply_implicit = [ float_sexp_grammar ]\n ; generic_group = _the_generic_group\n ; origin = \"float.ml.T\"\n }\n in\n let (t_sexp_grammar : Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.t) =\n Ref (\"t\", _the_group)\n in\n t_sexp_grammar\n ;;\n\n [@@@end]\n\n let compare = Float_replace_polymorphic_compare.compare\nend\n\ninclude T\ninclude Comparator.Make (T)\n\n(* Open replace_polymorphic_compare after including functor instantiations so they do not\n shadow its definitions. This is here so that efficient versions of the comparison\n functions are available within this module. *)\nopen Float_replace_polymorphic_compare\n\nlet invariant (_ : t) = ()\nlet to_float x = x\nlet of_float x = x\n\nlet of_string s =\n try float_of_string s with\n | _ -> invalid_argf \"Float.of_string %s\" s ()\n;;\n\nexternal format_float : string -> float -> string = \"caml_format_float\"\n\n(* Stolen from [pervasives.ml]. Adds a \".\" at the end if needed. It is in\n [pervasives.mli], but it also says not to use it directly, so we copy and paste the\n code. It makes the assumption on the string passed in argument that it was returned by\n [format_float]. *)\nlet valid_float_lexem s =\n let l = String.length s in\n let rec loop i =\n if Int_replace_polymorphic_compare.( >= ) i l\n then s ^ \".\"\n else (\n match s.[i] with\n | '0' .. '9' | '-' -> loop (i + 1)\n | _ -> s)\n in\n loop 0\n;;\n\n(* Let [y] be a power of 2. Then the next representable float is:\n [z = y * (1 + 2 ** -52)]\n and the previous one is\n [x = y * (1 - 2 ** -53)]\n\n In general, every two adjacent floats are within a factor of between [1 + 2**-53]\n and [1 + 2**-52] from each other, that is within [1 + 1.1e-16] and [1 + 2.3e-16].\n\n So if the decimal representation of a float starts with \"1\", then its adjacent floats\n will usually differ from it by 1, and sometimes by 2, at the 17th significant digit\n (counting from 1).\n\n On the other hand, if the decimal representation starts with \"9\", then the adjacent\n floats will be off by no more than 23 at the 16th and 17th significant digits.\n\n E.g.:\n\n {v\n # sprintf \"%.17g\" (1024. *. (1. -. 2.** (-53.)));;\n 11111111\n 1234 5678901234567\n - : string = \"1023.9999999999999\"\n v}\n Printing a couple of extra digits reveals that the difference indeed is roughly 11 at\n digits 17th and 18th (that is, 13th and 14th after \".\"):\n\n {v\n # sprintf \"%.19g\" (1024. *. (1. -. 2.** (-53.)));;\n 1111111111\n 1234 567890123456789\n - : string = \"1023.999999999999886\"\n v}\n\n The ulp (the difference between adjacent floats) is twice as big on the other side of\n 1024.:\n\n {v\n # sprintf \"%.19g\" (1024. *. (1. +. 2.** (-52.)));;\n 1111111111\n 1234 567890123456789\n - : string = \"1024.000000000000227\"\n v}\n\n Now take a power of 2 which starts with 99:\n\n {v\n # 2.**93. ;;\n 1111111111\n 1 23456789012345678\n - : float = 9.9035203142830422e+27\n\n # 2.**93. *. (1. +. 2.** (-52.));;\n - : float = 9.9035203142830444e+27\n\n # 2.**93. *. (1. -. 2.** (-53.));;\n - : float = 9.9035203142830411e+27\n v}\n\n The difference between 2**93 and its two neighbors is slightly more than, respectively,\n 1 and 2 at significant digit 16.\n\n Those examples show that:\n - 17 significant digits is always sufficient to represent a float without ambiguity\n - 15th significant digit can always be represented accurately\n - converting a decimal number with 16 significant digits to its nearest float and back\n can change the last decimal digit by no more than 1\n\n To make sure that floats obtained by conversion from decimal fractions (e.g. \"3.14\")\n are printed without trailing non-zero digits, one should choose the first among the\n '%.15g', '%.16g', and '%.17g' representations which does round-trip:\n\n {v\n # sprintf \"%.15g\" 3.14;;\n - : string = \"3.14\" (* pick this one *)\n # sprintf \"%.16g\" 3.14;;\n - : string = \"3.14\"\n # sprintf \"%.17g\" 3.14;;\n - : string = \"3.1400000000000001\" (* do not pick this one *)\n\n # sprintf \"%.15g\" 8.000000000000002;;\n - : string = \"8\" (* do not pick this one--does not round-trip *)\n # sprintf \"%.16g\" 8.000000000000002;;\n - : string = \"8.000000000000002\" (* prefer this one *)\n # sprintf \"%.17g\" 8.000000000000002;;\n - : string = \"8.0000000000000018\" (* this one has one digit of junk at the end *)\n v}\n\n Skipping the '%.16g' in the above procedure saves us some time, but it means that, as\n seen in the second example above, occasionally numbers with exactly 16 significant\n digits will have an error introduced at the 17th digit. That is probably OK for\n typical use, because a number with 16 significant digits is \"ugly\" already. Adding one\n more doesn't make it much worse for a human reader.\n\n On the other hand, we cannot skip '%.15g' and only look at '%.16g' and '%.17g', since\n the inaccuracy at the 16th digit might introduce the noise we want to avoid:\n\n {v\n # sprintf \"%.15g\" 9.992;;\n - : string = \"9.992\" (* pick this one *)\n # sprintf \"%.16g\" 9.992;;\n - : string = \"9.992000000000001\" (* do not pick this one--junk at the end *)\n # sprintf \"%.17g\" 9.992;;\n - : string = \"9.9920000000000009\"\n v}\n*)\nlet to_string x =\n valid_float_lexem\n (let y = format_float \"%.15g\" x in\n if float_of_string y = x then y else format_float \"%.17g\" x)\n;;\n\nlet max_value = infinity\nlet min_value = neg_infinity\nlet min_positive_subnormal_value = 2. ** -1074.\nlet min_positive_normal_value = 2. ** -1022.\nlet zero = 0.\nlet one = 1.\nlet minus_one = -1.\nlet pi = 0x3.243F6A8885A308D313198A2E037073\nlet sqrt_pi = 0x1.C5BF891B4EF6AA79C3B0520D5DB938\nlet sqrt_2pi = 0x2.81B263FEC4E0B2CAF9483F5CE459DC\nlet euler = 0x0.93C467E37DB0C7A4D1BE3F810152CB\nlet of_int = Int.to_float\nlet to_int = Int.of_float\nlet of_int63 i = Int63.to_float i\nlet of_int64 i = Caml.Int64.to_float i\nlet to_int64 = Caml.Int64.of_float\nlet iround_lbound = lower_bound_for_int Int.num_bits\nlet iround_ubound = upper_bound_for_int Int.num_bits\n\n(* The performance of the \"exn\" rounding functions is important, so they are written\n out separately, and tuned individually. (We could have the option versions call\n the \"exn\" versions, but that imposes arguably gratuitous overhead---especially\n in the case where the capture of backtraces is enabled upon \"with\"---and that seems\n not worth it when compared to the relatively small amount of code duplication.) *)\n\n(* Error reporting below is very carefully arranged so that, e.g., [iround_nearest_exn]\n itself can be inlined into callers such that they don't need to allocate a box for the\n [float] argument. This is done with a box [box] function carefully chosen to allow the\n compiler to create a separate box for the float only in error cases. See, e.g.,\n [../../zero/test/price_test.ml] for a mechanical test of this property when building\n with [X_LIBRARY_INLINING=true]. *)\n\nlet iround_up t =\n if t > 0.0\n then (\n let t' = ceil t in\n if t' <= iround_ubound then Some (Int.of_float_unchecked t') else None)\n else if t >= iround_lbound\n then Some (Int.of_float_unchecked t)\n else None\n;;\n\nlet[@ocaml.inline always] iround_up_exn t =\n if t > 0.0\n then (\n let t' = ceil t in\n if t' <= iround_ubound\n then Int.of_float_unchecked t'\n else invalid_argf \"Float.iround_up_exn: argument (%f) is too large\" (box t) ())\n else if t >= iround_lbound\n then Int.of_float_unchecked t\n else invalid_argf \"Float.iround_up_exn: argument (%f) is too small or NaN\" (box t) ()\n;;\n\nlet iround_down t =\n if t >= 0.0\n then if t <= iround_ubound then Some (Int.of_float_unchecked t) else None\n else (\n let t' = floor t in\n if t' >= iround_lbound then Some (Int.of_float_unchecked t') else None)\n;;\n\nlet[@ocaml.inline always] iround_down_exn t =\n if t >= 0.0\n then\n if t <= iround_ubound\n then Int.of_float_unchecked t\n else invalid_argf \"Float.iround_down_exn: argument (%f) is too large\" (box t) ()\n else (\n let t' = floor t in\n if t' >= iround_lbound\n then Int.of_float_unchecked t'\n else\n invalid_argf \"Float.iround_down_exn: argument (%f) is too small or NaN\" (box t) ())\n;;\n\nlet iround_towards_zero t =\n if t >= iround_lbound && t <= iround_ubound\n then Some (Int.of_float_unchecked t)\n else None\n;;\n\nlet[@ocaml.inline always] iround_towards_zero_exn t =\n if t >= iround_lbound && t <= iround_ubound\n then Int.of_float_unchecked t\n else\n invalid_argf\n \"Float.iround_towards_zero_exn: argument (%f) is out of range or NaN\"\n (box t)\n ()\n;;\n\n(* Outside of the range (round_nearest_lb..round_nearest_ub), all representable doubles\n are integers in the mathematical sense, and [round_nearest] should be identity.\n\n However, for odd numbers with the absolute value between 2**52 and 2**53, the formula\n [round_nearest x = floor (x + 0.5)] does not hold:\n\n {v\n # let naive_round_nearest x = floor (x +. 0.5);;\n # let x = 2. ** 52. +. 1.;;\n val x : float = 4503599627370497.\n # naive_round_nearest x;;\n - : float = 4503599627370498.\n v}\n*)\n\nlet round_nearest_lb = -.(2. ** 52.)\nlet round_nearest_ub = 2. ** 52.\n\n(* For [x = one_ulp `Down 0.5], the formula [floor (x +. 0.5)] for rounding to nearest\n does not work, because the exact result is halfway between [one_ulp `Down 1.] and [1.],\n and it gets rounded up to [1.] due to the round-ties-to-even rule. *)\nlet one_ulp_less_than_half = one_ulp `Down 0.5\n\nlet add_half_for_round_nearest t =\n t\n +.\n if t = one_ulp_less_than_half\n then one_ulp_less_than_half (* since t < 0.5, make sure the result is < 1.0 *)\n else 0.5\n;;\n\nlet iround_nearest_32 t =\n if t >= 0.\n then (\n let t' = add_half_for_round_nearest t in\n if t' <= iround_ubound then Some (Int.of_float_unchecked t') else None)\n else (\n let t' = floor (t +. 0.5) in\n if t' >= iround_lbound then Some (Int.of_float_unchecked t') else None)\n;;\n\nlet iround_nearest_64 t =\n if t >= 0.\n then\n if t < round_nearest_ub\n then Some (Int.of_float_unchecked (add_half_for_round_nearest t))\n else if t <= iround_ubound\n then Some (Int.of_float_unchecked t)\n else None\n else if t > round_nearest_lb\n then Some (Int.of_float_unchecked (floor (t +. 0.5)))\n else if t >= iround_lbound\n then Some (Int.of_float_unchecked t)\n else None\n;;\n\nlet iround_nearest =\n match Word_size.word_size with\n | W64 -> iround_nearest_64\n | W32 -> iround_nearest_32\n;;\n\nlet iround_nearest_exn_32 t =\n if t >= 0.\n then (\n let t' = add_half_for_round_nearest t in\n if t' <= iround_ubound\n then Int.of_float_unchecked t'\n else invalid_argf \"Float.iround_nearest_exn: argument (%f) is too large\" (box t) ())\n else (\n let t' = floor (t +. 0.5) in\n if t' >= iround_lbound\n then Int.of_float_unchecked t'\n else invalid_argf \"Float.iround_nearest_exn: argument (%f) is too small\" (box t) ())\n;;\n\nlet[@ocaml.inline always] iround_nearest_exn_64 t =\n if t >= 0.\n then\n if t < round_nearest_ub\n then Int.of_float_unchecked (add_half_for_round_nearest t)\n else if t <= iround_ubound\n then Int.of_float_unchecked t\n else invalid_argf \"Float.iround_nearest_exn: argument (%f) is too large\" (box t) ()\n else if t > round_nearest_lb\n then Int.of_float_unchecked (floor (t +. 0.5))\n else if t >= iround_lbound\n then Int.of_float_unchecked t\n else\n invalid_argf \"Float.iround_nearest_exn: argument (%f) is too small or NaN\" (box t) ()\n;;\n\nlet iround_nearest_exn =\n match Word_size.word_size with\n | W64 -> iround_nearest_exn_64\n | W32 -> iround_nearest_exn_32\n;;\n\n(* The following [iround_exn] and [iround] functions are slower than the ones above.\n Their equivalence to those functions is tested in the unit tests below. *)\n\nlet[@inline] iround_exn ?(dir = `Nearest) t =\n match dir with\n | `Zero -> iround_towards_zero_exn t\n | `Nearest -> iround_nearest_exn t\n | `Up -> iround_up_exn t\n | `Down -> iround_down_exn t\n;;\n\nlet iround ?(dir = `Nearest) t =\n try Some (iround_exn ~dir t) with\n | _ -> None\n;;\n\nlet is_inf x =\n match classify_float x with\n | FP_infinite -> true\n | _ -> false\n;;\n\nlet min_inan (x : t) y =\n if is_nan y then x else if is_nan x then y else if x < y then x else y\n;;\n\nlet max_inan (x : t) y =\n if is_nan y then x else if is_nan x then y else if x > y then x else y\n;;\n\nlet add = ( +. )\nlet sub = ( -. )\nlet neg = ( ~-. )\nlet abs = abs_float\nlet scale = ( *. )\nlet square x = x *. x\n\nmodule Parts : sig\n type t\n\n val fractional : t -> float\n val integral : t -> float\n val modf : float -> t\nend = struct\n type t = float * float\n\n let fractional t = fst t\n let integral t = snd t\n let modf = modf\nend\n\nlet modf = Parts.modf\nlet round_down = floor\nlet round_up = ceil\nlet round_towards_zero t = if t >= 0. then round_down t else round_up t\n\n(* see the comment above [round_nearest_lb] and [round_nearest_ub] for an explanation *)\nlet round_nearest t =\n if t > round_nearest_lb && t < round_nearest_ub\n then floor (add_half_for_round_nearest t)\n else t +. 0.\n;;\n\nlet round_nearest_half_to_even t =\n if t <= round_nearest_lb || t >= round_nearest_ub\n then t +. 0.\n else (\n let floor = floor t in\n (* [ceil_or_succ = if t is an integer then t +. 1. else ceil t]. Faster than [ceil]. *)\n let ceil_or_succ = floor +. 1. in\n let diff_floor = t -. floor in\n let diff_ceil = ceil_or_succ -. t in\n if diff_floor < diff_ceil\n then floor\n else if diff_floor > diff_ceil\n then ceil_or_succ\n else if (* exact tie, pick the even *)\n mod_float floor 2. = 0.\n then floor\n else ceil_or_succ)\n;;\n\nlet int63_round_lbound = lower_bound_for_int Int63.num_bits\nlet int63_round_ubound = upper_bound_for_int Int63.num_bits\n\nlet int63_round_up_exn t =\n if t > 0.0\n then (\n let t' = ceil t in\n if t' <= int63_round_ubound\n then Int63.of_float_unchecked t'\n else\n invalid_argf\n \"Float.int63_round_up_exn: argument (%f) is too large\"\n (Float0.box t)\n ())\n else if t >= int63_round_lbound\n then Int63.of_float_unchecked t\n else\n invalid_argf\n \"Float.int63_round_up_exn: argument (%f) is too small or NaN\"\n (Float0.box t)\n ()\n;;\n\nlet int63_round_down_exn t =\n if t >= 0.0\n then\n if t <= int63_round_ubound\n then Int63.of_float_unchecked t\n else\n invalid_argf\n \"Float.int63_round_down_exn: argument (%f) is too large\"\n (Float0.box t)\n ()\n else (\n let t' = floor t in\n if t' >= int63_round_lbound\n then Int63.of_float_unchecked t'\n else\n invalid_argf\n \"Float.int63_round_down_exn: argument (%f) is too small or NaN\"\n (Float0.box t)\n ())\n;;\n\nlet int63_round_nearest_portable_alloc_exn t0 =\n let t = round_nearest t0 in\n if t > 0.\n then\n if t <= int63_round_ubound\n then Int63.of_float_unchecked t\n else\n invalid_argf\n \"Float.int63_round_nearest_portable_alloc_exn: argument (%f) is too large\"\n (box t0)\n ()\n else if t >= int63_round_lbound\n then Int63.of_float_unchecked t\n else\n invalid_argf\n \"Float.int63_round_nearest_portable_alloc_exn: argument (%f) is too small or NaN\"\n (box t0)\n ()\n;;\n\nlet int63_round_nearest_arch64_noalloc_exn f = Int63.of_int (iround_nearest_exn f)\n\nlet int63_round_nearest_exn =\n match Word_size.word_size with\n | W64 -> int63_round_nearest_arch64_noalloc_exn\n | W32 -> int63_round_nearest_portable_alloc_exn\n;;\n\nlet round ?(dir = `Nearest) t =\n match dir with\n | `Nearest -> round_nearest t\n | `Down -> round_down t\n | `Up -> round_up t\n | `Zero -> round_towards_zero t\n;;\n\nmodule Class = struct\n type t =\n | Infinite\n | Nan\n | Normal\n | Subnormal\n | Zero\n [@@deriving_inline compare, enumerate, sexp]\n\n let compare = (Ppx_compare_lib.polymorphic_compare : t -> t -> int)\n let all = ([ Infinite; Nan; Normal; Subnormal; Zero ] : t list)\n\n let t_of_sexp =\n (let _tp_loc = \"float.ml.Class.t\" in\n function\n | Ppx_sexp_conv_lib.Sexp.Atom (\"infinite\" | \"Infinite\") -> Infinite\n | Ppx_sexp_conv_lib.Sexp.Atom (\"nan\" | \"Nan\") -> Nan\n | Ppx_sexp_conv_lib.Sexp.Atom (\"normal\" | \"Normal\") -> Normal\n | Ppx_sexp_conv_lib.Sexp.Atom (\"subnormal\" | \"Subnormal\") -> Subnormal\n | Ppx_sexp_conv_lib.Sexp.Atom (\"zero\" | \"Zero\") -> Zero\n | Ppx_sexp_conv_lib.Sexp.List\n (Ppx_sexp_conv_lib.Sexp.Atom (\"infinite\" | \"Infinite\") :: _) as sexp ->\n Ppx_sexp_conv_lib.Conv_error.stag_no_args _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.List (Ppx_sexp_conv_lib.Sexp.Atom (\"nan\" | \"Nan\") :: _) as\n sexp -> Ppx_sexp_conv_lib.Conv_error.stag_no_args _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.List\n (Ppx_sexp_conv_lib.Sexp.Atom (\"normal\" | \"Normal\") :: _) as sexp ->\n Ppx_sexp_conv_lib.Conv_error.stag_no_args _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.List\n (Ppx_sexp_conv_lib.Sexp.Atom (\"subnormal\" | \"Subnormal\") :: _) as sexp ->\n Ppx_sexp_conv_lib.Conv_error.stag_no_args _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.List (Ppx_sexp_conv_lib.Sexp.Atom (\"zero\" | \"Zero\") :: _)\n as sexp -> Ppx_sexp_conv_lib.Conv_error.stag_no_args _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.List (Ppx_sexp_conv_lib.Sexp.List _ :: _) as sexp ->\n Ppx_sexp_conv_lib.Conv_error.nested_list_invalid_sum _tp_loc sexp\n | Ppx_sexp_conv_lib.Sexp.List [] as sexp ->\n Ppx_sexp_conv_lib.Conv_error.empty_list_invalid_sum _tp_loc sexp\n | sexp -> Ppx_sexp_conv_lib.Conv_error.unexpected_stag _tp_loc sexp\n : Ppx_sexp_conv_lib.Sexp.t -> t)\n ;;\n\n let sexp_of_t =\n (function\n | Infinite -> Ppx_sexp_conv_lib.Sexp.Atom \"Infinite\"\n | Nan -> Ppx_sexp_conv_lib.Sexp.Atom \"Nan\"\n | Normal -> Ppx_sexp_conv_lib.Sexp.Atom \"Normal\"\n | Subnormal -> Ppx_sexp_conv_lib.Sexp.Atom \"Subnormal\"\n | Zero -> Ppx_sexp_conv_lib.Sexp.Atom \"Zero\"\n : t -> Ppx_sexp_conv_lib.Sexp.t)\n ;;\n\n [@@@end]\n\n let to_string t = string_of_sexp (sexp_of_t t)\n let of_string s = t_of_sexp (sexp_of_string s)\nend\n\nlet classify t =\n let module C = Class in\n match classify_float t with\n | FP_normal -> C.Normal\n | FP_subnormal -> C.Subnormal\n | FP_zero -> C.Zero\n | FP_infinite -> C.Infinite\n | FP_nan -> C.Nan\n;;\n\nlet is_finite t = not (t = infinity || t = neg_infinity || is_nan t)\n\nlet insert_underscores ?(delimiter = '_') ?(strip_zero = false) string =\n match String.lsplit2 string ~on:'.' with\n | None -> Int_conversions.insert_delimiter string ~delimiter\n | Some (left, right) ->\n let left = Int_conversions.insert_delimiter left ~delimiter in\n let right =\n if strip_zero then String.rstrip right ~drop:(fun c -> Char.( = ) c '0') else right\n in\n (match right with\n | \"\" -> left\n | _ -> left ^ \".\" ^ right)\n;;\n\nlet to_string_hum ?delimiter ?(decimals = 3) ?strip_zero f =\n if Int_replace_polymorphic_compare.( < ) decimals 0\n then invalid_argf \"to_string_hum: invalid argument ~decimals=%d\" decimals ();\n match classify f with\n | Class.Infinite -> if f > 0. then \"inf\" else \"-inf\"\n | Class.Nan -> \"nan\"\n | Class.Normal | Class.Subnormal | Class.Zero ->\n insert_underscores (sprintf \"%.*f\" decimals f) ?delimiter ?strip_zero\n;;\n\nlet sexp_of_t t =\n let sexp = sexp_of_t t in\n match !Sexp.of_float_style with\n | `No_underscores -> sexp\n | `Underscores ->\n (match sexp with\n | List _ ->\n raise_s\n (Sexp.message\n \"[sexp_of_float] produced strange sexp\"\n [ \"sexp\", Sexp.sexp_of_t sexp ])\n | Atom string ->\n if String.contains string 'E' then sexp else Atom (insert_underscores string))\n;;\n\nlet to_padded_compact_string_custom t ?(prefix = \"\") ~kilo ~mega ~giga ~tera ?peta () =\n (* Round a ratio toward the nearest integer, resolving ties toward the nearest even\n number. For sane inputs (in particular, when [denominator] is an integer and\n [abs numerator < 2e52]) this should be accurate. Otherwise, the result might be a\n little bit off, but we don't really use that case. *)\n let iround_ratio_exn ~numerator ~denominator =\n let k = floor (numerator /. denominator) in\n (* if [abs k < 2e53], then both [k] and [k +. 1.] are accurately represented, and in\n particular [k +. 1. > k]. If [denominator] is also an integer, and\n [abs (denominator *. (k +. 1)) < 2e53] (and in some other cases, too), then [lower]\n and [higher] are actually both accurate. Since (roughly)\n [numerator = denominator *. k] then for [abs numerator < 2e52] we should be\n fine. *)\n let lower = denominator *. k in\n let higher = denominator *. (k +. 1.) in\n (* Subtracting numbers within a factor of two from each other is accurate.\n So either the two subtractions below are accurate, or k = 0, or k = -1.\n In case of a tie, round to even. *)\n let diff_right = higher -. numerator in\n let diff_left = numerator -. lower in\n let k = iround_nearest_exn k in\n if diff_right < diff_left\n then k + 1\n else if diff_right > diff_left\n then k\n else if (* a tie *)\n Int_replace_polymorphic_compare.( = ) (k mod 2) 0\n then k\n else k + 1\n in\n match classify t with\n | Class.Infinite -> if t < 0.0 then \"-inf \" else \"inf \"\n | Class.Nan -> \"nan \"\n | Class.Subnormal | Class.Normal | Class.Zero ->\n let go t =\n let conv_one t =\n assert (0. <= t && t < 999.95);\n let x = prefix ^ format_float \"%.1f\" t in\n (* Fix the \".0\" suffix *)\n if String.is_suffix x ~suffix:\".0\"\n then (\n let x = Bytes.of_string x in\n let n = Bytes.length x in\n Bytes.set x (n - 1) ' ';\n Bytes.set x (n - 2) ' ';\n Bytes.unsafe_to_string ~no_mutation_while_string_reachable:x)\n else x\n in\n let conv mag t denominator =\n assert (\n (denominator = 100. && t >= 999.95)\n || (denominator >= 100_000. && t >= round_nearest (denominator *. 9.999_5)));\n assert (t < round_nearest (denominator *. 9_999.5));\n let i, d =\n let k = iround_ratio_exn ~numerator:t ~denominator in\n (* [mod] is okay here because we know i >= 0. *)\n k / 10, k mod 10\n in\n let open Int_replace_polymorphic_compare in\n assert (0 <= i && i < 1000);\n assert (0 <= d && d < 10);\n if d = 0\n then sprintf \"%s%d%s \" prefix i mag\n else sprintf \"%s%d%s%d\" prefix i mag d\n in\n (* While the standard metric prefixes (e.g. capital \"M\" rather than \"m\", [1]) are\n nominally more correct, this hinders readability in our case. E.g., 10G6 and\n 1066 look too similar. That's an extreme example, but in general k,m,g,t,p\n probably stand out better than K,M,G,T,P when interspersed with digits.\n\n [1] http://en.wikipedia.org/wiki/Metric_prefix *)\n (* The trick here is that:\n - the first boundary (999.95) as a float is slightly over-represented (so it is\n better approximated as \"1k\" than as \"999.9\"),\n - the other boundaries are accurately represented, because they are integers.\n That's why the strict equalities below do exactly what we want. *)\n if t < 999.95E0\n then conv_one t\n else if t < 999.95E3\n then conv kilo t 100.\n else if t < 999.95E6\n then conv mega t 100_000.\n else if t < 999.95E9\n then conv giga t 100_000_000.\n else if t < 999.95E12\n then conv tera t 100_000_000_000.\n else (\n match peta with\n | None -> sprintf \"%s%.1e\" prefix t\n | Some peta ->\n if t < 999.95E15\n then conv peta t 100_000_000_000_000.\n else sprintf \"%s%.1e\" prefix t)\n in\n if t >= 0. then go t else \"-\" ^ go ~-.t\n;;\n\nlet to_padded_compact_string t =\n to_padded_compact_string_custom t ~kilo:\"k\" ~mega:\"m\" ~giga:\"g\" ~tera:\"t\" ~peta:\"p\" ()\n;;\n\n(* Performance note: Initializing the accumulator to 1 results in one extra\n multiply; e.g., to compute x ** 4, we in principle only need 2 multiplies,\n but this function will have 3 multiplies. However, attempts to avoid this\n (like decrementing n and initializing accum to be x, or handling small\n exponents as a special case) have not yielded anything that is a net\n improvement.\n*)\nlet int_pow x n =\n let open Int_replace_polymorphic_compare in\n if n = 0\n then 1.\n else (\n (* Using [x +. (-0.)] on the following line convinces the compiler to avoid a certain\n boxing (that would result in allocation in each iteration). Soon, the compiler\n shouldn't need this \"hint\" to avoid the boxing. The reason we add -0 rather than 0\n is that [x +. (-0.)] is apparently always the same as [x], whereas [x +. 0.] is\n not, in that it sends [-0.] to [0.]. This makes a difference because we want\n [int_pow (-0.) (-1)] to return neg_infinity just like [-0. ** -1.] would. *)\n let x = ref (x +. -0.) in\n let n = ref n in\n let accum = ref 1. in\n if !n < 0\n then (\n (* x ** n = (1/x) ** -n *)\n x := 1. /. !x;\n n := ~- (!n);\n if !n < 0\n then (\n (* n must have been min_int, so it is now so big that it has wrapped around.\n We decrement it so that it looks positive again, but accordingly have\n to put an extra factor of x in the accumulator.\n *)\n accum := !x;\n decr n));\n (* Letting [a] denote (the original value of) [x ** n], we maintain\n the invariant that [(x ** n) *. accum = a]. *)\n while !n > 1 do\n if !n land 1 <> 0 then accum := !x *. !accum;\n x := !x *. !x;\n n := !n lsr 1\n done;\n (* n is necessarily 1 at this point, so there is one additional\n multiplication by x. *)\n !x *. !accum)\n;;\n\nlet round_gen x ~how =\n if x = 0.\n then 0.\n else if not (is_finite x)\n then x\n else (\n (* Significant digits and decimal digits. *)\n let sd, dd =\n match how with\n | `significant_digits sd ->\n let dd = sd - to_int (round_up (log10 (abs x))) in\n sd, dd\n | `decimal_digits dd ->\n let sd = dd + to_int (round_up (log10 (abs x))) in\n sd, dd\n in\n let open Int_replace_polymorphic_compare in\n if sd < 0\n then 0.\n else if sd >= 17\n then x\n else (\n (* Choose the order that is exactly representable as a float. Small positive\n integers are, but their inverses in most cases are not. *)\n let abs_dd = Int.abs dd in\n if abs_dd > 22 || sd >= 16\n (* 10**22 is exactly representable as a float, but 10**23 is not, so use the slow\n path. Similarly, if we need 16 significant digits in the result, then the integer\n [round_nearest (x order)] might not be exactly representable as a float, since\n for some ranges we only have 15 digits of precision guaranteed.\n\n That said, we are still rounding twice here:\n\n 1) first time when rounding [x *. order] or [x /. order] to the nearest float\n (just the normal way floating-point multiplication or division works),\n\n 2) second time when applying [round_nearest_half_to_even] to the result of the\n above operation\n\n So for arguments within an ulp from a tie we might still produce an off-by-one\n result. *)\n then of_string (sprintf \"%.*g\" sd x)\n else (\n let order = int_pow 10. abs_dd in\n if dd >= 0\n then round_nearest_half_to_even (x *. order) /. order\n else round_nearest_half_to_even (x /. order) *. order)))\n;;\n\nlet round_significant x ~significant_digits =\n if Int_replace_polymorphic_compare.( <= ) significant_digits 0\n then\n invalid_argf\n \"Float.round_significant: invalid argument significant_digits:%d\"\n significant_digits\n ()\n else round_gen x ~how:(`significant_digits significant_digits)\n;;\n\nlet round_decimal x ~decimal_digits = round_gen x ~how:(`decimal_digits decimal_digits)\nlet between t ~low ~high = low <= t && t <= high\n\nlet clamp_exn t ~min ~max =\n (* Also fails if [min] or [max] is nan *)\n assert (min <= max);\n (* clamp_unchecked is in float0.ml *)\n clamp_unchecked t ~min ~max\n;;\n\nlet clamp t ~min ~max =\n (* Also fails if [min] or [max] is nan *)\n if min <= max\n then Ok (clamp_unchecked t ~min ~max)\n else\n Or_error.error_s\n (Sexp.message\n \"clamp requires [min <= max]\"\n [ \"min\", T.sexp_of_t min; \"max\", T.sexp_of_t max ])\n;;\n\nlet ( + ) = ( +. )\nlet ( - ) = ( -. )\nlet ( * ) = ( *. )\nlet ( ** ) = ( ** )\nlet ( / ) = ( /. )\nlet ( ~- ) = ( ~-. )\n\nlet sign_exn t : Sign.t =\n if t > 0.\n then Pos\n else if t < 0.\n then Neg\n else if t = 0.\n then Zero\n else Error.raise_s (Sexp.message \"Float.sign_exn of NAN\" [ \"\", sexp_of_t t ])\n;;\n\nlet sign_or_nan t : Sign_or_nan.t =\n if t > 0. then Pos else if t < 0. then Neg else if t = 0. then Zero else Nan\n;;\n\nlet ieee_negative t =\n let bits = Caml.Int64.bits_of_float t in\n Poly.(bits < Caml.Int64.zero)\n;;\n\nlet exponent_bits = 11\nlet mantissa_bits = 52\nlet exponent_mask64 = Int64.(shift_left one exponent_bits - one)\nlet exponent_mask = Int64.to_int_exn exponent_mask64\nlet mantissa_mask = Int63.(shift_left one mantissa_bits - one)\nlet mantissa_mask64 = Int63.to_int64 mantissa_mask\n\nlet ieee_exponent t =\n let bits = Caml.Int64.bits_of_float t in\n Int64.(bit_and (shift_right_logical bits mantissa_bits) exponent_mask64)\n |> Caml.Int64.to_int\n;;\n\nlet ieee_mantissa t =\n let bits = Caml.Int64.bits_of_float t in\n Int63.of_int64_exn Caml.Int64.(logand bits mantissa_mask64)\n;;\n\nlet create_ieee_exn ~negative ~exponent ~mantissa =\n if Int.(bit_and exponent exponent_mask <> exponent)\n then failwithf \"exponent %d out of range [0, %d]\" exponent exponent_mask ()\n else if Int63.(bit_and mantissa mantissa_mask <> mantissa)\n then\n failwithf\n \"mantissa %s out of range [0, %s]\"\n (Int63.to_string mantissa)\n (Int63.to_string mantissa_mask)\n ()\n else (\n let sign_bits = if negative then Caml.Int64.min_int else Caml.Int64.zero in\n let expt_bits = Caml.Int64.shift_left (Caml.Int64.of_int exponent) mantissa_bits in\n let mant_bits = Int63.to_int64 mantissa in\n let bits = Caml.Int64.(logor sign_bits (logor expt_bits mant_bits)) in\n Caml.Int64.float_of_bits bits)\n;;\n\nlet create_ieee ~negative ~exponent ~mantissa =\n Or_error.try_with (fun () -> create_ieee_exn ~negative ~exponent ~mantissa)\n;;\n\nmodule Terse = struct\n type nonrec t = t\n\n let t_of_sexp = t_of_sexp\n let to_string x = Printf.sprintf \"%.8G\" x\n let sexp_of_t x = Sexp.Atom (to_string x)\n let of_string x = of_string x\nend\n\nlet validate_ordinary t =\n Validate.of_error_opt\n (let module C = Class in\n match classify t with\n | C.Normal | C.Subnormal | C.Zero -> None\n | C.Infinite -> Some \"value is infinite\"\n | C.Nan -> Some \"value is NaN\")\n;;\n\nmodule V = struct\n module ZZ = Comparable.Validate (T)\n\n let validate_bound ~min ~max t =\n Validate.first_failure (validate_ordinary t) (ZZ.validate_bound t ~min ~max)\n ;;\n\n let validate_lbound ~min t =\n Validate.first_failure (validate_ordinary t) (ZZ.validate_lbound t ~min)\n ;;\n\n let validate_ubound ~max t =\n Validate.first_failure (validate_ordinary t) (ZZ.validate_ubound t ~max)\n ;;\nend\n\ninclude V\n\ninclude Comparable.With_zero (struct\n include T\n\n let zero = zero\n\n include V\n end)\n\n(* These are partly here as a performance hack to avoid some boxing we're getting with\n the versions we get from [With_zero]. They also make [Float.is_negative nan] and\n [Float.is_non_positive nan] return [false]; the versions we get from [With_zero] return\n [true]. *)\nlet is_positive t = t > 0.\nlet is_non_negative t = t >= 0.\nlet is_negative t = t < 0.\nlet is_non_positive t = t <= 0.\n\ninclude Pretty_printer.Register (struct\n include T\n\n let module_name = \"Base.Float\"\n let to_string = to_string\n end)\n\nmodule O = struct\n let ( + ) = ( + )\n let ( - ) = ( - )\n let ( * ) = ( * )\n let ( / ) = ( / )\n let ( ~- ) = ( ~- )\n let ( ** ) = ( ** )\n\n include (Float_replace_polymorphic_compare : Comparisons.Infix with type t := t)\n\n let abs = abs\n let neg = neg\n let zero = zero\n let of_int = of_int\n let of_float x = x\nend\n\nmodule O_dot = struct\n let ( *. ) = ( * )\n let ( +. ) = ( + )\n let ( -. ) = ( - )\n let ( /. ) = ( / )\n let ( ~-. ) = ( ~- )\n let ( **. ) = ( ** )\nend\n\nmodule Private = struct\n let box = box\n let clamp_unchecked = clamp_unchecked\n let lower_bound_for_int = lower_bound_for_int\n let upper_bound_for_int = upper_bound_for_int\n let specialized_hash = hash_float\n let one_ulp_less_than_half = one_ulp_less_than_half\n let int63_round_nearest_portable_alloc_exn = int63_round_nearest_portable_alloc_exn\n let int63_round_nearest_arch64_noalloc_exn = int63_round_nearest_arch64_noalloc_exn\n let iround_nearest_exn_64 = iround_nearest_exn_64\nend\n\n(* Include type-specific [Replace_polymorphic_compare] at the end, after\n including functor application that could shadow its definitions. This is\n here so that efficient versions of the comparison functions are exported by\n this module. *)\ninclude Float_replace_polymorphic_compare\n\n(* These functions specifically replace defaults in replace_polymorphic_compare.\n\n The desired behavior here is to propagate a nan if either argument is nan. Because the\n first comparison will always return false if either argument is nan, it suffices to\n check if x is nan. Then, when x is nan or both x and y are nan, we return x = nan; and\n when y is nan but not x, we return y = nan.\n\n There are various ways to implement these functions. The benchmark below shows a few\n different versions. This benchmark was run over an array of random floats (none of\n which are nan).\n\n ┌────────────────────────────────────────────────┬──────────┐\n │ Name │ Time/Run │\n ├────────────────────────────────────────────────┼──────────┤\n │ if is_nan x then x else if x < y then x else y │ 2.42us │\n │ if is_nan x || x < y then x else y │ 2.02us │\n │ if x < y || is_nan x then x else y │ 1.88us │\n └────────────────────────────────────────────────┴──────────┘\n\n The benchmark below was run when x > y is always true (again, no nan values).\n\n ┌────────────────────────────────────────────────┬──────────┐\n │ Name │ Time/Run │\n ├────────────────────────────────────────────────┼──────────┤\n │ if is_nan x then x else if x < y then x else y │ 2.83us │\n │ if is_nan x || x < y then x else y │ 1.97us │\n │ if x < y || is_nan x then x else y │ 1.56us │\n └────────────────────────────────────────────────┴──────────┘\n*)\nlet min (x : t) y = if x < y || is_nan x then x else y\nlet max (x : t) y = if x > y || is_nan x then x else y\n","open! Import\ninclude Buffer_intf\ninclude Caml.Buffer\n\nlet contents_bytes = to_bytes\nlet add_substring t s ~pos ~len = add_substring t s pos len\nlet add_subbytes t s ~pos ~len = add_subbytes t s pos len\nlet sexp_of_t t = sexp_of_string (contents t)\n\nmodule To_bytes =\n Blit.Make_distinct\n (struct\n type nonrec t = t\n\n let length = length\n end)\n (struct\n type t = Bytes.t\n\n let create ~len = Bytes.create len\n let length = Bytes.length\n\n let unsafe_blit ~src ~src_pos ~dst ~dst_pos ~len =\n Caml.Buffer.blit src src_pos dst dst_pos len\n ;;\n end)\n\ninclude To_bytes\nmodule To_string = Blit.Make_to_string (Caml.Buffer) (To_bytes)\n","open Base\n\ntype 'a test_pred\n = ?here:Lexing.position list\n -> ?message:string\n -> ('a -> bool)\n -> 'a\n -> unit\n\ntype 'a test_eq\n = ?here:Lexing.position list\n -> ?message:string\n -> ?equal:('a -> 'a -> bool)\n -> 'a\n -> 'a\n -> unit\n\ntype 'a test_result\n = ?here:Lexing.position list\n -> ?message:string\n -> ?equal:('a -> 'a -> bool)\n -> expect:'a\n -> 'a\n -> unit\n\nexception E of string * Sexp.t [@@deriving sexp]\n\nlet failwith message sexp = raise (E (message, sexp))\n\nlet fail_in_sexp_style ~message ~pos ~here ~tag body =\n let message =\n match message with\n | None -> tag\n | Some s -> s ^ \": \" ^ tag\n in\n let sexp =\n Sexp.List (\n body\n @ [ Sexp.List [ Sexp.Atom \"Loc\"; Sexp.Atom pos ] ]\n @ begin match here with\n | [] -> []\n | _ -> [ Sexp.List [ Sexp.Atom \"Stack\"\n ; [%sexp_of: Source_code_position.t list] here\n ] ]\n end\n )\n in\n failwith message sexp\n\nlet [@cold] test_pred_failed ~message ~pos ~here ~sexpifier t =\n fail_in_sexp_style ~message ~pos ~here ~tag:\"predicate failed\" [\n Sexp.List [Sexp.Atom \"Value\"; sexpifier t]\n ]\n\nlet test_pred ~pos ~sexpifier ~here ?message predicate t =\n if not (predicate t) then\n test_pred_failed ~message ~pos ~here ~sexpifier t\n\nlet r_diff : (from_:string -> to_:string -> unit) option ref = ref None\nlet set_diff_function f = r_diff := f\n\nlet [@cold] test_result_or_eq_failed ~sexpifier ~expect ~got =\n let got = sexpifier got in\n let expect = sexpifier expect in\n begin match !r_diff with\n | None -> ()\n | Some diff ->\n let from_ = Sexp.to_string_hum expect in\n let to_ = Sexp.to_string_hum got in\n diff ~from_ ~to_\n end;\n `Fail (expect, got)\n\nlet test_result_or_eq ~sexpifier ~comparator ?equal ~expect ~got =\n let pass =\n match equal with\n | None -> comparator got expect = 0\n | Some f -> f got expect\n in\n if pass\n then `Pass\n else test_result_or_eq_failed ~sexpifier ~expect ~got\n\nlet [@cold] test_eq_failed ~message ~pos ~here ~t1 ~t2 =\n fail_in_sexp_style ~message ~pos ~here ~tag:\"comparison failed\" [\n t1;\n Sexp.Atom \"vs\";\n t2;\n ]\n\nlet test_eq ~pos ~sexpifier ~comparator ~here ?message ?equal t1 t2 =\n match test_result_or_eq ~sexpifier ~comparator ?equal ~expect:t1 ~got:t2 with\n | `Pass -> ()\n | `Fail (t1, t2) -> test_eq_failed ~message ~pos ~here ~t1 ~t2\n\nlet [@cold] test_result_failed ~message ~pos ~here ~expect ~got =\n fail_in_sexp_style ~message ~pos ~here ~tag:\"got unexpected result\" [\n Sexp.List [Sexp.Atom \"expected\"; expect];\n Sexp.List [Sexp.Atom \"got\"; got];\n ]\n\nlet test_result ~pos ~sexpifier ~comparator ~here ?message ?equal ~expect ~got =\n match test_result_or_eq ~sexpifier ~comparator ?equal ~expect ~got with\n | `Pass -> ()\n | `Fail (expect, got) -> test_result_failed ~message ~pos ~here ~expect ~got\n","type t = string\n\n(* Share the digest of the empty string *)\nlet empty = Digest.string \"\"\nlet make s =\n if s = empty then\n empty\n else\n s\n\nlet compare = compare\n\nlet length = 16\n\nlet to_binary s = s\nlet of_binary_exn s = assert (String.length s = length); make s\nlet unsafe_of_binary = make\n\nlet to_hex = Digest.to_hex\nlet of_hex_exn s = make (Digest.from_hex s)\n\nlet string s = make (Digest.string s)\n\nlet bytes s = make (Digest.bytes s)\n\nlet subbytes bytes ~pos ~len = make (Digest.subbytes bytes pos len)\n","(* Common: common definitions used by binary protocol converters *)\n\nopen Base\nopen Printf\nopen Bigarray\n\ntype pos = int [@@deriving sexp_of]\n\n(* Errors and exceptions *)\n\nexception Buffer_short\nexception No_variant_match\n\nmodule ReadError = struct\n type t =\n | Neg_int8\n | Int_code\n | Int_overflow\n | Nat0_code\n | Nat0_overflow\n | Int32_code\n | Int64_code\n | Nativeint_code\n | Unit_code\n | Bool_code\n | Option_code\n | String_too_long\n | Variant_tag\n | Array_too_long\n | List_too_long of\n { len : int\n ; max_len : int\n }\n | Hashtbl_too_long\n | Sum_tag of string\n | Variant of string\n | Poly_rec_bound of string\n | Variant_wrong_type of string\n | Silly_type of string\n | Empty_type of string\n\n let to_string = function\n | Neg_int8 -> \"Neg_int8\"\n | Int_code -> \"Int_code\"\n | Int_overflow -> \"Int_overflow\"\n | Nat0_code -> \"Nat0_code\"\n | Nat0_overflow -> \"Nat0_overflow\"\n | Int32_code -> \"Int32_code\"\n | Int64_code -> \"Int64_code\"\n | Nativeint_code -> \"Nativeint_code\"\n | Unit_code -> \"Unit_code\"\n | Bool_code -> \"Bool_code\"\n | Option_code -> \"Option_code\"\n | String_too_long -> \"String_too_long\"\n | Variant_tag -> \"Variant_tag\"\n | Array_too_long -> \"Array_too_long\"\n | List_too_long { len; max_len } -> sprintf \"List_too_long / %d (max %d)\" len max_len\n | Hashtbl_too_long -> \"Hashtbl_too_long\"\n | Sum_tag loc -> \"Sum_tag / \" ^ loc\n | Variant loc -> \"Variant / \" ^ loc\n | Poly_rec_bound loc -> \"Poly_rec_bound / \" ^ loc\n | Variant_wrong_type loc -> \"Variant_wrong_type / \" ^ loc\n | Silly_type loc -> \"Silly_type / \" ^ loc\n | Empty_type loc -> \"Empty_type / \" ^ loc\n ;;\n\n let sexp_of_t t = Sexp.Atom (to_string t)\nend\n\nexception Read_error of ReadError.t * pos [@@deriving sexp_of]\nexception Poly_rec_write of string\nexception Empty_type of string\n\nlet raise_read_error err pos = raise (Read_error (err, pos))\n\nlet raise_variant_wrong_type name pos =\n raise (Read_error (ReadError.Variant_wrong_type name, pos))\n;;\n\nlet raise_concurrent_modification loc = failwith (loc ^ \": concurrent modification\")\nlet array_bound_error () = invalid_arg \"index out of bounds\"\n\n(* Buffers *)\n\ntype pos_ref = pos ref\ntype buf = (char, int8_unsigned_elt, c_layout) Array1.t\n\nlet create_buf n = Array1.create Bigarray.char c_layout n\nlet buf_len buf = Array1.dim buf\nlet assert_pos pos = if pos < 0 then array_bound_error ()\nlet check_pos (buf : buf) pos = if pos >= Array1.dim buf then raise Buffer_short\n\nlet safe_get_pos buf pos_ref =\n let pos = !pos_ref in\n check_pos buf pos;\n pos\n;;\n\nlet check_next (buf : buf) next = if next > Array1.dim buf then raise Buffer_short\n\nlet get_opt_pos ~loc ~var = function\n | Some pos ->\n if pos < 0 then invalid_arg (sprintf \"Bin_prot.Common.%s: %s < 0\" loc var);\n pos\n | None -> 0\n;;\n\nexternal unsafe_blit_buf\n : src_pos:int\n -> src:buf\n -> dst_pos:int\n -> dst:buf\n -> len:int\n -> unit\n = \"bin_prot_blit_buf_stub\"\n\nlet blit_buf ?src_pos ~src ?dst_pos ~dst len =\n let loc = \"blit_buf\" in\n let src_pos = get_opt_pos ~loc ~var:\"src_pos\" src_pos in\n let dst_pos = get_opt_pos ~loc ~var:\"dst_pos\" dst_pos in\n if len < 0\n then invalid_arg \"Bin_prot.Common.blit_buf: len < 0\"\n else if len = 0\n then (\n if src_pos > Array1.dim src\n then invalid_arg \"Bin_prot.Common.blit_buf: src_pos > src_len\";\n if dst_pos > Array1.dim dst\n then invalid_arg \"Bin_prot.Common.blit_buf: dst_pos > dst_len\")\n else if src_pos + len > Array1.dim src\n then invalid_arg \"Bin_prot.Common.blit_buf: src_pos + len > src_len\"\n else if dst_pos + len > Array1.dim dst\n then invalid_arg \"Bin_prot.Common.blit_buf: dst_pos + len > dst_len\"\n else unsafe_blit_buf ~src_pos ~src ~dst_pos ~dst ~len\n;;\n\nexternal unsafe_blit_string_buf\n : src_pos:int\n -> string\n -> dst_pos:int\n -> buf\n -> len:int\n -> unit\n = \"bin_prot_blit_string_buf_stub\"\n[@@noalloc]\n\nexternal unsafe_blit_bytes_buf\n : src_pos:int\n -> bytes\n -> dst_pos:int\n -> buf\n -> len:int\n -> unit\n = \"bin_prot_blit_bytes_buf_stub\"\n[@@noalloc]\n\nlet blit_string_buf ?src_pos str ?dst_pos buf ~len =\n let loc = \"blit_string_buf\" in\n let src_pos = get_opt_pos ~loc ~var:\"src_pos\" src_pos in\n let dst_pos = get_opt_pos ~loc ~var:\"dst_pos\" dst_pos in\n if len < 0\n then invalid_arg \"Bin_prot.Common.blit_string_buf: len < 0\"\n else if len = 0\n then (\n if src_pos > String.length str\n then invalid_arg \"Bin_prot.Common.blit_string_buf: src_pos > str_len\";\n if dst_pos > Array1.dim buf\n then invalid_arg \"Bin_prot.Common.blit_string_buf: src_pos > buf\")\n else if src_pos + len > String.length str\n then invalid_arg \"Bin_prot.Common.blit_string_buf: src_pos + len > str_len\"\n else if dst_pos + len > Array1.dim buf\n then invalid_arg \"Bin_prot.Common.blit_string_buf: src_pos + len > buf\"\n else unsafe_blit_string_buf ~src_pos str ~dst_pos buf ~len\n;;\n\nlet blit_bytes_buf ?src_pos str ?dst_pos buf ~len =\n let loc = \"blit_bytes_buf\" in\n let src_pos = get_opt_pos ~loc ~var:\"src_pos\" src_pos in\n let dst_pos = get_opt_pos ~loc ~var:\"dst_pos\" dst_pos in\n if len < 0\n then invalid_arg \"Bin_prot.Common.blit_bytes_buf: len < 0\"\n else if len = 0\n then (\n if src_pos > Bytes.length str\n then invalid_arg \"Bin_prot.Common.blit_bytes_buf: src_pos > str_len\";\n if dst_pos > Array1.dim buf\n then invalid_arg \"Bin_prot.Common.blit_bytes_buf: src_pos > buf\")\n else if src_pos + len > Bytes.length str\n then invalid_arg \"Bin_prot.Common.blit_bytes_buf: src_pos + len > str_len\"\n else if dst_pos + len > Array1.dim buf\n then invalid_arg \"Bin_prot.Common.blit_bytes_buf: src_pos + len > buf\"\n else unsafe_blit_bytes_buf ~src_pos str ~dst_pos buf ~len\n;;\n\nexternal unsafe_blit_buf_string\n : src_pos:int\n -> buf\n -> dst_pos:int\n -> bytes\n -> len:int\n -> unit\n = \"bin_prot_blit_buf_bytes_stub\"\n[@@noalloc]\n\nexternal unsafe_blit_buf_bytes\n : src_pos:int\n -> buf\n -> dst_pos:int\n -> bytes\n -> len:int\n -> unit\n = \"bin_prot_blit_buf_bytes_stub\"\n[@@noalloc]\n\nlet blit_buf_bytes ?src_pos buf ?dst_pos str ~len =\n let loc = \"blit_buf_string\" in\n let src_pos = get_opt_pos ~loc ~var:\"src_pos\" src_pos in\n let dst_pos = get_opt_pos ~loc ~var:\"dst_pos\" dst_pos in\n if len < 0\n then invalid_arg \"Bin_prot.Common.blit_buf_string: len < 0\"\n else if len = 0\n then (\n if src_pos > Array1.dim buf\n then invalid_arg \"Bin_prot.Common.blit_buf_string: src_pos > buf_len\";\n if dst_pos > Bytes.length str\n then invalid_arg \"Bin_prot.Common.blit_buf_string: src_pos > str_len\")\n else if src_pos + len > Array1.dim buf\n then invalid_arg \"Bin_prot.Common.blit_buf_string: src_pos + len > buf_len\"\n else if dst_pos + len > Bytes.length str\n then invalid_arg \"Bin_prot.Common.blit_buf_string: src_pos + len > str_len\"\n else unsafe_blit_buf_bytes ~src_pos buf ~dst_pos str ~len\n;;\n\nlet blit_buf_string = blit_buf_bytes\n\n(* Miscellaneous *)\n\nlet rec copy_htbl_list htbl = function\n | [] -> htbl\n | (k, v) :: rest ->\n Caml.Hashtbl.add htbl k v;\n copy_htbl_list htbl rest\n;;\n\n(* Bigarrays *)\n\ntype vec32 = (float, float32_elt, fortran_layout) Array1.t\ntype vec64 = (float, float64_elt, fortran_layout) Array1.t\ntype vec = vec64\ntype mat32 = (float, float32_elt, fortran_layout) Array2.t\ntype mat64 = (float, float64_elt, fortran_layout) Array2.t\ntype mat = mat64\n\n(* Float arrays *)\n\nexternal unsafe_blit_float_array_buf\n : src_pos:int\n -> float array\n -> dst_pos:int\n -> buf\n -> len:int\n -> unit\n = \"bin_prot_blit_float_array_buf_stub\"\n[@@noalloc]\n\nexternal unsafe_blit_buf_float_array\n : src_pos:int\n -> buf\n -> dst_pos:int\n -> float array\n -> len:int\n -> unit\n = \"bin_prot_blit_buf_float_array_stub\"\n[@@noalloc]\n\n(***)\n\nlet ( + ) = ( + )\n","open Core_kernel\n\nmodule type Nat_intf = Nat.Intf\n\ntype z = Nat.z\n\ntype 'a s = 'a Nat.s\n\nmodule T = struct\n type ('a, _) t = [] : ('a, z) t | ( :: ) : 'a * ('a, 'n) t -> ('a, 'n s) t\nend\n\ninclude T\n\nlet singleton a = [ a ]\n\nlet unsingleton (type a) ([ x ] : (a, z s) t) : a = x\n\nlet rec iter : type a n. (a, n) t -> f:(a -> unit) -> unit =\n fun t ~f -> match t with [] -> () | x :: xs -> f x ; iter xs ~f\n\nlet iteri (type a n) (t : (a, n) t) ~(f : int -> a -> unit) : unit =\n let rec go : type n. int -> (a, n) t -> unit =\n fun acc t ->\n match t with\n | [] ->\n ()\n | x :: xs ->\n f acc x ;\n go (acc + 1) xs\n in\n go 0 t\n\nlet rec length : type a n. (a, n) t -> n Nat.t = function\n | [] ->\n Z\n | _ :: xs ->\n S (length xs)\n\nlet nth v i =\n let rec loop : type a n. int -> (a, n) t -> a option =\n fun j -> function\n | [] ->\n None\n | x :: xs ->\n if Int.equal i j then Some x else loop (j + 1) xs\n in\n loop 0 v\n\nlet nth_exn v i =\n match nth v i with\n | None ->\n invalid_argf \"Vector.nth_exn %d called on a vector of length %d\" i\n (length v |> Nat.to_int)\n ()\n | Some e ->\n e\n\nlet rec iter2 : type a b n. (a, n) t -> (b, n) t -> f:(a -> b -> unit) -> unit =\n fun t1 t2 ~f ->\n match (t1, t2) with\n | [], [] ->\n ()\n | x :: xs, y :: ys ->\n f x y ; iter2 xs ys ~f\n\nlet rec map2 : type a b c n. (a, n) t -> (b, n) t -> f:(a -> b -> c) -> (c, n) t\n =\n fun t1 t2 ~f ->\n match (t1, t2) with\n | [], [] ->\n []\n | x :: xs, y :: ys ->\n f x y :: map2 xs ys ~f\n\nlet rec hhead_off :\n type xs n.\n (xs, n s) Hlist0.H1_1(T).t -> xs Hlist0.HlistId.t * (xs, n) Hlist0.H1_1(T).t\n =\n fun xss ->\n match xss with\n | [] ->\n ([], [])\n | (x :: xs) :: xss ->\n let hds, tls = hhead_off xss in\n (x :: hds, xs :: tls)\n\nlet rec mapn :\n type xs y n.\n (xs, n) Hlist0.H1_1(T).t -> f:(xs Hlist0.HlistId.t -> y) -> (y, n) t =\n fun xss ~f ->\n match xss with\n | [] :: _xss ->\n []\n | (_ :: _) :: _ ->\n let hds, tls = hhead_off xss in\n let y = f hds in\n let ys = mapn tls ~f in\n y :: ys\n | [] ->\n failwith \"mapn: Empty args\"\n\nlet rec nth : type a n. (a, n) t -> int -> a option =\n fun t idx ->\n match t with\n | [] ->\n None\n | x :: _ when idx = 0 ->\n Some x\n | _ :: t ->\n nth t (idx - 1)\n\nlet zip xs ys = map2 xs ys ~f:(fun x y -> (x, y))\n\nlet rec to_list : type a n. (a, n) t -> a list =\n fun t -> match t with [] -> [] | x :: xs -> x :: to_list xs\n\nlet sexp_of_t a _ v = List.sexp_of_t a (to_list v)\n\nlet to_array t = Array.of_list (to_list t)\n\nlet rec init : type a n. int -> n Nat.t -> f:(int -> a) -> (a, n) t =\n fun i n ~f -> match n with Z -> [] | S n -> f i :: init (i + 1) n ~f\n\nlet init n ~f = init 0 n ~f\n\nlet rec _fold_map :\n type acc a b n.\n (a, n) t -> f:(acc -> a -> acc * b) -> init:acc -> acc * (b, n) t =\n fun t ~f ~init ->\n match t with\n | [] ->\n (init, [])\n | x :: xs ->\n let acc, y = f init x in\n let res, ys = _fold_map xs ~f ~init:acc in\n (res, y :: ys)\n\nlet rec map : type a b n. (a, n) t -> f:(a -> b) -> (b, n) t =\n fun t ~f -> match t with [] -> [] | x :: xs -> f x :: map xs ~f\n\nlet mapi (type a b m) (t : (a, m) t) ~(f : int -> a -> b) =\n let rec go : type n. int -> (a, n) t -> (b, n) t =\n fun i t -> match t with [] -> [] | x :: xs -> f i x :: go (i + 1) xs\n in\n go 0 t\n\nlet unzip ts = (map ts ~f:fst, map ts ~f:snd)\n\ntype _ e = T : ('a, 'n) t -> 'a e\n\nlet rec of_list : type a. a list -> a e = function\n | [] ->\n T []\n | x :: xs ->\n let (T xs) = of_list xs in\n T (x :: xs)\n\nlet rec of_list_and_length_exn : type a n. a list -> n Nat.t -> (a, n) t =\n fun xs n ->\n match (xs, n) with\n | [], Z ->\n []\n | x :: xs, S n ->\n x :: of_list_and_length_exn xs n\n | [], S _ | _ :: _, Z ->\n failwith \"Vector: Length mismatch\"\n\nlet of_array_and_length_exn : type a n. a array -> n Nat.t -> (a, n) t =\n fun xs n ->\n if Array.length xs <> Nat.to_int n then\n failwithf \"of_array_and_length_exn: got %d (expected %d)\" (Array.length xs)\n (Nat.to_int n) () ;\n init n ~f:(Array.get xs)\n\nlet rec _take_from_list : type a n. a list -> n Nat.t -> (a, n) t =\n fun xs n ->\n match (xs, n) with\n | _, Z ->\n []\n | x :: xs, S n ->\n x :: _take_from_list xs n\n | [], S _ ->\n failwith \"take_from_list: Not enough to take\"\n\nlet rec fold : type acc a n. (a, n) t -> f:(acc -> a -> acc) -> init:acc -> acc\n =\n fun t ~f ~init ->\n match t with\n | [] ->\n init\n | x :: xs ->\n let acc = f init x in\n fold xs ~f ~init:acc\n\nlet for_all : type a n. (a, n) t -> f:(a -> bool) -> bool =\n fun v ~f ->\n with_return (fun { return } ->\n iter v ~f:(fun x -> if not (f x) then return false) ;\n true )\n\nlet foldi t ~f ~init =\n snd (fold t ~f:(fun (i, acc) x -> (i + 1, f i acc x)) ~init:(0, init))\n\nlet reduce_exn (type n) (t : (_, n) t) ~f =\n match t with\n | [] ->\n failwith \"reduce_exn: empty list\"\n | init :: xs ->\n fold xs ~f ~init\n\nmodule L = struct\n type 'a t = 'a list [@@deriving yojson]\nend\n\nmodule Make = struct\n module Cata (F : sig\n type _ t\n\n val pair : 'a t -> 'b t -> ('a * 'b) t\n\n val cnv : ('a -> 'b) -> ('b -> 'a) -> 'b t -> 'a t\n\n val unit : unit t\n end) =\n struct\n let rec f : type n a. n Nat.t -> a F.t -> (a, n) t F.t =\n fun n tc ->\n match n with\n | Z ->\n F.cnv (function [] -> ()) (fun () -> []) F.unit\n | S n ->\n let tl = f n tc in\n F.cnv\n (function x :: xs -> (x, xs))\n (fun (x, xs) -> x :: xs)\n (F.pair tc tl)\n end\n\n module Sexpable (N : Nat_intf) : Sexpable.S1 with type 'a t := ('a, N.n) t =\n struct\n let sexp_of_t f t = List.sexp_of_t f (to_list t)\n\n let t_of_sexp f s = of_list_and_length_exn (List.t_of_sexp f s) N.n\n end\n\n module Yojson (N : Nat_intf) :\n Sigs.Jsonable.S1 with type 'a t := ('a, N.n) t = struct\n let to_yojson f t = L.to_yojson f (to_list t)\n\n let of_yojson f s =\n Result.map (L.of_yojson f s) ~f:(Fn.flip of_list_and_length_exn N.n)\n end\n\n module Binable (N : Nat_intf) : Binable.S1 with type 'a t := ('a, N.n) t =\n struct\n open Bin_prot\n\n module Tc = Cata (struct\n type 'a t = 'a Type_class.t\n\n let pair = Type_class.bin_pair\n\n let cnv t = Type_class.cnv Fn.id t\n\n let unit = Type_class.bin_unit\n end)\n\n module Shape = Cata (struct\n type _ t = Shape.t\n\n let pair = Shape.bin_shape_pair\n\n let cnv _ _ = Fn.id\n\n let unit = Shape.bin_shape_unit\n end)\n\n module Size = Cata (struct\n type 'a t = 'a Size.sizer\n\n let pair = Size.bin_size_pair\n\n let cnv a_to_b _b_to_a b_sizer a = b_sizer (a_to_b a)\n\n let unit = Size.bin_size_unit\n end)\n\n module Write = Cata (struct\n type 'a t = 'a Write.writer\n\n let pair = Write.bin_write_pair\n\n let cnv a_to_b _b_to_a b_writer buf ~pos a = b_writer buf ~pos (a_to_b a)\n\n let unit = Write.bin_write_unit\n end)\n\n module Writer = Cata (struct\n type 'a t = 'a Type_class.writer\n\n let pair = Type_class.bin_writer_pair\n\n let cnv a_to_b _b_to_a b_writer = Type_class.cnv_writer a_to_b b_writer\n\n let unit = Type_class.bin_writer_unit\n end)\n\n module Reader = Cata (struct\n type 'a t = 'a Type_class.reader\n\n let pair = Type_class.bin_reader_pair\n\n let cnv _a_to_b b_to_a b_reader = Type_class.cnv_reader b_to_a b_reader\n\n let unit = Type_class.bin_reader_unit\n end)\n\n module Read = Cata (struct\n type 'a t = 'a Read.reader\n\n let pair = Read.bin_read_pair\n\n let cnv _a_to_b b_to_a b_reader buf ~pos_ref =\n b_to_a (b_reader buf ~pos_ref)\n\n let unit = Read.bin_read_unit\n end)\n\n let bin_shape_t sh = Shape.f N.n sh\n\n let bin_size_t sz = Size.f N.n sz\n\n let bin_write_t wr = Write.f N.n wr\n\n let bin_writer_t wr = Writer.f N.n wr\n\n let bin_t tc = Tc.f N.n tc\n\n let bin_reader_t re = Reader.f N.n re\n\n let bin_read_t re = Read.f N.n re\n\n let __bin_read_t__ _f _buf ~pos_ref _vint =\n Common.raise_variant_wrong_type \"vector\" !pos_ref\n end\nend\n\ntype ('a, 'n) vec = ('a, 'n) t\n\nmodule With_length (N : Nat.Intf) = struct\n type 'a t = ('a, N.n) vec\n\n let compare c t1 t2 = Base.List.compare c (to_list t1) (to_list t2)\n\n let hash_fold_t f s v = List.hash_fold_t f s (to_list v)\n\n let equal f t1 t2 = List.equal f (to_list t1) (to_list t2)\n\n include Make.Yojson (N)\n include Make.Sexpable (N)\n\n let map (t : 'a t) = map t\n\n let of_list_exn : 'a list -> 'a t = fun ls -> of_list_and_length_exn ls N.n\n\n let to_list : 'a t -> 'a list = to_list\nend\n\nlet rec typ' :\n type f var value n.\n ((var, value, f) Snarky_backendless.Typ.t, n) t\n -> ((var, n) t, (value, n) t, f) Snarky_backendless.Typ.t =\n let open Snarky_backendless.Typ in\n fun elts ->\n match elts with\n | elt :: elts ->\n let tl = typ' elts in\n let there = function x :: xs -> (x, xs) in\n let back (x, xs) = x :: xs in\n transport (elt * tl) ~there ~back |> transport_var ~there ~back\n | [] ->\n let there [] = () in\n let back () = [] in\n transport (unit ()) ~there ~back |> transport_var ~there ~back\n\nlet typ elt n = typ' (init n ~f:(fun _ -> elt))\n\nlet rec append :\n type n m n_m a. (a, n) t -> (a, m) t -> (n, m, n_m) Nat.Adds.t -> (a, n_m) t\n =\n fun t1 t2 adds ->\n match (t1, adds) with\n | [], Z ->\n t2\n | x :: t1, S adds ->\n x :: append t1 t2 adds\n\n(* TODO: Make more efficient *)\nlet rev (type a n) (xs : (a, n) t) : (a, n) t =\n of_list_and_length_exn\n (fold ~init:[] ~f:(fun acc x -> List.cons x acc) xs)\n (length xs)\n\nlet rec _last : type a n. (a, n s) t -> a = function\n | [ x ] ->\n x\n | _ :: (_ :: _ as xs) ->\n _last xs\n\nlet rec split :\n type n m n_m a. (a, n_m) t -> (n, m, n_m) Nat.Adds.t -> (a, n) t * (a, m) t\n =\n fun t adds ->\n match (t, adds) with\n | [], Z ->\n ([], [])\n | _ :: _, Z ->\n ([], t)\n | x :: t1, S adds ->\n let xs, ys = split t1 adds in\n (x :: xs, ys)\n\nlet rec transpose : type a n m. ((a, n) t, m) t -> ((a, m) t, n) t =\n fun xss ->\n match xss with\n | [] ->\n failwith \"transpose: empty list\"\n | [] :: _ ->\n []\n | (_ :: _) :: _ ->\n let heads, tails = unzip (map xss ~f:(fun (x :: xs) -> (x, xs))) in\n heads :: transpose tails\n\nlet rec trim : type a n m. (a, m) t -> (n, m) Nat.Lte.t -> (a, n) t =\n fun v p -> match (v, p) with _, Z -> [] | x :: xs, S p -> x :: trim xs p\n\nlet trim_front (type a n m) (v : (a, m) t) (p : (n, m) Nat.Lte.t) : (a, n) t =\n rev (trim (rev v) p)\n\nlet extend_front_exn : type n m a. (a, n) t -> m Nat.t -> a -> (a, m) t =\n fun v m dummy ->\n let v = to_array v in\n let n = Array.length v in\n let m' = Nat.to_int m in\n assert (n <= m') ;\n let padding = m' - n in\n init m ~f:(fun i -> if i < padding then dummy else v.(i - padding))\n\nlet rec extend_exn : type n m a. (a, n) t -> m Nat.t -> a -> (a, m) t =\n fun v m default ->\n match (v, m) with\n | [], Z ->\n []\n | [], S n ->\n default :: extend_exn [] n default\n | _x :: _xs, Z ->\n failwith \"extend_exn: list too long\"\n | x :: xs, S m ->\n let extended = extend_exn xs m default in\n x :: extended\n\nlet rec extend :\n type a n m. (a, n) t -> (n, m) Nat.Lte.t -> m Nat.t -> a -> (a, m) t =\n fun v p m default ->\n match (v, p, m) with\n | _, Z, Z ->\n []\n | _, Z, S m ->\n default :: extend [] Z m default\n | x :: xs, S p, S m ->\n x :: extend xs p m default\n\nlet extend_front :\n type a n m. (a, n) t -> (n, m) Nat.Lte.t -> m Nat.t -> a -> (a, m) t =\n fun v _p m default -> extend_front_exn v m default\n\nmodule type S = sig\n type 'a t [@@deriving compare, yojson, sexp, hash, equal]\n\n val map : 'a t -> f:('a -> 'b) -> 'b t\n\n val of_list_exn : 'a list -> 'a t\n\n val to_list : 'a t -> 'a list\nend\n\nmodule type VECTOR = sig\n type 'a t\n\n include S with type 'a t := 'a t\n\n module Stable : sig\n module V1 : sig\n include S with type 'a t = 'a t\n\n include Sigs.Binable.S1 with type 'a t = 'a t\n\n include Sigs.VERSIONED\n end\n end\nend\n\nmodule With_version (N : Nat.Intf) = struct\n module type S = sig\n [%%versioned:\n module Stable : sig\n module V1 : sig\n type 'a t = ('a, N.n) vec\n [@@deriving compare, yojson, sexp, hash, equal]\n end\n end]\n\n val map : 'a t -> f:('a -> 'b) -> 'b t\n\n val of_list_exn : 'a list -> 'a t\n\n val to_list : 'a t -> 'a list\n end\nend\n\nmodule Vector_2 = struct\n module T = With_length (Nat.N2)\n\n [%%versioned_binable\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n type 'a t = ('a, Nat.N2.n) vec\n\n include Make.Binable (Nat.N2)\n\n include (T : module type of T with type 'a t := 'a t)\n end\n end]\n\n include T\n\n let _type_equal : type a. (a t, a Stable.Latest.t) Type_equal.t = Type_equal.T\nend\n\nmodule Vector_4 = struct\n module T = With_length (Nat.N4)\n\n [%%versioned_binable\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n type 'a t = ('a, Nat.N4.n) vec\n\n include Make.Binable (Nat.N4)\n\n include (T : module type of T with type 'a t := 'a t)\n end\n end]\n\n include T\n\n let _type_equal : type a. (a t, a Stable.Latest.t) Type_equal.t = Type_equal.T\nend\n\nmodule Vector_5 = struct\n module T = With_length (Nat.N5)\n\n [%%versioned_binable\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n type 'a t = ('a, Nat.N5.n) vec\n\n include Make.Binable (Nat.N5)\n\n include (T : module type of T with type 'a t := 'a t)\n end\n end]\n\n include T\n\n let _type_equal : type a. (a t, a Stable.Latest.t) Type_equal.t = Type_equal.T\nend\n\nmodule Vector_6 = struct\n module T = With_length (Nat.N6)\n\n [%%versioned_binable\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n type 'a t = ('a, Nat.N6.n) vec\n\n include Make.Binable (Nat.N6)\n\n include (T : module type of T with type 'a t := 'a t)\n end\n end]\n\n include T\n\n let _type_equal : type a. (a t, a Stable.Latest.t) Type_equal.t = Type_equal.T\nend\n\nmodule Vector_7 = struct\n module T = With_length (Nat.N7)\n\n [%%versioned_binable\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n type 'a t = ('a, Nat.N7.n) vec\n\n include Make.Binable (Nat.N7)\n\n include (T : module type of T with type 'a t := 'a t)\n end\n end]\n\n include T\n\n let _type_equal : type a. (a t, a Stable.Latest.t) Type_equal.t = Type_equal.T\nend\n\nmodule Vector_8 = struct\n module T = With_length (Nat.N8)\n\n [%%versioned_binable\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n type 'a t = ('a, Nat.N8.n) vec\n\n include Make.Binable (Nat.N8)\n\n include (T : module type of T with type 'a t := 'a t)\n end\n end]\n\n include T\n\n let _type_equal : type a. (a t, a Stable.Latest.t) Type_equal.t = Type_equal.T\nend\n\nmodule Vector_15 = struct\n module T = With_length (Nat.N15)\n\n [%%versioned_binable\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n type 'a t = ('a, Nat.N15.n) vec\n\n include Make.Binable (Nat.N15)\n\n include (T : module type of T with type 'a t := 'a t)\n end\n end]\n\n include T\n\n let _type_equal : type a. (a t, a Stable.Latest.t) Type_equal.t = Type_equal.T\nend\n\nmodule Vector_16 = struct\n module T = With_length (Nat.N16)\n\n [%%versioned_binable\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n type 'a t = ('a, Nat.N16.n) vec\n\n include Make.Binable (Nat.N16)\n\n include (T : module type of T with type 'a t := 'a t)\n end\n end]\n\n include T\n\n let _type_equal : type a. (a t, a Stable.Latest.t) Type_equal.t = Type_equal.T\nend\n","(* Read_ml: reading values from the binary protocol using (mostly) OCaml. *)\n\n(* Note: the code is this file is carefully written to avoid unnecessary allocations. When\n touching this code, be sure to run the benchmarks to check for regressions. *)\n\nopen Bigarray\nopen Common\n\ntype 'a reader = buf -> pos_ref:pos_ref -> 'a\ntype ('a, 'b) reader1 = 'a reader -> 'b reader\ntype ('a, 'b, 'c) reader2 = 'a reader -> ('b, 'c) reader1\ntype ('a, 'b, 'c, 'd) reader3 = 'a reader -> ('b, 'c, 'd) reader2\n\nexternal unsafe_get : buf -> int -> char = \"%caml_ba_unsafe_ref_1\"\nexternal unsafe_get8 : buf -> int -> int = \"%caml_ba_unsafe_ref_1\"\n\nlet unsafe_get8_signed buf pos =\n let c = unsafe_get8 buf pos in\n if c >= 128 then c - 256 else c\n;;\n\n(*$ open Bin_prot_cinaps $*)\n\nlet arch_sixtyfour = Sys.word_size = 64\nlet arch_big_endian = Sys.big_endian\nlet max_int_int32 = if arch_sixtyfour then Int32.max_int else Int32.of_int max_int\nlet min_int_int32 = if arch_sixtyfour then Int32.max_int else Int32.of_int min_int\nlet max_int_int64 = Int64.of_int max_int\nlet min_int_int64 = Int64.of_int min_int\n\nlet safe_int_of_int32 pos x =\n if arch_sixtyfour\n then Int32.to_int x\n else if x >= min_int_int32 && x <= max_int_int32\n then Int32.to_int x\n else raise_read_error ReadError.Int_overflow pos\n;;\n\nlet safe_int_of_int64 pos x =\n if x >= min_int_int64 && x <= max_int_int64\n then Int64.to_int x\n else raise_read_error ReadError.Int_overflow pos\n;;\n\nlet safe_nativeint_of_int64 =\n if arch_sixtyfour\n then fun _pos x -> Int64.to_nativeint x\n else\n fun pos x ->\n if x >= Int64.of_nativeint Nativeint.min_int\n && x <= Int64.of_nativeint Nativeint.max_int\n then Int64.to_nativeint x\n else raise_read_error ReadError.Int_overflow pos\n;;\n\nexternal unsafe_get16 : buf -> int -> int = \"%caml_bigstring_get16u\"\nexternal unsafe_get32 : buf -> int -> int32 = \"%caml_bigstring_get32u\"\nexternal unsafe_get64 : buf -> int -> int64 = \"%caml_bigstring_get64u\"\nexternal bswap16 : int -> int = \"%bswap16\"\nexternal bswap32 : int32 -> int32 = \"%bswap_int32\"\nexternal bswap64 : int64 -> int64 = \"%bswap_int64\"\n\nlet unsafe_get16be_unsigned =\n if arch_big_endian\n then unsafe_get16\n else fun buf pos -> unsafe_get16 buf pos |> bswap16\n;;\n\nlet unsafe_get32be =\n if arch_big_endian\n then unsafe_get32\n else fun buf pos -> unsafe_get32 buf pos |> bswap32\n;;\n\nlet unsafe_get64be =\n if arch_big_endian\n then unsafe_get64\n else fun buf pos -> unsafe_get64 buf pos |> bswap64\n;;\n\nlet unsafe_get16le_unsigned =\n if arch_big_endian\n then fun buf pos -> unsafe_get16 buf pos |> bswap16\n else unsafe_get16\n;;\n\nlet unsafe_get32le =\n if arch_big_endian\n then fun buf pos -> unsafe_get32 buf pos |> bswap32\n else unsafe_get32\n;;\n\nlet unsafe_get64le =\n if arch_big_endian\n then fun buf pos -> unsafe_get64 buf pos |> bswap64\n else unsafe_get64\n;;\n\nlet unsafe_get16le_signed buf pos =\n let x = unsafe_get16le_unsigned buf pos in\n if x > 32767 then x - 65536 else x\n;;\n\nlet bin_read_unit buf ~pos_ref =\n let pos = safe_get_pos buf pos_ref in\n assert_pos pos;\n if unsafe_get buf pos = '\\000'\n then pos_ref := pos + 1\n else raise_read_error ReadError.Unit_code pos\n;;\n\nlet bin_read_bool buf ~pos_ref =\n let pos = safe_get_pos buf pos_ref in\n assert_pos pos;\n match unsafe_get buf pos with\n | '\\000' ->\n pos_ref := pos + 1;\n false\n | '\\001' ->\n pos_ref := pos + 1;\n true\n | _ -> raise_read_error ReadError.Bool_code pos\n;;\n\nlet safe_bin_read_neg_int8 buf ~pos_ref ~pos =\n let next = pos + 1 in\n check_next buf next;\n let n = unsafe_get8_signed buf pos in\n if n >= 0 then raise_read_error ReadError.Neg_int8 !pos_ref;\n pos_ref := next;\n n\n;;\n\nlet safe_bin_read_int16 buf ~pos_ref ~pos =\n let next = pos + 2 in\n check_next buf next;\n pos_ref := next;\n (* Can be above next line (no errors possible with 16bit).\n This should improve the generated code. *)\n unsafe_get16le_signed buf pos\n;;\n\nlet safe_bin_read_int32 buf ~pos_ref ~pos =\n let next = pos + 4 in\n check_next buf next;\n pos_ref := next;\n (* No error possible either. *)\n unsafe_get32le buf pos\n;;\n\nlet safe_bin_read_int64 buf ~pos_ref ~pos =\n let next = pos + 8 in\n check_next buf next;\n pos_ref := next;\n (* No error possible either. *)\n unsafe_get64le buf pos\n;;\n\nlet safe_bin_read_int32_as_int buf ~pos_ref ~pos =\n let next = pos + 4 in\n check_next buf next;\n let n = unsafe_get32le buf pos in\n let n = safe_int_of_int32 !pos_ref n in\n pos_ref := next;\n n\n;;\n\nlet safe_bin_read_int64_as_int buf ~pos_ref ~pos =\n let next = pos + 8 in\n check_next buf next;\n let n = unsafe_get64le buf pos in\n let n = safe_int_of_int64 !pos_ref n in\n pos_ref := next;\n n\n;;\n\nlet safe_bin_read_int32_as_int64 buf ~pos_ref ~pos =\n let next = pos + 4 in\n check_next buf next;\n pos_ref := next;\n let n = unsafe_get32le buf pos in\n Int64.of_int32 n\n;;\n\nlet safe_bin_read_int32_as_nativeint buf ~pos_ref ~pos =\n let next = pos + 4 in\n check_next buf next;\n pos_ref := next;\n let n = unsafe_get32le buf pos in\n Nativeint.of_int32 n\n;;\n\nlet safe_bin_read_int64_as_nativeint buf ~pos_ref ~pos =\n let next = pos + 8 in\n check_next buf next;\n let n = unsafe_get64le buf pos in\n let n = safe_nativeint_of_int64 pos n in\n pos_ref := next;\n n\n;;\n\nlet safe_bin_read_nat0_16 buf ~pos_ref ~pos =\n let next = pos + 2 in\n check_next buf next;\n pos_ref := next;\n Nat0.unsafe_of_int (unsafe_get16le_unsigned buf pos)\n;;\n\nlet safe_bin_read_nat0_32 =\n if arch_sixtyfour\n then (\n let mask_32bit = Int64.to_int 0xffff_ffffL in\n fun buf ~pos_ref ~pos ->\n let next = pos + 4 in\n check_next buf next;\n pos_ref := next;\n let n = Int32.to_int (unsafe_get32le buf pos) in\n if n >= 0\n then Nat0.unsafe_of_int n\n else\n (* Erase the upper bits that were set to 1 during the int32 -> int conversion. *)\n Nat0.unsafe_of_int (n land mask_32bit))\n else\n fun buf ~pos_ref ~pos ->\n let next = pos + 4 in\n check_next buf next;\n let n = unsafe_get32le buf pos in\n if n >= 0l && n <= max_int_int32\n then (\n let n = Nat0.unsafe_of_int (Int32.to_int n) in\n pos_ref := next;\n n)\n else raise_read_error ReadError.Nat0_overflow !pos_ref\n;;\n\nlet safe_bin_read_nat0_64 buf ~pos_ref ~pos =\n let next = pos + 8 in\n check_next buf next;\n let n = unsafe_get64le buf pos in\n if n >= 0L && n <= max_int_int64\n then (\n let n = Nat0.unsafe_of_int (Int64.to_int n) in\n pos_ref := next;\n n)\n else raise_read_error ReadError.Nat0_overflow !pos_ref\n;;\n\nlet bin_read_nat0 buf ~pos_ref =\n let pos = safe_get_pos buf pos_ref in\n assert_pos pos;\n match unsafe_get buf pos with\n | '\\x00'..'\\x7f' as ch ->\n pos_ref := pos + 1;\n Nat0.unsafe_of_int (Char.code ch)\n | (*$ Code.char INT16 *)'\\xfe'(*$*) ->\n safe_bin_read_nat0_16 buf ~pos_ref ~pos:(pos + 1)\n | (*$ Code.char INT32 *)'\\xfd'(*$*) ->\n safe_bin_read_nat0_32 buf ~pos_ref ~pos:(pos + 1)\n | (*$ Code.char INT64 *)'\\xfc'(*$*) ->\n if arch_sixtyfour then\n safe_bin_read_nat0_64 buf ~pos_ref ~pos:(pos + 1)\n else\n raise_read_error ReadError.Nat0_overflow pos\n | _ ->\n raise_read_error ReadError.Nat0_code pos\n[@@ocamlformat \"disable\"]\n\nlet bin_read_bytes buf ~pos_ref =\n let start_pos = !pos_ref in\n let len = (bin_read_nat0 buf ~pos_ref :> int) in\n if len > Sys.max_string_length\n then raise_read_error ReadError.String_too_long start_pos;\n let pos = !pos_ref in\n let next = pos + len in\n check_next buf next;\n pos_ref := next;\n let str = Bytes.create len in\n unsafe_blit_buf_bytes ~src_pos:pos buf ~dst_pos:0 str ~len;\n str\n;;\n\nlet bin_read_string buf ~pos_ref =\n let str = bin_read_bytes buf ~pos_ref in\n Bytes.unsafe_to_string str\n;;\n\nlet bin_read_char buf ~pos_ref =\n let pos = safe_get_pos buf pos_ref in\n assert_pos pos;\n pos_ref := pos + 1;\n unsafe_get buf pos\n;;\n\nlet bin_read_int buf ~pos_ref =\n let pos = safe_get_pos buf pos_ref in\n assert_pos pos;\n match unsafe_get buf pos with\n | '\\x00'..'\\x7f' as ch ->\n pos_ref := pos + 1;\n Char.code ch\n | (*$ Code.char NEG_INT8 *)'\\xff'(*$*) ->\n safe_bin_read_neg_int8 buf ~pos_ref ~pos:(pos + 1)\n | (*$ Code.char INT16 *)'\\xfe'(*$*) ->\n safe_bin_read_int16 buf ~pos_ref ~pos:(pos + 1)\n | (*$ Code.char INT32 *)'\\xfd'(*$*) ->\n safe_bin_read_int32_as_int buf ~pos_ref ~pos:(pos + 1)\n | (*$ Code.char INT64 *)'\\xfc'(*$*) ->\n if arch_sixtyfour then\n safe_bin_read_int64_as_int buf ~pos_ref ~pos:(pos + 1)\n else\n raise_read_error ReadError.Int_overflow pos\n | _ ->\n raise_read_error ReadError.Int_code pos\n[@@ocamlformat \"disable\"]\n\nlet bin_read_float buf ~pos_ref =\n let pos = safe_get_pos buf pos_ref in\n assert_pos pos;\n let next = pos + 8 in\n check_next buf next;\n pos_ref := next;\n (* No error possible either. *)\n Int64.float_of_bits (unsafe_get64le buf pos)\n;;\n\nlet bin_read_int32 buf ~pos_ref =\n let pos = safe_get_pos buf pos_ref in\n assert_pos pos;\n match unsafe_get buf pos with\n | '\\x00'..'\\x7f' as ch ->\n pos_ref := pos + 1;\n Int32.of_int (Char.code ch)\n | (*$ Code.char NEG_INT8 *)'\\xff'(*$*) ->\n Int32.of_int (safe_bin_read_neg_int8 buf ~pos_ref ~pos:(pos + 1))\n | (*$ Code.char INT16 *)'\\xfe'(*$*) ->\n Int32.of_int (safe_bin_read_int16 buf ~pos_ref ~pos:(pos + 1))\n | (*$ Code.char INT32 *)'\\xfd'(*$*) ->\n safe_bin_read_int32 buf ~pos_ref ~pos:(pos + 1)\n | _ ->\n raise_read_error ReadError.Int32_code pos\n[@@ocamlformat \"disable\"]\n\nlet bin_read_int64 buf ~pos_ref =\n let pos = safe_get_pos buf pos_ref in\n assert_pos pos;\n match unsafe_get buf pos with\n | '\\x00'..'\\x7f' as ch ->\n pos_ref := pos + 1;\n Int64.of_int (Char.code ch)\n | (*$ Code.char NEG_INT8 *)'\\xff'(*$*) ->\n Int64.of_int (safe_bin_read_neg_int8 buf ~pos_ref ~pos:(pos + 1))\n | (*$ Code.char INT16 *)'\\xfe'(*$*) ->\n Int64.of_int (safe_bin_read_int16 buf ~pos_ref ~pos:(pos + 1))\n | (*$ Code.char INT32 *)'\\xfd'(*$*) ->\n safe_bin_read_int32_as_int64 buf ~pos_ref ~pos:(pos + 1)\n | (*$ Code.char INT64 *)'\\xfc'(*$*) ->\n safe_bin_read_int64 buf ~pos_ref ~pos:(pos + 1)\n | _ ->\n raise_read_error ReadError.Int64_code pos\n[@@ocamlformat \"disable\"]\n\nlet bin_read_nativeint buf ~pos_ref =\n let pos = safe_get_pos buf pos_ref in\n assert_pos pos;\n match unsafe_get buf pos with\n | '\\x00'..'\\x7f' as ch ->\n pos_ref := pos + 1;\n Nativeint.of_int (Char.code ch)\n | (*$ Code.char NEG_INT8 *)'\\xff'(*$*) ->\n Nativeint.of_int (safe_bin_read_neg_int8 buf ~pos_ref ~pos:(pos + 1))\n | (*$ Code.char INT16 *)'\\xfe'(*$*) ->\n Nativeint.of_int (safe_bin_read_int16 buf ~pos_ref ~pos:(pos + 1))\n | (*$ Code.char INT32 *)'\\xfd'(*$*) ->\n safe_bin_read_int32_as_nativeint buf ~pos_ref ~pos:(pos + 1)\n | (*$ Code.char INT64 *)'\\xfc'(*$*) when arch_sixtyfour ->\n safe_bin_read_int64_as_nativeint buf ~pos_ref ~pos:(pos + 1)\n | _ ->\n raise_read_error ReadError.Nativeint_code pos\n[@@ocamlformat \"disable\"]\n\nlet bin_read_ref bin_read_el buf ~pos_ref =\n let el = bin_read_el buf ~pos_ref in\n ref el\n;;\n\nlet bin_read_lazy bin_read_el buf ~pos_ref =\n let el = bin_read_el buf ~pos_ref in\n Lazy.from_val el\n;;\n\nlet bin_read_option bin_read_el buf ~pos_ref =\n let pos = safe_get_pos buf pos_ref in\n assert_pos pos;\n match unsafe_get buf pos with\n | '\\000' ->\n pos_ref := pos + 1;\n None\n | '\\001' ->\n pos_ref := pos + 1;\n let el = bin_read_el buf ~pos_ref in\n Some el\n | _ -> raise_read_error ReadError.Option_code pos\n;;\n\nlet bin_read_pair bin_read_a bin_read_b buf ~pos_ref =\n let a = bin_read_a buf ~pos_ref in\n let b = bin_read_b buf ~pos_ref in\n a, b\n;;\n\nlet bin_read_triple bin_read_a bin_read_b bin_read_c buf ~pos_ref =\n let a = bin_read_a buf ~pos_ref in\n let b = bin_read_b buf ~pos_ref in\n let c = bin_read_c buf ~pos_ref in\n a, b, c\n;;\n\nlet bin_read_n_rev_list bin_read_el buf ~pos_ref len =\n let rec loop n acc =\n if n = 0 then acc else loop (n - 1) (bin_read_el buf ~pos_ref :: acc)\n in\n loop len []\n;;\n\nlet bin_read_list_with_max_len ~max_len bin_read_el buf ~pos_ref =\n let len = (bin_read_nat0 buf ~pos_ref :> int) in\n if len > max_len then raise_read_error (List_too_long { len; max_len }) !pos_ref;\n let rev_lst = bin_read_n_rev_list bin_read_el buf ~pos_ref len in\n List.rev rev_lst\n;;\n\nlet bin_read_list bin_read_el buf ~pos_ref =\n bin_read_list_with_max_len ~max_len:max_int bin_read_el buf ~pos_ref\n;;\n\nlet dummy_float_buf = create_buf 8\nlet () = ignore (Write.bin_write_float dummy_float_buf ~pos:0 3.1)\n\nlet max_float_array_length =\n if arch_sixtyfour then Sys.max_array_length else Sys.max_array_length / 2\n;;\n\nlet bin_read_float_array buf ~pos_ref =\n let pos = !pos_ref in\n let len = (bin_read_nat0 buf ~pos_ref :> int) in\n if len > max_float_array_length then raise_read_error ReadError.Array_too_long pos;\n let size = len * 8 in\n let pos = !pos_ref in\n let next = pos + size in\n check_next buf next;\n let arr = Array.create_float len in\n unsafe_blit_buf_float_array buf arr ~src_pos:pos ~dst_pos:0 ~len;\n pos_ref := next;\n arr\n;;\n\nlet bin_read_array (type a) bin_read_el buf ~pos_ref =\n if (Obj.magic (bin_read_el : a reader) : float reader) == bin_read_float\n then (Obj.magic (bin_read_float_array buf ~pos_ref : float array) : a array)\n else (\n let start_pos = !pos_ref in\n let len = (bin_read_nat0 buf ~pos_ref :> int) in\n if len = 0\n then [||]\n else (\n if arch_sixtyfour\n then (\n if len > Sys.max_array_length\n then raise_read_error ReadError.Array_too_long start_pos)\n else if len > Sys.max_array_length / 2\n then (\n let maybe_float =\n try\n let el = bin_read_el dummy_float_buf ~pos_ref:(ref 0) in\n Some el\n with\n | _ -> None\n in\n match maybe_float with\n | None ->\n if len > Sys.max_array_length\n then raise_read_error ReadError.Array_too_long start_pos\n | Some el ->\n if Obj.tag (Obj.repr el) = Obj.double_tag || len > Sys.max_array_length\n then raise_read_error ReadError.Array_too_long start_pos);\n let first = bin_read_el buf ~pos_ref in\n let res = Array.make len first in\n for i = 1 to len - 1 do\n let el = bin_read_el buf ~pos_ref in\n Array.unsafe_set res i el\n done;\n res))\n;;\n\nlet bin_read_hashtbl bin_read_key bin_read_val buf ~pos_ref =\n let len = (bin_read_nat0 buf ~pos_ref :> int) in\n let htbl = Hashtbl.create len in\n let read_kv_pair = bin_read_pair bin_read_key bin_read_val in\n let els = bin_read_n_rev_list read_kv_pair buf ~pos_ref len in\n copy_htbl_list htbl els\n;;\n\nexternal buf_of_vec32 : vec32 -> buf = \"%identity\"\nexternal buf_of_vec64 : vec64 -> buf = \"%identity\"\nexternal buf_of_mat32 : mat32 -> buf = \"%identity\"\nexternal buf_of_mat64 : mat64 -> buf = \"%identity\"\n\nlet bin_read_float32_vec buf ~pos_ref =\n let len = (bin_read_nat0 buf ~pos_ref :> int) in\n let size = len * 4 in\n let pos = !pos_ref in\n let next = pos + size in\n check_next buf next;\n let vec = Array1.create float32 fortran_layout len in\n unsafe_blit_buf ~src:buf ~src_pos:pos ~dst:(buf_of_vec32 vec) ~dst_pos:0 ~len:size;\n pos_ref := next;\n vec\n;;\n\nlet bin_read_float64_vec buf ~pos_ref =\n let len = (bin_read_nat0 buf ~pos_ref :> int) in\n let size = len * 8 in\n let pos = !pos_ref in\n let next = pos + size in\n check_next buf next;\n let vec = Array1.create float64 fortran_layout len in\n unsafe_blit_buf ~src:buf ~src_pos:pos ~dst:(buf_of_vec64 vec) ~dst_pos:0 ~len:size;\n pos_ref := next;\n vec\n;;\n\nlet bin_read_vec = bin_read_float64_vec\n\nlet bin_read_float32_mat buf ~pos_ref =\n let len1 = (bin_read_nat0 buf ~pos_ref :> int) in\n let len2 = (bin_read_nat0 buf ~pos_ref :> int) in\n let size = len1 * len2 * 4 in\n let pos = !pos_ref in\n let next = pos + size in\n check_next buf next;\n let mat = Array2.create float32 fortran_layout len1 len2 in\n unsafe_blit_buf ~src:buf ~src_pos:pos ~dst:(buf_of_mat32 mat) ~dst_pos:0 ~len:size;\n pos_ref := next;\n mat\n;;\n\nlet bin_read_float64_mat buf ~pos_ref =\n let len1 = (bin_read_nat0 buf ~pos_ref :> int) in\n let len2 = (bin_read_nat0 buf ~pos_ref :> int) in\n let size = len1 * len2 * 8 in\n let pos = !pos_ref in\n let next = pos + size in\n check_next buf next;\n let mat = Array2.create float64 fortran_layout len1 len2 in\n unsafe_blit_buf ~src:buf ~src_pos:pos ~dst:(buf_of_mat64 mat) ~dst_pos:0 ~len:size;\n pos_ref := next;\n mat\n;;\n\nlet bin_read_mat = bin_read_float64_mat\n\nlet bin_read_bigstring buf ~pos_ref =\n let len = (bin_read_nat0 buf ~pos_ref :> int) in\n let pos = !pos_ref in\n let next = pos + len in\n check_next buf next;\n let str = create_buf len in\n unsafe_blit_buf ~src:buf ~src_pos:pos ~dst:str ~dst_pos:0 ~len;\n pos_ref := next;\n str\n;;\n\nlet bin_read_variant_int buf ~pos_ref =\n let pos = !pos_ref in\n assert_pos pos;\n let next = pos + 4 in\n check_next buf next;\n let n = unsafe_get32le buf pos in\n (* [n] must contain an integer already encoded, i.e. [n = 2 * k + 1]. *)\n if Int32.logand n 1l = 0l\n then raise (Read_error (ReadError.Variant_tag, pos))\n else (\n (* We shift it by one bit to the right se we get back [2 * k + 1] in the end. *)\n pos_ref := next;\n Int32.to_int (Int32.shift_right n 1))\n;;\n\nlet bin_read_int_8bit buf ~pos_ref =\n let pos = safe_get_pos buf pos_ref in\n assert_pos pos;\n pos_ref := pos + 1;\n unsafe_get8 buf pos\n;;\n\nlet bin_read_int_16bit buf ~pos_ref =\n let pos = !pos_ref in\n assert_pos pos;\n let next = pos + 2 in\n check_next buf next;\n pos_ref := next;\n unsafe_get16le_unsigned buf pos\n;;\n\nlet bin_read_int_32bit buf ~pos_ref =\n let pos = !pos_ref in\n assert_pos pos;\n let next = pos + 4 in\n check_next buf next;\n pos_ref := next;\n let n = unsafe_get32le buf pos in\n safe_int_of_int32 pos n\n;;\n\nlet bin_read_int_64bit buf ~pos_ref =\n let pos = !pos_ref in\n assert_pos pos;\n let next = pos + 8 in\n check_next buf next;\n pos_ref := next;\n let n = unsafe_get64le buf pos in\n safe_int_of_int64 pos n\n;;\n\nlet bin_read_int64_bits buf ~pos_ref =\n let pos = !pos_ref in\n assert_pos pos;\n let next = pos + 8 in\n check_next buf next;\n pos_ref := next;\n unsafe_get64le buf pos\n;;\n\nlet bin_read_network16_int buf ~pos_ref =\n let pos = !pos_ref in\n assert_pos pos;\n let next = pos + 2 in\n check_next buf next;\n pos_ref := next;\n unsafe_get16be_unsigned buf pos\n;;\n\nlet bin_read_network32_int buf ~pos_ref =\n let pos = !pos_ref in\n assert_pos pos;\n let next = pos + 4 in\n check_next buf next;\n pos_ref := next;\n let n = unsafe_get32be buf pos in\n safe_int_of_int32 pos n\n;;\n\nlet bin_read_network32_int32 buf ~pos_ref =\n let pos = !pos_ref in\n assert_pos pos;\n let next = pos + 4 in\n check_next buf next;\n pos_ref := next;\n unsafe_get32be buf pos\n;;\n\nlet bin_read_network64_int buf ~pos_ref =\n let pos = !pos_ref in\n assert_pos pos;\n let next = pos + 8 in\n check_next buf next;\n pos_ref := next;\n let n = unsafe_get64be buf pos in\n safe_int_of_int64 pos n\n;;\n\nlet bin_read_network64_int64 buf ~pos_ref =\n let pos = !pos_ref in\n assert_pos pos;\n let next = pos + 8 in\n check_next buf next;\n pos_ref := next;\n unsafe_get64be buf pos\n;;\n\n[%%if\n ocaml_version < (4, 07, 0)]\n\nexternal unsafe_bytes_set32 : bytes -> int -> int32 -> unit = \"%caml_string_set32u\"\nexternal unsafe_bytes_set64 : bytes -> int -> int64 -> unit = \"%caml_string_set64u\"\n\n[%%else]\n\nexternal unsafe_bytes_set32 : bytes -> int -> int32 -> unit = \"%caml_bytes_set32u\"\nexternal unsafe_bytes_set64 : bytes -> int -> int64 -> unit = \"%caml_bytes_set64u\"\n\n[%%endif]\n\nlet bin_read_md5 buf ~pos_ref =\n let pos = !pos_ref in\n assert_pos pos;\n let next = pos + 16 in\n check_next buf next;\n pos_ref := next;\n let res = Bytes.create 16 in\n if arch_sixtyfour\n then (\n let a = unsafe_get64 buf pos in\n let b = unsafe_get64 buf (pos + 8) in\n unsafe_bytes_set64 res 0 a;\n unsafe_bytes_set64 res 8 b)\n else (\n let a = unsafe_get32 buf pos in\n let b = unsafe_get32 buf (pos + 4) in\n let c = unsafe_get32 buf (pos + 8) in\n let d = unsafe_get32 buf (pos + 12) in\n unsafe_bytes_set32 res 0 a;\n unsafe_bytes_set32 res 4 b;\n unsafe_bytes_set32 res 8 c;\n unsafe_bytes_set32 res 12 d);\n Md5_lib.unsafe_of_binary (Bytes.unsafe_to_string res)\n;;\n","include Bin_shape_lib.Std.Shape\n\n(* new base shapes *)\nlet bin_shape_unit = basetype (Uuid.of_string \"unit\") []\nlet bin_shape_bool = basetype (Uuid.of_string \"bool\") []\nlet bin_shape_string = basetype (Uuid.of_string \"string\") []\nlet bin_shape_bytes = basetype (Uuid.of_string \"bytes\") []\nlet bin_shape_char = basetype (Uuid.of_string \"char\") []\nlet bin_shape_float = basetype (Uuid.of_string \"float\") []\nlet bin_shape_int = basetype (Uuid.of_string \"int\") []\nlet bin_shape_int32 = basetype (Uuid.of_string \"int32\") []\nlet bin_shape_int63 = basetype (Uuid.of_string \"int63\") []\nlet bin_shape_int64 = basetype (Uuid.of_string \"int64\") []\nlet bin_shape_nativeint = basetype (Uuid.of_string \"nativeint\") []\nlet bin_shape_nat0 = basetype (Uuid.of_string \"nat0\") []\nlet bin_shape_digest = basetype (Uuid.of_string \"digest\") []\nlet bin_shape_float32_vec = basetype (Uuid.of_string \"float32_vec\") []\nlet bin_shape_float64_vec = basetype (Uuid.of_string \"float64_vec\") []\nlet bin_shape_vec = basetype (Uuid.of_string \"vec\") []\nlet bin_shape_float32_mat = basetype (Uuid.of_string \"float32_mat\") []\nlet bin_shape_float64_mat = basetype (Uuid.of_string \"float64_mat\") []\nlet bin_shape_mat = basetype (Uuid.of_string \"mat\") []\nlet bin_shape_bigstring = basetype (Uuid.of_string \"bigstring\") []\nlet bin_shape_variant_int = basetype (Uuid.of_string \"variant_int\") []\nlet bin_shape_int_8bit = basetype (Uuid.of_string \"int_8bit\") []\nlet bin_shape_int_16bit = basetype (Uuid.of_string \"int_16bit\") []\nlet bin_shape_int_32bit = basetype (Uuid.of_string \"int_32bit\") []\nlet bin_shape_int_64bit = basetype (Uuid.of_string \"int_64bit\") []\nlet bin_shape_int64_bits = basetype (Uuid.of_string \"int64_bits\") []\nlet bin_shape_network16_int = basetype (Uuid.of_string \"network16_int\") []\nlet bin_shape_network32_int = basetype (Uuid.of_string \"network32_int\") []\nlet bin_shape_network32_int32 = basetype (Uuid.of_string \"network32_int32\") []\nlet bin_shape_network64_int = basetype (Uuid.of_string \"network64_int\") []\nlet bin_shape_network64_int64 = basetype (Uuid.of_string \"network64_int64\") []\n\n(* new shape constructors *)\nlet bin_shape_ref x = basetype (Uuid.of_string \"ref\") [ x ]\nlet bin_shape_option x = basetype (Uuid.of_string \"option\") [ x ]\nlet bin_shape_list x = basetype (Uuid.of_string \"list\") [ x ]\nlet bin_shape_array x = basetype (Uuid.of_string \"array\") [ x ]\nlet bin_shape_hashtbl x y = basetype (Uuid.of_string \"hashtbl\") [ x; y ]\n\n(* shape alias *)\nlet bin_shape_float_array = bin_shape_array bin_shape_float\n\n(* shape-constructor aliases *)\nlet bin_shape_lazy x = x\nlet bin_shape_pair x y = tuple [ x; y ]\nlet bin_shape_triple x y z = tuple [ x; y; z ]\n","(* Size: compute size of values in the binary protocol. *)\n\nopen Bigarray\n\nlet arch_sixtyfour = Sys.word_size = 64\n\nopen Common\n\nmodule Maximum = struct\n let bin_size_unit = 1\n let bin_size_bool = 1\n let bin_size_char = 1\n let bin_size_md5 = 16\n let bin_size_int_nat0 = if arch_sixtyfour then 9 else 5\n let bin_size_int_negative = if arch_sixtyfour then 9 else 5\n let bin_size_int = max bin_size_int_nat0 bin_size_int_negative\n let bin_size_float = 8\n let bin_size_int32 = 5\n let bin_size_int64 = 9\n let bin_size_nativeint = bin_size_int\n let bin_size_nat0 = bin_size_int_nat0\n let bin_size_variant_int = 4\n let bin_size_int_8bit = 1\n let bin_size_int_16bit = 2\n let bin_size_int_32bit = 4\n let bin_size_int_64bit = 8\n let bin_size_int64_bits = 8\n let bin_size_network16_int = 2\n let bin_size_network32_int = 4\n let bin_size_network32_int32 = 4\n let bin_size_network64_int = 8\n let bin_size_network64_int64 = 8\nend\n\nmodule Minimum = struct\n let bin_size_unit = Maximum.bin_size_unit\n let bin_size_bool = Maximum.bin_size_bool\n let bin_size_char = Maximum.bin_size_char\n let bin_size_md5 = 16\n let bin_size_int_nat0 = 1\n let bin_size_int_negative = 2\n let bin_size_int = min bin_size_int_nat0 bin_size_int_negative\n let bin_size_float = Maximum.bin_size_float\n let bin_size_int32 = bin_size_int\n let bin_size_int64 = bin_size_int\n let bin_size_nativeint = bin_size_int\n let bin_size_nat0 = 1\n let bin_size_ref = 1\n let bin_size_lazy_t = 1\n let bin_size_option = 1\n let bin_size_pair = 1 + 1\n let bin_size_triple = 1 + 1 + 1\n let bin_size_len = bin_size_nat0\n let bin_size_list = bin_size_len\n let bin_size_array = bin_size_len\n let bin_size_hashtbl = bin_size_len\n let bin_size_string = bin_size_len\n let bin_size_bytes = bin_size_len\n let bin_size_vec = bin_size_len\n let bin_size_float32_vec = bin_size_vec\n let bin_size_float64_vec = bin_size_vec\n let bin_size_mat = bin_size_len + bin_size_len\n let bin_size_float32_mat = bin_size_mat\n let bin_size_float64_mat = bin_size_mat\n let bin_size_bigstring = bin_size_len\n let bin_size_float_array = bin_size_len\n let bin_size_variant_int = Maximum.bin_size_variant_int\n let bin_size_int_8bit = Maximum.bin_size_int_8bit\n let bin_size_int_16bit = Maximum.bin_size_int_16bit\n let bin_size_int_32bit = Maximum.bin_size_int_32bit\n let bin_size_int_64bit = Maximum.bin_size_int_64bit\n let bin_size_int64_bits = Maximum.bin_size_int64_bits\n let bin_size_network16_int = Maximum.bin_size_network16_int\n let bin_size_network32_int = Maximum.bin_size_network32_int\n let bin_size_network32_int32 = Maximum.bin_size_network32_int32\n let bin_size_network64_int = Maximum.bin_size_network64_int\n let bin_size_network64_int64 = Maximum.bin_size_network64_int64\nend\n\ntype 'a sizer = 'a -> int\ntype ('a, 'b) sizer1 = 'a sizer -> 'b sizer\ntype ('a, 'b, 'c) sizer2 = 'a sizer -> ('b, 'c) sizer1\ntype ('a, 'b, 'c, 'd) sizer3 = 'a sizer -> ('b, 'c, 'd) sizer2\n\nlet bin_size_unit () = 1\nlet bin_size_bool _ = 1\n\nlet bin_size_int_nat0 n =\n if n < 0x00000080\n then 1\n else if n < 0x00008000\n then 3\n else if arch_sixtyfour && n >= (* 0x80000000 *) 1 lsl 31\n then 9\n else 5\n;;\n\nlet bin_size_int_negative n =\n if n >= -0x00000080\n then 2\n else if n >= -0x00008000\n then 3\n else if arch_sixtyfour && n < (* -0x80000000 *) -(1 lsl 31)\n then 9\n else 5\n;;\n\nlet bin_size_char _ = 1\nlet bin_size_int n = if n >= 0 then bin_size_int_nat0 n else bin_size_int_negative n\n\nlet bin_size_nat0 nat0 =\n let n = (nat0 : Nat0.t :> int) in\n if n < 0x00000080\n then 1\n else if n < 0x00010000\n then 3\n else if arch_sixtyfour && n >= (* 0x100000000 *) 1 lsl 32\n then 9\n else 5\n;;\n\nlet bin_size_string_or_bytes len =\n let plen = Nat0.unsafe_of_int len in\n let size_len = bin_size_nat0 plen in\n size_len + len\n;;\n\nlet bin_size_string str = bin_size_string_or_bytes (String.length str)\nlet bin_size_bytes str = bin_size_string_or_bytes (Bytes.length str)\nlet bin_size_md5 _ = 16\n\nlet bin_size_float f =\n (* If we just ignore the argument the compiler will still require it to exist and be\n boxed. This means that if for instance we call this for a field of a float record,\n the compiler will allocate the float for nothing.\n\n With this line the compiler really ignores the float. *)\n ignore (truncate f);\n 8\n;;\n\nlet bin_size_int32 =\n if arch_sixtyfour\n then fun n -> bin_size_int (Int32.to_int n)\n else\n fun n ->\n if n >= 0x00008000l || n < -0x00008000l then 5 else bin_size_int (Int32.to_int n)\n;;\n\nlet bin_size_int64 =\n if arch_sixtyfour\n then\n fun n ->\n if n >= 0x80000000L || n < -0x80000000L then 9 else bin_size_int (Int64.to_int n)\n else\n fun n ->\n if n >= 0x80000000L || n < -0x80000000L then 9 else bin_size_int32 (Int64.to_int32 n)\n;;\n\nlet bin_size_nativeint =\n if arch_sixtyfour\n then fun n -> bin_size_int64 (Int64.of_nativeint n)\n else fun n -> bin_size_int32 (Nativeint.to_int32 n)\n;;\n\nlet bin_size_ref bin_size_el r = bin_size_el !r\nlet bin_size_lazy_t bin_size_el lv = bin_size_el (Lazy.force lv)\nlet bin_size_lazy = bin_size_lazy_t\n\nlet bin_size_option bin_size_el = function\n | None -> 1\n | Some v -> 1 + bin_size_el v\n;;\n\nlet bin_size_pair bin_size_a bin_size_b (a, b) = bin_size_a a + bin_size_b b\n\nlet bin_size_triple bin_size_a bin_size_b bin_size_c (a, b, c) =\n bin_size_a a + bin_size_b b + bin_size_c c\n;;\n\nlet bin_size_list bin_size_el lst =\n let rec loop len = function\n | [] -> len\n | h :: t -> loop (len + bin_size_el h) t\n in\n let len = Nat0.unsafe_of_int (List.length lst) in\n let size_len = bin_size_nat0 len in\n loop size_len lst\n;;\n\nlet bin_size_len len =\n let plen = Nat0.unsafe_of_int len in\n bin_size_nat0 plen\n;;\n\nlet bin_size_float_array ar =\n let len = Array.length ar in\n bin_size_len len + (8 * len)\n;;\n\nlet bin_size_array_loop bin_size_el ar ~total_len ~n =\n let total_len_ref = ref total_len in\n for i = 0 to n - 1 do\n let el = Array.unsafe_get ar i in\n total_len_ref := !total_len_ref + bin_size_el el\n done;\n !total_len_ref\n;;\n\nlet bin_size_array (type a) bin_size_el ar =\n if (Obj.magic (bin_size_el : a sizer) : float sizer) == bin_size_float\n then bin_size_float_array (Obj.magic (ar : a array) : float array)\n else (\n let n = Array.length ar in\n let total_len = bin_size_len n in\n bin_size_array_loop bin_size_el ar ~total_len ~n)\n;;\n\nlet bin_size_hashtbl bin_size_key bin_size_val htbl =\n let cnt_ref = ref 0 in\n let coll_htbl k v total_len =\n incr cnt_ref;\n total_len + bin_size_key k + bin_size_val v\n in\n let len = Hashtbl.length htbl in\n let total_len = Hashtbl.fold coll_htbl htbl (bin_size_len len) in\n if !cnt_ref <> len then raise_concurrent_modification \"bin_size_hashtbl\";\n total_len\n;;\n\nlet bin_size_gen_vec vec multiplier =\n let len = Array1.dim vec in\n bin_size_len len + (multiplier * len)\n;;\n\nlet bin_size_float32_vec vec = bin_size_gen_vec vec 4\nlet bin_size_float64_vec vec = bin_size_gen_vec vec 8\nlet bin_size_vec = bin_size_float64_vec\n\nlet bin_size_gen_mat mat multiplier =\n let dim1 = Array2.dim1 mat in\n let dim2 = Array2.dim2 mat in\n let size = dim1 * dim2 in\n bin_size_len dim1 + bin_size_len dim2 + (multiplier * size)\n;;\n\nlet bin_size_float32_mat mat = bin_size_gen_mat mat 4\nlet bin_size_float64_mat mat = bin_size_gen_mat mat 8\nlet bin_size_mat = bin_size_float64_mat\nlet bin_size_bigstring buf = bin_size_gen_vec buf 1\nlet bin_size_variant_int _ = 4\nlet bin_size_int_8bit _ = 1\nlet bin_size_int_16bit _ = 2\nlet bin_size_int_32bit _ = 4\nlet bin_size_int_64bit _ = 8\nlet bin_size_int64_bits _ = 8\nlet bin_size_network16_int _ = 2\nlet bin_size_network32_int _ = 4\nlet bin_size_network32_int32 _ = 4\nlet bin_size_network64_int _ = 8\nlet bin_size_network64_int64 _ = 8\n\nlet bin_size_array_no_length bin_size_el ar =\n bin_size_array_loop bin_size_el ar ~total_len:0 ~n:(Array.length ar)\n;;\n","(* Tp_class: sizers, writers, and readers in records *)\n\ntype 'a writer =\n { size : 'a Size.sizer\n ; write : 'a Write.writer\n }\n\ntype 'a reader =\n { read : 'a Read.reader\n ; vtag_read : (int -> 'a) Read.reader\n }\n\ntype 'a t =\n { shape : Shape.t\n ; writer : 'a writer\n ; reader : 'a reader\n }\n\ntype 'a writer0 = 'a writer\ntype 'a reader0 = 'a reader\ntype 'a t0 = 'a t\n\nmodule S1 = struct\n type ('a, 'b) writer = 'a writer0 -> 'b writer0\n type ('a, 'b) reader = 'a reader0 -> 'b reader0\n type ('a, 'b) t = 'a t0 -> 'b t0\nend\n\nmodule S2 = struct\n type ('a, 'b, 'c) writer = 'a writer0 -> ('b, 'c) S1.writer\n type ('a, 'b, 'c) reader = 'a reader0 -> ('b, 'c) S1.reader\n type ('a, 'b, 'c) t = 'a t0 -> ('b, 'c) S1.t\nend\n\nmodule S3 = struct\n type ('a, 'b, 'c, 'd) writer = 'a writer0 -> ('b, 'c, 'd) S2.writer\n type ('a, 'b, 'c, 'd) reader = 'a reader0 -> ('b, 'c, 'd) S2.reader\n type ('a, 'b, 'c, 'd) t = 'a t0 -> ('b, 'c, 'd) S2.t\nend\n\nlet variant_wrong_type name _buf ~pos_ref _x =\n Common.raise_variant_wrong_type name !pos_ref\n;;\n\n(*$ open Bin_prot_cinaps.Str *)\n(*$ mk_base \"unit\" *)\nlet bin_writer_unit = { size = Size.bin_size_unit; write = Write.bin_write_unit }\n\nlet bin_reader_unit =\n { read = Read.bin_read_unit; vtag_read = variant_wrong_type \"unit\" }\n;;\n\nlet bin_shape_unit = Shape.bin_shape_unit\n\nlet bin_unit =\n { shape = bin_shape_unit; writer = bin_writer_unit; reader = bin_reader_unit }\n;;\n\n(*$ mk_base \"bool\" *)\nlet bin_writer_bool = { size = Size.bin_size_bool; write = Write.bin_write_bool }\n\nlet bin_reader_bool =\n { read = Read.bin_read_bool; vtag_read = variant_wrong_type \"bool\" }\n;;\n\nlet bin_shape_bool = Shape.bin_shape_bool\n\nlet bin_bool =\n { shape = bin_shape_bool; writer = bin_writer_bool; reader = bin_reader_bool }\n;;\n\n(*$ mk_base \"string\" *)\nlet bin_writer_string = { size = Size.bin_size_string; write = Write.bin_write_string }\n\nlet bin_reader_string =\n { read = Read.bin_read_string; vtag_read = variant_wrong_type \"string\" }\n;;\n\nlet bin_shape_string = Shape.bin_shape_string\n\nlet bin_string =\n { shape = bin_shape_string; writer = bin_writer_string; reader = bin_reader_string }\n;;\n\n(*$ mk_base \"bytes\" *)\nlet bin_writer_bytes = { size = Size.bin_size_bytes; write = Write.bin_write_bytes }\n\nlet bin_reader_bytes =\n { read = Read.bin_read_bytes; vtag_read = variant_wrong_type \"bytes\" }\n;;\n\nlet bin_shape_bytes = Shape.bin_shape_bytes\n\nlet bin_bytes =\n { shape = bin_shape_bytes; writer = bin_writer_bytes; reader = bin_reader_bytes }\n;;\n\n(*$ mk_base \"char\" *)\nlet bin_writer_char = { size = Size.bin_size_char; write = Write.bin_write_char }\n\nlet bin_reader_char =\n { read = Read.bin_read_char; vtag_read = variant_wrong_type \"char\" }\n;;\n\nlet bin_shape_char = Shape.bin_shape_char\n\nlet bin_char =\n { shape = bin_shape_char; writer = bin_writer_char; reader = bin_reader_char }\n;;\n\n(*$ mk_base \"int\" *)\nlet bin_writer_int = { size = Size.bin_size_int; write = Write.bin_write_int }\nlet bin_reader_int = { read = Read.bin_read_int; vtag_read = variant_wrong_type \"int\" }\nlet bin_shape_int = Shape.bin_shape_int\nlet bin_int = { shape = bin_shape_int; writer = bin_writer_int; reader = bin_reader_int }\n\n(*$ mk_base \"float\" *)\nlet bin_writer_float = { size = Size.bin_size_float; write = Write.bin_write_float }\n\nlet bin_reader_float =\n { read = Read.bin_read_float; vtag_read = variant_wrong_type \"float\" }\n;;\n\nlet bin_shape_float = Shape.bin_shape_float\n\nlet bin_float =\n { shape = bin_shape_float; writer = bin_writer_float; reader = bin_reader_float }\n;;\n\n(*$ mk_base \"int32\" *)\nlet bin_writer_int32 = { size = Size.bin_size_int32; write = Write.bin_write_int32 }\n\nlet bin_reader_int32 =\n { read = Read.bin_read_int32; vtag_read = variant_wrong_type \"int32\" }\n;;\n\nlet bin_shape_int32 = Shape.bin_shape_int32\n\nlet bin_int32 =\n { shape = bin_shape_int32; writer = bin_writer_int32; reader = bin_reader_int32 }\n;;\n\n(*$ mk_base \"int64\" *)\nlet bin_writer_int64 = { size = Size.bin_size_int64; write = Write.bin_write_int64 }\n\nlet bin_reader_int64 =\n { read = Read.bin_read_int64; vtag_read = variant_wrong_type \"int64\" }\n;;\n\nlet bin_shape_int64 = Shape.bin_shape_int64\n\nlet bin_int64 =\n { shape = bin_shape_int64; writer = bin_writer_int64; reader = bin_reader_int64 }\n;;\n\n(*$ mk_base \"nativeint\" *)\nlet bin_writer_nativeint =\n { size = Size.bin_size_nativeint; write = Write.bin_write_nativeint }\n;;\n\nlet bin_reader_nativeint =\n { read = Read.bin_read_nativeint; vtag_read = variant_wrong_type \"nativeint\" }\n;;\n\nlet bin_shape_nativeint = Shape.bin_shape_nativeint\n\nlet bin_nativeint =\n { shape = bin_shape_nativeint\n ; writer = bin_writer_nativeint\n ; reader = bin_reader_nativeint\n }\n;;\n\n(*$ mk_base \"nat0\" *)\nlet bin_writer_nat0 = { size = Size.bin_size_nat0; write = Write.bin_write_nat0 }\n\nlet bin_reader_nat0 =\n { read = Read.bin_read_nat0; vtag_read = variant_wrong_type \"nat0\" }\n;;\n\nlet bin_shape_nat0 = Shape.bin_shape_nat0\n\nlet bin_nat0 =\n { shape = bin_shape_nat0; writer = bin_writer_nat0; reader = bin_reader_nat0 }\n;;\n\n(*$ mk_base1 \"ref\" *)\nlet bin_writer_ref bin_writer_el =\n { size = (fun v -> Size.bin_size_ref bin_writer_el.size v)\n ; write = (fun buf ~pos v -> Write.bin_write_ref bin_writer_el.write buf ~pos v)\n }\n;;\n\nlet bin_reader_ref bin_reader_el =\n { read = (fun buf ~pos_ref -> Read.bin_read_ref bin_reader_el.read buf ~pos_ref)\n ; vtag_read = variant_wrong_type \"ref\"\n }\n;;\n\nlet bin_shape_ref x1 = Shape.bin_shape_ref x1\n\nlet bin_ref bin_el =\n { shape = bin_shape_ref bin_el.shape\n ; writer = bin_writer_ref bin_el.writer\n ; reader = bin_reader_ref bin_el.reader\n }\n;;\n\n(*$ mk_base1 \"lazy\" *)\nlet bin_writer_lazy bin_writer_el =\n { size = (fun v -> Size.bin_size_lazy bin_writer_el.size v)\n ; write = (fun buf ~pos v -> Write.bin_write_lazy bin_writer_el.write buf ~pos v)\n }\n;;\n\nlet bin_reader_lazy bin_reader_el =\n { read = (fun buf ~pos_ref -> Read.bin_read_lazy bin_reader_el.read buf ~pos_ref)\n ; vtag_read = variant_wrong_type \"lazy\"\n }\n;;\n\nlet bin_shape_lazy x1 = Shape.bin_shape_lazy x1\n\nlet bin_lazy bin_el =\n { shape = bin_shape_lazy bin_el.shape\n ; writer = bin_writer_lazy bin_el.writer\n ; reader = bin_reader_lazy bin_el.reader\n }\n;;\n\n(*$ mk_base1 \"option\" *)\nlet bin_writer_option bin_writer_el =\n { size = (fun v -> Size.bin_size_option bin_writer_el.size v)\n ; write = (fun buf ~pos v -> Write.bin_write_option bin_writer_el.write buf ~pos v)\n }\n;;\n\nlet bin_reader_option bin_reader_el =\n { read = (fun buf ~pos_ref -> Read.bin_read_option bin_reader_el.read buf ~pos_ref)\n ; vtag_read = variant_wrong_type \"option\"\n }\n;;\n\nlet bin_shape_option x1 = Shape.bin_shape_option x1\n\nlet bin_option bin_el =\n { shape = bin_shape_option bin_el.shape\n ; writer = bin_writer_option bin_el.writer\n ; reader = bin_reader_option bin_el.reader\n }\n;;\n\n(*$ mk_base2 \"pair\" *)\nlet bin_writer_pair bin_writer_el1 bin_writer_el2 =\n { size = (fun v -> Size.bin_size_pair bin_writer_el1.size bin_writer_el2.size v)\n ; write =\n (fun buf ~pos v ->\n Write.bin_write_pair bin_writer_el1.write bin_writer_el2.write buf ~pos v)\n }\n;;\n\nlet bin_reader_pair bin_reader_el1 bin_reader_el2 =\n { read =\n (fun buf ~pos_ref ->\n Read.bin_read_pair bin_reader_el1.read bin_reader_el2.read buf ~pos_ref)\n ; vtag_read = variant_wrong_type \"pair\"\n }\n;;\n\nlet bin_shape_pair x1 x2 = Shape.bin_shape_pair x1 x2\n\nlet bin_pair bin_el1 bin_el2 =\n { shape = bin_shape_pair bin_el1.shape bin_el2.shape\n ; writer = bin_writer_pair bin_el1.writer bin_el2.writer\n ; reader = bin_reader_pair bin_el1.reader bin_el2.reader\n }\n;;\n\n(*$ mk_base3 \"triple\" *)\nlet bin_writer_triple bin_writer_el1 bin_writer_el2 bin_writer_el3 =\n { size =\n (fun v ->\n Size.bin_size_triple\n bin_writer_el1.size\n bin_writer_el2.size\n bin_writer_el3.size\n v)\n ; write =\n (fun buf ~pos v ->\n Write.bin_write_triple\n bin_writer_el1.write\n bin_writer_el2.write\n bin_writer_el3.write\n buf\n ~pos\n v)\n }\n;;\n\nlet bin_reader_triple bin_reader_el1 bin_reader_el2 bin_reader_el3 =\n { read =\n (fun buf ~pos_ref ->\n Read.bin_read_triple\n bin_reader_el1.read\n bin_reader_el2.read\n bin_reader_el3.read\n buf\n ~pos_ref)\n ; vtag_read = variant_wrong_type \"triple\"\n }\n;;\n\nlet bin_shape_triple x1 x2 x3 = Shape.bin_shape_triple x1 x2 x3\n\nlet bin_triple bin_el1 bin_el2 bin_el3 =\n { shape = bin_shape_triple bin_el1.shape bin_el2.shape bin_el3.shape\n ; writer = bin_writer_triple bin_el1.writer bin_el2.writer bin_el3.writer\n ; reader = bin_reader_triple bin_el1.reader bin_el2.reader bin_el3.reader\n }\n;;\n\n(*$ mk_base1 \"list\" *)\nlet bin_writer_list bin_writer_el =\n { size = (fun v -> Size.bin_size_list bin_writer_el.size v)\n ; write = (fun buf ~pos v -> Write.bin_write_list bin_writer_el.write buf ~pos v)\n }\n;;\n\nlet bin_reader_list bin_reader_el =\n { read = (fun buf ~pos_ref -> Read.bin_read_list bin_reader_el.read buf ~pos_ref)\n ; vtag_read = variant_wrong_type \"list\"\n }\n;;\n\nlet bin_shape_list x1 = Shape.bin_shape_list x1\n\nlet bin_list bin_el =\n { shape = bin_shape_list bin_el.shape\n ; writer = bin_writer_list bin_el.writer\n ; reader = bin_reader_list bin_el.reader\n }\n;;\n\n(*$ mk_base1 \"array\" *)\nlet bin_writer_array bin_writer_el =\n { size = (fun v -> Size.bin_size_array bin_writer_el.size v)\n ; write = (fun buf ~pos v -> Write.bin_write_array bin_writer_el.write buf ~pos v)\n }\n;;\n\nlet bin_reader_array bin_reader_el =\n { read = (fun buf ~pos_ref -> Read.bin_read_array bin_reader_el.read buf ~pos_ref)\n ; vtag_read = variant_wrong_type \"array\"\n }\n;;\n\nlet bin_shape_array x1 = Shape.bin_shape_array x1\n\nlet bin_array bin_el =\n { shape = bin_shape_array bin_el.shape\n ; writer = bin_writer_array bin_el.writer\n ; reader = bin_reader_array bin_el.reader\n }\n;;\n\n(*$ mk_base2 \"hashtbl\" *)\nlet bin_writer_hashtbl bin_writer_el1 bin_writer_el2 =\n { size = (fun v -> Size.bin_size_hashtbl bin_writer_el1.size bin_writer_el2.size v)\n ; write =\n (fun buf ~pos v ->\n Write.bin_write_hashtbl bin_writer_el1.write bin_writer_el2.write buf ~pos v)\n }\n;;\n\nlet bin_reader_hashtbl bin_reader_el1 bin_reader_el2 =\n { read =\n (fun buf ~pos_ref ->\n Read.bin_read_hashtbl bin_reader_el1.read bin_reader_el2.read buf ~pos_ref)\n ; vtag_read = variant_wrong_type \"hashtbl\"\n }\n;;\n\nlet bin_shape_hashtbl x1 x2 = Shape.bin_shape_hashtbl x1 x2\n\nlet bin_hashtbl bin_el1 bin_el2 =\n { shape = bin_shape_hashtbl bin_el1.shape bin_el2.shape\n ; writer = bin_writer_hashtbl bin_el1.writer bin_el2.writer\n ; reader = bin_reader_hashtbl bin_el1.reader bin_el2.reader\n }\n;;\n\n(*$ mk_base \"float32_vec\" *)\nlet bin_writer_float32_vec =\n { size = Size.bin_size_float32_vec; write = Write.bin_write_float32_vec }\n;;\n\nlet bin_reader_float32_vec =\n { read = Read.bin_read_float32_vec; vtag_read = variant_wrong_type \"float32_vec\" }\n;;\n\nlet bin_shape_float32_vec = Shape.bin_shape_float32_vec\n\nlet bin_float32_vec =\n { shape = bin_shape_float32_vec\n ; writer = bin_writer_float32_vec\n ; reader = bin_reader_float32_vec\n }\n;;\n\n(*$ mk_base \"float64_vec\" *)\nlet bin_writer_float64_vec =\n { size = Size.bin_size_float64_vec; write = Write.bin_write_float64_vec }\n;;\n\nlet bin_reader_float64_vec =\n { read = Read.bin_read_float64_vec; vtag_read = variant_wrong_type \"float64_vec\" }\n;;\n\nlet bin_shape_float64_vec = Shape.bin_shape_float64_vec\n\nlet bin_float64_vec =\n { shape = bin_shape_float64_vec\n ; writer = bin_writer_float64_vec\n ; reader = bin_reader_float64_vec\n }\n;;\n\n(*$ mk_base \"vec\" *)\nlet bin_writer_vec = { size = Size.bin_size_vec; write = Write.bin_write_vec }\nlet bin_reader_vec = { read = Read.bin_read_vec; vtag_read = variant_wrong_type \"vec\" }\nlet bin_shape_vec = Shape.bin_shape_vec\nlet bin_vec = { shape = bin_shape_vec; writer = bin_writer_vec; reader = bin_reader_vec }\n\n(*$ mk_base \"float32_mat\" *)\nlet bin_writer_float32_mat =\n { size = Size.bin_size_float32_mat; write = Write.bin_write_float32_mat }\n;;\n\nlet bin_reader_float32_mat =\n { read = Read.bin_read_float32_mat; vtag_read = variant_wrong_type \"float32_mat\" }\n;;\n\nlet bin_shape_float32_mat = Shape.bin_shape_float32_mat\n\nlet bin_float32_mat =\n { shape = bin_shape_float32_mat\n ; writer = bin_writer_float32_mat\n ; reader = bin_reader_float32_mat\n }\n;;\n\n(*$ mk_base \"float64_mat\" *)\nlet bin_writer_float64_mat =\n { size = Size.bin_size_float64_mat; write = Write.bin_write_float64_mat }\n;;\n\nlet bin_reader_float64_mat =\n { read = Read.bin_read_float64_mat; vtag_read = variant_wrong_type \"float64_mat\" }\n;;\n\nlet bin_shape_float64_mat = Shape.bin_shape_float64_mat\n\nlet bin_float64_mat =\n { shape = bin_shape_float64_mat\n ; writer = bin_writer_float64_mat\n ; reader = bin_reader_float64_mat\n }\n;;\n\n(*$ mk_base \"mat\" *)\nlet bin_writer_mat = { size = Size.bin_size_mat; write = Write.bin_write_mat }\nlet bin_reader_mat = { read = Read.bin_read_mat; vtag_read = variant_wrong_type \"mat\" }\nlet bin_shape_mat = Shape.bin_shape_mat\nlet bin_mat = { shape = bin_shape_mat; writer = bin_writer_mat; reader = bin_reader_mat }\n\n(*$ mk_base \"bigstring\" *)\nlet bin_writer_bigstring =\n { size = Size.bin_size_bigstring; write = Write.bin_write_bigstring }\n;;\n\nlet bin_reader_bigstring =\n { read = Read.bin_read_bigstring; vtag_read = variant_wrong_type \"bigstring\" }\n;;\n\nlet bin_shape_bigstring = Shape.bin_shape_bigstring\n\nlet bin_bigstring =\n { shape = bin_shape_bigstring\n ; writer = bin_writer_bigstring\n ; reader = bin_reader_bigstring\n }\n;;\n\n(*$*)\ntype float_array = float array\n\n(*$ mk_base \"float_array\" *)\nlet bin_writer_float_array =\n { size = Size.bin_size_float_array; write = Write.bin_write_float_array }\n;;\n\nlet bin_reader_float_array =\n { read = Read.bin_read_float_array; vtag_read = variant_wrong_type \"float_array\" }\n;;\n\nlet bin_shape_float_array = Shape.bin_shape_float_array\n\nlet bin_float_array =\n { shape = bin_shape_float_array\n ; writer = bin_writer_float_array\n ; reader = bin_reader_float_array\n }\n;;\n\n(*$ mk_base \"variant_int\" *)\nlet bin_writer_variant_int =\n { size = Size.bin_size_variant_int; write = Write.bin_write_variant_int }\n;;\n\nlet bin_reader_variant_int =\n { read = Read.bin_read_variant_int; vtag_read = variant_wrong_type \"variant_int\" }\n;;\n\nlet bin_shape_variant_int = Shape.bin_shape_variant_int\n\nlet bin_variant_int =\n { shape = bin_shape_variant_int\n ; writer = bin_writer_variant_int\n ; reader = bin_reader_variant_int\n }\n;;\n\n(*$ mk_base \"int_8bit\" *)\nlet bin_writer_int_8bit =\n { size = Size.bin_size_int_8bit; write = Write.bin_write_int_8bit }\n;;\n\nlet bin_reader_int_8bit =\n { read = Read.bin_read_int_8bit; vtag_read = variant_wrong_type \"int_8bit\" }\n;;\n\nlet bin_shape_int_8bit = Shape.bin_shape_int_8bit\n\nlet bin_int_8bit =\n { shape = bin_shape_int_8bit\n ; writer = bin_writer_int_8bit\n ; reader = bin_reader_int_8bit\n }\n;;\n\n(*$ mk_base \"int_16bit\" *)\nlet bin_writer_int_16bit =\n { size = Size.bin_size_int_16bit; write = Write.bin_write_int_16bit }\n;;\n\nlet bin_reader_int_16bit =\n { read = Read.bin_read_int_16bit; vtag_read = variant_wrong_type \"int_16bit\" }\n;;\n\nlet bin_shape_int_16bit = Shape.bin_shape_int_16bit\n\nlet bin_int_16bit =\n { shape = bin_shape_int_16bit\n ; writer = bin_writer_int_16bit\n ; reader = bin_reader_int_16bit\n }\n;;\n\n(*$ mk_base \"int_32bit\" *)\nlet bin_writer_int_32bit =\n { size = Size.bin_size_int_32bit; write = Write.bin_write_int_32bit }\n;;\n\nlet bin_reader_int_32bit =\n { read = Read.bin_read_int_32bit; vtag_read = variant_wrong_type \"int_32bit\" }\n;;\n\nlet bin_shape_int_32bit = Shape.bin_shape_int_32bit\n\nlet bin_int_32bit =\n { shape = bin_shape_int_32bit\n ; writer = bin_writer_int_32bit\n ; reader = bin_reader_int_32bit\n }\n;;\n\n(*$ mk_base \"int_64bit\" *)\nlet bin_writer_int_64bit =\n { size = Size.bin_size_int_64bit; write = Write.bin_write_int_64bit }\n;;\n\nlet bin_reader_int_64bit =\n { read = Read.bin_read_int_64bit; vtag_read = variant_wrong_type \"int_64bit\" }\n;;\n\nlet bin_shape_int_64bit = Shape.bin_shape_int_64bit\n\nlet bin_int_64bit =\n { shape = bin_shape_int_64bit\n ; writer = bin_writer_int_64bit\n ; reader = bin_reader_int_64bit\n }\n;;\n\n(*$ mk_base \"int64_bits\" *)\nlet bin_writer_int64_bits =\n { size = Size.bin_size_int64_bits; write = Write.bin_write_int64_bits }\n;;\n\nlet bin_reader_int64_bits =\n { read = Read.bin_read_int64_bits; vtag_read = variant_wrong_type \"int64_bits\" }\n;;\n\nlet bin_shape_int64_bits = Shape.bin_shape_int64_bits\n\nlet bin_int64_bits =\n { shape = bin_shape_int64_bits\n ; writer = bin_writer_int64_bits\n ; reader = bin_reader_int64_bits\n }\n;;\n\n(*$ mk_base \"network16_int\" *)\nlet bin_writer_network16_int =\n { size = Size.bin_size_network16_int; write = Write.bin_write_network16_int }\n;;\n\nlet bin_reader_network16_int =\n { read = Read.bin_read_network16_int; vtag_read = variant_wrong_type \"network16_int\" }\n;;\n\nlet bin_shape_network16_int = Shape.bin_shape_network16_int\n\nlet bin_network16_int =\n { shape = bin_shape_network16_int\n ; writer = bin_writer_network16_int\n ; reader = bin_reader_network16_int\n }\n;;\n\n(*$ mk_base \"network32_int\" *)\nlet bin_writer_network32_int =\n { size = Size.bin_size_network32_int; write = Write.bin_write_network32_int }\n;;\n\nlet bin_reader_network32_int =\n { read = Read.bin_read_network32_int; vtag_read = variant_wrong_type \"network32_int\" }\n;;\n\nlet bin_shape_network32_int = Shape.bin_shape_network32_int\n\nlet bin_network32_int =\n { shape = bin_shape_network32_int\n ; writer = bin_writer_network32_int\n ; reader = bin_reader_network32_int\n }\n;;\n\n(*$ mk_base \"network32_int32\" *)\nlet bin_writer_network32_int32 =\n { size = Size.bin_size_network32_int32; write = Write.bin_write_network32_int32 }\n;;\n\nlet bin_reader_network32_int32 =\n { read = Read.bin_read_network32_int32\n ; vtag_read = variant_wrong_type \"network32_int32\"\n }\n;;\n\nlet bin_shape_network32_int32 = Shape.bin_shape_network32_int32\n\nlet bin_network32_int32 =\n { shape = bin_shape_network32_int32\n ; writer = bin_writer_network32_int32\n ; reader = bin_reader_network32_int32\n }\n;;\n\n(*$ mk_base \"network64_int\" *)\nlet bin_writer_network64_int =\n { size = Size.bin_size_network64_int; write = Write.bin_write_network64_int }\n;;\n\nlet bin_reader_network64_int =\n { read = Read.bin_read_network64_int; vtag_read = variant_wrong_type \"network64_int\" }\n;;\n\nlet bin_shape_network64_int = Shape.bin_shape_network64_int\n\nlet bin_network64_int =\n { shape = bin_shape_network64_int\n ; writer = bin_writer_network64_int\n ; reader = bin_reader_network64_int\n }\n;;\n\n(*$ mk_base \"network64_int64\" *)\nlet bin_writer_network64_int64 =\n { size = Size.bin_size_network64_int64; write = Write.bin_write_network64_int64 }\n;;\n\nlet bin_reader_network64_int64 =\n { read = Read.bin_read_network64_int64\n ; vtag_read = variant_wrong_type \"network64_int64\"\n }\n;;\n\nlet bin_shape_network64_int64 = Shape.bin_shape_network64_int64\n\nlet bin_network64_int64 =\n { shape = bin_shape_network64_int64\n ; writer = bin_writer_network64_int64\n ; reader = bin_reader_network64_int64\n }\n;;\n\n(*$*)\nlet bin_writer_array_no_length bin_writer_el =\n { size =\n (fun v -> (Size.bin_size_array_no_length [@warning \"-3\"]) bin_writer_el.size v)\n ; write =\n (fun buf ~pos v ->\n (Write.bin_write_array_no_length [@warning \"-3\"]) bin_writer_el.write buf ~pos v)\n }\n;;\n\n(* Conversion of binable types *)\n\nlet cnv_writer cnv tp_class =\n { size = (fun v -> tp_class.size (cnv v))\n ; write = (fun buf ~pos v -> tp_class.write buf ~pos (cnv v))\n }\n;;\n\nlet cnv_reader cnv tp_class =\n { read = (fun buf ~pos_ref -> cnv (tp_class.read buf ~pos_ref))\n ; vtag_read = (fun buf ~pos_ref vtag -> cnv (tp_class.vtag_read buf ~pos_ref vtag))\n }\n;;\n\nlet cnv for_shape for_writer for_reader tp_class =\n { shape = for_shape tp_class.shape\n ; writer = cnv_writer for_writer tp_class.writer\n ; reader = cnv_reader for_reader tp_class.reader\n }\n;;\n","(* Utils: utility functions for user convenience *)\n\nopen Common\nopen Size\nopen Type_class\ninclude Utils_intf\n\nlet size_header_length = 8\nlet bin_write_size_header = Write.bin_write_int_64bit\nlet bin_read_size_header = Read.bin_read_int_64bit\n\nlet bin_dump ?(header = false) writer v =\n let buf, pos, pos_len =\n let v_len = writer.size v in\n if header\n then (\n let tot_len = v_len + size_header_length in\n let buf = create_buf tot_len in\n let pos = bin_write_size_header buf ~pos:0 v_len in\n buf, pos, pos + v_len)\n else (\n let buf = create_buf v_len in\n buf, 0, v_len)\n in\n let pos = writer.write buf ~pos v in\n if pos = pos_len\n then buf\n else failwith \"Bin_prot.Utils.bin_dump: size changed during writing\"\n;;\n\n(* Reading from streams *)\n\nlet bin_read_stream ?max_size ~read reader =\n let buf = create_buf size_header_length in\n read buf ~pos:0 ~len:size_header_length;\n let pos_ref = ref 0 in\n let len = bin_read_size_header buf ~pos_ref in\n match max_size with\n | Some max_size when len > max_size ->\n failwith\n (Printf.sprintf\n \"Bin_prot.Utils.bin_read_stream: size exceeds max_size: %d > %d\"\n len\n max_size)\n | _ ->\n let buf = if len > size_header_length then create_buf len else buf in\n read buf ~pos:0 ~len;\n pos_ref := 0;\n let res = reader.read buf ~pos_ref in\n if !pos_ref = len\n then res\n else (\n let msg =\n Printf.sprintf\n \"Bin_prot.Utils.bin_read_stream: protocol lied about length of value: \\\n expected %d, received %d\"\n len\n !pos_ref\n in\n failwith msg)\n;;\n\n(* Conversion of binable types *)\n\nmodule Of_minimal (S : Binable.Minimal.S) : Binable.S with type t := S.t = struct\n include S\n\n let bin_writer_t = { size = bin_size_t; write = bin_write_t }\n let bin_reader_t = { read = bin_read_t; vtag_read = __bin_read_t__ }\n let bin_t = { shape = bin_shape_t; writer = bin_writer_t; reader = bin_reader_t }\nend\n\nlet maybe_annotate_shape maybe_uuid shape =\n match maybe_uuid with\n | None -> shape\n | Some uuid -> Shape.annotate uuid shape\n;;\n\nmodule Make_binable_gen (S : sig\n include Make_binable_without_uuid_spec\n\n val maybe_caller_identity : Shape.Uuid.t option\n end) =\nstruct\n include Of_minimal (struct\n module B = S.Binable\n\n type t = S.t\n\n let bin_shape_t = maybe_annotate_shape S.maybe_caller_identity B.bin_shape_t\n let bin_size_t t = B.bin_size_t (S.to_binable t)\n let bin_write_t buf ~pos t = B.bin_write_t buf ~pos (S.to_binable t)\n let bin_read_t buf ~pos_ref = S.of_binable (B.bin_read_t buf ~pos_ref)\n let __bin_read_t__ buf ~pos_ref n = S.of_binable (B.__bin_read_t__ buf ~pos_ref n)\n end)\nend\n\nmodule Make_binable1_gen (S : sig\n include Make_binable1_without_uuid_spec\n\n val maybe_caller_identity : Shape.Uuid.t option\n end) =\nstruct\n module B = S.Binable\n\n let bin_shape_t bin_shape_el =\n maybe_annotate_shape S.maybe_caller_identity (B.bin_shape_t bin_shape_el)\n ;;\n\n let bin_size_t bin_size_el t = B.bin_size_t bin_size_el (S.to_binable t)\n\n let bin_write_t bin_write_el buf ~pos t =\n B.bin_write_t bin_write_el buf ~pos (S.to_binable t)\n ;;\n\n let bin_read_t bin_read_el buf ~pos_ref =\n S.of_binable (B.bin_read_t bin_read_el buf ~pos_ref)\n ;;\n\n let __bin_read_t__ bin_read_el buf ~pos_ref n =\n S.of_binable (B.__bin_read_t__ bin_read_el buf ~pos_ref n)\n ;;\n\n let bin_writer_t bin_writer =\n { size = (fun v -> bin_size_t bin_writer.size v)\n ; write = (fun buf ~pos v -> bin_write_t bin_writer.write buf ~pos v)\n }\n ;;\n\n let bin_reader_t bin_reader =\n { read = (fun buf ~pos_ref -> bin_read_t bin_reader.read buf ~pos_ref)\n ; vtag_read =\n (fun _buf ~pos_ref _n ->\n raise_variant_wrong_type \"Bin_prot.Utils.Make_binable1.bin_reader_t\" !pos_ref)\n }\n ;;\n\n let bin_t type_class =\n { shape = bin_shape_t type_class.shape\n ; writer = bin_writer_t type_class.writer\n ; reader = bin_reader_t type_class.reader\n }\n ;;\nend\n\nmodule Make_binable2_gen (S : sig\n include Make_binable2_without_uuid_spec\n\n val maybe_caller_identity : Shape.Uuid.t option\n end) =\nstruct\n module B = S.Binable\n\n let bin_shape_t bin_shape_el1 bin_shape_el2 =\n maybe_annotate_shape\n S.maybe_caller_identity\n (B.bin_shape_t bin_shape_el1 bin_shape_el2)\n ;;\n\n let bin_size_t bin_size_el1 bin_size_el2 t =\n B.bin_size_t bin_size_el1 bin_size_el2 (S.to_binable t)\n ;;\n\n let bin_write_t bin_write_el1 bin_write_el2 buf ~pos t =\n B.bin_write_t bin_write_el1 bin_write_el2 buf ~pos (S.to_binable t)\n ;;\n\n let bin_read_t bin_read_el1 bin_read_el2 buf ~pos_ref =\n S.of_binable (B.bin_read_t bin_read_el1 bin_read_el2 buf ~pos_ref)\n ;;\n\n let __bin_read_t__ bin_read_el1 bin_read_el2 buf ~pos_ref n =\n S.of_binable (B.__bin_read_t__ bin_read_el1 bin_read_el2 buf ~pos_ref n)\n ;;\n\n let bin_writer_t bin_writer1 bin_writer2 =\n { size = (fun v -> bin_size_t bin_writer1.size bin_writer2.size v)\n ; write =\n (fun buf ~pos v -> bin_write_t bin_writer1.write bin_writer2.write buf ~pos v)\n }\n ;;\n\n let bin_reader_t bin_reader1 bin_reader2 =\n { read =\n (fun buf ~pos_ref -> bin_read_t bin_reader1.read bin_reader2.read buf ~pos_ref)\n ; vtag_read =\n (fun _buf ~pos_ref _n ->\n raise_variant_wrong_type \"Bin_prot.Utils.Make_binable2.bin_reader_t\" !pos_ref)\n }\n ;;\n\n let bin_t type_class1 type_class2 =\n { shape = bin_shape_t type_class1.shape type_class2.shape\n ; writer = bin_writer_t type_class1.writer type_class2.writer\n ; reader = bin_reader_t type_class1.reader type_class2.reader\n }\n ;;\nend\n\nmodule Make_binable3_gen (S : sig\n include Make_binable3_without_uuid_spec\n\n val maybe_caller_identity : Shape.Uuid.t option\n end) =\nstruct\n module B = S.Binable\n\n let bin_shape_t bin_shape_el1 bin_shape_el2 bin_shape_el3 =\n maybe_annotate_shape\n S.maybe_caller_identity\n (B.bin_shape_t bin_shape_el1 bin_shape_el2 bin_shape_el3)\n ;;\n\n let bin_size_t bin_size_el1 bin_size_el2 bin_size_el3 t =\n B.bin_size_t bin_size_el1 bin_size_el2 bin_size_el3 (S.to_binable t)\n ;;\n\n let bin_write_t bin_write_el1 bin_write_el2 bin_write_el3 buf ~pos t =\n B.bin_write_t bin_write_el1 bin_write_el2 bin_write_el3 buf ~pos (S.to_binable t)\n ;;\n\n let bin_read_t bin_read_el1 bin_read_el2 bin_read_el3 buf ~pos_ref =\n S.of_binable (B.bin_read_t bin_read_el1 bin_read_el2 bin_read_el3 buf ~pos_ref)\n ;;\n\n let __bin_read_t__ bin_read_el1 bin_read_el2 bin_read_el3 buf ~pos_ref n =\n S.of_binable (B.__bin_read_t__ bin_read_el1 bin_read_el2 bin_read_el3 buf ~pos_ref n)\n ;;\n\n let bin_writer_t bin_writer1 bin_writer2 bin_writer3 =\n { size = (fun v -> bin_size_t bin_writer1.size bin_writer2.size bin_writer3.size v)\n ; write =\n (fun buf ~pos v ->\n bin_write_t bin_writer1.write bin_writer2.write bin_writer3.write buf ~pos v)\n }\n ;;\n\n let bin_reader_t bin_reader1 bin_reader2 bin_reader3 =\n { read =\n (fun buf ~pos_ref ->\n bin_read_t bin_reader1.read bin_reader2.read bin_reader3.read buf ~pos_ref)\n ; vtag_read =\n (fun _buf ~pos_ref _n ->\n raise_variant_wrong_type \"Bin_prot.Utils.Make_binable3.bin_reader_t\" !pos_ref)\n }\n ;;\n\n let bin_t type_class1 type_class2 type_class3 =\n { shape = bin_shape_t type_class1.shape type_class2.shape type_class3.shape\n ; writer = bin_writer_t type_class1.writer type_class2.writer type_class3.writer\n ; reader = bin_reader_t type_class1.reader type_class2.reader type_class3.reader\n }\n ;;\nend\n\nmodule Make_binable_with_uuid (S : Make_binable_with_uuid_spec) =\n Make_binable_gen (struct\n include S\n\n let maybe_caller_identity = Some S.caller_identity\n end)\n\nmodule Make_binable1_with_uuid (S : Make_binable1_with_uuid_spec) =\n Make_binable1_gen (struct\n include S\n\n let maybe_caller_identity = Some S.caller_identity\n end)\n\nmodule Make_binable2_with_uuid (S : Make_binable2_with_uuid_spec) =\n Make_binable2_gen (struct\n include S\n\n let maybe_caller_identity = Some S.caller_identity\n end)\n\nmodule Make_binable3_with_uuid (S : Make_binable3_with_uuid_spec) =\n Make_binable3_gen (struct\n include S\n\n let maybe_caller_identity = Some S.caller_identity\n end)\n\nmodule Make_binable_without_uuid (S : Make_binable_without_uuid_spec) =\n Make_binable_gen (struct\n include S\n\n let maybe_caller_identity = None\n end)\n\nmodule Make_binable1_without_uuid (S : Make_binable1_without_uuid_spec) =\n Make_binable1_gen (struct\n include S\n\n let maybe_caller_identity = None\n end)\n\nmodule Make_binable2_without_uuid (S : Make_binable2_without_uuid_spec) =\n Make_binable2_gen (struct\n include S\n\n let maybe_caller_identity = None\n end)\n\nmodule Make_binable3_without_uuid (S : Make_binable3_without_uuid_spec) =\n Make_binable3_gen (struct\n include S\n\n let maybe_caller_identity = None\n end)\n\nmodule Make_binable = Make_binable_without_uuid\nmodule Make_binable1 = Make_binable1_without_uuid\nmodule Make_binable2 = Make_binable2_without_uuid\nmodule Make_binable3 = Make_binable3_without_uuid\n\nlet with_module_name f ~module_name function_name =\n match module_name with\n | None -> f function_name\n | Some module_name -> Printf.ksprintf f \"%s.%s\" module_name function_name\n;;\n\nlet raise_concurrent_modification = with_module_name raise_concurrent_modification\n\nlet raise_read_too_much =\n with_module_name\n (Printf.ksprintf failwith \"%s: tried to read more elements than available\")\n;;\n\nlet raise_read_not_enough =\n with_module_name (Printf.ksprintf failwith \"%s: didn't read all elements\")\n;;\n\nmodule Make_iterable_binable (S : Make_iterable_binable_spec) = struct\n open S\n\n let bin_shape_t =\n Shape.(\n basetype\n caller_identity\n [ basetype\n (Uuid.of_string \"6592371a-4994-11e6-923a-7748e4182764\")\n [ S.bin_shape_el ]\n ])\n ;;\n\n let bin_size_t t =\n let size_ref = ref 0 in\n let cnt_ref = ref 0 in\n iter t ~f:(fun el ->\n size_ref := !size_ref + bin_size_el el;\n incr cnt_ref);\n let len = length t in\n if !cnt_ref = len\n then bin_size_nat0 (Nat0.unsafe_of_int len) + !size_ref\n else raise_concurrent_modification ~module_name \"bin_size_t\"\n ;;\n\n let bin_write_t buf ~pos t =\n let len = length t in\n let plen = Nat0.unsafe_of_int len in\n let pos_ref = ref (Write.bin_write_nat0 buf ~pos plen) in\n let cnt_ref = ref 0 in\n iter t ~f:(fun el ->\n pos_ref := bin_write_el buf ~pos:!pos_ref el;\n incr cnt_ref);\n if !cnt_ref = len\n then !pos_ref\n else raise_concurrent_modification ~module_name \"bin_write_t\"\n ;;\n\n let bin_read_t buf ~pos_ref =\n let len = (Read.bin_read_nat0 buf ~pos_ref :> int) in\n let idx = ref 0 in\n let next () =\n if !idx >= len then raise_read_too_much ~module_name \"bin_read_t\";\n incr idx;\n bin_read_el buf ~pos_ref\n in\n let result = init ~len ~next in\n if !idx < len then raise_read_not_enough ~module_name \"bin_read_t\";\n result\n ;;\n\n let __bin_read_t__ _buf ~pos_ref _n = raise_variant_wrong_type \"t\" !pos_ref\n let bin_writer_t = { size = bin_size_t; write = bin_write_t }\n let bin_reader_t = { read = bin_read_t; vtag_read = __bin_read_t__ }\n let bin_t = { shape = bin_shape_t; writer = bin_writer_t; reader = bin_reader_t }\nend\n\nmodule Make_iterable_binable1 (S : Make_iterable_binable1_spec) = struct\n open S\n\n let bin_shape_t t =\n Shape.(\n basetype\n caller_identity\n [ basetype\n (Uuid.of_string \"ac8a9ff4-4994-11e6-9a1b-9fb4e933bd9d\")\n [ S.bin_shape_el t ]\n ])\n ;;\n\n let bin_size_t bin_size_a t =\n let size_ref = ref 0 in\n let cnt_ref = ref 0 in\n iter t ~f:(fun el ->\n size_ref := !size_ref + bin_size_el bin_size_a el;\n incr cnt_ref);\n let len = length t in\n if !cnt_ref = len\n then bin_size_nat0 (Nat0.unsafe_of_int len) + !size_ref\n else raise_concurrent_modification ~module_name \"bin_size_t\"\n ;;\n\n let bin_write_t bin_write_a buf ~pos t =\n let len = length t in\n let plen = Nat0.unsafe_of_int len in\n let pos_ref = ref (Write.bin_write_nat0 buf ~pos plen) in\n let cnt_ref = ref 0 in\n iter t ~f:(fun el ->\n pos_ref := bin_write_el bin_write_a buf ~pos:!pos_ref el;\n incr cnt_ref);\n if !cnt_ref = len\n then !pos_ref\n else raise_concurrent_modification ~module_name \"bin_write_t\"\n ;;\n\n let bin_read_t bin_read_a buf ~pos_ref =\n let len = (Read.bin_read_nat0 buf ~pos_ref :> int) in\n let idx = ref 0 in\n let next () =\n if !idx >= len then raise_read_too_much ~module_name \"bin_read_t\";\n incr idx;\n bin_read_el bin_read_a buf ~pos_ref\n in\n let result = init ~len ~next in\n if !idx < len then raise_read_not_enough ~module_name \"bin_read_t\";\n result\n ;;\n\n let __bin_read_t__ _bin_read_a _buf ~pos_ref _n = raise_variant_wrong_type \"t\" !pos_ref\n\n let bin_writer_t bin_writer =\n { size = (fun v -> bin_size_t bin_writer.size v)\n ; write = (fun buf ~pos v -> bin_write_t bin_writer.write buf ~pos v)\n }\n ;;\n\n let bin_reader_t bin_reader =\n { read = (fun buf ~pos_ref -> bin_read_t bin_reader.read buf ~pos_ref)\n ; vtag_read = (fun buf ~pos_ref _n -> __bin_read_t__ bin_reader.read buf ~pos_ref _n)\n }\n ;;\n\n let bin_t type_class =\n { shape = bin_shape_t type_class.shape\n ; writer = bin_writer_t type_class.writer\n ; reader = bin_reader_t type_class.reader\n }\n ;;\nend\n\nmodule Make_iterable_binable2 (S : Make_iterable_binable2_spec) = struct\n open S\n\n let bin_shape_t t1 t2 =\n Shape.(\n basetype\n caller_identity\n [ basetype\n (Uuid.of_string \"b4e54ad2-4994-11e6-b8df-87c2997f9f52\")\n [ S.bin_shape_el t1 t2 ]\n ])\n ;;\n\n let bin_size_t bin_size_a bin_size_b t =\n let size_ref = ref 0 in\n let cnt_ref = ref 0 in\n iter t ~f:(fun el ->\n size_ref := !size_ref + bin_size_el bin_size_a bin_size_b el;\n incr cnt_ref);\n let len = length t in\n if !cnt_ref = len\n then bin_size_nat0 (Nat0.unsafe_of_int len) + !size_ref\n else raise_concurrent_modification ~module_name \"bin_size_t\"\n ;;\n\n let bin_write_t bin_write_a bin_write_b buf ~pos t =\n let len = length t in\n let plen = Nat0.unsafe_of_int len in\n let pos_ref = ref (Write.bin_write_nat0 buf ~pos plen) in\n let cnt_ref = ref 0 in\n iter t ~f:(fun el ->\n pos_ref := bin_write_el bin_write_a bin_write_b buf ~pos:!pos_ref el;\n incr cnt_ref);\n if !cnt_ref = len\n then !pos_ref\n else raise_concurrent_modification ~module_name \"bin_write_t\"\n ;;\n\n let bin_read_t bin_read_a bin_read_b buf ~pos_ref =\n let len = (Read.bin_read_nat0 buf ~pos_ref :> int) in\n let idx = ref 0 in\n let next () =\n if !idx >= len then raise_read_too_much ~module_name \"bin_read_t\";\n incr idx;\n bin_read_el bin_read_a bin_read_b buf ~pos_ref\n in\n let result = init ~len ~next in\n if !idx < len then raise_read_not_enough ~module_name \"bin_read_t\";\n result\n ;;\n\n let __bin_read_t__ _bin_read_a _bin_read_b _buf ~pos_ref _n =\n raise_variant_wrong_type \"t\" !pos_ref\n ;;\n\n let bin_writer_t bin_writer1 bin_writer2 =\n { size = (fun v -> bin_size_t bin_writer1.size bin_writer2.size v)\n ; write =\n (fun buf ~pos v -> bin_write_t bin_writer1.write bin_writer2.write buf ~pos v)\n }\n ;;\n\n let bin_reader_t bin_reader1 bin_reader2 =\n { read =\n (fun buf ~pos_ref -> bin_read_t bin_reader1.read bin_reader2.read buf ~pos_ref)\n ; vtag_read =\n (fun buf ~pos_ref n ->\n __bin_read_t__ bin_reader1.read bin_reader2.read buf ~pos_ref n)\n }\n ;;\n\n let bin_t type_class1 type_class2 =\n { shape = bin_shape_t type_class1.shape type_class2.shape\n ; writer = bin_writer_t type_class1.writer type_class2.writer\n ; reader = bin_reader_t type_class1.reader type_class2.reader\n }\n ;;\nend\n\nmodule Make_iterable_binable3 (S : Make_iterable_binable3_spec) = struct\n open S\n\n let bin_shape_t t1 t2 t3 =\n Shape.(\n basetype\n caller_identity\n [ basetype\n (Uuid.of_string \"f2112eda-e7d7-11e6-bb36-072e9ce159db\")\n [ S.bin_shape_el t1 t2 t3 ]\n ])\n ;;\n\n let bin_size_t bin_size_a bin_size_b bin_size_c t =\n let size_ref = ref 0 in\n let cnt_ref = ref 0 in\n iter t ~f:(fun el ->\n size_ref := !size_ref + bin_size_el bin_size_a bin_size_b bin_size_c el;\n incr cnt_ref);\n let len = length t in\n if !cnt_ref = len\n then bin_size_nat0 (Nat0.unsafe_of_int len) + !size_ref\n else raise_concurrent_modification ~module_name \"bin_size_t\"\n ;;\n\n let bin_write_t bin_write_a bin_write_b bin_write_c buf ~pos t =\n let len = length t in\n let plen = Nat0.unsafe_of_int len in\n let pos_ref = ref (Write.bin_write_nat0 buf ~pos plen) in\n let cnt_ref = ref 0 in\n iter t ~f:(fun el ->\n pos_ref := bin_write_el bin_write_a bin_write_b bin_write_c buf ~pos:!pos_ref el;\n incr cnt_ref);\n if !cnt_ref = len\n then !pos_ref\n else raise_concurrent_modification ~module_name \"bin_write_t\"\n ;;\n\n let bin_read_t bin_read_a bin_read_b bin_read_c buf ~pos_ref =\n let len = (Read.bin_read_nat0 buf ~pos_ref :> int) in\n let idx = ref 0 in\n let next () =\n if !idx >= len then raise_read_too_much ~module_name \"bin_read_t\";\n incr idx;\n bin_read_el bin_read_a bin_read_b bin_read_c buf ~pos_ref\n in\n let result = init ~len ~next in\n if !idx < len then raise_read_not_enough ~module_name \"bin_read_t\";\n result\n ;;\n\n let __bin_read_t__ _bin_read_a _bin_read_b _bin_read_c _buf ~pos_ref _n =\n raise_variant_wrong_type \"t\" !pos_ref\n ;;\n\n let bin_writer_t bin_writer1 bin_writer2 bin_writer3 =\n { size = (fun v -> bin_size_t bin_writer1.size bin_writer2.size bin_writer3.size v)\n ; write =\n (fun buf ~pos v ->\n bin_write_t bin_writer1.write bin_writer2.write bin_writer3.write buf ~pos v)\n }\n ;;\n\n let bin_reader_t bin_reader1 bin_reader2 bin_reader3 =\n { read =\n (fun buf ~pos_ref ->\n bin_read_t bin_reader1.read bin_reader2.read bin_reader3.read buf ~pos_ref)\n ; vtag_read =\n (fun buf ~pos_ref n ->\n __bin_read_t__\n bin_reader1.read\n bin_reader2.read\n bin_reader3.read\n buf\n ~pos_ref\n n)\n }\n ;;\n\n let bin_t type_class1 type_class2 type_class3 =\n { shape = bin_shape_t type_class1.shape type_class2.shape type_class3.shape\n ; writer = bin_writer_t type_class1.writer type_class2.writer type_class3.writer\n ; reader = bin_reader_t type_class1.reader type_class2.reader type_class3.reader\n }\n ;;\nend\n","(**\n This module defines default converters for the types defined in the OCaml\n standard library.\n*)\n\ninclude Size\n\nlet bin_unit = Type_class.bin_unit\nlet bin_shape_unit = Type_class.bin_shape_unit\nlet bin_writer_unit = Type_class.bin_writer_unit\nlet bin_write_unit = Write.bin_write_unit\nlet bin_reader_unit = Type_class.bin_reader_unit\nlet bin_read_unit = Read.bin_read_unit\n\nlet __bin_read_unit__ _buf ~pos_ref _vint =\n Common.raise_variant_wrong_type \"unit\" !pos_ref\n;;\n\nlet bin_bool = Type_class.bin_bool\nlet bin_shape_bool = Type_class.bin_shape_bool\nlet bin_writer_bool = Type_class.bin_writer_bool\nlet bin_write_bool = Write.bin_write_bool\nlet bin_reader_bool = Type_class.bin_reader_bool\nlet bin_read_bool = Read.bin_read_bool\n\nlet __bin_read_bool__ _buf ~pos_ref _vint =\n Common.raise_variant_wrong_type \"bool\" !pos_ref\n;;\n\nlet bin_string = Type_class.bin_string\nlet bin_shape_string = Type_class.bin_shape_string\nlet bin_writer_string = Type_class.bin_writer_string\nlet bin_write_string = Write.bin_write_string\nlet bin_reader_string = Type_class.bin_reader_string\nlet bin_read_string = Read.bin_read_string\n\nlet __bin_read_string__ _buf ~pos_ref _vint =\n Common.raise_variant_wrong_type \"string\" !pos_ref\n;;\n\nlet bin_bytes = Type_class.bin_bytes\nlet bin_shape_bytes = Type_class.bin_shape_bytes\nlet bin_writer_bytes = Type_class.bin_writer_bytes\nlet bin_write_bytes = Write.bin_write_bytes\nlet bin_reader_bytes = Type_class.bin_reader_bytes\nlet bin_read_bytes = Read.bin_read_bytes\n\nlet __bin_read_bytes__ _buf ~pos_ref _vint =\n Common.raise_variant_wrong_type \"bytes\" !pos_ref\n;;\n\nlet bin_char = Type_class.bin_char\nlet bin_shape_char = Type_class.bin_shape_char\nlet bin_writer_char = Type_class.bin_writer_char\nlet bin_write_char = Write.bin_write_char\nlet bin_reader_char = Type_class.bin_reader_char\nlet bin_read_char = Read.bin_read_char\n\nlet __bin_read_char__ _buf ~pos_ref _vint =\n Common.raise_variant_wrong_type \"char\" !pos_ref\n;;\n\nlet bin_int = Type_class.bin_int\nlet bin_shape_int = Type_class.bin_shape_int\nlet bin_writer_int = Type_class.bin_writer_int\nlet bin_write_int = Write.bin_write_int\nlet bin_reader_int = Type_class.bin_reader_int\nlet bin_read_int = Read.bin_read_int\nlet __bin_read_int__ _buf ~pos_ref _vint = Common.raise_variant_wrong_type \"int\" !pos_ref\nlet bin_float = Type_class.bin_float\nlet bin_shape_float = Type_class.bin_shape_float\nlet bin_writer_float = Type_class.bin_writer_float\nlet bin_write_float = Write.bin_write_float\nlet bin_reader_float = Type_class.bin_reader_float\nlet bin_read_float = Read.bin_read_float\n\nlet __bin_read_float__ _buf ~pos_ref _vint =\n Common.raise_variant_wrong_type \"float\" !pos_ref\n;;\n\ntype float_array = float array\n\nlet bin_float_array = Type_class.bin_float_array\nlet bin_shape_float_array = Type_class.bin_shape_float_array\nlet bin_writer_float_array = Type_class.bin_writer_float_array\nlet bin_write_float_array = Write.bin_write_float_array\nlet bin_reader_float_array = Type_class.bin_reader_float_array\nlet bin_read_float_array = Read.bin_read_float_array\n\nlet __bin_read_float_array__ _buf ~pos_ref _vint =\n Common.raise_variant_wrong_type \"float_array\" !pos_ref\n;;\n\nlet bin_int32 = Type_class.bin_int32\nlet bin_shape_int32 = Type_class.bin_shape_int32\nlet bin_writer_int32 = Type_class.bin_writer_int32\nlet bin_write_int32 = Write.bin_write_int32\nlet bin_reader_int32 = Type_class.bin_reader_int32\nlet bin_read_int32 = Read.bin_read_int32\n\nlet __bin_read_int32__ _buf ~pos_ref _vint =\n Common.raise_variant_wrong_type \"int32\" !pos_ref\n;;\n\nlet bin_int64 = Type_class.bin_int64\nlet bin_shape_int64 = Type_class.bin_shape_int64\nlet bin_writer_int64 = Type_class.bin_writer_int64\nlet bin_write_int64 = Write.bin_write_int64\nlet bin_reader_int64 = Type_class.bin_reader_int64\nlet bin_read_int64 = Read.bin_read_int64\n\nlet __bin_read_int64__ _buf ~pos_ref _vint =\n Common.raise_variant_wrong_type \"int64\" !pos_ref\n;;\n\nlet bin_nativeint = Type_class.bin_nativeint\nlet bin_shape_nativeint = Type_class.bin_shape_nativeint\nlet bin_writer_nativeint = Type_class.bin_writer_nativeint\nlet bin_write_nativeint = Write.bin_write_nativeint\nlet bin_reader_nativeint = Type_class.bin_reader_nativeint\nlet bin_read_nativeint = Read.bin_read_nativeint\n\nlet __bin_read_nativeint__ _buf ~pos_ref _vint =\n Common.raise_variant_wrong_type \"nativeint\" !pos_ref\n;;\n\nlet bin_ref = Type_class.bin_ref\nlet bin_shape_ref = Type_class.bin_shape_ref\nlet bin_writer_ref = Type_class.bin_writer_ref\nlet bin_write_ref = Write.bin_write_ref\nlet bin_reader_ref = Type_class.bin_reader_ref\nlet bin_read_ref = Read.bin_read_ref\n\nlet __bin_read_ref__ _f _buf ~pos_ref _vint =\n Common.raise_variant_wrong_type \"ref\" !pos_ref\n;;\n\nlet bin_lazy_t = Type_class.bin_lazy\nlet bin_shape_lazy_t = Type_class.bin_shape_lazy\nlet bin_writer_lazy_t = Type_class.bin_writer_lazy\nlet bin_write_lazy_t = Write.bin_write_lazy\nlet bin_reader_lazy_t = Type_class.bin_reader_lazy\nlet bin_read_lazy_t = Read.bin_read_lazy\n\nlet __bin_read_lazy_t__ _f _buf ~pos_ref _vint =\n Common.raise_variant_wrong_type \"lazy\" !pos_ref\n;;\n\nlet bin_lazy = Type_class.bin_lazy\nlet bin_shape_lazy = Type_class.bin_shape_lazy\nlet bin_writer_lazy = Type_class.bin_writer_lazy\nlet bin_write_lazy = Write.bin_write_lazy\nlet bin_reader_lazy = Type_class.bin_reader_lazy\nlet bin_read_lazy = Read.bin_read_lazy\n\nlet __bin_read_lazy__ _f _buf ~pos_ref _vint =\n Common.raise_variant_wrong_type \"lazy\" !pos_ref\n;;\n\nlet bin_option = Type_class.bin_option\nlet bin_shape_option = Type_class.bin_shape_option\nlet bin_writer_option = Type_class.bin_writer_option\nlet bin_write_option = Write.bin_write_option\nlet bin_reader_option = Type_class.bin_reader_option\nlet bin_read_option = Read.bin_read_option\n\nlet __bin_read_option__ _f _buf ~pos_ref _vint =\n Common.raise_variant_wrong_type \"option\" !pos_ref\n;;\n\nlet bin_list = Type_class.bin_list\nlet bin_shape_list = Type_class.bin_shape_list\nlet bin_writer_list = Type_class.bin_writer_list\nlet bin_write_list = Write.bin_write_list\nlet bin_reader_list = Type_class.bin_reader_list\nlet bin_read_list = Read.bin_read_list\n\nlet __bin_read_list__ _f _buf ~pos_ref _vint =\n Common.raise_variant_wrong_type \"list\" !pos_ref\n;;\n\nlet bin_array = Type_class.bin_array\nlet bin_shape_array = Type_class.bin_shape_array\nlet bin_writer_array = Type_class.bin_writer_array\nlet bin_write_array = Write.bin_write_array\nlet bin_reader_array = Type_class.bin_reader_array\nlet bin_read_array = Read.bin_read_array\n\nlet __bin_read_array__ _f _buf ~pos_ref _vint =\n Common.raise_variant_wrong_type \"array\" !pos_ref\n;;\n\nlet bin_hashtbl = Type_class.bin_hashtbl\nlet bin_shape_hashtbl = Type_class.bin_shape_hashtbl\nlet bin_writer_hashtbl = Type_class.bin_writer_hashtbl\nlet bin_write_hashtbl = Write.bin_write_hashtbl\nlet bin_reader_hashtbl = Type_class.bin_reader_hashtbl\nlet bin_read_hashtbl = Read.bin_read_hashtbl\n\nlet __bin_read_hashtbl__ _f _g _buf ~pos_ref _vint =\n Common.raise_variant_wrong_type \"hashtbl\" !pos_ref\n;;\n\nlet bin_bigstring = Type_class.bin_bigstring\nlet bin_shape_bigstring = Type_class.bin_shape_bigstring\nlet bin_writer_bigstring = Type_class.bin_writer_bigstring\nlet bin_write_bigstring = Write.bin_write_bigstring\nlet bin_reader_bigstring = Type_class.bin_reader_bigstring\nlet bin_read_bigstring = Read.bin_read_bigstring\n\nlet __bin_read_bigstring__ _buf ~pos_ref _vint =\n Common.raise_variant_wrong_type \"bigstring\" !pos_ref\n;;\n\nlet bin_mat = Type_class.bin_mat\nlet bin_shape_mat = Type_class.bin_shape_mat\nlet bin_writer_mat = Type_class.bin_writer_mat\nlet bin_write_mat = Write.bin_write_mat\nlet bin_reader_mat = Type_class.bin_reader_mat\nlet bin_read_mat = Read.bin_read_mat\nlet __bin_read_mat__ _buf ~pos_ref _vint = Common.raise_variant_wrong_type \"mat\" !pos_ref\nlet bin_float32_mat = Type_class.bin_float32_mat\nlet bin_shape_float32_mat = Type_class.bin_shape_float32_mat\nlet bin_writer_float32_mat = Type_class.bin_writer_float32_mat\nlet bin_write_float32_mat = Write.bin_write_float32_mat\nlet bin_reader_float32_mat = Type_class.bin_reader_float32_mat\nlet bin_read_float32_mat = Read.bin_read_float32_mat\n\nlet __bin_read_float32_mat__ _buf ~pos_ref _vint =\n Common.raise_variant_wrong_type \"float32_mat\" !pos_ref\n;;\n\nlet bin_float64_mat = Type_class.bin_float64_mat\nlet bin_shape_float64_mat = Type_class.bin_shape_float64_mat\nlet bin_writer_float64_mat = Type_class.bin_writer_float64_mat\nlet bin_write_float64_mat = Write.bin_write_float64_mat\nlet bin_reader_float64_mat = Type_class.bin_reader_float64_mat\nlet bin_read_float64_mat = Read.bin_read_float64_mat\n\nlet __bin_read_float64_mat__ _buf ~pos_ref _vint =\n Common.raise_variant_wrong_type \"float64_mat\" !pos_ref\n;;\n\nlet bin_vec = Type_class.bin_vec\nlet bin_shape_vec = Type_class.bin_shape_vec\nlet bin_writer_vec = Type_class.bin_writer_vec\nlet bin_write_vec = Write.bin_write_vec\nlet bin_reader_vec = Type_class.bin_reader_vec\nlet bin_read_vec = Read.bin_read_vec\nlet __bin_read_vec__ _buf ~pos_ref _vint = Common.raise_variant_wrong_type \"vec\" !pos_ref\nlet bin_float32_vec = Type_class.bin_float32_vec\nlet bin_shape_float32_vec = Type_class.bin_shape_float32_vec\nlet bin_writer_float32_vec = Type_class.bin_writer_float32_vec\nlet bin_write_float32_vec = Write.bin_write_float32_vec\nlet bin_reader_float32_vec = Type_class.bin_reader_float32_vec\nlet bin_read_float32_vec = Read.bin_read_float32_vec\n\nlet __bin_read_float32_vec__ _buf ~pos_ref _vint =\n Common.raise_variant_wrong_type \"float32_vec\" !pos_ref\n;;\n\nlet bin_float64_vec = Type_class.bin_float64_vec\nlet bin_shape_float64_vec = Type_class.bin_shape_float64_vec\nlet bin_writer_float64_vec = Type_class.bin_writer_float64_vec\nlet bin_write_float64_vec = Write.bin_write_float64_vec\nlet bin_reader_float64_vec = Type_class.bin_reader_float64_vec\nlet bin_read_float64_vec = Read.bin_read_float64_vec\n\nlet __bin_read_float64_vec__ _buf ~pos_ref _vint =\n Common.raise_variant_wrong_type \"float64_vec\" !pos_ref\n;;\n","module type S = sig\n val pre_test_hook : unit -> unit\nend\n\nlet pre_test_hook = ignore\n","[%%import\n \"config.h\"]\n\nopen! Base\n\n[%%ifdef\n JSC_ARCH_SIXTYFOUR]\n\nexternal nanoseconds_since_unix_epoch_or_zero\n : unit\n -> Int63.t\n = \"time_now_nanoseconds_since_unix_epoch_or_zero\"\n[@@noalloc]\n\n[%%else]\n\nexternal nanoseconds_since_unix_epoch_or_zero\n : unit\n -> Int63.t\n = \"time_now_nanoseconds_since_unix_epoch_or_zero\"\n\n[%%endif]\n\n[%%ifdef\n JSC_POSIX_TIMERS]\n\nlet[@cold] gettime_failed () = failwith \"clock_gettime(CLOCK_REALTIME) failed\"\n\n[%%else]\n\nlet[@cold] gettime_failed () = failwith \"gettimeofday failed\"\n\n[%%endif]\n\nlet nanoseconds_since_unix_epoch () =\n let t = nanoseconds_since_unix_epoch_or_zero () in\n if Int63.( <> ) t Int63.zero then t else gettime_failed ()\n;;\n","module Test_result = struct\n type t = Success | Failure | Error\n\n let to_exit_code = function\n | Success -> 0\n | Failure -> 2\n | Error -> 1\n ;;\n\n let to_string = function\n | Success -> \"success\"\n | Failure -> \"failure\"\n | Error -> \"error\"\n ;;\n\n let combine t1 t2 =\n match t1, t2 with\n | Success, Success -> Success\n | Error , _ | _, Error -> Error\n | Failure, _ | _, Failure -> Failure\n ;;\n\n let combine_all ts = List.fold_left combine Success ts\nend\n\nlet parse_argv argv l f msg =\n try\n Arg.parse_argv argv l f msg\n with\n | Arg.Bad msg -> Printf.eprintf \"%s\" msg; exit 1\n | Arg.Help msg -> Printf.printf \"%s\" msg; exit 0\n;;\n\ntype descr = string\nlet test_modules_ran = ref 0\nlet test_modules_failed = ref 0\nlet tests_ran = ref 0\nlet tests_failed = ref 0\nlet dynamic_lib : string option ref = ref None\ntype filename = string\ntype line_number = int\ntype start_pos = int\ntype end_pos = int\ntype config = (module Inline_test_config.S)\ntype 'a test_function_args\n = config:config\n -> descr:descr\n -> tags:string list\n -> filename:filename\n -> line_number:line_number\n -> start_pos:start_pos\n -> end_pos:end_pos\n -> 'a\n\nmodule Tag_predicate = struct\n type t =\n { required_tags : string list\n ; dropped_tags : string list\n }\n\n let enable_everything = { required_tags = []; dropped_tags = [] }\n\n let drop t tag =\n { dropped_tags = tag :: t.dropped_tags\n ; required_tags = List.filter ((<>) tag) t.required_tags\n }\n\n let require t tag =\n { dropped_tags = List.filter ((<>) tag) t.dropped_tags\n ; required_tags = tag :: t.required_tags\n }\n\n let entire_module_disabled t ~partial_tags:tags =\n List.exists (fun dropped -> List.mem dropped tags) t.dropped_tags\n\n let disabled t ~complete_tags:tags =\n List.exists (fun req -> not (List.mem req tags)) t.required_tags\n || List.exists (fun dropped -> List.mem dropped tags) t.dropped_tags\nend\n\n\ntype which_tests =\n { libname : string\n ; only_test_location : (filename * line_number option * bool ref) list\n ; which_tags : Tag_predicate.t\n }\ntype test_mode =\n { which_tests : which_tests\n ; what_to_do :\n [ `Run_partition of string option\n | `List_partitions\n ]\n }\n\nmodule Action : sig\n type t = [\n | `Ignore\n | `Test_mode of test_mode\n ]\n val get : unit -> t\n val set : t -> unit\nend = struct\n type t = [\n | `Ignore\n | `Test_mode of test_mode\n ]\n let action : t ref = ref `Ignore\n let force_drop =\n try ignore (Sys.getenv \"FORCE_DROP_INLINE_TEST\" : string); true\n with Not_found -> false\n let get () =\n (* This is useful when compiling to javascript.\n Js_of_ocaml can statically evaluate [Sys.getenv \"FORCE_DROP_INLINE_TEST\"]\n and inline the result ([`Ignore]) whenever [get ()] is called.\n Unit tests can then be treated as deadcode since the argument [f] of the [test]\n function below is never used. *)\n if force_drop\n then `Ignore\n else !action\n\n let set v = action := v\nend\n\nmodule Partition : sig\n val found_test : unit -> unit\n val set_current : string -> unit\n val is_current : string option -> bool\n val all : unit -> string list\nend = struct\n let all = Hashtbl.create 23\n let current = ref \"\" let set_current x = current := x\n let found_test () =\n if !current <> \"\" && not (Hashtbl.mem all !current) then\n Hashtbl.add all !current ()\n ;;\n let is_current = function\n | None -> true\n | Some p -> p = !current\n ;;\n let all () =\n List.sort String.compare\n (Hashtbl.fold (fun k () acc -> k :: acc) all [])\n ;;\nend\n\nmodule Module_context = struct\n module T = struct\n type one_module =\n { descr : string\n ; tags : string list\n }\n\n type t = one_module list\n\n let descr t = List.map (fun m -> m.descr) t\n let tags t = List.concat (List.map (fun m -> m.tags) t)\n end\n\n let current : T.t ref = ref []\n\n let with_ ~descr ~tags f =\n let prev = !current in\n current := { T. descr; tags } :: prev;\n try\n f ();\n current := prev;\n with e ->\n current := prev;\n raise e\n\n let current_descr () = T.descr !current\n let current_tags () = T.tags !current\nend\n\nlet verbose = ref false\nlet strict = ref false\nlet show_counts = ref false\nlet list_test_names = ref false\nlet delayed_errors = ref []\nlet stop_on_error = ref false\n\nlet log = ref None\n\nlet time_sec = ref 0.\n\nlet use_color = ref true\nlet in_place = ref false\nlet diff_command = ref None\nlet source_tree_root = ref None\nlet allow_output_patterns = ref false\n\nlet displayed_descr descr filename line start_pos end_pos =\n Printf.sprintf \"File %S, line %d, characters %d-%d%s\"\n filename line start_pos end_pos descr\nlet parse_descr str =\n try Some (Scanf.sscanf str \" File %S , line %d , characters %d - %d %!\"\n (fun file line _start_pos _end_pos -> file, Some line))\n with _ ->\n try Some (Scanf.sscanf str \" File %S , line %d %!\" (fun file line -> file, Some line))\n with _ ->\n try Some (Scanf.sscanf str \" File %S %!\" (fun file -> file, None))\n with _ -> None\n\nlet indent ~by = function\n | \"\" -> \"\"\n | str ->\n let len = String.length str in\n let buf = Buffer.create (len * 2) in\n let indentation = String.make by ' ' in\n Buffer.add_string buf indentation;\n for i = 0 to len - 1; do\n Buffer.add_char buf str.[i];\n if str.[i] = '\\n' && i <> len - 1 then Buffer.add_string buf indentation\n done;\n Buffer.contents buf\n\nlet backtrace_indented ~by =\n let str = Printexc.get_backtrace () in\n indent str ~by\n\nlet () =\n match Array.to_list Sys.argv with\n | name :: \"inline-test-runner\" :: lib :: rest\n when Base.Exported_for_specific_uses.am_testing -> begin\n (* when we see this argument, we switch to test mode *)\n let tests = ref [] in\n let list_partitions = ref false in\n let partition = ref None in\n let tag_predicate = ref Tag_predicate.enable_everything in\n parse_argv (Array.of_list (name :: rest)) (Arg.align [\n \"-list-test-names\", Arg.Unit (fun () -> list_test_names := true; verbose := true),\n \" Do not run tests but show what would have been run\";\n \"-list-partitions\", Arg.Unit (fun () -> list_partitions := true),\n \" Lists all the partitions that contain at least one test or test_module\";\n \"-partition\", Arg.String (fun i -> partition := Some i),\n \" Only run the tests in the given partition\";\n \"-verbose\", Arg.Set verbose, \" Show the tests as they run\";\n \"-stop-on-error\", Arg.Set stop_on_error, \" Run tests only up to the first error \\\n (doesn't work for expect tests)\";\n \"-strict\", Arg.Set strict, \" End with an error if no tests were run\";\n \"-show-counts\", Arg.Set show_counts, \" Show the number of tests ran\";\n \"-log\", Arg.Unit (fun () ->\n (try Sys.remove \"inline_tests.log\" with _ -> ());\n log := Some (open_out \"inline_tests.log\")\n ), \" Log the tests run in inline_tests.log\";\n \"-drop-tag\", Arg.String (fun s ->\n tag_predicate := Tag_predicate.drop !tag_predicate s\n ), \"tag Only run tests not tagged with [tag] (overrides previous -require-tag)\";\n \"-require-tag\", Arg.String (fun s ->\n tag_predicate := Tag_predicate.require !tag_predicate s\n ), \"tag Only run tests tagged with [tag] (overrides previous -drop-tag)\";\n \"-only-test\", Arg.String (fun s ->\n let filename, index =\n match parse_descr s with\n | Some (file, index) -> file, index\n | None ->\n if String.contains s ':' then\n let i = String.index s ':' in\n let filename = String.sub s 0 i in\n let index_string = String.sub s (i + 1) (String.length s - i - 1) in\n let index =\n try int_of_string index_string\n with Failure _ ->\n Printf.eprintf\n \"Argument %s doesn't fit the format filename[:line_number]\\n%!\" s;\n exit 1\n in\n filename, Some index\n else\n s, None\n in\n tests := (filename, index, ref false) :: !tests\n ), \"location Run only the tests specified by all the -only-test options.\n Locations can be one of these forms:\n - file.ml\n - file.ml:line_number\n - File \\\"file.ml\\\"\n - File \\\"file.ml\\\", line 23\n - File \\\"file.ml\\\", line 23, characters 2-3\";\n \"-no-color\", Arg.Clear use_color, \" Summarize tests without using color\";\n \"-in-place\", Arg.Set in_place, \" Update expect tests in place\";\n \"-diff-cmd\", Arg.String (fun s -> diff_command := Some s),\n \" Diff command for tests that require diffing (use - to disable diffing)\";\n \"-allow-output-patterns\", Arg.Set allow_output_patterns,\n \" Allow output patterns in tests expectations\";\n \"-source-tree-root\", Arg.String (fun s -> source_tree_root := Some s),\n \" Path to the root of the source tree\"\n ]) (fun anon ->\n Printf.eprintf \"%s: unexpected anonymous argument %s\\n%!\" name anon;\n exit 1\n ) (Printf.sprintf \"%s %s %s [args]\" name \"inline-test-runner\" lib);\n Action.set (\n `Test_mode\n { which_tests =\n { libname = lib\n ; only_test_location = !tests;\n which_tags = !tag_predicate;\n }\n ; what_to_do =\n if !list_partitions\n then `List_partitions\n else `Run_partition !partition\n })\n end\n | _ ->\n ()\n\nlet am_test_runner =\n match Action.get () with\n | `Test_mode _ -> true\n | `Ignore -> false\n\nlet am_running_inline_test_env_var =\n (* for approximate compatibility, given that the variable is not exactly equivalent\n to what PPX_INLINE_TEST_LIB_AM_RUNNING_INLINE_TEST used to be *)\n \"TESTING_FRAMEWORK\"\n\n(* This value is deprecated in principle, in favor of Core_kernel.am_running_test, so\n we're going to live with the ugly pattern match. *)\nlet am_running_inline_test =\n match Sys.getenv \"PPX_INLINE_TEST_LIB_AM_RUNNING_INLINE_TEST\" with\n | (_ : string) -> true (* for compatibility with people setting this variable directly *)\n | exception Not_found ->\n match Sys.getenv am_running_inline_test_env_var with\n | \"inline-test\" -> true\n | exception Not_found -> false\n | _ -> false\n\nlet testing =\n if am_test_runner\n then `Testing `Am_test_runner\n else\n (if am_running_inline_test\n then `Testing `Am_child_of_test_runner\n else `Not_testing)\n\nlet wall_time_clock_ns () =\n Time_now.nanoseconds_since_unix_epoch ()\n\n\nlet time_without_resetting_random_seeds f =\n let before_ns = wall_time_clock_ns () in\n Base.Exn.protect ~finally:(fun[@inline] () ->\n time_sec := Base.Int63.(wall_time_clock_ns () - before_ns |> to_float) /. 1e9)\n ~f\n\n\nlet saved_caml_random_state = lazy (Caml.Random.State.make [| 100; 200; 300 |])\nlet saved_base_random_state = lazy (Base.Random.State.make [| 111; 222; 333 |])\n\nlet time_and_reset_random_seeds f =\n let caml_random_state = Caml.Random.get_state () in\n let base_random_state = Base.Random.State.copy Base.Random.State.default in\n Caml.Random.set_state (Lazy.force saved_caml_random_state);\n Base.Random.set_state (Lazy.force saved_base_random_state);\n let result = time_without_resetting_random_seeds f in\n Caml.Random.set_state caml_random_state;\n Base.Random.set_state base_random_state;\n result\n\nlet string_of_module_descr () =\n String.concat \"\" (\n List.map (fun s -> \" in TES\" ^ \"T_MODULE at \" ^ String.uncapitalize_ascii s ^ \"\\n\")\n (Module_context.current_descr ())\n )\n\nlet position_match def_filename def_line_number l =\n List.exists (fun (filename, line_number_opt, used) ->\n let position_start =\n String.length def_filename - String.length filename in\n let found =\n position_start >= 0 &&\n let end_of_def_filename =\n String.sub def_filename\n position_start\n (String.length filename) in\n end_of_def_filename = filename\n && (position_start = 0 || def_filename.[position_start - 1] = '/')\n && (match line_number_opt with\n | None -> true\n | Some line_number -> def_line_number = line_number)\n in\n if found then used := true;\n found\n ) l\n\nlet print_delayed_errors () =\n match List.rev !delayed_errors with\n | [] -> ()\n | _ :: _ as delayed_errors ->\n Printf.eprintf \"\\n%s\\n%!\" (String.make 70 '=');\n List.iter (fun message ->\n Printf.eprintf \"%s%!\" message\n ) delayed_errors\n\nlet eprintf_or_delay fmt =\n Printf.ksprintf (fun s ->\n if !verbose then delayed_errors := s :: !delayed_errors\n else Printf.eprintf \"%s%!\" s;\n if !stop_on_error then begin\n print_delayed_errors ();\n exit 2\n end\n ) fmt\n\nlet add_hooks ((module C) : config) f =\n fun () -> C.pre_test_hook (); f ()\n\nlet[@inline never] test ~config ~descr ~tags ~filename:def_filename ~line_number:def_line_number\n ~start_pos ~end_pos f =\n match Action.get () with\n | `Ignore -> ()\n | `Test_mode { which_tests = { libname; only_test_location; which_tags }; what_to_do } ->\n let f = add_hooks config f in\n let descr () = displayed_descr descr def_filename def_line_number start_pos end_pos in\n let complete_tags = tags @ Module_context.current_tags () in\n let should_run =\n Some libname = !dynamic_lib\n && begin match only_test_location with\n | [] -> true\n | _ :: _ -> position_match def_filename def_line_number only_test_location\n end\n && not (Tag_predicate.disabled which_tags ~complete_tags)\n in\n if should_run then begin\n match what_to_do with\n | `List_partitions -> Partition.found_test ()\n | `Run_partition partition ->\n if Partition.is_current partition then begin\n let descr = descr () in\n incr tests_ran;\n begin match !log with\n | None -> ()\n | Some ch -> Printf.fprintf ch \"%s\\n%s\" descr (string_of_module_descr ())\n end;\n if !verbose then begin\n Printf.printf \"%s%!\" descr\n end;\n let print_time_taken () =\n (* If !list_test_names, this is is a harmless zero. *)\n if !verbose then Printf.printf \" (%.3f sec)\\n%!\" !time_sec;\n in\n try\n let failed = not !list_test_names && not (time_and_reset_random_seeds f) in\n print_time_taken ();\n if failed then begin\n incr tests_failed;\n eprintf_or_delay \"%s is false.\\n%s\\n%!\" descr\n (string_of_module_descr ())\n end\n with exn ->\n print_time_taken ();\n let backtrace = backtrace_indented ~by:2 in\n incr tests_failed;\n let exn_str = Printexc.to_string exn in\n let sep = if String.contains exn_str '\\n' then \"\\n\" else \" \" in\n eprintf_or_delay \"%s threw%s%s.\\n%s%s\\n%!\" descr sep exn_str\n backtrace (string_of_module_descr ())\n end\n end\n\nlet set_lib_and_partition static_lib partition =\n match !dynamic_lib with\n | Some _ ->\n (* possible if the interface is used explicitly or if we happen to dynlink something\n that contain tests *)\n ()\n | None ->\n dynamic_lib := Some static_lib;\n match Action.get () with\n | `Ignore -> ()\n | `Test_mode { which_tests; what_to_do } ->\n if which_tests.libname = static_lib then begin\n let requires_partition =\n match what_to_do with\n | `List_partitions | `Run_partition (Some _) -> true\n | `Run_partition None -> false\n in\n if partition = \"\" && requires_partition\n then failwith \"ppx_inline_test: cannot use -list-partition or -partition \\\n without specifying a partition at preprocessing time\"\n else Partition.set_current partition\n end\n\nlet unset_lib static_lib =\n match !dynamic_lib with\n | None ->\n (* not giving an error, because when some annoying people put pa_ounit in their list\n of preprocessors, pa_ounit is set up twice and we have two calls to unset_lib at\n the end of the file, and the second one comes in this branch *)\n ()\n | Some lib ->\n if lib = static_lib then dynamic_lib := None\n\nlet test_unit ~config ~descr ~tags ~filename ~line_number ~start_pos ~end_pos f =\n test ~config ~descr ~tags ~filename ~line_number ~start_pos ~end_pos\n (fun () -> f (); true)\n\nlet[@inline never] test_module ~config ~descr ~tags ~filename:def_filename ~line_number:def_line_number\n ~start_pos ~end_pos f =\n match Action.get () with\n | `Ignore -> ()\n | `Test_mode { which_tests = { libname; only_test_location = _; which_tags }; what_to_do } ->\n let f = add_hooks config f in\n let descr () = displayed_descr descr def_filename def_line_number start_pos end_pos in\n let partial_tags = tags @ Module_context.current_tags () in\n let should_run =\n Some libname = !dynamic_lib\n (* If, no matter what tags a test defines, we certainly will drop all tests within\n this module, then don't run the module at all. This means people can write\n things like the following without breaking the 32-bit build:\n let%test_module [@tags \"64-bits-only\"] = (module struct\n let i = Int64.to_int_exn ....\n end)\n We don't shortcut based on position, as we can't tell what positions the\n inner tests will have. *)\n && not (Tag_predicate.entire_module_disabled which_tags ~partial_tags)\n in\n if should_run then begin\n match what_to_do with\n | `List_partitions -> Partition.found_test ()\n | `Run_partition partition ->\n if Partition.is_current partition then begin\n incr test_modules_ran;\n let descr = descr () in\n try\n Module_context.with_ ~descr ~tags (fun () ->\n (* We do not reset random states upon entering [let%test_module].\n\n Con: Code in test modules can accidentally depend on top-level random\n state effects.\n\n Pros: (1) We don't reset to the same seed on entering a [let%test_module]\n and then a [let%test] inside that module, which could lead to\n accidentally randomly generating the same values in some test. (2) Moving\n code into and out of [let%test_module] does not change its random seed.\n *)\n time_without_resetting_random_seeds f)\n with exn ->\n let backtrace = backtrace_indented ~by:2 in\n incr test_modules_failed;\n let exn_str = Printexc.to_string exn in\n let sep = if String.contains exn_str '\\n' then \"\\n\" else \" \" in\n eprintf_or_delay (\"TES\" ^^ \"T_MODULE at %s threw%s%s.\\n%s%s\\n%!\")\n (String.uncapitalize_ascii descr) sep exn_str backtrace (string_of_module_descr ())\n end\n end\n\nlet summarize () =\n match Action.get () with\n | `Ignore ->\n if Sys.argv <> [||] && Filename.basename Sys.argv.(0) = \"inline_tests_runner.exe\" then\n Printf.eprintf \"inline_tests_runner.exe is not supposed to be run by hand, you \\n\\\n should run the inline_tests_runner script instead.\\n%!\"\n else\n Printf.eprintf \"You are doing something unexpected with the tests. No tests have \\n\\\n been run. You should use the inline_tests_runner script to run \\n\\\n tests.\\n%!\";\n Test_result.Error\n | `Test_mode { which_tests = _; what_to_do = `List_partitions } ->\n List.iter (Printf.printf \"%s\\n\") (Partition.all ());\n Test_result.Success\n | `Test_mode { what_to_do = `Run_partition _; which_tests } -> begin\n begin match !log with\n | None -> ()\n | Some ch -> close_out ch\n end;\n print_delayed_errors ();\n match !tests_failed, !test_modules_failed with\n | 0, 0 -> begin\n if !show_counts then begin\n Printf.eprintf \"%d tests ran, %d test_modules ran\\n%!\" !tests_ran !test_modules_ran\n end;\n let errors =\n let unused_tests =\n List.filter (fun (_, _, used) -> not !used) which_tests.only_test_location\n in\n match unused_tests with\n | [] -> None\n | _ :: _ -> Some unused_tests\n in\n match errors with\n | Some tests ->\n Printf.eprintf \"ppx_inline_test error: the following -only-test flags matched nothing:\";\n List.iter (fun (filename, line_number_opt, _) ->\n match line_number_opt with\n | None -> Printf.eprintf \" %s\" filename\n | Some line_number -> Printf.eprintf \" %s:%d\" filename line_number\n ) tests;\n Printf.eprintf \".\\n%!\";\n Test_result.Error\n | None ->\n if !tests_ran = 0 && !strict then begin\n Printf.eprintf \"ppx_inline_test error: no tests have been run.\\n%!\";\n Test_result.Error\n end else begin\n Test_result.Success\n end\n end\n | count, count_test_modules ->\n Printf.eprintf \"FAILED %d / %d tests%s\\n%!\" count !tests_ran\n (if count_test_modules = 0 then \"\" else Printf.sprintf (\", %d TES\" ^^ \"T_MODULES\") count_test_modules);\n Test_result.Failure\n end\n\nlet use_color = !use_color\nlet in_place = !in_place\nlet diff_command = !diff_command\nlet source_tree_root = !source_tree_root\nlet allow_output_patterns = !allow_output_patterns\n\nlet evaluators = ref [summarize]\nlet add_evaluator ~f = evaluators := f :: !evaluators\nlet exit () =\n List.map (fun f -> f ()) (List.rev !evaluators)\n |> Test_result.combine_all\n |> Test_result.to_exit_code\n |> exit\n","(* this lib should not depend on core *)\nmodule List = struct\n include List\n let compare cmp a b =\n let rec loop a b =\n match a, b with\n | [], [] -> 0\n | [], _ -> -1\n | _ , [] -> 1\n | x :: xs, y :: ys ->\n let n = cmp x y in\n if n = 0 then loop xs ys\n else n\n in\n loop a b\nend\n\nmodule Uid : sig\n type t\n val compare : t -> t -> int\n val equal : t -> t -> bool\n val next : string -> t\n val hash : t -> int\n val name : t -> string\n val static : t\nend = struct\n type t = {\n code : int;\n name : string;\n }\n let compare a b = compare (a.code : int) b.code\n let equal a b = (a.code : int) = b.code\n let uid = ref 0\n let next name = let code = !uid in incr uid; {code; name}\n let hash a = Hashtbl.hash a.code\n let name a = a.name\n let static = next \"static\"\nend\n\nmodule Key = struct\n type t = {\n uid : Uid.t;\n params : t list;\n }\n let rec compare k1 k2 =\n if k1 == k2 then 0 else\n let cmp = Uid.compare k1.uid k2.uid in\n if cmp <> 0 then cmp else\n List.compare compare k1.params k2.params\n let equal a b = compare a b = 0\n let hash = (Hashtbl.hash : t -> int)\n let static = { uid = Uid.static ; params = [] }\nend\n\ntype 'a t = Key.t\ntype 'a typename = 'a t\n\nlet key t = t\nlet uid t = t.Key.uid\nlet name t = Uid.name t.Key.uid\nlet static = Key.static\n\nlet create ?(name=\"Typename.create\") () = { Key.uid = Uid.next name ; params = [] }\n\ninclude struct\n (* The argument for Obj.magic here is the same as the one in core/type_equal *)\n\n let same (type a) (type b) (nm1 : a t) (nm2 : b t) = Key.compare nm1 nm2 = 0\n\n let same_witness (type a) (type b) (nm1 : a t) (nm2 : b t) =\n if Key.compare nm1 nm2 = 0\n then Some (Obj.magic Type_equal.refl : (a, b) Type_equal.t)\n else None\n\n let same_witness_exn (type a) (type b) (nm1 : a t) (nm2 : b t) =\n if Key.compare nm1 nm2 = 0\n then (Obj.magic Type_equal.refl : (a, b) Type_equal.t)\n else failwith \"Typename.same_witness_exn\"\n\nend\n\nmodule type S0 = sig\n type t\n val typename_of_t : t typename\nend\n\nmodule type S1 = sig\n type 'a t\n val typename_of_t : 'a typename -> 'a t typename\nend\n\nmodule type S2 = sig\n type ('a, 'b) t\n val typename_of_t :\n 'a typename\n -> 'b typename\n -> ('a, 'b) t typename\nend\n\nmodule type S3 = sig\n type ('a, 'b, 'c) t\n val typename_of_t :\n 'a typename\n -> 'b typename\n -> 'c typename\n -> ('a, 'b, 'c) t typename\nend\n\nmodule type S4 = sig\n type ('a, 'b, 'c, 'd) t\n val typename_of_t :\n 'a typename\n -> 'b typename\n -> 'c typename\n -> 'd typename\n -> ('a, 'b, 'c, 'd) t typename\nend\n\nmodule type S5 = sig\n type ('a, 'b, 'c, 'd, 'e) t\n val typename_of_t :\n 'a typename\n -> 'b typename\n -> 'c typename\n -> 'd typename\n -> 'e typename\n -> ('a, 'b, 'c, 'd, 'e) t typename\nend\n\nmodule Make0 (X : Named_intf.S0) = struct\n let uid = Uid.next X.name\n let typename_of_t = { Key.uid ; params = [] }\nend\n\nmodule Make1 (X : Named_intf.S1) = struct\n let uid = Uid.next X.name\n let typename_of_t a = { Key.uid ; params = [ a ] }\nend\n\nmodule Make2 (X : Named_intf.S2) = struct\n let uid = Uid.next X.name\n let typename_of_t a b = { Key.uid ; params = [ a ; b ] }\nend\n\nmodule Make3 (X : Named_intf.S3) = struct\n let uid = Uid.next X.name\n let typename_of_t a b c = { Key.uid ; params = [ a ; b ; c ] }\nend\n\nmodule Make4 (X : Named_intf.S4) = struct\n let uid = Uid.next X.name\n let typename_of_t a b c d = { Key.uid ; params = [ a ; b ; c ; d ] }\nend\n\nmodule Make5 (X : Named_intf.S5) = struct\n let uid = Uid.next X.name\n let typename_of_t a b c d e = { Key.uid ; params = [ a ; b ; c ; d ; e ] }\nend\n\nmodule Key_table = Hashtbl.Make (Key)\n\nmodule Table (X : sig\n type 'a t\nend) = struct\n\n type data = Data : 'a t * 'a X.t -> data\n type t = data Key_table.t\n\n let create int = Key_table.create int\n\n let mem table name = Key_table.mem table (key name)\n\n let set table name data =\n Key_table.replace table (key name) (Data (name, data))\n\n let find (type a) table (name : a typename) =\n let data =\n try Some (Key_table.find table (key name))\n with Base.Not_found_s _ | Caml.Not_found -> None\n in\n match data with\n | None -> None\n | Some (Data (name', data)) ->\n (fun (type b) (name' : b typename) (data : b X.t) ->\n let Type_equal.T = (same_witness_exn name' name : (b, a) Type_equal.t) in\n Some (data : a X.t)\n ) name' data\nend\n\nlet fail uid_a uid_b =\n let msg =\n Printf.sprintf \"Typename.Same_witness_exn %S %S\" (Uid.name uid_a) (Uid.name uid_b)\n in\n failwith msg\n\nmodule Same_witness_exn_1 (A : S1) (B : S1) = struct\n type t = { eq : 'a. ('a A.t, 'a B.t) Type_equal.t }\n\n let witness =\n let uid_a = uid (A.typename_of_t static) in\n let uid_b = uid (B.typename_of_t static) in\n if Uid.equal uid_a uid_b\n then { eq = Obj.magic Type_equal.refl }\n else fail uid_a uid_b\nend\n\nmodule Same_witness_exn_2 (A : S2) (B : S2) = struct\n type t = {\n eq : 'a 'b. ( ('a, 'b) A.t,\n ('a, 'b) B.t ) Type_equal.t\n }\n\n let witness =\n let uid_a = uid (A.typename_of_t static static) in\n let uid_b = uid (B.typename_of_t static static) in\n if Uid.equal uid_a uid_b\n then { eq = Obj.magic Type_equal.refl }\n else fail uid_a uid_b\nend\n\nmodule Same_witness_exn_3 (A : S3) (B : S3) = struct\n type t = {\n eq : 'a 'b 'c. ( ('a, 'b, 'c) A.t,\n ('a, 'b, 'c) B.t ) Type_equal.t\n }\n\n let witness =\n let uid_a = uid (A.typename_of_t static static static) in\n let uid_b = uid (B.typename_of_t static static static) in\n if Uid.equal uid_a uid_b\n then { eq = Obj.magic Type_equal.refl }\n else fail uid_a uid_b\nend\n\nmodule Same_witness_exn_4 (A : S4) (B : S4) = struct\n type t = {\n eq : 'a 'b 'c 'd. ( ('a, 'b, 'c, 'd) A.t,\n ('a, 'b, 'c, 'd) B.t ) Type_equal.t\n }\n\n let witness =\n let uid_a = uid (A.typename_of_t static static static static) in\n let uid_b = uid (B.typename_of_t static static static static) in\n if Uid.equal uid_a uid_b\n then { eq = Obj.magic Type_equal.refl }\n else fail uid_a uid_b\nend\n\nmodule Same_witness_exn_5 (A : S5) (B : S5) = struct\n type t = {\n eq : 'a 'b 'c 'd 'e. ( ('a, 'b, 'c, 'd, 'e) A.t,\n ('a, 'b, 'c, 'd, 'e) B.t ) Type_equal.t\n }\n\n let witness =\n let uid_a = uid (A.typename_of_t static static static static static) in\n let uid_b = uid (B.typename_of_t static static static static static) in\n if Uid.equal uid_a uid_b\n then { eq = Obj.magic Type_equal.refl }\n else fail uid_a uid_b\nend\n","open Std_internal\n\nmodule Make0 (X : Named_intf.S0) = struct\n module Name_of_x = Typename.Make0 (X)\n let typename_of_t = Name_of_x.typename_of_t\n let named =\n Typerep.Named.T0 (module struct\n type named = X.t\n type t = X.t\n let typename_of_named = Name_of_x.typename_of_t\n let typename_of_t = typename_of_t\n let witness = Type_equal.refl\n end : Typerep.Named.T0 with type t = X.t)\nend\n\nmodule Make1 (X : Named_intf.S1) = struct\n module Name_of_x = Typename.Make1 (X)\n let typename_of_t = Name_of_x.typename_of_t\n let named (type p1) of_p1 =\n let typename_of_t = Name_of_x.typename_of_t\n (Typerep.typename_of_t of_p1)\n in\n Typerep.Named.T1 (module struct\n type 'a named = 'a X.t\n type a = p1 let a = of_p1\n type t = p1 X.t\n let typename_of_named = Name_of_x.typename_of_t\n let typename_of_t = typename_of_t\n let witness = Type_equal.refl\n end : Typerep.Named.T1 with type t = p1 X.t)\nend\n\nmodule Make2 (X : Named_intf.S2) = struct\n module Name_of_x = Typename.Make2 (X)\n let typename_of_t = Name_of_x.typename_of_t\n let named (type p1) (type p2) of_p1 of_p2 =\n let typename_of_t = Name_of_x.typename_of_t\n (Typerep.typename_of_t of_p1)\n (Typerep.typename_of_t of_p2)\n in\n Typerep.Named.T2 (module struct\n type ('a, 'b) named = ('a, 'b) X.t\n type a = p1 let a = of_p1\n type b = p2 let b = of_p2\n type t = (p1, p2) X.t\n let typename_of_named = Name_of_x.typename_of_t\n let typename_of_t = typename_of_t\n let witness = Type_equal.refl\n end : Typerep.Named.T2 with type t = (p1, p2) X.t)\nend\n\nmodule Make3 (X : Named_intf.S3) = struct\n module Name_of_x = Typename.Make3 (X)\n let typename_of_t = Name_of_x.typename_of_t\n let named (type p1) (type p2) (type p3) of_p1 of_p2 of_p3 =\n let typename_of_t = Name_of_x.typename_of_t\n (Typerep.typename_of_t of_p1)\n (Typerep.typename_of_t of_p2)\n (Typerep.typename_of_t of_p3)\n in\n Typerep.Named.T3 (module struct\n type ('a, 'b, 'c) named = ('a, 'b, 'c) X.t\n type a = p1 let a = of_p1\n type b = p2 let b = of_p2\n type c = p3 let c = of_p3\n type t = (p1, p2, p3) X.t\n let typename_of_named = Name_of_x.typename_of_t\n let typename_of_t = typename_of_t\n let witness = Type_equal.refl\n end : Typerep.Named.T3 with type t = (p1, p2, p3) X.t)\nend\n\nmodule Make4 (X : Named_intf.S4) = struct\n module Name_of_x = Typename.Make4 (X)\n let typename_of_t = Name_of_x.typename_of_t\n let named (type p1) (type p2) (type p3) (type p4) of_p1 of_p2 of_p3 of_p4 =\n let typename_of_t = Name_of_x.typename_of_t\n (Typerep.typename_of_t of_p1)\n (Typerep.typename_of_t of_p2)\n (Typerep.typename_of_t of_p3)\n (Typerep.typename_of_t of_p4)\n in\n Typerep.Named.T4 (module struct\n type ('a, 'b, 'c, 'd) named = ('a, 'b, 'c, 'd) X.t\n type a = p1 let a = of_p1\n type b = p2 let b = of_p2\n type c = p3 let c = of_p3\n type d = p4 let d = of_p4\n type t = (p1, p2, p3, p4) X.t\n let typename_of_named = Name_of_x.typename_of_t\n let typename_of_t = typename_of_t\n let witness = Type_equal.refl\n end : Typerep.Named.T4 with type t = (p1, p2, p3, p4) X.t)\nend\n\nmodule Make5 (X : Named_intf.S5) = struct\n module Name_of_x = Typename.Make5 (X)\n let typename_of_t = Name_of_x.typename_of_t\n let named\n (type p1) (type p2) (type p3) (type p4) (type p5)\n of_p1 of_p2 of_p3 of_p4 of_p5 =\n let typename_of_t = Name_of_x.typename_of_t\n (Typerep.typename_of_t of_p1)\n (Typerep.typename_of_t of_p2)\n (Typerep.typename_of_t of_p3)\n (Typerep.typename_of_t of_p4)\n (Typerep.typename_of_t of_p5)\n in\n Typerep.Named.T5 (module struct\n type ('a, 'b, 'c, 'd, 'e) named = ('a, 'b, 'c, 'd, 'e) X.t\n type a = p1 let a = of_p1\n type b = p2 let b = of_p2\n type c = p3 let c = of_p3\n type d = p4 let d = of_p4\n type e = p5 let e = of_p5\n type t = (p1, p2, p3, p4, p5) X.t\n let typename_of_named = Name_of_x.typename_of_t\n let typename_of_t = typename_of_t\n let witness = Type_equal.refl\n end : Typerep.Named.T5 with type t = (p1, p2, p3, p4, p5) X.t)\nend\n","(**\n Place holder for common Variants and Fields interface\n*)\n\nmodule M (X : sig\n\n (**\n This functor is essentially there because we use this same interface in different\n contexts, with different types for ['a t].\n\n 1) One use case for it is where ['a X.t = 'a Typerep.t]. These interfaces are then\n part of the type witness built for a type containing a record or a variant in its\n structure. [traverse] will give a way of accessing the type representation for the\n arguments of a variant or record type.\n\n 2) Another use case is for building \"staged generic computations\". In that case, the\n type ['a X.t] is the type of the computation that is being built. [traverse]\n returns the computation built for the argument. The interface no longer exports\n the typerep of the arguments in hopes of enforcing that no typerep traversal\n happens at runtime if the computation happen to be a function.\n *)\n type 'a t\nend) = struct\n\n (* The functions prefixed by [internal] as well as the module suffixed by [_internal]\n are used by the code generated by the camlp4 extension [with typerep] as well as some\n internals of the typerep library. Do not consider using these somewhere else. They\n should ideally not be exported outside the typerep library, but the generated code\n needs somehow to access this, even outside. *)\n\n module Tag_internal = struct\n type ('variant, 'args) create = Args of ('args -> 'variant) | Const of 'variant\n type ('variant, 'args) t =\n { label : string\n ; rep : 'args X.t\n ; arity : int\n ; args_labels: string list\n ; index : int\n ; ocaml_repr : int\n ; tyid : 'args Typename.t\n ; create : ('variant, 'args) create\n }\n end\n\n (**\n Witness of a tag, that is an item in a variant type, also called an \"applied\n variant Constructor\"\n\n The first parameter is the variant type, the second is the type of the tag\n parameters. Example:\n\n {[\n type t =\n | A of (int * string)\n | B of string\n | C of { x : int; y : string }\n ]}\n\n this type has three constructors. For each of them we'll have a corresponding\n [Tag.t]:\n\n {[\n val tag_A : (t, (int * string)) Tag.t\n val tag_B : (t, string ) Tag.t\n val tag_C : (t, (int * string)) Tag.t\n ]}\n\n Note, inline record in variant are typed as if their definition was using tuples,\n without the parenthesis. This is consistent with their runtime representation. But\n the distinction is carried and available for introspection as part of the [Tag.t].\n See [args_labels]. *)\n module Tag : sig\n type ('variant, 'args) create = Args of ('args -> 'variant) | Const of 'variant\n type ('variant, 'args) t\n\n (**\n The name of the constructor as it is given in the concrete syntax\n Examples:\n\n {v\n Constructor | label\n -------------------------\n | A of int | \"A\"\n | `a of int | \"a\"\n | `A of int | \"A\"\n | A of { x : int } | \"A\"\n v}\n\n for standard variant, the ocaml syntax implies that this label will always starts\n with a capital letter. For polymorphic variants, this might be a lowercase char.\n For polymorphic variant, this label does not include the [`] character.\n *)\n val label : (_, _) t -> string\n\n (**\n The size of the ocaml heap block containing the arguments\n\n Examples:\n {v\n 0: | A | 'A\n 1: | A of int | `A of int | A of (int * int) | `A of (int * int)\n | `A of int * int\n | A of { x : int}\n 2: | A of int * float\n | A of { x : int; y : string }\n etc.\n v}\n *)\n val arity : (_, _) t -> int\n\n (** The label of the fields for inline records. For other forms of tags, this is the\n empty list. When this returns a non empty list, the length of the returned list\n is equal to the arity.\n\n Example:\n\n {v\n (1) Empty:\n\n | A | 'A\n | A of int | `A of int | A of (int * int) | `A of (int * int)\n | `A of int * int\n | A of int * float\n\n (2) Non empty:\n\n | A of { x : int } -> [ \"x\" ]\n | A of { x : int; y : string } -> [ \"x\" ; \"y\" ]\n v}\n *)\n val args_labels : (_, _) t -> string list\n\n (**\n The index of the constructor in the list of all the variant type's constructors\n Examples:\n {[\n type t =\n | A of int (* 0 *)\n | B (* 1 *)\n | C of int (* 2 *)\n | D of char (* 3 *)\n | E of { x : int } (* 4 *)\n ]}\n *)\n val index : (_, _) t -> int\n\n (**\n ocaml_repr is related to the runtime of objects. this is essentially a way of\n giving one the ability to rebuild dynamically an [Obj.t] representing a tag.\n\n Polymorphic variants:\n ---------------------\n\n [ocaml_repr] is the hash of the label, as done by the compiler.\n Example:\n print_int (Obj.magic `bar) (* 4895187 *)\n print_int (Obj.magic 'foo) (* 5097222 *)\n\n Standards variants:\n -------------------\n\n [ocaml_repr] is the tag corresponding to the constructor within the type.\n the way it works in the ocaml runtime is by partitioning the constructors regarding\n if they have some arguments or not, preserving the order, then assign increasing\n index withing each partition.\n Example:\n\n {[\n type t = (* no arg *) (* args *)\n | A (* 0 *)\n | B of int (* 0 *)\n | C (* 1 *)\n | D of (float * string) (* 1 *)\n | E (* 2 *)\n | F (* 3 *)\n | G of string (* 2 *)\n | H of { x : int } (* 3 *)\n ]}\n *)\n val ocaml_repr : (_, _) t -> int\n\n (**\n Give back a way of constructing a value of that constructor from its arguments.\n\n Examples:\n\n {[\n type t =\n | A of (int * string)\n | B of int * float\n | C\n | D of { x : int; y : string }\n ]}\n\n [create] will return something equivalent to:\n tag_A : [Args (fun (d : (int * string) -> A d)]\n tag_B : [Args (fun (i, f) -> B (i, f))]\n tag_C : [Const C]\n tag_D : [Args (fun (x, y) -> D { x; y })]\n *)\n val create : ('variant, 'args) t -> ('variant, 'args) create\n\n (** return the type_name of the arguments. might be used to perform some lookup based\n on it while building a computation for example *)\n val tyid : (_, 'args) t -> 'args Typename.t\n\n (** get the representation/computation of the arguments *)\n val traverse : (_, 'args) t -> 'args X.t\n\n (* used by the camlp4 extension to build type witnesses, or by some internal parts of\n typerep. you should feel bad if you need to use it in some user code *)\n val internal_use_only : ('a, 'b) Tag_internal.t -> ('a, 'b) t\n end = struct\n include Tag_internal\n let label t = t.label\n let arity t = t.arity\n let args_labels t = t.args_labels\n let index t = t.index\n let ocaml_repr t = t.ocaml_repr\n let create t = t.create\n let tyid t = t.tyid\n let traverse t = t.rep\n\n let internal_use_only t = t\n end\n\n module Variant_internal = struct\n type _ tag = Tag : ('variant, 'a) Tag.t -> 'variant tag\n type _ value = Value : ('variant, 'a) Tag.t * 'a -> 'variant value\n type 'a t = {\n typename : 'a Typename.t;\n tags : 'a tag array;\n polymorphic : bool;\n value : 'a -> 'a value;\n }\n end\n\n module Variant : sig\n\n (**\n An existential type used to gather all the tags constituing a variant\n type. the ['variant] parameter is the variant type, it is the same for all the\n constructors of that variant type. The type of the parameters might be different\n for each constructor and is thus existential\n *)\n type _ tag = Tag : ('variant, 'args) Tag.t -> 'variant tag\n\n (**\n A similar existential constructor to [_ tag] but this one holds a value whose type\n is the arguments of the tag constructor. A value of type ['a value] is a pair of\n (1) a value of variant type ['a] along with (2) some information about the\n constructor within the type ['a]\n *)\n type _ value = Value : ('variant, 'args) Tag.t * 'args -> 'variant value\n\n (**\n Witness of a variant type. The parameter is the type of the variant type witnessed.\n *)\n type 'a t\n\n val typename_of_t : 'a t -> 'a Typename.t\n\n (**\n Returns the number of tags of this variant type definition.\n *)\n val length : 'a t -> int\n\n (**\n Get the nth tag of this variant type, indexed from 0.\n *)\n val tag : 'a t -> int -> 'a tag\n\n (**\n Distinguish polymorphic variants and standard variants. Typically, polymorphic\n variants tags starts with the [`] character.\n Example\n polymorphic variant: type t = [ `A | `B ]\n standard variant: type t = A | B\n *)\n val is_polymorphic : _ t -> bool\n\n (**\n Pattern matching on a value of this variant type.\n *)\n val value : 'a t -> 'a -> 'a value\n\n (**\n folding along the tags of the variant type\n *)\n val fold : 'a t -> init:'acc -> f:('acc -> 'a tag -> 'acc) -> 'acc\n\n (* used by the camlp4 extension to build type witnesses, or by some internal parts of\n typerep. you should feel bad if you need to use it in some user code *)\n val internal_use_only : 'a Variant_internal.t -> 'a t\n end = struct\n include Variant_internal\n let typename_of_t t = t.typename\n let length t = Array.length t.tags\n let tag t index = t.tags.(index)\n let is_polymorphic t = t.polymorphic\n let value t = t.value\n\n let fold t ~init ~f = Array.fold_left f init t.tags\n\n let internal_use_only t = t\n end\n\n module Field_internal = struct\n type ('record, 'field) t = {\n label : string;\n rep : 'field X.t;\n index : int;\n tyid : 'field Typename.t;\n get : ('record -> 'field);\n (* set : ('record -> 'field -> unit) option; (\\* mutable field *\\) *)\n is_mutable : bool;\n }\n end\n\n (**\n Witness of a field, that is an item in a record type.\n The first parameter is the record type, the second is the type of the field.\n Example:\n {[\n type t = { x : int ; y : string }\n ]}\n This type has two fields. for each of them we'll have a corresponding [Field.t]\n\n val field_x : (t, int) Field.t\n val field_y : (t, string) Field.t\n *)\n module Field : sig\n type ('record, 'field) t\n\n (**\n The name of the field as it is given in the concrete syntax\n Examples:\n {[\n { x : int; (* \"x\" *)\n foo : string; (* \"foo\" *)\n bar : float; (* \"bar\" *)\n }\n ]}\n *)\n val label : (_, _) t -> string\n\n (**\n The 0-based index of the field in the list of all fields for this record type.\n Example:\n {[\n type t = {\n x : int; (* 0 *)\n foo : string; (* 1 *)\n bar : string; (* 2 *)\n }\n ]}\n *)\n val index : (_, _) t -> int\n\n (**\n Field accessors. This corresponds to the dot operation.\n [Field.get bar_field t] returns the field [bar] of the record value [t], just the\n same as [t.bar]\n *)\n val get : ('record, 'field) t -> 'record -> 'field\n\n (** return whether the field is mutable, i.e. whether its declaration is prefixed with\n the keyword [mutable] *)\n val is_mutable : (_, _) t -> bool\n\n (** return the type_name of the arguments. Might be used to perform some lookup based\n on it *)\n val tyid : (_, 'field) t -> 'field Typename.t\n\n (** get the computation of the arguments *)\n val traverse : (_, 'field) t -> 'field X.t\n\n (* used by the camlp4 extension to build type witnesses, or by some internal parts of\n typerep. you should feel bad if you need to use it in some user code *)\n val internal_use_only : ('a, 'b) Field_internal.t -> ('a, 'b) t\n end = struct\n include Field_internal\n let label t = t.label\n let index t = t.index\n let get t = t.get\n let is_mutable t = t.is_mutable\n let tyid t = t.tyid\n let traverse t = t.rep\n\n let internal_use_only t = t\n end\n\n module Record_internal = struct\n type _ field = Field : ('record, 'a) Field.t -> 'record field\n type 'record fields = { get : 'field. ('record, 'field) Field.t -> 'field }\n type 'a t = {\n typename : 'a Typename.t;\n fields : 'a field array;\n has_double_array_tag : bool;\n create : 'a fields -> 'a;\n }\n end\n\n module Record : sig\n\n (**\n An existential type used to gather all the fields constituing a record type. the\n ['record] parameter is the record type, it is the same for all the field of that\n record type. The type of the fields might be different for each field and is thus\n existential.\n *)\n type _ field = Field : ('record, 'a) Field.t -> 'record field\n\n (**\n ['record fields] is a type isomorphic to ['record]. This gives a way to get the\n field value for each field of the record. The advantage of this representation is\n that it is convenient for writing generic computations.\n *)\n type 'record fields = { get : 'field. ('record, 'field) Field.t -> 'field }\n\n (**\n Witness of a record type. The parameter is the type of the record type witnessed.\n *)\n type 'a t\n\n val typename_of_t : 'a t -> 'a Typename.t\n\n (**\n Returns the number of fields of this record type definition.\n *)\n val length : 'a t -> int\n\n (**\n Get the nth field of this record type, indexed from 0.\n *)\n val field : 'a t -> int -> 'a field\n\n (**\n This is a low level metadata regarding the way the ocaml compiler represent the\n array underneath that is the runtime value of a record of type ['a] given a witness\n of type ['a t]. [has_double_array_tag w] returns [true] if the array that\n represents runtime values of this type is an optimized ocaml float array.\n Typically, this will be true for record where all fields are statically known as to\n be [floats].\n\n Note that you can't get this information dynamically by inspecting the typerep once\n it is applied, because there is at this point no way to tell whether one of the\n field is polymorphic in the type definition.\n *)\n val has_double_array_tag : _ t -> bool\n\n (**\n Expose one direction of the isomorphism between a value of type ['a] and a value of\n type ['a fields]. Basically, given an encoding way of accessing the value of all\n the fields of a record, create that record and return it.\n *)\n val create : 'a t -> 'a fields -> 'a\n\n (**\n folding along the tags of the variant type\n *)\n val fold : 'a t -> init:'acc -> f:('acc -> 'a field -> 'acc) -> 'acc\n\n (* used by the camlp4 extension to build type witnesses, or by some internal parts of\n typerep. you should feel bad if you need to use it in some user code *)\n val internal_use_only : 'a Record_internal.t -> 'a t\n end = struct\n include Record_internal\n let typename_of_t t = t.typename\n let length t = Array.length t.fields\n let field t index = t.fields.(index)\n let has_double_array_tag t = t.has_double_array_tag\n let create t = t.create\n let fold t ~init ~f = Array.fold_left f init t.fields\n\n let internal_use_only t = t\n end\nend\n\nmodule type S = sig\n type 'a t\n include (module type of M (struct type 'a rep = 'a t type 'a t = 'a rep end))\nend\n","(* using the hash_variant of pa_type_conv at compile time *)\nlet repr_of_poly_variant : [> ] -> int = fun variant ->\n let obj = Obj.repr variant in\n if Obj.is_int obj then Obj.obj obj\n else\n let size = Obj.size obj in\n assert (size = 2);\n let repr = Obj.field obj 0 in\n (assert (Obj.is_int repr));\n Obj.obj repr\n\nlet hash_variant s =\n let accu = ref 0 in\n for i = 0 to String.length s - 1 do\n accu := 223 * !accu + Char.code s.[i]\n done;\n (* reduce to 31 bits *)\n accu := !accu land (1 lsl 31 - 1);\n (* make it signed for 64 bits architectures *)\n if !accu > 0x3FFFFFFF then !accu - (1 lsl 31) else !accu\n\n(* a few unit tests of cases that have triggered diffs in the past of this\n lib *)\nlet () = assert (repr_of_poly_variant `Latency_stats = hash_variant \"Latency_stats\")\nlet () = assert (repr_of_poly_variant `zero = hash_variant \"zero\")\n\nlet double_array_value = Obj.magic 0.\nlet has_double_array_tag a = Obj.double_array_tag = (Obj.tag (Obj.repr a))\nlet () =\n let module M = struct\n type double = { a : float ; b : float }\n type simple = { c : float ; d : int }\n let double = { a = double_array_value; b = double_array_value; }\n let simple = { c = double_array_value; d = double_array_value; }\n end in\n assert (has_double_array_tag M.double);\n assert (not (has_double_array_tag M.simple));\n;;\n","open Std_internal\n\nmodule Make0 (X : Named_intf.S0) : Typerepable.S\n with type t := X.t\n= struct\n module M = Make_typename.Make0(X)\n let typerep_of_t =\n Typerep.Named (M.named, None)\n let typename_of_t = M.typename_of_t\nend\n\nmodule Make1 (X : Named_intf.S1) : Typerepable.S1\n with type 'a t := 'a X.t\n= struct\n module M = Make_typename.Make1(X)\n let typerep_of_t of_p1 =\n Typerep.Named (M.named of_p1, None)\n let typename_of_t = M.typename_of_t\nend\n\nmodule Make2 (X : Named_intf.S2) : Typerepable.S2\n with type ('a, 'b) t := ('a, 'b) X.t\n= struct\n module M = Make_typename.Make2(X)\n let typerep_of_t of_p1 of_p2 =\n Typerep.Named (M.named of_p1 of_p2, None)\n let typename_of_t = M.typename_of_t\nend\n\nmodule Make3 (X : Named_intf.S3) : Typerepable.S3\n with type ('a, 'b, 'c) t := ('a, 'b, 'c) X.t\n= struct\n module M = Make_typename.Make3(X)\n let typerep_of_t of_p1 of_p2 of_p3 =\n Typerep.Named (M.named of_p1 of_p2 of_p3, None)\n let typename_of_t = M.typename_of_t\nend\n\nmodule Make4 (X : Named_intf.S4) : Typerepable.S4\n with type ('a, 'b, 'c, 'd) t := ('a, 'b, 'c, 'd) X.t\n= struct\n module M = Make_typename.Make4(X)\n let typerep_of_t of_p1 of_p2 of_p3 of_p4 =\n Typerep.Named (M.named of_p1 of_p2 of_p3 of_p4, None)\n let typename_of_t = M.typename_of_t\nend\n\nmodule Make5 (X : Named_intf.S5) : Typerepable.S5\n with type ('a, 'b, 'c, 'd, 'e) t := ('a, 'b, 'c, 'd, 'e) X.t\n= struct\n module M = Make_typename.Make5(X)\n let typerep_of_t of_p1 of_p2 of_p3 of_p4 of_p5 =\n Typerep.Named (M.named of_p1 of_p2 of_p3 of_p4 of_p5, None)\n let typename_of_t = M.typename_of_t\nend\n","open! Base\nopen Import\n\nmodule Name : sig\n type t [@@deriving_inline sexp, compare]\n\n include sig\n [@@@ocaml.warning \"-32\"]\n\n include Ppx_sexp_conv_lib.Sexpable.S with type t := t\n\n val compare : t -> t -> int\n end\n [@@ocaml.doc \"@inline\"]\n\n [@@@end]\n\n val relative_to : dir:string -> t -> string\n\n include Identifiable.S with type t := t\nend = struct\n include String\n\n let relative_to ~dir t =\n if not (Caml.Filename.is_relative t) then t else Caml.Filename.concat dir t\n ;;\nend\n\nlet initial_dir =\n let dir_or_error =\n match Caml.Sys.getcwd () with\n | v -> `Ok v\n | exception exn -> `Exn exn\n in\n fun () ->\n match dir_or_error with\n | `Ok v -> v\n | `Exn exn -> raise exn\n;;\n\nmodule Location = struct\n module T = struct\n type t =\n { filename : Name.t\n ; line_number : int\n ; line_start : int\n ; start_pos : int\n ; end_pos : int\n }\n [@@deriving_inline sexp, compare]\n\n let _ = fun (_ : t) -> ()\n\n let t_of_sexp =\n (let _tp_loc = \"file.ml.Location.T.t\" in\n function\n | Ppx_sexp_conv_lib.Sexp.List field_sexps as sexp ->\n let filename_field = ref Ppx_sexp_conv_lib.Option.None\n and line_number_field = ref Ppx_sexp_conv_lib.Option.None\n and line_start_field = ref Ppx_sexp_conv_lib.Option.None\n and start_pos_field = ref Ppx_sexp_conv_lib.Option.None\n and end_pos_field = ref Ppx_sexp_conv_lib.Option.None\n and duplicates = ref []\n and extra = ref [] in\n let rec iter = function\n | Ppx_sexp_conv_lib.Sexp.List\n (Ppx_sexp_conv_lib.Sexp.Atom field_name :: (([] | [ _ ]) as _field_sexps))\n :: tail ->\n let _field_sexp () =\n match _field_sexps with\n | [ x ] -> x\n | [] ->\n Ppx_sexp_conv_lib.Conv_error.record_only_pairs_expected _tp_loc sexp\n | _ -> assert false\n in\n (match field_name with\n | \"filename\" ->\n (match !filename_field with\n | Ppx_sexp_conv_lib.Option.None ->\n let _field_sexp = _field_sexp () in\n let fvalue = Name.t_of_sexp _field_sexp in\n filename_field := Ppx_sexp_conv_lib.Option.Some fvalue\n | Ppx_sexp_conv_lib.Option.Some _ ->\n duplicates := field_name :: !duplicates)\n | \"line_number\" ->\n (match !line_number_field with\n | Ppx_sexp_conv_lib.Option.None ->\n let _field_sexp = _field_sexp () in\n let fvalue = int_of_sexp _field_sexp in\n line_number_field := Ppx_sexp_conv_lib.Option.Some fvalue\n | Ppx_sexp_conv_lib.Option.Some _ ->\n duplicates := field_name :: !duplicates)\n | \"line_start\" ->\n (match !line_start_field with\n | Ppx_sexp_conv_lib.Option.None ->\n let _field_sexp = _field_sexp () in\n let fvalue = int_of_sexp _field_sexp in\n line_start_field := Ppx_sexp_conv_lib.Option.Some fvalue\n | Ppx_sexp_conv_lib.Option.Some _ ->\n duplicates := field_name :: !duplicates)\n | \"start_pos\" ->\n (match !start_pos_field with\n | Ppx_sexp_conv_lib.Option.None ->\n let _field_sexp = _field_sexp () in\n let fvalue = int_of_sexp _field_sexp in\n start_pos_field := Ppx_sexp_conv_lib.Option.Some fvalue\n | Ppx_sexp_conv_lib.Option.Some _ ->\n duplicates := field_name :: !duplicates)\n | \"end_pos\" ->\n (match !end_pos_field with\n | Ppx_sexp_conv_lib.Option.None ->\n let _field_sexp = _field_sexp () in\n let fvalue = int_of_sexp _field_sexp in\n end_pos_field := Ppx_sexp_conv_lib.Option.Some fvalue\n | Ppx_sexp_conv_lib.Option.Some _ ->\n duplicates := field_name :: !duplicates)\n | _ ->\n if !Ppx_sexp_conv_lib.Conv.record_check_extra_fields\n then extra := field_name :: !extra\n else ());\n iter tail\n | ((Ppx_sexp_conv_lib.Sexp.Atom _ | Ppx_sexp_conv_lib.Sexp.List _) as sexp)\n :: _ -> Ppx_sexp_conv_lib.Conv_error.record_only_pairs_expected _tp_loc sexp\n | [] -> ()\n in\n iter field_sexps;\n (match !duplicates with\n | _ :: _ ->\n Ppx_sexp_conv_lib.Conv_error.record_duplicate_fields _tp_loc !duplicates sexp\n | [] ->\n (match !extra with\n | _ :: _ ->\n Ppx_sexp_conv_lib.Conv_error.record_extra_fields _tp_loc !extra sexp\n | [] ->\n (match\n ( !filename_field\n , !line_number_field\n , !line_start_field\n , !start_pos_field\n , !end_pos_field )\n with\n | ( Ppx_sexp_conv_lib.Option.Some filename_value\n , Ppx_sexp_conv_lib.Option.Some line_number_value\n , Ppx_sexp_conv_lib.Option.Some line_start_value\n , Ppx_sexp_conv_lib.Option.Some start_pos_value\n , Ppx_sexp_conv_lib.Option.Some end_pos_value ) ->\n { filename = filename_value\n ; line_number = line_number_value\n ; line_start = line_start_value\n ; start_pos = start_pos_value\n ; end_pos = end_pos_value\n }\n | _ ->\n Ppx_sexp_conv_lib.Conv_error.record_undefined_elements\n _tp_loc\n sexp\n [ ( Ppx_sexp_conv_lib.Conv.( = )\n !filename_field\n Ppx_sexp_conv_lib.Option.None\n , \"filename\" )\n ; ( Ppx_sexp_conv_lib.Conv.( = )\n !line_number_field\n Ppx_sexp_conv_lib.Option.None\n , \"line_number\" )\n ; ( Ppx_sexp_conv_lib.Conv.( = )\n !line_start_field\n Ppx_sexp_conv_lib.Option.None\n , \"line_start\" )\n ; ( Ppx_sexp_conv_lib.Conv.( = )\n !start_pos_field\n Ppx_sexp_conv_lib.Option.None\n , \"start_pos\" )\n ; ( Ppx_sexp_conv_lib.Conv.( = )\n !end_pos_field\n Ppx_sexp_conv_lib.Option.None\n , \"end_pos\" )\n ])))\n | Ppx_sexp_conv_lib.Sexp.Atom _ as sexp ->\n Ppx_sexp_conv_lib.Conv_error.record_list_instead_atom _tp_loc sexp\n : Ppx_sexp_conv_lib.Sexp.t -> t)\n ;;\n\n let _ = t_of_sexp\n\n let sexp_of_t =\n (function\n | { filename = v_filename\n ; line_number = v_line_number\n ; line_start = v_line_start\n ; start_pos = v_start_pos\n ; end_pos = v_end_pos\n } ->\n let bnds = [] in\n let bnds =\n let arg = sexp_of_int v_end_pos in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"end_pos\"; arg ]\n :: bnds\n in\n let bnds =\n let arg = sexp_of_int v_start_pos in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"start_pos\"; arg ]\n :: bnds\n in\n let bnds =\n let arg = sexp_of_int v_line_start in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"line_start\"; arg ]\n :: bnds\n in\n let bnds =\n let arg = sexp_of_int v_line_number in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"line_number\"; arg ]\n :: bnds\n in\n let bnds =\n let arg = Name.sexp_of_t v_filename in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"filename\"; arg ]\n :: bnds\n in\n Ppx_sexp_conv_lib.Sexp.List bnds\n : t -> Ppx_sexp_conv_lib.Sexp.t)\n ;;\n\n let _ = sexp_of_t\n\n let compare =\n (fun a__001_ b__002_ ->\n if Ppx_compare_lib.phys_equal a__001_ b__002_\n then 0\n else (\n match Name.compare a__001_.filename b__002_.filename with\n | 0 ->\n (match compare_int a__001_.line_number b__002_.line_number with\n | 0 ->\n (match compare_int a__001_.line_start b__002_.line_start with\n | 0 ->\n (match compare_int a__001_.start_pos b__002_.start_pos with\n | 0 -> compare_int a__001_.end_pos b__002_.end_pos\n | n -> n)\n | n -> n)\n | n -> n)\n | n -> n)\n : t -> t -> int)\n ;;\n\n let _ = compare\n\n [@@@end]\n\n let compare a b =\n if not (Name.equal a.filename b.filename)\n then invalid_arg \"Expect_test_collector.File.Location.compare\"\n else compare a b\n ;;\n end\n\n include T\n include Comparable.Make (T)\n\n let beginning_of_file filename =\n { filename; line_number = 1; line_start = 0; start_pos = 0; end_pos = 0 }\n ;;\nend\n\nmodule Digest : sig\n type t [@@deriving_inline sexp_of, compare]\n\n include sig\n [@@@ocaml.warning \"-32\"]\n\n val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t\n val compare : t -> t -> int\n end\n [@@ocaml.doc \"@inline\"]\n\n [@@@end]\n\n val to_string : t -> string\n val of_string : string -> t\nend = struct\n type t = string [@@deriving_inline sexp_of, compare]\n\n let _ = fun (_ : t) -> ()\n let sexp_of_t = (sexp_of_string : t -> Ppx_sexp_conv_lib.Sexp.t)\n let _ = sexp_of_t\n let compare = (compare_string : t -> t -> int)\n let _ = compare\n\n [@@@end]\n\n let to_string t = t\n\n let of_string s =\n let expected_length = 32 in\n if String.length s <> expected_length\n then invalid_arg \"Expect_test_collector.File.Digest.of_string, unexpected length\";\n for i = 0 to expected_length - 1 do\n match s.[i] with\n | '0' .. '9' | 'a' .. 'f' -> ()\n | _ -> invalid_arg \"Expect_test_collector.File.Digest.of_string\"\n done;\n s\n ;;\nend\n","open Expect_test_common\nmodule List = ListLabels\n\nmodule Test_outcome = struct\n type t =\n { file_digest : File.Digest.t\n ; location : File.Location.t\n ; expectations : Expectation.Raw.t list\n ; uncaught_exn_expectation : Expectation.Raw.t option\n ; saved_output : (File.Location.t * string) list\n ; trailing_output : string\n ; upon_unreleasable_issue : Expect_test_config_types.Upon_unreleasable_issue.t\n ; uncaught_exn : (exn * Printexc.raw_backtrace) option\n }\nend\n\nlet tests_run : Test_outcome.t list ref = ref []\n\nlet protect ~finally ~f =\n match f () with\n | x ->\n finally ();\n x\n | exception e ->\n finally ();\n raise e\n;;\n\nmodule Current_file = struct\n let current = ref None\n\n let set ~absolute_filename =\n match !current with\n | None -> current := Some absolute_filename\n | Some _ -> failwith \"Expect_test_collector.set: already set\"\n ;;\n\n let unset () =\n match !current with\n | Some _ -> current := None\n | None -> failwith \"Expect_test_collector.unset: not set\"\n ;;\n\n let get () =\n match !current with\n | Some fn -> fn\n | None -> failwith \"Expect_test_collector.get: not set\"\n ;;\nend\n\nmodule Make (C : Expect_test_config_types.S) = struct\n let ( >>= ) t f = C.IO_flush.bind t ~f\n let return = C.IO_flush.return\n\n module C = struct\n include C\n\n let flush () =\n Format.pp_print_flush Format.std_formatter ();\n Format.pp_print_flush Format.err_formatter ();\n Caml.flush Caml.stdout;\n Caml.flush Caml.stderr;\n C.flush ()\n ;;\n end\n\n module Instance : sig\n val save_output : File.Location.t -> unit C.IO_flush.t\n val save_and_return_output : File.Location.t -> string C.IO_flush.t\n\n val exec\n : file_digest:File.Digest.t\n -> location:File.Location.t\n -> expectations:Expectation.Raw.t list\n -> uncaught_exn_expectation:Expectation.Raw.t option\n -> f:(unit -> unit C.IO_run.t)\n -> unit\n end = struct\n type t =\n { mutable saved : (File.Location.t * int) list\n ; chan : out_channel\n ; filename : File.Name.t\n }\n\n external before_test\n : output:out_channel\n -> stdout:out_channel\n -> stderr:out_channel\n -> unit\n = \"expect_test_collector_before_test\"\n\n external after_test\n : stdout:out_channel\n -> stderr:out_channel\n -> unit\n = \"expect_test_collector_after_test\"\n\n external pos_out : out_channel -> int = \"caml_out_channel_pos_fd\"\n\n let get_position () = pos_out stdout\n\n let create () =\n let filename = Filename.temp_file \"expect-test\" \"output\" in\n let chan = open_out_bin filename in\n before_test ~output:chan ~stdout ~stderr;\n { chan; filename = File.Name.of_string filename; saved = [] }\n ;;\n\n let extract_output ic len =\n let s = really_input_string ic len in\n if not (Check_backtraces.contains_backtraces s)\n then s\n else\n Expect_test_config_types.Upon_unreleasable_issue\n .message_when_expectation_contains_backtrace\n C.upon_unreleasable_issue\n ^ s\n ;;\n\n let relative_filename t = File.Name.relative_to ~dir:(File.initial_dir ()) t.filename\n\n let with_ic fname ~f =\n let ic = open_in_bin fname in\n protect ~finally:(fun () -> close_in ic) ~f:(fun () -> f ic)\n ;;\n\n let get_outputs_and_cleanup t =\n let last_ofs = get_position () in\n after_test ~stdout ~stderr;\n close_out t.chan;\n let fname = relative_filename t in\n protect\n ~finally:(fun () -> Sys.remove fname)\n ~f:(fun () ->\n with_ic fname ~f:(fun ic ->\n let ofs, outputs =\n List.fold_left\n (List.rev t.saved)\n ~init:(0, [])\n ~f:(fun (ofs, acc) (loc, next_ofs) ->\n let s = extract_output ic (next_ofs - ofs) in\n next_ofs, (loc, s) :: acc)\n in\n let trailing_output = extract_output ic (last_ofs - ofs) in\n List.rev outputs, trailing_output))\n ;;\n\n let current_test : (File.Location.t * t) option ref = ref None\n\n let get_current () =\n match !current_test with\n | Some (_, t) -> t\n | None ->\n failwith \"Expect_test_collector.Instance.get_current called outside a test.\"\n ;;\n\n let save_output location =\n let t = get_current () in\n C.flush ()\n >>= fun () ->\n let pos = get_position () in\n t.saved <- (location, pos) :: t.saved;\n return ()\n ;;\n\n let save_and_return_output location =\n let t = get_current () in\n C.flush ()\n >>= fun () ->\n let pos = get_position () in\n let prev_pos =\n match t.saved with\n | [] -> 0\n | (_, prev_pos) :: _ -> prev_pos\n in\n t.saved <- (location, pos) :: t.saved;\n flush t.chan;\n let len = pos - prev_pos in\n return\n (with_ic (relative_filename t) ~f:(fun ic ->\n seek_in ic prev_pos;\n really_input_string ic len))\n ;;\n\n let () =\n Caml.at_exit (fun () ->\n match !current_test with\n | None -> ()\n | Some (loc, t) ->\n let blocks, trailing = get_outputs_and_cleanup t in\n Printf.eprintf\n \"File %S, line %d, characters %d-%d:\\n\\\n Error: program exited while expect test was running!\\n\\\n Output captured so far:\\n\\\n %!\"\n (File.Name.to_string loc.filename)\n loc.line_number\n (loc.start_pos - loc.line_start)\n (loc.end_pos - loc.line_start);\n List.iter blocks ~f:(fun (_, s) -> Printf.eprintf \"%s%!\" s);\n Printf.eprintf \"%s%!\" trailing)\n ;;\n\n let rec final_flush ?(count = 0) k =\n let max_attempts = 10 in\n C.flush ()\n >>= fun () ->\n if C.flushed ()\n then k ~append:\"\"\n else if count = max_attempts\n then\n k\n ~append:\n (Printf.sprintf\n \"\\n\\\n STOPPED COLLECTING OUTPUT AFTER %d FLUSHING ATTEMPS\\n\\\n THERE MUST BE A BACKGROUND JOB PRINTING TO STDOUT\\n\"\n max_attempts)\n else final_flush ~count:(count + 1) k\n ;;\n\n let exec ~file_digest ~location ~expectations ~uncaught_exn_expectation ~f =\n let t = create () in\n current_test := Some (location, t);\n let finally uncaught_exn =\n C.run (fun () ->\n C.IO_flush.to_run\n (final_flush (fun ~append ->\n current_test := None;\n let saved_output, trailing_output = get_outputs_and_cleanup t in\n tests_run\n := { file_digest\n ; location\n ; expectations\n ; uncaught_exn_expectation\n ; saved_output\n ; trailing_output = trailing_output ^ append\n ; upon_unreleasable_issue = C.upon_unreleasable_issue\n ; uncaught_exn\n }\n :: !tests_run;\n return ())))\n in\n match C.run f with\n | () -> finally None\n | exception exn ->\n let bt = Printexc.get_raw_backtrace () in\n finally (Some (exn, bt))\n ;;\n end\n\n let save_output = Instance.save_output\n let save_and_return_output = Instance.save_and_return_output\n\n let run\n ~file_digest\n ~(location : File.Location.t)\n ~absolute_filename:defined_in\n ~description\n ~tags\n ~expectations\n ~uncaught_exn_expectation\n ~inline_test_config\n f\n =\n Ppx_inline_test_lib.Runtime.test\n ~config:inline_test_config\n ~descr:\n (match description with\n | None -> \"\"\n | Some s -> \": \" ^ s)\n ~tags\n ~filename:(File.Name.to_string location.filename)\n ~line_number:location.line_number\n ~start_pos:(location.start_pos - location.line_start)\n ~end_pos:(location.end_pos - location.line_start)\n (fun () ->\n let registering_tests_for = Current_file.get () in\n if defined_in <> registering_tests_for\n then\n Printf.ksprintf\n failwith\n \"Trying to run an expect test from the wrong file.\\n\\\n - test declared at %s:%d\\n\\\n - trying to run it from %s\\n\"\n defined_in\n location.line_number\n registering_tests_for\n else (\n (* To avoid capturing not-yet flushed data of the stdout buffer *)\n C.run (fun () -> C.IO_flush.to_run (C.flush ()));\n Instance.exec ~file_digest ~location ~expectations ~uncaught_exn_expectation ~f;\n true))\n ;;\nend\n[@@inline never]\n\nlet tests_run () =\n (* We prepend tests when we encounter them, so reverse the list to reinstate order *)\n List.rev !tests_run\n;;\n","module Upon_unreleasable_issue = struct\n type t =\n [ `CR (** Leaves a CR, so that features cannot be released. *)\n | `Warning_for_collector_testing (** Only for ppx_expect testing; do not use. *)\n ]\nend\n\nmodule type S = sig\n module IO_run : sig\n type 'a t\n end\n\n module IO_flush : sig\n type 'a t\n\n val return : 'a -> 'a t\n val bind : 'a t -> f:('a -> 'b t) -> 'b t\n val to_run : 'a t -> 'a IO_run.t\n end\n\n (** Flush whatever need to be to get pending output out on file descriptor 0. *)\n val flush : unit -> unit IO_flush.t\n\n (** Run an IO operation until completion *)\n val run : (unit -> unit IO_run.t) -> unit\n\n (** Synchronous check that there is no pending output on file description 0. With async,\n there is no guarantee that on the rhs of a [IO.bind (flush ()) ...] the output is\n completely flushed, that's why we need this. *)\n val flushed : unit -> bool\n\n\n (** [upon_unreleasable_issue] specifies how to deal with output that should not be\n released even if it is accepted (e.g. backtraces). The default is [`CR]. *)\n val upon_unreleasable_issue : Upon_unreleasable_issue.t\nend\n\n(** Configuration for running expect tests *)\nmodule type Expect_test_config_types = sig\n (** To configure expect_test, add the following at the top of your .ml file, or in some\n import.ml:\n\n {[\n module Expect_test_config = struct\n include Expect_test_config\n let pre_redirect_hook () = ...\n end\n ]}\n\n Note that since all expect test are also inline tests, the inline test configuration\n also applies to all expect test.\n *)\n\n module Upon_unreleasable_issue : sig\n include module type of Upon_unreleasable_issue\n\n val equal : t -> t -> bool\n val comment_prefix : t -> string\n\n (** Message to print when an expectation contains a backtrace *)\n val message_when_expectation_contains_backtrace : t -> string\n end\n\n module type S = S\nend\n","module type S = Expect_test_config_types_intf.S\n\nmodule type Expect_test_config_types =\n Expect_test_config_types_intf.Expect_test_config_types\n\nmodule Upon_unreleasable_issue = struct\n include Expect_test_config_types_intf.Upon_unreleasable_issue\n\n let equal t1 t2 = t1 = t2\n\n let comment_prefix = function\n | `CR -> \"CR \"\n | `Warning_for_collector_testing -> \"\"\n ;;\n\n let message_when_expectation_contains_backtrace t =\n Printf.sprintf\n {|\n(* %sexpect_test_collector: This test expectation appears to contain a backtrace.\n This is strongly discouraged as backtraces are fragile.\n Please change this test to not include a backtrace. *)\n\n|}\n (comment_prefix t)\n ;;\nend\n","module IO_run = struct\n type 'a t = 'a\n\n let return x = x\n let bind t ~f = f t\nend\n\nmodule IO_flush = struct\n include IO_run\n\n let to_run t = t\nend\n\nlet flush () = () (* the runtime already flushes [stdout] *)\n\nlet run f = f ()\nlet flushed () = true (* the runtime flushed [stdout] before calling this function *)\n\nlet upon_unreleasable_issue = `CR\n","open! Base\n\nmodule T : sig\n type +'a t\n\n val create : (size:int -> random:Splittable_random.State.t -> 'a) -> 'a t\n val generate : 'a t -> size:int -> random:Splittable_random.State.t -> 'a\nend = struct\n type 'a t = (size:int -> random:Splittable_random.State.t -> 'a) Staged.t\n\n let create f : _ t = Staged.stage f\n\n let generate (t : _ t) ~size ~random =\n if size < 0\n then raise_s [%message \"Base_quickcheck.Generator.generate: size < 0\" (size : int)]\n else Staged.unstage t ~size ~random\n ;;\nend\n\ninclude T\n\nlet size = create (fun ~size ~random:_ -> size)\n\nlet fn dom rng =\n create (fun ~size ~random ->\n let random = Splittable_random.State.split random in\n fun x ->\n let hash = Observer0.observe dom x ~size ~hash:(Hash.alloc ()) in\n let random = Splittable_random.State.copy random in\n Splittable_random.State.perturb random (Hash.get_hash_value hash);\n generate rng ~size ~random)\n;;\n\nlet with_size t ~size = create (fun ~size:_ ~random -> generate t ~size ~random)\n\nlet perturb t salt =\n create (fun ~size ~random ->\n Splittable_random.State.perturb random salt;\n generate t ~size ~random)\n;;\n\nlet filter_map t ~f =\n let rec loop ~size ~random =\n let x = generate t ~size ~random in\n match f x with\n | Some y -> y\n | None -> loop ~size:(size + 1) ~random\n in\n create loop\n;;\n\nlet filter t ~f = filter_map t ~f:(fun x -> if f x then Some x else None)\nlet return x = create (fun ~size:_ ~random:_ -> x)\nlet map t ~f = create (fun ~size ~random -> f (generate t ~size ~random))\n\nlet apply tf tx =\n create (fun ~size ~random ->\n let f = generate tf ~size ~random in\n let x = generate tx ~size ~random in\n f x)\n;;\n\nlet bind t ~f =\n create (fun ~size ~random ->\n let x = generate t ~size ~random in\n generate (f x) ~size ~random)\n;;\n\nlet all list = create (fun ~size ~random -> List.map list ~f:(generate ~size ~random))\n\nlet all_unit list =\n create (fun ~size ~random -> List.iter list ~f:(generate ~size ~random))\n;;\n\nmodule For_applicative = Applicative.Make (struct\n type nonrec 'a t = 'a t\n\n let return = return\n let apply = apply\n let map = `Custom map\n end)\n\nlet both = For_applicative.both\nlet map2 = For_applicative.map2\nlet map3 = For_applicative.map3\n\nmodule Applicative_infix = For_applicative.Applicative_infix\ninclude Applicative_infix\n\nmodule For_monad = Monad.Make (struct\n type nonrec 'a t = 'a t\n\n let return = return\n let bind = bind\n let map = `Custom map\n end)\n\nlet ignore_m = For_monad.ignore_m\nlet join = For_monad.join\n\nmodule Monad_infix = For_monad.Monad_infix\ninclude Monad_infix\nmodule Let_syntax = For_monad.Let_syntax\nopen Let_syntax\n\nlet of_list list =\n if List.is_empty list\n then Error.raise_s [%message \"Base_quickcheck.Generator.of_list: empty list\"];\n let array = Array.of_list list in\n let lo = 0 in\n let hi = Array.length array - 1 in\n create (fun ~size:_ ~random ->\n let index = Splittable_random.int random ~lo ~hi in\n array.(index))\n;;\n\nlet union list = join (of_list list)\n\nlet of_weighted_list alist =\n if List.is_empty alist\n then Error.raise_s [%message \"Base_quickcheck.Generator.of_weighted_list: empty list\"];\n let weights, values = List.unzip alist in\n let value_array = Array.of_list values in\n let total_weight, cumulative_weight_array =\n let array = Array.init (Array.length value_array) ~f:(fun _ -> 0.) in\n let sum =\n List.foldi weights ~init:0. ~f:(fun index acc weight ->\n if not (Float.is_finite weight)\n then\n Error.raise_s\n [%message\n \"Base_quickcheck.Generator.of_weighted_list: weight is not finite\"\n (weight : float)];\n if Float.( < ) weight 0.\n then\n Error.raise_s\n [%message\n \"Base_quickcheck.Generator.of_weighted_list: weight is negative\"\n (weight : float)];\n let cumulative = acc +. weight in\n array.(index) <- cumulative;\n cumulative)\n in\n if Float.( <= ) sum 0.\n then\n Error.raise_s\n [%message \"Base_quickcheck.Generator.of_weighted_list: total weight is zero\"];\n sum, array\n in\n create (fun ~size:_ ~random ->\n let choice = Splittable_random.float random ~lo:0. ~hi:total_weight in\n match\n Array.binary_search\n cumulative_weight_array\n ~compare:Float.compare\n `First_greater_than_or_equal_to\n choice\n with\n | Some index -> value_array.(index)\n | None -> assert false)\n;;\n\nlet weighted_union alist = join (of_weighted_list alist)\nlet of_lazy lazy_t = create (fun ~size ~random -> generate (force lazy_t) ~size ~random)\n\nlet fixed_point of_generator =\n let rec lazy_t = lazy (of_generator (of_lazy lazy_t)) in\n force lazy_t\n;;\n\nlet weighted_recursive_union nonrec_list ~f =\n fixed_point (fun self ->\n let rec_list =\n List.map (f self) ~f:(fun (w, t) ->\n ( w\n , let%bind n = size in\n with_size ~size:(n - 1) t ))\n in\n if List.is_empty nonrec_list || List.is_empty rec_list\n then\n raise_s\n [%message\n \"Base_quickcheck.Generator.weighted_recursive_union: lists must be non-empty\"];\n let nonrec_gen = weighted_union nonrec_list in\n let rec_gen = weighted_union (nonrec_list @ rec_list) in\n match%bind size with\n | 0 -> nonrec_gen\n | _ -> rec_gen)\n;;\n\nlet recursive_union nonrec_list ~f =\n let weighted list = List.map list ~f:(fun t -> 1., t) in\n weighted_recursive_union (weighted nonrec_list) ~f:(fun self -> weighted (f self))\n;;\n\nlet sizes ?(min_length = 0) ?(max_length = Int.max_value) () =\n create (fun ~size ~random ->\n assert (min_length <= max_length);\n let upper_bound = min_length + size in\n let max_length =\n if upper_bound >= min_length (* guard against overflow *)\n then min max_length upper_bound\n else max_length\n in\n (* pick a length, weighted low so that most of the size is spent on elements *)\n let len = Splittable_random.Log_uniform.int random ~lo:min_length ~hi:max_length in\n (* if there are no elements return an empty array, otherwise return a non-empty array\n with the size distributed among the elements *)\n if len = 0\n then []\n else (\n let sizes = Array.init len ~f:(fun _ -> 0) in\n let remaining = size - (len - min_length) in\n let max_index = len - 1 in\n for _ = 1 to remaining do\n (* pick an index, weighted low so that we see unbalanced distributions often *)\n let index = Splittable_random.Log_uniform.int random ~lo:0 ~hi:max_index in\n sizes.(index) <- sizes.(index) + 1\n done;\n (* permute the array so that no index is favored over another *)\n for i = 0 to max_index - 1 do\n let j = Splittable_random.int random ~lo:i ~hi:max_index in\n Array.swap sizes i j\n done;\n assert (Array.sum (module Int) sizes ~f:Fn.id + (len - min_length) = size);\n Array.to_list sizes))\n;;\n\nlet unit = return ()\nlet bool = create (fun ~size:_ ~random -> Splittable_random.bool random)\nlet option value_t = union [ return None; map value_t ~f:Option.return ]\nlet either fst_t snd_t = union [ map fst_t ~f:Either.first; map snd_t ~f:Either.second ]\n\nlet result ok_t err_t =\n map (either ok_t err_t) ~f:(function\n | First ok -> Ok ok\n | Second err -> Error err)\n;;\n\nlet list_generic ?min_length ?max_length elt_gen =\n let%bind sizes = sizes ?min_length ?max_length () in\n List.map sizes ~f:(fun size -> with_size ~size elt_gen) |> all\n;;\n\nlet list elt_gen = list_generic elt_gen\nlet list_non_empty elt_gen = list_generic ~min_length:1 elt_gen\n\nlet list_with_length elt_gen ~length =\n list_generic ~min_length:length ~max_length:length elt_gen\n;;\n\nlet list_filtered elts =\n let elts = Array.of_list elts in\n let length_of_input = Array.length elts in\n create (fun ~size:_ ~random ->\n let length_of_output = Splittable_random.int random ~lo:0 ~hi:length_of_input in\n let indices = Array.init length_of_input ~f:Fn.id in\n (* Choose [length_of_output] random values in the prefix of [indices]. *)\n for i = 0 to length_of_output - 1 do\n let j = Splittable_random.int random ~lo:i ~hi:(length_of_input - 1) in\n Array.swap indices i j\n done;\n (* Sort the chosen indices because we don't want to reorder them. *)\n Array.sort indices ~pos:0 ~len:length_of_output ~compare:Int.compare;\n (* Return the chosen elements. *)\n List.init length_of_output ~f:(fun i -> elts.(indices.(i))))\n;;\n\nlet list_permutations list =\n create (fun ~size:_ ~random ->\n let array = Array.of_list list in\n for i = 1 to Array.length array - 1 do\n let j = Splittable_random.int random ~lo:0 ~hi:i in\n Array.swap array i j\n done;\n Array.to_list array)\n;;\n\nlet char_uniform_inclusive lo hi =\n create (fun ~size:_ ~random ->\n Splittable_random.int random ~lo:(Char.to_int lo) ~hi:(Char.to_int hi)\n |> Char.unsafe_of_int)\n;;\n\nlet char_uppercase = char_uniform_inclusive 'A' 'Z'\nlet char_lowercase = char_uniform_inclusive 'a' 'z'\nlet char_digit = char_uniform_inclusive '0' '9'\nlet char_print_uniform = char_uniform_inclusive ' ' '~'\nlet char_uniform = char_uniform_inclusive Char.min_value Char.max_value\nlet char_alpha = union [ char_lowercase; char_uppercase ]\n\nlet char_alphanum =\n weighted_union\n (* Most people probably expect this to be a uniform distribution, not weighted\n toward digits like we would get with [union] (since there are fewer digits than\n letters). *)\n [ 52., char_alpha; 10., char_digit ]\n;;\n\nlet char_whitespace = of_list (List.filter Char.all ~f:Char.is_whitespace)\nlet char_print = weighted_union [ 10., char_alphanum; 1., char_print_uniform ]\n\nlet char =\n weighted_union\n [ 100., char_print\n ; 10., char_uniform\n ; 1., return Char.min_value\n ; 1., return Char.max_value\n ]\n;;\n\n(* Produces a number from 0 or 1 to size + 1, weighted high. We have found this\n distribution empirically useful for string lengths. *)\nlet small_int ~allow_zero =\n create (fun ~size ~random ->\n let lower_bound = if allow_zero then 0 else 1 in\n let upper_bound = size + 1 in\n let weighted_low =\n Splittable_random.Log_uniform.int random ~lo:0 ~hi:(upper_bound - lower_bound)\n in\n let weighted_high = upper_bound - weighted_low in\n weighted_high)\n;;\n\nlet small_positive_or_zero_int = small_int ~allow_zero:true\nlet small_strictly_positive_int = small_int ~allow_zero:false\n\nmodule type Int_with_random = sig\n include Int.S\n\n val uniform : Splittable_random.State.t -> lo:t -> hi:t -> t\n val log_uniform : Splittable_random.State.t -> lo:t -> hi:t -> t\nend\n\nmodule For_integer (Integer : Int_with_random) = struct\n let uniform_inclusive lo hi =\n create (fun ~size:_ ~random -> Integer.uniform random ~lo ~hi)\n ;;\n\n let log_uniform_inclusive lo hi =\n create (fun ~size:_ ~random -> Integer.log_uniform random ~lo ~hi)\n ;;\n\n let non_uniform f lo hi =\n weighted_union [ 0.05, return lo; 0.05, return hi; 0.9, f lo hi ]\n ;;\n\n let inclusive = non_uniform uniform_inclusive\n let log_inclusive = non_uniform log_uniform_inclusive\n let uniform_all = uniform_inclusive Integer.min_value Integer.max_value\n\n let all =\n [%map\n let negative = bool\n and magnitude = log_inclusive Integer.zero Integer.max_value in\n if negative then Integer.bit_not magnitude else magnitude]\n ;;\nend\n\nmodule For_int = For_integer (struct\n include Int\n\n let uniform = Splittable_random.int\n let log_uniform = Splittable_random.Log_uniform.int\n end)\n\nlet int = For_int.all\nlet int_uniform = For_int.uniform_all\nlet int_inclusive = For_int.inclusive\nlet int_uniform_inclusive = For_int.uniform_inclusive\nlet int_log_inclusive = For_int.log_inclusive\nlet int_log_uniform_inclusive = For_int.log_uniform_inclusive\n\nmodule For_int32 = For_integer (struct\n include Int32\n\n let uniform = Splittable_random.int32\n let log_uniform = Splittable_random.Log_uniform.int32\n end)\n\nlet int32 = For_int32.all\nlet int32_uniform = For_int32.uniform_all\nlet int32_inclusive = For_int32.inclusive\nlet int32_uniform_inclusive = For_int32.uniform_inclusive\nlet int32_log_inclusive = For_int32.log_inclusive\nlet int32_log_uniform_inclusive = For_int32.log_uniform_inclusive\n\nmodule For_int63 = For_integer (struct\n include Int63\n\n let uniform = Splittable_random.int63\n let log_uniform = Splittable_random.Log_uniform.int63\n end)\n\nlet int63 = For_int63.all\nlet int63_uniform = For_int63.uniform_all\nlet int63_inclusive = For_int63.inclusive\nlet int63_uniform_inclusive = For_int63.uniform_inclusive\nlet int63_log_inclusive = For_int63.log_inclusive\nlet int63_log_uniform_inclusive = For_int63.log_uniform_inclusive\n\nmodule For_int64 = For_integer (struct\n include Int64\n\n let uniform = Splittable_random.int64\n let log_uniform = Splittable_random.Log_uniform.int64\n end)\n\nlet int64 = For_int64.all\nlet int64_uniform = For_int64.uniform_all\nlet int64_inclusive = For_int64.inclusive\nlet int64_uniform_inclusive = For_int64.uniform_inclusive\nlet int64_log_inclusive = For_int64.log_inclusive\nlet int64_log_uniform_inclusive = For_int64.log_uniform_inclusive\n\nmodule For_nativeint = For_integer (struct\n include Nativeint\n\n let uniform = Splittable_random.nativeint\n let log_uniform = Splittable_random.Log_uniform.nativeint\n end)\n\nlet nativeint = For_nativeint.all\nlet nativeint_uniform = For_nativeint.uniform_all\nlet nativeint_inclusive = For_nativeint.inclusive\nlet nativeint_uniform_inclusive = For_nativeint.uniform_inclusive\nlet nativeint_log_inclusive = For_nativeint.log_inclusive\nlet nativeint_log_uniform_inclusive = For_nativeint.log_uniform_inclusive\nlet float_zero_exponent = Float.ieee_exponent 0.\nlet float_zero_mantissa = Float.ieee_mantissa 0.\n\nlet float_max_positive_subnormal_value =\n Float.one_ulp `Down Float.min_positive_normal_value\n;;\n\nlet float_subnormal_exponent = Float.ieee_exponent Float.min_positive_subnormal_value\nlet float_min_subnormal_mantissa = Float.ieee_mantissa Float.min_positive_subnormal_value\nlet float_max_subnormal_mantissa = Float.ieee_mantissa float_max_positive_subnormal_value\nlet float_max_positive_normal_value = Float.max_finite_value\nlet float_min_normal_exponent = Float.ieee_exponent Float.min_positive_normal_value\nlet float_max_normal_exponent = Float.ieee_exponent float_max_positive_normal_value\nlet float_max_normal_mantissa = Float.ieee_mantissa float_max_positive_normal_value\nlet float_inf_exponent = Float.ieee_exponent Float.infinity\nlet float_inf_mantissa = Float.ieee_mantissa Float.infinity\nlet float_nan_exponent = Float.ieee_exponent Float.nan\nlet float_min_nan_mantissa = Int63.succ float_inf_mantissa\nlet float_max_nan_mantissa = float_max_normal_mantissa\nlet float_num_mantissa_bits = 52\n\n(* We weight mantissas so that \"integer-like\" values, and values with only a few digits\n past the decimal, are reasonably common. *)\nlet float_normal_mantissa =\n let%bind num_bits = For_int.uniform_inclusive 0 float_num_mantissa_bits in\n let%map bits =\n For_int63.inclusive Int63.zero (Int63.pred (Int63.shift_left Int63.one num_bits))\n in\n Int63.shift_left bits (Int.( - ) float_num_mantissa_bits num_bits)\n;;\n\nlet float_exponent_weighted_low lower_bound upper_bound =\n let%map offset = For_int.log_inclusive 0 (Int.( - ) upper_bound lower_bound) in\n Int.( + ) lower_bound offset\n;;\n\nlet float_exponent_weighted_high lower_bound upper_bound =\n let%map offset = For_int.log_inclusive 0 (Int.( - ) upper_bound lower_bound) in\n Int.( - ) upper_bound offset\n;;\n\n(* We weight exponents such that values near 1 are more likely. *)\nlet float_exponent =\n let midpoint = Float.ieee_exponent 1. in\n union\n [ float_exponent_weighted_high float_min_normal_exponent midpoint\n ; float_exponent_weighted_low midpoint float_max_normal_exponent\n ]\n;;\n\nlet float_zero =\n let%map negative = bool in\n Float.create_ieee_exn\n ~negative\n ~exponent:float_zero_exponent\n ~mantissa:float_zero_mantissa\n;;\n\nlet float_subnormal =\n let%map negative = bool\n and exponent = return float_subnormal_exponent\n and mantissa =\n For_int63.log_inclusive float_min_subnormal_mantissa float_max_subnormal_mantissa\n in\n Float.create_ieee_exn ~negative ~exponent ~mantissa\n;;\n\nlet float_normal =\n let%map negative = bool\n and exponent = float_exponent\n and mantissa = float_normal_mantissa in\n Float.create_ieee_exn ~negative ~exponent ~mantissa\n;;\n\nlet float_infinite =\n let%map negative = bool in\n Float.create_ieee_exn\n ~negative\n ~exponent:float_inf_exponent\n ~mantissa:float_inf_mantissa\n;;\n\nlet float_nan =\n let%map negative = bool\n and exponent = return float_nan_exponent\n and mantissa = For_int63.inclusive float_min_nan_mantissa float_max_nan_mantissa in\n Float.create_ieee_exn ~negative ~exponent ~mantissa\n;;\n\nlet float_of_class c =\n match (c : Float.Class.t) with\n | Zero -> float_zero\n | Subnormal -> float_subnormal\n | Normal -> float_normal\n | Infinite -> float_infinite\n | Nan -> float_nan\n;;\n\nlet float_weight_of_class c =\n match (c : Float.Class.t) with\n | Zero -> 1.\n | Subnormal -> 10.\n | Normal -> 100.\n | Infinite -> 1.\n | Nan -> 1.\n;;\n\nlet float_matching_classes filter =\n List.filter_map Float.Class.all ~f:(fun c ->\n if filter c then Some (float_weight_of_class c, float_of_class c) else None)\n |> weighted_union\n;;\n\nlet float_finite =\n float_matching_classes (function\n | Zero | Subnormal | Normal -> true\n | Infinite | Nan -> false)\n;;\n\nlet float_without_nan =\n float_matching_classes (function\n | Zero | Subnormal | Normal | Infinite -> true\n | Nan -> false)\n;;\n\nlet float = float_matching_classes (fun _ -> true)\n\nlet float_finite_non_zero =\n float_matching_classes (function\n | Subnormal | Normal -> true\n | Zero | Infinite | Nan -> false)\n;;\n\nlet float_strictly_positive =\n let%map t = float_finite_non_zero in\n Float.abs t\n;;\n\nlet float_strictly_negative =\n let%map t = float_finite_non_zero in\n ~-.(Float.abs t)\n;;\n\nlet float_positive_or_zero =\n let%map t = float_finite in\n Float.abs t\n;;\n\nlet float_negative_or_zero =\n let%map t = float_finite in\n ~-.(Float.abs t)\n;;\n\nlet float_uniform_exclusive lower_bound upper_bound =\n let open Float.O in\n if (not (Float.is_finite lower_bound)) || not (Float.is_finite upper_bound)\n then\n raise_s\n [%message\n \"Float.uniform_exclusive: bounds are not finite\"\n (lower_bound : float)\n (upper_bound : float)];\n let lower_inclusive = Float.one_ulp `Up lower_bound in\n let upper_inclusive = Float.one_ulp `Down upper_bound in\n if lower_inclusive > upper_inclusive\n then\n raise_s\n [%message\n \"Float.uniform_exclusive: requested range is empty\"\n (lower_bound : float)\n (upper_bound : float)];\n create (fun ~size:_ ~random ->\n Splittable_random.float random ~lo:lower_inclusive ~hi:upper_inclusive)\n;;\n\nlet float_inclusive lower_bound upper_bound =\n weighted_union\n [ 0.05, return lower_bound\n ; 0.05, return upper_bound\n ; 0.9, float_uniform_exclusive lower_bound upper_bound\n ]\n;;\n\nlet string_with_length_of char_gen ~length =\n list_with_length char_gen ~length |> map ~f:String.of_char_list\n;;\n\nlet string_of char_gen =\n bind small_positive_or_zero_int ~f:(fun length ->\n string_with_length_of char_gen ~length)\n;;\n\nlet string_non_empty_of char_gen =\n bind small_strictly_positive_int ~f:(fun length ->\n string_with_length_of char_gen ~length)\n;;\n\nlet string = string_of char\nlet string_non_empty = string_non_empty_of char\nlet string_with_length ~length = string_with_length_of char ~length\n\nlet sexp_of atom =\n fixed_point (fun self ->\n let%bind size = size in\n (* choose a number weighted low so we have a decreasing, but not vanishing, chance\n to generate atoms as size grows *)\n match%bind For_int.log_uniform_inclusive 0 (size + 1) with\n (* generate an atom using the given size *)\n | 0 ->\n let%map atom = atom in\n Sexp.Atom atom\n (* relying on [List.gen] to distribute [size] over sub-sexps *)\n | _ ->\n let%map list = list self in\n Sexp.List list)\n;;\n\nlet sexp = sexp_of string\n\nlet map_tree_using_comparator ~comparator key_gen data_gen =\n let%bind keys = list key_gen in\n let keys = List.dedup_and_sort keys ~compare:comparator.Comparator.compare in\n let%bind data = list_with_length data_gen ~length:(List.length keys) in\n return (Map.Using_comparator.Tree.of_alist_exn ~comparator (List.zip_exn keys data))\n;;\n\nlet set_tree_using_comparator ~comparator elt_gen =\n map (list elt_gen) ~f:(Set.Using_comparator.Tree.of_list ~comparator)\n;;\n\nlet comparator_of_m\n (type a c)\n (module M : Comparator.S with type t = a and type comparator_witness = c)\n =\n M.comparator\n;;\n\nlet map_t_m m key_gen data_gen =\n let comparator = comparator_of_m m in\n map_tree_using_comparator ~comparator key_gen data_gen\n |> map ~f:(Map.Using_comparator.of_tree ~comparator)\n;;\n\nlet set_t_m m elt_gen =\n let comparator = comparator_of_m m in\n set_tree_using_comparator ~comparator elt_gen\n |> map ~f:(Set.Using_comparator.of_tree ~comparator)\n;;\n\nlet bigarray1 t kind layout =\n let%map elts = list t in\n let elts = Array.of_list elts in\n let dim = Array.length elts in\n let offset = Bigarray_helpers.Layout.offset layout in\n Bigarray_helpers.Array1.init kind layout dim ~f:(fun i -> elts.(i - offset))\n;;\n\nlet bigstring = bigarray1 char Char C_layout\nlet float32_vec = bigarray1 float Float32 Fortran_layout\nlet float64_vec = bigarray1 float Float64 Fortran_layout\n\nlet bigarray2_dim =\n match%bind size with\n | 0 -> return (0, 0)\n | max_total_size ->\n let%bind a =\n (* choose a dimension up to [max_total_size], weighted low to give the other\n dimension a good chance of being comparatively high *)\n int_log_uniform_inclusive 1 max_total_size\n in\n let%bind b =\n (* choose a dimension up to [max_total_size / a], weighted high to reach close to\n [max_total_size] most of the time *)\n let max_b = max_total_size / a in\n let%map b_weighted_low = int_log_uniform_inclusive 0 max_b in\n max_b - b_weighted_low\n in\n (* avoid any skew of a vs b by randomly swapping *)\n if%map bool then a, b else b, a\n;;\n\nlet bigarray2 t kind layout =\n let%bind dim1, dim2 = bigarray2_dim in\n let%map elts = list_with_length ~length:dim1 (list_with_length ~length:dim2 t) in\n let elts = Array.of_list_map ~f:Array.of_list elts in\n let offset = Bigarray_helpers.Layout.offset layout in\n Bigarray_helpers.Array2.init kind layout dim1 dim2 ~f:(fun i j ->\n elts.(i - offset).(j - offset))\n;;\n\nlet float32_mat = bigarray2 float Float32 Fortran_layout\nlet float64_mat = bigarray2 float Float64 Fortran_layout\n","open! Base\n\nmodule Layout = struct\n type 'a t = 'a Bigarray.layout\n\n let offset : type a. a t -> int = function\n | Bigarray.Fortran_layout -> 1\n | Bigarray.C_layout -> 0\n ;;\nend\n\nmodule Array1 = struct\n type ('a, 'b, 'c) t = ('a, 'b, 'c) Bigarray.Array1.t\n\n let iteri t ~f =\n let offset = Layout.offset (Bigarray.Array1.layout t) in\n for i = 0 to Bigarray.Array1.dim t - 1 do\n f (i + offset) t.{i + offset}\n done\n ;;\n\n let init (type elt) (kind : (elt, _) Bigarray.kind) layout dim ~f =\n let t = Bigarray.Array1.create kind layout dim in\n iteri t ~f:(fun i (_ : elt) -> t.{i} <- f i);\n t\n ;;\n\n let fold (type elt) (t : (elt, _, _) t) ~init ~f =\n let init = ref init in\n iteri t ~f:(fun i (_ : elt) -> init := f !init t.{i});\n !init\n ;;\n\n let to_array t =\n let offset = Layout.offset (Bigarray.Array1.layout t) in\n Array.init (Bigarray.Array1.dim t) ~f:(fun i -> t.{i + offset})\n ;;\n\n let sexp_of_t sexp_of_elt _sexp_of_pack _sexp_of_layout t =\n [%sexp (to_array t : elt array)]\n ;;\n\n let hash_fold hash_fold_elt state t =\n let state = hash_fold_int state (Bigarray.Array1.dim t) in\n fold t ~init:state ~f:hash_fold_elt\n ;;\nend\n\nmodule Array2 = struct\n type ('a, 'b, 'c) t = ('a, 'b, 'c) Bigarray.Array2.t\n\n let iteri t ~f =\n let offset = Layout.offset (Bigarray.Array2.layout t) in\n for i = 0 to Bigarray.Array2.dim1 t - 1 do\n for j = 0 to Bigarray.Array2.dim2 t - 1 do\n f (i + offset) (j + offset) t.{i + offset, j + offset}\n done\n done\n ;;\n\n let init (type elt) (kind : (elt, _) Bigarray.kind) layout dim1 dim2 ~f =\n let t = Bigarray.Array2.create kind layout dim1 dim2 in\n iteri t ~f:(fun i j (_ : elt) -> t.{i, j} <- f i j);\n t\n ;;\n\n let fold (type elt) (t : (elt, _, _) t) ~init ~f =\n let init = ref init in\n iteri t ~f:(fun (_ : int) (_ : int) elt -> init := f !init elt);\n !init\n ;;\n\n let to_array t =\n let offset = Layout.offset (Bigarray.Array2.layout t) in\n Array.init (Bigarray.Array2.dim1 t) ~f:(fun i ->\n Array.init (Bigarray.Array2.dim2 t) ~f:(fun j -> t.{i + offset, j + offset}))\n ;;\n\n let sexp_of_t sexp_of_elt _sexp_of_pack _sexp_of_layout t =\n [%sexp (to_array t : elt array array)]\n ;;\n\n let hash_fold hash_fold_elt state t =\n let state = hash_fold_int state (Bigarray.Array2.dim1 t) in\n let state = hash_fold_int state (Bigarray.Array2.dim2 t) in\n fold t ~init:state ~f:hash_fold_elt\n ;;\nend\n","open! Base\n\ntype 'a t = 'a -> size:int -> hash:Hash.state -> Hash.state\n\nlet create f : _ t = f\n\nlet observe (t : _ t) x ~size ~hash =\n if size < 0\n then raise_s [%message \"Base_quickcheck.Observer.observe: size < 0\" (size : int)]\n else t x ~size ~hash\n;;\n\nlet opaque _ ~size:_ ~hash = hash\n","open Core_kernel\n\n(* This module implements snarky functions for a sponge that can *conditionally* absorb input,\n while branching minimally. Specifically, if absorbing N field elements, this sponge can absorb\n a variable subset of N field elements, while performing N + 1 invocations of the sponge's\n underlying permutation. *)\n\nlet m = 3\n\nlet capacity = 1\n\nlet rate = m - capacity\n\ntype 'f sponge_state =\n | Absorbing of\n { next_index : 'f Snarky_backendless.Boolean.t\n ; xs : ('f Snarky_backendless.Boolean.t * 'f) list\n }\n | Squeezed of int\n\ntype 'f t =\n { mutable state : 'f array\n ; params : 'f Sponge.Params.t\n ; needs_final_permute_if_empty : bool\n ; mutable sponge_state : 'f sponge_state\n }\n\nmodule Make\n (Impl : Snarky_backendless.Snark_intf.Run)\n (P : Sponge.Intf.Permutation with type Field.t = Impl.Field.t) =\nstruct\n open P\n open Impl\n\n type nonrec t = Field.t t\n\n let _state { state; _ } = Array.copy state\n\n let _copy { state; params; sponge_state; needs_final_permute_if_empty } =\n { state = Array.copy state\n ; params\n ; sponge_state\n ; needs_final_permute_if_empty\n }\n\n let initial_state = Array.init m ~f:(fun _ -> Field.zero)\n\n let of_sponge { Sponge.state; params; sponge_state; id = _ } =\n match sponge_state with\n | Sponge.Squeezed n ->\n { sponge_state = Squeezed n\n ; state = Array.copy state\n ; needs_final_permute_if_empty = true\n ; params\n }\n | Sponge.Absorbed n -> (\n let abs i =\n { sponge_state = Absorbing { next_index = i; xs = [] }\n ; state = Array.copy state\n ; params\n ; needs_final_permute_if_empty = true\n }\n in\n match n with\n | 0 ->\n abs Boolean.false_\n | 1 ->\n abs Boolean.true_\n | 2 ->\n { sponge_state = Absorbing { next_index = Boolean.false_; xs = [] }\n ; state = P.block_cipher params state\n ; needs_final_permute_if_empty = false\n ; params\n }\n | _ ->\n assert false )\n\n let create ?(init = initial_state) params =\n { params\n ; state = Array.copy init\n ; needs_final_permute_if_empty = true\n ; sponge_state = Absorbing { next_index = Boolean.false_; xs = [] }\n }\n\n let () = assert (rate = 2)\n\n let add_in a i x =\n let i_equals_0 = Boolean.not i in\n let i_equals_1 = i in\n (*\n a.(0) <- a.(0) + i_equals_0 * x\n a.(1) <- a.(1) + i_equals_1 * x *)\n List.iteri [ i_equals_0; i_equals_1 ] ~f:(fun j i_equals_j ->\n let a_j' =\n exists Field.typ\n ~compute:\n As_prover.(\n fun () ->\n let a_j = read Field.typ a.(j) in\n if read Boolean.typ i_equals_j then\n Field.Constant.(a_j + read Field.typ x)\n else a_j)\n in\n assert_r1cs x (i_equals_j :> Field.t) Field.(a_j' - a.(j)) ;\n a.(j) <- a_j' )\n\n let consume ~needs_final_permute_if_empty ~params ~start_pos input state =\n assert (Array.length state = m) ;\n let n = Array.length input in\n let pos = ref start_pos in\n let cond_permute permute =\n let permuted = P.block_cipher params (Array.copy state) in\n for i = 0 to m - 1 do\n state.(i) <- Field.if_ permute ~then_:permuted.(i) ~else_:state.(i)\n done\n in\n let pairs = n / 2 in\n let remaining = n - (2 * pairs) in\n for i = 0 to pairs - 1 do\n (* Semantically, we want to do this.\n match b, b' with\n | 1, 1 ->\n if p = 0\n then state := perm {state with .0 += x, .1 += y }\n else state := {perm {state with .1 += x} with .0 += y}\n | 1, 0 ->\n if p = 0\n then state := {state with .0 += x}\n else state := perm {state with .1 += x}\n | 0, 1 ->\n if p = 0\n then state := {state with .0 += y }\n else state := perm {state with .1 += y}\n | 0, 0 ->\n state\n *)\n let b, x = input.(2 * i) in\n let b', y = input.((2 * i) + 1) in\n let p = !pos in\n let p' = Boolean.( lxor ) p b in\n pos := Boolean.( lxor ) p' b' ;\n let y = Field.(y * (b' :> t)) in\n let add_in_y_after_perm =\n (* post\n add in\n (1, 1, 1)\n\n do not add in\n (1, 1, 0)\n (0, 1, 0)\n (0, 1, 1)\n\n (1, 0, 0)\n (1, 0, 1)\n (0, 0, 0)\n (0, 0, 1)\n *)\n (* Only one case where we add in y after the permutation is applied *)\n Boolean.all [ b; b'; p ]\n in\n let add_in_y_before_perm = Boolean.not add_in_y_after_perm in\n add_in state p Field.(x * (b :> t)) ;\n add_in state p' Field.(y * (add_in_y_before_perm :> t)) ;\n let permute =\n (* (b, b', p)\n true:\n (0, 1, 1)\n (1, 0, 1)\n (1, 1, 0)\n (1, 1, 1)\n\n false:\n (0, 0, 0)\n (0, 0, 1)\n (0, 1, 0)\n (1, 0, 0)\n *)\n (* (b && b') || (p && (b || b')) *)\n Boolean.(any [ all [ b; b' ]; all [ p; b ||| b' ] ])\n in\n cond_permute permute ;\n add_in state p' Field.(y * (add_in_y_after_perm :> t))\n done ;\n let empty_imput =\n Boolean.not (Boolean.Array.any (Array.map input ~f:fst))\n in\n let should_permute =\n match remaining with\n | 0 ->\n if needs_final_permute_if_empty then Boolean.(empty_imput ||| !pos)\n else !pos\n | 1 ->\n let b, x = input.(n - 1) in\n let p = !pos in\n pos := Boolean.( lxor ) p b ;\n add_in state p Field.(x * (b :> t)) ;\n if needs_final_permute_if_empty then Boolean.any [ p; b; empty_imput ]\n else Boolean.any [ p; b ]\n | _ ->\n assert false\n in\n cond_permute should_permute\n\n let absorb (t : t) x =\n match t.sponge_state with\n | Absorbing { next_index; xs } ->\n t.sponge_state <- Absorbing { next_index; xs = x :: xs }\n | Squeezed _ ->\n t.sponge_state <- Absorbing { next_index = Boolean.false_; xs = [ x ] }\n\n let squeeze (t : t) =\n match t.sponge_state with\n | Squeezed n ->\n if n = rate then (\n t.state <- block_cipher t.params t.state ;\n t.sponge_state <- Squeezed 1 ;\n t.state.(0) )\n else (\n t.sponge_state <- Squeezed (n + 1) ;\n t.state.(n) )\n | Absorbing { next_index; xs } ->\n consume ~needs_final_permute_if_empty:t.needs_final_permute_if_empty\n ~start_pos:next_index ~params:t.params (Array.of_list_rev xs) t.state ;\n t.sponge_state <- Squeezed 1 ;\n t.state.(0)\n\n let%test_module \"opt_sponge\" =\n ( module struct\n module S = Sponge.Make_sponge (P)\n\n let%test_unit \"correctness\" =\n let params : _ Sponge.Params.t =\n let a () =\n Array.init 3 ~f:(fun _ -> Field.(constant (Constant.random ())))\n in\n { mds = Array.init 3 ~f:(fun _ -> a ())\n ; round_constants = Array.init 40 ~f:(fun _ -> a ())\n }\n in\n let gen =\n let open Quickcheck.Generator.Let_syntax in\n let%bind n = Quickcheck.Generator.small_positive_int\n and n_pre = Quickcheck.Generator.small_positive_int in\n let%map xs = List.gen_with_length n Field.Constant.gen\n and bs = List.gen_with_length n Bool.quickcheck_generator\n and pre = List.gen_with_length n_pre Field.Constant.gen in\n (pre, List.zip_exn bs xs)\n in\n Quickcheck.test gen ~trials:10 ~f:(fun (pre, ps) ->\n let filtered =\n List.filter_map ps ~f:(fun (b, x) -> if b then Some x else None)\n in\n let init () =\n let pre =\n exists\n (Typ.list ~length:(List.length pre) Field.typ)\n ~compute:(fun () -> pre)\n in\n let s = S.create params in\n List.iter pre ~f:(S.absorb s) ;\n s\n in\n let filtered_res =\n let n = List.length filtered in\n Impl.Internal_Basic.Test.checked_to_unchecked\n (Typ.list ~length:n Field.typ)\n Field.typ\n (fun xs ->\n make_checked (fun () ->\n let s = init () in\n List.iter xs ~f:(S.absorb s) ;\n S.squeeze s ) )\n filtered\n in\n let opt_res =\n let n = List.length ps in\n Impl.Internal_Basic.Test.checked_to_unchecked\n (Typ.list ~length:n (Typ.tuple2 Boolean.typ Field.typ))\n Field.typ\n (fun xs ->\n make_checked (fun () ->\n let s =\n if List.length pre = 0 then create params\n else of_sponge (init ())\n in\n List.iter xs ~f:(absorb s) ;\n squeeze s ) )\n ps\n in\n if not (Field.Constant.equal filtered_res opt_res) then\n failwithf\n !\"hash(%{sexp:Field.Constant.t list}) = %{sexp:Field.Constant.t}\\n\\\n hash(%{sexp:(bool * Field.Constant.t) list}) = \\\n %{sexp:Field.Constant.t}\"\n filtered filtered_res ps opt_res () )\n end )\nend\n","open! Base\n\nmodule T : sig\n type 'a t\n\n val atomic : _ t\n val create : ('a -> 'a Sequence.t) -> 'a t\n val shrink : 'a t -> 'a -> 'a Sequence.t\nend = struct\n type 'a t = 'a -> 'a Sequence.t\n\n let atomic _ = Sequence.empty\n let create = Fn.id\n let shrink = Fn.id\nend\n\ninclude T\n\nlet map t ~f ~f_inverse = create (fun x -> Sequence.map ~f (shrink t (f_inverse x)))\nlet filter t ~f = create (fun x -> Sequence.filter ~f (shrink t x))\n\nlet filter_map t ~f ~f_inverse =\n create (fun x -> Sequence.filter_map ~f (shrink t (f_inverse x)))\n;;\n\nlet of_lazy lazy_t = create (fun x -> Sequence.of_lazy (lazy (shrink (force lazy_t) x)))\n\nlet fixed_point of_shrinker =\n let rec lazy_t = lazy (of_shrinker (of_lazy lazy_t)) in\n of_lazy lazy_t\n;;\n\nlet both fst_t snd_t =\n create (fun (fst, snd) ->\n Sequence.round_robin\n [ Sequence.map (shrink fst_t fst) ~f:(fun fst -> fst, snd)\n ; Sequence.map (shrink snd_t snd) ~f:(fun snd -> fst, snd)\n ])\n;;\n\nlet unit = atomic\nlet bool = atomic\nlet char = atomic\nlet int = atomic\nlet int32 = atomic\nlet int63 = atomic\nlet int64 = atomic\nlet nativeint = atomic\nlet float = atomic\n\nlet bigarray1 src =\n let dim = Bigarray.Array1.dim src in\n match dim with\n | 0 -> Sequence.empty\n | _ ->\n let kind = Bigarray.Array1.kind src in\n let layout = Bigarray.Array1.layout src in\n let offset = Bigarray_helpers.Layout.offset layout in\n Sequence.init dim ~f:(fun to_skip ->\n let to_skip = to_skip + offset in\n Bigarray_helpers.Array1.init kind layout (dim - 1) ~f:(fun i ->\n src.{(if i < to_skip then i else i + 1)}))\n;;\n\nlet bigstring = create bigarray1\nlet float32_vec = create bigarray1\nlet float64_vec = create bigarray1\n\nlet bigarray2 =\n let module Dims = struct\n type t =\n { dim1 : int\n ; dim2 : int\n }\n [@@deriving fields]\n\n let create a = Bigarray.Array2.{ dim1 = dim1 a; dim2 = dim2 a }\n end\n in\n let shrink field src =\n let dims = Dims.create src in\n match Field.get field dims with\n | 0 -> Sequence.empty\n | _ ->\n let kind = Bigarray.Array2.kind src in\n let layout = Bigarray.Array2.layout src in\n let offset = Bigarray_helpers.Layout.offset layout in\n let ({ dim1; dim2 } : Dims.t) = Field.map field dims ~f:Int.pred in\n Sequence.init (Field.get field dims) ~f:(fun to_skip ->\n let to_skip = to_skip + offset in\n let skip i = if i < to_skip then i else i + 1 in\n Bigarray_helpers.Array2.init kind layout dim1 dim2 ~f:(fun dim1 dim2 ->\n let ({ dim1; dim2 } : Dims.t) = Field.map field { dim1; dim2 } ~f:skip in\n src.{dim1, dim2}))\n in\n fun src ->\n Sequence.round_robin [ shrink Dims.Fields.dim1 src; shrink Dims.Fields.dim2 src ]\n;;\n\nlet float32_mat = create bigarray2\nlet float64_mat = create bigarray2\n\nlet option value_t =\n create (function\n | None -> Sequence.empty\n | Some value ->\n Sequence.append\n (Sequence.singleton None)\n (Sequence.map ~f:Option.return (shrink value_t value)))\n;;\n\nlet list elt_t =\n fixed_point (fun list_t ->\n create (function\n | [] -> Sequence.empty\n | head :: tail ->\n Sequence.round_robin\n [ Sequence.singleton tail\n ; Sequence.map (shrink elt_t head) ~f:(fun head -> head :: tail)\n ; Sequence.map (shrink list_t tail) ~f:(fun tail -> head :: tail)\n ]))\n;;\n\nlet string = map (list char) ~f:String.of_char_list ~f_inverse:String.to_list\n\nlet sexp =\n fixed_point (fun shrinker ->\n create (function\n | Sexp.Atom _ -> Sequence.empty\n | Sexp.List l ->\n let shrink_list =\n shrink (list shrinker) l |> Sequence.map ~f:(fun l -> Sexp.List l)\n in\n let shrink_tree = Sequence.of_list l in\n Sequence.round_robin [ shrink_list; shrink_tree ]))\n;;\n\nlet either fst_t snd_t =\n create (fun either ->\n match (either : _ Either.t) with\n | First fst -> Sequence.map (shrink fst_t fst) ~f:Either.first\n | Second snd -> Sequence.map (shrink snd_t snd) ~f:Either.second)\n;;\n\nlet result ok_t err_t =\n map\n (either ok_t err_t)\n ~f:(function\n | First ok -> Ok ok\n | Second err -> Error err)\n ~f_inverse:(function\n | Ok ok -> First ok\n | Error err -> Second err)\n;;\n\nlet map_tree_using_comparator ~comparator key_t data_t =\n create (fun tree ->\n let alist = Map.Using_comparator.Tree.to_alist tree in\n let drop_keys =\n Sequence.map (Sequence.of_list alist) ~f:(fun (k, _) ->\n Map.Using_comparator.Tree.remove ~comparator tree k)\n in\n let shrink_keys =\n Sequence.round_robin\n (List.map alist ~f:(fun (key, data) ->\n let tree = Map.Using_comparator.Tree.remove ~comparator tree key in\n Sequence.filter_map (shrink key_t key) ~f:(fun smaller_key ->\n match\n Map.Using_comparator.Tree.add\n ~comparator\n tree\n ~key:smaller_key\n ~data\n with\n | `Ok tree -> Some tree\n | `Duplicate -> None)))\n in\n let shrink_data =\n Sequence.round_robin\n (List.map alist ~f:(fun (key, data) ->\n Sequence.map (shrink data_t data) ~f:(fun smaller_data ->\n Map.Using_comparator.Tree.set ~comparator tree ~key ~data:smaller_data)))\n in\n Sequence.round_robin [ drop_keys; shrink_keys; shrink_data ])\n;;\n\nlet set_tree_using_comparator ~comparator elt_t =\n create (fun tree ->\n let list = Set.Using_comparator.Tree.to_list tree in\n let drop_elts =\n Sequence.map (Sequence.of_list list) ~f:(fun elt ->\n Set.Using_comparator.Tree.remove ~comparator tree elt)\n in\n let shrink_elts =\n Sequence.round_robin\n (List.map list ~f:(fun elt ->\n let tree = Set.Using_comparator.Tree.remove ~comparator tree elt in\n Sequence.filter_map (shrink elt_t elt) ~f:(fun smaller_elt ->\n match Set.Using_comparator.Tree.mem ~comparator tree smaller_elt with\n | true -> None\n | false ->\n Some (Set.Using_comparator.Tree.add tree ~comparator smaller_elt))))\n in\n Sequence.round_robin [ drop_elts; shrink_elts ])\n;;\n\nlet map_t key_t data_t =\n create (fun map_t ->\n let comparator = Map.comparator map_t in\n let t =\n map\n (map_tree_using_comparator ~comparator key_t data_t)\n ~f:(Map.Using_comparator.of_tree ~comparator)\n ~f_inverse:Map.Using_comparator.to_tree\n in\n shrink t map_t)\n;;\n\nlet set_t elt_t =\n create (fun set_t ->\n let comparator = Set.comparator set_t in\n let t =\n map\n (set_tree_using_comparator ~comparator elt_t)\n ~f:(Set.Using_comparator.of_tree ~comparator)\n ~f_inverse:Set.Using_comparator.to_tree\n in\n shrink t set_t)\n;;\n","open! Base\ninclude Test_intf\n\nmodule Config = struct\n module Seed = struct\n type t =\n | Nondeterministic\n | Deterministic of string\n [@@deriving sexp_of]\n end\n\n module Potentially_infinite_sequence = struct\n type 'a t = 'a Sequence.t\n\n let sexp_of_t sexp_of_elt sequence =\n let prefix, suffix = Sequence.split_n sequence 100 in\n let prefix = List.map prefix ~f:sexp_of_elt in\n let suffix =\n match Sequence.is_empty suffix with\n | true -> []\n | false -> [ [%message \"...\"] ]\n in\n Sexp.List (prefix @ suffix)\n ;;\n end\n\n type t =\n { seed : Seed.t\n ; test_count : int\n ; shrink_count : int\n ; sizes : int Potentially_infinite_sequence.t\n }\n [@@deriving fields, sexp_of]\nend\n\nlet default_config : Config.t =\n { seed = Deterministic \"an arbitrary but deterministic string\"\n ; test_count = 10_000\n ; shrink_count = 10_000\n ; sizes = Sequence.cycle_list_exn (List.range 0 ~start:`inclusive 30 ~stop:`inclusive)\n }\n;;\n\nlet lazy_nondeterministic_state = lazy (Random.State.make_self_init ())\n\nlet initial_random_state ~config =\n match Config.seed config with\n | Nondeterministic ->\n Splittable_random.State.create (force lazy_nondeterministic_state)\n | Deterministic string -> Splittable_random.State.of_int (String.hash string)\n;;\n\nlet one_size_per_test ~(config : Config.t) =\n Sequence.unfold ~init:(config.sizes, 0) ~f:(fun (sizes, number_of_size_values) ->\n match number_of_size_values >= config.test_count with\n | true -> None\n | false ->\n (match Sequence.next sizes with\n | Some (size, remaining_sizes) ->\n Some (size, (remaining_sizes, number_of_size_values + 1))\n | None ->\n raise_s\n [%message\n \"Base_quickcheck.Test.run: insufficient size values for test count\"\n ~test_count:(config.test_count : int)\n (number_of_size_values : int)]))\n;;\n\nlet shrink_error ~shrinker ~config ~f input error =\n let rec loop ~shrink_count ~alternates input error =\n match shrink_count with\n | 0 -> input, error\n | _ ->\n let shrink_count = shrink_count - 1 in\n (match Sequence.next alternates with\n | None -> input, error\n | Some (alternate, alternates) ->\n (match f alternate with\n | Ok () -> loop ~shrink_count ~alternates input error\n | Error error ->\n let alternates = Shrinker.shrink shrinker alternate in\n loop ~shrink_count ~alternates alternate error))\n in\n let shrink_count = Config.shrink_count config in\n let alternates = Shrinker.shrink shrinker input in\n loop ~shrink_count ~alternates input error\n;;\n\nlet input_sequence ~config ~examples ~generator =\n let random = initial_random_state ~config in\n Sequence.append\n (Sequence.of_list examples)\n (one_size_per_test ~config\n |> Sequence.map ~f:(fun size -> Generator.generate generator ~size ~random))\n;;\n\nlet with_sample ~f ?(config = default_config) ?(examples = []) generator =\n let sequence = input_sequence ~config ~examples ~generator in\n f sequence\n;;\n\nlet result (type a) ~f ?(config = default_config) ?(examples = []) m =\n let (module M : S with type t = a) = m in\n with_sample M.quickcheck_generator ~config ~examples ~f:(fun sequence ->\n match\n Sequence.fold_result sequence ~init:() ~f:(fun () input ->\n match f input with\n | Ok () -> Ok ()\n | Error error -> Error (input, error))\n with\n | Ok () -> Ok ()\n | Error (input, error) ->\n let shrinker = M.quickcheck_shrinker in\n let input, error = shrink_error ~shrinker ~config ~f input error in\n Error (input, error))\n;;\n\nlet run (type a) ~f ?config ?examples (module M : S with type t = a) =\n let f x =\n Or_error.try_with_join ~backtrace:(Backtrace.Exn.am_recording ()) (fun () -> f x)\n in\n match result ~f ?config ?examples (module M) with\n | Ok () -> Ok ()\n | Error (input, error) ->\n Or_error.error_s\n [%message \"Base_quickcheck.Test.run: test failed\" (input : M.t) (error : Error.t)]\n;;\n\nlet with_sample_exn ~f ?config ?examples generator =\n let f x = Or_error.try_with (fun () -> f x) in\n with_sample ~f ?config ?examples generator |> Or_error.ok_exn\n;;\n\nlet run_exn ~f ?config ?examples testable =\n let f x =\n Or_error.try_with ~backtrace:(Backtrace.Exn.am_recording ()) (fun () -> f x)\n in\n run ~f ?config ?examples testable |> Or_error.ok_exn\n;;\n","open! Base\ninclude Observer0\n\nlet unmap t ~f = create (fun x ~size ~hash -> observe t (f x) ~size ~hash)\nlet of_hash_fold f = create (fun x ~size:_ ~hash -> f hash x)\nlet of_lazy lazy_t = create (fun x ~size ~hash -> observe (force lazy_t) x ~size ~hash)\n\nlet fixed_point wrap =\n let rec lazy_t = lazy (wrap (of_lazy lazy_t)) in\n of_lazy lazy_t\n;;\n\nlet unit = opaque\nlet bool = of_hash_fold Bool.hash_fold_t\nlet char = of_hash_fold Char.hash_fold_t\nlet int = of_hash_fold Int.hash_fold_t\nlet int32 = of_hash_fold Int32.hash_fold_t\nlet int63 = of_hash_fold Int63.hash_fold_t\nlet int64 = of_hash_fold Int64.hash_fold_t\nlet nativeint = of_hash_fold Nativeint.hash_fold_t\nlet float = of_hash_fold Float.hash_fold_t\nlet string = of_hash_fold String.hash_fold_t\nlet sexp = of_hash_fold Sexp.hash_fold_t\nlet bigstring = of_hash_fold (Bigarray_helpers.Array1.hash_fold hash_fold_char)\nlet float32_vec = of_hash_fold (Bigarray_helpers.Array1.hash_fold hash_fold_float)\nlet float64_vec = of_hash_fold (Bigarray_helpers.Array1.hash_fold hash_fold_float)\nlet float32_mat = of_hash_fold (Bigarray_helpers.Array2.hash_fold hash_fold_float)\nlet float64_mat = of_hash_fold (Bigarray_helpers.Array2.hash_fold hash_fold_float)\n\nlet either fst_t snd_t =\n create (fun either ~size ~hash ->\n match (either : _ Either.t) with\n | First fst -> observe fst_t fst ~size ~hash:(hash_fold_int hash 1)\n | Second snd -> observe snd_t snd ~size ~hash:(hash_fold_int hash 2))\n;;\n\nlet result ok_t err_t =\n unmap (either ok_t err_t) ~f:(function\n | Ok ok -> First ok\n | Error err -> Second err)\n;;\n\nlet both fst_t snd_t =\n create (fun (fst, snd) ~size ~hash ->\n let hash = observe fst_t fst ~size ~hash in\n let hash = observe snd_t snd ~size ~hash in\n hash)\n;;\n\nlet option value_t =\n unmap (either opaque value_t) ~f:(function\n | None -> First ()\n | Some value -> Second value)\n;;\n\nlet list elt_t =\n create (fun list ~size ~hash ->\n let random = Splittable_random.State.of_int (Hash.get_hash_value hash) in\n let length = List.length list in\n let sizes =\n Generator.sizes ~min_length:length ~max_length:length ()\n |> Generator.generate ~size ~random\n in\n List.fold2_exn list sizes ~init:(hash_fold_int hash 0) ~f:(fun hash elt size ->\n observe elt_t elt ~size ~hash:(hash_fold_int hash 1)))\n;;\n\nlet fn dom rng =\n create (fun f ~size ~hash ->\n let random = Splittable_random.State.of_int (Hash.get_hash_value hash) in\n let sizes =\n (* Empirically, doubling the size when generating the list of inputs gives us much\n better coverage of the space of functions. *)\n Generator.generate (Generator.sizes ()) ~size:(size * 2) ~random\n in\n List.fold sizes ~init:hash ~f:(fun hash size ->\n let x = Generator.generate dom ~size ~random in\n observe rng (f x) ~size ~hash))\n;;\n\nlet map_tree key_obs data_obs =\n unmap (list (both key_obs data_obs)) ~f:Map.Using_comparator.Tree.to_alist\n;;\n\nlet set_tree elt_obs = unmap (list elt_obs) ~f:Set.Using_comparator.Tree.to_list\n\nlet map_t key_obs data_obs =\n unmap (map_tree key_obs data_obs) ~f:Map.Using_comparator.to_tree\n;;\n\nlet set_t elt_obs = unmap (set_tree elt_obs) ~f:Set.Using_comparator.to_tree\n","open! Base\nopen! Blit\n\ninclude Test_blit_intf\n\nmodule type S_gen = sig\n open Blit\n type 'a src\n type 'a dst\n (* val blit : ('a src, 'a dst) blit*)\n val blito : ('a src, 'a dst) blito\n (* val unsafe_blit : ('a src, 'a dst) blit*)\n val sub : ('a src, 'a dst) sub\n (*val subo : ('a src, 'a dst) subo*)\nend\n\nmodule type For_tests_gen = sig\n module Elt : sig\n type 'a t\n val equal : bool t -> bool t -> bool\n val of_bool : bool -> bool t\n end\n\n type 'a z\n\n module Src : sig\n type 'a t\n val length : _ t -> int\n val create_bool : len:int -> bool z t\n val get : 'a z t -> int -> 'a Elt.t\n val set : 'a z t -> int -> 'a Elt.t -> unit\n end\n\n module Dst : sig\n type 'a t\n val length : _ t -> int\n val create_bool : len:int -> bool z t\n val get : 'a z t -> int -> 'a Elt.t\n val set : 'a z t -> int -> 'a Elt.t -> unit\n val overlapping_src_dst\n : [ `Do_not_check\n | `Check of ('a Src.t -> 'a t)\n ]\n end\nend\n\nmodule Test_gen\n (For_tests : For_tests_gen)\n (Tested : S_gen\n with type 'a src := 'a For_tests.Src.t\n with type 'a dst := 'a For_tests.Dst.t)\n= struct\n open Tested\n open For_tests\n\n let init ~len ~create ~set ~f =\n let t = create ~len in\n for i = 0 to len - 1 do\n set t i (f i);\n done;\n t\n ;;\n\n (* Test [blit]. *)\n let%test_unit _ =\n let elt1 = Elt.of_bool true in\n let elt2 = Elt.of_bool false in\n assert (not (Elt.equal elt1 elt2));\n let src_bit i = if i land 0x1 = 0 then elt1 else elt2 in\n let dst_bit i = if i land 0x1 = 0 then elt2 else elt1 in\n let n = 4 in\n for src_length = 0 to n do\n for dst_length = 0 to n do\n for src_pos = 0 to src_length do\n for dst_pos = 0 to dst_length do\n for src_len = 0 to min (src_length - src_pos) (dst_length - dst_pos) do\n try\n let is_in_range i = i >= dst_pos && i < dst_pos + src_len in\n let check length get =\n fun name sequence ~expect ->\n for i = 0 to length sequence - 1 do\n if not (Elt.equal (get sequence i) (expect i)) then\n raise_s [%message \"bug\" (name : string) (i : int)]\n done;\n in\n let check_src = check Src.length Src.get in\n let check_dst = check Dst.length Dst.get in\n let src =\n init ~len:src_length ~create:Src.create_bool ~set:Src.set ~f:src_bit\n in\n assert (Src.length src = src_length);\n let dst =\n init ~len:dst_length ~create:Dst.create_bool ~set:Dst.set ~f:dst_bit\n in\n assert (Dst.length dst = dst_length);\n let init_src () =\n for i = 0 to src_length - 1 do\n Src.set src i (src_bit i);\n done\n in\n blito ~src ~src_pos ~src_len ~dst ~dst_pos ();\n check_src \"blit src\" src ~expect:src_bit;\n check_dst \"blit dst\" dst ~expect:(fun i ->\n if is_in_range i\n then src_bit (src_pos + i - dst_pos)\n else dst_bit i);\n begin match Dst.overlapping_src_dst with\n | `Do_not_check -> ()\n | `Check src_to_dst ->\n if dst_pos + src_len <= src_length then begin\n init_src ();\n let dst = src_to_dst src in\n if false then begin\n blito ~src ~src_pos ~src_len ~dst ~dst_pos ();\n check_dst \"blit dst overlapping\" dst ~expect:(fun i ->\n src_bit (if is_in_range i then (src_pos + i - dst_pos) else i));\n end;\n end;\n end;\n (* Check [sub]. *)\n init_src ();\n let dst = sub src ~pos:src_pos ~len:src_len in\n check_src \"sub src\" src ~expect:src_bit;\n check_dst \"sub dst\" dst ~expect:(fun i -> src_bit (src_pos + i));\n with exn ->\n raise_s [%message\n \"bug\"\n (exn : exn)\n (src_length : int) (src_pos : int)\n (dst_length : int) (dst_pos : int)]\n done;\n done;\n done;\n done;\n done\n ;;\nend\n\nmodule Test1\n (Sequence : Sequence1 with type 'a elt := 'a poly)\n (Tested : S1 with type 'a t := 'a Sequence.t)\n = Test_gen\n (struct\n module Elt = struct\n type 'a t = 'a\n let equal = Poly.equal\n let of_bool = Fn.id\n end\n type 'a z = 'a Sequence.z\n module Src = Sequence\n module Dst = struct\n include Sequence\n let overlapping_src_dst = `Check Fn.id\n end\n end)\n (Tested)\n\nmodule Test1_generic\n (Elt : Elt1)\n (Sequence : Sequence1 with type 'a elt := 'a Elt.t)\n (Tested : S1 with type 'a t := 'a Sequence.t)\n = Test_gen\n (struct\n module Elt = Elt\n type 'a z = 'a Sequence.z\n module Src = Sequence\n module Dst = struct\n include Sequence\n let overlapping_src_dst = `Check Fn.id\n end\n end)\n (Tested)\n\nmodule Elt_to_elt1 (Elt : Elt) = struct\n type 'a t = Elt.t\n let equal = Elt.equal\n let of_bool = Elt.of_bool\nend\n\nmodule Test\n (Elt : Elt)\n (Sequence : Sequence with type elt := Elt.t)\n (Tested : S with type t := Sequence.t)\n = Test_gen\n (struct\n module Elt = Elt_to_elt1(Elt)\n type 'a z = unit\n module Src = struct\n open Sequence\n type nonrec 'a t = t\n let length = length\n let get = get\n let set = set\n let create_bool = create\n end\n module Dst = struct\n include Src\n let overlapping_src_dst = `Check Fn.id\n end\n end)\n (Tested)\n\nmodule Test_distinct\n (Elt : Elt)\n (Src : Sequence with type elt := Elt.t)\n (Dst : Sequence with type elt := Elt.t)\n (Tested : S_distinct\n with type src := Src.t\n with type dst := Dst.t)\n = Test_gen\n (struct\n module Elt = Elt_to_elt1 (Elt)\n type 'a z = unit\n module Src = struct\n open Src\n type nonrec 'a t = t\n let length = length\n let get = get\n let set = set\n let create_bool = create\n end\n module Dst = struct\n open Dst\n type nonrec 'a t = t\n let length = length\n let get = get\n let set = set\n let create_bool = create\n let overlapping_src_dst = `Do_not_check\n end\n end)\n (Tested)\n\nmodule Make_and_test\n (Elt : Elt)\n (Sequence : sig\n include Sequence with type elt := Elt.t\n val unsafe_blit : (t, t) blit\n end) = struct\n module B = Make (Sequence)\n include Test (Elt) (Sequence) (B)\n include B\nend\n\nmodule Make_distinct_and_test\n (Elt : Elt)\n (Src : Sequence with type elt := Elt.t)\n (Dst : sig\n include Sequence with type elt := Elt.t\n val unsafe_blit : (Src.t, t) blit\n end) = struct\n module B = Make_distinct (Src) (Dst)\n include Test_distinct (Elt) (Src) (Dst) (B)\n include B\nend\n\nmodule Make1_and_test\n (Sequence : sig\n include Blit.Sequence1\n include Sequence1\n with type 'a t := 'a t\n with type 'a elt := 'a poly\n end) = struct\n module B = Make1 (Sequence)\n include Test1 (Sequence) (B)\n include B\nend\n\nmodule Make1_generic_and_test\n (Elt : Elt1)\n (Sequence : sig\n include Blit.Sequence1\n include Sequence1\n with type 'a t := 'a t\n with type 'a elt := 'a Elt.t\n end) = struct\n module B = Make1_generic (Sequence)\n include Test1_generic (Elt) (Sequence) (B)\n include B\nend\n","open! Base\nopen! Binary_searchable\n\ninclude Test_binary_searchable_intf\n\nmodule type S_gen = sig\n open Binary_searchable\n\n type 'a t\n type 'a elt\n\n val binary_search : ('a t, 'a elt, 'a elt) binary_search\n val binary_search_segmented : ('a t, 'a elt) binary_search_segmented\nend\n\nmodule type Indexable_gen_and_for_test = sig\n include S_gen\n\n module For_test : sig\n val compare : bool elt -> bool elt -> int\n val small : bool elt\n val big : bool elt\n val of_array : bool elt array -> bool t\n end\nend\n\nmodule Test_gen (M : Indexable_gen_and_for_test) = struct\n open M\n\n let%test_module \"test_binary_searchable\" =\n (module struct\n let compare = For_test.compare\n let elt_compare = For_test.compare\n\n let s = For_test.small\n let b = For_test.big\n\n let binary_search ?pos ?len ~compare t how v =\n binary_search ?pos ?len ~compare (For_test.of_array t) how v\n\n let (=) = Poly.equal\n\n let%test _ = binary_search ~compare [| |] `First_equal_to s = None\n let%test _ = binary_search ~compare [| s |] `First_equal_to s = Some 0\n let%test _ = binary_search ~compare [| s |] `First_equal_to b = None\n let%test _ = binary_search ~compare [| s ; b |] `First_equal_to s = Some 0\n let%test _ = binary_search ~compare [| s ; b |] `First_equal_to b = Some 1\n let%test _ = binary_search ~compare [| b ; b |] `First_equal_to s = None\n let%test _ = binary_search ~compare [| s ; s |] `First_equal_to b = None\n let%test _ = binary_search ~compare [| s ; b ; b |] `First_equal_to b = Some 1\n let%test _ = binary_search ~compare [| s ; s ; b |] `First_equal_to s = Some 0\n let%test _ = binary_search ~compare [| b ; b ; b |] `First_equal_to s = None\n\n let%test _ = binary_search ~compare [| |] `Last_equal_to s = None\n let%test _ = binary_search ~compare [| s |] `Last_equal_to s = Some 0\n let%test _ = binary_search ~compare [| s |] `Last_equal_to b = None\n let%test _ = binary_search ~compare [| s ; b |] `Last_equal_to b = Some 1\n let%test _ = binary_search ~compare [| s ; b |] `Last_equal_to s = Some 0\n let%test _ = binary_search ~compare [| b ; b |] `Last_equal_to s = None\n let%test _ = binary_search ~compare [| s ; s |] `Last_equal_to b = None\n let%test _ = binary_search ~compare [| s ; b ; b |] `Last_equal_to b = Some 2\n let%test _ = binary_search ~compare [| s ; s ; b |] `Last_equal_to s = Some 1\n let%test _ = binary_search ~compare [| b ; b; b |] `Last_equal_to s = None\n\n let%test _ = binary_search ~compare [||] `First_greater_than_or_equal_to s = None\n let%test _ = binary_search ~compare [| b |] `First_greater_than_or_equal_to s = Some 0\n let%test _ = binary_search ~compare [| s |] `First_greater_than_or_equal_to s = Some 0\n let%test _ = binary_search ~compare [| s |] `First_strictly_greater_than s = None\n\n let%test _ = binary_search ~compare [||] `Last_less_than_or_equal_to s = None\n let%test _ = binary_search ~compare [| b |] `Last_less_than_or_equal_to s = None\n let%test _ = binary_search ~compare [| s |] `Last_less_than_or_equal_to s = Some 0\n let%test _ = binary_search ~compare [| s |] `Last_strictly_less_than s = None\n\n let create_test_case (num_s, num_b) =\n let arr = Array.create b ~len:(num_s + num_b) in\n for i = 0 to num_s -1 do\n arr.(i) <- s\n done;\n arr\n ;;\n\n let only_small = (10_000, 0)\n let only_big = (0, 10_000)\n\n let both = (2531, 4717)\n\n let%test _ =\n match binary_search (create_test_case only_small) ~compare `First_equal_to s with\n | None -> false\n | Some _ -> true\n\n let%test _ =\n let arr = create_test_case both in\n match binary_search arr ~compare `First_equal_to b with\n | None -> false\n | Some v -> v = 2531\n\n let%test _ =\n let arr = create_test_case only_small in\n binary_search arr ~compare `First_equal_to b = None\n\n let create_deterministic_test () =\n Array.init 100_000 ~f:(fun i -> if i > 50_000 then b else s)\n\n let%test _ =\n let arr = create_deterministic_test () in\n binary_search arr ~compare `First_equal_to s = Some 0\n\n let%test _ =\n let arr = create_deterministic_test () in\n binary_search arr ~compare `Last_equal_to s = Some 50_000\n\n let%test _ =\n let arr = create_deterministic_test () in\n binary_search arr ~compare `First_greater_than_or_equal_to s = Some 0\n\n let%test _ =\n let arr = create_deterministic_test () in\n binary_search arr ~compare `Last_less_than_or_equal_to s = Some 50_000\n\n let%test _ =\n let arr = create_deterministic_test () in\n binary_search arr ~compare `First_strictly_greater_than s = Some 50_001\n\n let%test _ =\n let arr = create_deterministic_test () in\n binary_search arr ~compare `Last_strictly_less_than b = Some 50_000\n\n (* tests around a gap*)\n let%test _ =\n let arr = create_deterministic_test () in\n binary_search arr ~compare `First_equal_to b = Some 50_001\n\n let%test _ =\n let arr = create_deterministic_test () in\n binary_search arr ~compare `Last_equal_to b = Some 99_999\n\n let%test _ =\n let arr = create_deterministic_test () in\n binary_search arr ~compare `First_greater_than_or_equal_to b = Some 50_001\n\n let%test _ =\n let arr = create_deterministic_test () in\n binary_search arr ~compare `Last_less_than_or_equal_to b = Some 99_999\n\n let%test _ =\n let arr = create_deterministic_test () in\n binary_search arr ~compare `First_strictly_greater_than b = None\n\n let%test _ =\n let arr = create_deterministic_test () in\n binary_search arr ~compare `Last_strictly_less_than b = Some 50_000\n\n (* test beginning of array *)\n\n let%test _ =\n let arr = create_test_case only_big in\n binary_search arr ~compare `First_equal_to s = None\n\n let%test _ =\n let arr = create_test_case only_big in\n binary_search arr ~compare `Last_equal_to s = None\n\n let%test _ =\n let arr = create_test_case only_big in\n binary_search arr ~compare `First_greater_than_or_equal_to s = Some 0\n\n let%test _ =\n let arr = create_test_case only_big in\n binary_search arr ~compare `Last_less_than_or_equal_to s = None\n\n let%test _ =\n let arr = create_test_case only_big in\n binary_search arr ~compare `First_strictly_greater_than s = Some 0\n\n let%test _ =\n let arr = create_test_case only_big in\n binary_search arr ~compare `Last_strictly_less_than b = None\n\n\n (* test end of array *)\n\n let%test _ =\n let arr = create_test_case only_small in\n binary_search arr ~compare `First_equal_to b = None\n\n let%test _ =\n let arr = create_test_case only_small in\n binary_search arr ~compare `Last_equal_to b = None\n\n let%test _ =\n let arr = create_test_case only_small in\n binary_search arr ~compare `First_greater_than_or_equal_to b = None\n\n let%test _ =\n let arr = create_test_case only_small in\n binary_search arr ~compare `Last_less_than_or_equal_to b = Some 9_999\n\n let%test _ =\n let arr = create_test_case only_small in\n binary_search arr ~compare `First_strictly_greater_than s = None\n\n let%test _ =\n let arr = create_test_case only_small in\n binary_search arr ~compare `Last_strictly_less_than b = Some 9_999\n\n let%test_unit _ =\n for length = 0 to 5 do\n for num_s = 0 to length do\n let arr = Array.init length ~f:(fun i -> if i < num_s then s else b) in\n for pos = -1 to length do\n for len = -1 to length + 1 do\n (*try*)\n let should_raise =\n Exn.does_raise (fun () ->\n Ordered_collection_common.check_pos_len_exn ~pos ~len\n ~total_length:length)\n in\n let result =\n Result.try_with (fun () ->\n binary_search arr ~pos ~len ~compare:elt_compare `Last_equal_to s)\n in\n match should_raise, result with\n | true , Error _ -> ()\n | true , Ok _ -> failwith \"expected it to raise but it didn't\"\n | false, Error _ -> failwith \"expected it to not raise, but it raised\"\n | false, Ok result ->\n let searched = num_s - 1 in\n let correct_result =\n if searched < pos then None\n else if len = 0 then None\n else if searched >= pos + len then Some(pos + len - 1)\n else Some searched\n in\n if not (correct_result = result) then failwith \"Wrong result\"\n (*with exn ->\n failwiths \"binary_search bug\"\n (exn, `length length, `search_key search_key, `pos pos, `len len)\n <:sexp_of< exn * [ `length of int ] * [ `search_key of int ]\n * [ `pos of int ] * [ `len of int ] >>*)\n done;\n done;\n done;\n done\n ;;\n\n let binary_search_segmented a = binary_search_segmented (For_test.of_array a)\n\n (*test for binary_search_segmented*)\n let%test _ =\n let arr = create_deterministic_test () in\n let segment_of x = if x = b then `Right else `Left in\n binary_search_segmented arr ~segment_of `Last_on_left = Some 50_000 &&\n binary_search_segmented arr ~segment_of `First_on_right = Some 50_001\n\n let%test _ =\n let arr = create_deterministic_test () in\n let segment_of _ = `Right in\n binary_search_segmented arr ~segment_of `Last_on_left = None &&\n binary_search_segmented arr ~segment_of `First_on_right = Some 0\n\n let%test _ =\n let arr = create_deterministic_test () in\n let segment_of _ = `Left in\n binary_search_segmented arr ~segment_of `Last_on_left = Some 99_999 &&\n binary_search_segmented arr ~segment_of `First_on_right = None\n\n end)\nend\n\nmodule Test (M : Binary_searchable_and_for_test) =\n Test_gen\n (struct\n type 'a t = M.t\n type 'a elt = M.elt\n let binary_search = M.binary_search\n let binary_search_segmented = M.binary_search_segmented\n module For_test = M.For_test\n end)\n\nmodule Test1 (M : Binary_searchable1_and_for_test) =\n Test_gen\n (struct\n type 'a t = 'a M.t\n type 'a elt = 'a\n let binary_search = M.binary_search\n let binary_search_segmented = M.binary_search_segmented\n module For_test = struct\n let of_array = M.For_test.of_array\n let compare = Bool.compare\n let small = false\n let big = true\n end\n end)\n\nmodule Make_and_test (M : Indexable_and_for_test) = struct\n module B = Binary_searchable.Make (M)\n include B\n include Test (struct\n type t = M.t\n type elt = M.elt\n include B\n module For_test = M.For_test\n end)\nend\n\nmodule Make1_and_test (M : Indexable1_and_for_test) = struct\n module B = Binary_searchable.Make1 (M)\n include B\n include Test1 (struct\n type 'a t = 'a M.t\n include B\n module For_test = M.For_test\n end)\nend\n","open! Import\n\nmodule type Conv = Conv.S\nmodule type Parser = Parser.S\nmodule type Eager_parser = Parser.S_eager\n\nmodule Conv_error = Conv_error\nmodule Of_sexp_error = Of_sexp_error\nmodule Old_parser_cont_state = Old_parser_cont_state\nmodule Parse_error = Parse_error\nmodule Positions = Positions\nmodule Cst = Cst\nmodule A = Parser_automaton\n\nexception Parse_error = Parse_error.Parse_error\nexception Of_sexp_error = Of_sexp_error.Of_sexp_error\n\nmodule Single =\n Parser.Make\n (Kind.Sexp)\n (struct\n type parsed_value = Sexp.t\n\n let mode = A.Single\n let make_value _ stack = Automaton_stack.get_single stack\n end)\n\nmodule Many =\n Parser.Make\n (Kind.Sexp)\n (struct\n type parsed_value = Sexp.t list\n\n let mode = A.Many\n let make_value _ stack = Automaton_stack.get_many stack\n end)\n\nmodule Eager =\n Parser.Make_eager\n (Kind.Sexp)\n (struct\n type parsed_value = Sexp.t\n\n let make_value _ stack = Automaton_stack.get_single stack\n end)\n\nmodule Single_and_positions =\n Parser.Make\n (Kind.Sexp_with_positions)\n (struct\n type parsed_value = Sexp.t * Positions.t\n\n let mode = A.Single\n let make_value state stack = Automaton_stack.get_single stack, A.positions state\n end)\n\nmodule Many_and_positions =\n Parser.Make\n (Kind.Sexp_with_positions)\n (struct\n type parsed_value = Sexp.t list * Positions.t\n\n let mode = A.Many\n let make_value state stack = Automaton_stack.get_many stack, A.positions state\n end)\n\nmodule Eager_and_positions =\n Parser.Make_eager\n (Kind.Sexp_with_positions)\n (struct\n type parsed_value = Sexp.t * Positions.t\n\n let make_value state stack = Automaton_stack.get_single stack, A.positions state\n end)\n\nmodule Single_just_positions =\n Parser.Make\n (Kind.Positions)\n (struct\n type parsed_value = Positions.t\n\n let mode = A.Single\n let make_value state () = A.positions state\n end)\n\nmodule Many_just_positions =\n Parser.Make\n (Kind.Positions)\n (struct\n type parsed_value = Positions.t\n\n let mode = A.Many\n let make_value state () = A.positions state\n end)\n\nmodule Eager_just_positions =\n Parser.Make_eager\n (Kind.Positions)\n (struct\n type parsed_value = Positions.t\n\n let make_value state () = A.positions state\n end)\n\nmodule Many_cst =\n Parser.Make\n (Kind.Cst)\n (struct\n type parsed_value = Cst.t_or_comment list\n\n let mode = A.Many\n let make_value _ stack = Automaton_stack.For_cst.get_many stack\n end)\n\nmodule Eager_cst =\n Parser.Make_eager\n (Kind.Cst)\n (struct\n type parsed_value = Cst.t_or_comment\n\n let make_value _ stack =\n match Automaton_stack.For_cst.get_many stack with\n | [ sexp ] -> sexp\n | _ -> assert false\n ;;\n end)\n\ntype 'a id = 'a\ntype sexp_list = Sexp.t list\n\nmodule Conv_single =\n Conv.Make\n (struct\n type 'a res = 'a\n type parsed_sexp = Sexp.t\n type chunk_to_conv = Sexp.t\n\n let apply_f x ~f = f x\n let find = Positions.find_sub_sexp_phys\n end)\n (Single)\n (Single_just_positions)\n\nmodule Conv_many =\n Conv.Make\n (struct\n type 'a res = 'a list\n type parsed_sexp = Sexp.t list\n type chunk_to_conv = Sexp.t\n\n let apply_f x ~f = List.rev (List.rev_map x ~f)\n let find = Positions.find_sub_sexp_in_list_phys\n end)\n (Many)\n (Many_just_positions)\n\nmodule Conv_many_at_once =\n Conv.Make\n (struct\n type 'a res = 'a\n type parsed_sexp = Sexp.t list\n type chunk_to_conv = Sexp.t list\n\n let apply_f x ~f = f x\n let find = Positions.find_sub_sexp_in_list_phys\n end)\n (Many)\n (Many_just_positions)\n\nmodule Private = struct\n module Automaton_stack = Automaton_stack\n module Parser_automaton = Parser_automaton\nend\n","open! Import\ninclude Automaton_stack_intf\n\nmodule For_cst = struct\n type t =\n | Empty\n | T_or_comment of Cst.t_or_comment * t\n | Open of Positions.pos * t\n | In_sexp_comment of\n { hash_semi_pos : Positions.pos\n ; rev_comments : Cst.comment list\n ; stack : t\n }\n\n let empty = Empty\n\n let get_many =\n let rec loop acc = function\n | Empty -> acc\n | T_or_comment (t, stack) -> loop (t :: acc) stack\n | Open _ | In_sexp_comment _ -> failwith \"Automaton_stack.For_cst.get_many\"\n in\n fun stack -> loop [] stack\n ;;\nend\n\nmodule Just_positions = struct\n type t = unit\n\n let empty = ()\nend\n\ntype t =\n | Empty\n | Open of t\n | Sexp of Sexp.t * t\n\nlet empty = Empty\n\nlet get_single = function\n | Sexp (sexp, Empty) -> sexp\n | _ -> failwith \"Automaton_stack.get_single\"\n;;\n\nlet get_many =\n let rec loop acc = function\n | Empty -> acc\n | Open _ -> failwith \"Automaton_stack.get_many\"\n | Sexp (sexp, stack) -> loop (sexp :: acc) stack\n in\n fun stack -> loop [] stack\n;;\n","open! Import\n\ntype t =\n { user_exn : exn\n ; sub_sexp : Sexp.t\n ; location : Positions.range option\n }\n[@@deriving_inline sexp_of]\n\nlet sexp_of_t =\n (function\n | { user_exn = v_user_exn; sub_sexp = v_sub_sexp; location = v_location } ->\n let bnds = [] in\n let bnds =\n let arg = sexp_of_option Positions.sexp_of_range v_location in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"location\"; arg ]\n :: bnds\n in\n let bnds =\n let arg = Sexp.sexp_of_t v_sub_sexp in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"sub_sexp\"; arg ]\n :: bnds\n in\n let bnds =\n let arg = sexp_of_exn v_user_exn in\n Ppx_sexp_conv_lib.Sexp.List [ Ppx_sexp_conv_lib.Sexp.Atom \"user_exn\"; arg ]\n :: bnds\n in\n Ppx_sexp_conv_lib.Sexp.List bnds\n : t -> Ppx_sexp_conv_lib.Sexp.t)\n;;\n\n[@@@end]\n\nlet user_exn t = t.user_exn\nlet sub_sexp t = t.sub_sexp\nlet location t = t.location\n\nlet report ppf ~filename t =\n let line, start, stop =\n match t.location with\n | None -> 1, 0, 0\n | Some { start_pos; end_pos } ->\n start_pos.line, start_pos.col, start_pos.col + end_pos.offset - start_pos.offset\n in\n Format.fprintf\n ppf\n \"File \\\"%s\\\", line %d, characters %d-%d:\\n\\\n Error: s-expression conversion error;\\n\\\n exception %s\\n\"\n filename\n line\n start\n stop\n (Printexc.to_string t.user_exn)\n;;\n\nexception Of_sexp_error of t [@@deriving_inline sexp_of]\n\nlet () =\n Ppx_sexp_conv_lib.Conv.Exn_converter.add\n [%extension_constructor Of_sexp_error]\n (function\n | Of_sexp_error v0 ->\n let v0 = sexp_of_t v0 in\n Ppx_sexp_conv_lib.Sexp.List\n [ Ppx_sexp_conv_lib.Sexp.Atom \"of_sexp_error.ml.Of_sexp_error\"; v0 ]\n | _ -> assert false)\n;;\n\n[@@@end]\n\nlet raise ~user_exn ~sub_sexp ~location =\n raise (Of_sexp_error { user_exn; sub_sexp; location })\n;;\n","open! Import\ninclude Parse_error_intf\n\ntype t =\n { position : Positions.pos\n ; message : string\n ; old_parser_exn : [ `Parse_error | `Failure ]\n }\n\nlet sexp_of_t { position; message; old_parser_exn = _ } : Sexp.t =\n List\n [ List [ Atom \"position\"; Positions.sexp_of_pos position ]\n ; List [ Atom \"message\"; sexp_of_string message ]\n ]\n;;\n\nlet position t = t.position\nlet message t = t.message\nlet old_parser_exn t = t.old_parser_exn\n\nlet report ppf ~filename t =\n let pos = position t in\n let msg = message t in\n Format.fprintf\n ppf\n \"File \\\"%s\\\", line %d, character %d:\\nError: s-expression parsing error;\\n%s\\n\"\n filename\n pos.line\n pos.col\n msg\n;;\n\nexception Parse_error of t [@@deriving_inline sexp]\n\nlet () =\n Ppx_sexp_conv_lib.Conv.Exn_converter.add [%extension_constructor Parse_error] (function\n | Parse_error v0 ->\n let v0 = sexp_of_t v0 in\n Ppx_sexp_conv_lib.Sexp.List\n [ Ppx_sexp_conv_lib.Sexp.Atom \"parse_error.ml.Parse_error\"; v0 ]\n | _ -> assert false)\n;;\n\n[@@@end]\n\nlet raise (reason : Reason.t) position ~at_eof ~atom_buffer =\n let message =\n (* These messages where choosen such that we can build the various Sexplib parsing\n functions on top of Parsexp and keep the same exceptions.\n\n At the time of writing this, a simple layer on top of parsexp to implement the\n sexplib API is passing all the sexplib tests.\n\n Note that parsexp matches the semantic of Sexp.parse which is slightly\n different from the ocamllex/ocamlyacc based parser of Sexplib. The latter one\n is less tested and assumed to be less used. *)\n match reason with\n | Unexpected_char_parsing_hex_escape -> \"unterminated hexadecimal escape sequence\"\n | Unexpected_char_parsing_dec_escape -> \"unterminated decimal escape sequence\"\n | Unterminated_quoted_string -> \"unterminated quoted string\"\n | Unterminated_block_comment -> \"unterminated block comment\"\n | Escape_sequence_out_of_range -> \"escape sequence in quoted string out of range\"\n | Unclosed_paren -> \"unclosed parentheses at end of input\"\n | Too_many_sexps -> \"s-expression followed by data\"\n | Closed_paren_without_opened -> \"unexpected character: ')'\"\n | Comment_token_in_unquoted_atom ->\n if String.equal (Buffer.contents atom_buffer) \"|\"\n then \"illegal end of comment\"\n else \"comment tokens in unquoted atom\"\n | Sexp_comment_without_sexp -> \"unterminated sexp comment\"\n | Unexpected_character_after_cr ->\n if at_eof\n then \"unexpected end of input after carriage return\"\n else \"unexpected character after carriage return\"\n | No_sexp_found_in_input -> \"no s-expression found in input\"\n | Automaton_in_error_state -> failwith \"Parsexp.Parser_automaton: parser is dead\"\n in\n let old_parser_exn =\n match reason, at_eof with\n | Too_many_sexps, _ | _, true -> `Failure\n | Comment_token_in_unquoted_atom, _\n when String.equal (Buffer.contents atom_buffer) \"|\" -> `Failure\n | _ -> `Parse_error\n in\n raise (Parse_error { position; message; old_parser_exn })\n;;\n\nmodule Private = struct\n module Reason = Reason\n\n let old_parser_exn = old_parser_exn\n let raise = raise\nend\n","open! Import\n\nmodule Public = struct\n type state_cst =\n { token_buffer : Buffer.t\n ; (* Starting positions of the current token *)\n mutable token_start_pos : Positions.pos\n }\n\n type ('u, 's) kind =\n | Positions : (Positions.Builder.t, unit) kind\n | Sexp : (unit, Automaton_stack.t) kind\n | Sexp_with_positions : (Positions.Builder.t, Automaton_stack.t) kind\n | Cst : (state_cst, Automaton_stack.For_cst.t) kind\n\n type ('u, 's) state =\n { mutable automaton_state : int\n ; kind : ('u, 's) kind\n ; mutable depth : int\n ; (* Number of opened #| when parsing a block comment *)\n mutable block_comment_depth : int\n ; (* Stack of ignoring depths; the current depth is pushed\n each time a #; comment is entered. *)\n mutable ignoring_stack : int list\n ; (* When parsing an escape sequence of the form \"\\\\NNN\" or \"\\\\XX\", this accumulates\n the computed number *)\n mutable escaped_value : int\n ; (* Buffer for accumulating atoms *)\n atom_buffer : Buffer.t\n ; user_state : 'u\n ; mode : ('u, 's) mode\n ; mutable full_sexps : int\n ; mutable offset : int (* global offset *)\n ; mutable line_number : int\n ; mutable bol_offset : int (* offset of beginning of line *)\n }\n\n and ('u, 's) mode =\n | Single\n | Many\n | Eager of\n { got_sexp : ('u, 's) state -> 's -> 's\n ; mutable no_sexp_is_error : bool\n }\n\n let initial_user_state : type u s. (u, s) kind -> Positions.pos -> u =\n fun kind initial_pos ->\n match kind with\n | Positions -> Positions.Builder.create ~initial_pos ()\n | Sexp -> ()\n | Sexp_with_positions -> Positions.Builder.create ~initial_pos ()\n | Cst ->\n (* [token_start_pos] is set to a dummy location here. It is properly set when we\n start to capture a token from the input *)\n { token_buffer = Buffer.create 128; token_start_pos = Positions.beginning_of_file }\n ;;\n\n (* these magic numbers are checked in gen_parser_automaton.ml:\n let () = assert (initial = 0)\n let () = assert (to_int Error = 1) *)\n let initial_state = 0\n let error_state = 1\n\n let new_state ?(initial_pos = Positions.beginning_of_file) mode kind =\n { kind\n ; depth = 0\n ; automaton_state = initial_state\n ; block_comment_depth = 0\n ; ignoring_stack = []\n ; escaped_value = 0\n ; atom_buffer = Buffer.create 128\n ; user_state = initial_user_state kind initial_pos\n ; mode\n ; full_sexps = 0\n ; offset = initial_pos.offset\n ; line_number = initial_pos.line\n ; bol_offset = initial_pos.offset - initial_pos.col\n }\n ;;\n\n let mode t = t.mode\n let positions t = Positions.Builder.contents t.user_state\n let atom_buffer t = t.atom_buffer\n let offset state = state.offset\n let line state = state.line_number\n let column state = state.offset - state.bol_offset\n let position t = { Positions.col = column t; line = line t; offset = offset t }\n\n let reset_user_state : type u s. (u, s) state -> unit =\n fun t ->\n match t.kind with\n | Positions -> Positions.Builder.reset t.user_state (position t)\n | Sexp -> ()\n | Sexp_with_positions -> Positions.Builder.reset t.user_state (position t)\n | Cst -> Buffer.clear t.user_state.token_buffer\n ;;\n\n let reset ?(pos = Positions.beginning_of_file) t =\n t.depth <- 0;\n t.automaton_state <- initial_state;\n t.block_comment_depth <- 0;\n t.ignoring_stack <- [];\n t.escaped_value <- 0;\n t.full_sexps <- 0;\n t.offset <- pos.offset;\n t.line_number <- pos.line;\n t.bol_offset <- pos.offset - pos.col;\n reset_user_state t;\n Buffer.clear t.atom_buffer\n ;;\n\n type context =\n | Sexp_comment\n | Sexp\n\n let is_ignoring state =\n match state.ignoring_stack with\n | _ :: _ -> true\n | [] -> false\n ;;\n\n let is_not_ignoring state = not (is_ignoring state)\n let context state = if is_not_ignoring state then Sexp else Sexp_comment\n let has_unclosed_paren state = state.depth > 0\n let set_error_state state = state.automaton_state <- error_state\n\n module Error = Parse_error\n\n let automaton_state state = state.automaton_state\nend\n\nopen Public\n\nlet raise_error : type a b. (a, b) state -> _ =\n fun state ~at_eof reason ->\n set_error_state state;\n Parse_error.Private.raise\n reason\n { line = state.line_number\n ; col = state.offset - state.bol_offset\n ; offset = state.offset\n }\n ~at_eof\n ~atom_buffer:state.atom_buffer\n;;\n\ntype nonrec context = context =\n | Sexp_comment\n | Sexp\n\nlet context = context\n\ntype ('u, 's) action = ('u, 's) state -> char -> 's -> 's\ntype ('u, 's) epsilon_action = ('u, 's) state -> 's -> 's\n\nlet current_pos ?(delta = 0) state : Positions.pos =\n let offset = state.offset + delta in\n { line = state.line_number; col = offset - state.bol_offset; offset }\n;;\n\nlet set_automaton_state state x = state.automaton_state <- x\nlet advance state = state.offset <- state.offset + 1\n\nlet advance_eol : type u s. (u, s) state -> unit =\n fun state ->\n let newline_offset = state.offset in\n state.offset <- newline_offset + 1;\n state.bol_offset <- state.offset;\n state.line_number <- state.line_number + 1;\n match state.kind with\n | Positions -> Positions.Builder.add_newline state.user_state ~offset:newline_offset\n | Sexp_with_positions ->\n Positions.Builder.add_newline state.user_state ~offset:newline_offset\n | _ -> ()\n;;\n\nlet block_comment_depth state = state.block_comment_depth\n\nlet add_token_char : type u s. (u, s) action =\n fun state char stack ->\n match state.kind with\n | Cst ->\n Buffer.add_char state.user_state.token_buffer char;\n stack\n | _ -> stack\n;;\n\nlet add_atom_char state c stack =\n Buffer.add_char state.atom_buffer c;\n stack\n;;\n\nlet add_quoted_atom_char state c stack =\n Buffer.add_char state.atom_buffer c;\n add_token_char state c stack\n;;\n\nlet check_new_sexp_allowed state =\n let is_single =\n match state.mode with\n | Single -> true\n | _ -> false\n in\n if is_single && state.full_sexps > 0 && is_not_ignoring state\n then raise_error state ~at_eof:false Too_many_sexps\n;;\n\nlet add_pos state ~delta =\n Positions.Builder.add state.user_state ~offset:(state.offset + delta)\n;;\n\nlet add_first_char : type u s. (u, s) action =\n fun state char stack ->\n check_new_sexp_allowed state;\n Buffer.add_char state.atom_buffer char;\n (* For non-quoted atoms, we save both positions at the end. We can always determine the\n start position from the end position and the atom length for non-quoted atoms.\n\n Doing it this way allows us to detect single characater atoms for which we need to\n save the position twice. *)\n stack\n;;\n\nlet eps_add_first_char_hash : type u s. (u, s) epsilon_action =\n fun state stack ->\n check_new_sexp_allowed state;\n Buffer.add_char state.atom_buffer '#';\n stack\n;;\n\nlet start_quoted_string : type u s. (u, s) action =\n fun state _char stack ->\n check_new_sexp_allowed state;\n match state.kind with\n | Positions ->\n if is_not_ignoring state then add_pos state ~delta:0;\n stack\n | Sexp_with_positions ->\n if is_not_ignoring state then add_pos state ~delta:0;\n stack\n | Cst ->\n state.user_state.token_start_pos <- current_pos state;\n Buffer.add_char state.user_state.token_buffer '\"';\n stack\n | Sexp -> stack\n;;\n\nlet add_escaped state c stack =\n let c' =\n match c with\n | 'n' -> '\\n'\n | 'r' -> '\\r'\n | 'b' -> '\\b'\n | 't' -> '\\t'\n | '\\\\' | '\\'' | '\"' -> c\n | _ ->\n Buffer.add_char state.atom_buffer '\\\\';\n c\n in\n Buffer.add_char state.atom_buffer c';\n add_token_char state c stack\n;;\n\nlet eps_add_escaped_cr state stack =\n Buffer.add_char state.atom_buffer '\\r';\n stack\n;;\n\nlet dec_val c = Char.code c - Char.code '0'\n\nlet hex_val c =\n match c with\n | '0' .. '9' -> Char.code c - Char.code '0'\n | 'a' .. 'f' -> Char.code c - Char.code 'a' + 10\n | _ -> Char.code c - Char.code 'A' + 10\n;;\n\nlet add_dec_escape_char state c stack =\n state.escaped_value <- (state.escaped_value * 10) + dec_val c;\n add_token_char state c stack\n;;\n\nlet add_last_dec_escape_char state c stack =\n let value = (state.escaped_value * 10) + dec_val c in\n state.escaped_value <- 0;\n if value > 255 then raise_error state ~at_eof:false Escape_sequence_out_of_range;\n Buffer.add_char state.atom_buffer (Char.chr value);\n add_token_char state c stack\n;;\n\nlet comment_add_last_dec_escape_char state c stack =\n let value = (state.escaped_value * 10) + dec_val c in\n state.escaped_value <- 0;\n if value > 255 then raise_error state ~at_eof:false Escape_sequence_out_of_range;\n add_token_char state c stack\n;;\n\nlet add_hex_escape_char state c stack =\n state.escaped_value <- (state.escaped_value lsl 4) lor hex_val c;\n add_token_char state c stack\n;;\n\nlet add_last_hex_escape_char state c stack =\n let value = (state.escaped_value lsl 4) lor hex_val c in\n state.escaped_value <- 0;\n Buffer.add_char state.atom_buffer (Char.chr value);\n add_token_char state c stack\n;;\n\nlet opening : type u s. (u, s) state -> char -> s -> s =\n fun state _char stack ->\n check_new_sexp_allowed state;\n state.depth <- state.depth + 1;\n match state.kind with\n | Positions ->\n if is_not_ignoring state then add_pos state ~delta:0;\n stack\n | Sexp -> if is_not_ignoring state then Open stack else stack\n | Sexp_with_positions ->\n if is_not_ignoring state\n then (\n add_pos state ~delta:0;\n Open stack)\n else stack\n | Cst -> Open (current_pos state, stack)\n;;\n\nlet do_reset_positions state =\n Positions.Builder.reset\n state.user_state\n { line = state.line_number\n ; col = state.offset - state.bol_offset\n ; offset = state.offset\n }\n;;\n\nlet reset_positions : type u s. (u, s) state -> unit =\n fun state ->\n match state.kind with\n | Positions -> do_reset_positions state\n | Sexp_with_positions -> do_reset_positions state\n | Sexp -> ()\n | Cst -> ()\n;;\n\nlet toplevel_sexp_or_comment_added state stack ~delta =\n match state.mode with\n | Single | Many -> stack\n | Eager { got_sexp = f; _ } ->\n (* Modify the offset so that [f] get a state pointing to the end of the current\n s-expression *)\n let saved_offset = state.offset in\n state.offset <- state.offset + delta;\n let saved_full_sexps = state.full_sexps in\n (match f state stack with\n | exception e ->\n set_error_state state;\n raise e\n | stack ->\n (* This assert is not a full protection against the user mutating the state but\n it should catch most cases. *)\n assert (state.offset = saved_offset + delta && state.full_sexps = saved_full_sexps);\n state.offset <- saved_offset;\n reset_positions state;\n stack)\n;;\n\nlet is_top_level state = is_not_ignoring state && state.depth = 0\n\nlet comment_added_assuming_cst state stack ~delta =\n if is_top_level state then toplevel_sexp_or_comment_added state stack ~delta else stack\n;;\n\nlet maybe_pop_ignoring_stack state =\n match state.ignoring_stack with\n | inner_comment_depth :: _tl when inner_comment_depth > state.depth ->\n raise_error state ~at_eof:false Sexp_comment_without_sexp\n | inner_comment_depth :: tl when inner_comment_depth = state.depth ->\n state.ignoring_stack <- tl;\n true\n | _ -> false\n;;\n\nlet sexp_added : type u s. (u, s) state -> s -> delta:int -> s =\n fun state stack ~delta ->\n let is_comment = maybe_pop_ignoring_stack state in\n if is_top_level state\n then (\n if not is_comment then state.full_sexps <- state.full_sexps + 1;\n if (not is_comment)\n ||\n match state.kind with\n | Cst -> true\n | _ -> false\n then toplevel_sexp_or_comment_added state stack ~delta\n else stack)\n else stack\n;;\n\nlet rec make_list acc : Automaton_stack.t -> Automaton_stack.t = function\n | Empty -> assert false\n | Open stack -> Sexp (List acc, stack)\n | Sexp (sexp, stack) -> make_list (sexp :: acc) stack\n;;\n\nlet add_comment_to_stack_cst comment (stack : Automaton_stack.For_cst.t)\n : Automaton_stack.For_cst.t\n =\n match stack with\n | In_sexp_comment r ->\n In_sexp_comment { r with rev_comments = comment :: r.rev_comments }\n | _ -> T_or_comment (Comment comment, stack)\n;;\n\nlet add_sexp_to_stack_cst sexp : Automaton_stack.For_cst.t -> Automaton_stack.For_cst.t\n = function\n | In_sexp_comment { hash_semi_pos; rev_comments; stack } ->\n let comment : Cst.comment =\n Sexp_comment { hash_semi_pos; comments = List.rev rev_comments; sexp }\n in\n add_comment_to_stack_cst comment stack\n | stack -> T_or_comment (Sexp sexp, stack)\n;;\n\nlet rec make_list_cst end_pos acc\n : Automaton_stack.For_cst.t -> Automaton_stack.For_cst.t\n = function\n | T_or_comment (t, stack) -> make_list_cst end_pos (t :: acc) stack\n | Open (start_pos, stack) ->\n let sexp : Cst.t = List { loc = { start_pos; end_pos }; elements = acc } in\n add_sexp_to_stack_cst sexp stack\n | Empty | In_sexp_comment _ -> assert false\n;;\n\nlet closing : type u s. (u, s) state -> char -> s -> s =\n fun state _char stack ->\n if state.depth > 0\n then (\n let stack : s =\n match state.kind with\n | Positions ->\n (* Note we store end positions as inclusive in [Positions.t], so we use [delta:0],\n while in the [Cst] case we save directly the final ranges, so we use\n [delta:1]. *)\n if is_not_ignoring state then add_pos state ~delta:0;\n stack\n | Sexp -> if is_not_ignoring state then make_list [] stack else stack\n | Sexp_with_positions ->\n if is_not_ignoring state\n then (\n add_pos state ~delta:0;\n make_list [] stack)\n else stack\n | Cst -> make_list_cst (current_pos state ~delta:1) [] stack\n in\n state.depth <- state.depth - 1;\n sexp_added state stack ~delta:1)\n else raise_error state ~at_eof:false Closed_paren_without_opened\n;;\n\nlet make_loc ?(delta = 0) state : Positions.range =\n { start_pos = state.user_state.token_start_pos; end_pos = current_pos state ~delta }\n;;\n\n(* This is always called on the position exactly following the last character of a\n non-quoted atom *)\nlet add_non_quoted_atom_pos state ~atom =\n let len = String.length atom in\n if len = 1\n then Positions.Builder.add_twice state.user_state ~offset:(state.offset - 1)\n else (\n add_pos state ~delta:(-len);\n add_pos state ~delta:(-1))\n;;\n\nlet eps_push_atom : type u s. (u, s) epsilon_action =\n fun state stack ->\n let str = Buffer.contents state.atom_buffer in\n Buffer.clear state.atom_buffer;\n let stack : s =\n match state.kind with\n | Positions ->\n if is_not_ignoring state then add_non_quoted_atom_pos state ~atom:str;\n stack\n | Sexp -> if is_not_ignoring state then Sexp (Atom str, stack) else stack\n | Sexp_with_positions ->\n if is_not_ignoring state\n then (\n add_non_quoted_atom_pos state ~atom:str;\n Sexp (Atom str, stack))\n else stack\n | Cst ->\n let loc : Positions.range =\n { start_pos = current_pos state ~delta:(-String.length str)\n ; end_pos = current_pos state ~delta:0\n }\n in\n let sexp : Cst.t = Atom { loc; atom = str; unescaped = Some str } in\n add_sexp_to_stack_cst sexp stack\n in\n sexp_added state stack ~delta:0\n;;\n\nlet push_quoted_atom : type u s. (u, s) action =\n fun state _char stack ->\n let str = Buffer.contents state.atom_buffer in\n Buffer.clear state.atom_buffer;\n let stack : s =\n match state.kind with\n | Positions ->\n if is_not_ignoring state then add_pos state ~delta:0;\n stack\n | Sexp -> if is_not_ignoring state then Sexp (Atom str, stack) else stack\n | Sexp_with_positions ->\n if is_not_ignoring state\n then (\n add_pos state ~delta:0;\n Sexp (Atom str, stack))\n else stack\n | Cst ->\n let buf = state.user_state.token_buffer in\n Buffer.add_char buf '\"';\n let s = Buffer.contents buf in\n Buffer.clear buf;\n let sexp : Cst.t =\n Atom { loc = make_loc state ~delta:1; atom = str; unescaped = Some s }\n in\n add_sexp_to_stack_cst sexp stack\n in\n sexp_added state stack ~delta:1\n;;\n\nlet start_sexp_comment : type u s. (u, s) action =\n fun state _char stack ->\n state.ignoring_stack <- state.depth :: state.ignoring_stack;\n match state.kind with\n | Cst ->\n In_sexp_comment\n { hash_semi_pos = current_pos state ~delta:(-1); rev_comments = []; stack }\n | _ -> stack\n;;\n\nlet start_block_comment : type u s. (u, s) state -> char -> s -> s =\n fun state char stack ->\n state.block_comment_depth <- state.block_comment_depth + 1;\n match state.kind with\n | Positions -> stack\n | Sexp -> stack\n | Sexp_with_positions -> stack\n | Cst ->\n if state.block_comment_depth = 1\n then (\n state.user_state.token_start_pos <- current_pos state ~delta:(-1);\n Buffer.add_char state.user_state.token_buffer '#');\n Buffer.add_char state.user_state.token_buffer char;\n stack\n;;\n\nlet end_block_comment : type u s. (u, s) state -> char -> s -> s =\n fun state char stack ->\n state.block_comment_depth <- state.block_comment_depth - 1;\n match state.kind with\n | Positions -> stack\n | Sexp -> stack\n | Sexp_with_positions -> stack\n | Cst ->\n let buf = state.user_state.token_buffer in\n Buffer.add_char buf char;\n if state.block_comment_depth = 0\n then (\n let s = Buffer.contents buf in\n Buffer.clear buf;\n let comment : Cst.comment =\n Plain_comment { loc = make_loc state ~delta:1; comment = s }\n in\n let stack = add_comment_to_stack_cst comment stack in\n comment_added_assuming_cst state stack ~delta:1)\n else stack\n;;\n\nlet start_line_comment : type u s. (u, s) action =\n fun state char stack ->\n match state.kind with\n | Cst ->\n state.user_state.token_start_pos <- current_pos state;\n Buffer.add_char state.user_state.token_buffer char;\n stack\n | _ -> stack\n;;\n\nlet end_line_comment : type u s. (u, s) epsilon_action =\n fun state stack ->\n match state.kind with\n | Positions -> stack\n | Sexp -> stack\n | Sexp_with_positions -> stack\n | Cst ->\n let buf = state.user_state.token_buffer in\n let s = Buffer.contents buf in\n Buffer.clear buf;\n let comment : Cst.comment = Plain_comment { loc = make_loc state; comment = s } in\n let stack = add_comment_to_stack_cst comment stack in\n comment_added_assuming_cst state stack ~delta:0\n;;\n\nlet eps_eoi_check : type u s. (u, s) epsilon_action =\n fun state stack ->\n if state.depth > 0 then raise_error state ~at_eof:true Unclosed_paren;\n if is_ignoring state then raise_error state ~at_eof:true Sexp_comment_without_sexp;\n if state.full_sexps = 0\n then (\n match state.mode with\n | Many | Eager { no_sexp_is_error = false; _ } -> ()\n | Single | Eager { no_sexp_is_error = true; _ } ->\n raise_error state ~at_eof:true No_sexp_found_in_input);\n stack\n;;\n","open Parser_automaton_internal\ninclude Public\n\nlet raise = Parser_automaton_internal.raise_error\n\ntype u'\ntype s'\n\n(*$ open Parsexp_cinaps_helpers.Gen_parser_automaton ;; *)\n(*$ print_code () ;; *)\n\nlet tr_00 state char stack =\n let stack = add_first_char state char stack in\n set_automaton_state state 3;\n advance state;\n stack\n;;\n\nlet tr_01 state _char stack =\n set_automaton_state state 0;\n advance state;\n stack\n;;\n\nlet tr_02 state _char stack =\n set_automaton_state state 0;\n advance_eol state;\n stack\n;;\n\nlet tr_03 state _char stack =\n set_automaton_state state 2;\n advance state;\n stack\n;;\n\nlet tr_04 state char stack =\n let stack = start_quoted_string state char stack in\n set_automaton_state state 8;\n advance state;\n stack\n;;\n\nlet tr_05 state _char stack =\n set_automaton_state state 7;\n advance state;\n stack\n;;\n\nlet tr_06 state char stack =\n let stack = opening state char stack in\n set_automaton_state state 0;\n advance state;\n stack\n;;\n\nlet tr_07 state char stack =\n let stack = closing state char stack in\n set_automaton_state state 0;\n advance state;\n stack\n;;\n\nlet tr_08 state char stack =\n let stack = start_line_comment state char stack in\n set_automaton_state state 6;\n advance state;\n stack\n;;\n\nlet tr_09 state char stack =\n let stack = add_first_char state char stack in\n set_automaton_state state 5;\n advance state;\n stack\n;;\n\nlet tr_10 _state _char _stack = raise _state ~at_eof:false Automaton_in_error_state\nlet tr_11 _state _char _stack = raise _state ~at_eof:false Unexpected_character_after_cr\n\nlet tr_12 state char stack =\n let stack = add_atom_char state char stack in\n set_automaton_state state 3;\n advance state;\n stack\n;;\n\nlet tr_13 state _char stack =\n let stack = eps_push_atom state stack in\n set_automaton_state state 0;\n advance state;\n stack\n;;\n\nlet tr_14 state _char stack =\n let stack = eps_push_atom state stack in\n set_automaton_state state 0;\n advance_eol state;\n stack\n;;\n\nlet tr_15 state _char stack =\n let stack = eps_push_atom state stack in\n set_automaton_state state 2;\n advance state;\n stack\n;;\n\nlet tr_16 state char stack =\n let stack = eps_push_atom state stack in\n let stack = start_quoted_string state char stack in\n set_automaton_state state 8;\n advance state;\n stack\n;;\n\nlet tr_17 state char stack =\n let stack = add_atom_char state char stack in\n set_automaton_state state 4;\n advance state;\n stack\n;;\n\nlet tr_18 state char stack =\n let stack = eps_push_atom state stack in\n let stack = opening state char stack in\n set_automaton_state state 0;\n advance state;\n stack\n;;\n\nlet tr_19 state char stack =\n let stack = eps_push_atom state stack in\n let stack = closing state char stack in\n set_automaton_state state 0;\n advance state;\n stack\n;;\n\nlet tr_20 state char stack =\n let stack = eps_push_atom state stack in\n let stack = start_line_comment state char stack in\n set_automaton_state state 6;\n advance state;\n stack\n;;\n\nlet tr_21 state char stack =\n let stack = add_atom_char state char stack in\n set_automaton_state state 5;\n advance state;\n stack\n;;\n\nlet tr_22 _state _char _stack = raise _state ~at_eof:false Comment_token_in_unquoted_atom\n\nlet tr_23 state char stack =\n let stack = add_token_char state char stack in\n set_automaton_state state 6;\n advance state;\n stack\n;;\n\nlet tr_24 state _char stack =\n let stack = end_line_comment state stack in\n set_automaton_state state 0;\n advance_eol state;\n stack\n;;\n\nlet tr_25 state _char stack =\n let stack = end_line_comment state stack in\n set_automaton_state state 2;\n advance state;\n stack\n;;\n\nlet tr_26 state char stack =\n let stack = eps_add_first_char_hash state stack in\n let stack = add_atom_char state char stack in\n set_automaton_state state 3;\n advance state;\n stack\n;;\n\nlet tr_27 state _char stack =\n let stack = eps_add_first_char_hash state stack in\n let stack = eps_push_atom state stack in\n set_automaton_state state 0;\n advance state;\n stack\n;;\n\nlet tr_28 state _char stack =\n let stack = eps_add_first_char_hash state stack in\n let stack = eps_push_atom state stack in\n set_automaton_state state 0;\n advance_eol state;\n stack\n;;\n\nlet tr_29 state _char stack =\n let stack = eps_add_first_char_hash state stack in\n let stack = eps_push_atom state stack in\n set_automaton_state state 2;\n advance state;\n stack\n;;\n\nlet tr_30 state char stack =\n let stack = eps_add_first_char_hash state stack in\n let stack = eps_push_atom state stack in\n let stack = start_quoted_string state char stack in\n set_automaton_state state 8;\n advance state;\n stack\n;;\n\nlet tr_31 state char stack =\n let stack = eps_add_first_char_hash state stack in\n let stack = add_atom_char state char stack in\n set_automaton_state state 4;\n advance state;\n stack\n;;\n\nlet tr_32 state char stack =\n let stack = eps_add_first_char_hash state stack in\n let stack = eps_push_atom state stack in\n let stack = opening state char stack in\n set_automaton_state state 0;\n advance state;\n stack\n;;\n\nlet tr_33 state char stack =\n let stack = eps_add_first_char_hash state stack in\n let stack = eps_push_atom state stack in\n let stack = closing state char stack in\n set_automaton_state state 0;\n advance state;\n stack\n;;\n\nlet tr_34 state char stack =\n let stack = start_sexp_comment state char stack in\n set_automaton_state state 0;\n advance state;\n stack\n;;\n\nlet tr_35 state char stack =\n let stack = start_block_comment state char stack in\n set_automaton_state state 16;\n advance state;\n stack\n;;\n\nlet tr_36 state char stack =\n let stack = add_quoted_atom_char state char stack in\n set_automaton_state state 8;\n advance state;\n stack\n;;\n\nlet tr_37 state char stack =\n let stack = add_quoted_atom_char state char stack in\n set_automaton_state state 8;\n advance_eol state;\n stack\n;;\n\nlet tr_38 state char stack =\n let stack = push_quoted_atom state char stack in\n set_automaton_state state 0;\n advance state;\n stack\n;;\n\nlet tr_39 state char stack =\n let stack = add_token_char state char stack in\n set_automaton_state state 9;\n advance state;\n stack\n;;\n\nlet tr_40 state char stack =\n let stack = add_escaped state char stack in\n set_automaton_state state 8;\n advance state;\n stack\n;;\n\nlet tr_41 state char stack =\n let stack = add_token_char state char stack in\n set_automaton_state state 15;\n advance_eol state;\n stack\n;;\n\nlet tr_42 state char stack =\n let stack = add_token_char state char stack in\n set_automaton_state state 10;\n advance state;\n stack\n;;\n\nlet tr_43 state char stack =\n let stack = add_dec_escape_char state char stack in\n set_automaton_state state 11;\n advance state;\n stack\n;;\n\nlet tr_44 state char stack =\n let stack = add_token_char state char stack in\n set_automaton_state state 13;\n advance state;\n stack\n;;\n\nlet tr_45 state char stack =\n let stack = eps_add_escaped_cr state stack in\n let stack = add_quoted_atom_char state char stack in\n set_automaton_state state 8;\n advance state;\n stack\n;;\n\nlet tr_46 state char stack =\n let stack = eps_add_escaped_cr state stack in\n let stack = push_quoted_atom state char stack in\n set_automaton_state state 0;\n advance state;\n stack\n;;\n\nlet tr_47 state char stack =\n let stack = eps_add_escaped_cr state stack in\n let stack = add_token_char state char stack in\n set_automaton_state state 9;\n advance state;\n stack\n;;\n\nlet tr_48 _state _char _stack =\n raise _state ~at_eof:false Unexpected_char_parsing_dec_escape\n;;\n\nlet tr_49 state char stack =\n let stack = add_dec_escape_char state char stack in\n set_automaton_state state 12;\n advance state;\n stack\n;;\n\nlet tr_50 state char stack =\n let stack = add_last_dec_escape_char state char stack in\n set_automaton_state state 8;\n advance state;\n stack\n;;\n\nlet tr_51 _state _char _stack =\n raise _state ~at_eof:false Unexpected_char_parsing_hex_escape\n;;\n\nlet tr_52 state char stack =\n let stack = add_hex_escape_char state char stack in\n set_automaton_state state 14;\n advance state;\n stack\n;;\n\nlet tr_53 state char stack =\n let stack = add_last_hex_escape_char state char stack in\n set_automaton_state state 8;\n advance state;\n stack\n;;\n\nlet tr_54 state char stack =\n let stack = add_quoted_atom_char state char stack in\n set_automaton_state state 8;\n advance state;\n stack\n;;\n\nlet tr_55 state char stack =\n let stack = add_token_char state char stack in\n set_automaton_state state 15;\n advance state;\n stack\n;;\n\nlet tr_56 state char stack =\n let stack = add_quoted_atom_char state char stack in\n set_automaton_state state 8;\n advance_eol state;\n stack\n;;\n\nlet tr_57 state char stack =\n let stack = push_quoted_atom state char stack in\n set_automaton_state state 0;\n advance state;\n stack\n;;\n\nlet tr_58 state char stack =\n let stack = add_token_char state char stack in\n set_automaton_state state 9;\n advance state;\n stack\n;;\n\nlet tr_59 state char stack =\n let stack = add_token_char state char stack in\n set_automaton_state state 16;\n advance state;\n stack\n;;\n\nlet tr_60 state char stack =\n let stack = add_token_char state char stack in\n set_automaton_state state 16;\n advance_eol state;\n stack\n;;\n\nlet tr_61 state char stack =\n let stack = add_token_char state char stack in\n set_automaton_state state 19;\n advance state;\n stack\n;;\n\nlet tr_62 state char stack =\n let stack = add_token_char state char stack in\n set_automaton_state state 18;\n advance state;\n stack\n;;\n\nlet tr_63 state char stack =\n let stack = add_token_char state char stack in\n set_automaton_state state 17;\n advance state;\n stack\n;;\n\nlet tr_64 state char stack =\n let stack = end_block_comment state char stack in\n set_automaton_state state (if block_comment_depth state <> 0 then 16 else 0);\n advance state;\n stack\n;;\n\nlet tr_65 state char stack =\n let stack = add_token_char state char stack in\n set_automaton_state state 19;\n advance_eol state;\n stack\n;;\n\nlet tr_66 state char stack =\n let stack = add_token_char state char stack in\n set_automaton_state state 20;\n advance state;\n stack\n;;\n\nlet tr_67 state char stack =\n let stack = add_token_char state char stack in\n set_automaton_state state 26;\n advance_eol state;\n stack\n;;\n\nlet tr_68 state char stack =\n let stack = add_token_char state char stack in\n set_automaton_state state 21;\n advance state;\n stack\n;;\n\nlet tr_69 state char stack =\n let stack = add_dec_escape_char state char stack in\n set_automaton_state state 22;\n advance state;\n stack\n;;\n\nlet tr_70 state char stack =\n let stack = add_token_char state char stack in\n set_automaton_state state 24;\n advance state;\n stack\n;;\n\nlet tr_71 state char stack =\n let stack = add_token_char state char stack in\n set_automaton_state state 19;\n advance state;\n stack\n;;\n\nlet tr_72 state char stack =\n let stack = add_token_char state char stack in\n set_automaton_state state 16;\n advance state;\n stack\n;;\n\nlet tr_73 state char stack =\n let stack = add_token_char state char stack in\n set_automaton_state state 20;\n advance state;\n stack\n;;\n\nlet tr_74 state char stack =\n let stack = add_dec_escape_char state char stack in\n set_automaton_state state 23;\n advance state;\n stack\n;;\n\nlet tr_75 state char stack =\n let stack = comment_add_last_dec_escape_char state char stack in\n set_automaton_state state 19;\n advance state;\n stack\n;;\n\nlet tr_76 state char stack =\n let stack = add_token_char state char stack in\n set_automaton_state state 25;\n advance state;\n stack\n;;\n\nlet tr_77 state char stack =\n let stack = add_token_char state char stack in\n set_automaton_state state 26;\n advance state;\n stack\n;;\n\nlet tr_78 state char stack =\n let stack = add_token_char state char stack in\n set_automaton_state state 19;\n advance_eol state;\n stack\n;;\n\nlet tr_eoi_00 state stack = eps_eoi_check state stack\nlet tr_eoi_01 state _stack = raise state ~at_eof:true Automaton_in_error_state\nlet tr_eoi_02 state _stack = raise state ~at_eof:true Unexpected_character_after_cr\n\nlet tr_eoi_03 state stack =\n let stack = eps_push_atom state stack in\n eps_eoi_check state stack\n;;\n\nlet tr_eoi_04 state stack =\n let stack = end_line_comment state stack in\n eps_eoi_check state stack\n;;\n\nlet tr_eoi_05 state stack =\n let stack = eps_add_first_char_hash state stack in\n let stack = eps_push_atom state stack in\n eps_eoi_check state stack\n;;\n\nlet tr_eoi_06 state _stack = raise state ~at_eof:true Unterminated_quoted_string\nlet tr_eoi_07 state _stack = raise state ~at_eof:true Unterminated_block_comment\n\nlet transitions =\n [| tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_01\n ; tr_02\n ; tr_00\n ; tr_01\n ; tr_03\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_01\n ; tr_00\n ; tr_04\n ; tr_05\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_06\n ; tr_07\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_08\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_09\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_00\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_10\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_02\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_11\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_13\n ; tr_14\n ; tr_12\n ; tr_13\n ; tr_15\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_13\n ; tr_12\n ; tr_16\n ; tr_17\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_18\n ; tr_19\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_20\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_21\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_13\n ; tr_14\n ; tr_12\n ; tr_13\n ; tr_15\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_13\n ; tr_12\n ; tr_16\n ; tr_17\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_18\n ; tr_19\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_20\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_22\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_13\n ; tr_14\n ; tr_12\n ; tr_13\n ; tr_15\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_13\n ; tr_12\n ; tr_16\n ; tr_22\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_18\n ; tr_19\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_20\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_21\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_12\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_24\n ; tr_23\n ; tr_23\n ; tr_25\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_23\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_27\n ; tr_28\n ; tr_26\n ; tr_27\n ; tr_29\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_27\n ; tr_26\n ; tr_30\n ; tr_31\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_32\n ; tr_33\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_34\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_35\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_26\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_37\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_38\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_39\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_36\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_41\n ; tr_40\n ; tr_40\n ; tr_42\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_43\n ; tr_43\n ; tr_43\n ; tr_43\n ; tr_43\n ; tr_43\n ; tr_43\n ; tr_43\n ; tr_43\n ; tr_43\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_44\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_40\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_41\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_46\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_47\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_45\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_49\n ; tr_49\n ; tr_49\n ; tr_49\n ; tr_49\n ; tr_49\n ; tr_49\n ; tr_49\n ; tr_49\n ; tr_49\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_50\n ; tr_50\n ; tr_50\n ; tr_50\n ; tr_50\n ; tr_50\n ; tr_50\n ; tr_50\n ; tr_50\n ; tr_50\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_52\n ; tr_52\n ; tr_52\n ; tr_52\n ; tr_52\n ; tr_52\n ; tr_52\n ; tr_52\n ; tr_52\n ; tr_52\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_52\n ; tr_52\n ; tr_52\n ; tr_52\n ; tr_52\n ; tr_52\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_52\n ; tr_52\n ; tr_52\n ; tr_52\n ; tr_52\n ; tr_52\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_53\n ; tr_53\n ; tr_53\n ; tr_53\n ; tr_53\n ; tr_53\n ; tr_53\n ; tr_53\n ; tr_53\n ; tr_53\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_53\n ; tr_53\n ; tr_53\n ; tr_53\n ; tr_53\n ; tr_53\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_53\n ; tr_53\n ; tr_53\n ; tr_53\n ; tr_53\n ; tr_53\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_55\n ; tr_56\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_55\n ; tr_54\n ; tr_57\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_58\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_54\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_60\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_61\n ; tr_62\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_63\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_60\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_61\n ; tr_64\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_63\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_60\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_61\n ; tr_62\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_35\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_59\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_65\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_59\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_66\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_67\n ; tr_61\n ; tr_61\n ; tr_68\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_69\n ; tr_69\n ; tr_69\n ; tr_69\n ; tr_69\n ; tr_69\n ; tr_69\n ; tr_69\n ; tr_69\n ; tr_69\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_70\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_67\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_72\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_73\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_74\n ; tr_74\n ; tr_74\n ; tr_74\n ; tr_74\n ; tr_74\n ; tr_74\n ; tr_74\n ; tr_74\n ; tr_74\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_75\n ; tr_75\n ; tr_75\n ; tr_75\n ; tr_75\n ; tr_75\n ; tr_75\n ; tr_75\n ; tr_75\n ; tr_75\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_48\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_76\n ; tr_76\n ; tr_76\n ; tr_76\n ; tr_76\n ; tr_76\n ; tr_76\n ; tr_76\n ; tr_76\n ; tr_76\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_76\n ; tr_76\n ; tr_76\n ; tr_76\n ; tr_76\n ; tr_76\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_76\n ; tr_76\n ; tr_76\n ; tr_76\n ; tr_76\n ; tr_76\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_61\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_51\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_77\n ; tr_78\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_77\n ; tr_71\n ; tr_72\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_73\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n ; tr_71\n |]\n;;\n\nlet transitions_eoi =\n [| tr_eoi_00\n ; tr_eoi_01\n ; tr_eoi_02\n ; tr_eoi_03\n ; tr_eoi_03\n ; tr_eoi_03\n ; tr_eoi_04\n ; tr_eoi_05\n ; tr_eoi_06\n ; tr_eoi_06\n ; tr_eoi_06\n ; tr_eoi_06\n ; tr_eoi_06\n ; tr_eoi_06\n ; tr_eoi_06\n ; tr_eoi_06\n ; tr_eoi_07\n ; tr_eoi_07\n ; tr_eoi_07\n ; tr_eoi_07\n ; tr_eoi_07\n ; tr_eoi_07\n ; tr_eoi_07\n ; tr_eoi_07\n ; tr_eoi_07\n ; tr_eoi_07\n ; tr_eoi_07\n |]\n;;\n\nlet old_parser_approx_cont_states : Old_parser_cont_state.t array =\n [| Parsing_toplevel_whitespace\n ; Parsing_toplevel_whitespace\n ; Parsing_nested_whitespace\n ; Parsing_atom\n ; Parsing_atom\n ; Parsing_atom\n ; Parsing_toplevel_whitespace\n ; Parsing_atom\n ; Parsing_atom\n ; Parsing_atom\n ; Parsing_atom\n ; Parsing_atom\n ; Parsing_atom\n ; Parsing_atom\n ; Parsing_atom\n ; Parsing_atom\n ; Parsing_block_comment\n ; Parsing_block_comment\n ; Parsing_block_comment\n ; Parsing_block_comment\n ; Parsing_block_comment\n ; Parsing_block_comment\n ; Parsing_block_comment\n ; Parsing_block_comment\n ; Parsing_block_comment\n ; Parsing_block_comment\n ; Parsing_block_comment\n |]\n;;\n\n(*$*)\n\nlet feed (type u s) (state : (u, s) state) char (stack : s) : s =\n let idx = (automaton_state state lsl 8) lor Char.code char in\n (* We need an Obj.magic as the type of the array can't be generalized.\n This problem will go away when we get immutable arrays. *)\n let magic\n : ((u', s') state -> char -> s' -> s') array\n -> ((u, s) state -> char -> s -> s) array\n =\n Obj.magic\n in\n (magic transitions).(idx) state char stack\n[@@inline always]\n;;\n\nlet feed_eoi (type u s) (state : (u, s) state) (stack : s) : s =\n let magic : ((u', s') state -> s' -> s') array -> ((u, s) state -> s -> s) array =\n Obj.magic\n in\n let stack = (magic transitions_eoi).(automaton_state state) state stack in\n set_error_state state;\n stack\n;;\n\nlet old_parser_cont_state state : Old_parser_cont_state.t =\n match context state with\n | Sexp_comment -> Parsing_sexp_comment\n | Sexp ->\n (match\n old_parser_approx_cont_states.(automaton_state state), has_unclosed_paren state\n with\n | Parsing_toplevel_whitespace, true -> Parsing_list\n | s, _ -> s)\n;;\n","open! Import\ninclude Kind_intf\n\nlet create (type stack state) (module Stack : Stack with type t = stack) kind\n : (module S with type Stack.t = stack and type state = state)\n =\n (module struct\n module Stack = Stack\n\n type nonrec state = state\n\n let kind = kind\n end)\n;;\n\nmodule Sexp = (val create (module Automaton_stack) Sexp)\nmodule Sexp_with_positions = (val create (module Automaton_stack) Sexp_with_positions)\nmodule Positions = (val create (module Automaton_stack.Just_positions) Positions)\nmodule Cst = (val create (module Automaton_stack.For_cst) Cst)\n","open! Import\n\nlet rec feed_substring_unsafe str state stack i stop =\n if i < stop\n then (\n let c = String.unsafe_get str i in\n let stack = Parser_automaton.feed state c stack in\n feed_substring_unsafe str state stack (i + 1) stop)\n else stack\n;;\n\nlet rec feed_subbytes_unsafe str state stack i stop =\n if i < stop\n then (\n let c = Bytes.unsafe_get str i in\n let stack = Parser_automaton.feed state c stack in\n feed_subbytes_unsafe str state stack (i + 1) stop)\n else stack\n;;\n\nlet feed_substring state str ~pos ~len stack =\n let str_len = String.length str in\n if pos < 0 || len < 0 || pos > str_len - len then invalid_arg \"Parsexp.feed_substring\";\n feed_substring_unsafe str state stack pos (pos + len)\n;;\n\nlet feed_subbytes state str ~pos ~len stack =\n let str_len = Bytes.length str in\n if pos < 0 || len < 0 || pos > str_len - len then invalid_arg \"Parsexp.feed_subbytes\";\n feed_subbytes_unsafe str state stack pos (pos + len)\n;;\n\nlet feed_string state str stack =\n feed_substring_unsafe str state stack 0 (String.length str)\n;;\n\nlet feed_bytes state str stack =\n feed_subbytes_unsafe str state stack 0 (Bytes.length str)\n;;\n","open! Import\ninclude Parser_intf\n\n\nmodule Make (Kind : Kind.S) (Mode : Mode(Kind).S) :\n S\n with type parsed_value = Mode.parsed_value\n with type State.t = (Kind.state, Kind.Stack.t) A.state\n with module Stack = Kind.Stack = struct\n type parsed_value = Mode.parsed_value\n\n module Stack = Kind.Stack\n\n module State = struct\n type t = (Kind.state, Kind.Stack.t) A.state\n\n let create ?pos () = A.new_state ?initial_pos:pos Mode.mode Kind.kind\n let reset = A.reset\n let offset = A.offset\n let line = A.line\n let column = A.column\n let position t : Positions.pos = { offset = offset t; line = line t; col = column t }\n let stop state = A.set_error_state state\n end\n\n let feed = A.feed\n let feed_eoi state stack = Mode.make_value state (A.feed_eoi state stack)\n let feed_substring = Automaton_helpers.feed_substring\n let feed_string = Automaton_helpers.feed_string\n let feed_subbytes = Automaton_helpers.feed_subbytes\n let feed_bytes = Automaton_helpers.feed_bytes\n\n let parse_string_exn str =\n let state = State.create () in\n feed_eoi state (feed_string state str Kind.Stack.empty)\n ;;\n\n let parse_string str =\n match parse_string_exn str with\n | x -> Ok x\n | exception Parse_error.Parse_error e -> Error e\n ;;\nend\n\nmodule Make_eager (Kind : Kind.S) (Mode : Mode_eager(Kind).S) :\n S_eager\n with type parsed_value = Mode.parsed_value\n with type State.t = (Kind.state, Kind.Stack.t) A.state\n with module Stack = Kind.Stack = struct\n type parsed_value = Mode.parsed_value\n\n module Stack = Kind.Stack\n\n module State = struct\n module Read_only = struct\n type t = (Kind.state, Kind.Stack.t) A.state\n\n let offset = A.offset\n let line = A.line\n let column = A.column\n\n let position t : Positions.pos =\n { offset = offset t; line = line t; col = column t }\n ;;\n end\n\n include Read_only\n\n let create ?pos ?(no_sexp_is_error = false) f =\n let got_sexp state stack =\n let parsed_value = Mode.make_value state stack in\n f state parsed_value;\n Stack.empty\n in\n A.new_state ?initial_pos:pos (Eager { got_sexp; no_sexp_is_error }) Kind.kind\n ;;\n\n let reset = A.reset\n let stop t = A.set_error_state t\n let old_parser_cont_state t = Parser_automaton.old_parser_cont_state t\n end\n\n let feed = A.feed\n let feed_eoi state stack = ignore (A.feed_eoi state stack : Stack.t)\n let feed_substring = Automaton_helpers.feed_substring\n let feed_string = Automaton_helpers.feed_string\n let feed_subbytes = Automaton_helpers.feed_subbytes\n let feed_bytes = Automaton_helpers.feed_bytes\n\n module Lexbuf_consumer = struct\n type t = State.t\n\n exception Got_sexp of parsed_value * Positions.pos\n\n let got_sexp state parsed_value =\n raise_notrace (Got_sexp (parsed_value, State.position state))\n ;;\n\n let create () = State.create got_sexp\n\n let pos_of_lexbuf lexbuf =\n let p = lexbuf.Lexing.lex_curr_p in\n { Positions.line = p.pos_lnum; col = p.pos_cnum - p.pos_bol; offset = p.pos_cnum }\n ;;\n\n let update_lexbuf (lexbuf : Lexing.lexbuf) (pos : Positions.pos) =\n let p = pos.offset - lexbuf.lex_abs_pos in\n lexbuf.lex_curr_pos <- p;\n lexbuf.lex_start_pos <- p;\n lexbuf.lex_curr_p\n <- { lexbuf.lex_curr_p with\n pos_lnum = pos.line\n ; pos_cnum = pos.offset\n ; pos_bol = pos.offset - pos.col\n }\n ;;\n\n let rec feed_lexbuf t (lexbuf : Lexing.lexbuf) stack =\n let stack =\n feed_subbytes\n t\n lexbuf.lex_buffer\n stack\n ~pos:lexbuf.lex_curr_pos\n ~len:(lexbuf.lex_buffer_len - lexbuf.lex_curr_pos)\n in\n lexbuf.lex_curr_pos <- lexbuf.lex_buffer_len;\n lexbuf.lex_start_pos <- lexbuf.lex_buffer_len;\n if not lexbuf.lex_eof_reached\n then (\n lexbuf.refill_buff lexbuf;\n feed_lexbuf t lexbuf stack)\n else feed_eoi t stack\n ;;\n\n let parse_gen t (lexbuf : Lexing.lexbuf) =\n A.reset t ~pos:(pos_of_lexbuf lexbuf);\n match feed_lexbuf t lexbuf Stack.empty with\n | () ->\n update_lexbuf lexbuf (State.position t);\n None\n | exception Got_sexp (parsed_value, pos) ->\n update_lexbuf lexbuf pos;\n Some parsed_value\n | exception exn ->\n update_lexbuf lexbuf (State.position t);\n raise exn\n ;;\n\n let set_no_sexp_is_error t x =\n match A.mode t with\n | Eager e -> e.no_sexp_is_error <- x\n | _ -> assert false\n ;;\n\n let parse t lexbuf =\n set_no_sexp_is_error t true;\n match parse_gen t lexbuf with\n | Some x -> x\n | None -> failwith \"Parsexp.parse_gen: None\"\n ;;\n\n let parse_opt t lexbuf =\n set_no_sexp_is_error t false;\n parse_gen t lexbuf\n ;;\n end\nend\n","open! Import\ninclude Conv_intf\n\nmodule Make\n (Mode : Mode)\n (Sexp_parser : Parser.S with type parsed_value = Mode.parsed_sexp)\n (Positions_parser : Parser.S with type parsed_value = Positions.t) =\nstruct\n let reraise positions parsed_value ~sub user_exn =\n let location = Mode.find positions parsed_value ~sub in\n Of_sexp_error.raise ~user_exn ~sub_sexp:sub ~location\n ;;\n\n let parse_string_exn str f =\n let parsed_value = Sexp_parser.parse_string_exn str in\n match Mode.apply_f parsed_value ~f with\n | x -> x\n | exception Sexp.Of_sexp_error (exn, sub) ->\n let positions = Positions_parser.parse_string_exn str in\n reraise positions parsed_value exn ~sub\n ;;\n\n let parse_string str f : (_, Conv_error.t) result =\n match parse_string_exn str f with\n | x -> Ok x\n | exception Parse_error.Parse_error e -> Error (Parse_error e)\n | exception Of_sexp_error.Of_sexp_error e -> Error (Of_sexp_error e)\n ;;\n\n let conv_exn (parsed_value, positions) f =\n match Mode.apply_f parsed_value ~f with\n | x -> x\n | exception Sexp.Of_sexp_error (exn, sub) -> reraise positions parsed_value exn ~sub\n ;;\n\n let conv x f =\n match conv_exn x f with\n | x -> Ok x\n | exception Of_sexp_error.Of_sexp_error e -> Error e\n ;;\n\n let conv_combine result f : (_, Conv_error.t) result =\n match result with\n | Error e -> Error (Parse_error e)\n | Ok x ->\n (match conv x f with\n | Ok _ as r -> r\n | Error e -> Error (Of_sexp_error e))\n ;;\nend\n","(* Sexp: Module for handling S-expressions (I/O, etc.) *)\n\nopen Format\nopen Bigarray\nmodule Sexplib = Sexplib0\nmodule Conv = Sexplib.Sexp_conv\n\n(* conv.ml depends on us so we can only use this module *)\n\ninclude Type\n\ntype bigstring = (char, int8_unsigned_elt, c_layout) Array1.t\n\ninclude (\n Sexplib.Sexp :\n module type of struct\n include Sexplib.Sexp\n end\n with type t := t)\n\ninclude Private\n\n(* Output of S-expressions to I/O-channels *)\n\nlet with_new_buffer oc f =\n let buf = buffer () in\n f buf;\n Buffer.output_buffer oc buf\n;;\n\nlet output_hum oc sexp = with_new_buffer oc (fun buf -> to_buffer_hum sexp ~buf)\n\nlet output_hum_indent indent oc sexp =\n with_new_buffer oc (fun buf -> to_buffer_hum ~indent sexp ~buf)\n;;\n\nlet output_mach oc sexp = with_new_buffer oc (fun buf -> to_buffer_mach sexp ~buf)\nlet output = output_mach\n\n(* Output of S-expressions to file *)\n\n(* The temp file functions in the OCaml Filename module do not support\n permissions. But opening a file with given permissions is different\n from opening it and chmoding it to these permissions, because the umask\n is taken in account. Under Unix there's no easy way to get the umask in\n a thread-safe way. *)\nmodule Tmp_file = struct\n let prng = ref None\n\n let temp_file_name prefix suffix =\n let rand_state =\n match !prng with\n | Some v -> v\n | None ->\n let ret = Random.State.make_self_init () in\n prng := Some ret;\n ret\n in\n let rnd = Random.State.bits rand_state land 0xFFFFFF in\n Printf.sprintf \"%s%06x%s\" prefix rnd suffix\n ;;\n\n (* Keep the permissions loose. Sexps are usually shared and rarely private*)\n let open_temp_file ?(perm = 0o666) prefix suffix =\n let rec try_name counter =\n let name = temp_file_name prefix suffix in\n try\n let oc =\n open_out_gen [ Open_wronly; Open_creat; Open_excl; Open_text ] perm name\n in\n name, oc\n with\n | Sys_error _ as e -> if counter >= 1000 then raise e else try_name (counter + 1)\n in\n try_name 0\n ;;\nend\n\nlet save_of_output ?perm output_function file sexp =\n let tmp_name, oc = Tmp_file.open_temp_file ?perm file \"tmp\" in\n (try\n output_function oc sexp;\n close_out oc\n with\n | e ->\n close_out_noerr oc;\n (try Sys.remove tmp_name with\n | _ -> ());\n raise e);\n Sys.rename tmp_name file\n;;\n\nlet output_sexp_nl do_output oc sexp =\n do_output oc sexp;\n output_string oc \"\\n\"\n;;\n\nlet save_hum ?perm file sexp = save_of_output ?perm (output_sexp_nl output_hum) file sexp\nlet save_mach ?perm file sexp = save_of_output ?perm output_mach file sexp\nlet save = save_mach\nlet output_sexps_nl do_output oc sexps = List.iter (output_sexp_nl do_output oc) sexps\n\nlet save_sexps_hum ?perm file sexps =\n save_of_output ?perm (output_sexps_nl output_hum) file sexps\n;;\n\nlet save_sexps_mach ?perm file sexps =\n save_of_output ?perm (output_sexps_nl output_mach) file sexps\n;;\n\nlet save_sexps = save_sexps_mach\n\n(* Scan functions *)\n\nlet scan_sexp ?buf lexbuf = Parser.sexp (Lexer.main ?buf) lexbuf\nlet scan_sexp_opt ?buf lexbuf = Parser.sexp_opt (Lexer.main ?buf) lexbuf\nlet scan_sexps ?buf lexbuf = Parser.sexps (Lexer.main ?buf) lexbuf\nlet scan_rev_sexps ?buf lexbuf = Parser.rev_sexps (Lexer.main ?buf) lexbuf\n\nlet get_main_buf buf =\n let buf =\n match buf with\n | None -> Buffer.create 128\n | Some buf -> buf\n in\n Lexer.main ~buf\n;;\n\nlet scan_fold_sexps ?buf ~f ~init lexbuf =\n let main = get_main_buf buf in\n let rec loop acc =\n match Parser.sexp_opt main lexbuf with\n | None -> acc\n | Some sexp -> loop (f acc sexp)\n in\n loop init\n;;\n\nlet scan_iter_sexps ?buf ~f lexbuf =\n scan_fold_sexps ?buf lexbuf ~init:() ~f:(fun () sexp -> f sexp)\n;;\n\nlet scan_sexps_conv ?buf ~f lexbuf =\n let coll acc sexp = f sexp :: acc in\n List.rev (scan_fold_sexps ?buf ~f:coll ~init:[] lexbuf)\n;;\n\nlet sexp_conversion_error_message ?containing_sexp ?location ?invalid_sexp () ~exn : t =\n List\n (List.concat\n [ [ Atom \"Of_sexp_error\" ]\n ; (match location with\n | None -> []\n | Some x -> [ Atom x ])\n ; [ (match exn with\n | Failure x -> Atom x\n | _ -> Conv.sexp_of_exn exn)\n ]\n ; (match invalid_sexp with\n | None -> []\n | Some x -> [ List [ Atom \"invalid_sexp\"; x ] ])\n ; (match containing_sexp with\n | None -> []\n | Some x -> [ List [ Atom \"containing_sexp\"; x ] ])\n ])\n;;\n\n(* Partial parsing *)\n\nmodule Annot = struct\n type pos = Parsexp.Positions.pos =\n { line : int\n ; col : int\n ; offset : int\n }\n\n type range = Parsexp.Positions.range =\n { start_pos : pos\n ; end_pos : pos\n }\n\n type t =\n | Atom of range * Type.t\n | List of range * t list * Type.t\n\n type 'a conv =\n [ `Result of 'a\n | `Error of exn * t\n ]\n\n exception Conv_exn of string * exn\n\n let () =\n Conv.Exn_converter.add ~finalise:false [%extension_constructor Conv_exn] (function\n | Conv_exn (location, exn) -> sexp_conversion_error_message () ~location ~exn\n | _ -> assert false)\n ;;\n\n type stack =\n { mutable positions : pos list\n ; mutable stack : t list list\n }\n\n let get_sexp = function\n | Atom (_, sexp) | List (_, _, sexp) -> sexp\n ;;\n\n let get_range = function\n | Atom (range, _) | List (range, _, _) -> range\n ;;\n\n let sexp_of_conv sexp_of_a = function\n | `Result a -> Type.List [ Atom \"Result\"; a |> sexp_of_a ]\n | `Error (exn, t) ->\n List [ Atom \"Error\"; List [ exn |> Conv.sexp_of_exn; t |> get_sexp ] ]\n ;;\n\n exception Annot_sexp of t\n\n let find_sexp annot_sexp sexp =\n let rec loop annot_sexp =\n match annot_sexp with\n | (Atom (_, sub_sexp) | List (_, _, sub_sexp)) when sexp == sub_sexp ->\n raise (Annot_sexp annot_sexp)\n | List (_, annots, _) -> List.iter loop annots\n | Atom _ -> ()\n in\n try\n loop annot_sexp;\n None\n with\n | Annot_sexp res -> Some res\n ;;\nend\n\nlet () =\n Conv.Exn_converter.add ~finalise:false [%extension_constructor Of_sexp_error] (function\n | Of_sexp_error (Annot.Conv_exn (location, exn), invalid_sexp) ->\n sexp_conversion_error_message () ~location ~invalid_sexp ~exn\n | Of_sexp_error (exn, invalid_sexp) ->\n sexp_conversion_error_message () ~invalid_sexp ~exn\n | _ ->\n (* Reaching this branch indicates a bug in sexplib. *)\n assert false)\n;;\n\nmodule Parse_pos = struct\n type t =\n { mutable text_line : int\n ; mutable text_char : int\n ; mutable global_offset : int\n ; mutable buf_pos : int\n }\n\n let create ?(text_line = 1) ?(text_char = 0) ?(buf_pos = 0) ?(global_offset = 0) () =\n let fail msg = failwith (\"Sexplib.Sexp.Parse_pos.create: \" ^ msg) in\n if text_line < 1\n then fail \"text_line < 1\"\n else if text_char < 0\n then fail \"text_char < 0\"\n else if global_offset < 0\n then fail \"global_offset < 0\"\n else if buf_pos < 0\n then fail \"buf_pos < 0\"\n else { text_line; text_char; global_offset; buf_pos }\n ;;\n\n let with_buf_pos t buf_pos = { t with buf_pos }\nend\n\nmodule Cont_state = Parsexp.Old_parser_cont_state\n\ntype ('a, 't) parse_result =\n | Done of 't * Parse_pos.t\n | Cont of Cont_state.t * ('a, 't) parse_fun\n\nand ('a, 't) parse_fun = pos:int -> len:int -> 'a -> ('a, 't) parse_result\n\ntype 't parse_state = { parse_pos : Parse_pos.t }\n\ntype parse_error =\n { err_msg : string\n ; parse_state : [ `Sexp of t list list parse_state | `Annot of Annot.stack parse_state ]\n }\n\nexception Parse_error of parse_error\n\nlet () =\n Conv.Exn_converter.add ~finalise:false [%extension_constructor Parse_error] (function\n | Parse_error pe ->\n let ppos =\n match pe.parse_state with\n | `Sexp { parse_pos } | `Annot { parse_pos } -> parse_pos\n in\n List\n [ Atom \"Sexplib.Sexp.Parse_error\"\n ; List\n [ List [ Atom \"err_msg\"; Atom pe.err_msg ]\n ; List [ Atom \"text_line\"; Conv.sexp_of_int ppos.Parse_pos.text_line ]\n ; List [ Atom \"text_char\"; Conv.sexp_of_int ppos.Parse_pos.text_char ]\n ; List\n [ Atom \"global_offset\"; Conv.sexp_of_int ppos.Parse_pos.global_offset ]\n ; List [ Atom \"buf_pos\"; Conv.sexp_of_int ppos.Parse_pos.buf_pos ]\n ]\n ]\n | _ -> assert false)\n;;\n\nmodule Parser_output : sig\n module type T = sig\n module Impl : Parsexp.Eager_parser\n\n type output\n\n exception Found of output\n\n val raise_found : Impl.State.Read_only.t -> Impl.parsed_value -> unit\n end\n\n module Bare_sexp : T with type output = Type.t\n module Annotated_sexp : T with type output = Annot.t\nend = struct\n module type T = sig\n module Impl : Parsexp.Eager_parser\n\n type output\n\n exception Found of output\n\n val raise_found : Impl.State.Read_only.t -> Impl.parsed_value -> unit\n end\n\n module I = Parsexp.Positions.Iterator\n\n let rec annotate_sexp sexp iter =\n match sexp with\n | Type.Atom _ ->\n let start_pos = I.advance_exn iter ~skip:0 in\n let end_pos = I.advance_exn iter ~skip:0 in\n Annot.Atom ({ start_pos; end_pos }, sexp)\n | Type.List l ->\n let start_pos = I.advance_exn iter ~skip:0 in\n let annot = annotate_sexp_list l iter in\n let end_pos = I.advance_exn iter ~skip:0 in\n Annot.List ({ start_pos; end_pos }, annot, sexp)\n\n and annotate_sexp_list sexps iter =\n List.rev (List.rev_map (fun sexp -> annotate_sexp sexp iter) sexps)\n ;;\n\n module Bare_sexp = struct\n module Impl = Parsexp.Eager\n\n type output = Type.t\n\n exception Found of output\n\n let raise_found _state sexp = raise_notrace (Found sexp)\n end\n\n module Annotated_sexp = struct\n module Impl = Parsexp.Eager_and_positions\n\n type output = Annot.t\n\n exception Found of output\n\n let raise_found _state (sexp, positions) =\n let annot = annotate_sexp sexp (I.create positions) in\n raise_notrace (Found annot)\n ;;\n end\nend\n\nmodule Make_parser (T : sig\n include Parser_output.T\n\n type input\n\n val length : input -> int\n\n val unsafe_feed_loop\n : Impl.State.t\n -> Impl.Stack.t\n -> input\n -> max_pos:int\n -> pos:int\n -> Impl.Stack.t\n end) : sig\n val parse\n : ?parse_pos:Parse_pos.t\n -> ?len:int\n -> T.input\n -> (T.input, T.output) parse_result\nend = struct\n let parse_pos_of_state state buf_pos =\n { Parse_pos.text_line = T.Impl.State.line state\n ; Parse_pos.text_char = T.Impl.State.column state\n ; Parse_pos.global_offset = T.Impl.State.offset state\n ; Parse_pos.buf_pos\n }\n ;;\n\n let check_str_bounds ~pos ~len str =\n if pos < 0 then invalid_arg \"parse: pos < 0\";\n if len < 0 then invalid_arg \"parse: len < 0\";\n let str_len = T.length str in\n let pos_len = pos + len in\n if pos_len > str_len then invalid_arg \"parse: pos + len > str_len\";\n pos_len - 1\n ;;\n\n let raise_parse_error state pos msg =\n let parse_state = { parse_pos = parse_pos_of_state state pos } in\n let parse_error = { err_msg = msg; parse_state = `Sexp parse_state } in\n raise (Parse_error parse_error)\n ;;\n\n let handle_parsexp_error state pos e =\n let msg = Parsexp.Parse_error.message e in\n match Parsexp.Parse_error.Private.old_parser_exn e with\n | `Parse_error -> raise_parse_error state pos msg\n | `Failure -> failwith msg\n ;;\n\n let rec run_feed_loop state stack ~pos ~len str =\n let max_pos = check_str_bounds ~pos ~len str in\n let previous_offset = T.Impl.State.offset state in\n match T.unsafe_feed_loop state stack str ~max_pos ~pos with\n | stack -> mk_cont_state state stack\n | exception T.Found result ->\n let offset = T.Impl.State.offset state in\n let next_pos = pos + (offset - previous_offset) in\n Done (result, parse_pos_of_state state next_pos)\n | exception Parsexp.Parse_error.Parse_error err ->\n handle_parsexp_error\n state\n (pos + (T.Impl.State.offset state - previous_offset))\n err\n\n and mk_cont_state state stack =\n let parse_fun =\n let used_ref = ref false in\n fun ~pos ~len str ->\n if !used_ref\n then failwith \"Sexplib.Sexp: parser continuation called twice\"\n else (\n used_ref := true;\n run_feed_loop state stack ~pos ~len str)\n in\n let cont_state = T.Impl.State.old_parser_cont_state state in\n Cont (cont_state, parse_fun)\n ;;\n\n let parse ?(parse_pos = Parse_pos.create ()) ?len str =\n let pos, buf_pos =\n let { Parse_pos.text_line; text_char; global_offset; buf_pos } = parse_pos in\n ( { Parsexp.Positions.line = text_line; col = text_char; offset = global_offset }\n , buf_pos )\n in\n let state = T.Impl.State.create ~pos ~no_sexp_is_error:false T.raise_found in\n let stack = T.Impl.Stack.empty in\n let len =\n match len with\n | Some x -> x\n | None -> T.length str - buf_pos\n in\n run_feed_loop state stack str ~pos:buf_pos ~len\n ;;\nend\n[@@inline always]\n\nmodule String_single_sexp = Make_parser (struct\n include Parser_output.Bare_sexp\n\n type input = string\n\n let length = String.length\n\n let rec unsafe_feed_loop state stack str ~max_pos ~pos =\n if pos <= max_pos\n then (\n let stack = Impl.feed state (String.unsafe_get str pos) stack in\n unsafe_feed_loop state stack str ~max_pos ~pos:(pos + 1))\n else stack\n ;;\n end)\n\nlet parse_str = String_single_sexp.parse\nlet parse = String_single_sexp.parse\n\nmodule String_single_annot = Make_parser (struct\n include Parser_output.Annotated_sexp\n\n type input = string\n\n let length = String.length\n\n let rec unsafe_feed_loop state stack str ~max_pos ~pos =\n if pos <= max_pos\n then (\n let stack = Impl.feed state (String.unsafe_get str pos) stack in\n unsafe_feed_loop state stack str ~max_pos ~pos:(pos + 1))\n else stack\n ;;\n end)\n\nlet parse_str_annot = String_single_annot.parse\n\nmodule Bigstring_single_sexp = Make_parser (struct\n include Parser_output.Bare_sexp\n\n type input = bigstring\n\n let length = Array1.dim\n\n let rec unsafe_feed_loop state stack (str : input) ~max_pos ~pos =\n if pos <= max_pos\n then (\n let stack = Impl.feed state (Array1.unsafe_get str pos) stack in\n unsafe_feed_loop state stack str ~max_pos ~pos:(pos + 1))\n else stack\n ;;\n end)\n\nlet parse_bigstring = Bigstring_single_sexp.parse\n\nmodule Bigstring_single_annot = Make_parser (struct\n include Parser_output.Annotated_sexp\n\n type input = bigstring\n\n let length = Array1.dim\n\n let rec unsafe_feed_loop state stack (str : input) ~max_pos ~pos =\n if pos <= max_pos\n then (\n let stack = Impl.feed state (Array1.unsafe_get str pos) stack in\n unsafe_feed_loop state stack str ~max_pos ~pos:(pos + 1))\n else stack\n ;;\n end)\n\nlet parse_bigstring_annot = Bigstring_single_annot.parse\n\n(* Input functions *)\n\nlet mk_this_parse ?parse_pos my_parse =\n ();\n fun ~pos ~len str ->\n let parse_pos =\n match parse_pos with\n | None -> Parse_pos.create ~buf_pos:pos ()\n | Some parse_pos ->\n parse_pos.Parse_pos.buf_pos <- pos;\n parse_pos\n in\n my_parse ?parse_pos:(Some parse_pos) ?len:(Some len) str\n;;\n\n(* [ws_buf] must contain a single space character *)\nlet feed_end_of_input ~this_parse ~ws_buf =\n (* When parsing atoms, the incremental parser cannot tell whether\n it is at the end until it hits whitespace. We therefore feed it\n one space to determine whether it is finished. *)\n match this_parse ~pos:0 ~len:1 ws_buf with\n | Done (sexp, _) -> Ok sexp\n | Cont (cont_state, _) -> Error cont_state\n;;\n\nlet gen_input_sexp my_parse ?parse_pos ic =\n let buf = Bytes.create 1 in\n let rec loop this_parse =\n match input_char ic with\n | exception End_of_file ->\n (match feed_end_of_input ~this_parse ~ws_buf:\" \" with\n | Ok sexp -> sexp\n | Error _ -> raise End_of_file)\n | c ->\n Bytes.set buf 0 c;\n (match this_parse ~pos:0 ~len:1 (Bytes.unsafe_to_string buf) with\n | Done (sexp, _) -> sexp\n | Cont (_, this_parse) -> loop this_parse)\n in\n loop (mk_this_parse ?parse_pos my_parse)\n;;\n\nlet input_sexp ?parse_pos ic = gen_input_sexp parse ?parse_pos ic\n\nlet gen_input_rev_sexps my_parse ~ws_buf ?parse_pos ?(buf = Bytes.create 8192) ic =\n let rev_sexps_ref = ref [] in\n let buf_len = Bytes.length buf in\n let rec loop this_parse ~pos ~len =\n if len > 0\n then (\n match this_parse ~pos ~len (Bytes.unsafe_to_string buf) with\n | Done (sexp, ({ Parse_pos.buf_pos; _ } as parse_pos)) ->\n rev_sexps_ref := sexp :: !rev_sexps_ref;\n let n_parsed = buf_pos - pos in\n let this_parse = mk_this_parse ~parse_pos my_parse in\n if n_parsed = len\n then (\n let new_len = input ic buf 0 buf_len in\n loop this_parse ~pos:0 ~len:new_len)\n else loop this_parse ~pos:buf_pos ~len:(len - n_parsed)\n | Cont (_, this_parse) -> loop this_parse ~pos:0 ~len:(input ic buf 0 buf_len))\n else (\n match feed_end_of_input ~this_parse ~ws_buf with\n | Ok sexp -> sexp :: !rev_sexps_ref\n | Error Parsing_toplevel_whitespace -> !rev_sexps_ref\n | Error cont_state ->\n failwith\n (\"Sexplib.Sexp.input_rev_sexps: reached EOF while in state \"\n ^ Cont_state.to_string cont_state))\n in\n let len = input ic buf 0 buf_len in\n let this_parse = mk_this_parse ?parse_pos my_parse in\n loop this_parse ~pos:0 ~len\n;;\n\nlet input_rev_sexps ?parse_pos ?buf ic =\n gen_input_rev_sexps parse ~ws_buf:\" \" ?parse_pos ?buf ic\n;;\n\nlet input_sexps ?parse_pos ?buf ic = List.rev (input_rev_sexps ?parse_pos ?buf ic)\n\n(* of_string and of_bigstring *)\n\nlet of_string_bigstring loc my_parse ws_buf get_len get_sub str =\n match my_parse ?parse_pos:None ?len:None str with\n | Done (sexp, parse_pos) ->\n (match my_parse ?parse_pos:(Some parse_pos) ?len:None str with\n | Done (_sexp2, _) ->\n failwith\n (sprintf\n \"Sexplib.Sexp.%s: got multiple S-expressions where only one was expected.\"\n loc)\n | Cont (Cont_state.Parsing_toplevel_whitespace, _) -> sexp\n | Cont (_, _) ->\n (* not using [feed_end_of_input] here means \"a b\" will end up here and not in\n \"multiple S-expressions\" branch, but it doesn't matter that much *)\n failwith\n (sprintf\n \"Sexplib.Sexp.%s: S-expression followed by data at position %d...\"\n loc\n parse_pos.buf_pos))\n | Cont (_, this_parse) ->\n (match feed_end_of_input ~this_parse ~ws_buf with\n | Ok sexp -> sexp\n | Error cont_state ->\n let cont_state_str = Cont_state.to_string cont_state in\n failwith\n (sprintf\n \"Sexplib.Sexp.%s: incomplete S-expression while in state %s: %s\"\n loc\n cont_state_str\n (get_sub str 0 (get_len str))))\n;;\n\nlet of_string str =\n of_string_bigstring \"of_string\" parse \" \" String.length String.sub str\n;;\n\nlet get_bstr_sub_str bstr pos len =\n let str = Bytes.create len in\n for i = 0 to len - 1 do\n Bytes.set str i bstr.{pos + i}\n done;\n Bytes.unsafe_to_string str\n;;\n\nlet bstr_ws_buf = Array1.create char c_layout 1\nlet () = bstr_ws_buf.{0} <- ' '\n\nlet of_bigstring bstr =\n of_string_bigstring\n \"of_bigstring\"\n parse_bigstring\n bstr_ws_buf\n Array1.dim\n get_bstr_sub_str\n bstr\n;;\n\n(* Loading *)\n\nlet gen_load_rev_sexps input_rev_sexps ?buf file =\n let ic = open_in file in\n try\n let sexps = input_rev_sexps ?parse_pos:None ?buf ic in\n close_in ic;\n sexps\n with\n | exc ->\n close_in_noerr ic;\n raise exc\n;;\n\nlet load_rev_sexps ?buf file = gen_load_rev_sexps input_rev_sexps ?buf file\nlet load_sexps ?buf file = List.rev (load_rev_sexps ?buf file)\nlet gen_load_sexp_loc = \"Sexplib.Sexp.gen_load_sexp\"\n\nlet gen_load_sexp my_parse ?(strict = true) ?(buf = Bytes.create 8192) file =\n let buf_len = Bytes.length buf in\n let ic = open_in file in\n let rec loop this_parse =\n let len = input ic buf 0 buf_len in\n if len = 0\n then (\n match feed_end_of_input ~this_parse ~ws_buf:\" \" with\n | Ok sexp -> sexp\n | Error cont_state ->\n failwith\n (sprintf\n \"%s: EOF in %s while in state %s\"\n gen_load_sexp_loc\n file\n (Cont_state.to_string cont_state)))\n else (\n match this_parse ~pos:0 ~len (Bytes.unsafe_to_string buf) with\n | Done (sexp, ({ Parse_pos.buf_pos; _ } as parse_pos)) when strict ->\n let rec strict_loop this_parse ~pos ~len =\n match this_parse ~pos ~len (Bytes.unsafe_to_string buf) with\n | Done _ ->\n failwith\n (sprintf \"%s: more than one S-expression in file %s\" gen_load_sexp_loc file)\n | Cont (cont_state, this_parse) ->\n let len = input ic buf 0 buf_len in\n if len > 0\n then strict_loop this_parse ~pos:0 ~len\n else if cont_state = Cont_state.Parsing_toplevel_whitespace\n then sexp\n else\n failwith\n (sprintf\n \"%s: %s in state %s loading file %s\"\n gen_load_sexp_loc\n \"additional incomplete data\"\n (Cont_state.to_string cont_state)\n file)\n in\n let this_parse = mk_this_parse ~parse_pos my_parse in\n strict_loop this_parse ~pos:buf_pos ~len:(len - buf_pos)\n | Done (sexp, _) -> sexp\n | Cont (_, this_parse) -> loop this_parse)\n in\n try\n let sexp = loop (mk_this_parse my_parse) in\n close_in ic;\n sexp\n with\n | exc ->\n close_in_noerr ic;\n raise exc\n;;\n\nlet load_sexp ?strict ?buf file = gen_load_sexp parse ?strict ?buf file\n\nmodule Annotated = struct\n include Annot\n\n let parse = parse_str_annot\n let parse_bigstring = parse_bigstring_annot\n\n let input_rev_sexps ?parse_pos ?buf ic =\n gen_input_rev_sexps parse ~ws_buf:\" \" ?parse_pos ?buf ic\n ;;\n\n let input_sexp ?parse_pos ic = gen_input_sexp parse ?parse_pos ic\n let input_sexps ?parse_pos ?buf ic = List.rev (input_rev_sexps ?parse_pos ?buf ic)\n\n let of_string str =\n of_string_bigstring \"Annotated.of_string\" parse \" \" String.length String.sub str\n ;;\n\n let of_bigstring bstr =\n of_string_bigstring\n \"Annotated.of_bigstring\"\n parse_bigstring\n bstr_ws_buf\n Array1.dim\n get_bstr_sub_str\n bstr\n ;;\n\n let load_rev_sexps ?buf file = gen_load_rev_sexps input_rev_sexps ?buf file\n let load_sexps ?buf file = List.rev (load_rev_sexps ?buf file)\n let load_sexp ?strict ?buf file = gen_load_sexp parse ?strict ?buf file\n\n let conv f annot_sexp =\n let sexp = get_sexp annot_sexp in\n try `Result (f sexp) with\n | Of_sexp_error (exc, bad_sexp) as e ->\n (match find_sexp annot_sexp bad_sexp with\n | None -> raise e\n | Some bad_annot_sexp -> `Error (exc, bad_annot_sexp))\n ;;\n\n let get_conv_exn ~file ~exc annot_sexp =\n let range = get_range annot_sexp in\n let { start_pos = { line; col; offset = _ }; end_pos = _ } = range in\n let loc = sprintf \"%s:%d:%d\" file line col in\n Of_sexp_error (Annot.Conv_exn (loc, exc), get_sexp annot_sexp)\n ;;\nend\n\nlet load_sexp_conv ?(strict = true) ?(buf = Bytes.create 8192) file f =\n let sexp = load_sexp ~strict ~buf file in\n try `Result (f sexp) with\n | Of_sexp_error _ -> Annotated.conv f (Annotated.load_sexp ~strict ~buf file)\n;;\n\nlet raise_conv_exn ~file = function\n | `Result res -> res\n | `Error (exc, annot_sexp) -> raise (Annotated.get_conv_exn ~file ~exc annot_sexp)\n;;\n\nlet load_sexp_conv_exn ?strict ?buf file f =\n raise_conv_exn ~file (load_sexp_conv ?strict ?buf file f)\n;;\n\nlet load_sexps_conv ?(buf = Bytes.create 8192) file f =\n let rev_sexps = load_rev_sexps ~buf file in\n try List.rev_map (fun sexp -> `Result (f sexp)) rev_sexps with\n | Of_sexp_error _ as e ->\n (match Annotated.load_rev_sexps ~buf file with\n | [] ->\n (* File is now empty - perhaps it was a temporary file handle? *)\n raise e\n | rev_annot_sexps ->\n List.rev_map (fun annot_sexp -> Annotated.conv f annot_sexp) rev_annot_sexps)\n;;\n\nlet load_sexps_conv_exn ?(buf = Bytes.create 8192) file f =\n let rev_sexps = load_rev_sexps ~buf file in\n try List.rev_map f rev_sexps with\n | Of_sexp_error _ as e ->\n (match Annotated.load_rev_sexps ~buf file with\n | [] ->\n (* File is now empty - perhaps it was a temporary file handle? *)\n raise e\n | rev_annot_sexps ->\n List.rev_map\n (fun annot_sexp -> raise_conv_exn ~file (Annotated.conv f annot_sexp))\n rev_annot_sexps)\n;;\n\nlet gen_of_string_conv of_string annot_of_string str f =\n let sexp = of_string str in\n try `Result (f sexp) with\n | Of_sexp_error _ -> Annotated.conv f (annot_of_string str)\n;;\n\nlet of_string_conv str f = gen_of_string_conv of_string Annotated.of_string str f\n\nlet of_bigstring_conv bstr f =\n gen_of_string_conv of_bigstring Annotated.of_bigstring bstr f\n;;\n\nmodule Of_string_conv_exn = struct\n type t =\n { exc : exn\n ; sexp : Type.t\n ; sub_sexp : Type.t\n }\n\n exception E of t\n\n let () =\n Conv.Exn_converter.add ~finalise:false [%extension_constructor E] (function\n | E osce ->\n sexp_conversion_error_message\n ()\n ~invalid_sexp:osce.sub_sexp\n ~exn:osce.exc\n ~containing_sexp:osce.sexp\n | _ -> assert false)\n ;;\nend\n\nlet gen_of_string_conv_exn of_string str f =\n let sexp = of_string str in\n try f sexp with\n | Of_sexp_error (exc, sub_sexp) ->\n raise (Of_string_conv_exn.E { Of_string_conv_exn.exc; sexp; sub_sexp })\n;;\n\nlet of_string_conv_exn str f = gen_of_string_conv_exn of_string str f\nlet of_bigstring_conv_exn bstr f = gen_of_string_conv_exn of_bigstring bstr f\n\n(* Utilities for automated type conversions *)\n\nlet unit = List []\n\nlet is_unit = function\n | List [] -> true\n | _ -> false\n;;\n\nexternal sexp_of_t : t -> t = \"%identity\"\nexternal t_of_sexp : t -> t = \"%identity\"\n\n(* Utilities for conversion error handling *)\n\ntype found =\n [ `Found\n | `Pos of int * found\n ]\n\ntype search_result =\n [ `Not_found\n | found\n ]\n\nlet rec search_physical sexp ~contained =\n if sexp == contained\n then `Found\n else (\n match sexp with\n | Atom _ -> `Not_found\n | List lst ->\n let rec loop i = function\n | [] -> `Not_found\n | h :: t ->\n let res = search_physical h ~contained in\n (match res with\n | `Not_found -> loop (i + 1) t\n | #found as found -> `Pos (i, found))\n in\n loop 0 lst)\n;;\n\nlet rec subst_found sexp ~subst = function\n | `Found -> subst\n | `Pos (pos, found) ->\n (match sexp with\n | Atom _ -> failwith \"Sexplib.Sexp.subst_found: atom when position requested\"\n | List lst ->\n let rec loop acc pos = function\n | [] -> failwith \"Sexplib.Sexp.subst_found: short list when position requested\"\n | h :: t when pos <> 0 -> loop (h :: acc) (pos - 1) t\n | h :: t -> List (List.rev_append acc (subst_found h ~subst found :: t))\n in\n loop [] pos lst)\n;;\n","open! Import\n\ntype t =\n | Parsing_toplevel_whitespace\n | Parsing_nested_whitespace\n | Parsing_atom\n | Parsing_list\n | Parsing_sexp_comment\n | Parsing_block_comment\n[@@deriving_inline sexp_of]\n\nlet sexp_of_t =\n (function\n | Parsing_toplevel_whitespace ->\n Ppx_sexp_conv_lib.Sexp.Atom \"Parsing_toplevel_whitespace\"\n | Parsing_nested_whitespace -> Ppx_sexp_conv_lib.Sexp.Atom \"Parsing_nested_whitespace\"\n | Parsing_atom -> Ppx_sexp_conv_lib.Sexp.Atom \"Parsing_atom\"\n | Parsing_list -> Ppx_sexp_conv_lib.Sexp.Atom \"Parsing_list\"\n | Parsing_sexp_comment -> Ppx_sexp_conv_lib.Sexp.Atom \"Parsing_sexp_comment\"\n | Parsing_block_comment -> Ppx_sexp_conv_lib.Sexp.Atom \"Parsing_block_comment\"\n : t -> Ppx_sexp_conv_lib.Sexp.t)\n;;\n\n[@@@end]\n\nlet to_string t =\n match sexp_of_t t with\n | Atom s -> s\n | List _ -> failwith \"BUG: [sexp_of_t] returned a [List _]\"\n;;\n","open Printf\nopen Bigarray\ninclude Sexplib0.Sexp_conv\nopen Sexp\n\ntype bigstring = (char, int8_unsigned_elt, c_layout) Array1.t\ntype float32_vec = (float, float32_elt, fortran_layout) Array1.t\ntype float64_vec = (float, float64_elt, fortran_layout) Array1.t\ntype vec = float64_vec\ntype float32_mat = (float, float32_elt, fortran_layout) Array2.t\ntype float64_mat = (float, float64_elt, fortran_layout) Array2.t\ntype mat = float64_mat\n\nlet sexp_of_float_vec vec =\n let lst_ref = ref [] in\n for i = Array1.dim vec downto 1 do\n lst_ref := sexp_of_float vec.{i} :: !lst_ref\n done;\n List !lst_ref\n;;\n\nlet sexp_of_bigstring (bstr : bigstring) =\n let n = Array1.dim bstr in\n let str = Bytes.create n in\n for i = 0 to n - 1 do\n Bytes.set str i bstr.{i}\n done;\n Atom (Bytes.unsafe_to_string str)\n;;\n\nlet sexp_of_float32_vec (vec : float32_vec) = sexp_of_float_vec vec\nlet sexp_of_float64_vec (vec : float64_vec) = sexp_of_float_vec vec\nlet sexp_of_vec (vec : vec) = sexp_of_float_vec vec\n\nlet sexp_of_float_mat mat =\n let m = Array2.dim1 mat in\n let n = Array2.dim2 mat in\n let lst_ref = ref [] in\n (* It's surprising that we serialize [Fortran_layout] matrices in row-major order. I can\n only speculate that it was chosen for readability. The cache performance is\n irrelevant because people who care won't serialize to sexp. *)\n for row = n downto 1 do\n for col = m downto 1 do\n lst_ref := sexp_of_float mat.{col, row} :: !lst_ref\n done\n done;\n List (sexp_of_int m :: sexp_of_int n :: !lst_ref)\n;;\n\nlet sexp_of_float32_mat (mat : float32_mat) = sexp_of_float_mat mat\nlet sexp_of_float64_mat (mat : float64_mat) = sexp_of_float_mat mat\nlet sexp_of_mat (mat : mat) = sexp_of_float_mat mat\nlet bigstring_sexp_grammar : Sexplib0.Sexp.Private.Raw_grammar.t = Inline (Atom String)\n\nlet bigstring_of_sexp sexp =\n match sexp with\n | Atom str ->\n let len = String.length str in\n let bstr = Array1.create char c_layout len in\n for i = 0 to len - 1 do\n bstr.{i} <- str.[i]\n done;\n bstr\n | List _ -> of_sexp_error \"bigstring_of_sexp: atom needed\" sexp\n;;\n\nlet float_vec_of_sexp empty_float_vec create_float_vec sexp =\n match sexp with\n | List [] -> empty_float_vec\n | List lst ->\n let len = List.length lst in\n let res = create_float_vec len in\n let rec loop i = function\n | [] -> res\n | h :: t ->\n res.{i} <- float_of_sexp h;\n loop (i + 1) t\n in\n loop 1 lst\n | Atom _ -> of_sexp_error \"float_vec_of_sexp: list needed\" sexp\n;;\n\nlet create_float32_vec = Array1.create float32 fortran_layout\nlet create_float64_vec = Array1.create float64 fortran_layout\nlet empty_float32_vec = create_float32_vec 0\nlet empty_float64_vec = create_float64_vec 0\nlet float32_vec_of_sexp = float_vec_of_sexp empty_float32_vec create_float32_vec\nlet float64_vec_of_sexp = float_vec_of_sexp empty_float64_vec create_float64_vec\nlet vec_of_sexp = float_vec_of_sexp empty_float64_vec create_float64_vec\n\nlet vec_sexp_grammar : Sexplib0.Sexp.Private.Raw_grammar.t =\n Inline (List [ Many (Atom Float) ])\n;;\n\nlet float32_vec_sexp_grammar = vec_sexp_grammar\nlet float64_vec_sexp_grammar = vec_sexp_grammar\n\nlet check_too_much_data sexp data res =\n if data = [] then res else of_sexp_error \"float_mat_of_sexp: too much data\" sexp\n;;\n\nlet float_mat_of_sexp create_float_mat sexp =\n match sexp with\n | List (sm :: sn :: data) ->\n let m = int_of_sexp sm in\n let n = int_of_sexp sn in\n let res = create_float_mat m n in\n if m = 0 || n = 0\n then check_too_much_data sexp data res\n else (\n let rec loop_cols col data =\n let vec = Array2.slice_right res col in\n let rec loop_rows row = function\n | [] -> of_sexp_error \"float_mat_of_sexp: not enough data\" sexp\n | h :: t ->\n vec.{row} <- float_of_sexp h;\n if row = m\n then\n if col = n then check_too_much_data sexp t res else loop_cols (col + 1) t\n else loop_rows (row + 1) t\n in\n loop_rows 1 data\n in\n loop_cols 1 data)\n | List _ -> of_sexp_error \"float_mat_of_sexp: list too short\" sexp\n | Atom _ -> of_sexp_error \"float_mat_of_sexp: list needed\" sexp\n;;\n\nlet create_float32_mat = Array2.create float32 fortran_layout\nlet create_float64_mat = Array2.create float64 fortran_layout\nlet float32_mat_of_sexp = float_mat_of_sexp create_float32_mat\nlet float64_mat_of_sexp = float_mat_of_sexp create_float64_mat\nlet mat_of_sexp = float_mat_of_sexp create_float64_mat\n\nlet mat_sexp_grammar : Sexplib0.Sexp.Private.Raw_grammar.t =\n Inline (List [ One (Atom Int); One (Atom Int); Many (Atom Float) ])\n;;\n\nlet float32_mat_sexp_grammar = mat_sexp_grammar\nlet float64_mat_sexp_grammar = mat_sexp_grammar\nlet string_of__of__sexp_of to_sexp x = Sexp.to_string (to_sexp x)\n\nlet of_string__of__of_sexp of_sexp s =\n try\n let sexp = Sexp.of_string s in\n of_sexp sexp\n with\n | e ->\n failwith\n (sprintf \"of_string failed on %s with %s\" s (Sexp.to_string_hum (sexp_of_exn e)))\n;;\n","\n(* We do not [include Base] here, and instead import modules that [Core_kernel] doesn't\n extend, because we want code in [Core_kernel] to be clear when it references a [Base]\n module that [Core_kernel] is overriding. *)\nmodule Applicative = Base.Applicative\nmodule Avltree = Base.Avltree\nmodule Backtrace = Base.Backtrace\nmodule Binary_search = Base.Binary_search\nmodule Comparisons = Base.Comparisons\nmodule Continue_or_stop = Base.Continue_or_stop\nmodule Equal = Base.Equal\nmodule Exn = Base.Exn\nmodule Floatable = Base.Floatable\nmodule Formatter = Base.Formatter\nmodule Hash = Base.Hash\nmodule Hasher = Base.Hasher\nmodule Indexed_container = Base.Indexed_container\nmodule Intable = Base.Intable\nmodule Int_conversions = Base.Int_conversions\nmodule Int_math = Base.Int_math\nmodule Invariant = Base.Invariant\nmodule Monad = Base.Monad\nmodule Poly = Base.Poly\n\nmodule Popcount = Base.Popcount\n[@@warning \"-3\"]\n[@@deprecated \"[since 2018-10] use [popcount] functions in individual int modules\"]\n\nmodule Pretty_printer = Base.Pretty_printer\nmodule Random = Base.Random\nmodule Staged = Base.Staged\nmodule Stringable = Base.Stringable\nmodule Uchar = Base.Uchar\nmodule Validate = Base.Validate\nmodule With_return = Base.With_return\nmodule Word_size = Base.Word_size\n\n(* We do include [Base]'s top-level value and type bindings, because they don't cause\n any confusion, and duplicating them would be error prone. *)\ninclude Base.Export\ninclude Stdio\ninclude Base_for_tests\ninclude Bin_prot.Std\nmodule Field = Fieldslib.Field\n\nmodule From_sexplib : sig\n type bigstring = Sexplib.Conv.bigstring [@@deriving sexp]\n type mat = Sexplib.Conv.mat [@@deriving sexp]\n type vec = Sexplib.Conv.vec [@@deriving sexp]\n\n (* [sexp_of_opaque] and [opaque_of_sexp] are used by the code generated from\n [[@@deriving sexp]], [[%sexp_of: ]], and [[%of_sexp: ]]. The type [_ sexp_opaque]\n expands to uses of [sexp_of_opaque] and [opaque_of_sexp]. *)\n\n val sexp_of_opaque : _ -> Base.Sexp.t\n val opaque_of_sexp : Base.Sexp.t -> _\n val sexp_of_pair : ('a -> Base.Sexp.t) -> ('b -> Base.Sexp.t) -> 'a * 'b -> Base.Sexp.t\n val pair_of_sexp : (Base.Sexp.t -> 'a) -> (Base.Sexp.t -> 'b) -> Base.Sexp.t -> 'a * 'b\n\n exception Of_sexp_error of exn * Base.Sexp.t\n\n val of_sexp_error : string -> Base.Sexp.t -> _\n val of_sexp_error_exn : exn -> Base.Sexp.t -> _\nend =\n Sexplib.Conv\n\ninclude From_sexplib\n\n(* [sexp_opaque] indicates to [ppx_sexp_conv] that a value should be rendered as [_], i.e.\n [Sexp.Atom \"_\"]. Here we expose the [@@deriving] aspects of [sexp_opaque] so that\n other ppx's treat [sexp_opaque] correctly, by ignoring it and processing the underlying\n type. *)\ninclude (\nstruct\n type 'a sexp_opaque = 'a [@@deriving bin_io, compare, hash, typerep]\nend :\nsig\n type 'a sexp_opaque [@@deriving bin_io, compare, hash, typerep]\nend\nwith type 'a sexp_opaque := 'a)\n\ninclude (\n Typerep_lib.Std :\n module type of struct\n include Typerep_lib.Std\n end\n with module Type_equal := Typerep_lib.Std.Type_equal)\n\nmodule Variant = Variantslib.Variant\n\nlet with_return = With_return.with_return\nlet am_running_inline_test = Ppx_inline_test_lib.Runtime.am_running_inline_test\n\nlet am_running_test =\n try\n ignore (Caml.Sys.getenv \"TESTING_FRAMEWORK\" : string);\n true\n with\n (* [Caml.*] never raises [Not_found_s] *)\n | Caml.Not_found -> false\n;;\n\ntype 'a identity = 'a\n\nmodule Not_found = struct\n exception\n Not_found = Not_found\n [@deprecated\n {|[since 2018-02] Instead of raising [Not_found], consider using [raise_s] with an\ninformative error message. If code needs to distinguish [Not_found] from other\nexceptions, please change it to handle both [Not_found] and [Not_found_s]. Then, instead\nof raising [Not_found], raise [Not_found_s] with an informative error message.|}]\n\n exception Not_found_s = Base.Not_found_s\nend\n\ninclude Not_found\n","open! Import\ninclude Base.Sexpable\n\nmodule Stable = struct\n module Of_sexpable = struct\n module V1\n (Sexpable : S) (M : sig\n type t\n\n val to_sexpable : t -> Sexpable.t\n val of_sexpable : Sexpable.t -> t\n end) : S with type t := M.t = struct\n let t_of_sexp sexp =\n let s = Sexpable.t_of_sexp sexp in\n try M.of_sexpable s with\n | exn -> of_sexp_error_exn exn sexp\n ;;\n\n let sexp_of_t t = Sexpable.sexp_of_t (M.to_sexpable t)\n end\n end\n\n module Of_sexpable1 = struct\n module V1\n (Sexpable : S1) (M : sig\n type 'a t\n\n val to_sexpable : 'a t -> 'a Sexpable.t\n val of_sexpable : 'a Sexpable.t -> 'a t\n end) : S1 with type 'a t := 'a M.t = struct\n let t_of_sexp a_of_sexp sexp =\n let s = Sexpable.t_of_sexp a_of_sexp sexp in\n try M.of_sexpable s with\n | exn -> of_sexp_error_exn exn sexp\n ;;\n\n let sexp_of_t sexp_of_a t = Sexpable.sexp_of_t sexp_of_a (M.to_sexpable t)\n end\n end\n\n module Of_sexpable2 = struct\n module V1\n (Sexpable : S2) (M : sig\n type ('a, 'b) t\n\n val to_sexpable : ('a, 'b) t -> ('a, 'b) Sexpable.t\n val of_sexpable : ('a, 'b) Sexpable.t -> ('a, 'b) t\n end) : S2 with type ('a, 'b) t := ('a, 'b) M.t = struct\n let t_of_sexp a_of_sexp b_of_sexp sexp =\n let s = Sexpable.t_of_sexp a_of_sexp b_of_sexp sexp in\n try M.of_sexpable s with\n | exn -> of_sexp_error_exn exn sexp\n ;;\n\n let sexp_of_t sexp_of_a sexp_of_b t =\n Sexpable.sexp_of_t sexp_of_a sexp_of_b (M.to_sexpable t)\n ;;\n end\n end\n\n module Of_sexpable3 = struct\n module V1\n (Sexpable : S3) (M : sig\n type ('a, 'b, 'c) t\n\n val to_sexpable : ('a, 'b, 'c) t -> ('a, 'b, 'c) Sexpable.t\n val of_sexpable : ('a, 'b, 'c) Sexpable.t -> ('a, 'b, 'c) t\n end) : S3 with type ('a, 'b, 'c) t := ('a, 'b, 'c) M.t = struct\n let t_of_sexp a_of_sexp b_of_sexp c_of_sexp sexp =\n let s = Sexpable.t_of_sexp a_of_sexp b_of_sexp c_of_sexp sexp in\n try M.of_sexpable s with\n | exn -> of_sexp_error_exn exn sexp\n ;;\n\n let sexp_of_t sexp_of_a sexp_of_b sexp_of_c t =\n Sexpable.sexp_of_t sexp_of_a sexp_of_b sexp_of_c (M.to_sexpable t)\n ;;\n end\n end\n\n module Of_stringable = struct\n module V1 (M : Stringable.S) : S with type t := M.t = struct\n let t_of_sexp sexp =\n match sexp with\n | Sexplib.Sexp.Atom s ->\n (try M.of_string s with\n | exn -> of_sexp_error_exn exn sexp)\n | Sexplib.Sexp.List _ ->\n of_sexp_error\n \"Sexpable.Of_stringable.t_of_sexp expected an atom, but got a list\"\n sexp\n ;;\n\n let sexp_of_t t = Sexplib.Sexp.Atom (M.to_string t)\n end\n end\n\n module To_stringable = struct\n module V1 (M : S) : Stringable.S with type t := M.t = struct\n let of_string x = Sexplib.Conv.of_string__of__of_sexp M.t_of_sexp x\n let to_string x = Sexplib.Conv.string_of__of__sexp_of M.sexp_of_t x\n end\n end\nend\n\nmodule To_stringable = Stable.To_stringable.V1\n","open! Import\nopen Bin_prot.Binable\nopen Bigarray\n\nmodule type Conv_without_uuid = sig\n type binable\n type t\n\n val to_binable : t -> binable\n val of_binable : binable -> t\nend\n\nmodule type Conv1_without_uuid = sig\n type 'a binable\n type 'a t\n\n val to_binable : 'a t -> 'a binable\n val of_binable : 'a binable -> 'a t\nend\n\nmodule type Conv2_without_uuid = sig\n type ('a, 'b) binable\n type ('a, 'b) t\n\n val to_binable : ('a, 'b) t -> ('a, 'b) binable\n val of_binable : ('a, 'b) binable -> ('a, 'b) t\nend\n\nmodule type Conv3_without_uuid = sig\n type ('a, 'b, 'c) binable\n type ('a, 'b, 'c) t\n\n val to_binable : ('a, 'b, 'c) t -> ('a, 'b, 'c) binable\n val of_binable : ('a, 'b, 'c) binable -> ('a, 'b, 'c) t\nend\n\nmodule type Conv = sig\n include Conv_without_uuid\n\n val caller_identity : Bin_prot.Shape.Uuid.t\nend\n\nmodule type Conv1 = sig\n include Conv1_without_uuid\n\n val caller_identity : Bin_prot.Shape.Uuid.t\nend\n\nmodule type Conv2 = sig\n include Conv2_without_uuid\n\n val caller_identity : Bin_prot.Shape.Uuid.t\nend\n\nmodule type Conv3 = sig\n include Conv3_without_uuid\n\n val caller_identity : Bin_prot.Shape.Uuid.t\nend\n\nmodule type Conv_sexpable = sig\n include Sexpable.S\n\n val caller_identity : Bin_prot.Shape.Uuid.t\nend\n\nmodule type Conv_stringable = sig\n include Stringable.S\n\n val caller_identity : Bin_prot.Shape.Uuid.t\nend\n\n(** Module types and utilities for dealing with types that support the bin-io binary\n encoding. *)\nmodule type Binable = sig\n (** We copy the definition of the bigstring type here, because we cannot depend on\n bigstring.ml *)\n type bigstring = (char, int8_unsigned_elt, c_layout) Array1.t\n\n (** New code should use [@@deriving bin_io]. These module types ([S], [S1], and [S2])\n are exported only for backwards compatibility. *)\n module type S = S\n\n module type S_only_functions = S_only_functions\n module type S1 = S1\n module type S2 = S2\n module type S3 = S3\n\n module Minimal : sig\n module type S = Minimal.S\n module type S1 = Minimal.S1\n module type S2 = Minimal.S2\n module type S3 = Minimal.S3\n end\n\n module type Conv = Conv\n module type Conv1 = Conv1\n module type Conv2 = Conv2\n module type Conv3 = Conv3\n module type Conv_sexpable = Conv_sexpable\n module type Conv_stringable = Conv_stringable\n module type Conv_without_uuid = Conv_without_uuid\n module type Conv1_without_uuid = Conv1_without_uuid\n module type Conv2_without_uuid = Conv2_without_uuid\n module type Conv3_without_uuid = Conv3_without_uuid\n\n (** [Of_binable*] functors are for when you want the binary representation of one type\n to be the same as that for some other isomorphic type. *)\n\n module Of_binable_with_uuid\n (Binable : Minimal.S)\n (M : Conv with type binable := Binable.t) : S with type t := M.t\n\n module Of_binable1_with_uuid\n (Binable : Minimal.S1)\n (M : Conv1 with type 'a binable := 'a Binable.t) : S1 with type 'a t := 'a M.t\n\n module Of_binable2_with_uuid\n (Binable : Minimal.S2)\n (M : Conv2 with type ('a, 'b) binable := ('a, 'b) Binable.t) :\n S2 with type ('a, 'b) t := ('a, 'b) M.t\n\n module Of_binable3_with_uuid\n (Binable : Minimal.S3)\n (M : Conv3 with type ('a, 'b, 'c) binable := ('a, 'b, 'c) Binable.t) :\n S3 with type ('a, 'b, 'c) t := ('a, 'b, 'c) M.t\n\n module Of_binable_without_uuid\n (Binable : Minimal.S)\n (M : Conv_without_uuid with type binable := Binable.t) : S with type t := M.t\n [@@alert legacy \"Use [Of_binable_with_uuid] if possible.\"]\n\n module Of_binable1_without_uuid\n (Binable : Minimal.S1)\n (M : Conv1_without_uuid with type 'a binable := 'a Binable.t) :\n S1 with type 'a t := 'a M.t\n [@@alert legacy \"Use [Of_binable1_with_uuid] if possible.\"]\n\n module Of_binable2_without_uuid\n (Binable : Minimal.S2)\n (M : Conv2_without_uuid with type ('a, 'b) binable := ('a, 'b) Binable.t) :\n S2 with type ('a, 'b) t := ('a, 'b) M.t\n [@@alert legacy \"Use [Of_binable2_with_uuid] if possible.\"]\n\n module Of_binable3_without_uuid\n (Binable : Minimal.S3)\n (M : Conv3_without_uuid with type ('a, 'b, 'c) binable := ('a, 'b, 'c) Binable.t) :\n S3 with type ('a, 'b, 'c) t := ('a, 'b, 'c) M.t\n [@@alert legacy \"Use [Of_binable3_with_uuid] if possible.\"]\n\n module Of_binable = Of_binable_without_uuid\n [@@alert \"-legacy\"]\n [@@deprecated\n \"[since 2019-11] Use [Of_binable_with_uuid] if possible, otherwise use \\\n [Of_binable_without_uuid].\"]\n\n module Of_binable1 = Of_binable1_without_uuid\n [@@alert \"-legacy\"]\n [@@deprecated\n \"[since 2019-11] Use [Of_binable1_with_uuid] if possible, otherwise use \\\n [Of_binable1_without_uuid].\"]\n\n module Of_binable2 = Of_binable2_without_uuid\n [@@alert \"-legacy\"]\n [@@deprecated\n \"[since 2019-11] Use [Of_binable2_with_uuid] if possible, otherwise use \\\n [Of_binable2_without_uuid].\"]\n\n module Of_binable3 = Of_binable3_without_uuid\n [@@alert \"-legacy\"]\n [@@deprecated\n \"[since 2019-11] Use [Of_binable3_with_uuid] if possible, otherwise use \\\n [Of_binable3_without_uuid].\"]\n\n (** [Of_sexpable_with_uuid] serializes a value using the bin-io of the sexp\n serialization of the value. This is not as efficient as using [@@deriving bin_io].\n However, it is useful when performance isn't important and there are obstacles to\n using [@@deriving bin_io], e.g., some type missing [@@deriving bin_io].\n [Of_sexpable_with_uuid] is also useful when one wants to be forgiving about format\n changes, due to the sexp serialization being more robust to changes like adding or\n removing a constructor. *)\n\n module Of_sexpable_with_uuid (M : Conv_sexpable) : S with type t := M.t\n module Of_stringable_with_uuid (M : Conv_stringable) : S with type t := M.t\n\n module Of_sexpable_without_uuid (M : Sexpable.S) : S with type t := M.t\n [@@alert legacy \"Use [Of_sexpable_with_uuid] if possible.\"]\n\n module Of_stringable_without_uuid (M : Stringable.S) : S with type t := M.t\n [@@alert legacy \"Use [Of_stringable_with_uuid] if possible.\"]\n\n module Of_sexpable = Of_sexpable_without_uuid\n [@@alert \"-legacy\"]\n [@@deprecated\n \"[since 2019-11] Use [Of_sexpable_with_uuid] if possible, otherwise use \\\n [Of_sexpable_without_uuid].\"]\n\n module Of_stringable = Of_stringable_without_uuid\n [@@alert \"-legacy\"]\n [@@deprecated\n \"[since 2019-11] Use [Of_stringable_with_uuid] if possible, otherwise use \\\n [Of_stringable_without_uuid].\"]\n\n type 'a m = (module S with type t = 'a)\n\n val of_bigstring : 'a m -> bigstring -> 'a\n\n val to_bigstring\n : ?prefix_with_length:bool (** defaults to false *)\n -> 'a m\n -> 'a\n -> bigstring\n\n val of_string : 'a m -> string -> 'a\n val to_string : 'a m -> 'a -> string\n\n (** The following functors preserve stability: if applied to stable types with stable\n (de)serializations, they will produce stable types with stable (de)serializations.\n\n Note: In all cases, stability of the input (and therefore the output) depends on the\n semantics of all conversion functions (e.g. [to_string], [to_sexpable]) not changing\n in the future.\n *)\n\n module Stable : sig\n module Of_binable : sig\n module V1 : (module type of Of_binable_without_uuid) [@alert \"-legacy\"]\n [@@alert legacy \"Use [V2] instead.\"]\n\n module V2 : module type of Of_binable_with_uuid\n end\n\n module Of_binable1 : sig\n module V1 : (module type of Of_binable1_without_uuid) [@alert \"-legacy\"]\n [@@alert legacy \"Use [V2] instead.\"]\n\n module V2 : module type of Of_binable1_with_uuid\n end\n\n module Of_binable2 : sig\n module V1 : (module type of Of_binable2_without_uuid) [@alert \"-legacy\"]\n [@@alert legacy \"Use [V2] instead.\"]\n\n module V2 : module type of Of_binable2_with_uuid\n end\n\n module Of_binable3 : sig\n module V1 : (module type of Of_binable3_without_uuid) [@alert \"-legacy\"]\n [@@alert legacy \"Use [V2] instead.\"]\n\n module V2 : module type of Of_binable3_with_uuid\n end\n\n module Of_sexpable : sig\n module V1 : (module type of Of_sexpable_without_uuid) [@alert \"-legacy\"]\n [@@alert legacy \"Use [V2] instead.\"]\n\n module V2 : module type of Of_sexpable_with_uuid\n end\n\n module Of_stringable : sig\n module V1 : (module type of Of_stringable_without_uuid) [@alert \"-legacy\"]\n [@@alert legacy \"Use [V2] instead.\"]\n\n module V2 : module type of Of_stringable_with_uuid\n end\n end\nend\n","open! Import\nopen Binable_intf\ninclude Bin_prot.Binable\nmodule Shape = Bin_prot.Shape\nmodule List = Base.List\n\nmodule Stable = struct\n module Of_binable = struct\n module V1\n (Binable : Minimal.S)\n (M : Conv_without_uuid with type binable := Binable.t) : S with type t := M.t =\n Bin_prot.Utils.Make_binable_without_uuid (struct\n module Binable = Binable\n include M\n end)\n [@@alert \"-legacy\"]\n\n module V2 (Binable : Minimal.S) (M : Conv with type binable := Binable.t) :\n S with type t := M.t = Bin_prot.Utils.Make_binable_with_uuid (struct\n module Binable = Binable\n include M\n end)\n end\n\n module Of_binable1 = struct\n module V1\n (Binable : Minimal.S1)\n (M : Conv1_without_uuid with type 'a binable := 'a Binable.t) :\n S1 with type 'a t := 'a M.t = Bin_prot.Utils.Make_binable1_without_uuid (struct\n module Binable = Binable\n include M\n end)\n [@@alert \"-legacy\"]\n\n module V2 (Binable : Minimal.S1) (M : Conv1 with type 'a binable := 'a Binable.t) :\n S1 with type 'a t := 'a M.t = Bin_prot.Utils.Make_binable1_with_uuid (struct\n module Binable = Binable\n include M\n end)\n end\n\n module Of_binable2 = struct\n module V1\n (Binable : Minimal.S2)\n (M : Conv2_without_uuid with type ('a, 'b) binable := ('a, 'b) Binable.t) :\n S2 with type ('a, 'b) t := ('a, 'b) M.t =\n Bin_prot.Utils.Make_binable2_without_uuid (struct\n module Binable = Binable\n include M\n end)\n [@@alert \"-legacy\"]\n\n module V2\n (Binable : Minimal.S2)\n (M : Conv2 with type ('a, 'b) binable := ('a, 'b) Binable.t) :\n S2 with type ('a, 'b) t := ('a, 'b) M.t =\n Bin_prot.Utils.Make_binable2_with_uuid (struct\n module Binable = Binable\n include M\n end)\n end\n\n module Of_binable3 = struct\n module V1\n (Binable : Minimal.S3)\n (M : Conv3_without_uuid with type ('a, 'b, 'c) binable := ('a, 'b, 'c) Binable.t) :\n S3 with type ('a, 'b, 'c) t := ('a, 'b, 'c) M.t =\n Bin_prot.Utils.Make_binable3_without_uuid (struct\n module Binable = Binable\n include M\n end)\n [@@alert \"-legacy\"]\n\n module V2\n (Binable : Minimal.S3)\n (M : Conv3 with type ('a, 'b, 'c) binable := ('a, 'b, 'c) Binable.t) :\n S3 with type ('a, 'b, 'c) t := ('a, 'b, 'c) M.t =\n Bin_prot.Utils.Make_binable3_with_uuid (struct\n module Binable = Binable\n include M\n end)\n end\n\n module Of_sexpable = struct\n module V1 (M : Sexpable.S) =\n Of_binable.V1\n (struct\n type t = Base.Sexp.t =\n | Atom of string\n | List of t list\n [@@deriving bin_io]\n end)\n (struct\n type t = M.t\n\n let to_binable = M.sexp_of_t\n let of_binable = M.t_of_sexp\n end)\n\n module V2 (M : Conv_sexpable) =\n Of_binable.V2\n (struct\n type t = Base.Sexp.t =\n | Atom of string\n | List of t list\n [@@deriving bin_io]\n end)\n (struct\n type t = M.t\n\n let to_binable = M.sexp_of_t\n let of_binable = M.t_of_sexp\n let caller_identity = M.caller_identity\n end)\n end\n\n module Of_stringable = struct\n module V1 (M : Stringable.S) = Bin_prot.Utils.Make_binable_without_uuid (struct\n module Binable = struct\n type t = string [@@deriving bin_io]\n end\n\n type t = M.t\n\n let to_binable = M.to_string\n\n (* Wrap exception for improved diagnostics. *)\n exception Of_binable of string * exn [@@deriving sexp]\n\n let of_binable s =\n try M.of_string s with\n | x -> raise (Of_binable (s, x))\n ;;\n end)\n [@@alert \"-legacy\"]\n\n module V2 (M : Conv_stringable) = Bin_prot.Utils.Make_binable_with_uuid (struct\n module Binable = struct\n type t = string [@@deriving bin_io]\n end\n\n type t = M.t\n\n let to_binable = M.to_string\n\n (* Wrap exception for improved diagnostics. *)\n exception Of_binable of string * exn [@@deriving sexp]\n\n let of_binable s =\n try M.of_string s with\n | x -> raise (Of_binable (s, x))\n ;;\n\n let caller_identity = M.caller_identity\n end)\n end\nend\n\nopen Bigarray\n\ntype bigstring = (char, int8_unsigned_elt, c_layout) Array1.t\n\n\ntype 'a m = (module S with type t = 'a)\n\nlet of_bigstring (type a) m bigstring =\n let module M = (val m : S with type t = a) in\n let pos_ref = ref 0 in\n let t = M.bin_read_t bigstring ~pos_ref in\n assert (!pos_ref = Array1.dim bigstring);\n t\n;;\n\n(* Using the [Bigstring] module would introduce a cyclic dependency. *)\nlet create_bigstring size = Array1.create Bigarray.char Bigarray.c_layout size\n\nlet to_bigstring ?(prefix_with_length = false) (type a) m t =\n let module M = (val m : S with type t = a) in\n let t_length = M.bin_size_t t in\n let bigstring_length =\n if prefix_with_length then t_length + 8 (* the size of a 64-bit int *) else t_length\n in\n let bigstring = create_bigstring bigstring_length in\n let pos =\n if prefix_with_length\n then Bin_prot.Write.bin_write_int_64bit bigstring ~pos:0 t_length\n else 0\n in\n let pos = M.bin_write_t bigstring ~pos t in\n assert (pos = bigstring_length);\n bigstring\n;;\n\nmodule Of_binable_with_uuid = Stable.Of_binable.V2\nmodule Of_binable1_with_uuid = Stable.Of_binable1.V2\nmodule Of_binable2_with_uuid = Stable.Of_binable2.V2\nmodule Of_binable3_with_uuid = Stable.Of_binable3.V2\nmodule Of_sexpable_with_uuid = Stable.Of_sexpable.V2\nmodule Of_stringable_with_uuid = Stable.Of_stringable.V2\n\nmodule Of_binable_without_uuid = Stable.Of_binable.V1\n[@@alert legacy \"Use [Of_binable_with_uuid] if possible.\"]\n\nmodule Of_binable1_without_uuid = Stable.Of_binable1.V1\n[@@alert legacy \"Use [Of_binable1_with_uuid] if possible.\"]\n\nmodule Of_binable2_without_uuid = Stable.Of_binable2.V1\n[@@alert legacy \"Use [Of_binable2_with_uuid] if possible.\"]\n\nmodule Of_binable3_without_uuid = Stable.Of_binable3.V1\n[@@alert legacy \"Use [Of_binable3_with_uuid] if possible.\"]\n\nmodule Of_sexpable_without_uuid = Stable.Of_sexpable.V1\n[@@alert legacy \"Use [Of_sexpable_with_uuid] if possible.\"]\n\nmodule Of_stringable_without_uuid = Stable.Of_stringable.V1\n[@@alert legacy \"Use [Of_stringable_with_uuid] if possible.\"]\n\nmodule type S_only_functions_and_shape = sig\n include S_only_functions\n\n val bin_shape_t : Shape.t\nend\n\n(* check that only the functions & shape are sufficient for [@@deriving bin_io] *)\nmodule Of_only_functions_and_shape (X : S_only_functions_and_shape) : S = struct\n type t = X.t [@@deriving bin_io]\nend\n","(** This module extends {{!Base.Printf}[Base.Printf]}. *)\n\nopen! Import\n\ninclude Base.Printf (** @open *)\n\nlet eprintf = Stdio.Out_channel.eprintf\nlet fprintf = Stdio.Out_channel.fprintf\nlet kfprintf = Stdio.Out_channel.kfprintf\nlet printf = Stdio.Out_channel.printf\n\n\n(** print to stderr; exit 1 *)\nlet exitf fmt =\n ksprintf\n (fun s () ->\n eprintf \"%s\\n%!\" s;\n exit 1)\n fmt\n;;\n","open! Import\nmodule Comparator = Base.Comparator\n\ntype ('a, 'witness) t = ('a, 'witness) Comparator.t = private\n { compare : 'a -> 'a -> int\n ; sexp_of_t : 'a -> Base.Sexp.t\n }\n\nmodule type Base_mask = module type of Comparator with type ('a, 'b) t := ('a, 'b) t\n\ninclude (Comparator : Base_mask)\n\nmodule Stable = struct\n module V1 = struct\n type nonrec ('a, 'witness) t = ('a, 'witness) t = private\n { compare : 'a -> 'a -> int\n ; sexp_of_t : 'a -> Base.Sexp.t\n }\n\n type ('a, 'b) comparator = ('a, 'b) t\n\n module type S = S\n module type S1 = S1\n\n let make = make\n\n module Make = Make\n module Make1 = Make1\n end\nend\n","open! Import\nmodule Result = Base.Result\n\nmodule Stable = struct\n module V1 = struct\n type ('a, 'b) t = ('a, 'b) Result.t =\n | Ok of 'a\n | Error of 'b\n [@@deriving bin_io, compare, hash, sexp]\n\n let map x ~f1 ~f2 =\n match x with\n | Error err -> Error (f2 err)\n | Ok x -> Ok (f1 x)\n ;;\n end\n\n module V1_stable_unit_test = struct\n type t = (string, int) V1.t [@@deriving bin_io, compare, hash, sexp]\n\n let equal = [%compare.equal: t]\n\n let tests =\n [ V1.Ok \"foo\", \"(Ok foo)\", \"\\000\\003foo\"; V1.Error 7, \"(Error 7)\", \"\\001\\007\" ]\n ;;\n end\nend\n\ninclude Stable.V1\ninclude Result\n","include Base.Container\n\nmodule type S1_permissions = Container_intf.S1_permissions\n","let ( |! ) x y = x |> y\n","(** Extends {{!Base.Fn}[Base.Fn]}. *)\n\ninclude Base.Fn (** @open *)\n\ninclude Deprecate_pipe_bang\n","include Base.Ordered_collection_common\n\nlet normalize ~length_fun t i = if i < 0 then i + length_fun t else i\n\nlet slice ~length_fun ~sub_fun t start stop =\n let stop = if stop = 0 then length_fun t else stop in\n let pos = normalize ~length_fun t start in\n let len = normalize ~length_fun t stop - pos in\n sub_fun t ~pos ~len\n;;\n","open! Import\ninclude Base.Sequence\n\ninclude Bin_prot.Utils.Make_binable1_without_uuid [@alert \"-legacy\"] (struct\n module Binable = struct\n type 'a t = 'a list [@@deriving bin_io]\n end\n\n type 'a t = 'a Base.Sequence.t\n\n let of_binable = Base.Sequence.of_list\n let to_binable = Base.Sequence.to_list\n end)\n\nmodule Step = struct\n include Step\n\n type ('a, 's) t = ('a, 's) Step.t =\n | Done\n | Skip of 's\n | Yield of 'a * 's\n [@@deriving bin_io]\nend\n\nmodule Merge_with_duplicates_element = struct\n include Merge_with_duplicates_element\n\n type ('a, 'b) t = ('a, 'b) Merge_with_duplicates_element.t =\n | Left of 'a\n | Right of 'b\n | Both of 'a * 'b\n [@@deriving bin_io]\nend\n\nmodule type Heap = sig\n type 'a t\n\n val create : compare:('a -> 'a -> int) -> 'a t\n val add : 'a t -> 'a -> 'a t\n val remove_min : 'a t -> ('a * 'a t) option\nend\n\nlet merge_all (module Heap : Heap) seqs ~compare =\n let module Merge_all_state = struct\n type 'a t =\n { heap : ('a * 'a Base.Sequence.t) Heap.t\n ; not_yet_in_heap : 'a Base.Sequence.t list\n }\n [@@deriving fields]\n\n let create = Fields.create\n end\n in\n unfold_step\n ~init:\n (Merge_all_state.create\n ~heap:(Heap.create ~compare:(Base.Comparable.lift compare ~f:fst))\n ~not_yet_in_heap:seqs)\n ~f:(fun { heap; not_yet_in_heap } ->\n match not_yet_in_heap with\n | seq :: not_yet_in_heap ->\n (match Expert.next_step seq with\n | Done -> Skip { not_yet_in_heap; heap }\n | Skip seq -> Skip { not_yet_in_heap = seq :: not_yet_in_heap; heap }\n | Yield (elt, seq) -> Skip { not_yet_in_heap; heap = Heap.add heap (elt, seq) })\n | [] ->\n (match Heap.remove_min heap with\n | None -> Done\n | Some ((elt, seq), heap) -> Yield (elt, { heap; not_yet_in_heap = [ seq ] })))\n;;\n","open! Import\nopen Perms.Export\nmodule Array = Base.Array\nmodule Core_sequence = Sequence\n\ninclude (\n Base.Array :\n sig\n type 'a t = 'a array [@@deriving sexp, compare, sexp_grammar]\n end)\n\ntype 'a t = 'a array [@@deriving bin_io, typerep]\n\nmodule Private = Base.Array.Private\n\nmodule T = struct\n include Base.Array\n\n let normalize t i = Ordered_collection_common.normalize ~length_fun:length t i\n\n let slice t start stop =\n Ordered_collection_common.slice ~length_fun:length ~sub_fun:sub t start stop\n ;;\n\n let nget t i = t.(normalize t i)\n let nset t i v = t.(normalize t i) <- v\n\n module Sequence = struct\n open Base.Array\n\n let length = length\n let get = get\n let set = set\n end\n\n (* See OCaml perf notes for why these array blits are special cased -- in particular,\n the section entitled \"Fast, Slow and Incorrect Array blits\" of\n https://janestreet.github.io/ocaml-perf-notes.html *)\n module Int = struct\n type t_ = int array [@@deriving bin_io, compare, sexp]\n\n module Unsafe_blit = struct\n external unsafe_blit\n : src:t_\n -> src_pos:int\n -> dst:t_\n -> dst_pos:int\n -> len:int\n -> unit\n = \"core_array_unsafe_int_blit\"\n [@@noalloc]\n end\n\n include Test_blit.Make_and_test\n (struct\n type t = int\n\n let equal = ( = )\n let of_bool b = if b then 1 else 0\n end)\n (struct\n type t = t_ [@@deriving sexp_of]\n\n include Sequence\n\n let create ~len = create ~len 0\n\n include Unsafe_blit\n end)\n\n include Unsafe_blit\n end\n\n module Float = struct\n type t_ = float array [@@deriving bin_io, compare, sexp]\n\n module Unsafe_blit = struct\n external unsafe_blit\n : src:t_\n -> src_pos:int\n -> dst:t_\n -> dst_pos:int\n -> len:int\n -> unit\n = \"core_array_unsafe_float_blit\"\n [@@noalloc]\n end\n\n include Test_blit.Make_and_test\n (struct\n type t = float\n\n let equal = Base.Float.equal\n let of_bool b = if b then 1. else 0.\n end)\n (struct\n type t = t_ [@@deriving sexp_of]\n\n include Sequence\n\n let create ~len = create ~len 0.\n\n include Unsafe_blit\n end)\n\n include Unsafe_blit\n end\nend\n\nmodule type Permissioned = sig\n type ('a, -'perms) t\n\n include Container.S1_permissions with type ('a, 'perms) t := ('a, 'perms) t\n include Blit.S1_permissions with type ('a, 'perms) t := ('a, 'perms) t\n include Binary_searchable.S1_permissions with type ('a, 'perms) t := ('a, 'perms) t\n\n val length : (_, _) t -> int\n val is_empty : (_, _) t -> bool\n external get : ('a, [> read ]) t -> int -> 'a = \"%array_safe_get\"\n external set : ('a, [> write ]) t -> int -> 'a -> unit = \"%array_safe_set\"\n external unsafe_get : ('a, [> read ]) t -> int -> 'a = \"%array_unsafe_get\"\n external unsafe_set : ('a, [> write ]) t -> int -> 'a -> unit = \"%array_unsafe_set\"\n val create : len:int -> 'a -> ('a, [< _ perms ]) t\n val init : int -> f:(int -> 'a) -> ('a, [< _ perms ]) t\n val make_matrix : dimx:int -> dimy:int -> 'a -> (('a, [< _ perms ]) t, [< _ perms ]) t\n val append : ('a, [> read ]) t -> ('a, [> read ]) t -> ('a, [< _ perms ]) t\n val concat : ('a, [> read ]) t list -> ('a, [< _ perms ]) t\n val copy : ('a, [> read ]) t -> ('a, [< _ perms ]) t\n val fill : ('a, [> write ]) t -> pos:int -> len:int -> 'a -> unit\n val of_list : 'a list -> ('a, [< _ perms ]) t\n val map : ('a, [> read ]) t -> f:('a -> 'b) -> ('b, [< _ perms ]) t\n\n val folding_map\n : ('a, [> read ]) t\n -> init:'b\n -> f:('b -> 'a -> 'b * 'c)\n -> ('c, [< _ perms ]) t\n\n val fold_map\n : ('a, [> read ]) t\n -> init:'b\n -> f:('b -> 'a -> 'b * 'c)\n -> 'b * ('c, [< _ perms ]) t\n\n val mapi : ('a, [> read ]) t -> f:(int -> 'a -> 'b) -> ('b, [< _ perms ]) t\n val iteri : ('a, [> read ]) t -> f:(int -> 'a -> unit) -> unit\n val foldi : ('a, [> read ]) t -> init:'b -> f:(int -> 'b -> 'a -> 'b) -> 'b\n\n val folding_mapi\n : ('a, [> read ]) t\n -> init:'b\n -> f:(int -> 'b -> 'a -> 'b * 'c)\n -> ('c, [< _ perms ]) t\n\n val fold_mapi\n : ('a, [> read ]) t\n -> init:'b\n -> f:(int -> 'b -> 'a -> 'b * 'c)\n -> 'b * ('c, [< _ perms ]) t\n\n val fold_right : ('a, [> read ]) t -> f:('a -> 'b -> 'b) -> init:'b -> 'b\n\n val sort\n : ?pos:int\n -> ?len:int\n -> ('a, [> read_write ]) t\n -> compare:('a -> 'a -> int)\n -> unit\n\n val stable_sort : ('a, [> read_write ]) t -> compare:('a -> 'a -> int) -> unit\n val is_sorted : ('a, [> read ]) t -> compare:('a -> 'a -> int) -> bool\n val is_sorted_strictly : ('a, [> read ]) t -> compare:('a -> 'a -> int) -> bool\n\n val concat_map\n : ('a, [> read ]) t\n -> f:('a -> ('b, [> read ]) t)\n -> ('b, [< _ perms ]) t\n\n val concat_mapi\n : ('a, [> read ]) t\n -> f:(int -> 'a -> ('b, [> read ]) t)\n -> ('b, [< _ perms ]) t\n\n val partition_tf\n : ('a, [> read ]) t\n -> f:('a -> bool)\n -> ('a, [< _ perms ]) t * ('a, [< _ perms ]) t\n\n val partitioni_tf\n : ('a, [> read ]) t\n -> f:(int -> 'a -> bool)\n -> ('a, [< _ perms ]) t * ('a, [< _ perms ]) t\n\n val cartesian_product\n : ('a, [> read ]) t\n -> ('b, [> read ]) t\n -> ('a * 'b, [< _ perms ]) t\n\n val transpose\n : (('a, [> read ]) t, [> read ]) t\n -> (('a, [< _ perms ]) t, [< _ perms ]) t option\n\n val transpose_exn\n : (('a, [> read ]) t, [> read ]) t\n -> (('a, [< _ perms ]) t, [< _ perms ]) t\n\n val normalize : ('a, _) t -> int -> int\n val slice : ('a, [> read ]) t -> int -> int -> ('a, [< _ perms ]) t\n val nget : ('a, [> read ]) t -> int -> 'a\n val nset : ('a, [> write ]) t -> int -> 'a -> unit\n val filter_opt : ('a option, [> read ]) t -> ('a, [< _ perms ]) t\n val filter_map : ('a, [> read ]) t -> f:('a -> 'b option) -> ('b, [< _ perms ]) t\n\n val filter_mapi\n : ('a, [> read ]) t\n -> f:(int -> 'a -> 'b option)\n -> ('b, [< _ perms ]) t\n\n val for_alli : ('a, [> read ]) t -> f:(int -> 'a -> bool) -> bool\n val existsi : ('a, [> read ]) t -> f:(int -> 'a -> bool) -> bool\n val counti : ('a, [> read ]) t -> f:(int -> 'a -> bool) -> int\n val iter2_exn : ('a, [> read ]) t -> ('b, [> read ]) t -> f:('a -> 'b -> unit) -> unit\n\n val map2_exn\n : ('a, [> read ]) t\n -> ('b, [> read ]) t\n -> f:('a -> 'b -> 'c)\n -> ('c, [< _ perms ]) t\n\n val fold2_exn\n : ('a, [> read ]) t\n -> ('b, [> read ]) t\n -> init:'c\n -> f:('c -> 'a -> 'b -> 'c)\n -> 'c\n\n val for_all2_exn\n : ('a, [> read ]) t\n -> ('b, [> read ]) t\n -> f:('a -> 'b -> bool)\n -> bool\n\n val exists2_exn\n : ('a, [> read ]) t\n -> ('b, [> read ]) t\n -> f:('a -> 'b -> bool)\n -> bool\n\n val filter : ('a, [> read ]) t -> f:('a -> bool) -> ('a, [< _ perms ]) t\n val filteri : ('a, [> read ]) t -> f:(int -> 'a -> bool) -> ('a, [< _ perms ]) t\n val swap : ('a, [> read_write ]) t -> int -> int -> unit\n val rev_inplace : ('a, [> read_write ]) t -> unit\n val of_list_rev : 'a list -> ('a, [< _ perms ]) t\n val of_list_map : 'a list -> f:('a -> 'b) -> ('b, [< _ perms ]) t\n val of_list_mapi : 'a list -> f:(int -> 'a -> 'b) -> ('b, [< _ perms ]) t\n val of_list_rev_map : 'a list -> f:('a -> 'b) -> ('b, [< _ perms ]) t\n val of_list_rev_mapi : 'a list -> f:(int -> 'a -> 'b) -> ('b, [< _ perms ]) t\n val map_inplace : ('a, [> read_write ]) t -> f:('a -> 'a) -> unit\n val find_exn : ('a, [> read ]) t -> f:('a -> bool) -> 'a\n val find_map_exn : ('a, [> read ]) t -> f:('a -> 'b option) -> 'b\n val findi : ('a, [> read ]) t -> f:(int -> 'a -> bool) -> (int * 'a) option\n val findi_exn : ('a, [> read ]) t -> f:(int -> 'a -> bool) -> int * 'a\n val find_mapi : ('a, [> read ]) t -> f:(int -> 'a -> 'b option) -> 'b option\n val find_mapi_exn : ('a, [> read ]) t -> f:(int -> 'a -> 'b option) -> 'b\n\n val find_consecutive_duplicate\n : ('a, [> read ]) t\n -> equal:('a -> 'a -> bool)\n -> ('a * 'a) option\n\n val reduce : ('a, [> read ]) t -> f:('a -> 'a -> 'a) -> 'a option\n val reduce_exn : ('a, [> read ]) t -> f:('a -> 'a -> 'a) -> 'a\n val permute : ?random_state:Random.State.t -> ('a, [> read_write ]) t -> unit\n val random_element : ?random_state:Random.State.t -> ('a, [> read ]) t -> 'a option\n val random_element_exn : ?random_state:Random.State.t -> ('a, [> read ]) t -> 'a\n val zip : ('a, [> read ]) t -> ('b, [> read ]) t -> ('a * 'b, [< _ perms ]) t option\n val zip_exn : ('a, [> read ]) t -> ('b, [> read ]) t -> ('a * 'b, [< _ perms ]) t\n val unzip : ('a * 'b, [> read ]) t -> ('a, [< _ perms ]) t * ('b, [< _ perms ]) t\n\n val sorted_copy\n : ('a, [> read ]) t\n -> compare:('a -> 'a -> int)\n -> ('a, [< _ perms ]) t\n\n val last : ('a, [> read ]) t -> 'a\n val equal : ('a -> 'a -> bool) -> ('a, [> read ]) t -> ('a, [> read ]) t -> bool\n val to_sequence : ('a, [> read ]) t -> 'a Sequence.t\n val to_sequence_mutable : ('a, [> read ]) t -> 'a Sequence.t\nend\n\nmodule Permissioned : sig\n type ('a, -'perms) t [@@deriving bin_io, compare, sexp]\n\n module Int : sig\n type nonrec -'perms t = (int, 'perms) t [@@deriving bin_io, compare, sexp]\n\n include Blit.S_permissions with type 'perms t := 'perms t\n\n external unsafe_blit\n : src:[> read ] t\n -> src_pos:int\n -> dst:[> write ] t\n -> dst_pos:int\n -> len:int\n -> unit\n = \"core_array_unsafe_int_blit\"\n [@@noalloc]\n end\n\n module Float : sig\n type nonrec -'perms t = (float, 'perms) t [@@deriving bin_io, compare, sexp]\n\n include Blit.S_permissions with type 'perms t := 'perms t\n\n external unsafe_blit\n : src:[> read ] t\n -> src_pos:int\n -> dst:[> write ] t\n -> dst_pos:int\n -> len:int\n -> unit\n = \"core_array_unsafe_float_blit\"\n [@@noalloc]\n end\n\n val of_array_id : 'a array -> ('a, [< read_write ]) t\n val to_array_id : ('a, [> read_write ]) t -> 'a array\n val to_sequence_immutable : ('a, [> immutable ]) t -> 'a Sequence.t\n\n include Permissioned with type ('a, 'perms) t := ('a, 'perms) t\nend = struct\n type ('a, -'perms) t = 'a array [@@deriving bin_io, compare, sexp, typerep]\n\n module Int = struct\n include T.Int\n\n type -'perms t = t_ [@@deriving bin_io, compare, sexp]\n end\n\n module Float = struct\n include T.Float\n\n type -'perms t = t_ [@@deriving bin_io, compare, sexp]\n end\n\n let to_array_id = Fn.id\n let of_array_id = Fn.id\n\n include (T : Permissioned with type ('a, 'b) t := ('a, 'b) t) [@ocaml.warning \"-3\"]\n\n let to_array = copy\n let to_sequence_immutable = to_sequence_mutable\nend\n\nmodule type S = sig\n type 'a t\n\n include Binary_searchable.S1 with type 'a t := 'a t\n include Container.S1 with type 'a t := 'a t\n\n external get : 'a t -> int -> 'a = \"%array_safe_get\"\n external set : 'a t -> int -> 'a -> unit = \"%array_safe_set\"\n external unsafe_get : 'a t -> int -> 'a = \"%array_unsafe_get\"\n external unsafe_set : 'a t -> int -> 'a -> unit = \"%array_unsafe_set\"\n val create : len:int -> 'a -> 'a t\n val init : int -> f:(int -> 'a) -> 'a t\n val make_matrix : dimx:int -> dimy:int -> 'a -> 'a t t\n val append : 'a t -> 'a t -> 'a t\n val concat : 'a t list -> 'a t\n val copy : 'a t -> 'a t\n val fill : 'a t -> pos:int -> len:int -> 'a -> unit\n\n include Blit.S1 with type 'a t := 'a t\n\n val of_list : 'a list -> 'a t\n val map : 'a t -> f:('a -> 'b) -> 'b t\n val folding_map : 'a t -> init:'b -> f:('b -> 'a -> 'b * 'c) -> 'c t\n val fold_map : 'a t -> init:'b -> f:('b -> 'a -> 'b * 'c) -> 'b * 'c t\n val mapi : 'a t -> f:(int -> 'a -> 'b) -> 'b t\n val iteri : 'a t -> f:(int -> 'a -> unit) -> unit\n val foldi : 'a t -> init:'b -> f:(int -> 'b -> 'a -> 'b) -> 'b\n val folding_mapi : 'a t -> init:'b -> f:(int -> 'b -> 'a -> 'b * 'c) -> 'c t\n val fold_mapi : 'a t -> init:'b -> f:(int -> 'b -> 'a -> 'b * 'c) -> 'b * 'c t\n val fold_right : 'a t -> f:('a -> 'b -> 'b) -> init:'b -> 'b\n val sort : ?pos:int -> ?len:int -> 'a t -> compare:('a -> 'a -> int) -> unit\n val stable_sort : 'a t -> compare:('a -> 'a -> int) -> unit\n val is_sorted : 'a t -> compare:('a -> 'a -> int) -> bool\n val is_sorted_strictly : 'a t -> compare:('a -> 'a -> int) -> bool\n val concat_map : 'a t -> f:('a -> 'b t) -> 'b t\n val concat_mapi : 'a t -> f:(int -> 'a -> 'b t) -> 'b t\n val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t\n val partitioni_tf : 'a t -> f:(int -> 'a -> bool) -> 'a t * 'a t\n val cartesian_product : 'a t -> 'b t -> ('a * 'b) t\n val transpose : 'a t t -> 'a t t option\n val transpose_exn : 'a t t -> 'a t t\n val normalize : 'a t -> int -> int\n val slice : 'a t -> int -> int -> 'a t\n val nget : 'a t -> int -> 'a\n val nset : 'a t -> int -> 'a -> unit\n val filter_opt : 'a option t -> 'a t\n val filter_map : 'a t -> f:('a -> 'b option) -> 'b t\n val filter_mapi : 'a t -> f:(int -> 'a -> 'b option) -> 'b t\n val for_alli : 'a t -> f:(int -> 'a -> bool) -> bool\n val existsi : 'a t -> f:(int -> 'a -> bool) -> bool\n val counti : 'a t -> f:(int -> 'a -> bool) -> int\n val iter2_exn : 'a t -> 'b t -> f:('a -> 'b -> unit) -> unit\n val map2_exn : 'a t -> 'b t -> f:('a -> 'b -> 'c) -> 'c t\n val fold2_exn : 'a t -> 'b t -> init:'c -> f:('c -> 'a -> 'b -> 'c) -> 'c\n val for_all2_exn : 'a t -> 'b t -> f:('a -> 'b -> bool) -> bool\n val exists2_exn : 'a t -> 'b t -> f:('a -> 'b -> bool) -> bool\n val filter : 'a t -> f:('a -> bool) -> 'a t\n val filteri : 'a t -> f:(int -> 'a -> bool) -> 'a t\n val swap : 'a t -> int -> int -> unit\n val rev_inplace : 'a t -> unit\n val of_list_rev : 'a list -> 'a t\n val of_list_map : 'a list -> f:('a -> 'b) -> 'b t\n val of_list_mapi : 'a list -> f:(int -> 'a -> 'b) -> 'b t\n val of_list_rev_map : 'a list -> f:('a -> 'b) -> 'b t\n val of_list_rev_mapi : 'a list -> f:(int -> 'a -> 'b) -> 'b t\n val map_inplace : 'a t -> f:('a -> 'a) -> unit\n val find_exn : 'a t -> f:('a -> bool) -> 'a\n val find_map_exn : 'a t -> f:('a -> 'b option) -> 'b\n val findi : 'a t -> f:(int -> 'a -> bool) -> (int * 'a) option\n val findi_exn : 'a t -> f:(int -> 'a -> bool) -> int * 'a\n val find_mapi : 'a t -> f:(int -> 'a -> 'b option) -> 'b option\n val find_mapi_exn : 'a t -> f:(int -> 'a -> 'b option) -> 'b\n val find_consecutive_duplicate : 'a t -> equal:('a -> 'a -> bool) -> ('a * 'a) option\n val reduce : 'a t -> f:('a -> 'a -> 'a) -> 'a option\n val reduce_exn : 'a t -> f:('a -> 'a -> 'a) -> 'a\n val permute : ?random_state:Random.State.t -> 'a t -> unit\n val random_element : ?random_state:Random.State.t -> 'a t -> 'a option\n val random_element_exn : ?random_state:Random.State.t -> 'a t -> 'a\n val zip : 'a t -> 'b t -> ('a * 'b) t option\n val zip_exn : 'a t -> 'b t -> ('a * 'b) t\n val unzip : ('a * 'b) t -> 'a t * 'b t\n val sorted_copy : 'a t -> compare:('a -> 'a -> int) -> 'a t\n val last : 'a t -> 'a\n val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool\n val to_sequence : 'a t -> 'a Core_sequence.t\n val to_sequence_mutable : 'a t -> 'a Core_sequence.t\nend\n\ninclude (T : S with type 'a t := 'a array) [@ocaml.warning \"-3\"]\n\nlet invariant invariant_a t = iter t ~f:invariant_a\nlet max_length = Sys.max_array_length\n\nmodule Int = struct\n include T.Int\n\n type t = t_ [@@deriving bin_io, compare, sexp]\nend\n\nmodule Float = struct\n include T.Float\n\n type t = t_ [@@deriving bin_io, compare, sexp]\nend\n\nmodule Check1 (M : S) : sig\n type ('a, -'perm) t_\n\n include Permissioned with type ('a, 'perm) t := ('a, 'perm) t_\nend = struct\n include M\n\n type ('a, -'perm) t_ = 'a t\nend\n\nmodule Check2 (M : Permissioned) : sig\n type 'a t_\n\n include S with type 'a t := 'a t_\nend = struct\n include M\n\n type 'a t_ = ('a, read_write) t\nend\n","open! Import\n\nmodule Stable = struct\n module V1 = struct\n include Base.Source_code_position\n\n type t = Base.Source_code_position.t =\n { pos_fname : string\n ; pos_lnum : int\n ; pos_bol : int\n ; pos_cnum : int\n }\n [@@deriving bin_io, compare, hash, sexp]\n end\nend\n\ninclude Stable.V1\n\nlet to_string = Base.Source_code_position.to_string\nlet sexp_of_t = Base.Source_code_position.sexp_of_t\n","(* This module is trying to minimize dependencies on modules in Core, so as to allow\n [Info], [Error], and [Or_error] to be used in is many places places as possible.\n Please avoid adding new dependencies. *)\n\nopen! Import\nopen! Info_intf\n\nmodule type S = Base.Info.S\n\nmodule Source_code_position = Source_code_position0\nmodule Binable = Binable0\n\nmodule Sexp = struct\n include Sexplib.Sexp\n\n include (\n struct\n type t = Base.Sexp.t =\n | Atom of string\n | List of t list\n [@@deriving bin_io, compare, hash]\n end :\n sig\n type t [@@deriving bin_io, compare, hash]\n end\n with type t := t)\nend\n\nmodule Binable_exn = struct\n module Stable = struct\n module V1 = struct\n module T = struct\n type t = exn [@@deriving sexp_of]\n end\n\n include T\n\n include Binable.Stable.Of_binable.V1 [@alert \"-legacy\"]\n (Sexp)\n (struct\n include T\n\n let to_binable t = t |> [%sexp_of: t]\n let of_binable = Exn.create_s\n end)\n end\n end\nend\n\nmodule Extend (Info : Base.Info.S) = struct\n include Info\n\n module Internal_repr = struct\n module Stable = struct\n module Binable_exn = Binable_exn.Stable\n\n module Source_code_position = struct\n module V1 = struct\n type t = Source_code_position.Stable.V1.t [@@deriving bin_io]\n\n (* [sexp_of_t] as defined here is unstable; this is OK because there is no\n [t_of_sexp]. [sexp_of_t] is only used to produce a sexp that is never\n deserialized as a [Source_code_position]. *)\n let sexp_of_t = Source_code_position.sexp_of_t\n end\n end\n\n module V2 = struct\n type t = Info.Internal_repr.t =\n | Could_not_construct of Sexp.t\n | String of string\n | Exn of Binable_exn.V1.t\n | Sexp of Sexp.t\n | Tag_sexp of string * Sexp.t * Source_code_position.V1.t option\n | Tag_t of string * t\n | Tag_arg of string * Sexp.t * t\n | Of_list of int option * t list\n | With_backtrace of t * string (* backtrace *)\n [@@deriving bin_io, sexp_of]\n end\n end\n\n include Stable.V2\n\n let to_info = Info.Internal_repr.to_info\n let of_info = Info.Internal_repr.of_info\n end\n\n module Stable = struct\n module V2 = struct\n module T = struct\n type t = Info.t [@@deriving sexp, compare, hash]\n end\n\n include T\n include Comparator.Stable.V1.Make (T)\n\n include Binable.Stable.Of_binable.V1 [@alert \"-legacy\"]\n (Internal_repr.Stable.V2)\n (struct\n type nonrec t = t\n\n let to_binable = Info.Internal_repr.of_info\n let of_binable = Info.Internal_repr.to_info\n end)\n end\n\n module V1 = struct\n module T = struct\n type t = Info.t [@@deriving compare]\n\n include Sexpable.Stable.Of_sexpable.V1\n (Sexp)\n (struct\n type nonrec t = t\n\n let to_sexpable = Info.sexp_of_t\n let of_sexpable = Info.t_of_sexp\n end)\n\n let compare = compare\n end\n\n include T\n include Comparator.Stable.V1.Make (T)\n\n include Binable.Stable.Of_binable.V1 [@alert \"-legacy\"]\n (Sexp)\n (struct\n type nonrec t = t\n\n let to_binable = sexp_of_t\n let of_binable = t_of_sexp\n end)\n end\n end\n\n type t = Stable.V2.t [@@deriving bin_io]\nend\n\ninclude Extend (Base.Info)\n\n","include Base.Error\ninclude Info.Extend (Base.Error)\n\nlet failwiths ?strict ~here message a sexp_of_a =\n raise (create ?strict ~here message a sexp_of_a)\n;;\n\nlet failwithp ?strict here message a sexp_of_a =\n raise (create ?strict ~here message a sexp_of_a)\n;;\n","(** Derived from [Base.T]. Used for matching bare signatures with just a type. *)\n\nopen! Import\ninclude Base.T\n\nmodule type T_bin = sig\n type t [@@deriving bin_io]\nend\n","open! Import\nopen! Typerep_lib.Std\nmodule Array = Base.Array\ninclude Base.List\n\ntype 'a t = 'a list [@@deriving bin_io, typerep]\n\nmodule Assoc = struct\n include Assoc\n\n type ('a, 'b) t = ('a * 'b) list [@@deriving bin_io]\n\n let[@deprecated\n \"[since 2016-06] This does not respect the equivalence class promised by \\\n List.Assoc. Use List.compare directly if that's what you want.\"] compare\n (type a b)\n compare_a\n compare_b\n =\n [%compare: (a * b) list]\n ;;\nend\n\nlet to_string ~f t =\n Sexplib.Sexp.to_string (sexp_of_t (fun x -> Sexplib.Sexp.Atom x) (map t ~f))\n;;\n\ninclude Comparator.Derived (struct\n type nonrec 'a t = 'a t [@@deriving sexp_of, compare]\n end)\n\nlet quickcheck_generator = Base_quickcheck.Generator.list\nlet gen_non_empty = Base_quickcheck.Generator.list_non_empty\n\nlet gen_with_length length quickcheck_generator =\n Base_quickcheck.Generator.list_with_length quickcheck_generator ~length\n;;\n\nlet gen_filtered = Base_quickcheck.Generator.list_filtered\nlet gen_permutations = Base_quickcheck.Generator.list_permutations\nlet quickcheck_observer = Base_quickcheck.Observer.list\nlet quickcheck_shrinker = Base_quickcheck.Shrinker.list\n","open! Import\nopen Hashtbl_intf\nmodule Avltree = Avltree\nmodule Binable = Binable0\nmodule Hashable = Hashtbl_intf.Hashable\nmodule Merge_into_action = Hashtbl_intf.Merge_into_action\nmodule List = List0\n\nlet failwiths = Error.failwiths\n\nmodule Creators = Hashtbl.Creators\n\ninclude (\n Hashtbl :\n sig\n type ('a, 'b) t = ('a, 'b) Hashtbl.t [@@deriving sexp_of]\n\n include Base.Hashtbl.S_without_submodules with type ('a, 'b) t := ('a, 'b) t\n end)\n\nmodule Using_hashable = struct\n type nonrec ('a, 'b) t = ('a, 'b) t [@@deriving sexp_of]\n\n let create ?growth_allowed ?size ~hashable () =\n create ?growth_allowed ?size (Base.Hashable.to_key hashable)\n ;;\n\n let of_alist ?growth_allowed ?size ~hashable l =\n of_alist ?growth_allowed ?size (Base.Hashable.to_key hashable) l\n ;;\n\n let of_alist_report_all_dups ?growth_allowed ?size ~hashable l =\n of_alist_report_all_dups ?growth_allowed ?size (Base.Hashable.to_key hashable) l\n ;;\n\n let of_alist_or_error ?growth_allowed ?size ~hashable l =\n of_alist_or_error ?growth_allowed ?size (Base.Hashable.to_key hashable) l\n ;;\n\n let of_alist_exn ?growth_allowed ?size ~hashable l =\n of_alist_exn ?growth_allowed ?size (Base.Hashable.to_key hashable) l\n ;;\n\n let of_alist_multi ?growth_allowed ?size ~hashable l =\n of_alist_multi ?growth_allowed ?size (Base.Hashable.to_key hashable) l\n ;;\n\n let create_mapped ?growth_allowed ?size ~hashable ~get_key ~get_data l =\n create_mapped\n ?growth_allowed\n ?size\n (Base.Hashable.to_key hashable)\n ~get_key\n ~get_data\n l\n ;;\n\n let create_with_key ?growth_allowed ?size ~hashable ~get_key l =\n create_with_key ?growth_allowed ?size (Base.Hashable.to_key hashable) ~get_key l\n ;;\n\n let create_with_key_or_error ?growth_allowed ?size ~hashable ~get_key l =\n create_with_key_or_error\n ?growth_allowed\n ?size\n (Base.Hashable.to_key hashable)\n ~get_key\n l\n ;;\n\n let create_with_key_exn ?growth_allowed ?size ~hashable ~get_key l =\n create_with_key_exn ?growth_allowed ?size (Base.Hashable.to_key hashable) ~get_key l\n ;;\n\n let group ?growth_allowed ?size ~hashable ~get_key ~get_data ~combine l =\n group\n ?growth_allowed\n ?size\n (Base.Hashable.to_key hashable)\n ~get_key\n ~get_data\n ~combine\n l\n ;;\nend\n\nmodule type S_plain = S_plain with type ('a, 'b) hashtbl = ('a, 'b) t\nmodule type S = S with type ('a, 'b) hashtbl = ('a, 'b) t\nmodule type S_binable = S_binable with type ('a, 'b) hashtbl = ('a, 'b) t\nmodule type Key_plain = Key_plain\nmodule type Key = Key\nmodule type Key_binable = Key_binable\n\nmodule Poly = struct\n include Hashtbl.Poly\n\n include Bin_prot.Utils.Make_iterable_binable2 (struct\n type nonrec ('a, 'b) t = ('a, 'b) t\n type ('a, 'b) el = 'a * 'b [@@deriving bin_io]\n\n let caller_identity =\n Bin_prot.Shape.Uuid.of_string \"8f3e445c-4992-11e6-a279-3703be311e7b\"\n ;;\n\n let module_name = Some \"Core_kernel.Hashtbl\"\n let length = length\n let iter t ~f = iteri t ~f:(fun ~key ~data -> f (key, data))\n\n let init ~len ~next =\n let t = create ~size:len () in\n for _i = 0 to len - 1 do\n let key, data = next () in\n match find t key with\n | None -> set t ~key ~data\n | Some _ -> failwith \"Core_hashtbl.bin_read_t_: duplicate key\"\n done;\n t\n ;;\n end)\nend\n\nmodule Make_plain (Key : Key_plain) = struct\n let hashable =\n { Hashable.hash = Key.hash; compare = Key.compare; sexp_of_t = Key.sexp_of_t }\n ;;\n\n type key = Key.t\n type ('a, 'b) hashtbl = ('a, 'b) t\n type 'a t = (Key.t, 'a) hashtbl\n type ('a, 'b) t__ = (Key.t, 'b) hashtbl\n type 'a key_ = Key.t\n\n include Creators (struct\n type 'a t = Key.t\n\n let hashable = hashable\n end)\n\n include (\n Hashtbl :\n sig\n include\n Hashtbl.Accessors\n with type ('a, 'b) t := ('a, 'b) t__\n with type 'a key := 'a key_\n\n include\n Hashtbl.Multi with type ('a, 'b) t := ('a, 'b) t__ with type 'a key := 'a key_\n\n include Invariant.S2 with type ('a, 'b) t := ('a, 'b) hashtbl\n end)\n\n let invariant invariant_key t = invariant ignore invariant_key t\n let sexp_of_t sexp_of_v t = Poly.sexp_of_t Key.sexp_of_t sexp_of_v t\n\n module Provide_of_sexp\n (Key : sig\n type t [@@deriving of_sexp]\n end\n with type t := key) =\n struct\n let t_of_sexp v_of_sexp sexp = t_of_sexp Key.t_of_sexp v_of_sexp sexp\n end\n\n module Provide_bin_io\n (Key' : sig\n type t [@@deriving bin_io]\n end\n with type t := key) =\n Bin_prot.Utils.Make_iterable_binable1 (struct\n module Key = struct\n include Key\n include Key'\n end\n\n type nonrec 'a t = 'a t\n type 'a el = Key.t * 'a [@@deriving bin_io]\n\n let caller_identity =\n Bin_prot.Shape.Uuid.of_string \"8fabab0a-4992-11e6-8cca-9ba2c4686d9e\"\n ;;\n\n let module_name = Some \"Core_kernel.Hashtbl\"\n let length = length\n let iter t ~f = iteri t ~f:(fun ~key ~data -> f (key, data))\n\n let init ~len ~next =\n let t = create ~size:len () in\n for _i = 0 to len - 1 do\n let key, data = next () in\n match find t key with\n | None -> set t ~key ~data\n | Some _ ->\n failwiths\n ~here:[%here]\n \"Hashtbl.bin_read_t: duplicate key\"\n key\n [%sexp_of: Key.t]\n done;\n t\n ;;\n end)\nend\n\nmodule Make (Key : Key) = struct\n include Make_plain (Key)\n include Provide_of_sexp (Key)\nend\n\nmodule Make_binable (Key : Key_binable) = struct\n include Make (Key)\n include Provide_bin_io (Key)\nend\n\nmodule M = Hashtbl.M\n\nmodule type For_deriving = For_deriving\n\ninclude (Hashtbl : For_deriving with type ('a, 'b) t := ('a, 'b) t)\n\nlet hashable = Hashtbl.Private.hashable\n","open! Import\nopen Hash_set_intf\ninclude Base.Hash_set\n\nmodule type S_plain = S_plain with type 'a hash_set := 'a t\nmodule type S = S with type 'a hash_set := 'a t\nmodule type S_binable = S_binable with type 'a hash_set := 'a t\nmodule type Elt_plain = Hashtbl.Key_plain\nmodule type Elt = Hashtbl.Key\nmodule type Elt_binable = Hashtbl.Key_binable\n\nmodule Make_plain (Elt : Elt_plain) = struct\n type elt = Elt.t\n type nonrec t = elt t\n type 'a elt_ = elt\n\n include Creators (struct\n type 'a t = Elt.t\n\n let hashable = Hashtbl.Hashable.of_key (module Elt)\n end)\n\n let sexp_of_t t = Poly.sexp_of_t Elt.sexp_of_t t\n\n module Provide_of_sexp\n (X : sig\n type t [@@deriving of_sexp]\n end\n with type t := elt) =\n struct\n let t_of_sexp sexp = t_of_sexp X.t_of_sexp sexp\n end\n\n module Provide_bin_io\n (X : sig\n type t [@@deriving bin_io]\n end\n with type t := elt) =\n Bin_prot.Utils.Make_iterable_binable (struct\n module Elt = struct\n include Elt\n include X\n end\n\n type nonrec t = t\n type el = Elt.t [@@deriving bin_io]\n\n let _ = bin_el\n\n let caller_identity =\n Bin_prot.Shape.Uuid.of_string \"ad381672-4992-11e6-9e36-b76dc8cd466f\"\n ;;\n\n let module_name = Some \"Core_kernel.Hash_set\"\n let length = length\n let iter = iter\n\n let init ~len ~next =\n let t = create ~size:len () in\n for _i = 0 to len - 1 do\n let v = next () in\n add t v\n done;\n t\n ;;\n end)\nend\n\nmodule Make (Elt : Elt) = struct\n include Make_plain (Elt)\n include Provide_of_sexp (Elt)\nend\n\nmodule Make_binable (Elt : Elt_binable) = struct\n include Make (Elt)\n include Provide_bin_io (Elt)\nend\n\nmodule Using_hashable = struct\n type 'a elt = 'a\n\n let create ?growth_allowed ?size ~hashable () =\n create ?growth_allowed ?size (Base.Hashable.to_key hashable)\n ;;\n\n let of_list ?growth_allowed ?size ~hashable l =\n of_list ?growth_allowed ?size (Base.Hashable.to_key hashable) l\n ;;\nend\n\nlet hashable = Private.hashable\nlet create ?growth_allowed ?size m = create ?growth_allowed ?size m\n","open! Import\ninclude Base.Or_error\n\ntype 'a t = ('a, Error.t) Result.t [@@deriving bin_io]\n\nmodule Expect_test_config = struct\n module IO = Base.Or_error\n module IO_run = IO\n\n module IO_flush = struct\n include IO\n\n let to_run t = t\n end\n\n let flush () = return ()\n let run f = ok_exn (f ())\n let flushed () = true\n let upon_unreleasable_issue = Expect_test_config.upon_unreleasable_issue\nend\n\nmodule Stable = struct\n module V1 = struct\n type 'a t = ('a, Error.Stable.V1.t) Result.Stable.V1.t\n [@@deriving bin_io, compare, sexp]\n\n let map x ~f = Result.Stable.V1.map x ~f1:f ~f2:Fn.id\n end\n\n module V2 = struct\n type 'a t = ('a, Error.Stable.V2.t) Result.Stable.V1.t\n [@@deriving bin_io, compare, sexp]\n\n let map x ~f = Result.Stable.V1.map x ~f1:f ~f2:Fn.id\n end\nend\n","open! Import\nopen Map_intf\nmodule List = List0\n\nmodule Symmetric_diff_element = struct\n module Stable = struct\n module V1 = struct\n type ('k, 'v) t = 'k * [ `Left of 'v | `Right of 'v | `Unequal of 'v * 'v ]\n [@@deriving bin_io, compare, sexp]\n\n let%expect_test _ =\n print_endline [%bin_digest: (int, string) t];\n [%expect {| 00674be9fe8dfe9e9ad476067d7d8101 |}]\n ;;\n\n let map (k, diff) ~f1 ~f2 =\n let k = f1 k in\n let diff =\n match diff with\n | `Left v -> `Left (f2 v)\n | `Right v -> `Right (f2 v)\n | `Unequal (v1, v2) -> `Unequal (f2 v1, f2 v2)\n in\n k, diff\n ;;\n\n let map_data t ~f = map t ~f1:Fn.id ~f2:f\n\n let left (_key, diff) =\n match diff with\n | `Left x | `Unequal (x, _) -> Some x\n | `Right _ -> None\n ;;\n\n let right (_key, diff) =\n match diff with\n | `Right x | `Unequal (_, x) -> Some x\n | `Left _ -> None\n ;;\n end\n end\n\n include Stable.V1\nend\n\nmodule Continue_or_stop = Base.Map.Continue_or_stop\nmodule Finished_or_unfinished = Base.Map.Finished_or_unfinished\n\ntype ('k, 'cmp) comparator =\n (module Comparator.S with type t = 'k and type comparator_witness = 'cmp)\n\nlet to_comparator (type k cmp) ((module M) : (k, cmp) Map.comparator) = M.comparator\n\nlet of_comparator (type k cmp) comparator : (k, cmp) Map.comparator =\n (module struct\n type t = k\n type comparator_witness = cmp\n\n let comparator = comparator\n end)\n;;\n\nmodule For_quickcheck = struct\n let gen_tree ~comparator k_gen v_gen =\n Base_quickcheck.Generator.map_tree_using_comparator ~comparator k_gen v_gen\n ;;\n\n let quickcheck_generator ~comparator k_gen v_gen =\n Base_quickcheck.Generator.map_t_m (of_comparator comparator) k_gen v_gen\n ;;\n\n let obs_tree k_obs v_obs = Base_quickcheck.Observer.map_tree k_obs v_obs\n\n let shr_tree ~comparator k_shr v_shr =\n Base_quickcheck.Shrinker.map_tree_using_comparator ~comparator k_shr v_shr\n ;;\nend\n\nlet quickcheck_generator = Base_quickcheck.Generator.map_t_m\nlet quickcheck_observer = Base_quickcheck.Observer.map_t\nlet quickcheck_shrinker = Base_quickcheck.Shrinker.map_t\n\nmodule Using_comparator = struct\n include Map.Using_comparator\n include For_quickcheck\n\n let of_hashtbl_exn ~comparator hashtbl =\n match of_iteri ~comparator ~iteri:(Hashtbl.iteri hashtbl) with\n | `Ok map -> map\n | `Duplicate_key key ->\n Error.failwiths\n ~here:[%here]\n \"Map.of_hashtbl_exn: duplicate key\"\n key\n comparator.sexp_of_t\n ;;\n\n let tree_of_hashtbl_exn ~comparator hashtbl =\n to_tree (of_hashtbl_exn ~comparator hashtbl)\n ;;\n\n let key_set ~comparator t =\n Base.Set.Using_comparator.of_sorted_array_unchecked\n ~comparator\n (List.to_array (keys t))\n ;;\n\n let key_set_of_tree ~comparator t = key_set ~comparator (of_tree ~comparator t)\n\n let of_key_set key_set ~f =\n of_sorted_array_unchecked\n ~comparator:(Base.Set.comparator key_set)\n (Array.map (Base.Set.to_array key_set) ~f:(fun key -> key, f key))\n ;;\n\n let tree_of_key_set key_set ~f = to_tree (of_key_set key_set ~f)\nend\n\nmodule Accessors = struct\n include (\n Map.Using_comparator :\n Map.Accessors3\n with type ('a, 'b, 'c) t := ('a, 'b, 'c) Map.t\n with type ('a, 'b, 'c) tree := ('a, 'b, 'c) Tree.t)\n\n let quickcheck_observer k v = quickcheck_observer k v\n let quickcheck_shrinker k v = quickcheck_shrinker k v\n let key_set t = Using_comparator.key_set t ~comparator:(Using_comparator.comparator t)\nend\n\nlet key_set t = Using_comparator.key_set ~comparator:(Using_comparator.comparator t) t\nlet of_key_set = Using_comparator.of_key_set\nlet hash_fold_direct = Using_comparator.hash_fold_direct\nlet comparator = Using_comparator.comparator\nlet comparator_s = Base.Map.comparator_s\n\ntype 'k key = 'k\ntype 'c cmp = 'c\n\ninclude (\nstruct\n include Map\n\n let of_tree m = Map.Using_comparator.of_tree ~comparator:(to_comparator m)\n let to_tree = Map.Using_comparator.to_tree\nend :\nsig\n type ('a, 'b, 'c) t = ('a, 'b, 'c) Map.t\n\n include\n Map.Creators_generic\n with type ('a, 'b, 'c) options := ('a, 'b, 'c) Map.With_first_class_module.t\n with type ('a, 'b, 'c) t := ('a, 'b, 'c) t\n with type ('a, 'b, 'c) tree := ('a, 'b, 'c) Tree.t\n with type 'k key := 'k key\n with type 'c cmp := 'c cmp\n\n include\n Map.Accessors3\n with type ('a, 'b, 'c) t := ('a, 'b, 'c) t\n with type ('a, 'b, 'c) tree := ('a, 'b, 'c) Tree.t\nend)\n\nmodule Empty_without_value_restriction = Using_comparator.Empty_without_value_restriction\n\nlet find_or_error t key =\n let comparator = comparator t in\n match find t key with\n | Some data -> Ok data\n | None ->\n let sexp_of_key = comparator.sexp_of_t in\n Or_error.error_s [%message \"key not found\" ~_:(key : key)]\n;;\n\nlet merge_skewed = Map.merge_skewed\nlet of_hashtbl_exn m t = Using_comparator.of_hashtbl_exn ~comparator:(to_comparator m) t\n\nmodule Creators (Key : Comparator.S1) : sig\n type ('a, 'b, 'c) t_ = ('a Key.t, 'b, Key.comparator_witness) t\n type ('a, 'b, 'c) tree = ('a, 'b, Key.comparator_witness) Tree.t\n type ('a, 'b, 'c) options = ('a, 'b, 'c) Without_comparator.t\n\n val t_of_sexp\n : (Base.Sexp.t -> 'a Key.t)\n -> (Base.Sexp.t -> 'b)\n -> Base.Sexp.t\n -> ('a, 'b, _) t_\n\n include\n Creators_generic\n with type ('a, 'b, 'c) t := ('a, 'b, 'c) t_\n with type ('a, 'b, 'c) tree := ('a, 'b, 'c) tree\n with type 'a key := 'a Key.t\n with type 'a cmp := Key.comparator_witness\n with type ('a, 'b, 'c) options := ('a, 'b, 'c) options\nend = struct\n type ('a, 'b, 'c) options = ('a, 'b, 'c) Without_comparator.t\n\n let comparator = Key.comparator\n\n type ('a, 'b, 'c) t_ = ('a Key.t, 'b, Key.comparator_witness) t\n type ('a, 'b, 'c) tree = ('a, 'b, Key.comparator_witness) Tree.t\n\n module M_empty = Empty_without_value_restriction (Key)\n\n let empty = M_empty.empty\n let of_tree tree = Using_comparator.of_tree ~comparator tree\n let singleton k v = Using_comparator.singleton ~comparator k v\n\n let of_sorted_array_unchecked array =\n Using_comparator.of_sorted_array_unchecked ~comparator array\n ;;\n\n let of_sorted_array array = Using_comparator.of_sorted_array ~comparator array\n\n let of_increasing_iterator_unchecked ~len ~f =\n Using_comparator.of_increasing_iterator_unchecked ~comparator ~len ~f\n ;;\n\n let of_increasing_sequence seq =\n Using_comparator.of_increasing_sequence ~comparator seq\n ;;\n\n let of_sequence seq = Using_comparator.of_sequence ~comparator seq\n let of_sequence_or_error seq = Using_comparator.of_sequence_or_error ~comparator seq\n let of_sequence_exn seq = Using_comparator.of_sequence_exn ~comparator seq\n let of_sequence_multi seq = Using_comparator.of_sequence_multi ~comparator seq\n\n let of_sequence_fold seq ~init ~f =\n Using_comparator.of_sequence_fold ~comparator seq ~init ~f\n ;;\n\n let of_sequence_reduce seq ~f = Using_comparator.of_sequence_reduce ~comparator seq ~f\n let of_alist alist = Using_comparator.of_alist ~comparator alist\n let of_alist_or_error alist = Using_comparator.of_alist_or_error ~comparator alist\n let of_alist_exn alist = Using_comparator.of_alist_exn ~comparator alist\n let of_hashtbl_exn hashtbl = Using_comparator.of_hashtbl_exn ~comparator hashtbl\n let of_alist_multi alist = Using_comparator.of_alist_multi ~comparator alist\n\n let of_alist_fold alist ~init ~f =\n Using_comparator.of_alist_fold ~comparator alist ~init ~f\n ;;\n\n let of_alist_reduce alist ~f = Using_comparator.of_alist_reduce ~comparator alist ~f\n let of_iteri ~iteri = Using_comparator.of_iteri ~comparator ~iteri\n\n let t_of_sexp k_of_sexp v_of_sexp sexp =\n Using_comparator.t_of_sexp_direct ~comparator k_of_sexp v_of_sexp sexp\n ;;\n\n let of_key_set key_set ~f = Using_comparator.of_key_set key_set ~f\n\n let quickcheck_generator gen_k gen_v =\n Using_comparator.quickcheck_generator ~comparator gen_k gen_v\n ;;\nend\n\nmodule Make_tree (Key : Comparator.S1) = struct\n open Tree\n\n let comparator = Key.comparator\n let sexp_of_t = sexp_of_t\n let t_of_sexp a b c = t_of_sexp_direct a b c ~comparator\n let empty = empty_without_value_restriction\n let of_tree tree = tree\n let singleton a = singleton a ~comparator\n let of_sorted_array_unchecked a = of_sorted_array_unchecked a ~comparator\n let of_sorted_array a = of_sorted_array a ~comparator\n\n let of_increasing_iterator_unchecked ~len ~f =\n of_increasing_iterator_unchecked ~len ~f ~comparator\n ;;\n\n let of_increasing_sequence seq = of_increasing_sequence ~comparator seq\n let of_sequence s = of_sequence s ~comparator\n let of_sequence_or_error s = of_sequence_or_error s ~comparator\n let of_sequence_exn s = of_sequence_exn s ~comparator\n let of_sequence_multi s = of_sequence_multi s ~comparator\n let of_sequence_fold s ~init ~f = of_sequence_fold s ~init ~f ~comparator\n let of_sequence_reduce s ~f = of_sequence_reduce s ~f ~comparator\n let of_alist a = of_alist a ~comparator\n let of_alist_or_error a = of_alist_or_error a ~comparator\n let of_alist_exn a = of_alist_exn a ~comparator\n let of_hashtbl_exn a = Using_comparator.tree_of_hashtbl_exn a ~comparator\n let of_alist_multi a = of_alist_multi a ~comparator\n let of_alist_fold a ~init ~f = of_alist_fold a ~init ~f ~comparator\n let of_alist_reduce a ~f = of_alist_reduce a ~f ~comparator\n let of_iteri ~iteri = of_iteri ~iteri ~comparator\n let of_key_set = Using_comparator.tree_of_key_set\n let to_tree t = t\n let invariants a = invariants a ~comparator\n let is_empty a = is_empty a\n let length a = length a\n let set a ~key ~data = set a ~key ~data ~comparator\n let add a ~key ~data = add a ~key ~data ~comparator\n let add_exn a ~key ~data = add_exn a ~key ~data ~comparator\n let add_multi a ~key ~data = add_multi a ~key ~data ~comparator\n let remove_multi a b = remove_multi a b ~comparator\n let find_multi a b = find_multi a b ~comparator\n let change a b ~f = change a b ~f ~comparator\n let update a b ~f = update a b ~f ~comparator\n let find_exn a b = find_exn a b ~comparator\n let find a b = find a b ~comparator\n let remove a b = remove a b ~comparator\n let mem a b = mem a b ~comparator\n let iter_keys = iter_keys\n let iter = iter\n let iteri = iteri\n let iteri_until = iteri_until\n let iter2 a b ~f = iter2 a b ~f ~comparator\n let map = map\n let mapi = mapi\n let fold = fold\n let fold_right = fold_right\n let fold2 a b ~init ~f = fold2 a b ~init ~f ~comparator\n let filter_keys a ~f = filter_keys a ~f ~comparator\n let filter a ~f = filter a ~f ~comparator\n let filteri a ~f = filteri a ~f ~comparator\n let filter_map a ~f = filter_map a ~f ~comparator\n let filter_mapi a ~f = filter_mapi a ~f ~comparator\n let partition_mapi t ~f = partition_mapi t ~f ~comparator\n let partition_map t ~f = partition_map t ~f ~comparator\n let partitioni_tf t ~f = partitioni_tf t ~f ~comparator\n let partition_tf t ~f = partition_tf t ~f ~comparator\n let combine_errors t = combine_errors t ~comparator\n let compare_direct a b c = compare_direct a b c ~comparator\n let equal a b c = equal a b c ~comparator\n let keys = keys\n let data = data\n let to_alist = to_alist\n let validate = validate\n let validatei = validatei\n let symmetric_diff a b ~data_equal = symmetric_diff a b ~data_equal ~comparator\n\n let fold_symmetric_diff a b ~data_equal ~init ~f =\n fold_symmetric_diff a b ~data_equal ~f ~init ~comparator\n ;;\n\n let merge a b ~f = merge a b ~f ~comparator\n let min_elt = min_elt\n let min_elt_exn = min_elt_exn\n let max_elt = max_elt\n let max_elt_exn = max_elt_exn\n let for_all = for_all\n let for_alli = for_alli\n let exists = exists\n let existsi = existsi\n let count = count\n let counti = counti\n let split a b = split a b ~comparator\n let append ~lower_part ~upper_part = append ~lower_part ~upper_part ~comparator\n\n let subrange t ~lower_bound ~upper_bound =\n subrange t ~lower_bound ~upper_bound ~comparator\n ;;\n\n let fold_range_inclusive t ~min ~max ~init ~f =\n fold_range_inclusive t ~min ~max ~init ~f ~comparator\n ;;\n\n let range_to_alist t ~min ~max = range_to_alist t ~min ~max ~comparator\n let closest_key a b c = closest_key a b c ~comparator\n let nth a = nth a ~comparator\n let nth_exn a = nth_exn a ~comparator\n let rank a b = rank a b ~comparator\n\n let to_sequence ?order ?keys_greater_or_equal_to ?keys_less_or_equal_to t =\n to_sequence ~comparator ?order ?keys_greater_or_equal_to ?keys_less_or_equal_to t\n ;;\n\n let binary_search t ~compare how v = binary_search ~comparator t ~compare how v\n\n let binary_search_segmented t ~segment_of how =\n binary_search_segmented ~comparator t ~segment_of how\n ;;\n\n let key_set t = Using_comparator.key_set_of_tree ~comparator t\n let quickcheck_generator k v = For_quickcheck.gen_tree ~comparator k v\n let quickcheck_observer k v = For_quickcheck.obs_tree k v\n let quickcheck_shrinker k v = For_quickcheck.shr_tree ~comparator k v\nend\n\n(* Don't use [of_sorted_array] to avoid the allocation of an intermediate array *)\nlet init_for_bin_prot ~len ~f ~comparator =\n let map = Using_comparator.of_increasing_iterator_unchecked ~len ~f ~comparator in\n if invariants map\n then map\n else (\n (* The invariants are broken, but we can still traverse the structure. *)\n match Using_comparator.of_iteri ~iteri:(iteri map) ~comparator with\n | `Ok map -> map\n | `Duplicate_key _key -> failwith \"Map.bin_read_t: duplicate element in map\")\n;;\n\nmodule Poly = struct\n include Creators (Comparator.Poly)\n\n type ('a, 'b, 'c) map = ('a, 'b, 'c) t\n type ('k, 'v) t = ('k, 'v, Comparator.Poly.comparator_witness) map\n type comparator_witness = Comparator.Poly.comparator_witness\n\n include Accessors\n\n let compare _ cmpv t1 t2 = compare_direct cmpv t1 t2\n\n let sexp_of_t sexp_of_k sexp_of_v t =\n Using_comparator.sexp_of_t sexp_of_k sexp_of_v [%sexp_of: _] t\n ;;\n\n include Bin_prot.Utils.Make_iterable_binable2 (struct\n type nonrec ('a, 'b) t = ('a, 'b) t\n type ('a, 'b) el = 'a * 'b [@@deriving bin_io]\n\n let _ = bin_el\n\n let caller_identity =\n Bin_prot.Shape.Uuid.of_string \"b7d7b1a0-4992-11e6-8a32-bbb221fa025c\"\n ;;\n\n let module_name = Some \"Core_kernel.Map\"\n let length = length\n let iter t ~f = iteri t ~f:(fun ~key ~data -> f (key, data))\n\n let init ~len ~next =\n init_for_bin_prot ~len ~f:(fun _ -> next ()) ~comparator:Comparator.Poly.comparator\n ;;\n end)\n\n module Tree = struct\n include Make_tree (Comparator.Poly)\n\n type ('k, +'v) t = ('k, 'v, Comparator.Poly.comparator_witness) tree\n type comparator_witness = Comparator.Poly.comparator_witness\n\n let sexp_of_t sexp_of_k sexp_of_v t = sexp_of_t sexp_of_k sexp_of_v [%sexp_of: _] t\n end\nend\n\nmodule type Key_plain = Key_plain\nmodule type Key = Key\nmodule type Key_binable = Key_binable\nmodule type Key_hashable = Key_hashable\nmodule type Key_binable_hashable = Key_binable_hashable\nmodule type S_plain = S_plain\nmodule type S = S\nmodule type S_binable = S_binable\n\nmodule Key_bin_io = Key_bin_io\n\nmodule Provide_bin_io (Key : Key_bin_io.S) =\n Bin_prot.Utils.Make_iterable_binable1 (struct\n module Key = Key\n\n type nonrec 'v t = (Key.t, 'v, Key.comparator_witness) t\n type 'v el = Key.t * 'v [@@deriving bin_io]\n\n let _ = bin_el\n\n let caller_identity =\n Bin_prot.Shape.Uuid.of_string \"dfb300f8-4992-11e6-9c15-73a2ac6b815c\"\n ;;\n\n let module_name = Some \"Core_kernel.Map\"\n let length = length\n let iter t ~f = iteri t ~f:(fun ~key ~data -> f (key, data))\n\n let init ~len ~next =\n init_for_bin_prot ~len ~f:(fun _ -> next ()) ~comparator:Key.comparator\n ;;\n end)\n\nmodule Make_plain_using_comparator (Key : sig\n type t [@@deriving sexp_of]\n\n include Comparator.S with type t := t\n end) =\nstruct\n module Key = Key\n module Key_S1 = Comparator.S_to_S1 (Key)\n include Creators (Key_S1)\n\n type key = Key.t\n type ('a, 'b, 'c) map = ('a, 'b, 'c) t\n type 'v t = (key, 'v, Key.comparator_witness) map\n\n include Accessors\n\n let compare cmpv t1 t2 = compare_direct cmpv t1 t2\n\n let sexp_of_t sexp_of_v t =\n Using_comparator.sexp_of_t Key.sexp_of_t sexp_of_v [%sexp_of: _] t\n ;;\n\n module Provide_of_sexp\n (Key : sig\n type t [@@deriving of_sexp]\n end\n with type t := Key.t) =\n struct\n let t_of_sexp v_of_sexp sexp = t_of_sexp Key.t_of_sexp v_of_sexp sexp\n end\n\n module Provide_hash (Key' : Hasher.S with type t := Key.t) = struct\n let hash_fold_t (type a) hash_fold_data state (t : a t) =\n Using_comparator.hash_fold_direct Key'.hash_fold_t hash_fold_data state t\n ;;\n end\n\n module Provide_bin_io\n (Key' : sig\n type t [@@deriving bin_io]\n end\n with type t := Key.t) =\n Provide_bin_io (struct\n include Key\n include Key'\n end)\n\n module Tree = struct\n include Make_tree (Key_S1)\n\n type +'v t = (Key.t, 'v, Key.comparator_witness) tree\n\n let sexp_of_t sexp_of_v t = sexp_of_t Key.sexp_of_t sexp_of_v [%sexp_of: _] t\n\n module Provide_of_sexp\n (X : sig\n type t [@@deriving of_sexp]\n end\n with type t := Key.t) =\n struct\n let t_of_sexp v_of_sexp sexp = t_of_sexp X.t_of_sexp v_of_sexp sexp\n end\n end\nend\n\nmodule Make_plain (Key : Key_plain) = Make_plain_using_comparator (struct\n include Key\n include Comparator.Make (Key)\n end)\n\nmodule Make_using_comparator (Key_sexp : sig\n type t [@@deriving sexp]\n\n include Comparator.S with type t := t\n end) =\nstruct\n include Make_plain_using_comparator (Key_sexp)\n module Key = Key_sexp\n include Provide_of_sexp (Key)\n\n module Tree = struct\n include Tree\n include Provide_of_sexp (Key)\n end\nend\n\nmodule Make (Key : Key) = Make_using_comparator (struct\n include Key\n include Comparator.Make (Key)\n end)\n\nmodule Make_binable_using_comparator (Key_bin_sexp : sig\n type t [@@deriving bin_io, sexp]\n\n include Comparator.S with type t := t\n end) =\nstruct\n include Make_using_comparator (Key_bin_sexp)\n module Key = Key_bin_sexp\n include Provide_bin_io (Key)\nend\n\nmodule Make_binable (Key : Key_binable) = Make_binable_using_comparator (struct\n include Key\n include Comparator.Make (Key)\n end)\n\nmodule For_deriving = struct\n module M = Map.M\n\n let bin_shape_m__t (type t c) (m : (t, c) Key_bin_io.t) =\n let module M = Provide_bin_io ((val m)) in\n M.bin_shape_t\n ;;\n\n let bin_size_m__t (type t c) (m : (t, c) Key_bin_io.t) =\n let module M = Provide_bin_io ((val m)) in\n M.bin_size_t\n ;;\n\n let bin_write_m__t (type t c) (m : (t, c) Key_bin_io.t) =\n let module M = Provide_bin_io ((val m)) in\n M.bin_write_t\n ;;\n\n let bin_read_m__t (type t c) (m : (t, c) Key_bin_io.t) =\n let module M = Provide_bin_io ((val m)) in\n M.bin_read_t\n ;;\n\n let __bin_read_m__t__ (type t c) (m : (t, c) Key_bin_io.t) =\n let module M = Provide_bin_io ((val m)) in\n M.__bin_read_t__\n ;;\n\n module type Quickcheck_generator_m = sig\n include Comparator.S\n\n val quickcheck_generator : t Quickcheck.Generator.t\n end\n\n module type Quickcheck_observer_m = sig\n include Comparator.S\n\n val quickcheck_observer : t Quickcheck.Observer.t\n end\n\n module type Quickcheck_shrinker_m = sig\n include Comparator.S\n\n val quickcheck_shrinker : t Quickcheck.Shrinker.t\n end\n\n let quickcheck_generator_m__t\n (type k cmp)\n (module Key : Quickcheck_generator_m\n with type t = k\n and type comparator_witness = cmp)\n v_generator\n =\n quickcheck_generator (module Key) Key.quickcheck_generator v_generator\n ;;\n\n let quickcheck_observer_m__t\n (type k cmp)\n (module Key : Quickcheck_observer_m\n with type t = k\n and type comparator_witness = cmp)\n v_observer\n =\n quickcheck_observer Key.quickcheck_observer v_observer\n ;;\n\n let quickcheck_shrinker_m__t\n (type k cmp)\n (module Key : Quickcheck_shrinker_m\n with type t = k\n and type comparator_witness = cmp)\n v_shrinker\n =\n quickcheck_shrinker Key.quickcheck_shrinker v_shrinker\n ;;\n\n module type For_deriving = Map.For_deriving\n\n include (Map : For_deriving with type ('a, 'b, 'c) t := ('a, 'b, 'c) t)\nend\n\ninclude For_deriving\n\nmodule Tree = struct\n include Tree\n\n let of_hashtbl_exn = Using_comparator.tree_of_hashtbl_exn\n let key_set = Using_comparator.key_set_of_tree\n let of_key_set = Using_comparator.tree_of_key_set\n let quickcheck_generator ~comparator k v = For_quickcheck.gen_tree ~comparator k v\n let quickcheck_observer k v = For_quickcheck.obs_tree k v\n let quickcheck_shrinker ~comparator k v = For_quickcheck.shr_tree ~comparator k v\nend\n\nmodule Stable = struct\n module V1 = struct\n type nonrec ('k, 'v, 'cmp) t = ('k, 'v, 'cmp) t\n\n module type S = sig\n type key\n type comparator_witness\n type nonrec 'a t = (key, 'a, comparator_witness) t\n\n include Stable_module_types.S1 with type 'a t := 'a t\n end\n\n module Make (Key : Stable_module_types.S0) = Make_binable_using_comparator (Key)\n end\n\n module Symmetric_diff_element = Symmetric_diff_element.Stable\nend\n","open! Import\nmodule List = List0\nopen Set_intf\nmodule Merge_to_sequence_element = Merge_to_sequence_element\nmodule Named = Named\n\nmodule type Elt_plain = Elt_plain\nmodule type Elt = Elt\nmodule type Elt_binable = Elt_binable\n\nlet to_comparator (type k cmp) ((module M) : (k, cmp) Set.comparator) = M.comparator\n\nlet of_comparator (type k cmp) comparator : (k, cmp) Set.comparator =\n (module struct\n type t = k\n type comparator_witness = cmp\n\n let comparator = comparator\n end)\n;;\n\nmodule For_quickcheck = struct\n let quickcheck_generator ~comparator elt_gen =\n Base_quickcheck.Generator.set_t_m (of_comparator comparator) elt_gen\n ;;\n\n let gen_tree ~comparator elt_gen =\n Base_quickcheck.Generator.set_tree_using_comparator ~comparator elt_gen\n ;;\n\n let quickcheck_observer elt_obs = Base_quickcheck.Observer.set_t elt_obs\n let obs_tree elt_obs = Base_quickcheck.Observer.set_tree elt_obs\n let quickcheck_shrinker elt_shr = Base_quickcheck.Shrinker.set_t elt_shr\n\n let shr_tree ~comparator elt_shr =\n Base_quickcheck.Shrinker.set_tree_using_comparator ~comparator elt_shr\n ;;\nend\n\nlet quickcheck_generator m elt_gen =\n For_quickcheck.quickcheck_generator ~comparator:(to_comparator m) elt_gen\n;;\n\nlet quickcheck_observer = For_quickcheck.quickcheck_observer\nlet quickcheck_shrinker = For_quickcheck.quickcheck_shrinker\n\nmodule Tree = struct\n include Tree\n\n let to_map ~comparator t = Map.of_key_set (Set.Using_comparator.of_tree t ~comparator)\n let of_map_keys m = Set.Using_comparator.to_tree (Map.key_set m)\n\n let of_hash_set ~comparator hset =\n Hash_set.fold hset ~init:(empty ~comparator) ~f:(fun t x -> add t x ~comparator)\n ;;\n\n let of_hashtbl_keys ~comparator hashtbl =\n Hashtbl.fold hashtbl ~init:(empty ~comparator) ~f:(fun ~key:x ~data:_ t ->\n add t x ~comparator)\n ;;\n\n let quickcheck_generator = For_quickcheck.gen_tree\n let quickcheck_observer = For_quickcheck.obs_tree\n let quickcheck_shrinker = For_quickcheck.shr_tree\nend\n\nmodule Accessors = struct\n include (\n Set.Using_comparator :\n Set.Accessors2\n with type ('a, 'b) t := ('a, 'b) Set.t\n with type ('a, 'b) tree := ('a, 'b) Tree.t\n with type ('a, 'b) named := ('a, 'b) Set.Named.t)\n\n let to_map = Map.of_key_set\n let quickcheck_observer = quickcheck_observer\n let quickcheck_shrinker = quickcheck_shrinker\nend\n\ntype 'a cmp = 'a\ntype 'a elt = 'a\n\ninclude (\nstruct\n include Set\n\n let of_tree m = Set.Using_comparator.of_tree ~comparator:(to_comparator m)\n let to_tree = Set.Using_comparator.to_tree\n let sexp_of_t = Set.Using_comparator.sexp_of_t\n\n module Empty_without_value_restriction =\n Set.Using_comparator.Empty_without_value_restriction\nend :\nsig\n type ('a, 'b) t = ('a, 'b) Set.t [@@deriving sexp_of]\n\n include\n Set.Creators_generic\n with type ('a, 'b, 'c) options := ('a, 'b, 'c) Set.With_first_class_module.t\n with type ('a, 'b) t := ('a, 'b) t\n with type ('a, 'b) set := ('a, 'b) t\n with type ('a, 'b) tree := ('a, 'b) Tree.t\n with type 'a cmp := 'a cmp\n with type 'a elt := 'a elt\n\n include\n Set.Accessors2\n with type ('a, 'b) t := ('a, 'b) t\n with type ('a, 'b) tree := ('a, 'b) Tree.t\n with type ('a, 'b) named := ('a, 'b) Set.Named.t\n with module Named := Named\nend)\n\ntype ('k, 'cmp) comparator =\n (module Comparator.S with type t = 'k and type comparator_witness = 'cmp)\n\nlet compare _ _ t1 t2 = compare_direct t1 t2\n\nmodule Using_comparator = struct\n include (\n Set.Using_comparator :\n module type of struct\n include Set.Using_comparator\n end\n with module Tree := Set.Using_comparator.Tree)\n\n include For_quickcheck\n\n let of_map_keys = Map.key_set\n\n let of_hash_set ~comparator hset =\n of_tree ~comparator (Tree.of_hash_set hset ~comparator)\n ;;\n\n let of_hashtbl_keys ~comparator hashtbl =\n of_tree ~comparator (Tree.of_hashtbl_keys hashtbl ~comparator)\n ;;\nend\n\nlet to_map = Map.of_key_set\nlet of_map_keys = Map.key_set\nlet hash_fold_direct = Using_comparator.hash_fold_direct\nlet comparator = Using_comparator.comparator\nlet of_hash_set m hset = Using_comparator.of_hash_set ~comparator:(to_comparator m) hset\n\nlet of_hashtbl_keys m hashtbl =\n Using_comparator.of_hashtbl_keys ~comparator:(to_comparator m) hashtbl\n;;\n\nmodule Creators (Elt : Comparator.S1) : sig\n type nonrec ('a, 'comparator) t_ = ('a Elt.t, Elt.comparator_witness) t\n type ('a, 'b) tree = ('a, Elt.comparator_witness) Tree.t\n type 'a elt_ = 'a Elt.t\n type 'a cmp_ = Elt.comparator_witness\n\n val t_of_sexp : (Base.Sexp.t -> 'a Elt.t) -> Base.Sexp.t -> ('a, 'comparator) t_\n\n include\n Creators_generic\n with type ('a, 'b) t := ('a, 'b) t_\n with type ('a, 'b) set := ('a, 'b) t\n with type ('a, 'b) tree := ('a, 'b) tree\n with type 'a elt := 'a elt_\n with type ('a, 'b, 'c) options := ('a, 'b, 'c) Without_comparator.t\n with type 'a cmp := 'a cmp_\nend = struct\n open Using_comparator\n\n type nonrec ('a, 'comparator) t_ = ('a Elt.t, Elt.comparator_witness) t\n type ('a, 'b) tree = ('a, Elt.comparator_witness) Tree.t\n type 'a elt_ = 'a Elt.t\n type 'cmp cmp_ = Elt.comparator_witness\n\n let comparator = Elt.comparator\n let of_tree tree = of_tree ~comparator tree\n let of_sorted_array_unchecked array = of_sorted_array_unchecked ~comparator array\n\n let of_increasing_iterator_unchecked ~len ~f =\n of_increasing_iterator_unchecked ~comparator ~len ~f\n ;;\n\n let of_sorted_array array = of_sorted_array ~comparator array\n\n module M_empty = Empty_without_value_restriction (Elt)\n\n let empty = M_empty.empty\n let singleton e = singleton ~comparator e\n let union_list l = union_list ~comparator l\n let of_list l = of_list ~comparator l\n let of_hash_set h = of_hash_set ~comparator h\n let of_hashtbl_keys h = of_hashtbl_keys ~comparator h\n let of_array a = of_array ~comparator a\n let stable_dedup_list xs = stable_dedup_list ~comparator xs\n let map t ~f = map ~comparator t ~f\n let filter_map t ~f = filter_map ~comparator t ~f\n\n let t_of_sexp a_of_sexp sexp =\n of_tree (Tree.t_of_sexp_direct a_of_sexp sexp ~comparator)\n ;;\n\n let of_map_keys = Map.key_set\n let quickcheck_generator elt = quickcheck_generator ~comparator elt\nend\n\nmodule Make_tree (Elt : Comparator.S1) = struct\n let comparator = Elt.comparator\n let empty = Tree.empty_without_value_restriction\n let singleton e = Tree.singleton ~comparator e\n let invariants t = Tree.invariants t ~comparator\n let length t = Tree.length t\n let is_empty t = Tree.is_empty t\n let elements t = Tree.elements t\n let min_elt t = Tree.min_elt t\n let min_elt_exn t = Tree.min_elt_exn t\n let max_elt t = Tree.max_elt t\n let max_elt_exn t = Tree.max_elt_exn t\n let choose t = Tree.choose t\n let choose_exn t = Tree.choose_exn t\n let to_list t = Tree.to_list t\n let to_array t = Tree.to_array t\n let iter t ~f = Tree.iter t ~f\n let iter2 a b ~f = Tree.iter2 a b ~f ~comparator\n let exists t ~f = Tree.exists t ~f\n let for_all t ~f = Tree.for_all t ~f\n let count t ~f = Tree.count t ~f\n let sum m t ~f = Tree.sum m t ~f\n let find t ~f = Tree.find t ~f\n let find_exn t ~f = Tree.find_exn t ~f\n let find_map t ~f = Tree.find_map t ~f\n let fold t ~init ~f = Tree.fold t ~init ~f\n let fold_until t ~init ~f = Tree.fold_until t ~init ~f\n let fold_right t ~init ~f = Tree.fold_right t ~init ~f\n let fold_result t ~init ~f = Container.fold_result ~fold ~init ~f t\n let map t ~f = Tree.map t ~f ~comparator\n let filter t ~f = Tree.filter t ~f ~comparator\n let filter_map t ~f = Tree.filter_map t ~f ~comparator\n let partition_tf t ~f = Tree.partition_tf t ~f ~comparator\n let mem t a = Tree.mem t a ~comparator\n let add t a = Tree.add t a ~comparator\n let remove t a = Tree.remove t a ~comparator\n let union t1 t2 = Tree.union t1 t2 ~comparator\n let inter t1 t2 = Tree.inter t1 t2 ~comparator\n let diff t1 t2 = Tree.diff t1 t2 ~comparator\n let symmetric_diff t1 t2 = Tree.symmetric_diff t1 t2 ~comparator\n let compare_direct t1 t2 = Tree.compare_direct ~comparator t1 t2\n let equal t1 t2 = Tree.equal t1 t2 ~comparator\n let is_subset t ~of_ = Tree.is_subset t ~of_ ~comparator\n let are_disjoint t1 t2 = Tree.are_disjoint t1 t2 ~comparator\n let of_list l = Tree.of_list l ~comparator\n let of_hash_set h = Tree.of_hash_set h ~comparator\n let of_hashtbl_keys h = Tree.of_hashtbl_keys h ~comparator\n let of_array a = Tree.of_array a ~comparator\n let of_sorted_array_unchecked a = Tree.of_sorted_array_unchecked a ~comparator\n\n let of_increasing_iterator_unchecked ~len ~f =\n Tree.of_increasing_iterator_unchecked ~len ~f ~comparator\n ;;\n\n let of_sorted_array a = Tree.of_sorted_array a ~comparator\n let union_list l = Tree.union_list l ~comparator\n let stable_dedup_list xs = Tree.stable_dedup_list xs ~comparator\n let group_by t ~equiv = Tree.group_by t ~equiv ~comparator\n let split t a = Tree.split t a ~comparator\n let nth t i = Tree.nth t i\n let remove_index t i = Tree.remove_index t i ~comparator\n let to_tree t = t\n let of_tree t = t\n\n let to_sequence ?order ?greater_or_equal_to ?less_or_equal_to t =\n Tree.to_sequence ~comparator ?order ?greater_or_equal_to ?less_or_equal_to t\n ;;\n\n let binary_search t ~compare how v = Tree.binary_search ~comparator t ~compare how v\n\n let binary_search_segmented t ~segment_of how =\n Tree.binary_search_segmented ~comparator t ~segment_of how\n ;;\n\n let merge_to_sequence ?order ?greater_or_equal_to ?less_or_equal_to t t' =\n Tree.merge_to_sequence ~comparator ?order ?greater_or_equal_to ?less_or_equal_to t t'\n ;;\n\n let of_map_keys = Tree.of_map_keys\n let to_map t ~f = Tree.to_map ~comparator t ~f\n\n module Named = struct\n let is_subset t ~of_ = Tree.Named.is_subset t ~of_ ~comparator\n let equal t1 t2 = Tree.Named.equal t1 t2 ~comparator\n end\n\n let quickcheck_generator elt = For_quickcheck.gen_tree elt ~comparator\n let quickcheck_observer elt = For_quickcheck.obs_tree elt\n let quickcheck_shrinker elt = For_quickcheck.shr_tree elt ~comparator\nend\n\n(* Don't use [of_sorted_array] to avoid the allocation of an intermediate array *)\nlet init_for_bin_prot ~len ~f ~comparator =\n let set = Using_comparator.of_increasing_iterator_unchecked ~comparator ~len ~f in\n if invariants set\n then set\n else\n Using_comparator.of_tree\n ~comparator\n (fold set ~init:(Tree.empty ~comparator) ~f:(fun acc elt ->\n if Tree.mem acc elt ~comparator\n then failwith \"Set.bin_read_t: duplicate element in map\"\n else Tree.add acc elt ~comparator))\n;;\n\nmodule Poly = struct\n module Elt = Comparator.Poly\n include Creators (Elt)\n\n type nonrec 'a t = ('a, Elt.comparator_witness) t\n type 'a named = ('a, Elt.comparator_witness) Named.t\n\n include Accessors\n\n let compare _ t1 t2 = compare_direct t1 t2\n let sexp_of_t sexp_of_k t = sexp_of_t sexp_of_k [%sexp_of: _] t\n\n include Bin_prot.Utils.Make_iterable_binable1 (struct\n type nonrec 'a t = 'a t\n type 'a el = 'a [@@deriving bin_io]\n\n let _ = bin_el\n\n let caller_identity =\n Bin_prot.Shape.Uuid.of_string \"88bcc478-4992-11e6-a95d-ff4831acf410\"\n ;;\n\n let module_name = Some \"Core_kernel.Set\"\n let length = length\n let iter t ~f = iter ~f:(fun key -> f key) t\n\n let init ~len ~next =\n init_for_bin_prot ~len ~f:(fun _ -> next ()) ~comparator:Comparator.Poly.comparator\n ;;\n end)\n\n module Tree = struct\n include Make_tree (Comparator.Poly)\n\n type 'elt t = ('elt, Comparator.Poly.comparator_witness) tree\n type 'a named = ('a, Elt.comparator_witness) Tree.Named.t\n\n let sexp_of_t sexp_of_elt t = Tree.sexp_of_t sexp_of_elt [%sexp_of: _] t\n\n let t_of_sexp elt_of_sexp sexp =\n Tree.t_of_sexp_direct elt_of_sexp sexp ~comparator:Comparator.Poly.comparator\n ;;\n end\nend\n\nmodule type S_plain = S_plain\nmodule type S = S\nmodule type S_binable = S_binable\n\nmodule Elt_bin_io = Elt_bin_io\n\nmodule Provide_bin_io (Elt : Elt_bin_io.S) = Bin_prot.Utils.Make_iterable_binable (struct\n type nonrec t = (Elt.t, Elt.comparator_witness) t\n type el = Elt.t [@@deriving bin_io]\n\n let _ = bin_el\n\n let caller_identity =\n Bin_prot.Shape.Uuid.of_string \"8989278e-4992-11e6-8f4a-6b89776b1e53\"\n ;;\n\n let module_name = Some \"Core_kernel.Set\"\n let length = length\n let iter t ~f = iter ~f:(fun key -> f key) t\n\n let init ~len ~next =\n init_for_bin_prot ~len ~f:(fun _ -> next ()) ~comparator:Elt.comparator\n ;;\n end)\n\nmodule Make_plain_using_comparator (Elt : sig\n type t [@@deriving sexp_of]\n\n include Comparator.S with type t := t\n end) =\nstruct\n module Elt = Elt\n module Elt_S1 = Comparator.S_to_S1 (Elt)\n include Creators (Elt_S1)\n\n type ('a, 'b) set = ('a, 'b) t\n type t = (Elt.t, Elt.comparator_witness) set\n type named = (Elt.t, Elt.comparator_witness) Named.t\n\n include Accessors\n\n let compare t1 t2 = compare_direct t1 t2\n let sexp_of_t t = sexp_of_t Elt.sexp_of_t [%sexp_of: _] t\n\n module Provide_of_sexp\n (Elt : sig\n type t [@@deriving of_sexp]\n end\n with type t := Elt.t) =\n struct\n let t_of_sexp sexp = t_of_sexp Elt.t_of_sexp sexp\n end\n\n module Provide_hash (Elt : Hasher.S with type t := Elt.t) = struct\n let hash_fold_t state t = Using_comparator.hash_fold_direct Elt.hash_fold_t state t\n\n let hash t =\n Ppx_hash_lib.Std.Hash.get_hash_value\n (hash_fold_t (Ppx_hash_lib.Std.Hash.create ()) t)\n ;;\n end\n\n module Provide_bin_io\n (Elt' : sig\n type t [@@deriving bin_io]\n end\n with type t := Elt.t) =\n Provide_bin_io (struct\n include Elt\n include Elt'\n end)\n\n module Tree = struct\n include Make_tree (Elt_S1)\n\n type t = (Elt.t, Elt.comparator_witness) tree\n type named = (Elt.t, Elt.comparator_witness) Tree.Named.t\n\n let compare t1 t2 = compare_direct t1 t2\n let sexp_of_t t = Tree.sexp_of_t Elt.sexp_of_t [%sexp_of: _] t\n\n module Provide_of_sexp\n (X : sig\n type t [@@deriving of_sexp]\n end\n with type t := Elt.t) =\n struct\n let t_of_sexp sexp =\n Tree.t_of_sexp_direct X.t_of_sexp sexp ~comparator:Elt_S1.comparator\n ;;\n end\n end\nend\n\nmodule Make_plain (Elt : Elt_plain) = Make_plain_using_comparator (struct\n include Elt\n include Comparator.Make (Elt)\n end)\n\nmodule Make_using_comparator (Elt_sexp : sig\n type t [@@deriving sexp]\n\n include Comparator.S with type t := t\n end) =\nstruct\n include Make_plain_using_comparator (Elt_sexp)\n module Elt = Elt_sexp\n include Provide_of_sexp (Elt)\n\n module Tree = struct\n include Tree\n include Provide_of_sexp (Elt)\n end\nend\n\nmodule Make (Elt : Elt) = Make_using_comparator (struct\n include Elt\n include Comparator.Make (Elt)\n end)\n\nmodule Make_binable_using_comparator (Elt_bin_sexp : sig\n type t [@@deriving bin_io, sexp]\n\n include Comparator.S with type t := t\n end) =\nstruct\n include Make_using_comparator (Elt_bin_sexp)\n module Elt = Elt_bin_sexp\n include Provide_bin_io (Elt)\nend\n\nmodule Make_binable (Elt : Elt_binable) = Make_binable_using_comparator (struct\n include Elt\n include Comparator.Make (Elt)\n end)\n\nmodule For_deriving = struct\n module M = Set.M\n\n let bin_shape_m__t (type t c) (m : (t, c) Elt_bin_io.t) =\n let module M = Provide_bin_io ((val m)) in\n M.bin_shape_t\n ;;\n\n let bin_size_m__t (type t c) (m : (t, c) Elt_bin_io.t) =\n let module M = Provide_bin_io ((val m)) in\n M.bin_size_t\n ;;\n\n let bin_write_m__t (type t c) (m : (t, c) Elt_bin_io.t) =\n let module M = Provide_bin_io ((val m)) in\n M.bin_write_t\n ;;\n\n let bin_read_m__t (type t c) (m : (t, c) Elt_bin_io.t) =\n let module M = Provide_bin_io ((val m)) in\n M.bin_read_t\n ;;\n\n let __bin_read_m__t__ (type t c) (m : (t, c) Elt_bin_io.t) =\n let module M = Provide_bin_io ((val m)) in\n M.__bin_read_t__\n ;;\n\n module type Quickcheck_generator_m = sig\n include Comparator.S\n\n val quickcheck_generator : t Quickcheck.Generator.t\n end\n\n module type Quickcheck_observer_m = sig\n include Comparator.S\n\n val quickcheck_observer : t Quickcheck.Observer.t\n end\n\n module type Quickcheck_shrinker_m = sig\n include Comparator.S\n\n val quickcheck_shrinker : t Quickcheck.Shrinker.t\n end\n\n let quickcheck_generator_m__t\n (type t cmp)\n (module Elt : Quickcheck_generator_m\n with type t = t\n and type comparator_witness = cmp)\n =\n quickcheck_generator (module Elt) Elt.quickcheck_generator\n ;;\n\n let quickcheck_observer_m__t\n (type t cmp)\n (module Elt : Quickcheck_observer_m\n with type t = t\n and type comparator_witness = cmp)\n =\n quickcheck_observer Elt.quickcheck_observer\n ;;\n\n let quickcheck_shrinker_m__t\n (type t cmp)\n (module Elt : Quickcheck_shrinker_m\n with type t = t\n and type comparator_witness = cmp)\n =\n quickcheck_shrinker Elt.quickcheck_shrinker\n ;;\n\n module type For_deriving = Set.For_deriving\n\n include (Set : For_deriving with type ('a, 'b) t := ('a, 'b) t)\nend\n\ninclude For_deriving\n\nmodule Stable = struct\n module V1 = struct\n type nonrec ('a, 'cmp) t = ('a, 'cmp) t\n\n module type S = sig\n type elt\n type elt_comparator_witness\n type nonrec t = (elt, elt_comparator_witness) t\n\n include Stable_module_types.S0_without_comparator with type t := t\n end\n\n include For_deriving\n module Make (Elt : Stable_module_types.S0) = Make_binable_using_comparator (Elt)\n end\nend\n","open! Import\nmodule List = Base.List\ninclude Comparable_intf\nmodule Infix = Base.Comparable.Infix\nmodule Polymorphic_compare = Base.Comparable.Polymorphic_compare\nmodule Validate = Base.Comparable.Validate\n\nmodule With_zero (T : sig\n type t [@@deriving compare, sexp]\n\n val zero : t\n\n include Validate with type t := t\n end) =\n Base.Comparable.With_zero (T)\n\nmodule Validate_with_zero (T : sig\n type t [@@deriving compare, sexp]\n\n val zero : t\n end) =\n Base.Comparable.Validate_with_zero (T)\n\nmodule Map_and_set_binable_using_comparator (T : sig\n type t [@@deriving bin_io, compare, sexp]\n\n include Comparator.S with type t := t\n end) =\nstruct\n include T\n module Map = Map.Make_binable_using_comparator (T)\n module Set = Set.Make_binable_using_comparator (T)\nend\n\nmodule Map_and_set_binable (T : sig\n type t [@@deriving bin_io, compare, sexp]\n end) =\n Map_and_set_binable_using_comparator (struct\n include T\n include Comparator.Make (T)\n end)\n\nmodule Poly (T : sig\n type t [@@deriving sexp]\n end) =\nstruct\n module C = struct\n include T\n include Base.Comparable.Poly (T)\n end\n\n include C\n module Replace_polymorphic_compare : Polymorphic_compare with type t := t = C\n module Map = Map.Make_using_comparator (C)\n module Set = Set.Make_using_comparator (C)\nend\n\nmodule Make_plain_using_comparator (T : sig\n type t [@@deriving sexp_of]\n\n include Comparator.S with type t := t\n end) : S_plain with type t := T.t and type comparator_witness = T.comparator_witness =\nstruct\n include T\n module M = Base.Comparable.Make_using_comparator (T)\n include M\n module Replace_polymorphic_compare : Polymorphic_compare with type t := t = M\n module Map = Map.Make_plain_using_comparator (T)\n module Set = Set.Make_plain_using_comparator (T)\nend\n\nmodule Make_plain (T : sig\n type t [@@deriving compare, sexp_of]\n end) =\n Make_plain_using_comparator (struct\n include T\n include Comparator.Make (T)\n end)\n\nmodule Make_using_comparator (T : sig\n type t [@@deriving sexp]\n\n include Comparator.S with type t := t\n end) : S with type t := T.t and type comparator_witness = T.comparator_witness = struct\n include T\n module M = Base.Comparable.Make_using_comparator (T)\n include M\n module Replace_polymorphic_compare : Polymorphic_compare with type t := t = M\n module Map = Map.Make_using_comparator (T)\n module Set = Set.Make_using_comparator (T)\nend\n\nmodule Make (T : sig\n type t [@@deriving compare, sexp]\n end) : S with type t := T.t = Make_using_comparator (struct\n include T\n include Comparator.Make (T)\n end)\n\nmodule Make_binable_using_comparator (T : sig\n type t [@@deriving bin_io, sexp]\n\n include Comparator.S with type t := t\n end) =\nstruct\n include T\n module M = Base.Comparable.Make_using_comparator (T)\n include M\n module Replace_polymorphic_compare : Polymorphic_compare with type t := t = M\n module Map = Map.Make_binable_using_comparator (T)\n module Set = Set.Make_binable_using_comparator (T)\nend\n\nmodule Make_binable (T : sig\n type t [@@deriving bin_io, compare, sexp]\n end) =\n Make_binable_using_comparator (struct\n include T\n include Comparator.Make (T)\n end)\n\nmodule Extend\n (M : Base.Comparable.S) (X : sig\n type t = M.t [@@deriving sexp]\n end) =\nstruct\n module T = struct\n include M\n\n include (\n X :\n sig\n type t = M.t [@@deriving sexp]\n end\n with type t := t)\n end\n\n include T\n module Replace_polymorphic_compare : Comparisons.S with type t := t = M\n module Map = Map.Make_using_comparator (T)\n module Set = Set.Make_using_comparator (T)\nend\n\nmodule Extend_binable\n (M : Base.Comparable.S) (X : sig\n type t = M.t [@@deriving bin_io, sexp]\n end) =\nstruct\n module T = struct\n include M\n\n include (\n X :\n sig\n type t = M.t [@@deriving bin_io, sexp]\n end\n with type t := t)\n end\n\n include T\n module Replace_polymorphic_compare : Comparisons.S with type t := t = M\n module Map = Map.Make_binable_using_comparator (T)\n module Set = Set.Make_binable_using_comparator (T)\nend\n\nmodule Inherit (C : sig\n type t [@@deriving compare]\n end) (T : sig\n type t [@@deriving sexp]\n\n val component : t -> C.t\n end) =\n Make (struct\n type t = T.t [@@deriving sexp]\n\n let compare t t' = C.compare (T.component t) (T.component t')\n end)\n\nlet lexicographic = Base.Comparable.lexicographic\nlet lift = Base.Comparable.lift\nlet reverse = Base.Comparable.reverse\n\nmodule Stable = struct\n module V1 = struct\n module type S = sig\n type comparable\n type comparator_witness\n\n module Map :\n Map.Stable.V1.S\n with type key := comparable\n with type comparator_witness := comparator_witness\n\n module Set :\n Set.Stable.V1.S\n with type elt := comparable\n with type elt_comparator_witness := comparator_witness\n end\n\n module Make (X : Stable_module_types.S0) = struct\n module Map = Map.Stable.V1.Make (X)\n module Set = Set.Stable.V1.Make (X)\n end\n end\nend\n","(** Doubly-linked lists.\n\n Compared to other doubly-linked lists, in this one:\n\n 1. Calls to modification functions ([insert*], [move*], ...) detect if the list is\n being iterated over ([iter], [fold], ...), and if so raise an exception. For example,\n a use like the following would raise:\n\n {[\n iter t ~f:(fun _ -> ... remove t e ...)\n ]}\n\n 2. There is a designated \"front\" and \"back\" of each list, rather than viewing each\n element as an equal in a ring.\n\n 3. Elements know which list they're in. Each operation that takes an [Elt.t] also\n takes a [t], first checks that the [Elt] belongs to the [t], and if not, raises.\n\n 4. Related to (3), lists cannot be split, though a sort of splicing is available as\n [transfer]. In other words, no operation will cause one list to become two. This\n makes this module unsuitable for maintaining the faces of a planar graph under edge\n insertion and deletion, for example.\n\n 5. Another property permitted by (3) and (4) is that [length] is O(1).\n*)\n\nopen! Import\n\nmodule type S = sig\n module Elt : sig\n type 'a t\n\n val value : 'a t -> 'a\n\n (** pointer equality *)\n val equal : 'a t -> 'a t -> bool\n\n val set : 'a t -> 'a -> unit\n val sexp_of_t : ('a -> Base.Sexp.t) -> 'a t -> Base.Sexp.t\n end\n\n type 'a t [@@deriving compare, sexp]\n\n include Container.S1 with type 'a t := 'a t\n include Invariant.S1 with type 'a t := 'a t\n\n (** {2 Creating doubly-linked lists} *)\n\n val create : unit -> 'a t\n\n (** [of_list l] returns a doubly-linked list [t] with the same elements as [l] and in the\n same order (i.e., the first element of [l] is the first element of [t]). It is always\n the case that [l = to_list (of_list l)]. *)\n val of_list : 'a list -> 'a t\n\n val of_array : 'a array -> 'a t\n\n (** {2 Predicates} *)\n\n (** pointer equality *)\n val equal : 'a t -> 'a t -> bool\n\n val is_first : 'a t -> 'a Elt.t -> bool\n val is_last : 'a t -> 'a Elt.t -> bool\n val mem_elt : 'a t -> 'a Elt.t -> bool\n\n (** {2 Constant-time extraction of first and last elements} *)\n\n val first_elt : 'a t -> 'a Elt.t option\n val last_elt : 'a t -> 'a Elt.t option\n val first : 'a t -> 'a option\n val last : 'a t -> 'a option\n\n (** {2 Constant-time retrieval of next or previous element} *)\n\n val next : 'a t -> 'a Elt.t -> 'a Elt.t option\n val prev : 'a t -> 'a Elt.t -> 'a Elt.t option\n\n (** {2 Constant-time insertion of a new element} *)\n\n val insert_before : 'a t -> 'a Elt.t -> 'a -> 'a Elt.t\n val insert_after : 'a t -> 'a Elt.t -> 'a -> 'a Elt.t\n val insert_first : 'a t -> 'a -> 'a Elt.t\n val insert_last : 'a t -> 'a -> 'a Elt.t\n\n (** {2 Constant-time move of an element from and to positions in the same list}\n\n An exception is raised if [elt] is equal to [anchor]. *)\n\n val move_to_front : 'a t -> 'a Elt.t -> unit\n val move_to_back : 'a t -> 'a Elt.t -> unit\n val move_after : 'a t -> 'a Elt.t -> anchor:'a Elt.t -> unit\n val move_before : 'a t -> 'a Elt.t -> anchor:'a Elt.t -> unit\n\n (** {2 Constant-time removal of an element} *)\n\n val remove : 'a t -> 'a Elt.t -> unit\n val remove_first : 'a t -> 'a option\n val remove_last : 'a t -> 'a option\n val iteri : 'a t -> f:(int -> 'a -> unit) -> unit\n val foldi : 'a t -> init:'b -> f:(int -> 'b -> 'a -> 'b) -> 'b\n\n (** [fold_elt t ~init ~f] is the same as fold, except [f] is called with the ['a Elt.t]'s\n from the list instead of the contained ['a] values.\n\n Note that like other iteration functions, it is an error to mutate [t] inside the\n fold. If you'd like to call [remove] on any of the ['a Elt.t]'s, use\n [filter_inplace]. *)\n val fold_elt : 'a t -> init:'b -> f:('b -> 'a Elt.t -> 'b) -> 'b\n\n val foldi_elt : 'a t -> init:'b -> f:(int -> 'b -> 'a Elt.t -> 'b) -> 'b\n val iter_elt : 'a t -> f:('a Elt.t -> unit) -> unit\n val iteri_elt : 'a t -> f:(int -> 'a Elt.t -> unit) -> unit\n\n\n val fold_right : 'a t -> init:'b -> f:('a -> 'b -> 'b) -> 'b\n val fold_right_elt : 'a t -> init:'b -> f:('a Elt.t -> 'b -> 'b) -> 'b\n\n (** [find_elt t ~f] finds the first element in [t] that satisfies [f], by testing each of\n element of [t] in turn until [f] succeeds. *)\n val find_elt : 'a t -> f:('a -> bool) -> 'a Elt.t option\n\n val findi_elt : 'a t -> f:(int -> 'a -> bool) -> (int * 'a Elt.t) option\n\n (** [clear t] removes all elements from the list in constant time. *)\n val clear : 'a t -> unit\n\n val copy : 'a t -> 'a t\n\n (** [transfer ~src ~dst] has the same behavior as\n [iter src ~f:(insert_last dst); clear src] except that it runs in constant time.\n\n If [s = to_list src] and [d = to_list dst], then after [transfer ~src ~dst]:\n\n [to_list src = []]\n\n [to_list dst = d @ s] *)\n val transfer : src:'a t -> dst:'a t -> unit\n\n (** {2 Linear-time mapping of lists (creates a new list)} *)\n\n val map : 'a t -> f:('a -> 'b) -> 'b t\n val mapi : 'a t -> f:(int -> 'a -> 'b) -> 'b t\n val filter : 'a t -> f:('a -> bool) -> 'a t\n val filteri : 'a t -> f:(int -> 'a -> bool) -> 'a t\n val filter_map : 'a t -> f:('a -> 'b option) -> 'b t\n val filter_mapi : 'a t -> f:(int -> 'a -> 'b option) -> 'b t\n\n (** {2 Linear-time partition of lists (creates two new lists)} *)\n\n val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t\n val partitioni_tf : 'a t -> f:(int -> 'a -> bool) -> 'a t * 'a t\n val partition_map : 'a t -> f:('a -> ('b, 'c) Either.t) -> 'b t * 'c t\n val partition_mapi : 'a t -> f:(int -> 'a -> ('b, 'c) Either.t) -> 'b t * 'c t\n\n (** {2 Linear-time in-place mapping of lists} *)\n\n (** [map_inplace t ~f] replaces all values [v] with [f v] *)\n val map_inplace : 'a t -> f:('a -> 'a) -> unit\n\n val mapi_inplace : 'a t -> f:(int -> 'a -> 'a) -> unit\n\n (** [filter_inplace t ~f] removes all elements of [t] that don't satisfy [f]. *)\n val filter_inplace : 'a t -> f:('a -> bool) -> unit\n\n val filteri_inplace : 'a t -> f:(int -> 'a -> bool) -> unit\n\n (** If [f] returns [None], the element is removed, else the value is replaced with the\n contents of the [Some] *)\n val filter_map_inplace : 'a t -> f:('a -> 'a option) -> unit\n\n val filter_mapi_inplace : 'a t -> f:(int -> 'a -> 'a option) -> unit\n\n (** [unchecked_iter t ~f] behaves like [iter t ~f] except that [f] is allowed to modify\n [t]. Adding or removing elements before the element currently being visited has no\n effect on the traversal. Elements added after the element currently being visited\n will be traversed. Elements deleted after the element currently being visited will\n not be traversed. Deleting the element currently being visited is an error that is not\n detected (presumably leading to an infinite loop). *)\n val unchecked_iter : 'a t -> f:('a -> unit) -> unit\n\n\n (** A sequence of values from the doubly-linked list. It makes an intermediate copy of the\n list so that the returned sequence is immune to any subsequent mutation of the\n original list. *)\n val to_sequence : 'a t -> 'a Sequence.t\nend\n\nmodule type Doubly_linked = sig\n module type S = S\n\n include S\nend\n","include List0 (** @inline *)\n\n(** [stable_dedup] Same as [dedup] but maintains the order of the list and doesn't allow\n compare function to be specified (otherwise, the implementation in terms of Set.t\n would hide a heavyweight functor instantiation at each call). *)\nlet stable_dedup = Set.Poly.stable_dedup_list\n\n(* This function is staged to indicate that real work (the functor application) takes\n place after a partial application. *)\nlet stable_dedup_staged (type a) ~(compare : a -> a -> int)\n : (a list -> a list) Base.Staged.t\n =\n let module Set =\n Set.Make (struct\n type t = a\n\n let compare = compare\n\n (* [stable_dedup_list] never calls these *)\n let t_of_sexp _ = assert false\n let sexp_of_t _ = assert false\n end)\n in\n Base.Staged.stage Set.stable_dedup_list\n;;\n\nlet zip_with_remainder =\n let rec zip_with_acc_and_remainder acc xs ys =\n match xs, ys with\n | [], [] -> rev acc, None\n | fst, [] -> rev acc, Some (Either.First fst)\n | [], snd -> rev acc, Some (Either.Second snd)\n | x :: xs, y :: ys -> zip_with_acc_and_remainder ((x, y) :: acc) xs ys\n in\n fun xs ys -> zip_with_acc_and_remainder [] xs ys\n;;\n\ntype sexp_thunk = unit -> Base.Sexp.t\n\nlet sexp_of_sexp_thunk x = x ()\n\nexception Duplicate_found of sexp_thunk * Base.String.t [@@deriving sexp]\n\nlet exn_if_dup ~compare ?(context = \"exn_if_dup\") t ~to_sexp =\n match find_a_dup ~compare t with\n | None -> ()\n | Some dup -> raise (Duplicate_found ((fun () -> to_sexp dup), context))\n;;\n\nlet slice a start stop =\n Ordered_collection_common.slice ~length_fun:length ~sub_fun:sub a start stop\n;;\n\nmodule Stable = struct\n module V1 = struct\n type nonrec 'a t = 'a t [@@deriving sexp, bin_io, compare]\n end\nend\n","open! Import\ninclude Base.Option\n\ntype 'a t = 'a option [@@deriving bin_io, typerep]\n\ninclude Comparator.Derived (struct\n type nonrec 'a t = 'a t [@@deriving sexp_of, compare]\n end)\n\nlet quickcheck_generator = Base_quickcheck.Generator.option\nlet quickcheck_observer = Base_quickcheck.Observer.option\nlet quickcheck_shrinker = Base_quickcheck.Shrinker.option\n\nmodule Stable = struct\n module V1 = struct\n type nonrec 'a t = 'a t [@@deriving bin_io, compare, equal, sexp]\n end\nend\n\nmodule Optional_syntax = struct\n module Optional_syntax = struct\n let is_none = is_none\n\n (* [unsafe_value] is only safe to call when [is_none] returns [false]. To avoid\n repeating the [is_none] check, we declare [Unchecked_some]. [Unchecked_some x]\n has the same representation as [Some x], but the type has no [None] clause.\n\n We make sure all this works with tests of [unsafe_value] in test_option.ml.\n\n We tried using [Obj.field] instead. It generates much worse native code due to\n float array representations. *)\n\n module Unchecked_some = struct\n (* Warning 37 tells us [Unchecked_some] is never used as a constructor. This is\n intentional, so we disable the warning. *)\n type 'a t = Unchecked_some of 'a [@@ocaml.boxed] [@@ocaml.warning \"-37\"]\n end\n\n let unsafe_value (type a) (t : a t) : a =\n let (Unchecked_some value) = (Obj.magic t : a Unchecked_some.t) in\n value\n ;;\n end\nend\n","(* This code is based on the MLton library set/disjoint.fun, which has the\n following copyright notice.\n*)\n(* Copyright (C) 1999-2005 Henry Cejtin, Matthew Fluet, Suresh\n * Jagannathan, and Stephen Weeks.\n *\n * MLton is released under a BSD-style license.\n * See the file MLton-LICENSE for details.\n*)\n\nopen! Import\n\n(*\n {v\n Root\n |\n Inner\n / .. | .. \\\n Inner Inner Inner\n /|\\ /|\\ /|\\\n ... ... ...\n v}\n\n We construct the `inverted' tree in the ML representation.\n The direction of the edges is UPWARDS.\n Starting with any ['a t] we can step directly to its parent.\n But we can't (and don't need to) start from the root and step to its children.\n*)\n\n(*\n [rank] is an upper bound on the depth of any node in the up-tree.\n\n Imagine an unlucky sequence of operations in which you create N\n individual [t]-values and then union them together in such a way\n that you always pick the root of each tree to union together, so that\n no path compression takes place. If you don't take care to somehow\n balance the resulting up-tree, it is possible that you end up with one\n big long chain of N links, and then calling [representative] on the\n deepest node takes Theta(N) time. With the balancing scheme of never\n increasing the rank of a node unnecessarily, it would take O(log N).\n*)\ntype 'a root =\n { mutable value : 'a\n ; mutable rank : int\n }\n\ntype 'a t = { mutable node : 'a node }\n\nand 'a node =\n | Inner of 'a t\n (* [Inner x] is a node whose parent is [x]. *)\n | Root of 'a root\n\nlet invariant _ t =\n let rec loop t depth =\n match t.node with\n | Inner t -> loop t (depth + 1)\n | Root r -> assert (depth <= r.rank)\n in\n loop t 0\n;;\n\nlet create v = { node = Root { value = v; rank = 0 } }\n\n(* invariants:\n [inner.node] = [inner_node] = [Inner t].\n [descendants] are the proper descendants of [inner] we've visited.\n*)\nlet rec compress t ~inner_node ~inner ~descendants =\n match t.node with\n | Root r ->\n (* t is the root of the tree.\n Re-point all descendants directly to it by setting them to [Inner t].\n Note: we don't re-point [inner] as it already points there. *)\n List.iter descendants ~f:(fun t -> t.node <- inner_node);\n t, r\n | Inner t' as node ->\n compress t' ~inner_node:node ~inner:t ~descendants:(inner :: descendants)\n;;\n\nlet representative t =\n match t.node with\n | Root r -> t, r\n | Inner t' as node -> compress t' ~inner_node:node ~inner:t ~descendants:[]\n;;\n\nlet root t =\n match t.node with\n | Root r ->\n (* avoid tuple allocation in the fast path *)\n r\n | _ -> snd (representative t)\n;;\n\nlet rank t = (root t).rank\nlet get t = (root t).value\nlet set t v = (root t).value <- v\nlet same_class t1 t2 = phys_equal (root t1) (root t2)\n\nlet union t1 t2 =\n let t1, r1 = representative t1 in\n let t2, r2 = representative t2 in\n if phys_equal r1 r2\n then ()\n else (\n let n1 = r1.rank in\n let n2 = r2.rank in\n if n1 < n2\n then t1.node <- Inner t2\n else (\n t2.node <- Inner t1;\n if n1 = n2 then r1.rank <- r1.rank + 1))\n;;\n\nlet is_compressed t =\n invariant ignore t;\n match t.node with\n | Root _ -> true\n | Inner t ->\n (match t.node with\n | Root _ -> true\n | Inner _ -> false)\n;;\n\nmodule Private = struct\n let is_compressed = is_compressed\n let rank = rank\nend\n","open! Import\ninclude Doubly_linked_intf\n\n(* INVARIANT: This exception is raised if a list is mutated during a pending iteration.\n\n This invariant is guaranteed by the Header and Elt modules in conjunction. All\n downstream code in this module need not be concerned with this invariant.\n*)\nexception Attempt_to_mutate_list_during_iteration\n\nlet phys_equal = ( == )\n\nmodule Header : sig\n type t\n\n val create : unit -> t\n val length : t -> int\n val equal : t -> t -> bool\n val incr_length : by:int -> t -> unit\n val check_no_pending_iterations : t -> unit\n\n (* Unfortunate, but by specializing [with_iteration] for different arities, a large\n amount of allocation during folds and iterations is avoided.\n\n The original type of [with_iteration] was\n [val with_iteration : t -> (unit -> 'a) -> 'a]\n\n The difference between\n {[\n let x = e in\n let f () = g x in\n f ()\n ]}\n and\n {[\n let x = e in\n let f x = g x in\n f x\n ]}\n is that in the first case the closure for [f] contains a pointer to [x],\n and in the second case it doesn't. A closure without pointers to enclosing\n environment is implemented as a naked function pointer, so we don't\n allocate at all.\n\n For the same reason we make sure not to call [Result.try_with (fun () -> ...)]\n inside [with_iteration] and do an explicit match statement instead. *)\n\n val with_iteration_2 : t -> 'a -> 'b -> ('a -> 'b -> 'c) -> 'c\n val with_iteration_3 : t -> 'a -> 'b -> 'c -> ('a -> 'b -> 'c -> 'd) -> 'd\n val with_iteration_4 : t -> 'a -> 'b -> 'c -> 'd -> ('a -> 'b -> 'c -> 'd -> 'e) -> 'e\n val merge : t -> t -> [ `Same_already | `Merged ]\nend = struct\n type s =\n { mutable length : int\n ;\n mutable pending_iterations : int\n }\n\n type t = s Union_find.t\n\n let create () = Union_find.create { length = 1; pending_iterations = 0 }\n let equal (t1 : t) t2 = Union_find.same_class t1 t2\n let length t = (Union_find.get t).length\n\n let union_find_get__check_no_pending_iterations t =\n let s = Union_find.get t in\n if s.pending_iterations > 0 then raise Attempt_to_mutate_list_during_iteration else s\n ;;\n\n let check_no_pending_iterations t =\n ignore (union_find_get__check_no_pending_iterations t : s)\n ;;\n\n let incr_length ~by:n t =\n let s = union_find_get__check_no_pending_iterations t in\n s.length <- s.length + n\n ;;\n\n (* Care is taken not to allocate in [with_iteration_*], since it is called every second\n by [every_second] in [writer0.ml] *)\n\n let incr_pending_iters s = s.pending_iterations <- s.pending_iterations + 1\n let decr_pending_iters s = s.pending_iterations <- s.pending_iterations - 1\n\n let with_iteration_2 t a b f =\n let s = Union_find.get t in\n incr_pending_iters s;\n match f a b with\n | exception exn ->\n decr_pending_iters s;\n raise exn\n | r ->\n decr_pending_iters s;\n r\n ;;\n\n let with_iteration_3 t a b c f =\n let s = Union_find.get t in\n incr_pending_iters s;\n match f a b c with\n | exception exn ->\n decr_pending_iters s;\n raise exn\n | r ->\n decr_pending_iters s;\n r\n ;;\n\n let with_iteration_4 t a b c d f =\n let s = Union_find.get t in\n incr_pending_iters s;\n match f a b c d with\n | exception exn ->\n decr_pending_iters s;\n raise exn\n | r ->\n decr_pending_iters s;\n r\n ;;\n\n let merge (t1 : t) t2 =\n if Union_find.same_class t1 t2\n then `Same_already\n else (\n let n1 = (union_find_get__check_no_pending_iterations t1).length in\n let n2 = (union_find_get__check_no_pending_iterations t2).length in\n with_iteration_4 t1 t1 t2 n1 n2 (fun t1 t2 n1 n2 ->\n with_iteration_4 t2 t1 t2 n1 n2 (fun t1 t2 n1 n2 ->\n Union_find.union t1 t2;\n Union_find.set t1 { length = n1 + n2; pending_iterations = 0 }));\n `Merged)\n ;;\nend\n\nmodule Elt : sig\n type 'a t [@@deriving sexp_of]\n\n val header : 'a t -> Header.t\n val equal : 'a t -> 'a t -> bool\n val create : 'a -> 'a t\n val value : 'a t -> 'a\n val set : 'a t -> 'a -> unit\n val unlink : 'a t -> unit\n val split_or_splice_before : 'a t -> 'a t -> unit\n val split_or_splice_after : 'a t -> 'a t -> unit\n val insert_after : 'a t -> 'a -> 'a t\n val insert_before : 'a t -> 'a -> 'a t\n val unlink_before : 'a t -> 'a t\n val next : 'a t -> 'a t\n val prev : 'a t -> 'a t\nend = struct\n type 'a t =\n { mutable value : 'a\n ; mutable prev : 'a t\n ; mutable next : 'a t\n ; mutable header : Header.t\n }\n\n let equal = phys_equal\n let next t = t.next\n let prev t = t.prev\n let header t = t.header\n\n let create_aux v header =\n let rec t = { value = v; prev = t; next = t; header } in\n t\n ;;\n\n let is_singleton t = equal t t.prev\n let sexp_of_t sexp_of_a t = sexp_of_a t.value\n let create v = create_aux v (Header.create ())\n let value t = t.value\n let set t v = t.value <- v\n\n (*\n [split_or_splice] is sufficient as the lone primitive for\n accomplishing all pointer updates on cyclic loops of list nodes.\n It takes two \"gaps\" between adjacent linked list nodes. If the gaps\n point into the same list, the result is that it will be split into\n two lists afterwards. If the gaps point into different lists, the\n result is that they will be spliced together into one list afterwards.\n\n {v\n Before After\n -----+ +----- -----+ +-----\n A | <--> | B A | <--- ---> | B\n -----+ +----- -----+ \\ / +-----\n X\n -----+ +----- -----+ / \\ +-----\n C | <--> | D C | <--- ---> | D\n -----+ +----- -----+ +-----\n v} *)\n\n let unsafe_split_or_splice ~prev1:a ~next1:b ~prev2:c ~next2:d =\n a.next <- d;\n d.prev <- a;\n c.next <- b;\n b.prev <- c\n ;;\n\n let unsafe_split_or_splice_after t1 t2 =\n unsafe_split_or_splice\n ~next1:t1.next\n ~prev1:t1.next.prev\n ~next2:t2.next\n ~prev2:t2.next.prev\n ;;\n\n let unsafe_split_or_splice_before t1 t2 =\n unsafe_split_or_splice\n ~prev1:t1.prev\n ~next1:t1.prev.next\n ~prev2:t2.prev\n ~next2:t2.prev.next\n ;;\n\n let check_two_nodes_no_pending_iterations t1 t2 =\n Header.check_no_pending_iterations t1.header;\n if not (Header.equal t1.header t2.header)\n then Header.check_no_pending_iterations t2.header\n ;;\n\n (* We redefine safe versions for export *)\n let split_or_splice_after t1 t2 =\n check_two_nodes_no_pending_iterations t1 t2;\n unsafe_split_or_splice_after t1 t2\n ;;\n\n let split_or_splice_before t1 t2 =\n check_two_nodes_no_pending_iterations t1 t2;\n unsafe_split_or_splice_before t1 t2\n ;;\n\n let insert_before t v =\n Header.incr_length t.header ~by:1;\n let node = create_aux v t.header in\n unsafe_split_or_splice_before t node;\n node\n ;;\n\n let insert_after t v =\n Header.incr_length t.header ~by:1;\n let node = create_aux v t.header in\n unsafe_split_or_splice_after t node;\n node\n ;;\n\n let dummy_header = Header.create ()\n\n let unlink_before t =\n let node = t.prev in\n if is_singleton node\n then node\n else (\n Header.incr_length t.header ~by:(-1);\n unsafe_split_or_splice_before t node;\n node.header <- dummy_header;\n node)\n ;;\n\n let unlink_after t =\n let node = t.next in\n if is_singleton node\n then node\n else (\n Header.incr_length t.header ~by:(-1);\n unsafe_split_or_splice_after t node;\n node.header <- dummy_header;\n node)\n ;;\n\n let unlink t = ignore (unlink_after t.prev : _ t)\nend\n\ntype 'a t = 'a Elt.t option ref\n\nlet invariant invariant_a t =\n match !t with\n | None -> ()\n | Some head ->\n let header = Elt.header head in\n let rec loop n elt =\n let next_elt = Elt.next elt in\n let prev_elt = Elt.prev elt in\n assert (Elt.equal elt (Elt.prev next_elt));\n assert (Elt.equal elt (Elt.next prev_elt));\n assert (Header.equal (Elt.header elt) header);\n invariant_a (Elt.value elt);\n if Elt.equal next_elt head then n else loop (n + 1) next_elt\n in\n let len = loop 1 head in\n assert (len = Header.length header)\n;;\n\nlet create (type a) () : a t = ref None\nlet equal (t : _ t) t' = phys_equal t t'\n\nlet of_list = function\n | [] -> create ()\n | x :: xs ->\n let first = Elt.create x in\n let _last = List.fold xs ~init:first ~f:Elt.insert_after in\n ref (Some first)\n;;\n\nlet of_array = function\n | [||] -> create ()\n | arr ->\n let first = Elt.create arr.(0) in\n let rec loop arr elt i =\n if i < Array.length arr then loop arr (Elt.insert_after elt arr.(i)) (i + 1)\n in\n loop arr first 1;\n ref (Some first)\n;;\n\nlet map t ~f =\n match !t with\n | None -> create ()\n | Some first ->\n let new_first = Elt.create (f (Elt.value first)) in\n Header.with_iteration_3\n (Elt.header first)\n f\n new_first\n first\n (fun f new_first first ->\n let rec loop f acc first elt =\n let acc = Elt.insert_after acc (f (Elt.value elt)) in\n let next = Elt.next elt in\n if not (phys_equal next first) then loop f acc first next\n in\n (* unroll and skip first elt *)\n let next = Elt.next first in\n if not (phys_equal next first) then loop f new_first first next);\n ref (Some new_first)\n;;\n\nlet mapi t ~f =\n match !t with\n | None -> create ()\n | Some first ->\n let new_first = Elt.create (f 0 (Elt.value first)) in\n Header.with_iteration_3\n (Elt.header first)\n f\n new_first\n first\n (fun f new_first first ->\n let rec loop f i acc first elt =\n let acc = Elt.insert_after acc (f i (Elt.value elt)) in\n let next = Elt.next elt in\n if not (phys_equal next first) then loop f (i + 1) acc first next\n in\n (* unroll and skip first elt *)\n let next = Elt.next first in\n if not (phys_equal next first) then loop f 1 new_first first next);\n ref (Some new_first)\n;;\n\nlet fold_elt t ~init ~f =\n match !t with\n | None -> init\n | Some first ->\n Header.with_iteration_3 (Elt.header first) f init first (fun f init first ->\n let rec loop f acc first elt =\n let acc = f acc elt in\n let next = Elt.next elt in\n if phys_equal next first then acc else loop f acc first next\n in\n loop f init first first)\n;;\n\nlet foldi_elt t ~init ~f =\n match !t with\n | None -> init\n | Some first ->\n Header.with_iteration_3 (Elt.header first) f init first (fun f init first ->\n let rec loop f i acc first elt =\n let acc = f i acc elt in\n let next = Elt.next elt in\n if phys_equal next first then acc else loop f (i + 1) acc first next\n in\n loop f 0 init first first)\n;;\n\nlet fold_elt_1 t ~init ~f a =\n match !t with\n | None -> init\n | Some first ->\n Header.with_iteration_4 (Elt.header first) f a init first (fun f a init first ->\n let rec loop f a acc first elt =\n let acc = f a acc elt in\n let next = Elt.next elt in\n if phys_equal next first then acc else loop f a acc first next\n in\n loop f a init first first)\n;;\n\nlet foldi_elt_1 t ~init ~f a =\n match !t with\n | None -> init\n | Some first ->\n Header.with_iteration_4 (Elt.header first) f a init first (fun f a init first ->\n let rec loop f i a acc first elt =\n let acc = f i a acc elt in\n let next = Elt.next elt in\n if phys_equal next first then acc else loop f (i + 1) a acc first next\n in\n loop f 0 a init first first)\n;;\n\nlet iter_elt t ~f = fold_elt_1 t ~init:() ~f:(fun f () elt -> f elt) f\nlet iteri_elt t ~f = foldi_elt t ~init:() ~f:(fun i () elt -> f i elt)\n\nopen With_return\n\nlet find_elt t ~f =\n with_return (fun r ->\n fold_elt_1 t f ~init:() ~f:(fun f () elt ->\n if f (Elt.value elt) then r.return (Some elt));\n None)\n;;\n\nlet findi_elt t ~f =\n with_return (fun r ->\n foldi_elt_1 t f ~init:() ~f:(fun i f () elt ->\n if f i (Elt.value elt) then r.return (Some (i, elt)));\n None)\n;;\n\n(* this function is lambda lifted for performance, to make direct recursive calls instead\n of calls through its closure. It also avoids the initial closure allocation. *)\nlet rec iter_loop first f elt =\n f (Elt.value elt);\n let next = Elt.next elt in\n if not (phys_equal next first) then iter_loop first f next\n;;\n\nlet iter t ~f =\n match !t with\n | None -> ()\n | Some first ->\n Header.with_iteration_2 (Elt.header first) first f (fun first f ->\n iter_loop first f first)\n;;\n\nlet length t =\n match !t with\n | None -> 0\n | Some first -> Header.length (Elt.header first)\n;;\n\nlet rec iteri_loop first f i elt =\n f i (Elt.value elt);\n let next = Elt.next elt in\n if not (phys_equal next first) then iteri_loop first f (i + 1) next\n;;\n\nlet iteri t ~f =\n match !t with\n | None -> ()\n | Some first ->\n Header.with_iteration_2 (Elt.header first) first f (fun first f ->\n iteri_loop first f 0 first)\n;;\n\nlet foldi t ~init ~f =\n foldi_elt_1 t ~init f ~f:(fun i f acc elt -> f i acc (Elt.value elt))\n;;\n\nmodule C = Container.Make (struct\n type nonrec 'a t = 'a t\n\n let fold t ~init ~f = fold_elt_1 t ~init f ~f:(fun f acc elt -> f acc (Elt.value elt))\n let iter = `Custom iter\n let length = `Custom length\n end)\n\nlet count = C.count\nlet sum = C.sum\nlet exists = C.exists\nlet find = C.find\nlet find_map = C.find_map\nlet fold = C.fold\nlet for_all = C.for_all\nlet mem = C.mem\nlet to_array = C.to_array\nlet min_elt = C.min_elt\nlet max_elt = C.max_elt\nlet fold_result = C.fold_result\nlet fold_until = C.fold_until\n\nlet unchecked_iter t ~f =\n match !t with\n | None -> ()\n | Some first ->\n let rec loop t f elt =\n f (Elt.value elt);\n let next = Elt.next elt in\n match !t with\n (* the first element of the bag may have been changed by [f] *)\n | None -> ()\n | Some first -> if not (phys_equal first next) then loop t f next\n in\n loop t f first\n;;\n\nlet is_empty t = Option.is_none !t\n\n(* more efficient than what Container.Make returns *)\n\nlet fold_right t ~init ~f =\n match !t with\n | None -> init\n | Some first ->\n Header.with_iteration_3 (Elt.header first) f init first (fun f init first ->\n let rec loop f acc elt =\n let prev = Elt.prev elt in\n let acc = f (Elt.value prev) acc in\n if phys_equal prev first then acc else loop f acc prev\n in\n loop f init first)\n;;\n\nlet fold_right_elt t ~init ~f =\n match !t with\n | None -> init\n | Some first ->\n Header.with_iteration_3 (Elt.header first) f init first (fun f init first ->\n let rec loop f acc elt =\n let prev = Elt.prev elt in\n let acc = f prev acc in\n if phys_equal prev first then acc else loop f acc prev\n in\n loop f init first)\n;;\n\nlet to_list t = fold_right t ~init:[] ~f:(fun x tl -> x :: tl)\nlet sexp_of_t sexp_of_a t = List.sexp_of_t sexp_of_a (to_list t)\nlet t_of_sexp a_of_sexp s = of_list (List.t_of_sexp a_of_sexp s)\nlet copy t = of_list (to_list t)\nlet clear t = t := None\n\nlet compare compare_elt t1 t2 =\n match !t1, !t2 with\n | None, None -> 0\n | None, _ -> -1\n | _, None -> 1\n | Some f1, Some f2 ->\n Header.with_iteration_3 (Elt.header f1) compare_elt f1 f2 (fun compare_elt f1 f2 ->\n Header.with_iteration_3\n (Elt.header f2)\n compare_elt\n f1\n f2\n (fun compare_elt f1 f2 ->\n let rec loop compare_elt elt1 f1 elt2 f2 =\n let compare_result = compare_elt (Elt.value elt1) (Elt.value elt2) in\n if compare_result <> 0\n then compare_result\n else (\n let next1 = Elt.next elt1 in\n let next2 = Elt.next elt2 in\n match phys_equal next1 f1, phys_equal next2 f2 with\n | true, true -> 0\n | true, false -> -1\n | false, true -> 1\n | false, false -> loop compare_elt next1 f1 next2 f2)\n in\n loop compare_elt f1 f1 f2 f2))\n;;\n\nexception Transfer_src_and_dst_are_same_list\n\nlet transfer ~src ~dst =\n if phys_equal src dst then raise Transfer_src_and_dst_are_same_list;\n match !src with\n | None -> ()\n | Some src_head ->\n (match !dst with\n | None ->\n dst := Some src_head;\n clear src\n | Some dst_head ->\n (match Header.merge (Elt.header src_head) (Elt.header dst_head) with\n | `Same_already -> raise Transfer_src_and_dst_are_same_list\n | `Merged ->\n Elt.split_or_splice_before dst_head src_head;\n clear src))\n;;\n\nlet map_inplace t ~f = iter_elt t ~f:(fun elt -> Elt.set elt (f (Elt.value elt)))\nlet mapi_inplace t ~f = iteri_elt t ~f:(fun i elt -> Elt.set elt (f i (Elt.value elt)))\n\nlet remove_list t to_remove =\n List.iter to_remove ~f:(fun elt ->\n (match !t with\n | None -> ()\n | Some head ->\n if Elt.equal head elt\n then (\n let next_elt = Elt.next elt in\n t := if Elt.equal head next_elt then None else Some next_elt));\n Elt.unlink elt)\n;;\n\nlet filter_inplace t ~f =\n let to_remove =\n List.rev\n (fold_elt t ~init:[] ~f:(fun elts elt ->\n if f (Elt.value elt) then elts else elt :: elts))\n in\n remove_list t to_remove\n;;\n\nlet filteri_inplace t ~f =\n let to_remove =\n List.rev\n (foldi_elt t ~init:[] ~f:(fun i elts elt ->\n if f i (Elt.value elt) then elts else elt :: elts))\n in\n remove_list t to_remove\n;;\n\nlet filter_map_inplace t ~f =\n let to_remove =\n List.rev\n (fold_elt t ~init:[] ~f:(fun elts elt ->\n match f (Elt.value elt) with\n | None -> elt :: elts\n | Some value ->\n Elt.set elt value;\n elts))\n in\n remove_list t to_remove\n;;\n\nlet filter_mapi_inplace t ~f =\n let to_remove =\n List.rev\n (foldi_elt t ~init:[] ~f:(fun i elts elt ->\n match f i (Elt.value elt) with\n | None -> elt :: elts\n | Some value ->\n Elt.set elt value;\n elts))\n in\n remove_list t to_remove\n;;\n\nexception Elt_does_not_belong_to_list\n\nlet first_elt t = !t\nlet last_elt t = Option.map ~f:Elt.prev !t\nlet first t = Option.map ~f:Elt.value (first_elt t)\nlet last t = Option.map ~f:Elt.value (last_elt t)\n\nlet is_first t elt =\n match !t with\n | None -> raise Elt_does_not_belong_to_list\n | Some first ->\n if Header.equal (Elt.header first) (Elt.header elt)\n then Elt.equal elt first\n else raise Elt_does_not_belong_to_list\n;;\n\nlet is_last t elt =\n match !t with\n | None -> raise Elt_does_not_belong_to_list\n | Some first ->\n if Header.equal (Elt.header first) (Elt.header elt)\n then (\n let last = Elt.prev first in\n Elt.equal elt last)\n else raise Elt_does_not_belong_to_list\n;;\n\nlet mem_elt t elt =\n match !t with\n | None -> false\n | Some first -> Header.equal (Elt.header first) (Elt.header elt)\n;;\n\nlet prev t elt =\n match !t with\n | None -> raise Elt_does_not_belong_to_list\n | Some first ->\n if Elt.equal elt first\n then None\n else if Header.equal (Elt.header first) (Elt.header elt)\n then Some (Elt.prev elt)\n else raise Elt_does_not_belong_to_list\n;;\n\nlet next t elt =\n match !t with\n | None -> raise Elt_does_not_belong_to_list\n | Some first ->\n let last = Elt.prev first in\n if Elt.equal elt last\n then None\n else if Header.equal (Elt.header first) (Elt.header elt)\n then Some (Elt.next elt)\n else raise Elt_does_not_belong_to_list\n;;\n\nlet insert_after t elt v =\n match !t with\n | None -> raise Elt_does_not_belong_to_list\n | Some first ->\n if Header.equal (Elt.header first) (Elt.header elt)\n then Elt.insert_after elt v\n else raise Elt_does_not_belong_to_list\n;;\n\nlet insert_before t elt v =\n match !t with\n | None -> raise Elt_does_not_belong_to_list\n | Some first ->\n if Elt.equal elt first\n then (\n let new_elt = Elt.insert_before first v in\n t := Some new_elt;\n new_elt)\n else if Header.equal (Elt.header first) (Elt.header elt)\n then Elt.insert_before elt v\n else raise Elt_does_not_belong_to_list\n;;\n\nlet insert_empty t v =\n let new_elt = Elt.create v in\n t := Some new_elt;\n new_elt\n;;\n\nlet insert_last t v =\n match !t with\n | None -> insert_empty t v\n | Some first -> Elt.insert_before first v\n;;\n\nlet insert_first t v =\n match !t with\n | None -> insert_empty t v\n | Some first ->\n let new_elt = Elt.insert_before first v in\n t := Some new_elt;\n new_elt\n;;\n\nlet remove_last t =\n match !t with\n | None -> None\n | Some first ->\n let last = Elt.unlink_before first in\n if Elt.equal first last then t := None;\n Some (Elt.value last)\n;;\n\nlet remove_first t =\n match !t with\n | None -> None\n | Some first ->\n let second = Elt.next first in\n Elt.unlink first;\n t := if Elt.equal first second then None else Some second;\n Some (Elt.value first)\n;;\n\nlet remove t elt =\n match !t with\n | None -> raise Elt_does_not_belong_to_list\n | Some first ->\n if Elt.equal elt first\n then ignore (remove_first t : _ option)\n else if Header.equal (Elt.header first) (Elt.header elt)\n then Elt.unlink elt\n else raise Elt_does_not_belong_to_list\n;;\n\nlet filter t ~f =\n let new_t = create () in\n (match !t with\n | None -> ()\n | Some first ->\n Header.with_iteration_3 (Elt.header first) f new_t first (fun f new_t first ->\n let rec loop f new_t first elt =\n if f (Elt.value elt)\n then insert_last new_t (Elt.value elt) |> (ignore : _ Elt.t -> unit);\n let next = Elt.next elt in\n if not (phys_equal next first) then loop f new_t first next\n in\n loop f new_t first first));\n new_t\n;;\n\nlet filteri t ~f =\n let new_t = create () in\n (match !t with\n | None -> ()\n | Some first ->\n Header.with_iteration_3 (Elt.header first) f new_t first (fun f new_t first ->\n let rec loop f i new_t first elt =\n if f i (Elt.value elt)\n then insert_last new_t (Elt.value elt) |> (ignore : _ Elt.t -> unit);\n let next = Elt.next elt in\n if not (phys_equal next first) then loop f (i + 1) new_t first next\n in\n loop f 0 new_t first first));\n new_t\n;;\n\nlet filter_map t ~f =\n let new_t = create () in\n (match !t with\n | None -> ()\n | Some first ->\n Header.with_iteration_3 (Elt.header first) f new_t first (fun f new_t first ->\n let rec loop f new_t first elt =\n (match f (Elt.value elt) with\n | None -> ()\n | Some value -> insert_last new_t value |> (ignore : _ Elt.t -> unit));\n let next = Elt.next elt in\n if not (phys_equal next first) then loop f new_t first next\n in\n loop f new_t first first));\n new_t\n;;\n\nlet filter_mapi t ~f =\n let new_t = create () in\n (match !t with\n | None -> ()\n | Some first ->\n Header.with_iteration_3 (Elt.header first) f new_t first (fun f new_t first ->\n let rec loop f i new_t first elt =\n (match f i (Elt.value elt) with\n | None -> ()\n | Some value -> insert_last new_t value |> (ignore : _ Elt.t -> unit));\n let next = Elt.next elt in\n if not (phys_equal next first) then loop f (i + 1) new_t first next\n in\n loop f 0 new_t first first));\n new_t\n;;\n\nlet partition_tf t ~f =\n let t1 = create () in\n let t2 = create () in\n (match !t with\n | None -> ()\n | Some first ->\n Header.with_iteration_4 (Elt.header first) f t1 t2 first (fun f t1 t2 first ->\n let rec loop f t1 t2 first elt =\n insert_last (if f (Elt.value elt) then t1 else t2) (Elt.value elt)\n |> (ignore : _ Elt.t -> unit);\n let next = Elt.next elt in\n if not (phys_equal next first) then loop f t1 t2 first next\n in\n loop f t1 t2 first first));\n t1, t2\n;;\n\nlet partitioni_tf t ~f =\n let t1 = create () in\n let t2 = create () in\n (match !t with\n | None -> ()\n | Some first ->\n Header.with_iteration_4 (Elt.header first) f t1 t2 first (fun f t1 t2 first ->\n let rec loop f i t1 t2 first elt =\n insert_last (if f i (Elt.value elt) then t1 else t2) (Elt.value elt)\n |> (ignore : _ Elt.t -> unit);\n let next = Elt.next elt in\n if not (phys_equal next first) then loop f (i + 1) t1 t2 first next\n in\n loop f 0 t1 t2 first first));\n t1, t2\n;;\n\nlet partition_map t ~f =\n let t1 = create () in\n let t2 = create () in\n (match !t with\n | None -> ()\n | Some first ->\n Header.with_iteration_4 (Elt.header first) f t1 t2 first (fun f t1 t2 first ->\n let rec loop f t1 t2 first elt =\n (match (f (Elt.value elt) : (_, _) Either.t) with\n | First value -> insert_last t1 value |> (ignore : _ Elt.t -> unit)\n | Second value -> insert_last t2 value |> (ignore : _ Elt.t -> unit));\n let next = Elt.next elt in\n if not (phys_equal next first) then loop f t1 t2 first next\n in\n loop f t1 t2 first first));\n t1, t2\n;;\n\nlet partition_mapi t ~f =\n let t1 = create () in\n let t2 = create () in\n (match !t with\n | None -> ()\n | Some first ->\n Header.with_iteration_4 (Elt.header first) f t1 t2 first (fun f t1 t2 first ->\n let rec loop f i t1 t2 first elt =\n (match (f i (Elt.value elt) : (_, _) Either.t) with\n | First value -> insert_last t1 value |> (ignore : _ Elt.t -> unit)\n | Second value -> insert_last t2 value |> (ignore : _ Elt.t -> unit));\n let next = Elt.next elt in\n if not (phys_equal next first) then loop f (i + 1) t1 t2 first next\n in\n loop f 0 t1 t2 first first));\n t1, t2\n;;\n\nexception Invalid_move__elt_equals_anchor\n\nlet move_before t elt ~anchor =\n if Elt.equal anchor elt then raise Invalid_move__elt_equals_anchor;\n if Header.equal (Elt.header anchor) (Elt.header elt)\n then (\n match !t with\n | None -> raise Elt_does_not_belong_to_list\n | Some first ->\n if Header.equal (Elt.header first) (Elt.header elt)\n then (\n (* unlink [elt] *)\n let after_elt = Elt.next elt in\n Elt.split_or_splice_before elt after_elt;\n let first =\n if Elt.equal first elt\n then (\n t := Some after_elt;\n after_elt)\n else first\n in\n (* splice [elt] in before [anchor] *)\n Elt.split_or_splice_before anchor elt;\n if Elt.equal first anchor then t := Some elt)\n else raise Elt_does_not_belong_to_list)\n else raise Elt_does_not_belong_to_list\n;;\n\nlet move_to_front t elt =\n match !t with\n | None -> raise Elt_does_not_belong_to_list\n | Some first -> if not (Elt.equal elt first) then move_before t elt ~anchor:first\n;;\n\nlet move_after t elt ~anchor =\n if Elt.equal anchor elt then raise Invalid_move__elt_equals_anchor;\n if Header.equal (Elt.header anchor) (Elt.header elt)\n then (\n match !t with\n | None -> raise Elt_does_not_belong_to_list\n | Some first ->\n if Header.equal (Elt.header first) (Elt.header elt)\n then (\n (* unlink [elt] *)\n let after_elt = Elt.next elt in\n Elt.split_or_splice_before elt after_elt;\n if Elt.equal first elt then t := Some after_elt;\n (* splice [elt] in after [anchor] *)\n Elt.split_or_splice_after anchor elt)\n else raise Elt_does_not_belong_to_list)\n else raise Elt_does_not_belong_to_list\n;;\n\nlet move_to_back t elt =\n match !t with\n | None -> raise Elt_does_not_belong_to_list\n | Some first ->\n let last = Elt.prev first in\n if not (Elt.equal elt last) then move_after t elt ~anchor:last\n;;\n\nlet to_sequence t = to_list t |> Sequence.of_list\n","open! Import\ninclude Bag_intf\ninclude (Doubly_linked : Doubly_linked.S)\n\nlet add = insert_first\nlet add_unit t v = add t v |> (ignore : _ Elt.t -> unit)\nlet elts t = fold_elt t ~init:[] ~f:(fun acc elt -> elt :: acc)\nlet remove_one = remove_first\nlet choose = first_elt\n\nlet until_empty t f =\n let rec loop () =\n Option.iter (remove_one t) ~f:(fun v ->\n f v;\n loop ())\n in\n loop ()\n;;\n","open! Import\n\nmodule Stable = struct\n module V1 = struct\n type t = Base.Sexp.t =\n | Atom of string\n | List of t list\n [@@deriving bin_io, compare, hash]\n\n let t_of_sexp = Sexplib.Sexp.t_of_sexp\n let sexp_of_t = Sexplib.Sexp.sexp_of_t\n end\nend\n\ninclude Stable.V1\n\ninclude (\n Base.Sexp :\n module type of struct\n include Base.Sexp\n end\n with type t := t)\n\ninclude (\n Sexplib.Sexp :\n module type of struct\n include Sexplib.Sexp\n end\n with type t := t)\n\nmodule O = struct\n type sexp = Base.Sexp.t =\n | Atom of string\n | List of t list\nend\n\nmodule Sexp_maybe = struct\n type nonrec 'a t = ('a, t * Error.t) Result.t [@@deriving bin_io, compare, hash]\n\n let sexp_of_t sexp_of_a t =\n match t with\n | Result.Ok a -> sexp_of_a a\n | Result.Error (sexp, err) ->\n List [ Atom \"sexp_parse_error\"; sexp; Error.sexp_of_t err ]\n ;;\n\n let t_of_sexp a_of_sexp sexp =\n match sexp with\n | List [ Atom \"sexp_parse_error\"; sexp; _ ] | sexp ->\n (try Result.Ok (a_of_sexp sexp) with\n | exn -> Result.Error (sexp, Error.of_exn exn))\n ;;\nend\n\nmodule With_text = struct\n open Result.Export\n\n type 'a t =\n { value : 'a\n ; text : string\n }\n [@@deriving bin_io]\n\n let sexp_of_t _ t = Atom t.text\n\n let of_text value_of_sexp ?(filename = \"\") text =\n match Or_error.try_with (fun () -> of_string_conv text value_of_sexp) with\n | Ok (`Result value) -> Ok { value; text }\n | Error _ as err -> err\n | Ok (`Error (exn, annotated)) ->\n Error (Error.of_exn (Annotated.get_conv_exn annotated ~file:filename ~exc:exn))\n ;;\n\n let t_of_sexp a_of_sexp sexp =\n match sexp with\n | List _ ->\n of_sexp_error\n \"With_text.t should be stored as an atom, but instead a list was found.\"\n sexp\n | Atom text -> of_text a_of_sexp text |> Or_error.ok_exn\n ;;\n\n let text t = t.text\n let value t = t.value\n\n let of_value sexp_of_value value =\n let text = sexp_of_value value |> to_string_hum in\n { value; text }\n ;;\nend\n\ntype 'a no_raise = 'a [@@deriving bin_io, sexp]\n\nlet sexp_of_no_raise sexp_of_a a =\n try sexp_of_a a with\n | exn ->\n (try List [ Atom \"failure building sexp\"; sexp_of_exn exn ] with\n | _ -> Atom \"could not build sexp for exn raised when building sexp for value\")\n;;\n\ninclude Comparable.Extend (Base.Sexp) (Base.Sexp)\n\nlet of_sexp_allow_extra_fields_recursively of_sexp sexp =\n let r = Sexplib.Conv.record_check_extra_fields in\n let prev = !r in\n Exn.protect\n ~finally:(fun () -> r := prev)\n ~f:(fun () ->\n r := false;\n of_sexp sexp)\n;;\n\nlet quickcheck_generator = Base_quickcheck.Generator.sexp\nlet quickcheck_observer = Base_quickcheck.Observer.sexp\nlet quickcheck_shrinker = Base_quickcheck.Shrinker.sexp\n","open! Import\nopen Hash_queue_intf\n\nmodule type Key = Key\nmodule type S_backend = S_backend\n\nmodule Make_backend (Table : Hashtbl_intf.Hashtbl) : S_backend = struct\n module type Backend =\n S1\n with type 'key create_arg := 'key Hashtbl.Hashable.t\n with type 'key create_key := 'key\n\n module Backend : Backend = struct\n module Key_value = struct\n module T = struct\n type ('key, 'value) t =\n { key : 'key\n ; mutable value : 'value\n }\n end\n\n include T\n\n let key t = t.key\n let value t = t.value\n\n let sexp_of_t sexp_of_key sexp_of_data { key; value } =\n [%sexp_of: key * data] (key, value)\n ;;\n end\n\n open Key_value.T\n module Elt = Doubly_linked.Elt\n\n type ('key, 'data) t =\n { mutable num_readers : int\n ; queue : ('key, 'data) Key_value.t Doubly_linked.t\n ; table : ('key, ('key, 'data) Key_value.t Elt.t) Table.t\n }\n\n let sexp_of_t sexp_of_key sexp_of_data t =\n [%sexp_of: (key, data) Key_value.t Doubly_linked.t] t.queue\n ;;\n\n let invariant t =\n assert (Doubly_linked.length t.queue = Table.length t.table);\n (* Look at each element in the queue, checking:\n * - every element in the queue is in the hash table\n * - there are no duplicate keys\n *)\n let keys = Table.create ~size:(Table.length t.table) (Table.hashable_s t.table) in\n Doubly_linked.iter t.queue ~f:(fun kv ->\n let key = kv.key in\n match Table.find t.table key with\n | None -> assert false\n | Some _ ->\n assert (not (Table.mem keys key));\n Table.set keys ~key ~data:())\n ;;\n\n let create ?(growth_allowed = true) ?(size = 16) hashable =\n { num_readers = 0\n ; queue = Doubly_linked.create ()\n ; table = Table.create ~growth_allowed ~size (Table.Hashable.to_key hashable)\n }\n ;;\n\n let read t f =\n t.num_readers <- t.num_readers + 1;\n Exn.protect ~f ~finally:(fun () -> t.num_readers <- t.num_readers - 1)\n ;;\n\n let ensure_can_modify t =\n if t.num_readers > 0\n then failwith \"It is an error to modify a Hash_queue.t while iterating over it.\"\n ;;\n\n let clear t =\n ensure_can_modify t;\n Doubly_linked.clear t.queue;\n Table.clear t.table\n ;;\n\n let length t = Table.length t.table\n let is_empty t = length t = 0\n\n let lookup t k =\n match Table.find t.table k with\n | None -> None\n | Some elt -> Some (Elt.value elt).value\n ;;\n\n let lookup_exn t k = (Elt.value (Table.find_exn t.table k)).value\n let mem t k = Table.mem t.table k\n\n (* Note that this is the tail-recursive Core_list.map *)\n let to_list t = List.map (Doubly_linked.to_list t.queue) ~f:Key_value.value\n let to_array t = Array.map (Doubly_linked.to_array t.queue) ~f:Key_value.value\n\n let for_all t ~f =\n read t (fun () -> Doubly_linked.for_all t.queue ~f:(fun kv -> f kv.value))\n ;;\n\n let exists t ~f =\n read t (fun () -> Doubly_linked.exists t.queue ~f:(fun kv -> f kv.value))\n ;;\n\n let find_map t ~f =\n read t (fun () -> Doubly_linked.find_map t.queue ~f:(fun kv -> f kv.value))\n ;;\n\n let find t ~f =\n read t (fun () ->\n Option.map\n (Doubly_linked.find t.queue ~f:(fun kv -> f kv.value))\n ~f:Key_value.value)\n ;;\n\n let enqueue t back_or_front key value =\n ensure_can_modify t;\n if Table.mem t.table key\n then `Key_already_present\n else (\n let contents = { Key_value.key; value } in\n let elt =\n match back_or_front with\n | `back -> Doubly_linked.insert_last t.queue contents\n | `front -> Doubly_linked.insert_first t.queue contents\n in\n Table.set t.table ~key ~data:elt;\n `Ok)\n ;;\n\n let enqueue_back t = enqueue t `back\n let enqueue_front t = enqueue t `front\n\n let raise_enqueue_duplicate_key t key =\n raise_s\n [%message\n \"Hash_queue.enqueue_exn: duplicate key\"\n ~_:(Table.sexp_of_key t.table key : Sexp.t)]\n ;;\n\n let enqueue_exn t back_or_front key value =\n match enqueue t back_or_front key value with\n | `Key_already_present -> raise_enqueue_duplicate_key t key\n | `Ok -> ()\n ;;\n\n let enqueue_back_exn t = enqueue_exn t `back\n let enqueue_front_exn t = enqueue_exn t `front\n\n (* Performance hack: we implement this version separately to avoid allocation from the\n option. *)\n let lookup_and_move_to_back_exn t key =\n ensure_can_modify t;\n let elt = Table.find_exn t.table key in\n Doubly_linked.move_to_back t.queue elt;\n Key_value.value (Elt.value elt)\n ;;\n\n let lookup_and_move_to_back t key =\n let open Option.Let_syntax in\n ensure_can_modify t;\n let%map elt = Table.find t.table key in\n Doubly_linked.move_to_back t.queue elt;\n Key_value.value (Elt.value elt)\n ;;\n\n let lookup_and_move_to_front_exn t key =\n ensure_can_modify t;\n let elt = Table.find_exn t.table key in\n Doubly_linked.move_to_front t.queue elt;\n Key_value.value (Elt.value elt)\n ;;\n\n let lookup_and_move_to_front t key =\n let open Option.Let_syntax in\n ensure_can_modify t;\n let%map elt = Table.find t.table key in\n Doubly_linked.move_to_front t.queue elt;\n Key_value.value (Elt.value elt)\n ;;\n\n let dequeue_with_key t back_or_front =\n ensure_can_modify t;\n let maybe_kv =\n match back_or_front with\n | `back -> Doubly_linked.remove_last t.queue\n | `front -> Doubly_linked.remove_first t.queue\n in\n match maybe_kv with\n | None -> None\n | Some kv ->\n Table.remove t.table kv.key;\n Some (kv.key, kv.value)\n ;;\n\n let raise_dequeue_with_key_empty () =\n raise_s [%message \"Hash_queue.dequeue_with_key: empty queue\"]\n ;;\n\n let dequeue_with_key_exn t back_or_front =\n match dequeue_with_key t back_or_front with\n | None -> raise_dequeue_with_key_empty ()\n | Some (k, v) -> k, v\n ;;\n\n let dequeue_back_with_key t = dequeue_with_key t `back\n let dequeue_back_with_key_exn t = dequeue_with_key_exn t `back\n let dequeue_front_with_key t = dequeue_with_key t `front\n let dequeue_front_with_key_exn t = dequeue_with_key_exn t `front\n\n let dequeue t back_or_front =\n match dequeue_with_key t back_or_front with\n | None -> None\n | Some (_, v) -> Some v\n ;;\n\n let dequeue_back t = dequeue t `back\n let dequeue_front t = dequeue t `front\n\n let first_with_key t =\n match Doubly_linked.first t.queue with\n | None -> None\n | Some { key; value } -> Some (key, value)\n ;;\n\n let first t =\n match Doubly_linked.first t.queue with\n | None -> None\n | Some kv -> Some kv.value\n ;;\n\n let raise_dequeue_empty () = raise_s [%message \"Hash_queue.dequeue_exn: empty queue\"]\n\n let dequeue_exn t back_or_front =\n match dequeue t back_or_front with\n | None -> raise_dequeue_empty ()\n | Some v -> v\n ;;\n\n let dequeue_back_exn t = dequeue_exn t `back\n let dequeue_front_exn t = dequeue_exn t `front\n\n let keys t =\n (* Return the keys in the order of the queue. *)\n List.map (Doubly_linked.to_list t.queue) ~f:Key_value.key\n ;;\n\n let iteri t ~f =\n read t (fun () ->\n Doubly_linked.iter t.queue ~f:(fun kv -> f ~key:kv.key ~data:kv.value))\n ;;\n\n let iter t ~f = iteri t ~f:(fun ~key:_ ~data -> f data)\n\n let foldi t ~init ~f =\n read t (fun () ->\n Doubly_linked.fold t.queue ~init ~f:(fun ac kv ->\n f ac ~key:kv.key ~data:kv.value))\n ;;\n\n let fold t ~init ~f = foldi t ~init ~f:(fun ac ~key:_ ~data -> f ac data)\n let count t ~f = Container.count ~fold t ~f\n let sum m t ~f = Container.sum m ~fold t ~f\n let min_elt t ~compare = Container.min_elt ~fold t ~compare\n let max_elt t ~compare = Container.max_elt ~fold t ~compare\n let fold_result t ~init ~f = Container.fold_result ~fold ~init ~f t\n let fold_until t ~init ~f = Container.fold_until ~fold ~init ~f t\n\n let dequeue_all t ~f =\n let rec loop () =\n match dequeue_front t with\n | None -> ()\n | Some v ->\n f v;\n loop ()\n in\n loop ()\n ;;\n\n let remove t k =\n ensure_can_modify t;\n match Table.find_and_remove t.table k with\n | None -> `No_such_key\n | Some elt ->\n Doubly_linked.remove t.queue elt;\n `Ok\n ;;\n\n let raise_remove_unknown_key t key =\n raise_s\n [%message\n \"Hash_queue.remove_exn: unknown key\"\n ~_:(Table.sexp_of_key t.table key : Sexp.t)]\n ;;\n\n let remove_exn t k =\n ensure_can_modify t;\n match remove t k with\n | `No_such_key -> raise_remove_unknown_key t k\n | `Ok -> ()\n ;;\n\n let lookup_and_remove t k =\n ensure_can_modify t;\n match Table.find_and_remove t.table k with\n | None -> None\n | Some elt ->\n Doubly_linked.remove t.queue elt;\n Some (Elt.value elt).value\n ;;\n\n let replace t k v =\n ensure_can_modify t;\n match Table.find t.table k with\n | None -> `No_such_key\n | Some elt ->\n (Elt.value elt).value <- v;\n `Ok\n ;;\n\n let raise_replace_unknown_key t key =\n raise_s\n [%message\n \"Hash_queue.replace_exn: unknown key\"\n ~_:(Table.sexp_of_key t.table key : Sexp.t)]\n ;;\n\n let replace_exn t k v =\n ensure_can_modify t;\n match replace t k v with\n | `No_such_key -> raise_replace_unknown_key t k\n | `Ok -> ()\n ;;\n\n let drop ?(n = 1) t back_or_front =\n if n >= length t\n then clear t\n else\n for _ = 1 to n do\n ignore (dequeue_with_key t back_or_front : _ option)\n done\n ;;\n\n let drop_back ?n t = drop ?n t `back\n let drop_front ?n t = drop ?n t `front\n end\n\n module type S = S0 with type ('key, 'data) hash_queue := ('key, 'data) Backend.t\n\n module Make (Key : Key) : S with type key = Key.t = struct\n include (Backend : Backend with type ('k, 'd) t := ('k, 'd) Backend.t)\n\n type key = Key.t\n type 'data t = (Key.t, 'data) Backend.t [@@deriving sexp_of]\n\n let hashable = Table.Hashable.of_key (module Key)\n let create ?growth_allowed ?size () = create ?growth_allowed ?size hashable\n end\n\n include Backend\nend\n\ninclude Make_backend (Hashtbl)\n","(** Functors and interfaces used to make modules hashable. *)\n\nopen! Import\nmodule Binable = Binable0\n\nmodule type Common = sig\n type t [@@deriving compare, hash]\n\n val hashable : t Hashtbl.Hashable.t\nend\n\nmodule type S_plain = sig\n include Common\n module Table : Hashtbl.S_plain with type key = t\n module Hash_set : Hash_set.S_plain with type elt = t\n module Hash_queue : Hash_queue.S with type key = t\nend\n\nmodule type S = sig\n include Common\n module Table : Hashtbl.S with type key = t\n module Hash_set : Hash_set.S with type elt = t\n module Hash_queue : Hash_queue.S with type key = t\nend\n\nmodule Make_plain (T : sig\n type t [@@deriving hash]\n\n include Hashtbl.Key_plain with type t := t\n end) : S_plain with type t := T.t = struct\n include T\n module Table = Hashtbl.Make_plain (T)\n module Hash_set = Hash_set.Make_plain (T)\n module Hash_queue = Hash_queue.Make (T)\n\n let hashable = Table.hashable\nend\n\nmodule Make_plain_and_derive_hash_fold_t (T : Hashtbl.Key_plain) :\n S_plain with type t := T.t = Make_plain (struct\n include T\n\n let hash_fold_t state t = hash_fold_int state (hash t)\n end)\n\nmodule Make (T : sig\n type t [@@deriving hash]\n\n include Hashtbl.Key with type t := t\n end) : S with type t := T.t = struct\n include T\n module Table = Hashtbl.Make (T)\n module Hash_set = Hash_set.Make (T)\n module Hash_queue = Hash_queue.Make (T)\n\n let hashable = Table.hashable\nend\n\nmodule Make_and_derive_hash_fold_t (T : Hashtbl.Key) : S with type t := T.t =\n Make (struct\n include T\n\n let hash_fold_t state t = hash_fold_int state (hash t)\n end)\n\nmodule type S_binable = sig\n type t [@@deriving hash]\n\n val hashable : t Hashtbl.Hashable.t\n\n module Table : Hashtbl.S_binable with type key = t\n module Hash_set : Hash_set.S_binable with type elt = t\n module Hash_queue : Hash_queue.S with type key = t\nend\n\nmodule Make_binable (T : sig\n type t [@@deriving hash]\n\n include Hashtbl.Key_binable with type t := t\n end) : S_binable with type t := T.t = struct\n module Table = Hashtbl.Make_binable (T)\n module Hash_set = Hash_set.Make_binable (T)\n module Hash_queue = Hash_queue.Make (T)\n include T\n\n let hashable = Table.hashable\nend\n\nmodule Make_binable_and_derive_hash_fold_t (T : Hashtbl.Key_binable) :\n S_binable with type t := T.t = Make_binable (struct\n include T\n\n let hash_fold_t state t = hash_fold_int state (hash t)\n end)\n\nmodule Stable : sig\n module V1 : sig\n module type S = sig\n type key\n\n module Table : sig\n type 'a t = (key, 'a) Hashtbl.t [@@deriving sexp, bin_io]\n end\n\n module Hash_set : sig\n type t = key Hash_set.t [@@deriving sexp, bin_io]\n end\n end\n\n module Make (Key : Hashtbl.Key_binable) : S with type key := Key.t\n end\nend = struct\n module V1 = struct\n module type S = sig\n type key\n\n module Table : sig\n type 'a t = (key, 'a) Hashtbl.t [@@deriving sexp, bin_io]\n end\n\n module Hash_set : sig\n type t = key Hash_set.t [@@deriving sexp, bin_io]\n end\n end\n\n module Make (Key : Hashtbl.Key_binable) : S with type key := Key.t = struct\n module Table = Hashtbl.Make_binable (Key)\n module Hash_set = Hash_set.Make_binable (Key)\n end\n end\nend\n","open! Import\nmodule Binable = Binable0\n\nmodule type S_common = sig\n type t [@@deriving compare, hash, sexp_of]\n\n include Stringable.S with type t := t\n include Pretty_printer.S with type t := t\nend\n\nmodule type S_plain = sig\n include S_common\n include Comparable.S_plain with type t := t\n include Hashable.S_plain with type t := t\nend\n\nmodule type S_not_binable = sig\n type t [@@deriving hash, sexp]\n\n include S_common with type t := t\n include Comparable.S with type t := t\n include Hashable.S with type t := t\nend\n\nmodule type S = sig\n type t [@@deriving bin_io, hash, sexp]\n\n include S_common with type t := t\n include Comparable.S_binable with type t := t\n include Hashable.S_binable with type t := t\nend\n\nmodule Make_plain (T : sig\n type t [@@deriving compare, hash, sexp_of]\n\n include Stringable.S with type t := t\n\n val module_name : string\n end) =\nstruct\n include T\n include Comparable.Make_plain (T)\n include Hashable.Make_plain (T)\n include Pretty_printer.Register (T)\nend\n\nmodule Make (T : sig\n type t [@@deriving bin_io, compare, hash, sexp]\n\n include Stringable.S with type t := t\n\n val module_name : string\n end) =\nstruct\n include T\n include Comparable.Make_binable (T)\n include Hashable.Make_binable (T)\n include Pretty_printer.Register (T)\nend\n\nmodule Make_and_derive_hash_fold_t (T : sig\n type t [@@deriving bin_io, compare, sexp]\n\n include Stringable.S with type t := t\n\n val hash : t -> int\n val module_name : string\n end) =\n Make (struct\n include T\n\n let hash_fold_t state t = hash_fold_int state (hash t)\n end)\n\nmodule Make_using_comparator (T : sig\n type t [@@deriving bin_io, compare, hash, sexp]\n\n include Comparator.S with type t := t\n include Stringable.S with type t := t\n\n val module_name : string\n end) =\nstruct\n include T\n include Comparable.Make_binable_using_comparator (T)\n include Hashable.Make_binable (T)\n include Pretty_printer.Register (T)\nend\n\nmodule Make_using_comparator_and_derive_hash_fold_t (T : sig\n type t [@@deriving bin_io, compare, sexp]\n\n include Comparator.S with type t := t\n include Stringable.S with type t := t\n\n val hash : t -> int\n val module_name : string\n end) =\n Make_using_comparator (struct\n include T\n\n let hash_fold_t state t = hash_fold_int state (hash t)\n end)\n\nmodule Extend (M : Base.Identifiable.S) (B : Binable0.S with type t = M.t) = struct\n module T = struct\n include M\n include (B : Binable.S with type t := t)\n end\n\n include T\n include Comparable.Extend_binable (M) (T)\n include Hashable.Make_binable (T)\nend\n","open! Import\n\ntype t = bool [@@deriving bin_io, typerep]\n\ninclude Identifiable.Extend\n (Base.Bool)\n (struct\n type nonrec t = t [@@deriving bin_io]\n end)\n\nmodule Replace_polymorphic_compare = Base.Bool\n\ninclude (\n Base.Bool :\n module type of struct\n include Base.Bool\n end\n with type t := t)\n\nlet quickcheck_generator = Base_quickcheck.Generator.bool\nlet quickcheck_observer = Base_quickcheck.Observer.bool\nlet quickcheck_shrinker = Base_quickcheck.Shrinker.bool\n\nmodule Stable = struct\n module V1 = struct\n type nonrec t = t [@@deriving compare, sexp, bin_io]\n end\nend\n","(** A functor for displaying a type as a sequence of ASCII characters printed in\n hexadecimal.\n\n [sexp_of_t] and [to_string_hum] print [t] in a similar format to 'hexdump' on Unix\n systems. For example, the string \"Back off, man, I'm a scientist.\" renders as:\n\n {v\n00000000 42 61 63 6b 20 6f 66 66 2c 20 6d 61 6e 2c 20 49 |Back off, man, I|\n00000010 27 6d 20 61 20 73 63 69 65 6e 74 69 73 74 2e |'m a scientist.|\n v}\n\n [to_sequence] produces a sequence of strings representing lines in the hex dump. It\n can be used to process a hex dump incrementally, for example with potentially infinite\n values, or to avoid keeping the entire output in memory at once. *)\n\nopen! Import\n\nmodule type S = sig\n type t\n\n module Hexdump : sig\n type nonrec t = t [@@deriving sexp_of]\n\n (** [to_string_hum] renders [t] as a multi-line ASCII string in hexdump format. [pos]\n and [len] select a subrange of [t] to render. [max_lines] determines the maximum\n number of lines of hex dump to produce. If the full hex dump exceeds this number,\n lines in the middle are replaced by a single \"...\"; the beginning and end of the\n hex dump are left intact. In order to produce at least some readable hex dump, at\n least 3 lines are always produced. *)\n val to_string_hum\n : ?max_lines:int (** default: [!default_max_lines] *)\n -> ?pos:int\n -> ?len:int\n -> t\n -> string\n\n (** [to_sequence] produces the lines of [to_string_hum] as a sequence of strings.\n This may be useful for incrementally rendering a large hex dump without producing\n the whole thing in memory. Optional arguments function as in [to_string_hum]. *)\n val to_sequence\n : ?max_lines:int (** default: [!default_max_lines] *)\n -> ?pos:int\n -> ?len:int\n -> t\n -> string Sequence.t\n\n (** [[%sexp_of: Hexdump.Pretty.t]] is the same as [[%sexp_of: Hexdump.t]], unless the\n underlying sequence of characters is entirely printable. In that case, it is\n rendered directly as a string. This allows e.g. test output to be much more\n compact in the common (printable) case while still being interpretable for any\n byte sequence. *)\n module Pretty : sig\n type nonrec t = t [@@deriving sexp_of]\n end\n end\nend\n\nmodule type S1 = sig\n type _ t\n\n module Hexdump : sig\n type nonrec 'a t = 'a t [@@deriving sexp_of]\n\n val to_string_hum : ?max_lines:int -> ?pos:int -> ?len:int -> _ t -> string\n\n\n val to_sequence : ?max_lines:int -> ?pos:int -> ?len:int -> _ t -> string Sequence.t\n\n module Pretty : sig\n type nonrec 'a t = 'a t [@@deriving sexp_of]\n end\n end\nend\n\nmodule type S2 = sig\n type (_, _) t\n\n module Hexdump : sig\n type nonrec ('a, 'b) t = ('a, 'b) t [@@deriving sexp_of]\n\n val to_string_hum : ?max_lines:int -> ?pos:int -> ?len:int -> (_, _) t -> string\n\n val to_sequence\n : ?max_lines:int\n -> ?pos:int\n -> ?len:int\n -> (_, _) t\n -> string Sequence.t\n\n module Pretty : sig\n type nonrec ('a, 'b) t = ('a, 'b) t [@@deriving sexp_of]\n end\n end\nend\n\n(** The functor [Hexdump.Of_indexable] uses [length] and [get] to iterate over the\n characters in a value and produce a hex dump. *)\nmodule type Indexable = sig\n type t\n\n val length : t -> int\n val get : t -> int -> char\nend\n\nmodule type Indexable1 = sig\n type _ t\n\n val length : _ t -> int\n val get : _ t -> int -> char\nend\n\nmodule type Indexable2 = sig\n type (_, _) t\n\n val length : (_, _) t -> int\n val get : (_, _) t -> int -> char\nend\n\nmodule type Hexdump = sig\n module type Indexable = Indexable\n module type Indexable1 = Indexable1\n module type Indexable2 = Indexable2\n module type S = S\n module type S1 = S1\n module type S2 = S2\n\n (** Can be used to override the default [~lines] argument for [to_string_hum] and\n [to_sequence] in [S]. *)\n val default_max_lines : int ref\n\n module Of_indexable (T : Indexable) : S with type t := T.t\n module Of_indexable1 (T : Indexable1) : S1 with type 'a t := 'a T.t\n module Of_indexable2 (T : Indexable2) : S2 with type ('a, 'b) t := ('a, 'b) T.t\nend\n","open! Import\nmodule Char = Base.Char\nmodule Int = Base.Int\nmodule String = Base.String\ninclude Hexdump_intf\n\nlet bytes_per_line = 16\n\n(* Initialize to enough lines to display 4096 bytes -- large enough that, for example, a\n complete Ethernet packet can always be displayed -- including the line containing the\n final index. *)\nlet default_max_lines = ref ((4096 / bytes_per_line) + 1)\n\nmodule Of_indexable2 (T : Indexable2) = struct\n module Hexdump = struct\n include T\n\n let hex_of_pos pos = Printf.sprintf \"%08x\" pos\n\n let hex_of_char t ~start ~until offset =\n let pos = start + offset in\n if pos >= until then \" \" else Printf.sprintf \"%02x\" (Char.to_int (get t pos))\n ;;\n\n let hex_of_line t ~start ~until =\n Printf.sprintf\n \"%s %s %s %s %s %s %s %s %s %s %s %s %s %s %s %s\"\n (hex_of_char t ~start ~until 0)\n (hex_of_char t ~start ~until 1)\n (hex_of_char t ~start ~until 2)\n (hex_of_char t ~start ~until 3)\n (hex_of_char t ~start ~until 4)\n (hex_of_char t ~start ~until 5)\n (hex_of_char t ~start ~until 6)\n (hex_of_char t ~start ~until 7)\n (hex_of_char t ~start ~until 8)\n (hex_of_char t ~start ~until 9)\n (hex_of_char t ~start ~until 10)\n (hex_of_char t ~start ~until 11)\n (hex_of_char t ~start ~until 12)\n (hex_of_char t ~start ~until 13)\n (hex_of_char t ~start ~until 14)\n (hex_of_char t ~start ~until 15)\n ;;\n\n let printable_string t ~start ~until =\n String.init (until - start) ~f:(fun i ->\n let char = get t (start + i) in\n if Char.is_print char then char else '.')\n ;;\n\n let line t ~pos ~len ~line_index =\n let start = pos + (line_index * bytes_per_line) in\n let until = min (start + bytes_per_line) (pos + len) in\n Printf.sprintf\n \"%s %s |%s|\"\n (hex_of_pos start)\n (hex_of_line t ~start ~until)\n (printable_string t ~start ~until)\n ;;\n\n let to_sequence ?max_lines ?pos ?len t =\n let pos, len =\n Ordered_collection_common.get_pos_len_exn () ?pos ?len ~total_length:(length t)\n in\n let max_lines =\n match max_lines with\n | Some max_lines -> max_lines\n | None -> !default_max_lines\n in\n (* always produce at least 3 lines: first line of hex, ellipsis, last line of hex *)\n let max_lines = max max_lines 3 in\n (* unabridged lines = lines of hex + line with final index *)\n let unabridged_lines =\n Int.round_up len ~to_multiple_of:bytes_per_line / bytes_per_line\n in\n (* Figure out where we need to skip from and to if [max_lines < unabridged_lines].\n Skip after half the actual hex lines (subtracting one line for the ellipsis).\n Skip to near the end, less the number of lines remaining to produce, plus the\n ellipsis line. *)\n let skip_from = (max_lines - 1) / 2 in\n let skip_to = unabridged_lines - (max_lines - skip_from) + 1 in\n Sequence.unfold_step ~init:0 ~f:(fun line_index ->\n if line_index >= unabridged_lines\n then Done\n else if line_index = skip_from && max_lines < unabridged_lines\n then Yield (\"...\", skip_to)\n else Yield (line t ~pos ~len ~line_index, line_index + 1))\n ;;\n\n let to_string_hum ?max_lines ?pos ?len t =\n to_sequence ?max_lines ?pos ?len t |> Sequence.to_list |> String.concat ~sep:\"\\n\"\n ;;\n\n let sexp_of_t _ _ t = to_sequence t |> Sequence.to_list |> [%sexp_of: string list]\n\n module Pretty = struct\n include T\n\n let printable =\n let rec printable_from t ~pos ~length =\n pos >= length\n || (Char.is_print (get t pos) && printable_from t ~pos:(pos + 1) ~length)\n in\n fun t -> printable_from t ~pos:0 ~length:(length t)\n ;;\n\n let to_string t = String.init (length t) ~f:(fun pos -> get t pos)\n\n let sexp_of_t sexp_of_a sexp_of_b t =\n if printable t then [%sexp (to_string t : string)] else [%sexp (t : (a, b) t)]\n ;;\n end\n end\nend\n\nmodule Of_indexable1 (T : Indexable1) = struct\n module M = Of_indexable2 (struct\n type ('a, _) t = 'a T.t\n\n let length = T.length\n let get = T.get\n end)\n\n module Hexdump = struct\n include T\n\n let sexp_of_t x t = M.Hexdump.sexp_of_t x [%sexp_of: _] t\n let to_sequence = M.Hexdump.to_sequence\n let to_string_hum = M.Hexdump.to_string_hum\n\n module Pretty = struct\n include T\n\n let sexp_of_t sexp_of_a t = [%sexp (t : (a, _) M.Hexdump.Pretty.t)]\n end\n end\nend\n\nmodule Of_indexable (T : Indexable) = struct\n module M = Of_indexable1 (struct\n type _ t = T.t\n\n let length = T.length\n let get = T.get\n end)\n\n module Hexdump = struct\n include T\n\n let sexp_of_t t = M.Hexdump.sexp_of_t [%sexp_of: _] t\n let to_sequence = M.Hexdump.to_sequence\n let to_string_hum = M.Hexdump.to_string_hum\n\n module Pretty = struct\n include T\n\n let sexp_of_t t = [%sexp (t : _ M.Hexdump.Pretty.t)]\n end\n end\nend\n","open! Import\ninclude Base.String\n\n(* These two are needed because [include Identifiable.Extend] (present later in the file)\n binds new [Map] and [Set] modules. *)\nmodule Core_map = Map\nmodule Core_set = Set\n\nmodule Stable = struct\n module V1 = struct\n module T = struct\n include Base.String\n\n type t = string [@@deriving bin_io]\n end\n\n include T\n\n let to_string = Fn.id\n let of_string = Fn.id\n\n include Comparable.Stable.V1.Make (T)\n include Hashable.Stable.V1.Make (T)\n end\nend\n\nmodule Caseless = struct\n module T = struct\n include Caseless\n\n type t = string [@@deriving bin_io]\n end\n\n include T\n include Comparable.Make_binable_using_comparator (T)\n include Hashable.Make_binable (T)\nend\n\ntype t = string [@@deriving typerep]\n\ninclude Identifiable.Extend\n (Base.String)\n (struct\n type t = string [@@deriving bin_io]\n end)\n\ninclude Hexdump.Of_indexable (struct\n type t = string\n\n let length = length\n let get = get\n end)\n\nlet quickcheck_generator = Base_quickcheck.Generator.string\nlet quickcheck_observer = Base_quickcheck.Observer.string\nlet quickcheck_shrinker = Base_quickcheck.Shrinker.string\nlet gen_nonempty = Base_quickcheck.Generator.string_non_empty\nlet gen' = Base_quickcheck.Generator.string_of\nlet gen_nonempty' = Base_quickcheck.Generator.string_non_empty_of\n\nlet gen_with_length length chars =\n Base_quickcheck.Generator.string_with_length_of chars ~length\n;;\n\nlet take_while t ~f =\n match lfindi t ~f:(fun _ elt -> not (f elt)) with\n | None -> t\n | Some i -> sub t ~pos:0 ~len:i\n;;\n\nlet rtake_while t ~f =\n match rfindi t ~f:(fun _ elt -> not (f elt)) with\n | None -> t\n | Some i -> sub t ~pos:(i + 1) ~len:(length t - i - 1)\n;;\n\n(** See {!Array.normalize} for the following 4 functions. *)\nlet normalize t i = Ordered_collection_common.normalize ~length_fun:length t i\n\nlet slice t start stop =\n Ordered_collection_common.slice ~length_fun:length ~sub_fun:sub t start stop\n;;\n\nlet nget x i =\n let module String = Base.String in\n x.[normalize x i]\n;;\n","open! Import\n\nmodule Stable = struct\n module V1 = struct\n include Base.Bytes\n\n type t = bytes [@@deriving bin_io, typerep]\n end\nend\n\ninclude Stable.V1\n\ninclude Hexdump.Of_indexable (struct\n type t = bytes\n\n let length = length\n let get = get\n end)\n\nlet quickcheck_generator =\n String.quickcheck_generator |> Quickcheck.Generator.map ~f:of_string\n;;\n\nlet quickcheck_observer =\n String.quickcheck_observer |> Quickcheck.Observer.unmap ~f:to_string\n;;\n\nlet quickcheck_shrinker =\n String.quickcheck_shrinker |> Quickcheck.Shrinker.map ~f:of_string ~f_inverse:to_string\n;;\n\nlet gen' char_gen = String.gen' char_gen |> Quickcheck.Generator.map ~f:of_string\n\nlet gen_with_length len char_gen =\n String.gen_with_length len char_gen |> Quickcheck.Generator.map ~f:of_string\n;;\n","open! Import\n\ntype t = char [@@deriving typerep]\n\ninclude Identifiable.Extend\n (Base.Char)\n (struct\n type t = char [@@deriving bin_io]\n end)\n\n(* include [Base.Char] after the application of [Identifiable.Extend] to replace the\n [Comparable] functions with the pervasive versions *)\ninclude (\n Base.Char :\n module type of struct\n include Base.Char\n end\n with type t := t)\n\nmodule Caseless = struct\n module T = struct\n include Caseless\n\n type t = char [@@deriving bin_io]\n end\n\n include T\n include Comparable.Make_binable_using_comparator (T)\n include Hashable.Make_binable (T)\nend\n\nmodule Replace_polymorphic_compare = Base.Char\n\nlet quickcheck_generator = Base_quickcheck.Generator.char\nlet quickcheck_observer = Base_quickcheck.Observer.char\nlet quickcheck_shrinker = Base_quickcheck.Shrinker.char\nlet gen_digit = Base_quickcheck.Generator.char_digit\nlet gen_lowercase = Base_quickcheck.Generator.char_lowercase\nlet gen_uppercase = Base_quickcheck.Generator.char_uppercase\nlet gen_alpha = Base_quickcheck.Generator.char_alpha\nlet gen_alphanum = Base_quickcheck.Generator.char_alphanum\nlet gen_print = Base_quickcheck.Generator.char_print\nlet gen_whitespace = Base_quickcheck.Generator.char_whitespace\nlet gen_uniform_inclusive = Base_quickcheck.Generator.char_uniform_inclusive\n","include Caml\n\n(* At Jane Street, the OCaml stdlib is patched to define [Pervasives.raise] as the\n [\"%reraise\"] primitive. We do this as the compiler is currently not good enough at\n automatically detecting reraise [1]. We patch the stdlib so that everything is\n affected, including libraries defined before base such as sexplib or non Jane Street\n libraries.\n\n We need this definition so that this implementation can match its interface with the\n patched stdlib and with the original one.\n\n [[1] http://caml.inria.fr/mantis/view.php?id=6556\n*)\nexternal raise : exn -> 'a = \"%reraise\"\n","open! Import\nmodule Sign = Base.Sign\n\nmodule Stable = struct\n module V1 = struct\n type t = Sign.t =\n | Neg\n | Zero\n | Pos\n [@@deriving sexp, bin_io, compare, hash, typerep, enumerate]\n end\nend\n\ninclude Stable.V1\ninclude Sign\ninclude Identifiable.Extend (Sign) (Stable.V1)\n","external format_float : string -> float -> string = \"caml_format_float\"\n\n(* Stolen from [pervasives.ml]. Adds a \".\" at the end if needed. It is in\n [pervasives.mli], but it also says not to use it directly, so we copy and paste the\n code. It makes the assumption on the string passed in argument that it was returned by\n [format_float] *)\nlet valid_float_lexem s =\n let l = String.length s in\n let rec loop i =\n if i >= l\n then s ^ \".\"\n else (\n match s.[i] with\n | '0' .. '9' | '-' -> loop (i + 1)\n | _ -> s)\n in\n loop 0\n;;\n\nopen! Import\nmodule List = Base.List\n\nmodule T = struct\n include Base.Float\n\n type t = float [@@deriving bin_io, typerep]\nend\n\ninclude T\ninclude Hashable.Make_binable (T)\ninclude Comparable.Map_and_set_binable_using_comparator (T)\nmodule Replace_polymorphic_compare : Comparisons.S with type t := t = T\n\nmodule Robust_compare = struct\n module type S = sig\n (* intended to be a tolerance on human-entered floats *)\n\n val robust_comparison_tolerance : float\n\n include Robustly_comparable.S with type t := float\n end\n\n module Make (T : sig\n val robust_comparison_tolerance : float\n end) : S = struct\n (* We have test in the tree that rely on these functions not allocating, even without\n X_LIBRARY_INLING. The only way to ensure that these don't create temporary boxed\n floats without X_LIBRARY_INLING is for this code to see the float operations as\n externals, as defined in [Pervasives]. That's why we use [Poly] and float\n arithmetic from [Caml]. *)\n open Poly\n\n let robust_comparison_tolerance = T.robust_comparison_tolerance\n let ( >=. ) x y = x >= Caml.( -. ) y robust_comparison_tolerance\n let ( <=. ) x y = y >=. x\n let ( =. ) x y = x >=. y && y >=. x\n let ( >. ) x y = x > Caml.( +. ) y robust_comparison_tolerance\n let ( <. ) x y = y >. x\n let ( <>. ) x y = not (x =. y)\n\n let robustly_compare x y =\n let d = Caml.( -. ) x y in\n if d < Caml.( ~-. ) robust_comparison_tolerance\n then -1\n else if d > robust_comparison_tolerance\n then 1\n else 0\n ;;\n end\nend\n\nmodule Robustly_comparable = Robust_compare.Make (struct\n let robust_comparison_tolerance = 1E-7\n end)\n\ninclude Robustly_comparable\n\nmodule O = struct\n include Base.Float.O\n include Robustly_comparable\nend\n\nmodule Terse = struct\n type nonrec t = t [@@deriving bin_io]\n\n include (\n Base.Float.Terse :\n module type of struct\n include Base.Float.Terse\n end\n with type t := t)\nend\n\nlet robust_sign t : Sign.t = if t >. 0. then Pos else if t <. 0. then Neg else Zero\n\n(* There are two issues:\n - Float.sign used to use robust comparison, and users of [Core] might have come to\n depend on this.\n - Robustness aside, what we get from Comparable.With_zero would map nan to Neg.\n*)\nlet sign = robust_sign\n\n(* Standard 12 significant digits, exponential notation used as necessary, guaranteed to\n be a valid OCaml float lexem, not to look like an int. *)\nlet to_string_12 x = valid_float_lexem (format_float \"%.12g\" x)\nlet quickcheck_generator = Base_quickcheck.Generator.float\nlet quickcheck_observer = Base_quickcheck.Observer.float\nlet quickcheck_shrinker = Base_quickcheck.Shrinker.float\nlet gen_uniform_excl = Base_quickcheck.Generator.float_uniform_exclusive\nlet gen_incl = Base_quickcheck.Generator.float_inclusive\nlet gen_without_nan = Base_quickcheck.Generator.float_without_nan\nlet gen_finite = Base_quickcheck.Generator.float_finite\nlet gen_positive = Base_quickcheck.Generator.float_strictly_positive\nlet gen_negative = Base_quickcheck.Generator.float_strictly_negative\nlet gen_zero = Base_quickcheck.Generator.float_of_class Zero\nlet gen_nan = Base_quickcheck.Generator.float_of_class Nan\nlet gen_subnormal = Base_quickcheck.Generator.float_of_class Subnormal\nlet gen_normal = Base_quickcheck.Generator.float_of_class Normal\nlet gen_infinite = Base_quickcheck.Generator.float_of_class Infinite\n","open! Import\n\nmodule Stable = struct\n module V1 = struct\n module T = struct\n include Base.Int\n\n type t = int [@@deriving hash, bin_io, sexp]\n end\n\n include T\n include Comparable.Stable.V1.Make (T)\n end\nend\n\ninclude Identifiable.Extend\n (Base.Int)\n (struct\n type t = int [@@deriving bin_io]\n end)\n\nmodule Replace_polymorphic_compare = Base.Int\ninclude Base.Int\n\ntype t = int [@@deriving typerep]\n\nmodule Hex = struct\n include Hex\n\n type nonrec t = t [@@deriving typerep, bin_io]\nend\n\nlet quickcheck_generator = Base_quickcheck.Generator.int\nlet quickcheck_observer = Base_quickcheck.Observer.int\nlet quickcheck_shrinker = Base_quickcheck.Shrinker.int\nlet gen_incl = Base_quickcheck.Generator.int_inclusive\nlet gen_uniform_incl = Base_quickcheck.Generator.int_uniform_inclusive\nlet gen_log_incl = Base_quickcheck.Generator.int_log_inclusive\nlet gen_log_uniform_incl = Base_quickcheck.Generator.int_log_uniform_inclusive\n","open! Import\n\ninclude Identifiable.Extend\n (Base.Int32)\n (struct\n type t = int32 [@@deriving bin_io]\n end)\n\ninclude Base.Int32\n\ntype t = int32 [@@deriving typerep]\n\nmodule Hex = struct\n include Hex\n\n type nonrec t = t [@@deriving typerep, bin_io]\nend\n\nlet quickcheck_generator = Base_quickcheck.Generator.int32\nlet quickcheck_observer = Base_quickcheck.Observer.int32\nlet quickcheck_shrinker = Base_quickcheck.Shrinker.int32\nlet gen_incl = Base_quickcheck.Generator.int32_inclusive\nlet gen_uniform_incl = Base_quickcheck.Generator.int32_uniform_inclusive\nlet gen_log_incl = Base_quickcheck.Generator.int32_log_inclusive\nlet gen_log_uniform_incl = Base_quickcheck.Generator.int32_log_uniform_inclusive\n","(* unsigned_extended.ml *)\n\nopen Core_kernel\ninclude Intf\nopen Snark_params\nopen Tick\n\nmodule type Unsigned_intf = Unsigned.S\n\nmodule Extend\n (Unsigned : Unsigned.S) (M : sig\n val length : int\n end) : S with type t = Unsigned.t = struct\n assert (M.length < Field.size_in_bits - 3)\n\n let length_in_bits = M.length\n\n module T = struct\n include Sexpable.Of_stringable (Unsigned)\n\n type t = Unsigned.t\n\n let compare = Unsigned.compare\n\n let hash_fold_t s t = Int64.hash_fold_t s (Unsigned.to_int64 t)\n\n let hash t = Int64.hash (Unsigned.to_int64 t)\n\n let to_bigint t =\n let i64 = Unsigned.to_int64 t in\n if Int64.(i64 >= 0L) then Bignum_bigint.of_int64 i64\n else\n Bignum_bigint.(\n of_int64 i64 - of_int64 Int64.min_value + of_int64 Int64.max_value\n + one)\n end\n\n include T\n include Hashable.Make (T)\n\n include (Unsigned : Unsigned_intf with type t := t)\n\n (* serializes to and from json as strings since bit lengths > 32 cannot be represented in json *)\n let to_yojson n = `String (to_string n)\n\n let of_yojson = function\n | `String s ->\n Ok (of_string s)\n | _ ->\n Error \"expected string\"\n\n let ( < ) x y = compare x y < 0\n\n let ( > ) x y = compare x y > 0\n\n let ( = ) x y = compare x y = 0\n\n let ( <= ) x y = compare x y <= 0\n\n let ( >= ) x y = compare x y >= 0\nend\n\nmodule UInt64 = struct\n module M =\n Extend\n (Unsigned.UInt64)\n (struct\n let length = 64\n end)\n\n (* this module allows use to generate With_all_version_tags from the\n Binable.Of_binable functor below, needed to decode transaction ids\n for V1 signed commands; it does not add any tags\n *)\n module Int64_for_version_tags = struct\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n type t = (Int64.t[@version_asserted])\n\n let to_latest = Fn.id\n\n module With_all_version_tags = struct\n type typ = t [@@deriving bin_io_unversioned]\n\n type t = typ [@@deriving bin_io_unversioned]\n end\n end\n end]\n end\n\n [%%versioned_binable\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n [@@@with_all_version_tags]\n\n type t = Unsigned.UInt64.t\n\n let to_latest = Fn.id\n\n (* these are defined in the Extend functor, rather than derived, so import them *)\n [%%define_locally\n M.\n ( equal\n , compare\n , hash\n , hash_fold_t\n , sexp_of_t\n , t_of_sexp\n , to_yojson\n , of_yojson )]\n\n module M = struct\n type t = Unsigned.UInt64.t\n\n let to_binable = Unsigned.UInt64.to_int64\n\n let of_binable = Unsigned.UInt64.of_int64\n end\n\n include Binable.Of_binable (Int64_for_version_tags.Stable.V1) (M)\n end\n end]\n\n include M\n\n let dhall_type = Ppx_dhall_type.Dhall_type.Text\n\n let to_uint64 : t -> uint64 = Fn.id\n\n let of_uint64 : uint64 -> t = Fn.id\nend\n\nmodule UInt32 = struct\n module M =\n Extend\n (Unsigned.UInt32)\n (struct\n let length = 32\n end)\n\n (* this module allows use to generate With_all_version_tags from the\n Binable.Of_binable functor below, needed to decode transaction ids\n for V1 signed commands; it does not add any tags\n *)\n module Int32_for_version_tags = struct\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n type t = (Int32.t[@version_asserted])\n\n let to_latest = Fn.id\n\n module With_all_version_tags = struct\n type typ = t [@@deriving bin_io_unversioned]\n\n type t = typ [@@deriving bin_io_unversioned]\n end\n end\n end]\n end\n\n [%%versioned_binable\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n [@@@with_all_version_tags]\n\n type t = Unsigned.UInt32.t\n\n let to_latest = Fn.id\n\n (* these are defined in the Extend functor, rather than derived, so import them *)\n [%%define_locally\n M.\n ( equal\n , compare\n , hash\n , hash_fold_t\n , sexp_of_t\n , t_of_sexp\n , to_yojson\n , of_yojson )]\n\n module M = struct\n type t = Unsigned.UInt32.t\n\n let to_binable = Unsigned.UInt32.to_int32\n\n let of_binable = Unsigned.UInt32.of_int32\n end\n\n include Binable.Of_binable (Int32_for_version_tags.Stable.V1) (M)\n end\n end]\n\n include M\n\n let to_uint32 : t -> uint32 = Fn.id\n\n let of_uint32 : uint32 -> t = Fn.id\nend\n","open! Import\n\ninclude Identifiable.Extend\n (Base.Int64)\n (struct\n type t = int64 [@@deriving bin_io]\n end)\n\ninclude Base.Int64\n\ntype t = int64 [@@deriving typerep]\n\nmodule Hex = struct\n include Hex\n\n type nonrec t = t [@@deriving typerep, bin_io]\nend\n\nlet quickcheck_generator = Base_quickcheck.Generator.int64\nlet quickcheck_observer = Base_quickcheck.Observer.int64\nlet quickcheck_shrinker = Base_quickcheck.Shrinker.int64\nlet gen_incl = Base_quickcheck.Generator.int64_inclusive\nlet gen_uniform_incl = Base_quickcheck.Generator.int64_uniform_inclusive\nlet gen_log_incl = Base_quickcheck.Generator.int64_log_inclusive\nlet gen_log_uniform_incl = Base_quickcheck.Generator.int64_log_uniform_inclusive\n","open! Import\n\nmodule Bin : Binable0.S with type t := Base.Int63.t = struct\n module Bin_emulated = struct\n type t = Base.Int63.Private.Emul.t\n\n include Binable0.Of_binable_without_uuid [@alert \"-legacy\"]\n (Int64)\n (struct\n type nonrec t = t\n\n let of_binable = Base.Int63.Private.Emul.W.wrap_exn\n let to_binable = Base.Int63.Private.Emul.W.unwrap\n end)\n end\n\n type 'a binable = (module Binable0.S with type t = 'a)\n\n let binable_of_repr : type a b. (a, b) Base.Int63.Private.Repr.t -> b binable\n = function\n | Base.Int63.Private.Repr.Int -> (module Int)\n | Base.Int63.Private.Repr.Int64 -> (module Bin_emulated)\n ;;\n\n let binable : Base.Int63.t binable = binable_of_repr Base.Int63.Private.repr\n\n include (val binable)\n\n let bin_shape_t = Bin_prot.Shape.bin_shape_int63\nend\n\nmodule Stable = struct\n module V1 = struct\n module T = struct\n type t = Base.Int63.t [@@deriving hash, sexp]\n\n include Bin\n\n include (\n Base.Int63 :\n Base.Comparable.S\n with type t := t\n with type comparator_witness = Base.Int63.comparator_witness)\n end\n\n include T\n include Comparable.Stable.V1.Make (T)\n end\nend\n\n(* This [include struct] is required because it lets us shadow [t] when we include\n [Base.Int63] later on. *)\ninclude struct\n type t = Base.Int63.t\nend\n\nlet typerep_of_t = typerep_of_int63\nlet typename_of_t = typename_of_int63\n\ninclude Identifiable.Extend\n (Base.Int63)\n (struct\n type nonrec t = t\n\n include Bin\n end)\n\nmodule Replace_polymorphic_compare : Comparable.Polymorphic_compare with type t := t =\n Base.Int63\n\ninclude Base.Int63\n\nmodule Hex = struct\n include Hex\n\n type nonrec t = t [@@deriving typerep, bin_io]\nend\n\nlet quickcheck_generator = Base_quickcheck.Generator.int63\nlet quickcheck_observer = Base_quickcheck.Observer.int63\nlet quickcheck_shrinker = Base_quickcheck.Shrinker.int63\nlet gen_incl = Base_quickcheck.Generator.int63_inclusive\nlet gen_uniform_incl = Base_quickcheck.Generator.int63_uniform_inclusive\nlet gen_log_incl = Base_quickcheck.Generator.int63_log_inclusive\nlet gen_log_uniform_incl = Base_quickcheck.Generator.int63_log_uniform_inclusive\n","module Stable = struct\n open Base.Export\n open Bin_prot.Std\n\n module V1 = struct\n module T = struct\n type t = unit [@@deriving bin_io, compare, sexp]\n end\n\n include T\n include Comparator.Stable.V1.Make (T)\n\n let%expect_test _ =\n print_endline [%bin_digest: t];\n [%expect {| 86ba5df747eec837f0b391dd49f33f9e |}]\n ;;\n end\nend\n\nopen! Import\n\ninclude Identifiable.Extend\n (Base.Unit)\n (struct\n type t = unit [@@deriving bin_io]\n end)\n\ninclude Base.Unit\n\ntype t = unit [@@deriving typerep]\n\nlet quickcheck_generator = Base_quickcheck.Generator.unit\nlet quickcheck_observer = Base_quickcheck.Observer.unit\nlet quickcheck_shrinker = Base_quickcheck.Shrinker.unit\n\nmodule type S = sig end\n\ntype m = (module S)\n","(** Various interface exports. *)\n\nopen! Import\n\nmodule type Applicative = Applicative.S\nmodule type Binable = Binable0.S\nmodule type Comparable = Comparable.S\nmodule type Comparable_binable = Comparable.S_binable\nmodule type Floatable = Floatable.S\nmodule type Hashable = Hashable.S\nmodule type Hashable_binable = Hashable.S_binable\nmodule type Identifiable = Identifiable.S\nmodule type Infix_comparators = Comparable.Infix\nmodule type Intable = Intable.S\nmodule type Monad = Monad.S\nmodule type Quickcheckable = Quickcheckable.S\nmodule type Robustly_comparable = Robustly_comparable.S\nmodule type Sexpable = Sexpable.S\nmodule type Stable = Stable_module_types.S0\nmodule type Stable_int63able = Stable_int63able.S\nmodule type Stable_without_comparator = Stable_module_types.S0_without_comparator\nmodule type Stable1 = Stable_module_types.S1\nmodule type Stable2 = Stable_module_types.S2\nmodule type Stable3 = Stable_module_types.S3\nmodule type Stable4 = Stable_module_types.S4\nmodule type Stringable = Stringable.S\nmodule type Unit = Unit.S\n","open! Import\n\nmodule Stable = struct\n module V1 = struct\n open Sexplib.Std\n\n type 'a t = 'a lazy_t [@@deriving bin_io, sexp, typerep]\n\n let map = Base.Lazy.map\n let compare = Base.Lazy.compare\n let t_sexp_grammar = lazy_t_sexp_grammar\n end\nend\n\nmodule type Base_mask = module type of Base.Lazy with type 'a t := 'a Stable.V1.t\n\ninclude Stable.V1\ninclude (Base.Lazy : Base_mask)\n","open! Import\n\ninclude Identifiable.Extend\n (Base.Nativeint)\n (struct\n type t = nativeint [@@deriving bin_io]\n end)\n\ninclude Base.Nativeint\n\ntype t = nativeint [@@deriving typerep]\n\nmodule Hex = struct\n include Hex\n\n type nonrec t = t [@@deriving typerep, bin_io]\nend\n\nlet quickcheck_generator = Base_quickcheck.Generator.nativeint\nlet quickcheck_observer = Base_quickcheck.Observer.nativeint\nlet quickcheck_shrinker = Base_quickcheck.Shrinker.nativeint\nlet gen_incl = Base_quickcheck.Generator.nativeint_inclusive\nlet gen_uniform_incl = Base_quickcheck.Generator.nativeint_uniform_inclusive\nlet gen_log_incl = Base_quickcheck.Generator.nativeint_log_inclusive\nlet gen_log_uniform_incl = Base_quickcheck.Generator.nativeint_log_uniform_inclusive\n","open! Import\n\nmodule Stable = struct\n module V1 = struct\n type t = Base.Nothing.t = |\n\n module Shape = struct\n type t [@@deriving bin_shape]\n end\n\n let unreachable_code = Base.Nothing.unreachable_code\n let bin_shape_t = Shape.bin_shape_t\n let tp_loc = [%here].pos_fname ^ \".Stable.V1.t\"\n let all = []\n let hash_fold_t _ t = unreachable_code t\n let hash = unreachable_code\n let compare a _ = unreachable_code a\n let bin_size_t = unreachable_code\n let bin_write_t _buf ~pos:_ t = unreachable_code t\n let bin_writer_t = { Bin_prot.Type_class.size = bin_size_t; write = bin_write_t }\n\n let __bin_read_t__ _buf ~pos_ref _ =\n Bin_prot.Common.raise_variant_wrong_type tp_loc !pos_ref\n ;;\n\n let bin_read_t _buf ~pos_ref =\n Bin_prot.Common.raise_read_error (Empty_type tp_loc) !pos_ref\n ;;\n\n let bin_reader_t =\n { Bin_prot.Type_class.read = bin_read_t; vtag_read = __bin_read_t__ }\n ;;\n\n let bin_t =\n { Bin_prot.Type_class.writer = bin_writer_t\n ; reader = bin_reader_t\n ; shape = bin_shape_t\n }\n ;;\n\n let sexp_of_t = unreachable_code\n let t_of_sexp sexp = Sexplib.Conv_error.empty_type tp_loc sexp\n end\nend\n\ninclude Stable.V1\ninclude Base.Nothing\ninclude Identifiable.Extend (Base.Nothing) (Stable.V1)\n","open! Import\n\ntype t = Base.Ordering.t =\n | Less\n | Equal\n | Greater\n[@@deriving bin_io, compare, hash, sexp]\n\nmodule type Base_mask = module type of Base.Ordering with type t := t\n\ninclude (Base.Ordering : Base_mask)\n","open! Import\n\nmodule T = struct\n include Base.Ref\n\n include (\n struct\n type 'a t = 'a ref [@@deriving bin_io, typerep]\n end :\n sig\n type 'a t = 'a ref [@@deriving bin_io, typerep]\n end\n with type 'a t := 'a t)\nend\n\ninclude T\n\nmodule Permissioned = struct\n include T\n\n type ('a, -'perms) t = 'a T.t [@@deriving bin_io, sexp]\n\n let read_only = Fn.id\n let of_ref = Fn.id\n let to_ref = Fn.id\n let set = ( := )\n let get = ( ! )\nend\n","(* zkapp_command_logic.ml *)\n\nopen Core_kernel\nopen Mina_base\n\nmodule type Iffable = sig\n type bool\n\n type t\n\n val if_ : bool -> then_:t -> else_:t -> t\nend\n\nmodule type Bool_intf = sig\n type t\n\n include Iffable with type t := t and type bool := t\n\n val true_ : t\n\n val false_ : t\n\n val equal : t -> t -> t\n\n val not : t -> t\n\n val ( ||| ) : t -> t -> t\n\n val ( &&& ) : t -> t -> t\n\n module Assert : sig\n (* [pos] is file,line,col,endcol from __POS__ *)\n val is_true : pos:string * int * int * int -> t -> unit\n\n (* [pos] is file,line,col,endcol from __POS__ *)\n val any : pos:string * int * int * int -> t list -> unit\n end\n\n val display : t -> label:string -> string\n\n val all : t list -> t\n\n type failure_status\n\n type failure_status_tbl\n\n (* [pos] is file,line,col,endcol from __POS__ *)\n val assert_with_failure_status_tbl :\n pos:string * int * int * int -> t -> failure_status_tbl -> unit\nend\n\nmodule type Balance_intf = sig\n include Iffable\n\n type amount\n\n type signed_amount\n\n val sub_amount_flagged : t -> amount -> t * [ `Underflow of bool ]\n\n val add_signed_amount_flagged : t -> signed_amount -> t * [ `Overflow of bool ]\nend\n\nmodule type Receipt_chain_hash_intf = sig\n include Iffable\n\n type transaction_commitment\n\n type index\n\n module Elt : sig\n type t\n\n val of_transaction_commitment : transaction_commitment -> t\n end\n\n val cons_zkapp_command_commitment : index -> Elt.t -> t -> t\nend\n\nmodule type Amount_intf = sig\n include Iffable\n\n type unsigned = t\n\n module Signed : sig\n include Iffable with type bool := bool\n\n val equal : t -> t -> bool\n\n val is_neg : t -> bool\n\n val is_non_neg : t -> bool\n\n val negate : t -> t\n\n val add_flagged : t -> t -> t * [ `Overflow of bool ]\n\n val of_unsigned : unsigned -> t\n end\n\n val zero : t\n\n val equal : t -> t -> bool\n\n val add_flagged : t -> t -> t * [ `Overflow of bool ]\n\n val add_signed_flagged : t -> Signed.t -> t * [ `Overflow of bool ]\n\n val of_constant_fee : Currency.Fee.t -> t\nend\n\nmodule type Account_id_intf = sig\n include Iffable\n\n type public_key\n\n type token_id\n\n val invalid : t\n\n val equal : t -> t -> bool\n\n val create : public_key -> token_id -> t\n\n val derive_token_id : owner:t -> token_id\nend\n\nmodule type Global_slot_since_genesis_intf = sig\n include Iffable\n\n val zero : t\n\n val ( > ) : t -> t -> bool\n\n val equal : t -> t -> bool\nend\n\nmodule type Global_slot_span_intf = sig\n include Iffable\n\n val zero : t\n\n val ( > ) : t -> t -> bool\nend\n\nmodule type Verification_key_hash_intf = sig\n type t\n\n type bool\n\n val equal : t -> t -> bool\nend\n\nmodule type Timing_intf = sig\n include Iffable\n\n type global_slot_span\n\n val vesting_period : t -> global_slot_span\nend\n\nmodule type Token_id_intf = sig\n include Iffable\n\n val equal : t -> t -> bool\n\n val default : t\nend\n\nmodule type Actions_intf = sig\n type t\n\n type bool\n\n type field\n\n val is_empty : t -> bool\n\n val push_events : field -> t -> field\nend\n\nmodule type Protocol_state_precondition_intf = sig\n type t\nend\n\nmodule type Valid_while_precondition_intf = sig\n type t\nend\n\nmodule Local_state = struct\n open Core_kernel\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n type ( 'stack_frame\n , 'call_stack\n , 'signed_amount\n , 'ledger\n , 'bool\n , 'comm\n , 'length\n , 'failure_status_tbl )\n t =\n ( 'stack_frame\n , 'call_stack\n , 'signed_amount\n , 'ledger\n , 'bool\n , 'comm\n , 'length\n , 'failure_status_tbl )\n Mina_wire_types.Mina_transaction_logic.Zkapp_command_logic\n .Local_state\n .V1\n .t =\n { stack_frame : 'stack_frame\n ; call_stack : 'call_stack\n ; transaction_commitment : 'comm\n ; full_transaction_commitment : 'comm\n ; excess : 'signed_amount\n ; supply_increase : 'signed_amount\n ; ledger : 'ledger\n ; success : 'bool\n ; account_update_index : 'length\n ; failure_status_tbl : 'failure_status_tbl\n ; will_succeed : 'bool\n }\n [@@deriving compare, equal, hash, sexp, yojson, fields, hlist]\n end\n end]\n\n let typ stack_frame call_stack excess supply_increase ledger bool comm length\n failure_status_tbl =\n Pickles.Impls.Step.Typ.of_hlistable\n [ stack_frame\n ; call_stack\n ; comm\n ; comm\n ; excess\n ; supply_increase\n ; ledger\n ; bool\n ; length\n ; failure_status_tbl\n ; bool\n ]\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist\n\n module Value = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t =\n ( Mina_base.Stack_frame.Digest.Stable.V1.t\n , Mina_base.Call_stack_digest.Stable.V1.t\n , ( Currency.Amount.Stable.V1.t\n , Sgn.Stable.V1.t )\n Currency.Signed_poly.Stable.V1.t\n , Ledger_hash.Stable.V1.t\n , bool\n , Zkapp_command.Transaction_commitment.Stable.V1.t\n , Mina_numbers.Index.Stable.V1.t\n , Transaction_status.Failure.Collection.Stable.V1.t )\n Stable.V1.t\n [@@deriving equal, compare, hash, yojson, sexp]\n\n let to_latest = Fn.id\n end\n end]\n end\n\n module Checked = struct\n open Pickles.Impls.Step\n\n type t =\n ( Stack_frame.Digest.Checked.t\n , Call_stack_digest.Checked.t\n , Currency.Amount.Signed.Checked.t\n , Ledger_hash.var\n , Boolean.var\n , Zkapp_command.Transaction_commitment.Checked.t\n , Mina_numbers.Index.Checked.t\n , unit )\n Stable.Latest.t\n end\nend\n\nmodule type Set_or_keep_intf = sig\n type _ t\n\n type bool\n\n val is_set : _ t -> bool\n\n val is_keep : _ t -> bool\n\n val set_or_keep : if_:(bool -> then_:'a -> else_:'a -> 'a) -> 'a t -> 'a -> 'a\nend\n\nmodule type Account_update_intf = sig\n type t\n\n type bool\n\n type call_forest\n\n type signed_amount\n\n type transaction_commitment\n\n type protocol_state_precondition\n\n type valid_while_precondition\n\n type public_key\n\n type token_id\n\n type account_id\n\n type account\n\n type nonce\n\n type verification_key_hash\n\n type _ or_ignore\n\n val balance_change : t -> signed_amount\n\n val protocol_state_precondition : t -> protocol_state_precondition\n\n val valid_while_precondition : t -> valid_while_precondition\n\n val public_key : t -> public_key\n\n val token_id : t -> token_id\n\n val account_id : t -> account_id\n\n val may_use_parents_own_token : t -> bool\n\n val may_use_token_inherited_from_parent : t -> bool\n\n val use_full_commitment : t -> bool\n\n val increment_nonce : t -> bool\n\n val implicit_account_creation_fee : t -> bool\n\n val check_authorization :\n will_succeed:bool\n -> commitment:transaction_commitment\n -> calls:call_forest\n -> t\n -> [ `Proof_verifies of bool ] * [ `Signature_verifies of bool ]\n\n val is_signed : t -> bool\n\n val is_proved : t -> bool\n\n val verification_key_hash : t -> verification_key_hash\n\n module Update : sig\n type _ set_or_keep\n\n type timing\n\n val timing : t -> timing set_or_keep\n\n type field\n\n val app_state : t -> field set_or_keep Zkapp_state.V.t\n\n type verification_key\n\n val verification_key : t -> verification_key set_or_keep\n\n type actions\n\n val actions : t -> actions\n\n type zkapp_uri\n\n val zkapp_uri : t -> zkapp_uri set_or_keep\n\n type token_symbol\n\n val token_symbol : t -> token_symbol set_or_keep\n\n val delegate : t -> public_key set_or_keep\n\n type state_hash\n\n val voting_for : t -> state_hash set_or_keep\n\n type permissions\n\n val permissions : t -> permissions set_or_keep\n end\n\n module Account_precondition : sig\n val nonce : t -> nonce Zkapp_precondition.Closed_interval.t or_ignore\n end\nend\n\nmodule type Opt_intf = sig\n type bool\n\n type 'a t\n\n val is_some : 'a t -> bool\n\n val map : 'a t -> f:('a -> 'b) -> 'b t\n\n val or_default :\n if_:(bool -> then_:'a -> else_:'a -> 'a) -> 'a t -> default:'a -> 'a\n\n val or_exn : 'a t -> 'a\nend\n\nmodule type Stack_intf = sig\n include Iffable\n\n module Opt : Opt_intf with type bool := bool\n\n type elt\n\n val empty : unit -> t\n\n val is_empty : t -> bool\n\n val pop_exn : t -> elt * t\n\n val pop : t -> (elt * t) Opt.t\n\n val push : elt -> onto:t -> t\nend\n\nmodule type Call_forest_intf = sig\n include Iffable\n\n type account_update\n\n module Opt : Opt_intf with type bool := bool\n\n val empty : unit -> t\n\n val is_empty : t -> bool\n\n val pop_exn : t -> (account_update * t) * t\nend\n\nmodule type Stack_frame_intf = sig\n type caller\n\n type call_forest\n\n include Iffable\n\n val caller : t -> caller\n\n val caller_caller : t -> caller\n\n val calls : t -> call_forest\n\n val make : caller:caller -> caller_caller:caller -> calls:call_forest -> t\nend\n\nmodule type Call_stack_intf = sig\n type stack_frame\n\n include Stack_intf with type elt := stack_frame\nend\n\nmodule type Ledger_intf = sig\n include Iffable\n\n type public_key\n\n type token_id\n\n type account_update\n\n type account\n\n type inclusion_proof\n\n val empty : depth:int -> unit -> t\n\n val get_account : account_update -> t -> account * inclusion_proof\n\n val set_account : t -> account * inclusion_proof -> t\n\n val check_inclusion : t -> account * inclusion_proof -> unit\n\n val check_account :\n public_key -> token_id -> account * inclusion_proof -> [ `Is_new of bool ]\nend\n\nmodule type Controller_intf = sig\n include Iffable\n\n val check : proof_verifies:bool -> signature_verifies:bool -> t -> bool\nend\n\nmodule type Account_intf = sig\n type t\n\n type bool\n\n type public_key\n\n type account_id\n\n module Permissions : sig\n type controller\n\n val access : t -> controller\n\n val edit_state : t -> controller\n\n val send : t -> controller\n\n val receive : t -> controller\n\n val set_delegate : t -> controller\n\n val set_permissions : t -> controller\n\n val set_verification_key : t -> controller\n\n val set_zkapp_uri : t -> controller\n\n val edit_action_state : t -> controller\n\n val set_token_symbol : t -> controller\n\n val increment_nonce : t -> controller\n\n val set_voting_for : t -> controller\n\n val set_timing : t -> controller\n\n include Iffable with type bool := bool\n end\n\n type timing\n\n type token_id\n\n type receipt_chain_hash\n\n val timing : t -> timing\n\n val set_timing : t -> timing -> t\n\n val is_timed : t -> bool\n\n val set_token_id : t -> token_id -> t\n\n type balance\n\n val balance : t -> balance\n\n val set_balance : balance -> t -> t\n\n type global_slot\n\n val check_timing :\n txn_global_slot:global_slot\n -> t\n -> [ `Invalid_timing of bool | `Insufficient_balance of bool ] * timing\n\n val receipt_chain_hash : t -> receipt_chain_hash\n\n val set_receipt_chain_hash : t -> receipt_chain_hash -> t\n\n (** Fill the zkapp field of the account if it's currently [None] *)\n val make_zkapp : t -> t\n\n (** If the current account has no zkApp fields set, reset its zkapp field to\n [None].\n *)\n val unmake_zkapp : t -> t\n\n val proved_state : t -> bool\n\n val set_proved_state : bool -> t -> t\n\n type field\n\n val app_state : t -> field Zkapp_state.V.t\n\n val set_app_state : field Zkapp_state.V.t -> t -> t\n\n val register_verification_key : t -> unit\n\n type verification_key\n\n val verification_key : t -> verification_key\n\n val set_verification_key : verification_key -> t -> t\n\n type verification_key_hash\n\n val verification_key_hash : t -> verification_key_hash\n\n val last_action_slot : t -> global_slot\n\n val set_last_action_slot : global_slot -> t -> t\n\n val action_state : t -> field Pickles_types.Vector.Vector_5.t\n\n val set_action_state : field Pickles_types.Vector.Vector_5.t -> t -> t\n\n type zkapp_uri\n\n val zkapp_uri : t -> zkapp_uri\n\n val set_zkapp_uri : zkapp_uri -> t -> t\n\n type token_symbol\n\n val token_symbol : t -> token_symbol\n\n val set_token_symbol : token_symbol -> t -> t\n\n val public_key : t -> public_key\n\n val set_public_key : public_key -> t -> t\n\n val delegate : t -> public_key\n\n val set_delegate : public_key -> t -> t\n\n type nonce\n\n val nonce : t -> nonce\n\n val set_nonce : nonce -> t -> t\n\n type state_hash\n\n val voting_for : t -> state_hash\n\n val set_voting_for : state_hash -> t -> t\n\n val permissions : t -> Permissions.t\n\n val set_permissions : Permissions.t -> t -> t\nend\n\nmodule Eff = struct\n type (_, _) t =\n | Check_valid_while_precondition :\n 'valid_while_precondition * 'global_state\n -> ( 'bool\n , < bool : 'bool\n ; valid_while_precondition : 'valid_while_precondition\n ; global_state : 'global_state\n ; .. > )\n t\n | Check_account_precondition :\n (* the bool input is a new_account flag *)\n 'account_update\n * 'account\n * 'bool\n * 'local_state\n -> ( 'local_state\n , < bool : 'bool\n ; account_update : 'account_update\n ; account : 'account\n ; local_state : 'local_state\n ; .. > )\n t\n | Check_protocol_state_precondition :\n 'protocol_state_pred * 'global_state\n -> ( 'bool\n , < bool : 'bool\n ; global_state : 'global_state\n ; protocol_state_precondition : 'protocol_state_pred\n ; .. > )\n t\n | Init_account :\n { account_update : 'account_update; account : 'account }\n -> ( 'account\n , < account_update : 'account_update ; account : 'account ; .. > )\n t\nend\n\ntype 'e handler = { perform : 'r. ('r, 'e) Eff.t -> 'r }\n\nmodule type Inputs_intf = sig\n val with_label : label:string -> (unit -> 'a) -> 'a\n\n module Bool : Bool_intf\n\n module Field : Iffable with type bool := Bool.t\n\n module Amount : Amount_intf with type bool := Bool.t\n\n module Balance :\n Balance_intf\n with type bool := Bool.t\n and type amount := Amount.t\n and type signed_amount := Amount.Signed.t\n\n module Public_key : Iffable with type bool := Bool.t\n\n module Token_id : Token_id_intf with type bool := Bool.t\n\n module Account_id :\n Account_id_intf\n with type bool := Bool.t\n and type public_key := Public_key.t\n and type token_id := Token_id.t\n\n module Set_or_keep : Set_or_keep_intf with type bool := Bool.t\n\n module Protocol_state_precondition : Protocol_state_precondition_intf\n\n module Valid_while_precondition : Valid_while_precondition_intf\n\n module Controller : Controller_intf with type bool := Bool.t\n\n module Global_slot_since_genesis :\n Global_slot_since_genesis_intf with type bool := Bool.t\n\n module Global_slot_span : Global_slot_span_intf with type bool := Bool.t\n\n module Nonce : sig\n include Iffable with type bool := Bool.t\n\n val succ : t -> t\n end\n\n module State_hash : Iffable with type bool := Bool.t\n\n module Timing :\n Timing_intf\n with type bool := Bool.t\n and type global_slot_span := Global_slot_span.t\n\n module Zkapp_uri : Iffable with type bool := Bool.t\n\n module Token_symbol : Iffable with type bool := Bool.t\n\n module Opt : Opt_intf with type bool := Bool.t\n\n module rec Receipt_chain_hash :\n (Receipt_chain_hash_intf\n with type bool := Bool.t\n and type transaction_commitment := Transaction_commitment.t\n and type index := Index.t)\n\n and Verification_key : (Iffable with type bool := Bool.t)\n and Verification_key_hash :\n (Verification_key_hash_intf with type bool := Bool.t)\n\n and Account :\n (Account_intf\n with type Permissions.controller := Controller.t\n and type timing := Timing.t\n and type balance := Balance.t\n and type receipt_chain_hash := Receipt_chain_hash.t\n and type bool := Bool.t\n and type global_slot := Global_slot_since_genesis.t\n and type field := Field.t\n and type verification_key := Verification_key.t\n and type verification_key_hash := Verification_key_hash.t\n and type zkapp_uri := Zkapp_uri.t\n and type token_symbol := Token_symbol.t\n and type public_key := Public_key.t\n and type nonce := Nonce.t\n and type state_hash := State_hash.t\n and type token_id := Token_id.t\n and type account_id := Account_id.t)\n\n and Actions :\n (Actions_intf with type bool := Bool.t and type field := Field.t)\n\n and Account_update :\n (Account_update_intf\n with type signed_amount := Amount.Signed.t\n and type protocol_state_precondition := Protocol_state_precondition.t\n and type valid_while_precondition := Valid_while_precondition.t\n and type token_id := Token_id.t\n and type bool := Bool.t\n and type account := Account.t\n and type public_key := Public_key.t\n and type nonce := Nonce.t\n and type account_id := Account_id.t\n and type verification_key_hash := Verification_key_hash.t\n and type Update.timing := Timing.t\n and type 'a Update.set_or_keep := 'a Set_or_keep.t\n and type Update.field := Field.t\n and type Update.verification_key := Verification_key.t\n and type Update.actions := Actions.t\n and type Update.zkapp_uri := Zkapp_uri.t\n and type Update.token_symbol := Token_symbol.t\n and type Update.state_hash := State_hash.t\n and type Update.permissions := Account.Permissions.t)\n\n and Nonce_precondition : sig\n val is_constant :\n Nonce.t Zkapp_precondition.Closed_interval.t Account_update.or_ignore\n -> Bool.t\n end\n\n and Ledger :\n (Ledger_intf\n with type bool := Bool.t\n and type account := Account.t\n and type account_update := Account_update.t\n and type token_id := Token_id.t\n and type public_key := Public_key.t)\n\n and Call_forest :\n (Call_forest_intf\n with type t = Account_update.call_forest\n and type bool := Bool.t\n and type account_update := Account_update.t\n and module Opt := Opt)\n\n and Stack_frame :\n (Stack_frame_intf\n with type bool := Bool.t\n and type call_forest := Call_forest.t\n and type caller := Token_id.t)\n\n and Call_stack :\n (Call_stack_intf\n with type stack_frame := Stack_frame.t\n and type bool := Bool.t\n and module Opt := Opt)\n\n and Transaction_commitment : sig\n include\n Iffable\n with type bool := Bool.t\n and type t = Account_update.transaction_commitment\n\n val empty : t\n\n val commitment : account_updates:Call_forest.t -> t\n\n val full_commitment :\n account_update:Account_update.t -> memo_hash:Field.t -> commitment:t -> t\n end\n\n and Index : sig\n include Iffable with type bool := Bool.t\n\n val zero : t\n\n val succ : t -> t\n end\n\n module Local_state : sig\n type t =\n ( Stack_frame.t\n , Call_stack.t\n , Amount.Signed.t\n , Ledger.t\n , Bool.t\n , Transaction_commitment.t\n , Index.t\n , Bool.failure_status_tbl )\n Local_state.t\n\n val add_check : t -> Transaction_status.Failure.t -> Bool.t -> t\n\n val update_failure_status_tbl : t -> Bool.failure_status -> Bool.t -> t\n\n val add_new_failure_status_bucket : t -> t\n end\n\n module Global_state : sig\n type t\n\n val first_pass_ledger : t -> Ledger.t\n\n val set_first_pass_ledger : should_update:Bool.t -> t -> Ledger.t -> t\n\n val second_pass_ledger : t -> Ledger.t\n\n val set_second_pass_ledger : should_update:Bool.t -> t -> Ledger.t -> t\n\n val fee_excess : t -> Amount.Signed.t\n\n val set_fee_excess : t -> Amount.Signed.t -> t\n\n val supply_increase : t -> Amount.Signed.t\n\n val set_supply_increase : t -> Amount.Signed.t -> t\n\n val block_global_slot : t -> Global_slot_since_genesis.t\n end\nend\n\nmodule Start_data = struct\n open Core_kernel\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n type ('account_updates, 'field, 'bool) t =\n { account_updates : 'account_updates\n ; memo_hash : 'field\n ; will_succeed : 'bool\n }\n [@@deriving sexp, yojson]\n end\n end]\nend\n\nmodule Make (Inputs : Inputs_intf) = struct\n open Inputs\n\n let default_caller = Token_id.default\n\n let stack_frame_default () =\n Stack_frame.make ~caller:default_caller ~caller_caller:default_caller\n ~calls:(Call_forest.empty ())\n\n let assert_ ~pos b = Bool.Assert.is_true ~pos b\n\n (* Pop from the call stack, returning dummy values if the stack is empty. *)\n let pop_call_stack (s : Call_stack.t) : Stack_frame.t * Call_stack.t =\n let res = Call_stack.pop s in\n (* Split out the option returned by Call_stack.pop into two options *)\n let next_frame, next_call_stack =\n (Opt.map ~f:fst res, Opt.map ~f:snd res)\n in\n (* Handle the None cases *)\n ( Opt.or_default ~if_:Stack_frame.if_ ~default:(stack_frame_default ())\n next_frame\n , Opt.or_default ~if_:Call_stack.if_ ~default:(Call_stack.empty ())\n next_call_stack )\n\n type get_next_account_update_result =\n { account_update : Account_update.t\n ; caller_id : Token_id.t\n ; account_update_forest : Call_forest.t\n ; new_call_stack : Call_stack.t\n ; new_frame : Stack_frame.t\n }\n\n let get_next_account_update (current_forest : Stack_frame.t)\n (* The stack for the most recent zkApp *)\n (call_stack : Call_stack.t) (* The partially-completed parent stacks *)\n : get_next_account_update_result =\n (* If the current stack is complete, 'return' to the previous\n partially-completed one.\n *)\n let current_forest, call_stack =\n let next_forest, next_call_stack =\n (* Invariant: call_stack contains only non-empty forests. *)\n pop_call_stack call_stack\n in\n (* TODO: I believe current should only be empty for the first account_update in\n a transaction. *)\n let current_is_empty =\n Call_forest.is_empty (Stack_frame.calls current_forest)\n in\n ( Stack_frame.if_ current_is_empty ~then_:next_forest ~else_:current_forest\n , Call_stack.if_ current_is_empty ~then_:next_call_stack ~else_:call_stack\n )\n in\n let (account_update, account_update_forest), remainder_of_current_forest =\n Call_forest.pop_exn (Stack_frame.calls current_forest)\n in\n let may_use_parents_own_token =\n Account_update.may_use_parents_own_token account_update\n in\n let may_use_token_inherited_from_parent =\n Account_update.may_use_token_inherited_from_parent account_update\n in\n let caller_id =\n Token_id.if_ may_use_token_inherited_from_parent\n ~then_:(Stack_frame.caller_caller current_forest)\n ~else_:\n (Token_id.if_ may_use_parents_own_token\n ~then_:(Stack_frame.caller current_forest)\n ~else_:Token_id.default )\n in\n (* Cases:\n - [account_update_forest] is empty, [remainder_of_current_forest] is empty.\n Pop from the call stack to get another forest, which is guaranteed to be non-empty.\n The result of popping becomes the \"current forest\".\n - [account_update_forest] is empty, [remainder_of_current_forest] is non-empty.\n Push nothing to the stack. [remainder_of_current_forest] becomes new \"current forest\"\n - [account_update_forest] is non-empty, [remainder_of_current_forest] is empty.\n Push nothing to the stack. [account_update_forest] becomes new \"current forest\"\n - [account_update_forest] is non-empty, [remainder_of_current_forest] is non-empty:\n Push [remainder_of_current_forest] to the stack. [account_update_forest] becomes new \"current forest\".\n *)\n let account_update_forest_empty =\n Call_forest.is_empty account_update_forest\n in\n let remainder_of_current_forest_empty =\n Call_forest.is_empty remainder_of_current_forest\n in\n let newly_popped_frame, popped_call_stack = pop_call_stack call_stack in\n let remainder_of_current_forest_frame : Stack_frame.t =\n Stack_frame.make\n ~caller:(Stack_frame.caller current_forest)\n ~caller_caller:(Stack_frame.caller_caller current_forest)\n ~calls:remainder_of_current_forest\n in\n let new_call_stack =\n Call_stack.if_ account_update_forest_empty\n ~then_:\n (Call_stack.if_ remainder_of_current_forest_empty\n ~then_:\n (* Don't actually need the or_default used in this case. *)\n popped_call_stack ~else_:call_stack )\n ~else_:\n (Call_stack.if_ remainder_of_current_forest_empty ~then_:call_stack\n ~else_:\n (Call_stack.push remainder_of_current_forest_frame\n ~onto:call_stack ) )\n in\n let new_frame =\n Stack_frame.if_ account_update_forest_empty\n ~then_:\n (Stack_frame.if_ remainder_of_current_forest_empty\n ~then_:newly_popped_frame ~else_:remainder_of_current_forest_frame )\n ~else_:\n (let caller =\n Account_id.derive_token_id\n ~owner:(Account_update.account_id account_update)\n and caller_caller = caller_id in\n Stack_frame.make ~calls:account_update_forest ~caller ~caller_caller\n )\n in\n { account_update\n ; caller_id\n ; account_update_forest\n ; new_frame\n ; new_call_stack\n }\n\n let update_action_state (action_state : _ Pickles_types.Vector.t) actions\n ~txn_global_slot ~last_action_slot =\n (* Push events to s1. *)\n let [ s1'; s2'; s3'; s4'; s5' ] = action_state in\n let is_empty = Actions.is_empty actions in\n let s1_updated = Actions.push_events s1' actions in\n let s1 = Field.if_ is_empty ~then_:s1' ~else_:s1_updated in\n (* Shift along if not empty and last update wasn't this slot *)\n let is_this_slot =\n Global_slot_since_genesis.equal txn_global_slot last_action_slot\n in\n let is_empty_or_this_slot = Bool.(is_empty ||| is_this_slot) in\n let s5 = Field.if_ is_empty_or_this_slot ~then_:s5' ~else_:s4' in\n let s4 = Field.if_ is_empty_or_this_slot ~then_:s4' ~else_:s3' in\n let s3 = Field.if_ is_empty_or_this_slot ~then_:s3' ~else_:s2' in\n let s2 = Field.if_ is_empty_or_this_slot ~then_:s2' ~else_:s1' in\n let last_action_slot =\n Global_slot_since_genesis.if_ is_empty ~then_:last_action_slot\n ~else_:txn_global_slot\n in\n (([ s1; s2; s3; s4; s5 ] : _ Pickles_types.Vector.t), last_action_slot)\n\n let apply ~(constraint_constants : Genesis_constants.Constraint_constants.t)\n ~(is_start : [ `Yes of _ Start_data.t | `No | `Compute of _ Start_data.t ])\n (h :\n (< global_state : Global_state.t\n ; transaction_commitment : Transaction_commitment.t\n ; full_transaction_commitment : Transaction_commitment.t\n ; amount : Amount.t\n ; bool : Bool.t\n ; failure : Bool.failure_status\n ; .. >\n as\n 'env )\n handler )\n ((global_state : Global_state.t), (local_state : Local_state.t)) =\n let open Inputs in\n let is_start' =\n let is_empty_call_forest =\n Call_forest.is_empty (Stack_frame.calls local_state.stack_frame)\n in\n ( match is_start with\n | `Compute _ ->\n ()\n | `Yes _ ->\n assert_ ~pos:__POS__ is_empty_call_forest\n | `No ->\n assert_ ~pos:__POS__ (Bool.not is_empty_call_forest) ) ;\n match is_start with\n | `Yes _ ->\n Bool.true_\n | `No ->\n Bool.false_\n | `Compute _ ->\n is_empty_call_forest\n in\n let will_succeed =\n match is_start with\n | `Compute start_data ->\n Bool.if_ is_start' ~then_:start_data.will_succeed\n ~else_:local_state.will_succeed\n | `Yes start_data ->\n start_data.will_succeed\n | `No ->\n local_state.will_succeed\n in\n let local_state =\n { local_state with\n ledger =\n Inputs.Ledger.if_ is_start'\n ~then_:(Inputs.Global_state.first_pass_ledger global_state)\n ~else_:local_state.ledger\n ; will_succeed\n }\n in\n let ( (account_update, remaining, call_stack)\n , account_update_forest\n , local_state\n , (a, inclusion_proof) ) =\n let to_pop, call_stack =\n match is_start with\n | `Compute start_data ->\n ( Stack_frame.if_ is_start'\n ~then_:\n (Stack_frame.make ~calls:start_data.account_updates\n ~caller:default_caller ~caller_caller:default_caller )\n ~else_:local_state.stack_frame\n , Call_stack.if_ is_start' ~then_:(Call_stack.empty ())\n ~else_:local_state.call_stack )\n | `Yes start_data ->\n ( Stack_frame.make ~calls:start_data.account_updates\n ~caller:default_caller ~caller_caller:default_caller\n , Call_stack.empty () )\n | `No ->\n (local_state.stack_frame, local_state.call_stack)\n in\n let { account_update\n ; caller_id\n ; account_update_forest\n ; new_frame = remaining\n ; new_call_stack = call_stack\n } =\n with_label ~label:\"get next account update\" (fun () ->\n (* TODO: Make the stack frame hashed inside of the local state *)\n get_next_account_update to_pop call_stack )\n in\n let local_state =\n with_label ~label:\"token owner not caller\" (fun () ->\n let default_token_or_token_owner_was_caller =\n (* Check that the token owner was consulted if using a non-default\n token *)\n let account_update_token_id =\n Account_update.token_id account_update\n in\n Bool.( ||| )\n (Token_id.equal account_update_token_id Token_id.default)\n (Token_id.equal account_update_token_id caller_id)\n in\n Local_state.add_check local_state Token_owner_not_caller\n default_token_or_token_owner_was_caller )\n in\n let ((a, inclusion_proof) as acct) =\n with_label ~label:\"get account\" (fun () ->\n Inputs.Ledger.get_account account_update local_state.ledger )\n in\n Inputs.Ledger.check_inclusion local_state.ledger (a, inclusion_proof) ;\n let transaction_commitment, full_transaction_commitment =\n match is_start with\n | `No ->\n ( local_state.transaction_commitment\n , local_state.full_transaction_commitment )\n | `Yes start_data | `Compute start_data ->\n let tx_commitment_on_start =\n Transaction_commitment.commitment\n ~account_updates:(Stack_frame.calls remaining)\n in\n let full_tx_commitment_on_start =\n Transaction_commitment.full_commitment ~account_update\n ~memo_hash:start_data.memo_hash\n ~commitment:tx_commitment_on_start\n in\n let tx_commitment =\n Transaction_commitment.if_ is_start' ~then_:tx_commitment_on_start\n ~else_:local_state.transaction_commitment\n in\n let full_tx_commitment =\n Transaction_commitment.if_ is_start'\n ~then_:full_tx_commitment_on_start\n ~else_:local_state.full_transaction_commitment\n in\n (tx_commitment, full_tx_commitment)\n in\n let local_state =\n { local_state with transaction_commitment; full_transaction_commitment }\n in\n ( (account_update, remaining, call_stack)\n , account_update_forest\n , local_state\n , acct )\n in\n let local_state =\n { local_state with stack_frame = remaining; call_stack }\n in\n let local_state = Local_state.add_new_failure_status_bucket local_state in\n (* Register verification key, in case it needs to be 'side-loaded' to\n verify a zkapp proof.\n *)\n Account.register_verification_key a ;\n let (`Is_new account_is_new) =\n Inputs.Ledger.check_account\n (Account_update.public_key account_update)\n (Account_update.token_id account_update)\n (a, inclusion_proof)\n in\n (* delegate to public key if new account using default token *)\n let a =\n let self_delegate =\n let account_update_token_id = Account_update.token_id account_update in\n Bool.(\n account_is_new\n &&& Token_id.equal account_update_token_id Token_id.default)\n in\n (* in-SNARK, a new account has the empty public key here\n in that case, use the public key from the account update, not the account\n *)\n Account.set_delegate\n (Public_key.if_ self_delegate\n ~then_:(Account_update.public_key account_update)\n ~else_:(Account.delegate a) )\n a\n in\n let matching_verification_key_hashes =\n Inputs.Bool.(\n (not (Account_update.is_proved account_update))\n ||| Verification_key_hash.equal\n (Account.verification_key_hash a)\n (Account_update.verification_key_hash account_update))\n in\n let local_state =\n Local_state.add_check local_state Unexpected_verification_key_hash\n matching_verification_key_hashes\n in\n let local_state =\n h.perform\n (Check_account_precondition\n (account_update, a, account_is_new, local_state) )\n in\n let protocol_state_predicate_satisfied =\n h.perform\n (Check_protocol_state_precondition\n ( Account_update.protocol_state_precondition account_update\n , global_state ) )\n in\n let local_state =\n Local_state.add_check local_state Protocol_state_precondition_unsatisfied\n protocol_state_predicate_satisfied\n in\n let local_state =\n let valid_while_satisfied =\n h.perform\n (Check_valid_while_precondition\n ( Account_update.valid_while_precondition account_update\n , global_state ) )\n in\n Local_state.add_check local_state Valid_while_precondition_unsatisfied\n valid_while_satisfied\n in\n let `Proof_verifies proof_verifies, `Signature_verifies signature_verifies =\n let commitment =\n Inputs.Transaction_commitment.if_\n (Inputs.Account_update.use_full_commitment account_update)\n ~then_:local_state.full_transaction_commitment\n ~else_:local_state.transaction_commitment\n in\n Inputs.Account_update.check_authorization\n ~will_succeed:local_state.will_succeed ~commitment\n ~calls:account_update_forest account_update\n in\n assert_ ~pos:__POS__\n (Bool.equal proof_verifies (Account_update.is_proved account_update)) ;\n assert_ ~pos:__POS__\n (Bool.equal signature_verifies (Account_update.is_signed account_update)) ;\n (* The fee-payer must increment their nonce. *)\n let local_state =\n Local_state.add_check local_state Fee_payer_nonce_must_increase\n Inputs.Bool.(\n Inputs.Account_update.increment_nonce account_update ||| not is_start')\n in\n let local_state =\n Local_state.add_check local_state Fee_payer_must_be_signed\n Inputs.Bool.(signature_verifies ||| not is_start')\n in\n let local_state =\n let precondition_has_constant_nonce =\n Inputs.Account_update.Account_precondition.nonce account_update\n |> Inputs.Nonce_precondition.is_constant\n in\n let increments_nonce_and_constrains_its_old_value =\n Inputs.Bool.(\n Inputs.Account_update.increment_nonce account_update\n &&& precondition_has_constant_nonce)\n in\n let depends_on_the_fee_payers_nonce_and_isnt_the_fee_payer =\n Inputs.Bool.(\n Inputs.Account_update.use_full_commitment account_update\n &&& not is_start')\n in\n let does_not_use_a_signature = Inputs.Bool.not signature_verifies in\n Local_state.add_check local_state Zkapp_command_replay_check_failed\n Inputs.Bool.(\n increments_nonce_and_constrains_its_old_value\n ||| depends_on_the_fee_payers_nonce_and_isnt_the_fee_payer\n ||| does_not_use_a_signature)\n in\n let a = Account.set_token_id a (Account_update.token_id account_update) in\n let account_update_token = Account_update.token_id account_update in\n let account_update_token_is_default =\n Token_id.(equal default) account_update_token\n in\n let account_is_untimed = Bool.not (Account.is_timed a) in\n (* Set account timing. *)\n let a, local_state =\n let timing = Account_update.Update.timing account_update in\n let has_permission =\n Controller.check ~proof_verifies ~signature_verifies\n (Account.Permissions.set_timing a)\n in\n let local_state =\n Local_state.add_check local_state Update_not_permitted_timing\n Bool.(\n Set_or_keep.is_keep timing\n ||| (account_is_untimed &&& has_permission))\n in\n let timing =\n Set_or_keep.set_or_keep ~if_:Timing.if_ timing (Account.timing a)\n in\n let vesting_period = Timing.vesting_period timing in\n (* Assert that timing is valid, otherwise we may have a division by 0. *)\n assert_ ~pos:__POS__ Global_slot_span.(vesting_period > zero) ;\n let a = Account.set_timing a timing in\n (a, local_state)\n in\n let account_creation_fee =\n Amount.of_constant_fee constraint_constants.account_creation_fee\n in\n let implicit_account_creation_fee =\n Account_update.implicit_account_creation_fee account_update\n in\n (* Check the token for implicit account creation fee payment. *)\n let local_state =\n Local_state.add_check local_state Cannot_pay_creation_fee_in_token\n Bool.(\n (not implicit_account_creation_fee)\n ||| account_update_token_is_default)\n in\n (* Compute the change to the account balance. *)\n let local_state, actual_balance_change =\n let balance_change = Account_update.balance_change account_update in\n let neg_creation_fee =\n let open Amount.Signed in\n negate (of_unsigned account_creation_fee)\n in\n let balance_change_for_creation, `Overflow creation_overflow =\n let open Amount.Signed in\n add_flagged balance_change neg_creation_fee\n in\n let pay_creation_fee =\n Bool.(account_is_new &&& implicit_account_creation_fee)\n in\n let creation_overflow = Bool.(pay_creation_fee &&& creation_overflow) in\n let balance_change =\n Amount.Signed.if_ pay_creation_fee ~then_:balance_change_for_creation\n ~else_:balance_change\n in\n let local_state =\n Local_state.add_check local_state Amount_insufficient_to_create_account\n Bool.(\n not\n ( pay_creation_fee\n &&& (creation_overflow ||| Amount.Signed.is_neg balance_change) ))\n in\n (local_state, balance_change)\n in\n (* Apply balance change. *)\n let a, local_state =\n let pay_creation_fee_from_excess =\n Bool.(account_is_new &&& not implicit_account_creation_fee)\n in\n let balance, `Overflow failed1 =\n Balance.add_signed_amount_flagged (Account.balance a)\n actual_balance_change\n in\n (* TODO: Should this report 'insufficient balance'? *)\n let local_state =\n Local_state.add_check local_state Overflow (Bool.not failed1)\n in\n let account_creation_fee =\n Amount.of_constant_fee constraint_constants.account_creation_fee\n in\n let local_state =\n (* Conditionally subtract account creation fee from fee excess *)\n let excess_minus_creation_fee, `Overflow excess_update_failed =\n Amount.Signed.add_flagged local_state.excess\n Amount.Signed.(negate (of_unsigned account_creation_fee))\n in\n let local_state =\n Local_state.add_check local_state Local_excess_overflow\n Bool.(not (pay_creation_fee_from_excess &&& excess_update_failed))\n in\n { local_state with\n excess =\n Amount.Signed.if_ pay_creation_fee_from_excess\n ~then_:excess_minus_creation_fee ~else_:local_state.excess\n }\n in\n let local_state =\n (* Conditionally subtract account creation fee from supply increase *)\n let ( supply_increase_minus_creation_fee\n , `Overflow supply_increase_update_failed ) =\n Amount.Signed.add_flagged local_state.supply_increase\n Amount.Signed.(negate (of_unsigned account_creation_fee))\n in\n let local_state =\n Local_state.add_check local_state Local_supply_increase_overflow\n Bool.(not (account_is_new &&& supply_increase_update_failed))\n in\n { local_state with\n supply_increase =\n Amount.Signed.if_ account_is_new\n ~then_:supply_increase_minus_creation_fee\n ~else_:local_state.supply_increase\n }\n in\n let is_receiver = Amount.Signed.is_non_neg actual_balance_change in\n let local_state =\n let controller =\n Controller.if_ is_receiver\n ~then_:(Account.Permissions.receive a)\n ~else_:(Account.Permissions.send a)\n in\n let has_permission =\n Controller.check ~proof_verifies ~signature_verifies controller\n in\n Local_state.add_check local_state Update_not_permitted_balance\n Bool.(\n has_permission\n ||| Amount.Signed.(\n equal (of_unsigned Amount.zero) actual_balance_change))\n in\n let a = Account.set_balance balance a in\n (a, local_state)\n in\n let txn_global_slot = Global_state.block_global_slot global_state in\n (* Check timing with current balance *)\n let a, local_state =\n let `Invalid_timing invalid_timing, timing =\n match Account.check_timing ~txn_global_slot a with\n | `Insufficient_balance _, _ ->\n failwith \"Did not propose a balance change at this timing check!\"\n | `Invalid_timing invalid_timing, timing ->\n (* NB: Have to destructure to remove the possibility of\n [`Insufficient_balance _] in the type.\n *)\n (`Invalid_timing invalid_timing, timing)\n in\n let local_state =\n Local_state.add_check local_state Source_minimum_balance_violation\n (Bool.not invalid_timing)\n in\n let a = Account.set_timing a timing in\n (a, local_state)\n in\n (* Transform into a zkApp account.\n This must be done before updating zkApp fields!\n *)\n let a = Account.make_zkapp a in\n (* Check that the account can be accessed with the given authorization. *)\n let local_state =\n let has_permission =\n Controller.check ~proof_verifies ~signature_verifies\n (Account.Permissions.access a)\n in\n Local_state.add_check local_state Update_not_permitted_access\n has_permission\n in\n (* Update app state. *)\n let a, local_state =\n let app_state = Account_update.Update.app_state account_update in\n let keeping_app_state =\n Bool.all\n (List.map ~f:Set_or_keep.is_keep\n (Pickles_types.Vector.to_list app_state) )\n in\n let changing_entire_app_state =\n Bool.all\n (List.map ~f:Set_or_keep.is_set\n (Pickles_types.Vector.to_list app_state) )\n in\n let proved_state =\n (* The [proved_state] tracks whether the app state has been entirely\n determined by proofs ([true] if so), to allow zkApp authors to be\n confident that their initialization logic has been run, rather than\n some malicious deployer instantiating the zkApp in an account with\n some fake non-initial state.\n The logic here is:\n * if the state is unchanged, keep the previous value;\n * if the state has been entirely replaced, and the authentication\n was a proof, the state has been 'proved' and [proved_state] is set\n to [true];\n * if the state has been partially updated by a proof, the\n [proved_state] is unchanged;\n * if the state has been changed by some authentication other than a\n proof, the state is considered to have been tampered with, and\n [proved_state] is reset to [false].\n *)\n Bool.if_ keeping_app_state ~then_:(Account.proved_state a)\n ~else_:\n (Bool.if_ proof_verifies\n ~then_:\n (Bool.if_ changing_entire_app_state ~then_:Bool.true_\n ~else_:(Account.proved_state a) )\n ~else_:Bool.false_ )\n in\n let a = Account.set_proved_state proved_state a in\n let has_permission =\n Controller.check ~proof_verifies ~signature_verifies\n (Account.Permissions.edit_state a)\n in\n let local_state =\n Local_state.add_check local_state Update_not_permitted_app_state\n Bool.(keeping_app_state ||| has_permission)\n in\n let app_state =\n Pickles_types.Vector.map2 app_state (Account.app_state a)\n ~f:(Set_or_keep.set_or_keep ~if_:Field.if_)\n in\n let a = Account.set_app_state app_state a in\n (a, local_state)\n in\n (* Set verification key. *)\n let a, local_state =\n let verification_key =\n Account_update.Update.verification_key account_update\n in\n let has_permission =\n Controller.check ~proof_verifies ~signature_verifies\n (Account.Permissions.set_verification_key a)\n in\n let local_state =\n Local_state.add_check local_state Update_not_permitted_verification_key\n Bool.(Set_or_keep.is_keep verification_key ||| has_permission)\n in\n let verification_key =\n Set_or_keep.set_or_keep ~if_:Verification_key.if_ verification_key\n (Account.verification_key a)\n in\n let a = Account.set_verification_key verification_key a in\n (a, local_state)\n in\n (* Update action state. *)\n let a, local_state =\n let actions = Account_update.Update.actions account_update in\n let last_action_slot = Account.last_action_slot a in\n let action_state, last_action_slot =\n update_action_state (Account.action_state a) actions ~txn_global_slot\n ~last_action_slot\n in\n let is_empty =\n (* also computed in update_action_state, but messy to return it *)\n Actions.is_empty actions\n in\n let has_permission =\n Controller.check ~proof_verifies ~signature_verifies\n (Account.Permissions.edit_action_state a)\n in\n let local_state =\n Local_state.add_check local_state Update_not_permitted_action_state\n Bool.(is_empty ||| has_permission)\n in\n let a =\n a\n |> Account.set_action_state action_state\n |> Account.set_last_action_slot last_action_slot\n in\n (a, local_state)\n in\n (* Update zkApp URI. *)\n let a, local_state =\n let zkapp_uri = Account_update.Update.zkapp_uri account_update in\n let has_permission =\n Controller.check ~proof_verifies ~signature_verifies\n (Account.Permissions.set_zkapp_uri a)\n in\n let local_state =\n Local_state.add_check local_state Update_not_permitted_zkapp_uri\n Bool.(Set_or_keep.is_keep zkapp_uri ||| has_permission)\n in\n let zkapp_uri =\n Set_or_keep.set_or_keep ~if_:Zkapp_uri.if_ zkapp_uri\n (Account.zkapp_uri a)\n in\n let a = Account.set_zkapp_uri zkapp_uri a in\n (a, local_state)\n in\n (* At this point, all possible changes have been made to the zkapp\n part of an account. Reset zkApp state to [None] if that part\n is unmodified.\n *)\n let a = Account.unmake_zkapp a in\n (* Update token symbol. *)\n let a, local_state =\n let token_symbol = Account_update.Update.token_symbol account_update in\n let has_permission =\n Controller.check ~proof_verifies ~signature_verifies\n (Account.Permissions.set_token_symbol a)\n in\n let local_state =\n Local_state.add_check local_state Update_not_permitted_token_symbol\n Bool.(Set_or_keep.is_keep token_symbol ||| has_permission)\n in\n let token_symbol =\n Set_or_keep.set_or_keep ~if_:Token_symbol.if_ token_symbol\n (Account.token_symbol a)\n in\n let a = Account.set_token_symbol token_symbol a in\n (a, local_state)\n in\n (* Update delegate. *)\n let a, local_state =\n let delegate = Account_update.Update.delegate account_update in\n (* for new accounts using the default token, we've already\n set the delegate to the public key\n *)\n let base_delegate = Account.delegate a in\n let has_permission =\n Controller.check ~proof_verifies ~signature_verifies\n (Account.Permissions.set_delegate a)\n in\n let local_state =\n (* Note: only accounts for the default token can delegate. *)\n Local_state.add_check local_state Update_not_permitted_delegate\n Bool.(\n Set_or_keep.is_keep delegate\n ||| (has_permission &&& account_update_token_is_default))\n in\n let delegate =\n Set_or_keep.set_or_keep ~if_:Public_key.if_ delegate base_delegate\n in\n let a = Account.set_delegate delegate a in\n (a, local_state)\n in\n (* Update nonce. *)\n let a, local_state =\n let nonce = Account.nonce a in\n let increment_nonce = Account_update.increment_nonce account_update in\n let nonce =\n Nonce.if_ increment_nonce ~then_:(Nonce.succ nonce) ~else_:nonce\n in\n let has_permission =\n Controller.check ~proof_verifies ~signature_verifies\n (Account.Permissions.increment_nonce a)\n in\n let local_state =\n Local_state.add_check local_state Update_not_permitted_nonce\n Bool.((not increment_nonce) ||| has_permission)\n in\n let a = Account.set_nonce nonce a in\n (a, local_state)\n in\n (* Update voting-for. *)\n let a, local_state =\n let voting_for = Account_update.Update.voting_for account_update in\n let has_permission =\n Controller.check ~proof_verifies ~signature_verifies\n (Account.Permissions.set_voting_for a)\n in\n let local_state =\n Local_state.add_check local_state Update_not_permitted_voting_for\n Bool.(Set_or_keep.is_keep voting_for ||| has_permission)\n in\n let voting_for =\n Set_or_keep.set_or_keep ~if_:State_hash.if_ voting_for\n (Account.voting_for a)\n in\n let a = Account.set_voting_for voting_for a in\n (a, local_state)\n in\n (* Update receipt chain hash *)\n let a =\n let new_hash =\n let old_hash = Account.receipt_chain_hash a in\n Receipt_chain_hash.if_\n (let open Inputs.Bool in\n signature_verifies ||| proof_verifies)\n ~then_:\n (let elt =\n local_state.full_transaction_commitment\n |> Receipt_chain_hash.Elt.of_transaction_commitment\n in\n Receipt_chain_hash.cons_zkapp_command_commitment\n local_state.account_update_index elt old_hash )\n ~else_:old_hash\n in\n Account.set_receipt_chain_hash a new_hash\n in\n (* Finally, update permissions.\n This should be the last update applied, to ensure that any earlier\n updates use the account's existing permissions, and not permissions that\n are specified by the account_update!\n *)\n let a, local_state =\n let permissions = Account_update.Update.permissions account_update in\n let has_permission =\n Controller.check ~proof_verifies ~signature_verifies\n (Account.Permissions.set_permissions a)\n in\n let local_state =\n Local_state.add_check local_state Update_not_permitted_permissions\n Bool.(Set_or_keep.is_keep permissions ||| has_permission)\n in\n let permissions =\n Set_or_keep.set_or_keep ~if_:Account.Permissions.if_ permissions\n (Account.permissions a)\n in\n let a = Account.set_permissions permissions a in\n (a, local_state)\n in\n (* Initialize account's pk, in case it is new. *)\n let a = h.perform (Init_account { account_update; account = a }) in\n (* DO NOT ADD ANY UPDATES HERE. They must be earlier in the code.\n See comment above.\n *)\n let local_delta =\n (* NOTE: It is *not* correct to use the actual change in balance here.\n Indeed, if the account creation fee is paid, using that amount would\n be equivalent to paying it out to the block producer.\n In the case of a failure that prevents any updates from being applied,\n every other account_update in this transaction will also fail, and the\n excess will never be promoted to the global excess, so this amount is\n irrelevant.\n *)\n Amount.Signed.negate (Account_update.balance_change account_update)\n in\n let new_local_fee_excess, `Overflow overflowed =\n (* We only allow the default token for fees. *)\n Bool.(\n assert_ ~pos:__POS__\n ( (not is_start')\n ||| ( account_update_token_is_default\n &&& Amount.Signed.is_non_neg local_delta ) )) ;\n let new_local_fee_excess, `Overflow overflow =\n Amount.Signed.add_flagged local_state.excess local_delta\n in\n ( Amount.Signed.if_ account_update_token_is_default\n ~then_:new_local_fee_excess ~else_:local_state.excess\n , (* No overflow if we aren't using the result of the addition (which we don't in the case that account_update token is not default). *)\n `Overflow (Bool.( &&& ) account_update_token_is_default overflow) )\n in\n let local_state = { local_state with excess = new_local_fee_excess } in\n let local_state =\n Local_state.add_check local_state Local_excess_overflow\n (Bool.not overflowed)\n in\n (* If a's token ID differs from that in the local state, then\n the local state excess gets moved into the execution state's fee excess.\n\n If there are more zkapp_command to execute after this one, then the local delta gets\n accumulated in the local state.\n\n If there are no more zkapp_command to execute, then we do the same as if we switch tokens.\n The local state excess (plus the local delta) gets moved to the fee excess if it is default token.\n *)\n let new_ledger =\n Inputs.Ledger.set_account local_state.ledger (a, inclusion_proof)\n in\n let is_last_account_update =\n Call_forest.is_empty (Stack_frame.calls remaining)\n in\n let local_state =\n { local_state with\n ledger = new_ledger\n ; transaction_commitment =\n Transaction_commitment.if_ is_last_account_update\n ~then_:Transaction_commitment.empty\n ~else_:local_state.transaction_commitment\n ; full_transaction_commitment =\n Transaction_commitment.if_ is_last_account_update\n ~then_:Transaction_commitment.empty\n ~else_:local_state.full_transaction_commitment\n }\n in\n let valid_fee_excess =\n let delta_settled =\n Amount.Signed.equal local_state.excess Amount.(Signed.of_unsigned zero)\n in\n (* 1) ignore local excess if it is_start because it will be promoted to global\n excess and then set to zero later in the code\n 2) ignore everything but last account update since the excess wouldn't have\n been settled\n 3) Excess should be settled after the last account update has been applied.\n *)\n Bool.(is_start' ||| not is_last_account_update ||| delta_settled)\n in\n let local_state =\n Local_state.add_check local_state Invalid_fee_excess valid_fee_excess\n in\n let is_start_or_last = Bool.(is_start' ||| is_last_account_update) in\n let update_global_state_fee_excess =\n Bool.(is_start_or_last &&& local_state.success)\n in\n let global_state, global_excess_update_failed =\n let amt = Global_state.fee_excess global_state in\n let res, `Overflow overflow =\n Amount.Signed.add_flagged amt local_state.excess\n in\n let global_excess_update_failed =\n Bool.(update_global_state_fee_excess &&& overflow)\n in\n let new_amt =\n Amount.Signed.if_ update_global_state_fee_excess ~then_:res ~else_:amt\n in\n ( Global_state.set_fee_excess global_state new_amt\n , global_excess_update_failed )\n in\n let local_state =\n { local_state with\n excess =\n Amount.Signed.if_ is_start_or_last\n ~then_:Amount.(Signed.of_unsigned zero)\n ~else_:local_state.excess\n }\n in\n let local_state =\n Local_state.add_check local_state Global_excess_overflow\n Bool.(not global_excess_update_failed)\n in\n (* add local supply increase in global state *)\n let new_global_supply_increase, global_supply_increase_update_failed =\n let res, `Overflow overflow =\n Amount.Signed.add_flagged\n (Global_state.supply_increase global_state)\n local_state.supply_increase\n in\n (res, overflow)\n in\n let local_state =\n Local_state.add_check local_state Global_supply_increase_overflow\n Bool.(not global_supply_increase_update_failed)\n in\n (* The first account_update must succeed. *)\n Bool.(\n assert_with_failure_status_tbl ~pos:__POS__\n ((not is_start') ||| local_state.success)\n local_state.failure_status_tbl) ;\n (* If we are the fee payer (is_start' = true), push the first pass ledger\n and set the local ledger to be the second pass ledger in preparation for\n the children.\n *)\n let local_state, global_state =\n let is_fee_payer = is_start' in\n let global_state =\n Global_state.set_first_pass_ledger ~should_update:is_fee_payer\n global_state local_state.ledger\n in\n let local_state =\n { local_state with\n ledger =\n Inputs.Ledger.if_ is_fee_payer\n ~then_:(Global_state.second_pass_ledger global_state)\n ~else_:local_state.ledger\n }\n in\n (local_state, global_state)\n in\n (* If this is the last account update, and [will_succeed] is false, then\n [success] must also be false.\n *)\n Bool.(\n Assert.any ~pos:__POS__\n [ not is_last_account_update\n ; local_state.will_succeed\n ; not local_state.success\n ]) ;\n (* If this is the last party and there were no failures, update the second\n pass ledger and the supply increase.\n *)\n let global_state =\n let is_successful_last_party =\n Bool.(is_last_account_update &&& local_state.success)\n in\n let global_state =\n Global_state.set_supply_increase global_state\n (Amount.Signed.if_ is_successful_last_party\n ~then_:new_global_supply_increase\n ~else_:(Global_state.supply_increase global_state) )\n in\n Global_state.set_second_pass_ledger\n ~should_update:is_successful_last_party global_state local_state.ledger\n in\n let local_state =\n (* Make sure to reset the local_state at the end of a transaction.\n The following fields are already reset\n - zkapp_command\n - transaction_commitment\n - full_transaction_commitment\n - excess\n so we need to reset\n - token_id = Token_id.default\n - ledger = Frozen_ledger_hash.empty_hash\n - success = true\n - account_update_index = Index.zero\n - supply_increase = Amount.Signed.zero\n *)\n { local_state with\n ledger =\n Inputs.Ledger.if_ is_last_account_update\n ~then_:(Inputs.Ledger.empty ~depth:0 ())\n ~else_:local_state.ledger\n ; success =\n Bool.if_ is_last_account_update ~then_:Bool.true_\n ~else_:local_state.success\n ; account_update_index =\n Inputs.Index.if_ is_last_account_update ~then_:Inputs.Index.zero\n ~else_:(Inputs.Index.succ local_state.account_update_index)\n ; supply_increase =\n Amount.Signed.if_ is_last_account_update\n ~then_:Amount.(Signed.of_unsigned zero)\n ~else_:local_state.supply_increase\n ; will_succeed =\n Bool.if_ is_last_account_update ~then_:Bool.true_\n ~else_:local_state.will_succeed\n }\n in\n (global_state, local_state)\n\n let step h state = apply ~is_start:`No h state\n\n let start start_data h state = apply ~is_start:(`Yes start_data) h state\nend\n","open! Import\nopen Std_internal\nmodule Repr = Int63\n\nmodule T : sig\n type t [@@deriving compare, hash, sexp_of]\n\n val to_string : t -> string\n val of_repr : Repr.t -> t\n val to_repr : t -> Repr.t\nend = struct\n type t = Repr.t [@@deriving compare, hash]\n\n let of_repr = Fn.id\n let to_repr = Fn.id\n\n let to_string n =\n let open Repr in\n let kib = of_int 1024 in\n let mib = kib * kib in\n let gib = kib * mib in\n let n_abs = abs n in\n if n_abs < kib\n then sprintf \"%dB\" (to_int_exn n)\n else if n_abs < mib\n then sprintf \"%gK\" (to_float n /. to_float kib)\n else if n_abs < gib\n then sprintf \"%gM\" (to_float n /. to_float mib)\n else sprintf \"%gG\" (to_float n /. to_float gib)\n ;;\n\n let sexp_of_t n = Sexp.Atom (to_string n)\nend\n\ninclude T\n\nlet bytes_int_exn t = Repr.to_int_exn (to_repr t)\n","open! Import\nopen Std_internal\nopen Bigarray\nmodule Binable = Binable0\n\nmodule Stable = struct\n module V1 = struct\n include Base_bigstring\n\n module Z : sig\n type t = (char, int8_unsigned_elt, c_layout) Array1.t [@@deriving bin_io]\n end = struct\n type t = bigstring [@@deriving bin_io]\n end\n\n include Z\n\n type t_frozen = t [@@deriving bin_io]\n end\nend\n\nmodule T = Stable.V1\ninclude T\nmodule Unstable = T\n\nlet create ?max_mem_waiting_gc size =\n let max_mem_waiting_gc_in_bytes =\n Option.map max_mem_waiting_gc ~f:Byte_units0.bytes_int_exn\n in\n create ?max_mem_waiting_gc_in_bytes size\n;;\n\nlet sub_shared ?(pos = 0) ?len (bstr : t) =\n let len = get_opt_len bstr ~pos len in\n Array1.sub bstr pos len\n;;\n\n(* Destruction *)\n\nexternal unsafe_destroy : t -> unit = \"bigstring_destroy_stub\"\n\nexternal unsafe_destroy_and_resize : t -> len:int -> t = \"bigstring_realloc\"\n\n(* Reading / writing bin-prot *)\n\nlet read_bin_prot_verbose_errors t ?(pos = 0) ?len reader =\n let len = get_opt_len t len ~pos in\n let limit = pos + len in\n check_args ~loc:\"read_bin_prot_verbose_errors\" t ~pos ~len;\n let invalid_data message a sexp_of_a =\n `Invalid_data (Error.create message a sexp_of_a)\n in\n let read bin_reader ~pos ~len =\n if len > limit - pos\n then `Not_enough_data\n else (\n let pos_ref = ref pos in\n match\n try `Ok (bin_reader t ~pos_ref) with\n | exn -> `Invalid_data (Error.of_exn exn)\n with\n | `Invalid_data _ as x -> x\n | `Ok result ->\n let expected_pos = pos + len in\n if !pos_ref = expected_pos\n then `Ok (result, expected_pos)\n else\n invalid_data\n \"pos_ref <> expected_pos\"\n (!pos_ref, expected_pos)\n [%sexp_of: int * int])\n in\n match\n read Bin_prot.Utils.bin_read_size_header ~pos ~len:Bin_prot.Utils.size_header_length\n with\n | (`Not_enough_data | `Invalid_data _) as x -> x\n | `Ok (element_length, pos) ->\n if element_length < 0\n then invalid_data \"negative element length %d\" element_length [%sexp_of: int]\n else read reader.Bin_prot.Type_class.read ~pos ~len:element_length\n;;\n\nlet read_bin_prot t ?pos ?len reader =\n match read_bin_prot_verbose_errors t ?pos ?len reader with\n | `Ok x -> Ok x\n | `Invalid_data e -> Error (Error.tag e ~tag:\"Invalid data\")\n | `Not_enough_data -> Or_error.error_string \"not enough data\"\n;;\n\nlet write_bin_prot t ?(pos = 0) writer v =\n let data_len = writer.Bin_prot.Type_class.size v in\n let total_len = data_len + Bin_prot.Utils.size_header_length in\n if pos < 0\n then\n failwiths ~here:[%here] \"Bigstring.write_bin_prot: negative pos\" pos [%sexp_of: int];\n if pos + total_len > length t\n then\n failwiths\n ~here:[%here]\n \"Bigstring.write_bin_prot: not enough room\"\n (`pos pos, `pos_after_writing (pos + total_len), `bigstring_length (length t))\n [%sexp_of:\n [ `pos of int ] * [ `pos_after_writing of int ] * [ `bigstring_length of int ]];\n let pos_after_size_header = Bin_prot.Utils.bin_write_size_header t ~pos data_len in\n let pos_after_data = writer.Bin_prot.Type_class.write t ~pos:pos_after_size_header v in\n if pos_after_data - pos <> total_len\n then\n failwiths\n ~here:[%here]\n \"Bigstring.write_bin_prot bug!\"\n ( `pos_after_data pos_after_data\n , `start_pos pos\n , `bin_prot_size_header_length Bin_prot.Utils.size_header_length\n , `data_len data_len\n , `total_len total_len )\n [%sexp_of:\n [ `pos_after_data of int ]\n * [ `start_pos of int ]\n * [ `bin_prot_size_header_length of int ]\n * [ `data_len of int ]\n * [ `total_len of int ]];\n pos_after_data\n;;\n\n(* Hex dump *)\n\ninclude Hexdump.Of_indexable (struct\n type nonrec t = t\n\n let length = length\n let get = get\n end)\n\nlet rec last_nonmatch_plus_one ~buf ~min_pos ~pos ~char =\n let pos' = pos - 1 in\n if pos' >= min_pos && Char.( = ) (get buf pos') char\n then last_nonmatch_plus_one ~buf ~min_pos ~pos:pos' ~char\n else pos\n;;\n\nlet get_tail_padded_fixed_string ~padding t ~pos ~len () =\n let data_end =\n last_nonmatch_plus_one ~buf:t ~min_pos:pos ~pos:(pos + len) ~char:padding\n in\n to_string t ~pos ~len:(data_end - pos)\n;;\n\nlet set_tail_padded_fixed_string ~padding t ~pos ~len value =\n let slen = String.length value in\n if slen > len\n then\n Printf.failwithf\n \"Bigstring.set_tail_padded_fixed_string: %S is longer than %d\"\n value\n len\n ();\n From_string.blit ~src:value ~dst:t ~src_pos:0 ~dst_pos:pos ~len:slen;\n for i = pos + slen to pos + len - 1 do\n set t i padding\n done\n;;\n\nlet rec first_nonmatch ~buf ~pos ~max_pos ~char =\n if pos <= max_pos && Char.( = ) (get buf pos) char\n then first_nonmatch ~buf ~pos:(Int.succ pos) ~max_pos ~char\n else pos\n;;\n\nlet set_head_padded_fixed_string ~padding t ~pos ~len value =\n let slen = String.length value in\n if slen > len\n then\n Printf.failwithf\n \"Bigstring.set_head_padded_fixed_string: %S is longer than %d\"\n value\n len\n ();\n From_string.blit ~src:value ~dst:t ~src_pos:0 ~dst_pos:(pos + len - slen) ~len:slen;\n for i = pos to pos + len - slen - 1 do\n set t i padding\n done\n;;\n\nlet get_head_padded_fixed_string ~padding t ~pos ~len () =\n let data_begin = first_nonmatch ~buf:t ~pos ~max_pos:(pos + len - 1) ~char:padding in\n to_string t ~pos:data_begin ~len:(len - (data_begin - pos))\n;;\n","open! Import\ninclude Bin_prot\n\nmodule Writer = struct\n type 'a t = 'a Bin_prot.Type_class.writer =\n { size : 'a Size.sizer\n ; write : 'a Write.writer\n }\n\n let to_string t v =\n let len = t.size v in\n let buf = Bigstring.create len in\n let pos = t.write buf ~pos:0 v in\n assert (pos = Bigstring.length buf);\n let str = Bigstring.to_string buf in\n Bigstring.unsafe_destroy buf;\n str\n ;;\n\n let to_bytes t v =\n let len = t.size v in\n let buf = Bigstring.create len in\n let pos = t.write buf ~pos:0 v in\n assert (pos = Bigstring.length buf);\n let str = Bigstring.to_bytes buf in\n Bigstring.unsafe_destroy buf;\n str\n ;;\nend\n\nmodule Reader = struct\n type 'a t = 'a Bin_prot.Type_class.reader =\n { read : 'a Read.reader\n ; vtag_read : (int -> 'a) Read.reader\n }\n\n let of_string t string =\n let buf = Bigstring.of_string string in\n let pos_ref = ref 0 in\n let v = t.read buf ~pos_ref in\n assert (!pos_ref = Bigstring.length buf);\n Bigstring.unsafe_destroy buf;\n v\n ;;\n\n let of_bytes t bytes =\n let buf = Bigstring.of_bytes bytes in\n let pos_ref = ref 0 in\n let v = t.read buf ~pos_ref in\n assert (!pos_ref = Bigstring.length buf);\n Bigstring.unsafe_destroy buf;\n v\n ;;\nend\n","module T = struct\n include Bin_prot.Md5\n\n let sexp_of_t t = t |> to_hex |> String.sexp_of_t\n let t_of_sexp s = s |> String.t_of_sexp |> of_hex_exn\nend\n\nlet hash_fold_t accum t = String.hash_fold_t accum (T.to_binary t)\nlet hash t = String.hash (T.to_binary t)\n\nmodule As_binary_string = struct\n module Stable = struct\n module V1 = struct\n type t = T.t [@@deriving compare]\n\n let hash_fold_t = hash_fold_t\n let hash = hash\n let sexp_of_t x = String.sexp_of_t (T.to_binary x)\n let t_of_sexp x = T.of_binary_exn (String.t_of_sexp x)\n\n include Bin_prot.Utils.Make_binable_without_uuid [@alert \"-legacy\"] (struct\n module Binable = String\n\n type t = Bin_prot.Md5.t\n\n let to_binable = T.to_binary\n let of_binable = T.of_binary_exn\n end)\n end\n end\n\n include Stable.V1\n include Comparable.Make (Stable.V1)\n include Hashable.Make (Stable.V1)\nend\n\nmodule Stable = struct\n module V1 = struct\n type t = T.t [@@deriving compare, sexp]\n\n let hash_fold_t = hash_fold_t\n let hash = hash\n\n include Bin_prot.Utils.Make_binable_without_uuid [@alert \"-legacy\"] (struct\n module Binable = Bin_prot.Md5\n\n type t = Bin_prot.Md5.t\n\n let to_binable = Fn.id\n let of_binable = Fn.id\n end)\n end\n\n let digest_string s = Md5_lib.string s\nend\n\ninclude Stable.V1\ninclude Comparable.Make (Stable.V1)\ninclude Hashable.Make (Stable.V1)\n\nlet digest_num_bytes = 16\nlet to_hex = T.to_hex\nlet from_hex = T.of_hex_exn\nlet of_hex_exn = T.of_hex_exn\nlet of_binary_exn = T.of_binary_exn\nlet to_binary = T.to_binary\nlet digest_string = Stable.digest_string\nlet digest_bytes = Md5_lib.bytes\n\nexternal caml_sys_open\n : string\n -> Caml.open_flag list\n -> perm:int\n -> int\n = \"caml_sys_open\"\n\nexternal caml_sys_close : int -> unit = \"caml_sys_close\"\nexternal digest_fd_blocking : int -> string = \"core_md5_fd\"\n\nlet digest_file_blocking path =\n of_binary_exn\n (Base.Exn.protectx\n (caml_sys_open path [ Open_rdonly; Open_binary ] ~perm:0o000)\n ~f:digest_fd_blocking\n ~finally:caml_sys_close)\n;;\n\nlet file = digest_file_blocking\n\nlet digest_channel_blocking_without_releasing_runtime_lock channel ~len =\n of_binary_exn (Caml.Digest.channel channel len)\n;;\n\nlet channel channel len =\n digest_channel_blocking_without_releasing_runtime_lock channel ~len\n;;\n\nlet output_blocking t oc = Caml.Digest.output oc (to_binary t)\nlet output oc t = output_blocking t oc\nlet input_blocking ic = of_binary_exn (Caml.Digest.input ic)\nlet input = input_blocking\nlet digest_subbytes = Md5_lib.subbytes\nlet string = digest_string\nlet bytes = digest_bytes\nlet subbytes s pos len = digest_subbytes s ~pos ~len\n\nlet digest_bin_prot writer value =\n digest_string (Core_bin_prot.Writer.to_string writer value)\n;;\n\nexternal c_digest_subbigstring\n : Bigstring.t\n -> pos:int\n -> len:int\n -> res:Bytes.t\n -> unit\n = \"core_md5_digest_subbigstring\"\n\nlet unsafe_digest_subbigstring buf ~pos ~len =\n (* It's more efficient to allocate the result on the OCaml side and declare the C\n function as noalloc than to let the C function allocate. *)\n let res = Bytes.create 16 in\n c_digest_subbigstring buf ~pos ~len ~res;\n Md5_lib.unsafe_of_binary\n (Bytes.unsafe_to_string ~no_mutation_while_string_reachable:res)\n;;\n\nlet digest_subbigstring buf ~pos ~len =\n Ordered_collection_common.check_pos_len_exn\n ~pos\n ~len\n ~total_length:(Bigstring.length buf);\n unsafe_digest_subbigstring buf ~pos ~len\n;;\n\nlet digest_bigstring buf =\n unsafe_digest_subbigstring buf ~pos:0 ~len:(Bigstring.length buf)\n;;\n","(** Time-zone handling. *)\n\nopen! Import\n\n(** The internal time representation of [Zone.t]. This is a tiny subset of [Time0_intf.S],\n see that interface for details such as the meaning of [Span] and [Date_and_ofday].\n\n The name of the interface reflects the fact that the interface only gives you access\n to the seconds of the [t]. But you can use this interface with types that have higher\n precision than that, hence the rounding implied in the name of\n [to_int63_seconds_round_down_exn].\n*)\nmodule type Time_in_seconds = sig\n module Span : sig\n type t\n\n val of_int63_seconds : Int63.t -> t\n val to_int63_seconds_round_down_exn : t -> Int63.t\n end\n\n module Date_and_ofday : sig\n type t\n\n val of_synthetic_span_since_epoch : Span.t -> t\n val to_synthetic_span_since_epoch : t -> Span.t\n end\n\n type t\n\n val of_span_since_epoch : Span.t -> t\n val to_span_since_epoch : t -> Span.t\nend\n\n(** This is the interface of [Zone], but not the interface of [Time.Zone] or\n [Time_ns.Zone]. For those, look at [Time_intf.Zone] *)\nmodule type S = sig\n (** {1 User-friendly interface} *)\n\n (** The type of a time-zone.\n\n bin_io and sexp representations of Zone.t are the name of the zone, and\n not the full data that is read from disk when Zone.find is called. The\n full Zone.t is reconstructed on the receiving/reading side by reloading\n the zone file from disk. Any zone name that is accepted by [find] is\n acceptable in the bin_io and sexp representations. *)\n type t [@@deriving sexp_of, compare]\n\n (** [input_tz_file ~zonename ~filename] read in [filename] and return [t]\n with [name t] = [zonename] *)\n val input_tz_file : zonename:string -> filename:string -> t\n\n (** [likely_machine_zones] is a list of zone names that will be searched\n first when trying to determine the machine zone of a box. Setting this\n to a likely set of zones for your application will speed the very first\n use of the local timezone. *)\n val likely_machine_zones : string list ref\n\n (** [of_utc_offset offset] returns a timezone with a static UTC offset (given in\n hours). *)\n val of_utc_offset : hours:int -> t\n\n (** [utc] the UTC time zone. Included for convenience *)\n val utc : t\n\n val name : t -> string\n\n (** [original_filename t] return the filename [t] was loaded from (if any) *)\n val original_filename : t -> string option\n\n (** [digest t] return the MD5 digest of the file the t was created from (if any) *)\n val digest : t -> Md5.t option\n\n module Time_in_seconds : Time_in_seconds\n\n (** For performance testing only; [reset_transition_cache t] resets an internal cache in\n [t] used to speed up repeated lookups of the same clock shift transition. *)\n val reset_transition_cache : t -> unit\n\n (** A time zone index refers to a range of times delimited by DST transitions at one or\n both ends. Every time belongs to exactly one such range. The times of DST\n transitions themselves belong to the range for which they are the lower bound. *)\n module Index : sig\n type t [@@immediate]\n\n val next : t -> t\n val prev : t -> t\n end\n\n (** Gets the index of a time. *)\n val index : t -> Time_in_seconds.t -> Index.t\n\n val index_of_date_and_ofday : t -> Time_in_seconds.Date_and_ofday.t -> Index.t\n\n (** Gets the UTC offset of times in a specific range.\n\n This can raise if you use an [Index.t] that is out of bounds for this [t]. *)\n val index_offset_from_utc_exn : t -> Index.t -> Time_in_seconds.Span.t\n\n (** [index_abbreviation_exn t index] returns the abbreviation name (such as EDT, EST,\n JST) of given zone [t] for the range of [index]. This string conversion is one-way\n only, and cannot reliably be turned back into a [t]. This function reads and writes\n the zone's cached index. Raises if [index] is out of bounds for [t]. *)\n val index_abbreviation_exn : t -> Index.t -> string\n\n (** Accessors for the DST transitions delimiting the start and end of a range, if any.\n The [_exn] accessors raise if there is no such transition. These accessors are split\n up to increase performance and improve allocation; they are intended as a low-level\n back-end for commonly-used time conversion functions. See [Time.Zone] and\n [Time_ns.Zone] for higher-level accessors that return an optional tuple for clock\n shifts in either direction. *)\n val index_has_prev_clock_shift : t -> Index.t -> bool\n\n val index_prev_clock_shift_time_exn : t -> Index.t -> Time_in_seconds.t\n val index_prev_clock_shift_amount_exn : t -> Index.t -> Time_in_seconds.Span.t\n val index_has_next_clock_shift : t -> Index.t -> bool\n val index_next_clock_shift_time_exn : t -> Index.t -> Time_in_seconds.t\n val index_next_clock_shift_amount_exn : t -> Index.t -> Time_in_seconds.Span.t\nend\n\nmodule type S_stable = sig\n type t\n\n module Full_data : sig\n module V1 : Stable_module_types.S0_without_comparator with type t = t\n end\nend\n\nmodule type Zone = sig\n module type S = S\n module type S_stable = S_stable\n\n include S\n module Stable : S_stable with type t := t\nend\n","open! Import\ninclude Binable_intf\ninclude Binable0\n\n(* [of_string] and [to_string] can't go in binable0.ml due to a cyclic dependency. *)\nlet of_string m string = of_bigstring m (Bigstring.of_string string)\nlet to_string m t = Bigstring.to_string (to_bigstring m t)\n\nmodule Of_binable = Of_binable_without_uuid [@@alert \"-legacy\"]\nmodule Of_binable1 = Of_binable1_without_uuid [@@alert \"-legacy\"]\nmodule Of_binable2 = Of_binable2_without_uuid [@@alert \"-legacy\"]\nmodule Of_binable3 = Of_binable3_without_uuid [@@alert \"-legacy\"]\nmodule Of_sexpable = Of_sexpable_without_uuid [@@alert \"-legacy\"]\nmodule Of_stringable = Of_stringable_without_uuid [@@alert \"-legacy\"]\n","(* Functions for parsing time zone database files (zic files).\n\n A time zone file consists (conceptually - the representation is more\n compact) of an ordered list of (Time.t * [local_time_type]) that mark\n the boundaries (marked from the epoch) at which various time adjustment\n regimes are in effect. This can also be thought of as breaking down all\n time past the epoch into ranges with a [local_time_type] that describes the\n offset from GMT to apply to each range to get local time.\n*)\n\nopen Import\nopen Std_internal\nopen! Int.Replace_polymorphic_compare\ninclude Zone_intf\n\nexception Invalid_file_format of string [@@deriving sexp]\n\nmodule Stable = struct\n module Full_data = struct\n module V1 = struct\n module Index = struct\n type t = int\n\n let next = Int.succ\n let prev = Int.pred\n let before_first_transition = -1\n\n (* Some existing clients expect [index >= 0], so we never serialize a negative\n index. This conversion can be removed if new stable versions are minted. *)\n let to_external t = max 0 t\n\n (* When the index of a time zone with no transitions is converted via to_external,\n its value becomes 0 even though its transition array is empty (and it should\n have been -1). When the converted value is changed back to a Zone.t through\n of_external, returning this value for its index could result in unsafe array\n accesses to the transition array of the zone (since there is no transition at\n index 0). Also, it does not make sense to keep the converted index because it\n is intended to be a mutable value used for caching. So of_external always sets\n the index to -1, which is a safe value. *)\n let of_external (_ : t) = -1\n\n include Binable.Of_binable_without_uuid [@alert \"-legacy\"]\n (Int)\n (struct\n type t = int\n\n let to_binable = to_external\n let of_binable = of_external\n end)\n\n include Sexpable.Of_sexpable\n (Int)\n (struct\n type t = int\n\n let to_sexpable = to_external\n let of_sexpable = of_external\n end)\n end\n\n module Regime = struct\n type t =\n { utc_offset_in_seconds : Int63.Stable.V1.t\n ; is_dst : bool\n ; abbrv : string\n }\n [@@deriving bin_io, sexp]\n end\n\n (* holds information about when leap seconds should be applied - unused\n because we are translating based on a epoch system clock (see the Core_zone\n documentation). *)\n module Leap_second = struct\n type t =\n { time_in_seconds_since_epoch : Int63.Stable.V1.t\n ; seconds : int\n }\n [@@deriving bin_io, sexp]\n end\n\n module Transition = struct\n type t =\n { start_time_in_seconds_since_epoch : Int63.Stable.V1.t\n ; new_regime : Regime.t\n }\n [@@deriving bin_io, sexp]\n end\n\n type t =\n { name : string\n ; original_filename : string option\n ;\n digest : Md5.As_binary_string.t option\n ; transitions : Transition.t array\n ; (* caches the index of the last transition we used to make lookups faster *)\n mutable last_regime_index : Index.t\n ; default_local_time_type : Regime.t\n ; leap_seconds : Leap_second.t list\n }\n [@@deriving bin_io, sexp]\n\n (* this relies on zones with the same name having the same transitions *)\n let compare t1 t2 = String.compare t1.name t2.name\n let original_filename zone = zone.original_filename\n let digest zone = zone.digest\n\n module Zone_file : sig\n val input_tz_file : zonename:string -> filename:string -> t\n end = struct\n let bool_of_int i = i <> 0\n\n let input_long_as_int32 =\n let long = Bytes.create 4 in\n let int32_of_char chr = Int32.of_int_exn (int_of_char chr) in\n fun ic ->\n In_channel.really_input_exn ic ~buf:long ~pos:0 ~len:4;\n let sb1 = Int32.shift_left (int32_of_char (Bytes.get long 0)) 24 in\n let sb2 = Int32.shift_left (int32_of_char (Bytes.get long 1)) 16 in\n let sb3 = Int32.shift_left (int32_of_char (Bytes.get long 2)) 8 in\n let sb4 = int32_of_char (Bytes.get long 3) in\n Int32.bit_or (Int32.bit_or sb1 sb2) (Int32.bit_or sb3 sb4)\n ;;\n\n (* Note that this is only safe to use on numbers that will fit into a 31-bit\n int. UNIX timestamps won't, for example. In our case this is only used\n to hold small numbers that are never interpreted as timestamps. *)\n let input_long_as_int ic = Int32.to_int_exn (input_long_as_int32 ic)\n let input_long_as_int63 ic = Int63.of_int32 (input_long_as_int32 ic)\n\n let input_long_long_as_int63 ic =\n let int63_of_char chr = Int63.of_int_exn (int_of_char chr) in\n let shift c bits = Int63.shift_left (int63_of_char c) bits in\n let long_long = Bytes.create 8 in\n In_channel.really_input_exn ic ~buf:long_long ~pos:0 ~len:8;\n let result = shift (Bytes.get long_long 0) 56 in\n let result = Int63.bit_or result (shift (Bytes.get long_long 1) 48) in\n let result = Int63.bit_or result (shift (Bytes.get long_long 2) 40) in\n let result = Int63.bit_or result (shift (Bytes.get long_long 3) 32) in\n let result = Int63.bit_or result (shift (Bytes.get long_long 4) 24) in\n let result = Int63.bit_or result (shift (Bytes.get long_long 5) 16) in\n let result = Int63.bit_or result (shift (Bytes.get long_long 6) 8) in\n let result = Int63.bit_or result (int63_of_char (Bytes.get long_long 7)) in\n result\n ;;\n\n let input_list ic ~len ~f =\n let rec loop c lst =\n if c > 0 then loop (c - 1) (f ic :: lst) else List.rev lst\n in\n loop len []\n ;;\n\n let input_array ic ~len ~f = Array.of_list (input_list ic ~len ~f)\n\n let input_regime ic =\n let utc_offset_in_seconds = input_long_as_int63 ic in\n let is_dst = bool_of_int (Option.value_exn (In_channel.input_byte ic)) in\n let abbrv_index = Option.value_exn (In_channel.input_byte ic) in\n let lt abbrv = { Regime.utc_offset_in_seconds; is_dst; abbrv } in\n lt, abbrv_index\n ;;\n\n let input_abbreviations ic ~len =\n let raw_abbrvs =\n input_list ic ~len ~f:(fun ic -> Option.value_exn (In_channel.input_char ic))\n in\n let buf = Buffer.create len in\n let _, indexed_abbrvs =\n List.fold raw_abbrvs ~init:(0, Map.Poly.empty) ~f:(fun (index, abbrvs) c ->\n match c with\n | '\\000' ->\n let data = Buffer.contents buf in\n let next_index = index + String.length data + 1 in\n let abbrvs = Map.set abbrvs ~key:index ~data in\n Buffer.clear buf;\n next_index, abbrvs\n | c ->\n Buffer.add_char buf c;\n index, abbrvs)\n in\n if Buffer.length buf <> 0\n then\n raise\n (Invalid_file_format\n \"missing \\000 terminating character in input_abbreviations\");\n indexed_abbrvs\n ;;\n\n let input_tz_file_gen ~input_transition ~input_leap_second ic =\n let utc_local_count = input_long_as_int ic in\n let std_wall_count = input_long_as_int ic in\n let leap_count = input_long_as_int ic in\n let transition_count = input_long_as_int ic in\n let type_count = input_long_as_int ic in\n let abbrv_char_count = input_long_as_int ic in\n let transition_times =\n input_list ic ~f:input_transition ~len:transition_count\n in\n let transition_indices =\n input_list\n ic\n ~f:(fun ic -> Option.value_exn (In_channel.input_byte ic))\n ~len:transition_count\n in\n let regimes = input_list ic ~f:input_regime ~len:type_count in\n let abbreviations = input_abbreviations ic ~len:abbrv_char_count in\n let leap_seconds = input_list ic ~f:input_leap_second ~len:leap_count in\n (* The following two arrays indicate two boolean values per regime that\n represent a three-value type that would translate to:\n\n type transition_type = UTC | Standard | Wall_clock\n\n However, these are only used by the system library when handling the case where the\n TZ variable is set, not to a time zone name, but instead is of the form:\n\n TZ = \"std offset dst offset, rule\"\n\n Which is deeply obscure, and almost certainly a mistake to use. This library makes\n no pretense about handling this case. We continue to read them in for\n completeness, and because it's possible that we will later discover a case where\n they are used. *)\n let _std_wall_indicators =\n input_array ic ~len:std_wall_count ~f:(fun ic ->\n bool_of_int (Option.value_exn (In_channel.input_byte ic)))\n in\n let _utc_local_indicators =\n input_array ic ~len:utc_local_count ~f:(fun ic ->\n bool_of_int (Option.value_exn (In_channel.input_byte ic)))\n in\n let regimes =\n Array.of_list\n (List.map regimes ~f:(fun (lt, abbrv_index) ->\n let abbrv = Map.find_exn abbreviations abbrv_index in\n lt abbrv))\n in\n let raw_transitions =\n List.map2_exn transition_times transition_indices ~f:(fun time index ->\n let regime = regimes.(index) in\n time, regime)\n in\n let transitions =\n let rec make_transitions acc l =\n match l with\n | [] -> Array.of_list (List.rev acc)\n | (start_time_in_seconds_since_epoch, new_regime) :: rest ->\n make_transitions\n ({ Transition.start_time_in_seconds_since_epoch; new_regime } :: acc)\n rest\n in\n make_transitions [] raw_transitions\n in\n let default_local_time_type =\n match Array.find regimes ~f:(fun r -> not r.Regime.is_dst) with\n | None -> regimes.(0)\n | Some ltt -> ltt\n in\n fun name ~original_filename ~digest ->\n { name\n ; original_filename = Some original_filename\n ; digest = Some digest\n ; transitions\n ; last_regime_index = Index.before_first_transition\n ; default_local_time_type\n ; leap_seconds\n }\n ;;\n\n let input_leap_second_gen ~input_leap_second ic =\n let time_in_seconds_since_epoch = input_leap_second ic in\n let seconds = input_long_as_int ic in\n { Leap_second.time_in_seconds_since_epoch; seconds }\n ;;\n\n let read_header ic =\n let magic =\n let buf = Bytes.create 4 in\n In_channel.really_input_exn ic ~buf ~pos:0 ~len:4;\n Bytes.unsafe_to_string ~no_mutation_while_string_reachable:buf\n in\n if not (String.equal magic \"TZif\")\n then raise (Invalid_file_format \"magic characters TZif not present\");\n let version =\n match In_channel.input_char ic with\n | Some '\\000' -> `V1\n | Some '2' -> `V2\n | Some '3' -> `V3\n | None -> raise (Invalid_file_format \"expected version, found nothing\")\n | Some bad_version ->\n raise (Invalid_file_format (sprintf \"version (%c) is invalid\" bad_version))\n in\n (* space reserved for future use in the format *)\n In_channel.really_input_exn ic ~buf:(Bytes.create 15) ~pos:0 ~len:15;\n version\n ;;\n\n let input_tz_file_v1 ic =\n let input_leap_second =\n input_leap_second_gen ~input_leap_second:input_long_as_int63\n in\n input_tz_file_gen ~input_transition:input_long_as_int63 ~input_leap_second ic\n ;;\n\n (*\n version 2 timezone files have the format:\n\n part 1 - exactly the same as v1\n\n part 2 - same format as v1, except that 8 bytes are used to store\n transition times and leap seconds\n\n part 3 - a newline-encloded, POSIX-TZ-environment-variable-style\n string for use in handling instants after the last transition time\n stored in the file (with nothing between the newlines if there is no\n POSIX representation for such instants)\n\n We handle files in this format by parsing the first part exactly as a v1\n timezone file and then continuing to parse with 64bit reading functions in the\n right places.\n\n Version 3 timezone files are the same as version 2, except the\n POSIX-TZ-environment-variable-style string in part 3 may use two minor\n extensions to the POSIX TZ format (the hours part of its transition\n times may be signed and range from -167 through 167 instead of the\n POSIX-required unsigned values from 0 through 24; and DST is in effect all\n year if it starts January 1 at 00:00 and ends December 31 at 24:00 plus the\n difference between daylight saving and standard time).\n\n As we don't actually do anything with part 3 anyway, we can just read v3\n files as v2.\n *)\n let input_tz_file_v2_or_v3 ~version ic =\n let (_ : string -> original_filename:string -> digest:Md5_lib.t -> t) =\n input_tz_file_v1 ic\n in\n (* the header is fully repeated *)\n assert ([%compare.equal: [ `V1 | `V2 | `V3 ]] (read_header ic) version);\n let input_leap_second =\n input_leap_second_gen ~input_leap_second:input_long_long_as_int63\n in\n input_tz_file_gen\n ~input_transition:input_long_long_as_int63\n ~input_leap_second\n ic\n ;;\n\n let input_tz_file ~zonename ~filename =\n try\n protectx (In_channel.create filename) ~finally:In_channel.close ~f:(fun ic ->\n let make_zone =\n match read_header ic with\n | `V1 -> input_tz_file_v1 ic\n | (`V2 | `V3) as version -> input_tz_file_v2_or_v3 ~version ic\n in\n let digest = Md5.digest_file_blocking filename in\n let r = make_zone zonename ~original_filename:filename ~digest in\n r)\n with\n | Invalid_file_format reason ->\n raise (Invalid_file_format (sprintf \"%s - %s\" filename reason))\n ;;\n end\n\n let of_utc_offset ~hours:offset =\n assert (offset >= -24 && offset <= 24);\n let name =\n if offset = 0\n then \"UTC\"\n else sprintf \"UTC%s%d\" (if offset < 0 then \"-\" else \"+\") (abs offset)\n in\n let utc_offset_in_seconds = Int63.of_int (offset * 60 * 60) in\n { name\n ; original_filename = None\n ; digest = None\n ; transitions = [||]\n ; last_regime_index = Index.before_first_transition\n ; default_local_time_type =\n { Regime.utc_offset_in_seconds; is_dst = false; abbrv = name }\n ; leap_seconds = []\n }\n ;;\n end\n end\nend\n\ninclude Stable.Full_data.V1\n\nlet sexp_of_t t = Sexp.Atom t.name\n\nlet likely_machine_zones =\n ref [ \"America/New_York\"; \"Europe/London\"; \"Asia/Hong_Kong\"; \"America/Chicago\" ]\n;;\n\nlet input_tz_file = Zone_file.input_tz_file\nlet utc = of_utc_offset ~hours:0\nlet name zone = zone.name\nlet reset_transition_cache t = t.last_regime_index <- Index.before_first_transition\n\n(* Raises if [index >= Array.length t.transitions] *)\nlet get_regime_exn t index =\n if index < 0 then t.default_local_time_type else t.transitions.(index).new_regime\n;;\n\n(* In \"absolute mode\", a number of seconds is interpreted as an offset of that many\n seconds from the UNIX epoch, ignoring leap seconds.\n\n In \"date and ofday mode\", you interpret the number of seconds as a number of days in\n combination with a number of seconds since midnight, which gives you a calendar day and\n a clock face time. Then you take the time that those represent in some relevant\n timezone.\n\n Of course, if the timezone in question has DST shifts, the date and ofday might\n represent two or zero times. These times will be interpreted according to either the\n previous UTC offset or the next one, in a way whose precise details you probably\n shouldn't depend on.\n\n (For the curious, what we do is: compute the \"relative time\" of the shift according to\n the new regime, and assign relative times to the old regime or new regime depending on\n which side of the shift time they occur. Since this amounts to using the old regime\n when the clocks move forward and the new regime when the clocks move back, it's\n equivalent to calculating the corresponding Time.t's relative to both the old and the\n new regime and picking the one that occurs later. Yes, later. I had to draw a diagram\n to persuade myself that it's that way round, but it is.)\n*)\nmodule Mode = struct\n type t =\n | Absolute\n | Date_and_ofday\nend\n\nlet effective_start_time ~mode (x : Transition.t) =\n let open Int63.O in\n match (mode : Mode.t) with\n | Absolute -> x.start_time_in_seconds_since_epoch\n | Date_and_ofday ->\n x.start_time_in_seconds_since_epoch + x.new_regime.utc_offset_in_seconds\n;;\n\nlet index_lower_bound_contains_seconds_since_epoch t index ~mode seconds =\n index < 0 || Int63.( >= ) seconds (effective_start_time ~mode t.transitions.(index))\n;;\n\nlet index_upper_bound_contains_seconds_since_epoch t index ~mode seconds =\n index + 1 >= Array.length t.transitions\n || Int63.( < ) seconds (effective_start_time ~mode t.transitions.(index + 1))\n;;\n\nlet binary_search_index_of_seconds_since_epoch t ~mode seconds : Index.t =\n Array.binary_search_segmented\n t.transitions\n `Last_on_left\n ~segment_of:(fun transition ->\n if Int63.( <= ) (effective_start_time transition ~mode) seconds\n then `Left\n else `Right)\n |> Option.value ~default:Index.before_first_transition\n;;\n\nlet index_of_seconds_since_epoch t ~mode seconds =\n let index =\n let index = t.last_regime_index in\n if not (index_lower_bound_contains_seconds_since_epoch t index ~mode seconds)\n (* time is before cached index; try previous index *)\n then (\n let index = index - 1 in\n if not (index_lower_bound_contains_seconds_since_epoch t index ~mode seconds)\n (* time is before previous index; fall back on binary search *)\n then\n binary_search_index_of_seconds_since_epoch t ~mode seconds\n (* time is before cached index and not before previous, so within previous *)\n else index)\n else if not (index_upper_bound_contains_seconds_since_epoch t index ~mode seconds)\n (* time is after cached index; try next index *)\n then (\n let index = index + 1 in\n if not (index_upper_bound_contains_seconds_since_epoch t index ~mode seconds)\n (* time is after next index; fall back on binary search *)\n then\n binary_search_index_of_seconds_since_epoch t ~mode seconds\n (* time is after cached index and not after next, so within next *)\n else index (* time is within cached index *))\n else index\n in\n t.last_regime_index <- index;\n index\n;;\n\nmodule Time_in_seconds : sig\n include Zone_intf.Time_in_seconds\nend = struct\n module Span = struct\n type t = Int63.t\n\n let of_int63_seconds = ident\n let to_int63_seconds_round_down_exn = ident\n end\n\n module Absolute = struct\n type t = Int63.t\n\n let of_span_since_epoch = ident\n let to_span_since_epoch = ident\n end\n\n module Date_and_ofday = struct\n type t = Int63.t\n\n let of_synthetic_span_since_epoch = ident\n let to_synthetic_span_since_epoch = ident\n end\n\n include Absolute\nend\n\nlet index t time =\n Time_in_seconds.to_span_since_epoch time\n |> Time_in_seconds.Span.to_int63_seconds_round_down_exn\n |> index_of_seconds_since_epoch t ~mode:Absolute\n;;\n\nlet index_of_date_and_ofday t time =\n Time_in_seconds.Date_and_ofday.to_synthetic_span_since_epoch time\n |> Time_in_seconds.Span.to_int63_seconds_round_down_exn\n |> index_of_seconds_since_epoch t ~mode:Date_and_ofday\n;;\n\nlet index_has_prev_clock_shift t index = index >= 0 && index < Array.length t.transitions\nlet index_has_next_clock_shift t index = index_has_prev_clock_shift t (index + 1)\n\nlet index_prev_clock_shift_time_exn t index =\n let transition = t.transitions.(index) in\n transition.start_time_in_seconds_since_epoch\n |> Time_in_seconds.Span.of_int63_seconds\n |> Time_in_seconds.of_span_since_epoch\n;;\n\nlet index_next_clock_shift_time_exn t index =\n index_prev_clock_shift_time_exn t (index + 1)\n;;\n\nlet index_prev_clock_shift_amount_exn t index =\n let transition = t.transitions.(index) in\n let after = transition.new_regime in\n let before =\n if index = 0 then t.default_local_time_type else t.transitions.(index - 1).new_regime\n in\n Int63.( - ) after.utc_offset_in_seconds before.utc_offset_in_seconds\n |> Time_in_seconds.Span.of_int63_seconds\n;;\n\nlet index_next_clock_shift_amount_exn t index =\n index_prev_clock_shift_amount_exn t (index + 1)\n;;\n\nlet index_abbreviation_exn t index =\n let regime = get_regime_exn t index in\n regime.abbrv\n;;\n\nlet index_offset_from_utc_exn t index =\n let regime = get_regime_exn t index in\n Time_in_seconds.Span.of_int63_seconds regime.utc_offset_in_seconds\n;;\n","open! Import\ninclude Base.Source_code_position\ninclude Source_code_position0\ninclude Comparable.Extend (Base.Source_code_position) (Source_code_position0)\ninclude Hashable.Make (Source_code_position0)\n","open! Import\nopen Std_internal\nopen Validated_intf\n\nmodule type Raw = Raw\n\ntype ('raw, 'witness) t = 'raw\n\nmodule type S = S with type ('a, 'b) validated := ('a, 'b) t\nmodule type S_bin_io = S_bin_io with type ('a, 'b) validated := ('a, 'b) t\n\nmodule type S_bin_io_compare_hash_sexp =\n S_bin_io_compare_hash_sexp with type ('a, 'b) validated := ('a, 'b) t\n\nlet raw t = t\n\nmodule Make (Raw : Raw) = struct\n type witness\n type t = Raw.t [@@deriving sexp_of]\n\n let validation_failed t error =\n Error.create\n \"validation failed\"\n (t, error, Raw.here)\n [%sexp_of: Raw.t * Error.t * Source_code_position.t]\n ;;\n\n let create_exn t =\n match Validate.result (Raw.validate t) with\n | Ok () -> t\n | Error error -> Error.raise (validation_failed t error)\n ;;\n\n let create t =\n match Validate.result (Raw.validate t) with\n | Ok () -> Ok t\n | Error error -> Error (validation_failed t error)\n ;;\n\n let t_of_sexp sexp = create_exn (Raw.t_of_sexp sexp)\n let raw t = t\nend\n\nmodule Add_bin_io (Raw : sig\n type t [@@deriving bin_io]\n\n include Raw_bin_io with type t := t\n end)\n (Validated : S with type raw := Raw.t) =\nstruct\n include Binable.Of_binable_without_uuid [@alert \"-legacy\"]\n (Raw)\n (struct\n type t = Raw.t\n\n let of_binable raw =\n if Raw.validate_binio_deserialization\n then Validated.create_exn raw\n else raw\n ;;\n\n let to_binable = Fn.id\n end)\nend\n\nmodule Add_compare (Raw : sig\n type t [@@deriving compare]\n\n include Raw with type t := t\n end)\n (Validated : S with type raw := Raw.t) =\nstruct\n let compare t1 t2 = [%compare: Raw.t] (raw t1) (raw t2)\nend\n\nmodule Add_hash (Raw : sig\n type t [@@deriving hash]\n\n include Raw with type t := t\n end)\n (Validated : S with type raw := Raw.t) =\nstruct\n let hash_fold_t state t = Raw.hash_fold_t state (Validated.raw t)\n let hash t = Raw.hash (Validated.raw t)\nend\n\nmodule Add_typerep (Raw : sig\n type t [@@deriving typerep]\n\n include Raw with type t := t\n end)\n (Validated : S with type raw := Raw.t) =\nstruct\n type t = Raw.t [@@deriving typerep]\nend\n\nmodule Make_binable (Raw : Raw_bin_io) = struct\n module T0 = Make (Raw)\n include T0\n include Add_bin_io (Raw) (T0)\nend\n\nmodule Make_bin_io_compare_hash_sexp (Raw : sig\n type t [@@deriving compare, hash]\n\n include Raw_bin_io with type t := t\n end) =\nstruct\n module T = Make_binable (Raw)\n include T\n include Add_compare (Raw) (T)\n\n include (\n Add_hash (Raw) (T) :\n sig\n type t [@@deriving hash]\n end\n with type t := t)\nend\n","include Base.Type_equal\n\nmodule Id = struct\n include Id\n\n module Uid = struct\n module Upstream = Base.Type_equal.Id.Uid\n include Base.Type_equal.Id.Uid\n\n include Comparable.Extend\n (Upstream)\n (struct\n type t = Base.Type_equal.Id.Uid.t [@@deriving sexp]\n end)\n\n include Hashable.Make (Upstream)\n end\nend\n","(** Universal/heterogeneous maps, useful for storing values of arbitrary type in a single\n map.\n\n In order to recover a value, it must be looked up with exactly the [Key.t] it was\n stored in. In other words, given different [Key.t]s from the same [string], one will\n not be able to recover the key stored in the other one.\n\n This is similar to [Univ] in spirit.\n*)\n\nopen! Import\n\nmodule type Key = sig\n type 'a t [@@deriving sexp_of]\n\n (** For correct behavior of the map, [to_type_id] must return the same\n [Type_equal.Id] on different calls on the same input.\n *)\n val to_type_id : 'a t -> 'a Type_equal.Id.t\nend\n\nmodule type Data = sig\n type 'a t [@@deriving sexp_of]\nend\n\nmodule type Data1 = sig\n type ('s, 'a) t [@@deriving sexp_of]\nend\n\nmodule type S = sig\n type t [@@deriving sexp_of]\n\n module Key : Key\n\n type 'a data\n\n include Invariant.S with type t := t\n\n val empty : t\n val is_empty : t -> bool\n val set : t -> 'a Key.t -> 'a data -> t\n val mem : t -> 'a Key.t -> bool\n val mem_by_id : t -> Type_equal.Id.Uid.t -> bool\n val find : t -> 'a Key.t -> 'a data option\n val find_exn : t -> 'a Key.t -> 'a data\n val add : t -> 'a Key.t -> 'a data -> [ `Ok of t | `Duplicate ]\n val add_exn : t -> 'a Key.t -> 'a data -> t\n val change : t -> 'a Key.t -> f:('a data option -> 'a data option) -> t\n val change_exn : t -> 'a Key.t -> f:('a data -> 'a data) -> t\n val update : t -> 'a Key.t -> f:('a data option -> 'a data) -> t\n val remove : t -> 'a Key.t -> t\n val remove_by_id : t -> Type_equal.Id.Uid.t -> t\n\n module Packed : sig\n type t = T : 'a Key.t * 'a data -> t\n end\n\n val to_alist : t -> Packed.t list\n val of_alist_exn : Packed.t list -> t\nend\n\nmodule type S1 = sig\n (** The ['s] parameter is shared across all values stored in the map. *)\n type 's t [@@deriving sexp_of]\n\n module Key : Key\n\n type ('s, 'a) data\n\n val invariant : _ t -> unit\n val empty : _ t\n val is_empty : _ t -> bool\n val set : 's t -> 'a Key.t -> ('s, 'a) data -> 's t\n val mem : _ t -> _ Key.t -> bool\n val mem_by_id : _ t -> Type_equal.Id.Uid.t -> bool\n val find : 's t -> 'a Key.t -> ('s, 'a) data option\n val find_exn : 's t -> 'a Key.t -> ('s, 'a) data\n val add : 's t -> 'a Key.t -> ('s, 'a) data -> [ `Ok of 's t | `Duplicate ]\n val add_exn : 's t -> 'a Key.t -> ('s, 'a) data -> 's t\n\n val change\n : 's t\n -> 'a Key.t\n -> f:(('s, 'a) data option -> ('s, 'a) data option)\n -> 's t\n\n val change_exn : 's t -> 'a Key.t -> f:(('s, 'a) data -> ('s, 'a) data) -> 's t\n val update : 's t -> 'a Key.t -> f:(('s, 'a) data option -> ('s, 'a) data) -> 's t\n val remove : 's t -> 'a Key.t -> 's t\n val remove_by_id : 's t -> Type_equal.Id.Uid.t -> 's t\n\n module Packed : sig\n type 's t = T : 'a Key.t * ('s, 'a) data -> 's t\n end\n\n val to_alist : 's t -> 's Packed.t list\n val of_alist_exn : 's Packed.t list -> 's t\nend\n\nmodule type Univ_map = sig\n module type S = S\n module type S1 = S1\n module type Key = Key\n module type Data = Data\n\n module Type_id_key : Key with type 'a t = 'a Type_equal.Id.t\n include S with type 'a data = 'a and module Key := Type_id_key\n\n (** This binding is convenient because existing call sites often refer to\n [Univ_map.Key.create].\n *)\n module Key = Type_equal.Id\n\n module Make (Key : Key) (Data : Data) :\n S with type 'a data = 'a Data.t and module Key = Key\n\n module Make1 (Key : Key) (Data : Data1) :\n S1 with type ('s, 'a) data = ('s, 'a) Data.t and module Key = Key\n\n module Merge\n (Key : Key)\n (Input1_data : Data1)\n (Input2_data : Data1)\n (Output_data : Data1) : sig\n type 's f =\n { f :\n 'a. key:'a Key.t\n -> [ `Left of ('s, 'a) Input1_data.t\n | `Right of ('s, 'a) Input2_data.t\n | `Both of ('s, 'a) Input1_data.t * ('s, 'a) Input2_data.t\n ] -> ('s, 'a) Output_data.t option\n }\n\n (** The analogue of the normal [Map.merge] function. *)\n val merge\n : 's Make1(Key)(Input1_data).t\n -> 's Make1(Key)(Input2_data).t\n -> f:'s f\n -> 's Make1(Key)(Output_data).t\n end\n\n (** keys with associated default values, so that [find] is no longer partial *)\n module With_default : sig\n module Key : sig\n type 'a t\n\n val create : default:'a -> name:string -> ('a -> Sexp.t) -> 'a t\n val id : 'a t -> 'a Type_equal.Id.t\n end\n\n val set : t -> 'a Key.t -> 'a -> t\n val find : t -> 'a Key.t -> 'a\n val change : t -> 'a Key.t -> f:('a -> 'a) -> t\n end\n\n (** keys that map to an accumulator value with an associated fold operation *)\n module With_fold : sig\n module Key : sig\n type ('a, 'b) t\n\n val create\n : init:'b\n -> f:('b -> 'a -> 'b)\n -> name:string\n -> ('b -> Sexp.t)\n -> ('a, 'b) t\n\n val id : ('a, 'b) t -> 'b Type_equal.Id.t\n end\n\n (** reset the accumulator *)\n val set : t -> ('a, 'b) Key.t -> 'b -> t\n\n (** the current accumulator *)\n val find : t -> ('a, 'b) Key.t -> 'b\n\n (** fold value into accumulator *)\n val add : t -> ('a, 'b) Key.t -> 'a -> t\n\n (** accumulator update *)\n val change : t -> ('a, 'b) Key.t -> f:('b -> 'b) -> t\n end\n\n (** list-accumulating keys with a default value of the empty list *)\n module Multi : sig\n module Key : sig\n type 'a t\n\n val create : name:string -> ('a -> Sexp.t) -> 'a t\n val id : 'a t -> 'a list Type_equal.Id.t\n end\n\n val set : t -> 'a Key.t -> 'a list -> t\n val find : t -> 'a Key.t -> 'a list\n val add : t -> 'a Key.t -> 'a -> t\n val change : t -> 'a Key.t -> f:('a list -> 'a list) -> t\n end\nend\n","open! Import\n\ntype t =\n | Nanosecond\n | Microsecond\n | Millisecond\n | Second\n | Minute\n | Hour\n | Day\n[@@deriving sexp, compare, enumerate, hash]\n","open! Import\nopen Std_internal\nopen Unique_id_intf\n\nmodule type Id = Id\n\n(* Only \"make\" can cause a context-switch that might lead to a race.\n Thus we have to check whether the contents of the cell remained\n unchanged across this call. The subsequent comparison, dereferencing\n and assignment cannot cause context switches. If the contents of the\n cell had changed, we will have to try again to obtain a unique id.\n This is essentially like a spin-lock and is virtually guaranteed to\n succeed quickly. *)\nlet rec race_free_create_loop cell make =\n let x = !cell in\n let new_x = make x in\n if phys_equal !cell x\n then (\n cell := new_x;\n x)\n else race_free_create_loop cell make\n;;\n\nmodule Int () = struct\n include Int\n\n let current = ref zero\n let create () = race_free_create_loop current succ\nend\n\nmodule Int63 () = struct\n include Int63\n\n let current = ref zero\n let create () = race_free_create_loop current succ\nend\n","open! Import\ninclude Base.Uniform_array\n\ninclude Binable.Of_binable1_without_uuid [@alert \"-legacy\"]\n (Array)\n (struct\n type nonrec 'a t = 'a t\n\n let to_binable = to_array\n let of_binable = of_array\n end)\n","open! Import\n\nlet failwithf = Printf.failwithf\n\nmodule Stable = struct\n module V1 = struct\n module T = struct\n type t =\n | Sun\n | Mon\n | Tue\n | Wed\n | Thu\n | Fri\n | Sat\n [@@deriving bin_io, compare, hash, quickcheck]\n\n let to_string t =\n match t with\n | Sun -> \"SUN\"\n | Mon -> \"MON\"\n | Tue -> \"TUE\"\n | Wed -> \"WED\"\n | Thu -> \"THU\"\n | Fri -> \"FRI\"\n | Sat -> \"SAT\"\n ;;\n\n let to_string_long t =\n match t with\n | Sun -> \"Sunday\"\n | Mon -> \"Monday\"\n | Tue -> \"Tuesday\"\n | Wed -> \"Wednesday\"\n | Thu -> \"Thursday\"\n | Fri -> \"Friday\"\n | Sat -> \"Saturday\"\n ;;\n\n let of_string_internal s =\n match String.uppercase s with\n | \"SUN\" | \"SUNDAY\" -> Sun\n | \"MON\" | \"MONDAY\" -> Mon\n | \"TUE\" | \"TUESDAY\" -> Tue\n | \"WED\" | \"WEDNESDAY\" -> Wed\n | \"THU\" | \"THURSDAY\" -> Thu\n | \"FRI\" | \"FRIDAY\" -> Fri\n | \"SAT\" | \"SATURDAY\" -> Sat\n | _ -> failwithf \"Day_of_week.of_string: %S\" s ()\n ;;\n\n let of_int_exn i =\n match i with\n | 0 -> Sun\n | 1 -> Mon\n | 2 -> Tue\n | 3 -> Wed\n | 4 -> Thu\n | 5 -> Fri\n | 6 -> Sat\n | _ -> failwithf \"Day_of_week.of_int_exn: %d\" i ()\n ;;\n\n (* Be very generous with of_string. We accept all possible capitalizations and the\n integer representations as well. *)\n let of_string s =\n try of_string_internal s with\n | _ ->\n (try of_int_exn (Int.of_string s) with\n | _ -> failwithf \"Day_of_week.of_string: %S\" s ())\n ;;\n\n (* this is in T rather than outside so that the later functor application to build maps\n uses this sexp representation *)\n include Sexpable.Stable.Of_stringable.V1 (struct\n type nonrec t = t\n\n let of_string = of_string\n let to_string = to_string\n end)\n end\n\n include T\n\n module Unstable = struct\n include T\n include (Comparable.Make_binable (T) : Comparable.S_binable with type t := t)\n include Hashable.Make_binable (T)\n end\n\n include Comparable.Stable.V1.Make (Unstable)\n include Hashable.Stable.V1.Make (Unstable)\n end\nend\n\ninclude Stable.V1.Unstable\n\nlet weekdays = [ Mon; Tue; Wed; Thu; Fri ]\nlet weekends = [ Sat; Sun ]\n\n(* written out to save overhead when loading modules. The members of the set and the\n ordering should never change, so speed wins over something more complex that proves\n the order = the order in t at runtime *)\nlet all = [ Sun; Mon; Tue; Wed; Thu; Fri; Sat ]\n\nlet of_int i =\n try Some (of_int_exn i) with\n | _ -> None\n;;\n\nlet to_int t =\n match t with\n | Sun -> 0\n | Mon -> 1\n | Tue -> 2\n | Wed -> 3\n | Thu -> 4\n | Fri -> 5\n | Sat -> 6\n;;\n\nlet iso_8601_weekday_number t =\n match t with\n | Mon -> 1\n | Tue -> 2\n | Wed -> 3\n | Thu -> 4\n | Fri -> 5\n | Sat -> 6\n | Sun -> 7\n;;\n\nlet num_days_in_week = 7\nlet shift t i = of_int_exn (Int.( % ) (to_int t + i) num_days_in_week)\n\nlet num_days ~from ~to_ =\n let d = to_int to_ - to_int from in\n if Int.(d < 0) then d + num_days_in_week else d\n;;\n\nlet is_sun_or_sat t = t = Sun || t = Sat\n","open! Import\nopen Std_internal\nopen Digit_string_helpers\n\nlet suffixes char =\n let sprintf = Printf.sprintf in\n [ sprintf \"%c\" char; sprintf \"%cM\" char; sprintf \"%c.M\" char; sprintf \"%c.M.\" char ]\n |> List.concat_map ~f:(fun suffix ->\n [ String.lowercase suffix; String.uppercase suffix ])\n;;\n\nlet am_suffixes = lazy (suffixes 'A')\nlet pm_suffixes = lazy (suffixes 'P')\n\n(* Avoids the allocation that [List.find] would entail in both both the closure input and\n the option output. *)\nlet rec find_suffix string suffixes =\n match suffixes with\n | suffix :: suffixes ->\n if String.is_suffix string ~suffix then suffix else find_suffix string suffixes\n | [] -> \"\"\n;;\n\nlet has_colon string pos ~until = pos < until && Char.equal ':' string.[pos]\n\n(* This function defines what we meant by \"decimal point\", because in some string formats\n it means '.' and in some it can be '.' or ','. There's no particular demand for support\n for ',', and using just '.' lets us use [Float.of_string] for the decimal substring\n without any substitutions. *)\nlet char_is_decimal_point string pos = Char.equal '.' string.[pos]\n\nlet decrement_length_if_ends_in_space string len =\n if len > 0 && Char.equal ' ' string.[len - 1] then len - 1 else len\n;;\n\nlet[@cold] invalid_string string ~reason =\n raise_s [%message \"Time.Ofday: invalid string\" string reason]\n;;\n\nlet check_digits_with_underscore_and_return_if_nonzero string pos ~until =\n let nonzero = ref false in\n for pos = pos to until - 1 do\n match string.[pos] with\n | '0' | '_' -> ()\n | '1' .. '9' -> nonzero := true\n | _ ->\n invalid_string\n string\n ~reason:\"expected digits and/or underscores after decimal point\"\n done;\n !nonzero\n;;\n\nlet check_digits_without_underscore_and_return_if_nonzero string pos ~until =\n let nonzero = ref false in\n for pos = pos to until - 1 do\n match string.[pos] with\n | '0' -> ()\n | '1' .. '9' -> nonzero := true\n | _ -> invalid_string string ~reason:\"expected digits after decimal point\"\n done;\n !nonzero\n;;\n\nlet parse string ~f =\n let len = String.length string in\n let am_or_pm, until =\n (* discriminate among AM (1:30am), PM (12:30:00 P.M.), or 24-hr (13:00). *)\n match\n ( find_suffix string (Lazy.force am_suffixes)\n , find_suffix string (Lazy.force pm_suffixes) )\n with\n | \"\", \"\" -> `hr_24, len\n | am, \"\" -> `hr_AM, decrement_length_if_ends_in_space string (len - String.length am)\n | \"\", pm -> `hr_PM, decrement_length_if_ends_in_space string (len - String.length pm)\n | _, _ -> `hr_24, assert false\n (* Immediately above, it may seem nonsensical to write [`hr_24, assert false] when the\n [`hr_24] can never be returned. We do this to help the compiler figure out never to\n allocate a tuple in this code: the [let] pattern is syntactically a tuple and every\n match clause is syntactically a tuple. *)\n in\n let pos = 0 in\n let pos, hr, expect_minutes_and_seconds =\n (* e.g. \"1:00\" or \"1:00:00\" *)\n if has_colon string (pos + 1) ~until\n then\n pos + 2, read_1_digit_int string ~pos, `Minutes_and_maybe_seconds\n (* e.g. \"12:00\" or \"12:00:00\" *)\n else if has_colon string (pos + 2) ~until\n then\n pos + 3, read_2_digit_int string ~pos, `Minutes_and_maybe_seconds\n (* e.g. \"1am\"; must have AM or PM (checked below) *)\n else if pos + 1 = until\n then\n pos + 1, read_1_digit_int string ~pos, `Neither_minutes_nor_seconds\n (* e.g. \"12am\"; must have AM or PM (checked below) *)\n else if pos + 2 = until\n then\n pos + 2, read_2_digit_int string ~pos, `Neither_minutes_nor_seconds\n (* e.g. \"0930\"; must not have seconds *)\n else pos + 2, read_2_digit_int string ~pos, `Minutes_but_not_seconds\n in\n let pos, min, expect_seconds =\n match expect_minutes_and_seconds with\n | `Neither_minutes_nor_seconds ->\n (* e.g. \"12am\" *)\n pos, 0, false\n | (`Minutes_and_maybe_seconds | `Minutes_but_not_seconds) as maybe_seconds ->\n (* e.g. \"12:00:00\" *)\n if has_colon string (pos + 2) ~until\n then\n ( pos + 3\n , read_2_digit_int string ~pos\n , match maybe_seconds with\n | `Minutes_and_maybe_seconds -> true\n | `Minutes_but_not_seconds ->\n invalid_string string ~reason:\"expected end of string after minutes\" )\n (* e.g. \"12:00\" *)\n else if pos + 2 = until\n then pos + 2, read_2_digit_int string ~pos, false\n else\n invalid_string\n string\n ~reason:\"expected colon or am/pm suffix with optional space after minutes\"\n in\n let sec, subsec_pos, subsec_len, subsec_nonzero =\n match expect_seconds with\n | false ->\n (* e.g. \"12am\" or \"12:00\" *)\n if pos = until\n then 0, pos, 0, false\n else\n (* This case is actually unreachable, based on the various ways that\n [expect_seconds] can end up false. *)\n invalid_string string ~reason:\"BUG: did not expect seconds, but found them\"\n | true ->\n (* e.g. \"12:00:00\" *)\n if pos + 2 > until\n then\n (* e.g. \"12:00:0\" *)\n invalid_string string ~reason:\"expected two digits of seconds\"\n else (\n let sec = read_2_digit_int string ~pos in\n let pos = pos + 2 in\n (* e.g. \"12:00:00\" *)\n if pos = until\n then sec, pos, 0, false (* e.g. \"12:00:00.123\" *)\n else if pos < until && char_is_decimal_point string pos\n then\n ( sec\n , pos\n , until - pos\n , check_digits_with_underscore_and_return_if_nonzero string (pos + 1) ~until )\n else\n invalid_string\n string\n ~reason:\"expected decimal point or am/pm suffix after seconds\")\n in\n let hr =\n (* NB. We already know [hr] is non-negative, because it's the result of\n [read_2_digit_int]. *)\n match am_or_pm with\n | `hr_AM ->\n (* e.g. \"12:00am\" *)\n if hr < 1 || hr > 12\n then invalid_string string ~reason:\"hours out of bounds\"\n else if hr = 12\n then 0\n else hr\n | `hr_PM ->\n (* e.g. \"12:00pm\" *)\n if hr < 1 || hr > 12\n then invalid_string string ~reason:\"hours out of bounds\"\n else if hr = 12\n then 12\n else hr + 12\n | `hr_24 ->\n (match expect_minutes_and_seconds with\n | `Neither_minutes_nor_seconds ->\n invalid_string string ~reason:\"hours without minutes or AM/PM\"\n | `Minutes_but_not_seconds | `Minutes_and_maybe_seconds ->\n if hr > 24\n then invalid_string string ~reason:\"hours out of bounds\"\n else if hr = 24 && (min > 0 || sec > 0 || subsec_nonzero)\n then invalid_string string ~reason:\"time is past 24:00:00\" (* e.g. \"13:00:00\" *)\n else hr)\n in\n let min =\n if min > 59 then invalid_string string ~reason:\"minutes out of bounds\" else min\n in\n let sec =\n if sec > 60 then invalid_string string ~reason:\"seconds out of bounds\" else sec\n in\n let subsec_len = if sec = 60 || not subsec_nonzero then 0 else subsec_len in\n f string ~hr ~min ~sec ~subsec_pos ~subsec_len\n;;\n\nlet parse_iso8601_extended ?pos ?len str ~f =\n let pos, len =\n match\n Ordered_collection_common.get_pos_len\n ()\n ?pos\n ?len\n ~total_length:(String.length str)\n with\n | Result.Ok z -> z\n | Result.Error s ->\n failwithf \"Ofday.of_string_iso8601_extended: %s\" (Error.to_string_mach s) ()\n in\n if len < 2\n then failwith \"len < 2\"\n else (\n let hr = read_2_digit_int str ~pos in\n if hr > 24 then failwith \"hour > 24\";\n if len = 2\n then f str ~hr ~min:0 ~sec:0 ~subsec_pos:(pos + len) ~subsec_len:0\n else if len < 5\n then failwith \"2 < len < 5\"\n else if not (Char.equal str.[pos + 2] ':')\n then failwith \"first colon missing\"\n else (\n let min = read_2_digit_int str ~pos:(pos + 3) in\n if min >= 60 then failwith \"minute > 60\";\n if hr = 24 && min <> 0 then failwith \"24 hours and non-zero minute\";\n if len = 5\n then f str ~hr ~min ~sec:0 ~subsec_pos:(pos + len) ~subsec_len:0\n else if len < 8\n then failwith \"5 < len < 8\"\n else if not (Char.equal str.[pos + 5] ':')\n then failwith \"second colon missing\"\n else (\n let sec = read_2_digit_int str ~pos:(pos + 6) in\n (* second can be 60 in the case of a leap second. Unfortunately, what with\n non-hour-multiple timezone offsets, we can't say anything about what\n the hour or minute must be in that case *)\n if sec > 60 then failwithf \"invalid second: %i\" sec ();\n if hr = 24 && sec <> 0 then failwith \"24 hours and non-zero seconds\";\n if len = 8\n then f str ~hr ~min ~sec ~subsec_pos:(pos + len) ~subsec_len:0\n else if len = 9\n then failwith \"length = 9\"\n else (\n match str.[pos + 8] with\n | '.' | ',' ->\n let subsec_pos = pos + 8 in\n let subsec_len =\n match\n check_digits_without_underscore_and_return_if_nonzero\n str\n (subsec_pos + 1)\n ~until:(pos + len)\n with\n | true when sec = 60 -> 0\n | true when hr = 24 -> failwith \"24 hours and non-zero subseconds\"\n | _ -> len - 8\n in\n f str ~hr ~min ~sec ~subsec_pos ~subsec_len\n | _ -> failwith \"missing subsecond separator\"))))\n;;\n","open! Import\ninclude Bin_prot.Std\ninclude Hash.Builtin\n\ninclude (\n Base :\n sig\n type nonrec 'a array = 'a array [@@deriving sexp, sexp_grammar]\n type nonrec bool = bool [@@deriving sexp, sexp_grammar]\n type nonrec char = char [@@deriving sexp, sexp_grammar]\n type nonrec exn = exn [@@deriving sexp_of]\n type nonrec float = float [@@deriving sexp, sexp_grammar]\n type nonrec int = int [@@deriving sexp, sexp_grammar]\n type nonrec int32 = int32 [@@deriving sexp, sexp_grammar]\n type nonrec int64 = int64 [@@deriving sexp, sexp_grammar]\n type nonrec 'a list = 'a list [@@deriving sexp, sexp_grammar]\n type nonrec nativeint = nativeint [@@deriving sexp, sexp_grammar]\n type nonrec 'a option = 'a option [@@deriving sexp, sexp_grammar]\n type nonrec 'a ref = 'a ref [@@deriving sexp, sexp_grammar]\n type nonrec string = string [@@deriving sexp, sexp_grammar]\n type nonrec bytes = bytes [@@deriving sexp, sexp_grammar]\n type nonrec unit = unit [@@deriving sexp, sexp_grammar]\n end\n with type 'a array := 'a array\n with type bool := bool\n with type char := char\n with type exn := exn\n with type float := float\n with type int := int\n with type int32 := int32\n with type int64 := int64\n with type 'a list := 'a list\n with type nativeint := nativeint\n with type 'a option := 'a option\n with type 'a ref := 'a ref\n with type string := string\n with type bytes := bytes\n with type unit := unit)\n\ninclude (\nstruct\n type 'a sexp_option = ('a Std_internal.sexp_option[@ocaml.warning \"-3\"])\n [@@deriving bin_io, compare, hash]\n\n type 'a sexp_list = ('a Std_internal.sexp_list[@ocaml.warning \"-3\"])\n [@@deriving bin_io, compare, hash]\nend :\nsig\n type 'a sexp_option = ('a Std_internal.sexp_option[@ocaml.warning \"-3\"])\n [@@deriving bin_io, compare, hash]\n\n type 'a sexp_list = ('a Std_internal.sexp_list[@ocaml.warning \"-3\"])\n [@@deriving bin_io, compare, hash]\nend\nwith type 'a sexp_option := ('a Std_internal.sexp_option[@ocaml.warning \"-3\"])\nwith type 'a sexp_list := ('a Std_internal.sexp_list[@ocaml.warning \"-3\"]))\n\ntype 'a sexp_option = ('a Std_internal.sexp_option[@ocaml.warning \"-3\"])\n[@@deprecated \"[since 2019-03] use [@sexp.option] instead\"]\n\ntype 'a sexp_list = ('a Std_internal.sexp_list[@ocaml.warning \"-3\"])\n[@@deprecated \"[since 2019-03] use [@sexp.list] instead\"]\n","open Ppx_compare_lib.Builtin\n\nmodule Stable = struct\n open Stable_internal\n module Binable = Binable.Stable\n\n module V1 = struct\n exception Nan_or_inf [@@deriving sexp]\n\n type t = float [@@deriving compare, hash]\n\n let verify t =\n match Caml.classify_float t with\n | FP_normal | FP_subnormal | FP_zero -> ()\n | FP_infinite | FP_nan -> raise Nan_or_inf\n ;;\n\n include Binable.Of_binable.V1 [@alert \"-legacy\"]\n (Float)\n (struct\n type nonrec t = t\n\n let of_binable t =\n verify t;\n t\n ;;\n\n let to_binable t =\n verify t;\n t\n ;;\n end)\n\n let sexp_of_t = Float.sexp_of_t\n\n let t_of_sexp = function\n | Sexp.Atom _ as sexp ->\n let t = Float.t_of_sexp sexp in\n (try verify t with\n | e -> Import.of_sexp_error (Import.Exn.to_string e) sexp);\n t\n | s -> Import.of_sexp_error \"Decimal.t_of_sexp: Expected Atom, found List\" s\n ;;\n end\nend\n\ninclude Stable.V1\n","open Async_kernel\nopen Core_kernel\n\nmodule type Time_intf = sig\n type t\n\n module Span : sig\n type t\n\n val to_time_ns_span : t -> Time_ns.Span.t\n\n val ( - ) : t -> t -> t\n end\n\n module Controller : sig\n type t\n end\n\n val now : Controller.t -> t\n\n val diff : t -> t -> Span.t\nend\n\nmodule Timeout_intf (Time : Time_intf) = struct\n module type S = sig\n type 'a t\n\n val create : Time.Controller.t -> Time.Span.t -> f:(Time.t -> 'a) -> 'a t\n\n val to_deferred : 'a t -> 'a Async_kernel.Deferred.t\n\n val peek : 'a t -> 'a option\n\n val cancel : Time.Controller.t -> 'a t -> 'a -> unit\n\n val remaining_time : 'a t -> Time.Span.t\n\n val await :\n timeout_duration:Time.Span.t\n -> Time.Controller.t\n -> 'a Deferred.t\n -> [ `Ok of 'a | `Timeout ] Deferred.t\n\n val await_exn :\n timeout_duration:Time.Span.t\n -> Time.Controller.t\n -> 'a Deferred.t\n -> 'a Deferred.t\n end\nend\n\nmodule Make (Time : Time_intf) : Timeout_intf(Time).S = struct\n type 'a t =\n { deferred : 'a Deferred.t\n ; cancel : 'a -> unit\n ; start_time : Time.t\n ; span : Time.Span.t\n ; ctrl : Time.Controller.t\n }\n\n let create ctrl span ~f:action =\n let open Deferred.Let_syntax in\n let cancel_ivar = Ivar.create () in\n let timeout = after (Time.Span.to_time_ns_span span) >>| fun () -> None in\n let deferred =\n Deferred.any [ Ivar.read cancel_ivar; timeout ]\n >>| function None -> action (Time.now ctrl) | Some x -> x\n in\n let cancel value = Ivar.fill_if_empty cancel_ivar (Some value) in\n { ctrl; deferred; cancel; start_time = Time.now ctrl; span }\n\n let to_deferred { deferred; _ } = deferred\n\n let peek { deferred; _ } = Deferred.peek deferred\n\n let cancel _ { cancel; _ } value = cancel value\n\n let remaining_time { ctrl : _; start_time; span; _ } =\n let current_time = Time.now ctrl in\n let time_elapsed = Time.diff current_time start_time in\n Time.Span.(span - time_elapsed)\n\n let await ~timeout_duration time_controller deferred =\n let timeout =\n Deferred.create (fun ivar ->\n ignore\n ( create time_controller timeout_duration ~f:(fun x ->\n if Ivar.is_full ivar then\n [%log' error (Logger.create ())] \"Ivar.fill bug is here!\" ;\n Ivar.fill_if_empty ivar x )\n : unit t ) )\n in\n Deferred.(\n choose\n [ choice deferred (fun x -> `Ok x); choice timeout (Fn.const `Timeout) ])\n\n let await_exn ~timeout_duration time_controller deferred =\n match%map await ~timeout_duration time_controller deferred with\n | `Timeout ->\n failwith \"timeout\"\n | `Ok x ->\n x\nend\n\nmodule Core_time = Make (struct\n include (\n Core_kernel.Time :\n module type of Core_kernel.Time\n with module Span := Core_kernel.Time.Span\n and type underlying = float )\n\n module Controller = struct\n type t = unit\n end\n\n module Span = struct\n include Core_kernel.Time.Span\n\n let to_time_ns_span = Fn.compose Core_kernel.Time_ns.Span.of_ns to_ns\n end\n\n let diff x y =\n let x_ns = Span.to_ns @@ to_span_since_epoch x in\n let y_ns = Span.to_ms @@ to_span_since_epoch y in\n Span.of_ns (x_ns -. y_ns)\nend)\n\nmodule Core_time_ns = Make (struct\n include (\n Core_kernel.Time_ns :\n module type of Core_kernel.Time_ns\n with module Span := Core_kernel.Time_ns.Span )\n\n module Controller = struct\n type t = unit\n end\n\n module Span = struct\n include Core_kernel.Time_ns.Span\n\n let to_time_ns_span = Fn.id\n end\n\n let diff x y =\n let x_ns = Span.to_ns @@ to_span_since_epoch x in\n let y_ns = Span.to_ms @@ to_span_since_epoch y in\n Span.of_ns (x_ns -. y_ns)\nend)\n","open! Import\nopen! Std_internal\nmodule Date = Date0\n\nmodule type Zone = sig\n module Time : Time0_intf.S\n include Zone.S with type t = Zone.t and module Time_in_seconds := Time\n\n (** [abbreviation t time] returns the abbreviation name (such as EDT, EST, JST) of given\n zone [t] at [time]. This string conversion is one-way only, and cannot reliably be\n turned back into a [t]. This function reads and writes the zone's cached index. *)\n val abbreviation : t -> Time.t -> string\n\n (** [absolute_time_of_date_and_ofday] and [date_and_ofday_of_absolute_time] convert\n between absolute times and date + ofday forms. These are low level functions not\n intended for most clients. These functions read and write the zone's cached index.\n *)\n val absolute_time_of_date_and_ofday : t -> Time.Date_and_ofday.t -> Time.t\n\n val date_and_ofday_of_absolute_time : t -> Time.t -> Time.Date_and_ofday.t\n\n (** Takes a [Time.t] and returns the next [Time.t] strictly after it, if any, that the\n time zone UTC offset changes, and by how much it does so. *)\n val next_clock_shift : t -> strictly_after:Time.t -> (Time.t * Time.Span.t) option\n\n (** As [next_clock_shift], but *at or before* the given time. *)\n val prev_clock_shift : t -> at_or_before:Time.t -> (Time.t * Time.Span.t) option\nend\n\nmodule type Basic = sig\n module Time : Time0_intf.S\n\n (*_ necessary to preserve type equality with the Time functor argument *)\n\n include module type of struct\n include Time\n end\n [@ocaml.remove_aliases]\n\n (** [now ()] returns a [t] representing the current time *)\n val now : unit -> t\n\n module Zone : Zone with module Time := Time\n\n (** {6 Basic operations on times} *)\n\n (** [add t s] adds the span [s] to time [t] and returns the resulting time.\n\n NOTE: adding spans as a means of adding days is not accurate, and may run into trouble\n due to shifts in daylight savings time, float arithmetic issues, and leap seconds.\n See the comment at the top of Zone.mli for a more complete discussion of some of\n the issues of time-keeping. For spans that cross date boundaries, use date functions\n instead.\n *)\n val add : t -> Span.t -> t\n\n (** [sub t s] subtracts the span [s] from time [t] and returns the\n resulting time. See important note for [add]. *)\n val sub : t -> Span.t -> t\n\n (** [diff t1 t2] returns time [t1] minus time [t2]. *)\n val diff : t -> t -> Span.t\n\n (** [abs_diff t1 t2] returns the absolute span of time [t1] minus time [t2]. *)\n val abs_diff : t -> t -> Span.t\nend\n\nmodule type Shared = sig\n type t\n\n include Quickcheck.S_range with type t := t\n\n module Span : sig\n type t\n end\n\n module Ofday : sig\n type t\n end\n\n (** {6 Comparisons} *)\n\n val is_earlier : t -> than:t -> bool\n val is_later : t -> than:t -> bool\n\n (** {6 Conversions} *)\n\n val of_date_ofday : zone:Zone.t -> Date.t -> Ofday.t -> t\n\n (** Because timezone offsets change throughout the year (clocks go forward or back) some\n local times can occur twice or not at all. In the case that they occur twice, this\n function gives [`Twice] with both occurrences in order; if they do not occur at all,\n this function gives [`Never] with the time at which the local clock skips over the\n desired time of day.\n\n Note that this is really only intended to work with DST transitions and not unusual or\n dramatic changes, like the calendar change in 1752 (run \"cal 9 1752\" in a shell to\n see). In particular it makes the assumption that midnight of each day is unambiguous.\n\n Most callers should use {!of_date_ofday} rather than this function. In the [`Twice]\n and [`Never] cases, {!of_date_ofday} will return reasonable times for most uses. *)\n val of_date_ofday_precise\n : Date.t\n -> Ofday.t\n -> zone:Zone.t\n -> [ `Once of t | `Twice of t * t | `Never of t ]\n\n val to_date_ofday : t -> zone:Zone.t -> Date.t * Ofday.t\n\n (** Always returns the [Date.t * Ofday.t] that [to_date_ofday] would have returned, and in\n addition returns a variant indicating whether the time is associated with a time zone\n transition.\n\n {v\n - `Only -> there is a one-to-one mapping between [t]'s and\n [Date.t * Ofday.t] pairs\n - `Also_at -> there is another [t] that maps to the same [Date.t * Ofday.t]\n (this date/time pair happened twice because the clock fell back)\n - `Also_skipped -> there is another [Date.t * Ofday.t] pair that never happened (due\n to a jump forward) that [of_date_ofday] would map to the same\n [t].\n v}\n *)\n val to_date_ofday_precise\n : t\n -> zone:Zone.t\n -> Date.t * Ofday.t * [ `Only | `Also_at of t | `Also_skipped of Date.t * Ofday.t ]\n\n val to_date : t -> zone:Zone.t -> Date.t\n val to_ofday : t -> zone:Zone.t -> Ofday.t\n\n (** For performance testing only; [reset_date_cache ()] resets an internal cache used to\n speed up [to_date] and related functions when called repeatedly on times that fall\n within the same day. *)\n val reset_date_cache : unit -> unit\n\n (** Unlike [Time_ns], this module purposely omits [max_value] and [min_value]:\n 1. They produce unintuitive corner cases because most people's mental models of time\n do not include +/- infinity as concrete values\n 2. In practice, when people ask for these values, it is for questionable uses, e.g.,\n as null values to use in place of explicit options. *)\n\n (** midnight, Jan 1, 1970 in UTC *)\n val epoch : t\n\n (** It's unspecified what happens if the given date/ofday/zone correspond to more than\n one date/ofday pair in the other zone. *)\n val convert : from_tz:Zone.t -> to_tz:Zone.t -> Date.t -> Ofday.t -> Date.t * Ofday.t\n\n val utc_offset : t -> zone:Zone.t -> Span.t\n\n (** {6 Other string conversions} *)\n\n (** The [{to,of}_string] functions in [Time] convert to UTC time, because a local time\n zone is not necessarily available. They are generous in what they will read in. *)\n include\n Stringable with type t := t\n\n (** [to_filename_string t ~zone] converts [t] to string with format\n YYYY-MM-DD_HH-MM-SS.mmm which is suitable for using in filenames. *)\n val to_filename_string : t -> zone:Zone.t -> string\n\n (** [of_filename_string s ~zone] converts [s] that has format YYYY-MM-DD_HH-MM-SS.mmm into\n time. *)\n val of_filename_string : string -> zone:Zone.t -> t\n\n (** [to_string_abs ~zone t] is the same as [to_string t] except that it uses the given\n time zone. *)\n val to_string_abs : t -> zone:Zone.t -> string\n\n (** [to_string_abs_trimmed] is the same as [to_string_abs], but drops trailing seconds\n and milliseconds if they are 0. *)\n val to_string_abs_trimmed : t -> zone:Zone.t -> string\n\n val to_string_abs_parts : t -> zone:Zone.t -> string list\n\n (** Same as [to_string_abs_trimmed], except it leaves off the timezone, so won't\n reliably round trip. *)\n val to_string_trimmed : t -> zone:Zone.t -> string\n\n (** Same as [to_string_abs], but without milliseconds *)\n val to_sec_string : t -> zone:Zone.t -> string\n\n (** [of_localized_string ~zone str] read in the given string assuming that it represents\n a time in zone and return the appropriate Time.t *)\n val of_localized_string : zone:Zone.t -> string -> t\n\n (** [of_string_gen ~default_zone ~find_zone s] attempts to parse [s] as a [t], calling\n out to [default_zone] and [find_zone] as needed. *)\n val of_string_gen\n : default_zone:(unit -> Zone.t)\n -> find_zone:(string -> Zone.t)\n -> string\n -> t\n\n (** [to_string_iso8601_basic] return a string representation of the following form:\n %Y-%m-%dT%H:%M:%S.%s%Z\n e.g.\n [ to_string_iso8601_basic ~zone:Time.Zone.utc epoch = \"1970-01-01T00:00:00.000000Z\" ]\n *)\n val to_string_iso8601_basic : t -> zone:Zone.t -> string\n\n (** [occurrence side time ~ofday ~zone] returns a [Time.t] that is the occurrence of\n ofday (in the given [zone]) that is the latest occurrence (<=) [time] or the\n earliest occurrence (>=) [time], according to [side].\n\n NOTE: If the given time converted to wall clock time in the given zone is equal to\n ofday then the t returned will be equal to the t given.\n *)\n val occurrence\n : [ `First_after_or_at | `Last_before_or_at ]\n -> t\n -> ofday:Ofday.t\n -> zone:Zone.t\n -> t\nend\n\nmodule type S = sig\n include Basic\n include Shared with type t := t with module Span := Span with module Ofday := Ofday\nend\n\nmodule type Time = sig\n module type S = S\n\n module Make (Time : Time0_intf.S) : S with module Time := Time\nend\n","(* See Time_float.ml for the primary instantiation of this functor that is visible outside\n of Core_kernel as Time (see core_kernel.ml and std.ml). *)\nopen! Import\nopen Std_internal\nopen! Int.Replace_polymorphic_compare\ninclude Time_intf\nmodule Zone0 = Zone\n\nmodule Make (Time0 : Time0_intf.S) = struct\n module Time0 = Time0\n include Time0\n\n let epoch = of_span_since_epoch Span.zero\n let is_earlier t1 ~than:t2 = t1 <. t2\n let is_later t1 ~than:t2 = t1 >. t2\n\n module Zone : sig\n include Time_intf.Zone with module Time := Time0\n end = struct\n include Zone\n\n let of_span_in_seconds span_in_seconds =\n (* NB. no actual rounding or exns can occur here *)\n Time_in_seconds.Span.to_int63_seconds_round_down_exn span_in_seconds\n |> Time0.Span.of_int63_seconds\n ;;\n\n let of_time_in_seconds time_in_seconds =\n Time_in_seconds.to_span_since_epoch time_in_seconds\n (* NB. no actual rounding or exns can occur here *)\n |> Time_in_seconds.Span.to_int63_seconds_round_down_exn\n |> Time0.Span.of_int63_seconds\n |> Time0.of_span_since_epoch\n ;;\n\n let to_time_in_seconds_round_down_exn time =\n Time0.to_span_since_epoch time\n |> Time0.Span.to_int63_seconds_round_down_exn\n |> Time_in_seconds.Span.of_int63_seconds\n |> Time_in_seconds.of_span_since_epoch\n ;;\n\n let to_date_and_ofday_in_seconds_round_down_exn relative =\n Time0.Date_and_ofday.to_synthetic_span_since_epoch relative\n |> Time0.Span.to_int63_seconds_round_down_exn\n |> Time_in_seconds.Span.of_int63_seconds\n |> Time_in_seconds.Date_and_ofday.of_synthetic_span_since_epoch\n ;;\n\n let index t time = index t (to_time_in_seconds_round_down_exn time)\n\n let index_of_date_and_ofday t relative =\n index_of_date_and_ofday t (to_date_and_ofday_in_seconds_round_down_exn relative)\n ;;\n\n let index_offset_from_utc_exn t index =\n of_span_in_seconds (index_offset_from_utc_exn t index)\n ;;\n\n let index_prev_clock_shift_time_exn t index =\n of_time_in_seconds (index_prev_clock_shift_time_exn t index)\n ;;\n\n let index_next_clock_shift_time_exn t index =\n of_time_in_seconds (index_next_clock_shift_time_exn t index)\n ;;\n\n let index_prev_clock_shift_amount_exn t index =\n of_span_in_seconds (index_prev_clock_shift_amount_exn t index)\n ;;\n\n let index_next_clock_shift_amount_exn t index =\n of_span_in_seconds (index_next_clock_shift_amount_exn t index)\n ;;\n\n let abbreviation t time =\n (* no exn because [index] always returns a valid index *)\n index_abbreviation_exn t (index t time)\n ;;\n\n let index_prev_clock_shift t index =\n match index_has_prev_clock_shift t index with\n | false -> None\n | true ->\n Some\n ( index_prev_clock_shift_time_exn t index\n , index_prev_clock_shift_amount_exn t index )\n ;;\n\n let index_next_clock_shift t index = index_prev_clock_shift t (Index.next index)\n let prev_clock_shift t ~at_or_before:time = index_prev_clock_shift t (index t time)\n let next_clock_shift t ~strictly_after:time = index_next_clock_shift t (index t time)\n\n let date_and_ofday_of_absolute_time t time =\n let index = index t time in\n (* no exn because [index] always returns a valid index *)\n let offset_from_utc = index_offset_from_utc_exn t index in\n Time0.Date_and_ofday.of_absolute time ~offset_from_utc\n ;;\n\n let absolute_time_of_date_and_ofday t relative =\n let index = index_of_date_and_ofday t relative in\n (* no exn because [index_of_date_and_ofday] always returns a valid index *)\n let offset_from_utc = index_offset_from_utc_exn t index in\n Time0.Date_and_ofday.to_absolute relative ~offset_from_utc\n ;;\n end\n\n let abs_diff t1 t2 = Span.abs (diff t1 t2)\n\n let of_date_ofday ~zone date ofday =\n let relative = Date_and_ofday.of_date_ofday date ofday in\n Zone.absolute_time_of_date_and_ofday zone relative\n ;;\n\n let of_date_ofday_precise date ofday ~zone =\n (* We assume that there will be only one zone shift within a given local day. *)\n let start_of_day = of_date_ofday ~zone date Ofday.start_of_day in\n let proposed_time = add start_of_day (Ofday.to_span_since_start_of_day ofday) in\n match Zone.next_clock_shift zone ~strictly_after:start_of_day with\n | None -> `Once proposed_time\n | Some (shift_start, shift_amount) ->\n let shift_backwards = Span.(shift_amount < zero) in\n (* start and end of the \"problematic region\" *)\n let s, e =\n if shift_backwards\n then add shift_start shift_amount, shift_start\n else shift_start, add shift_start shift_amount\n in\n if proposed_time < s\n then `Once proposed_time\n else if s <= proposed_time && proposed_time < e\n then\n if shift_backwards\n then `Twice (proposed_time, sub proposed_time shift_amount)\n else `Never shift_start\n else `Once (sub proposed_time shift_amount)\n ;;\n\n module Date_cache = struct\n type t =\n { mutable zone : Zone.t\n ; mutable cache_start_incl : Time0.t\n ; mutable cache_until_excl : Time0.t\n ; mutable effective_day_start : Time0.t\n ; mutable date : Date0.t\n }\n end\n\n let date_cache : Date_cache.t =\n { zone = Zone.utc\n ; cache_start_incl = epoch\n ; cache_until_excl = epoch\n ; effective_day_start = epoch\n ; date = Date0.unix_epoch\n }\n ;;\n\n let reset_date_cache () =\n date_cache.zone <- Zone.utc;\n date_cache.cache_start_incl <- epoch;\n date_cache.cache_until_excl <- epoch;\n date_cache.effective_day_start <- epoch;\n date_cache.date <- Date0.unix_epoch\n ;;\n\n let is_in_cache time ~zone =\n phys_equal zone date_cache.zone\n && Time0.( >= ) time date_cache.cache_start_incl\n && Time0.( < ) time date_cache.cache_until_excl\n ;;\n\n let set_date_cache time ~zone =\n match is_in_cache time ~zone with\n | true -> ()\n | false ->\n let index = Zone.index zone time in\n (* no exn because [Zone.index] always returns a valid index *)\n let offset_from_utc = Zone.index_offset_from_utc_exn zone index in\n let rel = Date_and_ofday.of_absolute time ~offset_from_utc in\n let date = Date_and_ofday.to_date rel in\n let span = Date_and_ofday.to_ofday rel |> Ofday.to_span_since_start_of_day in\n let effective_day_start =\n Time0.sub (Date_and_ofday.to_absolute rel ~offset_from_utc) span\n in\n let effective_day_until = Time0.add effective_day_start Span.day in\n let cache_start_incl =\n match Zone.index_has_prev_clock_shift zone index with\n | false -> effective_day_start\n | true ->\n effective_day_start\n |> Time0.max (Zone.index_prev_clock_shift_time_exn zone index)\n in\n let cache_until_excl =\n match Zone.index_has_next_clock_shift zone index with\n | false -> effective_day_until\n | true ->\n effective_day_until\n |> Time0.min (Zone.index_next_clock_shift_time_exn zone index)\n in\n date_cache.zone <- zone;\n date_cache.cache_start_incl <- cache_start_incl;\n date_cache.cache_until_excl <- cache_until_excl;\n date_cache.effective_day_start <- effective_day_start;\n date_cache.date <- date\n ;;\n\n let to_date time ~zone =\n set_date_cache time ~zone;\n date_cache.date\n ;;\n\n let to_ofday time ~zone =\n set_date_cache time ~zone;\n Time0.diff time date_cache.effective_day_start\n |> Ofday.of_span_since_start_of_day_exn\n ;;\n\n let to_date_ofday time ~zone = to_date time ~zone, to_ofday time ~zone\n\n (* The correctness of this algorithm (interface, even) depends on the fact that\n timezone shifts aren't too close together (as in, it can't simultaneously be the\n case that a timezone shift of X hours occurred less than X hours ago, *and*\n a timezone shift of Y hours will occur in less than Y hours' time) *)\n let to_date_ofday_precise time ~zone =\n let date, ofday = to_date_ofday time ~zone in\n let clock_shift_after = Zone.next_clock_shift zone ~strictly_after:time in\n let clock_shift_before_or_at = Zone.prev_clock_shift zone ~at_or_before:time in\n let also_skipped_earlier amount =\n (* Using [date] and raising on [None] here is OK on the assumption that clock\n shifts can't cross date boundaries. This is true in all cases I've ever heard\n of (and [of_date_ofday_precise] would need revisiting if it turned out to be\n false) *)\n match Ofday.sub ofday amount with\n | Some ofday -> `Also_skipped (date, ofday)\n | None ->\n raise_s\n [%message\n \"Time.to_date_ofday_precise\"\n ~span_since_epoch:(to_span_since_epoch time : Span.t)\n (zone : Zone.t)]\n in\n let ambiguity =\n (* Edge cases: the instant of transition belongs to the new zone regime. So if the\n clock moved by an hour exactly one hour ago, there's no ambiguity, because the\n hour-ago time belongs to the same regime as you, and conversely, if the clock\n will move by an hour in an hours' time, there *is* ambiguity. Hence [>.] for\n the first case and [<=.] for the second. *)\n match clock_shift_before_or_at, clock_shift_after with\n | Some (start, amount), _ when add start (Span.abs amount) >. time ->\n (* clock shifted recently *)\n if Span.(amount > zero)\n then\n (* clock shifted forward recently: we skipped a time *)\n also_skipped_earlier amount\n else (\n (* clock shifted back recently: this date/ofday already happened *)\n assert (Span.(amount < zero));\n `Also_at (sub time (Span.abs amount)))\n | _, Some (start, amount) when sub start (Span.abs amount) <=. time ->\n (* clock is about to shift *)\n if Span.(amount > zero)\n then (* clock about to shift forward: no effect *)\n `Only\n else (\n (* clock about to shift back: this date/ofday will be repeated *)\n assert (Span.(amount < zero));\n `Also_at (add time (Span.abs amount)))\n | _ -> `Only\n in\n date, ofday, ambiguity\n ;;\n\n let convert ~from_tz ~to_tz date ofday =\n let start_time = of_date_ofday ~zone:from_tz date ofday in\n to_date_ofday ~zone:to_tz start_time\n ;;\n\n let utc_offset t ~zone =\n let utc_epoch = Zone.date_and_ofday_of_absolute_time zone t in\n Span.( - )\n (Date_and_ofday.to_synthetic_span_since_epoch utc_epoch)\n (to_span_since_epoch t)\n ;;\n\n let offset_string time ~zone =\n let utc_offset = utc_offset time ~zone in\n let is_utc = Span.( = ) utc_offset Span.zero in\n if is_utc\n then \"Z\"\n else\n String.concat\n [ (if Span.( < ) utc_offset Span.zero then \"-\" else \"+\")\n ; Ofday.to_string_trimmed\n (Ofday.of_span_since_start_of_day_exn (Span.abs utc_offset))\n ]\n ;;\n\n let to_string_abs_parts time ~zone =\n let date, ofday = to_date_ofday time ~zone in\n let offset_string = offset_string time ~zone in\n [ Date0.to_string date\n ; String.concat ~sep:\"\" [ Ofday.to_string ofday; offset_string ]\n ]\n ;;\n\n let to_string_abs_trimmed time ~zone =\n let date, ofday = to_date_ofday time ~zone in\n let offset_string = offset_string time ~zone in\n String.concat\n ~sep:\" \"\n [ Date0.to_string date; Ofday.to_string_trimmed ofday ^ offset_string ]\n ;;\n\n let to_string_abs time ~zone = String.concat ~sep:\" \" (to_string_abs_parts ~zone time)\n let to_string t = to_string_abs t ~zone:Zone.utc\n\n let to_string_iso8601_basic time ~zone =\n String.concat ~sep:\"T\" (to_string_abs_parts ~zone time)\n ;;\n\n let to_string_trimmed t ~zone =\n let date, sec = to_date_ofday ~zone t in\n Date0.to_string date ^ \" \" ^ Ofday.to_string_trimmed sec\n ;;\n\n let to_sec_string t ~zone =\n let date, sec = to_date_ofday ~zone t in\n Date0.to_string date ^ \" \" ^ Ofday.to_sec_string sec\n ;;\n\n let to_filename_string t ~zone =\n let date, ofday = to_date_ofday ~zone t in\n Date0.to_string date\n ^ \"_\"\n ^ String.tr ~target:':' ~replacement:'-' (Ofday.to_string ofday)\n ;;\n\n let of_filename_string s ~zone =\n try\n match String.lsplit2 s ~on:'_' with\n | None -> failwith \"no space in filename string\"\n | Some (date, ofday) ->\n let date = Date0.of_string date in\n let ofday = String.tr ~target:'-' ~replacement:':' ofday in\n let ofday = Ofday.of_string ofday in\n of_date_ofday date ofday ~zone\n with\n | exn -> invalid_argf \"Time.of_filename_string (%s): %s\" s (Exn.to_string exn) ()\n ;;\n\n let of_localized_string ~zone str =\n try\n match String.lsplit2 str ~on:' ' with\n | None -> invalid_arg (sprintf \"no space in date_ofday string: %s\" str)\n | Some (date, time) ->\n let date = Date0.of_string date in\n let ofday = Ofday.of_string time in\n of_date_ofday ~zone date ofday\n with\n | e -> Exn.reraise e \"Time.of_localized_string\"\n ;;\n\n let occurrence before_or_after t ~ofday ~zone =\n let first_guess_date = to_date t ~zone in\n let first_guess = of_date_ofday ~zone first_guess_date ofday in\n let cmp, increment =\n match before_or_after with\n | `Last_before_or_at -> ( <= ), -1\n | `First_after_or_at -> ( >= ), 1\n in\n if cmp first_guess t\n then first_guess\n else of_date_ofday ~zone (Date0.add_days first_guess_date increment) ofday\n ;;\n\n let ensure_colon_in_offset offset =\n let offset_length = String.length offset in\n if Int.( <= ) offset_length 2\n && Char.is_digit offset.[0]\n && Char.is_digit offset.[offset_length - 1]\n then offset ^ \":00\"\n else if Char.( = ) offset.[1] ':' || Char.( = ) offset.[2] ':'\n then offset\n else if Int.( < ) offset_length 3 || Int.( > ) offset_length 4\n then failwithf \"invalid offset %s\" offset ()\n else\n String.concat\n [ String.slice offset 0 (offset_length - 2)\n ; \":\"\n ; String.slice offset (offset_length - 2) offset_length\n ]\n ;;\n\n exception Time_of_string of string * Exn.t [@@deriving sexp]\n\n let of_string_gen ~default_zone ~find_zone s =\n try\n let date, ofday, tz =\n match String.split s ~on:' ' with\n | [ day; month; year; ofday ] ->\n String.concat [ day; \" \"; month; \" \"; year ], ofday, None\n | [ date; ofday; tz ] -> date, ofday, Some tz\n | [ date; ofday ] -> date, ofday, None\n | [ s ] ->\n (match String.rsplit2 ~on:'T' s with\n | Some (date, ofday) -> date, ofday, None\n | None -> failwith \"no spaces or T found\")\n | _ -> failwith \"too many spaces\"\n in\n let ofday_to_sec od = Span.to_sec (Ofday.to_span_since_start_of_day od) in\n let ofday, utc_offset =\n match tz with\n | Some _ -> ofday, None\n | None ->\n if Char.( = ) ofday.[String.length ofday - 1] 'Z'\n then String.sub ofday ~pos:0 ~len:(String.length ofday - 1), Some 0.\n else (\n match String.lsplit2 ~on:'+' ofday with\n | Some (l, r) ->\n l, Some (ofday_to_sec (Ofday.of_string (ensure_colon_in_offset r)))\n | None ->\n (match String.lsplit2 ~on:'-' ofday with\n | Some (l, r) ->\n l, Some (-1. *. ofday_to_sec (Ofday.of_string (ensure_colon_in_offset r)))\n | None -> ofday, None))\n in\n let date = Date0.of_string date in\n let ofday = Ofday.of_string ofday in\n match tz with\n | Some tz -> of_date_ofday ~zone:(find_zone tz) date ofday\n | None ->\n (match utc_offset with\n | None ->\n let zone = default_zone () in\n of_date_ofday ~zone date ofday\n | Some utc_offset ->\n let utc_t = of_date_ofday ~zone:Zone.utc date ofday in\n sub utc_t (Span.of_sec utc_offset))\n with\n | e -> raise (Time_of_string (s, e))\n ;;\n\n let of_string s =\n let default_zone () = raise_s [%message \"time has no time zone or UTC offset\" s] in\n let find_zone zone_name =\n failwithf \"unable to lookup Zone %s. Try using Core.Time.of_string\" zone_name ()\n in\n of_string_gen ~default_zone ~find_zone s\n ;;\n\n let quickcheck_shrinker =\n Quickcheck.Shrinker.map\n Span.quickcheck_shrinker\n ~f:of_span_since_epoch\n ~f_inverse:to_span_since_epoch\n ;;\n\n let quickcheck_observer =\n Quickcheck.Observer.unmap Span.quickcheck_observer ~f:to_span_since_epoch\n ;;\n\n let quickcheck_generator =\n Quickcheck.Generator.map Span.quickcheck_generator ~f:of_span_since_epoch\n ;;\n\n let gen_incl lo hi =\n Span.gen_incl (to_span_since_epoch lo) (to_span_since_epoch hi)\n |> Quickcheck.Generator.map ~f:of_span_since_epoch\n ;;\n\n let gen_uniform_incl lo hi =\n Span.gen_uniform_incl (to_span_since_epoch lo) (to_span_since_epoch hi)\n |> Quickcheck.Generator.map ~f:of_span_since_epoch\n ;;\nend\n","open! Import\nopen Std_internal\nopen! Int.Replace_polymorphic_compare\nmodule Span = Span_float\nmodule Ofday = Ofday_float\n\nmodule Absolute = struct\n type underlying = Float.t\n\n include (\n Float :\n sig\n type t = float [@@deriving bin_io, hash, typerep]\n\n include Comparable.S_common with type t := t\n\n include module type of struct\n include Float.O\n end\n end)\n\n (* due to precision limitations in float we can't expect better than microsecond\n precision *)\n include Float.Robust_compare.Make (struct\n let robust_comparison_tolerance = 1E-6\n end)\n\n let diff t1 t2 = Span.of_sec (t1 - t2)\n let add t span = t +. Span.to_sec span\n let sub t span = t -. Span.to_sec span\n let prev t = Float.one_ulp `Down t\n let next t = Float.one_ulp `Up t\n let to_span_since_epoch = Span.of_sec\n let of_span_since_epoch = Span.to_sec\nend\n\ninclude Absolute\n\nmodule Date_and_ofday = struct\n type t = float\n\n let of_synthetic_span_since_epoch span = Span.to_sec span\n let to_synthetic_span_since_epoch t = Span.of_sec t\n\n let of_date_ofday date ofday =\n let days =\n Float.of_int (Date0.Days.diff (Date0.Days.of_date date) Date0.Days.unix_epoch)\n in\n (days *. 86400.) +. Span.to_sec (Ofday.to_span_since_start_of_day ofday)\n ;;\n\n let to_absolute relative ~offset_from_utc = sub relative offset_from_utc\n let of_absolute absolute ~offset_from_utc = add absolute offset_from_utc\n\n (* Years out of range for [Date.create_exn]. *)\n let[@cold] assert_in_bounds ~sec_since_epoch =\n (* $ TZ=UTC date --date=@-62167219200\n Sat Jan 1 00:00:00 UTC 0000 *)\n let gmtime_lower_bound = -62_167_219_200. in\n (* $ TZ=UTC date --date=@253402300799\n Fri Dec 31 23:59:59 UTC 9999 *)\n let gmtime_upper_bound = 253_402_300_799. in\n if Float.( >= ) sec_since_epoch (gmtime_upper_bound +. 1.)\n || Float.( < ) sec_since_epoch gmtime_lower_bound\n then failwithf \"Time.gmtime: out of range (%f)\" sec_since_epoch ()\n ;;\n\n let sec_per_day = Int63.of_int 86_400\n\n let to_days_from_epoch t =\n assert_in_bounds ~sec_since_epoch:t;\n let open Int63.O in\n let days_from_epoch_approx = Int63.of_float t / sec_per_day in\n (* when [t] is negative the integer division that calculated days_from_epoch_approx\n will leave us one day short because it truncates (e.g. -100 / 86_400 = 0 and we\n want -1) -- adjust for that here. *)\n if Float.( < ) t (Int63.to_float (days_from_epoch_approx * sec_per_day))\n then Int63.pred days_from_epoch_approx\n else days_from_epoch_approx\n ;;\n\n let ofday_of_days_from_epoch t ~days_from_epoch =\n let open Int63.O in\n let days_from_epoch_in_sec = Int63.to_float (days_from_epoch * sec_per_day) in\n let remainder = t -. days_from_epoch_in_sec in\n Span.of_sec remainder |> Ofday.of_span_since_start_of_day_exn\n ;;\n\n let date_of_days_from_epoch ~days_from_epoch =\n Int63.to_int_exn days_from_epoch\n |> Date0.Days.add_days Date0.Days.unix_epoch\n |> Date0.Days.to_date\n ;;\n\n let to_date t =\n let days_from_epoch = to_days_from_epoch t in\n date_of_days_from_epoch ~days_from_epoch\n ;;\n\n let to_ofday t =\n let days_from_epoch = to_days_from_epoch t in\n ofday_of_days_from_epoch t ~days_from_epoch\n ;;\n\n let to_date_ofday t =\n let days_from_epoch = to_days_from_epoch t in\n let date = date_of_days_from_epoch ~days_from_epoch in\n let ofday = ofday_of_days_from_epoch t ~days_from_epoch in\n date, ofday\n ;;\nend\n\nlet next_multiple_internal ~can_equal_after ~base ~after ~interval =\n if Span.( <= ) interval Span.zero\n then\n failwiths\n ~here:[%here]\n \"Time.next_multiple got nonpositive interval\"\n interval\n [%sexp_of: Span.t];\n let base_to_after = diff after base in\n if Span.( < ) base_to_after Span.zero\n then base (* [after < base], choose [k = 0]. *)\n else (\n let next =\n add\n base\n (Span.scale\n interval\n (Float.round ~dir:`Down (Span.( // ) base_to_after interval)))\n in\n if next > after || (can_equal_after && next = after) then next else add next interval)\n;;\n\nlet next_multiple ?(can_equal_after = false) ~base ~after ~interval () =\n next_multiple_internal ~can_equal_after ~base ~after ~interval\n;;\n\nlet prev_multiple ?(can_equal_before = false) ~base ~before ~interval () =\n next_multiple_internal\n ~can_equal_after:(not can_equal_before)\n ~base\n ~after:(sub before interval)\n ~interval\n;;\n\nlet now () =\n let float_ns = Time_now.nanoseconds_since_unix_epoch () |> Int63.to_float in\n of_span_since_epoch (Span.of_sec (float_ns *. 1E-9))\n;;\n\nmodule Stable = struct\n module Span = Span.Stable\n module Ofday = Ofday.Stable\nend\n","open! Import\nopen! Std_internal\n\nmodule type S_kernel_without_zone = Time0_intf.S\nmodule type S_kernel = Time_intf.S\n\nmodule Zone_stable = Zone.Stable\ninclude Time.Make (Time_float0)\ninclude Time_float0\n\nmodule Stable = struct\n include Time_float0.Stable\n\n module With_utc_sexp = struct\n (* V2 is actually the first version of this in Core_kernel, but a V1 stable module\n with generous parsing, unix-dependent [t_of_sexp] already existed in Core *)\n module V2 = struct\n type nonrec t = t [@@deriving bin_io, compare, hash]\n\n let sexp_of_t t = [%sexp (to_string_abs_parts t ~zone:Zone.utc : string list)]\n\n let t_of_sexp sexp =\n try\n match sexp with\n | Sexp.List [ Sexp.Atom date; Sexp.Atom ofday_and_possibly_zone ] ->\n of_string_gen\n ~default_zone:(fun () -> Zone.utc)\n ~find_zone:(fun _ ->\n of_sexp_error \"Time.Stable.With_utc.V2.t_of_sexp: unknown time zone\" sexp)\n (date ^ \" \" ^ ofday_and_possibly_zone)\n | _ -> of_sexp_error \"Time.Stable.With_utc.V2.t_of_sexp\" sexp\n with\n | Of_sexp_error _ as e -> raise e\n | e ->\n of_sexp_error\n (sprintf \"Time.Stable.With_utc.V2.t_of_sexp: %s\" (Exn.to_string e))\n sexp\n ;;\n end\n end\n\n module Zone = Zone_stable\nend\n","open! Import\nopen Std_internal\n\nlet arch_sixtyfour = Sys.word_size = 64\n\nmodule Span = Span_ns\nmodule Ofday = Ofday_ns\n\ntype t = Span.t (* since the Unix epoch (1970-01-01 00:00:00 UTC) *)\n[@@deriving bin_io, compare, hash, typerep]\n\ninclude (Span : Comparable.Infix with type t := t)\ninclude (Span : Quickcheck.S_range with type t := t)\n\nlet now = Span.since_unix_epoch\nlet equal = Span.equal\nlet min_value_for_1us_rounding = Span.min_value_for_1us_rounding\nlet max_value_for_1us_rounding = Span.max_value_for_1us_rounding\nlet epoch = Span.zero\nlet add = Span.( + )\nlet sub = Span.( - )\nlet diff = Span.( - )\nlet abs_diff t u = Span.abs (diff t u)\nlet max = Span.max\nlet min = Span.min\nlet next = Span.next\nlet prev = Span.prev\nlet to_span_since_epoch t = t\nlet of_span_since_epoch s = s\nlet to_int63_ns_since_epoch t : Int63.t = Span.to_int63_ns (to_span_since_epoch t)\nlet of_int63_ns_since_epoch i = of_span_since_epoch (Span.of_int63_ns i)\nlet[@cold] overflow () = raise_s [%message \"Time_ns: overflow\"]\nlet is_earlier t1 ~than:t2 = t1 < t2\nlet is_later t1 ~than:t2 = t1 > t2\n\nlet add_overflowed x y ~sum =\n if Span.( > ) y Span.zero then Span.( < ) sum x else Span.( > ) sum x\n;;\n\nlet sub_overflowed x y ~diff =\n if Span.( > ) y Span.zero then Span.( > ) diff x else Span.( < ) diff x\n;;\n\nlet add_exn x y =\n let sum = add x y in\n if add_overflowed x y ~sum then overflow () else sum\n;;\n\nlet sub_exn x y =\n let diff = sub x y in\n if sub_overflowed x y ~diff then overflow () else diff\n;;\n\nlet add_saturating x y =\n let sum = add x y in\n if add_overflowed x y ~sum\n then\n if Span.(y > zero)\n then Span.max_value_representable\n else Span.min_value_representable\n else sum\n;;\n\nlet sub_saturating x y =\n let diff = sub x y in\n if sub_overflowed x y ~diff\n then\n if Span.(y > zero)\n then Span.min_value_representable\n else Span.max_value_representable\n else diff\n;;\n\nlet to_int_ns_since_epoch =\n if arch_sixtyfour\n then fun t -> Int63.to_int_exn (to_int63_ns_since_epoch t)\n else fun _ -> failwith \"Time_ns.to_int_ns_since_epoch: unsupported on 32bit machines\"\n;;\n\nlet of_int_ns_since_epoch i = of_int63_ns_since_epoch (Int63.of_int i)\n\nlet to_time_float_round_nearest t =\n Time_float.of_span_since_epoch\n (Span.to_span_float_round_nearest (to_span_since_epoch t))\n;;\n\nlet to_time_float_round_nearest_microsecond t =\n Time_float.of_span_since_epoch\n (Span.to_span_float_round_nearest_microsecond (to_span_since_epoch t))\n;;\n\nlet min_time_value_for_1us_rounding =\n to_time_float_round_nearest min_value_for_1us_rounding\n;;\n\nlet max_time_value_for_1us_rounding =\n to_time_float_round_nearest max_value_for_1us_rounding\n;;\n\nlet check_before_conversion_for_1us_rounding time =\n if Time_float.( < ) time min_time_value_for_1us_rounding\n || Time_float.( > ) time max_time_value_for_1us_rounding\n then\n failwiths\n ~here:[%here]\n \"Time_ns does not support this time\"\n time\n [%sexp_of: Time_float.Stable.With_utc_sexp.V2.t]\n;;\n\nlet of_time_float_round_nearest time =\n of_span_since_epoch\n (Span.of_span_float_round_nearest (Time_float.to_span_since_epoch time))\n;;\n\nlet of_time_float_round_nearest_microsecond time =\n check_before_conversion_for_1us_rounding time;\n of_span_since_epoch\n (Span.of_span_float_round_nearest_microsecond (Time_float.to_span_since_epoch time))\n;;\n\nlet[@cold] raise_next_multiple_got_nonpositive_interval interval =\n failwiths\n ~here:[%here]\n \"Time_ns.next_multiple got nonpositive interval\"\n interval\n [%sexp_of: Span.t]\n;;\n\nlet next_multiple_internal ~can_equal_after ~base ~after ~interval =\n if Span.( <= ) interval Span.zero\n then raise_next_multiple_got_nonpositive_interval interval;\n let base_to_after = diff after base in\n if Span.( < ) base_to_after Span.zero\n then base (* [after < base], choose [k = 0]. *)\n else (\n let next = add base (Span.scale_int63 interval (Span.div base_to_after interval)) in\n if next > after || (can_equal_after && next = after) then next else add next interval)\n;;\n\nlet next_multiple ?(can_equal_after = false) ~base ~after ~interval () =\n next_multiple_internal ~can_equal_after ~base ~after ~interval\n;;\n\nlet prev_multiple ?(can_equal_before = false) ~base ~before ~interval () =\n next_multiple_internal\n ~can_equal_after:(not can_equal_before)\n ~base\n ~after:(sub before interval)\n ~interval\n;;\n\nlet random ?state () = Span.random ?state ()\n\nmodule Utc : sig\n val to_date_and_span_since_start_of_day : t -> Date0.t * Span.t\n val of_date_and_span_since_start_of_day : Date0.t -> Span.t -> t\nend = struct\n (* a recreation of the system call gmtime specialized to the fields we need that also\n doesn't rely on Unix. *)\n let to_date_and_span_since_start_of_day t =\n let open Int63.O in\n let ( !< ) i = Int63.of_int_exn i in\n let ( !> ) t = Int63.to_int_exn t in\n let ns_since_epoch = to_int63_ns_since_epoch t in\n let ns_per_day = !<86_400 * !<1_000_000_000 in\n let approx_days_from_epoch = ns_since_epoch / ns_per_day in\n let days_from_epoch =\n if ns_since_epoch < !<0 && approx_days_from_epoch * ns_per_day <> ns_since_epoch\n then approx_days_from_epoch - !<1\n else approx_days_from_epoch\n in\n let ns_since_start_of_day = ns_since_epoch - (ns_per_day * days_from_epoch) in\n let date =\n Date0.Days.add_days Date0.Days.unix_epoch !>days_from_epoch |> Date0.Days.to_date\n in\n let span_since_start_of_day = Span.of_int63_ns ns_since_start_of_day in\n date, span_since_start_of_day\n ;;\n\n let of_date_and_span_since_start_of_day date span_since_start_of_day =\n assert (\n Span.( >= ) span_since_start_of_day Span.zero\n && Span.( < ) span_since_start_of_day Span.day);\n let days_from_epoch =\n Date0.Days.diff (Date0.Days.of_date date) Date0.Days.unix_epoch\n in\n let span_in_days_since_epoch = Span.scale_int Span.day days_from_epoch in\n let span_since_epoch = Span.( + ) span_in_days_since_epoch span_since_start_of_day in\n of_span_since_epoch span_since_epoch\n ;;\nend\n\nmodule Alternate_sexp = struct\n type nonrec t = t\n\n module Ofday_as_span = struct\n open Int.O\n\n let seconds_to_string seconds_span =\n let seconds = Span.to_int_sec seconds_span in\n let h = seconds / 3600 in\n let m = seconds / 60 % 60 in\n let s = seconds % 60 in\n sprintf \"%02d:%02d:%02d\" h m s\n ;;\n\n let two_digit_of_string string =\n assert (String.length string = 2 && String.for_all string ~f:Char.is_digit);\n Int.of_string string\n ;;\n\n let seconds_of_string seconds_string =\n match String.split seconds_string ~on:':' with\n | [ h_string; m_string; s_string ] ->\n let h = two_digit_of_string h_string in\n let m = two_digit_of_string m_string in\n let s = two_digit_of_string s_string in\n Span.of_int_sec ((((h * 60) + m) * 60) + s)\n | _ -> assert false\n ;;\n\n let ns_of_100_ms = 100_000_000\n let ns_of_10_ms = 10_000_000\n let ns_of_1_ms = 1_000_000\n let ns_of_100_us = 100_000\n let ns_of_10_us = 10_000\n let ns_of_1_us = 1_000\n let ns_of_100_ns = 100\n let ns_of_10_ns = 10\n let ns_of_1_ns = 1\n\n let sub_second_to_string sub_second_span =\n let open Int.O in\n let ns = Span.to_int63_ns sub_second_span |> Int63.to_int_exn in\n if ns = 0\n then \"\"\n else if ns % ns_of_100_ms = 0\n then sprintf \".%01d\" (ns / ns_of_100_ms)\n else if ns % ns_of_10_ms = 0\n then sprintf \".%02d\" (ns / ns_of_10_ms)\n else if ns % ns_of_1_ms = 0\n then sprintf \".%03d\" (ns / ns_of_1_ms)\n else if ns % ns_of_100_us = 0\n then sprintf \".%04d\" (ns / ns_of_100_us)\n else if ns % ns_of_10_us = 0\n then sprintf \".%05d\" (ns / ns_of_10_us)\n else if ns % ns_of_1_us = 0\n then sprintf \".%06d\" (ns / ns_of_1_us)\n else if ns % ns_of_100_ns = 0\n then sprintf \".%07d\" (ns / ns_of_100_ns)\n else if ns % ns_of_10_ns = 0\n then sprintf \".%08d\" (ns / ns_of_10_ns)\n else sprintf \".%09d\" ns\n ;;\n\n let sub_second_of_string string =\n if String.is_empty string\n then Span.zero\n else (\n let digits = String.chop_prefix_exn string ~prefix:\".\" in\n assert (String.for_all digits ~f:Char.is_digit);\n let multiplier =\n match String.length digits with\n | 1 -> ns_of_100_ms\n | 2 -> ns_of_10_ms\n | 3 -> ns_of_1_ms\n | 4 -> ns_of_100_us\n | 5 -> ns_of_10_us\n | 6 -> ns_of_1_us\n | 7 -> ns_of_100_ns\n | 8 -> ns_of_10_ns\n | 9 -> ns_of_1_ns\n | _ -> assert false\n in\n Span.of_int63_ns (Int63.of_int (Int.of_string digits * multiplier)))\n ;;\n\n let to_string span =\n assert (Span.( >= ) span Span.zero && Span.( < ) span Span.day);\n let seconds_span = span |> Span.to_int_sec |> Span.of_int_sec in\n let sub_second_span = Span.( - ) span seconds_span in\n seconds_to_string seconds_span ^ sub_second_to_string sub_second_span\n ;;\n\n let of_string string =\n let len = String.length string in\n let prefix_len = 8 in\n (* \"HH:MM:DD\" *)\n let suffix_len = len - prefix_len in\n let seconds_string = String.sub string ~pos:0 ~len:prefix_len in\n let sub_second_string = String.sub string ~pos:prefix_len ~len:suffix_len in\n let seconds_span = seconds_of_string seconds_string in\n let sub_second_span = sub_second_of_string sub_second_string in\n Span.( + ) seconds_span sub_second_span\n ;;\n end\n\n let to_string t =\n let date, span_since_start_of_day = Utc.to_date_and_span_since_start_of_day t in\n Date0.to_string date ^ \" \" ^ Ofday_as_span.to_string span_since_start_of_day ^ \"Z\"\n ;;\n\n let of_string string =\n let date_string, ofday_string_with_zone = String.lsplit2_exn string ~on:' ' in\n let ofday_string = String.chop_suffix_exn ofday_string_with_zone ~suffix:\"Z\" in\n let date = Date0.of_string date_string in\n let ofday = Ofday_as_span.of_string ofday_string in\n Utc.of_date_and_span_since_start_of_day date ofday\n ;;\n\n include Sexpable.Of_stringable (struct\n type nonrec t = t\n\n let to_string = to_string\n let of_string = of_string\n end)\n\n module Stable = struct\n module V1 = struct\n (* see tests in lib/core_kernel/test/test_time_ns that ensure stability of this\n representation *)\n type nonrec t = t [@@deriving bin_io, compare, sexp]\n end\n end\nend\n\nmodule Stable = struct\n module Alternate_sexp = Alternate_sexp.Stable\n module Span = Span.Stable\n module Ofday = Ofday.Stable\nend\n\n(* this code is directly duplicated from Time.ml functor, converted enough to get Time_ns\n to/of_string working *)\nmodule To_and_of_string : sig\n val of_date_ofday : zone:Zone.t -> Date.t -> Ofday.t -> t\n\n val of_date_ofday_precise\n : Date.t\n -> Ofday.t\n -> zone:Zone.t\n -> [ `Once of t | `Twice of t * t | `Never of t ]\n\n val to_date_ofday : t -> zone:Zone.t -> Date.t * Ofday.t\n\n val to_date_ofday_precise\n : t\n -> zone:Zone.t\n -> Date.t * Ofday.t * [ `Only | `Also_at of t | `Also_skipped of Date.t * Ofday.t ]\n\n val to_date : t -> zone:Zone.t -> Date.t\n val to_ofday : t -> zone:Zone.t -> Ofday.t\n val convert : from_tz:Zone.t -> to_tz:Zone.t -> Date.t -> Ofday.t -> Date.t * Ofday.t\n val reset_date_cache : unit -> unit\n val utc_offset : t -> zone:Zone.t -> Span.t\n\n include Stringable with type t := t\n\n val to_filename_string : t -> zone:Zone.t -> string\n val of_filename_string : string -> zone:Zone.t -> t\n val to_string_trimmed : t -> zone:Zone.t -> string\n val to_sec_string : t -> zone:Zone.t -> string\n val of_localized_string : zone:Zone.t -> string -> t\n\n val of_string_gen\n : default_zone:(unit -> Zone.t)\n -> find_zone:(string -> Zone.t)\n -> string\n -> t\n\n val to_string_abs : t -> zone:Zone.t -> string\n val to_string_abs_trimmed : t -> zone:Zone.t -> string\n val to_string_abs_parts : t -> zone:Zone.t -> string list\n val to_string_iso8601_basic : t -> zone:Zone.t -> string\n\n val occurrence\n : [ `First_after_or_at | `Last_before_or_at ]\n -> t\n -> ofday:Ofday.t\n -> zone:Zone.t\n -> t\nend = struct\n (* this code is directly duplicated from Time_float0.ml, converted enough to get\n Time_ns to/of_string working *)\n module Date_and_ofday = struct\n type t = Int63.t\n\n let to_synthetic_span_since_epoch t = Span.of_int63_ns t\n\n let of_date_ofday date ofday =\n let days =\n Date0.Days.diff (Date0.Days.of_date date) Date0.Days.unix_epoch |> Int63.of_int\n in\n let open Int63.O in\n (days * Span.to_int63_ns Span.day)\n + Span.to_int63_ns (Ofday.to_span_since_start_of_day ofday)\n ;;\n\n let to_absolute relative ~offset_from_utc =\n sub_exn (Span.of_int63_ns relative) offset_from_utc\n ;;\n\n let of_absolute absolute ~offset_from_utc =\n Span.to_int63_ns (add_exn absolute offset_from_utc)\n ;;\n\n let ns_per_day = Span.to_int63_ns Span.day\n\n let to_days_from_epoch t =\n (* note Time_ns represents about 146 years, not enough for [Date.create_exn] to ever\n raise *)\n let open Int63.O in\n let days_from_epoch_approx = t / ns_per_day in\n (* when [t] is negative the integer division that calculated days_from_epoch_approx\n will leave us one day short because it truncates (e.g. -100 / 86_400 = 0 and we\n want -1) -- adjust for that here. *)\n if t < days_from_epoch_approx * ns_per_day\n then Int63.pred days_from_epoch_approx\n else days_from_epoch_approx\n ;;\n\n let ofday_of_days_from_epoch t ~days_from_epoch =\n let open Int63.O in\n let days_from_epoch_in_ns = days_from_epoch * ns_per_day in\n let remainder = t - days_from_epoch_in_ns in\n Span.of_int63_ns remainder |> Ofday.of_span_since_start_of_day_exn\n ;;\n\n let date_of_days_from_epoch ~days_from_epoch =\n Int63.to_int_exn days_from_epoch\n |> Date0.Days.add_days Date0.Days.unix_epoch\n |> Date0.Days.to_date\n ;;\n\n let to_date t =\n let days_from_epoch = to_days_from_epoch t in\n date_of_days_from_epoch ~days_from_epoch\n ;;\n\n let to_ofday t =\n let days_from_epoch = to_days_from_epoch t in\n ofday_of_days_from_epoch t ~days_from_epoch\n ;;\n end\n\n module Zone0 = Zone\n\n module Zone : sig\n (* This interface is directly duplicated from Time_intf.Zone, converted enough to get\n this to work.\n\n The problem is has references to Time0_intf.S, which is the functor input interface\n that Time_ns currently does not satisfy. *)\n\n type time = t\n type t = Zone.t [@@deriving sexp_of]\n\n module Index = Zone.Index\n\n (* copied functions reexported from Zone *)\n\n val utc : t\n val index_has_prev_clock_shift : t -> Index.t -> bool\n val index_has_next_clock_shift : t -> Index.t -> bool\n\n (* new functions defined below *)\n\n val index : t -> time -> Index.t\n val index_offset_from_utc_exn : t -> Index.t -> time\n val index_prev_clock_shift_time_exn : t -> Index.t -> time\n val index_next_clock_shift_time_exn : t -> Index.t -> time\n val absolute_time_of_date_and_ofday : t -> Date_and_ofday.t -> time\n val date_and_ofday_of_absolute_time : t -> time -> Date_and_ofday.t\n val next_clock_shift : t -> strictly_after:time -> (time * Span.t) option\n val prev_clock_shift : t -> at_or_before:time -> (time * Span.t) option\n end = struct\n type time = t\n\n include Zone\n\n let of_span_in_seconds span_in_seconds =\n (* NB. no actual rounding or exns can occur here *)\n Time_in_seconds.Span.to_int63_seconds_round_down_exn span_in_seconds\n |> Span.of_int63_seconds\n ;;\n\n let of_time_in_seconds time_in_seconds =\n Time_in_seconds.to_span_since_epoch time_in_seconds\n (* NB. no actual rounding or exns can occur here *)\n |> Time_in_seconds.Span.to_int63_seconds_round_down_exn\n |> Span.of_int63_seconds\n |> of_span_since_epoch\n ;;\n\n let to_time_in_seconds_round_down_exn time =\n to_span_since_epoch time\n |> Span.to_int63_seconds_round_down_exn\n |> Time_in_seconds.Span.of_int63_seconds\n |> Time_in_seconds.of_span_since_epoch\n ;;\n\n let to_date_and_ofday_in_seconds_round_down_exn relative =\n Date_and_ofday.to_synthetic_span_since_epoch relative\n |> Span.to_int63_seconds_round_down_exn\n |> Time_in_seconds.Span.of_int63_seconds\n |> Time_in_seconds.Date_and_ofday.of_synthetic_span_since_epoch\n ;;\n\n let index t time = index t (to_time_in_seconds_round_down_exn time)\n\n let index_of_date_and_ofday t relative =\n index_of_date_and_ofday t (to_date_and_ofday_in_seconds_round_down_exn relative)\n ;;\n\n let index_offset_from_utc_exn t index =\n of_span_in_seconds (index_offset_from_utc_exn t index)\n ;;\n\n let index_prev_clock_shift_time_exn t index =\n of_time_in_seconds (index_prev_clock_shift_time_exn t index)\n ;;\n\n let index_next_clock_shift_time_exn t index =\n of_time_in_seconds (index_next_clock_shift_time_exn t index)\n ;;\n\n let index_prev_clock_shift_amount_exn t index =\n of_span_in_seconds (index_prev_clock_shift_amount_exn t index)\n ;;\n\n let index_prev_clock_shift t index =\n match index_has_prev_clock_shift t index with\n | false -> None\n | true ->\n Some\n ( index_prev_clock_shift_time_exn t index\n , index_prev_clock_shift_amount_exn t index )\n ;;\n\n let index_next_clock_shift t index = index_prev_clock_shift t (Index.next index)\n let prev_clock_shift t ~at_or_before:time = index_prev_clock_shift t (index t time)\n let next_clock_shift t ~strictly_after:time = index_next_clock_shift t (index t time)\n\n let date_and_ofday_of_absolute_time t time =\n let index = index t time in\n (* no exn because [index] always returns a valid index *)\n let offset_from_utc = index_offset_from_utc_exn t index in\n Date_and_ofday.of_absolute time ~offset_from_utc\n ;;\n\n let absolute_time_of_date_and_ofday t relative =\n let index = index_of_date_and_ofday t relative in\n (* no exn because [index_of_date_and_ofday] always returns a valid index *)\n let offset_from_utc = index_offset_from_utc_exn t index in\n Date_and_ofday.to_absolute relative ~offset_from_utc\n ;;\n end\n\n let of_date_ofday ~zone date ofday =\n let relative = Date_and_ofday.of_date_ofday date ofday in\n Zone.absolute_time_of_date_and_ofday zone relative\n ;;\n\n let of_date_ofday_precise date ofday ~zone =\n (* We assume that there will be only one zone shift within a given local day. *)\n let start_of_day = of_date_ofday ~zone date Ofday.start_of_day in\n let proposed_time = add start_of_day (Ofday.to_span_since_start_of_day ofday) in\n match Zone.next_clock_shift zone ~strictly_after:start_of_day with\n | None -> `Once proposed_time\n | Some (shift_start, shift_amount) ->\n let shift_backwards = Span.(shift_amount < zero) in\n (* start and end of the \"problematic region\" *)\n let s, e =\n if shift_backwards\n then add shift_start shift_amount, shift_start\n else shift_start, add shift_start shift_amount\n in\n if proposed_time < s\n then `Once proposed_time\n else if s <= proposed_time && proposed_time < e\n then\n if shift_backwards\n then `Twice (proposed_time, sub proposed_time shift_amount)\n else `Never shift_start\n else `Once (sub proposed_time shift_amount)\n ;;\n\n module Date_cache = struct\n type nonrec t =\n { mutable zone : Zone.t\n ; mutable cache_start_incl : t\n ; mutable cache_until_excl : t\n ; mutable effective_day_start : t\n ; mutable date : Date0.t\n }\n end\n\n let date_cache : Date_cache.t =\n { zone = Zone.utc\n ; cache_start_incl = epoch\n ; cache_until_excl = epoch\n ; effective_day_start = epoch\n ; date = Date0.unix_epoch\n }\n ;;\n\n let reset_date_cache () =\n date_cache.zone <- Zone.utc;\n date_cache.cache_start_incl <- epoch;\n date_cache.cache_until_excl <- epoch;\n date_cache.effective_day_start <- epoch;\n date_cache.date <- Date0.unix_epoch\n ;;\n\n let is_in_cache time ~zone =\n phys_equal zone date_cache.zone\n && time >= date_cache.cache_start_incl\n && time < date_cache.cache_until_excl\n ;;\n\n let set_date_cache time ~zone =\n match is_in_cache time ~zone with\n | true -> ()\n | false ->\n let index = Zone.index zone time in\n (* no exn because [Zone.index] always returns a valid index *)\n let offset_from_utc = Zone.index_offset_from_utc_exn zone index in\n let rel = Date_and_ofday.of_absolute time ~offset_from_utc in\n let date = Date_and_ofday.to_date rel in\n let span = Date_and_ofday.to_ofday rel |> Ofday.to_span_since_start_of_day in\n let effective_day_start =\n sub (Date_and_ofday.to_absolute rel ~offset_from_utc) span\n in\n let effective_day_until = add effective_day_start Span.day in\n let cache_start_incl =\n match Zone.index_has_prev_clock_shift zone index with\n | false -> effective_day_start\n | true ->\n effective_day_start |> max (Zone.index_prev_clock_shift_time_exn zone index)\n in\n let cache_until_excl =\n match Zone.index_has_next_clock_shift zone index with\n | false -> effective_day_until\n | true ->\n effective_day_until |> min (Zone.index_next_clock_shift_time_exn zone index)\n in\n date_cache.zone <- zone;\n date_cache.cache_start_incl <- cache_start_incl;\n date_cache.cache_until_excl <- cache_until_excl;\n date_cache.effective_day_start <- effective_day_start;\n date_cache.date <- date\n ;;\n\n let to_date time ~zone =\n set_date_cache time ~zone;\n date_cache.date\n ;;\n\n let to_ofday time ~zone =\n set_date_cache time ~zone;\n diff time date_cache.effective_day_start |> Ofday.of_span_since_start_of_day_exn\n ;;\n\n let to_date_ofday time ~zone = to_date time ~zone, to_ofday time ~zone\n\n (* The correctness of this algorithm (interface, even) depends on the fact that\n timezone shifts aren't too close together (as in, it can't simultaneously be the\n case that a timezone shift of X hours occurred less than X hours ago, *and*\n a timezone shift of Y hours will occur in less than Y hours' time) *)\n let to_date_ofday_precise time ~zone =\n let date, ofday = to_date_ofday time ~zone in\n let clock_shift_after = Zone.next_clock_shift zone ~strictly_after:time in\n let clock_shift_before_or_at = Zone.prev_clock_shift zone ~at_or_before:time in\n let also_skipped_earlier amount =\n (* Using [date] and raising on [None] here is OK on the assumption that clock\n shifts can't cross date boundaries. This is true in all cases I've ever heard\n of (and [of_date_ofday_precise] would need revisiting if it turned out to be\n false) *)\n match Ofday.sub ofday amount with\n | Some ofday -> `Also_skipped (date, ofday)\n | None ->\n raise_s\n [%message\n \"Time.to_date_ofday_precise\"\n ~span_since_epoch:(to_span_since_epoch time : Span.t)\n (zone : Zone.t)]\n in\n let ambiguity =\n (* Edge cases: the instant of transition belongs to the new zone regime. So if the\n clock moved by an hour exactly one hour ago, there's no ambiguity, because the\n hour-ago time belongs to the same regime as you, and conversely, if the clock\n will move by an hour in an hours' time, there *is* ambiguity. Hence [>.] for\n the first case and [<=.] for the second. *)\n match clock_shift_before_or_at, clock_shift_after with\n | Some (start, amount), _ when add start (Span.abs amount) > time ->\n (* clock shifted recently *)\n if Span.(amount > zero)\n then\n (* clock shifted forward recently: we skipped a time *)\n also_skipped_earlier amount\n else (\n (* clock shifted back recently: this date/ofday already happened *)\n assert (Span.(amount < zero));\n `Also_at (sub time (Span.abs amount)))\n | _, Some (start, amount) when sub start (Span.abs amount) <= time ->\n (* clock is about to shift *)\n if Span.(amount > zero)\n then (* clock about to shift forward: no effect *)\n `Only\n else (\n (* clock about to shift back: this date/ofday will be repeated *)\n assert (Span.(amount < zero));\n `Also_at (add time (Span.abs amount)))\n | _ -> `Only\n in\n date, ofday, ambiguity\n ;;\n\n let convert ~from_tz ~to_tz date ofday =\n let start_time = of_date_ofday ~zone:from_tz date ofday in\n to_date_ofday ~zone:to_tz start_time\n ;;\n\n let utc_offset t ~zone =\n let utc_epoch = Zone.date_and_ofday_of_absolute_time zone t in\n Span.( - )\n (Date_and_ofday.to_synthetic_span_since_epoch utc_epoch)\n (to_span_since_epoch t)\n ;;\n\n let offset_string time ~zone =\n let utc_offset = utc_offset time ~zone in\n let is_utc = Span.( = ) utc_offset Span.zero in\n if is_utc\n then \"Z\"\n else\n String.concat\n [ (if Span.( < ) utc_offset Span.zero then \"-\" else \"+\")\n ; Ofday.to_string_trimmed\n (Ofday.of_span_since_start_of_day_exn (Span.abs utc_offset))\n ]\n ;;\n\n let to_string_abs_parts =\n let attempt time ~zone =\n let date, ofday = to_date_ofday time ~zone in\n let offset_string = offset_string time ~zone in\n [ Date0.to_string date\n ; String.concat ~sep:\"\" [ Ofday.to_string ofday; offset_string ]\n ]\n in\n fun time ~zone ->\n try attempt time ~zone with\n | (_ : exn) ->\n (* If we overflow applying the UTC offset, try again with UTC time. *)\n attempt time ~zone:Zone.utc\n ;;\n\n let to_string_abs_trimmed time ~zone =\n let date, ofday = to_date_ofday time ~zone in\n let offset_string = offset_string time ~zone in\n String.concat\n ~sep:\" \"\n [ Date0.to_string date; Ofday.to_string_trimmed ofday ^ offset_string ]\n ;;\n\n let to_string_abs time ~zone = String.concat ~sep:\" \" (to_string_abs_parts ~zone time)\n let to_string t = to_string_abs t ~zone:Zone.utc\n\n let to_string_iso8601_basic time ~zone =\n String.concat ~sep:\"T\" (to_string_abs_parts ~zone time)\n ;;\n\n let to_string_trimmed t ~zone =\n let date, sec = to_date_ofday ~zone t in\n Date0.to_string date ^ \" \" ^ Ofday.to_string_trimmed sec\n ;;\n\n let to_sec_string t ~zone =\n let date, sec = to_date_ofday ~zone t in\n Date0.to_string date ^ \" \" ^ Ofday.to_sec_string sec\n ;;\n\n let to_filename_string t ~zone =\n let date, ofday = to_date_ofday ~zone t in\n Date0.to_string date\n ^ \"_\"\n ^ String.tr\n ~target:':'\n ~replacement:'-'\n (String.drop_suffix (Ofday.to_string ofday) 3)\n ;;\n\n let of_filename_string s ~zone =\n try\n match String.lsplit2 s ~on:'_' with\n | None -> failwith \"no space in filename string\"\n | Some (date, ofday) ->\n let date = Date0.of_string date in\n let ofday = String.tr ~target:'-' ~replacement:':' ofday in\n let ofday = Ofday.of_string ofday in\n of_date_ofday date ofday ~zone\n with\n | exn -> invalid_argf \"Time.of_filename_string (%s): %s\" s (Exn.to_string exn) ()\n ;;\n\n let of_localized_string ~zone str =\n try\n match String.lsplit2 str ~on:' ' with\n | None -> invalid_arg (sprintf \"no space in date_ofday string: %s\" str)\n | Some (date, time) ->\n let date = Date0.of_string date in\n let ofday = Ofday.of_string time in\n of_date_ofday ~zone date ofday\n with\n | e -> Exn.reraise e \"Time.of_localized_string\"\n ;;\n\n let occurrence before_or_after t ~ofday ~zone =\n let first_guess_date = to_date t ~zone in\n let first_guess = of_date_ofday ~zone first_guess_date ofday in\n let cmp, increment =\n match before_or_after with\n | `Last_before_or_at -> ( <= ), -1\n | `First_after_or_at -> ( >= ), 1\n in\n if cmp first_guess t\n then first_guess\n else of_date_ofday ~zone (Date0.add_days first_guess_date increment) ofday\n ;;\n\n let ensure_colon_in_offset offset =\n let offset_length = String.length offset in\n if Int.( <= ) offset_length 2\n && Char.is_digit offset.[0]\n && Char.is_digit offset.[offset_length - 1]\n then offset ^ \":00\"\n else if Char.( = ) offset.[1] ':' || Char.( = ) offset.[2] ':'\n then offset\n else if Int.( < ) offset_length 3 || Int.( > ) offset_length 4\n then failwithf \"invalid offset %s\" offset ()\n else\n String.concat\n [ String.slice offset 0 (offset_length - 2)\n ; \":\"\n ; String.slice offset (offset_length - 2) offset_length\n ]\n ;;\n\n exception Time_ns_of_string of string * Exn.t [@@deriving sexp]\n\n let of_string_gen ~default_zone ~find_zone s =\n try\n let date, ofday, tz =\n match String.split s ~on:' ' with\n | [ day; month; year; ofday ] ->\n String.concat [ day; \" \"; month; \" \"; year ], ofday, None\n | [ date; ofday; tz ] -> date, ofday, Some tz\n | [ date; ofday ] -> date, ofday, None\n | [ s ] ->\n (match String.rsplit2 ~on:'T' s with\n | Some (date, ofday) -> date, ofday, None\n | None -> failwith \"no spaces or T found\")\n | _ -> failwith \"too many spaces\"\n in\n let ofday_to_sec od = Span.to_sec (Ofday.to_span_since_start_of_day od) in\n let ofday, utc_offset =\n match tz with\n | Some _ -> ofday, None\n | None ->\n if Char.( = ) ofday.[String.length ofday - 1] 'Z'\n then String.sub ofday ~pos:0 ~len:(String.length ofday - 1), Some 0.\n else (\n match String.lsplit2 ~on:'+' ofday with\n | Some (l, r) ->\n l, Some (ofday_to_sec (Ofday.of_string (ensure_colon_in_offset r)))\n | None ->\n (match String.lsplit2 ~on:'-' ofday with\n | Some (l, r) ->\n l, Some (-1. *. ofday_to_sec (Ofday.of_string (ensure_colon_in_offset r)))\n | None -> ofday, None))\n in\n let date = Date0.of_string date in\n let ofday = Ofday.of_string ofday in\n match tz with\n | Some tz -> of_date_ofday ~zone:(find_zone tz) date ofday\n | None ->\n (match utc_offset with\n | None ->\n let zone = default_zone () in\n of_date_ofday ~zone date ofday\n | Some utc_offset ->\n let utc_t = of_date_ofday ~zone:Zone.utc date ofday in\n sub utc_t (Span.of_sec utc_offset))\n with\n | e -> raise (Time_ns_of_string (s, e))\n ;;\n\n let of_string s =\n let default_zone () = raise_s [%message \"time has no time zone or UTC offset\" s] in\n let find_zone zone_name =\n failwithf \"unable to lookup Zone %s. Try using Core.Time.of_string\" zone_name ()\n in\n of_string_gen ~default_zone ~find_zone s\n ;;\nend\n\ninclude To_and_of_string\n\nlet min_value_representable = of_span_since_epoch Span.min_value_representable\nlet max_value_representable = of_span_since_epoch Span.max_value_representable\n\n(* Legacy definitions based on rounding to the nearest microsecond. *)\nlet min_value = min_value_for_1us_rounding\nlet max_value = max_value_for_1us_rounding\nlet to_time = to_time_float_round_nearest_microsecond\nlet of_time = of_time_float_round_nearest_microsecond\n\nmodule For_ppx_module_timer = struct\n open Ppx_module_timer_runtime\n\n let () =\n Duration.format\n := (module struct\n let duration_of_span s = s |> Span.to_int63_ns |> Duration.of_nanoseconds\n let span_of_duration d = d |> Duration.to_nanoseconds |> Span.of_int63_ns\n let of_string string = string |> Span.of_string |> duration_of_span\n\n let to_string_with_same_unit durations =\n let spans = durations |> List.map ~f:span_of_duration in\n let unit_of_time =\n spans\n |> List.max_elt ~compare:Span.compare\n |> Option.value_map\n ~f:Span.to_unit_of_time\n ~default:Unit_of_time.Nanosecond\n in\n spans |> List.map ~f:(Span.to_string_hum ~unit_of_time ~align_decimal:true)\n ;;\n end)\n ;;\nend\n","open! Import\n\n(* A [Time_ns] that uses its alternate sexp representation. *)\ninclude Time_ns\ninclude Alternate_sexp\n","module Stable = struct\n open Stable_internal\n\n module T = struct\n type 'a t =\n { mutable value : 'a option\n ; mutable set_at : Source_code_position.Stable.V1.t\n }\n [@@deriving fields]\n end\n\n module V1 = struct\n module Format = struct\n type 'a t = 'a option ref [@@deriving bin_io, sexp]\n end\n\n module T = struct\n type 'a t = 'a T.t\n\n let of_format (v1 : 'a Format.t) : 'a t = { value = !v1; set_at = [%here] }\n let to_format (t : 'a t) : 'a Format.t = ref t.value\n end\n\n include T\n\n include Binable.Of_binable1_without_uuid [@alert \"-legacy\"]\n (Format)\n (struct\n include T\n\n let of_binable = of_format\n let to_binable = to_format\n end)\n\n include Sexpable.Of_sexpable1\n (Format)\n (struct\n include T\n\n let of_sexpable = of_format\n let to_sexpable = to_format\n end)\n end\nend\n\nopen! Import\nmodule Unstable = Stable.V1\nopen Stable.T\n\ntype 'a t = 'a Stable.T.t\n\nlet sexp_of_t sexp_of_a { value; set_at } =\n match value with\n | None -> [%message \"unset\"]\n | Some value ->\n [%message \"\" (value : a) ~set_at:(set_at |> Source_code_position.to_string)]\n;;\n\nlet invariant invariant_a t =\n match t.value with\n | None -> ()\n | Some a -> invariant_a a\n;;\n\nlet create () = { value = None; set_at = [%here] }\n\nlet set_internal t here value =\n t.value <- Some value;\n t.set_at <- here\n;;\n\nlet set_if_none t here value = if Option.is_none t.value then set_internal t here value\n\nlet set t here value =\n if Option.is_none t.value\n then (\n set_internal t here value;\n Ok ())\n else\n Or_error.error_s\n [%message\n \"[Set_once.set_exn] already set\"\n ~setting_at:(here : Source_code_position.t)\n ~previously_set_at:(t.set_at : Source_code_position.t)]\n;;\n\nlet set_exn t here value = Or_error.ok_exn (set t here value)\nlet get t = t.value\n\nlet get_exn (t : _ t) here =\n match t.value with\n | Some a -> a\n | None ->\n raise_s [%message \"[Set_once.get_exn] unset\" ~at:(here : Source_code_position.t)]\n;;\n\nlet is_none t = Option.is_none t.value\nlet is_some t = Option.is_some t.value\nlet iter t ~f = Option.iter t.value ~f\n\nmodule Optional_syntax = struct\n module Optional_syntax = struct\n let is_none = is_none\n let unsafe_value t = get_exn t [%here]\n end\nend\n","open! Import\n\ntype 'a t = 'a [@@deriving sexp_of]\n\nexternal is_heap_block : Caml.Obj.t -> bool = \"Core_kernel_heap_block_is_heap_block\"\n[@@noalloc]\n\nlet is_ok v = is_heap_block (Caml.Obj.repr v)\nlet create v = if is_ok v then Some v else None\n\nlet create_exn v =\n if is_ok v then v else failwith \"Heap_block.create_exn called with non heap block\"\n;;\n\nlet value t = t\nlet bytes_per_word = Word_size.(num_bits word_size) / 8\n\nlet bytes (type a) (t : a t) =\n (Caml.Obj.size (Caml.Obj.repr (t : a t)) + 1) * bytes_per_word\n;;\n","open! Import\ninclude Base.Queue\n\ninclude Test_binary_searchable.Make1_and_test (struct\n type nonrec 'a t = 'a t\n\n let get = get\n let length = length\n\n module For_test = struct\n let of_array a =\n let r = create () in\n (* We enqueue everything twice, and dequeue it once to ensure:\n - that the queue has the same content as the array.\n - that it has, in most cases, an interesting internal structure*)\n for i = 0 to Array.length a - 1 do\n enqueue r a.(i)\n done;\n for i = 0 to Array.length a - 1 do\n ignore (dequeue_exn r : bool);\n enqueue r a.(i)\n done;\n r\n ;;\n end\n end)\n\nmodule Serialization_v1 = struct\n let sexp_of_t = sexp_of_t\n let t_of_sexp = t_of_sexp\n\n include Bin_prot.Utils.Make_iterable_binable1 (struct\n type nonrec 'a t = 'a t\n type 'a el = 'a [@@deriving bin_io]\n\n let caller_identity =\n Bin_prot.Shape.Uuid.of_string \"b4c84254-4992-11e6-9ba7-734e154027bd\"\n ;;\n\n let module_name = Some \"Core_kernel.Queue\"\n let length = length\n let iter = iter\n let init ~len ~next = init len ~f:(fun _ -> next ())\n end)\nend\n\ninclude Serialization_v1\n\nmodule Stable = struct\n module V1 = struct\n type nonrec 'a t = 'a t [@@deriving compare]\n\n include Serialization_v1\n\n (* We don't have a [%bin_digest] expect test here because the bin_io is mostly hand\n written, and [core_queue_unit_tests.ml] has unit tests for specific values. *)\n\n let map = map\n end\nend\n","open! Import\ninclude Base.Option_array\n\nlet to_array t = Array.init (length t) ~f:(fun i -> unsafe_get t i)\nlet of_array a = init (Array.length a) ~f:(fun i -> Array.unsafe_get a i)\n\ninclude Binable.Of_binable1_without_uuid [@alert \"-legacy\"]\n (struct\n type 'a t = 'a option array [@@deriving sexp, bin_io]\n end)\n (struct\n type nonrec 'a t = 'a t\n\n let to_binable = to_array\n let of_binable = of_array\n end)\n","open! Import\nopen Std_internal\n\ntype ('a, 'b) fn = 'a -> 'b\n\nmodule Result = struct\n type 'a t =\n | Rval of 'a\n | Expt of exn\n\n let return = function\n | Rval v -> v\n | Expt e -> raise e\n ;;\n\n let capture f x =\n try Rval (f x) with\n | Sys.Break as e -> raise e\n | e -> Expt e\n ;;\nend\n\nlet unit f =\n let l = Lazy.from_fun f in\n fun () -> Lazy.force l\n;;\n\nlet unbounded (type a) ?(hashable = Hashtbl.Hashable.poly) f =\n let cache =\n let module A =\n Hashable.Make_plain_and_derive_hash_fold_t (struct\n type t = a\n\n let { Hashtbl.Hashable.hash; compare; sexp_of_t } = hashable\n end)\n in\n A.Table.create () ~size:0\n in\n (* Allocate this closure at the call to [unbounded], not at each call to the memoized\n function. *)\n let really_call_f arg = Result.capture f arg in\n fun arg -> Result.return (Hashtbl.findi_or_add cache arg ~default:really_call_f)\n;;\n\n(* the same but with a bound on cache size *)\nlet lru (type a) ?(hashable = Hashtbl.Hashable.poly) ~max_cache_size f =\n if max_cache_size <= 0\n then failwithf \"Memo.lru: max_cache_size of %i <= 0\" max_cache_size ();\n let module Cache =\n Hash_queue.Make (struct\n type t = a\n\n let { Hashtbl.Hashable.hash; compare; sexp_of_t } = hashable\n end)\n in\n let cache = Cache.create () in\n fun arg ->\n Result.return\n (match Cache.lookup_and_move_to_back cache arg with\n | Some result -> result\n | None ->\n let result = Result.capture f arg in\n Cache.enqueue_back_exn cache arg result;\n (* eject least recently used cache entry *)\n if Cache.length cache > max_cache_size\n then ignore (Cache.dequeue_front_exn cache : _ Result.t);\n result)\n;;\n\nlet general ?hashable ?cache_size_bound f =\n match cache_size_bound with\n | None -> unbounded ?hashable f\n | Some n -> lru ?hashable ~max_cache_size:n f\n;;\n\nlet of_comparable (type index) (module M : Comparable.S_plain with type t = index) f =\n let m = ref M.Map.empty in\n fun (x : M.t) ->\n let v =\n match Map.find !m x with\n | Some v -> v\n | None ->\n let v = Result.capture f x in\n m := Map.set !m ~key:x ~data:v;\n v\n in\n Result.return v\n;;\n","open! Import\nopen Std_internal\n\ntype 'a t =\n { (* [arr] is a cyclic buffer *)\n mutable arr : 'a Option_array.t\n ; (* [front_index] and [back_index] are the positions in which new elements may be\n enqueued. This makes the active part of [arr] the range from [front_index+1] to\n [back_index-1] (modulo the length of [arr] and wrapping around if necessary). Note\n that this means the active range is maximized when [front_index = back_index], which\n occurs when there are [Array.length arr - 1] active elements. *)\n mutable front_index : int\n ; mutable back_index : int\n ; (* apparent_front_index is what is exposed as the front index externally. It has no\n real relation to the array -- every enqueue to the front decrements it and every\n dequeue from the front increments it. *)\n mutable apparent_front_index : int\n ; mutable length : int\n ; (* We keep arr_length here as a speed hack. Calling Array.length on arr is actually\n meaningfully slower. *)\n mutable arr_length : int\n ; never_shrink : bool\n }\n\nlet create ?initial_length ?never_shrink () =\n let never_shrink =\n match never_shrink with\n | None -> Option.is_some initial_length\n | Some b -> b\n in\n let initial_length = Option.value ~default:7 initial_length in\n if initial_length < 0\n then\n invalid_argf \"passed negative initial_length to Deque.create: %i\" initial_length ();\n (* Make the initial array length be [initial_length + 1] so we can fit [initial_length]\n elements without growing. We never quite use the whole array. *)\n let arr_length = initial_length + 1 in\n { arr = Option_array.create ~len:arr_length\n ; front_index = 0\n ; back_index = 1\n ; apparent_front_index = 0\n ; length = 0\n ; arr_length\n ; never_shrink\n }\n;;\n\nlet length t = t.length\nlet is_empty t = length t = 0\n\n(* We keep track of the length in a mutable field for speed, but this calculation should\n be correct by construction, and can be used for testing. *)\nlet _invariant_length t =\n let constructed_length =\n if t.front_index < t.back_index\n then t.back_index - t.front_index - 1\n else t.back_index - t.front_index - 1 + t.arr_length\n in\n assert (length t = constructed_length)\n;;\n\n(* The various \"when_not_empty\" functions return misleading numbers when the dequeue is\n empty. They are safe to call if it is known that the dequeue is non-empty. *)\nlet apparent_front_index_when_not_empty t = t.apparent_front_index\nlet apparent_back_index_when_not_empty t = t.apparent_front_index + length t - 1\n\nlet actual_front_index_when_not_empty t =\n if t.front_index = t.arr_length - 1 then 0 else t.front_index + 1\n;;\n\nlet actual_back_index_when_not_empty t =\n if t.back_index = 0 then t.arr_length - 1 else t.back_index - 1\n;;\n\nlet checked t f = if is_empty t then None else Some (f t)\nlet apparent_front_index t = checked t apparent_front_index_when_not_empty\nlet apparent_back_index t = checked t apparent_back_index_when_not_empty\n\nlet foldi' t dir ~init ~f =\n if is_empty t\n then init\n else (\n let apparent_front = apparent_front_index_when_not_empty t in\n let apparent_back = apparent_back_index_when_not_empty t in\n let actual_front = actual_front_index_when_not_empty t in\n let actual_back = actual_back_index_when_not_empty t in\n let rec loop acc ~apparent_i ~real_i ~stop_pos ~step =\n if real_i = stop_pos\n then acc, apparent_i\n else\n loop\n (f apparent_i acc (Option_array.get_some_exn t.arr real_i))\n ~apparent_i:(apparent_i + step)\n ~real_i:(real_i + step)\n ~stop_pos\n ~step\n in\n (* We want to iterate from actual_front to actual_back (or vice versa), but we may\n need to wrap around the array to do so. Thus we do the following:\n 1. If the active range is contiguous (i.e. actual_front <= actual_back), then loop\n starting at the appropriate end of the active range until we reach the first\n element outside of it.\n 2. If it is not contiguous (actual_front > actual_back), then first loop from the\n appropriate end of the active range to the end of the array. Then, loop from\n the opposite end of the array to the opposite end of the active range.\n *)\n match dir with\n | `front_to_back ->\n if actual_front <= actual_back\n then (\n let acc, _ =\n loop\n init\n ~apparent_i:apparent_front\n ~real_i:actual_front\n ~stop_pos:(actual_back + 1)\n ~step:1\n in\n acc)\n else (\n let acc, apparent_i =\n loop\n init\n ~apparent_i:apparent_front\n ~real_i:actual_front\n ~stop_pos:t.arr_length\n ~step:1\n in\n let acc, _ =\n loop acc ~apparent_i ~real_i:0 ~stop_pos:(actual_back + 1) ~step:1\n in\n acc)\n | `back_to_front ->\n if actual_front <= actual_back\n then (\n let acc, _ =\n loop\n init\n ~apparent_i:apparent_back\n ~real_i:actual_back\n ~stop_pos:(actual_front - 1)\n ~step:(-1)\n in\n acc)\n else (\n let acc, apparent_i =\n loop\n init\n ~apparent_i:apparent_back\n ~real_i:actual_back\n ~stop_pos:(-1)\n ~step:(-1)\n in\n let acc, _ =\n loop\n acc\n ~apparent_i\n ~real_i:(t.arr_length - 1)\n ~stop_pos:(actual_front - 1)\n ~step:(-1)\n in\n acc))\n;;\n\nlet fold' t dir ~init ~f = foldi' t dir ~init ~f:(fun _ acc v -> f acc v)\nlet iteri' t dir ~f = foldi' t dir ~init:() ~f:(fun i () v -> f i v)\nlet iter' t dir ~f = foldi' t dir ~init:() ~f:(fun _ () v -> f v)\nlet fold t ~init ~f = fold' t `front_to_back ~init ~f\nlet foldi t ~init ~f = foldi' t `front_to_back ~init ~f\nlet iteri t ~f = iteri' t `front_to_back ~f\n\nlet iteri_internal t ~f =\n if not (is_empty t)\n then (\n let actual_front = actual_front_index_when_not_empty t in\n let actual_back = actual_back_index_when_not_empty t in\n let rec loop ~real_i ~stop_pos =\n if real_i < stop_pos\n then (\n f t.arr real_i;\n loop ~real_i:(real_i + 1) ~stop_pos)\n in\n if actual_front <= actual_back\n then loop ~real_i:actual_front ~stop_pos:(actual_back + 1)\n else (\n loop ~real_i:actual_front ~stop_pos:t.arr_length;\n loop ~real_i:0 ~stop_pos:(actual_back + 1)))\n;;\n\nlet iter t ~f = iteri_internal t ~f:(fun arr i -> Option_array.get_some_exn arr i |> f)\n\nlet clear t =\n if t.never_shrink\n then\n (* clear the array to allow elements to be garbage collected *)\n iteri_internal t ~f:Option_array.unsafe_set_none\n else t.arr <- Option_array.create ~len:8;\n t.front_index <- 0;\n t.back_index <- 1;\n t.length <- 0;\n t.arr_length <- Option_array.length t.arr\n;;\n\n(* We have to be careful here, importing all of Container.Make would change the runtime of\n some functions ([length] minimally) silently without changing the semantics. We get\n around that by importing things explicitly. *)\nmodule C = Container.Make (struct\n type nonrec 'a t = 'a t\n\n let fold = fold\n let iter = `Custom iter\n let length = `Custom length\n end)\n\nlet count = C.count\nlet sum = C.sum\nlet exists = C.exists\nlet mem = C.mem\nlet for_all = C.for_all\nlet find_map = C.find_map\nlet find = C.find\nlet to_list = C.to_list\nlet min_elt = C.min_elt\nlet max_elt = C.max_elt\nlet fold_result = C.fold_result\nlet fold_until = C.fold_until\n\nlet blit new_arr t =\n assert (not (is_empty t));\n let actual_front = actual_front_index_when_not_empty t in\n let actual_back = actual_back_index_when_not_empty t in\n let old_arr = t.arr in\n if actual_front <= actual_back\n then\n Option_array.blit\n ~src:old_arr\n ~dst:new_arr\n ~src_pos:actual_front\n ~dst_pos:0\n ~len:(length t)\n else (\n let break_pos = Option_array.length old_arr - actual_front in\n Option_array.blit\n ~src:old_arr\n ~dst:new_arr\n ~src_pos:actual_front\n ~dst_pos:0\n ~len:break_pos;\n Option_array.blit\n ~src:old_arr\n ~dst:new_arr\n ~src_pos:0\n ~dst_pos:break_pos\n ~len:(actual_back + 1));\n (* length depends on t.arr and t.front_index, so this needs to be first *)\n t.back_index <- length t;\n t.arr <- new_arr;\n t.arr_length <- Option_array.length new_arr;\n t.front_index <- Option_array.length new_arr - 1;\n (* Since t.front_index = Option_array.length new_arr - 1, this is asserting that t.back_index\n is a valid index in the array and that the array can support at least one more\n element -- recall, if t.front_index = t.back_index then the array is full.\n\n Note that this is true if and only if Option_array.length new_arr > length t + 1.\n *)\n assert (t.front_index > t.back_index)\n;;\n\nlet maybe_shrink_underlying t =\n if (not t.never_shrink) && t.arr_length > 10 && t.arr_length / 3 > length t\n then (\n let new_arr = Option_array.create ~len:(t.arr_length / 2) in\n blit new_arr t)\n;;\n\nlet grow_underlying t =\n let new_arr = Option_array.create ~len:(t.arr_length * 2) in\n blit new_arr t\n;;\n\nlet enqueue_back t v =\n if t.front_index = t.back_index then grow_underlying t;\n Option_array.set_some t.arr t.back_index v;\n t.back_index <- (if t.back_index = t.arr_length - 1 then 0 else t.back_index + 1);\n t.length <- t.length + 1\n;;\n\nlet enqueue_front t v =\n if t.front_index = t.back_index then grow_underlying t;\n Option_array.set_some t.arr t.front_index v;\n t.front_index <- (if t.front_index = 0 then t.arr_length - 1 else t.front_index - 1);\n t.apparent_front_index <- t.apparent_front_index - 1;\n t.length <- t.length + 1\n;;\n\nlet enqueue t back_or_front v =\n match back_or_front with\n | `back -> enqueue_back t v\n | `front -> enqueue_front t v\n;;\n\nlet peek_front_nonempty t =\n Option_array.get_some_exn t.arr (actual_front_index_when_not_empty t)\n;;\n\nlet peek_front_exn t =\n if is_empty t\n then failwith \"Deque.peek_front_exn passed an empty queue\"\n else peek_front_nonempty t\n;;\n\nlet peek_front t = if is_empty t then None else Some (peek_front_nonempty t)\n\nlet peek_back_nonempty t =\n Option_array.get_some_exn t.arr (actual_back_index_when_not_empty t)\n;;\n\nlet peek_back_exn t =\n if is_empty t\n then failwith \"Deque.peek_back_exn passed an empty queue\"\n else peek_back_nonempty t\n;;\n\nlet peek_back t = if is_empty t then None else Some (peek_back_nonempty t)\n\nlet peek t back_or_front =\n match back_or_front with\n | `back -> peek_back t\n | `front -> peek_front t\n;;\n\nlet dequeue_front_nonempty t =\n let i = actual_front_index_when_not_empty t in\n let res = Option_array.get_some_exn t.arr i in\n Option_array.set_none t.arr i;\n t.front_index <- i;\n t.apparent_front_index <- t.apparent_front_index + 1;\n t.length <- t.length - 1;\n maybe_shrink_underlying t;\n res\n;;\n\nlet dequeue_front_exn t =\n if is_empty t\n then failwith \"Deque.dequeue_front_exn passed an empty queue\"\n else dequeue_front_nonempty t\n;;\n\nlet dequeue_front t = if is_empty t then None else Some (dequeue_front_nonempty t)\n\nlet dequeue_back_nonempty t =\n let i = actual_back_index_when_not_empty t in\n let res = Option_array.get_some_exn t.arr i in\n Option_array.set_none t.arr i;\n t.back_index <- i;\n t.length <- t.length - 1;\n maybe_shrink_underlying t;\n res\n;;\n\nlet dequeue_back_exn t =\n if is_empty t\n then failwith \"Deque.dequeue_back_exn passed an empty queue\"\n else dequeue_back_nonempty t\n;;\n\nlet dequeue_back t = if is_empty t then None else Some (dequeue_back_nonempty t)\n\nlet dequeue_exn t back_or_front =\n match back_or_front with\n | `front -> dequeue_front_exn t\n | `back -> dequeue_back_exn t\n;;\n\nlet dequeue t back_or_front =\n match back_or_front with\n | `front -> dequeue_front t\n | `back -> dequeue_back t\n;;\n\nlet drop_gen ?(n = 1) ~dequeue t =\n if n < 0 then invalid_argf \"Deque.drop: negative input (%d)\" n ();\n let rec loop n =\n if n > 0\n then (\n match dequeue t with\n | None -> ()\n | Some _ -> loop (n - 1))\n in\n loop n\n;;\n\nlet drop_front ?n t = drop_gen ?n ~dequeue:dequeue_front t\nlet drop_back ?n t = drop_gen ?n ~dequeue:dequeue_back t\n\nlet drop ?n t back_or_front =\n match back_or_front with\n | `back -> drop_back ?n t\n | `front -> drop_front ?n t\n;;\n\nlet assert_not_empty t name = if is_empty t then failwithf \"%s: Deque.t is empty\" name ()\n\nlet true_index_exn t i =\n let i_from_zero = i - t.apparent_front_index in\n if i_from_zero < 0 || length t <= i_from_zero\n then (\n assert_not_empty t \"Deque.true_index_exn\";\n let apparent_front = apparent_front_index_when_not_empty t in\n let apparent_back = apparent_back_index_when_not_empty t in\n invalid_argf\n \"invalid index: %i for array with indices (%i,%i)\"\n i\n apparent_front\n apparent_back\n ());\n let true_i = t.front_index + 1 + i_from_zero in\n if true_i >= t.arr_length then true_i - t.arr_length else true_i\n;;\n\nlet get t i = Option_array.get_some_exn t.arr (true_index_exn t i)\n\nlet get_opt t i =\n try Some (get t i) with\n | _ -> None\n;;\n\nlet set_exn t i v = Option_array.set_some t.arr (true_index_exn t i) v\n\nlet to_array t =\n match peek_front t with\n | None -> [||]\n | Some front ->\n let arr = Array.create ~len:(length t) front in\n ignore\n (fold t ~init:0 ~f:(fun i v ->\n arr.(i) <- v;\n i + 1)\n : int);\n arr\n;;\n\nlet of_array arr =\n let t = create ~initial_length:(Array.length arr + 1) () in\n Array.iter arr ~f:(fun v -> enqueue_back t v);\n t\n;;\n\ninclude Bin_prot.Utils.Make_iterable_binable1 (struct\n type nonrec 'a t = 'a t\n type 'a el = 'a [@@deriving bin_io]\n\n let caller_identity =\n Bin_prot.Shape.Uuid.of_string \"34c1e9ca-4992-11e6-a686-8b4bd4f87796\"\n ;;\n\n let module_name = Some \"Core_kernel.Deque\"\n let length = length\n let iter t ~f = iter t ~f\n\n let init ~len ~next =\n let t = create ~initial_length:len () in\n for _i = 0 to len - 1 do\n let x = next () in\n enqueue_back t x\n done;\n t\n ;;\n end)\n\nlet t_of_sexp f sexp = of_array (Array.t_of_sexp f sexp)\nlet sexp_of_t f t = Array.sexp_of_t f (to_array t)\n\n(* re-expose these here under a different name to avoid internal confusion *)\nlet back_index = apparent_back_index\nlet front_index = apparent_front_index\n\nlet back_index_exn t =\n assert_not_empty t \"Deque.back_index_exn\";\n apparent_back_index_when_not_empty t\n;;\n\nlet front_index_exn t =\n assert_not_empty t \"Deque.front_index_exn\";\n apparent_front_index_when_not_empty t\n;;\n\nmodule Binary_searchable = Test_binary_searchable.Make1_and_test (struct\n type nonrec 'a t = 'a t\n\n let get t i = get t (front_index_exn t + i)\n let length = length\n\n module For_test = struct\n let of_array = of_array\n end\n end)\n\n(* The \"stable\" indices used in this module make the application of the\n [Binary_searchable] functor awkward. We need to be sure to translate incoming\n positions from stable space to the expected 0 -> length - 1 space and then we need to\n translate them back on return. *)\nlet binary_search ?pos ?len t ~compare how v =\n let pos =\n match pos with\n | None -> None\n | Some pos -> Some (pos - t.apparent_front_index)\n in\n match Binary_searchable.binary_search ?pos ?len t ~compare how v with\n | None -> None\n | Some untranslated_i -> Some (t.apparent_front_index + untranslated_i)\n;;\n\nlet binary_search_segmented ?pos ?len t ~segment_of how =\n let pos =\n match pos with\n | None -> None\n | Some pos -> Some (pos - t.apparent_front_index)\n in\n match Binary_searchable.binary_search_segmented ?pos ?len t ~segment_of how with\n | None -> None\n | Some untranslated_i -> Some (t.apparent_front_index + untranslated_i)\n;;\n","open! Import\nmodule List = Base.List\nmodule String = Base.String\n\nlet eprint message = Printf.eprintf \"%s\\n%!\" message\nlet eprint_s sexp = eprint (Sexp.to_string_hum sexp)\nlet eprints message a sexp_of_a = eprint_s ([%sexp_of: string * a] (message, a))\nlet eprintf format = Printf.ksprintf eprint format\nlet failwiths = Error.failwiths\n\nmodule Make () = struct\n let check_invariant = ref true\n let show_messages = ref true\n\n let debug invariant ~module_name name ts arg sexp_of_arg sexp_of_result f =\n if !show_messages\n then eprints (String.concat ~sep:\"\" [ module_name; \".\"; name ]) arg sexp_of_arg;\n if !check_invariant\n then (\n try List.iter ts ~f:invariant with\n | exn ->\n failwiths\n ~here:[%here]\n \"invariant pre-condition failed\"\n (name, exn)\n [%sexp_of: string * exn]);\n let result_or_exn = Result.try_with f in\n if !check_invariant\n then (\n try List.iter ts ~f:invariant with\n | exn ->\n failwiths\n ~here:[%here]\n \"invariant post-condition failed\"\n (name, exn)\n [%sexp_of: string * exn]);\n if !show_messages\n then\n eprints\n (String.concat ~sep:\"\" [ module_name; \".\"; name; \"-result\" ])\n result_or_exn\n [%sexp_of: (result, exn) Result.t];\n Result.ok_exn result_or_exn\n ;;\nend\n\nlet should_print_backtrace = ref false\n\nlet am_internal here message =\n (* In this function we use [Printf.eprintf] rather than [Debug.eprintf], because the\n former doesn't flush, while the latter does. We'd rather flush once at the end,\n rather than three times. *)\n Printf.eprintf \"%s:\\n\" (Source_code_position.to_string here);\n if !should_print_backtrace\n then\n Printf.eprintf\n \"%s\\n\"\n (Backtrace.get () |> [%sexp_of: Backtrace.t] |> Sexp.to_string_hum);\n (match message with\n | None -> ()\n | Some message -> Printf.eprintf \"%s\\n\" message);\n Printf.eprintf \"%!\"\n;;\n\nlet am here = am_internal here None\nlet amf here fmt = Printf.ksprintf (fun string -> am_internal here (Some string)) fmt\n\nlet ams here message a sexp_of_a =\n am_internal here (Some ((message, a) |> [%sexp_of: string * a] |> Sexp.to_string_hum))\n;;\n","(** Imperative set-like data structure.\n\n There are a few differences from simple sets:\n\n - Duplicates are allowed.\n - It doesn't require anything (hashable, comparable) of elements in the bag.\n - Addition and removal are constant time operations.\n\n It is an error to modify a bag ([add], [remove], [remove_one], ...) during iteration\n ([fold], [iter], ...). *)\n\nopen! Import\n\nmodule type S = sig\n module Elt : sig\n type 'a t\n\n val equal : 'a t -> 'a t -> bool\n val sexp_of_t : ('a -> Sexp.t) -> 'a t -> Sexp.t\n val value : 'a t -> 'a\n end\n\n type 'a t [@@deriving sexp]\n\n (** Much of a bag's interface comes from the generic {!Base.Container} module. *)\n include\n Container.S1 with type 'a t := 'a t\n\n include Invariant.S1 with type 'a t := 'a t\n\n (** [create ()] returns an empty bag. *)\n val create : unit -> 'a t\n\n (** [add t v] adds [v] to the bag [t], returning an element that can\n later be removed from the bag. [add] runs in constant time. *)\n val add : 'a t -> 'a -> 'a Elt.t\n\n val add_unit : 'a t -> 'a -> unit\n\n (** [mem_elt t elt] returns whether or not [elt] is in [t]. It is like [mem] (included\n from [Container]), but it takes an ['a Elt.t] instead of an ['a] and runs in constant\n time instead of linear time. *)\n val mem_elt : 'a t -> 'a Elt.t -> bool\n\n (** [remove t elt] removes [elt] from the bag [t], raising an exception if [elt]\n is not in the bag. [remove] runs in constant time. *)\n val remove : 'a t -> 'a Elt.t -> unit\n\n (** [choose t] returns some element in the bag. *)\n val choose : 'a t -> 'a Elt.t option\n\n (** [remove_one t] removes some element from the bag, and returns its value.\n [remove_one] runs in constant time. *)\n val remove_one : 'a t -> 'a option\n\n (** [clear t] removes all elements from the bag. [clear] runs in constant time. *)\n val clear : 'a t -> unit\n\n (** [filter_inplace t ~f] removes all the elements from [t] that don't satisfy [f]. *)\n val filter_inplace : 'a t -> f:('a -> bool) -> unit\n\n val iter_elt : 'a t -> f:('a Elt.t -> unit) -> unit\n\n (** [find_elt t ~f] returns the first element in the bag satisfying [f], returning [None]\n if none is found. *)\n val find_elt : 'a t -> f:('a -> bool) -> 'a Elt.t option\n\n (** [until_empty t f] repeatedly removes values [v] from [t], running [f v] on each one,\n until [t] is empty. Running [f] may add elements to [t] if it wants. *)\n val until_empty : 'a t -> ('a -> unit) -> unit\n\n (** [transfer ~src ~dst] moves all of the elements from [src] to [dst] in constant\n time. *)\n val transfer : src:'a t -> dst:'a t -> unit\n\n val of_list : 'a list -> 'a t\n val elts : 'a t -> 'a Elt.t list\n\n (** [unchecked_iter t ~f] behaves like [iter t ~f] except that [f] is allowed to modify\n [t]. Elements added by [f] may or may not be visited; elements removed by [f] that\n have not been visited will not be visited. It is an (undetected) error to delete the\n current element. *)\n val unchecked_iter : 'a t -> f:('a -> unit) -> unit\nend\n\nmodule type Bag = sig\n (** The module type of the Bag module.\n\n Example usage:\n {[\n module My_bag : Bag.S = Bag\n ]}\n\n Now [My_bag.Elt.t] can't be used with any other [Bag.t] type.\n *)\n module type S = S\n\n include S\nend\n","(*\n * Copyright (c) 2013 Jeremy Yallop.\n *\n * This file is distributed under the terms of the MIT License.\n * See the file LICENSE for details.\n *)\n\nmodule Pervasives = Pervasives [@@ocaml.warning \"-3\"]\n\nexternal init : unit -> unit = \"integers_unsigned_init\"\nlet () = init ()\n\n(* Boxed unsigned types *)\nmodule type Basics = sig\n type t\n\n val add : t -> t -> t\n val sub : t -> t -> t\n val mul : t -> t -> t\n val div : t -> t -> t\n val rem : t -> t -> t\n val max_int : t\n val logand : t -> t -> t\n val logor : t -> t -> t\n val logxor : t -> t -> t\n val shift_left : t -> int -> t\n val shift_right : t -> int -> t\n val of_int : int -> t\n val to_int : t -> int\n val of_int64 : int64 -> t\n val to_int64 : t -> int64\n val of_string : string -> t\n val to_string : t -> string\nend\n\n\nmodule type Extras = sig\n type t\n\n val zero : t\n val one : t\n val lognot : t -> t\n val succ : t -> t\n val pred : t -> t\n val compare : t -> t -> int\n val equal : t -> t -> bool\n val max : t -> t -> t\n val min : t -> t -> t\n val pp : Format.formatter -> t -> unit\nend\n\n\nmodule type Infix = sig\n type t\n val (+) : t -> t -> t\n val (-) : t -> t -> t\n val ( * ) : t -> t -> t\n val (/) : t -> t -> t\n val (mod) : t -> t -> t\n val (land) : t -> t -> t\n val (lor) : t -> t -> t\n val (lxor) : t -> t -> t\n val (lsl) : t -> int -> t\n val (lsr) : t -> int -> t\nend\n\n\nmodule type S = sig\n include Basics\n include Extras with type t := t\n\n module Infix : Infix with type t := t\nend\n\n\nmodule MakeInfix (B : Basics) =\nstruct\n open B\n let (+) = add\n let (-) = sub\n let ( * ) = mul\n let (/) = div\n let (mod) = rem\n let (land) = logand\n let (lor) = logor\n let (lxor) = logxor\n let (lsl) = shift_left\n let (lsr) = shift_right\nend\n\n\nmodule Extras(Basics : Basics) : Extras with type t := Basics.t =\nstruct\n open Basics\n let zero = of_int 0\n let one = of_int 1\n let succ n = add n one\n let pred n = sub n one\n let lognot n = logxor n max_int\n let compare (x : t) (y : t) = Pervasives.compare x y\n let equal (x : t) (y : t) = Pervasives.(=) x y\n let max (x : t) (y : t) = Pervasives.max x y\n let min (x : t) (y : t) = Pervasives.min x y\n let pp fmt x = Format.fprintf fmt \"%s\" (to_string x)\nend\n\n\nmodule UInt8 : S with type t = private int =\nstruct\n module B =\n struct\n type t = int\n let max_int = 255\n let add : t -> t -> t = fun x y -> (x + y) land max_int\n let sub : t -> t -> t = fun x y -> (x - y) land max_int\n let mul : t -> t -> t = fun x y -> (x * y) land max_int\n let div : t -> t -> t = (/)\n let rem : t -> t -> t = (mod)\n let logand: t -> t -> t = (land)\n let logor: t -> t -> t = (lor)\n let logxor : t -> t -> t = (lxor)\n let shift_left : t -> int -> t = fun x y -> (x lsl y) land max_int\n let shift_right : t -> int -> t = (lsr)\n let of_int (x: int): t =\n (* For backwards compatibility, this wraps *)\n x land max_int\n external to_int : t -> int = \"%identity\"\n let of_int64 : int64 -> t = fun x -> of_int (Int64.to_int x)\n let to_int64 : t -> int64 = fun x -> Int64.of_int (to_int x)\n external of_string : string -> t = \"integers_uint8_of_string\"\n let to_string : t -> string = string_of_int\n end\n include B\n include Extras(B)\n module Infix = MakeInfix(B)\nend\n\n\nmodule UInt16 : S with type t = private int =\nstruct\n module B =\n struct\n type t = int\n let max_int = 65535\n let add : t -> t -> t = fun x y -> (x + y) land max_int\n let sub : t -> t -> t = fun x y -> (x - y) land max_int\n let mul : t -> t -> t = fun x y -> (x * y) land max_int\n let div : t -> t -> t = (/)\n let rem : t -> t -> t = (mod)\n let logand: t -> t -> t = (land)\n let logor: t -> t -> t = (lor)\n let logxor : t -> t -> t = (lxor)\n let shift_left : t -> int -> t = fun x y -> (x lsl y) land max_int\n let shift_right : t -> int -> t = (lsr)\n let of_int (x: int): t =\n (* For backwards compatibility, this wraps *)\n x land max_int\n external to_int : t -> int = \"%identity\"\n let of_int64 : int64 -> t = fun x -> Int64.to_int x |> of_int\n let to_int64 : t -> int64 = fun x -> to_int x |> Int64.of_int\n external of_string : string -> t = \"integers_uint16_of_string\"\n let to_string : t -> string = string_of_int\n end\n include B\n include Extras(B)\n module Infix = MakeInfix(B)\nend\n\n\nmodule UInt32 : sig\n include S\n external of_int32 : int32 -> t = \"integers_uint32_of_int32\"\n external to_int32 : t -> int32 = \"integers_int32_of_uint32\"\nend = \nstruct\n module B =\n struct\n type t\n external add : t -> t -> t = \"integers_uint32_add\"\n external sub : t -> t -> t = \"integers_uint32_sub\"\n external mul : t -> t -> t = \"integers_uint32_mul\"\n external div : t -> t -> t = \"integers_uint32_div\"\n external rem : t -> t -> t = \"integers_uint32_rem\"\n external logand : t -> t -> t = \"integers_uint32_logand\"\n external logor : t -> t -> t = \"integers_uint32_logor\"\n external logxor : t -> t -> t = \"integers_uint32_logxor\"\n external shift_left : t -> int -> t = \"integers_uint32_shift_left\"\n external shift_right : t -> int -> t = \"integers_uint32_shift_right\"\n external of_int : int -> t = \"integers_uint32_of_int\"\n external to_int : t -> int = \"integers_uint32_to_int\"\n external of_int64 : int64 -> t = \"integers_uint32_of_int64\"\n external to_int64 : t -> int64 = \"integers_uint32_to_int64\"\n external of_string : string -> t = \"integers_uint32_of_string\"\n external to_string : t -> string = \"integers_uint32_to_string\"\n external _max_int : unit -> t = \"integers_uint32_max\"\n let max_int = _max_int ()\n end\n include B\n include Extras(B)\n module Infix = MakeInfix(B)\n external of_int32 : int32 -> t = \"integers_uint32_of_int32\"\n external to_int32 : t -> int32 = \"integers_int32_of_uint32\"\nend\n\n\nmodule UInt64 : sig\n include S\n external of_int64 : int64 -> t = \"integers_uint64_of_int64\"\n external to_int64 : t -> int64 = \"integers_uint64_to_int64\"\n external of_uint32 : UInt32.t -> t = \"integers_uint64_of_uint32\"\n external to_uint32 : t -> UInt32.t = \"integers_uint32_of_uint64\"\nend = \nstruct\n module B =\n struct\n type t\n external add : t -> t -> t = \"integers_uint64_add\"\n external sub : t -> t -> t = \"integers_uint64_sub\"\n external mul : t -> t -> t = \"integers_uint64_mul\"\n external div : t -> t -> t = \"integers_uint64_div\"\n external rem : t -> t -> t = \"integers_uint64_rem\"\n external logand : t -> t -> t = \"integers_uint64_logand\"\n external logor : t -> t -> t = \"integers_uint64_logor\"\n external logxor : t -> t -> t = \"integers_uint64_logxor\"\n external shift_left : t -> int -> t = \"integers_uint64_shift_left\"\n external shift_right : t -> int -> t = \"integers_uint64_shift_right\"\n external of_int : int -> t = \"integers_uint64_of_int\"\n external to_int : t -> int = \"integers_uint64_to_int\"\n external of_int64 : int64 -> t = \"integers_uint64_of_int64\"\n external to_int64 : t -> int64 = \"integers_uint64_to_int64\"\n external of_uint32 : UInt32.t -> t = \"integers_uint64_of_uint32\"\n external to_uint32 : t -> UInt32.t = \"integers_uint32_of_uint64\"\n external of_string : string -> t = \"integers_uint64_of_string\"\n external to_string : t -> string = \"integers_uint64_to_string\"\n external _max_int : unit -> t = \"integers_uint64_max\"\n let max_int = _max_int ()\n end\n include B\n include Extras(B)\n module Infix = MakeInfix(B)\nend\n\n\nlet of_byte_size : int -> (module S) = function\n | 1 -> (module UInt8)\n | 2 -> (module UInt16)\n | 4 -> (module UInt32)\n | 8 -> (module UInt64)\n | _ -> invalid_arg \"Unsigned.of_byte_size\"\n\n \nexternal size_t_size : unit -> int = \"integers_size_t_size\"\nexternal ushort_size : unit -> int = \"integers_ushort_size\"\nexternal uint_size : unit -> int = \"integers_uint_size\"\nexternal ulong_size : unit -> int = \"integers_ulong_size\"\nexternal ulonglong_size : unit -> int = \"integers_ulonglong_size\"\n\nmodule Size_t : S = (val of_byte_size (size_t_size ()))\nmodule UChar = UInt8\nmodule UShort : S = (val of_byte_size (ushort_size ()))\nmodule UInt : S = (val of_byte_size (uint_size ()))\nmodule ULong : S = (val of_byte_size (ulong_size ()))\nmodule ULLong : S = (val of_byte_size (ulonglong_size ()))\n\ntype uchar = UChar.t\ntype uint8 = UInt8.t\ntype uint16 = UInt16.t\ntype uint32 = UInt32.t\ntype uint64 = UInt64.t\ntype size_t = Size_t.t\ntype ushort = UShort.t\ntype uint = UInt.t\ntype ulong = ULong.t\ntype ullong = ULLong.t\n","exception Error of string\n\nlet error s = raise (Error s)\n\n\n(*\n Debugging utilities.\n*)\n\nlet string8_of_int x =\n let s = Bytes.create 8 in\n for i = 0 to 7 do\n Bytes.set s (7-i) (Char.chr (0xff land (x lsr (8 * i))))\n done;\n Bytes.to_string s\n\nlet string4_of_int x =\n let s = Bytes.create 4 in\n for i = 0 to 3 do\n Bytes.set s (3-i) (Char.chr (0xff land (x lsr (8 * i))))\n done;\n Bytes.to_string s\n\nlet print_bits ?(pos = 0) ?len s =\n let slen = String.length s in\n if pos < 0 || (pos > 0 && pos >= slen) then\n invalid_arg \"Bi_util.print_bits\";\n let len =\n match len with\n None -> slen - pos\n | Some len ->\n if len > slen - pos then invalid_arg \"Bi_util.print_bits\"\n else len\n in\n\n let r = Bytes.create (len * 9) in\n for i = 0 to len - 1 do\n let k = i * 9 in\n let x = Char.code s.[pos+i] in\n for j = 0 to 7 do\n Bytes.set r (k+j) (if (x lsr (7 - j)) land 1 = 0 then '0' else '1')\n done;\n Bytes.set r (k+8) (if (i + 1) mod 8 = 0 then '\\n' else ' ')\n done;\n Bytes.to_string r\n\n(* int size in bits *)\nlet int_size =\n let c = ref 0 in\n let r = ref (-1) in\n while !r <> 0 do\n r := !r lsr 1;\n incr c\n done;\n !c\n","type t = {\n mutable o_s : bytes;\n mutable o_max_len : int;\n mutable o_len : int;\n mutable o_offs : int;\n o_init_len : int;\n o_make_room : (t -> int -> unit);\n mutable o_shared : Bi_share.Wr.tbl;\n o_shared_init_len : int;\n}\n\nlet really_extend b n =\n let slen0 = b.o_max_len in\n let reqlen = b.o_len + n in\n let slen =\n let x = max reqlen (2 * slen0) in\n if x <= Sys.max_string_length then x\n else\n if Sys.max_string_length < reqlen then\n\tinvalid_arg \"Buf.extend: reached Sys.max_string_length\"\n else\n\tSys.max_string_length\n in\n let s = Bytes.create slen in\n Bytes.blit b.o_s 0 s 0 b.o_len;\n b.o_s <- s;\n b.o_max_len <- slen\n\nlet flush_to_output abstract_output b n =\n abstract_output (Bytes.to_string b.o_s) 0 b.o_len;\n b.o_offs <- b.o_offs + b.o_len;\n b.o_len <- 0;\n if n > b.o_max_len then\n really_extend b n\n\nlet flush_to_channel oc = flush_to_output (output_substring oc)\n\n\nlet create ?(make_room = really_extend) ?(shrlen = 16) n = {\n o_s = Bytes.create n;\n o_max_len = n;\n o_len = 0;\n o_offs = 0;\n o_init_len = n;\n o_make_room = make_room;\n o_shared = Bi_share.Wr.create shrlen;\n o_shared_init_len = shrlen;\n}\n\nlet create_channel_writer ?(len = 4096) ?shrlen oc =\n create ~make_room:(flush_to_channel oc) ?shrlen len\n\nlet flush_channel_writer b =\n b.o_make_room b 0\n\nlet create_output_writer ?(len = 4096) ?shrlen out =\n create ~make_room:(flush_to_output out#output) ?shrlen len\n\nlet flush_output_writer = flush_channel_writer\n\n\n(*\n Guarantee that the buffer string has enough room for n additional bytes.\n*)\nlet extend b n =\n if b.o_len + n > b.o_max_len then\n b.o_make_room b n\n\nlet alloc b n =\n extend b n;\n let pos = b.o_len in\n b.o_len <- pos + n;\n pos\n\nlet add_sub blit b s pos len =\n extend b len;\n blit s pos b.o_s b.o_len len;\n b.o_len <- b.o_len + len\n\nlet add_substring = add_sub String.blit\nlet add_subbytes = add_sub Bytes.blit\n\nlet add_string b s =\n add_substring b s 0 (String.length s)\n\nlet add_bytes b s =\n add_subbytes b s 0 (Bytes.length s)\n\n\nlet add_char b c =\n let pos = alloc b 1 in\n Bytes.set b.o_s pos c\n\nlet unsafe_add_char b c =\n let len = b.o_len in\n Bytes.set b.o_s len c;\n b.o_len <- len + 1\n\nlet add_char2 b c1 c2 =\n let pos = alloc b 2 in\n let s = b.o_s in\n Bytes.unsafe_set s pos c1;\n Bytes.unsafe_set s (pos+1) c2\n\nlet add_char4 b c1 c2 c3 c4 =\n let pos = alloc b 4 in\n let s = b.o_s in\n Bytes.unsafe_set s pos c1;\n Bytes.unsafe_set s (pos+1) c2;\n Bytes.unsafe_set s (pos+2) c3;\n Bytes.unsafe_set s (pos+3) c4\n\n\n\nlet clear b =\n b.o_offs <- 0;\n b.o_len <- 0;\n Bi_share.Wr.clear b.o_shared\n\nlet reset b =\n if Bytes.length b.o_s <> b.o_init_len then\n b.o_s <- Bytes.create b.o_init_len;\n b.o_offs <- 0;\n b.o_len <- 0;\n b.o_shared <- Bi_share.Wr.create b.o_shared_init_len\n\nlet contents b = Bytes.sub_string b.o_s 0 b.o_len\n","type type_id = int\n\nlet dummy_type_id = 0\n\nlet create_type_id =\n let n = ref dummy_type_id in\n fun () ->\n incr n;\n if !n < 0 then\n failwith \"Bi_share.Rd_poly.create_type_id: \\\n exhausted available type_id's\"\n else\n !n\n\nmodule Wr =\nstruct\n module H = Hashtbl.Make (\n struct\n type t = Obj.t * type_id\n let equal (x1, t1) (x2, t2) = x1 == x2 && t1 == t2\n let hash = Hashtbl.hash\n end\n )\n\n type tbl = int H.t\n\n let create = H.create\n let clear tbl =\n if H.length tbl > 0 then\n H.clear tbl\n\n let put tbl k pos =\n try\n let pos0 = H.find tbl (Obj.magic k) in\n pos - pos0\n with Not_found ->\n H.add tbl (Obj.magic k) pos;\n 0\nend\n\nmodule Rd =\nstruct\n type tbl = ((int * type_id), Obj.t) Hashtbl.t\n\n let create n = Hashtbl.create n\n let clear = Hashtbl.clear\n\n let put tbl pos x =\n Hashtbl.add tbl pos x\n\n let get tbl pos =\n try Hashtbl.find tbl pos\n with Not_found ->\n Bi_util.error \"Corrupted data (invalid reference)\"\nend\n","include Ppx_deriving_runtime\n\nlet (>>=) x f =\n match x with Result.Ok x -> f x | (Result.Error _) as x -> x\n\nlet (>|=) x f =\n x >>= fun x -> Result.Ok (f x)\n\nlet rec map_bind f acc xs =\n match xs with\n | x :: xs -> f x >>= fun x -> map_bind f (x :: acc) xs\n | [] -> Result.Ok (List.rev acc)\n\ntype 'a error_or = ('a, string) Result.result\n\n(** [safe_map f l] returns the same value as [List.map f l], but\n computes it tail-recursively so that large list lengths don't\n cause a stack overflow *)\nlet safe_map f l = List.rev (List.rev_map f l)\n","(* This file is generated automatically with ocaml_gen. *)\n\nmodule BigInt256 = struct\n type nonrec t\n\n external of_numeral : string -> int -> int -> t = \"caml_bigint_256_of_numeral\"\n\n external of_decimal_string : string -> t = \"caml_bigint_256_of_decimal_string\"\n\n external num_limbs : unit -> int = \"caml_bigint_256_num_limbs\"\n\n external bytes_per_limb : unit -> int = \"caml_bigint_256_bytes_per_limb\"\n\n external div : t -> t -> t = \"caml_bigint_256_div\"\n\n external compare : t -> t -> int = \"caml_bigint_256_compare\"\n\n external print : t -> unit = \"caml_bigint_256_print\"\n\n external to_string : t -> string = \"caml_bigint_256_to_string\"\n\n external test_bit : t -> int -> bool = \"caml_bigint_256_test_bit\"\n\n external to_bytes : t -> bytes = \"caml_bigint_256_to_bytes\"\n\n external of_bytes : bytes -> t = \"caml_bigint_256_of_bytes\"\n\n external deep_copy : t -> t = \"caml_bigint_256_deep_copy\"\nend\n\nmodule Fp = struct\n type nonrec t\n\n external size_in_bits : unit -> int = \"caml_pasta_fp_size_in_bits\"\n\n external size : unit -> BigInt256.t = \"caml_pasta_fp_size\"\n\n external add : t -> t -> t = \"caml_pasta_fp_add\"\n\n external sub : t -> t -> t = \"caml_pasta_fp_sub\"\n\n external negate : t -> t = \"caml_pasta_fp_negate\"\n\n external mul : t -> t -> t = \"caml_pasta_fp_mul\"\n\n external div : t -> t -> t = \"caml_pasta_fp_div\"\n\n external inv : t -> t option = \"caml_pasta_fp_inv\"\n\n external square : t -> t = \"caml_pasta_fp_square\"\n\n external is_square : t -> bool = \"caml_pasta_fp_is_square\"\n\n external sqrt : t -> t option = \"caml_pasta_fp_sqrt\"\n\n external of_int : int -> t = \"caml_pasta_fp_of_int\"\n\n external to_string : t -> string = \"caml_pasta_fp_to_string\"\n\n external of_string : string -> t = \"caml_pasta_fp_of_string\"\n\n external print : t -> unit = \"caml_pasta_fp_print\"\n\n external copy : t -> t -> unit = \"caml_pasta_fp_copy\"\n\n external mut_add : t -> t -> unit = \"caml_pasta_fp_mut_add\"\n\n external mut_sub : t -> t -> unit = \"caml_pasta_fp_mut_sub\"\n\n external mut_mul : t -> t -> unit = \"caml_pasta_fp_mut_mul\"\n\n external mut_square : t -> unit = \"caml_pasta_fp_mut_square\"\n\n external compare : t -> t -> int = \"caml_pasta_fp_compare\"\n\n external equal : t -> t -> bool = \"caml_pasta_fp_equal\"\n\n external random : unit -> t = \"caml_pasta_fp_random\"\n\n external rng : int -> t = \"caml_pasta_fp_rng\"\n\n external to_bigint : t -> BigInt256.t = \"caml_pasta_fp_to_bigint\"\n\n external of_bigint : BigInt256.t -> t = \"caml_pasta_fp_of_bigint\"\n\n external two_adic_root_of_unity : unit -> t\n = \"caml_pasta_fp_two_adic_root_of_unity\"\n\n external domain_generator : int -> t = \"caml_pasta_fp_domain_generator\"\n\n external to_bytes : t -> bytes = \"caml_pasta_fp_to_bytes\"\n\n external of_bytes : bytes -> t = \"caml_pasta_fp_of_bytes\"\n\n external deep_copy : t -> t = \"caml_pasta_fp_deep_copy\"\nend\n\nmodule Fq = struct\n type nonrec t\n\n external size_in_bits : unit -> int = \"caml_pasta_fq_size_in_bits\"\n\n external size : unit -> BigInt256.t = \"caml_pasta_fq_size\"\n\n external add : t -> t -> t = \"caml_pasta_fq_add\"\n\n external sub : t -> t -> t = \"caml_pasta_fq_sub\"\n\n external negate : t -> t = \"caml_pasta_fq_negate\"\n\n external mul : t -> t -> t = \"caml_pasta_fq_mul\"\n\n external div : t -> t -> t = \"caml_pasta_fq_div\"\n\n external inv : t -> t option = \"caml_pasta_fq_inv\"\n\n external square : t -> t = \"caml_pasta_fq_square\"\n\n external is_square : t -> bool = \"caml_pasta_fq_is_square\"\n\n external sqrt : t -> t option = \"caml_pasta_fq_sqrt\"\n\n external of_int : int -> t = \"caml_pasta_fq_of_int\"\n\n external to_string : t -> string = \"caml_pasta_fq_to_string\"\n\n external of_string : string -> t = \"caml_pasta_fq_of_string\"\n\n external print : t -> unit = \"caml_pasta_fq_print\"\n\n external copy : t -> t -> unit = \"caml_pasta_fq_copy\"\n\n external mut_add : t -> t -> unit = \"caml_pasta_fq_mut_add\"\n\n external mut_sub : t -> t -> unit = \"caml_pasta_fq_mut_sub\"\n\n external mut_mul : t -> t -> unit = \"caml_pasta_fq_mut_mul\"\n\n external mut_square : t -> unit = \"caml_pasta_fq_mut_square\"\n\n external compare : t -> t -> int = \"caml_pasta_fq_compare\"\n\n external equal : t -> t -> bool = \"caml_pasta_fq_equal\"\n\n external random : unit -> t = \"caml_pasta_fq_random\"\n\n external rng : int -> t = \"caml_pasta_fq_rng\"\n\n external to_bigint : t -> BigInt256.t = \"caml_pasta_fq_to_bigint\"\n\n external of_bigint : BigInt256.t -> t = \"caml_pasta_fq_of_bigint\"\n\n external two_adic_root_of_unity : unit -> t\n = \"caml_pasta_fq_two_adic_root_of_unity\"\n\n external domain_generator : int -> t = \"caml_pasta_fq_domain_generator\"\n\n external to_bytes : t -> bytes = \"caml_pasta_fq_to_bytes\"\n\n external of_bytes : bytes -> t = \"caml_pasta_fq_of_bytes\"\n\n external deep_copy : t -> t = \"caml_pasta_fq_deep_copy\"\nend\n\nmodule Vesta = struct\n module BaseField = struct\n type nonrec t = Fq.t\n end\n\n module ScalarField = struct\n type nonrec t = Fp.t\n end\n\n module Affine = struct\n type nonrec t = Fq.t Kimchi_types.or_infinity\n end\n\n type nonrec t\n\n external one : unit -> t = \"caml_vesta_one\"\n\n external add : t -> t -> t = \"caml_vesta_add\"\n\n external sub : t -> t -> t = \"caml_vesta_sub\"\n\n external negate : t -> t = \"caml_vesta_negate\"\n\n external double : t -> t = \"caml_vesta_double\"\n\n external scale : t -> Fp.t -> t = \"caml_vesta_scale\"\n\n external random : unit -> t = \"caml_vesta_random\"\n\n external rng : int -> t = \"caml_vesta_rng\"\n\n external endo_base : unit -> Fq.t = \"caml_vesta_endo_base\"\n\n external endo_scalar : unit -> Fp.t = \"caml_vesta_endo_scalar\"\n\n external to_affine : t -> Fq.t Kimchi_types.or_infinity\n = \"caml_vesta_to_affine\"\n\n external of_affine : Fq.t Kimchi_types.or_infinity -> t\n = \"caml_vesta_of_affine\"\n\n external of_affine_coordinates : Fq.t -> Fq.t -> t\n = \"caml_vesta_of_affine_coordinates\"\n\n external deep_copy :\n Fq.t Kimchi_types.or_infinity -> Fq.t Kimchi_types.or_infinity\n = \"caml_vesta_affine_deep_copy\"\nend\n\nmodule Pallas = struct\n module BaseField = struct\n type nonrec t = Fp.t\n end\n\n module ScalarField = struct\n type nonrec t = Fq.t\n end\n\n module Affine = struct\n type nonrec t = Fp.t Kimchi_types.or_infinity\n end\n\n type nonrec t\n\n external one : unit -> t = \"caml_pallas_one\"\n\n external add : t -> t -> t = \"caml_pallas_add\"\n\n external sub : t -> t -> t = \"caml_pallas_sub\"\n\n external negate : t -> t = \"caml_pallas_negate\"\n\n external double : t -> t = \"caml_pallas_double\"\n\n external scale : t -> Fq.t -> t = \"caml_pallas_scale\"\n\n external random : unit -> t = \"caml_pallas_random\"\n\n external rng : int -> t = \"caml_pallas_rng\"\n\n external endo_base : unit -> Fp.t = \"caml_pallas_endo_base\"\n\n external endo_scalar : unit -> Fq.t = \"caml_pallas_endo_scalar\"\n\n external to_affine : t -> Fp.t Kimchi_types.or_infinity\n = \"caml_pallas_to_affine\"\n\n external of_affine : Fp.t Kimchi_types.or_infinity -> t\n = \"caml_pallas_of_affine\"\n\n external of_affine_coordinates : Fp.t -> Fp.t -> t\n = \"caml_pallas_of_affine_coordinates\"\n\n external deep_copy :\n Fp.t Kimchi_types.or_infinity -> Fp.t Kimchi_types.or_infinity\n = \"caml_pallas_affine_deep_copy\"\nend\n","open Core_kernel\n\ntype 'a t = 'a * 'a [@@deriving bin_io, sexp, eq, compare]\n\nlet map (x1, x2) ~f = (f x1, f x2)\n\nlet map2 (x1, x2) (y1, y2) ~f = (f x1 y1, f x2 y2)\n\nlet iter (x1, x2) ~f = f x1 ; f x2\n","open Core_kernel\n\nmodule type S = sig\n type 'a t [@@deriving bin_io, sexp, eq, compare]\n\n val iter : 'a t -> f:('a -> unit) -> unit\n\n val map : 'a t -> f:('a -> 'b) -> 'b t\n\n val map2 : 'a t -> 'b t -> f:('a -> 'b -> 'c) -> 'c t\nend\n","open Core_kernel\n\ntype t = Zero | One | Two | Three [@@deriving sexp, eq, bin_io, hash]\n\nlet of_bits_lsb : bool Double.t -> t = function\n | false, false ->\n Zero\n | true, false ->\n One\n | false, true ->\n Two\n | true, true ->\n Three\n","open Core_kernel\n\ntype 'a t = 'a * 'a * 'a * 'a [@@deriving bin_io, sexp, eq, compare]\n\nlet get ((x0, x1, x2, x3) : 'a t) (i : Four.t) =\n match i with Zero -> x0 | One -> x1 | Two -> x2 | Three -> x3\n\nlet map (x1, x2, x3, x4) ~f = (f x1, f x2, f x3, f x4)\n\nlet map2 (x1, x2, x3, x4) (y1, y2, y3, y4) ~f =\n (f x1 y1, f x2 y2, f x3 y3, f x4 y4)\n\nlet iter (x1, x2, x3, x4) ~f = f x1 ; f x2 ; f x3 ; f x4\n","open Core_kernel\n\ntype 'a t = 'a * 'a * 'a [@@deriving bin_io, sexp, eq, compare]\n\nlet map (x1, x2, x3) ~f = (f x1, f x2, f x3)\n\nlet map2 (x1, x2, x3) (y1, y2, y3) ~f = (f x1 y1, f x2 y2, f x3 y3)\n\nlet iter (x1, x2, x3) ~f = f x1 ; f x2 ; f x3\n","module Double = Double\nmodule Triple = Triple\nmodule Quadruple = Quadruple\nmodule Four = Four\n","(* bits.ml *)\n\n[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Fold_lib\nopen Bitstring_lib\n\n(* Someday: Make more efficient by giving Field.unpack a length argument in\n camlsnark *)\nlet unpack_field unpack ~bit_length x = List.take (unpack x) bit_length\n\nlet bits_per_char = 8\n\nlet pad (type a) ~length ~default (bs : a Bitstring.Lsb_first.t) =\n let bs = (bs :> a list) in\n let padding = length - List.length bs in\n assert (padding >= 0) ;\n bs @ List.init padding ~f:(fun _ -> default)\n\nmodule Vector = struct\n module type Basic = sig\n type t\n\n val length : int\n\n val get : t -> int -> bool\n\n val set : t -> int -> bool -> t\n end\n\n module type S = sig\n include Basic\n\n val empty : t\n\n val set : t -> int -> bool -> t\n end\n\n module UInt64 : S with type t = Unsigned.UInt64.t = struct\n open Unsigned.UInt64.Infix\n include Unsigned.UInt64\n\n let length = 64\n\n let empty = zero\n\n let get t i = equal ((t lsr i) land one) one\n\n let set t i b = if b then t lor (one lsl i) else t land lognot (one lsl i)\n end\n\n module UInt32 : S with type t = Unsigned.UInt32.t = struct\n open Unsigned.UInt32.Infix\n include Unsigned.UInt32\n\n let length = 32\n\n let empty = zero\n\n let get t i = equal ((t lsr i) land one) one\n\n let set t i b = if b then t lor (one lsl i) else t land lognot (one lsl i)\n end\n\n module Make (V : S) : Bits_intf.Convertible_bits with type t = V.t = struct\n type t = V.t\n\n let fold t =\n { Fold.fold =\n (fun ~init ~f ->\n let rec go acc i =\n if i = V.length then acc else go (f acc (V.get t i)) (i + 1)\n in\n go init 0 )\n }\n\n let iter t ~f =\n for i = 0 to V.length - 1 do\n f (V.get t i)\n done\n\n let to_bits t = List.init V.length ~f:(V.get t)\n\n let of_bits bools =\n List.foldi bools ~init:V.empty ~f:(fun i t bool -> V.set t i bool)\n\n let size_in_bits = V.length\n end\nend\n\nmodule UInt64 : Bits_intf.Convertible_bits with type t := Unsigned.UInt64.t =\n Vector.Make (Vector.UInt64)\n\nmodule UInt32 : Bits_intf.Convertible_bits with type t := Unsigned.UInt32.t =\n Vector.Make (Vector.UInt32)\n\n[%%ifdef consensus_mechanism]\n\nmodule type Big_int_intf = sig\n include Snarky_backendless.Bigint_intf.S\n\n val to_field : t -> field\nend\n\nmodule Make_field0\n (Field : Snarky_backendless.Field_intf.S)\n (Bigint : Big_int_intf with type field := Field.t) (M : sig\n val bit_length : int\n end) : Bits_intf.S with type t = Field.t = struct\n open M\n\n type t = Field.t\n\n let fold t =\n { Fold.fold =\n (fun ~init ~f ->\n let n = Bigint.of_field t in\n let rec go acc i =\n if i = bit_length then acc\n else go (f acc (Bigint.test_bit n i)) (i + 1)\n in\n go init 0 )\n }\n\n let iter t ~f =\n let n = Bigint.of_field t in\n for i = 0 to bit_length - 1 do\n f (Bigint.test_bit n i)\n done\n\n let to_bits t =\n let n = Bigint.of_field t in\n let rec go acc i =\n if i < 0 then acc else go (Bigint.test_bit n i :: acc) (i - 1)\n in\n go [] (bit_length - 1)\n\n let size_in_bits = bit_length\nend\n\nmodule Make_field\n (Field : Snarky_backendless.Field_intf.S)\n (Bigint : Big_int_intf with type field := Field.t) :\n Bits_intf.S with type t = Field.t =\n Make_field0 (Field) (Bigint)\n (struct\n let bit_length = Field.size_in_bits\n end)\n\nmodule Small\n (Field : Snarky_backendless.Field_intf.S)\n (Bigint : Big_int_intf with type field := Field.t) (M : sig\n val bit_length : int\n end) : Bits_intf.S with type t = Field.t = struct\n let () = assert (M.bit_length < Field.size_in_bits)\n\n include Make_field0 (Field) (Bigint) (M)\nend\n\nmodule Snarkable = struct\n module Small_bit_vector\n (Impl : Snarky_backendless.Snark_intf.S) (V : sig\n type t\n\n val empty : t\n\n val length : int\n\n val get : t -> int -> bool\n\n val set : t -> int -> bool -> t\n end) :\n Bits_intf.Snarkable.Small\n with type ('a, 'b) typ := ('a, 'b) Impl.Typ.t\n and type 'a checked := 'a Impl.Checked.t\n and type boolean_var := Impl.Boolean.var\n and type field_var := Impl.Field.Var.t\n and type Packed.var = Impl.Field.Var.t\n and type Packed.value = V.t\n and type Unpacked.var = Impl.Boolean.var list\n and type Unpacked.value = V.t\n and type comparison_result := Impl.Field.Checked.comparison_result =\n struct\n open Impl\n\n let bit_length = V.length\n\n let () = assert (bit_length < Field.size_in_bits)\n\n let size_in_bits = bit_length\n\n let init ~f =\n let rec go acc i =\n if i = V.length then acc else go (V.set acc i (f i)) (i + 1)\n in\n go V.empty 0\n\n module Packed = struct\n type var = Field.Var.t\n\n type value = V.t\n\n let typ : (var, value) Typ.t =\n Field.typ\n |> Typ.transport\n ~there:(fun t ->\n let rec go two_to_the_i i acc =\n if i = V.length then acc\n else\n let acc =\n if V.get t i then Field.add two_to_the_i acc else acc\n in\n go (Field.add two_to_the_i two_to_the_i) (i + 1) acc\n in\n go Field.one 0 Field.zero )\n ~back:(fun t ->\n let n = Bigint.of_field t in\n init ~f:(fun i -> Bigint.test_bit n i) )\n\n let size_in_bits = size_in_bits\n end\n\n let v_to_list n v =\n List.init n ~f:(fun i -> if i < V.length then V.get v i else false)\n\n let v_of_list vs =\n List.foldi vs ~init:V.empty ~f:(fun i acc b ->\n if i < V.length then V.set acc i b else acc )\n\n let pack_var = Field.Var.project\n\n let pack_value = Fn.id\n\n module Unpacked = struct\n type var = Boolean.var list\n\n type value = V.t\n\n let typ : (var, value) Typ.t =\n Typ.transport\n (Typ.list ~length:V.length Boolean.typ)\n ~there:(v_to_list V.length) ~back:v_of_list\n\n let var_to_bits = Bitstring.Lsb_first.of_list\n\n let var_of_bits = pad ~length:V.length ~default:Boolean.false_\n\n let var_to_triples (bs : var) =\n Bitstring_lib.Bitstring.pad_to_triple_list ~default:Boolean.false_ bs\n\n let var_of_value v =\n List.init V.length ~f:(fun i -> Boolean.var_of_value (V.get v i))\n\n let size_in_bits = size_in_bits\n end\n\n let unpack_var x = Impl.Field.Checked.unpack x ~length:bit_length\n\n let var_of_field = unpack_var\n\n let var_of_field_unsafe = Fn.id\n\n let unpack_value (x : Packed.value) : Unpacked.value = x\n\n let compare_var x y =\n Impl.Field.Checked.compare ~bit_length:V.length (pack_var x) (pack_var y)\n\n let%snarkydef_ increment_if_var bs (b : Boolean.var) =\n let open Impl in\n let v = Field.Var.pack bs in\n let v' = Field.Var.add v (b :> Field.Var.t) in\n Field.Checked.unpack v' ~length:V.length\n\n let%snarkydef_ increment_var bs =\n let open Impl in\n let v = Field.Var.pack bs in\n let v' = Field.Var.add v (Field.Var.constant Field.one) in\n Field.Checked.unpack v' ~length:V.length\n\n let%snarkydef_ equal_var (n : Unpacked.var) (n' : Unpacked.var) =\n Field.Checked.equal (pack_var n) (pack_var n')\n\n let%snarkydef_ assert_equal_var (n : Unpacked.var) (n' : Unpacked.var) =\n Field.Checked.Assert.equal (pack_var n) (pack_var n')\n\n let if_ (cond : Boolean.var) ~(then_ : Unpacked.var) ~(else_ : Unpacked.var)\n : Unpacked.var Checked.t =\n match\n List.map2 then_ else_ ~f:(fun then_ else_ ->\n Boolean.if_ cond ~then_ ~else_ )\n with\n | Ok result ->\n Checked.List.all result\n | Unequal_lengths ->\n failwith \"Bits.if_: unpacked bit lengths were unequal\"\n end\n\n module UInt64 (Impl : Snarky_backendless.Snark_intf.S) =\n Small_bit_vector (Impl) (Vector.UInt64)\n module UInt32 (Impl : Snarky_backendless.Snark_intf.S) =\n Small_bit_vector (Impl) (Vector.UInt32)\n\n module Field_backed\n (Impl : Snarky_backendless.Snark_intf.S) (M : sig\n val bit_length : int\n end) =\n struct\n open Impl\n include M\n\n let size_in_bits = bit_length\n\n module Packed = struct\n type var = Field.Var.t\n\n type value = Field.t\n\n let typ = Typ.field\n\n let assert_equal = Field.Checked.Assert.equal\n\n let size_in_bits = size_in_bits\n end\n\n module Unpacked = struct\n type var = Boolean.var list\n\n type value = Field.t\n\n let typ : (var, value) Typ.t =\n Typ.transport\n (Typ.list ~length:bit_length Boolean.typ)\n ~there:(unpack_field Field.unpack ~bit_length)\n ~back:Field.project\n\n let var_to_bits = Bitstring_lib.Bitstring.Lsb_first.of_list\n\n let var_of_bits = pad ~length:bit_length ~default:Boolean.false_\n\n let var_to_triples (bs : var) =\n Bitstring_lib.Bitstring.pad_to_triple_list ~default:Boolean.false_ bs\n\n let var_of_value v =\n unpack_field Field.unpack ~bit_length v\n |> List.map ~f:Boolean.var_of_value\n\n let size_in_bits = size_in_bits\n end\n\n let project_value = Fn.id\n\n let project_var = Field.Var.project\n\n let choose_preimage_var : Packed.var -> Unpacked.var Checked.t =\n Field.Checked.choose_preimage_var ~length:bit_length\n\n let unpack_value = Fn.id\n end\n\n module Field (Impl : Snarky_backendless.Snark_intf.S) :\n Bits_intf.Snarkable.Lossy\n with type ('a, 'b) typ := ('a, 'b) Impl.Typ.t\n and type 'a checked := 'a Impl.Checked.t\n and type boolean_var := Impl.Boolean.var\n and type Packed.var = Impl.Field.Var.t\n and type Packed.value = Impl.Field.t\n and type Unpacked.var = Impl.Boolean.var list\n and type Unpacked.value = Impl.Field.t =\n Field_backed\n (Impl)\n (struct\n let bit_length = Impl.Field.size_in_bits\n end)\n\n module Small\n (Impl : Snarky_backendless.Snark_intf.S) (M : sig\n val bit_length : int\n end) :\n Bits_intf.Snarkable.Faithful\n with type ('a, 'b) typ := ('a, 'b) Impl.Typ.t\n and type 'a checked := 'a Impl.Checked.t\n and type boolean_var := Impl.Boolean.var\n and type Packed.var = Impl.Field.Var.t\n and type Packed.value = Impl.Field.t\n and type Unpacked.var = Impl.Boolean.var list\n and type Unpacked.value = Impl.Field.t = struct\n let () = assert (M.bit_length < Impl.Field.size_in_bits)\n\n include Field_backed (Impl) (M)\n\n let pack_var bs =\n assert (Mina_stdlib.List.Length.Compare.(bs = M.bit_length)) ;\n project_var bs\n\n let pack_value = Fn.id\n\n let unpack_var = Impl.Field.Checked.unpack ~length:M.bit_length\n end\nend\n\nmodule Make_unpacked\n (Impl : Snarky_backendless.Snark_intf.S) (M : sig\n val bit_length : int\n end) =\nstruct\n open Impl\n\n module T = struct\n type var = Boolean.var list\n\n type value = Boolean.value list\n end\n\n include T\n\n let typ : (var, value) Typ.t = Typ.list ~length:M.bit_length Boolean.typ\nend\n\n[%%endif]\n","open Core_kernel\n\nmodule Interval = struct\n (* Semantically (a, b) : t is the closed interval [a, b] *)\n type t = int * int [@@deriving eq, sexp]\n\n let before (_, b1) (a2, _) = b1 <= a2\n\n let gen_from start =\n let open Quickcheck.Generator.Let_syntax in\n let%bind x = Int.gen_incl start Int.max_value_30_bits in\n let%map y = Int.gen_incl x Int.max_value_30_bits in\n (x, y)\n\n let gen =\n let open Quickcheck.Generator.Let_syntax in\n let%bind x = Int.gen_incl Int.min_value Int.max_value_30_bits in\n let%map y = Int.gen_incl x Int.max_value_30_bits in\n (x, y)\n\n let%test_unit \"gen is correct\" =\n Quickcheck.test gen ~f:(fun (x, y) -> assert (x <= y))\nend\n\n(* Simplest possible implementation. Should be an increasing list of\n disjoint intervals.\n Semantically is the set of ints corresponding to the union of these\n ntervals. *)\ntype t = Interval.t list [@@deriving eq, sexp]\n\nlet empty : t = []\n\nlet union_intervals_exn (a1, b1) (a2, b2) =\n let ( = ) = Int.( = ) in\n if b1 = a2 then `Combine (a1, b2)\n else if b2 = a1 then `Combine (a2, b1)\n else if b1 < a2 then `Disjoint_ordered\n else if b2 < a1 then `Disjoint_inverted\n else failwithf \"Intervals not disjoint: (%d, %d) and (%d, %d)\" a1 b1 a2 b2 ()\n\nlet of_interval i = [ i ]\n\nlet rec canonicalize = function\n | [] ->\n []\n | [ i1 ] ->\n [ i1 ]\n | (a1, a2) :: (a3, a4) :: t ->\n if a2 = a3 then canonicalize ((a1, a4) :: t)\n else (a1, a2) :: canonicalize ((a3, a4) :: t)\n\nlet rec disjoint_union_exn t1 t2 =\n match (t1, t2) with\n | t, [] | [], t ->\n t\n | i1 :: t1', i2 :: t2' -> (\n match union_intervals_exn i1 i2 with\n | `Combine (a, b) ->\n (a, b) :: disjoint_union_exn t1' t2'\n | `Disjoint_ordered ->\n i1 :: disjoint_union_exn t1' t2\n | `Disjoint_inverted ->\n i2 :: disjoint_union_exn t1 t2' )\n\nlet disjoint_union_exn t1 t2 = canonicalize (disjoint_union_exn t1 t2)\n\nlet rec disjoint t1 t2 =\n match (t1, t2) with\n | _, [] | [], _ ->\n true\n | i1 :: t1', i2 :: t2' ->\n if Interval.before i1 i2 then disjoint t1' t2\n else if Interval.before i2 i1 then disjoint t1 t2'\n else false\n\n(* Someday: inefficient *)\nlet of_intervals_exn is =\n match is with\n | [] ->\n []\n | i :: is ->\n List.fold is ~init:(of_interval i) ~f:(fun acc x ->\n disjoint_union_exn (of_interval x) acc )\n\nlet to_interval = function\n | [ i ] ->\n Ok i\n | [] ->\n Or_error.error_string \"Interval_union.to_interval: the union is empty\\n\"\n | _ :: _ :: _ as xs ->\n Or_error.error_string\n (Printf.sprintf\n !\"Interval_union.to_interval: expected a single interval in the \\\n union, got multiple disjoint intervals %{sexp: Interval.t list}\\n\"\n xs )\n\nlet right_endpoint t = Option.map ~f:snd (List.last t)\n\nlet left_endpoint t = Option.map ~f:fst (List.hd t)\n\nlet invariant t =\n let rec go = function\n | [ (a, b) ] ->\n assert (a <= b)\n | [] ->\n ()\n | (a1, b1) :: ((a2, _) :: _ as t) ->\n assert (a1 <= b1) ;\n assert (b1 < a2) ;\n go t\n in\n go t\n\nlet gen_from ?(min_size = 0) start =\n let open Quickcheck.Generator.Let_syntax in\n let rec go acc size start =\n if size = 0 then return (of_intervals_exn (List.rev acc))\n else\n let%bind ((_, y) as i) = Interval.gen_from start in\n go (i :: acc) (size - 1) y\n in\n let%bind size = Quickcheck.Generator.small_positive_int in\n go [] (min_size + size) start\n\nlet gen = gen_from Int.min_value\n\nlet%test_unit \"check invariant\" = Quickcheck.test gen ~f:invariant\n\nlet gen_disjoint_pair =\n let open Quickcheck.Generator.Let_syntax in\n let%bind t1 = gen in\n let y = List.last_exn t1 |> snd in\n let%map t2 = gen_from y in\n (t1, t2)\n\nlet%test_unit \"canonicalize\" =\n assert (equal (canonicalize [ (1, 2); (2, 3) ]) [ (1, 3) ])\n\nlet%test_unit \"disjoint union doesn't care about order\" =\n Quickcheck.test gen_disjoint_pair ~f:(fun (a, b) ->\n assert (equal (disjoint_union_exn a b) (disjoint_union_exn b a)) )\n\nlet%test_unit \"check invariant on disjoint union\" =\n Quickcheck.test gen_disjoint_pair ~f:(fun (a, b) ->\n invariant (disjoint_union_exn a b) )\n\nlet%test_unit \"disjoint_union works with holes\" =\n let gen =\n let open Quickcheck.Generator.Let_syntax in\n let s = 1000000 in\n let%bind y0 = Int.gen_incl 0 s in\n let%bind y1 = Int.gen_incl (y0 + 1) (y0 + s) in\n let%bind y2 = Int.gen_incl (y1 + 1) (y1 + s) in\n let%bind y3 = Int.gen_incl (y2 + 1) (y2 + s) in\n return (of_interval (y1, y2), of_intervals_exn [ (y0, y1); (y2, y3) ])\n in\n Quickcheck.test gen ~f:(fun (x, y) -> invariant (disjoint_union_exn x y))\n","open Core_kernel\n\ntype t = Big_int.big_int\n\nlet equal = Big_int.eq_big_int\n\nlet num_bits = Big_int.num_bits_big_int\n\nlet shift_right = Big_int.shift_right_big_int\n\nlet shift_left = Big_int.shift_left_big_int\n\nlet log_and = Big_int.and_big_int\n\nlet log_or = Big_int.or_big_int\n\nlet of_int = Big_int.big_int_of_int\n\nlet test_bit t i =\n equal (log_and Big_int.unit_big_int (shift_right t i)) Big_int.unit_big_int\n\nlet to_bytes x =\n let n = num_bits x in\n let num_bytes = (n + 7) / 8 in\n String.init num_bytes ~f:(fun byte ->\n let c i =\n let bit = (8 * byte) + i in\n if test_bit x bit then 1 lsl i else 0\n in\n Char.of_int_exn\n (c 0 lor c 1 lor c 2 lor c 3 lor c 4 lor c 5 lor c 6 lor c 7) )\n\nlet of_bytes x =\n String.foldi x ~init:Big_int.zero_big_int ~f:(fun i acc c ->\n log_or acc (shift_left (of_int (Char.to_int c)) (8 * i)) )\n\nlet ( + ) = Big_int.add_big_int\n\nlet ( - ) = Big_int.sub_big_int\n\nlet ( * ) = Big_int.mult_big_int\n\nlet ( % ) = Big_int.mod_big_int\n\nlet ( // ) = Big_int.div_big_int\n\nlet ( < ) = Big_int.lt_big_int\n\nlet to_int_exn = Big_int.int_of_big_int\n\nlet compare = Big_int.compare_big_int\n\nmodule String_hum = struct\n type nonrec t = t\n\n let of_string = Big_int.big_int_of_string\n\n let to_string = Big_int.string_of_big_int\nend\n\ninclude Sexpable.Of_stringable (String_hum)\n\ninclude (String_hum : Stringable.S with type t := t)\n\nlet hash t = Stdlib.Hashtbl.hash t\n\nlet hash_fold_t h t = hash_fold_int h (hash t)\n\nlet to_yojson t = `String (to_string t)\n\nlet of_yojson = function\n | `String s ->\n Ok (of_string s)\n | _ ->\n Error \"Nat.of_yojson: Expected string\"\n\n[@@@alert \"-legacy\"]\n\n(** this serialization is not used for fields *)\ninclude Binable.Of_stringable_without_uuid (struct\n type nonrec t = t\n\n let of_string = of_bytes\n\n let to_string = to_bytes\nend)\n","type ('var, 'value) t = { var : 'var; mutable value : 'value option }\n\nlet var { var; _ } = var\n","(** The usual Janestreet [Monad] interfaces, with [Let_syntax] included in the\n monad module. *)\nopen Core_kernel\n\nopen Monad\n\nmodule type Let_syntax = sig\n type 'a t\n\n val return : 'a -> 'a t\n\n val bind : 'a t -> f:('a -> 'b t) -> 'b t\n\n val map : 'a t -> f:('a -> 'b) -> 'b t\n\n val both : 'a t -> 'b t -> ('a * 'b) t\n\n module Open_on_rhs : sig end\nend\n\nmodule type Base_syntax = sig\n type 'a t\n\n val return : 'a -> 'a t\n\n include Infix with type 'a t := 'a t\nend\n\nmodule type Syntax = sig\n include Base_syntax\n\n include Let_syntax with type 'a t := 'a t\nend\n\nmodule type S = sig\n type 'a t\n\n include S_without_syntax with type 'a t := 'a t\n\n module Let_syntax : sig\n include Base_syntax with type 'a t := 'a t\n\n include Let_syntax with type 'a t := 'a t\n\n module Let_syntax : Let_syntax with type 'a t := 'a t\n end\nend\n\nmodule type Let_syntax2 = sig\n type ('a, 'e) t\n\n val return : 'a -> ('a, 'e) t\n\n val bind : ('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t\n\n val map : ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t\n\n val both : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t\n\n module Open_on_rhs : sig end\nend\n\nmodule type Base_syntax2 = sig\n type ('a, 'e) t\n\n val return : 'a -> ('a, 'e) t\n\n include Infix2 with type ('a, 'e) t := ('a, 'e) t\nend\n\nmodule type Syntax2 = sig\n include Base_syntax2\n\n include Let_syntax2 with type ('a, 'e) t := ('a, 'e) t\nend\n\nmodule type S_without_syntax2 = sig\n type ('a, 'e) t\n\n include Infix2 with type ('a, 'e) t := ('a, 'e) t\n\n module Monad_infix : Infix2 with type ('a, 'e) t := ('a, 'e) t\n\n val bind : ('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t\n\n val return : 'a -> ('a, _) t\n\n val map : ('a, 'e) t -> f:('a -> 'b) -> ('b, 'e) t\n\n val join : (('a, 'e) t, 'e) t -> ('a, 'e) t\n\n val ignore_m : (_, 'e) t -> (unit, 'e) t\n\n val all : ('a, 'e) t list -> ('a list, 'e) t\n\n val all_unit : (unit, 'e) t list -> (unit, 'e) t\nend\n\nmodule type S2 = sig\n type ('a, 'e) t\n\n include S_without_syntax2 with type ('a, 'e) t := ('a, 'e) t\n\n module Let_syntax : sig\n include Base_syntax2 with type ('a, 'e) t := ('a, 'e) t\n\n include Let_syntax2 with type ('a, 'e) t := ('a, 'e) t\n\n module Let_syntax : Let_syntax2 with type ('a, 'e) t := ('a, 'e) t\n end\nend\n\nmodule type Let_syntax3 = sig\n type ('a, 'd, 'e) t\n\n val return : 'a -> ('a, 'd, 'e) t\n\n val bind : ('a, 'd, 'e) t -> f:('a -> ('b, 'd, 'e) t) -> ('b, 'd, 'e) t\n\n val map : ('a, 'd, 'e) t -> f:('a -> 'b) -> ('b, 'd, 'e) t\n\n val both : ('a, 'd, 'e) t -> ('b, 'd, 'e) t -> ('a * 'b, 'd, 'e) t\n\n module Open_on_rhs : sig end\nend\n\nmodule type Base_syntax3 = sig\n type ('a, 'd, 'e) t\n\n val return : 'a -> ('a, 'd, 'e) t\n\n include Infix3 with type ('a, 'd, 'e) t := ('a, 'd, 'e) t\nend\n\nmodule type Syntax3 = sig\n include Base_syntax3\n\n include Let_syntax3 with type ('a, 'd, 'e) t := ('a, 'd, 'e) t\nend\n\nmodule type S_without_syntax3 = sig\n type ('a, 'd, 'e) t\n\n include Infix3 with type ('a, 'd, 'e) t := ('a, 'd, 'e) t\n\n module Monad_infix : Infix3 with type ('a, 'd, 'e) t := ('a, 'd, 'e) t\n\n val bind : ('a, 'd, 'e) t -> f:('a -> ('b, 'd, 'e) t) -> ('b, 'd, 'e) t\n\n val return : 'a -> ('a, _, _) t\n\n val map : ('a, 'd, 'e) t -> f:('a -> 'b) -> ('b, 'd, 'e) t\n\n val join : (('a, 'd, 'e) t, 'd, 'e) t -> ('a, 'd, 'e) t\n\n val ignore_m : (_, 'd, 'e) t -> (unit, 'd, 'e) t\n\n val all : ('a, 'd, 'e) t list -> ('a list, 'd, 'e) t\n\n val all_unit : (unit, 'd, 'e) t list -> (unit, 'd, 'e) t\nend\n\nmodule type S3 = sig\n type ('a, 'd, 'e) t\n\n include S_without_syntax3 with type ('a, 'd, 'e) t := ('a, 'd, 'e) t\n\n module Let_syntax : sig\n include Base_syntax3 with type ('a, 'd, 'e) t := ('a, 'd, 'e) t\n\n include Let_syntax3 with type ('a, 'd, 'e) t := ('a, 'd, 'e) t\n\n module Let_syntax : Let_syntax3 with type ('a, 'd, 'e) t := ('a, 'd, 'e) t\n end\nend\n\nmodule Make3 (X : Monad.Basic3) :\n S3 with type ('a, 'd, 'e) t := ('a, 'd, 'e) X.t = struct\n include X\n module M = Monad.Make3 (X)\n module Let = M.Let_syntax.Let_syntax\n\n [@@@warning \"-3\"]\n\n include (M : S_without_syntax3 with type ('a, 'd, 'e) t := ('a, 'd, 'e) t)\n\n module Let_syntax = struct\n include (\n M.Let_syntax : Base_syntax3 with type ('a, 'd, 'e) t := ('a, 'd, 'e) t )\n\n include (Let : Let_syntax3 with type ('a, 'd, 'e) t := ('a, 'd, 'e) t)\n\n module Let_syntax = Let\n end\nend\n\nmodule Make2 (X : Monad.Basic2) : S2 with type ('a, 'e) t := ('a, 'e) X.t =\nMake3 (struct\n type ('a, 'd, 'e) t = ('a, 'e) X.t\n\n include (X : Monad.Basic3 with type ('a, 'd, 'e) t := ('a, 'e) X.t)\nend)\n\nmodule Make (X : Monad.Basic) : S with type 'a t := 'a X.t = Make2 (struct\n type ('a, 'e) t = 'a X.t\n\n include (X : Monad.Basic2 with type ('a, 'e) t := 'a X.t)\nend)\n","type _ t = ..\n\ntype _ t += Fail : 'a t\n\ntype 'a req = 'a t\n\ntype response = ..\n\ntype response += Unhandled\n\nlet unhandled = Unhandled\n\nmodule Response = struct\n type 'a t = Provide of 'a | Delegate of 'a req | Unhandled\nend\n\ntype request =\n | With : { request : 'a t; respond : 'a Response.t -> response } -> request\n\nmodule Handler = struct\n type single = { handle : 'a. 'a t -> 'a Response.t }\n\n type t = single list\n\n let fail = []\n\n let run : t -> string list -> 'a req -> 'a =\n fun stack0 label_stack req0 ->\n let rec go req = function\n | [] ->\n failwith\n ( \"Unhandled request: \"\n ^ Core_kernel.String.concat ~sep:\"\\n\" label_stack )\n | { handle } :: hs -> (\n match handle req with\n | Provide x ->\n x\n | Delegate req' ->\n go req' hs\n | Unhandled ->\n go req hs )\n in\n go req0 stack0\n\n let create_single (handler : request -> response) : single =\n let handle : type a. a req -> a Response.t =\n fun request ->\n let module T = struct\n type response += T of a Response.t\n end in\n match handler (With { request; respond = (fun x -> T.T x) }) with\n | T.T x ->\n x\n | _ ->\n Response.Unhandled\n in\n { handle }\n\n let push (t : t) (single : single) : t = single :: t\nend\n","open Core_kernel\n\nmodule Make (Field : sig\n type t [@@deriving sexp]\n\n val equal : t -> t -> bool\nend)\n(Basic : Checked_intf.Basic with type 'f field = Field.t)\n(As_prover : As_prover_intf.Basic with type 'f field := 'f Basic.field) :\n Checked_intf.S\n with module Types = Basic.Types\n with type 'f field = 'f Basic.field = struct\n include Basic\n\n let request_witness (typ : ('var, 'value, 'f field) Types.Typ.t)\n (r : ('value Request.t, 'f field) As_prover.t) =\n let%map h = exists typ (Request r) in\n Handle.var h\n\n let request ?such_that typ r =\n match such_that with\n | None ->\n request_witness typ (As_prover.return r)\n | Some such_that ->\n let open Let_syntax in\n let%bind x = request_witness typ (As_prover.return r) in\n let%map () = such_that x in\n x\n\n let exists_handle ?request ?compute typ =\n let provider =\n let request =\n Option.value request ~default:(As_prover.return Request.Fail)\n in\n match compute with\n | None ->\n Types.Provider.Request request\n | Some c ->\n Types.Provider.Both (request, c)\n in\n exists typ provider\n\n let exists ?request ?compute typ =\n let%map h = exists_handle ?request ?compute typ in\n Handle.var h\n\n type response = Request.response\n\n let unhandled = Request.unhandled\n\n type request = Request.request =\n | With :\n { request : 'a Request.t; respond : 'a Request.Response.t -> response }\n -> request\n\n let handle t k = with_handler (Request.Handler.create_single k) t\n\n let handle_as_prover t k =\n let handler = ref None in\n let%bind () =\n as_prover\n As_prover.(\n let%map h = k in\n handler := Some h)\n in\n handle t (fun request -> (Option.value_exn !handler) request)\n\n let assert_ ?label c = add_constraint (Constraint.override_label c label)\n\n let assert_r1cs ?label a b c = assert_ (Constraint.r1cs ?label a b c)\n\n let assert_square ?label a c = assert_ (Constraint.square ?label a c)\n\n let assert_all ?label cs =\n List.fold_right cs ~init:(return ()) ~f:(fun c (acc : _ t) ->\n bind acc ~f:(fun () ->\n add_constraint (Constraint.override_label c label) ) )\n\n let assert_equal ?label x y =\n match (x, y) with\n | Cvar.Constant x, Cvar.Constant y ->\n if Field.equal x y then return ()\n else\n failwithf !\"assert_equal: %{sexp: Field.t} != %{sexp: Field.t}\" x y ()\n | _ ->\n assert_ (Constraint.equal ?label x y)\nend\n","module As_prover = struct\n type ('a, 'f) t = ('f Cvar.t -> 'f) -> 'a\nend\n\nmodule Provider = struct\n module T = struct\n (** The different ways to generate a value for the circuit witness.\n\n If [Both], this attempts the request first, and falls back on compute\n if the request is unhandled or raises an exception.\n *)\n type ('request, 'compute) provider =\n | Request of 'request\n | Compute of 'compute\n | Both of 'request * 'compute\n end\n\n include T\n\n type ('request, 'compute) t = ('request, 'compute) provider\nend\n\nmodule Typ = struct\n module T = struct\n (** The type [('var, 'value, 'field, 'checked) t] describes a mapping from\n OCaml types to the variables and constraints they represent:\n - ['value] is the OCaml type\n - ['field] is the type of the field elements\n - ['var] is some other type that contains some R1CS variables\n - ['checked] is the type of checked computation that verifies the stored\n contents as R1CS variables.\n\n For convenience and readability, it is usually best to have the ['var]\n type mirror the ['value] type in structure, for example:\n{[\n type t = {b1 : bool; b2 : bool} (* 'value *)\n\n let or (x : t) = x.b1 || x.b2\n\n module Checked = struct\n type t = {b1 : Snark.Boolean.var; b2 : Snark.Boolean.var} (* 'var *)\n\n let or (x : t) = Snark.Boolean.(x.b1 || x.b2)\n end\n]}*)\n type ('var, 'value, 'aux, 'field, 'checked) typ' =\n { var_to_fields : 'var -> 'field Cvar.t array * 'aux\n ; var_of_fields : 'field Cvar.t array * 'aux -> 'var\n ; value_to_fields : 'value -> 'field array * 'aux\n ; value_of_fields : 'field array * 'aux -> 'value\n ; size_in_field_elements : int\n ; constraint_system_auxiliary : unit -> 'aux\n ; check : 'var -> 'checked\n }\n\n type ('var, 'value, 'field, 'checked) typ =\n | Typ :\n ('var, 'value, 'aux, 'field, 'checked) typ'\n -> ('var, 'value, 'field, 'checked) typ\n end\n\n include T\n\n type ('var, 'value, 'field, 'checked) t = ('var, 'value, 'field, 'checked) typ\nend\n\nmodule type Types = sig\n module Checked : sig\n type ('a, 'f) t\n end\n\n module Typ : sig\n include module type of Typ.T\n\n type ('var, 'value, 'f) t = ('var, 'value, 'f, (unit, 'f) Checked.t) Typ.t\n end\n\n module Provider : sig\n include module type of Provider.T\n\n type ('a, 'f) t =\n (('a Request.t, 'f) As_prover.t, ('a, 'f) As_prover.t) provider\n end\nend\n","open Core_kernel\n\ntype ('a, 'f) t = ('a, 'f) Types.As_prover.t\n\nlet map t ~f tbl =\n let x = t tbl in\n f x\n\nlet bind t ~f tbl =\n let x = t tbl in\n f x tbl\n\nlet return x _ = x\n\nlet run t tbl = t tbl\n\nlet get_state _tbl s = (s, s)\n\nlet set_state s _tbl _ = (s, ())\n\nlet modify_state f _tbl s = (f s, ())\n\nlet map2 x y ~f tbl =\n let x = x tbl in\n let y = y tbl in\n f x y\n\nlet read_var (v : 'var) : ('field, 'field) t = fun tbl -> tbl v\n\nlet read\n (Typ { var_to_fields; value_of_fields; _ } :\n ('var, 'value, 'field, _) Types.Typ.t ) (var : 'var) : ('value, 'field) t\n =\n fun tbl ->\n let field_vars, aux = var_to_fields var in\n let fields = Array.map ~f:tbl field_vars in\n value_of_fields (fields, aux)\n\ninclude Monad_let.Make2 (struct\n type nonrec ('a, 'e) t = ('a, 'e) t\n\n let map = `Custom map\n\n let bind = bind\n\n let return = return\nend)\n\nmodule Provider = struct\n (** The different ways to generate a value of type ['a] for a circuit\n witness over field ['f].\n\n This is one of:\n * a [Request], dispatching an ['a Request.t];\n * [Compute], running a computation to generate the value;\n * [Both], attempting to dispatch an ['a Request.t], and falling back to\n the computation if the request is unhandled or raises an exception.\n *)\n type nonrec ('a, 'f) t = (('a Request.t, 'f) t, ('a, 'f) t) Types.Provider.t\n\n open Types.Provider\n\n let run t stack tbl (handler : Request.Handler.t) =\n match t with\n | Request rc ->\n let r = run rc tbl in\n Request.Handler.run handler stack r\n | Compute c ->\n run c tbl\n | Both (rc, c) -> (\n let r = run rc tbl in\n match Request.Handler.run handler stack r with\n | exception _ ->\n run c tbl\n | x ->\n x )\nend\n\nmodule Handle = struct\n let value (t : ('var, 'value) Handle.t) : ('value, 'field) t =\n fun _ -> Option.value_exn t.value\nend\n\nmodule type Extended = sig\n type field\n\n include As_prover_intf.Basic with type 'f field := field\n\n type nonrec 'a t = ('a, field) t\nend\n\nmodule Make_extended (Env : sig\n type field\nend)\n(As_prover : As_prover_intf.Basic with type 'f field := Env.field) =\nstruct\n include Env\n include As_prover\n\n type nonrec 'a t = ('a, field) t\nend\n","module Vector = struct\n open Core_kernel\n\n type 'elt t =\n | T :\n (module Snarky_intf.Vector.S with type elt = 'elt and type t = 't)\n * 't Type_equal.Id.t\n * 't\n -> 'elt t\n\n let unit = Type_equal.Id.create ~name:\"unit\" Unit.sexp_of_t\n\n let null : type a. a t =\n let module T = struct\n type elt = a\n\n type t = unit\n\n let create () = ()\n\n let get _ _ = failwith \"Vector.null: get\"\n\n let emplace_back _ _ = failwith \"Vector.null: emplace_back\"\n\n let length () = 0\n end in\n T ((module T), unit, ())\n\n let get (type x) (T ((module T), _, t) : x t) i = T.get t i\n\n let emplace_back (type x) (T ((module T), _, t) : x t) x = T.emplace_back t x\nend\n\n(** The internal state used to run a checked computation. *)\ntype 'field t =\n { system : 'field Constraint_system.t option\n ; input : 'field Vector.t\n ; aux : 'field Vector.t\n ; eval_constraints : bool\n ; num_inputs : int\n ; next_auxiliary : int ref\n ; has_witness : bool\n ; stack : string list\n ; handler : Request.Handler.t\n ; is_running : bool\n ; as_prover : bool ref\n ; log_constraint :\n ( ?at_label_boundary:[ `Start | `End ] * string\n -> ('field Cvar.t, 'field) Constraint.t option\n -> unit )\n option\n }\n\nlet make ~num_inputs ~input ~next_auxiliary ~aux ?system ~eval_constraints\n ?log_constraint ?handler ~with_witness ?(stack = []) ?(is_running = true) ()\n =\n next_auxiliary := num_inputs ;\n (* We can't evaluate the constraints if we are not computing over a value. *)\n let eval_constraints = eval_constraints && with_witness in\n { system\n ; input\n ; aux\n ; eval_constraints\n ; num_inputs\n ; next_auxiliary\n ; has_witness = with_witness\n ; stack\n ; handler = Option.value handler ~default:Request.Handler.fail\n ; is_running\n ; as_prover = ref false\n ; log_constraint\n }\n\nlet dump (t : _ t) =\n Format.sprintf\n \"state { is_running: %B; as_prover: %B; has_witness: %B; eval_constraints: \\\n %B; num_inputs: %d; next_auxiliary: %d }\\n\"\n t.is_running !(t.as_prover) t.has_witness t.eval_constraints t.num_inputs\n !(t.next_auxiliary)\n\nlet get_variable_value { num_inputs; input; aux; _ } : int -> 'field =\n fun i ->\n if i < num_inputs then Vector.get input i else Vector.get aux (i - num_inputs)\n\nlet store_field_elt { next_auxiliary; aux; _ } x =\n let v = !next_auxiliary in\n incr next_auxiliary ; Vector.emplace_back aux x ; Cvar.Unsafe.of_index v\n\nlet alloc_var { next_auxiliary; _ } () =\n let v = !next_auxiliary in\n incr next_auxiliary ; Cvar.Unsafe.of_index v\n\nlet has_witness { has_witness; _ } = has_witness\n\nlet as_prover { as_prover; _ } = !as_prover\n\nlet set_as_prover t as_prover = t.as_prover := as_prover\n\nlet stack { stack; _ } = stack\n\nlet set_stack t stack = { t with stack }\n\nlet log_constraint { log_constraint; _ } = log_constraint\n\nlet eval_constraints { eval_constraints; _ } = eval_constraints\n\nlet system { system; _ } = system\n\nlet handler { handler; _ } = handler\n\nlet set_handler t handler = { t with handler }\n\nlet is_running { is_running; _ } = is_running\n\nlet set_is_running t is_running = { t with is_running }\n\nlet next_auxiliary { next_auxiliary; _ } = !next_auxiliary\n","module type Basic = sig\n module Types : Types.Types\n\n type ('a, 'f) t = ('a, 'f) Types.Checked.t\n\n type 'f field\n\n include Monad_let.S2 with type ('a, 'f) t := ('a, 'f) t\n\n val add_constraint :\n ('f field Cvar.t, 'f field) Constraint.t -> (unit, 'f field) t\n\n val as_prover : (unit, 'f field) As_prover0.t -> (unit, 'f field) t\n\n val mk_lazy : (unit -> ('a, 'f) t) -> ('a Lazy.t, 'f) t\n\n val with_label : string -> (unit -> ('a, 'f field) t) -> ('a, 'f field) t\n\n val with_handler :\n Request.Handler.single -> (unit -> ('a, 'f field) t) -> ('a, 'f field) t\n\n val exists :\n ('var, 'value, 'f field) Types.Typ.t\n -> ('value, 'f field) Types.Provider.t\n -> (('var, 'value) Handle.t, 'f field) t\n\n val next_auxiliary : unit -> (int, 'f field) t\n\n val direct :\n ('f field Run_state.t -> 'f field Run_state.t * 'a) -> ('a, 'f field) t\n\n val constraint_count :\n ?weight:(('f field Cvar.t, 'f field) Constraint.t -> int)\n -> ?log:(?start:bool -> string -> int -> unit)\n -> (unit -> ('a, 'f field) t)\n -> int\nend\n\nmodule type S = sig\n module Types : Types.Types\n\n type ('a, 'f) t = ('a, 'f) Types.Checked.t\n\n type 'f field\n\n include Monad_let.S2 with type ('a, 'f) t := ('a, 'f) t\n\n val as_prover : (unit, 'f field) As_prover0.t -> (unit, 'f field) t\n\n val mk_lazy : (unit -> ('a, 'f) t) -> ('a Lazy.t, 'f) t\n\n val request_witness :\n ('var, 'value, 'f field) Types.Typ.t\n -> ('value Request.t, 'f field) As_prover0.t\n -> ('var, 'f field) t\n\n val request :\n ?such_that:('var -> (unit, 'f field) t)\n -> ('var, 'value, 'f field) Types.Typ.t\n -> 'value Request.t\n -> ('var, 'f field) t\n\n val exists_handle :\n ?request:('value Request.t, 'f field) As_prover0.t\n -> ?compute:('value, 'f field) As_prover0.t\n -> ('var, 'value, 'f field) Types.Typ.t\n -> (('var, 'value) Handle.t, 'f field) t\n\n val exists :\n ?request:('value Request.t, 'f field) As_prover0.t\n -> ?compute:('value, 'f field) As_prover0.t\n -> ('var, 'value, 'f field) Types.Typ.t\n -> ('var, 'f field) t\n\n type response = Request.response\n\n val unhandled : response\n\n type request = Request.request =\n | With :\n { request : 'a Request.t; respond : 'a Request.Response.t -> response }\n -> request\n\n val handle :\n (unit -> ('a, 'f field) t) -> (request -> response) -> ('a, 'f field) t\n\n val handle_as_prover :\n (unit -> ('a, 'f field) t)\n -> (request -> response, 'f field) As_prover0.t\n -> ('a, 'f field) t\n\n val next_auxiliary : unit -> (int, 'f field) t\n\n val with_label : string -> (unit -> ('a, 'f field) t) -> ('a, 'f field) t\n\n val assert_ :\n ?label:Base.string\n -> ('f field Cvar.t, 'f field) Constraint.t\n -> (unit, 'f field) t\n\n val assert_r1cs :\n ?label:Base.string\n -> 'f field Cvar.t\n -> 'f field Cvar.t\n -> 'f field Cvar.t\n -> (unit, 'f field) t\n\n val assert_square :\n ?label:Base.string\n -> 'f field Cvar.t\n -> 'f field Cvar.t\n -> (unit, 'f field) t\n\n val assert_all :\n ?label:Base.string\n -> ('f field Cvar.t, 'f field) Constraint.t list\n -> (unit, 'f field) t\n\n val assert_equal :\n ?label:Base.string\n -> 'f field Cvar.t\n -> 'f field Cvar.t\n -> (unit, 'f field) t\n\n val direct :\n ('f field Run_state.t -> 'f field Run_state.t * 'a) -> ('a, 'f field) t\n\n val constraint_count :\n ?weight:(('f field Cvar.t, 'f field) Constraint.t -> int)\n -> ?log:(?start:bool -> string -> int -> unit)\n -> (unit -> ('a, 'f field) t)\n -> int\nend\n\nmodule type Extended = sig\n type field\n\n module Types : Types.Types\n\n type 'a t = ('a, field) Types.Checked.t\n\n include\n S\n with module Types := Types\n with type 'f field := field\n and type ('a, 'f) t := ('a, 'f) Types.Checked.t\n\n val run : 'a t -> field Run_state.t -> field Run_state.t * 'a\nend\n\nmodule Unextend (Checked : Extended) :\n S with module Types = Checked.Types with type 'f field = Checked.field =\nstruct\n include (\n Checked :\n S\n with module Types = Checked.Types\n with type 'f field := Checked.field\n and type ('a, 'f) t := ('a, 'f) Checked.Types.Checked.t )\n\n type 'f field = Checked.field\n\n type ('a, 'f) t = ('a, 'f) Types.Checked.t\nend\n","open Core_kernel\n\ntype 'a t = 'a option ref\n\nmodule Make_ref_typ (Checked : Monad_let.S2) = struct\n let typ : ('a t, 'a, _, _) Types.Typ.t =\n Typ\n { var_to_fields = (fun x -> ([||], !x))\n ; var_of_fields = (fun (_, x) -> ref x)\n ; value_to_fields = (fun x -> ([||], Some x))\n ; value_of_fields = (fun (_, x) -> Option.value_exn x)\n ; size_in_field_elements = 0\n ; constraint_system_auxiliary = (fun () -> None)\n ; check = (fun _ -> Checked.return ())\n }\nend\n\nmodule type S = sig\n module Types : Types.Types\n\n type ('a, 'f) checked\n\n type 'f field\n\n type nonrec 'a t = 'a t\n\n val create : ('a, 'f field) As_prover0.t -> ('a t, 'f field) checked\n\n val get : 'a t -> ('a, 'f field) As_prover0.t\n\n val set : 'a t -> 'a -> (unit, 'f field) As_prover0.t\nend\n\nmodule Make\n (Checked : Checked_intf.S)\n (As_prover : As_prover_intf.Basic\n with type 'f field := 'f Checked.field\n and type ('a, 'f) Provider.t =\n ('a, 'f) Checked.Types.Provider.t) :\n S\n with module Types = Checked.Types\n and type ('a, 'f) checked := ('a, 'f) Checked.t\n and type 'f field = 'f Checked.field = struct\n module Types = Checked.Types\n\n type 'f field = 'f Checked.field\n\n type nonrec 'a t = 'a t\n\n let create (x : ('a, 'f Checked.field) As_prover.t) :\n ('a t, 'f Checked.field) Checked.t =\n let r = ref None in\n let open Checked in\n let%map () =\n Checked.as_prover (As_prover.map x ~f:(fun x -> r := Some x))\n in\n r\n\n open As_prover.Let_syntax\n\n let get (r : 'a t) =\n let%map () = As_prover.return () in\n Option.value_exn !r\n\n let set (r : 'a t) x =\n let%map () = As_prover.return () in\n r := Some x\nend\n","type 'v t = 'v\n\nmodule Unsafe = struct\n let create x = x\nend\n","open Core_kernel\nmodule Types0 = Types\n\nmodule Make\n (Backend : Backend_extended.S)\n (Checked : Checked_intf.Extended with type field = Backend.Field.t)\n (As_prover : As_prover0.Extended with type field := Backend.Field.t)\n (Runner : Checked_runner.S\n with module Types := Checked.Types\n with type field := Backend.Field.t\n and type cvar := Backend.Cvar.t\n and type constr := Backend.Constraint.t option\n and type r1cs := Backend.R1CS_constraint_system.t) =\nstruct\n open Backend\n\n let set_constraint_logger = Runner.set_constraint_logger\n\n let clear_constraint_logger = Runner.clear_constraint_logger\n\n type field = Field.t\n\n let field_vec_id : Field.Vector.t Type_equal.Id.t =\n Type_equal.Id.create ~name:\"field-vector\" sexp_of_opaque\n\n let pack_field_vec v =\n Run_state.Vector.T ((module Field.Vector), field_vec_id, v)\n\n let field_vec () = pack_field_vec (Field.Vector.create ())\n\n module Proof_inputs = struct\n type t =\n { public_inputs : Field.Vector.t; auxiliary_inputs : Field.Vector.t }\n end\n\n module Bigint = Bigint\n module Field0 = Field\n module Cvar = Cvar\n module Constraint = Constraint\n\n module Handler = struct\n type t = Request.request -> Request.response\n end\n\n module Runner = Runner\n\n (* TODO-someday: Add pass to unify variables which have an Equal constraint *)\n let constraint_system ~run ~num_inputs ~return_typ:(Types.Typ.Typ return_typ)\n output t : R1CS_constraint_system.t =\n let input = field_vec () in\n let next_auxiliary = ref num_inputs in\n let aux = field_vec () in\n let system = R1CS_constraint_system.create () in\n let state =\n Runner.State.make ~num_inputs ~input ~next_auxiliary ~aux ~system\n ~with_witness:false ()\n in\n let state, res = run t state in\n let res, _ = return_typ.var_to_fields res in\n let output, _ = return_typ.var_to_fields output in\n let _state =\n Array.fold2_exn ~init:state res output ~f:(fun state res output ->\n fst @@ Checked.run (Checked.assert_equal res output) state )\n in\n let auxiliary_input_size = !next_auxiliary - num_inputs in\n R1CS_constraint_system.set_auxiliary_input_size system auxiliary_input_size ;\n system\n\n let auxiliary_input ?system ~run ~num_inputs\n ?(handlers = ([] : Handler.t list)) t0 (input : Field.Vector.t)\n ~return_typ:(Types.Typ.Typ return_typ) ~output : Field.Vector.t * _ =\n let next_auxiliary = ref num_inputs in\n let aux = Field.Vector.create () in\n let handler =\n List.fold ~init:Request.Handler.fail handlers ~f:(fun handler h ->\n Request.Handler.(push handler (create_single h)) )\n in\n let state =\n Runner.State.make ?system ~num_inputs ~input:(pack_field_vec input)\n ~next_auxiliary ~aux:(pack_field_vec aux) ~handler ~with_witness:true ()\n in\n let state, res = run t0 state in\n let res, auxiliary_output_data = return_typ.var_to_fields res in\n let output, _ = return_typ.var_to_fields output in\n let _state =\n Array.fold2_exn ~init:state res output ~f:(fun state res output ->\n Field.Vector.emplace_back input (Runner.get_value state res) ;\n fst @@ Checked.run (Checked.assert_equal res output) state )\n in\n let true_output =\n return_typ.var_of_fields (output, auxiliary_output_data)\n in\n Option.iter system ~f:(fun system ->\n let auxiliary_input_size = !next_auxiliary - num_inputs in\n R1CS_constraint_system.set_auxiliary_input_size system\n auxiliary_input_size ;\n R1CS_constraint_system.finalize system ) ;\n (aux, true_output)\n\n let run_and_check_exn' ~run t0 =\n let num_inputs = 0 in\n let input = field_vec () in\n let next_auxiliary = ref 0 in\n let aux = Field.Vector.create () in\n let system = R1CS_constraint_system.create () in\n let get_value : Cvar.t -> Field.t =\n let get_one v = Field.Vector.get aux v in\n Cvar.eval (`Return_values_will_be_mutated get_one)\n in\n let state =\n Runner.State.make ~num_inputs ~input ~next_auxiliary\n ~aux:(pack_field_vec aux) ~system ~eval_constraints:true\n ~with_witness:true ()\n in\n let _, x = run t0 state in\n (x, get_value)\n\n let run_and_check' ~run t0 =\n match run_and_check_exn' ~run t0 with\n | exception e ->\n Or_error.of_exn ~backtrace:`Get e\n | res ->\n Ok res\n\n let run_and_check_deferred_exn' ~map ~run t0 =\n let num_inputs = 0 in\n let input = field_vec () in\n let next_auxiliary = ref 0 in\n let aux = Field.Vector.create () in\n let system = R1CS_constraint_system.create () in\n let get_value : Cvar.t -> Field.t =\n let get_one v = Field.Vector.get aux v in\n Cvar.eval (`Return_values_will_be_mutated get_one)\n in\n let state =\n Runner.State.make ~num_inputs ~input ~next_auxiliary\n ~aux:(pack_field_vec aux) ~system ~eval_constraints:true\n ~with_witness:true ()\n in\n let res = run t0 state in\n map res ~f:(function _, x -> (x, get_value))\n\n let run_and_check_deferred' ~map ~return ~run t0 =\n match\n run_and_check_deferred_exn'\n ~map:(fun x ~f -> map x ~f:(fun x -> Ok (f x)))\n ~run t0\n with\n | exception e ->\n return (Or_error.of_exn ~backtrace:`Get e)\n | res ->\n res\n\n let run_unchecked ~run t0 =\n let num_inputs = 0 in\n let input = field_vec () in\n let next_auxiliary = ref 0 in\n let aux = field_vec () in\n let state =\n Runner.State.make ~num_inputs ~input ~next_auxiliary ~aux\n ~with_witness:true ()\n in\n match run t0 state with _, x -> x\n\n let run_and_check_exn ~run t =\n let x, get_value = run_and_check_exn' ~run t in\n let x = As_prover.run x get_value in\n x\n\n let run_and_check ~run t =\n Or_error.map (run_and_check' ~run t) ~f:(fun (x, get_value) ->\n let x = As_prover.run x get_value in\n x )\n\n let check_exn ~run t = run_and_check_exn' ~run t |> Fn.const ()\n\n let check ~run t = run_and_check' ~run t |> Result.map ~f:(Fn.const ())\n\n module Run = struct\n let alloc_var next_input () =\n let v = !next_input in\n incr next_input ; Cvar.Unsafe.of_index v\n\n let store_field_elt primary_input next_input x =\n let v = alloc_var next_input () in\n Field.Vector.emplace_back primary_input x ;\n v\n\n let collect_input_constraints :\n type checked input_var input_value.\n int ref\n -> input_typ:\n ( input_var\n , input_value\n , field\n , (unit, field) Checked.Types.Checked.t )\n Types.Typ.typ\n -> return_typ:_ Types.Typ.t\n -> (unit -> input_var -> checked)\n -> _ * (unit -> checked) Checked.t =\n fun next_input ~input_typ:(Typ input_typ) ~return_typ:(Typ return_typ) k ->\n (* allocate variables for the public input and the public output *)\n let open Checked in\n let alloc_input\n { Types0.Typ.var_of_fields\n ; size_in_field_elements\n ; constraint_system_auxiliary\n ; _\n } =\n var_of_fields\n ( Core_kernel.Array.init size_in_field_elements ~f:(fun _ ->\n alloc_var next_input () )\n , constraint_system_auxiliary () )\n in\n let var = alloc_input input_typ in\n let retval = alloc_input return_typ in\n\n (* create constraints to validate the input (using the input [Typ]'s [check]) *)\n let circuit =\n let%bind () = input_typ.check var in\n Checked.return (fun () -> k () var)\n in\n (retval, circuit)\n\n let r1cs_h :\n type a checked input_var input_value retval.\n run:(a, checked) Runner.run\n -> int ref\n -> input_typ:\n ( input_var\n , input_value\n , field\n , (unit, field) Checked.Types.Checked.t )\n Types.Typ.typ\n -> return_typ:(a, retval, _, _) Types.Typ.t\n -> (input_var -> checked)\n -> R1CS_constraint_system.t =\n fun ~run next_input ~input_typ ~return_typ k ->\n (* allocate variables for the public input and the public output *)\n let retval, checked =\n collect_input_constraints next_input ~input_typ ~return_typ (fun () ->\n k )\n in\n\n (* ? *)\n let run_in_run checked state =\n let state, x = Checked.run checked state in\n run x state\n in\n\n (* ? *)\n constraint_system ~run:run_in_run ~num_inputs:!next_input ~return_typ\n retval\n (Checked.map ~f:(fun r -> r ()) checked)\n\n let constraint_system (type a checked input_var) :\n run:(a, checked) Runner.run\n -> input_typ:(input_var, _, _, _) Types.Typ.typ\n -> return_typ:_\n -> (input_var -> checked)\n -> R1CS_constraint_system.t =\n fun ~run ~input_typ ~return_typ k ->\n r1cs_h ~run (ref 0) ~input_typ ~return_typ k\n\n let generate_public_input :\n ('input_var, 'input_value, _, _) Types.Typ.typ\n -> 'input_value\n -> Field.Vector.t =\n fun (Typ { value_to_fields; _ }) value ->\n let primary_input = Field.Vector.create () in\n let next_input = ref 0 in\n let store_field_elt = store_field_elt primary_input next_input in\n let fields, _aux = value_to_fields value in\n let _fields = Array.map ~f:store_field_elt fields in\n primary_input\n\n let conv :\n type r_var r_value.\n (int -> _ -> r_var -> Field.Vector.t -> r_value)\n -> ('input_var, 'input_value, _, _) Types.Typ.t\n -> _ Types.Typ.t\n -> (unit -> 'input_var -> r_var)\n -> 'input_value\n -> r_value =\n fun cont0 input_typ (Typ return_typ) k0 ->\n let primary_input = Field.Vector.create () in\n let next_input = ref 0 in\n let store_field_elt x =\n let v = !next_input in\n incr next_input ;\n Field.Vector.emplace_back primary_input x ;\n Cvar.Unsafe.of_index v\n in\n let (Typ { var_of_fields; value_to_fields; _ }) = input_typ in\n fun value ->\n let fields, aux = value_to_fields value in\n let fields = Array.map ~f:store_field_elt fields in\n let var = var_of_fields (fields, aux) in\n let retval =\n return_typ.var_of_fields\n ( Core_kernel.Array.init return_typ.size_in_field_elements\n ~f:(fun _ -> alloc_var next_input ())\n , return_typ.constraint_system_auxiliary () )\n in\n cont0 !next_input retval (k0 () var) primary_input\n\n let generate_auxiliary_input :\n run:('a, 'checked) Runner.run\n -> input_typ:_ Types.Typ.t\n -> return_typ:(_, _, _, _) Types.Typ.t\n -> ?handlers:Handler.t list\n -> 'k_var\n -> 'k_value =\n fun ~run ~input_typ ~return_typ ?handlers k ->\n conv\n (fun num_inputs output c primary ->\n let auxiliary =\n auxiliary_input ~run ?handlers ~return_typ ~output ~num_inputs c\n primary\n in\n ignore auxiliary )\n input_typ return_typ\n (fun () -> k)\n\n let generate_witness_conv :\n run:('a, 'checked) Runner.run\n -> f:(Proof_inputs.t -> _ -> 'out)\n -> input_typ:_ Types.Typ.t\n -> return_typ:_ Types.Typ.t\n -> ?handlers:Handler.t list\n -> 'k_var\n -> 'k_value =\n fun ~run ~f ~input_typ ~return_typ ?handlers k ->\n conv\n (fun num_inputs output c primary ->\n let auxiliary, output =\n auxiliary_input ~run ?handlers ~return_typ ~output ~num_inputs c\n primary\n in\n let output =\n let (Typ return_typ) = return_typ in\n let fields, aux = return_typ.var_to_fields output in\n let read_cvar =\n let get_one i =\n if i < num_inputs then Field.Vector.get primary i\n else Field.Vector.get auxiliary (i - num_inputs)\n in\n Cvar.eval (`Return_values_will_be_mutated get_one)\n in\n let fields = Array.map ~f:read_cvar fields in\n return_typ.value_of_fields (fields, aux)\n in\n f\n { Proof_inputs.public_inputs = primary\n ; auxiliary_inputs = auxiliary\n }\n output )\n input_typ return_typ\n (fun () -> k)\n\n let generate_witness =\n generate_witness_conv ~f:(fun inputs _output -> inputs)\n end\n\n module Perform = struct\n let generate_witness ~run t ~return_typ k =\n Run.generate_witness ~run t ~return_typ k\n\n let generate_witness_conv ~run ~f t ~return_typ k =\n Run.generate_witness_conv ~run ~f t ~return_typ k\n\n let constraint_system = Run.constraint_system\n\n let run_unchecked = run_unchecked\n\n let run_and_check_exn = run_and_check_exn\n\n let run_and_check = run_and_check\n\n let check_exn = check_exn\n\n let check = check\n end\n\n let conv f spec return_typ k =\n Run.conv (fun _ _ x _ -> f x) spec return_typ (fun () -> k)\n\n let generate_auxiliary_input ~input_typ ~return_typ k =\n Run.generate_auxiliary_input ~run:Checked.run ~input_typ ~return_typ k\n\n let generate_public_input = Run.generate_public_input\n\n let generate_witness ~input_typ ~return_typ k =\n Run.generate_witness ~run:Checked.run ~input_typ ~return_typ k\n\n let generate_witness_conv ~f ~input_typ ~return_typ k =\n Run.generate_witness_conv ~run:Checked.run ~f ~input_typ ~return_typ k\n\n let constraint_system ~input_typ ~return_typ k =\n Run.constraint_system ~run:Checked.run ~input_typ ~return_typ k\n\n let run_unchecked t = run_unchecked ~run:Checked.run t\n\n let run_and_check t = run_and_check ~run:Checked.run t\n\n let run_and_check_exn t = run_and_check_exn ~run:Checked.run t\n\n let check t = check ~run:Checked.run t\n\n let check_exn t = check_exn ~run:Checked.run t\nend\n","open Core_kernel\nopen Types.Typ\n\nmodule Data_spec0 = struct\n (** A list of {!type:Type.Typ.t} values, describing the inputs to a checked\n computation. The type [('r_var, 'r_value, 'k_var, 'k_value, 'field) t]\n represents\n - ['k_value] is the OCaml type of the computation\n - ['r_value] is the OCaml type of the result\n - ['k_var] is the type of the computation within the R1CS\n - ['k_value] is the type of the result within the R1CS\n - ['field] is the field over which the R1CS operates\n - ['checked] is the type of checked computation that verifies the stored\n contents as R1CS variables.\n\n This functions the same as OCaml's default list type:\n{[\n Data_spec.[typ1; typ2; typ3]\n\n Data_spec.(typ1 :: typs)\n\n let open Data_spec in\n [typ1; typ2; typ3; typ4; typ5]\n\n let open Data_spec in\n typ1 :: typ2 :: typs\n\n]}\n all function as you would expect.\n *)\n type ('r_var, 'r_value, 'k_var, 'k_value, 'f, 'checked) data_spec =\n | ( :: ) :\n ('var, 'value, 'f, 'checked) Types.Typ.t\n * ('r_var, 'r_value, 'k_var, 'k_value, 'f, 'checked) data_spec\n -> ( 'r_var\n , 'r_value\n , 'var -> 'k_var\n , 'value -> 'k_value\n , 'f\n , 'checked )\n data_spec\n | [] : ('r_var, 'r_value, 'r_var, 'r_value, 'f, 'checked) data_spec\nend\n\nmodule Intf = struct\n module type S = sig\n type field\n\n type field_var\n\n type 'field checked\n\n module Var : sig\n type t\n\n val size_in_field_elements : int\n\n val to_field_elements : t -> field_var array\n\n val of_field_elements : field_var array -> t\n\n val check : t -> field checked\n end\n\n module Value : sig\n type t\n\n val size_in_field_elements : int\n\n val to_field_elements : t -> field array\n\n val of_field_elements : field array -> t\n end\n end\nend\n\nmodule type Checked_monad = sig\n type ('a, 'f) t\n\n type 'f field\n\n include Monad_let.S2 with type ('a, 'e) t := ('a, 'e) t\n\n module Types : Types.Types\nend\n\nmodule Make (Checked : Checked_monad) = struct\n type ('var, 'value, 'field) t =\n ('var, 'value, 'field, (unit, 'field) Checked.t) Types.Typ.t\n\n type ('var, 'value, 'field) typ = ('var, 'value, 'field) t\n\n module type S = sig\n type field\n\n include\n Intf.S\n with type 'field checked := (unit, 'field) Checked.t\n and type field := field\n and type field_var := field Cvar.t\n end\n\n module Data_spec = struct\n include Data_spec0\n\n type ('r_var, 'r_value, 'k_var, 'k_value, 'f) t =\n ('r_var, 'r_value, 'k_var, 'k_value, 'f, (unit, 'f) Checked.t) data_spec\n\n let size t =\n let rec go :\n type r_var r_value k_var k_value.\n int -> (r_var, r_value, k_var, k_value, 'f) t -> int =\n fun acc t ->\n match t with\n | [] ->\n acc\n | Typ { size_in_field_elements; _ } :: t' ->\n go (acc + size_in_field_elements) t'\n in\n go 0 t\n end\n\n module T = struct\n let unit () : (unit, unit, 'field) t =\n Typ\n { var_to_fields = (fun () -> ([||], ()))\n ; var_of_fields = (fun _ -> ())\n ; value_to_fields = (fun () -> ([||], ()))\n ; value_of_fields = (fun _ -> ())\n ; size_in_field_elements = 0\n ; constraint_system_auxiliary = (fun () -> ())\n ; check = (fun () -> Checked.return ())\n }\n\n let field () : ('field Cvar.t, 'field, 'field) t =\n Typ\n { var_to_fields = (fun f -> ([| f |], ()))\n ; var_of_fields = (fun (fields, _) -> fields.(0))\n ; value_to_fields = (fun f -> ([| f |], ()))\n ; value_of_fields = (fun (fields, _) -> fields.(0))\n ; size_in_field_elements = 1\n ; constraint_system_auxiliary = (fun () -> ())\n ; check = (fun _ -> Checked.return ())\n }\n\n module Internal = struct\n let snarkless value : _ t =\n Typ\n { var_to_fields = (fun _ -> ([||], ()))\n ; var_of_fields = (fun _ -> value)\n ; value_to_fields =\n (fun value' ->\n assert (phys_equal value value') ;\n ([||], ()) )\n ; value_of_fields = (fun _ -> value)\n ; size_in_field_elements = 0\n ; constraint_system_auxiliary = (fun () -> ())\n ; check = (fun _ -> Checked.return ())\n }\n\n module Ref_typ = As_prover_ref.Make_ref_typ (Checked)\n\n let ref () = Ref_typ.typ\n end\n\n let transport (type var value1 value2 field)\n (Typ\n { var_to_fields\n ; var_of_fields\n ; value_to_fields\n ; value_of_fields\n ; size_in_field_elements\n ; constraint_system_auxiliary\n ; check\n } :\n (var, value1, field) t ) ~(there : value2 -> value1)\n ~(back : value1 -> value2) : (var, value2, field) t =\n Typ\n { var_to_fields\n ; var_of_fields\n ; value_to_fields = (fun x -> value_to_fields (there x))\n ; value_of_fields = (fun x -> back (value_of_fields x))\n ; size_in_field_elements\n ; constraint_system_auxiliary\n ; check\n }\n\n let transport_var (type var1 var2 value field)\n (Typ\n { var_to_fields\n ; var_of_fields\n ; value_to_fields\n ; value_of_fields\n ; size_in_field_elements\n ; constraint_system_auxiliary\n ; check\n } :\n (var1, value, field) t ) ~(there : var2 -> var1) ~(back : var1 -> var2)\n : (var2, value, field) t =\n Typ\n { var_to_fields = (fun x -> var_to_fields (there x))\n ; var_of_fields = (fun x -> back (var_of_fields x))\n ; value_to_fields\n ; value_of_fields\n ; size_in_field_elements\n ; constraint_system_auxiliary\n ; check = (fun x -> check (there x))\n }\n\n let list ~length\n (Typ\n { var_to_fields\n ; var_of_fields\n ; value_to_fields\n ; value_of_fields\n ; size_in_field_elements\n ; constraint_system_auxiliary\n ; check\n } :\n ('elt_var, 'elt_value, 'field) t ) :\n ('elt_var list, 'elt_value list, 'field) t =\n (* NB: We store the size_in_field_elements of each in the auxiliary\n data, to allow for 'reads' of e.g. list of lists of different\n lengths.\n *)\n Typ\n { var_to_fields =\n (fun ts ->\n let rec go ts ((fieldss, auxes) as acc) =\n match ts with\n | [] ->\n acc\n | t :: tl ->\n let fields, aux = var_to_fields t in\n let acc =\n ( Array.append fieldss fields\n , (aux, Array.length fields) :: auxes )\n in\n go tl acc\n in\n go ts ([||], []) )\n ; var_of_fields =\n (fun (fields, auxes) ->\n let vars, _ =\n List.fold\n ~init:([], Array.length fields)\n auxes\n ~f:(fun (vars, end_pos) (aux, num_fields) ->\n let end_pos = end_pos - num_fields in\n let var =\n var_of_fields\n (Array.sub ~pos:end_pos ~len:num_fields fields, aux)\n in\n (var :: vars, end_pos) )\n in\n vars )\n ; value_to_fields =\n (fun ts ->\n let rec go ts ((fieldss, auxes) as acc) =\n match ts with\n | [] ->\n acc\n | t :: tl ->\n let fields, aux = value_to_fields t in\n let acc =\n ( Array.append fieldss fields\n , (aux, Array.length fields) :: auxes )\n in\n go tl acc\n in\n go ts ([||], []) )\n ; value_of_fields =\n (fun (fields, auxes) ->\n let vars, _ =\n List.fold\n ~init:([], Array.length fields)\n auxes\n ~f:(fun (vars, end_pos) (aux, num_fields) ->\n let end_pos = end_pos - num_fields in\n let var =\n value_of_fields\n (Array.sub ~pos:end_pos ~len:num_fields fields, aux)\n in\n (var :: vars, end_pos) )\n in\n vars )\n ; size_in_field_elements = length * size_in_field_elements\n ; constraint_system_auxiliary =\n (fun () ->\n List.init length ~f:(fun _ ->\n (constraint_system_auxiliary (), size_in_field_elements) ) )\n ; check = (fun ts -> Checked.all_unit (List.map ts ~f:check))\n }\n\n let array ~length typ =\n list ~length typ\n |> transport ~there:Array.to_list ~back:Array.of_list\n |> transport_var ~there:Array.to_list ~back:Array.of_list\n\n let hlist (type k_var k_value)\n (spec0 : (unit, unit, k_var, k_value, 'f) Data_spec.t) :\n ((unit, k_var) H_list.t, (unit, k_value) H_list.t, 'f) t =\n let rec go :\n type k_var k_value.\n (unit, unit, k_var, k_value, 'f) Data_spec.t\n -> ((unit, k_var) H_list.t, (unit, k_value) H_list.t, 'f) t =\n fun spec0 ->\n let open H_list in\n match spec0 with\n | [] ->\n Typ\n { var_to_fields = (fun [] -> ([||], ()))\n ; var_of_fields = (fun _ -> [])\n ; value_to_fields = (fun [] -> ([||], ()))\n ; value_of_fields = (fun _ -> [])\n ; size_in_field_elements = 0\n ; constraint_system_auxiliary = (fun () -> ())\n ; check = (fun [] -> Checked.return ())\n }\n | Typ\n { var_to_fields\n ; var_of_fields\n ; value_to_fields\n ; value_of_fields\n ; size_in_field_elements\n ; constraint_system_auxiliary\n ; check\n }\n :: spec0 ->\n let (Typ typ) = go spec0 in\n let open H_list in\n Typ\n { var_to_fields =\n (fun (x :: tl) ->\n let fields, aux = var_to_fields x in\n let fieldss, auxes = typ.var_to_fields tl in\n ( Array.append fields fieldss\n , (aux, Array.length fields, auxes) ) )\n ; var_of_fields =\n (fun (fields, (hd, len, tl)) ->\n let var =\n var_of_fields (Array.sub ~pos:0 ~len fields, hd)\n in\n let tl =\n typ.var_of_fields\n ( Array.sub ~pos:len\n ~len:(Array.length fields - len)\n fields\n , tl )\n in\n var :: tl )\n ; value_to_fields =\n (fun (x :: tl) ->\n let fields, aux = value_to_fields x in\n let fieldss, auxes = typ.value_to_fields tl in\n ( Array.append fields fieldss\n , (aux, Array.length fields, auxes) ) )\n ; value_of_fields =\n (fun (fields, (hd, len, tl)) ->\n let value =\n value_of_fields (Array.sub ~pos:0 ~len fields, hd)\n in\n let tl =\n typ.value_of_fields\n ( Array.sub ~pos:len\n ~len:(Array.length fields - len)\n fields\n , tl )\n in\n value :: tl )\n ; size_in_field_elements =\n size_in_field_elements + typ.size_in_field_elements\n ; constraint_system_auxiliary =\n (fun () ->\n let hd = constraint_system_auxiliary () in\n let auxes = typ.constraint_system_auxiliary () in\n (hd, size_in_field_elements, auxes) )\n ; check =\n (fun (x :: tl) ->\n Checked.bind (check x) ~f:(fun () -> typ.check tl) )\n }\n in\n go spec0\n\n let tuple2 typ1 typ2 =\n let open H_list in\n hlist [ typ1; typ2 ]\n |> transport\n ~there:(fun (a, b) -> [ a; b ])\n ~back:(fun ([ a; b ] : (unit, _ -> _ -> unit) H_list.t) -> (a, b))\n |> transport_var\n ~there:(fun (a, b) -> [ a; b ])\n ~back:(fun ([ a; b ] : (unit, _ -> _ -> unit) H_list.t) -> (a, b))\n\n let ( * ) = tuple2\n\n let tuple3 typ1 typ2 typ3 =\n let open H_list in\n hlist [ typ1; typ2; typ3 ]\n |> transport\n ~there:(fun (a, b, c) -> [ a; b; c ])\n ~back:(fun ([ a; b; c ] : (unit, _ -> _ -> _ -> unit) H_list.t) ->\n (a, b, c) )\n |> transport_var\n ~there:(fun (a, b, c) -> [ a; b; c ])\n ~back:(fun ([ a; b; c ] : (unit, _ -> _ -> _ -> unit) H_list.t) ->\n (a, b, c) )\n\n let tuple4 typ1 typ2 typ3 typ4 =\n let open H_list in\n hlist [ typ1; typ2; typ3; typ4 ]\n |> transport\n ~there:(fun (a, b, c, d) -> [ a; b; c; d ])\n ~back:(fun ([ a; b; c; d ] :\n (unit, _ -> _ -> _ -> _ -> unit) H_list.t ) ->\n (a, b, c, d) )\n |> transport_var\n ~there:(fun (a, b, c, d) -> [ a; b; c; d ])\n ~back:(fun ([ a; b; c; d ] :\n (unit, _ -> _ -> _ -> _ -> unit) H_list.t ) ->\n (a, b, c, d) )\n\n let tuple5 typ1 typ2 typ3 typ4 typ5 =\n let open H_list in\n hlist [ typ1; typ2; typ3; typ4; typ5 ]\n |> transport\n ~there:(fun (a, b, c, d, e) -> [ a; b; c; d; e ])\n ~back:(fun ([ a; b; c; d; e ] :\n (unit, _ -> _ -> _ -> _ -> _ -> unit) H_list.t ) ->\n (a, b, c, d, e) )\n |> transport_var\n ~there:(fun (a, b, c, d, e) -> [ a; b; c; d; e ])\n ~back:(fun ([ a; b; c; d; e ] :\n (unit, _ -> _ -> _ -> _ -> _ -> unit) H_list.t ) ->\n (a, b, c, d, e) )\n\n let tuple6 typ1 typ2 typ3 typ4 typ5 typ6 =\n let open H_list in\n hlist [ typ1; typ2; typ3; typ4; typ5; typ6 ]\n |> transport\n ~there:(fun (a, b, c, d, e, f) -> [ a; b; c; d; e; f ])\n ~back:(fun ([ a; b; c; d; e; f ] :\n (unit, _ -> _ -> _ -> _ -> _ -> _ -> unit) H_list.t ) ->\n (a, b, c, d, e, f) )\n |> transport_var\n ~there:(fun (a, b, c, d, e, f) -> [ a; b; c; d; e; f ])\n ~back:(fun ([ a; b; c; d; e; f ] :\n (unit, _ -> _ -> _ -> _ -> _ -> _ -> unit) H_list.t ) ->\n (a, b, c, d, e, f) )\n\n let of_hlistable (spec : (unit, unit, 'k_var, 'k_value, 'f) Data_spec.t)\n ~(var_to_hlist : 'var -> (unit, 'k_var) H_list.t)\n ~(var_of_hlist : (unit, 'k_var) H_list.t -> 'var)\n ~(value_to_hlist : 'value -> (unit, 'k_value) H_list.t)\n ~(value_of_hlist : (unit, 'k_value) H_list.t -> 'value) :\n ('var, 'value, 'f) t =\n hlist spec\n |> transport ~there:value_to_hlist ~back:value_of_hlist\n |> transport_var ~there:var_to_hlist ~back:var_of_hlist\n end\n\n include T\nend\n\ninclude Make (Checked_runner.Simple)\n","open Core_kernel\n\n(** Helpers for operating over a sequence of data (currently, either an array\n or a list) inside of a monad.\n*)\nmodule type S = sig\n type 'a monad\n\n type 'a t\n\n type boolean\n\n val foldi : 'a t -> init:'b -> f:(int -> 'b -> 'a -> 'b monad) -> 'b monad\n\n val fold : 'a t -> init:'b -> f:('b -> 'a -> 'b monad) -> 'b monad\n\n val fold_map :\n 'a t -> init:'b -> f:('b -> 'a -> ('b * 'c) monad) -> ('b * 'c t) monad\n\n val exists : 'a t -> f:('a -> boolean monad) -> boolean monad\n\n val existsi : 'a t -> f:(int -> 'a -> boolean monad) -> boolean monad\n\n val for_all : 'a t -> f:('a -> boolean monad) -> boolean monad\n\n val for_alli : 'a t -> f:(int -> 'a -> boolean monad) -> boolean monad\n\n val all : 'a monad t -> 'a t monad\n\n val all_unit : unit monad t -> unit monad\n\n val init : int -> f:(int -> 'a monad) -> 'a t monad\n\n val iter : 'a t -> f:('a -> unit monad) -> unit monad\n\n val iteri : 'a t -> f:(int -> 'a -> unit monad) -> unit monad\n\n val map : 'a t -> f:('a -> 'b monad) -> 'b t monad\n\n val mapi : 'a t -> f:(int -> 'a -> 'b monad) -> 'b t monad\nend\n\nmodule List\n (M : Monad_let.S) (Bool : sig\n type t\n\n val any : t list -> t M.t\n\n val all : t list -> t M.t\n end) :\n S\n with type 'a t = 'a list\n and type 'a monad := 'a M.t\n and type boolean := Bool.t = struct\n type 'a t = 'a list\n\n open M.Let_syntax\n\n let foldi t ~init ~f =\n let rec go i acc = function\n | [] ->\n return acc\n | x :: xs ->\n let%bind acc = f i acc x in\n go (i + 1) acc xs\n in\n go 0 init t\n\n let fold t ~init ~f = foldi t ~init ~f:(fun _ acc x -> f acc x)\n\n let fold_map xs ~init ~f =\n let%map res, ys =\n fold xs ~init:(init, []) ~f:(fun (acc, ys) x ->\n let%map acc, y = f acc x in\n (acc, y :: ys) )\n in\n (res, List.rev ys)\n\n let all = M.all\n\n let all_unit = M.all_unit\n\n let init n ~f =\n let rec go acc i =\n if i < 0 then return acc\n else\n let%bind x = f i in\n go (x :: acc) (i - 1)\n in\n go [] (n - 1)\n\n let iteri t ~f =\n let rec go i = function\n | [] ->\n return ()\n | x :: xs ->\n let%bind () = f i x in\n go (i + 1) xs\n in\n go 0 t\n\n let iter t ~f = iteri t ~f:(fun _i x -> f x)\n\n let mapi t ~f =\n let rec go i acc = function\n | [] ->\n return (List.rev acc)\n | x :: xs ->\n let%bind y = f i x in\n go (i + 1) (y :: acc) xs\n in\n go 0 [] t\n\n let map t ~f = mapi t ~f:(fun _i x -> f x)\n\n (* The following functions use [map] to evaluate [f] on every element, since\n * we can't shortcut in the snark -- every constraint is either always\n present or always absent -- so we need to apply [f] to all of them\n * [Bool.any]/[Bool.all] operate by calculating the sum of the array,\n which requires an R1CS variable representing each element to be\n available.\n *)\n\n let existsi t ~f = mapi t ~f >>= Bool.any\n\n let exists t ~f = map t ~f >>= Bool.any\n\n let for_alli t ~f = mapi t ~f >>= Bool.all\n\n let for_all t ~f = map t ~f >>= Bool.all\nend\n\nmodule Array\n (M : Monad_let.S) (Bool : sig\n type t\n\n val any : t array -> t M.t\n\n val all : t array -> t M.t\n end) :\n S\n with type 'a t = 'a array\n and type 'a monad := 'a M.t\n and type boolean := Bool.t = struct\n type 'a t = 'a array\n\n open M.Let_syntax\n\n let foldi t ~init ~f =\n Array.foldi t ~init:(M.return init) ~f:(fun i acc x ->\n let%bind acc = acc in\n f i acc x )\n\n let fold t ~init ~f =\n Array.fold t ~init:(M.return init) ~f:(fun acc x ->\n let%bind acc = acc in\n f acc x )\n\n let iteri t ~f = foldi t ~init:() ~f:(fun i () x -> f i x)\n\n let iter t ~f = fold t ~init:() ~f:(fun () x -> f x)\n\n let init n ~f =\n let rec go arr i =\n if i < 0 then M.return arr\n else\n let%bind x = f i in\n Array.unsafe_set arr i x ;\n go arr (i - 1)\n in\n if n < 0 then invalid_arg \"Monad_sequence.Array.init\"\n else if n = 0 then M.return [||]\n else\n let%bind last = f (n - 1) in\n let arr = Array.create ~len:n last in\n go arr (n - 2)\n\n let mapi t ~f = init (Array.length t) ~f:(fun i -> f i (Array.unsafe_get t i))\n\n let map t ~f = mapi t ~f:(fun _i x -> f x)\n\n let fold_map t ~init ~f =\n let res = ref init in\n let%map t =\n map t ~f:(fun x ->\n let%map acc, y = f !res x in\n res := acc ;\n y )\n in\n (!res, t)\n\n let all = map ~f:(fun x -> x)\n\n let all_unit = iter ~f:(fun x -> x)\n\n (* The following functions use [map] to evaluate [f] on every element, since\n * we can't shortcut in the snark -- every constraint is either always\n present or always absent -- so we need to apply [f] to all of them\n * [Bool.any]/[Bool.all] operate by calculating the sum of the array,\n which requires an R1CS variable representing each element to be\n available.\n *)\n\n let existsi t ~f = mapi t ~f >>= Bool.any\n\n let exists t ~f = map t ~f >>= Bool.any\n\n let for_alli t ~f = mapi t ~f >>= Bool.all\n\n let for_all t ~f = map t ~f >>= Bool.all\nend\n","open Core_kernel\n\nlet int_to_bits ~length n =\n let ith_bit i = (n lsr i) land 1 = 1 in\n List.init length ~f:ith_bit\n\nlet int_of_bits bs =\n List.foldi bs ~init:0 ~f:(fun i acc b -> if b then acc + (1 lsl i) else acc)\n\nmodule Make\n (Impl : Snark_intf.Basic) (M : sig\n type t [@@deriving enum]\n end) =\nstruct\n open Impl\n\n (* TODO: Make this throw when the elt is too big *)\n let field_to_int x = int_of_bits (List.take (Field.unpack x) 62)\n\n open M\n\n let _unused = M.min (* generate unused variable error *)\n\n let bit_length =\n let n = Int.ceil_log2 (M.max + 1) in\n assert (n < Field.size_in_bits) ;\n n\n\n type var = Field.Var.t\n\n let to_field t = Field.of_int (to_enum t)\n\n let of_field x = Option.value_exn (of_enum (field_to_int x))\n\n let assert_equal x y = Field.Checked.Assert.equal x y\n\n let typ : (var, t) Typ.t =\n let check =\n if M.max = 1 then fun x -> assert_ (Constraint.boolean x)\n else fun x ->\n Field.Checked.Assert.lte ~bit_length x\n (constant Field.typ (Field.of_int M.max))\n in\n let (Typ typ) = Typ.transport Field.typ ~there:to_field ~back:of_field in\n Typ { typ with check }\n\n let var_to_bits : var -> Boolean.var list Checked.t =\n Field.Checked.unpack ~length:bit_length\n\n let to_bits t = int_to_bits ~length:bit_length (to_enum t)\n\n let if_ b ~(then_ : var) ~(else_ : var) = Field.Checked.if_ b ~then_ ~else_\n\n let var t : var = constant Field.typ (to_field t)\n\n let ( = ) = Field.Checked.equal\nend\n\nmodule Run = struct\n module Make\n (Impl : Snark_intf.Run_basic) (M : sig\n type t [@@deriving enum]\n end) =\n struct\n open Impl\n include Make (Impl.Internal_Basic) (M)\n\n let assert_equal x y = run_checked (assert_equal x y)\n\n let var_to_bits x = run_checked (var_to_bits x)\n\n let if_ x ~then_ ~else_ = run_checked (if_ x ~then_ ~else_)\n\n let ( = ) x y = run_checked (x = y)\n end\nend\n","module Bignum_bigint = Bigint\nopen Core_kernel\n\nlet pow2 n = Bignum_bigint.(pow (of_int 2) (of_int n))\n\nlet bigint_num_bits =\n let rec go acc i =\n if Bignum_bigint.(acc = zero) then i\n else go (Bignum_bigint.shift_right acc 1) (i + 1)\n in\n fun n -> go n 0\n\nmodule Make (Impl : Snark_intf.Basic) = struct\n open Impl\n open Let_syntax\n\n type t =\n { upper_bound : Bignum_bigint.t\n ; lower_bound : Bignum_bigint.t\n ; var : Field.Var.t\n ; bits : Boolean.var list option\n }\n\n let two_to_the n =\n let rec go acc i = if i <= 0 then acc else go (Field.add acc acc) (i - 1) in\n go Field.one n\n\n let to_bits { var; bits; upper_bound; lower_bound = _ } =\n let length = bigint_num_bits upper_bound in\n with_label \"Number.to_bits\" (fun () ->\n match bits with\n | Some bs ->\n return (List.take bs length)\n | None ->\n Field.Checked.unpack var ~length )\n\n let of_bits bs =\n let n = List.length bs in\n assert (n < Field.size_in_bits) ;\n { upper_bound = Bignum_bigint.(pow2 n - one)\n ; lower_bound = Bignum_bigint.zero\n ; var = Field.Var.pack bs\n ; bits = Some bs\n }\n\n let mul_pow_2 n (`Two_to_the k) =\n let%map bits = to_bits n in\n let multiplied = List.init k ~f:(fun _ -> Boolean.false_) @ bits in\n let upper_bound =\n Bignum_bigint.(n.upper_bound * pow (of_int 2) (of_int k))\n in\n assert (Bignum_bigint.(upper_bound < Field.size)) ;\n { upper_bound\n ; lower_bound = Bignum_bigint.(n.lower_bound * pow (of_int 2) (of_int k))\n ; var = Field.Var.pack multiplied\n ; bits = Some multiplied\n }\n\n let div_pow_2 n (`Two_to_the k) =\n let%map bits = to_bits n in\n let divided = List.drop bits k in\n let divided_of_bits = of_bits divided in\n { upper_bound =\n Bignum_bigint.(divided_of_bits.upper_bound / pow (of_int 2) (of_int k))\n ; lower_bound =\n Bignum_bigint.(divided_of_bits.lower_bound / pow (of_int 2) (of_int k))\n ; var = divided_of_bits.var\n ; bits = divided_of_bits.bits\n }\n\n let clamp_to_n_bits t n =\n assert (n < Field.size_in_bits) ;\n with_label \"Number.clamp_to_n_bits\" (fun () ->\n let k = pow2 n in\n if Bignum_bigint.(t.upper_bound < k) then return t\n else\n let%bind bs = to_bits t in\n let bs' = List.take bs n in\n let g = Field.Var.project bs' in\n let%bind fits = Field.Checked.equal t.var g in\n let%map r =\n Field.Checked.if_ fits ~then_:g\n ~else_:(constant Field.typ Field.(sub (two_to_the n) one))\n in\n { upper_bound = Bignum_bigint.(k - one)\n ; lower_bound = t.lower_bound\n ; var = r\n ; bits = None\n } )\n\n let ( < ) x y =\n let open Bignum_bigint in\n (*\n x [ ]\n y [ ]\n\n x [ ]\n y [ ]\n *)\n with_label \"Number.(<)\" (fun () ->\n if x.upper_bound < y.lower_bound then return Boolean.true_\n else if x.lower_bound >= y.upper_bound then return Boolean.false_\n else\n let bit_length =\n Int.max\n (bigint_num_bits x.upper_bound)\n (bigint_num_bits y.upper_bound)\n in\n let%map { less; _ } = Field.Checked.compare ~bit_length x.var y.var in\n less )\n\n let ( <= ) x y =\n let open Bignum_bigint in\n (*\n x [ ]\n y [ ]\n\n x [ ]\n y [ ]\n *)\n with_label \"Number.(<=)\" (fun () ->\n if x.upper_bound <= y.lower_bound then return Boolean.true_\n else if x.lower_bound > y.upper_bound then return Boolean.false_\n else\n let bit_length =\n Int.max\n (bigint_num_bits x.upper_bound)\n (bigint_num_bits y.upper_bound)\n in\n let%map { less_or_equal; _ } =\n Field.Checked.compare ~bit_length x.var y.var\n in\n less_or_equal )\n\n let ( > ) x y = y < x\n\n let ( >= ) x y = y <= x\n\n let ( = ) x y =\n (* TODO: Have \"short circuiting\" for efficiency as above. *)\n Field.Checked.equal x.var y.var\n\n let to_var { var; _ } = var\n\n let constant x =\n let tick_n = Bigint.of_field x in\n let n = Bigint.to_bignum_bigint tick_n in\n { upper_bound = n\n ; lower_bound = n\n ; var = constant Field.typ x\n ; bits =\n Some\n (List.init (bigint_num_bits n) ~f:(fun i ->\n constant Boolean.typ (Bigint.test_bit tick_n i) ) )\n }\n\n let one = constant Field.one\n\n let zero = constant Field.zero\n\n let of_pow_2 (`Two_to_the k) = constant (Field.of_int (Int.pow 2 k))\n\n let if_ b ~then_ ~else_ =\n let%map var = Field.Checked.if_ b ~then_:then_.var ~else_:else_.var in\n let open Bignum_bigint in\n { upper_bound = max then_.upper_bound else_.upper_bound\n ; lower_bound = min then_.lower_bound else_.lower_bound\n ; var\n ; bits = None\n }\n\n let ( + ) x y =\n let open Bignum_bigint in\n let upper_bound = x.upper_bound + y.upper_bound in\n if upper_bound < Field.size then\n { upper_bound\n ; lower_bound = x.lower_bound + y.lower_bound\n ; var = Field.Var.add x.var y.var\n ; bits = None\n }\n else\n failwithf \"Number.+: Potential overflow: (%s + %s > Field.size)\"\n (to_string x.upper_bound) (to_string y.upper_bound) ()\n\n (* Compute (n, k) -> ceil(n / 2^k) using the identity\n\n ceil(n / m)\n =\n if n % m = 0\n then floor(n / m)\n else floor(n / m) + 1\n =\n if m * floor(n / m) = n\n then floor(n / m)\n else floor(n / m) + 1\n *)\n let ceil_div_pow_2 n m =\n let%bind floor_div = div_pow_2 n m in\n let%bind m_divides_n = mul_pow_2 floor_div m >>= ( = ) n in\n if_ m_divides_n ~then_:floor_div ~else_:(floor_div + one)\n\n let ( - ) x y =\n let open Bignum_bigint in\n (* x_upper_bound >= x >= x_lower_bound >= y_upper_bound >= y >= y_lower_bound *)\n if x.lower_bound >= y.upper_bound then\n { upper_bound = x.upper_bound - y.lower_bound\n ; lower_bound = x.lower_bound - y.upper_bound\n ; var = Field.Var.sub x.var y.var\n ; bits = None\n }\n else\n failwithf \"Number.-: Potential underflow (%s < %s)\"\n (to_string x.lower_bound) (to_string y.upper_bound) ()\n\n let ( * ) x y =\n let open Bignum_bigint in\n with_label \"Number.(*)\" (fun () ->\n let upper_bound = x.upper_bound * y.upper_bound in\n if upper_bound < Field.size then\n let%map var = Field.Checked.mul x.var y.var in\n { upper_bound\n ; lower_bound = x.lower_bound * y.lower_bound\n ; var\n ; bits = None\n }\n else\n failwithf \"Number.*: Potential overflow: (%s * %s > Field.size)\"\n (to_string x.upper_bound) (to_string y.upper_bound) () )\n\n (* x mod n = x - n * floor(x / n) *)\n let mod_pow_2 x n =\n let%bind x_div_n = div_pow_2 x n in\n let%map n_x_div_n = mul_pow_2 x_div_n n in\n let res = x - n_x_div_n in\n { res with\n lower_bound = Bignum_bigint.zero\n ; upper_bound =\n (let (`Two_to_the k) = n in\n Bignum_bigint.(pow (of_int 2) (of_int k)) )\n }\n\n let min x y =\n let%bind less = x < y in\n if_ less ~then_:x ~else_:y\n\n let max x y =\n let%bind less = x < y in\n if_ less ~then_:y ~else_:x\nend\n\nmodule Run = struct\n module Make (Impl : Snark_intf.Run_basic) = struct\n open Impl\n include Make (Impl.Internal_Basic)\n\n let ( * ) x y = run_checked (x * y)\n\n let if_ x ~then_ ~else_ = run_checked (if_ x ~then_ ~else_)\n\n let ( < ) x y = run_checked (x < y)\n\n let ( > ) x y = run_checked (x > y)\n\n let ( <= ) x y = run_checked (x <= y)\n\n let ( >= ) x y = run_checked (x >= y)\n\n let ( = ) x y = run_checked (x = y)\n\n let min x y = run_checked (min x y)\n\n let max x y = run_checked (max x y)\n\n let to_bits x = run_checked (to_bits x)\n\n let div_pow_2 x y = run_checked (div_pow_2 x y)\n\n let ceil_div_pow_2 x y = run_checked (ceil_div_pow_2 x y)\n\n let mul_pow_2 x y = run_checked (mul_pow_2 x y)\n\n let mod_pow_2 x y = run_checked (mod_pow_2 x y)\n\n let clamp_to_n_bits x y = run_checked (clamp_to_n_bits x y)\n end\nend\n","include Snark0\nmodule Backend_intf = Backend_intf\nmodule Merkle_tree = Merkle_tree\n","(* shapes.ml -- registry of Bin_prot shapes *)\n\nopen Core_kernel\nmodule Shape_tbl = Hashtbl.Make (Base.String)\n\nlet shape_tbl : (Bin_prot.Shape.t * string) Shape_tbl.t = Shape_tbl.create ()\n\nlet find path_to_type = Shape_tbl.find shape_tbl path_to_type\n\nlet iteri ~f = Shape_tbl.iteri shape_tbl ~f\n\nlet equal_shapes shape1 shape2 =\n let canonical1 = Bin_prot.Shape.eval shape1 in\n let canonical2 = Bin_prot.Shape.eval shape2 in\n Bin_prot.Shape.Canonical.compare canonical1 canonical2 = 0\n\nlet register path_to_type (shape : Bin_prot.Shape.t) (ty_decl : string) =\n match Shape_tbl.add shape_tbl ~key:path_to_type ~data:(shape, ty_decl) with\n | `Ok ->\n ()\n | `Duplicate -> (\n (* versioned types inside functors that are called more than\n once will yield duplicates; OK if the shapes are the same\n *)\n match find path_to_type with\n | Some (shape', _ty_decl) ->\n if not (equal_shapes shape shape') then\n failwithf \"Different type shapes at path %s\" path_to_type ()\n else ()\n | None ->\n failwithf \"Expected to find registered shape at path %s\" path_to_type\n () )\n","(*----------------------------------------------------------------------------\n Copyright (c) 2017 Inhabited Type LLC.\n\n All rights reserved.\n\n Redistribution and use in source and binary forms, with or without\n modification, are permitted provided that the following conditions\n are met:\n\n 1. Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n\n 2. Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n\n 3. Neither the name of the author nor the names of his contributors\n may be used to endorse or promote products derived from this software\n without specific prior written permission.\n\n THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS ``AS IS'' AND ANY EXPRESS\n OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\n WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR\n ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\n DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS\n OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\n HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,\n STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN\n ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n POSSIBILITY OF SUCH DAMAGE.\n ----------------------------------------------------------------------------*)\n\ntype t =\n { mutable parser_committed_bytes : int\n ; client_committed_bytes : int\n ; off : int\n ; len : int\n ; buffer : Bigstringaf.t\n }\n\nlet create buffer ~off ~len ~committed_bytes =\n { parser_committed_bytes = committed_bytes\n ; client_committed_bytes = committed_bytes\n ; off\n ; len\n ; buffer }\n\nlet length t = t.client_committed_bytes + t.len\nlet client_committed_bytes t = t.client_committed_bytes\nlet parser_committed_bytes t = t.parser_committed_bytes\n\nlet committed_bytes_discrepancy t = t.parser_committed_bytes - t.client_committed_bytes\nlet bytes_for_client_to_commit t = committed_bytes_discrepancy t\n\nlet parser_uncommitted_bytes t = t.len - bytes_for_client_to_commit t\n\nlet invariant t =\n assert (parser_committed_bytes t + parser_uncommitted_bytes t = length t);\n assert (parser_committed_bytes t - client_committed_bytes t = bytes_for_client_to_commit t);\n;;\n\nlet offset_in_buffer t pos =\n t.off + pos - t.client_committed_bytes\n\nlet apply t pos len ~f =\n let off = offset_in_buffer t pos in\n f t.buffer ~off ~len\n\nlet unsafe_get_char t pos =\n let off = offset_in_buffer t pos in\n Bigstringaf.unsafe_get t.buffer off\n\nlet unsafe_get_int16_le t pos =\n let off = offset_in_buffer t pos in\n Bigstringaf.unsafe_get_int16_le t.buffer off\n\nlet unsafe_get_int32_le t pos =\n let off = offset_in_buffer t pos in\n Bigstringaf.unsafe_get_int32_le t.buffer off\n\nlet unsafe_get_int64_le t pos =\n let off = offset_in_buffer t pos in\n Bigstringaf.unsafe_get_int64_le t.buffer off\n\nlet unsafe_get_int16_be t pos =\n let off = offset_in_buffer t pos in\n Bigstringaf.unsafe_get_int16_be t.buffer off\n\nlet unsafe_get_int32_be t pos =\n let off = offset_in_buffer t pos in\n Bigstringaf.unsafe_get_int32_be t.buffer off\n\nlet unsafe_get_int64_be t pos =\n let off = offset_in_buffer t pos in\n Bigstringaf.unsafe_get_int64_be t.buffer off\n\nlet count_while t pos ~f =\n let buffer = t.buffer in\n let off = offset_in_buffer t pos in\n let i = ref off in\n let limit = t.off + t.len in\n while !i < limit && f (Bigstringaf.unsafe_get buffer !i) do\n incr i\n done;\n !i - off\n;;\n\nlet commit t pos =\n t.parser_committed_bytes <- pos\n;;\n","module State = struct\n type 'a t =\n | Partial of 'a partial\n | Lazy of 'a t Lazy.t\n | Done of int * 'a\n | Fail of int * string list * string\n\n and 'a partial =\n { committed : int\n ; continue : Bigstringaf.t -> off:int -> len:int -> More.t -> 'a t }\n\nend\ntype 'a with_state = Input.t -> int -> More.t -> 'a\n\ntype 'a failure = (string list -> string -> 'a State.t) with_state\ntype ('a, 'r) success = ('a -> 'r State.t) with_state\n\ntype 'a t =\n { run : 'r. ('r failure -> ('a, 'r) success -> 'r State.t) with_state }\n\nlet fail_k input pos _ marks msg =\n State.Fail(pos - Input.client_committed_bytes input, marks, msg)\nlet succeed_k input pos _ v =\n State.Done(pos - Input.client_committed_bytes input, v)\n\nlet rec to_exported_state = function\n | State.Partial {committed;continue} ->\n Exported_state.Partial\n { committed\n ; continue =\n fun bs ~off ~len more ->\n to_exported_state (continue bs ~off ~len more)}\n | State.Done (i,x) -> Exported_state.Done (i,x)\n | State.Fail (i, sl, s) -> Exported_state.Fail (i, sl, s)\n | State.Lazy x -> to_exported_state (Lazy.force x)\n\nlet parse p =\n let input = Input.create Bigstringaf.empty ~committed_bytes:0 ~off:0 ~len:0 in\n to_exported_state (p.run input 0 Incomplete fail_k succeed_k)\n\nlet parse_bigstring p input =\n let input = Input.create input ~committed_bytes:0 ~off:0 ~len:(Bigstringaf.length input) in\n Exported_state.state_to_result (to_exported_state (p.run input 0 Complete fail_k succeed_k))\n\nmodule Monad = struct\n let return v =\n { run = fun input pos more _fail succ ->\n succ input pos more v\n }\n\n let fail msg =\n { run = fun input pos more fail _succ ->\n fail input pos more [] msg\n }\n\n let (>>=) p f =\n { run = fun input pos more fail succ ->\n let succ' input' pos' more' v = (f v).run input' pos' more' fail succ in\n p.run input pos more fail succ'\n }\n\n let (>>|) p f =\n { run = fun input pos more fail succ ->\n let succ' input' pos' more' v = succ input' pos' more' (f v) in\n p.run input pos more fail succ'\n }\n\n let (<$>) f m =\n m >>| f\n\n let (<*>) f m =\n (* f >>= fun f -> m >>| f *)\n { run = fun input pos more fail succ ->\n let succ0 input0 pos0 more0 f =\n let succ1 input1 pos1 more1 m = succ input1 pos1 more1 (f m) in\n m.run input0 pos0 more0 fail succ1\n in\n f.run input pos more fail succ0 }\n\n let lift f m =\n f <$> m\n\n let lift2 f m1 m2 =\n { run = fun input pos more fail succ ->\n let succ1 input1 pos1 more1 m1 =\n let succ2 input2 pos2 more2 m2 = succ input2 pos2 more2 (f m1 m2) in\n m2.run input1 pos1 more1 fail succ2\n in\n m1.run input pos more fail succ1 }\n\n let lift3 f m1 m2 m3 =\n { run = fun input pos more fail succ ->\n let succ1 input1 pos1 more1 m1 =\n let succ2 input2 pos2 more2 m2 =\n let succ3 input3 pos3 more3 m3 =\n succ input3 pos3 more3 (f m1 m2 m3) in\n m3.run input2 pos2 more2 fail succ3 in\n m2.run input1 pos1 more1 fail succ2\n in\n m1.run input pos more fail succ1 }\n\n let lift4 f m1 m2 m3 m4 =\n { run = fun input pos more fail succ ->\n let succ1 input1 pos1 more1 m1 =\n let succ2 input2 pos2 more2 m2 =\n let succ3 input3 pos3 more3 m3 =\n let succ4 input4 pos4 more4 m4 =\n succ input4 pos4 more4 (f m1 m2 m3 m4) in\n m4.run input3 pos3 more3 fail succ4 in\n m3.run input2 pos2 more2 fail succ3 in\n m2.run input1 pos1 more1 fail succ2\n in\n m1.run input pos more fail succ1 }\n\n let ( *>) a b =\n (* a >>= fun _ -> b *)\n { run = fun input pos more fail succ ->\n let succ' input' pos' more' _ = b.run input' pos' more' fail succ in\n a.run input pos more fail succ'\n }\n\n let (<* ) a b =\n (* a >>= fun x -> b >>| fun _ -> x *)\n { run = fun input pos more fail succ ->\n let succ0 input0 pos0 more0 x =\n let succ1 input1 pos1 more1 _ = succ input1 pos1 more1 x in\n b.run input0 pos0 more0 fail succ1\n in\n a.run input pos more fail succ0 }\nend\n\nmodule Choice = struct\n let () p mark =\n { run = fun input pos more fail succ ->\n let fail' input' pos' more' marks msg =\n fail input' pos' more' (mark::marks) msg in\n p.run input pos more fail' succ\n }\n\n let (<|>) p q =\n { run = fun input pos more fail succ ->\n let fail' input' pos' more' marks msg =\n (* The only two constructors that introduce new failure continuations are\n * [] and [<|>]. If the initial input position is less than the length\n * of the committed input, then calling the failure continuation will\n * have the effect of unwinding all choices and collecting marks along\n * the way. *)\n if pos < Input.parser_committed_bytes input' then\n fail input' pos' more marks msg\n else\n q.run input' pos more' fail succ in\n p.run input pos more fail' succ\n }\nend\n\nmodule Monad_use_for_debugging = struct\n let return = Monad.return\n let fail = Monad.fail\n let (>>=) = Monad.(>>=)\n\n let (>>|) m f = m >>= fun x -> return (f x)\n\n let (<$>) f m = m >>| f\n let (<*>) f m = f >>= fun f -> m >>| f\n\n let lift = (>>|)\n let lift2 f m1 m2 = f <$> m1 <*> m2\n let lift3 f m1 m2 m3 = f <$> m1 <*> m2 <*> m3\n let lift4 f m1 m2 m3 m4 = f <$> m1 <*> m2 <*> m3 <*> m4\n\n let ( *>) a b = a >>= fun _ -> b\n let (<* ) a b = a >>= fun x -> b >>| fun _ -> x\nend\n","(*----------------------------------------------------------------------------\n Copyright (c) 2016 Inhabited Type LLC.\n\n All rights reserved.\n\n Redistribution and use in source and binary forms, with or without\n modification, are permitted provided that the following conditions\n are met:\n\n 1. Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n\n 2. Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n\n 3. Neither the name of the author nor the names of his contributors\n may be used to endorse or promote products derived from this software\n without specific prior written permission.\n\n THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS ``AS IS'' AND ANY EXPRESS\n OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\n WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR\n ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\n DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS\n OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\n HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,\n STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN\n ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n POSSIBILITY OF SUCH DAMAGE.\n ----------------------------------------------------------------------------*)\n\nmodule Bigarray = struct\n (* Do not access Bigarray operations directly. If anything's needed, refer to\n * the internal Bigstring module. *)\nend\n\ntype bigstring = Bigstringaf.t\n\n\nmodule Unbuffered = struct\n include Parser\n\n include Exported_state\n\n type more = More.t =\n | Complete\n | Incomplete\nend\n\ninclude Unbuffered\ninclude Parser.Monad\ninclude Parser.Choice\n\nmodule Buffered = struct\n type unconsumed = Buffering.unconsumed =\n { buf : bigstring\n ; off : int\n ; len : int }\n\n type input =\n [ `Bigstring of bigstring\n | `String of string ]\n\n type 'a state =\n | Partial of ([ input | `Eof ] -> 'a state)\n | Done of unconsumed * 'a\n | Fail of unconsumed * string list * string\n\n let from_unbuffered_state ~f buffering = function\n | Unbuffered.Partial p -> Partial (f p)\n | Unbuffered.Done(consumed, v) ->\n let unconsumed = Buffering.unconsumed ~shift:consumed buffering in\n Done(unconsumed, v)\n | Unbuffered.Fail(consumed, marks, msg) ->\n let unconsumed = Buffering.unconsumed ~shift:consumed buffering in\n Fail(unconsumed, marks, msg)\n\n let parse ?(initial_buffer_size=0x1000) p =\n if initial_buffer_size < 1 then\n failwith \"parse: invalid argument, initial_buffer_size < 1\";\n let buffering = Buffering.create initial_buffer_size in\n let rec f p input =\n Buffering.shift buffering p.committed;\n let more : More.t =\n match input with\n | `Eof -> Complete\n | #input as input ->\n Buffering.feed_input buffering input;\n Incomplete\n in\n let for_reading = Buffering.for_reading buffering in\n p.continue for_reading ~off:0 ~len:(Bigstringaf.length for_reading) more\n |> from_unbuffered_state buffering ~f\n in\n Unbuffered.parse p\n |> from_unbuffered_state buffering ~f\n\n let feed state input =\n match state with\n | Partial k -> k input\n | Fail(unconsumed, marks, msg) ->\n begin match input with\n | `Eof -> state\n | #input as input ->\n let buffering = Buffering.of_unconsumed unconsumed in\n Buffering.feed_input buffering input;\n Fail(Buffering.unconsumed buffering, marks, msg)\n end\n | Done(unconsumed, v) ->\n begin match input with\n | `Eof -> state\n | #input as input ->\n let buffering = Buffering.of_unconsumed unconsumed in\n Buffering.feed_input buffering input;\n Done(Buffering.unconsumed buffering, v)\n end\n\n let state_to_option = function\n | Done(_, v) -> Some v\n | Partial _ -> None\n | Fail _ -> None\n\n let state_to_result = function\n | Partial _ -> Error \"incomplete input\"\n | Done(_, v) -> Ok v\n | Fail(_, marks, msg) -> Error (Unbuffered.fail_to_string marks msg)\n\n let state_to_unconsumed = function\n | Done(unconsumed, _)\n | Fail(unconsumed, _, _) -> Some unconsumed\n | Partial _ -> None\n\nend\n\n(** BEGIN: getting input *)\n\nlet rec prompt input pos fail succ =\n (* [prompt] should only call [succ] if it has received more input. If there\n * is no chance that the input will grow, i.e., [more = Complete], then\n * [prompt] should call [fail]. Otherwise (in the case where the input\n * hasn't grown but [more = Incomplete] just prompt again. *)\n let parser_uncommitted_bytes = Input.parser_uncommitted_bytes input in\n let parser_committed_bytes = Input.parser_committed_bytes input in\n (* The continuation should not hold any references to input above. *)\n let continue input ~off ~len more =\n if len < parser_uncommitted_bytes then\n failwith \"prompt: input shrunk!\";\n let input = Input.create input ~off ~len ~committed_bytes:parser_committed_bytes in\n if len = parser_uncommitted_bytes then\n match (more : More.t) with\n | Complete -> fail input pos More.Complete\n | Incomplete -> prompt input pos fail succ\n else\n succ input pos more\n in\n State.Partial { committed = Input.bytes_for_client_to_commit input; continue }\n\nlet demand_input =\n { run = fun input pos more fail succ ->\n match (more : More.t) with\n | Complete -> fail input pos more [] \"not enough input\"\n | Incomplete ->\n let succ' input' pos' more' = succ input' pos' more' ()\n and fail' input' pos' more' = fail input' pos' more' [] \"not enough input\" in\n prompt input pos fail' succ'\n }\n\nlet ensure_suspended n input pos more fail succ =\n let rec go =\n { run = fun input' pos' more' fail' succ' ->\n if pos' + n <= Input.length input' then\n succ' input' pos' more' ()\n else\n (demand_input *> go).run input' pos' more' fail' succ'\n }\n in\n (demand_input *> go).run input pos more fail succ\n\nlet unsafe_apply len ~f =\n { run = fun input pos more _fail succ ->\n succ input (pos + len) more (Input.apply input pos len ~f)\n }\n\nlet unsafe_apply_opt len ~f =\n { run = fun input pos more fail succ ->\n match Input.apply input pos len ~f with\n | Error e -> fail input pos more [] e\n | Ok x -> succ input (pos + len) more x\n }\n\nlet ensure n p =\n { run = fun input pos more fail succ ->\n if pos + n <= Input.length input\n then p.run input pos more fail succ\n else\n let succ' input' pos' more' () = p.run input' pos' more' fail succ in\n ensure_suspended n input pos more fail succ' }\n\n(** END: getting input *)\n\nlet at_end_of_input =\n { run = fun input pos more _ succ ->\n if pos < Input.length input then\n succ input pos more false\n else match more with\n | Complete -> succ input pos more true\n | Incomplete ->\n let succ' input' pos' more' = succ input' pos' more' false\n and fail' input' pos' more' = succ input' pos' more' true in\n prompt input pos fail' succ'\n }\n\nlet end_of_input =\n at_end_of_input\n >>= function\n | true -> return ()\n | false -> fail \"end_of_input\"\n\nlet advance n =\n if n < 0\n then fail \"advance\"\n else\n let p =\n { run = fun input pos more _fail succ -> succ input (pos + n) more () }\n in\n ensure n p\n\nlet pos =\n { run = fun input pos more _fail succ -> succ input pos more pos }\n\nlet available =\n { run = fun input pos more _fail succ ->\n succ input pos more (Input.length input - pos)\n }\n\nlet commit =\n { run = fun input pos more _fail succ ->\n Input.commit input pos;\n succ input pos more () }\n\n(* Do not use this if [p] contains a [commit]. *)\nlet unsafe_lookahead p =\n { run = fun input pos more fail succ ->\n let succ' input' _ more' v = succ input' pos more' v in\n p.run input pos more fail succ' }\n\nlet peek_char =\n { run = fun input pos more _fail succ ->\n if pos < Input.length input then\n succ input pos more (Some (Input.unsafe_get_char input pos))\n else if more = Complete then\n succ input pos more None\n else\n let succ' input' pos' more' =\n succ input' pos' more' (Some (Input.unsafe_get_char input' pos'))\n and fail' input' pos' more' =\n succ input' pos' more' None in\n prompt input pos fail' succ'\n }\n\n(* This parser is too important to not be optimized. Do a custom job. *)\nlet rec peek_char_fail =\n { run = fun input pos more fail succ ->\n if pos < Input.length input\n then succ input pos more (Input.unsafe_get_char input pos)\n else\n let succ' input' pos' more' () =\n peek_char_fail.run input' pos' more' fail succ in\n ensure_suspended 1 input pos more fail succ' }\n\nlet satisfy f =\n { run = fun input pos more fail succ ->\n if pos < Input.length input then\n let c = Input.unsafe_get_char input pos in\n if f c\n then succ input (pos + 1) more c\n else Printf.ksprintf (fail input pos more []) \"satisfy: %C\" c\n else\n let succ' input' pos' more' () =\n let c = Input.unsafe_get_char input' pos' in\n if f c\n then succ input' (pos' + 1) more' c\n else Printf.ksprintf (fail input' pos' more' []) \"satisfy: %C\" c\n in\n ensure_suspended 1 input pos more fail succ' }\n\nlet char c =\n let p =\n { run = fun input pos more fail succ ->\n if Input.unsafe_get_char input pos = c\n then succ input (pos + 1) more c\n else fail input pos more [] (Printf.sprintf \"char %C\" c) }\n in\n ensure 1 p\n\nlet not_char c =\n let p =\n { run = fun input pos more fail succ ->\n let c' = Input.unsafe_get_char input pos in\n if c <> c'\n then succ input (pos + 1) more c'\n else fail input pos more [] (Printf.sprintf \"not char %C\" c) }\n in\n ensure 1 p\n\nlet any_char =\n let p =\n { run = fun input pos more _fail succ ->\n succ input (pos + 1) more (Input.unsafe_get_char input pos) }\n in\n ensure 1 p\n\nlet int8 i =\n let p =\n { run = fun input pos more fail succ ->\n let c = Char.code (Input.unsafe_get_char input pos) in\n if c = i land 0xff\n then succ input (pos + 1) more c\n else fail input pos more [] (Printf.sprintf \"int8 %d\" i) }\n in\n ensure 1 p\n\nlet any_uint8 =\n let p =\n { run = fun input pos more _fail succ ->\n let c = Input.unsafe_get_char input pos in\n succ input (pos + 1) more (Char.code c) }\n in\n ensure 1 p\n\nlet any_int8 =\n (* https://graphics.stanford.edu/~seander/bithacks.html#VariableSignExtendRisky *)\n let s = Sys.int_size - 8 in\n let p =\n { run = fun input pos more _fail succ ->\n let c = Input.unsafe_get_char input pos in\n succ input (pos + 1) more ((Char.code c lsl s) asr s) }\n in\n ensure 1 p\n\nlet skip f =\n let p =\n { run = fun input pos more fail succ ->\n if f (Input.unsafe_get_char input pos)\n then succ input (pos + 1) more ()\n else fail input pos more [] \"skip\" }\n in\n ensure 1 p\n\nlet rec count_while ~init ~f ~with_buffer =\n { run = fun input pos more fail succ ->\n let len = Input.count_while input (pos + init) ~f in\n let input_len = Input.length input in\n let init' = init + len in\n (* Check if the loop terminated because it reached the end of the input\n * buffer. If so, then prompt for additional input and continue. *)\n if pos + init' < input_len || more = Complete\n then succ input (pos + init') more (Input.apply input pos init' ~f:with_buffer)\n else\n let succ' input' pos' more' =\n (count_while ~init:init' ~f ~with_buffer).run input' pos' more' fail succ\n and fail' input' pos' more' =\n succ input' (pos' + init') more' (Input.apply input' pos' init' ~f:with_buffer)\n in\n prompt input pos fail' succ'\n }\n\nlet rec count_while1 ~f ~with_buffer =\n { run = fun input pos more fail succ ->\n let len = Input.count_while input pos ~f in\n let input_len = Input.length input in\n (* Check if the loop terminated because it reached the end of the input\n * buffer. If so, then prompt for additional input and continue. *)\n if len < 1\n then\n if pos < input_len || more = Complete\n then fail input pos more [] \"count_while1\"\n else\n let succ' input' pos' more' =\n (count_while1 ~f ~with_buffer).run input' pos' more' fail succ\n and fail' input' pos' more' =\n fail input' pos' more' [] \"count_while1\"\n in\n prompt input pos fail' succ'\n else if pos + len < input_len || more = Complete\n then succ input (pos + len) more (Input.apply input pos len ~f:with_buffer)\n else\n let succ' input' pos' more' =\n (count_while ~init:len ~f ~with_buffer).run input' pos' more' fail succ\n and fail' input' pos' more' =\n succ input' (pos' + len) more' (Input.apply input' pos' len ~f:with_buffer)\n in\n prompt input pos fail' succ'\n }\n\nlet string_ f s =\n (* XXX(seliopou): Inefficient. Could check prefix equality to short-circuit\n * the io. *)\n let len = String.length s in\n ensure len (unsafe_apply_opt len ~f:(fun buffer ~off ~len ->\n let i = ref 0 in\n while !i < len && Char.equal (f (Bigstringaf.unsafe_get buffer (off + !i)))\n (f (String.unsafe_get s !i))\n do\n incr i\n done;\n if len = !i\n then Ok (Bigstringaf.substring buffer ~off ~len)\n else Error \"string\"))\n\nlet string s = string_ (fun x -> x) s\nlet string_ci s = string_ Char.lowercase_ascii s\n\nlet skip_while f =\n count_while ~init:0 ~f ~with_buffer:(fun _ ~off:_ ~len:_ -> ())\n\nlet take n =\n if n < 0\n then fail \"take: n < 0\"\n else\n let n = max n 0 in\n ensure n (unsafe_apply n ~f:Bigstringaf.substring)\n\nlet take_bigstring n =\n if n < 0\n then fail \"take_bigstring: n < 0\"\n else\n let n = max n 0 in\n ensure n (unsafe_apply n ~f:Bigstringaf.copy)\n\nlet take_bigstring_while f =\n count_while ~init:0 ~f ~with_buffer:Bigstringaf.copy\n\nlet take_bigstring_while1 f =\n count_while1 ~f ~with_buffer:Bigstringaf.copy\n\nlet take_bigstring_till f =\n take_bigstring_while (fun c -> not (f c))\n\nlet peek_string n =\n unsafe_lookahead (take n)\n\nlet take_while f =\n count_while ~init:0 ~f ~with_buffer:Bigstringaf.substring\n\nlet take_while1 f =\n count_while1 ~f ~with_buffer:Bigstringaf.substring\n\nlet take_till f =\n take_while (fun c -> not (f c))\n\nlet choice ?(failure_msg=\"no more choices\") ps =\n List.fold_right (<|>) ps (fail failure_msg)\n\nlet fix_direct f =\n let rec p = lazy (f r)\n and r = { run = fun buf pos more fail succ ->\n (Lazy.force p).run buf pos more fail succ }\n in\n r\n\nlet fix_lazy f =\n let max_steps = 20 in\n let steps = ref max_steps in\n let rec p = lazy (f r)\n and r = { run = fun buf pos more fail succ ->\n decr steps;\n if !steps < 0\n then (\n steps := max_steps;\n State.Lazy (lazy ((Lazy.force p).run buf pos more fail succ)))\n else\n (Lazy.force p).run buf pos more fail succ\n }\n in\n r\n\nlet fix = match Sys.backend_type with\n | Native -> fix_direct\n | Bytecode -> fix_direct\n | Other _ -> fix_lazy\n\nlet option x p =\n p <|> return x\n\nlet cons x xs = x :: xs\n\nlet rec list ps =\n match ps with\n | [] -> return []\n | p::ps -> lift2 cons p (list ps)\n\nlet count n p =\n if n < 0 \n then fail \"count: n < 0\"\n else \n let rec loop = function\n | 0 -> return []\n | n -> lift2 cons p (loop (n - 1))\n in\n loop n\n\nlet many p =\n fix (fun m ->\n (lift2 cons p m) <|> return [])\n\nlet many1 p =\n lift2 cons p (many p)\n\nlet many_till p t =\n fix (fun m ->\n (t *> return []) <|> (lift2 cons p m))\n\nlet sep_by1 s p =\n fix (fun m ->\n lift2 cons p ((s *> m) <|> return []))\n\nlet sep_by s p =\n (lift2 cons p ((s *> sep_by1 s p) <|> return [])) <|> return []\n\nlet skip_many p =\n fix (fun m ->\n (p *> m) <|> return ())\n\nlet skip_many1 p =\n p *> skip_many p\n\nlet end_of_line =\n (char '\\n' *> return ()) <|> (string \"\\r\\n\" *> return ()) \"end_of_line\"\n\nlet scan_ state f ~with_buffer =\n { run = fun input pos more fail succ ->\n let state = ref state in\n let parser =\n count_while ~init:0 ~f:(fun c ->\n match f !state c with\n | None -> false\n | Some state' -> state := state'; true)\n ~with_buffer\n >>| fun x -> x, !state\n in\n parser.run input pos more fail succ }\n\nlet scan state f =\n scan_ state f ~with_buffer:Bigstringaf.substring\n\nlet scan_state state f =\n scan_ state f ~with_buffer:(fun _ ~off:_ ~len:_ -> ())\n >>| fun ((), state) -> state\n\nlet scan_string state f =\n scan state f >>| fst\n\nlet consume_with p f =\n { run = fun input pos more fail succ ->\n let start = pos in\n let parser_committed_bytes = Input.parser_committed_bytes input in\n let succ' input' pos' more' _ =\n if parser_committed_bytes <> Input.parser_committed_bytes input'\n then fail input' pos' more' [] \"consumed: parser committed\"\n else (\n let len = pos' - start in\n let consumed = Input.apply input' start len ~f in\n succ input' pos' more' consumed)\n in\n p.run input pos more fail succ'\n }\n\nlet consumed p = consume_with p Bigstringaf.substring\nlet consumed_bigstring p = consume_with p Bigstringaf.copy\n\nlet both a b = lift2 (fun a b -> a, b) a b\nlet map t ~f = t >>| f\nlet bind t ~f = t >>= f\nlet map2 a b ~f = lift2 f a b\nlet map3 a b c ~f = lift3 f a b c\nlet map4 a b c d ~f = lift4 f a b c d\n\nmodule Let_syntax = struct\n let return = return\n let ( >>| ) = ( >>| )\n let ( >>= ) = ( >>= )\n\n module Let_syntax = struct\n let return = return\n let map = map\n let bind = bind\n let both = both\n let map2 = map2\n let map3 = map3\n let map4 = map4\n end\nend\n\nlet ( let+ ) = ( >>| )\nlet ( let* ) = ( >>= )\nlet ( and+ ) = both\n\nmodule BE = struct\n (* XXX(seliopou): The pattern in both this module and [LE] are a compromise\n * between efficiency and code reuse. By inlining [ensure] you can recover\n * about 2 nanoseconds on average. That may add up in certain applications.\n *\n * This pattern does not allocate in the fast (success) path.\n * *)\n let int16 n =\n let bytes = 2 in\n let p =\n { run = fun input pos more fail succ ->\n if Input.unsafe_get_int16_be input pos = (n land 0xffff)\n then succ input (pos + bytes) more ()\n else fail input pos more [] \"BE.int16\" }\n in\n ensure bytes p\n\n let int32 n =\n let bytes = 4 in\n let p =\n { run = fun input pos more fail succ ->\n if Int32.equal (Input.unsafe_get_int32_be input pos) n\n then succ input (pos + bytes) more ()\n else fail input pos more [] \"BE.int32\" }\n in\n ensure bytes p\n\n let int64 n =\n let bytes = 8 in\n let p =\n { run = fun input pos more fail succ ->\n if Int64.equal (Input.unsafe_get_int64_be input pos) n\n then succ input (pos + bytes) more ()\n else fail input pos more [] \"BE.int64\" }\n in\n ensure bytes p\n\n let any_uint16 =\n ensure 2 (unsafe_apply 2 ~f:(fun bs ~off ~len:_ -> Bigstringaf.unsafe_get_int16_be bs off))\n\n let any_int16 =\n ensure 2 (unsafe_apply 2 ~f:(fun bs ~off ~len:_ -> Bigstringaf.unsafe_get_int16_sign_extended_be bs off))\n\n let any_int32 =\n ensure 4 (unsafe_apply 4 ~f:(fun bs ~off ~len:_ -> Bigstringaf.unsafe_get_int32_be bs off))\n\n let any_int64 =\n ensure 8 (unsafe_apply 8 ~f:(fun bs ~off ~len:_ -> Bigstringaf.unsafe_get_int64_be bs off))\n\n let any_float =\n ensure 4 (unsafe_apply 4 ~f:(fun bs ~off ~len:_ -> Int32.float_of_bits (Bigstringaf.unsafe_get_int32_be bs off)))\n\n let any_double =\n ensure 8 (unsafe_apply 8 ~f:(fun bs ~off ~len:_ -> Int64.float_of_bits (Bigstringaf.unsafe_get_int64_be bs off)))\nend\n\nmodule LE = struct\n let int16 n =\n let bytes = 2 in\n let p =\n { run = fun input pos more fail succ ->\n if Input.unsafe_get_int16_le input pos = (n land 0xffff)\n then succ input (pos + bytes) more ()\n else fail input pos more [] \"LE.int16\" }\n in\n ensure bytes p\n\n let int32 n =\n let bytes = 4 in\n let p =\n { run = fun input pos more fail succ ->\n if Int32.equal (Input.unsafe_get_int32_le input pos) n\n then succ input (pos + bytes) more ()\n else fail input pos more [] \"LE.int32\" }\n in\n ensure bytes p\n\n let int64 n =\n let bytes = 8 in\n let p =\n { run = fun input pos more fail succ ->\n if Int64.equal (Input.unsafe_get_int64_le input pos) n\n then succ input (pos + bytes) more ()\n else fail input pos more [] \"LE.int64\" }\n in\n ensure bytes p\n\n\n let any_uint16 =\n ensure 2 (unsafe_apply 2 ~f:(fun bs ~off ~len:_ -> Bigstringaf.unsafe_get_int16_le bs off))\n\n let any_int16 =\n ensure 2 (unsafe_apply 2 ~f:(fun bs ~off ~len:_ -> Bigstringaf.unsafe_get_int16_sign_extended_le bs off))\n\n let any_int32 =\n ensure 4 (unsafe_apply 4 ~f:(fun bs ~off ~len:_ -> Bigstringaf.unsafe_get_int32_le bs off))\n\n let any_int64 =\n ensure 8 (unsafe_apply 8 ~f:(fun bs ~off ~len:_ -> Bigstringaf.unsafe_get_int64_le bs off))\n\n let any_float =\n ensure 4 (unsafe_apply 4 ~f:(fun bs ~off ~len:_ -> Int32.float_of_bits (Bigstringaf.unsafe_get_int32_le bs off)))\n\n let any_double =\n ensure 8 (unsafe_apply 8 ~f:(fun bs ~off ~len:_ -> Int64.float_of_bits (Bigstringaf.unsafe_get_int64_le bs off)))\nend\n\nmodule Unsafe = struct\n let take n f =\n let n = max n 0 in\n ensure n (unsafe_apply n ~f)\n\n let peek n f =\n unsafe_lookahead (take n f)\n\n let take_while check f =\n count_while ~init:0 ~f:check ~with_buffer:f\n\n let take_while1 check f =\n count_while1 ~f:check ~with_buffer:f\n\n let take_till check f =\n take_while (fun c -> not (check c)) f\nend\n\nmodule Consume = struct\n type t =\n | Prefix\n | All\nend\n\nlet parse_bigstring ~consume p bs =\n let p =\n match (consume : Consume.t) with\n | Prefix -> p\n | All -> p <* end_of_input\n in\n Unbuffered.parse_bigstring p bs\n\nlet parse_string ~consume p s =\n let len = String.length s in\n let bs = Bigstringaf.create len in\n Bigstringaf.unsafe_blit_from_string s ~src_off:0 bs ~dst_off:0 ~len;\n parse_bigstring ~consume p bs\n","open Core_kernel\n\ntype mode = Hidden | Inline | After\n\ntype config =\n { mode : mode; max_interpolation_length : int; pretty_print : bool }\n\nlet rec result_fold_left ls ~init ~f =\n match ls with\n | [] ->\n Ok init\n | h :: t -> (\n match f init h with\n | Ok init' ->\n result_fold_left t ~init:init' ~f\n | Error err ->\n Error err )\n\nlet parser =\n let open Angstrom in\n let not_f f x = not (f x) in\n let or_f f g x = f x || g x in\n let is_alpha = function\n | 'a' .. 'z' | 'A' .. 'Z' | '_' ->\n true\n | _ ->\n false\n in\n let is_numeric = function '0' .. '9' -> true | _ -> false in\n let interpolation =\n lift2\n (fun c s -> String.of_char c ^ s)\n (char '$' *> commit *> satisfy is_alpha)\n (take_while (or_f is_alpha is_numeric))\n in\n let message =\n many1\n (choice\n [ (take_while1 (not_f (Char.equal '$')) >>| fun x -> `Raw x)\n ; (interpolation >>| fun x -> `Interpolate x)\n ] )\n in\n message <* end_of_input\n\nlet parse = Angstrom.parse_string ~consume:All parser\n\n(* map and concat vs. fold: which is better for strings? *)\nlet render ~max_interpolation_length ~format_json metadata items =\n let open Result.Let_syntax in\n let%map msg, extra =\n result_fold_left items ~init:(\"\", []) ~f:(fun (msg_acc, extra_acc) el ->\n match el with\n | `Raw str ->\n Ok (msg_acc ^ str, extra_acc)\n | `Interpolate id ->\n let%map json =\n String.Map.find metadata id\n |> Result.of_option ~error:(sprintf \"bad interpolation for %s\" id)\n in\n let str = format_json json in\n if String.length str > max_interpolation_length then\n (msg_acc ^ \"$\" ^ id, (id, str) :: extra_acc)\n else (msg_acc ^ str, extra_acc) )\n in\n (msg, List.rev extra)\n\nlet interpolate { mode; max_interpolation_length; pretty_print } msg metadata =\n let open Result.Let_syntax in\n let format_json =\n if pretty_print then Yojson.Safe.pretty_to_string\n else Yojson.Safe.to_string ?buf:None ?len:None\n in\n match mode with\n | Hidden ->\n Ok (msg, [])\n | Inline ->\n let%bind items = parse msg in\n render ~max_interpolation_length ~format_json metadata items\n | After ->\n Ok\n ( msg\n , List.map (String.Map.to_alist metadata) ~f:(fun (k, v) ->\n (k, format_json v) ) )\n","open Core_kernel\n\ntype t = ..\n\ntype id = string [@@deriving equal, yojson, sexp]\n\nmodule Set = String.Set\n\nlet id_of_string s = s\n\nlet string_of_id s = s\n\ntype repr =\n { id : id\n ; event_name : string\n ; arguments : String.Set.t\n ; log : t -> (string * (string * Yojson.Safe.t) list) option\n ; parse : (string * Yojson.Safe.t) list -> t option\n }\n\nmodule Registry = struct\n let reprs : repr list ref = ref []\n\n let register_constructor repr = reprs := repr :: !reprs\nend\n\nlet parse_exn id json_pairs =\n let result =\n List.find_map !Registry.reprs ~f:(fun repr ->\n if equal_id id repr.id then\n let json_pairs =\n (* Remove additional metadata that may have been added to the log\n message.\n *)\n List.filter json_pairs ~f:(fun (field_name, _) ->\n Set.mem repr.arguments field_name )\n in\n match repr.parse json_pairs with\n | Some t ->\n Some t\n | None ->\n failwithf\n \"parse_exn: parser for id %s found, but failed when applied to \\\n arguments: %s\"\n id\n ( List.map json_pairs ~f:(fun (name, json) ->\n sprintf \"%s = %s\" name (Yojson.Safe.to_string json) )\n |> String.concat ~sep:\",\" )\n ()\n else None )\n in\n match result with\n | Some data ->\n data\n | None ->\n failwithf \"parse_exn: did not find matching parser for id %s\" id ()\n\nlet log t =\n let result =\n List.find_map !Registry.reprs ~f:(fun repr ->\n Option.map (repr.log t) ~f:(fun (msg, fields) -> (msg, repr.id, fields)) )\n in\n match result with\n | Some data ->\n data\n | None ->\n let[@warning \"-3\"] name =\n Obj.extension_name (Obj.extension_constructor t)\n in\n failwithf \"log: did not find matching logger for %s\" name ()\n\nlet register_constructor = Registry.register_constructor\n\nlet dump_registered_events () =\n List.map !Registry.reprs ~f:(fun { event_name; id; arguments; _ } ->\n (event_name, id, Set.to_list arguments) )\n\nlet check_interpolations_exn ~msg_loc msg label_names =\n (* don't use Logproc_lib, which depends on C++ code\n using Interpolator_lib allows use in js_of_ocaml\n the `parse` code is the same\n *)\n match Interpolator_lib.Interpolator.parse msg with\n | Error err ->\n failwithf\n \"%s\\nEncountered an error while parsing the structured log message: %s\"\n msg_loc err ()\n | Ok items ->\n List.iter items ~f:(function\n | `Interpolate interp\n when not (List.mem ~equal:String.equal label_names interp) ->\n failwithf\n \"%s\\n\\\n The structured log message contains interpolation point \\\"$%s\\\" \\\n which is not a field in the record\"\n msg_loc interp ()\n | _ ->\n () )\n","type z = Z of z\n\ntype 'a s = Z | S of 'a\n\ntype _ t = Z : z t | S : 'n t -> 'n s t\n\ntype 'a nat = 'a t\n\ntype e = T : 'n nat -> e\n\nlet to_int : type n. n t -> int =\n let rec go : type n. int -> n t -> int =\n fun acc n -> match n with Z -> acc | S n -> go (acc + 1) n\n in\n fun x -> go 0 x\n\nlet rec of_int : int -> e =\n fun n ->\n if n < 0 then failwith \"of_int: negative\"\n else if n = 0 then T Z\n else\n let (T n) = of_int (n - 1) in\n T (S n)\n\nmodule type Intf = sig\n type n\n\n val n : n t\nend\n\nmodule Adds = struct\n type ('a, 'b, 'c) t =\n | Z : (z, 'n, 'n) t\n | S : ('a, 'b, 'c) t -> ('a s, 'b, 'c s) t\n\n let rec add_zr : type n. n nat -> (n, z, n) t = function\n | Z ->\n Z\n | S n ->\n let pi = add_zr n in\n S pi\nend\n\nmodule Lte = struct\n type (_, _) t = Z : (z, _) t | S : ('n, 'm) t -> ('n s, 'm s) t\n\n let rec refl : type n. n nat -> (n, n) t = function\n | Z ->\n Z\n | S n ->\n S (refl n)\n\n let rec trans : type a b c. (a, b) t -> (b, c) t -> (a, c) t =\n fun t1 t2 -> match (t1, t2) with Z, _ -> Z | S t1, S t2 -> S (trans t1 t2)\nend\n\nmodule N0 = struct\n type 'a plus_n = 'a\n\n type n = z\n\n let n = Z\n\n let add m = (m, Adds.Z)\n\n let eq = Core_kernel.Type_equal.T\nend\n\nmodule Add = struct\n module type Intf = sig\n type _ plus_n\n\n type n\n\n val eq : (n, z plus_n) Core_kernel.Type_equal.t\n\n val n : z plus_n t\n\n val add : 'm nat -> 'm plus_n nat * (z plus_n, 'm, 'm plus_n) Adds.t\n end\n\n let rec create : type n. n nat -> (module Intf with type n = n) = function\n | Z ->\n (module N0)\n | S n ->\n let (module N) = create n in\n let T = N.eq in\n let module Sn = struct\n type 'a plus_n = 'a N.plus_n s\n\n type n = N.n s\n\n let n = S N.n\n\n let eq = Core_kernel.Type_equal.T\n\n let add t =\n let t_plus_n, pi = N.add t in\n (S t_plus_n, Adds.S pi)\n end in\n (module Sn)\n\n let n : type n. (module Intf with type n = n) -> n nat =\n fun (module N) ->\n let T = N.eq in\n N.n\n\n module type Intf_transparent = sig\n type _ plus_n\n\n type n = z plus_n\n\n val eq : (n, z plus_n) Core_kernel.Type_equal.t\n\n val n : z plus_n t\n\n val add : 'm nat -> 'm plus_n nat * (z plus_n, 'm, 'm plus_n) Adds.t\n end\nend\n\nmodule S (N : Add.Intf) = struct\n type 'a plus_n = 'a N.plus_n s\n\n type n = z plus_n\n\n let n = S N.n\n\n let add m =\n let k, pi = N.add m in\n (S k, Adds.S pi)\n\n let eq = match N.eq with T -> Core_kernel.Type_equal.T\nend\n\nmodule N1 = S (N0)\nmodule N2 = S (N1)\nmodule N3 = S (N2)\nmodule N4 = S (N3)\nmodule N5 = S (N4)\nmodule N6 = S (N5)\nmodule N7 = S (N6)\nmodule N8 = S (N7)\nmodule N9 = S (N8)\nmodule N10 = S (N9)\nmodule N11 = S (N10)\nmodule N12 = S (N11)\nmodule N13 = S (N12)\nmodule N14 = S (N13)\nmodule N15 = S (N14)\nmodule N16 = S (N15)\nmodule N17 = S (N16)\nmodule N18 = S (N17)\nmodule N19 = S (N18)\nmodule N20 = S (N19)\nmodule N21 = S (N20)\nmodule N22 = S (N21)\nmodule N23 = S (N22)\nmodule N24 = S (N23)\nmodule N25 = S (N24)\nmodule N26 = S (N25)\nmodule N27 = S (N26)\nmodule N28 = S (N27)\nmodule N29 = S (N28)\nmodule N30 = S (N29)\nmodule N31 = S (N30)\nmodule N32 = S (N31)\nmodule N33 = S (N32)\nmodule N34 = S (N33)\nmodule N35 = S (N34)\nmodule N36 = S (N35)\nmodule N37 = S (N36)\nmodule N38 = S (N37)\nmodule N39 = S (N38)\nmodule N40 = S (N39)\nmodule N41 = S (N40)\nmodule N42 = S (N41)\nmodule N43 = S (N42)\nmodule N44 = S (N43)\nmodule N45 = S (N44)\nmodule N46 = S (N45)\nmodule N47 = S (N46)\nmodule N48 = S (N47)\n\nmodule Empty = struct\n type t = T of t\n\n let rec elim : type a. t -> a = function T t -> elim t\nend\n\nmodule Not = struct\n type 'a t = 'a -> Empty.t\nend\n\nopen Core_kernel\n\nlet rec compare :\n type n m. n t -> m t -> [ `Lte of (n, m) Lte.t | `Gt of (n, m) Lte.t Not.t ]\n =\n fun n m ->\n match (n, m) with\n | Z, _ ->\n `Lte Lte.Z\n | S _, Z ->\n `Gt (function _ -> .)\n | S n, S m -> (\n match compare n m with\n | `Lte pi ->\n `Lte (S pi)\n | `Gt gt ->\n `Gt (function S pi -> gt pi) )\n\nlet lte_exn n m =\n match compare n m with `Lte pi -> pi | `Gt _gt -> failwith \"lte_exn\"\n\nlet rec gt_implies_gte :\n type n m. n nat -> m nat -> (n, m) Lte.t Not.t -> (m, n) Lte.t =\n fun n m not_lte ->\n match (n, m) with\n | Z, _ ->\n Empty.elim (not_lte Z)\n | S _, Z ->\n Z\n | S n, S m ->\n S (gt_implies_gte n m (fun pi -> not_lte (S pi)))\n\nlet rec eq :\n type n m.\n n nat\n -> m nat\n -> [ `Equal of (n, m) Type_equal.t\n | `Not_equal of (n, m) Type_equal.t Not.t ] =\n fun n m ->\n match (n, m) with\n | Z, Z ->\n `Equal T\n | S _, Z ->\n `Not_equal (function _ -> .)\n | Z, S _ ->\n `Not_equal (function _ -> .)\n | S n, S m -> (\n match eq n m with\n | `Equal T ->\n `Equal T\n | `Not_equal f ->\n `Not_equal (function T -> f T) )\n\nlet eq_exn : type n m. n nat -> m nat -> (n, m) Type_equal.t =\n fun n m ->\n match eq n m with\n | `Equal t ->\n t\n | `Not_equal _ ->\n failwithf \"eq_exn: %d vs %d\" (to_int n) (to_int m) ()\n\nmodule type I = Add.Intf_transparent\n","module Length = struct\n type (_, _) t =\n | Z : (unit, Nat.z) t\n | S : ('tail, 'n) t -> ('a * 'tail, 'n Nat.s) t\n\n let rec to_nat : type xs n. (xs, n) t -> n Nat.t = function\n | Z ->\n Z\n | S n ->\n S (to_nat n)\n\n type 'xs n = T : 'n Nat.t * ('xs, 'n) t -> 'xs n\n\n let rec contr :\n type xs n m. (xs, n) t -> (xs, m) t -> (n, m) Core_kernel.Type_equal.t =\n fun t1 t2 ->\n match (t1, t2) with\n | Z, Z ->\n T\n | S n, S m ->\n let T = contr n m in\n T\nend\n\nmodule H1 (F : Poly_types.T1) = struct\n type _ t = [] : unit t | ( :: ) : 'a F.t * 'b t -> ('a * 'b) t\n\n let rec length : type tail1. tail1 t -> tail1 Length.n = function\n | [] ->\n T (Z, Z)\n | _ :: xs ->\n let (T (n, p)) = length xs in\n T (S n, S p)\nend\n\nmodule H1_1 (F : Poly_types.T2) = struct\n type (_, 's) t =\n | [] : (unit, _) t\n | ( :: ) : ('a, 's) F.t * ('b, 's) t -> ('a * 'b, 's) t\n\n let rec length : type tail1 tail2. (tail1, tail2) t -> tail1 Length.n =\n function\n | [] ->\n T (Z, Z)\n | _ :: xs ->\n let (T (n, p)) = length xs in\n T (S n, S p)\nend\n\nmodule Id = struct\n type 'a t = 'a\nend\n\nmodule HlistId = H1 (Id)\n","open Core_kernel\nopen Pickles_types\nmodule Max_state_size = Nat.N8\n\nmodule V = struct\n (* Think about versioning here! These vector types *will* change\n serialization if the numbers above change, and so will require a new\n version number. Thus, it's important that these are modules with new\n versioned types, and not just module aliases to the corresponding vector\n implementation.\n *)\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n type 'a t = 'a Vector.Vector_8.Stable.V1.t\n [@@deriving compare, yojson, sexp, hash, equal]\n end\n end]\n\n type 'a t = 'a Vector.Vector_8.t\n [@@deriving compare, yojson, sexp, hash, equal]\n\n let map = Vector.map\n\n let of_list_exn = Vector.Vector_8.of_list_exn\n\n let to_list = Vector.to_list\nend\n\nlet _type_equal :\n type a. (a V.t, a Vector.With_length(Max_state_size).t) Type_equal.t =\n Type_equal.T\n\nlet typ t = Vector.typ t Max_state_size.n\n\nopen Core_kernel\n\nmodule Value = struct\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n type t = Zkapp_basic.F.Stable.V1.t V.Stable.V1.t\n [@@deriving sexp, equal, yojson, hash, compare]\n\n let to_latest = Fn.id\n end\n end]\n\n type t = Zkapp_basic.F.t V.t [@@deriving sexp, equal, yojson, hash, compare]\n\n let (_ : (t, Stable.Latest.t) Type_equal.t) = Type_equal.T\nend\n\nlet to_input (t : _ V.t) ~f =\n Vector.(reduce_exn (map t ~f) ~f:Random_oracle_input.Chunked.append)\n\nlet deriver inner obj =\n let open Fields_derivers_zkapps.Derivers in\n iso ~map:V.of_list_exn ~contramap:V.to_list\n ((list ~static_length:(Nat.to_int Max_state_size.n) @@ inner @@ o ())\n (o ()) )\n obj\n","open Core_kernel\nopen Kimchi_backend_common\n\nmodule Rounds : sig\n open Pickles_types\n\n module Wrap : Nat.Add.Intf_transparent\n\n module Wrap_vector : Vector.With_version(Wrap).S\n\n module Step : Nat.Add.Intf_transparent\n\n module Step_vector : Vector.With_version(Step).S\nend = struct\n open Pickles_types\n module Wrap = Nat.N15\n module Step = Nat.N16\n\n (* Think about versioning here! These vector types *will* change\n serialization if the numbers above change, and so will require a new\n version number. Thus, it's important that these are modules with new\n versioned types, and not just module aliases to the corresponding vector\n implementation.\n *)\n\n module Wrap_vector = struct\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n type 'a t = 'a Vector.Vector_15.Stable.V1.t\n [@@deriving compare, yojson, sexp, hash, equal]\n end\n end]\n\n type 'a t = 'a Vector.Vector_15.t\n [@@deriving compare, yojson, sexp, hash, equal]\n\n let map = Vector.map\n\n let of_list_exn = Vector.Vector_15.of_list_exn\n\n let to_list = Vector.to_list\n end\n\n module Step_vector = struct\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n type 'a t = 'a Vector.Vector_16.Stable.V1.t\n [@@deriving compare, yojson, sexp, hash, equal]\n end\n end]\n\n type 'a t = 'a Vector.Vector_16.t\n [@@deriving compare, yojson, sexp, hash, equal]\n\n let map = Vector.map\n\n let of_list_exn = Vector.Vector_16.of_list_exn\n\n let to_list = Vector.to_list\n end\nend\n\n(* why use a functor here? *)\nmodule Bigint256 =\n Kimchi_backend_common.Bigint.Make\n (Pasta_bindings.BigInt256)\n (struct\n let length_in_bytes = 32\n end)\n\n(* the two pasta fields and curves *)\n\nmodule Fp = Field.Make (struct\n module Bigint = Bigint256\n include Pasta_bindings.Fp\n module Vector = Kimchi_bindings.FieldVectors.Fp\nend)\n\nmodule Fq = Field.Make (struct\n module Bigint = Bigint256\n include Pasta_bindings.Fq\n module Vector = Kimchi_bindings.FieldVectors.Fq\nend)\n\nmodule Vesta = struct\n module Params = struct\n open Fq\n\n let a = zero\n\n let b = of_int 5\n end\n\n include Curve.Make (Fq) (Fp) (Params) (Pasta_bindings.Vesta)\nend\n\nmodule Pallas = struct\n module Params = struct\n open Fp\n\n let a = zero\n\n let b = of_int 5\n end\n\n include Curve.Make (Fp) (Fq) (Params) (Pasta_bindings.Pallas)\nend\n\n(* the polynomial commitment types *)\n\nmodule Fq_poly_comm = Kimchi_backend_common.Poly_comm.Make (struct\n module Curve = Pallas\n module Base_field = Fp\n\n module Backend = struct\n type t = Curve.Affine.Backend.t Kimchi_types.poly_comm\n\n let shifted ({ shifted; _ } : t) = shifted\n\n let unshifted ({ unshifted; _ } : t) = unshifted\n\n let make :\n Curve.Affine.Backend.t array -> Curve.Affine.Backend.t option -> t =\n fun unshifted shifted : t -> { shifted; unshifted }\n end\nend)\n\nmodule Fp_poly_comm = Kimchi_backend_common.Poly_comm.Make (struct\n module Curve = Vesta\n module Base_field = Fq\n\n module Backend = struct\n type t = Curve.Affine.Backend.t Kimchi_types.poly_comm\n\n let shifted ({ shifted; _ } : t) = shifted\n\n let unshifted ({ unshifted; _ } : t) = unshifted\n\n let make :\n Curve.Affine.Backend.t array -> Curve.Affine.Backend.t option -> t =\n fun unshifted shifted : t -> { shifted; unshifted }\n end\nend)\n","open Core_kernel\nopen Poly_types\nmodule Id = Hlist0.Id\nmodule HlistId = Hlist0.HlistId\nmodule H1_1 = Hlist0.H1_1\n\nmodule E13 (T : T1) = struct\n type ('a, _, _) t = 'a T.t\nend\n\nmodule E23 (T : T2) = struct\n type ('a, 'b, _) t = ('a, 'b) T.t\nend\n\nmodule E01 (T : T0) = struct\n type _ t = T.t\nend\n\nmodule E02 (T : T0) = struct\n type (_, _) t = T.t\nend\n\nmodule E03 (T : T0) = struct\n type (_, _, _) t = T.t\nend\n\nmodule E04 (T : T0) = struct\n type (_, _, _, _) t = T.t\nend\n\nmodule E06 (T : T0) = struct\n type (_, _, _, _, _, _) t = T.t\nend\n\nmodule Tuple2 (F : T3) (G : T3) = struct\n type ('a, 'b, 'c) t = ('a, 'b, 'c) F.t * ('a, 'b, 'c) G.t\nend\n\nmodule Tuple3 (F : T3) (G : T3) (H : T3) = struct\n type ('a, 'b, 'c) t = ('a, 'b, 'c) F.t * ('a, 'b, 'c) G.t * ('a, 'b, 'c) H.t\nend\n\nmodule Tuple4 (F : T3) (G : T3) (H : T3) (I : T3) = struct\n type ('a, 'b, 'c) t =\n ('a, 'b, 'c) F.t * ('a, 'b, 'c) G.t * ('a, 'b, 'c) H.t * ('a, 'b, 'c) I.t\nend\n\nmodule Tuple5 (F : T3) (G : T3) (H : T3) (I : T3) (J : T3) = struct\n type ('a, 'b, 'c) t =\n ('a, 'b, 'c) F.t\n * ('a, 'b, 'c) G.t\n * ('a, 'b, 'c) H.t\n * ('a, 'b, 'c) I.t\n * ('a, 'b, 'c) J.t\nend\n\nmodule Arg1 = struct\n type ('a, _, _) t = 'a\nend\n\nmodule Arg2 = struct\n type (_, 'a, _) t = 'a\nend\n\nmodule Apply2 (F : T2) (X : T1) (Y : T1) = struct\n type ('a, 'b) t = ('a X.t, 'b Y.t) F.t\nend\n\nmodule Dup (F : T2) = struct\n type 'a t = ('a, 'a) F.t\nend\n\nmodule Length = Hlist0.Length\n\nmodule H1 = struct\n module T = Hlist0.H1\n\n module Iter\n (F : T1) (C : sig\n val f : 'a F.t -> unit\n end) =\n struct\n let rec f : type a. a T(F).t -> unit = function\n | [] ->\n ()\n | x :: xs ->\n C.f x ; f xs\n end\n\n module Of_vector (X : T0) = struct\n let rec f :\n type xs length.\n (xs, length) Length.t -> (X.t, length) Vector.t -> xs T(E01(X)).t =\n fun l1 v ->\n match (l1, v) with Z, [] -> [] | S n1, x :: xs -> x :: f n1 xs\n end\n\n module Map\n (F : T1)\n (G : T1) (C : sig\n val f : 'a F.t -> 'a G.t\n end) =\n struct\n let rec f : type a. a T(F).t -> a T(G).t = function\n | [] ->\n []\n | x :: xs ->\n let y = C.f x in\n y :: f xs\n end\n\n module Fold\n (F : T1)\n (X : T0) (C : sig\n val f : X.t -> 'a F.t -> X.t\n end) =\n struct\n let rec f : type a. init:X.t -> a T(F).t -> X.t =\n fun ~init xs ->\n match xs with [] -> init | x :: xs -> f ~init:(C.f init x) xs\n end\n\n module Map_reduce\n (F : T1)\n (X : T0) (C : sig\n val reduce : X.t -> X.t -> X.t\n\n val map : 'a F.t -> X.t\n end) =\n struct\n let rec f : type a. X.t -> a T(F).t -> X.t =\n fun acc xs ->\n match xs with [] -> acc | x :: xs -> f (C.reduce acc (C.map x)) xs\n\n let f (type a) (xs : a T(F).t) =\n match xs with\n | [] ->\n failwith \"Hlist.Map_reduce: empty list\"\n | x :: xs ->\n f (C.map x) xs\n end\n\n module To_vector (X : T0) = struct\n let rec f :\n type xs length.\n (xs, length) Length.t -> xs T(E01(X)).t -> (X.t, length) Vector.t =\n fun l1 v ->\n match (l1, v) with Z, [] -> [] | S n1, x :: xs -> x :: f n1 xs\n end\n\n module Tuple2 (F : T1) (G : T1) = struct\n type 'a t = 'a F.t * 'a G.t\n end\n\n module Zip (F : T1) (G : T1) = struct\n let rec f : type a. a T(F).t -> a T(G).t -> a T(Tuple2(F)(G)).t =\n fun xs ys ->\n match (xs, ys) with [], [] -> [] | x :: xs, y :: ys -> (x, y) :: f xs ys\n end\n\n module Typ (Impl : sig\n type field\n end)\n (F : T1)\n (Var : T1)\n (Val : T1) (C : sig\n val f : 'a F.t -> ('a Var.t, 'a Val.t, Impl.field) Snarky_backendless.Typ.t\n end) =\n struct\n let rec f :\n type xs.\n xs T(F).t\n -> (xs T(Var).t, xs T(Val).t, Impl.field) Snarky_backendless.Typ.t =\n let transport, transport_var, tuple2, unit =\n Snarky_backendless.Typ.(transport, transport_var, tuple2, unit)\n in\n fun ts ->\n match ts with\n | t :: ts ->\n let tail = f ts in\n transport\n (tuple2 (C.f t) tail)\n ~there:(fun (x :: xs : _ T(Val).t) -> (x, xs))\n ~back:(fun (x, xs) -> x :: xs)\n |> transport_var\n ~there:(fun (x :: xs : _ T(Var).t) -> (x, xs))\n ~back:(fun (x, xs) -> x :: xs)\n | [] ->\n let there _ = () in\n transport (unit ()) ~there ~back:(fun () : _ T(Val).t -> [])\n |> transport_var ~there ~back:(fun () : _ T(Var).t -> [])\n end\nend\n\nmodule H2 = struct\n module Arg1 = struct\n type ('a, _) t = 'a\n end\n\n module Arg2 = struct\n type (_, 'a) t = 'a\n end\n\n module Tuple2 (F : T2) (G : T2) = struct\n type ('a, 'b) t = ('a, 'b) F.t * ('a, 'b) G.t\n end\n\n module T (F : T2) = struct\n type (_, _) t =\n | [] : (unit, unit) t\n | ( :: ) : ('a1, 'a2) F.t * ('b1, 'b2) t -> ('a1 * 'b1, 'a2 * 'b2) t\n\n let rec length : type tail1 tail2. (tail1, tail2) t -> tail1 Length.n =\n function\n | [] ->\n T (Z, Z)\n | _ :: xs ->\n let (T (n, p)) = length xs in\n T (S n, S p)\n end\n\n module Zip (F : T2) (G : T2) = struct\n let rec f :\n type a b. (a, b) T(F).t -> (a, b) T(G).t -> (a, b) T(Tuple2(F)(G)).t =\n fun xs ys ->\n match (xs, ys) with [], [] -> [] | x :: xs, y :: ys -> (x, y) :: f xs ys\n end\n\n module Map\n (F : T2)\n (G : T2) (C : sig\n val f : ('a, 'b) F.t -> ('a, 'b) G.t\n end) =\n struct\n let rec f : type a b. (a, b) T(F).t -> (a, b) T(G).t = function\n | [] ->\n []\n | x :: xs ->\n let y = C.f x in\n y :: f xs\n end\n\n module Typ (Impl : sig\n type field\n\n module Typ : sig\n type ('var, 'value) t = ('var, 'value, field) Snarky_backendless.Typ.t\n end\n end) =\n struct\n let transport, transport_var, tuple2, unit =\n Snarky_backendless.Typ.(transport, transport_var, tuple2, unit)\n\n let rec f :\n type vars values.\n (vars, values) T(Impl.Typ).t\n -> ( vars H1.T(Id).t\n , values H1.T(Id).t\n , Impl.field )\n Snarky_backendless.Typ.t =\n fun ts ->\n match ts with\n | [] ->\n let there _ = () in\n transport (unit ()) ~there ~back:(fun () : _ H1.T(Id).t -> [])\n |> transport_var ~there ~back:(fun () : _ H1.T(Id).t -> [])\n | t :: ts ->\n transport\n (tuple2 t (f ts))\n ~there:(fun (x :: xs : _ H1.T(Id).t) -> (x, xs))\n ~back:(fun (x, xs) -> x :: xs)\n |> transport_var\n ~there:(fun (x :: xs : _ H1.T(Id).t) -> (x, xs))\n ~back:(fun (x, xs) -> x :: xs)\n end\nend\n\nmodule H3_2 = struct\n module T (F : sig\n type (_, _, _, _, _) t\n end) =\n struct\n type (_, _, _, 's1, 's2) t =\n | [] : (unit, unit, unit, _, _) t\n | ( :: ) :\n ('a1, 'a2, 'a3, 's1, 's2) F.t * ('b1, 'b2, 'b3, 's1, 's2) t\n -> ('a1 * 'b1, 'a2 * 'b2, 'a3 * 'b3, 's1, 's2) t\n\n let rec length : type t1 t2 t3 e1 e2. (t1, t2, t3, e1, e2) t -> t1 Length.n\n = function\n | [] ->\n T (Z, Z)\n | _ :: xs ->\n let (T (n, p)) = length xs in\n T (S n, S p)\n end\nend\n\nmodule H3_3 = struct\n module T (F : sig\n type (_, _, _, _, _, _) t\n end) =\n struct\n type (_, _, _, 's1, 's2, 's3) t =\n | [] : (unit, unit, unit, _, _, _) t\n | ( :: ) :\n ('a1, 'a2, 'a3, 's1, 's2, 's3) F.t * ('b1, 'b2, 'b3, 's1, 's2, 's3) t\n -> ('a1 * 'b1, 'a2 * 'b2, 'a3 * 'b3, 's1, 's2, 's3) t\n\n let rec length :\n type t1 t2 t3 e1 e2 e3. (t1, t2, t3, e1, e2, e3) t -> t1 Length.n =\n function\n | [] ->\n T (Z, Z)\n | _ :: xs ->\n let (T (n, p)) = length xs in\n T (S n, S p)\n end\nend\n\nmodule H3_4 = struct\n module T (F : sig\n type (_, _, _, _, _, _, _) t\n end) =\n struct\n type (_, _, _, 's1, 's2, 's3, 's4) t =\n | [] : (unit, unit, unit, _, _, _, _) t\n | ( :: ) :\n ('a1, 'a2, 'a3, 's1, 's2, 's3, 's4) F.t\n * ('b1, 'b2, 'b3, 's1, 's2, 's3, 's4) t\n -> ('a1 * 'b1, 'a2 * 'b2, 'a3 * 'b3, 's1, 's2, 's3, 's4) t\n\n let rec length :\n type t1 t2 t3 e1 e2 e3 e4. (t1, t2, t3, e1, e2, e3, e4) t -> t1 Length.n\n = function\n | [] ->\n T (Z, Z)\n | _ :: xs ->\n let (T (n, p)) = length xs in\n T (S n, S p)\n end\nend\n\nmodule H2_1 = struct\n module T (F : sig\n type (_, _, _) t\n end) =\n struct\n type (_, _, 's) t =\n | [] : (unit, unit, _) t\n | ( :: ) :\n ('a1, 'a2, 's) F.t * ('b1, 'b2, 's) t\n -> ('a1 * 'b1, 'a2 * 'b2, 's) t\n\n let rec length : type tail1 tail2 e. (tail1, tail2, e) t -> tail1 Length.n =\n function\n | [] ->\n T (Z, Z)\n | _ :: xs ->\n let (T (n, p)) = length xs in\n T (S n, S p)\n end\n\n module Iter\n (F : T3) (C : sig\n val f : ('a, 'b, 'c) F.t -> unit\n end) =\n struct\n let rec f : type a b c. (a, b, c) T(F).t -> unit = function\n | [] ->\n ()\n | x :: xs ->\n C.f x ; f xs\n end\n\n module Map_\n (F : T3)\n (G : T3) (Env : sig\n type t\n end) (C : sig\n val f : ('a, 'b, Env.t) F.t -> ('a, 'b, Env.t) G.t\n end) =\n struct\n let rec f : type a b. (a, b, Env.t) T(F).t -> (a, b, Env.t) T(G).t =\n function\n | [] ->\n []\n | x :: xs ->\n let y = C.f x in\n y :: f xs\n end\n\n module Map\n (F : T3)\n (G : T3) (C : sig\n val f : ('a, 'b, 'c) F.t -> ('a, 'b, 'c) G.t\n end) =\n struct\n let f : type a b c. (a, b, c) T(F).t -> (a, b, c) T(G).t =\n fun xs ->\n let module M =\n Map_ (F) (G)\n (struct\n type t = c\n end)\n (struct\n let f = C.f\n end)\n in\n M.f xs\n end\n\n module Zip (F : T3) (G : T3) = struct\n let rec f :\n type a b c.\n (a, b, c) T(F).t -> (a, b, c) T(G).t -> (a, b, c) T(Tuple2(F)(G)).t =\n fun xs ys ->\n match (xs, ys) with [], [] -> [] | x :: xs, y :: ys -> (x, y) :: f xs ys\n end\n\n module Zip3 (F1 : T3) (F2 : T3) (F3 : T3) = struct\n let rec f :\n type a b c.\n (a, b, c) T(F1).t\n -> (a, b, c) T(F2).t\n -> (a, b, c) T(F3).t\n -> (a, b, c) T(Tuple3(F1)(F2)(F3)).t =\n fun xs ys zs ->\n match (xs, ys, zs) with\n | [], [], [] ->\n []\n | x :: xs, y :: ys, z :: zs ->\n (x, y, z) :: f xs ys zs\n end\n\n module Unzip3 (F1 : T3) (F2 : T3) (F3 : T3) = struct\n let rec f :\n type a b c.\n (a, b, c) T(Tuple3(F1)(F2)(F3)).t\n -> (a, b, c) T(F1).t * (a, b, c) T(F2).t * (a, b, c) T(F3).t =\n fun ts ->\n match ts with\n | [] ->\n ([], [], [])\n | (x, y, z) :: ts ->\n let xs, ys, zs = f ts in\n (x :: xs, y :: ys, z :: zs)\n end\n\n module Zip4 (F1 : T3) (F2 : T3) (F3 : T3) (F4 : T3) = struct\n let rec f :\n type a b c.\n (a, b, c) T(F1).t\n -> (a, b, c) T(F2).t\n -> (a, b, c) T(F3).t\n -> (a, b, c) T(F4).t\n -> (a, b, c) T(Tuple4(F1)(F2)(F3)(F4)).t =\n fun xs ys zs ws ->\n match (xs, ys, zs, ws) with\n | [], [], [], [] ->\n []\n | x :: xs, y :: ys, z :: zs, w :: ws ->\n (x, y, z, w) :: f xs ys zs ws\n end\n\n module Zip5 (F1 : T3) (F2 : T3) (F3 : T3) (F4 : T3) (F5 : T3) = struct\n let rec f :\n type a b c.\n (a, b, c) T(F1).t\n -> (a, b, c) T(F2).t\n -> (a, b, c) T(F3).t\n -> (a, b, c) T(F4).t\n -> (a, b, c) T(F5).t\n -> (a, b, c) T(Tuple5(F1)(F2)(F3)(F4)(F5)).t =\n fun l1 l2 l3 l4 l5 ->\n match (l1, l2, l3, l4, l5) with\n | [], [], [], [], [] ->\n []\n | x1 :: l1, x2 :: l2, x3 :: l3, x4 :: l4, x5 :: l5 ->\n (x1, x2, x3, x4, x5) :: f l1 l2 l3 l4 l5\n end\n\n module Of_vector (X : T0) = struct\n let rec f :\n type e xs ys length.\n (xs, length) Length.t\n -> (ys, length) Length.t\n -> (X.t, length) Vector.t\n -> (xs, ys, e) T(E03(X)).t =\n fun l1 l2 v ->\n match (l1, l2, v) with\n | Z, Z, [] ->\n []\n | S n1, S n2, x :: xs ->\n x :: f n1 n2 xs\n end\n\n module To_vector (X : T0) = struct\n let rec f :\n type e xs ys length.\n (xs, length) Length.t\n -> (xs, ys, e) T(E03(X)).t\n -> (X.t, length) Vector.t =\n fun l1 v ->\n match (l1, v) with Z, [] -> [] | S n1, x :: xs -> x :: f n1 xs\n end\nend\n\nmodule H3 = struct\n module T (F : sig\n type (_, _, _) t\n end) =\n struct\n type (_, _, _) t =\n | [] : (unit, unit, unit) t\n | ( :: ) :\n ('a1, 'a2, 'a3) F.t * ('b1, 'b2, 'b3) t\n -> ('a1 * 'b1, 'a2 * 'b2, 'a3 * 'b3) t\n\n let rec length :\n type tail1 tail2 tail3. (tail1, tail2, tail3) t -> tail1 Length.n =\n function\n | [] ->\n T (Z, Z)\n | _ :: xs ->\n let (T (n, p)) = length xs in\n T (S n, S p)\n end\n\n module To_vector (X : T0) = struct\n let rec f :\n type a b c length.\n (a, length) Length.t -> (a, b, c) T(E03(X)).t -> (X.t, length) Vector.t\n =\n fun l1 v ->\n match (l1, v) with Z, [] -> [] | S n1, x :: xs -> x :: f n1 xs\n end\n\n module Zip (F : T3) (G : T3) = struct\n let rec f :\n type a b c.\n (a, b, c) T(F).t -> (a, b, c) T(G).t -> (a, b, c) T(Tuple2(F)(G)).t =\n fun xs ys ->\n match (xs, ys) with [], [] -> [] | x :: xs, y :: ys -> (x, y) :: f xs ys\n end\n\n module Arg1 = struct\n type ('a, _, _) t = 'a\n end\n\n module Map1_to_H1\n (F : T3)\n (G : T1) (C : sig\n val f : ('a, 'b, 'c) F.t -> 'a G.t\n end) =\n struct\n let rec f : type a b c. (a, b, c) T(F).t -> a H1.T(G).t = function\n | [] ->\n []\n | x :: xs ->\n let y = C.f x in\n y :: f xs\n end\n\n module Map2_to_H1\n (F : T3)\n (G : T1) (C : sig\n val f : ('a, 'b, 'c) F.t -> 'b G.t\n end) =\n struct\n let rec f : type a b c. (a, b, c) T(F).t -> b H1.T(G).t = function\n | [] ->\n []\n | x :: xs ->\n let y = C.f x in\n y :: f xs\n end\n\n module Map\n (F : T3)\n (G : T3) (C : sig\n val f : ('a, 'b, 'c) F.t -> ('a, 'b, 'c) G.t\n end) =\n struct\n let rec f : type a b c. (a, b, c) T(F).t -> (a, b, c) T(G).t = function\n | [] ->\n []\n | x :: xs ->\n let y = C.f x in\n y :: f xs\n end\nend\n\nmodule H4 = struct\n module T (F : sig\n type (_, _, _, _) t\n end) =\n struct\n type (_, _, _, _) t =\n | [] : (unit, unit, unit, unit) t\n | ( :: ) :\n ('a1, 'a2, 'a3, 'a4) F.t * ('b1, 'b2, 'b3, 'b4) t\n -> ('a1 * 'b1, 'a2 * 'b2, 'a3 * 'b3, 'a4 * 'b4) t\n\n let rec length :\n type tail1 tail2 tail3 tail4.\n (tail1, tail2, tail3, tail4) t -> tail1 Length.n = function\n | [] ->\n T (Z, Z)\n | _ :: xs ->\n let (T (n, p)) = length xs in\n T (S n, S p)\n end\n\n module Fold\n (F : T4)\n (X : T0) (C : sig\n val f : X.t -> _ F.t -> X.t\n end) =\n struct\n let rec f : type a b c d. init:X.t -> (a, b, c, d) T(F).t -> X.t =\n fun ~init xs ->\n match xs with [] -> init | x :: xs -> f ~init:(C.f init x) xs\n end\n\n module Iter\n (F : T4) (C : sig\n val f : _ F.t -> unit\n end) =\n struct\n let rec f : type a b c d. (a, b, c, d) T(F).t -> unit =\n fun xs -> match xs with [] -> () | x :: xs -> C.f x ; f xs\n end\n\n module Map\n (F : T4)\n (G : T4) (C : sig\n val f : ('a, 'b, 'c, 'd) F.t -> ('a, 'b, 'c, 'd) G.t\n end) =\n struct\n let rec f : type a b c d. (a, b, c, d) T(F).t -> (a, b, c, d) T(G).t =\n function\n | [] ->\n []\n | x :: xs ->\n let y = C.f x in\n y :: f xs\n end\n\n module To_vector (X : T0) = struct\n let rec f :\n type a b c d length.\n (a, length) Length.t\n -> (a, b, c, d) T(E04(X)).t\n -> (X.t, length) Vector.t =\n fun l1 v ->\n match (l1, v) with Z, [] -> [] | S n1, x :: xs -> x :: f n1 xs\n end\n\n module Tuple2 (F : T4) (G : T4) = struct\n type ('a, 'b, 'c, 'd) t = ('a, 'b, 'c, 'd) F.t * ('a, 'b, 'c, 'd) G.t\n end\n\n module Zip (F : T4) (G : T4) = struct\n let rec f :\n type a b c d.\n (a, b, c, d) T(F).t\n -> (a, b, c, d) T(G).t\n -> (a, b, c, d) T(Tuple2(F)(G)).t =\n fun xs ys ->\n match (xs, ys) with [], [] -> [] | x :: xs, y :: ys -> (x, y) :: f xs ys\n end\n\n module Length_1_to_2 (F : T4) = struct\n let rec f :\n type n xs ys a b.\n (xs, ys, a, b) T(F).t -> (xs, n) Length.t -> (ys, n) Length.t =\n fun xs n -> match (xs, n) with [], Z -> Z | _ :: xs, S n -> S (f xs n)\n end\n\n module Typ (Impl : sig\n type field\n end)\n (F : T4)\n (Var : T3)\n (Val : T3) (C : sig\n val f :\n ('var, 'value, 'n1, 'n2) F.t\n -> ( ('var, 'n1, 'n2) Var.t\n , ('value, 'n1, 'n2) Val.t\n , Impl.field )\n Snarky_backendless.Typ.t\n end) =\n struct\n let transport, transport_var, tuple2, unit =\n Snarky_backendless.Typ.(transport, transport_var, tuple2, unit)\n\n let rec f :\n type vars values ns1 ns2.\n (vars, values, ns1, ns2) T(F).t\n -> ( (vars, ns1, ns2) H3.T(Var).t\n , (values, ns1, ns2) H3.T(Val).t\n , Impl.field )\n Snarky_backendless.Typ.t =\n fun ts ->\n match ts with\n | [] ->\n let there _ = () in\n transport (unit ()) ~there ~back:(fun () : _ H3.T(Val).t -> [])\n |> transport_var ~there ~back:(fun () : _ H3.T(Var).t -> [])\n | t :: ts ->\n transport\n (tuple2 (C.f t) (f ts))\n ~there:(fun (x :: xs : _ H3.T(Val).t) -> (x, xs))\n ~back:(fun (x, xs) -> x :: xs)\n |> transport_var\n ~there:(fun (x :: xs : _ H3.T(Var).t) -> (x, xs))\n ~back:(fun (x, xs) -> x :: xs)\n end\nend\n\nmodule H6 = struct\n module T (F : sig\n type (_, _, _, _, _, _) t\n end) =\n struct\n type (_, _, _, _, _, _) t =\n | [] : (unit, unit, unit, unit, unit, unit) t\n | ( :: ) :\n ('a1, 'a2, 'a3, 'a4, 'a5, 'a6) F.t * ('b1, 'b2, 'b3, 'b4, 'b5, 'b6) t\n -> ( 'a1 * 'b1\n , 'a2 * 'b2\n , 'a3 * 'b3\n , 'a4 * 'b4\n , 'a5 * 'b5\n , 'a6 * 'b6 )\n t\n\n let rec length :\n type tail1 tail2 tail3 tail4 tail5 tail6.\n (tail1, tail2, tail3, tail4, tail5, tail6) t -> tail1 Length.n =\n function\n | [] ->\n T (Z, Z)\n | _ :: xs ->\n let (T (n, p)) = length xs in\n T (S n, S p)\n end\n\n module Fold\n (F : T6)\n (X : T0) (C : sig\n val f : X.t -> _ F.t -> X.t\n end) =\n struct\n let rec f :\n type a1 a2 a3 a4 a5 a6.\n init:X.t -> (a1, a2, a3, a4, a5, a6) T(F).t -> X.t =\n fun ~init xs ->\n match xs with [] -> init | x :: xs -> f ~init:(C.f init x) xs\n end\n\n module Iter\n (F : T6) (C : sig\n val f : _ F.t -> unit\n end) =\n struct\n let rec f : type a1 a2 a3 a4 a5 a6. (a1, a2, a3, a4, a5, a6) T(F).t -> unit\n =\n fun xs -> match xs with [] -> () | x :: xs -> C.f x ; f xs\n end\n\n module Map\n (F : T6)\n (G : T6) (C : sig\n val f :\n ('a1, 'a2, 'a3, 'a4, 'a5, 'a6) F.t\n -> ('a1, 'a2, 'a3, 'a4, 'a5, 'a6) G.t\n end) =\n struct\n let rec f :\n type a1 a2 a3 a4 a5 a6.\n (a1, a2, a3, a4, a5, a6) T(F).t -> (a1, a2, a3, a4, a5, a6) T(G).t =\n function\n | [] ->\n []\n | x :: xs ->\n let y = C.f x in\n y :: f xs\n end\n\n module To_vector (X : T0) = struct\n let rec f :\n type a1 a2 a3 a4 a5 a6 length.\n (a1, length) Length.t\n -> (a1, a2, a3, a4, a5, a6) T(E06(X)).t\n -> (X.t, length) Vector.t =\n fun l1 v ->\n match (l1, v) with Z, [] -> [] | S n1, x :: xs -> x :: f n1 xs\n end\n\n module Tuple2 (F : T6) (G : T6) = struct\n type ('a1, 'a2, 'a3, 'a4, 'a5, 'a6) t =\n ('a1, 'a2, 'a3, 'a4, 'a5, 'a6) F.t * ('a1, 'a2, 'a3, 'a4, 'a5, 'a6) G.t\n end\n\n module Zip (F : T6) (G : T6) = struct\n let rec f :\n type a1 a2 a3 a4 a5 a6.\n (a1, a2, a3, a4, a5, a6) T(F).t\n -> (a1, a2, a3, a4, a5, a6) T(G).t\n -> (a1, a2, a3, a4, a5, a6) T(Tuple2(F)(G)).t =\n fun xs ys ->\n match (xs, ys) with [], [] -> [] | x :: xs, y :: ys -> (x, y) :: f xs ys\n end\n\n module Length_1_to_2 (F : T6) = struct\n let rec f :\n type n a1 a2 a3 a4 a5 a6.\n (a1, a2, a3, a4, a5, a6) T(F).t -> (a1, n) Length.t -> (a2, n) Length.t\n =\n fun xs n -> match (xs, n) with [], Z -> Z | _ :: xs, S n -> S (f xs n)\n end\n\n module Typ (Impl : sig\n type field\n end)\n (F : T6)\n (Var : T4)\n (Val : T4) (C : sig\n val f :\n ('var, 'value, 'ret_var, 'ret_value, 'n1, 'n2) F.t\n -> ( ('var, 'ret_var, 'n1, 'n2) Var.t\n , ('value, 'ret_value, 'n1, 'n2) Val.t\n , Impl.field )\n Snarky_backendless.Typ.t\n end) =\n struct\n let transport, transport_var, tuple2, unit =\n Snarky_backendless.Typ.(transport, transport_var, tuple2, unit)\n\n let rec f :\n type vars values ret_vars ret_values ns1 ns2.\n (vars, values, ret_vars, ret_values, ns1, ns2) T(F).t\n -> ( (vars, ret_vars, ns1, ns2) H4.T(Var).t\n , (values, ret_values, ns1, ns2) H4.T(Val).t\n , Impl.field )\n Snarky_backendless.Typ.t =\n fun ts ->\n match ts with\n | [] ->\n let there _ = () in\n transport (unit ()) ~there ~back:(fun () : _ H4.T(Val).t -> [])\n |> transport_var ~there ~back:(fun () : _ H4.T(Var).t -> [])\n | t :: ts ->\n transport\n (tuple2 (C.f t) (f ts))\n ~there:(fun (x :: xs : _ H4.T(Val).t) -> (x, xs))\n ~back:(fun (x, xs) -> x :: xs)\n |> transport_var\n ~there:(fun (x :: xs : _ H4.T(Var).t) -> (x, xs))\n ~back:(fun (x, xs) -> x :: xs)\n end\nend\n\nmodule H4_2 = struct\n module T (F : sig\n type (_, _, _, _, _, _) t\n end) =\n struct\n type (_, _, _, _, 's1, 's2) t =\n | [] : (unit, unit, unit, unit, _, _) t\n | ( :: ) :\n ('a1, 'a2, 'a3, 'a4, 's1, 's2) F.t * ('b1, 'b2, 'b3, 'b4, 's1, 's2) t\n -> ('a1 * 'b1, 'a2 * 'b2, 'a3 * 'b3, 'a4 * 'b4, 's1, 's2) t\n\n let rec length :\n type t1 t2 t3 t4 e1 e2. (t1, t2, t3, t4, e1, e2) t -> t1 Length.n =\n function\n | [] ->\n T (Z, Z)\n | _ :: xs ->\n let (T (n, p)) = length xs in\n T (S n, S p)\n end\nend\n\nmodule H4_4 = struct\n module T (F : sig\n type (_, _, _, _, _, _, _, _) t\n end) =\n struct\n type (_, _, _, _, 's1, 's2, 's3, 's4) t =\n | [] : (unit, unit, unit, unit, _, _, _, _) t\n | ( :: ) :\n ('a1, 'a2, 'a3, 'a4, 's1, 's2, 's3, 's4) F.t\n * ('b1, 'b2, 'b3, 'b4, 's1, 's2, 's3, 's4) t\n -> ('a1 * 'b1, 'a2 * 'b2, 'a3 * 'b3, 'a4 * 'b4, 's1, 's2, 's3, 's4) t\n\n let rec length :\n type t1 t2 t3 t4 e1 e2 e3 e4.\n (t1, t2, t3, t4, e1, e2, e3, e4) t -> t1 Length.n = function\n | [] ->\n T (Z, Z)\n | _ :: xs ->\n let (T (n, p)) = length xs in\n T (S n, S p)\n end\nend\n\nmodule H4_6 = struct\n module T (F : sig\n type (_, _, _, _, _, _, _, _, _, _) t\n end) =\n struct\n type (_, _, _, _, 's1, 's2, 's3, 's4, 's5, 's6) t =\n | [] : (unit, unit, unit, unit, _, _, _, _, _, _) t\n | ( :: ) :\n ('a1, 'a2, 'a3, 'a4, 's1, 's2, 's3, 's4, 's5, 's6) F.t\n * ('b1, 'b2, 'b3, 'b4, 's1, 's2, 's3, 's4, 's5, 's6) t\n -> ( 'a1 * 'b1\n , 'a2 * 'b2\n , 'a3 * 'b3\n , 'a4 * 'b4\n , 's1\n , 's2\n , 's3\n , 's4\n , 's5\n , 's6 )\n t\n\n let rec length :\n type t1 t2 t3 t4 e1 e2 e3 e4 e5 e6.\n (t1, t2, t3, t4, e1, e2, e3, e4, e5, e6) t -> t1 Length.n = function\n | [] ->\n T (Z, Z)\n | _ :: xs ->\n let (T (n, p)) = length xs in\n T (S n, S p)\n end\nend\n\nmodule H6_2 = struct\n module T (F : sig\n type (_, _, _, _, _, _, _, _) t\n end) =\n struct\n type (_, _, _, _, _, _, 's1, 's2) t =\n | [] : (unit, unit, unit, unit, unit, unit, _, _) t\n | ( :: ) :\n ('a1, 'a2, 'a3, 'a4, 'a5, 'a6, 's1, 's2) F.t\n * ('b1, 'b2, 'b3, 'b4, 'b5, 'b6, 's1, 's2) t\n -> ( 'a1 * 'b1\n , 'a2 * 'b2\n , 'a3 * 'b3\n , 'a4 * 'b4\n , 'a5 * 'b5\n , 'a6 * 'b6\n , 's1\n , 's2 )\n t\n\n let rec length :\n type t1 t2 t3 t4 t5 t6 e1 e2.\n (t1, t2, t3, t4, t5, t6, e1, e2) t -> t1 Length.n = function\n | [] ->\n T (Z, Z)\n | _ :: xs ->\n let (T (n, p)) = length xs in\n T (S n, S p)\n end\nend\n\nmodule H6_4 = struct\n module T (F : sig\n type (_, _, _, _, _, _, _, _, _, _) t\n end) =\n struct\n type (_, _, _, _, _, _, 's1, 's2, 's3, 's4) t =\n | [] : (unit, unit, unit, unit, unit, unit, _, _, _, _) t\n | ( :: ) :\n ('a1, 'a2, 'a3, 'a4, 'a5, 'a6, 's1, 's2, 's3, 's4) F.t\n * ('b1, 'b2, 'b3, 'b4, 'b5, 'b6, 's1, 's2, 's3, 's4) t\n -> ( 'a1 * 'b1\n , 'a2 * 'b2\n , 'a3 * 'b3\n , 'a4 * 'b4\n , 'a5 * 'b5\n , 'a6 * 'b6\n , 's1\n , 's2\n , 's3\n , 's4 )\n t\n\n let rec length :\n type t1 t2 t3 t4 t5 t6 e1 e2 e3 e4.\n (t1, t2, t3, t4, t5, t6, e1, e2, e3, e4) t -> t1 Length.n = function\n | [] ->\n T (Z, Z)\n | _ :: xs ->\n let (T (n, p)) = length xs in\n T (S n, S p)\n end\nend\n\nmodule H3_1 (F : sig\n type (_, _, _, _) t\nend) =\nstruct\n type (_, _, _, 's) t =\n | [] : (unit, unit, unit, _) t\n | ( :: ) :\n ('a1, 'a2, 'a3, 's) F.t * ('b1, 'b2, 'b3, 's) t\n -> ('a1 * 'b1, 'a2 * 'b2, 'a3 * 'b3, 's) t\n\n let rec length :\n type tail1 tail2 tail3 e. (tail1, tail2, tail3, e) t -> tail1 Length.n =\n function\n | [] ->\n T (Z, Z)\n | _ :: xs ->\n let (T (n, p)) = length xs in\n T (S n, S p)\nend\n\nmodule Map_1_specific\n (F : T2)\n (G : T2) (C : sig\n type b1\n\n type b2\n\n val f : ('a, b1) F.t -> ('a, b2) G.t\n end) =\nstruct\n let rec f : type a. (a, C.b1) H1_1(F).t -> (a, C.b2) H1_1(G).t = function\n | [] ->\n []\n | x :: xs ->\n let y = C.f x in\n y :: f xs\nend\n\nopen Nat\n\nmodule type Max_s = sig\n type ns\n\n type n\n\n val n : n t\n\n val p : (ns, n) H1_1(Lte).t\nend\n\ntype 'ns max = (module Max_s with type ns = 'ns)\n\nlet rec max : type n ns. (n * ns) H1.T(Nat).t -> (n * ns) max =\n fun xs ->\n match xs with\n | [ x ] ->\n let module M = struct\n type nonrec ns = n * ns\n\n type nonrec n = n\n\n let n = x\n\n let p : (_, _) H1_1(Lte).t = [ Lte.refl x ]\n end in\n (module M : Max_s with type ns = n * ns)\n | x :: (_ :: _ as ys) -> (\n let (module Max) = max ys in\n match compare x Max.n with\n | `Lte p_x ->\n let module M = struct\n type nonrec ns = n * ns\n\n type n = Max.n\n\n let n = Max.n\n\n let p : (ns, Max.n) H1_1(Lte).t = p_x :: Max.p\n end in\n (module M)\n | `Gt gt ->\n let max_lt_x = gt_implies_gte x Max.n gt in\n let module M =\n Map_1_specific (Lte) (Lte)\n (struct\n type b1 = Max.n\n\n type b2 = n\n\n let f : type a. (a, Max.n) Lte.t -> (a, n) Lte.t =\n fun a_lt_max -> Lte.trans a_lt_max max_lt_x\n end)\n in\n let module M : Max_s with type ns = n * ns = struct\n type nonrec ns = n * ns\n\n type nonrec n = n\n\n let n = x\n\n let p : (ns, n) H1_1(Lte).t = Lte.refl x :: M.f Max.p\n end in\n (module M) )\n\nlet max_exn : type ns. ns H1.T(Nat).t -> ns max = function\n | [] ->\n failwith \"max_exn: empty list\"\n | _ :: _ as xs ->\n max xs\n\nmodule Maxes = struct\n module type S = sig\n type ns\n\n type length\n\n val length : (ns, length) Length.t\n\n val maxes : ns H1.T(Nat).t\n end\n\n type 'length t = T : 'ns H1.T(Nat).t * ('ns, 'length) Length.t -> 'length t\n\n let rec f : type branches n. ((int, branches) Vector.t, n) Vector.t -> n t =\n function\n | [] ->\n T ([], Length.Z)\n | v :: vs ->\n let (T (maxes, len)) = f vs in\n let (T n) = Nat.of_int (Vector.reduce_exn v ~f:Int.max) in\n T (n :: maxes, S len)\n\n let m (type length) (vs : (_, length) Vector.t) :\n (module S with type length = length) =\n let g :\n type length ns.\n ns H1.T(Nat).t\n -> (ns, length) Length.t\n -> (module S with type length = length) =\n fun maxes length ->\n ( module struct\n type nonrec length = length\n\n type nonrec ns = ns\n\n let length = length\n\n let maxes = maxes\n end )\n in\n let (T (ms, len)) = f vs in\n g ms len\nend\n\nmodule Lengths = struct\n let rec extract :\n type prev_varss ns env.\n (prev_varss, ns, env) H2_1.T(E23(Length)).t -> ns H1.T(Nat).t = function\n | [] ->\n []\n | n :: ns ->\n (* TODO: This is quadratic because of Length.to_nat *)\n Length.to_nat n :: extract ns\n\n type ('prev_varss, 'prev_valss, 'env) t =\n | T :\n ('prev_varss, 'ns, 'env) H2_1.T(E23(Length)).t\n -> ('prev_varss, 'prev_valss, 'env) t\nend\n","open Core_kernel\n\n[@@@warning \"-4\"]\n\n[%%versioned\nmodule Stable = struct\n module V1 = struct\n type 'a t = Infinity | Finite of 'a\n [@@deriving sexp, equal, compare, hash, yojson]\n end\nend]\n\n[@@@warning \"+4\"]\n\nlet finite_exn = function\n | Finite x ->\n x\n | Infinity ->\n failwith \"curve point must not be the point at infinity\"\n","open Core_kernel\nopen Pickles_types\nopen Pickles_base\nmodule Scalars = Scalars\nmodule Domain = Domain\nmodule Opt = Plonk_types.Opt\n\ntype 'field vanishing_polynomial_domain =\n < vanishing_polynomial : 'field -> 'field >\n\ntype 'field plonk_domain =\n < vanishing_polynomial : 'field -> 'field\n ; shifts : 'field Plonk_types.Shifts.t\n ; generator : 'field >\n\ntype 'field domain = < size : 'field ; vanishing_polynomial : 'field -> 'field >\n\nmodule type Bool_intf = sig\n type t\n\n val true_ : t\n\n val false_ : t\n\n val ( &&& ) : t -> t -> t\n\n val ( ||| ) : t -> t -> t\n\n val any : t list -> t\nend\n\nmodule type Field_intf = sig\n type t\n\n val size_in_bits : int\n\n val zero : t\n\n val one : t\n\n val of_int : int -> t\n\n val ( * ) : t -> t -> t\n\n val ( / ) : t -> t -> t\n\n val ( + ) : t -> t -> t\n\n val ( - ) : t -> t -> t\n\n val inv : t -> t\n\n val negate : t -> t\nend\n\nmodule type Field_with_if_intf = sig\n include Field_intf\n\n type bool\n\n val if_ : bool -> then_:(unit -> t) -> else_:(unit -> t) -> t\nend\n\ntype 'f field = (module Field_intf with type t = 'f)\n\nlet pow2pow (type t) ((module F) : t field) (x : t) n : t =\n let rec go acc i = if i = 0 then acc else go F.(acc * acc) (i - 1) in\n go x n\n\n(* x^{2 ^ k} - 1 *)\nlet vanishing_polynomial (type t) ((module F) : t field) domain x =\n let k = Domain.log2_size domain in\n F.(pow2pow (module F) x k - one)\n\nlet domain (type t) ((module F) : t field) ~shifts ~domain_generator\n (domain : Domain.t) : t plonk_domain =\n let log2_size = Domain.log2_size domain in\n let shifts = shifts ~log2_size in\n let generator = domain_generator ~log2_size in\n object\n method shifts = shifts\n\n method vanishing_polynomial x = vanishing_polynomial (module F) domain x\n\n method generator = generator\n end\n\nlet actual_evaluation (type f) (module Field : Field_intf with type t = f)\n (e : Field.t array) (pt : Field.t) ~rounds : Field.t =\n let pt_n =\n let rec go acc i = if i = 0 then acc else go Field.(acc * acc) (i - 1) in\n go pt rounds\n in\n match List.rev (Array.to_list e) with\n | e :: es ->\n List.fold ~init:e es ~f:(fun acc fx -> Field.(fx + (pt_n * acc)))\n | [] ->\n Field.of_int 0\n\nlet evals_of_split_evals field ~zeta ~zetaw (es : _ Plonk_types.Evals.t) ~rounds\n =\n let e = Fn.flip (actual_evaluation field ~rounds) in\n Plonk_types.Evals.map es ~f:(fun (x1, x2) -> (e zeta x1, e zetaw x2))\n\nopen Composition_types.Wrap.Proof_state.Deferred_values.Plonk\n\ntype 'bool all_feature_flags =\n { lookup_tables : 'bool Lazy.t\n ; table_width_at_least_1 : 'bool Lazy.t\n ; table_width_at_least_2 : 'bool Lazy.t\n ; table_width_3 : 'bool Lazy.t\n ; lookups_per_row_3 : 'bool Lazy.t\n ; lookups_per_row_4 : 'bool Lazy.t\n ; lookup_pattern_xor : 'bool Lazy.t\n ; lookup_pattern_range_check : 'bool Lazy.t\n ; features : 'bool Plonk_types.Features.t\n }\n\nlet expand_feature_flags (type boolean)\n (module B : Bool_intf with type t = boolean)\n ({ range_check0\n ; range_check1\n ; foreign_field_add = _\n ; foreign_field_mul\n ; xor\n ; rot\n ; lookup\n ; runtime_tables = _\n } as features :\n boolean Plonk_types.Features.t ) : boolean all_feature_flags =\n let lookup_pattern_range_check =\n (* RangeCheck, Rot gates use RangeCheck lookup pattern *)\n lazy B.(range_check0 ||| range_check1 ||| rot)\n in\n let lookup_pattern_xor =\n (* Xor lookup pattern *)\n lazy xor\n in\n (* Make sure these stay up-to-date with the layouts!! *)\n let table_width_3 =\n (* Xor have max_joint_size = 3 *)\n lookup_pattern_xor\n in\n let table_width_at_least_2 =\n (* Lookup has max_joint_size = 2 *)\n lazy (B.( ||| ) (Lazy.force table_width_3) lookup)\n in\n let table_width_at_least_1 =\n (* RangeCheck, ForeignFieldMul have max_joint_size = 1 *)\n lazy\n (B.any\n [ Lazy.force table_width_at_least_2\n ; Lazy.force lookup_pattern_range_check\n ; foreign_field_mul\n ] )\n in\n let lookups_per_row_4 =\n (* Xor, RangeCheckGate, ForeignFieldMul, have max_lookups_per_row = 4 *)\n lazy\n (B.any\n [ Lazy.force lookup_pattern_xor\n ; Lazy.force lookup_pattern_range_check\n ; foreign_field_mul\n ] )\n in\n let lookups_per_row_3 =\n (* Lookup has max_lookups_per_row = 3 *)\n lazy (B.( ||| ) (Lazy.force lookups_per_row_4) lookup)\n in\n { lookup_tables = lookups_per_row_3\n ; table_width_at_least_1\n ; table_width_at_least_2\n ; table_width_3\n ; lookups_per_row_3\n ; lookups_per_row_4\n ; lookup_pattern_xor\n ; lookup_pattern_range_check\n ; features\n }\n\nlet lookup_tables_used feature_flags =\n let module Bool = struct\n type t = Plonk_types.Opt.Flag.t\n\n let (true_ : t) = Yes\n\n let (false_ : t) = No\n\n let ( &&& ) (x : t) (y : t) : t =\n match (x, y) with\n | Yes, Yes ->\n Yes\n | Maybe, _ | _, Maybe ->\n Maybe\n | No, _ | _, No ->\n No\n\n let ( ||| ) (x : t) (y : t) : t =\n match (x, y) with\n | Yes, _ | _, Yes ->\n Yes\n | Maybe, _ | _, Maybe ->\n Maybe\n | No, No ->\n No\n\n let any = List.fold_left ~f:( ||| ) ~init:false_\n end in\n let all_feature_flags = expand_feature_flags (module Bool) feature_flags in\n Lazy.force all_feature_flags.lookup_tables\n\nlet get_feature_flag (feature_flags : _ all_feature_flags)\n (feature : Kimchi_types.feature_flag) =\n match feature with\n | RangeCheck0 ->\n Some feature_flags.features.range_check0\n | RangeCheck1 ->\n Some feature_flags.features.range_check1\n | ForeignFieldAdd ->\n Some feature_flags.features.foreign_field_add\n | ForeignFieldMul ->\n Some feature_flags.features.foreign_field_mul\n | Xor ->\n Some feature_flags.features.xor\n | Rot ->\n Some feature_flags.features.rot\n | LookupTables ->\n Some (Lazy.force feature_flags.lookup_tables)\n | RuntimeLookupTables ->\n Some feature_flags.features.runtime_tables\n | TableWidth 3 ->\n Some (Lazy.force feature_flags.table_width_3)\n | TableWidth 2 ->\n Some (Lazy.force feature_flags.table_width_at_least_2)\n | TableWidth i when i <= 1 ->\n Some (Lazy.force feature_flags.table_width_at_least_1)\n | TableWidth _ ->\n None\n | LookupsPerRow 4 ->\n Some (Lazy.force feature_flags.lookups_per_row_4)\n | LookupsPerRow i when i <= 3 ->\n Some (Lazy.force feature_flags.lookups_per_row_3)\n | LookupsPerRow _ ->\n None\n | LookupPattern Lookup ->\n Some feature_flags.features.lookup\n | LookupPattern Xor ->\n Some (Lazy.force feature_flags.lookup_pattern_xor)\n | LookupPattern RangeCheck ->\n Some (Lazy.force feature_flags.lookup_pattern_range_check)\n | LookupPattern ForeignFieldMul ->\n Some feature_flags.features.foreign_field_mul\n\nlet scalars_env (type boolean t) (module B : Bool_intf with type t = boolean)\n (module F : Field_with_if_intf with type t = t and type bool = boolean)\n ~endo ~mds ~field_of_hex ~domain ~srs_length_log2\n ({ alpha; beta; gamma; zeta; joint_combiner; feature_flags } :\n (t, _, boolean) Minimal.t ) (e : (_ * _, _) Plonk_types.Evals.In_circuit.t)\n =\n let feature_flags = expand_feature_flags (module B) feature_flags in\n let witness = Vector.to_array e.w in\n let coefficients = Vector.to_array e.coefficients in\n let var (col, row) =\n let get_eval =\n match (row : Scalars.curr_or_next) with Curr -> fst | Next -> snd\n in\n match[@warning \"-4\"] (col : Scalars.Column.t) with\n | Witness i ->\n get_eval witness.(i)\n | Index Poseidon ->\n get_eval e.poseidon_selector\n | Index Generic ->\n get_eval e.generic_selector\n | Index CompleteAdd ->\n get_eval e.complete_add_selector\n | Index VarBaseMul ->\n get_eval e.mul_selector\n | Index EndoMul ->\n get_eval e.emul_selector\n | Index EndoMulScalar ->\n get_eval e.endomul_scalar_selector\n | Index RangeCheck0 ->\n get_eval (Opt.value_exn e.range_check0_selector)\n | Index RangeCheck1 ->\n get_eval (Opt.value_exn e.range_check1_selector)\n | Index ForeignFieldAdd ->\n get_eval (Opt.value_exn e.foreign_field_add_selector)\n | Index ForeignFieldMul ->\n get_eval (Opt.value_exn e.foreign_field_mul_selector)\n | Index Xor16 ->\n get_eval (Opt.value_exn e.xor_selector)\n | Index Rot64 ->\n get_eval (Opt.value_exn e.rot_selector)\n | Index i ->\n failwithf\n !\"Index %{sexp:Scalars.Gate_type.t}\\n\\\n %! should have been linearized away\"\n i ()\n | Coefficient i ->\n get_eval coefficients.(i)\n | LookupTable ->\n get_eval (Opt.value_exn e.lookup_table)\n | LookupSorted i ->\n get_eval\n (Opt.value_exn (Option.value_exn (Vector.nth e.lookup_sorted i)))\n | LookupAggreg ->\n get_eval (Opt.value_exn e.lookup_aggregation)\n | LookupRuntimeTable ->\n get_eval (Opt.value_exn e.runtime_lookup_table)\n | LookupKindIndex Lookup ->\n get_eval (Opt.value_exn e.lookup_gate_lookup_selector)\n | LookupKindIndex Xor ->\n get_eval (Opt.value_exn e.xor_lookup_selector)\n | LookupKindIndex RangeCheck ->\n get_eval (Opt.value_exn e.range_check_lookup_selector)\n | LookupKindIndex ForeignFieldMul ->\n get_eval (Opt.value_exn e.foreign_field_mul_lookup_selector)\n | LookupRuntimeSelector ->\n get_eval (Opt.value_exn e.runtime_lookup_table_selector)\n in\n let open F in\n let square x = x * x in\n let rec pow x n =\n if n = 0 then one\n else if n = 1 then x\n else\n let y = pow (square x) Int.(n / 2) in\n if n mod 2 = 0 then y else x * y\n in\n let alpha_pows =\n let arr = Array.create ~len:71 one in\n arr.(1) <- alpha ;\n for i = 2 to Int.(Array.length arr - 1) do\n arr.(i) <- alpha * arr.(Int.(i - 1))\n done ;\n arr\n in\n let w4, w3, w2, w1 =\n (* generator^{n - 3} *)\n let gen = domain#generator in\n (* gen_inv = gen^{n - 1} = gen^{-1} *)\n let w1 = one / gen in\n let w2 = square w1 in\n let w3 = w2 * w1 in\n let w4 = lazy (w3 * w1) in\n (w4, w3, w2, w1)\n in\n let zk_polynomial =\n (* Vanishing polynomial of [w1, w2, w3]\n evaluated at x = zeta\n *)\n (zeta - w1) * (zeta - w2) * (zeta - w3)\n in\n let zeta_to_n_minus_1 = lazy (domain#vanishing_polynomial zeta) in\n { Scalars.Env.add = ( + )\n ; sub = ( - )\n ; mul = ( * )\n ; square\n ; alpha_pow = (fun i -> alpha_pows.(i))\n ; var\n ; pow = Tuple2.uncurry pow\n ; field = field_of_hex\n ; cell = Fn.id\n ; double = (fun x -> of_int 2 * x)\n ; zk_polynomial\n ; omega_to_minus_3 = w3\n ; zeta_to_n_minus_1 = domain#vanishing_polynomial zeta\n ; endo_coefficient = endo\n ; mds = (fun (row, col) -> mds.(row).(col))\n ; srs_length_log2\n ; vanishes_on_last_4_rows =\n ( match joint_combiner with\n | None ->\n (* No need to compute anything when not using lookups *)\n F.one\n | Some _ ->\n zk_polynomial * (zeta - Lazy.force w4) )\n ; joint_combiner = Option.value joint_combiner ~default:F.one\n ; beta\n ; gamma\n ; unnormalized_lagrange_basis =\n (fun i ->\n let w_to_i =\n match i with\n | 0 ->\n one\n | 1 ->\n domain#generator\n | -1 ->\n w1\n | -2 ->\n w2\n | -3 ->\n w3\n | -4 ->\n Lazy.force w4\n | _ ->\n failwith \"TODO\"\n in\n Lazy.force zeta_to_n_minus_1 / (zeta - w_to_i) )\n ; if_feature =\n (fun (feature, e1, e2) ->\n let if_ b ~then_ ~else_ =\n match b with None -> e2 () | Some b -> F.if_ b ~then_ ~else_\n in\n let b = get_feature_flag feature_flags feature in\n if_ b ~then_:e1 ~else_:e2 )\n }\n\n(* TODO: not true anymore if lookup is used *)\n\n(** The offset of the powers of alpha for the permutation.\n(see https://github.com/o1-labs/proof-systems/blob/516b16fc9b0fdcab5c608cd1aea07c0c66b6675d/kimchi/src/index.rs#L190) *)\nlet perm_alpha0 : int = 21\n\nmodule Make (Shifted_value : Shifted_value.S) (Sc : Scalars.S) = struct\n (** Computes the ft evaluation at zeta.\n (see https://o1-labs.github.io/mina-book/crypto/plonk/maller_15.html#the-evaluation-of-l)\n *)\n let ft_eval0 (type t) (module F : Field_intf with type t = t) ~domain\n ~(env : t Scalars.Env.t)\n ({ alpha = _; beta; gamma; zeta; joint_combiner = _; feature_flags = _ } :\n _ Minimal.t ) (e : (_ * _, _) Plonk_types.Evals.In_circuit.t) p_eval0 =\n let open Plonk_types.Evals.In_circuit in\n let e0 field = fst (field e) in\n let e1 field = snd (field e) in\n let e0_s = Vector.map e.s ~f:fst in\n let zkp = env.zk_polynomial in\n let alpha_pow = env.alpha_pow in\n let zeta1m1 = env.zeta_to_n_minus_1 in\n let open F in\n let w0 = Vector.to_array e.w |> Array.map ~f:fst in\n let ft_eval0 =\n let a0 = alpha_pow perm_alpha0 in\n let w_n = w0.(Nat.to_int Plonk_types.Permuts_minus_1.n) in\n let init = (w_n + gamma) * e1 z * a0 * zkp in\n (* TODO: This shares some computation with the permutation scalar in\n derive_plonk. Could share between them. *)\n Vector.foldi e0_s ~init ~f:(fun i acc s ->\n ((beta * s) + w0.(i) + gamma) * acc )\n in\n let shifts = domain#shifts in\n let ft_eval0 = ft_eval0 - p_eval0 in\n let ft_eval0 =\n ft_eval0\n - Array.foldi shifts\n ~init:(alpha_pow perm_alpha0 * zkp * e0 z)\n ~f:(fun i acc s -> acc * (gamma + (beta * zeta * s) + w0.(i)))\n in\n let nominator =\n ( zeta1m1\n * alpha_pow Int.(perm_alpha0 + 1)\n * (zeta - env.omega_to_minus_3)\n + (zeta1m1 * alpha_pow Int.(perm_alpha0 + 2) * (zeta - one)) )\n * (one - e0 z)\n in\n let denominator = (zeta - env.omega_to_minus_3) * (zeta - one) in\n let ft_eval0 = ft_eval0 + (nominator / denominator) in\n let constant_term = Sc.constant_term env in\n ft_eval0 - constant_term\n\n (** Computes the list of scalars used in the linearization. *)\n let derive_plonk (type t) ?(with_label = fun _ (f : unit -> t) -> f ())\n (module F : Field_intf with type t = t) ~(env : t Scalars.Env.t) ~shift =\n let _ = with_label in\n let open F in\n fun ({ alpha\n ; beta\n ; gamma\n ; zeta\n ; joint_combiner\n ; feature_flags = actual_feature_flags\n } :\n _ Minimal.t )\n (e : (_ * _, _) Plonk_types.Evals.In_circuit.t)\n (*((e0, e1) : _ Plonk_types.Evals.In_circuit.t Double.t) *) ->\n let open Plonk_types.Evals.In_circuit in\n let e1 field = snd (field e) in\n let zkp = env.zk_polynomial in\n let alpha_pow = env.alpha_pow in\n let w0 = Vector.map e.w ~f:fst in\n let perm =\n let w0 = Vector.to_array w0 in\n with_label __LOC__ (fun () ->\n Vector.foldi e.s\n ~init:(e1 z * beta * alpha_pow perm_alpha0 * zkp)\n ~f:(fun i acc (s, _) -> acc * (gamma + (beta * s) + w0.(i)))\n |> negate )\n in\n In_circuit.map_fields\n ~f:(Shifted_value.of_field (module F) ~shift)\n { alpha\n ; beta\n ; gamma\n ; zeta\n ; zeta_to_domain_size = env.zeta_to_n_minus_1 + F.one\n ; zeta_to_srs_length = pow2pow (module F) zeta env.srs_length_log2\n ; perm\n ; lookup =\n ( match joint_combiner with\n | None ->\n Plonk_types.Opt.None\n | Some joint_combiner ->\n Some { joint_combiner } )\n ; feature_flags = actual_feature_flags\n }\n\n (** Check that computed proof scalars match the expected ones,\n using the native field.\n Note that the expected scalars are used to check\n the linearization in a proof over the other field\n (where those checks are more efficient),\n but we deferred the arithmetic checks until here\n so that we have the efficiency of the native field.\n *)\n let checked (type t)\n (module Impl : Snarky_backendless.Snark_intf.Run with type field = t)\n ~shift ~env (plonk : (_, _, _, _ Opt.t, _ Opt.t, _) In_circuit.t) evals =\n let actual =\n derive_plonk ~with_label:Impl.with_label\n (module Impl.Field)\n ~shift ~env\n { alpha = plonk.alpha\n ; beta = plonk.beta\n ; gamma = plonk.gamma\n ; zeta = plonk.zeta\n ; joint_combiner =\n ( match plonk.lookup with\n | Plonk_types.Opt.None ->\n None\n | Some l | Maybe (_, l) ->\n Some l.In_circuit.Lookup.joint_combiner )\n ; feature_flags = plonk.feature_flags\n }\n evals\n in\n let open Impl in\n let open In_circuit in\n with_label __LOC__ (fun () ->\n with_label __LOC__ (fun () ->\n List.map\n ~f:(fun f -> Shifted_value.equal Field.equal (f plonk) (f actual))\n [ perm ] )\n |> Boolean.all )\nend\n","type ('a, _) t =\n | [] : ('a, 'n) t\n | ( :: ) : 'a * ('a, 'n) t -> ('a, 'n Nat.s) t\n\nlet rec to_list : type a n. (a, n) t -> a list = function\n | [] ->\n []\n | x :: xs ->\n x :: to_list xs\n\nlet rec _length : type a n. (a, n) t -> int = function\n | [] ->\n 0\n | _ :: xs ->\n 1 + _length xs\n\nlet rec to_vector : type a n. (a, n) t -> a Vector.e = function\n | [] ->\n T []\n | x :: xs ->\n let (T xs) = to_vector xs in\n T (x :: xs)\n\nlet rec of_vector : type a n m. (a, n) Vector.t -> (n, m) Nat.Lte.t -> (a, m) t\n =\n fun v p ->\n match (v, p) with [], _ -> [] | x :: xs, S p -> x :: of_vector xs p\n\nlet rec of_list_and_length_exn : type a n. a list -> n Nat.t -> (a, n) t =\n fun xs n ->\n match (xs, n) with\n | [], _ ->\n []\n | x :: xs, S n ->\n x :: of_list_and_length_exn xs n\n | _ :: _, Z ->\n failwith \"At_most: Length mismatch\"\n\nmodule type S = sig\n type 'a t\n\n include Sigs.Hash_foldable.S1 with type 'a t := 'a t\n\n include Sigs.Comparable.S1 with type 'a t := 'a t\n\n include Sigs.Jsonable.S1 with type 'a t := 'a t\n\n include Sigs.Sexpable.S1 with type 'a t := 'a t\nend\n\nmodule type VERSIONED = sig\n type 'a ty\n\n module Stable : sig\n module V1 : sig\n type 'a t = 'a ty\n\n include Sigs.VERSIONED\n\n include Sigs.Binable.S1 with type 'a t := 'a t\n\n include S with type 'a t := 'a t\n end\n end\n\n type 'a t = 'a Stable.V1.t\n\n include S with type 'a t := 'a t\nend\n\nmodule Make = struct\n module Yojson (N : Nat.Intf) :\n Sigs.Jsonable.S1 with type 'a t := ('a, N.n) t = struct\n let to_yojson f t = Vector.L.to_yojson f (to_list t)\n\n let of_yojson f s =\n Core_kernel.Result.map (Vector.L.of_yojson f s)\n ~f:(Base.Fn.flip of_list_and_length_exn N.n)\n end\n\n module Sexpable (N : Nat.Intf) :\n Core_kernel.Sexpable.S1 with type 'a t := ('a, N.n) t =\n Core_kernel.Sexpable.Of_sexpable1\n (Base.List)\n (struct\n type nonrec 'a t = ('a, N.n) t\n\n let to_sexpable = to_list\n\n let of_sexpable xs = of_list_and_length_exn xs N.n\n end)\nend\n\ntype ('a, 'n) at_most = ('a, 'n) t\n\nmodule With_length (N : Nat.Intf) : S with type 'a t = ('a, N.n) at_most =\nstruct\n type 'a t = ('a, N.n) at_most\n\n let compare c t1 t2 = Base.List.compare c (to_list t1) (to_list t2)\n\n let hash_fold_t f s v = Base.List.hash_fold_t f s (to_list v)\n\n let equal f t1 t2 = List.equal f (to_list t1) (to_list t2)\n\n include Make.Sexpable (N)\n include Make.Yojson (N)\nend\n\nmodule At_most_2 = struct\n [%%versioned_binable\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n type 'a t = ('a, Nat.N2.n) at_most\n\n include\n Core_kernel.Binable.Of_binable1_without_uuid\n (Core_kernel.List.Stable.V1)\n (struct\n type nonrec 'a t = 'a t\n\n let to_binable = to_list\n\n let of_binable xs = of_list_and_length_exn xs Nat.N2.n\n end)\n\n include (\n With_length\n (Nat.N2) :\n module type of With_length (Nat.N2) with type 'a t := 'a t )\n end\n end]\n\n type 'a t = 'a Stable.Latest.t [@@deriving sexp, equal, compare, hash, yojson]\n\n type 'a ty = 'a t\n end\n\nmodule At_most_8 = struct\n [%%versioned_binable\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n type 'a t = ('a, Nat.N8.n) at_most\n\n include\n Core_kernel.Binable.Of_binable1_without_uuid\n (Core_kernel.List.Stable.V1)\n (struct\n type nonrec 'a t = 'a t\n\n let to_binable = to_list\n\n let of_binable xs = of_list_and_length_exn xs Nat.N8.n\n end)\n\n include (\n With_length\n (Nat.N8) :\n module type of With_length (Nat.N8) with type 'a t := 'a t )\n end\n end]\n\n type 'a t = 'a Stable.Latest.t [@@deriving sexp, equal, compare, hash, yojson]\n\n type 'a ty = 'a t\n end\n","(* This file is generated automatically with ocaml_gen. *)\n\nmodule FieldVectors = struct\n module Fp = struct\n type nonrec t\n\n type nonrec elt = Pasta_bindings.Fp.t\n\n external create : unit -> t = \"caml_fp_vector_create\"\n\n external length : t -> int = \"caml_fp_vector_length\"\n\n external emplace_back : t -> elt -> unit = \"caml_fp_vector_emplace_back\"\n\n external get : t -> int -> elt = \"caml_fp_vector_get\"\n\n external set : t -> int -> elt -> unit = \"caml_fp_vector_set\"\n end\n\n module Fq = struct\n type nonrec t\n\n type nonrec elt = Pasta_bindings.Fq.t\n\n external create : unit -> t = \"caml_fq_vector_create\"\n\n external length : t -> int = \"caml_fq_vector_length\"\n\n external emplace_back : t -> elt -> unit = \"caml_fq_vector_emplace_back\"\n\n external get : t -> int -> elt = \"caml_fq_vector_get\"\n\n external set : t -> int -> elt -> unit = \"caml_fq_vector_set\"\n end\nend\n\nmodule Protocol = struct\n module Gates = struct\n module Vector = struct\n module Fp = struct\n type nonrec t\n\n type nonrec elt = Pasta_bindings.Fp.t Kimchi_types.circuit_gate\n\n external create : unit -> t = \"caml_pasta_fp_plonk_gate_vector_create\"\n\n external add : t -> elt -> unit = \"caml_pasta_fp_plonk_gate_vector_add\"\n\n external get : t -> int -> elt = \"caml_pasta_fp_plonk_gate_vector_get\"\n\n external len : t -> int = \"caml_pasta_fp_plonk_gate_vector_len\"\n\n external wrap : t -> Kimchi_types.wire -> Kimchi_types.wire -> unit\n = \"caml_pasta_fp_plonk_gate_vector_wrap\"\n\n external digest : int -> t -> bytes\n = \"caml_pasta_fp_plonk_gate_vector_digest\"\n\n external to_json : int -> t -> string\n = \"caml_pasta_fp_plonk_circuit_serialize\"\n end\n\n module Fq = struct\n type nonrec t\n\n type nonrec elt = Pasta_bindings.Fq.t Kimchi_types.circuit_gate\n\n external create : unit -> t = \"caml_pasta_fq_plonk_gate_vector_create\"\n\n external add : t -> elt -> unit = \"caml_pasta_fq_plonk_gate_vector_add\"\n\n external get : t -> int -> elt = \"caml_pasta_fq_plonk_gate_vector_get\"\n\n external len : t -> int = \"caml_pasta_fq_plonk_gate_vector_len\"\n\n external wrap : t -> Kimchi_types.wire -> Kimchi_types.wire -> unit\n = \"caml_pasta_fq_plonk_gate_vector_wrap\"\n\n external digest : int -> t -> bytes\n = \"caml_pasta_fq_plonk_gate_vector_digest\"\n\n external to_json : int -> t -> string\n = \"caml_pasta_fq_plonk_circuit_serialize\"\n end\n end\n end\n\n module SRS = struct\n module Fp = struct\n type nonrec t\n\n module Poly_comm = struct\n type nonrec t =\n Pasta_bindings.Fp.t Kimchi_types.or_infinity Kimchi_types.poly_comm\n end\n\n external create : int -> t = \"caml_fp_srs_create\"\n\n external write : bool option -> t -> string -> unit = \"caml_fp_srs_write\"\n\n external read : int option -> string -> t option = \"caml_fp_srs_read\"\n\n external lagrange_commitment :\n t\n -> int\n -> int\n -> Pasta_bindings.Fq.t Kimchi_types.or_infinity Kimchi_types.poly_comm\n = \"caml_fp_srs_lagrange_commitment\"\n\n external add_lagrange_basis : t -> int -> unit\n = \"caml_fp_srs_add_lagrange_basis\"\n\n external commit_evaluations :\n t\n -> int\n -> Pasta_bindings.Fp.t array\n -> Pasta_bindings.Fq.t Kimchi_types.or_infinity Kimchi_types.poly_comm\n = \"caml_fp_srs_commit_evaluations\"\n\n external b_poly_commitment :\n t\n -> Pasta_bindings.Fp.t array\n -> Pasta_bindings.Fq.t Kimchi_types.or_infinity Kimchi_types.poly_comm\n = \"caml_fp_srs_b_poly_commitment\"\n\n external batch_accumulator_check :\n t\n -> Pasta_bindings.Fq.t Kimchi_types.or_infinity array\n -> Pasta_bindings.Fp.t array\n -> bool = \"caml_fp_srs_batch_accumulator_check\"\n\n external batch_accumulator_generate :\n t\n -> int\n -> Pasta_bindings.Fp.t array\n -> Pasta_bindings.Fq.t Kimchi_types.or_infinity array\n = \"caml_fp_srs_batch_accumulator_generate\"\n\n external urs_h : t -> Pasta_bindings.Fq.t Kimchi_types.or_infinity\n = \"caml_fp_srs_h\"\n end\n\n module Fq = struct\n type nonrec t\n\n external create : int -> t = \"caml_fq_srs_create\"\n\n external write : bool option -> t -> string -> unit = \"caml_fq_srs_write\"\n\n external read : int option -> string -> t option = \"caml_fq_srs_read\"\n\n external lagrange_commitment :\n t\n -> int\n -> int\n -> Pasta_bindings.Fp.t Kimchi_types.or_infinity Kimchi_types.poly_comm\n = \"caml_fq_srs_lagrange_commitment\"\n\n external add_lagrange_basis : t -> int -> unit\n = \"caml_fq_srs_add_lagrange_basis\"\n\n external commit_evaluations :\n t\n -> int\n -> Pasta_bindings.Fq.t array\n -> Pasta_bindings.Fp.t Kimchi_types.or_infinity Kimchi_types.poly_comm\n = \"caml_fq_srs_commit_evaluations\"\n\n external b_poly_commitment :\n t\n -> Pasta_bindings.Fq.t array\n -> Pasta_bindings.Fp.t Kimchi_types.or_infinity Kimchi_types.poly_comm\n = \"caml_fq_srs_b_poly_commitment\"\n\n external batch_accumulator_check :\n t\n -> Pasta_bindings.Fp.t Kimchi_types.or_infinity array\n -> Pasta_bindings.Fq.t array\n -> bool = \"caml_fq_srs_batch_accumulator_check\"\n\n external batch_accumulator_generate :\n t\n -> int\n -> Pasta_bindings.Fq.t array\n -> Pasta_bindings.Fp.t Kimchi_types.or_infinity array\n = \"caml_fq_srs_batch_accumulator_generate\"\n\n external urs_h : t -> Pasta_bindings.Fp.t Kimchi_types.or_infinity\n = \"caml_fq_srs_h\"\n end\n end\n\n module Index = struct\n module Fp = struct\n type nonrec t\n\n external create :\n Gates.Vector.Fp.t\n -> int\n -> Pasta_bindings.Fp.t Kimchi_types.runtime_table_cfg array\n -> int\n -> SRS.Fp.t\n -> t = \"caml_pasta_fp_plonk_index_create\"\n\n external max_degree : t -> int = \"caml_pasta_fp_plonk_index_max_degree\"\n\n external public_inputs : t -> int\n = \"caml_pasta_fp_plonk_index_public_inputs\"\n\n external domain_d1_size : t -> int\n = \"caml_pasta_fp_plonk_index_domain_d1_size\"\n\n external domain_d4_size : t -> int\n = \"caml_pasta_fp_plonk_index_domain_d4_size\"\n\n external domain_d8_size : t -> int\n = \"caml_pasta_fp_plonk_index_domain_d8_size\"\n\n external read : int option -> SRS.Fp.t -> string -> t\n = \"caml_pasta_fp_plonk_index_read\"\n\n external write : bool option -> t -> string -> unit\n = \"caml_pasta_fp_plonk_index_write\"\n end\n\n module Fq = struct\n type nonrec t\n\n external create :\n Gates.Vector.Fq.t\n -> int\n -> Pasta_bindings.Fq.t Kimchi_types.runtime_table_cfg array\n -> int\n -> SRS.Fq.t\n -> t = \"caml_pasta_fq_plonk_index_create\"\n\n external max_degree : t -> int = \"caml_pasta_fq_plonk_index_max_degree\"\n\n external public_inputs : t -> int\n = \"caml_pasta_fq_plonk_index_public_inputs\"\n\n external domain_d1_size : t -> int\n = \"caml_pasta_fq_plonk_index_domain_d1_size\"\n\n external domain_d4_size : t -> int\n = \"caml_pasta_fq_plonk_index_domain_d4_size\"\n\n external domain_d8_size : t -> int\n = \"caml_pasta_fq_plonk_index_domain_d8_size\"\n\n external read : int option -> SRS.Fq.t -> string -> t\n = \"caml_pasta_fq_plonk_index_read\"\n\n external write : bool option -> t -> string -> unit\n = \"caml_pasta_fq_plonk_index_write\"\n end\n end\n\n module VerifierIndex = struct\n module Fp = struct\n type nonrec t =\n ( Pasta_bindings.Fp.t\n , SRS.Fp.t\n , Pasta_bindings.Fq.t Kimchi_types.or_infinity Kimchi_types.poly_comm\n )\n Kimchi_types.VerifierIndex.verifier_index\n\n external create : Index.Fp.t -> t\n = \"caml_pasta_fp_plonk_verifier_index_create\"\n\n external read : int option -> SRS.Fp.t -> string -> t\n = \"caml_pasta_fp_plonk_verifier_index_read\"\n\n external write : bool option -> t -> string -> unit\n = \"caml_pasta_fp_plonk_verifier_index_write\"\n\n external shifts : int -> Pasta_bindings.Fp.t array\n = \"caml_pasta_fp_plonk_verifier_index_shifts\"\n\n external dummy : unit -> t = \"caml_pasta_fp_plonk_verifier_index_dummy\"\n\n external deep_copy : t -> t\n = \"caml_pasta_fp_plonk_verifier_index_deep_copy\"\n end\n\n module Fq = struct\n type nonrec t =\n ( Pasta_bindings.Fq.t\n , SRS.Fq.t\n , Pasta_bindings.Fp.t Kimchi_types.or_infinity Kimchi_types.poly_comm\n )\n Kimchi_types.VerifierIndex.verifier_index\n\n external create : Index.Fq.t -> t\n = \"caml_pasta_fq_plonk_verifier_index_create\"\n\n external read : int option -> SRS.Fq.t -> string -> t\n = \"caml_pasta_fq_plonk_verifier_index_read\"\n\n external write : bool option -> t -> string -> unit\n = \"caml_pasta_fq_plonk_verifier_index_write\"\n\n external shifts : int -> Pasta_bindings.Fq.t array\n = \"caml_pasta_fq_plonk_verifier_index_shifts\"\n\n external dummy : unit -> t = \"caml_pasta_fq_plonk_verifier_index_dummy\"\n\n external deep_copy : t -> t\n = \"caml_pasta_fq_plonk_verifier_index_deep_copy\"\n end\n end\n\n module Oracles = struct\n module Fp = struct\n type nonrec t = Pasta_bindings.Fp.t Kimchi_types.oracles\n\n external create :\n Pasta_bindings.Fq.t Kimchi_types.or_infinity Kimchi_types.poly_comm\n array\n -> ( Pasta_bindings.Fp.t\n , SRS.Fp.t\n , Pasta_bindings.Fq.t Kimchi_types.or_infinity Kimchi_types.poly_comm\n )\n Kimchi_types.VerifierIndex.verifier_index\n -> ( Pasta_bindings.Fq.t Kimchi_types.or_infinity\n , Pasta_bindings.Fp.t )\n Kimchi_types.prover_proof\n -> t = \"fp_oracles_create\"\n\n external dummy : unit -> Pasta_bindings.Fp.t Kimchi_types.random_oracles\n = \"fp_oracles_dummy\"\n\n external deep_copy :\n Pasta_bindings.Fp.t Kimchi_types.random_oracles\n -> Pasta_bindings.Fp.t Kimchi_types.random_oracles\n = \"fp_oracles_deep_copy\"\n end\n\n module Fq = struct\n type nonrec t = Pasta_bindings.Fq.t Kimchi_types.oracles\n\n external create :\n Pasta_bindings.Fp.t Kimchi_types.or_infinity Kimchi_types.poly_comm\n array\n -> ( Pasta_bindings.Fq.t\n , SRS.Fq.t\n , Pasta_bindings.Fp.t Kimchi_types.or_infinity Kimchi_types.poly_comm\n )\n Kimchi_types.VerifierIndex.verifier_index\n -> ( Pasta_bindings.Fp.t Kimchi_types.or_infinity\n , Pasta_bindings.Fq.t )\n Kimchi_types.prover_proof\n -> t = \"fq_oracles_create\"\n\n external dummy : unit -> Pasta_bindings.Fq.t Kimchi_types.random_oracles\n = \"fq_oracles_dummy\"\n\n external deep_copy :\n Pasta_bindings.Fq.t Kimchi_types.random_oracles\n -> Pasta_bindings.Fq.t Kimchi_types.random_oracles\n = \"fq_oracles_deep_copy\"\n end\n end\n\n module Proof = struct\n module Fp = struct\n external create :\n Index.Fp.t\n -> FieldVectors.Fp.t array\n -> Pasta_bindings.Fp.t array\n -> Pasta_bindings.Fq.t Kimchi_types.or_infinity array\n -> ( Pasta_bindings.Fq.t Kimchi_types.or_infinity\n , Pasta_bindings.Fp.t )\n Kimchi_types.prover_proof = \"caml_pasta_fp_plonk_proof_create\"\n\n external create_and_verify :\n Index.Fp.t\n -> FieldVectors.Fp.t array\n -> Pasta_bindings.Fp.t array\n -> Pasta_bindings.Fq.t Kimchi_types.or_infinity array\n -> ( Pasta_bindings.Fq.t Kimchi_types.or_infinity\n , Pasta_bindings.Fp.t )\n Kimchi_types.prover_proof\n = \"caml_pasta_fp_plonk_proof_create_and_verify\"\n\n external example_with_lookup :\n SRS.Fp.t\n -> Index.Fp.t\n * Pasta_bindings.Fp.t\n * ( Pasta_bindings.Fq.t Kimchi_types.or_infinity\n , Pasta_bindings.Fp.t )\n Kimchi_types.prover_proof\n = \"caml_pasta_fp_plonk_proof_example_with_lookup\"\n\n external example_with_ffadd :\n SRS.Fp.t\n -> Index.Fp.t\n * Pasta_bindings.Fp.t\n * ( Pasta_bindings.Fq.t Kimchi_types.or_infinity\n , Pasta_bindings.Fp.t )\n Kimchi_types.prover_proof\n = \"caml_pasta_fp_plonk_proof_example_with_ffadd\"\n\n external example_with_xor :\n SRS.Fp.t\n -> Index.Fp.t\n * (Pasta_bindings.Fp.t * Pasta_bindings.Fp.t)\n * ( Pasta_bindings.Fq.t Kimchi_types.or_infinity\n , Pasta_bindings.Fp.t )\n Kimchi_types.prover_proof\n = \"caml_pasta_fp_plonk_proof_example_with_xor\"\n\n external example_with_rot :\n SRS.Fp.t\n -> Index.Fp.t\n * (Pasta_bindings.Fp.t * Pasta_bindings.Fp.t)\n * ( Pasta_bindings.Fq.t Kimchi_types.or_infinity\n , Pasta_bindings.Fp.t )\n Kimchi_types.prover_proof\n = \"caml_pasta_fp_plonk_proof_example_with_rot\"\n\n external example_with_foreign_field_mul :\n SRS.Fp.t\n -> Index.Fp.t\n * ( Pasta_bindings.Fq.t Kimchi_types.or_infinity\n , Pasta_bindings.Fp.t )\n Kimchi_types.prover_proof\n = \"caml_pasta_fp_plonk_proof_example_with_foreign_field_mul\"\n\n external example_with_range_check :\n SRS.Fp.t\n -> Index.Fp.t\n * ( Pasta_bindings.Fq.t Kimchi_types.or_infinity\n , Pasta_bindings.Fp.t )\n Kimchi_types.prover_proof\n = \"caml_pasta_fp_plonk_proof_example_with_range_check\"\n\n external example_with_range_check0 :\n SRS.Fp.t\n -> Index.Fp.t\n * ( Pasta_bindings.Fq.t Kimchi_types.or_infinity\n , Pasta_bindings.Fp.t )\n Kimchi_types.prover_proof\n = \"caml_pasta_fp_plonk_proof_example_with_range_check0\"\n\n external verify :\n ( Pasta_bindings.Fp.t\n , SRS.Fp.t\n , Pasta_bindings.Fq.t Kimchi_types.or_infinity Kimchi_types.poly_comm\n )\n Kimchi_types.VerifierIndex.verifier_index\n -> ( Pasta_bindings.Fq.t Kimchi_types.or_infinity\n , Pasta_bindings.Fp.t )\n Kimchi_types.prover_proof\n -> bool = \"caml_pasta_fp_plonk_proof_verify\"\n\n external batch_verify :\n ( Pasta_bindings.Fp.t\n , SRS.Fp.t\n , Pasta_bindings.Fq.t Kimchi_types.or_infinity Kimchi_types.poly_comm\n )\n Kimchi_types.VerifierIndex.verifier_index\n array\n -> ( Pasta_bindings.Fq.t Kimchi_types.or_infinity\n , Pasta_bindings.Fp.t )\n Kimchi_types.prover_proof\n array\n -> bool = \"caml_pasta_fp_plonk_proof_batch_verify\"\n\n external dummy :\n unit\n -> ( Pasta_bindings.Fq.t Kimchi_types.or_infinity\n , Pasta_bindings.Fp.t )\n Kimchi_types.prover_proof = \"caml_pasta_fp_plonk_proof_dummy\"\n\n external deep_copy :\n ( Pasta_bindings.Fq.t Kimchi_types.or_infinity\n , Pasta_bindings.Fp.t )\n Kimchi_types.prover_proof\n -> ( Pasta_bindings.Fq.t Kimchi_types.or_infinity\n , Pasta_bindings.Fp.t )\n Kimchi_types.prover_proof = \"caml_pasta_fp_plonk_proof_deep_copy\"\n end\n\n module Fq = struct\n external create :\n Index.Fq.t\n -> FieldVectors.Fq.t array\n -> Pasta_bindings.Fq.t array\n -> Pasta_bindings.Fp.t Kimchi_types.or_infinity array\n -> ( Pasta_bindings.Fp.t Kimchi_types.or_infinity\n , Pasta_bindings.Fq.t )\n Kimchi_types.prover_proof = \"caml_pasta_fq_plonk_proof_create\"\n\n external verify :\n ( Pasta_bindings.Fq.t\n , SRS.Fq.t\n , Pasta_bindings.Fp.t Kimchi_types.or_infinity Kimchi_types.poly_comm\n )\n Kimchi_types.VerifierIndex.verifier_index\n -> ( Pasta_bindings.Fp.t Kimchi_types.or_infinity\n , Pasta_bindings.Fq.t )\n Kimchi_types.prover_proof\n -> bool = \"caml_pasta_fq_plonk_proof_verify\"\n\n external batch_verify :\n ( Pasta_bindings.Fq.t\n , SRS.Fq.t\n , Pasta_bindings.Fp.t Kimchi_types.or_infinity Kimchi_types.poly_comm\n )\n Kimchi_types.VerifierIndex.verifier_index\n array\n -> ( Pasta_bindings.Fp.t Kimchi_types.or_infinity\n , Pasta_bindings.Fq.t )\n Kimchi_types.prover_proof\n array\n -> bool = \"caml_pasta_fq_plonk_proof_batch_verify\"\n\n external dummy :\n unit\n -> ( Pasta_bindings.Fp.t Kimchi_types.or_infinity\n , Pasta_bindings.Fq.t )\n Kimchi_types.prover_proof = \"caml_pasta_fq_plonk_proof_dummy\"\n\n external deep_copy :\n ( Pasta_bindings.Fp.t Kimchi_types.or_infinity\n , Pasta_bindings.Fq.t )\n Kimchi_types.prover_proof\n -> ( Pasta_bindings.Fp.t Kimchi_types.or_infinity\n , Pasta_bindings.Fq.t )\n Kimchi_types.prover_proof = \"caml_pasta_fq_plonk_proof_deep_copy\"\n end\n end\nend\n","open Core_kernel\n\ntype 'a t = { mds : 'a array array; round_constants : 'a array array }\n[@@deriving bin_io]\n\nlet map { mds; round_constants } ~f =\n let f = Array.map ~f:(Array.map ~f) in\n { mds = f mds; round_constants = f round_constants }\n","let params_Bn128 =\n { Params.mds =\n [| [| \"15913613074278028058360498857043999222867772811338037425231170199156889337604\"\n ; \"65180538277771794992983614695816638391617290189527384182155063505825555179\"\n ; \"5394145287608961087977235806233358974273334844303649346024304966582176196487\"\n |]\n ; [| \"15414815283538893716009156559702084916211023875136356807248219032453798152465\"\n ; \"3463018243616155786290732419705147785020336294529003837260493734746385539469\"\n ; \"12716468877825667500219920861172138145894921271005565146996037137547785771411\"\n |]\n ; [| \"1792045203208933407244693490495238027092197802128268175009298962707699842710\"\n ; \"76356542649790718492035692281837451271781062546545119705441901238018861818\"\n ; \"9520069514281255561624128661339565451189764370791651000392579220353790670830\"\n |]\n |]\n ; round_constants =\n [| [| \"12455131979215983316735047846658291859029812584241282581257197013302738138666\"\n ; \"20029656970890966196099810168066995443524989185718089119520857141365451679654\"\n ; \"8929913078653797661905726823410775654210481762974885244818731639242977419622\"\n |]\n ; [| \"8662787891019924101534530927954444401015394189462080864609938870691307539536\"\n ; \"20294115837600366998212029140165760858924828875933683067126492672917588261877\"\n ; \"2682014173266320611146882768057075830238591616831154961603507352639750394592\"\n |]\n ; [| \"18907515456503482670621260399010811269866082079896285203284611749350771281411\"\n ; \"1424609887444859910324043210736091906100438801135358613993092433663809225411\"\n ; \"1531059541788158835714117823424146308635531997487162670061618032695665453831\"\n |]\n ; [| \"19444238474448321066398700689084787616548516614414549514749853660756611792379\"\n ; \"2236237945310446639621733106225706828551103453944652411264620402517164583264\"\n ; \"12605646628049520919535266096828454658561884709869426105979276828733666269521\"\n |]\n ; [| \"14653124040822125428573681427514890989900893513402451718822527259901516216058\"\n ; \"1535968898232047429062068090527484451997796559364245278047376516596586180554\"\n ; \"3307538294663905716144414865227035949873283327379581103741297483063276195183\"\n |]\n ; [| \"21111467054595055527346262240389751012262991994706430976179289552457483727796\"\n ; \"17649294376560630922417546944777537620537408190408066211453084495108565929366\"\n ; \"7683463515567855955851784553909126014159314191075450219244796328948411069744\"\n |]\n ; [| \"21262229851583325466767017312569047417622760705999088078958228786464449033067\"\n ; \"11691182518884460508022694337582074624192039580202157360389815110719437213363\"\n ; \"8690728446593494554377477996892461126663797704587025899930929227865493269824\"\n |]\n ; [| \"21622260498668079571860417097494779160364898191075577203239012897437375456411\"\n ; \"21067767847052854366896470071519184914663018103241392453030719014890445499665\"\n ; \"21348828409856354758094844442899573788047317201055667836817119877806560465334\"\n |]\n ; [| \"2704440995725305992776846806711930876273040749514871232837487081811513368296\"\n ; \"1142050494870706434296077676238780951797136607536187326800297147932619878418\"\n ; \"3652944740784795248484484454916800802095288396765069024258114251561069674735\"\n |]\n ; [| \"1747641587474624832364464288237802774971629275511085691789065855359044028198\"\n ; \"14935834110027005954806028171080511939971704126366459140378790942754129686907\"\n ; \"3215720726490672077485888789426411334496962379737529853320875594879037332594\"\n |]\n ; [| \"2892159931078719741396670290810431382361178666606213506995456264415113913847\"\n ; \"1938538891009879014088646889644828497511974353410971027478866497380422633484\"\n ; \"13916214761542255527505866254811968868327635410573168146297241319868121689821\"\n |]\n ; [| \"266821775768872344171470219200118028338254464492956024813242747554382748942\"\n ; \"11055386921184594780372263378420826851562920740321950336882051897732501262543\"\n ; \"2504617730099125455929793538006173214604536705392412461363354681040283013164\"\n |]\n ; [| \"8077046888362371937918818344109572894796988781119069525502907016581642522710\"\n ; \"7281012798633884984170366068851653834509460567285503188952416990462599509288\"\n ; \"11914125581503780978633571238267986373793149282818856451291452464271781243920\"\n |]\n ; [| \"5911373857383996424444312456230128887937254975139357544835683280828995545397\"\n ; \"20728259298426389276714612941176977888429183727869747381529137474366072279101\"\n ; \"8331123017723440628782766975941869108307759426898189357261715346312601104654\"\n |]\n ; [| \"19978529403683797449165109778464832800224916941903951374610236813523844409526\"\n ; \"17316158269457914256007584527534747738658973027567786054549020564540952112346\"\n ; \"7848194400773744361171082305364633343688318123652518347170031226439829254882\"\n |]\n ; [| \"17698087730709566968258013675219881840614043344609152682517330801348583470562\"\n ; \"2484533502052370851335172153342694835144795809438965797062785488685902188726\"\n ; \"13372068881052003992228272108672679285817785895634149926809187580418595890381\"\n |]\n ; [| \"4450005426773734601782625050142815413017019480402129494014819930729323864775\"\n ; \"15031465389782276133463098319911853017052619244999605688724393058338301291115\"\n ; \"6028902109643218557806340932181364476799161079643636815411563224652423572198\"\n |]\n ; [| \"2957732585137901025626087202113249345076588554941059487693780861098604986119\"\n ; \"12565476532112137808460978474958060441970941349010371267577877299656634907765\"\n ; \"10508327646678453674728048391759640526197954899878596680197847666563367632543\"\n |]\n ; [| \"4493451765845812430310778141104432201437429164475176054680492630627878568332\"\n ; \"15095408309586969968044201398966210357547906905122453139947200130015688526573\"\n ; \"10819130048432875198797495465270179395954461390529553930221225323229387202234\"\n |]\n ; [| \"15905267794015672354278595057670574122197927816429433548802165993220415414073\"\n ; \"19290205907831398371768999387869637435049824367233327965730120884036212709842\"\n ; \"15451920390057917627290027104082580122165965120355347782937661856388593985245\"\n |]\n ; [| \"6425598873527092853966039409614693840647173123073098849086711894647944582332\"\n ; \"17307716513182567320564075539526480893558355908652993731441220999922946005081\"\n ; \"19372285427179952013203092658533484049593114439149219035606060254764845851391\"\n |]\n ; [| \"14724939606645168531546334343600232253284320276481307778787768813885931648950\"\n ; \"4684996260500305121238590806572541849891754312215139285622888510153705963000\"\n ; \"19906278135333202031075665370853003279083131420237405129919260859757146418025\"\n |]\n ; [| \"3999693912508849442569285360026642503093489903926874133118153062461080435481\"\n ; \"20129375303694053217240183105192753906500831553949001131297105718176015558964\"\n ; \"17281496576809338419011697046933296343189100335422897604615575811331627359485\"\n |]\n ; [| \"15637748291684046440453413703705692658155214802161964102299272768648229342362\"\n ; \"2094444825794502002152585986969571562449905861771519270554787618649438333195\"\n ; \"1152889601932463959824817875107315518104722504910095364729880245759523916044\"\n |]\n ; [| \"12114165850379066500859611262167642397834899331804245444372878412987365128590\"\n ; \"20821227542001445006023346122554483849065713580779858784021328359824080462519\"\n ; \"3440756720132945332811173288138999408441021502908547499697282473681525253805\"\n |]\n ; [| \"20938628428302899368158656913047855118000040623605421135349389583331392728782\"\n ; \"8850081254230234130482383430433176873344633494243110112848647064077741649744\"\n ; \"1819639941546179668398979507053724449231350395599747300736218202072168364980\"\n |]\n ; [| \"21219092773772827667886204262476112905428217689703647484316763603169544906986\"\n ; \"13148487544990345541730567143235754764404038697816450525897467218977412799129\"\n ; \"13598807739063229961519663325640861142062394342851403440808670891533339780790\"\n |]\n ; [| \"18784327298376147342042823437947970462892869194728299228507919810276864843414\"\n ; \"2764493745803317574883853704043825342340808631956690807684613803167040529511\"\n ; \"21531775639025076953020023111055490895978901214310417059307899853240995381819\"\n |]\n ; [| \"19964398501876039777029130298682737202257582985971095863290288610857831427638\"\n ; \"15003442983970848114681480873546789629160262059108570865485071572172687676835\"\n ; \"20614241966717622390914334053622572167995367802051836931454426877074875942253\"\n |]\n ; [| \"19733168743390283576337440585736332292298547880804855952734808967278966077887\"\n ; \"20530621481603446397085836296967350209890164029268319619481535419199429275412\"\n ; \"12361620530467399202722610329149901344545851901477091854159960517963801528971\"\n |]\n ; [| \"9497854724940806346676139162466690071592872530638144182764466319052293463165\"\n ; \"7549205476288061047040852944548942878112823732145584918107208536541712726277\"\n ; \"9010672859023729500640324904403960830965495099902505763591033382017769059028\"\n |]\n ; [| \"809006882768062359480853341102632220777932068978149301935174282279746446958\"\n ; \"7106371976957177712230305966566701811850820970657101896348127436646177656365\"\n ; \"18845123379649840503129460949570724717923057602542920800815047452665097128575\"\n |]\n ; [| \"14712923944932171466124439335703740452883296028663247289510978550197451911919\"\n ; \"19555759172327736128240171000715903945570888389700763573790859521156095228287\"\n ; \"17179695917466049633838471880559548490881310699092342418090873652775810295378\"\n |]\n ; [| \"18944876856792381816055068913314141690530834943354883079085532905267119397008\"\n ; \"3257630700960849517603336097571474897923100547762764495987576852490355943460\"\n ; \"3963500912949736174926372928446487843084987377580944585294277449817215093365\"\n |]\n ; [| \"21304716730402869084944080869903443431235336418077153507261240151959530377653\"\n ; \"18998265936988640248585036755202701418246223100957416731998639191794797638003\"\n ; \"16839625825914009701942141907800050396084195897386326382915730670235616618695\"\n |]\n ; [| \"16907937154215020261110468963982390213438461071031811101554056252102505124726\"\n ; \"1294898660752289889975651445755491766586322714088107994205473403531724749589\"\n ; \"9172546393414544394143001120250095355087186863911844697260687867341704896778\"\n |]\n ; [| \"18891778779724165209072874482651171817270086247356116562427206569585293483055\"\n ; \"13093554332096549605604948416229955030385793767090042194569924056338021838108\"\n ; \"6540069282618873496342140872069384185118574828832026154295825270730722501809\"\n |]\n ; [| \"11698805795265597745890922320669982345748592147825010914959366790903803563027\"\n ; \"11128587690756409041400570351324823090287237584985813997261416805030246953137\"\n ; \"574796972312053991589591668868339165343116554180562026519971681663627339366\"\n |]\n ; [| \"8263653526367544279471418475309371793291954818747935714794248360166503487859\"\n ; \"495546618036723566920914648951352373868059898268055487677897567226892784967\"\n ; \"2528292188392170914010448139211586215817069915670005292953294092269979070980\"\n |]\n ; [| \"14954597262610438728753406794870316034770442280143947719391702684620418262496\"\n ; \"2873290581141877304970576969082349138229332018341156071844198415188999408160\"\n ; \"7877226570858832633875209751493918650976179001613717862579011309181456152753\"\n |]\n ; [| \"5290811263292128650829809831924435265520706616680110737471312421357061576251\"\n ; \"5711353914598993184207904758686192904620948114158132435163135551043392236587\"\n ; \"9671966951859991559346179676315084295317241890404128352532995814366687016784\"\n |]\n ; [| \"20648234869018782942484412385329986060607455807332118750782252709151244400533\"\n ; \"1521221467156754943933671253020851096017281629892920730907443291972734010497\"\n ; \"6375300799036358132607612364454746219201386369274233783761503007631282551380\"\n |]\n ; [| \"18921242117750773300194037006101341214923275379274370683247849512779159129078\"\n ; \"7813033521740037204631731835076108697814182206021466630450781049551634237483\"\n ; \"7795208366125068859216483161820518701837348485078219412133643408967011329822\"\n |]\n ; [| \"21634048616875364065210304993971256601326650069082669576726378272437410251852\"\n ; \"1440291557054822025042926468154900761163167753541613162663250995564641638121\"\n ; \"8030862880899531201072645375229460968330384014296763956553993045932171788794\"\n |]\n ; [| \"18227143364048378671809657511264604955612895339528675264153781365139338073044\"\n ; \"21758886539711282145698252967647695643837152466011063420158481037553923112829\"\n ; \"2085588517087605436136379278738013214233743532079287631079316773925068862732\"\n |]\n ; [| \"9513664655545306376987968929852776467090105742275395185801917554996684570014\"\n ; \"3550496136894926428779047632731319031180547135184616875506154252232382772731\"\n ; \"17611757480287922505786279147168077243913583114117625089682651438292645979006\"\n |]\n ; [| \"9510531870810299962531161626148485102758508164021526746981465493469502973181\"\n ; \"13147395489659079072941169740078305253501735721348147621757420460777184976765\"\n ; \"20981004218820236011689230170078809973840534961691702543937445515733151438851\"\n |]\n ; [| \"7510474971056266438887013036637998526887329893492694485779774584612719651459\"\n ; \"1410506880075029891986606588556057112819357276074907152324471561666187504226\"\n ; \"8531153700191448965915372279944017070557402838400132057846710117192547288312\"\n |]\n ; [| \"9754021311900999917627020811752417367253388211990562024285328010011773088524\"\n ; \"2596434275792412604724294796434266571220373976229139969740378299737237088707\"\n ; \"12362606196840499695717697542757730593369897628148107607660372162713524022091\"\n |]\n ; [| \"7436712609498458515091822640340398689078308761236724993140849063351217155692\"\n ; \"13658397008139421803306375444518324400013880452735832208526361116879733324843\"\n ; \"8172299227253932586074375157726142633344272790321861656172484971306271304428\"\n |]\n ; [| \"8605586894544301092657394167906502995894014247978769840701086209902531650480\"\n ; \"8900145888985471928279988821934068156350024482295663273746853580585203659117\"\n ; \"10470367937616887936936637392485540045417066546520320064401889047735866701687\"\n |]\n ; [| \"11506602210275354295255815678397482725225279643868372198705067756030230710066\"\n ; \"17848856881287888035559207919717746181941756011012420474955535369227552058196\"\n ; \"19621145748343950799654655801831590696734631175445290325293238308726746856381\"\n |]\n ; [| \"12864577757979281303137787677967581089249504938390812240088160999517854207023\"\n ; \"18146514933233558325125054842576736679593504913006946427595273862389774486334\"\n ; \"17884323247493851213892188228998881081766487773962855826892871743190914823275\"\n |]\n ; [| \"15402752720164650756401756498467037967910822997380610100998339390049962612988\"\n ; \"7603833157231114748089157493970988832295123465399487746989788482408777456140\"\n ; \"2397354421161661799662850246720819176952681967344524176801474312220041680576\"\n |]\n ; [| \"4644616545339594419852483555455431260822330146405566037177120172304445909733\"\n ; \"5263316028405817083848964416595634986103420395264546879434975622138579030157\"\n ; \"17782273009863750298483603933610732253879825505411230932533407287574651036994\"\n |]\n ; [| \"6757311365906043231713330034681410088312690560822302805339061832230418577842\"\n ; \"1747290142831105666564148972092238090059848968766027623980111244846463775952\"\n ; \"15626225602106279302483693031455114927351808163854564654776963760236790234423\"\n |]\n ; [| \"4913834867494755682369542218157533479788980551925269537630059523083653281581\"\n ; \"9877617390649361889067963484857474874019563445507538784053773745685676317984\"\n ; \"8907943459697784281828563593274242625606699321626165523327303792165072591809\"\n |]\n ; [| \"14664441047816797924985624056829230652985567659075289185564514710695287602702\"\n ; \"7007559757050385070202651829819464617707337597545855825279581955097245183469\"\n ; \"9907785227545441866241924986174555965766785257012652276622736289520175209842\"\n |]\n ; [| \"7597089497072493253646609764279824048404496412283438400323292326749646956121\"\n ; \"17909115638003629710512488646279326535029895707443505816458395075119245680309\"\n ; \"19899288359840151413448648239934294957736422087766709732366801832575234898200\"\n |]\n ; [| \"2776453255551777594442164922386336989357594907242688467733231910101268428455\"\n ; \"8731512921802677638551206899688496704819923065834522157915668185471088199231\"\n ; \"4270476107979642660344328132306502268479679050594759895042187137572326348178\"\n |]\n ; [| \"372963191403207230700085823960930798511810380777302780932220121859190714585\"\n ; \"1925392345596430848747460046135384348851089627416455489129305703977614383441\"\n ; \"17789118105598492176513882528357022912279065134405326075480819364512109487507\"\n |]\n ; [| \"20825008332751730091153821568987055752818061964131515789006779860691972036326\"\n ; \"12268072226614207724192089529070006978828099093641075700056577974897967878044\"\n ; \"8022939345678575485891537869705234790517539631432710130025799605516328239965\"\n |]\n ; [| \"15920446357440463160102379501579737913732417583637399015449814673775945192536\"\n ; \"4889967763577997404116252754960720158524059605911680924823220236886032161368\"\n ; \"13012115310019421859484865413402512912208022868124085927375736053832542569552\"\n |]\n ; [| \"11184812848348784840758139578916764774803469528077342079324383443440533140274\"\n ; \"10919525644265283860710095821750480494008303946536963464168615308937735732928\"\n ; \"16643027351354734329387947050668943310718100664075062130784371167893146427056\"\n |]\n ; [| \"2547391079287933146721925003560805204947901674695385307171999864858240689647\"\n ; \"5461671591847528192305502006203904211083239588855740323679605269651748982133\"\n ; \"1475483405991676112203600016600397946486872901513454996978092595555024286449\"\n |]\n ; [| \"5284066352388289958166453130467461920311116585098603685258698324490583696214\"\n ; \"11079707743980425617427448803513138667107248696505015838485445487813501565055\"\n ; \"18819466619498056228169794477791931948230648942982309978769076145394195937041\"\n |]\n ; [| \"20108313126965297449432768889178575293551084908049301416432179490902972394331\"\n ; \"18446218870769123862937242938812447270514023886221086573211479802027270358088\"\n ; \"16636528128134911466622907961467317982179835733058354229921170933476186200761\"\n |]\n ; [| \"21580255665898770000010464770058710398562069327783167608746916860519840032223\"\n ; \"14719915601901504081829966027980062397831689039960210526441564682684152170817\"\n ; \"797386830910520008361185815477523544664694040635544500916993469578452189812\"\n |]\n ; [| \"9191954826842055432037975444679415772735351199913945274909680288228536535340\"\n ; \"11513278700830950317038408125611466230422950302149566779135423862866530023329\"\n ; \"13459513701495368402370574098477760729128222868352131109204646186188457791240\"\n |]\n ; [| \"5838069727284828316721466034821618997221603062621589223178808662165373261546\"\n ; \"6979902978975477924362644821755411140298300026935490428140425890908442375988\"\n ; \"16599678038272927378481138839511139789855186087290435109798146115836043579679\"\n |]\n ; [| \"12381797209422929428691015082010109537263140181969703876017444022025467803832\"\n ; \"6196650026284414689888119006953515712490610535320673834463816720858366634575\"\n ; \"18782265413128936113173411940279630009396595382244197409034789821410800698518\"\n |]\n ; [| \"18317002472599225949038448120242542829985613745531554876060436499109578301758\"\n ; \"1113479082803535302111716504211921283895099225074844625686926178204705529642\"\n ; \"5260759667255734667421232066934840926892602367345740699882163520384512718144\"\n |]\n ; [| \"127322212868745470136356444796372247628159800282485305190839131621480537609\"\n ; \"12956514709922286639520985225111137950302442378466870763868693820049405409474\"\n ; \"16137538628380664965477096166491883462931577135505027115582810475234963977421\"\n |]\n ; [| \"11057045636926688236651567778699977961671424092293844825634750356999128470728\"\n ; \"20835936071817504066403719723663997794776505092359954695254304206506756731833\"\n ; \"11961388648747677421997837882451601307689195235077835309786508479783430361445\"\n |]\n ; [| \"1793573889039951715150662350698925328676543592757846244725079508391393408932\"\n ; \"13402289137612357934827599869485046878369856459821775713222740005646790544884\"\n ; \"6508055411788943934719705492602467864380077642763636443982129530687343724318\"\n |]\n ; [| \"17607902685988307931266356493635411696470169831190714792315124728753478035177\"\n ; \"8194273390415023152581060020119881338779571723515253104919314696738194355344\"\n ; \"14994505851254731180804912001382376960436431877822495675906581329931114145032\"\n |]\n ; [| \"18381184948945816702338052755591260342844745389721883995323025098702517473904\"\n ; \"9186573784864449816023279170257163602574499515262252135042448697937263179368\"\n ; \"16881796086836744646703159464114164393240695449455598565494759189917589453976\"\n |]\n ; [| \"20572234397819806324185746612386811237648846766146640064924937718650897781978\"\n ; \"15398960110011455954857390264976694406010423055791889624651258877641756178391\"\n ; \"7626627472565586612974136909394190701438927259101824156422280944508708088979\"\n |]\n ; [| \"5225513048091970342186287982290643286434413678466132108172918521639972895801\"\n ; \"20796219142718322272479527852102350372678035311367637066794738260059405761892\"\n ; \"18867914789735779656943683552060466421616672953566565464125163675462552310225\"\n |]\n ; [| \"1082743678015977585514191190870862236773423558498135453104771878687511906366\"\n ; \"12623224059252254308457589993365174837697684756635908936641223908438823373531\"\n ; \"12555890586414377546838955106772636059664719538696271061728900536297596172906\"\n |]\n ; [| \"15264924047176739600757644598701762120134127746088692861582462406342309222440\"\n ; \"13735945315945382005247895569035266667172550063549145646185577935658666385507\"\n ; \"16846296242516834547231537358954027537902709068158411294345086281698311539718\"\n |]\n ; [| \"5529559903327977764360588597603235134251022845353553657623467329197099735440\"\n ; \"17896661983150937411004047429485556264820315976705642986609974816436222162633\"\n ; \"6132147645856673317909222426799071493032959293586440635818225286067400272621\"\n |]\n ; [| \"19910536448857177568998054979673460274356626268309923630750601690129744044143\"\n ; \"21837022717353361125929262770547893899304355057483567328441690117551675150495\"\n ; \"18222937567706439527101614170488289588444167715669706061945406480673991437911\"\n |]\n ; [| \"1444795096087046870164826172194881116549489406599247123900277072374333222523\"\n ; \"7789285740743619796571024808404378017415878533792118428790588967260363950606\"\n ; \"2733591517253510124338232417535938539627593736745105875672348998709544742241\"\n |]\n ; [| \"10797236245657229835704604790990749002913266164534811352882924972411330424481\"\n ; \"8586865110658270624125510090452038681539626362312203247529227232785490000213\"\n ; \"16990606351055720221300633612533434675038905235719867684891402550154692840579\"\n |]\n ; [| \"13886834869596827027283068322204563244577723967928602405785473534631482228259\"\n ; \"15370041030312982119820349355806306848945675230473045778175606920520020444465\"\n ; \"4892392164144856036080673702415932177491638051096567008590655427718905654995\"\n |]\n ; [| \"7156056361402750618478307158538015778512650133626207855710105646992193371811\"\n ; \"18611994297623980580066352324654520696209128189173454279498506046357017146863\"\n ; \"20685574625754044704454597610042653981655420607405749168756591785339765348017\"\n |]\n ; [| \"19771798755427122057663307238031585225333077748195038834574552418532105026109\"\n ; \"7198246770791404776745997973411401046335399072925979346193035999274650139809\"\n ; \"4023053642231617394331377349850999955271972515156538475518460583299482183537\"\n |]\n ; [| \"8600241056877374090996492763915201371612819917708477598778176717657922462947\"\n ; \"13457797645730052033686724345687857978500724093559828625307818927699840833531\"\n ; \"16026530057488171235747101959040626414628692240827947554707033614704824950299\"\n |]\n ; [| \"17395049232451382970906883167116397657891664802601579276725674512534883408665\"\n ; \"9339859050789350561021790367067195330588925099928812336960590308144433379361\"\n ; \"2949098252117356570135518983407292742860689840833413663842097549831698684366\"\n |]\n ; [| \"20556719902345568138970735755829852608784985449829745172855204153387982836579\"\n ; \"17130405757403641097651484965062131526367059595476924144885570325828777794585\"\n ; \"12098791849907955483840555979771849699037912527654257328360429401569823685788\"\n |]\n ; [| \"17814517977679061356584950826520510701145481336316888282105225134451035883368\"\n ; \"18340263833447961155645725374025776400999561225129160795675360757778486987388\"\n ; \"2393071357700172397099185245759131983536576193657235776526704600015951290441\"\n |]\n ; [| \"4212550607122984812935174903270756328485507924528581618288369631872316849833\"\n ; \"4619648579309903974086199484827129282821840232468518761664883379486001128848\"\n ; \"11830688953328429351984357834116389341476681935757757908813724623462162230171\"\n |]\n ; [| \"9433820477150269924006815701757707228705128802452735931367255389078887381031\"\n ; \"19125188968599512029274834491491595733696896208317777847233033576184416289376\"\n ; \"5918385816682866756860679567405784562483373873565987668410277610868983146285\"\n |]\n ; [| \"11679489428851609457960439894174478045625452323813143057634803520728058419797\"\n ; \"5724733785096476011403606227853139854344547354731648536310363676109859979599\"\n ; \"17573793517331212796808333696068548553394697853729636886331034644281465518715\"\n |]\n ; [| \"282611654311082728776282944765587839903391931876410017096206359579538734085\"\n ; \"742728073451137928865285752406697012428821295824901554854990717103000537584\"\n ; \"20306380368695786945008272690438693745796297843799468268993907772341096948885\"\n |]\n ; [| \"18100113160685180514467703718098463577197975190144073884222766672672318113538\"\n ; \"3596350844916320672068639652188042917240676939829686824217717083735102849099\"\n ; \"20838832950303269747058536033620845977209873531644245727210334971563271393066\"\n |]\n ; [| \"6253957843395630813948692334683334608532810817769598722493240718085139817265\"\n ; \"19309791485130397858271625213458465097936495981008767692231734090527713082114\"\n ; \"5939164146353625472313254161303475736537743070584069770562424769865448756665\"\n |]\n ; [| \"12298194698807155456066733319264594344499679328227389872285371269582859681345\"\n ; \"10410720333027720675907856932360489614426170334449240317306371002856268450593\"\n ; \"13207537521011022812319141236421268356825327806625537047299253455889808792527\"\n |]\n ; [| \"2622643323130765702269424224791233611920515499144047449633123689743564676648\"\n ; \"7934318163093606910388307192320021056510770283350564327826894301919432120323\"\n ; \"7390981975273378581893427566935692330605702531948453130383999822487328794460\"\n |]\n |]\n }\n\nlet params_Mnt4_298 =\n { Params.mds =\n [| [| \"181324588122329172048070802614406344967661900669343676997796156524662650229663511778086513\"\n ; \"263839662794798230944406038483748877420003467481254943330033497627810628977768312588897021\"\n ; \"47787034086054868794736504598805355240746067397315425760363325479582067585554122384528750\"\n |]\n ; [| \"391385728862913577230643656405794210023251219169789744235774373121108965138889307827345939\"\n ; \"368056256556859616791833365938123080683505948787537081082804782658777406001515743364112843\"\n ; \"249229689710372851346889167834108105226843437678081232334602983010385341756350839066179566\"\n |]\n ; [| \"391761630355250451965959916078641131603140945583687294349414005799846378806556028223600720\"\n ; \"309426222273897994989187985039896323914733463925481353595665936771905869408957537639744345\"\n ; \"429282034891350663871556405902853196474768911490694799502975387461169986038745882893853806\"\n |]\n |]\n ; round_constants =\n [| [| \"78119860594733808983474265082430117124674905785489385612351809573030163625517\"\n ; \"41917899842730241418346215913324270532073353586134123463219061327941260175271\"\n ; \"74594641694171623328644944059182600919855574964222988275913344198970402906473\"\n |]\n ; [| \"96215759378377024990520153908983544755208851791126218239402755616994541522004\"\n ; \"64070601581278917442704840630680311036021557676765751754522901046069205253111\"\n ; \"112123228532462696722378911494343451272980413618911326680094528285518792872677\"\n |]\n ; [| \"84572244072021308337360477634782636535511175281144388234379224309078196768262\"\n ; \"45201095631123410354816854701250642083197167601967427301389500806815426216645\"\n ; \"23419302413627434057960523568681421397183896397903197013759822219271473949448\"\n |]\n ; [| \"63220724218126871510891512179599337793645245415246618202146262033908228783613\"\n ; \"67900966560828272306360950341997532094196196655192755442359232962244590070115\"\n ; \"56382132371728071364028077587343004835658613510701494793375685201885283260755\"\n |]\n ; [| \"80317852656339951095312898663286716255545986714650554749917139819628941702909\"\n ; \"110977183257428423540294096816813859894739618561444416996538397449475628658639\"\n ; \"25195781166503180938390820610484311038421647727795615447439501669639084690800\"\n |]\n ; [| \"108664438541952156416331885221418851366456449596370568350972106298760717710264\"\n ; \"17649294376560630922417546944777537620537408190408066211453084495108565929366\"\n ; \"95236435002924956844837407534938226368352771792739587594037613075251645052212\"\n |]\n ; [| \"43150472723422600689013423057826322506171125106415122422656432973040257528684\"\n ; \"77355911134402286174761911573353899889837132781450260391484427670446862700214\"\n ; \"8690728446593494554377477996892461126663797704587025899930929227865493269824\"\n |]\n ; [| \"109175231986025180460846040078523879514558355792739714578031829643740609438879\"\n ; \"64844253590731404811389281562033735091759746904073461140427127388042062490899\"\n ; \"43237071281695629980341250188156848876595681601471702180515324064382368960951\"\n |]\n ; [| \"2704440995725305992776846806711930876273040749514871232837487081811513368296\"\n ; \"66806779110388532101035294912010606217442229808784290357894909707660045365269\"\n ; \"25541187612624070470730890200174075890643652797181103367956318438136878170352\"\n |]\n ; [| \"89300613074831725721350087269266903129165086877175223066581882601662278010666\"\n ; \"36824076981866281177052433916337787028520068526782493484076995129329938182524\"\n ; \"68880449342008497744225106025198236600142055580985632884415488154606462819445\"\n |]\n ; [| \"68556888546596545408135887526582256648006271867854316538090068824142539400698\"\n ; \"111379753250206255125320675615931203940253796355491142745969887430259465111569\"\n ; \"101469186248899356416491489235841069222521093012237305521090058066171355672289\"\n |]\n ; [| \"87819793263125973233157093200229218382531712066157093399606059493857616731410\"\n ; \"11055386921184594780372263378420826851562920740321950336882051897732501262543\"\n ; \"111945832089295501567161822264292548657346358707472584179854375613919325491249\"\n |]\n ; [| \"95630018375719472826904441325138673248990446382783206900295723762884876505178\"\n ; \"94833984285990985873155989049880754188702918168949640563745233736765833491756\"\n ; \"77578854197021606645372788474039811639438242484066959482386065023999206730771\"\n |]\n ; [| \"27799616729223271646690718201487403976485619375555391888533887467404804041014\"\n ; \"42616502170265664498961018686434252976977548128285781725227341660941880774718\"\n ; \"95884094505080541517768389956970969462501217028562326732054532092615835087122\"\n |]\n ; [| \"107531500891040898338150732759493933154418374543568088749403053559827078391994\"\n ; \"17316158269457914256007584527534747738658973027567786054549020564540952112346\"\n ; \"51624680144452294805663893795879183520785046924484587034566439599591446246116\"\n |]\n ; [| \"17698087730709566968258013675219881840614043344609152682517330801348583470562\"\n ; \"111925747861248746962567200879629070277886617811519137515553806421564944666811\"\n ; \"57148554624730554436721083599187229462914514696466218614205595953570212881615\"\n |]\n ; [| \"92002976914130835490768248031171915767210477082066266868807636677032557847243\"\n ; \"58807951133460826577955909810426403194149348045831674376120801431489918282349\"\n ; \"93581873597000319446791963913210464830992618681307774190204379970955657554666\"\n |]\n ; [| \"46734218328816451470118898692627799522173317355773128175090189234250221977353\"\n ; \"12565476532112137808460978474958060441970941349010371267577877299656634907765\"\n ; \"54284813390357004119220859882274190703294683700710665367594256039714984623777\"\n |]\n ; [| \"92046423253202913319296401122133532555630886766139313429473309376931112550800\"\n ; \"15095408309586969968044201398966210357547906905122453139947200130015688526573\"\n ; \"76483858663950700865536712701042004661599554591777656961315837882956812689085\"\n |]\n ; [| \"37793510665854947576525000802927849210746292216845467892500370179796223909690\"\n ; \"84954934523349224038508216623641462700694917568481430996824733443763638196693\"\n ; \"81116649005575743294029244339854405387811058321603450814032274416116019472096\"\n |]\n ; [| \"28313841745366368076212445154871968929195537523489133192784916081223753077949\"\n ; \"17307716513182567320564075539526480893558355908652993731441220999922946005081\"\n ; \"63148771170858502457695904149048034226689843239981287723002468627916462842625\"\n |]\n ; [| \"14724939606645168531546334343600232253284320276481307778787768813885931648950\"\n ; \"4684996260500305121238590806572541849891754312215139285622888510153705963000\"\n ; \"63682763879011752475568476861367553456179860221069473817315669232908763409259\"\n |]\n ; [| \"47776179656187399887062096850541192680190218704758942820514561435612697426715\"\n ; \"42017618175533328439486588850450028995049195954365035474995309904751824054581\"\n ; \"39169739448648613641258102792190571431737464735838931948313779997907435855102\"\n |]\n ; [| \"37525991163523321662699819448962967746703579202577998445997476955224037837979\"\n ; \"67759173441312327668891803222741396828094999063019622301649400178376863820046\"\n ; \"23041132473771739182071223620364590606653086905326129708428084432335332411661\"\n |]\n ; [| \"77778894465896892167598828497939467663479992533052348475467490972714790615441\"\n ; \"20821227542001445006023346122554483849065713580779858784021328359824080462519\"\n ; \"47217242463811495777303984778653549585537750303740616187093690846833142245039\"\n |]\n ; [| \"42826871300142174590405062658305130206548405024021455479047593769907201224399\"\n ; \"8850081254230234130482383430433176873344633494243110112848647064077741649744\"\n ; \"1819639941546179668398979507053724449231350395599747300736218202072168364980\"\n |]\n ; [| \"21219092773772827667886204262476112905428217689703647484316763603169544906986\"\n ; \"35036730416829620763976972888493029852952403098232484869595671405553221294746\"\n ; \"35487050610902505183766069070898136230610758743267437784506875078109148276407\"\n |]\n ; [| \"62560813042054697786535634928462520639989597995560367915904328183428481834648\"\n ; \"112205708104999693686115882430330200785082630634036862526175634736046083007596\"\n ; \"109084747126382177842005646092084591250172358815974554434100716599544229364287\"\n |]\n ; [| \"63740884245554590221521941789197287379354311786803164550686696984009448418872\"\n ; \"58779928727649398559174292364061339806256990859940639552881479945324304668069\"\n ; \"20614241966717622390914334053622572167995367802051836931454426877074875942253\"\n |]\n ; [| \"41621411615229558798583846330993607380846912281220890296433013153854774573504\"\n ; \"20530621481603446397085836296967350209890164029268319619481535419199429275412\"\n ; \"99914592017824500091708233310179001698739309503141229228952777264267035511439\"\n |]\n ; [| \"9497854724940806346676139162466690071592872530638144182764466319052293463165\"\n ; \"7549205476288061047040852944548942878112823732145584918107208536541712726277\"\n ; \"30898915730863004722886730649661235919513859500318540107289237568593577554645\"\n |]\n ; [| \"22697249754607337581727259086359907309326296469394183645633378468855554942575\"\n ; \"72771100592475003378969523202338527077495914171905204927442739996373603143216\"\n ; \"84509851995167666169868678185342549983568150803791023831909660012392522615426\"\n |]\n ; [| \"36601166816771446688370845080961015541431660429079281633209182736773260407536\"\n ; \"19555759172327736128240171000715903945570888389700763573790859521156095228287\"\n ; \"82844424532983875300577689116331373756526403900340445449185486212503235782229\"\n |]\n ; [| \"40833119728631657038301474658571416779079199343770917422783737091842927892625\"\n ; \"68922359316478675184342553333343300163568193749010867527082189412217781430311\"\n ; \"91516472400306837063911995909475588197278444979245081960087094196120449075833\"\n |]\n ; [| \"21304716730402869084944080869903443431235336418077153507261240151959530377653\"\n ; \"106551237424345741137570659736231801772439680702621554106791455938098031620471\"\n ; \"104392597313271110590927764888829150750277653499050463757708547416538850601163\"\n |]\n ; [| \"16907937154215020261110468963982390213438461071031811101554056252102505124726\"\n ; \"23183141532591565112222057191012766855134687114504142337903677590107533245206\"\n ; \"96725517880771645283128624101279195709280644465575982072053504613644938879246\"\n |]\n ; [| \"84556507395241990875812091718422997082915179448604219593521819129312718969906\"\n ; \"100646525819453650494590571397259055384579251368754179569362740802641255820576\"\n ; \"50316555026297423940834952362583934362215303629664094841692233643882339493043\"\n |]\n ; [| \"77363534410783423412630139556441807611393685349073113946053979350631229049878\"\n ; \"54905073434434959485893381841839373267383966385817882684657825178181863944371\"\n ; \"110016011331508430102821620395154714608084938556260733745010992614542669817451\"\n |]\n ; [| \"52040139270046094723964229965823921970388683619580004402190656733318120479093\"\n ; \"495546618036723566920914648951352373868059898268055487677897567226892784967\"\n ; \"2528292188392170914010448139211586215817069915670005292953294092269979070980\"\n |]\n ; [| \"36842840134449713950999812540127591123318806680559982063089906871196226758113\"\n ; \"112314504940338253416202605695368724580971154020421327790335219348068041886245\"\n ; \"51653712314537383078368021242008468828072907802445786549975419682333073143987\"\n |]\n ; [| \"27179054135131403873076215577181710354069071017096145081169516607932870071868\"\n ; \"93264325401956094073193527739715293258814405715822269809955952297346626219055\"\n ; \"75336695567377817226085396912086909560962335091652231383627608374094112503635\"\n |]\n ; [| \"42536477740858058164730818130587261149155820207748153094480456895727052896150\"\n ; \"45297707210835305388426482743535401273114010430724989418303851665124351001731\"\n ; \"28263543670875633354854018109712021307749750769690268127459707194207091046997\"\n |]\n ; [| \"40809484989590048522440442751358616303471639779690405026946053699354967624695\"\n ; \"51589519265418587649124543325590658874910911006853535317847189422703251228717\"\n ; \"73459936981642894525955700397592343967482441686326322443228255968694436816673\"\n |]\n ; [| \"87298777232393189731949522229743081866971743270330772607820990832164835738703\"\n ; \"23328534428894097247289332213412175849711532153957647506361455182140450133738\"\n ; \"51807348624578081645565456865744011145427112815128832643950401419083788780028\"\n |]\n ; [| \"62003629107726929116302469001779155132709624140360743951550189738290955064278\"\n ; \"109311858027068383034683875948676795998030610067675200794951297783857157095297\"\n ; \"2085588517087605436136379278738013214233743532079287631079316773925068862732\"\n |]\n ; [| \"9513664655545306376987968929852776467090105742275395185801917554996684570014\"\n ; \"91103467624252027317764670613760419385374004736848754250298970998535616755199\"\n ; \"39500000352127197728032684892425352332461947514533659433380855624868454474623\"\n |]\n ; [| \"75175260486328125629270378861920310368403601365269629778076078053196928460032\"\n ; \"56923881233337629517433981230592855430598464522180216309153828833928801967999\"\n ; \"20981004218820236011689230170078809973840534961691702543937445515733151438851\"\n |]\n ; [| \"73175203586574092105626230272409823792532423094740797516874387144340145138310\"\n ; \"45186992623753580336479418079070607289916086076906975839720879934817804495460\"\n ; \"96084125187548549854900995260973117424750860440064269432639526863495781270780\"\n |]\n ; [| \"53530507055579550362119832302266967544350117012822630711681736383163390079758\"\n ; \"24484677147631687826970700541691541659768738376645174313438582486313045584324\"\n ; \"99915577684197600584703320523786830947563355229812244982453188909016758004559\"\n |]\n ; [| \"73101441225016284181831039876112223954723401962484828024235461623078642642543\"\n ; \"57434882751817972247799186935032874577110609253567900895922769490031350316077\"\n ; \"73837027842771758252813592393497967898989365991569964687267097531033696791279\"\n |]\n ; [| \"8605586894544301092657394167906502995894014247978769840701086209902531650480\"\n ; \"8900145888985471928279988821934068156350024482295663273746853580585203659117\"\n ; \"76135096553134713603675854628257365311062159747768423095496501607463292188538\"\n |]\n ; [| \"77171330825793179961995032914169307990870372845116475229799680315757656196917\"\n ; \"17848856881287888035559207919717746181941756011012420474955535369227552058196\"\n ; \"85285874363861776466393873037603415962379724376693393356387850868454172343232\"\n |]\n ; [| \"34752820629818556525384193423224856177797869338806846583786365186093662702640\"\n ; \"61923000676912108769617866333091286856690233713839015114991682235541391477568\"\n ; \"105437294734850952102877811210027981435959945375626993201685688489494148805743\"\n |]\n ; [| \"37290995592003925978648162243724313056459187397796644444696543576625771108605\"\n ; \"95156804644588215637074780475000089186488581067063625121782605228712011438608\"\n ; \"111838568780358037910894878973007194619694503969424695895292495245099084158661\"\n |]\n ; [| \"114085830904535970531084512281741806703564152148485737755668141105183488387818\"\n ; \"27151558900245092306095370161852910074651784795680581223133179808714387525774\"\n ; \"17782273009863750298483603933610732253879825505411230932533407287574651036994\"\n |]\n ; [| \"72422039981423868898452547270453235353957783762070405836433674391957844064693\"\n ; \"23635533014670380888810554717349513178608213369182061967678315431422272271569\"\n ; \"59402711345784829746976504521969665104448536964686633342173372133388407225657\"\n |]\n ; [| \"92466806354851856571355165199186633833982438153589406912422876269386887264049\"\n ; \"9877617390649361889067963484857474874019563445507538784053773745685676317984\"\n ; \"74572672075215609948567780829046067891251792522874268554421916351892498078660\"\n |]\n ; [| \"36552683919656073147232029802086505741533932059491323529262718897271096098319\"\n ; \"28895802628889660292449057575076739706255701997961890168977786141673053679086\"\n ; \"9907785227545441866241924986174555965766785257012652276622736289520175209842\"\n |]\n ; [| \"29485332368911768475893015509537099136952860812699472744021496513325455451738\"\n ; \"39797358509842904932758894391536601623578260107859540160156599261695054175926\"\n ; \"107452259847197252302434271220963395311929879689430847107159618578878468880668\"\n |]\n ; [| \"24664696127391052816688570667643612077905959307658722811431436096677076924072\"\n ; \"52507998665481228083044018390203046881916651866666590845312076558622705190465\"\n ; \"69935204723497468327083545368078327534124772251842862926136799697299751835029\"\n |]\n ; [| \"372963191403207230700085823960930798511810380777302780932220121859190714585\"\n ; \"111366606704792806959979488772421759791592911629496627207620326636856656861526\"\n ; \"39677360977437767398760288273614298000827429534821360419179023551087917983124\"\n |]\n ; [| \"64601494076430280535646633059501605929914790764963584476403188233843589027560\"\n ; \"34156315098453482946438495274327282067376463494057110043754782161473776373661\"\n ; \"73687667961196401152630755105477060056162632832680813161120412165243753726816\"\n |]\n ; [| \"37808689229279738382348785246837013002280781984053433359148018860351753688153\"\n ; \"26778210635417272626362658500217995247072424006327715268521424423461840656985\"\n ; \"13012115310019421859484865413402512912208022868124085927375736053832542569552\"\n |]\n ; [| \"33073055720188060063004545324174039863351833928493376423022587630016341635891\"\n ; \"76584254259783109527449313057522305759653397147785066495263227868665161219779\"\n ; \"38531270223194009551634352795926218399266465064491096474482575354468954922673\"\n |]\n ; [| \"90100362566645034035707547984589905559141359276359522681964816611161474672115\"\n ; \"93014643079204629081291124987233004565276697190519877698472422015954982964601\"\n ; \"110916697765188052223435628742886773389228694903593626715469113528434066764534\"\n |]\n ; [| \"114725280711584666069398481856753837363052938587178775403749719257369626174299\"\n ; \"32967950615819700839673854548770413755655613096921050182183649674389310060672\"\n ; \"106372438106855157117155417458821032302424106544646447353561892891697429919509\"\n |]\n ; [| \"41996555998804572671679174634435850382099449308465335760130383677478780889948\"\n ; \"105999190358126224751922865919841547624707481487885223948004296548330504340556\"\n ; \"16636528128134911466622907961467317982179835733058354229921170933476186200761\"\n |]\n ; [| \"43468498537738045222256870515315985487110433728199201952445121047095648527840\"\n ; \"102272887089258604970815589009009162752025146641624347901234381428987386153285\"\n ; \"797386830910520008361185815477523544664694040635544500916993469578452189812\"\n |]\n ; [| \"96744926314199156321023598425708516126928808801578082649702497034531770517808\"\n ; \"99066250188188051206024031106640566584616407903813704153928240609169764005797\"\n ; \"101012485188852469291356197079506861083321680470016268483997462932491691773708\"\n |]\n ; [| \"49614555470963378761214277525336169174318331863453657910575217035316990252780\"\n ; \"94532874466332578813348267802784511494491757628599627802933242637211676358456\"\n ; \"60376163781951477822973950330025689966951914888122503797194554488987660570913\"\n |]\n ; [| \"99934768696780030317676638063039209891456597783633841250810260768328701786300\"\n ; \"71861378641802240356627336242725340978135703736568776865558429280585792121426\"\n ; \"84446994028646761779912629176051455275041688583492300440129402381138226185369\"\n |]\n ; [| \"18317002472599225949038448120242542829985613745531554876060436499109578301758\"\n ; \"23001721954642810524358122249469196372443463625490878969385130364780514025259\"\n ; \"49037245410934285111914043557449391103989331168177809387278571893536129709378\"\n |]\n ; [| \"65792050828386571136875573680568197513273253001530588336285451691348906024460\"\n ; \"12956514709922286639520985225111137950302442378466870763868693820049405409474\"\n ; \"38025781500219940187723501911749158551479941535921061459281014661810772473038\"\n |]\n ; [| \"98610017124283789125637190759729078315864881693957982200427567103302362453196\"\n ; \"42724178943656779288650125468921272883324869492775989038952508393082565227450\"\n ; \"99514360136104778310983460863480701661882652836741972684579325226086664343913\"\n |]\n ; [| \"111234788248236327826382691076985300771418365594838017963216100441270435887017\"\n ; \"35290532009451633157074005614742321966918220860237810056920944192222599040501\"\n ; \"72172784027306769601458922728374293130025170844011739475076742090414769211169\"\n |]\n ; [| \"61384388429666858375759167984149961873566898632022783479711533101905095026411\"\n ; \"8194273390415023152581060020119881338779571723515253104919314696738194355344\"\n ; \"80659234466772556847544129237154202226081525079070598707001193889658539631883\"\n |]\n ; [| \"62157670692624367146830864246105810519941474190553952682719433471854134465138\"\n ; \"74851302400382275482762496406028988868219592716510355166137061257664688666219\"\n ; \"16881796086836744646703159464114164393240695449455598565494759189917589453976\"\n |]\n ; [| \"42460477269659081546432152357644086326197211166562674408623141905226706277595\"\n ; \"81063688725529281621596607500748519671655516257039992655745871437369181665242\"\n ; \"51403113216244137057466948399908740878535656059933892843818689317660325080213\"\n |]\n ; [| \"49001998791770520786679099472805193463531142479298200795569326894791589887035\"\n ; \"42684462014557597494725933597359625461226399711783671410492942446635214257509\"\n ; \"106420886277092880545929306533089566775810130555230702838917980421765786292693\"\n |]\n ; [| \"110523958037212353696746219917157237679515245560578307171595792811566554384451\"\n ; \"56399709802930804752950401483879725014794413557467977624037632281590440364765\"\n ; \"100108862073771478435824578087801736413858177140360408436521717282600830155374\"\n |]\n ; [| \"59041409790855290045250456089216312297230856546920761548978870779493926213674\"\n ; \"13735945315945382005247895569035266667172550063549145646185577935658666385507\"\n ; \"16846296242516834547231537358954027537902709068158411294345086281698311539718\"\n |]\n ; [| \"114970774262524353875592617323889610576992844847433725376114488262076142213525\"\n ; \"17896661983150937411004047429485556264820315976705642986609974816436222162633\"\n ; \"115573362005053049429141251153085446935774781295666612354309246218946442750706\"\n |]\n ; [| \"85575265064375003235737272215445285540001719469558026661845214249857169530994\"\n ; \"87501751332871186792668480006319719164949448258731670359536302677279100637346\"\n ; \"105775909055063540416087237151517389942637625317333843436738223226977225420379\"\n |]\n ; [| \"110886009455283422981396854898481256559291311408679418842391298005253375700608\"\n ; \"95342257228100720685556647789433478371609336135456255803583405713563597933074\"\n ; \"2733591517253510124338232417535938539627593736745105875672348998709544742241\"\n |]\n ; [| \"32685479117496505057951010536248024091461630564950845696581129158987138920098\"\n ; \"96139836598015371513111133071481139035733083963976340622322043979088723982681\"\n ; \"16990606351055720221300633612533434675038905235719867684891402550154692840579\"\n |]\n ; [| \"13886834869596827027283068322204563244577723967928602405785473534631482228259\"\n ; \"81034769645830807786559566591578132114590768431721148809270219480247445931316\"\n ; \"26780635035984131258327079447673207266040002451512601352288859614294714150612\"\n |]\n ; [| \"72820784976920576285217524394309841044157743334874310886804718206719618858662\"\n ; \"84276722913141806246805569560426345961854221390421557310593118606084442633714\"\n ; \"42573817497593319926701003355299929070203785007821783512454795971915573843634\"\n |]\n ; [| \"41660041627266397279909712983288860313881442148611073178272756605107913521726\"\n ; \"7198246770791404776745997973411401046335399072925979346193035999274650139809\"\n ; \"91576025129588718283317000330880100309465430116820675850311277329602716166005\"\n |]\n ; [| \"30488483928716649313242898509172476460161184318124511942476380904233730958564\"\n ; \"35346040517569327255933130090945133067049088493975862969006023114275649329148\"\n ; \"59803015801166721680239913449555176591725421041660016242103441987856441941533\"\n |]\n ; [| \"17395049232451382970906883167116397657891664802601579276725674512534883408665\"\n ; \"96892830538146451450007413348096295684782382701592949711753407054447667361829\"\n ; \"46725583995795907014628330473921842919957418641665482351238505922983315675600\"\n |]\n ; [| \"20556719902345568138970735755829852608784985449829745172855204153387982836579\"\n ; \"17130405757403641097651484965062131526367059595476924144885570325828777794585\"\n ; \"99651763337265056372826178960800950053231370129318394703153246147873057668256\"\n |]\n ; [| \"17814517977679061356584950826520510701145481336316888282105225134451035883368\"\n ; \"62116749577126511600138536864540326578096290025961229483071769130930103978622\"\n ; \"68057799973217998063838402481530957249181669394905338807621317159743376777292\"\n |]\n ; [| \"26100793478962260035181580648528031417033872324944615961986573818448125345450\"\n ; \"26507891451149179196332605230084404371370204632884553105363087566061809624465\"\n ; \"55607174697006979796477169324630939518573410736589826596210132996613779221405\"\n |]\n ; [| \"75098549092668095590746032937529532494350222003700838962461867948806312867882\"\n ; \"62901674712278062473767645982006145910793625009149846534629441949336033280610\"\n ; \"5918385816682866756860679567405784562483373873565987668410277610868983146285\"\n |]\n ; [| \"99232460916208710346946062875203578399818909925477280432427620267031292402265\"\n ; \"115165948144292852122635634954139515297086369356811820254801384608988902457684\"\n ; \"39462036389170488019054739441325823641943062254145671230029238830857274014332\"\n |]\n ; [| \"109723826013507458840008311671051963282645213933956581735587227292458581212170\"\n ; \"88295699560808238817850908733435797366622278897489038929647807463406234520052\"\n ; \"20306380368695786945008272690438693745796297843799468268993907772341096948885\"\n |]\n ; [| \"39988356032524455736714109463355738665746339590560108227920970859248126609155\"\n ; \"47372836588594871116561451142702593094337405740661755511614125456886719840333\"\n ; \"42727075822142544969304941778878121065758237932060280070908539158139079888683\"\n |]\n ; [| \"115695172202592006925180721060969710051274632819849770440984261650964182295350\"\n ; \"41198034356969673080518030958715740186484860381424802035929938277103521577731\"\n ; \"115380378505550001583545282887589851179279565072664241489053445702744491234750\"\n |]\n ; [| \"56074680442485705900559544809779144521596408129059458559681779642734476672579\"\n ; \"54187206076706271120400668422875039791522899135281309004702779376007885441827\"\n ; \"100760509008368123701304764217450368711018785408289674422092070202193042774995\"\n |]\n ; [| \"2622643323130765702269424224791233611920515499144047449633123689743564676648\"\n ; \"95487289650450707799373930173349121410704227885014701702619711048222666102791\"\n ; \"94943953462630479470879050547964792684799160133612590505176816568790562776928\"\n |]\n |]\n }\n\nlet params_Mnt4_753 =\n { Params.mds =\n [| [| \"18008368437737423474309001369890301521976028259557869102888851965525650962978826556079921598599098888590302388431866694591858505845787597588918688371226882207991627422083815074127761663891796146172734531991290402968541914191945\"\n ; \"32962087054539410523956712909309686802653898657605569239066684150412875533806729129396719808139132458477579312916467576544007112173179883702872518317566248974424872120316787037296877442303550788674087649228607529914336317231815\"\n ; \"5483644920564955035638567475101171013329909513705951195576914157062781400017095978578204379959018576768230785151221956162299596069033091214145892295417145700700562355150808732841416210677611704678816316579070697592848376918151\"\n |]\n ; [| \"22978648816866328436434244623482365207916416489037627250857600725663194263360344221738155318310265722276036466391561221273100146793047089336717612168000266025808046352571957200240941276891050003938106626328014785436301089444973\"\n ; \"30994637628885441247541289546067547358628828834593234742882770745561956454298316691254641971835514862825457645395555821312465912408960063865618013131940007283956832467402859348036195396599351702172170219903104023278420827940135\"\n ; \"7096546890972108774287040498267941446510912236116268882520023333699636048386130304511472040490894498194252489942856762189629237475878134498814298584446894911200379613916180563419809701971057277837757006070684068787238347669992\"\n |]\n ; [| \"36972350749469737754741804679554799140755989986720531577443294433161553396641362942311484418395414339763390349161399190591697773588979458652577643792428305947365748981633559835484411429153283032734484874265223184021528054671667\"\n ; \"41737243523985324129413602960234190443256387558212939183466624464606481865667576817406507424236723364751044981130064473555650490691461017936143464747647507236853158008794221676669840197156981325463879378696484711828785706949884\"\n ; \"17173689835840458026597473076649786448044751322360472626284380020090825232350642484368920024327948574743378803111953285570783101340571478325610471380479472689631139762331626281838772360396878623880994496993923849428256427219637\"\n |]\n |]\n ; round_constants =\n [| [| \"78119860594733808983474265082430117124674905785489385612351809573030163625517\"\n ; \"41917899842730241418346215913324270532073353586134123463219061327941260175271\"\n ; \"74594641694171623328644944059182600919855574964222988275913344198970402906473\"\n |]\n ; [| \"96215759378377024990520153908983544755208851791126218239402755616994541522004\"\n ; \"64070601581278917442704840630680311036021557676765751754522901046069205253111\"\n ; \"112123228532462696722378911494343451272980413618911326680094528285518792872677\"\n |]\n ; [| \"84572244072021308337360477634782636535511175281144388234379224309078196768262\"\n ; \"45201095631123410354816854701250642083197167601967427301389500806815426216645\"\n ; \"23419302413627434057960523568681421397183896397903197013759822219271473949448\"\n |]\n ; [| \"63220724218126871510891512179599337793645245415246618202146262033908228783613\"\n ; \"67900966560828272306360950341997532094196196655192755442359232962244590070115\"\n ; \"56382132371728071364028077587343004835658613510701494793375685201885283260755\"\n |]\n ; [| \"80317852656339951095312898663286716255545986714650554749917139819628941702909\"\n ; \"110977183257428423540294096816813859894739618561444416996538397449475628658639\"\n ; \"25195781166503180938390820610484311038421647727795615447439501669639084690800\"\n |]\n ; [| \"108664438541952156416331885221418851366456449596370568350972106298760717710264\"\n ; \"17649294376560630922417546944777537620537408190408066211453084495108565929366\"\n ; \"95236435002924956844837407534938226368352771792739587594037613075251645052212\"\n |]\n ; [| \"43150472723422600689013423057826322506171125106415122422656432973040257528684\"\n ; \"77355911134402286174761911573353899889837132781450260391484427670446862700214\"\n ; \"8690728446593494554377477996892461126663797704587025899930929227865493269824\"\n |]\n ; [| \"109175231986025180460846040078523879514558355792739714578031829643740609438879\"\n ; \"64844253590731404811389281562033735091759746904073461140427127388042062490899\"\n ; \"43237071281695629980341250188156848876595681601471702180515324064382368960951\"\n |]\n ; [| \"2704440995725305992776846806711930876273040749514871232837487081811513368296\"\n ; \"66806779110388532101035294912010606217442229808784290357894909707660045365269\"\n ; \"25541187612624070470730890200174075890643652797181103367956318438136878170352\"\n |]\n ; [| \"89300613074831725721350087269266903129165086877175223066581882601662278010666\"\n ; \"36824076981866281177052433916337787028520068526782493484076995129329938182524\"\n ; \"68880449342008497744225106025198236600142055580985632884415488154606462819445\"\n |]\n ; [| \"68556888546596545408135887526582256648006271867854316538090068824142539400698\"\n ; \"111379753250206255125320675615931203940253796355491142745969887430259465111569\"\n ; \"101469186248899356416491489235841069222521093012237305521090058066171355672289\"\n |]\n ; [| \"87819793263125973233157093200229218382531712066157093399606059493857616731410\"\n ; \"11055386921184594780372263378420826851562920740321950336882051897732501262543\"\n ; \"111945832089295501567161822264292548657346358707472584179854375613919325491249\"\n |]\n ; [| \"95630018375719472826904441325138673248990446382783206900295723762884876505178\"\n ; \"94833984285990985873155989049880754188702918168949640563745233736765833491756\"\n ; \"77578854197021606645372788474039811639438242484066959482386065023999206730771\"\n |]\n ; [| \"27799616729223271646690718201487403976485619375555391888533887467404804041014\"\n ; \"42616502170265664498961018686434252976977548128285781725227341660941880774718\"\n ; \"95884094505080541517768389956970969462501217028562326732054532092615835087122\"\n |]\n ; [| \"107531500891040898338150732759493933154418374543568088749403053559827078391994\"\n ; \"17316158269457914256007584527534747738658973027567786054549020564540952112346\"\n ; \"51624680144452294805663893795879183520785046924484587034566439599591446246116\"\n |]\n ; [| \"17698087730709566968258013675219881840614043344609152682517330801348583470562\"\n ; \"111925747861248746962567200879629070277886617811519137515553806421564944666811\"\n ; \"57148554624730554436721083599187229462914514696466218614205595953570212881615\"\n |]\n ; [| \"92002976914130835490768248031171915767210477082066266868807636677032557847243\"\n ; \"58807951133460826577955909810426403194149348045831674376120801431489918282349\"\n ; \"93581873597000319446791963913210464830992618681307774190204379970955657554666\"\n |]\n ; [| \"46734218328816451470118898692627799522173317355773128175090189234250221977353\"\n ; \"12565476532112137808460978474958060441970941349010371267577877299656634907765\"\n ; \"54284813390357004119220859882274190703294683700710665367594256039714984623777\"\n |]\n ; [| \"92046423253202913319296401122133532555630886766139313429473309376931112550800\"\n ; \"15095408309586969968044201398966210357547906905122453139947200130015688526573\"\n ; \"76483858663950700865536712701042004661599554591777656961315837882956812689085\"\n |]\n ; [| \"37793510665854947576525000802927849210746292216845467892500370179796223909690\"\n ; \"84954934523349224038508216623641462700694917568481430996824733443763638196693\"\n ; \"81116649005575743294029244339854405387811058321603450814032274416116019472096\"\n |]\n ; [| \"28313841745366368076212445154871968929195537523489133192784916081223753077949\"\n ; \"17307716513182567320564075539526480893558355908652993731441220999922946005081\"\n ; \"63148771170858502457695904149048034226689843239981287723002468627916462842625\"\n |]\n ; [| \"14724939606645168531546334343600232253284320276481307778787768813885931648950\"\n ; \"4684996260500305121238590806572541849891754312215139285622888510153705963000\"\n ; \"63682763879011752475568476861367553456179860221069473817315669232908763409259\"\n |]\n ; [| \"47776179656187399887062096850541192680190218704758942820514561435612697426715\"\n ; \"42017618175533328439486588850450028995049195954365035474995309904751824054581\"\n ; \"39169739448648613641258102792190571431737464735838931948313779997907435855102\"\n |]\n ; [| \"37525991163523321662699819448962967746703579202577998445997476955224037837979\"\n ; \"67759173441312327668891803222741396828094999063019622301649400178376863820046\"\n ; \"23041132473771739182071223620364590606653086905326129708428084432335332411661\"\n |]\n ; [| \"77778894465896892167598828497939467663479992533052348475467490972714790615441\"\n ; \"20821227542001445006023346122554483849065713580779858784021328359824080462519\"\n ; \"47217242463811495777303984778653549585537750303740616187093690846833142245039\"\n |]\n ; [| \"42826871300142174590405062658305130206548405024021455479047593769907201224399\"\n ; \"8850081254230234130482383430433176873344633494243110112848647064077741649744\"\n ; \"1819639941546179668398979507053724449231350395599747300736218202072168364980\"\n |]\n ; [| \"21219092773772827667886204262476112905428217689703647484316763603169544906986\"\n ; \"35036730416829620763976972888493029852952403098232484869595671405553221294746\"\n ; \"35487050610902505183766069070898136230610758743267437784506875078109148276407\"\n |]\n ; [| \"62560813042054697786535634928462520639989597995560367915904328183428481834648\"\n ; \"112205708104999693686115882430330200785082630634036862526175634736046083007596\"\n ; \"109084747126382177842005646092084591250172358815974554434100716599544229364287\"\n |]\n ; [| \"63740884245554590221521941789197287379354311786803164550686696984009448418872\"\n ; \"58779928727649398559174292364061339806256990859940639552881479945324304668069\"\n ; \"20614241966717622390914334053622572167995367802051836931454426877074875942253\"\n |]\n ; [| \"41621411615229558798583846330993607380846912281220890296433013153854774573504\"\n ; \"20530621481603446397085836296967350209890164029268319619481535419199429275412\"\n ; \"99914592017824500091708233310179001698739309503141229228952777264267035511439\"\n |]\n ; [| \"9497854724940806346676139162466690071592872530638144182764466319052293463165\"\n ; \"7549205476288061047040852944548942878112823732145584918107208536541712726277\"\n ; \"30898915730863004722886730649661235919513859500318540107289237568593577554645\"\n |]\n ; [| \"22697249754607337581727259086359907309326296469394183645633378468855554942575\"\n ; \"72771100592475003378969523202338527077495914171905204927442739996373603143216\"\n ; \"84509851995167666169868678185342549983568150803791023831909660012392522615426\"\n |]\n ; [| \"36601166816771446688370845080961015541431660429079281633209182736773260407536\"\n ; \"19555759172327736128240171000715903945570888389700763573790859521156095228287\"\n ; \"82844424532983875300577689116331373756526403900340445449185486212503235782229\"\n |]\n ; [| \"40833119728631657038301474658571416779079199343770917422783737091842927892625\"\n ; \"68922359316478675184342553333343300163568193749010867527082189412217781430311\"\n ; \"91516472400306837063911995909475588197278444979245081960087094196120449075833\"\n |]\n ; [| \"21304716730402869084944080869903443431235336418077153507261240151959530377653\"\n ; \"106551237424345741137570659736231801772439680702621554106791455938098031620471\"\n ; \"104392597313271110590927764888829150750277653499050463757708547416538850601163\"\n |]\n ; [| \"16907937154215020261110468963982390213438461071031811101554056252102505124726\"\n ; \"23183141532591565112222057191012766855134687114504142337903677590107533245206\"\n ; \"96725517880771645283128624101279195709280644465575982072053504613644938879246\"\n |]\n ; [| \"84556507395241990875812091718422997082915179448604219593521819129312718969906\"\n ; \"100646525819453650494590571397259055384579251368754179569362740802641255820576\"\n ; \"50316555026297423940834952362583934362215303629664094841692233643882339493043\"\n |]\n ; [| \"77363534410783423412630139556441807611393685349073113946053979350631229049878\"\n ; \"54905073434434959485893381841839373267383966385817882684657825178181863944371\"\n ; \"110016011331508430102821620395154714608084938556260733745010992614542669817451\"\n |]\n ; [| \"52040139270046094723964229965823921970388683619580004402190656733318120479093\"\n ; \"495546618036723566920914648951352373868059898268055487677897567226892784967\"\n ; \"2528292188392170914010448139211586215817069915670005292953294092269979070980\"\n |]\n ; [| \"36842840134449713950999812540127591123318806680559982063089906871196226758113\"\n ; \"112314504940338253416202605695368724580971154020421327790335219348068041886245\"\n ; \"51653712314537383078368021242008468828072907802445786549975419682333073143987\"\n |]\n ; [| \"27179054135131403873076215577181710354069071017096145081169516607932870071868\"\n ; \"93264325401956094073193527739715293258814405715822269809955952297346626219055\"\n ; \"75336695567377817226085396912086909560962335091652231383627608374094112503635\"\n |]\n ; [| \"42536477740858058164730818130587261149155820207748153094480456895727052896150\"\n ; \"45297707210835305388426482743535401273114010430724989418303851665124351001731\"\n ; \"28263543670875633354854018109712021307749750769690268127459707194207091046997\"\n |]\n ; [| \"40809484989590048522440442751358616303471639779690405026946053699354967624695\"\n ; \"51589519265418587649124543325590658874910911006853535317847189422703251228717\"\n ; \"73459936981642894525955700397592343967482441686326322443228255968694436816673\"\n |]\n ; [| \"87298777232393189731949522229743081866971743270330772607820990832164835738703\"\n ; \"23328534428894097247289332213412175849711532153957647506361455182140450133738\"\n ; \"51807348624578081645565456865744011145427112815128832643950401419083788780028\"\n |]\n ; [| \"62003629107726929116302469001779155132709624140360743951550189738290955064278\"\n ; \"109311858027068383034683875948676795998030610067675200794951297783857157095297\"\n ; \"2085588517087605436136379278738013214233743532079287631079316773925068862732\"\n |]\n ; [| \"9513664655545306376987968929852776467090105742275395185801917554996684570014\"\n ; \"91103467624252027317764670613760419385374004736848754250298970998535616755199\"\n ; \"39500000352127197728032684892425352332461947514533659433380855624868454474623\"\n |]\n ; [| \"75175260486328125629270378861920310368403601365269629778076078053196928460032\"\n ; \"56923881233337629517433981230592855430598464522180216309153828833928801967999\"\n ; \"20981004218820236011689230170078809973840534961691702543937445515733151438851\"\n |]\n ; [| \"73175203586574092105626230272409823792532423094740797516874387144340145138310\"\n ; \"45186992623753580336479418079070607289916086076906975839720879934817804495460\"\n ; \"96084125187548549854900995260973117424750860440064269432639526863495781270780\"\n |]\n ; [| \"53530507055579550362119832302266967544350117012822630711681736383163390079758\"\n ; \"24484677147631687826970700541691541659768738376645174313438582486313045584324\"\n ; \"99915577684197600584703320523786830947563355229812244982453188909016758004559\"\n |]\n ; [| \"73101441225016284181831039876112223954723401962484828024235461623078642642543\"\n ; \"57434882751817972247799186935032874577110609253567900895922769490031350316077\"\n ; \"73837027842771758252813592393497967898989365991569964687267097531033696791279\"\n |]\n ; [| \"8605586894544301092657394167906502995894014247978769840701086209902531650480\"\n ; \"8900145888985471928279988821934068156350024482295663273746853580585203659117\"\n ; \"76135096553134713603675854628257365311062159747768423095496501607463292188538\"\n |]\n ; [| \"77171330825793179961995032914169307990870372845116475229799680315757656196917\"\n ; \"17848856881287888035559207919717746181941756011012420474955535369227552058196\"\n ; \"85285874363861776466393873037603415962379724376693393356387850868454172343232\"\n |]\n ; [| \"34752820629818556525384193423224856177797869338806846583786365186093662702640\"\n ; \"61923000676912108769617866333091286856690233713839015114991682235541391477568\"\n ; \"105437294734850952102877811210027981435959945375626993201685688489494148805743\"\n |]\n ; [| \"37290995592003925978648162243724313056459187397796644444696543576625771108605\"\n ; \"95156804644588215637074780475000089186488581067063625121782605228712011438608\"\n ; \"111838568780358037910894878973007194619694503969424695895292495245099084158661\"\n |]\n ; [| \"114085830904535970531084512281741806703564152148485737755668141105183488387818\"\n ; \"27151558900245092306095370161852910074651784795680581223133179808714387525774\"\n ; \"17782273009863750298483603933610732253879825505411230932533407287574651036994\"\n |]\n ; [| \"72422039981423868898452547270453235353957783762070405836433674391957844064693\"\n ; \"23635533014670380888810554717349513178608213369182061967678315431422272271569\"\n ; \"59402711345784829746976504521969665104448536964686633342173372133388407225657\"\n |]\n ; [| \"92466806354851856571355165199186633833982438153589406912422876269386887264049\"\n ; \"9877617390649361889067963484857474874019563445507538784053773745685676317984\"\n ; \"74572672075215609948567780829046067891251792522874268554421916351892498078660\"\n |]\n ; [| \"36552683919656073147232029802086505741533932059491323529262718897271096098319\"\n ; \"28895802628889660292449057575076739706255701997961890168977786141673053679086\"\n ; \"9907785227545441866241924986174555965766785257012652276622736289520175209842\"\n |]\n ; [| \"29485332368911768475893015509537099136952860812699472744021496513325455451738\"\n ; \"39797358509842904932758894391536601623578260107859540160156599261695054175926\"\n ; \"107452259847197252302434271220963395311929879689430847107159618578878468880668\"\n |]\n ; [| \"24664696127391052816688570667643612077905959307658722811431436096677076924072\"\n ; \"52507998665481228083044018390203046881916651866666590845312076558622705190465\"\n ; \"69935204723497468327083545368078327534124772251842862926136799697299751835029\"\n |]\n ; [| \"372963191403207230700085823960930798511810380777302780932220121859190714585\"\n ; \"111366606704792806959979488772421759791592911629496627207620326636856656861526\"\n ; \"39677360977437767398760288273614298000827429534821360419179023551087917983124\"\n |]\n ; [| \"64601494076430280535646633059501605929914790764963584476403188233843589027560\"\n ; \"34156315098453482946438495274327282067376463494057110043754782161473776373661\"\n ; \"73687667961196401152630755105477060056162632832680813161120412165243753726816\"\n |]\n ; [| \"37808689229279738382348785246837013002280781984053433359148018860351753688153\"\n ; \"26778210635417272626362658500217995247072424006327715268521424423461840656985\"\n ; \"13012115310019421859484865413402512912208022868124085927375736053832542569552\"\n |]\n ; [| \"33073055720188060063004545324174039863351833928493376423022587630016341635891\"\n ; \"76584254259783109527449313057522305759653397147785066495263227868665161219779\"\n ; \"38531270223194009551634352795926218399266465064491096474482575354468954922673\"\n |]\n ; [| \"90100362566645034035707547984589905559141359276359522681964816611161474672115\"\n ; \"93014643079204629081291124987233004565276697190519877698472422015954982964601\"\n ; \"110916697765188052223435628742886773389228694903593626715469113528434066764534\"\n |]\n ; [| \"114725280711584666069398481856753837363052938587178775403749719257369626174299\"\n ; \"32967950615819700839673854548770413755655613096921050182183649674389310060672\"\n ; \"106372438106855157117155417458821032302424106544646447353561892891697429919509\"\n |]\n ; [| \"41996555998804572671679174634435850382099449308465335760130383677478780889948\"\n ; \"105999190358126224751922865919841547624707481487885223948004296548330504340556\"\n ; \"16636528128134911466622907961467317982179835733058354229921170933476186200761\"\n |]\n ; [| \"43468498537738045222256870515315985487110433728199201952445121047095648527840\"\n ; \"102272887089258604970815589009009162752025146641624347901234381428987386153285\"\n ; \"797386830910520008361185815477523544664694040635544500916993469578452189812\"\n |]\n ; [| \"96744926314199156321023598425708516126928808801578082649702497034531770517808\"\n ; \"99066250188188051206024031106640566584616407903813704153928240609169764005797\"\n ; \"101012485188852469291356197079506861083321680470016268483997462932491691773708\"\n |]\n ; [| \"49614555470963378761214277525336169174318331863453657910575217035316990252780\"\n ; \"94532874466332578813348267802784511494491757628599627802933242637211676358456\"\n ; \"60376163781951477822973950330025689966951914888122503797194554488987660570913\"\n |]\n ; [| \"99934768696780030317676638063039209891456597783633841250810260768328701786300\"\n ; \"71861378641802240356627336242725340978135703736568776865558429280585792121426\"\n ; \"84446994028646761779912629176051455275041688583492300440129402381138226185369\"\n |]\n ; [| \"18317002472599225949038448120242542829985613745531554876060436499109578301758\"\n ; \"23001721954642810524358122249469196372443463625490878969385130364780514025259\"\n ; \"49037245410934285111914043557449391103989331168177809387278571893536129709378\"\n |]\n ; [| \"65792050828386571136875573680568197513273253001530588336285451691348906024460\"\n ; \"12956514709922286639520985225111137950302442378466870763868693820049405409474\"\n ; \"38025781500219940187723501911749158551479941535921061459281014661810772473038\"\n |]\n ; [| \"98610017124283789125637190759729078315864881693957982200427567103302362453196\"\n ; \"42724178943656779288650125468921272883324869492775989038952508393082565227450\"\n ; \"99514360136104778310983460863480701661882652836741972684579325226086664343913\"\n |]\n ; [| \"111234788248236327826382691076985300771418365594838017963216100441270435887017\"\n ; \"35290532009451633157074005614742321966918220860237810056920944192222599040501\"\n ; \"72172784027306769601458922728374293130025170844011739475076742090414769211169\"\n |]\n ; [| \"61384388429666858375759167984149961873566898632022783479711533101905095026411\"\n ; \"8194273390415023152581060020119881338779571723515253104919314696738194355344\"\n ; \"80659234466772556847544129237154202226081525079070598707001193889658539631883\"\n |]\n ; [| \"62157670692624367146830864246105810519941474190553952682719433471854134465138\"\n ; \"74851302400382275482762496406028988868219592716510355166137061257664688666219\"\n ; \"16881796086836744646703159464114164393240695449455598565494759189917589453976\"\n |]\n ; [| \"42460477269659081546432152357644086326197211166562674408623141905226706277595\"\n ; \"81063688725529281621596607500748519671655516257039992655745871437369181665242\"\n ; \"51403113216244137057466948399908740878535656059933892843818689317660325080213\"\n |]\n ; [| \"49001998791770520786679099472805193463531142479298200795569326894791589887035\"\n ; \"42684462014557597494725933597359625461226399711783671410492942446635214257509\"\n ; \"106420886277092880545929306533089566775810130555230702838917980421765786292693\"\n |]\n ; [| \"110523958037212353696746219917157237679515245560578307171595792811566554384451\"\n ; \"56399709802930804752950401483879725014794413557467977624037632281590440364765\"\n ; \"100108862073771478435824578087801736413858177140360408436521717282600830155374\"\n |]\n ; [| \"59041409790855290045250456089216312297230856546920761548978870779493926213674\"\n ; \"13735945315945382005247895569035266667172550063549145646185577935658666385507\"\n ; \"16846296242516834547231537358954027537902709068158411294345086281698311539718\"\n |]\n ; [| \"114970774262524353875592617323889610576992844847433725376114488262076142213525\"\n ; \"17896661983150937411004047429485556264820315976705642986609974816436222162633\"\n ; \"115573362005053049429141251153085446935774781295666612354309246218946442750706\"\n |]\n ; [| \"85575265064375003235737272215445285540001719469558026661845214249857169530994\"\n ; \"87501751332871186792668480006319719164949448258731670359536302677279100637346\"\n ; \"105775909055063540416087237151517389942637625317333843436738223226977225420379\"\n |]\n ; [| \"110886009455283422981396854898481256559291311408679418842391298005253375700608\"\n ; \"95342257228100720685556647789433478371609336135456255803583405713563597933074\"\n ; \"2733591517253510124338232417535938539627593736745105875672348998709544742241\"\n |]\n ; [| \"32685479117496505057951010536248024091461630564950845696581129158987138920098\"\n ; \"96139836598015371513111133071481139035733083963976340622322043979088723982681\"\n ; \"16990606351055720221300633612533434675038905235719867684891402550154692840579\"\n |]\n ; [| \"13886834869596827027283068322204563244577723967928602405785473534631482228259\"\n ; \"81034769645830807786559566591578132114590768431721148809270219480247445931316\"\n ; \"26780635035984131258327079447673207266040002451512601352288859614294714150612\"\n |]\n ; [| \"72820784976920576285217524394309841044157743334874310886804718206719618858662\"\n ; \"84276722913141806246805569560426345961854221390421557310593118606084442633714\"\n ; \"42573817497593319926701003355299929070203785007821783512454795971915573843634\"\n |]\n ; [| \"41660041627266397279909712983288860313881442148611073178272756605107913521726\"\n ; \"7198246770791404776745997973411401046335399072925979346193035999274650139809\"\n ; \"91576025129588718283317000330880100309465430116820675850311277329602716166005\"\n |]\n ; [| \"30488483928716649313242898509172476460161184318124511942476380904233730958564\"\n ; \"35346040517569327255933130090945133067049088493975862969006023114275649329148\"\n ; \"59803015801166721680239913449555176591725421041660016242103441987856441941533\"\n |]\n ; [| \"17395049232451382970906883167116397657891664802601579276725674512534883408665\"\n ; \"96892830538146451450007413348096295684782382701592949711753407054447667361829\"\n ; \"46725583995795907014628330473921842919957418641665482351238505922983315675600\"\n |]\n ; [| \"20556719902345568138970735755829852608784985449829745172855204153387982836579\"\n ; \"17130405757403641097651484965062131526367059595476924144885570325828777794585\"\n ; \"99651763337265056372826178960800950053231370129318394703153246147873057668256\"\n |]\n ; [| \"17814517977679061356584950826520510701145481336316888282105225134451035883368\"\n ; \"62116749577126511600138536864540326578096290025961229483071769130930103978622\"\n ; \"68057799973217998063838402481530957249181669394905338807621317159743376777292\"\n |]\n ; [| \"26100793478962260035181580648528031417033872324944615961986573818448125345450\"\n ; \"26507891451149179196332605230084404371370204632884553105363087566061809624465\"\n ; \"55607174697006979796477169324630939518573410736589826596210132996613779221405\"\n |]\n ; [| \"75098549092668095590746032937529532494350222003700838962461867948806312867882\"\n ; \"62901674712278062473767645982006145910793625009149846534629441949336033280610\"\n ; \"5918385816682866756860679567405784562483373873565987668410277610868983146285\"\n |]\n ; [| \"99232460916208710346946062875203578399818909925477280432427620267031292402265\"\n ; \"115165948144292852122635634954139515297086369356811820254801384608988902457684\"\n ; \"39462036389170488019054739441325823641943062254145671230029238830857274014332\"\n |]\n ; [| \"109723826013507458840008311671051963282645213933956581735587227292458581212170\"\n ; \"88295699560808238817850908733435797366622278897489038929647807463406234520052\"\n ; \"20306380368695786945008272690438693745796297843799468268993907772341096948885\"\n |]\n ; [| \"39988356032524455736714109463355738665746339590560108227920970859248126609155\"\n ; \"47372836588594871116561451142702593094337405740661755511614125456886719840333\"\n ; \"42727075822142544969304941778878121065758237932060280070908539158139079888683\"\n |]\n ; [| \"115695172202592006925180721060969710051274632819849770440984261650964182295350\"\n ; \"41198034356969673080518030958715740186484860381424802035929938277103521577731\"\n ; \"115380378505550001583545282887589851179279565072664241489053445702744491234750\"\n |]\n ; [| \"56074680442485705900559544809779144521596408129059458559681779642734476672579\"\n ; \"54187206076706271120400668422875039791522899135281309004702779376007885441827\"\n ; \"100760509008368123701304764217450368711018785408289674422092070202193042774995\"\n |]\n ; [| \"2622643323130765702269424224791233611920515499144047449633123689743564676648\"\n ; \"95487289650450707799373930173349121410704227885014701702619711048222666102791\"\n ; \"94943953462630479470879050547964792684799160133612590505176816568790562776928\"\n |]\n |]\n }\n\nlet params_Bn382_p =\n { Params.mds =\n [| [| \"4926718831512540855203478495979679874185641835428705237807701341316303469093728860979847281433445543762468419547411\"\n ; \"4453596550915421838691584449484083455887331059810907256950733279540412430443020452528503585415545381600691692720802\"\n ; \"1809585458879543727351605930307281128231661313471183867681242998028598391382436278589655704222701087043779610899776\"\n |]\n ; [| \"3780881913608981191949291171826187563049531728010823449829977324390598960444713739971716972221840264885560113043153\"\n ; \"2776232227357305515637478180339794495756715372405744816056109665788926102619439001152349187314657683550310562099867\"\n ; \"5103043266714397927073209822516498302262227174566336138856687248083295588845596823903140201767618523431001452833199\"\n |]\n ; [| \"2159355678817062797712812554732125404698639502388517586006300841333631216487588790808135492514630783259920881851018\"\n ; \"3193464442349738376799117666463048091278737759406985595335727474699041234966227606028409475413066859111860974240541\"\n ; \"3068849848776138129466484826306219095394321880438971409892892215677003762666783452446184790715435684915272918256552\"\n |]\n |]\n ; round_constants =\n [| [| \"78119860594733808983474265082430117124674905785489385612351809573030163625517\"\n ; \"41917899842730241418346215913324270532073353586134123463219061327941260175271\"\n ; \"74594641694171623328644944059182600919855574964222988275913344198970402906473\"\n |]\n ; [| \"96215759378377024990520153908983544755208851791126218239402755616994541522004\"\n ; \"64070601581278917442704840630680311036021557676765751754522901046069205253111\"\n ; \"112123228532462696722378911494343451272980413618911326680094528285518792872677\"\n |]\n ; [| \"84572244072021308337360477634782636535511175281144388234379224309078196768262\"\n ; \"45201095631123410354816854701250642083197167601967427301389500806815426216645\"\n ; \"23419302413627434057960523568681421397183896397903197013759822219271473949448\"\n |]\n ; [| \"63220724218126871510891512179599337793645245415246618202146262033908228783613\"\n ; \"67900966560828272306360950341997532094196196655192755442359232962244590070115\"\n ; \"56382132371728071364028077587343004835658613510701494793375685201885283260755\"\n |]\n ; [| \"80317852656339951095312898663286716255545986714650554749917139819628941702909\"\n ; \"110977183257428423540294096816813859894739618561444416996538397449475628658639\"\n ; \"25195781166503180938390820610484311038421647727795615447439501669639084690800\"\n |]\n ; [| \"108664438541952156416331885221418851366456449596370568350972106298760717710264\"\n ; \"17649294376560630922417546944777537620537408190408066211453084495108565929366\"\n ; \"95236435002924956844837407534938226368352771792739587594037613075251645052212\"\n |]\n ; [| \"43150472723422600689013423057826322506171125106415122422656432973040257528684\"\n ; \"77355911134402286174761911573353899889837132781450260391484427670446862700214\"\n ; \"8690728446593494554377477996892461126663797704587025899930929227865493269824\"\n |]\n ; [| \"109175231986025180460846040078523879514558355792739714578031829643740609438879\"\n ; \"64844253590731404811389281562033735091759746904073461140427127388042062490899\"\n ; \"43237071281695629980341250188156848876595681601471702180515324064382368960951\"\n |]\n ; [| \"2704440995725305992776846806711930876273040749514871232837487081811513368296\"\n ; \"66806779110388532101035294912010606217442229808784290357894909707660045365269\"\n ; \"25541187612624070470730890200174075890643652797181103367956318438136878170352\"\n |]\n ; [| \"89300613074831725721350087269266903129165086877175223066581882601662278010666\"\n ; \"36824076981866281177052433916337787028520068526782493484076995129329938182524\"\n ; \"68880449342008497744225106025198236600142055580985632884415488154606462819445\"\n |]\n ; [| \"68556888546596545408135887526582256648006271867854316538090068824142539400698\"\n ; \"111379753250206255125320675615931203940253796355491142745969887430259465111569\"\n ; \"101469186248899356416491489235841069222521093012237305521090058066171355672289\"\n |]\n ; [| \"87819793263125973233157093200229218382531712066157093399606059493857616731410\"\n ; \"11055386921184594780372263378420826851562920740321950336882051897732501262543\"\n ; \"111945832089295501567161822264292548657346358707472584179854375613919325491249\"\n |]\n ; [| \"95630018375719472826904441325138673248990446382783206900295723762884876505178\"\n ; \"94833984285990985873155989049880754188702918168949640563745233736765833491756\"\n ; \"77578854197021606645372788474039811639438242484066959482386065023999206730771\"\n |]\n ; [| \"27799616729223271646690718201487403976485619375555391888533887467404804041014\"\n ; \"42616502170265664498961018686434252976977548128285781725227341660941880774718\"\n ; \"95884094505080541517768389956970969462501217028562326732054532092615835087122\"\n |]\n ; [| \"107531500891040898338150732759493933154418374543568088749403053559827078391994\"\n ; \"17316158269457914256007584527534747738658973027567786054549020564540952112346\"\n ; \"51624680144452294805663893795879183520785046924484587034566439599591446246116\"\n |]\n ; [| \"17698087730709566968258013675219881840614043344609152682517330801348583470562\"\n ; \"111925747861248746962567200879629070277886617811519137515553806421564944666811\"\n ; \"57148554624730554436721083599187229462914514696466218614205595953570212881615\"\n |]\n ; [| \"92002976914130835490768248031171915767210477082066266868807636677032557847243\"\n ; \"58807951133460826577955909810426403194149348045831674376120801431489918282349\"\n ; \"93581873597000319446791963913210464830992618681307774190204379970955657554666\"\n |]\n ; [| \"46734218328816451470118898692627799522173317355773128175090189234250221977353\"\n ; \"12565476532112137808460978474958060441970941349010371267577877299656634907765\"\n ; \"54284813390357004119220859882274190703294683700710665367594256039714984623777\"\n |]\n ; [| \"92046423253202913319296401122133532555630886766139313429473309376931112550800\"\n ; \"15095408309586969968044201398966210357547906905122453139947200130015688526573\"\n ; \"76483858663950700865536712701042004661599554591777656961315837882956812689085\"\n |]\n ; [| \"37793510665854947576525000802927849210746292216845467892500370179796223909690\"\n ; \"84954934523349224038508216623641462700694917568481430996824733443763638196693\"\n ; \"81116649005575743294029244339854405387811058321603450814032274416116019472096\"\n |]\n ; [| \"28313841745366368076212445154871968929195537523489133192784916081223753077949\"\n ; \"17307716513182567320564075539526480893558355908652993731441220999922946005081\"\n ; \"63148771170858502457695904149048034226689843239981287723002468627916462842625\"\n |]\n ; [| \"14724939606645168531546334343600232253284320276481307778787768813885931648950\"\n ; \"4684996260500305121238590806572541849891754312215139285622888510153705963000\"\n ; \"63682763879011752475568476861367553456179860221069473817315669232908763409259\"\n |]\n ; [| \"47776179656187399887062096850541192680190218704758942820514561435612697426715\"\n ; \"42017618175533328439486588850450028995049195954365035474995309904751824054581\"\n ; \"39169739448648613641258102792190571431737464735838931948313779997907435855102\"\n |]\n ; [| \"37525991163523321662699819448962967746703579202577998445997476955224037837979\"\n ; \"67759173441312327668891803222741396828094999063019622301649400178376863820046\"\n ; \"23041132473771739182071223620364590606653086905326129708428084432335332411661\"\n |]\n ; [| \"77778894465896892167598828497939467663479992533052348475467490972714790615441\"\n ; \"20821227542001445006023346122554483849065713580779858784021328359824080462519\"\n ; \"47217242463811495777303984778653549585537750303740616187093690846833142245039\"\n |]\n ; [| \"42826871300142174590405062658305130206548405024021455479047593769907201224399\"\n ; \"8850081254230234130482383430433176873344633494243110112848647064077741649744\"\n ; \"1819639941546179668398979507053724449231350395599747300736218202072168364980\"\n |]\n ; [| \"21219092773772827667886204262476112905428217689703647484316763603169544906986\"\n ; \"35036730416829620763976972888493029852952403098232484869595671405553221294746\"\n ; \"35487050610902505183766069070898136230610758743267437784506875078109148276407\"\n |]\n ; [| \"62560813042054697786535634928462520639989597995560367915904328183428481834648\"\n ; \"112205708104999693686115882430330200785082630634036862526175634736046083007596\"\n ; \"109084747126382177842005646092084591250172358815974554434100716599544229364287\"\n |]\n ; [| \"63740884245554590221521941789197287379354311786803164550686696984009448418872\"\n ; \"58779928727649398559174292364061339806256990859940639552881479945324304668069\"\n ; \"20614241966717622390914334053622572167995367802051836931454426877074875942253\"\n |]\n ; [| \"41621411615229558798583846330993607380846912281220890296433013153854774573504\"\n ; \"20530621481603446397085836296967350209890164029268319619481535419199429275412\"\n ; \"99914592017824500091708233310179001698739309503141229228952777264267035511439\"\n |]\n ; [| \"9497854724940806346676139162466690071592872530638144182764466319052293463165\"\n ; \"7549205476288061047040852944548942878112823732145584918107208536541712726277\"\n ; \"30898915730863004722886730649661235919513859500318540107289237568593577554645\"\n |]\n ; [| \"22697249754607337581727259086359907309326296469394183645633378468855554942575\"\n ; \"72771100592475003378969523202338527077495914171905204927442739996373603143216\"\n ; \"84509851995167666169868678185342549983568150803791023831909660012392522615426\"\n |]\n ; [| \"36601166816771446688370845080961015541431660429079281633209182736773260407536\"\n ; \"19555759172327736128240171000715903945570888389700763573790859521156095228287\"\n ; \"82844424532983875300577689116331373756526403900340445449185486212503235782229\"\n |]\n ; [| \"40833119728631657038301474658571416779079199343770917422783737091842927892625\"\n ; \"68922359316478675184342553333343300163568193749010867527082189412217781430311\"\n ; \"91516472400306837063911995909475588197278444979245081960087094196120449075833\"\n |]\n ; [| \"21304716730402869084944080869903443431235336418077153507261240151959530377653\"\n ; \"106551237424345741137570659736231801772439680702621554106791455938098031620471\"\n ; \"104392597313271110590927764888829150750277653499050463757708547416538850601163\"\n |]\n ; [| \"16907937154215020261110468963982390213438461071031811101554056252102505124726\"\n ; \"23183141532591565112222057191012766855134687114504142337903677590107533245206\"\n ; \"96725517880771645283128624101279195709280644465575982072053504613644938879246\"\n |]\n ; [| \"84556507395241990875812091718422997082915179448604219593521819129312718969906\"\n ; \"100646525819453650494590571397259055384579251368754179569362740802641255820576\"\n ; \"50316555026297423940834952362583934362215303629664094841692233643882339493043\"\n |]\n ; [| \"77363534410783423412630139556441807611393685349073113946053979350631229049878\"\n ; \"54905073434434959485893381841839373267383966385817882684657825178181863944371\"\n ; \"110016011331508430102821620395154714608084938556260733745010992614542669817451\"\n |]\n ; [| \"52040139270046094723964229965823921970388683619580004402190656733318120479093\"\n ; \"495546618036723566920914648951352373868059898268055487677897567226892784967\"\n ; \"2528292188392170914010448139211586215817069915670005292953294092269979070980\"\n |]\n ; [| \"36842840134449713950999812540127591123318806680559982063089906871196226758113\"\n ; \"112314504940338253416202605695368724580971154020421327790335219348068041886245\"\n ; \"51653712314537383078368021242008468828072907802445786549975419682333073143987\"\n |]\n ; [| \"27179054135131403873076215577181710354069071017096145081169516607932870071868\"\n ; \"93264325401956094073193527739715293258814405715822269809955952297346626219055\"\n ; \"75336695567377817226085396912086909560962335091652231383627608374094112503635\"\n |]\n ; [| \"42536477740858058164730818130587261149155820207748153094480456895727052896150\"\n ; \"45297707210835305388426482743535401273114010430724989418303851665124351001731\"\n ; \"28263543670875633354854018109712021307749750769690268127459707194207091046997\"\n |]\n ; [| \"40809484989590048522440442751358616303471639779690405026946053699354967624695\"\n ; \"51589519265418587649124543325590658874910911006853535317847189422703251228717\"\n ; \"73459936981642894525955700397592343967482441686326322443228255968694436816673\"\n |]\n ; [| \"87298777232393189731949522229743081866971743270330772607820990832164835738703\"\n ; \"23328534428894097247289332213412175849711532153957647506361455182140450133738\"\n ; \"51807348624578081645565456865744011145427112815128832643950401419083788780028\"\n |]\n ; [| \"62003629107726929116302469001779155132709624140360743951550189738290955064278\"\n ; \"109311858027068383034683875948676795998030610067675200794951297783857157095297\"\n ; \"2085588517087605436136379278738013214233743532079287631079316773925068862732\"\n |]\n ; [| \"9513664655545306376987968929852776467090105742275395185801917554996684570014\"\n ; \"91103467624252027317764670613760419385374004736848754250298970998535616755199\"\n ; \"39500000352127197728032684892425352332461947514533659433380855624868454474623\"\n |]\n ; [| \"75175260486328125629270378861920310368403601365269629778076078053196928460032\"\n ; \"56923881233337629517433981230592855430598464522180216309153828833928801967999\"\n ; \"20981004218820236011689230170078809973840534961691702543937445515733151438851\"\n |]\n ; [| \"73175203586574092105626230272409823792532423094740797516874387144340145138310\"\n ; \"45186992623753580336479418079070607289916086076906975839720879934817804495460\"\n ; \"96084125187548549854900995260973117424750860440064269432639526863495781270780\"\n |]\n ; [| \"53530507055579550362119832302266967544350117012822630711681736383163390079758\"\n ; \"24484677147631687826970700541691541659768738376645174313438582486313045584324\"\n ; \"99915577684197600584703320523786830947563355229812244982453188909016758004559\"\n |]\n ; [| \"73101441225016284181831039876112223954723401962484828024235461623078642642543\"\n ; \"57434882751817972247799186935032874577110609253567900895922769490031350316077\"\n ; \"73837027842771758252813592393497967898989365991569964687267097531033696791279\"\n |]\n ; [| \"8605586894544301092657394167906502995894014247978769840701086209902531650480\"\n ; \"8900145888985471928279988821934068156350024482295663273746853580585203659117\"\n ; \"76135096553134713603675854628257365311062159747768423095496501607463292188538\"\n |]\n ; [| \"77171330825793179961995032914169307990870372845116475229799680315757656196917\"\n ; \"17848856881287888035559207919717746181941756011012420474955535369227552058196\"\n ; \"85285874363861776466393873037603415962379724376693393356387850868454172343232\"\n |]\n ; [| \"34752820629818556525384193423224856177797869338806846583786365186093662702640\"\n ; \"61923000676912108769617866333091286856690233713839015114991682235541391477568\"\n ; \"105437294734850952102877811210027981435959945375626993201685688489494148805743\"\n |]\n ; [| \"37290995592003925978648162243724313056459187397796644444696543576625771108605\"\n ; \"95156804644588215637074780475000089186488581067063625121782605228712011438608\"\n ; \"111838568780358037910894878973007194619694503969424695895292495245099084158661\"\n |]\n ; [| \"114085830904535970531084512281741806703564152148485737755668141105183488387818\"\n ; \"27151558900245092306095370161852910074651784795680581223133179808714387525774\"\n ; \"17782273009863750298483603933610732253879825505411230932533407287574651036994\"\n |]\n ; [| \"72422039981423868898452547270453235353957783762070405836433674391957844064693\"\n ; \"23635533014670380888810554717349513178608213369182061967678315431422272271569\"\n ; \"59402711345784829746976504521969665104448536964686633342173372133388407225657\"\n |]\n ; [| \"92466806354851856571355165199186633833982438153589406912422876269386887264049\"\n ; \"9877617390649361889067963484857474874019563445507538784053773745685676317984\"\n ; \"74572672075215609948567780829046067891251792522874268554421916351892498078660\"\n |]\n ; [| \"36552683919656073147232029802086505741533932059491323529262718897271096098319\"\n ; \"28895802628889660292449057575076739706255701997961890168977786141673053679086\"\n ; \"9907785227545441866241924986174555965766785257012652276622736289520175209842\"\n |]\n ; [| \"29485332368911768475893015509537099136952860812699472744021496513325455451738\"\n ; \"39797358509842904932758894391536601623578260107859540160156599261695054175926\"\n ; \"107452259847197252302434271220963395311929879689430847107159618578878468880668\"\n |]\n ; [| \"24664696127391052816688570667643612077905959307658722811431436096677076924072\"\n ; \"52507998665481228083044018390203046881916651866666590845312076558622705190465\"\n ; \"69935204723497468327083545368078327534124772251842862926136799697299751835029\"\n |]\n ; [| \"372963191403207230700085823960930798511810380777302780932220121859190714585\"\n ; \"111366606704792806959979488772421759791592911629496627207620326636856656861526\"\n ; \"39677360977437767398760288273614298000827429534821360419179023551087917983124\"\n |]\n ; [| \"64601494076430280535646633059501605929914790764963584476403188233843589027560\"\n ; \"34156315098453482946438495274327282067376463494057110043754782161473776373661\"\n ; \"73687667961196401152630755105477060056162632832680813161120412165243753726816\"\n |]\n ; [| \"37808689229279738382348785246837013002280781984053433359148018860351753688153\"\n ; \"26778210635417272626362658500217995247072424006327715268521424423461840656985\"\n ; \"13012115310019421859484865413402512912208022868124085927375736053832542569552\"\n |]\n ; [| \"33073055720188060063004545324174039863351833928493376423022587630016341635891\"\n ; \"76584254259783109527449313057522305759653397147785066495263227868665161219779\"\n ; \"38531270223194009551634352795926218399266465064491096474482575354468954922673\"\n |]\n ; [| \"90100362566645034035707547984589905559141359276359522681964816611161474672115\"\n ; \"93014643079204629081291124987233004565276697190519877698472422015954982964601\"\n ; \"110916697765188052223435628742886773389228694903593626715469113528434066764534\"\n |]\n ; [| \"114725280711584666069398481856753837363052938587178775403749719257369626174299\"\n ; \"32967950615819700839673854548770413755655613096921050182183649674389310060672\"\n ; \"106372438106855157117155417458821032302424106544646447353561892891697429919509\"\n |]\n ; [| \"41996555998804572671679174634435850382099449308465335760130383677478780889948\"\n ; \"105999190358126224751922865919841547624707481487885223948004296548330504340556\"\n ; \"16636528128134911466622907961467317982179835733058354229921170933476186200761\"\n |]\n ; [| \"43468498537738045222256870515315985487110433728199201952445121047095648527840\"\n ; \"102272887089258604970815589009009162752025146641624347901234381428987386153285\"\n ; \"797386830910520008361185815477523544664694040635544500916993469578452189812\"\n |]\n ; [| \"96744926314199156321023598425708516126928808801578082649702497034531770517808\"\n ; \"99066250188188051206024031106640566584616407903813704153928240609169764005797\"\n ; \"101012485188852469291356197079506861083321680470016268483997462932491691773708\"\n |]\n ; [| \"49614555470963378761214277525336169174318331863453657910575217035316990252780\"\n ; \"94532874466332578813348267802784511494491757628599627802933242637211676358456\"\n ; \"60376163781951477822973950330025689966951914888122503797194554488987660570913\"\n |]\n ; [| \"99934768696780030317676638063039209891456597783633841250810260768328701786300\"\n ; \"71861378641802240356627336242725340978135703736568776865558429280585792121426\"\n ; \"84446994028646761779912629176051455275041688583492300440129402381138226185369\"\n |]\n ; [| \"18317002472599225949038448120242542829985613745531554876060436499109578301758\"\n ; \"23001721954642810524358122249469196372443463625490878969385130364780514025259\"\n ; \"49037245410934285111914043557449391103989331168177809387278571893536129709378\"\n |]\n ; [| \"65792050828386571136875573680568197513273253001530588336285451691348906024460\"\n ; \"12956514709922286639520985225111137950302442378466870763868693820049405409474\"\n ; \"38025781500219940187723501911749158551479941535921061459281014661810772473038\"\n |]\n ; [| \"98610017124283789125637190759729078315864881693957982200427567103302362453196\"\n ; \"42724178943656779288650125468921272883324869492775989038952508393082565227450\"\n ; \"99514360136104778310983460863480701661882652836741972684579325226086664343913\"\n |]\n ; [| \"111234788248236327826382691076985300771418365594838017963216100441270435887017\"\n ; \"35290532009451633157074005614742321966918220860237810056920944192222599040501\"\n ; \"72172784027306769601458922728374293130025170844011739475076742090414769211169\"\n |]\n ; [| \"61384388429666858375759167984149961873566898632022783479711533101905095026411\"\n ; \"8194273390415023152581060020119881338779571723515253104919314696738194355344\"\n ; \"80659234466772556847544129237154202226081525079070598707001193889658539631883\"\n |]\n ; [| \"62157670692624367146830864246105810519941474190553952682719433471854134465138\"\n ; \"74851302400382275482762496406028988868219592716510355166137061257664688666219\"\n ; \"16881796086836744646703159464114164393240695449455598565494759189917589453976\"\n |]\n ; [| \"42460477269659081546432152357644086326197211166562674408623141905226706277595\"\n ; \"81063688725529281621596607500748519671655516257039992655745871437369181665242\"\n ; \"51403113216244137057466948399908740878535656059933892843818689317660325080213\"\n |]\n ; [| \"49001998791770520786679099472805193463531142479298200795569326894791589887035\"\n ; \"42684462014557597494725933597359625461226399711783671410492942446635214257509\"\n ; \"106420886277092880545929306533089566775810130555230702838917980421765786292693\"\n |]\n ; [| \"110523958037212353696746219917157237679515245560578307171595792811566554384451\"\n ; \"56399709802930804752950401483879725014794413557467977624037632281590440364765\"\n ; \"100108862073771478435824578087801736413858177140360408436521717282600830155374\"\n |]\n ; [| \"59041409790855290045250456089216312297230856546920761548978870779493926213674\"\n ; \"13735945315945382005247895569035266667172550063549145646185577935658666385507\"\n ; \"16846296242516834547231537358954027537902709068158411294345086281698311539718\"\n |]\n ; [| \"114970774262524353875592617323889610576992844847433725376114488262076142213525\"\n ; \"17896661983150937411004047429485556264820315976705642986609974816436222162633\"\n ; \"115573362005053049429141251153085446935774781295666612354309246218946442750706\"\n |]\n ; [| \"85575265064375003235737272215445285540001719469558026661845214249857169530994\"\n ; \"87501751332871186792668480006319719164949448258731670359536302677279100637346\"\n ; \"105775909055063540416087237151517389942637625317333843436738223226977225420379\"\n |]\n ; [| \"110886009455283422981396854898481256559291311408679418842391298005253375700608\"\n ; \"95342257228100720685556647789433478371609336135456255803583405713563597933074\"\n ; \"2733591517253510124338232417535938539627593736745105875672348998709544742241\"\n |]\n ; [| \"32685479117496505057951010536248024091461630564950845696581129158987138920098\"\n ; \"96139836598015371513111133071481139035733083963976340622322043979088723982681\"\n ; \"16990606351055720221300633612533434675038905235719867684891402550154692840579\"\n |]\n ; [| \"13886834869596827027283068322204563244577723967928602405785473534631482228259\"\n ; \"81034769645830807786559566591578132114590768431721148809270219480247445931316\"\n ; \"26780635035984131258327079447673207266040002451512601352288859614294714150612\"\n |]\n ; [| \"72820784976920576285217524394309841044157743334874310886804718206719618858662\"\n ; \"84276722913141806246805569560426345961854221390421557310593118606084442633714\"\n ; \"42573817497593319926701003355299929070203785007821783512454795971915573843634\"\n |]\n ; [| \"41660041627266397279909712983288860313881442148611073178272756605107913521726\"\n ; \"7198246770791404776745997973411401046335399072925979346193035999274650139809\"\n ; \"91576025129588718283317000330880100309465430116820675850311277329602716166005\"\n |]\n ; [| \"30488483928716649313242898509172476460161184318124511942476380904233730958564\"\n ; \"35346040517569327255933130090945133067049088493975862969006023114275649329148\"\n ; \"59803015801166721680239913449555176591725421041660016242103441987856441941533\"\n |]\n ; [| \"17395049232451382970906883167116397657891664802601579276725674512534883408665\"\n ; \"96892830538146451450007413348096295684782382701592949711753407054447667361829\"\n ; \"46725583995795907014628330473921842919957418641665482351238505922983315675600\"\n |]\n ; [| \"20556719902345568138970735755829852608784985449829745172855204153387982836579\"\n ; \"17130405757403641097651484965062131526367059595476924144885570325828777794585\"\n ; \"99651763337265056372826178960800950053231370129318394703153246147873057668256\"\n |]\n ; [| \"17814517977679061356584950826520510701145481336316888282105225134451035883368\"\n ; \"62116749577126511600138536864540326578096290025961229483071769130930103978622\"\n ; \"68057799973217998063838402481530957249181669394905338807621317159743376777292\"\n |]\n ; [| \"26100793478962260035181580648528031417033872324944615961986573818448125345450\"\n ; \"26507891451149179196332605230084404371370204632884553105363087566061809624465\"\n ; \"55607174697006979796477169324630939518573410736589826596210132996613779221405\"\n |]\n ; [| \"75098549092668095590746032937529532494350222003700838962461867948806312867882\"\n ; \"62901674712278062473767645982006145910793625009149846534629441949336033280610\"\n ; \"5918385816682866756860679567405784562483373873565987668410277610868983146285\"\n |]\n ; [| \"99232460916208710346946062875203578399818909925477280432427620267031292402265\"\n ; \"115165948144292852122635634954139515297086369356811820254801384608988902457684\"\n ; \"39462036389170488019054739441325823641943062254145671230029238830857274014332\"\n |]\n ; [| \"109723826013507458840008311671051963282645213933956581735587227292458581212170\"\n ; \"88295699560808238817850908733435797366622278897489038929647807463406234520052\"\n ; \"20306380368695786945008272690438693745796297843799468268993907772341096948885\"\n |]\n ; [| \"39988356032524455736714109463355738665746339590560108227920970859248126609155\"\n ; \"47372836588594871116561451142702593094337405740661755511614125456886719840333\"\n ; \"42727075822142544969304941778878121065758237932060280070908539158139079888683\"\n |]\n ; [| \"115695172202592006925180721060969710051274632819849770440984261650964182295350\"\n ; \"41198034356969673080518030958715740186484860381424802035929938277103521577731\"\n ; \"115380378505550001583545282887589851179279565072664241489053445702744491234750\"\n |]\n ; [| \"56074680442485705900559544809779144521596408129059458559681779642734476672579\"\n ; \"54187206076706271120400668422875039791522899135281309004702779376007885441827\"\n ; \"100760509008368123701304764217450368711018785408289674422092070202193042774995\"\n |]\n ; [| \"2622643323130765702269424224791233611920515499144047449633123689743564676648\"\n ; \"95487289650450707799373930173349121410704227885014701702619711048222666102791\"\n ; \"94943953462630479470879050547964792684799160133612590505176816568790562776928\"\n |]\n |]\n }\n\nlet params_Bn382_q =\n { Params.mds =\n [| [| \"2663538809597650435844500745640128112500797729229320076136089551791530014683740176469459837095745057420024990698304\"\n ; \"3372673220977743741609068262704292488957271565700673274891426149291073445433316668667874458522247135736401556339737\"\n ; \"4702399048364054789745695060954166226249916683594965873315202085308155435886379283955080194729213218481069112754347\"\n |]\n ; [| \"2215778453553447259216822687321394545528815439827126692759606056122905656424424554076355712016973336681821219494537\"\n ; \"1284753801167450198664971157009572170099813485759371112881157467066929464161583508786486164543283350228782139803094\"\n ; \"1136441139974396511543268992916724168911879411721635269198331720240499757381302440272659128030869203409955304203115\"\n |]\n ; [| \"5295202322853619951220986804473857321275810243906349721146315070442772012272591642930885737122084843222525444659152\"\n ; \"2585574180998322214773500417577043354533137309395421285678021891228333612974808568921533701659765694493897008321886\"\n ; \"4327637570022845964174929847928171567054668769686956705326721990617716210727017530524703225454617877992054172811917\"\n |]\n |]\n ; round_constants =\n [| [| \"78119860594733808983474265082430117124674905785489385612351809573030163625517\"\n ; \"41917899842730241418346215913324270532073353586134123463219061327941260175271\"\n ; \"74594641694171623328644944059182600919855574964222988275913344198970402906473\"\n |]\n ; [| \"96215759378377024990520153908983544755208851791126218239402755616994541522004\"\n ; \"64070601581278917442704840630680311036021557676765751754522901046069205253111\"\n ; \"112123228532462696722378911494343451272980413618911326680094528285518792872677\"\n |]\n ; [| \"84572244072021308337360477634782636535511175281144388234379224309078196768262\"\n ; \"45201095631123410354816854701250642083197167601967427301389500806815426216645\"\n ; \"23419302413627434057960523568681421397183896397903197013759822219271473949448\"\n |]\n ; [| \"63220724218126871510891512179599337793645245415246618202146262033908228783613\"\n ; \"67900966560828272306360950341997532094196196655192755442359232962244590070115\"\n ; \"56382132371728071364028077587343004835658613510701494793375685201885283260755\"\n |]\n ; [| \"80317852656339951095312898663286716255545986714650554749917139819628941702909\"\n ; \"110977183257428423540294096816813859894739618561444416996538397449475628658639\"\n ; \"25195781166503180938390820610484311038421647727795615447439501669639084690800\"\n |]\n ; [| \"108664438541952156416331885221418851366456449596370568350972106298760717710264\"\n ; \"17649294376560630922417546944777537620537408190408066211453084495108565929366\"\n ; \"95236435002924956844837407534938226368352771792739587594037613075251645052212\"\n |]\n ; [| \"43150472723422600689013423057826322506171125106415122422656432973040257528684\"\n ; \"77355911134402286174761911573353899889837132781450260391484427670446862700214\"\n ; \"8690728446593494554377477996892461126663797704587025899930929227865493269824\"\n |]\n ; [| \"109175231986025180460846040078523879514558355792739714578031829643740609438879\"\n ; \"64844253590731404811389281562033735091759746904073461140427127388042062490899\"\n ; \"43237071281695629980341250188156848876595681601471702180515324064382368960951\"\n |]\n ; [| \"2704440995725305992776846806711930876273040749514871232837487081811513368296\"\n ; \"66806779110388532101035294912010606217442229808784290357894909707660045365269\"\n ; \"25541187612624070470730890200174075890643652797181103367956318438136878170352\"\n |]\n ; [| \"89300613074831725721350087269266903129165086877175223066581882601662278010666\"\n ; \"36824076981866281177052433916337787028520068526782493484076995129329938182524\"\n ; \"68880449342008497744225106025198236600142055580985632884415488154606462819445\"\n |]\n ; [| \"68556888546596545408135887526582256648006271867854316538090068824142539400698\"\n ; \"111379753250206255125320675615931203940253796355491142745969887430259465111569\"\n ; \"101469186248899356416491489235841069222521093012237305521090058066171355672289\"\n |]\n ; [| \"87819793263125973233157093200229218382531712066157093399606059493857616731410\"\n ; \"11055386921184594780372263378420826851562920740321950336882051897732501262543\"\n ; \"111945832089295501567161822264292548657346358707472584179854375613919325491249\"\n |]\n ; [| \"95630018375719472826904441325138673248990446382783206900295723762884876505178\"\n ; \"94833984285990985873155989049880754188702918168949640563745233736765833491756\"\n ; \"77578854197021606645372788474039811639438242484066959482386065023999206730771\"\n |]\n ; [| \"27799616729223271646690718201487403976485619375555391888533887467404804041014\"\n ; \"42616502170265664498961018686434252976977548128285781725227341660941880774718\"\n ; \"95884094505080541517768389956970969462501217028562326732054532092615835087122\"\n |]\n ; [| \"107531500891040898338150732759493933154418374543568088749403053559827078391994\"\n ; \"17316158269457914256007584527534747738658973027567786054549020564540952112346\"\n ; \"51624680144452294805663893795879183520785046924484587034566439599591446246116\"\n |]\n ; [| \"17698087730709566968258013675219881840614043344609152682517330801348583470562\"\n ; \"111925747861248746962567200879629070277886617811519137515553806421564944666811\"\n ; \"57148554624730554436721083599187229462914514696466218614205595953570212881615\"\n |]\n ; [| \"92002976914130835490768248031171915767210477082066266868807636677032557847243\"\n ; \"58807951133460826577955909810426403194149348045831674376120801431489918282349\"\n ; \"93581873597000319446791963913210464830992618681307774190204379970955657554666\"\n |]\n ; [| \"46734218328816451470118898692627799522173317355773128175090189234250221977353\"\n ; \"12565476532112137808460978474958060441970941349010371267577877299656634907765\"\n ; \"54284813390357004119220859882274190703294683700710665367594256039714984623777\"\n |]\n ; [| \"92046423253202913319296401122133532555630886766139313429473309376931112550800\"\n ; \"15095408309586969968044201398966210357547906905122453139947200130015688526573\"\n ; \"76483858663950700865536712701042004661599554591777656961315837882956812689085\"\n |]\n ; [| \"37793510665854947576525000802927849210746292216845467892500370179796223909690\"\n ; \"84954934523349224038508216623641462700694917568481430996824733443763638196693\"\n ; \"81116649005575743294029244339854405387811058321603450814032274416116019472096\"\n |]\n ; [| \"28313841745366368076212445154871968929195537523489133192784916081223753077949\"\n ; \"17307716513182567320564075539526480893558355908652993731441220999922946005081\"\n ; \"63148771170858502457695904149048034226689843239981287723002468627916462842625\"\n |]\n ; [| \"14724939606645168531546334343600232253284320276481307778787768813885931648950\"\n ; \"4684996260500305121238590806572541849891754312215139285622888510153705963000\"\n ; \"63682763879011752475568476861367553456179860221069473817315669232908763409259\"\n |]\n ; [| \"47776179656187399887062096850541192680190218704758942820514561435612697426715\"\n ; \"42017618175533328439486588850450028995049195954365035474995309904751824054581\"\n ; \"39169739448648613641258102792190571431737464735838931948313779997907435855102\"\n |]\n ; [| \"37525991163523321662699819448962967746703579202577998445997476955224037837979\"\n ; \"67759173441312327668891803222741396828094999063019622301649400178376863820046\"\n ; \"23041132473771739182071223620364590606653086905326129708428084432335332411661\"\n |]\n ; [| \"77778894465896892167598828497939467663479992533052348475467490972714790615441\"\n ; \"20821227542001445006023346122554483849065713580779858784021328359824080462519\"\n ; \"47217242463811495777303984778653549585537750303740616187093690846833142245039\"\n |]\n ; [| \"42826871300142174590405062658305130206548405024021455479047593769907201224399\"\n ; \"8850081254230234130482383430433176873344633494243110112848647064077741649744\"\n ; \"1819639941546179668398979507053724449231350395599747300736218202072168364980\"\n |]\n ; [| \"21219092773772827667886204262476112905428217689703647484316763603169544906986\"\n ; \"35036730416829620763976972888493029852952403098232484869595671405553221294746\"\n ; \"35487050610902505183766069070898136230610758743267437784506875078109148276407\"\n |]\n ; [| \"62560813042054697786535634928462520639989597995560367915904328183428481834648\"\n ; \"112205708104999693686115882430330200785082630634036862526175634736046083007596\"\n ; \"109084747126382177842005646092084591250172358815974554434100716599544229364287\"\n |]\n ; [| \"63740884245554590221521941789197287379354311786803164550686696984009448418872\"\n ; \"58779928727649398559174292364061339806256990859940639552881479945324304668069\"\n ; \"20614241966717622390914334053622572167995367802051836931454426877074875942253\"\n |]\n ; [| \"41621411615229558798583846330993607380846912281220890296433013153854774573504\"\n ; \"20530621481603446397085836296967350209890164029268319619481535419199429275412\"\n ; \"99914592017824500091708233310179001698739309503141229228952777264267035511439\"\n |]\n ; [| \"9497854724940806346676139162466690071592872530638144182764466319052293463165\"\n ; \"7549205476288061047040852944548942878112823732145584918107208536541712726277\"\n ; \"30898915730863004722886730649661235919513859500318540107289237568593577554645\"\n |]\n ; [| \"22697249754607337581727259086359907309326296469394183645633378468855554942575\"\n ; \"72771100592475003378969523202338527077495914171905204927442739996373603143216\"\n ; \"84509851995167666169868678185342549983568150803791023831909660012392522615426\"\n |]\n ; [| \"36601166816771446688370845080961015541431660429079281633209182736773260407536\"\n ; \"19555759172327736128240171000715903945570888389700763573790859521156095228287\"\n ; \"82844424532983875300577689116331373756526403900340445449185486212503235782229\"\n |]\n ; [| \"40833119728631657038301474658571416779079199343770917422783737091842927892625\"\n ; \"68922359316478675184342553333343300163568193749010867527082189412217781430311\"\n ; \"91516472400306837063911995909475588197278444979245081960087094196120449075833\"\n |]\n ; [| \"21304716730402869084944080869903443431235336418077153507261240151959530377653\"\n ; \"106551237424345741137570659736231801772439680702621554106791455938098031620471\"\n ; \"104392597313271110590927764888829150750277653499050463757708547416538850601163\"\n |]\n ; [| \"16907937154215020261110468963982390213438461071031811101554056252102505124726\"\n ; \"23183141532591565112222057191012766855134687114504142337903677590107533245206\"\n ; \"96725517880771645283128624101279195709280644465575982072053504613644938879246\"\n |]\n ; [| \"84556507395241990875812091718422997082915179448604219593521819129312718969906\"\n ; \"100646525819453650494590571397259055384579251368754179569362740802641255820576\"\n ; \"50316555026297423940834952362583934362215303629664094841692233643882339493043\"\n |]\n ; [| \"77363534410783423412630139556441807611393685349073113946053979350631229049878\"\n ; \"54905073434434959485893381841839373267383966385817882684657825178181863944371\"\n ; \"110016011331508430102821620395154714608084938556260733745010992614542669817451\"\n |]\n ; [| \"52040139270046094723964229965823921970388683619580004402190656733318120479093\"\n ; \"495546618036723566920914648951352373868059898268055487677897567226892784967\"\n ; \"2528292188392170914010448139211586215817069915670005292953294092269979070980\"\n |]\n ; [| \"36842840134449713950999812540127591123318806680559982063089906871196226758113\"\n ; \"112314504940338253416202605695368724580971154020421327790335219348068041886245\"\n ; \"51653712314537383078368021242008468828072907802445786549975419682333073143987\"\n |]\n ; [| \"27179054135131403873076215577181710354069071017096145081169516607932870071868\"\n ; \"93264325401956094073193527739715293258814405715822269809955952297346626219055\"\n ; \"75336695567377817226085396912086909560962335091652231383627608374094112503635\"\n |]\n ; [| \"42536477740858058164730818130587261149155820207748153094480456895727052896150\"\n ; \"45297707210835305388426482743535401273114010430724989418303851665124351001731\"\n ; \"28263543670875633354854018109712021307749750769690268127459707194207091046997\"\n |]\n ; [| \"40809484989590048522440442751358616303471639779690405026946053699354967624695\"\n ; \"51589519265418587649124543325590658874910911006853535317847189422703251228717\"\n ; \"73459936981642894525955700397592343967482441686326322443228255968694436816673\"\n |]\n ; [| \"87298777232393189731949522229743081866971743270330772607820990832164835738703\"\n ; \"23328534428894097247289332213412175849711532153957647506361455182140450133738\"\n ; \"51807348624578081645565456865744011145427112815128832643950401419083788780028\"\n |]\n ; [| \"62003629107726929116302469001779155132709624140360743951550189738290955064278\"\n ; \"109311858027068383034683875948676795998030610067675200794951297783857157095297\"\n ; \"2085588517087605436136379278738013214233743532079287631079316773925068862732\"\n |]\n ; [| \"9513664655545306376987968929852776467090105742275395185801917554996684570014\"\n ; \"91103467624252027317764670613760419385374004736848754250298970998535616755199\"\n ; \"39500000352127197728032684892425352332461947514533659433380855624868454474623\"\n |]\n ; [| \"75175260486328125629270378861920310368403601365269629778076078053196928460032\"\n ; \"56923881233337629517433981230592855430598464522180216309153828833928801967999\"\n ; \"20981004218820236011689230170078809973840534961691702543937445515733151438851\"\n |]\n ; [| \"73175203586574092105626230272409823792532423094740797516874387144340145138310\"\n ; \"45186992623753580336479418079070607289916086076906975839720879934817804495460\"\n ; \"96084125187548549854900995260973117424750860440064269432639526863495781270780\"\n |]\n ; [| \"53530507055579550362119832302266967544350117012822630711681736383163390079758\"\n ; \"24484677147631687826970700541691541659768738376645174313438582486313045584324\"\n ; \"99915577684197600584703320523786830947563355229812244982453188909016758004559\"\n |]\n ; [| \"73101441225016284181831039876112223954723401962484828024235461623078642642543\"\n ; \"57434882751817972247799186935032874577110609253567900895922769490031350316077\"\n ; \"73837027842771758252813592393497967898989365991569964687267097531033696791279\"\n |]\n ; [| \"8605586894544301092657394167906502995894014247978769840701086209902531650480\"\n ; \"8900145888985471928279988821934068156350024482295663273746853580585203659117\"\n ; \"76135096553134713603675854628257365311062159747768423095496501607463292188538\"\n |]\n ; [| \"77171330825793179961995032914169307990870372845116475229799680315757656196917\"\n ; \"17848856881287888035559207919717746181941756011012420474955535369227552058196\"\n ; \"85285874363861776466393873037603415962379724376693393356387850868454172343232\"\n |]\n ; [| \"34752820629818556525384193423224856177797869338806846583786365186093662702640\"\n ; \"61923000676912108769617866333091286856690233713839015114991682235541391477568\"\n ; \"105437294734850952102877811210027981435959945375626993201685688489494148805743\"\n |]\n ; [| \"37290995592003925978648162243724313056459187397796644444696543576625771108605\"\n ; \"95156804644588215637074780475000089186488581067063625121782605228712011438608\"\n ; \"111838568780358037910894878973007194619694503969424695895292495245099084158661\"\n |]\n ; [| \"114085830904535970531084512281741806703564152148485737755668141105183488387818\"\n ; \"27151558900245092306095370161852910074651784795680581223133179808714387525774\"\n ; \"17782273009863750298483603933610732253879825505411230932533407287574651036994\"\n |]\n ; [| \"72422039981423868898452547270453235353957783762070405836433674391957844064693\"\n ; \"23635533014670380888810554717349513178608213369182061967678315431422272271569\"\n ; \"59402711345784829746976504521969665104448536964686633342173372133388407225657\"\n |]\n ; [| \"92466806354851856571355165199186633833982438153589406912422876269386887264049\"\n ; \"9877617390649361889067963484857474874019563445507538784053773745685676317984\"\n ; \"74572672075215609948567780829046067891251792522874268554421916351892498078660\"\n |]\n ; [| \"36552683919656073147232029802086505741533932059491323529262718897271096098319\"\n ; \"28895802628889660292449057575076739706255701997961890168977786141673053679086\"\n ; \"9907785227545441866241924986174555965766785257012652276622736289520175209842\"\n |]\n ; [| \"29485332368911768475893015509537099136952860812699472744021496513325455451738\"\n ; \"39797358509842904932758894391536601623578260107859540160156599261695054175926\"\n ; \"107452259847197252302434271220963395311929879689430847107159618578878468880668\"\n |]\n ; [| \"24664696127391052816688570667643612077905959307658722811431436096677076924072\"\n ; \"52507998665481228083044018390203046881916651866666590845312076558622705190465\"\n ; \"69935204723497468327083545368078327534124772251842862926136799697299751835029\"\n |]\n ; [| \"372963191403207230700085823960930798511810380777302780932220121859190714585\"\n ; \"111366606704792806959979488772421759791592911629496627207620326636856656861526\"\n ; \"39677360977437767398760288273614298000827429534821360419179023551087917983124\"\n |]\n ; [| \"64601494076430280535646633059501605929914790764963584476403188233843589027560\"\n ; \"34156315098453482946438495274327282067376463494057110043754782161473776373661\"\n ; \"73687667961196401152630755105477060056162632832680813161120412165243753726816\"\n |]\n ; [| \"37808689229279738382348785246837013002280781984053433359148018860351753688153\"\n ; \"26778210635417272626362658500217995247072424006327715268521424423461840656985\"\n ; \"13012115310019421859484865413402512912208022868124085927375736053832542569552\"\n |]\n ; [| \"33073055720188060063004545324174039863351833928493376423022587630016341635891\"\n ; \"76584254259783109527449313057522305759653397147785066495263227868665161219779\"\n ; \"38531270223194009551634352795926218399266465064491096474482575354468954922673\"\n |]\n ; [| \"90100362566645034035707547984589905559141359276359522681964816611161474672115\"\n ; \"93014643079204629081291124987233004565276697190519877698472422015954982964601\"\n ; \"110916697765188052223435628742886773389228694903593626715469113528434066764534\"\n |]\n ; [| \"114725280711584666069398481856753837363052938587178775403749719257369626174299\"\n ; \"32967950615819700839673854548770413755655613096921050182183649674389310060672\"\n ; \"106372438106855157117155417458821032302424106544646447353561892891697429919509\"\n |]\n ; [| \"41996555998804572671679174634435850382099449308465335760130383677478780889948\"\n ; \"105999190358126224751922865919841547624707481487885223948004296548330504340556\"\n ; \"16636528128134911466622907961467317982179835733058354229921170933476186200761\"\n |]\n ; [| \"43468498537738045222256870515315985487110433728199201952445121047095648527840\"\n ; \"102272887089258604970815589009009162752025146641624347901234381428987386153285\"\n ; \"797386830910520008361185815477523544664694040635544500916993469578452189812\"\n |]\n ; [| \"96744926314199156321023598425708516126928808801578082649702497034531770517808\"\n ; \"99066250188188051206024031106640566584616407903813704153928240609169764005797\"\n ; \"101012485188852469291356197079506861083321680470016268483997462932491691773708\"\n |]\n ; [| \"49614555470963378761214277525336169174318331863453657910575217035316990252780\"\n ; \"94532874466332578813348267802784511494491757628599627802933242637211676358456\"\n ; \"60376163781951477822973950330025689966951914888122503797194554488987660570913\"\n |]\n ; [| \"99934768696780030317676638063039209891456597783633841250810260768328701786300\"\n ; \"71861378641802240356627336242725340978135703736568776865558429280585792121426\"\n ; \"84446994028646761779912629176051455275041688583492300440129402381138226185369\"\n |]\n ; [| \"18317002472599225949038448120242542829985613745531554876060436499109578301758\"\n ; \"23001721954642810524358122249469196372443463625490878969385130364780514025259\"\n ; \"49037245410934285111914043557449391103989331168177809387278571893536129709378\"\n |]\n ; [| \"65792050828386571136875573680568197513273253001530588336285451691348906024460\"\n ; \"12956514709922286639520985225111137950302442378466870763868693820049405409474\"\n ; \"38025781500219940187723501911749158551479941535921061459281014661810772473038\"\n |]\n ; [| \"98610017124283789125637190759729078315864881693957982200427567103302362453196\"\n ; \"42724178943656779288650125468921272883324869492775989038952508393082565227450\"\n ; \"99514360136104778310983460863480701661882652836741972684579325226086664343913\"\n |]\n ; [| \"111234788248236327826382691076985300771418365594838017963216100441270435887017\"\n ; \"35290532009451633157074005614742321966918220860237810056920944192222599040501\"\n ; \"72172784027306769601458922728374293130025170844011739475076742090414769211169\"\n |]\n ; [| \"61384388429666858375759167984149961873566898632022783479711533101905095026411\"\n ; \"8194273390415023152581060020119881338779571723515253104919314696738194355344\"\n ; \"80659234466772556847544129237154202226081525079070598707001193889658539631883\"\n |]\n ; [| \"62157670692624367146830864246105810519941474190553952682719433471854134465138\"\n ; \"74851302400382275482762496406028988868219592716510355166137061257664688666219\"\n ; \"16881796086836744646703159464114164393240695449455598565494759189917589453976\"\n |]\n ; [| \"42460477269659081546432152357644086326197211166562674408623141905226706277595\"\n ; \"81063688725529281621596607500748519671655516257039992655745871437369181665242\"\n ; \"51403113216244137057466948399908740878535656059933892843818689317660325080213\"\n |]\n ; [| \"49001998791770520786679099472805193463531142479298200795569326894791589887035\"\n ; \"42684462014557597494725933597359625461226399711783671410492942446635214257509\"\n ; \"106420886277092880545929306533089566775810130555230702838917980421765786292693\"\n |]\n ; [| \"110523958037212353696746219917157237679515245560578307171595792811566554384451\"\n ; \"56399709802930804752950401483879725014794413557467977624037632281590440364765\"\n ; \"100108862073771478435824578087801736413858177140360408436521717282600830155374\"\n |]\n ; [| \"59041409790855290045250456089216312297230856546920761548978870779493926213674\"\n ; \"13735945315945382005247895569035266667172550063549145646185577935658666385507\"\n ; \"16846296242516834547231537358954027537902709068158411294345086281698311539718\"\n |]\n ; [| \"114970774262524353875592617323889610576992844847433725376114488262076142213525\"\n ; \"17896661983150937411004047429485556264820315976705642986609974816436222162633\"\n ; \"115573362005053049429141251153085446935774781295666612354309246218946442750706\"\n |]\n ; [| \"85575265064375003235737272215445285540001719469558026661845214249857169530994\"\n ; \"87501751332871186792668480006319719164949448258731670359536302677279100637346\"\n ; \"105775909055063540416087237151517389942637625317333843436738223226977225420379\"\n |]\n ; [| \"110886009455283422981396854898481256559291311408679418842391298005253375700608\"\n ; \"95342257228100720685556647789433478371609336135456255803583405713563597933074\"\n ; \"2733591517253510124338232417535938539627593736745105875672348998709544742241\"\n |]\n ; [| \"32685479117496505057951010536248024091461630564950845696581129158987138920098\"\n ; \"96139836598015371513111133071481139035733083963976340622322043979088723982681\"\n ; \"16990606351055720221300633612533434675038905235719867684891402550154692840579\"\n |]\n ; [| \"13886834869596827027283068322204563244577723967928602405785473534631482228259\"\n ; \"81034769645830807786559566591578132114590768431721148809270219480247445931316\"\n ; \"26780635035984131258327079447673207266040002451512601352288859614294714150612\"\n |]\n ; [| \"72820784976920576285217524394309841044157743334874310886804718206719618858662\"\n ; \"84276722913141806246805569560426345961854221390421557310593118606084442633714\"\n ; \"42573817497593319926701003355299929070203785007821783512454795971915573843634\"\n |]\n ; [| \"41660041627266397279909712983288860313881442148611073178272756605107913521726\"\n ; \"7198246770791404776745997973411401046335399072925979346193035999274650139809\"\n ; \"91576025129588718283317000330880100309465430116820675850311277329602716166005\"\n |]\n ; [| \"30488483928716649313242898509172476460161184318124511942476380904233730958564\"\n ; \"35346040517569327255933130090945133067049088493975862969006023114275649329148\"\n ; \"59803015801166721680239913449555176591725421041660016242103441987856441941533\"\n |]\n ; [| \"17395049232451382970906883167116397657891664802601579276725674512534883408665\"\n ; \"96892830538146451450007413348096295684782382701592949711753407054447667361829\"\n ; \"46725583995795907014628330473921842919957418641665482351238505922983315675600\"\n |]\n ; [| \"20556719902345568138970735755829852608784985449829745172855204153387982836579\"\n ; \"17130405757403641097651484965062131526367059595476924144885570325828777794585\"\n ; \"99651763337265056372826178960800950053231370129318394703153246147873057668256\"\n |]\n ; [| \"17814517977679061356584950826520510701145481336316888282105225134451035883368\"\n ; \"62116749577126511600138536864540326578096290025961229483071769130930103978622\"\n ; \"68057799973217998063838402481530957249181669394905338807621317159743376777292\"\n |]\n ; [| \"26100793478962260035181580648528031417033872324944615961986573818448125345450\"\n ; \"26507891451149179196332605230084404371370204632884553105363087566061809624465\"\n ; \"55607174697006979796477169324630939518573410736589826596210132996613779221405\"\n |]\n ; [| \"75098549092668095590746032937529532494350222003700838962461867948806312867882\"\n ; \"62901674712278062473767645982006145910793625009149846534629441949336033280610\"\n ; \"5918385816682866756860679567405784562483373873565987668410277610868983146285\"\n |]\n ; [| \"99232460916208710346946062875203578399818909925477280432427620267031292402265\"\n ; \"115165948144292852122635634954139515297086369356811820254801384608988902457684\"\n ; \"39462036389170488019054739441325823641943062254145671230029238830857274014332\"\n |]\n ; [| \"109723826013507458840008311671051963282645213933956581735587227292458581212170\"\n ; \"88295699560808238817850908733435797366622278897489038929647807463406234520052\"\n ; \"20306380368695786945008272690438693745796297843799468268993907772341096948885\"\n |]\n ; [| \"39988356032524455736714109463355738665746339590560108227920970859248126609155\"\n ; \"47372836588594871116561451142702593094337405740661755511614125456886719840333\"\n ; \"42727075822142544969304941778878121065758237932060280070908539158139079888683\"\n |]\n ; [| \"115695172202592006925180721060969710051274632819849770440984261650964182295350\"\n ; \"41198034356969673080518030958715740186484860381424802035929938277103521577731\"\n ; \"115380378505550001583545282887589851179279565072664241489053445702744491234750\"\n |]\n ; [| \"56074680442485705900559544809779144521596408129059458559681779642734476672579\"\n ; \"54187206076706271120400668422875039791522899135281309004702779376007885441827\"\n ; \"100760509008368123701304764217450368711018785408289674422092070202193042774995\"\n |]\n ; [| \"2622643323130765702269424224791233611920515499144047449633123689743564676648\"\n ; \"95487289650450707799373930173349121410704227885014701702619711048222666102791\"\n ; \"94943953462630479470879050547964792684799160133612590505176816568790562776928\"\n |]\n |]\n }\n\nlet params_Tweedle_p =\n { Params.mds =\n [| [| \"7892482395656804349644706591899634788891398382785975587948820587975527991027\"\n ; \"11929678886172339432249632245409218061683715785450195046937244296345281508001\"\n ; \"14031028727666215233628980515424371116641513455277823607571812548899776279020\"\n |]\n ; [| \"7068151019014908222760412877815939864640073704531562607661785991407609364631\"\n ; \"20000306279614657869922305271027332599039933086359117559307552225546808822661\"\n ; \"11789548007016973514330291636006559052177068373404372008308286066331957081587\"\n |]\n ; [| \"4596429675096962119861928990065498834900102715520185745595618370978168039762\"\n ; \"2419382603939993361171611462560649281200390612440053944534827125842944774778\"\n ; \"4204784055784266414484460653790149892220936342148543538356735100428170988226\"\n |]\n |]\n ; round_constants =\n [| [| \"23871411633030431908815309679954664955316835501833596382711537998018196877083\"\n ; \"10266075254464775081489705012423357777448464454058081904455633881524670629031\"\n ; \"25330590157378829472296364867033252573045672523068709711474216638118028547521\"\n |]\n ; [| \"17731890776914364842025248625325793211421093305063918487984842622991225662959\"\n ; \"11733994571128449437695833182309936427385843597031955163409472509305883070660\"\n ; \"24434628986405408065629924634775662413138564617325268165975978656343592221427\"\n |]\n ; [| \"24536402423562099407865959531182080003010952879037409125240233415066893274478\"\n ; \"6659347569024195568957991805519163899458248905612848191888227437243439812692\"\n ; \"5960767186841646855432896459128104017951108167445308950169111825889581577061\"\n |]\n ; [| \"4971911842906289673901226938513151439879412562713230347716896457803333981940\"\n ; \"309541453644722548825874753903709706899515232384157286261751156736135339003\"\n ; \"2269569616427699911129222135189454646445178229181823882769580159958019242097\"\n |]\n ; [| \"26993878188558092116624938696043644448548700311708990249335713416846104251941\"\n ; \"24517651748676427005644984612090266723222512573361699639974666939135208353913\"\n ; \"1097726622863402924577966380605322382732118204644384325315739877029330402588\"\n |]\n ; [| \"6426758383747111723734570359305954670329012940529176997601958694540682554431\"\n ; \"21998569714212750241527571701712502925679335862585921971643825857153225305984\"\n ; \"11047558033241019082897471004499357092985291837411225795336191143257516860961\"\n |]\n ; [| \"9093665141362071558275397247216897637652502299054137932451490373194253077166\"\n ; \"1800243967051770052116464993247352026875477402681617776355019059173229087774\"\n ; \"26123174928857348712960596162051313701754733407348331834302644408819678596924\"\n |]\n ; [| \"23812410588002831655659233838637953883343555294778677500694584331113461461429\"\n ; \"16568937332253520415004151553015144261880434455738996526515454547064570797856\"\n ; \"17416986733486903313008211792802080561485956593184988794629480990990241332753\"\n |]\n ; [| \"18850099810484503215488003706456560440897969494004838374239261525322319819433\"\n ; \"11994895177966687446998282218714100449449665604701986885520927508332599942486\"\n ; \"1425492478667258597960503405197195915139351100492375612463171033833952312365\"\n |]\n ; [| \"26851566219342728401327392853793780102411433232004161234295219003581835075094\"\n ; \"344621744446962141869707506851008584085694659330775548168637253712934505608\"\n ; \"27869765162837447936932893631710126670776990181965052553686418664996771747596\"\n |]\n ; [| \"16748261191950640387981479364297758560864676430387245694151916012002124597033\"\n ; \"14637099470938912277872449097875538968878222997977657926224477080477442009809\"\n ; \"20134098049637875993058446069963966007404168258760138083222194380042623128253\"\n |]\n ; [| \"172643149346341872053831853059095100992686236318507345773031309275063274280\"\n ; \"21874843113613945727298268457562401417065305917171338167509212463100548326138\"\n ; \"1700476193411517352507365601977550539756670894414173315822287469432716857784\"\n |]\n ; [| \"1993872240998785476519726097091542582716493962333829952600400285464827481667\"\n ; \"8472968691234464451203870490242938239228570177726710854613935637388109305350\"\n ; \"3164353924636797794161130496213914461962109666565363218256253978570495482041\"\n |]\n ; [| \"18244688836192292124520893341941070140825196416664991549095593577108644921872\"\n ; \"19859999153394936655973233989554564211615670588445691525235383025282647829759\"\n ; \"14768311403338750313336252298369831176491426375153840900301806527515974149276\"\n |]\n ; [| \"25048746858150888741163510410158558227335767837462499905107113911114136816901\"\n ; \"9227230998590560160520502436666565937931267956328463227409811272485685606743\"\n ; \"4696776701448869702784130024458706731441259445875220148105235193026890671102\"\n |]\n ; [| \"11301287347994988321521498920971508070471338636236053007115010700214623134272\"\n ; \"748252891813253856881595793948847132117119525095726183576703279303135116231\"\n ; \"1209563742600434023250112835996756101387112259967014633008182172249296990489\"\n |]\n ; [| \"22609170854153903022054335214005629175374223898873094415826508662474540012601\"\n ; \"5756488621395177188006147242675038050365093553404446887430772051137609241084\"\n ; \"12204891034723523196031315166164117720044397647721380430344188362824579202559\"\n |]\n ; [| \"77948413643208929474117747177500706081858969144437292876038062365116961856\"\n ; \"4819244967439699230735093723487091713222852277599700902443121153586483108261\"\n ; \"27255193365519906102265579122686066635100777748346545926565256522831777732553\"\n |]\n ; [| \"17483513281289738114320990201034187042331906234136726563186654929503890752423\"\n ; \"34539753269842243397370782720638857152602526530856732612587217775462538897\"\n ; \"26670389866012575823645511883620356698491268371217559959046672563897471132762\"\n |]\n ; [| \"6221497512567057828130180875424737245292473047926600299819610408205436413046\"\n ; \"19660878074830892741426544634587706872027677058382555048951769961524177907107\"\n ; \"18156934729803692033361542236751723515055361449102326383067242692178901601513\"\n |]\n ; [| \"20073967418251150136032317311523223358394853170230955059721556689651929220184\"\n ; \"27772273899948728907116549961890766782916787451941456619762132483552045169192\"\n ; \"15971692165674397331342925986736499624826262396209267283406828364924966200635\"\n |]\n ; [| \"16416286997172332555663573131890151419265070164405909524639440666852040213934\"\n ; \"20103224377910718515832192173396139379357815331321992767836849578341263715617\"\n ; \"1992082765658661183841193649461040448653056879234437404013909283532649563512\"\n |]\n ; [| \"19951269645786270967009199575056978741590225092285762370657308905017645787726\"\n ; \"9251473059263374648207691341973093388418035271819559725381912479353472754743\"\n ; \"2444980378309704186211898448086030379464888548066321109843797635753120477485\"\n |]\n ; [| \"10928282022919314114783091884635542308337867197724629946199953660957345275397\"\n ; \"20860003419679976346116549953191442898649396106318245755983695478063963781522\"\n ; \"9125646500493112058936359272551424490842840477766749690227538466206819804312\"\n |]\n ; [| \"20177768780524517369036303031063597036475507744395182409567531978700484378289\"\n ; \"23849136275489209274738706275875891467606042431504310216391474226820256396157\"\n ; \"7976082325486396563438765887430351103212480060205218817888924447342264023448\"\n |]\n ; [| \"21218093079130866432053178184495259038615729811686678720305378508679861852386\"\n ; \"22222629794092576664613127689533080951595674722722217395604438734265291507137\"\n ; \"16117082350553416755654415094185598367594750430516162377370652361756124580927\"\n |]\n ; [| \"15386072248373014774707633578974000489889916088461822982033430186915251599101\"\n ; \"20059444943956181967567300338884496353066968918285957577453937920821326774911\"\n ; \"15969043598280333886921493788703960477679932825020353079985508309173442399807\"\n |]\n ; [| \"18441908288363677832500730109945652708871777726808321883963939341572708678438\"\n ; \"9156742662968671243472647671483446293299984596395820828399187385978257187180\"\n ; \"26117513962333705951186643847036445264112495570596099092098117311469761624146\"\n |]\n ; [| \"9227362126330995448990863192270789313546500545949776416489812561581590597341\"\n ; \"1651638493276735214427785026108815161181550587953472105263074483216056083718\"\n ; \"19754190980633296736565417422427507009115461976496493840015545861722778641757\"\n |]\n ; [| \"24059801258623894209907222963420795819610514468735113836904109681657134646406\"\n ; \"2507773721870400383553935214026283806800287719784543798652125141300020939070\"\n ; \"11545619277487756168659369622509301766172311628766869964453828841442812398464\"\n |]\n ; [| \"18599404251801695916676262627086229256833226846935875794848292474360329710182\"\n ; \"7672585728603312485277463389894405790617721546034983006052523579994187672256\"\n ; \"11663243875044039826255065018193844285574447293546626080552543307831236101532\"\n |]\n ; [| \"3736737114971552038249889038312531109770417843384959461392265945390839075490\"\n ; \"15405041123991166901995181017584204362284350353917954151561434093358377932416\"\n ; \"21190402840771768305757114855125881983900480564766015821826135703463049645985\"\n |]\n ; [| \"27657612144465152844076751970773624300501046484432872648148700499103897742199\"\n ; \"20388430216478368624703227056329193371722737732187907129943643410513691213535\"\n ; \"3344820289563345194933219828087298037081196856323727299522946086140971056423\"\n |]\n ; [| \"8527890306194452597728380300408050856248447791462807214374322801696709074298\"\n ; \"3344453085657711280093205964282996094870704440396012352126082601788308767424\"\n ; \"24129621344772065907359832544790760848535846792550779738943452820186937321016\"\n |]\n ; [| \"16682281929114205892868637273887744852593056654081569289385196216494586052059\"\n ; \"13390546402723680321309451408062261872073917009165123815466701909179323058725\"\n ; \"12454401735435545041240744062413508439776638863019945214106500639361960301753\"\n |]\n ; [| \"22691978545214712333682322509829714302565160720214993370385276444403705409774\"\n ; \"9304194978657396762457989504468955280882290742713614422164474050373984880419\"\n ; \"24518330162580075369755426938387542128644607789410819379604533097820563945147\"\n |]\n ; [| \"7793343388923696013769312876044250715843242497839331541419306365445952124334\"\n ; \"15474893610836752417132140205467036343146784962533163791549972307193429176684\"\n ; \"11116443861170111868320138692617094510473035491476329457635995671799970535803\"\n |]\n ; [| \"16877979504226807061419377389528064425375368470773322489308736865456734785901\"\n ; \"12194411710031950769113984418215809481238312707786246344424020890556957457012\"\n ; \"21329761519619810559319231763677758647122208920134924045388361417919054295294\"\n |]\n ; [| \"15486704070124713197776757158780492106937367947624672577943214567891933787258\"\n ; \"21879500021741312414877635555959377131752915257473724817131516706125013556007\"\n ; \"5043420522702480930107029442863985487527788786987286425206067343205474678396\"\n |]\n ; [| \"28416728565535371153714147767297875894376657006631966873680443521362574322416\"\n ; \"28188295006821213084652983277541040229663295908823345264477158493251950224190\"\n ; \"811696348709499453953485215191565713676093511624729934721077050082968313251\"\n |]\n ; [| \"14655407507725921832105500951552761181971660775931368508685072434505922507512\"\n ; \"15452937371493366546640620581126461399707812646853303452806945678641253144882\"\n ; \"2286261699720696752622655970051026147406838467804385944265035557798199981133\"\n |]\n ; [| \"1992557442353308000623574109100253608701924636766704840114158126271278280731\"\n ; \"21694450413109623921951195958057854484852090181678130751969309977692551536018\"\n ; \"9249731319012017779017326743606194923643668526628748858217378905811538368382\"\n |]\n ; [| \"3939219222555454896586029131514042607480723623744884435463307473774574605152\"\n ; \"10797179208934709183850676357345550930799476411664074421966228250898236909457\"\n ; \"16003349341141317690412220236365636756328414540434964599637729177724750393340\"\n |]\n ; [| \"7139886020914795212662604367684684711418131042431587260958077772503994611059\"\n ; \"14548527492795536984793003371667969667596401576140783527415224992442661296652\"\n ; \"27784961580458637262287375576745710987249457442419641954865148924289640098875\"\n |]\n ; [| \"12713866702735338063343936521670481149781186654485300349666527843472483230312\"\n ; \"9092010170409960335483537084430885053488154353385070704782245279718737955046\"\n ; \"5094923690647683377313391496286927104459466521704225286803035696710155177995\"\n |]\n ; [| \"25569861054853573619838769694313237597861085179963737149403330254183532535529\"\n ; \"5878170049851666055783493866996165172583448340223151974352193778036352307943\"\n ; \"3872169186443882698001210463876163485285999493224352597337453067537500276246\"\n |]\n ; [| \"18665784052407501847083570675839500069230593336210620138506436003881713609889\"\n ; \"18152379076079140594000518889838158343416361432991548307242241800589989006514\"\n ; \"15293096858608991177688271468787656348083923851728718260954929346470077552533\"\n |]\n ; [| \"27458404667733046540990542309129625717764044091884418745028933631962947220717\"\n ; \"8006229583150739842023227507854792176671075468287456095936807010603225964853\"\n ; \"6673337136101970490098396053273218923846658878925354650729739777392657741321\"\n |]\n ; [| \"2866189528434329040657150614965317384179174137415824086986689674293245440869\"\n ; \"850286832335872065552208685923468151432517596206010380489009288659201960609\"\n ; \"826167896454325673153913201896766310675528897953588379016483511428072705149\"\n |]\n ; [| \"11091353885350315399281534279307640099073252617438924758095267005171197532901\"\n ; \"24332996362686645308612352679547748916117510430673097992758824281388269163049\"\n ; \"7697281120418309884363241543849152373040915185661630590946085871626953307630\"\n |]\n ; [| \"26903415823976566965446163261389520506645994486239829395342314389345167145490\"\n ; \"16331473399937436063872600675479075998365344725582239128025161788438169634490\"\n ; \"27478782423978673109458866577304881582710228942880032866222151681880849121754\"\n |]\n ; [| \"9157575957419463790299788535651375681659171956515351213017221629165597230565\"\n ; \"7212846269226025424784660189052377648721231465719295820195086840304302908764\"\n ; \"15079360452490344164815517579543356820049766968077892340838182489029333395345\"\n |]\n ; [| \"2164387758948063499404878920144621238577478053584327446777845938241996921307\"\n ; \"21971530571660454464263042379401691171478093875859848797664553305525096942047\"\n ; \"24996214603829854187327550321668003124272776524258345997409641809486816101711\"\n |]\n ; [| \"5012530167147645132123926239187192574015992833971936940239020886743588014969\"\n ; \"3538797852945828178389690727899551008654641317873025930608250831273186708784\"\n ; \"16351872580375794420559957848346781277378485393541927811867651422570033372488\"\n |]\n ; [| \"6649114213329992677018914668592605228429520774140774692558017652328554186338\"\n ; \"18665440706841919461000547042069933770374154186835596054373579551791088230368\"\n ; \"12068241390808361251909200960327581910129328275585071206860621578629194685379\"\n |]\n ; [| \"15905233165225780889629861680805819536375352205513425939444748949014424918343\"\n ; \"12508454002472469574115566912186222048654143934720930056557327011774683943013\"\n ; \"7034709393479901734220602275921317679827342926959053187089378763382019774818\"\n |]\n ; [| \"15071057763697867068980601577937010855726002209360872455781029717330270540558\"\n ; \"26837903264629473479982710556353240390490167539626299502592215453725741017346\"\n ; \"15815857256588462989339312138660989790088642030075547425161293150909179052889\"\n |]\n ; [| \"17790122309815232908548524561514677539176024837185249994150799440752116986971\"\n ; \"25681654720833964361368816492300991096107229186861423365051433302640152727160\"\n ; \"25092605033552047946753252380591729771370646821844905835767238550702091926466\"\n |]\n ; [| \"9133411374125723094094125880554229361676050614544252095679163115115894136841\"\n ; \"26932002400667217014602216630093364493283860795391062254701152928395308796018\"\n ; \"22106228556612087153532192407561886213520535606346621942342426362558131787963\"\n |]\n ; [| \"9406311227783101741290261235550552478435250008098267151139650559181505389852\"\n ; \"27348341640941808284285285580081335760088527770841163602103782109071842104934\"\n ; \"23559463527614164053397335039301766055455415575615533929384690127861601499457\"\n |]\n ; [| \"5619769611055946079310055282596239209008895876149398331145676663636029101157\"\n ; \"13578163259668232168333668013435506407087237516177382960962039602890195751920\"\n ; \"7413830766934399815434854130814997370862812666201550415594211525136216734282\"\n |]\n ; [| \"13792443813595271204983556094168533754933130020885607088800378971405796327369\"\n ; \"27980816529551052578978463084908633402261105969483057107732537724040827783618\"\n ; \"9086585172488644340339192486024741212137636677834987669856236495399842977922\"\n |]\n ; [| \"11313421680706870429846305787628308653216330618143751161363947025312249024761\"\n ; \"4021066901602104243187251101773896805730813605469425950314405128776613579602\"\n ; \"14767121153557006971815403909933008062947309032922288476507340789333378073654\"\n |]\n ; [| \"20370619771295344300690236727919219226792483779515051540457737461170706414475\"\n ; \"19057013717580762168292421969225077213646512718101800237917624429055981813838\"\n ; \"18802159878265458151106922138846829134121904345009173021788332776013230402104\"\n |]\n ; [| \"24016190866456985740426033746487501435211791016346499791546425666381940738421\"\n ; \"287764449305195377184537313636736253449783439200917075011454826449334249192\"\n ; \"28924625533476565101998318658547220617045362556325453564311201040145506030261\"\n |]\n ; [| \"7599844266964312760321206419543935528432789425869947893826782118191539450266\"\n ; \"27134279976752686312431326985386138880800506706870947398386273393113450719312\"\n ; \"16691817056677639737321251699552704590963223686119737935250825199787652805166\"\n |]\n ; [| \"22998044684431557794791841708335486493573768985622899417439899102757564768837\"\n ; \"9401177121715465262238174135751147495308547205972761175814504972150026367535\"\n ; \"26790130566347368063997033116765929382273650193131343958415387299771850673985\"\n |]\n ; [| \"3677775394669979862889071463502051146295423081411873494668961683260168561200\"\n ; \"15979374501543368828047096104571216535562304582450829728472504102636784119438\"\n ; \"27983949821598015961883988148799706647207081688438954093427232113605924435366\"\n |]\n ; [| \"27544538692601828352117435876403689629911776874104761257423949309268045763185\"\n ; \"26518335501934972769761573274318670551390596750003847775195848446258018442847\"\n ; \"4394131430649458263649250511378672198908409479410475627536485368480589477325\"\n |]\n ; [| \"17852065984807648650789061534513315071882379764409167220327155188497750610044\"\n ; \"18175119138227704225937550148743137184987075122850987480893509516338237125431\"\n ; \"9213947738410262749305252213461572203334592178012688401993745223133683403178\"\n |]\n ; [| \"27122114905718250703139963834720424986105744685568269961612244344496328439886\"\n ; \"4760667796367744574889553071124411738303713877930746202875952709775583533416\"\n ; \"6869551919316193097108785401949737566268346424578556997536454243546346759675\"\n |]\n ; [| \"23037512317774976799069981329205938965143927594538311039095844313686020797562\"\n ; \"5054896342931452597037605872652090619656314276168870046892307499425423949760\"\n ; \"23203714262075719720359794801639953965353238316905585901583196491094684440749\"\n |]\n ; [| \"28934221989290923495677613925521064896104825372643558590174660971609344537462\"\n ; \"8088721343567483152949374218613505786573889657303344700058590499312426775261\"\n ; \"21917953186139856111153943474716456656175171733392297547383518245334653482436\"\n |]\n ; [| \"13961331694190054971056058301976924809966415553682688755720832242614168486723\"\n ; \"12544911152480935441357195703690990795365136419393151814200219795399220718629\"\n ; \"21695520803994090395949407367250368059907198292643658069384062711565918112344\"\n |]\n ; [| \"3716150465866919736709076695055976565597785970845650354410730126658608015494\"\n ; \"327336957994661404033945962575518119150720065183392456042720063992483355163\"\n ; \"3665947140103366584087139828849494245835014110441785513464272098210192613654\"\n |]\n ; [| \"26369492318428928735445021592697190549303995382614357682017136715337112747935\"\n ; \"27749815921003845385723497945745117881231921684907697336156182087899053510673\"\n ; \"10355044492217226758344497131673377893070994153140912920311451906060821340248\"\n |]\n ; [| \"4628431130793759981513415398028190279858542396207977476299170127225184781705\"\n ; \"11394587544387541452118107143659899713641924256823223827419604528665720745426\"\n ; \"27501113180347337346361365060944451586249867412705472720376921357546323344395\"\n |]\n ; [| \"28278837938314100710292020893318211455155607281093551519038981321116602349373\"\n ; \"4157302910095235339431818149458321721626091681389723550549352022675823861398\"\n ; \"10647753346148135279439456095440861046789212730332155466632561589399089133326\"\n |]\n ; [| \"16276422291909940897533508339274805427392027844787029744067454575137039713632\"\n ; \"23729032431762932898115881024840919797648524831708845029533918801044987536615\"\n ; \"22905612910561717552380974405189058153230663615322248220713638543054825797666\"\n |]\n ; [| \"5444504530356500737158011550177553406072045906791914738537751528417224842639\"\n ; \"28510386747999403469810407444832806233927676089588288134899522943795774693661\"\n ; \"19805413841948596162239177018362584237164470208997373794301520395085284750539\"\n |]\n ; [| \"19122547678583805564624026606820513504429328853794128995861987147454516637234\"\n ; \"14149390468608933390700184668781640373558946294178094543601697991189519008854\"\n ; \"20866357658195086764903364035397344007481887992484022195436866986726691198910\"\n |]\n ; [| \"3091400614672562681643141264311087165471646584668481415815002651728679925334\"\n ; \"19494024337294025984052821389584821264663721932805988242535888300060571638572\"\n ; \"17644592732159647749467251733367874632398437355549297444150061364959517600595\"\n |]\n ; [| \"20396032354914064522098028139725361423909280526354910804413358051025918529619\"\n ; \"8139121339158552499821459368548404840589616792874943249851117821336073953085\"\n ; \"10922434269468548872208754791993251262753058094227791965335951350558389242990\"\n |]\n ; [| \"15649912252593120246156581284146963323803608017723227709583948225917889870238\"\n ; \"21372394998583927818008072510481270840383010669604639655072625570587680791691\"\n ; \"8898065452020133817419600668300082490862298528579716847829659770466997068972\"\n |]\n ; [| \"18650547661483668504889775893476275079031609582673355265573607371710055926487\"\n ; \"23618674478465955845441421736720381271262239925598902631963493613481722447464\"\n ; \"12891746797231517000473007152761525047439710094872911258902687687042685332250\"\n |]\n ; [| \"1833893631568920050533599834904970213411923339935020486417653785575000615143\"\n ; \"21710180770129352998141024499580964469666455613123734716169584679669510873775\"\n ; \"8320010738639970594139541432443041967828948675894027397631123863826975291437\"\n |]\n ; [| \"20373837152733625366974701596758373355440504238040809868686624790270197493528\"\n ; \"12781438644864943427350664202279855672900381345640622661363395863727232461941\"\n ; \"5622234659258862655204519959448765784253304067430902712408596795866706826032\"\n |]\n ; [| \"1029291849649659108434334644503982141075719243675099861198550852722630712209\"\n ; \"3399484996504249361098308540916753999551454215950119214258113924944098529133\"\n ; \"4228806379514872892076346437718106945625482776494389450700910204388632399170\"\n |]\n ; [| \"16757668050571560648475639292687013846146697092325505133502515482647055695358\"\n ; \"18015084288230839372033169918933220044489391040316918002447358599016172874588\"\n ; \"22518355405199157615512407427389375489730975216718755365792251880852001347523\"\n |]\n ; [| \"20573368860115893940170639217949296882201199808293037762710789923980031371642\"\n ; \"9960840295218443524938341356473179849353725032041141822502293175783147220810\"\n ; \"16607996476430852400280109630637008547605338554739450722762338812055064961040\"\n |]\n ; [| \"7171658568863901784323661701131019863889729147856087046438022012589987643202\"\n ; \"10419002933357804877530761113458274768874412386136675204576115138741608012739\"\n ; \"18861306008102317898949274209011264398227868370415517665809396034224603196914\"\n |]\n ; [| \"1158669061044700880156383735717084681300773582244764163190588381073092936750\"\n ; \"22580910367253859335421514059655021468195876007209097419255510855097011721727\"\n ; \"25227641011701829958282079681052124431202635521215558068499733331989655141417\"\n |]\n ; [| \"17631556489231839623790313532079202613255385273277758734940753078216858815087\"\n ; \"12364579808565613988949646111979230705580282638991093972288646497224214207629\"\n ; \"27329142993476341161848962227966301919437953833554828144399467978240930742586\"\n |]\n ; [| \"18928954276816129093422581186438144214889196137619925522418500128918638106192\"\n ; \"2694991762120052049414391511440055444192349820338943254217225671225856705354\"\n ; \"24550218467559691781293396903076544150117989130151493573851599275085996606415\"\n |]\n ; [| \"2263637838316531719424059727023190126413315239400030877929788886432292775329\"\n ; \"17640968677322424538098309260107170953689147177463962461922714776240524875178\"\n ; \"19443928844574086327434242479460066104315747577578735497796887088983936043942\"\n |]\n ; [| \"11946837349828339651553745139029680016817294186050265590839923356905805035357\"\n ; \"22348022813139862849068148377528486325131041514035743832201785720676226808476\"\n ; \"26916778334032102178669575567836710673110496650392713945070999799105131256857\"\n |]\n ; [| \"6772367578799449199630493680882624055636516414598646521039901701866152406803\"\n ; \"12963643276721087785826784687244852783616903441339291312110495293886231701342\"\n ; \"3495180091566437950872177051556773503914696078922351249973160522225629648761\"\n |]\n ; [| \"19636722086015988900698322500132161186603083218895346390169893819062129539093\"\n ; \"5666220019570366878592707781772835552094759159906603422414363731979336135967\"\n ; \"7874102875783310620499310739194930556976996287514313823549459686051373482140\"\n |]\n ; [| \"14280578027404451144128482988128079454347604231057136906257574339598355143304\"\n ; \"5144471065355127918389406816656570319104327848925794556365711516976530276907\"\n ; \"14225884822276867436898370040228402906367131879332823332133680447067984518507\"\n |]\n ; [| \"28941268628390287870660292646709031665780090480358777746775844529193861308069\"\n ; \"13377111905191945833969566484261585035643984609846866899463874566132398229000\"\n ; \"22564078765828517667859311123307256081299021587637307540298808998440794108520\"\n |]\n |]\n }\n\nlet params_Tweedle_q =\n { Params.mds =\n [| [| \"25915736081177016241546598112391708036536987432422305635260260760208122221944\"\n ; \"16297879259961607025362014922234140032361260365432098634487800168878994764928\"\n ; \"6033733257175634837476818019847848256912403026667817175660404282168388911176\"\n |]\n ; [| \"14045886505657516091660160567697347035599074026719425910347091110613125329282\"\n ; \"28063323679221750580410141978618538612191923017649765586082296380600660325013\"\n ; \"16819697298174473653322938069684433995665518997062997223549599541089417145617\"\n |]\n ; [| \"15413524273045791515306211887939932559344561300389872507948116835986601106260\"\n ; \"36421043490025209186163871592492585408887527098720780722489614383638192290\"\n ; \"19794181301775644846947316991663934780462668882189182094267354309951373752713\"\n |]\n |]\n ; round_constants =\n [| [| \"1407093205071385134019160203229442695267924164910042285561052671714302327117\"\n ; \"11779724282856814171131489762288461172831486048510303387508269258305405159494\"\n ; \"20501356828629986222924519680141334519157249096910596964295651887901812757851\"\n |]\n ; [| \"23419085236318922177448829791267506851321183371308368120588907466638891990218\"\n ; \"23622615725307076779847815917182329276803050417362884676509671384840820735432\"\n ; \"9803250007852134109663616761249682289000165070757264268444033227122154712435\"\n |]\n ; [| \"8258125311635369235384004583299440393524061932038233801638278824513198056900\"\n ; \"7351712538809193694641892798746315547120734114915787568462574210306016208172\"\n ; \"3059129220572147109518378560013963561504677918762824375487834543428745926058\"\n |]\n ; [| \"2042383557155251217884643242454382272036567754448083296933565675865119461967\"\n ; \"15129675271994104178514880712320024929034675263917539062120100905141109232670\"\n ; \"2643699531755105343660845635266167445623854478292984863437116378029552006216\"\n |]\n ; [| \"21874906039195160027003265247067314884270948612748992177669773940314010123091\"\n ; \"19764685963582912390728638382178998584043501872176444130158409984862908383367\"\n ; \"24731701819796788156889906156124721070820824358000508514589474587782991304615\"\n |]\n ; [| \"23349997101843053192913636118003774827214499818459416641628849125511955859433\"\n ; \"24717674860585372478964575915011580548457995997758548284742988139987280611508\"\n ; \"28526106831601024593647394922551831336459814654587212090704645596629587939482\"\n |]\n ; [| \"11124237076008500471717934253870630742394346079041199265139475769025505862924\"\n ; \"5603568104404435184153167261671260274794550222989896759977234085169877356121\"\n ; \"18631968134615245163535085925543871536654560418979608277352837363265788104887\"\n |]\n ; [| \"25622000111684154876169657771818113353862466658383499382458602104118482932612\"\n ; \"14685553097248008037900441153689553464954749573708220558483151708440673116626\"\n ; \"22638290793036874494380252722781129323329912946279958525645948986012903271588\"\n |]\n ; [| \"26722642316240919944771155748582214575762636956156192045531407557947082330441\"\n ; \"11688527178001319047781582359974030014986749568962572618484185726534538143302\"\n ; \"4132435099492261681531450855031935115318187070155419444963918466294918478458\"\n |]\n ; [| \"20141284225901340938890656022639520931541470876509036146369749046098483015757\"\n ; \"18736332138502980964445308743240819782522235173987082303305443804684531454297\"\n ; \"17600693717098925665126422004940106422694608593016843967562670357150381420609\"\n |]\n ; [| \"18592614129146387690177360441516834331069369945676621261719641293117078327702\"\n ; \"14150577074637411884886261168762693600439005064514241836521926118301097417857\"\n ; \"19031036144447273288422615508693769842934451415657310442034112526338125336308\"\n |]\n ; [| \"26053352781064856963576604784372156952426155549559043326273302769112379165473\"\n ; \"12778639913079427028917330759671637587295979742641290726186546285252525246028\"\n ; \"21084419118692958743436020036593002996130380427307664962379311458126599853734\"\n |]\n ; [| \"1683679732388236007430336774551658766186300637910023597309960010871812663155\"\n ; \"382382265518823882035704612421171594350637534457994341641249505478238999843\"\n ; \"24103231983573822934379730503341131278940831646017600293219010706164863268100\"\n |]\n ; [| \"15002924105159692538984514753644972208898096660405454273558411866368262628713\"\n ; \"8060462184755100984999826027229470284760371993470314636251170461776357079944\"\n ; \"8014397154910879842052615519912717212158245202057892272449783600873015574114\"\n |]\n ; [| \"22515836383808274667935072370173638116426359208031587416631515348588332802165\"\n ; \"16360177906204352406408982804994067585455569983797470664902705838290946655225\"\n ; \"7377024122149545148833892203521810447795322854651603924615290711324827954389\"\n |]\n ; [| \"13822535231889686674929431810384661533456403404275348094834293881078653521828\"\n ; \"11336050547636194564207457615233402475265718541062192408495224405268258092008\"\n ; \"18805821644425041501933345241847488386094077373308766699152348641373866215637\"\n |]\n ; [| \"2953706678908410496027875422038498650868917425939787828661796632154883847146\"\n ; \"22240918382283561059183778204822808538520952332636130676150942209160161480801\"\n ; \"16015663662903953014672458804500981049100146349056166187951058089247981862386\"\n |]\n ; [| \"24566120104055916417636960820360051385362045582201684271866443305615866009754\"\n ; \"15228716568582234525417425530930303055506743342549413293218302255768537007353\"\n ; \"28426124059260498940560550539619538039187481771001333967681038135790962915359\"\n |]\n ; [| \"12599554983931780658667521993267051645893868162155451498896637831795673118184\"\n ; \"1743852770826535536371230785504182299307419480962231494027537273484933148311\"\n ; \"16732518316750597282164750160114357349321948404345032126728303794088049194652\"\n |]\n ; [| \"2939281672959978006600800750725734354669446788664764296199685579097815688131\"\n ; \"556549314727718724918645466738763616425350766385166232734551188399043650782\"\n ; \"6329117812888271765311270770521948075037705083688439409207121873030159665123\"\n |]\n ; [| \"6923365867589651412567397268415595797793475737512742162240319715473926481537\"\n ; \"4709424083348196884624344278997759837872647743148178850362091985071988205427\"\n ; \"1605876544033197953000953983514955993933721338350067171290806459066306025695\"\n |]\n ; [| \"4856902810419335425286300966705023110125381957049978608074194350995662024158\"\n ; \"20115199687715104656653685599631056012389662876070860842940278390288575808663\"\n ; \"22603228560902176600736298140950778622069342058615699936072284883863656072632\"\n |]\n ; [| \"24638889469288846994071707357580162402582890839221549302411376340642923220642\"\n ; \"8913206227935260631493024400945766094870661822141101533706907528294845461904\"\n ; \"8927637538483897027107933030206270470499387407187148996083180177802476521625\"\n |]\n ; [| \"25384650098348911768966273053118959028169194481031323865282329732266030144680\"\n ; \"8576715726771771074868969966299138879569870568699811773298590613391459414307\"\n ; \"3736564798057387316276742408343458912069444888643530254776791689428332583857\"\n |]\n ; [| \"20271224536548381827255516591952574401260411805623699585521321246109241454930\"\n ; \"22919819358488746629260266084595897095209320929848482502446393294056491878897\"\n ; \"25806583473442384033721287178211835499298441266111076622895704944892288698730\"\n |]\n ; [| \"11271425654462192981130104009501267954567715499141722773571838183810298369617\"\n ; \"11963379853558729949243781995772428902494203393999693908696977832618218983729\"\n ; \"13559702535330349895320048426685665280396765028909072427284399240094315358267\"\n |]\n ; [| \"27798947305954309531282132451491992692211979630877274468503798794516296093624\"\n ; \"10139836872400883770038180190686397055576624900289129633646571009821193103303\"\n ; \"1681175063131614831383428140062517416675656042319902366945851342455320095975\"\n |]\n ; [| \"762311789472828450694939050895584869062612821719579283252590387322583966709\"\n ; \"2491291459395889912950418486840554679531585085810901240245257580168300654138\"\n ; \"26335391344920052134408519665978324228030775533115901754595026922650621387203\"\n |]\n ; [| \"5213934155193667555020919712276789476025967849892310766358967009263904788906\"\n ; \"21596654192879006807545262299640391626541355389417053174982949135914632601259\"\n ; \"11543651420409105093285035822258612547933041509768934342943688172902948155496\"\n |]\n ; [| \"6912476548173319038280387824458412456324099644037049670165470126637201776352\"\n ; \"1249979215389391088361432819941458017849901973474233553675756693352168310261\"\n ; \"8800672549391869855287240050462700541180857572619168816793782094195159154680\"\n |]\n ; [| \"28839355932304714762685479310377995008738258609935766418698284661589499598024\"\n ; \"9159710460329873378525040285653524567247412401936807205880030247592503719192\"\n ; \"3169998943567105341123452675041701435607857255203848874399754618805253622740\"\n |]\n ; [| \"10847531416223195148660243132827532434469902981120107367281282638460589851312\"\n ; \"14278009698362110794389980561773702824351567830428544578500093225142170712282\"\n ; \"9939277074183953713358210481928994846174442435889738896177490616666695764405\"\n |]\n ; [| \"326943879771829400219165757090427396897467323936588117324383366036029433704\"\n ; \"9374630771131918886890707351323606275428692663736893032376887751531034826056\"\n ; \"11290359581308816011059133790190691320815711617432693226101285885253555535565\"\n |]\n ; [| \"3911773409691474638225302262361438181771774863685935030974147227178932759469\"\n ; \"22956796290890941726039085400420127418179229593189943764136263359967499205095\"\n ; \"24905285680262095209614295868376139501135921243025528029309869104981722146091\"\n |]\n ; [| \"15396187849300264600949181619153171915541270808841426006223982193824166071313\"\n ; \"2021103552199756934225861737484570471349644013573281450873950919842892776230\"\n ; \"27806074863915516268783086994108941110298172438899852542592001290302316983529\"\n |]\n ; [| \"20850985044745265985587285429983550433472508184202273658904387230312500935146\"\n ; \"26750188037261381177305438051189173436844269300804365655670910061723402311840\"\n ; \"5346322587722845563528031827169305184007234875695836707960307122364690080342\"\n |]\n ; [| \"6220486513127683592919002338026088751244535283268014603675952476125549409312\"\n ; \"19903676557766566961511712707831152869695369024367352451363145661501930906935\"\n ; \"1180890285168209978184781715739655933965222804468162152537914819015316336929\"\n |]\n ; [| \"14777748415006576804127517907788573988371775407557947805900937323975909847953\"\n ; \"20105710741166769379631189443035554033451548978342191459802351018727518338375\"\n ; \"15000279473920339785489843141790752670514139742561441953224274301751356279088\"\n |]\n ; [| \"10845580737423146858413611539996656798831260499192914333052323948287095325896\"\n ; \"9807299453661141796892511560669448305233135023678812710641622817525465476789\"\n ; \"18820070346872194506701007873416449730211513161354530152730232231128055179020\"\n |]\n ; [| \"21552635109132824636995550194415349978714050563816356406378271654768042443914\"\n ; \"424252812084212000584148587569013716105926976846895922827871912164530554017\"\n ; \"19731111636912344832419806270898792823432039785853920997930198140374517037138\"\n |]\n ; [| \"22034227457855960657032112217714947497269347815575055932350706059498866808825\"\n ; \"28900549436482563321706115220019073654618056963014478327301367425569435393025\"\n ; \"9690323567346977726143631917040896368566497117131585170975102457752911385070\"\n |]\n ; [| \"24901777589153809722090856106322215040853844303892027345081846927117655474799\"\n ; \"24618629228062397341252905498799061176053328430774401516486784312004562743191\"\n ; \"28607940154394052066154355049458241016994677703128094815451893517962352487603\"\n |]\n ; [| \"28028628276659162325922057320540093432599391103119722511477699756313028345898\"\n ; \"22855357183685501398606162033830514721290735737703014103574096507164859341813\"\n ; \"27834367819357692909285882545810100377631199500915361384737671966983146025809\"\n |]\n ; [| \"1152586797671427538966496719385915934546059520122802470413322678492958894682\"\n ; \"508384107034063705486611598325755112413731704833369868231768120077490444630\"\n ; \"19300657361561951607131776332671479212098250434693263049514294780805629653473\"\n |]\n ; [| \"15470960985350481400842167015023775571355492800121582793999502093397427698383\"\n ; \"17720942074350206208330220964590971549266016335665304491607989853024314401251\"\n ; \"28851134571887486837044103758388058466256575668947796957305978438699899353287\"\n |]\n ; [| \"3578785053164294612963526112344478663211208096085744338409755465254754875674\"\n ; \"21326437066553963598520552760114586864776638322466352011871692222662384645363\"\n ; \"13429745934270095487255860144847939327740721270623398376981782305947706095670\"\n |]\n ; [| \"26319050026331552836426774369067652650059182744902567571224496539143745005789\"\n ; \"1078263435617676875695007120605477838039487913270059992176509301150569425787\"\n ; \"20512958822951485066323868584206248027312484777844371817239233161574729401619\"\n |]\n ; [| \"3439862210936907243622471091733755342416004198449084092526552267425888891334\"\n ; \"26344024615038835357968358502500389300221110985359344438627145422128854936010\"\n ; \"4407509671483019180323111663733989542669030294423331160640503012574051046463\"\n |]\n ; [| \"23686502687109748462558238297713453205336655550865311005650407347470798706276\"\n ; \"20935865617522634258880604534809753050761951325231883554583651243657755177384\"\n ; \"28068466419776916874263313788106583531149883580106732537932576845496874610760\"\n |]\n ; [| \"9340583216031797210406121496934538779821608465213537538754368179509091190496\"\n ; \"8378478185794583011191561708485020796460113225246093188020296866408689405447\"\n ; \"13593729876983630500293152970812869181694169206857373826104652065849275824904\"\n |]\n ; [| \"225582802476164593958918341784756417052231176877435466478201328339339298792\"\n ; \"11190000628324239936372479652026730262762535908110580922398549511844970564726\"\n ; \"14408510109047970600383365920163973974300511112581396474451952115423633760669\"\n |]\n ; [| \"15419712893693617903799150033771605514243986042167614240262941635002474003403\"\n ; \"7731439925760230991749404015249576908754514348048350297750723620909282729431\"\n ; \"19666770682774865023295895307812388197776507921636129891377759111914829255638\"\n |]\n ; [| \"8087212899093356791510655283154899277086785698103236127882829927797366304828\"\n ; \"20433944315277380264641847906582628806193939008300369182185651050982835630279\"\n ; \"19313210645126659866795487832507797079135783289793587088105157706081916299559\"\n |]\n ; [| \"9123328805166387524465533579226697545839760827737590290669661663774141633743\"\n ; \"3879879306261238409785977281757250639343229913301993681022375404219618433235\"\n ; \"9517409716012760917696192179044536803939394129766651220028362590735480122573\"\n |]\n ; [| \"20332463768718929699130730432447025575189976076426482297440430469341755042921\"\n ; \"23053672884236177934514268600149479745125027580775805056144654269680148757624\"\n ; \"25226946353885521968414981773406166683897441042573998588821906686512894266029\"\n |]\n ; [| \"21175609603299698220053961274718080893444373067044100451463712419133495237612\"\n ; \"9553694240553762923597118226736247618469252203348132132110825914961792198835\"\n ; \"17843854580091429191163038608499805869715159461506741160730374911681651289471\"\n |]\n ; [| \"14269966061002750716248007081424385164175906346684599134425437034554624251236\"\n ; \"5362620995145057363259413950799285152609317352806427035690937773014391566299\"\n ; \"4205064533075248547624548681629884406823264917512221686783667975932358100596\"\n |]\n ; [| \"1447928410709031033534935853216514556147486755632766593078722977427728960730\"\n ; \"28245240921931699941506083221177914425757254840948018801597419359119971216733\"\n ; \"26525902932142017663120008236364707593713540498564605735573010501454347937720\"\n |]\n ; [| \"7368631296987951000711115613504553604704592237398914353915901403543114662889\"\n ; \"5554881053965220973295749123586734879290036494602787556161693926447302760390\"\n ; \"24967171202016264042634677694667363841007103245517469364248634966946756557992\"\n |]\n ; [| \"11573826089465863056429265227887713664716641745106347139398991914839486636523\"\n ; \"1937718699958481554769675564975554369566343919737475668546953656937087754563\"\n ; \"11930922536251020493907238369241004043321211518887691790013224522248735046033\"\n |]\n ; [| \"22785017658870359000526032391904855161537701900296638953930381770914415145341\"\n ; \"25976628305796286420142020978093161249350138636110131585936062956834855313329\"\n ; \"16303236307764870561352823146290518191951038219791428310990760657710142544538\"\n |]\n ; [| \"27093108982678491292736852279722292369809241753037402387831341673617292355433\"\n ; \"7240163250117019016769197875995700032806501977645639130984508545602324096827\"\n ; \"22203724525852948038550437387972982668395471437091775649961488356662998264151\"\n |]\n ; [| \"4684246545018636131749425719987566020282183864196151512373949996479685177204\"\n ; \"25146969866420782139590198915491672984778622065064131222228045794185882122026\"\n ; \"27592425452661098730505196328609404774740926022433368462118081059212268546033\"\n |]\n ; [| \"17586009379821990524587867681671154015571782654760878221394286500330572879956\"\n ; \"17466109782412583174035666757463650324907665895615102404350838404505294814861\"\n ; \"6801099680371208186449438911369486272231733437775451500294923992271849771500\"\n |]\n ; [| \"14709234089749348360616371037761032504562743719673952659049173960937006221457\"\n ; \"20550184887334781662092751106487190173000191851604597380877613197870113909079\"\n ; \"28406290890506223928300453112417162962784806964069027890524481548485194752847\"\n |]\n ; [| \"481714770023051785525400834238336329808423276768584726829869103876837700377\"\n ; \"4020991797205864659257764480061098490500855823437474389403990553320209934398\"\n ; \"16337095167623579562847225379575824048052657014596464618336659839371535688692\"\n |]\n ; [| \"23217111278739825984846557926350102803991056777137304871503782411490597852276\"\n ; \"12165535003710678763048152747651928445434323221944097116678948970350369208929\"\n ; \"9488689094750447786105144162385165112898472220919295987197253237633013659895\"\n |]\n ; [| \"15982980312773671675473213613073972898714178082762602910121113887258972139946\"\n ; \"21878657311388335888708327724490657766902944759667044620416025845959804126630\"\n ; \"13675090710467970179628129651886021836957928350486496127049130621993923573755\"\n |]\n ; [| \"20917518447937574010663058701489181063333313587680044759711243380728520685863\"\n ; \"6170213040301483568981693148798365424121650111680781917289361228522864615996\"\n ; \"21775919999815502126259344494851143760329007416636852564546368286124982536695\"\n |]\n ; [| \"24368490522730194755777521472193388991367336341364002103399150275833011922423\"\n ; \"23758037332911549734847840203343330629256629298188143399488142378421247847690\"\n ; \"27571203431800228771338832670745356383939659914478358343820683195821147658740\"\n |]\n ; [| \"13755890941050195595545518932064686480206338615096777475340391971161142758063\"\n ; \"1146646539267290799737842332448542194132747795692489481869657131476583545261\"\n ; \"12804413470423903667943767263817101023115585083457063162343920360142649266798\"\n |]\n ; [| \"14409531300005419187223363160445506887342750079089420367658939335895822993543\"\n ; \"17814204056137953075459933026732902773040596329028927521838357681289997118113\"\n ; \"7817950203232955618618957010364419159456278143380878513604058657652018062980\"\n |]\n ; [| \"25960264684815433578190462022149634694335702464818992353329781703033013233121\"\n ; \"25759640500090985800437893091627346304260382311106694139575298427306966520523\"\n ; \"28367407529609657391892674962602105816261356754665670959257133180337999840539\"\n |]\n ; [| \"14266800571483937742793133924056626153889815742052966634816685646807339508312\"\n ; \"19127339481560024189602206365457486575195002728494501053095019117702139872893\"\n ; \"28519789563308940253093752790854817966629126140155280689836626891738001080737\"\n |]\n ; [| \"6956040341676069594538770374637867923851690699633394576277451833826951657961\"\n ; \"21005839334445364578511922473026653470661503168441639424115223139672665178130\"\n ; \"28315945273881727033707996355494725432549327504432844662583768252508930919892\"\n |]\n ; [| \"23821368050370699560443847027609270446880531147779436118159731211758008434917\"\n ; \"16481474195192864226077436336148187210130651787958956807674920780544075759296\"\n ; \"9201162478838874386717176037702794693750993812982695310231747629926752684935\"\n |]\n ; [| \"28632598467805640977248891280150694716252721359271588938464824193707123356074\"\n ; \"26685464290112784835718410452005685502357915255553654159429733217095134319675\"\n ; \"23238436156616628957271098742219023373736106288667637787431116054734729902810\"\n |]\n ; [| \"11100700451337429910479488290132218019001384186778460632129760648736641453089\"\n ; \"1514360569355020424898405719576361021811778172693203007691280959952152364455\"\n ; \"8340047814157949706510940907075594981467165368035215496966506269014211515161\"\n |]\n ; [| \"2427640653249618892553580189088976454401710146993511837542094625722279344011\"\n ; \"13594733327028460655848011453697829703783521855510653296924838920678502849608\"\n ; \"23299557907058685778984064294190866024328373590131005250950142719507348823505\"\n |]\n ; [| \"16957366136159159628470985738911466666552608209993423872602970163277075193826\"\n ; \"18413473853520613049315131192841305891076833008669861411383562686504219287358\"\n ; \"23006926050889222476128897576830486416666235970076803315213892539278411622015\"\n |]\n ; [| \"9774905316340561579539853883151948424138741303135183297579387042285531085133\"\n ; \"10269962303207382593854468302115992150940915300353510160768219325150644267118\"\n ; \"7959157234270969248940923336563675290410277851870343572948477386731238161393\"\n |]\n ; [| \"16106024964504098503571852149534027928523108637339842287012373190722613251659\"\n ; \"14745173385311451223498911097599033554863252099869795844775385009273683860264\"\n ; \"19937960969760569200449808442711281818884901583558873199752602417155970563987\"\n |]\n ; [| \"3182366146375526747362994559814691338395593175949415378173407263876720083397\"\n ; \"17413302548292738580314411603626834416295685927950587784515273510105438873422\"\n ; \"4889919393105279580426440996922797206571373750340190707744646290242059542853\"\n |]\n ; [| \"12846868702289135169703545726353247801195875942556949295948719366264621666233\"\n ; \"216026894661943610141047365076631027216797294256741428193225490408409896066\"\n ; \"5594507038710796719799954595203002154918429779115131548267228293545608955934\"\n |]\n ; [| \"20683325187150331608421945253309437504612179745536037022444222877738935657188\"\n ; \"17258155199327171857088567149720370973460517702673221805327154937215155098037\"\n ; \"19531451346903375647980488842525266722395393577734760487171780808563121552715\"\n |]\n ; [| \"15001316252470008872398592005036567799341341008679319658354851032874333308382\"\n ; \"3153366364932652911576884248299389708958131128720414599588818761136290661667\"\n ; \"6755239607153943600624506592209826209761618621309160929893160538996653160964\"\n |]\n ; [| \"27386913053417648783169595109305635785586212401824032172587510910095445670008\"\n ; \"13255419335681899162220762381979787288418216927844199356802168847207218078328\"\n ; \"24056932697318807312802542300271008041574260214121915600042800629313367235460\"\n |]\n ; [| \"681706469194140471433006526218256921616949602161281492934799081124952223492\"\n ; \"7859466024237704991714057608591467007441884809553786534483120034131115786526\"\n ; \"16700668341177433681838948975596616692527529309395474903935090736709940070878\"\n |]\n ; [| \"22901316653569929238119228745362176008602504925113946861459962514753719309663\"\n ; \"22640283367220911539563798732800666806616130576227469449706008775827807382817\"\n ; \"19535281588527177916573861327698030605390832518994091195537441015284187660038\"\n |]\n ; [| \"24027911193734335746676746844040947617820732337092851583866178947775548114262\"\n ; \"18133232728995811983770470174587129261332348411742016303225452920487624098342\"\n ; \"5194749654862040835697949936835668263923802179629880492924388865332422989363\"\n |]\n ; [| \"9316005463786577585413113516915677504827184958655839058352363543312786833160\"\n ; \"19044257614252585758763026210126521817485691264322479305708941715087727988354\"\n ; \"24488455675278660807809390650162487037017599485528141481545441190036504950534\"\n |]\n ; [| \"20189530657293446691983795945222508167625355746118650082940427940595276845732\"\n ; \"18164715324891407664606312435855154695754327590709603495801185914278567423821\"\n ; \"3777285533445984127387924239502713396887498568124548831616871789655039173588\"\n |]\n ; [| \"15592830182691848850373386427196961486282012390610273530420460470172877717683\"\n ; \"25760859528166610551872518774575759523111878433095409331041961249196989169616\"\n ; \"24722046352010883056709269730597243888430933191481739010765617998146349934086\"\n |]\n ; [| \"28753571052849887152802307457879116732346031260848508112338593673454875118992\"\n ; \"3001384261845987887110277211273546956213661938635022280612595622904841185681\"\n ; \"14677009419547603678203788843515487352782342288802842850372444676527117589395\"\n |]\n ; [| \"22844611608619408029685336179217843453642421101233912107898751889136663864792\"\n ; \"17906137102637384489732199749359922643081810160900805140716991796711023316200\"\n ; \"586544213343455846993111183121079851951145071960141918284223009850760128570\"\n |]\n ; [| \"10073022737051199071936469142782915912111557650707356761559885949095600793223\"\n ; \"18767707439586621911012683484743285554245197776295242644551355924169214852141\"\n ; \"4119962398253504109413010562733363762918650892359086980174059883847160426733\"\n |]\n ; [| \"22822667561075354253870135521524118501968910357712769905157593725117077725730\"\n ; \"19021134546417697443807407377942768385512805335328886525219419127991328099808\"\n ; \"543520545955418275520704370531208732549254996101593838150191956610790962041\"\n |]\n ; [| \"13465682039988507334664785354077591628283934378748051390584708440723246405022\"\n ; \"14968258475921764664246292128413258686551060309754574320898450232154678954678\"\n ; \"21308271006956028514569991019983954873714018423377636189886404602491045197837\"\n |]\n ; [| \"8144208462590654621513596158704608446866068401332835980335197042714849642337\"\n ; \"20834284501721431645327510539019601687008489803392802952240179181017009408562\"\n ; \"28229089440547774816202807517944174133449953515318622356237408090506536035121\"\n |]\n ; [| \"4701139152778460212311525289989698272661680893554566356761097167593286071097\"\n ; \"1311177055788535572979185179079106285448805711141806719704208925309029338758\"\n ; \"15261537101227695093574937572139198753629872383884947512058428039104133367921\"\n |]\n |]\n }\n\nlet params_Pasta_p_legacy =\n { Params.mds =\n [| [| \"5328350144166205084223774245058198666309664348635459768305312917086056785354\"\n ; \"15214731724107930304595906373487084110291887262136882623959435918484004667388\"\n ; \"22399519358931858664262538157042328690232277435337286643350379269028878354609\"\n |]\n ; [| \"10086628405675314879458652402278736459294354590428582803795166650930540770072\"\n ; \"17127968360683744052278857147989507037142007029142438136689352416106177192235\"\n ; \"14207324749280135281015658576564097509614634975132487654324863824516044294735\"\n |]\n ; [| \"3059104278162906687184746935153057867173086006783171716838577369156969739687\"\n ; \"16755849208683706534025643823697988418063305979108082130624352443958404325985\"\n ; \"16889774624482628108075965871448623911656600744832339664842346756371603433407\"\n |]\n |]\n ; round_constants =\n [| [| \"1346081094044643970582493287085428191977688221215786919106342366360741041016\"\n ; \"10635969173348128974923358283368657934408577270968219574411363948927109531877\"\n ; \"18431955373344919956072236142080066866861234899777299873162413437379924987003\"\n |]\n ; [| \"5797044060651575840084283729791357462720161727701814038830889113712361837236\"\n ; \"931288489507796144596974766082847744938192694315568692730730202141894005205\"\n ; \"13659894470945121760517769979107966886673294523737498361566285362771110125394\"\n |]\n ; [| \"6076231707445968054305995680347976771585015308155855387339303513025362636128\"\n ; \"28822740034050339685362260108484262889265034407340240070058997651710236456303\"\n ; \"23420266473857869790486107029614186913447272961845992963194006142267563993493\"\n |]\n ; [| \"13753917374184785903125509246122783296344288469304898921025291716613575849357\"\n ; \"22396739346703340038555577564698139382745239004673153148674304627904081092826\"\n ; \"13064238335532551154986111986409392866270911640785653458047811526842088084911\"\n |]\n ; [| \"23165923875642452719095776619341762858050322341374771345641255745672274104746\"\n ; \"1876216571769482372914291210815859835162659440705283782713345335434924136736\"\n ; \"25448252060136178247213604035267580231762596830634036926922217427938159849142\"\n |]\n ; [| \"2161875315509206970842862195937323600322108268401381254431163181777726747153\"\n ; \"19159855698625842998331760283165907305622417625829203038229273729196960321630\"\n ; \"24828563875172432296791053766778475681869974948122169083176331088266823626561\"\n |]\n ; [| \"15959479662608710141128458274961057999257961784282074767105536637788386907463\"\n ; \"8006369581283017287449277389162056290714176164680299906116833200510117952858\"\n ; \"18794336794618132129607701188430371953320538976527988886453665523008714542779\"\n |]\n ; [| \"19408271715954593722501381885401160867835377473312521553027032015227895029571\"\n ; \"13654747284005184272412579731446984220568337794941823533879059135026064413631\"\n ; \"14094055032353750931629930778481002727722804310855727808905931659115939920989\"\n |]\n ; [| \"13241818625838429282823260827177433104574315653706102174619924764342778921524\"\n ; \"25709259239494174564705048436260891089407557689981668111890003079561388887725\"\n ; \"26866626910239634723971078462134580196819809568632305020800296809092442642381\"\n |]\n ; [| \"23886826350713085163238005260075062110062681905356997481925492650252417143049\"\n ; \"16853602711255261520713463306790360324679500458440235992292027384928526778856\"\n ; \"18444710386168488194610417945072711530390091945738595259171890487504771614189\"\n |]\n ; [| \"16896789009769903615328691751424474161656500693270070895928499575572871141439\"\n ; \"23842266984616972287898037872537536999393060934879414668030219493005225085992\"\n ; \"24369698563802298585444760814856330583118549706483939267059237951238240608187\"\n |]\n ; [| \"25360195173713628054110426524260405937218170863260484655473435413697869858790\"\n ; \"1486437708678506228822038923353468635394979165769861487132708983207562337116\"\n ; \"18653498960429911228442559598959970807723487073275324556015861725806677047150\"\n |]\n ; [| \"18878179044241268037057256060083772636369783391816038647949347814518015576522\"\n ; \"178715779905629247116805974152863592571182389085419970371289655361443016848\"\n ; \"8381006794425876451998903949255801618132578446062133243427381291481465852184\"\n |]\n ; [| \"4176946262813877719206528849579392120806054050640974718891398605746592169324\"\n ; \"16376345520728802444699629729684297833862527190772376028981704525651968727081\"\n ; \"8399065769082251057361366626601550736334213197703006866551331927128775757919\"\n |]\n ; [| \"15435308585611812393531506745122614542196708285088622615406141986333182280857\"\n ; \"4082259282787276939431186930090898350392871145699460879678141552997816391817\"\n ; \"26348742719959309014730178326877937464605873211235784184917342950648457078699\"\n |]\n ; [| \"9707631711734344681918469569872517425107158187591261754498805460753455298868\"\n ; \"27910768846011709391567916011595957279088224137468948238696800459136335473132\"\n ; \"20407239095656434708569263842372155762970847207558227886302782130015730063802\"\n |]\n ; [| \"22726225412881182965250630589245572283256255052470345984553083359461473893802\"\n ; \"12443967854426795490638709950679156338200426963050610832781263082981525248175\"\n ; \"27102543658848146076219989119639465430524061997280788166887046421706499775415\"\n |]\n ; [| \"14427224233985680214097547669945064793149553513421479297921556194475574770861\"\n ; \"22917454832925781549840198815703114840452733537799472739275668965081704937832\"\n ; \"3455076056123630366063931123762198941796412458154689469887583689725886013901\"\n |]\n ; [| \"4513100023937785913596662867311227004762025658663076805918211014066645403017\"\n ; \"18187619530784075723418065322038024507729605774832001333883311123910954334059\"\n ; \"9447065431426150382325592560406989926365684509675374414068135115024495130938\"\n |]\n ; [| \"3227816098015819796753427754968234889554095489076864339942014527747604603014\"\n ; \"14798316759185072116520458171957899889489461918408669809912344751222514418582\"\n ; \"23013904852315603905843158448056763116188801262838729536210355401378476650033\"\n |]\n ; [| \"20979191509934291452182967564058656088941447895799901211038858159903580333267\"\n ; \"20772973010251235271448378823573767262405703078344288856168565499702414379868\"\n ; \"10105446427739226002497411811738001382334316505480517822035303561899927603685\"\n |]\n ; [| \"11079074761356717003579108002319997196881121172538617046865136940931215263187\"\n ; \"4693927775411489288330326150094711670434597808961717172753867514688725690438\"\n ; \"18581720304902876944842830383273503265470859268712618325357902881821721540119\"\n |]\n ; [| \"3065369948183164725765083504606321683481629263177690053939474679689088169185\"\n ; \"18515622379147081456114962668688706121098539582467584736624699157043365677487\"\n ; \"17563088600719312877716085528177751048248154461245613291986010180187238198006\"\n |]\n ; [| \"26199746176994924146211004840756471702409132230831594954444947705902602287290\"\n ; \"7576136600627345523051497639367002272003104458453478964661395239732811642605\"\n ; \"20058687874612168338994287374025378897088936171250328231848098497610185784281\"\n |]\n ; [| \"16894722532414195606958290526999761110785277556463400588047573469106594850228\"\n ; \"13961730805696859614283621225672002906734926278118993580398533742874863598733\"\n ; \"25256842011135514243352951950573936602906198374305137963222382546140030647211\"\n |]\n ; [| \"18530360047537856737482157200091774590035773602620205695980247565433703032532\"\n ; \"23014819965938599260086897799541446473887833964178378497976832161473586995397\"\n ; \"27911426213258307990762460361663504655967992659180759140364181941291843542489\"\n |]\n ; [| \"1067338118323302017358103178057182291035336430305886255160210378977812067042\"\n ; \"17219092885519007424608854460610388434712113621163885775309496940189894433620\"\n ; \"16432921127615937542183846559291144733339643093361323334499888895135356545408\"\n |]\n ; [| \"28608851042959977114787048070153637607786033079364369200270218128830983558707\"\n ; \"10121629780013165888398831090128011045011860641816380162950736555305748332191\"\n ; \"2348036340843128746981122630521268144839343500596932561106759754644596320722\"\n |]\n ; [| \"16619881370356823200358060093334065394764987467483650323706184068451904156452\"\n ; \"2302436627861989749837563733434625231689351276818486757748445924305258835336\"\n ; \"27514536540953539473280001431110316405453388911725550380123851609652679788049\"\n |]\n ; [| \"9459277727420672604737117687200019308525004979918488827092207438664125039815\"\n ; \"23425670740358068509956137586663046763224562225383386726193078231034380596217\"\n ; \"7641885067011661443791509688937280323563328029517832788240965464798835873658\"\n |]\n ; [| \"9579420382351699601929202663836555665702024548386778299996961509578687980280\"\n ; \"18513671386572584282611234979588379470994484682444053600751415262497237017703\"\n ; \"24923151431234706142737221165378041700050312199585085101919834422744926421604\"\n |]\n ; [| \"21131320841803068139502705966375283830095161079635803028011171241658723560073\"\n ; \"19208476595309656066589572658712717685014329237892885950958199953675225096566\"\n ; \"24023185216737416080949689106968568821656545490748664446389634158498624398204\"\n |]\n ; [| \"7510552996848634969347937904645640209946785877619890235458182993413526028718\"\n ; \"3694415017252995094553868781762548289196990492336482360084813900937464847638\"\n ; \"9219021070107873028263141554048987416559034633883158827414043929220388719352\"\n |]\n ; [| \"5058327241234443421111591959922712922949620710493120384930391763032694640881\"\n ; \"13148252221647574076185511663661016015859769210867362839817254885265598775418\"\n ; \"15186790492457240277904880519227706403545816456632095870015828239411033220638\"\n |]\n ; [| \"2775942914650502409705888572245750999561427024488403026572311267798009048466\"\n ; \"6277965230841030155341171319927732572492215818164736949144854827643964384893\"\n ; \"24144742149845235561087977558785057713814731737434473021812189457617252043745\"\n |]\n ; [| \"25789129719327437503403457598813971826156253950521984610569937361506914183550\"\n ; \"21500534320778995945845999974779950304491968082325255355181901574840373597824\"\n ; \"17185359848218837018503091932245529880546896465437232425673134558221638601375\"\n |]\n ; [| \"12253896579078110143384981818031883112606762215016553811786428215758384195713\"\n ; \"12956658260778456372481429232709881794962204180363200699121804724437678625542\"\n ; \"3023603786717368708677300377055384474816569333060487675635618249403832078921\"\n |]\n ; [| \"4186492855716808019562789862833898284927736051002588766326482010810259565130\"\n ; \"4263939782228419774639068267872291539552889472311225829898746091327730032923\"\n ; \"24068843626280451423530509388397151179174104901782990365720205643492047328816\"\n |]\n ; [| \"14564937827374621319716285527475223392664010281568256859627186463065876537730\"\n ; \"28367596550218705971881480694115935470211319172596432472834880507822452927283\"\n ; \"28712267437482356021504544448225827500268648754270274754623969882031853409874\"\n |]\n ; [| \"4542596163006916397403529184431773692747461300288194722982487051249951403191\"\n ; \"2530461821259252672899452671728393208543894014761816288817584587718369998371\"\n ; \"12886393063011539390567049190923398676964700147222878509238966758839020897414\"\n |]\n ; [| \"21593897590707514492037699253654745501762191795293908682495110982956631870528\"\n ; \"13233005790593128135480716846773978578237145313006994631606474472023504621256\"\n ; \"21621863098292803642478350494794106282518362577273973885587684567452726939909\"\n |]\n ; [| \"26068620073001644720969640099644251616742620988609091568084348314770436291745\"\n ; \"18248589586787935500122854210401321966459127818593446990365211078521058875685\"\n ; \"21247134484403265289037859533347798468858819117600251067578809852124865474448\"\n |]\n ; [| \"7947383127165915366383984718363902897504221803836013123394785749404572432524\"\n ; \"22173041014621867335598230447618036223462011647696367239478182269973488867154\"\n ; \"16773227734018849308448505860847939069870370055633571816925675705713088305139\"\n |]\n ; [| \"10708707957340055662073314227607620808612686977606082605219160019699644826999\"\n ; \"21249897193797038261479589555720746994050836195265348846222835266344091683000\"\n ; \"12581195059139097540117398803363514148192715293133623516709277290477633379593\"\n |]\n ; [| \"19779599816866992123290302397082614570282926215253589712189610064229996603178\"\n ; \"21749216503901548676985371189807470207364320167486559936962401093285243029177\"\n ; \"17600045923623503357380202389718735904174992978547372448837488832457719009224\"\n |]\n ; [| \"2732872979548118117758016335601225525660858727422778256671975055129965858636\"\n ; \"13703031005128062046175331918702218558750713240446179585947851411173844703597\"\n ; \"28447710105386636841938034820015573492556750872924193415447818187228356409281\"\n |]\n ; [| \"28539960355005748517007309210788803416171161412204526246799800716567376494244\"\n ; \"21329318452221893900731030722137844458345358926323127858742388587761302609863\"\n ; \"28135302149599894709369178097439582767613940517471323224020113411362601191873\"\n |]\n ; [| \"24980774120400248734054527936006392540889095705961960837980443629260392758683\"\n ; \"20339911045808632098936066397942175169549806052128535543540543556255197716643\"\n ; \"7929293103930252545581851978492699598413941396422930641071359388697302362494\"\n |]\n ; [| \"8911092207145893152276662096451247820054843777071569723455408545101628926203\"\n ; \"19648860643145256523615441075182036100116634560394529500146405733687718224516\"\n ; \"14635387208623683806428528837466762532853903031263830054986064902455379735903\"\n |]\n ; [| \"11555212214346132926966321609673228184079851030522218543981385635403167028692\"\n ; \"20896918157639814425520058178561910811657326967880217845710779511927814874973\"\n ; \"4650158165912007049140499755153804318686705949436165235742106170124284287326\"\n |]\n ; [| \"13880660273492757167295696447853232191657893303250187467329180558670697369810\"\n ; \"8043529172463774320604378774840863923445982272478964686447801046272917236836\"\n ; \"2134399296482715903442913099374581981696436050603410080564843555725771329441\"\n |]\n ; [| \"27320952903412641133501507962185246982787769547770982814240701526492601978122\"\n ; \"23417491374379751329394424924400186404791519133465537872457405970098902747611\"\n ; \"17612427354278346772575179176139417348059847375297761006336024476146551185903\"\n |]\n ; [| \"10710998507064742997612080847223278109404482930427999113323732519626499166548\"\n ; \"14958094513415797513745395709487730603918953350067504982704138489305723550923\"\n ; \"24096319595904213497633343966229498735553590589105811393277073274927955202995\"\n |]\n ; [| \"17983724131200292654039765185049138356840415443160477259330748730019147254309\"\n ; \"17598096800487588874709548646068838880468456205252324677357706597166777506441\"\n ; \"27420647821110229619898200875848631488422182349567475956209153112306555222281\"\n |]\n ; [| \"448538544835457571662601142415301047108854812427100562339376187510452313026\"\n ; \"23494184556634922103535803143214434479598067155171780264810485708203176455201\"\n ; \"22626342941879801989161990529511235538216563009907378573817996229389756621777\"\n |]\n ; [| \"26128268137723417163973860961686381960826033145738852158792607959175787222856\"\n ; \"20225791828042873305317281581105429726352058325970107209484198122707862156597\"\n ; \"7538871133759632802857159609785118198934349221046986784429069814655215585732\"\n |]\n ; [| \"26184554861259642274153262777073624024579929401668865520166966302070394487366\"\n ; \"28755259264665180745537307265993667261709206143628938749669440804401623257679\"\n ; \"11896066093033549470312328497237649508068258723531931099214795928200015717321\"\n |]\n ; [| \"21657721599978732693249012287058163532690942515202465984736373311077240614059\"\n ; \"9214914097169852704753116653702415951907628005986883140609006971322091003693\"\n ; \"18710111680849814325169297240208687402588261569152088592693815711857504371037\"\n |]\n ; [| \"6813635166770764528979084175325709935892248249948967889926276426090222296643\"\n ; \"20546585456429436268067726231902751119458200511988152296570567167520382569278\"\n ; \"20087466019194902429054761607398988292568594301671509779549344754172952693871\"\n |]\n ; [| \"28185105286740691904534067831357491310995891986363455251895371651360605333143\"\n ; \"10108348212894231193041286244259038275269464277821588425688314560368589986063\"\n ; \"11433633215392393209829215018579238412423821563056156785641278458497271271546\"\n |]\n ; [| \"27870881917195016999862550657996865268956893566432995492427618003637597051321\"\n ; \"102309803677783876701097881491240456320211833502658383473112057006867019389\"\n ; \"22844040227595875612525628393174357057929113317578127744718774517498324646590\"\n |]\n ; [| \"18364790233947478619325319418813215212267974311771564959136180502266118026133\"\n ; \"2480624341921718230432383518425561514824501138863702825916674641657321180841\"\n ; \"16778939567530361665956758171503829349658551798564323167725356065198936433124\"\n |]\n ; [| \"11947564511486966895926950599696532964589539443187518177489990556481125699966\"\n ; \"3133187646540385483015602955087323554103587039123577645562801570574691666057\"\n ; \"27704797101265438206569218421707753788081674727344603874614391656565567951541\"\n |]\n ; [| \"13001484695584753475562184349533365512515447041450030471627087395341039487710\"\n ; \"477322000667279478600757543806155989948171541982639893984064422067850617496\"\n ; \"13913755821658634147813329813115566967428755223601185963529801459396673113438\"\n |]\n ; [| \"16621869429023470107454028095846067937827722393398508604914831452950874033411\"\n ; \"21755744236927410239079501831014076529931327263341620300431356747367343619046\"\n ; \"26538666591151124505694487799121414506088199961481579132019627484065014831180\"\n |]\n ; [| \"3066480818457008068617042549071052338581291837882909165666223566402713429090\"\n ; \"16182268213934119294035309949459684472027705439038023775276926916166831108357\"\n ; \"28907604876608422892474268478706783033050951245339691569015166507728369585190\"\n |]\n ; [| \"27973960109508292680965426133498827831691369851701664449575719912259359998113\"\n ; \"1456924360278399121996742356757866616312146358469991014696110099534285524446\"\n ; \"8234248752911525485438611255163504976087091103090603316695312869292347668495\"\n |]\n ; [| \"8716078950082339630026654067608811496722305720644485560320987802533380421009\"\n ; \"19016744645809919602099479306503354923553336014593353020688463619133130053825\"\n ; \"24379650661051444982012238084495990858827340608012118841005379796362233056432\"\n |]\n ; [| \"2245379544097631382062919677963998259142792890502492881341386639439507471783\"\n ; \"28788137434161061988371619554419440748189388934884757179010092973102292086583\"\n ; \"7187000185648741287953633167647835668543536354944774631102766873251849991238\"\n |]\n ; [| \"18319349500538500800225762827448369057030532278398270164660609327776487168142\"\n ; \"2622932985948021877314529887962683530522545893985767148345336304947201715671\"\n ; \"13805188629797792210337544360632964855143280581052079479249966961215582531026\"\n |]\n ; [| \"27457600993464082637917106210690168172469473943609357897393615707457194410878\"\n ; \"15448646156961779103834447043970817898237835202826003934642165760908058355399\"\n ; \"9396792545729486882231669677795667529746274932273033601723318032992363022062\"\n |]\n ; [| \"9927877141952679457141759789181418464292082444806533413864151258248124544859\"\n ; \"23827901395971835838179844085051957393677906360196119690926757794561937573142\"\n ; \"3273544693673216914876067527455588276979859627093391584406340272737391174619\"\n |]\n ; [| \"19571510438350300564152393820251652609646082150148656806391655428002614034315\"\n ; \"4458840243585913642400750597703353770666314833058197517675446022682775625834\"\n ; \"6452218213610300363069953741424106105609715382419342511693148495219793324457\"\n |]\n ; [| \"14558167930891460678441266912176752652821641543245953113671886345167213541771\"\n ; \"10650967986920075561478528461783351160938460620955779955379459848889204404950\"\n ; \"19990009778942542934049216419052172134625404062770188357110708518621145688588\"\n |]\n ; [| \"26855242974447190235826233682457047761532515293146087151296725996543442567035\"\n ; \"22785340043356532865086769889360674409753343398766563441587096485751538658065\"\n ; \"28603049427449348335651629195385434188071937908693764500052489540779792538285\"\n |]\n ; [| \"20545812864989828913452616721240947168977365844984763819184465128164378967167\"\n ; \"23234068381345797209897730226956922073109641728569353961504167817770340037954\"\n ; \"26031714567641615877877111172701145299483019910006153132858512509897185854695\"\n |]\n ; [| \"9512221744061419790435674197238913998387834650389922233458121639503195504983\"\n ; \"12587458000103271975978240683793268604398305885278203470492658961734100340536\"\n ; \"9670291694005369437277651504604785512303147991710650505302465204429311229197\"\n |]\n ; [| \"26995526763045548800439747262386290359229145489609341602564040676717570935439\"\n ; \"23742712112104280264401317024221734961713400615669958343926511931219510484675\"\n ; \"27931469778579449247589315744656633392873808631802461175539563849884447358271\"\n |]\n ; [| \"20669006894143187877081688942720159738269397552445286314270368345994751825389\"\n ; \"26891772301075275370472640177651637211280740381619976926886106618375467277414\"\n ; \"28387986011980449959047232529988203397251084614417760995257355718700961696092\"\n |]\n ; [| \"6579105010484741592730389416372694666279917604793318157514380025250233913402\"\n ; \"11007035767869292700964744408562802781669930023548892567535397874932420229930\"\n ; \"981148366863906885900456473323410468923514528856216824044152942069412627408\"\n |]\n ; [| \"22213671088722307302576907504985884923571642958053627659840326928319445671280\"\n ; \"1318836216310789598614608105109389429335273432455224127576823891011367206122\"\n ; \"25586582796990779718352441955439394949194222626688223867952982491529809559257\"\n |]\n ; [| \"4923739488579452777913681531125585976446366144127161879759262506690369040090\"\n ; \"23505612338866210737103599484620591026802005128655081877133994175016351514827\"\n ; \"323887003859465324514901860965142186539600668250760639664361851354147799637\"\n |]\n ; [| \"10198923064967306784017949469108033682156920551672348936591491217255268794658\"\n ; \"9593680688139131432883442351722730169325112619984238956948153423155998917175\"\n ; \"27027988263960602112273050725720071355535922812577299127302015348825197871870\"\n |]\n ; [| \"14419883951157390867695097127684346981136020111885301573583640959136319507752\"\n ; \"5104414988075833278683649298543440897371415916271358703850262680431809374355\"\n ; \"24739655595299332818980677669648719986462429574612913501586844601377825836782\"\n |]\n ; [| \"28522818684103966731129743408029731246564480741348128436668680764518115102581\"\n ; \"21520350704208288978690888796633940487888044365108767319141211249242880355961\"\n ; \"17391005598311948834360476853940353239444383292422171321575043660157438608537\"\n |]\n ; [| \"15367833944125677011173327826570204350687925236257190051755087781855930646142\"\n ; \"21715073802090413714601069529558707101797361591183718695054701329871284436172\"\n ; \"8994093285353831008525761670339342200997965950202092028313103110478252647618\"\n |]\n ; [| \"8370824693889782161629525898408725452177580012023459750897244954935682978671\"\n ; \"16123253540853556024347150096993154278773652905830608614979368087152152043083\"\n ; \"3535380953353495025888433493640531836449699255364366295870140701379497967423\"\n |]\n ; [| \"6954518484798178646508803478426114267143074508396663899281411171704702743829\"\n ; \"28903134801897070276701950388422104654018369750191967384271618837091859516942\"\n ; \"20872505363530172448468374920196608937030884647150175861507911076568784054834\"\n |]\n ; [| \"6902861581703501105786795670676641959401710346423594578401934671029571262513\"\n ; \"10124161387604183369443890585742198433184078889862870469507328332805848271064\"\n ; \"10488004060799269337071647841224034919633445750252076195310163972966405029030\"\n |]\n ; [| \"507704911991278613147490289466075160618843900088471236546244459176211783848\"\n ; \"7252739745607302667257774481690407709040936359589867974787811552896597703097\"\n ; \"23278073497974004442836030100920157527910770509761505828038443336325476654930\"\n |]\n ; [| \"22766285055433137793164317120096790621982728188995759745859222009100808389090\"\n ; \"23129058299483468195787339200845749049960038336751758017949899311636830205152\"\n ; \"16665333681978951552434356320651834889869437822496200946959897681307959400425\"\n |]\n ; [| \"12145699202182574939376505075528461451757079041659894988784442097333218352048\"\n ; \"26340666275844437932755852805027863696219004039301187587209926587657008948704\"\n ; \"19208771804191839410002226941825269105677187954811130189835856228258013753206\"\n |]\n ; [| \"21957102494792377508237608216278079874536155315851198461024084071231867104453\"\n ; \"6933367436450995525851693784691226222726503560893470094614235356287049091852\"\n ; \"15707767379191450768747057313641112321773921923533732633534831270357733757271\"\n |]\n ; [| \"27661963645951389261638591385668507557739541354225916772550248746235106571003\"\n ; \"19699458096897937575096494582288688995241392471402204995195057374756282223421\"\n ; \"902873385171181344315871113842580653512118892800584003934454469411716098791\"\n |]\n ; [| \"17184835876565576154014372215369798779520343573944211203710896053325717110660\"\n ; \"664657295519303589036289440053175741110032988007278988577620229144220576240\"\n ; \"10803972669668998371638869508774217165881281885838503958226056357738500321396\"\n |]\n ; [| \"2329846733754251453632375727999372856194157027336139087170310553870624325301\"\n ; \"14139944357035048486675740400655356660678187875721949218090128899571575479791\"\n ; \"18368148273419807418427674359327442879484531833435081951870369910704734685351\"\n |]\n ; [| \"10480273665080572189328459165704340191901489646067580012574464138528963201459\"\n ; \"21773636700078124500346009061678153597323236568110076029811348966753228682835\"\n ; \"18184268307211429260956076021417309535471438696101133218049142374847151474905\"\n |]\n ; [| \"25957533025669311312382992376854735734491934602484112256289764602447226406852\"\n ; \"22223261506176684934865714490719116745135417403915426392159449667435294570739\"\n ; \"22937309162832499167063076416585504361695925730111272512450449042837586253575\"\n |]\n ; [| \"16956181785481598286719868503945127919581091625126206673934113115358441284347\"\n ; \"8497782777197814773596870810881707148695901557289856910220737358078100998191\"\n ; \"21135503731586600979470064722475007625236017670426339278983640892218291297054\"\n |]\n ; [| \"17809297343844488723046665739910571149089769215421130894378638450427880983923\"\n ; \"72435395972188389387093550708873189001876361107443937983754878061522372356\"\n ; \"7511239878692099209014947248389283109997289411550315391143819429585903287870\"\n |]\n |]\n }\n\nlet params_Pasta_q_legacy =\n { Params.mds =\n [| [| \"25059545165736646824438510995018528850798284624488112529736697979897721366717\"\n ; \"16698749787253722942243837797889445179074274353678606740096686335476872429399\"\n ; \"8431542578059462988142441820574484670502416261430105626118810753064502454172\"\n |]\n ; [| \"24729854844697760654067608751525498327180690314591492982304918187023029914826\"\n ; \"1121552144213806241339137182024814961508305746462827911242566288860442556748\"\n ; \"13091758359064753420271764138904670126701916846914918026096660522220974412796\"\n |]\n ; [| \"14318325434506839029297004068378670093722923223466359838374948921878384497878\"\n ; \"21049625586117008961018856577112352485632537866388888422067379870460247825481\"\n ; \"11967204246156045515212780049644733421582972293043836026003728262137316485428\"\n |]\n |]\n ; round_constants =\n [| [| \"27823288320934189888335104419667051541440213716337979953029039814477122015803\"\n ; \"7253519329434178666336171171011092435792450637855327869661074429483992798663\"\n ; \"12943190030917713819083161989292505641412002214667543002424543294305586713622\"\n |]\n ; [| \"27652450736585745228854776198724711889399928847227796610514615862285675851603\"\n ; \"14974144387861463358629448488728583756510094143360287299992064027672013096218\"\n ; \"7097911473075039536684392748485048129620058816999734741035507137919094344000\"\n |]\n ; [| \"9833471627477871590542564294396788818371219099618369953520953128833069622998\"\n ; \"1216722705894969315906023467727879380441696627034784137237245320657648994073\"\n ; \"23711484374443627488130462875874481115682053816071105446952037381155017895779\"\n |]\n ; [| \"20334834189812750348389095362218130162301260954195045344340626330588177435942\"\n ; \"4366529093468402654059406041856606540091882399834904947969748538808812090209\"\n ; \"19522556558624240319308906783506879200944684005866343832929046513996276368523\"\n |]\n ; [| \"23468156490044127088707992399042874063294495237928703268006456122691893114531\"\n ; \"10734041842950229608874281327056547473719120183996972794393760960989413485309\"\n ; \"3234488841736382875399536096222344212453291206089588556042783786752950726222\"\n |]\n ; [| \"7306686533350672818132556583061081086083445583634785280645571504913340166178\"\n ; \"10055837153364380487257619433543992440564488619143210451383396316865395141767\"\n ; \"17005554504252596333905431799020688136174578956026736789538843112027911340688\"\n |]\n ; [| \"11088831290647913265184319169987825710158339243590017331996929570375044581141\"\n ; \"18272514567796081346048223631818362002154999137167000861967874931307115963229\"\n ; \"2041522009924764288246767723256644894737485859434724922096489305438150594740\"\n |]\n ; [| \"11154210356751829838084431411705166756691650190195364032751879907682556256563\"\n ; \"23653929191474563116794828027291046485627178938492016942565292972650213420708\"\n ; \"10285757729660670290227890459658768244478343389595417793240783735403842747803\"\n |]\n ; [| \"27122162076320933627388879342386660773804566925381935727677186578594924773004\"\n ; \"25134653885736994960102027470761976149413229279137043556790564613470281817026\"\n ; \"6659993804933127797936877003954612022106867848874586482405999929720922911898\"\n |]\n ; [| \"1999981756946475588545224006048368808065463727746380893415897089701535614681\"\n ; \"117353258519553885966322353309393133659964765643696354970870351531909803419\"\n ; \"6394630448856946333677807337170062255969284635756530106258303122060761829375\"\n |]\n ; [| \"10402812455948335282625861441472459100503153859758204506020258199084032529891\"\n ; \"24521576250845873373537149390654765866957414335470107480004100764170074644129\"\n ; \"28343148273143818383375888384222625178643820136230475659994359540667696060401\"\n |]\n ; [| \"19466274031477176253567256907114468319559962421369951854132011198919308086813\"\n ; \"15950373298313107490097624474333726880960801439930364792944142444680782981647\"\n ; \"17502012461772831993035812876278636151120700925824710547719185259039723973873\"\n |]\n ; [| \"13427943193313984564171438077343446106584745896824089935661921301233540577663\"\n ; \"19169237962582795898123052276700824726897554497737731003794686518711369308701\"\n ; \"9083808098781854981749406088158848274120691731417104666413783119140757689434\"\n |]\n ; [| \"3085572928600572710130215355481483413152463940337003200200686333839836936060\"\n ; \"6423923726405952993270285921266354528708083436156049822651047436988725799335\"\n ; \"11711163607312960445460153090393005414044253191457667104588071606706527083035\"\n |]\n ; [| \"22862764769570580579955370870655020558642400260785510683021349826526091593487\"\n ; \"27106527830212782583531586155197640258773355519954630305727973089302997251797\"\n ; \"16868720082666046473782251283858811018289758418191781142790257643516182531272\"\n |]\n ; [| \"23158332713461282002423665990353034524451940720249144308509697639018478890344\"\n ; \"4196222884247438401050717959999141753538715859111095883718384227804271580571\"\n ; \"22572557742560406175483660351232922626321427879380236408573364865152875751999\"\n |]\n ; [| \"6498384178588263785275487016065720553418371000134613854044334919909896078231\"\n ; \"19713457172464396779910830357144111010125169288012289325852007667562797201617\"\n ; \"9370618609381654599580351346089018265074763897101213494189302119360756555515\"\n |]\n ; [| \"17332110085907729652621872688438506098032926644356340523235380228784153361946\"\n ; \"15828217198541208438489225959666895536847479530801819210983017536719128875310\"\n ; \"22909304389117426005516739639132057953847831090140119017131773808660581359339\"\n |]\n ; [| \"13274846258473860762348270229895556617343668531781906800111616196606379168678\"\n ; \"20563817685937794654177709363835160405142894424010788995801747935877119235477\"\n ; \"20063600011389636949850146896035168067037303328482473908141578341678944583640\"\n |]\n ; [| \"15561372644915625354729031742269409074452750500059702572378336917069173281200\"\n ; \"1198490580487628040011397824278054034135841708228898001350812771879916960859\"\n ; \"18879421345448691096589106007214815329241576402832734110268197859756832871926\"\n |]\n ; [| \"27399632471000964892968952930054846863781961828780329177494048571243833336763\"\n ; \"2834864942083315409826100384502236980961959328095446142898875620023252496233\"\n ; \"4869045848545701242953923765295279010470656159359352534992875895020324731123\"\n |]\n ; [| \"14325690392479768681007652408098324173976655892283539787053225046370602615453\"\n ; \"25414347192966841451685828069955147897403238857128755301675290249558576625379\"\n ; \"16590289516213461810017744664371295027301564689635234008641715363769691252951\"\n |]\n ; [| \"7999784177991937194560403228390571132248134775394758539082341051882961743020\"\n ; \"27627395050531728876502002078316976742781103442109539911472055005902825690089\"\n ; \"18036356111926470640247668504029296840956365668466479796170120459318979414011\"\n |]\n ; [| \"5913242795575813219801658492942666827872903959995896555280069960017119884723\"\n ; \"14937809672911513589131385409454363020800493802245991188388679796557583708641\"\n ; \"3172852326416764473757677332305817213305384800572730229499136253125245597387\"\n |]\n ; [| \"1832396283457909430686926169612235735546922286254241081539828449889942491358\"\n ; \"28715821183944831340251190244581222742951105435037341519427068245935486106710\"\n ; \"14690804016462235339916279821852369558429158839477443587616468985654313024916\"\n |]\n ; [| \"10594946257886875886350188493790544854294225726533811714616959802551003511354\"\n ; \"16258660270470428008977128056439132854218579917105801771424980524100431529141\"\n ; \"14389177900004589865692617486629808338224936524382373991229450083375030187419\"\n |]\n ; [| \"5254897446260226925010930278774739002366094838197608352776711034691419167908\"\n ; \"10017451766970898293191969301037043760556997294605718695671614691099240320486\"\n ; \"10377472495000399544094005473576037833003171018156457133642162749306784348836\"\n |]\n ; [| \"23218136335641731339524766058408447175805302377930780974300993009302336516500\"\n ; \"20191488824991124775021487716004416112776365506510575739204924567600203901269\"\n ; \"110606975331244410915904098772946457859594892267516924942421765736318866617\"\n |]\n ; [| \"23027069668757981664879070455867290821752779218098836684714327441246591774759\"\n ; \"4589247739673767474307973868199446429401684489991453077155492434850787381702\"\n ; \"6379670142720597470858520674745082918596505550095259476677356817872026090713\"\n |]\n ; [| \"19764864476474764903616550282446756103765436833072775572851316648333869235114\"\n ; \"12894898442410371982703732271804085318212494678649934125021268012840299185637\"\n ; \"4894374129066677193060314651654909732906317879933995748486904122303748724381\"\n |]\n ; [| \"9392947448126670174003480248219776361392113047007441983095267747240201787052\"\n ; \"17448004227122961073493138290943872881683504888463872361350949670680638193246\"\n ; \"24898908270148995600292988565336948748670477048995196059344166957302253353468\"\n |]\n ; [| \"17672969484563875329340665269765905710099865885284111146969980578304648998989\"\n ; \"17315183356963381222871645160515357484888194239021894873634846607120433299603\"\n ; \"16657291105770020999163388035414073826686069942847209725990896237129724531623\"\n |]\n ; [| \"20045358898180937726150285529789401521185856403599282370725965114285467221394\"\n ; \"7604720689465762204259558177050824657125765219907087093134275946944476764623\"\n ; \"4946157133141303389791048466320735878774808191447977218588320463643439643617\"\n |]\n ; [| \"16095543778893367554646246146733094380954235388863918230797975064302848608110\"\n ; \"9495028757440948201524349973141898811031260740727574963230822567659024070475\"\n ; \"15652394153551772951410898217296838776100645778717025418259184512269824513281\"\n |]\n ; [| \"22221075851011525495207739030167842998461976982084095286887110082203892655949\"\n ; \"9773505979109619840461605806117798267810157941804844442655531835520967463113\"\n ; \"9699921110253873916726596291176974227884871755181878140734719120429532053002\"\n |]\n ; [| \"17682231260051753498617845281951269726537935653976607531850308842757348601329\"\n ; \"18026887242590310014427209724078991193599958030254077118842503456583403950827\"\n ; \"25015306241717221564050692754953747248185536052663170582824605966511132780487\"\n |]\n ; [| \"16913017783534832741366331557377027835283393598087920619147327295000966841306\"\n ; \"14346687497088016967038616732353182101844963538110413455107565365722012953284\"\n ; \"5306566980905870284116776586767806070957377455264987606648038923624253495328\"\n |]\n ; [| \"1776756375313230649731428479835496304149043878892306245847918259342669070843\"\n ; \"490116546446566363527874936210269421699868025744627465261205141315457929764\"\n ; \"15895862901922909582174688550455317647454688607836801729345729632260371594678\"\n |]\n ; [| \"13688862447353097641921417721564599384304916802983599264426675175604875742315\"\n ; \"24548198092994361104088706233911543485350973671834385909863857501675802878279\"\n ; \"13459479827606540544689621578844182868859283770589890980132135394570347186061\"\n |]\n ; [| \"24044394058320635022361075601656905043313553792325674538366784156913803812196\"\n ; \"13224911244448701263582762940879464967836683002210854167321246073960841644522\"\n ; \"8458040493721843207908979005771386571338972860793346258045061108188537269575\"\n |]\n ; [| \"3373954096140863425424783847439718500809124286660183499962641073452219575239\"\n ; \"20786023834921480994573103385555575391782193954100981434750965529916600088428\"\n ; \"4062313531423140960397881434049476366932415559401603628257162927863296206641\"\n |]\n ; [| \"1898020409546207805320648144920011726191859363441411206281917919526161244598\"\n ; \"24277367400752675228358431727080852820923883244494414698417676920127526770088\"\n ; \"27041649732785968593009926556186278849799597604234485085263424041769060430672\"\n |]\n ; [| \"21584002498671958383320932658470323644925729001241157174062149135688934590153\"\n ; \"296461973635637542200993277788422285516983090690405454296351759221006819546\"\n ; \"8818839967799505500555627771598501831696804919367222237507197660660892665148\"\n |]\n ; [| \"4439337387294703935549667847378420965887876421209156336246561071020526953695\"\n ; \"27771844118085313731256751422668441516968763521122036346441924658635531209834\"\n ; \"7599670163703076794117421319905831310613637703095599713786252660612843368075\"\n |]\n ; [| \"12193036087689296361781682831088176514376474290884092260169857032550680408546\"\n ; \"25791228645469784134598013409595043692878987806412190415747720776255632142972\"\n ; \"8504882545271841062057911639581320453656588156705418395838850434018335784764\"\n |]\n ; [| \"9130894449689099154616722799255778500706692445872833148087121191022987751351\"\n ; \"21553577145491938499114888018915447040714863615699957078888430024590510223125\"\n ; \"8307396866731830889712140446282281226154409273955284908758959517111805068379\"\n |]\n ; [| \"20697895431092576068009892921110410029570860731610412906827921169156559036877\"\n ; \"25847730491997591203980701133953084257949899509409890411883471391399589272255\"\n ; \"27068530132452520868806589188908435601314783511462339379808399629696227108300\"\n |]\n ; [| \"20579165271364650486101631743580639117276566815442383429004130800710012624677\"\n ; \"2049872261441584532266169243588650339607343237488816821021818230059988793881\"\n ; \"5229222520976935575159907831883087156061470447412599430611711892673497144820\"\n |]\n ; [| \"16888076312477210105490768408731364790051105858421097779712165387651960648918\"\n ; \"2063328481371063362698477795877294174447601367525854450572877036817950486588\"\n ; \"9978860706589405700636863259000379424111716695830255414810479786243742448788\"\n |]\n ; [| \"10317246955612741053663756285229154782235034400014758881046851747850823867516\"\n ; \"13593887292763642751523995903547641851467767154363297491262315140569344482619\"\n ; \"23402502496341059894809445627668621422181262255992641144517916256091271283596\"\n |]\n ; [| \"21967434350664893350794692419887682460286669021917537287854750673456386148796\"\n ; \"23353689534149296842880441871386688481067867589772985300786059302345245225322\"\n ; \"23735357311909906399385947858290446886270449558355528121401365099315742122681\"\n |]\n ; [| \"10912898365787795098976682182552503726774830131561177111534481011887568028225\"\n ; \"24870024081013773996332492735582388115312107253015059784314149687041374665561\"\n ; \"14959251092871859358484341584905048546998757007023469906733200814028817787676\"\n |]\n ; [| \"4862971281682736739478329712142805000991054403202074379778464975706269552737\"\n ; \"18880974505260055428677233450169574923539187497744705144686621167223290501713\"\n ; \"15019860251830177408295304948562135143018077531659007557525973719668356977506\"\n |]\n ; [| \"20568371280002005481616540220671990391004159655382801184704914533391923227442\"\n ; \"17618564901060519653065801707062565705965252069071642419351201848751288646311\"\n ; \"6175806441176276214249342720153255252512916129811023844537243081853881530586\"\n |]\n ; [| \"296698681032659410437385638424768886607081580850224832109048866253174706324\"\n ; \"7268871617745116292779237678539517235521185661165310960197803054547440338193\"\n ; \"16341563652551468195688432165785741488638381548308118992703945905571040710551\"\n |]\n ; [| \"20802839862702262365306655858469071118895773474002102559223288884562755221802\"\n ; \"8463358659774659224604995990679067672391550969286021897665237635502349549078\"\n ; \"15978158329915368408793563753006455633333602546915141756185279989524351398011\"\n |]\n ; [| \"17622341778239430423221939745175386197971754657696111634181640277323050526814\"\n ; \"10608335237642480929422693089800206983573202659550442733156493623334131463648\"\n ; \"4030685945296549297325867649675145444613863086399488872024691844215015865404\"\n |]\n ; [| \"13622512335702925704246239293965891829357706731007005465669806728128070589631\"\n ; \"28096860376731134760587904422020552532782566250134663540225061105608367763617\"\n ; \"23408844245917750106421907693053932839460443870282241477420090247810403742130\"\n |]\n ; [| \"1333283643113200911795408607575124847498003548266053936354869116413818233994\"\n ; \"5114627784027951102582115213264649034477290065123683766415035791913182621990\"\n ; \"12764392856508616755454501281162355366590010491252202055937861522683929322726\"\n |]\n ; [| \"17151467035003081822551161487450697402952914914532916714361135117937359660435\"\n ; \"5790806510531167647314677971786602969791369262808321427822737321737295918626\"\n ; \"25402570155872412453028168278079114058150183483929245811506328339445321991585\"\n |]\n ; [| \"12920564330262937347355086382215038686842973035591062422536047377306795551956\"\n ; \"12250718187966551349934722909284957659425918779784022718640942555655844833782\"\n ; \"20895727170003937274470408646745579174029123755980503191289166493378198853753\"\n |]\n ; [| \"15956841763991535793203092153585710767934653432429666292367107371891246878431\"\n ; \"165004921874760145525553135393467831289178931448821175010841518884068397358\"\n ; \"21701359314438421232412634090067127199084976819670003578888860920096628455908\"\n |]\n ; [| \"6848902582754636090737517131578591551788309332465803574486567584842713095075\"\n ; \"9148729239860297908222294166176107790125495380930731971791358581588488088179\"\n ; \"8358777029774639487464736856867300896187008886831215496030522112768313792659\"\n |]\n ; [| \"27763005231503543326388909385720946430141828710795454442053340035715385775564\"\n ; \"22636772741960501900595405662321074335936299276173491651140399382705798268766\"\n ; \"24200783367862580793810376984298862005065285339141826318611417638508272680935\"\n |]\n ; [| \"822600333766772255824054922496304222560196931439044456446485963982870790028\"\n ; \"11620067212793640354075687381092798024341928813664220586751309617921494471627\"\n ; \"25396694389942268941157432367167881033474136344183279866045115614823524486381\"\n |]\n ; [| \"7950044866662305700342331645322097694799649174330586954392082006195652431589\"\n ; \"22840933456350447931596740831047097851905435130998852812846918451453709541072\"\n ; \"5952562873278923355396014494234833112602416727163262543950012068378966526374\"\n |]\n ; [| \"14941744106899001396490468834896552276228477518658489130424851675983796484223\"\n ; \"8411858922787427790040186603365979935733234451728885815156429633351516622170\"\n ; \"25728130512642084604375585079417861667709258338193885601642539891291402554672\"\n |]\n ; [| \"20604517750643336005470932595806868673102682184328905598449933465373164368567\"\n ; \"18692086501272312775058232861104840534405554074751818414995965413576504506898\"\n ; \"5269470419857278770474250796707995245651827289253410681285877302520855951649\"\n |]\n ; [| \"132958317750014592125353639381410869535729112359715476758774573020346177038\"\n ; \"17193272337125758342712697198430394405858515930784181707588441236523237399507\"\n ; \"6907588900146294348775248591028498082882128985613063249028470164033147125714\"\n |]\n ; [| \"16309200565821244573168333253815499203949927814550835828103574182056728678956\"\n ; \"4607702890113363215119270116443817064683508025122288758534057630367234921015\"\n ; \"11237233790658676278102726466515564713414270355327201961157117083230382852243\"\n |]\n ; [| \"10064330808822528140235288193284673078859867025792057686345339813053087817354\"\n ; \"25051392317202122071857024659315208391485135039862063722352057784569902851363\"\n ; \"22126617513529506569359166365810362424423294611767941651490344758258540414004\"\n |]\n ; [| \"12091746476208536681080525048942500448418433204654951972926283776785275935445\"\n ; \"12111265990251598624141275756247422663513559759757319153701374783734518534525\"\n ; \"26739984777421171183341767053331505211465422029143782259686543457935639077074\"\n |]\n ; [| \"7819054201259648899956766259173509994826070622646983709427380262867238635463\"\n ; \"10445115028929965619698941897016402172414044576496139170399391316067978563932\"\n ; \"19684711726373570147937187126430934630002495670017015298886915356480224463252\"\n |]\n ; [| \"11239307846668865409559961011092791606629566617449107300929575297206367273772\"\n ; \"28805033990368921872277896029043745855817246151363711680251631474098318414959\"\n ; \"18401979852581903763050302976527384564541846667710514970197455751949363551773\"\n |]\n ; [| \"28263368266760706140556936890723050350981960590399696453960533699777929937332\"\n ; \"13171701559671490165454061311663500722478022888953080003164558696925706691950\"\n ; \"19602525380638837013300511621093845194121859856160220235414966930348094741920\"\n |]\n ; [| \"25875044639134258735138554352016034131847861924507451443931721478575773042344\"\n ; \"1286919834973261464274310810959674232070230673485764517044208498391267530988\"\n ; \"12782511029953763844753944101233413908378422219581060868637062846684140416599\"\n |]\n ; [| \"13777170936966635591451775007775796682884247670199445877358680218373012583133\"\n ; \"13914069095415962019849305704612514109938496116014955678392598600149568146470\"\n ; \"6783088795558416833900023860884913748051142639172416787734707305655085393583\"\n |]\n ; [| \"23759768419633407428810307098986751935262813445177317925266674188878521655568\"\n ; \"6216329803333944314103957880878676099988045568818271561443283432381325370083\"\n ; \"25114051080902804484727511815467173212803244349938543937989789439460074114186\"\n |]\n ; [| \"1180226883916835404878157801250992605812628262348217873510319284727730147381\"\n ; \"28284648834460517620415684321276302970692148546984768206724059094698247703614\"\n ; \"24033429483804377793699007789045563117176754720883449007735536724064971910209\"\n |]\n ; [| \"24837980504224007072003842463132805986188595503848986775222831487536454430702\"\n ; \"7321472857412311158120212341338101751477713807416898032253162676888996785560\"\n ; \"16969570257066093255532410834694788936815887939867116143226504248562357179280\"\n |]\n ; [| \"4125673734564343532339577642546830393637205447174011175535077670456408467503\"\n ; \"10632713303134500465283168727266716395067246541628032088845987128902453337705\"\n ; \"9574680283229048309682722855094170144602083182060214720561022770315159925050\"\n |]\n ; [| \"25200516884616393326554198239117840577353244771178619578270272915036798525203\"\n ; \"8016037998616729200273828218865709942562955788458067024686069967773623280702\"\n ; \"23152730567726048528634883257060835573481024340136073260056069507023870894846\"\n |]\n ; [| \"4936905020024289826614920724630062129669650361835193562496220267355967500709\"\n ; \"18184641423707818974834811540508053654673520711184768800680158891503991754351\"\n ; \"27444333582924293137279963432375877042954535401580653830648855025913046131946\"\n |]\n ; [| \"19258787990037904339970574900663327047151333605558856194461096727736980981409\"\n ; \"7307247571008211080591958435739460884694126720317257874083215846110062993851\"\n ; \"26746958803361511836036369403239292474668097850167071971132263374551313661859\"\n |]\n ; [| \"2986707284687082908367239099770334052301679778803284796428725648583327571996\"\n ; \"11076872572044729168706875668696902097477024573484865352103135025101837260335\"\n ; \"7676893881767745856368855909105588397337840304590696665395773396488415841368\"\n |]\n ; [| \"8035879860710675293804855837795384803722427367423273349615911494186867635695\"\n ; \"8777228662288028976220651807443998778731851272244712495838227067153229552036\"\n ; \"9404729766074943289512201205781943537326342248324517034957699512018199204738\"\n |]\n ; [| \"28138039971941229743877350137198714871803339371774209928210486168306126282046\"\n ; \"24746372913562546565307551019536112359520027514996722419915199065654026706269\"\n ; \"5992908251399318789048901337027258610373870655662449861810221050890563237785\"\n |]\n ; [| \"8986662495311798908019190514368815106790964767556070538172234209887075670815\"\n ; \"7819511120920480038906806637526904433010099047963872696607543518954984324963\"\n ; \"20040748576462413617236432113139264992338669108015478382493668322296306085726\"\n |]\n ; [| \"12604124251667268108802430657250418818373981324591677149693775791311237018115\"\n ; \"3713446680888938926487722727702881477451007635693922407499275812693082163524\"\n ; \"4729722979346651955109002515433891123630816656581607922377526264122826791278\"\n |]\n ; [| \"16455155466899261355363975391464726179721089911718581260053823330812044805329\"\n ; \"27164824221249686345132567624748537410457840627513096638619870411838704887939\"\n ; \"16276969634012778467682584281076733912813949584479602315250697584070339970173\"\n |]\n ; [| \"25641921087422510763187305803178924090589997867692682422161021888360562111214\"\n ; \"3667017006482520184366983251713265998942338144600409725070021931240855063242\"\n ; \"16624027448839826107498199322162430278228409173124621849582911009734159268523\"\n |]\n ; [| \"26317000137938324098695631123138063604840025944173958478354566632124186905402\"\n ; \"26340841271036888065816939024344358177648115802586515509528813558078622483283\"\n ; \"26760792070192677486356259617078495242352693159824472284838522738202103374517\"\n |]\n ; [| \"12721771512080997403280267277695539784262535121086502864139373913498888705215\"\n ; \"22548741447254480389350118476622153801605101093013811309651936063066499340364\"\n ; \"27978367330497576661463216897542761474015119849207592150731961184044447336019\"\n |]\n ; [| \"25747063373517637067792390107027157627279718780430393414118399515398493230570\"\n ; \"20151199118555759838932276113163555479083735668386566652089241087017456180596\"\n ; \"18879014815739649515414305835536994932451911664341341839193146489857284960764\"\n |]\n ; [| \"3810373645102571961856835110796286023878561472775937446095180271215591973482\"\n ; \"21670724524877659990430014767408914315012249576025971870416576542969889929722\"\n ; \"3915354581322191374887706360194439190056113572215823372708498368264986411752\"\n |]\n ; [| \"25396010083988081390296945409600690498532747776857675039749936403891275914607\"\n ; \"27390501373018759994091671141783422648482925902652559051505224556105818276432\"\n ; \"21943756395113869385673889596972393684048914861116005493936041142864388308640\"\n |]\n ; [| \"21009529429359499435346117020843766611662779822918934812595290904562681460194\"\n ; \"4403095793362209982879649985124453117401775317228756238293170861698283724152\"\n ; \"13402721305808954031052740171341806281977967539270936940650446104784640742956\"\n |]\n ; [| \"27491349623398243944682353258003517841463983130426355707277141054509970413931\"\n ; \"839162295650533705111165213845914661169544698196543148318540951139745338443\"\n ; \"2360031015226134235320333722839592171180466963140089662936226146376372598269\"\n |]\n ; [| \"23187073805281466301515357725635655379740035976872552251192653562569108948332\"\n ; \"13415450340633894897579130593672628357474718745976391717544515771527056769433\"\n ; \"20551598721856083916810924558283736201557848101716997060847530300465710342492\"\n |]\n ; [| \"3672594647865661748928752317746079229095373133257293162774720337138304704736\"\n ; \"28656412123828764424722913154831876184400121058128257557942467880106263931024\"\n ; \"12488798341044520189714771416078903136558391518843419705687775573556817797577\"\n |]\n |]\n }\n\nlet params_Pasta_p_kimchi =\n { Params.mds =\n [| [| \"12035446894107573964500871153637039653510326950134440362813193268448863222019\"\n ; \"25461374787957152039031444204194007219326765802730624564074257060397341542093\"\n ; \"27667907157110496066452777015908813333407980290333709698851344970789663080149\"\n |]\n ; [| \"4491931056866994439025447213644536587424785196363427220456343191847333476930\"\n ; \"14743631939509747387607291926699970421064627808101543132147270746750887019919\"\n ; \"9448400033389617131295304336481030167723486090288313334230651810071857784477\"\n |]\n ; [| \"10525578725509990281643336361904863911009900817790387635342941550657754064843\"\n ; \"27437632000253211280915908546961303399777448677029255413769125486614773776695\"\n ; \"27566319851776897085443681456689352477426926500749993803132851225169606086988\"\n |]\n |]\n ; round_constants =\n [| [| \"21155079691556475130150866428468322463125560312786319980770950159250751855431\"\n ; \"16883442198399350202652499677723930673110172289234921799701652810789093522349\"\n ; \"17030687036425314703519085065002231920937594822150793091243263847382891822670\"\n |]\n ; [| \"25216718237129482752721276445368692059997901880654047883630276346421457427360\"\n ; \"9054264347380455706540423067244764093107767235485930776517975315876127782582\"\n ; \"26439087121446593160953570192891907825526260324480347638727375735543609856888\"\n |]\n ; [| \"15251000790817261169639394496851831733819930596125214313084182526610855787494\"\n ; \"10861916012597714684433535077722887124099023163589869801449218212493070551767\"\n ; \"18597653523270601187312528478986388028263730767495975370566527202946430104139\"\n |]\n ; [| \"15831416454198644276563319006805490049460322229057756462580029181847589006611\"\n ; \"15171856919255965617705854914448645702014039524159471542852132430360867202292\"\n ; \"15488495958879593647482715143904752785889816789652405888927117106448507625751\"\n |]\n ; [| \"19039802679983063488134304670998725949842655199289961967801223969839823940152\"\n ; \"4720101937153217036737330058775388037616286510783561045464678919473230044408\"\n ; \"10226318327254973427513859412126640040910264416718766418164893837597674300190\"\n |]\n ; [| \"20878756131129218406920515859235137275859844638301967889441262030146031838819\"\n ; \"7178475685651744631172532830973371642652029385893667810726019303466125436953\"\n ; \"1996970955918516145107673266490486752153434673064635795711751450164177339618\"\n |]\n ; [| \"15205545916434157464929420145756897321482314798910153575340430817222504672630\"\n ; \"25660296961552699573824264215804279051322332899472350724416657386062327210698\"\n ; \"13842611741937412200312851417353455040950878279339067816479233688850376089318\"\n |]\n ; [| \"1383799642177300432144836486981606294838630135265094078921115713566691160459\"\n ; \"1135532281155277588005319334542025976079676424839948500020664227027300010929\"\n ; \"4384117336930380014868572224801371377488688194169758696438185377724744869360\"\n |]\n ; [| \"21725577575710270071808882335900370909424604447083353471892004026180492193649\"\n ; \"676128913284806802699862508051022306366147359505124346651466289788974059668\"\n ; \"25186611339598418732666781049829183886812651492845008333418424746493100589207\"\n |]\n ; [| \"10402240124664763733060094237696964473609580414190944671778761753887884341073\"\n ; \"11918307118590866200687906627767559273324023585642003803337447146531313172441\"\n ; \"16895677254395661024186292503536662354181715337630376909778003268311296637301\"\n |]\n ; [| \"23818602699032741669874498456696325705498383130221297580399035778119213224810\"\n ; \"4285193711150023248690088154344086684336247475445482883105661485741762600154\"\n ; \"19133204443389422404056150665863951250222934590192266371578950735825153238612\"\n |]\n ; [| \"5515589673266504033533906836494002702866463791762187140099560583198974233395\"\n ; \"11830435563729472715615302060564876527985621376031612798386367965451821182352\"\n ; \"7510711479224915247011074129666445216001563200717943545636462819681638560128\"\n |]\n ; [| \"24694843201907722940091503626731830056550128225297370217610328578733387733444\"\n ; \"27361655066973784653563425664091383058914302579694897188019422193564924110528\"\n ; \"21606788186194534241166833954371013788633495786419718955480491478044413102713\"\n |]\n ; [| \"19934060063390905409309407607814787335159021816537006003398035237707924006757\"\n ; \"8495813630060004961768092461554180468161254914257386012937942498774724649553\"\n ; \"27524960680529762202005330464726908693944660961000958842417927307941561848461\"\n |]\n ; [| \"15178481650950399259757805400615635703086255035073919114667254549690862896985\"\n ; \"16164780354695672259791105197274509251141405713012804937107314962551600380870\"\n ; \"10529167793600778056702353412758954281652843049850979705476598375597148191979\"\n |]\n ; [| \"721141070179074082553302896292167103755384741083338957818644728290501449040\"\n ; \"22044408985956234023934090378372374883099115753118261312473550998188148912041\"\n ; \"27068254103241989852888872162525066148367014691482601147536314217249046186315\"\n |]\n ; [| \"3880429241956357176819112098792744584376727450211873998699580893624868748961\"\n ; \"17387097125522937623262508065966749501583017524609697127088211568136333655623\"\n ; \"6256814421247770895467770393029354017922744712896100913895513234184920631289\"\n |]\n ; [| \"2942627347777337187690939671601251987500285937340386328746818861972711408579\"\n ; \"24031654937764287280548628128490074801809101323243546313826173430897408945397\"\n ; \"14401457902976567713827506689641442844921449636054278900045849050301331732143\"\n |]\n ; [| \"20170632877385406450742199836933900257692624353889848352407590794211839130727\"\n ; \"24056496193857444725324410428861722338174099794084586764867109123681727290181\"\n ; \"11257913009612703357266904349759250619633397075667824800196659858304604714965\"\n |]\n ; [| \"22228158921984425749199071461510152694025757871561406897041788037116931009246\"\n ; \"9152163378317846541430311327336774331416267016980485920222768197583559318682\"\n ; \"13906695403538884432896105059360907560653506400343268230130536740148070289175\"\n |]\n ; [| \"7220714562509721437034241786731185291972496952091254931195414855962344025067\"\n ; \"27608867305903811397208862801981345878179337369367554478205559689592889691927\"\n ; \"13288465747219756218882697408422850918209170830515545272152965967042670763153\"\n |]\n ; [| \"8251343892709140154567051772980662609566359215743613773155065627504813327653\"\n ; \"22035238365102171608166944627493632660244312563934708756134297161332908879090\"\n ; \"13560937766273321037807329177749403409731524715067067740487246745322577571823\"\n |]\n ; [| \"21652518608959234550262559135285358020552897349934571164032339186996805408040\"\n ; \"22479086963324173427634460342145551255011746993910136574926173581069603086891\"\n ; \"13676501958531751140966255121288182631772843001727158043704693838707387130095\"\n |]\n ; [| \"5680310394102577950568930199056707827608275306479994663197187031893244826674\"\n ; \"25125360450906166639190392763071557410047335755341060350879819485506243289998\"\n ; \"22659254028501616785029594492374243581602744364859762239504348429834224676676\"\n |]\n ; [| \"23101411405087512171421838856759448177512679869882987631073569441496722536782\"\n ; \"24149774013240355952057123660656464942409328637280437515964899830988178868108\"\n ; \"5782097512368226173095183217893826020351125522160843964147125728530147423065\"\n |]\n ; [| \"13540762114500083869920564649399977644344247485313990448129838910231204868111\"\n ; \"20421637734328811337527547703833013277831804985438407401987624070721139913982\"\n ; \"7742664118615900772129122541139124149525273579639574972380600206383923500701\"\n |]\n ; [| \"1109643801053963021778418773196543643970146666329661268825691230294798976318\"\n ; \"16580663920817053843121063692728699890952505074386761779275436996241901223840\"\n ; \"14638514680222429058240285918830106208025229459346033470787111294847121792366\"\n |]\n ; [| \"17080385857812672649489217965285727739557573467014392822992021264701563205891\"\n ; \"26176268111736737558502775993925696791974738793095023824029827577569530708665\"\n ; \"4382756253392449071896813428140986330161215829425086284611219278674857536001\"\n |]\n ; [| \"13934033814940585315406666445960471293638427404971553891617533231178815348902\"\n ; \"27054912732979753314774418228399230433963143177662848084045249524271046173121\"\n ; \"28916070403698593376490976676534962592542013020010643734621202484860041243391\"\n |]\n ; [| \"24820015636966360150164458094894587765384135259446295278101998130934963922381\"\n ; \"7969535238488580655870884015145760954416088335296905520306227531221721881868\"\n ; \"7690547696740080985104189563436871930607055124031711216224219523236060212249\"\n |]\n ; [| \"9712576468091272384496248353414290908377825697488757134833205246106605867289\"\n ; \"12148698031438398980683630141370402088785182722473169207262735228500190477924\"\n ; \"14359657643133476969781351728574842164124292705609900285041476162075031948227\"\n |]\n ; [| \"23563839965372067275137992801035780013422228997724286060975035719045352435470\"\n ; \"4184634822776323233231956802962638484057536837393405750680645555481330909086\"\n ; \"16249511905185772125762038789038193114431085603985079639889795722501216492487\"\n |]\n ; [| \"11001863048692031559800673473526311616702863826063550559568315794438941516621\"\n ; \"4702354107983530219070178410740869035350641284373933887080161024348425080464\"\n ; \"23751680507533064238793742311430343910720206725883441625894258483004979501613\"\n |]\n ; [| \"28670526516158451470169873496541739545860177757793329093045522432279094518766\"\n ; \"3568312993091537758218792253361873752799472566055209125947589819564395417072\"\n ; \"1819755756343439646550062754332039103654718693246396323207323333948654200950\"\n |]\n ; [| \"5372129954699791301953948907349887257752247843844511069896766784624930478273\"\n ; \"17512156688034945920605615850550150476471921176481039715733979181538491476080\"\n ; \"25777105342317622165159064911913148785971147228777677435200128966844208883059\"\n |]\n ; [| \"25350392006158741749134238306326265756085455157012701586003300872637887157982\"\n ; \"20096724945283767296886159120145376967480397366990493578897615204296873954844\"\n ; \"8063283381910110762785892100479219642751540456251198202214433355775540036851\"\n |]\n ; [| \"4393613870462297385565277757207010824900723217720226130342463666351557475823\"\n ; \"9874972555132910032057499689351411450892722671352476280351715757363137891038\"\n ; \"23590926474329902351439438151596866311245682682435235170001347511997242904868\"\n |]\n ; [| \"17723373371137275859467518615551278584842947963894791032296774955869958211070\"\n ; \"2350345015303336966039836492267992193191479606566494799781846958620636621159\"\n ; \"27755207882790211140683010581856487965587066971982625511152297537534623405016\"\n |]\n ; [| \"6584607987789185408123601849106260907671314994378225066806060862710814193906\"\n ; \"609759108847171587253578490536519506369136135254150754300671591987320319770\"\n ; \"28435187585965602110074342250910608316032945187476441868666714022529803033083\"\n |]\n ; [| \"16016664911651770663938916450245705908287192964254704641717751103464322455303\"\n ; \"17551273293154696089066968171579395800922204266630874071186322718903959339163\"\n ; \"20414195497994754529479032467015716938594722029047207834858832838081413050198\"\n |]\n ; [| \"19773307918850685463180290966774465805537520595602496529624568184993487593855\"\n ; \"24598603838812162820757838364185126333280131847747737533989799467867231166980\"\n ; \"11040972566103463398651864390163813377135738019556270484707889323659789290225\"\n |]\n ; [| \"5189242080957784038860188184443287562488963023922086723850863987437818393811\"\n ; \"1435203288979376557721239239445613396009633263160237764653161500252258220144\"\n ; \"13066591163578079667911016543985168493088721636164837520689376346534152547210\"\n |]\n ; [| \"17345901407013599418148210465150865782628422047458024807490502489711252831342\"\n ; \"22139633362249671900128029132387275539363684188353969065288495002671733200348\"\n ; \"1061056418502836172283188490483332922126033656372467737207927075184389487061\"\n |]\n ; [| \"10241738906190857416046229928455551829189196941239601756375665129874835232299\"\n ; \"27808033332417845112292408673209999320983657696373938259351951416571545364415\"\n ; \"18820154989873674261497645724903918046694142479240549687085662625471577737140\"\n |]\n ; [| \"7983688435214640842673294735439196010654951226956101271763849527529940619307\"\n ; \"17067928657801807648925755556866676899145460770352731818062909643149568271566\"\n ; \"24472070825156236829515738091791182856425635433388202153358580534810244942762\"\n |]\n ; [| \"25752201169361795911258625731016717414310986450004737514595241038036936283227\"\n ; \"26041505376284666160132119888949817249574689146924196064963008712979256107535\"\n ; \"23977050489096115210391718599021827780049209314283111721864956071820102846008\"\n |]\n ; [| \"26678257097278788410676026718736087312816016749016738933942134600725962413805\"\n ; \"10480026985951498884090911619636977502506079971893083605102044931823547311729\"\n ; \"21126631300593007055117122830961273871167754554670317425822083333557535463396\"\n |]\n ; [| \"1564862894215434177641156287699106659379648851457681469848362532131406827573\"\n ; \"13247162472821152334486419054854847522301612781818744556576865965657773174584\"\n ; \"8673615954922496961704442777870253767001276027366984739283715623634850885984\"\n |]\n ; [| \"2794525076937490807476666942602262298677291735723129868457629508555429470085\"\n ; \"4656175953888995612264371467596648522808911819700660048695373348629527757049\"\n ; \"23221574237857660318443567292601561932489621919104226163978909845174616477329\"\n |]\n ; [| \"1878392460078272317716114458784636517603142716091316893054365153068227117145\"\n ; \"2370412714505757731457251173604396662292063533194555369091306667486647634097\"\n ; \"17409784861870189930766639925394191888667317762328427589153989811980152373276\"\n |]\n ; [| \"25869136641898166514111941708608048269584233242773814014385564101168774293194\"\n ; \"11361209360311194794795494027949518465383235799633128250259863567683341091323\"\n ; \"14913258820718821235077379851098720071902170702113538811112331615559409988569\"\n |]\n ; [| \"12957012022018304419868287033513141736995211906682903915897515954290678373899\"\n ; \"17128889547450684566010972445328859295804027707361763477802050112063630550300\"\n ; \"23329219085372232771288306767242735245018143857623151155581182779769305489903\"\n |]\n ; [| \"1607741027962933685476527275858938699728586794398382348454736018784568853937\"\n ; \"2611953825405141009309433982109911976923326848135736099261873796908057448476\"\n ; \"7372230383134982628913227482618052530364724821976589156840317933676130378411\"\n |]\n ; [| \"20203606758501212620842735123770014952499754751430660463060696990317556818571\"\n ; \"4678361398979174017885631008335559529633853759463947250620930343087749944307\"\n ; \"27176462634198471376002287271754121925750749676999036165457559387195124025594\"\n |]\n ; [| \"6361981813552614697928697527332318530502852015189048838072565811230204474643\"\n ; \"13815234633287489023151647353581705241145927054858922281829444557905946323248\"\n ; \"10888828634279127981352133512429657747610298502219125571406085952954136470354\"\n |]\n |]\n }\n\nlet params_Pasta_q_kimchi =\n { Params.mds =\n [| [| \"28115781186772277486790024060542467295096710153315236019619365740021995624782\"\n ; \"22098002279041163367053200604969603243328318626084412751290336872362628294144\"\n ; \"10518156075882958317589806716220047551309200159506906232124952575033472931386\"\n |]\n ; [| \"8515206633865386306014865142947895502833797732365705727001733785057042819852\"\n ; \"19310731234716792175834594131802557577955166208124819468043130037927500684373\"\n ; \"361439796332338311597104753147071943681730695313819021679602959964518909239\"\n |]\n ; [| \"2193808570710678216879007026210418088296432071066284289131688133644970611483\"\n ; \"1201496953174589855481629688627002262719699487577300614284420648015658009380\"\n ; \"11619800255560837597192574795389782851917036920101027584480912719351481334717\"\n |]\n |]\n ; round_constants =\n [| [| \"2517640872121921965298496967863234221143680281046699148760560696057284005606\"\n ; \"3391756047431116221709518926936538303706203177575259437741546230828058541679\"\n ; \"28193080211857729746868575888309975056941007202713113547154010421664334143056\"\n |]\n ; [| \"25261619184426186938919514618416881383323154981235406731208902193655587998749\"\n ; \"5438499261516835502981531641588657477212528137520578797088407969732830437134\"\n ; \"1447697894671779324954748568939217281372628544919576009518449387265606369859\"\n |]\n ; [| \"5035532530235542599906399941203951970682478985022204457211063504597080640029\"\n ; \"18548939393800290417015907795270784249198528773378593112394621615021029911007\"\n ; \"28314657632459005492203969796973258399484591559931227050853551342156833947891\"\n |]\n ; [| \"10075465805557971120845970058070916255338843492716768289922460436606689369477\"\n ; \"21985996556868691161386211003270106475915714625334030557267947035839814254081\"\n ; \"9778523497398309788873186849997676949503189428912377745814036481347657299161\"\n |]\n ; [| \"6085447467925843146276340167082679235758707259098174769103982431882228334038\"\n ; \"11214803418623679719680560978819619149235769633101428825693192995405955507848\"\n ; \"20585482519401972421539035665320299097144487427998598740316244173221216198246\"\n |]\n ; [| \"18602266896623204184748247002001496873223612100325866696399863661914256384486\"\n ; \"22165919841309962137671309308234475433816142848229812860682345190836583925843\"\n ; \"22833505632200982123686653495190412951871851216487329681987951602744930627412\"\n |]\n ; [| \"200996541962081036547810490655955282117589336000744078845964972887355639644\"\n ; \"17159390488590225463405148524511348095493761844950655304775985535830170165304\"\n ; \"7519689807382250126180254188667761476713509751388558140260305473388567529705\"\n |]\n ; [| \"14159331841037307097148990917607709903712709092721125605507719995418592745663\"\n ; \"10490695046555645615062072066940833278139280813429718770298136076375411280286\"\n ; \"9996921069626538041923613626115903019578182147993504053879837245826104687293\"\n |]\n ; [| \"28009241574980093348462093077828465154604666812509186537490618830383877236685\"\n ; \"18925279443828804264179873719494108834579217607847079902207023181925588871175\"\n ; \"13126164514615718686767880517156253918404905174962666942976286681458411835722\"\n |]\n ; [| \"1125667389564136291825905670957082668987611691949011617627091942772124917554\"\n ; \"12737072162917928935765906421286553437026542524142430058538254259863452556200\"\n ; \"9855113244149548216327019561589719324434080884827484555441182992249251832158\"\n |]\n ; [| \"6006604346195593001833550983798183088851044846011297061071167569148810544010\"\n ; \"23783465709464699444911580329342599880163107932561352210466223087637763994288\"\n ; \"1581060363083815351710754851350813999229829634252940169154424073664057276774\"\n |]\n ; [| \"24121961545310887440574053281799796355427122479626872394472157625455666323022\"\n ; \"23925781309638869606256007860000699567158045595326122474217734988331349678475\"\n ; \"433512980570318160778040929743715681206456334448542248765142091911433454703\"\n |]\n ; [| \"8080307140515367021419180108267113624095868360927897204642243727009503935719\"\n ; \"13661807750191096117929173962837770733539092996971801228126331071941306856508\"\n ; \"9268394414065063505331314418649987795374055416089324253185088859000252370756\"\n |]\n ; [| \"22374115023493407761095751712373350824513305398485824175669182288521610150311\"\n ; \"22951274634403942446739133926874770994604864227598567536319143390467218980824\"\n ; \"21411532836345163980832919797897483979345524322135010935120723250070247464549\"\n |]\n ; [| \"20688285497159372157224857370703211924056803904697620218749985029000049442943\"\n ; \"8350087190167057556241775495760369408781696125331535735138679647687106863977\"\n ; \"13485893160159637778707269611856683957779710980787754997470728774769162419576\"\n |]\n ; [| \"4621792784192688819920303666439776744566536330750316034321950771579978771021\"\n ; \"13900656491552343190424687336475573267660717627286734246676255663734655019912\"\n ; \"16577037405341365304416318048187907895286388691199320947077947552959834207823\"\n |]\n ; [| \"17453637937712580666297652202332273322112052411250919589546137386514183913993\"\n ; \"9852736110707561006399582579453396957225552488023642073454517393228764176471\"\n ; \"8053970357622019747109700798952789019805031210730923951116580579194625334710\"\n |]\n ; [| \"14566849926060034944494603512439278530775668595134329897253012222562109882008\"\n ; \"8863944349051942080060073891691580009950648437676309749771884964336231381737\"\n ; \"16455762285584757654310476505019438984453107876908065440396394186006196612077\"\n |]\n ; [| \"28098375311516838082882166381119795701982164671360574802728073046992978741339\"\n ; \"13538346067341652694825445642847479918140731375902310280683284825070643960891\"\n ; \"18313412784975078534612748781201087502203257054025866271209086293337241477805\"\n |]\n ; [| \"24807061345703288899043018750567607387907450632666147403804744880717736838940\"\n ; \"16638378638176552952794487891875614248110181610295183306789394461536640085108\"\n ; \"2342874860138849081032934096750004917991517717553229739958552529472431319656\"\n |]\n ; [| \"21631810094765090996871180483650934431972930909326270651252393395613356531282\"\n ; \"2220759912186713489010197903069023809260408491503960321105305330086947471014\"\n ; \"14815764944505758746761442212662459585220143243155504464852948007238083120696\"\n |]\n ; [| \"23947619952183462858644581465494050309407721428302029371055887418452994318961\"\n ; \"25035254658153233628169609451068923631269927394392748023889572264723092874720\"\n ; \"17468020412163678868776493601957969748197290347006692843306595815987772942732\"\n |]\n ; [| \"15262198027618900223004625662874755104828479630165814039838611768431063172994\"\n ; \"25161066724266754383358798644805908588326959881061318668106454787543611445887\"\n ; \"2454250001039770891411267760383268680504653332090622148533496270387793031332\"\n |]\n ; [| \"9171946491887082474979985164918822959719377078284664312866368737511724712644\"\n ; \"6672870238005411132577302023934139592378291207852994424857452575898007687159\"\n ; \"2950400608762766076731526167833938554190979516192019010641815746350334547745\"\n |]\n ; [| \"10653725154501691589476837895400001173933804810435931645261606197625601363132\"\n ; \"12717400214508961810851553873706609743505640660238109459222577386574996883747\"\n ; \"5871058785976817081042949511195036111847495052209270758342334312740290470200\"\n |]\n ; [| \"18192562665205900830717234913238180302424621739145466326708104656354353538015\"\n ; \"19946412409172091711185698839696950657650658896270607012902209489827790455314\"\n ; \"21997416257528392077410699901606794827305154904508120972585193876767785262539\"\n |]\n ; [| \"16525092684784199198745517563091041705366544303388462641935777835264970071331\"\n ; \"27613372589672512522307803997948488817865025374001297632527692577079750053456\"\n ; \"23369674747888778238616865774843237791546925005553032792584302158017141634655\"\n |]\n ; [| \"11012136308159330675912474383855146192700147583104742924419195363346115019405\"\n ; \"20632243971343595216801828590185617698839041744000918292113739726624680548813\"\n ; \"10530371852841765918702282883445676639977895775479854136871270050807595649710\"\n |]\n ; [| \"1610594053831245596683250788274018471388810111366046583216577135605955718023\"\n ; \"452300846172044702598793611907955884294868639769163388132276731316720796255\"\n ; \"22297945145153422883128810575530182077542612397826351322358420927950400316504\"\n |]\n ; [| \"28212510899948152845929142163236606049756849316851154583029383581129293825706\"\n ; \"28325924586146971645663587791728624896861517146549428987043066595915712075981\"\n ; \"23489013325315178311518261165509151135555509351661386106070231815049642443022\"\n |]\n ; [| \"10150108696154604591036176090028652090941375062280095655463112192524823306544\"\n ; \"14935856239824547404885450872472169780177654619496758596151670953532153419587\"\n ; \"4367251608666794961207658726914177158125339342277880902441218521648798930454\"\n |]\n ; [| \"14278046449956534912766622635951826857049583276976844525135170835571509013020\"\n ; \"11627801940273881243235293875277734806211947530882079339115454640100174268255\"\n ; \"22853853581419894582873479603685652928885253184240650995805892818180355600894\"\n |]\n ; [| \"4405193089432137585625363585733613667088817369599257533888439029942466720878\"\n ; \"26434497741746827048559732407319982377645052620918789373329661707603241810667\"\n ; \"23558650878002025381506445692526977061352711282820117441110868042756853707843\"\n |]\n ; [| \"27427423077748345654234924309581695092179468167973406115643356520054395647078\"\n ; \"17585801825757985265979208086560185342609289319992678737491966299829354657891\"\n ; \"22079131836316223121286612953926945430480043835170303484162677394496378207190\"\n |]\n ; [| \"20126865597655889981803452476686954944892814234259869552204215672627920656068\"\n ; \"5591585339015997308682985123056479221565470335707041924016523106405300562835\"\n ; \"9422316572086279209843572429137982927615080330725918371521370800874341571474\"\n |]\n ; [| \"2735677349719528139570614238939713941030373684882307164259316901880218894412\"\n ; \"16229147459127626384090303399894157248853232127961182470501666316464149067069\"\n ; \"17151067888069760812629817914442472623785916486309268828873486698948911058517\"\n |]\n ; [| \"13833972862865550568348750465964022581895521701070662509936215512761615491351\"\n ; \"9624679817699048440664645568701817641311119158936258215534754849666144699339\"\n ; \"10273179847163882031630140477902608240997857384703412878925192706057610103613\"\n |]\n ; [| \"3172037826021850467928085880043492158321918352296515787555947245998877188849\"\n ; \"28890802281119993101506497911757988639840653958256859430239635494708187190915\"\n ; \"23496953773368274731821824281559682992786773767847557735733251263969009271239\"\n |]\n ; [| \"1509044982655321910215442389040863370827049078919961070795919190828975736187\"\n ; \"13927172650979098916742472053302036482743492746437467103459483008024082210879\"\n ; \"17248379591027039069313293591621091031164062825086122980769287846951363066520\"\n |]\n ; [| \"11350333545134487336540967650634077894516131586708748380417042089147896079201\"\n ; \"639497848254405996993150855123515463224731962182127668267769103213580096582\"\n ; \"24528361599642320451530127347946798949257664936307333999618279589325586618880\"\n |]\n ; [| \"8217015496508457685301448884203977810298711070026260090660268003968421268717\"\n ; \"6703444480721420507060701216472376128524677965704475494357937059812166295103\"\n ; \"8051365375874262471960241848873604339195556527603956582828833313772444122472\"\n |]\n ; [| \"10412735174026641936105532807659667596947675372330827493649954160029449767122\"\n ; \"8447576362386697729021229138353952824970707645851763166490398451107606293885\"\n ; \"4802965296970904162106502573136505305073730277702271660292532219583823320181\"\n |]\n ; [| \"3244354881334856885788568976540712586633556478250043997221528214026130052269\"\n ; \"817270901440592571623549787267103386561304980129799240746702119063425010300\"\n ; \"6566338353152134577893356938981496347522747926131278635019050445923229718029\"\n |]\n ; [| \"4854521709622003124815206874897232905514824969466266873443062691298769768277\"\n ; \"12830134034124699064152980183243986699241944691238427861184919962819448276943\"\n ; \"24309439157688106320977023683093060719537142150089588950480669629964661236785\"\n |]\n ; [| \"1853791709949511636795588377016980571084333441972847324139062389997895453872\"\n ; \"11399505004623970417786749745036397690793259153591025248188283534764565207306\"\n ; \"6280235834578097246976697944083887557501831809932305676532914637669922657807\"\n |]\n ; [| \"1516294190187225192808636261678393666537186816904214776860202535671714230097\"\n ; \"5835813607391397757416951433662507638966861369364000865214031356023042341328\"\n ; \"25777313996516799380163546628133415256678997511953860435781885414872422583905\"\n |]\n ; [| \"9749298878960864917089442034293906589697892682402070689770627645324414273893\"\n ; \"19986612197193695239708718365565978831607994386509967951279410162135133793419\"\n ; \"5020585421647265067890838871263925730422335215511670656851726444447972642755\"\n |]\n ; [| \"7256822974971238434100017358319972368738353570339258522235883585691301791128\"\n ; \"9789139064283320903202623693175751994730652446378861671859478926598420184293\"\n ; \"19283468246375057076525422714896652730563534118070235174488237489890270899533\"\n |]\n ; [| \"11487321478704551489982188818171823402443882145686911658585221913500937481156\"\n ; \"16513958012405406860890342996091255867910990589443610357743227675107758695101\"\n ; \"24764429351173766080138047602436205744310671344674490826288279531917797263231\"\n |]\n ; [| \"8256258316375000496541664568891934707113720493937218096466691600593595285909\"\n ; \"26919625894863883593081175799908601863265420311251948374988589188905317081443\"\n ; \"10135851848127171199130812615581006825969108287418884763125596866448544567342\"\n |]\n ; [| \"17567146349912867622479843655652582453162587996421871126612027345809646551661\"\n ; \"2524802431860351616270075327416865184018211992251290134350377936184047953453\"\n ; \"3417609143162661859785838333493682460709943782149216513733553607075915176256\"\n |]\n ; [| \"6906455011502599710165862205505812668908382042647994457156780865092846286493\"\n ; \"21042097659487317081899343674473811663642293019125869396575405454328274948985\"\n ; \"25222370053690749913129090298406788520061040938312366403907461864202905656238\"\n |]\n ; [| \"18933201791079410639949505893100361911334261775545573219434897335758052335005\"\n ; \"14503331557348715387048413780116585195932777696828173626366829282421027153184\"\n ; \"3558781473325529402549318082942465709639711182863041375748599816583729962116\"\n |]\n ; [| \"23932570601084008621895097434501731960424360312878373523779451810455362953625\"\n ; \"13286131463754478912858022007443470896920464302917391606059553157137090717219\"\n ; \"9969435194445819847988134248075866286921574284754991873902788928171429847506\"\n |]\n ; [| \"10821551500865029673311799086099720530496516676117927814621168667836737594374\"\n ; \"57689402905128519605376551862931564078571458212398163192591670282543962941\"\n ; \"4484359679395800410695081358212522306960518636189521201445105538223906998486\"\n |]\n |]\n }\n","open! Core_kernel\nopen! Import\n\nmodule type Slots = sig\n (** [Slots] has types [t1], ..., [t12] of arities 1 to 12 that are isomorphic to tuple\n types of the corresponding arities. Type [('a0, ..., 'a) t] corresponds to\n ['a0 * ... * 'a].\n\n Each type [ti] is an instance of type [('tuple, 'variant) t], in which ['tuple] is\n the tuple type ['a0 * ... * 'a] and ['variant] is an encoding of the tuple type\n in the form: [[ `S0 of `a0 | `S1 of `a1 | ... | `S of `a ]].\n\n The encoding of the slots using a polymorphic variant allows one to write functions\n that are polymorphic in the tuple type, and require that a tuple have a certain\n slot, but allow more slots.\n\n We make [t] itself a polymorphic variant type so that one can easily encode cyclic\n types, e.g. lists, like:\n\n {[\n type 'a slots = ('a, 'a slots Pointer.t) Slots.t2\n ]}\n\n Observe that [slots] in the above is cyclic, but that OCaml allows it because the\n definition expands to:\n\n {[\n type 'a slots = [ `Slots of ('a * 'a slots Pointer.t,\n [ `S0 of 'a\n | `S1 of 'a slots Pointer.t\n ]\n ) u\n ]\n ]}\n\n Ultimately, a [Slots.t] is used as a phantom type that ensures consistent usage of\n the tuples in the data structure containing them. *)\n\n type ('tuple, 'variant) u\n type ('tuple, 'variant) t = [ `Slots of ('tuple, 'variant) u ] [@@deriving sexp_of]\n\n val slots_per_tuple : (_, _) t -> int\n\n type 'a0 t1 = ('a0, [ `S0 of 'a0 ]) t [@@deriving sexp_of]\n type ('a0, 'a1) t2 = ('a0 * 'a1, [ `S0 of 'a0 | `S1 of 'a1 ]) t [@@deriving sexp_of]\n\n type ('a0, 'a1, 'a2) t3 = ('a0 * 'a1 * 'a2, [ `S0 of 'a0 | `S1 of 'a1 | `S2 of 'a2 ]) t\n [@@deriving sexp_of]\n\n type ('a0, 'a1, 'a2, 'a3) t4 =\n ('a0 * 'a1 * 'a2 * 'a3, [ `S0 of 'a0 | `S1 of 'a1 | `S2 of 'a2 | `S3 of 'a3 ]) t\n [@@deriving sexp_of]\n\n type ('a0, 'a1, 'a2, 'a3, 'a4) t5 =\n ( 'a0 * 'a1 * 'a2 * 'a3 * 'a4\n , [ `S0 of 'a0 | `S1 of 'a1 | `S2 of 'a2 | `S3 of 'a3 | `S4 of 'a4 ] )\n t\n [@@deriving sexp_of]\n\n type ('a0, 'a1, 'a2, 'a3, 'a4, 'a5) t6 =\n ( 'a0 * 'a1 * 'a2 * 'a3 * 'a4 * 'a5\n , [ `S0 of 'a0 | `S1 of 'a1 | `S2 of 'a2 | `S3 of 'a3 | `S4 of 'a4 | `S5 of 'a5 ] )\n t\n [@@deriving sexp_of]\n\n type ('a0, 'a1, 'a2, 'a3, 'a4, 'a5, 'a6) t7 =\n ( 'a0 * 'a1 * 'a2 * 'a3 * 'a4 * 'a5 * 'a6\n , [ `S0 of 'a0\n | `S1 of 'a1\n | `S2 of 'a2\n | `S3 of 'a3\n | `S4 of 'a4\n | `S5 of 'a5\n | `S6 of 'a6\n ] )\n t\n [@@deriving sexp_of]\n\n type ('a0, 'a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7) t8 =\n ( 'a0 * 'a1 * 'a2 * 'a3 * 'a4 * 'a5 * 'a6 * 'a7\n , [ `S0 of 'a0\n | `S1 of 'a1\n | `S2 of 'a2\n | `S3 of 'a3\n | `S4 of 'a4\n | `S5 of 'a5\n | `S6 of 'a6\n | `S7 of 'a7\n ] )\n t\n [@@deriving sexp_of]\n\n type ('a0, 'a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8) t9 =\n ( 'a0 * 'a1 * 'a2 * 'a3 * 'a4 * 'a5 * 'a6 * 'a7 * 'a8\n , [ `S0 of 'a0\n | `S1 of 'a1\n | `S2 of 'a2\n | `S3 of 'a3\n | `S4 of 'a4\n | `S5 of 'a5\n | `S6 of 'a6\n | `S7 of 'a7\n | `S8 of 'a8\n ] )\n t\n [@@deriving sexp_of]\n\n type ('a0, 'a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8, 'a9) t10 =\n ( 'a0 * 'a1 * 'a2 * 'a3 * 'a4 * 'a5 * 'a6 * 'a7 * 'a8 * 'a9\n , [ `S0 of 'a0\n | `S1 of 'a1\n | `S2 of 'a2\n | `S3 of 'a3\n | `S4 of 'a4\n | `S5 of 'a5\n | `S6 of 'a6\n | `S7 of 'a7\n | `S8 of 'a8\n | `S9 of 'a9\n ] )\n t\n [@@deriving sexp_of]\n\n type ('a0, 'a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8, 'a9, 'a10) t11 =\n ( 'a0 * 'a1 * 'a2 * 'a3 * 'a4 * 'a5 * 'a6 * 'a7 * 'a8 * 'a9 * 'a10\n , [ `S0 of 'a0\n | `S1 of 'a1\n | `S2 of 'a2\n | `S3 of 'a3\n | `S4 of 'a4\n | `S5 of 'a5\n | `S6 of 'a6\n | `S7 of 'a7\n | `S8 of 'a8\n | `S9 of 'a9\n | `S10 of 'a10\n ] )\n t\n [@@deriving sexp_of]\n\n type ('a0, 'a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8, 'a9, 'a10, 'a11) t12 =\n ( 'a0 * 'a1 * 'a2 * 'a3 * 'a4 * 'a5 * 'a6 * 'a7 * 'a8 * 'a9 * 'a10 * 'a11\n , [ `S0 of 'a0\n | `S1 of 'a1\n | `S2 of 'a2\n | `S3 of 'a3\n | `S4 of 'a4\n | `S5 of 'a5\n | `S6 of 'a6\n | `S7 of 'a7\n | `S8 of 'a8\n | `S9 of 'a9\n | `S10 of 'a10\n | `S11 of 'a11\n ] )\n t\n [@@deriving sexp_of]\n\n type ('a0, 'a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8, 'a9, 'a10, 'a11, 'a12) t13 =\n ( 'a0 * 'a1 * 'a2 * 'a3 * 'a4 * 'a5 * 'a6 * 'a7 * 'a8 * 'a9 * 'a10 * 'a11 * 'a12\n , [ `S0 of 'a0\n | `S1 of 'a1\n | `S2 of 'a2\n | `S3 of 'a3\n | `S4 of 'a4\n | `S5 of 'a5\n | `S6 of 'a6\n | `S7 of 'a7\n | `S8 of 'a8\n | `S9 of 'a9\n | `S10 of 'a10\n | `S11 of 'a11\n | `S12 of 'a12\n ] )\n t\n [@@deriving sexp_of]\n\n type ('a0, 'a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8, 'a9, 'a10, 'a11, 'a12, 'a13) t14 =\n ( 'a0\n * 'a1\n * 'a2\n * 'a3\n * 'a4\n * 'a5\n * 'a6\n * 'a7\n * 'a8\n * 'a9\n * 'a10\n * 'a11\n * 'a12\n * 'a13\n , [ `S0 of 'a0\n | `S1 of 'a1\n | `S2 of 'a2\n | `S3 of 'a3\n | `S4 of 'a4\n | `S5 of 'a5\n | `S6 of 'a6\n | `S7 of 'a7\n | `S8 of 'a8\n | `S9 of 'a9\n | `S10 of 'a10\n | `S11 of 'a11\n | `S12 of 'a12\n | `S13 of 'a13\n ] )\n t\n [@@deriving sexp_of]\n\n val t1 : _ t1\n val t2 : (_, _) t2\n val t3 : (_, _, _) t3\n val t4 : (_, _, _, _) t4\n val t5 : (_, _, _, _, _) t5\n val t6 : (_, _, _, _, _, _) t6\n val t7 : (_, _, _, _, _, _, _) t7\n val t8 : (_, _, _, _, _, _, _, _) t8\n val t9 : (_, _, _, _, _, _, _, _, _) t9\n val t10 : (_, _, _, _, _, _, _, _, _, _) t10\n val t11 : (_, _, _, _, _, _, _, _, _, _, _) t11\n val t12 : (_, _, _, _, _, _, _, _, _, _, _, _) t12\n val t13 : (_, _, _, _, _, _, _, _, _, _, _, _, _) t13\n val t14 : (_, _, _, _, _, _, _, _, _, _, _, _, _, _) t14\nend\n\nmodule type Slot = sig\n (** A [Slot.t] represents a slot in a tuple type. *)\n type ('variant, 'a) t [@@deriving sexp_of]\n\n val equal : ('v, 'a) t -> ('v, 'a) t -> bool\n\n (** [ti] is the [i]'th slot. *)\n\n val t0 : ([> `S0 of 'a ], 'a) t\n val t1 : ([> `S1 of 'a ], 'a) t\n val t2 : ([> `S2 of 'a ], 'a) t\n val t3 : ([> `S3 of 'a ], 'a) t\n val t4 : ([> `S4 of 'a ], 'a) t\n val t5 : ([> `S5 of 'a ], 'a) t\n val t6 : ([> `S6 of 'a ], 'a) t\n val t7 : ([> `S7 of 'a ], 'a) t\n val t8 : ([> `S8 of 'a ], 'a) t\n val t9 : ([> `S9 of 'a ], 'a) t\n val t10 : ([> `S10 of 'a ], 'a) t\n val t11 : ([> `S11 of 'a ], 'a) t\n val t12 : ([> `S12 of 'a ], 'a) t\n val t13 : ([> `S13 of 'a ], 'a) t\nend\n","open! Core_kernel\nopen! Import\ninclude Tuple_type_intf\n\nmodule Slots = struct\n type u_ = { slots_per_tuple : int } [@@deriving sexp_of]\n type ('tuple, 'variant) u = u_ [@@deriving sexp_of]\n type t_ = [ `Slots of u_ ] [@@deriving sexp_of]\n type ('tuple, 'variant) t = t_ [@@deriving sexp_of]\n\n let slots_per_tuple (`Slots { slots_per_tuple = n }) = n\n\n type 'a0 t1 = t_ [@@deriving sexp_of]\n type ('a0, 'a1) t2 = t_ [@@deriving sexp_of]\n type ('a0, 'a1, 'a2) t3 = t_ [@@deriving sexp_of]\n type ('a0, 'a1, 'a2, 'a3) t4 = t_ [@@deriving sexp_of]\n type ('a0, 'a1, 'a2, 'a3, 'a4) t5 = t_ [@@deriving sexp_of]\n type ('a0, 'a1, 'a2, 'a3, 'a4, 'a5) t6 = t_ [@@deriving sexp_of]\n type ('a0, 'a1, 'a2, 'a3, 'a4, 'a5, 'a6) t7 = t_ [@@deriving sexp_of]\n type ('a0, 'a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7) t8 = t_ [@@deriving sexp_of]\n type ('a0, 'a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8) t9 = t_ [@@deriving sexp_of]\n type ('a0, 'a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8, 'a9) t10 = t_ [@@deriving sexp_of]\n\n type ('a0, 'a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8, 'a9, 'a10) t11 = t_\n [@@deriving sexp_of]\n\n type ('a0, 'a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8, 'a9, 'a10, 'a11) t12 = t_\n [@@deriving sexp_of]\n\n type ('a0, 'a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8, 'a9, 'a10, 'a11, 'a12) t13 = t_\n [@@deriving sexp_of]\n\n type ('a0, 'a1, 'a2, 'a3, 'a4, 'a5, 'a6, 'a7, 'a8, 'a9, 'a10, 'a11, 'a12, 'a13) t14 =\n t_\n [@@deriving sexp_of]\n\n let t1 = `Slots { slots_per_tuple = 1 }\n let t2 = `Slots { slots_per_tuple = 2 }\n let t3 = `Slots { slots_per_tuple = 3 }\n let t4 = `Slots { slots_per_tuple = 4 }\n let t5 = `Slots { slots_per_tuple = 5 }\n let t6 = `Slots { slots_per_tuple = 6 }\n let t7 = `Slots { slots_per_tuple = 7 }\n let t8 = `Slots { slots_per_tuple = 8 }\n let t9 = `Slots { slots_per_tuple = 9 }\n let t10 = `Slots { slots_per_tuple = 10 }\n let t11 = `Slots { slots_per_tuple = 11 }\n let t12 = `Slots { slots_per_tuple = 12 }\n let t13 = `Slots { slots_per_tuple = 13 }\n let t14 = `Slots { slots_per_tuple = 14 }\nend\n","open! Core_kernel\nmodule Pool = Tuple_pool\nmodule Pointer = Pool.Pointer\n\n(* This pool holds nodes that would be represented more traditionally as:\n\n {[\n type 'a t =\n | Empty\n | Heap of 'a * 'a t list ]}\n\n We will represent them as a left-child, right-sibling tree in a triplet\n (value * left_child * right_sibling). The left child and all right siblings\n of the left child form a linked list representing the subheaps of a given heap:\n\n {v\n A\n /\n B -> C -> D -> E -> F\n / / /\n G H->I->J K->L\n v} *)\n\nmodule Node : sig\n (* Exposing [private int] is a significant performance improvement, because it allows\n the compiler to skip the write barrier. *)\n\n type 'a t = private int\n\n module Id : sig\n type t\n\n val of_int : int -> t\n val equal : t -> t -> bool\n end\n\n module Pool : sig\n type 'a node = 'a t\n type 'a t\n\n val create : min_size:int -> 'a t\n val is_full : 'a t -> bool\n val length : 'a t -> int\n val grow : 'a t -> 'a t\n val copy : 'a t -> 'a node -> 'a node * 'a t\n end\n\n (** [allocate v ~pool] allocates a new node from the pool with no child or sibling *)\n val allocate : 'a -> pool:'a Pool.t -> id:Id.t -> 'a t\n\n (** [free t ~pool] frees [t] for reuse. It is an error to access [t] after this. *)\n val free : 'a t -> pool:'a Pool.t -> unit\n\n (** a special [t] that represents the empty node *)\n val empty : unit -> 'a t\n\n val is_empty : 'a t -> bool\n val equal : 'a t -> 'a t -> bool\n\n (** [value_exn t ~pool] return the value of [t], raise if [is_empty t] *)\n val value_exn : 'a t -> pool:'a Pool.t -> 'a\n\n val id : 'a t -> pool:'a Pool.t -> Id.t\n val child : 'a t -> pool:'a Pool.t -> 'a t\n val sibling : 'a t -> pool:'a Pool.t -> 'a t\n\n (** [prev t] is either the parent of [t] or the sibling immediately left of [t] *)\n val prev : 'a t -> pool:'a Pool.t -> 'a t\n\n (** [add_child t ~child ~pool] Add a child to [t], preserving existing children as\n siblings of [child]. [t] and [child] should not be empty and [child] should have no\n sibling and have no prev node. *)\n val add_child : 'a t -> child:'a t -> pool:'a Pool.t -> unit\n\n (** disconnect and return the sibling *)\n val disconnect_sibling : 'a t -> pool:'a Pool.t -> 'a t\n\n (** disconnect and return the child *)\n val disconnect_child : 'a t -> pool:'a Pool.t -> 'a t\n\n (** [detach t ~pool] removes [t] from the tree, adjusting pointers around it. After\n [detach], [t] is the root of a standalone heap, which is detached from the original\n heap. *)\n val detach : 'a t -> pool:'a Pool.t -> unit\nend = struct\n module Id = Int\n\n let dummy_id : Id.t = -1\n\n type 'a node =\n ('a, 'a node Pointer.t, 'a node Pointer.t, 'a node Pointer.t, Id.t) Pool.Slots.t5\n\n type 'a t = 'a node Pointer.t\n\n let empty = Pointer.null\n let is_empty = Pointer.is_null\n let equal = Pointer.phys_equal\n let value t ~pool = Pool.get pool t Pool.Slot.t0\n let child t ~pool = Pool.get pool t Pool.Slot.t1\n let sibling t ~pool = Pool.get pool t Pool.Slot.t2\n let prev t ~pool = Pool.get pool t Pool.Slot.t3\n let id t ~pool = Pool.get pool t Pool.Slot.t4\n\n (* let set_value t v ~pool = Pool.set pool t Pool.Slot.t0 v *)\n let set_child t v ~pool = Pool.set pool t Pool.Slot.t1 v\n let set_sibling t v ~pool = Pool.set pool t Pool.Slot.t2 v\n let set_prev t v ~pool = Pool.set pool t Pool.Slot.t3 v\n\n let value_exn t ~pool =\n assert (not (is_empty t));\n value t ~pool\n ;;\n\n let allocate value ~pool ~id = Pool.new5 pool value (empty ()) (empty ()) (empty ()) id\n let free t ~pool = Pool.unsafe_free pool t\n\n let disconnect_sibling t ~pool =\n let sibling = sibling t ~pool in\n if not (is_empty sibling)\n then (\n set_sibling t (empty ()) ~pool;\n set_prev sibling (empty ()) ~pool);\n sibling\n ;;\n\n let disconnect_child t ~pool =\n let child = child t ~pool in\n if not (is_empty child)\n then (\n set_child t (empty ()) ~pool;\n set_prev child (empty ()) ~pool);\n child\n ;;\n\n let add_child t ~child:new_child ~pool =\n (* assertions we would make, but for speed:\n assert (not (is_empty t));\n assert (not (is_empty new_child));\n assert (is_empty (sibling new_child ~pool));\n assert (is_empty (prev new_child ~pool));\n *)\n let current_child = disconnect_child t ~pool in\n (* add [new_child] to the list of [t]'s children (which may be empty) *)\n set_sibling new_child current_child ~pool;\n if not (is_empty current_child) then set_prev current_child new_child ~pool;\n set_child t new_child ~pool;\n set_prev new_child t ~pool\n ;;\n\n let detach t ~pool =\n if not (is_empty t)\n then (\n let prev = prev t ~pool in\n if not (is_empty prev)\n then (\n let relation_to_prev = if equal t (child prev ~pool) then `child else `sibling in\n set_prev t (empty ()) ~pool;\n let sibling = disconnect_sibling t ~pool in\n (match relation_to_prev with\n | `child -> set_child prev sibling ~pool\n | `sibling -> set_sibling prev sibling ~pool);\n if not (is_empty sibling) then set_prev sibling prev ~pool))\n ;;\n\n module Pool = struct\n type 'a t = 'a node Pool.t\n type nonrec 'a node = 'a node Pointer.t\n\n let create (type a) ~min_size:capacity : a t =\n Pool.create\n Pool.Slots.t5\n ~capacity\n ~dummy:\n ( (Obj.magic None : a)\n , Pointer.null ()\n , Pointer.null ()\n , Pointer.null ()\n , dummy_id )\n ;;\n\n let is_full t = Pool.is_full t\n let length t = Pool.length t\n let grow t = Pool.grow t\n\n let copy t start =\n let t' = create ~min_size:(Pool.capacity t) in\n let copy_node node to_visit =\n if is_empty node\n then empty (), to_visit\n else (\n (* we use the same id, but that's ok since ids should be unique per heap *)\n let new_node =\n allocate (value_exn node ~pool:t) ~pool:t' ~id:(id node ~pool:t)\n in\n let to_visit =\n (new_node, `child, child node ~pool:t)\n :: (new_node, `sibling, sibling node ~pool:t)\n :: to_visit\n in\n new_node, to_visit)\n in\n let rec loop to_visit =\n match to_visit with\n | [] -> ()\n | (node_to_update, slot, node_to_copy) :: rest ->\n let new_node, to_visit = copy_node node_to_copy rest in\n (match slot with\n | `child -> set_child node_to_update new_node ~pool:t'\n | `sibling -> set_sibling node_to_update new_node ~pool:t');\n if not (is_empty new_node) then set_prev new_node node_to_update ~pool:t';\n loop to_visit\n in\n let new_start, to_visit = copy_node start [] in\n loop to_visit;\n new_start, t'\n ;;\n end\nend\n\ntype 'a t =\n { (* cmp is placed first to short-circuit polymorphic compare *)\n cmp : 'a -> 'a -> int\n ; mutable pool : 'a Node.Pool.t\n ; (* invariant: [root] never has a sibling *)\n mutable root : 'a Node.t\n ; mutable num_of_allocated_nodes : int\n }\n\nlet invariant _ t =\n let rec loop to_visit =\n match to_visit with\n | [] -> ()\n | (node, expected_prev, maybe_parent_value) :: rest ->\n if not (Node.is_empty node)\n then (\n let this_value = Node.value_exn node ~pool:t.pool in\n assert (Node.equal (Node.prev node ~pool:t.pool) expected_prev);\n Option.iter maybe_parent_value ~f:(fun parent_value ->\n assert (t.cmp parent_value this_value <= 0));\n loop\n ((Node.child node ~pool:t.pool, node, Some this_value)\n :: (Node.sibling node ~pool:t.pool, node, maybe_parent_value)\n :: rest))\n else loop rest\n in\n assert (Node.is_empty t.root || Node.is_empty (Node.sibling t.root ~pool:t.pool));\n loop [ t.root, Node.empty (), None ]\n;;\n\nlet create ?(min_size = 1) ~cmp () =\n { cmp\n ; pool = Node.Pool.create ~min_size\n ; root = Node.empty ()\n ; num_of_allocated_nodes = 0\n }\n;;\n\nlet copy { cmp; pool; root; num_of_allocated_nodes } =\n let root, pool = Node.Pool.copy pool root in\n { cmp; pool; root; num_of_allocated_nodes }\n;;\n\nlet allocate t v =\n if Node.Pool.is_full t.pool then t.pool <- Node.Pool.grow t.pool;\n t.num_of_allocated_nodes <- t.num_of_allocated_nodes + 1;\n Node.allocate v ~pool:t.pool ~id:(Node.Id.of_int t.num_of_allocated_nodes)\n;;\n\n(* translation:\n {[\n match root1, root2 with\n | None, h | h, None -> h\n | Some (Node (v1, children1)), Some (Node (v2, children2)) ->\n if v1 < v2\n then Some (Node (v1, root2 :: children1))\n else Some (Node (v2, root1 :: children2))\n ]}\n\n This function assumes neither root has a prev node (usually because the inputs come\n from [disconnect_*] or are the top of the heap or are the output of this function). *)\nlet merge t root1 root2 =\n if Node.is_empty root1\n then root2\n else if Node.is_empty root2\n then root1\n else (\n let add_child t node ~child =\n Node.add_child node ~pool:t.pool ~child;\n node\n in\n let v1 = Node.value_exn root1 ~pool:t.pool in\n let v2 = Node.value_exn root2 ~pool:t.pool in\n if t.cmp v1 v2 < 0\n then add_child t root1 ~child:root2\n else add_child t root2 ~child:root1)\n;;\n\nlet top_exn t =\n if Node.is_empty t.root\n then failwith \"Heap.top_exn called on an empty heap\"\n else Node.value_exn t.root ~pool:t.pool\n;;\n\nlet top t = if Node.is_empty t.root then None else Some (top_exn t)\n\nlet add_node t v =\n let node = allocate t v in\n t.root <- merge t t.root node;\n node\n;;\n\nlet add t v = ignore (add_node t v : _ Node.t)\n\n(* [merge_pairs] takes a list of heap roots and merges consecutive pairs, reducing the\n list of length n to n/2. Then it merges the merged pairs into a single heap. One\n intuition is that this is somewhat like building a single level of a binary tree.\n\n The output heap does not contain the value that was at the root of the input heap.\n\n We break the function into two parts. A first stage that is willing to use limited\n stack instead of heap allocation for bookkeeping, and a second stage that shifts to\n using a list as an accumulator if we go too deep.\n\n This can be made tail recursive and non-allocating by starting with an empty heap and\n merging merged pairs into it. Unfortunately this \"left fold\" version is not what is\n described in the original paper by Fredman et al.; they specifically say that\n children should be merged together from the end of the list to the beginning of the\n list. ([merge] is not associative, so order matters.)\n*)\n(* translation:\n {[\n let rec loop acc = function\n | [] -> acc\n | [head] -> head :: acc\n | head :: next1 :: next2 -> loop (merge head next1 :: acc) next2\n in\n match loop [] children with\n | [] -> None\n | [h] -> Some h\n | x :: xs -> Some (List.fold xs ~init:x ~f:merge)\n ]}\n*)\nlet allocating_merge_pairs t head =\n let rec loop acc head =\n if Node.is_empty head\n then acc\n else (\n let next1 = Node.disconnect_sibling head ~pool:t.pool in\n if Node.is_empty next1\n then head :: acc\n else (\n let next2 = Node.disconnect_sibling next1 ~pool:t.pool in\n loop (merge t head next1 :: acc) next2))\n in\n match loop [] head with\n | [] -> Node.empty ()\n | [ h ] -> h\n | x :: xs -> List.fold xs ~init:x ~f:(fun acc heap -> merge t acc heap)\n;;\n\n(* translation:\n {[\n match t.root with\n | Node (_, children) ->\n let rec loop depth children =\n if depth >= max_stack_depth\n then allocating_merge_pairs t childen\n else begin\n match children with\n | [] -> None\n | [head] -> Some head\n | head :: next1 :: next2 ->\n merge (merge head next1) (loop (depth + 1) next2)\n end\n in\n loop 0 children\n ]}\n*)\nlet merge_pairs =\n let max_stack_depth = 1_000 in\n let rec loop t depth head =\n if depth >= max_stack_depth\n then allocating_merge_pairs t head\n else if Node.is_empty head\n then head\n else (\n let next1 = Node.disconnect_sibling head ~pool:t.pool in\n if Node.is_empty next1\n then head\n else (\n let next2 = Node.disconnect_sibling next1 ~pool:t.pool in\n (* merge the first two nodes in our list, and then merge the result with the\n result of recursively calling merge_pairs on the tail *)\n merge t (merge t head next1) (loop t (depth + 1) next2)))\n in\n fun t head -> loop t 0 head\n;;\n\nlet remove_non_empty t node =\n let pool = t.pool in\n Node.detach node ~pool;\n let merged_children = merge_pairs t (Node.disconnect_child node ~pool) in\n let new_root =\n if Node.equal t.root node then merged_children else merge t t.root merged_children\n in\n Node.free node ~pool;\n t.root <- new_root\n;;\n\nlet remove_top t = if not (Node.is_empty t.root) then remove_non_empty t t.root\n\nlet pop_exn t =\n let r = top_exn t in\n remove_top t;\n r\n;;\n\nlet pop t = if Node.is_empty t.root then None else Some (pop_exn t)\n\nlet pop_if t f =\n match top t with\n | None -> None\n | Some v ->\n if f v\n then (\n remove_top t;\n Some v)\n else None\n;;\n\n(* pairing heaps are not balanced trees, and therefore we can't rely on a balance\n property to stop ourselves from overflowing the stack. *)\nlet fold t ~init ~f =\n let pool = t.pool in\n let rec loop acc to_visit =\n match to_visit with\n | [] -> acc\n | node :: rest ->\n if Node.is_empty node\n then loop acc rest\n else (\n let to_visit = Node.sibling ~pool node :: Node.child ~pool node :: rest in\n loop (f acc (Node.value_exn ~pool node)) to_visit)\n in\n loop init [ t.root ]\n;;\n\n(* almost identical to fold, copied for speed purposes *)\nlet iter t ~f =\n let pool = t.pool in\n let rec loop to_visit =\n match to_visit with\n | [] -> ()\n | node :: rest ->\n if Node.is_empty node\n then loop rest\n else (\n f (Node.value_exn ~pool node);\n let to_visit = Node.sibling ~pool node :: Node.child ~pool node :: rest in\n loop to_visit)\n in\n loop [ t.root ]\n;;\n\nlet length t = Node.Pool.length t.pool\n\nmodule C = Container.Make (struct\n type nonrec 'a t = 'a t\n\n let fold = fold\n let iter = `Custom iter\n let length = `Custom length\n end)\n\nlet is_empty t = Node.is_empty t.root\nlet mem = C.mem\nlet exists = C.exists\nlet for_all = C.for_all\nlet count = C.count\nlet sum = C.sum\nlet find = C.find\nlet find_map = C.find_map\nlet to_list = C.to_list\nlet to_array = C.to_array\nlet min_elt = C.min_elt\nlet max_elt = C.max_elt\nlet fold_result = C.fold_result\nlet fold_until = C.fold_until\n\nlet of_array arr ~cmp =\n let t = create ~min_size:(Array.length arr) ~cmp () in\n Array.iter arr ~f:(fun v -> add t v);\n t\n;;\n\nlet of_list l ~cmp = of_array (Array.of_list l) ~cmp\nlet sexp_of_t f t = Array.sexp_of_t f (to_array t |> Array.sorted_copy ~compare:t.cmp)\n\nmodule Elt = struct\n type nonrec 'a t =\n { mutable node : 'a Node.t\n ; node_id : Node.Id.t\n ; heap : 'a t\n }\n\n (* If ids are different, it means that the node has already been removed by some\n other means (and possibly reused). *)\n let is_node_valid t = Node.Id.equal (Node.id ~pool:t.heap.pool t.node) t.node_id\n\n let value t =\n if is_node_valid t then Some (Node.value_exn t.node ~pool:t.heap.pool) else None\n ;;\n\n let value_exn t =\n if is_node_valid t\n then Node.value_exn t.node ~pool:t.heap.pool\n else failwith \"Heap.value_exn: node was removed from the heap\"\n ;;\n\n let sexp_of_t sexp_of_a t = [%sexp (value t : a option)]\nend\n\nlet remove t (token : _ Elt.t) =\n if not (phys_equal t token.heap)\n then failwith \"cannot remove from a different heap\"\n else if not (Node.is_empty token.node)\n then (\n if Elt.is_node_valid token then remove_non_empty t token.node;\n token.node <- Node.empty ())\n;;\n\nlet add_removable t v =\n let node = add_node t v in\n { Elt.node; heap = t; node_id = Node.id ~pool:t.pool node }\n;;\n\nlet update t token v =\n remove t token;\n add_removable t v\n;;\n\nlet find_elt =\n let rec loop t f nodes =\n match nodes with\n | [] -> None\n | node :: rest ->\n if Node.is_empty node\n then loop t f rest\n else if f (Node.value_exn node ~pool:t.pool)\n then Some { Elt.node; heap = t; node_id = Node.id ~pool:t.pool node }\n else\n loop t f (Node.sibling node ~pool:t.pool :: Node.child node ~pool:t.pool :: rest)\n in\n fun t ~f -> loop t f [ t.root ]\n;;\n\nmodule Unsafe = struct\n module Elt = struct\n type 'a heap = 'a t\n type 'a t = 'a Node.t\n\n let value t heap = Node.value_exn ~pool:heap.pool t\n end\n\n let add_removable = add_node\n let remove = remove_non_empty\n\n let update t elt v =\n remove t elt;\n add_removable t v\n ;;\nend\n","open! Core_kernel\n\nmodule Make (M : sig\n val am_running_test : bool\n end) =\nstruct\n type 'a t = 'a [@@deriving bin_io, compare, sexp]\n\n let sexp_of_t sexp_of_a a =\n if M.am_running_test then Sexp.Atom \"\" else sexp_of_a a\n ;;\n\n module With_non_roundtripping_in_test_of_sexp = struct\n type nonrec 'a t = 'a t [@@deriving bin_io, compare, sexp]\n end\nend\n\nlet%test_module _ =\n (module struct\n module Turned_off = struct\n module Sexp_hidden_in_test_turned_off = Make (struct\n let am_running_test = false\n end)\n\n type nonrec t = int Sexp_hidden_in_test_turned_off.t [@@deriving sexp_of]\n end\n\n module Turned_on = struct\n module Sexp_hidden_in_test_turned_on = Make (struct\n let am_running_test = true\n end)\n\n type nonrec t = int Sexp_hidden_in_test_turned_on.t [@@deriving sexp_of]\n end\n\n let%expect_test \"Turned on\" =\n print_s [%sexp (1024 : Turned_on.t)];\n [%expect {| |}]\n ;;\n\n let%expect_test \"Turned off\" =\n print_s ([%sexp_of: Turned_off.t] 1024);\n [%expect {| 1024 |}]\n ;;\n end)\n;;\n\ninclude Make (struct\n let am_running_test = am_running_test\n end)\n","(* This module exploits the fact that OCaml does not perform context-switches under\n certain conditions. It can therefore avoid using mutexes.\n\n Given the semantics of the current OCaml runtime (and for the foreseeable future), code\n sections documented as atomic below will never contain a context-switch. The deciding\n criterion is whether they contain allocations or calls to external/builtin functions.\n If there is none, a context-switch cannot happen. Assignments without allocations,\n field access, pattern-matching, etc., do not trigger context-switches.\n\n Code reviewers should therefore make sure that the sections documented as atomic below\n do not violate the above assumptions. It is prudent to disassemble the .o file (using\n [objdump -dr]) and examine it. *)\n\nopen! Core_kernel\nopen! Import\n\nmodule Elt = struct\n type 'a t =\n { mutable value : 'a Uopt.t\n ; mutable next : ('a t Uopt.t[@sexp.opaque])\n }\n [@@deriving sexp_of]\n\n let create () = { value = Uopt.none; next = Uopt.none }\nend\n\ntype 'a t =\n { mutable length : int\n (* [front] to [back] has [length + 1] linked elements, where the first [length] hold the\n values in the queue, and the last is [back], holding no value. *)\n ; mutable front : 'a Elt.t\n ; mutable back : 'a Elt.t\n (* [unused_elts] is singly linked via [next], and ends with [sentinel]. All elts in\n [unused_elts] have [Uopt.is_none elt.value]. *)\n ; mutable unused_elts : 'a Elt.t Uopt.t\n }\n[@@deriving fields, sexp_of]\n\nlet invariant _invariant_a t =\n Invariant.invariant [%here] t [%sexp_of: _ t] (fun () ->\n let check f = Invariant.check_field t f in\n Fields.iter\n ~length:(check (fun length -> assert (length >= 0)))\n ~front:\n (check (fun front ->\n let i = ref t.length in\n let r = ref front in\n while !i > 0 do\n decr i;\n let elt = !r in\n r := Uopt.value_exn elt.Elt.next;\n assert (Uopt.is_some elt.value)\n done;\n assert (phys_equal !r t.back)))\n ~back:(check (fun back -> assert (Uopt.is_none back.Elt.value)))\n ~unused_elts:\n (check (fun unused_elts ->\n let r = ref unused_elts in\n while Uopt.is_some !r do\n let elt = Uopt.value_exn !r in\n r := elt.Elt.next;\n assert (Uopt.is_none elt.value)\n done)))\n;;\n\nlet create () =\n let elt = Elt.create () in\n { front = elt; back = elt; length = 0; unused_elts = Uopt.none }\n;;\n\nlet get_unused_elt t =\n (* BEGIN ATOMIC SECTION *)\n if Uopt.is_some t.unused_elts\n then (\n let elt = Uopt.unsafe_value t.unused_elts in\n t.unused_elts <- elt.next;\n elt (* END ATOMIC SECTION *))\n else Elt.create ()\n;;\n\nlet enqueue (type a) (t : a t) (a : a) =\n let new_back = get_unused_elt t in\n (* BEGIN ATOMIC SECTION *)\n t.length <- t.length + 1;\n t.back.value <- Uopt.some a;\n t.back.next <- Uopt.some new_back;\n t.back <- new_back\n;;\n\n(* END ATOMIC SECTION *)\n\nlet return_unused_elt t (elt : _ Elt.t) =\n (* BEGIN ATOMIC SECTION *)\n elt.value <- Uopt.none;\n elt.next <- t.unused_elts;\n t.unused_elts <- Uopt.some elt;\n (* END ATOMIC SECTION *)\n ()\n;;\n\nlet[@cold] raise_dequeue_empty t =\n failwiths\n ~here:[%here]\n \"Thread_safe_queue.dequeue_exn of empty queue\"\n t\n [%sexp_of: _ t]\n;;\n\nlet dequeue_exn t =\n (* BEGIN ATOMIC SECTION *)\n if t.length = 0 then raise_dequeue_empty t;\n let elt = t.front in\n let a = elt.value in\n t.front <- Uopt.unsafe_value elt.next;\n t.length <- t.length - 1;\n (* END ATOMIC SECTION *)\n return_unused_elt t elt;\n Uopt.unsafe_value a\n;;\n\nlet clear_internal_pool t = t.unused_elts <- Uopt.none\n\nmodule Private = struct\n module Uopt = Uopt\nend\n","include Core_kernel.Core_kernel_private.Time_ns_alternate_sexp\n\n(* [after] is like [add], but deals nicely with the case of overflow by instead returning\n [max_value]. Time-source functions use [after] to avoid immediately firing events that\n should never fire, due to the overflow leading to a negative time that appears to be in\n the past. We don't check underflow because that is very unlikely, requiring both a\n negative time and a negative span. *)\nlet after t span =\n let result = add t span in\n if Span.( > ) span Span.zero && result < t then max_value_for_1us_rounding else result\n;;\n","open Core_kernel\nopen Import\n\nlet debug = Debug.monitor\n\ntype t = Types.Monitor.t =\n { name : Info.t\n ; here : Source_code_position.t option\n ; id : int\n ; parent : t option\n ; mutable next_error : exn Types.Ivar.t\n ; (* [Monitor.send_exn] schedules a job for each element of [handlers_for_all_errors]. *)\n mutable handlers_for_all_errors : (Types.Execution_context.t * (exn -> unit)) Bag.t\n ; (* [Monitor.send_exn] extends each tail in [tails_for_all_errors]. *)\n mutable tails_for_all_errors : exn Types.Tail.t list\n ; mutable has_seen_error : bool\n ; mutable is_detached : bool\n }\n[@@deriving fields]\n\nmodule Pretty = struct\n type one =\n { name : Info.t\n ; here : Source_code_position.t option\n ; id : int\n ; has_seen_error : bool\n ; is_detached : bool\n }\n [@@deriving sexp_of]\n\n type t = one list [@@deriving sexp_of]\nend\n\nlet to_pretty =\n let rec loop\n { name\n ; here\n ; id\n ; parent\n ; has_seen_error\n ; is_detached\n ; next_error = _\n ; handlers_for_all_errors = _\n ; tails_for_all_errors = _\n }\n ac\n =\n let ac = { Pretty.name; here; id; has_seen_error; is_detached } :: ac in\n match parent with\n | None -> List.rev ac\n | Some t -> loop t ac\n in\n fun t -> loop t []\n;;\n\nlet sexp_of_t t = Pretty.sexp_of_t (to_pretty t)\n\nlet next_id =\n let r = ref 0 in\n fun () ->\n incr r;\n !r\n;;\n\nlet create_with_parent ?here ?info ?name parent =\n let id = next_id () in\n let name =\n match info, name with\n | Some i, None -> i\n | Some i, Some s -> Info.tag i ~tag:s\n | None, Some s -> Info.of_string s\n | None, None -> Info.create \"id\" id [%sexp_of: int]\n in\n let t =\n { name\n ; here\n ; parent\n ; id\n ; next_error = { cell = Empty }\n ; handlers_for_all_errors = Bag.create ()\n ; tails_for_all_errors = []\n ; has_seen_error = false\n ; is_detached = false\n }\n in\n if debug then Debug.log \"created monitor\" t [%sexp_of: t];\n t\n;;\n\nlet main = create_with_parent ~name:\"main\" None\n","module Time_ns_in_this_directory = Time_ns\nopen Core_kernel\nmodule Time_ns = Time_ns_in_this_directory\ninclude Async_kernel_config.Print_debug_messages_for\n\nlet log message a sexp_of_a =\n eprintf\n \"%s\\n%!\"\n (Sexp.to_string_hum\n ([%sexp_of: Sexp.t * Time_ns.t * string * a]\n (!Async_kernel_config.task_id (), Time_ns.now (), message, a)))\n;;\n\nlet log_string message = log message () [%sexp_of: unit]\n","module Debug_in_this_directory = Debug\nmodule Time_ns_in_this_directory = Time_ns\nopen! Core_kernel\ninclude Int.Replace_polymorphic_compare\nmodule Debug = Debug_in_this_directory\nmodule Time_ns = Time_ns_in_this_directory\nmodule Epoll_max_ready_events = Async_kernel_config.Epoll_max_ready_events\nmodule Max_inter_cycle_timeout = Async_kernel_config.Max_inter_cycle_timeout\nmodule Max_num_open_file_descrs = Async_kernel_config.Max_num_open_file_descrs\nmodule Max_num_threads = Async_kernel_config.Max_num_threads\nmodule Pool = Tuple_pool\n\nmodule Max_num_jobs_per_priority_per_cycle =\n Async_kernel_config.Max_num_jobs_per_priority_per_cycle\n\nlet concat = String.concat\nlet eprint = Core_kernel.Debug.eprint\nlet eprint_s = Core_kernel.Debug.eprint_s\nlet eprints = Core_kernel.Debug.eprints\nlet print_s sexp = printf \"%s\\n%!\" (sexp |> Sexp.to_string_hum)\nlet sec = Time_ns.Span.of_sec\n\n(* We don't want to use these modules in Async_kernel, to avoid difficulties with\n using it on js_of_ocaml. *)\nmodule Thread = struct end\nmodule Unix = struct end\n","open! Core_kernel\nopen! Import\n\ntype t =\n | Normal\n | Low\n[@@deriving sexp_of]\n\nlet normal = Normal\nlet low = Low\n","(* This file defines the mutually recursive types at the heart of Async. The functions\n associated with the types are defined in the corresponding file(s) for each module.\n This file should define only types, not functions, since functions defined inside the\n recursive modules are not inlined.\n\n If you need to add functionality to a module but doing so would create a dependency\n cycle, split the file into pieces as needed to break the cycle, e.g. scheduler0.ml,\n scheduler1.ml, scheduler.ml. *)\n\nopen! Core_kernel\nopen! Import\n\nmodule rec Cell : sig\n type any =\n [ `Empty\n | `Empty_one_handler\n | `Empty_one_or_more_handlers\n | `Full\n | `Indir\n ]\n\n type ('a, 'b) t =\n | Empty_one_or_more_handlers :\n { mutable run : 'a -> unit\n ; execution_context : Execution_context.t\n ; mutable prev : 'a Handler.t\n ; mutable next : 'a Handler.t\n }\n -> ('a, [> `Empty_one_or_more_handlers ]) t\n | Empty_one_handler :\n ('a -> unit) * Execution_context.t\n -> ('a, [> `Empty_one_handler ]) t\n | Empty : ('a, [> `Empty ]) t\n | Full : 'a -> ('a, [> `Full ]) t\n | Indir : 'a Ivar.t -> ('a, [> `Indir ]) t\nend =\n Cell\n\nand Handler : sig\n type 'a t = ('a, [ `Empty_one_or_more_handlers ]) Cell.t\nend =\n Handler\n\nand Ivar : sig\n type 'a t = { mutable cell : ('a, Cell.any) Cell.t }\n\n module Immutable : sig\n type 'a t = { cell : ('a, Cell.any) Cell.t }\n end\nend =\n Ivar\n\nand Deferred : sig\n type +'a t\nend =\n Deferred\n\nand Execution_context : sig\n type t =\n { monitor : Monitor.t\n ; priority : Priority.t\n ; local_storage : Univ_map.t\n ; tid : int\n ; backtrace_history : Backtrace.t list\n }\nend =\n Execution_context\n\nand Monitor : sig\n type t =\n { name : Info.t\n ; here : Source_code_position.t option\n ; id : int\n ; parent : t option\n ; mutable next_error : exn Ivar.t\n ; mutable handlers_for_all_errors : (Execution_context.t * (exn -> unit)) Bag.t\n ; mutable tails_for_all_errors : exn Tail.t list\n ; mutable has_seen_error : bool\n ; mutable is_detached : bool\n }\nend =\n Monitor\n\nand Tail : sig\n type 'a t = { mutable next : 'a Stream.next Ivar.t }\nend =\n Tail\n\nand Stream : sig\n type 'a t = 'a next Deferred.t\n\n and 'a next =\n | Nil\n | Cons of 'a * 'a t\nend =\n Stream\n\n(* We avoid using [module rec] to define [Bvar], so that [to_repr] and [of_repr] are\n inlined. *)\nmodule Bvar : sig\n type ('a, -'permission) t\n\n (** [repr] exists so that we may hide the implementation of a [Bvar.t], and then add a\n phantom type to it upstream. Without this, the phantom type variable would allow\n for anything to be coerced in and out, since it is unused. *)\n type 'a repr =\n { mutable has_any_waiters : bool\n ; mutable ivar : 'a Ivar.t\n }\n\n val of_repr : 'a repr -> ('a, 'permission) t\n val to_repr : ('a, 'permission) t -> 'a repr\nend = struct\n type 'a repr =\n { mutable has_any_waiters : bool\n ; mutable ivar : 'a Ivar.t\n }\n\n type ('a, 'permission) t = 'a repr\n\n let to_repr t = t\n let of_repr t = t\nend\n\nmodule rec Event : sig\n module Status : sig\n type t =\n | Aborted\n | Fired\n | Happening\n | Scheduled\n | Unscheduled\n end\n\n type t =\n { mutable alarm : Job_or_event.t Timing_wheel.Alarm.t\n ; mutable at : Time_ns.t\n ; callback : unit -> unit\n ; execution_context : Execution_context.t\n ; mutable interval : Time_ns.Span.t option\n ; mutable next_fired : t\n ; mutable status : Status.t\n }\nend =\n Event\n\nand External_job : sig\n type t = T : Execution_context.t * ('a -> unit) * 'a -> t\nend =\n External_job\n\nand Job : sig\n type slots = (Execution_context.t, Obj.t -> unit, Obj.t) Pool.Slots.t3\n type t = slots Pool.Pointer.t\nend =\n Job\n\nand Job_or_event : sig\n type t\nend =\n Job_or_event\n\nand Job_pool : sig\n type t = Job.slots Pool.t\nend =\n Job_pool\n\nand Job_queue : sig\n type t =\n { mutable num_jobs_run : int\n ; mutable jobs_left_this_cycle : int\n ; mutable jobs : Obj.t Uniform_array.t\n ; mutable mask : int\n ; mutable front : int\n ; mutable length : int\n }\nend =\n Job_queue\n\nand Jobs : sig\n type t =\n { scheduler : Scheduler.t\n ; mutable job_pool : Job_pool.t\n ; normal : Job_queue.t\n ; low : Job_queue.t\n }\nend =\n Jobs\n\nand Scheduler : sig\n\n type t =\n { mutable check_access : (unit -> unit) option\n ; mutable job_pool : Job_pool.t\n ; normal_priority_jobs : Job_queue.t\n ; low_priority_jobs : Job_queue.t\n ; very_low_priority_workers : Very_low_priority_worker.t Deque.t\n ; mutable main_execution_context : Execution_context.t\n ; mutable current_execution_context : Execution_context.t\n ; mutable uncaught_exn : (Exn.t * Sexp.t) option\n ; mutable cycle_count : int\n ; mutable cycle_start : Time_ns.t\n ; mutable in_cycle : bool\n ; mutable run_every_cycle_start : (unit -> unit) list\n ; mutable run_every_cycle_end : (unit -> unit) list\n ; mutable last_cycle_time : Time_ns.Span.t\n ; mutable last_cycle_num_jobs : int\n ; mutable total_cycle_time : Time_ns.Span.t\n ; mutable time_source : read_write Time_source.t1\n ; external_jobs : External_job.t Thread_safe_queue.t\n ; mutable thread_safe_external_job_hook : unit -> unit\n ; mutable job_queued_hook : (Priority.t -> unit) option\n ; mutable event_added_hook : (Time_ns.t -> unit) option\n ; mutable yield : (unit, read_write) Bvar.t\n ; mutable yield_until_no_jobs_remain : (unit, read_write) Bvar.t\n ; mutable check_invariants : bool\n ; mutable max_num_jobs_per_priority_per_cycle : Max_num_jobs_per_priority_per_cycle.t\n ; mutable record_backtraces : bool\n ; mutable on_start_of_cycle : unit -> unit\n ; mutable on_end_of_cycle : unit -> unit\n ; mutable long_jobs_last_cycle : (Execution_context.t * Time_ns.Span.t) list\n ; mutable cycle_started : bool\n }\nend =\n Scheduler\n\nand Time_source_id : Unique_id.Id = Unique_id.Int63 ()\n\nand Time_source : sig\n type -'rw t1 =\n { id : Time_source_id.t\n ; mutable advance_errors : Error.t list\n ; mutable am_advancing : bool\n ; events : Job_or_event.t Timing_wheel.t\n ; mutable fired_events : Event.t\n ; mutable most_recently_fired : Event.t\n ; handle_fired : Job_or_event.t Timing_wheel.Alarm.t -> unit\n ; is_wall_clock : bool\n ; scheduler : Scheduler.t\n }\nend =\n Time_source\n\nand Very_low_priority_worker : sig\n module Exec_result : sig\n type t =\n | Finished\n | Not_finished\n end\n\n type t =\n { execution_context : Execution_context.t\n ; exec : unit -> Exec_result.t\n }\nend =\n Very_low_priority_worker\n","open! Core_kernel\nopen! Import\nmodule Monitor = Monitor0\n\ntype t = Types.Execution_context.t =\n { monitor : Monitor.t\n ; priority : Priority.t\n ; local_storage : Univ_map.t\n ; tid : int\n ; backtrace_history : Backtrace.t list\n }\n[@@deriving fields, sexp_of]\n\nlet invariant (_ : t) = ()\n\nlet main =\n { monitor = Monitor.main\n ; priority = Priority.normal\n ; local_storage = Univ_map.empty\n ; tid = 0\n ; backtrace_history = []\n }\n;;\n\nlet create_like ?monitor ?priority ?local_storage t =\n let monitor = Option.value monitor ~default:t.monitor in\n { monitor\n ; priority = Option.value priority ~default:t.priority\n ; local_storage = Option.value local_storage ~default:t.local_storage\n ; tid = t.tid\n ; backtrace_history = t.backtrace_history\n }\n;;\n\nlet find_local t key = Univ_map.find t.local_storage key\n\nlet with_local t key data =\n { t with local_storage = Univ_map.change t.local_storage key ~f:(fun _ -> data) }\n;;\n\nlet with_tid t tid =\n { t with tid }\n;;\n\nlet record_backtrace t =\n { t with backtrace_history = Backtrace.get () :: t.backtrace_history }\n;;\n","open! Core_kernel\nopen! Import\nmodule Scheduler = Scheduler0\n\nlet dummy_e = Execution_context.main\nlet dummy_f : Obj.t -> unit = ignore\nlet dummy_a : Obj.t = Obj.repr ()\nlet slots_per_elt = 3\n\nmodule A = Uniform_array\n\n(* This is essentially a specialized [Flat_queue], done for reasons of speed. *)\ntype t = Types.Job_queue.t =\n { mutable num_jobs_run : int\n ; mutable jobs_left_this_cycle : int\n ; (* [jobs] is an array of length [capacity t * slots_per_elt], where each elt has the\n three components of a job ([execution_context], [f], [a]) in consecutive spots in\n [jobs]. [enqueue] doubles the length of [jobs] if [jobs] is full. [jobs] never\n shrinks. [jobs] is somewhat like a [Core_kernel.Pool] specialized to 3-tuples; we\n don't use [Pool] because that implements a set, where [jobs] is a queue. *)\n mutable jobs : (Obj.t A.t[@sexp.opaque])\n ; (* [mask] is [capacity t - 1], and is used for quickly computing [i mod (capacity\n t)] *)\n mutable mask : int\n ; (* [front] is the index of the first job in the queue. The array index of that job's\n execution context is [front * slots_per_elt]. *)\n mutable front : int\n ; mutable length : int\n }\n[@@deriving fields, sexp_of]\n\nlet offset t i = (t.front + i) land t.mask * slots_per_elt\nlet capacity t = t.mask + 1\n\nlet invariant t : unit =\n Invariant.invariant [%here] t [%sexp_of: t] (fun () ->\n let check f = Invariant.check_field t f in\n Fields.iter\n ~num_jobs_run:(check (fun num_jobs_run -> assert (num_jobs_run >= 0)))\n ~jobs_left_this_cycle:\n (check (fun jobs_left_this_cycle -> assert (jobs_left_this_cycle >= 0)))\n ~jobs:\n (check (fun jobs ->\n for i = 0 to t.length - 1 do\n Execution_context.invariant\n (Obj.obj (A.get jobs (offset t i)) : Execution_context.t)\n done))\n ~mask:\n (check (fun mask ->\n let capacity = mask + 1 in\n assert (Int.is_pow2 capacity);\n assert (capacity * slots_per_elt = A.length t.jobs)))\n ~front:\n (check (fun front ->\n assert (front >= 0);\n assert (front < capacity t)))\n ~length:\n (check (fun length ->\n assert (length >= 0);\n assert (length <= capacity t))))\n;;\n\nlet create_array ~capacity = A.create_obj_array ~len:(capacity * slots_per_elt)\n\nlet create () =\n let capacity = 1 in\n { num_jobs_run = 0\n ; jobs_left_this_cycle = 0\n ; jobs = create_array ~capacity\n ; mask = capacity - 1\n ; front = 0\n ; length = 0\n }\n;;\n\nlet clear t =\n t.front <- 0;\n t.length <- 0;\n t.jobs_left_this_cycle <- 0\n;;\n\nlet grow t =\n let old_capacity = capacity t in\n let new_capacity = old_capacity * 2 in\n let old_jobs = t.jobs in\n let old_front = t.front in\n let len1 = Int.min t.length (old_capacity - old_front) * slots_per_elt in\n let len2 = (t.length * slots_per_elt) - len1 in\n let new_jobs = create_array ~capacity:new_capacity in\n A.blit\n ~len:len1\n ~src:old_jobs\n ~src_pos:(old_front * slots_per_elt)\n ~dst:new_jobs\n ~dst_pos:0;\n A.blit ~len:len2 ~src:old_jobs ~src_pos:0 ~dst:new_jobs ~dst_pos:len1;\n t.mask <- new_capacity - 1;\n t.jobs <- new_jobs;\n t.front <- 0\n;;\n\nlet set (type a) t i execution_context f a =\n let offset = offset t i in\n A.unsafe_set t.jobs offset (Obj.repr (execution_context : Execution_context.t));\n A.unsafe_set t.jobs (offset + 1) (Obj.repr (f : a -> unit));\n A.unsafe_set t.jobs (offset + 2) (Obj.repr (a : a))\n;;\n\nlet enqueue t execution_context f a =\n if t.length = capacity t then grow t;\n set t t.length execution_context f a;\n t.length <- t.length + 1\n;;\n\nlet set_jobs_left_this_cycle t n =\n if n < 0\n then\n raise_s\n [%message \"Jobs.set_jobs_left_this_cycle got negative number\" (n : int) (t : t)];\n t.jobs_left_this_cycle <- n\n;;\n\nlet can_run_a_job t = t.length > 0 && t.jobs_left_this_cycle > 0\n\nlet run_job t (scheduler : Scheduler.t) execution_context f a =\n t.num_jobs_run <- t.num_jobs_run + 1;\n Scheduler.set_execution_context scheduler execution_context;\n f a\n;;\n\nlet run_external_jobs t (scheduler : Scheduler.t) =\n let external_jobs = scheduler.external_jobs in\n while Thread_safe_queue.length external_jobs > 0 do\n let (External_job.T (execution_context, f, a)) =\n Thread_safe_queue.dequeue_exn external_jobs\n in\n run_job t scheduler execution_context f a\n done\n;;\n\nlet run_jobs (type a) t (scheduler : Scheduler.t) =\n (* We do the [try-with] outside of the [while] because it is cheaper than doing a\n [try-with] for each job. *)\n (* [run_external_jobs] before entering the loop, since it might enqueue a job,\n changing [t.length]. *)\n try\n run_external_jobs t scheduler;\n while can_run_a_job t do\n let this_job = offset t 0 in\n let execution_context : Execution_context.t =\n Obj.obj (A.unsafe_get t.jobs this_job)\n in\n let f : a -> unit = Obj.obj (A.unsafe_get t.jobs (this_job + 1)) in\n let a : a = Obj.obj (A.unsafe_get t.jobs (this_job + 2)) in\n (* We clear out the job right now so that it isn't live at the next minor\n collection. We tried not doing this and saw significant (15% or so) performance\n hits due to spurious promotion. *)\n set t 0 dummy_e dummy_f dummy_a;\n t.front <- (t.front + 1) land t.mask;\n t.length <- t.length - 1;\n t.jobs_left_this_cycle <- t.jobs_left_this_cycle - 1;\n (* It is OK if [run_job] or [run_external_jobs] raises, in which case the exn is\n handled by the outer try-with. The only side effects we have done are to take\n the job out of the queue and decrement [jobs_left_this_cycle]. [run_job] or\n [run_external_jobs] may side effect [t], either by enqueueing jobs, or by\n clearing [t]. *)\n (!Tracing.fns).on_job_enter execution_context ;\n let start = Time_ns.now () in\n run_job t scheduler execution_context f a;\n let this_job_time = Time_ns.(diff (now ()) start) in\n if Float.(Time_ns.Span.to_ms this_job_time >= 2000.) then scheduler.long_jobs_last_cycle <- (execution_context, this_job_time) :: scheduler.long_jobs_last_cycle;\n (!Tracing.fns).on_job_exit execution_context this_job_time ;\n (* [run_external_jobs] at each iteration of the [while] loop, for fairness. *)\n run_external_jobs t scheduler\n done;\n Ok ()\n with\n | exn ->\n (* We call [Exn.backtrace] immediately after catching an unhandled exception, to\n ensure there is no intervening code that interferes with the global backtrace\n state. *)\n let backtrace = Backtrace.Exn.most_recent () in\n Error (exn, backtrace)\n;;\n","type tracing_fns =\n { on_job_enter : Execution_context.t -> unit\n ; on_job_exit : Execution_context.t -> Time_ns.Span.t -> unit }\n\nlet fns = ref { on_job_enter= (fun _ -> ()); on_job_exit= (fun _ _ -> ()) }\n","open! Core_kernel\nopen! Import\ninclude Types.External_job\n\nlet sexp_of_t _ = Sexp.Atom \"\"\n","open! Core_kernel\nopen! Import\nopen Pool\nmodule Pointer = Pointer\nmodule Slot = Slot\n\nlet dummy_e = Execution_context.main\nlet dummy_f : Obj.t -> unit = ignore\nlet dummy_a : Obj.t = Obj.repr ()\n\ntype slots = (Execution_context.t, Obj.t -> unit, (Obj.t[@sexp.opaque])) Slots.t3\n[@@deriving sexp_of]\n\ntype t = slots Pool.t [@@deriving sexp_of]\n\nlet invariant t = Pool.invariant ignore t\nlet create () = create Slots.t3 ~capacity:1 ~dummy:(dummy_e, dummy_f, dummy_a)\n","open! Core_kernel\nopen! Import\nmodule Event = Types.Event\nmodule Job = Types.Job\ninclude Types.Job_or_event\n\n(* This redefinition of [Event] is here so the type checks are right next to\n [Obj.magic]s. *)\nmodule Event_is_block : sig end = struct\n open Types\n open Event\n\n type _t = t =\n { (* must never be immediate *)\n mutable alarm : Job_or_event.t Timing_wheel.Alarm.t\n ; mutable at : Time_ns.t\n ; callback : unit -> unit\n ; execution_context : Execution_context.t\n ; mutable interval : Time_ns.Span.t option\n ; mutable next_fired : t\n ; mutable status : Status.t\n }\nend\n\nmodule Job_is_not_block : sig end = struct\n module Ensure_private_int (M : sig\n type t = private int\n end) =\n struct\n type _t = M.t\n end\n\n include Ensure_private_int (Job)\nend\n\nlet of_event event : t = Obj.magic (event : Event.t)\nlet of_job job : t = Obj.magic (job : Job.t)\nlet is_event (t : t) = Obj.is_block (Obj.repr t)\nlet is_job (t : t) = Obj.is_int (Obj.repr t)\n\nmodule Match = struct\n type _ kind =\n | Event : Event.t kind\n | Job : Job.t kind\n\n type packed = K : _ kind -> packed\n\n let kind t = if is_event t then K Event else K Job\n let project (type a) (_ : a kind) job_or_event = (Obj.magic : t -> a) job_or_event\nend\n","open! Core_kernel\nopen! Import\ninclude Types.Scheduler\n\nlet events t = t.time_source.events\n\nlet set_execution_context t execution_context =\n (* Avoid a caml_modify in most cases. *)\n (* XXX: see where job_queue also modifies current_execution_context *)\n if not (phys_equal t.current_execution_context execution_context) then (\n t.cycle_started <- false ;\n t.current_execution_context <- execution_context )\n","open! Core_kernel\nopen! Import\n\nmodule Time_ns = struct\n include Time_ns\n\n external format : float -> string -> string = \"core_kernel_time_ns_format\"\n\n (* We use a more pleasant format than [Core_kernel.Time_ns.sexp_of_t],\n which has to be messier for round trippability. *)\n let sexp_of_t t =\n [%sexp\n (format (t |> to_span_since_epoch |> Span.to_sec) \"%Y-%m-%dT%H:%M:%S%z\" : string)]\n ;;\nend\n\nmodule Alarm = struct\n include Timing_wheel.Alarm\n\n let is_null t = phys_equal t (null ())\nend\n\nmodule Alarm_precision = Timing_wheel.Alarm_precision\n\nlet default_timing_wheel_config =\n (* 1/8th of a millisecond alarm_precision seems sufficient to avoid having many alarms\n in the same interval, which avoids quadratic insertion sort when firing alarms. And\n the level bits give us levels of >1s, >1m, >1h, >1d. See test in\n [../test/test_synchronous_time_source.ml]. *)\n Timing_wheel.Config.create\n ~alarm_precision:Alarm_precision.(div about_one_millisecond ~pow2:3)\n ~level_bits:(Timing_wheel.Level_bits.create_exn [ 13; 6; 6; 5 ])\n ()\n;;\n\ntype callback = unit -> unit\n\nmodule Id = Types.Time_source_id\n\nmodule T1 = struct\n module Event = struct\n module Status = struct\n type t = Types.Event.Status.t =\n | Aborted\n (* in [fired_events], must not run *)\n | Fired\n (* in [fired_events], ready to run *)\n | Happening\n (* currently running the callback *)\n | Scheduled\n (* in the timing wheel *)\n | Unscheduled (* not in timing wheel or [fired_events] *)\n [@@deriving compare, sexp_of]\n\n let transition_is_allowed ~from ~to_ =\n match from, to_ with\n | Aborted, Unscheduled (* skipped running callback *)\n | Fired, Happening (* started running callback *)\n | Fired, Aborted (* aborted *)\n | Happening, Scheduled (* for repeating events *)\n | Happening, Unscheduled (* event callback finished *)\n | Scheduled, Fired (* moved from timing wheel to [fired_events] *)\n | Scheduled, Unscheduled (* aborted *)\n | Unscheduled, Fired (* event scheduled in the past *)\n | Unscheduled, Scheduled (* event scheduled in the future *) -> true\n | (Aborted | Fired | Happening | Scheduled | Unscheduled), _ -> false\n ;;\n end\n\n type t = Types.Event.t =\n { (* [alarm] is non-null iff the event is in the timing wheel. *)\n mutable alarm : Job_or_event.t Alarm.t\n ; mutable at : Time_ns.t\n ; callback : unit -> unit\n ; execution_context : Execution_context.t\n ; (* [interval] is the period for the periodic events *)\n mutable interval : Time_ns.Span.t option\n ; (* [next_fired] is a singly-linked list of fired events, linked via [next_fired].\n An event is added to the list when it fires, either because it is added with a\n time in the past, or because time advances. [advance_by_alarms] iterates over\n the events in [next_fired] and runs them, emptying the list. *)\n mutable next_fired : t\n ; mutable status : Status.t\n }\n [@@deriving fields]\n\n (* [none] is used to indicate the end of the singly-linked list of fired events. *)\n let rec none =\n { alarm = Alarm.null ()\n ; at = Time_ns.min_value_for_1us_rounding\n ; callback = (fun () -> assert false)\n ; execution_context = Execution_context.main\n ; interval = None\n ; next_fired = none\n ; status = Unscheduled\n }\n ;;\n\n let is_none t = phys_equal t none\n let is_some t = not (is_none t)\n\n let sexp_of_t\n ({ alarm = _\n ; at\n ; callback = _\n ; execution_context = _\n ; interval\n ; next_fired = _\n ; status\n } as t)\n =\n if is_none t\n then [%sexp \"none\"]\n else\n [%message\n \"\" (status : Status.t) (at : Time_ns.t) (interval : Time_ns.Span.t option)]\n ;;\n\n let invariant t =\n Invariant.invariant [%here] t [%sexp_of: t] (fun () ->\n let check f = Invariant.check_field t f in\n Fields.iter\n ~alarm:\n (check (fun alarm ->\n [%test_result: bool]\n (Alarm.is_null alarm)\n ~expect:\n (match t.status with\n | Aborted | Fired | Happening | Unscheduled -> true\n | Scheduled -> false)))\n ~at:ignore\n ~callback:ignore\n ~execution_context:ignore\n ~interval:ignore\n ~next_fired:\n (check (fun next_fired ->\n if is_some next_fired\n then (\n match t.status with\n | Aborted | Fired -> ()\n | Happening | Scheduled | Unscheduled -> assert false)))\n ~status:ignore)\n ;;\n\n let compare_at t1 t2 = Time_ns.compare t1.at t2.at\n\n let set_status t to_ =\n let from = t.status in\n if not (Status.transition_is_allowed ~from ~to_)\n then\n raise_s\n [%message\n [%here]\n \"bug -- set_status transition not allowed\"\n (from : Status.t)\n (to_ : Status.t)\n ~event:(t : t)];\n t.status <- to_\n ;;\n end\n\n module Job_or_event = struct\n include Job_or_event\n\n let sexp_of_t t =\n let open Job_or_event.Match in\n let (K k) = kind t in\n match k, project k t with\n | Event, event -> [%sexp (event : Event.t)]\n | Job, _ ->\n (* We don't display the [Job.t]s in [events] because those are\n pool pointers, which are uninformative. *)\n [%message \"\"]\n ;;\n end\n\n type -'rw t = 'rw Types.Time_source.t1 =\n { id : Id.t\n ; (* [advance_errors] accumulates errors raised by alarms run by\n [advance_by_alarms]. *)\n mutable advance_errors : Error.t list\n ; (* [am_advancing] is true only during [advance_by_alarms], and is used to cause\n callbacks to raise if they call [advance_by_alarms]. *)\n mutable am_advancing : bool\n ; events : Job_or_event.t Timing_wheel.t\n ; (* [fired_events] is the front of the singly linked list of fired events, which is\n stored in increasing order of [Event.at]. *)\n mutable fired_events : Event.t\n ; (* [most_recently_fired] is the event that was most recently inserted into\n [fired_events]. It is used as an optimization to allow insertion of subsequent\n events to start later in the list rather than at the beginning. It specifically\n avoids quadratic behavior when inserting multiple events that have exactly the\n same time -- the time source fires such events in the order they were added, and\n we want them to be in that same order in [fired_events]. *)\n mutable most_recently_fired : Event.t\n ; (* We store [handle_fired] in [t] to avoid allocating it every time we call\n [advance_clock]. *)\n handle_fired : Job_or_event.t Alarm.t -> unit\n ; is_wall_clock : bool\n ; scheduler : Scheduler0.t\n }\n [@@deriving fields]\n\n (* We don't include the [id] in the sexp because the user (rightly) can't control it, so\n it's hard to make it deterministic in tests. *)\n let sexp_of_t\n _\n { id = _\n ; advance_errors = _\n ; am_advancing = _\n ; events\n ; fired_events = _\n ; handle_fired = _\n ; is_wall_clock\n ; most_recently_fired = _\n ; scheduler = _\n }\n =\n let now = Timing_wheel.now events in\n if is_wall_clock\n then [%message \"wall_clock\" (now : Time_ns.t)]\n else (\n let all_events = ref [] in\n Timing_wheel.iter events ~f:(fun alarm ->\n all_events := (Alarm.at events alarm, Alarm.value events alarm) :: !all_events);\n let events =\n List.sort !all_events ~compare:(fun (at1, _) (at2, _) -> Time_ns.compare at1 at2)\n |> List.map ~f:snd\n in\n [%message \"\" (now : Time_ns.t) (events : Job_or_event.t list)])\n ;;\n\n let timing_wheel_now t = Timing_wheel.now t.events\n\n let is_in_fired_events t event =\n with_return (fun r ->\n let current = ref t.fired_events in\n while Event.is_some !current do\n if phys_equal !current event then r.return true;\n current := !current.next_fired\n done;\n false)\n ;;\n\n let invariant_with_jobs (type rw) ~job:(job_invariant : Job.t -> unit) (t : rw t) =\n Invariant.invariant [%here] t [%sexp_of: _ t] (fun () ->\n let check f = Invariant.check_field t f in\n Fields.iter\n ~id:ignore\n ~advance_errors:ignore\n ~am_advancing:ignore\n ~events:\n (check (fun events ->\n Timing_wheel.invariant ignore events;\n Timing_wheel.iter events ~f:(fun alarm ->\n let job_or_event = Alarm.value events alarm in\n let open Job_or_event.Match in\n let (K k) = kind job_or_event in\n match k, project k job_or_event with\n | Job, job -> job_invariant job\n | Event, event ->\n assert (phys_equal alarm event.alarm);\n [%test_result: Time_ns.t] event.at ~expect:(Alarm.at events alarm);\n [%test_result: Event.Status.t] event.status ~expect:Scheduled)))\n ~fired_events:\n (check (fun (fired_events : Event.t) ->\n let current = ref fired_events in\n while Event.is_some !current do\n assert (Time_ns.( <= ) !current.at (timing_wheel_now t));\n let next = !current.next_fired in\n if Event.is_some next then assert (Time_ns.( <= ) !current.at next.at);\n current := next\n done))\n ~handle_fired:ignore\n ~is_wall_clock:ignore\n ~most_recently_fired:\n (check (fun most_recently_fired ->\n if Event.is_some t.most_recently_fired\n then assert (is_in_fired_events t most_recently_fired)))\n ~scheduler:ignore)\n ;;\n\n let invariant t = invariant_with_jobs ~job:(fun _ -> ()) t\nend\n\nopen T1\n\ntype t = read T1.t [@@deriving sexp_of]\n\nlet invariant = invariant\nlet invariant_with_jobs = invariant_with_jobs\n\nmodule Read_write = struct\n type t = read_write T1.t [@@deriving sexp_of]\n\n let invariant = invariant\n let invariant_with_jobs = invariant_with_jobs\nend\n\nlet id t = t.id\nlet is_wall_clock t = t.is_wall_clock\nlet length t = Timing_wheel.length t.events\nlet max_allowed_alarm_time t = Timing_wheel.max_allowed_alarm_time t.events\nlet read_only (t : [> read ] T1.t) = (t :> t)\n\n(* [fire t event] sets [event.status = Fired] and inserts [event] into [t.fired_events] in\n sorted time order. *)\nlet fire t (event : Event.t) =\n Event.set_status event Fired;\n event.alarm <- Alarm.null ();\n let prev = ref Event.none in\n let current = ref t.fired_events in\n (* If [event] belongs after [t.most_recently_fired], then we start the insertion there\n rather than at the front of [t.fired_events]. This works nicely if we're getting the\n alarms in non-decreasing time order, which is close to what [Timing_wheel]\n provides (although [Timing_wheel] doesn't guarantee time ordering for times in the\n same interval). *)\n if Event.is_some t.most_recently_fired\n && Time_ns.( >= ) event.at t.most_recently_fired.at\n then (\n prev := t.most_recently_fired;\n current := !prev.next_fired);\n (* We use [Time_ns.( <= )] rather than [<] so that [event] is added after other events\n at the same time. Since [Timing_wheel] fires alarms in a bucket in the order in\n which they were added, using [<=] keeps events at the same time in the order in which\n they were added. *)\n while Event.is_some !current && Time_ns.( <= ) !current.at event.at do\n prev := !current;\n current := !current.next_fired\n done;\n event.next_fired <- !current;\n t.most_recently_fired <- event;\n if Event.is_none !prev then t.fired_events <- event else !prev.next_fired <- event\n;;\n\nlet alarm_precision t = Timing_wheel.alarm_precision t.events\nlet next_alarm_fires_at t = Timing_wheel.next_alarm_fires_at t.events\nlet now t = if t.is_wall_clock then Time_ns.now () else timing_wheel_now t\nlet timing_wheel_now = timing_wheel_now\n\nlet schedule t (event : Event.t) =\n Event.set_status event Scheduled;\n event.alarm <- Timing_wheel.add t.events ~at:event.at (event |> Job_or_event.of_event)\n;;\n\nmodule Event = struct\n include Event\n\n let create_internal t ~at ~interval ~callback =\n { alarm = Alarm.null ()\n ; at\n ; callback\n ; execution_context = t.scheduler.current_execution_context\n ; interval\n ; next_fired = none\n ; status = Unscheduled\n }\n ;;\n\n let add t event =\n if Time_ns.( <= ) event.at (timing_wheel_now t)\n then fire t event\n else schedule t event\n ;;\n\n let create_and_add t ~at ~interval ~callback =\n let event = create_internal t ~at ~interval ~callback in\n add t event;\n event\n ;;\n\n let at t at callback = create_and_add t ~at ~interval:None ~callback\n\n let after t span callback =\n create_and_add t ~at:(Time_ns.after (now t) span) ~interval:None ~callback\n ;;\n\n let require_span_at_least_alarm_precision t span =\n let alarm_precision = alarm_precision t in\n if Time_ns.Span.( < ) span alarm_precision\n then\n raise_s\n [%message\n \"interval span smaller than alarm precision\"\n (span : Time_ns.Span.t)\n (alarm_precision : Time_ns.Span.t)]\n ;;\n\n let at_intervals t span callback =\n require_span_at_least_alarm_precision t span;\n create_and_add t ~at:(now t) ~interval:(Some span) ~callback\n ;;\n\n module Abort_result = struct\n type t =\n | Ok\n | Currently_happening\n | Previously_unscheduled\n [@@deriving sexp_of]\n end\n\n let abort t (event : t) : Abort_result.t =\n match event.status with\n | Aborted -> Previously_unscheduled\n | Happening ->\n if Option.is_none event.interval\n then Currently_happening\n else (\n event.interval <- None;\n Ok)\n | Fired ->\n Event.set_status event Aborted;\n Ok\n | Scheduled ->\n Event.set_status event Unscheduled;\n Timing_wheel.remove t.events event.alarm;\n event.alarm <- Alarm.null ();\n Ok\n | Unscheduled -> Previously_unscheduled\n ;;\n\n let abort_if_possible t event = ignore (abort t event : Abort_result.t)\n\n let abort_exn t event =\n match abort t event with\n | Ok -> ()\n | reason ->\n raise_s\n [%message\n \"[Synchronous_time_source.abort_exn] cannot abort event\"\n (reason : Abort_result.t)]\n ;;\n\n let create t callback = create_internal t ~at:Time_ns.epoch ~interval:None ~callback\n\n let schedule_at_internal t (event : t) at ~interval =\n (* [Fired] is disallowed to prevent the user from entering into an infinite loop. The\n user could specify [at] in the past which would constantly add [callback] to the\n back of [t.next_fired] if this function is called from [callback]. *)\n match event.status with\n | (Aborted | Happening | Scheduled | Fired) as status ->\n Or_error.error_s\n [%message \"cannot schedule an event with status\" ~_:(status : Event.Status.t)]\n | Unscheduled ->\n event.at <- at;\n event.interval <- interval;\n add t event;\n Ok ()\n ;;\n\n let schedule_at t event at = schedule_at_internal t event at ~interval:None\n let schedule_after t event span = schedule_at t event (Time_ns.after (now t) span)\n\n let schedule_at_intervals t event span =\n require_span_at_least_alarm_precision t span;\n schedule_at_internal t event (now t) ~interval:(Some span)\n ;;\n\n module Reschedule_result = struct\n type t =\n | Ok\n | Currently_happening\n | Recently_aborted\n | Recently_fired\n [@@deriving sexp_of]\n end\n\n let reschedule_at t event at : Reschedule_result.t =\n match event.status with\n | Aborted -> Recently_aborted\n | Fired -> Recently_fired\n | Happening -> Currently_happening\n | Scheduled ->\n event.at <- at;\n if Time_ns.( > ) at (timing_wheel_now t)\n then Timing_wheel.reschedule t.events event.alarm ~at\n else (\n Timing_wheel.remove t.events event.alarm;\n fire t event);\n Ok\n | Unscheduled ->\n event.at <- at;\n event.interval <- None;\n add t event;\n Ok\n ;;\n\n let reschedule_after t event span = reschedule_at t event (Time_ns.after (now t) span)\n\n module Option = struct\n type value = t\n type nonrec t = t\n\n let is_none = is_none\n let is_some = is_some\n\n let some value =\n (* This assert shouldn't fail because [t] is a [value] and so should never\n be [none]. *)\n assert (is_some value);\n value\n ;;\n\n (* It should be impossible for [some_is_representable] to return [false]\n because its input is a [value], but since it's only loosely enforced we\n handle the general case. *)\n let some_is_representable value =\n assert (is_some value);\n true\n ;;\n\n let none = none\n let unchecked_value = Fn.id\n let value t ~default = if is_none t then default else unchecked_value t\n\n let value_exn t =\n if is_none t\n then raise_s [%message \"[Synchronous_time_source.Event.Option.value_exn None]\"];\n t\n ;;\n\n let to_option t = if is_none t then None else Some t\n\n let of_option = function\n | None -> none\n | Some t -> some t\n ;;\n\n let sexp_of_t t = to_option t |> [%sexp_of: t option]\n\n module Optional_syntax = struct\n module Optional_syntax = struct\n let is_none = is_none\n let unsafe_value = Fn.id\n end\n end\n end\n\nend\n\nlet run_after t span callback = ignore (Event.after t span callback : Event.t)\nlet run_at t at callback = ignore (Event.at t at callback : Event.t)\n\nlet run_at_intervals t span callback =\n ignore (Event.at_intervals t span callback : Event.t)\n;;\n\ntype send_exn = Monitor0.t -> ?backtrace:[ `Get | `This of Backtrace.t ] -> exn -> unit\n\nlet run_fired_events t ~(send_exn : send_exn option) =\n let current_execution_context = t.scheduler.current_execution_context in\n while Event.is_some t.fired_events do\n let event = t.fired_events in\n if phys_equal event t.most_recently_fired then t.most_recently_fired <- Event.none;\n t.fired_events <- event.next_fired;\n event.next_fired <- Event.none;\n match event.status with\n | Aborted -> Event.set_status event Unscheduled\n | Happening | Scheduled | Unscheduled -> assert false\n | Fired ->\n Event.set_status event Happening;\n (* We set the execution context so that [event.callback] runs in the same context\n that was in place when [event] was created. *)\n Scheduler0.set_execution_context t.scheduler event.execution_context;\n (match event.callback () with\n | exception exn ->\n (match send_exn with\n | None -> t.advance_errors <- Error.of_exn exn :: t.advance_errors\n | Some send_exn ->\n let backtrace = Backtrace.get () in\n send_exn event.execution_context.monitor exn ~backtrace:(`This backtrace));\n Event.set_status event Unscheduled\n | () ->\n (match event.interval with\n | None -> Event.set_status event Unscheduled\n | Some interval ->\n event.at\n <- Time_ns.next_multiple\n ()\n ~base:event.at\n ~after:(timing_wheel_now t)\n ~interval;\n schedule t event))\n done;\n Scheduler0.set_execution_context t.scheduler current_execution_context\n;;\n\nlet advance_clock t ~to_ ~send_exn =\n Timing_wheel.advance_clock t.events ~to_ ~handle_fired:t.handle_fired;\n run_fired_events t ~send_exn\n;;\n\nlet fire_past_alarms t ~send_exn =\n Timing_wheel.fire_past_alarms t.events ~handle_fired:t.handle_fired;\n run_fired_events t ~send_exn\n;;\n\nlet advance_internal t ~to_ ~send_exn =\n advance_clock t ~to_ ~send_exn;\n fire_past_alarms t ~send_exn\n;;\n\nlet prepare_to_advance t ~send_exn =\n if t.am_advancing\n then raise_s [%message \"cannot call [advance_by_alarms] from callback\"];\n t.am_advancing <- true;\n (match t.advance_errors with\n | [] -> ()\n | _ -> t.advance_errors <- []);\n run_fired_events t ~send_exn\n;;\n\nlet finish_advancing t =\n t.am_advancing <- false;\n match t.advance_errors with\n | [] -> Ok ()\n | errors ->\n t.advance_errors <- [];\n Error (Error.of_list errors)\n;;\n\nlet advance_by_alarms t ~to_ =\n let send_exn = None in\n prepare_to_advance t ~send_exn;\n let continue = ref true in\n while !continue do\n if Timing_wheel.is_empty t.events\n then continue := false\n else (\n let next_alarm_fires_at = Timing_wheel.next_alarm_fires_at_exn t.events in\n if Time_ns.( >= ) next_alarm_fires_at to_\n then continue := false\n else\n (* We use the actual alarm time, rather than [next_alarm_fires_at], so as not to\n expose (or accumulate errors associated with) the precision of\n [Timing_wheel]. *)\n advance_internal\n t\n ~to_:(Timing_wheel.max_alarm_time_in_min_interval_exn t.events)\n ~send_exn)\n done;\n advance_internal t ~to_ ~send_exn;\n finish_advancing t\n;;\n\nlet advance_directly t ~to_ =\n let send_exn = None in\n prepare_to_advance t ~send_exn;\n advance_internal t ~to_ ~send_exn;\n finish_advancing t\n;;\n\nmodule Expert = struct\n let max_alarm_time_in_min_timing_wheel_interval t =\n Timing_wheel.max_alarm_time_in_min_interval t.events\n ;;\n\n let has_events_to_run t = Event.is_some t.fired_events\nend\n","open Core_kernel\nopen Import\ninclude Scheduler0\nmodule Synchronous_time_source = Synchronous_time_source0\nmodule Event = Synchronous_time_source.Event\nmodule Alarm = Timing_wheel.Alarm\nmodule Job_or_event = Synchronous_time_source.T1.Job_or_event\n\nlet debug = Debug.scheduler\n\nmodule Ivar = struct\n open Types.Ivar\n\n let create_with_cell cell = { cell }\n let create () = create_with_cell Empty\n\n let create_full (type a) (a : a) =\n (* We allocate an immutable ivar and then cast it to a mutable ivar. The immutability\n allows OCaml to statically allocate the ivar if [a] is constant. This cast is safe\n because a full ivar is never mutated. We also believe that we will not trigger\n flambda to spuriously repor warning 59, mutation of known immutable data. All\n mutations of an ivar cell, i.e. [foo.cell <- ...], are directly preceded by a\n [match foo.cell] that prevents the [Full] case from reaching the modification. So\n flambda should always eliminate the [foo.cell <- ...] of a constant [Full] ivar,\n and not warn. *)\n (Obj.magic : a Immutable.t -> a t) { cell = Full a }\n ;;\nend\n\nmodule Bvar = struct\n open Types.Bvar\n\n let create () = of_repr { has_any_waiters = false; ivar = Ivar.create () }\nend\n\nmodule Very_low_priority_worker = struct\n module Exec_result = struct\n type t = Types.Very_low_priority_worker.Exec_result.t =\n | Finished\n | Not_finished\n [@@deriving sexp_of]\n end\n\n type t = Types.Very_low_priority_worker.t =\n { execution_context : Execution_context.t\n ; exec : unit -> Exec_result.t\n }\n [@@deriving fields, sexp_of]\n\n let invariant t =\n Invariant.invariant [%here] t [%sexp_of: t] (fun () ->\n let check f = Invariant.check_field t f in\n Fields.iter ~execution_context:(check Execution_context.invariant) ~exec:ignore)\n ;;\nend\n\ntype t = Scheduler0.t =\n { (* [check_access] optionally holds a function to run to check whether access to [t] is\n currently allowed. It is used to detect invalid access to the scheduler from a\n thread. *)\n mutable check_access : (unit -> unit) option\n ; mutable job_pool : Job_pool.t\n ; normal_priority_jobs : Job_queue.t\n ; low_priority_jobs : Job_queue.t\n ; very_low_priority_workers : Very_low_priority_worker.t Deque.t\n ; mutable main_execution_context : Execution_context.t\n ; mutable current_execution_context : Execution_context.t\n (* The scheduler calls [got_uncaught_exn] when an exception bubbles to the top of the\n monitor tree without being handled. This function guarantees to never run another\n job after this by calling [clear] and because [enqueue_job] will never add another\n job. *)\n ; mutable uncaught_exn : (Exn.t * Sexp.t) option\n ; mutable cycle_count : int\n ; mutable cycle_start : Time_ns.t\n ; mutable in_cycle : bool\n ; mutable run_every_cycle_start : (unit -> unit) list\n ; mutable run_every_cycle_end : (unit -> unit) list\n ; mutable last_cycle_time : Time_ns.Span.t\n ; mutable last_cycle_num_jobs : int\n ; mutable total_cycle_time : Time_ns.Span.t\n ; mutable time_source : read_write Synchronous_time_source.T1.t\n (* [external_jobs] is a queue of actions sent from outside of async. This is for the\n case where we want to schedule a job or fill an ivar from a context where it is not\n safe to run async code, because the async lock isn't held. For instance: - in an\n OCaml finalizer, as they can run at any time in any thread.\n\n The way to do it is to queue a thunk in [external_jobs] and call\n [thread_safe_external_job_hook], which is responsible for notifying the scheduler\n that new actions are available.\n\n When using Async on unix, [thread_safe_external_job_hook] is set in [Async_unix]\n to call [Interruptor.thread_safe_interrupt], which will wake up the\n [Async_unix] scheduler and run a cycle.\n\n Note that this hook might be used in other context (js_of_ocaml, mirage).\n\n When running a cycle, we pull external actions at every job and perform them\n immediately. *)\n ; external_jobs : External_job.t Thread_safe_queue.t\n ; mutable thread_safe_external_job_hook : unit -> unit\n (* [job_queued_hook] and [event_added_hook] aim to be used by js_of_ocaml. *)\n (* We use [_ option] here because those hooks will not be set in the common case\n and we want to avoid extra function calls. *)\n ; mutable job_queued_hook : (Priority.t -> unit) option\n ; mutable event_added_hook : (Time_ns.t -> unit) option\n ; mutable yield : ((unit, read_write) Types.Bvar.t[@sexp.opaque])\n ; mutable yield_until_no_jobs_remain :\n ((unit, read_write) Types.Bvar.t[@sexp.opaque] (* configuration*))\n ; mutable check_invariants : bool\n ; mutable max_num_jobs_per_priority_per_cycle : Max_num_jobs_per_priority_per_cycle.t\n ; mutable record_backtraces : bool\n ; mutable on_start_of_cycle : unit -> unit\n ; mutable on_end_of_cycle : unit -> unit\n ; mutable long_jobs_last_cycle : (Execution_context.t * Time_ns.Span.t) list\n ; mutable cycle_started : bool\n }\n[@@deriving fields, sexp_of]\n\nlet uncaught_exn_unwrapped = uncaught_exn\n\nlet uncaught_exn t =\n match t.uncaught_exn with\n | None -> None\n | Some (exn, sexp) ->\n Some (Error.create \"unhandled exception\" (exn, sexp) [%sexp_of: Exn.t * Sexp.t])\n;;\n\nlet num_pending_jobs t =\n Job_queue.length t.normal_priority_jobs + Job_queue.length t.low_priority_jobs\n;;\n\nlet num_jobs_run t =\n Job_queue.num_jobs_run t.normal_priority_jobs\n + Job_queue.num_jobs_run t.low_priority_jobs\n;;\n\nlet last_cycle_num_jobs t = t.last_cycle_num_jobs\n\nlet invariant t : unit =\n try\n let check f field = f (Field.get field t) in\n Fields.iter\n ~check_access:ignore\n ~job_pool:(check Job_pool.invariant)\n ~normal_priority_jobs:(check Job_queue.invariant)\n ~low_priority_jobs:(check Job_queue.invariant)\n ~very_low_priority_workers:\n (check (fun q -> Deque.iter q ~f:Very_low_priority_worker.invariant))\n ~main_execution_context:(check Execution_context.invariant)\n ~current_execution_context:(check Execution_context.invariant)\n ~uncaught_exn:\n (check (fun uncaught_exn ->\n if is_some uncaught_exn then assert (num_pending_jobs t = 0)))\n ~cycle_count:(check (fun cycle_count -> assert (cycle_count >= 0)))\n ~cycle_start:ignore\n ~in_cycle:ignore\n ~run_every_cycle_start:ignore\n ~run_every_cycle_end:ignore\n ~last_cycle_time:ignore\n ~total_cycle_time:ignore\n ~last_cycle_num_jobs:\n (check (fun last_cycle_num_jobs -> assert (last_cycle_num_jobs >= 0)))\n ~time_source:\n (check\n (Synchronous_time_source.Read_write.invariant_with_jobs ~job:(fun job ->\n assert (Pool.pointer_is_valid t.job_pool job))))\n ~external_jobs:ignore\n ~thread_safe_external_job_hook:ignore\n ~job_queued_hook:ignore\n ~event_added_hook:ignore\n ~yield:ignore\n ~yield_until_no_jobs_remain:ignore\n ~check_invariants:ignore\n ~max_num_jobs_per_priority_per_cycle:ignore\n ~record_backtraces:ignore\n ~cycle_started:ignore\n ~long_jobs_last_cycle:ignore\n ~on_start_of_cycle:ignore\n ~on_end_of_cycle:ignore\n with\n | exn -> raise_s [%message \"Scheduler.invariant failed\" (exn : exn) (t : t)]\n;;\n\nlet free_job t job = Pool.free t.job_pool job\n\nlet enqueue t (execution_context : Execution_context.t) f a =\n (* If there's been an uncaught exn, we don't add the job, since we don't want any jobs\n to run once there's been an uncaught exn. *)\n if is_none t.uncaught_exn\n then (\n let priority = execution_context.priority in\n let job_queue =\n match priority with\n | Normal -> t.normal_priority_jobs\n | Low -> t.low_priority_jobs\n in\n Job_queue.enqueue job_queue execution_context f a;\n match t.job_queued_hook with\n | None -> ()\n | Some f -> f priority)\n;;\n\nlet enqueue_job t job ~free_job =\n let job_pool = t.job_pool in\n enqueue\n t\n (Pool.get job_pool job Pool.Slot.t0)\n (Pool.get job_pool job Pool.Slot.t1)\n (Pool.get job_pool job Pool.Slot.t2);\n if free_job then Pool.free t.job_pool job\n;;\n\nlet handle_fired (time_source : _ Synchronous_time_source.T1.t) job_or_event =\n let open Job_or_event.Match in\n let (K k) = kind job_or_event in\n match k, project k job_or_event with\n | Job, job -> enqueue_job time_source.scheduler job ~free_job:true\n | Event, event -> Synchronous_time_source.fire time_source event\n;;\n\nlet create () =\n let now = Time_ns.now () in\n let rec t =\n { check_access = None\n ; job_pool = Job_pool.create ()\n ; normal_priority_jobs = Job_queue.create ()\n ; low_priority_jobs = Job_queue.create ()\n ; very_low_priority_workers = Deque.create ()\n ; main_execution_context = Execution_context.main\n ; current_execution_context = Execution_context.main\n ; uncaught_exn = None\n ; cycle_start = now\n ; cycle_count = 0\n ; in_cycle = false\n ; run_every_cycle_start = []\n ; run_every_cycle_end = []\n ; last_cycle_time = sec 0.\n ; last_cycle_num_jobs = 0\n ; total_cycle_time = sec 0.\n ; time_source\n ; external_jobs = Thread_safe_queue.create ()\n ; thread_safe_external_job_hook = ignore\n ; job_queued_hook = None\n ; event_added_hook = None\n ; yield = Bvar.create ()\n ; yield_until_no_jobs_remain = Bvar.create () (* configuration *)\n ; check_invariants = Async_kernel_config.check_invariants\n ; max_num_jobs_per_priority_per_cycle =\n Async_kernel_config.max_num_jobs_per_priority_per_cycle\n ; record_backtraces = Async_kernel_config.record_backtraces\n ; cycle_started = false\n ; on_start_of_cycle = Fn.id\n ; on_end_of_cycle = Fn.id\n ; long_jobs_last_cycle= []\n }\n and events =\n Timing_wheel.create ~config:Async_kernel_config.timing_wheel_config ~start:now\n and time_source : _ Synchronous_time_source.T1.t =\n { id = Types.Time_source_id.create ()\n ; advance_errors = []\n ; am_advancing = false\n ; events\n ; handle_fired = (fun alarm -> handle_fired time_source (Alarm.value events alarm))\n ; fired_events = Event.none\n ; is_wall_clock = true\n ; most_recently_fired = Event.none\n ; scheduler = t\n }\n in\n t\n;;\n\nlet is_dead t = is_some t.uncaught_exn\nlet set_check_access t f = t.check_access <- f\n\nlet t_ref =\n match Result.try_with create with\n | Ok t -> ref t\n | Error exn ->\n Debug.log \"Async cannot create its raw scheduler\" exn [%sexp_of: exn];\n exit 1\n;;\n\nlet check_access t =\n match t.check_access with\n | None -> ()\n | Some f -> f ()\n;;\n\nlet t () =\n let t = !t_ref in\n check_access t;\n t\n;;\n\nlet current_execution_context t =\n if t.record_backtraces\n then Execution_context.record_backtrace t.current_execution_context\n else t.current_execution_context\n;;\n\nlet with_execution_context t tmp_context ~f =\n let old_context = current_execution_context t in\n set_execution_context t tmp_context;\n protect ~f ~finally:(fun () -> set_execution_context t old_context)\n;;\n\nlet create_job (type a) t execution_context f a =\n if Pool.is_full t.job_pool then t.job_pool <- Pool.grow t.job_pool;\n Pool.new3\n t.job_pool\n execution_context\n (Obj.magic (f : a -> unit) : Obj.t -> unit)\n (Obj.repr (a : a))\n;;\n\nlet got_uncaught_exn t exn sexp =\n if debug then Debug.log \"got_uncaught_exn\" (exn, sexp) [%sexp_of: Exn.t * Sexp.t];\n List.iter [ t.normal_priority_jobs; t.low_priority_jobs ] ~f:Job_queue.clear;\n t.uncaught_exn <- Some (exn, sexp)\n;;\n\n(* [start_cycle t ~max_num_jobs_per_priority] enables subsequent calls of [run_jobs]\n to run up to [max_num_jobs_per_priority] jobs of each priority level. *)\nlet start_cycle t ~max_num_jobs_per_priority =\n let n = Max_num_jobs_per_priority_per_cycle.raw max_num_jobs_per_priority in\n Job_queue.set_jobs_left_this_cycle t.normal_priority_jobs n;\n Job_queue.set_jobs_left_this_cycle t.low_priority_jobs n\n;;\n\n(* [run_jobs t] removes jobs from [t] one at a time and runs them, stopping as soon\n as an unhandled exception is raised, or when no more jobs can be run at any priority,\n as per [~max_num_jobs_per_priority]. *)\nlet rec run_jobs t =\n match Job_queue.run_jobs t.normal_priority_jobs t with\n | Error _ as e -> e\n | Ok () ->\n (match Job_queue.run_jobs t.low_priority_jobs t with\n | Error _ as e -> e\n | Ok () ->\n if Job_queue.can_run_a_job t.normal_priority_jobs\n || Job_queue.can_run_a_job t.low_priority_jobs\n then run_jobs t\n else Ok ())\n;;\n\nlet stabilize t =\n start_cycle\n t\n ~max_num_jobs_per_priority:\n (Max_num_jobs_per_priority_per_cycle.create_exn Int.max_value);\n match run_jobs t with\n | Ok () -> Ok ()\n | Error (exn, _backtrace) -> Error exn\n;;\n\nlet create_time_source\n ?(timing_wheel_config = Async_kernel_config.timing_wheel_config)\n ~now\n ()\n =\n let t = t () in\n let events = Timing_wheel.create ~config:timing_wheel_config ~start:now in\n let rec time_source : _ Synchronous_time_source.T1.t =\n { id = Types.Time_source_id.create ()\n ; advance_errors = []\n ; am_advancing = false\n ; events\n ; handle_fired = (fun alarm -> handle_fired time_source (Alarm.value events alarm))\n ; fired_events = Event.none\n ; is_wall_clock = false\n ; most_recently_fired = Event.none\n ; scheduler = t\n }\n in\n time_source\n;;\n\nlet wall_clock () = Synchronous_time_source.read_only (t ()).time_source\n","open! Core_kernel\nopen! Import\nopen! Deferred_std\nmodule Deferred = Deferred1\nmodule Scheduler = Scheduler1\nmodule Stream = Async_stream\ninclude (Scheduler : module type of Scheduler with module Bvar := Scheduler.Bvar)\n\nlet t = Scheduler.t\n\ninclude Monitor.Exported_for_scheduler\n\nlet find_local key = Execution_context.find_local (current_execution_context (t ())) key\n\nlet with_local key value ~f =\n let t = t () in\n let execution_context =\n Execution_context.with_local (current_execution_context t) key value\n in\n with_execution_context t execution_context ~f\n;;\n\nlet main_execution_context = (t ()).main_execution_context\nlet can_run_a_job t = num_pending_jobs t > 0 || Bvar.has_any_waiters t.yield\nlet has_upcoming_event t = not (Timing_wheel.is_empty (events t))\nlet next_upcoming_event t = Timing_wheel.next_alarm_fires_at (events t)\nlet next_upcoming_event_exn t = Timing_wheel.next_alarm_fires_at_exn (events t)\nlet event_precision t = Timing_wheel.alarm_precision (events t)\nlet cycle_start t = t.cycle_start\nlet run_every_cycle_start t ~f = t.run_every_cycle_start <- f :: t.run_every_cycle_start\nlet run_every_cycle_end t ~f = t.run_every_cycle_end <- f :: t.run_every_cycle_end\n\nlet map_cycle_times t ~f =\n Stream.create (fun tail ->\n run_every_cycle_start t ~f:(fun () -> Tail.extend tail (f t.last_cycle_time)))\n;;\n\nlet long_cycles t ~at_least =\n Stream.create (fun tail ->\n run_every_cycle_start t ~f:(fun () ->\n if Time_ns.Span.( >= ) t.last_cycle_time at_least\n then Tail.extend tail t.last_cycle_time))\n;;\n\nlet long_cycles_with_context t ~at_least =\n Stream.create (fun tail ->\n run_every_cycle_start t ~f:(fun () ->\n if Time_ns.Span.( >= ) t.last_cycle_time at_least\n then Tail.extend tail (t.last_cycle_time,t.current_execution_context)))\n;;\n\nlet long_jobs_with_context t =\n Stream.create (fun tail ->\n run_every_cycle_start t ~f:(fun () ->\n List.iter t.long_jobs_last_cycle ~f:(fun job -> Tail.extend tail job) ; t.long_jobs_last_cycle <- [] ))\n;;\n\nlet cycle_num_jobs t =\n Stream.create (fun tail ->\n run_every_cycle_start t ~f:(fun () -> Tail.extend tail t.last_cycle_num_jobs))\n;;\n\nlet cycle_count t = t.cycle_count\n\nlet set_max_num_jobs_per_priority_per_cycle t int =\n t.max_num_jobs_per_priority_per_cycle\n <- Max_num_jobs_per_priority_per_cycle.create_exn int\n;;\n\nlet max_num_jobs_per_priority_per_cycle t =\n Max_num_jobs_per_priority_per_cycle.raw t.max_num_jobs_per_priority_per_cycle\n;;\n\nlet set_thread_safe_external_job_hook t f = t.thread_safe_external_job_hook <- f\n\nlet thread_safe_enqueue_external_job t execution_context f a =\n Thread_safe_queue.enqueue t.external_jobs (External_job.T (execution_context, f, a));\n t.thread_safe_external_job_hook ()\n;;\n\nlet set_event_added_hook t f = t.event_added_hook <- Some f\nlet set_job_queued_hook t f = t.job_queued_hook <- Some f\n\nlet create_alarm t f =\n let execution_context = current_execution_context t in\n Gc.Expert.Alarm.create (fun () ->\n thread_safe_enqueue_external_job t execution_context f ())\n;;\n\nlet add_finalizer t heap_block f =\n let execution_context = current_execution_context t in\n let finalizer heap_block =\n (* Here we can be in any thread, and may not be holding the async lock. So, we can\n only do thread-safe things.\n\n By putting [heap_block] in [external_jobs], we are keeping it alive until the next\n time the async scheduler gets around to dequeueing it. Calling\n [t.thread_safe_external_job_hook] ensures that will happen in short order. Thus,\n we are not dramatically increasing the lifetime of [heap_block], since the OCaml\n runtime already resurrected [heap_block] so that we could refer to it here. The\n OCaml runtime already removed the finalizer function when it noticed [heap_block]\n could be finalized, so there is no infinite loop in which we are causing the\n finalizer to run again. Also, OCaml does not impose any requirement on finalizer\n functions that they need to dispose of the block, so it's fine that we keep\n [heap_block] around until later. *)\n if Debug.finalizers then Debug.log_string \"enqueueing finalizer\";\n thread_safe_enqueue_external_job t execution_context f heap_block\n in\n if Debug.finalizers then Debug.log_string \"adding finalizer\";\n (* We use [Caml.Gc.finalise] instead of [Core_kernel.Gc.add_finalizer] because the latter\n has its own wrapper around [Caml.Gc.finalise] to run finalizers synchronously. *)\n try Caml.Gc.finalise finalizer heap_block with\n | Invalid_argument _ ->\n (* [Heap_block] ensures that this will only fail for static data, in which case we\n can drop the finalizer since the block will never be collected.*)\n ()\n;;\n\nlet add_finalizer_exn t x f =\n add_finalizer t (Heap_block.create_exn x) (fun heap_block ->\n f (Heap_block.value heap_block))\n;;\n\nlet add_finalizer_last t heap_block f =\n let execution_context = current_execution_context t in\n let finalizer () =\n (* Here we can be in any thread, and may not be holding the async lock. So, we can\n only do thread-safe things. *)\n if Debug.finalizers\n then Debug.log_string \"enqueueing finalizer (using 'last' semantic)\";\n thread_safe_enqueue_external_job t execution_context f ()\n in\n if Debug.finalizers then Debug.log_string \"adding finalizer (using 'last' semantic)\";\n (* We use [Caml.Gc.finalise_last] instead of [Core_kernel.Gc.add_finalizer_last] because\n the latter has its own wrapper around [Caml.Gc.finalise_last] to run finalizers\n synchronously. *)\n try Caml.Gc.finalise_last finalizer heap_block with\n | Invalid_argument _ ->\n (* [Heap_block] ensures that this will only fail for static data, in which case we\n can drop the finalizer since the block will never be collected.*)\n ()\n;;\n\nlet add_finalizer_last_exn t x f = add_finalizer_last t (Heap_block.create_exn x) f\n\n(** [force_current_cycle_to_end] sets the number of normal jobs allowed to run in this\n cycle to zero. Thus, after the currently running job completes, the scheduler will\n switch to low priority jobs and then end the current cycle. *)\nlet force_current_cycle_to_end t =\n Job_queue.set_jobs_left_this_cycle t.normal_priority_jobs 0\n;;\n\n(* We preallocate [send_exn] to avoid allocating it on each call to [advance_clock]. *)\nlet send_exn = Some Monitor.send_exn\n\nlet advance_clock t ~now =\n Synchronous_time_source0.advance_internal t.time_source ~to_:now ~send_exn\n;;\n\nlet run_cycle t =\n if debug then Debug.log \"run_cycle starting\" t [%sexp_of: t];\n t.on_start_of_cycle ();\n let now = Time_ns.now () in\n t.cycle_count <- t.cycle_count + 1;\n t.cycle_start <- now;\n t.in_cycle <- true;\n Bvar.broadcast t.yield ();\n let num_jobs_run_at_start_of_cycle = num_jobs_run t in\n List.iter t.run_every_cycle_start ~f:(fun f -> f ());\n advance_clock t ~now;\n start_cycle t ~max_num_jobs_per_priority:t.max_num_jobs_per_priority_per_cycle;\n let rec run_jobs t =\n match Scheduler.run_jobs t with\n | Ok () -> ()\n | Error (exn, backtrace) ->\n Monitor.send_exn (Monitor.current ()) exn ~backtrace:(`This backtrace);\n (* [run_jobs] stopped due to an exn. There may still be jobs that could be\n run this cycle, so [run_jobs] again. *)\n run_jobs t\n in\n run_jobs t;\n let cycle_time = Time_ns.diff (Time_ns.now ()) t.cycle_start in\n t.last_cycle_time <- cycle_time;\n t.last_cycle_num_jobs <- num_jobs_run t - num_jobs_run_at_start_of_cycle;\n t.total_cycle_time <- Time_ns.Span.(t.total_cycle_time + cycle_time);\n if Bvar.has_any_waiters t.yield_until_no_jobs_remain && num_pending_jobs t = 0\n then Bvar.broadcast t.yield_until_no_jobs_remain ();\n List.iter t.run_every_cycle_end ~f:(fun f -> f ());\n t.in_cycle <- false;\n t.on_end_of_cycle ();\n if debug\n then\n Debug.log\n \"run_cycle finished\"\n (uncaught_exn t, is_some (next_upcoming_event t))\n [%sexp_of: Error.t option * bool]\n;;\n\nlet run_cycles_until_no_jobs_remain () =\n if debug then Debug.log_string \"run_cycles_until_no_jobs_remain starting\";\n let t = t () in\n if is_dead t\n then\n raise_s\n [%message\n \"run_cycles_until_no_jobs_remain cannot proceed -- scheduler is dead\"\n ~scheduler:(t : t)];\n let rec loop () =\n run_cycle t;\n advance_clock t ~now:(Time_ns.now ());\n if can_run_a_job t then loop ()\n in\n loop ();\n (* Reset the current execution context to maintain the invariant that when we're not in\n a job, [current_execution_context = main_execution_context]. *)\n set_execution_context t t.main_execution_context;\n if debug then Debug.log_string \"run_cycles_until_no_jobs_remain finished\";\n Option.iter (uncaught_exn t) ~f:Error.raise\n;;\n\nlet make_async_unusable () =\n let t = !t_ref in\n t.check_access\n <- Some\n (fun () ->\n raise_s [%sexp \"Async scheduler is unusable due to [make_async_unusable]\"])\n;;\n\nlet reset_in_forked_process () =\n if debug then Debug.log_string \"reset_in_forked_process\";\n (* There is no need to empty [main_monitor_hole]. *)\n Scheduler.(t_ref := create ())\n;;\n\nlet check_invariants t = t.check_invariants\nlet set_check_invariants t b = t.check_invariants <- b\nlet set_record_backtraces t b = t.record_backtraces <- b\nlet set_on_start_of_cycle t f = t.on_start_of_cycle <- f\nlet set_on_end_of_cycle t f = t.on_end_of_cycle <- f\nlet yield t = Bvar.wait t.yield\n\nlet yield_until_no_jobs_remain ?(may_return_immediately = false) t =\n if may_return_immediately && num_pending_jobs t = 0\n then return ()\n else Bvar.wait t.yield_until_no_jobs_remain\n;;\n\nlet yield_every ~n =\n if n <= 0\n then raise_s [%message \"Scheduler.yield_every got nonpositive count\" (n : int)]\n else if n = 1\n then stage (fun t -> yield t)\n else (\n let count_until_yield = ref n in\n stage (fun t ->\n decr count_until_yield;\n if !count_until_yield > 0\n then return ()\n else (\n count_until_yield := n;\n yield t)))\n;;\n\nlet total_cycle_time t =\n (* Adjust for the fact the caller's probably an Async job. *)\n if t.in_cycle\n then (\n let this_cycle_time = Time_ns.(diff (now ()) t.cycle_start) in\n Time_ns.Span.(t.total_cycle_time + this_cycle_time))\n else t.total_cycle_time\n;;\n\nmodule Very_low_priority_work = struct\n module Worker_result = Very_low_priority_worker.Exec_result\n\n\n let rec run t = run_workers t ~num_execs_before_yielding:1_000\n\n and run_workers t ~num_execs_before_yielding =\n if num_execs_before_yielding = 0\n then yield_then_run t\n else if not (Deque.is_empty t.very_low_priority_workers)\n then (\n let worker = Deque.dequeue_front_exn t.very_low_priority_workers in\n set_execution_context t worker.execution_context;\n run_worker t worker ~num_execs_before_yielding)\n\n and yield_then_run t =\n if not (Deque.is_empty t.very_low_priority_workers)\n then Deferred.upon (yield t) (fun () -> run t)\n\n and run_worker t worker ~num_execs_before_yielding =\n assert (phys_equal t.current_execution_context worker.execution_context);\n if num_execs_before_yielding = 0\n then (\n Deque.enqueue_front t.very_low_priority_workers worker;\n yield_then_run t)\n else (\n let num_execs_before_yielding = num_execs_before_yielding - 1 in\n match worker.exec () with\n | Finished -> run_workers t ~num_execs_before_yielding\n | Not_finished -> run_worker t worker ~num_execs_before_yielding\n | exception exn ->\n let bt = Backtrace.Exn.most_recent () in\n Monitor.send_exn (Monitor.current ()) exn ~backtrace:(`This bt);\n run_workers t ~num_execs_before_yielding)\n ;;\n\n let enqueue ~f =\n let t = t () in\n let queue = t.very_low_priority_workers in\n let running = not (Deque.is_empty queue) in\n let execution_context =\n Execution_context.create_like (current_execution_context t) ~priority:Low\n in\n Deque.enqueue_back queue { execution_context; exec = f };\n if not running then enqueue t execution_context run t\n ;;\nend\n\nmodule For_bench = struct\n let advance_clock = advance_clock\nend\n","open! Core_kernel\nopen! Import\nmodule Scheduler = Scheduler1\nmodule Cell = Types.Cell\n\ntype any =\n [ `Empty\n | `Empty_one_handler\n | `Empty_one_or_more_handlers\n | `Full\n | `Indir\n ]\n\ntype 'a t = 'a Types.Ivar.t = { mutable cell : ('a, any) cell }\n\n(* The ['b] is used to encode the constructor. This allows us to write functions that\n take only one of the constructors, with no runtime test.\n\n We maintain the invariant that the directed graph with ivars as nodes and [Indir]s as\n edges is acyclic. The only functions that create an [Indir] are [squash] and\n [connect], and for those, the target of the [Indir] is always a non-[Indir]. Thus, the\n newly added edges are never part of a cycle. *)\nand ('a, 'b) cell = ('a, 'b) Types.Cell.t =\n | Empty_one_or_more_handlers :\n { (* [run] is mutable so we can set it to [ignore] when the handler is removed.\n This is used when we install a handler on a full ivar since it is immediately\n added to the scheduler. *)\n mutable run : 'a -> unit\n ; execution_context : Execution_context.t\n ; (* [prev] and [next] circularly doubly link all handlers of the same ivar. *)\n mutable prev : ('a, [ `Empty_one_or_more_handlers ]) cell\n ; mutable next : ('a, [ `Empty_one_or_more_handlers ]) cell\n }\n -> ('a, [> `Empty_one_or_more_handlers ]) cell\n | Empty_one_handler :\n ('a -> unit) * Execution_context.t\n -> ('a, [> `Empty_one_handler ]) cell\n | Empty : ('a, [> `Empty ]) cell\n | Full : 'a -> ('a, [> `Full ]) cell\n | Indir : 'a t -> ('a, [> `Indir ]) cell\n\nmodule Handler = struct\n type 'a t = ('a, [ `Empty_one_or_more_handlers ]) cell\n\n let run (Empty_one_or_more_handlers t : _ t) = t.run\n let execution_context (Empty_one_or_more_handlers t : _ t) = t.execution_context\n let prev (Empty_one_or_more_handlers t : _ t) = t.prev\n let next (Empty_one_or_more_handlers t : _ t) = t.next\n let set_run (Empty_one_or_more_handlers t : _ t) x = t.run <- x\n let set_prev (Empty_one_or_more_handlers t : _ t) x = t.prev <- x\n let set_next (Empty_one_or_more_handlers t : _ t) x = t.next <- x\n\n let create run execution_context =\n (* An optimized implementation of:\n\n {[\n let rec t =\n Empty_one_or_more_handlers\n { run\n ; execution_context\n ; prev = t\n ; next = t }\n in\n h1 ]}\n\n However the compilation of recursive value in OCaml is not optimal: the value is\n allocated twice and copied once (with a loop calling caml_modify). This is not\n necessary for simple recursive definitions like this one.\n\n Instead we allocate the value with dummy fields and update them after. *)\n let t =\n Empty_one_or_more_handlers\n { run; execution_context; prev = Obj.magic None; next = Obj.magic None }\n in\n set_prev t t;\n set_next t t;\n t\n ;;\n\n let create2 run1 execution_context1 run2 execution_context2 =\n (* An optimized implementation of:\n\n {[\n let rec t1 =\n { run = run1\n ; execution_context = execution_context1\n ; prev = t2\n ; next = t2 }\n and t2 =\n { run = run2\n ; execution_context = execution_context2\n ; prev = t1\n ; next = t1 }\n in\n t1 ]} *)\n let t1 =\n Empty_one_or_more_handlers\n { run = run1\n ; execution_context = execution_context1\n ; prev = Obj.magic None\n ; next = Obj.magic None\n }\n in\n let t2 =\n Empty_one_or_more_handlers\n { run = run2; execution_context = execution_context2; prev = t1; next = t1 }\n in\n set_prev t1 t2;\n set_next t1 t2;\n t1\n ;;\n\n let invariant t =\n Execution_context.invariant (execution_context t);\n let r = ref (next t) in\n while not (phys_equal !r t) do\n let t1 = !r in\n assert (phys_equal (prev (next t1)) t1);\n Execution_context.invariant (execution_context t1);\n r := next !r\n done\n ;;\n\n let is_singleton t = phys_equal t (next t)\n\n let length t =\n let n = ref 1 in\n let r = ref (next t) in\n while not (phys_equal !r t) do\n incr n;\n r := next !r\n done;\n !n\n ;;\n\n let enqueue t scheduler v = Scheduler.enqueue scheduler (execution_context t) (run t) v\n\n let schedule_jobs t v =\n let scheduler = Scheduler.t () in\n enqueue t scheduler v;\n let r = ref (next t) in\n while not (phys_equal !r t) do\n enqueue !r scheduler v;\n r := next !r\n done\n ;;\n\n let unlink t =\n set_prev (next t) (prev t);\n set_next (prev t) (next t);\n set_prev t t;\n set_next t t\n ;;\n\n let add t run execution_context =\n let result =\n Empty_one_or_more_handlers { run; execution_context; prev = prev t; next = t }\n in\n set_next (prev t) result;\n set_prev t result;\n result\n ;;\n\n (* [splice t1 t2] creates:\n\n {v\n --> t1 <--> ... <--> last1 <--> t2 <--> ... <--> last2 <--\n | |\n ----------------------------------------------------------\n v} *)\n let splice t1 t2 =\n let last1 = prev t1 in\n let last2 = prev t2 in\n set_next last1 t2;\n set_next last2 t1;\n set_prev t1 last2;\n set_prev t2 last1\n ;;\n\n let of_list l =\n match l with\n | [] -> None\n | (run, execution_context) :: l ->\n let first = create run execution_context in\n let rec loop prev l =\n match l with\n | [] -> set_prev first prev\n | (run, execution_context) :: l ->\n let t =\n Empty_one_or_more_handlers { run; execution_context; prev; next = first }\n in\n set_next prev t;\n loop t l\n in\n loop first l;\n Some first\n ;;\n\n let to_list first =\n let rec loop t acc =\n let acc = (run t, execution_context t) :: acc in\n if phys_equal t first then acc else loop (prev t) acc\n in\n loop (prev first) []\n ;;\n\n let sexp_of_t _ (t : _ t) =\n let (Empty_one_or_more_handlers { run = _; execution_context; next = _; prev = _ }) =\n t\n in\n [%message (execution_context : Execution_context.t)]\n ;;\nend\n\ntype 'a ivar = 'a t\n\n(* Compiled as the identity. *)\nlet cell_of_handler : _ Handler.t -> _ = function\n | Empty_one_or_more_handlers _ as x -> (x :> (_, any) cell)\n;;\n\nlet equal (t : _ t) t' = phys_equal t t'\nlet indir t = { cell = Indir t }\n\ninclude Scheduler.Ivar\n\n(* [squash t] returns the non-[Indir] ivar at the end of the (possibly empty) chain of\n [Indir]s starting with [t] and ensures that all [Indir]s along that chain are replaced\n with an [Indir] pointing to the end of the chain. *)\nlet squash =\n let rec follow indir t =\n (* [indir = Indir t] *)\n match t.cell with\n | Indir t' as indir' -> follow indir' t'\n | _ -> indir\n in\n let rec update t indir =\n match t.cell with\n | Indir t' ->\n t.cell <- indir;\n update t' indir\n | _ -> t\n in\n fun t ->\n match t.cell with\n | Indir t' ->\n (match t'.cell with\n | Indir t'' as indir -> update t (follow indir t'')\n | _ -> t' (* nothing to do, since [t] is a chain with a single [Indir] *))\n | _ -> t\n;;\n\n(* nothing to do, since [t] isn't an [Indir]. *)\n\nlet invariant a_invariant t =\n let t = squash t in\n match t.cell with\n | Indir _ -> assert false (* fulfilled by [squash] *)\n | Full a -> a_invariant a\n | Empty -> ()\n | Empty_one_handler (_, execution_context) ->\n Execution_context.invariant execution_context\n | Empty_one_or_more_handlers _ as handler -> Handler.invariant handler\n;;\n\nlet sexp_of_t sexp_of_a t : Sexp.t =\n let t = squash t in\n match t.cell with\n | Indir _ -> assert false (* fulfilled by [squash] *)\n | Full a -> List [ Atom \"Full\"; sexp_of_a a ]\n | Empty | Empty_one_handler _ | Empty_one_or_more_handlers _ -> Atom \"Empty\"\n;;\n\nlet peek t =\n let t = squash t in\n match t.cell with\n | Indir _ -> assert false (* fulfilled by [squash] *)\n | Full a -> Some a\n | Empty | Empty_one_handler _ | Empty_one_or_more_handlers _ -> None\n;;\n\nlet value t ~if_empty_then_failwith =\n let t = squash t in\n match t.cell with\n | Indir _ -> assert false (* fulfilled by [squash] *)\n | Full a -> a\n | Empty | Empty_one_handler _ | Empty_one_or_more_handlers _ ->\n failwith if_empty_then_failwith\n;;\n\nlet value_exn t = value t ~if_empty_then_failwith:\"Ivar.value_exn called on empty ivar\"\n\nlet is_empty t =\n let t = squash t in\n match t.cell with\n | Indir _ -> assert false (* fulfilled by [squash] *)\n | Full _ -> false\n | Empty | Empty_one_handler _ | Empty_one_or_more_handlers _ -> true\n;;\n\nlet is_full t = not (is_empty t)\n\nlet fill t v =\n let t = squash t in\n match t.cell with\n | Indir _ -> assert false (* fulfilled by [squash] *)\n | Full _ -> raise_s [%message \"Ivar.fill of full ivar\" (t : _ t)]\n | Empty -> t.cell <- Full v\n | Empty_one_handler (run, execution_context) ->\n t.cell <- Full v;\n Scheduler.(enqueue (t ())) execution_context run v\n | Empty_one_or_more_handlers _ as handler ->\n t.cell <- Full v;\n Handler.schedule_jobs handler v\n;;\n\nlet remove_handler t (handler : _ Handler.t) =\n Handler.set_run handler ignore;\n let t = squash t in\n match t.cell with\n | Indir _ -> assert false (* fulfilled by [squash] *)\n | Empty | Empty_one_handler _ ->\n (* These are only possible if [handler] was already removed. *)\n ()\n | Full _ ->\n (* This is possible if [t] was filled before we try to remove the handler. E.g.\n [Deferred.choose] will do this. *)\n ()\n | Empty_one_or_more_handlers _ as cell ->\n if Handler.is_singleton handler\n then t.cell <- Empty\n else (\n if phys_equal handler cell then t.cell <- cell_of_handler (Handler.next handler);\n Handler.unlink handler)\n;;\n\nlet add_handler t run execution_context =\n let t = squash t in\n match t.cell with\n | Indir _ -> assert false (* fulfilled by [squash] *)\n | Empty ->\n let handler = Handler.create run execution_context in\n t.cell <- cell_of_handler handler;\n handler\n | Empty_one_handler (run', execution_context') ->\n let handler = Handler.create2 run execution_context run' execution_context' in\n t.cell <- cell_of_handler handler;\n handler\n | Empty_one_or_more_handlers _ as handler -> Handler.add handler run execution_context\n | Full v ->\n let handler = Handler.create run execution_context in\n (* [run] calls [handler.run], which, if [handler] has been removed, has been changed\n to [ignore]. *)\n let run v = Handler.run handler v in\n Scheduler.(enqueue (t ())) execution_context run v;\n handler\n;;\n\nlet has_handlers t =\n let t = squash t in\n match t.cell with\n | Indir _ -> assert false (* fulfilled by [squash] *)\n | Empty_one_handler _ | Empty_one_or_more_handlers _ -> true\n | Empty | Full _ -> false\n;;\n\nlet upon' t run = add_handler t run Scheduler.(current_execution_context (t ()))\n\n(* [upon] is conceptually the same as:\n\n {[\n let upon t f = ignore (upon' t run) ]}\n\n However, below is a more efficient implementation, which is worth doing because [upon]\n is very widely used and is so much more common than [upon']. The below implementation\n avoids the use of the bag of handlers in the extremely common case of one handler for\n the deferred. *)\nlet upon t run =\n let scheduler = Scheduler.t () in\n let execution_context = Scheduler.current_execution_context scheduler in\n let t = squash t in\n match t.cell with\n | Indir _ -> assert false (* fulfilled by [squash] *)\n | Full v -> Scheduler.enqueue scheduler execution_context run v\n | Empty -> t.cell <- Empty_one_handler (run, execution_context)\n | Empty_one_handler (run', execution_context') ->\n t.cell\n <- cell_of_handler (Handler.create2 run execution_context run' execution_context')\n | Empty_one_or_more_handlers _ as handler ->\n ignore (Handler.add handler run execution_context : _ Handler.t)\n;;\n\n(* [connect] takes ivars [bind_result] and [bind_rhs], and makes [bind_rhs]\n be an [Indir] pointing to the non-indir cell reachable from [bind_result]. On entry\n to [connect], [bind_result] and [bind_rhs] may be chains, since [bind_rhs] is an\n arbitrary user-supplied deferred, and [bind_result] is returned to the user prior to\n being [connect]ed, and may have been converted to an indirection in the case of\n right-nested binds.\n\n The purpose of [connect] is to make tail-recursive bind loops use constant space.\n E.g.:\n\n {[\n let rec loop i =\n if i = 0\n then return ()\n else (\n let%bind () = after (sec 1.) in\n loop (i - 1)) ]}\n\n [connect] makes intermediate bind results all be [Indir]s pointing at the outermost\n bind, rather than being a linear-length chain, with each pointing to the previous one.\n Then, since the program is only holding on to the innermost and outermost binds all the\n intermediate ones can be garbage collected.\n\n [connect] works by squashing its arguments so that the [bind_rhs] always points at the\n ultimate result. *)\nlet connect =\n (* [repoint_indirs ~ivar ~indir ~bind_result] repoints to [indir] all the ivars in the\n chain reachable from [ivar], and returns the non-[Indir] cell at the end of the\n chain. After repointing, we will merge the handlers in that cell with the handlers\n in [bind_result], and put the merged set of handlers in [bind_result]. *)\n let rec repoint_indirs ~ivar ~indir ~bind_result =\n let cell = ivar.cell in\n match cell with\n | Indir ivar' ->\n ivar.cell <- indir;\n repoint_indirs ~ivar:ivar' ~indir ~bind_result\n | Full _ -> cell\n | Empty | Empty_one_handler _ | Empty_one_or_more_handlers _ ->\n (* It is possible that [bind_result] and [bind_rhs] are not equal, but their chains\n of indirs lead to the same non-[Indir] cell, in which case we cannot set that\n cell to point to itself, because that would introduce a cycle. *)\n if not (phys_equal ivar bind_result) then ivar.cell <- indir;\n cell\n in\n fun ~bind_result ~bind_rhs ->\n if not (phys_equal bind_result bind_rhs)\n then (\n let bind_result = squash bind_result in\n let indir = Indir bind_result in\n let bind_rhs_contents = repoint_indirs ~ivar:bind_rhs ~indir ~bind_result in\n (* update [bind_result] with the union of handlers in [bind_result] and\n [bind_rhs] *)\n match bind_result.cell, bind_rhs_contents with\n | Indir _, _ | _, Indir _ -> assert false\n (* fulfilled by [squash] and [repoint_indirs] *)\n (* [connect] is only used in bind, whose ivar is only ever exported as a read-only\n deferred. Thus, [bind_result] must be empty. *)\n | Full _, _ -> assert false\n | _, Empty -> ()\n | Empty, _ -> bind_result.cell <- bind_rhs_contents\n | Empty_one_handler (run, execution_context), Full v ->\n bind_result.cell <- bind_rhs_contents;\n Scheduler.(enqueue (t ())) execution_context run v\n | (Empty_one_or_more_handlers _ as handler), Full v ->\n bind_result.cell <- bind_rhs_contents;\n Handler.schedule_jobs handler v\n | ( Empty_one_handler (run1, execution_context1)\n , Empty_one_handler (run2, execution_context2) ) ->\n let handler1 = Handler.create2 run1 execution_context1 run2 execution_context2 in\n bind_result.cell <- cell_of_handler handler1\n | ( (Empty_one_or_more_handlers _ as handler1)\n , Empty_one_handler (run2, execution_context2) ) ->\n ignore (Handler.add handler1 run2 execution_context2 : _ Handler.t)\n | ( Empty_one_handler (run1, execution_context1)\n , (Empty_one_or_more_handlers _ as handler2) ) ->\n let handler1 = Handler.add handler2 run1 execution_context1 in\n bind_result.cell <- cell_of_handler handler1\n | ( (Empty_one_or_more_handlers _ as handler1)\n , (Empty_one_or_more_handlers _ as handler2) ) ->\n Handler.splice handler1 handler2)\n;;\n","open! Core_kernel\nopen! Import\nmodule Ivar = Ivar0\nmodule Handler = Ivar.Handler\n\n(* Deferreds present a covariant view of ivars. We could actually implement deferreds\n using a record of closures, as in the [essence_of_deferred] record below, for which the\n OCaml type checker can infer covariance. However, doing so would make [Ivar.read] very\n costly, because it would have to allocate lots of closures and a record. Instead of\n doing this, we make deferreds an abstract covariant type, which concretely is just the\n ivar, and use [Obj.magic] to convert back and forth between a deferred and its concrete\n representation as an ivar. This [Obj.magic] is safe because the representation is\n always just an ivar, and the covariance follows from the fact that all the deferred\n operations are equivalent to those implemented directly on top of the\n [essence_of_deferred].\n\n {[\n type (+'a, 'execution_context) essence_of_deferred =\n { peek : unit -> 'a option\n ; is_determined : unit -> bool\n ; upon : ('a -> unit) -> unit\n ; upon' : ('a -> unit) -> Unregister.t\n ; install_removable_handler : ('a, 'execution_context) Raw_handler.t -> Unregister.t; } ]} *)\n\ntype +'a t = 'a Types.Deferred.t\n\n(* the abstract covariant type, equivalent to ivar *)\n\nlet of_ivar (type a) (ivar : a Ivar.t) : a t = Obj.magic ivar\nlet to_ivar (type a) t : a Ivar.t = Obj.magic (t : a t)\nlet invariant invariant_a t = Ivar.invariant invariant_a (to_ivar t)\nlet sexp_of_t sexp_of_a t = Ivar.sexp_of_t sexp_of_a (to_ivar t)\nlet peek t = Ivar.peek (to_ivar t)\nlet return a = of_ivar (Ivar.create_full a)\nlet is_determined t = Ivar.is_full (to_ivar t)\n\nlet value_exn t =\n Ivar.value\n (to_ivar t)\n ~if_empty_then_failwith:\"Deferred.value_exn called on undetermined deferred\"\n;;\n\nlet upon t f = Ivar.upon (to_ivar t) f\n\nlet create f =\n let result = Ivar.create () in\n f result;\n of_ivar result\n;;\n\n(* don't use [create] here as it would allocate one more closure *)\nlet bind t ~f =\n let bind_result = Ivar.create () in\n upon t (fun a -> Ivar.connect ~bind_result ~bind_rhs:(to_ivar (f a)));\n of_ivar bind_result\n;;\n\nlet add_handler t f execution_context = Ivar.add_handler (to_ivar t) f execution_context\nlet remove_handler t h = Ivar.remove_handler (to_ivar t) h\n","open Core_kernel\nmodule Deferred = Deferred0\ninclude Ivar0\n\nlet read = Deferred.of_ivar\nlet fill_if_empty t v = if is_empty t then fill t v\n\ninclude Binable.Of_binable1 [@alert \"-legacy\"]\n (Option)\n (struct\n type nonrec 'a t = 'a t\n\n let to_binable t = peek t\n\n let of_binable = function\n | None -> create ()\n | Some a -> create_full a\n ;;\n end)\n","(** [Monad_sequence.S] is a generic interface specifying functions that deal with a\n container and a monad. It is specialized to the [Deferred] monad and used with\n various containers in modules [Deferred.Array], [Deferred.List], [Deferred.Queue], and\n [Deferred.Sequence]. The [Monad_sequence.how] type specifies the parallelism of\n container iterators. *)\n\nopen! Core_kernel\nopen! Import\n\ntype how =\n [ `Parallel (** like [`Max_concurrent_jobs Int.max_value] *)\n | `Sequential\n (** [`Sequential] is often but not always the same as [`Max_concurrent_jobs 1]\n (for example, they differ in the [Or_error] monad). *)\n | `Max_concurrent_jobs of int\n ]\n[@@deriving sexp_of]\n\nmodule type S = sig\n type 'a monad\n type 'a t\n\n val foldi : 'a t -> init:'b -> f:(int -> 'b -> 'a -> 'b monad) -> 'b monad\n val fold : 'a t -> init:'b -> f:('b -> 'a -> 'b monad) -> 'b monad\n val find : 'a t -> f:('a -> bool monad) -> 'a option monad\n val findi : 'a t -> f:(int -> 'a -> bool monad) -> (int * 'a) option monad\n val find_map : 'a t -> f:('a -> 'b option monad) -> 'b option monad\n val find_mapi : 'a t -> f:(int -> 'a -> 'b option monad) -> 'b option monad\n val exists : 'a t -> f:('a -> bool monad) -> bool monad\n val existsi : 'a t -> f:(int -> 'a -> bool monad) -> bool monad\n val for_all : 'a t -> f:('a -> bool monad) -> bool monad\n val for_alli : 'a t -> f:(int -> 'a -> bool monad) -> bool monad\n val all : 'a monad t -> 'a t monad\n val all_unit : unit monad t -> unit monad\n\n (** {2 Deferred iterators}\n\n In the following, the default [how] is [`Sequential] *)\n\n val init : ?how:how -> int -> f:(int -> 'a monad) -> 'a t monad\n val iter : ?how:how -> 'a t -> f:('a -> unit monad) -> unit monad\n val iteri : ?how:how -> 'a t -> f:(int -> 'a -> unit monad) -> unit monad\n val map : ?how:how -> 'a t -> f:('a -> 'b monad) -> 'b t monad\n val mapi : ?how:how -> 'a t -> f:(int -> 'a -> 'b monad) -> 'b t monad\n val filter : ?how:how -> 'a t -> f:('a -> bool monad) -> 'a t monad\n val filteri : ?how:how -> 'a t -> f:(int -> 'a -> bool monad) -> 'a t monad\n val filter_map : ?how:how -> 'a t -> f:('a -> 'b option monad) -> 'b t monad\n val filter_mapi : ?how:how -> 'a t -> f:(int -> 'a -> 'b option monad) -> 'b t monad\n val concat_map : ?how:how -> 'a t -> f:('a -> 'b t monad) -> 'b t monad\n val concat_mapi : ?how:how -> 'a t -> f:(int -> 'a -> 'b t monad) -> 'b t monad\nend\n","open Core_kernel\nmodule Scheduler = Scheduler1\ninclude Deferred0\n\n(* To avoid a space leak, it is necessary that [never] allocates a new ivar whenever it is\n called. Code can bind on [never ()], so if we re-used the ivar, we could endlessly\n accumulate handlers. *)\nlet never () = Ivar.read (Ivar.create ())\n\nmodule M = Monad.Make (struct\n include Deferred0\n\n let map t ~f =\n (* We manually inline [Deferred.create] here, because the non-flambda compiler isn't\n able to optimize away the closure that would be be created. *)\n let result = Ivar.create () in\n upon t (fun a -> Ivar.fill result (f a));\n of_ivar result\n ;;\n\n let map = `Custom map\n end)\n\ninclude M\n\n(* We rebind all the various [return]s because the use of the [Monad.Make] functor\n causes the compiler to not inline [return], and hence makes it impossible to\n statically allocate constants like [return ()]. By rebinding [return] as\n [Deferred0.return], the compiler can see that:\n\n {[\n return a = { Ivar.Immutable. cell = Full a } ]}\n\n And hence, if [a] is constant, then the return is constant and can be statically\n allocated. When compiling with flambda, the compiler inlines [return] and this manual\n rebinding would not help; we've decided to do it anyway so that non-flambda builds\n get the optimization. *)\nlet return = Deferred0.return\n\nmodule Let_syntax = struct\n include M.Let_syntax\n\n let return = Deferred0.return\n\n module Let_syntax = struct\n include M.Let_syntax.Let_syntax\n\n let return = Deferred0.return\n end\nend\n\nopen Let_syntax\n\n(* We shadow [all] on-purpose here, since the default definition introduces a chain of\n binds as long as the list. *)\nlet all = `Make_sure_to_define_all_elsewhere\nlet _ = all\nlet unit = return ()\n\nlet both t1 t2 =\n create (fun result ->\n upon t1 (fun a1 -> upon t2 (fun a2 -> Ivar.fill result (a1, a2))))\n;;\n\nmodule Infix = struct\n include Monad_infix\n\n let ( >>> ) = upon\n let ppx_both = both\nend\n\nopen Infix\n\nlet don't_wait_for (_ : unit t) = ()\n\nmodule Choice = struct\n type +'a t = T : 'b Deferred0.t * ('b -> 'a) -> 'a t\n\n let map (T (t, f1)) ~f:f2 = T (t, fun x -> f2 (f1 x))\nend\n\ntype 'a choice = 'a Choice.t\n\nmodule Unregister = struct\n (* This representation saves 2n words for a list of n choices. *)\n type t =\n | Nil : t\n | Cons : 'a Deferred0.t * 'a Deferred0.Handler.t * t -> t\n\n let rec process = function\n | Nil -> ()\n | Cons (t, handler, rest) ->\n remove_handler t handler;\n process rest\n ;;\nend\n\nlet choice t f = Choice.T (t, f)\n\nlet enabled choices =\n let result = Ivar.create () in\n let unregisters = ref Unregister.Nil in\n let ready _ =\n if Ivar.is_empty result\n then (\n Unregister.process !unregisters;\n Ivar.fill result (fun () ->\n List.rev\n (List.fold choices ~init:[] ~f:(fun ac (Choice.T (t, f)) ->\n match peek t with\n | None -> ac\n | Some v -> f v :: ac))))\n in\n let execution_context = Scheduler.(current_execution_context (t ())) in\n unregisters\n := List.fold choices ~init:Unregister.Nil ~f:(fun acc (Choice.T (t, _)) ->\n Cons (t, Deferred0.add_handler t ready execution_context, acc));\n Ivar.read result\n;;\n\nlet rec choose_result choices =\n match choices with\n | [] -> assert false\n | Choice.T (t, f) :: choices ->\n (match peek t with\n | None -> choose_result choices\n | Some v -> f v)\n;;\n\nlet choose choices =\n let result = Ivar.create () in\n let unregisters = ref Unregister.Nil in\n let ready _ =\n if Ivar.is_empty result\n then (\n Unregister.process !unregisters;\n Ivar.fill result (choose_result choices))\n in\n let execution_context = Scheduler.(current_execution_context (t ())) in\n unregisters\n := List.fold choices ~init:Unregister.Nil ~f:(fun acc (Choice.T (t, _)) ->\n Cons (t, Deferred0.add_handler t ready execution_context, acc));\n Ivar.read result\n;;\n\nlet any_f ts f = choose (List.map ts ~f:(fun t -> choice t f))\nlet any ts = any_f ts Fn.id\nlet any_unit ts = any_f ts (Fn.ignore : unit -> unit)\n\nlet for_ start ~to_ ~do_ =\n let rec loop i =\n if i > to_\n then return ()\n else (\n let%bind () = do_ i in\n loop (i + 1))\n in\n loop start\n;;\n\nlet repeat_until_finished state f =\n create (fun finished ->\n let rec loop state =\n f state\n >>> function\n | `Repeat state -> loop state\n | `Finished result -> Ivar.fill finished result\n in\n loop state)\n;;\n\nlet forever state f =\n repeat_until_finished state (fun state ->\n let%map state = f state in\n `Repeat state)\n >>> never_returns\n;;\n\ntype how = Monad_sequence.how [@@deriving sexp_of]\n\nmodule type Monad_sequence = Monad_sequence.S with type 'a monad := 'a t\n\n\nlet fold t ~init ~f =\n create (fun result ->\n let rec loop t b =\n match t with\n | [] -> Ivar.fill result b\n | x :: xs -> f b x >>> fun b -> loop xs b\n in\n loop t init)\n;;\n\nlet seqmap t ~f = fold t ~init:[] ~f:(fun bs a -> f a >>| fun b -> b :: bs) >>| List.rev\nlet all ds = seqmap ds ~f:Fn.id\nlet all_unit ds = fold ds ~init:() ~f:(fun () d -> d)\nlet ok x = x >>| fun x -> Ok x\n","open Deferred1\ninclude Infix\ninclude Let_syntax\n\nlet choice = choice\nlet choose = choose\nlet don't_wait_for = don't_wait_for\nlet never = never\nlet return = return\nlet upon = upon\n","open! Core_kernel\nopen! Import\n\ntype 'a u =\n | Empty of 'a Ivar.t\n | Full\n[@@deriving sexp_of]\n\ntype 'a t = 'a u ref [@@deriving sexp_of]\n\nlet invariant _ t =\n Invariant.invariant [%here] t [%sexp_of: _ t] (fun () ->\n match !t with\n | Full -> ()\n | Empty ivar -> assert (Ivar.is_empty ivar))\n;;\n\nlet create () =\n let ivar = Ivar.create () in\n let t = ref (Empty ivar) in\n t, Ivar.read ivar\n;;\n\nlet is_empty t =\n match !t with\n | Empty _ -> true\n | Full -> false\n;;\n\nlet fill t a =\n match !t with\n | Empty i ->\n t := Full;\n Ivar.fill i a\n | Full -> raise_s [%message \"attempt to fill full ivar\"]\n;;\n","open! Core_kernel\nopen! Import\nmodule Deferred = Deferred1\n\nmodule Stream = struct\n type 'a t = 'a next Deferred.t\n\n and 'a next = 'a Types.Stream.next =\n | Nil\n | Cons of 'a * 'a t\n\n let sexp_of_t sexp_of_a t =\n let rec loop d ac : Sexp.t =\n match Deferred.peek d with\n | None -> List (List.rev (Sexp.Atom \"...\" :: ac))\n | Some Nil -> List (List.rev ac)\n | Some (Cons (a, t)) -> loop t (sexp_of_a a :: ac)\n in\n loop t []\n ;;\n\n let next t = t\nend\n\ntype 'a t = 'a Types.Tail.t =\n { (* [next] points at the tail of the stream *) mutable next : 'a Stream.next Ivar.t }\n[@@deriving fields]\n\nlet sexp_of_t _ t : Sexp.t =\n Atom (if Ivar.is_empty t.next then \"\" else \"\")\n;;\n\nlet create () = { next = Ivar.create () }\nlet collect t = Ivar.read (next t)\nlet is_closed t = Ivar.is_full (next t)\n\nlet fill_exn t v =\n if is_closed t then raise_s [%message \"stream is closed\"] else Ivar.fill (next t) v\n;;\n\nlet close_exn t = fill_exn t Nil\nlet close_if_open t = if not (is_closed t) then Ivar.fill (next t) Nil\n\nlet extend t v =\n let next = Ivar.create () in\n fill_exn t (Cons (v, Ivar.read next));\n t.next <- next\n;;\n","open Core_kernel\nopen Deferred_std\nmodule Deferred = Deferred1\ninclude Tail.Stream\n\nlet first_exn t =\n match%map next t with\n | Nil -> raise_s [%message \"Stream.first of empty stream\"]\n | Cons (x, _) -> x\n;;\n\nlet fold' t ~init ~f =\n Deferred.create (fun result ->\n let rec loop t b =\n upon (next t) (function\n | Nil -> Ivar.fill result b\n | Cons (v, t) -> upon (f b v) (loop t))\n in\n loop t init)\n;;\n\n(* [fold] is implemented to avoid per-stream-element deferred overhead in the case when\n multiple stream elements are available simultaneously. *)\nlet fold t ~init ~f =\n Deferred.create (fun result ->\n let rec loop t b =\n match Deferred.peek (next t) with\n | None -> upon (next t) (fun next -> loop_next next b)\n | Some next -> loop_next next b\n and loop_next next b =\n match next with\n | Nil -> Ivar.fill result b\n | Cons (v, t) -> loop t (f b v)\n in\n loop t init)\n;;\n\nlet length t = fold t ~init:0 ~f:(fun n _ -> n + 1)\nlet iter' t ~f = fold' t ~init:() ~f:(fun () v -> f v)\n\nlet closed t =\n match Deferred.peek (next t) with\n | Some Nil -> return ()\n | _ -> iter' t ~f:(fun _ -> return ())\n;;\n\nlet iter t ~f =\n don't_wait_for\n (iter' t ~f:(fun a ->\n f a;\n return ()))\n;;\n\nlet create f =\n let tail = Tail.create () in\n (* collect before calling [f], in case [f] immediately extends. *)\n let t = Tail.collect tail in\n f tail;\n t\n;;\n\nlet unfold b ~f =\n create (fun tail ->\n let rec loop b =\n upon (f b) (function\n | None -> Tail.close_exn tail\n | Some (a, b) ->\n Tail.extend tail a;\n loop b)\n in\n loop b)\n;;\n\nlet of_list l =\n create (fun tail ->\n List.iter l ~f:(fun x -> Tail.extend tail x);\n Tail.close_exn tail)\n;;\n\nlet to_list s = fold' s ~init:[] ~f:(fun b a -> return (a :: b)) >>| List.rev\nlet copy_to_tail t tail = iter' t ~f:(fun a -> return (Tail.extend tail a))\n\nlet append t1 t2 =\n create (fun tail ->\n upon (copy_to_tail t1 tail) (fun () ->\n upon (copy_to_tail t2 tail) (fun () -> Tail.close_exn tail)))\n;;\n\nlet concat t =\n create (fun tail ->\n upon (iter' t ~f:(fun t -> copy_to_tail t tail)) (fun () -> Tail.close_exn tail))\n;;\n\nlet filter' t ~f =\n create (fun tail ->\n upon\n (iter' t ~f:(fun v ->\n match%map f v with\n | false -> ()\n | true -> Tail.extend tail v))\n (fun () -> Tail.close_exn tail))\n;;\n\nlet filter_deprecated t ~f = filter' t ~f:(fun a -> return (f a))\n\nlet filter_map' t ~f =\n create (fun tail ->\n upon\n (iter' t ~f:(fun v ->\n match%map f v with\n | None -> ()\n | Some v -> Tail.extend tail v))\n (fun () -> Tail.close_exn tail))\n;;\n\nlet filter_map_deprecated t ~f = filter_map' t ~f:(fun a -> return (f a))\n\nlet map' t ~f =\n create (fun tail ->\n upon\n (iter' t ~f:(fun v -> f v >>| Tail.extend tail))\n (fun () -> Tail.close_exn tail))\n;;\n\nlet map t ~f = map' t ~f:(fun a -> return (f a))\n\nlet first_n s n =\n create (fun tail ->\n let rec loop s n =\n if n = 0\n then Tail.close_exn tail\n else\n upon (next s) (function\n | Nil -> Tail.close_exn tail\n | Cons (x, t) ->\n Tail.extend tail x;\n loop t (n - 1))\n in\n loop s n)\n;;\n\nlet available_now t =\n let rec loop t ac =\n match Deferred.peek (next t) with\n | None | Some Nil -> List.rev ac, t\n | Some (Cons (x, t)) -> loop t (x :: ac)\n in\n loop t []\n;;\n\nlet split ?(stop = Deferred.never ()) ?(f = fun _ -> `Continue) t =\n let reason_for_stopping = Ivar.create () in\n let prefix = Tail.create () in\n let finish v =\n Tail.close_exn prefix;\n Ivar.fill reason_for_stopping v\n in\n let rec loop t =\n choose [ choice stop (fun () -> `Stopped); choice (next t) (fun o -> `Next o) ]\n >>> function\n | `Stopped -> finish (`Stopped t)\n | `Next o ->\n (match o with\n | Nil -> finish `End_of_stream\n | Cons (a, t) ->\n (match f a with\n | `Continue ->\n Tail.extend prefix a;\n loop t\n | `Found b -> finish (`Found (b, t))))\n in\n loop t;\n Tail.collect prefix, Ivar.read reason_for_stopping\n;;\n\nlet find t ~f =\n let _, found = split t ~f:(fun a -> if f a then `Found a else `Continue) in\n match%map found with\n | `Stopped _ -> assert false\n | (`End_of_stream | `Found _) as x -> x\n;;\n\nlet ungroup t =\n create (fun tail ->\n upon\n (iter' t ~f:(fun l ->\n List.iter l ~f:(fun x -> Tail.extend tail x);\n return ()))\n (fun () -> Tail.close_exn tail))\n;;\n\nlet interleave ts =\n create (fun tail ->\n (* The interleaved stream should be closed when the outer stream and all of\n the inner streams have been closed. Keep a count of the number of open\n streams and close the interleaved stream when that count becomes\n zero. *)\n let num_open = ref 1 in\n (* 1 for the outer stream that is open *)\n let close () =\n num_open := !num_open - 1;\n if !num_open = 0 then Tail.close_exn tail\n in\n let outer_closed =\n iter' ts ~f:(fun t ->\n num_open := !num_open + 1;\n upon (copy_to_tail t tail) close;\n return ())\n in\n upon outer_closed close)\n;;\n\nlet take_until t d =\n create (fun tail ->\n let rec loop t =\n upon\n (choose [ choice d (fun () -> `Stop); choice (next t) (fun z -> `Next z) ])\n (function\n | `Stop | `Next Nil -> Tail.close_exn tail\n | `Next (Cons (x, t)) ->\n Tail.extend tail x;\n loop t)\n in\n loop t)\n;;\n\nlet iter_durably' t ~f =\n Deferred.create (fun result ->\n let rec loop t =\n next t\n >>> function\n | Nil -> Ivar.fill result ()\n | Cons (x, t) ->\n Monitor.try_with ~rest:`Raise (fun () -> f x)\n >>> fun z ->\n loop t;\n (match z with\n | Ok () -> ()\n | Error e -> Monitor.send_exn (Monitor.current ()) e)\n in\n loop t)\n;;\n\nlet iter_durably_report_end t ~f =\n Deferred.create (fun result ->\n let rec loop t =\n next t\n >>> function\n | Nil -> Ivar.fill result ()\n | Cons (x, t) ->\n (* We immediately call [loop], thus making the iter durable. Any exceptions\n raised by [f] will not prevent the loop from continuing, and will go to the\n monitor of whomever called [iter_durably_report_end]. *)\n loop t;\n f x\n in\n loop t)\n;;\n\nlet iter_durably t ~f = don't_wait_for (iter_durably_report_end t ~f)\n\nlet of_fun f =\n unfold () ~f:(fun () ->\n let%map a = f () in\n Some (a, ()))\n;;\n","include Synchronous_time_source0\n\nlet create = Scheduler1.create_time_source\nlet wall_clock = Scheduler1.wall_clock\n","open! Core_kernel\nopen! Import\n\ntype ('a, 'permission) t = ('a, 'permission) Types.Bvar.t\n\ntype 'a repr = 'a Types.Bvar.repr =\n { mutable has_any_waiters : bool\n ; mutable ivar : 'a Ivar.t\n }\n[@@deriving fields, sexp_of]\n\nlet invariant invariant_a _ t =\n let repr = Types.Bvar.to_repr t in\n Invariant.invariant [%here] repr [%sexp_of: _ repr] (fun () ->\n let check f = Invariant.check_field repr f in\n Fields_of_repr.iter\n ~has_any_waiters:\n (check (fun has_any_waiters ->\n if Ivar.has_handlers repr.ivar then assert has_any_waiters))\n ~ivar:\n (check (fun ivar ->\n Ivar.invariant invariant_a ivar;\n assert (Ivar.is_empty ivar))))\n;;\n\nlet sexp_of_t _ _ t =\n let { has_any_waiters; ivar = _ } = Types.Bvar.to_repr t in\n (* We don't show [ivar] because it's always empty. *)\n [%message (has_any_waiters : bool)]\n;;\n\ninclude Scheduler1.Bvar\n\nlet broadcast t a =\n let repr = Types.Bvar.to_repr t in\n if repr.has_any_waiters\n then (\n repr.has_any_waiters <- false;\n Ivar.fill repr.ivar a;\n repr.ivar <- Ivar.create ())\n;;\n\nlet wait t =\n let repr = Types.Bvar.to_repr t in\n repr.has_any_waiters <- true;\n Ivar.read repr.ivar\n;;\n\nlet has_any_waiters t =\n let repr = Types.Bvar.to_repr t in\n repr.has_any_waiters\n;;\n","open! Core_kernel\nopen! Import\nopen! Deferred_std\n\nlet debug = Debug.clock\n\nmodule Alarm = Timing_wheel.Alarm\nmodule Deferred = Deferred1\nmodule Scheduler = Scheduler1\n\nlet upon = Deferred.upon\nlet choose = Deferred.choose\nlet choice = Deferred.choice\nlet ( >>> ) = upon\n\nmodule T1 = struct\n include Synchronous_time_source0.T1\n\n (* We don't include the [id] in the sexp because the user (rightly) can't control it, so\n it's hard to make it deterministic in tests. *)\n let sexp_of_t\n _\n { id = _\n ; advance_errors = _\n ; am_advancing = _\n ; events\n ; fired_events = _\n ; handle_fired = _\n ; is_wall_clock\n ; most_recently_fired = _\n ; scheduler = _\n }\n =\n if is_wall_clock\n then [%message \"\"]\n else\n [%message\n (is_wall_clock : bool)\n (* We don't display the [Job.t]s in [events] because those are\n pool pointers, which are uninformative. *)\n (events : _ Timing_wheel.t)]\n ;;\nend\n\nopen T1\n\nmodule Read_write = struct\n type t = read_write T1.t [@@deriving sexp_of]\n\n let invariant = invariant\n let invariant_with_jobs = invariant_with_jobs\nend\n\ntype t = read T1.t [@@deriving sexp_of]\n\nlet invariant = invariant\nlet invariant_with_jobs = invariant_with_jobs\nlet read_only (t : [> read ] T1.t) = (t :> t)\nlet create = Scheduler.create_time_source\nlet wall_clock = Scheduler.wall_clock\nlet alarm_precision t = Timing_wheel.alarm_precision t.events\nlet next_alarm_fires_at t = Timing_wheel.next_alarm_fires_at t.events\nlet timing_wheel_now t = Timing_wheel.now t.events\nlet id t = t.id\n\nmodule Id = Synchronous_time_source0.Id\n\nlet now t =\n if t.is_wall_clock\n then\n (* For the wall-clock time-source, we use [Time_ns.now ()] rather than\n [Timing_wheel.now t.events]. The latter is only updated at the start of each\n cycle. There can be substantial difference between the two when people do long\n running computations or mix blocking code with async. And humans expect that\n wall-clock time is based on [Time.now], not some artifact of async\n implementation. *)\n Time_ns.now ()\n else timing_wheel_now t\n;;\n\n(* We preallocate [send_exn] to avoid allocating it on each call to [advance_clock]. *)\nlet send_exn = Some Monitor.send_exn\nlet advance_directly t ~to_ = Synchronous_time_source0.advance_clock t ~to_ ~send_exn\nlet advance_directly_by t by = advance_directly t ~to_:(Time_ns.after (now t) by)\nlet advance = advance_directly\nlet advance_by = advance_directly_by\nlet fire_past_alarms t = Synchronous_time_source0.fire_past_alarms t ~send_exn\nlet yield t = Bvar.wait (Scheduler.yield t.scheduler)\n\nlet advance_by_alarms ?wait_for t ~to_ =\n let run_queued_alarms () =\n (* Every time we want to run queued alarms we need to yield control back to the\n [Async.Scheduler] and [wait_for] any logic that is supposed to finish at this time\n before advancing. If no [wait_for] logic is specified we can simply yield control\n by invoking [yield t], which enqueues another job at the end of the scheduler job\n queue so alarm jobs have the opportunity to run before we advance. *)\n match wait_for with\n | None -> yield t\n | Some f -> f ()\n in\n let finish () =\n advance_directly t ~to_;\n fire_past_alarms t;\n (* so that alarms scheduled at or before [to_] fire *)\n run_queued_alarms ()\n in\n let rec walk_alarms () =\n match next_alarm_fires_at t with\n | None -> finish ()\n | Some next_alarm_fires_at ->\n if Time_ns.( >= ) next_alarm_fires_at to_\n then finish ()\n else (\n advance_directly t ~to_:next_alarm_fires_at;\n let queued_alarms_ran = run_queued_alarms () in\n if Deferred.is_determined queued_alarms_ran\n then walk_alarms ()\n else (\n let%bind () = queued_alarms_ran in\n walk_alarms ()))\n in\n (* This first [run_queued_alarms] call allows [Clock_ns.every] the opportunity to run\n its continuation deferreds so that they can reschedule alarms. This is particularly\n useful in our \"advance hits intermediate alarms\" unit test below, but likely useful\n in other cases where [every] is synchronously followed by [advance]. *)\n let%bind () = run_queued_alarms () in\n walk_alarms ()\n;;\n\nlet advance_by_alarms_by ?wait_for t by =\n advance_by_alarms ?wait_for t ~to_:(Time_ns.after (now t) by)\n;;\n\nlet span_to_time t span = Time_ns.after (now t) span\n\nlet schedule_job t ~at execution_context f a =\n let alarm =\n Timing_wheel.add\n t.events\n ~at\n (Job_or_event.of_job (Scheduler.create_job t.scheduler execution_context f a))\n in\n (match t.scheduler.event_added_hook with\n | None -> ()\n | Some f -> f at);\n alarm\n;;\n\nlet run_at_internal t time f a =\n let execution_context = Scheduler.current_execution_context t.scheduler in\n if Time_ns.( > ) time (Timing_wheel.now t.events)\n then schedule_job t ~at:time execution_context f a\n else (\n Scheduler.enqueue t.scheduler execution_context f a;\n Alarm.null ())\n;;\n\nlet run_at t time f a = ignore (run_at_internal t time f a : _ Alarm.t)\nlet run_after t span f a = run_at t (span_to_time t span) f a\n\nlet at =\n let fill result = Ivar.fill result () in\n fun t time ->\n if Time_ns.( <= ) time (Timing_wheel.now t.events)\n then return ()\n else (\n let result = Ivar.create () in\n ignore (run_at_internal t time fill result : _ Alarm.t);\n Ivar.read result)\n;;\n\nlet after t span = at t (span_to_time t span)\n\nlet remove_alarm t alarm : unit =\n let job_or_event = Alarm.value t.events alarm in\n (let open Job_or_event.Match in\n let (K k) = kind job_or_event in\n match k, project k job_or_event with\n | Job, job -> Scheduler.free_job t.scheduler job\n | Event, _ ->\n (* This is unreachable because [alarm] only ever comes from [Event.alarm] which only\n ever gets populated by a call to [schedule_job]. *)\n assert false);\n Timing_wheel.remove t.events alarm\n;;\n\nlet remove_alarm_if_scheduled t alarm =\n if Timing_wheel.mem t.events alarm then remove_alarm t alarm\n;;\n\nmodule Event = struct\n module Fired = struct\n type ('a, 'h) t =\n | Aborted of 'a\n | Happened of 'h\n [@@deriving sexp_of]\n end\n\n type ('a, 'h) t =\n { mutable alarm : Job_or_event.t Alarm.t\n ; mutable fire : unit -> unit\n ; (* As long as [Ivar.is_empty fired], we have not yet committed to whether the event\n will happen or be aborted. When [Ivar.is_empty fired], the alarm may or may not\n be in the timing wheel -- if it isn't, then there's a job in Async's job queue\n that will fire the event, unless it is aborted before that job can run. *)\n fired : ('a, 'h) Fired.t Ivar.t\n ; (* [num_fires_to_skip] is used to reschedule events that have fired and entered the\n Async job queue, but have not yet run. Those jobs only run if [num_fires_to_skip\n = 0], and otherwise just decrement it. So, to reschedule an event in such a\n state, we increment [num_fires_to_skip] and add a new alarm to the timing\n wheel. *)\n mutable num_fires_to_skip : int\n ; (* [scheduled_at] is the time at which [t] has most recently been scheduled to fire.\n While [t.alarm] is still in the timing wheel, this is the same as [Alarm.at\n t.alarm]. *)\n mutable scheduled_at : Time_ns.t\n ; time_source : Synchronous_time_source.t\n }\n [@@deriving fields, sexp_of]\n\n type t_unit = (unit, unit) t [@@deriving sexp_of]\n\n let fired t = Ivar.read t.fired\n\n let invariant invariant_a invariant_h t =\n Invariant.invariant [%here] t [%sexp_of: (_, _) t] (fun () ->\n let events = t.time_source.events in\n let check f = Invariant.check_field t f in\n Fields.iter\n ~alarm:\n (check (fun alarm ->\n if Ivar.is_full t.fired\n then assert (not (Timing_wheel.mem events alarm))\n else if Timing_wheel.mem events alarm\n then assert (Job_or_event.is_job (Alarm.value events alarm))))\n ~fire:ignore\n ~fired:\n (check (fun (fired : _ Fired.t Ivar.t) ->\n match Deferred.peek (Ivar.read fired) with\n | None -> ()\n | Some (Aborted a) -> invariant_a a\n | Some (Happened h) -> invariant_h h))\n ~num_fires_to_skip:\n (check (fun num_fires_to_skip -> assert (num_fires_to_skip >= 0)))\n ~scheduled_at:\n (check (fun scheduled_at ->\n if Timing_wheel.mem events t.alarm\n then\n [%test_result: Time_ns.t]\n scheduled_at\n ~expect:(Alarm.at events t.alarm)))\n ~time_source:ignore)\n ;;\n\n module Status = struct\n type ('a, 'h) t =\n | Aborted of 'a\n | Happened of 'h\n | Scheduled_at of Time_ns.t\n [@@deriving sexp_of]\n end\n\n let status t : _ Status.t =\n match Deferred.peek (Ivar.read t.fired) with\n | None -> Scheduled_at t.scheduled_at\n | Some (Aborted a) -> Aborted a\n | Some (Happened h) -> Happened h\n ;;\n\n module Abort_result = struct\n type ('a, 'h) t =\n | Ok\n | Previously_aborted of 'a\n | Previously_happened of 'h\n [@@deriving sexp_of]\n end\n\n let abort t a : _ Abort_result.t =\n if debug then Debug.log \"Time_source.Event.abort\" t [%sexp_of: (_, _) t];\n match Deferred.peek (fired t) with\n | Some (Aborted a) -> Previously_aborted a\n | Some (Happened h) -> Previously_happened h\n | None ->\n Ivar.fill t.fired (Aborted a);\n remove_alarm_if_scheduled t.time_source t.alarm;\n Ok\n ;;\n\n let abort_exn t a =\n match abort t a with\n | Ok -> ()\n | Previously_happened _ ->\n raise_s\n [%message \"Clock.Event.abort_exn failed to abort event that previously happened\"]\n | Previously_aborted _ ->\n raise_s\n [%message \"Clock.Event.abort_exn failed to abort event that previously aborted\"]\n ;;\n\n let abort_if_possible t a = ignore (abort t a : _ Abort_result.t)\n let schedule t = t.alarm <- run_at_internal t.time_source t.scheduled_at t.fire ()\n\n module Reschedule_result = struct\n type ('a, 'h) t =\n | Ok\n | Previously_aborted of 'a\n | Previously_happened of 'h\n [@@deriving sexp_of]\n end\n\n let reschedule_at t at : _ Reschedule_result.t =\n if debug\n then\n Debug.log\n \"Time_source.Event.reschedule_at\"\n (t, at)\n [%sexp_of: (_, _) t * Time_ns.t];\n match Deferred.peek (fired t) with\n | Some (Aborted a) -> Previously_aborted a\n | Some (Happened h) -> Previously_happened h\n | None ->\n let events = t.time_source.events in\n let is_in_timing_wheel = Timing_wheel.mem events t.alarm in\n let am_trying_to_reschedule_in_the_future =\n Time_ns.( > ) at (Timing_wheel.now events)\n in\n t.scheduled_at <- at;\n (match am_trying_to_reschedule_in_the_future, is_in_timing_wheel with\n | false, false -> ()\n | false, true ->\n t.time_source.handle_fired t.alarm;\n Timing_wheel.remove events t.alarm\n | true, false ->\n t.num_fires_to_skip <- t.num_fires_to_skip + 1;\n schedule t\n | true, true -> Timing_wheel.reschedule events t.alarm ~at);\n Ok\n ;;\n\n let reschedule_after t span = reschedule_at t (span_to_time t.time_source span)\n\n let run_at time_source scheduled_at f z =\n if debug then Debug.log \"Time_source.Event.run_at\" scheduled_at [%sexp_of: Time_ns.t];\n let t =\n { alarm = Alarm.null ()\n ; fire = ignore (* set below *)\n ; fired = Ivar.create ()\n ; num_fires_to_skip = 0\n ; scheduled_at\n ; time_source = read_only time_source\n }\n in\n let fire () =\n (* [fire] runs in an Async job. The event may have been aborted after the job\n was enqueued, so [fire] must check [fired]. *)\n if Ivar.is_empty t.fired\n then\n if t.num_fires_to_skip > 0\n then t.num_fires_to_skip <- t.num_fires_to_skip - 1\n else (\n let result = f z in\n (* [f z] may have aborted the event, so we must check [fired] again. *)\n if Ivar.is_empty t.fired then Ivar.fill t.fired (Happened result))\n in\n t.fire <- fire;\n schedule t;\n t\n ;;\n\n let at time_source time = run_at time_source time ignore ()\n\n let run_after time_source span f a =\n run_at time_source (span_to_time time_source span) f a\n ;;\n\n let after time_source span = at time_source (span_to_time time_source span)\nend\n\nlet at_times ?(stop = Deferred.never ()) t next_time =\n let tail = Tail.create () in\n let rec loop () =\n choose\n [ choice stop (fun () -> `Stop); choice (at t (next_time ())) (fun () -> `Tick) ]\n >>> function\n | `Stop -> Tail.close_exn tail\n | `Tick ->\n Tail.extend tail ();\n loop ()\n in\n loop ();\n Tail.collect tail\n;;\n\nlet at_varying_intervals ?stop t compute_span =\n at_times t ?stop (fun () -> Time_ns.after (now t) (compute_span ()))\n;;\n\nlet at_intervals ?start ?stop t interval =\n let start =\n match start with\n | Some x -> x\n | None -> now t\n in\n at_times t ?stop (fun () ->\n Time_ns.next_multiple ~base:start ~after:(now t) ~interval ())\n;;\n\nmodule Continue = struct\n type t =\n | Immediately\n | After of Time_ns.Span.t\n | Next_multiple of Time_ns.t * Time_ns.Span.t\n\n let immediately = Immediately\n\n let at t time_source =\n match t with\n | Immediately -> Timing_wheel.now time_source.events\n | After span -> span_to_time time_source span\n | Next_multiple (base, interval) ->\n Time_ns.next_multiple ~base ~after:(now time_source) ~interval ()\n ;;\nend\n\nlet run_repeatedly\n ?(start = return ())\n ?stop\n ?(continue_on_error = true)\n ?(finished = Ivar.create ())\n t\n ~f\n ~continue\n =\n start\n >>> fun () ->\n let alarm = ref (Alarm.null ()) in\n let stop =\n match stop with\n | None -> Deferred.never ()\n | Some stop ->\n upon stop (fun () ->\n if Timing_wheel.mem t.events !alarm\n then (\n remove_alarm t !alarm;\n Ivar.fill_if_empty finished ()));\n stop\n in\n (* [run_f], [continue_f], and [continue_try_with] are defined so that we allocate their\n closures once, not once per iteration. *)\n let rec run_f () =\n (* Before calling [f], we synchronously check whether [stop] is determined. *)\n if Deferred.is_determined stop\n then Ivar.fill_if_empty finished ()\n else if continue_on_error\n then Monitor.try_with f ~run:`Now ~rest:`Raise >>> continue_try_with\n else (\n let d = f () in\n if Deferred.is_determined d then continue_f () else d >>> continue_f)\n and continue_f () =\n if Deferred.is_determined stop\n then Ivar.fill_if_empty finished ()\n else alarm := run_at_internal t (Continue.at continue t) run_f ()\n and continue_try_with or_error =\n (match or_error with\n | Ok () -> ()\n | Error error -> Monitor.send_exn (Monitor.current ()) error);\n continue_f ()\n in\n run_f ()\n;;\n\nlet every' ?start ?stop ?continue_on_error ?finished t span f =\n if Time_ns.Span.( <= ) span Time_ns.Span.zero\n then\n raise_s [%message \"Time_source.every got nonpositive span\" (span : Time_ns.Span.t)];\n run_repeatedly t ?start ?stop ?continue_on_error ?finished ~f ~continue:(After span)\n;;\n\nlet every ?start ?stop ?continue_on_error t span f =\n every' t ?start ?stop ?continue_on_error ?finished:None span (fun () ->\n f ();\n return ())\n;;\n\nlet run_at_intervals' ?start ?stop ?continue_on_error t interval f =\n let now = now t in\n let base, start =\n match start with\n | None -> now, None\n | Some start ->\n ( start\n , Some\n (at\n t\n (Time_ns.next_multiple\n ()\n ~base:start\n ~after:now\n ~can_equal_after:true\n ~interval)) )\n in\n run_repeatedly\n t\n ?start\n ?stop\n ?continue_on_error\n ~f\n ~continue:(Next_multiple (base, interval))\n;;\n\nlet run_at_intervals ?start ?stop ?continue_on_error t interval f =\n run_at_intervals' ?start ?stop ?continue_on_error t interval (fun () ->\n f ();\n return ())\n;;\n\nlet with_timeout t span d =\n let timeout = Event.after t span in\n choose\n (* The code below does exhaustive case analysis in both [choice]s. Because [timeout]\n does not escape the scope of this function, certain cases should be impossible, and\n are marked as such with exceptions. We do not expect those exceptions to occur,\n but if they do, it likely indicates a bug in [choose] rather than\n [with_timeout]. *)\n [ choice d (fun v ->\n (match Event.abort timeout () with\n (* [Previously_happened] can occur if both [d] and [wait] become determined at\n the same time, e.g. [with_timeout (sec 0.) (return ())]. *)\n | Ok | Previously_happened () -> ()\n | Previously_aborted () ->\n raise_s [%message \"Time_source.with_timeout bug: should only abort once\"]);\n `Result v)\n ; choice (Event.fired timeout) (function\n | Happened () -> `Timeout\n | Aborted () ->\n raise_s\n [%message \"Time_source.with_timeout bug: both completed and timed out\"])\n ]\n;;\n\nlet of_synchronous t = t\nlet to_synchronous t = t\n","open! Base\n\ntype _ t =\n | Stack : 'a Stack.t -> 'a t\n | Counter : { mutable length : int } -> unit t\n[@@deriving sexp_of]\n\nlet of_list list = Stack (Stack.of_list list)\n\nlet create_counter ~length =\n if length < 0\n then\n raise_s\n [%message \"[Stack_or_counter.create_counter] got negative length\" (length : int)];\n Counter { length }\n;;\n\nlet length (type a) (t : a t) =\n match t with\n | Stack s -> Stack.length s\n | Counter r -> r.length\n;;\n\nlet clear (type a) (t : a t) =\n match t with\n | Stack s -> Stack.clear s\n | Counter r -> r.length <- 0\n;;\n\nlet push (type a) (t : a t) a =\n match t with\n | Stack s -> Stack.push s a\n | Counter r -> r.length <- r.length + 1\n;;\n\nlet pop_exn (type a) (t : a t) =\n match t with\n | Stack s -> Stack.pop_exn s\n | Counter r ->\n if r.length = 0 then raise_s [%message \"[Stack_or_counter.pop_exn] of empty stack\"];\n r.length <- r.length - 1\n;;\n\nlet iter (type a) (t : a t) ~(f : a -> unit) =\n match t with\n | Stack s -> Stack.iter s ~f\n | Counter r ->\n for _ = 1 to r.length do\n f ()\n done\n;;\n","open! Core_kernel\nopen! Import\nopen! Deferred_std\nmodule Deferred = Deferred1\n\ntype 'a outcome =\n [ `Ok of 'a\n | `Aborted\n | `Raised of exn\n ]\n[@@deriving sexp_of]\n\nmodule Internal_job : sig\n type 'a t [@@deriving sexp_of]\n\n val create : ('a -> 'b Deferred.t) -> 'a t * 'b outcome Deferred.t\n\n (* Every internal job will eventually be either [run] or [abort]ed, but not both. *)\n\n val run : 'a t -> 'a -> [ `Ok | `Raised ] Deferred.t\n val abort : _ t -> unit\nend = struct\n type 'a t =\n { start : [ `Abort | `Start of 'a ] Ivar.t\n ; outcome : [ `Ok | `Aborted | `Raised ] Deferred.t\n }\n [@@deriving sexp_of]\n\n let create work =\n let start = Ivar.create () in\n let result =\n match%bind Ivar.read start with\n | `Abort -> return `Aborted\n | `Start a ->\n (match%map Monitor.try_with (fun () -> work a) with\n | Ok a -> `Ok a\n | Error exn -> `Raised exn)\n in\n let outcome =\n match%map result with\n | `Ok _ -> `Ok\n | `Aborted -> `Aborted\n | `Raised _ -> `Raised\n in\n let t = { start; outcome } in\n t, result\n ;;\n\n let run t a =\n Ivar.fill t.start (`Start a);\n match%map t.outcome with\n | `Aborted -> assert false\n | (`Ok | `Raised) as x -> x\n ;;\n\n let abort t = Ivar.fill t.start `Abort\nend\n\ntype 'a t =\n { continue_on_error : bool\n ; max_concurrent_jobs : int\n ; (* [job_resources_not_in_use] holds resources that are not currently in use by a\n running job. *)\n job_resources_not_in_use : 'a Stack_or_counter.t\n ;\n (* [jobs_waiting_to_start] is the queue of jobs that haven't yet started. *)\n jobs_waiting_to_start : 'a Internal_job.t Queue.t\n ; (* [0 <= num_jobs_running <= max_concurrent_jobs]. *)\n mutable num_jobs_running : int\n ; (* [capacity_available] is [Some ivar] if user code has called [capacity_available t]\n and is waiting to be notified when capacity is available in the throttle.\n [maybe_start_job] will fill [ivar] when capacity becomes available, i.e. when\n [jobs_waiting_to_start] is empty and [num_jobs_running < max_concurrent_jobs]. *)\n mutable capacity_available : unit Ivar.t option\n ; (* [is_dead] is true if [t] was killed due to a job raising an exception or [kill t]\n being called. *)\n mutable is_dead : bool\n ; (* [cleans] holds functions that will be called to clean each resource when [t] is\n killed. *)\n mutable cleans : ('a -> unit Deferred.t) list\n ; (* [num_resources_not_cleaned] is the number of resources whose clean functions have\n not yet completed. While [t] is alive, [num_resources_not_cleaned =\n max_concurrent_jobs]. Once [t] is killed, [num_resources_not_cleaned] decreases to\n zero over time as the clean functions complete. *)\n mutable num_resources_not_cleaned : int\n ; (* [cleaned] becomes determined when [num_resources_not_cleaned] reaches zero,\n i.e. after [t] is killed and all its clean functions complete. *)\n cleaned : unit Ivar.t\n }\n[@@deriving fields, sexp_of]\n\nlet invariant invariant_a t : unit =\n try\n let check f field = f (Field.get field t) in\n Fields.iter\n ~continue_on_error:ignore\n ~max_concurrent_jobs:\n (check (fun max_concurrent_jobs -> assert (max_concurrent_jobs > 0)))\n ~job_resources_not_in_use:\n (check (fun job_resources_not_in_use ->\n Stack_or_counter.iter job_resources_not_in_use ~f:invariant_a;\n assert (\n Stack_or_counter.length job_resources_not_in_use\n = if t.is_dead then 0 else t.max_concurrent_jobs - t.num_jobs_running)))\n ~jobs_waiting_to_start:\n (check (function jobs_waiting_to_start ->\n if t.is_dead then assert (Queue.is_empty jobs_waiting_to_start)))\n ~num_jobs_running:\n (check (fun num_jobs_running ->\n assert (num_jobs_running >= 0);\n assert (num_jobs_running <= t.max_concurrent_jobs);\n if num_jobs_running < t.max_concurrent_jobs\n then assert (Queue.is_empty t.jobs_waiting_to_start)))\n ~capacity_available:\n (check (function\n | None -> ()\n | Some ivar -> assert (Ivar.is_empty ivar)))\n ~is_dead:ignore\n ~cleans:ignore\n ~num_resources_not_cleaned:\n (check (fun num_resources_not_cleaned ->\n assert (num_resources_not_cleaned >= 0);\n assert (num_resources_not_cleaned <= t.max_concurrent_jobs);\n if num_resources_not_cleaned < t.max_concurrent_jobs then assert t.is_dead))\n ~cleaned:\n (check (fun cleaned ->\n if Ivar.is_full cleaned then assert (t.num_resources_not_cleaned = 0)))\n with\n | exn -> raise_s [%message \"Throttle.invariant failed\" (exn : exn) (t : _ t)]\n;;\n\nmodule T2 = struct\n type nonrec ('a, 'kind) t = 'a t [@@deriving sexp_of]\n\n let invariant invariant_a _ t = invariant invariant_a t\nend\n\nlet num_jobs_waiting_to_start t = Queue.length t.jobs_waiting_to_start\n\nlet clean_resource t a =\n Deferred.all_unit (List.map t.cleans ~f:(fun f -> f a))\n >>> fun () ->\n t.num_resources_not_cleaned <- t.num_resources_not_cleaned - 1;\n if t.num_resources_not_cleaned = 0 then Ivar.fill t.cleaned ()\n;;\n\nlet kill t =\n if not t.is_dead\n then (\n t.is_dead <- true;\n Queue.iter t.jobs_waiting_to_start ~f:Internal_job.abort;\n Queue.clear t.jobs_waiting_to_start;\n Stack_or_counter.iter t.job_resources_not_in_use ~f:(fun a -> clean_resource t a);\n Stack_or_counter.clear t.job_resources_not_in_use)\n;;\n\nlet at_kill t f =\n (* We preserve the execution context so that exceptions raised by [f] go to the monitor\n in effect when [at_kill] was called. *)\n let f = unstage (Monitor.Exported_for_scheduler.preserve_execution_context' f) in\n t.cleans <- f :: t.cleans\n;;\n\nlet cleaned t = Ivar.read t.cleaned\n\nlet rec start_job t =\n assert (not t.is_dead);\n assert (t.num_jobs_running < t.max_concurrent_jobs);\n assert (not (Queue.is_empty t.jobs_waiting_to_start));\n let job = Queue.dequeue_exn t.jobs_waiting_to_start in\n t.num_jobs_running <- t.num_jobs_running + 1;\n let job_resource = Stack_or_counter.pop_exn t.job_resources_not_in_use in\n Internal_job.run job job_resource\n >>> fun res ->\n t.num_jobs_running <- t.num_jobs_running - 1;\n (match res with\n | `Ok -> ()\n | `Raised -> if not t.continue_on_error then kill t);\n if t.is_dead\n then clean_resource t job_resource\n else (\n Stack_or_counter.push t.job_resources_not_in_use job_resource;\n if not (Queue.is_empty t.jobs_waiting_to_start)\n then start_job t\n else (\n match t.capacity_available with\n | None -> ()\n | Some ivar ->\n Ivar.fill ivar ();\n t.capacity_available <- None))\n;;\n\nlet create_internal ~continue_on_error job_resources =\n let max_concurrent_jobs = Stack_or_counter.length job_resources in\n { continue_on_error\n ; max_concurrent_jobs\n ; job_resources_not_in_use = job_resources\n ; jobs_waiting_to_start = Queue.create ()\n ; num_jobs_running = 0\n ; capacity_available = None\n ; is_dead = false\n ; cleans = []\n ; num_resources_not_cleaned = max_concurrent_jobs\n ; cleaned = Ivar.create ()\n }\n;;\n\nlet create_with ~continue_on_error job_resources =\n create_internal ~continue_on_error (Stack_or_counter.of_list job_resources)\n;;\n\nmodule Sequencer = struct\n type nonrec 'a t = 'a t [@@deriving sexp_of]\n\n let create ?(continue_on_error = false) a = create_with ~continue_on_error [ a ]\nend\n\nlet create ~continue_on_error ~max_concurrent_jobs =\n if max_concurrent_jobs <= 0\n then\n raise_s\n [%message\n \"Throttle.create requires positive max_concurrent_jobs, but got\"\n (max_concurrent_jobs : int)];\n create_internal\n ~continue_on_error\n (Stack_or_counter.create_counter ~length:max_concurrent_jobs)\n;;\n\nmodule Job = struct\n type ('a, 'b) t =\n { internal_job : 'a Internal_job.t\n ; result : [ `Ok of 'b | `Aborted | `Raised of exn ] Deferred.t\n }\n\n let result t = t.result\n let abort t = Internal_job.abort t.internal_job\n\n let create f =\n let internal_job, result = Internal_job.create f in\n { internal_job; result }\n ;;\nend\n\nlet enqueue' t f =\n let job = Job.create f in\n if t.is_dead\n then Job.abort job\n else (\n Queue.enqueue t.jobs_waiting_to_start job.internal_job;\n if t.num_jobs_running < t.max_concurrent_jobs then start_job t);\n Job.result job\n;;\n\nlet handle_enqueue_result result =\n match result with\n | `Ok a -> a\n | `Aborted -> raise_s [%message \"throttle aborted job\"]\n | `Raised exn -> raise exn\n;;\n\nlet enqueue t f = enqueue' t f >>| handle_enqueue_result\n\nlet enqueue_exclusive t f =\n let n = t.max_concurrent_jobs in\n if Int.( >= ) n 1_000_000\n then\n raise_s\n [%sexp\n \"[enqueue_exclusive] was called with a very large value of \\\n [max_concurrent_jobs]. This doesn't work.\"];\n let done_ = Ivar.create () in\n assert (n > 0);\n let f_placeholder _slot = Ivar.read done_ in\n for _ = 1 to n - 1 do\n don't_wait_for (enqueue t f_placeholder)\n done;\n let%map result = enqueue' t (fun _slot -> f ()) in\n Ivar.fill done_ ();\n handle_enqueue_result result\n;;\n\nlet monad_sequence_how ?(how = `Sequential) ~f =\n stage\n (match how with\n | `Parallel -> f\n | (`Sequential | `Max_concurrent_jobs _) as how ->\n let max_concurrent_jobs =\n match how with\n | `Sequential -> 1\n | `Max_concurrent_jobs max_concurrent_jobs -> max_concurrent_jobs\n in\n let t = create ~continue_on_error:false ~max_concurrent_jobs in\n fun a -> enqueue t (fun () -> f a))\n;;\n\nlet monad_sequence_how2 ?(how = `Sequential) ~f =\n stage\n (match how with\n | `Parallel -> f\n | (`Sequential | `Max_concurrent_jobs _) as how ->\n let max_concurrent_jobs =\n match how with\n | `Sequential -> 1\n | `Max_concurrent_jobs max_concurrent_jobs -> max_concurrent_jobs\n in\n let t = create ~continue_on_error:false ~max_concurrent_jobs in\n fun a1 a2 -> enqueue t (fun () -> f a1 a2))\n;;\n\nlet prior_jobs_done t =\n (* We queue [t.max_concurrent_jobs] dummy jobs and when they are all started we know\n that all prior jobs finished. We make sure that all dummy jobs wait for the last one\n to get started before finishing. *)\n Deferred.create (fun all_dummy_jobs_running ->\n let dummy_jobs_running = ref 0 in\n for _ = 1 to t.max_concurrent_jobs do\n don't_wait_for\n (enqueue t (fun _ ->\n incr dummy_jobs_running;\n if !dummy_jobs_running = t.max_concurrent_jobs\n then Ivar.fill all_dummy_jobs_running ();\n Ivar.read all_dummy_jobs_running))\n done)\n;;\n\nlet capacity_available t =\n if num_jobs_running t < max_concurrent_jobs t\n then return ()\n else (\n match t.capacity_available with\n | Some ivar -> Ivar.read ivar\n | None -> Deferred.create (fun ivar -> t.capacity_available <- Some ivar))\n;;\n","open! Core_kernel\nopen! Import\ninclude Scheduler\n\nlet enqueue_job execution_context f a = enqueue (t ()) execution_context f a\n\nlet thread_safe_enqueue_job execution_context f a =\n thread_safe_enqueue_external_job (t ()) execution_context f a\n;;\n\nlet current_execution_context () = current_execution_context (t ())\nlet cycle_count () = cycle_count (t ())\nlet cycle_start_ns () = cycle_start (t ())\nlet cycle_start () = Time_ns.to_time_float_round_nearest (cycle_start_ns ())\nlet cycle_times_ns () = map_cycle_times (t ()) ~f:Fn.id\nlet cycle_times () = map_cycle_times (t ()) ~f:Time_ns.Span.to_span_float_round_nearest\nlet total_cycle_time () = total_cycle_time (t ())\nlet long_cycles ~at_least = long_cycles (t ()) ~at_least\nlet long_cycles_with_context ~at_least = long_cycles_with_context (t ()) ~at_least\nlet long_jobs_with_context = long_jobs_with_context (t ())\nlet last_cycle_time () = last_cycle_time (t ())\nlet event_precision_ns () = event_precision (t ())\nlet event_precision () = Time_ns.Span.to_span_float_round_nearest (event_precision_ns ())\n\nlet set_max_num_jobs_per_priority_per_cycle i =\n set_max_num_jobs_per_priority_per_cycle (t ()) i\n;;\n\nlet max_num_jobs_per_priority_per_cycle () = max_num_jobs_per_priority_per_cycle (t ())\nlet set_record_backtraces bool = set_record_backtraces (t ()) bool\nlet force_current_cycle_to_end () = force_current_cycle_to_end (t ())\nlet yield () = yield (t ())\nlet yield_until_no_jobs_remain ?may_return_immediately () =\n yield_until_no_jobs_remain ?may_return_immediately (t ())\n;;\n\nlet yield_every ~n =\n let yield_every = Staged.unstage (yield_every ~n) in\n let t = t () in\n stage (fun () -> yield_every t)\n;;\n\nlet num_jobs_run () = num_jobs_run (t ())\nlet num_pending_jobs () = num_pending_jobs (t ())\n\nmodule Expert = struct\n let run_cycles_until_no_jobs_remain = run_cycles_until_no_jobs_remain\n let set_on_start_of_cycle f = set_on_start_of_cycle (t ()) f\n let set_on_end_of_cycle f = set_on_end_of_cycle (t ()) f\n let last_cycle_num_jobs () = last_cycle_num_jobs (t ())\n let run_every_cycle_start f = run_every_cycle_start (t ()) ~f\n let run_every_cycle_end f = run_every_cycle_end (t ()) ~f\nend\n\nmodule Private = Scheduler\n","open! Core_kernel\nopen! Import\n\nmodule type Clock = Clock_intf.Clock\nmodule type Clock_deprecated = Clock_intf.Clock_deprecated\n\nmodule Scheduler = Scheduler1\n\nlet time_source () = (Scheduler.t ()).time_source |> Time_source.of_synchronous\nlet after span = Time_source.after (time_source ()) span\nlet at time = Time_source.at (time_source ()) time\n\nlet at_varying_intervals ?stop compute_span =\n Time_source.at_varying_intervals ?stop (time_source ()) compute_span\n;;\n\nlet at_intervals ?start ?stop interval =\n Time_source.at_intervals ?start ?stop (time_source ()) interval\n;;\n\nlet every' ?start ?stop ?continue_on_error ?finished span f =\n Time_source.every' ?start ?stop ?continue_on_error ?finished (time_source ()) span f\n;;\n\nlet every ?start ?stop ?continue_on_error span f =\n Time_source.every ?start ?stop ?continue_on_error (time_source ()) span f\n;;\n\nlet run_after span f a = Time_source.run_after (time_source ()) span f a\nlet run_at time f a = Time_source.run_at (time_source ()) time f a\n\nlet run_at_intervals ?start ?stop ?continue_on_error interval f =\n Time_source.run_at_intervals\n ?start\n ?stop\n ?continue_on_error\n (time_source ())\n interval\n f\n;;\n\nlet run_at_intervals' ?start ?stop ?continue_on_error interval f =\n Time_source.run_at_intervals'\n ?start\n ?stop\n ?continue_on_error\n (time_source ())\n interval\n f\n;;\n\nlet with_timeout span d = Time_source.with_timeout (time_source ()) span d\n\nmodule Event = struct\n include Time_source.Event\n\n let after span = after (time_source ()) span\n let run_after span f a = run_after (time_source ()) span f a\n let at time = at (time_source ()) time\n let run_at time f z = run_at (time_source ()) time f z\nend\n","open Core_kernel\nopen Deferred_std\nmodule Deferred = Deferred1\n\nlet foldi t ~init ~f =\n Deferred.create (fun result ->\n let rec loop t i b =\n match t with\n | [] -> Ivar.fill result b\n | x :: xs -> f i b x >>> fun b -> loop xs (i + 1) b\n in\n loop t 0 init)\n;;\n\nlet fold t ~init ~f = foldi t ~init ~f:(fun _ a x -> f a x)\n\nlet seqmapi t ~f =\n foldi t ~init:[] ~f:(fun i bs a ->\n let%map b = f i a in\n b :: bs)\n >>| List.rev\n;;\n\nlet all ds = seqmapi ds ~f:(fun _ x -> x)\nlet all_unit ds = Deferred.ignore_m (fold ds ~init:() ~f:(fun () d -> d))\n\nlet iteri ?(how = `Sequential) t ~f =\n match how with\n | (`Parallel | `Max_concurrent_jobs _) as how ->\n all_unit (List.mapi t ~f:(unstage (Throttle.monad_sequence_how2 ~how ~f)))\n | `Sequential -> foldi t ~init:() ~f:(fun i () x -> f i x)\n;;\n\nlet mapi ?(how = `Sequential) t ~f =\n match how with\n | (`Parallel | `Max_concurrent_jobs _) as how ->\n all (List.mapi t ~f:(unstage (Throttle.monad_sequence_how2 ~how ~f)))\n | `Sequential -> seqmapi t ~f\n;;\n\nlet filteri ?how t ~f =\n let%map bools = mapi t ?how ~f in\n List.rev (List.fold2_exn t bools ~init:[] ~f:(fun ac x b -> if b then x :: ac else ac))\n;;\n\nlet filter_mapi ?how t ~f = mapi t ?how ~f >>| List.filter_opt\nlet concat_mapi ?how t ~f = mapi t ?how ~f >>| List.concat\n\nlet find_mapi t ~f =\n let rec find_mapi t ~f i =\n match t with\n | [] -> return None\n | hd :: tl ->\n (match%bind f i hd with\n | None -> find_mapi tl ~f (i + 1)\n | Some _ as some -> return some)\n in\n find_mapi t ~f 0\n;;\n\nlet findi t ~f =\n find_mapi t ~f:(fun i elt ->\n let%map b = f i elt in\n if b then Some (i, elt) else None)\n;;\n\nlet find t ~f =\n find_mapi t ~f:(fun _ elt ->\n let%map b = f elt in\n if b then Some elt else None)\n;;\n\nlet existsi t ~f =\n match%map\n find_mapi t ~f:(fun i elt ->\n let%map b = f i elt in\n if b then Some () else None)\n with\n | Some () -> true\n | None -> false\n;;\n\nlet for_alli t ~f =\n match%map\n find_mapi t ~f:(fun i elt ->\n let%map b = f i elt in\n if not b then Some () else None)\n with\n | Some () -> false\n | None -> true\n;;\n\nlet iter ?how t ~f = iteri ?how t ~f:(fun _ a -> f a)\nlet map ?how t ~f = mapi ?how t ~f:(fun _ a -> f a)\nlet filter ?how t ~f = filteri ?how t ~f:(fun _ a -> f a)\nlet filter_map ?how t ~f = filter_mapi ?how t ~f:(fun _ a -> f a)\nlet concat_map ?how t ~f = concat_mapi ?how t ~f:(fun _ a -> f a)\nlet find_map t ~f = find_mapi t ~f:(fun _ a -> f a)\nlet exists t ~f = existsi t ~f:(fun _ a -> f a)\nlet for_all t ~f = for_alli t ~f:(fun _ a -> f a)\nlet init ?how n ~f = map ?how (List.init n ~f:Fn.id) ~f\n","open Core_kernel\nopen Deferred_std\nmodule Deferred = Deferred1\n\nmodule T = struct\n type ('a, 'error) t = ('a, 'error) Result.t Deferred.t\nend\n\ninclude T\n\nlet combine t1 t2 ~ok ~err =\n let%map t1 = t1\n and t2 = t2 in\n Result.combine t1 t2 ~ok ~err\n;;\n\ninclude Monad.Make2 (struct\n include T\n\n let return a = Deferred.return (Ok a)\n\n let bind t ~f =\n Deferred.bind t ~f:(function\n | Ok a -> f a\n | Error _ as error -> Deferred.return error)\n ;;\n\n let map t ~f = Deferred.map t ~f:(fun r -> Result.map r ~f)\n let map = `Custom map\n end)\n\nlet fail x = Deferred.return (Error x)\nlet failf format = Printf.ksprintf fail format\nlet map_error t ~f = Deferred.map t ~f:(fun r -> Result.map_error r ~f)\n","open! Core_kernel\nopen! Import\nmodule Deferred = Deferred1\n\nmodule Monitor = struct\n let try_with = Monitor.try_with\nend\n\n(* Copied to [eager_deferred_or_error.ml]. There should be no diffs below this line. *)\n\ninclude (Deferred_result : Monad.S2 with type ('a, 'b) t := ('a, 'b) Deferred_result.t)\n\ntype 'a t = 'a Or_error.t Deferred.t\n\ninclude Applicative.Make (struct\n type nonrec 'a t = 'a t\n\n let return = return\n\n let apply f x =\n Deferred_result.combine\n f\n x\n ~ok:(fun f x -> f x)\n ~err:(fun e1 e2 -> Error.of_list [ e1; e2 ])\n ;;\n\n let map = `Custom map\n end)\n\nmodule Let_syntax = struct\n let return = return\n\n include Monad_infix\n\n module Let_syntax = struct\n let return = return\n let map = map\n let bind = bind\n let both = both\n\n (* from Applicative.Make *)\n module Open_on_rhs = struct end\n end\nend\n\nopen Let_syntax\n\nlet fail error = Deferred.return (Result.fail error)\nlet ok_exn t = Deferred.map t ~f:Or_error.ok_exn\nlet of_exn exn = Deferred.return (Or_error.of_exn exn)\nlet of_exn_result t = Deferred.map t ~f:Or_error.of_exn_result\nlet error msg v sexp_of = Deferred.return (Or_error.error msg v sexp_of)\nlet error_s sexp = Deferred.return (Or_error.error_s sexp)\nlet error_string msg = Deferred.return (Or_error.error_string msg)\nlet errorf format = ksprintf error_string format\nlet tag t ~tag = Deferred.map t ~f:(Or_error.tag ~tag)\nlet tag_s t ~tag = Deferred.map t ~f:(Or_error.tag_s ~tag)\n\nlet tag_arg t message a sexp_of_a =\n Deferred.map t ~f:(fun t -> Or_error.tag_arg t message a sexp_of_a)\n;;\n\nlet unimplemented msg = Deferred.return (Or_error.unimplemented msg)\nlet combine_errors l = Deferred.map (Deferred.all l) ~f:Or_error.combine_errors\nlet combine_errors_unit l = Deferred.map (Deferred.all l) ~f:Or_error.combine_errors_unit\n\nlet filter_ok_at_least_one l =\n Deferred.map (Deferred.all l) ~f:Or_error.filter_ok_at_least_one\n;;\n\nlet find_map_ok l ~f =\n Deferred.repeat_until_finished (l, []) (fun (l, errors) ->\n match l with\n | [] ->\n let errors = Error.of_list (List.rev errors) in\n Deferred.return (`Finished (Error errors))\n | hd :: tl ->\n Deferred.map (f hd) ~f:(function\n | Error current_error -> `Repeat (tl, current_error :: errors)\n | Ok result -> `Finished (Ok result)))\n;;\n\nlet ok_unit = return ()\n\nlet try_with ?extract_exn ?run ?here ?name f =\n Deferred.map (Monitor.try_with ?extract_exn ?run ?here ?name f) ~f:(function\n | Error exn -> Error (Error.of_exn exn)\n | Ok _ as ok -> ok)\n;;\n\nlet try_with_join ?extract_exn ?run ?here ?name f =\n Deferred.map (try_with ?extract_exn ?run ?here ?name f) ~f:Or_error.join\n;;\n\nmodule List = struct\n let foldi list ~init:acc ~f =\n let rec loop i acc = function\n | [] -> return acc\n | hd :: tl ->\n let%bind acc = f i acc hd in\n loop (i + 1) acc tl\n in\n loop 0 acc list\n ;;\n\n let fold t ~init ~f = foldi t ~init ~f:(fun _ a x -> f a x)\n\n let seqmapi t ~f =\n foldi t ~init:[] ~f:(fun i bs a ->\n let%map b = f i a in\n b :: bs)\n >>| List.rev\n ;;\n\n let all = all\n let all_unit = all_unit\n\n let iteri ?(how = `Sequential) t ~f =\n match how with\n | (`Parallel | `Max_concurrent_jobs _) as how ->\n all_unit (List.mapi t ~f:(unstage (Throttle.monad_sequence_how2 ~how ~f)))\n | `Sequential -> foldi t ~init:() ~f:(fun i () x -> f i x)\n ;;\n\n let mapi ?(how = `Sequential) t ~f =\n match how with\n | (`Parallel | `Max_concurrent_jobs _) as how ->\n all (List.mapi t ~f:(unstage (Throttle.monad_sequence_how2 ~how ~f)))\n | `Sequential -> seqmapi t ~f\n ;;\n\n let filter_mapi ?how t ~f = mapi t ?how ~f >>| List.filter_opt\n let concat_mapi ?how t ~f = mapi t ?how ~f >>| List.concat\n\n let filteri ?how t ~f =\n filter_mapi ?how t ~f:(fun i x ->\n let%map b = f i x in\n if b then Some x else None)\n ;;\n\n let find_mapi t ~f =\n let rec find_mapi t ~f i =\n match t with\n | [] -> return None\n | hd :: tl ->\n (match%bind f i hd with\n | None -> find_mapi tl ~f (i + 1)\n | Some _ as some -> return some)\n in\n find_mapi t ~f 0\n ;;\n\n let find_map t ~f = find_mapi t ~f:(fun _ a -> f a)\n\n let findi t ~f =\n find_mapi t ~f:(fun i elt ->\n let%map b = f i elt in\n if b then Some (i, elt) else None)\n ;;\n\n let find t ~f =\n find_map t ~f:(fun elt ->\n let%map b = f elt in\n if b then Some elt else None)\n ;;\n\n let existsi t ~f =\n match%map\n find_mapi t ~f:(fun i elt ->\n let%map b = f i elt in\n if b then Some () else None)\n with\n | Some () -> true\n | None -> false\n ;;\n\n let for_alli t ~f =\n match%map\n find_mapi t ~f:(fun i elt ->\n let%map b = f i elt in\n if not b then Some () else None)\n with\n | Some () -> false\n | None -> true\n ;;\n\n let iter ?how t ~f = iteri ?how t ~f:(fun _ a -> f a)\n let map ?how t ~f = mapi ?how t ~f:(fun _ a -> f a)\n let filter ?how t ~f = filteri ?how t ~f:(fun _ a -> f a)\n let filter_map ?how t ~f = filter_mapi ?how t ~f:(fun _ a -> f a)\n let concat_map ?how t ~f = concat_mapi ?how t ~f:(fun _ a -> f a)\n let find_map t ~f = find_mapi t ~f:(fun _ a -> f a)\n let exists t ~f = existsi t ~f:(fun _ a -> f a)\n let for_all t ~f = for_alli t ~f:(fun _ a -> f a)\n let init ?how n ~f = map ?how (List.init n ~f:Fn.id) ~f\nend\n\nlet rec repeat_until_finished state f =\n match%bind f state with\n | `Repeat state -> repeat_until_finished state f\n | `Finished state -> return state\n;;\n","open Core_kernel\nopen Deferred_std\nmodule List = Deferred_list\n\n(* We implement all of the [Queue] operations by converting the queue to a list and then\n using the corresponding [List] operation. We use lists rather than arrays because\n arrays longer than a certain length are allocated in the major heap, which can cause\n unnecessary promotion of the elements in the queue. Also, when one is folding or\n iterating over an array, the entire array must be kept alive. When folding or\n iterating over a list, only the remaining tail of the list is kept alive. So, using\n arrays rather than lists would increase the live-space needed by the program. *)\n\nlet foldi t ~init ~f = List.foldi (Queue.to_list t) ~init ~f\nlet fold t ~init ~f = List.fold (Queue.to_list t) ~init ~f\nlet all t = List.all (Queue.to_list t) >>| Queue.of_list\nlet all_unit t = List.all_unit (Queue.to_list t)\nlet iter ?how t ~f = List.iter ?how (Queue.to_list t) ~f\nlet iteri ?how t ~f = List.iteri ?how (Queue.to_list t) ~f\nlet map ?how t ~f = List.map ?how (Queue.to_list t) ~f >>| Queue.of_list\nlet mapi ?how t ~f = List.mapi ?how (Queue.to_list t) ~f >>| Queue.of_list\nlet init ?how n ~f = List.init ?how n ~f >>| Queue.of_list\nlet filter ?how t ~f = List.filter ?how (Queue.to_list t) ~f >>| Queue.of_list\nlet filteri ?how t ~f = List.filteri ?how (Queue.to_list t) ~f >>| Queue.of_list\nlet filter_map ?how t ~f = List.filter_map ?how (Queue.to_list t) ~f >>| Queue.of_list\nlet filter_mapi ?how t ~f = List.filter_mapi ?how (Queue.to_list t) ~f >>| Queue.of_list\n\nlet concat_map ?how t ~f =\n List.concat_map ?how (Queue.to_list t) ~f:(fun x -> f x >>| Queue.to_list)\n >>| Queue.of_list\n;;\n\nlet concat_mapi ?how t ~f =\n List.concat_mapi ?how (Queue.to_list t) ~f:(fun i x -> f i x >>| Queue.to_list)\n >>| Queue.of_list\n;;\n\nlet find_map t ~f = List.find_map (Queue.to_list t) ~f\nlet find_mapi t ~f = List.find_mapi (Queue.to_list t) ~f\nlet find t ~f = List.find (Queue.to_list t) ~f\nlet findi t ~f = List.findi (Queue.to_list t) ~f\nlet for_all t ~f = List.for_all (Queue.to_list t) ~f\nlet for_alli t ~f = List.for_alli (Queue.to_list t) ~f\nlet exists t ~f = List.exists (Queue.to_list t) ~f\nlet existsi t ~f = List.existsi (Queue.to_list t) ~f\n","include Deferred1\nmodule Array = Deferred_array\nmodule List = Deferred_list\nmodule Map = Deferred_map\nmodule Memo = Deferred_memo\nmodule Option = Deferred_option\nmodule Or_error = Deferred_or_error\nmodule Queue = Deferred_queue\nmodule Result = Deferred_result\nmodule Sequence = Deferred_sequence\n","open Core_kernel\ninclude Gc\n\n(** [add_finalizer f x] is like [Gc.finalise f x], except that the finalizer is guaranteed\n to run as an Async job (i.e. without interrupting other Async jobs). Unprotected use\n of [Caml.Gc.finalise] or [Core.Gc.add_finalizer] in Async programs is wrong, because\n the finalizers won't hold the async lock, and thus could interleave arbitrarily with\n async jobs. *)\nlet add_finalizer heap_block f = Scheduler.(add_finalizer (t ())) heap_block f\n\nlet add_finalizer_exn heap_block f = Scheduler.(add_finalizer_exn (t ())) heap_block f\nlet add_finalizer_last heap_block f = Scheduler.(add_finalizer_last (t ())) heap_block f\n\nlet add_finalizer_last_exn heap_block f =\n Scheduler.(add_finalizer_last_exn (t ())) heap_block f\n;;\n\nmodule Alarm = struct\n module Alarm = Gc.Expert.Alarm\n\n type t = Alarm.t [@@deriving sexp_of]\n\n let create f = Scheduler.(create_alarm (t ())) f\n let delete = Alarm.delete\nend\n","# 1 \"src/digestif_bi.ml\"\nopen Bigarray_compat\n\ntype t = (char, int8_unsigned_elt, c_layout) Array1.t\n\nlet create n = Array1.create Char c_layout n\n\nlet length = Array1.dim\n\nlet sub = Array1.sub\n\nlet empty = Array1.create Char c_layout 0\n\nlet get = Array1.get\n\nlet copy t =\n let r = create (length t) in\n Array1.blit t r ;\n r\n\nlet init l f =\n let v = Array1.create Char c_layout l in\n for i = 0 to l - 1 do\n Array1.set v i (f i)\n done ;\n v\n\nexternal unsafe_get_32 : t -> int -> int32 = \"%caml_bigstring_get32u\"\n\nexternal unsafe_get_64 : t -> int -> int64 = \"%caml_bigstring_get64u\"\n\nlet unsafe_get_nat : t -> int -> nativeint =\n fun s i ->\n if Sys.word_size = 32\n then Nativeint.of_int32 @@ unsafe_get_32 s i\n else Int64.to_nativeint @@ unsafe_get_64 s i\n\nexternal unsafe_set_32 : t -> int -> int32 -> unit = \"%caml_bigstring_set32u\"\n\nexternal unsafe_set_64 : t -> int -> int64 -> unit = \"%caml_bigstring_set64u\"\n\nlet unsafe_set_nat : t -> int -> nativeint -> unit =\n fun s i v ->\n if Sys.word_size = 32\n then unsafe_set_32 s i (Nativeint.to_int32 v)\n else unsafe_set_64 s i (Int64.of_nativeint v)\n\nlet to_string v = String.init (length v) (Array1.get v)\n\nlet blit_from_bytes src src_off dst dst_off len =\n for i = 0 to len - 1 do\n Array1.set dst (dst_off + i) (Bytes.get src (src_off + i))\n done\n\nexternal swap32 : int32 -> int32 = \"%bswap_int32\"\n\nexternal swap64 : int64 -> int64 = \"%bswap_int64\"\n\nexternal swapnat : nativeint -> nativeint = \"%bswap_native\"\n\nlet cpu_to_be32 s i v =\n if Sys.big_endian then unsafe_set_32 s i v else unsafe_set_32 s i (swap32 v)\n\nlet cpu_to_le32 s i v =\n if Sys.big_endian then unsafe_set_32 s i (swap32 v) else unsafe_set_32 s i v\n\nlet cpu_to_be64 s i v =\n if Sys.big_endian then unsafe_set_64 s i v else unsafe_set_64 s i (swap64 v)\n\nlet cpu_to_le64 s i v =\n if Sys.big_endian then unsafe_set_64 s i (swap64 v) else unsafe_set_64 s i v\n\nlet be32_to_cpu s i =\n if Sys.big_endian then unsafe_get_32 s i else swap32 @@ unsafe_get_32 s i\n\nlet le32_to_cpu s i =\n if Sys.big_endian then swap32 @@ unsafe_get_32 s i else unsafe_get_32 s i\n\nlet be64_to_cpu s i =\n if Sys.big_endian then unsafe_get_64 s i else swap64 @@ unsafe_get_64 s i\n\nlet le64_to_cpu s i =\n if Sys.big_endian then swap64 @@ unsafe_get_64 s i else unsafe_get_64 s i\n\nlet benat_to_cpu s i =\n if Sys.big_endian then unsafe_get_nat s i else swapnat @@ unsafe_get_nat s i\n\nlet cpu_to_benat s i v =\n if Sys.big_endian\n then unsafe_set_nat s i v\n else unsafe_set_nat s i (swapnat v)\n","# 1 \"src/digestif_by.ml\"\ninclude Bytes\n\nexternal unsafe_get_32 : t -> int -> int32 = \"%caml_string_get32u\"\n\nexternal unsafe_get_64 : t -> int -> int64 = \"%caml_string_get64u\"\n\nlet unsafe_get_nat : t -> int -> nativeint =\n fun s i ->\n if Sys.word_size = 32\n then Nativeint.of_int32 @@ unsafe_get_32 s i\n else Int64.to_nativeint @@ unsafe_get_64 s i\n\nexternal unsafe_set_32 : t -> int -> int32 -> unit = \"%caml_string_set32u\"\n\nexternal unsafe_set_64 : t -> int -> int64 -> unit = \"%caml_string_set64u\"\n\nlet unsafe_set_nat : t -> int -> nativeint -> unit =\n fun s i v ->\n if Sys.word_size = 32\n then unsafe_set_32 s i (Nativeint.to_int32 v)\n else unsafe_set_64 s i (Int64.of_nativeint v)\n\nlet blit_from_bigstring src src_off dst dst_off len =\n for i = 0 to len - 1 do\n set dst (dst_off + i) src.{src_off + i}\n done\n\nlet rpad a size x =\n let l = length a in\n let b = create size in\n blit a 0 b 0 l ;\n fill b l (size - l) x ;\n b\n\nexternal swap32 : int32 -> int32 = \"%bswap_int32\"\n\nexternal swap64 : int64 -> int64 = \"%bswap_int64\"\n\nexternal swapnat : nativeint -> nativeint = \"%bswap_native\"\n\nlet cpu_to_be32 s i v =\n if Sys.big_endian then unsafe_set_32 s i v else unsafe_set_32 s i (swap32 v)\n\nlet cpu_to_le32 s i v =\n if Sys.big_endian then unsafe_set_32 s i (swap32 v) else unsafe_set_32 s i v\n\nlet cpu_to_be64 s i v =\n if Sys.big_endian then unsafe_set_64 s i v else unsafe_set_64 s i (swap64 v)\n\nlet cpu_to_le64 s i v =\n if Sys.big_endian then unsafe_set_64 s i (swap64 v) else unsafe_set_64 s i v\n\nlet be32_to_cpu s i =\n if Sys.big_endian then unsafe_get_32 s i else swap32 @@ unsafe_get_32 s i\n\nlet le32_to_cpu s i =\n if Sys.big_endian then swap32 @@ unsafe_get_32 s i else unsafe_get_32 s i\n\nlet be64_to_cpu s i =\n if Sys.big_endian then unsafe_get_64 s i else swap64 @@ unsafe_get_64 s i\n\nlet le64_to_cpu s i =\n if Sys.big_endian then swap64 @@ unsafe_get_64 s i else unsafe_get_64 s i\n\nlet benat_to_cpu s i =\n if Sys.big_endian then unsafe_get_nat s i else swapnat @@ unsafe_get_nat s i\n\nlet cpu_to_benat s i v =\n if Sys.big_endian\n then unsafe_set_nat s i v\n else unsafe_set_nat s i (swapnat v)\n","module Nat = struct\n include Nativeint\n\n let ( lxor ) = Nativeint.logxor\nend\n\nmodule type BUFFER = sig\n type t\n\n val length : t -> int\n\n val sub : t -> int -> int -> t\n\n val copy : t -> t\n\n val benat_to_cpu : t -> int -> nativeint\n\n val cpu_to_benat : t -> int -> nativeint -> unit\nend\n\nlet imin (a : int) (b : int) = if a < b then a else b\n\nmodule Make (B : BUFFER) = struct\n let size_of_long = Sys.word_size / 8\n\n (* XXX(dinosaure): I'm not sure about this code. May be we don't need the\n first loop and the _optimization_ is irrelevant. *)\n let xor_into src src_off dst dst_off n =\n let n = ref n in\n let i = ref 0 in\n while !n >= size_of_long do\n B.cpu_to_benat dst (dst_off + !i)\n Nat.(\n B.benat_to_cpu dst (dst_off + !i)\n lxor B.benat_to_cpu src (src_off + !i)) ;\n n := !n - size_of_long ;\n i := !i + size_of_long\n done ;\n while !n > 0 do\n B.cpu_to_benat dst (dst_off + !i)\n Nat.(\n B.benat_to_cpu src (src_off + !i)\n lxor B.benat_to_cpu dst (dst_off + !i)) ;\n incr i ;\n decr n\n done\n\n let xor_into a b n =\n if n > imin (B.length a) (B.length b)\n then raise (Invalid_argument \"Baijiu.Xor.xor_inrot: buffers to small\")\n else xor_into a 0 b 0 n\n\n let xor a b =\n let l = imin (B.length a) (B.length b) in\n let r = B.copy (B.sub b 0 l) in\n xor_into a r l ;\n r\nend\n\nmodule Bytes = Make (Digestif_by)\nmodule Bigstring = Make (Digestif_bi)\n","# 1 \"src/digestif_conv.ml\"\nlet invalid_arg fmt = Format.ksprintf (fun s -> invalid_arg s) fmt\n\nmodule Make (D : sig\n val digest_size : int\nend) =\nstruct\n let to_hex hash =\n let res = Bytes.create (D.digest_size * 2) in\n let chr x =\n match x with\n | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 -> Char.chr (48 + x)\n | _ -> Char.chr (97 + (x - 10)) in\n for i = 0 to D.digest_size - 1 do\n let v = Char.code hash.[i] in\n Bytes.unsafe_set res (i * 2) (chr (v lsr 4)) ;\n Bytes.unsafe_set res ((i * 2) + 1) (chr (v land 0x0F))\n done ;\n Bytes.unsafe_to_string res\n\n let code x =\n match x with\n | '0' .. '9' -> Char.code x - Char.code '0'\n | 'A' .. 'F' -> Char.code x - Char.code 'A' + 10\n | 'a' .. 'f' -> Char.code x - Char.code 'a' + 10\n | _ -> invalid_arg \"of_hex: %02X\" (Char.code x)\n\n let decode chr1 chr2 = Char.chr ((code chr1 lsl 4) lor code chr2)\n\n let of_hex hex =\n let offset = ref 0 in\n let rec go have_first idx =\n if !offset + idx >= String.length hex\n then '\\x00'\n else\n match hex.[!offset + idx] with\n | ' ' | '\\t' | '\\r' | '\\n' ->\n incr offset ;\n go have_first idx\n | chr2 when have_first -> chr2\n | chr1 ->\n incr offset ;\n let chr2 = go true idx in\n if chr2 <> '\\x00'\n then decode chr1 chr2\n else invalid_arg \"of_hex: odd number of hex characters\" in\n String.init D.digest_size (go false)\n\n let of_hex_opt hex =\n match of_hex hex with\n | digest -> Some digest\n | exception Invalid_argument _ -> None\n\n let consistent_of_hex str =\n let offset = ref 0 in\n let rec go have_first idx =\n if !offset + idx >= String.length str\n then invalid_arg \"Not enough hex value\"\n else\n match str.[!offset + idx] with\n | ' ' | '\\t' | '\\r' | '\\n' ->\n incr offset ;\n go have_first idx\n | chr2 when have_first -> chr2\n | chr1 ->\n incr offset ;\n let chr2 = go true idx in\n decode chr1 chr2 in\n let res = String.init D.digest_size (go false) in\n let is_wsp = function ' ' | '\\t' | '\\r' | '\\n' -> true | _ -> false in\n while\n D.digest_size + !offset < String.length str\n && is_wsp str.[!offset + (D.digest_size * 2)]\n do\n incr offset\n done ;\n if !offset + D.digest_size = String.length str\n then res\n else\n invalid_arg \"Too much enough bytes (reach: %d, expect: %d)\"\n (!offset + (D.digest_size * 2))\n (String.length str)\n\n let consistent_of_hex_opt hex =\n match consistent_of_hex hex with\n | digest -> Some digest\n | exception Invalid_argument _ -> None\n\n let pp ppf hash =\n for i = 0 to D.digest_size - 1 do\n Format.fprintf ppf \"%02x\" (Char.code hash.[i])\n done\n\n let of_raw_string x =\n if String.length x <> D.digest_size\n then invalid_arg \"invalid hash size\"\n else x\n\n let of_raw_string_opt x =\n match of_raw_string x with\n | digest -> Some digest\n | exception Invalid_argument _ -> None\n\n let to_raw_string x = x\nend\n","module By = Digestif_by\nmodule Bi = Digestif_bi\n\nmodule Int32 = struct\n include Int32\n\n let ( lsl ) = Int32.shift_left\n\n let ( lsr ) = Int32.shift_right_logical\n\n let ( asr ) = Int32.shift_right\n\n let ( lor ) = Int32.logor\n\n let ( lxor ) = Int32.logxor\n\n let ( land ) = Int32.logand\n\n let lnot = Int32.lognot\n\n let ( + ) = Int32.add\n\n let rol32 a n = (a lsl n) lor (a lsr (32 - n))\n\n let ror32 a n = (a lsr n) lor (a lsl (32 - n))\nend\n\nmodule Int64 = struct\n include Int64\n\n let ( land ) = Int64.logand\n\n let ( lsl ) = Int64.shift_left\nend\n\nmodule type S = sig\n type kind = [ `MD5 ]\n\n type ctx = { mutable size : int64; b : Bytes.t; h : int32 array }\n\n val init : unit -> ctx\n\n val unsafe_feed_bytes : ctx -> By.t -> int -> int -> unit\n\n val unsafe_feed_bigstring : ctx -> Bi.t -> int -> int -> unit\n\n val unsafe_get : ctx -> By.t\n\n val dup : ctx -> ctx\nend\n\nmodule Unsafe : S = struct\n type kind = [ `MD5 ]\n\n type ctx = { mutable size : int64; b : Bytes.t; h : int32 array }\n\n let dup ctx = { size = ctx.size; b = By.copy ctx.b; h = Array.copy ctx.h }\n\n let init () =\n let b = By.make 64 '\\x00' in\n {\n size = 0L;\n b;\n h = [| 0x67452301l; 0xefcdab89l; 0x98badcfel; 0x10325476l |];\n }\n\n let f1 x y z = Int32.(z lxor (x land (y lxor z)))\n\n let f2 x y z = f1 z x y\n\n let f3 x y z = Int32.(x lxor y lxor z)\n\n let f4 x y z = Int32.(y lxor (x lor lnot z))\n\n let md5_do_chunk :\n type a. le32_to_cpu:(a -> int -> int32) -> ctx -> a -> int -> unit =\n fun ~le32_to_cpu ctx buf off ->\n let a, b, c, d =\n (ref ctx.h.(0), ref ctx.h.(1), ref ctx.h.(2), ref ctx.h.(3)) in\n let w = Array.make 16 0l in\n for i = 0 to 15 do\n w.(i) <- le32_to_cpu buf (off + (i * 4))\n done ;\n let round f a b c d i k s =\n let open Int32 in\n a := !a + f !b !c !d + w.(i) + k ;\n a := rol32 !a s ;\n a := !a + !b in\n round f1 a b c d 0 0xd76aa478l 7 ;\n round f1 d a b c 1 0xe8c7b756l 12 ;\n round f1 c d a b 2 0x242070dbl 17 ;\n round f1 b c d a 3 0xc1bdceeel 22 ;\n round f1 a b c d 4 0xf57c0fafl 7 ;\n round f1 d a b c 5 0x4787c62al 12 ;\n round f1 c d a b 6 0xa8304613l 17 ;\n round f1 b c d a 7 0xfd469501l 22 ;\n round f1 a b c d 8 0x698098d8l 7 ;\n round f1 d a b c 9 0x8b44f7afl 12 ;\n round f1 c d a b 10 0xffff5bb1l 17 ;\n round f1 b c d a 11 0x895cd7bel 22 ;\n round f1 a b c d 12 0x6b901122l 7 ;\n round f1 d a b c 13 0xfd987193l 12 ;\n round f1 c d a b 14 0xa679438el 17 ;\n round f1 b c d a 15 0x49b40821l 22 ;\n round f2 a b c d 1 0xf61e2562l 5 ;\n round f2 d a b c 6 0xc040b340l 9 ;\n round f2 c d a b 11 0x265e5a51l 14 ;\n round f2 b c d a 0 0xe9b6c7aal 20 ;\n round f2 a b c d 5 0xd62f105dl 5 ;\n round f2 d a b c 10 0x02441453l 9 ;\n round f2 c d a b 15 0xd8a1e681l 14 ;\n round f2 b c d a 4 0xe7d3fbc8l 20 ;\n round f2 a b c d 9 0x21e1cde6l 5 ;\n round f2 d a b c 14 0xc33707d6l 9 ;\n round f2 c d a b 3 0xf4d50d87l 14 ;\n round f2 b c d a 8 0x455a14edl 20 ;\n round f2 a b c d 13 0xa9e3e905l 5 ;\n round f2 d a b c 2 0xfcefa3f8l 9 ;\n round f2 c d a b 7 0x676f02d9l 14 ;\n round f2 b c d a 12 0x8d2a4c8al 20 ;\n round f3 a b c d 5 0xfffa3942l 4 ;\n round f3 d a b c 8 0x8771f681l 11 ;\n round f3 c d a b 11 0x6d9d6122l 16 ;\n round f3 b c d a 14 0xfde5380cl 23 ;\n round f3 a b c d 1 0xa4beea44l 4 ;\n round f3 d a b c 4 0x4bdecfa9l 11 ;\n round f3 c d a b 7 0xf6bb4b60l 16 ;\n round f3 b c d a 10 0xbebfbc70l 23 ;\n round f3 a b c d 13 0x289b7ec6l 4 ;\n round f3 d a b c 0 0xeaa127fal 11 ;\n round f3 c d a b 3 0xd4ef3085l 16 ;\n round f3 b c d a 6 0x04881d05l 23 ;\n round f3 a b c d 9 0xd9d4d039l 4 ;\n round f3 d a b c 12 0xe6db99e5l 11 ;\n round f3 c d a b 15 0x1fa27cf8l 16 ;\n round f3 b c d a 2 0xc4ac5665l 23 ;\n round f4 a b c d 0 0xf4292244l 6 ;\n round f4 d a b c 7 0x432aff97l 10 ;\n round f4 c d a b 14 0xab9423a7l 15 ;\n round f4 b c d a 5 0xfc93a039l 21 ;\n round f4 a b c d 12 0x655b59c3l 6 ;\n round f4 d a b c 3 0x8f0ccc92l 10 ;\n round f4 c d a b 10 0xffeff47dl 15 ;\n round f4 b c d a 1 0x85845dd1l 21 ;\n round f4 a b c d 8 0x6fa87e4fl 6 ;\n round f4 d a b c 15 0xfe2ce6e0l 10 ;\n round f4 c d a b 6 0xa3014314l 15 ;\n round f4 b c d a 13 0x4e0811a1l 21 ;\n round f4 a b c d 4 0xf7537e82l 6 ;\n round f4 d a b c 11 0xbd3af235l 10 ;\n round f4 c d a b 2 0x2ad7d2bbl 15 ;\n round f4 b c d a 9 0xeb86d391l 21 ;\n let open Int32 in\n ctx.h.(0) <- ctx.h.(0) + !a ;\n ctx.h.(1) <- ctx.h.(1) + !b ;\n ctx.h.(2) <- ctx.h.(2) + !c ;\n ctx.h.(3) <- ctx.h.(3) + !d ;\n ()\n\n let feed :\n type a.\n blit:(a -> int -> By.t -> int -> int -> unit) ->\n le32_to_cpu:(a -> int -> int32) ->\n ctx ->\n a ->\n int ->\n int ->\n unit =\n fun ~blit ~le32_to_cpu ctx buf off len ->\n let idx = ref Int64.(to_int (ctx.size land 0x3FL)) in\n let len = ref len in\n let off = ref off in\n let to_fill = 64 - !idx in\n ctx.size <- Int64.add ctx.size (Int64.of_int !len) ;\n if !idx <> 0 && !len >= to_fill\n then (\n blit buf !off ctx.b !idx to_fill ;\n md5_do_chunk ~le32_to_cpu:By.le32_to_cpu ctx ctx.b 0 ;\n len := !len - to_fill ;\n off := !off + to_fill ;\n idx := 0) ;\n while !len >= 64 do\n md5_do_chunk ~le32_to_cpu ctx buf !off ;\n len := !len - 64 ;\n off := !off + 64\n done ;\n if !len <> 0 then blit buf !off ctx.b !idx !len ;\n ()\n\n let unsafe_feed_bytes = feed ~blit:By.blit ~le32_to_cpu:By.le32_to_cpu\n\n let unsafe_feed_bigstring =\n feed ~blit:By.blit_from_bigstring ~le32_to_cpu:Bi.le32_to_cpu\n\n let unsafe_get ctx =\n let index = Int64.(to_int (ctx.size land 0x3FL)) in\n let padlen = if index < 56 then 56 - index else 64 + 56 - index in\n let padding = By.init padlen (function 0 -> '\\x80' | _ -> '\\x00') in\n let bits = By.create 8 in\n By.cpu_to_le64 bits 0 Int64.(ctx.size lsl 3) ;\n unsafe_feed_bytes ctx padding 0 padlen ;\n unsafe_feed_bytes ctx bits 0 8 ;\n let res = By.create (4 * 4) in\n for i = 0 to 3 do\n By.cpu_to_le32 res (i * 4) ctx.h.(i)\n done ;\n res\nend\n","module By = Digestif_by\nmodule Bi = Digestif_bi\n\nmodule type S = sig\n type ctx\n\n type kind = [ `RMD160 ]\n\n val init : unit -> ctx\n\n val unsafe_feed_bytes : ctx -> By.t -> int -> int -> unit\n\n val unsafe_feed_bigstring : ctx -> Bi.t -> int -> int -> unit\n\n val unsafe_get : ctx -> By.t\n\n val dup : ctx -> ctx\nend\n\nmodule Int32 = struct\n include Int32\n\n let ( lsl ) = Int32.shift_left\n\n let ( lsr ) = Int32.shift_right_logical\n\n let ( asr ) = Int32.shift_right\n\n let ( lor ) = Int32.logor\n\n let ( lxor ) = Int32.logxor\n\n let ( land ) = Int32.logand\n\n let lnot = Int32.lognot\n\n let ( + ) = Int32.add\n\n let rol32 a n = (a lsl n) lor (a lsr (32 - n))\n\n let ror32 a n = (a lsr n) lor (a lsl (32 - n))\nend\n\nmodule Int64 = struct\n include Int64\n\n let ( land ) = Int64.logand\n\n let ( lsl ) = Int64.shift_left\nend\n\nmodule Unsafe : S = struct\n type kind = [ `RMD160 ]\n\n type ctx = { s : int32 array; mutable n : int; h : int32 array; b : Bytes.t }\n\n let dup ctx =\n { s = Array.copy ctx.s; n = ctx.n; h = Array.copy ctx.h; b = By.copy ctx.b }\n\n let init () =\n let b = By.make 64 '\\x00' in\n {\n s = [| 0l; 0l |];\n n = 0;\n b;\n h = [| 0x67452301l; 0xefcdab89l; 0x98badcfel; 0x10325476l; 0xc3d2e1f0l |];\n }\n\n let f x y z = Int32.(x lxor y lxor z)\n\n let g x y z = Int32.(x land y lor (lnot x land z))\n\n let h x y z = Int32.(x lor lnot y lxor z)\n\n let i x y z = Int32.(x land z lor (y land lnot z))\n\n let j x y z = Int32.(x lxor (y lor lnot z))\n\n let ff a b c d e x s =\n let open Int32 in\n a := !a + f !b !c !d + x ;\n a := rol32 !a s + !e ;\n c := rol32 !c 10\n\n let gg a b c d e x s =\n let open Int32 in\n a := !a + g !b !c !d + x + 0x5a827999l ;\n a := rol32 !a s + !e ;\n c := rol32 !c 10\n\n let hh a b c d e x s =\n let open Int32 in\n a := !a + h !b !c !d + x + 0x6ed9eba1l ;\n a := rol32 !a s + !e ;\n c := rol32 !c 10\n\n let ii a b c d e x s =\n let open Int32 in\n a := !a + i !b !c !d + x + 0x8f1bbcdcl ;\n a := rol32 !a s + !e ;\n c := rol32 !c 10\n\n let jj a b c d e x s =\n let open Int32 in\n a := !a + j !b !c !d + x + 0xa953fd4el ;\n a := rol32 !a s + !e ;\n c := rol32 !c 10\n\n let fff a b c d e x s =\n let open Int32 in\n a := !a + f !b !c !d + x ;\n a := rol32 !a s + !e ;\n c := rol32 !c 10\n\n let ggg a b c d e x s =\n let open Int32 in\n a := !a + g !b !c !d + x + 0x7a6d76e9l ;\n a := rol32 !a s + !e ;\n c := rol32 !c 10\n\n let hhh a b c d e x s =\n let open Int32 in\n a := !a + h !b !c !d + x + 0x6d703ef3l ;\n a := rol32 !a s + !e ;\n c := rol32 !c 10\n\n let iii a b c d e x s =\n let open Int32 in\n a := !a + i !b !c !d + x + 0x5c4dd124l ;\n a := rol32 !a s + !e ;\n c := rol32 !c 10\n\n let jjj a b c d e x s =\n let open Int32 in\n a := !a + j !b !c !d + x + 0x50a28be6l ;\n a := rol32 !a s + !e ;\n c := rol32 !c 10\n\n let rmd160_do_chunk :\n type a. le32_to_cpu:(a -> int -> int32) -> ctx -> a -> int -> unit =\n fun ~le32_to_cpu ctx buff off ->\n let aa, bb, cc, dd, ee, aaa, bbb, ccc, ddd, eee =\n ( ref ctx.h.(0),\n ref ctx.h.(1),\n ref ctx.h.(2),\n ref ctx.h.(3),\n ref ctx.h.(4),\n ref ctx.h.(0),\n ref ctx.h.(1),\n ref ctx.h.(2),\n ref ctx.h.(3),\n ref ctx.h.(4) ) in\n let w = Array.make 16 0l in\n for i = 0 to 15 do\n w.(i) <- le32_to_cpu buff (off + (i * 4))\n done ;\n ff aa bb cc dd ee w.(0) 11 ;\n ff ee aa bb cc dd w.(1) 14 ;\n ff dd ee aa bb cc w.(2) 15 ;\n ff cc dd ee aa bb w.(3) 12 ;\n ff bb cc dd ee aa w.(4) 5 ;\n ff aa bb cc dd ee w.(5) 8 ;\n ff ee aa bb cc dd w.(6) 7 ;\n ff dd ee aa bb cc w.(7) 9 ;\n ff cc dd ee aa bb w.(8) 11 ;\n ff bb cc dd ee aa w.(9) 13 ;\n ff aa bb cc dd ee w.(10) 14 ;\n ff ee aa bb cc dd w.(11) 15 ;\n ff dd ee aa bb cc w.(12) 6 ;\n ff cc dd ee aa bb w.(13) 7 ;\n ff bb cc dd ee aa w.(14) 9 ;\n ff aa bb cc dd ee w.(15) 8 ;\n gg ee aa bb cc dd w.(7) 7 ;\n gg dd ee aa bb cc w.(4) 6 ;\n gg cc dd ee aa bb w.(13) 8 ;\n gg bb cc dd ee aa w.(1) 13 ;\n gg aa bb cc dd ee w.(10) 11 ;\n gg ee aa bb cc dd w.(6) 9 ;\n gg dd ee aa bb cc w.(15) 7 ;\n gg cc dd ee aa bb w.(3) 15 ;\n gg bb cc dd ee aa w.(12) 7 ;\n gg aa bb cc dd ee w.(0) 12 ;\n gg ee aa bb cc dd w.(9) 15 ;\n gg dd ee aa bb cc w.(5) 9 ;\n gg cc dd ee aa bb w.(2) 11 ;\n gg bb cc dd ee aa w.(14) 7 ;\n gg aa bb cc dd ee w.(11) 13 ;\n gg ee aa bb cc dd w.(8) 12 ;\n hh dd ee aa bb cc w.(3) 11 ;\n hh cc dd ee aa bb w.(10) 13 ;\n hh bb cc dd ee aa w.(14) 6 ;\n hh aa bb cc dd ee w.(4) 7 ;\n hh ee aa bb cc dd w.(9) 14 ;\n hh dd ee aa bb cc w.(15) 9 ;\n hh cc dd ee aa bb w.(8) 13 ;\n hh bb cc dd ee aa w.(1) 15 ;\n hh aa bb cc dd ee w.(2) 14 ;\n hh ee aa bb cc dd w.(7) 8 ;\n hh dd ee aa bb cc w.(0) 13 ;\n hh cc dd ee aa bb w.(6) 6 ;\n hh bb cc dd ee aa w.(13) 5 ;\n hh aa bb cc dd ee w.(11) 12 ;\n hh ee aa bb cc dd w.(5) 7 ;\n hh dd ee aa bb cc w.(12) 5 ;\n ii cc dd ee aa bb w.(1) 11 ;\n ii bb cc dd ee aa w.(9) 12 ;\n ii aa bb cc dd ee w.(11) 14 ;\n ii ee aa bb cc dd w.(10) 15 ;\n ii dd ee aa bb cc w.(0) 14 ;\n ii cc dd ee aa bb w.(8) 15 ;\n ii bb cc dd ee aa w.(12) 9 ;\n ii aa bb cc dd ee w.(4) 8 ;\n ii ee aa bb cc dd w.(13) 9 ;\n ii dd ee aa bb cc w.(3) 14 ;\n ii cc dd ee aa bb w.(7) 5 ;\n ii bb cc dd ee aa w.(15) 6 ;\n ii aa bb cc dd ee w.(14) 8 ;\n ii ee aa bb cc dd w.(5) 6 ;\n ii dd ee aa bb cc w.(6) 5 ;\n ii cc dd ee aa bb w.(2) 12 ;\n jj bb cc dd ee aa w.(4) 9 ;\n jj aa bb cc dd ee w.(0) 15 ;\n jj ee aa bb cc dd w.(5) 5 ;\n jj dd ee aa bb cc w.(9) 11 ;\n jj cc dd ee aa bb w.(7) 6 ;\n jj bb cc dd ee aa w.(12) 8 ;\n jj aa bb cc dd ee w.(2) 13 ;\n jj ee aa bb cc dd w.(10) 12 ;\n jj dd ee aa bb cc w.(14) 5 ;\n jj cc dd ee aa bb w.(1) 12 ;\n jj bb cc dd ee aa w.(3) 13 ;\n jj aa bb cc dd ee w.(8) 14 ;\n jj ee aa bb cc dd w.(11) 11 ;\n jj dd ee aa bb cc w.(6) 8 ;\n jj cc dd ee aa bb w.(15) 5 ;\n jj bb cc dd ee aa w.(13) 6 ;\n jjj aaa bbb ccc ddd eee w.(5) 8 ;\n jjj eee aaa bbb ccc ddd w.(14) 9 ;\n jjj ddd eee aaa bbb ccc w.(7) 9 ;\n jjj ccc ddd eee aaa bbb w.(0) 11 ;\n jjj bbb ccc ddd eee aaa w.(9) 13 ;\n jjj aaa bbb ccc ddd eee w.(2) 15 ;\n jjj eee aaa bbb ccc ddd w.(11) 15 ;\n jjj ddd eee aaa bbb ccc w.(4) 5 ;\n jjj ccc ddd eee aaa bbb w.(13) 7 ;\n jjj bbb ccc ddd eee aaa w.(6) 7 ;\n jjj aaa bbb ccc ddd eee w.(15) 8 ;\n jjj eee aaa bbb ccc ddd w.(8) 11 ;\n jjj ddd eee aaa bbb ccc w.(1) 14 ;\n jjj ccc ddd eee aaa bbb w.(10) 14 ;\n jjj bbb ccc ddd eee aaa w.(3) 12 ;\n jjj aaa bbb ccc ddd eee w.(12) 6 ;\n iii eee aaa bbb ccc ddd w.(6) 9 ;\n iii ddd eee aaa bbb ccc w.(11) 13 ;\n iii ccc ddd eee aaa bbb w.(3) 15 ;\n iii bbb ccc ddd eee aaa w.(7) 7 ;\n iii aaa bbb ccc ddd eee w.(0) 12 ;\n iii eee aaa bbb ccc ddd w.(13) 8 ;\n iii ddd eee aaa bbb ccc w.(5) 9 ;\n iii ccc ddd eee aaa bbb w.(10) 11 ;\n iii bbb ccc ddd eee aaa w.(14) 7 ;\n iii aaa bbb ccc ddd eee w.(15) 7 ;\n iii eee aaa bbb ccc ddd w.(8) 12 ;\n iii ddd eee aaa bbb ccc w.(12) 7 ;\n iii ccc ddd eee aaa bbb w.(4) 6 ;\n iii bbb ccc ddd eee aaa w.(9) 15 ;\n iii aaa bbb ccc ddd eee w.(1) 13 ;\n iii eee aaa bbb ccc ddd w.(2) 11 ;\n hhh ddd eee aaa bbb ccc w.(15) 9 ;\n hhh ccc ddd eee aaa bbb w.(5) 7 ;\n hhh bbb ccc ddd eee aaa w.(1) 15 ;\n hhh aaa bbb ccc ddd eee w.(3) 11 ;\n hhh eee aaa bbb ccc ddd w.(7) 8 ;\n hhh ddd eee aaa bbb ccc w.(14) 6 ;\n hhh ccc ddd eee aaa bbb w.(6) 6 ;\n hhh bbb ccc ddd eee aaa w.(9) 14 ;\n hhh aaa bbb ccc ddd eee w.(11) 12 ;\n hhh eee aaa bbb ccc ddd w.(8) 13 ;\n hhh ddd eee aaa bbb ccc w.(12) 5 ;\n hhh ccc ddd eee aaa bbb w.(2) 14 ;\n hhh bbb ccc ddd eee aaa w.(10) 13 ;\n hhh aaa bbb ccc ddd eee w.(0) 13 ;\n hhh eee aaa bbb ccc ddd w.(4) 7 ;\n hhh ddd eee aaa bbb ccc w.(13) 5 ;\n ggg ccc ddd eee aaa bbb w.(8) 15 ;\n ggg bbb ccc ddd eee aaa w.(6) 5 ;\n ggg aaa bbb ccc ddd eee w.(4) 8 ;\n ggg eee aaa bbb ccc ddd w.(1) 11 ;\n ggg ddd eee aaa bbb ccc w.(3) 14 ;\n ggg ccc ddd eee aaa bbb w.(11) 14 ;\n ggg bbb ccc ddd eee aaa w.(15) 6 ;\n ggg aaa bbb ccc ddd eee w.(0) 14 ;\n ggg eee aaa bbb ccc ddd w.(5) 6 ;\n ggg ddd eee aaa bbb ccc w.(12) 9 ;\n ggg ccc ddd eee aaa bbb w.(2) 12 ;\n ggg bbb ccc ddd eee aaa w.(13) 9 ;\n ggg aaa bbb ccc ddd eee w.(9) 12 ;\n ggg eee aaa bbb ccc ddd w.(7) 5 ;\n ggg ddd eee aaa bbb ccc w.(10) 15 ;\n ggg ccc ddd eee aaa bbb w.(14) 8 ;\n fff bbb ccc ddd eee aaa w.(12) 8 ;\n fff aaa bbb ccc ddd eee w.(15) 5 ;\n fff eee aaa bbb ccc ddd w.(10) 12 ;\n fff ddd eee aaa bbb ccc w.(4) 9 ;\n fff ccc ddd eee aaa bbb w.(1) 12 ;\n fff bbb ccc ddd eee aaa w.(5) 5 ;\n fff aaa bbb ccc ddd eee w.(8) 14 ;\n fff eee aaa bbb ccc ddd w.(7) 6 ;\n fff ddd eee aaa bbb ccc w.(6) 8 ;\n fff ccc ddd eee aaa bbb w.(2) 13 ;\n fff bbb ccc ddd eee aaa w.(13) 6 ;\n fff aaa bbb ccc ddd eee w.(14) 5 ;\n fff eee aaa bbb ccc ddd w.(0) 15 ;\n fff ddd eee aaa bbb ccc w.(3) 13 ;\n fff ccc ddd eee aaa bbb w.(9) 11 ;\n fff bbb ccc ddd eee aaa w.(11) 11 ;\n let open Int32 in\n ddd := !ddd + !cc + ctx.h.(1) ;\n (* final result for h[0]. *)\n ctx.h.(1) <- ctx.h.(2) + !dd + !eee ;\n ctx.h.(2) <- ctx.h.(3) + !ee + !aaa ;\n ctx.h.(3) <- ctx.h.(4) + !aa + !bbb ;\n ctx.h.(4) <- ctx.h.(0) + !bb + !ccc ;\n ctx.h.(0) <- !ddd ;\n ()\n\n exception Leave\n\n let feed :\n type a.\n le32_to_cpu:(a -> int -> int32) ->\n blit:(a -> int -> By.t -> int -> int -> unit) ->\n ctx ->\n a ->\n int ->\n int ->\n unit =\n fun ~le32_to_cpu ~blit ctx buf off len ->\n let t = ref ctx.s.(0) in\n let off = ref off in\n let len = ref len in\n ctx.s.(0) <- Int32.add !t (Int32.of_int (!len lsl 3)) ;\n if ctx.s.(0) < !t then ctx.s.(1) <- Int32.(ctx.s.(1) + 1l) ;\n ctx.s.(1) <- Int32.add ctx.s.(1) (Int32.of_int (!len lsr 29)) ;\n try\n if ctx.n <> 0\n then (\n let t = 64 - ctx.n in\n if !len < t\n then (\n blit buf !off ctx.b ctx.n !len ;\n ctx.n <- ctx.n + !len ;\n raise Leave) ;\n blit buf !off ctx.b ctx.n t ;\n rmd160_do_chunk ~le32_to_cpu:By.le32_to_cpu ctx ctx.b 0 ;\n off := !off + t ;\n len := !len - t) ;\n while !len >= 64 do\n rmd160_do_chunk ~le32_to_cpu ctx buf !off ;\n off := !off + 64 ;\n len := !len - 64\n done ;\n blit buf !off ctx.b 0 !len ;\n ctx.n <- !len\n with Leave -> ()\n\n let unsafe_feed_bytes ctx buf off len =\n feed ~blit:By.blit ~le32_to_cpu:By.le32_to_cpu ctx buf off len\n\n let unsafe_feed_bigstring ctx buf off len =\n feed ~blit:By.blit_from_bigstring ~le32_to_cpu:Bi.le32_to_cpu ctx buf off\n len\n\n let unsafe_get ctx =\n let i = ref (ctx.n + 1) in\n let res = By.create (5 * 4) in\n By.set ctx.b ctx.n '\\x80' ;\n if !i > 56\n then (\n By.fill ctx.b !i (64 - !i) '\\x00' ;\n rmd160_do_chunk ~le32_to_cpu:By.le32_to_cpu ctx ctx.b 0 ;\n i := 0) ;\n By.fill ctx.b !i (56 - !i) '\\x00' ;\n By.cpu_to_le32 ctx.b 56 ctx.s.(0) ;\n By.cpu_to_le32 ctx.b 60 ctx.s.(1) ;\n rmd160_do_chunk ~le32_to_cpu:By.le32_to_cpu ctx ctx.b 0 ;\n for i = 0 to 4 do\n By.cpu_to_le32 res (i * 4) ctx.h.(i)\n done ;\n res\nend\n","module By = Digestif_by\nmodule Bi = Digestif_bi\n\nmodule Int32 = struct\n include Int32\n\n let ( lsl ) = Int32.shift_left\n\n let ( lsr ) = Int32.shift_right_logical\n\n let ( asr ) = Int32.shift_right\n\n let ( lor ) = Int32.logor\n\n let ( lxor ) = Int32.logxor\n\n let ( land ) = Int32.logand\n\n let ( + ) = Int32.add\n\n let rol32 a n = (a lsl n) lor (a lsr (32 - n))\nend\n\nmodule Int64 = struct\n include Int64\n\n let ( land ) = Int64.logand\n\n let ( lsl ) = Int64.shift_left\nend\n\nmodule type S = sig\n type ctx\n\n type kind = [ `SHA1 ]\n\n val init : unit -> ctx\n\n val unsafe_feed_bytes : ctx -> By.t -> int -> int -> unit\n\n val unsafe_feed_bigstring : ctx -> Bi.t -> int -> int -> unit\n\n val unsafe_get : ctx -> By.t\n\n val dup : ctx -> ctx\nend\n\nmodule Unsafe : S = struct\n type kind = [ `SHA1 ]\n\n type ctx = { mutable size : int64; b : Bytes.t; h : int32 array }\n\n let dup ctx = { size = ctx.size; b = By.copy ctx.b; h = Array.copy ctx.h }\n\n let init () =\n let b = By.make 64 '\\x00' in\n {\n size = 0L;\n b;\n h = [| 0x67452301l; 0xefcdab89l; 0x98badcfel; 0x10325476l; 0xc3d2e1f0l |];\n }\n\n let f1 x y z = Int32.(z lxor (x land (y lxor z)))\n\n let f2 x y z = Int32.(x lxor y lxor z)\n\n let f3 x y z = Int32.((x land y) + (z land (x lxor y)))\n\n let f4 = f2\n\n let k1 = 0x5a827999l\n\n let k2 = 0x6ed9eba1l\n\n let k3 = 0x8f1bbcdcl\n\n let k4 = 0xca62c1d6l\n\n let sha1_do_chunk :\n type a. be32_to_cpu:(a -> int -> int32) -> ctx -> a -> int -> unit =\n fun ~be32_to_cpu ctx buf off ->\n let a = ref ctx.h.(0) in\n let b = ref ctx.h.(1) in\n let c = ref ctx.h.(2) in\n let d = ref ctx.h.(3) in\n let e = ref ctx.h.(4) in\n let w = Array.make 16 0l in\n let m i =\n let ( && ) a b = a land b in\n let ( -- ) a b = a - b in\n let v =\n Int32.(\n rol32\n (w.(i && 0x0F)\n lxor w.((i -- 14) && 0x0F)\n lxor w.((i -- 8) && 0x0F)\n lxor w.((i -- 3) && 0x0F))\n 1) in\n w.(i land 0x0F) <- v ;\n w.(i land 0x0F) in\n let round a b c d e f k w =\n (e := Int32.(!e + rol32 !a 5 + f !b !c !d + k + w)) ;\n b := Int32.(rol32 !b 30) in\n for i = 0 to 15 do\n w.(i) <- be32_to_cpu buf (off + (i * 4))\n done ;\n round a b c d e f1 k1 w.(0) ;\n round e a b c d f1 k1 w.(1) ;\n round d e a b c f1 k1 w.(2) ;\n round c d e a b f1 k1 w.(3) ;\n round b c d e a f1 k1 w.(4) ;\n round a b c d e f1 k1 w.(5) ;\n round e a b c d f1 k1 w.(6) ;\n round d e a b c f1 k1 w.(7) ;\n round c d e a b f1 k1 w.(8) ;\n round b c d e a f1 k1 w.(9) ;\n round a b c d e f1 k1 w.(10) ;\n round e a b c d f1 k1 w.(11) ;\n round d e a b c f1 k1 w.(12) ;\n round c d e a b f1 k1 w.(13) ;\n round b c d e a f1 k1 w.(14) ;\n round a b c d e f1 k1 w.(15) ;\n round e a b c d f1 k1 (m 16) ;\n round d e a b c f1 k1 (m 17) ;\n round c d e a b f1 k1 (m 18) ;\n round b c d e a f1 k1 (m 19) ;\n round a b c d e f2 k2 (m 20) ;\n round e a b c d f2 k2 (m 21) ;\n round d e a b c f2 k2 (m 22) ;\n round c d e a b f2 k2 (m 23) ;\n round b c d e a f2 k2 (m 24) ;\n round a b c d e f2 k2 (m 25) ;\n round e a b c d f2 k2 (m 26) ;\n round d e a b c f2 k2 (m 27) ;\n round c d e a b f2 k2 (m 28) ;\n round b c d e a f2 k2 (m 29) ;\n round a b c d e f2 k2 (m 30) ;\n round e a b c d f2 k2 (m 31) ;\n round d e a b c f2 k2 (m 32) ;\n round c d e a b f2 k2 (m 33) ;\n round b c d e a f2 k2 (m 34) ;\n round a b c d e f2 k2 (m 35) ;\n round e a b c d f2 k2 (m 36) ;\n round d e a b c f2 k2 (m 37) ;\n round c d e a b f2 k2 (m 38) ;\n round b c d e a f2 k2 (m 39) ;\n round a b c d e f3 k3 (m 40) ;\n round e a b c d f3 k3 (m 41) ;\n round d e a b c f3 k3 (m 42) ;\n round c d e a b f3 k3 (m 43) ;\n round b c d e a f3 k3 (m 44) ;\n round a b c d e f3 k3 (m 45) ;\n round e a b c d f3 k3 (m 46) ;\n round d e a b c f3 k3 (m 47) ;\n round c d e a b f3 k3 (m 48) ;\n round b c d e a f3 k3 (m 49) ;\n round a b c d e f3 k3 (m 50) ;\n round e a b c d f3 k3 (m 51) ;\n round d e a b c f3 k3 (m 52) ;\n round c d e a b f3 k3 (m 53) ;\n round b c d e a f3 k3 (m 54) ;\n round a b c d e f3 k3 (m 55) ;\n round e a b c d f3 k3 (m 56) ;\n round d e a b c f3 k3 (m 57) ;\n round c d e a b f3 k3 (m 58) ;\n round b c d e a f3 k3 (m 59) ;\n round a b c d e f4 k4 (m 60) ;\n round e a b c d f4 k4 (m 61) ;\n round d e a b c f4 k4 (m 62) ;\n round c d e a b f4 k4 (m 63) ;\n round b c d e a f4 k4 (m 64) ;\n round a b c d e f4 k4 (m 65) ;\n round e a b c d f4 k4 (m 66) ;\n round d e a b c f4 k4 (m 67) ;\n round c d e a b f4 k4 (m 68) ;\n round b c d e a f4 k4 (m 69) ;\n round a b c d e f4 k4 (m 70) ;\n round e a b c d f4 k4 (m 71) ;\n round d e a b c f4 k4 (m 72) ;\n round c d e a b f4 k4 (m 73) ;\n round b c d e a f4 k4 (m 74) ;\n round a b c d e f4 k4 (m 75) ;\n round e a b c d f4 k4 (m 76) ;\n round d e a b c f4 k4 (m 77) ;\n round c d e a b f4 k4 (m 78) ;\n round b c d e a f4 k4 (m 79) ;\n ctx.h.(0) <- Int32.add ctx.h.(0) !a ;\n ctx.h.(1) <- Int32.add ctx.h.(1) !b ;\n ctx.h.(2) <- Int32.add ctx.h.(2) !c ;\n ctx.h.(3) <- Int32.add ctx.h.(3) !d ;\n ctx.h.(4) <- Int32.add ctx.h.(4) !e ;\n ()\n\n let feed :\n type a.\n blit:(a -> int -> By.t -> int -> int -> unit) ->\n be32_to_cpu:(a -> int -> int32) ->\n ctx ->\n a ->\n int ->\n int ->\n unit =\n fun ~blit ~be32_to_cpu ctx buf off len ->\n let idx = ref Int64.(to_int (ctx.size land 0x3FL)) in\n let len = ref len in\n let off = ref off in\n let to_fill = 64 - !idx in\n ctx.size <- Int64.add ctx.size (Int64.of_int !len) ;\n if !idx <> 0 && !len >= to_fill\n then (\n blit buf !off ctx.b !idx to_fill ;\n sha1_do_chunk ~be32_to_cpu:By.be32_to_cpu ctx ctx.b 0 ;\n len := !len - to_fill ;\n off := !off + to_fill ;\n idx := 0) ;\n while !len >= 64 do\n sha1_do_chunk ~be32_to_cpu ctx buf !off ;\n len := !len - 64 ;\n off := !off + 64\n done ;\n if !len <> 0 then blit buf !off ctx.b !idx !len ;\n ()\n\n let unsafe_feed_bytes = feed ~blit:By.blit ~be32_to_cpu:By.be32_to_cpu\n\n let unsafe_feed_bigstring =\n feed ~blit:By.blit_from_bigstring ~be32_to_cpu:Bi.be32_to_cpu\n\n let unsafe_get ctx =\n let index = Int64.(to_int (ctx.size land 0x3FL)) in\n let padlen = if index < 56 then 56 - index else 64 + 56 - index in\n let padding = By.init padlen (function 0 -> '\\x80' | _ -> '\\x00') in\n let bits = By.create 8 in\n By.cpu_to_be64 bits 0 Int64.(ctx.size lsl 3) ;\n unsafe_feed_bytes ctx padding 0 padlen ;\n unsafe_feed_bytes ctx bits 0 8 ;\n let res = By.create (5 * 4) in\n for i = 0 to 4 do\n By.cpu_to_be32 res (i * 4) ctx.h.(i)\n done ;\n res\nend\n","module By = Digestif_by\nmodule Bi = Digestif_bi\n\nmodule Int32 = struct\n include Int32\n\n let ( lsl ) = Int32.shift_left\n\n let ( lsr ) = Int32.shift_right_logical\n\n let ( asr ) = Int32.shift_right\n\n let ( lor ) = Int32.logor\n\n let ( lxor ) = Int32.logxor\n\n let ( land ) = Int32.logand\n\n let ( + ) = Int32.add\n\n let rol32 a n = (a lsl n) lor (a lsr (32 - n))\n\n let ror32 a n = (a lsr n) lor (a lsl (32 - n))\nend\n\nmodule Int64 = struct\n include Int64\n\n let ( land ) = Int64.logand\n\n let ( lsl ) = Int64.shift_left\nend\n\nmodule type S = sig\n type kind = [ `SHA256 ]\n\n type ctx = { mutable size : int64; b : Bytes.t; h : int32 array }\n\n val init : unit -> ctx\n\n val unsafe_feed_bytes : ctx -> By.t -> int -> int -> unit\n\n val unsafe_feed_bigstring : ctx -> Bi.t -> int -> int -> unit\n\n val unsafe_get : ctx -> By.t\n\n val dup : ctx -> ctx\nend\n\nmodule Unsafe : S = struct\n type kind = [ `SHA256 ]\n\n type ctx = { mutable size : int64; b : Bytes.t; h : int32 array }\n\n let dup ctx = { size = ctx.size; b = By.copy ctx.b; h = Array.copy ctx.h }\n\n let init () =\n let b = By.make 128 '\\x00' in\n {\n size = 0L;\n b;\n h =\n [|\n 0x6a09e667l;\n 0xbb67ae85l;\n 0x3c6ef372l;\n 0xa54ff53al;\n 0x510e527fl;\n 0x9b05688cl;\n 0x1f83d9abl;\n 0x5be0cd19l;\n |];\n }\n\n let k =\n [|\n 0x428a2f98l;\n 0x71374491l;\n 0xb5c0fbcfl;\n 0xe9b5dba5l;\n 0x3956c25bl;\n 0x59f111f1l;\n 0x923f82a4l;\n 0xab1c5ed5l;\n 0xd807aa98l;\n 0x12835b01l;\n 0x243185bel;\n 0x550c7dc3l;\n 0x72be5d74l;\n 0x80deb1fel;\n 0x9bdc06a7l;\n 0xc19bf174l;\n 0xe49b69c1l;\n 0xefbe4786l;\n 0x0fc19dc6l;\n 0x240ca1ccl;\n 0x2de92c6fl;\n 0x4a7484aal;\n 0x5cb0a9dcl;\n 0x76f988dal;\n 0x983e5152l;\n 0xa831c66dl;\n 0xb00327c8l;\n 0xbf597fc7l;\n 0xc6e00bf3l;\n 0xd5a79147l;\n 0x06ca6351l;\n 0x14292967l;\n 0x27b70a85l;\n 0x2e1b2138l;\n 0x4d2c6dfcl;\n 0x53380d13l;\n 0x650a7354l;\n 0x766a0abbl;\n 0x81c2c92el;\n 0x92722c85l;\n 0xa2bfe8a1l;\n 0xa81a664bl;\n 0xc24b8b70l;\n 0xc76c51a3l;\n 0xd192e819l;\n 0xd6990624l;\n 0xf40e3585l;\n 0x106aa070l;\n 0x19a4c116l;\n 0x1e376c08l;\n 0x2748774cl;\n 0x34b0bcb5l;\n 0x391c0cb3l;\n 0x4ed8aa4al;\n 0x5b9cca4fl;\n 0x682e6ff3l;\n 0x748f82eel;\n 0x78a5636fl;\n 0x84c87814l;\n 0x8cc70208l;\n 0x90befffal;\n 0xa4506cebl;\n 0xbef9a3f7l;\n 0xc67178f2l;\n |]\n\n let e0 x = Int32.(ror32 x 2 lxor ror32 x 13 lxor ror32 x 22)\n\n let e1 x = Int32.(ror32 x 6 lxor ror32 x 11 lxor ror32 x 25)\n\n let s0 x = Int32.(ror32 x 7 lxor ror32 x 18 lxor (x lsr 3))\n\n let s1 x = Int32.(ror32 x 17 lxor ror32 x 19 lxor (x lsr 10))\n\n let sha256_do_chunk :\n type a. be32_to_cpu:(a -> int -> int32) -> ctx -> a -> int -> unit =\n fun ~be32_to_cpu ctx buf off ->\n let a, b, c, d, e, f, g, h, t1, t2 =\n ( ref ctx.h.(0),\n ref ctx.h.(1),\n ref ctx.h.(2),\n ref ctx.h.(3),\n ref ctx.h.(4),\n ref ctx.h.(5),\n ref ctx.h.(6),\n ref ctx.h.(7),\n ref 0l,\n ref 0l ) in\n let w = Array.make 64 0l in\n for i = 0 to 15 do\n w.(i) <- be32_to_cpu buf (off + (i * 4))\n done ;\n let ( -- ) a b = a - b in\n for i = 16 to 63 do\n w.(i) <- Int32.(s1 w.(i -- 2) + w.(i -- 7) + s0 w.(i -- 15) + w.(i -- 16))\n done ;\n let round a b c d e f g h k w =\n let open Int32 in\n t1 := !h + e1 !e + (!g lxor (!e land (!f lxor !g))) + k + w ;\n t2 := e0 !a + (!a land !b lor (!c land (!a lor !b))) ;\n d := !d + !t1 ;\n h := !t1 + !t2 in\n for i = 0 to 7 do\n round a b c d e f g h k.((i * 8) + 0) w.((i * 8) + 0) ;\n round h a b c d e f g k.((i * 8) + 1) w.((i * 8) + 1) ;\n round g h a b c d e f k.((i * 8) + 2) w.((i * 8) + 2) ;\n round f g h a b c d e k.((i * 8) + 3) w.((i * 8) + 3) ;\n round e f g h a b c d k.((i * 8) + 4) w.((i * 8) + 4) ;\n round d e f g h a b c k.((i * 8) + 5) w.((i * 8) + 5) ;\n round c d e f g h a b k.((i * 8) + 6) w.((i * 8) + 6) ;\n round b c d e f g h a k.((i * 8) + 7) w.((i * 8) + 7)\n done ;\n let open Int32 in\n ctx.h.(0) <- ctx.h.(0) + !a ;\n ctx.h.(1) <- ctx.h.(1) + !b ;\n ctx.h.(2) <- ctx.h.(2) + !c ;\n ctx.h.(3) <- ctx.h.(3) + !d ;\n ctx.h.(4) <- ctx.h.(4) + !e ;\n ctx.h.(5) <- ctx.h.(5) + !f ;\n ctx.h.(6) <- ctx.h.(6) + !g ;\n ctx.h.(7) <- ctx.h.(7) + !h ;\n ()\n\n let feed :\n type a.\n blit:(a -> int -> By.t -> int -> int -> unit) ->\n be32_to_cpu:(a -> int -> int32) ->\n ctx ->\n a ->\n int ->\n int ->\n unit =\n fun ~blit ~be32_to_cpu ctx buf off len ->\n let idx = ref Int64.(to_int (ctx.size land 0x3FL)) in\n let len = ref len in\n let off = ref off in\n let to_fill = 64 - !idx in\n ctx.size <- Int64.add ctx.size (Int64.of_int !len) ;\n if !idx <> 0 && !len >= to_fill\n then (\n blit buf !off ctx.b !idx to_fill ;\n sha256_do_chunk ~be32_to_cpu:By.be32_to_cpu ctx ctx.b 0 ;\n len := !len - to_fill ;\n off := !off + to_fill ;\n idx := 0) ;\n while !len >= 64 do\n sha256_do_chunk ~be32_to_cpu ctx buf !off ;\n len := !len - 64 ;\n off := !off + 64\n done ;\n if !len <> 0 then blit buf !off ctx.b !idx !len ;\n ()\n\n let unsafe_feed_bytes = feed ~blit:By.blit ~be32_to_cpu:By.be32_to_cpu\n\n let unsafe_feed_bigstring =\n feed ~blit:By.blit_from_bigstring ~be32_to_cpu:Bi.be32_to_cpu\n\n let unsafe_get ctx =\n let index = Int64.(to_int (ctx.size land 0x3FL)) in\n let padlen = if index < 56 then 56 - index else 64 + 56 - index in\n let padding = By.init padlen (function 0 -> '\\x80' | _ -> '\\x00') in\n let bits = By.create 8 in\n By.cpu_to_be64 bits 0 Int64.(ctx.size lsl 3) ;\n unsafe_feed_bytes ctx padding 0 padlen ;\n unsafe_feed_bytes ctx bits 0 8 ;\n let res = By.create (8 * 4) in\n for i = 0 to 7 do\n By.cpu_to_be32 res (i * 4) ctx.h.(i)\n done ;\n res\nend\n","module By = Digestif_by\nmodule Bi = Digestif_bi\n\nmodule type S = sig\n type ctx\n\n type kind = [ `SHA224 ]\n\n val init : unit -> ctx\n\n val unsafe_feed_bytes : ctx -> By.t -> int -> int -> unit\n\n val unsafe_feed_bigstring : ctx -> Bi.t -> int -> int -> unit\n\n val unsafe_get : ctx -> By.t\n\n val dup : ctx -> ctx\nend\n\nmodule Unsafe : S = struct\n type kind = [ `SHA224 ]\n\n open Baijiu_sha256.Unsafe\n\n type nonrec ctx = ctx\n\n let init () =\n let b = By.make 128 '\\x00' in\n {\n size = 0L;\n b;\n h =\n [|\n 0xc1059ed8l;\n 0x367cd507l;\n 0x3070dd17l;\n 0xf70e5939l;\n 0xffc00b31l;\n 0x68581511l;\n 0x64f98fa7l;\n 0xbefa4fa4l;\n |];\n }\n\n let unsafe_get ctx =\n let res = unsafe_get ctx in\n By.sub res 0 28\n\n let dup = dup\n\n let unsafe_feed_bytes = unsafe_feed_bytes\n\n let unsafe_feed_bigstring = unsafe_feed_bigstring\nend\n","module By = Digestif_by\nmodule Bi = Digestif_bi\n\nmodule Int64 = struct\n include Int64\n\n let ( lsl ) = Int64.shift_left\n\n let ( lsr ) = Int64.shift_right_logical\n\n let ( asr ) = Int64.shift_right\n\n let ( lor ) = Int64.logor\n\n let ( land ) = Int64.logand\n\n let ( lxor ) = Int64.logxor\n\n let ( + ) = Int64.add\n\n let ror64 a n = (a lsr n) lor (a lsl (64 - n))\n\n let rol64 a n = (a lsl n) lor (a lsr (64 - n))\nend\n\nmodule Unsafe = struct\n type ctx = {\n q : int64 array;\n rsize : int;\n (* block size *)\n mdlen : int;\n (* output size *)\n mutable pt : int;\n }\n\n let dup ctx =\n { q = Array.copy ctx.q; rsize = ctx.rsize; mdlen = ctx.mdlen; pt = ctx.pt }\n\n let init mdlen =\n let rsize = 200 - (2 * mdlen) in\n { q = Array.make 25 0L; rsize; mdlen; pt = 0 }\n\n let keccakf_rounds = 24\n\n let keccaft_rndc : int64 array =\n [|\n 0x0000000000000001L;\n 0x0000000000008082L;\n 0x800000000000808aL;\n 0x8000000080008000L;\n 0x000000000000808bL;\n 0x0000000080000001L;\n 0x8000000080008081L;\n 0x8000000000008009L;\n 0x000000000000008aL;\n 0x0000000000000088L;\n 0x0000000080008009L;\n 0x000000008000000aL;\n 0x000000008000808bL;\n 0x800000000000008bL;\n 0x8000000000008089L;\n 0x8000000000008003L;\n 0x8000000000008002L;\n 0x8000000000000080L;\n 0x000000000000800aL;\n 0x800000008000000aL;\n 0x8000000080008081L;\n 0x8000000000008080L;\n 0x0000000080000001L;\n 0x8000000080008008L;\n |]\n\n let keccaft_rotc : int array =\n [|\n 1;\n 3;\n 6;\n 10;\n 15;\n 21;\n 28;\n 36;\n 45;\n 55;\n 2;\n 14;\n 27;\n 41;\n 56;\n 8;\n 25;\n 43;\n 62;\n 18;\n 39;\n 61;\n 20;\n 44;\n |]\n\n let keccakf_piln : int array =\n [|\n 10;\n 7;\n 11;\n 17;\n 18;\n 3;\n 5;\n 16;\n 8;\n 21;\n 24;\n 4;\n 15;\n 23;\n 19;\n 13;\n 12;\n 2;\n 20;\n 14;\n 22;\n 9;\n 6;\n 1;\n |]\n\n let swap64 = if Sys.big_endian then By.swap64 else fun x -> x\n\n let sha3_keccakf (q : int64 array) =\n if Sys.big_endian then Array.iteri (fun i sti -> q.(i) <- swap64 sti) q ;\n\n for r = 0 to keccakf_rounds - 1 do\n let ( lxor ) = Int64.( lxor ) in\n let lnot = Int64.lognot in\n let ( land ) = Int64.( land ) in\n (* Theta *)\n let bc =\n Array.init 5 (fun i ->\n q.(i) lxor q.(i + 5) lxor q.(i + 10) lxor q.(i + 15) lxor q.(i + 20))\n in\n for i = 0 to 4 do\n let t = bc.((i + 4) mod 5) lxor Int64.rol64 bc.((i + 1) mod 5) 1 in\n for k = 0 to 4 do\n let j = k * 5 in\n q.(j + i) <- q.(j + i) lxor t\n done\n done ;\n\n (* Rho Pi *)\n let t = ref q.(1) in\n let _ =\n Array.iteri\n (fun i rotc ->\n let j = keccakf_piln.(i) in\n bc.(0) <- q.(j) ;\n q.(j) <- Int64.rol64 !t rotc ;\n t := bc.(0))\n keccaft_rotc in\n\n (* Chi *)\n for k = 0 to 4 do\n let j = k * 5 in\n let bc = Array.init 5 (fun i -> q.(j + i)) in\n for i = 0 to 4 do\n q.(j + i) <-\n q.(j + i) lxor (lnot bc.((i + 1) mod 5) land bc.((i + 2) mod 5))\n done\n done ;\n\n (* Iota *)\n q.(0) <- q.(0) lxor keccaft_rndc.(r)\n done ;\n\n if Sys.big_endian then Array.iteri (fun i sti -> q.(i) <- swap64 sti) q\n\n let masks =\n [|\n 0xffffffffffffff00L;\n 0xffffffffffff00ffL;\n 0xffffffffff00ffffL;\n 0xffffffff00ffffffL;\n 0xffffff00ffffffffL;\n 0xffff00ffffffffffL;\n 0xff00ffffffffffffL;\n 0x00ffffffffffffffL;\n |]\n\n let feed :\n type a. get_uint8:(a -> int -> int) -> ctx -> a -> int -> int -> unit =\n fun ~get_uint8 ctx buf off len ->\n let ( && ) = ( land ) in\n\n let ( lxor ) = Int64.( lxor ) in\n let ( land ) = Int64.( land ) in\n let ( lor ) = Int64.( lor ) in\n let ( lsr ) = Int64.( lsr ) in\n let ( lsl ) = Int64.( lsl ) in\n\n let j = ref ctx.pt in\n\n for i = 0 to len - 1 do\n let v =\n (ctx.q.(!j / 8) land (0xffL lsl ((!j && 0x7) * 8))) lsr ((!j && 0x7) * 8)\n in\n let v = v lxor Int64.of_int (get_uint8 buf (off + i)) in\n ctx.q.(!j / 8) <-\n ctx.q.(!j / 8) land masks.(!j && 0x7) lor (v lsl ((!j && 0x7) * 8)) ;\n incr j ;\n if !j >= ctx.rsize\n then (\n sha3_keccakf ctx.q ;\n j := 0)\n done ;\n\n ctx.pt <- !j\n\n let unsafe_feed_bytes ctx buf off len =\n let get_uint8 buf off = Char.code (By.get buf off) in\n feed ~get_uint8 ctx buf off len\n\n let unsafe_feed_bigstring : ctx -> Bi.t -> int -> int -> unit =\n fun ctx buf off len ->\n let get_uint8 buf off = Char.code (Bi.get buf off) in\n feed ~get_uint8 ctx buf off len\n\n let unsafe_get ctx =\n let ( && ) = ( land ) in\n\n let ( lxor ) = Int64.( lxor ) in\n let ( lsl ) = Int64.( lsl ) in\n\n let v = ctx.q.(ctx.pt / 8) in\n let v = v lxor (0x6L lsl ((ctx.pt && 0x7) * 8)) in\n ctx.q.(ctx.pt / 8) <- v ;\n\n let v = ctx.q.((ctx.rsize - 1) / 8) in\n let v = v lxor (0x80L lsl (((ctx.rsize - 1) && 0x7) * 8)) in\n ctx.q.((ctx.rsize - 1) / 8) <- v ;\n\n sha3_keccakf ctx.q ;\n\n (* Get hash *)\n (* if the hash size in bytes is not a multiple of 8 (meaning it is\n not composed of whole int64 words, like for sha3_224), we\n extract the whole last int64 word from the state [ctx.st] and\n cut the hash at the right size after conversion to bytes. *)\n let n =\n let r = ctx.mdlen mod 8 in\n ctx.mdlen + if r = 0 then 0 else 8 - r in\n\n let hash = By.create n in\n for i = 0 to (n / 8) - 1 do\n By.unsafe_set_64 hash (i * 8) ctx.q.(i)\n done ;\n\n By.sub hash 0 ctx.mdlen\nend\n","module By = Digestif_by\nmodule Bi = Digestif_bi\n\nmodule type S = sig\n type ctx\n\n type kind = [ `SHA3_512 ]\n\n val init : unit -> ctx\n\n val unsafe_feed_bytes : ctx -> By.t -> int -> int -> unit\n\n val unsafe_feed_bigstring : ctx -> Bi.t -> int -> int -> unit\n\n val unsafe_get : ctx -> By.t\n\n val dup : ctx -> ctx\nend\n\nmodule Unsafe : S = struct\n type kind = [ `SHA3_512 ]\n\n open Baijiu_sha3.Unsafe\n\n type nonrec ctx = ctx\n\n let init () = Baijiu_sha3.Unsafe.init 64\n\n let unsafe_get = unsafe_get\n\n let dup = dup\n\n let unsafe_feed_bytes = unsafe_feed_bytes\n\n let unsafe_feed_bigstring = unsafe_feed_bigstring\nend\n","module By = Digestif_by\nmodule Bi = Digestif_bi\n\nmodule Int64 = struct\n include Int64\n\n let ( lsl ) = Int64.shift_left\n\n let ( lsr ) = Int64.shift_right_logical\n\n let ( asr ) = Int64.shift_right\n\n let ( lor ) = Int64.logor\n\n let ( land ) = Int64.logand\n\n let ( lxor ) = Int64.logxor\n\n let ( + ) = Int64.add\n\n let ror64 a n = (a lsr n) lor (a lsl (64 - n))\n\n let rol64 a n = (a lsl n) lor (a lsr (64 - n))\nend\n\nmodule type S = sig\n type kind = [ `SHA512 ]\n\n type ctx = { mutable size : int64 array; b : Bytes.t; h : int64 array }\n\n val init : unit -> ctx\n\n val unsafe_feed_bytes : ctx -> By.t -> int -> int -> unit\n\n val unsafe_feed_bigstring : ctx -> Bi.t -> int -> int -> unit\n\n val unsafe_get : ctx -> By.t\n\n val dup : ctx -> ctx\nend\n\nmodule Unsafe : S = struct\n type kind = [ `SHA512 ]\n\n type ctx = { mutable size : int64 array; b : Bytes.t; h : int64 array }\n\n let dup ctx =\n { size = Array.copy ctx.size; b = By.copy ctx.b; h = Array.copy ctx.h }\n\n let init () =\n let b = By.make 128 '\\x00' in\n {\n size = [| 0L; 0L |];\n b;\n h =\n [|\n 0x6a09e667f3bcc908L;\n 0xbb67ae8584caa73bL;\n 0x3c6ef372fe94f82bL;\n 0xa54ff53a5f1d36f1L;\n 0x510e527fade682d1L;\n 0x9b05688c2b3e6c1fL;\n 0x1f83d9abfb41bd6bL;\n 0x5be0cd19137e2179L;\n |];\n }\n\n let k =\n [|\n 0x428a2f98d728ae22L;\n 0x7137449123ef65cdL;\n 0xb5c0fbcfec4d3b2fL;\n 0xe9b5dba58189dbbcL;\n 0x3956c25bf348b538L;\n 0x59f111f1b605d019L;\n 0x923f82a4af194f9bL;\n 0xab1c5ed5da6d8118L;\n 0xd807aa98a3030242L;\n 0x12835b0145706fbeL;\n 0x243185be4ee4b28cL;\n 0x550c7dc3d5ffb4e2L;\n 0x72be5d74f27b896fL;\n 0x80deb1fe3b1696b1L;\n 0x9bdc06a725c71235L;\n 0xc19bf174cf692694L;\n 0xe49b69c19ef14ad2L;\n 0xefbe4786384f25e3L;\n 0x0fc19dc68b8cd5b5L;\n 0x240ca1cc77ac9c65L;\n 0x2de92c6f592b0275L;\n 0x4a7484aa6ea6e483L;\n 0x5cb0a9dcbd41fbd4L;\n 0x76f988da831153b5L;\n 0x983e5152ee66dfabL;\n 0xa831c66d2db43210L;\n 0xb00327c898fb213fL;\n 0xbf597fc7beef0ee4L;\n 0xc6e00bf33da88fc2L;\n 0xd5a79147930aa725L;\n 0x06ca6351e003826fL;\n 0x142929670a0e6e70L;\n 0x27b70a8546d22ffcL;\n 0x2e1b21385c26c926L;\n 0x4d2c6dfc5ac42aedL;\n 0x53380d139d95b3dfL;\n 0x650a73548baf63deL;\n 0x766a0abb3c77b2a8L;\n 0x81c2c92e47edaee6L;\n 0x92722c851482353bL;\n 0xa2bfe8a14cf10364L;\n 0xa81a664bbc423001L;\n 0xc24b8b70d0f89791L;\n 0xc76c51a30654be30L;\n 0xd192e819d6ef5218L;\n 0xd69906245565a910L;\n 0xf40e35855771202aL;\n 0x106aa07032bbd1b8L;\n 0x19a4c116b8d2d0c8L;\n 0x1e376c085141ab53L;\n 0x2748774cdf8eeb99L;\n 0x34b0bcb5e19b48a8L;\n 0x391c0cb3c5c95a63L;\n 0x4ed8aa4ae3418acbL;\n 0x5b9cca4f7763e373L;\n 0x682e6ff3d6b2b8a3L;\n 0x748f82ee5defb2fcL;\n 0x78a5636f43172f60L;\n 0x84c87814a1f0ab72L;\n 0x8cc702081a6439ecL;\n 0x90befffa23631e28L;\n 0xa4506cebde82bde9L;\n 0xbef9a3f7b2c67915L;\n 0xc67178f2e372532bL;\n 0xca273eceea26619cL;\n 0xd186b8c721c0c207L;\n 0xeada7dd6cde0eb1eL;\n 0xf57d4f7fee6ed178L;\n 0x06f067aa72176fbaL;\n 0x0a637dc5a2c898a6L;\n 0x113f9804bef90daeL;\n 0x1b710b35131c471bL;\n 0x28db77f523047d84L;\n 0x32caab7b40c72493L;\n 0x3c9ebe0a15c9bebcL;\n 0x431d67c49c100d4cL;\n 0x4cc5d4becb3e42b6L;\n 0x597f299cfc657e2aL;\n 0x5fcb6fab3ad6faecL;\n 0x6c44198c4a475817L;\n |]\n\n let e0 x = Int64.(ror64 x 28 lxor ror64 x 34 lxor ror64 x 39)\n\n let e1 x = Int64.(ror64 x 14 lxor ror64 x 18 lxor ror64 x 41)\n\n let s0 x = Int64.(ror64 x 1 lxor ror64 x 8 lxor (x lsr 7))\n\n let s1 x = Int64.(ror64 x 19 lxor ror64 x 61 lxor (x lsr 6))\n\n let sha512_do_chunk :\n type a. be64_to_cpu:(a -> int -> int64) -> ctx -> a -> int -> unit =\n fun ~be64_to_cpu ctx buf off ->\n let a, b, c, d, e, f, g, h, t1, t2 =\n ( ref ctx.h.(0),\n ref ctx.h.(1),\n ref ctx.h.(2),\n ref ctx.h.(3),\n ref ctx.h.(4),\n ref ctx.h.(5),\n ref ctx.h.(6),\n ref ctx.h.(7),\n ref 0L,\n ref 0L ) in\n let w = Array.make 80 0L in\n for i = 0 to 15 do\n w.(i) <- be64_to_cpu buf (off + (i * 8))\n done ;\n let ( -- ) a b = a - b in\n for i = 16 to 79 do\n w.(i) <- Int64.(s1 w.(i -- 2) + w.(i -- 7) + s0 w.(i -- 15) + w.(i -- 16))\n done ;\n let round a b c d e f g h k w =\n let open Int64 in\n t1 := !h + e1 !e + (!g lxor (!e land (!f lxor !g))) + k + w ;\n t2 := e0 !a + (!a land !b lor (!c land (!a lor !b))) ;\n d := !d + !t1 ;\n h := !t1 + !t2 in\n for i = 0 to 9 do\n round a b c d e f g h k.((i * 8) + 0) w.((i * 8) + 0) ;\n round h a b c d e f g k.((i * 8) + 1) w.((i * 8) + 1) ;\n round g h a b c d e f k.((i * 8) + 2) w.((i * 8) + 2) ;\n round f g h a b c d e k.((i * 8) + 3) w.((i * 8) + 3) ;\n round e f g h a b c d k.((i * 8) + 4) w.((i * 8) + 4) ;\n round d e f g h a b c k.((i * 8) + 5) w.((i * 8) + 5) ;\n round c d e f g h a b k.((i * 8) + 6) w.((i * 8) + 6) ;\n round b c d e f g h a k.((i * 8) + 7) w.((i * 8) + 7)\n done ;\n let open Int64 in\n ctx.h.(0) <- ctx.h.(0) + !a ;\n ctx.h.(1) <- ctx.h.(1) + !b ;\n ctx.h.(2) <- ctx.h.(2) + !c ;\n ctx.h.(3) <- ctx.h.(3) + !d ;\n ctx.h.(4) <- ctx.h.(4) + !e ;\n ctx.h.(5) <- ctx.h.(5) + !f ;\n ctx.h.(6) <- ctx.h.(6) + !g ;\n ctx.h.(7) <- ctx.h.(7) + !h ;\n ()\n\n let feed :\n type a.\n blit:(a -> int -> By.t -> int -> int -> unit) ->\n be64_to_cpu:(a -> int -> int64) ->\n ctx ->\n a ->\n int ->\n int ->\n unit =\n fun ~blit ~be64_to_cpu ctx buf off len ->\n let idx = ref Int64.(to_int (ctx.size.(0) land 0x7FL)) in\n let len = ref len in\n let off = ref off in\n let to_fill = 128 - !idx in\n ctx.size.(0) <- Int64.add ctx.size.(0) (Int64.of_int !len) ;\n if ctx.size.(0) < Int64.of_int !len\n then ctx.size.(1) <- Int64.succ ctx.size.(1) ;\n if !idx <> 0 && !len >= to_fill\n then (\n blit buf !off ctx.b !idx to_fill ;\n sha512_do_chunk ~be64_to_cpu:By.be64_to_cpu ctx ctx.b 0 ;\n len := !len - to_fill ;\n off := !off + to_fill ;\n idx := 0) ;\n while !len >= 128 do\n sha512_do_chunk ~be64_to_cpu ctx buf !off ;\n len := !len - 128 ;\n off := !off + 128\n done ;\n if !len <> 0 then blit buf !off ctx.b !idx !len ;\n ()\n\n let unsafe_feed_bytes = feed ~blit:By.blit ~be64_to_cpu:By.be64_to_cpu\n\n let unsafe_feed_bigstring =\n feed ~blit:By.blit_from_bigstring ~be64_to_cpu:Bi.be64_to_cpu\n\n let unsafe_get ctx =\n let index = Int64.(to_int (ctx.size.(0) land 0x7FL)) in\n let padlen = if index < 112 then 112 - index else 128 + 112 - index in\n let padding = By.init padlen (function 0 -> '\\x80' | _ -> '\\x00') in\n let bits = By.create 16 in\n By.cpu_to_be64 bits 0 Int64.((ctx.size.(1) lsl 3) lor (ctx.size.(0) lsr 61)) ;\n By.cpu_to_be64 bits 8 Int64.(ctx.size.(0) lsl 3) ;\n unsafe_feed_bytes ctx padding 0 padlen ;\n unsafe_feed_bytes ctx bits 0 16 ;\n let res = By.create (8 * 8) in\n for i = 0 to 7 do\n By.cpu_to_be64 res (i * 8) ctx.h.(i)\n done ;\n res\nend\n","module By = Digestif_by\nmodule Bi = Digestif_bi\n\nmodule type S = sig\n type ctx\n\n type kind = [ `SHA384 ]\n\n val init : unit -> ctx\n\n val unsafe_feed_bytes : ctx -> By.t -> int -> int -> unit\n\n val unsafe_feed_bigstring : ctx -> Bi.t -> int -> int -> unit\n\n val unsafe_get : ctx -> By.t\n\n val dup : ctx -> ctx\nend\n\nmodule Unsafe : S = struct\n type kind = [ `SHA384 ]\n\n open Baijiu_sha512.Unsafe\n\n type nonrec ctx = ctx\n\n let init () =\n let b = By.make 128 '\\x00' in\n {\n size = [| 0L; 0L |];\n b;\n h =\n [|\n 0xcbbb9d5dc1059ed8L;\n 0x629a292a367cd507L;\n 0x9159015a3070dd17L;\n 0x152fecd8f70e5939L;\n 0x67332667ffc00b31L;\n 0x8eb44a8768581511L;\n 0xdb0c2e0d64f98fa7L;\n 0x47b5481dbefa4fa4L;\n |];\n }\n\n let unsafe_get ctx =\n let res = unsafe_get ctx in\n By.sub res 0 48\n\n let dup = dup\n\n let unsafe_feed_bytes = unsafe_feed_bytes\n\n let unsafe_feed_bigstring = unsafe_feed_bigstring\nend\n","module By = Digestif_by\nmodule Bi = Digestif_bi\n\nmodule type S = sig\n type ctx\n\n type kind = [ `SHA3_224 ]\n\n val init : unit -> ctx\n\n val unsafe_feed_bytes : ctx -> By.t -> int -> int -> unit\n\n val unsafe_feed_bigstring : ctx -> Bi.t -> int -> int -> unit\n\n val unsafe_get : ctx -> By.t\n\n val dup : ctx -> ctx\nend\n\nmodule Unsafe : S = struct\n type kind = [ `SHA3_224 ]\n\n open Baijiu_sha3.Unsafe\n\n type nonrec ctx = ctx\n\n let init () = Baijiu_sha3.Unsafe.init 28\n\n let unsafe_get = unsafe_get\n\n let dup = dup\n\n let unsafe_feed_bytes = unsafe_feed_bytes\n\n let unsafe_feed_bigstring = unsafe_feed_bigstring\nend\n","module By = Digestif_by\nmodule Bi = Digestif_bi\n\nmodule type S = sig\n type ctx\n\n type kind = [ `SHA3_256 ]\n\n val init : unit -> ctx\n\n val unsafe_feed_bytes : ctx -> By.t -> int -> int -> unit\n\n val unsafe_feed_bigstring : ctx -> Bi.t -> int -> int -> unit\n\n val unsafe_get : ctx -> By.t\n\n val dup : ctx -> ctx\nend\n\nmodule Unsafe : S = struct\n type kind = [ `SHA3_256 ]\n\n open Baijiu_sha3.Unsafe\n\n type nonrec ctx = ctx\n\n let init () = Baijiu_sha3.Unsafe.init 32\n\n let unsafe_get = unsafe_get\n\n let dup = dup\n\n let unsafe_feed_bytes = unsafe_feed_bytes\n\n let unsafe_feed_bigstring = unsafe_feed_bigstring\nend\n","module By = Digestif_by\nmodule Bi = Digestif_bi\n\nmodule type S = sig\n type ctx\n\n type kind = [ `SHA3_384 ]\n\n val init : unit -> ctx\n\n val unsafe_feed_bytes : ctx -> By.t -> int -> int -> unit\n\n val unsafe_feed_bigstring : ctx -> Bi.t -> int -> int -> unit\n\n val unsafe_get : ctx -> By.t\n\n val dup : ctx -> ctx\nend\n\nmodule Unsafe : S = struct\n type kind = [ `SHA3_384 ]\n\n open Baijiu_sha3.Unsafe\n\n type nonrec ctx = ctx\n\n let init () = Baijiu_sha3.Unsafe.init 48\n\n let unsafe_get = unsafe_get\n\n let dup = dup\n\n let unsafe_feed_bytes = unsafe_feed_bytes\n\n let unsafe_feed_bigstring = unsafe_feed_bigstring\nend\n","module By = Digestif_by\nmodule Bi = Digestif_bi\n\nmodule Int64 = struct\n include Int64\n\n let ( lsl ) = Int64.shift_left\n\n let ( lsr ) = Int64.shift_right_logical\n\n let ( asr ) = Int64.shift_right\n\n let ( lor ) = Int64.logor\n\n let ( land ) = Int64.logand\n\n let ( lxor ) = Int64.logxor\n\n let ( + ) = Int64.add\n\n let ror64 a n = (a lsr n) lor (a lsl (64 - n))\n\n let rol64 a n = (a lsl n) lor (a lsr (64 - n))\nend\n\nmodule type S = sig\n type kind = [ `WHIRLPOOL ]\n\n type ctx = { mutable size : int64; b : Bytes.t; h : int64 array }\n\n val init : unit -> ctx\n\n val unsafe_feed_bytes : ctx -> By.t -> int -> int -> unit\n\n val unsafe_feed_bigstring : ctx -> Bi.t -> int -> int -> unit\n\n val unsafe_get : ctx -> By.t\n\n val dup : ctx -> ctx\nend\n\nmodule Unsafe : S = struct\n type kind = [ `WHIRLPOOL ]\n\n type ctx = { mutable size : int64; b : Bytes.t; h : int64 array }\n\n let dup ctx = { size = ctx.size; b = By.copy ctx.b; h = Array.copy ctx.h }\n\n let init () =\n let b = By.make 64 '\\x00' in\n { size = 0L; b; h = Array.make 8 Int64.zero }\n\n let k =\n [|\n [|\n 0x18186018c07830d8L;\n 0x23238c2305af4626L;\n 0xc6c63fc67ef991b8L;\n 0xe8e887e8136fcdfbL;\n 0x878726874ca113cbL;\n 0xb8b8dab8a9626d11L;\n 0x0101040108050209L;\n 0x4f4f214f426e9e0dL;\n 0x3636d836adee6c9bL;\n 0xa6a6a2a6590451ffL;\n 0xd2d26fd2debdb90cL;\n 0xf5f5f3f5fb06f70eL;\n 0x7979f979ef80f296L;\n 0x6f6fa16f5fcede30L;\n 0x91917e91fcef3f6dL;\n 0x52525552aa07a4f8L;\n 0x60609d6027fdc047L;\n 0xbcbccabc89766535L;\n 0x9b9b569baccd2b37L;\n 0x8e8e028e048c018aL;\n 0xa3a3b6a371155bd2L;\n 0x0c0c300c603c186cL;\n 0x7b7bf17bff8af684L;\n 0x3535d435b5e16a80L;\n 0x1d1d741de8693af5L;\n 0xe0e0a7e05347ddb3L;\n 0xd7d77bd7f6acb321L;\n 0xc2c22fc25eed999cL;\n 0x2e2eb82e6d965c43L;\n 0x4b4b314b627a9629L;\n 0xfefedffea321e15dL;\n 0x575741578216aed5L;\n 0x15155415a8412abdL;\n 0x7777c1779fb6eee8L;\n 0x3737dc37a5eb6e92L;\n 0xe5e5b3e57b56d79eL;\n 0x9f9f469f8cd92313L;\n 0xf0f0e7f0d317fd23L;\n 0x4a4a354a6a7f9420L;\n 0xdada4fda9e95a944L;\n 0x58587d58fa25b0a2L;\n 0xc9c903c906ca8fcfL;\n 0x2929a429558d527cL;\n 0x0a0a280a5022145aL;\n 0xb1b1feb1e14f7f50L;\n 0xa0a0baa0691a5dc9L;\n 0x6b6bb16b7fdad614L;\n 0x85852e855cab17d9L;\n 0xbdbdcebd8173673cL;\n 0x5d5d695dd234ba8fL;\n 0x1010401080502090L;\n 0xf4f4f7f4f303f507L;\n 0xcbcb0bcb16c08bddL;\n 0x3e3ef83eedc67cd3L;\n 0x0505140528110a2dL;\n 0x676781671fe6ce78L;\n 0xe4e4b7e47353d597L;\n 0x27279c2725bb4e02L;\n 0x4141194132588273L;\n 0x8b8b168b2c9d0ba7L;\n 0xa7a7a6a7510153f6L;\n 0x7d7de97dcf94fab2L;\n 0x95956e95dcfb3749L;\n 0xd8d847d88e9fad56L;\n 0xfbfbcbfb8b30eb70L;\n 0xeeee9fee2371c1cdL;\n 0x7c7ced7cc791f8bbL;\n 0x6666856617e3cc71L;\n 0xdddd53dda68ea77bL;\n 0x17175c17b84b2eafL;\n 0x4747014702468e45L;\n 0x9e9e429e84dc211aL;\n 0xcaca0fca1ec589d4L;\n 0x2d2db42d75995a58L;\n 0xbfbfc6bf9179632eL;\n 0x07071c07381b0e3fL;\n 0xadad8ead012347acL;\n 0x5a5a755aea2fb4b0L;\n 0x838336836cb51befL;\n 0x3333cc3385ff66b6L;\n 0x636391633ff2c65cL;\n 0x02020802100a0412L;\n 0xaaaa92aa39384993L;\n 0x7171d971afa8e2deL;\n 0xc8c807c80ecf8dc6L;\n 0x19196419c87d32d1L;\n 0x494939497270923bL;\n 0xd9d943d9869aaf5fL;\n 0xf2f2eff2c31df931L;\n 0xe3e3abe34b48dba8L;\n 0x5b5b715be22ab6b9L;\n 0x88881a8834920dbcL;\n 0x9a9a529aa4c8293eL;\n 0x262698262dbe4c0bL;\n 0x3232c8328dfa64bfL;\n 0xb0b0fab0e94a7d59L;\n 0xe9e983e91b6acff2L;\n 0x0f0f3c0f78331e77L;\n 0xd5d573d5e6a6b733L;\n 0x80803a8074ba1df4L;\n 0xbebec2be997c6127L;\n 0xcdcd13cd26de87ebL;\n 0x3434d034bde46889L;\n 0x48483d487a759032L;\n 0xffffdbffab24e354L;\n 0x7a7af57af78ff48dL;\n 0x90907a90f4ea3d64L;\n 0x5f5f615fc23ebe9dL;\n 0x202080201da0403dL;\n 0x6868bd6867d5d00fL;\n 0x1a1a681ad07234caL;\n 0xaeae82ae192c41b7L;\n 0xb4b4eab4c95e757dL;\n 0x54544d549a19a8ceL;\n 0x93937693ece53b7fL;\n 0x222288220daa442fL;\n 0x64648d6407e9c863L;\n 0xf1f1e3f1db12ff2aL;\n 0x7373d173bfa2e6ccL;\n 0x12124812905a2482L;\n 0x40401d403a5d807aL;\n 0x0808200840281048L;\n 0xc3c32bc356e89b95L;\n 0xecec97ec337bc5dfL;\n 0xdbdb4bdb9690ab4dL;\n 0xa1a1bea1611f5fc0L;\n 0x8d8d0e8d1c830791L;\n 0x3d3df43df5c97ac8L;\n 0x97976697ccf1335bL;\n 0x0000000000000000L;\n 0xcfcf1bcf36d483f9L;\n 0x2b2bac2b4587566eL;\n 0x7676c57697b3ece1L;\n 0x8282328264b019e6L;\n 0xd6d67fd6fea9b128L;\n 0x1b1b6c1bd87736c3L;\n 0xb5b5eeb5c15b7774L;\n 0xafaf86af112943beL;\n 0x6a6ab56a77dfd41dL;\n 0x50505d50ba0da0eaL;\n 0x45450945124c8a57L;\n 0xf3f3ebf3cb18fb38L;\n 0x3030c0309df060adL;\n 0xefef9bef2b74c3c4L;\n 0x3f3ffc3fe5c37edaL;\n 0x55554955921caac7L;\n 0xa2a2b2a2791059dbL;\n 0xeaea8fea0365c9e9L;\n 0x656589650fecca6aL;\n 0xbabad2bab9686903L;\n 0x2f2fbc2f65935e4aL;\n 0xc0c027c04ee79d8eL;\n 0xdede5fdebe81a160L;\n 0x1c1c701ce06c38fcL;\n 0xfdfdd3fdbb2ee746L;\n 0x4d4d294d52649a1fL;\n 0x92927292e4e03976L;\n 0x7575c9758fbceafaL;\n 0x06061806301e0c36L;\n 0x8a8a128a249809aeL;\n 0xb2b2f2b2f940794bL;\n 0xe6e6bfe66359d185L;\n 0x0e0e380e70361c7eL;\n 0x1f1f7c1ff8633ee7L;\n 0x6262956237f7c455L;\n 0xd4d477d4eea3b53aL;\n 0xa8a89aa829324d81L;\n 0x96966296c4f43152L;\n 0xf9f9c3f99b3aef62L;\n 0xc5c533c566f697a3L;\n 0x2525942535b14a10L;\n 0x59597959f220b2abL;\n 0x84842a8454ae15d0L;\n 0x7272d572b7a7e4c5L;\n 0x3939e439d5dd72ecL;\n 0x4c4c2d4c5a619816L;\n 0x5e5e655eca3bbc94L;\n 0x7878fd78e785f09fL;\n 0x3838e038ddd870e5L;\n 0x8c8c0a8c14860598L;\n 0xd1d163d1c6b2bf17L;\n 0xa5a5aea5410b57e4L;\n 0xe2e2afe2434dd9a1L;\n 0x616199612ff8c24eL;\n 0xb3b3f6b3f1457b42L;\n 0x2121842115a54234L;\n 0x9c9c4a9c94d62508L;\n 0x1e1e781ef0663ceeL;\n 0x4343114322528661L;\n 0xc7c73bc776fc93b1L;\n 0xfcfcd7fcb32be54fL;\n 0x0404100420140824L;\n 0x51515951b208a2e3L;\n 0x99995e99bcc72f25L;\n 0x6d6da96d4fc4da22L;\n 0x0d0d340d68391a65L;\n 0xfafacffa8335e979L;\n 0xdfdf5bdfb684a369L;\n 0x7e7ee57ed79bfca9L;\n 0x242490243db44819L;\n 0x3b3bec3bc5d776feL;\n 0xabab96ab313d4b9aL;\n 0xcece1fce3ed181f0L;\n 0x1111441188552299L;\n 0x8f8f068f0c890383L;\n 0x4e4e254e4a6b9c04L;\n 0xb7b7e6b7d1517366L;\n 0xebeb8beb0b60cbe0L;\n 0x3c3cf03cfdcc78c1L;\n 0x81813e817cbf1ffdL;\n 0x94946a94d4fe3540L;\n 0xf7f7fbf7eb0cf31cL;\n 0xb9b9deb9a1676f18L;\n 0x13134c13985f268bL;\n 0x2c2cb02c7d9c5851L;\n 0xd3d36bd3d6b8bb05L;\n 0xe7e7bbe76b5cd38cL;\n 0x6e6ea56e57cbdc39L;\n 0xc4c437c46ef395aaL;\n 0x03030c03180f061bL;\n 0x565645568a13acdcL;\n 0x44440d441a49885eL;\n 0x7f7fe17fdf9efea0L;\n 0xa9a99ea921374f88L;\n 0x2a2aa82a4d825467L;\n 0xbbbbd6bbb16d6b0aL;\n 0xc1c123c146e29f87L;\n 0x53535153a202a6f1L;\n 0xdcdc57dcae8ba572L;\n 0x0b0b2c0b58271653L;\n 0x9d9d4e9d9cd32701L;\n 0x6c6cad6c47c1d82bL;\n 0x3131c43195f562a4L;\n 0x7474cd7487b9e8f3L;\n 0xf6f6fff6e309f115L;\n 0x464605460a438c4cL;\n 0xacac8aac092645a5L;\n 0x89891e893c970fb5L;\n 0x14145014a04428b4L;\n 0xe1e1a3e15b42dfbaL;\n 0x16165816b04e2ca6L;\n 0x3a3ae83acdd274f7L;\n 0x6969b9696fd0d206L;\n 0x09092409482d1241L;\n 0x7070dd70a7ade0d7L;\n 0xb6b6e2b6d954716fL;\n 0xd0d067d0ceb7bd1eL;\n 0xeded93ed3b7ec7d6L;\n 0xcccc17cc2edb85e2L;\n 0x424215422a578468L;\n 0x98985a98b4c22d2cL;\n 0xa4a4aaa4490e55edL;\n 0x2828a0285d885075L;\n 0x5c5c6d5cda31b886L;\n 0xf8f8c7f8933fed6bL;\n 0x8686228644a411c2L;\n |];\n [|\n 0xd818186018c07830L;\n 0x2623238c2305af46L;\n 0xb8c6c63fc67ef991L;\n 0xfbe8e887e8136fcdL;\n 0xcb878726874ca113L;\n 0x11b8b8dab8a9626dL;\n 0x0901010401080502L;\n 0x0d4f4f214f426e9eL;\n 0x9b3636d836adee6cL;\n 0xffa6a6a2a6590451L;\n 0x0cd2d26fd2debdb9L;\n 0x0ef5f5f3f5fb06f7L;\n 0x967979f979ef80f2L;\n 0x306f6fa16f5fcedeL;\n 0x6d91917e91fcef3fL;\n 0xf852525552aa07a4L;\n 0x4760609d6027fdc0L;\n 0x35bcbccabc897665L;\n 0x379b9b569baccd2bL;\n 0x8a8e8e028e048c01L;\n 0xd2a3a3b6a371155bL;\n 0x6c0c0c300c603c18L;\n 0x847b7bf17bff8af6L;\n 0x803535d435b5e16aL;\n 0xf51d1d741de8693aL;\n 0xb3e0e0a7e05347ddL;\n 0x21d7d77bd7f6acb3L;\n 0x9cc2c22fc25eed99L;\n 0x432e2eb82e6d965cL;\n 0x294b4b314b627a96L;\n 0x5dfefedffea321e1L;\n 0xd5575741578216aeL;\n 0xbd15155415a8412aL;\n 0xe87777c1779fb6eeL;\n 0x923737dc37a5eb6eL;\n 0x9ee5e5b3e57b56d7L;\n 0x139f9f469f8cd923L;\n 0x23f0f0e7f0d317fdL;\n 0x204a4a354a6a7f94L;\n 0x44dada4fda9e95a9L;\n 0xa258587d58fa25b0L;\n 0xcfc9c903c906ca8fL;\n 0x7c2929a429558d52L;\n 0x5a0a0a280a502214L;\n 0x50b1b1feb1e14f7fL;\n 0xc9a0a0baa0691a5dL;\n 0x146b6bb16b7fdad6L;\n 0xd985852e855cab17L;\n 0x3cbdbdcebd817367L;\n 0x8f5d5d695dd234baL;\n 0x9010104010805020L;\n 0x07f4f4f7f4f303f5L;\n 0xddcbcb0bcb16c08bL;\n 0xd33e3ef83eedc67cL;\n 0x2d0505140528110aL;\n 0x78676781671fe6ceL;\n 0x97e4e4b7e47353d5L;\n 0x0227279c2725bb4eL;\n 0x7341411941325882L;\n 0xa78b8b168b2c9d0bL;\n 0xf6a7a7a6a7510153L;\n 0xb27d7de97dcf94faL;\n 0x4995956e95dcfb37L;\n 0x56d8d847d88e9fadL;\n 0x70fbfbcbfb8b30ebL;\n 0xcdeeee9fee2371c1L;\n 0xbb7c7ced7cc791f8L;\n 0x716666856617e3ccL;\n 0x7bdddd53dda68ea7L;\n 0xaf17175c17b84b2eL;\n 0x454747014702468eL;\n 0x1a9e9e429e84dc21L;\n 0xd4caca0fca1ec589L;\n 0x582d2db42d75995aL;\n 0x2ebfbfc6bf917963L;\n 0x3f07071c07381b0eL;\n 0xacadad8ead012347L;\n 0xb05a5a755aea2fb4L;\n 0xef838336836cb51bL;\n 0xb63333cc3385ff66L;\n 0x5c636391633ff2c6L;\n 0x1202020802100a04L;\n 0x93aaaa92aa393849L;\n 0xde7171d971afa8e2L;\n 0xc6c8c807c80ecf8dL;\n 0xd119196419c87d32L;\n 0x3b49493949727092L;\n 0x5fd9d943d9869aafL;\n 0x31f2f2eff2c31df9L;\n 0xa8e3e3abe34b48dbL;\n 0xb95b5b715be22ab6L;\n 0xbc88881a8834920dL;\n 0x3e9a9a529aa4c829L;\n 0x0b262698262dbe4cL;\n 0xbf3232c8328dfa64L;\n 0x59b0b0fab0e94a7dL;\n 0xf2e9e983e91b6acfL;\n 0x770f0f3c0f78331eL;\n 0x33d5d573d5e6a6b7L;\n 0xf480803a8074ba1dL;\n 0x27bebec2be997c61L;\n 0xebcdcd13cd26de87L;\n 0x893434d034bde468L;\n 0x3248483d487a7590L;\n 0x54ffffdbffab24e3L;\n 0x8d7a7af57af78ff4L;\n 0x6490907a90f4ea3dL;\n 0x9d5f5f615fc23ebeL;\n 0x3d202080201da040L;\n 0x0f6868bd6867d5d0L;\n 0xca1a1a681ad07234L;\n 0xb7aeae82ae192c41L;\n 0x7db4b4eab4c95e75L;\n 0xce54544d549a19a8L;\n 0x7f93937693ece53bL;\n 0x2f222288220daa44L;\n 0x6364648d6407e9c8L;\n 0x2af1f1e3f1db12ffL;\n 0xcc7373d173bfa2e6L;\n 0x8212124812905a24L;\n 0x7a40401d403a5d80L;\n 0x4808082008402810L;\n 0x95c3c32bc356e89bL;\n 0xdfecec97ec337bc5L;\n 0x4ddbdb4bdb9690abL;\n 0xc0a1a1bea1611f5fL;\n 0x918d8d0e8d1c8307L;\n 0xc83d3df43df5c97aL;\n 0x5b97976697ccf133L;\n 0x0000000000000000L;\n 0xf9cfcf1bcf36d483L;\n 0x6e2b2bac2b458756L;\n 0xe17676c57697b3ecL;\n 0xe68282328264b019L;\n 0x28d6d67fd6fea9b1L;\n 0xc31b1b6c1bd87736L;\n 0x74b5b5eeb5c15b77L;\n 0xbeafaf86af112943L;\n 0x1d6a6ab56a77dfd4L;\n 0xea50505d50ba0da0L;\n 0x5745450945124c8aL;\n 0x38f3f3ebf3cb18fbL;\n 0xad3030c0309df060L;\n 0xc4efef9bef2b74c3L;\n 0xda3f3ffc3fe5c37eL;\n 0xc755554955921caaL;\n 0xdba2a2b2a2791059L;\n 0xe9eaea8fea0365c9L;\n 0x6a656589650feccaL;\n 0x03babad2bab96869L;\n 0x4a2f2fbc2f65935eL;\n 0x8ec0c027c04ee79dL;\n 0x60dede5fdebe81a1L;\n 0xfc1c1c701ce06c38L;\n 0x46fdfdd3fdbb2ee7L;\n 0x1f4d4d294d52649aL;\n 0x7692927292e4e039L;\n 0xfa7575c9758fbceaL;\n 0x3606061806301e0cL;\n 0xae8a8a128a249809L;\n 0x4bb2b2f2b2f94079L;\n 0x85e6e6bfe66359d1L;\n 0x7e0e0e380e70361cL;\n 0xe71f1f7c1ff8633eL;\n 0x556262956237f7c4L;\n 0x3ad4d477d4eea3b5L;\n 0x81a8a89aa829324dL;\n 0x5296966296c4f431L;\n 0x62f9f9c3f99b3aefL;\n 0xa3c5c533c566f697L;\n 0x102525942535b14aL;\n 0xab59597959f220b2L;\n 0xd084842a8454ae15L;\n 0xc57272d572b7a7e4L;\n 0xec3939e439d5dd72L;\n 0x164c4c2d4c5a6198L;\n 0x945e5e655eca3bbcL;\n 0x9f7878fd78e785f0L;\n 0xe53838e038ddd870L;\n 0x988c8c0a8c148605L;\n 0x17d1d163d1c6b2bfL;\n 0xe4a5a5aea5410b57L;\n 0xa1e2e2afe2434dd9L;\n 0x4e616199612ff8c2L;\n 0x42b3b3f6b3f1457bL;\n 0x342121842115a542L;\n 0x089c9c4a9c94d625L;\n 0xee1e1e781ef0663cL;\n 0x6143431143225286L;\n 0xb1c7c73bc776fc93L;\n 0x4ffcfcd7fcb32be5L;\n 0x2404041004201408L;\n 0xe351515951b208a2L;\n 0x2599995e99bcc72fL;\n 0x226d6da96d4fc4daL;\n 0x650d0d340d68391aL;\n 0x79fafacffa8335e9L;\n 0x69dfdf5bdfb684a3L;\n 0xa97e7ee57ed79bfcL;\n 0x19242490243db448L;\n 0xfe3b3bec3bc5d776L;\n 0x9aabab96ab313d4bL;\n 0xf0cece1fce3ed181L;\n 0x9911114411885522L;\n 0x838f8f068f0c8903L;\n 0x044e4e254e4a6b9cL;\n 0x66b7b7e6b7d15173L;\n 0xe0ebeb8beb0b60cbL;\n 0xc13c3cf03cfdcc78L;\n 0xfd81813e817cbf1fL;\n 0x4094946a94d4fe35L;\n 0x1cf7f7fbf7eb0cf3L;\n 0x18b9b9deb9a1676fL;\n 0x8b13134c13985f26L;\n 0x512c2cb02c7d9c58L;\n 0x05d3d36bd3d6b8bbL;\n 0x8ce7e7bbe76b5cd3L;\n 0x396e6ea56e57cbdcL;\n 0xaac4c437c46ef395L;\n 0x1b03030c03180f06L;\n 0xdc565645568a13acL;\n 0x5e44440d441a4988L;\n 0xa07f7fe17fdf9efeL;\n 0x88a9a99ea921374fL;\n 0x672a2aa82a4d8254L;\n 0x0abbbbd6bbb16d6bL;\n 0x87c1c123c146e29fL;\n 0xf153535153a202a6L;\n 0x72dcdc57dcae8ba5L;\n 0x530b0b2c0b582716L;\n 0x019d9d4e9d9cd327L;\n 0x2b6c6cad6c47c1d8L;\n 0xa43131c43195f562L;\n 0xf37474cd7487b9e8L;\n 0x15f6f6fff6e309f1L;\n 0x4c464605460a438cL;\n 0xa5acac8aac092645L;\n 0xb589891e893c970fL;\n 0xb414145014a04428L;\n 0xbae1e1a3e15b42dfL;\n 0xa616165816b04e2cL;\n 0xf73a3ae83acdd274L;\n 0x066969b9696fd0d2L;\n 0x4109092409482d12L;\n 0xd77070dd70a7ade0L;\n 0x6fb6b6e2b6d95471L;\n 0x1ed0d067d0ceb7bdL;\n 0xd6eded93ed3b7ec7L;\n 0xe2cccc17cc2edb85L;\n 0x68424215422a5784L;\n 0x2c98985a98b4c22dL;\n 0xeda4a4aaa4490e55L;\n 0x752828a0285d8850L;\n 0x865c5c6d5cda31b8L;\n 0x6bf8f8c7f8933fedL;\n 0xc28686228644a411L;\n |];\n [|\n 0x30d818186018c078L;\n 0x462623238c2305afL;\n 0x91b8c6c63fc67ef9L;\n 0xcdfbe8e887e8136fL;\n 0x13cb878726874ca1L;\n 0x6d11b8b8dab8a962L;\n 0x0209010104010805L;\n 0x9e0d4f4f214f426eL;\n 0x6c9b3636d836adeeL;\n 0x51ffa6a6a2a65904L;\n 0xb90cd2d26fd2debdL;\n 0xf70ef5f5f3f5fb06L;\n 0xf2967979f979ef80L;\n 0xde306f6fa16f5fceL;\n 0x3f6d91917e91fcefL;\n 0xa4f852525552aa07L;\n 0xc04760609d6027fdL;\n 0x6535bcbccabc8976L;\n 0x2b379b9b569baccdL;\n 0x018a8e8e028e048cL;\n 0x5bd2a3a3b6a37115L;\n 0x186c0c0c300c603cL;\n 0xf6847b7bf17bff8aL;\n 0x6a803535d435b5e1L;\n 0x3af51d1d741de869L;\n 0xddb3e0e0a7e05347L;\n 0xb321d7d77bd7f6acL;\n 0x999cc2c22fc25eedL;\n 0x5c432e2eb82e6d96L;\n 0x96294b4b314b627aL;\n 0xe15dfefedffea321L;\n 0xaed5575741578216L;\n 0x2abd15155415a841L;\n 0xeee87777c1779fb6L;\n 0x6e923737dc37a5ebL;\n 0xd79ee5e5b3e57b56L;\n 0x23139f9f469f8cd9L;\n 0xfd23f0f0e7f0d317L;\n 0x94204a4a354a6a7fL;\n 0xa944dada4fda9e95L;\n 0xb0a258587d58fa25L;\n 0x8fcfc9c903c906caL;\n 0x527c2929a429558dL;\n 0x145a0a0a280a5022L;\n 0x7f50b1b1feb1e14fL;\n 0x5dc9a0a0baa0691aL;\n 0xd6146b6bb16b7fdaL;\n 0x17d985852e855cabL;\n 0x673cbdbdcebd8173L;\n 0xba8f5d5d695dd234L;\n 0x2090101040108050L;\n 0xf507f4f4f7f4f303L;\n 0x8bddcbcb0bcb16c0L;\n 0x7cd33e3ef83eedc6L;\n 0x0a2d050514052811L;\n 0xce78676781671fe6L;\n 0xd597e4e4b7e47353L;\n 0x4e0227279c2725bbL;\n 0x8273414119413258L;\n 0x0ba78b8b168b2c9dL;\n 0x53f6a7a7a6a75101L;\n 0xfab27d7de97dcf94L;\n 0x374995956e95dcfbL;\n 0xad56d8d847d88e9fL;\n 0xeb70fbfbcbfb8b30L;\n 0xc1cdeeee9fee2371L;\n 0xf8bb7c7ced7cc791L;\n 0xcc716666856617e3L;\n 0xa77bdddd53dda68eL;\n 0x2eaf17175c17b84bL;\n 0x8e45474701470246L;\n 0x211a9e9e429e84dcL;\n 0x89d4caca0fca1ec5L;\n 0x5a582d2db42d7599L;\n 0x632ebfbfc6bf9179L;\n 0x0e3f07071c07381bL;\n 0x47acadad8ead0123L;\n 0xb4b05a5a755aea2fL;\n 0x1bef838336836cb5L;\n 0x66b63333cc3385ffL;\n 0xc65c636391633ff2L;\n 0x041202020802100aL;\n 0x4993aaaa92aa3938L;\n 0xe2de7171d971afa8L;\n 0x8dc6c8c807c80ecfL;\n 0x32d119196419c87dL;\n 0x923b494939497270L;\n 0xaf5fd9d943d9869aL;\n 0xf931f2f2eff2c31dL;\n 0xdba8e3e3abe34b48L;\n 0xb6b95b5b715be22aL;\n 0x0dbc88881a883492L;\n 0x293e9a9a529aa4c8L;\n 0x4c0b262698262dbeL;\n 0x64bf3232c8328dfaL;\n 0x7d59b0b0fab0e94aL;\n 0xcff2e9e983e91b6aL;\n 0x1e770f0f3c0f7833L;\n 0xb733d5d573d5e6a6L;\n 0x1df480803a8074baL;\n 0x6127bebec2be997cL;\n 0x87ebcdcd13cd26deL;\n 0x68893434d034bde4L;\n 0x903248483d487a75L;\n 0xe354ffffdbffab24L;\n 0xf48d7a7af57af78fL;\n 0x3d6490907a90f4eaL;\n 0xbe9d5f5f615fc23eL;\n 0x403d202080201da0L;\n 0xd00f6868bd6867d5L;\n 0x34ca1a1a681ad072L;\n 0x41b7aeae82ae192cL;\n 0x757db4b4eab4c95eL;\n 0xa8ce54544d549a19L;\n 0x3b7f93937693ece5L;\n 0x442f222288220daaL;\n 0xc86364648d6407e9L;\n 0xff2af1f1e3f1db12L;\n 0xe6cc7373d173bfa2L;\n 0x248212124812905aL;\n 0x807a40401d403a5dL;\n 0x1048080820084028L;\n 0x9b95c3c32bc356e8L;\n 0xc5dfecec97ec337bL;\n 0xab4ddbdb4bdb9690L;\n 0x5fc0a1a1bea1611fL;\n 0x07918d8d0e8d1c83L;\n 0x7ac83d3df43df5c9L;\n 0x335b97976697ccf1L;\n 0x0000000000000000L;\n 0x83f9cfcf1bcf36d4L;\n 0x566e2b2bac2b4587L;\n 0xece17676c57697b3L;\n 0x19e68282328264b0L;\n 0xb128d6d67fd6fea9L;\n 0x36c31b1b6c1bd877L;\n 0x7774b5b5eeb5c15bL;\n 0x43beafaf86af1129L;\n 0xd41d6a6ab56a77dfL;\n 0xa0ea50505d50ba0dL;\n 0x8a5745450945124cL;\n 0xfb38f3f3ebf3cb18L;\n 0x60ad3030c0309df0L;\n 0xc3c4efef9bef2b74L;\n 0x7eda3f3ffc3fe5c3L;\n 0xaac755554955921cL;\n 0x59dba2a2b2a27910L;\n 0xc9e9eaea8fea0365L;\n 0xca6a656589650fecL;\n 0x6903babad2bab968L;\n 0x5e4a2f2fbc2f6593L;\n 0x9d8ec0c027c04ee7L;\n 0xa160dede5fdebe81L;\n 0x38fc1c1c701ce06cL;\n 0xe746fdfdd3fdbb2eL;\n 0x9a1f4d4d294d5264L;\n 0x397692927292e4e0L;\n 0xeafa7575c9758fbcL;\n 0x0c3606061806301eL;\n 0x09ae8a8a128a2498L;\n 0x794bb2b2f2b2f940L;\n 0xd185e6e6bfe66359L;\n 0x1c7e0e0e380e7036L;\n 0x3ee71f1f7c1ff863L;\n 0xc4556262956237f7L;\n 0xb53ad4d477d4eea3L;\n 0x4d81a8a89aa82932L;\n 0x315296966296c4f4L;\n 0xef62f9f9c3f99b3aL;\n 0x97a3c5c533c566f6L;\n 0x4a102525942535b1L;\n 0xb2ab59597959f220L;\n 0x15d084842a8454aeL;\n 0xe4c57272d572b7a7L;\n 0x72ec3939e439d5ddL;\n 0x98164c4c2d4c5a61L;\n 0xbc945e5e655eca3bL;\n 0xf09f7878fd78e785L;\n 0x70e53838e038ddd8L;\n 0x05988c8c0a8c1486L;\n 0xbf17d1d163d1c6b2L;\n 0x57e4a5a5aea5410bL;\n 0xd9a1e2e2afe2434dL;\n 0xc24e616199612ff8L;\n 0x7b42b3b3f6b3f145L;\n 0x42342121842115a5L;\n 0x25089c9c4a9c94d6L;\n 0x3cee1e1e781ef066L;\n 0x8661434311432252L;\n 0x93b1c7c73bc776fcL;\n 0xe54ffcfcd7fcb32bL;\n 0x0824040410042014L;\n 0xa2e351515951b208L;\n 0x2f2599995e99bcc7L;\n 0xda226d6da96d4fc4L;\n 0x1a650d0d340d6839L;\n 0xe979fafacffa8335L;\n 0xa369dfdf5bdfb684L;\n 0xfca97e7ee57ed79bL;\n 0x4819242490243db4L;\n 0x76fe3b3bec3bc5d7L;\n 0x4b9aabab96ab313dL;\n 0x81f0cece1fce3ed1L;\n 0x2299111144118855L;\n 0x03838f8f068f0c89L;\n 0x9c044e4e254e4a6bL;\n 0x7366b7b7e6b7d151L;\n 0xcbe0ebeb8beb0b60L;\n 0x78c13c3cf03cfdccL;\n 0x1ffd81813e817cbfL;\n 0x354094946a94d4feL;\n 0xf31cf7f7fbf7eb0cL;\n 0x6f18b9b9deb9a167L;\n 0x268b13134c13985fL;\n 0x58512c2cb02c7d9cL;\n 0xbb05d3d36bd3d6b8L;\n 0xd38ce7e7bbe76b5cL;\n 0xdc396e6ea56e57cbL;\n 0x95aac4c437c46ef3L;\n 0x061b03030c03180fL;\n 0xacdc565645568a13L;\n 0x885e44440d441a49L;\n 0xfea07f7fe17fdf9eL;\n 0x4f88a9a99ea92137L;\n 0x54672a2aa82a4d82L;\n 0x6b0abbbbd6bbb16dL;\n 0x9f87c1c123c146e2L;\n 0xa6f153535153a202L;\n 0xa572dcdc57dcae8bL;\n 0x16530b0b2c0b5827L;\n 0x27019d9d4e9d9cd3L;\n 0xd82b6c6cad6c47c1L;\n 0x62a43131c43195f5L;\n 0xe8f37474cd7487b9L;\n 0xf115f6f6fff6e309L;\n 0x8c4c464605460a43L;\n 0x45a5acac8aac0926L;\n 0x0fb589891e893c97L;\n 0x28b414145014a044L;\n 0xdfbae1e1a3e15b42L;\n 0x2ca616165816b04eL;\n 0x74f73a3ae83acdd2L;\n 0xd2066969b9696fd0L;\n 0x124109092409482dL;\n 0xe0d77070dd70a7adL;\n 0x716fb6b6e2b6d954L;\n 0xbd1ed0d067d0ceb7L;\n 0xc7d6eded93ed3b7eL;\n 0x85e2cccc17cc2edbL;\n 0x8468424215422a57L;\n 0x2d2c98985a98b4c2L;\n 0x55eda4a4aaa4490eL;\n 0x50752828a0285d88L;\n 0xb8865c5c6d5cda31L;\n 0xed6bf8f8c7f8933fL;\n 0x11c28686228644a4L;\n |];\n [|\n 0x7830d818186018c0L;\n 0xaf462623238c2305L;\n 0xf991b8c6c63fc67eL;\n 0x6fcdfbe8e887e813L;\n 0xa113cb878726874cL;\n 0x626d11b8b8dab8a9L;\n 0x0502090101040108L;\n 0x6e9e0d4f4f214f42L;\n 0xee6c9b3636d836adL;\n 0x0451ffa6a6a2a659L;\n 0xbdb90cd2d26fd2deL;\n 0x06f70ef5f5f3f5fbL;\n 0x80f2967979f979efL;\n 0xcede306f6fa16f5fL;\n 0xef3f6d91917e91fcL;\n 0x07a4f852525552aaL;\n 0xfdc04760609d6027L;\n 0x766535bcbccabc89L;\n 0xcd2b379b9b569bacL;\n 0x8c018a8e8e028e04L;\n 0x155bd2a3a3b6a371L;\n 0x3c186c0c0c300c60L;\n 0x8af6847b7bf17bffL;\n 0xe16a803535d435b5L;\n 0x693af51d1d741de8L;\n 0x47ddb3e0e0a7e053L;\n 0xacb321d7d77bd7f6L;\n 0xed999cc2c22fc25eL;\n 0x965c432e2eb82e6dL;\n 0x7a96294b4b314b62L;\n 0x21e15dfefedffea3L;\n 0x16aed55757415782L;\n 0x412abd15155415a8L;\n 0xb6eee87777c1779fL;\n 0xeb6e923737dc37a5L;\n 0x56d79ee5e5b3e57bL;\n 0xd923139f9f469f8cL;\n 0x17fd23f0f0e7f0d3L;\n 0x7f94204a4a354a6aL;\n 0x95a944dada4fda9eL;\n 0x25b0a258587d58faL;\n 0xca8fcfc9c903c906L;\n 0x8d527c2929a42955L;\n 0x22145a0a0a280a50L;\n 0x4f7f50b1b1feb1e1L;\n 0x1a5dc9a0a0baa069L;\n 0xdad6146b6bb16b7fL;\n 0xab17d985852e855cL;\n 0x73673cbdbdcebd81L;\n 0x34ba8f5d5d695dd2L;\n 0x5020901010401080L;\n 0x03f507f4f4f7f4f3L;\n 0xc08bddcbcb0bcb16L;\n 0xc67cd33e3ef83eedL;\n 0x110a2d0505140528L;\n 0xe6ce78676781671fL;\n 0x53d597e4e4b7e473L;\n 0xbb4e0227279c2725L;\n 0x5882734141194132L;\n 0x9d0ba78b8b168b2cL;\n 0x0153f6a7a7a6a751L;\n 0x94fab27d7de97dcfL;\n 0xfb374995956e95dcL;\n 0x9fad56d8d847d88eL;\n 0x30eb70fbfbcbfb8bL;\n 0x71c1cdeeee9fee23L;\n 0x91f8bb7c7ced7cc7L;\n 0xe3cc716666856617L;\n 0x8ea77bdddd53dda6L;\n 0x4b2eaf17175c17b8L;\n 0x468e454747014702L;\n 0xdc211a9e9e429e84L;\n 0xc589d4caca0fca1eL;\n 0x995a582d2db42d75L;\n 0x79632ebfbfc6bf91L;\n 0x1b0e3f07071c0738L;\n 0x2347acadad8ead01L;\n 0x2fb4b05a5a755aeaL;\n 0xb51bef838336836cL;\n 0xff66b63333cc3385L;\n 0xf2c65c636391633fL;\n 0x0a04120202080210L;\n 0x384993aaaa92aa39L;\n 0xa8e2de7171d971afL;\n 0xcf8dc6c8c807c80eL;\n 0x7d32d119196419c8L;\n 0x70923b4949394972L;\n 0x9aaf5fd9d943d986L;\n 0x1df931f2f2eff2c3L;\n 0x48dba8e3e3abe34bL;\n 0x2ab6b95b5b715be2L;\n 0x920dbc88881a8834L;\n 0xc8293e9a9a529aa4L;\n 0xbe4c0b262698262dL;\n 0xfa64bf3232c8328dL;\n 0x4a7d59b0b0fab0e9L;\n 0x6acff2e9e983e91bL;\n 0x331e770f0f3c0f78L;\n 0xa6b733d5d573d5e6L;\n 0xba1df480803a8074L;\n 0x7c6127bebec2be99L;\n 0xde87ebcdcd13cd26L;\n 0xe468893434d034bdL;\n 0x75903248483d487aL;\n 0x24e354ffffdbffabL;\n 0x8ff48d7a7af57af7L;\n 0xea3d6490907a90f4L;\n 0x3ebe9d5f5f615fc2L;\n 0xa0403d202080201dL;\n 0xd5d00f6868bd6867L;\n 0x7234ca1a1a681ad0L;\n 0x2c41b7aeae82ae19L;\n 0x5e757db4b4eab4c9L;\n 0x19a8ce54544d549aL;\n 0xe53b7f93937693ecL;\n 0xaa442f222288220dL;\n 0xe9c86364648d6407L;\n 0x12ff2af1f1e3f1dbL;\n 0xa2e6cc7373d173bfL;\n 0x5a24821212481290L;\n 0x5d807a40401d403aL;\n 0x2810480808200840L;\n 0xe89b95c3c32bc356L;\n 0x7bc5dfecec97ec33L;\n 0x90ab4ddbdb4bdb96L;\n 0x1f5fc0a1a1bea161L;\n 0x8307918d8d0e8d1cL;\n 0xc97ac83d3df43df5L;\n 0xf1335b97976697ccL;\n 0x0000000000000000L;\n 0xd483f9cfcf1bcf36L;\n 0x87566e2b2bac2b45L;\n 0xb3ece17676c57697L;\n 0xb019e68282328264L;\n 0xa9b128d6d67fd6feL;\n 0x7736c31b1b6c1bd8L;\n 0x5b7774b5b5eeb5c1L;\n 0x2943beafaf86af11L;\n 0xdfd41d6a6ab56a77L;\n 0x0da0ea50505d50baL;\n 0x4c8a574545094512L;\n 0x18fb38f3f3ebf3cbL;\n 0xf060ad3030c0309dL;\n 0x74c3c4efef9bef2bL;\n 0xc37eda3f3ffc3fe5L;\n 0x1caac75555495592L;\n 0x1059dba2a2b2a279L;\n 0x65c9e9eaea8fea03L;\n 0xecca6a656589650fL;\n 0x686903babad2bab9L;\n 0x935e4a2f2fbc2f65L;\n 0xe79d8ec0c027c04eL;\n 0x81a160dede5fdebeL;\n 0x6c38fc1c1c701ce0L;\n 0x2ee746fdfdd3fdbbL;\n 0x649a1f4d4d294d52L;\n 0xe0397692927292e4L;\n 0xbceafa7575c9758fL;\n 0x1e0c360606180630L;\n 0x9809ae8a8a128a24L;\n 0x40794bb2b2f2b2f9L;\n 0x59d185e6e6bfe663L;\n 0x361c7e0e0e380e70L;\n 0x633ee71f1f7c1ff8L;\n 0xf7c4556262956237L;\n 0xa3b53ad4d477d4eeL;\n 0x324d81a8a89aa829L;\n 0xf4315296966296c4L;\n 0x3aef62f9f9c3f99bL;\n 0xf697a3c5c533c566L;\n 0xb14a102525942535L;\n 0x20b2ab59597959f2L;\n 0xae15d084842a8454L;\n 0xa7e4c57272d572b7L;\n 0xdd72ec3939e439d5L;\n 0x6198164c4c2d4c5aL;\n 0x3bbc945e5e655ecaL;\n 0x85f09f7878fd78e7L;\n 0xd870e53838e038ddL;\n 0x8605988c8c0a8c14L;\n 0xb2bf17d1d163d1c6L;\n 0x0b57e4a5a5aea541L;\n 0x4dd9a1e2e2afe243L;\n 0xf8c24e616199612fL;\n 0x457b42b3b3f6b3f1L;\n 0xa542342121842115L;\n 0xd625089c9c4a9c94L;\n 0x663cee1e1e781ef0L;\n 0x5286614343114322L;\n 0xfc93b1c7c73bc776L;\n 0x2be54ffcfcd7fcb3L;\n 0x1408240404100420L;\n 0x08a2e351515951b2L;\n 0xc72f2599995e99bcL;\n 0xc4da226d6da96d4fL;\n 0x391a650d0d340d68L;\n 0x35e979fafacffa83L;\n 0x84a369dfdf5bdfb6L;\n 0x9bfca97e7ee57ed7L;\n 0xb44819242490243dL;\n 0xd776fe3b3bec3bc5L;\n 0x3d4b9aabab96ab31L;\n 0xd181f0cece1fce3eL;\n 0x5522991111441188L;\n 0x8903838f8f068f0cL;\n 0x6b9c044e4e254e4aL;\n 0x517366b7b7e6b7d1L;\n 0x60cbe0ebeb8beb0bL;\n 0xcc78c13c3cf03cfdL;\n 0xbf1ffd81813e817cL;\n 0xfe354094946a94d4L;\n 0x0cf31cf7f7fbf7ebL;\n 0x676f18b9b9deb9a1L;\n 0x5f268b13134c1398L;\n 0x9c58512c2cb02c7dL;\n 0xb8bb05d3d36bd3d6L;\n 0x5cd38ce7e7bbe76bL;\n 0xcbdc396e6ea56e57L;\n 0xf395aac4c437c46eL;\n 0x0f061b03030c0318L;\n 0x13acdc565645568aL;\n 0x49885e44440d441aL;\n 0x9efea07f7fe17fdfL;\n 0x374f88a9a99ea921L;\n 0x8254672a2aa82a4dL;\n 0x6d6b0abbbbd6bbb1L;\n 0xe29f87c1c123c146L;\n 0x02a6f153535153a2L;\n 0x8ba572dcdc57dcaeL;\n 0x2716530b0b2c0b58L;\n 0xd327019d9d4e9d9cL;\n 0xc1d82b6c6cad6c47L;\n 0xf562a43131c43195L;\n 0xb9e8f37474cd7487L;\n 0x09f115f6f6fff6e3L;\n 0x438c4c464605460aL;\n 0x2645a5acac8aac09L;\n 0x970fb589891e893cL;\n 0x4428b414145014a0L;\n 0x42dfbae1e1a3e15bL;\n 0x4e2ca616165816b0L;\n 0xd274f73a3ae83acdL;\n 0xd0d2066969b9696fL;\n 0x2d12410909240948L;\n 0xade0d77070dd70a7L;\n 0x54716fb6b6e2b6d9L;\n 0xb7bd1ed0d067d0ceL;\n 0x7ec7d6eded93ed3bL;\n 0xdb85e2cccc17cc2eL;\n 0x578468424215422aL;\n 0xc22d2c98985a98b4L;\n 0x0e55eda4a4aaa449L;\n 0x8850752828a0285dL;\n 0x31b8865c5c6d5cdaL;\n 0x3fed6bf8f8c7f893L;\n 0xa411c28686228644L;\n |];\n [|\n 0xc07830d818186018L;\n 0x05af462623238c23L;\n 0x7ef991b8c6c63fc6L;\n 0x136fcdfbe8e887e8L;\n 0x4ca113cb87872687L;\n 0xa9626d11b8b8dab8L;\n 0x0805020901010401L;\n 0x426e9e0d4f4f214fL;\n 0xadee6c9b3636d836L;\n 0x590451ffa6a6a2a6L;\n 0xdebdb90cd2d26fd2L;\n 0xfb06f70ef5f5f3f5L;\n 0xef80f2967979f979L;\n 0x5fcede306f6fa16fL;\n 0xfcef3f6d91917e91L;\n 0xaa07a4f852525552L;\n 0x27fdc04760609d60L;\n 0x89766535bcbccabcL;\n 0xaccd2b379b9b569bL;\n 0x048c018a8e8e028eL;\n 0x71155bd2a3a3b6a3L;\n 0x603c186c0c0c300cL;\n 0xff8af6847b7bf17bL;\n 0xb5e16a803535d435L;\n 0xe8693af51d1d741dL;\n 0x5347ddb3e0e0a7e0L;\n 0xf6acb321d7d77bd7L;\n 0x5eed999cc2c22fc2L;\n 0x6d965c432e2eb82eL;\n 0x627a96294b4b314bL;\n 0xa321e15dfefedffeL;\n 0x8216aed557574157L;\n 0xa8412abd15155415L;\n 0x9fb6eee87777c177L;\n 0xa5eb6e923737dc37L;\n 0x7b56d79ee5e5b3e5L;\n 0x8cd923139f9f469fL;\n 0xd317fd23f0f0e7f0L;\n 0x6a7f94204a4a354aL;\n 0x9e95a944dada4fdaL;\n 0xfa25b0a258587d58L;\n 0x06ca8fcfc9c903c9L;\n 0x558d527c2929a429L;\n 0x5022145a0a0a280aL;\n 0xe14f7f50b1b1feb1L;\n 0x691a5dc9a0a0baa0L;\n 0x7fdad6146b6bb16bL;\n 0x5cab17d985852e85L;\n 0x8173673cbdbdcebdL;\n 0xd234ba8f5d5d695dL;\n 0x8050209010104010L;\n 0xf303f507f4f4f7f4L;\n 0x16c08bddcbcb0bcbL;\n 0xedc67cd33e3ef83eL;\n 0x28110a2d05051405L;\n 0x1fe6ce7867678167L;\n 0x7353d597e4e4b7e4L;\n 0x25bb4e0227279c27L;\n 0x3258827341411941L;\n 0x2c9d0ba78b8b168bL;\n 0x510153f6a7a7a6a7L;\n 0xcf94fab27d7de97dL;\n 0xdcfb374995956e95L;\n 0x8e9fad56d8d847d8L;\n 0x8b30eb70fbfbcbfbL;\n 0x2371c1cdeeee9feeL;\n 0xc791f8bb7c7ced7cL;\n 0x17e3cc7166668566L;\n 0xa68ea77bdddd53ddL;\n 0xb84b2eaf17175c17L;\n 0x02468e4547470147L;\n 0x84dc211a9e9e429eL;\n 0x1ec589d4caca0fcaL;\n 0x75995a582d2db42dL;\n 0x9179632ebfbfc6bfL;\n 0x381b0e3f07071c07L;\n 0x012347acadad8eadL;\n 0xea2fb4b05a5a755aL;\n 0x6cb51bef83833683L;\n 0x85ff66b63333cc33L;\n 0x3ff2c65c63639163L;\n 0x100a041202020802L;\n 0x39384993aaaa92aaL;\n 0xafa8e2de7171d971L;\n 0x0ecf8dc6c8c807c8L;\n 0xc87d32d119196419L;\n 0x7270923b49493949L;\n 0x869aaf5fd9d943d9L;\n 0xc31df931f2f2eff2L;\n 0x4b48dba8e3e3abe3L;\n 0xe22ab6b95b5b715bL;\n 0x34920dbc88881a88L;\n 0xa4c8293e9a9a529aL;\n 0x2dbe4c0b26269826L;\n 0x8dfa64bf3232c832L;\n 0xe94a7d59b0b0fab0L;\n 0x1b6acff2e9e983e9L;\n 0x78331e770f0f3c0fL;\n 0xe6a6b733d5d573d5L;\n 0x74ba1df480803a80L;\n 0x997c6127bebec2beL;\n 0x26de87ebcdcd13cdL;\n 0xbde468893434d034L;\n 0x7a75903248483d48L;\n 0xab24e354ffffdbffL;\n 0xf78ff48d7a7af57aL;\n 0xf4ea3d6490907a90L;\n 0xc23ebe9d5f5f615fL;\n 0x1da0403d20208020L;\n 0x67d5d00f6868bd68L;\n 0xd07234ca1a1a681aL;\n 0x192c41b7aeae82aeL;\n 0xc95e757db4b4eab4L;\n 0x9a19a8ce54544d54L;\n 0xece53b7f93937693L;\n 0x0daa442f22228822L;\n 0x07e9c86364648d64L;\n 0xdb12ff2af1f1e3f1L;\n 0xbfa2e6cc7373d173L;\n 0x905a248212124812L;\n 0x3a5d807a40401d40L;\n 0x4028104808082008L;\n 0x56e89b95c3c32bc3L;\n 0x337bc5dfecec97ecL;\n 0x9690ab4ddbdb4bdbL;\n 0x611f5fc0a1a1bea1L;\n 0x1c8307918d8d0e8dL;\n 0xf5c97ac83d3df43dL;\n 0xccf1335b97976697L;\n 0x0000000000000000L;\n 0x36d483f9cfcf1bcfL;\n 0x4587566e2b2bac2bL;\n 0x97b3ece17676c576L;\n 0x64b019e682823282L;\n 0xfea9b128d6d67fd6L;\n 0xd87736c31b1b6c1bL;\n 0xc15b7774b5b5eeb5L;\n 0x112943beafaf86afL;\n 0x77dfd41d6a6ab56aL;\n 0xba0da0ea50505d50L;\n 0x124c8a5745450945L;\n 0xcb18fb38f3f3ebf3L;\n 0x9df060ad3030c030L;\n 0x2b74c3c4efef9befL;\n 0xe5c37eda3f3ffc3fL;\n 0x921caac755554955L;\n 0x791059dba2a2b2a2L;\n 0x0365c9e9eaea8feaL;\n 0x0fecca6a65658965L;\n 0xb9686903babad2baL;\n 0x65935e4a2f2fbc2fL;\n 0x4ee79d8ec0c027c0L;\n 0xbe81a160dede5fdeL;\n 0xe06c38fc1c1c701cL;\n 0xbb2ee746fdfdd3fdL;\n 0x52649a1f4d4d294dL;\n 0xe4e0397692927292L;\n 0x8fbceafa7575c975L;\n 0x301e0c3606061806L;\n 0x249809ae8a8a128aL;\n 0xf940794bb2b2f2b2L;\n 0x6359d185e6e6bfe6L;\n 0x70361c7e0e0e380eL;\n 0xf8633ee71f1f7c1fL;\n 0x37f7c45562629562L;\n 0xeea3b53ad4d477d4L;\n 0x29324d81a8a89aa8L;\n 0xc4f4315296966296L;\n 0x9b3aef62f9f9c3f9L;\n 0x66f697a3c5c533c5L;\n 0x35b14a1025259425L;\n 0xf220b2ab59597959L;\n 0x54ae15d084842a84L;\n 0xb7a7e4c57272d572L;\n 0xd5dd72ec3939e439L;\n 0x5a6198164c4c2d4cL;\n 0xca3bbc945e5e655eL;\n 0xe785f09f7878fd78L;\n 0xddd870e53838e038L;\n 0x148605988c8c0a8cL;\n 0xc6b2bf17d1d163d1L;\n 0x410b57e4a5a5aea5L;\n 0x434dd9a1e2e2afe2L;\n 0x2ff8c24e61619961L;\n 0xf1457b42b3b3f6b3L;\n 0x15a5423421218421L;\n 0x94d625089c9c4a9cL;\n 0xf0663cee1e1e781eL;\n 0x2252866143431143L;\n 0x76fc93b1c7c73bc7L;\n 0xb32be54ffcfcd7fcL;\n 0x2014082404041004L;\n 0xb208a2e351515951L;\n 0xbcc72f2599995e99L;\n 0x4fc4da226d6da96dL;\n 0x68391a650d0d340dL;\n 0x8335e979fafacffaL;\n 0xb684a369dfdf5bdfL;\n 0xd79bfca97e7ee57eL;\n 0x3db4481924249024L;\n 0xc5d776fe3b3bec3bL;\n 0x313d4b9aabab96abL;\n 0x3ed181f0cece1fceL;\n 0x8855229911114411L;\n 0x0c8903838f8f068fL;\n 0x4a6b9c044e4e254eL;\n 0xd1517366b7b7e6b7L;\n 0x0b60cbe0ebeb8bebL;\n 0xfdcc78c13c3cf03cL;\n 0x7cbf1ffd81813e81L;\n 0xd4fe354094946a94L;\n 0xeb0cf31cf7f7fbf7L;\n 0xa1676f18b9b9deb9L;\n 0x985f268b13134c13L;\n 0x7d9c58512c2cb02cL;\n 0xd6b8bb05d3d36bd3L;\n 0x6b5cd38ce7e7bbe7L;\n 0x57cbdc396e6ea56eL;\n 0x6ef395aac4c437c4L;\n 0x180f061b03030c03L;\n 0x8a13acdc56564556L;\n 0x1a49885e44440d44L;\n 0xdf9efea07f7fe17fL;\n 0x21374f88a9a99ea9L;\n 0x4d8254672a2aa82aL;\n 0xb16d6b0abbbbd6bbL;\n 0x46e29f87c1c123c1L;\n 0xa202a6f153535153L;\n 0xae8ba572dcdc57dcL;\n 0x582716530b0b2c0bL;\n 0x9cd327019d9d4e9dL;\n 0x47c1d82b6c6cad6cL;\n 0x95f562a43131c431L;\n 0x87b9e8f37474cd74L;\n 0xe309f115f6f6fff6L;\n 0x0a438c4c46460546L;\n 0x092645a5acac8aacL;\n 0x3c970fb589891e89L;\n 0xa04428b414145014L;\n 0x5b42dfbae1e1a3e1L;\n 0xb04e2ca616165816L;\n 0xcdd274f73a3ae83aL;\n 0x6fd0d2066969b969L;\n 0x482d124109092409L;\n 0xa7ade0d77070dd70L;\n 0xd954716fb6b6e2b6L;\n 0xceb7bd1ed0d067d0L;\n 0x3b7ec7d6eded93edL;\n 0x2edb85e2cccc17ccL;\n 0x2a57846842421542L;\n 0xb4c22d2c98985a98L;\n 0x490e55eda4a4aaa4L;\n 0x5d8850752828a028L;\n 0xda31b8865c5c6d5cL;\n 0x933fed6bf8f8c7f8L;\n 0x44a411c286862286L;\n |];\n [|\n 0x18c07830d8181860L;\n 0x2305af462623238cL;\n 0xc67ef991b8c6c63fL;\n 0xe8136fcdfbe8e887L;\n 0x874ca113cb878726L;\n 0xb8a9626d11b8b8daL;\n 0x0108050209010104L;\n 0x4f426e9e0d4f4f21L;\n 0x36adee6c9b3636d8L;\n 0xa6590451ffa6a6a2L;\n 0xd2debdb90cd2d26fL;\n 0xf5fb06f70ef5f5f3L;\n 0x79ef80f2967979f9L;\n 0x6f5fcede306f6fa1L;\n 0x91fcef3f6d91917eL;\n 0x52aa07a4f8525255L;\n 0x6027fdc04760609dL;\n 0xbc89766535bcbccaL;\n 0x9baccd2b379b9b56L;\n 0x8e048c018a8e8e02L;\n 0xa371155bd2a3a3b6L;\n 0x0c603c186c0c0c30L;\n 0x7bff8af6847b7bf1L;\n 0x35b5e16a803535d4L;\n 0x1de8693af51d1d74L;\n 0xe05347ddb3e0e0a7L;\n 0xd7f6acb321d7d77bL;\n 0xc25eed999cc2c22fL;\n 0x2e6d965c432e2eb8L;\n 0x4b627a96294b4b31L;\n 0xfea321e15dfefedfL;\n 0x578216aed5575741L;\n 0x15a8412abd151554L;\n 0x779fb6eee87777c1L;\n 0x37a5eb6e923737dcL;\n 0xe57b56d79ee5e5b3L;\n 0x9f8cd923139f9f46L;\n 0xf0d317fd23f0f0e7L;\n 0x4a6a7f94204a4a35L;\n 0xda9e95a944dada4fL;\n 0x58fa25b0a258587dL;\n 0xc906ca8fcfc9c903L;\n 0x29558d527c2929a4L;\n 0x0a5022145a0a0a28L;\n 0xb1e14f7f50b1b1feL;\n 0xa0691a5dc9a0a0baL;\n 0x6b7fdad6146b6bb1L;\n 0x855cab17d985852eL;\n 0xbd8173673cbdbdceL;\n 0x5dd234ba8f5d5d69L;\n 0x1080502090101040L;\n 0xf4f303f507f4f4f7L;\n 0xcb16c08bddcbcb0bL;\n 0x3eedc67cd33e3ef8L;\n 0x0528110a2d050514L;\n 0x671fe6ce78676781L;\n 0xe47353d597e4e4b7L;\n 0x2725bb4e0227279cL;\n 0x4132588273414119L;\n 0x8b2c9d0ba78b8b16L;\n 0xa7510153f6a7a7a6L;\n 0x7dcf94fab27d7de9L;\n 0x95dcfb374995956eL;\n 0xd88e9fad56d8d847L;\n 0xfb8b30eb70fbfbcbL;\n 0xee2371c1cdeeee9fL;\n 0x7cc791f8bb7c7cedL;\n 0x6617e3cc71666685L;\n 0xdda68ea77bdddd53L;\n 0x17b84b2eaf17175cL;\n 0x4702468e45474701L;\n 0x9e84dc211a9e9e42L;\n 0xca1ec589d4caca0fL;\n 0x2d75995a582d2db4L;\n 0xbf9179632ebfbfc6L;\n 0x07381b0e3f07071cL;\n 0xad012347acadad8eL;\n 0x5aea2fb4b05a5a75L;\n 0x836cb51bef838336L;\n 0x3385ff66b63333ccL;\n 0x633ff2c65c636391L;\n 0x02100a0412020208L;\n 0xaa39384993aaaa92L;\n 0x71afa8e2de7171d9L;\n 0xc80ecf8dc6c8c807L;\n 0x19c87d32d1191964L;\n 0x497270923b494939L;\n 0xd9869aaf5fd9d943L;\n 0xf2c31df931f2f2efL;\n 0xe34b48dba8e3e3abL;\n 0x5be22ab6b95b5b71L;\n 0x8834920dbc88881aL;\n 0x9aa4c8293e9a9a52L;\n 0x262dbe4c0b262698L;\n 0x328dfa64bf3232c8L;\n 0xb0e94a7d59b0b0faL;\n 0xe91b6acff2e9e983L;\n 0x0f78331e770f0f3cL;\n 0xd5e6a6b733d5d573L;\n 0x8074ba1df480803aL;\n 0xbe997c6127bebec2L;\n 0xcd26de87ebcdcd13L;\n 0x34bde468893434d0L;\n 0x487a75903248483dL;\n 0xffab24e354ffffdbL;\n 0x7af78ff48d7a7af5L;\n 0x90f4ea3d6490907aL;\n 0x5fc23ebe9d5f5f61L;\n 0x201da0403d202080L;\n 0x6867d5d00f6868bdL;\n 0x1ad07234ca1a1a68L;\n 0xae192c41b7aeae82L;\n 0xb4c95e757db4b4eaL;\n 0x549a19a8ce54544dL;\n 0x93ece53b7f939376L;\n 0x220daa442f222288L;\n 0x6407e9c86364648dL;\n 0xf1db12ff2af1f1e3L;\n 0x73bfa2e6cc7373d1L;\n 0x12905a2482121248L;\n 0x403a5d807a40401dL;\n 0x0840281048080820L;\n 0xc356e89b95c3c32bL;\n 0xec337bc5dfecec97L;\n 0xdb9690ab4ddbdb4bL;\n 0xa1611f5fc0a1a1beL;\n 0x8d1c8307918d8d0eL;\n 0x3df5c97ac83d3df4L;\n 0x97ccf1335b979766L;\n 0x0000000000000000L;\n 0xcf36d483f9cfcf1bL;\n 0x2b4587566e2b2bacL;\n 0x7697b3ece17676c5L;\n 0x8264b019e6828232L;\n 0xd6fea9b128d6d67fL;\n 0x1bd87736c31b1b6cL;\n 0xb5c15b7774b5b5eeL;\n 0xaf112943beafaf86L;\n 0x6a77dfd41d6a6ab5L;\n 0x50ba0da0ea50505dL;\n 0x45124c8a57454509L;\n 0xf3cb18fb38f3f3ebL;\n 0x309df060ad3030c0L;\n 0xef2b74c3c4efef9bL;\n 0x3fe5c37eda3f3ffcL;\n 0x55921caac7555549L;\n 0xa2791059dba2a2b2L;\n 0xea0365c9e9eaea8fL;\n 0x650fecca6a656589L;\n 0xbab9686903babad2L;\n 0x2f65935e4a2f2fbcL;\n 0xc04ee79d8ec0c027L;\n 0xdebe81a160dede5fL;\n 0x1ce06c38fc1c1c70L;\n 0xfdbb2ee746fdfdd3L;\n 0x4d52649a1f4d4d29L;\n 0x92e4e03976929272L;\n 0x758fbceafa7575c9L;\n 0x06301e0c36060618L;\n 0x8a249809ae8a8a12L;\n 0xb2f940794bb2b2f2L;\n 0xe66359d185e6e6bfL;\n 0x0e70361c7e0e0e38L;\n 0x1ff8633ee71f1f7cL;\n 0x6237f7c455626295L;\n 0xd4eea3b53ad4d477L;\n 0xa829324d81a8a89aL;\n 0x96c4f43152969662L;\n 0xf99b3aef62f9f9c3L;\n 0xc566f697a3c5c533L;\n 0x2535b14a10252594L;\n 0x59f220b2ab595979L;\n 0x8454ae15d084842aL;\n 0x72b7a7e4c57272d5L;\n 0x39d5dd72ec3939e4L;\n 0x4c5a6198164c4c2dL;\n 0x5eca3bbc945e5e65L;\n 0x78e785f09f7878fdL;\n 0x38ddd870e53838e0L;\n 0x8c148605988c8c0aL;\n 0xd1c6b2bf17d1d163L;\n 0xa5410b57e4a5a5aeL;\n 0xe2434dd9a1e2e2afL;\n 0x612ff8c24e616199L;\n 0xb3f1457b42b3b3f6L;\n 0x2115a54234212184L;\n 0x9c94d625089c9c4aL;\n 0x1ef0663cee1e1e78L;\n 0x4322528661434311L;\n 0xc776fc93b1c7c73bL;\n 0xfcb32be54ffcfcd7L;\n 0x0420140824040410L;\n 0x51b208a2e3515159L;\n 0x99bcc72f2599995eL;\n 0x6d4fc4da226d6da9L;\n 0x0d68391a650d0d34L;\n 0xfa8335e979fafacfL;\n 0xdfb684a369dfdf5bL;\n 0x7ed79bfca97e7ee5L;\n 0x243db44819242490L;\n 0x3bc5d776fe3b3becL;\n 0xab313d4b9aabab96L;\n 0xce3ed181f0cece1fL;\n 0x1188552299111144L;\n 0x8f0c8903838f8f06L;\n 0x4e4a6b9c044e4e25L;\n 0xb7d1517366b7b7e6L;\n 0xeb0b60cbe0ebeb8bL;\n 0x3cfdcc78c13c3cf0L;\n 0x817cbf1ffd81813eL;\n 0x94d4fe354094946aL;\n 0xf7eb0cf31cf7f7fbL;\n 0xb9a1676f18b9b9deL;\n 0x13985f268b13134cL;\n 0x2c7d9c58512c2cb0L;\n 0xd3d6b8bb05d3d36bL;\n 0xe76b5cd38ce7e7bbL;\n 0x6e57cbdc396e6ea5L;\n 0xc46ef395aac4c437L;\n 0x03180f061b03030cL;\n 0x568a13acdc565645L;\n 0x441a49885e44440dL;\n 0x7fdf9efea07f7fe1L;\n 0xa921374f88a9a99eL;\n 0x2a4d8254672a2aa8L;\n 0xbbb16d6b0abbbbd6L;\n 0xc146e29f87c1c123L;\n 0x53a202a6f1535351L;\n 0xdcae8ba572dcdc57L;\n 0x0b582716530b0b2cL;\n 0x9d9cd327019d9d4eL;\n 0x6c47c1d82b6c6cadL;\n 0x3195f562a43131c4L;\n 0x7487b9e8f37474cdL;\n 0xf6e309f115f6f6ffL;\n 0x460a438c4c464605L;\n 0xac092645a5acac8aL;\n 0x893c970fb589891eL;\n 0x14a04428b4141450L;\n 0xe15b42dfbae1e1a3L;\n 0x16b04e2ca6161658L;\n 0x3acdd274f73a3ae8L;\n 0x696fd0d2066969b9L;\n 0x09482d1241090924L;\n 0x70a7ade0d77070ddL;\n 0xb6d954716fb6b6e2L;\n 0xd0ceb7bd1ed0d067L;\n 0xed3b7ec7d6eded93L;\n 0xcc2edb85e2cccc17L;\n 0x422a578468424215L;\n 0x98b4c22d2c98985aL;\n 0xa4490e55eda4a4aaL;\n 0x285d8850752828a0L;\n 0x5cda31b8865c5c6dL;\n 0xf8933fed6bf8f8c7L;\n 0x8644a411c2868622L;\n |];\n [|\n 0x6018c07830d81818L;\n 0x8c2305af46262323L;\n 0x3fc67ef991b8c6c6L;\n 0x87e8136fcdfbe8e8L;\n 0x26874ca113cb8787L;\n 0xdab8a9626d11b8b8L;\n 0x0401080502090101L;\n 0x214f426e9e0d4f4fL;\n 0xd836adee6c9b3636L;\n 0xa2a6590451ffa6a6L;\n 0x6fd2debdb90cd2d2L;\n 0xf3f5fb06f70ef5f5L;\n 0xf979ef80f2967979L;\n 0xa16f5fcede306f6fL;\n 0x7e91fcef3f6d9191L;\n 0x5552aa07a4f85252L;\n 0x9d6027fdc0476060L;\n 0xcabc89766535bcbcL;\n 0x569baccd2b379b9bL;\n 0x028e048c018a8e8eL;\n 0xb6a371155bd2a3a3L;\n 0x300c603c186c0c0cL;\n 0xf17bff8af6847b7bL;\n 0xd435b5e16a803535L;\n 0x741de8693af51d1dL;\n 0xa7e05347ddb3e0e0L;\n 0x7bd7f6acb321d7d7L;\n 0x2fc25eed999cc2c2L;\n 0xb82e6d965c432e2eL;\n 0x314b627a96294b4bL;\n 0xdffea321e15dfefeL;\n 0x41578216aed55757L;\n 0x5415a8412abd1515L;\n 0xc1779fb6eee87777L;\n 0xdc37a5eb6e923737L;\n 0xb3e57b56d79ee5e5L;\n 0x469f8cd923139f9fL;\n 0xe7f0d317fd23f0f0L;\n 0x354a6a7f94204a4aL;\n 0x4fda9e95a944dadaL;\n 0x7d58fa25b0a25858L;\n 0x03c906ca8fcfc9c9L;\n 0xa429558d527c2929L;\n 0x280a5022145a0a0aL;\n 0xfeb1e14f7f50b1b1L;\n 0xbaa0691a5dc9a0a0L;\n 0xb16b7fdad6146b6bL;\n 0x2e855cab17d98585L;\n 0xcebd8173673cbdbdL;\n 0x695dd234ba8f5d5dL;\n 0x4010805020901010L;\n 0xf7f4f303f507f4f4L;\n 0x0bcb16c08bddcbcbL;\n 0xf83eedc67cd33e3eL;\n 0x140528110a2d0505L;\n 0x81671fe6ce786767L;\n 0xb7e47353d597e4e4L;\n 0x9c2725bb4e022727L;\n 0x1941325882734141L;\n 0x168b2c9d0ba78b8bL;\n 0xa6a7510153f6a7a7L;\n 0xe97dcf94fab27d7dL;\n 0x6e95dcfb37499595L;\n 0x47d88e9fad56d8d8L;\n 0xcbfb8b30eb70fbfbL;\n 0x9fee2371c1cdeeeeL;\n 0xed7cc791f8bb7c7cL;\n 0x856617e3cc716666L;\n 0x53dda68ea77bddddL;\n 0x5c17b84b2eaf1717L;\n 0x014702468e454747L;\n 0x429e84dc211a9e9eL;\n 0x0fca1ec589d4cacaL;\n 0xb42d75995a582d2dL;\n 0xc6bf9179632ebfbfL;\n 0x1c07381b0e3f0707L;\n 0x8ead012347acadadL;\n 0x755aea2fb4b05a5aL;\n 0x36836cb51bef8383L;\n 0xcc3385ff66b63333L;\n 0x91633ff2c65c6363L;\n 0x0802100a04120202L;\n 0x92aa39384993aaaaL;\n 0xd971afa8e2de7171L;\n 0x07c80ecf8dc6c8c8L;\n 0x6419c87d32d11919L;\n 0x39497270923b4949L;\n 0x43d9869aaf5fd9d9L;\n 0xeff2c31df931f2f2L;\n 0xabe34b48dba8e3e3L;\n 0x715be22ab6b95b5bL;\n 0x1a8834920dbc8888L;\n 0x529aa4c8293e9a9aL;\n 0x98262dbe4c0b2626L;\n 0xc8328dfa64bf3232L;\n 0xfab0e94a7d59b0b0L;\n 0x83e91b6acff2e9e9L;\n 0x3c0f78331e770f0fL;\n 0x73d5e6a6b733d5d5L;\n 0x3a8074ba1df48080L;\n 0xc2be997c6127bebeL;\n 0x13cd26de87ebcdcdL;\n 0xd034bde468893434L;\n 0x3d487a7590324848L;\n 0xdbffab24e354ffffL;\n 0xf57af78ff48d7a7aL;\n 0x7a90f4ea3d649090L;\n 0x615fc23ebe9d5f5fL;\n 0x80201da0403d2020L;\n 0xbd6867d5d00f6868L;\n 0x681ad07234ca1a1aL;\n 0x82ae192c41b7aeaeL;\n 0xeab4c95e757db4b4L;\n 0x4d549a19a8ce5454L;\n 0x7693ece53b7f9393L;\n 0x88220daa442f2222L;\n 0x8d6407e9c8636464L;\n 0xe3f1db12ff2af1f1L;\n 0xd173bfa2e6cc7373L;\n 0x4812905a24821212L;\n 0x1d403a5d807a4040L;\n 0x2008402810480808L;\n 0x2bc356e89b95c3c3L;\n 0x97ec337bc5dfececL;\n 0x4bdb9690ab4ddbdbL;\n 0xbea1611f5fc0a1a1L;\n 0x0e8d1c8307918d8dL;\n 0xf43df5c97ac83d3dL;\n 0x6697ccf1335b9797L;\n 0x0000000000000000L;\n 0x1bcf36d483f9cfcfL;\n 0xac2b4587566e2b2bL;\n 0xc57697b3ece17676L;\n 0x328264b019e68282L;\n 0x7fd6fea9b128d6d6L;\n 0x6c1bd87736c31b1bL;\n 0xeeb5c15b7774b5b5L;\n 0x86af112943beafafL;\n 0xb56a77dfd41d6a6aL;\n 0x5d50ba0da0ea5050L;\n 0x0945124c8a574545L;\n 0xebf3cb18fb38f3f3L;\n 0xc0309df060ad3030L;\n 0x9bef2b74c3c4efefL;\n 0xfc3fe5c37eda3f3fL;\n 0x4955921caac75555L;\n 0xb2a2791059dba2a2L;\n 0x8fea0365c9e9eaeaL;\n 0x89650fecca6a6565L;\n 0xd2bab9686903babaL;\n 0xbc2f65935e4a2f2fL;\n 0x27c04ee79d8ec0c0L;\n 0x5fdebe81a160dedeL;\n 0x701ce06c38fc1c1cL;\n 0xd3fdbb2ee746fdfdL;\n 0x294d52649a1f4d4dL;\n 0x7292e4e039769292L;\n 0xc9758fbceafa7575L;\n 0x1806301e0c360606L;\n 0x128a249809ae8a8aL;\n 0xf2b2f940794bb2b2L;\n 0xbfe66359d185e6e6L;\n 0x380e70361c7e0e0eL;\n 0x7c1ff8633ee71f1fL;\n 0x956237f7c4556262L;\n 0x77d4eea3b53ad4d4L;\n 0x9aa829324d81a8a8L;\n 0x6296c4f431529696L;\n 0xc3f99b3aef62f9f9L;\n 0x33c566f697a3c5c5L;\n 0x942535b14a102525L;\n 0x7959f220b2ab5959L;\n 0x2a8454ae15d08484L;\n 0xd572b7a7e4c57272L;\n 0xe439d5dd72ec3939L;\n 0x2d4c5a6198164c4cL;\n 0x655eca3bbc945e5eL;\n 0xfd78e785f09f7878L;\n 0xe038ddd870e53838L;\n 0x0a8c148605988c8cL;\n 0x63d1c6b2bf17d1d1L;\n 0xaea5410b57e4a5a5L;\n 0xafe2434dd9a1e2e2L;\n 0x99612ff8c24e6161L;\n 0xf6b3f1457b42b3b3L;\n 0x842115a542342121L;\n 0x4a9c94d625089c9cL;\n 0x781ef0663cee1e1eL;\n 0x1143225286614343L;\n 0x3bc776fc93b1c7c7L;\n 0xd7fcb32be54ffcfcL;\n 0x1004201408240404L;\n 0x5951b208a2e35151L;\n 0x5e99bcc72f259999L;\n 0xa96d4fc4da226d6dL;\n 0x340d68391a650d0dL;\n 0xcffa8335e979fafaL;\n 0x5bdfb684a369dfdfL;\n 0xe57ed79bfca97e7eL;\n 0x90243db448192424L;\n 0xec3bc5d776fe3b3bL;\n 0x96ab313d4b9aababL;\n 0x1fce3ed181f0ceceL;\n 0x4411885522991111L;\n 0x068f0c8903838f8fL;\n 0x254e4a6b9c044e4eL;\n 0xe6b7d1517366b7b7L;\n 0x8beb0b60cbe0ebebL;\n 0xf03cfdcc78c13c3cL;\n 0x3e817cbf1ffd8181L;\n 0x6a94d4fe35409494L;\n 0xfbf7eb0cf31cf7f7L;\n 0xdeb9a1676f18b9b9L;\n 0x4c13985f268b1313L;\n 0xb02c7d9c58512c2cL;\n 0x6bd3d6b8bb05d3d3L;\n 0xbbe76b5cd38ce7e7L;\n 0xa56e57cbdc396e6eL;\n 0x37c46ef395aac4c4L;\n 0x0c03180f061b0303L;\n 0x45568a13acdc5656L;\n 0x0d441a49885e4444L;\n 0xe17fdf9efea07f7fL;\n 0x9ea921374f88a9a9L;\n 0xa82a4d8254672a2aL;\n 0xd6bbb16d6b0abbbbL;\n 0x23c146e29f87c1c1L;\n 0x5153a202a6f15353L;\n 0x57dcae8ba572dcdcL;\n 0x2c0b582716530b0bL;\n 0x4e9d9cd327019d9dL;\n 0xad6c47c1d82b6c6cL;\n 0xc43195f562a43131L;\n 0xcd7487b9e8f37474L;\n 0xfff6e309f115f6f6L;\n 0x05460a438c4c4646L;\n 0x8aac092645a5acacL;\n 0x1e893c970fb58989L;\n 0x5014a04428b41414L;\n 0xa3e15b42dfbae1e1L;\n 0x5816b04e2ca61616L;\n 0xe83acdd274f73a3aL;\n 0xb9696fd0d2066969L;\n 0x2409482d12410909L;\n 0xdd70a7ade0d77070L;\n 0xe2b6d954716fb6b6L;\n 0x67d0ceb7bd1ed0d0L;\n 0x93ed3b7ec7d6ededL;\n 0x17cc2edb85e2ccccL;\n 0x15422a5784684242L;\n 0x5a98b4c22d2c9898L;\n 0xaaa4490e55eda4a4L;\n 0xa0285d8850752828L;\n 0x6d5cda31b8865c5cL;\n 0xc7f8933fed6bf8f8L;\n 0x228644a411c28686L;\n |];\n [|\n 0x186018c07830d818L;\n 0x238c2305af462623L;\n 0xc63fc67ef991b8c6L;\n 0xe887e8136fcdfbe8L;\n 0x8726874ca113cb87L;\n 0xb8dab8a9626d11b8L;\n 0x0104010805020901L;\n 0x4f214f426e9e0d4fL;\n 0x36d836adee6c9b36L;\n 0xa6a2a6590451ffa6L;\n 0xd26fd2debdb90cd2L;\n 0xf5f3f5fb06f70ef5L;\n 0x79f979ef80f29679L;\n 0x6fa16f5fcede306fL;\n 0x917e91fcef3f6d91L;\n 0x525552aa07a4f852L;\n 0x609d6027fdc04760L;\n 0xbccabc89766535bcL;\n 0x9b569baccd2b379bL;\n 0x8e028e048c018a8eL;\n 0xa3b6a371155bd2a3L;\n 0x0c300c603c186c0cL;\n 0x7bf17bff8af6847bL;\n 0x35d435b5e16a8035L;\n 0x1d741de8693af51dL;\n 0xe0a7e05347ddb3e0L;\n 0xd77bd7f6acb321d7L;\n 0xc22fc25eed999cc2L;\n 0x2eb82e6d965c432eL;\n 0x4b314b627a96294bL;\n 0xfedffea321e15dfeL;\n 0x5741578216aed557L;\n 0x155415a8412abd15L;\n 0x77c1779fb6eee877L;\n 0x37dc37a5eb6e9237L;\n 0xe5b3e57b56d79ee5L;\n 0x9f469f8cd923139fL;\n 0xf0e7f0d317fd23f0L;\n 0x4a354a6a7f94204aL;\n 0xda4fda9e95a944daL;\n 0x587d58fa25b0a258L;\n 0xc903c906ca8fcfc9L;\n 0x29a429558d527c29L;\n 0x0a280a5022145a0aL;\n 0xb1feb1e14f7f50b1L;\n 0xa0baa0691a5dc9a0L;\n 0x6bb16b7fdad6146bL;\n 0x852e855cab17d985L;\n 0xbdcebd8173673cbdL;\n 0x5d695dd234ba8f5dL;\n 0x1040108050209010L;\n 0xf4f7f4f303f507f4L;\n 0xcb0bcb16c08bddcbL;\n 0x3ef83eedc67cd33eL;\n 0x05140528110a2d05L;\n 0x6781671fe6ce7867L;\n 0xe4b7e47353d597e4L;\n 0x279c2725bb4e0227L;\n 0x4119413258827341L;\n 0x8b168b2c9d0ba78bL;\n 0xa7a6a7510153f6a7L;\n 0x7de97dcf94fab27dL;\n 0x956e95dcfb374995L;\n 0xd847d88e9fad56d8L;\n 0xfbcbfb8b30eb70fbL;\n 0xee9fee2371c1cdeeL;\n 0x7ced7cc791f8bb7cL;\n 0x66856617e3cc7166L;\n 0xdd53dda68ea77bddL;\n 0x175c17b84b2eaf17L;\n 0x47014702468e4547L;\n 0x9e429e84dc211a9eL;\n 0xca0fca1ec589d4caL;\n 0x2db42d75995a582dL;\n 0xbfc6bf9179632ebfL;\n 0x071c07381b0e3f07L;\n 0xad8ead012347acadL;\n 0x5a755aea2fb4b05aL;\n 0x8336836cb51bef83L;\n 0x33cc3385ff66b633L;\n 0x6391633ff2c65c63L;\n 0x020802100a041202L;\n 0xaa92aa39384993aaL;\n 0x71d971afa8e2de71L;\n 0xc807c80ecf8dc6c8L;\n 0x196419c87d32d119L;\n 0x4939497270923b49L;\n 0xd943d9869aaf5fd9L;\n 0xf2eff2c31df931f2L;\n 0xe3abe34b48dba8e3L;\n 0x5b715be22ab6b95bL;\n 0x881a8834920dbc88L;\n 0x9a529aa4c8293e9aL;\n 0x2698262dbe4c0b26L;\n 0x32c8328dfa64bf32L;\n 0xb0fab0e94a7d59b0L;\n 0xe983e91b6acff2e9L;\n 0x0f3c0f78331e770fL;\n 0xd573d5e6a6b733d5L;\n 0x803a8074ba1df480L;\n 0xbec2be997c6127beL;\n 0xcd13cd26de87ebcdL;\n 0x34d034bde4688934L;\n 0x483d487a75903248L;\n 0xffdbffab24e354ffL;\n 0x7af57af78ff48d7aL;\n 0x907a90f4ea3d6490L;\n 0x5f615fc23ebe9d5fL;\n 0x2080201da0403d20L;\n 0x68bd6867d5d00f68L;\n 0x1a681ad07234ca1aL;\n 0xae82ae192c41b7aeL;\n 0xb4eab4c95e757db4L;\n 0x544d549a19a8ce54L;\n 0x937693ece53b7f93L;\n 0x2288220daa442f22L;\n 0x648d6407e9c86364L;\n 0xf1e3f1db12ff2af1L;\n 0x73d173bfa2e6cc73L;\n 0x124812905a248212L;\n 0x401d403a5d807a40L;\n 0x0820084028104808L;\n 0xc32bc356e89b95c3L;\n 0xec97ec337bc5dfecL;\n 0xdb4bdb9690ab4ddbL;\n 0xa1bea1611f5fc0a1L;\n 0x8d0e8d1c8307918dL;\n 0x3df43df5c97ac83dL;\n 0x976697ccf1335b97L;\n 0x0000000000000000L;\n 0xcf1bcf36d483f9cfL;\n 0x2bac2b4587566e2bL;\n 0x76c57697b3ece176L;\n 0x82328264b019e682L;\n 0xd67fd6fea9b128d6L;\n 0x1b6c1bd87736c31bL;\n 0xb5eeb5c15b7774b5L;\n 0xaf86af112943beafL;\n 0x6ab56a77dfd41d6aL;\n 0x505d50ba0da0ea50L;\n 0x450945124c8a5745L;\n 0xf3ebf3cb18fb38f3L;\n 0x30c0309df060ad30L;\n 0xef9bef2b74c3c4efL;\n 0x3ffc3fe5c37eda3fL;\n 0x554955921caac755L;\n 0xa2b2a2791059dba2L;\n 0xea8fea0365c9e9eaL;\n 0x6589650fecca6a65L;\n 0xbad2bab9686903baL;\n 0x2fbc2f65935e4a2fL;\n 0xc027c04ee79d8ec0L;\n 0xde5fdebe81a160deL;\n 0x1c701ce06c38fc1cL;\n 0xfdd3fdbb2ee746fdL;\n 0x4d294d52649a1f4dL;\n 0x927292e4e0397692L;\n 0x75c9758fbceafa75L;\n 0x061806301e0c3606L;\n 0x8a128a249809ae8aL;\n 0xb2f2b2f940794bb2L;\n 0xe6bfe66359d185e6L;\n 0x0e380e70361c7e0eL;\n 0x1f7c1ff8633ee71fL;\n 0x62956237f7c45562L;\n 0xd477d4eea3b53ad4L;\n 0xa89aa829324d81a8L;\n 0x966296c4f4315296L;\n 0xf9c3f99b3aef62f9L;\n 0xc533c566f697a3c5L;\n 0x25942535b14a1025L;\n 0x597959f220b2ab59L;\n 0x842a8454ae15d084L;\n 0x72d572b7a7e4c572L;\n 0x39e439d5dd72ec39L;\n 0x4c2d4c5a6198164cL;\n 0x5e655eca3bbc945eL;\n 0x78fd78e785f09f78L;\n 0x38e038ddd870e538L;\n 0x8c0a8c148605988cL;\n 0xd163d1c6b2bf17d1L;\n 0xa5aea5410b57e4a5L;\n 0xe2afe2434dd9a1e2L;\n 0x6199612ff8c24e61L;\n 0xb3f6b3f1457b42b3L;\n 0x21842115a5423421L;\n 0x9c4a9c94d625089cL;\n 0x1e781ef0663cee1eL;\n 0x4311432252866143L;\n 0xc73bc776fc93b1c7L;\n 0xfcd7fcb32be54ffcL;\n 0x0410042014082404L;\n 0x515951b208a2e351L;\n 0x995e99bcc72f2599L;\n 0x6da96d4fc4da226dL;\n 0x0d340d68391a650dL;\n 0xfacffa8335e979faL;\n 0xdf5bdfb684a369dfL;\n 0x7ee57ed79bfca97eL;\n 0x2490243db4481924L;\n 0x3bec3bc5d776fe3bL;\n 0xab96ab313d4b9aabL;\n 0xce1fce3ed181f0ceL;\n 0x1144118855229911L;\n 0x8f068f0c8903838fL;\n 0x4e254e4a6b9c044eL;\n 0xb7e6b7d1517366b7L;\n 0xeb8beb0b60cbe0ebL;\n 0x3cf03cfdcc78c13cL;\n 0x813e817cbf1ffd81L;\n 0x946a94d4fe354094L;\n 0xf7fbf7eb0cf31cf7L;\n 0xb9deb9a1676f18b9L;\n 0x134c13985f268b13L;\n 0x2cb02c7d9c58512cL;\n 0xd36bd3d6b8bb05d3L;\n 0xe7bbe76b5cd38ce7L;\n 0x6ea56e57cbdc396eL;\n 0xc437c46ef395aac4L;\n 0x030c03180f061b03L;\n 0x5645568a13acdc56L;\n 0x440d441a49885e44L;\n 0x7fe17fdf9efea07fL;\n 0xa99ea921374f88a9L;\n 0x2aa82a4d8254672aL;\n 0xbbd6bbb16d6b0abbL;\n 0xc123c146e29f87c1L;\n 0x535153a202a6f153L;\n 0xdc57dcae8ba572dcL;\n 0x0b2c0b582716530bL;\n 0x9d4e9d9cd327019dL;\n 0x6cad6c47c1d82b6cL;\n 0x31c43195f562a431L;\n 0x74cd7487b9e8f374L;\n 0xf6fff6e309f115f6L;\n 0x4605460a438c4c46L;\n 0xac8aac092645a5acL;\n 0x891e893c970fb589L;\n 0x145014a04428b414L;\n 0xe1a3e15b42dfbae1L;\n 0x165816b04e2ca616L;\n 0x3ae83acdd274f73aL;\n 0x69b9696fd0d20669L;\n 0x092409482d124109L;\n 0x70dd70a7ade0d770L;\n 0xb6e2b6d954716fb6L;\n 0xd067d0ceb7bd1ed0L;\n 0xed93ed3b7ec7d6edL;\n 0xcc17cc2edb85e2ccL;\n 0x4215422a57846842L;\n 0x985a98b4c22d2c98L;\n 0xa4aaa4490e55eda4L;\n 0x28a0285d88507528L;\n 0x5c6d5cda31b8865cL;\n 0xf8c7f8933fed6bf8L;\n 0x86228644a411c286L;\n |];\n |]\n\n let whirlpool_do_chunk :\n type a. be64_to_cpu:(a -> int -> int64) -> ctx -> a -> int -> unit =\n fun ~be64_to_cpu ctx buf off ->\n let key = Array.init 2 (fun _ -> Array.make 8 Int64.zero) in\n let state = Array.init 2 (fun _ -> Array.make 8 Int64.zero) in\n let m = ref 0 in\n let rc =\n [|\n 0x1823c6e887b8014fL;\n 0x36a6d2f5796f9152L;\n 0x60bc9b8ea30c7b35L;\n 0x1de0d7c22e4bfe57L;\n 0x157737e59ff04adaL;\n 0x58c9290ab1a06b85L;\n 0xbd5d10f4cb3e0567L;\n 0xe427418ba77d95d8L;\n 0xfbee7c66dd17479eL;\n 0xca2dbf07ad5a8333L;\n |] in\n for i = 0 to 7 do\n key.(0).(i) <- ctx.h.(i) ;\n let off = off + (i * 8) in\n state.(0).(i) <- Int64.(be64_to_cpu buf off lxor ctx.h.(i)) ;\n ctx.h.(i) <- state.(0).(i)\n done ;\n let wp_op src shift =\n let mask v = Int64.(to_int (v land 0xffL)) in\n let get_k i =\n k.(i).(mask\n (Int64.shift_right src.((shift + 8 - i) land 7) (56 - (8 * i))))\n in\n Array.fold_left Int64.logxor Int64.zero (Array.init 8 get_k) in\n for i = 0 to 9 do\n let m0, m1 = (!m, !m lxor 1) in\n let upd_key i = key.(m1).(i) <- wp_op key.(m0) i in\n let upd_state i =\n state.(m1).(i) <- Int64.(wp_op state.(m0) i lxor key.(m1).(i)) in\n for i = 0 to 7 do\n upd_key i\n done ;\n key.(m1).(0) <- Int64.(key.(m1).(0) lxor rc.(i)) ;\n for i = 0 to 7 do\n upd_state i\n done ;\n m := !m lxor 1\n done ;\n let upd_hash i = Int64.(ctx.h.(i) <- ctx.h.(i) lxor state.(0).(i)) in\n for i = 0 to 7 do\n upd_hash i\n done ;\n ()\n\n let feed :\n type a.\n blit:(a -> int -> By.t -> int -> int -> unit) ->\n be64_to_cpu:(a -> int -> int64) ->\n ctx ->\n a ->\n int ->\n int ->\n unit =\n fun ~blit ~be64_to_cpu ctx buf off len ->\n let idx = ref Int64.(to_int (ctx.size land 0x3FL)) in\n let len = ref len in\n let off = ref off in\n let to_fill = 64 - !idx in\n ctx.size <- Int64.add ctx.size (Int64.of_int !len) ;\n if !idx <> 0 && !len >= to_fill\n then (\n blit buf !off ctx.b !idx to_fill ;\n whirlpool_do_chunk ~be64_to_cpu:By.be64_to_cpu ctx ctx.b 0 ;\n len := !len - to_fill ;\n off := !off + to_fill ;\n idx := 0) ;\n while !len >= 64 do\n whirlpool_do_chunk ~be64_to_cpu ctx buf !off ;\n len := !len - 64 ;\n off := !off + 64\n done ;\n if !len <> 0 then blit buf !off ctx.b !idx !len ;\n ()\n\n let unsafe_feed_bytes = feed ~blit:By.blit ~be64_to_cpu:By.be64_to_cpu\n\n let unsafe_feed_bigstring =\n feed ~blit:By.blit_from_bigstring ~be64_to_cpu:Bi.be64_to_cpu\n\n let unsafe_get ctx =\n let index = Int64.(to_int (ctx.size land 0x3FL)) + 1 in\n By.set ctx.b (index - 1) '\\x80' ;\n if index > 32\n then (\n By.fill ctx.b index (64 - index) '\\x00' ;\n whirlpool_do_chunk ~be64_to_cpu:By.be64_to_cpu ctx ctx.b 0 ;\n By.fill ctx.b 0 56 '\\x00')\n else By.fill ctx.b index (56 - index) '\\x00' ;\n By.cpu_to_be64 ctx.b 56 Int64.(ctx.size lsl 3) ;\n whirlpool_do_chunk ~be64_to_cpu:By.be64_to_cpu ctx ctx.b 0 ;\n let res = By.create (8 * 8) in\n for i = 0 to 7 do\n By.cpu_to_be64 res (i * 8) ctx.h.(i)\n done ;\n res\nend\n","# 1 \"src/digestif_eq.ml\"\nmodule Make (D : sig\n val digest_size : int\nend) =\nstruct\n let _ = D.digest_size\n\n let equal a b = Eqaf.equal a b\n\n let unsafe_compare a b = String.compare a b\nend\n","let[@inline always] char_chr ch =\n (* Char.chr contains a branch on [ch] and a plt indirection, this\n * implementation ensures well-formedness by construction and avoids that: *)\n Char.unsafe_chr (ch land 0xff)\n\nlet[@inline] get x i = String.unsafe_get x i |> Char.code\n\n(* XXX(dinosaure): we use [unsafe_get] to avoid jump to exception:\n\n sarq $1, %rbx\n movzbq (%rax,%rbx), %rax\n leaq 1(%rax,%rax), %rax\n ret\n*)\n\nexternal unsafe_get_int16 : string -> int -> int = \"%caml_string_get16u\"\nlet[@inline] get16 x i = unsafe_get_int16 x i\n\n(* XXX(dinosaure): same as [unsafe_get] but for [int16]:\n\n sarq $1, %rbx\n movzwq (%rax,%rbx), %rax\n leaq 1(%rax,%rax), %rax\n ret\n*)\n\nlet equal ~ln a b =\n let l1 = ln asr 1 in\n\n (*\n sarq $1, %rcx\n orq $1, %rcx\n *)\n\n let r = ref 0 in\n\n (*\n movq $1, %rdx\n *)\n\n for i = 0 to pred l1 do r := !r lor (get16 a (i * 2) lxor get16 b (i * 2)) done ;\n\n (*\n movq $1, %rsi\n addq $-2, %rcx\n cmpq %rcx, %rsi\n jg .L104\n.L105:\n leaq -1(%rsi,%rsi), %r8\n\n sarq $1, %r8\n movzwq (%rdi,%r8), %r9\n leaq 1(%r9,%r9), %r9\n movzwq (%rbx,%r8), %r8\n leaq 1(%r8,%r8), %r8\n\n // [unsafe_get_int16 a i] and [unsafe_get_int6 b i]\n\n xorq %r9, %r8\n orq $1, %r8\n orq %r8, %rdx\n movq %rsi, %r8\n addq $2, %rsi\n cmpq %rcx, %r8\n jne .L105\n.L104:\n *)\n\n for _ = 1 to ln land 1 do r := !r lor (get a (ln - 1) lxor get b (ln - 1)) done ;\n\n (*\n movq $3, %rsi\n movq %rax, %rcx\n andq $3, %rcx\n cmpq %rcx, %rsi\n jg .L102\n.L103:\n movq %rax, %r8\n addq $-2, %r8\n\n sarq $1, %r8\n movzbq (%rdi,%r8), %r9\n leaq 1(%r9,%r9), %r9\n movzbq (%rbx,%r8), %r8\n leaq 1(%r8,%r8), %r8\n\n // [unsafe_get a i] and [unsafe_get b i]\n\n xorq %r9, %r8\n orq $1, %r8\n orq %r8, %rdx\n movq %rsi, %r8\n addq $2, %rsi\n cmpq %rcx, %r8\n jne .L103\n.L102:\n *)\n\n !r = 0\n\n(*\n cmpq $1, %rdx\n sete %al\n movzbq %al, %rax\n leaq 1(%rax,%rax), %rax\n ret\n*)\n\nlet equal a b =\n let al = String.length a in\n let bl = String.length b in\n if al <> bl\n then false\n else equal ~ln:al a b\n\nlet[@inline always] compare (a:int) b = a - b\nlet[@inline always] sixteen_if_minus_one_or_less n = (n asr Sys.int_size) land 16\nlet[@inline always] eight_if_one_or_more n = ((-n) asr Sys.int_size) land 8\n\nlet compare_le ~ln a b =\n let r = ref 0 in\n let i = ref (pred ln) in\n\n while !i >= 0 do\n let xa = get a !i and xb = get b !i in\n let c = compare xa xb in\n r := !r lor ((sixteen_if_minus_one_or_less c + eight_if_one_or_more c) lsr !r) ;\n decr i ;\n done ;\n\n (!r land 8) - (!r land 16)\n\nlet compare_le_with_len ~len:ln a b =\n let al = String.length a in\n let bl = String.length b in\n if ln = 0 then 0\n else if (al lxor ln) lor (bl lxor ln) <> 0\n then invalid_arg \"compare_le_with_len\"\n else compare_le ~ln a b\n\nlet compare_le a b =\n let al = String.length a in\n let bl = String.length b in\n if al < bl\n then 1\n else if al > bl\n then (-1)\n else compare_le ~ln:al (* = bl *) a b\n\nlet compare_be ~ln a b =\n let r = ref 0 in\n let i = ref 0 in\n\n while !i < ln do\n let xa = get a !i and xb = get b !i in\n let c = compare xa xb in\n r := !r lor ((sixteen_if_minus_one_or_less c + eight_if_one_or_more c) lsr !r) ;\n incr i ;\n done ;\n\n (!r land 8) - (!r land 16)\n\nlet compare_be_with_len ~len:ln a b =\n let al = String.length a in\n let bl = String.length b in\n if ln = 0 then 0\n else if (al lxor ln) lor (bl lxor ln) <> 0\n then invalid_arg \"compare_be_with_len\"\n else compare_be ~ln a b\n\nlet compare_be a b =\n let al = String.length a in\n let bl = String.length b in\n if al < bl then 1\n else if al > bl then (-1)\n else compare_be ~ln:al (* = bl *) a b\n\nlet[@inline always] minus_one_or_less n =\n n lsr (Sys.int_size - 1)\n\nlet[@inline always] one_if_not_zero n =\n minus_one_or_less ((- n) lor n)\n\nlet[@inline always] zero_if_not_zero n =\n (one_if_not_zero n) - 1\n\nlet[@inline always] select_int choose_b a b =\n let mask = ((- choose_b) lor choose_b) asr Sys.int_size in\n (a land (lnot mask)) lor (b land mask)\n\nexternal int_of_bool : bool -> int = \"%identity\"\nexternal unsafe_bool_of_int : int -> bool = \"%identity\"\n\nlet[@inline] bool_of_int n =\n unsafe_bool_of_int (one_if_not_zero n)\n\nlet[@inline always] find_uint8 ~off ~len ~f str =\n let i = ref (len - 1) in\n let a = ref (lnot 0) in\n while !i >= off do\n let byte = get str !i in\n let pred = int_of_bool (f byte) in\n (* XXX(dinosaure): a composition of [f] with [bool_of_int] such as\n [let f = bool_of_int <.> f in] implies an allocation (of a closure).\n To be GC-free, we must store result of [f] into a register, and apply\n [bool_of_int] then (introspection was done on OCaml 4.08.1). *)\n a := select_int (((!i - off) land min_int) lor pred) !a !i ;\n decr i ;\n done ; !a\n\nlet find_uint8 ?(off= 0) ~f str =\n (* XXX(dinosaure): with this overload, OCaml is able to produce 2 [find_uint8].\n One with [off= 0] and one other where [off] is an argument. I think it's about\n cross-module optimization where a call to [find_uint8 ~f v] will directly call\n the first one and a call to [find_uint8 ~off:x ~f v] will call the second one. *)\n let len = String.length str in\n find_uint8 ~off ~len ~f str\n\nlet exists_uint8 ?off ~f str =\n let v = find_uint8 ?off ~f str in\n let r = select_int (v + 1) 0 1 in\n unsafe_bool_of_int r\n\nlet divmod ~(x:int32) ~(m:int32) : int32 * int32 =\n (* Division and remainder being constant-time with respect to [x]\n * ( NOT [m] !). The OCaml variant would be:\n * [(x / m , x mod m)] where [x] is a secret and [m] is not secret.\n * Adapted from the NTRU Prime team's algorithm from\n * supercop/crypto_kem/sntrup761/ref/uint32.c\n * cite the round-2 ntru prime submission to nistpqc (march 2019)\n * Note that in practice this works for at least some much larger [x] and [m],\n * but it's unclear to me how to evaluate *which*, so leaving the original\n * restrictions in.\n *)\n let ( - ) , ( + ), ( * ) = Int32.(sub, add, mul) in\n let ( >> ) = Int32.shift_right_logical in\n if (m <= 0l) then raise (Invalid_argument \"m <= 0\") ;\n if (m >= 16348l) then raise (Invalid_argument \"m >= 16348 not supported\") ;\n\n let of_uint32 uint =\n (* apparently Int64.of_int32 sign-extends ... great... avoid that: *)\n let b = Bytes.make 8 '\\x00' in\n Unsafe.set_int32_le b 0 uint ;\n Unsafe.get_int64_le b 0\n in\n\n let x_0 = x in\n\n let x_2, q_1 =\n let int32_div_unsigned n d =\n (* can be replaced by Int32.unsigned_div\n * from OCaml >= 4.10 *)\n let sub,min_int = Int32.(sub,min_int)in\n let int32_unsigned_compare n m =\n Int32.compare (sub n min_int) (sub m min_int)\n in\n if d < 0_l then\n if int32_unsigned_compare n d < 0 then 0_l else 1_l\n else\n let q =\n let open Int32 in\n shift_left (Int32.div (Int32.shift_right_logical n 1) d) 1 in\n let r = sub n (Int32.mul q d) in\n if int32_unsigned_compare r d >= 0 then Int32.succ q else q\n in\n let v = int32_div_unsigned Int32.min_int m |> of_uint32 in\n (*let v = 0x80_00_00_00 / m in*) (* floored div *)\n let x_1, q_0 =\n let qpart_0 =\n let open Int64 in\n shift_right_logical (mul (of_uint32 x_0) v) 31\n |> to_int32\n in\n x_0 - (qpart_0 * m), qpart_0\n in\n let qpart_1 =\n let open Int64 in\n shift_right_logical (mul (of_uint32 x_1) v) 31\n |> to_int32 in\n x_1 - (qpart_1 * m),\n (q_0 + qpart_1 + 1l) in\n let x_3 = x_2 - m in\n let mask = 0l - (x_3 >> 31) in\n q_1 + mask, x_3 + (Int32.logand mask m)\n\nlet ascii_of_int32 ~digits (n:int32) : string =\n (* Recursively calls [divmod n 10]; the remainder is turned into ASCII\n and the quotient is used for the next division.*)\n if digits < 0 then raise (Invalid_argument \"digits < 0\");\n let out = Bytes.make digits '0' in\n let rec loop x = function\n | -1 -> Bytes.unsafe_to_string out\n | idx ->\n let next, this = divmod ~x ~m:10l in\n Bytes.set out idx @@ char_chr (0x30 lor (Int32.to_int this)) ;\n loop next (pred idx)\n in loop n (pred digits)\n\nlet[@inline always] to_hex_nibble f : char =\n let a = 86 + f in\n let c = 1 + ((a - 71 * ((a land 0x10) lsr 4)) lor 0x20) in\n char_chr c\n\nlet hex_of_string rawbytes =\n String.init (2 * String.length rawbytes)\n (fun idx ->\n let byt = String.get rawbytes (idx lsr 1) |> Char.code in\n (* select which 4 bits to use, this can probably be done faster:*)\n let nib = 0xf land (byt lsr (((lnot idx) land 1) lsl 2)) in\n to_hex_nibble nib)\n\nlet hex_of_bytes rawbytes = hex_of_string (Bytes.unsafe_to_string rawbytes)\n\nlet[@inline always] select_a_if_in_range ~low ~high ~n a b =\n (* select [a] if [low <= n <= high] and [b] if [n] is out of range.*)\n (* NB: ONLY WORKS FOR [0 <= low <= high <= max_int]*)\n (* The idea being that:\n 1.a) if low <= n : (n - low) is positive +\n 1.b) if low > n : (n - low) is negative -\n 2.a) if n <= high: (high - n) is positive +\n 2.b) if n > high: (high - n) is negative -\n We OR the numbers together; we only really care about the sign bit\n which is set when negative.\n Thus both numbers are positive iff (low <= n && n <= high).\n We then select the sign bit with (land min_int) and use that to choose:\n *)\n let out_of_range = (* choose b if out of range *)\n ((n - low) lor (high - n)\n land min_int)\n in\n select_int out_of_range a b\n\nlet lowercase_ascii src =\n (* ct version of String.lowercase_ascii *)\n String.map\n ( fun ch -> let n = Char.code ch in\n (* 0x41 is 'A'; 0x5a is 'Z'; 0x20 controls case for ASCII letters *)\n select_a_if_in_range ~low:0x41 ~high:0x5a ~n (n lor 0x20) (n)\n |> char_chr\n ) src\n\nlet uppercase_ascii src =\n (* ct version of String.uppercase_ascii *)\n String.map\n ( fun ch -> let n = Char.code ch in\n (* 0x61 is 'a'; 0x7a is 'z'; 0x20 controls case for ASCII letters *)\n select_a_if_in_range ~low:0x61 ~high:0x7a ~n (n lxor 0x20) (n)\n |> char_chr\n ) src\n\nlet bytes_of_hex rawhex =\n (* hex length must be multiple of 2: *)\n let error_bitmap = ref ((String.length rawhex land 1) lsl 4) in\n let decoded =\n Bytes.init (String.length rawhex lsr 1)\n (fun idx ->\n let idx = idx lsl 1 in\n let nib idx =\n String.get rawhex idx\n |> Char.code\n |> fun n -> (* uppercase -> lowercase: *)\n select_a_if_in_range ~low:0x41 ~high:0x5a\n ~n\n (n lor 0x20) (* set case bit *)\n n (* leave as-is *)\n |> fun n -> (* now either invalid; lowercase; numeric*)\n (select_a_if_in_range ~low:0x30 ~high:0x39\n ~n\n (n - 0x30) (* numeric: subtract '0' to get [0..9] *)\n (select_a_if_in_range ~low:0x61 ~high:0x66\n ~n\n (* a-f: subtract 'a' and add 10 to get [10..15]: *)\n (n - 0x61 + 10)\n (0xff) (* invalid, ensure we set upper bits of error_bitmap *)\n )\n )\n in\n let nibf0 = nib idx\n and nib0f = nib (succ idx) in\n error_bitmap := !error_bitmap lor nibf0 lor nib0f ;\n char_chr ((nibf0 lsl 4) lor nib0f)\n )\n in\n (* if any non-nibble bits were set in !error_bitmap, decoding failed: *)\n decoded, !error_bitmap land (lnot 0xf)\n\nlet string_of_hex rawhex =\n let byt, error = bytes_of_hex rawhex in\n Bytes.unsafe_to_string byt, error\n","open Core_kernel\nopen Async_kernel\n\n[%%import \"/src/config.mlh\"]\n\nmodule Spec = struct\n type t =\n | On_disk of { directory : string; should_write : bool }\n | S3 of { bucket_prefix : string; install_path : string }\nend\n\n[%%inject \"may_download\", download_snark_keys]\n\nlet may_download = ref may_download\n\nlet set_downloads_enabled b = may_download := b\n\nlet may_download () = !may_download\n\nmodule T (M : sig\n type _ t\nend) =\nstruct\n type ('a, 'b) t = { write : 'a -> 'b -> unit M.t; read : 'a -> 'b M.t }\nend\n\nmodule Disk_storable (M : sig\n type _ t\nend) =\nstruct\n type ('k, 'v) t =\n { to_string : 'k -> string\n ; read : 'k -> path:string -> 'v M.t\n ; write : 'k -> 'v -> string -> unit M.t\n }\nend\n\nmodule type S = sig\n module M : sig\n type _ t\n end\n\n type ('a, 'b) t = ('a, 'b) T(M).t =\n { write : 'a -> 'b -> unit M.t; read : 'a -> 'b M.t }\n\n module Disk_storable : sig\n type ('k, 'v) t = ('k, 'v) Disk_storable(M).t =\n { to_string : 'k -> string\n ; read : 'k -> path:string -> 'v M.t\n ; write : 'k -> 'v -> string -> unit M.t\n }\n\n val of_binable :\n ('k -> string) -> (module Binable.S with type t = 'v) -> ('k, 'v) t\n\n val simple :\n ('k -> string)\n -> ('k -> path:string -> 'v M.t)\n -> ('k -> 'v -> string -> unit M.t)\n -> ('k, 'v) t\n end\n\n val read :\n Spec.t list\n -> ('k, 'v) Disk_storable.t\n -> 'k\n -> ('v * [> `Cache_hit | `Locally_generated ]) M.t\n\n val write : Spec.t list -> ('k, 'v) Disk_storable.t -> 'k -> 'v -> unit M.t\nend\n\nmodule type Sync = S with module M := Or_error\n\nmodule type Async = S with module M := Deferred.Or_error\n\nmodule Trivial : Sync = struct\n include T (Or_error)\n\n module Disk_storable = struct\n include Disk_storable (Or_error)\n\n let of_binable to_string _m =\n let read _ ~path:_ =\n Or_error.error_string \"Key_cache: Trivial store cannot read\"\n in\n let write _k _t _path = Ok () in\n { to_string; read; write }\n\n let simple to_string read write = { to_string; read; write }\n end\n\n let read _spec { Disk_storable.to_string = _; read = _; write = _ } _k =\n Or_error.error_string \"Key_cache: Trivial store cannot read\"\n\n let write _spec { Disk_storable.to_string = _; read = _; write = _ } _k _v =\n Ok ()\nend\n\nmodule Trivial_async : Async = struct\n include T (Deferred.Or_error)\n\n module Disk_storable = struct\n include Disk_storable (Deferred.Or_error)\n\n let of_binable to_string _m =\n let read _ ~path:_ =\n Deferred.Or_error.error_string \"Key_cache: Trivial store cannot read\"\n in\n let write _k _t _path = Deferred.Or_error.return () in\n { to_string; read; write }\n\n let simple to_string read write = { to_string; read; write }\n end\n\n let read _spec { Disk_storable.to_string = _; read = _; write = _ } _k =\n Deferred.Or_error.error_string \"Key_cache: Trivial store cannot read\"\n\n let write _spec { Disk_storable.to_string = _; read = _; write = _ } _k _v =\n Deferred.Or_error.return ()\nend\n\nlet sync = ref (module Trivial : Sync)\n\nlet async = ref (module Trivial_async : Async)\n\nlet set_sync_implementation x = sync := x\n\nlet set_async_implementation x = async := x\n\nmodule Sync : Sync = struct\n include T (Or_error)\n\n module Disk_storable = struct\n include Disk_storable (Or_error)\n\n let of_binable to_string binable =\n let (module M) = !sync in\n M.Disk_storable.of_binable to_string binable\n\n let simple to_string read write =\n let (module M) = !sync in\n M.Disk_storable.simple to_string read write\n end\n\n let read spec ds k =\n let (module M) = !sync in\n M.read spec ds k\n\n let write spec ds k v =\n let (module M) = !sync in\n M.write spec ds k v\nend\n\nmodule Async : Async = struct\n include T (Deferred.Or_error)\n\n module Disk_storable = struct\n include Disk_storable (Deferred.Or_error)\n\n let of_binable to_string binable =\n let (module M) = !async in\n M.Disk_storable.of_binable to_string binable\n\n let simple to_string read write =\n let (module M) = !async in\n M.Disk_storable.simple to_string read write\n end\n\n let read spec ds k =\n let (module M) = !async in\n M.read spec ds k\n\n let write spec ds k v =\n let (module M) = !async in\n M.write spec ds k v\nend\n","open Core_kernel\n\nmodule Partial = struct\n module Bin_io (M : Intf.Input.Bin_io_intf) :\n Intf.Partial.Bin_io_intf with type t := M.t = struct\n open Bin_prot.Type_class\n\n let bin_size_t = M.bin_size_t\n\n let bin_write_t = M.bin_write_t\n\n let bin_read_t buf ~pos_ref =\n Table.attach_finalizer M.id (M.bin_read_t buf ~pos_ref)\n\n let __bin_read_t__ buf ~pos_ref i =\n Table.attach_finalizer M.id (M.__bin_read_t__ buf ~pos_ref i)\n\n let bin_shape_t = M.bin_shape_t\n\n let bin_writer_t = M.bin_writer_t\n\n let bin_reader_t = { read = bin_read_t; vtag_read = __bin_read_t__ }\n\n let bin_t =\n { shape = bin_shape_t; writer = bin_writer_t; reader = bin_reader_t }\n end\n\n module Sexp (M : Intf.Input.Sexp_intf) :\n Intf.Partial.Sexp_intf with type t := M.t = struct\n let sexp_of_t = M.sexp_of_t\n\n let t_of_sexp t = Table.attach_finalizer M.id (M.t_of_sexp t)\n end\n\n module Yojson (M : Intf.Input.Yojson_intf) :\n Intf.Partial.Yojson_intf with type t := M.t = struct\n let to_yojson = M.to_yojson\n\n let of_yojson json =\n M.of_yojson json |> Result.map ~f:(Table.attach_finalizer M.id)\n end\nend\n\nmodule Basic (M : Intf.Input.Basic_intf) :\n Intf.Output.Basic_intf with type t = M.t and type 'a creator := 'a M.creator =\nstruct\n type t = M.t\n\n let create = M.map_creator M.create ~f:(Table.attach_finalizer M.id)\nend\n\nmodule Bin_io (M : Intf.Input.Bin_io_intf) :\n Intf.Output.Bin_io_intf with type t = M.t and type 'a creator := 'a M.creator =\nstruct\n include Basic (M)\n include Partial.Bin_io (M)\nend\n\nmodule Sexp (M : Intf.Input.Sexp_intf) :\n Intf.Output.Sexp_intf with type t = M.t and type 'a creator := 'a M.creator =\nstruct\n include Basic (M)\n include Partial.Sexp (M)\nend\n\nmodule Bin_io_and_sexp (M : Intf.Input.Bin_io_and_sexp_intf) :\n Intf.Output.Bin_io_and_sexp_intf\n with type t = M.t\n and type 'a creator := 'a M.creator = struct\n include Basic (M)\n include Partial.Bin_io (M)\n include Partial.Sexp (M)\nend\n\nmodule Yojson (M : Intf.Input.Yojson_intf) :\n Intf.Output.Yojson_intf with type t = M.t and type 'a creator := 'a M.creator =\nstruct\n include Basic (M)\n include Partial.Yojson (M)\nend\n\nmodule Bin_io_and_yojson (M : Intf.Input.Bin_io_and_yojson_intf) :\n Intf.Output.Bin_io_and_yojson_intf\n with type t = M.t\n and type 'a creator := 'a M.creator = struct\n include Basic (M)\n include Partial.Bin_io (M)\n include Partial.Yojson (M)\nend\n\nmodule Full (M : Intf.Input.Full_intf) :\n Intf.Output.Full_intf with type t = M.t and type 'a creator := 'a M.creator =\nstruct\n include Basic (M)\n include Partial.Bin_io (M)\n include Partial.Sexp (M)\n include Partial.Yojson (M)\nend\n\nmodule Versioned_v1 = struct\n module Basic_intf (M : Intf.Input.Versioned_v1.Basic_intf) : sig\n include\n Intf.Output.Versioned_v1.Basic_intf\n with type Stable.V1.t = M.Stable.V1.t\n and type 'a Stable.V1.creator = 'a M.Stable.V1.creator\n end = struct\n module Stable = struct\n module V1 = struct\n include Bin_io (struct\n let id = M.id\n\n include M.Stable.V1\n end)\n\n let __versioned__ = ()\n\n type 'a creator = 'a M.Stable.V1.creator\n end\n\n module Latest = V1\n end\n\n type t = Stable.V1.t\n end\n\n module Sexp (M : Intf.Input.Versioned_v1.Sexp_intf) : sig\n include\n Intf.Output.Versioned_v1.Sexp_intf\n with type Stable.V1.t = M.Stable.V1.t\n and type 'a Stable.V1.creator = 'a M.Stable.V1.creator\n end = struct\n module Stable = struct\n module V1 = struct\n include Bin_io_and_sexp (struct\n let id = M.id\n\n include M.Stable.V1\n end)\n\n let __versioned__ = ()\n\n type 'a creator = 'a M.Stable.V1.creator\n end\n\n module Latest = V1\n end\n\n type t = Stable.V1.t\n end\n\n module Yojson (M : Intf.Input.Versioned_v1.Yojson_intf) : sig\n include\n Intf.Output.Versioned_v1.Yojson_intf\n with type Stable.V1.t = M.Stable.V1.t\n and type 'a Stable.V1.creator = 'a M.Stable.V1.creator\n end = struct\n module Stable = struct\n module V1 = struct\n include Bin_io_and_yojson (struct\n let id = M.id\n\n include M.Stable.V1\n end)\n\n let __versioned__ = ()\n\n type 'a creator = 'a M.Stable.V1.creator\n end\n\n module Latest = V1\n end\n\n type t = Stable.V1.t\n end\n\n module Full_compare_eq_hash\n (M : Intf.Input.Versioned_v1.Full_compare_eq_hash_intf) : sig\n include\n Intf.Output.Versioned_v1.Full_compare_eq_hash_intf\n with type Stable.V1.t = M.Stable.V1.t\n and type 'a Stable.V1.creator = 'a M.Stable.V1.creator\n end = struct\n module Stable = struct\n module V1 = struct\n include Full (struct\n let id = M.id\n\n include M.Stable.V1\n end)\n\n let compare = M.Stable.V1.compare\n\n let equal = M.Stable.V1.equal\n\n let hash = M.Stable.V1.hash\n\n let hash_fold_t = M.Stable.V1.hash_fold_t\n\n let __versioned__ = ()\n\n type 'a creator = 'a M.Stable.V1.creator\n end\n\n module Latest = V1\n end\n\n type t = Stable.V1.t\n\n let equal = M.equal\n\n let compare = M.compare\n\n let hash = M.hash\n\n let hash_fold_t = M.hash_fold_t\n end\n\n module Full (M : Intf.Input.Versioned_v1.Full_intf) : sig\n include\n Intf.Output.Versioned_v1.Full_intf\n with type Stable.V1.t = M.Stable.V1.t\n and type 'a Stable.V1.creator = 'a M.Stable.V1.creator\n end = struct\n module Stable = struct\n module V1 = struct\n include Full (struct\n let id = M.id\n\n include M.Stable.V1\n end)\n\n let __versioned__ = ()\n\n type 'a creator = 'a M.Stable.V1.creator\n end\n\n module Latest = V1\n end\n\n type t = Stable.V1.t\n end\nend\n\nmodule Versioned_v2 = struct\n module Sexp (M : Intf.Input.Versioned_v2.Sexp_intf) : sig\n include\n Intf.Output.Versioned_v2.Sexp_intf\n with type Stable.V2.t = M.Stable.V2.t\n and type 'a Stable.V2.creator = 'a M.Stable.V2.creator\n and type Stable.V1.t = M.Stable.V1.t\n and type 'a Stable.V1.creator = 'a M.Stable.V1.creator\n end = struct\n module Stable = struct\n module V2 = struct\n include Bin_io_and_sexp (struct\n let id = M.id\n\n include M.Stable.V2\n end)\n\n let __versioned__ = ()\n\n type 'a creator = 'a M.Stable.V2.creator\n end\n\n module V1 = struct\n include Bin_io_and_sexp (struct\n let id = M.id\n\n include M.Stable.V1\n end)\n\n let __versioned__ = ()\n\n type 'a creator = 'a M.Stable.V1.creator\n\n let to_latest = M.Stable.V1.to_latest\n end\n\n module Latest = V2\n end\n\n type t = Stable.V2.t\n end\nend\n","type 'a t\n\nexternal run_in_thread : (unit -> 'a) -> 'a t = \"deferred_run\"\n\nlet block_on_async_exn (_ : unit -> 'a t) : 'a =\n failwith \"You can't block on async execution in JS\"\n\nexternal map : 'a t -> f:('a -> 'b) -> 'b t = \"deferred_map\"\n\nexternal bind : 'a t -> f:('a -> 'b t) -> 'b t = \"deferred_bind\"\n\nexternal upon : 'a t -> ('a -> unit) -> unit = \"deferred_upon\"\n\nexternal upon_exn : 'a t -> ('a -> unit) -> unit = \"deferred_upon_exn\"\n\nexternal is_determined : 'a t -> bool = \"deferred_is_determined\"\n\nexternal peek : 'a t -> 'a option = \"deferred_peek\"\n\nexternal value_exn : 'a t -> 'a = \"deferred_value_exn\"\n\nexternal return : 'a -> 'a t = \"deferred_return\"\n\nexternal create : (('a -> unit) -> unit) -> 'a t = \"deferred_create\"\n\nlet to_deferred promise =\n let module Ivar = Async_kernel.Ivar in\n let ivar = Ivar.create () in\n upon_exn promise (fun x -> Ivar.fill ivar x) ;\n Ivar.read ivar\n\ninclude Base.Monad.Make (struct\n type nonrec 'a t = 'a t\n\n let map = `Custom map\n\n let bind = bind\n\n let return = return\nend)\n","open Core_kernel\n\nlet key = Univ_map.Key.create ~name:\"logger\" sexp_of_opaque\n\nlet with_logger logger f =\n Async_kernel.Async_kernel_scheduler.with_local key logger ~f\n\nlet get_opt () = Async_kernel.Async_kernel_scheduler.find_local key\n\nlet get () = Option.value (get_opt ()) ~default:(Logger.null ())\n","open Intf\nopen Core_kernel\n\nmodule type Inputs_intf = sig\n module Base_field : sig\n type t\n end\n\n module Curve : sig\n module Affine : sig\n type t = Base_field.t * Base_field.t\n\n module Backend : sig\n type t = Base_field.t Kimchi_types.or_infinity\n\n val zero : unit -> t\n\n val create : Base_field.t -> Base_field.t -> t\n end\n\n val of_backend :\n Backend.t -> (Base_field.t * Base_field.t) Pickles_types.Or_infinity.t\n end\n end\n\n module Backend : sig\n type t\n\n val make :\n Curve.Affine.Backend.t array -> Curve.Affine.Backend.t option -> t\n\n val shifted : t -> Curve.Affine.Backend.t option\n\n val unshifted : t -> Curve.Affine.Backend.t array\n end\nend\n\ntype 'a t =\n [ `With_degree_bound of\n ('a * 'a) Pickles_types.Or_infinity.t\n Pickles_types.Plonk_types.Poly_comm.With_degree_bound.t\n | `Without_degree_bound of\n ('a * 'a) Pickles_types.Plonk_types.Poly_comm.Without_degree_bound.t ]\n\nmodule Make (Inputs : Inputs_intf) = struct\n open Inputs\n module Backend = Backend\n\n type nonrec t = Base_field.t t\n\n module G_affine = Curve.Affine.Backend\n\n let g (a, b) = G_affine.create a b\n\n let g_vec arr = Array.map ~f:g arr\n\n let or_infinity_to_backend :\n ('a * 'a) Pickles_types.Or_infinity.t -> 'a Kimchi_types.or_infinity =\n function\n | Infinity ->\n Infinity\n | Finite (x, y) ->\n Finite (x, y)\n\n let or_infinity_of_backend :\n 'a Kimchi_types.or_infinity -> ('a * 'a) Pickles_types.Or_infinity.t =\n function\n | Infinity ->\n Infinity\n | Finite (x, y) ->\n Finite (x, y)\n\n let with_degree_bound_to_backend\n (commitment :\n (Base_field.t * Base_field.t) Pickles_types.Or_infinity.t\n Pickles_types.Plonk_types.Poly_comm.With_degree_bound.t ) : Backend.t =\n Backend.make\n (Array.map ~f:or_infinity_to_backend commitment.unshifted)\n (Some (or_infinity_to_backend commitment.shifted))\n\n let without_degree_bound_to_backend\n (commitment :\n (Base_field.t * Base_field.t)\n Pickles_types.Plonk_types.Poly_comm.Without_degree_bound.t ) : Backend.t\n =\n Backend.make\n (Array.map ~f:(fun x -> Kimchi_types.Finite (fst x, snd x)) commitment)\n None\n\n let to_backend (t : t) : Backend.t =\n match t with\n | `With_degree_bound t ->\n with_degree_bound_to_backend t\n | `Without_degree_bound t ->\n without_degree_bound_to_backend t\n\n let of_backend' (t : Backend.t) =\n ( Backend.unshifted t\n , Option.map (Backend.shifted t) ~f:Curve.Affine.of_backend )\n\n let of_backend_with_degree_bound (t : Backend.t) : t =\n let open Pickles_types.Plonk_types.Poly_comm in\n match Backend.shifted t with\n | None ->\n assert false\n | Some shifted ->\n let shifted = or_infinity_of_backend shifted in\n let unshifted =\n Backend.unshifted t |> Array.map ~f:or_infinity_of_backend\n in\n `With_degree_bound { unshifted; shifted }\n\n (*\n type 'a t =\n [ `With_degree_bound of\n ('a * 'a) Pickles_types.Or_infinity.t\n Pickles_types.Plonk_types.Poly_comm.With_degree_bound.t\n | `Without_degree_bound of\n ('a * 'a) Pickles_types.Plonk_types.Poly_comm.Without_degree_bound.t\n ]\n *)\n\n let of_backend_without_degree_bound (t : Backend.t) =\n let open Pickles_types.Plonk_types.Poly_comm in\n let unshifted = Backend.unshifted t in\n match Backend.shifted t with\n | None ->\n `Without_degree_bound\n (Array.map unshifted ~f:(function\n | Infinity ->\n assert false\n | Finite (x, y) ->\n (x, y) ) )\n | _ ->\n assert false\nend\n","open Core_kernel\nopen Intf\n\nmodule type Inputs_intf = sig\n module Verifier_index : T0\n\n module Field : sig\n type t\n end\n\n module Proof : sig\n type t\n\n module Challenge_polynomial : T0\n\n module Backend : sig\n type t\n end\n\n val to_backend :\n Challenge_polynomial.t list -> Field.t list -> t -> Backend.t\n end\n\n module Backend : sig\n type t = Field.t Kimchi_types.oracles\n\n val create : Verifier_index.t -> Proof.Backend.t -> t\n end\nend\n\nmodule Make (Inputs : Inputs_intf) = struct\n open Inputs\n\n let create vk prev_challenge input (pi : Proof.t) =\n let pi = Proof.to_backend prev_challenge input pi in\n Backend.create vk pi\n\n open Backend\n\n let scalar_challenge t = Scalar_challenge.create t\n\n let alpha (t : t) = t.o.alpha_chal\n\n let beta (t : t) = t.o.beta\n\n let gamma (t : t) = t.o.gamma\n\n let zeta (t : t) = t.o.zeta_chal\n\n let joint_combiner_chal (t : t) = Option.map ~f:fst t.o.joint_combiner\n\n let joint_combiner (t : t) = Option.map ~f:snd t.o.joint_combiner\n\n let digest_before_evaluations (t : t) = t.digest_before_evaluations\n\n let v (t : t) = t.o.v_chal\n\n let u (t : t) = t.o.u_chal\n\n let p_eval_1 (t : t) = fst t.p_eval\n\n let p_eval_2 (t : t) = snd t.p_eval\n\n let opening_prechallenges (t : t) =\n Array.map ~f:scalar_challenge t.opening_prechallenges\nend\n","(** number of witness *)\nlet columns = 15\n\n(** number of columns that take part in the permutation *)\nlet permutation_cols = 7\n","module Poly_comm0 = Poly_comm\nopen Unsigned.Size_t\n\nmodule type Stable_v1 = sig\n module Stable : sig\n module V1 : sig\n type t [@@deriving version, bin_io, sexp, compare, yojson, hash, equal]\n end\n\n module Latest = V1\n end\n\n type t = Stable.V1.t [@@deriving sexp, compare, yojson]\nend\n\nmodule type Inputs_intf = sig\n open Intf\n\n val name : string\n\n module Rounds : Pickles_types.Nat.Intf\n\n module Gate_vector : sig\n open Unsigned\n\n type t\n\n val wrap : t -> Kimchi_types.wire -> Kimchi_types.wire -> unit\n end\n\n module Urs : sig\n type t\n\n val read : int option -> string -> t option\n\n val write : bool option -> t -> string -> unit\n\n val create : int -> t\n end\n\n module Scalar_field : sig\n include Stable_v1\n\n val one : t\n end\n\n module Constraint_system : sig\n type t\n\n val get_primary_input_size : t -> int\n\n val get_prev_challenges : t -> int option\n\n val set_prev_challenges : t -> int -> unit\n\n val finalize_and_get_gates : t -> Gate_vector.t\n end\n\n module Index : sig\n type t\n\n (** [create\n gates\n nb_public\n runtime_tables_cfg\n nb_prev_challanges\n srs] *)\n val create :\n Gate_vector.t\n -> int\n -> Scalar_field.t Kimchi_types.runtime_table_cfg array\n -> int\n -> Urs.t\n -> t\n end\n\n module Curve : sig\n module Base_field : sig\n type t\n end\n\n module Affine : sig\n type t = Base_field.t * Base_field.t\n end\n end\n\n module Poly_comm : sig\n module Backend : sig\n type t\n end\n\n type t = Curve.Base_field.t Poly_comm0.t\n\n val of_backend_without_degree_bound : Backend.t -> t\n end\n\n module Verifier_index : sig\n type t =\n ( Scalar_field.t\n , Urs.t\n , Poly_comm.Backend.t )\n Kimchi_types.VerifierIndex.verifier_index\n\n val create : Index.t -> t\n end\nend\n\nmodule Make (Inputs : Inputs_intf) = struct\n open Core_kernel\n\n type t = { index : Inputs.Index.t; cs : Inputs.Constraint_system.t }\n\n let name =\n sprintf \"%s_%d_v4\" Inputs.name (Pickles_types.Nat.to_int Inputs.Rounds.n)\n\n let set_urs_info, load_urs =\n let urs_info = Set_once.create () in\n let urs = ref None in\n let degree = 1 lsl Pickles_types.Nat.to_int Inputs.Rounds.n in\n let set_urs_info specs = Set_once.set_exn urs_info Lexing.dummy_pos specs in\n let load () =\n match !urs with\n | Some urs ->\n urs\n | None ->\n let specs =\n match Set_once.get urs_info with\n | None ->\n failwith \"Dlog_based.urs: Info not set\"\n | Some t ->\n t\n in\n let store =\n Key_cache.Sync.Disk_storable.simple\n (fun () -> name)\n (fun () ~path ->\n Or_error.try_with_join (fun () ->\n match Inputs.Urs.read None path with\n | Some urs ->\n Ok urs\n | None ->\n Or_error.errorf\n \"Could not read the URS from disk; its format did \\\n not match the expected format\" ) )\n (fun _ urs path ->\n Or_error.try_with (fun () -> Inputs.Urs.write None urs path) )\n in\n let u =\n match Key_cache.Sync.read specs store () with\n | Ok (u, _) ->\n u\n | Error _e ->\n let urs = Inputs.Urs.create degree in\n let (_ : (unit, Error.t) Result.t) =\n Key_cache.Sync.write\n (List.filter specs ~f:(function\n | On_disk _ ->\n true\n | S3 _ ->\n false ) )\n store () urs\n in\n urs\n in\n urs := Some u ;\n u\n in\n (set_urs_info, load)\n\n let create ~prev_challenges cs =\n let gates = Inputs.Constraint_system.finalize_and_get_gates cs in\n let public_input_size =\n Inputs.Constraint_system.get_primary_input_size cs\n in\n let prev_challenges =\n match Inputs.Constraint_system.get_prev_challenges cs with\n | None ->\n Inputs.Constraint_system.set_prev_challenges cs prev_challenges ;\n prev_challenges\n | Some prev_challenges' ->\n assert (prev_challenges = prev_challenges') ;\n prev_challenges'\n in\n (* TODO(dw) pass runtime table cfg info *)\n let runtime_table_cfg = [||] in\n let index =\n Inputs.Index.create gates public_input_size runtime_table_cfg\n prev_challenges (load_urs ())\n in\n { index; cs }\n\n let vk t = Inputs.Verifier_index.create t.index\n\n let pk t = t\n\n let array_to_vector a = Pickles_types.Vector.of_list (Array.to_list a)\n\n (** does this convert a backend.verifier_index to a pickles_types.verifier_index? *)\n let vk_commitments (t : Inputs.Verifier_index.t) :\n Inputs.Curve.Affine.t Pickles_types.Plonk_verification_key_evals.t =\n let g c : Inputs.Curve.Affine.t =\n match Inputs.Poly_comm.of_backend_without_degree_bound c with\n | `Without_degree_bound x ->\n x.(0)\n | `With_degree_bound _ ->\n assert false\n in\n { sigma_comm =\n Pickles_types.Vector.init Pickles_types.Plonk_types.Permuts.n\n ~f:(fun i -> g t.evals.sigma_comm.(i))\n ; coefficients_comm =\n Pickles_types.Vector.init Pickles_types.Plonk_types.Columns.n\n ~f:(fun i -> g t.evals.coefficients_comm.(i))\n ; generic_comm = g t.evals.generic_comm\n ; psm_comm = g t.evals.psm_comm\n ; complete_add_comm = g t.evals.complete_add_comm\n ; mul_comm = g t.evals.mul_comm\n ; emul_comm = g t.evals.emul_comm\n ; endomul_scalar_comm = g t.evals.endomul_scalar_comm\n }\nend\n","module Bigint = Bigint\nmodule Field = Field\nmodule Curve = Curve\nmodule Poly_comm = Poly_comm\nmodule Plonk_constraint_system = Plonk_constraint_system\nmodule Dlog_plonk_based_keypair = Dlog_plonk_based_keypair\nmodule Constants = Constants\nmodule Plonk_dlog_proof = Plonk_dlog_proof\nmodule Plonk_dlog_oracles = Plonk_dlog_oracles\nmodule Scalar_challenge = Scalar_challenge\nmodule Endoscale_round = Endoscale_round\nmodule Scale_round = Scale_round\nmodule Endoscale_scalar_round = Endoscale_scalar_round\nmodule Intf = Intf\n","open Kimchi_backend_common\nopen Kimchi_pasta_basic\n\ninclude\n Plonk_constraint_system.Make (Fp) (Kimchi_bindings.Protocol.Gates.Vector.Fp)\n (struct\n let params =\n Sponge.Params.(\n map pasta_p_kimchi ~f:(fun x ->\n Fp.of_bigint (Bigint256.of_decimal_string x) ))\n end)\n","open Kimchi_backend_common\nopen Kimchi_pasta_basic\n\ninclude\n Plonk_constraint_system.Make (Fq) (Kimchi_bindings.Protocol.Gates.Vector.Fq)\n (struct\n let params =\n Sponge.Params.(\n map pasta_q_kimchi ~f:(fun x ->\n Fq.of_bigint (Bigint256.of_decimal_string x) ))\n end)\n","module Basic = Kimchi_pasta_basic\n\nmodule Pallas_based_plonk = struct\n module Field = Pallas_based_plonk.Field\n module Curve = Pallas_based_plonk.Curve\n module Bigint = Pallas_based_plonk.Bigint\n\n let field_size = Pallas_based_plonk.field_size\n\n module Verification_key = Pallas_based_plonk.Verification_key\n module R1CS_constraint_system = Pallas_based_plonk.R1CS_constraint_system\n module Rounds_vector = Pallas_based_plonk.Rounds_vector\n module Rounds = Pallas_based_plonk.Rounds\n module Keypair = Pallas_based_plonk.Keypair\n module Proof = Pallas_based_plonk.Proof\n module Proving_key = Pallas_based_plonk.Proving_key\n module Oracles = Pallas_based_plonk.Oracles\nend\n\nmodule Vesta_based_plonk = struct\n module Field = Vesta_based_plonk.Field\n module Curve = Vesta_based_plonk.Curve\n module Bigint = Vesta_based_plonk.Bigint\n\n let field_size = Vesta_based_plonk.field_size\n\n module Verification_key = Vesta_based_plonk.Verification_key\n module R1CS_constraint_system = Vesta_based_plonk.R1CS_constraint_system\n module Rounds_vector = Vesta_based_plonk.Rounds_vector\n module Rounds = Vesta_based_plonk.Rounds\n module Keypair = Vesta_based_plonk.Keypair\n module Proof = Vesta_based_plonk.Proof\n module Proving_key = Vesta_based_plonk.Proving_key\n module Oracles = Vesta_based_plonk.Oracles\nend\n\nmodule Pasta = struct\n module Rounds = Pasta.Rounds\n module Bigint256 = Pasta.Bigint256\n module Fp = Pasta.Fp\n module Fq = Pasta.Fq\n module Vesta = Pasta.Vesta\n module Pallas = Pasta.Pallas\nend\n","open Utils\n\nmodule Types = struct\n module type S = V1S0\nend\n\nmodule type Concrete = Types.S with type V1.t = Unsigned.UInt64.t\n\nmodule M = struct\n module V1 = struct\n type t = Unsigned.UInt64.t\n end\nend\n\nmodule type Local_sig = Signature(Types).S\n\nmodule Make\n (Signature : Local_sig) (F : functor (A : Concrete) -> Signature(A).S) =\n F (M)\ninclude M\n","open Utils\n\n(** We first define a [Types] module, with the expected final signature of this\n module (hidden types should be hidden here) *)\nmodule Types = struct\n module type S = sig\n module Fee : V1S0\n\n module Amount : V1S0\n\n module Balance : V1S0\n end\nend\n\n(** We define a module type [Concrete], where we replace hidden types in\n {!Types.S} by their actual definition. This module will not be exported. *)\nmodule type Concrete =\n Types.S\n with type Fee.V1.t = Unsigned.UInt64.t\n and type Amount.V1.t = Unsigned.UInt64.t\n and type Balance.V1.t = Unsigned.UInt64.t\n\n(** Then we define the actual module [M] with its type definitions. It must be\n compatible with {!Concrete} *)\nmodule M = struct\n module Fee = struct\n module V1 = struct\n type t = Unsigned.UInt64.t\n end\n end\n\n module Amount = struct\n module V1 = struct\n type t = Unsigned.UInt64.t\n end\n end\n\n module Balance = struct\n module V1 = struct\n type t = Amount.V1.t\n end\n end\nend\n\n(** [Local_sig] is the type of functors which receive a {!Types.S} module and\n return a complete module signature (with operations etc.) based on these\n types. It will be expected to be given by the implementation module. *)\nmodule type Local_sig = Signature(Types).S\n\n(** To make a full module, the implementation module will have to use [Make] and\n provide: (i) a {!Local_sig} functor to know the final signature of the\n module and (ii) a functor which takes the concrete types defined here and\n make the actual full module, adding type equalities where needed. *)\nmodule Make\n (Signature : Local_sig) (F : functor (A : Concrete) -> Signature(A).S) =\n F (M)\n\n(** Finally, we include our module to make the types available to everyone (they\n will be hidden in the MLI *)\ninclude M\n","open Utils\n\nmodule Branch_data = struct\n module Types = struct\n module type S = sig\n module Domain_log2 : V1S0\n\n module V1 : sig\n type t =\n { proofs_verified : Pickles_base.Proofs_verified.V1.t\n ; domain_log2 : Domain_log2.V1.t\n }\n end\n end\n end\n\n module type Concrete = Types.S with type Domain_log2.V1.t = char\n\n module M = struct\n module Domain_log2 = struct\n module V1 = struct\n type t = char\n end\n end\n\n module V1 = struct\n type t =\n { proofs_verified : Pickles_base.Proofs_verified.V1.t\n ; domain_log2 : Domain_log2.V1.t\n }\n end\n end\n\n module type Local_sig = Signature(Types).S\n\n module Make\n (Signature : Local_sig) (F : functor (A : Concrete) -> Signature(A).S) =\n F (M)\n include M\nend\n\nmodule Wrap = struct\n module Proof_state = struct\n module Messages_for_next_wrap_proof = struct\n module V1 = struct\n type ('g1, 'bulletproof_challenges) t =\n { challenge_polynomial_commitment : 'g1\n ; old_bulletproof_challenges : 'bulletproof_challenges\n }\n end\n end\n\n module Deferred_values = struct\n module Plonk = struct\n module Minimal = struct\n module V1 = struct\n type ('challenge, 'scalar_challenge, 'bool) t =\n { alpha : 'scalar_challenge\n ; beta : 'challenge\n ; gamma : 'challenge\n ; zeta : 'scalar_challenge\n ; joint_combiner : 'scalar_challenge option\n ; feature_flags :\n 'bool Pickles_types.Plonk_types.Features.Stable.V1.t\n }\n end\n end\n end\n\n module V1 = struct\n type ( 'plonk\n , 'scalar_challenge\n , 'fp\n , 'bulletproof_challenges\n , 'branch_data )\n t =\n { plonk : 'plonk\n ; combined_inner_product : 'fp\n ; b : 'fp\n ; xi : 'scalar_challenge\n ; bulletproof_challenges : 'bulletproof_challenges\n ; branch_data : 'branch_data\n }\n end\n\n module Minimal = struct\n module V1 = struct\n type ( 'challenge\n , 'scalar_challenge\n , 'fp\n , 'bool\n , 'bulletproof_challenges\n , 'branch_data )\n t =\n { plonk : ('challenge, 'scalar_challenge, 'bool) Plonk.Minimal.V1.t\n ; bulletproof_challenges : 'bulletproof_challenges\n ; branch_data : 'branch_data\n }\n end\n end\n end\n\n module V1 = struct\n type ( 'plonk\n , 'scalar_challenge\n , 'fp\n , 'messages_for_next_wrap_proof\n , 'digest\n , 'bp_chals\n , 'index )\n t =\n { deferred_values :\n ( 'plonk\n , 'scalar_challenge\n , 'fp\n , 'bp_chals\n , 'index )\n Deferred_values.V1.t\n ; sponge_digest_before_evaluations : 'digest\n ; messages_for_next_wrap_proof : 'messages_for_next_wrap_proof\n }\n end\n\n module Minimal = struct\n module V1 = struct\n type ( 'challenge\n , 'scalar_challenge\n , 'fp\n , 'bool\n , 'messages_for_next_wrap_proof\n , 'digest\n , 'bp_chals\n , 'index )\n t =\n { deferred_values :\n ( 'challenge\n , 'scalar_challenge\n , 'fp\n , 'bool\n , 'bp_chals\n , 'index )\n Deferred_values.Minimal.V1.t\n ; sponge_digest_before_evaluations : 'digest\n ; messages_for_next_wrap_proof : 'messages_for_next_wrap_proof\n }\n end\n end\n end\n\n module Statement = struct\n module V1 = struct\n type ( 'plonk\n , 'scalar_challenge\n , 'fp\n , 'messages_for_next_wrap_proof\n , 'digest\n , 'messages_for_next_step_proof\n , 'bp_chals\n , 'index )\n t =\n { proof_state :\n ( 'plonk\n , 'scalar_challenge\n , 'fp\n , 'messages_for_next_wrap_proof\n , 'digest\n , 'bp_chals\n , 'index )\n Proof_state.V1.t\n ; messages_for_next_step_proof : 'messages_for_next_step_proof\n }\n end\n\n module Minimal = struct\n module V1 = struct\n type ( 'challenge\n , 'scalar_challenge\n , 'fp\n , 'bool\n , 'messages_for_next_wrap_proof\n , 'digest\n , 'messages_for_next_step_proof\n , 'bp_chals\n , 'index )\n t =\n { proof_state :\n ( 'challenge\n , 'scalar_challenge\n , 'fp\n , 'bool\n , 'messages_for_next_wrap_proof\n , 'digest\n , 'bp_chals\n , 'index )\n Proof_state.Minimal.V1.t\n ; messages_for_next_step_proof : 'messages_for_next_step_proof\n }\n end\n end\n end\nend\n","open Utils\n\nmodule M = struct\n module Backend = struct\n module Tick = struct\n module Field = struct\n module V1 = struct\n type t = Pasta_bindings.Fp.t\n end\n end\n end\n end\n\n module Wrap_wire_proof = struct\n module Columns_vec = Pickles_types.Vector.Vector_15\n module Coefficients_vec = Pickles_types.Vector.Vector_15\n module Quotient_polynomial_vec = Pickles_types.Vector.Vector_7\n module Permuts_minus_1_vec = Pickles_types.Vector.Vector_6\n\n module Commitments = struct\n module V1 = struct\n type t =\n { w_comm :\n (Pasta_bindings.Fp.t * Pasta_bindings.Fp.t)\n Columns_vec.Stable.V1.t\n ; z_comm : Pasta_bindings.Fp.t * Pasta_bindings.Fp.t\n ; t_comm :\n (Pasta_bindings.Fp.t * Pasta_bindings.Fp.t)\n Quotient_polynomial_vec.Stable.V1.t\n }\n end\n end\n\n module Evaluations = struct\n module V1 = struct\n type t =\n { w :\n (Pasta_bindings.Fq.t * Pasta_bindings.Fq.t)\n Columns_vec.Stable.V1.t\n ; coefficients :\n (Pasta_bindings.Fq.t * Pasta_bindings.Fq.t)\n Columns_vec.Stable.V1.t\n ; z : Pasta_bindings.Fq.t * Pasta_bindings.Fq.t\n ; s :\n (Pasta_bindings.Fq.t * Pasta_bindings.Fq.t)\n Permuts_minus_1_vec.Stable.V1.t\n ; generic_selector : Pasta_bindings.Fq.t * Pasta_bindings.Fq.t\n ; poseidon_selector : Pasta_bindings.Fq.t * Pasta_bindings.Fq.t\n ; complete_add_selector : Pasta_bindings.Fq.t * Pasta_bindings.Fq.t\n ; mul_selector : Pasta_bindings.Fq.t * Pasta_bindings.Fq.t\n ; emul_selector : Pasta_bindings.Fq.t * Pasta_bindings.Fq.t\n ; endomul_scalar_selector : Pasta_bindings.Fq.t * Pasta_bindings.Fq.t\n }\n end\n end\n\n module V1 = struct\n type t =\n { commitments : Commitments.V1.t\n ; evaluations : Evaluations.V1.t\n ; ft_eval1 : Pasta_bindings.Fq.t\n ; bulletproof :\n ( Pasta_bindings.Fp.t * Pasta_bindings.Fp.t\n , Pasta_bindings.Fq.t )\n Pickles_types.Plonk_types.Openings.Bulletproof.Stable.V1.t\n }\n end\n end\n\n module Proof = struct\n type challenge_constant =\n Pickles_limb_vector.Constant.Make(Pickles_types.Nat.N2).t\n\n type tock_affine = Pasta_bindings.Fp.t * Pasta_bindings.Fp.t\n\n type 'a step_bp_vec = 'a Kimchi_pasta.Basic.Rounds.Step_vector.Stable.V1.t\n\n module Base = struct\n module Wrap = struct\n module V2 = struct\n type digest_constant =\n Pickles_limb_vector.Constant.Make(Pickles_types.Nat.N4).t\n\n type ('messages_for_next_wrap_proof, 'messages_for_next_step_proof) t =\n { statement :\n ( challenge_constant\n , challenge_constant Kimchi_types.scalar_challenge\n , Snark_params.Tick.Field.t Pickles_types.Shifted_value.Type1.t\n , bool\n , 'messages_for_next_wrap_proof\n , digest_constant\n , 'messages_for_next_step_proof\n , challenge_constant Kimchi_types.scalar_challenge\n Pickles_bulletproof_challenge.V1.t\n step_bp_vec\n , Pickles_composition_types.Branch_data.V1.t )\n Pickles_composition_types.Wrap.Statement.Minimal.V1.t\n ; prev_evals :\n ( Snark_params.Tick.Field.t\n , Snark_params.Tick.Field.t array )\n Pickles_types.Plonk_types.All_evals.t\n ; proof : Wrap_wire_proof.V1.t\n }\n end\n end\n end\n\n type ('s, 'mlmb, _) with_data =\n | T :\n ( 'mlmb Pickles_reduced_messages_for_next_proof_over_same_field.Wrap.t\n , ( 's\n , (tock_affine, 'most_recent_width) Pickles_types.Vector.t\n , ( challenge_constant Kimchi_types.scalar_challenge\n Pickles_bulletproof_challenge.V1.t\n step_bp_vec\n , 'most_recent_width )\n Pickles_types.Vector.t )\n Pickles_reduced_messages_for_next_proof_over_same_field.Step.V1.t\n )\n Base.Wrap.V2.t\n -> ('s, 'mlmb, _) with_data\n\n type ('max_width, 'mlmb) t = (unit, 'mlmb, 'max_width) with_data\n\n module Proofs_verified_2 = struct\n module V2 = struct\n type nonrec t = (Pickles_types.Nat.N2.n, Pickles_types.Nat.N2.n) t\n end\n end\n end\n\n module Side_loaded = struct\n module Verification_key = struct\n module Vk = struct\n type t =\n ( Pasta_bindings.Fq.t\n , Kimchi_bindings.Protocol.SRS.Fq.t\n , Pasta_bindings.Fp.t Kimchi_types.or_infinity Kimchi_types.poly_comm\n )\n Kimchi_types.VerifierIndex.verifier_index\n end\n\n type tock_curve_affine =\n Snark_params.Tick.Field.t * Snark_params.Tick.Field.t\n\n module V2 = struct\n type t =\n ( tock_curve_affine\n , Pickles_base.Proofs_verified.V1.t\n , Vk.t )\n Pickles_base.Side_loaded_verification_key.Poly.V2.t\n end\n\n module Max_width = Pickles_types.Nat.N2\n end\n\n module Proof = struct\n module V2 = struct\n type t =\n (Verification_key.Max_width.n, Verification_key.Max_width.n) Proof.t\n end\n end\n end\nend\n\nmodule Types = struct\n module type S = sig\n module Proof : sig\n type ('a, 'b) t\n\n module Proofs_verified_2 : sig\n module V2 : sig\n type nonrec t = (Pickles_types.Nat.N2.n, Pickles_types.Nat.N2.n) t\n end\n end\n end\n\n module Side_loaded : sig\n module Verification_key : sig\n module Max_width : module type of Pickles_types.Nat.N2\n\n module V2 : sig\n type t\n end\n end\n\n module Proof : sig\n module V2 : sig\n type t =\n (Verification_key.Max_width.n, Verification_key.Max_width.n) Proof.t\n end\n end\n end\n\n module Backend : sig\n module Tick : sig\n module Field : sig\n module V1 : sig\n type t = Pasta_bindings.Fp.t\n end\n end\n end\n end\n end\nend\n\nmodule Concrete_ = M\n\nmodule type Concrete =\n Types.S\n with type Side_loaded.Verification_key.V2.t =\n M.Side_loaded.Verification_key.V2.t\n and type Backend.Tick.Field.V1.t = Pasta_bindings.Fp.t\n and type ('a, 'b) Proof.t = ('a, 'b) M.Proof.t\n\nmodule type Local_sig = Signature(Types).S\n\nmodule Make\n (Signature : Local_sig) (F : functor (A : Concrete) -> Signature(A).S) =\n F (M)\ninclude M\n","[%%import \"/src/config.mlh\"]\n\nopen Utils\n\nmodule Types = struct\n module type S = sig\n module Digest : V1S0\n\n include V2S0\n end\nend\n\n[%%ifdef consensus_mechanism]\n\nmodule type Concrete =\n Types.S\n with type Digest.V1.t = Pickles.Backend.Tick.Field.V1.t\n and type V2.t =\n Public_key.Compressed.V1.t * Pickles.Backend.Tick.Field.V1.t\n\n[%%else]\n\nmodule type Concrete =\n Types.S\n with type Digest.V1.t = Snark_params.Tick.Field.t\n and type V2.t = Public_key.Compressed.V1.t * Snark_params.Tick.Field.V1.t\n\n[%%endif]\n\nmodule M = struct\n [%%ifdef consensus_mechanism]\n\n module Digest = struct\n module V1 = struct\n type t = Pickles.Backend.Tick.Field.V1.t\n end\n end\n\n module V2 = struct\n type t = Public_key.Compressed.V1.t * Pickles.Backend.Tick.Field.V1.t\n end\n\n [%%else]\n\n module Digest = struct\n module V1 = struct\n type t = Snark_params.Tick.Field.t\n end\n end\n\n module V2 = struct\n type t = Public_key.Compressed.V1.t * Snark_params.Tick.Field.V1.t\n end\n\n [%%endif]\nend\n\nmodule type Local_sig = Signature(Types).S\n\nmodule Make\n (Signature : Local_sig) (F : functor (A : Concrete) -> Signature(A).S) =\n F (M)\ninclude M\n","open Utils\n\nmodule Account_nonce = struct\n module Types = struct\n module type S = V1S0\n end\n\n module type Concrete = Types.S with type V1.t = Unsigned.UInt32.t\n\n module M = struct\n module V1 = struct\n type t = Unsigned.UInt32.t\n end\n end\n\n module type Local_sig = Signature(Types).S\n\n module Make\n (Signature : Local_sig) (F : functor (A : Concrete) -> Signature(A).S) =\n F (M)\n include M\nend\n\nmodule Global_slot_legacy = struct\n module Types = struct\n module type S = V1S0\n end\n\n module type Concrete = Types.S with type V1.t = Unsigned.UInt32.t\n\n module M = struct\n module V1 = struct\n type t = Unsigned.UInt32.t\n end\n end\n\n module type Local_sig = Signature(Types).S\n\n module Make\n (Signature : Local_sig) (F : functor (A : Concrete) -> Signature(A).S) =\n F (M)\n include M\nend\n\nmodule Global_slot_since_genesis = struct\n module Types = struct\n module type S = V1S0\n end\n\n type global_slot = Since_genesis of Unsigned.UInt32.t [@@unboxed]\n\n module type Concrete = Types.S with type V1.t = global_slot\n\n module M = struct\n module V1 = struct\n type t = global_slot\n end\n end\n\n module type Local_sig = Signature(Types).S\n\n module Make\n (Signature : Local_sig) (F : functor (A : Concrete) -> Signature(A).S) =\n F (M)\n include M\nend\n\nmodule Global_slot_since_hard_fork = struct\n module Types = struct\n module type S = V1S0\n end\n\n type global_slot = Since_hard_fork of Unsigned.UInt32.t [@@unboxed]\n\n module type Concrete = Types.S with type V1.t = global_slot\n\n module M = struct\n module V1 = struct\n type t = global_slot\n end\n end\n\n module type Local_sig = Signature(Types).S\n\n module Make\n (Signature : Local_sig) (F : functor (A : Concrete) -> Signature(A).S) =\n F (M)\n include M\nend\n\nmodule Global_slot_span = struct\n module Types = struct\n module type S = V1S0\n end\n\n type global_slot_span = Global_slot_span of Unsigned.UInt32.t [@@unboxed]\n\n module type Concrete = Types.S with type V1.t = global_slot_span\n\n module M = struct\n module V1 = struct\n type t = global_slot_span\n end\n end\n\n module type Local_sig = Signature(Types).S\n\n module Make\n (Signature : Local_sig) (F : functor (A : Concrete) -> Signature(A).S) =\n F (M)\n include M\nend\n\nmodule Length = struct\n module Types = struct\n module type S = V1S0\n end\n\n module type Concrete = Types.S with type V1.t = Unsigned.UInt32.t\n\n module M = struct\n module V1 = struct\n type t = Unsigned.UInt32.t\n end\n end\n\n module type Local_sig = Signature(Types).S\n\n module Make\n (Signature : Local_sig) (F : functor (A : Concrete) -> Signature(A).S) =\n F (M)\n include M\nend\n\nmodule Index = struct\n module Types = struct\n module type S = V1S0\n end\n\n module type Concrete = Types.S with type V1.t = Unsigned.UInt32.t\n\n module M = struct\n module V1 = struct\n type t = Unsigned.UInt32.t\n end\n end\n\n module type Local_sig = Signature(Types).S\n\n module Make\n (Signature : Local_sig) (F : functor (A : Concrete) -> Signature(A).S) =\n F (M)\n include M\nend\n","open Utils\n\nmodule Types = struct\n module type S = sig\n module V1 : sig\n type t = private Mina_base_zkapp_basic.F.V1.t\n end\n end\nend\n\nmodule type Concrete = sig\n module V1 : sig\n type t = Pasta_bindings.Fp.t\n end\nend\n\nmodule M = struct\n module V1 = struct\n type t = Pasta_bindings.Fp.t\n end\nend\n\nmodule type Local_sig = Signature(Types).S\n\nmodule Make\n (Signature : Local_sig) (F : functor (A : Concrete) -> Signature(A).S) =\n F (M)\ninclude M\n","open Utils\n\nmodule Types = struct\n module type S = sig\n module V1 : sig\n type t = private\n { receiver_pk : Public_key.Compressed.V1.t; fee : Currency.Fee.V1.t }\n end\n end\nend\n\nmodule type Concrete = sig\n module V1 : sig\n type t =\n { receiver_pk : Public_key.Compressed.V1.t; fee : Currency.Fee.V1.t }\n end\nend\n\nmodule M = struct\n module V1 = struct\n type t =\n { receiver_pk : Public_key.Compressed.V1.t; fee : Currency.Fee.V1.t }\n end\nend\n\nmodule type Local_sig = Utils.Signature(Types).S\n\nmodule Make\n (Signature : Local_sig) (F : functor (A : Concrete) -> Signature(A).S) =\n F (M)\ninclude M\n","open Utils\n\nmodule Types = struct\n module type S = sig\n module V1 : sig\n type t = private\n { receiver : Public_key.Compressed.V1.t\n ; amount : Currency.Amount.V1.t\n ; fee_transfer : Mina_base_coinbase_fee_transfer.V1.t option\n }\n end\n end\nend\n\nmodule M = struct\n module V1 = struct\n type t =\n { receiver : Public_key.Compressed.V1.t\n ; amount : Currency.Amount.V1.t\n ; fee_transfer : Mina_base_coinbase_fee_transfer.V1.t option\n }\n end\nend\n\nmodule type Concrete = sig\n module V1 : sig\n type t =\n { receiver : Public_key.Compressed.V1.t\n ; amount : Currency.Amount.V1.t\n ; fee_transfer : Mina_base_coinbase_fee_transfer.V1.t option\n }\n end\nend\n\nmodule type Local_sig = Signature(Types).S\n\nmodule Make\n (Signature : Local_sig) (F : functor (A : Concrete) -> Signature(A).S) =\n F (M)\ninclude M\n","open Utils\n\nmodule Types = struct\n module type S = sig\n module Single : sig\n module V2 : sig\n type t = private\n { receiver_pk : Public_key.Compressed.V1.t\n ; fee : Currency.Fee.V1.t\n ; fee_token : Mina_base_token_id.V2.t\n }\n end\n end\n\n module V2 : sig\n type t = private Single.V2.t One_or_two.V1.t\n end\n end\nend\n\nmodule M = struct\n module Single = struct\n module V2 = struct\n type t =\n { receiver_pk : Public_key.Compressed.V1.t\n ; fee : Currency.Fee.V1.t\n ; fee_token : Mina_base_token_id.V2.t\n }\n end\n end\n\n module V2 = struct\n type t = Single.V2.t One_or_two.V1.t\n end\nend\n\nmodule type Concrete = sig\n module Single : sig\n module V2 : sig\n type t =\n { receiver_pk : Public_key.Compressed.V1.t\n ; fee : Currency.Fee.V1.t\n ; fee_token : Mina_base_token_id.V2.t\n }\n end\n end\n\n module V2 : sig\n type t = Single.V2.t One_or_two.V1.t\n end\nend\n\nmodule type Local_sig = Signature(Types).S\n\nmodule Make\n (Signature : Local_sig) (F : functor (A : Concrete) -> Signature(A).S) =\n F (M)\ninclude M\n","open Utils\n\nmodule Types = struct\n module type S = sig\n module State_stack : sig\n module V1 : sig\n type t\n end\n end\n\n module Stack_versioned : sig\n module V1 : sig\n type nonrec t\n end\n end\n\n module Hash_builder : sig\n module V1 : sig\n type t = private Snark_params.Tick.Field.t\n end\n end\n\n module Hash_versioned : sig\n module V1 : sig\n type t = Hash_builder.V1.t\n end\n end\n end\nend\n\nmodule type Concrete = sig\n module Poly : sig\n type ('tree, 'stack_id) t =\n { tree : 'tree; pos_list : 'stack_id list; new_pos : 'stack_id }\n end\n\n module Stack_hash : sig\n module V1 : sig\n type t = Snark_params.Tick.Field.t\n end\n end\n\n module State_stack : sig\n module Poly : sig\n module V1 : sig\n type 'stack_hash t = { init : 'stack_hash; curr : 'stack_hash }\n end\n end\n\n module V1 : sig\n type t = Stack_hash.V1.t Poly.V1.t\n end\n end\n\n module Coinbase_stack : sig\n module V1 : sig\n type t = Snark_params.Tick.Field.t\n end\n end\n\n module Stack_versioned : sig\n module Poly : sig\n module V1 : sig\n type ('data_stack, 'state_stack) t =\n { data : 'data_stack; state : 'state_stack }\n end\n end\n\n module V1 : sig\n type t = (Coinbase_stack.V1.t, State_stack.V1.t) Poly.V1.t\n end\n end\n\n module Hash_builder : sig\n module V1 : sig\n type t = Snark_params.Tick.Field.t\n end\n end\n\n module Hash_versioned : sig\n module V1 : sig\n type t = Hash_builder.V1.t\n end\n end\nend\n\nmodule M = struct\n module Poly = struct\n type ('tree, 'stack_id) t =\n { tree : 'tree; pos_list : 'stack_id list; new_pos : 'stack_id }\n end\n\n module Stack_hash = struct\n module V1 = struct\n type t = Snark_params.Tick.Field.t\n end\n end\n\n module State_stack = struct\n module Poly = struct\n module V1 = struct\n type 'stack_hash t = { init : 'stack_hash; curr : 'stack_hash }\n end\n end\n\n module V1 = struct\n type t = Stack_hash.V1.t Poly.V1.t\n end\n end\n\n module Coinbase_stack = struct\n module V1 = struct\n type t = Snark_params.Tick.Field.t\n end\n end\n\n module Stack_versioned = struct\n module Poly = struct\n module V1 = struct\n type ('data_stack, 'state_stack) t =\n { data : 'data_stack; state : 'state_stack }\n end\n end\n\n module V1 = struct\n type t = (Coinbase_stack.V1.t, State_stack.V1.t) Poly.V1.t\n end\n end\n\n module Hash_builder = struct\n module V1 = struct\n type t = Snark_params.Tick.Field.t\n end\n end\n\n module Hash_versioned = struct\n module V1 = struct\n type t = Hash_builder.V1.t\n end\n end\nend\n\nmodule type Local_sig = Signature(Types).S\n\nmodule Make\n (Signature : Local_sig) (F : functor (A : Concrete) -> Signature(A).S) =\n F (M)\ninclude M\n","open Utils\n\nmodule Types = struct\n module type S = V1S0\nend\n\nmodule type Concrete = Types.S with type V1.t = string\n\nmodule M = struct\n module V1 = struct\n type t = string\n end\nend\n\nmodule type Local_sig = Signature(Types).S\n\nmodule Make\n (Signature : Local_sig) (F : functor (A : Concrete) -> Signature(A).S) =\n F (M)\ninclude M\n","open Utils\n\nmodule Poly = struct\n module V1 = struct\n type ('payload, 'pk, 'signature) t =\n { payload : 'payload; signer : 'pk; signature : 'signature }\n end\nend\n\nmodule V1 = struct\n type t =\n ( Mina_base_signed_command_payload.V1.t\n , Public_key.V1.t\n , Mina_base_signature.V1.t )\n Poly.V1.t\nend\n\nmodule V2 = struct\n type t =\n ( Mina_base_signed_command_payload.V2.t\n , Public_key.V1.t\n , Mina_base_signature.V1.t )\n Poly.V1.t\nend\n\nmodule Types = struct\n module type S = sig\n module With_valid_signature : V2S0 with type V2.t = private V2.t\n end\nend\n\nmodule type Concrete = Types.S with type With_valid_signature.V2.t = V2.t\n\nmodule M = struct\n module With_valid_signature = struct\n module V2 = struct\n type t = V2.t\n end\n end\nend\n\nmodule type Local_sig = Utils.Signature(Types).S\n\nmodule Make\n (Signature : Local_sig) (F : functor (A : Concrete) -> Signature(A).S) =\n F (M)\ninclude M\n","open Utils\n\nmodule Types = struct\n module type S = sig\n module Digest : V1S0\n end\nend\n\nmodule type Concrete = Types.S with type Digest.V1.t = string\n\nmodule M = struct\n module Digest = struct\n module V1 = struct\n type t = string\n end\n end\nend\n\nmodule type Local_sig = Signature(Types).S\n\nmodule Make\n (Signature : Local_sig) (F : functor (A : Concrete) -> Signature(A).S) =\n F (M)\ninclude M\n","open Utils\n\nmodule Digest = struct\n module Types = struct\n module type S = sig\n module V1 : sig\n type t = private Mina_base_zkapp_basic.F.V1.t\n end\n end\n end\n\n module type Concrete = sig\n module V1 : sig\n type t = Pasta_bindings.Fp.t\n end\n end\n\n module M = struct\n module V1 = struct\n type t = Pasta_bindings.Fp.t\n end\n end\n\n module type Local_sig = Signature(Types).S\n\n module Make\n (Signature : Local_sig) (F : functor (A : Concrete) -> Signature(A).S) =\n F (M)\n include M\nend\n","open Utils\n\nmodule Types = struct\n module type S = sig\n module Aux_hash : sig\n type t\n\n module V1 : sig\n type nonrec t = t\n end\n end\n\n module Pending_coinbase_aux : V1S0\n\n module V1 : S0\n end\nend\n\nmodule type Concrete = sig\n module Aux_hash : sig\n type t = string\n\n module V1 : sig\n type nonrec t = t\n end\n end\n\n module Pending_coinbase_aux : sig\n module V1 : sig\n type t = string\n end\n end\n\n module Non_snark : sig\n module V1 : sig\n type t =\n { ledger_hash : Mina_base_ledger_hash.V1.t\n ; aux_hash : Aux_hash.V1.t\n ; pending_coinbase_aux : Pending_coinbase_aux.V1.t\n }\n end\n end\n\n module Poly : sig\n module V1 : sig\n type ('non_snark, 'pending_coinbase_hash) t =\n { non_snark : 'non_snark\n ; pending_coinbase_hash : 'pending_coinbase_hash\n }\n end\n end\n\n module V1 : sig\n type t =\n (Non_snark.V1.t, Mina_base_pending_coinbase.Hash_versioned.V1.t) Poly.V1.t\n end\nend\n\nmodule M = struct\n module Aux_hash = struct\n type t = string\n\n module V1 = struct\n type nonrec t = string\n end\n end\n\n module Pending_coinbase_aux = struct\n module V1 = struct\n type t = string\n end\n end\n\n module Non_snark = struct\n module V1 = struct\n type t =\n { ledger_hash : Mina_base_ledger_hash.V1.t\n ; aux_hash : Aux_hash.V1.t\n ; pending_coinbase_aux : Pending_coinbase_aux.V1.t\n }\n end\n end\n\n module Poly = struct\n module V1 = struct\n type ('non_snark, 'pending_coinbase_hash) t =\n { non_snark : 'non_snark\n ; pending_coinbase_hash : 'pending_coinbase_hash\n }\n end\n end\n\n module V1 = struct\n type t =\n (Non_snark.V1.t, Mina_base_pending_coinbase.Hash_versioned.V1.t) Poly.V1.t\n end\nend\n\nmodule type Local_sig = Signature(Types).S\n\nmodule Make\n (Signature : Local_sig) (F : functor (A : Concrete) -> Signature(A).S) =\n F (M)\ninclude M\n","open Utils\n\nmodule Digest_types = struct\n module type S = sig\n module Account_update : sig\n module V1 : sig\n type t = private Pasta_bindings.Fp.t\n end\n end\n\n module Forest : sig\n module V1 : sig\n type t = private Pasta_bindings.Fp.t\n end\n end\n end\nend\n\nmodule Digest_M = struct\n module Account_update = struct\n module V1 = struct\n type t = Pasta_bindings.Fp.t\n end\n end\n\n module Forest = struct\n module V1 = struct\n type t = Pasta_bindings.Fp.t\n end\n end\nend\n\nmodule type Digest_concrete = sig\n module Account_update : sig\n module V1 : sig\n type t = Pasta_bindings.Fp.t\n end\n end\n\n module Forest : sig\n module V1 : sig\n type t = Pasta_bindings.Fp.t\n end\n end\nend\n\nmodule type Digest_local_sig = Signature(Digest_types).S\n\nmodule Digest_make\n (Signature : Digest_local_sig) (F : functor (A : Digest_concrete) ->\n Signature(A).S) =\n F (Digest_M)\n\nmodule Call_forest = struct\n module Digest = Digest_M\n\n module Tree = struct\n module V1 = struct\n type ('account_update, 'account_update_digest, 'digest) t =\n { account_update : 'account_update\n ; account_update_digest : 'account_update_digest\n ; calls :\n ( ('account_update, 'account_update_digest, 'digest) t\n , 'digest )\n Mina_base_with_stack_hash.V1.t\n list\n }\n end\n end\n\n module V1 = struct\n type ('account_update, 'account_update_digest, 'digest) t =\n ( ('account_update, 'account_update_digest, 'digest) Tree.V1.t\n , 'digest )\n Mina_base_with_stack_hash.V1.t\n list\n end\nend\n\nmodule V1 = struct\n type t =\n { fee_payer : Mina_base_account_update.Fee_payer.V1.t\n ; account_updates :\n ( Mina_base_account_update.V1.t\n , Call_forest.Digest.Account_update.V1.t\n , Call_forest.Digest.Forest.V1.t )\n Call_forest.V1.t\n ; memo : Mina_base_signed_command_memo.V1.t\n }\nend\n\nmodule Valid = struct\n module Verification_key_hash = struct\n module V1 = struct\n type t = Mina_base_zkapp_basic.F.V1.t\n end\n end\n\n module V1 = struct\n type t = { zkapp_command : V1.t }\n end\nend\n\nmodule Transaction_commitment = struct\n module V1 = struct\n type t = Pasta_bindings.Fp.t\n end\nend\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Alain Frisch, LexiFi *)\n(* *)\n(* Copyright 2012 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* TODO: remove this open *)\nopen Stdlib0\nmodule Location = Astlib.Location\nmodule Longident = Astlib.Longident\nopen Astlib.Ast_412\n\n[@@@warning \"-9\"]\n\nopen Asttypes\nopen Parsetree\n\ntype 'a with_loc = 'a Location.loc\ntype loc = Location.t\ntype lid = Longident.t with_loc\ntype str = string with_loc\ntype str_opt = string option with_loc\ntype attrs = attribute list\n\nlet default_loc = ref Location.none\n\ntype ref_and_value = R : 'a ref * 'a -> ref_and_value\n\nlet protect_ref =\n let set_ref (R (r, v)) = r := v in\n fun ref f ->\n let (R (r, _)) = ref in\n let backup = R (r, !r) in\n set_ref ref;\n match f () with\n | x ->\n set_ref backup;\n x\n | exception e ->\n set_ref backup;\n raise e\n\nlet with_default_loc l f = protect_ref (R (default_loc, l)) f\n\nmodule Const = struct\n let integer ?suffix i = Pconst_integer (i, suffix)\n let int ?suffix i = integer ?suffix (Int.to_string i)\n let int32 ?(suffix = 'l') i = integer ~suffix (Int32.to_string i)\n let int64 ?(suffix = 'L') i = integer ~suffix (Int64.to_string i)\n let nativeint ?(suffix = 'n') i = integer ~suffix (Nativeint.to_string i)\n let float ?suffix f = Pconst_float (f, suffix)\n let char c = Pconst_char c\n\n let string ?quotation_delimiter ?(loc = !default_loc) s =\n Pconst_string (s, loc, quotation_delimiter)\nend\n\nmodule Attr = struct\n let mk ?(loc = !default_loc) name payload =\n { attr_name = name; attr_payload = payload; attr_loc = loc }\nend\n\nmodule Typ = struct\n let mk ?(loc = !default_loc) ?(attrs = []) d =\n {\n ptyp_desc = d;\n ptyp_loc = loc;\n ptyp_loc_stack = [];\n ptyp_attributes = attrs;\n }\n\n let attr d a = { d with ptyp_attributes = d.ptyp_attributes @ [ a ] }\n let any ?loc ?attrs () = mk ?loc ?attrs Ptyp_any\n let var ?loc ?attrs a = mk ?loc ?attrs (Ptyp_var a)\n let arrow ?loc ?attrs a b c = mk ?loc ?attrs (Ptyp_arrow (a, b, c))\n let tuple ?loc ?attrs a = mk ?loc ?attrs (Ptyp_tuple a)\n let constr ?loc ?attrs a b = mk ?loc ?attrs (Ptyp_constr (a, b))\n let object_ ?loc ?attrs a b = mk ?loc ?attrs (Ptyp_object (a, b))\n let class_ ?loc ?attrs a b = mk ?loc ?attrs (Ptyp_class (a, b))\n let alias ?loc ?attrs a b = mk ?loc ?attrs (Ptyp_alias (a, b))\n let variant ?loc ?attrs a b c = mk ?loc ?attrs (Ptyp_variant (a, b, c))\n let poly ?loc ?attrs a b = mk ?loc ?attrs (Ptyp_poly (a, b))\n let package ?loc ?attrs a b = mk ?loc ?attrs (Ptyp_package (a, b))\n let extension ?loc ?attrs a = mk ?loc ?attrs (Ptyp_extension a)\n\n let force_poly t =\n match t.ptyp_desc with Ptyp_poly _ -> t | _ -> poly ~loc:t.ptyp_loc [] t\n (* -> ghost? *)\n\n let varify_constructors var_names t =\n let check_variable vl loc v =\n if List.mem v vl then\n Location.raise_errorf ~loc \"variable in scope syntax error: %s\" v\n in\n let var_names = List.map (fun v -> v.txt) var_names in\n let rec loop t =\n let desc =\n match t.ptyp_desc with\n | Ptyp_any -> Ptyp_any\n | Ptyp_var x ->\n check_variable var_names t.ptyp_loc x;\n Ptyp_var x\n | Ptyp_arrow (label, core_type, core_type') ->\n Ptyp_arrow (label, loop core_type, loop core_type')\n | Ptyp_tuple lst -> Ptyp_tuple (List.map loop lst)\n | Ptyp_constr ({ txt = Longident.Lident s }, [])\n when List.mem s var_names ->\n Ptyp_var s\n | Ptyp_constr (longident, lst) ->\n Ptyp_constr (longident, List.map loop lst)\n | Ptyp_object (lst, o) -> Ptyp_object (List.map loop_object_field lst, o)\n | Ptyp_class (longident, lst) ->\n Ptyp_class (longident, List.map loop lst)\n | Ptyp_alias (core_type, string) ->\n check_variable var_names t.ptyp_loc string;\n Ptyp_alias (loop core_type, string)\n | Ptyp_variant (row_field_list, flag, lbl_lst_option) ->\n Ptyp_variant\n (List.map loop_row_field row_field_list, flag, lbl_lst_option)\n | Ptyp_poly (string_lst, core_type) ->\n List.iter\n (fun v -> check_variable var_names t.ptyp_loc v.txt)\n string_lst;\n Ptyp_poly (string_lst, loop core_type)\n | Ptyp_package (longident, lst) ->\n Ptyp_package\n (longident, List.map (fun (n, typ) -> (n, loop typ)) lst)\n | Ptyp_extension (s, arg) -> Ptyp_extension (s, arg)\n in\n { t with ptyp_desc = desc }\n and loop_row_field field =\n let prf_desc =\n match field.prf_desc with\n | Rtag (label, flag, lst) -> Rtag (label, flag, List.map loop lst)\n | Rinherit t -> Rinherit (loop t)\n in\n { field with prf_desc }\n and loop_object_field field =\n let pof_desc =\n match field.pof_desc with\n | Otag (label, t) -> Otag (label, loop t)\n | Oinherit t -> Oinherit (loop t)\n in\n { field with pof_desc }\n in\n loop t\nend\n\nmodule Pat = struct\n let mk ?(loc = !default_loc) ?(attrs = []) d =\n {\n ppat_desc = d;\n ppat_loc = loc;\n ppat_loc_stack = [];\n ppat_attributes = attrs;\n }\n\n let attr d a = { d with ppat_attributes = d.ppat_attributes @ [ a ] }\n let any ?loc ?attrs () = mk ?loc ?attrs Ppat_any\n let var ?loc ?attrs a = mk ?loc ?attrs (Ppat_var a)\n let alias ?loc ?attrs a b = mk ?loc ?attrs (Ppat_alias (a, b))\n let constant ?loc ?attrs a = mk ?loc ?attrs (Ppat_constant a)\n let interval ?loc ?attrs a b = mk ?loc ?attrs (Ppat_interval (a, b))\n let tuple ?loc ?attrs a = mk ?loc ?attrs (Ppat_tuple a)\n let construct ?loc ?attrs a b = mk ?loc ?attrs (Ppat_construct (a, b))\n let variant ?loc ?attrs a b = mk ?loc ?attrs (Ppat_variant (a, b))\n let record ?loc ?attrs a b = mk ?loc ?attrs (Ppat_record (a, b))\n let array ?loc ?attrs a = mk ?loc ?attrs (Ppat_array a)\n let or_ ?loc ?attrs a b = mk ?loc ?attrs (Ppat_or (a, b))\n let constraint_ ?loc ?attrs a b = mk ?loc ?attrs (Ppat_constraint (a, b))\n let type_ ?loc ?attrs a = mk ?loc ?attrs (Ppat_type a)\n let lazy_ ?loc ?attrs a = mk ?loc ?attrs (Ppat_lazy a)\n let unpack ?loc ?attrs a = mk ?loc ?attrs (Ppat_unpack a)\n let open_ ?loc ?attrs a b = mk ?loc ?attrs (Ppat_open (a, b))\n let exception_ ?loc ?attrs a = mk ?loc ?attrs (Ppat_exception a)\n let extension ?loc ?attrs a = mk ?loc ?attrs (Ppat_extension a)\nend\n\nmodule Exp = struct\n let mk ?(loc = !default_loc) ?(attrs = []) d =\n {\n pexp_desc = d;\n pexp_loc = loc;\n pexp_loc_stack = [];\n pexp_attributes = attrs;\n }\n\n let attr d a = { d with pexp_attributes = d.pexp_attributes @ [ a ] }\n let ident ?loc ?attrs a = mk ?loc ?attrs (Pexp_ident a)\n let constant ?loc ?attrs a = mk ?loc ?attrs (Pexp_constant a)\n let let_ ?loc ?attrs a b c = mk ?loc ?attrs (Pexp_let (a, b, c))\n let fun_ ?loc ?attrs a b c d = mk ?loc ?attrs (Pexp_fun (a, b, c, d))\n let function_ ?loc ?attrs a = mk ?loc ?attrs (Pexp_function a)\n let apply ?loc ?attrs a b = mk ?loc ?attrs (Pexp_apply (a, b))\n let match_ ?loc ?attrs a b = mk ?loc ?attrs (Pexp_match (a, b))\n let try_ ?loc ?attrs a b = mk ?loc ?attrs (Pexp_try (a, b))\n let tuple ?loc ?attrs a = mk ?loc ?attrs (Pexp_tuple a)\n let construct ?loc ?attrs a b = mk ?loc ?attrs (Pexp_construct (a, b))\n let variant ?loc ?attrs a b = mk ?loc ?attrs (Pexp_variant (a, b))\n let record ?loc ?attrs a b = mk ?loc ?attrs (Pexp_record (a, b))\n let field ?loc ?attrs a b = mk ?loc ?attrs (Pexp_field (a, b))\n let setfield ?loc ?attrs a b c = mk ?loc ?attrs (Pexp_setfield (a, b, c))\n let array ?loc ?attrs a = mk ?loc ?attrs (Pexp_array a)\n let ifthenelse ?loc ?attrs a b c = mk ?loc ?attrs (Pexp_ifthenelse (a, b, c))\n let sequence ?loc ?attrs a b = mk ?loc ?attrs (Pexp_sequence (a, b))\n let while_ ?loc ?attrs a b = mk ?loc ?attrs (Pexp_while (a, b))\n let for_ ?loc ?attrs a b c d e = mk ?loc ?attrs (Pexp_for (a, b, c, d, e))\n let constraint_ ?loc ?attrs a b = mk ?loc ?attrs (Pexp_constraint (a, b))\n let coerce ?loc ?attrs a b c = mk ?loc ?attrs (Pexp_coerce (a, b, c))\n let send ?loc ?attrs a b = mk ?loc ?attrs (Pexp_send (a, b))\n let new_ ?loc ?attrs a = mk ?loc ?attrs (Pexp_new a)\n let setinstvar ?loc ?attrs a b = mk ?loc ?attrs (Pexp_setinstvar (a, b))\n let override ?loc ?attrs a = mk ?loc ?attrs (Pexp_override a)\n let letmodule ?loc ?attrs a b c = mk ?loc ?attrs (Pexp_letmodule (a, b, c))\n let letexception ?loc ?attrs a b = mk ?loc ?attrs (Pexp_letexception (a, b))\n let assert_ ?loc ?attrs a = mk ?loc ?attrs (Pexp_assert a)\n let lazy_ ?loc ?attrs a = mk ?loc ?attrs (Pexp_lazy a)\n let poly ?loc ?attrs a b = mk ?loc ?attrs (Pexp_poly (a, b))\n let object_ ?loc ?attrs a = mk ?loc ?attrs (Pexp_object a)\n let newtype ?loc ?attrs a b = mk ?loc ?attrs (Pexp_newtype (a, b))\n let pack ?loc ?attrs a = mk ?loc ?attrs (Pexp_pack a)\n let open_ ?loc ?attrs a b = mk ?loc ?attrs (Pexp_open (a, b))\n\n let letop ?loc ?attrs let_ ands body =\n mk ?loc ?attrs (Pexp_letop { let_; ands; body })\n\n let extension ?loc ?attrs a = mk ?loc ?attrs (Pexp_extension a)\n let unreachable ?loc ?attrs () = mk ?loc ?attrs Pexp_unreachable\n let case lhs ?guard rhs = { pc_lhs = lhs; pc_guard = guard; pc_rhs = rhs }\n\n let binding_op op pat exp loc =\n { pbop_op = op; pbop_pat = pat; pbop_exp = exp; pbop_loc = loc }\nend\n\nmodule Mty = struct\n let mk ?(loc = !default_loc) ?(attrs = []) d =\n { pmty_desc = d; pmty_loc = loc; pmty_attributes = attrs }\n\n let attr d a = { d with pmty_attributes = d.pmty_attributes @ [ a ] }\n let ident ?loc ?attrs a = mk ?loc ?attrs (Pmty_ident a)\n let alias ?loc ?attrs a = mk ?loc ?attrs (Pmty_alias a)\n let signature ?loc ?attrs a = mk ?loc ?attrs (Pmty_signature a)\n let functor_ ?loc ?attrs a b = mk ?loc ?attrs (Pmty_functor (a, b))\n let with_ ?loc ?attrs a b = mk ?loc ?attrs (Pmty_with (a, b))\n let typeof_ ?loc ?attrs a = mk ?loc ?attrs (Pmty_typeof a)\n let extension ?loc ?attrs a = mk ?loc ?attrs (Pmty_extension a)\nend\n\nmodule Mod = struct\n let mk ?(loc = !default_loc) ?(attrs = []) d =\n { pmod_desc = d; pmod_loc = loc; pmod_attributes = attrs }\n\n let attr d a = { d with pmod_attributes = d.pmod_attributes @ [ a ] }\n let ident ?loc ?attrs x = mk ?loc ?attrs (Pmod_ident x)\n let structure ?loc ?attrs x = mk ?loc ?attrs (Pmod_structure x)\n let functor_ ?loc ?attrs arg body = mk ?loc ?attrs (Pmod_functor (arg, body))\n let apply ?loc ?attrs m1 m2 = mk ?loc ?attrs (Pmod_apply (m1, m2))\n let constraint_ ?loc ?attrs m mty = mk ?loc ?attrs (Pmod_constraint (m, mty))\n let unpack ?loc ?attrs e = mk ?loc ?attrs (Pmod_unpack e)\n let extension ?loc ?attrs a = mk ?loc ?attrs (Pmod_extension a)\nend\n\nmodule Sig = struct\n let mk ?(loc = !default_loc) d = { psig_desc = d; psig_loc = loc }\n let value ?loc a = mk ?loc (Psig_value a)\n let type_ ?loc rec_flag a = mk ?loc (Psig_type (rec_flag, a))\n let type_subst ?loc a = mk ?loc (Psig_typesubst a)\n let type_extension ?loc a = mk ?loc (Psig_typext a)\n let exception_ ?loc a = mk ?loc (Psig_exception a)\n let module_ ?loc a = mk ?loc (Psig_module a)\n let mod_subst ?loc a = mk ?loc (Psig_modsubst a)\n let rec_module ?loc a = mk ?loc (Psig_recmodule a)\n let modtype ?loc a = mk ?loc (Psig_modtype a)\n let open_ ?loc a = mk ?loc (Psig_open a)\n let include_ ?loc a = mk ?loc (Psig_include a)\n let class_ ?loc a = mk ?loc (Psig_class a)\n let class_type ?loc a = mk ?loc (Psig_class_type a)\n let extension ?loc ?(attrs = []) a = mk ?loc (Psig_extension (a, attrs))\n let attribute ?loc a = mk ?loc (Psig_attribute a)\nend\n\nmodule Str = struct\n let mk ?(loc = !default_loc) d = { pstr_desc = d; pstr_loc = loc }\n let eval ?loc ?(attrs = []) a = mk ?loc (Pstr_eval (a, attrs))\n let value ?loc a b = mk ?loc (Pstr_value (a, b))\n let primitive ?loc a = mk ?loc (Pstr_primitive a)\n let type_ ?loc rec_flag a = mk ?loc (Pstr_type (rec_flag, a))\n let type_extension ?loc a = mk ?loc (Pstr_typext a)\n let exception_ ?loc a = mk ?loc (Pstr_exception a)\n let module_ ?loc a = mk ?loc (Pstr_module a)\n let rec_module ?loc a = mk ?loc (Pstr_recmodule a)\n let modtype ?loc a = mk ?loc (Pstr_modtype a)\n let open_ ?loc a = mk ?loc (Pstr_open a)\n let class_ ?loc a = mk ?loc (Pstr_class a)\n let class_type ?loc a = mk ?loc (Pstr_class_type a)\n let include_ ?loc a = mk ?loc (Pstr_include a)\n let extension ?loc ?(attrs = []) a = mk ?loc (Pstr_extension (a, attrs))\n let attribute ?loc a = mk ?loc (Pstr_attribute a)\nend\n\nmodule Cl = struct\n let mk ?(loc = !default_loc) ?(attrs = []) d =\n { pcl_desc = d; pcl_loc = loc; pcl_attributes = attrs }\n\n let attr d a = { d with pcl_attributes = d.pcl_attributes @ [ a ] }\n let constr ?loc ?attrs a b = mk ?loc ?attrs (Pcl_constr (a, b))\n let structure ?loc ?attrs a = mk ?loc ?attrs (Pcl_structure a)\n let fun_ ?loc ?attrs a b c d = mk ?loc ?attrs (Pcl_fun (a, b, c, d))\n let apply ?loc ?attrs a b = mk ?loc ?attrs (Pcl_apply (a, b))\n let let_ ?loc ?attrs a b c = mk ?loc ?attrs (Pcl_let (a, b, c))\n let constraint_ ?loc ?attrs a b = mk ?loc ?attrs (Pcl_constraint (a, b))\n let extension ?loc ?attrs a = mk ?loc ?attrs (Pcl_extension a)\n let open_ ?loc ?attrs a b = mk ?loc ?attrs (Pcl_open (a, b))\nend\n\nmodule Cty = struct\n let mk ?(loc = !default_loc) ?(attrs = []) d =\n { pcty_desc = d; pcty_loc = loc; pcty_attributes = attrs }\n\n let attr d a = { d with pcty_attributes = d.pcty_attributes @ [ a ] }\n let constr ?loc ?attrs a b = mk ?loc ?attrs (Pcty_constr (a, b))\n let signature ?loc ?attrs a = mk ?loc ?attrs (Pcty_signature a)\n let arrow ?loc ?attrs a b c = mk ?loc ?attrs (Pcty_arrow (a, b, c))\n let extension ?loc ?attrs a = mk ?loc ?attrs (Pcty_extension a)\n let open_ ?loc ?attrs a b = mk ?loc ?attrs (Pcty_open (a, b))\nend\n\nmodule Ctf = struct\n let mk ?(loc = !default_loc) ?(attrs = []) d =\n { pctf_desc = d; pctf_loc = loc; pctf_attributes = attrs }\n\n let inherit_ ?loc ?attrs a = mk ?loc ?attrs (Pctf_inherit a)\n let val_ ?loc ?attrs a b c d = mk ?loc ?attrs (Pctf_val (a, b, c, d))\n let method_ ?loc ?attrs a b c d = mk ?loc ?attrs (Pctf_method (a, b, c, d))\n let constraint_ ?loc ?attrs a b = mk ?loc ?attrs (Pctf_constraint (a, b))\n let extension ?loc ?attrs a = mk ?loc ?attrs (Pctf_extension a)\n let attribute ?loc a = mk ?loc (Pctf_attribute a)\n let attr d a = { d with pctf_attributes = d.pctf_attributes @ [ a ] }\nend\n\nmodule Cf = struct\n let mk ?(loc = !default_loc) ?(attrs = []) d =\n { pcf_desc = d; pcf_loc = loc; pcf_attributes = attrs }\n\n let inherit_ ?loc ?attrs a b c = mk ?loc ?attrs (Pcf_inherit (a, b, c))\n let val_ ?loc ?attrs a b c = mk ?loc ?attrs (Pcf_val (a, b, c))\n let method_ ?loc ?attrs a b c = mk ?loc ?attrs (Pcf_method (a, b, c))\n let constraint_ ?loc ?attrs a b = mk ?loc ?attrs (Pcf_constraint (a, b))\n let initializer_ ?loc ?attrs a = mk ?loc ?attrs (Pcf_initializer a)\n let extension ?loc ?attrs a = mk ?loc ?attrs (Pcf_extension a)\n let attribute ?loc a = mk ?loc (Pcf_attribute a)\n let virtual_ ct = Cfk_virtual ct\n let concrete o e = Cfk_concrete (o, e)\n let attr d a = { d with pcf_attributes = d.pcf_attributes @ [ a ] }\nend\n\nmodule Val = struct\n let mk ?(loc = !default_loc) ?(attrs = []) ?(prim = []) name typ =\n {\n pval_name = name;\n pval_type = typ;\n pval_attributes = attrs;\n pval_loc = loc;\n pval_prim = prim;\n }\nend\n\nmodule Md = struct\n let mk ?(loc = !default_loc) ?(attrs = []) name typ =\n { pmd_name = name; pmd_type = typ; pmd_attributes = attrs; pmd_loc = loc }\nend\n\nmodule Ms = struct\n let mk ?(loc = !default_loc) ?(attrs = []) name syn =\n {\n pms_name = name;\n pms_manifest = syn;\n pms_attributes = attrs;\n pms_loc = loc;\n }\nend\n\nmodule Mtd = struct\n let mk ?(loc = !default_loc) ?(attrs = []) ?typ name =\n {\n pmtd_name = name;\n pmtd_type = typ;\n pmtd_attributes = attrs;\n pmtd_loc = loc;\n }\nend\n\nmodule Mb = struct\n let mk ?(loc = !default_loc) ?(attrs = []) name expr =\n { pmb_name = name; pmb_expr = expr; pmb_attributes = attrs; pmb_loc = loc }\nend\n\nmodule Opn = struct\n let mk ?(loc = !default_loc) ?(attrs = []) ?(override = Fresh) expr =\n {\n popen_expr = expr;\n popen_override = override;\n popen_loc = loc;\n popen_attributes = attrs;\n }\nend\n\nmodule Incl = struct\n let mk ?(loc = !default_loc) ?(attrs = []) mexpr =\n { pincl_mod = mexpr; pincl_loc = loc; pincl_attributes = attrs }\nend\n\nmodule Vb = struct\n let mk ?(loc = !default_loc) ?(attrs = []) pat expr =\n { pvb_pat = pat; pvb_expr = expr; pvb_attributes = attrs; pvb_loc = loc }\nend\n\nmodule Ci = struct\n let mk ?(loc = !default_loc) ?(attrs = []) ?(virt = Concrete) ?(params = [])\n name expr =\n {\n pci_virt = virt;\n pci_params = params;\n pci_name = name;\n pci_expr = expr;\n pci_attributes = attrs;\n pci_loc = loc;\n }\nend\n\nmodule Type = struct\n let mk ?(loc = !default_loc) ?(attrs = []) ?(params = []) ?(cstrs = [])\n ?(kind = Ptype_abstract) ?(priv = Public) ?manifest name =\n {\n ptype_name = name;\n ptype_params = params;\n ptype_cstrs = cstrs;\n ptype_kind = kind;\n ptype_private = priv;\n ptype_manifest = manifest;\n ptype_attributes = attrs;\n ptype_loc = loc;\n }\n\n let constructor ?(loc = !default_loc) ?(attrs = []) ?(args = Pcstr_tuple [])\n ?res name =\n {\n pcd_name = name;\n pcd_args = args;\n pcd_res = res;\n pcd_loc = loc;\n pcd_attributes = attrs;\n }\n\n let field ?(loc = !default_loc) ?(attrs = []) ?(mut = Immutable) name typ =\n {\n pld_name = name;\n pld_mutable = mut;\n pld_type = typ;\n pld_loc = loc;\n pld_attributes = attrs;\n }\nend\n\n(** Type extensions *)\nmodule Te = struct\n let mk ?(loc = !default_loc) ?(attrs = []) ?(params = []) ?(priv = Public)\n path constructors =\n {\n ptyext_path = path;\n ptyext_params = params;\n ptyext_constructors = constructors;\n ptyext_private = priv;\n ptyext_loc = loc;\n ptyext_attributes = attrs;\n }\n\n let mk_exception ?(loc = !default_loc) ?(attrs = []) constructor =\n {\n ptyexn_constructor = constructor;\n ptyexn_loc = loc;\n ptyexn_attributes = attrs;\n }\n\n let constructor ?(loc = !default_loc) ?(attrs = []) name kind =\n {\n pext_name = name;\n pext_kind = kind;\n pext_loc = loc;\n pext_attributes = attrs;\n }\n\n let decl ?(loc = !default_loc) ?(attrs = []) ?(args = Pcstr_tuple []) ?res\n name =\n {\n pext_name = name;\n pext_kind = Pext_decl (args, res);\n pext_loc = loc;\n pext_attributes = attrs;\n }\n\n let rebind ?(loc = !default_loc) ?(attrs = []) name lid =\n {\n pext_name = name;\n pext_kind = Pext_rebind lid;\n pext_loc = loc;\n pext_attributes = attrs;\n }\nend\n\nmodule Csig = struct\n let mk self fields = { pcsig_self = self; pcsig_fields = fields }\nend\n\nmodule Cstr = struct\n let mk self fields = { pcstr_self = self; pcstr_fields = fields }\nend\n\n(** Row fields *)\nmodule Rf = struct\n let mk ?(loc = !default_loc) ?(attrs = []) desc =\n { prf_desc = desc; prf_loc = loc; prf_attributes = attrs }\n\n let tag ?loc ?attrs label const tys =\n mk ?loc ?attrs (Rtag (label, const, tys))\n\n let inherit_ ?loc ty = mk ?loc (Rinherit ty)\nend\n\n(** Object fields *)\nmodule Of = struct\n let mk ?(loc = !default_loc) ?(attrs = []) desc =\n { pof_desc = desc; pof_loc = loc; pof_attributes = attrs }\n\n let tag ?loc ?attrs label ty = mk ?loc ?attrs (Otag (label, ty))\n let inherit_ ?loc ty = mk ?loc (Oinherit ty)\nend\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Daniel C. Buenzli *)\n(* *)\n(* Copyright 2014 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nexternal format_int : string -> int -> string = \"caml_format_int\"\n\nlet err_no_pred = \"U+0000 has no predecessor\"\nlet err_no_succ = \"U+10FFFF has no successor\"\nlet err_not_sv i = format_int \"%X\" i ^ \" is not an Unicode scalar value\"\nlet err_not_latin1 u = \"U+\" ^ format_int \"%04X\" u ^ \" is not a latin1 character\"\n\ntype t = int\n\nlet min = 0x0000\nlet max = 0x10FFFF\nlet lo_bound = 0xD7FF\nlet hi_bound = 0xE000\n\nlet bom = 0xFEFF\nlet rep = 0xFFFD\n\nlet succ u =\n if u = lo_bound then hi_bound else\n if u = max then invalid_arg err_no_succ else\n u + 1\n\nlet pred u =\n if u = hi_bound then lo_bound else\n if u = min then invalid_arg err_no_pred else\n u - 1\n\nlet is_valid i = (min <= i && i <= lo_bound) || (hi_bound <= i && i <= max)\nlet of_int i = if is_valid i then i else invalid_arg (err_not_sv i)\nexternal unsafe_of_int : int -> t = \"%identity\"\nexternal to_int : t -> int = \"%identity\"\n\nlet is_char u = u < 256\nlet of_char c = Char.code c\nlet to_char u =\n if u > 255 then invalid_arg (err_not_latin1 u) else\n Char.unsafe_chr u\n\nlet unsafe_to_char = Char.unsafe_chr\n\nlet equal : int -> int -> bool = ( = )\nlet compare : int -> int -> int = Stdlib.compare\nlet hash = to_int\n\n(* UTF codecs tools *)\n\ntype utf_decode = int\n(* This is an int [0xDUUUUUU] decomposed as follows:\n - [D] is four bits for decode information, the highest bit is set if the\n decode is valid. The three lower bits indicate the number of elements\n from the source that were consumed by the decode.\n - [UUUUUU] is the decoded Unicode character or the Unicode replacement\n character U+FFFD if for invalid decodes. *)\n\nlet valid_bit = 27\nlet decode_bits = 24\n\nlet[@inline] utf_decode_is_valid d = (d lsr valid_bit) = 1\nlet[@inline] utf_decode_length d = (d lsr decode_bits) land 0b111\nlet[@inline] utf_decode_uchar d = unsafe_of_int (d land 0xFFFFFF)\nlet[@inline] utf_decode n u = ((8 lor n) lsl decode_bits) lor (to_int u)\nlet[@inline] utf_decode_invalid n = (n lsl decode_bits) lor rep\n\nlet utf_8_byte_length u = match to_int u with\n| u when u < 0 -> assert false\n| u when u <= 0x007F -> 1\n| u when u <= 0x07FF -> 2\n| u when u <= 0xFFFF -> 3\n| u when u <= 0x10FFFF -> 4\n| _ -> assert false\n\nlet utf_16_byte_length u = match to_int u with\n| u when u < 0 -> assert false\n| u when u <= 0xFFFF -> 2\n| u when u <= 0x10FFFF -> 4\n| _ -> assert false\n","module Int = struct\n let to_string = string_of_int\nend\n\nmodule Option = struct\n let map f o = match o with None -> None | Some v -> Some (f v)\nend\n","include Ocaml_common.Location\n\nlet set_input_name name = input_name := name\n\nmodule Error = struct\n [@@@warning \"-37\"]\n\n type old_t (*IF_NOT_AT_LEAST 408 = Ocaml_common.Location.error *) = {\n loc: t;\n msg: string;\n sub: old_t list;\n if_highlight: string;\n }\n\n type location_report_kind (*IF_AT_LEAST 408 = Ocaml_common.Location.report_kind *) =\n | Report_error\n | Report_warning of string\n | Report_warning_as_error of string\n | Report_alert of string\n | Report_alert_as_error of string\n\n type location_msg = (Format.formatter -> unit) loc\n\n type location_report (*IF_AT_LEAST 408 = Ocaml_common.Location.report *) = {\n kind : location_report_kind;\n main : location_msg;\n sub : location_msg list;\n }\n\n type t (*IF_AT_LEAST 408 = Ocaml_common.Location.error *) (*IF_NOT_AT_LEAST 408 = old_t *)\n (** On ocaml >= 4.08: [t] is a [location_report] for which [location_report_kind] must be [Report_error]. *)\n\n type version_specific_t = [`New_error of location_report | `Old_error of old_t]\n\n let version_specific_t_of_t : t -> version_specific_t = fun x ->\n (*IF_AT_LEAST 408 `New_error x *)\n (*IF_NOT_AT_LEAST 408 `Old_error x *)\n\n let is_well_formed error =\n match version_specific_t_of_t error with\n | `New_error { kind = Report_error; _ } -> true\n | `New_error _ -> false\n | `Old_error _ -> true\n\n let string_of_location_msg (msg : location_msg) = Format.asprintf \"%t\" msg.txt\n\n let main_msg error =\n match version_specific_t_of_t error with\n | `New_error { main; _ } ->\n { txt = string_of_location_msg main; loc = main.loc }\n | `Old_error { msg; loc; _ } -> { txt = msg; loc }\n\n let sub_msgs error =\n match version_specific_t_of_t error with\n | `New_error { sub; _ } ->\n List.map\n (fun err -> { txt = string_of_location_msg err; loc = err.loc })\n sub\n | `Old_error { sub; _ } ->\n let rec deeply_flattened_sub_msgs acc = function\n | [] -> acc\n | { loc; msg; sub; _ } :: tail ->\n deeply_flattened_sub_msgs ({ txt = msg; loc } :: acc) (sub @ tail)\n in\n deeply_flattened_sub_msgs [] sub\n\n let of_exn exn =\n (*IF_AT_LEAST 406 match error_of_exn exn with | Some (`Ok e) -> Some e | None | Some `Already_displayed -> None *)\n (*IF_NOT_AT_LEAST 406 error_of_exn exn*)\n\n let _set_main_msg_old error msg = { error with msg }\n\n let _set_main_msg_new error msg =\n let txt ppf = Format.pp_print_string ppf msg in\n let main = { error.main with txt } in\n { error with main }\n\n let set_main_msg error msg =\n (*IF_NOT_AT_LEAST 408 _set_main_msg_old error msg*)\n (*IF_AT_LEAST 408 _set_main_msg_new error msg*)\n\n let _make_error_of_message_old ~sub { loc; txt } =\n let sub =\n List.map\n (fun { loc; txt } -> { loc; msg = txt; sub = []; if_highlight = txt })\n sub\n in\n { loc; msg = txt; sub; if_highlight = txt }\n\n let _make_error_of_message_new ~sub { loc; txt } =\n let mk_txt x ppf = Format.pp_print_string ppf x in\n let mk loc x = { loc; txt = mk_txt x } in\n {\n kind = Report_error;\n main = mk loc txt;\n sub = List.map (fun { loc; txt } -> mk loc txt) sub;\n }\n\n let make ~sub msg =\n (*IF_NOT_AT_LEAST 408 _make_error_of_message_old ~sub msg*)\n (*IF_AT_LEAST 408 _make_error_of_message_new ~sub msg*)\n\n let _set_main_loc_old error loc = { error with loc }\n\n let _set_main_loc_new error loc =\n let main = { error.main with loc } in\n { error with main }\n\n let set_main_loc error loc =\n (*IF_NOT_AT_LEAST 408 _set_main_loc_old error loc*)\n (*IF_AT_LEAST 408 _set_main_loc_new error loc*)\nend\n\nlet raise_errorf ?loc msg = raise_errorf ?loc msg\n","(*$ open Ppxlib_cinaps_helpers $*)\nopen! Import\nmodule Format = Caml.Format\nmodule Filename = Caml.Filename\n\n(* TODO: make the \"deriving.\" depend on the matching attribute name. *)\nlet end_marker_sig =\n Attribute.Floating.declare \"deriving.end\" Signature_item\n Ast_pattern.(pstr nil)\n ()\n\nlet end_marker_str =\n Attribute.Floating.declare \"deriving.end\" Structure_item\n Ast_pattern.(pstr nil)\n ()\n\nmodule type T1 = sig\n type 'a t\nend\n\nmodule Make (M : sig\n type t\n\n val get_loc : t -> Location.t\n val end_marker : (t, unit) Attribute.Floating.t\n\n module Transform (T : T1) : sig\n val apply :\n < structure_item : structure_item T.t\n ; signature_item : signature_item T.t\n ; .. > ->\n t T.t\n end\n\n val parse : Lexing.lexbuf -> t list\n val pp : Format.formatter -> t -> unit\n val to_sexp : t -> Sexp.t\nend) =\nstruct\n let extract_prefix ~pos l =\n let rec loop acc = function\n | [] ->\n let loc =\n { Location.loc_start = pos; loc_end = pos; loc_ghost = false }\n in\n Location.raise_errorf ~loc \"ppxlib: [@@@@@@%s] attribute missing\"\n (Attribute.Floating.name M.end_marker)\n | x :: l -> (\n match Attribute.Floating.convert [ M.end_marker ] x with\n | None -> loop (x :: acc) l\n | Some () -> (List.rev acc, (M.get_loc x).loc_start)\n | exception Failure _ -> loop (x :: acc) l)\n in\n loop [] l\n\n let remove_loc =\n object\n inherit Ast_traverse.map\n method! location _ = Location.none\n method! location_stack _ = []\n end\n\n module M_map = M.Transform (struct\n type 'a t = 'a -> 'a\n end)\n\n let remove_loc x = M_map.apply remove_loc x\n let rec last prev = function [] -> prev | x :: l -> last x l\n\n let diff_asts ~generated ~round_trip =\n let with_temp_file f =\n Exn.protectx (Filename.temp_file \"ppxlib\" \"\") ~finally:Caml.Sys.remove ~f\n in\n with_temp_file (fun fn1 ->\n with_temp_file (fun fn2 ->\n with_temp_file (fun out ->\n let dump fn ast =\n Out_channel.with_file fn ~f:(fun oc ->\n let ppf = Format.formatter_of_out_channel oc in\n Sexp.pp_hum ppf (M.to_sexp ast);\n Format.pp_print_flush ppf ())\n in\n dump fn1 generated;\n dump fn2 round_trip;\n let cmd =\n Printf.sprintf\n \"patdiff -ascii -alt-old generated -alt-new \\\n 'generated->printed->parsed' %s %s &> %s\"\n (Filename.quote fn1) (Filename.quote fn2)\n (Filename.quote out)\n in\n let ok =\n Caml.Sys.command cmd = 1\n ||\n let cmd =\n Printf.sprintf\n \"diff --label generated --label \\\n 'generated->printed->parsed' %s %s &> %s\"\n (Filename.quote fn1) (Filename.quote fn2)\n (Filename.quote out)\n in\n Caml.Sys.command cmd = 1\n in\n if ok then In_channel.read_all out\n else \"\")))\n\n let parse_string s =\n match M.parse (Lexing.from_string s) with [ x ] -> x | _ -> assert false\n\n let rec match_loop ~end_pos ~mismatch_handler ~expected ~source =\n match (expected, source) with\n | [], [] -> ()\n | [], x :: l ->\n let loc =\n { (M.get_loc x) with loc_end = (M.get_loc (last x l)).loc_end }\n in\n mismatch_handler loc []\n | _, [] ->\n let loc =\n { Location.loc_ghost = false; loc_start = end_pos; loc_end = end_pos }\n in\n mismatch_handler loc expected\n | x :: expected, y :: source ->\n let loc = M.get_loc y in\n let x = remove_loc x in\n let y = remove_loc y in\n if Poly.( <> ) x y then (\n let round_trip =\n remove_loc (parse_string (Format.asprintf \"%a@.\" M.pp x))\n in\n if Poly.( <> ) x round_trip then\n Location.raise_errorf ~loc\n \"ppxlib: the corrected code doesn't round-trip.\\n\\\n This is probably a bug in the OCaml printer:\\n\\\n %s\"\n (diff_asts ~generated:x ~round_trip);\n mismatch_handler loc [ x ]);\n match_loop ~end_pos ~mismatch_handler ~expected ~source\n\n let do_match ~pos ~expected ~mismatch_handler source =\n let source, end_pos = extract_prefix ~pos source in\n match_loop ~end_pos ~mismatch_handler ~expected ~source\nend\n\n(*$*)\nmodule Str = Make (struct\n type t = structure_item\n\n let get_loc x = x.pstr_loc\n let end_marker = end_marker_str\n\n module Transform (T : T1) = struct\n let apply o = o#structure_item\n end\n\n let parse = Parse.implementation\n let pp = Pprintast.structure_item\n let to_sexp = Ast_traverse.sexp_of#structure_item\nend)\n\n(*$ str_to_sig _last_text_block *)\nmodule Sig = Make (struct\n type t = signature_item\n\n let get_loc x = x.psig_loc\n let end_marker = end_marker_sig\n\n module Transform (T : T1) = struct\n let apply o = o#signature_item\n end\n\n let parse = Parse.interface\n let pp = Pprintast.signature_item\n let to_sexp = Ast_traverse.sexp_of#signature_item\nend)\n\n(*$*)\n\nlet match_structure = Str.do_match\nlet match_signature = Sig.do_match\n","open Stdlib0\nmodule From = Ast_414\nmodule To = Ast_413\n\nlet migration_error loc missing_feature =\n Location.raise_errorf ~loc\n \"migration error: %s is not supported before OCaml 4.13\" missing_feature\n\nlet rec copy_toplevel_phrase :\n Ast_414.Parsetree.toplevel_phrase -> Ast_413.Parsetree.toplevel_phrase =\n function\n | Ast_414.Parsetree.Ptop_def x0 ->\n Ast_413.Parsetree.Ptop_def (copy_structure x0)\n | Ast_414.Parsetree.Ptop_dir x0 ->\n Ast_413.Parsetree.Ptop_dir (copy_toplevel_directive x0)\n\nand copy_toplevel_directive :\n Ast_414.Parsetree.toplevel_directive -> Ast_413.Parsetree.toplevel_directive\n =\n fun {\n Ast_414.Parsetree.pdir_name;\n Ast_414.Parsetree.pdir_arg;\n Ast_414.Parsetree.pdir_loc;\n } ->\n {\n Ast_413.Parsetree.pdir_name = copy_loc (fun x -> x) pdir_name;\n Ast_413.Parsetree.pdir_arg = Option.map copy_directive_argument pdir_arg;\n Ast_413.Parsetree.pdir_loc = copy_location pdir_loc;\n }\n\nand copy_directive_argument :\n Ast_414.Parsetree.directive_argument -> Ast_413.Parsetree.directive_argument\n =\n fun { Ast_414.Parsetree.pdira_desc; Ast_414.Parsetree.pdira_loc } ->\n {\n Ast_413.Parsetree.pdira_desc = copy_directive_argument_desc pdira_desc;\n Ast_413.Parsetree.pdira_loc = copy_location pdira_loc;\n }\n\nand copy_directive_argument_desc :\n Ast_414.Parsetree.directive_argument_desc ->\n Ast_413.Parsetree.directive_argument_desc = function\n | Ast_414.Parsetree.Pdir_string x0 -> Ast_413.Parsetree.Pdir_string x0\n | Ast_414.Parsetree.Pdir_int (x0, x1) ->\n Ast_413.Parsetree.Pdir_int (x0, Option.map (fun x -> x) x1)\n | Ast_414.Parsetree.Pdir_ident x0 ->\n Ast_413.Parsetree.Pdir_ident (copy_Longident_t x0)\n | Ast_414.Parsetree.Pdir_bool x0 -> Ast_413.Parsetree.Pdir_bool x0\n\nand copy_expression :\n Ast_414.Parsetree.expression -> Ast_413.Parsetree.expression =\n fun {\n Ast_414.Parsetree.pexp_desc;\n Ast_414.Parsetree.pexp_loc;\n Ast_414.Parsetree.pexp_loc_stack;\n Ast_414.Parsetree.pexp_attributes;\n } ->\n {\n Ast_413.Parsetree.pexp_desc = copy_expression_desc pexp_desc;\n Ast_413.Parsetree.pexp_loc = copy_location pexp_loc;\n Ast_413.Parsetree.pexp_loc_stack = copy_location_stack pexp_loc_stack;\n Ast_413.Parsetree.pexp_attributes = copy_attributes pexp_attributes;\n }\n\nand copy_expression_desc :\n Ast_414.Parsetree.expression_desc -> Ast_413.Parsetree.expression_desc =\n function\n | Ast_414.Parsetree.Pexp_ident x0 ->\n Ast_413.Parsetree.Pexp_ident (copy_loc copy_Longident_t x0)\n | Ast_414.Parsetree.Pexp_constant x0 ->\n Ast_413.Parsetree.Pexp_constant (copy_constant x0)\n | Ast_414.Parsetree.Pexp_let (x0, x1, x2) ->\n Ast_413.Parsetree.Pexp_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_expression x2)\n | Ast_414.Parsetree.Pexp_function x0 ->\n Ast_413.Parsetree.Pexp_function (List.map copy_case x0)\n | Ast_414.Parsetree.Pexp_fun (x0, x1, x2, x3) ->\n Ast_413.Parsetree.Pexp_fun\n ( copy_arg_label x0,\n Option.map copy_expression x1,\n copy_pattern x2,\n copy_expression x3 )\n | Ast_414.Parsetree.Pexp_apply (x0, x1) ->\n Ast_413.Parsetree.Pexp_apply\n ( copy_expression x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | Ast_414.Parsetree.Pexp_match (x0, x1) ->\n Ast_413.Parsetree.Pexp_match (copy_expression x0, List.map copy_case x1)\n | Ast_414.Parsetree.Pexp_try (x0, x1) ->\n Ast_413.Parsetree.Pexp_try (copy_expression x0, List.map copy_case x1)\n | Ast_414.Parsetree.Pexp_tuple x0 ->\n Ast_413.Parsetree.Pexp_tuple (List.map copy_expression x0)\n | Ast_414.Parsetree.Pexp_construct (x0, x1) ->\n Ast_413.Parsetree.Pexp_construct\n (copy_loc copy_Longident_t x0, Option.map copy_expression x1)\n | Ast_414.Parsetree.Pexp_variant (x0, x1) ->\n Ast_413.Parsetree.Pexp_variant\n (copy_label x0, Option.map copy_expression x1)\n | Ast_414.Parsetree.Pexp_record (x0, x1) ->\n Ast_413.Parsetree.Pexp_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_expression x1))\n x0,\n Option.map copy_expression x1 )\n | Ast_414.Parsetree.Pexp_field (x0, x1) ->\n Ast_413.Parsetree.Pexp_field\n (copy_expression x0, copy_loc copy_Longident_t x1)\n | Ast_414.Parsetree.Pexp_setfield (x0, x1, x2) ->\n Ast_413.Parsetree.Pexp_setfield\n (copy_expression x0, copy_loc copy_Longident_t x1, copy_expression x2)\n | Ast_414.Parsetree.Pexp_array x0 ->\n Ast_413.Parsetree.Pexp_array (List.map copy_expression x0)\n | Ast_414.Parsetree.Pexp_ifthenelse (x0, x1, x2) ->\n Ast_413.Parsetree.Pexp_ifthenelse\n (copy_expression x0, copy_expression x1, Option.map copy_expression x2)\n | Ast_414.Parsetree.Pexp_sequence (x0, x1) ->\n Ast_413.Parsetree.Pexp_sequence (copy_expression x0, copy_expression x1)\n | Ast_414.Parsetree.Pexp_while (x0, x1) ->\n Ast_413.Parsetree.Pexp_while (copy_expression x0, copy_expression x1)\n | Ast_414.Parsetree.Pexp_for (x0, x1, x2, x3, x4) ->\n Ast_413.Parsetree.Pexp_for\n ( copy_pattern x0,\n copy_expression x1,\n copy_expression x2,\n copy_direction_flag x3,\n copy_expression x4 )\n | Ast_414.Parsetree.Pexp_constraint (x0, x1) ->\n Ast_413.Parsetree.Pexp_constraint (copy_expression x0, copy_core_type x1)\n | Ast_414.Parsetree.Pexp_coerce (x0, x1, x2) ->\n Ast_413.Parsetree.Pexp_coerce\n (copy_expression x0, Option.map copy_core_type x1, copy_core_type x2)\n | Ast_414.Parsetree.Pexp_send (x0, x1) ->\n Ast_413.Parsetree.Pexp_send (copy_expression x0, copy_loc copy_label x1)\n | Ast_414.Parsetree.Pexp_new x0 ->\n Ast_413.Parsetree.Pexp_new (copy_loc copy_Longident_t x0)\n | Ast_414.Parsetree.Pexp_setinstvar (x0, x1) ->\n Ast_413.Parsetree.Pexp_setinstvar\n (copy_loc copy_label x0, copy_expression x1)\n | Ast_414.Parsetree.Pexp_override x0 ->\n Ast_413.Parsetree.Pexp_override\n (List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_label x0, copy_expression x1))\n x0)\n | Ast_414.Parsetree.Pexp_letmodule (x0, x1, x2) ->\n Ast_413.Parsetree.Pexp_letmodule\n ( copy_loc (fun x -> Option.map (fun x -> x) x) x0,\n copy_module_expr x1,\n copy_expression x2 )\n | Ast_414.Parsetree.Pexp_letexception (x0, x1) ->\n Ast_413.Parsetree.Pexp_letexception\n (copy_extension_constructor x0, copy_expression x1)\n | Ast_414.Parsetree.Pexp_assert x0 ->\n Ast_413.Parsetree.Pexp_assert (copy_expression x0)\n | Ast_414.Parsetree.Pexp_lazy x0 ->\n Ast_413.Parsetree.Pexp_lazy (copy_expression x0)\n | Ast_414.Parsetree.Pexp_poly (x0, x1) ->\n Ast_413.Parsetree.Pexp_poly\n (copy_expression x0, Option.map copy_core_type x1)\n | Ast_414.Parsetree.Pexp_object x0 ->\n Ast_413.Parsetree.Pexp_object (copy_class_structure x0)\n | Ast_414.Parsetree.Pexp_newtype (x0, x1) ->\n Ast_413.Parsetree.Pexp_newtype\n (copy_loc (fun x -> x) x0, copy_expression x1)\n | Ast_414.Parsetree.Pexp_pack x0 ->\n Ast_413.Parsetree.Pexp_pack (copy_module_expr x0)\n | Ast_414.Parsetree.Pexp_open (x0, x1) ->\n Ast_413.Parsetree.Pexp_open (copy_open_declaration x0, copy_expression x1)\n | Ast_414.Parsetree.Pexp_letop x0 ->\n Ast_413.Parsetree.Pexp_letop (copy_letop x0)\n | Ast_414.Parsetree.Pexp_extension x0 ->\n Ast_413.Parsetree.Pexp_extension (copy_extension x0)\n | Ast_414.Parsetree.Pexp_unreachable -> Ast_413.Parsetree.Pexp_unreachable\n\nand copy_letop : Ast_414.Parsetree.letop -> Ast_413.Parsetree.letop =\n fun { Ast_414.Parsetree.let_; Ast_414.Parsetree.ands; Ast_414.Parsetree.body } ->\n {\n Ast_413.Parsetree.let_ = copy_binding_op let_;\n Ast_413.Parsetree.ands = List.map copy_binding_op ands;\n Ast_413.Parsetree.body = copy_expression body;\n }\n\nand copy_binding_op :\n Ast_414.Parsetree.binding_op -> Ast_413.Parsetree.binding_op =\n fun {\n Ast_414.Parsetree.pbop_op;\n Ast_414.Parsetree.pbop_pat;\n Ast_414.Parsetree.pbop_exp;\n Ast_414.Parsetree.pbop_loc;\n } ->\n {\n Ast_413.Parsetree.pbop_op = copy_loc (fun x -> x) pbop_op;\n Ast_413.Parsetree.pbop_pat = copy_pattern pbop_pat;\n Ast_413.Parsetree.pbop_exp = copy_expression pbop_exp;\n Ast_413.Parsetree.pbop_loc = copy_location pbop_loc;\n }\n\nand copy_direction_flag :\n Ast_414.Asttypes.direction_flag -> Ast_413.Asttypes.direction_flag =\n function\n | Ast_414.Asttypes.Upto -> Ast_413.Asttypes.Upto\n | Ast_414.Asttypes.Downto -> Ast_413.Asttypes.Downto\n\nand copy_case : Ast_414.Parsetree.case -> Ast_413.Parsetree.case =\n fun {\n Ast_414.Parsetree.pc_lhs;\n Ast_414.Parsetree.pc_guard;\n Ast_414.Parsetree.pc_rhs;\n } ->\n {\n Ast_413.Parsetree.pc_lhs = copy_pattern pc_lhs;\n Ast_413.Parsetree.pc_guard = Option.map copy_expression pc_guard;\n Ast_413.Parsetree.pc_rhs = copy_expression pc_rhs;\n }\n\nand copy_value_binding :\n Ast_414.Parsetree.value_binding -> Ast_413.Parsetree.value_binding =\n fun {\n Ast_414.Parsetree.pvb_pat;\n Ast_414.Parsetree.pvb_expr;\n Ast_414.Parsetree.pvb_attributes;\n Ast_414.Parsetree.pvb_loc;\n } ->\n {\n Ast_413.Parsetree.pvb_pat = copy_pattern pvb_pat;\n Ast_413.Parsetree.pvb_expr = copy_expression pvb_expr;\n Ast_413.Parsetree.pvb_attributes = copy_attributes pvb_attributes;\n Ast_413.Parsetree.pvb_loc = copy_location pvb_loc;\n }\n\nand copy_pattern : Ast_414.Parsetree.pattern -> Ast_413.Parsetree.pattern =\n fun {\n Ast_414.Parsetree.ppat_desc;\n Ast_414.Parsetree.ppat_loc;\n Ast_414.Parsetree.ppat_loc_stack;\n Ast_414.Parsetree.ppat_attributes;\n } ->\n {\n Ast_413.Parsetree.ppat_desc = copy_pattern_desc ppat_desc;\n Ast_413.Parsetree.ppat_loc = copy_location ppat_loc;\n Ast_413.Parsetree.ppat_loc_stack = copy_location_stack ppat_loc_stack;\n Ast_413.Parsetree.ppat_attributes = copy_attributes ppat_attributes;\n }\n\nand copy_pattern_desc :\n Ast_414.Parsetree.pattern_desc -> Ast_413.Parsetree.pattern_desc = function\n | Ast_414.Parsetree.Ppat_any -> Ast_413.Parsetree.Ppat_any\n | Ast_414.Parsetree.Ppat_var x0 ->\n Ast_413.Parsetree.Ppat_var (copy_loc (fun x -> x) x0)\n | Ast_414.Parsetree.Ppat_alias (x0, x1) ->\n Ast_413.Parsetree.Ppat_alias (copy_pattern x0, copy_loc (fun x -> x) x1)\n | Ast_414.Parsetree.Ppat_constant x0 ->\n Ast_413.Parsetree.Ppat_constant (copy_constant x0)\n | Ast_414.Parsetree.Ppat_interval (x0, x1) ->\n Ast_413.Parsetree.Ppat_interval (copy_constant x0, copy_constant x1)\n | Ast_414.Parsetree.Ppat_tuple x0 ->\n Ast_413.Parsetree.Ppat_tuple (List.map copy_pattern x0)\n | Ast_414.Parsetree.Ppat_construct (x0, x1) ->\n Ast_413.Parsetree.Ppat_construct\n ( copy_loc copy_Longident_t x0,\n Option.map\n (fun x ->\n let x0, x1 = x in\n (List.map (fun x -> copy_loc (fun x -> x) x) x0, copy_pattern x1))\n x1 )\n | Ast_414.Parsetree.Ppat_variant (x0, x1) ->\n Ast_413.Parsetree.Ppat_variant (copy_label x0, Option.map copy_pattern x1)\n | Ast_414.Parsetree.Ppat_record (x0, x1) ->\n Ast_413.Parsetree.Ppat_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_pattern x1))\n x0,\n copy_closed_flag x1 )\n | Ast_414.Parsetree.Ppat_array x0 ->\n Ast_413.Parsetree.Ppat_array (List.map copy_pattern x0)\n | Ast_414.Parsetree.Ppat_or (x0, x1) ->\n Ast_413.Parsetree.Ppat_or (copy_pattern x0, copy_pattern x1)\n | Ast_414.Parsetree.Ppat_constraint (x0, x1) ->\n Ast_413.Parsetree.Ppat_constraint (copy_pattern x0, copy_core_type x1)\n | Ast_414.Parsetree.Ppat_type x0 ->\n Ast_413.Parsetree.Ppat_type (copy_loc copy_Longident_t x0)\n | Ast_414.Parsetree.Ppat_lazy x0 ->\n Ast_413.Parsetree.Ppat_lazy (copy_pattern x0)\n | Ast_414.Parsetree.Ppat_unpack x0 ->\n Ast_413.Parsetree.Ppat_unpack\n (copy_loc (fun x -> Option.map (fun x -> x) x) x0)\n | Ast_414.Parsetree.Ppat_exception x0 ->\n Ast_413.Parsetree.Ppat_exception (copy_pattern x0)\n | Ast_414.Parsetree.Ppat_extension x0 ->\n Ast_413.Parsetree.Ppat_extension (copy_extension x0)\n | Ast_414.Parsetree.Ppat_open (x0, x1) ->\n Ast_413.Parsetree.Ppat_open (copy_loc copy_Longident_t x0, copy_pattern x1)\n\nand copy_core_type : Ast_414.Parsetree.core_type -> Ast_413.Parsetree.core_type\n =\n fun {\n Ast_414.Parsetree.ptyp_desc;\n Ast_414.Parsetree.ptyp_loc;\n Ast_414.Parsetree.ptyp_loc_stack;\n Ast_414.Parsetree.ptyp_attributes;\n } ->\n {\n Ast_413.Parsetree.ptyp_desc = copy_core_type_desc ptyp_desc;\n Ast_413.Parsetree.ptyp_loc = copy_location ptyp_loc;\n Ast_413.Parsetree.ptyp_loc_stack = copy_location_stack ptyp_loc_stack;\n Ast_413.Parsetree.ptyp_attributes = copy_attributes ptyp_attributes;\n }\n\nand copy_location_stack :\n Ast_414.Parsetree.location_stack -> Ast_413.Parsetree.location_stack =\n fun x -> x\n\nand copy_core_type_desc :\n Ast_414.Parsetree.core_type_desc -> Ast_413.Parsetree.core_type_desc =\n function\n | Ast_414.Parsetree.Ptyp_any -> Ast_413.Parsetree.Ptyp_any\n | Ast_414.Parsetree.Ptyp_var x0 -> Ast_413.Parsetree.Ptyp_var x0\n | Ast_414.Parsetree.Ptyp_arrow (x0, x1, x2) ->\n Ast_413.Parsetree.Ptyp_arrow\n (copy_arg_label x0, copy_core_type x1, copy_core_type x2)\n | Ast_414.Parsetree.Ptyp_tuple x0 ->\n Ast_413.Parsetree.Ptyp_tuple (List.map copy_core_type x0)\n | Ast_414.Parsetree.Ptyp_constr (x0, x1) ->\n Ast_413.Parsetree.Ptyp_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_414.Parsetree.Ptyp_object (x0, x1) ->\n Ast_413.Parsetree.Ptyp_object\n (List.map copy_object_field x0, copy_closed_flag x1)\n | Ast_414.Parsetree.Ptyp_class (x0, x1) ->\n Ast_413.Parsetree.Ptyp_class\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_414.Parsetree.Ptyp_alias (x0, x1) ->\n Ast_413.Parsetree.Ptyp_alias (copy_core_type x0, x1)\n | Ast_414.Parsetree.Ptyp_variant (x0, x1, x2) ->\n Ast_413.Parsetree.Ptyp_variant\n ( List.map copy_row_field x0,\n copy_closed_flag x1,\n Option.map (fun x -> List.map copy_label x) x2 )\n | Ast_414.Parsetree.Ptyp_poly (x0, x1) ->\n Ast_413.Parsetree.Ptyp_poly\n (List.map (fun x -> copy_loc (fun x -> x) x) x0, copy_core_type x1)\n | Ast_414.Parsetree.Ptyp_package x0 ->\n Ast_413.Parsetree.Ptyp_package (copy_package_type x0)\n | Ast_414.Parsetree.Ptyp_extension x0 ->\n Ast_413.Parsetree.Ptyp_extension (copy_extension x0)\n\nand copy_package_type :\n Ast_414.Parsetree.package_type -> Ast_413.Parsetree.package_type =\n fun x ->\n let x0, x1 = x in\n ( copy_loc copy_Longident_t x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_core_type x1))\n x1 )\n\nand copy_row_field : Ast_414.Parsetree.row_field -> Ast_413.Parsetree.row_field\n =\n fun {\n Ast_414.Parsetree.prf_desc;\n Ast_414.Parsetree.prf_loc;\n Ast_414.Parsetree.prf_attributes;\n } ->\n {\n Ast_413.Parsetree.prf_desc = copy_row_field_desc prf_desc;\n Ast_413.Parsetree.prf_loc = copy_location prf_loc;\n Ast_413.Parsetree.prf_attributes = copy_attributes prf_attributes;\n }\n\nand copy_row_field_desc :\n Ast_414.Parsetree.row_field_desc -> Ast_413.Parsetree.row_field_desc =\n function\n | Ast_414.Parsetree.Rtag (x0, x1, x2) ->\n Ast_413.Parsetree.Rtag\n (copy_loc copy_label x0, x1, List.map copy_core_type x2)\n | Ast_414.Parsetree.Rinherit x0 ->\n Ast_413.Parsetree.Rinherit (copy_core_type x0)\n\nand copy_object_field :\n Ast_414.Parsetree.object_field -> Ast_413.Parsetree.object_field =\n fun {\n Ast_414.Parsetree.pof_desc;\n Ast_414.Parsetree.pof_loc;\n Ast_414.Parsetree.pof_attributes;\n } ->\n {\n Ast_413.Parsetree.pof_desc = copy_object_field_desc pof_desc;\n Ast_413.Parsetree.pof_loc = copy_location pof_loc;\n Ast_413.Parsetree.pof_attributes = copy_attributes pof_attributes;\n }\n\nand copy_attributes :\n Ast_414.Parsetree.attributes -> Ast_413.Parsetree.attributes =\n fun x -> List.map copy_attribute x\n\nand copy_attribute : Ast_414.Parsetree.attribute -> Ast_413.Parsetree.attribute\n =\n fun {\n Ast_414.Parsetree.attr_name;\n Ast_414.Parsetree.attr_payload;\n Ast_414.Parsetree.attr_loc;\n } ->\n {\n Ast_413.Parsetree.attr_name = copy_loc (fun x -> x) attr_name;\n Ast_413.Parsetree.attr_payload = copy_payload attr_payload;\n Ast_413.Parsetree.attr_loc = copy_location attr_loc;\n }\n\nand copy_payload : Ast_414.Parsetree.payload -> Ast_413.Parsetree.payload =\n function\n | Ast_414.Parsetree.PStr x0 -> Ast_413.Parsetree.PStr (copy_structure x0)\n | Ast_414.Parsetree.PSig x0 -> Ast_413.Parsetree.PSig (copy_signature x0)\n | Ast_414.Parsetree.PTyp x0 -> Ast_413.Parsetree.PTyp (copy_core_type x0)\n | Ast_414.Parsetree.PPat (x0, x1) ->\n Ast_413.Parsetree.PPat (copy_pattern x0, Option.map copy_expression x1)\n\nand copy_structure : Ast_414.Parsetree.structure -> Ast_413.Parsetree.structure\n =\n fun x -> List.map copy_structure_item x\n\nand copy_structure_item :\n Ast_414.Parsetree.structure_item -> Ast_413.Parsetree.structure_item =\n fun { Ast_414.Parsetree.pstr_desc; Ast_414.Parsetree.pstr_loc } ->\n {\n Ast_413.Parsetree.pstr_desc = copy_structure_item_desc pstr_desc;\n Ast_413.Parsetree.pstr_loc = copy_location pstr_loc;\n }\n\nand copy_structure_item_desc :\n Ast_414.Parsetree.structure_item_desc ->\n Ast_413.Parsetree.structure_item_desc = function\n | Ast_414.Parsetree.Pstr_eval (x0, x1) ->\n Ast_413.Parsetree.Pstr_eval (copy_expression x0, copy_attributes x1)\n | Ast_414.Parsetree.Pstr_value (x0, x1) ->\n Ast_413.Parsetree.Pstr_value\n (copy_rec_flag x0, List.map copy_value_binding x1)\n | Ast_414.Parsetree.Pstr_primitive x0 ->\n Ast_413.Parsetree.Pstr_primitive (copy_value_description x0)\n | Ast_414.Parsetree.Pstr_type (x0, x1) ->\n Ast_413.Parsetree.Pstr_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | Ast_414.Parsetree.Pstr_typext x0 ->\n Ast_413.Parsetree.Pstr_typext (copy_type_extension x0)\n | Ast_414.Parsetree.Pstr_exception x0 ->\n Ast_413.Parsetree.Pstr_exception (copy_type_exception x0)\n | Ast_414.Parsetree.Pstr_module x0 ->\n Ast_413.Parsetree.Pstr_module (copy_module_binding x0)\n | Ast_414.Parsetree.Pstr_recmodule x0 ->\n Ast_413.Parsetree.Pstr_recmodule (List.map copy_module_binding x0)\n | Ast_414.Parsetree.Pstr_modtype x0 ->\n Ast_413.Parsetree.Pstr_modtype (copy_module_type_declaration x0)\n | Ast_414.Parsetree.Pstr_open x0 ->\n Ast_413.Parsetree.Pstr_open (copy_open_declaration x0)\n | Ast_414.Parsetree.Pstr_class x0 ->\n Ast_413.Parsetree.Pstr_class (List.map copy_class_declaration x0)\n | Ast_414.Parsetree.Pstr_class_type x0 ->\n Ast_413.Parsetree.Pstr_class_type\n (List.map copy_class_type_declaration x0)\n | Ast_414.Parsetree.Pstr_include x0 ->\n Ast_413.Parsetree.Pstr_include (copy_include_declaration x0)\n | Ast_414.Parsetree.Pstr_attribute x0 ->\n Ast_413.Parsetree.Pstr_attribute (copy_attribute x0)\n | Ast_414.Parsetree.Pstr_extension (x0, x1) ->\n Ast_413.Parsetree.Pstr_extension (copy_extension x0, copy_attributes x1)\n\nand copy_include_declaration :\n Ast_414.Parsetree.include_declaration ->\n Ast_413.Parsetree.include_declaration =\n fun x -> copy_include_infos copy_module_expr x\n\nand copy_class_declaration :\n Ast_414.Parsetree.class_declaration -> Ast_413.Parsetree.class_declaration =\n fun x -> copy_class_infos copy_class_expr x\n\nand copy_class_expr :\n Ast_414.Parsetree.class_expr -> Ast_413.Parsetree.class_expr =\n fun {\n Ast_414.Parsetree.pcl_desc;\n Ast_414.Parsetree.pcl_loc;\n Ast_414.Parsetree.pcl_attributes;\n } ->\n {\n Ast_413.Parsetree.pcl_desc = copy_class_expr_desc pcl_desc;\n Ast_413.Parsetree.pcl_loc = copy_location pcl_loc;\n Ast_413.Parsetree.pcl_attributes = copy_attributes pcl_attributes;\n }\n\nand copy_class_expr_desc :\n Ast_414.Parsetree.class_expr_desc -> Ast_413.Parsetree.class_expr_desc =\n function\n | Ast_414.Parsetree.Pcl_constr (x0, x1) ->\n Ast_413.Parsetree.Pcl_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_414.Parsetree.Pcl_structure x0 ->\n Ast_413.Parsetree.Pcl_structure (copy_class_structure x0)\n | Ast_414.Parsetree.Pcl_fun (x0, x1, x2, x3) ->\n Ast_413.Parsetree.Pcl_fun\n ( copy_arg_label x0,\n Option.map copy_expression x1,\n copy_pattern x2,\n copy_class_expr x3 )\n | Ast_414.Parsetree.Pcl_apply (x0, x1) ->\n Ast_413.Parsetree.Pcl_apply\n ( copy_class_expr x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | Ast_414.Parsetree.Pcl_let (x0, x1, x2) ->\n Ast_413.Parsetree.Pcl_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_class_expr x2)\n | Ast_414.Parsetree.Pcl_constraint (x0, x1) ->\n Ast_413.Parsetree.Pcl_constraint (copy_class_expr x0, copy_class_type x1)\n | Ast_414.Parsetree.Pcl_extension x0 ->\n Ast_413.Parsetree.Pcl_extension (copy_extension x0)\n | Ast_414.Parsetree.Pcl_open (x0, x1) ->\n Ast_413.Parsetree.Pcl_open (copy_open_description x0, copy_class_expr x1)\n\nand copy_class_structure :\n Ast_414.Parsetree.class_structure -> Ast_413.Parsetree.class_structure =\n fun { Ast_414.Parsetree.pcstr_self; Ast_414.Parsetree.pcstr_fields } ->\n {\n Ast_413.Parsetree.pcstr_self = copy_pattern pcstr_self;\n Ast_413.Parsetree.pcstr_fields = List.map copy_class_field pcstr_fields;\n }\n\nand copy_class_field :\n Ast_414.Parsetree.class_field -> Ast_413.Parsetree.class_field =\n fun {\n Ast_414.Parsetree.pcf_desc;\n Ast_414.Parsetree.pcf_loc;\n Ast_414.Parsetree.pcf_attributes;\n } ->\n {\n Ast_413.Parsetree.pcf_desc = copy_class_field_desc pcf_desc;\n Ast_413.Parsetree.pcf_loc = copy_location pcf_loc;\n Ast_413.Parsetree.pcf_attributes = copy_attributes pcf_attributes;\n }\n\nand copy_class_field_desc :\n Ast_414.Parsetree.class_field_desc -> Ast_413.Parsetree.class_field_desc =\n function\n | Ast_414.Parsetree.Pcf_inherit (x0, x1, x2) ->\n Ast_413.Parsetree.Pcf_inherit\n ( copy_override_flag x0,\n copy_class_expr x1,\n Option.map (fun x -> copy_loc (fun x -> x) x) x2 )\n | Ast_414.Parsetree.Pcf_val x0 ->\n Ast_413.Parsetree.Pcf_val\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_mutable_flag x1, copy_class_field_kind x2))\n | Ast_414.Parsetree.Pcf_method x0 ->\n Ast_413.Parsetree.Pcf_method\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_private_flag x1, copy_class_field_kind x2))\n | Ast_414.Parsetree.Pcf_constraint x0 ->\n Ast_413.Parsetree.Pcf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | Ast_414.Parsetree.Pcf_initializer x0 ->\n Ast_413.Parsetree.Pcf_initializer (copy_expression x0)\n | Ast_414.Parsetree.Pcf_attribute x0 ->\n Ast_413.Parsetree.Pcf_attribute (copy_attribute x0)\n | Ast_414.Parsetree.Pcf_extension x0 ->\n Ast_413.Parsetree.Pcf_extension (copy_extension x0)\n\nand copy_class_field_kind :\n Ast_414.Parsetree.class_field_kind -> Ast_413.Parsetree.class_field_kind =\n function\n | Ast_414.Parsetree.Cfk_virtual x0 ->\n Ast_413.Parsetree.Cfk_virtual (copy_core_type x0)\n | Ast_414.Parsetree.Cfk_concrete (x0, x1) ->\n Ast_413.Parsetree.Cfk_concrete (copy_override_flag x0, copy_expression x1)\n\nand copy_open_declaration :\n Ast_414.Parsetree.open_declaration -> Ast_413.Parsetree.open_declaration =\n fun x -> copy_open_infos copy_module_expr x\n\nand copy_module_binding :\n Ast_414.Parsetree.module_binding -> Ast_413.Parsetree.module_binding =\n fun {\n Ast_414.Parsetree.pmb_name;\n Ast_414.Parsetree.pmb_expr;\n Ast_414.Parsetree.pmb_attributes;\n Ast_414.Parsetree.pmb_loc;\n } ->\n {\n Ast_413.Parsetree.pmb_name =\n copy_loc (fun x -> Option.map (fun x -> x) x) pmb_name;\n Ast_413.Parsetree.pmb_expr = copy_module_expr pmb_expr;\n Ast_413.Parsetree.pmb_attributes = copy_attributes pmb_attributes;\n Ast_413.Parsetree.pmb_loc = copy_location pmb_loc;\n }\n\nand copy_module_expr :\n Ast_414.Parsetree.module_expr -> Ast_413.Parsetree.module_expr =\n fun {\n Ast_414.Parsetree.pmod_desc;\n Ast_414.Parsetree.pmod_loc;\n Ast_414.Parsetree.pmod_attributes;\n } ->\n {\n Ast_413.Parsetree.pmod_desc = copy_module_expr_desc pmod_desc;\n Ast_413.Parsetree.pmod_loc = copy_location pmod_loc;\n Ast_413.Parsetree.pmod_attributes = copy_attributes pmod_attributes;\n }\n\nand copy_module_expr_desc :\n Ast_414.Parsetree.module_expr_desc -> Ast_413.Parsetree.module_expr_desc =\n function\n | Ast_414.Parsetree.Pmod_ident x0 ->\n Ast_413.Parsetree.Pmod_ident (copy_loc copy_Longident_t x0)\n | Ast_414.Parsetree.Pmod_structure x0 ->\n Ast_413.Parsetree.Pmod_structure (copy_structure x0)\n | Ast_414.Parsetree.Pmod_functor (x0, x1) ->\n Ast_413.Parsetree.Pmod_functor\n (copy_functor_parameter x0, copy_module_expr x1)\n | Ast_414.Parsetree.Pmod_apply (x0, x1) ->\n Ast_413.Parsetree.Pmod_apply (copy_module_expr x0, copy_module_expr x1)\n | Ast_414.Parsetree.Pmod_constraint (x0, x1) ->\n Ast_413.Parsetree.Pmod_constraint\n (copy_module_expr x0, copy_module_type x1)\n | Ast_414.Parsetree.Pmod_unpack x0 ->\n Ast_413.Parsetree.Pmod_unpack (copy_expression x0)\n | Ast_414.Parsetree.Pmod_extension x0 ->\n Ast_413.Parsetree.Pmod_extension (copy_extension x0)\n\nand copy_functor_parameter :\n Ast_414.Parsetree.functor_parameter -> Ast_413.Parsetree.functor_parameter =\n function\n | Ast_414.Parsetree.Unit -> Ast_413.Parsetree.Unit\n | Ast_414.Parsetree.Named (x0, x1) ->\n Ast_413.Parsetree.Named\n (copy_loc (fun x -> Option.map (fun x -> x) x) x0, copy_module_type x1)\n\nand copy_module_type :\n Ast_414.Parsetree.module_type -> Ast_413.Parsetree.module_type =\n fun {\n Ast_414.Parsetree.pmty_desc;\n Ast_414.Parsetree.pmty_loc;\n Ast_414.Parsetree.pmty_attributes;\n } ->\n {\n Ast_413.Parsetree.pmty_desc = copy_module_type_desc pmty_desc;\n Ast_413.Parsetree.pmty_loc = copy_location pmty_loc;\n Ast_413.Parsetree.pmty_attributes = copy_attributes pmty_attributes;\n }\n\nand copy_module_type_desc :\n Ast_414.Parsetree.module_type_desc -> Ast_413.Parsetree.module_type_desc =\n function\n | Ast_414.Parsetree.Pmty_ident x0 ->\n Ast_413.Parsetree.Pmty_ident (copy_loc copy_Longident_t x0)\n | Ast_414.Parsetree.Pmty_signature x0 ->\n Ast_413.Parsetree.Pmty_signature (copy_signature x0)\n | Ast_414.Parsetree.Pmty_functor (x0, x1) ->\n Ast_413.Parsetree.Pmty_functor\n (copy_functor_parameter x0, copy_module_type x1)\n | Ast_414.Parsetree.Pmty_with (x0, x1) ->\n Ast_413.Parsetree.Pmty_with\n (copy_module_type x0, List.map copy_with_constraint x1)\n | Ast_414.Parsetree.Pmty_typeof x0 ->\n Ast_413.Parsetree.Pmty_typeof (copy_module_expr x0)\n | Ast_414.Parsetree.Pmty_extension x0 ->\n Ast_413.Parsetree.Pmty_extension (copy_extension x0)\n | Ast_414.Parsetree.Pmty_alias x0 ->\n Ast_413.Parsetree.Pmty_alias (copy_loc copy_Longident_t x0)\n\nand copy_with_constraint :\n Ast_414.Parsetree.with_constraint -> Ast_413.Parsetree.with_constraint =\n function\n | Ast_414.Parsetree.Pwith_type (x0, x1) ->\n Ast_413.Parsetree.Pwith_type\n (copy_loc copy_Longident_t x0, copy_type_declaration x1)\n | Ast_414.Parsetree.Pwith_module (x0, x1) ->\n Ast_413.Parsetree.Pwith_module\n (copy_loc copy_Longident_t x0, copy_loc copy_Longident_t x1)\n | Ast_414.Parsetree.Pwith_modtype (x0, x1) ->\n Ast_413.Parsetree.Pwith_modtype\n (copy_loc copy_Longident_t x0, copy_module_type x1)\n | Ast_414.Parsetree.Pwith_modtypesubst (x0, x1) ->\n Ast_413.Parsetree.Pwith_modtypesubst\n (copy_loc copy_Longident_t x0, copy_module_type x1)\n | Ast_414.Parsetree.Pwith_typesubst (x0, x1) ->\n Ast_413.Parsetree.Pwith_typesubst\n (copy_loc copy_Longident_t x0, copy_type_declaration x1)\n | Ast_414.Parsetree.Pwith_modsubst (x0, x1) ->\n Ast_413.Parsetree.Pwith_modsubst\n (copy_loc copy_Longident_t x0, copy_loc copy_Longident_t x1)\n\nand copy_signature : Ast_414.Parsetree.signature -> Ast_413.Parsetree.signature\n =\n fun x -> List.map copy_signature_item x\n\nand copy_signature_item :\n Ast_414.Parsetree.signature_item -> Ast_413.Parsetree.signature_item =\n fun { Ast_414.Parsetree.psig_desc; Ast_414.Parsetree.psig_loc } ->\n {\n Ast_413.Parsetree.psig_desc = copy_signature_item_desc psig_desc;\n Ast_413.Parsetree.psig_loc = copy_location psig_loc;\n }\n\nand copy_signature_item_desc :\n Ast_414.Parsetree.signature_item_desc ->\n Ast_413.Parsetree.signature_item_desc = function\n | Ast_414.Parsetree.Psig_value x0 ->\n Ast_413.Parsetree.Psig_value (copy_value_description x0)\n | Ast_414.Parsetree.Psig_type (x0, x1) ->\n Ast_413.Parsetree.Psig_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | Ast_414.Parsetree.Psig_typesubst x0 ->\n Ast_413.Parsetree.Psig_typesubst (List.map copy_type_declaration x0)\n | Ast_414.Parsetree.Psig_typext x0 ->\n Ast_413.Parsetree.Psig_typext (copy_type_extension x0)\n | Ast_414.Parsetree.Psig_exception x0 ->\n Ast_413.Parsetree.Psig_exception (copy_type_exception x0)\n | Ast_414.Parsetree.Psig_module x0 ->\n Ast_413.Parsetree.Psig_module (copy_module_declaration x0)\n | Ast_414.Parsetree.Psig_modsubst x0 ->\n Ast_413.Parsetree.Psig_modsubst (copy_module_substitution x0)\n | Ast_414.Parsetree.Psig_recmodule x0 ->\n Ast_413.Parsetree.Psig_recmodule (List.map copy_module_declaration x0)\n | Ast_414.Parsetree.Psig_modtype x0 ->\n Ast_413.Parsetree.Psig_modtype (copy_module_type_declaration x0)\n | Ast_414.Parsetree.Psig_modtypesubst x0 ->\n Ast_413.Parsetree.Psig_modtypesubst (copy_module_type_declaration x0)\n | Ast_414.Parsetree.Psig_open x0 ->\n Ast_413.Parsetree.Psig_open (copy_open_description x0)\n | Ast_414.Parsetree.Psig_include x0 ->\n Ast_413.Parsetree.Psig_include (copy_include_description x0)\n | Ast_414.Parsetree.Psig_class x0 ->\n Ast_413.Parsetree.Psig_class (List.map copy_class_description x0)\n | Ast_414.Parsetree.Psig_class_type x0 ->\n Ast_413.Parsetree.Psig_class_type\n (List.map copy_class_type_declaration x0)\n | Ast_414.Parsetree.Psig_attribute x0 ->\n Ast_413.Parsetree.Psig_attribute (copy_attribute x0)\n | Ast_414.Parsetree.Psig_extension (x0, x1) ->\n Ast_413.Parsetree.Psig_extension (copy_extension x0, copy_attributes x1)\n\nand copy_class_type_declaration :\n Ast_414.Parsetree.class_type_declaration ->\n Ast_413.Parsetree.class_type_declaration =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_description :\n Ast_414.Parsetree.class_description -> Ast_413.Parsetree.class_description =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_type :\n Ast_414.Parsetree.class_type -> Ast_413.Parsetree.class_type =\n fun {\n Ast_414.Parsetree.pcty_desc;\n Ast_414.Parsetree.pcty_loc;\n Ast_414.Parsetree.pcty_attributes;\n } ->\n {\n Ast_413.Parsetree.pcty_desc = copy_class_type_desc pcty_desc;\n Ast_413.Parsetree.pcty_loc = copy_location pcty_loc;\n Ast_413.Parsetree.pcty_attributes = copy_attributes pcty_attributes;\n }\n\nand copy_class_type_desc :\n Ast_414.Parsetree.class_type_desc -> Ast_413.Parsetree.class_type_desc =\n function\n | Ast_414.Parsetree.Pcty_constr (x0, x1) ->\n Ast_413.Parsetree.Pcty_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_414.Parsetree.Pcty_signature x0 ->\n Ast_413.Parsetree.Pcty_signature (copy_class_signature x0)\n | Ast_414.Parsetree.Pcty_arrow (x0, x1, x2) ->\n Ast_413.Parsetree.Pcty_arrow\n (copy_arg_label x0, copy_core_type x1, copy_class_type x2)\n | Ast_414.Parsetree.Pcty_extension x0 ->\n Ast_413.Parsetree.Pcty_extension (copy_extension x0)\n | Ast_414.Parsetree.Pcty_open (x0, x1) ->\n Ast_413.Parsetree.Pcty_open (copy_open_description x0, copy_class_type x1)\n\nand copy_class_signature :\n Ast_414.Parsetree.class_signature -> Ast_413.Parsetree.class_signature =\n fun { Ast_414.Parsetree.pcsig_self; Ast_414.Parsetree.pcsig_fields } ->\n {\n Ast_413.Parsetree.pcsig_self = copy_core_type pcsig_self;\n Ast_413.Parsetree.pcsig_fields = List.map copy_class_type_field pcsig_fields;\n }\n\nand copy_class_type_field :\n Ast_414.Parsetree.class_type_field -> Ast_413.Parsetree.class_type_field =\n fun {\n Ast_414.Parsetree.pctf_desc;\n Ast_414.Parsetree.pctf_loc;\n Ast_414.Parsetree.pctf_attributes;\n } ->\n {\n Ast_413.Parsetree.pctf_desc = copy_class_type_field_desc pctf_desc;\n Ast_413.Parsetree.pctf_loc = copy_location pctf_loc;\n Ast_413.Parsetree.pctf_attributes = copy_attributes pctf_attributes;\n }\n\nand copy_class_type_field_desc :\n Ast_414.Parsetree.class_type_field_desc ->\n Ast_413.Parsetree.class_type_field_desc = function\n | Ast_414.Parsetree.Pctf_inherit x0 ->\n Ast_413.Parsetree.Pctf_inherit (copy_class_type x0)\n | Ast_414.Parsetree.Pctf_val x0 ->\n Ast_413.Parsetree.Pctf_val\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_mutable_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | Ast_414.Parsetree.Pctf_method x0 ->\n Ast_413.Parsetree.Pctf_method\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_private_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | Ast_414.Parsetree.Pctf_constraint x0 ->\n Ast_413.Parsetree.Pctf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | Ast_414.Parsetree.Pctf_attribute x0 ->\n Ast_413.Parsetree.Pctf_attribute (copy_attribute x0)\n | Ast_414.Parsetree.Pctf_extension x0 ->\n Ast_413.Parsetree.Pctf_extension (copy_extension x0)\n\nand copy_extension : Ast_414.Parsetree.extension -> Ast_413.Parsetree.extension\n =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_class_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_414.Parsetree.class_infos ->\n 'g0 Ast_413.Parsetree.class_infos =\n fun f0\n {\n Ast_414.Parsetree.pci_virt;\n Ast_414.Parsetree.pci_params;\n Ast_414.Parsetree.pci_name;\n Ast_414.Parsetree.pci_expr;\n Ast_414.Parsetree.pci_loc;\n Ast_414.Parsetree.pci_attributes;\n } ->\n {\n Ast_413.Parsetree.pci_virt = copy_virtual_flag pci_virt;\n Ast_413.Parsetree.pci_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n ( copy_core_type x0,\n let x0, x1 = x1 in\n (copy_variance x0, copy_injectivity x1) ))\n pci_params;\n Ast_413.Parsetree.pci_name = copy_loc (fun x -> x) pci_name;\n Ast_413.Parsetree.pci_expr = f0 pci_expr;\n Ast_413.Parsetree.pci_loc = copy_location pci_loc;\n Ast_413.Parsetree.pci_attributes = copy_attributes pci_attributes;\n }\n\nand copy_virtual_flag :\n Ast_414.Asttypes.virtual_flag -> Ast_413.Asttypes.virtual_flag = function\n | Ast_414.Asttypes.Virtual -> Ast_413.Asttypes.Virtual\n | Ast_414.Asttypes.Concrete -> Ast_413.Asttypes.Concrete\n\nand copy_include_description :\n Ast_414.Parsetree.include_description ->\n Ast_413.Parsetree.include_description =\n fun x -> copy_include_infos copy_module_type x\n\nand copy_include_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_414.Parsetree.include_infos ->\n 'g0 Ast_413.Parsetree.include_infos =\n fun f0\n {\n Ast_414.Parsetree.pincl_mod;\n Ast_414.Parsetree.pincl_loc;\n Ast_414.Parsetree.pincl_attributes;\n } ->\n {\n Ast_413.Parsetree.pincl_mod = f0 pincl_mod;\n Ast_413.Parsetree.pincl_loc = copy_location pincl_loc;\n Ast_413.Parsetree.pincl_attributes = copy_attributes pincl_attributes;\n }\n\nand copy_open_description :\n Ast_414.Parsetree.open_description -> Ast_413.Parsetree.open_description =\n fun x -> copy_open_infos (fun x -> copy_loc copy_Longident_t x) x\n\nand copy_open_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_414.Parsetree.open_infos ->\n 'g0 Ast_413.Parsetree.open_infos =\n fun f0\n {\n Ast_414.Parsetree.popen_expr;\n Ast_414.Parsetree.popen_override;\n Ast_414.Parsetree.popen_loc;\n Ast_414.Parsetree.popen_attributes;\n } ->\n {\n Ast_413.Parsetree.popen_expr = f0 popen_expr;\n Ast_413.Parsetree.popen_override = copy_override_flag popen_override;\n Ast_413.Parsetree.popen_loc = copy_location popen_loc;\n Ast_413.Parsetree.popen_attributes = copy_attributes popen_attributes;\n }\n\nand copy_override_flag :\n Ast_414.Asttypes.override_flag -> Ast_413.Asttypes.override_flag = function\n | Ast_414.Asttypes.Override -> Ast_413.Asttypes.Override\n | Ast_414.Asttypes.Fresh -> Ast_413.Asttypes.Fresh\n\nand copy_module_type_declaration :\n Ast_414.Parsetree.module_type_declaration ->\n Ast_413.Parsetree.module_type_declaration =\n fun {\n Ast_414.Parsetree.pmtd_name;\n Ast_414.Parsetree.pmtd_type;\n Ast_414.Parsetree.pmtd_attributes;\n Ast_414.Parsetree.pmtd_loc;\n } ->\n {\n Ast_413.Parsetree.pmtd_name = copy_loc (fun x -> x) pmtd_name;\n Ast_413.Parsetree.pmtd_type = Option.map copy_module_type pmtd_type;\n Ast_413.Parsetree.pmtd_attributes = copy_attributes pmtd_attributes;\n Ast_413.Parsetree.pmtd_loc = copy_location pmtd_loc;\n }\n\nand copy_module_substitution :\n Ast_414.Parsetree.module_substitution ->\n Ast_413.Parsetree.module_substitution =\n fun {\n Ast_414.Parsetree.pms_name;\n Ast_414.Parsetree.pms_manifest;\n Ast_414.Parsetree.pms_attributes;\n Ast_414.Parsetree.pms_loc;\n } ->\n {\n Ast_413.Parsetree.pms_name = copy_loc (fun x -> x) pms_name;\n Ast_413.Parsetree.pms_manifest = copy_loc copy_Longident_t pms_manifest;\n Ast_413.Parsetree.pms_attributes = copy_attributes pms_attributes;\n Ast_413.Parsetree.pms_loc = copy_location pms_loc;\n }\n\nand copy_module_declaration :\n Ast_414.Parsetree.module_declaration -> Ast_413.Parsetree.module_declaration\n =\n fun {\n Ast_414.Parsetree.pmd_name;\n Ast_414.Parsetree.pmd_type;\n Ast_414.Parsetree.pmd_attributes;\n Ast_414.Parsetree.pmd_loc;\n } ->\n {\n Ast_413.Parsetree.pmd_name =\n copy_loc (fun x -> Option.map (fun x -> x) x) pmd_name;\n Ast_413.Parsetree.pmd_type = copy_module_type pmd_type;\n Ast_413.Parsetree.pmd_attributes = copy_attributes pmd_attributes;\n Ast_413.Parsetree.pmd_loc = copy_location pmd_loc;\n }\n\nand copy_type_exception :\n Ast_414.Parsetree.type_exception -> Ast_413.Parsetree.type_exception =\n fun {\n Ast_414.Parsetree.ptyexn_constructor;\n Ast_414.Parsetree.ptyexn_loc;\n Ast_414.Parsetree.ptyexn_attributes;\n } ->\n {\n Ast_413.Parsetree.ptyexn_constructor =\n copy_extension_constructor ptyexn_constructor;\n Ast_413.Parsetree.ptyexn_loc = copy_location ptyexn_loc;\n Ast_413.Parsetree.ptyexn_attributes = copy_attributes ptyexn_attributes;\n }\n\nand copy_type_extension :\n Ast_414.Parsetree.type_extension -> Ast_413.Parsetree.type_extension =\n fun {\n Ast_414.Parsetree.ptyext_path;\n Ast_414.Parsetree.ptyext_params;\n Ast_414.Parsetree.ptyext_constructors;\n Ast_414.Parsetree.ptyext_private;\n Ast_414.Parsetree.ptyext_loc;\n Ast_414.Parsetree.ptyext_attributes;\n } ->\n {\n Ast_413.Parsetree.ptyext_path = copy_loc copy_Longident_t ptyext_path;\n Ast_413.Parsetree.ptyext_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n ( copy_core_type x0,\n let x0, x1 = x1 in\n (copy_variance x0, copy_injectivity x1) ))\n ptyext_params;\n Ast_413.Parsetree.ptyext_constructors =\n List.map copy_extension_constructor ptyext_constructors;\n Ast_413.Parsetree.ptyext_private = copy_private_flag ptyext_private;\n Ast_413.Parsetree.ptyext_loc = copy_location ptyext_loc;\n Ast_413.Parsetree.ptyext_attributes = copy_attributes ptyext_attributes;\n }\n\nand copy_extension_constructor :\n Ast_414.Parsetree.extension_constructor ->\n Ast_413.Parsetree.extension_constructor =\n fun {\n Ast_414.Parsetree.pext_name;\n Ast_414.Parsetree.pext_kind;\n Ast_414.Parsetree.pext_loc;\n Ast_414.Parsetree.pext_attributes;\n } ->\n {\n Ast_413.Parsetree.pext_name = copy_loc (fun x -> x) pext_name;\n Ast_413.Parsetree.pext_kind = copy_extension_constructor_kind pext_kind;\n Ast_413.Parsetree.pext_loc = copy_location pext_loc;\n Ast_413.Parsetree.pext_attributes = copy_attributes pext_attributes;\n }\n\nand copy_extension_constructor_kind :\n Ast_414.Parsetree.extension_constructor_kind ->\n Ast_413.Parsetree.extension_constructor_kind = function\n | Ast_414.Parsetree.Pext_decl (x0, x1, x2) -> (\n match x0 with\n | [] ->\n Ast_413.Parsetree.Pext_decl\n (copy_constructor_arguments x1, Option.map copy_core_type x2)\n | hd :: _ ->\n migration_error hd.loc \"type parameters in extension constructors\")\n | Ast_414.Parsetree.Pext_rebind x0 ->\n Ast_413.Parsetree.Pext_rebind (copy_loc copy_Longident_t x0)\n\nand copy_type_declaration :\n Ast_414.Parsetree.type_declaration -> Ast_413.Parsetree.type_declaration =\n fun {\n Ast_414.Parsetree.ptype_name;\n Ast_414.Parsetree.ptype_params;\n Ast_414.Parsetree.ptype_cstrs;\n Ast_414.Parsetree.ptype_kind;\n Ast_414.Parsetree.ptype_private;\n Ast_414.Parsetree.ptype_manifest;\n Ast_414.Parsetree.ptype_attributes;\n Ast_414.Parsetree.ptype_loc;\n } ->\n {\n Ast_413.Parsetree.ptype_name = copy_loc (fun x -> x) ptype_name;\n Ast_413.Parsetree.ptype_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n ( copy_core_type x0,\n let x0, x1 = x1 in\n (copy_variance x0, copy_injectivity x1) ))\n ptype_params;\n Ast_413.Parsetree.ptype_cstrs =\n List.map\n (fun x ->\n let x0, x1, x2 = x in\n (copy_core_type x0, copy_core_type x1, copy_location x2))\n ptype_cstrs;\n Ast_413.Parsetree.ptype_kind = copy_type_kind ptype_kind;\n Ast_413.Parsetree.ptype_private = copy_private_flag ptype_private;\n Ast_413.Parsetree.ptype_manifest = Option.map copy_core_type ptype_manifest;\n Ast_413.Parsetree.ptype_attributes = copy_attributes ptype_attributes;\n Ast_413.Parsetree.ptype_loc = copy_location ptype_loc;\n }\n\nand copy_private_flag :\n Ast_414.Asttypes.private_flag -> Ast_413.Asttypes.private_flag = function\n | Ast_414.Asttypes.Private -> Ast_413.Asttypes.Private\n | Ast_414.Asttypes.Public -> Ast_413.Asttypes.Public\n\nand copy_type_kind : Ast_414.Parsetree.type_kind -> Ast_413.Parsetree.type_kind\n = function\n | Ast_414.Parsetree.Ptype_abstract -> Ast_413.Parsetree.Ptype_abstract\n | Ast_414.Parsetree.Ptype_variant x0 ->\n Ast_413.Parsetree.Ptype_variant (List.map copy_constructor_declaration x0)\n | Ast_414.Parsetree.Ptype_record x0 ->\n Ast_413.Parsetree.Ptype_record (List.map copy_label_declaration x0)\n | Ast_414.Parsetree.Ptype_open -> Ast_413.Parsetree.Ptype_open\n\nand copy_constructor_declaration :\n Ast_414.Parsetree.constructor_declaration ->\n Ast_413.Parsetree.constructor_declaration =\n fun {\n Ast_414.Parsetree.pcd_name;\n Ast_414.Parsetree.pcd_vars;\n Ast_414.Parsetree.pcd_args;\n Ast_414.Parsetree.pcd_res;\n Ast_414.Parsetree.pcd_loc;\n Ast_414.Parsetree.pcd_attributes;\n } ->\n match pcd_vars with\n | [] ->\n {\n Ast_413.Parsetree.pcd_name = copy_loc (fun x -> x) pcd_name;\n Ast_413.Parsetree.pcd_args = copy_constructor_arguments pcd_args;\n Ast_413.Parsetree.pcd_res = Option.map copy_core_type pcd_res;\n Ast_413.Parsetree.pcd_loc = copy_location pcd_loc;\n Ast_413.Parsetree.pcd_attributes = copy_attributes pcd_attributes;\n }\n | hd :: _ -> migration_error hd.loc \"pcd_vars in constructor declarations\"\n\nand copy_constructor_arguments :\n Ast_414.Parsetree.constructor_arguments ->\n Ast_413.Parsetree.constructor_arguments = function\n | Ast_414.Parsetree.Pcstr_tuple x0 ->\n Ast_413.Parsetree.Pcstr_tuple (List.map copy_core_type x0)\n | Ast_414.Parsetree.Pcstr_record x0 ->\n Ast_413.Parsetree.Pcstr_record (List.map copy_label_declaration x0)\n\nand copy_label_declaration :\n Ast_414.Parsetree.label_declaration -> Ast_413.Parsetree.label_declaration =\n fun {\n Ast_414.Parsetree.pld_name;\n Ast_414.Parsetree.pld_mutable;\n Ast_414.Parsetree.pld_type;\n Ast_414.Parsetree.pld_loc;\n Ast_414.Parsetree.pld_attributes;\n } ->\n {\n Ast_413.Parsetree.pld_name = copy_loc (fun x -> x) pld_name;\n Ast_413.Parsetree.pld_mutable = copy_mutable_flag pld_mutable;\n Ast_413.Parsetree.pld_type = copy_core_type pld_type;\n Ast_413.Parsetree.pld_loc = copy_location pld_loc;\n Ast_413.Parsetree.pld_attributes = copy_attributes pld_attributes;\n }\n\nand copy_mutable_flag :\n Ast_414.Asttypes.mutable_flag -> Ast_413.Asttypes.mutable_flag = function\n | Ast_414.Asttypes.Immutable -> Ast_413.Asttypes.Immutable\n | Ast_414.Asttypes.Mutable -> Ast_413.Asttypes.Mutable\n\nand copy_injectivity :\n Ast_414.Asttypes.injectivity -> Ast_413.Asttypes.injectivity = function\n | Ast_414.Asttypes.Injective -> Ast_413.Asttypes.Injective\n | Ast_414.Asttypes.NoInjectivity -> Ast_413.Asttypes.NoInjectivity\n\nand copy_variance : Ast_414.Asttypes.variance -> Ast_413.Asttypes.variance =\n function\n | Ast_414.Asttypes.Covariant -> Ast_413.Asttypes.Covariant\n | Ast_414.Asttypes.Contravariant -> Ast_413.Asttypes.Contravariant\n | Ast_414.Asttypes.NoVariance -> Ast_413.Asttypes.NoVariance\n\nand copy_value_description :\n Ast_414.Parsetree.value_description -> Ast_413.Parsetree.value_description =\n fun {\n Ast_414.Parsetree.pval_name;\n Ast_414.Parsetree.pval_type;\n Ast_414.Parsetree.pval_prim;\n Ast_414.Parsetree.pval_attributes;\n Ast_414.Parsetree.pval_loc;\n } ->\n {\n Ast_413.Parsetree.pval_name = copy_loc (fun x -> x) pval_name;\n Ast_413.Parsetree.pval_type = copy_core_type pval_type;\n Ast_413.Parsetree.pval_prim = List.map (fun x -> x) pval_prim;\n Ast_413.Parsetree.pval_attributes = copy_attributes pval_attributes;\n Ast_413.Parsetree.pval_loc = copy_location pval_loc;\n }\n\nand copy_object_field_desc :\n Ast_414.Parsetree.object_field_desc -> Ast_413.Parsetree.object_field_desc =\n function\n | Ast_414.Parsetree.Otag (x0, x1) ->\n Ast_413.Parsetree.Otag (copy_loc copy_label x0, copy_core_type x1)\n | Ast_414.Parsetree.Oinherit x0 ->\n Ast_413.Parsetree.Oinherit (copy_core_type x0)\n\nand copy_arg_label : Ast_414.Asttypes.arg_label -> Ast_413.Asttypes.arg_label =\n function\n | Ast_414.Asttypes.Nolabel -> Ast_413.Asttypes.Nolabel\n | Ast_414.Asttypes.Labelled x0 -> Ast_413.Asttypes.Labelled x0\n | Ast_414.Asttypes.Optional x0 -> Ast_413.Asttypes.Optional x0\n\nand copy_closed_flag :\n Ast_414.Asttypes.closed_flag -> Ast_413.Asttypes.closed_flag = function\n | Ast_414.Asttypes.Closed -> Ast_413.Asttypes.Closed\n | Ast_414.Asttypes.Open -> Ast_413.Asttypes.Open\n\nand copy_label : Ast_414.Asttypes.label -> Ast_413.Asttypes.label = fun x -> x\n\nand copy_rec_flag : Ast_414.Asttypes.rec_flag -> Ast_413.Asttypes.rec_flag =\n function\n | Ast_414.Asttypes.Nonrecursive -> Ast_413.Asttypes.Nonrecursive\n | Ast_414.Asttypes.Recursive -> Ast_413.Asttypes.Recursive\n\nand copy_constant : Ast_414.Parsetree.constant -> Ast_413.Parsetree.constant =\n function\n | Ast_414.Parsetree.Pconst_integer (x0, x1) ->\n Ast_413.Parsetree.Pconst_integer (x0, Option.map (fun x -> x) x1)\n | Ast_414.Parsetree.Pconst_char x0 -> Ast_413.Parsetree.Pconst_char x0\n | Ast_414.Parsetree.Pconst_string (x0, x1, x2) ->\n Ast_413.Parsetree.Pconst_string\n (x0, copy_location x1, Option.map (fun x -> x) x2)\n | Ast_414.Parsetree.Pconst_float (x0, x1) ->\n Ast_413.Parsetree.Pconst_float (x0, Option.map (fun x -> x) x1)\n\nand copy_Longident_t : Longident.t -> Longident.t = fun x -> x\n\nand copy_loc :\n 'f0 'g0.\n ('f0 -> 'g0) -> 'f0 Ast_414.Asttypes.loc -> 'g0 Ast_413.Asttypes.loc =\n fun f0 { Ast_414.Asttypes.txt; Ast_414.Asttypes.loc } ->\n { Ast_413.Asttypes.txt = f0 txt; Ast_413.Asttypes.loc = copy_location loc }\n\nand copy_location : Location.t -> Location.t = fun x -> x\n","open Stdlib0\nmodule From = Ast_413\nmodule To = Ast_414\n\nlet rec copy_toplevel_phrase :\n Ast_413.Parsetree.toplevel_phrase -> Ast_414.Parsetree.toplevel_phrase =\n function\n | Ast_413.Parsetree.Ptop_def x0 ->\n Ast_414.Parsetree.Ptop_def (copy_structure x0)\n | Ast_413.Parsetree.Ptop_dir x0 ->\n Ast_414.Parsetree.Ptop_dir (copy_toplevel_directive x0)\n\nand copy_toplevel_directive :\n Ast_413.Parsetree.toplevel_directive -> Ast_414.Parsetree.toplevel_directive\n =\n fun {\n Ast_413.Parsetree.pdir_name;\n Ast_413.Parsetree.pdir_arg;\n Ast_413.Parsetree.pdir_loc;\n } ->\n {\n Ast_414.Parsetree.pdir_name = copy_loc (fun x -> x) pdir_name;\n Ast_414.Parsetree.pdir_arg = Option.map copy_directive_argument pdir_arg;\n Ast_414.Parsetree.pdir_loc = copy_location pdir_loc;\n }\n\nand copy_directive_argument :\n Ast_413.Parsetree.directive_argument -> Ast_414.Parsetree.directive_argument\n =\n fun { Ast_413.Parsetree.pdira_desc; Ast_413.Parsetree.pdira_loc } ->\n {\n Ast_414.Parsetree.pdira_desc = copy_directive_argument_desc pdira_desc;\n Ast_414.Parsetree.pdira_loc = copy_location pdira_loc;\n }\n\nand copy_directive_argument_desc :\n Ast_413.Parsetree.directive_argument_desc ->\n Ast_414.Parsetree.directive_argument_desc = function\n | Ast_413.Parsetree.Pdir_string x0 -> Ast_414.Parsetree.Pdir_string x0\n | Ast_413.Parsetree.Pdir_int (x0, x1) ->\n Ast_414.Parsetree.Pdir_int (x0, Option.map (fun x -> x) x1)\n | Ast_413.Parsetree.Pdir_ident x0 ->\n Ast_414.Parsetree.Pdir_ident (copy_Longident_t x0)\n | Ast_413.Parsetree.Pdir_bool x0 -> Ast_414.Parsetree.Pdir_bool x0\n\nand copy_expression :\n Ast_413.Parsetree.expression -> Ast_414.Parsetree.expression =\n fun {\n Ast_413.Parsetree.pexp_desc;\n Ast_413.Parsetree.pexp_loc;\n Ast_413.Parsetree.pexp_loc_stack;\n Ast_413.Parsetree.pexp_attributes;\n } ->\n {\n Ast_414.Parsetree.pexp_desc = copy_expression_desc pexp_desc;\n Ast_414.Parsetree.pexp_loc = copy_location pexp_loc;\n Ast_414.Parsetree.pexp_loc_stack = copy_location_stack pexp_loc_stack;\n Ast_414.Parsetree.pexp_attributes = copy_attributes pexp_attributes;\n }\n\nand copy_expression_desc :\n Ast_413.Parsetree.expression_desc -> Ast_414.Parsetree.expression_desc =\n function\n | Ast_413.Parsetree.Pexp_ident x0 ->\n Ast_414.Parsetree.Pexp_ident (copy_loc copy_Longident_t x0)\n | Ast_413.Parsetree.Pexp_constant x0 ->\n Ast_414.Parsetree.Pexp_constant (copy_constant x0)\n | Ast_413.Parsetree.Pexp_let (x0, x1, x2) ->\n Ast_414.Parsetree.Pexp_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_expression x2)\n | Ast_413.Parsetree.Pexp_function x0 ->\n Ast_414.Parsetree.Pexp_function (List.map copy_case x0)\n | Ast_413.Parsetree.Pexp_fun (x0, x1, x2, x3) ->\n Ast_414.Parsetree.Pexp_fun\n ( copy_arg_label x0,\n Option.map copy_expression x1,\n copy_pattern x2,\n copy_expression x3 )\n | Ast_413.Parsetree.Pexp_apply (x0, x1) ->\n Ast_414.Parsetree.Pexp_apply\n ( copy_expression x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | Ast_413.Parsetree.Pexp_match (x0, x1) ->\n Ast_414.Parsetree.Pexp_match (copy_expression x0, List.map copy_case x1)\n | Ast_413.Parsetree.Pexp_try (x0, x1) ->\n Ast_414.Parsetree.Pexp_try (copy_expression x0, List.map copy_case x1)\n | Ast_413.Parsetree.Pexp_tuple x0 ->\n Ast_414.Parsetree.Pexp_tuple (List.map copy_expression x0)\n | Ast_413.Parsetree.Pexp_construct (x0, x1) ->\n Ast_414.Parsetree.Pexp_construct\n (copy_loc copy_Longident_t x0, Option.map copy_expression x1)\n | Ast_413.Parsetree.Pexp_variant (x0, x1) ->\n Ast_414.Parsetree.Pexp_variant\n (copy_label x0, Option.map copy_expression x1)\n | Ast_413.Parsetree.Pexp_record (x0, x1) ->\n Ast_414.Parsetree.Pexp_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_expression x1))\n x0,\n Option.map copy_expression x1 )\n | Ast_413.Parsetree.Pexp_field (x0, x1) ->\n Ast_414.Parsetree.Pexp_field\n (copy_expression x0, copy_loc copy_Longident_t x1)\n | Ast_413.Parsetree.Pexp_setfield (x0, x1, x2) ->\n Ast_414.Parsetree.Pexp_setfield\n (copy_expression x0, copy_loc copy_Longident_t x1, copy_expression x2)\n | Ast_413.Parsetree.Pexp_array x0 ->\n Ast_414.Parsetree.Pexp_array (List.map copy_expression x0)\n | Ast_413.Parsetree.Pexp_ifthenelse (x0, x1, x2) ->\n Ast_414.Parsetree.Pexp_ifthenelse\n (copy_expression x0, copy_expression x1, Option.map copy_expression x2)\n | Ast_413.Parsetree.Pexp_sequence (x0, x1) ->\n Ast_414.Parsetree.Pexp_sequence (copy_expression x0, copy_expression x1)\n | Ast_413.Parsetree.Pexp_while (x0, x1) ->\n Ast_414.Parsetree.Pexp_while (copy_expression x0, copy_expression x1)\n | Ast_413.Parsetree.Pexp_for (x0, x1, x2, x3, x4) ->\n Ast_414.Parsetree.Pexp_for\n ( copy_pattern x0,\n copy_expression x1,\n copy_expression x2,\n copy_direction_flag x3,\n copy_expression x4 )\n | Ast_413.Parsetree.Pexp_constraint (x0, x1) ->\n Ast_414.Parsetree.Pexp_constraint (copy_expression x0, copy_core_type x1)\n | Ast_413.Parsetree.Pexp_coerce (x0, x1, x2) ->\n Ast_414.Parsetree.Pexp_coerce\n (copy_expression x0, Option.map copy_core_type x1, copy_core_type x2)\n | Ast_413.Parsetree.Pexp_send (x0, x1) ->\n Ast_414.Parsetree.Pexp_send (copy_expression x0, copy_loc copy_label x1)\n | Ast_413.Parsetree.Pexp_new x0 ->\n Ast_414.Parsetree.Pexp_new (copy_loc copy_Longident_t x0)\n | Ast_413.Parsetree.Pexp_setinstvar (x0, x1) ->\n Ast_414.Parsetree.Pexp_setinstvar\n (copy_loc copy_label x0, copy_expression x1)\n | Ast_413.Parsetree.Pexp_override x0 ->\n Ast_414.Parsetree.Pexp_override\n (List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_label x0, copy_expression x1))\n x0)\n | Ast_413.Parsetree.Pexp_letmodule (x0, x1, x2) ->\n Ast_414.Parsetree.Pexp_letmodule\n ( copy_loc (fun x -> Option.map (fun x -> x) x) x0,\n copy_module_expr x1,\n copy_expression x2 )\n | Ast_413.Parsetree.Pexp_letexception (x0, x1) ->\n Ast_414.Parsetree.Pexp_letexception\n (copy_extension_constructor x0, copy_expression x1)\n | Ast_413.Parsetree.Pexp_assert x0 ->\n Ast_414.Parsetree.Pexp_assert (copy_expression x0)\n | Ast_413.Parsetree.Pexp_lazy x0 ->\n Ast_414.Parsetree.Pexp_lazy (copy_expression x0)\n | Ast_413.Parsetree.Pexp_poly (x0, x1) ->\n Ast_414.Parsetree.Pexp_poly\n (copy_expression x0, Option.map copy_core_type x1)\n | Ast_413.Parsetree.Pexp_object x0 ->\n Ast_414.Parsetree.Pexp_object (copy_class_structure x0)\n | Ast_413.Parsetree.Pexp_newtype (x0, x1) ->\n Ast_414.Parsetree.Pexp_newtype\n (copy_loc (fun x -> x) x0, copy_expression x1)\n | Ast_413.Parsetree.Pexp_pack x0 ->\n Ast_414.Parsetree.Pexp_pack (copy_module_expr x0)\n | Ast_413.Parsetree.Pexp_open (x0, x1) ->\n Ast_414.Parsetree.Pexp_open (copy_open_declaration x0, copy_expression x1)\n | Ast_413.Parsetree.Pexp_letop x0 ->\n Ast_414.Parsetree.Pexp_letop (copy_letop x0)\n | Ast_413.Parsetree.Pexp_extension x0 ->\n Ast_414.Parsetree.Pexp_extension (copy_extension x0)\n | Ast_413.Parsetree.Pexp_unreachable -> Ast_414.Parsetree.Pexp_unreachable\n\nand copy_letop : Ast_413.Parsetree.letop -> Ast_414.Parsetree.letop =\n fun { Ast_413.Parsetree.let_; Ast_413.Parsetree.ands; Ast_413.Parsetree.body } ->\n {\n Ast_414.Parsetree.let_ = copy_binding_op let_;\n Ast_414.Parsetree.ands = List.map copy_binding_op ands;\n Ast_414.Parsetree.body = copy_expression body;\n }\n\nand copy_binding_op :\n Ast_413.Parsetree.binding_op -> Ast_414.Parsetree.binding_op =\n fun {\n Ast_413.Parsetree.pbop_op;\n Ast_413.Parsetree.pbop_pat;\n Ast_413.Parsetree.pbop_exp;\n Ast_413.Parsetree.pbop_loc;\n } ->\n {\n Ast_414.Parsetree.pbop_op = copy_loc (fun x -> x) pbop_op;\n Ast_414.Parsetree.pbop_pat = copy_pattern pbop_pat;\n Ast_414.Parsetree.pbop_exp = copy_expression pbop_exp;\n Ast_414.Parsetree.pbop_loc = copy_location pbop_loc;\n }\n\nand copy_direction_flag :\n Ast_413.Asttypes.direction_flag -> Ast_414.Asttypes.direction_flag =\n function\n | Ast_413.Asttypes.Upto -> Ast_414.Asttypes.Upto\n | Ast_413.Asttypes.Downto -> Ast_414.Asttypes.Downto\n\nand copy_case : Ast_413.Parsetree.case -> Ast_414.Parsetree.case =\n fun {\n Ast_413.Parsetree.pc_lhs;\n Ast_413.Parsetree.pc_guard;\n Ast_413.Parsetree.pc_rhs;\n } ->\n {\n Ast_414.Parsetree.pc_lhs = copy_pattern pc_lhs;\n Ast_414.Parsetree.pc_guard = Option.map copy_expression pc_guard;\n Ast_414.Parsetree.pc_rhs = copy_expression pc_rhs;\n }\n\nand copy_value_binding :\n Ast_413.Parsetree.value_binding -> Ast_414.Parsetree.value_binding =\n fun {\n Ast_413.Parsetree.pvb_pat;\n Ast_413.Parsetree.pvb_expr;\n Ast_413.Parsetree.pvb_attributes;\n Ast_413.Parsetree.pvb_loc;\n } ->\n {\n Ast_414.Parsetree.pvb_pat = copy_pattern pvb_pat;\n Ast_414.Parsetree.pvb_expr = copy_expression pvb_expr;\n Ast_414.Parsetree.pvb_attributes = copy_attributes pvb_attributes;\n Ast_414.Parsetree.pvb_loc = copy_location pvb_loc;\n }\n\nand copy_pattern : Ast_413.Parsetree.pattern -> Ast_414.Parsetree.pattern =\n fun {\n Ast_413.Parsetree.ppat_desc;\n Ast_413.Parsetree.ppat_loc;\n Ast_413.Parsetree.ppat_loc_stack;\n Ast_413.Parsetree.ppat_attributes;\n } ->\n {\n Ast_414.Parsetree.ppat_desc = copy_pattern_desc ppat_desc;\n Ast_414.Parsetree.ppat_loc = copy_location ppat_loc;\n Ast_414.Parsetree.ppat_loc_stack = copy_location_stack ppat_loc_stack;\n Ast_414.Parsetree.ppat_attributes = copy_attributes ppat_attributes;\n }\n\nand copy_pattern_desc :\n Ast_413.Parsetree.pattern_desc -> Ast_414.Parsetree.pattern_desc = function\n | Ast_413.Parsetree.Ppat_any -> Ast_414.Parsetree.Ppat_any\n | Ast_413.Parsetree.Ppat_var x0 ->\n Ast_414.Parsetree.Ppat_var (copy_loc (fun x -> x) x0)\n | Ast_413.Parsetree.Ppat_alias (x0, x1) ->\n Ast_414.Parsetree.Ppat_alias (copy_pattern x0, copy_loc (fun x -> x) x1)\n | Ast_413.Parsetree.Ppat_constant x0 ->\n Ast_414.Parsetree.Ppat_constant (copy_constant x0)\n | Ast_413.Parsetree.Ppat_interval (x0, x1) ->\n Ast_414.Parsetree.Ppat_interval (copy_constant x0, copy_constant x1)\n | Ast_413.Parsetree.Ppat_tuple x0 ->\n Ast_414.Parsetree.Ppat_tuple (List.map copy_pattern x0)\n | Ast_413.Parsetree.Ppat_construct (x0, x1) ->\n Ast_414.Parsetree.Ppat_construct\n ( copy_loc copy_Longident_t x0,\n Option.map\n (fun x ->\n let x0, x1 = x in\n (List.map (fun x -> copy_loc (fun x -> x) x) x0, copy_pattern x1))\n x1 )\n | Ast_413.Parsetree.Ppat_variant (x0, x1) ->\n Ast_414.Parsetree.Ppat_variant (copy_label x0, Option.map copy_pattern x1)\n | Ast_413.Parsetree.Ppat_record (x0, x1) ->\n Ast_414.Parsetree.Ppat_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_pattern x1))\n x0,\n copy_closed_flag x1 )\n | Ast_413.Parsetree.Ppat_array x0 ->\n Ast_414.Parsetree.Ppat_array (List.map copy_pattern x0)\n | Ast_413.Parsetree.Ppat_or (x0, x1) ->\n Ast_414.Parsetree.Ppat_or (copy_pattern x0, copy_pattern x1)\n | Ast_413.Parsetree.Ppat_constraint (x0, x1) ->\n Ast_414.Parsetree.Ppat_constraint (copy_pattern x0, copy_core_type x1)\n | Ast_413.Parsetree.Ppat_type x0 ->\n Ast_414.Parsetree.Ppat_type (copy_loc copy_Longident_t x0)\n | Ast_413.Parsetree.Ppat_lazy x0 ->\n Ast_414.Parsetree.Ppat_lazy (copy_pattern x0)\n | Ast_413.Parsetree.Ppat_unpack x0 ->\n Ast_414.Parsetree.Ppat_unpack\n (copy_loc (fun x -> Option.map (fun x -> x) x) x0)\n | Ast_413.Parsetree.Ppat_exception x0 ->\n Ast_414.Parsetree.Ppat_exception (copy_pattern x0)\n | Ast_413.Parsetree.Ppat_extension x0 ->\n Ast_414.Parsetree.Ppat_extension (copy_extension x0)\n | Ast_413.Parsetree.Ppat_open (x0, x1) ->\n Ast_414.Parsetree.Ppat_open (copy_loc copy_Longident_t x0, copy_pattern x1)\n\nand copy_core_type : Ast_413.Parsetree.core_type -> Ast_414.Parsetree.core_type\n =\n fun {\n Ast_413.Parsetree.ptyp_desc;\n Ast_413.Parsetree.ptyp_loc;\n Ast_413.Parsetree.ptyp_loc_stack;\n Ast_413.Parsetree.ptyp_attributes;\n } ->\n {\n Ast_414.Parsetree.ptyp_desc = copy_core_type_desc ptyp_desc;\n Ast_414.Parsetree.ptyp_loc = copy_location ptyp_loc;\n Ast_414.Parsetree.ptyp_loc_stack = copy_location_stack ptyp_loc_stack;\n Ast_414.Parsetree.ptyp_attributes = copy_attributes ptyp_attributes;\n }\n\nand copy_location_stack :\n Ast_413.Parsetree.location_stack -> Ast_414.Parsetree.location_stack =\n fun x -> x\n\nand copy_core_type_desc :\n Ast_413.Parsetree.core_type_desc -> Ast_414.Parsetree.core_type_desc =\n function\n | Ast_413.Parsetree.Ptyp_any -> Ast_414.Parsetree.Ptyp_any\n | Ast_413.Parsetree.Ptyp_var x0 -> Ast_414.Parsetree.Ptyp_var x0\n | Ast_413.Parsetree.Ptyp_arrow (x0, x1, x2) ->\n Ast_414.Parsetree.Ptyp_arrow\n (copy_arg_label x0, copy_core_type x1, copy_core_type x2)\n | Ast_413.Parsetree.Ptyp_tuple x0 ->\n Ast_414.Parsetree.Ptyp_tuple (List.map copy_core_type x0)\n | Ast_413.Parsetree.Ptyp_constr (x0, x1) ->\n Ast_414.Parsetree.Ptyp_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_413.Parsetree.Ptyp_object (x0, x1) ->\n Ast_414.Parsetree.Ptyp_object\n (List.map copy_object_field x0, copy_closed_flag x1)\n | Ast_413.Parsetree.Ptyp_class (x0, x1) ->\n Ast_414.Parsetree.Ptyp_class\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_413.Parsetree.Ptyp_alias (x0, x1) ->\n Ast_414.Parsetree.Ptyp_alias (copy_core_type x0, x1)\n | Ast_413.Parsetree.Ptyp_variant (x0, x1, x2) ->\n Ast_414.Parsetree.Ptyp_variant\n ( List.map copy_row_field x0,\n copy_closed_flag x1,\n Option.map (fun x -> List.map copy_label x) x2 )\n | Ast_413.Parsetree.Ptyp_poly (x0, x1) ->\n Ast_414.Parsetree.Ptyp_poly\n (List.map (fun x -> copy_loc (fun x -> x) x) x0, copy_core_type x1)\n | Ast_413.Parsetree.Ptyp_package x0 ->\n Ast_414.Parsetree.Ptyp_package (copy_package_type x0)\n | Ast_413.Parsetree.Ptyp_extension x0 ->\n Ast_414.Parsetree.Ptyp_extension (copy_extension x0)\n\nand copy_package_type :\n Ast_413.Parsetree.package_type -> Ast_414.Parsetree.package_type =\n fun x ->\n let x0, x1 = x in\n ( copy_loc copy_Longident_t x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_core_type x1))\n x1 )\n\nand copy_row_field : Ast_413.Parsetree.row_field -> Ast_414.Parsetree.row_field\n =\n fun {\n Ast_413.Parsetree.prf_desc;\n Ast_413.Parsetree.prf_loc;\n Ast_413.Parsetree.prf_attributes;\n } ->\n {\n Ast_414.Parsetree.prf_desc = copy_row_field_desc prf_desc;\n Ast_414.Parsetree.prf_loc = copy_location prf_loc;\n Ast_414.Parsetree.prf_attributes = copy_attributes prf_attributes;\n }\n\nand copy_row_field_desc :\n Ast_413.Parsetree.row_field_desc -> Ast_414.Parsetree.row_field_desc =\n function\n | Ast_413.Parsetree.Rtag (x0, x1, x2) ->\n Ast_414.Parsetree.Rtag\n (copy_loc copy_label x0, x1, List.map copy_core_type x2)\n | Ast_413.Parsetree.Rinherit x0 ->\n Ast_414.Parsetree.Rinherit (copy_core_type x0)\n\nand copy_object_field :\n Ast_413.Parsetree.object_field -> Ast_414.Parsetree.object_field =\n fun {\n Ast_413.Parsetree.pof_desc;\n Ast_413.Parsetree.pof_loc;\n Ast_413.Parsetree.pof_attributes;\n } ->\n {\n Ast_414.Parsetree.pof_desc = copy_object_field_desc pof_desc;\n Ast_414.Parsetree.pof_loc = copy_location pof_loc;\n Ast_414.Parsetree.pof_attributes = copy_attributes pof_attributes;\n }\n\nand copy_attributes :\n Ast_413.Parsetree.attributes -> Ast_414.Parsetree.attributes =\n fun x -> List.map copy_attribute x\n\nand copy_attribute : Ast_413.Parsetree.attribute -> Ast_414.Parsetree.attribute\n =\n fun {\n Ast_413.Parsetree.attr_name;\n Ast_413.Parsetree.attr_payload;\n Ast_413.Parsetree.attr_loc;\n } ->\n {\n Ast_414.Parsetree.attr_name = copy_loc (fun x -> x) attr_name;\n Ast_414.Parsetree.attr_payload = copy_payload attr_payload;\n Ast_414.Parsetree.attr_loc = copy_location attr_loc;\n }\n\nand copy_payload : Ast_413.Parsetree.payload -> Ast_414.Parsetree.payload =\n function\n | Ast_413.Parsetree.PStr x0 -> Ast_414.Parsetree.PStr (copy_structure x0)\n | Ast_413.Parsetree.PSig x0 -> Ast_414.Parsetree.PSig (copy_signature x0)\n | Ast_413.Parsetree.PTyp x0 -> Ast_414.Parsetree.PTyp (copy_core_type x0)\n | Ast_413.Parsetree.PPat (x0, x1) ->\n Ast_414.Parsetree.PPat (copy_pattern x0, Option.map copy_expression x1)\n\nand copy_structure : Ast_413.Parsetree.structure -> Ast_414.Parsetree.structure\n =\n fun x -> List.map copy_structure_item x\n\nand copy_structure_item :\n Ast_413.Parsetree.structure_item -> Ast_414.Parsetree.structure_item =\n fun { Ast_413.Parsetree.pstr_desc; Ast_413.Parsetree.pstr_loc } ->\n {\n Ast_414.Parsetree.pstr_desc = copy_structure_item_desc pstr_desc;\n Ast_414.Parsetree.pstr_loc = copy_location pstr_loc;\n }\n\nand copy_structure_item_desc :\n Ast_413.Parsetree.structure_item_desc ->\n Ast_414.Parsetree.structure_item_desc = function\n | Ast_413.Parsetree.Pstr_eval (x0, x1) ->\n Ast_414.Parsetree.Pstr_eval (copy_expression x0, copy_attributes x1)\n | Ast_413.Parsetree.Pstr_value (x0, x1) ->\n Ast_414.Parsetree.Pstr_value\n (copy_rec_flag x0, List.map copy_value_binding x1)\n | Ast_413.Parsetree.Pstr_primitive x0 ->\n Ast_414.Parsetree.Pstr_primitive (copy_value_description x0)\n | Ast_413.Parsetree.Pstr_type (x0, x1) ->\n Ast_414.Parsetree.Pstr_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | Ast_413.Parsetree.Pstr_typext x0 ->\n Ast_414.Parsetree.Pstr_typext (copy_type_extension x0)\n | Ast_413.Parsetree.Pstr_exception x0 ->\n Ast_414.Parsetree.Pstr_exception (copy_type_exception x0)\n | Ast_413.Parsetree.Pstr_module x0 ->\n Ast_414.Parsetree.Pstr_module (copy_module_binding x0)\n | Ast_413.Parsetree.Pstr_recmodule x0 ->\n Ast_414.Parsetree.Pstr_recmodule (List.map copy_module_binding x0)\n | Ast_413.Parsetree.Pstr_modtype x0 ->\n Ast_414.Parsetree.Pstr_modtype (copy_module_type_declaration x0)\n | Ast_413.Parsetree.Pstr_open x0 ->\n Ast_414.Parsetree.Pstr_open (copy_open_declaration x0)\n | Ast_413.Parsetree.Pstr_class x0 ->\n Ast_414.Parsetree.Pstr_class (List.map copy_class_declaration x0)\n | Ast_413.Parsetree.Pstr_class_type x0 ->\n Ast_414.Parsetree.Pstr_class_type\n (List.map copy_class_type_declaration x0)\n | Ast_413.Parsetree.Pstr_include x0 ->\n Ast_414.Parsetree.Pstr_include (copy_include_declaration x0)\n | Ast_413.Parsetree.Pstr_attribute x0 ->\n Ast_414.Parsetree.Pstr_attribute (copy_attribute x0)\n | Ast_413.Parsetree.Pstr_extension (x0, x1) ->\n Ast_414.Parsetree.Pstr_extension (copy_extension x0, copy_attributes x1)\n\nand copy_include_declaration :\n Ast_413.Parsetree.include_declaration ->\n Ast_414.Parsetree.include_declaration =\n fun x -> copy_include_infos copy_module_expr x\n\nand copy_class_declaration :\n Ast_413.Parsetree.class_declaration -> Ast_414.Parsetree.class_declaration =\n fun x -> copy_class_infos copy_class_expr x\n\nand copy_class_expr :\n Ast_413.Parsetree.class_expr -> Ast_414.Parsetree.class_expr =\n fun {\n Ast_413.Parsetree.pcl_desc;\n Ast_413.Parsetree.pcl_loc;\n Ast_413.Parsetree.pcl_attributes;\n } ->\n {\n Ast_414.Parsetree.pcl_desc = copy_class_expr_desc pcl_desc;\n Ast_414.Parsetree.pcl_loc = copy_location pcl_loc;\n Ast_414.Parsetree.pcl_attributes = copy_attributes pcl_attributes;\n }\n\nand copy_class_expr_desc :\n Ast_413.Parsetree.class_expr_desc -> Ast_414.Parsetree.class_expr_desc =\n function\n | Ast_413.Parsetree.Pcl_constr (x0, x1) ->\n Ast_414.Parsetree.Pcl_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_413.Parsetree.Pcl_structure x0 ->\n Ast_414.Parsetree.Pcl_structure (copy_class_structure x0)\n | Ast_413.Parsetree.Pcl_fun (x0, x1, x2, x3) ->\n Ast_414.Parsetree.Pcl_fun\n ( copy_arg_label x0,\n Option.map copy_expression x1,\n copy_pattern x2,\n copy_class_expr x3 )\n | Ast_413.Parsetree.Pcl_apply (x0, x1) ->\n Ast_414.Parsetree.Pcl_apply\n ( copy_class_expr x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | Ast_413.Parsetree.Pcl_let (x0, x1, x2) ->\n Ast_414.Parsetree.Pcl_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_class_expr x2)\n | Ast_413.Parsetree.Pcl_constraint (x0, x1) ->\n Ast_414.Parsetree.Pcl_constraint (copy_class_expr x0, copy_class_type x1)\n | Ast_413.Parsetree.Pcl_extension x0 ->\n Ast_414.Parsetree.Pcl_extension (copy_extension x0)\n | Ast_413.Parsetree.Pcl_open (x0, x1) ->\n Ast_414.Parsetree.Pcl_open (copy_open_description x0, copy_class_expr x1)\n\nand copy_class_structure :\n Ast_413.Parsetree.class_structure -> Ast_414.Parsetree.class_structure =\n fun { Ast_413.Parsetree.pcstr_self; Ast_413.Parsetree.pcstr_fields } ->\n {\n Ast_414.Parsetree.pcstr_self = copy_pattern pcstr_self;\n Ast_414.Parsetree.pcstr_fields = List.map copy_class_field pcstr_fields;\n }\n\nand copy_class_field :\n Ast_413.Parsetree.class_field -> Ast_414.Parsetree.class_field =\n fun {\n Ast_413.Parsetree.pcf_desc;\n Ast_413.Parsetree.pcf_loc;\n Ast_413.Parsetree.pcf_attributes;\n } ->\n {\n Ast_414.Parsetree.pcf_desc = copy_class_field_desc pcf_desc;\n Ast_414.Parsetree.pcf_loc = copy_location pcf_loc;\n Ast_414.Parsetree.pcf_attributes = copy_attributes pcf_attributes;\n }\n\nand copy_class_field_desc :\n Ast_413.Parsetree.class_field_desc -> Ast_414.Parsetree.class_field_desc =\n function\n | Ast_413.Parsetree.Pcf_inherit (x0, x1, x2) ->\n Ast_414.Parsetree.Pcf_inherit\n ( copy_override_flag x0,\n copy_class_expr x1,\n Option.map (fun x -> copy_loc (fun x -> x) x) x2 )\n | Ast_413.Parsetree.Pcf_val x0 ->\n Ast_414.Parsetree.Pcf_val\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_mutable_flag x1, copy_class_field_kind x2))\n | Ast_413.Parsetree.Pcf_method x0 ->\n Ast_414.Parsetree.Pcf_method\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_private_flag x1, copy_class_field_kind x2))\n | Ast_413.Parsetree.Pcf_constraint x0 ->\n Ast_414.Parsetree.Pcf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | Ast_413.Parsetree.Pcf_initializer x0 ->\n Ast_414.Parsetree.Pcf_initializer (copy_expression x0)\n | Ast_413.Parsetree.Pcf_attribute x0 ->\n Ast_414.Parsetree.Pcf_attribute (copy_attribute x0)\n | Ast_413.Parsetree.Pcf_extension x0 ->\n Ast_414.Parsetree.Pcf_extension (copy_extension x0)\n\nand copy_class_field_kind :\n Ast_413.Parsetree.class_field_kind -> Ast_414.Parsetree.class_field_kind =\n function\n | Ast_413.Parsetree.Cfk_virtual x0 ->\n Ast_414.Parsetree.Cfk_virtual (copy_core_type x0)\n | Ast_413.Parsetree.Cfk_concrete (x0, x1) ->\n Ast_414.Parsetree.Cfk_concrete (copy_override_flag x0, copy_expression x1)\n\nand copy_open_declaration :\n Ast_413.Parsetree.open_declaration -> Ast_414.Parsetree.open_declaration =\n fun x -> copy_open_infos copy_module_expr x\n\nand copy_module_binding :\n Ast_413.Parsetree.module_binding -> Ast_414.Parsetree.module_binding =\n fun {\n Ast_413.Parsetree.pmb_name;\n Ast_413.Parsetree.pmb_expr;\n Ast_413.Parsetree.pmb_attributes;\n Ast_413.Parsetree.pmb_loc;\n } ->\n {\n Ast_414.Parsetree.pmb_name =\n copy_loc (fun x -> Option.map (fun x -> x) x) pmb_name;\n Ast_414.Parsetree.pmb_expr = copy_module_expr pmb_expr;\n Ast_414.Parsetree.pmb_attributes = copy_attributes pmb_attributes;\n Ast_414.Parsetree.pmb_loc = copy_location pmb_loc;\n }\n\nand copy_module_expr :\n Ast_413.Parsetree.module_expr -> Ast_414.Parsetree.module_expr =\n fun {\n Ast_413.Parsetree.pmod_desc;\n Ast_413.Parsetree.pmod_loc;\n Ast_413.Parsetree.pmod_attributes;\n } ->\n {\n Ast_414.Parsetree.pmod_desc = copy_module_expr_desc pmod_desc;\n Ast_414.Parsetree.pmod_loc = copy_location pmod_loc;\n Ast_414.Parsetree.pmod_attributes = copy_attributes pmod_attributes;\n }\n\nand copy_module_expr_desc :\n Ast_413.Parsetree.module_expr_desc -> Ast_414.Parsetree.module_expr_desc =\n function\n | Ast_413.Parsetree.Pmod_ident x0 ->\n Ast_414.Parsetree.Pmod_ident (copy_loc copy_Longident_t x0)\n | Ast_413.Parsetree.Pmod_structure x0 ->\n Ast_414.Parsetree.Pmod_structure (copy_structure x0)\n | Ast_413.Parsetree.Pmod_functor (x0, x1) ->\n Ast_414.Parsetree.Pmod_functor\n (copy_functor_parameter x0, copy_module_expr x1)\n | Ast_413.Parsetree.Pmod_apply (x0, x1) ->\n Ast_414.Parsetree.Pmod_apply (copy_module_expr x0, copy_module_expr x1)\n | Ast_413.Parsetree.Pmod_constraint (x0, x1) ->\n Ast_414.Parsetree.Pmod_constraint\n (copy_module_expr x0, copy_module_type x1)\n | Ast_413.Parsetree.Pmod_unpack x0 ->\n Ast_414.Parsetree.Pmod_unpack (copy_expression x0)\n | Ast_413.Parsetree.Pmod_extension x0 ->\n Ast_414.Parsetree.Pmod_extension (copy_extension x0)\n\nand copy_functor_parameter :\n Ast_413.Parsetree.functor_parameter -> Ast_414.Parsetree.functor_parameter =\n function\n | Ast_413.Parsetree.Unit -> Ast_414.Parsetree.Unit\n | Ast_413.Parsetree.Named (x0, x1) ->\n Ast_414.Parsetree.Named\n (copy_loc (fun x -> Option.map (fun x -> x) x) x0, copy_module_type x1)\n\nand copy_module_type :\n Ast_413.Parsetree.module_type -> Ast_414.Parsetree.module_type =\n fun {\n Ast_413.Parsetree.pmty_desc;\n Ast_413.Parsetree.pmty_loc;\n Ast_413.Parsetree.pmty_attributes;\n } ->\n {\n Ast_414.Parsetree.pmty_desc = copy_module_type_desc pmty_desc;\n Ast_414.Parsetree.pmty_loc = copy_location pmty_loc;\n Ast_414.Parsetree.pmty_attributes = copy_attributes pmty_attributes;\n }\n\nand copy_module_type_desc :\n Ast_413.Parsetree.module_type_desc -> Ast_414.Parsetree.module_type_desc =\n function\n | Ast_413.Parsetree.Pmty_ident x0 ->\n Ast_414.Parsetree.Pmty_ident (copy_loc copy_Longident_t x0)\n | Ast_413.Parsetree.Pmty_signature x0 ->\n Ast_414.Parsetree.Pmty_signature (copy_signature x0)\n | Ast_413.Parsetree.Pmty_functor (x0, x1) ->\n Ast_414.Parsetree.Pmty_functor\n (copy_functor_parameter x0, copy_module_type x1)\n | Ast_413.Parsetree.Pmty_with (x0, x1) ->\n Ast_414.Parsetree.Pmty_with\n (copy_module_type x0, List.map copy_with_constraint x1)\n | Ast_413.Parsetree.Pmty_typeof x0 ->\n Ast_414.Parsetree.Pmty_typeof (copy_module_expr x0)\n | Ast_413.Parsetree.Pmty_extension x0 ->\n Ast_414.Parsetree.Pmty_extension (copy_extension x0)\n | Ast_413.Parsetree.Pmty_alias x0 ->\n Ast_414.Parsetree.Pmty_alias (copy_loc copy_Longident_t x0)\n\nand copy_with_constraint :\n Ast_413.Parsetree.with_constraint -> Ast_414.Parsetree.with_constraint =\n function\n | Ast_413.Parsetree.Pwith_type (x0, x1) ->\n Ast_414.Parsetree.Pwith_type\n (copy_loc copy_Longident_t x0, copy_type_declaration x1)\n | Ast_413.Parsetree.Pwith_module (x0, x1) ->\n Ast_414.Parsetree.Pwith_module\n (copy_loc copy_Longident_t x0, copy_loc copy_Longident_t x1)\n | Ast_413.Parsetree.Pwith_modtype (x0, x1) ->\n Ast_414.Parsetree.Pwith_modtype\n (copy_loc copy_Longident_t x0, copy_module_type x1)\n | Ast_413.Parsetree.Pwith_modtypesubst (x0, x1) ->\n Ast_414.Parsetree.Pwith_modtypesubst\n (copy_loc copy_Longident_t x0, copy_module_type x1)\n | Ast_413.Parsetree.Pwith_typesubst (x0, x1) ->\n Ast_414.Parsetree.Pwith_typesubst\n (copy_loc copy_Longident_t x0, copy_type_declaration x1)\n | Ast_413.Parsetree.Pwith_modsubst (x0, x1) ->\n Ast_414.Parsetree.Pwith_modsubst\n (copy_loc copy_Longident_t x0, copy_loc copy_Longident_t x1)\n\nand copy_signature : Ast_413.Parsetree.signature -> Ast_414.Parsetree.signature\n =\n fun x -> List.map copy_signature_item x\n\nand copy_signature_item :\n Ast_413.Parsetree.signature_item -> Ast_414.Parsetree.signature_item =\n fun { Ast_413.Parsetree.psig_desc; Ast_413.Parsetree.psig_loc } ->\n {\n Ast_414.Parsetree.psig_desc = copy_signature_item_desc psig_desc;\n Ast_414.Parsetree.psig_loc = copy_location psig_loc;\n }\n\nand copy_signature_item_desc :\n Ast_413.Parsetree.signature_item_desc ->\n Ast_414.Parsetree.signature_item_desc = function\n | Ast_413.Parsetree.Psig_value x0 ->\n Ast_414.Parsetree.Psig_value (copy_value_description x0)\n | Ast_413.Parsetree.Psig_type (x0, x1) ->\n Ast_414.Parsetree.Psig_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | Ast_413.Parsetree.Psig_typesubst x0 ->\n Ast_414.Parsetree.Psig_typesubst (List.map copy_type_declaration x0)\n | Ast_413.Parsetree.Psig_typext x0 ->\n Ast_414.Parsetree.Psig_typext (copy_type_extension x0)\n | Ast_413.Parsetree.Psig_exception x0 ->\n Ast_414.Parsetree.Psig_exception (copy_type_exception x0)\n | Ast_413.Parsetree.Psig_module x0 ->\n Ast_414.Parsetree.Psig_module (copy_module_declaration x0)\n | Ast_413.Parsetree.Psig_modsubst x0 ->\n Ast_414.Parsetree.Psig_modsubst (copy_module_substitution x0)\n | Ast_413.Parsetree.Psig_recmodule x0 ->\n Ast_414.Parsetree.Psig_recmodule (List.map copy_module_declaration x0)\n | Ast_413.Parsetree.Psig_modtype x0 ->\n Ast_414.Parsetree.Psig_modtype (copy_module_type_declaration x0)\n | Ast_413.Parsetree.Psig_modtypesubst x0 ->\n Ast_414.Parsetree.Psig_modtypesubst (copy_module_type_declaration x0)\n | Ast_413.Parsetree.Psig_open x0 ->\n Ast_414.Parsetree.Psig_open (copy_open_description x0)\n | Ast_413.Parsetree.Psig_include x0 ->\n Ast_414.Parsetree.Psig_include (copy_include_description x0)\n | Ast_413.Parsetree.Psig_class x0 ->\n Ast_414.Parsetree.Psig_class (List.map copy_class_description x0)\n | Ast_413.Parsetree.Psig_class_type x0 ->\n Ast_414.Parsetree.Psig_class_type\n (List.map copy_class_type_declaration x0)\n | Ast_413.Parsetree.Psig_attribute x0 ->\n Ast_414.Parsetree.Psig_attribute (copy_attribute x0)\n | Ast_413.Parsetree.Psig_extension (x0, x1) ->\n Ast_414.Parsetree.Psig_extension (copy_extension x0, copy_attributes x1)\n\nand copy_class_type_declaration :\n Ast_413.Parsetree.class_type_declaration ->\n Ast_414.Parsetree.class_type_declaration =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_description :\n Ast_413.Parsetree.class_description -> Ast_414.Parsetree.class_description =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_type :\n Ast_413.Parsetree.class_type -> Ast_414.Parsetree.class_type =\n fun {\n Ast_413.Parsetree.pcty_desc;\n Ast_413.Parsetree.pcty_loc;\n Ast_413.Parsetree.pcty_attributes;\n } ->\n {\n Ast_414.Parsetree.pcty_desc = copy_class_type_desc pcty_desc;\n Ast_414.Parsetree.pcty_loc = copy_location pcty_loc;\n Ast_414.Parsetree.pcty_attributes = copy_attributes pcty_attributes;\n }\n\nand copy_class_type_desc :\n Ast_413.Parsetree.class_type_desc -> Ast_414.Parsetree.class_type_desc =\n function\n | Ast_413.Parsetree.Pcty_constr (x0, x1) ->\n Ast_414.Parsetree.Pcty_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_413.Parsetree.Pcty_signature x0 ->\n Ast_414.Parsetree.Pcty_signature (copy_class_signature x0)\n | Ast_413.Parsetree.Pcty_arrow (x0, x1, x2) ->\n Ast_414.Parsetree.Pcty_arrow\n (copy_arg_label x0, copy_core_type x1, copy_class_type x2)\n | Ast_413.Parsetree.Pcty_extension x0 ->\n Ast_414.Parsetree.Pcty_extension (copy_extension x0)\n | Ast_413.Parsetree.Pcty_open (x0, x1) ->\n Ast_414.Parsetree.Pcty_open (copy_open_description x0, copy_class_type x1)\n\nand copy_class_signature :\n Ast_413.Parsetree.class_signature -> Ast_414.Parsetree.class_signature =\n fun { Ast_413.Parsetree.pcsig_self; Ast_413.Parsetree.pcsig_fields } ->\n {\n Ast_414.Parsetree.pcsig_self = copy_core_type pcsig_self;\n Ast_414.Parsetree.pcsig_fields = List.map copy_class_type_field pcsig_fields;\n }\n\nand copy_class_type_field :\n Ast_413.Parsetree.class_type_field -> Ast_414.Parsetree.class_type_field =\n fun {\n Ast_413.Parsetree.pctf_desc;\n Ast_413.Parsetree.pctf_loc;\n Ast_413.Parsetree.pctf_attributes;\n } ->\n {\n Ast_414.Parsetree.pctf_desc = copy_class_type_field_desc pctf_desc;\n Ast_414.Parsetree.pctf_loc = copy_location pctf_loc;\n Ast_414.Parsetree.pctf_attributes = copy_attributes pctf_attributes;\n }\n\nand copy_class_type_field_desc :\n Ast_413.Parsetree.class_type_field_desc ->\n Ast_414.Parsetree.class_type_field_desc = function\n | Ast_413.Parsetree.Pctf_inherit x0 ->\n Ast_414.Parsetree.Pctf_inherit (copy_class_type x0)\n | Ast_413.Parsetree.Pctf_val x0 ->\n Ast_414.Parsetree.Pctf_val\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_mutable_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | Ast_413.Parsetree.Pctf_method x0 ->\n Ast_414.Parsetree.Pctf_method\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_private_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | Ast_413.Parsetree.Pctf_constraint x0 ->\n Ast_414.Parsetree.Pctf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | Ast_413.Parsetree.Pctf_attribute x0 ->\n Ast_414.Parsetree.Pctf_attribute (copy_attribute x0)\n | Ast_413.Parsetree.Pctf_extension x0 ->\n Ast_414.Parsetree.Pctf_extension (copy_extension x0)\n\nand copy_extension : Ast_413.Parsetree.extension -> Ast_414.Parsetree.extension\n =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_class_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_413.Parsetree.class_infos ->\n 'g0 Ast_414.Parsetree.class_infos =\n fun f0\n {\n Ast_413.Parsetree.pci_virt;\n Ast_413.Parsetree.pci_params;\n Ast_413.Parsetree.pci_name;\n Ast_413.Parsetree.pci_expr;\n Ast_413.Parsetree.pci_loc;\n Ast_413.Parsetree.pci_attributes;\n } ->\n {\n Ast_414.Parsetree.pci_virt = copy_virtual_flag pci_virt;\n Ast_414.Parsetree.pci_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n ( copy_core_type x0,\n let x0, x1 = x1 in\n (copy_variance x0, copy_injectivity x1) ))\n pci_params;\n Ast_414.Parsetree.pci_name = copy_loc (fun x -> x) pci_name;\n Ast_414.Parsetree.pci_expr = f0 pci_expr;\n Ast_414.Parsetree.pci_loc = copy_location pci_loc;\n Ast_414.Parsetree.pci_attributes = copy_attributes pci_attributes;\n }\n\nand copy_virtual_flag :\n Ast_413.Asttypes.virtual_flag -> Ast_414.Asttypes.virtual_flag = function\n | Ast_413.Asttypes.Virtual -> Ast_414.Asttypes.Virtual\n | Ast_413.Asttypes.Concrete -> Ast_414.Asttypes.Concrete\n\nand copy_include_description :\n Ast_413.Parsetree.include_description ->\n Ast_414.Parsetree.include_description =\n fun x -> copy_include_infos copy_module_type x\n\nand copy_include_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_413.Parsetree.include_infos ->\n 'g0 Ast_414.Parsetree.include_infos =\n fun f0\n {\n Ast_413.Parsetree.pincl_mod;\n Ast_413.Parsetree.pincl_loc;\n Ast_413.Parsetree.pincl_attributes;\n } ->\n {\n Ast_414.Parsetree.pincl_mod = f0 pincl_mod;\n Ast_414.Parsetree.pincl_loc = copy_location pincl_loc;\n Ast_414.Parsetree.pincl_attributes = copy_attributes pincl_attributes;\n }\n\nand copy_open_description :\n Ast_413.Parsetree.open_description -> Ast_414.Parsetree.open_description =\n fun x -> copy_open_infos (fun x -> copy_loc copy_Longident_t x) x\n\nand copy_open_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_413.Parsetree.open_infos ->\n 'g0 Ast_414.Parsetree.open_infos =\n fun f0\n {\n Ast_413.Parsetree.popen_expr;\n Ast_413.Parsetree.popen_override;\n Ast_413.Parsetree.popen_loc;\n Ast_413.Parsetree.popen_attributes;\n } ->\n {\n Ast_414.Parsetree.popen_expr = f0 popen_expr;\n Ast_414.Parsetree.popen_override = copy_override_flag popen_override;\n Ast_414.Parsetree.popen_loc = copy_location popen_loc;\n Ast_414.Parsetree.popen_attributes = copy_attributes popen_attributes;\n }\n\nand copy_override_flag :\n Ast_413.Asttypes.override_flag -> Ast_414.Asttypes.override_flag = function\n | Ast_413.Asttypes.Override -> Ast_414.Asttypes.Override\n | Ast_413.Asttypes.Fresh -> Ast_414.Asttypes.Fresh\n\nand copy_module_type_declaration :\n Ast_413.Parsetree.module_type_declaration ->\n Ast_414.Parsetree.module_type_declaration =\n fun {\n Ast_413.Parsetree.pmtd_name;\n Ast_413.Parsetree.pmtd_type;\n Ast_413.Parsetree.pmtd_attributes;\n Ast_413.Parsetree.pmtd_loc;\n } ->\n {\n Ast_414.Parsetree.pmtd_name = copy_loc (fun x -> x) pmtd_name;\n Ast_414.Parsetree.pmtd_type = Option.map copy_module_type pmtd_type;\n Ast_414.Parsetree.pmtd_attributes = copy_attributes pmtd_attributes;\n Ast_414.Parsetree.pmtd_loc = copy_location pmtd_loc;\n }\n\nand copy_module_substitution :\n Ast_413.Parsetree.module_substitution ->\n Ast_414.Parsetree.module_substitution =\n fun {\n Ast_413.Parsetree.pms_name;\n Ast_413.Parsetree.pms_manifest;\n Ast_413.Parsetree.pms_attributes;\n Ast_413.Parsetree.pms_loc;\n } ->\n {\n Ast_414.Parsetree.pms_name = copy_loc (fun x -> x) pms_name;\n Ast_414.Parsetree.pms_manifest = copy_loc copy_Longident_t pms_manifest;\n Ast_414.Parsetree.pms_attributes = copy_attributes pms_attributes;\n Ast_414.Parsetree.pms_loc = copy_location pms_loc;\n }\n\nand copy_module_declaration :\n Ast_413.Parsetree.module_declaration -> Ast_414.Parsetree.module_declaration\n =\n fun {\n Ast_413.Parsetree.pmd_name;\n Ast_413.Parsetree.pmd_type;\n Ast_413.Parsetree.pmd_attributes;\n Ast_413.Parsetree.pmd_loc;\n } ->\n {\n Ast_414.Parsetree.pmd_name =\n copy_loc (fun x -> Option.map (fun x -> x) x) pmd_name;\n Ast_414.Parsetree.pmd_type = copy_module_type pmd_type;\n Ast_414.Parsetree.pmd_attributes = copy_attributes pmd_attributes;\n Ast_414.Parsetree.pmd_loc = copy_location pmd_loc;\n }\n\nand copy_type_exception :\n Ast_413.Parsetree.type_exception -> Ast_414.Parsetree.type_exception =\n fun {\n Ast_413.Parsetree.ptyexn_constructor;\n Ast_413.Parsetree.ptyexn_loc;\n Ast_413.Parsetree.ptyexn_attributes;\n } ->\n {\n Ast_414.Parsetree.ptyexn_constructor =\n copy_extension_constructor ptyexn_constructor;\n Ast_414.Parsetree.ptyexn_loc = copy_location ptyexn_loc;\n Ast_414.Parsetree.ptyexn_attributes = copy_attributes ptyexn_attributes;\n }\n\nand copy_type_extension :\n Ast_413.Parsetree.type_extension -> Ast_414.Parsetree.type_extension =\n fun {\n Ast_413.Parsetree.ptyext_path;\n Ast_413.Parsetree.ptyext_params;\n Ast_413.Parsetree.ptyext_constructors;\n Ast_413.Parsetree.ptyext_private;\n Ast_413.Parsetree.ptyext_loc;\n Ast_413.Parsetree.ptyext_attributes;\n } ->\n {\n Ast_414.Parsetree.ptyext_path = copy_loc copy_Longident_t ptyext_path;\n Ast_414.Parsetree.ptyext_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n ( copy_core_type x0,\n let x0, x1 = x1 in\n (copy_variance x0, copy_injectivity x1) ))\n ptyext_params;\n Ast_414.Parsetree.ptyext_constructors =\n List.map copy_extension_constructor ptyext_constructors;\n Ast_414.Parsetree.ptyext_private = copy_private_flag ptyext_private;\n Ast_414.Parsetree.ptyext_loc = copy_location ptyext_loc;\n Ast_414.Parsetree.ptyext_attributes = copy_attributes ptyext_attributes;\n }\n\nand copy_extension_constructor :\n Ast_413.Parsetree.extension_constructor ->\n Ast_414.Parsetree.extension_constructor =\n fun {\n Ast_413.Parsetree.pext_name;\n Ast_413.Parsetree.pext_kind;\n Ast_413.Parsetree.pext_loc;\n Ast_413.Parsetree.pext_attributes;\n } ->\n {\n Ast_414.Parsetree.pext_name = copy_loc (fun x -> x) pext_name;\n Ast_414.Parsetree.pext_kind = copy_extension_constructor_kind pext_kind;\n Ast_414.Parsetree.pext_loc = copy_location pext_loc;\n Ast_414.Parsetree.pext_attributes = copy_attributes pext_attributes;\n }\n\nand copy_extension_constructor_kind :\n Ast_413.Parsetree.extension_constructor_kind ->\n Ast_414.Parsetree.extension_constructor_kind = function\n | Ast_413.Parsetree.Pext_decl (x0, x1) ->\n Ast_414.Parsetree.Pext_decl\n ([], copy_constructor_arguments x0, Option.map copy_core_type x1)\n | Ast_413.Parsetree.Pext_rebind x0 ->\n Ast_414.Parsetree.Pext_rebind (copy_loc copy_Longident_t x0)\n\nand copy_type_declaration :\n Ast_413.Parsetree.type_declaration -> Ast_414.Parsetree.type_declaration =\n fun {\n Ast_413.Parsetree.ptype_name;\n Ast_413.Parsetree.ptype_params;\n Ast_413.Parsetree.ptype_cstrs;\n Ast_413.Parsetree.ptype_kind;\n Ast_413.Parsetree.ptype_private;\n Ast_413.Parsetree.ptype_manifest;\n Ast_413.Parsetree.ptype_attributes;\n Ast_413.Parsetree.ptype_loc;\n } ->\n {\n Ast_414.Parsetree.ptype_name = copy_loc (fun x -> x) ptype_name;\n Ast_414.Parsetree.ptype_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n ( copy_core_type x0,\n let x0, x1 = x1 in\n (copy_variance x0, copy_injectivity x1) ))\n ptype_params;\n Ast_414.Parsetree.ptype_cstrs =\n List.map\n (fun x ->\n let x0, x1, x2 = x in\n (copy_core_type x0, copy_core_type x1, copy_location x2))\n ptype_cstrs;\n Ast_414.Parsetree.ptype_kind = copy_type_kind ptype_kind;\n Ast_414.Parsetree.ptype_private = copy_private_flag ptype_private;\n Ast_414.Parsetree.ptype_manifest = Option.map copy_core_type ptype_manifest;\n Ast_414.Parsetree.ptype_attributes = copy_attributes ptype_attributes;\n Ast_414.Parsetree.ptype_loc = copy_location ptype_loc;\n }\n\nand copy_private_flag :\n Ast_413.Asttypes.private_flag -> Ast_414.Asttypes.private_flag = function\n | Ast_413.Asttypes.Private -> Ast_414.Asttypes.Private\n | Ast_413.Asttypes.Public -> Ast_414.Asttypes.Public\n\nand copy_type_kind : Ast_413.Parsetree.type_kind -> Ast_414.Parsetree.type_kind\n = function\n | Ast_413.Parsetree.Ptype_abstract -> Ast_414.Parsetree.Ptype_abstract\n | Ast_413.Parsetree.Ptype_variant x0 ->\n Ast_414.Parsetree.Ptype_variant (List.map copy_constructor_declaration x0)\n | Ast_413.Parsetree.Ptype_record x0 ->\n Ast_414.Parsetree.Ptype_record (List.map copy_label_declaration x0)\n | Ast_413.Parsetree.Ptype_open -> Ast_414.Parsetree.Ptype_open\n\nand copy_constructor_declaration :\n Ast_413.Parsetree.constructor_declaration ->\n Ast_414.Parsetree.constructor_declaration =\n fun {\n Ast_413.Parsetree.pcd_name;\n Ast_413.Parsetree.pcd_args;\n Ast_413.Parsetree.pcd_res;\n Ast_413.Parsetree.pcd_loc;\n Ast_413.Parsetree.pcd_attributes;\n } ->\n {\n Ast_414.Parsetree.pcd_name = copy_loc (fun x -> x) pcd_name;\n Ast_414.Parsetree.pcd_vars = [];\n Ast_414.Parsetree.pcd_args = copy_constructor_arguments pcd_args;\n Ast_414.Parsetree.pcd_res = Option.map copy_core_type pcd_res;\n Ast_414.Parsetree.pcd_loc = copy_location pcd_loc;\n Ast_414.Parsetree.pcd_attributes = copy_attributes pcd_attributes;\n }\n\nand copy_constructor_arguments :\n Ast_413.Parsetree.constructor_arguments ->\n Ast_414.Parsetree.constructor_arguments = function\n | Ast_413.Parsetree.Pcstr_tuple x0 ->\n Ast_414.Parsetree.Pcstr_tuple (List.map copy_core_type x0)\n | Ast_413.Parsetree.Pcstr_record x0 ->\n Ast_414.Parsetree.Pcstr_record (List.map copy_label_declaration x0)\n\nand copy_label_declaration :\n Ast_413.Parsetree.label_declaration -> Ast_414.Parsetree.label_declaration =\n fun {\n Ast_413.Parsetree.pld_name;\n Ast_413.Parsetree.pld_mutable;\n Ast_413.Parsetree.pld_type;\n Ast_413.Parsetree.pld_loc;\n Ast_413.Parsetree.pld_attributes;\n } ->\n {\n Ast_414.Parsetree.pld_name = copy_loc (fun x -> x) pld_name;\n Ast_414.Parsetree.pld_mutable = copy_mutable_flag pld_mutable;\n Ast_414.Parsetree.pld_type = copy_core_type pld_type;\n Ast_414.Parsetree.pld_loc = copy_location pld_loc;\n Ast_414.Parsetree.pld_attributes = copy_attributes pld_attributes;\n }\n\nand copy_mutable_flag :\n Ast_413.Asttypes.mutable_flag -> Ast_414.Asttypes.mutable_flag = function\n | Ast_413.Asttypes.Immutable -> Ast_414.Asttypes.Immutable\n | Ast_413.Asttypes.Mutable -> Ast_414.Asttypes.Mutable\n\nand copy_injectivity :\n Ast_413.Asttypes.injectivity -> Ast_414.Asttypes.injectivity = function\n | Ast_413.Asttypes.Injective -> Ast_414.Asttypes.Injective\n | Ast_413.Asttypes.NoInjectivity -> Ast_414.Asttypes.NoInjectivity\n\nand copy_variance : Ast_413.Asttypes.variance -> Ast_414.Asttypes.variance =\n function\n | Ast_413.Asttypes.Covariant -> Ast_414.Asttypes.Covariant\n | Ast_413.Asttypes.Contravariant -> Ast_414.Asttypes.Contravariant\n | Ast_413.Asttypes.NoVariance -> Ast_414.Asttypes.NoVariance\n\nand copy_value_description :\n Ast_413.Parsetree.value_description -> Ast_414.Parsetree.value_description =\n fun {\n Ast_413.Parsetree.pval_name;\n Ast_413.Parsetree.pval_type;\n Ast_413.Parsetree.pval_prim;\n Ast_413.Parsetree.pval_attributes;\n Ast_413.Parsetree.pval_loc;\n } ->\n {\n Ast_414.Parsetree.pval_name = copy_loc (fun x -> x) pval_name;\n Ast_414.Parsetree.pval_type = copy_core_type pval_type;\n Ast_414.Parsetree.pval_prim = List.map (fun x -> x) pval_prim;\n Ast_414.Parsetree.pval_attributes = copy_attributes pval_attributes;\n Ast_414.Parsetree.pval_loc = copy_location pval_loc;\n }\n\nand copy_object_field_desc :\n Ast_413.Parsetree.object_field_desc -> Ast_414.Parsetree.object_field_desc =\n function\n | Ast_413.Parsetree.Otag (x0, x1) ->\n Ast_414.Parsetree.Otag (copy_loc copy_label x0, copy_core_type x1)\n | Ast_413.Parsetree.Oinherit x0 ->\n Ast_414.Parsetree.Oinherit (copy_core_type x0)\n\nand copy_arg_label : Ast_413.Asttypes.arg_label -> Ast_414.Asttypes.arg_label =\n function\n | Ast_413.Asttypes.Nolabel -> Ast_414.Asttypes.Nolabel\n | Ast_413.Asttypes.Labelled x0 -> Ast_414.Asttypes.Labelled x0\n | Ast_413.Asttypes.Optional x0 -> Ast_414.Asttypes.Optional x0\n\nand copy_closed_flag :\n Ast_413.Asttypes.closed_flag -> Ast_414.Asttypes.closed_flag = function\n | Ast_413.Asttypes.Closed -> Ast_414.Asttypes.Closed\n | Ast_413.Asttypes.Open -> Ast_414.Asttypes.Open\n\nand copy_label : Ast_413.Asttypes.label -> Ast_414.Asttypes.label = fun x -> x\n\nand copy_rec_flag : Ast_413.Asttypes.rec_flag -> Ast_414.Asttypes.rec_flag =\n function\n | Ast_413.Asttypes.Nonrecursive -> Ast_414.Asttypes.Nonrecursive\n | Ast_413.Asttypes.Recursive -> Ast_414.Asttypes.Recursive\n\nand copy_constant : Ast_413.Parsetree.constant -> Ast_414.Parsetree.constant =\n function\n | Ast_413.Parsetree.Pconst_integer (x0, x1) ->\n Ast_414.Parsetree.Pconst_integer (x0, Option.map (fun x -> x) x1)\n | Ast_413.Parsetree.Pconst_char x0 -> Ast_414.Parsetree.Pconst_char x0\n | Ast_413.Parsetree.Pconst_string (x0, x1, x2) ->\n Ast_414.Parsetree.Pconst_string\n (x0, copy_location x1, Option.map (fun x -> x) x2)\n | Ast_413.Parsetree.Pconst_float (x0, x1) ->\n Ast_414.Parsetree.Pconst_float (x0, Option.map (fun x -> x) x1)\n\nand copy_Longident_t : Longident.t -> Longident.t = fun x -> x\n\nand copy_loc :\n 'f0 'g0.\n ('f0 -> 'g0) -> 'f0 Ast_413.Asttypes.loc -> 'g0 Ast_414.Asttypes.loc =\n fun f0 { Ast_413.Asttypes.txt; Ast_413.Asttypes.loc } ->\n { Ast_414.Asttypes.txt = f0 txt; Ast_414.Asttypes.loc = copy_location loc }\n\nand copy_location : Location.t -> Location.t = fun x -> x\n","open Stdlib0\nmodule From = Ast_413\nmodule To = Ast_412\n\nlet migration_error loc missing_feature =\n Location.raise_errorf ~loc\n \"migration error: %s is not supported before OCaml 4.13\" missing_feature\n\nlet rec copy_toplevel_phrase :\n Ast_413.Parsetree.toplevel_phrase -> Ast_412.Parsetree.toplevel_phrase =\n function\n | Ast_413.Parsetree.Ptop_def x0 ->\n Ast_412.Parsetree.Ptop_def (copy_structure x0)\n | Ast_413.Parsetree.Ptop_dir x0 ->\n Ast_412.Parsetree.Ptop_dir (copy_toplevel_directive x0)\n\nand copy_toplevel_directive :\n Ast_413.Parsetree.toplevel_directive -> Ast_412.Parsetree.toplevel_directive\n =\n fun {\n Ast_413.Parsetree.pdir_name;\n Ast_413.Parsetree.pdir_arg;\n Ast_413.Parsetree.pdir_loc;\n } ->\n {\n Ast_412.Parsetree.pdir_name = copy_loc (fun x -> x) pdir_name;\n Ast_412.Parsetree.pdir_arg = Option.map copy_directive_argument pdir_arg;\n Ast_412.Parsetree.pdir_loc = copy_location pdir_loc;\n }\n\nand copy_directive_argument :\n Ast_413.Parsetree.directive_argument -> Ast_412.Parsetree.directive_argument\n =\n fun { Ast_413.Parsetree.pdira_desc; Ast_413.Parsetree.pdira_loc } ->\n {\n Ast_412.Parsetree.pdira_desc = copy_directive_argument_desc pdira_desc;\n Ast_412.Parsetree.pdira_loc = copy_location pdira_loc;\n }\n\nand copy_directive_argument_desc :\n Ast_413.Parsetree.directive_argument_desc ->\n Ast_412.Parsetree.directive_argument_desc = function\n | Ast_413.Parsetree.Pdir_string x0 -> Ast_412.Parsetree.Pdir_string x0\n | Ast_413.Parsetree.Pdir_int (x0, x1) ->\n Ast_412.Parsetree.Pdir_int (x0, Option.map (fun x -> x) x1)\n | Ast_413.Parsetree.Pdir_ident x0 ->\n Ast_412.Parsetree.Pdir_ident (copy_Longident_t x0)\n | Ast_413.Parsetree.Pdir_bool x0 -> Ast_412.Parsetree.Pdir_bool x0\n\nand copy_expression :\n Ast_413.Parsetree.expression -> Ast_412.Parsetree.expression =\n fun {\n Ast_413.Parsetree.pexp_desc;\n Ast_413.Parsetree.pexp_loc;\n Ast_413.Parsetree.pexp_loc_stack;\n Ast_413.Parsetree.pexp_attributes;\n } ->\n {\n Ast_412.Parsetree.pexp_desc = copy_expression_desc pexp_desc;\n Ast_412.Parsetree.pexp_loc = copy_location pexp_loc;\n Ast_412.Parsetree.pexp_loc_stack = copy_location_stack pexp_loc_stack;\n Ast_412.Parsetree.pexp_attributes = copy_attributes pexp_attributes;\n }\n\nand copy_expression_desc :\n Ast_413.Parsetree.expression_desc -> Ast_412.Parsetree.expression_desc =\n function\n | Ast_413.Parsetree.Pexp_ident x0 ->\n Ast_412.Parsetree.Pexp_ident (copy_loc copy_Longident_t x0)\n | Ast_413.Parsetree.Pexp_constant x0 ->\n Ast_412.Parsetree.Pexp_constant (copy_constant x0)\n | Ast_413.Parsetree.Pexp_let (x0, x1, x2) ->\n Ast_412.Parsetree.Pexp_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_expression x2)\n | Ast_413.Parsetree.Pexp_function x0 ->\n Ast_412.Parsetree.Pexp_function (List.map copy_case x0)\n | Ast_413.Parsetree.Pexp_fun (x0, x1, x2, x3) ->\n Ast_412.Parsetree.Pexp_fun\n ( copy_arg_label x0,\n Option.map copy_expression x1,\n copy_pattern x2,\n copy_expression x3 )\n | Ast_413.Parsetree.Pexp_apply (x0, x1) ->\n Ast_412.Parsetree.Pexp_apply\n ( copy_expression x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | Ast_413.Parsetree.Pexp_match (x0, x1) ->\n Ast_412.Parsetree.Pexp_match (copy_expression x0, List.map copy_case x1)\n | Ast_413.Parsetree.Pexp_try (x0, x1) ->\n Ast_412.Parsetree.Pexp_try (copy_expression x0, List.map copy_case x1)\n | Ast_413.Parsetree.Pexp_tuple x0 ->\n Ast_412.Parsetree.Pexp_tuple (List.map copy_expression x0)\n | Ast_413.Parsetree.Pexp_construct (x0, x1) ->\n Ast_412.Parsetree.Pexp_construct\n (copy_loc copy_Longident_t x0, Option.map copy_expression x1)\n | Ast_413.Parsetree.Pexp_variant (x0, x1) ->\n Ast_412.Parsetree.Pexp_variant\n (copy_label x0, Option.map copy_expression x1)\n | Ast_413.Parsetree.Pexp_record (x0, x1) ->\n Ast_412.Parsetree.Pexp_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_expression x1))\n x0,\n Option.map copy_expression x1 )\n | Ast_413.Parsetree.Pexp_field (x0, x1) ->\n Ast_412.Parsetree.Pexp_field\n (copy_expression x0, copy_loc copy_Longident_t x1)\n | Ast_413.Parsetree.Pexp_setfield (x0, x1, x2) ->\n Ast_412.Parsetree.Pexp_setfield\n (copy_expression x0, copy_loc copy_Longident_t x1, copy_expression x2)\n | Ast_413.Parsetree.Pexp_array x0 ->\n Ast_412.Parsetree.Pexp_array (List.map copy_expression x0)\n | Ast_413.Parsetree.Pexp_ifthenelse (x0, x1, x2) ->\n Ast_412.Parsetree.Pexp_ifthenelse\n (copy_expression x0, copy_expression x1, Option.map copy_expression x2)\n | Ast_413.Parsetree.Pexp_sequence (x0, x1) ->\n Ast_412.Parsetree.Pexp_sequence (copy_expression x0, copy_expression x1)\n | Ast_413.Parsetree.Pexp_while (x0, x1) ->\n Ast_412.Parsetree.Pexp_while (copy_expression x0, copy_expression x1)\n | Ast_413.Parsetree.Pexp_for (x0, x1, x2, x3, x4) ->\n Ast_412.Parsetree.Pexp_for\n ( copy_pattern x0,\n copy_expression x1,\n copy_expression x2,\n copy_direction_flag x3,\n copy_expression x4 )\n | Ast_413.Parsetree.Pexp_constraint (x0, x1) ->\n Ast_412.Parsetree.Pexp_constraint (copy_expression x0, copy_core_type x1)\n | Ast_413.Parsetree.Pexp_coerce (x0, x1, x2) ->\n Ast_412.Parsetree.Pexp_coerce\n (copy_expression x0, Option.map copy_core_type x1, copy_core_type x2)\n | Ast_413.Parsetree.Pexp_send (x0, x1) ->\n Ast_412.Parsetree.Pexp_send (copy_expression x0, copy_loc copy_label x1)\n | Ast_413.Parsetree.Pexp_new x0 ->\n Ast_412.Parsetree.Pexp_new (copy_loc copy_Longident_t x0)\n | Ast_413.Parsetree.Pexp_setinstvar (x0, x1) ->\n Ast_412.Parsetree.Pexp_setinstvar\n (copy_loc copy_label x0, copy_expression x1)\n | Ast_413.Parsetree.Pexp_override x0 ->\n Ast_412.Parsetree.Pexp_override\n (List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_label x0, copy_expression x1))\n x0)\n | Ast_413.Parsetree.Pexp_letmodule (x0, x1, x2) ->\n Ast_412.Parsetree.Pexp_letmodule\n ( copy_loc (fun x -> Option.map (fun x -> x) x) x0,\n copy_module_expr x1,\n copy_expression x2 )\n | Ast_413.Parsetree.Pexp_letexception (x0, x1) ->\n Ast_412.Parsetree.Pexp_letexception\n (copy_extension_constructor x0, copy_expression x1)\n | Ast_413.Parsetree.Pexp_assert x0 ->\n Ast_412.Parsetree.Pexp_assert (copy_expression x0)\n | Ast_413.Parsetree.Pexp_lazy x0 ->\n Ast_412.Parsetree.Pexp_lazy (copy_expression x0)\n | Ast_413.Parsetree.Pexp_poly (x0, x1) ->\n Ast_412.Parsetree.Pexp_poly\n (copy_expression x0, Option.map copy_core_type x1)\n | Ast_413.Parsetree.Pexp_object x0 ->\n Ast_412.Parsetree.Pexp_object (copy_class_structure x0)\n | Ast_413.Parsetree.Pexp_newtype (x0, x1) ->\n Ast_412.Parsetree.Pexp_newtype\n (copy_loc (fun x -> x) x0, copy_expression x1)\n | Ast_413.Parsetree.Pexp_pack x0 ->\n Ast_412.Parsetree.Pexp_pack (copy_module_expr x0)\n | Ast_413.Parsetree.Pexp_open (x0, x1) ->\n Ast_412.Parsetree.Pexp_open (copy_open_declaration x0, copy_expression x1)\n | Ast_413.Parsetree.Pexp_letop x0 ->\n Ast_412.Parsetree.Pexp_letop (copy_letop x0)\n | Ast_413.Parsetree.Pexp_extension x0 ->\n Ast_412.Parsetree.Pexp_extension (copy_extension x0)\n | Ast_413.Parsetree.Pexp_unreachable -> Ast_412.Parsetree.Pexp_unreachable\n\nand copy_letop : Ast_413.Parsetree.letop -> Ast_412.Parsetree.letop =\n fun { Ast_413.Parsetree.let_; Ast_413.Parsetree.ands; Ast_413.Parsetree.body } ->\n {\n Ast_412.Parsetree.let_ = copy_binding_op let_;\n Ast_412.Parsetree.ands = List.map copy_binding_op ands;\n Ast_412.Parsetree.body = copy_expression body;\n }\n\nand copy_binding_op :\n Ast_413.Parsetree.binding_op -> Ast_412.Parsetree.binding_op =\n fun {\n Ast_413.Parsetree.pbop_op;\n Ast_413.Parsetree.pbop_pat;\n Ast_413.Parsetree.pbop_exp;\n Ast_413.Parsetree.pbop_loc;\n } ->\n {\n Ast_412.Parsetree.pbop_op = copy_loc (fun x -> x) pbop_op;\n Ast_412.Parsetree.pbop_pat = copy_pattern pbop_pat;\n Ast_412.Parsetree.pbop_exp = copy_expression pbop_exp;\n Ast_412.Parsetree.pbop_loc = copy_location pbop_loc;\n }\n\nand copy_direction_flag :\n Ast_413.Asttypes.direction_flag -> Ast_412.Asttypes.direction_flag =\n function\n | Ast_413.Asttypes.Upto -> Ast_412.Asttypes.Upto\n | Ast_413.Asttypes.Downto -> Ast_412.Asttypes.Downto\n\nand copy_case : Ast_413.Parsetree.case -> Ast_412.Parsetree.case =\n fun {\n Ast_413.Parsetree.pc_lhs;\n Ast_413.Parsetree.pc_guard;\n Ast_413.Parsetree.pc_rhs;\n } ->\n {\n Ast_412.Parsetree.pc_lhs = copy_pattern pc_lhs;\n Ast_412.Parsetree.pc_guard = Option.map copy_expression pc_guard;\n Ast_412.Parsetree.pc_rhs = copy_expression pc_rhs;\n }\n\nand copy_value_binding :\n Ast_413.Parsetree.value_binding -> Ast_412.Parsetree.value_binding =\n fun {\n Ast_413.Parsetree.pvb_pat;\n Ast_413.Parsetree.pvb_expr;\n Ast_413.Parsetree.pvb_attributes;\n Ast_413.Parsetree.pvb_loc;\n } ->\n {\n Ast_412.Parsetree.pvb_pat = copy_pattern pvb_pat;\n Ast_412.Parsetree.pvb_expr = copy_expression pvb_expr;\n Ast_412.Parsetree.pvb_attributes = copy_attributes pvb_attributes;\n Ast_412.Parsetree.pvb_loc = copy_location pvb_loc;\n }\n\nand copy_pattern : Ast_413.Parsetree.pattern -> Ast_412.Parsetree.pattern =\n fun {\n Ast_413.Parsetree.ppat_desc;\n Ast_413.Parsetree.ppat_loc;\n Ast_413.Parsetree.ppat_loc_stack;\n Ast_413.Parsetree.ppat_attributes;\n } ->\n {\n Ast_412.Parsetree.ppat_desc = copy_pattern_desc ppat_desc;\n Ast_412.Parsetree.ppat_loc = copy_location ppat_loc;\n Ast_412.Parsetree.ppat_loc_stack = copy_location_stack ppat_loc_stack;\n Ast_412.Parsetree.ppat_attributes = copy_attributes ppat_attributes;\n }\n\nand copy_pattern_desc :\n Ast_413.Parsetree.pattern_desc -> Ast_412.Parsetree.pattern_desc = function\n | Ast_413.Parsetree.Ppat_any -> Ast_412.Parsetree.Ppat_any\n | Ast_413.Parsetree.Ppat_var x0 ->\n Ast_412.Parsetree.Ppat_var (copy_loc (fun x -> x) x0)\n | Ast_413.Parsetree.Ppat_alias (x0, x1) ->\n Ast_412.Parsetree.Ppat_alias (copy_pattern x0, copy_loc (fun x -> x) x1)\n | Ast_413.Parsetree.Ppat_constant x0 ->\n Ast_412.Parsetree.Ppat_constant (copy_constant x0)\n | Ast_413.Parsetree.Ppat_interval (x0, x1) ->\n Ast_412.Parsetree.Ppat_interval (copy_constant x0, copy_constant x1)\n | Ast_413.Parsetree.Ppat_tuple x0 ->\n Ast_412.Parsetree.Ppat_tuple (List.map copy_pattern x0)\n | Ast_413.Parsetree.Ppat_construct (x0, x1) ->\n Ast_412.Parsetree.Ppat_construct\n ( copy_loc copy_Longident_t x0,\n Option.map\n (fun x ->\n let x0, x1 = x in\n (match x0 with\n | [] -> ()\n | ty :: _ ->\n migration_error ty.Ast_413.Asttypes.loc\n \"existentials in pattern-matching\");\n copy_pattern x1)\n x1 )\n | Ast_413.Parsetree.Ppat_variant (x0, x1) ->\n Ast_412.Parsetree.Ppat_variant (copy_label x0, Option.map copy_pattern x1)\n | Ast_413.Parsetree.Ppat_record (x0, x1) ->\n Ast_412.Parsetree.Ppat_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_pattern x1))\n x0,\n copy_closed_flag x1 )\n | Ast_413.Parsetree.Ppat_array x0 ->\n Ast_412.Parsetree.Ppat_array (List.map copy_pattern x0)\n | Ast_413.Parsetree.Ppat_or (x0, x1) ->\n Ast_412.Parsetree.Ppat_or (copy_pattern x0, copy_pattern x1)\n | Ast_413.Parsetree.Ppat_constraint (x0, x1) ->\n Ast_412.Parsetree.Ppat_constraint (copy_pattern x0, copy_core_type x1)\n | Ast_413.Parsetree.Ppat_type x0 ->\n Ast_412.Parsetree.Ppat_type (copy_loc copy_Longident_t x0)\n | Ast_413.Parsetree.Ppat_lazy x0 ->\n Ast_412.Parsetree.Ppat_lazy (copy_pattern x0)\n | Ast_413.Parsetree.Ppat_unpack x0 ->\n Ast_412.Parsetree.Ppat_unpack\n (copy_loc (fun x -> Option.map (fun x -> x) x) x0)\n | Ast_413.Parsetree.Ppat_exception x0 ->\n Ast_412.Parsetree.Ppat_exception (copy_pattern x0)\n | Ast_413.Parsetree.Ppat_extension x0 ->\n Ast_412.Parsetree.Ppat_extension (copy_extension x0)\n | Ast_413.Parsetree.Ppat_open (x0, x1) ->\n Ast_412.Parsetree.Ppat_open (copy_loc copy_Longident_t x0, copy_pattern x1)\n\nand copy_core_type : Ast_413.Parsetree.core_type -> Ast_412.Parsetree.core_type\n =\n fun {\n Ast_413.Parsetree.ptyp_desc;\n Ast_413.Parsetree.ptyp_loc;\n Ast_413.Parsetree.ptyp_loc_stack;\n Ast_413.Parsetree.ptyp_attributes;\n } ->\n {\n Ast_412.Parsetree.ptyp_desc = copy_core_type_desc ptyp_desc;\n Ast_412.Parsetree.ptyp_loc = copy_location ptyp_loc;\n Ast_412.Parsetree.ptyp_loc_stack = copy_location_stack ptyp_loc_stack;\n Ast_412.Parsetree.ptyp_attributes = copy_attributes ptyp_attributes;\n }\n\nand copy_location_stack :\n Ast_413.Parsetree.location_stack -> Ast_412.Parsetree.location_stack =\n fun x -> List.map copy_location x\n\nand copy_core_type_desc :\n Ast_413.Parsetree.core_type_desc -> Ast_412.Parsetree.core_type_desc =\n function\n | Ast_413.Parsetree.Ptyp_any -> Ast_412.Parsetree.Ptyp_any\n | Ast_413.Parsetree.Ptyp_var x0 -> Ast_412.Parsetree.Ptyp_var x0\n | Ast_413.Parsetree.Ptyp_arrow (x0, x1, x2) ->\n Ast_412.Parsetree.Ptyp_arrow\n (copy_arg_label x0, copy_core_type x1, copy_core_type x2)\n | Ast_413.Parsetree.Ptyp_tuple x0 ->\n Ast_412.Parsetree.Ptyp_tuple (List.map copy_core_type x0)\n | Ast_413.Parsetree.Ptyp_constr (x0, x1) ->\n Ast_412.Parsetree.Ptyp_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_413.Parsetree.Ptyp_object (x0, x1) ->\n Ast_412.Parsetree.Ptyp_object\n (List.map copy_object_field x0, copy_closed_flag x1)\n | Ast_413.Parsetree.Ptyp_class (x0, x1) ->\n Ast_412.Parsetree.Ptyp_class\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_413.Parsetree.Ptyp_alias (x0, x1) ->\n Ast_412.Parsetree.Ptyp_alias (copy_core_type x0, x1)\n | Ast_413.Parsetree.Ptyp_variant (x0, x1, x2) ->\n Ast_412.Parsetree.Ptyp_variant\n ( List.map copy_row_field x0,\n copy_closed_flag x1,\n Option.map (fun x -> List.map copy_label x) x2 )\n | Ast_413.Parsetree.Ptyp_poly (x0, x1) ->\n Ast_412.Parsetree.Ptyp_poly\n (List.map (fun x -> copy_loc (fun x -> x) x) x0, copy_core_type x1)\n | Ast_413.Parsetree.Ptyp_package x0 ->\n Ast_412.Parsetree.Ptyp_package (copy_package_type x0)\n | Ast_413.Parsetree.Ptyp_extension x0 ->\n Ast_412.Parsetree.Ptyp_extension (copy_extension x0)\n\nand copy_package_type :\n Ast_413.Parsetree.package_type -> Ast_412.Parsetree.package_type =\n fun x ->\n let x0, x1 = x in\n ( copy_loc copy_Longident_t x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_core_type x1))\n x1 )\n\nand copy_row_field : Ast_413.Parsetree.row_field -> Ast_412.Parsetree.row_field\n =\n fun {\n Ast_413.Parsetree.prf_desc;\n Ast_413.Parsetree.prf_loc;\n Ast_413.Parsetree.prf_attributes;\n } ->\n {\n Ast_412.Parsetree.prf_desc = copy_row_field_desc prf_desc;\n Ast_412.Parsetree.prf_loc = copy_location prf_loc;\n Ast_412.Parsetree.prf_attributes = copy_attributes prf_attributes;\n }\n\nand copy_row_field_desc :\n Ast_413.Parsetree.row_field_desc -> Ast_412.Parsetree.row_field_desc =\n function\n | Ast_413.Parsetree.Rtag (x0, x1, x2) ->\n Ast_412.Parsetree.Rtag\n (copy_loc copy_label x0, x1, List.map copy_core_type x2)\n | Ast_413.Parsetree.Rinherit x0 ->\n Ast_412.Parsetree.Rinherit (copy_core_type x0)\n\nand copy_object_field :\n Ast_413.Parsetree.object_field -> Ast_412.Parsetree.object_field =\n fun {\n Ast_413.Parsetree.pof_desc;\n Ast_413.Parsetree.pof_loc;\n Ast_413.Parsetree.pof_attributes;\n } ->\n {\n Ast_412.Parsetree.pof_desc = copy_object_field_desc pof_desc;\n Ast_412.Parsetree.pof_loc = copy_location pof_loc;\n Ast_412.Parsetree.pof_attributes = copy_attributes pof_attributes;\n }\n\nand copy_attributes :\n Ast_413.Parsetree.attributes -> Ast_412.Parsetree.attributes =\n fun x -> List.map copy_attribute x\n\nand copy_attribute : Ast_413.Parsetree.attribute -> Ast_412.Parsetree.attribute\n =\n fun {\n Ast_413.Parsetree.attr_name;\n Ast_413.Parsetree.attr_payload;\n Ast_413.Parsetree.attr_loc;\n } ->\n {\n Ast_412.Parsetree.attr_name = copy_loc (fun x -> x) attr_name;\n Ast_412.Parsetree.attr_payload = copy_payload attr_payload;\n Ast_412.Parsetree.attr_loc = copy_location attr_loc;\n }\n\nand copy_payload : Ast_413.Parsetree.payload -> Ast_412.Parsetree.payload =\n function\n | Ast_413.Parsetree.PStr x0 -> Ast_412.Parsetree.PStr (copy_structure x0)\n | Ast_413.Parsetree.PSig x0 -> Ast_412.Parsetree.PSig (copy_signature x0)\n | Ast_413.Parsetree.PTyp x0 -> Ast_412.Parsetree.PTyp (copy_core_type x0)\n | Ast_413.Parsetree.PPat (x0, x1) ->\n Ast_412.Parsetree.PPat (copy_pattern x0, Option.map copy_expression x1)\n\nand copy_structure : Ast_413.Parsetree.structure -> Ast_412.Parsetree.structure\n =\n fun x -> List.map copy_structure_item x\n\nand copy_structure_item :\n Ast_413.Parsetree.structure_item -> Ast_412.Parsetree.structure_item =\n fun { Ast_413.Parsetree.pstr_desc; Ast_413.Parsetree.pstr_loc } ->\n {\n Ast_412.Parsetree.pstr_desc = copy_structure_item_desc pstr_desc;\n Ast_412.Parsetree.pstr_loc = copy_location pstr_loc;\n }\n\nand copy_structure_item_desc :\n Ast_413.Parsetree.structure_item_desc ->\n Ast_412.Parsetree.structure_item_desc = function\n | Ast_413.Parsetree.Pstr_eval (x0, x1) ->\n Ast_412.Parsetree.Pstr_eval (copy_expression x0, copy_attributes x1)\n | Ast_413.Parsetree.Pstr_value (x0, x1) ->\n Ast_412.Parsetree.Pstr_value\n (copy_rec_flag x0, List.map copy_value_binding x1)\n | Ast_413.Parsetree.Pstr_primitive x0 ->\n Ast_412.Parsetree.Pstr_primitive (copy_value_description x0)\n | Ast_413.Parsetree.Pstr_type (x0, x1) ->\n Ast_412.Parsetree.Pstr_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | Ast_413.Parsetree.Pstr_typext x0 ->\n Ast_412.Parsetree.Pstr_typext (copy_type_extension x0)\n | Ast_413.Parsetree.Pstr_exception x0 ->\n Ast_412.Parsetree.Pstr_exception (copy_type_exception x0)\n | Ast_413.Parsetree.Pstr_module x0 ->\n Ast_412.Parsetree.Pstr_module (copy_module_binding x0)\n | Ast_413.Parsetree.Pstr_recmodule x0 ->\n Ast_412.Parsetree.Pstr_recmodule (List.map copy_module_binding x0)\n | Ast_413.Parsetree.Pstr_modtype x0 ->\n Ast_412.Parsetree.Pstr_modtype (copy_module_type_declaration x0)\n | Ast_413.Parsetree.Pstr_open x0 ->\n Ast_412.Parsetree.Pstr_open (copy_open_declaration x0)\n | Ast_413.Parsetree.Pstr_class x0 ->\n Ast_412.Parsetree.Pstr_class (List.map copy_class_declaration x0)\n | Ast_413.Parsetree.Pstr_class_type x0 ->\n Ast_412.Parsetree.Pstr_class_type\n (List.map copy_class_type_declaration x0)\n | Ast_413.Parsetree.Pstr_include x0 ->\n Ast_412.Parsetree.Pstr_include (copy_include_declaration x0)\n | Ast_413.Parsetree.Pstr_attribute x0 ->\n Ast_412.Parsetree.Pstr_attribute (copy_attribute x0)\n | Ast_413.Parsetree.Pstr_extension (x0, x1) ->\n Ast_412.Parsetree.Pstr_extension (copy_extension x0, copy_attributes x1)\n\nand copy_include_declaration :\n Ast_413.Parsetree.include_declaration ->\n Ast_412.Parsetree.include_declaration =\n fun x -> copy_include_infos copy_module_expr x\n\nand copy_class_declaration :\n Ast_413.Parsetree.class_declaration -> Ast_412.Parsetree.class_declaration =\n fun x -> copy_class_infos copy_class_expr x\n\nand copy_class_expr :\n Ast_413.Parsetree.class_expr -> Ast_412.Parsetree.class_expr =\n fun {\n Ast_413.Parsetree.pcl_desc;\n Ast_413.Parsetree.pcl_loc;\n Ast_413.Parsetree.pcl_attributes;\n } ->\n {\n Ast_412.Parsetree.pcl_desc = copy_class_expr_desc pcl_desc;\n Ast_412.Parsetree.pcl_loc = copy_location pcl_loc;\n Ast_412.Parsetree.pcl_attributes = copy_attributes pcl_attributes;\n }\n\nand copy_class_expr_desc :\n Ast_413.Parsetree.class_expr_desc -> Ast_412.Parsetree.class_expr_desc =\n function\n | Ast_413.Parsetree.Pcl_constr (x0, x1) ->\n Ast_412.Parsetree.Pcl_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_413.Parsetree.Pcl_structure x0 ->\n Ast_412.Parsetree.Pcl_structure (copy_class_structure x0)\n | Ast_413.Parsetree.Pcl_fun (x0, x1, x2, x3) ->\n Ast_412.Parsetree.Pcl_fun\n ( copy_arg_label x0,\n Option.map copy_expression x1,\n copy_pattern x2,\n copy_class_expr x3 )\n | Ast_413.Parsetree.Pcl_apply (x0, x1) ->\n Ast_412.Parsetree.Pcl_apply\n ( copy_class_expr x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | Ast_413.Parsetree.Pcl_let (x0, x1, x2) ->\n Ast_412.Parsetree.Pcl_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_class_expr x2)\n | Ast_413.Parsetree.Pcl_constraint (x0, x1) ->\n Ast_412.Parsetree.Pcl_constraint (copy_class_expr x0, copy_class_type x1)\n | Ast_413.Parsetree.Pcl_extension x0 ->\n Ast_412.Parsetree.Pcl_extension (copy_extension x0)\n | Ast_413.Parsetree.Pcl_open (x0, x1) ->\n Ast_412.Parsetree.Pcl_open (copy_open_description x0, copy_class_expr x1)\n\nand copy_class_structure :\n Ast_413.Parsetree.class_structure -> Ast_412.Parsetree.class_structure =\n fun { Ast_413.Parsetree.pcstr_self; Ast_413.Parsetree.pcstr_fields } ->\n {\n Ast_412.Parsetree.pcstr_self = copy_pattern pcstr_self;\n Ast_412.Parsetree.pcstr_fields = List.map copy_class_field pcstr_fields;\n }\n\nand copy_class_field :\n Ast_413.Parsetree.class_field -> Ast_412.Parsetree.class_field =\n fun {\n Ast_413.Parsetree.pcf_desc;\n Ast_413.Parsetree.pcf_loc;\n Ast_413.Parsetree.pcf_attributes;\n } ->\n {\n Ast_412.Parsetree.pcf_desc = copy_class_field_desc pcf_desc;\n Ast_412.Parsetree.pcf_loc = copy_location pcf_loc;\n Ast_412.Parsetree.pcf_attributes = copy_attributes pcf_attributes;\n }\n\nand copy_class_field_desc :\n Ast_413.Parsetree.class_field_desc -> Ast_412.Parsetree.class_field_desc =\n function\n | Ast_413.Parsetree.Pcf_inherit (x0, x1, x2) ->\n Ast_412.Parsetree.Pcf_inherit\n ( copy_override_flag x0,\n copy_class_expr x1,\n Option.map (fun x -> copy_loc (fun x -> x) x) x2 )\n | Ast_413.Parsetree.Pcf_val x0 ->\n Ast_412.Parsetree.Pcf_val\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_mutable_flag x1, copy_class_field_kind x2))\n | Ast_413.Parsetree.Pcf_method x0 ->\n Ast_412.Parsetree.Pcf_method\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_private_flag x1, copy_class_field_kind x2))\n | Ast_413.Parsetree.Pcf_constraint x0 ->\n Ast_412.Parsetree.Pcf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | Ast_413.Parsetree.Pcf_initializer x0 ->\n Ast_412.Parsetree.Pcf_initializer (copy_expression x0)\n | Ast_413.Parsetree.Pcf_attribute x0 ->\n Ast_412.Parsetree.Pcf_attribute (copy_attribute x0)\n | Ast_413.Parsetree.Pcf_extension x0 ->\n Ast_412.Parsetree.Pcf_extension (copy_extension x0)\n\nand copy_class_field_kind :\n Ast_413.Parsetree.class_field_kind -> Ast_412.Parsetree.class_field_kind =\n function\n | Ast_413.Parsetree.Cfk_virtual x0 ->\n Ast_412.Parsetree.Cfk_virtual (copy_core_type x0)\n | Ast_413.Parsetree.Cfk_concrete (x0, x1) ->\n Ast_412.Parsetree.Cfk_concrete (copy_override_flag x0, copy_expression x1)\n\nand copy_open_declaration :\n Ast_413.Parsetree.open_declaration -> Ast_412.Parsetree.open_declaration =\n fun x -> copy_open_infos copy_module_expr x\n\nand copy_module_binding :\n Ast_413.Parsetree.module_binding -> Ast_412.Parsetree.module_binding =\n fun {\n Ast_413.Parsetree.pmb_name;\n Ast_413.Parsetree.pmb_expr;\n Ast_413.Parsetree.pmb_attributes;\n Ast_413.Parsetree.pmb_loc;\n } ->\n {\n Ast_412.Parsetree.pmb_name =\n copy_loc (fun x -> Option.map (fun x -> x) x) pmb_name;\n Ast_412.Parsetree.pmb_expr = copy_module_expr pmb_expr;\n Ast_412.Parsetree.pmb_attributes = copy_attributes pmb_attributes;\n Ast_412.Parsetree.pmb_loc = copy_location pmb_loc;\n }\n\nand copy_module_expr :\n Ast_413.Parsetree.module_expr -> Ast_412.Parsetree.module_expr =\n fun {\n Ast_413.Parsetree.pmod_desc;\n Ast_413.Parsetree.pmod_loc;\n Ast_413.Parsetree.pmod_attributes;\n } ->\n {\n Ast_412.Parsetree.pmod_desc = copy_module_expr_desc pmod_desc;\n Ast_412.Parsetree.pmod_loc = copy_location pmod_loc;\n Ast_412.Parsetree.pmod_attributes = copy_attributes pmod_attributes;\n }\n\nand copy_module_expr_desc :\n Ast_413.Parsetree.module_expr_desc -> Ast_412.Parsetree.module_expr_desc =\n function\n | Ast_413.Parsetree.Pmod_ident x0 ->\n Ast_412.Parsetree.Pmod_ident (copy_loc copy_Longident_t x0)\n | Ast_413.Parsetree.Pmod_structure x0 ->\n Ast_412.Parsetree.Pmod_structure (copy_structure x0)\n | Ast_413.Parsetree.Pmod_functor (x0, x1) ->\n Ast_412.Parsetree.Pmod_functor\n (copy_functor_parameter x0, copy_module_expr x1)\n | Ast_413.Parsetree.Pmod_apply (x0, x1) ->\n Ast_412.Parsetree.Pmod_apply (copy_module_expr x0, copy_module_expr x1)\n | Ast_413.Parsetree.Pmod_constraint (x0, x1) ->\n Ast_412.Parsetree.Pmod_constraint\n (copy_module_expr x0, copy_module_type x1)\n | Ast_413.Parsetree.Pmod_unpack x0 ->\n Ast_412.Parsetree.Pmod_unpack (copy_expression x0)\n | Ast_413.Parsetree.Pmod_extension x0 ->\n Ast_412.Parsetree.Pmod_extension (copy_extension x0)\n\nand copy_functor_parameter :\n Ast_413.Parsetree.functor_parameter -> Ast_412.Parsetree.functor_parameter =\n function\n | Ast_413.Parsetree.Unit -> Ast_412.Parsetree.Unit\n | Ast_413.Parsetree.Named (x0, x1) ->\n Ast_412.Parsetree.Named\n (copy_loc (fun x -> Option.map (fun x -> x) x) x0, copy_module_type x1)\n\nand copy_module_type :\n Ast_413.Parsetree.module_type -> Ast_412.Parsetree.module_type =\n fun {\n Ast_413.Parsetree.pmty_desc;\n Ast_413.Parsetree.pmty_loc;\n Ast_413.Parsetree.pmty_attributes;\n } ->\n {\n Ast_412.Parsetree.pmty_desc = copy_module_type_desc pmty_desc;\n Ast_412.Parsetree.pmty_loc = copy_location pmty_loc;\n Ast_412.Parsetree.pmty_attributes = copy_attributes pmty_attributes;\n }\n\nand copy_module_type_desc :\n Ast_413.Parsetree.module_type_desc -> Ast_412.Parsetree.module_type_desc =\n function\n | Ast_413.Parsetree.Pmty_ident x0 ->\n Ast_412.Parsetree.Pmty_ident (copy_loc copy_Longident_t x0)\n | Ast_413.Parsetree.Pmty_signature x0 ->\n Ast_412.Parsetree.Pmty_signature (copy_signature x0)\n | Ast_413.Parsetree.Pmty_functor (x0, x1) ->\n Ast_412.Parsetree.Pmty_functor\n (copy_functor_parameter x0, copy_module_type x1)\n | Ast_413.Parsetree.Pmty_with (x0, x1) ->\n Ast_412.Parsetree.Pmty_with\n (copy_module_type x0, List.map copy_with_constraint x1)\n | Ast_413.Parsetree.Pmty_typeof x0 ->\n Ast_412.Parsetree.Pmty_typeof (copy_module_expr x0)\n | Ast_413.Parsetree.Pmty_extension x0 ->\n Ast_412.Parsetree.Pmty_extension (copy_extension x0)\n | Ast_413.Parsetree.Pmty_alias x0 ->\n Ast_412.Parsetree.Pmty_alias (copy_loc copy_Longident_t x0)\n\nand copy_with_constraint :\n Ast_413.Parsetree.with_constraint -> Ast_412.Parsetree.with_constraint =\n function\n | Ast_413.Parsetree.Pwith_type (x0, x1) ->\n Ast_412.Parsetree.Pwith_type\n (copy_loc copy_Longident_t x0, copy_type_declaration x1)\n | Ast_413.Parsetree.Pwith_module (x0, x1) ->\n Ast_412.Parsetree.Pwith_module\n (copy_loc copy_Longident_t x0, copy_loc copy_Longident_t x1)\n | Ast_413.Parsetree.Pwith_modtype (_x0, x1) ->\n migration_error x1.Ast_413.Parsetree.pmty_loc \"module type substitution\"\n | Ast_413.Parsetree.Pwith_modtypesubst (_x0, x1) ->\n migration_error x1.Ast_413.Parsetree.pmty_loc\n \"destructive module type substitution\"\n | Ast_413.Parsetree.Pwith_typesubst (x0, x1) ->\n Ast_412.Parsetree.Pwith_typesubst\n (copy_loc copy_Longident_t x0, copy_type_declaration x1)\n | Ast_413.Parsetree.Pwith_modsubst (x0, x1) ->\n Ast_412.Parsetree.Pwith_modsubst\n (copy_loc copy_Longident_t x0, copy_loc copy_Longident_t x1)\n\nand copy_signature : Ast_413.Parsetree.signature -> Ast_412.Parsetree.signature\n =\n fun x -> List.map copy_signature_item x\n\nand copy_signature_item :\n Ast_413.Parsetree.signature_item -> Ast_412.Parsetree.signature_item =\n fun { Ast_413.Parsetree.psig_desc; Ast_413.Parsetree.psig_loc } ->\n {\n Ast_412.Parsetree.psig_desc = copy_signature_item_desc psig_desc;\n Ast_412.Parsetree.psig_loc = copy_location psig_loc;\n }\n\nand copy_signature_item_desc :\n Ast_413.Parsetree.signature_item_desc ->\n Ast_412.Parsetree.signature_item_desc = function\n | Ast_413.Parsetree.Psig_value x0 ->\n Ast_412.Parsetree.Psig_value (copy_value_description x0)\n | Ast_413.Parsetree.Psig_type (x0, x1) ->\n Ast_412.Parsetree.Psig_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | Ast_413.Parsetree.Psig_typesubst x0 ->\n Ast_412.Parsetree.Psig_typesubst (List.map copy_type_declaration x0)\n | Ast_413.Parsetree.Psig_typext x0 ->\n Ast_412.Parsetree.Psig_typext (copy_type_extension x0)\n | Ast_413.Parsetree.Psig_exception x0 ->\n Ast_412.Parsetree.Psig_exception (copy_type_exception x0)\n | Ast_413.Parsetree.Psig_module x0 ->\n Ast_412.Parsetree.Psig_module (copy_module_declaration x0)\n | Ast_413.Parsetree.Psig_modsubst x0 ->\n Ast_412.Parsetree.Psig_modsubst (copy_module_substitution x0)\n | Ast_413.Parsetree.Psig_recmodule x0 ->\n Ast_412.Parsetree.Psig_recmodule (List.map copy_module_declaration x0)\n | Ast_413.Parsetree.Psig_modtype x0 ->\n Ast_412.Parsetree.Psig_modtype (copy_module_type_declaration x0)\n | Ast_413.Parsetree.Psig_modtypesubst x0 ->\n migration_error x0.Ast_413.Parsetree.pmtd_loc\n \"local module type substitution\"\n | Ast_413.Parsetree.Psig_open x0 ->\n Ast_412.Parsetree.Psig_open (copy_open_description x0)\n | Ast_413.Parsetree.Psig_include x0 ->\n Ast_412.Parsetree.Psig_include (copy_include_description x0)\n | Ast_413.Parsetree.Psig_class x0 ->\n Ast_412.Parsetree.Psig_class (List.map copy_class_description x0)\n | Ast_413.Parsetree.Psig_class_type x0 ->\n Ast_412.Parsetree.Psig_class_type\n (List.map copy_class_type_declaration x0)\n | Ast_413.Parsetree.Psig_attribute x0 ->\n Ast_412.Parsetree.Psig_attribute (copy_attribute x0)\n | Ast_413.Parsetree.Psig_extension (x0, x1) ->\n Ast_412.Parsetree.Psig_extension (copy_extension x0, copy_attributes x1)\n\nand copy_class_type_declaration :\n Ast_413.Parsetree.class_type_declaration ->\n Ast_412.Parsetree.class_type_declaration =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_description :\n Ast_413.Parsetree.class_description -> Ast_412.Parsetree.class_description =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_type :\n Ast_413.Parsetree.class_type -> Ast_412.Parsetree.class_type =\n fun {\n Ast_413.Parsetree.pcty_desc;\n Ast_413.Parsetree.pcty_loc;\n Ast_413.Parsetree.pcty_attributes;\n } ->\n {\n Ast_412.Parsetree.pcty_desc = copy_class_type_desc pcty_desc;\n Ast_412.Parsetree.pcty_loc = copy_location pcty_loc;\n Ast_412.Parsetree.pcty_attributes = copy_attributes pcty_attributes;\n }\n\nand copy_class_type_desc :\n Ast_413.Parsetree.class_type_desc -> Ast_412.Parsetree.class_type_desc =\n function\n | Ast_413.Parsetree.Pcty_constr (x0, x1) ->\n Ast_412.Parsetree.Pcty_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_413.Parsetree.Pcty_signature x0 ->\n Ast_412.Parsetree.Pcty_signature (copy_class_signature x0)\n | Ast_413.Parsetree.Pcty_arrow (x0, x1, x2) ->\n Ast_412.Parsetree.Pcty_arrow\n (copy_arg_label x0, copy_core_type x1, copy_class_type x2)\n | Ast_413.Parsetree.Pcty_extension x0 ->\n Ast_412.Parsetree.Pcty_extension (copy_extension x0)\n | Ast_413.Parsetree.Pcty_open (x0, x1) ->\n Ast_412.Parsetree.Pcty_open (copy_open_description x0, copy_class_type x1)\n\nand copy_class_signature :\n Ast_413.Parsetree.class_signature -> Ast_412.Parsetree.class_signature =\n fun { Ast_413.Parsetree.pcsig_self; Ast_413.Parsetree.pcsig_fields } ->\n {\n Ast_412.Parsetree.pcsig_self = copy_core_type pcsig_self;\n Ast_412.Parsetree.pcsig_fields = List.map copy_class_type_field pcsig_fields;\n }\n\nand copy_class_type_field :\n Ast_413.Parsetree.class_type_field -> Ast_412.Parsetree.class_type_field =\n fun {\n Ast_413.Parsetree.pctf_desc;\n Ast_413.Parsetree.pctf_loc;\n Ast_413.Parsetree.pctf_attributes;\n } ->\n {\n Ast_412.Parsetree.pctf_desc = copy_class_type_field_desc pctf_desc;\n Ast_412.Parsetree.pctf_loc = copy_location pctf_loc;\n Ast_412.Parsetree.pctf_attributes = copy_attributes pctf_attributes;\n }\n\nand copy_class_type_field_desc :\n Ast_413.Parsetree.class_type_field_desc ->\n Ast_412.Parsetree.class_type_field_desc = function\n | Ast_413.Parsetree.Pctf_inherit x0 ->\n Ast_412.Parsetree.Pctf_inherit (copy_class_type x0)\n | Ast_413.Parsetree.Pctf_val x0 ->\n Ast_412.Parsetree.Pctf_val\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_mutable_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | Ast_413.Parsetree.Pctf_method x0 ->\n Ast_412.Parsetree.Pctf_method\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_private_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | Ast_413.Parsetree.Pctf_constraint x0 ->\n Ast_412.Parsetree.Pctf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | Ast_413.Parsetree.Pctf_attribute x0 ->\n Ast_412.Parsetree.Pctf_attribute (copy_attribute x0)\n | Ast_413.Parsetree.Pctf_extension x0 ->\n Ast_412.Parsetree.Pctf_extension (copy_extension x0)\n\nand copy_extension : Ast_413.Parsetree.extension -> Ast_412.Parsetree.extension\n =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_class_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_413.Parsetree.class_infos ->\n 'g0 Ast_412.Parsetree.class_infos =\n fun f0\n {\n Ast_413.Parsetree.pci_virt;\n Ast_413.Parsetree.pci_params;\n Ast_413.Parsetree.pci_name;\n Ast_413.Parsetree.pci_expr;\n Ast_413.Parsetree.pci_loc;\n Ast_413.Parsetree.pci_attributes;\n } ->\n {\n Ast_412.Parsetree.pci_virt = copy_virtual_flag pci_virt;\n Ast_412.Parsetree.pci_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n ( copy_core_type x0,\n let x0, x1 = x1 in\n (copy_variance x0, copy_injectivity x1) ))\n pci_params;\n Ast_412.Parsetree.pci_name = copy_loc (fun x -> x) pci_name;\n Ast_412.Parsetree.pci_expr = f0 pci_expr;\n Ast_412.Parsetree.pci_loc = copy_location pci_loc;\n Ast_412.Parsetree.pci_attributes = copy_attributes pci_attributes;\n }\n\nand copy_virtual_flag :\n Ast_413.Asttypes.virtual_flag -> Ast_412.Asttypes.virtual_flag = function\n | Ast_413.Asttypes.Virtual -> Ast_412.Asttypes.Virtual\n | Ast_413.Asttypes.Concrete -> Ast_412.Asttypes.Concrete\n\nand copy_include_description :\n Ast_413.Parsetree.include_description ->\n Ast_412.Parsetree.include_description =\n fun x -> copy_include_infos copy_module_type x\n\nand copy_include_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_413.Parsetree.include_infos ->\n 'g0 Ast_412.Parsetree.include_infos =\n fun f0\n {\n Ast_413.Parsetree.pincl_mod;\n Ast_413.Parsetree.pincl_loc;\n Ast_413.Parsetree.pincl_attributes;\n } ->\n {\n Ast_412.Parsetree.pincl_mod = f0 pincl_mod;\n Ast_412.Parsetree.pincl_loc = copy_location pincl_loc;\n Ast_412.Parsetree.pincl_attributes = copy_attributes pincl_attributes;\n }\n\nand copy_open_description :\n Ast_413.Parsetree.open_description -> Ast_412.Parsetree.open_description =\n fun x -> copy_open_infos (fun x -> copy_loc copy_Longident_t x) x\n\nand copy_open_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_413.Parsetree.open_infos ->\n 'g0 Ast_412.Parsetree.open_infos =\n fun f0\n {\n Ast_413.Parsetree.popen_expr;\n Ast_413.Parsetree.popen_override;\n Ast_413.Parsetree.popen_loc;\n Ast_413.Parsetree.popen_attributes;\n } ->\n {\n Ast_412.Parsetree.popen_expr = f0 popen_expr;\n Ast_412.Parsetree.popen_override = copy_override_flag popen_override;\n Ast_412.Parsetree.popen_loc = copy_location popen_loc;\n Ast_412.Parsetree.popen_attributes = copy_attributes popen_attributes;\n }\n\nand copy_override_flag :\n Ast_413.Asttypes.override_flag -> Ast_412.Asttypes.override_flag = function\n | Ast_413.Asttypes.Override -> Ast_412.Asttypes.Override\n | Ast_413.Asttypes.Fresh -> Ast_412.Asttypes.Fresh\n\nand copy_module_type_declaration :\n Ast_413.Parsetree.module_type_declaration ->\n Ast_412.Parsetree.module_type_declaration =\n fun {\n Ast_413.Parsetree.pmtd_name;\n Ast_413.Parsetree.pmtd_type;\n Ast_413.Parsetree.pmtd_attributes;\n Ast_413.Parsetree.pmtd_loc;\n } ->\n {\n Ast_412.Parsetree.pmtd_name = copy_loc (fun x -> x) pmtd_name;\n Ast_412.Parsetree.pmtd_type = Option.map copy_module_type pmtd_type;\n Ast_412.Parsetree.pmtd_attributes = copy_attributes pmtd_attributes;\n Ast_412.Parsetree.pmtd_loc = copy_location pmtd_loc;\n }\n\nand copy_module_substitution :\n Ast_413.Parsetree.module_substitution ->\n Ast_412.Parsetree.module_substitution =\n fun {\n Ast_413.Parsetree.pms_name;\n Ast_413.Parsetree.pms_manifest;\n Ast_413.Parsetree.pms_attributes;\n Ast_413.Parsetree.pms_loc;\n } ->\n {\n Ast_412.Parsetree.pms_name = copy_loc (fun x -> x) pms_name;\n Ast_412.Parsetree.pms_manifest = copy_loc copy_Longident_t pms_manifest;\n Ast_412.Parsetree.pms_attributes = copy_attributes pms_attributes;\n Ast_412.Parsetree.pms_loc = copy_location pms_loc;\n }\n\nand copy_module_declaration :\n Ast_413.Parsetree.module_declaration -> Ast_412.Parsetree.module_declaration\n =\n fun {\n Ast_413.Parsetree.pmd_name;\n Ast_413.Parsetree.pmd_type;\n Ast_413.Parsetree.pmd_attributes;\n Ast_413.Parsetree.pmd_loc;\n } ->\n {\n Ast_412.Parsetree.pmd_name =\n copy_loc (fun x -> Option.map (fun x -> x) x) pmd_name;\n Ast_412.Parsetree.pmd_type = copy_module_type pmd_type;\n Ast_412.Parsetree.pmd_attributes = copy_attributes pmd_attributes;\n Ast_412.Parsetree.pmd_loc = copy_location pmd_loc;\n }\n\nand copy_type_exception :\n Ast_413.Parsetree.type_exception -> Ast_412.Parsetree.type_exception =\n fun {\n Ast_413.Parsetree.ptyexn_constructor;\n Ast_413.Parsetree.ptyexn_loc;\n Ast_413.Parsetree.ptyexn_attributes;\n } ->\n {\n Ast_412.Parsetree.ptyexn_constructor =\n copy_extension_constructor ptyexn_constructor;\n Ast_412.Parsetree.ptyexn_loc = copy_location ptyexn_loc;\n Ast_412.Parsetree.ptyexn_attributes = copy_attributes ptyexn_attributes;\n }\n\nand copy_type_extension :\n Ast_413.Parsetree.type_extension -> Ast_412.Parsetree.type_extension =\n fun {\n Ast_413.Parsetree.ptyext_path;\n Ast_413.Parsetree.ptyext_params;\n Ast_413.Parsetree.ptyext_constructors;\n Ast_413.Parsetree.ptyext_private;\n Ast_413.Parsetree.ptyext_loc;\n Ast_413.Parsetree.ptyext_attributes;\n } ->\n {\n Ast_412.Parsetree.ptyext_path = copy_loc copy_Longident_t ptyext_path;\n Ast_412.Parsetree.ptyext_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n ( copy_core_type x0,\n let x0, x1 = x1 in\n (copy_variance x0, copy_injectivity x1) ))\n ptyext_params;\n Ast_412.Parsetree.ptyext_constructors =\n List.map copy_extension_constructor ptyext_constructors;\n Ast_412.Parsetree.ptyext_private = copy_private_flag ptyext_private;\n Ast_412.Parsetree.ptyext_loc = copy_location ptyext_loc;\n Ast_412.Parsetree.ptyext_attributes = copy_attributes ptyext_attributes;\n }\n\nand copy_extension_constructor :\n Ast_413.Parsetree.extension_constructor ->\n Ast_412.Parsetree.extension_constructor =\n fun {\n Ast_413.Parsetree.pext_name;\n Ast_413.Parsetree.pext_kind;\n Ast_413.Parsetree.pext_loc;\n Ast_413.Parsetree.pext_attributes;\n } ->\n {\n Ast_412.Parsetree.pext_name = copy_loc (fun x -> x) pext_name;\n Ast_412.Parsetree.pext_kind = copy_extension_constructor_kind pext_kind;\n Ast_412.Parsetree.pext_loc = copy_location pext_loc;\n Ast_412.Parsetree.pext_attributes = copy_attributes pext_attributes;\n }\n\nand copy_extension_constructor_kind :\n Ast_413.Parsetree.extension_constructor_kind ->\n Ast_412.Parsetree.extension_constructor_kind = function\n | Ast_413.Parsetree.Pext_decl (x0, x1) ->\n Ast_412.Parsetree.Pext_decl\n (copy_constructor_arguments x0, Option.map copy_core_type x1)\n | Ast_413.Parsetree.Pext_rebind x0 ->\n Ast_412.Parsetree.Pext_rebind (copy_loc copy_Longident_t x0)\n\nand copy_type_declaration :\n Ast_413.Parsetree.type_declaration -> Ast_412.Parsetree.type_declaration =\n fun {\n Ast_413.Parsetree.ptype_name;\n Ast_413.Parsetree.ptype_params;\n Ast_413.Parsetree.ptype_cstrs;\n Ast_413.Parsetree.ptype_kind;\n Ast_413.Parsetree.ptype_private;\n Ast_413.Parsetree.ptype_manifest;\n Ast_413.Parsetree.ptype_attributes;\n Ast_413.Parsetree.ptype_loc;\n } ->\n {\n Ast_412.Parsetree.ptype_name = copy_loc (fun x -> x) ptype_name;\n Ast_412.Parsetree.ptype_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n ( copy_core_type x0,\n let x0, x1 = x1 in\n (copy_variance x0, copy_injectivity x1) ))\n ptype_params;\n Ast_412.Parsetree.ptype_cstrs =\n List.map\n (fun x ->\n let x0, x1, x2 = x in\n (copy_core_type x0, copy_core_type x1, copy_location x2))\n ptype_cstrs;\n Ast_412.Parsetree.ptype_kind = copy_type_kind ptype_kind;\n Ast_412.Parsetree.ptype_private = copy_private_flag ptype_private;\n Ast_412.Parsetree.ptype_manifest = Option.map copy_core_type ptype_manifest;\n Ast_412.Parsetree.ptype_attributes = copy_attributes ptype_attributes;\n Ast_412.Parsetree.ptype_loc = copy_location ptype_loc;\n }\n\nand copy_private_flag :\n Ast_413.Asttypes.private_flag -> Ast_412.Asttypes.private_flag = function\n | Ast_413.Asttypes.Private -> Ast_412.Asttypes.Private\n | Ast_413.Asttypes.Public -> Ast_412.Asttypes.Public\n\nand copy_type_kind : Ast_413.Parsetree.type_kind -> Ast_412.Parsetree.type_kind\n = function\n | Ast_413.Parsetree.Ptype_abstract -> Ast_412.Parsetree.Ptype_abstract\n | Ast_413.Parsetree.Ptype_variant x0 ->\n Ast_412.Parsetree.Ptype_variant (List.map copy_constructor_declaration x0)\n | Ast_413.Parsetree.Ptype_record x0 ->\n Ast_412.Parsetree.Ptype_record (List.map copy_label_declaration x0)\n | Ast_413.Parsetree.Ptype_open -> Ast_412.Parsetree.Ptype_open\n\nand copy_constructor_declaration :\n Ast_413.Parsetree.constructor_declaration ->\n Ast_412.Parsetree.constructor_declaration =\n fun {\n Ast_413.Parsetree.pcd_name;\n Ast_413.Parsetree.pcd_args;\n Ast_413.Parsetree.pcd_res;\n Ast_413.Parsetree.pcd_loc;\n Ast_413.Parsetree.pcd_attributes;\n } ->\n {\n Ast_412.Parsetree.pcd_name = copy_loc (fun x -> x) pcd_name;\n Ast_412.Parsetree.pcd_args = copy_constructor_arguments pcd_args;\n Ast_412.Parsetree.pcd_res = Option.map copy_core_type pcd_res;\n Ast_412.Parsetree.pcd_loc = copy_location pcd_loc;\n Ast_412.Parsetree.pcd_attributes = copy_attributes pcd_attributes;\n }\n\nand copy_constructor_arguments :\n Ast_413.Parsetree.constructor_arguments ->\n Ast_412.Parsetree.constructor_arguments = function\n | Ast_413.Parsetree.Pcstr_tuple x0 ->\n Ast_412.Parsetree.Pcstr_tuple (List.map copy_core_type x0)\n | Ast_413.Parsetree.Pcstr_record x0 ->\n Ast_412.Parsetree.Pcstr_record (List.map copy_label_declaration x0)\n\nand copy_label_declaration :\n Ast_413.Parsetree.label_declaration -> Ast_412.Parsetree.label_declaration =\n fun {\n Ast_413.Parsetree.pld_name;\n Ast_413.Parsetree.pld_mutable;\n Ast_413.Parsetree.pld_type;\n Ast_413.Parsetree.pld_loc;\n Ast_413.Parsetree.pld_attributes;\n } ->\n {\n Ast_412.Parsetree.pld_name = copy_loc (fun x -> x) pld_name;\n Ast_412.Parsetree.pld_mutable = copy_mutable_flag pld_mutable;\n Ast_412.Parsetree.pld_type = copy_core_type pld_type;\n Ast_412.Parsetree.pld_loc = copy_location pld_loc;\n Ast_412.Parsetree.pld_attributes = copy_attributes pld_attributes;\n }\n\nand copy_mutable_flag :\n Ast_413.Asttypes.mutable_flag -> Ast_412.Asttypes.mutable_flag = function\n | Ast_413.Asttypes.Immutable -> Ast_412.Asttypes.Immutable\n | Ast_413.Asttypes.Mutable -> Ast_412.Asttypes.Mutable\n\nand copy_injectivity :\n Ast_413.Asttypes.injectivity -> Ast_412.Asttypes.injectivity = function\n | Ast_413.Asttypes.Injective -> Ast_412.Asttypes.Injective\n | Ast_413.Asttypes.NoInjectivity -> Ast_412.Asttypes.NoInjectivity\n\nand copy_variance : Ast_413.Asttypes.variance -> Ast_412.Asttypes.variance =\n function\n | Ast_413.Asttypes.Covariant -> Ast_412.Asttypes.Covariant\n | Ast_413.Asttypes.Contravariant -> Ast_412.Asttypes.Contravariant\n | Ast_413.Asttypes.NoVariance -> Ast_412.Asttypes.NoVariance\n\nand copy_value_description :\n Ast_413.Parsetree.value_description -> Ast_412.Parsetree.value_description =\n fun {\n Ast_413.Parsetree.pval_name;\n Ast_413.Parsetree.pval_type;\n Ast_413.Parsetree.pval_prim;\n Ast_413.Parsetree.pval_attributes;\n Ast_413.Parsetree.pval_loc;\n } ->\n {\n Ast_412.Parsetree.pval_name = copy_loc (fun x -> x) pval_name;\n Ast_412.Parsetree.pval_type = copy_core_type pval_type;\n Ast_412.Parsetree.pval_prim = List.map (fun x -> x) pval_prim;\n Ast_412.Parsetree.pval_attributes = copy_attributes pval_attributes;\n Ast_412.Parsetree.pval_loc = copy_location pval_loc;\n }\n\nand copy_object_field_desc :\n Ast_413.Parsetree.object_field_desc -> Ast_412.Parsetree.object_field_desc =\n function\n | Ast_413.Parsetree.Otag (x0, x1) ->\n Ast_412.Parsetree.Otag (copy_loc copy_label x0, copy_core_type x1)\n | Ast_413.Parsetree.Oinherit x0 ->\n Ast_412.Parsetree.Oinherit (copy_core_type x0)\n\nand copy_arg_label : Ast_413.Asttypes.arg_label -> Ast_412.Asttypes.arg_label =\n function\n | Ast_413.Asttypes.Nolabel -> Ast_412.Asttypes.Nolabel\n | Ast_413.Asttypes.Labelled x0 -> Ast_412.Asttypes.Labelled x0\n | Ast_413.Asttypes.Optional x0 -> Ast_412.Asttypes.Optional x0\n\nand copy_closed_flag :\n Ast_413.Asttypes.closed_flag -> Ast_412.Asttypes.closed_flag = function\n | Ast_413.Asttypes.Closed -> Ast_412.Asttypes.Closed\n | Ast_413.Asttypes.Open -> Ast_412.Asttypes.Open\n\nand copy_label : Ast_413.Asttypes.label -> Ast_412.Asttypes.label = fun x -> x\n\nand copy_rec_flag : Ast_413.Asttypes.rec_flag -> Ast_412.Asttypes.rec_flag =\n function\n | Ast_413.Asttypes.Nonrecursive -> Ast_412.Asttypes.Nonrecursive\n | Ast_413.Asttypes.Recursive -> Ast_412.Asttypes.Recursive\n\nand copy_constant : Ast_413.Parsetree.constant -> Ast_412.Parsetree.constant =\n function\n | Ast_413.Parsetree.Pconst_integer (x0, x1) ->\n Ast_412.Parsetree.Pconst_integer (x0, Option.map (fun x -> x) x1)\n | Ast_413.Parsetree.Pconst_char x0 -> Ast_412.Parsetree.Pconst_char x0\n | Ast_413.Parsetree.Pconst_string (x0, x1, x2) ->\n Ast_412.Parsetree.Pconst_string\n (x0, copy_location x1, Option.map (fun x -> x) x2)\n | Ast_413.Parsetree.Pconst_float (x0, x1) ->\n Ast_412.Parsetree.Pconst_float (x0, Option.map (fun x -> x) x1)\n\nand copy_Longident_t : Longident.t -> Longident.t = fun x -> x\n\nand copy_loc :\n 'f0 'g0.\n ('f0 -> 'g0) -> 'f0 Ast_413.Asttypes.loc -> 'g0 Ast_412.Asttypes.loc =\n fun f0 { Ast_413.Asttypes.txt; Ast_413.Asttypes.loc } ->\n { Ast_412.Asttypes.txt = f0 txt; Ast_412.Asttypes.loc = copy_location loc }\n\nand copy_location : Location.t -> Location.t = fun x -> x\n","open Stdlib0\nmodule From = Ast_412\nmodule To = Ast_413\n\nlet rec copy_toplevel_phrase :\n Ast_412.Parsetree.toplevel_phrase -> Ast_413.Parsetree.toplevel_phrase =\n function\n | Ast_412.Parsetree.Ptop_def x0 ->\n Ast_413.Parsetree.Ptop_def (copy_structure x0)\n | Ast_412.Parsetree.Ptop_dir x0 ->\n Ast_413.Parsetree.Ptop_dir (copy_toplevel_directive x0)\n\nand copy_toplevel_directive :\n Ast_412.Parsetree.toplevel_directive -> Ast_413.Parsetree.toplevel_directive\n =\n fun {\n Ast_412.Parsetree.pdir_name;\n Ast_412.Parsetree.pdir_arg;\n Ast_412.Parsetree.pdir_loc;\n } ->\n {\n Ast_413.Parsetree.pdir_name = copy_loc (fun x -> x) pdir_name;\n Ast_413.Parsetree.pdir_arg = Option.map copy_directive_argument pdir_arg;\n Ast_413.Parsetree.pdir_loc = copy_location pdir_loc;\n }\n\nand copy_directive_argument :\n Ast_412.Parsetree.directive_argument -> Ast_413.Parsetree.directive_argument\n =\n fun { Ast_412.Parsetree.pdira_desc; Ast_412.Parsetree.pdira_loc } ->\n {\n Ast_413.Parsetree.pdira_desc = copy_directive_argument_desc pdira_desc;\n Ast_413.Parsetree.pdira_loc = copy_location pdira_loc;\n }\n\nand copy_directive_argument_desc :\n Ast_412.Parsetree.directive_argument_desc ->\n Ast_413.Parsetree.directive_argument_desc = function\n | Ast_412.Parsetree.Pdir_string x0 -> Ast_413.Parsetree.Pdir_string x0\n | Ast_412.Parsetree.Pdir_int (x0, x1) ->\n Ast_413.Parsetree.Pdir_int (x0, Option.map (fun x -> x) x1)\n | Ast_412.Parsetree.Pdir_ident x0 ->\n Ast_413.Parsetree.Pdir_ident (copy_Longident_t x0)\n | Ast_412.Parsetree.Pdir_bool x0 -> Ast_413.Parsetree.Pdir_bool x0\n\nand copy_expression :\n Ast_412.Parsetree.expression -> Ast_413.Parsetree.expression =\n fun {\n Ast_412.Parsetree.pexp_desc;\n Ast_412.Parsetree.pexp_loc;\n Ast_412.Parsetree.pexp_loc_stack;\n Ast_412.Parsetree.pexp_attributes;\n } ->\n {\n Ast_413.Parsetree.pexp_desc = copy_expression_desc pexp_desc;\n Ast_413.Parsetree.pexp_loc = copy_location pexp_loc;\n Ast_413.Parsetree.pexp_loc_stack = copy_location_stack pexp_loc_stack;\n Ast_413.Parsetree.pexp_attributes = copy_attributes pexp_attributes;\n }\n\nand copy_expression_desc :\n Ast_412.Parsetree.expression_desc -> Ast_413.Parsetree.expression_desc =\n function\n | Ast_412.Parsetree.Pexp_ident x0 ->\n Ast_413.Parsetree.Pexp_ident (copy_loc copy_Longident_t x0)\n | Ast_412.Parsetree.Pexp_constant x0 ->\n Ast_413.Parsetree.Pexp_constant (copy_constant x0)\n | Ast_412.Parsetree.Pexp_let (x0, x1, x2) ->\n Ast_413.Parsetree.Pexp_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_expression x2)\n | Ast_412.Parsetree.Pexp_function x0 ->\n Ast_413.Parsetree.Pexp_function (List.map copy_case x0)\n | Ast_412.Parsetree.Pexp_fun (x0, x1, x2, x3) ->\n Ast_413.Parsetree.Pexp_fun\n ( copy_arg_label x0,\n Option.map copy_expression x1,\n copy_pattern x2,\n copy_expression x3 )\n | Ast_412.Parsetree.Pexp_apply (x0, x1) ->\n Ast_413.Parsetree.Pexp_apply\n ( copy_expression x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | Ast_412.Parsetree.Pexp_match (x0, x1) ->\n Ast_413.Parsetree.Pexp_match (copy_expression x0, List.map copy_case x1)\n | Ast_412.Parsetree.Pexp_try (x0, x1) ->\n Ast_413.Parsetree.Pexp_try (copy_expression x0, List.map copy_case x1)\n | Ast_412.Parsetree.Pexp_tuple x0 ->\n Ast_413.Parsetree.Pexp_tuple (List.map copy_expression x0)\n | Ast_412.Parsetree.Pexp_construct (x0, x1) ->\n Ast_413.Parsetree.Pexp_construct\n (copy_loc copy_Longident_t x0, Option.map copy_expression x1)\n | Ast_412.Parsetree.Pexp_variant (x0, x1) ->\n Ast_413.Parsetree.Pexp_variant\n (copy_label x0, Option.map copy_expression x1)\n | Ast_412.Parsetree.Pexp_record (x0, x1) ->\n Ast_413.Parsetree.Pexp_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_expression x1))\n x0,\n Option.map copy_expression x1 )\n | Ast_412.Parsetree.Pexp_field (x0, x1) ->\n Ast_413.Parsetree.Pexp_field\n (copy_expression x0, copy_loc copy_Longident_t x1)\n | Ast_412.Parsetree.Pexp_setfield (x0, x1, x2) ->\n Ast_413.Parsetree.Pexp_setfield\n (copy_expression x0, copy_loc copy_Longident_t x1, copy_expression x2)\n | Ast_412.Parsetree.Pexp_array x0 ->\n Ast_413.Parsetree.Pexp_array (List.map copy_expression x0)\n | Ast_412.Parsetree.Pexp_ifthenelse (x0, x1, x2) ->\n Ast_413.Parsetree.Pexp_ifthenelse\n (copy_expression x0, copy_expression x1, Option.map copy_expression x2)\n | Ast_412.Parsetree.Pexp_sequence (x0, x1) ->\n Ast_413.Parsetree.Pexp_sequence (copy_expression x0, copy_expression x1)\n | Ast_412.Parsetree.Pexp_while (x0, x1) ->\n Ast_413.Parsetree.Pexp_while (copy_expression x0, copy_expression x1)\n | Ast_412.Parsetree.Pexp_for (x0, x1, x2, x3, x4) ->\n Ast_413.Parsetree.Pexp_for\n ( copy_pattern x0,\n copy_expression x1,\n copy_expression x2,\n copy_direction_flag x3,\n copy_expression x4 )\n | Ast_412.Parsetree.Pexp_constraint (x0, x1) ->\n Ast_413.Parsetree.Pexp_constraint (copy_expression x0, copy_core_type x1)\n | Ast_412.Parsetree.Pexp_coerce (x0, x1, x2) ->\n Ast_413.Parsetree.Pexp_coerce\n (copy_expression x0, Option.map copy_core_type x1, copy_core_type x2)\n | Ast_412.Parsetree.Pexp_send (x0, x1) ->\n Ast_413.Parsetree.Pexp_send (copy_expression x0, copy_loc copy_label x1)\n | Ast_412.Parsetree.Pexp_new x0 ->\n Ast_413.Parsetree.Pexp_new (copy_loc copy_Longident_t x0)\n | Ast_412.Parsetree.Pexp_setinstvar (x0, x1) ->\n Ast_413.Parsetree.Pexp_setinstvar\n (copy_loc copy_label x0, copy_expression x1)\n | Ast_412.Parsetree.Pexp_override x0 ->\n Ast_413.Parsetree.Pexp_override\n (List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_label x0, copy_expression x1))\n x0)\n | Ast_412.Parsetree.Pexp_letmodule (x0, x1, x2) ->\n Ast_413.Parsetree.Pexp_letmodule\n ( copy_loc (fun x -> Option.map (fun x -> x) x) x0,\n copy_module_expr x1,\n copy_expression x2 )\n | Ast_412.Parsetree.Pexp_letexception (x0, x1) ->\n Ast_413.Parsetree.Pexp_letexception\n (copy_extension_constructor x0, copy_expression x1)\n | Ast_412.Parsetree.Pexp_assert x0 ->\n Ast_413.Parsetree.Pexp_assert (copy_expression x0)\n | Ast_412.Parsetree.Pexp_lazy x0 ->\n Ast_413.Parsetree.Pexp_lazy (copy_expression x0)\n | Ast_412.Parsetree.Pexp_poly (x0, x1) ->\n Ast_413.Parsetree.Pexp_poly\n (copy_expression x0, Option.map copy_core_type x1)\n | Ast_412.Parsetree.Pexp_object x0 ->\n Ast_413.Parsetree.Pexp_object (copy_class_structure x0)\n | Ast_412.Parsetree.Pexp_newtype (x0, x1) ->\n Ast_413.Parsetree.Pexp_newtype\n (copy_loc (fun x -> x) x0, copy_expression x1)\n | Ast_412.Parsetree.Pexp_pack x0 ->\n Ast_413.Parsetree.Pexp_pack (copy_module_expr x0)\n | Ast_412.Parsetree.Pexp_open (x0, x1) ->\n Ast_413.Parsetree.Pexp_open (copy_open_declaration x0, copy_expression x1)\n | Ast_412.Parsetree.Pexp_letop x0 ->\n Ast_413.Parsetree.Pexp_letop (copy_letop x0)\n | Ast_412.Parsetree.Pexp_extension x0 ->\n Ast_413.Parsetree.Pexp_extension (copy_extension x0)\n | Ast_412.Parsetree.Pexp_unreachable -> Ast_413.Parsetree.Pexp_unreachable\n\nand copy_letop : Ast_412.Parsetree.letop -> Ast_413.Parsetree.letop =\n fun { Ast_412.Parsetree.let_; Ast_412.Parsetree.ands; Ast_412.Parsetree.body } ->\n {\n Ast_413.Parsetree.let_ = copy_binding_op let_;\n Ast_413.Parsetree.ands = List.map copy_binding_op ands;\n Ast_413.Parsetree.body = copy_expression body;\n }\n\nand copy_binding_op :\n Ast_412.Parsetree.binding_op -> Ast_413.Parsetree.binding_op =\n fun {\n Ast_412.Parsetree.pbop_op;\n Ast_412.Parsetree.pbop_pat;\n Ast_412.Parsetree.pbop_exp;\n Ast_412.Parsetree.pbop_loc;\n } ->\n {\n Ast_413.Parsetree.pbop_op = copy_loc (fun x -> x) pbop_op;\n Ast_413.Parsetree.pbop_pat = copy_pattern pbop_pat;\n Ast_413.Parsetree.pbop_exp = copy_expression pbop_exp;\n Ast_413.Parsetree.pbop_loc = copy_location pbop_loc;\n }\n\nand copy_direction_flag :\n Ast_412.Asttypes.direction_flag -> Ast_413.Asttypes.direction_flag =\n function\n | Ast_412.Asttypes.Upto -> Ast_413.Asttypes.Upto\n | Ast_412.Asttypes.Downto -> Ast_413.Asttypes.Downto\n\nand copy_case : Ast_412.Parsetree.case -> Ast_413.Parsetree.case =\n fun {\n Ast_412.Parsetree.pc_lhs;\n Ast_412.Parsetree.pc_guard;\n Ast_412.Parsetree.pc_rhs;\n } ->\n {\n Ast_413.Parsetree.pc_lhs = copy_pattern pc_lhs;\n Ast_413.Parsetree.pc_guard = Option.map copy_expression pc_guard;\n Ast_413.Parsetree.pc_rhs = copy_expression pc_rhs;\n }\n\nand copy_value_binding :\n Ast_412.Parsetree.value_binding -> Ast_413.Parsetree.value_binding =\n fun {\n Ast_412.Parsetree.pvb_pat;\n Ast_412.Parsetree.pvb_expr;\n Ast_412.Parsetree.pvb_attributes;\n Ast_412.Parsetree.pvb_loc;\n } ->\n {\n Ast_413.Parsetree.pvb_pat = copy_pattern pvb_pat;\n Ast_413.Parsetree.pvb_expr = copy_expression pvb_expr;\n Ast_413.Parsetree.pvb_attributes = copy_attributes pvb_attributes;\n Ast_413.Parsetree.pvb_loc = copy_location pvb_loc;\n }\n\nand copy_pattern : Ast_412.Parsetree.pattern -> Ast_413.Parsetree.pattern =\n fun {\n Ast_412.Parsetree.ppat_desc;\n Ast_412.Parsetree.ppat_loc;\n Ast_412.Parsetree.ppat_loc_stack;\n Ast_412.Parsetree.ppat_attributes;\n } ->\n {\n Ast_413.Parsetree.ppat_desc = copy_pattern_desc ppat_desc;\n Ast_413.Parsetree.ppat_loc = copy_location ppat_loc;\n Ast_413.Parsetree.ppat_loc_stack = copy_location_stack ppat_loc_stack;\n Ast_413.Parsetree.ppat_attributes = copy_attributes ppat_attributes;\n }\n\nand copy_pattern_desc :\n Ast_412.Parsetree.pattern_desc -> Ast_413.Parsetree.pattern_desc = function\n | Ast_412.Parsetree.Ppat_any -> Ast_413.Parsetree.Ppat_any\n | Ast_412.Parsetree.Ppat_var x0 ->\n Ast_413.Parsetree.Ppat_var (copy_loc (fun x -> x) x0)\n | Ast_412.Parsetree.Ppat_alias (x0, x1) ->\n Ast_413.Parsetree.Ppat_alias (copy_pattern x0, copy_loc (fun x -> x) x1)\n | Ast_412.Parsetree.Ppat_constant x0 ->\n Ast_413.Parsetree.Ppat_constant (copy_constant x0)\n | Ast_412.Parsetree.Ppat_interval (x0, x1) ->\n Ast_413.Parsetree.Ppat_interval (copy_constant x0, copy_constant x1)\n | Ast_412.Parsetree.Ppat_tuple x0 ->\n Ast_413.Parsetree.Ppat_tuple (List.map copy_pattern x0)\n | Ast_412.Parsetree.Ppat_construct (x0, x1) ->\n Ast_413.Parsetree.Ppat_construct\n ( copy_loc copy_Longident_t x0,\n Option.map (fun x -> ([], copy_pattern x)) x1 )\n | Ast_412.Parsetree.Ppat_variant (x0, x1) ->\n Ast_413.Parsetree.Ppat_variant (copy_label x0, Option.map copy_pattern x1)\n | Ast_412.Parsetree.Ppat_record (x0, x1) ->\n Ast_413.Parsetree.Ppat_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_pattern x1))\n x0,\n copy_closed_flag x1 )\n | Ast_412.Parsetree.Ppat_array x0 ->\n Ast_413.Parsetree.Ppat_array (List.map copy_pattern x0)\n | Ast_412.Parsetree.Ppat_or (x0, x1) ->\n Ast_413.Parsetree.Ppat_or (copy_pattern x0, copy_pattern x1)\n | Ast_412.Parsetree.Ppat_constraint (x0, x1) ->\n Ast_413.Parsetree.Ppat_constraint (copy_pattern x0, copy_core_type x1)\n | Ast_412.Parsetree.Ppat_type x0 ->\n Ast_413.Parsetree.Ppat_type (copy_loc copy_Longident_t x0)\n | Ast_412.Parsetree.Ppat_lazy x0 ->\n Ast_413.Parsetree.Ppat_lazy (copy_pattern x0)\n | Ast_412.Parsetree.Ppat_unpack x0 ->\n Ast_413.Parsetree.Ppat_unpack\n (copy_loc (fun x -> Option.map (fun x -> x) x) x0)\n | Ast_412.Parsetree.Ppat_exception x0 ->\n Ast_413.Parsetree.Ppat_exception (copy_pattern x0)\n | Ast_412.Parsetree.Ppat_extension x0 ->\n Ast_413.Parsetree.Ppat_extension (copy_extension x0)\n | Ast_412.Parsetree.Ppat_open (x0, x1) ->\n Ast_413.Parsetree.Ppat_open (copy_loc copy_Longident_t x0, copy_pattern x1)\n\nand copy_core_type : Ast_412.Parsetree.core_type -> Ast_413.Parsetree.core_type\n =\n fun {\n Ast_412.Parsetree.ptyp_desc;\n Ast_412.Parsetree.ptyp_loc;\n Ast_412.Parsetree.ptyp_loc_stack;\n Ast_412.Parsetree.ptyp_attributes;\n } ->\n {\n Ast_413.Parsetree.ptyp_desc = copy_core_type_desc ptyp_desc;\n Ast_413.Parsetree.ptyp_loc = copy_location ptyp_loc;\n Ast_413.Parsetree.ptyp_loc_stack = copy_location_stack ptyp_loc_stack;\n Ast_413.Parsetree.ptyp_attributes = copy_attributes ptyp_attributes;\n }\n\nand copy_location_stack :\n Ast_412.Parsetree.location_stack -> Ast_413.Parsetree.location_stack =\n fun x -> List.map copy_location x\n\nand copy_core_type_desc :\n Ast_412.Parsetree.core_type_desc -> Ast_413.Parsetree.core_type_desc =\n function\n | Ast_412.Parsetree.Ptyp_any -> Ast_413.Parsetree.Ptyp_any\n | Ast_412.Parsetree.Ptyp_var x0 -> Ast_413.Parsetree.Ptyp_var x0\n | Ast_412.Parsetree.Ptyp_arrow (x0, x1, x2) ->\n Ast_413.Parsetree.Ptyp_arrow\n (copy_arg_label x0, copy_core_type x1, copy_core_type x2)\n | Ast_412.Parsetree.Ptyp_tuple x0 ->\n Ast_413.Parsetree.Ptyp_tuple (List.map copy_core_type x0)\n | Ast_412.Parsetree.Ptyp_constr (x0, x1) ->\n Ast_413.Parsetree.Ptyp_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_412.Parsetree.Ptyp_object (x0, x1) ->\n Ast_413.Parsetree.Ptyp_object\n (List.map copy_object_field x0, copy_closed_flag x1)\n | Ast_412.Parsetree.Ptyp_class (x0, x1) ->\n Ast_413.Parsetree.Ptyp_class\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_412.Parsetree.Ptyp_alias (x0, x1) ->\n Ast_413.Parsetree.Ptyp_alias (copy_core_type x0, x1)\n | Ast_412.Parsetree.Ptyp_variant (x0, x1, x2) ->\n Ast_413.Parsetree.Ptyp_variant\n ( List.map copy_row_field x0,\n copy_closed_flag x1,\n Option.map (fun x -> List.map copy_label x) x2 )\n | Ast_412.Parsetree.Ptyp_poly (x0, x1) ->\n Ast_413.Parsetree.Ptyp_poly\n (List.map (fun x -> copy_loc (fun x -> x) x) x0, copy_core_type x1)\n | Ast_412.Parsetree.Ptyp_package x0 ->\n Ast_413.Parsetree.Ptyp_package (copy_package_type x0)\n | Ast_412.Parsetree.Ptyp_extension x0 ->\n Ast_413.Parsetree.Ptyp_extension (copy_extension x0)\n\nand copy_package_type :\n Ast_412.Parsetree.package_type -> Ast_413.Parsetree.package_type =\n fun x ->\n let x0, x1 = x in\n ( copy_loc copy_Longident_t x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_core_type x1))\n x1 )\n\nand copy_row_field : Ast_412.Parsetree.row_field -> Ast_413.Parsetree.row_field\n =\n fun {\n Ast_412.Parsetree.prf_desc;\n Ast_412.Parsetree.prf_loc;\n Ast_412.Parsetree.prf_attributes;\n } ->\n {\n Ast_413.Parsetree.prf_desc = copy_row_field_desc prf_desc;\n Ast_413.Parsetree.prf_loc = copy_location prf_loc;\n Ast_413.Parsetree.prf_attributes = copy_attributes prf_attributes;\n }\n\nand copy_row_field_desc :\n Ast_412.Parsetree.row_field_desc -> Ast_413.Parsetree.row_field_desc =\n function\n | Ast_412.Parsetree.Rtag (x0, x1, x2) ->\n Ast_413.Parsetree.Rtag\n (copy_loc copy_label x0, x1, List.map copy_core_type x2)\n | Ast_412.Parsetree.Rinherit x0 ->\n Ast_413.Parsetree.Rinherit (copy_core_type x0)\n\nand copy_object_field :\n Ast_412.Parsetree.object_field -> Ast_413.Parsetree.object_field =\n fun {\n Ast_412.Parsetree.pof_desc;\n Ast_412.Parsetree.pof_loc;\n Ast_412.Parsetree.pof_attributes;\n } ->\n {\n Ast_413.Parsetree.pof_desc = copy_object_field_desc pof_desc;\n Ast_413.Parsetree.pof_loc = copy_location pof_loc;\n Ast_413.Parsetree.pof_attributes = copy_attributes pof_attributes;\n }\n\nand copy_attributes :\n Ast_412.Parsetree.attributes -> Ast_413.Parsetree.attributes =\n fun x -> List.map copy_attribute x\n\nand copy_attribute : Ast_412.Parsetree.attribute -> Ast_413.Parsetree.attribute\n =\n fun {\n Ast_412.Parsetree.attr_name;\n Ast_412.Parsetree.attr_payload;\n Ast_412.Parsetree.attr_loc;\n } ->\n {\n Ast_413.Parsetree.attr_name = copy_loc (fun x -> x) attr_name;\n Ast_413.Parsetree.attr_payload = copy_payload attr_payload;\n Ast_413.Parsetree.attr_loc = copy_location attr_loc;\n }\n\nand copy_payload : Ast_412.Parsetree.payload -> Ast_413.Parsetree.payload =\n function\n | Ast_412.Parsetree.PStr x0 -> Ast_413.Parsetree.PStr (copy_structure x0)\n | Ast_412.Parsetree.PSig x0 -> Ast_413.Parsetree.PSig (copy_signature x0)\n | Ast_412.Parsetree.PTyp x0 -> Ast_413.Parsetree.PTyp (copy_core_type x0)\n | Ast_412.Parsetree.PPat (x0, x1) ->\n Ast_413.Parsetree.PPat (copy_pattern x0, Option.map copy_expression x1)\n\nand copy_structure : Ast_412.Parsetree.structure -> Ast_413.Parsetree.structure\n =\n fun x -> List.map copy_structure_item x\n\nand copy_structure_item :\n Ast_412.Parsetree.structure_item -> Ast_413.Parsetree.structure_item =\n fun { Ast_412.Parsetree.pstr_desc; Ast_412.Parsetree.pstr_loc } ->\n {\n Ast_413.Parsetree.pstr_desc = copy_structure_item_desc pstr_desc;\n Ast_413.Parsetree.pstr_loc = copy_location pstr_loc;\n }\n\nand copy_structure_item_desc :\n Ast_412.Parsetree.structure_item_desc ->\n Ast_413.Parsetree.structure_item_desc = function\n | Ast_412.Parsetree.Pstr_eval (x0, x1) ->\n Ast_413.Parsetree.Pstr_eval (copy_expression x0, copy_attributes x1)\n | Ast_412.Parsetree.Pstr_value (x0, x1) ->\n Ast_413.Parsetree.Pstr_value\n (copy_rec_flag x0, List.map copy_value_binding x1)\n | Ast_412.Parsetree.Pstr_primitive x0 ->\n Ast_413.Parsetree.Pstr_primitive (copy_value_description x0)\n | Ast_412.Parsetree.Pstr_type (x0, x1) ->\n Ast_413.Parsetree.Pstr_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | Ast_412.Parsetree.Pstr_typext x0 ->\n Ast_413.Parsetree.Pstr_typext (copy_type_extension x0)\n | Ast_412.Parsetree.Pstr_exception x0 ->\n Ast_413.Parsetree.Pstr_exception (copy_type_exception x0)\n | Ast_412.Parsetree.Pstr_module x0 ->\n Ast_413.Parsetree.Pstr_module (copy_module_binding x0)\n | Ast_412.Parsetree.Pstr_recmodule x0 ->\n Ast_413.Parsetree.Pstr_recmodule (List.map copy_module_binding x0)\n | Ast_412.Parsetree.Pstr_modtype x0 ->\n Ast_413.Parsetree.Pstr_modtype (copy_module_type_declaration x0)\n | Ast_412.Parsetree.Pstr_open x0 ->\n Ast_413.Parsetree.Pstr_open (copy_open_declaration x0)\n | Ast_412.Parsetree.Pstr_class x0 ->\n Ast_413.Parsetree.Pstr_class (List.map copy_class_declaration x0)\n | Ast_412.Parsetree.Pstr_class_type x0 ->\n Ast_413.Parsetree.Pstr_class_type\n (List.map copy_class_type_declaration x0)\n | Ast_412.Parsetree.Pstr_include x0 ->\n Ast_413.Parsetree.Pstr_include (copy_include_declaration x0)\n | Ast_412.Parsetree.Pstr_attribute x0 ->\n Ast_413.Parsetree.Pstr_attribute (copy_attribute x0)\n | Ast_412.Parsetree.Pstr_extension (x0, x1) ->\n Ast_413.Parsetree.Pstr_extension (copy_extension x0, copy_attributes x1)\n\nand copy_include_declaration :\n Ast_412.Parsetree.include_declaration ->\n Ast_413.Parsetree.include_declaration =\n fun x -> copy_include_infos copy_module_expr x\n\nand copy_class_declaration :\n Ast_412.Parsetree.class_declaration -> Ast_413.Parsetree.class_declaration =\n fun x -> copy_class_infos copy_class_expr x\n\nand copy_class_expr :\n Ast_412.Parsetree.class_expr -> Ast_413.Parsetree.class_expr =\n fun {\n Ast_412.Parsetree.pcl_desc;\n Ast_412.Parsetree.pcl_loc;\n Ast_412.Parsetree.pcl_attributes;\n } ->\n {\n Ast_413.Parsetree.pcl_desc = copy_class_expr_desc pcl_desc;\n Ast_413.Parsetree.pcl_loc = copy_location pcl_loc;\n Ast_413.Parsetree.pcl_attributes = copy_attributes pcl_attributes;\n }\n\nand copy_class_expr_desc :\n Ast_412.Parsetree.class_expr_desc -> Ast_413.Parsetree.class_expr_desc =\n function\n | Ast_412.Parsetree.Pcl_constr (x0, x1) ->\n Ast_413.Parsetree.Pcl_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_412.Parsetree.Pcl_structure x0 ->\n Ast_413.Parsetree.Pcl_structure (copy_class_structure x0)\n | Ast_412.Parsetree.Pcl_fun (x0, x1, x2, x3) ->\n Ast_413.Parsetree.Pcl_fun\n ( copy_arg_label x0,\n Option.map copy_expression x1,\n copy_pattern x2,\n copy_class_expr x3 )\n | Ast_412.Parsetree.Pcl_apply (x0, x1) ->\n Ast_413.Parsetree.Pcl_apply\n ( copy_class_expr x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | Ast_412.Parsetree.Pcl_let (x0, x1, x2) ->\n Ast_413.Parsetree.Pcl_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_class_expr x2)\n | Ast_412.Parsetree.Pcl_constraint (x0, x1) ->\n Ast_413.Parsetree.Pcl_constraint (copy_class_expr x0, copy_class_type x1)\n | Ast_412.Parsetree.Pcl_extension x0 ->\n Ast_413.Parsetree.Pcl_extension (copy_extension x0)\n | Ast_412.Parsetree.Pcl_open (x0, x1) ->\n Ast_413.Parsetree.Pcl_open (copy_open_description x0, copy_class_expr x1)\n\nand copy_class_structure :\n Ast_412.Parsetree.class_structure -> Ast_413.Parsetree.class_structure =\n fun { Ast_412.Parsetree.pcstr_self; Ast_412.Parsetree.pcstr_fields } ->\n {\n Ast_413.Parsetree.pcstr_self = copy_pattern pcstr_self;\n Ast_413.Parsetree.pcstr_fields = List.map copy_class_field pcstr_fields;\n }\n\nand copy_class_field :\n Ast_412.Parsetree.class_field -> Ast_413.Parsetree.class_field =\n fun {\n Ast_412.Parsetree.pcf_desc;\n Ast_412.Parsetree.pcf_loc;\n Ast_412.Parsetree.pcf_attributes;\n } ->\n {\n Ast_413.Parsetree.pcf_desc = copy_class_field_desc pcf_desc;\n Ast_413.Parsetree.pcf_loc = copy_location pcf_loc;\n Ast_413.Parsetree.pcf_attributes = copy_attributes pcf_attributes;\n }\n\nand copy_class_field_desc :\n Ast_412.Parsetree.class_field_desc -> Ast_413.Parsetree.class_field_desc =\n function\n | Ast_412.Parsetree.Pcf_inherit (x0, x1, x2) ->\n Ast_413.Parsetree.Pcf_inherit\n ( copy_override_flag x0,\n copy_class_expr x1,\n Option.map (fun x -> copy_loc (fun x -> x) x) x2 )\n | Ast_412.Parsetree.Pcf_val x0 ->\n Ast_413.Parsetree.Pcf_val\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_mutable_flag x1, copy_class_field_kind x2))\n | Ast_412.Parsetree.Pcf_method x0 ->\n Ast_413.Parsetree.Pcf_method\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_private_flag x1, copy_class_field_kind x2))\n | Ast_412.Parsetree.Pcf_constraint x0 ->\n Ast_413.Parsetree.Pcf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | Ast_412.Parsetree.Pcf_initializer x0 ->\n Ast_413.Parsetree.Pcf_initializer (copy_expression x0)\n | Ast_412.Parsetree.Pcf_attribute x0 ->\n Ast_413.Parsetree.Pcf_attribute (copy_attribute x0)\n | Ast_412.Parsetree.Pcf_extension x0 ->\n Ast_413.Parsetree.Pcf_extension (copy_extension x0)\n\nand copy_class_field_kind :\n Ast_412.Parsetree.class_field_kind -> Ast_413.Parsetree.class_field_kind =\n function\n | Ast_412.Parsetree.Cfk_virtual x0 ->\n Ast_413.Parsetree.Cfk_virtual (copy_core_type x0)\n | Ast_412.Parsetree.Cfk_concrete (x0, x1) ->\n Ast_413.Parsetree.Cfk_concrete (copy_override_flag x0, copy_expression x1)\n\nand copy_open_declaration :\n Ast_412.Parsetree.open_declaration -> Ast_413.Parsetree.open_declaration =\n fun x -> copy_open_infos copy_module_expr x\n\nand copy_module_binding :\n Ast_412.Parsetree.module_binding -> Ast_413.Parsetree.module_binding =\n fun {\n Ast_412.Parsetree.pmb_name;\n Ast_412.Parsetree.pmb_expr;\n Ast_412.Parsetree.pmb_attributes;\n Ast_412.Parsetree.pmb_loc;\n } ->\n {\n Ast_413.Parsetree.pmb_name =\n copy_loc (fun x -> Option.map (fun x -> x) x) pmb_name;\n Ast_413.Parsetree.pmb_expr = copy_module_expr pmb_expr;\n Ast_413.Parsetree.pmb_attributes = copy_attributes pmb_attributes;\n Ast_413.Parsetree.pmb_loc = copy_location pmb_loc;\n }\n\nand copy_module_expr :\n Ast_412.Parsetree.module_expr -> Ast_413.Parsetree.module_expr =\n fun {\n Ast_412.Parsetree.pmod_desc;\n Ast_412.Parsetree.pmod_loc;\n Ast_412.Parsetree.pmod_attributes;\n } ->\n {\n Ast_413.Parsetree.pmod_desc = copy_module_expr_desc pmod_desc;\n Ast_413.Parsetree.pmod_loc = copy_location pmod_loc;\n Ast_413.Parsetree.pmod_attributes = copy_attributes pmod_attributes;\n }\n\nand copy_module_expr_desc :\n Ast_412.Parsetree.module_expr_desc -> Ast_413.Parsetree.module_expr_desc =\n function\n | Ast_412.Parsetree.Pmod_ident x0 ->\n Ast_413.Parsetree.Pmod_ident (copy_loc copy_Longident_t x0)\n | Ast_412.Parsetree.Pmod_structure x0 ->\n Ast_413.Parsetree.Pmod_structure (copy_structure x0)\n | Ast_412.Parsetree.Pmod_functor (x0, x1) ->\n Ast_413.Parsetree.Pmod_functor\n (copy_functor_parameter x0, copy_module_expr x1)\n | Ast_412.Parsetree.Pmod_apply (x0, x1) ->\n Ast_413.Parsetree.Pmod_apply (copy_module_expr x0, copy_module_expr x1)\n | Ast_412.Parsetree.Pmod_constraint (x0, x1) ->\n Ast_413.Parsetree.Pmod_constraint\n (copy_module_expr x0, copy_module_type x1)\n | Ast_412.Parsetree.Pmod_unpack x0 ->\n Ast_413.Parsetree.Pmod_unpack (copy_expression x0)\n | Ast_412.Parsetree.Pmod_extension x0 ->\n Ast_413.Parsetree.Pmod_extension (copy_extension x0)\n\nand copy_functor_parameter :\n Ast_412.Parsetree.functor_parameter -> Ast_413.Parsetree.functor_parameter =\n function\n | Ast_412.Parsetree.Unit -> Ast_413.Parsetree.Unit\n | Ast_412.Parsetree.Named (x0, x1) ->\n Ast_413.Parsetree.Named\n (copy_loc (fun x -> Option.map (fun x -> x) x) x0, copy_module_type x1)\n\nand copy_module_type :\n Ast_412.Parsetree.module_type -> Ast_413.Parsetree.module_type =\n fun {\n Ast_412.Parsetree.pmty_desc;\n Ast_412.Parsetree.pmty_loc;\n Ast_412.Parsetree.pmty_attributes;\n } ->\n {\n Ast_413.Parsetree.pmty_desc = copy_module_type_desc pmty_desc;\n Ast_413.Parsetree.pmty_loc = copy_location pmty_loc;\n Ast_413.Parsetree.pmty_attributes = copy_attributes pmty_attributes;\n }\n\nand copy_module_type_desc :\n Ast_412.Parsetree.module_type_desc -> Ast_413.Parsetree.module_type_desc =\n function\n | Ast_412.Parsetree.Pmty_ident x0 ->\n Ast_413.Parsetree.Pmty_ident (copy_loc copy_Longident_t x0)\n | Ast_412.Parsetree.Pmty_signature x0 ->\n Ast_413.Parsetree.Pmty_signature (copy_signature x0)\n | Ast_412.Parsetree.Pmty_functor (x0, x1) ->\n Ast_413.Parsetree.Pmty_functor\n (copy_functor_parameter x0, copy_module_type x1)\n | Ast_412.Parsetree.Pmty_with (x0, x1) ->\n Ast_413.Parsetree.Pmty_with\n (copy_module_type x0, List.map copy_with_constraint x1)\n | Ast_412.Parsetree.Pmty_typeof x0 ->\n Ast_413.Parsetree.Pmty_typeof (copy_module_expr x0)\n | Ast_412.Parsetree.Pmty_extension x0 ->\n Ast_413.Parsetree.Pmty_extension (copy_extension x0)\n | Ast_412.Parsetree.Pmty_alias x0 ->\n Ast_413.Parsetree.Pmty_alias (copy_loc copy_Longident_t x0)\n\nand copy_with_constraint :\n Ast_412.Parsetree.with_constraint -> Ast_413.Parsetree.with_constraint =\n function\n | Ast_412.Parsetree.Pwith_type (x0, x1) ->\n Ast_413.Parsetree.Pwith_type\n (copy_loc copy_Longident_t x0, copy_type_declaration x1)\n | Ast_412.Parsetree.Pwith_module (x0, x1) ->\n Ast_413.Parsetree.Pwith_module\n (copy_loc copy_Longident_t x0, copy_loc copy_Longident_t x1)\n | Ast_412.Parsetree.Pwith_typesubst (x0, x1) ->\n Ast_413.Parsetree.Pwith_typesubst\n (copy_loc copy_Longident_t x0, copy_type_declaration x1)\n | Ast_412.Parsetree.Pwith_modsubst (x0, x1) ->\n Ast_413.Parsetree.Pwith_modsubst\n (copy_loc copy_Longident_t x0, copy_loc copy_Longident_t x1)\n\nand copy_signature : Ast_412.Parsetree.signature -> Ast_413.Parsetree.signature\n =\n fun x -> List.map copy_signature_item x\n\nand copy_signature_item :\n Ast_412.Parsetree.signature_item -> Ast_413.Parsetree.signature_item =\n fun { Ast_412.Parsetree.psig_desc; Ast_412.Parsetree.psig_loc } ->\n {\n Ast_413.Parsetree.psig_desc = copy_signature_item_desc psig_desc;\n Ast_413.Parsetree.psig_loc = copy_location psig_loc;\n }\n\nand copy_signature_item_desc :\n Ast_412.Parsetree.signature_item_desc ->\n Ast_413.Parsetree.signature_item_desc = function\n | Ast_412.Parsetree.Psig_value x0 ->\n Ast_413.Parsetree.Psig_value (copy_value_description x0)\n | Ast_412.Parsetree.Psig_type (x0, x1) ->\n Ast_413.Parsetree.Psig_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | Ast_412.Parsetree.Psig_typesubst x0 ->\n Ast_413.Parsetree.Psig_typesubst (List.map copy_type_declaration x0)\n | Ast_412.Parsetree.Psig_typext x0 ->\n Ast_413.Parsetree.Psig_typext (copy_type_extension x0)\n | Ast_412.Parsetree.Psig_exception x0 ->\n Ast_413.Parsetree.Psig_exception (copy_type_exception x0)\n | Ast_412.Parsetree.Psig_module x0 ->\n Ast_413.Parsetree.Psig_module (copy_module_declaration x0)\n | Ast_412.Parsetree.Psig_modsubst x0 ->\n Ast_413.Parsetree.Psig_modsubst (copy_module_substitution x0)\n | Ast_412.Parsetree.Psig_recmodule x0 ->\n Ast_413.Parsetree.Psig_recmodule (List.map copy_module_declaration x0)\n | Ast_412.Parsetree.Psig_modtype x0 ->\n Ast_413.Parsetree.Psig_modtype (copy_module_type_declaration x0)\n | Ast_412.Parsetree.Psig_open x0 ->\n Ast_413.Parsetree.Psig_open (copy_open_description x0)\n | Ast_412.Parsetree.Psig_include x0 ->\n Ast_413.Parsetree.Psig_include (copy_include_description x0)\n | Ast_412.Parsetree.Psig_class x0 ->\n Ast_413.Parsetree.Psig_class (List.map copy_class_description x0)\n | Ast_412.Parsetree.Psig_class_type x0 ->\n Ast_413.Parsetree.Psig_class_type\n (List.map copy_class_type_declaration x0)\n | Ast_412.Parsetree.Psig_attribute x0 ->\n Ast_413.Parsetree.Psig_attribute (copy_attribute x0)\n | Ast_412.Parsetree.Psig_extension (x0, x1) ->\n Ast_413.Parsetree.Psig_extension (copy_extension x0, copy_attributes x1)\n\nand copy_class_type_declaration :\n Ast_412.Parsetree.class_type_declaration ->\n Ast_413.Parsetree.class_type_declaration =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_description :\n Ast_412.Parsetree.class_description -> Ast_413.Parsetree.class_description =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_type :\n Ast_412.Parsetree.class_type -> Ast_413.Parsetree.class_type =\n fun {\n Ast_412.Parsetree.pcty_desc;\n Ast_412.Parsetree.pcty_loc;\n Ast_412.Parsetree.pcty_attributes;\n } ->\n {\n Ast_413.Parsetree.pcty_desc = copy_class_type_desc pcty_desc;\n Ast_413.Parsetree.pcty_loc = copy_location pcty_loc;\n Ast_413.Parsetree.pcty_attributes = copy_attributes pcty_attributes;\n }\n\nand copy_class_type_desc :\n Ast_412.Parsetree.class_type_desc -> Ast_413.Parsetree.class_type_desc =\n function\n | Ast_412.Parsetree.Pcty_constr (x0, x1) ->\n Ast_413.Parsetree.Pcty_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_412.Parsetree.Pcty_signature x0 ->\n Ast_413.Parsetree.Pcty_signature (copy_class_signature x0)\n | Ast_412.Parsetree.Pcty_arrow (x0, x1, x2) ->\n Ast_413.Parsetree.Pcty_arrow\n (copy_arg_label x0, copy_core_type x1, copy_class_type x2)\n | Ast_412.Parsetree.Pcty_extension x0 ->\n Ast_413.Parsetree.Pcty_extension (copy_extension x0)\n | Ast_412.Parsetree.Pcty_open (x0, x1) ->\n Ast_413.Parsetree.Pcty_open (copy_open_description x0, copy_class_type x1)\n\nand copy_class_signature :\n Ast_412.Parsetree.class_signature -> Ast_413.Parsetree.class_signature =\n fun { Ast_412.Parsetree.pcsig_self; Ast_412.Parsetree.pcsig_fields } ->\n {\n Ast_413.Parsetree.pcsig_self = copy_core_type pcsig_self;\n Ast_413.Parsetree.pcsig_fields = List.map copy_class_type_field pcsig_fields;\n }\n\nand copy_class_type_field :\n Ast_412.Parsetree.class_type_field -> Ast_413.Parsetree.class_type_field =\n fun {\n Ast_412.Parsetree.pctf_desc;\n Ast_412.Parsetree.pctf_loc;\n Ast_412.Parsetree.pctf_attributes;\n } ->\n {\n Ast_413.Parsetree.pctf_desc = copy_class_type_field_desc pctf_desc;\n Ast_413.Parsetree.pctf_loc = copy_location pctf_loc;\n Ast_413.Parsetree.pctf_attributes = copy_attributes pctf_attributes;\n }\n\nand copy_class_type_field_desc :\n Ast_412.Parsetree.class_type_field_desc ->\n Ast_413.Parsetree.class_type_field_desc = function\n | Ast_412.Parsetree.Pctf_inherit x0 ->\n Ast_413.Parsetree.Pctf_inherit (copy_class_type x0)\n | Ast_412.Parsetree.Pctf_val x0 ->\n Ast_413.Parsetree.Pctf_val\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_mutable_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | Ast_412.Parsetree.Pctf_method x0 ->\n Ast_413.Parsetree.Pctf_method\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_private_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | Ast_412.Parsetree.Pctf_constraint x0 ->\n Ast_413.Parsetree.Pctf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | Ast_412.Parsetree.Pctf_attribute x0 ->\n Ast_413.Parsetree.Pctf_attribute (copy_attribute x0)\n | Ast_412.Parsetree.Pctf_extension x0 ->\n Ast_413.Parsetree.Pctf_extension (copy_extension x0)\n\nand copy_extension : Ast_412.Parsetree.extension -> Ast_413.Parsetree.extension\n =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_class_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_412.Parsetree.class_infos ->\n 'g0 Ast_413.Parsetree.class_infos =\n fun f0\n {\n Ast_412.Parsetree.pci_virt;\n Ast_412.Parsetree.pci_params;\n Ast_412.Parsetree.pci_name;\n Ast_412.Parsetree.pci_expr;\n Ast_412.Parsetree.pci_loc;\n Ast_412.Parsetree.pci_attributes;\n } ->\n {\n Ast_413.Parsetree.pci_virt = copy_virtual_flag pci_virt;\n Ast_413.Parsetree.pci_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n ( copy_core_type x0,\n let x0, x1 = x1 in\n (copy_variance x0, copy_injectivity x1) ))\n pci_params;\n Ast_413.Parsetree.pci_name = copy_loc (fun x -> x) pci_name;\n Ast_413.Parsetree.pci_expr = f0 pci_expr;\n Ast_413.Parsetree.pci_loc = copy_location pci_loc;\n Ast_413.Parsetree.pci_attributes = copy_attributes pci_attributes;\n }\n\nand copy_virtual_flag :\n Ast_412.Asttypes.virtual_flag -> Ast_413.Asttypes.virtual_flag = function\n | Ast_412.Asttypes.Virtual -> Ast_413.Asttypes.Virtual\n | Ast_412.Asttypes.Concrete -> Ast_413.Asttypes.Concrete\n\nand copy_include_description :\n Ast_412.Parsetree.include_description ->\n Ast_413.Parsetree.include_description =\n fun x -> copy_include_infos copy_module_type x\n\nand copy_include_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_412.Parsetree.include_infos ->\n 'g0 Ast_413.Parsetree.include_infos =\n fun f0\n {\n Ast_412.Parsetree.pincl_mod;\n Ast_412.Parsetree.pincl_loc;\n Ast_412.Parsetree.pincl_attributes;\n } ->\n {\n Ast_413.Parsetree.pincl_mod = f0 pincl_mod;\n Ast_413.Parsetree.pincl_loc = copy_location pincl_loc;\n Ast_413.Parsetree.pincl_attributes = copy_attributes pincl_attributes;\n }\n\nand copy_open_description :\n Ast_412.Parsetree.open_description -> Ast_413.Parsetree.open_description =\n fun x -> copy_open_infos (fun x -> copy_loc copy_Longident_t x) x\n\nand copy_open_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_412.Parsetree.open_infos ->\n 'g0 Ast_413.Parsetree.open_infos =\n fun f0\n {\n Ast_412.Parsetree.popen_expr;\n Ast_412.Parsetree.popen_override;\n Ast_412.Parsetree.popen_loc;\n Ast_412.Parsetree.popen_attributes;\n } ->\n {\n Ast_413.Parsetree.popen_expr = f0 popen_expr;\n Ast_413.Parsetree.popen_override = copy_override_flag popen_override;\n Ast_413.Parsetree.popen_loc = copy_location popen_loc;\n Ast_413.Parsetree.popen_attributes = copy_attributes popen_attributes;\n }\n\nand copy_override_flag :\n Ast_412.Asttypes.override_flag -> Ast_413.Asttypes.override_flag = function\n | Ast_412.Asttypes.Override -> Ast_413.Asttypes.Override\n | Ast_412.Asttypes.Fresh -> Ast_413.Asttypes.Fresh\n\nand copy_module_type_declaration :\n Ast_412.Parsetree.module_type_declaration ->\n Ast_413.Parsetree.module_type_declaration =\n fun {\n Ast_412.Parsetree.pmtd_name;\n Ast_412.Parsetree.pmtd_type;\n Ast_412.Parsetree.pmtd_attributes;\n Ast_412.Parsetree.pmtd_loc;\n } ->\n {\n Ast_413.Parsetree.pmtd_name = copy_loc (fun x -> x) pmtd_name;\n Ast_413.Parsetree.pmtd_type = Option.map copy_module_type pmtd_type;\n Ast_413.Parsetree.pmtd_attributes = copy_attributes pmtd_attributes;\n Ast_413.Parsetree.pmtd_loc = copy_location pmtd_loc;\n }\n\nand copy_module_substitution :\n Ast_412.Parsetree.module_substitution ->\n Ast_413.Parsetree.module_substitution =\n fun {\n Ast_412.Parsetree.pms_name;\n Ast_412.Parsetree.pms_manifest;\n Ast_412.Parsetree.pms_attributes;\n Ast_412.Parsetree.pms_loc;\n } ->\n {\n Ast_413.Parsetree.pms_name = copy_loc (fun x -> x) pms_name;\n Ast_413.Parsetree.pms_manifest = copy_loc copy_Longident_t pms_manifest;\n Ast_413.Parsetree.pms_attributes = copy_attributes pms_attributes;\n Ast_413.Parsetree.pms_loc = copy_location pms_loc;\n }\n\nand copy_module_declaration :\n Ast_412.Parsetree.module_declaration -> Ast_413.Parsetree.module_declaration\n =\n fun {\n Ast_412.Parsetree.pmd_name;\n Ast_412.Parsetree.pmd_type;\n Ast_412.Parsetree.pmd_attributes;\n Ast_412.Parsetree.pmd_loc;\n } ->\n {\n Ast_413.Parsetree.pmd_name =\n copy_loc (fun x -> Option.map (fun x -> x) x) pmd_name;\n Ast_413.Parsetree.pmd_type = copy_module_type pmd_type;\n Ast_413.Parsetree.pmd_attributes = copy_attributes pmd_attributes;\n Ast_413.Parsetree.pmd_loc = copy_location pmd_loc;\n }\n\nand copy_type_exception :\n Ast_412.Parsetree.type_exception -> Ast_413.Parsetree.type_exception =\n fun {\n Ast_412.Parsetree.ptyexn_constructor;\n Ast_412.Parsetree.ptyexn_loc;\n Ast_412.Parsetree.ptyexn_attributes;\n } ->\n {\n Ast_413.Parsetree.ptyexn_constructor =\n copy_extension_constructor ptyexn_constructor;\n Ast_413.Parsetree.ptyexn_loc = copy_location ptyexn_loc;\n Ast_413.Parsetree.ptyexn_attributes = copy_attributes ptyexn_attributes;\n }\n\nand copy_type_extension :\n Ast_412.Parsetree.type_extension -> Ast_413.Parsetree.type_extension =\n fun {\n Ast_412.Parsetree.ptyext_path;\n Ast_412.Parsetree.ptyext_params;\n Ast_412.Parsetree.ptyext_constructors;\n Ast_412.Parsetree.ptyext_private;\n Ast_412.Parsetree.ptyext_loc;\n Ast_412.Parsetree.ptyext_attributes;\n } ->\n {\n Ast_413.Parsetree.ptyext_path = copy_loc copy_Longident_t ptyext_path;\n Ast_413.Parsetree.ptyext_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n ( copy_core_type x0,\n let x0, x1 = x1 in\n (copy_variance x0, copy_injectivity x1) ))\n ptyext_params;\n Ast_413.Parsetree.ptyext_constructors =\n List.map copy_extension_constructor ptyext_constructors;\n Ast_413.Parsetree.ptyext_private = copy_private_flag ptyext_private;\n Ast_413.Parsetree.ptyext_loc = copy_location ptyext_loc;\n Ast_413.Parsetree.ptyext_attributes = copy_attributes ptyext_attributes;\n }\n\nand copy_extension_constructor :\n Ast_412.Parsetree.extension_constructor ->\n Ast_413.Parsetree.extension_constructor =\n fun {\n Ast_412.Parsetree.pext_name;\n Ast_412.Parsetree.pext_kind;\n Ast_412.Parsetree.pext_loc;\n Ast_412.Parsetree.pext_attributes;\n } ->\n {\n Ast_413.Parsetree.pext_name = copy_loc (fun x -> x) pext_name;\n Ast_413.Parsetree.pext_kind = copy_extension_constructor_kind pext_kind;\n Ast_413.Parsetree.pext_loc = copy_location pext_loc;\n Ast_413.Parsetree.pext_attributes = copy_attributes pext_attributes;\n }\n\nand copy_extension_constructor_kind :\n Ast_412.Parsetree.extension_constructor_kind ->\n Ast_413.Parsetree.extension_constructor_kind = function\n | Ast_412.Parsetree.Pext_decl (x0, x1) ->\n Ast_413.Parsetree.Pext_decl\n (copy_constructor_arguments x0, Option.map copy_core_type x1)\n | Ast_412.Parsetree.Pext_rebind x0 ->\n Ast_413.Parsetree.Pext_rebind (copy_loc copy_Longident_t x0)\n\nand copy_type_declaration :\n Ast_412.Parsetree.type_declaration -> Ast_413.Parsetree.type_declaration =\n fun {\n Ast_412.Parsetree.ptype_name;\n Ast_412.Parsetree.ptype_params;\n Ast_412.Parsetree.ptype_cstrs;\n Ast_412.Parsetree.ptype_kind;\n Ast_412.Parsetree.ptype_private;\n Ast_412.Parsetree.ptype_manifest;\n Ast_412.Parsetree.ptype_attributes;\n Ast_412.Parsetree.ptype_loc;\n } ->\n {\n Ast_413.Parsetree.ptype_name = copy_loc (fun x -> x) ptype_name;\n Ast_413.Parsetree.ptype_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n ( copy_core_type x0,\n let x0, x1 = x1 in\n (copy_variance x0, copy_injectivity x1) ))\n ptype_params;\n Ast_413.Parsetree.ptype_cstrs =\n List.map\n (fun x ->\n let x0, x1, x2 = x in\n (copy_core_type x0, copy_core_type x1, copy_location x2))\n ptype_cstrs;\n Ast_413.Parsetree.ptype_kind = copy_type_kind ptype_kind;\n Ast_413.Parsetree.ptype_private = copy_private_flag ptype_private;\n Ast_413.Parsetree.ptype_manifest = Option.map copy_core_type ptype_manifest;\n Ast_413.Parsetree.ptype_attributes = copy_attributes ptype_attributes;\n Ast_413.Parsetree.ptype_loc = copy_location ptype_loc;\n }\n\nand copy_private_flag :\n Ast_412.Asttypes.private_flag -> Ast_413.Asttypes.private_flag = function\n | Ast_412.Asttypes.Private -> Ast_413.Asttypes.Private\n | Ast_412.Asttypes.Public -> Ast_413.Asttypes.Public\n\nand copy_type_kind : Ast_412.Parsetree.type_kind -> Ast_413.Parsetree.type_kind\n = function\n | Ast_412.Parsetree.Ptype_abstract -> Ast_413.Parsetree.Ptype_abstract\n | Ast_412.Parsetree.Ptype_variant x0 ->\n Ast_413.Parsetree.Ptype_variant (List.map copy_constructor_declaration x0)\n | Ast_412.Parsetree.Ptype_record x0 ->\n Ast_413.Parsetree.Ptype_record (List.map copy_label_declaration x0)\n | Ast_412.Parsetree.Ptype_open -> Ast_413.Parsetree.Ptype_open\n\nand copy_constructor_declaration :\n Ast_412.Parsetree.constructor_declaration ->\n Ast_413.Parsetree.constructor_declaration =\n fun {\n Ast_412.Parsetree.pcd_name;\n Ast_412.Parsetree.pcd_args;\n Ast_412.Parsetree.pcd_res;\n Ast_412.Parsetree.pcd_loc;\n Ast_412.Parsetree.pcd_attributes;\n } ->\n {\n Ast_413.Parsetree.pcd_name = copy_loc (fun x -> x) pcd_name;\n Ast_413.Parsetree.pcd_args = copy_constructor_arguments pcd_args;\n Ast_413.Parsetree.pcd_res = Option.map copy_core_type pcd_res;\n Ast_413.Parsetree.pcd_loc = copy_location pcd_loc;\n Ast_413.Parsetree.pcd_attributes = copy_attributes pcd_attributes;\n }\n\nand copy_constructor_arguments :\n Ast_412.Parsetree.constructor_arguments ->\n Ast_413.Parsetree.constructor_arguments = function\n | Ast_412.Parsetree.Pcstr_tuple x0 ->\n Ast_413.Parsetree.Pcstr_tuple (List.map copy_core_type x0)\n | Ast_412.Parsetree.Pcstr_record x0 ->\n Ast_413.Parsetree.Pcstr_record (List.map copy_label_declaration x0)\n\nand copy_label_declaration :\n Ast_412.Parsetree.label_declaration -> Ast_413.Parsetree.label_declaration =\n fun {\n Ast_412.Parsetree.pld_name;\n Ast_412.Parsetree.pld_mutable;\n Ast_412.Parsetree.pld_type;\n Ast_412.Parsetree.pld_loc;\n Ast_412.Parsetree.pld_attributes;\n } ->\n {\n Ast_413.Parsetree.pld_name = copy_loc (fun x -> x) pld_name;\n Ast_413.Parsetree.pld_mutable = copy_mutable_flag pld_mutable;\n Ast_413.Parsetree.pld_type = copy_core_type pld_type;\n Ast_413.Parsetree.pld_loc = copy_location pld_loc;\n Ast_413.Parsetree.pld_attributes = copy_attributes pld_attributes;\n }\n\nand copy_mutable_flag :\n Ast_412.Asttypes.mutable_flag -> Ast_413.Asttypes.mutable_flag = function\n | Ast_412.Asttypes.Immutable -> Ast_413.Asttypes.Immutable\n | Ast_412.Asttypes.Mutable -> Ast_413.Asttypes.Mutable\n\nand copy_injectivity :\n Ast_412.Asttypes.injectivity -> Ast_413.Asttypes.injectivity = function\n | Ast_412.Asttypes.Injective -> Ast_413.Asttypes.Injective\n | Ast_412.Asttypes.NoInjectivity -> Ast_413.Asttypes.NoInjectivity\n\nand copy_variance : Ast_412.Asttypes.variance -> Ast_413.Asttypes.variance =\n function\n | Ast_412.Asttypes.Covariant -> Ast_413.Asttypes.Covariant\n | Ast_412.Asttypes.Contravariant -> Ast_413.Asttypes.Contravariant\n | Ast_412.Asttypes.NoVariance -> Ast_413.Asttypes.NoVariance\n\nand copy_value_description :\n Ast_412.Parsetree.value_description -> Ast_413.Parsetree.value_description =\n fun {\n Ast_412.Parsetree.pval_name;\n Ast_412.Parsetree.pval_type;\n Ast_412.Parsetree.pval_prim;\n Ast_412.Parsetree.pval_attributes;\n Ast_412.Parsetree.pval_loc;\n } ->\n {\n Ast_413.Parsetree.pval_name = copy_loc (fun x -> x) pval_name;\n Ast_413.Parsetree.pval_type = copy_core_type pval_type;\n Ast_413.Parsetree.pval_prim = List.map (fun x -> x) pval_prim;\n Ast_413.Parsetree.pval_attributes = copy_attributes pval_attributes;\n Ast_413.Parsetree.pval_loc = copy_location pval_loc;\n }\n\nand copy_object_field_desc :\n Ast_412.Parsetree.object_field_desc -> Ast_413.Parsetree.object_field_desc =\n function\n | Ast_412.Parsetree.Otag (x0, x1) ->\n Ast_413.Parsetree.Otag (copy_loc copy_label x0, copy_core_type x1)\n | Ast_412.Parsetree.Oinherit x0 ->\n Ast_413.Parsetree.Oinherit (copy_core_type x0)\n\nand copy_arg_label : Ast_412.Asttypes.arg_label -> Ast_413.Asttypes.arg_label =\n function\n | Ast_412.Asttypes.Nolabel -> Ast_413.Asttypes.Nolabel\n | Ast_412.Asttypes.Labelled x0 -> Ast_413.Asttypes.Labelled x0\n | Ast_412.Asttypes.Optional x0 -> Ast_413.Asttypes.Optional x0\n\nand copy_closed_flag :\n Ast_412.Asttypes.closed_flag -> Ast_413.Asttypes.closed_flag = function\n | Ast_412.Asttypes.Closed -> Ast_413.Asttypes.Closed\n | Ast_412.Asttypes.Open -> Ast_413.Asttypes.Open\n\nand copy_label : Ast_412.Asttypes.label -> Ast_413.Asttypes.label = fun x -> x\n\nand copy_rec_flag : Ast_412.Asttypes.rec_flag -> Ast_413.Asttypes.rec_flag =\n function\n | Ast_412.Asttypes.Nonrecursive -> Ast_413.Asttypes.Nonrecursive\n | Ast_412.Asttypes.Recursive -> Ast_413.Asttypes.Recursive\n\nand copy_constant : Ast_412.Parsetree.constant -> Ast_413.Parsetree.constant =\n function\n | Ast_412.Parsetree.Pconst_integer (x0, x1) ->\n Ast_413.Parsetree.Pconst_integer (x0, Option.map (fun x -> x) x1)\n | Ast_412.Parsetree.Pconst_char x0 -> Ast_413.Parsetree.Pconst_char x0\n | Ast_412.Parsetree.Pconst_string (x0, x1, x2) ->\n Ast_413.Parsetree.Pconst_string\n (x0, copy_location x1, Option.map (fun x -> x) x2)\n | Ast_412.Parsetree.Pconst_float (x0, x1) ->\n Ast_413.Parsetree.Pconst_float (x0, Option.map (fun x -> x) x1)\n\nand copy_Longident_t : Longident.t -> Longident.t = fun x -> x\n\nand copy_loc :\n 'f0 'g0.\n ('f0 -> 'g0) -> 'f0 Ast_412.Asttypes.loc -> 'g0 Ast_413.Asttypes.loc =\n fun f0 { Ast_412.Asttypes.txt; Ast_412.Asttypes.loc } ->\n { Ast_413.Asttypes.txt = f0 txt; Ast_413.Asttypes.loc = copy_location loc }\n\nand copy_location : Location.t -> Location.t = fun x -> x\n","open Stdlib0\nmodule From = Ast_412\nmodule To = Ast_411\n\nlet rec copy_toplevel_phrase :\n Ast_412.Parsetree.toplevel_phrase -> Ast_411.Parsetree.toplevel_phrase =\n function\n | Ast_412.Parsetree.Ptop_def x0 ->\n Ast_411.Parsetree.Ptop_def (copy_structure x0)\n | Ast_412.Parsetree.Ptop_dir x0 ->\n Ast_411.Parsetree.Ptop_dir (copy_toplevel_directive x0)\n\nand copy_toplevel_directive :\n Ast_412.Parsetree.toplevel_directive -> Ast_411.Parsetree.toplevel_directive\n =\n fun {\n Ast_412.Parsetree.pdir_name;\n Ast_412.Parsetree.pdir_arg;\n Ast_412.Parsetree.pdir_loc;\n } ->\n {\n Ast_411.Parsetree.pdir_name = copy_loc (fun x -> x) pdir_name;\n Ast_411.Parsetree.pdir_arg = Option.map copy_directive_argument pdir_arg;\n Ast_411.Parsetree.pdir_loc = copy_location pdir_loc;\n }\n\nand copy_directive_argument :\n Ast_412.Parsetree.directive_argument -> Ast_411.Parsetree.directive_argument\n =\n fun { Ast_412.Parsetree.pdira_desc; Ast_412.Parsetree.pdira_loc } ->\n {\n Ast_411.Parsetree.pdira_desc = copy_directive_argument_desc pdira_desc;\n Ast_411.Parsetree.pdira_loc = copy_location pdira_loc;\n }\n\nand copy_directive_argument_desc :\n Ast_412.Parsetree.directive_argument_desc ->\n Ast_411.Parsetree.directive_argument_desc = function\n | Ast_412.Parsetree.Pdir_string x0 -> Ast_411.Parsetree.Pdir_string x0\n | Ast_412.Parsetree.Pdir_int (x0, x1) ->\n Ast_411.Parsetree.Pdir_int (x0, Option.map (fun x -> x) x1)\n | Ast_412.Parsetree.Pdir_ident x0 ->\n Ast_411.Parsetree.Pdir_ident (copy_Longident_t x0)\n | Ast_412.Parsetree.Pdir_bool x0 -> Ast_411.Parsetree.Pdir_bool x0\n\nand copy_expression :\n Ast_412.Parsetree.expression -> Ast_411.Parsetree.expression =\n fun {\n Ast_412.Parsetree.pexp_desc;\n Ast_412.Parsetree.pexp_loc;\n Ast_412.Parsetree.pexp_loc_stack;\n Ast_412.Parsetree.pexp_attributes;\n } ->\n {\n Ast_411.Parsetree.pexp_desc = copy_expression_desc pexp_desc;\n Ast_411.Parsetree.pexp_loc = copy_location pexp_loc;\n Ast_411.Parsetree.pexp_loc_stack = copy_location_stack pexp_loc_stack;\n Ast_411.Parsetree.pexp_attributes = copy_attributes pexp_attributes;\n }\n\nand copy_expression_desc :\n Ast_412.Parsetree.expression_desc -> Ast_411.Parsetree.expression_desc =\n function\n | Ast_412.Parsetree.Pexp_ident x0 ->\n Ast_411.Parsetree.Pexp_ident (copy_loc copy_Longident_t x0)\n | Ast_412.Parsetree.Pexp_constant x0 ->\n Ast_411.Parsetree.Pexp_constant (copy_constant x0)\n | Ast_412.Parsetree.Pexp_let (x0, x1, x2) ->\n Ast_411.Parsetree.Pexp_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_expression x2)\n | Ast_412.Parsetree.Pexp_function x0 ->\n Ast_411.Parsetree.Pexp_function (List.map copy_case x0)\n | Ast_412.Parsetree.Pexp_fun (x0, x1, x2, x3) ->\n Ast_411.Parsetree.Pexp_fun\n ( copy_arg_label x0,\n Option.map copy_expression x1,\n copy_pattern x2,\n copy_expression x3 )\n | Ast_412.Parsetree.Pexp_apply (x0, x1) ->\n Ast_411.Parsetree.Pexp_apply\n ( copy_expression x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | Ast_412.Parsetree.Pexp_match (x0, x1) ->\n Ast_411.Parsetree.Pexp_match (copy_expression x0, List.map copy_case x1)\n | Ast_412.Parsetree.Pexp_try (x0, x1) ->\n Ast_411.Parsetree.Pexp_try (copy_expression x0, List.map copy_case x1)\n | Ast_412.Parsetree.Pexp_tuple x0 ->\n Ast_411.Parsetree.Pexp_tuple (List.map copy_expression x0)\n | Ast_412.Parsetree.Pexp_construct (x0, x1) ->\n Ast_411.Parsetree.Pexp_construct\n (copy_loc copy_Longident_t x0, Option.map copy_expression x1)\n | Ast_412.Parsetree.Pexp_variant (x0, x1) ->\n Ast_411.Parsetree.Pexp_variant\n (copy_label x0, Option.map copy_expression x1)\n | Ast_412.Parsetree.Pexp_record (x0, x1) ->\n Ast_411.Parsetree.Pexp_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_expression x1))\n x0,\n Option.map copy_expression x1 )\n | Ast_412.Parsetree.Pexp_field (x0, x1) ->\n Ast_411.Parsetree.Pexp_field\n (copy_expression x0, copy_loc copy_Longident_t x1)\n | Ast_412.Parsetree.Pexp_setfield (x0, x1, x2) ->\n Ast_411.Parsetree.Pexp_setfield\n (copy_expression x0, copy_loc copy_Longident_t x1, copy_expression x2)\n | Ast_412.Parsetree.Pexp_array x0 ->\n Ast_411.Parsetree.Pexp_array (List.map copy_expression x0)\n | Ast_412.Parsetree.Pexp_ifthenelse (x0, x1, x2) ->\n Ast_411.Parsetree.Pexp_ifthenelse\n (copy_expression x0, copy_expression x1, Option.map copy_expression x2)\n | Ast_412.Parsetree.Pexp_sequence (x0, x1) ->\n Ast_411.Parsetree.Pexp_sequence (copy_expression x0, copy_expression x1)\n | Ast_412.Parsetree.Pexp_while (x0, x1) ->\n Ast_411.Parsetree.Pexp_while (copy_expression x0, copy_expression x1)\n | Ast_412.Parsetree.Pexp_for (x0, x1, x2, x3, x4) ->\n Ast_411.Parsetree.Pexp_for\n ( copy_pattern x0,\n copy_expression x1,\n copy_expression x2,\n copy_direction_flag x3,\n copy_expression x4 )\n | Ast_412.Parsetree.Pexp_constraint (x0, x1) ->\n Ast_411.Parsetree.Pexp_constraint (copy_expression x0, copy_core_type x1)\n | Ast_412.Parsetree.Pexp_coerce (x0, x1, x2) ->\n Ast_411.Parsetree.Pexp_coerce\n (copy_expression x0, Option.map copy_core_type x1, copy_core_type x2)\n | Ast_412.Parsetree.Pexp_send (x0, x1) ->\n Ast_411.Parsetree.Pexp_send (copy_expression x0, copy_loc copy_label x1)\n | Ast_412.Parsetree.Pexp_new x0 ->\n Ast_411.Parsetree.Pexp_new (copy_loc copy_Longident_t x0)\n | Ast_412.Parsetree.Pexp_setinstvar (x0, x1) ->\n Ast_411.Parsetree.Pexp_setinstvar\n (copy_loc copy_label x0, copy_expression x1)\n | Ast_412.Parsetree.Pexp_override x0 ->\n Ast_411.Parsetree.Pexp_override\n (List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_label x0, copy_expression x1))\n x0)\n | Ast_412.Parsetree.Pexp_letmodule (x0, x1, x2) ->\n Ast_411.Parsetree.Pexp_letmodule\n ( copy_loc (fun x -> Option.map (fun x -> x) x) x0,\n copy_module_expr x1,\n copy_expression x2 )\n | Ast_412.Parsetree.Pexp_letexception (x0, x1) ->\n Ast_411.Parsetree.Pexp_letexception\n (copy_extension_constructor x0, copy_expression x1)\n | Ast_412.Parsetree.Pexp_assert x0 ->\n Ast_411.Parsetree.Pexp_assert (copy_expression x0)\n | Ast_412.Parsetree.Pexp_lazy x0 ->\n Ast_411.Parsetree.Pexp_lazy (copy_expression x0)\n | Ast_412.Parsetree.Pexp_poly (x0, x1) ->\n Ast_411.Parsetree.Pexp_poly\n (copy_expression x0, Option.map copy_core_type x1)\n | Ast_412.Parsetree.Pexp_object x0 ->\n Ast_411.Parsetree.Pexp_object (copy_class_structure x0)\n | Ast_412.Parsetree.Pexp_newtype (x0, x1) ->\n Ast_411.Parsetree.Pexp_newtype\n (copy_loc (fun x -> x) x0, copy_expression x1)\n | Ast_412.Parsetree.Pexp_pack x0 ->\n Ast_411.Parsetree.Pexp_pack (copy_module_expr x0)\n | Ast_412.Parsetree.Pexp_open (x0, x1) ->\n Ast_411.Parsetree.Pexp_open (copy_open_declaration x0, copy_expression x1)\n | Ast_412.Parsetree.Pexp_letop x0 ->\n Ast_411.Parsetree.Pexp_letop (copy_letop x0)\n | Ast_412.Parsetree.Pexp_extension x0 ->\n Ast_411.Parsetree.Pexp_extension (copy_extension x0)\n | Ast_412.Parsetree.Pexp_unreachable -> Ast_411.Parsetree.Pexp_unreachable\n\nand copy_letop : Ast_412.Parsetree.letop -> Ast_411.Parsetree.letop =\n fun { Ast_412.Parsetree.let_; Ast_412.Parsetree.ands; Ast_412.Parsetree.body } ->\n {\n Ast_411.Parsetree.let_ = copy_binding_op let_;\n Ast_411.Parsetree.ands = List.map copy_binding_op ands;\n Ast_411.Parsetree.body = copy_expression body;\n }\n\nand copy_binding_op :\n Ast_412.Parsetree.binding_op -> Ast_411.Parsetree.binding_op =\n fun {\n Ast_412.Parsetree.pbop_op;\n Ast_412.Parsetree.pbop_pat;\n Ast_412.Parsetree.pbop_exp;\n Ast_412.Parsetree.pbop_loc;\n } ->\n {\n Ast_411.Parsetree.pbop_op = copy_loc (fun x -> x) pbop_op;\n Ast_411.Parsetree.pbop_pat = copy_pattern pbop_pat;\n Ast_411.Parsetree.pbop_exp = copy_expression pbop_exp;\n Ast_411.Parsetree.pbop_loc = copy_location pbop_loc;\n }\n\nand copy_direction_flag :\n Ast_412.Asttypes.direction_flag -> Ast_411.Asttypes.direction_flag =\n function\n | Ast_412.Asttypes.Upto -> Ast_411.Asttypes.Upto\n | Ast_412.Asttypes.Downto -> Ast_411.Asttypes.Downto\n\nand copy_case : Ast_412.Parsetree.case -> Ast_411.Parsetree.case =\n fun {\n Ast_412.Parsetree.pc_lhs;\n Ast_412.Parsetree.pc_guard;\n Ast_412.Parsetree.pc_rhs;\n } ->\n {\n Ast_411.Parsetree.pc_lhs = copy_pattern pc_lhs;\n Ast_411.Parsetree.pc_guard = Option.map copy_expression pc_guard;\n Ast_411.Parsetree.pc_rhs = copy_expression pc_rhs;\n }\n\nand copy_value_binding :\n Ast_412.Parsetree.value_binding -> Ast_411.Parsetree.value_binding =\n fun {\n Ast_412.Parsetree.pvb_pat;\n Ast_412.Parsetree.pvb_expr;\n Ast_412.Parsetree.pvb_attributes;\n Ast_412.Parsetree.pvb_loc;\n } ->\n {\n Ast_411.Parsetree.pvb_pat = copy_pattern pvb_pat;\n Ast_411.Parsetree.pvb_expr = copy_expression pvb_expr;\n Ast_411.Parsetree.pvb_attributes = copy_attributes pvb_attributes;\n Ast_411.Parsetree.pvb_loc = copy_location pvb_loc;\n }\n\nand copy_pattern : Ast_412.Parsetree.pattern -> Ast_411.Parsetree.pattern =\n fun {\n Ast_412.Parsetree.ppat_desc;\n Ast_412.Parsetree.ppat_loc;\n Ast_412.Parsetree.ppat_loc_stack;\n Ast_412.Parsetree.ppat_attributes;\n } ->\n {\n Ast_411.Parsetree.ppat_desc = copy_pattern_desc ppat_desc;\n Ast_411.Parsetree.ppat_loc = copy_location ppat_loc;\n Ast_411.Parsetree.ppat_loc_stack = copy_location_stack ppat_loc_stack;\n Ast_411.Parsetree.ppat_attributes = copy_attributes ppat_attributes;\n }\n\nand copy_pattern_desc :\n Ast_412.Parsetree.pattern_desc -> Ast_411.Parsetree.pattern_desc = function\n | Ast_412.Parsetree.Ppat_any -> Ast_411.Parsetree.Ppat_any\n | Ast_412.Parsetree.Ppat_var x0 ->\n Ast_411.Parsetree.Ppat_var (copy_loc (fun x -> x) x0)\n | Ast_412.Parsetree.Ppat_alias (x0, x1) ->\n Ast_411.Parsetree.Ppat_alias (copy_pattern x0, copy_loc (fun x -> x) x1)\n | Ast_412.Parsetree.Ppat_constant x0 ->\n Ast_411.Parsetree.Ppat_constant (copy_constant x0)\n | Ast_412.Parsetree.Ppat_interval (x0, x1) ->\n Ast_411.Parsetree.Ppat_interval (copy_constant x0, copy_constant x1)\n | Ast_412.Parsetree.Ppat_tuple x0 ->\n Ast_411.Parsetree.Ppat_tuple (List.map copy_pattern x0)\n | Ast_412.Parsetree.Ppat_construct (x0, x1) ->\n Ast_411.Parsetree.Ppat_construct\n (copy_loc copy_Longident_t x0, Option.map copy_pattern x1)\n | Ast_412.Parsetree.Ppat_variant (x0, x1) ->\n Ast_411.Parsetree.Ppat_variant (copy_label x0, Option.map copy_pattern x1)\n | Ast_412.Parsetree.Ppat_record (x0, x1) ->\n Ast_411.Parsetree.Ppat_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_pattern x1))\n x0,\n copy_closed_flag x1 )\n | Ast_412.Parsetree.Ppat_array x0 ->\n Ast_411.Parsetree.Ppat_array (List.map copy_pattern x0)\n | Ast_412.Parsetree.Ppat_or (x0, x1) ->\n Ast_411.Parsetree.Ppat_or (copy_pattern x0, copy_pattern x1)\n | Ast_412.Parsetree.Ppat_constraint (x0, x1) ->\n Ast_411.Parsetree.Ppat_constraint (copy_pattern x0, copy_core_type x1)\n | Ast_412.Parsetree.Ppat_type x0 ->\n Ast_411.Parsetree.Ppat_type (copy_loc copy_Longident_t x0)\n | Ast_412.Parsetree.Ppat_lazy x0 ->\n Ast_411.Parsetree.Ppat_lazy (copy_pattern x0)\n | Ast_412.Parsetree.Ppat_unpack x0 ->\n Ast_411.Parsetree.Ppat_unpack\n (copy_loc (fun x -> Option.map (fun x -> x) x) x0)\n | Ast_412.Parsetree.Ppat_exception x0 ->\n Ast_411.Parsetree.Ppat_exception (copy_pattern x0)\n | Ast_412.Parsetree.Ppat_extension x0 ->\n Ast_411.Parsetree.Ppat_extension (copy_extension x0)\n | Ast_412.Parsetree.Ppat_open (x0, x1) ->\n Ast_411.Parsetree.Ppat_open (copy_loc copy_Longident_t x0, copy_pattern x1)\n\nand copy_core_type : Ast_412.Parsetree.core_type -> Ast_411.Parsetree.core_type\n =\n fun {\n Ast_412.Parsetree.ptyp_desc;\n Ast_412.Parsetree.ptyp_loc;\n Ast_412.Parsetree.ptyp_loc_stack;\n Ast_412.Parsetree.ptyp_attributes;\n } ->\n {\n Ast_411.Parsetree.ptyp_desc = copy_core_type_desc ptyp_desc;\n Ast_411.Parsetree.ptyp_loc = copy_location ptyp_loc;\n Ast_411.Parsetree.ptyp_loc_stack = copy_location_stack ptyp_loc_stack;\n Ast_411.Parsetree.ptyp_attributes = copy_attributes ptyp_attributes;\n }\n\nand copy_location_stack :\n Ast_412.Parsetree.location_stack -> Ast_411.Parsetree.location_stack =\n fun x -> x\n\nand copy_core_type_desc :\n Ast_412.Parsetree.core_type_desc -> Ast_411.Parsetree.core_type_desc =\n function\n | Ast_412.Parsetree.Ptyp_any -> Ast_411.Parsetree.Ptyp_any\n | Ast_412.Parsetree.Ptyp_var x0 -> Ast_411.Parsetree.Ptyp_var x0\n | Ast_412.Parsetree.Ptyp_arrow (x0, x1, x2) ->\n Ast_411.Parsetree.Ptyp_arrow\n (copy_arg_label x0, copy_core_type x1, copy_core_type x2)\n | Ast_412.Parsetree.Ptyp_tuple x0 ->\n Ast_411.Parsetree.Ptyp_tuple (List.map copy_core_type x0)\n | Ast_412.Parsetree.Ptyp_constr (x0, x1) ->\n Ast_411.Parsetree.Ptyp_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_412.Parsetree.Ptyp_object (x0, x1) ->\n Ast_411.Parsetree.Ptyp_object\n (List.map copy_object_field x0, copy_closed_flag x1)\n | Ast_412.Parsetree.Ptyp_class (x0, x1) ->\n Ast_411.Parsetree.Ptyp_class\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_412.Parsetree.Ptyp_alias (x0, x1) ->\n Ast_411.Parsetree.Ptyp_alias (copy_core_type x0, x1)\n | Ast_412.Parsetree.Ptyp_variant (x0, x1, x2) ->\n Ast_411.Parsetree.Ptyp_variant\n ( List.map copy_row_field x0,\n copy_closed_flag x1,\n Option.map (fun x -> List.map copy_label x) x2 )\n | Ast_412.Parsetree.Ptyp_poly (x0, x1) ->\n Ast_411.Parsetree.Ptyp_poly\n (List.map (fun x -> copy_loc (fun x -> x) x) x0, copy_core_type x1)\n | Ast_412.Parsetree.Ptyp_package x0 ->\n Ast_411.Parsetree.Ptyp_package (copy_package_type x0)\n | Ast_412.Parsetree.Ptyp_extension x0 ->\n Ast_411.Parsetree.Ptyp_extension (copy_extension x0)\n\nand copy_package_type :\n Ast_412.Parsetree.package_type -> Ast_411.Parsetree.package_type =\n fun x ->\n let x0, x1 = x in\n ( copy_loc copy_Longident_t x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_core_type x1))\n x1 )\n\nand copy_row_field : Ast_412.Parsetree.row_field -> Ast_411.Parsetree.row_field\n =\n fun {\n Ast_412.Parsetree.prf_desc;\n Ast_412.Parsetree.prf_loc;\n Ast_412.Parsetree.prf_attributes;\n } ->\n {\n Ast_411.Parsetree.prf_desc = copy_row_field_desc prf_desc;\n Ast_411.Parsetree.prf_loc = copy_location prf_loc;\n Ast_411.Parsetree.prf_attributes = copy_attributes prf_attributes;\n }\n\nand copy_row_field_desc :\n Ast_412.Parsetree.row_field_desc -> Ast_411.Parsetree.row_field_desc =\n function\n | Ast_412.Parsetree.Rtag (x0, x1, x2) ->\n Ast_411.Parsetree.Rtag\n (copy_loc copy_label x0, x1, List.map copy_core_type x2)\n | Ast_412.Parsetree.Rinherit x0 ->\n Ast_411.Parsetree.Rinherit (copy_core_type x0)\n\nand copy_object_field :\n Ast_412.Parsetree.object_field -> Ast_411.Parsetree.object_field =\n fun {\n Ast_412.Parsetree.pof_desc;\n Ast_412.Parsetree.pof_loc;\n Ast_412.Parsetree.pof_attributes;\n } ->\n {\n Ast_411.Parsetree.pof_desc = copy_object_field_desc pof_desc;\n Ast_411.Parsetree.pof_loc = copy_location pof_loc;\n Ast_411.Parsetree.pof_attributes = copy_attributes pof_attributes;\n }\n\nand copy_attributes :\n Ast_412.Parsetree.attributes -> Ast_411.Parsetree.attributes =\n fun x -> List.map copy_attribute x\n\nand copy_attribute : Ast_412.Parsetree.attribute -> Ast_411.Parsetree.attribute\n =\n fun {\n Ast_412.Parsetree.attr_name;\n Ast_412.Parsetree.attr_payload;\n Ast_412.Parsetree.attr_loc;\n } ->\n {\n Ast_411.Parsetree.attr_name = copy_loc (fun x -> x) attr_name;\n Ast_411.Parsetree.attr_payload = copy_payload attr_payload;\n Ast_411.Parsetree.attr_loc = copy_location attr_loc;\n }\n\nand copy_payload : Ast_412.Parsetree.payload -> Ast_411.Parsetree.payload =\n function\n | Ast_412.Parsetree.PStr x0 -> Ast_411.Parsetree.PStr (copy_structure x0)\n | Ast_412.Parsetree.PSig x0 -> Ast_411.Parsetree.PSig (copy_signature x0)\n | Ast_412.Parsetree.PTyp x0 -> Ast_411.Parsetree.PTyp (copy_core_type x0)\n | Ast_412.Parsetree.PPat (x0, x1) ->\n Ast_411.Parsetree.PPat (copy_pattern x0, Option.map copy_expression x1)\n\nand copy_structure : Ast_412.Parsetree.structure -> Ast_411.Parsetree.structure\n =\n fun x -> List.map copy_structure_item x\n\nand copy_structure_item :\n Ast_412.Parsetree.structure_item -> Ast_411.Parsetree.structure_item =\n fun { Ast_412.Parsetree.pstr_desc; Ast_412.Parsetree.pstr_loc } ->\n {\n Ast_411.Parsetree.pstr_desc = copy_structure_item_desc pstr_desc;\n Ast_411.Parsetree.pstr_loc = copy_location pstr_loc;\n }\n\nand copy_structure_item_desc :\n Ast_412.Parsetree.structure_item_desc ->\n Ast_411.Parsetree.structure_item_desc = function\n | Ast_412.Parsetree.Pstr_eval (x0, x1) ->\n Ast_411.Parsetree.Pstr_eval (copy_expression x0, copy_attributes x1)\n | Ast_412.Parsetree.Pstr_value (x0, x1) ->\n Ast_411.Parsetree.Pstr_value\n (copy_rec_flag x0, List.map copy_value_binding x1)\n | Ast_412.Parsetree.Pstr_primitive x0 ->\n Ast_411.Parsetree.Pstr_primitive (copy_value_description x0)\n | Ast_412.Parsetree.Pstr_type (x0, x1) ->\n Ast_411.Parsetree.Pstr_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | Ast_412.Parsetree.Pstr_typext x0 ->\n Ast_411.Parsetree.Pstr_typext (copy_type_extension x0)\n | Ast_412.Parsetree.Pstr_exception x0 ->\n Ast_411.Parsetree.Pstr_exception (copy_type_exception x0)\n | Ast_412.Parsetree.Pstr_module x0 ->\n Ast_411.Parsetree.Pstr_module (copy_module_binding x0)\n | Ast_412.Parsetree.Pstr_recmodule x0 ->\n Ast_411.Parsetree.Pstr_recmodule (List.map copy_module_binding x0)\n | Ast_412.Parsetree.Pstr_modtype x0 ->\n Ast_411.Parsetree.Pstr_modtype (copy_module_type_declaration x0)\n | Ast_412.Parsetree.Pstr_open x0 ->\n Ast_411.Parsetree.Pstr_open (copy_open_declaration x0)\n | Ast_412.Parsetree.Pstr_class x0 ->\n Ast_411.Parsetree.Pstr_class (List.map copy_class_declaration x0)\n | Ast_412.Parsetree.Pstr_class_type x0 ->\n Ast_411.Parsetree.Pstr_class_type\n (List.map copy_class_type_declaration x0)\n | Ast_412.Parsetree.Pstr_include x0 ->\n Ast_411.Parsetree.Pstr_include (copy_include_declaration x0)\n | Ast_412.Parsetree.Pstr_attribute x0 ->\n Ast_411.Parsetree.Pstr_attribute (copy_attribute x0)\n | Ast_412.Parsetree.Pstr_extension (x0, x1) ->\n Ast_411.Parsetree.Pstr_extension (copy_extension x0, copy_attributes x1)\n\nand copy_include_declaration :\n Ast_412.Parsetree.include_declaration ->\n Ast_411.Parsetree.include_declaration =\n fun x -> copy_include_infos copy_module_expr x\n\nand copy_class_declaration :\n Ast_412.Parsetree.class_declaration -> Ast_411.Parsetree.class_declaration =\n fun x -> copy_class_infos copy_class_expr x\n\nand copy_class_expr :\n Ast_412.Parsetree.class_expr -> Ast_411.Parsetree.class_expr =\n fun {\n Ast_412.Parsetree.pcl_desc;\n Ast_412.Parsetree.pcl_loc;\n Ast_412.Parsetree.pcl_attributes;\n } ->\n {\n Ast_411.Parsetree.pcl_desc = copy_class_expr_desc pcl_desc;\n Ast_411.Parsetree.pcl_loc = copy_location pcl_loc;\n Ast_411.Parsetree.pcl_attributes = copy_attributes pcl_attributes;\n }\n\nand copy_class_expr_desc :\n Ast_412.Parsetree.class_expr_desc -> Ast_411.Parsetree.class_expr_desc =\n function\n | Ast_412.Parsetree.Pcl_constr (x0, x1) ->\n Ast_411.Parsetree.Pcl_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_412.Parsetree.Pcl_structure x0 ->\n Ast_411.Parsetree.Pcl_structure (copy_class_structure x0)\n | Ast_412.Parsetree.Pcl_fun (x0, x1, x2, x3) ->\n Ast_411.Parsetree.Pcl_fun\n ( copy_arg_label x0,\n Option.map copy_expression x1,\n copy_pattern x2,\n copy_class_expr x3 )\n | Ast_412.Parsetree.Pcl_apply (x0, x1) ->\n Ast_411.Parsetree.Pcl_apply\n ( copy_class_expr x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | Ast_412.Parsetree.Pcl_let (x0, x1, x2) ->\n Ast_411.Parsetree.Pcl_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_class_expr x2)\n | Ast_412.Parsetree.Pcl_constraint (x0, x1) ->\n Ast_411.Parsetree.Pcl_constraint (copy_class_expr x0, copy_class_type x1)\n | Ast_412.Parsetree.Pcl_extension x0 ->\n Ast_411.Parsetree.Pcl_extension (copy_extension x0)\n | Ast_412.Parsetree.Pcl_open (x0, x1) ->\n Ast_411.Parsetree.Pcl_open (copy_open_description x0, copy_class_expr x1)\n\nand copy_class_structure :\n Ast_412.Parsetree.class_structure -> Ast_411.Parsetree.class_structure =\n fun { Ast_412.Parsetree.pcstr_self; Ast_412.Parsetree.pcstr_fields } ->\n {\n Ast_411.Parsetree.pcstr_self = copy_pattern pcstr_self;\n Ast_411.Parsetree.pcstr_fields = List.map copy_class_field pcstr_fields;\n }\n\nand copy_class_field :\n Ast_412.Parsetree.class_field -> Ast_411.Parsetree.class_field =\n fun {\n Ast_412.Parsetree.pcf_desc;\n Ast_412.Parsetree.pcf_loc;\n Ast_412.Parsetree.pcf_attributes;\n } ->\n {\n Ast_411.Parsetree.pcf_desc = copy_class_field_desc pcf_desc;\n Ast_411.Parsetree.pcf_loc = copy_location pcf_loc;\n Ast_411.Parsetree.pcf_attributes = copy_attributes pcf_attributes;\n }\n\nand copy_class_field_desc :\n Ast_412.Parsetree.class_field_desc -> Ast_411.Parsetree.class_field_desc =\n function\n | Ast_412.Parsetree.Pcf_inherit (x0, x1, x2) ->\n Ast_411.Parsetree.Pcf_inherit\n ( copy_override_flag x0,\n copy_class_expr x1,\n Option.map (fun x -> copy_loc (fun x -> x) x) x2 )\n | Ast_412.Parsetree.Pcf_val x0 ->\n Ast_411.Parsetree.Pcf_val\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_mutable_flag x1, copy_class_field_kind x2))\n | Ast_412.Parsetree.Pcf_method x0 ->\n Ast_411.Parsetree.Pcf_method\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_private_flag x1, copy_class_field_kind x2))\n | Ast_412.Parsetree.Pcf_constraint x0 ->\n Ast_411.Parsetree.Pcf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | Ast_412.Parsetree.Pcf_initializer x0 ->\n Ast_411.Parsetree.Pcf_initializer (copy_expression x0)\n | Ast_412.Parsetree.Pcf_attribute x0 ->\n Ast_411.Parsetree.Pcf_attribute (copy_attribute x0)\n | Ast_412.Parsetree.Pcf_extension x0 ->\n Ast_411.Parsetree.Pcf_extension (copy_extension x0)\n\nand copy_class_field_kind :\n Ast_412.Parsetree.class_field_kind -> Ast_411.Parsetree.class_field_kind =\n function\n | Ast_412.Parsetree.Cfk_virtual x0 ->\n Ast_411.Parsetree.Cfk_virtual (copy_core_type x0)\n | Ast_412.Parsetree.Cfk_concrete (x0, x1) ->\n Ast_411.Parsetree.Cfk_concrete (copy_override_flag x0, copy_expression x1)\n\nand copy_open_declaration :\n Ast_412.Parsetree.open_declaration -> Ast_411.Parsetree.open_declaration =\n fun x -> copy_open_infos copy_module_expr x\n\nand copy_module_binding :\n Ast_412.Parsetree.module_binding -> Ast_411.Parsetree.module_binding =\n fun {\n Ast_412.Parsetree.pmb_name;\n Ast_412.Parsetree.pmb_expr;\n Ast_412.Parsetree.pmb_attributes;\n Ast_412.Parsetree.pmb_loc;\n } ->\n {\n Ast_411.Parsetree.pmb_name =\n copy_loc (fun x -> Option.map (fun x -> x) x) pmb_name;\n Ast_411.Parsetree.pmb_expr = copy_module_expr pmb_expr;\n Ast_411.Parsetree.pmb_attributes = copy_attributes pmb_attributes;\n Ast_411.Parsetree.pmb_loc = copy_location pmb_loc;\n }\n\nand copy_module_expr :\n Ast_412.Parsetree.module_expr -> Ast_411.Parsetree.module_expr =\n fun {\n Ast_412.Parsetree.pmod_desc;\n Ast_412.Parsetree.pmod_loc;\n Ast_412.Parsetree.pmod_attributes;\n } ->\n {\n Ast_411.Parsetree.pmod_desc = copy_module_expr_desc pmod_desc;\n Ast_411.Parsetree.pmod_loc = copy_location pmod_loc;\n Ast_411.Parsetree.pmod_attributes = copy_attributes pmod_attributes;\n }\n\nand copy_module_expr_desc :\n Ast_412.Parsetree.module_expr_desc -> Ast_411.Parsetree.module_expr_desc =\n function\n | Ast_412.Parsetree.Pmod_ident x0 ->\n Ast_411.Parsetree.Pmod_ident (copy_loc copy_Longident_t x0)\n | Ast_412.Parsetree.Pmod_structure x0 ->\n Ast_411.Parsetree.Pmod_structure (copy_structure x0)\n | Ast_412.Parsetree.Pmod_functor (x0, x1) ->\n Ast_411.Parsetree.Pmod_functor\n (copy_functor_parameter x0, copy_module_expr x1)\n | Ast_412.Parsetree.Pmod_apply (x0, x1) ->\n Ast_411.Parsetree.Pmod_apply (copy_module_expr x0, copy_module_expr x1)\n | Ast_412.Parsetree.Pmod_constraint (x0, x1) ->\n Ast_411.Parsetree.Pmod_constraint\n (copy_module_expr x0, copy_module_type x1)\n | Ast_412.Parsetree.Pmod_unpack x0 ->\n Ast_411.Parsetree.Pmod_unpack (copy_expression x0)\n | Ast_412.Parsetree.Pmod_extension x0 ->\n Ast_411.Parsetree.Pmod_extension (copy_extension x0)\n\nand copy_functor_parameter :\n Ast_412.Parsetree.functor_parameter -> Ast_411.Parsetree.functor_parameter =\n function\n | Ast_412.Parsetree.Unit -> Ast_411.Parsetree.Unit\n | Ast_412.Parsetree.Named (x0, x1) ->\n Ast_411.Parsetree.Named\n (copy_loc (fun x -> Option.map (fun x -> x) x) x0, copy_module_type x1)\n\nand copy_module_type :\n Ast_412.Parsetree.module_type -> Ast_411.Parsetree.module_type =\n fun {\n Ast_412.Parsetree.pmty_desc;\n Ast_412.Parsetree.pmty_loc;\n Ast_412.Parsetree.pmty_attributes;\n } ->\n {\n Ast_411.Parsetree.pmty_desc = copy_module_type_desc pmty_desc;\n Ast_411.Parsetree.pmty_loc = copy_location pmty_loc;\n Ast_411.Parsetree.pmty_attributes = copy_attributes pmty_attributes;\n }\n\nand copy_module_type_desc :\n Ast_412.Parsetree.module_type_desc -> Ast_411.Parsetree.module_type_desc =\n function\n | Ast_412.Parsetree.Pmty_ident x0 ->\n Ast_411.Parsetree.Pmty_ident (copy_loc copy_Longident_t x0)\n | Ast_412.Parsetree.Pmty_signature x0 ->\n Ast_411.Parsetree.Pmty_signature (copy_signature x0)\n | Ast_412.Parsetree.Pmty_functor (x0, x1) ->\n Ast_411.Parsetree.Pmty_functor\n (copy_functor_parameter x0, copy_module_type x1)\n | Ast_412.Parsetree.Pmty_with (x0, x1) ->\n Ast_411.Parsetree.Pmty_with\n (copy_module_type x0, List.map copy_with_constraint x1)\n | Ast_412.Parsetree.Pmty_typeof x0 ->\n Ast_411.Parsetree.Pmty_typeof (copy_module_expr x0)\n | Ast_412.Parsetree.Pmty_extension x0 ->\n Ast_411.Parsetree.Pmty_extension (copy_extension x0)\n | Ast_412.Parsetree.Pmty_alias x0 ->\n Ast_411.Parsetree.Pmty_alias (copy_loc copy_Longident_t x0)\n\nand copy_with_constraint :\n Ast_412.Parsetree.with_constraint -> Ast_411.Parsetree.with_constraint =\n function\n | Ast_412.Parsetree.Pwith_type (x0, x1) ->\n Ast_411.Parsetree.Pwith_type\n (copy_loc copy_Longident_t x0, copy_type_declaration x1)\n | Ast_412.Parsetree.Pwith_module (x0, x1) ->\n Ast_411.Parsetree.Pwith_module\n (copy_loc copy_Longident_t x0, copy_loc copy_Longident_t x1)\n | Ast_412.Parsetree.Pwith_typesubst (x0, x1) ->\n Ast_411.Parsetree.Pwith_typesubst\n (copy_loc copy_Longident_t x0, copy_type_declaration x1)\n | Ast_412.Parsetree.Pwith_modsubst (x0, x1) ->\n Ast_411.Parsetree.Pwith_modsubst\n (copy_loc copy_Longident_t x0, copy_loc copy_Longident_t x1)\n\nand copy_signature : Ast_412.Parsetree.signature -> Ast_411.Parsetree.signature\n =\n fun x -> List.map copy_signature_item x\n\nand copy_signature_item :\n Ast_412.Parsetree.signature_item -> Ast_411.Parsetree.signature_item =\n fun { Ast_412.Parsetree.psig_desc; Ast_412.Parsetree.psig_loc } ->\n {\n Ast_411.Parsetree.psig_desc = copy_signature_item_desc psig_desc;\n Ast_411.Parsetree.psig_loc = copy_location psig_loc;\n }\n\nand copy_signature_item_desc :\n Ast_412.Parsetree.signature_item_desc ->\n Ast_411.Parsetree.signature_item_desc = function\n | Ast_412.Parsetree.Psig_value x0 ->\n Ast_411.Parsetree.Psig_value (copy_value_description x0)\n | Ast_412.Parsetree.Psig_type (x0, x1) ->\n Ast_411.Parsetree.Psig_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | Ast_412.Parsetree.Psig_typesubst x0 ->\n Ast_411.Parsetree.Psig_typesubst (List.map copy_type_declaration x0)\n | Ast_412.Parsetree.Psig_typext x0 ->\n Ast_411.Parsetree.Psig_typext (copy_type_extension x0)\n | Ast_412.Parsetree.Psig_exception x0 ->\n Ast_411.Parsetree.Psig_exception (copy_type_exception x0)\n | Ast_412.Parsetree.Psig_module x0 ->\n Ast_411.Parsetree.Psig_module (copy_module_declaration x0)\n | Ast_412.Parsetree.Psig_modsubst x0 ->\n Ast_411.Parsetree.Psig_modsubst (copy_module_substitution x0)\n | Ast_412.Parsetree.Psig_recmodule x0 ->\n Ast_411.Parsetree.Psig_recmodule (List.map copy_module_declaration x0)\n | Ast_412.Parsetree.Psig_modtype x0 ->\n Ast_411.Parsetree.Psig_modtype (copy_module_type_declaration x0)\n | Ast_412.Parsetree.Psig_open x0 ->\n Ast_411.Parsetree.Psig_open (copy_open_description x0)\n | Ast_412.Parsetree.Psig_include x0 ->\n Ast_411.Parsetree.Psig_include (copy_include_description x0)\n | Ast_412.Parsetree.Psig_class x0 ->\n Ast_411.Parsetree.Psig_class (List.map copy_class_description x0)\n | Ast_412.Parsetree.Psig_class_type x0 ->\n Ast_411.Parsetree.Psig_class_type\n (List.map copy_class_type_declaration x0)\n | Ast_412.Parsetree.Psig_attribute x0 ->\n Ast_411.Parsetree.Psig_attribute (copy_attribute x0)\n | Ast_412.Parsetree.Psig_extension (x0, x1) ->\n Ast_411.Parsetree.Psig_extension (copy_extension x0, copy_attributes x1)\n\nand copy_class_type_declaration :\n Ast_412.Parsetree.class_type_declaration ->\n Ast_411.Parsetree.class_type_declaration =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_description :\n Ast_412.Parsetree.class_description -> Ast_411.Parsetree.class_description =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_type :\n Ast_412.Parsetree.class_type -> Ast_411.Parsetree.class_type =\n fun {\n Ast_412.Parsetree.pcty_desc;\n Ast_412.Parsetree.pcty_loc;\n Ast_412.Parsetree.pcty_attributes;\n } ->\n {\n Ast_411.Parsetree.pcty_desc = copy_class_type_desc pcty_desc;\n Ast_411.Parsetree.pcty_loc = copy_location pcty_loc;\n Ast_411.Parsetree.pcty_attributes = copy_attributes pcty_attributes;\n }\n\nand copy_class_type_desc :\n Ast_412.Parsetree.class_type_desc -> Ast_411.Parsetree.class_type_desc =\n function\n | Ast_412.Parsetree.Pcty_constr (x0, x1) ->\n Ast_411.Parsetree.Pcty_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_412.Parsetree.Pcty_signature x0 ->\n Ast_411.Parsetree.Pcty_signature (copy_class_signature x0)\n | Ast_412.Parsetree.Pcty_arrow (x0, x1, x2) ->\n Ast_411.Parsetree.Pcty_arrow\n (copy_arg_label x0, copy_core_type x1, copy_class_type x2)\n | Ast_412.Parsetree.Pcty_extension x0 ->\n Ast_411.Parsetree.Pcty_extension (copy_extension x0)\n | Ast_412.Parsetree.Pcty_open (x0, x1) ->\n Ast_411.Parsetree.Pcty_open (copy_open_description x0, copy_class_type x1)\n\nand copy_class_signature :\n Ast_412.Parsetree.class_signature -> Ast_411.Parsetree.class_signature =\n fun { Ast_412.Parsetree.pcsig_self; Ast_412.Parsetree.pcsig_fields } ->\n {\n Ast_411.Parsetree.pcsig_self = copy_core_type pcsig_self;\n Ast_411.Parsetree.pcsig_fields = List.map copy_class_type_field pcsig_fields;\n }\n\nand copy_class_type_field :\n Ast_412.Parsetree.class_type_field -> Ast_411.Parsetree.class_type_field =\n fun {\n Ast_412.Parsetree.pctf_desc;\n Ast_412.Parsetree.pctf_loc;\n Ast_412.Parsetree.pctf_attributes;\n } ->\n {\n Ast_411.Parsetree.pctf_desc = copy_class_type_field_desc pctf_desc;\n Ast_411.Parsetree.pctf_loc = copy_location pctf_loc;\n Ast_411.Parsetree.pctf_attributes = copy_attributes pctf_attributes;\n }\n\nand copy_class_type_field_desc :\n Ast_412.Parsetree.class_type_field_desc ->\n Ast_411.Parsetree.class_type_field_desc = function\n | Ast_412.Parsetree.Pctf_inherit x0 ->\n Ast_411.Parsetree.Pctf_inherit (copy_class_type x0)\n | Ast_412.Parsetree.Pctf_val x0 ->\n Ast_411.Parsetree.Pctf_val\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_mutable_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | Ast_412.Parsetree.Pctf_method x0 ->\n Ast_411.Parsetree.Pctf_method\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_private_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | Ast_412.Parsetree.Pctf_constraint x0 ->\n Ast_411.Parsetree.Pctf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | Ast_412.Parsetree.Pctf_attribute x0 ->\n Ast_411.Parsetree.Pctf_attribute (copy_attribute x0)\n | Ast_412.Parsetree.Pctf_extension x0 ->\n Ast_411.Parsetree.Pctf_extension (copy_extension x0)\n\nand copy_extension : Ast_412.Parsetree.extension -> Ast_411.Parsetree.extension\n =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_class_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_412.Parsetree.class_infos ->\n 'g0 Ast_411.Parsetree.class_infos =\n fun f0\n {\n Ast_412.Parsetree.pci_virt;\n Ast_412.Parsetree.pci_params;\n Ast_412.Parsetree.pci_name;\n Ast_412.Parsetree.pci_expr;\n Ast_412.Parsetree.pci_loc;\n Ast_412.Parsetree.pci_attributes;\n } ->\n {\n Ast_411.Parsetree.pci_virt = copy_virtual_flag pci_virt;\n Ast_411.Parsetree.pci_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n ( copy_core_type x0,\n let x0, _ = x1 in\n copy_variance x0 ))\n pci_params;\n Ast_411.Parsetree.pci_name = copy_loc (fun x -> x) pci_name;\n Ast_411.Parsetree.pci_expr = f0 pci_expr;\n Ast_411.Parsetree.pci_loc = copy_location pci_loc;\n Ast_411.Parsetree.pci_attributes = copy_attributes pci_attributes;\n }\n\nand copy_virtual_flag :\n Ast_412.Asttypes.virtual_flag -> Ast_411.Asttypes.virtual_flag = function\n | Ast_412.Asttypes.Virtual -> Ast_411.Asttypes.Virtual\n | Ast_412.Asttypes.Concrete -> Ast_411.Asttypes.Concrete\n\nand copy_include_description :\n Ast_412.Parsetree.include_description ->\n Ast_411.Parsetree.include_description =\n fun x -> copy_include_infos copy_module_type x\n\nand copy_include_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_412.Parsetree.include_infos ->\n 'g0 Ast_411.Parsetree.include_infos =\n fun f0\n {\n Ast_412.Parsetree.pincl_mod;\n Ast_412.Parsetree.pincl_loc;\n Ast_412.Parsetree.pincl_attributes;\n } ->\n {\n Ast_411.Parsetree.pincl_mod = f0 pincl_mod;\n Ast_411.Parsetree.pincl_loc = copy_location pincl_loc;\n Ast_411.Parsetree.pincl_attributes = copy_attributes pincl_attributes;\n }\n\nand copy_open_description :\n Ast_412.Parsetree.open_description -> Ast_411.Parsetree.open_description =\n fun x -> copy_open_infos (fun x -> copy_loc copy_Longident_t x) x\n\nand copy_open_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_412.Parsetree.open_infos ->\n 'g0 Ast_411.Parsetree.open_infos =\n fun f0\n {\n Ast_412.Parsetree.popen_expr;\n Ast_412.Parsetree.popen_override;\n Ast_412.Parsetree.popen_loc;\n Ast_412.Parsetree.popen_attributes;\n } ->\n {\n Ast_411.Parsetree.popen_expr = f0 popen_expr;\n Ast_411.Parsetree.popen_override = copy_override_flag popen_override;\n Ast_411.Parsetree.popen_loc = copy_location popen_loc;\n Ast_411.Parsetree.popen_attributes = copy_attributes popen_attributes;\n }\n\nand copy_override_flag :\n Ast_412.Asttypes.override_flag -> Ast_411.Asttypes.override_flag = function\n | Ast_412.Asttypes.Override -> Ast_411.Asttypes.Override\n | Ast_412.Asttypes.Fresh -> Ast_411.Asttypes.Fresh\n\nand copy_module_type_declaration :\n Ast_412.Parsetree.module_type_declaration ->\n Ast_411.Parsetree.module_type_declaration =\n fun {\n Ast_412.Parsetree.pmtd_name;\n Ast_412.Parsetree.pmtd_type;\n Ast_412.Parsetree.pmtd_attributes;\n Ast_412.Parsetree.pmtd_loc;\n } ->\n {\n Ast_411.Parsetree.pmtd_name = copy_loc (fun x -> x) pmtd_name;\n Ast_411.Parsetree.pmtd_type = Option.map copy_module_type pmtd_type;\n Ast_411.Parsetree.pmtd_attributes = copy_attributes pmtd_attributes;\n Ast_411.Parsetree.pmtd_loc = copy_location pmtd_loc;\n }\n\nand copy_module_substitution :\n Ast_412.Parsetree.module_substitution ->\n Ast_411.Parsetree.module_substitution =\n fun {\n Ast_412.Parsetree.pms_name;\n Ast_412.Parsetree.pms_manifest;\n Ast_412.Parsetree.pms_attributes;\n Ast_412.Parsetree.pms_loc;\n } ->\n {\n Ast_411.Parsetree.pms_name = copy_loc (fun x -> x) pms_name;\n Ast_411.Parsetree.pms_manifest = copy_loc copy_Longident_t pms_manifest;\n Ast_411.Parsetree.pms_attributes = copy_attributes pms_attributes;\n Ast_411.Parsetree.pms_loc = copy_location pms_loc;\n }\n\nand copy_module_declaration :\n Ast_412.Parsetree.module_declaration -> Ast_411.Parsetree.module_declaration\n =\n fun {\n Ast_412.Parsetree.pmd_name;\n Ast_412.Parsetree.pmd_type;\n Ast_412.Parsetree.pmd_attributes;\n Ast_412.Parsetree.pmd_loc;\n } ->\n {\n Ast_411.Parsetree.pmd_name =\n copy_loc (fun x -> Option.map (fun x -> x) x) pmd_name;\n Ast_411.Parsetree.pmd_type = copy_module_type pmd_type;\n Ast_411.Parsetree.pmd_attributes = copy_attributes pmd_attributes;\n Ast_411.Parsetree.pmd_loc = copy_location pmd_loc;\n }\n\nand copy_type_exception :\n Ast_412.Parsetree.type_exception -> Ast_411.Parsetree.type_exception =\n fun {\n Ast_412.Parsetree.ptyexn_constructor;\n Ast_412.Parsetree.ptyexn_loc;\n Ast_412.Parsetree.ptyexn_attributes;\n } ->\n {\n Ast_411.Parsetree.ptyexn_constructor =\n copy_extension_constructor ptyexn_constructor;\n Ast_411.Parsetree.ptyexn_loc = copy_location ptyexn_loc;\n Ast_411.Parsetree.ptyexn_attributes = copy_attributes ptyexn_attributes;\n }\n\nand copy_type_extension :\n Ast_412.Parsetree.type_extension -> Ast_411.Parsetree.type_extension =\n fun {\n Ast_412.Parsetree.ptyext_path;\n Ast_412.Parsetree.ptyext_params;\n Ast_412.Parsetree.ptyext_constructors;\n Ast_412.Parsetree.ptyext_private;\n Ast_412.Parsetree.ptyext_loc;\n Ast_412.Parsetree.ptyext_attributes;\n } ->\n {\n Ast_411.Parsetree.ptyext_path = copy_loc copy_Longident_t ptyext_path;\n Ast_411.Parsetree.ptyext_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n ( copy_core_type x0,\n let x0, _ = x1 in\n copy_variance x0 ))\n ptyext_params;\n Ast_411.Parsetree.ptyext_constructors =\n List.map copy_extension_constructor ptyext_constructors;\n Ast_411.Parsetree.ptyext_private = copy_private_flag ptyext_private;\n Ast_411.Parsetree.ptyext_loc = copy_location ptyext_loc;\n Ast_411.Parsetree.ptyext_attributes = copy_attributes ptyext_attributes;\n }\n\nand copy_extension_constructor :\n Ast_412.Parsetree.extension_constructor ->\n Ast_411.Parsetree.extension_constructor =\n fun {\n Ast_412.Parsetree.pext_name;\n Ast_412.Parsetree.pext_kind;\n Ast_412.Parsetree.pext_loc;\n Ast_412.Parsetree.pext_attributes;\n } ->\n {\n Ast_411.Parsetree.pext_name = copy_loc (fun x -> x) pext_name;\n Ast_411.Parsetree.pext_kind = copy_extension_constructor_kind pext_kind;\n Ast_411.Parsetree.pext_loc = copy_location pext_loc;\n Ast_411.Parsetree.pext_attributes = copy_attributes pext_attributes;\n }\n\nand copy_extension_constructor_kind :\n Ast_412.Parsetree.extension_constructor_kind ->\n Ast_411.Parsetree.extension_constructor_kind = function\n | Ast_412.Parsetree.Pext_decl (x0, x1) ->\n Ast_411.Parsetree.Pext_decl\n (copy_constructor_arguments x0, Option.map copy_core_type x1)\n | Ast_412.Parsetree.Pext_rebind x0 ->\n Ast_411.Parsetree.Pext_rebind (copy_loc copy_Longident_t x0)\n\nand copy_type_declaration :\n Ast_412.Parsetree.type_declaration -> Ast_411.Parsetree.type_declaration =\n fun {\n Ast_412.Parsetree.ptype_name;\n Ast_412.Parsetree.ptype_params;\n Ast_412.Parsetree.ptype_cstrs;\n Ast_412.Parsetree.ptype_kind;\n Ast_412.Parsetree.ptype_private;\n Ast_412.Parsetree.ptype_manifest;\n Ast_412.Parsetree.ptype_attributes;\n Ast_412.Parsetree.ptype_loc;\n } ->\n {\n Ast_411.Parsetree.ptype_name = copy_loc (fun x -> x) ptype_name;\n Ast_411.Parsetree.ptype_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n ( copy_core_type x0,\n let x0, _ = x1 in\n copy_variance x0 ))\n ptype_params;\n Ast_411.Parsetree.ptype_cstrs =\n List.map\n (fun x ->\n let x0, x1, x2 = x in\n (copy_core_type x0, copy_core_type x1, copy_location x2))\n ptype_cstrs;\n Ast_411.Parsetree.ptype_kind = copy_type_kind ptype_kind;\n Ast_411.Parsetree.ptype_private = copy_private_flag ptype_private;\n Ast_411.Parsetree.ptype_manifest = Option.map copy_core_type ptype_manifest;\n Ast_411.Parsetree.ptype_attributes = copy_attributes ptype_attributes;\n Ast_411.Parsetree.ptype_loc = copy_location ptype_loc;\n }\n\nand copy_private_flag :\n Ast_412.Asttypes.private_flag -> Ast_411.Asttypes.private_flag = function\n | Ast_412.Asttypes.Private -> Ast_411.Asttypes.Private\n | Ast_412.Asttypes.Public -> Ast_411.Asttypes.Public\n\nand copy_type_kind : Ast_412.Parsetree.type_kind -> Ast_411.Parsetree.type_kind\n = function\n | Ast_412.Parsetree.Ptype_abstract -> Ast_411.Parsetree.Ptype_abstract\n | Ast_412.Parsetree.Ptype_variant x0 ->\n Ast_411.Parsetree.Ptype_variant (List.map copy_constructor_declaration x0)\n | Ast_412.Parsetree.Ptype_record x0 ->\n Ast_411.Parsetree.Ptype_record (List.map copy_label_declaration x0)\n | Ast_412.Parsetree.Ptype_open -> Ast_411.Parsetree.Ptype_open\n\nand copy_constructor_declaration :\n Ast_412.Parsetree.constructor_declaration ->\n Ast_411.Parsetree.constructor_declaration =\n fun {\n Ast_412.Parsetree.pcd_name;\n Ast_412.Parsetree.pcd_args;\n Ast_412.Parsetree.pcd_res;\n Ast_412.Parsetree.pcd_loc;\n Ast_412.Parsetree.pcd_attributes;\n } ->\n {\n Ast_411.Parsetree.pcd_name = copy_loc (fun x -> x) pcd_name;\n Ast_411.Parsetree.pcd_args = copy_constructor_arguments pcd_args;\n Ast_411.Parsetree.pcd_res = Option.map copy_core_type pcd_res;\n Ast_411.Parsetree.pcd_loc = copy_location pcd_loc;\n Ast_411.Parsetree.pcd_attributes = copy_attributes pcd_attributes;\n }\n\nand copy_constructor_arguments :\n Ast_412.Parsetree.constructor_arguments ->\n Ast_411.Parsetree.constructor_arguments = function\n | Ast_412.Parsetree.Pcstr_tuple x0 ->\n Ast_411.Parsetree.Pcstr_tuple (List.map copy_core_type x0)\n | Ast_412.Parsetree.Pcstr_record x0 ->\n Ast_411.Parsetree.Pcstr_record (List.map copy_label_declaration x0)\n\nand copy_label_declaration :\n Ast_412.Parsetree.label_declaration -> Ast_411.Parsetree.label_declaration =\n fun {\n Ast_412.Parsetree.pld_name;\n Ast_412.Parsetree.pld_mutable;\n Ast_412.Parsetree.pld_type;\n Ast_412.Parsetree.pld_loc;\n Ast_412.Parsetree.pld_attributes;\n } ->\n {\n Ast_411.Parsetree.pld_name = copy_loc (fun x -> x) pld_name;\n Ast_411.Parsetree.pld_mutable = copy_mutable_flag pld_mutable;\n Ast_411.Parsetree.pld_type = copy_core_type pld_type;\n Ast_411.Parsetree.pld_loc = copy_location pld_loc;\n Ast_411.Parsetree.pld_attributes = copy_attributes pld_attributes;\n }\n\nand copy_mutable_flag :\n Ast_412.Asttypes.mutable_flag -> Ast_411.Asttypes.mutable_flag = function\n | Ast_412.Asttypes.Immutable -> Ast_411.Asttypes.Immutable\n | Ast_412.Asttypes.Mutable -> Ast_411.Asttypes.Mutable\n\nand copy_variance : Ast_412.Asttypes.variance -> Ast_411.Asttypes.variance =\n function\n | Ast_412.Asttypes.Covariant -> Ast_411.Asttypes.Covariant\n | Ast_412.Asttypes.Contravariant -> Ast_411.Asttypes.Contravariant\n | Ast_412.Asttypes.NoVariance -> Ast_411.Asttypes.Invariant\n\nand copy_value_description :\n Ast_412.Parsetree.value_description -> Ast_411.Parsetree.value_description =\n fun {\n Ast_412.Parsetree.pval_name;\n Ast_412.Parsetree.pval_type;\n Ast_412.Parsetree.pval_prim;\n Ast_412.Parsetree.pval_attributes;\n Ast_412.Parsetree.pval_loc;\n } ->\n {\n Ast_411.Parsetree.pval_name = copy_loc (fun x -> x) pval_name;\n Ast_411.Parsetree.pval_type = copy_core_type pval_type;\n Ast_411.Parsetree.pval_prim = List.map (fun x -> x) pval_prim;\n Ast_411.Parsetree.pval_attributes = copy_attributes pval_attributes;\n Ast_411.Parsetree.pval_loc = copy_location pval_loc;\n }\n\nand copy_object_field_desc :\n Ast_412.Parsetree.object_field_desc -> Ast_411.Parsetree.object_field_desc =\n function\n | Ast_412.Parsetree.Otag (x0, x1) ->\n Ast_411.Parsetree.Otag (copy_loc copy_label x0, copy_core_type x1)\n | Ast_412.Parsetree.Oinherit x0 ->\n Ast_411.Parsetree.Oinherit (copy_core_type x0)\n\nand copy_arg_label : Ast_412.Asttypes.arg_label -> Ast_411.Asttypes.arg_label =\n function\n | Ast_412.Asttypes.Nolabel -> Ast_411.Asttypes.Nolabel\n | Ast_412.Asttypes.Labelled x0 -> Ast_411.Asttypes.Labelled x0\n | Ast_412.Asttypes.Optional x0 -> Ast_411.Asttypes.Optional x0\n\nand copy_closed_flag :\n Ast_412.Asttypes.closed_flag -> Ast_411.Asttypes.closed_flag = function\n | Ast_412.Asttypes.Closed -> Ast_411.Asttypes.Closed\n | Ast_412.Asttypes.Open -> Ast_411.Asttypes.Open\n\nand copy_label : Ast_412.Asttypes.label -> Ast_411.Asttypes.label = fun x -> x\n\nand copy_rec_flag : Ast_412.Asttypes.rec_flag -> Ast_411.Asttypes.rec_flag =\n function\n | Ast_412.Asttypes.Nonrecursive -> Ast_411.Asttypes.Nonrecursive\n | Ast_412.Asttypes.Recursive -> Ast_411.Asttypes.Recursive\n\nand copy_constant : Ast_412.Parsetree.constant -> Ast_411.Parsetree.constant =\n function\n | Ast_412.Parsetree.Pconst_integer (x0, x1) ->\n Ast_411.Parsetree.Pconst_integer (x0, Option.map (fun x -> x) x1)\n | Ast_412.Parsetree.Pconst_char x0 -> Ast_411.Parsetree.Pconst_char x0\n | Ast_412.Parsetree.Pconst_string (x0, x1, x2) ->\n Ast_411.Parsetree.Pconst_string\n (x0, copy_location x1, Option.map (fun x -> x) x2)\n | Ast_412.Parsetree.Pconst_float (x0, x1) ->\n Ast_411.Parsetree.Pconst_float (x0, Option.map (fun x -> x) x1)\n\nand copy_Longident_t : Longident.t -> Longident.t = fun x -> x\n\nand copy_loc :\n 'f0 'g0.\n ('f0 -> 'g0) -> 'f0 Ast_412.Asttypes.loc -> 'g0 Ast_411.Asttypes.loc =\n fun f0 { Ast_412.Asttypes.txt; Ast_412.Asttypes.loc } ->\n { Ast_411.Asttypes.txt = f0 txt; Ast_411.Asttypes.loc = copy_location loc }\n\nand copy_location : Location.t -> Location.t = fun x -> x\n","open Stdlib0\nmodule From = Ast_411\nmodule To = Ast_412\n\nlet rec copy_toplevel_phrase :\n Ast_411.Parsetree.toplevel_phrase -> Ast_412.Parsetree.toplevel_phrase =\n function\n | Ast_411.Parsetree.Ptop_def x0 ->\n Ast_412.Parsetree.Ptop_def (copy_structure x0)\n | Ast_411.Parsetree.Ptop_dir x0 ->\n Ast_412.Parsetree.Ptop_dir (copy_toplevel_directive x0)\n\nand copy_toplevel_directive :\n Ast_411.Parsetree.toplevel_directive -> Ast_412.Parsetree.toplevel_directive\n =\n fun {\n Ast_411.Parsetree.pdir_name;\n Ast_411.Parsetree.pdir_arg;\n Ast_411.Parsetree.pdir_loc;\n } ->\n {\n Ast_412.Parsetree.pdir_name = copy_loc (fun x -> x) pdir_name;\n Ast_412.Parsetree.pdir_arg = Option.map copy_directive_argument pdir_arg;\n Ast_412.Parsetree.pdir_loc = copy_location pdir_loc;\n }\n\nand copy_directive_argument :\n Ast_411.Parsetree.directive_argument -> Ast_412.Parsetree.directive_argument\n =\n fun { Ast_411.Parsetree.pdira_desc; Ast_411.Parsetree.pdira_loc } ->\n {\n Ast_412.Parsetree.pdira_desc = copy_directive_argument_desc pdira_desc;\n Ast_412.Parsetree.pdira_loc = copy_location pdira_loc;\n }\n\nand copy_directive_argument_desc :\n Ast_411.Parsetree.directive_argument_desc ->\n Ast_412.Parsetree.directive_argument_desc = function\n | Ast_411.Parsetree.Pdir_string x0 -> Ast_412.Parsetree.Pdir_string x0\n | Ast_411.Parsetree.Pdir_int (x0, x1) ->\n Ast_412.Parsetree.Pdir_int (x0, Option.map (fun x -> x) x1)\n | Ast_411.Parsetree.Pdir_ident x0 ->\n Ast_412.Parsetree.Pdir_ident (copy_Longident_t x0)\n | Ast_411.Parsetree.Pdir_bool x0 -> Ast_412.Parsetree.Pdir_bool x0\n\nand copy_expression :\n Ast_411.Parsetree.expression -> Ast_412.Parsetree.expression =\n fun {\n Ast_411.Parsetree.pexp_desc;\n Ast_411.Parsetree.pexp_loc;\n Ast_411.Parsetree.pexp_loc_stack;\n Ast_411.Parsetree.pexp_attributes;\n } ->\n {\n Ast_412.Parsetree.pexp_desc = copy_expression_desc pexp_desc;\n Ast_412.Parsetree.pexp_loc = copy_location pexp_loc;\n Ast_412.Parsetree.pexp_loc_stack = copy_location_stack pexp_loc_stack;\n Ast_412.Parsetree.pexp_attributes = copy_attributes pexp_attributes;\n }\n\nand copy_expression_desc :\n Ast_411.Parsetree.expression_desc -> Ast_412.Parsetree.expression_desc =\n function\n | Ast_411.Parsetree.Pexp_ident x0 ->\n Ast_412.Parsetree.Pexp_ident (copy_loc copy_Longident_t x0)\n | Ast_411.Parsetree.Pexp_constant x0 ->\n Ast_412.Parsetree.Pexp_constant (copy_constant x0)\n | Ast_411.Parsetree.Pexp_let (x0, x1, x2) ->\n Ast_412.Parsetree.Pexp_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_expression x2)\n | Ast_411.Parsetree.Pexp_function x0 ->\n Ast_412.Parsetree.Pexp_function (List.map copy_case x0)\n | Ast_411.Parsetree.Pexp_fun (x0, x1, x2, x3) ->\n Ast_412.Parsetree.Pexp_fun\n ( copy_arg_label x0,\n Option.map copy_expression x1,\n copy_pattern x2,\n copy_expression x3 )\n | Ast_411.Parsetree.Pexp_apply (x0, x1) ->\n Ast_412.Parsetree.Pexp_apply\n ( copy_expression x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | Ast_411.Parsetree.Pexp_match (x0, x1) ->\n Ast_412.Parsetree.Pexp_match (copy_expression x0, List.map copy_case x1)\n | Ast_411.Parsetree.Pexp_try (x0, x1) ->\n Ast_412.Parsetree.Pexp_try (copy_expression x0, List.map copy_case x1)\n | Ast_411.Parsetree.Pexp_tuple x0 ->\n Ast_412.Parsetree.Pexp_tuple (List.map copy_expression x0)\n | Ast_411.Parsetree.Pexp_construct (x0, x1) ->\n Ast_412.Parsetree.Pexp_construct\n (copy_loc copy_Longident_t x0, Option.map copy_expression x1)\n | Ast_411.Parsetree.Pexp_variant (x0, x1) ->\n Ast_412.Parsetree.Pexp_variant\n (copy_label x0, Option.map copy_expression x1)\n | Ast_411.Parsetree.Pexp_record (x0, x1) ->\n Ast_412.Parsetree.Pexp_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_expression x1))\n x0,\n Option.map copy_expression x1 )\n | Ast_411.Parsetree.Pexp_field (x0, x1) ->\n Ast_412.Parsetree.Pexp_field\n (copy_expression x0, copy_loc copy_Longident_t x1)\n | Ast_411.Parsetree.Pexp_setfield (x0, x1, x2) ->\n Ast_412.Parsetree.Pexp_setfield\n (copy_expression x0, copy_loc copy_Longident_t x1, copy_expression x2)\n | Ast_411.Parsetree.Pexp_array x0 ->\n Ast_412.Parsetree.Pexp_array (List.map copy_expression x0)\n | Ast_411.Parsetree.Pexp_ifthenelse (x0, x1, x2) ->\n Ast_412.Parsetree.Pexp_ifthenelse\n (copy_expression x0, copy_expression x1, Option.map copy_expression x2)\n | Ast_411.Parsetree.Pexp_sequence (x0, x1) ->\n Ast_412.Parsetree.Pexp_sequence (copy_expression x0, copy_expression x1)\n | Ast_411.Parsetree.Pexp_while (x0, x1) ->\n Ast_412.Parsetree.Pexp_while (copy_expression x0, copy_expression x1)\n | Ast_411.Parsetree.Pexp_for (x0, x1, x2, x3, x4) ->\n Ast_412.Parsetree.Pexp_for\n ( copy_pattern x0,\n copy_expression x1,\n copy_expression x2,\n copy_direction_flag x3,\n copy_expression x4 )\n | Ast_411.Parsetree.Pexp_constraint (x0, x1) ->\n Ast_412.Parsetree.Pexp_constraint (copy_expression x0, copy_core_type x1)\n | Ast_411.Parsetree.Pexp_coerce (x0, x1, x2) ->\n Ast_412.Parsetree.Pexp_coerce\n (copy_expression x0, Option.map copy_core_type x1, copy_core_type x2)\n | Ast_411.Parsetree.Pexp_send (x0, x1) ->\n Ast_412.Parsetree.Pexp_send (copy_expression x0, copy_loc copy_label x1)\n | Ast_411.Parsetree.Pexp_new x0 ->\n Ast_412.Parsetree.Pexp_new (copy_loc copy_Longident_t x0)\n | Ast_411.Parsetree.Pexp_setinstvar (x0, x1) ->\n Ast_412.Parsetree.Pexp_setinstvar\n (copy_loc copy_label x0, copy_expression x1)\n | Ast_411.Parsetree.Pexp_override x0 ->\n Ast_412.Parsetree.Pexp_override\n (List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_label x0, copy_expression x1))\n x0)\n | Ast_411.Parsetree.Pexp_letmodule (x0, x1, x2) ->\n Ast_412.Parsetree.Pexp_letmodule\n ( copy_loc (fun x -> Option.map (fun x -> x) x) x0,\n copy_module_expr x1,\n copy_expression x2 )\n | Ast_411.Parsetree.Pexp_letexception (x0, x1) ->\n Ast_412.Parsetree.Pexp_letexception\n (copy_extension_constructor x0, copy_expression x1)\n | Ast_411.Parsetree.Pexp_assert x0 ->\n Ast_412.Parsetree.Pexp_assert (copy_expression x0)\n | Ast_411.Parsetree.Pexp_lazy x0 ->\n Ast_412.Parsetree.Pexp_lazy (copy_expression x0)\n | Ast_411.Parsetree.Pexp_poly (x0, x1) ->\n Ast_412.Parsetree.Pexp_poly\n (copy_expression x0, Option.map copy_core_type x1)\n | Ast_411.Parsetree.Pexp_object x0 ->\n Ast_412.Parsetree.Pexp_object (copy_class_structure x0)\n | Ast_411.Parsetree.Pexp_newtype (x0, x1) ->\n Ast_412.Parsetree.Pexp_newtype\n (copy_loc (fun x -> x) x0, copy_expression x1)\n | Ast_411.Parsetree.Pexp_pack x0 ->\n Ast_412.Parsetree.Pexp_pack (copy_module_expr x0)\n | Ast_411.Parsetree.Pexp_open (x0, x1) ->\n Ast_412.Parsetree.Pexp_open (copy_open_declaration x0, copy_expression x1)\n | Ast_411.Parsetree.Pexp_letop x0 ->\n Ast_412.Parsetree.Pexp_letop (copy_letop x0)\n | Ast_411.Parsetree.Pexp_extension x0 ->\n Ast_412.Parsetree.Pexp_extension (copy_extension x0)\n | Ast_411.Parsetree.Pexp_unreachable -> Ast_412.Parsetree.Pexp_unreachable\n\nand copy_letop : Ast_411.Parsetree.letop -> Ast_412.Parsetree.letop =\n fun { Ast_411.Parsetree.let_; Ast_411.Parsetree.ands; Ast_411.Parsetree.body } ->\n {\n Ast_412.Parsetree.let_ = copy_binding_op let_;\n Ast_412.Parsetree.ands = List.map copy_binding_op ands;\n Ast_412.Parsetree.body = copy_expression body;\n }\n\nand copy_binding_op :\n Ast_411.Parsetree.binding_op -> Ast_412.Parsetree.binding_op =\n fun {\n Ast_411.Parsetree.pbop_op;\n Ast_411.Parsetree.pbop_pat;\n Ast_411.Parsetree.pbop_exp;\n Ast_411.Parsetree.pbop_loc;\n } ->\n {\n Ast_412.Parsetree.pbop_op = copy_loc (fun x -> x) pbop_op;\n Ast_412.Parsetree.pbop_pat = copy_pattern pbop_pat;\n Ast_412.Parsetree.pbop_exp = copy_expression pbop_exp;\n Ast_412.Parsetree.pbop_loc = copy_location pbop_loc;\n }\n\nand copy_direction_flag :\n Ast_411.Asttypes.direction_flag -> Ast_412.Asttypes.direction_flag =\n function\n | Ast_411.Asttypes.Upto -> Ast_412.Asttypes.Upto\n | Ast_411.Asttypes.Downto -> Ast_412.Asttypes.Downto\n\nand copy_case : Ast_411.Parsetree.case -> Ast_412.Parsetree.case =\n fun {\n Ast_411.Parsetree.pc_lhs;\n Ast_411.Parsetree.pc_guard;\n Ast_411.Parsetree.pc_rhs;\n } ->\n {\n Ast_412.Parsetree.pc_lhs = copy_pattern pc_lhs;\n Ast_412.Parsetree.pc_guard = Option.map copy_expression pc_guard;\n Ast_412.Parsetree.pc_rhs = copy_expression pc_rhs;\n }\n\nand copy_value_binding :\n Ast_411.Parsetree.value_binding -> Ast_412.Parsetree.value_binding =\n fun {\n Ast_411.Parsetree.pvb_pat;\n Ast_411.Parsetree.pvb_expr;\n Ast_411.Parsetree.pvb_attributes;\n Ast_411.Parsetree.pvb_loc;\n } ->\n {\n Ast_412.Parsetree.pvb_pat = copy_pattern pvb_pat;\n Ast_412.Parsetree.pvb_expr = copy_expression pvb_expr;\n Ast_412.Parsetree.pvb_attributes = copy_attributes pvb_attributes;\n Ast_412.Parsetree.pvb_loc = copy_location pvb_loc;\n }\n\nand copy_pattern : Ast_411.Parsetree.pattern -> Ast_412.Parsetree.pattern =\n fun {\n Ast_411.Parsetree.ppat_desc;\n Ast_411.Parsetree.ppat_loc;\n Ast_411.Parsetree.ppat_loc_stack;\n Ast_411.Parsetree.ppat_attributes;\n } ->\n {\n Ast_412.Parsetree.ppat_desc = copy_pattern_desc ppat_desc;\n Ast_412.Parsetree.ppat_loc = copy_location ppat_loc;\n Ast_412.Parsetree.ppat_loc_stack = copy_location_stack ppat_loc_stack;\n Ast_412.Parsetree.ppat_attributes = copy_attributes ppat_attributes;\n }\n\nand copy_pattern_desc :\n Ast_411.Parsetree.pattern_desc -> Ast_412.Parsetree.pattern_desc = function\n | Ast_411.Parsetree.Ppat_any -> Ast_412.Parsetree.Ppat_any\n | Ast_411.Parsetree.Ppat_var x0 ->\n Ast_412.Parsetree.Ppat_var (copy_loc (fun x -> x) x0)\n | Ast_411.Parsetree.Ppat_alias (x0, x1) ->\n Ast_412.Parsetree.Ppat_alias (copy_pattern x0, copy_loc (fun x -> x) x1)\n | Ast_411.Parsetree.Ppat_constant x0 ->\n Ast_412.Parsetree.Ppat_constant (copy_constant x0)\n | Ast_411.Parsetree.Ppat_interval (x0, x1) ->\n Ast_412.Parsetree.Ppat_interval (copy_constant x0, copy_constant x1)\n | Ast_411.Parsetree.Ppat_tuple x0 ->\n Ast_412.Parsetree.Ppat_tuple (List.map copy_pattern x0)\n | Ast_411.Parsetree.Ppat_construct (x0, x1) ->\n Ast_412.Parsetree.Ppat_construct\n (copy_loc copy_Longident_t x0, Option.map copy_pattern x1)\n | Ast_411.Parsetree.Ppat_variant (x0, x1) ->\n Ast_412.Parsetree.Ppat_variant (copy_label x0, Option.map copy_pattern x1)\n | Ast_411.Parsetree.Ppat_record (x0, x1) ->\n Ast_412.Parsetree.Ppat_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_pattern x1))\n x0,\n copy_closed_flag x1 )\n | Ast_411.Parsetree.Ppat_array x0 ->\n Ast_412.Parsetree.Ppat_array (List.map copy_pattern x0)\n | Ast_411.Parsetree.Ppat_or (x0, x1) ->\n Ast_412.Parsetree.Ppat_or (copy_pattern x0, copy_pattern x1)\n | Ast_411.Parsetree.Ppat_constraint (x0, x1) ->\n Ast_412.Parsetree.Ppat_constraint (copy_pattern x0, copy_core_type x1)\n | Ast_411.Parsetree.Ppat_type x0 ->\n Ast_412.Parsetree.Ppat_type (copy_loc copy_Longident_t x0)\n | Ast_411.Parsetree.Ppat_lazy x0 ->\n Ast_412.Parsetree.Ppat_lazy (copy_pattern x0)\n | Ast_411.Parsetree.Ppat_unpack x0 ->\n Ast_412.Parsetree.Ppat_unpack\n (copy_loc (fun x -> Option.map (fun x -> x) x) x0)\n | Ast_411.Parsetree.Ppat_exception x0 ->\n Ast_412.Parsetree.Ppat_exception (copy_pattern x0)\n | Ast_411.Parsetree.Ppat_extension x0 ->\n Ast_412.Parsetree.Ppat_extension (copy_extension x0)\n | Ast_411.Parsetree.Ppat_open (x0, x1) ->\n Ast_412.Parsetree.Ppat_open (copy_loc copy_Longident_t x0, copy_pattern x1)\n\nand copy_core_type : Ast_411.Parsetree.core_type -> Ast_412.Parsetree.core_type\n =\n fun {\n Ast_411.Parsetree.ptyp_desc;\n Ast_411.Parsetree.ptyp_loc;\n Ast_411.Parsetree.ptyp_loc_stack;\n Ast_411.Parsetree.ptyp_attributes;\n } ->\n {\n Ast_412.Parsetree.ptyp_desc = copy_core_type_desc ptyp_desc;\n Ast_412.Parsetree.ptyp_loc = copy_location ptyp_loc;\n Ast_412.Parsetree.ptyp_loc_stack = copy_location_stack ptyp_loc_stack;\n Ast_412.Parsetree.ptyp_attributes = copy_attributes ptyp_attributes;\n }\n\nand copy_location_stack :\n Ast_411.Parsetree.location_stack -> Ast_412.Parsetree.location_stack =\n fun x -> x\n\nand copy_core_type_desc :\n Ast_411.Parsetree.core_type_desc -> Ast_412.Parsetree.core_type_desc =\n function\n | Ast_411.Parsetree.Ptyp_any -> Ast_412.Parsetree.Ptyp_any\n | Ast_411.Parsetree.Ptyp_var x0 -> Ast_412.Parsetree.Ptyp_var x0\n | Ast_411.Parsetree.Ptyp_arrow (x0, x1, x2) ->\n Ast_412.Parsetree.Ptyp_arrow\n (copy_arg_label x0, copy_core_type x1, copy_core_type x2)\n | Ast_411.Parsetree.Ptyp_tuple x0 ->\n Ast_412.Parsetree.Ptyp_tuple (List.map copy_core_type x0)\n | Ast_411.Parsetree.Ptyp_constr (x0, x1) ->\n Ast_412.Parsetree.Ptyp_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_411.Parsetree.Ptyp_object (x0, x1) ->\n Ast_412.Parsetree.Ptyp_object\n (List.map copy_object_field x0, copy_closed_flag x1)\n | Ast_411.Parsetree.Ptyp_class (x0, x1) ->\n Ast_412.Parsetree.Ptyp_class\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_411.Parsetree.Ptyp_alias (x0, x1) ->\n Ast_412.Parsetree.Ptyp_alias (copy_core_type x0, x1)\n | Ast_411.Parsetree.Ptyp_variant (x0, x1, x2) ->\n Ast_412.Parsetree.Ptyp_variant\n ( List.map copy_row_field x0,\n copy_closed_flag x1,\n Option.map (fun x -> List.map copy_label x) x2 )\n | Ast_411.Parsetree.Ptyp_poly (x0, x1) ->\n Ast_412.Parsetree.Ptyp_poly\n (List.map (fun x -> copy_loc (fun x -> x) x) x0, copy_core_type x1)\n | Ast_411.Parsetree.Ptyp_package x0 ->\n Ast_412.Parsetree.Ptyp_package (copy_package_type x0)\n | Ast_411.Parsetree.Ptyp_extension x0 ->\n Ast_412.Parsetree.Ptyp_extension (copy_extension x0)\n\nand copy_package_type :\n Ast_411.Parsetree.package_type -> Ast_412.Parsetree.package_type =\n fun x ->\n let x0, x1 = x in\n ( copy_loc copy_Longident_t x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_core_type x1))\n x1 )\n\nand copy_row_field : Ast_411.Parsetree.row_field -> Ast_412.Parsetree.row_field\n =\n fun {\n Ast_411.Parsetree.prf_desc;\n Ast_411.Parsetree.prf_loc;\n Ast_411.Parsetree.prf_attributes;\n } ->\n {\n Ast_412.Parsetree.prf_desc = copy_row_field_desc prf_desc;\n Ast_412.Parsetree.prf_loc = copy_location prf_loc;\n Ast_412.Parsetree.prf_attributes = copy_attributes prf_attributes;\n }\n\nand copy_row_field_desc :\n Ast_411.Parsetree.row_field_desc -> Ast_412.Parsetree.row_field_desc =\n function\n | Ast_411.Parsetree.Rtag (x0, x1, x2) ->\n Ast_412.Parsetree.Rtag\n (copy_loc copy_label x0, x1, List.map copy_core_type x2)\n | Ast_411.Parsetree.Rinherit x0 ->\n Ast_412.Parsetree.Rinherit (copy_core_type x0)\n\nand copy_object_field :\n Ast_411.Parsetree.object_field -> Ast_412.Parsetree.object_field =\n fun {\n Ast_411.Parsetree.pof_desc;\n Ast_411.Parsetree.pof_loc;\n Ast_411.Parsetree.pof_attributes;\n } ->\n {\n Ast_412.Parsetree.pof_desc = copy_object_field_desc pof_desc;\n Ast_412.Parsetree.pof_loc = copy_location pof_loc;\n Ast_412.Parsetree.pof_attributes = copy_attributes pof_attributes;\n }\n\nand copy_attributes :\n Ast_411.Parsetree.attributes -> Ast_412.Parsetree.attributes =\n fun x -> List.map copy_attribute x\n\nand copy_attribute : Ast_411.Parsetree.attribute -> Ast_412.Parsetree.attribute\n =\n fun {\n Ast_411.Parsetree.attr_name;\n Ast_411.Parsetree.attr_payload;\n Ast_411.Parsetree.attr_loc;\n } ->\n {\n Ast_412.Parsetree.attr_name = copy_loc (fun x -> x) attr_name;\n Ast_412.Parsetree.attr_payload = copy_payload attr_payload;\n Ast_412.Parsetree.attr_loc = copy_location attr_loc;\n }\n\nand copy_payload : Ast_411.Parsetree.payload -> Ast_412.Parsetree.payload =\n function\n | Ast_411.Parsetree.PStr x0 -> Ast_412.Parsetree.PStr (copy_structure x0)\n | Ast_411.Parsetree.PSig x0 -> Ast_412.Parsetree.PSig (copy_signature x0)\n | Ast_411.Parsetree.PTyp x0 -> Ast_412.Parsetree.PTyp (copy_core_type x0)\n | Ast_411.Parsetree.PPat (x0, x1) ->\n Ast_412.Parsetree.PPat (copy_pattern x0, Option.map copy_expression x1)\n\nand copy_structure : Ast_411.Parsetree.structure -> Ast_412.Parsetree.structure\n =\n fun x -> List.map copy_structure_item x\n\nand copy_structure_item :\n Ast_411.Parsetree.structure_item -> Ast_412.Parsetree.structure_item =\n fun { Ast_411.Parsetree.pstr_desc; Ast_411.Parsetree.pstr_loc } ->\n {\n Ast_412.Parsetree.pstr_desc = copy_structure_item_desc pstr_desc;\n Ast_412.Parsetree.pstr_loc = copy_location pstr_loc;\n }\n\nand copy_structure_item_desc :\n Ast_411.Parsetree.structure_item_desc ->\n Ast_412.Parsetree.structure_item_desc = function\n | Ast_411.Parsetree.Pstr_eval (x0, x1) ->\n Ast_412.Parsetree.Pstr_eval (copy_expression x0, copy_attributes x1)\n | Ast_411.Parsetree.Pstr_value (x0, x1) ->\n Ast_412.Parsetree.Pstr_value\n (copy_rec_flag x0, List.map copy_value_binding x1)\n | Ast_411.Parsetree.Pstr_primitive x0 ->\n Ast_412.Parsetree.Pstr_primitive (copy_value_description x0)\n | Ast_411.Parsetree.Pstr_type (x0, x1) ->\n Ast_412.Parsetree.Pstr_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | Ast_411.Parsetree.Pstr_typext x0 ->\n Ast_412.Parsetree.Pstr_typext (copy_type_extension x0)\n | Ast_411.Parsetree.Pstr_exception x0 ->\n Ast_412.Parsetree.Pstr_exception (copy_type_exception x0)\n | Ast_411.Parsetree.Pstr_module x0 ->\n Ast_412.Parsetree.Pstr_module (copy_module_binding x0)\n | Ast_411.Parsetree.Pstr_recmodule x0 ->\n Ast_412.Parsetree.Pstr_recmodule (List.map copy_module_binding x0)\n | Ast_411.Parsetree.Pstr_modtype x0 ->\n Ast_412.Parsetree.Pstr_modtype (copy_module_type_declaration x0)\n | Ast_411.Parsetree.Pstr_open x0 ->\n Ast_412.Parsetree.Pstr_open (copy_open_declaration x0)\n | Ast_411.Parsetree.Pstr_class x0 ->\n Ast_412.Parsetree.Pstr_class (List.map copy_class_declaration x0)\n | Ast_411.Parsetree.Pstr_class_type x0 ->\n Ast_412.Parsetree.Pstr_class_type\n (List.map copy_class_type_declaration x0)\n | Ast_411.Parsetree.Pstr_include x0 ->\n Ast_412.Parsetree.Pstr_include (copy_include_declaration x0)\n | Ast_411.Parsetree.Pstr_attribute x0 ->\n Ast_412.Parsetree.Pstr_attribute (copy_attribute x0)\n | Ast_411.Parsetree.Pstr_extension (x0, x1) ->\n Ast_412.Parsetree.Pstr_extension (copy_extension x0, copy_attributes x1)\n\nand copy_include_declaration :\n Ast_411.Parsetree.include_declaration ->\n Ast_412.Parsetree.include_declaration =\n fun x -> copy_include_infos copy_module_expr x\n\nand copy_class_declaration :\n Ast_411.Parsetree.class_declaration -> Ast_412.Parsetree.class_declaration =\n fun x -> copy_class_infos copy_class_expr x\n\nand copy_class_expr :\n Ast_411.Parsetree.class_expr -> Ast_412.Parsetree.class_expr =\n fun {\n Ast_411.Parsetree.pcl_desc;\n Ast_411.Parsetree.pcl_loc;\n Ast_411.Parsetree.pcl_attributes;\n } ->\n {\n Ast_412.Parsetree.pcl_desc = copy_class_expr_desc pcl_desc;\n Ast_412.Parsetree.pcl_loc = copy_location pcl_loc;\n Ast_412.Parsetree.pcl_attributes = copy_attributes pcl_attributes;\n }\n\nand copy_class_expr_desc :\n Ast_411.Parsetree.class_expr_desc -> Ast_412.Parsetree.class_expr_desc =\n function\n | Ast_411.Parsetree.Pcl_constr (x0, x1) ->\n Ast_412.Parsetree.Pcl_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_411.Parsetree.Pcl_structure x0 ->\n Ast_412.Parsetree.Pcl_structure (copy_class_structure x0)\n | Ast_411.Parsetree.Pcl_fun (x0, x1, x2, x3) ->\n Ast_412.Parsetree.Pcl_fun\n ( copy_arg_label x0,\n Option.map copy_expression x1,\n copy_pattern x2,\n copy_class_expr x3 )\n | Ast_411.Parsetree.Pcl_apply (x0, x1) ->\n Ast_412.Parsetree.Pcl_apply\n ( copy_class_expr x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | Ast_411.Parsetree.Pcl_let (x0, x1, x2) ->\n Ast_412.Parsetree.Pcl_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_class_expr x2)\n | Ast_411.Parsetree.Pcl_constraint (x0, x1) ->\n Ast_412.Parsetree.Pcl_constraint (copy_class_expr x0, copy_class_type x1)\n | Ast_411.Parsetree.Pcl_extension x0 ->\n Ast_412.Parsetree.Pcl_extension (copy_extension x0)\n | Ast_411.Parsetree.Pcl_open (x0, x1) ->\n Ast_412.Parsetree.Pcl_open (copy_open_description x0, copy_class_expr x1)\n\nand copy_class_structure :\n Ast_411.Parsetree.class_structure -> Ast_412.Parsetree.class_structure =\n fun { Ast_411.Parsetree.pcstr_self; Ast_411.Parsetree.pcstr_fields } ->\n {\n Ast_412.Parsetree.pcstr_self = copy_pattern pcstr_self;\n Ast_412.Parsetree.pcstr_fields = List.map copy_class_field pcstr_fields;\n }\n\nand copy_class_field :\n Ast_411.Parsetree.class_field -> Ast_412.Parsetree.class_field =\n fun {\n Ast_411.Parsetree.pcf_desc;\n Ast_411.Parsetree.pcf_loc;\n Ast_411.Parsetree.pcf_attributes;\n } ->\n {\n Ast_412.Parsetree.pcf_desc = copy_class_field_desc pcf_desc;\n Ast_412.Parsetree.pcf_loc = copy_location pcf_loc;\n Ast_412.Parsetree.pcf_attributes = copy_attributes pcf_attributes;\n }\n\nand copy_class_field_desc :\n Ast_411.Parsetree.class_field_desc -> Ast_412.Parsetree.class_field_desc =\n function\n | Ast_411.Parsetree.Pcf_inherit (x0, x1, x2) ->\n Ast_412.Parsetree.Pcf_inherit\n ( copy_override_flag x0,\n copy_class_expr x1,\n Option.map (fun x -> copy_loc (fun x -> x) x) x2 )\n | Ast_411.Parsetree.Pcf_val x0 ->\n Ast_412.Parsetree.Pcf_val\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_mutable_flag x1, copy_class_field_kind x2))\n | Ast_411.Parsetree.Pcf_method x0 ->\n Ast_412.Parsetree.Pcf_method\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_private_flag x1, copy_class_field_kind x2))\n | Ast_411.Parsetree.Pcf_constraint x0 ->\n Ast_412.Parsetree.Pcf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | Ast_411.Parsetree.Pcf_initializer x0 ->\n Ast_412.Parsetree.Pcf_initializer (copy_expression x0)\n | Ast_411.Parsetree.Pcf_attribute x0 ->\n Ast_412.Parsetree.Pcf_attribute (copy_attribute x0)\n | Ast_411.Parsetree.Pcf_extension x0 ->\n Ast_412.Parsetree.Pcf_extension (copy_extension x0)\n\nand copy_class_field_kind :\n Ast_411.Parsetree.class_field_kind -> Ast_412.Parsetree.class_field_kind =\n function\n | Ast_411.Parsetree.Cfk_virtual x0 ->\n Ast_412.Parsetree.Cfk_virtual (copy_core_type x0)\n | Ast_411.Parsetree.Cfk_concrete (x0, x1) ->\n Ast_412.Parsetree.Cfk_concrete (copy_override_flag x0, copy_expression x1)\n\nand copy_open_declaration :\n Ast_411.Parsetree.open_declaration -> Ast_412.Parsetree.open_declaration =\n fun x -> copy_open_infos copy_module_expr x\n\nand copy_module_binding :\n Ast_411.Parsetree.module_binding -> Ast_412.Parsetree.module_binding =\n fun {\n Ast_411.Parsetree.pmb_name;\n Ast_411.Parsetree.pmb_expr;\n Ast_411.Parsetree.pmb_attributes;\n Ast_411.Parsetree.pmb_loc;\n } ->\n {\n Ast_412.Parsetree.pmb_name =\n copy_loc (fun x -> Option.map (fun x -> x) x) pmb_name;\n Ast_412.Parsetree.pmb_expr = copy_module_expr pmb_expr;\n Ast_412.Parsetree.pmb_attributes = copy_attributes pmb_attributes;\n Ast_412.Parsetree.pmb_loc = copy_location pmb_loc;\n }\n\nand copy_module_expr :\n Ast_411.Parsetree.module_expr -> Ast_412.Parsetree.module_expr =\n fun {\n Ast_411.Parsetree.pmod_desc;\n Ast_411.Parsetree.pmod_loc;\n Ast_411.Parsetree.pmod_attributes;\n } ->\n {\n Ast_412.Parsetree.pmod_desc = copy_module_expr_desc pmod_desc;\n Ast_412.Parsetree.pmod_loc = copy_location pmod_loc;\n Ast_412.Parsetree.pmod_attributes = copy_attributes pmod_attributes;\n }\n\nand copy_module_expr_desc :\n Ast_411.Parsetree.module_expr_desc -> Ast_412.Parsetree.module_expr_desc =\n function\n | Ast_411.Parsetree.Pmod_ident x0 ->\n Ast_412.Parsetree.Pmod_ident (copy_loc copy_Longident_t x0)\n | Ast_411.Parsetree.Pmod_structure x0 ->\n Ast_412.Parsetree.Pmod_structure (copy_structure x0)\n | Ast_411.Parsetree.Pmod_functor (x0, x1) ->\n Ast_412.Parsetree.Pmod_functor\n (copy_functor_parameter x0, copy_module_expr x1)\n | Ast_411.Parsetree.Pmod_apply (x0, x1) ->\n Ast_412.Parsetree.Pmod_apply (copy_module_expr x0, copy_module_expr x1)\n | Ast_411.Parsetree.Pmod_constraint (x0, x1) ->\n Ast_412.Parsetree.Pmod_constraint\n (copy_module_expr x0, copy_module_type x1)\n | Ast_411.Parsetree.Pmod_unpack x0 ->\n Ast_412.Parsetree.Pmod_unpack (copy_expression x0)\n | Ast_411.Parsetree.Pmod_extension x0 ->\n Ast_412.Parsetree.Pmod_extension (copy_extension x0)\n\nand copy_functor_parameter :\n Ast_411.Parsetree.functor_parameter -> Ast_412.Parsetree.functor_parameter =\n function\n | Ast_411.Parsetree.Unit -> Ast_412.Parsetree.Unit\n | Ast_411.Parsetree.Named (x0, x1) ->\n Ast_412.Parsetree.Named\n (copy_loc (fun x -> Option.map (fun x -> x) x) x0, copy_module_type x1)\n\nand copy_module_type :\n Ast_411.Parsetree.module_type -> Ast_412.Parsetree.module_type =\n fun {\n Ast_411.Parsetree.pmty_desc;\n Ast_411.Parsetree.pmty_loc;\n Ast_411.Parsetree.pmty_attributes;\n } ->\n {\n Ast_412.Parsetree.pmty_desc = copy_module_type_desc pmty_desc;\n Ast_412.Parsetree.pmty_loc = copy_location pmty_loc;\n Ast_412.Parsetree.pmty_attributes = copy_attributes pmty_attributes;\n }\n\nand copy_module_type_desc :\n Ast_411.Parsetree.module_type_desc -> Ast_412.Parsetree.module_type_desc =\n function\n | Ast_411.Parsetree.Pmty_ident x0 ->\n Ast_412.Parsetree.Pmty_ident (copy_loc copy_Longident_t x0)\n | Ast_411.Parsetree.Pmty_signature x0 ->\n Ast_412.Parsetree.Pmty_signature (copy_signature x0)\n | Ast_411.Parsetree.Pmty_functor (x0, x1) ->\n Ast_412.Parsetree.Pmty_functor\n (copy_functor_parameter x0, copy_module_type x1)\n | Ast_411.Parsetree.Pmty_with (x0, x1) ->\n Ast_412.Parsetree.Pmty_with\n (copy_module_type x0, List.map copy_with_constraint x1)\n | Ast_411.Parsetree.Pmty_typeof x0 ->\n Ast_412.Parsetree.Pmty_typeof (copy_module_expr x0)\n | Ast_411.Parsetree.Pmty_extension x0 ->\n Ast_412.Parsetree.Pmty_extension (copy_extension x0)\n | Ast_411.Parsetree.Pmty_alias x0 ->\n Ast_412.Parsetree.Pmty_alias (copy_loc copy_Longident_t x0)\n\nand copy_with_constraint :\n Ast_411.Parsetree.with_constraint -> Ast_412.Parsetree.with_constraint =\n function\n | Ast_411.Parsetree.Pwith_type (x0, x1) ->\n Ast_412.Parsetree.Pwith_type\n (copy_loc copy_Longident_t x0, copy_type_declaration x1)\n | Ast_411.Parsetree.Pwith_module (x0, x1) ->\n Ast_412.Parsetree.Pwith_module\n (copy_loc copy_Longident_t x0, copy_loc copy_Longident_t x1)\n | Ast_411.Parsetree.Pwith_typesubst (x0, x1) ->\n Ast_412.Parsetree.Pwith_typesubst\n (copy_loc copy_Longident_t x0, copy_type_declaration x1)\n | Ast_411.Parsetree.Pwith_modsubst (x0, x1) ->\n Ast_412.Parsetree.Pwith_modsubst\n (copy_loc copy_Longident_t x0, copy_loc copy_Longident_t x1)\n\nand copy_signature : Ast_411.Parsetree.signature -> Ast_412.Parsetree.signature\n =\n fun x -> List.map copy_signature_item x\n\nand copy_signature_item :\n Ast_411.Parsetree.signature_item -> Ast_412.Parsetree.signature_item =\n fun { Ast_411.Parsetree.psig_desc; Ast_411.Parsetree.psig_loc } ->\n {\n Ast_412.Parsetree.psig_desc = copy_signature_item_desc psig_desc;\n Ast_412.Parsetree.psig_loc = copy_location psig_loc;\n }\n\nand copy_signature_item_desc :\n Ast_411.Parsetree.signature_item_desc ->\n Ast_412.Parsetree.signature_item_desc = function\n | Ast_411.Parsetree.Psig_value x0 ->\n Ast_412.Parsetree.Psig_value (copy_value_description x0)\n | Ast_411.Parsetree.Psig_type (x0, x1) ->\n Ast_412.Parsetree.Psig_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | Ast_411.Parsetree.Psig_typesubst x0 ->\n Ast_412.Parsetree.Psig_typesubst (List.map copy_type_declaration x0)\n | Ast_411.Parsetree.Psig_typext x0 ->\n Ast_412.Parsetree.Psig_typext (copy_type_extension x0)\n | Ast_411.Parsetree.Psig_exception x0 ->\n Ast_412.Parsetree.Psig_exception (copy_type_exception x0)\n | Ast_411.Parsetree.Psig_module x0 ->\n Ast_412.Parsetree.Psig_module (copy_module_declaration x0)\n | Ast_411.Parsetree.Psig_modsubst x0 ->\n Ast_412.Parsetree.Psig_modsubst (copy_module_substitution x0)\n | Ast_411.Parsetree.Psig_recmodule x0 ->\n Ast_412.Parsetree.Psig_recmodule (List.map copy_module_declaration x0)\n | Ast_411.Parsetree.Psig_modtype x0 ->\n Ast_412.Parsetree.Psig_modtype (copy_module_type_declaration x0)\n | Ast_411.Parsetree.Psig_open x0 ->\n Ast_412.Parsetree.Psig_open (copy_open_description x0)\n | Ast_411.Parsetree.Psig_include x0 ->\n Ast_412.Parsetree.Psig_include (copy_include_description x0)\n | Ast_411.Parsetree.Psig_class x0 ->\n Ast_412.Parsetree.Psig_class (List.map copy_class_description x0)\n | Ast_411.Parsetree.Psig_class_type x0 ->\n Ast_412.Parsetree.Psig_class_type\n (List.map copy_class_type_declaration x0)\n | Ast_411.Parsetree.Psig_attribute x0 ->\n Ast_412.Parsetree.Psig_attribute (copy_attribute x0)\n | Ast_411.Parsetree.Psig_extension (x0, x1) ->\n Ast_412.Parsetree.Psig_extension (copy_extension x0, copy_attributes x1)\n\nand copy_class_type_declaration :\n Ast_411.Parsetree.class_type_declaration ->\n Ast_412.Parsetree.class_type_declaration =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_description :\n Ast_411.Parsetree.class_description -> Ast_412.Parsetree.class_description =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_type :\n Ast_411.Parsetree.class_type -> Ast_412.Parsetree.class_type =\n fun {\n Ast_411.Parsetree.pcty_desc;\n Ast_411.Parsetree.pcty_loc;\n Ast_411.Parsetree.pcty_attributes;\n } ->\n {\n Ast_412.Parsetree.pcty_desc = copy_class_type_desc pcty_desc;\n Ast_412.Parsetree.pcty_loc = copy_location pcty_loc;\n Ast_412.Parsetree.pcty_attributes = copy_attributes pcty_attributes;\n }\n\nand copy_class_type_desc :\n Ast_411.Parsetree.class_type_desc -> Ast_412.Parsetree.class_type_desc =\n function\n | Ast_411.Parsetree.Pcty_constr (x0, x1) ->\n Ast_412.Parsetree.Pcty_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_411.Parsetree.Pcty_signature x0 ->\n Ast_412.Parsetree.Pcty_signature (copy_class_signature x0)\n | Ast_411.Parsetree.Pcty_arrow (x0, x1, x2) ->\n Ast_412.Parsetree.Pcty_arrow\n (copy_arg_label x0, copy_core_type x1, copy_class_type x2)\n | Ast_411.Parsetree.Pcty_extension x0 ->\n Ast_412.Parsetree.Pcty_extension (copy_extension x0)\n | Ast_411.Parsetree.Pcty_open (x0, x1) ->\n Ast_412.Parsetree.Pcty_open (copy_open_description x0, copy_class_type x1)\n\nand copy_class_signature :\n Ast_411.Parsetree.class_signature -> Ast_412.Parsetree.class_signature =\n fun { Ast_411.Parsetree.pcsig_self; Ast_411.Parsetree.pcsig_fields } ->\n {\n Ast_412.Parsetree.pcsig_self = copy_core_type pcsig_self;\n Ast_412.Parsetree.pcsig_fields = List.map copy_class_type_field pcsig_fields;\n }\n\nand copy_class_type_field :\n Ast_411.Parsetree.class_type_field -> Ast_412.Parsetree.class_type_field =\n fun {\n Ast_411.Parsetree.pctf_desc;\n Ast_411.Parsetree.pctf_loc;\n Ast_411.Parsetree.pctf_attributes;\n } ->\n {\n Ast_412.Parsetree.pctf_desc = copy_class_type_field_desc pctf_desc;\n Ast_412.Parsetree.pctf_loc = copy_location pctf_loc;\n Ast_412.Parsetree.pctf_attributes = copy_attributes pctf_attributes;\n }\n\nand copy_class_type_field_desc :\n Ast_411.Parsetree.class_type_field_desc ->\n Ast_412.Parsetree.class_type_field_desc = function\n | Ast_411.Parsetree.Pctf_inherit x0 ->\n Ast_412.Parsetree.Pctf_inherit (copy_class_type x0)\n | Ast_411.Parsetree.Pctf_val x0 ->\n Ast_412.Parsetree.Pctf_val\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_mutable_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | Ast_411.Parsetree.Pctf_method x0 ->\n Ast_412.Parsetree.Pctf_method\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_private_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | Ast_411.Parsetree.Pctf_constraint x0 ->\n Ast_412.Parsetree.Pctf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | Ast_411.Parsetree.Pctf_attribute x0 ->\n Ast_412.Parsetree.Pctf_attribute (copy_attribute x0)\n | Ast_411.Parsetree.Pctf_extension x0 ->\n Ast_412.Parsetree.Pctf_extension (copy_extension x0)\n\nand copy_extension : Ast_411.Parsetree.extension -> Ast_412.Parsetree.extension\n =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_class_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_411.Parsetree.class_infos ->\n 'g0 Ast_412.Parsetree.class_infos =\n fun f0\n {\n Ast_411.Parsetree.pci_virt;\n Ast_411.Parsetree.pci_params;\n Ast_411.Parsetree.pci_name;\n Ast_411.Parsetree.pci_expr;\n Ast_411.Parsetree.pci_loc;\n Ast_411.Parsetree.pci_attributes;\n } ->\n {\n Ast_412.Parsetree.pci_virt = copy_virtual_flag pci_virt;\n Ast_412.Parsetree.pci_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, (copy_variance x1, Ast_412.Asttypes.NoInjectivity)))\n pci_params;\n Ast_412.Parsetree.pci_name = copy_loc (fun x -> x) pci_name;\n Ast_412.Parsetree.pci_expr = f0 pci_expr;\n Ast_412.Parsetree.pci_loc = copy_location pci_loc;\n Ast_412.Parsetree.pci_attributes = copy_attributes pci_attributes;\n }\n\nand copy_virtual_flag :\n Ast_411.Asttypes.virtual_flag -> Ast_412.Asttypes.virtual_flag = function\n | Ast_411.Asttypes.Virtual -> Ast_412.Asttypes.Virtual\n | Ast_411.Asttypes.Concrete -> Ast_412.Asttypes.Concrete\n\nand copy_include_description :\n Ast_411.Parsetree.include_description ->\n Ast_412.Parsetree.include_description =\n fun x -> copy_include_infos copy_module_type x\n\nand copy_include_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_411.Parsetree.include_infos ->\n 'g0 Ast_412.Parsetree.include_infos =\n fun f0\n {\n Ast_411.Parsetree.pincl_mod;\n Ast_411.Parsetree.pincl_loc;\n Ast_411.Parsetree.pincl_attributes;\n } ->\n {\n Ast_412.Parsetree.pincl_mod = f0 pincl_mod;\n Ast_412.Parsetree.pincl_loc = copy_location pincl_loc;\n Ast_412.Parsetree.pincl_attributes = copy_attributes pincl_attributes;\n }\n\nand copy_open_description :\n Ast_411.Parsetree.open_description -> Ast_412.Parsetree.open_description =\n fun x -> copy_open_infos (fun x -> copy_loc copy_Longident_t x) x\n\nand copy_open_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_411.Parsetree.open_infos ->\n 'g0 Ast_412.Parsetree.open_infos =\n fun f0\n {\n Ast_411.Parsetree.popen_expr;\n Ast_411.Parsetree.popen_override;\n Ast_411.Parsetree.popen_loc;\n Ast_411.Parsetree.popen_attributes;\n } ->\n {\n Ast_412.Parsetree.popen_expr = f0 popen_expr;\n Ast_412.Parsetree.popen_override = copy_override_flag popen_override;\n Ast_412.Parsetree.popen_loc = copy_location popen_loc;\n Ast_412.Parsetree.popen_attributes = copy_attributes popen_attributes;\n }\n\nand copy_override_flag :\n Ast_411.Asttypes.override_flag -> Ast_412.Asttypes.override_flag = function\n | Ast_411.Asttypes.Override -> Ast_412.Asttypes.Override\n | Ast_411.Asttypes.Fresh -> Ast_412.Asttypes.Fresh\n\nand copy_module_type_declaration :\n Ast_411.Parsetree.module_type_declaration ->\n Ast_412.Parsetree.module_type_declaration =\n fun {\n Ast_411.Parsetree.pmtd_name;\n Ast_411.Parsetree.pmtd_type;\n Ast_411.Parsetree.pmtd_attributes;\n Ast_411.Parsetree.pmtd_loc;\n } ->\n {\n Ast_412.Parsetree.pmtd_name = copy_loc (fun x -> x) pmtd_name;\n Ast_412.Parsetree.pmtd_type = Option.map copy_module_type pmtd_type;\n Ast_412.Parsetree.pmtd_attributes = copy_attributes pmtd_attributes;\n Ast_412.Parsetree.pmtd_loc = copy_location pmtd_loc;\n }\n\nand copy_module_substitution :\n Ast_411.Parsetree.module_substitution ->\n Ast_412.Parsetree.module_substitution =\n fun {\n Ast_411.Parsetree.pms_name;\n Ast_411.Parsetree.pms_manifest;\n Ast_411.Parsetree.pms_attributes;\n Ast_411.Parsetree.pms_loc;\n } ->\n {\n Ast_412.Parsetree.pms_name = copy_loc (fun x -> x) pms_name;\n Ast_412.Parsetree.pms_manifest = copy_loc copy_Longident_t pms_manifest;\n Ast_412.Parsetree.pms_attributes = copy_attributes pms_attributes;\n Ast_412.Parsetree.pms_loc = copy_location pms_loc;\n }\n\nand copy_module_declaration :\n Ast_411.Parsetree.module_declaration -> Ast_412.Parsetree.module_declaration\n =\n fun {\n Ast_411.Parsetree.pmd_name;\n Ast_411.Parsetree.pmd_type;\n Ast_411.Parsetree.pmd_attributes;\n Ast_411.Parsetree.pmd_loc;\n } ->\n {\n Ast_412.Parsetree.pmd_name =\n copy_loc (fun x -> Option.map (fun x -> x) x) pmd_name;\n Ast_412.Parsetree.pmd_type = copy_module_type pmd_type;\n Ast_412.Parsetree.pmd_attributes = copy_attributes pmd_attributes;\n Ast_412.Parsetree.pmd_loc = copy_location pmd_loc;\n }\n\nand copy_type_exception :\n Ast_411.Parsetree.type_exception -> Ast_412.Parsetree.type_exception =\n fun {\n Ast_411.Parsetree.ptyexn_constructor;\n Ast_411.Parsetree.ptyexn_loc;\n Ast_411.Parsetree.ptyexn_attributes;\n } ->\n {\n Ast_412.Parsetree.ptyexn_constructor =\n copy_extension_constructor ptyexn_constructor;\n Ast_412.Parsetree.ptyexn_loc = copy_location ptyexn_loc;\n Ast_412.Parsetree.ptyexn_attributes = copy_attributes ptyexn_attributes;\n }\n\nand copy_type_extension :\n Ast_411.Parsetree.type_extension -> Ast_412.Parsetree.type_extension =\n fun {\n Ast_411.Parsetree.ptyext_path;\n Ast_411.Parsetree.ptyext_params;\n Ast_411.Parsetree.ptyext_constructors;\n Ast_411.Parsetree.ptyext_private;\n Ast_411.Parsetree.ptyext_loc;\n Ast_411.Parsetree.ptyext_attributes;\n } ->\n {\n Ast_412.Parsetree.ptyext_path = copy_loc copy_Longident_t ptyext_path;\n Ast_412.Parsetree.ptyext_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, (copy_variance x1, Ast_412.Asttypes.NoInjectivity)))\n ptyext_params;\n Ast_412.Parsetree.ptyext_constructors =\n List.map copy_extension_constructor ptyext_constructors;\n Ast_412.Parsetree.ptyext_private = copy_private_flag ptyext_private;\n Ast_412.Parsetree.ptyext_loc = copy_location ptyext_loc;\n Ast_412.Parsetree.ptyext_attributes = copy_attributes ptyext_attributes;\n }\n\nand copy_extension_constructor :\n Ast_411.Parsetree.extension_constructor ->\n Ast_412.Parsetree.extension_constructor =\n fun {\n Ast_411.Parsetree.pext_name;\n Ast_411.Parsetree.pext_kind;\n Ast_411.Parsetree.pext_loc;\n Ast_411.Parsetree.pext_attributes;\n } ->\n {\n Ast_412.Parsetree.pext_name = copy_loc (fun x -> x) pext_name;\n Ast_412.Parsetree.pext_kind = copy_extension_constructor_kind pext_kind;\n Ast_412.Parsetree.pext_loc = copy_location pext_loc;\n Ast_412.Parsetree.pext_attributes = copy_attributes pext_attributes;\n }\n\nand copy_extension_constructor_kind :\n Ast_411.Parsetree.extension_constructor_kind ->\n Ast_412.Parsetree.extension_constructor_kind = function\n | Ast_411.Parsetree.Pext_decl (x0, x1) ->\n Ast_412.Parsetree.Pext_decl\n (copy_constructor_arguments x0, Option.map copy_core_type x1)\n | Ast_411.Parsetree.Pext_rebind x0 ->\n Ast_412.Parsetree.Pext_rebind (copy_loc copy_Longident_t x0)\n\nand copy_type_declaration :\n Ast_411.Parsetree.type_declaration -> Ast_412.Parsetree.type_declaration =\n fun {\n Ast_411.Parsetree.ptype_name;\n Ast_411.Parsetree.ptype_params;\n Ast_411.Parsetree.ptype_cstrs;\n Ast_411.Parsetree.ptype_kind;\n Ast_411.Parsetree.ptype_private;\n Ast_411.Parsetree.ptype_manifest;\n Ast_411.Parsetree.ptype_attributes;\n Ast_411.Parsetree.ptype_loc;\n } ->\n {\n Ast_412.Parsetree.ptype_name = copy_loc (fun x -> x) ptype_name;\n Ast_412.Parsetree.ptype_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, (copy_variance x1, Ast_412.Asttypes.NoInjectivity)))\n ptype_params;\n Ast_412.Parsetree.ptype_cstrs =\n List.map\n (fun x ->\n let x0, x1, x2 = x in\n (copy_core_type x0, copy_core_type x1, copy_location x2))\n ptype_cstrs;\n Ast_412.Parsetree.ptype_kind = copy_type_kind ptype_kind;\n Ast_412.Parsetree.ptype_private = copy_private_flag ptype_private;\n Ast_412.Parsetree.ptype_manifest = Option.map copy_core_type ptype_manifest;\n Ast_412.Parsetree.ptype_attributes = copy_attributes ptype_attributes;\n Ast_412.Parsetree.ptype_loc = copy_location ptype_loc;\n }\n\nand copy_private_flag :\n Ast_411.Asttypes.private_flag -> Ast_412.Asttypes.private_flag = function\n | Ast_411.Asttypes.Private -> Ast_412.Asttypes.Private\n | Ast_411.Asttypes.Public -> Ast_412.Asttypes.Public\n\nand copy_type_kind : Ast_411.Parsetree.type_kind -> Ast_412.Parsetree.type_kind\n = function\n | Ast_411.Parsetree.Ptype_abstract -> Ast_412.Parsetree.Ptype_abstract\n | Ast_411.Parsetree.Ptype_variant x0 ->\n Ast_412.Parsetree.Ptype_variant (List.map copy_constructor_declaration x0)\n | Ast_411.Parsetree.Ptype_record x0 ->\n Ast_412.Parsetree.Ptype_record (List.map copy_label_declaration x0)\n | Ast_411.Parsetree.Ptype_open -> Ast_412.Parsetree.Ptype_open\n\nand copy_constructor_declaration :\n Ast_411.Parsetree.constructor_declaration ->\n Ast_412.Parsetree.constructor_declaration =\n fun {\n Ast_411.Parsetree.pcd_name;\n Ast_411.Parsetree.pcd_args;\n Ast_411.Parsetree.pcd_res;\n Ast_411.Parsetree.pcd_loc;\n Ast_411.Parsetree.pcd_attributes;\n } ->\n {\n Ast_412.Parsetree.pcd_name = copy_loc (fun x -> x) pcd_name;\n Ast_412.Parsetree.pcd_args = copy_constructor_arguments pcd_args;\n Ast_412.Parsetree.pcd_res = Option.map copy_core_type pcd_res;\n Ast_412.Parsetree.pcd_loc = copy_location pcd_loc;\n Ast_412.Parsetree.pcd_attributes = copy_attributes pcd_attributes;\n }\n\nand copy_constructor_arguments :\n Ast_411.Parsetree.constructor_arguments ->\n Ast_412.Parsetree.constructor_arguments = function\n | Ast_411.Parsetree.Pcstr_tuple x0 ->\n Ast_412.Parsetree.Pcstr_tuple (List.map copy_core_type x0)\n | Ast_411.Parsetree.Pcstr_record x0 ->\n Ast_412.Parsetree.Pcstr_record (List.map copy_label_declaration x0)\n\nand copy_label_declaration :\n Ast_411.Parsetree.label_declaration -> Ast_412.Parsetree.label_declaration =\n fun {\n Ast_411.Parsetree.pld_name;\n Ast_411.Parsetree.pld_mutable;\n Ast_411.Parsetree.pld_type;\n Ast_411.Parsetree.pld_loc;\n Ast_411.Parsetree.pld_attributes;\n } ->\n {\n Ast_412.Parsetree.pld_name = copy_loc (fun x -> x) pld_name;\n Ast_412.Parsetree.pld_mutable = copy_mutable_flag pld_mutable;\n Ast_412.Parsetree.pld_type = copy_core_type pld_type;\n Ast_412.Parsetree.pld_loc = copy_location pld_loc;\n Ast_412.Parsetree.pld_attributes = copy_attributes pld_attributes;\n }\n\nand copy_mutable_flag :\n Ast_411.Asttypes.mutable_flag -> Ast_412.Asttypes.mutable_flag = function\n | Ast_411.Asttypes.Immutable -> Ast_412.Asttypes.Immutable\n | Ast_411.Asttypes.Mutable -> Ast_412.Asttypes.Mutable\n\nand copy_variance : Ast_411.Asttypes.variance -> Ast_412.Asttypes.variance =\n function\n | Ast_411.Asttypes.Covariant -> Ast_412.Asttypes.Covariant\n | Ast_411.Asttypes.Contravariant -> Ast_412.Asttypes.Contravariant\n | Ast_411.Asttypes.Invariant -> Ast_412.Asttypes.NoVariance\n\nand copy_value_description :\n Ast_411.Parsetree.value_description -> Ast_412.Parsetree.value_description =\n fun {\n Ast_411.Parsetree.pval_name;\n Ast_411.Parsetree.pval_type;\n Ast_411.Parsetree.pval_prim;\n Ast_411.Parsetree.pval_attributes;\n Ast_411.Parsetree.pval_loc;\n } ->\n {\n Ast_412.Parsetree.pval_name = copy_loc (fun x -> x) pval_name;\n Ast_412.Parsetree.pval_type = copy_core_type pval_type;\n Ast_412.Parsetree.pval_prim = List.map (fun x -> x) pval_prim;\n Ast_412.Parsetree.pval_attributes = copy_attributes pval_attributes;\n Ast_412.Parsetree.pval_loc = copy_location pval_loc;\n }\n\nand copy_object_field_desc :\n Ast_411.Parsetree.object_field_desc -> Ast_412.Parsetree.object_field_desc =\n function\n | Ast_411.Parsetree.Otag (x0, x1) ->\n Ast_412.Parsetree.Otag (copy_loc copy_label x0, copy_core_type x1)\n | Ast_411.Parsetree.Oinherit x0 ->\n Ast_412.Parsetree.Oinherit (copy_core_type x0)\n\nand copy_arg_label : Ast_411.Asttypes.arg_label -> Ast_412.Asttypes.arg_label =\n function\n | Ast_411.Asttypes.Nolabel -> Ast_412.Asttypes.Nolabel\n | Ast_411.Asttypes.Labelled x0 -> Ast_412.Asttypes.Labelled x0\n | Ast_411.Asttypes.Optional x0 -> Ast_412.Asttypes.Optional x0\n\nand copy_closed_flag :\n Ast_411.Asttypes.closed_flag -> Ast_412.Asttypes.closed_flag = function\n | Ast_411.Asttypes.Closed -> Ast_412.Asttypes.Closed\n | Ast_411.Asttypes.Open -> Ast_412.Asttypes.Open\n\nand copy_label : Ast_411.Asttypes.label -> Ast_412.Asttypes.label = fun x -> x\n\nand copy_rec_flag : Ast_411.Asttypes.rec_flag -> Ast_412.Asttypes.rec_flag =\n function\n | Ast_411.Asttypes.Nonrecursive -> Ast_412.Asttypes.Nonrecursive\n | Ast_411.Asttypes.Recursive -> Ast_412.Asttypes.Recursive\n\nand copy_constant : Ast_411.Parsetree.constant -> Ast_412.Parsetree.constant =\n function\n | Ast_411.Parsetree.Pconst_integer (x0, x1) ->\n Ast_412.Parsetree.Pconst_integer (x0, Option.map (fun x -> x) x1)\n | Ast_411.Parsetree.Pconst_char x0 -> Ast_412.Parsetree.Pconst_char x0\n | Ast_411.Parsetree.Pconst_string (x0, x1, x2) ->\n Ast_412.Parsetree.Pconst_string\n (x0, copy_location x1, Option.map (fun x -> x) x2)\n | Ast_411.Parsetree.Pconst_float (x0, x1) ->\n Ast_412.Parsetree.Pconst_float (x0, Option.map (fun x -> x) x1)\n\nand copy_Longident_t : Longident.t -> Longident.t = fun x -> x\n\nand copy_loc :\n 'f0 'g0.\n ('f0 -> 'g0) -> 'f0 Ast_411.Asttypes.loc -> 'g0 Ast_412.Asttypes.loc =\n fun f0 { Ast_411.Asttypes.txt; Ast_411.Asttypes.loc } ->\n { Ast_412.Asttypes.txt = f0 txt; Ast_412.Asttypes.loc = copy_location loc }\n\nand copy_location : Location.t -> Location.t = fun x -> x\n","open Stdlib0\nmodule From = Ast_411\nmodule To = Ast_410\n\nlet rec copy_toplevel_phrase :\n Ast_411.Parsetree.toplevel_phrase -> Ast_410.Parsetree.toplevel_phrase =\n function\n | Ast_411.Parsetree.Ptop_def x0 ->\n Ast_410.Parsetree.Ptop_def (copy_structure x0)\n | Ast_411.Parsetree.Ptop_dir x0 ->\n Ast_410.Parsetree.Ptop_dir (copy_toplevel_directive x0)\n\nand copy_toplevel_directive :\n Ast_411.Parsetree.toplevel_directive -> Ast_410.Parsetree.toplevel_directive\n =\n fun {\n Ast_411.Parsetree.pdir_name;\n Ast_411.Parsetree.pdir_arg;\n Ast_411.Parsetree.pdir_loc;\n } ->\n {\n Ast_410.Parsetree.pdir_name = copy_loc (fun x -> x) pdir_name;\n Ast_410.Parsetree.pdir_arg = Option.map copy_directive_argument pdir_arg;\n Ast_410.Parsetree.pdir_loc = copy_location pdir_loc;\n }\n\nand copy_directive_argument :\n Ast_411.Parsetree.directive_argument -> Ast_410.Parsetree.directive_argument\n =\n fun { Ast_411.Parsetree.pdira_desc; Ast_411.Parsetree.pdira_loc } ->\n {\n Ast_410.Parsetree.pdira_desc = copy_directive_argument_desc pdira_desc;\n Ast_410.Parsetree.pdira_loc = copy_location pdira_loc;\n }\n\nand copy_directive_argument_desc :\n Ast_411.Parsetree.directive_argument_desc ->\n Ast_410.Parsetree.directive_argument_desc = function\n | Ast_411.Parsetree.Pdir_string x0 -> Ast_410.Parsetree.Pdir_string x0\n | Ast_411.Parsetree.Pdir_int (x0, x1) ->\n Ast_410.Parsetree.Pdir_int (x0, Option.map (fun x -> x) x1)\n | Ast_411.Parsetree.Pdir_ident x0 ->\n Ast_410.Parsetree.Pdir_ident (copy_Longident_t x0)\n | Ast_411.Parsetree.Pdir_bool x0 -> Ast_410.Parsetree.Pdir_bool x0\n\nand copy_expression :\n Ast_411.Parsetree.expression -> Ast_410.Parsetree.expression =\n fun {\n Ast_411.Parsetree.pexp_desc;\n Ast_411.Parsetree.pexp_loc;\n Ast_411.Parsetree.pexp_loc_stack;\n Ast_411.Parsetree.pexp_attributes;\n } ->\n {\n Ast_410.Parsetree.pexp_desc = copy_expression_desc pexp_desc;\n Ast_410.Parsetree.pexp_loc = copy_location pexp_loc;\n Ast_410.Parsetree.pexp_loc_stack = copy_location_stack pexp_loc_stack;\n Ast_410.Parsetree.pexp_attributes = copy_attributes pexp_attributes;\n }\n\nand copy_expr x = copy_expression x\n\nand copy_expression_desc :\n Ast_411.Parsetree.expression_desc -> Ast_410.Parsetree.expression_desc =\n function\n | Ast_411.Parsetree.Pexp_ident x0 ->\n Ast_410.Parsetree.Pexp_ident (copy_loc copy_Longident_t x0)\n | Ast_411.Parsetree.Pexp_constant x0 ->\n Ast_410.Parsetree.Pexp_constant (copy_constant x0)\n | Ast_411.Parsetree.Pexp_let (x0, x1, x2) ->\n Ast_410.Parsetree.Pexp_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_expression x2)\n | Ast_411.Parsetree.Pexp_function x0 ->\n Ast_410.Parsetree.Pexp_function (List.map copy_case x0)\n | Ast_411.Parsetree.Pexp_fun (x0, x1, x2, x3) ->\n Ast_410.Parsetree.Pexp_fun\n ( copy_arg_label x0,\n Option.map copy_expression x1,\n copy_pattern x2,\n copy_expression x3 )\n | Ast_411.Parsetree.Pexp_apply (x0, x1) ->\n Ast_410.Parsetree.Pexp_apply\n ( copy_expression x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | Ast_411.Parsetree.Pexp_match (x0, x1) ->\n Ast_410.Parsetree.Pexp_match (copy_expression x0, List.map copy_case x1)\n | Ast_411.Parsetree.Pexp_try (x0, x1) ->\n Ast_410.Parsetree.Pexp_try (copy_expression x0, List.map copy_case x1)\n | Ast_411.Parsetree.Pexp_tuple x0 ->\n Ast_410.Parsetree.Pexp_tuple (List.map copy_expression x0)\n | Ast_411.Parsetree.Pexp_construct (x0, x1) ->\n Ast_410.Parsetree.Pexp_construct\n (copy_loc copy_Longident_t x0, Option.map copy_expression x1)\n | Ast_411.Parsetree.Pexp_variant (x0, x1) ->\n Ast_410.Parsetree.Pexp_variant\n (copy_label x0, Option.map copy_expression x1)\n | Ast_411.Parsetree.Pexp_record (x0, x1) ->\n Ast_410.Parsetree.Pexp_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_expression x1))\n x0,\n Option.map copy_expression x1 )\n | Ast_411.Parsetree.Pexp_field (x0, x1) ->\n Ast_410.Parsetree.Pexp_field\n (copy_expression x0, copy_loc copy_Longident_t x1)\n | Ast_411.Parsetree.Pexp_setfield (x0, x1, x2) ->\n Ast_410.Parsetree.Pexp_setfield\n (copy_expression x0, copy_loc copy_Longident_t x1, copy_expression x2)\n | Ast_411.Parsetree.Pexp_array x0 ->\n Ast_410.Parsetree.Pexp_array (List.map copy_expression x0)\n | Ast_411.Parsetree.Pexp_ifthenelse (x0, x1, x2) ->\n Ast_410.Parsetree.Pexp_ifthenelse\n (copy_expression x0, copy_expression x1, Option.map copy_expression x2)\n | Ast_411.Parsetree.Pexp_sequence (x0, x1) ->\n Ast_410.Parsetree.Pexp_sequence (copy_expression x0, copy_expression x1)\n | Ast_411.Parsetree.Pexp_while (x0, x1) ->\n Ast_410.Parsetree.Pexp_while (copy_expression x0, copy_expression x1)\n | Ast_411.Parsetree.Pexp_for (x0, x1, x2, x3, x4) ->\n Ast_410.Parsetree.Pexp_for\n ( copy_pattern x0,\n copy_expression x1,\n copy_expression x2,\n copy_direction_flag x3,\n copy_expression x4 )\n | Ast_411.Parsetree.Pexp_constraint (x0, x1) ->\n Ast_410.Parsetree.Pexp_constraint (copy_expression x0, copy_core_type x1)\n | Ast_411.Parsetree.Pexp_coerce (x0, x1, x2) ->\n Ast_410.Parsetree.Pexp_coerce\n (copy_expression x0, Option.map copy_core_type x1, copy_core_type x2)\n | Ast_411.Parsetree.Pexp_send (x0, x1) ->\n Ast_410.Parsetree.Pexp_send (copy_expression x0, copy_loc copy_label x1)\n | Ast_411.Parsetree.Pexp_new x0 ->\n Ast_410.Parsetree.Pexp_new (copy_loc copy_Longident_t x0)\n | Ast_411.Parsetree.Pexp_setinstvar (x0, x1) ->\n Ast_410.Parsetree.Pexp_setinstvar\n (copy_loc copy_label x0, copy_expression x1)\n | Ast_411.Parsetree.Pexp_override x0 ->\n Ast_410.Parsetree.Pexp_override\n (List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_label x0, copy_expression x1))\n x0)\n | Ast_411.Parsetree.Pexp_letmodule (x0, x1, x2) ->\n Ast_410.Parsetree.Pexp_letmodule\n ( copy_loc (fun x -> Option.map (fun x -> x) x) x0,\n copy_module_expr x1,\n copy_expression x2 )\n | Ast_411.Parsetree.Pexp_letexception (x0, x1) ->\n Ast_410.Parsetree.Pexp_letexception\n (copy_extension_constructor x0, copy_expression x1)\n | Ast_411.Parsetree.Pexp_assert x0 ->\n Ast_410.Parsetree.Pexp_assert (copy_expression x0)\n | Ast_411.Parsetree.Pexp_lazy x0 ->\n Ast_410.Parsetree.Pexp_lazy (copy_expression x0)\n | Ast_411.Parsetree.Pexp_poly (x0, x1) ->\n Ast_410.Parsetree.Pexp_poly\n (copy_expression x0, Option.map copy_core_type x1)\n | Ast_411.Parsetree.Pexp_object x0 ->\n Ast_410.Parsetree.Pexp_object (copy_class_structure x0)\n | Ast_411.Parsetree.Pexp_newtype (x0, x1) ->\n Ast_410.Parsetree.Pexp_newtype\n (copy_loc (fun x -> x) x0, copy_expression x1)\n | Ast_411.Parsetree.Pexp_pack x0 ->\n Ast_410.Parsetree.Pexp_pack (copy_module_expr x0)\n | Ast_411.Parsetree.Pexp_open (x0, x1) ->\n Ast_410.Parsetree.Pexp_open (copy_open_declaration x0, copy_expression x1)\n | Ast_411.Parsetree.Pexp_letop x0 ->\n Ast_410.Parsetree.Pexp_letop (copy_letop x0)\n | Ast_411.Parsetree.Pexp_extension x0 ->\n Ast_410.Parsetree.Pexp_extension (copy_extension x0)\n | Ast_411.Parsetree.Pexp_unreachable -> Ast_410.Parsetree.Pexp_unreachable\n\nand copy_letop : Ast_411.Parsetree.letop -> Ast_410.Parsetree.letop =\n fun { Ast_411.Parsetree.let_; Ast_411.Parsetree.ands; Ast_411.Parsetree.body } ->\n {\n Ast_410.Parsetree.let_ = copy_binding_op let_;\n Ast_410.Parsetree.ands = List.map copy_binding_op ands;\n Ast_410.Parsetree.body = copy_expression body;\n }\n\nand copy_binding_op :\n Ast_411.Parsetree.binding_op -> Ast_410.Parsetree.binding_op =\n fun {\n Ast_411.Parsetree.pbop_op;\n Ast_411.Parsetree.pbop_pat;\n Ast_411.Parsetree.pbop_exp;\n Ast_411.Parsetree.pbop_loc;\n } ->\n {\n Ast_410.Parsetree.pbop_op = copy_loc (fun x -> x) pbop_op;\n Ast_410.Parsetree.pbop_pat = copy_pattern pbop_pat;\n Ast_410.Parsetree.pbop_exp = copy_expression pbop_exp;\n Ast_410.Parsetree.pbop_loc = copy_location pbop_loc;\n }\n\nand copy_direction_flag :\n Ast_411.Asttypes.direction_flag -> Ast_410.Asttypes.direction_flag =\n function\n | Ast_411.Asttypes.Upto -> Ast_410.Asttypes.Upto\n | Ast_411.Asttypes.Downto -> Ast_410.Asttypes.Downto\n\nand copy_case : Ast_411.Parsetree.case -> Ast_410.Parsetree.case =\n fun {\n Ast_411.Parsetree.pc_lhs;\n Ast_411.Parsetree.pc_guard;\n Ast_411.Parsetree.pc_rhs;\n } ->\n {\n Ast_410.Parsetree.pc_lhs = copy_pattern pc_lhs;\n Ast_410.Parsetree.pc_guard = Option.map copy_expression pc_guard;\n Ast_410.Parsetree.pc_rhs = copy_expression pc_rhs;\n }\n\nand copy_cases : Ast_411.Parsetree.case list -> Ast_410.Parsetree.case list =\n fun x -> List.map copy_case x\n\nand copy_value_binding :\n Ast_411.Parsetree.value_binding -> Ast_410.Parsetree.value_binding =\n fun {\n Ast_411.Parsetree.pvb_pat;\n Ast_411.Parsetree.pvb_expr;\n Ast_411.Parsetree.pvb_attributes;\n Ast_411.Parsetree.pvb_loc;\n } ->\n {\n Ast_410.Parsetree.pvb_pat = copy_pattern pvb_pat;\n Ast_410.Parsetree.pvb_expr = copy_expression pvb_expr;\n Ast_410.Parsetree.pvb_attributes = copy_attributes pvb_attributes;\n Ast_410.Parsetree.pvb_loc = copy_location pvb_loc;\n }\n\nand copy_pattern : Ast_411.Parsetree.pattern -> Ast_410.Parsetree.pattern =\n fun {\n Ast_411.Parsetree.ppat_desc;\n Ast_411.Parsetree.ppat_loc;\n Ast_411.Parsetree.ppat_loc_stack;\n Ast_411.Parsetree.ppat_attributes;\n } ->\n {\n Ast_410.Parsetree.ppat_desc = copy_pattern_desc ppat_desc;\n Ast_410.Parsetree.ppat_loc = copy_location ppat_loc;\n Ast_410.Parsetree.ppat_loc_stack = copy_location_stack ppat_loc_stack;\n Ast_410.Parsetree.ppat_attributes = copy_attributes ppat_attributes;\n }\n\nand copy_pat x = copy_pattern x\n\nand copy_pattern_desc :\n Ast_411.Parsetree.pattern_desc -> Ast_410.Parsetree.pattern_desc = function\n | Ast_411.Parsetree.Ppat_any -> Ast_410.Parsetree.Ppat_any\n | Ast_411.Parsetree.Ppat_var x0 ->\n Ast_410.Parsetree.Ppat_var (copy_loc (fun x -> x) x0)\n | Ast_411.Parsetree.Ppat_alias (x0, x1) ->\n Ast_410.Parsetree.Ppat_alias (copy_pattern x0, copy_loc (fun x -> x) x1)\n | Ast_411.Parsetree.Ppat_constant x0 ->\n Ast_410.Parsetree.Ppat_constant (copy_constant x0)\n | Ast_411.Parsetree.Ppat_interval (x0, x1) ->\n Ast_410.Parsetree.Ppat_interval (copy_constant x0, copy_constant x1)\n | Ast_411.Parsetree.Ppat_tuple x0 ->\n Ast_410.Parsetree.Ppat_tuple (List.map copy_pattern x0)\n | Ast_411.Parsetree.Ppat_construct (x0, x1) ->\n Ast_410.Parsetree.Ppat_construct\n (copy_loc copy_Longident_t x0, Option.map copy_pattern x1)\n | Ast_411.Parsetree.Ppat_variant (x0, x1) ->\n Ast_410.Parsetree.Ppat_variant (copy_label x0, Option.map copy_pattern x1)\n | Ast_411.Parsetree.Ppat_record (x0, x1) ->\n Ast_410.Parsetree.Ppat_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_pattern x1))\n x0,\n copy_closed_flag x1 )\n | Ast_411.Parsetree.Ppat_array x0 ->\n Ast_410.Parsetree.Ppat_array (List.map copy_pattern x0)\n | Ast_411.Parsetree.Ppat_or (x0, x1) ->\n Ast_410.Parsetree.Ppat_or (copy_pattern x0, copy_pattern x1)\n | Ast_411.Parsetree.Ppat_constraint (x0, x1) ->\n Ast_410.Parsetree.Ppat_constraint (copy_pattern x0, copy_core_type x1)\n | Ast_411.Parsetree.Ppat_type x0 ->\n Ast_410.Parsetree.Ppat_type (copy_loc copy_Longident_t x0)\n | Ast_411.Parsetree.Ppat_lazy x0 ->\n Ast_410.Parsetree.Ppat_lazy (copy_pattern x0)\n | Ast_411.Parsetree.Ppat_unpack x0 ->\n Ast_410.Parsetree.Ppat_unpack\n (copy_loc (fun x -> Option.map (fun x -> x) x) x0)\n | Ast_411.Parsetree.Ppat_exception x0 ->\n Ast_410.Parsetree.Ppat_exception (copy_pattern x0)\n | Ast_411.Parsetree.Ppat_extension x0 ->\n Ast_410.Parsetree.Ppat_extension (copy_extension x0)\n | Ast_411.Parsetree.Ppat_open (x0, x1) ->\n Ast_410.Parsetree.Ppat_open (copy_loc copy_Longident_t x0, copy_pattern x1)\n\nand copy_core_type : Ast_411.Parsetree.core_type -> Ast_410.Parsetree.core_type\n =\n fun {\n Ast_411.Parsetree.ptyp_desc;\n Ast_411.Parsetree.ptyp_loc;\n Ast_411.Parsetree.ptyp_loc_stack;\n Ast_411.Parsetree.ptyp_attributes;\n } ->\n {\n Ast_410.Parsetree.ptyp_desc = copy_core_type_desc ptyp_desc;\n Ast_410.Parsetree.ptyp_loc = copy_location ptyp_loc;\n Ast_410.Parsetree.ptyp_loc_stack = copy_location_stack ptyp_loc_stack;\n Ast_410.Parsetree.ptyp_attributes = copy_attributes ptyp_attributes;\n }\n\nand copy_typ x = copy_core_type x\n\nand copy_location_stack :\n Ast_411.Parsetree.location_stack -> Ast_410.Parsetree.location_stack =\n fun x -> List.map copy_location x\n\nand copy_core_type_desc :\n Ast_411.Parsetree.core_type_desc -> Ast_410.Parsetree.core_type_desc =\n function\n | Ast_411.Parsetree.Ptyp_any -> Ast_410.Parsetree.Ptyp_any\n | Ast_411.Parsetree.Ptyp_var x0 -> Ast_410.Parsetree.Ptyp_var x0\n | Ast_411.Parsetree.Ptyp_arrow (x0, x1, x2) ->\n Ast_410.Parsetree.Ptyp_arrow\n (copy_arg_label x0, copy_core_type x1, copy_core_type x2)\n | Ast_411.Parsetree.Ptyp_tuple x0 ->\n Ast_410.Parsetree.Ptyp_tuple (List.map copy_core_type x0)\n | Ast_411.Parsetree.Ptyp_constr (x0, x1) ->\n Ast_410.Parsetree.Ptyp_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_411.Parsetree.Ptyp_object (x0, x1) ->\n Ast_410.Parsetree.Ptyp_object\n (List.map copy_object_field x0, copy_closed_flag x1)\n | Ast_411.Parsetree.Ptyp_class (x0, x1) ->\n Ast_410.Parsetree.Ptyp_class\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_411.Parsetree.Ptyp_alias (x0, x1) ->\n Ast_410.Parsetree.Ptyp_alias (copy_core_type x0, x1)\n | Ast_411.Parsetree.Ptyp_variant (x0, x1, x2) ->\n Ast_410.Parsetree.Ptyp_variant\n ( List.map copy_row_field x0,\n copy_closed_flag x1,\n Option.map (fun x -> List.map copy_label x) x2 )\n | Ast_411.Parsetree.Ptyp_poly (x0, x1) ->\n Ast_410.Parsetree.Ptyp_poly\n (List.map (fun x -> copy_loc (fun x -> x) x) x0, copy_core_type x1)\n | Ast_411.Parsetree.Ptyp_package x0 ->\n Ast_410.Parsetree.Ptyp_package (copy_package_type x0)\n | Ast_411.Parsetree.Ptyp_extension x0 ->\n Ast_410.Parsetree.Ptyp_extension (copy_extension x0)\n\nand copy_package_type :\n Ast_411.Parsetree.package_type -> Ast_410.Parsetree.package_type =\n fun x ->\n let x0, x1 = x in\n ( copy_loc copy_Longident_t x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_core_type x1))\n x1 )\n\nand copy_row_field : Ast_411.Parsetree.row_field -> Ast_410.Parsetree.row_field\n =\n fun {\n Ast_411.Parsetree.prf_desc;\n Ast_411.Parsetree.prf_loc;\n Ast_411.Parsetree.prf_attributes;\n } ->\n {\n Ast_410.Parsetree.prf_desc = copy_row_field_desc prf_desc;\n Ast_410.Parsetree.prf_loc = copy_location prf_loc;\n Ast_410.Parsetree.prf_attributes = copy_attributes prf_attributes;\n }\n\nand copy_row_field_desc :\n Ast_411.Parsetree.row_field_desc -> Ast_410.Parsetree.row_field_desc =\n function\n | Ast_411.Parsetree.Rtag (x0, x1, x2) ->\n Ast_410.Parsetree.Rtag\n (copy_loc copy_label x0, x1, List.map copy_core_type x2)\n | Ast_411.Parsetree.Rinherit x0 ->\n Ast_410.Parsetree.Rinherit (copy_core_type x0)\n\nand copy_object_field :\n Ast_411.Parsetree.object_field -> Ast_410.Parsetree.object_field =\n fun {\n Ast_411.Parsetree.pof_desc;\n Ast_411.Parsetree.pof_loc;\n Ast_411.Parsetree.pof_attributes;\n } ->\n {\n Ast_410.Parsetree.pof_desc = copy_object_field_desc pof_desc;\n Ast_410.Parsetree.pof_loc = copy_location pof_loc;\n Ast_410.Parsetree.pof_attributes = copy_attributes pof_attributes;\n }\n\nand copy_attributes :\n Ast_411.Parsetree.attributes -> Ast_410.Parsetree.attributes =\n fun x -> List.map copy_attribute x\n\nand copy_attribute : Ast_411.Parsetree.attribute -> Ast_410.Parsetree.attribute\n =\n fun {\n Ast_411.Parsetree.attr_name;\n Ast_411.Parsetree.attr_payload;\n Ast_411.Parsetree.attr_loc;\n } ->\n {\n Ast_410.Parsetree.attr_name = copy_loc (fun x -> x) attr_name;\n Ast_410.Parsetree.attr_payload = copy_payload attr_payload;\n Ast_410.Parsetree.attr_loc = copy_location attr_loc;\n }\n\nand copy_payload : Ast_411.Parsetree.payload -> Ast_410.Parsetree.payload =\n function\n | Ast_411.Parsetree.PStr x0 -> Ast_410.Parsetree.PStr (copy_structure x0)\n | Ast_411.Parsetree.PSig x0 -> Ast_410.Parsetree.PSig (copy_signature x0)\n | Ast_411.Parsetree.PTyp x0 -> Ast_410.Parsetree.PTyp (copy_core_type x0)\n | Ast_411.Parsetree.PPat (x0, x1) ->\n Ast_410.Parsetree.PPat (copy_pattern x0, Option.map copy_expression x1)\n\nand copy_structure : Ast_411.Parsetree.structure -> Ast_410.Parsetree.structure\n =\n fun x -> List.map copy_structure_item x\n\nand copy_structure_item :\n Ast_411.Parsetree.structure_item -> Ast_410.Parsetree.structure_item =\n fun { Ast_411.Parsetree.pstr_desc; Ast_411.Parsetree.pstr_loc } ->\n {\n Ast_410.Parsetree.pstr_desc = copy_structure_item_desc pstr_desc;\n Ast_410.Parsetree.pstr_loc = copy_location pstr_loc;\n }\n\nand copy_structure_item_desc :\n Ast_411.Parsetree.structure_item_desc ->\n Ast_410.Parsetree.structure_item_desc = function\n | Ast_411.Parsetree.Pstr_eval (x0, x1) ->\n Ast_410.Parsetree.Pstr_eval (copy_expression x0, copy_attributes x1)\n | Ast_411.Parsetree.Pstr_value (x0, x1) ->\n Ast_410.Parsetree.Pstr_value\n (copy_rec_flag x0, List.map copy_value_binding x1)\n | Ast_411.Parsetree.Pstr_primitive x0 ->\n Ast_410.Parsetree.Pstr_primitive (copy_value_description x0)\n | Ast_411.Parsetree.Pstr_type (x0, x1) ->\n Ast_410.Parsetree.Pstr_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | Ast_411.Parsetree.Pstr_typext x0 ->\n Ast_410.Parsetree.Pstr_typext (copy_type_extension x0)\n | Ast_411.Parsetree.Pstr_exception x0 ->\n Ast_410.Parsetree.Pstr_exception (copy_type_exception x0)\n | Ast_411.Parsetree.Pstr_module x0 ->\n Ast_410.Parsetree.Pstr_module (copy_module_binding x0)\n | Ast_411.Parsetree.Pstr_recmodule x0 ->\n Ast_410.Parsetree.Pstr_recmodule (List.map copy_module_binding x0)\n | Ast_411.Parsetree.Pstr_modtype x0 ->\n Ast_410.Parsetree.Pstr_modtype (copy_module_type_declaration x0)\n | Ast_411.Parsetree.Pstr_open x0 ->\n Ast_410.Parsetree.Pstr_open (copy_open_declaration x0)\n | Ast_411.Parsetree.Pstr_class x0 ->\n Ast_410.Parsetree.Pstr_class (List.map copy_class_declaration x0)\n | Ast_411.Parsetree.Pstr_class_type x0 ->\n Ast_410.Parsetree.Pstr_class_type\n (List.map copy_class_type_declaration x0)\n | Ast_411.Parsetree.Pstr_include x0 ->\n Ast_410.Parsetree.Pstr_include (copy_include_declaration x0)\n | Ast_411.Parsetree.Pstr_attribute x0 ->\n Ast_410.Parsetree.Pstr_attribute (copy_attribute x0)\n | Ast_411.Parsetree.Pstr_extension (x0, x1) ->\n Ast_410.Parsetree.Pstr_extension (copy_extension x0, copy_attributes x1)\n\nand copy_include_declaration :\n Ast_411.Parsetree.include_declaration ->\n Ast_410.Parsetree.include_declaration =\n fun x -> copy_include_infos copy_module_expr x\n\nand copy_class_declaration :\n Ast_411.Parsetree.class_declaration -> Ast_410.Parsetree.class_declaration =\n fun x -> copy_class_infos copy_class_expr x\n\nand copy_class_expr :\n Ast_411.Parsetree.class_expr -> Ast_410.Parsetree.class_expr =\n fun {\n Ast_411.Parsetree.pcl_desc;\n Ast_411.Parsetree.pcl_loc;\n Ast_411.Parsetree.pcl_attributes;\n } ->\n {\n Ast_410.Parsetree.pcl_desc = copy_class_expr_desc pcl_desc;\n Ast_410.Parsetree.pcl_loc = copy_location pcl_loc;\n Ast_410.Parsetree.pcl_attributes = copy_attributes pcl_attributes;\n }\n\nand copy_class_expr_desc :\n Ast_411.Parsetree.class_expr_desc -> Ast_410.Parsetree.class_expr_desc =\n function\n | Ast_411.Parsetree.Pcl_constr (x0, x1) ->\n Ast_410.Parsetree.Pcl_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_411.Parsetree.Pcl_structure x0 ->\n Ast_410.Parsetree.Pcl_structure (copy_class_structure x0)\n | Ast_411.Parsetree.Pcl_fun (x0, x1, x2, x3) ->\n Ast_410.Parsetree.Pcl_fun\n ( copy_arg_label x0,\n Option.map copy_expression x1,\n copy_pattern x2,\n copy_class_expr x3 )\n | Ast_411.Parsetree.Pcl_apply (x0, x1) ->\n Ast_410.Parsetree.Pcl_apply\n ( copy_class_expr x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | Ast_411.Parsetree.Pcl_let (x0, x1, x2) ->\n Ast_410.Parsetree.Pcl_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_class_expr x2)\n | Ast_411.Parsetree.Pcl_constraint (x0, x1) ->\n Ast_410.Parsetree.Pcl_constraint (copy_class_expr x0, copy_class_type x1)\n | Ast_411.Parsetree.Pcl_extension x0 ->\n Ast_410.Parsetree.Pcl_extension (copy_extension x0)\n | Ast_411.Parsetree.Pcl_open (x0, x1) ->\n Ast_410.Parsetree.Pcl_open (copy_open_description x0, copy_class_expr x1)\n\nand copy_class_structure :\n Ast_411.Parsetree.class_structure -> Ast_410.Parsetree.class_structure =\n fun { Ast_411.Parsetree.pcstr_self; Ast_411.Parsetree.pcstr_fields } ->\n {\n Ast_410.Parsetree.pcstr_self = copy_pattern pcstr_self;\n Ast_410.Parsetree.pcstr_fields = List.map copy_class_field pcstr_fields;\n }\n\nand copy_class_field :\n Ast_411.Parsetree.class_field -> Ast_410.Parsetree.class_field =\n fun {\n Ast_411.Parsetree.pcf_desc;\n Ast_411.Parsetree.pcf_loc;\n Ast_411.Parsetree.pcf_attributes;\n } ->\n {\n Ast_410.Parsetree.pcf_desc = copy_class_field_desc pcf_desc;\n Ast_410.Parsetree.pcf_loc = copy_location pcf_loc;\n Ast_410.Parsetree.pcf_attributes = copy_attributes pcf_attributes;\n }\n\nand copy_class_field_desc :\n Ast_411.Parsetree.class_field_desc -> Ast_410.Parsetree.class_field_desc =\n function\n | Ast_411.Parsetree.Pcf_inherit (x0, x1, x2) ->\n Ast_410.Parsetree.Pcf_inherit\n ( copy_override_flag x0,\n copy_class_expr x1,\n Option.map (fun x -> copy_loc (fun x -> x) x) x2 )\n | Ast_411.Parsetree.Pcf_val x0 ->\n Ast_410.Parsetree.Pcf_val\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_mutable_flag x1, copy_class_field_kind x2))\n | Ast_411.Parsetree.Pcf_method x0 ->\n Ast_410.Parsetree.Pcf_method\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_private_flag x1, copy_class_field_kind x2))\n | Ast_411.Parsetree.Pcf_constraint x0 ->\n Ast_410.Parsetree.Pcf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | Ast_411.Parsetree.Pcf_initializer x0 ->\n Ast_410.Parsetree.Pcf_initializer (copy_expression x0)\n | Ast_411.Parsetree.Pcf_attribute x0 ->\n Ast_410.Parsetree.Pcf_attribute (copy_attribute x0)\n | Ast_411.Parsetree.Pcf_extension x0 ->\n Ast_410.Parsetree.Pcf_extension (copy_extension x0)\n\nand copy_class_field_kind :\n Ast_411.Parsetree.class_field_kind -> Ast_410.Parsetree.class_field_kind =\n function\n | Ast_411.Parsetree.Cfk_virtual x0 ->\n Ast_410.Parsetree.Cfk_virtual (copy_core_type x0)\n | Ast_411.Parsetree.Cfk_concrete (x0, x1) ->\n Ast_410.Parsetree.Cfk_concrete (copy_override_flag x0, copy_expression x1)\n\nand copy_open_declaration :\n Ast_411.Parsetree.open_declaration -> Ast_410.Parsetree.open_declaration =\n fun x -> copy_open_infos copy_module_expr x\n\nand copy_module_binding :\n Ast_411.Parsetree.module_binding -> Ast_410.Parsetree.module_binding =\n fun {\n Ast_411.Parsetree.pmb_name;\n Ast_411.Parsetree.pmb_expr;\n Ast_411.Parsetree.pmb_attributes;\n Ast_411.Parsetree.pmb_loc;\n } ->\n {\n Ast_410.Parsetree.pmb_name =\n copy_loc (fun x -> Option.map (fun x -> x) x) pmb_name;\n Ast_410.Parsetree.pmb_expr = copy_module_expr pmb_expr;\n Ast_410.Parsetree.pmb_attributes = copy_attributes pmb_attributes;\n Ast_410.Parsetree.pmb_loc = copy_location pmb_loc;\n }\n\nand copy_module_expr :\n Ast_411.Parsetree.module_expr -> Ast_410.Parsetree.module_expr =\n fun {\n Ast_411.Parsetree.pmod_desc;\n Ast_411.Parsetree.pmod_loc;\n Ast_411.Parsetree.pmod_attributes;\n } ->\n {\n Ast_410.Parsetree.pmod_desc = copy_module_expr_desc pmod_desc;\n Ast_410.Parsetree.pmod_loc = copy_location pmod_loc;\n Ast_410.Parsetree.pmod_attributes = copy_attributes pmod_attributes;\n }\n\nand copy_module_expr_desc :\n Ast_411.Parsetree.module_expr_desc -> Ast_410.Parsetree.module_expr_desc =\n function\n | Ast_411.Parsetree.Pmod_ident x0 ->\n Ast_410.Parsetree.Pmod_ident (copy_loc copy_Longident_t x0)\n | Ast_411.Parsetree.Pmod_structure x0 ->\n Ast_410.Parsetree.Pmod_structure (copy_structure x0)\n | Ast_411.Parsetree.Pmod_functor (x0, x1) ->\n Ast_410.Parsetree.Pmod_functor\n (copy_functor_parameter x0, copy_module_expr x1)\n | Ast_411.Parsetree.Pmod_apply (x0, x1) ->\n Ast_410.Parsetree.Pmod_apply (copy_module_expr x0, copy_module_expr x1)\n | Ast_411.Parsetree.Pmod_constraint (x0, x1) ->\n Ast_410.Parsetree.Pmod_constraint\n (copy_module_expr x0, copy_module_type x1)\n | Ast_411.Parsetree.Pmod_unpack x0 ->\n Ast_410.Parsetree.Pmod_unpack (copy_expression x0)\n | Ast_411.Parsetree.Pmod_extension x0 ->\n Ast_410.Parsetree.Pmod_extension (copy_extension x0)\n\nand copy_functor_parameter :\n Ast_411.Parsetree.functor_parameter -> Ast_410.Parsetree.functor_parameter =\n function\n | Ast_411.Parsetree.Unit -> Ast_410.Parsetree.Unit\n | Ast_411.Parsetree.Named (x0, x1) ->\n Ast_410.Parsetree.Named\n (copy_loc (fun x -> Option.map (fun x -> x) x) x0, copy_module_type x1)\n\nand copy_module_type :\n Ast_411.Parsetree.module_type -> Ast_410.Parsetree.module_type =\n fun {\n Ast_411.Parsetree.pmty_desc;\n Ast_411.Parsetree.pmty_loc;\n Ast_411.Parsetree.pmty_attributes;\n } ->\n {\n Ast_410.Parsetree.pmty_desc = copy_module_type_desc pmty_desc;\n Ast_410.Parsetree.pmty_loc = copy_location pmty_loc;\n Ast_410.Parsetree.pmty_attributes = copy_attributes pmty_attributes;\n }\n\nand copy_module_type_desc :\n Ast_411.Parsetree.module_type_desc -> Ast_410.Parsetree.module_type_desc =\n function\n | Ast_411.Parsetree.Pmty_ident x0 ->\n Ast_410.Parsetree.Pmty_ident (copy_loc copy_Longident_t x0)\n | Ast_411.Parsetree.Pmty_signature x0 ->\n Ast_410.Parsetree.Pmty_signature (copy_signature x0)\n | Ast_411.Parsetree.Pmty_functor (x0, x1) ->\n Ast_410.Parsetree.Pmty_functor\n (copy_functor_parameter x0, copy_module_type x1)\n | Ast_411.Parsetree.Pmty_with (x0, x1) ->\n Ast_410.Parsetree.Pmty_with\n (copy_module_type x0, List.map copy_with_constraint x1)\n | Ast_411.Parsetree.Pmty_typeof x0 ->\n Ast_410.Parsetree.Pmty_typeof (copy_module_expr x0)\n | Ast_411.Parsetree.Pmty_extension x0 ->\n Ast_410.Parsetree.Pmty_extension (copy_extension x0)\n | Ast_411.Parsetree.Pmty_alias x0 ->\n Ast_410.Parsetree.Pmty_alias (copy_loc copy_Longident_t x0)\n\nand copy_with_constraint :\n Ast_411.Parsetree.with_constraint -> Ast_410.Parsetree.with_constraint =\n function\n | Ast_411.Parsetree.Pwith_type (x0, x1) ->\n Ast_410.Parsetree.Pwith_type\n (copy_loc copy_Longident_t x0, copy_type_declaration x1)\n | Ast_411.Parsetree.Pwith_module (x0, x1) ->\n Ast_410.Parsetree.Pwith_module\n (copy_loc copy_Longident_t x0, copy_loc copy_Longident_t x1)\n | Ast_411.Parsetree.Pwith_typesubst (x0, x1) ->\n Ast_410.Parsetree.Pwith_typesubst\n (copy_loc copy_Longident_t x0, copy_type_declaration x1)\n | Ast_411.Parsetree.Pwith_modsubst (x0, x1) ->\n Ast_410.Parsetree.Pwith_modsubst\n (copy_loc copy_Longident_t x0, copy_loc copy_Longident_t x1)\n\nand copy_signature : Ast_411.Parsetree.signature -> Ast_410.Parsetree.signature\n =\n fun x -> List.map copy_signature_item x\n\nand copy_signature_item :\n Ast_411.Parsetree.signature_item -> Ast_410.Parsetree.signature_item =\n fun { Ast_411.Parsetree.psig_desc; Ast_411.Parsetree.psig_loc } ->\n {\n Ast_410.Parsetree.psig_desc = copy_signature_item_desc psig_desc;\n Ast_410.Parsetree.psig_loc = copy_location psig_loc;\n }\n\nand copy_signature_item_desc :\n Ast_411.Parsetree.signature_item_desc ->\n Ast_410.Parsetree.signature_item_desc = function\n | Ast_411.Parsetree.Psig_value x0 ->\n Ast_410.Parsetree.Psig_value (copy_value_description x0)\n | Ast_411.Parsetree.Psig_type (x0, x1) ->\n Ast_410.Parsetree.Psig_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | Ast_411.Parsetree.Psig_typesubst x0 ->\n Ast_410.Parsetree.Psig_typesubst (List.map copy_type_declaration x0)\n | Ast_411.Parsetree.Psig_typext x0 ->\n Ast_410.Parsetree.Psig_typext (copy_type_extension x0)\n | Ast_411.Parsetree.Psig_exception x0 ->\n Ast_410.Parsetree.Psig_exception (copy_type_exception x0)\n | Ast_411.Parsetree.Psig_module x0 ->\n Ast_410.Parsetree.Psig_module (copy_module_declaration x0)\n | Ast_411.Parsetree.Psig_modsubst x0 ->\n Ast_410.Parsetree.Psig_modsubst (copy_module_substitution x0)\n | Ast_411.Parsetree.Psig_recmodule x0 ->\n Ast_410.Parsetree.Psig_recmodule (List.map copy_module_declaration x0)\n | Ast_411.Parsetree.Psig_modtype x0 ->\n Ast_410.Parsetree.Psig_modtype (copy_module_type_declaration x0)\n | Ast_411.Parsetree.Psig_open x0 ->\n Ast_410.Parsetree.Psig_open (copy_open_description x0)\n | Ast_411.Parsetree.Psig_include x0 ->\n Ast_410.Parsetree.Psig_include (copy_include_description x0)\n | Ast_411.Parsetree.Psig_class x0 ->\n Ast_410.Parsetree.Psig_class (List.map copy_class_description x0)\n | Ast_411.Parsetree.Psig_class_type x0 ->\n Ast_410.Parsetree.Psig_class_type\n (List.map copy_class_type_declaration x0)\n | Ast_411.Parsetree.Psig_attribute x0 ->\n Ast_410.Parsetree.Psig_attribute (copy_attribute x0)\n | Ast_411.Parsetree.Psig_extension (x0, x1) ->\n Ast_410.Parsetree.Psig_extension (copy_extension x0, copy_attributes x1)\n\nand copy_class_type_declaration :\n Ast_411.Parsetree.class_type_declaration ->\n Ast_410.Parsetree.class_type_declaration =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_description :\n Ast_411.Parsetree.class_description -> Ast_410.Parsetree.class_description =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_type :\n Ast_411.Parsetree.class_type -> Ast_410.Parsetree.class_type =\n fun {\n Ast_411.Parsetree.pcty_desc;\n Ast_411.Parsetree.pcty_loc;\n Ast_411.Parsetree.pcty_attributes;\n } ->\n {\n Ast_410.Parsetree.pcty_desc = copy_class_type_desc pcty_desc;\n Ast_410.Parsetree.pcty_loc = copy_location pcty_loc;\n Ast_410.Parsetree.pcty_attributes = copy_attributes pcty_attributes;\n }\n\nand copy_class_type_desc :\n Ast_411.Parsetree.class_type_desc -> Ast_410.Parsetree.class_type_desc =\n function\n | Ast_411.Parsetree.Pcty_constr (x0, x1) ->\n Ast_410.Parsetree.Pcty_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_411.Parsetree.Pcty_signature x0 ->\n Ast_410.Parsetree.Pcty_signature (copy_class_signature x0)\n | Ast_411.Parsetree.Pcty_arrow (x0, x1, x2) ->\n Ast_410.Parsetree.Pcty_arrow\n (copy_arg_label x0, copy_core_type x1, copy_class_type x2)\n | Ast_411.Parsetree.Pcty_extension x0 ->\n Ast_410.Parsetree.Pcty_extension (copy_extension x0)\n | Ast_411.Parsetree.Pcty_open (x0, x1) ->\n Ast_410.Parsetree.Pcty_open (copy_open_description x0, copy_class_type x1)\n\nand copy_class_signature :\n Ast_411.Parsetree.class_signature -> Ast_410.Parsetree.class_signature =\n fun { Ast_411.Parsetree.pcsig_self; Ast_411.Parsetree.pcsig_fields } ->\n {\n Ast_410.Parsetree.pcsig_self = copy_core_type pcsig_self;\n Ast_410.Parsetree.pcsig_fields = List.map copy_class_type_field pcsig_fields;\n }\n\nand copy_class_type_field :\n Ast_411.Parsetree.class_type_field -> Ast_410.Parsetree.class_type_field =\n fun {\n Ast_411.Parsetree.pctf_desc;\n Ast_411.Parsetree.pctf_loc;\n Ast_411.Parsetree.pctf_attributes;\n } ->\n {\n Ast_410.Parsetree.pctf_desc = copy_class_type_field_desc pctf_desc;\n Ast_410.Parsetree.pctf_loc = copy_location pctf_loc;\n Ast_410.Parsetree.pctf_attributes = copy_attributes pctf_attributes;\n }\n\nand copy_class_type_field_desc :\n Ast_411.Parsetree.class_type_field_desc ->\n Ast_410.Parsetree.class_type_field_desc = function\n | Ast_411.Parsetree.Pctf_inherit x0 ->\n Ast_410.Parsetree.Pctf_inherit (copy_class_type x0)\n | Ast_411.Parsetree.Pctf_val x0 ->\n Ast_410.Parsetree.Pctf_val\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_mutable_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | Ast_411.Parsetree.Pctf_method x0 ->\n Ast_410.Parsetree.Pctf_method\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_private_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | Ast_411.Parsetree.Pctf_constraint x0 ->\n Ast_410.Parsetree.Pctf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | Ast_411.Parsetree.Pctf_attribute x0 ->\n Ast_410.Parsetree.Pctf_attribute (copy_attribute x0)\n | Ast_411.Parsetree.Pctf_extension x0 ->\n Ast_410.Parsetree.Pctf_extension (copy_extension x0)\n\nand copy_extension : Ast_411.Parsetree.extension -> Ast_410.Parsetree.extension\n =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_class_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_411.Parsetree.class_infos ->\n 'g0 Ast_410.Parsetree.class_infos =\n fun f0\n {\n Ast_411.Parsetree.pci_virt;\n Ast_411.Parsetree.pci_params;\n Ast_411.Parsetree.pci_name;\n Ast_411.Parsetree.pci_expr;\n Ast_411.Parsetree.pci_loc;\n Ast_411.Parsetree.pci_attributes;\n } ->\n {\n Ast_410.Parsetree.pci_virt = copy_virtual_flag pci_virt;\n Ast_410.Parsetree.pci_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n pci_params;\n Ast_410.Parsetree.pci_name = copy_loc (fun x -> x) pci_name;\n Ast_410.Parsetree.pci_expr = f0 pci_expr;\n Ast_410.Parsetree.pci_loc = copy_location pci_loc;\n Ast_410.Parsetree.pci_attributes = copy_attributes pci_attributes;\n }\n\nand copy_virtual_flag :\n Ast_411.Asttypes.virtual_flag -> Ast_410.Asttypes.virtual_flag = function\n | Ast_411.Asttypes.Virtual -> Ast_410.Asttypes.Virtual\n | Ast_411.Asttypes.Concrete -> Ast_410.Asttypes.Concrete\n\nand copy_include_description :\n Ast_411.Parsetree.include_description ->\n Ast_410.Parsetree.include_description =\n fun x -> copy_include_infos copy_module_type x\n\nand copy_include_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_411.Parsetree.include_infos ->\n 'g0 Ast_410.Parsetree.include_infos =\n fun f0\n {\n Ast_411.Parsetree.pincl_mod;\n Ast_411.Parsetree.pincl_loc;\n Ast_411.Parsetree.pincl_attributes;\n } ->\n {\n Ast_410.Parsetree.pincl_mod = f0 pincl_mod;\n Ast_410.Parsetree.pincl_loc = copy_location pincl_loc;\n Ast_410.Parsetree.pincl_attributes = copy_attributes pincl_attributes;\n }\n\nand copy_open_description :\n Ast_411.Parsetree.open_description -> Ast_410.Parsetree.open_description =\n fun x -> copy_open_infos (fun x -> copy_loc copy_Longident_t x) x\n\nand copy_open_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_411.Parsetree.open_infos ->\n 'g0 Ast_410.Parsetree.open_infos =\n fun f0\n {\n Ast_411.Parsetree.popen_expr;\n Ast_411.Parsetree.popen_override;\n Ast_411.Parsetree.popen_loc;\n Ast_411.Parsetree.popen_attributes;\n } ->\n {\n Ast_410.Parsetree.popen_expr = f0 popen_expr;\n Ast_410.Parsetree.popen_override = copy_override_flag popen_override;\n Ast_410.Parsetree.popen_loc = copy_location popen_loc;\n Ast_410.Parsetree.popen_attributes = copy_attributes popen_attributes;\n }\n\nand copy_override_flag :\n Ast_411.Asttypes.override_flag -> Ast_410.Asttypes.override_flag = function\n | Ast_411.Asttypes.Override -> Ast_410.Asttypes.Override\n | Ast_411.Asttypes.Fresh -> Ast_410.Asttypes.Fresh\n\nand copy_module_type_declaration :\n Ast_411.Parsetree.module_type_declaration ->\n Ast_410.Parsetree.module_type_declaration =\n fun {\n Ast_411.Parsetree.pmtd_name;\n Ast_411.Parsetree.pmtd_type;\n Ast_411.Parsetree.pmtd_attributes;\n Ast_411.Parsetree.pmtd_loc;\n } ->\n {\n Ast_410.Parsetree.pmtd_name = copy_loc (fun x -> x) pmtd_name;\n Ast_410.Parsetree.pmtd_type = Option.map copy_module_type pmtd_type;\n Ast_410.Parsetree.pmtd_attributes = copy_attributes pmtd_attributes;\n Ast_410.Parsetree.pmtd_loc = copy_location pmtd_loc;\n }\n\nand copy_module_substitution :\n Ast_411.Parsetree.module_substitution ->\n Ast_410.Parsetree.module_substitution =\n fun {\n Ast_411.Parsetree.pms_name;\n Ast_411.Parsetree.pms_manifest;\n Ast_411.Parsetree.pms_attributes;\n Ast_411.Parsetree.pms_loc;\n } ->\n {\n Ast_410.Parsetree.pms_name = copy_loc (fun x -> x) pms_name;\n Ast_410.Parsetree.pms_manifest = copy_loc copy_Longident_t pms_manifest;\n Ast_410.Parsetree.pms_attributes = copy_attributes pms_attributes;\n Ast_410.Parsetree.pms_loc = copy_location pms_loc;\n }\n\nand copy_module_declaration :\n Ast_411.Parsetree.module_declaration -> Ast_410.Parsetree.module_declaration\n =\n fun {\n Ast_411.Parsetree.pmd_name;\n Ast_411.Parsetree.pmd_type;\n Ast_411.Parsetree.pmd_attributes;\n Ast_411.Parsetree.pmd_loc;\n } ->\n {\n Ast_410.Parsetree.pmd_name =\n copy_loc (fun x -> Option.map (fun x -> x) x) pmd_name;\n Ast_410.Parsetree.pmd_type = copy_module_type pmd_type;\n Ast_410.Parsetree.pmd_attributes = copy_attributes pmd_attributes;\n Ast_410.Parsetree.pmd_loc = copy_location pmd_loc;\n }\n\nand copy_type_exception :\n Ast_411.Parsetree.type_exception -> Ast_410.Parsetree.type_exception =\n fun {\n Ast_411.Parsetree.ptyexn_constructor;\n Ast_411.Parsetree.ptyexn_loc;\n Ast_411.Parsetree.ptyexn_attributes;\n } ->\n {\n Ast_410.Parsetree.ptyexn_constructor =\n copy_extension_constructor ptyexn_constructor;\n Ast_410.Parsetree.ptyexn_loc = copy_location ptyexn_loc;\n Ast_410.Parsetree.ptyexn_attributes = copy_attributes ptyexn_attributes;\n }\n\nand copy_type_extension :\n Ast_411.Parsetree.type_extension -> Ast_410.Parsetree.type_extension =\n fun {\n Ast_411.Parsetree.ptyext_path;\n Ast_411.Parsetree.ptyext_params;\n Ast_411.Parsetree.ptyext_constructors;\n Ast_411.Parsetree.ptyext_private;\n Ast_411.Parsetree.ptyext_loc;\n Ast_411.Parsetree.ptyext_attributes;\n } ->\n {\n Ast_410.Parsetree.ptyext_path = copy_loc copy_Longident_t ptyext_path;\n Ast_410.Parsetree.ptyext_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptyext_params;\n Ast_410.Parsetree.ptyext_constructors =\n List.map copy_extension_constructor ptyext_constructors;\n Ast_410.Parsetree.ptyext_private = copy_private_flag ptyext_private;\n Ast_410.Parsetree.ptyext_loc = copy_location ptyext_loc;\n Ast_410.Parsetree.ptyext_attributes = copy_attributes ptyext_attributes;\n }\n\nand copy_extension_constructor :\n Ast_411.Parsetree.extension_constructor ->\n Ast_410.Parsetree.extension_constructor =\n fun {\n Ast_411.Parsetree.pext_name;\n Ast_411.Parsetree.pext_kind;\n Ast_411.Parsetree.pext_loc;\n Ast_411.Parsetree.pext_attributes;\n } ->\n {\n Ast_410.Parsetree.pext_name = copy_loc (fun x -> x) pext_name;\n Ast_410.Parsetree.pext_kind = copy_extension_constructor_kind pext_kind;\n Ast_410.Parsetree.pext_loc = copy_location pext_loc;\n Ast_410.Parsetree.pext_attributes = copy_attributes pext_attributes;\n }\n\nand copy_extension_constructor_kind :\n Ast_411.Parsetree.extension_constructor_kind ->\n Ast_410.Parsetree.extension_constructor_kind = function\n | Ast_411.Parsetree.Pext_decl (x0, x1) ->\n Ast_410.Parsetree.Pext_decl\n (copy_constructor_arguments x0, Option.map copy_core_type x1)\n | Ast_411.Parsetree.Pext_rebind x0 ->\n Ast_410.Parsetree.Pext_rebind (copy_loc copy_Longident_t x0)\n\nand copy_type_declaration :\n Ast_411.Parsetree.type_declaration -> Ast_410.Parsetree.type_declaration =\n fun {\n Ast_411.Parsetree.ptype_name;\n Ast_411.Parsetree.ptype_params;\n Ast_411.Parsetree.ptype_cstrs;\n Ast_411.Parsetree.ptype_kind;\n Ast_411.Parsetree.ptype_private;\n Ast_411.Parsetree.ptype_manifest;\n Ast_411.Parsetree.ptype_attributes;\n Ast_411.Parsetree.ptype_loc;\n } ->\n {\n Ast_410.Parsetree.ptype_name = copy_loc (fun x -> x) ptype_name;\n Ast_410.Parsetree.ptype_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptype_params;\n Ast_410.Parsetree.ptype_cstrs =\n List.map\n (fun x ->\n let x0, x1, x2 = x in\n (copy_core_type x0, copy_core_type x1, copy_location x2))\n ptype_cstrs;\n Ast_410.Parsetree.ptype_kind = copy_type_kind ptype_kind;\n Ast_410.Parsetree.ptype_private = copy_private_flag ptype_private;\n Ast_410.Parsetree.ptype_manifest = Option.map copy_core_type ptype_manifest;\n Ast_410.Parsetree.ptype_attributes = copy_attributes ptype_attributes;\n Ast_410.Parsetree.ptype_loc = copy_location ptype_loc;\n }\n\nand copy_private_flag :\n Ast_411.Asttypes.private_flag -> Ast_410.Asttypes.private_flag = function\n | Ast_411.Asttypes.Private -> Ast_410.Asttypes.Private\n | Ast_411.Asttypes.Public -> Ast_410.Asttypes.Public\n\nand copy_type_kind : Ast_411.Parsetree.type_kind -> Ast_410.Parsetree.type_kind\n = function\n | Ast_411.Parsetree.Ptype_abstract -> Ast_410.Parsetree.Ptype_abstract\n | Ast_411.Parsetree.Ptype_variant x0 ->\n Ast_410.Parsetree.Ptype_variant (List.map copy_constructor_declaration x0)\n | Ast_411.Parsetree.Ptype_record x0 ->\n Ast_410.Parsetree.Ptype_record (List.map copy_label_declaration x0)\n | Ast_411.Parsetree.Ptype_open -> Ast_410.Parsetree.Ptype_open\n\nand copy_constructor_declaration :\n Ast_411.Parsetree.constructor_declaration ->\n Ast_410.Parsetree.constructor_declaration =\n fun {\n Ast_411.Parsetree.pcd_name;\n Ast_411.Parsetree.pcd_args;\n Ast_411.Parsetree.pcd_res;\n Ast_411.Parsetree.pcd_loc;\n Ast_411.Parsetree.pcd_attributes;\n } ->\n {\n Ast_410.Parsetree.pcd_name = copy_loc (fun x -> x) pcd_name;\n Ast_410.Parsetree.pcd_args = copy_constructor_arguments pcd_args;\n Ast_410.Parsetree.pcd_res = Option.map copy_core_type pcd_res;\n Ast_410.Parsetree.pcd_loc = copy_location pcd_loc;\n Ast_410.Parsetree.pcd_attributes = copy_attributes pcd_attributes;\n }\n\nand copy_constructor_arguments :\n Ast_411.Parsetree.constructor_arguments ->\n Ast_410.Parsetree.constructor_arguments = function\n | Ast_411.Parsetree.Pcstr_tuple x0 ->\n Ast_410.Parsetree.Pcstr_tuple (List.map copy_core_type x0)\n | Ast_411.Parsetree.Pcstr_record x0 ->\n Ast_410.Parsetree.Pcstr_record (List.map copy_label_declaration x0)\n\nand copy_label_declaration :\n Ast_411.Parsetree.label_declaration -> Ast_410.Parsetree.label_declaration =\n fun {\n Ast_411.Parsetree.pld_name;\n Ast_411.Parsetree.pld_mutable;\n Ast_411.Parsetree.pld_type;\n Ast_411.Parsetree.pld_loc;\n Ast_411.Parsetree.pld_attributes;\n } ->\n {\n Ast_410.Parsetree.pld_name = copy_loc (fun x -> x) pld_name;\n Ast_410.Parsetree.pld_mutable = copy_mutable_flag pld_mutable;\n Ast_410.Parsetree.pld_type = copy_core_type pld_type;\n Ast_410.Parsetree.pld_loc = copy_location pld_loc;\n Ast_410.Parsetree.pld_attributes = copy_attributes pld_attributes;\n }\n\nand copy_mutable_flag :\n Ast_411.Asttypes.mutable_flag -> Ast_410.Asttypes.mutable_flag = function\n | Ast_411.Asttypes.Immutable -> Ast_410.Asttypes.Immutable\n | Ast_411.Asttypes.Mutable -> Ast_410.Asttypes.Mutable\n\nand copy_variance : Ast_411.Asttypes.variance -> Ast_410.Asttypes.variance =\n function\n | Ast_411.Asttypes.Covariant -> Ast_410.Asttypes.Covariant\n | Ast_411.Asttypes.Contravariant -> Ast_410.Asttypes.Contravariant\n | Ast_411.Asttypes.Invariant -> Ast_410.Asttypes.Invariant\n\nand copy_value_description :\n Ast_411.Parsetree.value_description -> Ast_410.Parsetree.value_description =\n fun {\n Ast_411.Parsetree.pval_name;\n Ast_411.Parsetree.pval_type;\n Ast_411.Parsetree.pval_prim;\n Ast_411.Parsetree.pval_attributes;\n Ast_411.Parsetree.pval_loc;\n } ->\n {\n Ast_410.Parsetree.pval_name = copy_loc (fun x -> x) pval_name;\n Ast_410.Parsetree.pval_type = copy_core_type pval_type;\n Ast_410.Parsetree.pval_prim = List.map (fun x -> x) pval_prim;\n Ast_410.Parsetree.pval_attributes = copy_attributes pval_attributes;\n Ast_410.Parsetree.pval_loc = copy_location pval_loc;\n }\n\nand copy_object_field_desc :\n Ast_411.Parsetree.object_field_desc -> Ast_410.Parsetree.object_field_desc =\n function\n | Ast_411.Parsetree.Otag (x0, x1) ->\n Ast_410.Parsetree.Otag (copy_loc copy_label x0, copy_core_type x1)\n | Ast_411.Parsetree.Oinherit x0 ->\n Ast_410.Parsetree.Oinherit (copy_core_type x0)\n\nand copy_arg_label : Ast_411.Asttypes.arg_label -> Ast_410.Asttypes.arg_label =\n function\n | Ast_411.Asttypes.Nolabel -> Ast_410.Asttypes.Nolabel\n | Ast_411.Asttypes.Labelled x0 -> Ast_410.Asttypes.Labelled x0\n | Ast_411.Asttypes.Optional x0 -> Ast_410.Asttypes.Optional x0\n\nand copy_closed_flag :\n Ast_411.Asttypes.closed_flag -> Ast_410.Asttypes.closed_flag = function\n | Ast_411.Asttypes.Closed -> Ast_410.Asttypes.Closed\n | Ast_411.Asttypes.Open -> Ast_410.Asttypes.Open\n\nand copy_label : Ast_411.Asttypes.label -> Ast_410.Asttypes.label = fun x -> x\n\nand copy_rec_flag : Ast_411.Asttypes.rec_flag -> Ast_410.Asttypes.rec_flag =\n function\n | Ast_411.Asttypes.Nonrecursive -> Ast_410.Asttypes.Nonrecursive\n | Ast_411.Asttypes.Recursive -> Ast_410.Asttypes.Recursive\n\nand copy_constant : Ast_411.Parsetree.constant -> Ast_410.Parsetree.constant =\n function\n | Ast_411.Parsetree.Pconst_integer (x0, x1) ->\n Ast_410.Parsetree.Pconst_integer (x0, Option.map (fun x -> x) x1)\n | Ast_411.Parsetree.Pconst_char x0 -> Ast_410.Parsetree.Pconst_char x0\n | Ast_411.Parsetree.Pconst_string (x0, _, x2) ->\n Ast_410.Parsetree.Pconst_string (x0, Option.map (fun x -> x) x2)\n | Ast_411.Parsetree.Pconst_float (x0, x1) ->\n Ast_410.Parsetree.Pconst_float (x0, Option.map (fun x -> x) x1)\n\nand copy_Longident_t : Longident.t -> Longident.t = fun x -> x\n\nand copy_loc :\n 'f0 'g0.\n ('f0 -> 'g0) -> 'f0 Ast_411.Asttypes.loc -> 'g0 Ast_410.Asttypes.loc =\n fun f0 { Ast_411.Asttypes.txt; Ast_411.Asttypes.loc } ->\n { Ast_410.Asttypes.txt = f0 txt; Ast_410.Asttypes.loc = copy_location loc }\n\nand copy_location : Location.t -> Location.t = fun x -> x\n","open Stdlib0\nmodule From = Ast_410\nmodule To = Ast_411\n\nlet rec copy_toplevel_phrase :\n Ast_410.Parsetree.toplevel_phrase -> Ast_411.Parsetree.toplevel_phrase =\n function\n | Ast_410.Parsetree.Ptop_def x0 ->\n Ast_411.Parsetree.Ptop_def (copy_structure x0)\n | Ast_410.Parsetree.Ptop_dir x0 ->\n Ast_411.Parsetree.Ptop_dir (copy_toplevel_directive x0)\n\nand copy_toplevel_directive :\n Ast_410.Parsetree.toplevel_directive -> Ast_411.Parsetree.toplevel_directive\n =\n fun {\n Ast_410.Parsetree.pdir_name;\n Ast_410.Parsetree.pdir_arg;\n Ast_410.Parsetree.pdir_loc;\n } ->\n {\n Ast_411.Parsetree.pdir_name = copy_loc (fun x -> x) pdir_name;\n Ast_411.Parsetree.pdir_arg = Option.map copy_directive_argument pdir_arg;\n Ast_411.Parsetree.pdir_loc = copy_location pdir_loc;\n }\n\nand copy_directive_argument :\n Ast_410.Parsetree.directive_argument -> Ast_411.Parsetree.directive_argument\n =\n fun { Ast_410.Parsetree.pdira_desc; Ast_410.Parsetree.pdira_loc } ->\n {\n Ast_411.Parsetree.pdira_desc = copy_directive_argument_desc pdira_desc;\n Ast_411.Parsetree.pdira_loc = copy_location pdira_loc;\n }\n\nand copy_directive_argument_desc :\n Ast_410.Parsetree.directive_argument_desc ->\n Ast_411.Parsetree.directive_argument_desc = function\n | Ast_410.Parsetree.Pdir_string x0 -> Ast_411.Parsetree.Pdir_string x0\n | Ast_410.Parsetree.Pdir_int (x0, x1) ->\n Ast_411.Parsetree.Pdir_int (x0, Option.map (fun x -> x) x1)\n | Ast_410.Parsetree.Pdir_ident x0 ->\n Ast_411.Parsetree.Pdir_ident (copy_Longident_t x0)\n | Ast_410.Parsetree.Pdir_bool x0 -> Ast_411.Parsetree.Pdir_bool x0\n\nand copy_expression :\n Ast_410.Parsetree.expression -> Ast_411.Parsetree.expression =\n fun {\n Ast_410.Parsetree.pexp_desc;\n Ast_410.Parsetree.pexp_loc;\n Ast_410.Parsetree.pexp_loc_stack;\n Ast_410.Parsetree.pexp_attributes;\n } ->\n {\n Ast_411.Parsetree.pexp_desc = copy_expression_desc pexp_desc;\n Ast_411.Parsetree.pexp_loc = copy_location pexp_loc;\n Ast_411.Parsetree.pexp_loc_stack = copy_location_stack pexp_loc_stack;\n Ast_411.Parsetree.pexp_attributes = copy_attributes pexp_attributes;\n }\n\nand copy_expr x = copy_expression x\n\nand copy_expression_desc :\n Ast_410.Parsetree.expression_desc -> Ast_411.Parsetree.expression_desc =\n function\n | Ast_410.Parsetree.Pexp_ident x0 ->\n Ast_411.Parsetree.Pexp_ident (copy_loc copy_Longident_t x0)\n | Ast_410.Parsetree.Pexp_constant x0 ->\n Ast_411.Parsetree.Pexp_constant (copy_constant x0)\n | Ast_410.Parsetree.Pexp_let (x0, x1, x2) ->\n Ast_411.Parsetree.Pexp_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_expression x2)\n | Ast_410.Parsetree.Pexp_function x0 ->\n Ast_411.Parsetree.Pexp_function (List.map copy_case x0)\n | Ast_410.Parsetree.Pexp_fun (x0, x1, x2, x3) ->\n Ast_411.Parsetree.Pexp_fun\n ( copy_arg_label x0,\n Option.map copy_expression x1,\n copy_pattern x2,\n copy_expression x3 )\n | Ast_410.Parsetree.Pexp_apply (x0, x1) ->\n Ast_411.Parsetree.Pexp_apply\n ( copy_expression x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | Ast_410.Parsetree.Pexp_match (x0, x1) ->\n Ast_411.Parsetree.Pexp_match (copy_expression x0, List.map copy_case x1)\n | Ast_410.Parsetree.Pexp_try (x0, x1) ->\n Ast_411.Parsetree.Pexp_try (copy_expression x0, List.map copy_case x1)\n | Ast_410.Parsetree.Pexp_tuple x0 ->\n Ast_411.Parsetree.Pexp_tuple (List.map copy_expression x0)\n | Ast_410.Parsetree.Pexp_construct (x0, x1) ->\n Ast_411.Parsetree.Pexp_construct\n (copy_loc copy_Longident_t x0, Option.map copy_expression x1)\n | Ast_410.Parsetree.Pexp_variant (x0, x1) ->\n Ast_411.Parsetree.Pexp_variant\n (copy_label x0, Option.map copy_expression x1)\n | Ast_410.Parsetree.Pexp_record (x0, x1) ->\n Ast_411.Parsetree.Pexp_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_expression x1))\n x0,\n Option.map copy_expression x1 )\n | Ast_410.Parsetree.Pexp_field (x0, x1) ->\n Ast_411.Parsetree.Pexp_field\n (copy_expression x0, copy_loc copy_Longident_t x1)\n | Ast_410.Parsetree.Pexp_setfield (x0, x1, x2) ->\n Ast_411.Parsetree.Pexp_setfield\n (copy_expression x0, copy_loc copy_Longident_t x1, copy_expression x2)\n | Ast_410.Parsetree.Pexp_array x0 ->\n Ast_411.Parsetree.Pexp_array (List.map copy_expression x0)\n | Ast_410.Parsetree.Pexp_ifthenelse (x0, x1, x2) ->\n Ast_411.Parsetree.Pexp_ifthenelse\n (copy_expression x0, copy_expression x1, Option.map copy_expression x2)\n | Ast_410.Parsetree.Pexp_sequence (x0, x1) ->\n Ast_411.Parsetree.Pexp_sequence (copy_expression x0, copy_expression x1)\n | Ast_410.Parsetree.Pexp_while (x0, x1) ->\n Ast_411.Parsetree.Pexp_while (copy_expression x0, copy_expression x1)\n | Ast_410.Parsetree.Pexp_for (x0, x1, x2, x3, x4) ->\n Ast_411.Parsetree.Pexp_for\n ( copy_pattern x0,\n copy_expression x1,\n copy_expression x2,\n copy_direction_flag x3,\n copy_expression x4 )\n | Ast_410.Parsetree.Pexp_constraint (x0, x1) ->\n Ast_411.Parsetree.Pexp_constraint (copy_expression x0, copy_core_type x1)\n | Ast_410.Parsetree.Pexp_coerce (x0, x1, x2) ->\n Ast_411.Parsetree.Pexp_coerce\n (copy_expression x0, Option.map copy_core_type x1, copy_core_type x2)\n | Ast_410.Parsetree.Pexp_send (x0, x1) ->\n Ast_411.Parsetree.Pexp_send (copy_expression x0, copy_loc copy_label x1)\n | Ast_410.Parsetree.Pexp_new x0 ->\n Ast_411.Parsetree.Pexp_new (copy_loc copy_Longident_t x0)\n | Ast_410.Parsetree.Pexp_setinstvar (x0, x1) ->\n Ast_411.Parsetree.Pexp_setinstvar\n (copy_loc copy_label x0, copy_expression x1)\n | Ast_410.Parsetree.Pexp_override x0 ->\n Ast_411.Parsetree.Pexp_override\n (List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_label x0, copy_expression x1))\n x0)\n | Ast_410.Parsetree.Pexp_letmodule (x0, x1, x2) ->\n Ast_411.Parsetree.Pexp_letmodule\n ( copy_loc (fun x -> Option.map (fun x -> x) x) x0,\n copy_module_expr x1,\n copy_expression x2 )\n | Ast_410.Parsetree.Pexp_letexception (x0, x1) ->\n Ast_411.Parsetree.Pexp_letexception\n (copy_extension_constructor x0, copy_expression x1)\n | Ast_410.Parsetree.Pexp_assert x0 ->\n Ast_411.Parsetree.Pexp_assert (copy_expression x0)\n | Ast_410.Parsetree.Pexp_lazy x0 ->\n Ast_411.Parsetree.Pexp_lazy (copy_expression x0)\n | Ast_410.Parsetree.Pexp_poly (x0, x1) ->\n Ast_411.Parsetree.Pexp_poly\n (copy_expression x0, Option.map copy_core_type x1)\n | Ast_410.Parsetree.Pexp_object x0 ->\n Ast_411.Parsetree.Pexp_object (copy_class_structure x0)\n | Ast_410.Parsetree.Pexp_newtype (x0, x1) ->\n Ast_411.Parsetree.Pexp_newtype\n (copy_loc (fun x -> x) x0, copy_expression x1)\n | Ast_410.Parsetree.Pexp_pack x0 ->\n Ast_411.Parsetree.Pexp_pack (copy_module_expr x0)\n | Ast_410.Parsetree.Pexp_open (x0, x1) ->\n Ast_411.Parsetree.Pexp_open (copy_open_declaration x0, copy_expression x1)\n | Ast_410.Parsetree.Pexp_letop x0 ->\n Ast_411.Parsetree.Pexp_letop (copy_letop x0)\n | Ast_410.Parsetree.Pexp_extension x0 ->\n Ast_411.Parsetree.Pexp_extension (copy_extension x0)\n | Ast_410.Parsetree.Pexp_unreachable -> Ast_411.Parsetree.Pexp_unreachable\n\nand copy_letop : Ast_410.Parsetree.letop -> Ast_411.Parsetree.letop =\n fun { Ast_410.Parsetree.let_; Ast_410.Parsetree.ands; Ast_410.Parsetree.body } ->\n {\n Ast_411.Parsetree.let_ = copy_binding_op let_;\n Ast_411.Parsetree.ands = List.map copy_binding_op ands;\n Ast_411.Parsetree.body = copy_expression body;\n }\n\nand copy_binding_op :\n Ast_410.Parsetree.binding_op -> Ast_411.Parsetree.binding_op =\n fun {\n Ast_410.Parsetree.pbop_op;\n Ast_410.Parsetree.pbop_pat;\n Ast_410.Parsetree.pbop_exp;\n Ast_410.Parsetree.pbop_loc;\n } ->\n {\n Ast_411.Parsetree.pbop_op = copy_loc (fun x -> x) pbop_op;\n Ast_411.Parsetree.pbop_pat = copy_pattern pbop_pat;\n Ast_411.Parsetree.pbop_exp = copy_expression pbop_exp;\n Ast_411.Parsetree.pbop_loc = copy_location pbop_loc;\n }\n\nand copy_direction_flag :\n Ast_410.Asttypes.direction_flag -> Ast_411.Asttypes.direction_flag =\n function\n | Ast_410.Asttypes.Upto -> Ast_411.Asttypes.Upto\n | Ast_410.Asttypes.Downto -> Ast_411.Asttypes.Downto\n\nand copy_case : Ast_410.Parsetree.case -> Ast_411.Parsetree.case =\n fun {\n Ast_410.Parsetree.pc_lhs;\n Ast_410.Parsetree.pc_guard;\n Ast_410.Parsetree.pc_rhs;\n } ->\n {\n Ast_411.Parsetree.pc_lhs = copy_pattern pc_lhs;\n Ast_411.Parsetree.pc_guard = Option.map copy_expression pc_guard;\n Ast_411.Parsetree.pc_rhs = copy_expression pc_rhs;\n }\n\nand copy_cases : Ast_410.Parsetree.case list -> Ast_411.Parsetree.case list =\n fun x -> List.map copy_case x\n\nand copy_value_binding :\n Ast_410.Parsetree.value_binding -> Ast_411.Parsetree.value_binding =\n fun {\n Ast_410.Parsetree.pvb_pat;\n Ast_410.Parsetree.pvb_expr;\n Ast_410.Parsetree.pvb_attributes;\n Ast_410.Parsetree.pvb_loc;\n } ->\n {\n Ast_411.Parsetree.pvb_pat = copy_pattern pvb_pat;\n Ast_411.Parsetree.pvb_expr = copy_expression pvb_expr;\n Ast_411.Parsetree.pvb_attributes = copy_attributes pvb_attributes;\n Ast_411.Parsetree.pvb_loc = copy_location pvb_loc;\n }\n\nand copy_pattern : Ast_410.Parsetree.pattern -> Ast_411.Parsetree.pattern =\n fun {\n Ast_410.Parsetree.ppat_desc;\n Ast_410.Parsetree.ppat_loc;\n Ast_410.Parsetree.ppat_loc_stack;\n Ast_410.Parsetree.ppat_attributes;\n } ->\n {\n Ast_411.Parsetree.ppat_desc = copy_pattern_desc ppat_desc;\n Ast_411.Parsetree.ppat_loc = copy_location ppat_loc;\n Ast_411.Parsetree.ppat_loc_stack = copy_location_stack ppat_loc_stack;\n Ast_411.Parsetree.ppat_attributes = copy_attributes ppat_attributes;\n }\n\nand copy_pat x = copy_pattern x\n\nand copy_pattern_desc :\n Ast_410.Parsetree.pattern_desc -> Ast_411.Parsetree.pattern_desc = function\n | Ast_410.Parsetree.Ppat_any -> Ast_411.Parsetree.Ppat_any\n | Ast_410.Parsetree.Ppat_var x0 ->\n Ast_411.Parsetree.Ppat_var (copy_loc (fun x -> x) x0)\n | Ast_410.Parsetree.Ppat_alias (x0, x1) ->\n Ast_411.Parsetree.Ppat_alias (copy_pattern x0, copy_loc (fun x -> x) x1)\n | Ast_410.Parsetree.Ppat_constant x0 ->\n Ast_411.Parsetree.Ppat_constant (copy_constant x0)\n | Ast_410.Parsetree.Ppat_interval (x0, x1) ->\n Ast_411.Parsetree.Ppat_interval (copy_constant x0, copy_constant x1)\n | Ast_410.Parsetree.Ppat_tuple x0 ->\n Ast_411.Parsetree.Ppat_tuple (List.map copy_pattern x0)\n | Ast_410.Parsetree.Ppat_construct (x0, x1) ->\n Ast_411.Parsetree.Ppat_construct\n (copy_loc copy_Longident_t x0, Option.map copy_pattern x1)\n | Ast_410.Parsetree.Ppat_variant (x0, x1) ->\n Ast_411.Parsetree.Ppat_variant (copy_label x0, Option.map copy_pattern x1)\n | Ast_410.Parsetree.Ppat_record (x0, x1) ->\n Ast_411.Parsetree.Ppat_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_pattern x1))\n x0,\n copy_closed_flag x1 )\n | Ast_410.Parsetree.Ppat_array x0 ->\n Ast_411.Parsetree.Ppat_array (List.map copy_pattern x0)\n | Ast_410.Parsetree.Ppat_or (x0, x1) ->\n Ast_411.Parsetree.Ppat_or (copy_pattern x0, copy_pattern x1)\n | Ast_410.Parsetree.Ppat_constraint (x0, x1) ->\n Ast_411.Parsetree.Ppat_constraint (copy_pattern x0, copy_core_type x1)\n | Ast_410.Parsetree.Ppat_type x0 ->\n Ast_411.Parsetree.Ppat_type (copy_loc copy_Longident_t x0)\n | Ast_410.Parsetree.Ppat_lazy x0 ->\n Ast_411.Parsetree.Ppat_lazy (copy_pattern x0)\n | Ast_410.Parsetree.Ppat_unpack x0 ->\n Ast_411.Parsetree.Ppat_unpack\n (copy_loc (fun x -> Option.map (fun x -> x) x) x0)\n | Ast_410.Parsetree.Ppat_exception x0 ->\n Ast_411.Parsetree.Ppat_exception (copy_pattern x0)\n | Ast_410.Parsetree.Ppat_extension x0 ->\n Ast_411.Parsetree.Ppat_extension (copy_extension x0)\n | Ast_410.Parsetree.Ppat_open (x0, x1) ->\n Ast_411.Parsetree.Ppat_open (copy_loc copy_Longident_t x0, copy_pattern x1)\n\nand copy_core_type : Ast_410.Parsetree.core_type -> Ast_411.Parsetree.core_type\n =\n fun {\n Ast_410.Parsetree.ptyp_desc;\n Ast_410.Parsetree.ptyp_loc;\n Ast_410.Parsetree.ptyp_loc_stack;\n Ast_410.Parsetree.ptyp_attributes;\n } ->\n {\n Ast_411.Parsetree.ptyp_desc = copy_core_type_desc ptyp_desc;\n Ast_411.Parsetree.ptyp_loc = copy_location ptyp_loc;\n Ast_411.Parsetree.ptyp_loc_stack = copy_location_stack ptyp_loc_stack;\n Ast_411.Parsetree.ptyp_attributes = copy_attributes ptyp_attributes;\n }\n\nand copy_typ x = copy_core_type x\n\nand copy_location_stack :\n Ast_410.Parsetree.location_stack -> Ast_411.Parsetree.location_stack =\n fun x -> List.map copy_location x\n\nand copy_core_type_desc :\n Ast_410.Parsetree.core_type_desc -> Ast_411.Parsetree.core_type_desc =\n function\n | Ast_410.Parsetree.Ptyp_any -> Ast_411.Parsetree.Ptyp_any\n | Ast_410.Parsetree.Ptyp_var x0 -> Ast_411.Parsetree.Ptyp_var x0\n | Ast_410.Parsetree.Ptyp_arrow (x0, x1, x2) ->\n Ast_411.Parsetree.Ptyp_arrow\n (copy_arg_label x0, copy_core_type x1, copy_core_type x2)\n | Ast_410.Parsetree.Ptyp_tuple x0 ->\n Ast_411.Parsetree.Ptyp_tuple (List.map copy_core_type x0)\n | Ast_410.Parsetree.Ptyp_constr (x0, x1) ->\n Ast_411.Parsetree.Ptyp_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_410.Parsetree.Ptyp_object (x0, x1) ->\n Ast_411.Parsetree.Ptyp_object\n (List.map copy_object_field x0, copy_closed_flag x1)\n | Ast_410.Parsetree.Ptyp_class (x0, x1) ->\n Ast_411.Parsetree.Ptyp_class\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_410.Parsetree.Ptyp_alias (x0, x1) ->\n Ast_411.Parsetree.Ptyp_alias (copy_core_type x0, x1)\n | Ast_410.Parsetree.Ptyp_variant (x0, x1, x2) ->\n Ast_411.Parsetree.Ptyp_variant\n ( List.map copy_row_field x0,\n copy_closed_flag x1,\n Option.map (fun x -> List.map copy_label x) x2 )\n | Ast_410.Parsetree.Ptyp_poly (x0, x1) ->\n Ast_411.Parsetree.Ptyp_poly\n (List.map (fun x -> copy_loc (fun x -> x) x) x0, copy_core_type x1)\n | Ast_410.Parsetree.Ptyp_package x0 ->\n Ast_411.Parsetree.Ptyp_package (copy_package_type x0)\n | Ast_410.Parsetree.Ptyp_extension x0 ->\n Ast_411.Parsetree.Ptyp_extension (copy_extension x0)\n\nand copy_package_type :\n Ast_410.Parsetree.package_type -> Ast_411.Parsetree.package_type =\n fun x ->\n let x0, x1 = x in\n ( copy_loc copy_Longident_t x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_core_type x1))\n x1 )\n\nand copy_row_field : Ast_410.Parsetree.row_field -> Ast_411.Parsetree.row_field\n =\n fun {\n Ast_410.Parsetree.prf_desc;\n Ast_410.Parsetree.prf_loc;\n Ast_410.Parsetree.prf_attributes;\n } ->\n {\n Ast_411.Parsetree.prf_desc = copy_row_field_desc prf_desc;\n Ast_411.Parsetree.prf_loc = copy_location prf_loc;\n Ast_411.Parsetree.prf_attributes = copy_attributes prf_attributes;\n }\n\nand copy_row_field_desc :\n Ast_410.Parsetree.row_field_desc -> Ast_411.Parsetree.row_field_desc =\n function\n | Ast_410.Parsetree.Rtag (x0, x1, x2) ->\n Ast_411.Parsetree.Rtag\n (copy_loc copy_label x0, x1, List.map copy_core_type x2)\n | Ast_410.Parsetree.Rinherit x0 ->\n Ast_411.Parsetree.Rinherit (copy_core_type x0)\n\nand copy_object_field :\n Ast_410.Parsetree.object_field -> Ast_411.Parsetree.object_field =\n fun {\n Ast_410.Parsetree.pof_desc;\n Ast_410.Parsetree.pof_loc;\n Ast_410.Parsetree.pof_attributes;\n } ->\n {\n Ast_411.Parsetree.pof_desc = copy_object_field_desc pof_desc;\n Ast_411.Parsetree.pof_loc = copy_location pof_loc;\n Ast_411.Parsetree.pof_attributes = copy_attributes pof_attributes;\n }\n\nand copy_attributes :\n Ast_410.Parsetree.attributes -> Ast_411.Parsetree.attributes =\n fun x -> List.map copy_attribute x\n\nand copy_attribute : Ast_410.Parsetree.attribute -> Ast_411.Parsetree.attribute\n =\n fun {\n Ast_410.Parsetree.attr_name;\n Ast_410.Parsetree.attr_payload;\n Ast_410.Parsetree.attr_loc;\n } ->\n {\n Ast_411.Parsetree.attr_name = copy_loc (fun x -> x) attr_name;\n Ast_411.Parsetree.attr_payload = copy_payload attr_payload;\n Ast_411.Parsetree.attr_loc = copy_location attr_loc;\n }\n\nand copy_payload : Ast_410.Parsetree.payload -> Ast_411.Parsetree.payload =\n function\n | Ast_410.Parsetree.PStr x0 -> Ast_411.Parsetree.PStr (copy_structure x0)\n | Ast_410.Parsetree.PSig x0 -> Ast_411.Parsetree.PSig (copy_signature x0)\n | Ast_410.Parsetree.PTyp x0 -> Ast_411.Parsetree.PTyp (copy_core_type x0)\n | Ast_410.Parsetree.PPat (x0, x1) ->\n Ast_411.Parsetree.PPat (copy_pattern x0, Option.map copy_expression x1)\n\nand copy_structure : Ast_410.Parsetree.structure -> Ast_411.Parsetree.structure\n =\n fun x -> List.map copy_structure_item x\n\nand copy_structure_item :\n Ast_410.Parsetree.structure_item -> Ast_411.Parsetree.structure_item =\n fun { Ast_410.Parsetree.pstr_desc; Ast_410.Parsetree.pstr_loc } ->\n {\n Ast_411.Parsetree.pstr_desc = copy_structure_item_desc pstr_desc;\n Ast_411.Parsetree.pstr_loc = copy_location pstr_loc;\n }\n\nand copy_structure_item_desc :\n Ast_410.Parsetree.structure_item_desc ->\n Ast_411.Parsetree.structure_item_desc = function\n | Ast_410.Parsetree.Pstr_eval (x0, x1) ->\n Ast_411.Parsetree.Pstr_eval (copy_expression x0, copy_attributes x1)\n | Ast_410.Parsetree.Pstr_value (x0, x1) ->\n Ast_411.Parsetree.Pstr_value\n (copy_rec_flag x0, List.map copy_value_binding x1)\n | Ast_410.Parsetree.Pstr_primitive x0 ->\n Ast_411.Parsetree.Pstr_primitive (copy_value_description x0)\n | Ast_410.Parsetree.Pstr_type (x0, x1) ->\n Ast_411.Parsetree.Pstr_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | Ast_410.Parsetree.Pstr_typext x0 ->\n Ast_411.Parsetree.Pstr_typext (copy_type_extension x0)\n | Ast_410.Parsetree.Pstr_exception x0 ->\n Ast_411.Parsetree.Pstr_exception (copy_type_exception x0)\n | Ast_410.Parsetree.Pstr_module x0 ->\n Ast_411.Parsetree.Pstr_module (copy_module_binding x0)\n | Ast_410.Parsetree.Pstr_recmodule x0 ->\n Ast_411.Parsetree.Pstr_recmodule (List.map copy_module_binding x0)\n | Ast_410.Parsetree.Pstr_modtype x0 ->\n Ast_411.Parsetree.Pstr_modtype (copy_module_type_declaration x0)\n | Ast_410.Parsetree.Pstr_open x0 ->\n Ast_411.Parsetree.Pstr_open (copy_open_declaration x0)\n | Ast_410.Parsetree.Pstr_class x0 ->\n Ast_411.Parsetree.Pstr_class (List.map copy_class_declaration x0)\n | Ast_410.Parsetree.Pstr_class_type x0 ->\n Ast_411.Parsetree.Pstr_class_type\n (List.map copy_class_type_declaration x0)\n | Ast_410.Parsetree.Pstr_include x0 ->\n Ast_411.Parsetree.Pstr_include (copy_include_declaration x0)\n | Ast_410.Parsetree.Pstr_attribute x0 ->\n Ast_411.Parsetree.Pstr_attribute (copy_attribute x0)\n | Ast_410.Parsetree.Pstr_extension (x0, x1) ->\n Ast_411.Parsetree.Pstr_extension (copy_extension x0, copy_attributes x1)\n\nand copy_include_declaration :\n Ast_410.Parsetree.include_declaration ->\n Ast_411.Parsetree.include_declaration =\n fun x -> copy_include_infos copy_module_expr x\n\nand copy_class_declaration :\n Ast_410.Parsetree.class_declaration -> Ast_411.Parsetree.class_declaration =\n fun x -> copy_class_infos copy_class_expr x\n\nand copy_class_expr :\n Ast_410.Parsetree.class_expr -> Ast_411.Parsetree.class_expr =\n fun {\n Ast_410.Parsetree.pcl_desc;\n Ast_410.Parsetree.pcl_loc;\n Ast_410.Parsetree.pcl_attributes;\n } ->\n {\n Ast_411.Parsetree.pcl_desc = copy_class_expr_desc pcl_desc;\n Ast_411.Parsetree.pcl_loc = copy_location pcl_loc;\n Ast_411.Parsetree.pcl_attributes = copy_attributes pcl_attributes;\n }\n\nand copy_class_expr_desc :\n Ast_410.Parsetree.class_expr_desc -> Ast_411.Parsetree.class_expr_desc =\n function\n | Ast_410.Parsetree.Pcl_constr (x0, x1) ->\n Ast_411.Parsetree.Pcl_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_410.Parsetree.Pcl_structure x0 ->\n Ast_411.Parsetree.Pcl_structure (copy_class_structure x0)\n | Ast_410.Parsetree.Pcl_fun (x0, x1, x2, x3) ->\n Ast_411.Parsetree.Pcl_fun\n ( copy_arg_label x0,\n Option.map copy_expression x1,\n copy_pattern x2,\n copy_class_expr x3 )\n | Ast_410.Parsetree.Pcl_apply (x0, x1) ->\n Ast_411.Parsetree.Pcl_apply\n ( copy_class_expr x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | Ast_410.Parsetree.Pcl_let (x0, x1, x2) ->\n Ast_411.Parsetree.Pcl_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_class_expr x2)\n | Ast_410.Parsetree.Pcl_constraint (x0, x1) ->\n Ast_411.Parsetree.Pcl_constraint (copy_class_expr x0, copy_class_type x1)\n | Ast_410.Parsetree.Pcl_extension x0 ->\n Ast_411.Parsetree.Pcl_extension (copy_extension x0)\n | Ast_410.Parsetree.Pcl_open (x0, x1) ->\n Ast_411.Parsetree.Pcl_open (copy_open_description x0, copy_class_expr x1)\n\nand copy_class_structure :\n Ast_410.Parsetree.class_structure -> Ast_411.Parsetree.class_structure =\n fun { Ast_410.Parsetree.pcstr_self; Ast_410.Parsetree.pcstr_fields } ->\n {\n Ast_411.Parsetree.pcstr_self = copy_pattern pcstr_self;\n Ast_411.Parsetree.pcstr_fields = List.map copy_class_field pcstr_fields;\n }\n\nand copy_class_field :\n Ast_410.Parsetree.class_field -> Ast_411.Parsetree.class_field =\n fun {\n Ast_410.Parsetree.pcf_desc;\n Ast_410.Parsetree.pcf_loc;\n Ast_410.Parsetree.pcf_attributes;\n } ->\n {\n Ast_411.Parsetree.pcf_desc = copy_class_field_desc pcf_desc;\n Ast_411.Parsetree.pcf_loc = copy_location pcf_loc;\n Ast_411.Parsetree.pcf_attributes = copy_attributes pcf_attributes;\n }\n\nand copy_class_field_desc :\n Ast_410.Parsetree.class_field_desc -> Ast_411.Parsetree.class_field_desc =\n function\n | Ast_410.Parsetree.Pcf_inherit (x0, x1, x2) ->\n Ast_411.Parsetree.Pcf_inherit\n ( copy_override_flag x0,\n copy_class_expr x1,\n Option.map (fun x -> copy_loc (fun x -> x) x) x2 )\n | Ast_410.Parsetree.Pcf_val x0 ->\n Ast_411.Parsetree.Pcf_val\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_mutable_flag x1, copy_class_field_kind x2))\n | Ast_410.Parsetree.Pcf_method x0 ->\n Ast_411.Parsetree.Pcf_method\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_private_flag x1, copy_class_field_kind x2))\n | Ast_410.Parsetree.Pcf_constraint x0 ->\n Ast_411.Parsetree.Pcf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | Ast_410.Parsetree.Pcf_initializer x0 ->\n Ast_411.Parsetree.Pcf_initializer (copy_expression x0)\n | Ast_410.Parsetree.Pcf_attribute x0 ->\n Ast_411.Parsetree.Pcf_attribute (copy_attribute x0)\n | Ast_410.Parsetree.Pcf_extension x0 ->\n Ast_411.Parsetree.Pcf_extension (copy_extension x0)\n\nand copy_class_field_kind :\n Ast_410.Parsetree.class_field_kind -> Ast_411.Parsetree.class_field_kind =\n function\n | Ast_410.Parsetree.Cfk_virtual x0 ->\n Ast_411.Parsetree.Cfk_virtual (copy_core_type x0)\n | Ast_410.Parsetree.Cfk_concrete (x0, x1) ->\n Ast_411.Parsetree.Cfk_concrete (copy_override_flag x0, copy_expression x1)\n\nand copy_open_declaration :\n Ast_410.Parsetree.open_declaration -> Ast_411.Parsetree.open_declaration =\n fun x -> copy_open_infos copy_module_expr x\n\nand copy_module_binding :\n Ast_410.Parsetree.module_binding -> Ast_411.Parsetree.module_binding =\n fun {\n Ast_410.Parsetree.pmb_name;\n Ast_410.Parsetree.pmb_expr;\n Ast_410.Parsetree.pmb_attributes;\n Ast_410.Parsetree.pmb_loc;\n } ->\n {\n Ast_411.Parsetree.pmb_name =\n copy_loc (fun x -> Option.map (fun x -> x) x) pmb_name;\n Ast_411.Parsetree.pmb_expr = copy_module_expr pmb_expr;\n Ast_411.Parsetree.pmb_attributes = copy_attributes pmb_attributes;\n Ast_411.Parsetree.pmb_loc = copy_location pmb_loc;\n }\n\nand copy_module_expr :\n Ast_410.Parsetree.module_expr -> Ast_411.Parsetree.module_expr =\n fun {\n Ast_410.Parsetree.pmod_desc;\n Ast_410.Parsetree.pmod_loc;\n Ast_410.Parsetree.pmod_attributes;\n } ->\n {\n Ast_411.Parsetree.pmod_desc = copy_module_expr_desc pmod_desc;\n Ast_411.Parsetree.pmod_loc = copy_location pmod_loc;\n Ast_411.Parsetree.pmod_attributes = copy_attributes pmod_attributes;\n }\n\nand copy_module_expr_desc :\n Ast_410.Parsetree.module_expr_desc -> Ast_411.Parsetree.module_expr_desc =\n function\n | Ast_410.Parsetree.Pmod_ident x0 ->\n Ast_411.Parsetree.Pmod_ident (copy_loc copy_Longident_t x0)\n | Ast_410.Parsetree.Pmod_structure x0 ->\n Ast_411.Parsetree.Pmod_structure (copy_structure x0)\n | Ast_410.Parsetree.Pmod_functor (x0, x1) ->\n Ast_411.Parsetree.Pmod_functor\n (copy_functor_parameter x0, copy_module_expr x1)\n | Ast_410.Parsetree.Pmod_apply (x0, x1) ->\n Ast_411.Parsetree.Pmod_apply (copy_module_expr x0, copy_module_expr x1)\n | Ast_410.Parsetree.Pmod_constraint (x0, x1) ->\n Ast_411.Parsetree.Pmod_constraint\n (copy_module_expr x0, copy_module_type x1)\n | Ast_410.Parsetree.Pmod_unpack x0 ->\n Ast_411.Parsetree.Pmod_unpack (copy_expression x0)\n | Ast_410.Parsetree.Pmod_extension x0 ->\n Ast_411.Parsetree.Pmod_extension (copy_extension x0)\n\nand copy_functor_parameter :\n Ast_410.Parsetree.functor_parameter -> Ast_411.Parsetree.functor_parameter =\n function\n | Ast_410.Parsetree.Unit -> Ast_411.Parsetree.Unit\n | Ast_410.Parsetree.Named (x0, x1) ->\n Ast_411.Parsetree.Named\n (copy_loc (fun x -> Option.map (fun x -> x) x) x0, copy_module_type x1)\n\nand copy_module_type :\n Ast_410.Parsetree.module_type -> Ast_411.Parsetree.module_type =\n fun {\n Ast_410.Parsetree.pmty_desc;\n Ast_410.Parsetree.pmty_loc;\n Ast_410.Parsetree.pmty_attributes;\n } ->\n {\n Ast_411.Parsetree.pmty_desc = copy_module_type_desc pmty_desc;\n Ast_411.Parsetree.pmty_loc = copy_location pmty_loc;\n Ast_411.Parsetree.pmty_attributes = copy_attributes pmty_attributes;\n }\n\nand copy_module_type_desc :\n Ast_410.Parsetree.module_type_desc -> Ast_411.Parsetree.module_type_desc =\n function\n | Ast_410.Parsetree.Pmty_ident x0 ->\n Ast_411.Parsetree.Pmty_ident (copy_loc copy_Longident_t x0)\n | Ast_410.Parsetree.Pmty_signature x0 ->\n Ast_411.Parsetree.Pmty_signature (copy_signature x0)\n | Ast_410.Parsetree.Pmty_functor (x0, x1) ->\n Ast_411.Parsetree.Pmty_functor\n (copy_functor_parameter x0, copy_module_type x1)\n | Ast_410.Parsetree.Pmty_with (x0, x1) ->\n Ast_411.Parsetree.Pmty_with\n (copy_module_type x0, List.map copy_with_constraint x1)\n | Ast_410.Parsetree.Pmty_typeof x0 ->\n Ast_411.Parsetree.Pmty_typeof (copy_module_expr x0)\n | Ast_410.Parsetree.Pmty_extension x0 ->\n Ast_411.Parsetree.Pmty_extension (copy_extension x0)\n | Ast_410.Parsetree.Pmty_alias x0 ->\n Ast_411.Parsetree.Pmty_alias (copy_loc copy_Longident_t x0)\n\nand copy_with_constraint :\n Ast_410.Parsetree.with_constraint -> Ast_411.Parsetree.with_constraint =\n function\n | Ast_410.Parsetree.Pwith_type (x0, x1) ->\n Ast_411.Parsetree.Pwith_type\n (copy_loc copy_Longident_t x0, copy_type_declaration x1)\n | Ast_410.Parsetree.Pwith_module (x0, x1) ->\n Ast_411.Parsetree.Pwith_module\n (copy_loc copy_Longident_t x0, copy_loc copy_Longident_t x1)\n | Ast_410.Parsetree.Pwith_typesubst (x0, x1) ->\n Ast_411.Parsetree.Pwith_typesubst\n (copy_loc copy_Longident_t x0, copy_type_declaration x1)\n | Ast_410.Parsetree.Pwith_modsubst (x0, x1) ->\n Ast_411.Parsetree.Pwith_modsubst\n (copy_loc copy_Longident_t x0, copy_loc copy_Longident_t x1)\n\nand copy_signature : Ast_410.Parsetree.signature -> Ast_411.Parsetree.signature\n =\n fun x -> List.map copy_signature_item x\n\nand copy_signature_item :\n Ast_410.Parsetree.signature_item -> Ast_411.Parsetree.signature_item =\n fun { Ast_410.Parsetree.psig_desc; Ast_410.Parsetree.psig_loc } ->\n {\n Ast_411.Parsetree.psig_desc = copy_signature_item_desc psig_desc;\n Ast_411.Parsetree.psig_loc = copy_location psig_loc;\n }\n\nand copy_signature_item_desc :\n Ast_410.Parsetree.signature_item_desc ->\n Ast_411.Parsetree.signature_item_desc = function\n | Ast_410.Parsetree.Psig_value x0 ->\n Ast_411.Parsetree.Psig_value (copy_value_description x0)\n | Ast_410.Parsetree.Psig_type (x0, x1) ->\n Ast_411.Parsetree.Psig_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | Ast_410.Parsetree.Psig_typesubst x0 ->\n Ast_411.Parsetree.Psig_typesubst (List.map copy_type_declaration x0)\n | Ast_410.Parsetree.Psig_typext x0 ->\n Ast_411.Parsetree.Psig_typext (copy_type_extension x0)\n | Ast_410.Parsetree.Psig_exception x0 ->\n Ast_411.Parsetree.Psig_exception (copy_type_exception x0)\n | Ast_410.Parsetree.Psig_module x0 ->\n Ast_411.Parsetree.Psig_module (copy_module_declaration x0)\n | Ast_410.Parsetree.Psig_modsubst x0 ->\n Ast_411.Parsetree.Psig_modsubst (copy_module_substitution x0)\n | Ast_410.Parsetree.Psig_recmodule x0 ->\n Ast_411.Parsetree.Psig_recmodule (List.map copy_module_declaration x0)\n | Ast_410.Parsetree.Psig_modtype x0 ->\n Ast_411.Parsetree.Psig_modtype (copy_module_type_declaration x0)\n | Ast_410.Parsetree.Psig_open x0 ->\n Ast_411.Parsetree.Psig_open (copy_open_description x0)\n | Ast_410.Parsetree.Psig_include x0 ->\n Ast_411.Parsetree.Psig_include (copy_include_description x0)\n | Ast_410.Parsetree.Psig_class x0 ->\n Ast_411.Parsetree.Psig_class (List.map copy_class_description x0)\n | Ast_410.Parsetree.Psig_class_type x0 ->\n Ast_411.Parsetree.Psig_class_type\n (List.map copy_class_type_declaration x0)\n | Ast_410.Parsetree.Psig_attribute x0 ->\n Ast_411.Parsetree.Psig_attribute (copy_attribute x0)\n | Ast_410.Parsetree.Psig_extension (x0, x1) ->\n Ast_411.Parsetree.Psig_extension (copy_extension x0, copy_attributes x1)\n\nand copy_class_type_declaration :\n Ast_410.Parsetree.class_type_declaration ->\n Ast_411.Parsetree.class_type_declaration =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_description :\n Ast_410.Parsetree.class_description -> Ast_411.Parsetree.class_description =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_type :\n Ast_410.Parsetree.class_type -> Ast_411.Parsetree.class_type =\n fun {\n Ast_410.Parsetree.pcty_desc;\n Ast_410.Parsetree.pcty_loc;\n Ast_410.Parsetree.pcty_attributes;\n } ->\n {\n Ast_411.Parsetree.pcty_desc = copy_class_type_desc pcty_desc;\n Ast_411.Parsetree.pcty_loc = copy_location pcty_loc;\n Ast_411.Parsetree.pcty_attributes = copy_attributes pcty_attributes;\n }\n\nand copy_class_type_desc :\n Ast_410.Parsetree.class_type_desc -> Ast_411.Parsetree.class_type_desc =\n function\n | Ast_410.Parsetree.Pcty_constr (x0, x1) ->\n Ast_411.Parsetree.Pcty_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_410.Parsetree.Pcty_signature x0 ->\n Ast_411.Parsetree.Pcty_signature (copy_class_signature x0)\n | Ast_410.Parsetree.Pcty_arrow (x0, x1, x2) ->\n Ast_411.Parsetree.Pcty_arrow\n (copy_arg_label x0, copy_core_type x1, copy_class_type x2)\n | Ast_410.Parsetree.Pcty_extension x0 ->\n Ast_411.Parsetree.Pcty_extension (copy_extension x0)\n | Ast_410.Parsetree.Pcty_open (x0, x1) ->\n Ast_411.Parsetree.Pcty_open (copy_open_description x0, copy_class_type x1)\n\nand copy_class_signature :\n Ast_410.Parsetree.class_signature -> Ast_411.Parsetree.class_signature =\n fun { Ast_410.Parsetree.pcsig_self; Ast_410.Parsetree.pcsig_fields } ->\n {\n Ast_411.Parsetree.pcsig_self = copy_core_type pcsig_self;\n Ast_411.Parsetree.pcsig_fields = List.map copy_class_type_field pcsig_fields;\n }\n\nand copy_class_type_field :\n Ast_410.Parsetree.class_type_field -> Ast_411.Parsetree.class_type_field =\n fun {\n Ast_410.Parsetree.pctf_desc;\n Ast_410.Parsetree.pctf_loc;\n Ast_410.Parsetree.pctf_attributes;\n } ->\n {\n Ast_411.Parsetree.pctf_desc = copy_class_type_field_desc pctf_desc;\n Ast_411.Parsetree.pctf_loc = copy_location pctf_loc;\n Ast_411.Parsetree.pctf_attributes = copy_attributes pctf_attributes;\n }\n\nand copy_class_type_field_desc :\n Ast_410.Parsetree.class_type_field_desc ->\n Ast_411.Parsetree.class_type_field_desc = function\n | Ast_410.Parsetree.Pctf_inherit x0 ->\n Ast_411.Parsetree.Pctf_inherit (copy_class_type x0)\n | Ast_410.Parsetree.Pctf_val x0 ->\n Ast_411.Parsetree.Pctf_val\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_mutable_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | Ast_410.Parsetree.Pctf_method x0 ->\n Ast_411.Parsetree.Pctf_method\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_private_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | Ast_410.Parsetree.Pctf_constraint x0 ->\n Ast_411.Parsetree.Pctf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | Ast_410.Parsetree.Pctf_attribute x0 ->\n Ast_411.Parsetree.Pctf_attribute (copy_attribute x0)\n | Ast_410.Parsetree.Pctf_extension x0 ->\n Ast_411.Parsetree.Pctf_extension (copy_extension x0)\n\nand copy_extension : Ast_410.Parsetree.extension -> Ast_411.Parsetree.extension\n =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_class_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_410.Parsetree.class_infos ->\n 'g0 Ast_411.Parsetree.class_infos =\n fun f0\n {\n Ast_410.Parsetree.pci_virt;\n Ast_410.Parsetree.pci_params;\n Ast_410.Parsetree.pci_name;\n Ast_410.Parsetree.pci_expr;\n Ast_410.Parsetree.pci_loc;\n Ast_410.Parsetree.pci_attributes;\n } ->\n {\n Ast_411.Parsetree.pci_virt = copy_virtual_flag pci_virt;\n Ast_411.Parsetree.pci_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n pci_params;\n Ast_411.Parsetree.pci_name = copy_loc (fun x -> x) pci_name;\n Ast_411.Parsetree.pci_expr = f0 pci_expr;\n Ast_411.Parsetree.pci_loc = copy_location pci_loc;\n Ast_411.Parsetree.pci_attributes = copy_attributes pci_attributes;\n }\n\nand copy_virtual_flag :\n Ast_410.Asttypes.virtual_flag -> Ast_411.Asttypes.virtual_flag = function\n | Ast_410.Asttypes.Virtual -> Ast_411.Asttypes.Virtual\n | Ast_410.Asttypes.Concrete -> Ast_411.Asttypes.Concrete\n\nand copy_include_description :\n Ast_410.Parsetree.include_description ->\n Ast_411.Parsetree.include_description =\n fun x -> copy_include_infos copy_module_type x\n\nand copy_include_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_410.Parsetree.include_infos ->\n 'g0 Ast_411.Parsetree.include_infos =\n fun f0\n {\n Ast_410.Parsetree.pincl_mod;\n Ast_410.Parsetree.pincl_loc;\n Ast_410.Parsetree.pincl_attributes;\n } ->\n {\n Ast_411.Parsetree.pincl_mod = f0 pincl_mod;\n Ast_411.Parsetree.pincl_loc = copy_location pincl_loc;\n Ast_411.Parsetree.pincl_attributes = copy_attributes pincl_attributes;\n }\n\nand copy_open_description :\n Ast_410.Parsetree.open_description -> Ast_411.Parsetree.open_description =\n fun x -> copy_open_infos (fun x -> copy_loc copy_Longident_t x) x\n\nand copy_open_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_410.Parsetree.open_infos ->\n 'g0 Ast_411.Parsetree.open_infos =\n fun f0\n {\n Ast_410.Parsetree.popen_expr;\n Ast_410.Parsetree.popen_override;\n Ast_410.Parsetree.popen_loc;\n Ast_410.Parsetree.popen_attributes;\n } ->\n {\n Ast_411.Parsetree.popen_expr = f0 popen_expr;\n Ast_411.Parsetree.popen_override = copy_override_flag popen_override;\n Ast_411.Parsetree.popen_loc = copy_location popen_loc;\n Ast_411.Parsetree.popen_attributes = copy_attributes popen_attributes;\n }\n\nand copy_override_flag :\n Ast_410.Asttypes.override_flag -> Ast_411.Asttypes.override_flag = function\n | Ast_410.Asttypes.Override -> Ast_411.Asttypes.Override\n | Ast_410.Asttypes.Fresh -> Ast_411.Asttypes.Fresh\n\nand copy_module_type_declaration :\n Ast_410.Parsetree.module_type_declaration ->\n Ast_411.Parsetree.module_type_declaration =\n fun {\n Ast_410.Parsetree.pmtd_name;\n Ast_410.Parsetree.pmtd_type;\n Ast_410.Parsetree.pmtd_attributes;\n Ast_410.Parsetree.pmtd_loc;\n } ->\n {\n Ast_411.Parsetree.pmtd_name = copy_loc (fun x -> x) pmtd_name;\n Ast_411.Parsetree.pmtd_type = Option.map copy_module_type pmtd_type;\n Ast_411.Parsetree.pmtd_attributes = copy_attributes pmtd_attributes;\n Ast_411.Parsetree.pmtd_loc = copy_location pmtd_loc;\n }\n\nand copy_module_substitution :\n Ast_410.Parsetree.module_substitution ->\n Ast_411.Parsetree.module_substitution =\n fun {\n Ast_410.Parsetree.pms_name;\n Ast_410.Parsetree.pms_manifest;\n Ast_410.Parsetree.pms_attributes;\n Ast_410.Parsetree.pms_loc;\n } ->\n {\n Ast_411.Parsetree.pms_name = copy_loc (fun x -> x) pms_name;\n Ast_411.Parsetree.pms_manifest = copy_loc copy_Longident_t pms_manifest;\n Ast_411.Parsetree.pms_attributes = copy_attributes pms_attributes;\n Ast_411.Parsetree.pms_loc = copy_location pms_loc;\n }\n\nand copy_module_declaration :\n Ast_410.Parsetree.module_declaration -> Ast_411.Parsetree.module_declaration\n =\n fun {\n Ast_410.Parsetree.pmd_name;\n Ast_410.Parsetree.pmd_type;\n Ast_410.Parsetree.pmd_attributes;\n Ast_410.Parsetree.pmd_loc;\n } ->\n {\n Ast_411.Parsetree.pmd_name =\n copy_loc (fun x -> Option.map (fun x -> x) x) pmd_name;\n Ast_411.Parsetree.pmd_type = copy_module_type pmd_type;\n Ast_411.Parsetree.pmd_attributes = copy_attributes pmd_attributes;\n Ast_411.Parsetree.pmd_loc = copy_location pmd_loc;\n }\n\nand copy_type_exception :\n Ast_410.Parsetree.type_exception -> Ast_411.Parsetree.type_exception =\n fun {\n Ast_410.Parsetree.ptyexn_constructor;\n Ast_410.Parsetree.ptyexn_loc;\n Ast_410.Parsetree.ptyexn_attributes;\n } ->\n {\n Ast_411.Parsetree.ptyexn_constructor =\n copy_extension_constructor ptyexn_constructor;\n Ast_411.Parsetree.ptyexn_loc = copy_location ptyexn_loc;\n Ast_411.Parsetree.ptyexn_attributes = copy_attributes ptyexn_attributes;\n }\n\nand copy_type_extension :\n Ast_410.Parsetree.type_extension -> Ast_411.Parsetree.type_extension =\n fun {\n Ast_410.Parsetree.ptyext_path;\n Ast_410.Parsetree.ptyext_params;\n Ast_410.Parsetree.ptyext_constructors;\n Ast_410.Parsetree.ptyext_private;\n Ast_410.Parsetree.ptyext_loc;\n Ast_410.Parsetree.ptyext_attributes;\n } ->\n {\n Ast_411.Parsetree.ptyext_path = copy_loc copy_Longident_t ptyext_path;\n Ast_411.Parsetree.ptyext_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptyext_params;\n Ast_411.Parsetree.ptyext_constructors =\n List.map copy_extension_constructor ptyext_constructors;\n Ast_411.Parsetree.ptyext_private = copy_private_flag ptyext_private;\n Ast_411.Parsetree.ptyext_loc = copy_location ptyext_loc;\n Ast_411.Parsetree.ptyext_attributes = copy_attributes ptyext_attributes;\n }\n\nand copy_extension_constructor :\n Ast_410.Parsetree.extension_constructor ->\n Ast_411.Parsetree.extension_constructor =\n fun {\n Ast_410.Parsetree.pext_name;\n Ast_410.Parsetree.pext_kind;\n Ast_410.Parsetree.pext_loc;\n Ast_410.Parsetree.pext_attributes;\n } ->\n {\n Ast_411.Parsetree.pext_name = copy_loc (fun x -> x) pext_name;\n Ast_411.Parsetree.pext_kind = copy_extension_constructor_kind pext_kind;\n Ast_411.Parsetree.pext_loc = copy_location pext_loc;\n Ast_411.Parsetree.pext_attributes = copy_attributes pext_attributes;\n }\n\nand copy_extension_constructor_kind :\n Ast_410.Parsetree.extension_constructor_kind ->\n Ast_411.Parsetree.extension_constructor_kind = function\n | Ast_410.Parsetree.Pext_decl (x0, x1) ->\n Ast_411.Parsetree.Pext_decl\n (copy_constructor_arguments x0, Option.map copy_core_type x1)\n | Ast_410.Parsetree.Pext_rebind x0 ->\n Ast_411.Parsetree.Pext_rebind (copy_loc copy_Longident_t x0)\n\nand copy_type_declaration :\n Ast_410.Parsetree.type_declaration -> Ast_411.Parsetree.type_declaration =\n fun {\n Ast_410.Parsetree.ptype_name;\n Ast_410.Parsetree.ptype_params;\n Ast_410.Parsetree.ptype_cstrs;\n Ast_410.Parsetree.ptype_kind;\n Ast_410.Parsetree.ptype_private;\n Ast_410.Parsetree.ptype_manifest;\n Ast_410.Parsetree.ptype_attributes;\n Ast_410.Parsetree.ptype_loc;\n } ->\n {\n Ast_411.Parsetree.ptype_name = copy_loc (fun x -> x) ptype_name;\n Ast_411.Parsetree.ptype_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptype_params;\n Ast_411.Parsetree.ptype_cstrs =\n List.map\n (fun x ->\n let x0, x1, x2 = x in\n (copy_core_type x0, copy_core_type x1, copy_location x2))\n ptype_cstrs;\n Ast_411.Parsetree.ptype_kind = copy_type_kind ptype_kind;\n Ast_411.Parsetree.ptype_private = copy_private_flag ptype_private;\n Ast_411.Parsetree.ptype_manifest = Option.map copy_core_type ptype_manifest;\n Ast_411.Parsetree.ptype_attributes = copy_attributes ptype_attributes;\n Ast_411.Parsetree.ptype_loc = copy_location ptype_loc;\n }\n\nand copy_private_flag :\n Ast_410.Asttypes.private_flag -> Ast_411.Asttypes.private_flag = function\n | Ast_410.Asttypes.Private -> Ast_411.Asttypes.Private\n | Ast_410.Asttypes.Public -> Ast_411.Asttypes.Public\n\nand copy_type_kind : Ast_410.Parsetree.type_kind -> Ast_411.Parsetree.type_kind\n = function\n | Ast_410.Parsetree.Ptype_abstract -> Ast_411.Parsetree.Ptype_abstract\n | Ast_410.Parsetree.Ptype_variant x0 ->\n Ast_411.Parsetree.Ptype_variant (List.map copy_constructor_declaration x0)\n | Ast_410.Parsetree.Ptype_record x0 ->\n Ast_411.Parsetree.Ptype_record (List.map copy_label_declaration x0)\n | Ast_410.Parsetree.Ptype_open -> Ast_411.Parsetree.Ptype_open\n\nand copy_constructor_declaration :\n Ast_410.Parsetree.constructor_declaration ->\n Ast_411.Parsetree.constructor_declaration =\n fun {\n Ast_410.Parsetree.pcd_name;\n Ast_410.Parsetree.pcd_args;\n Ast_410.Parsetree.pcd_res;\n Ast_410.Parsetree.pcd_loc;\n Ast_410.Parsetree.pcd_attributes;\n } ->\n {\n Ast_411.Parsetree.pcd_name = copy_loc (fun x -> x) pcd_name;\n Ast_411.Parsetree.pcd_args = copy_constructor_arguments pcd_args;\n Ast_411.Parsetree.pcd_res = Option.map copy_core_type pcd_res;\n Ast_411.Parsetree.pcd_loc = copy_location pcd_loc;\n Ast_411.Parsetree.pcd_attributes = copy_attributes pcd_attributes;\n }\n\nand copy_constructor_arguments :\n Ast_410.Parsetree.constructor_arguments ->\n Ast_411.Parsetree.constructor_arguments = function\n | Ast_410.Parsetree.Pcstr_tuple x0 ->\n Ast_411.Parsetree.Pcstr_tuple (List.map copy_core_type x0)\n | Ast_410.Parsetree.Pcstr_record x0 ->\n Ast_411.Parsetree.Pcstr_record (List.map copy_label_declaration x0)\n\nand copy_label_declaration :\n Ast_410.Parsetree.label_declaration -> Ast_411.Parsetree.label_declaration =\n fun {\n Ast_410.Parsetree.pld_name;\n Ast_410.Parsetree.pld_mutable;\n Ast_410.Parsetree.pld_type;\n Ast_410.Parsetree.pld_loc;\n Ast_410.Parsetree.pld_attributes;\n } ->\n {\n Ast_411.Parsetree.pld_name = copy_loc (fun x -> x) pld_name;\n Ast_411.Parsetree.pld_mutable = copy_mutable_flag pld_mutable;\n Ast_411.Parsetree.pld_type = copy_core_type pld_type;\n Ast_411.Parsetree.pld_loc = copy_location pld_loc;\n Ast_411.Parsetree.pld_attributes = copy_attributes pld_attributes;\n }\n\nand copy_mutable_flag :\n Ast_410.Asttypes.mutable_flag -> Ast_411.Asttypes.mutable_flag = function\n | Ast_410.Asttypes.Immutable -> Ast_411.Asttypes.Immutable\n | Ast_410.Asttypes.Mutable -> Ast_411.Asttypes.Mutable\n\nand copy_variance : Ast_410.Asttypes.variance -> Ast_411.Asttypes.variance =\n function\n | Ast_410.Asttypes.Covariant -> Ast_411.Asttypes.Covariant\n | Ast_410.Asttypes.Contravariant -> Ast_411.Asttypes.Contravariant\n | Ast_410.Asttypes.Invariant -> Ast_411.Asttypes.Invariant\n\nand copy_value_description :\n Ast_410.Parsetree.value_description -> Ast_411.Parsetree.value_description =\n fun {\n Ast_410.Parsetree.pval_name;\n Ast_410.Parsetree.pval_type;\n Ast_410.Parsetree.pval_prim;\n Ast_410.Parsetree.pval_attributes;\n Ast_410.Parsetree.pval_loc;\n } ->\n {\n Ast_411.Parsetree.pval_name = copy_loc (fun x -> x) pval_name;\n Ast_411.Parsetree.pval_type = copy_core_type pval_type;\n Ast_411.Parsetree.pval_prim = List.map (fun x -> x) pval_prim;\n Ast_411.Parsetree.pval_attributes = copy_attributes pval_attributes;\n Ast_411.Parsetree.pval_loc = copy_location pval_loc;\n }\n\nand copy_object_field_desc :\n Ast_410.Parsetree.object_field_desc -> Ast_411.Parsetree.object_field_desc =\n function\n | Ast_410.Parsetree.Otag (x0, x1) ->\n Ast_411.Parsetree.Otag (copy_loc copy_label x0, copy_core_type x1)\n | Ast_410.Parsetree.Oinherit x0 ->\n Ast_411.Parsetree.Oinherit (copy_core_type x0)\n\nand copy_arg_label : Ast_410.Asttypes.arg_label -> Ast_411.Asttypes.arg_label =\n function\n | Ast_410.Asttypes.Nolabel -> Ast_411.Asttypes.Nolabel\n | Ast_410.Asttypes.Labelled x0 -> Ast_411.Asttypes.Labelled x0\n | Ast_410.Asttypes.Optional x0 -> Ast_411.Asttypes.Optional x0\n\nand copy_closed_flag :\n Ast_410.Asttypes.closed_flag -> Ast_411.Asttypes.closed_flag = function\n | Ast_410.Asttypes.Closed -> Ast_411.Asttypes.Closed\n | Ast_410.Asttypes.Open -> Ast_411.Asttypes.Open\n\nand copy_label : Ast_410.Asttypes.label -> Ast_411.Asttypes.label = fun x -> x\n\nand copy_rec_flag : Ast_410.Asttypes.rec_flag -> Ast_411.Asttypes.rec_flag =\n function\n | Ast_410.Asttypes.Nonrecursive -> Ast_411.Asttypes.Nonrecursive\n | Ast_410.Asttypes.Recursive -> Ast_411.Asttypes.Recursive\n\nand copy_constant : Ast_410.Parsetree.constant -> Ast_411.Parsetree.constant =\n function\n | Ast_410.Parsetree.Pconst_integer (x0, x1) ->\n Ast_411.Parsetree.Pconst_integer (x0, Option.map (fun x -> x) x1)\n | Ast_410.Parsetree.Pconst_char x0 -> Ast_411.Parsetree.Pconst_char x0\n | Ast_410.Parsetree.Pconst_string (x0, x1) ->\n Ast_411.Parsetree.Pconst_string\n (x0, Location.none, Option.map (fun x -> x) x1)\n | Ast_410.Parsetree.Pconst_float (x0, x1) ->\n Ast_411.Parsetree.Pconst_float (x0, Option.map (fun x -> x) x1)\n\nand copy_Longident_t : Longident.t -> Longident.t = fun x -> x\n\nand copy_loc :\n 'f0 'g0.\n ('f0 -> 'g0) -> 'f0 Ast_410.Asttypes.loc -> 'g0 Ast_411.Asttypes.loc =\n fun f0 { Ast_410.Asttypes.txt; Ast_410.Asttypes.loc } ->\n { Ast_411.Asttypes.txt = f0 txt; Ast_411.Asttypes.loc = copy_location loc }\n\nand copy_location : Location.t -> Location.t = fun x -> x\n","module From = Ast_410\nmodule To = Ast_409\n\nlet migration_error loc missing_feature =\n Location.raise_errorf ~loc\n \"migration error: %s is not supported before OCaml 4.10\" missing_feature\n\nlet map_option f x = match x with None -> None | Some x -> Some (f x)\n\nlet rec copy_toplevel_phrase :\n Ast_410.Parsetree.toplevel_phrase -> Ast_409.Parsetree.toplevel_phrase =\n function\n | Ast_410.Parsetree.Ptop_def x0 ->\n Ast_409.Parsetree.Ptop_def (copy_structure x0)\n | Ast_410.Parsetree.Ptop_dir x0 ->\n Ast_409.Parsetree.Ptop_dir (copy_toplevel_directive x0)\n\nand copy_toplevel_directive :\n Ast_410.Parsetree.toplevel_directive -> Ast_409.Parsetree.toplevel_directive\n =\n fun {\n Ast_410.Parsetree.pdir_name;\n Ast_410.Parsetree.pdir_arg;\n Ast_410.Parsetree.pdir_loc;\n } ->\n {\n Ast_409.Parsetree.pdir_name = copy_loc (fun x -> x) pdir_name;\n Ast_409.Parsetree.pdir_arg = map_option copy_directive_argument pdir_arg;\n Ast_409.Parsetree.pdir_loc = copy_location pdir_loc;\n }\n\nand copy_directive_argument :\n Ast_410.Parsetree.directive_argument -> Ast_409.Parsetree.directive_argument\n =\n fun { Ast_410.Parsetree.pdira_desc; Ast_410.Parsetree.pdira_loc } ->\n {\n Ast_409.Parsetree.pdira_desc = copy_directive_argument_desc pdira_desc;\n Ast_409.Parsetree.pdira_loc = copy_location pdira_loc;\n }\n\nand copy_directive_argument_desc :\n Ast_410.Parsetree.directive_argument_desc ->\n Ast_409.Parsetree.directive_argument_desc = function\n | Ast_410.Parsetree.Pdir_string x0 -> Ast_409.Parsetree.Pdir_string x0\n | Ast_410.Parsetree.Pdir_int (x0, x1) ->\n Ast_409.Parsetree.Pdir_int (x0, map_option (fun x -> x) x1)\n | Ast_410.Parsetree.Pdir_ident x0 ->\n Ast_409.Parsetree.Pdir_ident (copy_Longident_t x0)\n | Ast_410.Parsetree.Pdir_bool x0 -> Ast_409.Parsetree.Pdir_bool x0\n\nand copy_expression :\n Ast_410.Parsetree.expression -> Ast_409.Parsetree.expression =\n fun {\n Ast_410.Parsetree.pexp_desc;\n Ast_410.Parsetree.pexp_loc;\n Ast_410.Parsetree.pexp_loc_stack;\n Ast_410.Parsetree.pexp_attributes;\n } ->\n {\n Ast_409.Parsetree.pexp_desc = copy_expression_desc pexp_desc;\n Ast_409.Parsetree.pexp_loc = copy_location pexp_loc;\n Ast_409.Parsetree.pexp_loc_stack = copy_location_stack pexp_loc_stack;\n Ast_409.Parsetree.pexp_attributes = copy_attributes pexp_attributes;\n }\n\nand copy_expression_desc :\n Ast_410.Parsetree.expression_desc -> Ast_409.Parsetree.expression_desc =\n function\n | Ast_410.Parsetree.Pexp_ident x0 ->\n Ast_409.Parsetree.Pexp_ident (copy_loc copy_Longident_t x0)\n | Ast_410.Parsetree.Pexp_constant x0 ->\n Ast_409.Parsetree.Pexp_constant (copy_constant x0)\n | Ast_410.Parsetree.Pexp_let (x0, x1, x2) ->\n Ast_409.Parsetree.Pexp_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_expression x2)\n | Ast_410.Parsetree.Pexp_function x0 ->\n Ast_409.Parsetree.Pexp_function (List.map copy_case x0)\n | Ast_410.Parsetree.Pexp_fun (x0, x1, x2, x3) ->\n Ast_409.Parsetree.Pexp_fun\n ( copy_arg_label x0,\n map_option copy_expression x1,\n copy_pattern x2,\n copy_expression x3 )\n | Ast_410.Parsetree.Pexp_apply (x0, x1) ->\n Ast_409.Parsetree.Pexp_apply\n ( copy_expression x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | Ast_410.Parsetree.Pexp_match (x0, x1) ->\n Ast_409.Parsetree.Pexp_match (copy_expression x0, List.map copy_case x1)\n | Ast_410.Parsetree.Pexp_try (x0, x1) ->\n Ast_409.Parsetree.Pexp_try (copy_expression x0, List.map copy_case x1)\n | Ast_410.Parsetree.Pexp_tuple x0 ->\n Ast_409.Parsetree.Pexp_tuple (List.map copy_expression x0)\n | Ast_410.Parsetree.Pexp_construct (x0, x1) ->\n Ast_409.Parsetree.Pexp_construct\n (copy_loc copy_Longident_t x0, map_option copy_expression x1)\n | Ast_410.Parsetree.Pexp_variant (x0, x1) ->\n Ast_409.Parsetree.Pexp_variant\n (copy_label x0, map_option copy_expression x1)\n | Ast_410.Parsetree.Pexp_record (x0, x1) ->\n Ast_409.Parsetree.Pexp_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_expression x1))\n x0,\n map_option copy_expression x1 )\n | Ast_410.Parsetree.Pexp_field (x0, x1) ->\n Ast_409.Parsetree.Pexp_field\n (copy_expression x0, copy_loc copy_Longident_t x1)\n | Ast_410.Parsetree.Pexp_setfield (x0, x1, x2) ->\n Ast_409.Parsetree.Pexp_setfield\n (copy_expression x0, copy_loc copy_Longident_t x1, copy_expression x2)\n | Ast_410.Parsetree.Pexp_array x0 ->\n Ast_409.Parsetree.Pexp_array (List.map copy_expression x0)\n | Ast_410.Parsetree.Pexp_ifthenelse (x0, x1, x2) ->\n Ast_409.Parsetree.Pexp_ifthenelse\n (copy_expression x0, copy_expression x1, map_option copy_expression x2)\n | Ast_410.Parsetree.Pexp_sequence (x0, x1) ->\n Ast_409.Parsetree.Pexp_sequence (copy_expression x0, copy_expression x1)\n | Ast_410.Parsetree.Pexp_while (x0, x1) ->\n Ast_409.Parsetree.Pexp_while (copy_expression x0, copy_expression x1)\n | Ast_410.Parsetree.Pexp_for (x0, x1, x2, x3, x4) ->\n Ast_409.Parsetree.Pexp_for\n ( copy_pattern x0,\n copy_expression x1,\n copy_expression x2,\n copy_direction_flag x3,\n copy_expression x4 )\n | Ast_410.Parsetree.Pexp_constraint (x0, x1) ->\n Ast_409.Parsetree.Pexp_constraint (copy_expression x0, copy_core_type x1)\n | Ast_410.Parsetree.Pexp_coerce (x0, x1, x2) ->\n Ast_409.Parsetree.Pexp_coerce\n (copy_expression x0, map_option copy_core_type x1, copy_core_type x2)\n | Ast_410.Parsetree.Pexp_send (x0, x1) ->\n Ast_409.Parsetree.Pexp_send (copy_expression x0, copy_loc copy_label x1)\n | Ast_410.Parsetree.Pexp_new x0 ->\n Ast_409.Parsetree.Pexp_new (copy_loc copy_Longident_t x0)\n | Ast_410.Parsetree.Pexp_setinstvar (x0, x1) ->\n Ast_409.Parsetree.Pexp_setinstvar\n (copy_loc copy_label x0, copy_expression x1)\n | Ast_410.Parsetree.Pexp_override x0 ->\n Ast_409.Parsetree.Pexp_override\n (List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_label x0, copy_expression x1))\n x0)\n | Ast_410.Parsetree.Pexp_letmodule (x0, x1, x2) ->\n Ast_409.Parsetree.Pexp_letmodule\n ( copy_loc\n (function\n | None -> migration_error x0.loc \"anonymous let module\"\n | Some x -> x)\n x0,\n copy_module_expr x1,\n copy_expression x2 )\n | Ast_410.Parsetree.Pexp_letexception (x0, x1) ->\n Ast_409.Parsetree.Pexp_letexception\n (copy_extension_constructor x0, copy_expression x1)\n | Ast_410.Parsetree.Pexp_assert x0 ->\n Ast_409.Parsetree.Pexp_assert (copy_expression x0)\n | Ast_410.Parsetree.Pexp_lazy x0 ->\n Ast_409.Parsetree.Pexp_lazy (copy_expression x0)\n | Ast_410.Parsetree.Pexp_poly (x0, x1) ->\n Ast_409.Parsetree.Pexp_poly\n (copy_expression x0, map_option copy_core_type x1)\n | Ast_410.Parsetree.Pexp_object x0 ->\n Ast_409.Parsetree.Pexp_object (copy_class_structure x0)\n | Ast_410.Parsetree.Pexp_newtype (x0, x1) ->\n Ast_409.Parsetree.Pexp_newtype\n (copy_loc (fun x -> x) x0, copy_expression x1)\n | Ast_410.Parsetree.Pexp_pack x0 ->\n Ast_409.Parsetree.Pexp_pack (copy_module_expr x0)\n | Ast_410.Parsetree.Pexp_open (x0, x1) ->\n Ast_409.Parsetree.Pexp_open (copy_open_declaration x0, copy_expression x1)\n | Ast_410.Parsetree.Pexp_letop x0 ->\n Ast_409.Parsetree.Pexp_letop (copy_letop x0)\n | Ast_410.Parsetree.Pexp_extension x0 ->\n Ast_409.Parsetree.Pexp_extension (copy_extension x0)\n | Ast_410.Parsetree.Pexp_unreachable -> Ast_409.Parsetree.Pexp_unreachable\n\nand copy_letop : Ast_410.Parsetree.letop -> Ast_409.Parsetree.letop =\n fun { Ast_410.Parsetree.let_; Ast_410.Parsetree.ands; Ast_410.Parsetree.body } ->\n {\n Ast_409.Parsetree.let_ = copy_binding_op let_;\n Ast_409.Parsetree.ands = List.map copy_binding_op ands;\n Ast_409.Parsetree.body = copy_expression body;\n }\n\nand copy_binding_op :\n Ast_410.Parsetree.binding_op -> Ast_409.Parsetree.binding_op =\n fun {\n Ast_410.Parsetree.pbop_op;\n Ast_410.Parsetree.pbop_pat;\n Ast_410.Parsetree.pbop_exp;\n Ast_410.Parsetree.pbop_loc;\n } ->\n {\n Ast_409.Parsetree.pbop_op = copy_loc (fun x -> x) pbop_op;\n Ast_409.Parsetree.pbop_pat = copy_pattern pbop_pat;\n Ast_409.Parsetree.pbop_exp = copy_expression pbop_exp;\n Ast_409.Parsetree.pbop_loc = copy_location pbop_loc;\n }\n\nand copy_direction_flag :\n Ast_410.Asttypes.direction_flag -> Ast_409.Asttypes.direction_flag =\n function\n | Ast_410.Asttypes.Upto -> Ast_409.Asttypes.Upto\n | Ast_410.Asttypes.Downto -> Ast_409.Asttypes.Downto\n\nand copy_case : Ast_410.Parsetree.case -> Ast_409.Parsetree.case =\n fun {\n Ast_410.Parsetree.pc_lhs;\n Ast_410.Parsetree.pc_guard;\n Ast_410.Parsetree.pc_rhs;\n } ->\n {\n Ast_409.Parsetree.pc_lhs = copy_pattern pc_lhs;\n Ast_409.Parsetree.pc_guard = map_option copy_expression pc_guard;\n Ast_409.Parsetree.pc_rhs = copy_expression pc_rhs;\n }\n\nand copy_cases : Ast_410.Parsetree.case list -> Ast_409.Parsetree.cases =\n fun x -> List.map copy_case x\n\nand copy_value_binding :\n Ast_410.Parsetree.value_binding -> Ast_409.Parsetree.value_binding =\n fun {\n Ast_410.Parsetree.pvb_pat;\n Ast_410.Parsetree.pvb_expr;\n Ast_410.Parsetree.pvb_attributes;\n Ast_410.Parsetree.pvb_loc;\n } ->\n {\n Ast_409.Parsetree.pvb_pat = copy_pattern pvb_pat;\n Ast_409.Parsetree.pvb_expr = copy_expression pvb_expr;\n Ast_409.Parsetree.pvb_attributes = copy_attributes pvb_attributes;\n Ast_409.Parsetree.pvb_loc = copy_location pvb_loc;\n }\n\nand copy_pattern : Ast_410.Parsetree.pattern -> Ast_409.Parsetree.pattern =\n fun {\n Ast_410.Parsetree.ppat_desc;\n Ast_410.Parsetree.ppat_loc;\n Ast_410.Parsetree.ppat_loc_stack;\n Ast_410.Parsetree.ppat_attributes;\n } ->\n {\n Ast_409.Parsetree.ppat_desc = copy_pattern_desc ppat_desc;\n Ast_409.Parsetree.ppat_loc = copy_location ppat_loc;\n Ast_409.Parsetree.ppat_loc_stack = copy_location_stack ppat_loc_stack;\n Ast_409.Parsetree.ppat_attributes = copy_attributes ppat_attributes;\n }\n\nand copy_pattern_desc :\n Ast_410.Parsetree.pattern_desc -> Ast_409.Parsetree.pattern_desc = function\n | Ast_410.Parsetree.Ppat_any -> Ast_409.Parsetree.Ppat_any\n | Ast_410.Parsetree.Ppat_var x0 ->\n Ast_409.Parsetree.Ppat_var (copy_loc (fun x -> x) x0)\n | Ast_410.Parsetree.Ppat_alias (x0, x1) ->\n Ast_409.Parsetree.Ppat_alias (copy_pattern x0, copy_loc (fun x -> x) x1)\n | Ast_410.Parsetree.Ppat_constant x0 ->\n Ast_409.Parsetree.Ppat_constant (copy_constant x0)\n | Ast_410.Parsetree.Ppat_interval (x0, x1) ->\n Ast_409.Parsetree.Ppat_interval (copy_constant x0, copy_constant x1)\n | Ast_410.Parsetree.Ppat_tuple x0 ->\n Ast_409.Parsetree.Ppat_tuple (List.map copy_pattern x0)\n | Ast_410.Parsetree.Ppat_construct (x0, x1) ->\n Ast_409.Parsetree.Ppat_construct\n (copy_loc copy_Longident_t x0, map_option copy_pattern x1)\n | Ast_410.Parsetree.Ppat_variant (x0, x1) ->\n Ast_409.Parsetree.Ppat_variant (copy_label x0, map_option copy_pattern x1)\n | Ast_410.Parsetree.Ppat_record (x0, x1) ->\n Ast_409.Parsetree.Ppat_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_pattern x1))\n x0,\n copy_closed_flag x1 )\n | Ast_410.Parsetree.Ppat_array x0 ->\n Ast_409.Parsetree.Ppat_array (List.map copy_pattern x0)\n | Ast_410.Parsetree.Ppat_or (x0, x1) ->\n Ast_409.Parsetree.Ppat_or (copy_pattern x0, copy_pattern x1)\n | Ast_410.Parsetree.Ppat_constraint (x0, x1) ->\n Ast_409.Parsetree.Ppat_constraint (copy_pattern x0, copy_core_type x1)\n | Ast_410.Parsetree.Ppat_type x0 ->\n Ast_409.Parsetree.Ppat_type (copy_loc copy_Longident_t x0)\n | Ast_410.Parsetree.Ppat_lazy x0 ->\n Ast_409.Parsetree.Ppat_lazy (copy_pattern x0)\n | Ast_410.Parsetree.Ppat_unpack x0 ->\n Ast_409.Parsetree.Ppat_unpack\n (copy_loc\n (function\n | None -> migration_error x0.loc \"anynymous unpack\" | Some x -> x)\n x0)\n | Ast_410.Parsetree.Ppat_exception x0 ->\n Ast_409.Parsetree.Ppat_exception (copy_pattern x0)\n | Ast_410.Parsetree.Ppat_extension x0 ->\n Ast_409.Parsetree.Ppat_extension (copy_extension x0)\n | Ast_410.Parsetree.Ppat_open (x0, x1) ->\n Ast_409.Parsetree.Ppat_open (copy_loc copy_Longident_t x0, copy_pattern x1)\n\nand copy_core_type : Ast_410.Parsetree.core_type -> Ast_409.Parsetree.core_type\n =\n fun {\n Ast_410.Parsetree.ptyp_desc;\n Ast_410.Parsetree.ptyp_loc;\n Ast_410.Parsetree.ptyp_loc_stack;\n Ast_410.Parsetree.ptyp_attributes;\n } ->\n {\n Ast_409.Parsetree.ptyp_desc = copy_core_type_desc ptyp_desc;\n Ast_409.Parsetree.ptyp_loc = copy_location ptyp_loc;\n Ast_409.Parsetree.ptyp_loc_stack = copy_location_stack ptyp_loc_stack;\n Ast_409.Parsetree.ptyp_attributes = copy_attributes ptyp_attributes;\n }\n\nand copy_location_stack : Ast_410.Parsetree.location_stack -> Location.t list =\n fun x -> List.map copy_location x\n\nand copy_core_type_desc :\n Ast_410.Parsetree.core_type_desc -> Ast_409.Parsetree.core_type_desc =\n function\n | Ast_410.Parsetree.Ptyp_any -> Ast_409.Parsetree.Ptyp_any\n | Ast_410.Parsetree.Ptyp_var x0 -> Ast_409.Parsetree.Ptyp_var x0\n | Ast_410.Parsetree.Ptyp_arrow (x0, x1, x2) ->\n Ast_409.Parsetree.Ptyp_arrow\n (copy_arg_label x0, copy_core_type x1, copy_core_type x2)\n | Ast_410.Parsetree.Ptyp_tuple x0 ->\n Ast_409.Parsetree.Ptyp_tuple (List.map copy_core_type x0)\n | Ast_410.Parsetree.Ptyp_constr (x0, x1) ->\n Ast_409.Parsetree.Ptyp_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_410.Parsetree.Ptyp_object (x0, x1) ->\n Ast_409.Parsetree.Ptyp_object\n (List.map copy_object_field x0, copy_closed_flag x1)\n | Ast_410.Parsetree.Ptyp_class (x0, x1) ->\n Ast_409.Parsetree.Ptyp_class\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_410.Parsetree.Ptyp_alias (x0, x1) ->\n Ast_409.Parsetree.Ptyp_alias (copy_core_type x0, x1)\n | Ast_410.Parsetree.Ptyp_variant (x0, x1, x2) ->\n Ast_409.Parsetree.Ptyp_variant\n ( List.map copy_row_field x0,\n copy_closed_flag x1,\n map_option (fun x -> List.map copy_label x) x2 )\n | Ast_410.Parsetree.Ptyp_poly (x0, x1) ->\n Ast_409.Parsetree.Ptyp_poly\n (List.map (fun x -> copy_loc (fun x -> x) x) x0, copy_core_type x1)\n | Ast_410.Parsetree.Ptyp_package x0 ->\n Ast_409.Parsetree.Ptyp_package (copy_package_type x0)\n | Ast_410.Parsetree.Ptyp_extension x0 ->\n Ast_409.Parsetree.Ptyp_extension (copy_extension x0)\n\nand copy_package_type :\n Ast_410.Parsetree.package_type -> Ast_409.Parsetree.package_type =\n fun x ->\n let x0, x1 = x in\n ( copy_loc copy_Longident_t x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_core_type x1))\n x1 )\n\nand copy_row_field : Ast_410.Parsetree.row_field -> Ast_409.Parsetree.row_field\n =\n fun {\n Ast_410.Parsetree.prf_desc;\n Ast_410.Parsetree.prf_loc;\n Ast_410.Parsetree.prf_attributes;\n } ->\n {\n Ast_409.Parsetree.prf_desc = copy_row_field_desc prf_desc;\n Ast_409.Parsetree.prf_loc = copy_location prf_loc;\n Ast_409.Parsetree.prf_attributes = copy_attributes prf_attributes;\n }\n\nand copy_row_field_desc :\n Ast_410.Parsetree.row_field_desc -> Ast_409.Parsetree.row_field_desc =\n function\n | Ast_410.Parsetree.Rtag (x0, x1, x2) ->\n Ast_409.Parsetree.Rtag\n (copy_loc copy_label x0, x1, List.map copy_core_type x2)\n | Ast_410.Parsetree.Rinherit x0 ->\n Ast_409.Parsetree.Rinherit (copy_core_type x0)\n\nand copy_object_field :\n Ast_410.Parsetree.object_field -> Ast_409.Parsetree.object_field =\n fun {\n Ast_410.Parsetree.pof_desc;\n Ast_410.Parsetree.pof_loc;\n Ast_410.Parsetree.pof_attributes;\n } ->\n {\n Ast_409.Parsetree.pof_desc = copy_object_field_desc pof_desc;\n Ast_409.Parsetree.pof_loc = copy_location pof_loc;\n Ast_409.Parsetree.pof_attributes = copy_attributes pof_attributes;\n }\n\nand copy_attributes :\n Ast_410.Parsetree.attributes -> Ast_409.Parsetree.attributes =\n fun x -> List.map copy_attribute x\n\nand copy_attribute : Ast_410.Parsetree.attribute -> Ast_409.Parsetree.attribute\n =\n fun {\n Ast_410.Parsetree.attr_name;\n Ast_410.Parsetree.attr_payload;\n Ast_410.Parsetree.attr_loc;\n } ->\n {\n Ast_409.Parsetree.attr_name = copy_loc (fun x -> x) attr_name;\n Ast_409.Parsetree.attr_payload = copy_payload attr_payload;\n Ast_409.Parsetree.attr_loc = copy_location attr_loc;\n }\n\nand copy_payload : Ast_410.Parsetree.payload -> Ast_409.Parsetree.payload =\n function\n | Ast_410.Parsetree.PStr x0 -> Ast_409.Parsetree.PStr (copy_structure x0)\n | Ast_410.Parsetree.PSig x0 -> Ast_409.Parsetree.PSig (copy_signature x0)\n | Ast_410.Parsetree.PTyp x0 -> Ast_409.Parsetree.PTyp (copy_core_type x0)\n | Ast_410.Parsetree.PPat (x0, x1) ->\n Ast_409.Parsetree.PPat (copy_pattern x0, map_option copy_expression x1)\n\nand copy_structure : Ast_410.Parsetree.structure -> Ast_409.Parsetree.structure\n =\n fun x -> List.map copy_structure_item x\n\nand copy_structure_item :\n Ast_410.Parsetree.structure_item -> Ast_409.Parsetree.structure_item =\n fun { Ast_410.Parsetree.pstr_desc; Ast_410.Parsetree.pstr_loc } ->\n {\n Ast_409.Parsetree.pstr_desc = copy_structure_item_desc pstr_desc;\n Ast_409.Parsetree.pstr_loc = copy_location pstr_loc;\n }\n\nand copy_structure_item_desc :\n Ast_410.Parsetree.structure_item_desc ->\n Ast_409.Parsetree.structure_item_desc = function\n | Ast_410.Parsetree.Pstr_eval (x0, x1) ->\n Ast_409.Parsetree.Pstr_eval (copy_expression x0, copy_attributes x1)\n | Ast_410.Parsetree.Pstr_value (x0, x1) ->\n Ast_409.Parsetree.Pstr_value\n (copy_rec_flag x0, List.map copy_value_binding x1)\n | Ast_410.Parsetree.Pstr_primitive x0 ->\n Ast_409.Parsetree.Pstr_primitive (copy_value_description x0)\n | Ast_410.Parsetree.Pstr_type (x0, x1) ->\n Ast_409.Parsetree.Pstr_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | Ast_410.Parsetree.Pstr_typext x0 ->\n Ast_409.Parsetree.Pstr_typext (copy_type_extension x0)\n | Ast_410.Parsetree.Pstr_exception x0 ->\n Ast_409.Parsetree.Pstr_exception (copy_type_exception x0)\n | Ast_410.Parsetree.Pstr_module x0 ->\n Ast_409.Parsetree.Pstr_module (copy_module_binding x0)\n | Ast_410.Parsetree.Pstr_recmodule x0 ->\n Ast_409.Parsetree.Pstr_recmodule (List.map copy_module_binding x0)\n | Ast_410.Parsetree.Pstr_modtype x0 ->\n Ast_409.Parsetree.Pstr_modtype (copy_module_type_declaration x0)\n | Ast_410.Parsetree.Pstr_open x0 ->\n Ast_409.Parsetree.Pstr_open (copy_open_declaration x0)\n | Ast_410.Parsetree.Pstr_class x0 ->\n Ast_409.Parsetree.Pstr_class (List.map copy_class_declaration x0)\n | Ast_410.Parsetree.Pstr_class_type x0 ->\n Ast_409.Parsetree.Pstr_class_type\n (List.map copy_class_type_declaration x0)\n | Ast_410.Parsetree.Pstr_include x0 ->\n Ast_409.Parsetree.Pstr_include (copy_include_declaration x0)\n | Ast_410.Parsetree.Pstr_attribute x0 ->\n Ast_409.Parsetree.Pstr_attribute (copy_attribute x0)\n | Ast_410.Parsetree.Pstr_extension (x0, x1) ->\n Ast_409.Parsetree.Pstr_extension (copy_extension x0, copy_attributes x1)\n\nand copy_include_declaration :\n Ast_410.Parsetree.include_declaration ->\n Ast_409.Parsetree.include_declaration =\n fun x -> copy_include_infos copy_module_expr x\n\nand copy_class_declaration :\n Ast_410.Parsetree.class_declaration -> Ast_409.Parsetree.class_declaration =\n fun x -> copy_class_infos copy_class_expr x\n\nand copy_class_expr :\n Ast_410.Parsetree.class_expr -> Ast_409.Parsetree.class_expr =\n fun {\n Ast_410.Parsetree.pcl_desc;\n Ast_410.Parsetree.pcl_loc;\n Ast_410.Parsetree.pcl_attributes;\n } ->\n {\n Ast_409.Parsetree.pcl_desc = copy_class_expr_desc pcl_desc;\n Ast_409.Parsetree.pcl_loc = copy_location pcl_loc;\n Ast_409.Parsetree.pcl_attributes = copy_attributes pcl_attributes;\n }\n\nand copy_class_expr_desc :\n Ast_410.Parsetree.class_expr_desc -> Ast_409.Parsetree.class_expr_desc =\n function\n | Ast_410.Parsetree.Pcl_constr (x0, x1) ->\n Ast_409.Parsetree.Pcl_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_410.Parsetree.Pcl_structure x0 ->\n Ast_409.Parsetree.Pcl_structure (copy_class_structure x0)\n | Ast_410.Parsetree.Pcl_fun (x0, x1, x2, x3) ->\n Ast_409.Parsetree.Pcl_fun\n ( copy_arg_label x0,\n map_option copy_expression x1,\n copy_pattern x2,\n copy_class_expr x3 )\n | Ast_410.Parsetree.Pcl_apply (x0, x1) ->\n Ast_409.Parsetree.Pcl_apply\n ( copy_class_expr x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | Ast_410.Parsetree.Pcl_let (x0, x1, x2) ->\n Ast_409.Parsetree.Pcl_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_class_expr x2)\n | Ast_410.Parsetree.Pcl_constraint (x0, x1) ->\n Ast_409.Parsetree.Pcl_constraint (copy_class_expr x0, copy_class_type x1)\n | Ast_410.Parsetree.Pcl_extension x0 ->\n Ast_409.Parsetree.Pcl_extension (copy_extension x0)\n | Ast_410.Parsetree.Pcl_open (x0, x1) ->\n Ast_409.Parsetree.Pcl_open (copy_open_description x0, copy_class_expr x1)\n\nand copy_class_structure :\n Ast_410.Parsetree.class_structure -> Ast_409.Parsetree.class_structure =\n fun { Ast_410.Parsetree.pcstr_self; Ast_410.Parsetree.pcstr_fields } ->\n {\n Ast_409.Parsetree.pcstr_self = copy_pattern pcstr_self;\n Ast_409.Parsetree.pcstr_fields = List.map copy_class_field pcstr_fields;\n }\n\nand copy_class_field :\n Ast_410.Parsetree.class_field -> Ast_409.Parsetree.class_field =\n fun {\n Ast_410.Parsetree.pcf_desc;\n Ast_410.Parsetree.pcf_loc;\n Ast_410.Parsetree.pcf_attributes;\n } ->\n {\n Ast_409.Parsetree.pcf_desc = copy_class_field_desc pcf_desc;\n Ast_409.Parsetree.pcf_loc = copy_location pcf_loc;\n Ast_409.Parsetree.pcf_attributes = copy_attributes pcf_attributes;\n }\n\nand copy_class_field_desc :\n Ast_410.Parsetree.class_field_desc -> Ast_409.Parsetree.class_field_desc =\n function\n | Ast_410.Parsetree.Pcf_inherit (x0, x1, x2) ->\n Ast_409.Parsetree.Pcf_inherit\n ( copy_override_flag x0,\n copy_class_expr x1,\n map_option (fun x -> copy_loc (fun x -> x) x) x2 )\n | Ast_410.Parsetree.Pcf_val x0 ->\n Ast_409.Parsetree.Pcf_val\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_mutable_flag x1, copy_class_field_kind x2))\n | Ast_410.Parsetree.Pcf_method x0 ->\n Ast_409.Parsetree.Pcf_method\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_private_flag x1, copy_class_field_kind x2))\n | Ast_410.Parsetree.Pcf_constraint x0 ->\n Ast_409.Parsetree.Pcf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | Ast_410.Parsetree.Pcf_initializer x0 ->\n Ast_409.Parsetree.Pcf_initializer (copy_expression x0)\n | Ast_410.Parsetree.Pcf_attribute x0 ->\n Ast_409.Parsetree.Pcf_attribute (copy_attribute x0)\n | Ast_410.Parsetree.Pcf_extension x0 ->\n Ast_409.Parsetree.Pcf_extension (copy_extension x0)\n\nand copy_class_field_kind :\n Ast_410.Parsetree.class_field_kind -> Ast_409.Parsetree.class_field_kind =\n function\n | Ast_410.Parsetree.Cfk_virtual x0 ->\n Ast_409.Parsetree.Cfk_virtual (copy_core_type x0)\n | Ast_410.Parsetree.Cfk_concrete (x0, x1) ->\n Ast_409.Parsetree.Cfk_concrete (copy_override_flag x0, copy_expression x1)\n\nand copy_open_declaration :\n Ast_410.Parsetree.open_declaration -> Ast_409.Parsetree.open_declaration =\n fun x -> copy_open_infos copy_module_expr x\n\nand copy_module_binding :\n Ast_410.Parsetree.module_binding -> Ast_409.Parsetree.module_binding =\n fun {\n Ast_410.Parsetree.pmb_name;\n Ast_410.Parsetree.pmb_expr;\n Ast_410.Parsetree.pmb_attributes;\n Ast_410.Parsetree.pmb_loc;\n } ->\n {\n Ast_409.Parsetree.pmb_name =\n copy_loc\n (function\n | Some x -> x\n | None -> migration_error pmb_name.loc \"anonymous module binding\")\n pmb_name;\n Ast_409.Parsetree.pmb_expr = copy_module_expr pmb_expr;\n Ast_409.Parsetree.pmb_attributes = copy_attributes pmb_attributes;\n Ast_409.Parsetree.pmb_loc = copy_location pmb_loc;\n }\n\nand copy_module_expr :\n Ast_410.Parsetree.module_expr -> Ast_409.Parsetree.module_expr =\n fun {\n Ast_410.Parsetree.pmod_desc;\n Ast_410.Parsetree.pmod_loc;\n Ast_410.Parsetree.pmod_attributes;\n } ->\n {\n Ast_409.Parsetree.pmod_desc = copy_module_expr_desc pmod_desc;\n Ast_409.Parsetree.pmod_loc = copy_location pmod_loc;\n Ast_409.Parsetree.pmod_attributes = copy_attributes pmod_attributes;\n }\n\nand copy_module_expr_desc :\n Ast_410.Parsetree.module_expr_desc -> Ast_409.Parsetree.module_expr_desc =\n function\n | Ast_410.Parsetree.Pmod_ident x0 ->\n Ast_409.Parsetree.Pmod_ident (copy_loc copy_Longident_t x0)\n | Ast_410.Parsetree.Pmod_structure x0 ->\n Ast_409.Parsetree.Pmod_structure (copy_structure x0)\n | Ast_410.Parsetree.Pmod_functor (x0, x1) ->\n let x, y = copy_functor_parameter x0 in\n Ast_409.Parsetree.Pmod_functor (x, y, copy_module_expr x1)\n | Ast_410.Parsetree.Pmod_apply (x0, x1) ->\n Ast_409.Parsetree.Pmod_apply (copy_module_expr x0, copy_module_expr x1)\n | Ast_410.Parsetree.Pmod_constraint (x0, x1) ->\n Ast_409.Parsetree.Pmod_constraint\n (copy_module_expr x0, copy_module_type x1)\n | Ast_410.Parsetree.Pmod_unpack x0 ->\n Ast_409.Parsetree.Pmod_unpack (copy_expression x0)\n | Ast_410.Parsetree.Pmod_extension x0 ->\n Ast_409.Parsetree.Pmod_extension (copy_extension x0)\n\nand copy_functor_parameter :\n Ast_410.Parsetree.functor_parameter ->\n string Ast_409.Asttypes.loc * Ast_409.Parsetree.module_type option =\n function\n | Ast_410.Parsetree.Unit -> ({ loc = Location.none; txt = \"*\" }, None)\n | Ast_410.Parsetree.Named (x0, x1) ->\n ( copy_loc (function None -> \"_\" | Some x -> x) x0,\n Some (copy_module_type x1) )\n\nand copy_module_type :\n Ast_410.Parsetree.module_type -> Ast_409.Parsetree.module_type =\n fun {\n Ast_410.Parsetree.pmty_desc;\n Ast_410.Parsetree.pmty_loc;\n Ast_410.Parsetree.pmty_attributes;\n } ->\n {\n Ast_409.Parsetree.pmty_desc = copy_module_type_desc pmty_desc;\n Ast_409.Parsetree.pmty_loc = copy_location pmty_loc;\n Ast_409.Parsetree.pmty_attributes = copy_attributes pmty_attributes;\n }\n\nand copy_module_type_desc :\n Ast_410.Parsetree.module_type_desc -> Ast_409.Parsetree.module_type_desc =\n function\n | Ast_410.Parsetree.Pmty_ident x0 ->\n Ast_409.Parsetree.Pmty_ident (copy_loc copy_Longident_t x0)\n | Ast_410.Parsetree.Pmty_signature x0 ->\n Ast_409.Parsetree.Pmty_signature (copy_signature x0)\n | Ast_410.Parsetree.Pmty_functor (x0, x1) ->\n let x, y = copy_functor_parameter x0 in\n Ast_409.Parsetree.Pmty_functor (x, y, copy_module_type x1)\n | Ast_410.Parsetree.Pmty_with (x0, x1) ->\n Ast_409.Parsetree.Pmty_with\n (copy_module_type x0, List.map copy_with_constraint x1)\n | Ast_410.Parsetree.Pmty_typeof x0 ->\n Ast_409.Parsetree.Pmty_typeof (copy_module_expr x0)\n | Ast_410.Parsetree.Pmty_extension x0 ->\n Ast_409.Parsetree.Pmty_extension (copy_extension x0)\n | Ast_410.Parsetree.Pmty_alias x0 ->\n Ast_409.Parsetree.Pmty_alias (copy_loc copy_Longident_t x0)\n\nand copy_with_constraint :\n Ast_410.Parsetree.with_constraint -> Ast_409.Parsetree.with_constraint =\n function\n | Ast_410.Parsetree.Pwith_type (x0, x1) ->\n Ast_409.Parsetree.Pwith_type\n (copy_loc copy_Longident_t x0, copy_type_declaration x1)\n | Ast_410.Parsetree.Pwith_module (x0, x1) ->\n Ast_409.Parsetree.Pwith_module\n (copy_loc copy_Longident_t x0, copy_loc copy_Longident_t x1)\n | Ast_410.Parsetree.Pwith_typesubst (x0, x1) ->\n Ast_409.Parsetree.Pwith_typesubst\n (copy_loc copy_Longident_t x0, copy_type_declaration x1)\n | Ast_410.Parsetree.Pwith_modsubst (x0, x1) ->\n Ast_409.Parsetree.Pwith_modsubst\n (copy_loc copy_Longident_t x0, copy_loc copy_Longident_t x1)\n\nand copy_signature : Ast_410.Parsetree.signature -> Ast_409.Parsetree.signature\n =\n fun x -> List.map copy_signature_item x\n\nand copy_signature_item :\n Ast_410.Parsetree.signature_item -> Ast_409.Parsetree.signature_item =\n fun { Ast_410.Parsetree.psig_desc; Ast_410.Parsetree.psig_loc } ->\n {\n Ast_409.Parsetree.psig_desc = copy_signature_item_desc psig_desc;\n Ast_409.Parsetree.psig_loc = copy_location psig_loc;\n }\n\nand copy_signature_item_desc :\n Ast_410.Parsetree.signature_item_desc ->\n Ast_409.Parsetree.signature_item_desc = function\n | Ast_410.Parsetree.Psig_value x0 ->\n Ast_409.Parsetree.Psig_value (copy_value_description x0)\n | Ast_410.Parsetree.Psig_type (x0, x1) ->\n Ast_409.Parsetree.Psig_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | Ast_410.Parsetree.Psig_typesubst x0 ->\n Ast_409.Parsetree.Psig_typesubst (List.map copy_type_declaration x0)\n | Ast_410.Parsetree.Psig_typext x0 ->\n Ast_409.Parsetree.Psig_typext (copy_type_extension x0)\n | Ast_410.Parsetree.Psig_exception x0 ->\n Ast_409.Parsetree.Psig_exception (copy_type_exception x0)\n | Ast_410.Parsetree.Psig_module x0 ->\n Ast_409.Parsetree.Psig_module (copy_module_declaration x0)\n | Ast_410.Parsetree.Psig_modsubst x0 ->\n Ast_409.Parsetree.Psig_modsubst (copy_module_substitution x0)\n | Ast_410.Parsetree.Psig_recmodule x0 ->\n Ast_409.Parsetree.Psig_recmodule (List.map copy_module_declaration x0)\n | Ast_410.Parsetree.Psig_modtype x0 ->\n Ast_409.Parsetree.Psig_modtype (copy_module_type_declaration x0)\n | Ast_410.Parsetree.Psig_open x0 ->\n Ast_409.Parsetree.Psig_open (copy_open_description x0)\n | Ast_410.Parsetree.Psig_include x0 ->\n Ast_409.Parsetree.Psig_include (copy_include_description x0)\n | Ast_410.Parsetree.Psig_class x0 ->\n Ast_409.Parsetree.Psig_class (List.map copy_class_description x0)\n | Ast_410.Parsetree.Psig_class_type x0 ->\n Ast_409.Parsetree.Psig_class_type\n (List.map copy_class_type_declaration x0)\n | Ast_410.Parsetree.Psig_attribute x0 ->\n Ast_409.Parsetree.Psig_attribute (copy_attribute x0)\n | Ast_410.Parsetree.Psig_extension (x0, x1) ->\n Ast_409.Parsetree.Psig_extension (copy_extension x0, copy_attributes x1)\n\nand copy_class_type_declaration :\n Ast_410.Parsetree.class_type_declaration ->\n Ast_409.Parsetree.class_type_declaration =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_description :\n Ast_410.Parsetree.class_description -> Ast_409.Parsetree.class_description =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_type :\n Ast_410.Parsetree.class_type -> Ast_409.Parsetree.class_type =\n fun {\n Ast_410.Parsetree.pcty_desc;\n Ast_410.Parsetree.pcty_loc;\n Ast_410.Parsetree.pcty_attributes;\n } ->\n {\n Ast_409.Parsetree.pcty_desc = copy_class_type_desc pcty_desc;\n Ast_409.Parsetree.pcty_loc = copy_location pcty_loc;\n Ast_409.Parsetree.pcty_attributes = copy_attributes pcty_attributes;\n }\n\nand copy_class_type_desc :\n Ast_410.Parsetree.class_type_desc -> Ast_409.Parsetree.class_type_desc =\n function\n | Ast_410.Parsetree.Pcty_constr (x0, x1) ->\n Ast_409.Parsetree.Pcty_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_410.Parsetree.Pcty_signature x0 ->\n Ast_409.Parsetree.Pcty_signature (copy_class_signature x0)\n | Ast_410.Parsetree.Pcty_arrow (x0, x1, x2) ->\n Ast_409.Parsetree.Pcty_arrow\n (copy_arg_label x0, copy_core_type x1, copy_class_type x2)\n | Ast_410.Parsetree.Pcty_extension x0 ->\n Ast_409.Parsetree.Pcty_extension (copy_extension x0)\n | Ast_410.Parsetree.Pcty_open (x0, x1) ->\n Ast_409.Parsetree.Pcty_open (copy_open_description x0, copy_class_type x1)\n\nand copy_class_signature :\n Ast_410.Parsetree.class_signature -> Ast_409.Parsetree.class_signature =\n fun { Ast_410.Parsetree.pcsig_self; Ast_410.Parsetree.pcsig_fields } ->\n {\n Ast_409.Parsetree.pcsig_self = copy_core_type pcsig_self;\n Ast_409.Parsetree.pcsig_fields = List.map copy_class_type_field pcsig_fields;\n }\n\nand copy_class_type_field :\n Ast_410.Parsetree.class_type_field -> Ast_409.Parsetree.class_type_field =\n fun {\n Ast_410.Parsetree.pctf_desc;\n Ast_410.Parsetree.pctf_loc;\n Ast_410.Parsetree.pctf_attributes;\n } ->\n {\n Ast_409.Parsetree.pctf_desc = copy_class_type_field_desc pctf_desc;\n Ast_409.Parsetree.pctf_loc = copy_location pctf_loc;\n Ast_409.Parsetree.pctf_attributes = copy_attributes pctf_attributes;\n }\n\nand copy_class_type_field_desc :\n Ast_410.Parsetree.class_type_field_desc ->\n Ast_409.Parsetree.class_type_field_desc = function\n | Ast_410.Parsetree.Pctf_inherit x0 ->\n Ast_409.Parsetree.Pctf_inherit (copy_class_type x0)\n | Ast_410.Parsetree.Pctf_val x0 ->\n Ast_409.Parsetree.Pctf_val\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_mutable_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | Ast_410.Parsetree.Pctf_method x0 ->\n Ast_409.Parsetree.Pctf_method\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_private_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | Ast_410.Parsetree.Pctf_constraint x0 ->\n Ast_409.Parsetree.Pctf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | Ast_410.Parsetree.Pctf_attribute x0 ->\n Ast_409.Parsetree.Pctf_attribute (copy_attribute x0)\n | Ast_410.Parsetree.Pctf_extension x0 ->\n Ast_409.Parsetree.Pctf_extension (copy_extension x0)\n\nand copy_extension : Ast_410.Parsetree.extension -> Ast_409.Parsetree.extension\n =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_class_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_410.Parsetree.class_infos ->\n 'g0 Ast_409.Parsetree.class_infos =\n fun f0\n {\n Ast_410.Parsetree.pci_virt;\n Ast_410.Parsetree.pci_params;\n Ast_410.Parsetree.pci_name;\n Ast_410.Parsetree.pci_expr;\n Ast_410.Parsetree.pci_loc;\n Ast_410.Parsetree.pci_attributes;\n } ->\n {\n Ast_409.Parsetree.pci_virt = copy_virtual_flag pci_virt;\n Ast_409.Parsetree.pci_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n pci_params;\n Ast_409.Parsetree.pci_name = copy_loc (fun x -> x) pci_name;\n Ast_409.Parsetree.pci_expr = f0 pci_expr;\n Ast_409.Parsetree.pci_loc = copy_location pci_loc;\n Ast_409.Parsetree.pci_attributes = copy_attributes pci_attributes;\n }\n\nand copy_virtual_flag :\n Ast_410.Asttypes.virtual_flag -> Ast_409.Asttypes.virtual_flag = function\n | Ast_410.Asttypes.Virtual -> Ast_409.Asttypes.Virtual\n | Ast_410.Asttypes.Concrete -> Ast_409.Asttypes.Concrete\n\nand copy_include_description :\n Ast_410.Parsetree.include_description ->\n Ast_409.Parsetree.include_description =\n fun x -> copy_include_infos copy_module_type x\n\nand copy_include_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_410.Parsetree.include_infos ->\n 'g0 Ast_409.Parsetree.include_infos =\n fun f0\n {\n Ast_410.Parsetree.pincl_mod;\n Ast_410.Parsetree.pincl_loc;\n Ast_410.Parsetree.pincl_attributes;\n } ->\n {\n Ast_409.Parsetree.pincl_mod = f0 pincl_mod;\n Ast_409.Parsetree.pincl_loc = copy_location pincl_loc;\n Ast_409.Parsetree.pincl_attributes = copy_attributes pincl_attributes;\n }\n\nand copy_open_description :\n Ast_410.Parsetree.open_description -> Ast_409.Parsetree.open_description =\n fun x -> copy_open_infos (fun x -> copy_loc copy_Longident_t x) x\n\nand copy_open_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_410.Parsetree.open_infos ->\n 'g0 Ast_409.Parsetree.open_infos =\n fun f0\n {\n Ast_410.Parsetree.popen_expr;\n Ast_410.Parsetree.popen_override;\n Ast_410.Parsetree.popen_loc;\n Ast_410.Parsetree.popen_attributes;\n } ->\n {\n Ast_409.Parsetree.popen_expr = f0 popen_expr;\n Ast_409.Parsetree.popen_override = copy_override_flag popen_override;\n Ast_409.Parsetree.popen_loc = copy_location popen_loc;\n Ast_409.Parsetree.popen_attributes = copy_attributes popen_attributes;\n }\n\nand copy_override_flag :\n Ast_410.Asttypes.override_flag -> Ast_409.Asttypes.override_flag = function\n | Ast_410.Asttypes.Override -> Ast_409.Asttypes.Override\n | Ast_410.Asttypes.Fresh -> Ast_409.Asttypes.Fresh\n\nand copy_module_type_declaration :\n Ast_410.Parsetree.module_type_declaration ->\n Ast_409.Parsetree.module_type_declaration =\n fun {\n Ast_410.Parsetree.pmtd_name;\n Ast_410.Parsetree.pmtd_type;\n Ast_410.Parsetree.pmtd_attributes;\n Ast_410.Parsetree.pmtd_loc;\n } ->\n {\n Ast_409.Parsetree.pmtd_name = copy_loc (fun x -> x) pmtd_name;\n Ast_409.Parsetree.pmtd_type = map_option copy_module_type pmtd_type;\n Ast_409.Parsetree.pmtd_attributes = copy_attributes pmtd_attributes;\n Ast_409.Parsetree.pmtd_loc = copy_location pmtd_loc;\n }\n\nand copy_module_substitution :\n Ast_410.Parsetree.module_substitution ->\n Ast_409.Parsetree.module_substitution =\n fun {\n Ast_410.Parsetree.pms_name;\n Ast_410.Parsetree.pms_manifest;\n Ast_410.Parsetree.pms_attributes;\n Ast_410.Parsetree.pms_loc;\n } ->\n {\n Ast_409.Parsetree.pms_name = copy_loc (fun x -> x) pms_name;\n Ast_409.Parsetree.pms_manifest = copy_loc copy_Longident_t pms_manifest;\n Ast_409.Parsetree.pms_attributes = copy_attributes pms_attributes;\n Ast_409.Parsetree.pms_loc = copy_location pms_loc;\n }\n\nand copy_module_declaration :\n Ast_410.Parsetree.module_declaration -> Ast_409.Parsetree.module_declaration\n =\n fun {\n Ast_410.Parsetree.pmd_name;\n Ast_410.Parsetree.pmd_type;\n Ast_410.Parsetree.pmd_attributes;\n Ast_410.Parsetree.pmd_loc;\n } ->\n {\n Ast_409.Parsetree.pmd_name =\n copy_loc\n (function\n | None -> migration_error pmd_name.loc \"anonymous module declaration\"\n | Some x -> x)\n pmd_name;\n Ast_409.Parsetree.pmd_type = copy_module_type pmd_type;\n Ast_409.Parsetree.pmd_attributes = copy_attributes pmd_attributes;\n Ast_409.Parsetree.pmd_loc = copy_location pmd_loc;\n }\n\nand copy_type_exception :\n Ast_410.Parsetree.type_exception -> Ast_409.Parsetree.type_exception =\n fun {\n Ast_410.Parsetree.ptyexn_constructor;\n Ast_410.Parsetree.ptyexn_loc;\n Ast_410.Parsetree.ptyexn_attributes;\n } ->\n {\n Ast_409.Parsetree.ptyexn_constructor =\n copy_extension_constructor ptyexn_constructor;\n Ast_409.Parsetree.ptyexn_loc = copy_location ptyexn_loc;\n Ast_409.Parsetree.ptyexn_attributes = copy_attributes ptyexn_attributes;\n }\n\nand copy_type_extension :\n Ast_410.Parsetree.type_extension -> Ast_409.Parsetree.type_extension =\n fun {\n Ast_410.Parsetree.ptyext_path;\n Ast_410.Parsetree.ptyext_params;\n Ast_410.Parsetree.ptyext_constructors;\n Ast_410.Parsetree.ptyext_private;\n Ast_410.Parsetree.ptyext_loc;\n Ast_410.Parsetree.ptyext_attributes;\n } ->\n {\n Ast_409.Parsetree.ptyext_path = copy_loc copy_Longident_t ptyext_path;\n Ast_409.Parsetree.ptyext_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptyext_params;\n Ast_409.Parsetree.ptyext_constructors =\n List.map copy_extension_constructor ptyext_constructors;\n Ast_409.Parsetree.ptyext_private = copy_private_flag ptyext_private;\n Ast_409.Parsetree.ptyext_loc = copy_location ptyext_loc;\n Ast_409.Parsetree.ptyext_attributes = copy_attributes ptyext_attributes;\n }\n\nand copy_extension_constructor :\n Ast_410.Parsetree.extension_constructor ->\n Ast_409.Parsetree.extension_constructor =\n fun {\n Ast_410.Parsetree.pext_name;\n Ast_410.Parsetree.pext_kind;\n Ast_410.Parsetree.pext_loc;\n Ast_410.Parsetree.pext_attributes;\n } ->\n {\n Ast_409.Parsetree.pext_name = copy_loc (fun x -> x) pext_name;\n Ast_409.Parsetree.pext_kind = copy_extension_constructor_kind pext_kind;\n Ast_409.Parsetree.pext_loc = copy_location pext_loc;\n Ast_409.Parsetree.pext_attributes = copy_attributes pext_attributes;\n }\n\nand copy_extension_constructor_kind :\n Ast_410.Parsetree.extension_constructor_kind ->\n Ast_409.Parsetree.extension_constructor_kind = function\n | Ast_410.Parsetree.Pext_decl (x0, x1) ->\n Ast_409.Parsetree.Pext_decl\n (copy_constructor_arguments x0, map_option copy_core_type x1)\n | Ast_410.Parsetree.Pext_rebind x0 ->\n Ast_409.Parsetree.Pext_rebind (copy_loc copy_Longident_t x0)\n\nand copy_type_declaration :\n Ast_410.Parsetree.type_declaration -> Ast_409.Parsetree.type_declaration =\n fun {\n Ast_410.Parsetree.ptype_name;\n Ast_410.Parsetree.ptype_params;\n Ast_410.Parsetree.ptype_cstrs;\n Ast_410.Parsetree.ptype_kind;\n Ast_410.Parsetree.ptype_private;\n Ast_410.Parsetree.ptype_manifest;\n Ast_410.Parsetree.ptype_attributes;\n Ast_410.Parsetree.ptype_loc;\n } ->\n {\n Ast_409.Parsetree.ptype_name = copy_loc (fun x -> x) ptype_name;\n Ast_409.Parsetree.ptype_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptype_params;\n Ast_409.Parsetree.ptype_cstrs =\n List.map\n (fun x ->\n let x0, x1, x2 = x in\n (copy_core_type x0, copy_core_type x1, copy_location x2))\n ptype_cstrs;\n Ast_409.Parsetree.ptype_kind = copy_type_kind ptype_kind;\n Ast_409.Parsetree.ptype_private = copy_private_flag ptype_private;\n Ast_409.Parsetree.ptype_manifest = map_option copy_core_type ptype_manifest;\n Ast_409.Parsetree.ptype_attributes = copy_attributes ptype_attributes;\n Ast_409.Parsetree.ptype_loc = copy_location ptype_loc;\n }\n\nand copy_private_flag :\n Ast_410.Asttypes.private_flag -> Ast_409.Asttypes.private_flag = function\n | Ast_410.Asttypes.Private -> Ast_409.Asttypes.Private\n | Ast_410.Asttypes.Public -> Ast_409.Asttypes.Public\n\nand copy_type_kind : Ast_410.Parsetree.type_kind -> Ast_409.Parsetree.type_kind\n = function\n | Ast_410.Parsetree.Ptype_abstract -> Ast_409.Parsetree.Ptype_abstract\n | Ast_410.Parsetree.Ptype_variant x0 ->\n Ast_409.Parsetree.Ptype_variant (List.map copy_constructor_declaration x0)\n | Ast_410.Parsetree.Ptype_record x0 ->\n Ast_409.Parsetree.Ptype_record (List.map copy_label_declaration x0)\n | Ast_410.Parsetree.Ptype_open -> Ast_409.Parsetree.Ptype_open\n\nand copy_constructor_declaration :\n Ast_410.Parsetree.constructor_declaration ->\n Ast_409.Parsetree.constructor_declaration =\n fun {\n Ast_410.Parsetree.pcd_name;\n Ast_410.Parsetree.pcd_args;\n Ast_410.Parsetree.pcd_res;\n Ast_410.Parsetree.pcd_loc;\n Ast_410.Parsetree.pcd_attributes;\n } ->\n {\n Ast_409.Parsetree.pcd_name = copy_loc (fun x -> x) pcd_name;\n Ast_409.Parsetree.pcd_args = copy_constructor_arguments pcd_args;\n Ast_409.Parsetree.pcd_res = map_option copy_core_type pcd_res;\n Ast_409.Parsetree.pcd_loc = copy_location pcd_loc;\n Ast_409.Parsetree.pcd_attributes = copy_attributes pcd_attributes;\n }\n\nand copy_constructor_arguments :\n Ast_410.Parsetree.constructor_arguments ->\n Ast_409.Parsetree.constructor_arguments = function\n | Ast_410.Parsetree.Pcstr_tuple x0 ->\n Ast_409.Parsetree.Pcstr_tuple (List.map copy_core_type x0)\n | Ast_410.Parsetree.Pcstr_record x0 ->\n Ast_409.Parsetree.Pcstr_record (List.map copy_label_declaration x0)\n\nand copy_label_declaration :\n Ast_410.Parsetree.label_declaration -> Ast_409.Parsetree.label_declaration =\n fun {\n Ast_410.Parsetree.pld_name;\n Ast_410.Parsetree.pld_mutable;\n Ast_410.Parsetree.pld_type;\n Ast_410.Parsetree.pld_loc;\n Ast_410.Parsetree.pld_attributes;\n } ->\n {\n Ast_409.Parsetree.pld_name = copy_loc (fun x -> x) pld_name;\n Ast_409.Parsetree.pld_mutable = copy_mutable_flag pld_mutable;\n Ast_409.Parsetree.pld_type = copy_core_type pld_type;\n Ast_409.Parsetree.pld_loc = copy_location pld_loc;\n Ast_409.Parsetree.pld_attributes = copy_attributes pld_attributes;\n }\n\nand copy_mutable_flag :\n Ast_410.Asttypes.mutable_flag -> Ast_409.Asttypes.mutable_flag = function\n | Ast_410.Asttypes.Immutable -> Ast_409.Asttypes.Immutable\n | Ast_410.Asttypes.Mutable -> Ast_409.Asttypes.Mutable\n\nand copy_variance : Ast_410.Asttypes.variance -> Ast_409.Asttypes.variance =\n function\n | Ast_410.Asttypes.Covariant -> Ast_409.Asttypes.Covariant\n | Ast_410.Asttypes.Contravariant -> Ast_409.Asttypes.Contravariant\n | Ast_410.Asttypes.Invariant -> Ast_409.Asttypes.Invariant\n\nand copy_value_description :\n Ast_410.Parsetree.value_description -> Ast_409.Parsetree.value_description =\n fun {\n Ast_410.Parsetree.pval_name;\n Ast_410.Parsetree.pval_type;\n Ast_410.Parsetree.pval_prim;\n Ast_410.Parsetree.pval_attributes;\n Ast_410.Parsetree.pval_loc;\n } ->\n {\n Ast_409.Parsetree.pval_name = copy_loc (fun x -> x) pval_name;\n Ast_409.Parsetree.pval_type = copy_core_type pval_type;\n Ast_409.Parsetree.pval_prim = List.map (fun x -> x) pval_prim;\n Ast_409.Parsetree.pval_attributes = copy_attributes pval_attributes;\n Ast_409.Parsetree.pval_loc = copy_location pval_loc;\n }\n\nand copy_object_field_desc :\n Ast_410.Parsetree.object_field_desc -> Ast_409.Parsetree.object_field_desc =\n function\n | Ast_410.Parsetree.Otag (x0, x1) ->\n Ast_409.Parsetree.Otag (copy_loc copy_label x0, copy_core_type x1)\n | Ast_410.Parsetree.Oinherit x0 ->\n Ast_409.Parsetree.Oinherit (copy_core_type x0)\n\nand copy_arg_label : Ast_410.Asttypes.arg_label -> Ast_409.Asttypes.arg_label =\n function\n | Ast_410.Asttypes.Nolabel -> Ast_409.Asttypes.Nolabel\n | Ast_410.Asttypes.Labelled x0 -> Ast_409.Asttypes.Labelled x0\n | Ast_410.Asttypes.Optional x0 -> Ast_409.Asttypes.Optional x0\n\nand copy_closed_flag :\n Ast_410.Asttypes.closed_flag -> Ast_409.Asttypes.closed_flag = function\n | Ast_410.Asttypes.Closed -> Ast_409.Asttypes.Closed\n | Ast_410.Asttypes.Open -> Ast_409.Asttypes.Open\n\nand copy_label : Ast_410.Asttypes.label -> Ast_409.Asttypes.label = fun x -> x\n\nand copy_rec_flag : Ast_410.Asttypes.rec_flag -> Ast_409.Asttypes.rec_flag =\n function\n | Ast_410.Asttypes.Nonrecursive -> Ast_409.Asttypes.Nonrecursive\n | Ast_410.Asttypes.Recursive -> Ast_409.Asttypes.Recursive\n\nand copy_constant : Ast_410.Parsetree.constant -> Ast_409.Parsetree.constant =\n function\n | Ast_410.Parsetree.Pconst_integer (x0, x1) ->\n Ast_409.Parsetree.Pconst_integer (x0, map_option (fun x -> x) x1)\n | Ast_410.Parsetree.Pconst_char x0 -> Ast_409.Parsetree.Pconst_char x0\n | Ast_410.Parsetree.Pconst_string (x0, x1) ->\n Ast_409.Parsetree.Pconst_string (x0, map_option (fun x -> x) x1)\n | Ast_410.Parsetree.Pconst_float (x0, x1) ->\n Ast_409.Parsetree.Pconst_float (x0, map_option (fun x -> x) x1)\n\nand copy_Longident_t : Longident.t -> Longident.t = fun x -> x\n\nand copy_loc :\n 'f0 'g0.\n ('f0 -> 'g0) -> 'f0 Ast_410.Asttypes.loc -> 'g0 Ast_409.Asttypes.loc =\n fun f0 { Ast_410.Asttypes.txt; Ast_410.Asttypes.loc } ->\n { Ast_409.Asttypes.txt = f0 txt; Ast_409.Asttypes.loc = copy_location loc }\n\nand copy_location : Location.t -> Location.t = fun x -> x\n\nlet copy_expr = copy_expression\nlet copy_pat = copy_pattern\nlet copy_typ = copy_core_type\n","module From = Ast_409\nmodule To = Ast_410\n\nlet map_option f x = match x with None -> None | Some x -> Some (f x)\n\nlet rec copy_toplevel_phrase :\n Ast_409.Parsetree.toplevel_phrase -> Ast_410.Parsetree.toplevel_phrase =\n function\n | Ast_409.Parsetree.Ptop_def x0 ->\n Ast_410.Parsetree.Ptop_def (copy_structure x0)\n | Ast_409.Parsetree.Ptop_dir x0 ->\n Ast_410.Parsetree.Ptop_dir (copy_toplevel_directive x0)\n\nand copy_toplevel_directive :\n Ast_409.Parsetree.toplevel_directive -> Ast_410.Parsetree.toplevel_directive\n =\n fun {\n Ast_409.Parsetree.pdir_name;\n Ast_409.Parsetree.pdir_arg;\n Ast_409.Parsetree.pdir_loc;\n } ->\n {\n Ast_410.Parsetree.pdir_name = copy_loc (fun x -> x) pdir_name;\n Ast_410.Parsetree.pdir_arg = map_option copy_directive_argument pdir_arg;\n Ast_410.Parsetree.pdir_loc = copy_location pdir_loc;\n }\n\nand copy_directive_argument :\n Ast_409.Parsetree.directive_argument -> Ast_410.Parsetree.directive_argument\n =\n fun { Ast_409.Parsetree.pdira_desc; Ast_409.Parsetree.pdira_loc } ->\n {\n Ast_410.Parsetree.pdira_desc = copy_directive_argument_desc pdira_desc;\n Ast_410.Parsetree.pdira_loc = copy_location pdira_loc;\n }\n\nand copy_directive_argument_desc :\n Ast_409.Parsetree.directive_argument_desc ->\n Ast_410.Parsetree.directive_argument_desc = function\n | Ast_409.Parsetree.Pdir_string x0 -> Ast_410.Parsetree.Pdir_string x0\n | Ast_409.Parsetree.Pdir_int (x0, x1) ->\n Ast_410.Parsetree.Pdir_int (x0, map_option (fun x -> x) x1)\n | Ast_409.Parsetree.Pdir_ident x0 ->\n Ast_410.Parsetree.Pdir_ident (copy_Longident_t x0)\n | Ast_409.Parsetree.Pdir_bool x0 -> Ast_410.Parsetree.Pdir_bool x0\n\nand copy_expression :\n Ast_409.Parsetree.expression -> Ast_410.Parsetree.expression =\n fun {\n Ast_409.Parsetree.pexp_desc;\n Ast_409.Parsetree.pexp_loc;\n Ast_409.Parsetree.pexp_loc_stack;\n Ast_409.Parsetree.pexp_attributes;\n } ->\n {\n Ast_410.Parsetree.pexp_desc = copy_expression_desc pexp_desc;\n Ast_410.Parsetree.pexp_loc = copy_location pexp_loc;\n Ast_410.Parsetree.pexp_loc_stack = List.map copy_location pexp_loc_stack;\n Ast_410.Parsetree.pexp_attributes = copy_attributes pexp_attributes;\n }\n\nand copy_expression_desc :\n Ast_409.Parsetree.expression_desc -> Ast_410.Parsetree.expression_desc =\n function\n | Ast_409.Parsetree.Pexp_ident x0 ->\n Ast_410.Parsetree.Pexp_ident (copy_loc copy_Longident_t x0)\n | Ast_409.Parsetree.Pexp_constant x0 ->\n Ast_410.Parsetree.Pexp_constant (copy_constant x0)\n | Ast_409.Parsetree.Pexp_let (x0, x1, x2) ->\n Ast_410.Parsetree.Pexp_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_expression x2)\n | Ast_409.Parsetree.Pexp_function x0 ->\n Ast_410.Parsetree.Pexp_function (copy_cases x0)\n | Ast_409.Parsetree.Pexp_fun (x0, x1, x2, x3) ->\n Ast_410.Parsetree.Pexp_fun\n ( copy_arg_label x0,\n map_option copy_expression x1,\n copy_pattern x2,\n copy_expression x3 )\n | Ast_409.Parsetree.Pexp_apply (x0, x1) ->\n Ast_410.Parsetree.Pexp_apply\n ( copy_expression x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | Ast_409.Parsetree.Pexp_match (x0, x1) ->\n Ast_410.Parsetree.Pexp_match (copy_expression x0, copy_cases x1)\n | Ast_409.Parsetree.Pexp_try (x0, x1) ->\n Ast_410.Parsetree.Pexp_try (copy_expression x0, copy_cases x1)\n | Ast_409.Parsetree.Pexp_tuple x0 ->\n Ast_410.Parsetree.Pexp_tuple (List.map copy_expression x0)\n | Ast_409.Parsetree.Pexp_construct (x0, x1) ->\n Ast_410.Parsetree.Pexp_construct\n (copy_loc copy_Longident_t x0, map_option copy_expression x1)\n | Ast_409.Parsetree.Pexp_variant (x0, x1) ->\n Ast_410.Parsetree.Pexp_variant\n (copy_label x0, map_option copy_expression x1)\n | Ast_409.Parsetree.Pexp_record (x0, x1) ->\n Ast_410.Parsetree.Pexp_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_expression x1))\n x0,\n map_option copy_expression x1 )\n | Ast_409.Parsetree.Pexp_field (x0, x1) ->\n Ast_410.Parsetree.Pexp_field\n (copy_expression x0, copy_loc copy_Longident_t x1)\n | Ast_409.Parsetree.Pexp_setfield (x0, x1, x2) ->\n Ast_410.Parsetree.Pexp_setfield\n (copy_expression x0, copy_loc copy_Longident_t x1, copy_expression x2)\n | Ast_409.Parsetree.Pexp_array x0 ->\n Ast_410.Parsetree.Pexp_array (List.map copy_expression x0)\n | Ast_409.Parsetree.Pexp_ifthenelse (x0, x1, x2) ->\n Ast_410.Parsetree.Pexp_ifthenelse\n (copy_expression x0, copy_expression x1, map_option copy_expression x2)\n | Ast_409.Parsetree.Pexp_sequence (x0, x1) ->\n Ast_410.Parsetree.Pexp_sequence (copy_expression x0, copy_expression x1)\n | Ast_409.Parsetree.Pexp_while (x0, x1) ->\n Ast_410.Parsetree.Pexp_while (copy_expression x0, copy_expression x1)\n | Ast_409.Parsetree.Pexp_for (x0, x1, x2, x3, x4) ->\n Ast_410.Parsetree.Pexp_for\n ( copy_pattern x0,\n copy_expression x1,\n copy_expression x2,\n copy_direction_flag x3,\n copy_expression x4 )\n | Ast_409.Parsetree.Pexp_constraint (x0, x1) ->\n Ast_410.Parsetree.Pexp_constraint (copy_expression x0, copy_core_type x1)\n | Ast_409.Parsetree.Pexp_coerce (x0, x1, x2) ->\n Ast_410.Parsetree.Pexp_coerce\n (copy_expression x0, map_option copy_core_type x1, copy_core_type x2)\n | Ast_409.Parsetree.Pexp_send (x0, x1) ->\n Ast_410.Parsetree.Pexp_send (copy_expression x0, copy_loc copy_label x1)\n | Ast_409.Parsetree.Pexp_new x0 ->\n Ast_410.Parsetree.Pexp_new (copy_loc copy_Longident_t x0)\n | Ast_409.Parsetree.Pexp_setinstvar (x0, x1) ->\n Ast_410.Parsetree.Pexp_setinstvar\n (copy_loc copy_label x0, copy_expression x1)\n | Ast_409.Parsetree.Pexp_override x0 ->\n Ast_410.Parsetree.Pexp_override\n (List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_label x0, copy_expression x1))\n x0)\n | Ast_409.Parsetree.Pexp_letmodule (x0, x1, x2) ->\n Ast_410.Parsetree.Pexp_letmodule\n (copy_loc (fun x -> Some x) x0, copy_module_expr x1, copy_expression x2)\n | Ast_409.Parsetree.Pexp_letexception (x0, x1) ->\n Ast_410.Parsetree.Pexp_letexception\n (copy_extension_constructor x0, copy_expression x1)\n | Ast_409.Parsetree.Pexp_assert x0 ->\n Ast_410.Parsetree.Pexp_assert (copy_expression x0)\n | Ast_409.Parsetree.Pexp_lazy x0 ->\n Ast_410.Parsetree.Pexp_lazy (copy_expression x0)\n | Ast_409.Parsetree.Pexp_poly (x0, x1) ->\n Ast_410.Parsetree.Pexp_poly\n (copy_expression x0, map_option copy_core_type x1)\n | Ast_409.Parsetree.Pexp_object x0 ->\n Ast_410.Parsetree.Pexp_object (copy_class_structure x0)\n | Ast_409.Parsetree.Pexp_newtype (x0, x1) ->\n Ast_410.Parsetree.Pexp_newtype\n (copy_loc (fun x -> x) x0, copy_expression x1)\n | Ast_409.Parsetree.Pexp_pack x0 ->\n Ast_410.Parsetree.Pexp_pack (copy_module_expr x0)\n | Ast_409.Parsetree.Pexp_open (x0, x1) ->\n Ast_410.Parsetree.Pexp_open (copy_open_declaration x0, copy_expression x1)\n | Ast_409.Parsetree.Pexp_letop x0 ->\n Ast_410.Parsetree.Pexp_letop (copy_letop x0)\n | Ast_409.Parsetree.Pexp_extension x0 ->\n Ast_410.Parsetree.Pexp_extension (copy_extension x0)\n | Ast_409.Parsetree.Pexp_unreachable -> Ast_410.Parsetree.Pexp_unreachable\n\nand copy_letop : Ast_409.Parsetree.letop -> Ast_410.Parsetree.letop =\n fun { Ast_409.Parsetree.let_; Ast_409.Parsetree.ands; Ast_409.Parsetree.body } ->\n {\n Ast_410.Parsetree.let_ = copy_binding_op let_;\n Ast_410.Parsetree.ands = List.map copy_binding_op ands;\n Ast_410.Parsetree.body = copy_expression body;\n }\n\nand copy_binding_op :\n Ast_409.Parsetree.binding_op -> Ast_410.Parsetree.binding_op =\n fun {\n Ast_409.Parsetree.pbop_op;\n Ast_409.Parsetree.pbop_pat;\n Ast_409.Parsetree.pbop_exp;\n Ast_409.Parsetree.pbop_loc;\n } ->\n {\n Ast_410.Parsetree.pbop_op = copy_loc (fun x -> x) pbop_op;\n Ast_410.Parsetree.pbop_pat = copy_pattern pbop_pat;\n Ast_410.Parsetree.pbop_exp = copy_expression pbop_exp;\n Ast_410.Parsetree.pbop_loc = copy_location pbop_loc;\n }\n\nand copy_direction_flag :\n Ast_409.Asttypes.direction_flag -> Ast_410.Asttypes.direction_flag =\n function\n | Ast_409.Asttypes.Upto -> Ast_410.Asttypes.Upto\n | Ast_409.Asttypes.Downto -> Ast_410.Asttypes.Downto\n\nand copy_cases : Ast_409.Parsetree.cases -> Ast_410.Parsetree.case list =\n fun x -> List.map copy_case x\n\nand copy_case : Ast_409.Parsetree.case -> Ast_410.Parsetree.case =\n fun {\n Ast_409.Parsetree.pc_lhs;\n Ast_409.Parsetree.pc_guard;\n Ast_409.Parsetree.pc_rhs;\n } ->\n {\n Ast_410.Parsetree.pc_lhs = copy_pattern pc_lhs;\n Ast_410.Parsetree.pc_guard = map_option copy_expression pc_guard;\n Ast_410.Parsetree.pc_rhs = copy_expression pc_rhs;\n }\n\nand copy_value_binding :\n Ast_409.Parsetree.value_binding -> Ast_410.Parsetree.value_binding =\n fun {\n Ast_409.Parsetree.pvb_pat;\n Ast_409.Parsetree.pvb_expr;\n Ast_409.Parsetree.pvb_attributes;\n Ast_409.Parsetree.pvb_loc;\n } ->\n {\n Ast_410.Parsetree.pvb_pat = copy_pattern pvb_pat;\n Ast_410.Parsetree.pvb_expr = copy_expression pvb_expr;\n Ast_410.Parsetree.pvb_attributes = copy_attributes pvb_attributes;\n Ast_410.Parsetree.pvb_loc = copy_location pvb_loc;\n }\n\nand copy_pattern : Ast_409.Parsetree.pattern -> Ast_410.Parsetree.pattern =\n fun {\n Ast_409.Parsetree.ppat_desc;\n Ast_409.Parsetree.ppat_loc;\n Ast_409.Parsetree.ppat_loc_stack;\n Ast_409.Parsetree.ppat_attributes;\n } ->\n {\n Ast_410.Parsetree.ppat_desc = copy_pattern_desc ppat_desc;\n Ast_410.Parsetree.ppat_loc = copy_location ppat_loc;\n Ast_410.Parsetree.ppat_loc_stack = List.map copy_location ppat_loc_stack;\n Ast_410.Parsetree.ppat_attributes = copy_attributes ppat_attributes;\n }\n\nand copy_pattern_desc :\n Ast_409.Parsetree.pattern_desc -> Ast_410.Parsetree.pattern_desc = function\n | Ast_409.Parsetree.Ppat_any -> Ast_410.Parsetree.Ppat_any\n | Ast_409.Parsetree.Ppat_var x0 ->\n Ast_410.Parsetree.Ppat_var (copy_loc (fun x -> x) x0)\n | Ast_409.Parsetree.Ppat_alias (x0, x1) ->\n Ast_410.Parsetree.Ppat_alias (copy_pattern x0, copy_loc (fun x -> x) x1)\n | Ast_409.Parsetree.Ppat_constant x0 ->\n Ast_410.Parsetree.Ppat_constant (copy_constant x0)\n | Ast_409.Parsetree.Ppat_interval (x0, x1) ->\n Ast_410.Parsetree.Ppat_interval (copy_constant x0, copy_constant x1)\n | Ast_409.Parsetree.Ppat_tuple x0 ->\n Ast_410.Parsetree.Ppat_tuple (List.map copy_pattern x0)\n | Ast_409.Parsetree.Ppat_construct (x0, x1) ->\n Ast_410.Parsetree.Ppat_construct\n (copy_loc copy_Longident_t x0, map_option copy_pattern x1)\n | Ast_409.Parsetree.Ppat_variant (x0, x1) ->\n Ast_410.Parsetree.Ppat_variant (copy_label x0, map_option copy_pattern x1)\n | Ast_409.Parsetree.Ppat_record (x0, x1) ->\n Ast_410.Parsetree.Ppat_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_pattern x1))\n x0,\n copy_closed_flag x1 )\n | Ast_409.Parsetree.Ppat_array x0 ->\n Ast_410.Parsetree.Ppat_array (List.map copy_pattern x0)\n | Ast_409.Parsetree.Ppat_or (x0, x1) ->\n Ast_410.Parsetree.Ppat_or (copy_pattern x0, copy_pattern x1)\n | Ast_409.Parsetree.Ppat_constraint (x0, x1) ->\n Ast_410.Parsetree.Ppat_constraint (copy_pattern x0, copy_core_type x1)\n | Ast_409.Parsetree.Ppat_type x0 ->\n Ast_410.Parsetree.Ppat_type (copy_loc copy_Longident_t x0)\n | Ast_409.Parsetree.Ppat_lazy x0 ->\n Ast_410.Parsetree.Ppat_lazy (copy_pattern x0)\n | Ast_409.Parsetree.Ppat_unpack x0 ->\n Ast_410.Parsetree.Ppat_unpack (copy_loc (fun x -> Some x) x0)\n | Ast_409.Parsetree.Ppat_exception x0 ->\n Ast_410.Parsetree.Ppat_exception (copy_pattern x0)\n | Ast_409.Parsetree.Ppat_extension x0 ->\n Ast_410.Parsetree.Ppat_extension (copy_extension x0)\n | Ast_409.Parsetree.Ppat_open (x0, x1) ->\n Ast_410.Parsetree.Ppat_open (copy_loc copy_Longident_t x0, copy_pattern x1)\n\nand copy_core_type : Ast_409.Parsetree.core_type -> Ast_410.Parsetree.core_type\n =\n fun {\n Ast_409.Parsetree.ptyp_desc;\n Ast_409.Parsetree.ptyp_loc;\n Ast_409.Parsetree.ptyp_loc_stack;\n Ast_409.Parsetree.ptyp_attributes;\n } ->\n {\n Ast_410.Parsetree.ptyp_desc = copy_core_type_desc ptyp_desc;\n Ast_410.Parsetree.ptyp_loc = copy_location ptyp_loc;\n Ast_410.Parsetree.ptyp_loc_stack = List.map copy_location ptyp_loc_stack;\n Ast_410.Parsetree.ptyp_attributes = copy_attributes ptyp_attributes;\n }\n\nand copy_core_type_desc :\n Ast_409.Parsetree.core_type_desc -> Ast_410.Parsetree.core_type_desc =\n function\n | Ast_409.Parsetree.Ptyp_any -> Ast_410.Parsetree.Ptyp_any\n | Ast_409.Parsetree.Ptyp_var x0 -> Ast_410.Parsetree.Ptyp_var x0\n | Ast_409.Parsetree.Ptyp_arrow (x0, x1, x2) ->\n Ast_410.Parsetree.Ptyp_arrow\n (copy_arg_label x0, copy_core_type x1, copy_core_type x2)\n | Ast_409.Parsetree.Ptyp_tuple x0 ->\n Ast_410.Parsetree.Ptyp_tuple (List.map copy_core_type x0)\n | Ast_409.Parsetree.Ptyp_constr (x0, x1) ->\n Ast_410.Parsetree.Ptyp_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_409.Parsetree.Ptyp_object (x0, x1) ->\n Ast_410.Parsetree.Ptyp_object\n (List.map copy_object_field x0, copy_closed_flag x1)\n | Ast_409.Parsetree.Ptyp_class (x0, x1) ->\n Ast_410.Parsetree.Ptyp_class\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_409.Parsetree.Ptyp_alias (x0, x1) ->\n Ast_410.Parsetree.Ptyp_alias (copy_core_type x0, x1)\n | Ast_409.Parsetree.Ptyp_variant (x0, x1, x2) ->\n Ast_410.Parsetree.Ptyp_variant\n ( List.map copy_row_field x0,\n copy_closed_flag x1,\n map_option (fun x -> List.map copy_label x) x2 )\n | Ast_409.Parsetree.Ptyp_poly (x0, x1) ->\n Ast_410.Parsetree.Ptyp_poly\n (List.map (fun x -> copy_loc (fun x -> x) x) x0, copy_core_type x1)\n | Ast_409.Parsetree.Ptyp_package x0 ->\n Ast_410.Parsetree.Ptyp_package (copy_package_type x0)\n | Ast_409.Parsetree.Ptyp_extension x0 ->\n Ast_410.Parsetree.Ptyp_extension (copy_extension x0)\n\nand copy_package_type :\n Ast_409.Parsetree.package_type -> Ast_410.Parsetree.package_type =\n fun x ->\n let x0, x1 = x in\n ( copy_loc copy_Longident_t x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_core_type x1))\n x1 )\n\nand copy_row_field : Ast_409.Parsetree.row_field -> Ast_410.Parsetree.row_field\n =\n fun {\n Ast_409.Parsetree.prf_desc;\n Ast_409.Parsetree.prf_loc;\n Ast_409.Parsetree.prf_attributes;\n } ->\n {\n Ast_410.Parsetree.prf_desc = copy_row_field_desc prf_desc;\n Ast_410.Parsetree.prf_loc = copy_location prf_loc;\n Ast_410.Parsetree.prf_attributes = copy_attributes prf_attributes;\n }\n\nand copy_row_field_desc :\n Ast_409.Parsetree.row_field_desc -> Ast_410.Parsetree.row_field_desc =\n function\n | Ast_409.Parsetree.Rtag (x0, x1, x2) ->\n Ast_410.Parsetree.Rtag\n (copy_loc copy_label x0, x1, List.map copy_core_type x2)\n | Ast_409.Parsetree.Rinherit x0 ->\n Ast_410.Parsetree.Rinherit (copy_core_type x0)\n\nand copy_object_field :\n Ast_409.Parsetree.object_field -> Ast_410.Parsetree.object_field =\n fun {\n Ast_409.Parsetree.pof_desc;\n Ast_409.Parsetree.pof_loc;\n Ast_409.Parsetree.pof_attributes;\n } ->\n {\n Ast_410.Parsetree.pof_desc = copy_object_field_desc pof_desc;\n Ast_410.Parsetree.pof_loc = copy_location pof_loc;\n Ast_410.Parsetree.pof_attributes = copy_attributes pof_attributes;\n }\n\nand copy_attributes :\n Ast_409.Parsetree.attributes -> Ast_410.Parsetree.attributes =\n fun x -> List.map copy_attribute x\n\nand copy_attribute : Ast_409.Parsetree.attribute -> Ast_410.Parsetree.attribute\n =\n fun {\n Ast_409.Parsetree.attr_name;\n Ast_409.Parsetree.attr_payload;\n Ast_409.Parsetree.attr_loc;\n } ->\n {\n Ast_410.Parsetree.attr_name = copy_loc (fun x -> x) attr_name;\n Ast_410.Parsetree.attr_payload = copy_payload attr_payload;\n Ast_410.Parsetree.attr_loc = copy_location attr_loc;\n }\n\nand copy_payload : Ast_409.Parsetree.payload -> Ast_410.Parsetree.payload =\n function\n | Ast_409.Parsetree.PStr x0 -> Ast_410.Parsetree.PStr (copy_structure x0)\n | Ast_409.Parsetree.PSig x0 -> Ast_410.Parsetree.PSig (copy_signature x0)\n | Ast_409.Parsetree.PTyp x0 -> Ast_410.Parsetree.PTyp (copy_core_type x0)\n | Ast_409.Parsetree.PPat (x0, x1) ->\n Ast_410.Parsetree.PPat (copy_pattern x0, map_option copy_expression x1)\n\nand copy_structure : Ast_409.Parsetree.structure -> Ast_410.Parsetree.structure\n =\n fun x -> List.map copy_structure_item x\n\nand copy_structure_item :\n Ast_409.Parsetree.structure_item -> Ast_410.Parsetree.structure_item =\n fun { Ast_409.Parsetree.pstr_desc; Ast_409.Parsetree.pstr_loc } ->\n {\n Ast_410.Parsetree.pstr_desc = copy_structure_item_desc pstr_desc;\n Ast_410.Parsetree.pstr_loc = copy_location pstr_loc;\n }\n\nand copy_structure_item_desc :\n Ast_409.Parsetree.structure_item_desc ->\n Ast_410.Parsetree.structure_item_desc = function\n | Ast_409.Parsetree.Pstr_eval (x0, x1) ->\n Ast_410.Parsetree.Pstr_eval (copy_expression x0, copy_attributes x1)\n | Ast_409.Parsetree.Pstr_value (x0, x1) ->\n Ast_410.Parsetree.Pstr_value\n (copy_rec_flag x0, List.map copy_value_binding x1)\n | Ast_409.Parsetree.Pstr_primitive x0 ->\n Ast_410.Parsetree.Pstr_primitive (copy_value_description x0)\n | Ast_409.Parsetree.Pstr_type (x0, x1) ->\n Ast_410.Parsetree.Pstr_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | Ast_409.Parsetree.Pstr_typext x0 ->\n Ast_410.Parsetree.Pstr_typext (copy_type_extension x0)\n | Ast_409.Parsetree.Pstr_exception x0 ->\n Ast_410.Parsetree.Pstr_exception (copy_type_exception x0)\n | Ast_409.Parsetree.Pstr_module x0 ->\n Ast_410.Parsetree.Pstr_module (copy_module_binding x0)\n | Ast_409.Parsetree.Pstr_recmodule x0 ->\n Ast_410.Parsetree.Pstr_recmodule (List.map copy_module_binding x0)\n | Ast_409.Parsetree.Pstr_modtype x0 ->\n Ast_410.Parsetree.Pstr_modtype (copy_module_type_declaration x0)\n | Ast_409.Parsetree.Pstr_open x0 ->\n Ast_410.Parsetree.Pstr_open (copy_open_declaration x0)\n | Ast_409.Parsetree.Pstr_class x0 ->\n Ast_410.Parsetree.Pstr_class (List.map copy_class_declaration x0)\n | Ast_409.Parsetree.Pstr_class_type x0 ->\n Ast_410.Parsetree.Pstr_class_type\n (List.map copy_class_type_declaration x0)\n | Ast_409.Parsetree.Pstr_include x0 ->\n Ast_410.Parsetree.Pstr_include (copy_include_declaration x0)\n | Ast_409.Parsetree.Pstr_attribute x0 ->\n Ast_410.Parsetree.Pstr_attribute (copy_attribute x0)\n | Ast_409.Parsetree.Pstr_extension (x0, x1) ->\n Ast_410.Parsetree.Pstr_extension (copy_extension x0, copy_attributes x1)\n\nand copy_include_declaration :\n Ast_409.Parsetree.include_declaration ->\n Ast_410.Parsetree.include_declaration =\n fun x -> copy_include_infos copy_module_expr x\n\nand copy_class_declaration :\n Ast_409.Parsetree.class_declaration -> Ast_410.Parsetree.class_declaration =\n fun x -> copy_class_infos copy_class_expr x\n\nand copy_class_expr :\n Ast_409.Parsetree.class_expr -> Ast_410.Parsetree.class_expr =\n fun {\n Ast_409.Parsetree.pcl_desc;\n Ast_409.Parsetree.pcl_loc;\n Ast_409.Parsetree.pcl_attributes;\n } ->\n {\n Ast_410.Parsetree.pcl_desc = copy_class_expr_desc pcl_desc;\n Ast_410.Parsetree.pcl_loc = copy_location pcl_loc;\n Ast_410.Parsetree.pcl_attributes = copy_attributes pcl_attributes;\n }\n\nand copy_class_expr_desc :\n Ast_409.Parsetree.class_expr_desc -> Ast_410.Parsetree.class_expr_desc =\n function\n | Ast_409.Parsetree.Pcl_constr (x0, x1) ->\n Ast_410.Parsetree.Pcl_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_409.Parsetree.Pcl_structure x0 ->\n Ast_410.Parsetree.Pcl_structure (copy_class_structure x0)\n | Ast_409.Parsetree.Pcl_fun (x0, x1, x2, x3) ->\n Ast_410.Parsetree.Pcl_fun\n ( copy_arg_label x0,\n map_option copy_expression x1,\n copy_pattern x2,\n copy_class_expr x3 )\n | Ast_409.Parsetree.Pcl_apply (x0, x1) ->\n Ast_410.Parsetree.Pcl_apply\n ( copy_class_expr x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | Ast_409.Parsetree.Pcl_let (x0, x1, x2) ->\n Ast_410.Parsetree.Pcl_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_class_expr x2)\n | Ast_409.Parsetree.Pcl_constraint (x0, x1) ->\n Ast_410.Parsetree.Pcl_constraint (copy_class_expr x0, copy_class_type x1)\n | Ast_409.Parsetree.Pcl_extension x0 ->\n Ast_410.Parsetree.Pcl_extension (copy_extension x0)\n | Ast_409.Parsetree.Pcl_open (x0, x1) ->\n Ast_410.Parsetree.Pcl_open (copy_open_description x0, copy_class_expr x1)\n\nand copy_class_structure :\n Ast_409.Parsetree.class_structure -> Ast_410.Parsetree.class_structure =\n fun { Ast_409.Parsetree.pcstr_self; Ast_409.Parsetree.pcstr_fields } ->\n {\n Ast_410.Parsetree.pcstr_self = copy_pattern pcstr_self;\n Ast_410.Parsetree.pcstr_fields = List.map copy_class_field pcstr_fields;\n }\n\nand copy_class_field :\n Ast_409.Parsetree.class_field -> Ast_410.Parsetree.class_field =\n fun {\n Ast_409.Parsetree.pcf_desc;\n Ast_409.Parsetree.pcf_loc;\n Ast_409.Parsetree.pcf_attributes;\n } ->\n {\n Ast_410.Parsetree.pcf_desc = copy_class_field_desc pcf_desc;\n Ast_410.Parsetree.pcf_loc = copy_location pcf_loc;\n Ast_410.Parsetree.pcf_attributes = copy_attributes pcf_attributes;\n }\n\nand copy_class_field_desc :\n Ast_409.Parsetree.class_field_desc -> Ast_410.Parsetree.class_field_desc =\n function\n | Ast_409.Parsetree.Pcf_inherit (x0, x1, x2) ->\n Ast_410.Parsetree.Pcf_inherit\n ( copy_override_flag x0,\n copy_class_expr x1,\n map_option (fun x -> copy_loc (fun x -> x) x) x2 )\n | Ast_409.Parsetree.Pcf_val x0 ->\n Ast_410.Parsetree.Pcf_val\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_mutable_flag x1, copy_class_field_kind x2))\n | Ast_409.Parsetree.Pcf_method x0 ->\n Ast_410.Parsetree.Pcf_method\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_private_flag x1, copy_class_field_kind x2))\n | Ast_409.Parsetree.Pcf_constraint x0 ->\n Ast_410.Parsetree.Pcf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | Ast_409.Parsetree.Pcf_initializer x0 ->\n Ast_410.Parsetree.Pcf_initializer (copy_expression x0)\n | Ast_409.Parsetree.Pcf_attribute x0 ->\n Ast_410.Parsetree.Pcf_attribute (copy_attribute x0)\n | Ast_409.Parsetree.Pcf_extension x0 ->\n Ast_410.Parsetree.Pcf_extension (copy_extension x0)\n\nand copy_class_field_kind :\n Ast_409.Parsetree.class_field_kind -> Ast_410.Parsetree.class_field_kind =\n function\n | Ast_409.Parsetree.Cfk_virtual x0 ->\n Ast_410.Parsetree.Cfk_virtual (copy_core_type x0)\n | Ast_409.Parsetree.Cfk_concrete (x0, x1) ->\n Ast_410.Parsetree.Cfk_concrete (copy_override_flag x0, copy_expression x1)\n\nand copy_open_declaration :\n Ast_409.Parsetree.open_declaration -> Ast_410.Parsetree.open_declaration =\n fun x -> copy_open_infos copy_module_expr x\n\nand copy_module_binding :\n Ast_409.Parsetree.module_binding -> Ast_410.Parsetree.module_binding =\n fun {\n Ast_409.Parsetree.pmb_name;\n Ast_409.Parsetree.pmb_expr;\n Ast_409.Parsetree.pmb_attributes;\n Ast_409.Parsetree.pmb_loc;\n } ->\n {\n Ast_410.Parsetree.pmb_name = copy_loc (fun x -> Some x) pmb_name;\n Ast_410.Parsetree.pmb_expr = copy_module_expr pmb_expr;\n Ast_410.Parsetree.pmb_attributes = copy_attributes pmb_attributes;\n Ast_410.Parsetree.pmb_loc = copy_location pmb_loc;\n }\n\nand copy_module_expr :\n Ast_409.Parsetree.module_expr -> Ast_410.Parsetree.module_expr =\n fun {\n Ast_409.Parsetree.pmod_desc;\n Ast_409.Parsetree.pmod_loc;\n Ast_409.Parsetree.pmod_attributes;\n } ->\n {\n Ast_410.Parsetree.pmod_desc = copy_module_expr_desc pmod_desc;\n Ast_410.Parsetree.pmod_loc = copy_location pmod_loc;\n Ast_410.Parsetree.pmod_attributes = copy_attributes pmod_attributes;\n }\n\nand copy_module_expr_desc :\n Ast_409.Parsetree.module_expr_desc -> Ast_410.Parsetree.module_expr_desc =\n function\n | Ast_409.Parsetree.Pmod_ident x0 ->\n Ast_410.Parsetree.Pmod_ident (copy_loc copy_Longident_t x0)\n | Ast_409.Parsetree.Pmod_structure x0 ->\n Ast_410.Parsetree.Pmod_structure (copy_structure x0)\n | Ast_409.Parsetree.Pmod_functor (x0, x1, x2) ->\n Ast_410.Parsetree.Pmod_functor\n ( (match (x0.txt, x1) with\n | \"*\", None -> Unit\n | \"_\", Some mt ->\n Named (copy_loc (fun _ -> None) x0, copy_module_type mt)\n | _, Some mt ->\n Named (copy_loc (fun x -> Some x) x0, copy_module_type mt)\n | _ -> assert false),\n copy_module_expr x2 )\n | Ast_409.Parsetree.Pmod_apply (x0, x1) ->\n Ast_410.Parsetree.Pmod_apply (copy_module_expr x0, copy_module_expr x1)\n | Ast_409.Parsetree.Pmod_constraint (x0, x1) ->\n Ast_410.Parsetree.Pmod_constraint\n (copy_module_expr x0, copy_module_type x1)\n | Ast_409.Parsetree.Pmod_unpack x0 ->\n Ast_410.Parsetree.Pmod_unpack (copy_expression x0)\n | Ast_409.Parsetree.Pmod_extension x0 ->\n Ast_410.Parsetree.Pmod_extension (copy_extension x0)\n\nand copy_module_type :\n Ast_409.Parsetree.module_type -> Ast_410.Parsetree.module_type =\n fun {\n Ast_409.Parsetree.pmty_desc;\n Ast_409.Parsetree.pmty_loc;\n Ast_409.Parsetree.pmty_attributes;\n } ->\n {\n Ast_410.Parsetree.pmty_desc = copy_module_type_desc pmty_desc;\n Ast_410.Parsetree.pmty_loc = copy_location pmty_loc;\n Ast_410.Parsetree.pmty_attributes = copy_attributes pmty_attributes;\n }\n\nand copy_module_type_desc :\n Ast_409.Parsetree.module_type_desc -> Ast_410.Parsetree.module_type_desc =\n function\n | Ast_409.Parsetree.Pmty_ident x0 ->\n Ast_410.Parsetree.Pmty_ident (copy_loc copy_Longident_t x0)\n | Ast_409.Parsetree.Pmty_signature x0 ->\n Ast_410.Parsetree.Pmty_signature (copy_signature x0)\n | Ast_409.Parsetree.Pmty_functor (x0, x1, x2) ->\n Ast_410.Parsetree.Pmty_functor\n ( (match (x0.txt, x1) with\n | \"*\", None -> Unit\n | \"_\", Some mt ->\n Named (copy_loc (fun _ -> None) x0, copy_module_type mt)\n | _, Some mt ->\n Named (copy_loc (fun x -> Some x) x0, copy_module_type mt)\n | _ -> assert false),\n copy_module_type x2 )\n | Ast_409.Parsetree.Pmty_with (x0, x1) ->\n Ast_410.Parsetree.Pmty_with\n (copy_module_type x0, List.map copy_with_constraint x1)\n | Ast_409.Parsetree.Pmty_typeof x0 ->\n Ast_410.Parsetree.Pmty_typeof (copy_module_expr x0)\n | Ast_409.Parsetree.Pmty_extension x0 ->\n Ast_410.Parsetree.Pmty_extension (copy_extension x0)\n | Ast_409.Parsetree.Pmty_alias x0 ->\n Ast_410.Parsetree.Pmty_alias (copy_loc copy_Longident_t x0)\n\nand copy_with_constraint :\n Ast_409.Parsetree.with_constraint -> Ast_410.Parsetree.with_constraint =\n function\n | Ast_409.Parsetree.Pwith_type (x0, x1) ->\n Ast_410.Parsetree.Pwith_type\n (copy_loc copy_Longident_t x0, copy_type_declaration x1)\n | Ast_409.Parsetree.Pwith_module (x0, x1) ->\n Ast_410.Parsetree.Pwith_module\n (copy_loc copy_Longident_t x0, copy_loc copy_Longident_t x1)\n | Ast_409.Parsetree.Pwith_typesubst (x0, x1) ->\n Ast_410.Parsetree.Pwith_typesubst\n (copy_loc copy_Longident_t x0, copy_type_declaration x1)\n | Ast_409.Parsetree.Pwith_modsubst (x0, x1) ->\n Ast_410.Parsetree.Pwith_modsubst\n (copy_loc copy_Longident_t x0, copy_loc copy_Longident_t x1)\n\nand copy_signature : Ast_409.Parsetree.signature -> Ast_410.Parsetree.signature\n =\n fun x -> List.map copy_signature_item x\n\nand copy_signature_item :\n Ast_409.Parsetree.signature_item -> Ast_410.Parsetree.signature_item =\n fun { Ast_409.Parsetree.psig_desc; Ast_409.Parsetree.psig_loc } ->\n {\n Ast_410.Parsetree.psig_desc = copy_signature_item_desc psig_desc;\n Ast_410.Parsetree.psig_loc = copy_location psig_loc;\n }\n\nand copy_signature_item_desc :\n Ast_409.Parsetree.signature_item_desc ->\n Ast_410.Parsetree.signature_item_desc = function\n | Ast_409.Parsetree.Psig_value x0 ->\n Ast_410.Parsetree.Psig_value (copy_value_description x0)\n | Ast_409.Parsetree.Psig_type (x0, x1) ->\n Ast_410.Parsetree.Psig_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | Ast_409.Parsetree.Psig_typesubst x0 ->\n Ast_410.Parsetree.Psig_typesubst (List.map copy_type_declaration x0)\n | Ast_409.Parsetree.Psig_typext x0 ->\n Ast_410.Parsetree.Psig_typext (copy_type_extension x0)\n | Ast_409.Parsetree.Psig_exception x0 ->\n Ast_410.Parsetree.Psig_exception (copy_type_exception x0)\n | Ast_409.Parsetree.Psig_module x0 ->\n Ast_410.Parsetree.Psig_module (copy_module_declaration x0)\n | Ast_409.Parsetree.Psig_modsubst x0 ->\n Ast_410.Parsetree.Psig_modsubst (copy_module_substitution x0)\n | Ast_409.Parsetree.Psig_recmodule x0 ->\n Ast_410.Parsetree.Psig_recmodule (List.map copy_module_declaration x0)\n | Ast_409.Parsetree.Psig_modtype x0 ->\n Ast_410.Parsetree.Psig_modtype (copy_module_type_declaration x0)\n | Ast_409.Parsetree.Psig_open x0 ->\n Ast_410.Parsetree.Psig_open (copy_open_description x0)\n | Ast_409.Parsetree.Psig_include x0 ->\n Ast_410.Parsetree.Psig_include (copy_include_description x0)\n | Ast_409.Parsetree.Psig_class x0 ->\n Ast_410.Parsetree.Psig_class (List.map copy_class_description x0)\n | Ast_409.Parsetree.Psig_class_type x0 ->\n Ast_410.Parsetree.Psig_class_type\n (List.map copy_class_type_declaration x0)\n | Ast_409.Parsetree.Psig_attribute x0 ->\n Ast_410.Parsetree.Psig_attribute (copy_attribute x0)\n | Ast_409.Parsetree.Psig_extension (x0, x1) ->\n Ast_410.Parsetree.Psig_extension (copy_extension x0, copy_attributes x1)\n\nand copy_class_type_declaration :\n Ast_409.Parsetree.class_type_declaration ->\n Ast_410.Parsetree.class_type_declaration =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_description :\n Ast_409.Parsetree.class_description -> Ast_410.Parsetree.class_description =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_type :\n Ast_409.Parsetree.class_type -> Ast_410.Parsetree.class_type =\n fun {\n Ast_409.Parsetree.pcty_desc;\n Ast_409.Parsetree.pcty_loc;\n Ast_409.Parsetree.pcty_attributes;\n } ->\n {\n Ast_410.Parsetree.pcty_desc = copy_class_type_desc pcty_desc;\n Ast_410.Parsetree.pcty_loc = copy_location pcty_loc;\n Ast_410.Parsetree.pcty_attributes = copy_attributes pcty_attributes;\n }\n\nand copy_class_type_desc :\n Ast_409.Parsetree.class_type_desc -> Ast_410.Parsetree.class_type_desc =\n function\n | Ast_409.Parsetree.Pcty_constr (x0, x1) ->\n Ast_410.Parsetree.Pcty_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_409.Parsetree.Pcty_signature x0 ->\n Ast_410.Parsetree.Pcty_signature (copy_class_signature x0)\n | Ast_409.Parsetree.Pcty_arrow (x0, x1, x2) ->\n Ast_410.Parsetree.Pcty_arrow\n (copy_arg_label x0, copy_core_type x1, copy_class_type x2)\n | Ast_409.Parsetree.Pcty_extension x0 ->\n Ast_410.Parsetree.Pcty_extension (copy_extension x0)\n | Ast_409.Parsetree.Pcty_open (x0, x1) ->\n Ast_410.Parsetree.Pcty_open (copy_open_description x0, copy_class_type x1)\n\nand copy_class_signature :\n Ast_409.Parsetree.class_signature -> Ast_410.Parsetree.class_signature =\n fun { Ast_409.Parsetree.pcsig_self; Ast_409.Parsetree.pcsig_fields } ->\n {\n Ast_410.Parsetree.pcsig_self = copy_core_type pcsig_self;\n Ast_410.Parsetree.pcsig_fields = List.map copy_class_type_field pcsig_fields;\n }\n\nand copy_class_type_field :\n Ast_409.Parsetree.class_type_field -> Ast_410.Parsetree.class_type_field =\n fun {\n Ast_409.Parsetree.pctf_desc;\n Ast_409.Parsetree.pctf_loc;\n Ast_409.Parsetree.pctf_attributes;\n } ->\n {\n Ast_410.Parsetree.pctf_desc = copy_class_type_field_desc pctf_desc;\n Ast_410.Parsetree.pctf_loc = copy_location pctf_loc;\n Ast_410.Parsetree.pctf_attributes = copy_attributes pctf_attributes;\n }\n\nand copy_class_type_field_desc :\n Ast_409.Parsetree.class_type_field_desc ->\n Ast_410.Parsetree.class_type_field_desc = function\n | Ast_409.Parsetree.Pctf_inherit x0 ->\n Ast_410.Parsetree.Pctf_inherit (copy_class_type x0)\n | Ast_409.Parsetree.Pctf_val x0 ->\n Ast_410.Parsetree.Pctf_val\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_mutable_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | Ast_409.Parsetree.Pctf_method x0 ->\n Ast_410.Parsetree.Pctf_method\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_private_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | Ast_409.Parsetree.Pctf_constraint x0 ->\n Ast_410.Parsetree.Pctf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | Ast_409.Parsetree.Pctf_attribute x0 ->\n Ast_410.Parsetree.Pctf_attribute (copy_attribute x0)\n | Ast_409.Parsetree.Pctf_extension x0 ->\n Ast_410.Parsetree.Pctf_extension (copy_extension x0)\n\nand copy_extension : Ast_409.Parsetree.extension -> Ast_410.Parsetree.extension\n =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_class_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_409.Parsetree.class_infos ->\n 'g0 Ast_410.Parsetree.class_infos =\n fun f0\n {\n Ast_409.Parsetree.pci_virt;\n Ast_409.Parsetree.pci_params;\n Ast_409.Parsetree.pci_name;\n Ast_409.Parsetree.pci_expr;\n Ast_409.Parsetree.pci_loc;\n Ast_409.Parsetree.pci_attributes;\n } ->\n {\n Ast_410.Parsetree.pci_virt = copy_virtual_flag pci_virt;\n Ast_410.Parsetree.pci_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n pci_params;\n Ast_410.Parsetree.pci_name = copy_loc (fun x -> x) pci_name;\n Ast_410.Parsetree.pci_expr = f0 pci_expr;\n Ast_410.Parsetree.pci_loc = copy_location pci_loc;\n Ast_410.Parsetree.pci_attributes = copy_attributes pci_attributes;\n }\n\nand copy_virtual_flag :\n Ast_409.Asttypes.virtual_flag -> Ast_410.Asttypes.virtual_flag = function\n | Ast_409.Asttypes.Virtual -> Ast_410.Asttypes.Virtual\n | Ast_409.Asttypes.Concrete -> Ast_410.Asttypes.Concrete\n\nand copy_include_description :\n Ast_409.Parsetree.include_description ->\n Ast_410.Parsetree.include_description =\n fun x -> copy_include_infos copy_module_type x\n\nand copy_include_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_409.Parsetree.include_infos ->\n 'g0 Ast_410.Parsetree.include_infos =\n fun f0\n {\n Ast_409.Parsetree.pincl_mod;\n Ast_409.Parsetree.pincl_loc;\n Ast_409.Parsetree.pincl_attributes;\n } ->\n {\n Ast_410.Parsetree.pincl_mod = f0 pincl_mod;\n Ast_410.Parsetree.pincl_loc = copy_location pincl_loc;\n Ast_410.Parsetree.pincl_attributes = copy_attributes pincl_attributes;\n }\n\nand copy_open_description :\n Ast_409.Parsetree.open_description -> Ast_410.Parsetree.open_description =\n fun x -> copy_open_infos (fun x -> copy_loc copy_Longident_t x) x\n\nand copy_open_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_409.Parsetree.open_infos ->\n 'g0 Ast_410.Parsetree.open_infos =\n fun f0\n {\n Ast_409.Parsetree.popen_expr;\n Ast_409.Parsetree.popen_override;\n Ast_409.Parsetree.popen_loc;\n Ast_409.Parsetree.popen_attributes;\n } ->\n {\n Ast_410.Parsetree.popen_expr = f0 popen_expr;\n Ast_410.Parsetree.popen_override = copy_override_flag popen_override;\n Ast_410.Parsetree.popen_loc = copy_location popen_loc;\n Ast_410.Parsetree.popen_attributes = copy_attributes popen_attributes;\n }\n\nand copy_override_flag :\n Ast_409.Asttypes.override_flag -> Ast_410.Asttypes.override_flag = function\n | Ast_409.Asttypes.Override -> Ast_410.Asttypes.Override\n | Ast_409.Asttypes.Fresh -> Ast_410.Asttypes.Fresh\n\nand copy_module_type_declaration :\n Ast_409.Parsetree.module_type_declaration ->\n Ast_410.Parsetree.module_type_declaration =\n fun {\n Ast_409.Parsetree.pmtd_name;\n Ast_409.Parsetree.pmtd_type;\n Ast_409.Parsetree.pmtd_attributes;\n Ast_409.Parsetree.pmtd_loc;\n } ->\n {\n Ast_410.Parsetree.pmtd_name = copy_loc (fun x -> x) pmtd_name;\n Ast_410.Parsetree.pmtd_type = map_option copy_module_type pmtd_type;\n Ast_410.Parsetree.pmtd_attributes = copy_attributes pmtd_attributes;\n Ast_410.Parsetree.pmtd_loc = copy_location pmtd_loc;\n }\n\nand copy_module_substitution :\n Ast_409.Parsetree.module_substitution ->\n Ast_410.Parsetree.module_substitution =\n fun {\n Ast_409.Parsetree.pms_name;\n Ast_409.Parsetree.pms_manifest;\n Ast_409.Parsetree.pms_attributes;\n Ast_409.Parsetree.pms_loc;\n } ->\n {\n Ast_410.Parsetree.pms_name = copy_loc (fun x -> x) pms_name;\n Ast_410.Parsetree.pms_manifest = copy_loc copy_Longident_t pms_manifest;\n Ast_410.Parsetree.pms_attributes = copy_attributes pms_attributes;\n Ast_410.Parsetree.pms_loc = copy_location pms_loc;\n }\n\nand copy_module_declaration :\n Ast_409.Parsetree.module_declaration -> Ast_410.Parsetree.module_declaration\n =\n fun {\n Ast_409.Parsetree.pmd_name;\n Ast_409.Parsetree.pmd_type;\n Ast_409.Parsetree.pmd_attributes;\n Ast_409.Parsetree.pmd_loc;\n } ->\n {\n Ast_410.Parsetree.pmd_name = copy_loc (fun x -> Some x) pmd_name;\n Ast_410.Parsetree.pmd_type = copy_module_type pmd_type;\n Ast_410.Parsetree.pmd_attributes = copy_attributes pmd_attributes;\n Ast_410.Parsetree.pmd_loc = copy_location pmd_loc;\n }\n\nand copy_type_exception :\n Ast_409.Parsetree.type_exception -> Ast_410.Parsetree.type_exception =\n fun {\n Ast_409.Parsetree.ptyexn_constructor;\n Ast_409.Parsetree.ptyexn_loc;\n Ast_409.Parsetree.ptyexn_attributes;\n } ->\n {\n Ast_410.Parsetree.ptyexn_constructor =\n copy_extension_constructor ptyexn_constructor;\n Ast_410.Parsetree.ptyexn_loc = copy_location ptyexn_loc;\n Ast_410.Parsetree.ptyexn_attributes = copy_attributes ptyexn_attributes;\n }\n\nand copy_type_extension :\n Ast_409.Parsetree.type_extension -> Ast_410.Parsetree.type_extension =\n fun {\n Ast_409.Parsetree.ptyext_path;\n Ast_409.Parsetree.ptyext_params;\n Ast_409.Parsetree.ptyext_constructors;\n Ast_409.Parsetree.ptyext_private;\n Ast_409.Parsetree.ptyext_loc;\n Ast_409.Parsetree.ptyext_attributes;\n } ->\n {\n Ast_410.Parsetree.ptyext_path = copy_loc copy_Longident_t ptyext_path;\n Ast_410.Parsetree.ptyext_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptyext_params;\n Ast_410.Parsetree.ptyext_constructors =\n List.map copy_extension_constructor ptyext_constructors;\n Ast_410.Parsetree.ptyext_private = copy_private_flag ptyext_private;\n Ast_410.Parsetree.ptyext_loc = copy_location ptyext_loc;\n Ast_410.Parsetree.ptyext_attributes = copy_attributes ptyext_attributes;\n }\n\nand copy_extension_constructor :\n Ast_409.Parsetree.extension_constructor ->\n Ast_410.Parsetree.extension_constructor =\n fun {\n Ast_409.Parsetree.pext_name;\n Ast_409.Parsetree.pext_kind;\n Ast_409.Parsetree.pext_loc;\n Ast_409.Parsetree.pext_attributes;\n } ->\n {\n Ast_410.Parsetree.pext_name = copy_loc (fun x -> x) pext_name;\n Ast_410.Parsetree.pext_kind = copy_extension_constructor_kind pext_kind;\n Ast_410.Parsetree.pext_loc = copy_location pext_loc;\n Ast_410.Parsetree.pext_attributes = copy_attributes pext_attributes;\n }\n\nand copy_extension_constructor_kind :\n Ast_409.Parsetree.extension_constructor_kind ->\n Ast_410.Parsetree.extension_constructor_kind = function\n | Ast_409.Parsetree.Pext_decl (x0, x1) ->\n Ast_410.Parsetree.Pext_decl\n (copy_constructor_arguments x0, map_option copy_core_type x1)\n | Ast_409.Parsetree.Pext_rebind x0 ->\n Ast_410.Parsetree.Pext_rebind (copy_loc copy_Longident_t x0)\n\nand copy_type_declaration :\n Ast_409.Parsetree.type_declaration -> Ast_410.Parsetree.type_declaration =\n fun {\n Ast_409.Parsetree.ptype_name;\n Ast_409.Parsetree.ptype_params;\n Ast_409.Parsetree.ptype_cstrs;\n Ast_409.Parsetree.ptype_kind;\n Ast_409.Parsetree.ptype_private;\n Ast_409.Parsetree.ptype_manifest;\n Ast_409.Parsetree.ptype_attributes;\n Ast_409.Parsetree.ptype_loc;\n } ->\n {\n Ast_410.Parsetree.ptype_name = copy_loc (fun x -> x) ptype_name;\n Ast_410.Parsetree.ptype_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptype_params;\n Ast_410.Parsetree.ptype_cstrs =\n List.map\n (fun x ->\n let x0, x1, x2 = x in\n (copy_core_type x0, copy_core_type x1, copy_location x2))\n ptype_cstrs;\n Ast_410.Parsetree.ptype_kind = copy_type_kind ptype_kind;\n Ast_410.Parsetree.ptype_private = copy_private_flag ptype_private;\n Ast_410.Parsetree.ptype_manifest = map_option copy_core_type ptype_manifest;\n Ast_410.Parsetree.ptype_attributes = copy_attributes ptype_attributes;\n Ast_410.Parsetree.ptype_loc = copy_location ptype_loc;\n }\n\nand copy_private_flag :\n Ast_409.Asttypes.private_flag -> Ast_410.Asttypes.private_flag = function\n | Ast_409.Asttypes.Private -> Ast_410.Asttypes.Private\n | Ast_409.Asttypes.Public -> Ast_410.Asttypes.Public\n\nand copy_type_kind : Ast_409.Parsetree.type_kind -> Ast_410.Parsetree.type_kind\n = function\n | Ast_409.Parsetree.Ptype_abstract -> Ast_410.Parsetree.Ptype_abstract\n | Ast_409.Parsetree.Ptype_variant x0 ->\n Ast_410.Parsetree.Ptype_variant (List.map copy_constructor_declaration x0)\n | Ast_409.Parsetree.Ptype_record x0 ->\n Ast_410.Parsetree.Ptype_record (List.map copy_label_declaration x0)\n | Ast_409.Parsetree.Ptype_open -> Ast_410.Parsetree.Ptype_open\n\nand copy_constructor_declaration :\n Ast_409.Parsetree.constructor_declaration ->\n Ast_410.Parsetree.constructor_declaration =\n fun {\n Ast_409.Parsetree.pcd_name;\n Ast_409.Parsetree.pcd_args;\n Ast_409.Parsetree.pcd_res;\n Ast_409.Parsetree.pcd_loc;\n Ast_409.Parsetree.pcd_attributes;\n } ->\n {\n Ast_410.Parsetree.pcd_name = copy_loc (fun x -> x) pcd_name;\n Ast_410.Parsetree.pcd_args = copy_constructor_arguments pcd_args;\n Ast_410.Parsetree.pcd_res = map_option copy_core_type pcd_res;\n Ast_410.Parsetree.pcd_loc = copy_location pcd_loc;\n Ast_410.Parsetree.pcd_attributes = copy_attributes pcd_attributes;\n }\n\nand copy_constructor_arguments :\n Ast_409.Parsetree.constructor_arguments ->\n Ast_410.Parsetree.constructor_arguments = function\n | Ast_409.Parsetree.Pcstr_tuple x0 ->\n Ast_410.Parsetree.Pcstr_tuple (List.map copy_core_type x0)\n | Ast_409.Parsetree.Pcstr_record x0 ->\n Ast_410.Parsetree.Pcstr_record (List.map copy_label_declaration x0)\n\nand copy_label_declaration :\n Ast_409.Parsetree.label_declaration -> Ast_410.Parsetree.label_declaration =\n fun {\n Ast_409.Parsetree.pld_name;\n Ast_409.Parsetree.pld_mutable;\n Ast_409.Parsetree.pld_type;\n Ast_409.Parsetree.pld_loc;\n Ast_409.Parsetree.pld_attributes;\n } ->\n {\n Ast_410.Parsetree.pld_name = copy_loc (fun x -> x) pld_name;\n Ast_410.Parsetree.pld_mutable = copy_mutable_flag pld_mutable;\n Ast_410.Parsetree.pld_type = copy_core_type pld_type;\n Ast_410.Parsetree.pld_loc = copy_location pld_loc;\n Ast_410.Parsetree.pld_attributes = copy_attributes pld_attributes;\n }\n\nand copy_mutable_flag :\n Ast_409.Asttypes.mutable_flag -> Ast_410.Asttypes.mutable_flag = function\n | Ast_409.Asttypes.Immutable -> Ast_410.Asttypes.Immutable\n | Ast_409.Asttypes.Mutable -> Ast_410.Asttypes.Mutable\n\nand copy_variance : Ast_409.Asttypes.variance -> Ast_410.Asttypes.variance =\n function\n | Ast_409.Asttypes.Covariant -> Ast_410.Asttypes.Covariant\n | Ast_409.Asttypes.Contravariant -> Ast_410.Asttypes.Contravariant\n | Ast_409.Asttypes.Invariant -> Ast_410.Asttypes.Invariant\n\nand copy_value_description :\n Ast_409.Parsetree.value_description -> Ast_410.Parsetree.value_description =\n fun {\n Ast_409.Parsetree.pval_name;\n Ast_409.Parsetree.pval_type;\n Ast_409.Parsetree.pval_prim;\n Ast_409.Parsetree.pval_attributes;\n Ast_409.Parsetree.pval_loc;\n } ->\n {\n Ast_410.Parsetree.pval_name = copy_loc (fun x -> x) pval_name;\n Ast_410.Parsetree.pval_type = copy_core_type pval_type;\n Ast_410.Parsetree.pval_prim = List.map (fun x -> x) pval_prim;\n Ast_410.Parsetree.pval_attributes = copy_attributes pval_attributes;\n Ast_410.Parsetree.pval_loc = copy_location pval_loc;\n }\n\nand copy_object_field_desc :\n Ast_409.Parsetree.object_field_desc -> Ast_410.Parsetree.object_field_desc =\n function\n | Ast_409.Parsetree.Otag (x0, x1) ->\n Ast_410.Parsetree.Otag (copy_loc copy_label x0, copy_core_type x1)\n | Ast_409.Parsetree.Oinherit x0 ->\n Ast_410.Parsetree.Oinherit (copy_core_type x0)\n\nand copy_arg_label : Ast_409.Asttypes.arg_label -> Ast_410.Asttypes.arg_label =\n function\n | Ast_409.Asttypes.Nolabel -> Ast_410.Asttypes.Nolabel\n | Ast_409.Asttypes.Labelled x0 -> Ast_410.Asttypes.Labelled x0\n | Ast_409.Asttypes.Optional x0 -> Ast_410.Asttypes.Optional x0\n\nand copy_closed_flag :\n Ast_409.Asttypes.closed_flag -> Ast_410.Asttypes.closed_flag = function\n | Ast_409.Asttypes.Closed -> Ast_410.Asttypes.Closed\n | Ast_409.Asttypes.Open -> Ast_410.Asttypes.Open\n\nand copy_label : Ast_409.Asttypes.label -> Ast_410.Asttypes.label = fun x -> x\n\nand copy_rec_flag : Ast_409.Asttypes.rec_flag -> Ast_410.Asttypes.rec_flag =\n function\n | Ast_409.Asttypes.Nonrecursive -> Ast_410.Asttypes.Nonrecursive\n | Ast_409.Asttypes.Recursive -> Ast_410.Asttypes.Recursive\n\nand copy_constant : Ast_409.Parsetree.constant -> Ast_410.Parsetree.constant =\n function\n | Ast_409.Parsetree.Pconst_integer (x0, x1) ->\n Ast_410.Parsetree.Pconst_integer (x0, map_option (fun x -> x) x1)\n | Ast_409.Parsetree.Pconst_char x0 -> Ast_410.Parsetree.Pconst_char x0\n | Ast_409.Parsetree.Pconst_string (x0, x1) ->\n Ast_410.Parsetree.Pconst_string (x0, map_option (fun x -> x) x1)\n | Ast_409.Parsetree.Pconst_float (x0, x1) ->\n Ast_410.Parsetree.Pconst_float (x0, map_option (fun x -> x) x1)\n\nand copy_Longident_t : Longident.t -> Longident.t = fun x -> x\n\nand copy_loc :\n 'f0 'g0.\n ('f0 -> 'g0) -> 'f0 Ast_409.Asttypes.loc -> 'g0 Ast_410.Asttypes.loc =\n fun f0 { Ast_409.Asttypes.txt; Ast_409.Asttypes.loc } ->\n { Ast_410.Asttypes.txt = f0 txt; Ast_410.Asttypes.loc = copy_location loc }\n\nand copy_location : Location.t -> Location.t = fun x -> x\n\nlet copy_expr = copy_expression\nlet copy_pat = copy_pattern\nlet copy_typ = copy_core_type\n","open Stdlib0\nmodule From = Ast_409\nmodule To = Ast_408\n\nlet rec copy_toplevel_phrase :\n Ast_409.Parsetree.toplevel_phrase -> Ast_408.Parsetree.toplevel_phrase =\n function\n | Ast_409.Parsetree.Ptop_def x0 ->\n Ast_408.Parsetree.Ptop_def (copy_structure x0)\n | Ast_409.Parsetree.Ptop_dir x0 ->\n Ast_408.Parsetree.Ptop_dir (copy_toplevel_directive x0)\n\nand copy_toplevel_directive :\n Ast_409.Parsetree.toplevel_directive -> Ast_408.Parsetree.toplevel_directive\n =\n fun {\n Ast_409.Parsetree.pdir_name;\n Ast_409.Parsetree.pdir_arg;\n Ast_409.Parsetree.pdir_loc;\n } ->\n {\n Ast_408.Parsetree.pdir_name = copy_loc (fun x -> x) pdir_name;\n Ast_408.Parsetree.pdir_arg = Option.map copy_directive_argument pdir_arg;\n Ast_408.Parsetree.pdir_loc = copy_location pdir_loc;\n }\n\nand copy_directive_argument :\n Ast_409.Parsetree.directive_argument -> Ast_408.Parsetree.directive_argument\n =\n fun { Ast_409.Parsetree.pdira_desc; Ast_409.Parsetree.pdira_loc } ->\n {\n Ast_408.Parsetree.pdira_desc = copy_directive_argument_desc pdira_desc;\n Ast_408.Parsetree.pdira_loc = copy_location pdira_loc;\n }\n\nand copy_directive_argument_desc :\n Ast_409.Parsetree.directive_argument_desc ->\n Ast_408.Parsetree.directive_argument_desc = function\n | Ast_409.Parsetree.Pdir_string x0 -> Ast_408.Parsetree.Pdir_string x0\n | Ast_409.Parsetree.Pdir_int (x0, x1) ->\n Ast_408.Parsetree.Pdir_int (x0, Option.map (fun x -> x) x1)\n | Ast_409.Parsetree.Pdir_ident x0 ->\n Ast_408.Parsetree.Pdir_ident (copy_Longident_t x0)\n | Ast_409.Parsetree.Pdir_bool x0 -> Ast_408.Parsetree.Pdir_bool x0\n\nand copy_typ : Ast_409.Parsetree.typ -> Ast_408.Parsetree.typ =\n fun x -> copy_core_type x\n\nand copy_pat : Ast_409.Parsetree.pat -> Ast_408.Parsetree.pat =\n fun x -> copy_pattern x\n\nand copy_expr : Ast_409.Parsetree.expr -> Ast_408.Parsetree.expr =\n fun x -> copy_expression x\n\nand copy_expression :\n Ast_409.Parsetree.expression -> Ast_408.Parsetree.expression =\n fun {\n Ast_409.Parsetree.pexp_desc;\n Ast_409.Parsetree.pexp_loc;\n Ast_409.Parsetree.pexp_loc_stack;\n Ast_409.Parsetree.pexp_attributes;\n } ->\n {\n Ast_408.Parsetree.pexp_desc = copy_expression_desc pexp_desc;\n Ast_408.Parsetree.pexp_loc = copy_location pexp_loc;\n Ast_408.Parsetree.pexp_loc_stack = List.map copy_location pexp_loc_stack;\n Ast_408.Parsetree.pexp_attributes = copy_attributes pexp_attributes;\n }\n\nand copy_expression_desc :\n Ast_409.Parsetree.expression_desc -> Ast_408.Parsetree.expression_desc =\n function\n | Ast_409.Parsetree.Pexp_ident x0 ->\n Ast_408.Parsetree.Pexp_ident (copy_loc copy_Longident_t x0)\n | Ast_409.Parsetree.Pexp_constant x0 ->\n Ast_408.Parsetree.Pexp_constant (copy_constant x0)\n | Ast_409.Parsetree.Pexp_let (x0, x1, x2) ->\n Ast_408.Parsetree.Pexp_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_expression x2)\n | Ast_409.Parsetree.Pexp_function x0 ->\n Ast_408.Parsetree.Pexp_function (copy_cases x0)\n | Ast_409.Parsetree.Pexp_fun (x0, x1, x2, x3) ->\n Ast_408.Parsetree.Pexp_fun\n ( copy_arg_label x0,\n Option.map copy_expression x1,\n copy_pattern x2,\n copy_expression x3 )\n | Ast_409.Parsetree.Pexp_apply (x0, x1) ->\n Ast_408.Parsetree.Pexp_apply\n ( copy_expression x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | Ast_409.Parsetree.Pexp_match (x0, x1) ->\n Ast_408.Parsetree.Pexp_match (copy_expression x0, copy_cases x1)\n | Ast_409.Parsetree.Pexp_try (x0, x1) ->\n Ast_408.Parsetree.Pexp_try (copy_expression x0, copy_cases x1)\n | Ast_409.Parsetree.Pexp_tuple x0 ->\n Ast_408.Parsetree.Pexp_tuple (List.map copy_expression x0)\n | Ast_409.Parsetree.Pexp_construct (x0, x1) ->\n Ast_408.Parsetree.Pexp_construct\n (copy_loc copy_Longident_t x0, Option.map copy_expression x1)\n | Ast_409.Parsetree.Pexp_variant (x0, x1) ->\n Ast_408.Parsetree.Pexp_variant\n (copy_label x0, Option.map copy_expression x1)\n | Ast_409.Parsetree.Pexp_record (x0, x1) ->\n Ast_408.Parsetree.Pexp_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_expression x1))\n x0,\n Option.map copy_expression x1 )\n | Ast_409.Parsetree.Pexp_field (x0, x1) ->\n Ast_408.Parsetree.Pexp_field\n (copy_expression x0, copy_loc copy_Longident_t x1)\n | Ast_409.Parsetree.Pexp_setfield (x0, x1, x2) ->\n Ast_408.Parsetree.Pexp_setfield\n (copy_expression x0, copy_loc copy_Longident_t x1, copy_expression x2)\n | Ast_409.Parsetree.Pexp_array x0 ->\n Ast_408.Parsetree.Pexp_array (List.map copy_expression x0)\n | Ast_409.Parsetree.Pexp_ifthenelse (x0, x1, x2) ->\n Ast_408.Parsetree.Pexp_ifthenelse\n (copy_expression x0, copy_expression x1, Option.map copy_expression x2)\n | Ast_409.Parsetree.Pexp_sequence (x0, x1) ->\n Ast_408.Parsetree.Pexp_sequence (copy_expression x0, copy_expression x1)\n | Ast_409.Parsetree.Pexp_while (x0, x1) ->\n Ast_408.Parsetree.Pexp_while (copy_expression x0, copy_expression x1)\n | Ast_409.Parsetree.Pexp_for (x0, x1, x2, x3, x4) ->\n Ast_408.Parsetree.Pexp_for\n ( copy_pattern x0,\n copy_expression x1,\n copy_expression x2,\n copy_direction_flag x3,\n copy_expression x4 )\n | Ast_409.Parsetree.Pexp_constraint (x0, x1) ->\n Ast_408.Parsetree.Pexp_constraint (copy_expression x0, copy_core_type x1)\n | Ast_409.Parsetree.Pexp_coerce (x0, x1, x2) ->\n Ast_408.Parsetree.Pexp_coerce\n (copy_expression x0, Option.map copy_core_type x1, copy_core_type x2)\n | Ast_409.Parsetree.Pexp_send (x0, x1) ->\n Ast_408.Parsetree.Pexp_send (copy_expression x0, copy_loc copy_label x1)\n | Ast_409.Parsetree.Pexp_new x0 ->\n Ast_408.Parsetree.Pexp_new (copy_loc copy_Longident_t x0)\n | Ast_409.Parsetree.Pexp_setinstvar (x0, x1) ->\n Ast_408.Parsetree.Pexp_setinstvar\n (copy_loc copy_label x0, copy_expression x1)\n | Ast_409.Parsetree.Pexp_override x0 ->\n Ast_408.Parsetree.Pexp_override\n (List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_label x0, copy_expression x1))\n x0)\n | Ast_409.Parsetree.Pexp_letmodule (x0, x1, x2) ->\n Ast_408.Parsetree.Pexp_letmodule\n (copy_loc (fun x -> x) x0, copy_module_expr x1, copy_expression x2)\n | Ast_409.Parsetree.Pexp_letexception (x0, x1) ->\n Ast_408.Parsetree.Pexp_letexception\n (copy_extension_constructor x0, copy_expression x1)\n | Ast_409.Parsetree.Pexp_assert x0 ->\n Ast_408.Parsetree.Pexp_assert (copy_expression x0)\n | Ast_409.Parsetree.Pexp_lazy x0 ->\n Ast_408.Parsetree.Pexp_lazy (copy_expression x0)\n | Ast_409.Parsetree.Pexp_poly (x0, x1) ->\n Ast_408.Parsetree.Pexp_poly\n (copy_expression x0, Option.map copy_core_type x1)\n | Ast_409.Parsetree.Pexp_object x0 ->\n Ast_408.Parsetree.Pexp_object (copy_class_structure x0)\n | Ast_409.Parsetree.Pexp_newtype (x0, x1) ->\n Ast_408.Parsetree.Pexp_newtype\n (copy_loc (fun x -> x) x0, copy_expression x1)\n | Ast_409.Parsetree.Pexp_pack x0 ->\n Ast_408.Parsetree.Pexp_pack (copy_module_expr x0)\n | Ast_409.Parsetree.Pexp_open (x0, x1) ->\n Ast_408.Parsetree.Pexp_open (copy_open_declaration x0, copy_expression x1)\n | Ast_409.Parsetree.Pexp_letop x0 ->\n Ast_408.Parsetree.Pexp_letop (copy_letop x0)\n | Ast_409.Parsetree.Pexp_extension x0 ->\n Ast_408.Parsetree.Pexp_extension (copy_extension x0)\n | Ast_409.Parsetree.Pexp_unreachable -> Ast_408.Parsetree.Pexp_unreachable\n\nand copy_letop : Ast_409.Parsetree.letop -> Ast_408.Parsetree.letop =\n fun { Ast_409.Parsetree.let_; Ast_409.Parsetree.ands; Ast_409.Parsetree.body } ->\n {\n Ast_408.Parsetree.let_ = copy_binding_op let_;\n Ast_408.Parsetree.ands = List.map copy_binding_op ands;\n Ast_408.Parsetree.body = copy_expression body;\n }\n\nand copy_binding_op :\n Ast_409.Parsetree.binding_op -> Ast_408.Parsetree.binding_op =\n fun {\n Ast_409.Parsetree.pbop_op;\n Ast_409.Parsetree.pbop_pat;\n Ast_409.Parsetree.pbop_exp;\n Ast_409.Parsetree.pbop_loc;\n } ->\n {\n Ast_408.Parsetree.pbop_op = copy_loc (fun x -> x) pbop_op;\n Ast_408.Parsetree.pbop_pat = copy_pattern pbop_pat;\n Ast_408.Parsetree.pbop_exp = copy_expression pbop_exp;\n Ast_408.Parsetree.pbop_loc = copy_location pbop_loc;\n }\n\nand copy_direction_flag :\n Ast_409.Asttypes.direction_flag -> Ast_408.Asttypes.direction_flag =\n function\n | Ast_409.Asttypes.Upto -> Ast_408.Asttypes.Upto\n | Ast_409.Asttypes.Downto -> Ast_408.Asttypes.Downto\n\nand copy_cases : Ast_409.Parsetree.cases -> Ast_408.Parsetree.cases =\n fun x -> List.map copy_case x\n\nand copy_case : Ast_409.Parsetree.case -> Ast_408.Parsetree.case =\n fun {\n Ast_409.Parsetree.pc_lhs;\n Ast_409.Parsetree.pc_guard;\n Ast_409.Parsetree.pc_rhs;\n } ->\n {\n Ast_408.Parsetree.pc_lhs = copy_pattern pc_lhs;\n Ast_408.Parsetree.pc_guard = Option.map copy_expression pc_guard;\n Ast_408.Parsetree.pc_rhs = copy_expression pc_rhs;\n }\n\nand copy_value_binding :\n Ast_409.Parsetree.value_binding -> Ast_408.Parsetree.value_binding =\n fun {\n Ast_409.Parsetree.pvb_pat;\n Ast_409.Parsetree.pvb_expr;\n Ast_409.Parsetree.pvb_attributes;\n Ast_409.Parsetree.pvb_loc;\n } ->\n {\n Ast_408.Parsetree.pvb_pat = copy_pattern pvb_pat;\n Ast_408.Parsetree.pvb_expr = copy_expression pvb_expr;\n Ast_408.Parsetree.pvb_attributes = copy_attributes pvb_attributes;\n Ast_408.Parsetree.pvb_loc = copy_location pvb_loc;\n }\n\nand copy_pattern : Ast_409.Parsetree.pattern -> Ast_408.Parsetree.pattern =\n fun {\n Ast_409.Parsetree.ppat_desc;\n Ast_409.Parsetree.ppat_loc;\n Ast_409.Parsetree.ppat_loc_stack;\n Ast_409.Parsetree.ppat_attributes;\n } ->\n {\n Ast_408.Parsetree.ppat_desc = copy_pattern_desc ppat_desc;\n Ast_408.Parsetree.ppat_loc = copy_location ppat_loc;\n Ast_408.Parsetree.ppat_loc_stack = List.map copy_location ppat_loc_stack;\n Ast_408.Parsetree.ppat_attributes = copy_attributes ppat_attributes;\n }\n\nand copy_pattern_desc :\n Ast_409.Parsetree.pattern_desc -> Ast_408.Parsetree.pattern_desc = function\n | Ast_409.Parsetree.Ppat_any -> Ast_408.Parsetree.Ppat_any\n | Ast_409.Parsetree.Ppat_var x0 ->\n Ast_408.Parsetree.Ppat_var (copy_loc (fun x -> x) x0)\n | Ast_409.Parsetree.Ppat_alias (x0, x1) ->\n Ast_408.Parsetree.Ppat_alias (copy_pattern x0, copy_loc (fun x -> x) x1)\n | Ast_409.Parsetree.Ppat_constant x0 ->\n Ast_408.Parsetree.Ppat_constant (copy_constant x0)\n | Ast_409.Parsetree.Ppat_interval (x0, x1) ->\n Ast_408.Parsetree.Ppat_interval (copy_constant x0, copy_constant x1)\n | Ast_409.Parsetree.Ppat_tuple x0 ->\n Ast_408.Parsetree.Ppat_tuple (List.map copy_pattern x0)\n | Ast_409.Parsetree.Ppat_construct (x0, x1) ->\n Ast_408.Parsetree.Ppat_construct\n (copy_loc copy_Longident_t x0, Option.map copy_pattern x1)\n | Ast_409.Parsetree.Ppat_variant (x0, x1) ->\n Ast_408.Parsetree.Ppat_variant (copy_label x0, Option.map copy_pattern x1)\n | Ast_409.Parsetree.Ppat_record (x0, x1) ->\n Ast_408.Parsetree.Ppat_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_pattern x1))\n x0,\n copy_closed_flag x1 )\n | Ast_409.Parsetree.Ppat_array x0 ->\n Ast_408.Parsetree.Ppat_array (List.map copy_pattern x0)\n | Ast_409.Parsetree.Ppat_or (x0, x1) ->\n Ast_408.Parsetree.Ppat_or (copy_pattern x0, copy_pattern x1)\n | Ast_409.Parsetree.Ppat_constraint (x0, x1) ->\n Ast_408.Parsetree.Ppat_constraint (copy_pattern x0, copy_core_type x1)\n | Ast_409.Parsetree.Ppat_type x0 ->\n Ast_408.Parsetree.Ppat_type (copy_loc copy_Longident_t x0)\n | Ast_409.Parsetree.Ppat_lazy x0 ->\n Ast_408.Parsetree.Ppat_lazy (copy_pattern x0)\n | Ast_409.Parsetree.Ppat_unpack x0 ->\n Ast_408.Parsetree.Ppat_unpack (copy_loc (fun x -> x) x0)\n | Ast_409.Parsetree.Ppat_exception x0 ->\n Ast_408.Parsetree.Ppat_exception (copy_pattern x0)\n | Ast_409.Parsetree.Ppat_extension x0 ->\n Ast_408.Parsetree.Ppat_extension (copy_extension x0)\n | Ast_409.Parsetree.Ppat_open (x0, x1) ->\n Ast_408.Parsetree.Ppat_open (copy_loc copy_Longident_t x0, copy_pattern x1)\n\nand copy_core_type : Ast_409.Parsetree.core_type -> Ast_408.Parsetree.core_type\n =\n fun {\n Ast_409.Parsetree.ptyp_desc;\n Ast_409.Parsetree.ptyp_loc;\n Ast_409.Parsetree.ptyp_loc_stack;\n Ast_409.Parsetree.ptyp_attributes;\n } ->\n {\n Ast_408.Parsetree.ptyp_desc = copy_core_type_desc ptyp_desc;\n Ast_408.Parsetree.ptyp_loc = copy_location ptyp_loc;\n Ast_408.Parsetree.ptyp_loc_stack = List.map copy_location ptyp_loc_stack;\n Ast_408.Parsetree.ptyp_attributes = copy_attributes ptyp_attributes;\n }\n\nand copy_core_type_desc :\n Ast_409.Parsetree.core_type_desc -> Ast_408.Parsetree.core_type_desc =\n function\n | Ast_409.Parsetree.Ptyp_any -> Ast_408.Parsetree.Ptyp_any\n | Ast_409.Parsetree.Ptyp_var x0 -> Ast_408.Parsetree.Ptyp_var x0\n | Ast_409.Parsetree.Ptyp_arrow (x0, x1, x2) ->\n Ast_408.Parsetree.Ptyp_arrow\n (copy_arg_label x0, copy_core_type x1, copy_core_type x2)\n | Ast_409.Parsetree.Ptyp_tuple x0 ->\n Ast_408.Parsetree.Ptyp_tuple (List.map copy_core_type x0)\n | Ast_409.Parsetree.Ptyp_constr (x0, x1) ->\n Ast_408.Parsetree.Ptyp_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_409.Parsetree.Ptyp_object (x0, x1) ->\n Ast_408.Parsetree.Ptyp_object\n (List.map copy_object_field x0, copy_closed_flag x1)\n | Ast_409.Parsetree.Ptyp_class (x0, x1) ->\n Ast_408.Parsetree.Ptyp_class\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_409.Parsetree.Ptyp_alias (x0, x1) ->\n Ast_408.Parsetree.Ptyp_alias (copy_core_type x0, x1)\n | Ast_409.Parsetree.Ptyp_variant (x0, x1, x2) ->\n Ast_408.Parsetree.Ptyp_variant\n ( List.map copy_row_field x0,\n copy_closed_flag x1,\n Option.map (fun x -> List.map copy_label x) x2 )\n | Ast_409.Parsetree.Ptyp_poly (x0, x1) ->\n Ast_408.Parsetree.Ptyp_poly\n (List.map (fun x -> copy_loc (fun x -> x) x) x0, copy_core_type x1)\n | Ast_409.Parsetree.Ptyp_package x0 ->\n Ast_408.Parsetree.Ptyp_package (copy_package_type x0)\n | Ast_409.Parsetree.Ptyp_extension x0 ->\n Ast_408.Parsetree.Ptyp_extension (copy_extension x0)\n\nand copy_package_type :\n Ast_409.Parsetree.package_type -> Ast_408.Parsetree.package_type =\n fun x ->\n let x0, x1 = x in\n ( copy_loc copy_Longident_t x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_core_type x1))\n x1 )\n\nand copy_row_field : Ast_409.Parsetree.row_field -> Ast_408.Parsetree.row_field\n =\n fun {\n Ast_409.Parsetree.prf_desc;\n Ast_409.Parsetree.prf_loc;\n Ast_409.Parsetree.prf_attributes;\n } ->\n {\n Ast_408.Parsetree.prf_desc = copy_row_field_desc prf_desc;\n Ast_408.Parsetree.prf_loc = copy_location prf_loc;\n Ast_408.Parsetree.prf_attributes = copy_attributes prf_attributes;\n }\n\nand copy_row_field_desc :\n Ast_409.Parsetree.row_field_desc -> Ast_408.Parsetree.row_field_desc =\n function\n | Ast_409.Parsetree.Rtag (x0, x1, x2) ->\n Ast_408.Parsetree.Rtag\n (copy_loc copy_label x0, x1, List.map copy_core_type x2)\n | Ast_409.Parsetree.Rinherit x0 ->\n Ast_408.Parsetree.Rinherit (copy_core_type x0)\n\nand copy_object_field :\n Ast_409.Parsetree.object_field -> Ast_408.Parsetree.object_field =\n fun {\n Ast_409.Parsetree.pof_desc;\n Ast_409.Parsetree.pof_loc;\n Ast_409.Parsetree.pof_attributes;\n } ->\n {\n Ast_408.Parsetree.pof_desc = copy_object_field_desc pof_desc;\n Ast_408.Parsetree.pof_loc = copy_location pof_loc;\n Ast_408.Parsetree.pof_attributes = copy_attributes pof_attributes;\n }\n\nand copy_attributes :\n Ast_409.Parsetree.attributes -> Ast_408.Parsetree.attributes =\n fun x -> List.map copy_attribute x\n\nand copy_attribute : Ast_409.Parsetree.attribute -> Ast_408.Parsetree.attribute\n =\n fun {\n Ast_409.Parsetree.attr_name;\n Ast_409.Parsetree.attr_payload;\n Ast_409.Parsetree.attr_loc;\n } ->\n {\n Ast_408.Parsetree.attr_name = copy_loc (fun x -> x) attr_name;\n Ast_408.Parsetree.attr_payload = copy_payload attr_payload;\n Ast_408.Parsetree.attr_loc = copy_location attr_loc;\n }\n\nand copy_payload : Ast_409.Parsetree.payload -> Ast_408.Parsetree.payload =\n function\n | Ast_409.Parsetree.PStr x0 -> Ast_408.Parsetree.PStr (copy_structure x0)\n | Ast_409.Parsetree.PSig x0 -> Ast_408.Parsetree.PSig (copy_signature x0)\n | Ast_409.Parsetree.PTyp x0 -> Ast_408.Parsetree.PTyp (copy_core_type x0)\n | Ast_409.Parsetree.PPat (x0, x1) ->\n Ast_408.Parsetree.PPat (copy_pattern x0, Option.map copy_expression x1)\n\nand copy_structure : Ast_409.Parsetree.structure -> Ast_408.Parsetree.structure\n =\n fun x -> List.map copy_structure_item x\n\nand copy_structure_item :\n Ast_409.Parsetree.structure_item -> Ast_408.Parsetree.structure_item =\n fun { Ast_409.Parsetree.pstr_desc; Ast_409.Parsetree.pstr_loc } ->\n {\n Ast_408.Parsetree.pstr_desc = copy_structure_item_desc pstr_desc;\n Ast_408.Parsetree.pstr_loc = copy_location pstr_loc;\n }\n\nand copy_structure_item_desc :\n Ast_409.Parsetree.structure_item_desc ->\n Ast_408.Parsetree.structure_item_desc = function\n | Ast_409.Parsetree.Pstr_eval (x0, x1) ->\n Ast_408.Parsetree.Pstr_eval (copy_expression x0, copy_attributes x1)\n | Ast_409.Parsetree.Pstr_value (x0, x1) ->\n Ast_408.Parsetree.Pstr_value\n (copy_rec_flag x0, List.map copy_value_binding x1)\n | Ast_409.Parsetree.Pstr_primitive x0 ->\n Ast_408.Parsetree.Pstr_primitive (copy_value_description x0)\n | Ast_409.Parsetree.Pstr_type (x0, x1) ->\n Ast_408.Parsetree.Pstr_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | Ast_409.Parsetree.Pstr_typext x0 ->\n Ast_408.Parsetree.Pstr_typext (copy_type_extension x0)\n | Ast_409.Parsetree.Pstr_exception x0 ->\n Ast_408.Parsetree.Pstr_exception (copy_type_exception x0)\n | Ast_409.Parsetree.Pstr_module x0 ->\n Ast_408.Parsetree.Pstr_module (copy_module_binding x0)\n | Ast_409.Parsetree.Pstr_recmodule x0 ->\n Ast_408.Parsetree.Pstr_recmodule (List.map copy_module_binding x0)\n | Ast_409.Parsetree.Pstr_modtype x0 ->\n Ast_408.Parsetree.Pstr_modtype (copy_module_type_declaration x0)\n | Ast_409.Parsetree.Pstr_open x0 ->\n Ast_408.Parsetree.Pstr_open (copy_open_declaration x0)\n | Ast_409.Parsetree.Pstr_class x0 ->\n Ast_408.Parsetree.Pstr_class (List.map copy_class_declaration x0)\n | Ast_409.Parsetree.Pstr_class_type x0 ->\n Ast_408.Parsetree.Pstr_class_type\n (List.map copy_class_type_declaration x0)\n | Ast_409.Parsetree.Pstr_include x0 ->\n Ast_408.Parsetree.Pstr_include (copy_include_declaration x0)\n | Ast_409.Parsetree.Pstr_attribute x0 ->\n Ast_408.Parsetree.Pstr_attribute (copy_attribute x0)\n | Ast_409.Parsetree.Pstr_extension (x0, x1) ->\n Ast_408.Parsetree.Pstr_extension (copy_extension x0, copy_attributes x1)\n\nand copy_include_declaration :\n Ast_409.Parsetree.include_declaration ->\n Ast_408.Parsetree.include_declaration =\n fun x -> copy_include_infos copy_module_expr x\n\nand copy_class_declaration :\n Ast_409.Parsetree.class_declaration -> Ast_408.Parsetree.class_declaration =\n fun x -> copy_class_infos copy_class_expr x\n\nand copy_class_expr :\n Ast_409.Parsetree.class_expr -> Ast_408.Parsetree.class_expr =\n fun {\n Ast_409.Parsetree.pcl_desc;\n Ast_409.Parsetree.pcl_loc;\n Ast_409.Parsetree.pcl_attributes;\n } ->\n {\n Ast_408.Parsetree.pcl_desc = copy_class_expr_desc pcl_desc;\n Ast_408.Parsetree.pcl_loc = copy_location pcl_loc;\n Ast_408.Parsetree.pcl_attributes = copy_attributes pcl_attributes;\n }\n\nand copy_class_expr_desc :\n Ast_409.Parsetree.class_expr_desc -> Ast_408.Parsetree.class_expr_desc =\n function\n | Ast_409.Parsetree.Pcl_constr (x0, x1) ->\n Ast_408.Parsetree.Pcl_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_409.Parsetree.Pcl_structure x0 ->\n Ast_408.Parsetree.Pcl_structure (copy_class_structure x0)\n | Ast_409.Parsetree.Pcl_fun (x0, x1, x2, x3) ->\n Ast_408.Parsetree.Pcl_fun\n ( copy_arg_label x0,\n Option.map copy_expression x1,\n copy_pattern x2,\n copy_class_expr x3 )\n | Ast_409.Parsetree.Pcl_apply (x0, x1) ->\n Ast_408.Parsetree.Pcl_apply\n ( copy_class_expr x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | Ast_409.Parsetree.Pcl_let (x0, x1, x2) ->\n Ast_408.Parsetree.Pcl_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_class_expr x2)\n | Ast_409.Parsetree.Pcl_constraint (x0, x1) ->\n Ast_408.Parsetree.Pcl_constraint (copy_class_expr x0, copy_class_type x1)\n | Ast_409.Parsetree.Pcl_extension x0 ->\n Ast_408.Parsetree.Pcl_extension (copy_extension x0)\n | Ast_409.Parsetree.Pcl_open (x0, x1) ->\n Ast_408.Parsetree.Pcl_open (copy_open_description x0, copy_class_expr x1)\n\nand copy_class_structure :\n Ast_409.Parsetree.class_structure -> Ast_408.Parsetree.class_structure =\n fun { Ast_409.Parsetree.pcstr_self; Ast_409.Parsetree.pcstr_fields } ->\n {\n Ast_408.Parsetree.pcstr_self = copy_pattern pcstr_self;\n Ast_408.Parsetree.pcstr_fields = List.map copy_class_field pcstr_fields;\n }\n\nand copy_class_field :\n Ast_409.Parsetree.class_field -> Ast_408.Parsetree.class_field =\n fun {\n Ast_409.Parsetree.pcf_desc;\n Ast_409.Parsetree.pcf_loc;\n Ast_409.Parsetree.pcf_attributes;\n } ->\n {\n Ast_408.Parsetree.pcf_desc = copy_class_field_desc pcf_desc;\n Ast_408.Parsetree.pcf_loc = copy_location pcf_loc;\n Ast_408.Parsetree.pcf_attributes = copy_attributes pcf_attributes;\n }\n\nand copy_class_field_desc :\n Ast_409.Parsetree.class_field_desc -> Ast_408.Parsetree.class_field_desc =\n function\n | Ast_409.Parsetree.Pcf_inherit (x0, x1, x2) ->\n Ast_408.Parsetree.Pcf_inherit\n ( copy_override_flag x0,\n copy_class_expr x1,\n Option.map (fun x -> copy_loc (fun x -> x) x) x2 )\n | Ast_409.Parsetree.Pcf_val x0 ->\n Ast_408.Parsetree.Pcf_val\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_mutable_flag x1, copy_class_field_kind x2))\n | Ast_409.Parsetree.Pcf_method x0 ->\n Ast_408.Parsetree.Pcf_method\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_private_flag x1, copy_class_field_kind x2))\n | Ast_409.Parsetree.Pcf_constraint x0 ->\n Ast_408.Parsetree.Pcf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | Ast_409.Parsetree.Pcf_initializer x0 ->\n Ast_408.Parsetree.Pcf_initializer (copy_expression x0)\n | Ast_409.Parsetree.Pcf_attribute x0 ->\n Ast_408.Parsetree.Pcf_attribute (copy_attribute x0)\n | Ast_409.Parsetree.Pcf_extension x0 ->\n Ast_408.Parsetree.Pcf_extension (copy_extension x0)\n\nand copy_class_field_kind :\n Ast_409.Parsetree.class_field_kind -> Ast_408.Parsetree.class_field_kind =\n function\n | Ast_409.Parsetree.Cfk_virtual x0 ->\n Ast_408.Parsetree.Cfk_virtual (copy_core_type x0)\n | Ast_409.Parsetree.Cfk_concrete (x0, x1) ->\n Ast_408.Parsetree.Cfk_concrete (copy_override_flag x0, copy_expression x1)\n\nand copy_open_declaration :\n Ast_409.Parsetree.open_declaration -> Ast_408.Parsetree.open_declaration =\n fun x -> copy_open_infos copy_module_expr x\n\nand copy_module_binding :\n Ast_409.Parsetree.module_binding -> Ast_408.Parsetree.module_binding =\n fun {\n Ast_409.Parsetree.pmb_name;\n Ast_409.Parsetree.pmb_expr;\n Ast_409.Parsetree.pmb_attributes;\n Ast_409.Parsetree.pmb_loc;\n } ->\n {\n Ast_408.Parsetree.pmb_name = copy_loc (fun x -> x) pmb_name;\n Ast_408.Parsetree.pmb_expr = copy_module_expr pmb_expr;\n Ast_408.Parsetree.pmb_attributes = copy_attributes pmb_attributes;\n Ast_408.Parsetree.pmb_loc = copy_location pmb_loc;\n }\n\nand copy_module_expr :\n Ast_409.Parsetree.module_expr -> Ast_408.Parsetree.module_expr =\n fun {\n Ast_409.Parsetree.pmod_desc;\n Ast_409.Parsetree.pmod_loc;\n Ast_409.Parsetree.pmod_attributes;\n } ->\n {\n Ast_408.Parsetree.pmod_desc = copy_module_expr_desc pmod_desc;\n Ast_408.Parsetree.pmod_loc = copy_location pmod_loc;\n Ast_408.Parsetree.pmod_attributes = copy_attributes pmod_attributes;\n }\n\nand copy_module_expr_desc :\n Ast_409.Parsetree.module_expr_desc -> Ast_408.Parsetree.module_expr_desc =\n function\n | Ast_409.Parsetree.Pmod_ident x0 ->\n Ast_408.Parsetree.Pmod_ident (copy_loc copy_Longident_t x0)\n | Ast_409.Parsetree.Pmod_structure x0 ->\n Ast_408.Parsetree.Pmod_structure (copy_structure x0)\n | Ast_409.Parsetree.Pmod_functor (x0, x1, x2) ->\n Ast_408.Parsetree.Pmod_functor\n ( copy_loc (fun x -> x) x0,\n Option.map copy_module_type x1,\n copy_module_expr x2 )\n | Ast_409.Parsetree.Pmod_apply (x0, x1) ->\n Ast_408.Parsetree.Pmod_apply (copy_module_expr x0, copy_module_expr x1)\n | Ast_409.Parsetree.Pmod_constraint (x0, x1) ->\n Ast_408.Parsetree.Pmod_constraint\n (copy_module_expr x0, copy_module_type x1)\n | Ast_409.Parsetree.Pmod_unpack x0 ->\n Ast_408.Parsetree.Pmod_unpack (copy_expression x0)\n | Ast_409.Parsetree.Pmod_extension x0 ->\n Ast_408.Parsetree.Pmod_extension (copy_extension x0)\n\nand copy_module_type :\n Ast_409.Parsetree.module_type -> Ast_408.Parsetree.module_type =\n fun {\n Ast_409.Parsetree.pmty_desc;\n Ast_409.Parsetree.pmty_loc;\n Ast_409.Parsetree.pmty_attributes;\n } ->\n {\n Ast_408.Parsetree.pmty_desc = copy_module_type_desc pmty_desc;\n Ast_408.Parsetree.pmty_loc = copy_location pmty_loc;\n Ast_408.Parsetree.pmty_attributes = copy_attributes pmty_attributes;\n }\n\nand copy_module_type_desc :\n Ast_409.Parsetree.module_type_desc -> Ast_408.Parsetree.module_type_desc =\n function\n | Ast_409.Parsetree.Pmty_ident x0 ->\n Ast_408.Parsetree.Pmty_ident (copy_loc copy_Longident_t x0)\n | Ast_409.Parsetree.Pmty_signature x0 ->\n Ast_408.Parsetree.Pmty_signature (copy_signature x0)\n | Ast_409.Parsetree.Pmty_functor (x0, x1, x2) ->\n Ast_408.Parsetree.Pmty_functor\n ( copy_loc (fun x -> x) x0,\n Option.map copy_module_type x1,\n copy_module_type x2 )\n | Ast_409.Parsetree.Pmty_with (x0, x1) ->\n Ast_408.Parsetree.Pmty_with\n (copy_module_type x0, List.map copy_with_constraint x1)\n | Ast_409.Parsetree.Pmty_typeof x0 ->\n Ast_408.Parsetree.Pmty_typeof (copy_module_expr x0)\n | Ast_409.Parsetree.Pmty_extension x0 ->\n Ast_408.Parsetree.Pmty_extension (copy_extension x0)\n | Ast_409.Parsetree.Pmty_alias x0 ->\n Ast_408.Parsetree.Pmty_alias (copy_loc copy_Longident_t x0)\n\nand copy_with_constraint :\n Ast_409.Parsetree.with_constraint -> Ast_408.Parsetree.with_constraint =\n function\n | Ast_409.Parsetree.Pwith_type (x0, x1) ->\n Ast_408.Parsetree.Pwith_type\n (copy_loc copy_Longident_t x0, copy_type_declaration x1)\n | Ast_409.Parsetree.Pwith_module (x0, x1) ->\n Ast_408.Parsetree.Pwith_module\n (copy_loc copy_Longident_t x0, copy_loc copy_Longident_t x1)\n | Ast_409.Parsetree.Pwith_typesubst (x0, x1) ->\n Ast_408.Parsetree.Pwith_typesubst\n (copy_loc copy_Longident_t x0, copy_type_declaration x1)\n | Ast_409.Parsetree.Pwith_modsubst (x0, x1) ->\n Ast_408.Parsetree.Pwith_modsubst\n (copy_loc copy_Longident_t x0, copy_loc copy_Longident_t x1)\n\nand copy_signature : Ast_409.Parsetree.signature -> Ast_408.Parsetree.signature\n =\n fun x -> List.map copy_signature_item x\n\nand copy_signature_item :\n Ast_409.Parsetree.signature_item -> Ast_408.Parsetree.signature_item =\n fun { Ast_409.Parsetree.psig_desc; Ast_409.Parsetree.psig_loc } ->\n {\n Ast_408.Parsetree.psig_desc = copy_signature_item_desc psig_desc;\n Ast_408.Parsetree.psig_loc = copy_location psig_loc;\n }\n\nand copy_signature_item_desc :\n Ast_409.Parsetree.signature_item_desc ->\n Ast_408.Parsetree.signature_item_desc = function\n | Ast_409.Parsetree.Psig_value x0 ->\n Ast_408.Parsetree.Psig_value (copy_value_description x0)\n | Ast_409.Parsetree.Psig_type (x0, x1) ->\n Ast_408.Parsetree.Psig_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | Ast_409.Parsetree.Psig_typesubst x0 ->\n Ast_408.Parsetree.Psig_typesubst (List.map copy_type_declaration x0)\n | Ast_409.Parsetree.Psig_typext x0 ->\n Ast_408.Parsetree.Psig_typext (copy_type_extension x0)\n | Ast_409.Parsetree.Psig_exception x0 ->\n Ast_408.Parsetree.Psig_exception (copy_type_exception x0)\n | Ast_409.Parsetree.Psig_module x0 ->\n Ast_408.Parsetree.Psig_module (copy_module_declaration x0)\n | Ast_409.Parsetree.Psig_modsubst x0 ->\n Ast_408.Parsetree.Psig_modsubst (copy_module_substitution x0)\n | Ast_409.Parsetree.Psig_recmodule x0 ->\n Ast_408.Parsetree.Psig_recmodule (List.map copy_module_declaration x0)\n | Ast_409.Parsetree.Psig_modtype x0 ->\n Ast_408.Parsetree.Psig_modtype (copy_module_type_declaration x0)\n | Ast_409.Parsetree.Psig_open x0 ->\n Ast_408.Parsetree.Psig_open (copy_open_description x0)\n | Ast_409.Parsetree.Psig_include x0 ->\n Ast_408.Parsetree.Psig_include (copy_include_description x0)\n | Ast_409.Parsetree.Psig_class x0 ->\n Ast_408.Parsetree.Psig_class (List.map copy_class_description x0)\n | Ast_409.Parsetree.Psig_class_type x0 ->\n Ast_408.Parsetree.Psig_class_type\n (List.map copy_class_type_declaration x0)\n | Ast_409.Parsetree.Psig_attribute x0 ->\n Ast_408.Parsetree.Psig_attribute (copy_attribute x0)\n | Ast_409.Parsetree.Psig_extension (x0, x1) ->\n Ast_408.Parsetree.Psig_extension (copy_extension x0, copy_attributes x1)\n\nand copy_class_type_declaration :\n Ast_409.Parsetree.class_type_declaration ->\n Ast_408.Parsetree.class_type_declaration =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_description :\n Ast_409.Parsetree.class_description -> Ast_408.Parsetree.class_description =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_type :\n Ast_409.Parsetree.class_type -> Ast_408.Parsetree.class_type =\n fun {\n Ast_409.Parsetree.pcty_desc;\n Ast_409.Parsetree.pcty_loc;\n Ast_409.Parsetree.pcty_attributes;\n } ->\n {\n Ast_408.Parsetree.pcty_desc = copy_class_type_desc pcty_desc;\n Ast_408.Parsetree.pcty_loc = copy_location pcty_loc;\n Ast_408.Parsetree.pcty_attributes = copy_attributes pcty_attributes;\n }\n\nand copy_class_type_desc :\n Ast_409.Parsetree.class_type_desc -> Ast_408.Parsetree.class_type_desc =\n function\n | Ast_409.Parsetree.Pcty_constr (x0, x1) ->\n Ast_408.Parsetree.Pcty_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_409.Parsetree.Pcty_signature x0 ->\n Ast_408.Parsetree.Pcty_signature (copy_class_signature x0)\n | Ast_409.Parsetree.Pcty_arrow (x0, x1, x2) ->\n Ast_408.Parsetree.Pcty_arrow\n (copy_arg_label x0, copy_core_type x1, copy_class_type x2)\n | Ast_409.Parsetree.Pcty_extension x0 ->\n Ast_408.Parsetree.Pcty_extension (copy_extension x0)\n | Ast_409.Parsetree.Pcty_open (x0, x1) ->\n Ast_408.Parsetree.Pcty_open (copy_open_description x0, copy_class_type x1)\n\nand copy_class_signature :\n Ast_409.Parsetree.class_signature -> Ast_408.Parsetree.class_signature =\n fun { Ast_409.Parsetree.pcsig_self; Ast_409.Parsetree.pcsig_fields } ->\n {\n Ast_408.Parsetree.pcsig_self = copy_core_type pcsig_self;\n Ast_408.Parsetree.pcsig_fields = List.map copy_class_type_field pcsig_fields;\n }\n\nand copy_class_type_field :\n Ast_409.Parsetree.class_type_field -> Ast_408.Parsetree.class_type_field =\n fun {\n Ast_409.Parsetree.pctf_desc;\n Ast_409.Parsetree.pctf_loc;\n Ast_409.Parsetree.pctf_attributes;\n } ->\n {\n Ast_408.Parsetree.pctf_desc = copy_class_type_field_desc pctf_desc;\n Ast_408.Parsetree.pctf_loc = copy_location pctf_loc;\n Ast_408.Parsetree.pctf_attributes = copy_attributes pctf_attributes;\n }\n\nand copy_class_type_field_desc :\n Ast_409.Parsetree.class_type_field_desc ->\n Ast_408.Parsetree.class_type_field_desc = function\n | Ast_409.Parsetree.Pctf_inherit x0 ->\n Ast_408.Parsetree.Pctf_inherit (copy_class_type x0)\n | Ast_409.Parsetree.Pctf_val x0 ->\n Ast_408.Parsetree.Pctf_val\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_mutable_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | Ast_409.Parsetree.Pctf_method x0 ->\n Ast_408.Parsetree.Pctf_method\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_private_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | Ast_409.Parsetree.Pctf_constraint x0 ->\n Ast_408.Parsetree.Pctf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | Ast_409.Parsetree.Pctf_attribute x0 ->\n Ast_408.Parsetree.Pctf_attribute (copy_attribute x0)\n | Ast_409.Parsetree.Pctf_extension x0 ->\n Ast_408.Parsetree.Pctf_extension (copy_extension x0)\n\nand copy_extension : Ast_409.Parsetree.extension -> Ast_408.Parsetree.extension\n =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_class_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_409.Parsetree.class_infos ->\n 'g0 Ast_408.Parsetree.class_infos =\n fun f0\n {\n Ast_409.Parsetree.pci_virt;\n Ast_409.Parsetree.pci_params;\n Ast_409.Parsetree.pci_name;\n Ast_409.Parsetree.pci_expr;\n Ast_409.Parsetree.pci_loc;\n Ast_409.Parsetree.pci_attributes;\n } ->\n {\n Ast_408.Parsetree.pci_virt = copy_virtual_flag pci_virt;\n Ast_408.Parsetree.pci_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n pci_params;\n Ast_408.Parsetree.pci_name = copy_loc (fun x -> x) pci_name;\n Ast_408.Parsetree.pci_expr = f0 pci_expr;\n Ast_408.Parsetree.pci_loc = copy_location pci_loc;\n Ast_408.Parsetree.pci_attributes = copy_attributes pci_attributes;\n }\n\nand copy_virtual_flag :\n Ast_409.Asttypes.virtual_flag -> Ast_408.Asttypes.virtual_flag = function\n | Ast_409.Asttypes.Virtual -> Ast_408.Asttypes.Virtual\n | Ast_409.Asttypes.Concrete -> Ast_408.Asttypes.Concrete\n\nand copy_include_description :\n Ast_409.Parsetree.include_description ->\n Ast_408.Parsetree.include_description =\n fun x -> copy_include_infos copy_module_type x\n\nand copy_include_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_409.Parsetree.include_infos ->\n 'g0 Ast_408.Parsetree.include_infos =\n fun f0\n {\n Ast_409.Parsetree.pincl_mod;\n Ast_409.Parsetree.pincl_loc;\n Ast_409.Parsetree.pincl_attributes;\n } ->\n {\n Ast_408.Parsetree.pincl_mod = f0 pincl_mod;\n Ast_408.Parsetree.pincl_loc = copy_location pincl_loc;\n Ast_408.Parsetree.pincl_attributes = copy_attributes pincl_attributes;\n }\n\nand copy_open_description :\n Ast_409.Parsetree.open_description -> Ast_408.Parsetree.open_description =\n fun x -> copy_open_infos (fun x -> copy_loc copy_Longident_t x) x\n\nand copy_open_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_409.Parsetree.open_infos ->\n 'g0 Ast_408.Parsetree.open_infos =\n fun f0\n {\n Ast_409.Parsetree.popen_expr;\n Ast_409.Parsetree.popen_override;\n Ast_409.Parsetree.popen_loc;\n Ast_409.Parsetree.popen_attributes;\n } ->\n {\n Ast_408.Parsetree.popen_expr = f0 popen_expr;\n Ast_408.Parsetree.popen_override = copy_override_flag popen_override;\n Ast_408.Parsetree.popen_loc = copy_location popen_loc;\n Ast_408.Parsetree.popen_attributes = copy_attributes popen_attributes;\n }\n\nand copy_override_flag :\n Ast_409.Asttypes.override_flag -> Ast_408.Asttypes.override_flag = function\n | Ast_409.Asttypes.Override -> Ast_408.Asttypes.Override\n | Ast_409.Asttypes.Fresh -> Ast_408.Asttypes.Fresh\n\nand copy_module_type_declaration :\n Ast_409.Parsetree.module_type_declaration ->\n Ast_408.Parsetree.module_type_declaration =\n fun {\n Ast_409.Parsetree.pmtd_name;\n Ast_409.Parsetree.pmtd_type;\n Ast_409.Parsetree.pmtd_attributes;\n Ast_409.Parsetree.pmtd_loc;\n } ->\n {\n Ast_408.Parsetree.pmtd_name = copy_loc (fun x -> x) pmtd_name;\n Ast_408.Parsetree.pmtd_type = Option.map copy_module_type pmtd_type;\n Ast_408.Parsetree.pmtd_attributes = copy_attributes pmtd_attributes;\n Ast_408.Parsetree.pmtd_loc = copy_location pmtd_loc;\n }\n\nand copy_module_substitution :\n Ast_409.Parsetree.module_substitution ->\n Ast_408.Parsetree.module_substitution =\n fun {\n Ast_409.Parsetree.pms_name;\n Ast_409.Parsetree.pms_manifest;\n Ast_409.Parsetree.pms_attributes;\n Ast_409.Parsetree.pms_loc;\n } ->\n {\n Ast_408.Parsetree.pms_name = copy_loc (fun x -> x) pms_name;\n Ast_408.Parsetree.pms_manifest = copy_loc copy_Longident_t pms_manifest;\n Ast_408.Parsetree.pms_attributes = copy_attributes pms_attributes;\n Ast_408.Parsetree.pms_loc = copy_location pms_loc;\n }\n\nand copy_module_declaration :\n Ast_409.Parsetree.module_declaration -> Ast_408.Parsetree.module_declaration\n =\n fun {\n Ast_409.Parsetree.pmd_name;\n Ast_409.Parsetree.pmd_type;\n Ast_409.Parsetree.pmd_attributes;\n Ast_409.Parsetree.pmd_loc;\n } ->\n {\n Ast_408.Parsetree.pmd_name = copy_loc (fun x -> x) pmd_name;\n Ast_408.Parsetree.pmd_type = copy_module_type pmd_type;\n Ast_408.Parsetree.pmd_attributes = copy_attributes pmd_attributes;\n Ast_408.Parsetree.pmd_loc = copy_location pmd_loc;\n }\n\nand copy_type_exception :\n Ast_409.Parsetree.type_exception -> Ast_408.Parsetree.type_exception =\n fun {\n Ast_409.Parsetree.ptyexn_constructor;\n Ast_409.Parsetree.ptyexn_loc;\n Ast_409.Parsetree.ptyexn_attributes;\n } ->\n {\n Ast_408.Parsetree.ptyexn_constructor =\n copy_extension_constructor ptyexn_constructor;\n Ast_408.Parsetree.ptyexn_loc = copy_location ptyexn_loc;\n Ast_408.Parsetree.ptyexn_attributes = copy_attributes ptyexn_attributes;\n }\n\nand copy_type_extension :\n Ast_409.Parsetree.type_extension -> Ast_408.Parsetree.type_extension =\n fun {\n Ast_409.Parsetree.ptyext_path;\n Ast_409.Parsetree.ptyext_params;\n Ast_409.Parsetree.ptyext_constructors;\n Ast_409.Parsetree.ptyext_private;\n Ast_409.Parsetree.ptyext_loc;\n Ast_409.Parsetree.ptyext_attributes;\n } ->\n {\n Ast_408.Parsetree.ptyext_path = copy_loc copy_Longident_t ptyext_path;\n Ast_408.Parsetree.ptyext_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptyext_params;\n Ast_408.Parsetree.ptyext_constructors =\n List.map copy_extension_constructor ptyext_constructors;\n Ast_408.Parsetree.ptyext_private = copy_private_flag ptyext_private;\n Ast_408.Parsetree.ptyext_loc = copy_location ptyext_loc;\n Ast_408.Parsetree.ptyext_attributes = copy_attributes ptyext_attributes;\n }\n\nand copy_extension_constructor :\n Ast_409.Parsetree.extension_constructor ->\n Ast_408.Parsetree.extension_constructor =\n fun {\n Ast_409.Parsetree.pext_name;\n Ast_409.Parsetree.pext_kind;\n Ast_409.Parsetree.pext_loc;\n Ast_409.Parsetree.pext_attributes;\n } ->\n {\n Ast_408.Parsetree.pext_name = copy_loc (fun x -> x) pext_name;\n Ast_408.Parsetree.pext_kind = copy_extension_constructor_kind pext_kind;\n Ast_408.Parsetree.pext_loc = copy_location pext_loc;\n Ast_408.Parsetree.pext_attributes = copy_attributes pext_attributes;\n }\n\nand copy_extension_constructor_kind :\n Ast_409.Parsetree.extension_constructor_kind ->\n Ast_408.Parsetree.extension_constructor_kind = function\n | Ast_409.Parsetree.Pext_decl (x0, x1) ->\n Ast_408.Parsetree.Pext_decl\n (copy_constructor_arguments x0, Option.map copy_core_type x1)\n | Ast_409.Parsetree.Pext_rebind x0 ->\n Ast_408.Parsetree.Pext_rebind (copy_loc copy_Longident_t x0)\n\nand copy_type_declaration :\n Ast_409.Parsetree.type_declaration -> Ast_408.Parsetree.type_declaration =\n fun {\n Ast_409.Parsetree.ptype_name;\n Ast_409.Parsetree.ptype_params;\n Ast_409.Parsetree.ptype_cstrs;\n Ast_409.Parsetree.ptype_kind;\n Ast_409.Parsetree.ptype_private;\n Ast_409.Parsetree.ptype_manifest;\n Ast_409.Parsetree.ptype_attributes;\n Ast_409.Parsetree.ptype_loc;\n } ->\n {\n Ast_408.Parsetree.ptype_name = copy_loc (fun x -> x) ptype_name;\n Ast_408.Parsetree.ptype_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptype_params;\n Ast_408.Parsetree.ptype_cstrs =\n List.map\n (fun x ->\n let x0, x1, x2 = x in\n (copy_core_type x0, copy_core_type x1, copy_location x2))\n ptype_cstrs;\n Ast_408.Parsetree.ptype_kind = copy_type_kind ptype_kind;\n Ast_408.Parsetree.ptype_private = copy_private_flag ptype_private;\n Ast_408.Parsetree.ptype_manifest = Option.map copy_core_type ptype_manifest;\n Ast_408.Parsetree.ptype_attributes = copy_attributes ptype_attributes;\n Ast_408.Parsetree.ptype_loc = copy_location ptype_loc;\n }\n\nand copy_private_flag :\n Ast_409.Asttypes.private_flag -> Ast_408.Asttypes.private_flag = function\n | Ast_409.Asttypes.Private -> Ast_408.Asttypes.Private\n | Ast_409.Asttypes.Public -> Ast_408.Asttypes.Public\n\nand copy_type_kind : Ast_409.Parsetree.type_kind -> Ast_408.Parsetree.type_kind\n = function\n | Ast_409.Parsetree.Ptype_abstract -> Ast_408.Parsetree.Ptype_abstract\n | Ast_409.Parsetree.Ptype_variant x0 ->\n Ast_408.Parsetree.Ptype_variant (List.map copy_constructor_declaration x0)\n | Ast_409.Parsetree.Ptype_record x0 ->\n Ast_408.Parsetree.Ptype_record (List.map copy_label_declaration x0)\n | Ast_409.Parsetree.Ptype_open -> Ast_408.Parsetree.Ptype_open\n\nand copy_constructor_declaration :\n Ast_409.Parsetree.constructor_declaration ->\n Ast_408.Parsetree.constructor_declaration =\n fun {\n Ast_409.Parsetree.pcd_name;\n Ast_409.Parsetree.pcd_args;\n Ast_409.Parsetree.pcd_res;\n Ast_409.Parsetree.pcd_loc;\n Ast_409.Parsetree.pcd_attributes;\n } ->\n {\n Ast_408.Parsetree.pcd_name = copy_loc (fun x -> x) pcd_name;\n Ast_408.Parsetree.pcd_args = copy_constructor_arguments pcd_args;\n Ast_408.Parsetree.pcd_res = Option.map copy_core_type pcd_res;\n Ast_408.Parsetree.pcd_loc = copy_location pcd_loc;\n Ast_408.Parsetree.pcd_attributes = copy_attributes pcd_attributes;\n }\n\nand copy_constructor_arguments :\n Ast_409.Parsetree.constructor_arguments ->\n Ast_408.Parsetree.constructor_arguments = function\n | Ast_409.Parsetree.Pcstr_tuple x0 ->\n Ast_408.Parsetree.Pcstr_tuple (List.map copy_core_type x0)\n | Ast_409.Parsetree.Pcstr_record x0 ->\n Ast_408.Parsetree.Pcstr_record (List.map copy_label_declaration x0)\n\nand copy_label_declaration :\n Ast_409.Parsetree.label_declaration -> Ast_408.Parsetree.label_declaration =\n fun {\n Ast_409.Parsetree.pld_name;\n Ast_409.Parsetree.pld_mutable;\n Ast_409.Parsetree.pld_type;\n Ast_409.Parsetree.pld_loc;\n Ast_409.Parsetree.pld_attributes;\n } ->\n {\n Ast_408.Parsetree.pld_name = copy_loc (fun x -> x) pld_name;\n Ast_408.Parsetree.pld_mutable = copy_mutable_flag pld_mutable;\n Ast_408.Parsetree.pld_type = copy_core_type pld_type;\n Ast_408.Parsetree.pld_loc = copy_location pld_loc;\n Ast_408.Parsetree.pld_attributes = copy_attributes pld_attributes;\n }\n\nand copy_mutable_flag :\n Ast_409.Asttypes.mutable_flag -> Ast_408.Asttypes.mutable_flag = function\n | Ast_409.Asttypes.Immutable -> Ast_408.Asttypes.Immutable\n | Ast_409.Asttypes.Mutable -> Ast_408.Asttypes.Mutable\n\nand copy_variance : Ast_409.Asttypes.variance -> Ast_408.Asttypes.variance =\n function\n | Ast_409.Asttypes.Covariant -> Ast_408.Asttypes.Covariant\n | Ast_409.Asttypes.Contravariant -> Ast_408.Asttypes.Contravariant\n | Ast_409.Asttypes.Invariant -> Ast_408.Asttypes.Invariant\n\nand copy_value_description :\n Ast_409.Parsetree.value_description -> Ast_408.Parsetree.value_description =\n fun {\n Ast_409.Parsetree.pval_name;\n Ast_409.Parsetree.pval_type;\n Ast_409.Parsetree.pval_prim;\n Ast_409.Parsetree.pval_attributes;\n Ast_409.Parsetree.pval_loc;\n } ->\n {\n Ast_408.Parsetree.pval_name = copy_loc (fun x -> x) pval_name;\n Ast_408.Parsetree.pval_type = copy_core_type pval_type;\n Ast_408.Parsetree.pval_prim = List.map (fun x -> x) pval_prim;\n Ast_408.Parsetree.pval_attributes = copy_attributes pval_attributes;\n Ast_408.Parsetree.pval_loc = copy_location pval_loc;\n }\n\nand copy_object_field_desc :\n Ast_409.Parsetree.object_field_desc -> Ast_408.Parsetree.object_field_desc =\n function\n | Ast_409.Parsetree.Otag (x0, x1) ->\n Ast_408.Parsetree.Otag (copy_loc copy_label x0, copy_core_type x1)\n | Ast_409.Parsetree.Oinherit x0 ->\n Ast_408.Parsetree.Oinherit (copy_core_type x0)\n\nand copy_arg_label : Ast_409.Asttypes.arg_label -> Ast_408.Asttypes.arg_label =\n function\n | Ast_409.Asttypes.Nolabel -> Ast_408.Asttypes.Nolabel\n | Ast_409.Asttypes.Labelled x0 -> Ast_408.Asttypes.Labelled x0\n | Ast_409.Asttypes.Optional x0 -> Ast_408.Asttypes.Optional x0\n\nand copy_closed_flag :\n Ast_409.Asttypes.closed_flag -> Ast_408.Asttypes.closed_flag = function\n | Ast_409.Asttypes.Closed -> Ast_408.Asttypes.Closed\n | Ast_409.Asttypes.Open -> Ast_408.Asttypes.Open\n\nand copy_label : Ast_409.Asttypes.label -> Ast_408.Asttypes.label = fun x -> x\n\nand copy_rec_flag : Ast_409.Asttypes.rec_flag -> Ast_408.Asttypes.rec_flag =\n function\n | Ast_409.Asttypes.Nonrecursive -> Ast_408.Asttypes.Nonrecursive\n | Ast_409.Asttypes.Recursive -> Ast_408.Asttypes.Recursive\n\nand copy_constant : Ast_409.Parsetree.constant -> Ast_408.Parsetree.constant =\n function\n | Ast_409.Parsetree.Pconst_integer (x0, x1) ->\n Ast_408.Parsetree.Pconst_integer (x0, Option.map (fun x -> x) x1)\n | Ast_409.Parsetree.Pconst_char x0 -> Ast_408.Parsetree.Pconst_char x0\n | Ast_409.Parsetree.Pconst_string (x0, x1) ->\n Ast_408.Parsetree.Pconst_string (x0, Option.map (fun x -> x) x1)\n | Ast_409.Parsetree.Pconst_float (x0, x1) ->\n Ast_408.Parsetree.Pconst_float (x0, Option.map (fun x -> x) x1)\n\nand copy_Longident_t : Longident.t -> Longident.t = fun x -> x\n\nand copy_loc :\n 'f0 'g0.\n ('f0 -> 'g0) -> 'f0 Ast_409.Asttypes.loc -> 'g0 Ast_408.Asttypes.loc =\n fun f0 { Ast_409.Asttypes.txt; Ast_409.Asttypes.loc } ->\n { Ast_408.Asttypes.txt = f0 txt; Ast_408.Asttypes.loc = copy_location loc }\n\nand copy_location : Location.t -> Location.t = fun x -> x\n","open Stdlib0\nmodule From = Ast_408\nmodule To = Ast_409\n\nlet rec copy_toplevel_phrase :\n Ast_408.Parsetree.toplevel_phrase -> Ast_409.Parsetree.toplevel_phrase =\n function\n | Ast_408.Parsetree.Ptop_def x0 ->\n Ast_409.Parsetree.Ptop_def (copy_structure x0)\n | Ast_408.Parsetree.Ptop_dir x0 ->\n Ast_409.Parsetree.Ptop_dir (copy_toplevel_directive x0)\n\nand copy_toplevel_directive :\n Ast_408.Parsetree.toplevel_directive -> Ast_409.Parsetree.toplevel_directive\n =\n fun {\n Ast_408.Parsetree.pdir_name;\n Ast_408.Parsetree.pdir_arg;\n Ast_408.Parsetree.pdir_loc;\n } ->\n {\n Ast_409.Parsetree.pdir_name = copy_loc (fun x -> x) pdir_name;\n Ast_409.Parsetree.pdir_arg = Option.map copy_directive_argument pdir_arg;\n Ast_409.Parsetree.pdir_loc = copy_location pdir_loc;\n }\n\nand copy_directive_argument :\n Ast_408.Parsetree.directive_argument -> Ast_409.Parsetree.directive_argument\n =\n fun { Ast_408.Parsetree.pdira_desc; Ast_408.Parsetree.pdira_loc } ->\n {\n Ast_409.Parsetree.pdira_desc = copy_directive_argument_desc pdira_desc;\n Ast_409.Parsetree.pdira_loc = copy_location pdira_loc;\n }\n\nand copy_directive_argument_desc :\n Ast_408.Parsetree.directive_argument_desc ->\n Ast_409.Parsetree.directive_argument_desc = function\n | Ast_408.Parsetree.Pdir_string x0 -> Ast_409.Parsetree.Pdir_string x0\n | Ast_408.Parsetree.Pdir_int (x0, x1) ->\n Ast_409.Parsetree.Pdir_int (x0, Option.map (fun x -> x) x1)\n | Ast_408.Parsetree.Pdir_ident x0 ->\n Ast_409.Parsetree.Pdir_ident (copy_Longident_t x0)\n | Ast_408.Parsetree.Pdir_bool x0 -> Ast_409.Parsetree.Pdir_bool x0\n\nand copy_typ : Ast_408.Parsetree.typ -> Ast_409.Parsetree.typ =\n fun x -> copy_core_type x\n\nand copy_pat : Ast_408.Parsetree.pat -> Ast_409.Parsetree.pat =\n fun x -> copy_pattern x\n\nand copy_expr : Ast_408.Parsetree.expr -> Ast_409.Parsetree.expr =\n fun x -> copy_expression x\n\nand copy_expression :\n Ast_408.Parsetree.expression -> Ast_409.Parsetree.expression =\n fun {\n Ast_408.Parsetree.pexp_desc;\n Ast_408.Parsetree.pexp_loc;\n Ast_408.Parsetree.pexp_loc_stack;\n Ast_408.Parsetree.pexp_attributes;\n } ->\n {\n Ast_409.Parsetree.pexp_desc = copy_expression_desc pexp_desc;\n Ast_409.Parsetree.pexp_loc = copy_location pexp_loc;\n Ast_409.Parsetree.pexp_loc_stack = List.map copy_location pexp_loc_stack;\n Ast_409.Parsetree.pexp_attributes = copy_attributes pexp_attributes;\n }\n\nand copy_expression_desc :\n Ast_408.Parsetree.expression_desc -> Ast_409.Parsetree.expression_desc =\n function\n | Ast_408.Parsetree.Pexp_ident x0 ->\n Ast_409.Parsetree.Pexp_ident (copy_loc copy_Longident_t x0)\n | Ast_408.Parsetree.Pexp_constant x0 ->\n Ast_409.Parsetree.Pexp_constant (copy_constant x0)\n | Ast_408.Parsetree.Pexp_let (x0, x1, x2) ->\n Ast_409.Parsetree.Pexp_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_expression x2)\n | Ast_408.Parsetree.Pexp_function x0 ->\n Ast_409.Parsetree.Pexp_function (copy_cases x0)\n | Ast_408.Parsetree.Pexp_fun (x0, x1, x2, x3) ->\n Ast_409.Parsetree.Pexp_fun\n ( copy_arg_label x0,\n Option.map copy_expression x1,\n copy_pattern x2,\n copy_expression x3 )\n | Ast_408.Parsetree.Pexp_apply (x0, x1) ->\n Ast_409.Parsetree.Pexp_apply\n ( copy_expression x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | Ast_408.Parsetree.Pexp_match (x0, x1) ->\n Ast_409.Parsetree.Pexp_match (copy_expression x0, copy_cases x1)\n | Ast_408.Parsetree.Pexp_try (x0, x1) ->\n Ast_409.Parsetree.Pexp_try (copy_expression x0, copy_cases x1)\n | Ast_408.Parsetree.Pexp_tuple x0 ->\n Ast_409.Parsetree.Pexp_tuple (List.map copy_expression x0)\n | Ast_408.Parsetree.Pexp_construct (x0, x1) ->\n Ast_409.Parsetree.Pexp_construct\n (copy_loc copy_Longident_t x0, Option.map copy_expression x1)\n | Ast_408.Parsetree.Pexp_variant (x0, x1) ->\n Ast_409.Parsetree.Pexp_variant\n (copy_label x0, Option.map copy_expression x1)\n | Ast_408.Parsetree.Pexp_record (x0, x1) ->\n Ast_409.Parsetree.Pexp_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_expression x1))\n x0,\n Option.map copy_expression x1 )\n | Ast_408.Parsetree.Pexp_field (x0, x1) ->\n Ast_409.Parsetree.Pexp_field\n (copy_expression x0, copy_loc copy_Longident_t x1)\n | Ast_408.Parsetree.Pexp_setfield (x0, x1, x2) ->\n Ast_409.Parsetree.Pexp_setfield\n (copy_expression x0, copy_loc copy_Longident_t x1, copy_expression x2)\n | Ast_408.Parsetree.Pexp_array x0 ->\n Ast_409.Parsetree.Pexp_array (List.map copy_expression x0)\n | Ast_408.Parsetree.Pexp_ifthenelse (x0, x1, x2) ->\n Ast_409.Parsetree.Pexp_ifthenelse\n (copy_expression x0, copy_expression x1, Option.map copy_expression x2)\n | Ast_408.Parsetree.Pexp_sequence (x0, x1) ->\n Ast_409.Parsetree.Pexp_sequence (copy_expression x0, copy_expression x1)\n | Ast_408.Parsetree.Pexp_while (x0, x1) ->\n Ast_409.Parsetree.Pexp_while (copy_expression x0, copy_expression x1)\n | Ast_408.Parsetree.Pexp_for (x0, x1, x2, x3, x4) ->\n Ast_409.Parsetree.Pexp_for\n ( copy_pattern x0,\n copy_expression x1,\n copy_expression x2,\n copy_direction_flag x3,\n copy_expression x4 )\n | Ast_408.Parsetree.Pexp_constraint (x0, x1) ->\n Ast_409.Parsetree.Pexp_constraint (copy_expression x0, copy_core_type x1)\n | Ast_408.Parsetree.Pexp_coerce (x0, x1, x2) ->\n Ast_409.Parsetree.Pexp_coerce\n (copy_expression x0, Option.map copy_core_type x1, copy_core_type x2)\n | Ast_408.Parsetree.Pexp_send (x0, x1) ->\n Ast_409.Parsetree.Pexp_send (copy_expression x0, copy_loc copy_label x1)\n | Ast_408.Parsetree.Pexp_new x0 ->\n Ast_409.Parsetree.Pexp_new (copy_loc copy_Longident_t x0)\n | Ast_408.Parsetree.Pexp_setinstvar (x0, x1) ->\n Ast_409.Parsetree.Pexp_setinstvar\n (copy_loc copy_label x0, copy_expression x1)\n | Ast_408.Parsetree.Pexp_override x0 ->\n Ast_409.Parsetree.Pexp_override\n (List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_label x0, copy_expression x1))\n x0)\n | Ast_408.Parsetree.Pexp_letmodule (x0, x1, x2) ->\n Ast_409.Parsetree.Pexp_letmodule\n (copy_loc (fun x -> x) x0, copy_module_expr x1, copy_expression x2)\n | Ast_408.Parsetree.Pexp_letexception (x0, x1) ->\n Ast_409.Parsetree.Pexp_letexception\n (copy_extension_constructor x0, copy_expression x1)\n | Ast_408.Parsetree.Pexp_assert x0 ->\n Ast_409.Parsetree.Pexp_assert (copy_expression x0)\n | Ast_408.Parsetree.Pexp_lazy x0 ->\n Ast_409.Parsetree.Pexp_lazy (copy_expression x0)\n | Ast_408.Parsetree.Pexp_poly (x0, x1) ->\n Ast_409.Parsetree.Pexp_poly\n (copy_expression x0, Option.map copy_core_type x1)\n | Ast_408.Parsetree.Pexp_object x0 ->\n Ast_409.Parsetree.Pexp_object (copy_class_structure x0)\n | Ast_408.Parsetree.Pexp_newtype (x0, x1) ->\n Ast_409.Parsetree.Pexp_newtype\n (copy_loc (fun x -> x) x0, copy_expression x1)\n | Ast_408.Parsetree.Pexp_pack x0 ->\n Ast_409.Parsetree.Pexp_pack (copy_module_expr x0)\n | Ast_408.Parsetree.Pexp_open (x0, x1) ->\n Ast_409.Parsetree.Pexp_open (copy_open_declaration x0, copy_expression x1)\n | Ast_408.Parsetree.Pexp_letop x0 ->\n Ast_409.Parsetree.Pexp_letop (copy_letop x0)\n | Ast_408.Parsetree.Pexp_extension x0 ->\n Ast_409.Parsetree.Pexp_extension (copy_extension x0)\n | Ast_408.Parsetree.Pexp_unreachable -> Ast_409.Parsetree.Pexp_unreachable\n\nand copy_letop : Ast_408.Parsetree.letop -> Ast_409.Parsetree.letop =\n fun { Ast_408.Parsetree.let_; Ast_408.Parsetree.ands; Ast_408.Parsetree.body } ->\n {\n Ast_409.Parsetree.let_ = copy_binding_op let_;\n Ast_409.Parsetree.ands = List.map copy_binding_op ands;\n Ast_409.Parsetree.body = copy_expression body;\n }\n\nand copy_binding_op :\n Ast_408.Parsetree.binding_op -> Ast_409.Parsetree.binding_op =\n fun {\n Ast_408.Parsetree.pbop_op;\n Ast_408.Parsetree.pbop_pat;\n Ast_408.Parsetree.pbop_exp;\n Ast_408.Parsetree.pbop_loc;\n } ->\n {\n Ast_409.Parsetree.pbop_op = copy_loc (fun x -> x) pbop_op;\n Ast_409.Parsetree.pbop_pat = copy_pattern pbop_pat;\n Ast_409.Parsetree.pbop_exp = copy_expression pbop_exp;\n Ast_409.Parsetree.pbop_loc = copy_location pbop_loc;\n }\n\nand copy_direction_flag :\n Ast_408.Asttypes.direction_flag -> Ast_409.Asttypes.direction_flag =\n function\n | Ast_408.Asttypes.Upto -> Ast_409.Asttypes.Upto\n | Ast_408.Asttypes.Downto -> Ast_409.Asttypes.Downto\n\nand copy_cases : Ast_408.Parsetree.cases -> Ast_409.Parsetree.cases =\n fun x -> List.map copy_case x\n\nand copy_case : Ast_408.Parsetree.case -> Ast_409.Parsetree.case =\n fun {\n Ast_408.Parsetree.pc_lhs;\n Ast_408.Parsetree.pc_guard;\n Ast_408.Parsetree.pc_rhs;\n } ->\n {\n Ast_409.Parsetree.pc_lhs = copy_pattern pc_lhs;\n Ast_409.Parsetree.pc_guard = Option.map copy_expression pc_guard;\n Ast_409.Parsetree.pc_rhs = copy_expression pc_rhs;\n }\n\nand copy_value_binding :\n Ast_408.Parsetree.value_binding -> Ast_409.Parsetree.value_binding =\n fun {\n Ast_408.Parsetree.pvb_pat;\n Ast_408.Parsetree.pvb_expr;\n Ast_408.Parsetree.pvb_attributes;\n Ast_408.Parsetree.pvb_loc;\n } ->\n {\n Ast_409.Parsetree.pvb_pat = copy_pattern pvb_pat;\n Ast_409.Parsetree.pvb_expr = copy_expression pvb_expr;\n Ast_409.Parsetree.pvb_attributes = copy_attributes pvb_attributes;\n Ast_409.Parsetree.pvb_loc = copy_location pvb_loc;\n }\n\nand copy_pattern : Ast_408.Parsetree.pattern -> Ast_409.Parsetree.pattern =\n fun {\n Ast_408.Parsetree.ppat_desc;\n Ast_408.Parsetree.ppat_loc;\n Ast_408.Parsetree.ppat_loc_stack;\n Ast_408.Parsetree.ppat_attributes;\n } ->\n {\n Ast_409.Parsetree.ppat_desc = copy_pattern_desc ppat_desc;\n Ast_409.Parsetree.ppat_loc = copy_location ppat_loc;\n Ast_409.Parsetree.ppat_loc_stack = List.map copy_location ppat_loc_stack;\n Ast_409.Parsetree.ppat_attributes = copy_attributes ppat_attributes;\n }\n\nand copy_pattern_desc :\n Ast_408.Parsetree.pattern_desc -> Ast_409.Parsetree.pattern_desc = function\n | Ast_408.Parsetree.Ppat_any -> Ast_409.Parsetree.Ppat_any\n | Ast_408.Parsetree.Ppat_var x0 ->\n Ast_409.Parsetree.Ppat_var (copy_loc (fun x -> x) x0)\n | Ast_408.Parsetree.Ppat_alias (x0, x1) ->\n Ast_409.Parsetree.Ppat_alias (copy_pattern x0, copy_loc (fun x -> x) x1)\n | Ast_408.Parsetree.Ppat_constant x0 ->\n Ast_409.Parsetree.Ppat_constant (copy_constant x0)\n | Ast_408.Parsetree.Ppat_interval (x0, x1) ->\n Ast_409.Parsetree.Ppat_interval (copy_constant x0, copy_constant x1)\n | Ast_408.Parsetree.Ppat_tuple x0 ->\n Ast_409.Parsetree.Ppat_tuple (List.map copy_pattern x0)\n | Ast_408.Parsetree.Ppat_construct (x0, x1) ->\n Ast_409.Parsetree.Ppat_construct\n (copy_loc copy_Longident_t x0, Option.map copy_pattern x1)\n | Ast_408.Parsetree.Ppat_variant (x0, x1) ->\n Ast_409.Parsetree.Ppat_variant (copy_label x0, Option.map copy_pattern x1)\n | Ast_408.Parsetree.Ppat_record (x0, x1) ->\n Ast_409.Parsetree.Ppat_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_pattern x1))\n x0,\n copy_closed_flag x1 )\n | Ast_408.Parsetree.Ppat_array x0 ->\n Ast_409.Parsetree.Ppat_array (List.map copy_pattern x0)\n | Ast_408.Parsetree.Ppat_or (x0, x1) ->\n Ast_409.Parsetree.Ppat_or (copy_pattern x0, copy_pattern x1)\n | Ast_408.Parsetree.Ppat_constraint (x0, x1) ->\n Ast_409.Parsetree.Ppat_constraint (copy_pattern x0, copy_core_type x1)\n | Ast_408.Parsetree.Ppat_type x0 ->\n Ast_409.Parsetree.Ppat_type (copy_loc copy_Longident_t x0)\n | Ast_408.Parsetree.Ppat_lazy x0 ->\n Ast_409.Parsetree.Ppat_lazy (copy_pattern x0)\n | Ast_408.Parsetree.Ppat_unpack x0 ->\n Ast_409.Parsetree.Ppat_unpack (copy_loc (fun x -> x) x0)\n | Ast_408.Parsetree.Ppat_exception x0 ->\n Ast_409.Parsetree.Ppat_exception (copy_pattern x0)\n | Ast_408.Parsetree.Ppat_extension x0 ->\n Ast_409.Parsetree.Ppat_extension (copy_extension x0)\n | Ast_408.Parsetree.Ppat_open (x0, x1) ->\n Ast_409.Parsetree.Ppat_open (copy_loc copy_Longident_t x0, copy_pattern x1)\n\nand copy_core_type : Ast_408.Parsetree.core_type -> Ast_409.Parsetree.core_type\n =\n fun {\n Ast_408.Parsetree.ptyp_desc;\n Ast_408.Parsetree.ptyp_loc;\n Ast_408.Parsetree.ptyp_loc_stack;\n Ast_408.Parsetree.ptyp_attributes;\n } ->\n {\n Ast_409.Parsetree.ptyp_desc = copy_core_type_desc ptyp_desc;\n Ast_409.Parsetree.ptyp_loc = copy_location ptyp_loc;\n Ast_409.Parsetree.ptyp_loc_stack = List.map copy_location ptyp_loc_stack;\n Ast_409.Parsetree.ptyp_attributes = copy_attributes ptyp_attributes;\n }\n\nand copy_core_type_desc :\n Ast_408.Parsetree.core_type_desc -> Ast_409.Parsetree.core_type_desc =\n function\n | Ast_408.Parsetree.Ptyp_any -> Ast_409.Parsetree.Ptyp_any\n | Ast_408.Parsetree.Ptyp_var x0 -> Ast_409.Parsetree.Ptyp_var x0\n | Ast_408.Parsetree.Ptyp_arrow (x0, x1, x2) ->\n Ast_409.Parsetree.Ptyp_arrow\n (copy_arg_label x0, copy_core_type x1, copy_core_type x2)\n | Ast_408.Parsetree.Ptyp_tuple x0 ->\n Ast_409.Parsetree.Ptyp_tuple (List.map copy_core_type x0)\n | Ast_408.Parsetree.Ptyp_constr (x0, x1) ->\n Ast_409.Parsetree.Ptyp_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_408.Parsetree.Ptyp_object (x0, x1) ->\n Ast_409.Parsetree.Ptyp_object\n (List.map copy_object_field x0, copy_closed_flag x1)\n | Ast_408.Parsetree.Ptyp_class (x0, x1) ->\n Ast_409.Parsetree.Ptyp_class\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_408.Parsetree.Ptyp_alias (x0, x1) ->\n Ast_409.Parsetree.Ptyp_alias (copy_core_type x0, x1)\n | Ast_408.Parsetree.Ptyp_variant (x0, x1, x2) ->\n Ast_409.Parsetree.Ptyp_variant\n ( List.map copy_row_field x0,\n copy_closed_flag x1,\n Option.map (fun x -> List.map copy_label x) x2 )\n | Ast_408.Parsetree.Ptyp_poly (x0, x1) ->\n Ast_409.Parsetree.Ptyp_poly\n (List.map (fun x -> copy_loc (fun x -> x) x) x0, copy_core_type x1)\n | Ast_408.Parsetree.Ptyp_package x0 ->\n Ast_409.Parsetree.Ptyp_package (copy_package_type x0)\n | Ast_408.Parsetree.Ptyp_extension x0 ->\n Ast_409.Parsetree.Ptyp_extension (copy_extension x0)\n\nand copy_package_type :\n Ast_408.Parsetree.package_type -> Ast_409.Parsetree.package_type =\n fun x ->\n let x0, x1 = x in\n ( copy_loc copy_Longident_t x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_Longident_t x0, copy_core_type x1))\n x1 )\n\nand copy_row_field : Ast_408.Parsetree.row_field -> Ast_409.Parsetree.row_field\n =\n fun {\n Ast_408.Parsetree.prf_desc;\n Ast_408.Parsetree.prf_loc;\n Ast_408.Parsetree.prf_attributes;\n } ->\n {\n Ast_409.Parsetree.prf_desc = copy_row_field_desc prf_desc;\n Ast_409.Parsetree.prf_loc = copy_location prf_loc;\n Ast_409.Parsetree.prf_attributes = copy_attributes prf_attributes;\n }\n\nand copy_row_field_desc :\n Ast_408.Parsetree.row_field_desc -> Ast_409.Parsetree.row_field_desc =\n function\n | Ast_408.Parsetree.Rtag (x0, x1, x2) ->\n Ast_409.Parsetree.Rtag\n (copy_loc copy_label x0, x1, List.map copy_core_type x2)\n | Ast_408.Parsetree.Rinherit x0 ->\n Ast_409.Parsetree.Rinherit (copy_core_type x0)\n\nand copy_object_field :\n Ast_408.Parsetree.object_field -> Ast_409.Parsetree.object_field =\n fun {\n Ast_408.Parsetree.pof_desc;\n Ast_408.Parsetree.pof_loc;\n Ast_408.Parsetree.pof_attributes;\n } ->\n {\n Ast_409.Parsetree.pof_desc = copy_object_field_desc pof_desc;\n Ast_409.Parsetree.pof_loc = copy_location pof_loc;\n Ast_409.Parsetree.pof_attributes = copy_attributes pof_attributes;\n }\n\nand copy_attributes :\n Ast_408.Parsetree.attributes -> Ast_409.Parsetree.attributes =\n fun x -> List.map copy_attribute x\n\nand copy_attribute : Ast_408.Parsetree.attribute -> Ast_409.Parsetree.attribute\n =\n fun {\n Ast_408.Parsetree.attr_name;\n Ast_408.Parsetree.attr_payload;\n Ast_408.Parsetree.attr_loc;\n } ->\n {\n Ast_409.Parsetree.attr_name = copy_loc (fun x -> x) attr_name;\n Ast_409.Parsetree.attr_payload = copy_payload attr_payload;\n Ast_409.Parsetree.attr_loc = copy_location attr_loc;\n }\n\nand copy_payload : Ast_408.Parsetree.payload -> Ast_409.Parsetree.payload =\n function\n | Ast_408.Parsetree.PStr x0 -> Ast_409.Parsetree.PStr (copy_structure x0)\n | Ast_408.Parsetree.PSig x0 -> Ast_409.Parsetree.PSig (copy_signature x0)\n | Ast_408.Parsetree.PTyp x0 -> Ast_409.Parsetree.PTyp (copy_core_type x0)\n | Ast_408.Parsetree.PPat (x0, x1) ->\n Ast_409.Parsetree.PPat (copy_pattern x0, Option.map copy_expression x1)\n\nand copy_structure : Ast_408.Parsetree.structure -> Ast_409.Parsetree.structure\n =\n fun x -> List.map copy_structure_item x\n\nand copy_structure_item :\n Ast_408.Parsetree.structure_item -> Ast_409.Parsetree.structure_item =\n fun { Ast_408.Parsetree.pstr_desc; Ast_408.Parsetree.pstr_loc } ->\n {\n Ast_409.Parsetree.pstr_desc = copy_structure_item_desc pstr_desc;\n Ast_409.Parsetree.pstr_loc = copy_location pstr_loc;\n }\n\nand copy_structure_item_desc :\n Ast_408.Parsetree.structure_item_desc ->\n Ast_409.Parsetree.structure_item_desc = function\n | Ast_408.Parsetree.Pstr_eval (x0, x1) ->\n Ast_409.Parsetree.Pstr_eval (copy_expression x0, copy_attributes x1)\n | Ast_408.Parsetree.Pstr_value (x0, x1) ->\n Ast_409.Parsetree.Pstr_value\n (copy_rec_flag x0, List.map copy_value_binding x1)\n | Ast_408.Parsetree.Pstr_primitive x0 ->\n Ast_409.Parsetree.Pstr_primitive (copy_value_description x0)\n | Ast_408.Parsetree.Pstr_type (x0, x1) ->\n Ast_409.Parsetree.Pstr_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | Ast_408.Parsetree.Pstr_typext x0 ->\n Ast_409.Parsetree.Pstr_typext (copy_type_extension x0)\n | Ast_408.Parsetree.Pstr_exception x0 ->\n Ast_409.Parsetree.Pstr_exception (copy_type_exception x0)\n | Ast_408.Parsetree.Pstr_module x0 ->\n Ast_409.Parsetree.Pstr_module (copy_module_binding x0)\n | Ast_408.Parsetree.Pstr_recmodule x0 ->\n Ast_409.Parsetree.Pstr_recmodule (List.map copy_module_binding x0)\n | Ast_408.Parsetree.Pstr_modtype x0 ->\n Ast_409.Parsetree.Pstr_modtype (copy_module_type_declaration x0)\n | Ast_408.Parsetree.Pstr_open x0 ->\n Ast_409.Parsetree.Pstr_open (copy_open_declaration x0)\n | Ast_408.Parsetree.Pstr_class x0 ->\n Ast_409.Parsetree.Pstr_class (List.map copy_class_declaration x0)\n | Ast_408.Parsetree.Pstr_class_type x0 ->\n Ast_409.Parsetree.Pstr_class_type\n (List.map copy_class_type_declaration x0)\n | Ast_408.Parsetree.Pstr_include x0 ->\n Ast_409.Parsetree.Pstr_include (copy_include_declaration x0)\n | Ast_408.Parsetree.Pstr_attribute x0 ->\n Ast_409.Parsetree.Pstr_attribute (copy_attribute x0)\n | Ast_408.Parsetree.Pstr_extension (x0, x1) ->\n Ast_409.Parsetree.Pstr_extension (copy_extension x0, copy_attributes x1)\n\nand copy_include_declaration :\n Ast_408.Parsetree.include_declaration ->\n Ast_409.Parsetree.include_declaration =\n fun x -> copy_include_infos copy_module_expr x\n\nand copy_class_declaration :\n Ast_408.Parsetree.class_declaration -> Ast_409.Parsetree.class_declaration =\n fun x -> copy_class_infos copy_class_expr x\n\nand copy_class_expr :\n Ast_408.Parsetree.class_expr -> Ast_409.Parsetree.class_expr =\n fun {\n Ast_408.Parsetree.pcl_desc;\n Ast_408.Parsetree.pcl_loc;\n Ast_408.Parsetree.pcl_attributes;\n } ->\n {\n Ast_409.Parsetree.pcl_desc = copy_class_expr_desc pcl_desc;\n Ast_409.Parsetree.pcl_loc = copy_location pcl_loc;\n Ast_409.Parsetree.pcl_attributes = copy_attributes pcl_attributes;\n }\n\nand copy_class_expr_desc :\n Ast_408.Parsetree.class_expr_desc -> Ast_409.Parsetree.class_expr_desc =\n function\n | Ast_408.Parsetree.Pcl_constr (x0, x1) ->\n Ast_409.Parsetree.Pcl_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_408.Parsetree.Pcl_structure x0 ->\n Ast_409.Parsetree.Pcl_structure (copy_class_structure x0)\n | Ast_408.Parsetree.Pcl_fun (x0, x1, x2, x3) ->\n Ast_409.Parsetree.Pcl_fun\n ( copy_arg_label x0,\n Option.map copy_expression x1,\n copy_pattern x2,\n copy_class_expr x3 )\n | Ast_408.Parsetree.Pcl_apply (x0, x1) ->\n Ast_409.Parsetree.Pcl_apply\n ( copy_class_expr x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | Ast_408.Parsetree.Pcl_let (x0, x1, x2) ->\n Ast_409.Parsetree.Pcl_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_class_expr x2)\n | Ast_408.Parsetree.Pcl_constraint (x0, x1) ->\n Ast_409.Parsetree.Pcl_constraint (copy_class_expr x0, copy_class_type x1)\n | Ast_408.Parsetree.Pcl_extension x0 ->\n Ast_409.Parsetree.Pcl_extension (copy_extension x0)\n | Ast_408.Parsetree.Pcl_open (x0, x1) ->\n Ast_409.Parsetree.Pcl_open (copy_open_description x0, copy_class_expr x1)\n\nand copy_class_structure :\n Ast_408.Parsetree.class_structure -> Ast_409.Parsetree.class_structure =\n fun { Ast_408.Parsetree.pcstr_self; Ast_408.Parsetree.pcstr_fields } ->\n {\n Ast_409.Parsetree.pcstr_self = copy_pattern pcstr_self;\n Ast_409.Parsetree.pcstr_fields = List.map copy_class_field pcstr_fields;\n }\n\nand copy_class_field :\n Ast_408.Parsetree.class_field -> Ast_409.Parsetree.class_field =\n fun {\n Ast_408.Parsetree.pcf_desc;\n Ast_408.Parsetree.pcf_loc;\n Ast_408.Parsetree.pcf_attributes;\n } ->\n {\n Ast_409.Parsetree.pcf_desc = copy_class_field_desc pcf_desc;\n Ast_409.Parsetree.pcf_loc = copy_location pcf_loc;\n Ast_409.Parsetree.pcf_attributes = copy_attributes pcf_attributes;\n }\n\nand copy_class_field_desc :\n Ast_408.Parsetree.class_field_desc -> Ast_409.Parsetree.class_field_desc =\n function\n | Ast_408.Parsetree.Pcf_inherit (x0, x1, x2) ->\n Ast_409.Parsetree.Pcf_inherit\n ( copy_override_flag x0,\n copy_class_expr x1,\n Option.map (fun x -> copy_loc (fun x -> x) x) x2 )\n | Ast_408.Parsetree.Pcf_val x0 ->\n Ast_409.Parsetree.Pcf_val\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_mutable_flag x1, copy_class_field_kind x2))\n | Ast_408.Parsetree.Pcf_method x0 ->\n Ast_409.Parsetree.Pcf_method\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_private_flag x1, copy_class_field_kind x2))\n | Ast_408.Parsetree.Pcf_constraint x0 ->\n Ast_409.Parsetree.Pcf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | Ast_408.Parsetree.Pcf_initializer x0 ->\n Ast_409.Parsetree.Pcf_initializer (copy_expression x0)\n | Ast_408.Parsetree.Pcf_attribute x0 ->\n Ast_409.Parsetree.Pcf_attribute (copy_attribute x0)\n | Ast_408.Parsetree.Pcf_extension x0 ->\n Ast_409.Parsetree.Pcf_extension (copy_extension x0)\n\nand copy_class_field_kind :\n Ast_408.Parsetree.class_field_kind -> Ast_409.Parsetree.class_field_kind =\n function\n | Ast_408.Parsetree.Cfk_virtual x0 ->\n Ast_409.Parsetree.Cfk_virtual (copy_core_type x0)\n | Ast_408.Parsetree.Cfk_concrete (x0, x1) ->\n Ast_409.Parsetree.Cfk_concrete (copy_override_flag x0, copy_expression x1)\n\nand copy_open_declaration :\n Ast_408.Parsetree.open_declaration -> Ast_409.Parsetree.open_declaration =\n fun x -> copy_open_infos copy_module_expr x\n\nand copy_module_binding :\n Ast_408.Parsetree.module_binding -> Ast_409.Parsetree.module_binding =\n fun {\n Ast_408.Parsetree.pmb_name;\n Ast_408.Parsetree.pmb_expr;\n Ast_408.Parsetree.pmb_attributes;\n Ast_408.Parsetree.pmb_loc;\n } ->\n {\n Ast_409.Parsetree.pmb_name = copy_loc (fun x -> x) pmb_name;\n Ast_409.Parsetree.pmb_expr = copy_module_expr pmb_expr;\n Ast_409.Parsetree.pmb_attributes = copy_attributes pmb_attributes;\n Ast_409.Parsetree.pmb_loc = copy_location pmb_loc;\n }\n\nand copy_module_expr :\n Ast_408.Parsetree.module_expr -> Ast_409.Parsetree.module_expr =\n fun {\n Ast_408.Parsetree.pmod_desc;\n Ast_408.Parsetree.pmod_loc;\n Ast_408.Parsetree.pmod_attributes;\n } ->\n {\n Ast_409.Parsetree.pmod_desc = copy_module_expr_desc pmod_desc;\n Ast_409.Parsetree.pmod_loc = copy_location pmod_loc;\n Ast_409.Parsetree.pmod_attributes = copy_attributes pmod_attributes;\n }\n\nand copy_module_expr_desc :\n Ast_408.Parsetree.module_expr_desc -> Ast_409.Parsetree.module_expr_desc =\n function\n | Ast_408.Parsetree.Pmod_ident x0 ->\n Ast_409.Parsetree.Pmod_ident (copy_loc copy_Longident_t x0)\n | Ast_408.Parsetree.Pmod_structure x0 ->\n Ast_409.Parsetree.Pmod_structure (copy_structure x0)\n | Ast_408.Parsetree.Pmod_functor (x0, x1, x2) ->\n Ast_409.Parsetree.Pmod_functor\n ( copy_loc (fun x -> x) x0,\n Option.map copy_module_type x1,\n copy_module_expr x2 )\n | Ast_408.Parsetree.Pmod_apply (x0, x1) ->\n Ast_409.Parsetree.Pmod_apply (copy_module_expr x0, copy_module_expr x1)\n | Ast_408.Parsetree.Pmod_constraint (x0, x1) ->\n Ast_409.Parsetree.Pmod_constraint\n (copy_module_expr x0, copy_module_type x1)\n | Ast_408.Parsetree.Pmod_unpack x0 ->\n Ast_409.Parsetree.Pmod_unpack (copy_expression x0)\n | Ast_408.Parsetree.Pmod_extension x0 ->\n Ast_409.Parsetree.Pmod_extension (copy_extension x0)\n\nand copy_module_type :\n Ast_408.Parsetree.module_type -> Ast_409.Parsetree.module_type =\n fun {\n Ast_408.Parsetree.pmty_desc;\n Ast_408.Parsetree.pmty_loc;\n Ast_408.Parsetree.pmty_attributes;\n } ->\n {\n Ast_409.Parsetree.pmty_desc = copy_module_type_desc pmty_desc;\n Ast_409.Parsetree.pmty_loc = copy_location pmty_loc;\n Ast_409.Parsetree.pmty_attributes = copy_attributes pmty_attributes;\n }\n\nand copy_module_type_desc :\n Ast_408.Parsetree.module_type_desc -> Ast_409.Parsetree.module_type_desc =\n function\n | Ast_408.Parsetree.Pmty_ident x0 ->\n Ast_409.Parsetree.Pmty_ident (copy_loc copy_Longident_t x0)\n | Ast_408.Parsetree.Pmty_signature x0 ->\n Ast_409.Parsetree.Pmty_signature (copy_signature x0)\n | Ast_408.Parsetree.Pmty_functor (x0, x1, x2) ->\n Ast_409.Parsetree.Pmty_functor\n ( copy_loc (fun x -> x) x0,\n Option.map copy_module_type x1,\n copy_module_type x2 )\n | Ast_408.Parsetree.Pmty_with (x0, x1) ->\n Ast_409.Parsetree.Pmty_with\n (copy_module_type x0, List.map copy_with_constraint x1)\n | Ast_408.Parsetree.Pmty_typeof x0 ->\n Ast_409.Parsetree.Pmty_typeof (copy_module_expr x0)\n | Ast_408.Parsetree.Pmty_extension x0 ->\n Ast_409.Parsetree.Pmty_extension (copy_extension x0)\n | Ast_408.Parsetree.Pmty_alias x0 ->\n Ast_409.Parsetree.Pmty_alias (copy_loc copy_Longident_t x0)\n\nand copy_with_constraint :\n Ast_408.Parsetree.with_constraint -> Ast_409.Parsetree.with_constraint =\n function\n | Ast_408.Parsetree.Pwith_type (x0, x1) ->\n Ast_409.Parsetree.Pwith_type\n (copy_loc copy_Longident_t x0, copy_type_declaration x1)\n | Ast_408.Parsetree.Pwith_module (x0, x1) ->\n Ast_409.Parsetree.Pwith_module\n (copy_loc copy_Longident_t x0, copy_loc copy_Longident_t x1)\n | Ast_408.Parsetree.Pwith_typesubst (x0, x1) ->\n Ast_409.Parsetree.Pwith_typesubst\n (copy_loc copy_Longident_t x0, copy_type_declaration x1)\n | Ast_408.Parsetree.Pwith_modsubst (x0, x1) ->\n Ast_409.Parsetree.Pwith_modsubst\n (copy_loc copy_Longident_t x0, copy_loc copy_Longident_t x1)\n\nand copy_signature : Ast_408.Parsetree.signature -> Ast_409.Parsetree.signature\n =\n fun x -> List.map copy_signature_item x\n\nand copy_signature_item :\n Ast_408.Parsetree.signature_item -> Ast_409.Parsetree.signature_item =\n fun { Ast_408.Parsetree.psig_desc; Ast_408.Parsetree.psig_loc } ->\n {\n Ast_409.Parsetree.psig_desc = copy_signature_item_desc psig_desc;\n Ast_409.Parsetree.psig_loc = copy_location psig_loc;\n }\n\nand copy_signature_item_desc :\n Ast_408.Parsetree.signature_item_desc ->\n Ast_409.Parsetree.signature_item_desc = function\n | Ast_408.Parsetree.Psig_value x0 ->\n Ast_409.Parsetree.Psig_value (copy_value_description x0)\n | Ast_408.Parsetree.Psig_type (x0, x1) ->\n Ast_409.Parsetree.Psig_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | Ast_408.Parsetree.Psig_typesubst x0 ->\n Ast_409.Parsetree.Psig_typesubst (List.map copy_type_declaration x0)\n | Ast_408.Parsetree.Psig_typext x0 ->\n Ast_409.Parsetree.Psig_typext (copy_type_extension x0)\n | Ast_408.Parsetree.Psig_exception x0 ->\n Ast_409.Parsetree.Psig_exception (copy_type_exception x0)\n | Ast_408.Parsetree.Psig_module x0 ->\n Ast_409.Parsetree.Psig_module (copy_module_declaration x0)\n | Ast_408.Parsetree.Psig_modsubst x0 ->\n Ast_409.Parsetree.Psig_modsubst (copy_module_substitution x0)\n | Ast_408.Parsetree.Psig_recmodule x0 ->\n Ast_409.Parsetree.Psig_recmodule (List.map copy_module_declaration x0)\n | Ast_408.Parsetree.Psig_modtype x0 ->\n Ast_409.Parsetree.Psig_modtype (copy_module_type_declaration x0)\n | Ast_408.Parsetree.Psig_open x0 ->\n Ast_409.Parsetree.Psig_open (copy_open_description x0)\n | Ast_408.Parsetree.Psig_include x0 ->\n Ast_409.Parsetree.Psig_include (copy_include_description x0)\n | Ast_408.Parsetree.Psig_class x0 ->\n Ast_409.Parsetree.Psig_class (List.map copy_class_description x0)\n | Ast_408.Parsetree.Psig_class_type x0 ->\n Ast_409.Parsetree.Psig_class_type\n (List.map copy_class_type_declaration x0)\n | Ast_408.Parsetree.Psig_attribute x0 ->\n Ast_409.Parsetree.Psig_attribute (copy_attribute x0)\n | Ast_408.Parsetree.Psig_extension (x0, x1) ->\n Ast_409.Parsetree.Psig_extension (copy_extension x0, copy_attributes x1)\n\nand copy_class_type_declaration :\n Ast_408.Parsetree.class_type_declaration ->\n Ast_409.Parsetree.class_type_declaration =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_description :\n Ast_408.Parsetree.class_description -> Ast_409.Parsetree.class_description =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_type :\n Ast_408.Parsetree.class_type -> Ast_409.Parsetree.class_type =\n fun {\n Ast_408.Parsetree.pcty_desc;\n Ast_408.Parsetree.pcty_loc;\n Ast_408.Parsetree.pcty_attributes;\n } ->\n {\n Ast_409.Parsetree.pcty_desc = copy_class_type_desc pcty_desc;\n Ast_409.Parsetree.pcty_loc = copy_location pcty_loc;\n Ast_409.Parsetree.pcty_attributes = copy_attributes pcty_attributes;\n }\n\nand copy_class_type_desc :\n Ast_408.Parsetree.class_type_desc -> Ast_409.Parsetree.class_type_desc =\n function\n | Ast_408.Parsetree.Pcty_constr (x0, x1) ->\n Ast_409.Parsetree.Pcty_constr\n (copy_loc copy_Longident_t x0, List.map copy_core_type x1)\n | Ast_408.Parsetree.Pcty_signature x0 ->\n Ast_409.Parsetree.Pcty_signature (copy_class_signature x0)\n | Ast_408.Parsetree.Pcty_arrow (x0, x1, x2) ->\n Ast_409.Parsetree.Pcty_arrow\n (copy_arg_label x0, copy_core_type x1, copy_class_type x2)\n | Ast_408.Parsetree.Pcty_extension x0 ->\n Ast_409.Parsetree.Pcty_extension (copy_extension x0)\n | Ast_408.Parsetree.Pcty_open (x0, x1) ->\n Ast_409.Parsetree.Pcty_open (copy_open_description x0, copy_class_type x1)\n\nand copy_class_signature :\n Ast_408.Parsetree.class_signature -> Ast_409.Parsetree.class_signature =\n fun { Ast_408.Parsetree.pcsig_self; Ast_408.Parsetree.pcsig_fields } ->\n {\n Ast_409.Parsetree.pcsig_self = copy_core_type pcsig_self;\n Ast_409.Parsetree.pcsig_fields = List.map copy_class_type_field pcsig_fields;\n }\n\nand copy_class_type_field :\n Ast_408.Parsetree.class_type_field -> Ast_409.Parsetree.class_type_field =\n fun {\n Ast_408.Parsetree.pctf_desc;\n Ast_408.Parsetree.pctf_loc;\n Ast_408.Parsetree.pctf_attributes;\n } ->\n {\n Ast_409.Parsetree.pctf_desc = copy_class_type_field_desc pctf_desc;\n Ast_409.Parsetree.pctf_loc = copy_location pctf_loc;\n Ast_409.Parsetree.pctf_attributes = copy_attributes pctf_attributes;\n }\n\nand copy_class_type_field_desc :\n Ast_408.Parsetree.class_type_field_desc ->\n Ast_409.Parsetree.class_type_field_desc = function\n | Ast_408.Parsetree.Pctf_inherit x0 ->\n Ast_409.Parsetree.Pctf_inherit (copy_class_type x0)\n | Ast_408.Parsetree.Pctf_val x0 ->\n Ast_409.Parsetree.Pctf_val\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_mutable_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | Ast_408.Parsetree.Pctf_method x0 ->\n Ast_409.Parsetree.Pctf_method\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_private_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | Ast_408.Parsetree.Pctf_constraint x0 ->\n Ast_409.Parsetree.Pctf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | Ast_408.Parsetree.Pctf_attribute x0 ->\n Ast_409.Parsetree.Pctf_attribute (copy_attribute x0)\n | Ast_408.Parsetree.Pctf_extension x0 ->\n Ast_409.Parsetree.Pctf_extension (copy_extension x0)\n\nand copy_extension : Ast_408.Parsetree.extension -> Ast_409.Parsetree.extension\n =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_class_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_408.Parsetree.class_infos ->\n 'g0 Ast_409.Parsetree.class_infos =\n fun f0\n {\n Ast_408.Parsetree.pci_virt;\n Ast_408.Parsetree.pci_params;\n Ast_408.Parsetree.pci_name;\n Ast_408.Parsetree.pci_expr;\n Ast_408.Parsetree.pci_loc;\n Ast_408.Parsetree.pci_attributes;\n } ->\n {\n Ast_409.Parsetree.pci_virt = copy_virtual_flag pci_virt;\n Ast_409.Parsetree.pci_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n pci_params;\n Ast_409.Parsetree.pci_name = copy_loc (fun x -> x) pci_name;\n Ast_409.Parsetree.pci_expr = f0 pci_expr;\n Ast_409.Parsetree.pci_loc = copy_location pci_loc;\n Ast_409.Parsetree.pci_attributes = copy_attributes pci_attributes;\n }\n\nand copy_virtual_flag :\n Ast_408.Asttypes.virtual_flag -> Ast_409.Asttypes.virtual_flag = function\n | Ast_408.Asttypes.Virtual -> Ast_409.Asttypes.Virtual\n | Ast_408.Asttypes.Concrete -> Ast_409.Asttypes.Concrete\n\nand copy_include_description :\n Ast_408.Parsetree.include_description ->\n Ast_409.Parsetree.include_description =\n fun x -> copy_include_infos copy_module_type x\n\nand copy_include_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_408.Parsetree.include_infos ->\n 'g0 Ast_409.Parsetree.include_infos =\n fun f0\n {\n Ast_408.Parsetree.pincl_mod;\n Ast_408.Parsetree.pincl_loc;\n Ast_408.Parsetree.pincl_attributes;\n } ->\n {\n Ast_409.Parsetree.pincl_mod = f0 pincl_mod;\n Ast_409.Parsetree.pincl_loc = copy_location pincl_loc;\n Ast_409.Parsetree.pincl_attributes = copy_attributes pincl_attributes;\n }\n\nand copy_open_description :\n Ast_408.Parsetree.open_description -> Ast_409.Parsetree.open_description =\n fun x -> copy_open_infos (fun x -> copy_loc copy_Longident_t x) x\n\nand copy_open_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 Ast_408.Parsetree.open_infos ->\n 'g0 Ast_409.Parsetree.open_infos =\n fun f0\n {\n Ast_408.Parsetree.popen_expr;\n Ast_408.Parsetree.popen_override;\n Ast_408.Parsetree.popen_loc;\n Ast_408.Parsetree.popen_attributes;\n } ->\n {\n Ast_409.Parsetree.popen_expr = f0 popen_expr;\n Ast_409.Parsetree.popen_override = copy_override_flag popen_override;\n Ast_409.Parsetree.popen_loc = copy_location popen_loc;\n Ast_409.Parsetree.popen_attributes = copy_attributes popen_attributes;\n }\n\nand copy_override_flag :\n Ast_408.Asttypes.override_flag -> Ast_409.Asttypes.override_flag = function\n | Ast_408.Asttypes.Override -> Ast_409.Asttypes.Override\n | Ast_408.Asttypes.Fresh -> Ast_409.Asttypes.Fresh\n\nand copy_module_type_declaration :\n Ast_408.Parsetree.module_type_declaration ->\n Ast_409.Parsetree.module_type_declaration =\n fun {\n Ast_408.Parsetree.pmtd_name;\n Ast_408.Parsetree.pmtd_type;\n Ast_408.Parsetree.pmtd_attributes;\n Ast_408.Parsetree.pmtd_loc;\n } ->\n {\n Ast_409.Parsetree.pmtd_name = copy_loc (fun x -> x) pmtd_name;\n Ast_409.Parsetree.pmtd_type = Option.map copy_module_type pmtd_type;\n Ast_409.Parsetree.pmtd_attributes = copy_attributes pmtd_attributes;\n Ast_409.Parsetree.pmtd_loc = copy_location pmtd_loc;\n }\n\nand copy_module_substitution :\n Ast_408.Parsetree.module_substitution ->\n Ast_409.Parsetree.module_substitution =\n fun {\n Ast_408.Parsetree.pms_name;\n Ast_408.Parsetree.pms_manifest;\n Ast_408.Parsetree.pms_attributes;\n Ast_408.Parsetree.pms_loc;\n } ->\n {\n Ast_409.Parsetree.pms_name = copy_loc (fun x -> x) pms_name;\n Ast_409.Parsetree.pms_manifest = copy_loc copy_Longident_t pms_manifest;\n Ast_409.Parsetree.pms_attributes = copy_attributes pms_attributes;\n Ast_409.Parsetree.pms_loc = copy_location pms_loc;\n }\n\nand copy_module_declaration :\n Ast_408.Parsetree.module_declaration -> Ast_409.Parsetree.module_declaration\n =\n fun {\n Ast_408.Parsetree.pmd_name;\n Ast_408.Parsetree.pmd_type;\n Ast_408.Parsetree.pmd_attributes;\n Ast_408.Parsetree.pmd_loc;\n } ->\n {\n Ast_409.Parsetree.pmd_name = copy_loc (fun x -> x) pmd_name;\n Ast_409.Parsetree.pmd_type = copy_module_type pmd_type;\n Ast_409.Parsetree.pmd_attributes = copy_attributes pmd_attributes;\n Ast_409.Parsetree.pmd_loc = copy_location pmd_loc;\n }\n\nand copy_type_exception :\n Ast_408.Parsetree.type_exception -> Ast_409.Parsetree.type_exception =\n fun {\n Ast_408.Parsetree.ptyexn_constructor;\n Ast_408.Parsetree.ptyexn_loc;\n Ast_408.Parsetree.ptyexn_attributes;\n } ->\n {\n Ast_409.Parsetree.ptyexn_constructor =\n copy_extension_constructor ptyexn_constructor;\n Ast_409.Parsetree.ptyexn_loc = copy_location ptyexn_loc;\n Ast_409.Parsetree.ptyexn_attributes = copy_attributes ptyexn_attributes;\n }\n\nand copy_type_extension :\n Ast_408.Parsetree.type_extension -> Ast_409.Parsetree.type_extension =\n fun {\n Ast_408.Parsetree.ptyext_path;\n Ast_408.Parsetree.ptyext_params;\n Ast_408.Parsetree.ptyext_constructors;\n Ast_408.Parsetree.ptyext_private;\n Ast_408.Parsetree.ptyext_loc;\n Ast_408.Parsetree.ptyext_attributes;\n } ->\n {\n Ast_409.Parsetree.ptyext_path = copy_loc copy_Longident_t ptyext_path;\n Ast_409.Parsetree.ptyext_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptyext_params;\n Ast_409.Parsetree.ptyext_constructors =\n List.map copy_extension_constructor ptyext_constructors;\n Ast_409.Parsetree.ptyext_private = copy_private_flag ptyext_private;\n Ast_409.Parsetree.ptyext_loc = copy_location ptyext_loc;\n Ast_409.Parsetree.ptyext_attributes = copy_attributes ptyext_attributes;\n }\n\nand copy_extension_constructor :\n Ast_408.Parsetree.extension_constructor ->\n Ast_409.Parsetree.extension_constructor =\n fun {\n Ast_408.Parsetree.pext_name;\n Ast_408.Parsetree.pext_kind;\n Ast_408.Parsetree.pext_loc;\n Ast_408.Parsetree.pext_attributes;\n } ->\n {\n Ast_409.Parsetree.pext_name = copy_loc (fun x -> x) pext_name;\n Ast_409.Parsetree.pext_kind = copy_extension_constructor_kind pext_kind;\n Ast_409.Parsetree.pext_loc = copy_location pext_loc;\n Ast_409.Parsetree.pext_attributes = copy_attributes pext_attributes;\n }\n\nand copy_extension_constructor_kind :\n Ast_408.Parsetree.extension_constructor_kind ->\n Ast_409.Parsetree.extension_constructor_kind = function\n | Ast_408.Parsetree.Pext_decl (x0, x1) ->\n Ast_409.Parsetree.Pext_decl\n (copy_constructor_arguments x0, Option.map copy_core_type x1)\n | Ast_408.Parsetree.Pext_rebind x0 ->\n Ast_409.Parsetree.Pext_rebind (copy_loc copy_Longident_t x0)\n\nand copy_type_declaration :\n Ast_408.Parsetree.type_declaration -> Ast_409.Parsetree.type_declaration =\n fun {\n Ast_408.Parsetree.ptype_name;\n Ast_408.Parsetree.ptype_params;\n Ast_408.Parsetree.ptype_cstrs;\n Ast_408.Parsetree.ptype_kind;\n Ast_408.Parsetree.ptype_private;\n Ast_408.Parsetree.ptype_manifest;\n Ast_408.Parsetree.ptype_attributes;\n Ast_408.Parsetree.ptype_loc;\n } ->\n {\n Ast_409.Parsetree.ptype_name = copy_loc (fun x -> x) ptype_name;\n Ast_409.Parsetree.ptype_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptype_params;\n Ast_409.Parsetree.ptype_cstrs =\n List.map\n (fun x ->\n let x0, x1, x2 = x in\n (copy_core_type x0, copy_core_type x1, copy_location x2))\n ptype_cstrs;\n Ast_409.Parsetree.ptype_kind = copy_type_kind ptype_kind;\n Ast_409.Parsetree.ptype_private = copy_private_flag ptype_private;\n Ast_409.Parsetree.ptype_manifest = Option.map copy_core_type ptype_manifest;\n Ast_409.Parsetree.ptype_attributes = copy_attributes ptype_attributes;\n Ast_409.Parsetree.ptype_loc = copy_location ptype_loc;\n }\n\nand copy_private_flag :\n Ast_408.Asttypes.private_flag -> Ast_409.Asttypes.private_flag = function\n | Ast_408.Asttypes.Private -> Ast_409.Asttypes.Private\n | Ast_408.Asttypes.Public -> Ast_409.Asttypes.Public\n\nand copy_type_kind : Ast_408.Parsetree.type_kind -> Ast_409.Parsetree.type_kind\n = function\n | Ast_408.Parsetree.Ptype_abstract -> Ast_409.Parsetree.Ptype_abstract\n | Ast_408.Parsetree.Ptype_variant x0 ->\n Ast_409.Parsetree.Ptype_variant (List.map copy_constructor_declaration x0)\n | Ast_408.Parsetree.Ptype_record x0 ->\n Ast_409.Parsetree.Ptype_record (List.map copy_label_declaration x0)\n | Ast_408.Parsetree.Ptype_open -> Ast_409.Parsetree.Ptype_open\n\nand copy_constructor_declaration :\n Ast_408.Parsetree.constructor_declaration ->\n Ast_409.Parsetree.constructor_declaration =\n fun {\n Ast_408.Parsetree.pcd_name;\n Ast_408.Parsetree.pcd_args;\n Ast_408.Parsetree.pcd_res;\n Ast_408.Parsetree.pcd_loc;\n Ast_408.Parsetree.pcd_attributes;\n } ->\n {\n Ast_409.Parsetree.pcd_name = copy_loc (fun x -> x) pcd_name;\n Ast_409.Parsetree.pcd_args = copy_constructor_arguments pcd_args;\n Ast_409.Parsetree.pcd_res = Option.map copy_core_type pcd_res;\n Ast_409.Parsetree.pcd_loc = copy_location pcd_loc;\n Ast_409.Parsetree.pcd_attributes = copy_attributes pcd_attributes;\n }\n\nand copy_constructor_arguments :\n Ast_408.Parsetree.constructor_arguments ->\n Ast_409.Parsetree.constructor_arguments = function\n | Ast_408.Parsetree.Pcstr_tuple x0 ->\n Ast_409.Parsetree.Pcstr_tuple (List.map copy_core_type x0)\n | Ast_408.Parsetree.Pcstr_record x0 ->\n Ast_409.Parsetree.Pcstr_record (List.map copy_label_declaration x0)\n\nand copy_label_declaration :\n Ast_408.Parsetree.label_declaration -> Ast_409.Parsetree.label_declaration =\n fun {\n Ast_408.Parsetree.pld_name;\n Ast_408.Parsetree.pld_mutable;\n Ast_408.Parsetree.pld_type;\n Ast_408.Parsetree.pld_loc;\n Ast_408.Parsetree.pld_attributes;\n } ->\n {\n Ast_409.Parsetree.pld_name = copy_loc (fun x -> x) pld_name;\n Ast_409.Parsetree.pld_mutable = copy_mutable_flag pld_mutable;\n Ast_409.Parsetree.pld_type = copy_core_type pld_type;\n Ast_409.Parsetree.pld_loc = copy_location pld_loc;\n Ast_409.Parsetree.pld_attributes = copy_attributes pld_attributes;\n }\n\nand copy_mutable_flag :\n Ast_408.Asttypes.mutable_flag -> Ast_409.Asttypes.mutable_flag = function\n | Ast_408.Asttypes.Immutable -> Ast_409.Asttypes.Immutable\n | Ast_408.Asttypes.Mutable -> Ast_409.Asttypes.Mutable\n\nand copy_variance : Ast_408.Asttypes.variance -> Ast_409.Asttypes.variance =\n function\n | Ast_408.Asttypes.Covariant -> Ast_409.Asttypes.Covariant\n | Ast_408.Asttypes.Contravariant -> Ast_409.Asttypes.Contravariant\n | Ast_408.Asttypes.Invariant -> Ast_409.Asttypes.Invariant\n\nand copy_value_description :\n Ast_408.Parsetree.value_description -> Ast_409.Parsetree.value_description =\n fun {\n Ast_408.Parsetree.pval_name;\n Ast_408.Parsetree.pval_type;\n Ast_408.Parsetree.pval_prim;\n Ast_408.Parsetree.pval_attributes;\n Ast_408.Parsetree.pval_loc;\n } ->\n {\n Ast_409.Parsetree.pval_name = copy_loc (fun x -> x) pval_name;\n Ast_409.Parsetree.pval_type = copy_core_type pval_type;\n Ast_409.Parsetree.pval_prim = List.map (fun x -> x) pval_prim;\n Ast_409.Parsetree.pval_attributes = copy_attributes pval_attributes;\n Ast_409.Parsetree.pval_loc = copy_location pval_loc;\n }\n\nand copy_object_field_desc :\n Ast_408.Parsetree.object_field_desc -> Ast_409.Parsetree.object_field_desc =\n function\n | Ast_408.Parsetree.Otag (x0, x1) ->\n Ast_409.Parsetree.Otag (copy_loc copy_label x0, copy_core_type x1)\n | Ast_408.Parsetree.Oinherit x0 ->\n Ast_409.Parsetree.Oinherit (copy_core_type x0)\n\nand copy_arg_label : Ast_408.Asttypes.arg_label -> Ast_409.Asttypes.arg_label =\n function\n | Ast_408.Asttypes.Nolabel -> Ast_409.Asttypes.Nolabel\n | Ast_408.Asttypes.Labelled x0 -> Ast_409.Asttypes.Labelled x0\n | Ast_408.Asttypes.Optional x0 -> Ast_409.Asttypes.Optional x0\n\nand copy_closed_flag :\n Ast_408.Asttypes.closed_flag -> Ast_409.Asttypes.closed_flag = function\n | Ast_408.Asttypes.Closed -> Ast_409.Asttypes.Closed\n | Ast_408.Asttypes.Open -> Ast_409.Asttypes.Open\n\nand copy_label : Ast_408.Asttypes.label -> Ast_409.Asttypes.label = fun x -> x\n\nand copy_rec_flag : Ast_408.Asttypes.rec_flag -> Ast_409.Asttypes.rec_flag =\n function\n | Ast_408.Asttypes.Nonrecursive -> Ast_409.Asttypes.Nonrecursive\n | Ast_408.Asttypes.Recursive -> Ast_409.Asttypes.Recursive\n\nand copy_constant : Ast_408.Parsetree.constant -> Ast_409.Parsetree.constant =\n function\n | Ast_408.Parsetree.Pconst_integer (x0, x1) ->\n Ast_409.Parsetree.Pconst_integer (x0, Option.map (fun x -> x) x1)\n | Ast_408.Parsetree.Pconst_char x0 -> Ast_409.Parsetree.Pconst_char x0\n | Ast_408.Parsetree.Pconst_string (x0, x1) ->\n Ast_409.Parsetree.Pconst_string (x0, Option.map (fun x -> x) x1)\n | Ast_408.Parsetree.Pconst_float (x0, x1) ->\n Ast_409.Parsetree.Pconst_float (x0, Option.map (fun x -> x) x1)\n\nand copy_Longident_t : Longident.t -> Longident.t = fun x -> x\n\nand copy_loc :\n 'f0 'g0.\n ('f0 -> 'g0) -> 'f0 Ast_408.Asttypes.loc -> 'g0 Ast_409.Asttypes.loc =\n fun f0 { Ast_408.Asttypes.txt; Ast_408.Asttypes.loc } ->\n { Ast_409.Asttypes.txt = f0 txt; Ast_409.Asttypes.loc = copy_location loc }\n\nand copy_location : Location.t -> Location.t = fun x -> x\n","module From = Ast_408\nmodule To = Ast_407\n\nlet migration_error loc missing_feature =\n Location.raise_errorf ~loc\n \"migration error: %s is not supported before OCaml 4.08\" missing_feature\n\nlet rec copy_toplevel_phrase :\n From.Parsetree.toplevel_phrase -> To.Parsetree.toplevel_phrase = function\n | From.Parsetree.Ptop_def x0 -> To.Parsetree.Ptop_def (copy_structure x0)\n | From.Parsetree.Ptop_dir\n {\n From.Parsetree.pdir_name;\n From.Parsetree.pdir_arg;\n From.Parsetree.pdir_loc = _;\n } ->\n To.Parsetree.Ptop_dir\n ( pdir_name.Location.txt,\n match pdir_arg with\n | None -> To.Parsetree.Pdir_none\n | Some arg -> copy_directive_argument arg )\n\nand copy_directive_argument :\n From.Parsetree.directive_argument -> To.Parsetree.directive_argument =\n fun { From.Parsetree.pdira_desc; From.Parsetree.pdira_loc = _pdira_loc } ->\n copy_directive_argument_desc pdira_desc\n\nand copy_directive_argument_desc :\n From.Parsetree.directive_argument_desc -> To.Parsetree.directive_argument =\n function\n | From.Parsetree.Pdir_string x0 -> To.Parsetree.Pdir_string x0\n | From.Parsetree.Pdir_int (x0, x1) ->\n To.Parsetree.Pdir_int (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pdir_ident x0 -> To.Parsetree.Pdir_ident (copy_longident x0)\n | From.Parsetree.Pdir_bool x0 -> To.Parsetree.Pdir_bool (copy_bool x0)\n\nand copy_expression : From.Parsetree.expression -> To.Parsetree.expression =\n fun {\n From.Parsetree.pexp_desc;\n From.Parsetree.pexp_loc;\n From.Parsetree.pexp_loc_stack = _;\n From.Parsetree.pexp_attributes;\n } ->\n {\n To.Parsetree.pexp_desc = copy_expression_desc pexp_desc;\n To.Parsetree.pexp_loc = copy_location pexp_loc;\n To.Parsetree.pexp_attributes = copy_attributes pexp_attributes;\n }\n\nand copy_expression_desc :\n From.Parsetree.expression_desc -> To.Parsetree.expression_desc = function\n | From.Parsetree.Pexp_ident x0 ->\n To.Parsetree.Pexp_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pexp_constant x0 ->\n To.Parsetree.Pexp_constant (copy_constant x0)\n | From.Parsetree.Pexp_let (x0, x1, x2) ->\n To.Parsetree.Pexp_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_expression x2)\n | From.Parsetree.Pexp_function x0 ->\n To.Parsetree.Pexp_function (List.map copy_case x0)\n | From.Parsetree.Pexp_fun (x0, x1, x2, x3) ->\n To.Parsetree.Pexp_fun\n ( copy_arg_label x0,\n copy_option copy_expression x1,\n copy_pattern x2,\n copy_expression x3 )\n | From.Parsetree.Pexp_apply (x0, x1) ->\n To.Parsetree.Pexp_apply\n ( copy_expression x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | From.Parsetree.Pexp_match (x0, x1) ->\n To.Parsetree.Pexp_match (copy_expression x0, List.map copy_case x1)\n | From.Parsetree.Pexp_try (x0, x1) ->\n To.Parsetree.Pexp_try (copy_expression x0, List.map copy_case x1)\n | From.Parsetree.Pexp_tuple x0 ->\n To.Parsetree.Pexp_tuple (List.map copy_expression x0)\n | From.Parsetree.Pexp_construct (x0, x1) ->\n To.Parsetree.Pexp_construct\n (copy_loc copy_longident x0, copy_option copy_expression x1)\n | From.Parsetree.Pexp_variant (x0, x1) ->\n To.Parsetree.Pexp_variant (copy_label x0, copy_option copy_expression x1)\n | From.Parsetree.Pexp_record (x0, x1) ->\n To.Parsetree.Pexp_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_expression x1))\n x0,\n copy_option copy_expression x1 )\n | From.Parsetree.Pexp_field (x0, x1) ->\n To.Parsetree.Pexp_field (copy_expression x0, copy_loc copy_longident x1)\n | From.Parsetree.Pexp_setfield (x0, x1, x2) ->\n To.Parsetree.Pexp_setfield\n (copy_expression x0, copy_loc copy_longident x1, copy_expression x2)\n | From.Parsetree.Pexp_array x0 ->\n To.Parsetree.Pexp_array (List.map copy_expression x0)\n | From.Parsetree.Pexp_ifthenelse (x0, x1, x2) ->\n To.Parsetree.Pexp_ifthenelse\n (copy_expression x0, copy_expression x1, copy_option copy_expression x2)\n | From.Parsetree.Pexp_sequence (x0, x1) ->\n To.Parsetree.Pexp_sequence (copy_expression x0, copy_expression x1)\n | From.Parsetree.Pexp_while (x0, x1) ->\n To.Parsetree.Pexp_while (copy_expression x0, copy_expression x1)\n | From.Parsetree.Pexp_for (x0, x1, x2, x3, x4) ->\n To.Parsetree.Pexp_for\n ( copy_pattern x0,\n copy_expression x1,\n copy_expression x2,\n copy_direction_flag x3,\n copy_expression x4 )\n | From.Parsetree.Pexp_constraint (x0, x1) ->\n To.Parsetree.Pexp_constraint (copy_expression x0, copy_core_type x1)\n | From.Parsetree.Pexp_coerce (x0, x1, x2) ->\n To.Parsetree.Pexp_coerce\n (copy_expression x0, copy_option copy_core_type x1, copy_core_type x2)\n | From.Parsetree.Pexp_send (x0, x1) ->\n To.Parsetree.Pexp_send (copy_expression x0, copy_loc copy_label x1)\n | From.Parsetree.Pexp_new x0 ->\n To.Parsetree.Pexp_new (copy_loc copy_longident x0)\n | From.Parsetree.Pexp_setinstvar (x0, x1) ->\n To.Parsetree.Pexp_setinstvar (copy_loc copy_label x0, copy_expression x1)\n | From.Parsetree.Pexp_override x0 ->\n To.Parsetree.Pexp_override\n (List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_label x0, copy_expression x1))\n x0)\n | From.Parsetree.Pexp_letmodule (x0, x1, x2) ->\n To.Parsetree.Pexp_letmodule\n (copy_loc (fun x -> x) x0, copy_module_expr x1, copy_expression x2)\n | From.Parsetree.Pexp_letexception (x0, x1) ->\n To.Parsetree.Pexp_letexception\n (copy_extension_constructor x0, copy_expression x1)\n | From.Parsetree.Pexp_assert x0 ->\n To.Parsetree.Pexp_assert (copy_expression x0)\n | From.Parsetree.Pexp_lazy x0 -> To.Parsetree.Pexp_lazy (copy_expression x0)\n | From.Parsetree.Pexp_poly (x0, x1) ->\n To.Parsetree.Pexp_poly (copy_expression x0, copy_option copy_core_type x1)\n | From.Parsetree.Pexp_object x0 ->\n To.Parsetree.Pexp_object (copy_class_structure x0)\n | From.Parsetree.Pexp_newtype (x0, x1) ->\n To.Parsetree.Pexp_newtype (copy_loc (fun x -> x) x0, copy_expression x1)\n | From.Parsetree.Pexp_pack x0 -> To.Parsetree.Pexp_pack (copy_module_expr x0)\n | From.Parsetree.Pexp_open (x0, x1) -> (\n match x0.From.Parsetree.popen_expr.From.Parsetree.pmod_desc with\n | Pmod_ident lid ->\n To.Parsetree.Pexp_open\n ( copy_override_flag x0.From.Parsetree.popen_override,\n copy_loc copy_longident lid,\n copy_expression x1 )\n | Pmod_structure _ | Pmod_functor _ | Pmod_apply _ | Pmod_constraint _\n | Pmod_unpack _ | Pmod_extension _ ->\n migration_error x0.From.Parsetree.popen_loc \"complex open\")\n | From.Parsetree.Pexp_letop { let_; ands = _; body = _ } ->\n migration_error let_.pbop_op.loc \"let operators\"\n | From.Parsetree.Pexp_extension x0 ->\n To.Parsetree.Pexp_extension (copy_extension x0)\n | From.Parsetree.Pexp_unreachable -> To.Parsetree.Pexp_unreachable\n\nand copy_direction_flag :\n From.Asttypes.direction_flag -> To.Asttypes.direction_flag = function\n | From.Asttypes.Upto -> To.Asttypes.Upto\n | From.Asttypes.Downto -> To.Asttypes.Downto\n\nand copy_case : From.Parsetree.case -> To.Parsetree.case =\n fun { From.Parsetree.pc_lhs; From.Parsetree.pc_guard; From.Parsetree.pc_rhs } ->\n {\n To.Parsetree.pc_lhs = copy_pattern pc_lhs;\n To.Parsetree.pc_guard = copy_option copy_expression pc_guard;\n To.Parsetree.pc_rhs = copy_expression pc_rhs;\n }\n\nand copy_value_binding :\n From.Parsetree.value_binding -> To.Parsetree.value_binding =\n fun {\n From.Parsetree.pvb_pat;\n From.Parsetree.pvb_expr;\n From.Parsetree.pvb_attributes;\n From.Parsetree.pvb_loc;\n } ->\n {\n To.Parsetree.pvb_pat = copy_pattern pvb_pat;\n To.Parsetree.pvb_expr = copy_expression pvb_expr;\n To.Parsetree.pvb_attributes = copy_attributes pvb_attributes;\n To.Parsetree.pvb_loc = copy_location pvb_loc;\n }\n\nand copy_pattern : From.Parsetree.pattern -> To.Parsetree.pattern =\n fun {\n From.Parsetree.ppat_desc;\n From.Parsetree.ppat_loc;\n From.Parsetree.ppat_loc_stack = _;\n From.Parsetree.ppat_attributes;\n } ->\n {\n To.Parsetree.ppat_desc = copy_pattern_desc ppat_desc;\n To.Parsetree.ppat_loc = copy_location ppat_loc;\n To.Parsetree.ppat_attributes = copy_attributes ppat_attributes;\n }\n\nand copy_pattern_desc : From.Parsetree.pattern_desc -> To.Parsetree.pattern_desc\n = function\n | From.Parsetree.Ppat_any -> To.Parsetree.Ppat_any\n | From.Parsetree.Ppat_var x0 ->\n To.Parsetree.Ppat_var (copy_loc (fun x -> x) x0)\n | From.Parsetree.Ppat_alias (x0, x1) ->\n To.Parsetree.Ppat_alias (copy_pattern x0, copy_loc (fun x -> x) x1)\n | From.Parsetree.Ppat_constant x0 ->\n To.Parsetree.Ppat_constant (copy_constant x0)\n | From.Parsetree.Ppat_interval (x0, x1) ->\n To.Parsetree.Ppat_interval (copy_constant x0, copy_constant x1)\n | From.Parsetree.Ppat_tuple x0 ->\n To.Parsetree.Ppat_tuple (List.map copy_pattern x0)\n | From.Parsetree.Ppat_construct (x0, x1) ->\n To.Parsetree.Ppat_construct\n (copy_loc copy_longident x0, copy_option copy_pattern x1)\n | From.Parsetree.Ppat_variant (x0, x1) ->\n To.Parsetree.Ppat_variant (copy_label x0, copy_option copy_pattern x1)\n | From.Parsetree.Ppat_record (x0, x1) ->\n To.Parsetree.Ppat_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_pattern x1))\n x0,\n copy_closed_flag x1 )\n | From.Parsetree.Ppat_array x0 ->\n To.Parsetree.Ppat_array (List.map copy_pattern x0)\n | From.Parsetree.Ppat_or (x0, x1) ->\n To.Parsetree.Ppat_or (copy_pattern x0, copy_pattern x1)\n | From.Parsetree.Ppat_constraint (x0, x1) ->\n To.Parsetree.Ppat_constraint (copy_pattern x0, copy_core_type x1)\n | From.Parsetree.Ppat_type x0 ->\n To.Parsetree.Ppat_type (copy_loc copy_longident x0)\n | From.Parsetree.Ppat_lazy x0 -> To.Parsetree.Ppat_lazy (copy_pattern x0)\n | From.Parsetree.Ppat_unpack x0 ->\n To.Parsetree.Ppat_unpack (copy_loc (fun x -> x) x0)\n | From.Parsetree.Ppat_exception x0 ->\n To.Parsetree.Ppat_exception (copy_pattern x0)\n | From.Parsetree.Ppat_extension x0 ->\n To.Parsetree.Ppat_extension (copy_extension x0)\n | From.Parsetree.Ppat_open (x0, x1) ->\n To.Parsetree.Ppat_open (copy_loc copy_longident x0, copy_pattern x1)\n\nand copy_core_type : From.Parsetree.core_type -> To.Parsetree.core_type =\n fun {\n From.Parsetree.ptyp_desc;\n From.Parsetree.ptyp_loc;\n From.Parsetree.ptyp_loc_stack = _;\n From.Parsetree.ptyp_attributes;\n } ->\n {\n To.Parsetree.ptyp_desc = copy_core_type_desc ptyp_desc;\n To.Parsetree.ptyp_loc = copy_location ptyp_loc;\n To.Parsetree.ptyp_attributes = copy_attributes ptyp_attributes;\n }\n\nand copy_core_type_desc :\n From.Parsetree.core_type_desc -> To.Parsetree.core_type_desc = function\n | From.Parsetree.Ptyp_any -> To.Parsetree.Ptyp_any\n | From.Parsetree.Ptyp_var x0 -> To.Parsetree.Ptyp_var x0\n | From.Parsetree.Ptyp_arrow (x0, x1, x2) ->\n To.Parsetree.Ptyp_arrow\n (copy_arg_label x0, copy_core_type x1, copy_core_type x2)\n | From.Parsetree.Ptyp_tuple x0 ->\n To.Parsetree.Ptyp_tuple (List.map copy_core_type x0)\n | From.Parsetree.Ptyp_constr (x0, x1) ->\n To.Parsetree.Ptyp_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Ptyp_object (x0, x1) ->\n To.Parsetree.Ptyp_object\n (List.map copy_object_field x0, copy_closed_flag x1)\n | From.Parsetree.Ptyp_class (x0, x1) ->\n To.Parsetree.Ptyp_class\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Ptyp_alias (x0, x1) ->\n To.Parsetree.Ptyp_alias (copy_core_type x0, x1)\n | From.Parsetree.Ptyp_variant (x0, x1, x2) ->\n To.Parsetree.Ptyp_variant\n ( List.map copy_row_field x0,\n copy_closed_flag x1,\n copy_option (fun x -> List.map copy_label x) x2 )\n | From.Parsetree.Ptyp_poly (x0, x1) ->\n To.Parsetree.Ptyp_poly\n (List.map (fun x -> copy_loc (fun x -> x) x) x0, copy_core_type x1)\n | From.Parsetree.Ptyp_package x0 ->\n To.Parsetree.Ptyp_package (copy_package_type x0)\n | From.Parsetree.Ptyp_extension x0 ->\n To.Parsetree.Ptyp_extension (copy_extension x0)\n\nand copy_package_type : From.Parsetree.package_type -> To.Parsetree.package_type\n =\n fun x ->\n let x0, x1 = x in\n ( copy_loc copy_longident x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_core_type x1))\n x1 )\n\nand copy_row_field : From.Parsetree.row_field -> To.Parsetree.row_field =\n fun {\n From.Parsetree.prf_desc;\n From.Parsetree.prf_loc = _;\n From.Parsetree.prf_attributes;\n } ->\n match prf_desc with\n | From.Parsetree.Rtag (x0, x1, x2) ->\n To.Parsetree.Rtag\n ( copy_loc copy_label x0,\n copy_attributes prf_attributes,\n copy_bool x1,\n List.map copy_core_type x2 )\n | From.Parsetree.Rinherit x0 -> To.Parsetree.Rinherit (copy_core_type x0)\n\nand copy_object_field : From.Parsetree.object_field -> To.Parsetree.object_field\n =\n fun {\n From.Parsetree.pof_desc;\n From.Parsetree.pof_loc = _;\n From.Parsetree.pof_attributes;\n } ->\n match pof_desc with\n | From.Parsetree.Otag (x0, x1) ->\n To.Parsetree.Otag\n ( copy_loc copy_label x0,\n copy_attributes pof_attributes,\n copy_core_type x1 )\n | From.Parsetree.Oinherit x0 -> To.Parsetree.Oinherit (copy_core_type x0)\n\nand copy_attributes : From.Parsetree.attributes -> To.Parsetree.attributes =\n fun x -> List.map copy_attribute x\n\nand copy_attribute : From.Parsetree.attribute -> To.Parsetree.attribute =\n fun {\n From.Parsetree.attr_name;\n From.Parsetree.attr_payload;\n From.Parsetree.attr_loc = _;\n } ->\n (copy_loc (fun x -> x) attr_name, copy_payload attr_payload)\n\nand copy_payload : From.Parsetree.payload -> To.Parsetree.payload = function\n | From.Parsetree.PStr x0 -> To.Parsetree.PStr (copy_structure x0)\n | From.Parsetree.PSig x0 -> To.Parsetree.PSig (copy_signature x0)\n | From.Parsetree.PTyp x0 -> To.Parsetree.PTyp (copy_core_type x0)\n | From.Parsetree.PPat (x0, x1) ->\n To.Parsetree.PPat (copy_pattern x0, copy_option copy_expression x1)\n\nand copy_structure : From.Parsetree.structure -> To.Parsetree.structure =\n fun x -> List.map copy_structure_item x\n\nand copy_structure_item :\n From.Parsetree.structure_item -> To.Parsetree.structure_item =\n fun { From.Parsetree.pstr_desc; From.Parsetree.pstr_loc } ->\n {\n To.Parsetree.pstr_desc = copy_structure_item_desc pstr_desc;\n To.Parsetree.pstr_loc = copy_location pstr_loc;\n }\n\nand copy_structure_item_desc :\n From.Parsetree.structure_item_desc -> To.Parsetree.structure_item_desc =\n function\n | From.Parsetree.Pstr_eval (x0, x1) ->\n To.Parsetree.Pstr_eval (copy_expression x0, copy_attributes x1)\n | From.Parsetree.Pstr_value (x0, x1) ->\n To.Parsetree.Pstr_value (copy_rec_flag x0, List.map copy_value_binding x1)\n | From.Parsetree.Pstr_primitive x0 ->\n To.Parsetree.Pstr_primitive (copy_value_description x0)\n | From.Parsetree.Pstr_type (x0, x1) ->\n To.Parsetree.Pstr_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | From.Parsetree.Pstr_typext x0 ->\n To.Parsetree.Pstr_typext (copy_type_extension x0)\n | From.Parsetree.Pstr_exception x0 ->\n To.Parsetree.Pstr_exception\n (let e =\n copy_extension_constructor x0.From.Parsetree.ptyexn_constructor\n in\n {\n e with\n pext_attributes =\n e.pext_attributes @ copy_attributes x0.ptyexn_attributes;\n })\n | From.Parsetree.Pstr_module x0 ->\n To.Parsetree.Pstr_module (copy_module_binding x0)\n | From.Parsetree.Pstr_recmodule x0 ->\n To.Parsetree.Pstr_recmodule (List.map copy_module_binding x0)\n | From.Parsetree.Pstr_modtype x0 ->\n To.Parsetree.Pstr_modtype (copy_module_type_declaration x0)\n | From.Parsetree.Pstr_open x0 -> (\n match x0.From.Parsetree.popen_expr.From.Parsetree.pmod_desc with\n | Pmod_ident lid ->\n To.Parsetree.Pstr_open\n {\n To.Parsetree.popen_lid = copy_loc copy_longident lid;\n To.Parsetree.popen_override =\n copy_override_flag x0.From.Parsetree.popen_override;\n To.Parsetree.popen_loc = copy_location x0.From.Parsetree.popen_loc;\n To.Parsetree.popen_attributes =\n copy_attributes x0.From.Parsetree.popen_attributes;\n }\n | Pmod_structure _ | Pmod_functor _ | Pmod_apply _ | Pmod_constraint _\n | Pmod_unpack _ | Pmod_extension _ ->\n migration_error x0.From.Parsetree.popen_loc \"complex open\")\n | From.Parsetree.Pstr_class x0 ->\n To.Parsetree.Pstr_class (List.map copy_class_declaration x0)\n | From.Parsetree.Pstr_class_type x0 ->\n To.Parsetree.Pstr_class_type (List.map copy_class_type_declaration x0)\n | From.Parsetree.Pstr_include x0 ->\n To.Parsetree.Pstr_include (copy_include_declaration x0)\n | From.Parsetree.Pstr_attribute x0 ->\n To.Parsetree.Pstr_attribute (copy_attribute x0)\n | From.Parsetree.Pstr_extension (x0, x1) ->\n To.Parsetree.Pstr_extension (copy_extension x0, copy_attributes x1)\n\nand copy_include_declaration :\n From.Parsetree.include_declaration -> To.Parsetree.include_declaration =\n fun x -> copy_include_infos copy_module_expr x\n\nand copy_class_declaration :\n From.Parsetree.class_declaration -> To.Parsetree.class_declaration =\n fun x -> copy_class_infos copy_class_expr x\n\nand copy_class_expr : From.Parsetree.class_expr -> To.Parsetree.class_expr =\n fun {\n From.Parsetree.pcl_desc;\n From.Parsetree.pcl_loc;\n From.Parsetree.pcl_attributes;\n } ->\n {\n To.Parsetree.pcl_desc = copy_class_expr_desc pcl_desc;\n To.Parsetree.pcl_loc = copy_location pcl_loc;\n To.Parsetree.pcl_attributes = copy_attributes pcl_attributes;\n }\n\nand copy_class_expr_desc :\n From.Parsetree.class_expr_desc -> To.Parsetree.class_expr_desc = function\n | From.Parsetree.Pcl_constr (x0, x1) ->\n To.Parsetree.Pcl_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Pcl_structure x0 ->\n To.Parsetree.Pcl_structure (copy_class_structure x0)\n | From.Parsetree.Pcl_fun (x0, x1, x2, x3) ->\n To.Parsetree.Pcl_fun\n ( copy_arg_label x0,\n copy_option copy_expression x1,\n copy_pattern x2,\n copy_class_expr x3 )\n | From.Parsetree.Pcl_apply (x0, x1) ->\n To.Parsetree.Pcl_apply\n ( copy_class_expr x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | From.Parsetree.Pcl_let (x0, x1, x2) ->\n To.Parsetree.Pcl_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_class_expr x2)\n | From.Parsetree.Pcl_constraint (x0, x1) ->\n To.Parsetree.Pcl_constraint (copy_class_expr x0, copy_class_type x1)\n | From.Parsetree.Pcl_extension x0 ->\n To.Parsetree.Pcl_extension (copy_extension x0)\n | From.Parsetree.Pcl_open (x0, x1) ->\n To.Parsetree.Pcl_open\n ( copy_override_flag x0.From.Parsetree.popen_override,\n copy_loc copy_longident x0.From.Parsetree.popen_expr,\n copy_class_expr x1 )\n\nand copy_class_structure :\n From.Parsetree.class_structure -> To.Parsetree.class_structure =\n fun { From.Parsetree.pcstr_self; From.Parsetree.pcstr_fields } ->\n {\n To.Parsetree.pcstr_self = copy_pattern pcstr_self;\n To.Parsetree.pcstr_fields = List.map copy_class_field pcstr_fields;\n }\n\nand copy_class_field : From.Parsetree.class_field -> To.Parsetree.class_field =\n fun {\n From.Parsetree.pcf_desc;\n From.Parsetree.pcf_loc;\n From.Parsetree.pcf_attributes;\n } ->\n {\n To.Parsetree.pcf_desc = copy_class_field_desc pcf_desc;\n To.Parsetree.pcf_loc = copy_location pcf_loc;\n To.Parsetree.pcf_attributes = copy_attributes pcf_attributes;\n }\n\nand copy_class_field_desc :\n From.Parsetree.class_field_desc -> To.Parsetree.class_field_desc = function\n | From.Parsetree.Pcf_inherit (x0, x1, x2) ->\n To.Parsetree.Pcf_inherit\n ( copy_override_flag x0,\n copy_class_expr x1,\n copy_option (fun x -> copy_loc (fun x -> x) x) x2 )\n | From.Parsetree.Pcf_val x0 ->\n To.Parsetree.Pcf_val\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_mutable_flag x1, copy_class_field_kind x2))\n | From.Parsetree.Pcf_method x0 ->\n To.Parsetree.Pcf_method\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_private_flag x1, copy_class_field_kind x2))\n | From.Parsetree.Pcf_constraint x0 ->\n To.Parsetree.Pcf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | From.Parsetree.Pcf_initializer x0 ->\n To.Parsetree.Pcf_initializer (copy_expression x0)\n | From.Parsetree.Pcf_attribute x0 ->\n To.Parsetree.Pcf_attribute (copy_attribute x0)\n | From.Parsetree.Pcf_extension x0 ->\n To.Parsetree.Pcf_extension (copy_extension x0)\n\nand copy_class_field_kind :\n From.Parsetree.class_field_kind -> To.Parsetree.class_field_kind = function\n | From.Parsetree.Cfk_virtual x0 ->\n To.Parsetree.Cfk_virtual (copy_core_type x0)\n | From.Parsetree.Cfk_concrete (x0, x1) ->\n To.Parsetree.Cfk_concrete (copy_override_flag x0, copy_expression x1)\n\nand copy_module_binding :\n From.Parsetree.module_binding -> To.Parsetree.module_binding =\n fun {\n From.Parsetree.pmb_name;\n From.Parsetree.pmb_expr;\n From.Parsetree.pmb_attributes;\n From.Parsetree.pmb_loc;\n } ->\n {\n To.Parsetree.pmb_name = copy_loc (fun x -> x) pmb_name;\n To.Parsetree.pmb_expr = copy_module_expr pmb_expr;\n To.Parsetree.pmb_attributes = copy_attributes pmb_attributes;\n To.Parsetree.pmb_loc = copy_location pmb_loc;\n }\n\nand copy_module_expr : From.Parsetree.module_expr -> To.Parsetree.module_expr =\n fun {\n From.Parsetree.pmod_desc;\n From.Parsetree.pmod_loc;\n From.Parsetree.pmod_attributes;\n } ->\n {\n To.Parsetree.pmod_desc = copy_module_expr_desc pmod_desc;\n To.Parsetree.pmod_loc = copy_location pmod_loc;\n To.Parsetree.pmod_attributes = copy_attributes pmod_attributes;\n }\n\nand copy_module_expr_desc :\n From.Parsetree.module_expr_desc -> To.Parsetree.module_expr_desc = function\n | From.Parsetree.Pmod_ident x0 ->\n To.Parsetree.Pmod_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pmod_structure x0 ->\n To.Parsetree.Pmod_structure (copy_structure x0)\n | From.Parsetree.Pmod_functor (x0, x1, x2) ->\n To.Parsetree.Pmod_functor\n ( copy_loc (fun x -> x) x0,\n copy_option copy_module_type x1,\n copy_module_expr x2 )\n | From.Parsetree.Pmod_apply (x0, x1) ->\n To.Parsetree.Pmod_apply (copy_module_expr x0, copy_module_expr x1)\n | From.Parsetree.Pmod_constraint (x0, x1) ->\n To.Parsetree.Pmod_constraint (copy_module_expr x0, copy_module_type x1)\n | From.Parsetree.Pmod_unpack x0 ->\n To.Parsetree.Pmod_unpack (copy_expression x0)\n | From.Parsetree.Pmod_extension x0 ->\n To.Parsetree.Pmod_extension (copy_extension x0)\n\nand copy_module_type : From.Parsetree.module_type -> To.Parsetree.module_type =\n fun {\n From.Parsetree.pmty_desc;\n From.Parsetree.pmty_loc;\n From.Parsetree.pmty_attributes;\n } ->\n {\n To.Parsetree.pmty_desc = copy_module_type_desc pmty_desc;\n To.Parsetree.pmty_loc = copy_location pmty_loc;\n To.Parsetree.pmty_attributes = copy_attributes pmty_attributes;\n }\n\nand copy_module_type_desc :\n From.Parsetree.module_type_desc -> To.Parsetree.module_type_desc = function\n | From.Parsetree.Pmty_ident x0 ->\n To.Parsetree.Pmty_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pmty_signature x0 ->\n To.Parsetree.Pmty_signature (copy_signature x0)\n | From.Parsetree.Pmty_functor (x0, x1, x2) ->\n To.Parsetree.Pmty_functor\n ( copy_loc (fun x -> x) x0,\n copy_option copy_module_type x1,\n copy_module_type x2 )\n | From.Parsetree.Pmty_with (x0, x1) ->\n To.Parsetree.Pmty_with\n (copy_module_type x0, List.map copy_with_constraint x1)\n | From.Parsetree.Pmty_typeof x0 ->\n To.Parsetree.Pmty_typeof (copy_module_expr x0)\n | From.Parsetree.Pmty_extension x0 ->\n To.Parsetree.Pmty_extension (copy_extension x0)\n | From.Parsetree.Pmty_alias x0 ->\n To.Parsetree.Pmty_alias (copy_loc copy_longident x0)\n\nand copy_with_constraint :\n From.Parsetree.with_constraint -> To.Parsetree.with_constraint = function\n | From.Parsetree.Pwith_type (x0, x1) ->\n To.Parsetree.Pwith_type\n (copy_loc copy_longident x0, copy_type_declaration x1)\n | From.Parsetree.Pwith_module (x0, x1) ->\n To.Parsetree.Pwith_module\n (copy_loc copy_longident x0, copy_loc copy_longident x1)\n | From.Parsetree.Pwith_typesubst (x0, x1) ->\n To.Parsetree.Pwith_typesubst\n (copy_loc copy_longident x0, copy_type_declaration x1)\n | From.Parsetree.Pwith_modsubst (x0, x1) ->\n To.Parsetree.Pwith_modsubst\n (copy_loc copy_longident x0, copy_loc copy_longident x1)\n\nand copy_signature : From.Parsetree.signature -> To.Parsetree.signature =\n fun x -> List.map copy_signature_item x\n\nand copy_signature_item :\n From.Parsetree.signature_item -> To.Parsetree.signature_item =\n fun { From.Parsetree.psig_desc; From.Parsetree.psig_loc } ->\n {\n To.Parsetree.psig_desc = copy_signature_item_desc psig_desc;\n To.Parsetree.psig_loc = copy_location psig_loc;\n }\n\nand copy_signature_item_desc :\n From.Parsetree.signature_item_desc -> To.Parsetree.signature_item_desc =\n function\n | From.Parsetree.Psig_value x0 ->\n To.Parsetree.Psig_value (copy_value_description x0)\n | From.Parsetree.Psig_type (x0, x1) ->\n To.Parsetree.Psig_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | From.Parsetree.Psig_typesubst x0 ->\n let x0_loc =\n match x0 with\n | [] -> Location.none\n | { From.Parsetree.ptype_loc; _ } :: _ -> ptype_loc\n in\n migration_error x0_loc \"type substitution in signatures\"\n | From.Parsetree.Psig_typext x0 ->\n To.Parsetree.Psig_typext (copy_type_extension x0)\n | From.Parsetree.Psig_exception x0 ->\n To.Parsetree.Psig_exception\n (let e =\n copy_extension_constructor x0.From.Parsetree.ptyexn_constructor\n in\n {\n e with\n pext_attributes =\n e.pext_attributes @ copy_attributes x0.ptyexn_attributes;\n })\n | From.Parsetree.Psig_module x0 ->\n To.Parsetree.Psig_module (copy_module_declaration x0)\n | From.Parsetree.Psig_modsubst x0 ->\n migration_error x0.pms_loc \"module substitution in signatures\"\n | From.Parsetree.Psig_recmodule x0 ->\n To.Parsetree.Psig_recmodule (List.map copy_module_declaration x0)\n | From.Parsetree.Psig_modtype x0 ->\n To.Parsetree.Psig_modtype (copy_module_type_declaration x0)\n | From.Parsetree.Psig_open x0 ->\n To.Parsetree.Psig_open (copy_open_description x0)\n | From.Parsetree.Psig_include x0 ->\n To.Parsetree.Psig_include (copy_include_description x0)\n | From.Parsetree.Psig_class x0 ->\n To.Parsetree.Psig_class (List.map copy_class_description x0)\n | From.Parsetree.Psig_class_type x0 ->\n To.Parsetree.Psig_class_type (List.map copy_class_type_declaration x0)\n | From.Parsetree.Psig_attribute x0 ->\n To.Parsetree.Psig_attribute (copy_attribute x0)\n | From.Parsetree.Psig_extension (x0, x1) ->\n To.Parsetree.Psig_extension (copy_extension x0, copy_attributes x1)\n\nand copy_class_type_declaration :\n From.Parsetree.class_type_declaration -> To.Parsetree.class_type_declaration\n =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_description :\n From.Parsetree.class_description -> To.Parsetree.class_description =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_type : From.Parsetree.class_type -> To.Parsetree.class_type =\n fun {\n From.Parsetree.pcty_desc;\n From.Parsetree.pcty_loc;\n From.Parsetree.pcty_attributes;\n } ->\n {\n To.Parsetree.pcty_desc = copy_class_type_desc pcty_desc;\n To.Parsetree.pcty_loc = copy_location pcty_loc;\n To.Parsetree.pcty_attributes = copy_attributes pcty_attributes;\n }\n\nand copy_class_type_desc :\n From.Parsetree.class_type_desc -> To.Parsetree.class_type_desc = function\n | From.Parsetree.Pcty_constr (x0, x1) ->\n To.Parsetree.Pcty_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Pcty_signature x0 ->\n To.Parsetree.Pcty_signature (copy_class_signature x0)\n | From.Parsetree.Pcty_arrow (x0, x1, x2) ->\n To.Parsetree.Pcty_arrow\n (copy_arg_label x0, copy_core_type x1, copy_class_type x2)\n | From.Parsetree.Pcty_extension x0 ->\n To.Parsetree.Pcty_extension (copy_extension x0)\n | From.Parsetree.Pcty_open (x0, x1) ->\n To.Parsetree.Pcty_open\n ( copy_override_flag x0.From.Parsetree.popen_override,\n copy_loc copy_longident x0.From.Parsetree.popen_expr,\n copy_class_type x1 )\n\nand copy_class_signature :\n From.Parsetree.class_signature -> To.Parsetree.class_signature =\n fun { From.Parsetree.pcsig_self; From.Parsetree.pcsig_fields } ->\n {\n To.Parsetree.pcsig_self = copy_core_type pcsig_self;\n To.Parsetree.pcsig_fields = List.map copy_class_type_field pcsig_fields;\n }\n\nand copy_class_type_field :\n From.Parsetree.class_type_field -> To.Parsetree.class_type_field =\n fun {\n From.Parsetree.pctf_desc;\n From.Parsetree.pctf_loc;\n From.Parsetree.pctf_attributes;\n } ->\n {\n To.Parsetree.pctf_desc = copy_class_type_field_desc pctf_desc;\n To.Parsetree.pctf_loc = copy_location pctf_loc;\n To.Parsetree.pctf_attributes = copy_attributes pctf_attributes;\n }\n\nand copy_class_type_field_desc :\n From.Parsetree.class_type_field_desc -> To.Parsetree.class_type_field_desc =\n function\n | From.Parsetree.Pctf_inherit x0 ->\n To.Parsetree.Pctf_inherit (copy_class_type x0)\n | From.Parsetree.Pctf_val x0 ->\n To.Parsetree.Pctf_val\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_mutable_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | From.Parsetree.Pctf_method x0 ->\n To.Parsetree.Pctf_method\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_private_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | From.Parsetree.Pctf_constraint x0 ->\n To.Parsetree.Pctf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | From.Parsetree.Pctf_attribute x0 ->\n To.Parsetree.Pctf_attribute (copy_attribute x0)\n | From.Parsetree.Pctf_extension x0 ->\n To.Parsetree.Pctf_extension (copy_extension x0)\n\nand copy_extension : From.Parsetree.extension -> To.Parsetree.extension =\n fun x ->\n let x0, x1 = x in\n let x1 =\n match x0.txt with\n | \"ocaml.error\" | \"error\" -> (\n match x1 with\n | PStr (hd :: tl) -> From.Parsetree.PStr (hd :: hd :: tl)\n | _ -> x1)\n | _ -> x1\n in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_class_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 From.Parsetree.class_infos ->\n 'g0 To.Parsetree.class_infos =\n fun f0\n {\n From.Parsetree.pci_virt;\n From.Parsetree.pci_params;\n From.Parsetree.pci_name;\n From.Parsetree.pci_expr;\n From.Parsetree.pci_loc;\n From.Parsetree.pci_attributes;\n } ->\n {\n To.Parsetree.pci_virt = copy_virtual_flag pci_virt;\n To.Parsetree.pci_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n pci_params;\n To.Parsetree.pci_name = copy_loc (fun x -> x) pci_name;\n To.Parsetree.pci_expr = f0 pci_expr;\n To.Parsetree.pci_loc = copy_location pci_loc;\n To.Parsetree.pci_attributes = copy_attributes pci_attributes;\n }\n\nand copy_virtual_flag : From.Asttypes.virtual_flag -> To.Asttypes.virtual_flag =\n function\n | From.Asttypes.Virtual -> To.Asttypes.Virtual\n | From.Asttypes.Concrete -> To.Asttypes.Concrete\n\nand copy_include_description :\n From.Parsetree.include_description -> To.Parsetree.include_description =\n fun x -> copy_include_infos copy_module_type x\n\nand copy_include_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 From.Parsetree.include_infos ->\n 'g0 To.Parsetree.include_infos =\n fun f0\n {\n From.Parsetree.pincl_mod;\n From.Parsetree.pincl_loc;\n From.Parsetree.pincl_attributes;\n } ->\n {\n To.Parsetree.pincl_mod = f0 pincl_mod;\n To.Parsetree.pincl_loc = copy_location pincl_loc;\n To.Parsetree.pincl_attributes = copy_attributes pincl_attributes;\n }\n\nand copy_open_description :\n From.Parsetree.open_description -> To.Parsetree.open_description =\n fun {\n From.Parsetree.popen_expr;\n From.Parsetree.popen_override;\n From.Parsetree.popen_loc;\n From.Parsetree.popen_attributes;\n } ->\n {\n To.Parsetree.popen_lid = copy_loc copy_longident popen_expr;\n To.Parsetree.popen_override = copy_override_flag popen_override;\n To.Parsetree.popen_loc = copy_location popen_loc;\n To.Parsetree.popen_attributes = copy_attributes popen_attributes;\n }\n\nand copy_override_flag :\n From.Asttypes.override_flag -> To.Asttypes.override_flag = function\n | From.Asttypes.Override -> To.Asttypes.Override\n | From.Asttypes.Fresh -> To.Asttypes.Fresh\n\nand copy_module_type_declaration :\n From.Parsetree.module_type_declaration ->\n To.Parsetree.module_type_declaration =\n fun {\n From.Parsetree.pmtd_name;\n From.Parsetree.pmtd_type;\n From.Parsetree.pmtd_attributes;\n From.Parsetree.pmtd_loc;\n } ->\n {\n To.Parsetree.pmtd_name = copy_loc (fun x -> x) pmtd_name;\n To.Parsetree.pmtd_type = copy_option copy_module_type pmtd_type;\n To.Parsetree.pmtd_attributes = copy_attributes pmtd_attributes;\n To.Parsetree.pmtd_loc = copy_location pmtd_loc;\n }\n\nand copy_module_declaration :\n From.Parsetree.module_declaration -> To.Parsetree.module_declaration =\n fun {\n From.Parsetree.pmd_name;\n From.Parsetree.pmd_type;\n From.Parsetree.pmd_attributes;\n From.Parsetree.pmd_loc;\n } ->\n {\n To.Parsetree.pmd_name = copy_loc (fun x -> x) pmd_name;\n To.Parsetree.pmd_type = copy_module_type pmd_type;\n To.Parsetree.pmd_attributes = copy_attributes pmd_attributes;\n To.Parsetree.pmd_loc = copy_location pmd_loc;\n }\n\n(* and copy_type_exception :\n From.Parsetree.type_exception -> To.Parsetree.type_exception =\n fun\n { From.Parsetree.ptyexn_constructor = ptyexn_constructor;\n From.Parsetree.ptyexn_loc = ptyexn_loc;\n From.Parsetree.ptyexn_attributes = ptyexn_attributes }\n ->\n {\n To.Parsetree.ptyexn_constructor =\n (copy_extension_constructor ptyexn_constructor);\n To.Parsetree.ptyexn_loc = (copy_location ptyexn_loc);\n To.Parsetree.ptyexn_attributes =\n (copy_attributes ptyexn_attributes)\n }*)\nand copy_type_extension :\n From.Parsetree.type_extension -> To.Parsetree.type_extension =\n fun {\n From.Parsetree.ptyext_path;\n From.Parsetree.ptyext_params;\n From.Parsetree.ptyext_constructors;\n From.Parsetree.ptyext_private;\n From.Parsetree.ptyext_loc = _;\n From.Parsetree.ptyext_attributes;\n } ->\n {\n To.Parsetree.ptyext_path = copy_loc copy_longident ptyext_path;\n To.Parsetree.ptyext_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptyext_params;\n To.Parsetree.ptyext_constructors =\n List.map copy_extension_constructor ptyext_constructors;\n To.Parsetree.ptyext_private = copy_private_flag ptyext_private;\n To.Parsetree.ptyext_attributes = copy_attributes ptyext_attributes;\n }\n\nand copy_extension_constructor :\n From.Parsetree.extension_constructor -> To.Parsetree.extension_constructor =\n fun {\n From.Parsetree.pext_name;\n From.Parsetree.pext_kind;\n From.Parsetree.pext_loc;\n From.Parsetree.pext_attributes;\n } ->\n {\n To.Parsetree.pext_name = copy_loc (fun x -> x) pext_name;\n To.Parsetree.pext_kind = copy_extension_constructor_kind pext_kind;\n To.Parsetree.pext_loc = copy_location pext_loc;\n To.Parsetree.pext_attributes = copy_attributes pext_attributes;\n }\n\nand copy_extension_constructor_kind :\n From.Parsetree.extension_constructor_kind ->\n To.Parsetree.extension_constructor_kind = function\n | From.Parsetree.Pext_decl (x0, x1) ->\n To.Parsetree.Pext_decl\n (copy_constructor_arguments x0, copy_option copy_core_type x1)\n | From.Parsetree.Pext_rebind x0 ->\n To.Parsetree.Pext_rebind (copy_loc copy_longident x0)\n\nand copy_type_declaration :\n From.Parsetree.type_declaration -> To.Parsetree.type_declaration =\n fun {\n From.Parsetree.ptype_name;\n From.Parsetree.ptype_params;\n From.Parsetree.ptype_cstrs;\n From.Parsetree.ptype_kind;\n From.Parsetree.ptype_private;\n From.Parsetree.ptype_manifest;\n From.Parsetree.ptype_attributes;\n From.Parsetree.ptype_loc;\n } ->\n {\n To.Parsetree.ptype_name = copy_loc (fun x -> x) ptype_name;\n To.Parsetree.ptype_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptype_params;\n To.Parsetree.ptype_cstrs =\n List.map\n (fun x ->\n let x0, x1, x2 = x in\n (copy_core_type x0, copy_core_type x1, copy_location x2))\n ptype_cstrs;\n To.Parsetree.ptype_kind = copy_type_kind ptype_kind;\n To.Parsetree.ptype_private = copy_private_flag ptype_private;\n To.Parsetree.ptype_manifest = copy_option copy_core_type ptype_manifest;\n To.Parsetree.ptype_attributes = copy_attributes ptype_attributes;\n To.Parsetree.ptype_loc = copy_location ptype_loc;\n }\n\nand copy_private_flag : From.Asttypes.private_flag -> To.Asttypes.private_flag =\n function\n | From.Asttypes.Private -> To.Asttypes.Private\n | From.Asttypes.Public -> To.Asttypes.Public\n\nand copy_type_kind : From.Parsetree.type_kind -> To.Parsetree.type_kind =\n function\n | From.Parsetree.Ptype_abstract -> To.Parsetree.Ptype_abstract\n | From.Parsetree.Ptype_variant x0 ->\n To.Parsetree.Ptype_variant (List.map copy_constructor_declaration x0)\n | From.Parsetree.Ptype_record x0 ->\n To.Parsetree.Ptype_record (List.map copy_label_declaration x0)\n | From.Parsetree.Ptype_open -> To.Parsetree.Ptype_open\n\nand copy_constructor_declaration :\n From.Parsetree.constructor_declaration ->\n To.Parsetree.constructor_declaration =\n fun {\n From.Parsetree.pcd_name;\n From.Parsetree.pcd_args;\n From.Parsetree.pcd_res;\n From.Parsetree.pcd_loc;\n From.Parsetree.pcd_attributes;\n } ->\n {\n To.Parsetree.pcd_name = copy_loc (fun x -> x) pcd_name;\n To.Parsetree.pcd_args = copy_constructor_arguments pcd_args;\n To.Parsetree.pcd_res = copy_option copy_core_type pcd_res;\n To.Parsetree.pcd_loc = copy_location pcd_loc;\n To.Parsetree.pcd_attributes = copy_attributes pcd_attributes;\n }\n\nand copy_constructor_arguments :\n From.Parsetree.constructor_arguments -> To.Parsetree.constructor_arguments =\n function\n | From.Parsetree.Pcstr_tuple x0 ->\n To.Parsetree.Pcstr_tuple (List.map copy_core_type x0)\n | From.Parsetree.Pcstr_record x0 ->\n To.Parsetree.Pcstr_record (List.map copy_label_declaration x0)\n\nand copy_label_declaration :\n From.Parsetree.label_declaration -> To.Parsetree.label_declaration =\n fun {\n From.Parsetree.pld_name;\n From.Parsetree.pld_mutable;\n From.Parsetree.pld_type;\n From.Parsetree.pld_loc;\n From.Parsetree.pld_attributes;\n } ->\n {\n To.Parsetree.pld_name = copy_loc (fun x -> x) pld_name;\n To.Parsetree.pld_mutable = copy_mutable_flag pld_mutable;\n To.Parsetree.pld_type = copy_core_type pld_type;\n To.Parsetree.pld_loc = copy_location pld_loc;\n To.Parsetree.pld_attributes = copy_attributes pld_attributes;\n }\n\nand copy_mutable_flag : From.Asttypes.mutable_flag -> To.Asttypes.mutable_flag =\n function\n | From.Asttypes.Immutable -> To.Asttypes.Immutable\n | From.Asttypes.Mutable -> To.Asttypes.Mutable\n\nand copy_variance : From.Asttypes.variance -> To.Asttypes.variance = function\n | From.Asttypes.Covariant -> To.Asttypes.Covariant\n | From.Asttypes.Contravariant -> To.Asttypes.Contravariant\n | From.Asttypes.Invariant -> To.Asttypes.Invariant\n\nand copy_value_description :\n From.Parsetree.value_description -> To.Parsetree.value_description =\n fun {\n From.Parsetree.pval_name;\n From.Parsetree.pval_type;\n From.Parsetree.pval_prim;\n From.Parsetree.pval_attributes;\n From.Parsetree.pval_loc;\n } ->\n {\n To.Parsetree.pval_name = copy_loc (fun x -> x) pval_name;\n To.Parsetree.pval_type = copy_core_type pval_type;\n To.Parsetree.pval_prim = List.map (fun x -> x) pval_prim;\n To.Parsetree.pval_attributes = copy_attributes pval_attributes;\n To.Parsetree.pval_loc = copy_location pval_loc;\n }\n\nand copy_arg_label : From.Asttypes.arg_label -> To.Asttypes.arg_label = function\n | From.Asttypes.Nolabel -> To.Asttypes.Nolabel\n | From.Asttypes.Labelled x0 -> To.Asttypes.Labelled x0\n | From.Asttypes.Optional x0 -> To.Asttypes.Optional x0\n\nand copy_closed_flag : From.Asttypes.closed_flag -> To.Asttypes.closed_flag =\n function\n | From.Asttypes.Closed -> To.Asttypes.Closed\n | From.Asttypes.Open -> To.Asttypes.Open\n\nand copy_label : From.Asttypes.label -> To.Asttypes.label = fun x -> x\n\nand copy_rec_flag : From.Asttypes.rec_flag -> To.Asttypes.rec_flag = function\n | From.Asttypes.Nonrecursive -> To.Asttypes.Nonrecursive\n | From.Asttypes.Recursive -> To.Asttypes.Recursive\n\nand copy_constant : From.Parsetree.constant -> To.Parsetree.constant = function\n | From.Parsetree.Pconst_integer (x0, x1) ->\n To.Parsetree.Pconst_integer (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pconst_char x0 -> To.Parsetree.Pconst_char x0\n | From.Parsetree.Pconst_string (x0, x1) ->\n To.Parsetree.Pconst_string (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pconst_float (x0, x1) ->\n To.Parsetree.Pconst_float (x0, copy_option (fun x -> x) x1)\n\nand copy_option : 'f0 'g0. ('f0 -> 'g0) -> 'f0 option -> 'g0 option =\n fun f0 -> function None -> None | Some x0 -> Some (f0 x0)\n\nand copy_longident : Longident.t -> Longident.t = fun x -> x\n\nand copy_loc :\n 'f0 'g0. ('f0 -> 'g0) -> 'f0 From.Asttypes.loc -> 'g0 To.Asttypes.loc =\n fun f0 { From.Asttypes.txt; From.Asttypes.loc } ->\n { To.Asttypes.txt = f0 txt; To.Asttypes.loc = copy_location loc }\n\nand copy_location : Location.t -> Location.t = fun x -> x\nand copy_bool : bool -> bool = function false -> false | true -> true\n\nlet copy_cases x = List.map copy_case x\nlet copy_pat = copy_pattern\nlet copy_expr = copy_expression\nlet copy_typ = copy_core_type\n","module From = Ast_407\nmodule To = Ast_408\n\nlet rec copy_toplevel_phrase :\n From.Parsetree.toplevel_phrase -> To.Parsetree.toplevel_phrase = function\n | From.Parsetree.Ptop_def x0 -> To.Parsetree.Ptop_def (copy_structure x0)\n | From.Parsetree.Ptop_dir (x0, x1) ->\n To.Parsetree.Ptop_dir\n {\n To.Parsetree.pdir_name =\n { Location.txt = x0; Location.loc = Location.none };\n To.Parsetree.pdir_arg = copy_directive_argument x1;\n To.Parsetree.pdir_loc = Location.none;\n }\n\nand copy_directive_argument :\n From.Parsetree.directive_argument -> To.Parsetree.directive_argument option\n =\n let wrap pdira_desc =\n Some { To.Parsetree.pdira_desc; To.Parsetree.pdira_loc = Location.none }\n in\n function\n | From.Parsetree.Pdir_none -> None\n | From.Parsetree.Pdir_string x0 -> To.Parsetree.Pdir_string x0 |> wrap\n | From.Parsetree.Pdir_int (x0, x1) ->\n To.Parsetree.Pdir_int (x0, copy_option (fun x -> x) x1) |> wrap\n | From.Parsetree.Pdir_ident x0 ->\n To.Parsetree.Pdir_ident (copy_longident x0) |> wrap\n | From.Parsetree.Pdir_bool x0 -> To.Parsetree.Pdir_bool (copy_bool x0) |> wrap\n\nand copy_expression : From.Parsetree.expression -> To.Parsetree.expression =\n fun {\n From.Parsetree.pexp_desc;\n From.Parsetree.pexp_loc;\n From.Parsetree.pexp_attributes;\n } ->\n {\n To.Parsetree.pexp_desc = copy_expression_desc pexp_desc;\n To.Parsetree.pexp_loc = copy_location pexp_loc;\n To.Parsetree.pexp_loc_stack = [];\n To.Parsetree.pexp_attributes = copy_attributes pexp_attributes;\n }\n\nand copy_expression_desc :\n From.Parsetree.expression_desc -> To.Parsetree.expression_desc = function\n | From.Parsetree.Pexp_ident x0 ->\n To.Parsetree.Pexp_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pexp_constant x0 ->\n To.Parsetree.Pexp_constant (copy_constant x0)\n | From.Parsetree.Pexp_let (x0, x1, x2) ->\n To.Parsetree.Pexp_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_expression x2)\n | From.Parsetree.Pexp_function x0 ->\n To.Parsetree.Pexp_function (List.map copy_case x0)\n | From.Parsetree.Pexp_fun (x0, x1, x2, x3) ->\n To.Parsetree.Pexp_fun\n ( copy_arg_label x0,\n copy_option copy_expression x1,\n copy_pattern x2,\n copy_expression x3 )\n | From.Parsetree.Pexp_apply (x0, x1) ->\n To.Parsetree.Pexp_apply\n ( copy_expression x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | From.Parsetree.Pexp_match (x0, x1) ->\n To.Parsetree.Pexp_match (copy_expression x0, List.map copy_case x1)\n | From.Parsetree.Pexp_try (x0, x1) ->\n To.Parsetree.Pexp_try (copy_expression x0, List.map copy_case x1)\n | From.Parsetree.Pexp_tuple x0 ->\n To.Parsetree.Pexp_tuple (List.map copy_expression x0)\n | From.Parsetree.Pexp_construct (x0, x1) ->\n To.Parsetree.Pexp_construct\n (copy_loc copy_longident x0, copy_option copy_expression x1)\n | From.Parsetree.Pexp_variant (x0, x1) ->\n To.Parsetree.Pexp_variant (copy_label x0, copy_option copy_expression x1)\n | From.Parsetree.Pexp_record (x0, x1) ->\n To.Parsetree.Pexp_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_expression x1))\n x0,\n copy_option copy_expression x1 )\n | From.Parsetree.Pexp_field (x0, x1) ->\n To.Parsetree.Pexp_field (copy_expression x0, copy_loc copy_longident x1)\n | From.Parsetree.Pexp_setfield (x0, x1, x2) ->\n To.Parsetree.Pexp_setfield\n (copy_expression x0, copy_loc copy_longident x1, copy_expression x2)\n | From.Parsetree.Pexp_array x0 ->\n To.Parsetree.Pexp_array (List.map copy_expression x0)\n | From.Parsetree.Pexp_ifthenelse (x0, x1, x2) ->\n To.Parsetree.Pexp_ifthenelse\n (copy_expression x0, copy_expression x1, copy_option copy_expression x2)\n | From.Parsetree.Pexp_sequence (x0, x1) ->\n To.Parsetree.Pexp_sequence (copy_expression x0, copy_expression x1)\n | From.Parsetree.Pexp_while (x0, x1) ->\n To.Parsetree.Pexp_while (copy_expression x0, copy_expression x1)\n | From.Parsetree.Pexp_for (x0, x1, x2, x3, x4) ->\n To.Parsetree.Pexp_for\n ( copy_pattern x0,\n copy_expression x1,\n copy_expression x2,\n copy_direction_flag x3,\n copy_expression x4 )\n | From.Parsetree.Pexp_constraint (x0, x1) ->\n To.Parsetree.Pexp_constraint (copy_expression x0, copy_core_type x1)\n | From.Parsetree.Pexp_coerce (x0, x1, x2) ->\n To.Parsetree.Pexp_coerce\n (copy_expression x0, copy_option copy_core_type x1, copy_core_type x2)\n | From.Parsetree.Pexp_send (x0, x1) ->\n To.Parsetree.Pexp_send (copy_expression x0, copy_loc copy_label x1)\n | From.Parsetree.Pexp_new x0 ->\n To.Parsetree.Pexp_new (copy_loc copy_longident x0)\n | From.Parsetree.Pexp_setinstvar (x0, x1) ->\n To.Parsetree.Pexp_setinstvar (copy_loc copy_label x0, copy_expression x1)\n | From.Parsetree.Pexp_override x0 ->\n To.Parsetree.Pexp_override\n (List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_label x0, copy_expression x1))\n x0)\n | From.Parsetree.Pexp_letmodule (x0, x1, x2) ->\n To.Parsetree.Pexp_letmodule\n (copy_loc (fun x -> x) x0, copy_module_expr x1, copy_expression x2)\n | From.Parsetree.Pexp_letexception (x0, x1) ->\n To.Parsetree.Pexp_letexception\n (copy_extension_constructor x0, copy_expression x1)\n | From.Parsetree.Pexp_assert x0 ->\n To.Parsetree.Pexp_assert (copy_expression x0)\n | From.Parsetree.Pexp_lazy x0 -> To.Parsetree.Pexp_lazy (copy_expression x0)\n | From.Parsetree.Pexp_poly (x0, x1) ->\n To.Parsetree.Pexp_poly (copy_expression x0, copy_option copy_core_type x1)\n | From.Parsetree.Pexp_object x0 ->\n To.Parsetree.Pexp_object (copy_class_structure x0)\n | From.Parsetree.Pexp_newtype (x0, x1) ->\n To.Parsetree.Pexp_newtype (copy_loc (fun x -> x) x0, copy_expression x1)\n | From.Parsetree.Pexp_pack x0 -> To.Parsetree.Pexp_pack (copy_module_expr x0)\n | From.Parsetree.Pexp_open (x0, x1, x2) ->\n To.Parsetree.Pexp_open\n ( {\n To.Parsetree.popen_expr =\n {\n To.Parsetree.pmod_desc =\n To.Parsetree.Pmod_ident (copy_loc copy_longident x1);\n To.Parsetree.pmod_loc = x1.Location.loc;\n To.Parsetree.pmod_attributes = [];\n };\n To.Parsetree.popen_override = copy_override_flag x0;\n To.Parsetree.popen_loc = x1.Location.loc;\n To.Parsetree.popen_attributes = [];\n },\n copy_expression x2 )\n | From.Parsetree.Pexp_extension x0 ->\n To.Parsetree.Pexp_extension (copy_extension x0)\n | From.Parsetree.Pexp_unreachable -> To.Parsetree.Pexp_unreachable\n\nand copy_direction_flag :\n From.Asttypes.direction_flag -> To.Asttypes.direction_flag = function\n | From.Asttypes.Upto -> To.Asttypes.Upto\n | From.Asttypes.Downto -> To.Asttypes.Downto\n\nand copy_case : From.Parsetree.case -> To.Parsetree.case =\n fun { From.Parsetree.pc_lhs; From.Parsetree.pc_guard; From.Parsetree.pc_rhs } ->\n {\n To.Parsetree.pc_lhs = copy_pattern pc_lhs;\n To.Parsetree.pc_guard = copy_option copy_expression pc_guard;\n To.Parsetree.pc_rhs = copy_expression pc_rhs;\n }\n\nand copy_value_binding :\n From.Parsetree.value_binding -> To.Parsetree.value_binding =\n fun {\n From.Parsetree.pvb_pat;\n From.Parsetree.pvb_expr;\n From.Parsetree.pvb_attributes;\n From.Parsetree.pvb_loc;\n } ->\n {\n To.Parsetree.pvb_pat = copy_pattern pvb_pat;\n To.Parsetree.pvb_expr = copy_expression pvb_expr;\n To.Parsetree.pvb_attributes = copy_attributes pvb_attributes;\n To.Parsetree.pvb_loc = copy_location pvb_loc;\n }\n\nand copy_pattern : From.Parsetree.pattern -> To.Parsetree.pattern =\n fun {\n From.Parsetree.ppat_desc;\n From.Parsetree.ppat_loc;\n From.Parsetree.ppat_attributes;\n } ->\n {\n To.Parsetree.ppat_desc = copy_pattern_desc ppat_desc;\n To.Parsetree.ppat_loc = copy_location ppat_loc;\n To.Parsetree.ppat_loc_stack = [];\n To.Parsetree.ppat_attributes = copy_attributes ppat_attributes;\n }\n\nand copy_pattern_desc : From.Parsetree.pattern_desc -> To.Parsetree.pattern_desc\n = function\n | From.Parsetree.Ppat_any -> To.Parsetree.Ppat_any\n | From.Parsetree.Ppat_var x0 ->\n To.Parsetree.Ppat_var (copy_loc (fun x -> x) x0)\n | From.Parsetree.Ppat_alias (x0, x1) ->\n To.Parsetree.Ppat_alias (copy_pattern x0, copy_loc (fun x -> x) x1)\n | From.Parsetree.Ppat_constant x0 ->\n To.Parsetree.Ppat_constant (copy_constant x0)\n | From.Parsetree.Ppat_interval (x0, x1) ->\n To.Parsetree.Ppat_interval (copy_constant x0, copy_constant x1)\n | From.Parsetree.Ppat_tuple x0 ->\n To.Parsetree.Ppat_tuple (List.map copy_pattern x0)\n | From.Parsetree.Ppat_construct (x0, x1) ->\n To.Parsetree.Ppat_construct\n (copy_loc copy_longident x0, copy_option copy_pattern x1)\n | From.Parsetree.Ppat_variant (x0, x1) ->\n To.Parsetree.Ppat_variant (copy_label x0, copy_option copy_pattern x1)\n | From.Parsetree.Ppat_record (x0, x1) ->\n To.Parsetree.Ppat_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_pattern x1))\n x0,\n copy_closed_flag x1 )\n | From.Parsetree.Ppat_array x0 ->\n To.Parsetree.Ppat_array (List.map copy_pattern x0)\n | From.Parsetree.Ppat_or (x0, x1) ->\n To.Parsetree.Ppat_or (copy_pattern x0, copy_pattern x1)\n | From.Parsetree.Ppat_constraint (x0, x1) ->\n To.Parsetree.Ppat_constraint (copy_pattern x0, copy_core_type x1)\n | From.Parsetree.Ppat_type x0 ->\n To.Parsetree.Ppat_type (copy_loc copy_longident x0)\n | From.Parsetree.Ppat_lazy x0 -> To.Parsetree.Ppat_lazy (copy_pattern x0)\n | From.Parsetree.Ppat_unpack x0 ->\n To.Parsetree.Ppat_unpack (copy_loc (fun x -> x) x0)\n | From.Parsetree.Ppat_exception x0 ->\n To.Parsetree.Ppat_exception (copy_pattern x0)\n | From.Parsetree.Ppat_extension x0 ->\n To.Parsetree.Ppat_extension (copy_extension x0)\n | From.Parsetree.Ppat_open (x0, x1) ->\n To.Parsetree.Ppat_open (copy_loc copy_longident x0, copy_pattern x1)\n\nand copy_core_type : From.Parsetree.core_type -> To.Parsetree.core_type =\n fun {\n From.Parsetree.ptyp_desc;\n From.Parsetree.ptyp_loc;\n From.Parsetree.ptyp_attributes;\n } ->\n {\n To.Parsetree.ptyp_desc = copy_core_type_desc ptyp_desc;\n To.Parsetree.ptyp_loc = copy_location ptyp_loc;\n To.Parsetree.ptyp_loc_stack = [];\n To.Parsetree.ptyp_attributes = copy_attributes ptyp_attributes;\n }\n\nand copy_core_type_desc :\n From.Parsetree.core_type_desc -> To.Parsetree.core_type_desc = function\n | From.Parsetree.Ptyp_any -> To.Parsetree.Ptyp_any\n | From.Parsetree.Ptyp_var x0 -> To.Parsetree.Ptyp_var x0\n | From.Parsetree.Ptyp_arrow (x0, x1, x2) ->\n To.Parsetree.Ptyp_arrow\n (copy_arg_label x0, copy_core_type x1, copy_core_type x2)\n | From.Parsetree.Ptyp_tuple x0 ->\n To.Parsetree.Ptyp_tuple (List.map copy_core_type x0)\n | From.Parsetree.Ptyp_constr (x0, x1) ->\n To.Parsetree.Ptyp_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Ptyp_object (x0, x1) ->\n To.Parsetree.Ptyp_object\n (List.map copy_object_field x0, copy_closed_flag x1)\n | From.Parsetree.Ptyp_class (x0, x1) ->\n To.Parsetree.Ptyp_class\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Ptyp_alias (x0, x1) ->\n To.Parsetree.Ptyp_alias (copy_core_type x0, x1)\n | From.Parsetree.Ptyp_variant (x0, x1, x2) ->\n To.Parsetree.Ptyp_variant\n ( List.map copy_row_field x0,\n copy_closed_flag x1,\n copy_option (fun x -> List.map copy_label x) x2 )\n | From.Parsetree.Ptyp_poly (x0, x1) ->\n To.Parsetree.Ptyp_poly\n (List.map (fun x -> copy_loc (fun x -> x) x) x0, copy_core_type x1)\n | From.Parsetree.Ptyp_package x0 ->\n To.Parsetree.Ptyp_package (copy_package_type x0)\n | From.Parsetree.Ptyp_extension x0 ->\n To.Parsetree.Ptyp_extension (copy_extension x0)\n\nand copy_package_type : From.Parsetree.package_type -> To.Parsetree.package_type\n =\n fun x ->\n let x0, x1 = x in\n ( copy_loc copy_longident x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_core_type x1))\n x1 )\n\nand copy_row_field : From.Parsetree.row_field -> To.Parsetree.row_field =\n function\n | From.Parsetree.Rtag (x0, x1, x2, x3) ->\n {\n To.Parsetree.prf_desc =\n To.Parsetree.Rtag\n (copy_loc copy_label x0, copy_bool x2, List.map copy_core_type x3);\n To.Parsetree.prf_loc = x0.Location.loc;\n To.Parsetree.prf_attributes = copy_attributes x1;\n }\n | From.Parsetree.Rinherit x0 ->\n {\n To.Parsetree.prf_desc = To.Parsetree.Rinherit (copy_core_type x0);\n To.Parsetree.prf_loc = x0.From.Parsetree.ptyp_loc;\n To.Parsetree.prf_attributes = [];\n }\n\nand copy_object_field : From.Parsetree.object_field -> To.Parsetree.object_field\n = function\n | From.Parsetree.Otag (x0, x1, x2) ->\n {\n To.Parsetree.pof_desc =\n To.Parsetree.Otag (copy_loc copy_label x0, copy_core_type x2);\n To.Parsetree.pof_loc = x0.Location.loc;\n To.Parsetree.pof_attributes = copy_attributes x1;\n }\n | From.Parsetree.Oinherit x0 ->\n {\n To.Parsetree.pof_desc = To.Parsetree.Oinherit (copy_core_type x0);\n To.Parsetree.pof_loc = x0.From.Parsetree.ptyp_loc;\n To.Parsetree.pof_attributes = [];\n }\n\nand copy_attributes : From.Parsetree.attributes -> To.Parsetree.attributes =\n fun x -> List.map copy_attribute x\n\nand copy_attribute : From.Parsetree.attribute -> To.Parsetree.attribute =\n fun x ->\n let x0, x1 = x in\n {\n To.Parsetree.attr_name = copy_loc (fun x -> x) x0;\n To.Parsetree.attr_payload = copy_payload x1;\n To.Parsetree.attr_loc = x0.Location.loc;\n }\n\nand copy_payload : From.Parsetree.payload -> To.Parsetree.payload = function\n | From.Parsetree.PStr x0 -> To.Parsetree.PStr (copy_structure x0)\n | From.Parsetree.PSig x0 -> To.Parsetree.PSig (copy_signature x0)\n | From.Parsetree.PTyp x0 -> To.Parsetree.PTyp (copy_core_type x0)\n | From.Parsetree.PPat (x0, x1) ->\n To.Parsetree.PPat (copy_pattern x0, copy_option copy_expression x1)\n\nand copy_structure : From.Parsetree.structure -> To.Parsetree.structure =\n fun x -> List.map copy_structure_item x\n\nand copy_structure_item :\n From.Parsetree.structure_item -> To.Parsetree.structure_item =\n fun { From.Parsetree.pstr_desc; From.Parsetree.pstr_loc } ->\n {\n To.Parsetree.pstr_desc = copy_structure_item_desc pstr_desc;\n To.Parsetree.pstr_loc = copy_location pstr_loc;\n }\n\nand copy_structure_item_desc :\n From.Parsetree.structure_item_desc -> To.Parsetree.structure_item_desc =\n function\n | From.Parsetree.Pstr_eval (x0, x1) ->\n To.Parsetree.Pstr_eval (copy_expression x0, copy_attributes x1)\n | From.Parsetree.Pstr_value (x0, x1) ->\n To.Parsetree.Pstr_value (copy_rec_flag x0, List.map copy_value_binding x1)\n | From.Parsetree.Pstr_primitive x0 ->\n To.Parsetree.Pstr_primitive (copy_value_description x0)\n | From.Parsetree.Pstr_type (x0, x1) ->\n To.Parsetree.Pstr_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | From.Parsetree.Pstr_typext x0 ->\n To.Parsetree.Pstr_typext (copy_type_extension x0)\n | From.Parsetree.Pstr_exception x0 ->\n let atat, at =\n List.partition\n (function\n | { Location.txt = \"ocaml.deprecated\" | \"deprecated\"; _ }, _ ->\n false\n | _ -> true)\n x0.pext_attributes\n in\n let x0 = { x0 with pext_attributes = at } in\n To.Parsetree.Pstr_exception\n {\n To.Parsetree.ptyexn_constructor = copy_extension_constructor x0;\n To.Parsetree.ptyexn_loc = x0.From.Parsetree.pext_loc;\n To.Parsetree.ptyexn_attributes = copy_attributes atat;\n }\n | From.Parsetree.Pstr_module x0 ->\n To.Parsetree.Pstr_module (copy_module_binding x0)\n | From.Parsetree.Pstr_recmodule x0 ->\n To.Parsetree.Pstr_recmodule (List.map copy_module_binding x0)\n | From.Parsetree.Pstr_modtype x0 ->\n To.Parsetree.Pstr_modtype (copy_module_type_declaration x0)\n | From.Parsetree.Pstr_open\n {\n From.Parsetree.popen_lid;\n From.Parsetree.popen_override;\n From.Parsetree.popen_loc;\n From.Parsetree.popen_attributes;\n } ->\n To.Parsetree.Pstr_open\n {\n To.Parsetree.popen_expr =\n {\n To.Parsetree.pmod_desc =\n To.Parsetree.Pmod_ident (copy_loc copy_longident popen_lid);\n To.Parsetree.pmod_loc = popen_loc;\n To.Parsetree.pmod_attributes = [];\n };\n To.Parsetree.popen_override = copy_override_flag popen_override;\n To.Parsetree.popen_loc = copy_location popen_loc;\n To.Parsetree.popen_attributes = copy_attributes popen_attributes;\n }\n | From.Parsetree.Pstr_class x0 ->\n To.Parsetree.Pstr_class (List.map copy_class_declaration x0)\n | From.Parsetree.Pstr_class_type x0 ->\n To.Parsetree.Pstr_class_type (List.map copy_class_type_declaration x0)\n | From.Parsetree.Pstr_include x0 ->\n To.Parsetree.Pstr_include (copy_include_declaration x0)\n | From.Parsetree.Pstr_attribute x0 ->\n To.Parsetree.Pstr_attribute (copy_attribute x0)\n | From.Parsetree.Pstr_extension (x0, x1) ->\n To.Parsetree.Pstr_extension (copy_extension x0, copy_attributes x1)\n\nand copy_include_declaration :\n From.Parsetree.include_declaration -> To.Parsetree.include_declaration =\n fun x -> copy_include_infos copy_module_expr x\n\nand copy_class_declaration :\n From.Parsetree.class_declaration -> To.Parsetree.class_declaration =\n fun x -> copy_class_infos copy_class_expr x\n\nand copy_class_expr : From.Parsetree.class_expr -> To.Parsetree.class_expr =\n fun {\n From.Parsetree.pcl_desc;\n From.Parsetree.pcl_loc;\n From.Parsetree.pcl_attributes;\n } ->\n {\n To.Parsetree.pcl_desc = copy_class_expr_desc pcl_desc;\n To.Parsetree.pcl_loc = copy_location pcl_loc;\n To.Parsetree.pcl_attributes = copy_attributes pcl_attributes;\n }\n\nand copy_class_expr_desc :\n From.Parsetree.class_expr_desc -> To.Parsetree.class_expr_desc = function\n | From.Parsetree.Pcl_constr (x0, x1) ->\n To.Parsetree.Pcl_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Pcl_structure x0 ->\n To.Parsetree.Pcl_structure (copy_class_structure x0)\n | From.Parsetree.Pcl_fun (x0, x1, x2, x3) ->\n To.Parsetree.Pcl_fun\n ( copy_arg_label x0,\n copy_option copy_expression x1,\n copy_pattern x2,\n copy_class_expr x3 )\n | From.Parsetree.Pcl_apply (x0, x1) ->\n To.Parsetree.Pcl_apply\n ( copy_class_expr x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | From.Parsetree.Pcl_let (x0, x1, x2) ->\n To.Parsetree.Pcl_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_class_expr x2)\n | From.Parsetree.Pcl_constraint (x0, x1) ->\n To.Parsetree.Pcl_constraint (copy_class_expr x0, copy_class_type x1)\n | From.Parsetree.Pcl_extension x0 ->\n To.Parsetree.Pcl_extension (copy_extension x0)\n | From.Parsetree.Pcl_open (x0, x1, x2) ->\n To.Parsetree.Pcl_open\n ( {\n To.Parsetree.popen_expr = copy_loc copy_longident x1;\n To.Parsetree.popen_override = copy_override_flag x0;\n To.Parsetree.popen_loc = x1.Location.loc;\n To.Parsetree.popen_attributes = [];\n },\n copy_class_expr x2 )\n\nand copy_class_structure :\n From.Parsetree.class_structure -> To.Parsetree.class_structure =\n fun { From.Parsetree.pcstr_self; From.Parsetree.pcstr_fields } ->\n let fields =\n List.sort\n (fun (a : From.Parsetree.class_field) (b : From.Parsetree.class_field) ->\n compare a.pcf_loc.loc_start.pos_cnum b.pcf_loc.loc_start.pos_cnum)\n pcstr_fields\n in\n {\n To.Parsetree.pcstr_self = copy_pattern pcstr_self;\n To.Parsetree.pcstr_fields = List.map copy_class_field fields;\n }\n\nand copy_class_field : From.Parsetree.class_field -> To.Parsetree.class_field =\n fun {\n From.Parsetree.pcf_desc;\n From.Parsetree.pcf_loc;\n From.Parsetree.pcf_attributes;\n } ->\n {\n To.Parsetree.pcf_desc = copy_class_field_desc pcf_desc;\n To.Parsetree.pcf_loc = copy_location pcf_loc;\n To.Parsetree.pcf_attributes = copy_attributes pcf_attributes;\n }\n\nand copy_class_field_desc :\n From.Parsetree.class_field_desc -> To.Parsetree.class_field_desc = function\n | From.Parsetree.Pcf_inherit (x0, x1, x2) ->\n To.Parsetree.Pcf_inherit\n ( copy_override_flag x0,\n copy_class_expr x1,\n copy_option (fun x -> copy_loc (fun x -> x) x) x2 )\n | From.Parsetree.Pcf_val x0 ->\n To.Parsetree.Pcf_val\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_mutable_flag x1, copy_class_field_kind x2))\n | From.Parsetree.Pcf_method x0 ->\n To.Parsetree.Pcf_method\n (let x0, x1, x2 = x0 in\n (copy_loc copy_label x0, copy_private_flag x1, copy_class_field_kind x2))\n | From.Parsetree.Pcf_constraint x0 ->\n To.Parsetree.Pcf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | From.Parsetree.Pcf_initializer x0 ->\n To.Parsetree.Pcf_initializer (copy_expression x0)\n | From.Parsetree.Pcf_attribute x0 ->\n To.Parsetree.Pcf_attribute (copy_attribute x0)\n | From.Parsetree.Pcf_extension x0 ->\n To.Parsetree.Pcf_extension (copy_extension x0)\n\nand copy_class_field_kind :\n From.Parsetree.class_field_kind -> To.Parsetree.class_field_kind = function\n | From.Parsetree.Cfk_virtual x0 ->\n To.Parsetree.Cfk_virtual (copy_core_type x0)\n | From.Parsetree.Cfk_concrete (x0, x1) ->\n To.Parsetree.Cfk_concrete (copy_override_flag x0, copy_expression x1)\n\nand copy_module_binding :\n From.Parsetree.module_binding -> To.Parsetree.module_binding =\n fun {\n From.Parsetree.pmb_name;\n From.Parsetree.pmb_expr;\n From.Parsetree.pmb_attributes;\n From.Parsetree.pmb_loc;\n } ->\n {\n To.Parsetree.pmb_name = copy_loc (fun x -> x) pmb_name;\n To.Parsetree.pmb_expr = copy_module_expr pmb_expr;\n To.Parsetree.pmb_attributes = copy_attributes pmb_attributes;\n To.Parsetree.pmb_loc = copy_location pmb_loc;\n }\n\nand copy_module_expr : From.Parsetree.module_expr -> To.Parsetree.module_expr =\n fun {\n From.Parsetree.pmod_desc;\n From.Parsetree.pmod_loc;\n From.Parsetree.pmod_attributes;\n } ->\n {\n To.Parsetree.pmod_desc = copy_module_expr_desc pmod_desc;\n To.Parsetree.pmod_loc = copy_location pmod_loc;\n To.Parsetree.pmod_attributes = copy_attributes pmod_attributes;\n }\n\nand copy_module_expr_desc :\n From.Parsetree.module_expr_desc -> To.Parsetree.module_expr_desc = function\n | From.Parsetree.Pmod_ident x0 ->\n To.Parsetree.Pmod_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pmod_structure x0 ->\n To.Parsetree.Pmod_structure (copy_structure x0)\n | From.Parsetree.Pmod_functor (x0, x1, x2) ->\n To.Parsetree.Pmod_functor\n ( copy_loc (fun x -> x) x0,\n copy_option copy_module_type x1,\n copy_module_expr x2 )\n | From.Parsetree.Pmod_apply (x0, x1) ->\n To.Parsetree.Pmod_apply (copy_module_expr x0, copy_module_expr x1)\n | From.Parsetree.Pmod_constraint (x0, x1) ->\n To.Parsetree.Pmod_constraint (copy_module_expr x0, copy_module_type x1)\n | From.Parsetree.Pmod_unpack x0 ->\n To.Parsetree.Pmod_unpack (copy_expression x0)\n | From.Parsetree.Pmod_extension x0 ->\n To.Parsetree.Pmod_extension (copy_extension x0)\n\nand copy_module_type : From.Parsetree.module_type -> To.Parsetree.module_type =\n fun {\n From.Parsetree.pmty_desc;\n From.Parsetree.pmty_loc;\n From.Parsetree.pmty_attributes;\n } ->\n {\n To.Parsetree.pmty_desc = copy_module_type_desc pmty_desc;\n To.Parsetree.pmty_loc = copy_location pmty_loc;\n To.Parsetree.pmty_attributes = copy_attributes pmty_attributes;\n }\n\nand copy_module_type_desc :\n From.Parsetree.module_type_desc -> To.Parsetree.module_type_desc = function\n | From.Parsetree.Pmty_ident x0 ->\n To.Parsetree.Pmty_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pmty_signature x0 ->\n To.Parsetree.Pmty_signature (copy_signature x0)\n | From.Parsetree.Pmty_functor (x0, x1, x2) ->\n To.Parsetree.Pmty_functor\n ( copy_loc (fun x -> x) x0,\n copy_option copy_module_type x1,\n copy_module_type x2 )\n | From.Parsetree.Pmty_with (x0, x1) ->\n To.Parsetree.Pmty_with\n (copy_module_type x0, List.map copy_with_constraint x1)\n | From.Parsetree.Pmty_typeof x0 ->\n To.Parsetree.Pmty_typeof (copy_module_expr x0)\n | From.Parsetree.Pmty_extension x0 ->\n To.Parsetree.Pmty_extension (copy_extension x0)\n | From.Parsetree.Pmty_alias x0 ->\n To.Parsetree.Pmty_alias (copy_loc copy_longident x0)\n\nand copy_with_constraint :\n From.Parsetree.with_constraint -> To.Parsetree.with_constraint = function\n | From.Parsetree.Pwith_type (x0, x1) ->\n To.Parsetree.Pwith_type\n (copy_loc copy_longident x0, copy_type_declaration x1)\n | From.Parsetree.Pwith_module (x0, x1) ->\n To.Parsetree.Pwith_module\n (copy_loc copy_longident x0, copy_loc copy_longident x1)\n | From.Parsetree.Pwith_typesubst (x0, x1) ->\n To.Parsetree.Pwith_typesubst\n (copy_loc copy_longident x0, copy_type_declaration x1)\n | From.Parsetree.Pwith_modsubst (x0, x1) ->\n To.Parsetree.Pwith_modsubst\n (copy_loc copy_longident x0, copy_loc copy_longident x1)\n\nand copy_signature : From.Parsetree.signature -> To.Parsetree.signature =\n fun x -> List.map copy_signature_item x\n\nand copy_signature_item :\n From.Parsetree.signature_item -> To.Parsetree.signature_item =\n fun { From.Parsetree.psig_desc; From.Parsetree.psig_loc } ->\n {\n To.Parsetree.psig_desc = copy_signature_item_desc psig_desc;\n To.Parsetree.psig_loc = copy_location psig_loc;\n }\n\nand copy_signature_item_desc :\n From.Parsetree.signature_item_desc -> To.Parsetree.signature_item_desc =\n function\n | From.Parsetree.Psig_value x0 ->\n To.Parsetree.Psig_value (copy_value_description x0)\n | From.Parsetree.Psig_type (x0, x1) ->\n To.Parsetree.Psig_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | From.Parsetree.Psig_typext x0 ->\n To.Parsetree.Psig_typext (copy_type_extension x0)\n | From.Parsetree.Psig_exception x0 ->\n let atat, at =\n List.partition\n (function\n | { Location.txt = \"ocaml.deprecated\" | \"deprecated\"; _ }, _ ->\n false\n | _ -> true)\n x0.pext_attributes\n in\n let x0 = { x0 with pext_attributes = at } in\n\n To.Parsetree.Psig_exception\n {\n To.Parsetree.ptyexn_constructor = copy_extension_constructor x0;\n To.Parsetree.ptyexn_loc = x0.From.Parsetree.pext_loc;\n To.Parsetree.ptyexn_attributes = copy_attributes atat;\n }\n | From.Parsetree.Psig_module x0 ->\n To.Parsetree.Psig_module (copy_module_declaration x0)\n | From.Parsetree.Psig_recmodule x0 ->\n To.Parsetree.Psig_recmodule (List.map copy_module_declaration x0)\n | From.Parsetree.Psig_modtype x0 ->\n To.Parsetree.Psig_modtype (copy_module_type_declaration x0)\n | From.Parsetree.Psig_open x0 ->\n To.Parsetree.Psig_open (copy_open_description x0)\n | From.Parsetree.Psig_include x0 ->\n To.Parsetree.Psig_include (copy_include_description x0)\n | From.Parsetree.Psig_class x0 ->\n To.Parsetree.Psig_class (List.map copy_class_description x0)\n | From.Parsetree.Psig_class_type x0 ->\n To.Parsetree.Psig_class_type (List.map copy_class_type_declaration x0)\n | From.Parsetree.Psig_attribute x0 ->\n To.Parsetree.Psig_attribute (copy_attribute x0)\n | From.Parsetree.Psig_extension (x0, x1) ->\n To.Parsetree.Psig_extension (copy_extension x0, copy_attributes x1)\n\nand copy_class_type_declaration :\n From.Parsetree.class_type_declaration -> To.Parsetree.class_type_declaration\n =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_description :\n From.Parsetree.class_description -> To.Parsetree.class_description =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_type : From.Parsetree.class_type -> To.Parsetree.class_type =\n fun {\n From.Parsetree.pcty_desc;\n From.Parsetree.pcty_loc;\n From.Parsetree.pcty_attributes;\n } ->\n {\n To.Parsetree.pcty_desc = copy_class_type_desc pcty_desc;\n To.Parsetree.pcty_loc = copy_location pcty_loc;\n To.Parsetree.pcty_attributes = copy_attributes pcty_attributes;\n }\n\nand copy_class_type_desc :\n From.Parsetree.class_type_desc -> To.Parsetree.class_type_desc = function\n | From.Parsetree.Pcty_constr (x0, x1) ->\n To.Parsetree.Pcty_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Pcty_signature x0 ->\n To.Parsetree.Pcty_signature (copy_class_signature x0)\n | From.Parsetree.Pcty_arrow (x0, x1, x2) ->\n To.Parsetree.Pcty_arrow\n (copy_arg_label x0, copy_core_type x1, copy_class_type x2)\n | From.Parsetree.Pcty_extension x0 ->\n To.Parsetree.Pcty_extension (copy_extension x0)\n | From.Parsetree.Pcty_open (x0, x1, x2) ->\n To.Parsetree.Pcty_open\n ( {\n To.Parsetree.popen_expr = copy_loc copy_longident x1;\n To.Parsetree.popen_override = copy_override_flag x0;\n To.Parsetree.popen_loc = x1.Location.loc;\n To.Parsetree.popen_attributes = [];\n },\n copy_class_type x2 )\n\nand copy_class_signature :\n From.Parsetree.class_signature -> To.Parsetree.class_signature =\n fun { From.Parsetree.pcsig_self; From.Parsetree.pcsig_fields } ->\n let fields =\n List.sort\n (fun (a : From.Parsetree.class_type_field)\n (b : From.Parsetree.class_type_field) ->\n compare a.pctf_loc.loc_start.pos_cnum b.pctf_loc.loc_start.pos_cnum)\n pcsig_fields\n in\n\n {\n To.Parsetree.pcsig_self = copy_core_type pcsig_self;\n To.Parsetree.pcsig_fields = List.map copy_class_type_field fields;\n }\n\nand copy_class_type_field :\n From.Parsetree.class_type_field -> To.Parsetree.class_type_field =\n fun {\n From.Parsetree.pctf_desc;\n From.Parsetree.pctf_loc;\n From.Parsetree.pctf_attributes;\n } ->\n {\n To.Parsetree.pctf_desc = copy_class_type_field_desc pctf_desc;\n To.Parsetree.pctf_loc = copy_location pctf_loc;\n To.Parsetree.pctf_attributes = copy_attributes pctf_attributes;\n }\n\nand copy_class_type_field_desc :\n From.Parsetree.class_type_field_desc -> To.Parsetree.class_type_field_desc =\n function\n | From.Parsetree.Pctf_inherit x0 ->\n To.Parsetree.Pctf_inherit (copy_class_type x0)\n | From.Parsetree.Pctf_val x0 ->\n To.Parsetree.Pctf_val\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_mutable_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | From.Parsetree.Pctf_method x0 ->\n To.Parsetree.Pctf_method\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc copy_label x0,\n copy_private_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | From.Parsetree.Pctf_constraint x0 ->\n To.Parsetree.Pctf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | From.Parsetree.Pctf_attribute x0 ->\n To.Parsetree.Pctf_attribute (copy_attribute x0)\n | From.Parsetree.Pctf_extension x0 ->\n To.Parsetree.Pctf_extension (copy_extension x0)\n\nand copy_extension : From.Parsetree.extension -> To.Parsetree.extension =\n fun x ->\n let x0, x1 = x in\n let x1 =\n match x0.txt with\n | \"ocaml.error\" | \"error\" -> (\n match x1 with\n | PStr (hd :: _ :: tl) -> From.Parsetree.PStr (hd :: tl)\n | _ -> x1)\n | _ -> x1\n in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_class_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 From.Parsetree.class_infos ->\n 'g0 To.Parsetree.class_infos =\n fun f0\n {\n From.Parsetree.pci_virt;\n From.Parsetree.pci_params;\n From.Parsetree.pci_name;\n From.Parsetree.pci_expr;\n From.Parsetree.pci_loc;\n From.Parsetree.pci_attributes;\n } ->\n {\n To.Parsetree.pci_virt = copy_virtual_flag pci_virt;\n To.Parsetree.pci_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n pci_params;\n To.Parsetree.pci_name = copy_loc (fun x -> x) pci_name;\n To.Parsetree.pci_expr = f0 pci_expr;\n To.Parsetree.pci_loc = copy_location pci_loc;\n To.Parsetree.pci_attributes = copy_attributes pci_attributes;\n }\n\nand copy_virtual_flag : From.Asttypes.virtual_flag -> To.Asttypes.virtual_flag =\n function\n | From.Asttypes.Virtual -> To.Asttypes.Virtual\n | From.Asttypes.Concrete -> To.Asttypes.Concrete\n\nand copy_include_description :\n From.Parsetree.include_description -> To.Parsetree.include_description =\n fun x -> copy_include_infos copy_module_type x\n\nand copy_include_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 From.Parsetree.include_infos ->\n 'g0 To.Parsetree.include_infos =\n fun f0\n {\n From.Parsetree.pincl_mod;\n From.Parsetree.pincl_loc;\n From.Parsetree.pincl_attributes;\n } ->\n {\n To.Parsetree.pincl_mod = f0 pincl_mod;\n To.Parsetree.pincl_loc = copy_location pincl_loc;\n To.Parsetree.pincl_attributes = copy_attributes pincl_attributes;\n }\n\nand copy_open_description :\n From.Parsetree.open_description -> To.Parsetree.open_description =\n fun {\n From.Parsetree.popen_lid;\n From.Parsetree.popen_override;\n From.Parsetree.popen_loc;\n From.Parsetree.popen_attributes;\n } ->\n {\n To.Parsetree.popen_expr = copy_loc copy_longident popen_lid;\n To.Parsetree.popen_override = copy_override_flag popen_override;\n To.Parsetree.popen_loc = copy_location popen_loc;\n To.Parsetree.popen_attributes = copy_attributes popen_attributes;\n }\n\nand copy_override_flag :\n From.Asttypes.override_flag -> To.Asttypes.override_flag = function\n | From.Asttypes.Override -> To.Asttypes.Override\n | From.Asttypes.Fresh -> To.Asttypes.Fresh\n\nand copy_module_type_declaration :\n From.Parsetree.module_type_declaration ->\n To.Parsetree.module_type_declaration =\n fun {\n From.Parsetree.pmtd_name;\n From.Parsetree.pmtd_type;\n From.Parsetree.pmtd_attributes;\n From.Parsetree.pmtd_loc;\n } ->\n {\n To.Parsetree.pmtd_name = copy_loc (fun x -> x) pmtd_name;\n To.Parsetree.pmtd_type = copy_option copy_module_type pmtd_type;\n To.Parsetree.pmtd_attributes = copy_attributes pmtd_attributes;\n To.Parsetree.pmtd_loc = copy_location pmtd_loc;\n }\n\nand copy_module_declaration :\n From.Parsetree.module_declaration -> To.Parsetree.module_declaration =\n fun {\n From.Parsetree.pmd_name;\n From.Parsetree.pmd_type;\n From.Parsetree.pmd_attributes;\n From.Parsetree.pmd_loc;\n } ->\n {\n To.Parsetree.pmd_name = copy_loc (fun x -> x) pmd_name;\n To.Parsetree.pmd_type = copy_module_type pmd_type;\n To.Parsetree.pmd_attributes = copy_attributes pmd_attributes;\n To.Parsetree.pmd_loc = copy_location pmd_loc;\n }\n\nand copy_type_extension :\n From.Parsetree.type_extension -> To.Parsetree.type_extension =\n fun {\n From.Parsetree.ptyext_path;\n From.Parsetree.ptyext_params;\n From.Parsetree.ptyext_constructors;\n From.Parsetree.ptyext_private;\n From.Parsetree.ptyext_attributes;\n } ->\n {\n To.Parsetree.ptyext_path = copy_loc copy_longident ptyext_path;\n To.Parsetree.ptyext_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptyext_params;\n To.Parsetree.ptyext_constructors =\n List.map copy_extension_constructor ptyext_constructors;\n To.Parsetree.ptyext_private = copy_private_flag ptyext_private;\n To.Parsetree.ptyext_loc = ptyext_path.Location.loc;\n To.Parsetree.ptyext_attributes = copy_attributes ptyext_attributes;\n }\n\nand copy_extension_constructor :\n From.Parsetree.extension_constructor -> To.Parsetree.extension_constructor =\n fun {\n From.Parsetree.pext_name;\n From.Parsetree.pext_kind;\n From.Parsetree.pext_loc;\n From.Parsetree.pext_attributes;\n } ->\n {\n To.Parsetree.pext_name = copy_loc (fun x -> x) pext_name;\n To.Parsetree.pext_kind = copy_extension_constructor_kind pext_kind;\n To.Parsetree.pext_loc = copy_location pext_loc;\n To.Parsetree.pext_attributes = copy_attributes pext_attributes;\n }\n\nand copy_extension_constructor_kind :\n From.Parsetree.extension_constructor_kind ->\n To.Parsetree.extension_constructor_kind = function\n | From.Parsetree.Pext_decl (x0, x1) ->\n To.Parsetree.Pext_decl\n (copy_constructor_arguments x0, copy_option copy_core_type x1)\n | From.Parsetree.Pext_rebind x0 ->\n To.Parsetree.Pext_rebind (copy_loc copy_longident x0)\n\nand copy_type_declaration :\n From.Parsetree.type_declaration -> To.Parsetree.type_declaration =\n fun {\n From.Parsetree.ptype_name;\n From.Parsetree.ptype_params;\n From.Parsetree.ptype_cstrs;\n From.Parsetree.ptype_kind;\n From.Parsetree.ptype_private;\n From.Parsetree.ptype_manifest;\n From.Parsetree.ptype_attributes;\n From.Parsetree.ptype_loc;\n } ->\n {\n To.Parsetree.ptype_name = copy_loc (fun x -> x) ptype_name;\n To.Parsetree.ptype_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptype_params;\n To.Parsetree.ptype_cstrs =\n List.map\n (fun x ->\n let x0, x1, x2 = x in\n (copy_core_type x0, copy_core_type x1, copy_location x2))\n ptype_cstrs;\n To.Parsetree.ptype_kind = copy_type_kind ptype_kind;\n To.Parsetree.ptype_private = copy_private_flag ptype_private;\n To.Parsetree.ptype_manifest = copy_option copy_core_type ptype_manifest;\n To.Parsetree.ptype_attributes = copy_attributes ptype_attributes;\n To.Parsetree.ptype_loc = copy_location ptype_loc;\n }\n\nand copy_private_flag : From.Asttypes.private_flag -> To.Asttypes.private_flag =\n function\n | From.Asttypes.Private -> To.Asttypes.Private\n | From.Asttypes.Public -> To.Asttypes.Public\n\nand copy_type_kind : From.Parsetree.type_kind -> To.Parsetree.type_kind =\n function\n | From.Parsetree.Ptype_abstract -> To.Parsetree.Ptype_abstract\n | From.Parsetree.Ptype_variant x0 ->\n To.Parsetree.Ptype_variant (List.map copy_constructor_declaration x0)\n | From.Parsetree.Ptype_record x0 ->\n To.Parsetree.Ptype_record (List.map copy_label_declaration x0)\n | From.Parsetree.Ptype_open -> To.Parsetree.Ptype_open\n\nand copy_constructor_declaration :\n From.Parsetree.constructor_declaration ->\n To.Parsetree.constructor_declaration =\n fun {\n From.Parsetree.pcd_name;\n From.Parsetree.pcd_args;\n From.Parsetree.pcd_res;\n From.Parsetree.pcd_loc;\n From.Parsetree.pcd_attributes;\n } ->\n {\n To.Parsetree.pcd_name = copy_loc (fun x -> x) pcd_name;\n To.Parsetree.pcd_args = copy_constructor_arguments pcd_args;\n To.Parsetree.pcd_res = copy_option copy_core_type pcd_res;\n To.Parsetree.pcd_loc = copy_location pcd_loc;\n To.Parsetree.pcd_attributes = copy_attributes pcd_attributes;\n }\n\nand copy_constructor_arguments :\n From.Parsetree.constructor_arguments -> To.Parsetree.constructor_arguments =\n function\n | From.Parsetree.Pcstr_tuple x0 ->\n To.Parsetree.Pcstr_tuple (List.map copy_core_type x0)\n | From.Parsetree.Pcstr_record x0 ->\n To.Parsetree.Pcstr_record (List.map copy_label_declaration x0)\n\nand copy_label_declaration :\n From.Parsetree.label_declaration -> To.Parsetree.label_declaration =\n fun {\n From.Parsetree.pld_name;\n From.Parsetree.pld_mutable;\n From.Parsetree.pld_type;\n From.Parsetree.pld_loc;\n From.Parsetree.pld_attributes;\n } ->\n {\n To.Parsetree.pld_name = copy_loc (fun x -> x) pld_name;\n To.Parsetree.pld_mutable = copy_mutable_flag pld_mutable;\n To.Parsetree.pld_type = copy_core_type pld_type;\n To.Parsetree.pld_loc = copy_location pld_loc;\n To.Parsetree.pld_attributes = copy_attributes pld_attributes;\n }\n\nand copy_mutable_flag : From.Asttypes.mutable_flag -> To.Asttypes.mutable_flag =\n function\n | From.Asttypes.Immutable -> To.Asttypes.Immutable\n | From.Asttypes.Mutable -> To.Asttypes.Mutable\n\nand copy_variance : From.Asttypes.variance -> To.Asttypes.variance = function\n | From.Asttypes.Covariant -> To.Asttypes.Covariant\n | From.Asttypes.Contravariant -> To.Asttypes.Contravariant\n | From.Asttypes.Invariant -> To.Asttypes.Invariant\n\nand copy_value_description :\n From.Parsetree.value_description -> To.Parsetree.value_description =\n fun {\n From.Parsetree.pval_name;\n From.Parsetree.pval_type;\n From.Parsetree.pval_prim;\n From.Parsetree.pval_attributes;\n From.Parsetree.pval_loc;\n } ->\n {\n To.Parsetree.pval_name = copy_loc (fun x -> x) pval_name;\n To.Parsetree.pval_type = copy_core_type pval_type;\n To.Parsetree.pval_prim = List.map (fun x -> x) pval_prim;\n To.Parsetree.pval_attributes = copy_attributes pval_attributes;\n To.Parsetree.pval_loc = copy_location pval_loc;\n }\n\nand copy_arg_label : From.Asttypes.arg_label -> To.Asttypes.arg_label = function\n | From.Asttypes.Nolabel -> To.Asttypes.Nolabel\n | From.Asttypes.Labelled x0 -> To.Asttypes.Labelled x0\n | From.Asttypes.Optional x0 -> To.Asttypes.Optional x0\n\nand copy_closed_flag : From.Asttypes.closed_flag -> To.Asttypes.closed_flag =\n function\n | From.Asttypes.Closed -> To.Asttypes.Closed\n | From.Asttypes.Open -> To.Asttypes.Open\n\nand copy_label : From.Asttypes.label -> To.Asttypes.label = fun x -> x\n\nand copy_rec_flag : From.Asttypes.rec_flag -> To.Asttypes.rec_flag = function\n | From.Asttypes.Nonrecursive -> To.Asttypes.Nonrecursive\n | From.Asttypes.Recursive -> To.Asttypes.Recursive\n\nand copy_constant : From.Parsetree.constant -> To.Parsetree.constant = function\n | From.Parsetree.Pconst_integer (x0, x1) ->\n To.Parsetree.Pconst_integer (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pconst_char x0 -> To.Parsetree.Pconst_char x0\n | From.Parsetree.Pconst_string (x0, x1) ->\n To.Parsetree.Pconst_string (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pconst_float (x0, x1) ->\n To.Parsetree.Pconst_float (x0, copy_option (fun x -> x) x1)\n\nand copy_option : 'f0 'g0. ('f0 -> 'g0) -> 'f0 option -> 'g0 option =\n fun f0 -> function None -> None | Some x0 -> Some (f0 x0)\n\nand copy_longident : Longident.t -> Longident.t = fun x -> x\n\nand copy_loc :\n 'f0 'g0. ('f0 -> 'g0) -> 'f0 From.Asttypes.loc -> 'g0 To.Asttypes.loc =\n fun f0 { From.Asttypes.txt; From.Asttypes.loc } ->\n { To.Asttypes.txt = f0 txt; To.Asttypes.loc = copy_location loc }\n\nand copy_location : Location.t -> Location.t = fun x -> x\nand copy_bool : bool -> bool = function false -> false | true -> true\n\nlet copy_cases x = List.map copy_case x\nlet copy_pat = copy_pattern\nlet copy_expr = copy_expression\nlet copy_typ = copy_core_type\n","(**************************************************************************)\n(* *)\n(* OCaml Migrate Parsetree *)\n(* *)\n(* Frédéric Bour *)\n(* Alain Frisch, LexiFi *)\n(* *)\n(* Copyright 2017 Institut National de Recherche en Informatique et *)\n(* en Automatique (INRIA). *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nmodule From = Ast_407\nmodule To = Ast_406\n\nlet rec copy_expression : From.Parsetree.expression -> To.Parsetree.expression =\n fun {\n From.Parsetree.pexp_desc;\n From.Parsetree.pexp_loc;\n From.Parsetree.pexp_attributes;\n } ->\n {\n To.Parsetree.pexp_desc = copy_expression_desc pexp_desc;\n To.Parsetree.pexp_loc = copy_location pexp_loc;\n To.Parsetree.pexp_attributes = copy_attributes pexp_attributes;\n }\n\nand copy_expression_desc :\n From.Parsetree.expression_desc -> To.Parsetree.expression_desc = function\n | From.Parsetree.Pexp_ident x0 ->\n To.Parsetree.Pexp_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pexp_constant x0 ->\n To.Parsetree.Pexp_constant (copy_constant x0)\n | From.Parsetree.Pexp_let (x0, x1, x2) ->\n To.Parsetree.Pexp_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_expression x2)\n | From.Parsetree.Pexp_function x0 ->\n To.Parsetree.Pexp_function (List.map copy_case x0)\n | From.Parsetree.Pexp_fun (x0, x1, x2, x3) ->\n To.Parsetree.Pexp_fun\n ( copy_arg_label x0,\n copy_option copy_expression x1,\n copy_pattern x2,\n copy_expression x3 )\n | From.Parsetree.Pexp_apply (x0, x1) ->\n To.Parsetree.Pexp_apply\n ( copy_expression x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | From.Parsetree.Pexp_match (x0, x1) ->\n To.Parsetree.Pexp_match (copy_expression x0, List.map copy_case x1)\n | From.Parsetree.Pexp_try (x0, x1) ->\n To.Parsetree.Pexp_try (copy_expression x0, List.map copy_case x1)\n | From.Parsetree.Pexp_tuple x0 ->\n To.Parsetree.Pexp_tuple (List.map copy_expression x0)\n | From.Parsetree.Pexp_construct (x0, x1) ->\n To.Parsetree.Pexp_construct\n (copy_loc copy_longident x0, copy_option copy_expression x1)\n | From.Parsetree.Pexp_variant (x0, x1) ->\n To.Parsetree.Pexp_variant (copy_label x0, copy_option copy_expression x1)\n | From.Parsetree.Pexp_record (x0, x1) ->\n To.Parsetree.Pexp_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_expression x1))\n x0,\n copy_option copy_expression x1 )\n | From.Parsetree.Pexp_field (x0, x1) ->\n To.Parsetree.Pexp_field (copy_expression x0, copy_loc copy_longident x1)\n | From.Parsetree.Pexp_setfield (x0, x1, x2) ->\n To.Parsetree.Pexp_setfield\n (copy_expression x0, copy_loc copy_longident x1, copy_expression x2)\n | From.Parsetree.Pexp_array x0 ->\n To.Parsetree.Pexp_array (List.map copy_expression x0)\n | From.Parsetree.Pexp_ifthenelse (x0, x1, x2) ->\n To.Parsetree.Pexp_ifthenelse\n (copy_expression x0, copy_expression x1, copy_option copy_expression x2)\n | From.Parsetree.Pexp_sequence (x0, x1) ->\n To.Parsetree.Pexp_sequence (copy_expression x0, copy_expression x1)\n | From.Parsetree.Pexp_while (x0, x1) ->\n To.Parsetree.Pexp_while (copy_expression x0, copy_expression x1)\n | From.Parsetree.Pexp_for (x0, x1, x2, x3, x4) ->\n To.Parsetree.Pexp_for\n ( copy_pattern x0,\n copy_expression x1,\n copy_expression x2,\n copy_direction_flag x3,\n copy_expression x4 )\n | From.Parsetree.Pexp_constraint (x0, x1) ->\n To.Parsetree.Pexp_constraint (copy_expression x0, copy_core_type x1)\n | From.Parsetree.Pexp_coerce (x0, x1, x2) ->\n To.Parsetree.Pexp_coerce\n (copy_expression x0, copy_option copy_core_type x1, copy_core_type x2)\n | From.Parsetree.Pexp_send (x0, x1) ->\n To.Parsetree.Pexp_send (copy_expression x0, copy_loc (fun x -> x) x1)\n | From.Parsetree.Pexp_new x0 ->\n To.Parsetree.Pexp_new (copy_loc copy_longident x0)\n | From.Parsetree.Pexp_setinstvar (x0, x1) ->\n To.Parsetree.Pexp_setinstvar (copy_loc (fun x -> x) x0, copy_expression x1)\n | From.Parsetree.Pexp_override x0 ->\n To.Parsetree.Pexp_override\n (List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_expression x1))\n x0)\n | From.Parsetree.Pexp_letmodule (x0, x1, x2) ->\n To.Parsetree.Pexp_letmodule\n (copy_loc (fun x -> x) x0, copy_module_expr x1, copy_expression x2)\n | From.Parsetree.Pexp_letexception (x0, x1) ->\n To.Parsetree.Pexp_letexception\n (copy_extension_constructor x0, copy_expression x1)\n | From.Parsetree.Pexp_assert x0 ->\n To.Parsetree.Pexp_assert (copy_expression x0)\n | From.Parsetree.Pexp_lazy x0 -> To.Parsetree.Pexp_lazy (copy_expression x0)\n | From.Parsetree.Pexp_poly (x0, x1) ->\n To.Parsetree.Pexp_poly (copy_expression x0, copy_option copy_core_type x1)\n | From.Parsetree.Pexp_object x0 ->\n To.Parsetree.Pexp_object (copy_class_structure x0)\n | From.Parsetree.Pexp_newtype (x0, x1) ->\n To.Parsetree.Pexp_newtype (copy_loc (fun x -> x) x0, copy_expression x1)\n | From.Parsetree.Pexp_pack x0 -> To.Parsetree.Pexp_pack (copy_module_expr x0)\n | From.Parsetree.Pexp_open (x0, x1, x2) ->\n To.Parsetree.Pexp_open\n (copy_override_flag x0, copy_loc copy_longident x1, copy_expression x2)\n | From.Parsetree.Pexp_extension x0 ->\n To.Parsetree.Pexp_extension (copy_extension x0)\n | From.Parsetree.Pexp_unreachable -> To.Parsetree.Pexp_unreachable\n\nand copy_direction_flag :\n From.Asttypes.direction_flag -> To.Asttypes.direction_flag = function\n | From.Asttypes.Upto -> To.Asttypes.Upto\n | From.Asttypes.Downto -> To.Asttypes.Downto\n\nand copy_case : From.Parsetree.case -> To.Parsetree.case =\n fun { From.Parsetree.pc_lhs; From.Parsetree.pc_guard; From.Parsetree.pc_rhs } ->\n {\n To.Parsetree.pc_lhs = copy_pattern pc_lhs;\n To.Parsetree.pc_guard = copy_option copy_expression pc_guard;\n To.Parsetree.pc_rhs = copy_expression pc_rhs;\n }\n\nand copy_value_binding :\n From.Parsetree.value_binding -> To.Parsetree.value_binding =\n fun {\n From.Parsetree.pvb_pat;\n From.Parsetree.pvb_expr;\n From.Parsetree.pvb_attributes;\n From.Parsetree.pvb_loc;\n } ->\n {\n To.Parsetree.pvb_pat = copy_pattern pvb_pat;\n To.Parsetree.pvb_expr = copy_expression pvb_expr;\n To.Parsetree.pvb_attributes = copy_attributes pvb_attributes;\n To.Parsetree.pvb_loc = copy_location pvb_loc;\n }\n\nand copy_pattern : From.Parsetree.pattern -> To.Parsetree.pattern =\n fun {\n From.Parsetree.ppat_desc;\n From.Parsetree.ppat_loc;\n From.Parsetree.ppat_attributes;\n } ->\n {\n To.Parsetree.ppat_desc = copy_pattern_desc ppat_desc;\n To.Parsetree.ppat_loc = copy_location ppat_loc;\n To.Parsetree.ppat_attributes = copy_attributes ppat_attributes;\n }\n\nand copy_pattern_desc : From.Parsetree.pattern_desc -> To.Parsetree.pattern_desc\n = function\n | From.Parsetree.Ppat_any -> To.Parsetree.Ppat_any\n | From.Parsetree.Ppat_var x0 ->\n To.Parsetree.Ppat_var (copy_loc (fun x -> x) x0)\n | From.Parsetree.Ppat_alias (x0, x1) ->\n To.Parsetree.Ppat_alias (copy_pattern x0, copy_loc (fun x -> x) x1)\n | From.Parsetree.Ppat_constant x0 ->\n To.Parsetree.Ppat_constant (copy_constant x0)\n | From.Parsetree.Ppat_interval (x0, x1) ->\n To.Parsetree.Ppat_interval (copy_constant x0, copy_constant x1)\n | From.Parsetree.Ppat_tuple x0 ->\n To.Parsetree.Ppat_tuple (List.map copy_pattern x0)\n | From.Parsetree.Ppat_construct (x0, x1) ->\n To.Parsetree.Ppat_construct\n (copy_loc copy_longident x0, copy_option copy_pattern x1)\n | From.Parsetree.Ppat_variant (x0, x1) ->\n To.Parsetree.Ppat_variant (copy_label x0, copy_option copy_pattern x1)\n | From.Parsetree.Ppat_record (x0, x1) ->\n To.Parsetree.Ppat_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_pattern x1))\n x0,\n copy_closed_flag x1 )\n | From.Parsetree.Ppat_array x0 ->\n To.Parsetree.Ppat_array (List.map copy_pattern x0)\n | From.Parsetree.Ppat_or (x0, x1) ->\n To.Parsetree.Ppat_or (copy_pattern x0, copy_pattern x1)\n | From.Parsetree.Ppat_constraint (x0, x1) ->\n To.Parsetree.Ppat_constraint (copy_pattern x0, copy_core_type x1)\n | From.Parsetree.Ppat_type x0 ->\n To.Parsetree.Ppat_type (copy_loc copy_longident x0)\n | From.Parsetree.Ppat_lazy x0 -> To.Parsetree.Ppat_lazy (copy_pattern x0)\n | From.Parsetree.Ppat_unpack x0 ->\n To.Parsetree.Ppat_unpack (copy_loc (fun x -> x) x0)\n | From.Parsetree.Ppat_exception x0 ->\n To.Parsetree.Ppat_exception (copy_pattern x0)\n | From.Parsetree.Ppat_extension x0 ->\n To.Parsetree.Ppat_extension (copy_extension x0)\n | From.Parsetree.Ppat_open (x0, x1) ->\n To.Parsetree.Ppat_open (copy_loc copy_longident x0, copy_pattern x1)\n\nand copy_core_type : From.Parsetree.core_type -> To.Parsetree.core_type =\n fun {\n From.Parsetree.ptyp_desc;\n From.Parsetree.ptyp_loc;\n From.Parsetree.ptyp_attributes;\n } ->\n {\n To.Parsetree.ptyp_desc = copy_core_type_desc ptyp_desc;\n To.Parsetree.ptyp_loc = copy_location ptyp_loc;\n To.Parsetree.ptyp_attributes = copy_attributes ptyp_attributes;\n }\n\nand copy_core_type_desc :\n From.Parsetree.core_type_desc -> To.Parsetree.core_type_desc = function\n | From.Parsetree.Ptyp_any -> To.Parsetree.Ptyp_any\n | From.Parsetree.Ptyp_var x0 -> To.Parsetree.Ptyp_var x0\n | From.Parsetree.Ptyp_arrow (x0, x1, x2) ->\n To.Parsetree.Ptyp_arrow\n (copy_arg_label x0, copy_core_type x1, copy_core_type x2)\n | From.Parsetree.Ptyp_tuple x0 ->\n To.Parsetree.Ptyp_tuple (List.map copy_core_type x0)\n | From.Parsetree.Ptyp_constr (x0, x1) ->\n To.Parsetree.Ptyp_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Ptyp_object (x0, x1) ->\n To.Parsetree.Ptyp_object\n (List.map copy_object_field x0, copy_closed_flag x1)\n | From.Parsetree.Ptyp_class (x0, x1) ->\n To.Parsetree.Ptyp_class\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Ptyp_alias (x0, x1) ->\n To.Parsetree.Ptyp_alias (copy_core_type x0, x1)\n | From.Parsetree.Ptyp_variant (x0, x1, x2) ->\n To.Parsetree.Ptyp_variant\n ( List.map copy_row_field x0,\n copy_closed_flag x1,\n copy_option (fun x -> List.map copy_label x) x2 )\n | From.Parsetree.Ptyp_poly (x0, x1) ->\n To.Parsetree.Ptyp_poly\n (List.map (fun x -> copy_loc (fun x -> x) x) x0, copy_core_type x1)\n | From.Parsetree.Ptyp_package x0 ->\n To.Parsetree.Ptyp_package (copy_package_type x0)\n | From.Parsetree.Ptyp_extension x0 ->\n To.Parsetree.Ptyp_extension (copy_extension x0)\n\nand copy_package_type : From.Parsetree.package_type -> To.Parsetree.package_type\n =\n fun x ->\n let x0, x1 = x in\n ( copy_loc copy_longident x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_core_type x1))\n x1 )\n\nand copy_row_field : From.Parsetree.row_field -> To.Parsetree.row_field =\n function\n | From.Parsetree.Rtag (x0, x1, x2, x3) ->\n To.Parsetree.Rtag\n ( copy_loc copy_label x0,\n copy_attributes x1,\n copy_bool x2,\n List.map copy_core_type x3 )\n | From.Parsetree.Rinherit x0 -> To.Parsetree.Rinherit (copy_core_type x0)\n\nand copy_object_field : From.Parsetree.object_field -> To.Parsetree.object_field\n = function\n | From.Parsetree.Otag (x0, x1, x2) ->\n To.Parsetree.Otag\n (copy_loc (fun x -> x) x0, copy_attributes x1, copy_core_type x2)\n | From.Parsetree.Oinherit x -> To.Parsetree.Oinherit (copy_core_type x)\n\nand copy_attributes : From.Parsetree.attributes -> To.Parsetree.attributes =\n fun x -> List.map copy_attribute x\n\nand copy_attribute : From.Parsetree.attribute -> To.Parsetree.attribute =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_payload : From.Parsetree.payload -> To.Parsetree.payload = function\n | From.Parsetree.PStr x0 -> To.Parsetree.PStr (copy_structure x0)\n | From.Parsetree.PSig x0 -> To.Parsetree.PSig (copy_signature x0)\n | From.Parsetree.PTyp x0 -> To.Parsetree.PTyp (copy_core_type x0)\n | From.Parsetree.PPat (x0, x1) ->\n To.Parsetree.PPat (copy_pattern x0, copy_option copy_expression x1)\n\nand copy_structure : From.Parsetree.structure -> To.Parsetree.structure =\n fun x -> List.map copy_structure_item x\n\nand copy_structure_item :\n From.Parsetree.structure_item -> To.Parsetree.structure_item =\n fun { From.Parsetree.pstr_desc; From.Parsetree.pstr_loc } ->\n {\n To.Parsetree.pstr_desc = copy_structure_item_desc pstr_desc;\n To.Parsetree.pstr_loc = copy_location pstr_loc;\n }\n\nand copy_structure_item_desc :\n From.Parsetree.structure_item_desc -> To.Parsetree.structure_item_desc =\n function\n | From.Parsetree.Pstr_eval (x0, x1) ->\n To.Parsetree.Pstr_eval (copy_expression x0, copy_attributes x1)\n | From.Parsetree.Pstr_value (x0, x1) ->\n To.Parsetree.Pstr_value (copy_rec_flag x0, List.map copy_value_binding x1)\n | From.Parsetree.Pstr_primitive x0 ->\n To.Parsetree.Pstr_primitive (copy_value_description x0)\n | From.Parsetree.Pstr_type (x0, x1) ->\n To.Parsetree.Pstr_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | From.Parsetree.Pstr_typext x0 ->\n To.Parsetree.Pstr_typext (copy_type_extension x0)\n | From.Parsetree.Pstr_exception x0 ->\n To.Parsetree.Pstr_exception (copy_extension_constructor x0)\n | From.Parsetree.Pstr_module x0 ->\n To.Parsetree.Pstr_module (copy_module_binding x0)\n | From.Parsetree.Pstr_recmodule x0 ->\n To.Parsetree.Pstr_recmodule (List.map copy_module_binding x0)\n | From.Parsetree.Pstr_modtype x0 ->\n To.Parsetree.Pstr_modtype (copy_module_type_declaration x0)\n | From.Parsetree.Pstr_open x0 ->\n To.Parsetree.Pstr_open (copy_open_description x0)\n | From.Parsetree.Pstr_class x0 ->\n To.Parsetree.Pstr_class (List.map copy_class_declaration x0)\n | From.Parsetree.Pstr_class_type x0 ->\n To.Parsetree.Pstr_class_type (List.map copy_class_type_declaration x0)\n | From.Parsetree.Pstr_include x0 ->\n To.Parsetree.Pstr_include (copy_include_declaration x0)\n | From.Parsetree.Pstr_attribute x0 ->\n To.Parsetree.Pstr_attribute (copy_attribute x0)\n | From.Parsetree.Pstr_extension (x0, x1) ->\n To.Parsetree.Pstr_extension (copy_extension x0, copy_attributes x1)\n\nand copy_include_declaration :\n From.Parsetree.include_declaration -> To.Parsetree.include_declaration =\n fun x -> copy_include_infos copy_module_expr x\n\nand copy_class_declaration :\n From.Parsetree.class_declaration -> To.Parsetree.class_declaration =\n fun x -> copy_class_infos copy_class_expr x\n\nand copy_class_expr : From.Parsetree.class_expr -> To.Parsetree.class_expr =\n fun {\n From.Parsetree.pcl_desc;\n From.Parsetree.pcl_loc;\n From.Parsetree.pcl_attributes;\n } ->\n {\n To.Parsetree.pcl_desc = copy_class_expr_desc pcl_desc;\n To.Parsetree.pcl_loc = copy_location pcl_loc;\n To.Parsetree.pcl_attributes = copy_attributes pcl_attributes;\n }\n\nand copy_class_expr_desc :\n From.Parsetree.class_expr_desc -> To.Parsetree.class_expr_desc = function\n | From.Parsetree.Pcl_constr (x0, x1) ->\n To.Parsetree.Pcl_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Pcl_structure x0 ->\n To.Parsetree.Pcl_structure (copy_class_structure x0)\n | From.Parsetree.Pcl_fun (x0, x1, x2, x3) ->\n To.Parsetree.Pcl_fun\n ( copy_arg_label x0,\n copy_option copy_expression x1,\n copy_pattern x2,\n copy_class_expr x3 )\n | From.Parsetree.Pcl_apply (x0, x1) ->\n To.Parsetree.Pcl_apply\n ( copy_class_expr x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | From.Parsetree.Pcl_let (x0, x1, x2) ->\n To.Parsetree.Pcl_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_class_expr x2)\n | From.Parsetree.Pcl_constraint (x0, x1) ->\n To.Parsetree.Pcl_constraint (copy_class_expr x0, copy_class_type x1)\n | From.Parsetree.Pcl_extension x0 ->\n To.Parsetree.Pcl_extension (copy_extension x0)\n | From.Parsetree.Pcl_open (ovf, loc, ce) ->\n To.Parsetree.Pcl_open\n (copy_override_flag ovf, copy_loc copy_longident loc, copy_class_expr ce)\n\nand copy_class_structure :\n From.Parsetree.class_structure -> To.Parsetree.class_structure =\n fun { From.Parsetree.pcstr_self; From.Parsetree.pcstr_fields } ->\n {\n To.Parsetree.pcstr_self = copy_pattern pcstr_self;\n To.Parsetree.pcstr_fields = List.map copy_class_field pcstr_fields;\n }\n\nand copy_class_field : From.Parsetree.class_field -> To.Parsetree.class_field =\n fun {\n From.Parsetree.pcf_desc;\n From.Parsetree.pcf_loc;\n From.Parsetree.pcf_attributes;\n } ->\n {\n To.Parsetree.pcf_desc = copy_class_field_desc pcf_desc;\n To.Parsetree.pcf_loc = copy_location pcf_loc;\n To.Parsetree.pcf_attributes = copy_attributes pcf_attributes;\n }\n\nand copy_class_field_desc :\n From.Parsetree.class_field_desc -> To.Parsetree.class_field_desc = function\n | From.Parsetree.Pcf_inherit (x0, x1, x2) ->\n To.Parsetree.Pcf_inherit\n ( copy_override_flag x0,\n copy_class_expr x1,\n copy_option (copy_loc (fun x -> x)) x2 )\n | From.Parsetree.Pcf_val x0 ->\n To.Parsetree.Pcf_val\n (let x0, x1, x2 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_mutable_flag x1,\n copy_class_field_kind x2 ))\n | From.Parsetree.Pcf_method x0 ->\n To.Parsetree.Pcf_method\n (let x0, x1, x2 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_private_flag x1,\n copy_class_field_kind x2 ))\n | From.Parsetree.Pcf_constraint x0 ->\n To.Parsetree.Pcf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | From.Parsetree.Pcf_initializer x0 ->\n To.Parsetree.Pcf_initializer (copy_expression x0)\n | From.Parsetree.Pcf_attribute x0 ->\n To.Parsetree.Pcf_attribute (copy_attribute x0)\n | From.Parsetree.Pcf_extension x0 ->\n To.Parsetree.Pcf_extension (copy_extension x0)\n\nand copy_class_field_kind :\n From.Parsetree.class_field_kind -> To.Parsetree.class_field_kind = function\n | From.Parsetree.Cfk_virtual x0 ->\n To.Parsetree.Cfk_virtual (copy_core_type x0)\n | From.Parsetree.Cfk_concrete (x0, x1) ->\n To.Parsetree.Cfk_concrete (copy_override_flag x0, copy_expression x1)\n\nand copy_module_binding :\n From.Parsetree.module_binding -> To.Parsetree.module_binding =\n fun {\n From.Parsetree.pmb_name;\n From.Parsetree.pmb_expr;\n From.Parsetree.pmb_attributes;\n From.Parsetree.pmb_loc;\n } ->\n {\n To.Parsetree.pmb_name = copy_loc (fun x -> x) pmb_name;\n To.Parsetree.pmb_expr = copy_module_expr pmb_expr;\n To.Parsetree.pmb_attributes = copy_attributes pmb_attributes;\n To.Parsetree.pmb_loc = copy_location pmb_loc;\n }\n\nand copy_module_expr : From.Parsetree.module_expr -> To.Parsetree.module_expr =\n fun {\n From.Parsetree.pmod_desc;\n From.Parsetree.pmod_loc;\n From.Parsetree.pmod_attributes;\n } ->\n {\n To.Parsetree.pmod_desc = copy_module_expr_desc pmod_desc;\n To.Parsetree.pmod_loc = copy_location pmod_loc;\n To.Parsetree.pmod_attributes = copy_attributes pmod_attributes;\n }\n\nand copy_module_expr_desc :\n From.Parsetree.module_expr_desc -> To.Parsetree.module_expr_desc = function\n | From.Parsetree.Pmod_ident x0 ->\n To.Parsetree.Pmod_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pmod_structure x0 ->\n To.Parsetree.Pmod_structure (copy_structure x0)\n | From.Parsetree.Pmod_functor (x0, x1, x2) ->\n To.Parsetree.Pmod_functor\n ( copy_loc (fun x -> x) x0,\n copy_option copy_module_type x1,\n copy_module_expr x2 )\n | From.Parsetree.Pmod_apply (x0, x1) ->\n To.Parsetree.Pmod_apply (copy_module_expr x0, copy_module_expr x1)\n | From.Parsetree.Pmod_constraint (x0, x1) ->\n To.Parsetree.Pmod_constraint (copy_module_expr x0, copy_module_type x1)\n | From.Parsetree.Pmod_unpack x0 ->\n To.Parsetree.Pmod_unpack (copy_expression x0)\n | From.Parsetree.Pmod_extension x0 ->\n To.Parsetree.Pmod_extension (copy_extension x0)\n\nand copy_module_type : From.Parsetree.module_type -> To.Parsetree.module_type =\n fun {\n From.Parsetree.pmty_desc;\n From.Parsetree.pmty_loc;\n From.Parsetree.pmty_attributes;\n } ->\n {\n To.Parsetree.pmty_desc = copy_module_type_desc pmty_desc;\n To.Parsetree.pmty_loc = copy_location pmty_loc;\n To.Parsetree.pmty_attributes = copy_attributes pmty_attributes;\n }\n\nand copy_module_type_desc :\n From.Parsetree.module_type_desc -> To.Parsetree.module_type_desc = function\n | From.Parsetree.Pmty_ident x0 ->\n To.Parsetree.Pmty_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pmty_signature x0 ->\n To.Parsetree.Pmty_signature (copy_signature x0)\n | From.Parsetree.Pmty_functor (x0, x1, x2) ->\n To.Parsetree.Pmty_functor\n ( copy_loc (fun x -> x) x0,\n copy_option copy_module_type x1,\n copy_module_type x2 )\n | From.Parsetree.Pmty_with (x0, x1) ->\n To.Parsetree.Pmty_with\n (copy_module_type x0, List.map copy_with_constraint x1)\n | From.Parsetree.Pmty_typeof x0 ->\n To.Parsetree.Pmty_typeof (copy_module_expr x0)\n | From.Parsetree.Pmty_extension x0 ->\n To.Parsetree.Pmty_extension (copy_extension x0)\n | From.Parsetree.Pmty_alias x0 ->\n To.Parsetree.Pmty_alias (copy_loc copy_longident x0)\n\nand copy_with_constraint :\n From.Parsetree.with_constraint -> To.Parsetree.with_constraint = function\n | From.Parsetree.Pwith_type (x0, x1) ->\n To.Parsetree.Pwith_type\n (copy_loc copy_longident x0, copy_type_declaration x1)\n | From.Parsetree.Pwith_module (x0, x1) ->\n To.Parsetree.Pwith_module\n (copy_loc copy_longident x0, copy_loc copy_longident x1)\n | From.Parsetree.Pwith_typesubst (x0, x1) ->\n To.Parsetree.Pwith_typesubst\n (copy_loc copy_longident x0, copy_type_declaration x1)\n | From.Parsetree.Pwith_modsubst (x0, x1) ->\n To.Parsetree.Pwith_modsubst\n (copy_loc copy_longident x0, copy_loc copy_longident x1)\n\nand copy_signature : From.Parsetree.signature -> To.Parsetree.signature =\n fun x -> List.map copy_signature_item x\n\nand copy_signature_item :\n From.Parsetree.signature_item -> To.Parsetree.signature_item =\n fun { From.Parsetree.psig_desc; From.Parsetree.psig_loc } ->\n {\n To.Parsetree.psig_desc = copy_signature_item_desc psig_desc;\n To.Parsetree.psig_loc = copy_location psig_loc;\n }\n\nand copy_signature_item_desc :\n From.Parsetree.signature_item_desc -> To.Parsetree.signature_item_desc =\n function\n | From.Parsetree.Psig_value x0 ->\n To.Parsetree.Psig_value (copy_value_description x0)\n | From.Parsetree.Psig_type (x0, x1) ->\n To.Parsetree.Psig_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | From.Parsetree.Psig_typext x0 ->\n To.Parsetree.Psig_typext (copy_type_extension x0)\n | From.Parsetree.Psig_exception x0 ->\n To.Parsetree.Psig_exception (copy_extension_constructor x0)\n | From.Parsetree.Psig_module x0 ->\n To.Parsetree.Psig_module (copy_module_declaration x0)\n | From.Parsetree.Psig_recmodule x0 ->\n To.Parsetree.Psig_recmodule (List.map copy_module_declaration x0)\n | From.Parsetree.Psig_modtype x0 ->\n To.Parsetree.Psig_modtype (copy_module_type_declaration x0)\n | From.Parsetree.Psig_open x0 ->\n To.Parsetree.Psig_open (copy_open_description x0)\n | From.Parsetree.Psig_include x0 ->\n To.Parsetree.Psig_include (copy_include_description x0)\n | From.Parsetree.Psig_class x0 ->\n To.Parsetree.Psig_class (List.map copy_class_description x0)\n | From.Parsetree.Psig_class_type x0 ->\n To.Parsetree.Psig_class_type (List.map copy_class_type_declaration x0)\n | From.Parsetree.Psig_attribute x0 ->\n To.Parsetree.Psig_attribute (copy_attribute x0)\n | From.Parsetree.Psig_extension (x0, x1) ->\n To.Parsetree.Psig_extension (copy_extension x0, copy_attributes x1)\n\nand copy_class_type_declaration :\n From.Parsetree.class_type_declaration -> To.Parsetree.class_type_declaration\n =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_description :\n From.Parsetree.class_description -> To.Parsetree.class_description =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_type : From.Parsetree.class_type -> To.Parsetree.class_type =\n fun {\n From.Parsetree.pcty_desc;\n From.Parsetree.pcty_loc;\n From.Parsetree.pcty_attributes;\n } ->\n {\n To.Parsetree.pcty_desc = copy_class_type_desc pcty_desc;\n To.Parsetree.pcty_loc = copy_location pcty_loc;\n To.Parsetree.pcty_attributes = copy_attributes pcty_attributes;\n }\n\nand copy_class_type_desc :\n From.Parsetree.class_type_desc -> To.Parsetree.class_type_desc = function\n | From.Parsetree.Pcty_constr (x0, x1) ->\n To.Parsetree.Pcty_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Pcty_signature x0 ->\n To.Parsetree.Pcty_signature (copy_class_signature x0)\n | From.Parsetree.Pcty_arrow (x0, x1, x2) ->\n To.Parsetree.Pcty_arrow\n (copy_arg_label x0, copy_core_type x1, copy_class_type x2)\n | From.Parsetree.Pcty_extension x0 ->\n To.Parsetree.Pcty_extension (copy_extension x0)\n | From.Parsetree.Pcty_open (ovf, loc, cty) ->\n To.Parsetree.Pcty_open\n ( copy_override_flag ovf,\n copy_loc copy_longident loc,\n copy_class_type cty )\n\nand copy_class_signature :\n From.Parsetree.class_signature -> To.Parsetree.class_signature =\n fun { From.Parsetree.pcsig_self; From.Parsetree.pcsig_fields } ->\n {\n To.Parsetree.pcsig_self = copy_core_type pcsig_self;\n To.Parsetree.pcsig_fields = List.map copy_class_type_field pcsig_fields;\n }\n\nand copy_class_type_field :\n From.Parsetree.class_type_field -> To.Parsetree.class_type_field =\n fun {\n From.Parsetree.pctf_desc;\n From.Parsetree.pctf_loc;\n From.Parsetree.pctf_attributes;\n } ->\n {\n To.Parsetree.pctf_desc = copy_class_type_field_desc pctf_desc;\n To.Parsetree.pctf_loc = copy_location pctf_loc;\n To.Parsetree.pctf_attributes = copy_attributes pctf_attributes;\n }\n\nand copy_class_type_field_desc :\n From.Parsetree.class_type_field_desc -> To.Parsetree.class_type_field_desc =\n function\n | From.Parsetree.Pctf_inherit x0 ->\n To.Parsetree.Pctf_inherit (copy_class_type x0)\n | From.Parsetree.Pctf_val x0 ->\n To.Parsetree.Pctf_val\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_mutable_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | From.Parsetree.Pctf_method x0 ->\n To.Parsetree.Pctf_method\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_private_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | From.Parsetree.Pctf_constraint x0 ->\n To.Parsetree.Pctf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | From.Parsetree.Pctf_attribute x0 ->\n To.Parsetree.Pctf_attribute (copy_attribute x0)\n | From.Parsetree.Pctf_extension x0 ->\n To.Parsetree.Pctf_extension (copy_extension x0)\n\nand copy_extension : From.Parsetree.extension -> To.Parsetree.extension =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_class_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 From.Parsetree.class_infos ->\n 'g0 To.Parsetree.class_infos =\n fun f0\n {\n From.Parsetree.pci_virt;\n From.Parsetree.pci_params;\n From.Parsetree.pci_name;\n From.Parsetree.pci_expr;\n From.Parsetree.pci_loc;\n From.Parsetree.pci_attributes;\n } ->\n {\n To.Parsetree.pci_virt = copy_virtual_flag pci_virt;\n To.Parsetree.pci_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n pci_params;\n To.Parsetree.pci_name = copy_loc (fun x -> x) pci_name;\n To.Parsetree.pci_expr = f0 pci_expr;\n To.Parsetree.pci_loc = copy_location pci_loc;\n To.Parsetree.pci_attributes = copy_attributes pci_attributes;\n }\n\nand copy_virtual_flag : From.Asttypes.virtual_flag -> To.Asttypes.virtual_flag =\n function\n | From.Asttypes.Virtual -> To.Asttypes.Virtual\n | From.Asttypes.Concrete -> To.Asttypes.Concrete\n\nand copy_include_description :\n From.Parsetree.include_description -> To.Parsetree.include_description =\n fun x -> copy_include_infos copy_module_type x\n\nand copy_include_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 From.Parsetree.include_infos ->\n 'g0 To.Parsetree.include_infos =\n fun f0\n {\n From.Parsetree.pincl_mod;\n From.Parsetree.pincl_loc;\n From.Parsetree.pincl_attributes;\n } ->\n {\n To.Parsetree.pincl_mod = f0 pincl_mod;\n To.Parsetree.pincl_loc = copy_location pincl_loc;\n To.Parsetree.pincl_attributes = copy_attributes pincl_attributes;\n }\n\nand copy_open_description :\n From.Parsetree.open_description -> To.Parsetree.open_description =\n fun {\n From.Parsetree.popen_lid;\n From.Parsetree.popen_override;\n From.Parsetree.popen_loc;\n From.Parsetree.popen_attributes;\n } ->\n {\n To.Parsetree.popen_lid = copy_loc copy_longident popen_lid;\n To.Parsetree.popen_override = copy_override_flag popen_override;\n To.Parsetree.popen_loc = copy_location popen_loc;\n To.Parsetree.popen_attributes = copy_attributes popen_attributes;\n }\n\nand copy_override_flag :\n From.Asttypes.override_flag -> To.Asttypes.override_flag = function\n | From.Asttypes.Override -> To.Asttypes.Override\n | From.Asttypes.Fresh -> To.Asttypes.Fresh\n\nand copy_module_type_declaration :\n From.Parsetree.module_type_declaration ->\n To.Parsetree.module_type_declaration =\n fun {\n From.Parsetree.pmtd_name;\n From.Parsetree.pmtd_type;\n From.Parsetree.pmtd_attributes;\n From.Parsetree.pmtd_loc;\n } ->\n {\n To.Parsetree.pmtd_name = copy_loc (fun x -> x) pmtd_name;\n To.Parsetree.pmtd_type = copy_option copy_module_type pmtd_type;\n To.Parsetree.pmtd_attributes = copy_attributes pmtd_attributes;\n To.Parsetree.pmtd_loc = copy_location pmtd_loc;\n }\n\nand copy_module_declaration :\n From.Parsetree.module_declaration -> To.Parsetree.module_declaration =\n fun {\n From.Parsetree.pmd_name;\n From.Parsetree.pmd_type;\n From.Parsetree.pmd_attributes;\n From.Parsetree.pmd_loc;\n } ->\n {\n To.Parsetree.pmd_name = copy_loc (fun x -> x) pmd_name;\n To.Parsetree.pmd_type = copy_module_type pmd_type;\n To.Parsetree.pmd_attributes = copy_attributes pmd_attributes;\n To.Parsetree.pmd_loc = copy_location pmd_loc;\n }\n\nand copy_type_extension :\n From.Parsetree.type_extension -> To.Parsetree.type_extension =\n fun {\n From.Parsetree.ptyext_path;\n From.Parsetree.ptyext_params;\n From.Parsetree.ptyext_constructors;\n From.Parsetree.ptyext_private;\n From.Parsetree.ptyext_attributes;\n } ->\n {\n To.Parsetree.ptyext_path = copy_loc copy_longident ptyext_path;\n To.Parsetree.ptyext_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptyext_params;\n To.Parsetree.ptyext_constructors =\n List.map copy_extension_constructor ptyext_constructors;\n To.Parsetree.ptyext_private = copy_private_flag ptyext_private;\n To.Parsetree.ptyext_attributes = copy_attributes ptyext_attributes;\n }\n\nand copy_extension_constructor :\n From.Parsetree.extension_constructor -> To.Parsetree.extension_constructor =\n fun {\n From.Parsetree.pext_name;\n From.Parsetree.pext_kind;\n From.Parsetree.pext_loc;\n From.Parsetree.pext_attributes;\n } ->\n {\n To.Parsetree.pext_name = copy_loc (fun x -> x) pext_name;\n To.Parsetree.pext_kind = copy_extension_constructor_kind pext_kind;\n To.Parsetree.pext_loc = copy_location pext_loc;\n To.Parsetree.pext_attributes = copy_attributes pext_attributes;\n }\n\nand copy_extension_constructor_kind :\n From.Parsetree.extension_constructor_kind ->\n To.Parsetree.extension_constructor_kind = function\n | From.Parsetree.Pext_decl (x0, x1) ->\n To.Parsetree.Pext_decl\n (copy_constructor_arguments x0, copy_option copy_core_type x1)\n | From.Parsetree.Pext_rebind x0 ->\n To.Parsetree.Pext_rebind (copy_loc copy_longident x0)\n\nand copy_type_declaration :\n From.Parsetree.type_declaration -> To.Parsetree.type_declaration =\n fun {\n From.Parsetree.ptype_name;\n From.Parsetree.ptype_params;\n From.Parsetree.ptype_cstrs;\n From.Parsetree.ptype_kind;\n From.Parsetree.ptype_private;\n From.Parsetree.ptype_manifest;\n From.Parsetree.ptype_attributes;\n From.Parsetree.ptype_loc;\n } ->\n {\n To.Parsetree.ptype_name = copy_loc (fun x -> x) ptype_name;\n To.Parsetree.ptype_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptype_params;\n To.Parsetree.ptype_cstrs =\n List.map\n (fun x ->\n let x0, x1, x2 = x in\n (copy_core_type x0, copy_core_type x1, copy_location x2))\n ptype_cstrs;\n To.Parsetree.ptype_kind = copy_type_kind ptype_kind;\n To.Parsetree.ptype_private = copy_private_flag ptype_private;\n To.Parsetree.ptype_manifest = copy_option copy_core_type ptype_manifest;\n To.Parsetree.ptype_attributes = copy_attributes ptype_attributes;\n To.Parsetree.ptype_loc = copy_location ptype_loc;\n }\n\nand copy_private_flag : From.Asttypes.private_flag -> To.Asttypes.private_flag =\n function\n | From.Asttypes.Private -> To.Asttypes.Private\n | From.Asttypes.Public -> To.Asttypes.Public\n\nand copy_type_kind : From.Parsetree.type_kind -> To.Parsetree.type_kind =\n function\n | From.Parsetree.Ptype_abstract -> To.Parsetree.Ptype_abstract\n | From.Parsetree.Ptype_variant x0 ->\n To.Parsetree.Ptype_variant (List.map copy_constructor_declaration x0)\n | From.Parsetree.Ptype_record x0 ->\n To.Parsetree.Ptype_record (List.map copy_label_declaration x0)\n | From.Parsetree.Ptype_open -> To.Parsetree.Ptype_open\n\nand copy_constructor_declaration :\n From.Parsetree.constructor_declaration ->\n To.Parsetree.constructor_declaration =\n fun {\n From.Parsetree.pcd_name;\n From.Parsetree.pcd_args;\n From.Parsetree.pcd_res;\n From.Parsetree.pcd_loc;\n From.Parsetree.pcd_attributes;\n } ->\n {\n To.Parsetree.pcd_name = copy_loc (fun x -> x) pcd_name;\n To.Parsetree.pcd_args = copy_constructor_arguments pcd_args;\n To.Parsetree.pcd_res = copy_option copy_core_type pcd_res;\n To.Parsetree.pcd_loc = copy_location pcd_loc;\n To.Parsetree.pcd_attributes = copy_attributes pcd_attributes;\n }\n\nand copy_constructor_arguments :\n From.Parsetree.constructor_arguments -> To.Parsetree.constructor_arguments =\n function\n | From.Parsetree.Pcstr_tuple x0 ->\n To.Parsetree.Pcstr_tuple (List.map copy_core_type x0)\n | From.Parsetree.Pcstr_record x0 ->\n To.Parsetree.Pcstr_record (List.map copy_label_declaration x0)\n\nand copy_label_declaration :\n From.Parsetree.label_declaration -> To.Parsetree.label_declaration =\n fun {\n From.Parsetree.pld_name;\n From.Parsetree.pld_mutable;\n From.Parsetree.pld_type;\n From.Parsetree.pld_loc;\n From.Parsetree.pld_attributes;\n } ->\n {\n To.Parsetree.pld_name = copy_loc (fun x -> x) pld_name;\n To.Parsetree.pld_mutable = copy_mutable_flag pld_mutable;\n To.Parsetree.pld_type = copy_core_type pld_type;\n To.Parsetree.pld_loc = copy_location pld_loc;\n To.Parsetree.pld_attributes = copy_attributes pld_attributes;\n }\n\nand copy_mutable_flag : From.Asttypes.mutable_flag -> To.Asttypes.mutable_flag =\n function\n | From.Asttypes.Immutable -> To.Asttypes.Immutable\n | From.Asttypes.Mutable -> To.Asttypes.Mutable\n\nand copy_variance : From.Asttypes.variance -> To.Asttypes.variance = function\n | From.Asttypes.Covariant -> To.Asttypes.Covariant\n | From.Asttypes.Contravariant -> To.Asttypes.Contravariant\n | From.Asttypes.Invariant -> To.Asttypes.Invariant\n\nand copy_value_description :\n From.Parsetree.value_description -> To.Parsetree.value_description =\n fun {\n From.Parsetree.pval_name;\n From.Parsetree.pval_type;\n From.Parsetree.pval_prim;\n From.Parsetree.pval_attributes;\n From.Parsetree.pval_loc;\n } ->\n {\n To.Parsetree.pval_name = copy_loc (fun x -> x) pval_name;\n To.Parsetree.pval_type = copy_core_type pval_type;\n To.Parsetree.pval_prim = List.map (fun x -> x) pval_prim;\n To.Parsetree.pval_attributes = copy_attributes pval_attributes;\n To.Parsetree.pval_loc = copy_location pval_loc;\n }\n\nand copy_arg_label : From.Asttypes.arg_label -> To.Asttypes.arg_label = function\n | From.Asttypes.Nolabel -> To.Asttypes.Nolabel\n | From.Asttypes.Labelled x0 -> To.Asttypes.Labelled x0\n | From.Asttypes.Optional x0 -> To.Asttypes.Optional x0\n\nand copy_closed_flag : From.Asttypes.closed_flag -> To.Asttypes.closed_flag =\n function\n | From.Asttypes.Closed -> To.Asttypes.Closed\n | From.Asttypes.Open -> To.Asttypes.Open\n\nand copy_label : From.Asttypes.label -> To.Asttypes.label = fun x -> x\n\nand copy_rec_flag : From.Asttypes.rec_flag -> To.Asttypes.rec_flag = function\n | From.Asttypes.Nonrecursive -> To.Asttypes.Nonrecursive\n | From.Asttypes.Recursive -> To.Asttypes.Recursive\n\nand copy_constant : From.Parsetree.constant -> To.Parsetree.constant = function\n | From.Parsetree.Pconst_integer (x0, x1) ->\n To.Parsetree.Pconst_integer (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pconst_char x0 -> To.Parsetree.Pconst_char x0\n | From.Parsetree.Pconst_string (x0, x1) ->\n To.Parsetree.Pconst_string (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pconst_float (x0, x1) ->\n To.Parsetree.Pconst_float (x0, copy_option (fun x -> x) x1)\n\nand copy_option : 'f0 'g0. ('f0 -> 'g0) -> 'f0 option -> 'g0 option =\n fun f0 -> function None -> None | Some x0 -> Some (f0 x0)\n\nand copy_longident : Longident.t -> Longident.t = fun x -> x\n\nand copy_loc :\n 'f0 'g0. ('f0 -> 'g0) -> 'f0 From.Asttypes.loc -> 'g0 To.Asttypes.loc =\n fun f0 { From.Asttypes.txt; From.Asttypes.loc } ->\n { To.Asttypes.txt = f0 txt; To.Asttypes.loc = copy_location loc }\n\nand copy_location : Location.t -> Location.t = fun x -> x\nand copy_bool : bool -> bool = function false -> false | true -> true\n\nlet rec copy_toplevel_phrase :\n From.Parsetree.toplevel_phrase -> To.Parsetree.toplevel_phrase = function\n | From.Parsetree.Ptop_def x0 -> To.Parsetree.Ptop_def (copy_structure x0)\n | From.Parsetree.Ptop_dir (x0, x1) ->\n To.Parsetree.Ptop_dir (x0, copy_directive_argument x1)\n\nand copy_directive_argument :\n From.Parsetree.directive_argument -> To.Parsetree.directive_argument =\n function\n | From.Parsetree.Pdir_none -> To.Parsetree.Pdir_none\n | From.Parsetree.Pdir_string x0 -> To.Parsetree.Pdir_string x0\n | From.Parsetree.Pdir_int (x0, x1) ->\n To.Parsetree.Pdir_int (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pdir_ident x0 -> To.Parsetree.Pdir_ident (copy_longident x0)\n | From.Parsetree.Pdir_bool x0 -> To.Parsetree.Pdir_bool (copy_bool x0)\n\nlet copy_cases x = List.map copy_case x\nlet copy_pat = copy_pattern\nlet copy_expr = copy_expression\nlet copy_typ = copy_core_type\n","(**************************************************************************)\n(* *)\n(* OCaml Migrate Parsetree *)\n(* *)\n(* Frédéric Bour *)\n(* Alain Frisch, LexiFi *)\n(* *)\n(* Copyright 2017 Institut National de Recherche en Informatique et *)\n(* en Automatique (INRIA). *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nmodule From = Ast_406\nmodule To = Ast_407\n\nlet rec copy_expression : From.Parsetree.expression -> To.Parsetree.expression =\n fun {\n From.Parsetree.pexp_desc;\n From.Parsetree.pexp_loc;\n From.Parsetree.pexp_attributes;\n } ->\n {\n To.Parsetree.pexp_desc = copy_expression_desc pexp_desc;\n To.Parsetree.pexp_loc = copy_location pexp_loc;\n To.Parsetree.pexp_attributes = copy_attributes pexp_attributes;\n }\n\nand copy_expression_desc :\n From.Parsetree.expression_desc -> To.Parsetree.expression_desc = function\n | From.Parsetree.Pexp_ident x0 ->\n To.Parsetree.Pexp_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pexp_constant x0 ->\n To.Parsetree.Pexp_constant (copy_constant x0)\n | From.Parsetree.Pexp_let (x0, x1, x2) ->\n To.Parsetree.Pexp_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_expression x2)\n | From.Parsetree.Pexp_function x0 ->\n To.Parsetree.Pexp_function (List.map copy_case x0)\n | From.Parsetree.Pexp_fun (x0, x1, x2, x3) ->\n To.Parsetree.Pexp_fun\n ( copy_arg_label x0,\n copy_option copy_expression x1,\n copy_pattern x2,\n copy_expression x3 )\n | From.Parsetree.Pexp_apply (x0, x1) ->\n To.Parsetree.Pexp_apply\n ( copy_expression x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | From.Parsetree.Pexp_match (x0, x1) ->\n To.Parsetree.Pexp_match (copy_expression x0, List.map copy_case x1)\n | From.Parsetree.Pexp_try (x0, x1) ->\n To.Parsetree.Pexp_try (copy_expression x0, List.map copy_case x1)\n | From.Parsetree.Pexp_tuple x0 ->\n To.Parsetree.Pexp_tuple (List.map copy_expression x0)\n | From.Parsetree.Pexp_construct (x0, x1) ->\n To.Parsetree.Pexp_construct\n (copy_loc copy_longident x0, copy_option copy_expression x1)\n | From.Parsetree.Pexp_variant (x0, x1) ->\n To.Parsetree.Pexp_variant (copy_label x0, copy_option copy_expression x1)\n | From.Parsetree.Pexp_record (x0, x1) ->\n To.Parsetree.Pexp_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_expression x1))\n x0,\n copy_option copy_expression x1 )\n | From.Parsetree.Pexp_field (x0, x1) ->\n To.Parsetree.Pexp_field (copy_expression x0, copy_loc copy_longident x1)\n | From.Parsetree.Pexp_setfield (x0, x1, x2) ->\n To.Parsetree.Pexp_setfield\n (copy_expression x0, copy_loc copy_longident x1, copy_expression x2)\n | From.Parsetree.Pexp_array x0 ->\n To.Parsetree.Pexp_array (List.map copy_expression x0)\n | From.Parsetree.Pexp_ifthenelse (x0, x1, x2) ->\n To.Parsetree.Pexp_ifthenelse\n (copy_expression x0, copy_expression x1, copy_option copy_expression x2)\n | From.Parsetree.Pexp_sequence (x0, x1) ->\n To.Parsetree.Pexp_sequence (copy_expression x0, copy_expression x1)\n | From.Parsetree.Pexp_while (x0, x1) ->\n To.Parsetree.Pexp_while (copy_expression x0, copy_expression x1)\n | From.Parsetree.Pexp_for (x0, x1, x2, x3, x4) ->\n To.Parsetree.Pexp_for\n ( copy_pattern x0,\n copy_expression x1,\n copy_expression x2,\n copy_direction_flag x3,\n copy_expression x4 )\n | From.Parsetree.Pexp_constraint (x0, x1) ->\n To.Parsetree.Pexp_constraint (copy_expression x0, copy_core_type x1)\n | From.Parsetree.Pexp_coerce (x0, x1, x2) ->\n To.Parsetree.Pexp_coerce\n (copy_expression x0, copy_option copy_core_type x1, copy_core_type x2)\n | From.Parsetree.Pexp_send (x0, x1) ->\n To.Parsetree.Pexp_send (copy_expression x0, copy_loc (fun x -> x) x1)\n | From.Parsetree.Pexp_new x0 ->\n To.Parsetree.Pexp_new (copy_loc copy_longident x0)\n | From.Parsetree.Pexp_setinstvar (x0, x1) ->\n To.Parsetree.Pexp_setinstvar (copy_loc (fun x -> x) x0, copy_expression x1)\n | From.Parsetree.Pexp_override x0 ->\n To.Parsetree.Pexp_override\n (List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_expression x1))\n x0)\n | From.Parsetree.Pexp_letmodule (x0, x1, x2) ->\n To.Parsetree.Pexp_letmodule\n (copy_loc (fun x -> x) x0, copy_module_expr x1, copy_expression x2)\n | From.Parsetree.Pexp_letexception (x0, x1) ->\n To.Parsetree.Pexp_letexception\n (copy_extension_constructor x0, copy_expression x1)\n | From.Parsetree.Pexp_assert x0 ->\n To.Parsetree.Pexp_assert (copy_expression x0)\n | From.Parsetree.Pexp_lazy x0 -> To.Parsetree.Pexp_lazy (copy_expression x0)\n | From.Parsetree.Pexp_poly (x0, x1) ->\n To.Parsetree.Pexp_poly (copy_expression x0, copy_option copy_core_type x1)\n | From.Parsetree.Pexp_object x0 ->\n To.Parsetree.Pexp_object (copy_class_structure x0)\n | From.Parsetree.Pexp_newtype (x0, x1) ->\n To.Parsetree.Pexp_newtype (copy_loc (fun x -> x) x0, copy_expression x1)\n | From.Parsetree.Pexp_pack x0 -> To.Parsetree.Pexp_pack (copy_module_expr x0)\n | From.Parsetree.Pexp_open (x0, x1, x2) ->\n To.Parsetree.Pexp_open\n (copy_override_flag x0, copy_loc copy_longident x1, copy_expression x2)\n | From.Parsetree.Pexp_extension x0 ->\n To.Parsetree.Pexp_extension (copy_extension x0)\n | From.Parsetree.Pexp_unreachable -> To.Parsetree.Pexp_unreachable\n\nand copy_direction_flag :\n From.Asttypes.direction_flag -> To.Asttypes.direction_flag = function\n | From.Asttypes.Upto -> To.Asttypes.Upto\n | From.Asttypes.Downto -> To.Asttypes.Downto\n\nand copy_case : From.Parsetree.case -> To.Parsetree.case =\n fun { From.Parsetree.pc_lhs; From.Parsetree.pc_guard; From.Parsetree.pc_rhs } ->\n {\n To.Parsetree.pc_lhs = copy_pattern pc_lhs;\n To.Parsetree.pc_guard = copy_option copy_expression pc_guard;\n To.Parsetree.pc_rhs = copy_expression pc_rhs;\n }\n\nand copy_value_binding :\n From.Parsetree.value_binding -> To.Parsetree.value_binding =\n fun {\n From.Parsetree.pvb_pat;\n From.Parsetree.pvb_expr;\n From.Parsetree.pvb_attributes;\n From.Parsetree.pvb_loc;\n } ->\n {\n To.Parsetree.pvb_pat = copy_pattern pvb_pat;\n To.Parsetree.pvb_expr = copy_expression pvb_expr;\n To.Parsetree.pvb_attributes = copy_attributes pvb_attributes;\n To.Parsetree.pvb_loc = copy_location pvb_loc;\n }\n\nand copy_pattern : From.Parsetree.pattern -> To.Parsetree.pattern =\n fun {\n From.Parsetree.ppat_desc;\n From.Parsetree.ppat_loc;\n From.Parsetree.ppat_attributes;\n } ->\n {\n To.Parsetree.ppat_desc = copy_pattern_desc ppat_desc;\n To.Parsetree.ppat_loc = copy_location ppat_loc;\n To.Parsetree.ppat_attributes = copy_attributes ppat_attributes;\n }\n\nand copy_pattern_desc : From.Parsetree.pattern_desc -> To.Parsetree.pattern_desc\n = function\n | From.Parsetree.Ppat_any -> To.Parsetree.Ppat_any\n | From.Parsetree.Ppat_var x0 ->\n To.Parsetree.Ppat_var (copy_loc (fun x -> x) x0)\n | From.Parsetree.Ppat_alias (x0, x1) ->\n To.Parsetree.Ppat_alias (copy_pattern x0, copy_loc (fun x -> x) x1)\n | From.Parsetree.Ppat_constant x0 ->\n To.Parsetree.Ppat_constant (copy_constant x0)\n | From.Parsetree.Ppat_interval (x0, x1) ->\n To.Parsetree.Ppat_interval (copy_constant x0, copy_constant x1)\n | From.Parsetree.Ppat_tuple x0 ->\n To.Parsetree.Ppat_tuple (List.map copy_pattern x0)\n | From.Parsetree.Ppat_construct (x0, x1) ->\n To.Parsetree.Ppat_construct\n (copy_loc copy_longident x0, copy_option copy_pattern x1)\n | From.Parsetree.Ppat_variant (x0, x1) ->\n To.Parsetree.Ppat_variant (copy_label x0, copy_option copy_pattern x1)\n | From.Parsetree.Ppat_record (x0, x1) ->\n To.Parsetree.Ppat_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_pattern x1))\n x0,\n copy_closed_flag x1 )\n | From.Parsetree.Ppat_array x0 ->\n To.Parsetree.Ppat_array (List.map copy_pattern x0)\n | From.Parsetree.Ppat_or (x0, x1) ->\n To.Parsetree.Ppat_or (copy_pattern x0, copy_pattern x1)\n | From.Parsetree.Ppat_constraint (x0, x1) ->\n To.Parsetree.Ppat_constraint (copy_pattern x0, copy_core_type x1)\n | From.Parsetree.Ppat_type x0 ->\n To.Parsetree.Ppat_type (copy_loc copy_longident x0)\n | From.Parsetree.Ppat_lazy x0 -> To.Parsetree.Ppat_lazy (copy_pattern x0)\n | From.Parsetree.Ppat_unpack x0 ->\n To.Parsetree.Ppat_unpack (copy_loc (fun x -> x) x0)\n | From.Parsetree.Ppat_exception x0 ->\n To.Parsetree.Ppat_exception (copy_pattern x0)\n | From.Parsetree.Ppat_extension x0 ->\n To.Parsetree.Ppat_extension (copy_extension x0)\n | From.Parsetree.Ppat_open (x0, x1) ->\n To.Parsetree.Ppat_open (copy_loc copy_longident x0, copy_pattern x1)\n\nand copy_core_type : From.Parsetree.core_type -> To.Parsetree.core_type =\n fun {\n From.Parsetree.ptyp_desc;\n From.Parsetree.ptyp_loc;\n From.Parsetree.ptyp_attributes;\n } ->\n {\n To.Parsetree.ptyp_desc = copy_core_type_desc ptyp_desc;\n To.Parsetree.ptyp_loc = copy_location ptyp_loc;\n To.Parsetree.ptyp_attributes = copy_attributes ptyp_attributes;\n }\n\nand copy_core_type_desc :\n From.Parsetree.core_type_desc -> To.Parsetree.core_type_desc = function\n | From.Parsetree.Ptyp_any -> To.Parsetree.Ptyp_any\n | From.Parsetree.Ptyp_var x0 -> To.Parsetree.Ptyp_var x0\n | From.Parsetree.Ptyp_arrow (x0, x1, x2) ->\n To.Parsetree.Ptyp_arrow\n (copy_arg_label x0, copy_core_type x1, copy_core_type x2)\n | From.Parsetree.Ptyp_tuple x0 ->\n To.Parsetree.Ptyp_tuple (List.map copy_core_type x0)\n | From.Parsetree.Ptyp_constr (x0, x1) ->\n To.Parsetree.Ptyp_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Ptyp_object (x0, x1) ->\n To.Parsetree.Ptyp_object\n (List.map copy_object_field x0, copy_closed_flag x1)\n | From.Parsetree.Ptyp_class (x0, x1) ->\n To.Parsetree.Ptyp_class\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Ptyp_alias (x0, x1) ->\n To.Parsetree.Ptyp_alias (copy_core_type x0, x1)\n | From.Parsetree.Ptyp_variant (x0, x1, x2) ->\n To.Parsetree.Ptyp_variant\n ( List.map copy_row_field x0,\n copy_closed_flag x1,\n copy_option (fun x -> List.map copy_label x) x2 )\n | From.Parsetree.Ptyp_poly (x0, x1) ->\n To.Parsetree.Ptyp_poly\n (List.map (fun x -> copy_loc (fun x -> x) x) x0, copy_core_type x1)\n | From.Parsetree.Ptyp_package x0 ->\n To.Parsetree.Ptyp_package (copy_package_type x0)\n | From.Parsetree.Ptyp_extension x0 ->\n To.Parsetree.Ptyp_extension (copy_extension x0)\n\nand copy_package_type : From.Parsetree.package_type -> To.Parsetree.package_type\n =\n fun x ->\n let x0, x1 = x in\n ( copy_loc copy_longident x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_core_type x1))\n x1 )\n\nand copy_row_field : From.Parsetree.row_field -> To.Parsetree.row_field =\n function\n | From.Parsetree.Rtag (x0, x1, x2, x3) ->\n To.Parsetree.Rtag\n ( copy_loc copy_label x0,\n copy_attributes x1,\n copy_bool x2,\n List.map copy_core_type x3 )\n | From.Parsetree.Rinherit x0 -> To.Parsetree.Rinherit (copy_core_type x0)\n\nand copy_object_field : From.Parsetree.object_field -> To.Parsetree.object_field\n = function\n | From.Parsetree.Otag (x0, x1, x2) ->\n To.Parsetree.Otag\n (copy_loc (fun x -> x) x0, copy_attributes x1, copy_core_type x2)\n | From.Parsetree.Oinherit x -> To.Parsetree.Oinherit (copy_core_type x)\n\nand copy_attributes : From.Parsetree.attributes -> To.Parsetree.attributes =\n fun x -> List.map copy_attribute x\n\nand copy_attribute : From.Parsetree.attribute -> To.Parsetree.attribute =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_payload : From.Parsetree.payload -> To.Parsetree.payload = function\n | From.Parsetree.PStr x0 -> To.Parsetree.PStr (copy_structure x0)\n | From.Parsetree.PSig x0 -> To.Parsetree.PSig (copy_signature x0)\n | From.Parsetree.PTyp x0 -> To.Parsetree.PTyp (copy_core_type x0)\n | From.Parsetree.PPat (x0, x1) ->\n To.Parsetree.PPat (copy_pattern x0, copy_option copy_expression x1)\n\nand copy_structure : From.Parsetree.structure -> To.Parsetree.structure =\n fun x -> List.map copy_structure_item x\n\nand copy_structure_item :\n From.Parsetree.structure_item -> To.Parsetree.structure_item =\n fun { From.Parsetree.pstr_desc; From.Parsetree.pstr_loc } ->\n {\n To.Parsetree.pstr_desc = copy_structure_item_desc pstr_desc;\n To.Parsetree.pstr_loc = copy_location pstr_loc;\n }\n\nand copy_structure_item_desc :\n From.Parsetree.structure_item_desc -> To.Parsetree.structure_item_desc =\n function\n | From.Parsetree.Pstr_eval (x0, x1) ->\n To.Parsetree.Pstr_eval (copy_expression x0, copy_attributes x1)\n | From.Parsetree.Pstr_value (x0, x1) ->\n To.Parsetree.Pstr_value (copy_rec_flag x0, List.map copy_value_binding x1)\n | From.Parsetree.Pstr_primitive x0 ->\n To.Parsetree.Pstr_primitive (copy_value_description x0)\n | From.Parsetree.Pstr_type (x0, x1) ->\n To.Parsetree.Pstr_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | From.Parsetree.Pstr_typext x0 ->\n To.Parsetree.Pstr_typext (copy_type_extension x0)\n | From.Parsetree.Pstr_exception x0 ->\n To.Parsetree.Pstr_exception (copy_extension_constructor x0)\n | From.Parsetree.Pstr_module x0 ->\n To.Parsetree.Pstr_module (copy_module_binding x0)\n | From.Parsetree.Pstr_recmodule x0 ->\n To.Parsetree.Pstr_recmodule (List.map copy_module_binding x0)\n | From.Parsetree.Pstr_modtype x0 ->\n To.Parsetree.Pstr_modtype (copy_module_type_declaration x0)\n | From.Parsetree.Pstr_open x0 ->\n To.Parsetree.Pstr_open (copy_open_description x0)\n | From.Parsetree.Pstr_class x0 ->\n To.Parsetree.Pstr_class (List.map copy_class_declaration x0)\n | From.Parsetree.Pstr_class_type x0 ->\n To.Parsetree.Pstr_class_type (List.map copy_class_type_declaration x0)\n | From.Parsetree.Pstr_include x0 ->\n To.Parsetree.Pstr_include (copy_include_declaration x0)\n | From.Parsetree.Pstr_attribute x0 ->\n To.Parsetree.Pstr_attribute (copy_attribute x0)\n | From.Parsetree.Pstr_extension (x0, x1) ->\n To.Parsetree.Pstr_extension (copy_extension x0, copy_attributes x1)\n\nand copy_include_declaration :\n From.Parsetree.include_declaration -> To.Parsetree.include_declaration =\n fun x -> copy_include_infos copy_module_expr x\n\nand copy_class_declaration :\n From.Parsetree.class_declaration -> To.Parsetree.class_declaration =\n fun x -> copy_class_infos copy_class_expr x\n\nand copy_class_expr : From.Parsetree.class_expr -> To.Parsetree.class_expr =\n fun {\n From.Parsetree.pcl_desc;\n From.Parsetree.pcl_loc;\n From.Parsetree.pcl_attributes;\n } ->\n {\n To.Parsetree.pcl_desc = copy_class_expr_desc pcl_desc;\n To.Parsetree.pcl_loc = copy_location pcl_loc;\n To.Parsetree.pcl_attributes = copy_attributes pcl_attributes;\n }\n\nand copy_class_expr_desc :\n From.Parsetree.class_expr_desc -> To.Parsetree.class_expr_desc = function\n | From.Parsetree.Pcl_constr (x0, x1) ->\n To.Parsetree.Pcl_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Pcl_structure x0 ->\n To.Parsetree.Pcl_structure (copy_class_structure x0)\n | From.Parsetree.Pcl_fun (x0, x1, x2, x3) ->\n To.Parsetree.Pcl_fun\n ( copy_arg_label x0,\n copy_option copy_expression x1,\n copy_pattern x2,\n copy_class_expr x3 )\n | From.Parsetree.Pcl_apply (x0, x1) ->\n To.Parsetree.Pcl_apply\n ( copy_class_expr x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | From.Parsetree.Pcl_let (x0, x1, x2) ->\n To.Parsetree.Pcl_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_class_expr x2)\n | From.Parsetree.Pcl_constraint (x0, x1) ->\n To.Parsetree.Pcl_constraint (copy_class_expr x0, copy_class_type x1)\n | From.Parsetree.Pcl_extension x0 ->\n To.Parsetree.Pcl_extension (copy_extension x0)\n | From.Parsetree.Pcl_open (ovf, loc, ce) ->\n To.Parsetree.Pcl_open\n (copy_override_flag ovf, copy_loc copy_longident loc, copy_class_expr ce)\n\nand copy_class_structure :\n From.Parsetree.class_structure -> To.Parsetree.class_structure =\n fun { From.Parsetree.pcstr_self; From.Parsetree.pcstr_fields } ->\n {\n To.Parsetree.pcstr_self = copy_pattern pcstr_self;\n To.Parsetree.pcstr_fields = List.map copy_class_field pcstr_fields;\n }\n\nand copy_class_field : From.Parsetree.class_field -> To.Parsetree.class_field =\n fun {\n From.Parsetree.pcf_desc;\n From.Parsetree.pcf_loc;\n From.Parsetree.pcf_attributes;\n } ->\n {\n To.Parsetree.pcf_desc = copy_class_field_desc pcf_desc;\n To.Parsetree.pcf_loc = copy_location pcf_loc;\n To.Parsetree.pcf_attributes = copy_attributes pcf_attributes;\n }\n\nand copy_class_field_desc :\n From.Parsetree.class_field_desc -> To.Parsetree.class_field_desc = function\n | From.Parsetree.Pcf_inherit (x0, x1, x2) ->\n To.Parsetree.Pcf_inherit\n ( copy_override_flag x0,\n copy_class_expr x1,\n copy_option (copy_loc (fun x -> x)) x2 )\n | From.Parsetree.Pcf_val x0 ->\n To.Parsetree.Pcf_val\n (let x0, x1, x2 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_mutable_flag x1,\n copy_class_field_kind x2 ))\n | From.Parsetree.Pcf_method x0 ->\n To.Parsetree.Pcf_method\n (let x0, x1, x2 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_private_flag x1,\n copy_class_field_kind x2 ))\n | From.Parsetree.Pcf_constraint x0 ->\n To.Parsetree.Pcf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | From.Parsetree.Pcf_initializer x0 ->\n To.Parsetree.Pcf_initializer (copy_expression x0)\n | From.Parsetree.Pcf_attribute x0 ->\n To.Parsetree.Pcf_attribute (copy_attribute x0)\n | From.Parsetree.Pcf_extension x0 ->\n To.Parsetree.Pcf_extension (copy_extension x0)\n\nand copy_class_field_kind :\n From.Parsetree.class_field_kind -> To.Parsetree.class_field_kind = function\n | From.Parsetree.Cfk_virtual x0 ->\n To.Parsetree.Cfk_virtual (copy_core_type x0)\n | From.Parsetree.Cfk_concrete (x0, x1) ->\n To.Parsetree.Cfk_concrete (copy_override_flag x0, copy_expression x1)\n\nand copy_module_binding :\n From.Parsetree.module_binding -> To.Parsetree.module_binding =\n fun {\n From.Parsetree.pmb_name;\n From.Parsetree.pmb_expr;\n From.Parsetree.pmb_attributes;\n From.Parsetree.pmb_loc;\n } ->\n {\n To.Parsetree.pmb_name = copy_loc (fun x -> x) pmb_name;\n To.Parsetree.pmb_expr = copy_module_expr pmb_expr;\n To.Parsetree.pmb_attributes = copy_attributes pmb_attributes;\n To.Parsetree.pmb_loc = copy_location pmb_loc;\n }\n\nand copy_module_expr : From.Parsetree.module_expr -> To.Parsetree.module_expr =\n fun {\n From.Parsetree.pmod_desc;\n From.Parsetree.pmod_loc;\n From.Parsetree.pmod_attributes;\n } ->\n {\n To.Parsetree.pmod_desc = copy_module_expr_desc pmod_desc;\n To.Parsetree.pmod_loc = copy_location pmod_loc;\n To.Parsetree.pmod_attributes = copy_attributes pmod_attributes;\n }\n\nand copy_module_expr_desc :\n From.Parsetree.module_expr_desc -> To.Parsetree.module_expr_desc = function\n | From.Parsetree.Pmod_ident x0 ->\n To.Parsetree.Pmod_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pmod_structure x0 ->\n To.Parsetree.Pmod_structure (copy_structure x0)\n | From.Parsetree.Pmod_functor (x0, x1, x2) ->\n To.Parsetree.Pmod_functor\n ( copy_loc (fun x -> x) x0,\n copy_option copy_module_type x1,\n copy_module_expr x2 )\n | From.Parsetree.Pmod_apply (x0, x1) ->\n To.Parsetree.Pmod_apply (copy_module_expr x0, copy_module_expr x1)\n | From.Parsetree.Pmod_constraint (x0, x1) ->\n To.Parsetree.Pmod_constraint (copy_module_expr x0, copy_module_type x1)\n | From.Parsetree.Pmod_unpack x0 ->\n To.Parsetree.Pmod_unpack (copy_expression x0)\n | From.Parsetree.Pmod_extension x0 ->\n To.Parsetree.Pmod_extension (copy_extension x0)\n\nand copy_module_type : From.Parsetree.module_type -> To.Parsetree.module_type =\n fun {\n From.Parsetree.pmty_desc;\n From.Parsetree.pmty_loc;\n From.Parsetree.pmty_attributes;\n } ->\n {\n To.Parsetree.pmty_desc = copy_module_type_desc pmty_desc;\n To.Parsetree.pmty_loc = copy_location pmty_loc;\n To.Parsetree.pmty_attributes = copy_attributes pmty_attributes;\n }\n\nand copy_module_type_desc :\n From.Parsetree.module_type_desc -> To.Parsetree.module_type_desc = function\n | From.Parsetree.Pmty_ident x0 ->\n To.Parsetree.Pmty_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pmty_signature x0 ->\n To.Parsetree.Pmty_signature (copy_signature x0)\n | From.Parsetree.Pmty_functor (x0, x1, x2) ->\n To.Parsetree.Pmty_functor\n ( copy_loc (fun x -> x) x0,\n copy_option copy_module_type x1,\n copy_module_type x2 )\n | From.Parsetree.Pmty_with (x0, x1) ->\n To.Parsetree.Pmty_with\n (copy_module_type x0, List.map copy_with_constraint x1)\n | From.Parsetree.Pmty_typeof x0 ->\n To.Parsetree.Pmty_typeof (copy_module_expr x0)\n | From.Parsetree.Pmty_extension x0 ->\n To.Parsetree.Pmty_extension (copy_extension x0)\n | From.Parsetree.Pmty_alias x0 ->\n To.Parsetree.Pmty_alias (copy_loc copy_longident x0)\n\nand copy_with_constraint :\n From.Parsetree.with_constraint -> To.Parsetree.with_constraint = function\n | From.Parsetree.Pwith_type (x0, x1) ->\n To.Parsetree.Pwith_type\n (copy_loc copy_longident x0, copy_type_declaration x1)\n | From.Parsetree.Pwith_module (x0, x1) ->\n To.Parsetree.Pwith_module\n (copy_loc copy_longident x0, copy_loc copy_longident x1)\n | From.Parsetree.Pwith_typesubst (x0, x1) ->\n To.Parsetree.Pwith_typesubst\n (copy_loc copy_longident x0, copy_type_declaration x1)\n | From.Parsetree.Pwith_modsubst (x0, x1) ->\n To.Parsetree.Pwith_modsubst\n (copy_loc copy_longident x0, copy_loc copy_longident x1)\n\nand copy_signature : From.Parsetree.signature -> To.Parsetree.signature =\n fun x -> List.map copy_signature_item x\n\nand copy_signature_item :\n From.Parsetree.signature_item -> To.Parsetree.signature_item =\n fun { From.Parsetree.psig_desc; From.Parsetree.psig_loc } ->\n {\n To.Parsetree.psig_desc = copy_signature_item_desc psig_desc;\n To.Parsetree.psig_loc = copy_location psig_loc;\n }\n\nand copy_signature_item_desc :\n From.Parsetree.signature_item_desc -> To.Parsetree.signature_item_desc =\n function\n | From.Parsetree.Psig_value x0 ->\n To.Parsetree.Psig_value (copy_value_description x0)\n | From.Parsetree.Psig_type (x0, x1) ->\n To.Parsetree.Psig_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | From.Parsetree.Psig_typext x0 ->\n To.Parsetree.Psig_typext (copy_type_extension x0)\n | From.Parsetree.Psig_exception x0 ->\n To.Parsetree.Psig_exception (copy_extension_constructor x0)\n | From.Parsetree.Psig_module x0 ->\n To.Parsetree.Psig_module (copy_module_declaration x0)\n | From.Parsetree.Psig_recmodule x0 ->\n To.Parsetree.Psig_recmodule (List.map copy_module_declaration x0)\n | From.Parsetree.Psig_modtype x0 ->\n To.Parsetree.Psig_modtype (copy_module_type_declaration x0)\n | From.Parsetree.Psig_open x0 ->\n To.Parsetree.Psig_open (copy_open_description x0)\n | From.Parsetree.Psig_include x0 ->\n To.Parsetree.Psig_include (copy_include_description x0)\n | From.Parsetree.Psig_class x0 ->\n To.Parsetree.Psig_class (List.map copy_class_description x0)\n | From.Parsetree.Psig_class_type x0 ->\n To.Parsetree.Psig_class_type (List.map copy_class_type_declaration x0)\n | From.Parsetree.Psig_attribute x0 ->\n To.Parsetree.Psig_attribute (copy_attribute x0)\n | From.Parsetree.Psig_extension (x0, x1) ->\n To.Parsetree.Psig_extension (copy_extension x0, copy_attributes x1)\n\nand copy_class_type_declaration :\n From.Parsetree.class_type_declaration -> To.Parsetree.class_type_declaration\n =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_description :\n From.Parsetree.class_description -> To.Parsetree.class_description =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_type : From.Parsetree.class_type -> To.Parsetree.class_type =\n fun {\n From.Parsetree.pcty_desc;\n From.Parsetree.pcty_loc;\n From.Parsetree.pcty_attributes;\n } ->\n {\n To.Parsetree.pcty_desc = copy_class_type_desc pcty_desc;\n To.Parsetree.pcty_loc = copy_location pcty_loc;\n To.Parsetree.pcty_attributes = copy_attributes pcty_attributes;\n }\n\nand copy_class_type_desc :\n From.Parsetree.class_type_desc -> To.Parsetree.class_type_desc = function\n | From.Parsetree.Pcty_constr (x0, x1) ->\n To.Parsetree.Pcty_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Pcty_signature x0 ->\n To.Parsetree.Pcty_signature (copy_class_signature x0)\n | From.Parsetree.Pcty_arrow (x0, x1, x2) ->\n To.Parsetree.Pcty_arrow\n (copy_arg_label x0, copy_core_type x1, copy_class_type x2)\n | From.Parsetree.Pcty_extension x0 ->\n To.Parsetree.Pcty_extension (copy_extension x0)\n | From.Parsetree.Pcty_open (ovf, loc, cty) ->\n To.Parsetree.Pcty_open\n ( copy_override_flag ovf,\n copy_loc copy_longident loc,\n copy_class_type cty )\n\nand copy_class_signature :\n From.Parsetree.class_signature -> To.Parsetree.class_signature =\n fun { From.Parsetree.pcsig_self; From.Parsetree.pcsig_fields } ->\n {\n To.Parsetree.pcsig_self = copy_core_type pcsig_self;\n To.Parsetree.pcsig_fields = List.map copy_class_type_field pcsig_fields;\n }\n\nand copy_class_type_field :\n From.Parsetree.class_type_field -> To.Parsetree.class_type_field =\n fun {\n From.Parsetree.pctf_desc;\n From.Parsetree.pctf_loc;\n From.Parsetree.pctf_attributes;\n } ->\n {\n To.Parsetree.pctf_desc = copy_class_type_field_desc pctf_desc;\n To.Parsetree.pctf_loc = copy_location pctf_loc;\n To.Parsetree.pctf_attributes = copy_attributes pctf_attributes;\n }\n\nand copy_class_type_field_desc :\n From.Parsetree.class_type_field_desc -> To.Parsetree.class_type_field_desc =\n function\n | From.Parsetree.Pctf_inherit x0 ->\n To.Parsetree.Pctf_inherit (copy_class_type x0)\n | From.Parsetree.Pctf_val x0 ->\n To.Parsetree.Pctf_val\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_mutable_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | From.Parsetree.Pctf_method x0 ->\n To.Parsetree.Pctf_method\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_private_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | From.Parsetree.Pctf_constraint x0 ->\n To.Parsetree.Pctf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | From.Parsetree.Pctf_attribute x0 ->\n To.Parsetree.Pctf_attribute (copy_attribute x0)\n | From.Parsetree.Pctf_extension x0 ->\n To.Parsetree.Pctf_extension (copy_extension x0)\n\nand copy_extension : From.Parsetree.extension -> To.Parsetree.extension =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_class_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 From.Parsetree.class_infos ->\n 'g0 To.Parsetree.class_infos =\n fun f0\n {\n From.Parsetree.pci_virt;\n From.Parsetree.pci_params;\n From.Parsetree.pci_name;\n From.Parsetree.pci_expr;\n From.Parsetree.pci_loc;\n From.Parsetree.pci_attributes;\n } ->\n {\n To.Parsetree.pci_virt = copy_virtual_flag pci_virt;\n To.Parsetree.pci_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n pci_params;\n To.Parsetree.pci_name = copy_loc (fun x -> x) pci_name;\n To.Parsetree.pci_expr = f0 pci_expr;\n To.Parsetree.pci_loc = copy_location pci_loc;\n To.Parsetree.pci_attributes = copy_attributes pci_attributes;\n }\n\nand copy_virtual_flag : From.Asttypes.virtual_flag -> To.Asttypes.virtual_flag =\n function\n | From.Asttypes.Virtual -> To.Asttypes.Virtual\n | From.Asttypes.Concrete -> To.Asttypes.Concrete\n\nand copy_include_description :\n From.Parsetree.include_description -> To.Parsetree.include_description =\n fun x -> copy_include_infos copy_module_type x\n\nand copy_include_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 From.Parsetree.include_infos ->\n 'g0 To.Parsetree.include_infos =\n fun f0\n {\n From.Parsetree.pincl_mod;\n From.Parsetree.pincl_loc;\n From.Parsetree.pincl_attributes;\n } ->\n {\n To.Parsetree.pincl_mod = f0 pincl_mod;\n To.Parsetree.pincl_loc = copy_location pincl_loc;\n To.Parsetree.pincl_attributes = copy_attributes pincl_attributes;\n }\n\nand copy_open_description :\n From.Parsetree.open_description -> To.Parsetree.open_description =\n fun {\n From.Parsetree.popen_lid;\n From.Parsetree.popen_override;\n From.Parsetree.popen_loc;\n From.Parsetree.popen_attributes;\n } ->\n {\n To.Parsetree.popen_lid = copy_loc copy_longident popen_lid;\n To.Parsetree.popen_override = copy_override_flag popen_override;\n To.Parsetree.popen_loc = copy_location popen_loc;\n To.Parsetree.popen_attributes = copy_attributes popen_attributes;\n }\n\nand copy_override_flag :\n From.Asttypes.override_flag -> To.Asttypes.override_flag = function\n | From.Asttypes.Override -> To.Asttypes.Override\n | From.Asttypes.Fresh -> To.Asttypes.Fresh\n\nand copy_module_type_declaration :\n From.Parsetree.module_type_declaration ->\n To.Parsetree.module_type_declaration =\n fun {\n From.Parsetree.pmtd_name;\n From.Parsetree.pmtd_type;\n From.Parsetree.pmtd_attributes;\n From.Parsetree.pmtd_loc;\n } ->\n {\n To.Parsetree.pmtd_name = copy_loc (fun x -> x) pmtd_name;\n To.Parsetree.pmtd_type = copy_option copy_module_type pmtd_type;\n To.Parsetree.pmtd_attributes = copy_attributes pmtd_attributes;\n To.Parsetree.pmtd_loc = copy_location pmtd_loc;\n }\n\nand copy_module_declaration :\n From.Parsetree.module_declaration -> To.Parsetree.module_declaration =\n fun {\n From.Parsetree.pmd_name;\n From.Parsetree.pmd_type;\n From.Parsetree.pmd_attributes;\n From.Parsetree.pmd_loc;\n } ->\n {\n To.Parsetree.pmd_name = copy_loc (fun x -> x) pmd_name;\n To.Parsetree.pmd_type = copy_module_type pmd_type;\n To.Parsetree.pmd_attributes = copy_attributes pmd_attributes;\n To.Parsetree.pmd_loc = copy_location pmd_loc;\n }\n\nand copy_type_extension :\n From.Parsetree.type_extension -> To.Parsetree.type_extension =\n fun {\n From.Parsetree.ptyext_path;\n From.Parsetree.ptyext_params;\n From.Parsetree.ptyext_constructors;\n From.Parsetree.ptyext_private;\n From.Parsetree.ptyext_attributes;\n } ->\n {\n To.Parsetree.ptyext_path = copy_loc copy_longident ptyext_path;\n To.Parsetree.ptyext_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptyext_params;\n To.Parsetree.ptyext_constructors =\n List.map copy_extension_constructor ptyext_constructors;\n To.Parsetree.ptyext_private = copy_private_flag ptyext_private;\n To.Parsetree.ptyext_attributes = copy_attributes ptyext_attributes;\n }\n\nand copy_extension_constructor :\n From.Parsetree.extension_constructor -> To.Parsetree.extension_constructor =\n fun {\n From.Parsetree.pext_name;\n From.Parsetree.pext_kind;\n From.Parsetree.pext_loc;\n From.Parsetree.pext_attributes;\n } ->\n {\n To.Parsetree.pext_name = copy_loc (fun x -> x) pext_name;\n To.Parsetree.pext_kind = copy_extension_constructor_kind pext_kind;\n To.Parsetree.pext_loc = copy_location pext_loc;\n To.Parsetree.pext_attributes = copy_attributes pext_attributes;\n }\n\nand copy_extension_constructor_kind :\n From.Parsetree.extension_constructor_kind ->\n To.Parsetree.extension_constructor_kind = function\n | From.Parsetree.Pext_decl (x0, x1) ->\n To.Parsetree.Pext_decl\n (copy_constructor_arguments x0, copy_option copy_core_type x1)\n | From.Parsetree.Pext_rebind x0 ->\n To.Parsetree.Pext_rebind (copy_loc copy_longident x0)\n\nand copy_type_declaration :\n From.Parsetree.type_declaration -> To.Parsetree.type_declaration =\n fun {\n From.Parsetree.ptype_name;\n From.Parsetree.ptype_params;\n From.Parsetree.ptype_cstrs;\n From.Parsetree.ptype_kind;\n From.Parsetree.ptype_private;\n From.Parsetree.ptype_manifest;\n From.Parsetree.ptype_attributes;\n From.Parsetree.ptype_loc;\n } ->\n {\n To.Parsetree.ptype_name = copy_loc (fun x -> x) ptype_name;\n To.Parsetree.ptype_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptype_params;\n To.Parsetree.ptype_cstrs =\n List.map\n (fun x ->\n let x0, x1, x2 = x in\n (copy_core_type x0, copy_core_type x1, copy_location x2))\n ptype_cstrs;\n To.Parsetree.ptype_kind = copy_type_kind ptype_kind;\n To.Parsetree.ptype_private = copy_private_flag ptype_private;\n To.Parsetree.ptype_manifest = copy_option copy_core_type ptype_manifest;\n To.Parsetree.ptype_attributes = copy_attributes ptype_attributes;\n To.Parsetree.ptype_loc = copy_location ptype_loc;\n }\n\nand copy_private_flag : From.Asttypes.private_flag -> To.Asttypes.private_flag =\n function\n | From.Asttypes.Private -> To.Asttypes.Private\n | From.Asttypes.Public -> To.Asttypes.Public\n\nand copy_type_kind : From.Parsetree.type_kind -> To.Parsetree.type_kind =\n function\n | From.Parsetree.Ptype_abstract -> To.Parsetree.Ptype_abstract\n | From.Parsetree.Ptype_variant x0 ->\n To.Parsetree.Ptype_variant (List.map copy_constructor_declaration x0)\n | From.Parsetree.Ptype_record x0 ->\n To.Parsetree.Ptype_record (List.map copy_label_declaration x0)\n | From.Parsetree.Ptype_open -> To.Parsetree.Ptype_open\n\nand copy_constructor_declaration :\n From.Parsetree.constructor_declaration ->\n To.Parsetree.constructor_declaration =\n fun {\n From.Parsetree.pcd_name;\n From.Parsetree.pcd_args;\n From.Parsetree.pcd_res;\n From.Parsetree.pcd_loc;\n From.Parsetree.pcd_attributes;\n } ->\n {\n To.Parsetree.pcd_name = copy_loc (fun x -> x) pcd_name;\n To.Parsetree.pcd_args = copy_constructor_arguments pcd_args;\n To.Parsetree.pcd_res = copy_option copy_core_type pcd_res;\n To.Parsetree.pcd_loc = copy_location pcd_loc;\n To.Parsetree.pcd_attributes = copy_attributes pcd_attributes;\n }\n\nand copy_constructor_arguments :\n From.Parsetree.constructor_arguments -> To.Parsetree.constructor_arguments =\n function\n | From.Parsetree.Pcstr_tuple x0 ->\n To.Parsetree.Pcstr_tuple (List.map copy_core_type x0)\n | From.Parsetree.Pcstr_record x0 ->\n To.Parsetree.Pcstr_record (List.map copy_label_declaration x0)\n\nand copy_label_declaration :\n From.Parsetree.label_declaration -> To.Parsetree.label_declaration =\n fun {\n From.Parsetree.pld_name;\n From.Parsetree.pld_mutable;\n From.Parsetree.pld_type;\n From.Parsetree.pld_loc;\n From.Parsetree.pld_attributes;\n } ->\n {\n To.Parsetree.pld_name = copy_loc (fun x -> x) pld_name;\n To.Parsetree.pld_mutable = copy_mutable_flag pld_mutable;\n To.Parsetree.pld_type = copy_core_type pld_type;\n To.Parsetree.pld_loc = copy_location pld_loc;\n To.Parsetree.pld_attributes = copy_attributes pld_attributes;\n }\n\nand copy_mutable_flag : From.Asttypes.mutable_flag -> To.Asttypes.mutable_flag =\n function\n | From.Asttypes.Immutable -> To.Asttypes.Immutable\n | From.Asttypes.Mutable -> To.Asttypes.Mutable\n\nand copy_variance : From.Asttypes.variance -> To.Asttypes.variance = function\n | From.Asttypes.Covariant -> To.Asttypes.Covariant\n | From.Asttypes.Contravariant -> To.Asttypes.Contravariant\n | From.Asttypes.Invariant -> To.Asttypes.Invariant\n\nand copy_value_description :\n From.Parsetree.value_description -> To.Parsetree.value_description =\n fun {\n From.Parsetree.pval_name;\n From.Parsetree.pval_type;\n From.Parsetree.pval_prim;\n From.Parsetree.pval_attributes;\n From.Parsetree.pval_loc;\n } ->\n {\n To.Parsetree.pval_name = copy_loc (fun x -> x) pval_name;\n To.Parsetree.pval_type = copy_core_type pval_type;\n To.Parsetree.pval_prim = List.map (fun x -> x) pval_prim;\n To.Parsetree.pval_attributes = copy_attributes pval_attributes;\n To.Parsetree.pval_loc = copy_location pval_loc;\n }\n\nand copy_arg_label : From.Asttypes.arg_label -> To.Asttypes.arg_label = function\n | From.Asttypes.Nolabel -> To.Asttypes.Nolabel\n | From.Asttypes.Labelled x0 -> To.Asttypes.Labelled x0\n | From.Asttypes.Optional x0 -> To.Asttypes.Optional x0\n\nand copy_closed_flag : From.Asttypes.closed_flag -> To.Asttypes.closed_flag =\n function\n | From.Asttypes.Closed -> To.Asttypes.Closed\n | From.Asttypes.Open -> To.Asttypes.Open\n\nand copy_label : From.Asttypes.label -> To.Asttypes.label = fun x -> x\n\nand copy_rec_flag : From.Asttypes.rec_flag -> To.Asttypes.rec_flag = function\n | From.Asttypes.Nonrecursive -> To.Asttypes.Nonrecursive\n | From.Asttypes.Recursive -> To.Asttypes.Recursive\n\nand copy_constant : From.Parsetree.constant -> To.Parsetree.constant = function\n | From.Parsetree.Pconst_integer (x0, x1) ->\n To.Parsetree.Pconst_integer (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pconst_char x0 -> To.Parsetree.Pconst_char x0\n | From.Parsetree.Pconst_string (x0, x1) ->\n To.Parsetree.Pconst_string (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pconst_float (x0, x1) ->\n To.Parsetree.Pconst_float (x0, copy_option (fun x -> x) x1)\n\nand copy_option : 'f0 'g0. ('f0 -> 'g0) -> 'f0 option -> 'g0 option =\n fun f0 -> function None -> None | Some x0 -> Some (f0 x0)\n\nand copy_longident : Longident.t -> Longident.t = fun x -> x\n\nand copy_loc :\n 'f0 'g0. ('f0 -> 'g0) -> 'f0 From.Asttypes.loc -> 'g0 To.Asttypes.loc =\n fun f0 { From.Asttypes.txt; From.Asttypes.loc } ->\n { To.Asttypes.txt = f0 txt; To.Asttypes.loc = copy_location loc }\n\nand copy_location : Location.t -> Location.t = fun x -> x\nand copy_bool : bool -> bool = function false -> false | true -> true\n\nlet rec copy_toplevel_phrase :\n From.Parsetree.toplevel_phrase -> To.Parsetree.toplevel_phrase = function\n | From.Parsetree.Ptop_def x0 -> To.Parsetree.Ptop_def (copy_structure x0)\n | From.Parsetree.Ptop_dir (x0, x1) ->\n To.Parsetree.Ptop_dir (x0, copy_directive_argument x1)\n\nand copy_directive_argument :\n From.Parsetree.directive_argument -> To.Parsetree.directive_argument =\n function\n | From.Parsetree.Pdir_none -> To.Parsetree.Pdir_none\n | From.Parsetree.Pdir_string x0 -> To.Parsetree.Pdir_string x0\n | From.Parsetree.Pdir_int (x0, x1) ->\n To.Parsetree.Pdir_int (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pdir_ident x0 -> To.Parsetree.Pdir_ident (copy_longident x0)\n | From.Parsetree.Pdir_bool x0 -> To.Parsetree.Pdir_bool (copy_bool x0)\n\nlet copy_cases x = List.map copy_case x\nlet copy_pat = copy_pattern\nlet copy_expr = copy_expression\nlet copy_typ = copy_core_type\n","(**************************************************************************)\n(* *)\n(* OCaml Migrate Parsetree *)\n(* *)\n(* Frédéric Bour *)\n(* Alain Frisch, LexiFi *)\n(* *)\n(* Copyright 2017 Institut National de Recherche en Informatique et *)\n(* en Automatique (INRIA). *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nmodule From = Ast_406\nmodule To = Ast_405\n\nlet migration_error loc missing_feature =\n Location.raise_errorf ~loc\n \"migration error: %s is not supported before OCaml 4.06\" missing_feature\n\nlet rec copy_expression : From.Parsetree.expression -> To.Parsetree.expression =\n fun {\n From.Parsetree.pexp_desc;\n From.Parsetree.pexp_loc;\n From.Parsetree.pexp_attributes;\n } ->\n {\n To.Parsetree.pexp_desc = copy_expression_desc pexp_desc;\n To.Parsetree.pexp_loc = copy_location pexp_loc;\n To.Parsetree.pexp_attributes = copy_attributes pexp_attributes;\n }\n\nand copy_expression_desc :\n From.Parsetree.expression_desc -> To.Parsetree.expression_desc = function\n | From.Parsetree.Pexp_ident x0 ->\n To.Parsetree.Pexp_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pexp_constant x0 ->\n To.Parsetree.Pexp_constant (copy_constant x0)\n | From.Parsetree.Pexp_let (x0, x1, x2) ->\n To.Parsetree.Pexp_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_expression x2)\n | From.Parsetree.Pexp_function x0 ->\n To.Parsetree.Pexp_function (List.map copy_case x0)\n | From.Parsetree.Pexp_fun (x0, x1, x2, x3) ->\n To.Parsetree.Pexp_fun\n ( copy_arg_label x0,\n copy_option copy_expression x1,\n copy_pattern x2,\n copy_expression x3 )\n | From.Parsetree.Pexp_apply (x0, x1) ->\n To.Parsetree.Pexp_apply\n ( copy_expression x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | From.Parsetree.Pexp_match (x0, x1) ->\n To.Parsetree.Pexp_match (copy_expression x0, List.map copy_case x1)\n | From.Parsetree.Pexp_try (x0, x1) ->\n To.Parsetree.Pexp_try (copy_expression x0, List.map copy_case x1)\n | From.Parsetree.Pexp_tuple x0 ->\n To.Parsetree.Pexp_tuple (List.map copy_expression x0)\n | From.Parsetree.Pexp_construct (x0, x1) ->\n To.Parsetree.Pexp_construct\n (copy_loc copy_longident x0, copy_option copy_expression x1)\n | From.Parsetree.Pexp_variant (x0, x1) ->\n To.Parsetree.Pexp_variant (copy_label x0, copy_option copy_expression x1)\n | From.Parsetree.Pexp_record (x0, x1) ->\n To.Parsetree.Pexp_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_expression x1))\n x0,\n copy_option copy_expression x1 )\n | From.Parsetree.Pexp_field (x0, x1) ->\n To.Parsetree.Pexp_field (copy_expression x0, copy_loc copy_longident x1)\n | From.Parsetree.Pexp_setfield (x0, x1, x2) ->\n To.Parsetree.Pexp_setfield\n (copy_expression x0, copy_loc copy_longident x1, copy_expression x2)\n | From.Parsetree.Pexp_array x0 ->\n To.Parsetree.Pexp_array (List.map copy_expression x0)\n | From.Parsetree.Pexp_ifthenelse (x0, x1, x2) ->\n To.Parsetree.Pexp_ifthenelse\n (copy_expression x0, copy_expression x1, copy_option copy_expression x2)\n | From.Parsetree.Pexp_sequence (x0, x1) ->\n To.Parsetree.Pexp_sequence (copy_expression x0, copy_expression x1)\n | From.Parsetree.Pexp_while (x0, x1) ->\n To.Parsetree.Pexp_while (copy_expression x0, copy_expression x1)\n | From.Parsetree.Pexp_for (x0, x1, x2, x3, x4) ->\n To.Parsetree.Pexp_for\n ( copy_pattern x0,\n copy_expression x1,\n copy_expression x2,\n copy_direction_flag x3,\n copy_expression x4 )\n | From.Parsetree.Pexp_constraint (x0, x1) ->\n To.Parsetree.Pexp_constraint (copy_expression x0, copy_core_type x1)\n | From.Parsetree.Pexp_coerce (x0, x1, x2) ->\n To.Parsetree.Pexp_coerce\n (copy_expression x0, copy_option copy_core_type x1, copy_core_type x2)\n | From.Parsetree.Pexp_send (x0, x1) ->\n To.Parsetree.Pexp_send (copy_expression x0, copy_loc (fun x -> x) x1)\n | From.Parsetree.Pexp_new x0 ->\n To.Parsetree.Pexp_new (copy_loc copy_longident x0)\n | From.Parsetree.Pexp_setinstvar (x0, x1) ->\n To.Parsetree.Pexp_setinstvar (copy_loc (fun x -> x) x0, copy_expression x1)\n | From.Parsetree.Pexp_override x0 ->\n To.Parsetree.Pexp_override\n (List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_expression x1))\n x0)\n | From.Parsetree.Pexp_letmodule (x0, x1, x2) ->\n To.Parsetree.Pexp_letmodule\n (copy_loc (fun x -> x) x0, copy_module_expr x1, copy_expression x2)\n | From.Parsetree.Pexp_letexception (x0, x1) ->\n To.Parsetree.Pexp_letexception\n (copy_extension_constructor x0, copy_expression x1)\n | From.Parsetree.Pexp_assert x0 ->\n To.Parsetree.Pexp_assert (copy_expression x0)\n | From.Parsetree.Pexp_lazy x0 -> To.Parsetree.Pexp_lazy (copy_expression x0)\n | From.Parsetree.Pexp_poly (x0, x1) ->\n To.Parsetree.Pexp_poly (copy_expression x0, copy_option copy_core_type x1)\n | From.Parsetree.Pexp_object x0 ->\n To.Parsetree.Pexp_object (copy_class_structure x0)\n | From.Parsetree.Pexp_newtype (x0, x1) ->\n To.Parsetree.Pexp_newtype (copy_loc (fun x -> x) x0, copy_expression x1)\n | From.Parsetree.Pexp_pack x0 -> To.Parsetree.Pexp_pack (copy_module_expr x0)\n | From.Parsetree.Pexp_open (x0, x1, x2) ->\n To.Parsetree.Pexp_open\n (copy_override_flag x0, copy_loc copy_longident x1, copy_expression x2)\n | From.Parsetree.Pexp_extension x0 ->\n To.Parsetree.Pexp_extension (copy_extension x0)\n | From.Parsetree.Pexp_unreachable -> To.Parsetree.Pexp_unreachable\n\nand copy_direction_flag :\n From.Asttypes.direction_flag -> To.Asttypes.direction_flag = function\n | From.Asttypes.Upto -> To.Asttypes.Upto\n | From.Asttypes.Downto -> To.Asttypes.Downto\n\nand copy_case : From.Parsetree.case -> To.Parsetree.case =\n fun { From.Parsetree.pc_lhs; From.Parsetree.pc_guard; From.Parsetree.pc_rhs } ->\n {\n To.Parsetree.pc_lhs = copy_pattern pc_lhs;\n To.Parsetree.pc_guard = copy_option copy_expression pc_guard;\n To.Parsetree.pc_rhs = copy_expression pc_rhs;\n }\n\nand copy_value_binding :\n From.Parsetree.value_binding -> To.Parsetree.value_binding =\n fun {\n From.Parsetree.pvb_pat;\n From.Parsetree.pvb_expr;\n From.Parsetree.pvb_attributes;\n From.Parsetree.pvb_loc;\n } ->\n {\n To.Parsetree.pvb_pat = copy_pattern pvb_pat;\n To.Parsetree.pvb_expr = copy_expression pvb_expr;\n To.Parsetree.pvb_attributes = copy_attributes pvb_attributes;\n To.Parsetree.pvb_loc = copy_location pvb_loc;\n }\n\nand copy_pattern : From.Parsetree.pattern -> To.Parsetree.pattern =\n fun {\n From.Parsetree.ppat_desc;\n From.Parsetree.ppat_loc;\n From.Parsetree.ppat_attributes;\n } ->\n {\n To.Parsetree.ppat_desc = copy_pattern_desc ppat_desc;\n To.Parsetree.ppat_loc = copy_location ppat_loc;\n To.Parsetree.ppat_attributes = copy_attributes ppat_attributes;\n }\n\nand copy_pattern_desc : From.Parsetree.pattern_desc -> To.Parsetree.pattern_desc\n = function\n | From.Parsetree.Ppat_any -> To.Parsetree.Ppat_any\n | From.Parsetree.Ppat_var x0 ->\n To.Parsetree.Ppat_var (copy_loc (fun x -> x) x0)\n | From.Parsetree.Ppat_alias (x0, x1) ->\n To.Parsetree.Ppat_alias (copy_pattern x0, copy_loc (fun x -> x) x1)\n | From.Parsetree.Ppat_constant x0 ->\n To.Parsetree.Ppat_constant (copy_constant x0)\n | From.Parsetree.Ppat_interval (x0, x1) ->\n To.Parsetree.Ppat_interval (copy_constant x0, copy_constant x1)\n | From.Parsetree.Ppat_tuple x0 ->\n To.Parsetree.Ppat_tuple (List.map copy_pattern x0)\n | From.Parsetree.Ppat_construct (x0, x1) ->\n To.Parsetree.Ppat_construct\n (copy_loc copy_longident x0, copy_option copy_pattern x1)\n | From.Parsetree.Ppat_variant (x0, x1) ->\n To.Parsetree.Ppat_variant (copy_label x0, copy_option copy_pattern x1)\n | From.Parsetree.Ppat_record (x0, x1) ->\n To.Parsetree.Ppat_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_pattern x1))\n x0,\n copy_closed_flag x1 )\n | From.Parsetree.Ppat_array x0 ->\n To.Parsetree.Ppat_array (List.map copy_pattern x0)\n | From.Parsetree.Ppat_or (x0, x1) ->\n To.Parsetree.Ppat_or (copy_pattern x0, copy_pattern x1)\n | From.Parsetree.Ppat_constraint (x0, x1) ->\n To.Parsetree.Ppat_constraint (copy_pattern x0, copy_core_type x1)\n | From.Parsetree.Ppat_type x0 ->\n To.Parsetree.Ppat_type (copy_loc copy_longident x0)\n | From.Parsetree.Ppat_lazy x0 -> To.Parsetree.Ppat_lazy (copy_pattern x0)\n | From.Parsetree.Ppat_unpack x0 ->\n To.Parsetree.Ppat_unpack (copy_loc (fun x -> x) x0)\n | From.Parsetree.Ppat_exception x0 ->\n To.Parsetree.Ppat_exception (copy_pattern x0)\n | From.Parsetree.Ppat_extension x0 ->\n To.Parsetree.Ppat_extension (copy_extension x0)\n | From.Parsetree.Ppat_open (x0, x1) ->\n To.Parsetree.Ppat_open (copy_loc copy_longident x0, copy_pattern x1)\n\nand copy_core_type : From.Parsetree.core_type -> To.Parsetree.core_type =\n fun {\n From.Parsetree.ptyp_desc;\n From.Parsetree.ptyp_loc;\n From.Parsetree.ptyp_attributes;\n } ->\n {\n To.Parsetree.ptyp_desc = copy_core_type_desc ptyp_desc;\n To.Parsetree.ptyp_loc = copy_location ptyp_loc;\n To.Parsetree.ptyp_attributes = copy_attributes ptyp_attributes;\n }\n\nand copy_core_type_desc :\n From.Parsetree.core_type_desc -> To.Parsetree.core_type_desc = function\n | From.Parsetree.Ptyp_any -> To.Parsetree.Ptyp_any\n | From.Parsetree.Ptyp_var x0 -> To.Parsetree.Ptyp_var x0\n | From.Parsetree.Ptyp_arrow (x0, x1, x2) ->\n To.Parsetree.Ptyp_arrow\n (copy_arg_label x0, copy_core_type x1, copy_core_type x2)\n | From.Parsetree.Ptyp_tuple x0 ->\n To.Parsetree.Ptyp_tuple (List.map copy_core_type x0)\n | From.Parsetree.Ptyp_constr (x0, x1) ->\n To.Parsetree.Ptyp_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Ptyp_object (x0, x1) ->\n To.Parsetree.Ptyp_object\n ( List.map\n (function\n | From.Parsetree.Otag (x0, x1, x2) ->\n ( copy_loc (fun x -> x) x0,\n copy_attributes x1,\n copy_core_type x2 )\n | From.Parsetree.Oinherit _ ->\n migration_error Location.none \"inheritance in object type\")\n x0,\n copy_closed_flag x1 )\n | From.Parsetree.Ptyp_class (x0, x1) ->\n To.Parsetree.Ptyp_class\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Ptyp_alias (x0, x1) ->\n To.Parsetree.Ptyp_alias (copy_core_type x0, x1)\n | From.Parsetree.Ptyp_variant (x0, x1, x2) ->\n To.Parsetree.Ptyp_variant\n ( List.map copy_row_field x0,\n copy_closed_flag x1,\n copy_option (fun x -> List.map copy_label x) x2 )\n | From.Parsetree.Ptyp_poly (x0, x1) ->\n To.Parsetree.Ptyp_poly\n (List.map (fun x -> copy_loc (fun x -> x) x) x0, copy_core_type x1)\n | From.Parsetree.Ptyp_package x0 ->\n To.Parsetree.Ptyp_package (copy_package_type x0)\n | From.Parsetree.Ptyp_extension x0 ->\n To.Parsetree.Ptyp_extension (copy_extension x0)\n\nand copy_package_type : From.Parsetree.package_type -> To.Parsetree.package_type\n =\n fun x ->\n let x0, x1 = x in\n ( copy_loc copy_longident x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_core_type x1))\n x1 )\n\nand copy_row_field : From.Parsetree.row_field -> To.Parsetree.row_field =\n function\n | From.Parsetree.Rtag (x0, x1, x2, x3) ->\n To.Parsetree.Rtag\n ( copy_label x0.txt,\n copy_attributes x1,\n copy_bool x2,\n List.map copy_core_type x3 )\n | From.Parsetree.Rinherit x0 -> To.Parsetree.Rinherit (copy_core_type x0)\n\nand copy_attributes : From.Parsetree.attributes -> To.Parsetree.attributes =\n fun x -> List.map copy_attribute x\n\nand copy_attribute : From.Parsetree.attribute -> To.Parsetree.attribute =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_payload : From.Parsetree.payload -> To.Parsetree.payload = function\n | From.Parsetree.PStr x0 -> To.Parsetree.PStr (copy_structure x0)\n | From.Parsetree.PSig x0 -> To.Parsetree.PSig (copy_signature x0)\n | From.Parsetree.PTyp x0 -> To.Parsetree.PTyp (copy_core_type x0)\n | From.Parsetree.PPat (x0, x1) ->\n To.Parsetree.PPat (copy_pattern x0, copy_option copy_expression x1)\n\nand copy_structure : From.Parsetree.structure -> To.Parsetree.structure =\n fun x -> List.map copy_structure_item x\n\nand copy_structure_item :\n From.Parsetree.structure_item -> To.Parsetree.structure_item =\n fun { From.Parsetree.pstr_desc; From.Parsetree.pstr_loc } ->\n {\n To.Parsetree.pstr_desc = copy_structure_item_desc pstr_desc;\n To.Parsetree.pstr_loc = copy_location pstr_loc;\n }\n\nand copy_structure_item_desc :\n From.Parsetree.structure_item_desc -> To.Parsetree.structure_item_desc =\n function\n | From.Parsetree.Pstr_eval (x0, x1) ->\n To.Parsetree.Pstr_eval (copy_expression x0, copy_attributes x1)\n | From.Parsetree.Pstr_value (x0, x1) ->\n To.Parsetree.Pstr_value (copy_rec_flag x0, List.map copy_value_binding x1)\n | From.Parsetree.Pstr_primitive x0 ->\n To.Parsetree.Pstr_primitive (copy_value_description x0)\n | From.Parsetree.Pstr_type (x0, x1) ->\n To.Parsetree.Pstr_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | From.Parsetree.Pstr_typext x0 ->\n To.Parsetree.Pstr_typext (copy_type_extension x0)\n | From.Parsetree.Pstr_exception x0 ->\n To.Parsetree.Pstr_exception (copy_extension_constructor x0)\n | From.Parsetree.Pstr_module x0 ->\n To.Parsetree.Pstr_module (copy_module_binding x0)\n | From.Parsetree.Pstr_recmodule x0 ->\n To.Parsetree.Pstr_recmodule (List.map copy_module_binding x0)\n | From.Parsetree.Pstr_modtype x0 ->\n To.Parsetree.Pstr_modtype (copy_module_type_declaration x0)\n | From.Parsetree.Pstr_open x0 ->\n To.Parsetree.Pstr_open (copy_open_description x0)\n | From.Parsetree.Pstr_class x0 ->\n To.Parsetree.Pstr_class (List.map copy_class_declaration x0)\n | From.Parsetree.Pstr_class_type x0 ->\n To.Parsetree.Pstr_class_type (List.map copy_class_type_declaration x0)\n | From.Parsetree.Pstr_include x0 ->\n To.Parsetree.Pstr_include (copy_include_declaration x0)\n | From.Parsetree.Pstr_attribute x0 ->\n To.Parsetree.Pstr_attribute (copy_attribute x0)\n | From.Parsetree.Pstr_extension (x0, x1) ->\n To.Parsetree.Pstr_extension (copy_extension x0, copy_attributes x1)\n\nand copy_include_declaration :\n From.Parsetree.include_declaration -> To.Parsetree.include_declaration =\n fun x -> copy_include_infos copy_module_expr x\n\nand copy_class_declaration :\n From.Parsetree.class_declaration -> To.Parsetree.class_declaration =\n fun x -> copy_class_infos copy_class_expr x\n\nand copy_class_expr : From.Parsetree.class_expr -> To.Parsetree.class_expr =\n fun {\n From.Parsetree.pcl_desc;\n From.Parsetree.pcl_loc;\n From.Parsetree.pcl_attributes;\n } ->\n {\n To.Parsetree.pcl_desc = copy_class_expr_desc pcl_desc;\n To.Parsetree.pcl_loc = copy_location pcl_loc;\n To.Parsetree.pcl_attributes = copy_attributes pcl_attributes;\n }\n\nand copy_class_expr_desc :\n From.Parsetree.class_expr_desc -> To.Parsetree.class_expr_desc = function\n | From.Parsetree.Pcl_constr (x0, x1) ->\n To.Parsetree.Pcl_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Pcl_structure x0 ->\n To.Parsetree.Pcl_structure (copy_class_structure x0)\n | From.Parsetree.Pcl_fun (x0, x1, x2, x3) ->\n To.Parsetree.Pcl_fun\n ( copy_arg_label x0,\n copy_option copy_expression x1,\n copy_pattern x2,\n copy_class_expr x3 )\n | From.Parsetree.Pcl_apply (x0, x1) ->\n To.Parsetree.Pcl_apply\n ( copy_class_expr x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | From.Parsetree.Pcl_let (x0, x1, x2) ->\n To.Parsetree.Pcl_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_class_expr x2)\n | From.Parsetree.Pcl_constraint (x0, x1) ->\n To.Parsetree.Pcl_constraint (copy_class_expr x0, copy_class_type x1)\n | From.Parsetree.Pcl_extension x0 ->\n To.Parsetree.Pcl_extension (copy_extension x0)\n | From.Parsetree.Pcl_open (_, loc, _) ->\n migration_error loc.Location.loc \"module open in class expression\"\n\nand copy_class_structure :\n From.Parsetree.class_structure -> To.Parsetree.class_structure =\n fun { From.Parsetree.pcstr_self; From.Parsetree.pcstr_fields } ->\n {\n To.Parsetree.pcstr_self = copy_pattern pcstr_self;\n To.Parsetree.pcstr_fields = List.map copy_class_field pcstr_fields;\n }\n\nand copy_class_field : From.Parsetree.class_field -> To.Parsetree.class_field =\n fun {\n From.Parsetree.pcf_desc;\n From.Parsetree.pcf_loc;\n From.Parsetree.pcf_attributes;\n } ->\n {\n To.Parsetree.pcf_desc = copy_class_field_desc pcf_desc;\n To.Parsetree.pcf_loc = copy_location pcf_loc;\n To.Parsetree.pcf_attributes = copy_attributes pcf_attributes;\n }\n\nand copy_class_field_desc :\n From.Parsetree.class_field_desc -> To.Parsetree.class_field_desc = function\n | From.Parsetree.Pcf_inherit (x0, x1, x2) ->\n To.Parsetree.Pcf_inherit\n ( copy_override_flag x0,\n copy_class_expr x1,\n copy_option (copy_loc (fun x -> x)) x2 )\n | From.Parsetree.Pcf_val x0 ->\n To.Parsetree.Pcf_val\n (let x0, x1, x2 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_mutable_flag x1,\n copy_class_field_kind x2 ))\n | From.Parsetree.Pcf_method x0 ->\n To.Parsetree.Pcf_method\n (let x0, x1, x2 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_private_flag x1,\n copy_class_field_kind x2 ))\n | From.Parsetree.Pcf_constraint x0 ->\n To.Parsetree.Pcf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | From.Parsetree.Pcf_initializer x0 ->\n To.Parsetree.Pcf_initializer (copy_expression x0)\n | From.Parsetree.Pcf_attribute x0 ->\n To.Parsetree.Pcf_attribute (copy_attribute x0)\n | From.Parsetree.Pcf_extension x0 ->\n To.Parsetree.Pcf_extension (copy_extension x0)\n\nand copy_class_field_kind :\n From.Parsetree.class_field_kind -> To.Parsetree.class_field_kind = function\n | From.Parsetree.Cfk_virtual x0 ->\n To.Parsetree.Cfk_virtual (copy_core_type x0)\n | From.Parsetree.Cfk_concrete (x0, x1) ->\n To.Parsetree.Cfk_concrete (copy_override_flag x0, copy_expression x1)\n\nand copy_module_binding :\n From.Parsetree.module_binding -> To.Parsetree.module_binding =\n fun {\n From.Parsetree.pmb_name;\n From.Parsetree.pmb_expr;\n From.Parsetree.pmb_attributes;\n From.Parsetree.pmb_loc;\n } ->\n {\n To.Parsetree.pmb_name = copy_loc (fun x -> x) pmb_name;\n To.Parsetree.pmb_expr = copy_module_expr pmb_expr;\n To.Parsetree.pmb_attributes = copy_attributes pmb_attributes;\n To.Parsetree.pmb_loc = copy_location pmb_loc;\n }\n\nand copy_module_expr : From.Parsetree.module_expr -> To.Parsetree.module_expr =\n fun {\n From.Parsetree.pmod_desc;\n From.Parsetree.pmod_loc;\n From.Parsetree.pmod_attributes;\n } ->\n {\n To.Parsetree.pmod_desc = copy_module_expr_desc pmod_desc;\n To.Parsetree.pmod_loc = copy_location pmod_loc;\n To.Parsetree.pmod_attributes = copy_attributes pmod_attributes;\n }\n\nand copy_module_expr_desc :\n From.Parsetree.module_expr_desc -> To.Parsetree.module_expr_desc = function\n | From.Parsetree.Pmod_ident x0 ->\n To.Parsetree.Pmod_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pmod_structure x0 ->\n To.Parsetree.Pmod_structure (copy_structure x0)\n | From.Parsetree.Pmod_functor (x0, x1, x2) ->\n To.Parsetree.Pmod_functor\n ( copy_loc (fun x -> x) x0,\n copy_option copy_module_type x1,\n copy_module_expr x2 )\n | From.Parsetree.Pmod_apply (x0, x1) ->\n To.Parsetree.Pmod_apply (copy_module_expr x0, copy_module_expr x1)\n | From.Parsetree.Pmod_constraint (x0, x1) ->\n To.Parsetree.Pmod_constraint (copy_module_expr x0, copy_module_type x1)\n | From.Parsetree.Pmod_unpack x0 ->\n To.Parsetree.Pmod_unpack (copy_expression x0)\n | From.Parsetree.Pmod_extension x0 ->\n To.Parsetree.Pmod_extension (copy_extension x0)\n\nand copy_module_type : From.Parsetree.module_type -> To.Parsetree.module_type =\n fun {\n From.Parsetree.pmty_desc;\n From.Parsetree.pmty_loc;\n From.Parsetree.pmty_attributes;\n } ->\n {\n To.Parsetree.pmty_desc = copy_module_type_desc pmty_desc;\n To.Parsetree.pmty_loc = copy_location pmty_loc;\n To.Parsetree.pmty_attributes = copy_attributes pmty_attributes;\n }\n\nand copy_module_type_desc :\n From.Parsetree.module_type_desc -> To.Parsetree.module_type_desc = function\n | From.Parsetree.Pmty_ident x0 ->\n To.Parsetree.Pmty_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pmty_signature x0 ->\n To.Parsetree.Pmty_signature (copy_signature x0)\n | From.Parsetree.Pmty_functor (x0, x1, x2) ->\n To.Parsetree.Pmty_functor\n ( copy_loc (fun x -> x) x0,\n copy_option copy_module_type x1,\n copy_module_type x2 )\n | From.Parsetree.Pmty_with (x0, x1) ->\n To.Parsetree.Pmty_with\n (copy_module_type x0, List.map copy_with_constraint x1)\n | From.Parsetree.Pmty_typeof x0 ->\n To.Parsetree.Pmty_typeof (copy_module_expr x0)\n | From.Parsetree.Pmty_extension x0 ->\n To.Parsetree.Pmty_extension (copy_extension x0)\n | From.Parsetree.Pmty_alias x0 ->\n To.Parsetree.Pmty_alias (copy_loc copy_longident x0)\n\nand copy_with_constraint :\n From.Parsetree.with_constraint -> To.Parsetree.with_constraint = function\n | From.Parsetree.Pwith_type (x0, x1) ->\n To.Parsetree.Pwith_type\n (copy_loc copy_longident x0, copy_type_declaration x1)\n | From.Parsetree.Pwith_module (x0, x1) ->\n To.Parsetree.Pwith_module\n (copy_loc copy_longident x0, copy_loc copy_longident x1)\n | From.Parsetree.Pwith_typesubst ({ txt = Longident.Lident _; _ }, x0) ->\n To.Parsetree.Pwith_typesubst (copy_type_declaration x0)\n | From.Parsetree.Pwith_modsubst ({ txt = Longident.Lident x0; loc }, x1) ->\n To.Parsetree.Pwith_modsubst ({ txt = x0; loc }, copy_loc copy_longident x1)\n | From.Parsetree.Pwith_typesubst ({ loc; _ }, _x0) ->\n migration_error loc \"type substitution inside a submodule\"\n | From.Parsetree.Pwith_modsubst ({ loc; _ }, _x1) ->\n migration_error loc \"module substitution inside a submodule\"\n\nand copy_signature : From.Parsetree.signature -> To.Parsetree.signature =\n fun x -> List.map copy_signature_item x\n\nand copy_signature_item :\n From.Parsetree.signature_item -> To.Parsetree.signature_item =\n fun { From.Parsetree.psig_desc; From.Parsetree.psig_loc } ->\n {\n To.Parsetree.psig_desc = copy_signature_item_desc psig_desc;\n To.Parsetree.psig_loc = copy_location psig_loc;\n }\n\nand copy_signature_item_desc :\n From.Parsetree.signature_item_desc -> To.Parsetree.signature_item_desc =\n function\n | From.Parsetree.Psig_value x0 ->\n To.Parsetree.Psig_value (copy_value_description x0)\n | From.Parsetree.Psig_type (x0, x1) ->\n To.Parsetree.Psig_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | From.Parsetree.Psig_typext x0 ->\n To.Parsetree.Psig_typext (copy_type_extension x0)\n | From.Parsetree.Psig_exception x0 ->\n To.Parsetree.Psig_exception (copy_extension_constructor x0)\n | From.Parsetree.Psig_module x0 ->\n To.Parsetree.Psig_module (copy_module_declaration x0)\n | From.Parsetree.Psig_recmodule x0 ->\n To.Parsetree.Psig_recmodule (List.map copy_module_declaration x0)\n | From.Parsetree.Psig_modtype x0 ->\n To.Parsetree.Psig_modtype (copy_module_type_declaration x0)\n | From.Parsetree.Psig_open x0 ->\n To.Parsetree.Psig_open (copy_open_description x0)\n | From.Parsetree.Psig_include x0 ->\n To.Parsetree.Psig_include (copy_include_description x0)\n | From.Parsetree.Psig_class x0 ->\n To.Parsetree.Psig_class (List.map copy_class_description x0)\n | From.Parsetree.Psig_class_type x0 ->\n To.Parsetree.Psig_class_type (List.map copy_class_type_declaration x0)\n | From.Parsetree.Psig_attribute x0 ->\n To.Parsetree.Psig_attribute (copy_attribute x0)\n | From.Parsetree.Psig_extension (x0, x1) ->\n To.Parsetree.Psig_extension (copy_extension x0, copy_attributes x1)\n\nand copy_class_type_declaration :\n From.Parsetree.class_type_declaration -> To.Parsetree.class_type_declaration\n =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_description :\n From.Parsetree.class_description -> To.Parsetree.class_description =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_type : From.Parsetree.class_type -> To.Parsetree.class_type =\n fun {\n From.Parsetree.pcty_desc;\n From.Parsetree.pcty_loc;\n From.Parsetree.pcty_attributes;\n } ->\n {\n To.Parsetree.pcty_desc = copy_class_type_desc pcty_desc;\n To.Parsetree.pcty_loc = copy_location pcty_loc;\n To.Parsetree.pcty_attributes = copy_attributes pcty_attributes;\n }\n\nand copy_class_type_desc :\n From.Parsetree.class_type_desc -> To.Parsetree.class_type_desc = function\n | From.Parsetree.Pcty_constr (x0, x1) ->\n To.Parsetree.Pcty_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Pcty_signature x0 ->\n To.Parsetree.Pcty_signature (copy_class_signature x0)\n | From.Parsetree.Pcty_arrow (x0, x1, x2) ->\n To.Parsetree.Pcty_arrow\n (copy_arg_label x0, copy_core_type x1, copy_class_type x2)\n | From.Parsetree.Pcty_extension x0 ->\n To.Parsetree.Pcty_extension (copy_extension x0)\n | From.Parsetree.Pcty_open (_, loc, _) ->\n migration_error loc.Location.loc \"module open in class type\"\n\nand copy_class_signature :\n From.Parsetree.class_signature -> To.Parsetree.class_signature =\n fun { From.Parsetree.pcsig_self; From.Parsetree.pcsig_fields } ->\n {\n To.Parsetree.pcsig_self = copy_core_type pcsig_self;\n To.Parsetree.pcsig_fields = List.map copy_class_type_field pcsig_fields;\n }\n\nand copy_class_type_field :\n From.Parsetree.class_type_field -> To.Parsetree.class_type_field =\n fun {\n From.Parsetree.pctf_desc;\n From.Parsetree.pctf_loc;\n From.Parsetree.pctf_attributes;\n } ->\n {\n To.Parsetree.pctf_desc = copy_class_type_field_desc pctf_desc;\n To.Parsetree.pctf_loc = copy_location pctf_loc;\n To.Parsetree.pctf_attributes = copy_attributes pctf_attributes;\n }\n\nand copy_class_type_field_desc :\n From.Parsetree.class_type_field_desc -> To.Parsetree.class_type_field_desc =\n function\n | From.Parsetree.Pctf_inherit x0 ->\n To.Parsetree.Pctf_inherit (copy_class_type x0)\n | From.Parsetree.Pctf_val x0 ->\n To.Parsetree.Pctf_val\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_mutable_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | From.Parsetree.Pctf_method x0 ->\n To.Parsetree.Pctf_method\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_private_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | From.Parsetree.Pctf_constraint x0 ->\n To.Parsetree.Pctf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | From.Parsetree.Pctf_attribute x0 ->\n To.Parsetree.Pctf_attribute (copy_attribute x0)\n | From.Parsetree.Pctf_extension x0 ->\n To.Parsetree.Pctf_extension (copy_extension x0)\n\nand copy_extension : From.Parsetree.extension -> To.Parsetree.extension =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_class_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 From.Parsetree.class_infos ->\n 'g0 To.Parsetree.class_infos =\n fun f0\n {\n From.Parsetree.pci_virt;\n From.Parsetree.pci_params;\n From.Parsetree.pci_name;\n From.Parsetree.pci_expr;\n From.Parsetree.pci_loc;\n From.Parsetree.pci_attributes;\n } ->\n {\n To.Parsetree.pci_virt = copy_virtual_flag pci_virt;\n To.Parsetree.pci_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n pci_params;\n To.Parsetree.pci_name = copy_loc (fun x -> x) pci_name;\n To.Parsetree.pci_expr = f0 pci_expr;\n To.Parsetree.pci_loc = copy_location pci_loc;\n To.Parsetree.pci_attributes = copy_attributes pci_attributes;\n }\n\nand copy_virtual_flag : From.Asttypes.virtual_flag -> To.Asttypes.virtual_flag =\n function\n | From.Asttypes.Virtual -> To.Asttypes.Virtual\n | From.Asttypes.Concrete -> To.Asttypes.Concrete\n\nand copy_include_description :\n From.Parsetree.include_description -> To.Parsetree.include_description =\n fun x -> copy_include_infos copy_module_type x\n\nand copy_include_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 From.Parsetree.include_infos ->\n 'g0 To.Parsetree.include_infos =\n fun f0\n {\n From.Parsetree.pincl_mod;\n From.Parsetree.pincl_loc;\n From.Parsetree.pincl_attributes;\n } ->\n {\n To.Parsetree.pincl_mod = f0 pincl_mod;\n To.Parsetree.pincl_loc = copy_location pincl_loc;\n To.Parsetree.pincl_attributes = copy_attributes pincl_attributes;\n }\n\nand copy_open_description :\n From.Parsetree.open_description -> To.Parsetree.open_description =\n fun {\n From.Parsetree.popen_lid;\n From.Parsetree.popen_override;\n From.Parsetree.popen_loc;\n From.Parsetree.popen_attributes;\n } ->\n {\n To.Parsetree.popen_lid = copy_loc copy_longident popen_lid;\n To.Parsetree.popen_override = copy_override_flag popen_override;\n To.Parsetree.popen_loc = copy_location popen_loc;\n To.Parsetree.popen_attributes = copy_attributes popen_attributes;\n }\n\nand copy_override_flag :\n From.Asttypes.override_flag -> To.Asttypes.override_flag = function\n | From.Asttypes.Override -> To.Asttypes.Override\n | From.Asttypes.Fresh -> To.Asttypes.Fresh\n\nand copy_module_type_declaration :\n From.Parsetree.module_type_declaration ->\n To.Parsetree.module_type_declaration =\n fun {\n From.Parsetree.pmtd_name;\n From.Parsetree.pmtd_type;\n From.Parsetree.pmtd_attributes;\n From.Parsetree.pmtd_loc;\n } ->\n {\n To.Parsetree.pmtd_name = copy_loc (fun x -> x) pmtd_name;\n To.Parsetree.pmtd_type = copy_option copy_module_type pmtd_type;\n To.Parsetree.pmtd_attributes = copy_attributes pmtd_attributes;\n To.Parsetree.pmtd_loc = copy_location pmtd_loc;\n }\n\nand copy_module_declaration :\n From.Parsetree.module_declaration -> To.Parsetree.module_declaration =\n fun {\n From.Parsetree.pmd_name;\n From.Parsetree.pmd_type;\n From.Parsetree.pmd_attributes;\n From.Parsetree.pmd_loc;\n } ->\n {\n To.Parsetree.pmd_name = copy_loc (fun x -> x) pmd_name;\n To.Parsetree.pmd_type = copy_module_type pmd_type;\n To.Parsetree.pmd_attributes = copy_attributes pmd_attributes;\n To.Parsetree.pmd_loc = copy_location pmd_loc;\n }\n\nand copy_type_extension :\n From.Parsetree.type_extension -> To.Parsetree.type_extension =\n fun {\n From.Parsetree.ptyext_path;\n From.Parsetree.ptyext_params;\n From.Parsetree.ptyext_constructors;\n From.Parsetree.ptyext_private;\n From.Parsetree.ptyext_attributes;\n } ->\n {\n To.Parsetree.ptyext_path = copy_loc copy_longident ptyext_path;\n To.Parsetree.ptyext_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptyext_params;\n To.Parsetree.ptyext_constructors =\n List.map copy_extension_constructor ptyext_constructors;\n To.Parsetree.ptyext_private = copy_private_flag ptyext_private;\n To.Parsetree.ptyext_attributes = copy_attributes ptyext_attributes;\n }\n\nand copy_extension_constructor :\n From.Parsetree.extension_constructor -> To.Parsetree.extension_constructor =\n fun {\n From.Parsetree.pext_name;\n From.Parsetree.pext_kind;\n From.Parsetree.pext_loc;\n From.Parsetree.pext_attributes;\n } ->\n {\n To.Parsetree.pext_name = copy_loc (fun x -> x) pext_name;\n To.Parsetree.pext_kind = copy_extension_constructor_kind pext_kind;\n To.Parsetree.pext_loc = copy_location pext_loc;\n To.Parsetree.pext_attributes = copy_attributes pext_attributes;\n }\n\nand copy_extension_constructor_kind :\n From.Parsetree.extension_constructor_kind ->\n To.Parsetree.extension_constructor_kind = function\n | From.Parsetree.Pext_decl (x0, x1) ->\n To.Parsetree.Pext_decl\n (copy_constructor_arguments x0, copy_option copy_core_type x1)\n | From.Parsetree.Pext_rebind x0 ->\n To.Parsetree.Pext_rebind (copy_loc copy_longident x0)\n\nand copy_type_declaration :\n From.Parsetree.type_declaration -> To.Parsetree.type_declaration =\n fun {\n From.Parsetree.ptype_name;\n From.Parsetree.ptype_params;\n From.Parsetree.ptype_cstrs;\n From.Parsetree.ptype_kind;\n From.Parsetree.ptype_private;\n From.Parsetree.ptype_manifest;\n From.Parsetree.ptype_attributes;\n From.Parsetree.ptype_loc;\n } ->\n {\n To.Parsetree.ptype_name = copy_loc (fun x -> x) ptype_name;\n To.Parsetree.ptype_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptype_params;\n To.Parsetree.ptype_cstrs =\n List.map\n (fun x ->\n let x0, x1, x2 = x in\n (copy_core_type x0, copy_core_type x1, copy_location x2))\n ptype_cstrs;\n To.Parsetree.ptype_kind = copy_type_kind ptype_kind;\n To.Parsetree.ptype_private = copy_private_flag ptype_private;\n To.Parsetree.ptype_manifest = copy_option copy_core_type ptype_manifest;\n To.Parsetree.ptype_attributes = copy_attributes ptype_attributes;\n To.Parsetree.ptype_loc = copy_location ptype_loc;\n }\n\nand copy_private_flag : From.Asttypes.private_flag -> To.Asttypes.private_flag =\n function\n | From.Asttypes.Private -> To.Asttypes.Private\n | From.Asttypes.Public -> To.Asttypes.Public\n\nand copy_type_kind : From.Parsetree.type_kind -> To.Parsetree.type_kind =\n function\n | From.Parsetree.Ptype_abstract -> To.Parsetree.Ptype_abstract\n | From.Parsetree.Ptype_variant x0 ->\n To.Parsetree.Ptype_variant (List.map copy_constructor_declaration x0)\n | From.Parsetree.Ptype_record x0 ->\n To.Parsetree.Ptype_record (List.map copy_label_declaration x0)\n | From.Parsetree.Ptype_open -> To.Parsetree.Ptype_open\n\nand copy_constructor_declaration :\n From.Parsetree.constructor_declaration ->\n To.Parsetree.constructor_declaration =\n fun {\n From.Parsetree.pcd_name;\n From.Parsetree.pcd_args;\n From.Parsetree.pcd_res;\n From.Parsetree.pcd_loc;\n From.Parsetree.pcd_attributes;\n } ->\n {\n To.Parsetree.pcd_name = copy_loc (fun x -> x) pcd_name;\n To.Parsetree.pcd_args = copy_constructor_arguments pcd_args;\n To.Parsetree.pcd_res = copy_option copy_core_type pcd_res;\n To.Parsetree.pcd_loc = copy_location pcd_loc;\n To.Parsetree.pcd_attributes = copy_attributes pcd_attributes;\n }\n\nand copy_constructor_arguments :\n From.Parsetree.constructor_arguments -> To.Parsetree.constructor_arguments =\n function\n | From.Parsetree.Pcstr_tuple x0 ->\n To.Parsetree.Pcstr_tuple (List.map copy_core_type x0)\n | From.Parsetree.Pcstr_record x0 ->\n To.Parsetree.Pcstr_record (List.map copy_label_declaration x0)\n\nand copy_label_declaration :\n From.Parsetree.label_declaration -> To.Parsetree.label_declaration =\n fun {\n From.Parsetree.pld_name;\n From.Parsetree.pld_mutable;\n From.Parsetree.pld_type;\n From.Parsetree.pld_loc;\n From.Parsetree.pld_attributes;\n } ->\n {\n To.Parsetree.pld_name = copy_loc (fun x -> x) pld_name;\n To.Parsetree.pld_mutable = copy_mutable_flag pld_mutable;\n To.Parsetree.pld_type = copy_core_type pld_type;\n To.Parsetree.pld_loc = copy_location pld_loc;\n To.Parsetree.pld_attributes = copy_attributes pld_attributes;\n }\n\nand copy_mutable_flag : From.Asttypes.mutable_flag -> To.Asttypes.mutable_flag =\n function\n | From.Asttypes.Immutable -> To.Asttypes.Immutable\n | From.Asttypes.Mutable -> To.Asttypes.Mutable\n\nand copy_variance : From.Asttypes.variance -> To.Asttypes.variance = function\n | From.Asttypes.Covariant -> To.Asttypes.Covariant\n | From.Asttypes.Contravariant -> To.Asttypes.Contravariant\n | From.Asttypes.Invariant -> To.Asttypes.Invariant\n\nand copy_value_description :\n From.Parsetree.value_description -> To.Parsetree.value_description =\n fun {\n From.Parsetree.pval_name;\n From.Parsetree.pval_type;\n From.Parsetree.pval_prim;\n From.Parsetree.pval_attributes;\n From.Parsetree.pval_loc;\n } ->\n {\n To.Parsetree.pval_name = copy_loc (fun x -> x) pval_name;\n To.Parsetree.pval_type = copy_core_type pval_type;\n To.Parsetree.pval_prim = List.map (fun x -> x) pval_prim;\n To.Parsetree.pval_attributes = copy_attributes pval_attributes;\n To.Parsetree.pval_loc = copy_location pval_loc;\n }\n\nand copy_arg_label : From.Asttypes.arg_label -> To.Asttypes.arg_label = function\n | From.Asttypes.Nolabel -> To.Asttypes.Nolabel\n | From.Asttypes.Labelled x0 -> To.Asttypes.Labelled x0\n | From.Asttypes.Optional x0 -> To.Asttypes.Optional x0\n\nand copy_closed_flag : From.Asttypes.closed_flag -> To.Asttypes.closed_flag =\n function\n | From.Asttypes.Closed -> To.Asttypes.Closed\n | From.Asttypes.Open -> To.Asttypes.Open\n\nand copy_label : From.Asttypes.label -> To.Asttypes.label = fun x -> x\n\nand copy_rec_flag : From.Asttypes.rec_flag -> To.Asttypes.rec_flag = function\n | From.Asttypes.Nonrecursive -> To.Asttypes.Nonrecursive\n | From.Asttypes.Recursive -> To.Asttypes.Recursive\n\nand copy_constant : From.Parsetree.constant -> To.Parsetree.constant = function\n | From.Parsetree.Pconst_integer (x0, x1) ->\n To.Parsetree.Pconst_integer (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pconst_char x0 -> To.Parsetree.Pconst_char x0\n | From.Parsetree.Pconst_string (x0, x1) ->\n To.Parsetree.Pconst_string (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pconst_float (x0, x1) ->\n To.Parsetree.Pconst_float (x0, copy_option (fun x -> x) x1)\n\nand copy_option : 'f0 'g0. ('f0 -> 'g0) -> 'f0 option -> 'g0 option =\n fun f0 -> function None -> None | Some x0 -> Some (f0 x0)\n\nand copy_longident : Longident.t -> Longident.t = fun x -> x\n\nand copy_loc :\n 'f0 'g0. ('f0 -> 'g0) -> 'f0 From.Asttypes.loc -> 'g0 To.Asttypes.loc =\n fun f0 { From.Asttypes.txt; From.Asttypes.loc } ->\n { To.Asttypes.txt = f0 txt; To.Asttypes.loc = copy_location loc }\n\nand copy_location : Location.t -> Location.t = fun x -> x\nand copy_bool : bool -> bool = function false -> false | true -> true\n\nlet rec copy_toplevel_phrase :\n From.Parsetree.toplevel_phrase -> To.Parsetree.toplevel_phrase = function\n | From.Parsetree.Ptop_def x0 -> To.Parsetree.Ptop_def (copy_structure x0)\n | From.Parsetree.Ptop_dir (x0, x1) ->\n To.Parsetree.Ptop_dir (x0, copy_directive_argument x1)\n\nand copy_directive_argument :\n From.Parsetree.directive_argument -> To.Parsetree.directive_argument =\n function\n | From.Parsetree.Pdir_none -> To.Parsetree.Pdir_none\n | From.Parsetree.Pdir_string x0 -> To.Parsetree.Pdir_string x0\n | From.Parsetree.Pdir_int (x0, x1) ->\n To.Parsetree.Pdir_int (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pdir_ident x0 -> To.Parsetree.Pdir_ident (copy_longident x0)\n | From.Parsetree.Pdir_bool x0 -> To.Parsetree.Pdir_bool (copy_bool x0)\n\nlet copy_cases x = List.map copy_case x\nlet copy_pat = copy_pattern\nlet copy_expr = copy_expression\nlet copy_typ = copy_core_type\n","(**************************************************************************)\n(* *)\n(* OCaml Migrate Parsetree *)\n(* *)\n(* Frédéric Bour *)\n(* Alain Frisch, LexiFi *)\n(* *)\n(* Copyright 2017 Institut National de Recherche en Informatique et *)\n(* en Automatique (INRIA). *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nmodule From = Ast_405\nmodule To = Ast_406\n\nlet rec copy_expression : From.Parsetree.expression -> To.Parsetree.expression =\n fun {\n From.Parsetree.pexp_desc;\n From.Parsetree.pexp_loc;\n From.Parsetree.pexp_attributes;\n } ->\n {\n To.Parsetree.pexp_desc = copy_expression_desc pexp_desc;\n To.Parsetree.pexp_loc = copy_location pexp_loc;\n To.Parsetree.pexp_attributes = copy_attributes pexp_attributes;\n }\n\nand copy_expression_desc :\n From.Parsetree.expression_desc -> To.Parsetree.expression_desc = function\n | From.Parsetree.Pexp_ident x0 ->\n To.Parsetree.Pexp_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pexp_constant x0 ->\n To.Parsetree.Pexp_constant (copy_constant x0)\n | From.Parsetree.Pexp_let (x0, x1, x2) ->\n To.Parsetree.Pexp_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_expression x2)\n | From.Parsetree.Pexp_function x0 ->\n To.Parsetree.Pexp_function (List.map copy_case x0)\n | From.Parsetree.Pexp_fun (x0, x1, x2, x3) ->\n To.Parsetree.Pexp_fun\n ( copy_arg_label x0,\n copy_option copy_expression x1,\n copy_pattern x2,\n copy_expression x3 )\n | From.Parsetree.Pexp_apply (x0, x1) ->\n To.Parsetree.Pexp_apply\n ( copy_expression x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | From.Parsetree.Pexp_match (x0, x1) ->\n To.Parsetree.Pexp_match (copy_expression x0, List.map copy_case x1)\n | From.Parsetree.Pexp_try (x0, x1) ->\n To.Parsetree.Pexp_try (copy_expression x0, List.map copy_case x1)\n | From.Parsetree.Pexp_tuple x0 ->\n To.Parsetree.Pexp_tuple (List.map copy_expression x0)\n | From.Parsetree.Pexp_construct (x0, x1) ->\n To.Parsetree.Pexp_construct\n (copy_loc copy_longident x0, copy_option copy_expression x1)\n | From.Parsetree.Pexp_variant (x0, x1) ->\n To.Parsetree.Pexp_variant (copy_label x0, copy_option copy_expression x1)\n | From.Parsetree.Pexp_record (x0, x1) ->\n To.Parsetree.Pexp_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_expression x1))\n x0,\n copy_option copy_expression x1 )\n | From.Parsetree.Pexp_field (x0, x1) ->\n To.Parsetree.Pexp_field (copy_expression x0, copy_loc copy_longident x1)\n | From.Parsetree.Pexp_setfield (x0, x1, x2) ->\n To.Parsetree.Pexp_setfield\n (copy_expression x0, copy_loc copy_longident x1, copy_expression x2)\n | From.Parsetree.Pexp_array x0 ->\n To.Parsetree.Pexp_array (List.map copy_expression x0)\n | From.Parsetree.Pexp_ifthenelse (x0, x1, x2) ->\n To.Parsetree.Pexp_ifthenelse\n (copy_expression x0, copy_expression x1, copy_option copy_expression x2)\n | From.Parsetree.Pexp_sequence (x0, x1) ->\n To.Parsetree.Pexp_sequence (copy_expression x0, copy_expression x1)\n | From.Parsetree.Pexp_while (x0, x1) ->\n To.Parsetree.Pexp_while (copy_expression x0, copy_expression x1)\n | From.Parsetree.Pexp_for (x0, x1, x2, x3, x4) ->\n To.Parsetree.Pexp_for\n ( copy_pattern x0,\n copy_expression x1,\n copy_expression x2,\n copy_direction_flag x3,\n copy_expression x4 )\n | From.Parsetree.Pexp_constraint (x0, x1) ->\n To.Parsetree.Pexp_constraint (copy_expression x0, copy_core_type x1)\n | From.Parsetree.Pexp_coerce (x0, x1, x2) ->\n To.Parsetree.Pexp_coerce\n (copy_expression x0, copy_option copy_core_type x1, copy_core_type x2)\n | From.Parsetree.Pexp_send (x0, x1) ->\n To.Parsetree.Pexp_send (copy_expression x0, copy_loc (fun x -> x) x1)\n | From.Parsetree.Pexp_new x0 ->\n To.Parsetree.Pexp_new (copy_loc copy_longident x0)\n | From.Parsetree.Pexp_setinstvar (x0, x1) ->\n To.Parsetree.Pexp_setinstvar (copy_loc (fun x -> x) x0, copy_expression x1)\n | From.Parsetree.Pexp_override x0 ->\n To.Parsetree.Pexp_override\n (List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_expression x1))\n x0)\n | From.Parsetree.Pexp_letmodule (x0, x1, x2) ->\n To.Parsetree.Pexp_letmodule\n (copy_loc (fun x -> x) x0, copy_module_expr x1, copy_expression x2)\n | From.Parsetree.Pexp_letexception (x0, x1) ->\n To.Parsetree.Pexp_letexception\n (copy_extension_constructor x0, copy_expression x1)\n | From.Parsetree.Pexp_assert x0 ->\n To.Parsetree.Pexp_assert (copy_expression x0)\n | From.Parsetree.Pexp_lazy x0 -> To.Parsetree.Pexp_lazy (copy_expression x0)\n | From.Parsetree.Pexp_poly (x0, x1) ->\n To.Parsetree.Pexp_poly (copy_expression x0, copy_option copy_core_type x1)\n | From.Parsetree.Pexp_object x0 ->\n To.Parsetree.Pexp_object (copy_class_structure x0)\n | From.Parsetree.Pexp_newtype (x0, x1) ->\n To.Parsetree.Pexp_newtype (copy_loc (fun x -> x) x0, copy_expression x1)\n | From.Parsetree.Pexp_pack x0 -> To.Parsetree.Pexp_pack (copy_module_expr x0)\n | From.Parsetree.Pexp_open (x0, x1, x2) ->\n To.Parsetree.Pexp_open\n (copy_override_flag x0, copy_loc copy_longident x1, copy_expression x2)\n | From.Parsetree.Pexp_extension x0 ->\n To.Parsetree.Pexp_extension (copy_extension x0)\n | From.Parsetree.Pexp_unreachable -> To.Parsetree.Pexp_unreachable\n\nand copy_direction_flag :\n From.Asttypes.direction_flag -> To.Asttypes.direction_flag = function\n | From.Asttypes.Upto -> To.Asttypes.Upto\n | From.Asttypes.Downto -> To.Asttypes.Downto\n\nand copy_case : From.Parsetree.case -> To.Parsetree.case =\n fun { From.Parsetree.pc_lhs; From.Parsetree.pc_guard; From.Parsetree.pc_rhs } ->\n {\n To.Parsetree.pc_lhs = copy_pattern pc_lhs;\n To.Parsetree.pc_guard = copy_option copy_expression pc_guard;\n To.Parsetree.pc_rhs = copy_expression pc_rhs;\n }\n\nand copy_value_binding :\n From.Parsetree.value_binding -> To.Parsetree.value_binding =\n fun {\n From.Parsetree.pvb_pat;\n From.Parsetree.pvb_expr;\n From.Parsetree.pvb_attributes;\n From.Parsetree.pvb_loc;\n } ->\n {\n To.Parsetree.pvb_pat = copy_pattern pvb_pat;\n To.Parsetree.pvb_expr = copy_expression pvb_expr;\n To.Parsetree.pvb_attributes = copy_attributes pvb_attributes;\n To.Parsetree.pvb_loc = copy_location pvb_loc;\n }\n\nand copy_pattern : From.Parsetree.pattern -> To.Parsetree.pattern =\n fun {\n From.Parsetree.ppat_desc;\n From.Parsetree.ppat_loc;\n From.Parsetree.ppat_attributes;\n } ->\n {\n To.Parsetree.ppat_desc = copy_pattern_desc ppat_desc;\n To.Parsetree.ppat_loc = copy_location ppat_loc;\n To.Parsetree.ppat_attributes = copy_attributes ppat_attributes;\n }\n\nand copy_pattern_desc : From.Parsetree.pattern_desc -> To.Parsetree.pattern_desc\n = function\n | From.Parsetree.Ppat_any -> To.Parsetree.Ppat_any\n | From.Parsetree.Ppat_var x0 ->\n To.Parsetree.Ppat_var (copy_loc (fun x -> x) x0)\n | From.Parsetree.Ppat_alias (x0, x1) ->\n To.Parsetree.Ppat_alias (copy_pattern x0, copy_loc (fun x -> x) x1)\n | From.Parsetree.Ppat_constant x0 ->\n To.Parsetree.Ppat_constant (copy_constant x0)\n | From.Parsetree.Ppat_interval (x0, x1) ->\n To.Parsetree.Ppat_interval (copy_constant x0, copy_constant x1)\n | From.Parsetree.Ppat_tuple x0 ->\n To.Parsetree.Ppat_tuple (List.map copy_pattern x0)\n | From.Parsetree.Ppat_construct (x0, x1) ->\n To.Parsetree.Ppat_construct\n (copy_loc copy_longident x0, copy_option copy_pattern x1)\n | From.Parsetree.Ppat_variant (x0, x1) ->\n To.Parsetree.Ppat_variant (copy_label x0, copy_option copy_pattern x1)\n | From.Parsetree.Ppat_record (x0, x1) ->\n To.Parsetree.Ppat_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_pattern x1))\n x0,\n copy_closed_flag x1 )\n | From.Parsetree.Ppat_array x0 ->\n To.Parsetree.Ppat_array (List.map copy_pattern x0)\n | From.Parsetree.Ppat_or (x0, x1) ->\n To.Parsetree.Ppat_or (copy_pattern x0, copy_pattern x1)\n | From.Parsetree.Ppat_constraint (x0, x1) ->\n To.Parsetree.Ppat_constraint (copy_pattern x0, copy_core_type x1)\n | From.Parsetree.Ppat_type x0 ->\n To.Parsetree.Ppat_type (copy_loc copy_longident x0)\n | From.Parsetree.Ppat_lazy x0 -> To.Parsetree.Ppat_lazy (copy_pattern x0)\n | From.Parsetree.Ppat_unpack x0 ->\n To.Parsetree.Ppat_unpack (copy_loc (fun x -> x) x0)\n | From.Parsetree.Ppat_exception x0 ->\n To.Parsetree.Ppat_exception (copy_pattern x0)\n | From.Parsetree.Ppat_extension x0 ->\n To.Parsetree.Ppat_extension (copy_extension x0)\n | From.Parsetree.Ppat_open (x0, x1) ->\n To.Parsetree.Ppat_open (copy_loc copy_longident x0, copy_pattern x1)\n\nand copy_core_type : From.Parsetree.core_type -> To.Parsetree.core_type =\n fun {\n From.Parsetree.ptyp_desc;\n From.Parsetree.ptyp_loc;\n From.Parsetree.ptyp_attributes;\n } ->\n {\n To.Parsetree.ptyp_desc = copy_core_type_desc ptyp_desc;\n To.Parsetree.ptyp_loc = copy_location ptyp_loc;\n To.Parsetree.ptyp_attributes = copy_attributes ptyp_attributes;\n }\n\nand copy_core_type_desc :\n From.Parsetree.core_type_desc -> To.Parsetree.core_type_desc = function\n | From.Parsetree.Ptyp_any -> To.Parsetree.Ptyp_any\n | From.Parsetree.Ptyp_var x0 -> To.Parsetree.Ptyp_var x0\n | From.Parsetree.Ptyp_arrow (x0, x1, x2) ->\n To.Parsetree.Ptyp_arrow\n (copy_arg_label x0, copy_core_type x1, copy_core_type x2)\n | From.Parsetree.Ptyp_tuple x0 ->\n To.Parsetree.Ptyp_tuple (List.map copy_core_type x0)\n | From.Parsetree.Ptyp_constr (x0, x1) ->\n To.Parsetree.Ptyp_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Ptyp_object (x0, x1) ->\n To.Parsetree.Ptyp_object\n ( List.map\n (fun x ->\n let x0, x1, x2 = x in\n To.Parsetree.Otag\n (copy_loc (fun x -> x) x0, copy_attributes x1, copy_core_type x2))\n x0,\n copy_closed_flag x1 )\n | From.Parsetree.Ptyp_class (x0, x1) ->\n To.Parsetree.Ptyp_class\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Ptyp_alias (x0, x1) ->\n To.Parsetree.Ptyp_alias (copy_core_type x0, x1)\n | From.Parsetree.Ptyp_variant (x0, x1, x2) ->\n To.Parsetree.Ptyp_variant\n ( List.map copy_row_field x0,\n copy_closed_flag x1,\n copy_option (fun x -> List.map copy_label x) x2 )\n | From.Parsetree.Ptyp_poly (x0, x1) ->\n To.Parsetree.Ptyp_poly\n (List.map (fun x -> copy_loc (fun x -> x) x) x0, copy_core_type x1)\n | From.Parsetree.Ptyp_package x0 ->\n To.Parsetree.Ptyp_package (copy_package_type x0)\n | From.Parsetree.Ptyp_extension x0 ->\n To.Parsetree.Ptyp_extension (copy_extension x0)\n\nand copy_package_type : From.Parsetree.package_type -> To.Parsetree.package_type\n =\n fun x ->\n let x0, x1 = x in\n ( copy_loc copy_longident x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_core_type x1))\n x1 )\n\nand copy_row_field : From.Parsetree.row_field -> To.Parsetree.row_field =\n function\n | From.Parsetree.Rtag (x0, x1, x2, x3) ->\n To.Parsetree.Rtag\n ( { txt = copy_label x0; loc = Location.none },\n copy_attributes x1,\n copy_bool x2,\n List.map copy_core_type x3 )\n | From.Parsetree.Rinherit x0 -> To.Parsetree.Rinherit (copy_core_type x0)\n\nand copy_attributes : From.Parsetree.attributes -> To.Parsetree.attributes =\n fun x -> List.map copy_attribute x\n\nand copy_attribute : From.Parsetree.attribute -> To.Parsetree.attribute =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_payload : From.Parsetree.payload -> To.Parsetree.payload = function\n | From.Parsetree.PStr x0 -> To.Parsetree.PStr (copy_structure x0)\n | From.Parsetree.PSig x0 -> To.Parsetree.PSig (copy_signature x0)\n | From.Parsetree.PTyp x0 -> To.Parsetree.PTyp (copy_core_type x0)\n | From.Parsetree.PPat (x0, x1) ->\n To.Parsetree.PPat (copy_pattern x0, copy_option copy_expression x1)\n\nand copy_structure : From.Parsetree.structure -> To.Parsetree.structure =\n fun x -> List.map copy_structure_item x\n\nand copy_structure_item :\n From.Parsetree.structure_item -> To.Parsetree.structure_item =\n fun { From.Parsetree.pstr_desc; From.Parsetree.pstr_loc } ->\n {\n To.Parsetree.pstr_desc = copy_structure_item_desc pstr_desc;\n To.Parsetree.pstr_loc = copy_location pstr_loc;\n }\n\nand copy_structure_item_desc :\n From.Parsetree.structure_item_desc -> To.Parsetree.structure_item_desc =\n function\n | From.Parsetree.Pstr_eval (x0, x1) ->\n To.Parsetree.Pstr_eval (copy_expression x0, copy_attributes x1)\n | From.Parsetree.Pstr_value (x0, x1) ->\n To.Parsetree.Pstr_value (copy_rec_flag x0, List.map copy_value_binding x1)\n | From.Parsetree.Pstr_primitive x0 ->\n To.Parsetree.Pstr_primitive (copy_value_description x0)\n | From.Parsetree.Pstr_type (x0, x1) ->\n To.Parsetree.Pstr_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | From.Parsetree.Pstr_typext x0 ->\n To.Parsetree.Pstr_typext (copy_type_extension x0)\n | From.Parsetree.Pstr_exception x0 ->\n To.Parsetree.Pstr_exception (copy_extension_constructor x0)\n | From.Parsetree.Pstr_module x0 ->\n To.Parsetree.Pstr_module (copy_module_binding x0)\n | From.Parsetree.Pstr_recmodule x0 ->\n To.Parsetree.Pstr_recmodule (List.map copy_module_binding x0)\n | From.Parsetree.Pstr_modtype x0 ->\n To.Parsetree.Pstr_modtype (copy_module_type_declaration x0)\n | From.Parsetree.Pstr_open x0 ->\n To.Parsetree.Pstr_open (copy_open_description x0)\n | From.Parsetree.Pstr_class x0 ->\n To.Parsetree.Pstr_class (List.map copy_class_declaration x0)\n | From.Parsetree.Pstr_class_type x0 ->\n To.Parsetree.Pstr_class_type (List.map copy_class_type_declaration x0)\n | From.Parsetree.Pstr_include x0 ->\n To.Parsetree.Pstr_include (copy_include_declaration x0)\n | From.Parsetree.Pstr_attribute x0 ->\n To.Parsetree.Pstr_attribute (copy_attribute x0)\n | From.Parsetree.Pstr_extension (x0, x1) ->\n To.Parsetree.Pstr_extension (copy_extension x0, copy_attributes x1)\n\nand copy_include_declaration :\n From.Parsetree.include_declaration -> To.Parsetree.include_declaration =\n fun x -> copy_include_infos copy_module_expr x\n\nand copy_class_declaration :\n From.Parsetree.class_declaration -> To.Parsetree.class_declaration =\n fun x -> copy_class_infos copy_class_expr x\n\nand copy_class_expr : From.Parsetree.class_expr -> To.Parsetree.class_expr =\n fun {\n From.Parsetree.pcl_desc;\n From.Parsetree.pcl_loc;\n From.Parsetree.pcl_attributes;\n } ->\n {\n To.Parsetree.pcl_desc = copy_class_expr_desc pcl_desc;\n To.Parsetree.pcl_loc = copy_location pcl_loc;\n To.Parsetree.pcl_attributes = copy_attributes pcl_attributes;\n }\n\nand copy_class_expr_desc :\n From.Parsetree.class_expr_desc -> To.Parsetree.class_expr_desc = function\n | From.Parsetree.Pcl_constr (x0, x1) ->\n To.Parsetree.Pcl_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Pcl_structure x0 ->\n To.Parsetree.Pcl_structure (copy_class_structure x0)\n | From.Parsetree.Pcl_fun (x0, x1, x2, x3) ->\n To.Parsetree.Pcl_fun\n ( copy_arg_label x0,\n copy_option copy_expression x1,\n copy_pattern x2,\n copy_class_expr x3 )\n | From.Parsetree.Pcl_apply (x0, x1) ->\n To.Parsetree.Pcl_apply\n ( copy_class_expr x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | From.Parsetree.Pcl_let (x0, x1, x2) ->\n To.Parsetree.Pcl_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_class_expr x2)\n | From.Parsetree.Pcl_constraint (x0, x1) ->\n To.Parsetree.Pcl_constraint (copy_class_expr x0, copy_class_type x1)\n | From.Parsetree.Pcl_extension x0 ->\n To.Parsetree.Pcl_extension (copy_extension x0)\n\nand copy_class_structure :\n From.Parsetree.class_structure -> To.Parsetree.class_structure =\n fun { From.Parsetree.pcstr_self; From.Parsetree.pcstr_fields } ->\n {\n To.Parsetree.pcstr_self = copy_pattern pcstr_self;\n To.Parsetree.pcstr_fields = List.map copy_class_field pcstr_fields;\n }\n\nand copy_class_field : From.Parsetree.class_field -> To.Parsetree.class_field =\n fun {\n From.Parsetree.pcf_desc;\n From.Parsetree.pcf_loc;\n From.Parsetree.pcf_attributes;\n } ->\n {\n To.Parsetree.pcf_desc = copy_class_field_desc pcf_desc;\n To.Parsetree.pcf_loc = copy_location pcf_loc;\n To.Parsetree.pcf_attributes = copy_attributes pcf_attributes;\n }\n\nand copy_class_field_desc :\n From.Parsetree.class_field_desc -> To.Parsetree.class_field_desc = function\n | From.Parsetree.Pcf_inherit (x0, x1, x2) ->\n To.Parsetree.Pcf_inherit\n ( copy_override_flag x0,\n copy_class_expr x1,\n copy_option (copy_loc (fun x -> x)) x2 )\n | From.Parsetree.Pcf_val x0 ->\n To.Parsetree.Pcf_val\n (let x0, x1, x2 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_mutable_flag x1,\n copy_class_field_kind x2 ))\n | From.Parsetree.Pcf_method x0 ->\n To.Parsetree.Pcf_method\n (let x0, x1, x2 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_private_flag x1,\n copy_class_field_kind x2 ))\n | From.Parsetree.Pcf_constraint x0 ->\n To.Parsetree.Pcf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | From.Parsetree.Pcf_initializer x0 ->\n To.Parsetree.Pcf_initializer (copy_expression x0)\n | From.Parsetree.Pcf_attribute x0 ->\n To.Parsetree.Pcf_attribute (copy_attribute x0)\n | From.Parsetree.Pcf_extension x0 ->\n To.Parsetree.Pcf_extension (copy_extension x0)\n\nand copy_class_field_kind :\n From.Parsetree.class_field_kind -> To.Parsetree.class_field_kind = function\n | From.Parsetree.Cfk_virtual x0 ->\n To.Parsetree.Cfk_virtual (copy_core_type x0)\n | From.Parsetree.Cfk_concrete (x0, x1) ->\n To.Parsetree.Cfk_concrete (copy_override_flag x0, copy_expression x1)\n\nand copy_module_binding :\n From.Parsetree.module_binding -> To.Parsetree.module_binding =\n fun {\n From.Parsetree.pmb_name;\n From.Parsetree.pmb_expr;\n From.Parsetree.pmb_attributes;\n From.Parsetree.pmb_loc;\n } ->\n {\n To.Parsetree.pmb_name = copy_loc (fun x -> x) pmb_name;\n To.Parsetree.pmb_expr = copy_module_expr pmb_expr;\n To.Parsetree.pmb_attributes = copy_attributes pmb_attributes;\n To.Parsetree.pmb_loc = copy_location pmb_loc;\n }\n\nand copy_module_expr : From.Parsetree.module_expr -> To.Parsetree.module_expr =\n fun {\n From.Parsetree.pmod_desc;\n From.Parsetree.pmod_loc;\n From.Parsetree.pmod_attributes;\n } ->\n {\n To.Parsetree.pmod_desc = copy_module_expr_desc pmod_desc;\n To.Parsetree.pmod_loc = copy_location pmod_loc;\n To.Parsetree.pmod_attributes = copy_attributes pmod_attributes;\n }\n\nand copy_module_expr_desc :\n From.Parsetree.module_expr_desc -> To.Parsetree.module_expr_desc = function\n | From.Parsetree.Pmod_ident x0 ->\n To.Parsetree.Pmod_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pmod_structure x0 ->\n To.Parsetree.Pmod_structure (copy_structure x0)\n | From.Parsetree.Pmod_functor (x0, x1, x2) ->\n To.Parsetree.Pmod_functor\n ( copy_loc (fun x -> x) x0,\n copy_option copy_module_type x1,\n copy_module_expr x2 )\n | From.Parsetree.Pmod_apply (x0, x1) ->\n To.Parsetree.Pmod_apply (copy_module_expr x0, copy_module_expr x1)\n | From.Parsetree.Pmod_constraint (x0, x1) ->\n To.Parsetree.Pmod_constraint (copy_module_expr x0, copy_module_type x1)\n | From.Parsetree.Pmod_unpack x0 ->\n To.Parsetree.Pmod_unpack (copy_expression x0)\n | From.Parsetree.Pmod_extension x0 ->\n To.Parsetree.Pmod_extension (copy_extension x0)\n\nand copy_module_type : From.Parsetree.module_type -> To.Parsetree.module_type =\n fun {\n From.Parsetree.pmty_desc;\n From.Parsetree.pmty_loc;\n From.Parsetree.pmty_attributes;\n } ->\n {\n To.Parsetree.pmty_desc = copy_module_type_desc pmty_desc;\n To.Parsetree.pmty_loc = copy_location pmty_loc;\n To.Parsetree.pmty_attributes = copy_attributes pmty_attributes;\n }\n\nand copy_module_type_desc :\n From.Parsetree.module_type_desc -> To.Parsetree.module_type_desc = function\n | From.Parsetree.Pmty_ident x0 ->\n To.Parsetree.Pmty_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pmty_signature x0 ->\n To.Parsetree.Pmty_signature (copy_signature x0)\n | From.Parsetree.Pmty_functor (x0, x1, x2) ->\n To.Parsetree.Pmty_functor\n ( copy_loc (fun x -> x) x0,\n copy_option copy_module_type x1,\n copy_module_type x2 )\n | From.Parsetree.Pmty_with (x0, x1) ->\n To.Parsetree.Pmty_with\n (copy_module_type x0, List.map copy_with_constraint x1)\n | From.Parsetree.Pmty_typeof x0 ->\n To.Parsetree.Pmty_typeof (copy_module_expr x0)\n | From.Parsetree.Pmty_extension x0 ->\n To.Parsetree.Pmty_extension (copy_extension x0)\n | From.Parsetree.Pmty_alias x0 ->\n To.Parsetree.Pmty_alias (copy_loc copy_longident x0)\n\nand copy_with_constraint :\n From.Parsetree.with_constraint -> To.Parsetree.with_constraint = function\n | From.Parsetree.Pwith_type (x0, x1) ->\n To.Parsetree.Pwith_type\n (copy_loc copy_longident x0, copy_type_declaration x1)\n | From.Parsetree.Pwith_module (x0, x1) ->\n To.Parsetree.Pwith_module\n (copy_loc copy_longident x0, copy_loc copy_longident x1)\n | From.Parsetree.Pwith_typesubst x0 ->\n To.Parsetree.Pwith_typesubst\n ( copy_loc (fun x -> Longident.Lident x) x0.From.Parsetree.ptype_name,\n copy_type_declaration x0 )\n | From.Parsetree.Pwith_modsubst (x0, x1) ->\n To.Parsetree.Pwith_modsubst\n (copy_loc (fun x -> Longident.Lident x) x0, copy_loc copy_longident x1)\n\nand copy_signature : From.Parsetree.signature -> To.Parsetree.signature =\n fun x -> List.map copy_signature_item x\n\nand copy_signature_item :\n From.Parsetree.signature_item -> To.Parsetree.signature_item =\n fun { From.Parsetree.psig_desc; From.Parsetree.psig_loc } ->\n {\n To.Parsetree.psig_desc = copy_signature_item_desc psig_desc;\n To.Parsetree.psig_loc = copy_location psig_loc;\n }\n\nand copy_signature_item_desc :\n From.Parsetree.signature_item_desc -> To.Parsetree.signature_item_desc =\n function\n | From.Parsetree.Psig_value x0 ->\n To.Parsetree.Psig_value (copy_value_description x0)\n | From.Parsetree.Psig_type (x0, x1) ->\n To.Parsetree.Psig_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | From.Parsetree.Psig_typext x0 ->\n To.Parsetree.Psig_typext (copy_type_extension x0)\n | From.Parsetree.Psig_exception x0 ->\n To.Parsetree.Psig_exception (copy_extension_constructor x0)\n | From.Parsetree.Psig_module x0 ->\n To.Parsetree.Psig_module (copy_module_declaration x0)\n | From.Parsetree.Psig_recmodule x0 ->\n To.Parsetree.Psig_recmodule (List.map copy_module_declaration x0)\n | From.Parsetree.Psig_modtype x0 ->\n To.Parsetree.Psig_modtype (copy_module_type_declaration x0)\n | From.Parsetree.Psig_open x0 ->\n To.Parsetree.Psig_open (copy_open_description x0)\n | From.Parsetree.Psig_include x0 ->\n To.Parsetree.Psig_include (copy_include_description x0)\n | From.Parsetree.Psig_class x0 ->\n To.Parsetree.Psig_class (List.map copy_class_description x0)\n | From.Parsetree.Psig_class_type x0 ->\n To.Parsetree.Psig_class_type (List.map copy_class_type_declaration x0)\n | From.Parsetree.Psig_attribute x0 ->\n To.Parsetree.Psig_attribute (copy_attribute x0)\n | From.Parsetree.Psig_extension (x0, x1) ->\n To.Parsetree.Psig_extension (copy_extension x0, copy_attributes x1)\n\nand copy_class_type_declaration :\n From.Parsetree.class_type_declaration -> To.Parsetree.class_type_declaration\n =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_description :\n From.Parsetree.class_description -> To.Parsetree.class_description =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_type : From.Parsetree.class_type -> To.Parsetree.class_type =\n fun {\n From.Parsetree.pcty_desc;\n From.Parsetree.pcty_loc;\n From.Parsetree.pcty_attributes;\n } ->\n {\n To.Parsetree.pcty_desc = copy_class_type_desc pcty_desc;\n To.Parsetree.pcty_loc = copy_location pcty_loc;\n To.Parsetree.pcty_attributes = copy_attributes pcty_attributes;\n }\n\nand copy_class_type_desc :\n From.Parsetree.class_type_desc -> To.Parsetree.class_type_desc = function\n | From.Parsetree.Pcty_constr (x0, x1) ->\n To.Parsetree.Pcty_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Pcty_signature x0 ->\n To.Parsetree.Pcty_signature (copy_class_signature x0)\n | From.Parsetree.Pcty_arrow (x0, x1, x2) ->\n To.Parsetree.Pcty_arrow\n (copy_arg_label x0, copy_core_type x1, copy_class_type x2)\n | From.Parsetree.Pcty_extension x0 ->\n To.Parsetree.Pcty_extension (copy_extension x0)\n\nand copy_class_signature :\n From.Parsetree.class_signature -> To.Parsetree.class_signature =\n fun { From.Parsetree.pcsig_self; From.Parsetree.pcsig_fields } ->\n {\n To.Parsetree.pcsig_self = copy_core_type pcsig_self;\n To.Parsetree.pcsig_fields = List.map copy_class_type_field pcsig_fields;\n }\n\nand copy_class_type_field :\n From.Parsetree.class_type_field -> To.Parsetree.class_type_field =\n fun {\n From.Parsetree.pctf_desc;\n From.Parsetree.pctf_loc;\n From.Parsetree.pctf_attributes;\n } ->\n {\n To.Parsetree.pctf_desc = copy_class_type_field_desc pctf_desc;\n To.Parsetree.pctf_loc = copy_location pctf_loc;\n To.Parsetree.pctf_attributes = copy_attributes pctf_attributes;\n }\n\nand copy_class_type_field_desc :\n From.Parsetree.class_type_field_desc -> To.Parsetree.class_type_field_desc =\n function\n | From.Parsetree.Pctf_inherit x0 ->\n To.Parsetree.Pctf_inherit (copy_class_type x0)\n | From.Parsetree.Pctf_val x0 ->\n To.Parsetree.Pctf_val\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_mutable_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | From.Parsetree.Pctf_method x0 ->\n To.Parsetree.Pctf_method\n (let x0, x1, x2, x3 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_private_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | From.Parsetree.Pctf_constraint x0 ->\n To.Parsetree.Pctf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | From.Parsetree.Pctf_attribute x0 ->\n To.Parsetree.Pctf_attribute (copy_attribute x0)\n | From.Parsetree.Pctf_extension x0 ->\n To.Parsetree.Pctf_extension (copy_extension x0)\n\nand copy_extension : From.Parsetree.extension -> To.Parsetree.extension =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_class_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 From.Parsetree.class_infos ->\n 'g0 To.Parsetree.class_infos =\n fun f0\n {\n From.Parsetree.pci_virt;\n From.Parsetree.pci_params;\n From.Parsetree.pci_name;\n From.Parsetree.pci_expr;\n From.Parsetree.pci_loc;\n From.Parsetree.pci_attributes;\n } ->\n {\n To.Parsetree.pci_virt = copy_virtual_flag pci_virt;\n To.Parsetree.pci_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n pci_params;\n To.Parsetree.pci_name = copy_loc (fun x -> x) pci_name;\n To.Parsetree.pci_expr = f0 pci_expr;\n To.Parsetree.pci_loc = copy_location pci_loc;\n To.Parsetree.pci_attributes = copy_attributes pci_attributes;\n }\n\nand copy_virtual_flag : From.Asttypes.virtual_flag -> To.Asttypes.virtual_flag =\n function\n | From.Asttypes.Virtual -> To.Asttypes.Virtual\n | From.Asttypes.Concrete -> To.Asttypes.Concrete\n\nand copy_include_description :\n From.Parsetree.include_description -> To.Parsetree.include_description =\n fun x -> copy_include_infos copy_module_type x\n\nand copy_include_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 From.Parsetree.include_infos ->\n 'g0 To.Parsetree.include_infos =\n fun f0\n {\n From.Parsetree.pincl_mod;\n From.Parsetree.pincl_loc;\n From.Parsetree.pincl_attributes;\n } ->\n {\n To.Parsetree.pincl_mod = f0 pincl_mod;\n To.Parsetree.pincl_loc = copy_location pincl_loc;\n To.Parsetree.pincl_attributes = copy_attributes pincl_attributes;\n }\n\nand copy_open_description :\n From.Parsetree.open_description -> To.Parsetree.open_description =\n fun {\n From.Parsetree.popen_lid;\n From.Parsetree.popen_override;\n From.Parsetree.popen_loc;\n From.Parsetree.popen_attributes;\n } ->\n {\n To.Parsetree.popen_lid = copy_loc copy_longident popen_lid;\n To.Parsetree.popen_override = copy_override_flag popen_override;\n To.Parsetree.popen_loc = copy_location popen_loc;\n To.Parsetree.popen_attributes = copy_attributes popen_attributes;\n }\n\nand copy_override_flag :\n From.Asttypes.override_flag -> To.Asttypes.override_flag = function\n | From.Asttypes.Override -> To.Asttypes.Override\n | From.Asttypes.Fresh -> To.Asttypes.Fresh\n\nand copy_module_type_declaration :\n From.Parsetree.module_type_declaration ->\n To.Parsetree.module_type_declaration =\n fun {\n From.Parsetree.pmtd_name;\n From.Parsetree.pmtd_type;\n From.Parsetree.pmtd_attributes;\n From.Parsetree.pmtd_loc;\n } ->\n {\n To.Parsetree.pmtd_name = copy_loc (fun x -> x) pmtd_name;\n To.Parsetree.pmtd_type = copy_option copy_module_type pmtd_type;\n To.Parsetree.pmtd_attributes = copy_attributes pmtd_attributes;\n To.Parsetree.pmtd_loc = copy_location pmtd_loc;\n }\n\nand copy_module_declaration :\n From.Parsetree.module_declaration -> To.Parsetree.module_declaration =\n fun {\n From.Parsetree.pmd_name;\n From.Parsetree.pmd_type;\n From.Parsetree.pmd_attributes;\n From.Parsetree.pmd_loc;\n } ->\n {\n To.Parsetree.pmd_name = copy_loc (fun x -> x) pmd_name;\n To.Parsetree.pmd_type = copy_module_type pmd_type;\n To.Parsetree.pmd_attributes = copy_attributes pmd_attributes;\n To.Parsetree.pmd_loc = copy_location pmd_loc;\n }\n\nand copy_type_extension :\n From.Parsetree.type_extension -> To.Parsetree.type_extension =\n fun {\n From.Parsetree.ptyext_path;\n From.Parsetree.ptyext_params;\n From.Parsetree.ptyext_constructors;\n From.Parsetree.ptyext_private;\n From.Parsetree.ptyext_attributes;\n } ->\n {\n To.Parsetree.ptyext_path = copy_loc copy_longident ptyext_path;\n To.Parsetree.ptyext_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptyext_params;\n To.Parsetree.ptyext_constructors =\n List.map copy_extension_constructor ptyext_constructors;\n To.Parsetree.ptyext_private = copy_private_flag ptyext_private;\n To.Parsetree.ptyext_attributes = copy_attributes ptyext_attributes;\n }\n\nand copy_extension_constructor :\n From.Parsetree.extension_constructor -> To.Parsetree.extension_constructor =\n fun {\n From.Parsetree.pext_name;\n From.Parsetree.pext_kind;\n From.Parsetree.pext_loc;\n From.Parsetree.pext_attributes;\n } ->\n {\n To.Parsetree.pext_name = copy_loc (fun x -> x) pext_name;\n To.Parsetree.pext_kind = copy_extension_constructor_kind pext_kind;\n To.Parsetree.pext_loc = copy_location pext_loc;\n To.Parsetree.pext_attributes = copy_attributes pext_attributes;\n }\n\nand copy_extension_constructor_kind :\n From.Parsetree.extension_constructor_kind ->\n To.Parsetree.extension_constructor_kind = function\n | From.Parsetree.Pext_decl (x0, x1) ->\n To.Parsetree.Pext_decl\n (copy_constructor_arguments x0, copy_option copy_core_type x1)\n | From.Parsetree.Pext_rebind x0 ->\n To.Parsetree.Pext_rebind (copy_loc copy_longident x0)\n\nand copy_type_declaration :\n From.Parsetree.type_declaration -> To.Parsetree.type_declaration =\n fun {\n From.Parsetree.ptype_name;\n From.Parsetree.ptype_params;\n From.Parsetree.ptype_cstrs;\n From.Parsetree.ptype_kind;\n From.Parsetree.ptype_private;\n From.Parsetree.ptype_manifest;\n From.Parsetree.ptype_attributes;\n From.Parsetree.ptype_loc;\n } ->\n {\n To.Parsetree.ptype_name = copy_loc (fun x -> x) ptype_name;\n To.Parsetree.ptype_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptype_params;\n To.Parsetree.ptype_cstrs =\n List.map\n (fun x ->\n let x0, x1, x2 = x in\n (copy_core_type x0, copy_core_type x1, copy_location x2))\n ptype_cstrs;\n To.Parsetree.ptype_kind = copy_type_kind ptype_kind;\n To.Parsetree.ptype_private = copy_private_flag ptype_private;\n To.Parsetree.ptype_manifest = copy_option copy_core_type ptype_manifest;\n To.Parsetree.ptype_attributes = copy_attributes ptype_attributes;\n To.Parsetree.ptype_loc = copy_location ptype_loc;\n }\n\nand copy_private_flag : From.Asttypes.private_flag -> To.Asttypes.private_flag =\n function\n | From.Asttypes.Private -> To.Asttypes.Private\n | From.Asttypes.Public -> To.Asttypes.Public\n\nand copy_type_kind : From.Parsetree.type_kind -> To.Parsetree.type_kind =\n function\n | From.Parsetree.Ptype_abstract -> To.Parsetree.Ptype_abstract\n | From.Parsetree.Ptype_variant x0 ->\n To.Parsetree.Ptype_variant (List.map copy_constructor_declaration x0)\n | From.Parsetree.Ptype_record x0 ->\n To.Parsetree.Ptype_record (List.map copy_label_declaration x0)\n | From.Parsetree.Ptype_open -> To.Parsetree.Ptype_open\n\nand copy_constructor_declaration :\n From.Parsetree.constructor_declaration ->\n To.Parsetree.constructor_declaration =\n fun {\n From.Parsetree.pcd_name;\n From.Parsetree.pcd_args;\n From.Parsetree.pcd_res;\n From.Parsetree.pcd_loc;\n From.Parsetree.pcd_attributes;\n } ->\n {\n To.Parsetree.pcd_name = copy_loc (fun x -> x) pcd_name;\n To.Parsetree.pcd_args = copy_constructor_arguments pcd_args;\n To.Parsetree.pcd_res = copy_option copy_core_type pcd_res;\n To.Parsetree.pcd_loc = copy_location pcd_loc;\n To.Parsetree.pcd_attributes = copy_attributes pcd_attributes;\n }\n\nand copy_constructor_arguments :\n From.Parsetree.constructor_arguments -> To.Parsetree.constructor_arguments =\n function\n | From.Parsetree.Pcstr_tuple x0 ->\n To.Parsetree.Pcstr_tuple (List.map copy_core_type x0)\n | From.Parsetree.Pcstr_record x0 ->\n To.Parsetree.Pcstr_record (List.map copy_label_declaration x0)\n\nand copy_label_declaration :\n From.Parsetree.label_declaration -> To.Parsetree.label_declaration =\n fun {\n From.Parsetree.pld_name;\n From.Parsetree.pld_mutable;\n From.Parsetree.pld_type;\n From.Parsetree.pld_loc;\n From.Parsetree.pld_attributes;\n } ->\n {\n To.Parsetree.pld_name = copy_loc (fun x -> x) pld_name;\n To.Parsetree.pld_mutable = copy_mutable_flag pld_mutable;\n To.Parsetree.pld_type = copy_core_type pld_type;\n To.Parsetree.pld_loc = copy_location pld_loc;\n To.Parsetree.pld_attributes = copy_attributes pld_attributes;\n }\n\nand copy_mutable_flag : From.Asttypes.mutable_flag -> To.Asttypes.mutable_flag =\n function\n | From.Asttypes.Immutable -> To.Asttypes.Immutable\n | From.Asttypes.Mutable -> To.Asttypes.Mutable\n\nand copy_variance : From.Asttypes.variance -> To.Asttypes.variance = function\n | From.Asttypes.Covariant -> To.Asttypes.Covariant\n | From.Asttypes.Contravariant -> To.Asttypes.Contravariant\n | From.Asttypes.Invariant -> To.Asttypes.Invariant\n\nand copy_value_description :\n From.Parsetree.value_description -> To.Parsetree.value_description =\n fun {\n From.Parsetree.pval_name;\n From.Parsetree.pval_type;\n From.Parsetree.pval_prim;\n From.Parsetree.pval_attributes;\n From.Parsetree.pval_loc;\n } ->\n {\n To.Parsetree.pval_name = copy_loc (fun x -> x) pval_name;\n To.Parsetree.pval_type = copy_core_type pval_type;\n To.Parsetree.pval_prim = List.map (fun x -> x) pval_prim;\n To.Parsetree.pval_attributes = copy_attributes pval_attributes;\n To.Parsetree.pval_loc = copy_location pval_loc;\n }\n\nand copy_arg_label : From.Asttypes.arg_label -> To.Asttypes.arg_label = function\n | From.Asttypes.Nolabel -> To.Asttypes.Nolabel\n | From.Asttypes.Labelled x0 -> To.Asttypes.Labelled x0\n | From.Asttypes.Optional x0 -> To.Asttypes.Optional x0\n\nand copy_closed_flag : From.Asttypes.closed_flag -> To.Asttypes.closed_flag =\n function\n | From.Asttypes.Closed -> To.Asttypes.Closed\n | From.Asttypes.Open -> To.Asttypes.Open\n\nand copy_label : From.Asttypes.label -> To.Asttypes.label = fun x -> x\n\nand copy_rec_flag : From.Asttypes.rec_flag -> To.Asttypes.rec_flag = function\n | From.Asttypes.Nonrecursive -> To.Asttypes.Nonrecursive\n | From.Asttypes.Recursive -> To.Asttypes.Recursive\n\nand copy_constant : From.Parsetree.constant -> To.Parsetree.constant = function\n | From.Parsetree.Pconst_integer (x0, x1) ->\n To.Parsetree.Pconst_integer (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pconst_char x0 -> To.Parsetree.Pconst_char x0\n | From.Parsetree.Pconst_string (x0, x1) ->\n To.Parsetree.Pconst_string (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pconst_float (x0, x1) ->\n To.Parsetree.Pconst_float (x0, copy_option (fun x -> x) x1)\n\nand copy_option : 'f0 'g0. ('f0 -> 'g0) -> 'f0 option -> 'g0 option =\n fun f0 -> function None -> None | Some x0 -> Some (f0 x0)\n\nand copy_longident : Longident.t -> Longident.t = fun x -> x\n\nand copy_loc :\n 'f0 'g0. ('f0 -> 'g0) -> 'f0 From.Asttypes.loc -> 'g0 To.Asttypes.loc =\n fun f0 { From.Asttypes.txt; From.Asttypes.loc } ->\n { To.Asttypes.txt = f0 txt; To.Asttypes.loc = copy_location loc }\n\nand copy_location : Location.t -> Location.t = fun x -> x\nand copy_bool : bool -> bool = function false -> false | true -> true\n\nlet rec copy_toplevel_phrase :\n From.Parsetree.toplevel_phrase -> To.Parsetree.toplevel_phrase = function\n | From.Parsetree.Ptop_def x0 -> To.Parsetree.Ptop_def (copy_structure x0)\n | From.Parsetree.Ptop_dir (x0, x1) ->\n To.Parsetree.Ptop_dir (x0, copy_directive_argument x1)\n\nand copy_directive_argument :\n From.Parsetree.directive_argument -> To.Parsetree.directive_argument =\n function\n | From.Parsetree.Pdir_none -> To.Parsetree.Pdir_none\n | From.Parsetree.Pdir_string x0 -> To.Parsetree.Pdir_string x0\n | From.Parsetree.Pdir_int (x0, x1) ->\n To.Parsetree.Pdir_int (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pdir_ident x0 -> To.Parsetree.Pdir_ident (copy_longident x0)\n | From.Parsetree.Pdir_bool x0 -> To.Parsetree.Pdir_bool (copy_bool x0)\n\nlet copy_cases x = List.map copy_case x\nlet copy_pat = copy_pattern\nlet copy_expr = copy_expression\nlet copy_typ = copy_core_type\n","(**************************************************************************)\n(* *)\n(* OCaml Migrate Parsetree *)\n(* *)\n(* Frédéric Bour *)\n(* Alain Frisch, LexiFi *)\n(* *)\n(* Copyright 2017 Institut National de Recherche en Informatique et *)\n(* en Automatique (INRIA). *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nmodule From = Ast_405\nmodule To = Ast_404\n\nlet rec copy_expression : From.Parsetree.expression -> To.Parsetree.expression =\n fun {\n From.Parsetree.pexp_desc;\n From.Parsetree.pexp_loc;\n From.Parsetree.pexp_attributes;\n } ->\n {\n To.Parsetree.pexp_desc = copy_expression_desc pexp_desc;\n To.Parsetree.pexp_loc = copy_location pexp_loc;\n To.Parsetree.pexp_attributes = copy_attributes pexp_attributes;\n }\n\nand copy_expression_desc :\n From.Parsetree.expression_desc -> To.Parsetree.expression_desc = function\n | From.Parsetree.Pexp_ident x0 ->\n To.Parsetree.Pexp_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pexp_constant x0 ->\n To.Parsetree.Pexp_constant (copy_constant x0)\n | From.Parsetree.Pexp_let (x0, x1, x2) ->\n To.Parsetree.Pexp_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_expression x2)\n | From.Parsetree.Pexp_function x0 ->\n To.Parsetree.Pexp_function (List.map copy_case x0)\n | From.Parsetree.Pexp_fun (x0, x1, x2, x3) ->\n To.Parsetree.Pexp_fun\n ( copy_arg_label x0,\n copy_option copy_expression x1,\n copy_pattern x2,\n copy_expression x3 )\n | From.Parsetree.Pexp_apply (x0, x1) ->\n To.Parsetree.Pexp_apply\n ( copy_expression x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | From.Parsetree.Pexp_match (x0, x1) ->\n To.Parsetree.Pexp_match (copy_expression x0, List.map copy_case x1)\n | From.Parsetree.Pexp_try (x0, x1) ->\n To.Parsetree.Pexp_try (copy_expression x0, List.map copy_case x1)\n | From.Parsetree.Pexp_tuple x0 ->\n To.Parsetree.Pexp_tuple (List.map copy_expression x0)\n | From.Parsetree.Pexp_construct (x0, x1) ->\n To.Parsetree.Pexp_construct\n (copy_loc copy_longident x0, copy_option copy_expression x1)\n | From.Parsetree.Pexp_variant (x0, x1) ->\n To.Parsetree.Pexp_variant (copy_label x0, copy_option copy_expression x1)\n | From.Parsetree.Pexp_record (x0, x1) ->\n To.Parsetree.Pexp_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_expression x1))\n x0,\n copy_option copy_expression x1 )\n | From.Parsetree.Pexp_field (x0, x1) ->\n To.Parsetree.Pexp_field (copy_expression x0, copy_loc copy_longident x1)\n | From.Parsetree.Pexp_setfield (x0, x1, x2) ->\n To.Parsetree.Pexp_setfield\n (copy_expression x0, copy_loc copy_longident x1, copy_expression x2)\n | From.Parsetree.Pexp_array x0 ->\n To.Parsetree.Pexp_array (List.map copy_expression x0)\n | From.Parsetree.Pexp_ifthenelse (x0, x1, x2) ->\n To.Parsetree.Pexp_ifthenelse\n (copy_expression x0, copy_expression x1, copy_option copy_expression x2)\n | From.Parsetree.Pexp_sequence (x0, x1) ->\n To.Parsetree.Pexp_sequence (copy_expression x0, copy_expression x1)\n | From.Parsetree.Pexp_while (x0, x1) ->\n To.Parsetree.Pexp_while (copy_expression x0, copy_expression x1)\n | From.Parsetree.Pexp_for (x0, x1, x2, x3, x4) ->\n To.Parsetree.Pexp_for\n ( copy_pattern x0,\n copy_expression x1,\n copy_expression x2,\n copy_direction_flag x3,\n copy_expression x4 )\n | From.Parsetree.Pexp_constraint (x0, x1) ->\n To.Parsetree.Pexp_constraint (copy_expression x0, copy_core_type x1)\n | From.Parsetree.Pexp_coerce (x0, x1, x2) ->\n To.Parsetree.Pexp_coerce\n (copy_expression x0, copy_option copy_core_type x1, copy_core_type x2)\n | From.Parsetree.Pexp_send (x0, x1) ->\n To.Parsetree.Pexp_send (copy_expression x0, x1.From.Asttypes.txt)\n | From.Parsetree.Pexp_new x0 ->\n To.Parsetree.Pexp_new (copy_loc copy_longident x0)\n | From.Parsetree.Pexp_setinstvar (x0, x1) ->\n To.Parsetree.Pexp_setinstvar (copy_loc (fun x -> x) x0, copy_expression x1)\n | From.Parsetree.Pexp_override x0 ->\n To.Parsetree.Pexp_override\n (List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_expression x1))\n x0)\n | From.Parsetree.Pexp_letmodule (x0, x1, x2) ->\n To.Parsetree.Pexp_letmodule\n (copy_loc (fun x -> x) x0, copy_module_expr x1, copy_expression x2)\n | From.Parsetree.Pexp_letexception (x0, x1) ->\n To.Parsetree.Pexp_letexception\n (copy_extension_constructor x0, copy_expression x1)\n | From.Parsetree.Pexp_assert x0 ->\n To.Parsetree.Pexp_assert (copy_expression x0)\n | From.Parsetree.Pexp_lazy x0 -> To.Parsetree.Pexp_lazy (copy_expression x0)\n | From.Parsetree.Pexp_poly (x0, x1) ->\n To.Parsetree.Pexp_poly (copy_expression x0, copy_option copy_core_type x1)\n | From.Parsetree.Pexp_object x0 ->\n To.Parsetree.Pexp_object (copy_class_structure x0)\n | From.Parsetree.Pexp_newtype (x0, x1) ->\n To.Parsetree.Pexp_newtype (x0.From.Asttypes.txt, copy_expression x1)\n | From.Parsetree.Pexp_pack x0 -> To.Parsetree.Pexp_pack (copy_module_expr x0)\n | From.Parsetree.Pexp_open (x0, x1, x2) ->\n To.Parsetree.Pexp_open\n (copy_override_flag x0, copy_loc copy_longident x1, copy_expression x2)\n | From.Parsetree.Pexp_extension x0 ->\n To.Parsetree.Pexp_extension (copy_extension x0)\n | From.Parsetree.Pexp_unreachable -> To.Parsetree.Pexp_unreachable\n\nand copy_direction_flag :\n From.Asttypes.direction_flag -> To.Asttypes.direction_flag = function\n | From.Asttypes.Upto -> To.Asttypes.Upto\n | From.Asttypes.Downto -> To.Asttypes.Downto\n\nand copy_case : From.Parsetree.case -> To.Parsetree.case =\n fun { From.Parsetree.pc_lhs; From.Parsetree.pc_guard; From.Parsetree.pc_rhs } ->\n {\n To.Parsetree.pc_lhs = copy_pattern pc_lhs;\n To.Parsetree.pc_guard = copy_option copy_expression pc_guard;\n To.Parsetree.pc_rhs = copy_expression pc_rhs;\n }\n\nand copy_value_binding :\n From.Parsetree.value_binding -> To.Parsetree.value_binding =\n fun {\n From.Parsetree.pvb_pat;\n From.Parsetree.pvb_expr;\n From.Parsetree.pvb_attributes;\n From.Parsetree.pvb_loc;\n } ->\n {\n To.Parsetree.pvb_pat = copy_pattern pvb_pat;\n To.Parsetree.pvb_expr = copy_expression pvb_expr;\n To.Parsetree.pvb_attributes = copy_attributes pvb_attributes;\n To.Parsetree.pvb_loc = copy_location pvb_loc;\n }\n\nand copy_pattern : From.Parsetree.pattern -> To.Parsetree.pattern =\n fun {\n From.Parsetree.ppat_desc;\n From.Parsetree.ppat_loc;\n From.Parsetree.ppat_attributes;\n } ->\n {\n To.Parsetree.ppat_desc = copy_pattern_desc ppat_desc;\n To.Parsetree.ppat_loc = copy_location ppat_loc;\n To.Parsetree.ppat_attributes = copy_attributes ppat_attributes;\n }\n\nand copy_pattern_desc : From.Parsetree.pattern_desc -> To.Parsetree.pattern_desc\n = function\n | From.Parsetree.Ppat_any -> To.Parsetree.Ppat_any\n | From.Parsetree.Ppat_var x0 ->\n To.Parsetree.Ppat_var (copy_loc (fun x -> x) x0)\n | From.Parsetree.Ppat_alias (x0, x1) ->\n To.Parsetree.Ppat_alias (copy_pattern x0, copy_loc (fun x -> x) x1)\n | From.Parsetree.Ppat_constant x0 ->\n To.Parsetree.Ppat_constant (copy_constant x0)\n | From.Parsetree.Ppat_interval (x0, x1) ->\n To.Parsetree.Ppat_interval (copy_constant x0, copy_constant x1)\n | From.Parsetree.Ppat_tuple x0 ->\n To.Parsetree.Ppat_tuple (List.map copy_pattern x0)\n | From.Parsetree.Ppat_construct (x0, x1) ->\n To.Parsetree.Ppat_construct\n (copy_loc copy_longident x0, copy_option copy_pattern x1)\n | From.Parsetree.Ppat_variant (x0, x1) ->\n To.Parsetree.Ppat_variant (copy_label x0, copy_option copy_pattern x1)\n | From.Parsetree.Ppat_record (x0, x1) ->\n To.Parsetree.Ppat_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_pattern x1))\n x0,\n copy_closed_flag x1 )\n | From.Parsetree.Ppat_array x0 ->\n To.Parsetree.Ppat_array (List.map copy_pattern x0)\n | From.Parsetree.Ppat_or (x0, x1) ->\n To.Parsetree.Ppat_or (copy_pattern x0, copy_pattern x1)\n | From.Parsetree.Ppat_constraint (x0, x1) ->\n To.Parsetree.Ppat_constraint (copy_pattern x0, copy_core_type x1)\n | From.Parsetree.Ppat_type x0 ->\n To.Parsetree.Ppat_type (copy_loc copy_longident x0)\n | From.Parsetree.Ppat_lazy x0 -> To.Parsetree.Ppat_lazy (copy_pattern x0)\n | From.Parsetree.Ppat_unpack x0 ->\n To.Parsetree.Ppat_unpack (copy_loc (fun x -> x) x0)\n | From.Parsetree.Ppat_exception x0 ->\n To.Parsetree.Ppat_exception (copy_pattern x0)\n | From.Parsetree.Ppat_extension x0 ->\n To.Parsetree.Ppat_extension (copy_extension x0)\n | From.Parsetree.Ppat_open (x0, x1) ->\n To.Parsetree.Ppat_open (copy_loc copy_longident x0, copy_pattern x1)\n\nand copy_core_type : From.Parsetree.core_type -> To.Parsetree.core_type =\n fun {\n From.Parsetree.ptyp_desc;\n From.Parsetree.ptyp_loc;\n From.Parsetree.ptyp_attributes;\n } ->\n {\n To.Parsetree.ptyp_desc = copy_core_type_desc ptyp_desc;\n To.Parsetree.ptyp_loc = copy_location ptyp_loc;\n To.Parsetree.ptyp_attributes = copy_attributes ptyp_attributes;\n }\n\nand copy_core_type_desc :\n From.Parsetree.core_type_desc -> To.Parsetree.core_type_desc = function\n | From.Parsetree.Ptyp_any -> To.Parsetree.Ptyp_any\n | From.Parsetree.Ptyp_var x0 -> To.Parsetree.Ptyp_var x0\n | From.Parsetree.Ptyp_arrow (x0, x1, x2) ->\n To.Parsetree.Ptyp_arrow\n (copy_arg_label x0, copy_core_type x1, copy_core_type x2)\n | From.Parsetree.Ptyp_tuple x0 ->\n To.Parsetree.Ptyp_tuple (List.map copy_core_type x0)\n | From.Parsetree.Ptyp_constr (x0, x1) ->\n To.Parsetree.Ptyp_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Ptyp_object (x0, x1) ->\n To.Parsetree.Ptyp_object\n ( List.map\n (fun x ->\n let x0, x1, x2 = x in\n (x0.From.Asttypes.txt, copy_attributes x1, copy_core_type x2))\n x0,\n copy_closed_flag x1 )\n | From.Parsetree.Ptyp_class (x0, x1) ->\n To.Parsetree.Ptyp_class\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Ptyp_alias (x0, x1) ->\n To.Parsetree.Ptyp_alias (copy_core_type x0, x1)\n | From.Parsetree.Ptyp_variant (x0, x1, x2) ->\n To.Parsetree.Ptyp_variant\n ( List.map copy_row_field x0,\n copy_closed_flag x1,\n copy_option (fun x -> List.map copy_label x) x2 )\n | From.Parsetree.Ptyp_poly (x0, x1) ->\n To.Parsetree.Ptyp_poly\n (List.map (fun x -> x.From.Asttypes.txt) x0, copy_core_type x1)\n | From.Parsetree.Ptyp_package x0 ->\n To.Parsetree.Ptyp_package (copy_package_type x0)\n | From.Parsetree.Ptyp_extension x0 ->\n To.Parsetree.Ptyp_extension (copy_extension x0)\n\nand copy_package_type : From.Parsetree.package_type -> To.Parsetree.package_type\n =\n fun x ->\n let x0, x1 = x in\n ( copy_loc copy_longident x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_core_type x1))\n x1 )\n\nand copy_row_field : From.Parsetree.row_field -> To.Parsetree.row_field =\n function\n | From.Parsetree.Rtag (x0, x1, x2, x3) ->\n To.Parsetree.Rtag\n ( copy_label x0,\n copy_attributes x1,\n copy_bool x2,\n List.map copy_core_type x3 )\n | From.Parsetree.Rinherit x0 -> To.Parsetree.Rinherit (copy_core_type x0)\n\nand copy_attributes : From.Parsetree.attributes -> To.Parsetree.attributes =\n fun x -> List.map copy_attribute x\n\nand copy_attribute : From.Parsetree.attribute -> To.Parsetree.attribute =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_payload : From.Parsetree.payload -> To.Parsetree.payload = function\n | From.Parsetree.PStr x0 -> To.Parsetree.PStr (copy_structure x0)\n | From.Parsetree.PSig x0 -> To.Parsetree.PSig (copy_signature x0)\n | From.Parsetree.PTyp x0 -> To.Parsetree.PTyp (copy_core_type x0)\n | From.Parsetree.PPat (x0, x1) ->\n To.Parsetree.PPat (copy_pattern x0, copy_option copy_expression x1)\n\nand copy_structure : From.Parsetree.structure -> To.Parsetree.structure =\n fun x -> List.map copy_structure_item x\n\nand copy_structure_item :\n From.Parsetree.structure_item -> To.Parsetree.structure_item =\n fun { From.Parsetree.pstr_desc; From.Parsetree.pstr_loc } ->\n {\n To.Parsetree.pstr_desc = copy_structure_item_desc pstr_desc;\n To.Parsetree.pstr_loc = copy_location pstr_loc;\n }\n\nand copy_structure_item_desc :\n From.Parsetree.structure_item_desc -> To.Parsetree.structure_item_desc =\n function\n | From.Parsetree.Pstr_eval (x0, x1) ->\n To.Parsetree.Pstr_eval (copy_expression x0, copy_attributes x1)\n | From.Parsetree.Pstr_value (x0, x1) ->\n To.Parsetree.Pstr_value (copy_rec_flag x0, List.map copy_value_binding x1)\n | From.Parsetree.Pstr_primitive x0 ->\n To.Parsetree.Pstr_primitive (copy_value_description x0)\n | From.Parsetree.Pstr_type (x0, x1) ->\n To.Parsetree.Pstr_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | From.Parsetree.Pstr_typext x0 ->\n To.Parsetree.Pstr_typext (copy_type_extension x0)\n | From.Parsetree.Pstr_exception x0 ->\n To.Parsetree.Pstr_exception (copy_extension_constructor x0)\n | From.Parsetree.Pstr_module x0 ->\n To.Parsetree.Pstr_module (copy_module_binding x0)\n | From.Parsetree.Pstr_recmodule x0 ->\n To.Parsetree.Pstr_recmodule (List.map copy_module_binding x0)\n | From.Parsetree.Pstr_modtype x0 ->\n To.Parsetree.Pstr_modtype (copy_module_type_declaration x0)\n | From.Parsetree.Pstr_open x0 ->\n To.Parsetree.Pstr_open (copy_open_description x0)\n | From.Parsetree.Pstr_class x0 ->\n To.Parsetree.Pstr_class (List.map copy_class_declaration x0)\n | From.Parsetree.Pstr_class_type x0 ->\n To.Parsetree.Pstr_class_type (List.map copy_class_type_declaration x0)\n | From.Parsetree.Pstr_include x0 ->\n To.Parsetree.Pstr_include (copy_include_declaration x0)\n | From.Parsetree.Pstr_attribute x0 ->\n To.Parsetree.Pstr_attribute (copy_attribute x0)\n | From.Parsetree.Pstr_extension (x0, x1) ->\n To.Parsetree.Pstr_extension (copy_extension x0, copy_attributes x1)\n\nand copy_include_declaration :\n From.Parsetree.include_declaration -> To.Parsetree.include_declaration =\n fun x -> copy_include_infos copy_module_expr x\n\nand copy_class_declaration :\n From.Parsetree.class_declaration -> To.Parsetree.class_declaration =\n fun x -> copy_class_infos copy_class_expr x\n\nand copy_class_expr : From.Parsetree.class_expr -> To.Parsetree.class_expr =\n fun {\n From.Parsetree.pcl_desc;\n From.Parsetree.pcl_loc;\n From.Parsetree.pcl_attributes;\n } ->\n {\n To.Parsetree.pcl_desc = copy_class_expr_desc pcl_desc;\n To.Parsetree.pcl_loc = copy_location pcl_loc;\n To.Parsetree.pcl_attributes = copy_attributes pcl_attributes;\n }\n\nand copy_class_expr_desc :\n From.Parsetree.class_expr_desc -> To.Parsetree.class_expr_desc = function\n | From.Parsetree.Pcl_constr (x0, x1) ->\n To.Parsetree.Pcl_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Pcl_structure x0 ->\n To.Parsetree.Pcl_structure (copy_class_structure x0)\n | From.Parsetree.Pcl_fun (x0, x1, x2, x3) ->\n To.Parsetree.Pcl_fun\n ( copy_arg_label x0,\n copy_option copy_expression x1,\n copy_pattern x2,\n copy_class_expr x3 )\n | From.Parsetree.Pcl_apply (x0, x1) ->\n To.Parsetree.Pcl_apply\n ( copy_class_expr x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | From.Parsetree.Pcl_let (x0, x1, x2) ->\n To.Parsetree.Pcl_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_class_expr x2)\n | From.Parsetree.Pcl_constraint (x0, x1) ->\n To.Parsetree.Pcl_constraint (copy_class_expr x0, copy_class_type x1)\n | From.Parsetree.Pcl_extension x0 ->\n To.Parsetree.Pcl_extension (copy_extension x0)\n\nand copy_class_structure :\n From.Parsetree.class_structure -> To.Parsetree.class_structure =\n fun { From.Parsetree.pcstr_self; From.Parsetree.pcstr_fields } ->\n {\n To.Parsetree.pcstr_self = copy_pattern pcstr_self;\n To.Parsetree.pcstr_fields = List.map copy_class_field pcstr_fields;\n }\n\nand copy_class_field : From.Parsetree.class_field -> To.Parsetree.class_field =\n fun {\n From.Parsetree.pcf_desc;\n From.Parsetree.pcf_loc;\n From.Parsetree.pcf_attributes;\n } ->\n {\n To.Parsetree.pcf_desc = copy_class_field_desc pcf_desc;\n To.Parsetree.pcf_loc = copy_location pcf_loc;\n To.Parsetree.pcf_attributes = copy_attributes pcf_attributes;\n }\n\nand copy_class_field_desc :\n From.Parsetree.class_field_desc -> To.Parsetree.class_field_desc = function\n | From.Parsetree.Pcf_inherit (x0, x1, x2) ->\n To.Parsetree.Pcf_inherit\n ( copy_override_flag x0,\n copy_class_expr x1,\n copy_option (fun x -> x.From.Asttypes.txt) x2 )\n | From.Parsetree.Pcf_val x0 ->\n To.Parsetree.Pcf_val\n (let x0, x1, x2 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_mutable_flag x1,\n copy_class_field_kind x2 ))\n | From.Parsetree.Pcf_method x0 ->\n To.Parsetree.Pcf_method\n (let x0, x1, x2 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_private_flag x1,\n copy_class_field_kind x2 ))\n | From.Parsetree.Pcf_constraint x0 ->\n To.Parsetree.Pcf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | From.Parsetree.Pcf_initializer x0 ->\n To.Parsetree.Pcf_initializer (copy_expression x0)\n | From.Parsetree.Pcf_attribute x0 ->\n To.Parsetree.Pcf_attribute (copy_attribute x0)\n | From.Parsetree.Pcf_extension x0 ->\n To.Parsetree.Pcf_extension (copy_extension x0)\n\nand copy_class_field_kind :\n From.Parsetree.class_field_kind -> To.Parsetree.class_field_kind = function\n | From.Parsetree.Cfk_virtual x0 ->\n To.Parsetree.Cfk_virtual (copy_core_type x0)\n | From.Parsetree.Cfk_concrete (x0, x1) ->\n To.Parsetree.Cfk_concrete (copy_override_flag x0, copy_expression x1)\n\nand copy_module_binding :\n From.Parsetree.module_binding -> To.Parsetree.module_binding =\n fun {\n From.Parsetree.pmb_name;\n From.Parsetree.pmb_expr;\n From.Parsetree.pmb_attributes;\n From.Parsetree.pmb_loc;\n } ->\n {\n To.Parsetree.pmb_name = copy_loc (fun x -> x) pmb_name;\n To.Parsetree.pmb_expr = copy_module_expr pmb_expr;\n To.Parsetree.pmb_attributes = copy_attributes pmb_attributes;\n To.Parsetree.pmb_loc = copy_location pmb_loc;\n }\n\nand copy_module_expr : From.Parsetree.module_expr -> To.Parsetree.module_expr =\n fun {\n From.Parsetree.pmod_desc;\n From.Parsetree.pmod_loc;\n From.Parsetree.pmod_attributes;\n } ->\n {\n To.Parsetree.pmod_desc = copy_module_expr_desc pmod_desc;\n To.Parsetree.pmod_loc = copy_location pmod_loc;\n To.Parsetree.pmod_attributes = copy_attributes pmod_attributes;\n }\n\nand copy_module_expr_desc :\n From.Parsetree.module_expr_desc -> To.Parsetree.module_expr_desc = function\n | From.Parsetree.Pmod_ident x0 ->\n To.Parsetree.Pmod_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pmod_structure x0 ->\n To.Parsetree.Pmod_structure (copy_structure x0)\n | From.Parsetree.Pmod_functor (x0, x1, x2) ->\n To.Parsetree.Pmod_functor\n ( copy_loc (fun x -> x) x0,\n copy_option copy_module_type x1,\n copy_module_expr x2 )\n | From.Parsetree.Pmod_apply (x0, x1) ->\n To.Parsetree.Pmod_apply (copy_module_expr x0, copy_module_expr x1)\n | From.Parsetree.Pmod_constraint (x0, x1) ->\n To.Parsetree.Pmod_constraint (copy_module_expr x0, copy_module_type x1)\n | From.Parsetree.Pmod_unpack x0 ->\n To.Parsetree.Pmod_unpack (copy_expression x0)\n | From.Parsetree.Pmod_extension x0 ->\n To.Parsetree.Pmod_extension (copy_extension x0)\n\nand copy_module_type : From.Parsetree.module_type -> To.Parsetree.module_type =\n fun {\n From.Parsetree.pmty_desc;\n From.Parsetree.pmty_loc;\n From.Parsetree.pmty_attributes;\n } ->\n {\n To.Parsetree.pmty_desc = copy_module_type_desc pmty_desc;\n To.Parsetree.pmty_loc = copy_location pmty_loc;\n To.Parsetree.pmty_attributes = copy_attributes pmty_attributes;\n }\n\nand copy_module_type_desc :\n From.Parsetree.module_type_desc -> To.Parsetree.module_type_desc = function\n | From.Parsetree.Pmty_ident x0 ->\n To.Parsetree.Pmty_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pmty_signature x0 ->\n To.Parsetree.Pmty_signature (copy_signature x0)\n | From.Parsetree.Pmty_functor (x0, x1, x2) ->\n To.Parsetree.Pmty_functor\n ( copy_loc (fun x -> x) x0,\n copy_option copy_module_type x1,\n copy_module_type x2 )\n | From.Parsetree.Pmty_with (x0, x1) ->\n To.Parsetree.Pmty_with\n (copy_module_type x0, List.map copy_with_constraint x1)\n | From.Parsetree.Pmty_typeof x0 ->\n To.Parsetree.Pmty_typeof (copy_module_expr x0)\n | From.Parsetree.Pmty_extension x0 ->\n To.Parsetree.Pmty_extension (copy_extension x0)\n | From.Parsetree.Pmty_alias x0 ->\n To.Parsetree.Pmty_alias (copy_loc copy_longident x0)\n\nand copy_with_constraint :\n From.Parsetree.with_constraint -> To.Parsetree.with_constraint = function\n | From.Parsetree.Pwith_type (x0, x1) ->\n To.Parsetree.Pwith_type\n (copy_loc copy_longident x0, copy_type_declaration x1)\n | From.Parsetree.Pwith_module (x0, x1) ->\n To.Parsetree.Pwith_module\n (copy_loc copy_longident x0, copy_loc copy_longident x1)\n | From.Parsetree.Pwith_typesubst x0 ->\n To.Parsetree.Pwith_typesubst (copy_type_declaration x0)\n | From.Parsetree.Pwith_modsubst (x0, x1) ->\n To.Parsetree.Pwith_modsubst\n (copy_loc (fun x -> x) x0, copy_loc copy_longident x1)\n\nand copy_signature : From.Parsetree.signature -> To.Parsetree.signature =\n fun x -> List.map copy_signature_item x\n\nand copy_signature_item :\n From.Parsetree.signature_item -> To.Parsetree.signature_item =\n fun { From.Parsetree.psig_desc; From.Parsetree.psig_loc } ->\n {\n To.Parsetree.psig_desc = copy_signature_item_desc psig_desc;\n To.Parsetree.psig_loc = copy_location psig_loc;\n }\n\nand copy_signature_item_desc :\n From.Parsetree.signature_item_desc -> To.Parsetree.signature_item_desc =\n function\n | From.Parsetree.Psig_value x0 ->\n To.Parsetree.Psig_value (copy_value_description x0)\n | From.Parsetree.Psig_type (x0, x1) ->\n To.Parsetree.Psig_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | From.Parsetree.Psig_typext x0 ->\n To.Parsetree.Psig_typext (copy_type_extension x0)\n | From.Parsetree.Psig_exception x0 ->\n To.Parsetree.Psig_exception (copy_extension_constructor x0)\n | From.Parsetree.Psig_module x0 ->\n To.Parsetree.Psig_module (copy_module_declaration x0)\n | From.Parsetree.Psig_recmodule x0 ->\n To.Parsetree.Psig_recmodule (List.map copy_module_declaration x0)\n | From.Parsetree.Psig_modtype x0 ->\n To.Parsetree.Psig_modtype (copy_module_type_declaration x0)\n | From.Parsetree.Psig_open x0 ->\n To.Parsetree.Psig_open (copy_open_description x0)\n | From.Parsetree.Psig_include x0 ->\n To.Parsetree.Psig_include (copy_include_description x0)\n | From.Parsetree.Psig_class x0 ->\n To.Parsetree.Psig_class (List.map copy_class_description x0)\n | From.Parsetree.Psig_class_type x0 ->\n To.Parsetree.Psig_class_type (List.map copy_class_type_declaration x0)\n | From.Parsetree.Psig_attribute x0 ->\n To.Parsetree.Psig_attribute (copy_attribute x0)\n | From.Parsetree.Psig_extension (x0, x1) ->\n To.Parsetree.Psig_extension (copy_extension x0, copy_attributes x1)\n\nand copy_class_type_declaration :\n From.Parsetree.class_type_declaration -> To.Parsetree.class_type_declaration\n =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_description :\n From.Parsetree.class_description -> To.Parsetree.class_description =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_type : From.Parsetree.class_type -> To.Parsetree.class_type =\n fun {\n From.Parsetree.pcty_desc;\n From.Parsetree.pcty_loc;\n From.Parsetree.pcty_attributes;\n } ->\n {\n To.Parsetree.pcty_desc = copy_class_type_desc pcty_desc;\n To.Parsetree.pcty_loc = copy_location pcty_loc;\n To.Parsetree.pcty_attributes = copy_attributes pcty_attributes;\n }\n\nand copy_class_type_desc :\n From.Parsetree.class_type_desc -> To.Parsetree.class_type_desc = function\n | From.Parsetree.Pcty_constr (x0, x1) ->\n To.Parsetree.Pcty_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Pcty_signature x0 ->\n To.Parsetree.Pcty_signature (copy_class_signature x0)\n | From.Parsetree.Pcty_arrow (x0, x1, x2) ->\n To.Parsetree.Pcty_arrow\n (copy_arg_label x0, copy_core_type x1, copy_class_type x2)\n | From.Parsetree.Pcty_extension x0 ->\n To.Parsetree.Pcty_extension (copy_extension x0)\n\nand copy_class_signature :\n From.Parsetree.class_signature -> To.Parsetree.class_signature =\n fun { From.Parsetree.pcsig_self; From.Parsetree.pcsig_fields } ->\n {\n To.Parsetree.pcsig_self = copy_core_type pcsig_self;\n To.Parsetree.pcsig_fields = List.map copy_class_type_field pcsig_fields;\n }\n\nand copy_class_type_field :\n From.Parsetree.class_type_field -> To.Parsetree.class_type_field =\n fun {\n From.Parsetree.pctf_desc;\n From.Parsetree.pctf_loc;\n From.Parsetree.pctf_attributes;\n } ->\n {\n To.Parsetree.pctf_desc = copy_class_type_field_desc pctf_desc;\n To.Parsetree.pctf_loc = copy_location pctf_loc;\n To.Parsetree.pctf_attributes = copy_attributes pctf_attributes;\n }\n\nand copy_class_type_field_desc :\n From.Parsetree.class_type_field_desc -> To.Parsetree.class_type_field_desc =\n function\n | From.Parsetree.Pctf_inherit x0 ->\n To.Parsetree.Pctf_inherit (copy_class_type x0)\n | From.Parsetree.Pctf_val x0 ->\n To.Parsetree.Pctf_val\n (let x0, x1, x2, x3 = x0 in\n ( x0.From.Asttypes.txt,\n copy_mutable_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | From.Parsetree.Pctf_method x0 ->\n To.Parsetree.Pctf_method\n (let x0, x1, x2, x3 = x0 in\n ( x0.From.Asttypes.txt,\n copy_private_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | From.Parsetree.Pctf_constraint x0 ->\n To.Parsetree.Pctf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | From.Parsetree.Pctf_attribute x0 ->\n To.Parsetree.Pctf_attribute (copy_attribute x0)\n | From.Parsetree.Pctf_extension x0 ->\n To.Parsetree.Pctf_extension (copy_extension x0)\n\nand copy_extension : From.Parsetree.extension -> To.Parsetree.extension =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_class_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 From.Parsetree.class_infos ->\n 'g0 To.Parsetree.class_infos =\n fun f0\n {\n From.Parsetree.pci_virt;\n From.Parsetree.pci_params;\n From.Parsetree.pci_name;\n From.Parsetree.pci_expr;\n From.Parsetree.pci_loc;\n From.Parsetree.pci_attributes;\n } ->\n {\n To.Parsetree.pci_virt = copy_virtual_flag pci_virt;\n To.Parsetree.pci_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n pci_params;\n To.Parsetree.pci_name = copy_loc (fun x -> x) pci_name;\n To.Parsetree.pci_expr = f0 pci_expr;\n To.Parsetree.pci_loc = copy_location pci_loc;\n To.Parsetree.pci_attributes = copy_attributes pci_attributes;\n }\n\nand copy_virtual_flag : From.Asttypes.virtual_flag -> To.Asttypes.virtual_flag =\n function\n | From.Asttypes.Virtual -> To.Asttypes.Virtual\n | From.Asttypes.Concrete -> To.Asttypes.Concrete\n\nand copy_include_description :\n From.Parsetree.include_description -> To.Parsetree.include_description =\n fun x -> copy_include_infos copy_module_type x\n\nand copy_include_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 From.Parsetree.include_infos ->\n 'g0 To.Parsetree.include_infos =\n fun f0\n {\n From.Parsetree.pincl_mod;\n From.Parsetree.pincl_loc;\n From.Parsetree.pincl_attributes;\n } ->\n {\n To.Parsetree.pincl_mod = f0 pincl_mod;\n To.Parsetree.pincl_loc = copy_location pincl_loc;\n To.Parsetree.pincl_attributes = copy_attributes pincl_attributes;\n }\n\nand copy_open_description :\n From.Parsetree.open_description -> To.Parsetree.open_description =\n fun {\n From.Parsetree.popen_lid;\n From.Parsetree.popen_override;\n From.Parsetree.popen_loc;\n From.Parsetree.popen_attributes;\n } ->\n {\n To.Parsetree.popen_lid = copy_loc copy_longident popen_lid;\n To.Parsetree.popen_override = copy_override_flag popen_override;\n To.Parsetree.popen_loc = copy_location popen_loc;\n To.Parsetree.popen_attributes = copy_attributes popen_attributes;\n }\n\nand copy_override_flag :\n From.Asttypes.override_flag -> To.Asttypes.override_flag = function\n | From.Asttypes.Override -> To.Asttypes.Override\n | From.Asttypes.Fresh -> To.Asttypes.Fresh\n\nand copy_module_type_declaration :\n From.Parsetree.module_type_declaration ->\n To.Parsetree.module_type_declaration =\n fun {\n From.Parsetree.pmtd_name;\n From.Parsetree.pmtd_type;\n From.Parsetree.pmtd_attributes;\n From.Parsetree.pmtd_loc;\n } ->\n {\n To.Parsetree.pmtd_name = copy_loc (fun x -> x) pmtd_name;\n To.Parsetree.pmtd_type = copy_option copy_module_type pmtd_type;\n To.Parsetree.pmtd_attributes = copy_attributes pmtd_attributes;\n To.Parsetree.pmtd_loc = copy_location pmtd_loc;\n }\n\nand copy_module_declaration :\n From.Parsetree.module_declaration -> To.Parsetree.module_declaration =\n fun {\n From.Parsetree.pmd_name;\n From.Parsetree.pmd_type;\n From.Parsetree.pmd_attributes;\n From.Parsetree.pmd_loc;\n } ->\n {\n To.Parsetree.pmd_name = copy_loc (fun x -> x) pmd_name;\n To.Parsetree.pmd_type = copy_module_type pmd_type;\n To.Parsetree.pmd_attributes = copy_attributes pmd_attributes;\n To.Parsetree.pmd_loc = copy_location pmd_loc;\n }\n\nand copy_type_extension :\n From.Parsetree.type_extension -> To.Parsetree.type_extension =\n fun {\n From.Parsetree.ptyext_path;\n From.Parsetree.ptyext_params;\n From.Parsetree.ptyext_constructors;\n From.Parsetree.ptyext_private;\n From.Parsetree.ptyext_attributes;\n } ->\n {\n To.Parsetree.ptyext_path = copy_loc copy_longident ptyext_path;\n To.Parsetree.ptyext_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptyext_params;\n To.Parsetree.ptyext_constructors =\n List.map copy_extension_constructor ptyext_constructors;\n To.Parsetree.ptyext_private = copy_private_flag ptyext_private;\n To.Parsetree.ptyext_attributes = copy_attributes ptyext_attributes;\n }\n\nand copy_extension_constructor :\n From.Parsetree.extension_constructor -> To.Parsetree.extension_constructor =\n fun {\n From.Parsetree.pext_name;\n From.Parsetree.pext_kind;\n From.Parsetree.pext_loc;\n From.Parsetree.pext_attributes;\n } ->\n {\n To.Parsetree.pext_name = copy_loc (fun x -> x) pext_name;\n To.Parsetree.pext_kind = copy_extension_constructor_kind pext_kind;\n To.Parsetree.pext_loc = copy_location pext_loc;\n To.Parsetree.pext_attributes = copy_attributes pext_attributes;\n }\n\nand copy_extension_constructor_kind :\n From.Parsetree.extension_constructor_kind ->\n To.Parsetree.extension_constructor_kind = function\n | From.Parsetree.Pext_decl (x0, x1) ->\n To.Parsetree.Pext_decl\n (copy_constructor_arguments x0, copy_option copy_core_type x1)\n | From.Parsetree.Pext_rebind x0 ->\n To.Parsetree.Pext_rebind (copy_loc copy_longident x0)\n\nand copy_type_declaration :\n From.Parsetree.type_declaration -> To.Parsetree.type_declaration =\n fun {\n From.Parsetree.ptype_name;\n From.Parsetree.ptype_params;\n From.Parsetree.ptype_cstrs;\n From.Parsetree.ptype_kind;\n From.Parsetree.ptype_private;\n From.Parsetree.ptype_manifest;\n From.Parsetree.ptype_attributes;\n From.Parsetree.ptype_loc;\n } ->\n {\n To.Parsetree.ptype_name = copy_loc (fun x -> x) ptype_name;\n To.Parsetree.ptype_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptype_params;\n To.Parsetree.ptype_cstrs =\n List.map\n (fun x ->\n let x0, x1, x2 = x in\n (copy_core_type x0, copy_core_type x1, copy_location x2))\n ptype_cstrs;\n To.Parsetree.ptype_kind = copy_type_kind ptype_kind;\n To.Parsetree.ptype_private = copy_private_flag ptype_private;\n To.Parsetree.ptype_manifest = copy_option copy_core_type ptype_manifest;\n To.Parsetree.ptype_attributes = copy_attributes ptype_attributes;\n To.Parsetree.ptype_loc = copy_location ptype_loc;\n }\n\nand copy_private_flag : From.Asttypes.private_flag -> To.Asttypes.private_flag =\n function\n | From.Asttypes.Private -> To.Asttypes.Private\n | From.Asttypes.Public -> To.Asttypes.Public\n\nand copy_type_kind : From.Parsetree.type_kind -> To.Parsetree.type_kind =\n function\n | From.Parsetree.Ptype_abstract -> To.Parsetree.Ptype_abstract\n | From.Parsetree.Ptype_variant x0 ->\n To.Parsetree.Ptype_variant (List.map copy_constructor_declaration x0)\n | From.Parsetree.Ptype_record x0 ->\n To.Parsetree.Ptype_record (List.map copy_label_declaration x0)\n | From.Parsetree.Ptype_open -> To.Parsetree.Ptype_open\n\nand copy_constructor_declaration :\n From.Parsetree.constructor_declaration ->\n To.Parsetree.constructor_declaration =\n fun {\n From.Parsetree.pcd_name;\n From.Parsetree.pcd_args;\n From.Parsetree.pcd_res;\n From.Parsetree.pcd_loc;\n From.Parsetree.pcd_attributes;\n } ->\n {\n To.Parsetree.pcd_name = copy_loc (fun x -> x) pcd_name;\n To.Parsetree.pcd_args = copy_constructor_arguments pcd_args;\n To.Parsetree.pcd_res = copy_option copy_core_type pcd_res;\n To.Parsetree.pcd_loc = copy_location pcd_loc;\n To.Parsetree.pcd_attributes = copy_attributes pcd_attributes;\n }\n\nand copy_constructor_arguments :\n From.Parsetree.constructor_arguments -> To.Parsetree.constructor_arguments =\n function\n | From.Parsetree.Pcstr_tuple x0 ->\n To.Parsetree.Pcstr_tuple (List.map copy_core_type x0)\n | From.Parsetree.Pcstr_record x0 ->\n To.Parsetree.Pcstr_record (List.map copy_label_declaration x0)\n\nand copy_label_declaration :\n From.Parsetree.label_declaration -> To.Parsetree.label_declaration =\n fun {\n From.Parsetree.pld_name;\n From.Parsetree.pld_mutable;\n From.Parsetree.pld_type;\n From.Parsetree.pld_loc;\n From.Parsetree.pld_attributes;\n } ->\n {\n To.Parsetree.pld_name = copy_loc (fun x -> x) pld_name;\n To.Parsetree.pld_mutable = copy_mutable_flag pld_mutable;\n To.Parsetree.pld_type = copy_core_type pld_type;\n To.Parsetree.pld_loc = copy_location pld_loc;\n To.Parsetree.pld_attributes = copy_attributes pld_attributes;\n }\n\nand copy_mutable_flag : From.Asttypes.mutable_flag -> To.Asttypes.mutable_flag =\n function\n | From.Asttypes.Immutable -> To.Asttypes.Immutable\n | From.Asttypes.Mutable -> To.Asttypes.Mutable\n\nand copy_variance : From.Asttypes.variance -> To.Asttypes.variance = function\n | From.Asttypes.Covariant -> To.Asttypes.Covariant\n | From.Asttypes.Contravariant -> To.Asttypes.Contravariant\n | From.Asttypes.Invariant -> To.Asttypes.Invariant\n\nand copy_value_description :\n From.Parsetree.value_description -> To.Parsetree.value_description =\n fun {\n From.Parsetree.pval_name;\n From.Parsetree.pval_type;\n From.Parsetree.pval_prim;\n From.Parsetree.pval_attributes;\n From.Parsetree.pval_loc;\n } ->\n {\n To.Parsetree.pval_name = copy_loc (fun x -> x) pval_name;\n To.Parsetree.pval_type = copy_core_type pval_type;\n To.Parsetree.pval_prim = List.map (fun x -> x) pval_prim;\n To.Parsetree.pval_attributes = copy_attributes pval_attributes;\n To.Parsetree.pval_loc = copy_location pval_loc;\n }\n\nand copy_arg_label : From.Asttypes.arg_label -> To.Asttypes.arg_label = function\n | From.Asttypes.Nolabel -> To.Asttypes.Nolabel\n | From.Asttypes.Labelled x0 -> To.Asttypes.Labelled x0\n | From.Asttypes.Optional x0 -> To.Asttypes.Optional x0\n\nand copy_closed_flag : From.Asttypes.closed_flag -> To.Asttypes.closed_flag =\n function\n | From.Asttypes.Closed -> To.Asttypes.Closed\n | From.Asttypes.Open -> To.Asttypes.Open\n\nand copy_label : From.Asttypes.label -> To.Asttypes.label = fun x -> x\n\nand copy_rec_flag : From.Asttypes.rec_flag -> To.Asttypes.rec_flag = function\n | From.Asttypes.Nonrecursive -> To.Asttypes.Nonrecursive\n | From.Asttypes.Recursive -> To.Asttypes.Recursive\n\nand copy_constant : From.Parsetree.constant -> To.Parsetree.constant = function\n | From.Parsetree.Pconst_integer (x0, x1) ->\n To.Parsetree.Pconst_integer (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pconst_char x0 -> To.Parsetree.Pconst_char x0\n | From.Parsetree.Pconst_string (x0, x1) ->\n To.Parsetree.Pconst_string (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pconst_float (x0, x1) ->\n To.Parsetree.Pconst_float (x0, copy_option (fun x -> x) x1)\n\nand copy_option : 'f0 'g0. ('f0 -> 'g0) -> 'f0 option -> 'g0 option =\n fun f0 -> function None -> None | Some x0 -> Some (f0 x0)\n\nand copy_longident : Longident.t -> Longident.t = fun x -> x\n\nand copy_loc :\n 'f0 'g0. ('f0 -> 'g0) -> 'f0 From.Asttypes.loc -> 'g0 To.Asttypes.loc =\n fun f0 { From.Asttypes.txt; From.Asttypes.loc } ->\n { To.Asttypes.txt = f0 txt; To.Asttypes.loc = copy_location loc }\n\nand copy_location : Location.t -> Location.t = fun x -> x\nand copy_bool : bool -> bool = function false -> false | true -> true\n\nlet rec copy_toplevel_phrase :\n From.Parsetree.toplevel_phrase -> To.Parsetree.toplevel_phrase = function\n | From.Parsetree.Ptop_def x0 -> To.Parsetree.Ptop_def (copy_structure x0)\n | From.Parsetree.Ptop_dir (x0, x1) ->\n To.Parsetree.Ptop_dir (x0, copy_directive_argument x1)\n\nand copy_directive_argument :\n From.Parsetree.directive_argument -> To.Parsetree.directive_argument =\n function\n | From.Parsetree.Pdir_none -> To.Parsetree.Pdir_none\n | From.Parsetree.Pdir_string x0 -> To.Parsetree.Pdir_string x0\n | From.Parsetree.Pdir_int (x0, x1) ->\n To.Parsetree.Pdir_int (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pdir_ident x0 -> To.Parsetree.Pdir_ident (copy_longident x0)\n | From.Parsetree.Pdir_bool x0 -> To.Parsetree.Pdir_bool (copy_bool x0)\n\nlet copy_cases x = List.map copy_case x\nlet copy_pat = copy_pattern\nlet copy_expr = copy_expression\nlet copy_typ = copy_core_type\n","(**************************************************************************)\n(* *)\n(* OCaml Migrate Parsetree *)\n(* *)\n(* Frédéric Bour *)\n(* Alain Frisch, LexiFi *)\n(* *)\n(* Copyright 2017 Institut National de Recherche en Informatique et *)\n(* en Automatique (INRIA). *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nmodule From = Ast_404\nmodule To = Ast_405\n\nlet noloc x = { Location.txt = x; loc = Location.none }\n\nlet rec copy_expression : From.Parsetree.expression -> To.Parsetree.expression =\n fun {\n From.Parsetree.pexp_desc;\n From.Parsetree.pexp_loc;\n From.Parsetree.pexp_attributes;\n } ->\n {\n To.Parsetree.pexp_desc = copy_expression_desc pexp_desc;\n To.Parsetree.pexp_loc = copy_location pexp_loc;\n To.Parsetree.pexp_attributes = copy_attributes pexp_attributes;\n }\n\nand copy_expression_desc :\n From.Parsetree.expression_desc -> To.Parsetree.expression_desc = function\n | From.Parsetree.Pexp_ident x0 ->\n To.Parsetree.Pexp_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pexp_constant x0 ->\n To.Parsetree.Pexp_constant (copy_constant x0)\n | From.Parsetree.Pexp_let (x0, x1, x2) ->\n To.Parsetree.Pexp_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_expression x2)\n | From.Parsetree.Pexp_function x0 ->\n To.Parsetree.Pexp_function (List.map copy_case x0)\n | From.Parsetree.Pexp_fun (x0, x1, x2, x3) ->\n To.Parsetree.Pexp_fun\n ( copy_arg_label x0,\n copy_option copy_expression x1,\n copy_pattern x2,\n copy_expression x3 )\n | From.Parsetree.Pexp_apply (x0, x1) ->\n To.Parsetree.Pexp_apply\n ( copy_expression x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | From.Parsetree.Pexp_match (x0, x1) ->\n To.Parsetree.Pexp_match (copy_expression x0, List.map copy_case x1)\n | From.Parsetree.Pexp_try (x0, x1) ->\n To.Parsetree.Pexp_try (copy_expression x0, List.map copy_case x1)\n | From.Parsetree.Pexp_tuple x0 ->\n To.Parsetree.Pexp_tuple (List.map copy_expression x0)\n | From.Parsetree.Pexp_construct (x0, x1) ->\n To.Parsetree.Pexp_construct\n (copy_loc copy_longident x0, copy_option copy_expression x1)\n | From.Parsetree.Pexp_variant (x0, x1) ->\n To.Parsetree.Pexp_variant (copy_label x0, copy_option copy_expression x1)\n | From.Parsetree.Pexp_record (x0, x1) ->\n To.Parsetree.Pexp_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_expression x1))\n x0,\n copy_option copy_expression x1 )\n | From.Parsetree.Pexp_field (x0, x1) ->\n To.Parsetree.Pexp_field (copy_expression x0, copy_loc copy_longident x1)\n | From.Parsetree.Pexp_setfield (x0, x1, x2) ->\n To.Parsetree.Pexp_setfield\n (copy_expression x0, copy_loc copy_longident x1, copy_expression x2)\n | From.Parsetree.Pexp_array x0 ->\n To.Parsetree.Pexp_array (List.map copy_expression x0)\n | From.Parsetree.Pexp_ifthenelse (x0, x1, x2) ->\n To.Parsetree.Pexp_ifthenelse\n (copy_expression x0, copy_expression x1, copy_option copy_expression x2)\n | From.Parsetree.Pexp_sequence (x0, x1) ->\n To.Parsetree.Pexp_sequence (copy_expression x0, copy_expression x1)\n | From.Parsetree.Pexp_while (x0, x1) ->\n To.Parsetree.Pexp_while (copy_expression x0, copy_expression x1)\n | From.Parsetree.Pexp_for (x0, x1, x2, x3, x4) ->\n To.Parsetree.Pexp_for\n ( copy_pattern x0,\n copy_expression x1,\n copy_expression x2,\n copy_direction_flag x3,\n copy_expression x4 )\n | From.Parsetree.Pexp_constraint (x0, x1) ->\n To.Parsetree.Pexp_constraint (copy_expression x0, copy_core_type x1)\n | From.Parsetree.Pexp_coerce (x0, x1, x2) ->\n To.Parsetree.Pexp_coerce\n (copy_expression x0, copy_option copy_core_type x1, copy_core_type x2)\n | From.Parsetree.Pexp_send (x0, x1) ->\n To.Parsetree.Pexp_send (copy_expression x0, noloc x1)\n | From.Parsetree.Pexp_new x0 ->\n To.Parsetree.Pexp_new (copy_loc copy_longident x0)\n | From.Parsetree.Pexp_setinstvar (x0, x1) ->\n To.Parsetree.Pexp_setinstvar (copy_loc (fun x -> x) x0, copy_expression x1)\n | From.Parsetree.Pexp_override x0 ->\n To.Parsetree.Pexp_override\n (List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_expression x1))\n x0)\n | From.Parsetree.Pexp_letmodule (x0, x1, x2) ->\n To.Parsetree.Pexp_letmodule\n (copy_loc (fun x -> x) x0, copy_module_expr x1, copy_expression x2)\n | From.Parsetree.Pexp_letexception (x0, x1) ->\n To.Parsetree.Pexp_letexception\n (copy_extension_constructor x0, copy_expression x1)\n | From.Parsetree.Pexp_assert x0 ->\n To.Parsetree.Pexp_assert (copy_expression x0)\n | From.Parsetree.Pexp_lazy x0 -> To.Parsetree.Pexp_lazy (copy_expression x0)\n | From.Parsetree.Pexp_poly (x0, x1) ->\n To.Parsetree.Pexp_poly (copy_expression x0, copy_option copy_core_type x1)\n | From.Parsetree.Pexp_object x0 ->\n To.Parsetree.Pexp_object (copy_class_structure x0)\n | From.Parsetree.Pexp_newtype (x0, x1) ->\n To.Parsetree.Pexp_newtype (noloc x0, copy_expression x1)\n | From.Parsetree.Pexp_pack x0 -> To.Parsetree.Pexp_pack (copy_module_expr x0)\n | From.Parsetree.Pexp_open (x0, x1, x2) ->\n To.Parsetree.Pexp_open\n (copy_override_flag x0, copy_loc copy_longident x1, copy_expression x2)\n | From.Parsetree.Pexp_extension x0 ->\n To.Parsetree.Pexp_extension (copy_extension x0)\n | From.Parsetree.Pexp_unreachable -> To.Parsetree.Pexp_unreachable\n\nand copy_direction_flag :\n From.Asttypes.direction_flag -> To.Asttypes.direction_flag = function\n | From.Asttypes.Upto -> To.Asttypes.Upto\n | From.Asttypes.Downto -> To.Asttypes.Downto\n\nand copy_case : From.Parsetree.case -> To.Parsetree.case =\n fun { From.Parsetree.pc_lhs; From.Parsetree.pc_guard; From.Parsetree.pc_rhs } ->\n {\n To.Parsetree.pc_lhs = copy_pattern pc_lhs;\n To.Parsetree.pc_guard = copy_option copy_expression pc_guard;\n To.Parsetree.pc_rhs = copy_expression pc_rhs;\n }\n\nand copy_value_binding :\n From.Parsetree.value_binding -> To.Parsetree.value_binding =\n fun {\n From.Parsetree.pvb_pat;\n From.Parsetree.pvb_expr;\n From.Parsetree.pvb_attributes;\n From.Parsetree.pvb_loc;\n } ->\n {\n To.Parsetree.pvb_pat = copy_pattern pvb_pat;\n To.Parsetree.pvb_expr = copy_expression pvb_expr;\n To.Parsetree.pvb_attributes = copy_attributes pvb_attributes;\n To.Parsetree.pvb_loc = copy_location pvb_loc;\n }\n\nand copy_pattern : From.Parsetree.pattern -> To.Parsetree.pattern =\n fun {\n From.Parsetree.ppat_desc;\n From.Parsetree.ppat_loc;\n From.Parsetree.ppat_attributes;\n } ->\n {\n To.Parsetree.ppat_desc = copy_pattern_desc ppat_desc;\n To.Parsetree.ppat_loc = copy_location ppat_loc;\n To.Parsetree.ppat_attributes = copy_attributes ppat_attributes;\n }\n\nand copy_pattern_desc : From.Parsetree.pattern_desc -> To.Parsetree.pattern_desc\n = function\n | From.Parsetree.Ppat_any -> To.Parsetree.Ppat_any\n | From.Parsetree.Ppat_var x0 ->\n To.Parsetree.Ppat_var (copy_loc (fun x -> x) x0)\n | From.Parsetree.Ppat_alias (x0, x1) ->\n To.Parsetree.Ppat_alias (copy_pattern x0, copy_loc (fun x -> x) x1)\n | From.Parsetree.Ppat_constant x0 ->\n To.Parsetree.Ppat_constant (copy_constant x0)\n | From.Parsetree.Ppat_interval (x0, x1) ->\n To.Parsetree.Ppat_interval (copy_constant x0, copy_constant x1)\n | From.Parsetree.Ppat_tuple x0 ->\n To.Parsetree.Ppat_tuple (List.map copy_pattern x0)\n | From.Parsetree.Ppat_construct (x0, x1) ->\n To.Parsetree.Ppat_construct\n (copy_loc copy_longident x0, copy_option copy_pattern x1)\n | From.Parsetree.Ppat_variant (x0, x1) ->\n To.Parsetree.Ppat_variant (copy_label x0, copy_option copy_pattern x1)\n | From.Parsetree.Ppat_record (x0, x1) ->\n To.Parsetree.Ppat_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_pattern x1))\n x0,\n copy_closed_flag x1 )\n | From.Parsetree.Ppat_array x0 ->\n To.Parsetree.Ppat_array (List.map copy_pattern x0)\n | From.Parsetree.Ppat_or (x0, x1) ->\n To.Parsetree.Ppat_or (copy_pattern x0, copy_pattern x1)\n | From.Parsetree.Ppat_constraint (x0, x1) ->\n To.Parsetree.Ppat_constraint (copy_pattern x0, copy_core_type x1)\n | From.Parsetree.Ppat_type x0 ->\n To.Parsetree.Ppat_type (copy_loc copy_longident x0)\n | From.Parsetree.Ppat_lazy x0 -> To.Parsetree.Ppat_lazy (copy_pattern x0)\n | From.Parsetree.Ppat_unpack x0 ->\n To.Parsetree.Ppat_unpack (copy_loc (fun x -> x) x0)\n | From.Parsetree.Ppat_exception x0 ->\n To.Parsetree.Ppat_exception (copy_pattern x0)\n | From.Parsetree.Ppat_extension x0 ->\n To.Parsetree.Ppat_extension (copy_extension x0)\n | From.Parsetree.Ppat_open (x0, x1) ->\n To.Parsetree.Ppat_open (copy_loc copy_longident x0, copy_pattern x1)\n\nand copy_core_type : From.Parsetree.core_type -> To.Parsetree.core_type =\n fun {\n From.Parsetree.ptyp_desc;\n From.Parsetree.ptyp_loc;\n From.Parsetree.ptyp_attributes;\n } ->\n {\n To.Parsetree.ptyp_desc = copy_core_type_desc ptyp_desc;\n To.Parsetree.ptyp_loc = copy_location ptyp_loc;\n To.Parsetree.ptyp_attributes = copy_attributes ptyp_attributes;\n }\n\nand copy_core_type_desc :\n From.Parsetree.core_type_desc -> To.Parsetree.core_type_desc = function\n | From.Parsetree.Ptyp_any -> To.Parsetree.Ptyp_any\n | From.Parsetree.Ptyp_var x0 -> To.Parsetree.Ptyp_var x0\n | From.Parsetree.Ptyp_arrow (x0, x1, x2) ->\n To.Parsetree.Ptyp_arrow\n (copy_arg_label x0, copy_core_type x1, copy_core_type x2)\n | From.Parsetree.Ptyp_tuple x0 ->\n To.Parsetree.Ptyp_tuple (List.map copy_core_type x0)\n | From.Parsetree.Ptyp_constr (x0, x1) ->\n To.Parsetree.Ptyp_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Ptyp_object (x0, x1) ->\n To.Parsetree.Ptyp_object\n ( List.map\n (fun x ->\n let x0, x1, x2 = x in\n (noloc x0, copy_attributes x1, copy_core_type x2))\n x0,\n copy_closed_flag x1 )\n | From.Parsetree.Ptyp_class (x0, x1) ->\n To.Parsetree.Ptyp_class\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Ptyp_alias (x0, x1) ->\n To.Parsetree.Ptyp_alias (copy_core_type x0, x1)\n | From.Parsetree.Ptyp_variant (x0, x1, x2) ->\n To.Parsetree.Ptyp_variant\n ( List.map copy_row_field x0,\n copy_closed_flag x1,\n copy_option (fun x -> List.map copy_label x) x2 )\n | From.Parsetree.Ptyp_poly (x0, x1) ->\n To.Parsetree.Ptyp_poly (List.map (fun x -> noloc x) x0, copy_core_type x1)\n | From.Parsetree.Ptyp_package x0 ->\n To.Parsetree.Ptyp_package (copy_package_type x0)\n | From.Parsetree.Ptyp_extension x0 ->\n To.Parsetree.Ptyp_extension (copy_extension x0)\n\nand copy_package_type : From.Parsetree.package_type -> To.Parsetree.package_type\n =\n fun x ->\n let x0, x1 = x in\n ( copy_loc copy_longident x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_core_type x1))\n x1 )\n\nand copy_row_field : From.Parsetree.row_field -> To.Parsetree.row_field =\n function\n | From.Parsetree.Rtag (x0, x1, x2, x3) ->\n To.Parsetree.Rtag\n ( copy_label x0,\n copy_attributes x1,\n copy_bool x2,\n List.map copy_core_type x3 )\n | From.Parsetree.Rinherit x0 -> To.Parsetree.Rinherit (copy_core_type x0)\n\nand copy_attributes : From.Parsetree.attributes -> To.Parsetree.attributes =\n fun x -> List.map copy_attribute x\n\nand copy_attribute : From.Parsetree.attribute -> To.Parsetree.attribute =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_payload : From.Parsetree.payload -> To.Parsetree.payload = function\n | From.Parsetree.PStr x0 -> To.Parsetree.PStr (copy_structure x0)\n | From.Parsetree.PSig x0 -> To.Parsetree.PSig (copy_signature x0)\n | From.Parsetree.PTyp x0 -> To.Parsetree.PTyp (copy_core_type x0)\n | From.Parsetree.PPat (x0, x1) ->\n To.Parsetree.PPat (copy_pattern x0, copy_option copy_expression x1)\n\nand copy_structure : From.Parsetree.structure -> To.Parsetree.structure =\n fun x -> List.map copy_structure_item x\n\nand copy_structure_item :\n From.Parsetree.structure_item -> To.Parsetree.structure_item =\n fun { From.Parsetree.pstr_desc; From.Parsetree.pstr_loc } ->\n {\n To.Parsetree.pstr_desc = copy_structure_item_desc pstr_desc;\n To.Parsetree.pstr_loc = copy_location pstr_loc;\n }\n\nand copy_structure_item_desc :\n From.Parsetree.structure_item_desc -> To.Parsetree.structure_item_desc =\n function\n | From.Parsetree.Pstr_eval (x0, x1) ->\n To.Parsetree.Pstr_eval (copy_expression x0, copy_attributes x1)\n | From.Parsetree.Pstr_value (x0, x1) ->\n To.Parsetree.Pstr_value (copy_rec_flag x0, List.map copy_value_binding x1)\n | From.Parsetree.Pstr_primitive x0 ->\n To.Parsetree.Pstr_primitive (copy_value_description x0)\n | From.Parsetree.Pstr_type (x0, x1) ->\n To.Parsetree.Pstr_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | From.Parsetree.Pstr_typext x0 ->\n To.Parsetree.Pstr_typext (copy_type_extension x0)\n | From.Parsetree.Pstr_exception x0 ->\n To.Parsetree.Pstr_exception (copy_extension_constructor x0)\n | From.Parsetree.Pstr_module x0 ->\n To.Parsetree.Pstr_module (copy_module_binding x0)\n | From.Parsetree.Pstr_recmodule x0 ->\n To.Parsetree.Pstr_recmodule (List.map copy_module_binding x0)\n | From.Parsetree.Pstr_modtype x0 ->\n To.Parsetree.Pstr_modtype (copy_module_type_declaration x0)\n | From.Parsetree.Pstr_open x0 ->\n To.Parsetree.Pstr_open (copy_open_description x0)\n | From.Parsetree.Pstr_class x0 ->\n To.Parsetree.Pstr_class (List.map copy_class_declaration x0)\n | From.Parsetree.Pstr_class_type x0 ->\n To.Parsetree.Pstr_class_type (List.map copy_class_type_declaration x0)\n | From.Parsetree.Pstr_include x0 ->\n To.Parsetree.Pstr_include (copy_include_declaration x0)\n | From.Parsetree.Pstr_attribute x0 ->\n To.Parsetree.Pstr_attribute (copy_attribute x0)\n | From.Parsetree.Pstr_extension (x0, x1) ->\n To.Parsetree.Pstr_extension (copy_extension x0, copy_attributes x1)\n\nand copy_include_declaration :\n From.Parsetree.include_declaration -> To.Parsetree.include_declaration =\n fun x -> copy_include_infos copy_module_expr x\n\nand copy_class_declaration :\n From.Parsetree.class_declaration -> To.Parsetree.class_declaration =\n fun x -> copy_class_infos copy_class_expr x\n\nand copy_class_expr : From.Parsetree.class_expr -> To.Parsetree.class_expr =\n fun {\n From.Parsetree.pcl_desc;\n From.Parsetree.pcl_loc;\n From.Parsetree.pcl_attributes;\n } ->\n {\n To.Parsetree.pcl_desc = copy_class_expr_desc pcl_desc;\n To.Parsetree.pcl_loc = copy_location pcl_loc;\n To.Parsetree.pcl_attributes = copy_attributes pcl_attributes;\n }\n\nand copy_class_expr_desc :\n From.Parsetree.class_expr_desc -> To.Parsetree.class_expr_desc = function\n | From.Parsetree.Pcl_constr (x0, x1) ->\n To.Parsetree.Pcl_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Pcl_structure x0 ->\n To.Parsetree.Pcl_structure (copy_class_structure x0)\n | From.Parsetree.Pcl_fun (x0, x1, x2, x3) ->\n To.Parsetree.Pcl_fun\n ( copy_arg_label x0,\n copy_option copy_expression x1,\n copy_pattern x2,\n copy_class_expr x3 )\n | From.Parsetree.Pcl_apply (x0, x1) ->\n To.Parsetree.Pcl_apply\n ( copy_class_expr x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | From.Parsetree.Pcl_let (x0, x1, x2) ->\n To.Parsetree.Pcl_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_class_expr x2)\n | From.Parsetree.Pcl_constraint (x0, x1) ->\n To.Parsetree.Pcl_constraint (copy_class_expr x0, copy_class_type x1)\n | From.Parsetree.Pcl_extension x0 ->\n To.Parsetree.Pcl_extension (copy_extension x0)\n\nand copy_class_structure :\n From.Parsetree.class_structure -> To.Parsetree.class_structure =\n fun { From.Parsetree.pcstr_self; From.Parsetree.pcstr_fields } ->\n {\n To.Parsetree.pcstr_self = copy_pattern pcstr_self;\n To.Parsetree.pcstr_fields = List.map copy_class_field pcstr_fields;\n }\n\nand copy_class_field : From.Parsetree.class_field -> To.Parsetree.class_field =\n fun {\n From.Parsetree.pcf_desc;\n From.Parsetree.pcf_loc;\n From.Parsetree.pcf_attributes;\n } ->\n {\n To.Parsetree.pcf_desc = copy_class_field_desc pcf_desc;\n To.Parsetree.pcf_loc = copy_location pcf_loc;\n To.Parsetree.pcf_attributes = copy_attributes pcf_attributes;\n }\n\nand copy_class_field_desc :\n From.Parsetree.class_field_desc -> To.Parsetree.class_field_desc = function\n | From.Parsetree.Pcf_inherit (x0, x1, x2) ->\n To.Parsetree.Pcf_inherit\n ( copy_override_flag x0,\n copy_class_expr x1,\n copy_option (fun x -> noloc x) x2 )\n | From.Parsetree.Pcf_val x0 ->\n To.Parsetree.Pcf_val\n (let x0, x1, x2 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_mutable_flag x1,\n copy_class_field_kind x2 ))\n | From.Parsetree.Pcf_method x0 ->\n To.Parsetree.Pcf_method\n (let x0, x1, x2 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_private_flag x1,\n copy_class_field_kind x2 ))\n | From.Parsetree.Pcf_constraint x0 ->\n To.Parsetree.Pcf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | From.Parsetree.Pcf_initializer x0 ->\n To.Parsetree.Pcf_initializer (copy_expression x0)\n | From.Parsetree.Pcf_attribute x0 ->\n To.Parsetree.Pcf_attribute (copy_attribute x0)\n | From.Parsetree.Pcf_extension x0 ->\n To.Parsetree.Pcf_extension (copy_extension x0)\n\nand copy_class_field_kind :\n From.Parsetree.class_field_kind -> To.Parsetree.class_field_kind = function\n | From.Parsetree.Cfk_virtual x0 ->\n To.Parsetree.Cfk_virtual (copy_core_type x0)\n | From.Parsetree.Cfk_concrete (x0, x1) ->\n To.Parsetree.Cfk_concrete (copy_override_flag x0, copy_expression x1)\n\nand copy_module_binding :\n From.Parsetree.module_binding -> To.Parsetree.module_binding =\n fun {\n From.Parsetree.pmb_name;\n From.Parsetree.pmb_expr;\n From.Parsetree.pmb_attributes;\n From.Parsetree.pmb_loc;\n } ->\n {\n To.Parsetree.pmb_name = copy_loc (fun x -> x) pmb_name;\n To.Parsetree.pmb_expr = copy_module_expr pmb_expr;\n To.Parsetree.pmb_attributes = copy_attributes pmb_attributes;\n To.Parsetree.pmb_loc = copy_location pmb_loc;\n }\n\nand copy_module_expr : From.Parsetree.module_expr -> To.Parsetree.module_expr =\n fun {\n From.Parsetree.pmod_desc;\n From.Parsetree.pmod_loc;\n From.Parsetree.pmod_attributes;\n } ->\n {\n To.Parsetree.pmod_desc = copy_module_expr_desc pmod_desc;\n To.Parsetree.pmod_loc = copy_location pmod_loc;\n To.Parsetree.pmod_attributes = copy_attributes pmod_attributes;\n }\n\nand copy_module_expr_desc :\n From.Parsetree.module_expr_desc -> To.Parsetree.module_expr_desc = function\n | From.Parsetree.Pmod_ident x0 ->\n To.Parsetree.Pmod_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pmod_structure x0 ->\n To.Parsetree.Pmod_structure (copy_structure x0)\n | From.Parsetree.Pmod_functor (x0, x1, x2) ->\n To.Parsetree.Pmod_functor\n ( copy_loc (fun x -> x) x0,\n copy_option copy_module_type x1,\n copy_module_expr x2 )\n | From.Parsetree.Pmod_apply (x0, x1) ->\n To.Parsetree.Pmod_apply (copy_module_expr x0, copy_module_expr x1)\n | From.Parsetree.Pmod_constraint (x0, x1) ->\n To.Parsetree.Pmod_constraint (copy_module_expr x0, copy_module_type x1)\n | From.Parsetree.Pmod_unpack x0 ->\n To.Parsetree.Pmod_unpack (copy_expression x0)\n | From.Parsetree.Pmod_extension x0 ->\n To.Parsetree.Pmod_extension (copy_extension x0)\n\nand copy_module_type : From.Parsetree.module_type -> To.Parsetree.module_type =\n fun {\n From.Parsetree.pmty_desc;\n From.Parsetree.pmty_loc;\n From.Parsetree.pmty_attributes;\n } ->\n {\n To.Parsetree.pmty_desc = copy_module_type_desc pmty_desc;\n To.Parsetree.pmty_loc = copy_location pmty_loc;\n To.Parsetree.pmty_attributes = copy_attributes pmty_attributes;\n }\n\nand copy_module_type_desc :\n From.Parsetree.module_type_desc -> To.Parsetree.module_type_desc = function\n | From.Parsetree.Pmty_ident x0 ->\n To.Parsetree.Pmty_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pmty_signature x0 ->\n To.Parsetree.Pmty_signature (copy_signature x0)\n | From.Parsetree.Pmty_functor (x0, x1, x2) ->\n To.Parsetree.Pmty_functor\n ( copy_loc (fun x -> x) x0,\n copy_option copy_module_type x1,\n copy_module_type x2 )\n | From.Parsetree.Pmty_with (x0, x1) ->\n To.Parsetree.Pmty_with\n (copy_module_type x0, List.map copy_with_constraint x1)\n | From.Parsetree.Pmty_typeof x0 ->\n To.Parsetree.Pmty_typeof (copy_module_expr x0)\n | From.Parsetree.Pmty_extension x0 ->\n To.Parsetree.Pmty_extension (copy_extension x0)\n | From.Parsetree.Pmty_alias x0 ->\n To.Parsetree.Pmty_alias (copy_loc copy_longident x0)\n\nand copy_with_constraint :\n From.Parsetree.with_constraint -> To.Parsetree.with_constraint = function\n | From.Parsetree.Pwith_type (x0, x1) ->\n To.Parsetree.Pwith_type\n (copy_loc copy_longident x0, copy_type_declaration x1)\n | From.Parsetree.Pwith_module (x0, x1) ->\n To.Parsetree.Pwith_module\n (copy_loc copy_longident x0, copy_loc copy_longident x1)\n | From.Parsetree.Pwith_typesubst x0 ->\n To.Parsetree.Pwith_typesubst (copy_type_declaration x0)\n | From.Parsetree.Pwith_modsubst (x0, x1) ->\n To.Parsetree.Pwith_modsubst\n (copy_loc (fun x -> x) x0, copy_loc copy_longident x1)\n\nand copy_signature : From.Parsetree.signature -> To.Parsetree.signature =\n fun x -> List.map copy_signature_item x\n\nand copy_signature_item :\n From.Parsetree.signature_item -> To.Parsetree.signature_item =\n fun { From.Parsetree.psig_desc; From.Parsetree.psig_loc } ->\n {\n To.Parsetree.psig_desc = copy_signature_item_desc psig_desc;\n To.Parsetree.psig_loc = copy_location psig_loc;\n }\n\nand copy_signature_item_desc :\n From.Parsetree.signature_item_desc -> To.Parsetree.signature_item_desc =\n function\n | From.Parsetree.Psig_value x0 ->\n To.Parsetree.Psig_value (copy_value_description x0)\n | From.Parsetree.Psig_type (x0, x1) ->\n To.Parsetree.Psig_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | From.Parsetree.Psig_typext x0 ->\n To.Parsetree.Psig_typext (copy_type_extension x0)\n | From.Parsetree.Psig_exception x0 ->\n To.Parsetree.Psig_exception (copy_extension_constructor x0)\n | From.Parsetree.Psig_module x0 ->\n To.Parsetree.Psig_module (copy_module_declaration x0)\n | From.Parsetree.Psig_recmodule x0 ->\n To.Parsetree.Psig_recmodule (List.map copy_module_declaration x0)\n | From.Parsetree.Psig_modtype x0 ->\n To.Parsetree.Psig_modtype (copy_module_type_declaration x0)\n | From.Parsetree.Psig_open x0 ->\n To.Parsetree.Psig_open (copy_open_description x0)\n | From.Parsetree.Psig_include x0 ->\n To.Parsetree.Psig_include (copy_include_description x0)\n | From.Parsetree.Psig_class x0 ->\n To.Parsetree.Psig_class (List.map copy_class_description x0)\n | From.Parsetree.Psig_class_type x0 ->\n To.Parsetree.Psig_class_type (List.map copy_class_type_declaration x0)\n | From.Parsetree.Psig_attribute x0 ->\n To.Parsetree.Psig_attribute (copy_attribute x0)\n | From.Parsetree.Psig_extension (x0, x1) ->\n To.Parsetree.Psig_extension (copy_extension x0, copy_attributes x1)\n\nand copy_class_type_declaration :\n From.Parsetree.class_type_declaration -> To.Parsetree.class_type_declaration\n =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_description :\n From.Parsetree.class_description -> To.Parsetree.class_description =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_type : From.Parsetree.class_type -> To.Parsetree.class_type =\n fun {\n From.Parsetree.pcty_desc;\n From.Parsetree.pcty_loc;\n From.Parsetree.pcty_attributes;\n } ->\n {\n To.Parsetree.pcty_desc = copy_class_type_desc pcty_desc;\n To.Parsetree.pcty_loc = copy_location pcty_loc;\n To.Parsetree.pcty_attributes = copy_attributes pcty_attributes;\n }\n\nand copy_class_type_desc :\n From.Parsetree.class_type_desc -> To.Parsetree.class_type_desc = function\n | From.Parsetree.Pcty_constr (x0, x1) ->\n To.Parsetree.Pcty_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Pcty_signature x0 ->\n To.Parsetree.Pcty_signature (copy_class_signature x0)\n | From.Parsetree.Pcty_arrow (x0, x1, x2) ->\n To.Parsetree.Pcty_arrow\n (copy_arg_label x0, copy_core_type x1, copy_class_type x2)\n | From.Parsetree.Pcty_extension x0 ->\n To.Parsetree.Pcty_extension (copy_extension x0)\n\nand copy_class_signature :\n From.Parsetree.class_signature -> To.Parsetree.class_signature =\n fun { From.Parsetree.pcsig_self; From.Parsetree.pcsig_fields } ->\n {\n To.Parsetree.pcsig_self = copy_core_type pcsig_self;\n To.Parsetree.pcsig_fields = List.map copy_class_type_field pcsig_fields;\n }\n\nand copy_class_type_field :\n From.Parsetree.class_type_field -> To.Parsetree.class_type_field =\n fun {\n From.Parsetree.pctf_desc;\n From.Parsetree.pctf_loc;\n From.Parsetree.pctf_attributes;\n } ->\n {\n To.Parsetree.pctf_desc = copy_class_type_field_desc pctf_desc;\n To.Parsetree.pctf_loc = copy_location pctf_loc;\n To.Parsetree.pctf_attributes = copy_attributes pctf_attributes;\n }\n\nand copy_class_type_field_desc :\n From.Parsetree.class_type_field_desc -> To.Parsetree.class_type_field_desc =\n function\n | From.Parsetree.Pctf_inherit x0 ->\n To.Parsetree.Pctf_inherit (copy_class_type x0)\n | From.Parsetree.Pctf_val x0 ->\n To.Parsetree.Pctf_val\n (let x0, x1, x2, x3 = x0 in\n ( noloc x0,\n copy_mutable_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | From.Parsetree.Pctf_method x0 ->\n To.Parsetree.Pctf_method\n (let x0, x1, x2, x3 = x0 in\n ( noloc x0,\n copy_private_flag x1,\n copy_virtual_flag x2,\n copy_core_type x3 ))\n | From.Parsetree.Pctf_constraint x0 ->\n To.Parsetree.Pctf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | From.Parsetree.Pctf_attribute x0 ->\n To.Parsetree.Pctf_attribute (copy_attribute x0)\n | From.Parsetree.Pctf_extension x0 ->\n To.Parsetree.Pctf_extension (copy_extension x0)\n\nand copy_extension : From.Parsetree.extension -> To.Parsetree.extension =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_class_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 From.Parsetree.class_infos ->\n 'g0 To.Parsetree.class_infos =\n fun f0\n {\n From.Parsetree.pci_virt;\n From.Parsetree.pci_params;\n From.Parsetree.pci_name;\n From.Parsetree.pci_expr;\n From.Parsetree.pci_loc;\n From.Parsetree.pci_attributes;\n } ->\n {\n To.Parsetree.pci_virt = copy_virtual_flag pci_virt;\n To.Parsetree.pci_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n pci_params;\n To.Parsetree.pci_name = copy_loc (fun x -> x) pci_name;\n To.Parsetree.pci_expr = f0 pci_expr;\n To.Parsetree.pci_loc = copy_location pci_loc;\n To.Parsetree.pci_attributes = copy_attributes pci_attributes;\n }\n\nand copy_virtual_flag : From.Asttypes.virtual_flag -> To.Asttypes.virtual_flag =\n function\n | From.Asttypes.Virtual -> To.Asttypes.Virtual\n | From.Asttypes.Concrete -> To.Asttypes.Concrete\n\nand copy_include_description :\n From.Parsetree.include_description -> To.Parsetree.include_description =\n fun x -> copy_include_infos copy_module_type x\n\nand copy_include_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 From.Parsetree.include_infos ->\n 'g0 To.Parsetree.include_infos =\n fun f0\n {\n From.Parsetree.pincl_mod;\n From.Parsetree.pincl_loc;\n From.Parsetree.pincl_attributes;\n } ->\n {\n To.Parsetree.pincl_mod = f0 pincl_mod;\n To.Parsetree.pincl_loc = copy_location pincl_loc;\n To.Parsetree.pincl_attributes = copy_attributes pincl_attributes;\n }\n\nand copy_open_description :\n From.Parsetree.open_description -> To.Parsetree.open_description =\n fun {\n From.Parsetree.popen_lid;\n From.Parsetree.popen_override;\n From.Parsetree.popen_loc;\n From.Parsetree.popen_attributes;\n } ->\n {\n To.Parsetree.popen_lid = copy_loc copy_longident popen_lid;\n To.Parsetree.popen_override = copy_override_flag popen_override;\n To.Parsetree.popen_loc = copy_location popen_loc;\n To.Parsetree.popen_attributes = copy_attributes popen_attributes;\n }\n\nand copy_override_flag :\n From.Asttypes.override_flag -> To.Asttypes.override_flag = function\n | From.Asttypes.Override -> To.Asttypes.Override\n | From.Asttypes.Fresh -> To.Asttypes.Fresh\n\nand copy_module_type_declaration :\n From.Parsetree.module_type_declaration ->\n To.Parsetree.module_type_declaration =\n fun {\n From.Parsetree.pmtd_name;\n From.Parsetree.pmtd_type;\n From.Parsetree.pmtd_attributes;\n From.Parsetree.pmtd_loc;\n } ->\n {\n To.Parsetree.pmtd_name = copy_loc (fun x -> x) pmtd_name;\n To.Parsetree.pmtd_type = copy_option copy_module_type pmtd_type;\n To.Parsetree.pmtd_attributes = copy_attributes pmtd_attributes;\n To.Parsetree.pmtd_loc = copy_location pmtd_loc;\n }\n\nand copy_module_declaration :\n From.Parsetree.module_declaration -> To.Parsetree.module_declaration =\n fun {\n From.Parsetree.pmd_name;\n From.Parsetree.pmd_type;\n From.Parsetree.pmd_attributes;\n From.Parsetree.pmd_loc;\n } ->\n {\n To.Parsetree.pmd_name = copy_loc (fun x -> x) pmd_name;\n To.Parsetree.pmd_type = copy_module_type pmd_type;\n To.Parsetree.pmd_attributes = copy_attributes pmd_attributes;\n To.Parsetree.pmd_loc = copy_location pmd_loc;\n }\n\nand copy_type_extension :\n From.Parsetree.type_extension -> To.Parsetree.type_extension =\n fun {\n From.Parsetree.ptyext_path;\n From.Parsetree.ptyext_params;\n From.Parsetree.ptyext_constructors;\n From.Parsetree.ptyext_private;\n From.Parsetree.ptyext_attributes;\n } ->\n {\n To.Parsetree.ptyext_path = copy_loc copy_longident ptyext_path;\n To.Parsetree.ptyext_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptyext_params;\n To.Parsetree.ptyext_constructors =\n List.map copy_extension_constructor ptyext_constructors;\n To.Parsetree.ptyext_private = copy_private_flag ptyext_private;\n To.Parsetree.ptyext_attributes = copy_attributes ptyext_attributes;\n }\n\nand copy_extension_constructor :\n From.Parsetree.extension_constructor -> To.Parsetree.extension_constructor =\n fun {\n From.Parsetree.pext_name;\n From.Parsetree.pext_kind;\n From.Parsetree.pext_loc;\n From.Parsetree.pext_attributes;\n } ->\n {\n To.Parsetree.pext_name = copy_loc (fun x -> x) pext_name;\n To.Parsetree.pext_kind = copy_extension_constructor_kind pext_kind;\n To.Parsetree.pext_loc = copy_location pext_loc;\n To.Parsetree.pext_attributes = copy_attributes pext_attributes;\n }\n\nand copy_extension_constructor_kind :\n From.Parsetree.extension_constructor_kind ->\n To.Parsetree.extension_constructor_kind = function\n | From.Parsetree.Pext_decl (x0, x1) ->\n To.Parsetree.Pext_decl\n (copy_constructor_arguments x0, copy_option copy_core_type x1)\n | From.Parsetree.Pext_rebind x0 ->\n To.Parsetree.Pext_rebind (copy_loc copy_longident x0)\n\nand copy_type_declaration :\n From.Parsetree.type_declaration -> To.Parsetree.type_declaration =\n fun {\n From.Parsetree.ptype_name;\n From.Parsetree.ptype_params;\n From.Parsetree.ptype_cstrs;\n From.Parsetree.ptype_kind;\n From.Parsetree.ptype_private;\n From.Parsetree.ptype_manifest;\n From.Parsetree.ptype_attributes;\n From.Parsetree.ptype_loc;\n } ->\n {\n To.Parsetree.ptype_name = copy_loc (fun x -> x) ptype_name;\n To.Parsetree.ptype_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptype_params;\n To.Parsetree.ptype_cstrs =\n List.map\n (fun x ->\n let x0, x1, x2 = x in\n (copy_core_type x0, copy_core_type x1, copy_location x2))\n ptype_cstrs;\n To.Parsetree.ptype_kind = copy_type_kind ptype_kind;\n To.Parsetree.ptype_private = copy_private_flag ptype_private;\n To.Parsetree.ptype_manifest = copy_option copy_core_type ptype_manifest;\n To.Parsetree.ptype_attributes = copy_attributes ptype_attributes;\n To.Parsetree.ptype_loc = copy_location ptype_loc;\n }\n\nand copy_private_flag : From.Asttypes.private_flag -> To.Asttypes.private_flag =\n function\n | From.Asttypes.Private -> To.Asttypes.Private\n | From.Asttypes.Public -> To.Asttypes.Public\n\nand copy_type_kind : From.Parsetree.type_kind -> To.Parsetree.type_kind =\n function\n | From.Parsetree.Ptype_abstract -> To.Parsetree.Ptype_abstract\n | From.Parsetree.Ptype_variant x0 ->\n To.Parsetree.Ptype_variant (List.map copy_constructor_declaration x0)\n | From.Parsetree.Ptype_record x0 ->\n To.Parsetree.Ptype_record (List.map copy_label_declaration x0)\n | From.Parsetree.Ptype_open -> To.Parsetree.Ptype_open\n\nand copy_constructor_declaration :\n From.Parsetree.constructor_declaration ->\n To.Parsetree.constructor_declaration =\n fun {\n From.Parsetree.pcd_name;\n From.Parsetree.pcd_args;\n From.Parsetree.pcd_res;\n From.Parsetree.pcd_loc;\n From.Parsetree.pcd_attributes;\n } ->\n {\n To.Parsetree.pcd_name = copy_loc (fun x -> x) pcd_name;\n To.Parsetree.pcd_args = copy_constructor_arguments pcd_args;\n To.Parsetree.pcd_res = copy_option copy_core_type pcd_res;\n To.Parsetree.pcd_loc = copy_location pcd_loc;\n To.Parsetree.pcd_attributes = copy_attributes pcd_attributes;\n }\n\nand copy_constructor_arguments :\n From.Parsetree.constructor_arguments -> To.Parsetree.constructor_arguments =\n function\n | From.Parsetree.Pcstr_tuple x0 ->\n To.Parsetree.Pcstr_tuple (List.map copy_core_type x0)\n | From.Parsetree.Pcstr_record x0 ->\n To.Parsetree.Pcstr_record (List.map copy_label_declaration x0)\n\nand copy_label_declaration :\n From.Parsetree.label_declaration -> To.Parsetree.label_declaration =\n fun {\n From.Parsetree.pld_name;\n From.Parsetree.pld_mutable;\n From.Parsetree.pld_type;\n From.Parsetree.pld_loc;\n From.Parsetree.pld_attributes;\n } ->\n {\n To.Parsetree.pld_name = copy_loc (fun x -> x) pld_name;\n To.Parsetree.pld_mutable = copy_mutable_flag pld_mutable;\n To.Parsetree.pld_type = copy_core_type pld_type;\n To.Parsetree.pld_loc = copy_location pld_loc;\n To.Parsetree.pld_attributes = copy_attributes pld_attributes;\n }\n\nand copy_mutable_flag : From.Asttypes.mutable_flag -> To.Asttypes.mutable_flag =\n function\n | From.Asttypes.Immutable -> To.Asttypes.Immutable\n | From.Asttypes.Mutable -> To.Asttypes.Mutable\n\nand copy_variance : From.Asttypes.variance -> To.Asttypes.variance = function\n | From.Asttypes.Covariant -> To.Asttypes.Covariant\n | From.Asttypes.Contravariant -> To.Asttypes.Contravariant\n | From.Asttypes.Invariant -> To.Asttypes.Invariant\n\nand copy_value_description :\n From.Parsetree.value_description -> To.Parsetree.value_description =\n fun {\n From.Parsetree.pval_name;\n From.Parsetree.pval_type;\n From.Parsetree.pval_prim;\n From.Parsetree.pval_attributes;\n From.Parsetree.pval_loc;\n } ->\n {\n To.Parsetree.pval_name = copy_loc (fun x -> x) pval_name;\n To.Parsetree.pval_type = copy_core_type pval_type;\n To.Parsetree.pval_prim = List.map (fun x -> x) pval_prim;\n To.Parsetree.pval_attributes = copy_attributes pval_attributes;\n To.Parsetree.pval_loc = copy_location pval_loc;\n }\n\nand copy_arg_label : From.Asttypes.arg_label -> To.Asttypes.arg_label = function\n | From.Asttypes.Nolabel -> To.Asttypes.Nolabel\n | From.Asttypes.Labelled x0 -> To.Asttypes.Labelled x0\n | From.Asttypes.Optional x0 -> To.Asttypes.Optional x0\n\nand copy_closed_flag : From.Asttypes.closed_flag -> To.Asttypes.closed_flag =\n function\n | From.Asttypes.Closed -> To.Asttypes.Closed\n | From.Asttypes.Open -> To.Asttypes.Open\n\nand copy_label : From.Asttypes.label -> To.Asttypes.label = fun x -> x\n\nand copy_rec_flag : From.Asttypes.rec_flag -> To.Asttypes.rec_flag = function\n | From.Asttypes.Nonrecursive -> To.Asttypes.Nonrecursive\n | From.Asttypes.Recursive -> To.Asttypes.Recursive\n\nand copy_constant : From.Parsetree.constant -> To.Parsetree.constant = function\n | From.Parsetree.Pconst_integer (x0, x1) ->\n To.Parsetree.Pconst_integer (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pconst_char x0 -> To.Parsetree.Pconst_char x0\n | From.Parsetree.Pconst_string (x0, x1) ->\n To.Parsetree.Pconst_string (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pconst_float (x0, x1) ->\n To.Parsetree.Pconst_float (x0, copy_option (fun x -> x) x1)\n\nand copy_option : 'f0 'g0. ('f0 -> 'g0) -> 'f0 option -> 'g0 option =\n fun f0 -> function None -> None | Some x0 -> Some (f0 x0)\n\nand copy_longident : Longident.t -> Longident.t = fun x -> x\n\nand copy_loc :\n 'f0 'g0. ('f0 -> 'g0) -> 'f0 From.Asttypes.loc -> 'g0 To.Asttypes.loc =\n fun f0 { From.Asttypes.txt; From.Asttypes.loc } ->\n { To.Asttypes.txt = f0 txt; To.Asttypes.loc = copy_location loc }\n\nand copy_location : Location.t -> Location.t = fun x -> x\nand copy_bool : bool -> bool = function false -> false | true -> true\n\nlet rec copy_toplevel_phrase :\n From.Parsetree.toplevel_phrase -> To.Parsetree.toplevel_phrase = function\n | From.Parsetree.Ptop_def x0 -> To.Parsetree.Ptop_def (copy_structure x0)\n | From.Parsetree.Ptop_dir (x0, x1) ->\n To.Parsetree.Ptop_dir (x0, copy_directive_argument x1)\n\nand copy_directive_argument :\n From.Parsetree.directive_argument -> To.Parsetree.directive_argument =\n function\n | From.Parsetree.Pdir_none -> To.Parsetree.Pdir_none\n | From.Parsetree.Pdir_string x0 -> To.Parsetree.Pdir_string x0\n | From.Parsetree.Pdir_int (x0, x1) ->\n To.Parsetree.Pdir_int (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pdir_ident x0 -> To.Parsetree.Pdir_ident (copy_longident x0)\n | From.Parsetree.Pdir_bool x0 -> To.Parsetree.Pdir_bool (copy_bool x0)\n\nlet copy_cases x = List.map copy_case x\nlet copy_pat = copy_pattern\nlet copy_expr = copy_expression\nlet copy_typ = copy_core_type\n","(**************************************************************************)\n(* *)\n(* OCaml Migrate Parsetree *)\n(* *)\n(* Frédéric Bour *)\n(* Alain Frisch, LexiFi *)\n(* *)\n(* Copyright 2017 Institut National de Recherche en Informatique et *)\n(* en Automatique (INRIA). *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nmodule From = Ast_404\nmodule To = Ast_403\n\nlet from_loc { Location.txt = _; loc } = loc\n\nlet migration_error loc missing_feature =\n Location.raise_errorf ~loc\n \"migration error: %s is not supported before OCaml 4.04\" missing_feature\n\nlet rec copy_expression : From.Parsetree.expression -> To.Parsetree.expression =\n fun {\n From.Parsetree.pexp_desc;\n From.Parsetree.pexp_loc;\n From.Parsetree.pexp_attributes;\n } ->\n {\n To.Parsetree.pexp_desc = copy_expression_desc pexp_loc pexp_desc;\n To.Parsetree.pexp_loc = copy_location pexp_loc;\n To.Parsetree.pexp_attributes = copy_attributes pexp_attributes;\n }\n\nand copy_expression_desc loc :\n From.Parsetree.expression_desc -> To.Parsetree.expression_desc = function\n | From.Parsetree.Pexp_ident x0 ->\n To.Parsetree.Pexp_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pexp_constant x0 ->\n To.Parsetree.Pexp_constant (copy_constant x0)\n | From.Parsetree.Pexp_let (x0, x1, x2) ->\n To.Parsetree.Pexp_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_expression x2)\n | From.Parsetree.Pexp_function x0 ->\n To.Parsetree.Pexp_function (List.map copy_case x0)\n | From.Parsetree.Pexp_fun (x0, x1, x2, x3) ->\n To.Parsetree.Pexp_fun\n ( copy_arg_label x0,\n copy_option copy_expression x1,\n copy_pattern x2,\n copy_expression x3 )\n | From.Parsetree.Pexp_apply (x0, x1) ->\n To.Parsetree.Pexp_apply\n ( copy_expression x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | From.Parsetree.Pexp_match (x0, x1) ->\n To.Parsetree.Pexp_match (copy_expression x0, List.map copy_case x1)\n | From.Parsetree.Pexp_try (x0, x1) ->\n To.Parsetree.Pexp_try (copy_expression x0, List.map copy_case x1)\n | From.Parsetree.Pexp_tuple x0 ->\n To.Parsetree.Pexp_tuple (List.map copy_expression x0)\n | From.Parsetree.Pexp_construct (x0, x1) ->\n To.Parsetree.Pexp_construct\n (copy_loc copy_longident x0, copy_option copy_expression x1)\n | From.Parsetree.Pexp_variant (x0, x1) ->\n To.Parsetree.Pexp_variant (copy_label x0, copy_option copy_expression x1)\n | From.Parsetree.Pexp_record (x0, x1) ->\n To.Parsetree.Pexp_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_expression x1))\n x0,\n copy_option copy_expression x1 )\n | From.Parsetree.Pexp_field (x0, x1) ->\n To.Parsetree.Pexp_field (copy_expression x0, copy_loc copy_longident x1)\n | From.Parsetree.Pexp_setfield (x0, x1, x2) ->\n To.Parsetree.Pexp_setfield\n (copy_expression x0, copy_loc copy_longident x1, copy_expression x2)\n | From.Parsetree.Pexp_array x0 ->\n To.Parsetree.Pexp_array (List.map copy_expression x0)\n | From.Parsetree.Pexp_ifthenelse (x0, x1, x2) ->\n To.Parsetree.Pexp_ifthenelse\n (copy_expression x0, copy_expression x1, copy_option copy_expression x2)\n | From.Parsetree.Pexp_sequence (x0, x1) ->\n To.Parsetree.Pexp_sequence (copy_expression x0, copy_expression x1)\n | From.Parsetree.Pexp_while (x0, x1) ->\n To.Parsetree.Pexp_while (copy_expression x0, copy_expression x1)\n | From.Parsetree.Pexp_for (x0, x1, x2, x3, x4) ->\n To.Parsetree.Pexp_for\n ( copy_pattern x0,\n copy_expression x1,\n copy_expression x2,\n copy_direction_flag x3,\n copy_expression x4 )\n | From.Parsetree.Pexp_constraint (x0, x1) ->\n To.Parsetree.Pexp_constraint (copy_expression x0, copy_core_type x1)\n | From.Parsetree.Pexp_coerce (x0, x1, x2) ->\n To.Parsetree.Pexp_coerce\n (copy_expression x0, copy_option copy_core_type x1, copy_core_type x2)\n | From.Parsetree.Pexp_send (x0, x1) ->\n To.Parsetree.Pexp_send (copy_expression x0, x1)\n | From.Parsetree.Pexp_new x0 ->\n To.Parsetree.Pexp_new (copy_loc copy_longident x0)\n | From.Parsetree.Pexp_setinstvar (x0, x1) ->\n To.Parsetree.Pexp_setinstvar (copy_loc (fun x -> x) x0, copy_expression x1)\n | From.Parsetree.Pexp_override x0 ->\n To.Parsetree.Pexp_override\n (List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_expression x1))\n x0)\n | From.Parsetree.Pexp_letmodule (x0, x1, x2) ->\n To.Parsetree.Pexp_letmodule\n (copy_loc (fun x -> x) x0, copy_module_expr x1, copy_expression x2)\n | From.Parsetree.Pexp_letexception _ -> migration_error loc \"local exceptions\"\n | From.Parsetree.Pexp_assert x0 ->\n To.Parsetree.Pexp_assert (copy_expression x0)\n | From.Parsetree.Pexp_lazy x0 -> To.Parsetree.Pexp_lazy (copy_expression x0)\n | From.Parsetree.Pexp_poly (x0, x1) ->\n To.Parsetree.Pexp_poly (copy_expression x0, copy_option copy_core_type x1)\n | From.Parsetree.Pexp_object x0 ->\n To.Parsetree.Pexp_object (copy_class_structure x0)\n | From.Parsetree.Pexp_newtype (x0, x1) ->\n To.Parsetree.Pexp_newtype (x0, copy_expression x1)\n | From.Parsetree.Pexp_pack x0 -> To.Parsetree.Pexp_pack (copy_module_expr x0)\n | From.Parsetree.Pexp_open (x0, x1, x2) ->\n To.Parsetree.Pexp_open\n (copy_override_flag x0, copy_loc copy_longident x1, copy_expression x2)\n | From.Parsetree.Pexp_extension x0 ->\n To.Parsetree.Pexp_extension (copy_extension x0)\n | From.Parsetree.Pexp_unreachable -> To.Parsetree.Pexp_unreachable\n\nand copy_direction_flag :\n From.Asttypes.direction_flag -> To.Asttypes.direction_flag = function\n | From.Asttypes.Upto -> To.Asttypes.Upto\n | From.Asttypes.Downto -> To.Asttypes.Downto\n\nand copy_case : From.Parsetree.case -> To.Parsetree.case =\n fun { From.Parsetree.pc_lhs; From.Parsetree.pc_guard; From.Parsetree.pc_rhs } ->\n {\n To.Parsetree.pc_lhs = copy_pattern pc_lhs;\n To.Parsetree.pc_guard = copy_option copy_expression pc_guard;\n To.Parsetree.pc_rhs = copy_expression pc_rhs;\n }\n\nand copy_value_binding :\n From.Parsetree.value_binding -> To.Parsetree.value_binding =\n fun {\n From.Parsetree.pvb_pat;\n From.Parsetree.pvb_expr;\n From.Parsetree.pvb_attributes;\n From.Parsetree.pvb_loc;\n } ->\n {\n To.Parsetree.pvb_pat = copy_pattern pvb_pat;\n To.Parsetree.pvb_expr = copy_expression pvb_expr;\n To.Parsetree.pvb_attributes = copy_attributes pvb_attributes;\n To.Parsetree.pvb_loc = copy_location pvb_loc;\n }\n\nand copy_pattern : From.Parsetree.pattern -> To.Parsetree.pattern =\n fun {\n From.Parsetree.ppat_desc;\n From.Parsetree.ppat_loc;\n From.Parsetree.ppat_attributes;\n } ->\n {\n To.Parsetree.ppat_desc = copy_pattern_desc ppat_loc ppat_desc;\n To.Parsetree.ppat_loc = copy_location ppat_loc;\n To.Parsetree.ppat_attributes = copy_attributes ppat_attributes;\n }\n\nand copy_pattern_desc loc :\n From.Parsetree.pattern_desc -> To.Parsetree.pattern_desc = function\n | From.Parsetree.Ppat_any -> To.Parsetree.Ppat_any\n | From.Parsetree.Ppat_var x0 ->\n To.Parsetree.Ppat_var (copy_loc (fun x -> x) x0)\n | From.Parsetree.Ppat_alias (x0, x1) ->\n To.Parsetree.Ppat_alias (copy_pattern x0, copy_loc (fun x -> x) x1)\n | From.Parsetree.Ppat_constant x0 ->\n To.Parsetree.Ppat_constant (copy_constant x0)\n | From.Parsetree.Ppat_interval (x0, x1) ->\n To.Parsetree.Ppat_interval (copy_constant x0, copy_constant x1)\n | From.Parsetree.Ppat_tuple x0 ->\n To.Parsetree.Ppat_tuple (List.map copy_pattern x0)\n | From.Parsetree.Ppat_construct (x0, x1) ->\n To.Parsetree.Ppat_construct\n (copy_loc copy_longident x0, copy_option copy_pattern x1)\n | From.Parsetree.Ppat_variant (x0, x1) ->\n To.Parsetree.Ppat_variant (copy_label x0, copy_option copy_pattern x1)\n | From.Parsetree.Ppat_record (x0, x1) ->\n To.Parsetree.Ppat_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_pattern x1))\n x0,\n copy_closed_flag x1 )\n | From.Parsetree.Ppat_array x0 ->\n To.Parsetree.Ppat_array (List.map copy_pattern x0)\n | From.Parsetree.Ppat_or (x0, x1) ->\n To.Parsetree.Ppat_or (copy_pattern x0, copy_pattern x1)\n | From.Parsetree.Ppat_constraint (x0, x1) ->\n To.Parsetree.Ppat_constraint (copy_pattern x0, copy_core_type x1)\n | From.Parsetree.Ppat_type x0 ->\n To.Parsetree.Ppat_type (copy_loc copy_longident x0)\n | From.Parsetree.Ppat_lazy x0 -> To.Parsetree.Ppat_lazy (copy_pattern x0)\n | From.Parsetree.Ppat_unpack x0 ->\n To.Parsetree.Ppat_unpack (copy_loc (fun x -> x) x0)\n | From.Parsetree.Ppat_exception x0 ->\n To.Parsetree.Ppat_exception (copy_pattern x0)\n | From.Parsetree.Ppat_extension x0 ->\n To.Parsetree.Ppat_extension (copy_extension x0)\n | From.Parsetree.Ppat_open _ -> migration_error loc \"module open in patterns\"\n\nand copy_core_type : From.Parsetree.core_type -> To.Parsetree.core_type =\n fun {\n From.Parsetree.ptyp_desc;\n From.Parsetree.ptyp_loc;\n From.Parsetree.ptyp_attributes;\n } ->\n {\n To.Parsetree.ptyp_desc = copy_core_type_desc ptyp_desc;\n To.Parsetree.ptyp_loc = copy_location ptyp_loc;\n To.Parsetree.ptyp_attributes = copy_attributes ptyp_attributes;\n }\n\nand copy_core_type_desc :\n From.Parsetree.core_type_desc -> To.Parsetree.core_type_desc = function\n | From.Parsetree.Ptyp_any -> To.Parsetree.Ptyp_any\n | From.Parsetree.Ptyp_var x0 -> To.Parsetree.Ptyp_var x0\n | From.Parsetree.Ptyp_arrow (x0, x1, x2) ->\n To.Parsetree.Ptyp_arrow\n (copy_arg_label x0, copy_core_type x1, copy_core_type x2)\n | From.Parsetree.Ptyp_tuple x0 ->\n To.Parsetree.Ptyp_tuple (List.map copy_core_type x0)\n | From.Parsetree.Ptyp_constr (x0, x1) ->\n To.Parsetree.Ptyp_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Ptyp_object (x0, x1) ->\n To.Parsetree.Ptyp_object\n ( List.map\n (fun x ->\n let x0, x1, x2 = x in\n (x0, copy_attributes x1, copy_core_type x2))\n x0,\n copy_closed_flag x1 )\n | From.Parsetree.Ptyp_class (x0, x1) ->\n To.Parsetree.Ptyp_class\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Ptyp_alias (x0, x1) ->\n To.Parsetree.Ptyp_alias (copy_core_type x0, x1)\n | From.Parsetree.Ptyp_variant (x0, x1, x2) ->\n To.Parsetree.Ptyp_variant\n ( List.map copy_row_field x0,\n copy_closed_flag x1,\n copy_option (fun x -> List.map copy_label x) x2 )\n | From.Parsetree.Ptyp_poly (x0, x1) ->\n To.Parsetree.Ptyp_poly (List.map (fun x -> x) x0, copy_core_type x1)\n | From.Parsetree.Ptyp_package x0 ->\n To.Parsetree.Ptyp_package (copy_package_type x0)\n | From.Parsetree.Ptyp_extension x0 ->\n To.Parsetree.Ptyp_extension (copy_extension x0)\n\nand copy_package_type : From.Parsetree.package_type -> To.Parsetree.package_type\n =\n fun x ->\n let x0, x1 = x in\n ( copy_loc copy_longident x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_core_type x1))\n x1 )\n\nand copy_row_field : From.Parsetree.row_field -> To.Parsetree.row_field =\n function\n | From.Parsetree.Rtag (x0, x1, x2, x3) ->\n To.Parsetree.Rtag\n ( copy_label x0,\n copy_attributes x1,\n copy_bool x2,\n List.map copy_core_type x3 )\n | From.Parsetree.Rinherit x0 -> To.Parsetree.Rinherit (copy_core_type x0)\n\nand copy_attributes : From.Parsetree.attributes -> To.Parsetree.attributes =\n fun x -> List.map copy_attribute x\n\nand copy_attribute : From.Parsetree.attribute -> To.Parsetree.attribute =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_payload : From.Parsetree.payload -> To.Parsetree.payload = function\n | From.Parsetree.PStr x0 -> To.Parsetree.PStr (copy_structure x0)\n | From.Parsetree.PSig x0 -> To.Parsetree.PSig (copy_signature x0)\n | From.Parsetree.PTyp x0 -> To.Parsetree.PTyp (copy_core_type x0)\n | From.Parsetree.PPat (x0, x1) ->\n To.Parsetree.PPat (copy_pattern x0, copy_option copy_expression x1)\n\nand copy_structure : From.Parsetree.structure -> To.Parsetree.structure =\n fun x -> List.map copy_structure_item x\n\nand copy_structure_item :\n From.Parsetree.structure_item -> To.Parsetree.structure_item =\n fun { From.Parsetree.pstr_desc; From.Parsetree.pstr_loc } ->\n {\n To.Parsetree.pstr_desc = copy_structure_item_desc pstr_desc;\n To.Parsetree.pstr_loc = copy_location pstr_loc;\n }\n\nand copy_structure_item_desc :\n From.Parsetree.structure_item_desc -> To.Parsetree.structure_item_desc =\n function\n | From.Parsetree.Pstr_eval (x0, x1) ->\n To.Parsetree.Pstr_eval (copy_expression x0, copy_attributes x1)\n | From.Parsetree.Pstr_value (x0, x1) ->\n To.Parsetree.Pstr_value (copy_rec_flag x0, List.map copy_value_binding x1)\n | From.Parsetree.Pstr_primitive x0 ->\n To.Parsetree.Pstr_primitive (copy_value_description x0)\n | From.Parsetree.Pstr_type (x0, x1) ->\n To.Parsetree.Pstr_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | From.Parsetree.Pstr_typext x0 ->\n To.Parsetree.Pstr_typext (copy_type_extension x0)\n | From.Parsetree.Pstr_exception x0 ->\n To.Parsetree.Pstr_exception (copy_extension_constructor x0)\n | From.Parsetree.Pstr_module x0 ->\n To.Parsetree.Pstr_module (copy_module_binding x0)\n | From.Parsetree.Pstr_recmodule x0 ->\n To.Parsetree.Pstr_recmodule (List.map copy_module_binding x0)\n | From.Parsetree.Pstr_modtype x0 ->\n To.Parsetree.Pstr_modtype (copy_module_type_declaration x0)\n | From.Parsetree.Pstr_open x0 ->\n To.Parsetree.Pstr_open (copy_open_description x0)\n | From.Parsetree.Pstr_class x0 ->\n To.Parsetree.Pstr_class (List.map copy_class_declaration x0)\n | From.Parsetree.Pstr_class_type x0 ->\n To.Parsetree.Pstr_class_type (List.map copy_class_type_declaration x0)\n | From.Parsetree.Pstr_include x0 ->\n To.Parsetree.Pstr_include (copy_include_declaration x0)\n | From.Parsetree.Pstr_attribute x0 ->\n To.Parsetree.Pstr_attribute (copy_attribute x0)\n | From.Parsetree.Pstr_extension (x0, x1) ->\n To.Parsetree.Pstr_extension (copy_extension x0, copy_attributes x1)\n\nand copy_include_declaration :\n From.Parsetree.include_declaration -> To.Parsetree.include_declaration =\n fun x -> copy_include_infos copy_module_expr x\n\nand copy_class_declaration :\n From.Parsetree.class_declaration -> To.Parsetree.class_declaration =\n fun x -> copy_class_infos copy_class_expr x\n\nand copy_class_expr : From.Parsetree.class_expr -> To.Parsetree.class_expr =\n fun {\n From.Parsetree.pcl_desc;\n From.Parsetree.pcl_loc;\n From.Parsetree.pcl_attributes;\n } ->\n {\n To.Parsetree.pcl_desc = copy_class_expr_desc pcl_desc;\n To.Parsetree.pcl_loc = copy_location pcl_loc;\n To.Parsetree.pcl_attributes = copy_attributes pcl_attributes;\n }\n\nand copy_class_expr_desc :\n From.Parsetree.class_expr_desc -> To.Parsetree.class_expr_desc = function\n | From.Parsetree.Pcl_constr (x0, x1) ->\n To.Parsetree.Pcl_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Pcl_structure x0 ->\n To.Parsetree.Pcl_structure (copy_class_structure x0)\n | From.Parsetree.Pcl_fun (x0, x1, x2, x3) ->\n To.Parsetree.Pcl_fun\n ( copy_arg_label x0,\n copy_option copy_expression x1,\n copy_pattern x2,\n copy_class_expr x3 )\n | From.Parsetree.Pcl_apply (x0, x1) ->\n To.Parsetree.Pcl_apply\n ( copy_class_expr x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | From.Parsetree.Pcl_let (x0, x1, x2) ->\n To.Parsetree.Pcl_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_class_expr x2)\n | From.Parsetree.Pcl_constraint (x0, x1) ->\n To.Parsetree.Pcl_constraint (copy_class_expr x0, copy_class_type x1)\n | From.Parsetree.Pcl_extension x0 ->\n To.Parsetree.Pcl_extension (copy_extension x0)\n\nand copy_class_structure :\n From.Parsetree.class_structure -> To.Parsetree.class_structure =\n fun { From.Parsetree.pcstr_self; From.Parsetree.pcstr_fields } ->\n {\n To.Parsetree.pcstr_self = copy_pattern pcstr_self;\n To.Parsetree.pcstr_fields = List.map copy_class_field pcstr_fields;\n }\n\nand copy_class_field : From.Parsetree.class_field -> To.Parsetree.class_field =\n fun {\n From.Parsetree.pcf_desc;\n From.Parsetree.pcf_loc;\n From.Parsetree.pcf_attributes;\n } ->\n {\n To.Parsetree.pcf_desc = copy_class_field_desc pcf_desc;\n To.Parsetree.pcf_loc = copy_location pcf_loc;\n To.Parsetree.pcf_attributes = copy_attributes pcf_attributes;\n }\n\nand copy_class_field_desc :\n From.Parsetree.class_field_desc -> To.Parsetree.class_field_desc = function\n | From.Parsetree.Pcf_inherit (x0, x1, x2) ->\n To.Parsetree.Pcf_inherit\n (copy_override_flag x0, copy_class_expr x1, copy_option (fun x -> x) x2)\n | From.Parsetree.Pcf_val x0 ->\n To.Parsetree.Pcf_val\n (let x0, x1, x2 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_mutable_flag x1,\n copy_class_field_kind x2 ))\n | From.Parsetree.Pcf_method x0 ->\n To.Parsetree.Pcf_method\n (let x0, x1, x2 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_private_flag x1,\n copy_class_field_kind x2 ))\n | From.Parsetree.Pcf_constraint x0 ->\n To.Parsetree.Pcf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | From.Parsetree.Pcf_initializer x0 ->\n To.Parsetree.Pcf_initializer (copy_expression x0)\n | From.Parsetree.Pcf_attribute x0 ->\n To.Parsetree.Pcf_attribute (copy_attribute x0)\n | From.Parsetree.Pcf_extension x0 ->\n To.Parsetree.Pcf_extension (copy_extension x0)\n\nand copy_class_field_kind :\n From.Parsetree.class_field_kind -> To.Parsetree.class_field_kind = function\n | From.Parsetree.Cfk_virtual x0 ->\n To.Parsetree.Cfk_virtual (copy_core_type x0)\n | From.Parsetree.Cfk_concrete (x0, x1) ->\n To.Parsetree.Cfk_concrete (copy_override_flag x0, copy_expression x1)\n\nand copy_module_binding :\n From.Parsetree.module_binding -> To.Parsetree.module_binding =\n fun {\n From.Parsetree.pmb_name;\n From.Parsetree.pmb_expr;\n From.Parsetree.pmb_attributes;\n From.Parsetree.pmb_loc;\n } ->\n {\n To.Parsetree.pmb_name = copy_loc (fun x -> x) pmb_name;\n To.Parsetree.pmb_expr = copy_module_expr pmb_expr;\n To.Parsetree.pmb_attributes = copy_attributes pmb_attributes;\n To.Parsetree.pmb_loc = copy_location pmb_loc;\n }\n\nand copy_module_expr : From.Parsetree.module_expr -> To.Parsetree.module_expr =\n fun {\n From.Parsetree.pmod_desc;\n From.Parsetree.pmod_loc;\n From.Parsetree.pmod_attributes;\n } ->\n {\n To.Parsetree.pmod_desc = copy_module_expr_desc pmod_desc;\n To.Parsetree.pmod_loc = copy_location pmod_loc;\n To.Parsetree.pmod_attributes = copy_attributes pmod_attributes;\n }\n\nand copy_module_expr_desc :\n From.Parsetree.module_expr_desc -> To.Parsetree.module_expr_desc = function\n | From.Parsetree.Pmod_ident x0 ->\n To.Parsetree.Pmod_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pmod_structure x0 ->\n To.Parsetree.Pmod_structure (copy_structure x0)\n | From.Parsetree.Pmod_functor (x0, x1, x2) ->\n To.Parsetree.Pmod_functor\n ( copy_loc (fun x -> x) x0,\n copy_option copy_module_type x1,\n copy_module_expr x2 )\n | From.Parsetree.Pmod_apply (x0, x1) ->\n To.Parsetree.Pmod_apply (copy_module_expr x0, copy_module_expr x1)\n | From.Parsetree.Pmod_constraint (x0, x1) ->\n To.Parsetree.Pmod_constraint (copy_module_expr x0, copy_module_type x1)\n | From.Parsetree.Pmod_unpack x0 ->\n To.Parsetree.Pmod_unpack (copy_expression x0)\n | From.Parsetree.Pmod_extension x0 ->\n To.Parsetree.Pmod_extension (copy_extension x0)\n\nand copy_module_type : From.Parsetree.module_type -> To.Parsetree.module_type =\n fun {\n From.Parsetree.pmty_desc;\n From.Parsetree.pmty_loc;\n From.Parsetree.pmty_attributes;\n } ->\n {\n To.Parsetree.pmty_desc = copy_module_type_desc pmty_desc;\n To.Parsetree.pmty_loc = copy_location pmty_loc;\n To.Parsetree.pmty_attributes = copy_attributes pmty_attributes;\n }\n\nand copy_module_type_desc :\n From.Parsetree.module_type_desc -> To.Parsetree.module_type_desc = function\n | From.Parsetree.Pmty_ident x0 ->\n To.Parsetree.Pmty_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pmty_signature x0 ->\n To.Parsetree.Pmty_signature (copy_signature x0)\n | From.Parsetree.Pmty_functor (x0, x1, x2) ->\n To.Parsetree.Pmty_functor\n ( copy_loc (fun x -> x) x0,\n copy_option copy_module_type x1,\n copy_module_type x2 )\n | From.Parsetree.Pmty_with (x0, x1) ->\n To.Parsetree.Pmty_with\n (copy_module_type x0, List.map copy_with_constraint x1)\n | From.Parsetree.Pmty_typeof x0 ->\n To.Parsetree.Pmty_typeof (copy_module_expr x0)\n | From.Parsetree.Pmty_extension x0 ->\n To.Parsetree.Pmty_extension (copy_extension x0)\n | From.Parsetree.Pmty_alias x0 ->\n To.Parsetree.Pmty_alias (copy_loc copy_longident x0)\n\nand copy_with_constraint :\n From.Parsetree.with_constraint -> To.Parsetree.with_constraint = function\n | From.Parsetree.Pwith_type (x0, x1) ->\n To.Parsetree.Pwith_type\n (copy_loc copy_longident x0, copy_type_declaration x1)\n | From.Parsetree.Pwith_module (x0, x1) ->\n To.Parsetree.Pwith_module\n (copy_loc copy_longident x0, copy_loc copy_longident x1)\n | From.Parsetree.Pwith_typesubst x0 ->\n To.Parsetree.Pwith_typesubst (copy_type_declaration x0)\n | From.Parsetree.Pwith_modsubst (x0, x1) ->\n To.Parsetree.Pwith_modsubst\n (copy_loc (fun x -> x) x0, copy_loc copy_longident x1)\n\nand copy_signature : From.Parsetree.signature -> To.Parsetree.signature =\n fun x -> List.map copy_signature_item x\n\nand copy_signature_item :\n From.Parsetree.signature_item -> To.Parsetree.signature_item =\n fun { From.Parsetree.psig_desc; From.Parsetree.psig_loc } ->\n {\n To.Parsetree.psig_desc = copy_signature_item_desc psig_desc;\n To.Parsetree.psig_loc = copy_location psig_loc;\n }\n\nand copy_signature_item_desc :\n From.Parsetree.signature_item_desc -> To.Parsetree.signature_item_desc =\n function\n | From.Parsetree.Psig_value x0 ->\n To.Parsetree.Psig_value (copy_value_description x0)\n | From.Parsetree.Psig_type (x0, x1) ->\n To.Parsetree.Psig_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | From.Parsetree.Psig_typext x0 ->\n To.Parsetree.Psig_typext (copy_type_extension x0)\n | From.Parsetree.Psig_exception x0 ->\n To.Parsetree.Psig_exception (copy_extension_constructor x0)\n | From.Parsetree.Psig_module x0 ->\n To.Parsetree.Psig_module (copy_module_declaration x0)\n | From.Parsetree.Psig_recmodule x0 ->\n To.Parsetree.Psig_recmodule (List.map copy_module_declaration x0)\n | From.Parsetree.Psig_modtype x0 ->\n To.Parsetree.Psig_modtype (copy_module_type_declaration x0)\n | From.Parsetree.Psig_open x0 ->\n To.Parsetree.Psig_open (copy_open_description x0)\n | From.Parsetree.Psig_include x0 ->\n To.Parsetree.Psig_include (copy_include_description x0)\n | From.Parsetree.Psig_class x0 ->\n To.Parsetree.Psig_class (List.map copy_class_description x0)\n | From.Parsetree.Psig_class_type x0 ->\n To.Parsetree.Psig_class_type (List.map copy_class_type_declaration x0)\n | From.Parsetree.Psig_attribute x0 ->\n To.Parsetree.Psig_attribute (copy_attribute x0)\n | From.Parsetree.Psig_extension (x0, x1) ->\n To.Parsetree.Psig_extension (copy_extension x0, copy_attributes x1)\n\nand copy_class_type_declaration :\n From.Parsetree.class_type_declaration -> To.Parsetree.class_type_declaration\n =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_description :\n From.Parsetree.class_description -> To.Parsetree.class_description =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_type : From.Parsetree.class_type -> To.Parsetree.class_type =\n fun {\n From.Parsetree.pcty_desc;\n From.Parsetree.pcty_loc;\n From.Parsetree.pcty_attributes;\n } ->\n {\n To.Parsetree.pcty_desc = copy_class_type_desc pcty_desc;\n To.Parsetree.pcty_loc = copy_location pcty_loc;\n To.Parsetree.pcty_attributes = copy_attributes pcty_attributes;\n }\n\nand copy_class_type_desc :\n From.Parsetree.class_type_desc -> To.Parsetree.class_type_desc = function\n | From.Parsetree.Pcty_constr (x0, x1) ->\n To.Parsetree.Pcty_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Pcty_signature x0 ->\n To.Parsetree.Pcty_signature (copy_class_signature x0)\n | From.Parsetree.Pcty_arrow (x0, x1, x2) ->\n To.Parsetree.Pcty_arrow\n (copy_arg_label x0, copy_core_type x1, copy_class_type x2)\n | From.Parsetree.Pcty_extension x0 ->\n To.Parsetree.Pcty_extension (copy_extension x0)\n\nand copy_class_signature :\n From.Parsetree.class_signature -> To.Parsetree.class_signature =\n fun { From.Parsetree.pcsig_self; From.Parsetree.pcsig_fields } ->\n {\n To.Parsetree.pcsig_self = copy_core_type pcsig_self;\n To.Parsetree.pcsig_fields = List.map copy_class_type_field pcsig_fields;\n }\n\nand copy_class_type_field :\n From.Parsetree.class_type_field -> To.Parsetree.class_type_field =\n fun {\n From.Parsetree.pctf_desc;\n From.Parsetree.pctf_loc;\n From.Parsetree.pctf_attributes;\n } ->\n {\n To.Parsetree.pctf_desc = copy_class_type_field_desc pctf_desc;\n To.Parsetree.pctf_loc = copy_location pctf_loc;\n To.Parsetree.pctf_attributes = copy_attributes pctf_attributes;\n }\n\nand copy_class_type_field_desc :\n From.Parsetree.class_type_field_desc -> To.Parsetree.class_type_field_desc =\n function\n | From.Parsetree.Pctf_inherit x0 ->\n To.Parsetree.Pctf_inherit (copy_class_type x0)\n | From.Parsetree.Pctf_val x0 ->\n To.Parsetree.Pctf_val\n (let x0, x1, x2, x3 = x0 in\n (x0, copy_mutable_flag x1, copy_virtual_flag x2, copy_core_type x3))\n | From.Parsetree.Pctf_method x0 ->\n To.Parsetree.Pctf_method\n (let x0, x1, x2, x3 = x0 in\n (x0, copy_private_flag x1, copy_virtual_flag x2, copy_core_type x3))\n | From.Parsetree.Pctf_constraint x0 ->\n To.Parsetree.Pctf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | From.Parsetree.Pctf_attribute x0 ->\n To.Parsetree.Pctf_attribute (copy_attribute x0)\n | From.Parsetree.Pctf_extension x0 ->\n To.Parsetree.Pctf_extension (copy_extension x0)\n\nand copy_extension : From.Parsetree.extension -> To.Parsetree.extension =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_class_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 From.Parsetree.class_infos ->\n 'g0 To.Parsetree.class_infos =\n fun f0\n {\n From.Parsetree.pci_virt;\n From.Parsetree.pci_params;\n From.Parsetree.pci_name;\n From.Parsetree.pci_expr;\n From.Parsetree.pci_loc;\n From.Parsetree.pci_attributes;\n } ->\n {\n To.Parsetree.pci_virt = copy_virtual_flag pci_virt;\n To.Parsetree.pci_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n pci_params;\n To.Parsetree.pci_name = copy_loc (fun x -> x) pci_name;\n To.Parsetree.pci_expr = f0 pci_expr;\n To.Parsetree.pci_loc = copy_location pci_loc;\n To.Parsetree.pci_attributes = copy_attributes pci_attributes;\n }\n\nand copy_virtual_flag : From.Asttypes.virtual_flag -> To.Asttypes.virtual_flag =\n function\n | From.Asttypes.Virtual -> To.Asttypes.Virtual\n | From.Asttypes.Concrete -> To.Asttypes.Concrete\n\nand copy_include_description :\n From.Parsetree.include_description -> To.Parsetree.include_description =\n fun x -> copy_include_infos copy_module_type x\n\nand copy_include_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 From.Parsetree.include_infos ->\n 'g0 To.Parsetree.include_infos =\n fun f0\n {\n From.Parsetree.pincl_mod;\n From.Parsetree.pincl_loc;\n From.Parsetree.pincl_attributes;\n } ->\n {\n To.Parsetree.pincl_mod = f0 pincl_mod;\n To.Parsetree.pincl_loc = copy_location pincl_loc;\n To.Parsetree.pincl_attributes = copy_attributes pincl_attributes;\n }\n\nand copy_open_description :\n From.Parsetree.open_description -> To.Parsetree.open_description =\n fun {\n From.Parsetree.popen_lid;\n From.Parsetree.popen_override;\n From.Parsetree.popen_loc;\n From.Parsetree.popen_attributes;\n } ->\n {\n To.Parsetree.popen_lid = copy_loc copy_longident popen_lid;\n To.Parsetree.popen_override = copy_override_flag popen_override;\n To.Parsetree.popen_loc = copy_location popen_loc;\n To.Parsetree.popen_attributes = copy_attributes popen_attributes;\n }\n\nand copy_override_flag :\n From.Asttypes.override_flag -> To.Asttypes.override_flag = function\n | From.Asttypes.Override -> To.Asttypes.Override\n | From.Asttypes.Fresh -> To.Asttypes.Fresh\n\nand copy_module_type_declaration :\n From.Parsetree.module_type_declaration ->\n To.Parsetree.module_type_declaration =\n fun {\n From.Parsetree.pmtd_name;\n From.Parsetree.pmtd_type;\n From.Parsetree.pmtd_attributes;\n From.Parsetree.pmtd_loc;\n } ->\n {\n To.Parsetree.pmtd_name = copy_loc (fun x -> x) pmtd_name;\n To.Parsetree.pmtd_type = copy_option copy_module_type pmtd_type;\n To.Parsetree.pmtd_attributes = copy_attributes pmtd_attributes;\n To.Parsetree.pmtd_loc = copy_location pmtd_loc;\n }\n\nand copy_module_declaration :\n From.Parsetree.module_declaration -> To.Parsetree.module_declaration =\n fun {\n From.Parsetree.pmd_name;\n From.Parsetree.pmd_type;\n From.Parsetree.pmd_attributes;\n From.Parsetree.pmd_loc;\n } ->\n {\n To.Parsetree.pmd_name = copy_loc (fun x -> x) pmd_name;\n To.Parsetree.pmd_type = copy_module_type pmd_type;\n To.Parsetree.pmd_attributes = copy_attributes pmd_attributes;\n To.Parsetree.pmd_loc = copy_location pmd_loc;\n }\n\nand copy_type_extension :\n From.Parsetree.type_extension -> To.Parsetree.type_extension =\n fun {\n From.Parsetree.ptyext_path;\n From.Parsetree.ptyext_params;\n From.Parsetree.ptyext_constructors;\n From.Parsetree.ptyext_private;\n From.Parsetree.ptyext_attributes;\n } ->\n {\n To.Parsetree.ptyext_path = copy_loc copy_longident ptyext_path;\n To.Parsetree.ptyext_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptyext_params;\n To.Parsetree.ptyext_constructors =\n List.map copy_extension_constructor ptyext_constructors;\n To.Parsetree.ptyext_private = copy_private_flag ptyext_private;\n To.Parsetree.ptyext_attributes = copy_attributes ptyext_attributes;\n }\n\nand copy_extension_constructor :\n From.Parsetree.extension_constructor -> To.Parsetree.extension_constructor =\n fun {\n From.Parsetree.pext_name;\n From.Parsetree.pext_kind;\n From.Parsetree.pext_loc;\n From.Parsetree.pext_attributes;\n } ->\n {\n To.Parsetree.pext_name = copy_loc (fun x -> x) pext_name;\n To.Parsetree.pext_kind = copy_extension_constructor_kind pext_kind;\n To.Parsetree.pext_loc = copy_location pext_loc;\n To.Parsetree.pext_attributes = copy_attributes pext_attributes;\n }\n\nand copy_extension_constructor_kind :\n From.Parsetree.extension_constructor_kind ->\n To.Parsetree.extension_constructor_kind = function\n | From.Parsetree.Pext_decl (x0, x1) ->\n To.Parsetree.Pext_decl\n (copy_constructor_arguments x0, copy_option copy_core_type x1)\n | From.Parsetree.Pext_rebind x0 ->\n To.Parsetree.Pext_rebind (copy_loc copy_longident x0)\n\nand copy_type_declaration :\n From.Parsetree.type_declaration -> To.Parsetree.type_declaration =\n fun {\n From.Parsetree.ptype_name;\n From.Parsetree.ptype_params;\n From.Parsetree.ptype_cstrs;\n From.Parsetree.ptype_kind;\n From.Parsetree.ptype_private;\n From.Parsetree.ptype_manifest;\n From.Parsetree.ptype_attributes;\n From.Parsetree.ptype_loc;\n } ->\n {\n To.Parsetree.ptype_name = copy_loc (fun x -> x) ptype_name;\n To.Parsetree.ptype_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptype_params;\n To.Parsetree.ptype_cstrs =\n List.map\n (fun x ->\n let x0, x1, x2 = x in\n (copy_core_type x0, copy_core_type x1, copy_location x2))\n ptype_cstrs;\n To.Parsetree.ptype_kind = copy_type_kind ptype_kind;\n To.Parsetree.ptype_private = copy_private_flag ptype_private;\n To.Parsetree.ptype_manifest = copy_option copy_core_type ptype_manifest;\n To.Parsetree.ptype_attributes = copy_attributes ptype_attributes;\n To.Parsetree.ptype_loc = copy_location ptype_loc;\n }\n\nand copy_private_flag : From.Asttypes.private_flag -> To.Asttypes.private_flag =\n function\n | From.Asttypes.Private -> To.Asttypes.Private\n | From.Asttypes.Public -> To.Asttypes.Public\n\nand copy_type_kind : From.Parsetree.type_kind -> To.Parsetree.type_kind =\n function\n | From.Parsetree.Ptype_abstract -> To.Parsetree.Ptype_abstract\n | From.Parsetree.Ptype_variant x0 ->\n To.Parsetree.Ptype_variant (List.map copy_constructor_declaration x0)\n | From.Parsetree.Ptype_record x0 ->\n To.Parsetree.Ptype_record (List.map copy_label_declaration x0)\n | From.Parsetree.Ptype_open -> To.Parsetree.Ptype_open\n\nand copy_constructor_declaration :\n From.Parsetree.constructor_declaration ->\n To.Parsetree.constructor_declaration =\n fun {\n From.Parsetree.pcd_name;\n From.Parsetree.pcd_args;\n From.Parsetree.pcd_res;\n From.Parsetree.pcd_loc;\n From.Parsetree.pcd_attributes;\n } ->\n {\n To.Parsetree.pcd_name = copy_loc (fun x -> x) pcd_name;\n To.Parsetree.pcd_args = copy_constructor_arguments pcd_args;\n To.Parsetree.pcd_res = copy_option copy_core_type pcd_res;\n To.Parsetree.pcd_loc = copy_location pcd_loc;\n To.Parsetree.pcd_attributes = copy_attributes pcd_attributes;\n }\n\nand copy_constructor_arguments :\n From.Parsetree.constructor_arguments -> To.Parsetree.constructor_arguments =\n function\n | From.Parsetree.Pcstr_tuple x0 ->\n To.Parsetree.Pcstr_tuple (List.map copy_core_type x0)\n | From.Parsetree.Pcstr_record x0 ->\n To.Parsetree.Pcstr_record (List.map copy_label_declaration x0)\n\nand copy_label_declaration :\n From.Parsetree.label_declaration -> To.Parsetree.label_declaration =\n fun {\n From.Parsetree.pld_name;\n From.Parsetree.pld_mutable;\n From.Parsetree.pld_type;\n From.Parsetree.pld_loc;\n From.Parsetree.pld_attributes;\n } ->\n {\n To.Parsetree.pld_name = copy_loc (fun x -> x) pld_name;\n To.Parsetree.pld_mutable = copy_mutable_flag pld_mutable;\n To.Parsetree.pld_type = copy_core_type pld_type;\n To.Parsetree.pld_loc = copy_location pld_loc;\n To.Parsetree.pld_attributes = copy_attributes pld_attributes;\n }\n\nand copy_mutable_flag : From.Asttypes.mutable_flag -> To.Asttypes.mutable_flag =\n function\n | From.Asttypes.Immutable -> To.Asttypes.Immutable\n | From.Asttypes.Mutable -> To.Asttypes.Mutable\n\nand copy_variance : From.Asttypes.variance -> To.Asttypes.variance = function\n | From.Asttypes.Covariant -> To.Asttypes.Covariant\n | From.Asttypes.Contravariant -> To.Asttypes.Contravariant\n | From.Asttypes.Invariant -> To.Asttypes.Invariant\n\nand copy_value_description :\n From.Parsetree.value_description -> To.Parsetree.value_description =\n fun {\n From.Parsetree.pval_name;\n From.Parsetree.pval_type;\n From.Parsetree.pval_prim;\n From.Parsetree.pval_attributes;\n From.Parsetree.pval_loc;\n } ->\n {\n To.Parsetree.pval_name = copy_loc (fun x -> x) pval_name;\n To.Parsetree.pval_type = copy_core_type pval_type;\n To.Parsetree.pval_prim = List.map (fun x -> x) pval_prim;\n To.Parsetree.pval_attributes = copy_attributes pval_attributes;\n To.Parsetree.pval_loc = copy_location pval_loc;\n }\n\nand copy_arg_label : From.Asttypes.arg_label -> To.Asttypes.arg_label = function\n | From.Asttypes.Nolabel -> To.Asttypes.Nolabel\n | From.Asttypes.Labelled x0 -> To.Asttypes.Labelled x0\n | From.Asttypes.Optional x0 -> To.Asttypes.Optional x0\n\nand copy_closed_flag : From.Asttypes.closed_flag -> To.Asttypes.closed_flag =\n function\n | From.Asttypes.Closed -> To.Asttypes.Closed\n | From.Asttypes.Open -> To.Asttypes.Open\n\nand copy_label : From.Asttypes.label -> To.Asttypes.label = fun x -> x\n\nand copy_rec_flag : From.Asttypes.rec_flag -> To.Asttypes.rec_flag = function\n | From.Asttypes.Nonrecursive -> To.Asttypes.Nonrecursive\n | From.Asttypes.Recursive -> To.Asttypes.Recursive\n\nand copy_constant : From.Parsetree.constant -> To.Parsetree.constant = function\n | From.Parsetree.Pconst_integer (x0, x1) ->\n To.Parsetree.Pconst_integer (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pconst_char x0 -> To.Parsetree.Pconst_char x0\n | From.Parsetree.Pconst_string (x0, x1) ->\n To.Parsetree.Pconst_string (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pconst_float (x0, x1) ->\n To.Parsetree.Pconst_float (x0, copy_option (fun x -> x) x1)\n\nand copy_option : 'f0 'g0. ('f0 -> 'g0) -> 'f0 option -> 'g0 option =\n fun f0 -> function None -> None | Some x0 -> Some (f0 x0)\n\nand copy_longident : Longident.t -> Longident.t = fun x -> x\n\nand copy_loc :\n 'f0 'g0. ('f0 -> 'g0) -> 'f0 From.Asttypes.loc -> 'g0 To.Asttypes.loc =\n fun f0 { From.Asttypes.txt; From.Asttypes.loc } ->\n { To.Asttypes.txt = f0 txt; To.Asttypes.loc = copy_location loc }\n\nand copy_location : Location.t -> Location.t = fun x -> x\nand copy_bool : bool -> bool = function false -> false | true -> true\n\nlet rec copy_toplevel_phrase :\n From.Parsetree.toplevel_phrase -> To.Parsetree.toplevel_phrase = function\n | From.Parsetree.Ptop_def x0 -> To.Parsetree.Ptop_def (copy_structure x0)\n | From.Parsetree.Ptop_dir (x0, x1) ->\n To.Parsetree.Ptop_dir (x0, copy_directive_argument x1)\n\nand copy_directive_argument :\n From.Parsetree.directive_argument -> To.Parsetree.directive_argument =\n function\n | From.Parsetree.Pdir_none -> To.Parsetree.Pdir_none\n | From.Parsetree.Pdir_string x0 -> To.Parsetree.Pdir_string x0\n | From.Parsetree.Pdir_int (x0, x1) ->\n To.Parsetree.Pdir_int (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pdir_ident x0 -> To.Parsetree.Pdir_ident (copy_longident x0)\n | From.Parsetree.Pdir_bool x0 -> To.Parsetree.Pdir_bool (copy_bool x0)\n\nlet copy_cases x = List.map copy_case x\nlet copy_pat = copy_pattern\nlet copy_expr = copy_expression\nlet copy_typ = copy_core_type\n","(**************************************************************************)\n(* *)\n(* OCaml Migrate Parsetree *)\n(* *)\n(* Frédéric Bour *)\n(* Alain Frisch, LexiFi *)\n(* *)\n(* Copyright 2017 Institut National de Recherche en Informatique et *)\n(* en Automatique (INRIA). *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nmodule From = Ast_403\nmodule To = Ast_404\n\nlet rec copy_expression : From.Parsetree.expression -> To.Parsetree.expression =\n fun {\n From.Parsetree.pexp_desc;\n From.Parsetree.pexp_loc;\n From.Parsetree.pexp_attributes;\n } ->\n {\n To.Parsetree.pexp_desc = copy_expression_desc pexp_desc;\n To.Parsetree.pexp_loc = copy_location pexp_loc;\n To.Parsetree.pexp_attributes = copy_attributes pexp_attributes;\n }\n\nand copy_expression_desc :\n From.Parsetree.expression_desc -> To.Parsetree.expression_desc = function\n | From.Parsetree.Pexp_ident x0 ->\n To.Parsetree.Pexp_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pexp_constant x0 ->\n To.Parsetree.Pexp_constant (copy_constant x0)\n | From.Parsetree.Pexp_let (x0, x1, x2) ->\n To.Parsetree.Pexp_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_expression x2)\n | From.Parsetree.Pexp_function x0 ->\n To.Parsetree.Pexp_function (List.map copy_case x0)\n | From.Parsetree.Pexp_fun (x0, x1, x2, x3) ->\n To.Parsetree.Pexp_fun\n ( copy_arg_label x0,\n copy_option copy_expression x1,\n copy_pattern x2,\n copy_expression x3 )\n | From.Parsetree.Pexp_apply (x0, x1) ->\n To.Parsetree.Pexp_apply\n ( copy_expression x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | From.Parsetree.Pexp_match (x0, x1) ->\n To.Parsetree.Pexp_match (copy_expression x0, List.map copy_case x1)\n | From.Parsetree.Pexp_try (x0, x1) ->\n To.Parsetree.Pexp_try (copy_expression x0, List.map copy_case x1)\n | From.Parsetree.Pexp_tuple x0 ->\n To.Parsetree.Pexp_tuple (List.map copy_expression x0)\n | From.Parsetree.Pexp_construct (x0, x1) ->\n To.Parsetree.Pexp_construct\n (copy_loc copy_longident x0, copy_option copy_expression x1)\n | From.Parsetree.Pexp_variant (x0, x1) ->\n To.Parsetree.Pexp_variant (copy_label x0, copy_option copy_expression x1)\n | From.Parsetree.Pexp_record (x0, x1) ->\n To.Parsetree.Pexp_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_expression x1))\n x0,\n copy_option copy_expression x1 )\n | From.Parsetree.Pexp_field (x0, x1) ->\n To.Parsetree.Pexp_field (copy_expression x0, copy_loc copy_longident x1)\n | From.Parsetree.Pexp_setfield (x0, x1, x2) ->\n To.Parsetree.Pexp_setfield\n (copy_expression x0, copy_loc copy_longident x1, copy_expression x2)\n | From.Parsetree.Pexp_array x0 ->\n To.Parsetree.Pexp_array (List.map copy_expression x0)\n | From.Parsetree.Pexp_ifthenelse (x0, x1, x2) ->\n To.Parsetree.Pexp_ifthenelse\n (copy_expression x0, copy_expression x1, copy_option copy_expression x2)\n | From.Parsetree.Pexp_sequence (x0, x1) ->\n To.Parsetree.Pexp_sequence (copy_expression x0, copy_expression x1)\n | From.Parsetree.Pexp_while (x0, x1) ->\n To.Parsetree.Pexp_while (copy_expression x0, copy_expression x1)\n | From.Parsetree.Pexp_for (x0, x1, x2, x3, x4) ->\n To.Parsetree.Pexp_for\n ( copy_pattern x0,\n copy_expression x1,\n copy_expression x2,\n copy_direction_flag x3,\n copy_expression x4 )\n | From.Parsetree.Pexp_constraint (x0, x1) ->\n To.Parsetree.Pexp_constraint (copy_expression x0, copy_core_type x1)\n | From.Parsetree.Pexp_coerce (x0, x1, x2) ->\n To.Parsetree.Pexp_coerce\n (copy_expression x0, copy_option copy_core_type x1, copy_core_type x2)\n | From.Parsetree.Pexp_send (x0, x1) ->\n To.Parsetree.Pexp_send (copy_expression x0, x1)\n | From.Parsetree.Pexp_new x0 ->\n To.Parsetree.Pexp_new (copy_loc copy_longident x0)\n | From.Parsetree.Pexp_setinstvar (x0, x1) ->\n To.Parsetree.Pexp_setinstvar (copy_loc (fun x -> x) x0, copy_expression x1)\n | From.Parsetree.Pexp_override x0 ->\n To.Parsetree.Pexp_override\n (List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_expression x1))\n x0)\n | From.Parsetree.Pexp_letmodule (x0, x1, x2) ->\n To.Parsetree.Pexp_letmodule\n (copy_loc (fun x -> x) x0, copy_module_expr x1, copy_expression x2)\n | From.Parsetree.Pexp_assert x0 ->\n To.Parsetree.Pexp_assert (copy_expression x0)\n | From.Parsetree.Pexp_lazy x0 -> To.Parsetree.Pexp_lazy (copy_expression x0)\n | From.Parsetree.Pexp_poly (x0, x1) ->\n To.Parsetree.Pexp_poly (copy_expression x0, copy_option copy_core_type x1)\n | From.Parsetree.Pexp_object x0 ->\n To.Parsetree.Pexp_object (copy_class_structure x0)\n | From.Parsetree.Pexp_newtype (x0, x1) ->\n To.Parsetree.Pexp_newtype (x0, copy_expression x1)\n | From.Parsetree.Pexp_pack x0 -> To.Parsetree.Pexp_pack (copy_module_expr x0)\n | From.Parsetree.Pexp_open (x0, x1, x2) ->\n To.Parsetree.Pexp_open\n (copy_override_flag x0, copy_loc copy_longident x1, copy_expression x2)\n | From.Parsetree.Pexp_extension x0 ->\n To.Parsetree.Pexp_extension (copy_extension x0)\n | From.Parsetree.Pexp_unreachable -> To.Parsetree.Pexp_unreachable\n\nand copy_direction_flag :\n From.Asttypes.direction_flag -> To.Asttypes.direction_flag = function\n | From.Asttypes.Upto -> To.Asttypes.Upto\n | From.Asttypes.Downto -> To.Asttypes.Downto\n\nand copy_case : From.Parsetree.case -> To.Parsetree.case =\n fun { From.Parsetree.pc_lhs; From.Parsetree.pc_guard; From.Parsetree.pc_rhs } ->\n {\n To.Parsetree.pc_lhs = copy_pattern pc_lhs;\n To.Parsetree.pc_guard = copy_option copy_expression pc_guard;\n To.Parsetree.pc_rhs = copy_expression pc_rhs;\n }\n\nand copy_value_binding :\n From.Parsetree.value_binding -> To.Parsetree.value_binding =\n fun {\n From.Parsetree.pvb_pat;\n From.Parsetree.pvb_expr;\n From.Parsetree.pvb_attributes;\n From.Parsetree.pvb_loc;\n } ->\n {\n To.Parsetree.pvb_pat = copy_pattern pvb_pat;\n To.Parsetree.pvb_expr = copy_expression pvb_expr;\n To.Parsetree.pvb_attributes = copy_attributes pvb_attributes;\n To.Parsetree.pvb_loc = copy_location pvb_loc;\n }\n\nand copy_pattern : From.Parsetree.pattern -> To.Parsetree.pattern =\n fun {\n From.Parsetree.ppat_desc;\n From.Parsetree.ppat_loc;\n From.Parsetree.ppat_attributes;\n } ->\n {\n To.Parsetree.ppat_desc = copy_pattern_desc ppat_desc;\n To.Parsetree.ppat_loc = copy_location ppat_loc;\n To.Parsetree.ppat_attributes = copy_attributes ppat_attributes;\n }\n\nand copy_pattern_desc : From.Parsetree.pattern_desc -> To.Parsetree.pattern_desc\n = function\n | From.Parsetree.Ppat_any -> To.Parsetree.Ppat_any\n | From.Parsetree.Ppat_var x0 ->\n To.Parsetree.Ppat_var (copy_loc (fun x -> x) x0)\n | From.Parsetree.Ppat_alias (x0, x1) ->\n To.Parsetree.Ppat_alias (copy_pattern x0, copy_loc (fun x -> x) x1)\n | From.Parsetree.Ppat_constant x0 ->\n To.Parsetree.Ppat_constant (copy_constant x0)\n | From.Parsetree.Ppat_interval (x0, x1) ->\n To.Parsetree.Ppat_interval (copy_constant x0, copy_constant x1)\n | From.Parsetree.Ppat_tuple x0 ->\n To.Parsetree.Ppat_tuple (List.map copy_pattern x0)\n | From.Parsetree.Ppat_construct (x0, x1) ->\n To.Parsetree.Ppat_construct\n (copy_loc copy_longident x0, copy_option copy_pattern x1)\n | From.Parsetree.Ppat_variant (x0, x1) ->\n To.Parsetree.Ppat_variant (copy_label x0, copy_option copy_pattern x1)\n | From.Parsetree.Ppat_record (x0, x1) ->\n To.Parsetree.Ppat_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_pattern x1))\n x0,\n copy_closed_flag x1 )\n | From.Parsetree.Ppat_array x0 ->\n To.Parsetree.Ppat_array (List.map copy_pattern x0)\n | From.Parsetree.Ppat_or (x0, x1) ->\n To.Parsetree.Ppat_or (copy_pattern x0, copy_pattern x1)\n | From.Parsetree.Ppat_constraint (x0, x1) ->\n To.Parsetree.Ppat_constraint (copy_pattern x0, copy_core_type x1)\n | From.Parsetree.Ppat_type x0 ->\n To.Parsetree.Ppat_type (copy_loc copy_longident x0)\n | From.Parsetree.Ppat_lazy x0 -> To.Parsetree.Ppat_lazy (copy_pattern x0)\n | From.Parsetree.Ppat_unpack x0 ->\n To.Parsetree.Ppat_unpack (copy_loc (fun x -> x) x0)\n | From.Parsetree.Ppat_exception x0 ->\n To.Parsetree.Ppat_exception (copy_pattern x0)\n | From.Parsetree.Ppat_extension x0 ->\n To.Parsetree.Ppat_extension (copy_extension x0)\n\nand copy_core_type : From.Parsetree.core_type -> To.Parsetree.core_type =\n fun {\n From.Parsetree.ptyp_desc;\n From.Parsetree.ptyp_loc;\n From.Parsetree.ptyp_attributes;\n } ->\n {\n To.Parsetree.ptyp_desc = copy_core_type_desc ptyp_desc;\n To.Parsetree.ptyp_loc = copy_location ptyp_loc;\n To.Parsetree.ptyp_attributes = copy_attributes ptyp_attributes;\n }\n\nand copy_core_type_desc :\n From.Parsetree.core_type_desc -> To.Parsetree.core_type_desc = function\n | From.Parsetree.Ptyp_any -> To.Parsetree.Ptyp_any\n | From.Parsetree.Ptyp_var x0 -> To.Parsetree.Ptyp_var x0\n | From.Parsetree.Ptyp_arrow (x0, x1, x2) ->\n To.Parsetree.Ptyp_arrow\n (copy_arg_label x0, copy_core_type x1, copy_core_type x2)\n | From.Parsetree.Ptyp_tuple x0 ->\n To.Parsetree.Ptyp_tuple (List.map copy_core_type x0)\n | From.Parsetree.Ptyp_constr (x0, x1) ->\n To.Parsetree.Ptyp_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Ptyp_object (x0, x1) ->\n To.Parsetree.Ptyp_object\n ( List.map\n (fun x ->\n let x0, x1, x2 = x in\n (x0, copy_attributes x1, copy_core_type x2))\n x0,\n copy_closed_flag x1 )\n | From.Parsetree.Ptyp_class (x0, x1) ->\n To.Parsetree.Ptyp_class\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Ptyp_alias (x0, x1) ->\n To.Parsetree.Ptyp_alias (copy_core_type x0, x1)\n | From.Parsetree.Ptyp_variant (x0, x1, x2) ->\n To.Parsetree.Ptyp_variant\n ( List.map copy_row_field x0,\n copy_closed_flag x1,\n copy_option (fun x -> List.map copy_label x) x2 )\n | From.Parsetree.Ptyp_poly (x0, x1) ->\n To.Parsetree.Ptyp_poly (List.map (fun x -> x) x0, copy_core_type x1)\n | From.Parsetree.Ptyp_package x0 ->\n To.Parsetree.Ptyp_package (copy_package_type x0)\n | From.Parsetree.Ptyp_extension x0 ->\n To.Parsetree.Ptyp_extension (copy_extension x0)\n\nand copy_package_type : From.Parsetree.package_type -> To.Parsetree.package_type\n =\n fun x ->\n let x0, x1 = x in\n ( copy_loc copy_longident x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_core_type x1))\n x1 )\n\nand copy_row_field : From.Parsetree.row_field -> To.Parsetree.row_field =\n function\n | From.Parsetree.Rtag (x0, x1, x2, x3) ->\n To.Parsetree.Rtag\n ( copy_label x0,\n copy_attributes x1,\n copy_bool x2,\n List.map copy_core_type x3 )\n | From.Parsetree.Rinherit x0 -> To.Parsetree.Rinherit (copy_core_type x0)\n\nand copy_attributes : From.Parsetree.attributes -> To.Parsetree.attributes =\n fun x -> List.map copy_attribute x\n\nand copy_attribute : From.Parsetree.attribute -> To.Parsetree.attribute =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_payload : From.Parsetree.payload -> To.Parsetree.payload = function\n | From.Parsetree.PStr x0 -> To.Parsetree.PStr (copy_structure x0)\n | From.Parsetree.PSig x0 -> To.Parsetree.PSig (copy_signature x0)\n | From.Parsetree.PTyp x0 -> To.Parsetree.PTyp (copy_core_type x0)\n | From.Parsetree.PPat (x0, x1) ->\n To.Parsetree.PPat (copy_pattern x0, copy_option copy_expression x1)\n\nand copy_structure : From.Parsetree.structure -> To.Parsetree.structure =\n fun x -> List.map copy_structure_item x\n\nand copy_structure_item :\n From.Parsetree.structure_item -> To.Parsetree.structure_item =\n fun { From.Parsetree.pstr_desc; From.Parsetree.pstr_loc } ->\n {\n To.Parsetree.pstr_desc = copy_structure_item_desc pstr_desc;\n To.Parsetree.pstr_loc = copy_location pstr_loc;\n }\n\nand copy_structure_item_desc :\n From.Parsetree.structure_item_desc -> To.Parsetree.structure_item_desc =\n function\n | From.Parsetree.Pstr_eval (x0, x1) ->\n To.Parsetree.Pstr_eval (copy_expression x0, copy_attributes x1)\n | From.Parsetree.Pstr_value (x0, x1) ->\n To.Parsetree.Pstr_value (copy_rec_flag x0, List.map copy_value_binding x1)\n | From.Parsetree.Pstr_primitive x0 ->\n To.Parsetree.Pstr_primitive (copy_value_description x0)\n | From.Parsetree.Pstr_type (x0, x1) ->\n To.Parsetree.Pstr_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | From.Parsetree.Pstr_typext x0 ->\n To.Parsetree.Pstr_typext (copy_type_extension x0)\n | From.Parsetree.Pstr_exception x0 ->\n To.Parsetree.Pstr_exception (copy_extension_constructor x0)\n | From.Parsetree.Pstr_module x0 ->\n To.Parsetree.Pstr_module (copy_module_binding x0)\n | From.Parsetree.Pstr_recmodule x0 ->\n To.Parsetree.Pstr_recmodule (List.map copy_module_binding x0)\n | From.Parsetree.Pstr_modtype x0 ->\n To.Parsetree.Pstr_modtype (copy_module_type_declaration x0)\n | From.Parsetree.Pstr_open x0 ->\n To.Parsetree.Pstr_open (copy_open_description x0)\n | From.Parsetree.Pstr_class x0 ->\n To.Parsetree.Pstr_class (List.map copy_class_declaration x0)\n | From.Parsetree.Pstr_class_type x0 ->\n To.Parsetree.Pstr_class_type (List.map copy_class_type_declaration x0)\n | From.Parsetree.Pstr_include x0 ->\n To.Parsetree.Pstr_include (copy_include_declaration x0)\n | From.Parsetree.Pstr_attribute x0 ->\n To.Parsetree.Pstr_attribute (copy_attribute x0)\n | From.Parsetree.Pstr_extension (x0, x1) ->\n To.Parsetree.Pstr_extension (copy_extension x0, copy_attributes x1)\n\nand copy_include_declaration :\n From.Parsetree.include_declaration -> To.Parsetree.include_declaration =\n fun x -> copy_include_infos copy_module_expr x\n\nand copy_class_declaration :\n From.Parsetree.class_declaration -> To.Parsetree.class_declaration =\n fun x -> copy_class_infos copy_class_expr x\n\nand copy_class_expr : From.Parsetree.class_expr -> To.Parsetree.class_expr =\n fun {\n From.Parsetree.pcl_desc;\n From.Parsetree.pcl_loc;\n From.Parsetree.pcl_attributes;\n } ->\n {\n To.Parsetree.pcl_desc = copy_class_expr_desc pcl_desc;\n To.Parsetree.pcl_loc = copy_location pcl_loc;\n To.Parsetree.pcl_attributes = copy_attributes pcl_attributes;\n }\n\nand copy_class_expr_desc :\n From.Parsetree.class_expr_desc -> To.Parsetree.class_expr_desc = function\n | From.Parsetree.Pcl_constr (x0, x1) ->\n To.Parsetree.Pcl_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Pcl_structure x0 ->\n To.Parsetree.Pcl_structure (copy_class_structure x0)\n | From.Parsetree.Pcl_fun (x0, x1, x2, x3) ->\n To.Parsetree.Pcl_fun\n ( copy_arg_label x0,\n copy_option copy_expression x1,\n copy_pattern x2,\n copy_class_expr x3 )\n | From.Parsetree.Pcl_apply (x0, x1) ->\n To.Parsetree.Pcl_apply\n ( copy_class_expr x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | From.Parsetree.Pcl_let (x0, x1, x2) ->\n To.Parsetree.Pcl_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_class_expr x2)\n | From.Parsetree.Pcl_constraint (x0, x1) ->\n To.Parsetree.Pcl_constraint (copy_class_expr x0, copy_class_type x1)\n | From.Parsetree.Pcl_extension x0 ->\n To.Parsetree.Pcl_extension (copy_extension x0)\n\nand copy_class_structure :\n From.Parsetree.class_structure -> To.Parsetree.class_structure =\n fun { From.Parsetree.pcstr_self; From.Parsetree.pcstr_fields } ->\n {\n To.Parsetree.pcstr_self = copy_pattern pcstr_self;\n To.Parsetree.pcstr_fields = List.map copy_class_field pcstr_fields;\n }\n\nand copy_class_field : From.Parsetree.class_field -> To.Parsetree.class_field =\n fun {\n From.Parsetree.pcf_desc;\n From.Parsetree.pcf_loc;\n From.Parsetree.pcf_attributes;\n } ->\n {\n To.Parsetree.pcf_desc = copy_class_field_desc pcf_desc;\n To.Parsetree.pcf_loc = copy_location pcf_loc;\n To.Parsetree.pcf_attributes = copy_attributes pcf_attributes;\n }\n\nand copy_class_field_desc :\n From.Parsetree.class_field_desc -> To.Parsetree.class_field_desc = function\n | From.Parsetree.Pcf_inherit (x0, x1, x2) ->\n To.Parsetree.Pcf_inherit\n (copy_override_flag x0, copy_class_expr x1, copy_option (fun x -> x) x2)\n | From.Parsetree.Pcf_val x0 ->\n To.Parsetree.Pcf_val\n (let x0, x1, x2 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_mutable_flag x1,\n copy_class_field_kind x2 ))\n | From.Parsetree.Pcf_method x0 ->\n To.Parsetree.Pcf_method\n (let x0, x1, x2 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_private_flag x1,\n copy_class_field_kind x2 ))\n | From.Parsetree.Pcf_constraint x0 ->\n To.Parsetree.Pcf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | From.Parsetree.Pcf_initializer x0 ->\n To.Parsetree.Pcf_initializer (copy_expression x0)\n | From.Parsetree.Pcf_attribute x0 ->\n To.Parsetree.Pcf_attribute (copy_attribute x0)\n | From.Parsetree.Pcf_extension x0 ->\n To.Parsetree.Pcf_extension (copy_extension x0)\n\nand copy_class_field_kind :\n From.Parsetree.class_field_kind -> To.Parsetree.class_field_kind = function\n | From.Parsetree.Cfk_virtual x0 ->\n To.Parsetree.Cfk_virtual (copy_core_type x0)\n | From.Parsetree.Cfk_concrete (x0, x1) ->\n To.Parsetree.Cfk_concrete (copy_override_flag x0, copy_expression x1)\n\nand copy_module_binding :\n From.Parsetree.module_binding -> To.Parsetree.module_binding =\n fun {\n From.Parsetree.pmb_name;\n From.Parsetree.pmb_expr;\n From.Parsetree.pmb_attributes;\n From.Parsetree.pmb_loc;\n } ->\n {\n To.Parsetree.pmb_name = copy_loc (fun x -> x) pmb_name;\n To.Parsetree.pmb_expr = copy_module_expr pmb_expr;\n To.Parsetree.pmb_attributes = copy_attributes pmb_attributes;\n To.Parsetree.pmb_loc = copy_location pmb_loc;\n }\n\nand copy_module_expr : From.Parsetree.module_expr -> To.Parsetree.module_expr =\n fun {\n From.Parsetree.pmod_desc;\n From.Parsetree.pmod_loc;\n From.Parsetree.pmod_attributes;\n } ->\n {\n To.Parsetree.pmod_desc = copy_module_expr_desc pmod_desc;\n To.Parsetree.pmod_loc = copy_location pmod_loc;\n To.Parsetree.pmod_attributes = copy_attributes pmod_attributes;\n }\n\nand copy_module_expr_desc :\n From.Parsetree.module_expr_desc -> To.Parsetree.module_expr_desc = function\n | From.Parsetree.Pmod_ident x0 ->\n To.Parsetree.Pmod_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pmod_structure x0 ->\n To.Parsetree.Pmod_structure (copy_structure x0)\n | From.Parsetree.Pmod_functor (x0, x1, x2) ->\n To.Parsetree.Pmod_functor\n ( copy_loc (fun x -> x) x0,\n copy_option copy_module_type x1,\n copy_module_expr x2 )\n | From.Parsetree.Pmod_apply (x0, x1) ->\n To.Parsetree.Pmod_apply (copy_module_expr x0, copy_module_expr x1)\n | From.Parsetree.Pmod_constraint (x0, x1) ->\n To.Parsetree.Pmod_constraint (copy_module_expr x0, copy_module_type x1)\n | From.Parsetree.Pmod_unpack x0 ->\n To.Parsetree.Pmod_unpack (copy_expression x0)\n | From.Parsetree.Pmod_extension x0 ->\n To.Parsetree.Pmod_extension (copy_extension x0)\n\nand copy_module_type : From.Parsetree.module_type -> To.Parsetree.module_type =\n fun {\n From.Parsetree.pmty_desc;\n From.Parsetree.pmty_loc;\n From.Parsetree.pmty_attributes;\n } ->\n {\n To.Parsetree.pmty_desc = copy_module_type_desc pmty_desc;\n To.Parsetree.pmty_loc = copy_location pmty_loc;\n To.Parsetree.pmty_attributes = copy_attributes pmty_attributes;\n }\n\nand copy_module_type_desc :\n From.Parsetree.module_type_desc -> To.Parsetree.module_type_desc = function\n | From.Parsetree.Pmty_ident x0 ->\n To.Parsetree.Pmty_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pmty_signature x0 ->\n To.Parsetree.Pmty_signature (copy_signature x0)\n | From.Parsetree.Pmty_functor (x0, x1, x2) ->\n To.Parsetree.Pmty_functor\n ( copy_loc (fun x -> x) x0,\n copy_option copy_module_type x1,\n copy_module_type x2 )\n | From.Parsetree.Pmty_with (x0, x1) ->\n To.Parsetree.Pmty_with\n (copy_module_type x0, List.map copy_with_constraint x1)\n | From.Parsetree.Pmty_typeof x0 ->\n To.Parsetree.Pmty_typeof (copy_module_expr x0)\n | From.Parsetree.Pmty_extension x0 ->\n To.Parsetree.Pmty_extension (copy_extension x0)\n | From.Parsetree.Pmty_alias x0 ->\n To.Parsetree.Pmty_alias (copy_loc copy_longident x0)\n\nand copy_with_constraint :\n From.Parsetree.with_constraint -> To.Parsetree.with_constraint = function\n | From.Parsetree.Pwith_type (x0, x1) ->\n To.Parsetree.Pwith_type\n (copy_loc copy_longident x0, copy_type_declaration x1)\n | From.Parsetree.Pwith_module (x0, x1) ->\n To.Parsetree.Pwith_module\n (copy_loc copy_longident x0, copy_loc copy_longident x1)\n | From.Parsetree.Pwith_typesubst x0 ->\n To.Parsetree.Pwith_typesubst (copy_type_declaration x0)\n | From.Parsetree.Pwith_modsubst (x0, x1) ->\n To.Parsetree.Pwith_modsubst\n (copy_loc (fun x -> x) x0, copy_loc copy_longident x1)\n\nand copy_signature : From.Parsetree.signature -> To.Parsetree.signature =\n fun x -> List.map copy_signature_item x\n\nand copy_signature_item :\n From.Parsetree.signature_item -> To.Parsetree.signature_item =\n fun { From.Parsetree.psig_desc; From.Parsetree.psig_loc } ->\n {\n To.Parsetree.psig_desc = copy_signature_item_desc psig_desc;\n To.Parsetree.psig_loc = copy_location psig_loc;\n }\n\nand copy_signature_item_desc :\n From.Parsetree.signature_item_desc -> To.Parsetree.signature_item_desc =\n function\n | From.Parsetree.Psig_value x0 ->\n To.Parsetree.Psig_value (copy_value_description x0)\n | From.Parsetree.Psig_type (x0, x1) ->\n To.Parsetree.Psig_type\n (copy_rec_flag x0, List.map copy_type_declaration x1)\n | From.Parsetree.Psig_typext x0 ->\n To.Parsetree.Psig_typext (copy_type_extension x0)\n | From.Parsetree.Psig_exception x0 ->\n To.Parsetree.Psig_exception (copy_extension_constructor x0)\n | From.Parsetree.Psig_module x0 ->\n To.Parsetree.Psig_module (copy_module_declaration x0)\n | From.Parsetree.Psig_recmodule x0 ->\n To.Parsetree.Psig_recmodule (List.map copy_module_declaration x0)\n | From.Parsetree.Psig_modtype x0 ->\n To.Parsetree.Psig_modtype (copy_module_type_declaration x0)\n | From.Parsetree.Psig_open x0 ->\n To.Parsetree.Psig_open (copy_open_description x0)\n | From.Parsetree.Psig_include x0 ->\n To.Parsetree.Psig_include (copy_include_description x0)\n | From.Parsetree.Psig_class x0 ->\n To.Parsetree.Psig_class (List.map copy_class_description x0)\n | From.Parsetree.Psig_class_type x0 ->\n To.Parsetree.Psig_class_type (List.map copy_class_type_declaration x0)\n | From.Parsetree.Psig_attribute x0 ->\n To.Parsetree.Psig_attribute (copy_attribute x0)\n | From.Parsetree.Psig_extension (x0, x1) ->\n To.Parsetree.Psig_extension (copy_extension x0, copy_attributes x1)\n\nand copy_class_type_declaration :\n From.Parsetree.class_type_declaration -> To.Parsetree.class_type_declaration\n =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_description :\n From.Parsetree.class_description -> To.Parsetree.class_description =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_type : From.Parsetree.class_type -> To.Parsetree.class_type =\n fun {\n From.Parsetree.pcty_desc;\n From.Parsetree.pcty_loc;\n From.Parsetree.pcty_attributes;\n } ->\n {\n To.Parsetree.pcty_desc = copy_class_type_desc pcty_desc;\n To.Parsetree.pcty_loc = copy_location pcty_loc;\n To.Parsetree.pcty_attributes = copy_attributes pcty_attributes;\n }\n\nand copy_class_type_desc :\n From.Parsetree.class_type_desc -> To.Parsetree.class_type_desc = function\n | From.Parsetree.Pcty_constr (x0, x1) ->\n To.Parsetree.Pcty_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Pcty_signature x0 ->\n To.Parsetree.Pcty_signature (copy_class_signature x0)\n | From.Parsetree.Pcty_arrow (x0, x1, x2) ->\n To.Parsetree.Pcty_arrow\n (copy_arg_label x0, copy_core_type x1, copy_class_type x2)\n | From.Parsetree.Pcty_extension x0 ->\n To.Parsetree.Pcty_extension (copy_extension x0)\n\nand copy_class_signature :\n From.Parsetree.class_signature -> To.Parsetree.class_signature =\n fun { From.Parsetree.pcsig_self; From.Parsetree.pcsig_fields } ->\n {\n To.Parsetree.pcsig_self = copy_core_type pcsig_self;\n To.Parsetree.pcsig_fields = List.map copy_class_type_field pcsig_fields;\n }\n\nand copy_class_type_field :\n From.Parsetree.class_type_field -> To.Parsetree.class_type_field =\n fun {\n From.Parsetree.pctf_desc;\n From.Parsetree.pctf_loc;\n From.Parsetree.pctf_attributes;\n } ->\n {\n To.Parsetree.pctf_desc = copy_class_type_field_desc pctf_desc;\n To.Parsetree.pctf_loc = copy_location pctf_loc;\n To.Parsetree.pctf_attributes = copy_attributes pctf_attributes;\n }\n\nand copy_class_type_field_desc :\n From.Parsetree.class_type_field_desc -> To.Parsetree.class_type_field_desc =\n function\n | From.Parsetree.Pctf_inherit x0 ->\n To.Parsetree.Pctf_inherit (copy_class_type x0)\n | From.Parsetree.Pctf_val x0 ->\n To.Parsetree.Pctf_val\n (let x0, x1, x2, x3 = x0 in\n (x0, copy_mutable_flag x1, copy_virtual_flag x2, copy_core_type x3))\n | From.Parsetree.Pctf_method x0 ->\n To.Parsetree.Pctf_method\n (let x0, x1, x2, x3 = x0 in\n (x0, copy_private_flag x1, copy_virtual_flag x2, copy_core_type x3))\n | From.Parsetree.Pctf_constraint x0 ->\n To.Parsetree.Pctf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | From.Parsetree.Pctf_attribute x0 ->\n To.Parsetree.Pctf_attribute (copy_attribute x0)\n | From.Parsetree.Pctf_extension x0 ->\n To.Parsetree.Pctf_extension (copy_extension x0)\n\nand copy_extension : From.Parsetree.extension -> To.Parsetree.extension =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_class_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 From.Parsetree.class_infos ->\n 'g0 To.Parsetree.class_infos =\n fun f0\n {\n From.Parsetree.pci_virt;\n From.Parsetree.pci_params;\n From.Parsetree.pci_name;\n From.Parsetree.pci_expr;\n From.Parsetree.pci_loc;\n From.Parsetree.pci_attributes;\n } ->\n {\n To.Parsetree.pci_virt = copy_virtual_flag pci_virt;\n To.Parsetree.pci_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n pci_params;\n To.Parsetree.pci_name = copy_loc (fun x -> x) pci_name;\n To.Parsetree.pci_expr = f0 pci_expr;\n To.Parsetree.pci_loc = copy_location pci_loc;\n To.Parsetree.pci_attributes = copy_attributes pci_attributes;\n }\n\nand copy_virtual_flag : From.Asttypes.virtual_flag -> To.Asttypes.virtual_flag =\n function\n | From.Asttypes.Virtual -> To.Asttypes.Virtual\n | From.Asttypes.Concrete -> To.Asttypes.Concrete\n\nand copy_include_description :\n From.Parsetree.include_description -> To.Parsetree.include_description =\n fun x -> copy_include_infos copy_module_type x\n\nand copy_include_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 From.Parsetree.include_infos ->\n 'g0 To.Parsetree.include_infos =\n fun f0\n {\n From.Parsetree.pincl_mod;\n From.Parsetree.pincl_loc;\n From.Parsetree.pincl_attributes;\n } ->\n {\n To.Parsetree.pincl_mod = f0 pincl_mod;\n To.Parsetree.pincl_loc = copy_location pincl_loc;\n To.Parsetree.pincl_attributes = copy_attributes pincl_attributes;\n }\n\nand copy_open_description :\n From.Parsetree.open_description -> To.Parsetree.open_description =\n fun {\n From.Parsetree.popen_lid;\n From.Parsetree.popen_override;\n From.Parsetree.popen_loc;\n From.Parsetree.popen_attributes;\n } ->\n {\n To.Parsetree.popen_lid = copy_loc copy_longident popen_lid;\n To.Parsetree.popen_override = copy_override_flag popen_override;\n To.Parsetree.popen_loc = copy_location popen_loc;\n To.Parsetree.popen_attributes = copy_attributes popen_attributes;\n }\n\nand copy_override_flag :\n From.Asttypes.override_flag -> To.Asttypes.override_flag = function\n | From.Asttypes.Override -> To.Asttypes.Override\n | From.Asttypes.Fresh -> To.Asttypes.Fresh\n\nand copy_module_type_declaration :\n From.Parsetree.module_type_declaration ->\n To.Parsetree.module_type_declaration =\n fun {\n From.Parsetree.pmtd_name;\n From.Parsetree.pmtd_type;\n From.Parsetree.pmtd_attributes;\n From.Parsetree.pmtd_loc;\n } ->\n {\n To.Parsetree.pmtd_name = copy_loc (fun x -> x) pmtd_name;\n To.Parsetree.pmtd_type = copy_option copy_module_type pmtd_type;\n To.Parsetree.pmtd_attributes = copy_attributes pmtd_attributes;\n To.Parsetree.pmtd_loc = copy_location pmtd_loc;\n }\n\nand copy_module_declaration :\n From.Parsetree.module_declaration -> To.Parsetree.module_declaration =\n fun {\n From.Parsetree.pmd_name;\n From.Parsetree.pmd_type;\n From.Parsetree.pmd_attributes;\n From.Parsetree.pmd_loc;\n } ->\n {\n To.Parsetree.pmd_name = copy_loc (fun x -> x) pmd_name;\n To.Parsetree.pmd_type = copy_module_type pmd_type;\n To.Parsetree.pmd_attributes = copy_attributes pmd_attributes;\n To.Parsetree.pmd_loc = copy_location pmd_loc;\n }\n\nand copy_type_extension :\n From.Parsetree.type_extension -> To.Parsetree.type_extension =\n fun {\n From.Parsetree.ptyext_path;\n From.Parsetree.ptyext_params;\n From.Parsetree.ptyext_constructors;\n From.Parsetree.ptyext_private;\n From.Parsetree.ptyext_attributes;\n } ->\n {\n To.Parsetree.ptyext_path = copy_loc copy_longident ptyext_path;\n To.Parsetree.ptyext_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptyext_params;\n To.Parsetree.ptyext_constructors =\n List.map copy_extension_constructor ptyext_constructors;\n To.Parsetree.ptyext_private = copy_private_flag ptyext_private;\n To.Parsetree.ptyext_attributes = copy_attributes ptyext_attributes;\n }\n\nand copy_extension_constructor :\n From.Parsetree.extension_constructor -> To.Parsetree.extension_constructor =\n fun {\n From.Parsetree.pext_name;\n From.Parsetree.pext_kind;\n From.Parsetree.pext_loc;\n From.Parsetree.pext_attributes;\n } ->\n {\n To.Parsetree.pext_name = copy_loc (fun x -> x) pext_name;\n To.Parsetree.pext_kind = copy_extension_constructor_kind pext_kind;\n To.Parsetree.pext_loc = copy_location pext_loc;\n To.Parsetree.pext_attributes = copy_attributes pext_attributes;\n }\n\nand copy_extension_constructor_kind :\n From.Parsetree.extension_constructor_kind ->\n To.Parsetree.extension_constructor_kind = function\n | From.Parsetree.Pext_decl (x0, x1) ->\n To.Parsetree.Pext_decl\n (copy_constructor_arguments x0, copy_option copy_core_type x1)\n | From.Parsetree.Pext_rebind x0 ->\n To.Parsetree.Pext_rebind (copy_loc copy_longident x0)\n\nand copy_type_declaration :\n From.Parsetree.type_declaration -> To.Parsetree.type_declaration =\n fun {\n From.Parsetree.ptype_name;\n From.Parsetree.ptype_params;\n From.Parsetree.ptype_cstrs;\n From.Parsetree.ptype_kind;\n From.Parsetree.ptype_private;\n From.Parsetree.ptype_manifest;\n From.Parsetree.ptype_attributes;\n From.Parsetree.ptype_loc;\n } ->\n {\n To.Parsetree.ptype_name = copy_loc (fun x -> x) ptype_name;\n To.Parsetree.ptype_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptype_params;\n To.Parsetree.ptype_cstrs =\n List.map\n (fun x ->\n let x0, x1, x2 = x in\n (copy_core_type x0, copy_core_type x1, copy_location x2))\n ptype_cstrs;\n To.Parsetree.ptype_kind = copy_type_kind ptype_kind;\n To.Parsetree.ptype_private = copy_private_flag ptype_private;\n To.Parsetree.ptype_manifest = copy_option copy_core_type ptype_manifest;\n To.Parsetree.ptype_attributes = copy_attributes ptype_attributes;\n To.Parsetree.ptype_loc = copy_location ptype_loc;\n }\n\nand copy_private_flag : From.Asttypes.private_flag -> To.Asttypes.private_flag =\n function\n | From.Asttypes.Private -> To.Asttypes.Private\n | From.Asttypes.Public -> To.Asttypes.Public\n\nand copy_type_kind : From.Parsetree.type_kind -> To.Parsetree.type_kind =\n function\n | From.Parsetree.Ptype_abstract -> To.Parsetree.Ptype_abstract\n | From.Parsetree.Ptype_variant x0 ->\n To.Parsetree.Ptype_variant (List.map copy_constructor_declaration x0)\n | From.Parsetree.Ptype_record x0 ->\n To.Parsetree.Ptype_record (List.map copy_label_declaration x0)\n | From.Parsetree.Ptype_open -> To.Parsetree.Ptype_open\n\nand copy_constructor_declaration :\n From.Parsetree.constructor_declaration ->\n To.Parsetree.constructor_declaration =\n fun {\n From.Parsetree.pcd_name;\n From.Parsetree.pcd_args;\n From.Parsetree.pcd_res;\n From.Parsetree.pcd_loc;\n From.Parsetree.pcd_attributes;\n } ->\n {\n To.Parsetree.pcd_name = copy_loc (fun x -> x) pcd_name;\n To.Parsetree.pcd_args = copy_constructor_arguments pcd_args;\n To.Parsetree.pcd_res = copy_option copy_core_type pcd_res;\n To.Parsetree.pcd_loc = copy_location pcd_loc;\n To.Parsetree.pcd_attributes = copy_attributes pcd_attributes;\n }\n\nand copy_constructor_arguments :\n From.Parsetree.constructor_arguments -> To.Parsetree.constructor_arguments =\n function\n | From.Parsetree.Pcstr_tuple x0 ->\n To.Parsetree.Pcstr_tuple (List.map copy_core_type x0)\n | From.Parsetree.Pcstr_record x0 ->\n To.Parsetree.Pcstr_record (List.map copy_label_declaration x0)\n\nand copy_label_declaration :\n From.Parsetree.label_declaration -> To.Parsetree.label_declaration =\n fun {\n From.Parsetree.pld_name;\n From.Parsetree.pld_mutable;\n From.Parsetree.pld_type;\n From.Parsetree.pld_loc;\n From.Parsetree.pld_attributes;\n } ->\n {\n To.Parsetree.pld_name = copy_loc (fun x -> x) pld_name;\n To.Parsetree.pld_mutable = copy_mutable_flag pld_mutable;\n To.Parsetree.pld_type = copy_core_type pld_type;\n To.Parsetree.pld_loc = copy_location pld_loc;\n To.Parsetree.pld_attributes = copy_attributes pld_attributes;\n }\n\nand copy_mutable_flag : From.Asttypes.mutable_flag -> To.Asttypes.mutable_flag =\n function\n | From.Asttypes.Immutable -> To.Asttypes.Immutable\n | From.Asttypes.Mutable -> To.Asttypes.Mutable\n\nand copy_variance : From.Asttypes.variance -> To.Asttypes.variance = function\n | From.Asttypes.Covariant -> To.Asttypes.Covariant\n | From.Asttypes.Contravariant -> To.Asttypes.Contravariant\n | From.Asttypes.Invariant -> To.Asttypes.Invariant\n\nand copy_value_description :\n From.Parsetree.value_description -> To.Parsetree.value_description =\n fun {\n From.Parsetree.pval_name;\n From.Parsetree.pval_type;\n From.Parsetree.pval_prim;\n From.Parsetree.pval_attributes;\n From.Parsetree.pval_loc;\n } ->\n {\n To.Parsetree.pval_name = copy_loc (fun x -> x) pval_name;\n To.Parsetree.pval_type = copy_core_type pval_type;\n To.Parsetree.pval_prim = List.map (fun x -> x) pval_prim;\n To.Parsetree.pval_attributes = copy_attributes pval_attributes;\n To.Parsetree.pval_loc = copy_location pval_loc;\n }\n\nand copy_arg_label : From.Asttypes.arg_label -> To.Asttypes.arg_label = function\n | From.Asttypes.Nolabel -> To.Asttypes.Nolabel\n | From.Asttypes.Labelled x0 -> To.Asttypes.Labelled x0\n | From.Asttypes.Optional x0 -> To.Asttypes.Optional x0\n\nand copy_closed_flag : From.Asttypes.closed_flag -> To.Asttypes.closed_flag =\n function\n | From.Asttypes.Closed -> To.Asttypes.Closed\n | From.Asttypes.Open -> To.Asttypes.Open\n\nand copy_label : From.Asttypes.label -> To.Asttypes.label = fun x -> x\n\nand copy_rec_flag : From.Asttypes.rec_flag -> To.Asttypes.rec_flag = function\n | From.Asttypes.Nonrecursive -> To.Asttypes.Nonrecursive\n | From.Asttypes.Recursive -> To.Asttypes.Recursive\n\nand copy_constant : From.Parsetree.constant -> To.Parsetree.constant = function\n | From.Parsetree.Pconst_integer (x0, x1) ->\n To.Parsetree.Pconst_integer (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pconst_char x0 -> To.Parsetree.Pconst_char x0\n | From.Parsetree.Pconst_string (x0, x1) ->\n To.Parsetree.Pconst_string (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pconst_float (x0, x1) ->\n To.Parsetree.Pconst_float (x0, copy_option (fun x -> x) x1)\n\nand copy_option : 'f0 'g0. ('f0 -> 'g0) -> 'f0 option -> 'g0 option =\n fun f0 -> function None -> None | Some x0 -> Some (f0 x0)\n\nand copy_longident : Longident.t -> Longident.t = fun x -> x\n\nand copy_loc :\n 'f0 'g0. ('f0 -> 'g0) -> 'f0 From.Asttypes.loc -> 'g0 To.Asttypes.loc =\n fun f0 { From.Asttypes.txt; From.Asttypes.loc } ->\n { To.Asttypes.txt = f0 txt; To.Asttypes.loc = copy_location loc }\n\nand copy_location : Location.t -> Location.t = fun x -> x\nand copy_bool : bool -> bool = function false -> false | true -> true\n\nlet rec copy_toplevel_phrase :\n From.Parsetree.toplevel_phrase -> To.Parsetree.toplevel_phrase = function\n | From.Parsetree.Ptop_def x0 -> To.Parsetree.Ptop_def (copy_structure x0)\n | From.Parsetree.Ptop_dir (x0, x1) ->\n To.Parsetree.Ptop_dir (x0, copy_directive_argument x1)\n\nand copy_directive_argument :\n From.Parsetree.directive_argument -> To.Parsetree.directive_argument =\n function\n | From.Parsetree.Pdir_none -> To.Parsetree.Pdir_none\n | From.Parsetree.Pdir_string x0 -> To.Parsetree.Pdir_string x0\n | From.Parsetree.Pdir_int (x0, x1) ->\n To.Parsetree.Pdir_int (x0, copy_option (fun x -> x) x1)\n | From.Parsetree.Pdir_ident x0 -> To.Parsetree.Pdir_ident (copy_longident x0)\n | From.Parsetree.Pdir_bool x0 -> To.Parsetree.Pdir_bool (copy_bool x0)\n\nlet copy_cases x = List.map copy_case x\nlet copy_pat = copy_pattern\nlet copy_expr = copy_expression\nlet copy_typ = copy_core_type\n","(**************************************************************************)\n(* *)\n(* OCaml Migrate Parsetree *)\n(* *)\n(* Frédéric Bour *)\n(* Alain Frisch, LexiFi *)\n(* *)\n(* Copyright 2017 Institut National de Recherche en Informatique et *)\n(* en Automatique (INRIA). *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\nmodule From = Ast_402\nmodule To = Ast_403\n\nlet extract_predef_option label typ =\n let open From in\n let open Longident in\n match (label, typ.Parsetree.ptyp_desc) with\n | ( To.Asttypes.Optional _,\n From.Parsetree.Ptyp_constr\n ({ Location.txt = Ldot (Lident \"*predef*\", \"option\"); _ }, [ d ]) ) ->\n d\n | _ -> typ\n\nlet rec copy_expression : From.Parsetree.expression -> To.Parsetree.expression =\n fun {\n From.Parsetree.pexp_desc;\n From.Parsetree.pexp_loc;\n From.Parsetree.pexp_attributes;\n } ->\n {\n To.Parsetree.pexp_desc = copy_expression_desc pexp_desc;\n To.Parsetree.pexp_loc = copy_location pexp_loc;\n To.Parsetree.pexp_attributes = copy_attributes pexp_attributes;\n }\n\nand copy_expression_desc :\n From.Parsetree.expression_desc -> To.Parsetree.expression_desc = function\n | From.Parsetree.Pexp_ident x0 ->\n To.Parsetree.Pexp_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pexp_constant x0 ->\n To.Parsetree.Pexp_constant (copy_constant x0)\n | From.Parsetree.Pexp_let (x0, x1, x2) ->\n To.Parsetree.Pexp_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_expression x2)\n | From.Parsetree.Pexp_function x0 ->\n To.Parsetree.Pexp_function (List.map copy_case x0)\n | From.Parsetree.Pexp_fun (x0, x1, x2, x3) ->\n To.Parsetree.Pexp_fun\n ( copy_arg_label x0,\n copy_option copy_expression x1,\n copy_pattern x2,\n copy_expression x3 )\n | From.Parsetree.Pexp_apply (x0, x1) ->\n To.Parsetree.Pexp_apply\n ( copy_expression x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | From.Parsetree.Pexp_match (x0, x1) ->\n To.Parsetree.Pexp_match (copy_expression x0, List.map copy_case x1)\n | From.Parsetree.Pexp_try (x0, x1) ->\n To.Parsetree.Pexp_try (copy_expression x0, List.map copy_case x1)\n | From.Parsetree.Pexp_tuple x0 ->\n To.Parsetree.Pexp_tuple (List.map copy_expression x0)\n | From.Parsetree.Pexp_construct (x0, x1) ->\n To.Parsetree.Pexp_construct\n (copy_loc copy_longident x0, copy_option copy_expression x1)\n | From.Parsetree.Pexp_variant (x0, x1) ->\n To.Parsetree.Pexp_variant (copy_label x0, copy_option copy_expression x1)\n | From.Parsetree.Pexp_record (x0, x1) ->\n To.Parsetree.Pexp_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_expression x1))\n x0,\n copy_option copy_expression x1 )\n | From.Parsetree.Pexp_field (x0, x1) ->\n To.Parsetree.Pexp_field (copy_expression x0, copy_loc copy_longident x1)\n | From.Parsetree.Pexp_setfield (x0, x1, x2) ->\n To.Parsetree.Pexp_setfield\n (copy_expression x0, copy_loc copy_longident x1, copy_expression x2)\n | From.Parsetree.Pexp_array x0 ->\n To.Parsetree.Pexp_array (List.map copy_expression x0)\n | From.Parsetree.Pexp_ifthenelse (x0, x1, x2) ->\n To.Parsetree.Pexp_ifthenelse\n (copy_expression x0, copy_expression x1, copy_option copy_expression x2)\n | From.Parsetree.Pexp_sequence (x0, x1) ->\n To.Parsetree.Pexp_sequence (copy_expression x0, copy_expression x1)\n | From.Parsetree.Pexp_while (x0, x1) ->\n To.Parsetree.Pexp_while (copy_expression x0, copy_expression x1)\n | From.Parsetree.Pexp_for (x0, x1, x2, x3, x4) ->\n To.Parsetree.Pexp_for\n ( copy_pattern x0,\n copy_expression x1,\n copy_expression x2,\n copy_direction_flag x3,\n copy_expression x4 )\n | From.Parsetree.Pexp_constraint (x0, x1) ->\n To.Parsetree.Pexp_constraint (copy_expression x0, copy_core_type x1)\n | From.Parsetree.Pexp_coerce (x0, x1, x2) ->\n To.Parsetree.Pexp_coerce\n (copy_expression x0, copy_option copy_core_type x1, copy_core_type x2)\n | From.Parsetree.Pexp_send (x0, x1) ->\n To.Parsetree.Pexp_send (copy_expression x0, x1)\n | From.Parsetree.Pexp_new x0 ->\n To.Parsetree.Pexp_new (copy_loc copy_longident x0)\n | From.Parsetree.Pexp_setinstvar (x0, x1) ->\n To.Parsetree.Pexp_setinstvar (copy_loc (fun x -> x) x0, copy_expression x1)\n | From.Parsetree.Pexp_override x0 ->\n To.Parsetree.Pexp_override\n (List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_expression x1))\n x0)\n | From.Parsetree.Pexp_letmodule (x0, x1, x2) ->\n To.Parsetree.Pexp_letmodule\n (copy_loc (fun x -> x) x0, copy_module_expr x1, copy_expression x2)\n | From.Parsetree.Pexp_assert x0 ->\n To.Parsetree.Pexp_assert (copy_expression x0)\n | From.Parsetree.Pexp_lazy x0 -> To.Parsetree.Pexp_lazy (copy_expression x0)\n | From.Parsetree.Pexp_poly (x0, x1) ->\n To.Parsetree.Pexp_poly (copy_expression x0, copy_option copy_core_type x1)\n | From.Parsetree.Pexp_object x0 ->\n To.Parsetree.Pexp_object (copy_class_structure x0)\n | From.Parsetree.Pexp_newtype (x0, x1) ->\n To.Parsetree.Pexp_newtype (x0, copy_expression x1)\n | From.Parsetree.Pexp_pack x0 -> To.Parsetree.Pexp_pack (copy_module_expr x0)\n | From.Parsetree.Pexp_open (x0, x1, x2) ->\n To.Parsetree.Pexp_open\n (copy_override_flag x0, copy_loc copy_longident x1, copy_expression x2)\n | From.Parsetree.Pexp_extension x0 ->\n To.Parsetree.Pexp_extension (copy_extension x0)\n\nand copy_direction_flag :\n From.Asttypes.direction_flag -> To.Asttypes.direction_flag = function\n | From.Asttypes.Upto -> To.Asttypes.Upto\n | From.Asttypes.Downto -> To.Asttypes.Downto\n\nand copy_case : From.Parsetree.case -> To.Parsetree.case =\n fun { From.Parsetree.pc_lhs; From.Parsetree.pc_guard; From.Parsetree.pc_rhs } ->\n {\n To.Parsetree.pc_lhs = copy_pattern pc_lhs;\n To.Parsetree.pc_guard = copy_option copy_expression pc_guard;\n To.Parsetree.pc_rhs = copy_expression pc_rhs;\n }\n\nand copy_value_binding :\n From.Parsetree.value_binding -> To.Parsetree.value_binding =\n fun {\n From.Parsetree.pvb_pat;\n From.Parsetree.pvb_expr;\n From.Parsetree.pvb_attributes;\n From.Parsetree.pvb_loc;\n } ->\n {\n To.Parsetree.pvb_pat = copy_pattern pvb_pat;\n To.Parsetree.pvb_expr = copy_expression pvb_expr;\n To.Parsetree.pvb_attributes = copy_attributes pvb_attributes;\n To.Parsetree.pvb_loc = copy_location pvb_loc;\n }\n\nand copy_pattern : From.Parsetree.pattern -> To.Parsetree.pattern =\n fun {\n From.Parsetree.ppat_desc;\n From.Parsetree.ppat_loc;\n From.Parsetree.ppat_attributes;\n } ->\n {\n To.Parsetree.ppat_desc = copy_pattern_desc ppat_desc;\n To.Parsetree.ppat_loc = copy_location ppat_loc;\n To.Parsetree.ppat_attributes = copy_attributes ppat_attributes;\n }\n\nand copy_pattern_desc : From.Parsetree.pattern_desc -> To.Parsetree.pattern_desc\n = function\n | From.Parsetree.Ppat_any -> To.Parsetree.Ppat_any\n | From.Parsetree.Ppat_var x0 ->\n To.Parsetree.Ppat_var (copy_loc (fun x -> x) x0)\n | From.Parsetree.Ppat_alias (x0, x1) ->\n To.Parsetree.Ppat_alias (copy_pattern x0, copy_loc (fun x -> x) x1)\n | From.Parsetree.Ppat_constant x0 ->\n To.Parsetree.Ppat_constant (copy_constant x0)\n | From.Parsetree.Ppat_interval (x0, x1) ->\n To.Parsetree.Ppat_interval (copy_constant x0, copy_constant x1)\n | From.Parsetree.Ppat_tuple x0 ->\n To.Parsetree.Ppat_tuple (List.map copy_pattern x0)\n | From.Parsetree.Ppat_construct (x0, x1) ->\n To.Parsetree.Ppat_construct\n (copy_loc copy_longident x0, copy_option copy_pattern x1)\n | From.Parsetree.Ppat_variant (x0, x1) ->\n To.Parsetree.Ppat_variant (copy_label x0, copy_option copy_pattern x1)\n | From.Parsetree.Ppat_record (x0, x1) ->\n To.Parsetree.Ppat_record\n ( List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_pattern x1))\n x0,\n copy_closed_flag x1 )\n | From.Parsetree.Ppat_array x0 ->\n To.Parsetree.Ppat_array (List.map copy_pattern x0)\n | From.Parsetree.Ppat_or (x0, x1) ->\n To.Parsetree.Ppat_or (copy_pattern x0, copy_pattern x1)\n | From.Parsetree.Ppat_constraint (x0, x1) ->\n To.Parsetree.Ppat_constraint (copy_pattern x0, copy_core_type x1)\n | From.Parsetree.Ppat_type x0 ->\n To.Parsetree.Ppat_type (copy_loc copy_longident x0)\n | From.Parsetree.Ppat_lazy x0 -> To.Parsetree.Ppat_lazy (copy_pattern x0)\n | From.Parsetree.Ppat_unpack x0 ->\n To.Parsetree.Ppat_unpack (copy_loc (fun x -> x) x0)\n | From.Parsetree.Ppat_exception x0 ->\n To.Parsetree.Ppat_exception (copy_pattern x0)\n | From.Parsetree.Ppat_extension x0 ->\n To.Parsetree.Ppat_extension (copy_extension x0)\n\nand copy_core_type : From.Parsetree.core_type -> To.Parsetree.core_type =\n fun {\n From.Parsetree.ptyp_desc;\n From.Parsetree.ptyp_loc;\n From.Parsetree.ptyp_attributes;\n } ->\n {\n To.Parsetree.ptyp_desc = copy_core_type_desc ptyp_desc;\n To.Parsetree.ptyp_loc = copy_location ptyp_loc;\n To.Parsetree.ptyp_attributes = copy_attributes ptyp_attributes;\n }\n\nand copy_core_type_desc :\n From.Parsetree.core_type_desc -> To.Parsetree.core_type_desc = function\n | From.Parsetree.Ptyp_any -> To.Parsetree.Ptyp_any\n | From.Parsetree.Ptyp_var x0 -> To.Parsetree.Ptyp_var x0\n | From.Parsetree.Ptyp_arrow (x0, x1, x2) ->\n let label = copy_arg_label x0 in\n To.Parsetree.Ptyp_arrow\n ( label,\n copy_core_type (extract_predef_option label x1),\n copy_core_type x2 )\n | From.Parsetree.Ptyp_tuple x0 ->\n To.Parsetree.Ptyp_tuple (List.map copy_core_type x0)\n | From.Parsetree.Ptyp_constr (x0, x1) ->\n To.Parsetree.Ptyp_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Ptyp_object (x0, x1) ->\n To.Parsetree.Ptyp_object\n ( List.map\n (fun x ->\n let x0, x1, x2 = x in\n (x0, copy_attributes x1, copy_core_type x2))\n x0,\n copy_closed_flag x1 )\n | From.Parsetree.Ptyp_class (x0, x1) ->\n To.Parsetree.Ptyp_class\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Ptyp_alias (x0, x1) ->\n To.Parsetree.Ptyp_alias (copy_core_type x0, x1)\n | From.Parsetree.Ptyp_variant (x0, x1, x2) ->\n To.Parsetree.Ptyp_variant\n ( List.map copy_row_field x0,\n copy_closed_flag x1,\n copy_option (fun x -> List.map copy_label x) x2 )\n | From.Parsetree.Ptyp_poly (x0, x1) ->\n To.Parsetree.Ptyp_poly (List.map (fun x -> x) x0, copy_core_type x1)\n | From.Parsetree.Ptyp_package x0 ->\n To.Parsetree.Ptyp_package (copy_package_type x0)\n | From.Parsetree.Ptyp_extension x0 ->\n To.Parsetree.Ptyp_extension (copy_extension x0)\n\nand copy_package_type : From.Parsetree.package_type -> To.Parsetree.package_type\n =\n fun x ->\n let x0, x1 = x in\n ( copy_loc copy_longident x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_loc copy_longident x0, copy_core_type x1))\n x1 )\n\nand copy_row_field : From.Parsetree.row_field -> To.Parsetree.row_field =\n function\n | From.Parsetree.Rtag (x0, x1, x2, x3) ->\n To.Parsetree.Rtag\n ( copy_label x0,\n copy_attributes x1,\n copy_bool x2,\n List.map copy_core_type x3 )\n | From.Parsetree.Rinherit x0 -> To.Parsetree.Rinherit (copy_core_type x0)\n\nand copy_attributes : From.Parsetree.attributes -> To.Parsetree.attributes =\n fun x -> List.map copy_attribute x\n\nand copy_attribute : From.Parsetree.attribute -> To.Parsetree.attribute =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_payload : From.Parsetree.payload -> To.Parsetree.payload = function\n | From.Parsetree.PStr x0 -> To.Parsetree.PStr (copy_structure x0)\n | From.Parsetree.PTyp x0 -> To.Parsetree.PTyp (copy_core_type x0)\n | From.Parsetree.PPat (x0, x1) ->\n To.Parsetree.PPat (copy_pattern x0, copy_option copy_expression x1)\n\nand copy_structure : From.Parsetree.structure -> To.Parsetree.structure =\n fun x -> List.map copy_structure_item x\n\nand copy_structure_item :\n From.Parsetree.structure_item -> To.Parsetree.structure_item =\n fun { From.Parsetree.pstr_desc; From.Parsetree.pstr_loc } ->\n {\n To.Parsetree.pstr_desc = copy_structure_item_desc pstr_desc;\n To.Parsetree.pstr_loc = copy_location pstr_loc;\n }\n\nand copy_structure_item_desc :\n From.Parsetree.structure_item_desc -> To.Parsetree.structure_item_desc =\n function\n | From.Parsetree.Pstr_eval (x0, x1) ->\n To.Parsetree.Pstr_eval (copy_expression x0, copy_attributes x1)\n | From.Parsetree.Pstr_value (x0, x1) ->\n To.Parsetree.Pstr_value (copy_rec_flag x0, List.map copy_value_binding x1)\n | From.Parsetree.Pstr_primitive x0 ->\n To.Parsetree.Pstr_primitive (copy_value_description x0)\n | From.Parsetree.Pstr_type x0 ->\n let recflag, types = type_declarations x0 in\n To.Parsetree.Pstr_type (recflag, types)\n | From.Parsetree.Pstr_typext x0 ->\n To.Parsetree.Pstr_typext (copy_type_extension x0)\n | From.Parsetree.Pstr_exception x0 ->\n To.Parsetree.Pstr_exception (copy_extension_constructor x0)\n | From.Parsetree.Pstr_module x0 ->\n To.Parsetree.Pstr_module (copy_module_binding x0)\n | From.Parsetree.Pstr_recmodule x0 ->\n To.Parsetree.Pstr_recmodule (List.map copy_module_binding x0)\n | From.Parsetree.Pstr_modtype x0 ->\n To.Parsetree.Pstr_modtype (copy_module_type_declaration x0)\n | From.Parsetree.Pstr_open x0 ->\n To.Parsetree.Pstr_open (copy_open_description x0)\n | From.Parsetree.Pstr_class x0 ->\n To.Parsetree.Pstr_class (List.map copy_class_declaration x0)\n | From.Parsetree.Pstr_class_type x0 ->\n To.Parsetree.Pstr_class_type (List.map copy_class_type_declaration x0)\n | From.Parsetree.Pstr_include x0 ->\n To.Parsetree.Pstr_include (copy_include_declaration x0)\n | From.Parsetree.Pstr_attribute x0 ->\n To.Parsetree.Pstr_attribute (copy_attribute x0)\n | From.Parsetree.Pstr_extension (x0, x1) ->\n To.Parsetree.Pstr_extension (copy_extension x0, copy_attributes x1)\n\nand copy_include_declaration :\n From.Parsetree.include_declaration -> To.Parsetree.include_declaration =\n fun x -> copy_include_infos copy_module_expr x\n\nand copy_class_declaration :\n From.Parsetree.class_declaration -> To.Parsetree.class_declaration =\n fun x -> copy_class_infos copy_class_expr x\n\nand copy_class_expr : From.Parsetree.class_expr -> To.Parsetree.class_expr =\n fun {\n From.Parsetree.pcl_desc;\n From.Parsetree.pcl_loc;\n From.Parsetree.pcl_attributes;\n } ->\n {\n To.Parsetree.pcl_desc = copy_class_expr_desc pcl_desc;\n To.Parsetree.pcl_loc = copy_location pcl_loc;\n To.Parsetree.pcl_attributes = copy_attributes pcl_attributes;\n }\n\nand copy_class_expr_desc :\n From.Parsetree.class_expr_desc -> To.Parsetree.class_expr_desc = function\n | From.Parsetree.Pcl_constr (x0, x1) ->\n To.Parsetree.Pcl_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Pcl_structure x0 ->\n To.Parsetree.Pcl_structure (copy_class_structure x0)\n | From.Parsetree.Pcl_fun (x0, x1, x2, x3) ->\n To.Parsetree.Pcl_fun\n ( copy_arg_label x0,\n copy_option copy_expression x1,\n copy_pattern x2,\n copy_class_expr x3 )\n | From.Parsetree.Pcl_apply (x0, x1) ->\n To.Parsetree.Pcl_apply\n ( copy_class_expr x0,\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_arg_label x0, copy_expression x1))\n x1 )\n | From.Parsetree.Pcl_let (x0, x1, x2) ->\n To.Parsetree.Pcl_let\n (copy_rec_flag x0, List.map copy_value_binding x1, copy_class_expr x2)\n | From.Parsetree.Pcl_constraint (x0, x1) ->\n To.Parsetree.Pcl_constraint (copy_class_expr x0, copy_class_type x1)\n | From.Parsetree.Pcl_extension x0 ->\n To.Parsetree.Pcl_extension (copy_extension x0)\n\nand copy_class_structure :\n From.Parsetree.class_structure -> To.Parsetree.class_structure =\n fun { From.Parsetree.pcstr_self; From.Parsetree.pcstr_fields } ->\n {\n To.Parsetree.pcstr_self = copy_pattern pcstr_self;\n To.Parsetree.pcstr_fields = List.map copy_class_field pcstr_fields;\n }\n\nand copy_class_field : From.Parsetree.class_field -> To.Parsetree.class_field =\n fun {\n From.Parsetree.pcf_desc;\n From.Parsetree.pcf_loc;\n From.Parsetree.pcf_attributes;\n } ->\n {\n To.Parsetree.pcf_desc = copy_class_field_desc pcf_desc;\n To.Parsetree.pcf_loc = copy_location pcf_loc;\n To.Parsetree.pcf_attributes = copy_attributes pcf_attributes;\n }\n\nand copy_class_field_desc :\n From.Parsetree.class_field_desc -> To.Parsetree.class_field_desc = function\n | From.Parsetree.Pcf_inherit (x0, x1, x2) ->\n To.Parsetree.Pcf_inherit\n (copy_override_flag x0, copy_class_expr x1, copy_option (fun x -> x) x2)\n | From.Parsetree.Pcf_val x0 ->\n To.Parsetree.Pcf_val\n (let x0, x1, x2 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_mutable_flag x1,\n copy_class_field_kind x2 ))\n | From.Parsetree.Pcf_method x0 ->\n To.Parsetree.Pcf_method\n (let x0, x1, x2 = x0 in\n ( copy_loc (fun x -> x) x0,\n copy_private_flag x1,\n copy_class_field_kind x2 ))\n | From.Parsetree.Pcf_constraint x0 ->\n To.Parsetree.Pcf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | From.Parsetree.Pcf_initializer x0 ->\n To.Parsetree.Pcf_initializer (copy_expression x0)\n | From.Parsetree.Pcf_attribute x0 ->\n To.Parsetree.Pcf_attribute (copy_attribute x0)\n | From.Parsetree.Pcf_extension x0 ->\n To.Parsetree.Pcf_extension (copy_extension x0)\n\nand copy_class_field_kind :\n From.Parsetree.class_field_kind -> To.Parsetree.class_field_kind = function\n | From.Parsetree.Cfk_virtual x0 ->\n To.Parsetree.Cfk_virtual (copy_core_type x0)\n | From.Parsetree.Cfk_concrete (x0, x1) ->\n To.Parsetree.Cfk_concrete (copy_override_flag x0, copy_expression x1)\n\nand copy_module_binding :\n From.Parsetree.module_binding -> To.Parsetree.module_binding =\n fun {\n From.Parsetree.pmb_name;\n From.Parsetree.pmb_expr;\n From.Parsetree.pmb_attributes;\n From.Parsetree.pmb_loc;\n } ->\n {\n To.Parsetree.pmb_name = copy_loc (fun x -> x) pmb_name;\n To.Parsetree.pmb_expr = copy_module_expr pmb_expr;\n To.Parsetree.pmb_attributes = copy_attributes pmb_attributes;\n To.Parsetree.pmb_loc = copy_location pmb_loc;\n }\n\nand copy_module_expr : From.Parsetree.module_expr -> To.Parsetree.module_expr =\n fun {\n From.Parsetree.pmod_desc;\n From.Parsetree.pmod_loc;\n From.Parsetree.pmod_attributes;\n } ->\n {\n To.Parsetree.pmod_desc = copy_module_expr_desc pmod_desc;\n To.Parsetree.pmod_loc = copy_location pmod_loc;\n To.Parsetree.pmod_attributes = copy_attributes pmod_attributes;\n }\n\nand copy_module_expr_desc :\n From.Parsetree.module_expr_desc -> To.Parsetree.module_expr_desc = function\n | From.Parsetree.Pmod_ident x0 ->\n To.Parsetree.Pmod_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pmod_structure x0 ->\n To.Parsetree.Pmod_structure (copy_structure x0)\n | From.Parsetree.Pmod_functor (x0, x1, x2) ->\n To.Parsetree.Pmod_functor\n ( copy_loc (fun x -> x) x0,\n copy_option copy_module_type x1,\n copy_module_expr x2 )\n | From.Parsetree.Pmod_apply (x0, x1) ->\n To.Parsetree.Pmod_apply (copy_module_expr x0, copy_module_expr x1)\n | From.Parsetree.Pmod_constraint (x0, x1) ->\n To.Parsetree.Pmod_constraint (copy_module_expr x0, copy_module_type x1)\n | From.Parsetree.Pmod_unpack x0 ->\n To.Parsetree.Pmod_unpack (copy_expression x0)\n | From.Parsetree.Pmod_extension x0 ->\n To.Parsetree.Pmod_extension (copy_extension x0)\n\nand copy_module_type : From.Parsetree.module_type -> To.Parsetree.module_type =\n fun {\n From.Parsetree.pmty_desc;\n From.Parsetree.pmty_loc;\n From.Parsetree.pmty_attributes;\n } ->\n {\n To.Parsetree.pmty_desc = copy_module_type_desc pmty_desc;\n To.Parsetree.pmty_loc = copy_location pmty_loc;\n To.Parsetree.pmty_attributes = copy_attributes pmty_attributes;\n }\n\nand copy_module_type_desc :\n From.Parsetree.module_type_desc -> To.Parsetree.module_type_desc = function\n | From.Parsetree.Pmty_ident x0 ->\n To.Parsetree.Pmty_ident (copy_loc copy_longident x0)\n | From.Parsetree.Pmty_signature x0 ->\n To.Parsetree.Pmty_signature (copy_signature x0)\n | From.Parsetree.Pmty_functor (x0, x1, x2) ->\n To.Parsetree.Pmty_functor\n ( copy_loc (fun x -> x) x0,\n copy_option copy_module_type x1,\n copy_module_type x2 )\n | From.Parsetree.Pmty_with (x0, x1) ->\n To.Parsetree.Pmty_with\n (copy_module_type x0, List.map copy_with_constraint x1)\n | From.Parsetree.Pmty_typeof x0 ->\n To.Parsetree.Pmty_typeof (copy_module_expr x0)\n | From.Parsetree.Pmty_extension x0 ->\n To.Parsetree.Pmty_extension (copy_extension x0)\n | From.Parsetree.Pmty_alias x0 ->\n To.Parsetree.Pmty_alias (copy_loc copy_longident x0)\n\nand copy_with_constraint :\n From.Parsetree.with_constraint -> To.Parsetree.with_constraint = function\n | From.Parsetree.Pwith_type (x0, x1) ->\n To.Parsetree.Pwith_type\n (copy_loc copy_longident x0, copy_type_declaration x1)\n | From.Parsetree.Pwith_module (x0, x1) ->\n To.Parsetree.Pwith_module\n (copy_loc copy_longident x0, copy_loc copy_longident x1)\n | From.Parsetree.Pwith_typesubst x0 ->\n To.Parsetree.Pwith_typesubst (copy_type_declaration x0)\n | From.Parsetree.Pwith_modsubst (x0, x1) ->\n To.Parsetree.Pwith_modsubst\n (copy_loc (fun x -> x) x0, copy_loc copy_longident x1)\n\nand copy_signature : From.Parsetree.signature -> To.Parsetree.signature =\n fun x -> List.map copy_signature_item x\n\nand copy_signature_item :\n From.Parsetree.signature_item -> To.Parsetree.signature_item =\n fun { From.Parsetree.psig_desc; From.Parsetree.psig_loc } ->\n {\n To.Parsetree.psig_desc = copy_signature_item_desc psig_desc;\n To.Parsetree.psig_loc = copy_location psig_loc;\n }\n\nand copy_signature_item_desc :\n From.Parsetree.signature_item_desc -> To.Parsetree.signature_item_desc =\n function\n | From.Parsetree.Psig_value x0 ->\n To.Parsetree.Psig_value (copy_value_description x0)\n | From.Parsetree.Psig_type x0 ->\n let recflag, types = type_declarations x0 in\n To.Parsetree.Psig_type (recflag, types)\n | From.Parsetree.Psig_typext x0 ->\n To.Parsetree.Psig_typext (copy_type_extension x0)\n | From.Parsetree.Psig_exception x0 ->\n To.Parsetree.Psig_exception (copy_extension_constructor x0)\n | From.Parsetree.Psig_module x0 ->\n To.Parsetree.Psig_module (copy_module_declaration x0)\n | From.Parsetree.Psig_recmodule x0 ->\n To.Parsetree.Psig_recmodule (List.map copy_module_declaration x0)\n | From.Parsetree.Psig_modtype x0 ->\n To.Parsetree.Psig_modtype (copy_module_type_declaration x0)\n | From.Parsetree.Psig_open x0 ->\n To.Parsetree.Psig_open (copy_open_description x0)\n | From.Parsetree.Psig_include x0 ->\n To.Parsetree.Psig_include (copy_include_description x0)\n | From.Parsetree.Psig_class x0 ->\n To.Parsetree.Psig_class (List.map copy_class_description x0)\n | From.Parsetree.Psig_class_type x0 ->\n To.Parsetree.Psig_class_type (List.map copy_class_type_declaration x0)\n | From.Parsetree.Psig_attribute x0 ->\n To.Parsetree.Psig_attribute (copy_attribute x0)\n | From.Parsetree.Psig_extension (x0, x1) ->\n To.Parsetree.Psig_extension (copy_extension x0, copy_attributes x1)\n\nand copy_class_type_declaration :\n From.Parsetree.class_type_declaration -> To.Parsetree.class_type_declaration\n =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_description :\n From.Parsetree.class_description -> To.Parsetree.class_description =\n fun x -> copy_class_infos copy_class_type x\n\nand copy_class_type : From.Parsetree.class_type -> To.Parsetree.class_type =\n fun {\n From.Parsetree.pcty_desc;\n From.Parsetree.pcty_loc;\n From.Parsetree.pcty_attributes;\n } ->\n {\n To.Parsetree.pcty_desc = copy_class_type_desc pcty_desc;\n To.Parsetree.pcty_loc = copy_location pcty_loc;\n To.Parsetree.pcty_attributes = copy_attributes pcty_attributes;\n }\n\nand copy_class_type_desc :\n From.Parsetree.class_type_desc -> To.Parsetree.class_type_desc = function\n | From.Parsetree.Pcty_constr (x0, x1) ->\n To.Parsetree.Pcty_constr\n (copy_loc copy_longident x0, List.map copy_core_type x1)\n | From.Parsetree.Pcty_signature x0 ->\n To.Parsetree.Pcty_signature (copy_class_signature x0)\n | From.Parsetree.Pcty_arrow (x0, x1, x2) ->\n let label = copy_arg_label x0 in\n To.Parsetree.Pcty_arrow\n ( label,\n copy_core_type (extract_predef_option label x1),\n copy_class_type x2 )\n | From.Parsetree.Pcty_extension x0 ->\n To.Parsetree.Pcty_extension (copy_extension x0)\n\nand copy_class_signature :\n From.Parsetree.class_signature -> To.Parsetree.class_signature =\n fun { From.Parsetree.pcsig_self; From.Parsetree.pcsig_fields } ->\n {\n To.Parsetree.pcsig_self = copy_core_type pcsig_self;\n To.Parsetree.pcsig_fields = List.map copy_class_type_field pcsig_fields;\n }\n\nand copy_class_type_field :\n From.Parsetree.class_type_field -> To.Parsetree.class_type_field =\n fun {\n From.Parsetree.pctf_desc;\n From.Parsetree.pctf_loc;\n From.Parsetree.pctf_attributes;\n } ->\n {\n To.Parsetree.pctf_desc = copy_class_type_field_desc pctf_desc;\n To.Parsetree.pctf_loc = copy_location pctf_loc;\n To.Parsetree.pctf_attributes = copy_attributes pctf_attributes;\n }\n\nand copy_class_type_field_desc :\n From.Parsetree.class_type_field_desc -> To.Parsetree.class_type_field_desc =\n function\n | From.Parsetree.Pctf_inherit x0 ->\n To.Parsetree.Pctf_inherit (copy_class_type x0)\n | From.Parsetree.Pctf_val x0 ->\n To.Parsetree.Pctf_val\n (let x0, x1, x2, x3 = x0 in\n (x0, copy_mutable_flag x1, copy_virtual_flag x2, copy_core_type x3))\n | From.Parsetree.Pctf_method x0 ->\n To.Parsetree.Pctf_method\n (let x0, x1, x2, x3 = x0 in\n (x0, copy_private_flag x1, copy_virtual_flag x2, copy_core_type x3))\n | From.Parsetree.Pctf_constraint x0 ->\n To.Parsetree.Pctf_constraint\n (let x0, x1 = x0 in\n (copy_core_type x0, copy_core_type x1))\n | From.Parsetree.Pctf_attribute x0 ->\n To.Parsetree.Pctf_attribute (copy_attribute x0)\n | From.Parsetree.Pctf_extension x0 ->\n To.Parsetree.Pctf_extension (copy_extension x0)\n\nand copy_extension : From.Parsetree.extension -> To.Parsetree.extension =\n fun x ->\n let x0, x1 = x in\n (copy_loc (fun x -> x) x0, copy_payload x1)\n\nand copy_class_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 From.Parsetree.class_infos ->\n 'g0 To.Parsetree.class_infos =\n fun f0\n {\n From.Parsetree.pci_virt;\n From.Parsetree.pci_params;\n From.Parsetree.pci_name;\n From.Parsetree.pci_expr;\n From.Parsetree.pci_loc;\n From.Parsetree.pci_attributes;\n } ->\n {\n To.Parsetree.pci_virt = copy_virtual_flag pci_virt;\n To.Parsetree.pci_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n pci_params;\n To.Parsetree.pci_name = copy_loc (fun x -> x) pci_name;\n To.Parsetree.pci_expr = f0 pci_expr;\n To.Parsetree.pci_loc = copy_location pci_loc;\n To.Parsetree.pci_attributes = copy_attributes pci_attributes;\n }\n\nand copy_virtual_flag : From.Asttypes.virtual_flag -> To.Asttypes.virtual_flag =\n function\n | From.Asttypes.Virtual -> To.Asttypes.Virtual\n | From.Asttypes.Concrete -> To.Asttypes.Concrete\n\nand copy_include_description :\n From.Parsetree.include_description -> To.Parsetree.include_description =\n fun x -> copy_include_infos copy_module_type x\n\nand copy_include_infos :\n 'f0 'g0.\n ('f0 -> 'g0) ->\n 'f0 From.Parsetree.include_infos ->\n 'g0 To.Parsetree.include_infos =\n fun f0\n {\n From.Parsetree.pincl_mod;\n From.Parsetree.pincl_loc;\n From.Parsetree.pincl_attributes;\n } ->\n {\n To.Parsetree.pincl_mod = f0 pincl_mod;\n To.Parsetree.pincl_loc = copy_location pincl_loc;\n To.Parsetree.pincl_attributes = copy_attributes pincl_attributes;\n }\n\nand copy_open_description :\n From.Parsetree.open_description -> To.Parsetree.open_description =\n fun {\n From.Parsetree.popen_lid;\n From.Parsetree.popen_override;\n From.Parsetree.popen_loc;\n From.Parsetree.popen_attributes;\n } ->\n {\n To.Parsetree.popen_lid = copy_loc copy_longident popen_lid;\n To.Parsetree.popen_override = copy_override_flag popen_override;\n To.Parsetree.popen_loc = copy_location popen_loc;\n To.Parsetree.popen_attributes = copy_attributes popen_attributes;\n }\n\nand copy_override_flag :\n From.Asttypes.override_flag -> To.Asttypes.override_flag = function\n | From.Asttypes.Override -> To.Asttypes.Override\n | From.Asttypes.Fresh -> To.Asttypes.Fresh\n\nand copy_module_type_declaration :\n From.Parsetree.module_type_declaration ->\n To.Parsetree.module_type_declaration =\n fun {\n From.Parsetree.pmtd_name;\n From.Parsetree.pmtd_type;\n From.Parsetree.pmtd_attributes;\n From.Parsetree.pmtd_loc;\n } ->\n {\n To.Parsetree.pmtd_name = copy_loc (fun x -> x) pmtd_name;\n To.Parsetree.pmtd_type = copy_option copy_module_type pmtd_type;\n To.Parsetree.pmtd_attributes = copy_attributes pmtd_attributes;\n To.Parsetree.pmtd_loc = copy_location pmtd_loc;\n }\n\nand copy_module_declaration :\n From.Parsetree.module_declaration -> To.Parsetree.module_declaration =\n fun {\n From.Parsetree.pmd_name;\n From.Parsetree.pmd_type;\n From.Parsetree.pmd_attributes;\n From.Parsetree.pmd_loc;\n } ->\n {\n To.Parsetree.pmd_name = copy_loc (fun x -> x) pmd_name;\n To.Parsetree.pmd_type = copy_module_type pmd_type;\n To.Parsetree.pmd_attributes = copy_attributes pmd_attributes;\n To.Parsetree.pmd_loc = copy_location pmd_loc;\n }\n\nand copy_type_extension :\n From.Parsetree.type_extension -> To.Parsetree.type_extension =\n fun {\n From.Parsetree.ptyext_path;\n From.Parsetree.ptyext_params;\n From.Parsetree.ptyext_constructors;\n From.Parsetree.ptyext_private;\n From.Parsetree.ptyext_attributes;\n } ->\n {\n To.Parsetree.ptyext_path = copy_loc copy_longident ptyext_path;\n To.Parsetree.ptyext_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptyext_params;\n To.Parsetree.ptyext_constructors =\n List.map copy_extension_constructor ptyext_constructors;\n To.Parsetree.ptyext_private = copy_private_flag ptyext_private;\n To.Parsetree.ptyext_attributes = copy_attributes ptyext_attributes;\n }\n\nand copy_extension_constructor :\n From.Parsetree.extension_constructor -> To.Parsetree.extension_constructor =\n fun {\n From.Parsetree.pext_name;\n From.Parsetree.pext_kind;\n From.Parsetree.pext_loc;\n From.Parsetree.pext_attributes;\n } ->\n {\n To.Parsetree.pext_name = copy_loc (fun x -> x) pext_name;\n To.Parsetree.pext_kind = copy_extension_constructor_kind pext_kind;\n To.Parsetree.pext_loc = copy_location pext_loc;\n To.Parsetree.pext_attributes = copy_attributes pext_attributes;\n }\n\nand copy_extension_constructor_kind :\n From.Parsetree.extension_constructor_kind ->\n To.Parsetree.extension_constructor_kind = function\n | From.Parsetree.Pext_decl (x0, x1) ->\n To.Parsetree.Pext_decl\n ( To.Parsetree.Pcstr_tuple (List.map copy_core_type x0),\n copy_option copy_core_type x1 )\n | From.Parsetree.Pext_rebind x0 ->\n To.Parsetree.Pext_rebind (copy_loc copy_longident x0)\n\nand copy_type_declaration :\n From.Parsetree.type_declaration -> To.Parsetree.type_declaration =\n fun {\n From.Parsetree.ptype_name;\n From.Parsetree.ptype_params;\n From.Parsetree.ptype_cstrs;\n From.Parsetree.ptype_kind;\n From.Parsetree.ptype_private;\n From.Parsetree.ptype_manifest;\n From.Parsetree.ptype_attributes;\n From.Parsetree.ptype_loc;\n } ->\n {\n To.Parsetree.ptype_name = copy_loc (fun x -> x) ptype_name;\n To.Parsetree.ptype_params =\n List.map\n (fun x ->\n let x0, x1 = x in\n (copy_core_type x0, copy_variance x1))\n ptype_params;\n To.Parsetree.ptype_cstrs =\n List.map\n (fun x ->\n let x0, x1, x2 = x in\n (copy_core_type x0, copy_core_type x1, copy_location x2))\n ptype_cstrs;\n To.Parsetree.ptype_kind = copy_type_kind ptype_kind;\n To.Parsetree.ptype_private = copy_private_flag ptype_private;\n To.Parsetree.ptype_manifest = copy_option copy_core_type ptype_manifest;\n To.Parsetree.ptype_attributes = copy_attributes ptype_attributes;\n To.Parsetree.ptype_loc = copy_location ptype_loc;\n }\n\nand copy_private_flag : From.Asttypes.private_flag -> To.Asttypes.private_flag =\n function\n | From.Asttypes.Private -> To.Asttypes.Private\n | From.Asttypes.Public -> To.Asttypes.Public\n\nand copy_type_kind : From.Parsetree.type_kind -> To.Parsetree.type_kind =\n function\n | From.Parsetree.Ptype_abstract -> To.Parsetree.Ptype_abstract\n | From.Parsetree.Ptype_variant x0 ->\n To.Parsetree.Ptype_variant (List.map copy_constructor_declaration x0)\n | From.Parsetree.Ptype_record x0 ->\n To.Parsetree.Ptype_record (List.map copy_label_declaration x0)\n | From.Parsetree.Ptype_open -> To.Parsetree.Ptype_open\n\nand copy_label_declaration :\n From.Parsetree.label_declaration -> To.Parsetree.label_declaration =\n fun {\n From.Parsetree.pld_name;\n From.Parsetree.pld_mutable;\n From.Parsetree.pld_type;\n From.Parsetree.pld_loc;\n From.Parsetree.pld_attributes;\n } ->\n {\n To.Parsetree.pld_name = copy_loc (fun x -> x) pld_name;\n To.Parsetree.pld_mutable = copy_mutable_flag pld_mutable;\n To.Parsetree.pld_type = copy_core_type pld_type;\n To.Parsetree.pld_loc = copy_location pld_loc;\n To.Parsetree.pld_attributes = copy_attributes pld_attributes;\n }\n\nand copy_mutable_flag : From.Asttypes.mutable_flag -> To.Asttypes.mutable_flag =\n function\n | From.Asttypes.Immutable -> To.Asttypes.Immutable\n | From.Asttypes.Mutable -> To.Asttypes.Mutable\n\nand copy_constructor_declaration :\n From.Parsetree.constructor_declaration ->\n To.Parsetree.constructor_declaration =\n fun {\n From.Parsetree.pcd_name;\n From.Parsetree.pcd_args;\n From.Parsetree.pcd_res;\n From.Parsetree.pcd_loc;\n From.Parsetree.pcd_attributes;\n } ->\n {\n To.Parsetree.pcd_name = copy_loc (fun x -> x) pcd_name;\n To.Parsetree.pcd_args =\n To.Parsetree.Pcstr_tuple (List.map copy_core_type pcd_args);\n To.Parsetree.pcd_res = copy_option copy_core_type pcd_res;\n To.Parsetree.pcd_loc = copy_location pcd_loc;\n To.Parsetree.pcd_attributes = copy_attributes pcd_attributes;\n }\n\nand copy_variance : From.Asttypes.variance -> To.Asttypes.variance = function\n | From.Asttypes.Covariant -> To.Asttypes.Covariant\n | From.Asttypes.Contravariant -> To.Asttypes.Contravariant\n | From.Asttypes.Invariant -> To.Asttypes.Invariant\n\nand copy_value_description :\n From.Parsetree.value_description -> To.Parsetree.value_description =\n fun {\n From.Parsetree.pval_name;\n From.Parsetree.pval_type;\n From.Parsetree.pval_prim;\n From.Parsetree.pval_attributes;\n From.Parsetree.pval_loc;\n } ->\n {\n To.Parsetree.pval_name = copy_loc (fun x -> x) pval_name;\n To.Parsetree.pval_type = copy_core_type pval_type;\n To.Parsetree.pval_prim = List.map (fun x -> x) pval_prim;\n To.Parsetree.pval_attributes = copy_attributes pval_attributes;\n To.Parsetree.pval_loc = copy_location pval_loc;\n }\n\nand copy_closed_flag : From.Asttypes.closed_flag -> To.Asttypes.closed_flag =\n function\n | From.Asttypes.Closed -> To.Asttypes.Closed\n | From.Asttypes.Open -> To.Asttypes.Open\n\nand copy_label : From.Asttypes.label -> To.Asttypes.label = fun x -> x\n\nand copy_arg_label : From.Asttypes.label -> To.Asttypes.arg_label =\n fun x ->\n if x <> \"\" then\n if x.[0] = '?' then\n To.Asttypes.Optional (String.sub x 1 (String.length x - 1))\n else To.Asttypes.Labelled x\n else To.Asttypes.Nolabel\n\nand copy_rec_flag : From.Asttypes.rec_flag -> To.Asttypes.rec_flag = function\n | From.Asttypes.Nonrecursive -> To.Asttypes.Nonrecursive\n | From.Asttypes.Recursive -> To.Asttypes.Recursive\n\nand copy_constant : From.Asttypes.constant -> To.Parsetree.constant = function\n | From.Asttypes.Const_int x0 ->\n To.Parsetree.Pconst_integer (string_of_int x0, None)\n | From.Asttypes.Const_char x0 -> To.Parsetree.Pconst_char x0\n | From.Asttypes.Const_string (x0, x1) ->\n To.Parsetree.Pconst_string (x0, copy_option (fun x -> x) x1)\n | From.Asttypes.Const_float x0 -> To.Parsetree.Pconst_float (x0, None)\n | From.Asttypes.Const_int32 x0 ->\n To.Parsetree.Pconst_integer (Int32.to_string x0, Some 'l')\n | From.Asttypes.Const_int64 x0 ->\n To.Parsetree.Pconst_integer (Int64.to_string x0, Some 'L')\n | From.Asttypes.Const_nativeint x0 ->\n To.Parsetree.Pconst_integer (Nativeint.to_string x0, Some 'n')\n\nand copy_option : 'f0 'g0. ('f0 -> 'g0) -> 'f0 option -> 'g0 option =\n fun f0 -> function None -> None | Some x0 -> Some (f0 x0)\n\nand copy_longident : Longident.t -> Longident.t = fun x -> x\n\nand copy_loc :\n 'f0 'g0. ('f0 -> 'g0) -> 'f0 From.Asttypes.loc -> 'g0 To.Asttypes.loc =\n fun f0 { From.Asttypes.txt; From.Asttypes.loc } ->\n { To.Asttypes.txt = f0 txt; To.Asttypes.loc = copy_location loc }\n\nand copy_location : Location.t -> Location.t = fun x -> x\nand copy_bool : bool -> bool = function false -> false | true -> true\n\nand type_declarations types =\n let is_nonrec (attr, _) = attr.Location.txt = \"nonrec\" in\n match List.map copy_type_declaration types with\n | x :: xs when List.exists is_nonrec x.To.Parsetree.ptype_attributes ->\n let ptype_attributes =\n List.filter (fun x -> not (is_nonrec x)) x.To.Parsetree.ptype_attributes\n in\n (To.Asttypes.Nonrecursive, { x with To.Parsetree.ptype_attributes } :: xs)\n | types -> (To.Asttypes.Recursive, types)\n\nlet rec copy_toplevel_phrase :\n From.Parsetree.toplevel_phrase -> To.Parsetree.toplevel_phrase = function\n | From.Parsetree.Ptop_def x0 -> To.Parsetree.Ptop_def (copy_structure x0)\n | From.Parsetree.Ptop_dir (x0, x1) ->\n To.Parsetree.Ptop_dir (x0, copy_directive_argument x1)\n\nand copy_directive_argument :\n From.Parsetree.directive_argument -> To.Parsetree.directive_argument =\n function\n | From.Parsetree.Pdir_none -> To.Parsetree.Pdir_none\n | From.Parsetree.Pdir_string x0 -> To.Parsetree.Pdir_string x0\n | From.Parsetree.Pdir_int x0 -> To.Parsetree.Pdir_int (string_of_int x0, None)\n | From.Parsetree.Pdir_ident x0 -> To.Parsetree.Pdir_ident (copy_longident x0)\n | From.Parsetree.Pdir_bool x0 -> To.Parsetree.Pdir_bool (copy_bool x0)\n\nlet copy_cases x = List.map copy_case x\nlet copy_pat = copy_pattern\nlet copy_expr = copy_expression\nlet copy_typ = copy_core_type\n","(* This file is used to control what we use from the current compiler and what is embed in\n this library.\n\n It must be opened in all modules, especially the ones coming from the compiler.\n*)\n\nmodule Js = Versions.OCaml_412\nmodule Ocaml = Versions.OCaml_current\n\nmodule Select_ast (Ocaml : Versions.OCaml_version) = struct\n include Js\n\n module Type = struct\n type ('js, 'ocaml) t =\n | Signature\n : (Js.Ast.Parsetree.signature, Ocaml.Ast.Parsetree.signature) t\n | Structure\n : (Js.Ast.Parsetree.structure, Ocaml.Ast.Parsetree.structure) t\n | Toplevel_phrase\n : ( Js.Ast.Parsetree.toplevel_phrase,\n Ocaml.Ast.Parsetree.toplevel_phrase )\n t\n | Expression\n : (Js.Ast.Parsetree.expression, Ocaml.Ast.Parsetree.expression) t\n | Core_type\n : (Js.Ast.Parsetree.core_type, Ocaml.Ast.Parsetree.core_type) t\n | Type_declaration\n : ( Js.Ast.Parsetree.type_declaration,\n Ocaml.Ast.Parsetree.type_declaration )\n t\n | Type_extension\n : ( Js.Ast.Parsetree.type_extension,\n Ocaml.Ast.Parsetree.type_extension )\n t\n | Extension_constructor\n : ( Js.Ast.Parsetree.extension_constructor,\n Ocaml.Ast.Parsetree.extension_constructor )\n t\n | List : ('a, 'b) t -> ('a list, 'b list) t\n | Pair : ('a, 'b) t * ('c, 'd) t -> ('a * 'c, 'b * 'd) t\n end\n\n open Type\n module Of_ocaml = Versions.Convert (Ocaml) (Js)\n module To_ocaml = Versions.Convert (Js) (Ocaml)\n\n let rec of_ocaml : type ocaml js. (js, ocaml) Type.t -> ocaml -> js =\n let open Of_ocaml in\n fun node ->\n match node with\n | Signature -> copy_signature\n | Structure -> copy_structure\n | Toplevel_phrase -> copy_toplevel_phrase\n | Expression -> copy_expression\n | Core_type -> copy_core_type\n | Type_declaration -> copy_type_declaration\n | Type_extension -> copy_type_extension\n | Extension_constructor -> copy_extension_constructor\n | List t -> List.map (of_ocaml t)\n | Pair (a, b) ->\n let f = of_ocaml a in\n let g = of_ocaml b in\n fun (x, y) -> (f x, g y)\n\n let rec to_ocaml : type ocaml js. (js, ocaml) Type.t -> js -> ocaml =\n let open To_ocaml in\n fun node ->\n match node with\n | Signature -> copy_signature\n | Structure -> copy_structure\n | Toplevel_phrase -> copy_toplevel_phrase\n | Expression -> copy_expression\n | Core_type -> copy_core_type\n | Type_declaration -> copy_type_declaration\n | Type_extension -> copy_type_extension\n | Extension_constructor -> copy_extension_constructor\n | List t -> List.map (to_ocaml t)\n | Pair (a, b) ->\n let f = to_ocaml a in\n let g = to_ocaml b in\n fun (x, y) -> (f x, g y)\n\n let of_ocaml_mapper item f ctxt x = to_ocaml item x |> f ctxt |> of_ocaml item\n let to_ocaml_mapper item f ctxt x = of_ocaml item x |> f ctxt |> to_ocaml item\nend\n\nmodule Selected_ast = Select_ast (Ocaml)\nmodule Ast_helper = Ast_helper_lite\n\n(* Modules from Ast_ of Astlib, where is the compiler version the ppxlib driver is compiled with *)\nmodule Parsetree = Selected_ast.Ast.Parsetree\nmodule Asttypes = Selected_ast.Ast.Asttypes\n\n(* Other Astlib modules *)\nmodule Location = Astlib.Location\nmodule Longident = Astlib.Longident\n\nmodule Parse = struct\n include Astlib.Parse\n module Of_ocaml = Versions.Convert (Ocaml) (Js)\n\n let implementation lexbuf = implementation lexbuf |> Of_ocaml.copy_structure\n let interface lexbuf = interface lexbuf |> Of_ocaml.copy_signature\n\n let toplevel_phrase lexbuf =\n toplevel_phrase lexbuf |> Of_ocaml.copy_toplevel_phrase\n\n let use_file lexbuf =\n use_file lexbuf |> List.map Of_ocaml.copy_toplevel_phrase\n\n let core_type lexbuf = core_type lexbuf |> Of_ocaml.copy_core_type\n let expression lexbuf = expression lexbuf |> Of_ocaml.copy_expression\n let pattern lexbuf = pattern lexbuf |> Of_ocaml.copy_pattern\nend\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(** Definition of the OCaml AST *)\n\nopen Import\n\n(* This file is obtained by:\n\n - copying a subset of the corresponding ast_xxx.ml file from Astlib\n (sub-modules Asttypes and Parsetree)\n - adding the type definitions for position, location, loc and longident\n - flattening all the modules\n - removing Asttypes.constant (unused and conflicts with Parsetree.constant)\n - renaming a few types:\n - - Location.t -> location\n - - Longident.t -> longident\n - adding a type longident_loc = longident loc and replacing all the occurrences of the\n latter by the former. This is so that we can override iteration an the level of a\n longident loc\n - adding a type cases = case list\n - replacing all the (*IF_CURRENT = Foo.bar*) by: = Foo.bar\n - removing the extra values at the end of the file\n - replacing app [type ...] by [and ...] to make everything one recursive block\n - adding [@@deriving_inline traverse][@@@end] at the end\n\n To update it to a newer OCaml version, create a new module with the above from the\n latest compiler and add the following module definitions and opens to get it to\n compile:\n [{\n module Ast = Versions.OCaml_4xx\n open Ast.Ast\n module Location = Ocaml_common.Location\n module Longident = Ocaml_common.Longident\n }]\n\n Once you have generated the inlined derived traversal classes by running\n [{ dune build @lint }] you can replace the above mentioned module definitions by a\n [open Import] and update [Import] so that the [Js] module points to\n [Versions.OCaml_4xx].\n*)\n\n(* Source code locations (ranges of positions), used in parsetree. *)\n\ntype position = Lexing.position = {\n pos_fname : string;\n pos_lnum : int;\n pos_bol : int;\n pos_cnum : int;\n}\n\nand location = Location.t = {\n loc_start : position;\n loc_end : position;\n loc_ghost : bool;\n}\n\nand location_stack = location list\n\n(* Note on the use of Lexing.position in this module.\n If [pos_fname = \"\"], then use [!input_name] instead.\n If [pos_lnum = -1], then [pos_bol = 0]. Use [pos_cnum] and\n re-parse the file to get the line and character numbers.\n Else all fields are correct.\n*)\nand 'a loc = 'a Location.loc = { txt : 'a; loc : location }\n\n(* Long identifiers, used in parsetree. *)\nand longident = Longident.t =\n | Lident of string\n | Ldot of longident * string\n | Lapply of longident * longident\n\nand longident_loc = longident loc\n\n(** Auxiliary AST types used by parsetree and typedtree. *)\n\nand rec_flag = Asttypes.rec_flag = Nonrecursive | Recursive\n\nand direction_flag = Asttypes.direction_flag = Upto | Downto\n\n(* Order matters, used in polymorphic comparison *)\nand private_flag = Asttypes.private_flag = Private | Public\nand mutable_flag = Asttypes.mutable_flag = Immutable | Mutable\nand virtual_flag = Asttypes.virtual_flag = Virtual | Concrete\nand override_flag = Asttypes.override_flag = Override | Fresh\nand closed_flag = Asttypes.closed_flag = Closed | Open\nand label = string\n\nand arg_label = Asttypes.arg_label =\n | Nolabel\n | Labelled of string (* label:T -> ... *)\n | Optional of string\n(* ?label:T -> ... *)\n\nand variance = Asttypes.variance = Covariant | Contravariant | NoVariance\nand injectivity = Asttypes.injectivity = Injective | NoInjectivity\n\n(** Abstract syntax tree produced by parsing *)\n\nand constant = Parsetree.constant =\n | Pconst_integer of string * char option\n (* 3 3l 3L 3n\n\n Suffixes [g-z][G-Z] are accepted by the parser.\n Suffixes except 'l', 'L' and 'n' are rejected by the typechecker\n *)\n | Pconst_char of char\n (* 'c' *)\n | Pconst_string of string * location * string option\n (* \"constant\"\n {delim|other constant|delim}\n\n The location span the content of the string, without the delimiters.\n *)\n | Pconst_float of string * char option\n(* 3.4 2e5 1.4e-4\n\n Suffixes [g-z][G-Z] are accepted by the parser.\n Suffixes are rejected by the typechecker.\n*)\n\n(** {1 Extension points} *)\n\nand attribute = Parsetree.attribute = {\n attr_name : string loc;\n attr_payload : payload;\n attr_loc : location;\n}\n(* [@id ARG]\n [@@id ARG]\n\n Metadata containers passed around within the AST.\n The compiler ignores unknown attributes.\n*)\n\nand extension = string loc * payload\n(* [%id ARG]\n [%%id ARG]\n\n Sub-language placeholder -- rejected by the typechecker.\n*)\n\nand attributes = attribute list\n\nand payload = Parsetree.payload =\n | PStr of structure\n | PSig of signature (* : SIG *)\n | PTyp of core_type (* : T *)\n | PPat of pattern * expression option\n(* ? P or ? P when E *)\n\n(* Type expressions *)\n\n(** {1 Core language} *)\n\nand core_type = Parsetree.core_type = {\n ptyp_desc : core_type_desc;\n ptyp_loc : location;\n ptyp_loc_stack : location_stack;\n ptyp_attributes : attributes; (* ... [@id1] [@id2] *)\n}\n\nand core_type_desc = Parsetree.core_type_desc =\n | Ptyp_any\n (* _ *)\n | Ptyp_var of string\n (* 'a *)\n | Ptyp_arrow of arg_label * core_type * core_type\n (* T1 -> T2 Simple\n ~l:T1 -> T2 Labelled\n ?l:T1 -> T2 Optional\n *)\n | Ptyp_tuple of core_type list\n (* T1 * ... * Tn\n\n Invariant: n >= 2\n *)\n | Ptyp_constr of longident_loc * core_type list\n (* tconstr\n T tconstr\n (T1, ..., Tn) tconstr\n *)\n | Ptyp_object of object_field list * closed_flag\n (* < l1:T1; ...; ln:Tn > (flag = Closed)\n < l1:T1; ...; ln:Tn; .. > (flag = Open)\n *)\n | Ptyp_class of longident_loc * core_type list\n (* #tconstr\n T #tconstr\n (T1, ..., Tn) #tconstr\n *)\n | Ptyp_alias of core_type * string\n (* T as 'a *)\n | Ptyp_variant of row_field list * closed_flag * label list option\n (* [ `A|`B ] (flag = Closed; labels = None)\n [> `A|`B ] (flag = Open; labels = None)\n [< `A|`B ] (flag = Closed; labels = Some [])\n [< `A|`B > `X `Y ](flag = Closed; labels = Some [\"X\";\"Y\"])\n *)\n | Ptyp_poly of string loc list * core_type (* 'a1 ... 'an. T\n\n Can only appear in the following context:\n\n - As the core_type of a Ppat_constraint node corresponding\n to a constraint on a let-binding: let x : 'a1 ... 'an. T\n = e ...\n\n - Under Cfk_virtual for methods (not values).\n\n - As the core_type of a Pctf_method node.\n\n - As the core_type of a Pexp_poly node.\n\n - As the pld_type field of a label_declaration.\n\n - As a core_type of a Ptyp_object node.\n *)\n | Ptyp_package of package_type\n (* (module S) *)\n | Ptyp_extension of extension\n(* [%id] *)\n\nand package_type = longident_loc * (longident_loc * core_type) list\n(*\n (module S)\n (module S with type t1 = T1 and ... and tn = Tn)\n*)\n\nand row_field = Parsetree.row_field = {\n prf_desc : row_field_desc;\n prf_loc : location;\n prf_attributes : attributes;\n}\n\nand row_field_desc = Parsetree.row_field_desc =\n | Rtag of label loc * bool * core_type list\n (* [`A] ( true, [] )\n [`A of T] ( false, [T] )\n [`A of T1 & .. & Tn] ( false, [T1;...Tn] )\n [`A of & T1 & .. & Tn] ( true, [T1;...Tn] )\n\n - The 2nd field is true if the tag contains a\n constant (empty) constructor.\n - '&' occurs when several types are used for the same constructor\n (see 4.2 in the manual)\n\n - TODO: switch to a record representation, and keep location\n *)\n | Rinherit of core_type\n(* [ | t ] *)\n\nand object_field = Parsetree.object_field = {\n pof_desc : object_field_desc;\n pof_loc : location;\n pof_attributes : attributes;\n}\n\nand object_field_desc = Parsetree.object_field_desc =\n | Otag of label loc * core_type\n | Oinherit of core_type\n\n(* Patterns *)\nand pattern = Parsetree.pattern = {\n ppat_desc : pattern_desc;\n ppat_loc : location;\n ppat_loc_stack : location_stack;\n ppat_attributes : attributes; (* ... [@id1] [@id2] *)\n}\n\nand pattern_desc = Parsetree.pattern_desc =\n | Ppat_any\n (* _ *)\n | Ppat_var of string loc\n (* x *)\n | Ppat_alias of pattern * string loc\n (* P as 'a *)\n | Ppat_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Ppat_interval of constant * constant\n (* 'a'..'z'\n\n Other forms of interval are recognized by the parser\n but rejected by the type-checker. *)\n | Ppat_tuple of pattern list\n (* (P1, ..., Pn)\n\n Invariant: n >= 2\n *)\n | Ppat_construct of longident_loc * pattern option\n (* C None\n C P Some P\n C (P1, ..., Pn) Some (Ppat_tuple [P1; ...; Pn])\n *)\n | Ppat_variant of label * pattern option\n (* `A (None)\n `A P (Some P)\n *)\n | Ppat_record of (longident_loc * pattern) list * closed_flag\n (* { l1=P1; ...; ln=Pn } (flag = Closed)\n { l1=P1; ...; ln=Pn; _} (flag = Open)\n\n Invariant: n > 0\n *)\n | Ppat_array of pattern list\n (* [| P1; ...; Pn |] *)\n | Ppat_or of pattern * pattern\n (* P1 | P2 *)\n | Ppat_constraint of pattern * core_type\n (* (P : T) *)\n | Ppat_type of longident_loc\n (* #tconst *)\n | Ppat_lazy of pattern\n (* lazy P *)\n | Ppat_unpack of string option loc\n (* (module P)\n Note: (module P : S) is represented as\n Ppat_constraint(Ppat_unpack, Ptyp_package)\n *)\n | Ppat_exception of pattern\n (* exception P *)\n | Ppat_extension of extension\n (* [%id] *)\n | Ppat_open of longident_loc * pattern\n(* M.(P) *)\n\n(* Value expressions *)\nand expression = Parsetree.expression = {\n pexp_desc : expression_desc;\n pexp_loc : location;\n pexp_loc_stack : location_stack;\n pexp_attributes : attributes; (* ... [@id1] [@id2] *)\n}\n\nand expression_desc = Parsetree.expression_desc =\n | Pexp_ident of longident_loc\n (* x\n M.x\n *)\n | Pexp_constant of constant\n (* 1, 'a', \"true\", 1.0, 1l, 1L, 1n *)\n | Pexp_let of rec_flag * value_binding list * expression\n (* let P1 = E1 and ... and Pn = EN in E (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in E (flag = Recursive)\n *)\n | Pexp_function of cases\n (* function P1 -> E1 | ... | Pn -> En *)\n | Pexp_fun of arg_label * expression option * pattern * expression\n (* fun P -> E1 (Simple, None)\n fun ~l:P -> E1 (Labelled l, None)\n fun ?l:P -> E1 (Optional l, None)\n fun ?l:(P = E0) -> E1 (Optional l, Some E0)\n\n Notes:\n - If E0 is provided, only Optional is allowed.\n - \"fun P1 P2 .. Pn -> E1\" is represented as nested Pexp_fun.\n - \"let f P = E\" is represented using Pexp_fun.\n *)\n | Pexp_apply of expression * (arg_label * expression) list\n (* E0 ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pexp_match of expression * cases\n (* match E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_try of expression * cases\n (* try E0 with P1 -> E1 | ... | Pn -> En *)\n | Pexp_tuple of expression list\n (* (E1, ..., En)\n\n Invariant: n >= 2\n *)\n | Pexp_construct of longident_loc * expression option\n (* C None\n C E Some E\n C (E1, ..., En) Some (Pexp_tuple[E1;...;En])\n *)\n | Pexp_variant of label * expression option\n (* `A (None)\n `A E (Some E)\n *)\n | Pexp_record of (longident_loc * expression) list * expression option\n (* { l1=P1; ...; ln=Pn } (None)\n { E0 with l1=P1; ...; ln=Pn } (Some E0)\n\n Invariant: n > 0\n *)\n | Pexp_field of expression * longident_loc\n (* E.l *)\n | Pexp_setfield of expression * longident_loc * expression\n (* E1.l <- E2 *)\n | Pexp_array of expression list\n (* [| E1; ...; En |] *)\n | Pexp_ifthenelse of expression * expression * expression option\n (* if E1 then E2 else E3 *)\n | Pexp_sequence of expression * expression\n (* E1; E2 *)\n | Pexp_while of expression * expression\n (* while E1 do E2 done *)\n | Pexp_for of pattern * expression * expression * direction_flag * expression\n (* for i = E1 to E2 do E3 done (flag = Upto)\n for i = E1 downto E2 do E3 done (flag = Downto)\n *)\n | Pexp_constraint of expression * core_type\n (* (E : T) *)\n | Pexp_coerce of expression * core_type option * core_type\n (* (E :> T) (None, T)\n (E : T0 :> T) (Some T0, T)\n *)\n | Pexp_send of expression * label loc\n (* E # m *)\n | Pexp_new of longident_loc\n (* new M.c *)\n | Pexp_setinstvar of label loc * expression\n (* x <- 2 *)\n | Pexp_override of (label loc * expression) list\n (* {< x1 = E1; ...; Xn = En >} *)\n | Pexp_letmodule of string option loc * module_expr * expression\n (* let module M = ME in E *)\n | Pexp_letexception of extension_constructor * expression\n (* let exception C in E *)\n | Pexp_assert of expression\n (* assert E\n Note: \"assert false\" is treated in a special way by the\n type-checker. *)\n | Pexp_lazy of expression\n (* lazy E *)\n | Pexp_poly of expression * core_type option\n (* Used for method bodies.\n\n Can only be used as the expression under Cfk_concrete\n for methods (not values). *)\n | Pexp_object of class_structure\n (* object ... end *)\n | Pexp_newtype of string loc * expression\n (* fun (type t) -> E *)\n | Pexp_pack of module_expr\n (* (module ME)\n\n (module ME : S) is represented as\n Pexp_constraint(Pexp_pack, Ptyp_package S) *)\n | Pexp_open of open_declaration * expression\n (* M.(E)\n let open M in E\n let! open M in E *)\n | Pexp_letop of letop\n (* let* P = E in E\n let* P = E and* P = E in E *)\n | Pexp_extension of extension\n (* [%id] *)\n | Pexp_unreachable\n(* . *)\n\nand case = Parsetree.case = {\n (* (P -> E) or (P when E0 -> E) *)\n pc_lhs : pattern;\n pc_guard : expression option;\n pc_rhs : expression;\n}\n\nand letop = Parsetree.letop = {\n let_ : binding_op;\n ands : binding_op list;\n body : expression;\n}\n\nand binding_op = Parsetree.binding_op = {\n pbop_op : string loc;\n pbop_pat : pattern;\n pbop_exp : expression;\n pbop_loc : location;\n}\n\n(* Value descriptions *)\nand value_description = Parsetree.value_description = {\n pval_name : string loc;\n pval_type : core_type;\n pval_prim : string list;\n pval_attributes : attributes;\n (* ... [@@id1] [@@id2] *)\n pval_loc : location;\n}\n\n(*\n val x: T (prim = [])\n external x: T = \"s1\" ... \"sn\" (prim = [\"s1\";...\"sn\"])\n*)\n\n(* Type declarations *)\nand type_declaration = Parsetree.type_declaration = {\n ptype_name : string loc;\n ptype_params : (core_type * (variance * injectivity)) list;\n (* ('a1,...'an) t; None represents _*)\n ptype_cstrs : (core_type * core_type * location) list;\n (* ... constraint T1=T1' ... constraint Tn=Tn' *)\n ptype_kind : type_kind;\n ptype_private : private_flag;\n (* = private ... *)\n ptype_manifest : core_type option;\n (* = T *)\n ptype_attributes : attributes;\n (* ... [@@id1] [@@id2] *)\n ptype_loc : location;\n}\n\n(*\n type t (abstract, no manifest)\n type t = T0 (abstract, manifest=T0)\n type t = C of T | ... (variant, no manifest)\n type t = T0 = C of T | ... (variant, manifest=T0)\n type t = {l: T; ...} (record, no manifest)\n type t = T0 = {l : T; ...} (record, manifest=T0)\n type t = .. (open, no manifest)\n*)\nand type_kind = Parsetree.type_kind =\n | Ptype_abstract\n | Ptype_variant of constructor_declaration list\n | Ptype_record of label_declaration list\n (* Invariant: non-empty list *)\n | Ptype_open\n\nand label_declaration = Parsetree.label_declaration = {\n pld_name : string loc;\n pld_mutable : mutable_flag;\n pld_type : core_type;\n pld_loc : location;\n pld_attributes : attributes; (* l : T [@id1] [@id2] *)\n}\n\n(* { ...; l: T; ... } (mutable=Immutable)\n { ...; mutable l: T; ... } (mutable=Mutable)\n\n Note: T can be a Ptyp_poly.\n*)\nand constructor_declaration = Parsetree.constructor_declaration = {\n pcd_name : string loc;\n pcd_args : constructor_arguments;\n pcd_res : core_type option;\n pcd_loc : location;\n pcd_attributes : attributes; (* C of ... [@id1] [@id2] *)\n}\n\nand constructor_arguments = Parsetree.constructor_arguments =\n | Pcstr_tuple of core_type list\n | Pcstr_record of label_declaration list\n\n(*\n | C of T1 * ... * Tn (res = None, args = Pcstr_tuple [])\n | C: T0 (res = Some T0, args = [])\n | C: T1 * ... * Tn -> T0 (res = Some T0, args = Pcstr_tuple)\n | C of {...} (res = None, args = Pcstr_record)\n | C: {...} -> T0 (res = Some T0, args = Pcstr_record)\n | C of {...} as t (res = None, args = Pcstr_record)\n*)\nand type_extension = Parsetree.type_extension = {\n ptyext_path : longident_loc;\n ptyext_params : (core_type * (variance * injectivity)) list;\n ptyext_constructors : extension_constructor list;\n ptyext_private : private_flag;\n ptyext_loc : location;\n ptyext_attributes : attributes; (* ... [@@id1] [@@id2] *)\n}\n(*\n type t += ...\n*)\n\nand extension_constructor = Parsetree.extension_constructor = {\n pext_name : string loc;\n pext_kind : extension_constructor_kind;\n pext_loc : location;\n pext_attributes : attributes; (* C of ... [@id1] [@id2] *)\n}\n\nand type_exception = Parsetree.type_exception = {\n ptyexn_constructor : extension_constructor;\n ptyexn_loc : location;\n ptyexn_attributes : attributes;\n}\n\nand extension_constructor_kind = Parsetree.extension_constructor_kind =\n | Pext_decl of constructor_arguments * core_type option\n (*\n | C of T1 * ... * Tn ([T1; ...; Tn], None)\n | C: T0 ([], Some T0)\n | C: T1 * ... * Tn -> T0 ([T1; ...; Tn], Some T0)\n *)\n | Pext_rebind of longident_loc\n(*\n | C = D\n *)\n\n(* Type expressions for the class language *)\n\n(** {1 Class language} *)\n\nand class_type = Parsetree.class_type = {\n pcty_desc : class_type_desc;\n pcty_loc : location;\n pcty_attributes : attributes; (* ... [@id1] [@id2] *)\n}\n\nand class_type_desc = Parsetree.class_type_desc =\n | Pcty_constr of longident_loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcty_signature of class_signature\n (* object ... end *)\n | Pcty_arrow of arg_label * core_type * class_type\n (* T -> CT Simple\n ~l:T -> CT Labelled l\n ?l:T -> CT Optional l\n *)\n | Pcty_extension of extension\n (* [%id] *)\n | Pcty_open of open_description * class_type\n(* let open M in CT *)\n\nand class_signature = Parsetree.class_signature = {\n pcsig_self : core_type;\n pcsig_fields : class_type_field list;\n}\n(* object('selfpat) ... end\n object ... end (self = Ptyp_any)\n*)\n\nand class_type_field = Parsetree.class_type_field = {\n pctf_desc : class_type_field_desc;\n pctf_loc : location;\n pctf_attributes : attributes; (* ... [@@id1] [@@id2] *)\n}\n\nand class_type_field_desc = Parsetree.class_type_field_desc =\n | Pctf_inherit of class_type\n (* inherit CT *)\n | Pctf_val of (label loc * mutable_flag * virtual_flag * core_type)\n (* val x: T *)\n | Pctf_method of (label loc * private_flag * virtual_flag * core_type)\n (* method x: T\n\n Note: T can be a Ptyp_poly.\n *)\n | Pctf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pctf_attribute of attribute\n (* [@@@id] *)\n | Pctf_extension of extension\n(* [%%id] *)\n\nand 'a class_infos = 'a Parsetree.class_infos = {\n pci_virt : virtual_flag;\n pci_params : (core_type * (variance * injectivity)) list;\n pci_name : string loc;\n pci_expr : 'a;\n pci_loc : location;\n pci_attributes : attributes; (* ... [@@id1] [@@id2] *)\n}\n(* class c = ...\n class ['a1,...,'an] c = ...\n class virtual c = ...\n\n Also used for \"class type\" declaration.\n*)\n\nand class_description = class_type class_infos\nand class_type_declaration = class_type class_infos\n\n(* Value expressions for the class language *)\nand class_expr = Parsetree.class_expr = {\n pcl_desc : class_expr_desc;\n pcl_loc : location;\n pcl_attributes : attributes; (* ... [@id1] [@id2] *)\n}\n\nand class_expr_desc = Parsetree.class_expr_desc =\n | Pcl_constr of longident_loc * core_type list\n (* c\n ['a1, ..., 'an] c *)\n | Pcl_structure of class_structure\n (* object ... end *)\n | Pcl_fun of arg_label * expression option * pattern * class_expr\n (* fun P -> CE (Simple, None)\n fun ~l:P -> CE (Labelled l, None)\n fun ?l:P -> CE (Optional l, None)\n fun ?l:(P = E0) -> CE (Optional l, Some E0)\n *)\n | Pcl_apply of class_expr * (arg_label * expression) list\n (* CE ~l1:E1 ... ~ln:En\n li can be empty (non labeled argument) or start with '?'\n (optional argument).\n\n Invariant: n > 0\n *)\n | Pcl_let of rec_flag * value_binding list * class_expr\n (* let P1 = E1 and ... and Pn = EN in CE (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN in CE (flag = Recursive)\n *)\n | Pcl_constraint of class_expr * class_type\n (* (CE : CT) *)\n | Pcl_extension of extension\n (* [%id] *)\n | Pcl_open of open_description * class_expr\n(* let open M in CE *)\n\nand class_structure = Parsetree.class_structure = {\n pcstr_self : pattern;\n pcstr_fields : class_field list;\n}\n(* object(selfpat) ... end\n object ... end (self = Ppat_any)\n*)\n\nand class_field = Parsetree.class_field = {\n pcf_desc : class_field_desc;\n pcf_loc : location;\n pcf_attributes : attributes; (* ... [@@id1] [@@id2] *)\n}\n\nand class_field_desc = Parsetree.class_field_desc =\n | Pcf_inherit of override_flag * class_expr * string loc option\n (* inherit CE\n inherit CE as x\n inherit! CE\n inherit! CE as x\n *)\n | Pcf_val of (label loc * mutable_flag * class_field_kind)\n (* val x = E\n val virtual x: T\n *)\n | Pcf_method of (label loc * private_flag * class_field_kind)\n (* method x = E (E can be a Pexp_poly)\n method virtual x: T (T can be a Ptyp_poly)\n *)\n | Pcf_constraint of (core_type * core_type)\n (* constraint T1 = T2 *)\n | Pcf_initializer of expression\n (* initializer E *)\n | Pcf_attribute of attribute\n (* [@@@id] *)\n | Pcf_extension of extension\n(* [%%id] *)\n\nand class_field_kind = Parsetree.class_field_kind =\n | Cfk_virtual of core_type\n | Cfk_concrete of override_flag * expression\n\nand class_declaration = class_expr class_infos\n(* Type expressions for the module language *)\n\n(** {1 Module language} *)\n\nand module_type = Parsetree.module_type = {\n pmty_desc : module_type_desc;\n pmty_loc : location;\n pmty_attributes : attributes; (* ... [@id1] [@id2] *)\n}\n\nand module_type_desc = Parsetree.module_type_desc =\n | Pmty_ident of longident_loc\n (* S *)\n | Pmty_signature of signature\n (* sig ... end *)\n | Pmty_functor of functor_parameter * module_type\n (* functor(X : MT1) -> MT2 *)\n | Pmty_with of module_type * with_constraint list\n (* MT with ... *)\n | Pmty_typeof of module_expr\n (* module type of ME *)\n | Pmty_extension of extension\n (* [%id] *)\n | Pmty_alias of longident_loc\n(* (module M) *)\n\nand functor_parameter = Parsetree.functor_parameter =\n | Unit\n (* () *)\n | Named of string option loc * module_type\n(* (X : MT) Some X, MT\n (_ : MT) None, MT *)\n\nand signature = signature_item list\n\nand signature_item = Parsetree.signature_item = {\n psig_desc : signature_item_desc;\n psig_loc : location;\n}\n\nand signature_item_desc = Parsetree.signature_item_desc =\n | Psig_value of value_description\n (*\n val x: T\n external x: T = \"s1\" ... \"sn\"\n *)\n | Psig_type of rec_flag * type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Psig_typesubst of type_declaration list\n (* type t1 := ... and ... and tn := ... *)\n | Psig_typext of type_extension\n (* type t1 += ... *)\n | Psig_exception of type_exception\n (* exception C of T *)\n | Psig_module of module_declaration\n (* module X : MT *)\n | Psig_modsubst of module_substitution\n (* module X := M *)\n | Psig_recmodule of module_declaration list\n (* module rec X1 : MT1 and ... and Xn : MTn *)\n | Psig_modtype of module_type_declaration\n (* module type S = MT\n module type S *)\n | Psig_open of open_description\n (* open X *)\n | Psig_include of include_description\n (* include MT *)\n | Psig_class of class_description list\n (* class c1 : ... and ... and cn : ... *)\n | Psig_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Psig_attribute of attribute\n (* [@@@id] *)\n | Psig_extension of extension * attributes\n(* [%%id] *)\n\nand module_declaration = Parsetree.module_declaration = {\n pmd_name : string option loc;\n pmd_type : module_type;\n pmd_attributes : attributes;\n (* ... [@@id1] [@@id2] *)\n pmd_loc : location;\n}\n(* S : MT *)\n\nand module_substitution = Parsetree.module_substitution = {\n pms_name : string loc;\n pms_manifest : longident_loc;\n pms_attributes : attributes;\n pms_loc : location;\n}\n\nand module_type_declaration = Parsetree.module_type_declaration = {\n pmtd_name : string loc;\n pmtd_type : module_type option;\n pmtd_attributes : attributes;\n (* ... [@@id1] [@@id2] *)\n pmtd_loc : location;\n}\n(* S = MT\n S (abstract module type declaration, pmtd_type = None)\n*)\n\nand 'a open_infos = 'a Parsetree.open_infos = {\n popen_expr : 'a;\n popen_override : override_flag;\n popen_loc : location;\n popen_attributes : attributes;\n}\n\nand open_description = longident_loc open_infos\n(* open! X - popen_override = Override (silences the 'used identifier\n shadowing' warning)\n open X - popen_override = Fresh\n*)\n\nand open_declaration = module_expr open_infos\n\nand 'a include_infos = 'a Parsetree.include_infos = {\n pincl_mod : 'a;\n pincl_loc : location;\n pincl_attributes : attributes;\n}\n\nand include_description = module_type include_infos\n(* include MT *)\n\nand include_declaration = module_expr include_infos\n(* include ME *)\n\nand with_constraint = Parsetree.with_constraint =\n | Pwith_type of longident_loc * type_declaration\n (* with type X.t = ...\n\n Note: the last component of the longident must match\n the name of the type_declaration. *)\n | Pwith_module of longident_loc * longident_loc\n (* with module X.Y = Z *)\n | Pwith_typesubst of longident_loc * type_declaration\n (* with type X.t := ..., same format as [Pwith_type] *)\n | Pwith_modsubst of longident_loc * longident_loc\n(* with module X.Y := Z *)\n\n(* Value expressions for the module language *)\nand module_expr = Parsetree.module_expr = {\n pmod_desc : module_expr_desc;\n pmod_loc : location;\n pmod_attributes : attributes; (* ... [@id1] [@id2] *)\n}\n\nand module_expr_desc = Parsetree.module_expr_desc =\n | Pmod_ident of longident_loc\n (* X *)\n | Pmod_structure of structure\n (* struct ... end *)\n | Pmod_functor of functor_parameter * module_expr\n (* functor(X : MT1) -> ME *)\n | Pmod_apply of module_expr * module_expr\n (* ME1(ME2) *)\n | Pmod_constraint of module_expr * module_type\n (* (ME : MT) *)\n | Pmod_unpack of expression\n (* (val E) *)\n | Pmod_extension of extension\n(* [%id] *)\n\nand structure = structure_item list\n\nand structure_item = Parsetree.structure_item = {\n pstr_desc : structure_item_desc;\n pstr_loc : location;\n}\n\nand structure_item_desc = Parsetree.structure_item_desc =\n | Pstr_eval of expression * attributes\n (* E *)\n | Pstr_value of rec_flag * value_binding list\n (* let P1 = E1 and ... and Pn = EN (flag = Nonrecursive)\n let rec P1 = E1 and ... and Pn = EN (flag = Recursive)\n *)\n | Pstr_primitive of value_description\n (* val x: T\n external x: T = \"s1\" ... \"sn\" *)\n | Pstr_type of rec_flag * type_declaration list\n (* type t1 = ... and ... and tn = ... *)\n | Pstr_typext of type_extension\n (* type t1 += ... *)\n | Pstr_exception of type_exception\n (* exception C of T\n exception C = M.X *)\n | Pstr_module of module_binding\n (* module X = ME *)\n | Pstr_recmodule of module_binding list\n (* module rec X1 = ME1 and ... and Xn = MEn *)\n | Pstr_modtype of module_type_declaration\n (* module type S = MT *)\n | Pstr_open of open_declaration\n (* open X *)\n | Pstr_class of class_declaration list\n (* class c1 = ... and ... and cn = ... *)\n | Pstr_class_type of class_type_declaration list\n (* class type ct1 = ... and ... and ctn = ... *)\n | Pstr_include of include_declaration\n (* include ME *)\n | Pstr_attribute of attribute\n (* [@@@id] *)\n | Pstr_extension of extension * attributes\n(* [%%id] *)\n\nand value_binding = Parsetree.value_binding = {\n pvb_pat : pattern;\n pvb_expr : expression;\n pvb_attributes : attributes;\n pvb_loc : location;\n}\n\nand module_binding = Parsetree.module_binding = {\n pmb_name : string option loc;\n pmb_expr : module_expr;\n pmb_attributes : attributes;\n pmb_loc : location;\n}\n(* X = ME *)\n\n(* Toplevel phrases *)\n\n(** {1 Toplevel} *)\n\nand toplevel_phrase = Parsetree.toplevel_phrase =\n | Ptop_def of structure\n | Ptop_dir of toplevel_directive\n(* #use, #load ... *)\n\nand toplevel_directive = Parsetree.toplevel_directive = {\n pdir_name : string loc;\n pdir_arg : directive_argument option;\n pdir_loc : location;\n}\n\nand directive_argument = Parsetree.directive_argument = {\n pdira_desc : directive_argument_desc;\n pdira_loc : location;\n}\n\nand directive_argument_desc = Parsetree.directive_argument_desc =\n | Pdir_string of string\n | Pdir_int of string * char option\n | Pdir_ident of longident\n | Pdir_bool of bool\n\nand cases = case list [@@deriving_inline traverse]\n\nclass virtual map =\n object (self)\n method virtual bool : bool -> bool\n method virtual char : char -> char\n method virtual int : int -> int\n method virtual list : 'a. ('a -> 'a) -> 'a list -> 'a list\n method virtual option : 'a. ('a -> 'a) -> 'a option -> 'a option\n method virtual string : string -> string\n\n method position : position -> position =\n fun { pos_fname; pos_lnum; pos_bol; pos_cnum } ->\n let pos_fname = self#string pos_fname in\n let pos_lnum = self#int pos_lnum in\n let pos_bol = self#int pos_bol in\n let pos_cnum = self#int pos_cnum in\n { pos_fname; pos_lnum; pos_bol; pos_cnum }\n\n method location : location -> location =\n fun { loc_start; loc_end; loc_ghost } ->\n let loc_start = self#position loc_start in\n let loc_end = self#position loc_end in\n let loc_ghost = self#bool loc_ghost in\n { loc_start; loc_end; loc_ghost }\n\n method location_stack : location_stack -> location_stack =\n self#list self#location\n\n method loc : 'a. ('a -> 'a) -> 'a loc -> 'a loc =\n fun _a { txt; loc } ->\n let txt = _a txt in\n let loc = self#location loc in\n { txt; loc }\n\n method longident : longident -> longident =\n fun x ->\n match x with\n | Lident a ->\n let a = self#string a in\n Lident a\n | Ldot (a, b) ->\n let a = self#longident a in\n let b = self#string b in\n Ldot (a, b)\n | Lapply (a, b) ->\n let a = self#longident a in\n let b = self#longident b in\n Lapply (a, b)\n\n method longident_loc : longident_loc -> longident_loc =\n self#loc self#longident\n\n method rec_flag : rec_flag -> rec_flag = fun x -> x\n method direction_flag : direction_flag -> direction_flag = fun x -> x\n method private_flag : private_flag -> private_flag = fun x -> x\n method mutable_flag : mutable_flag -> mutable_flag = fun x -> x\n method virtual_flag : virtual_flag -> virtual_flag = fun x -> x\n method override_flag : override_flag -> override_flag = fun x -> x\n method closed_flag : closed_flag -> closed_flag = fun x -> x\n method label : label -> label = self#string\n\n method arg_label : arg_label -> arg_label =\n fun x ->\n match x with\n | Nolabel -> Nolabel\n | Labelled a ->\n let a = self#string a in\n Labelled a\n | Optional a ->\n let a = self#string a in\n Optional a\n\n method variance : variance -> variance = fun x -> x\n method injectivity : injectivity -> injectivity = fun x -> x\n\n method constant : constant -> constant =\n fun x ->\n match x with\n | Pconst_integer (a, b) ->\n let a = self#string a in\n let b = self#option self#char b in\n Pconst_integer (a, b)\n | Pconst_char a ->\n let a = self#char a in\n Pconst_char a\n | Pconst_string (a, b, c) ->\n let a = self#string a in\n let b = self#location b in\n let c = self#option self#string c in\n Pconst_string (a, b, c)\n | Pconst_float (a, b) ->\n let a = self#string a in\n let b = self#option self#char b in\n Pconst_float (a, b)\n\n method attribute : attribute -> attribute =\n fun { attr_name; attr_payload; attr_loc } ->\n let attr_name = self#loc self#string attr_name in\n let attr_payload = self#payload attr_payload in\n let attr_loc = self#location attr_loc in\n { attr_name; attr_payload; attr_loc }\n\n method extension : extension -> extension =\n fun (a, b) ->\n let a = self#loc self#string a in\n let b = self#payload b in\n (a, b)\n\n method attributes : attributes -> attributes = self#list self#attribute\n\n method payload : payload -> payload =\n fun x ->\n match x with\n | PStr a ->\n let a = self#structure a in\n PStr a\n | PSig a ->\n let a = self#signature a in\n PSig a\n | PTyp a ->\n let a = self#core_type a in\n PTyp a\n | PPat (a, b) ->\n let a = self#pattern a in\n let b = self#option self#expression b in\n PPat (a, b)\n\n method core_type : core_type -> core_type =\n fun { ptyp_desc; ptyp_loc; ptyp_loc_stack; ptyp_attributes } ->\n let ptyp_desc = self#core_type_desc ptyp_desc in\n let ptyp_loc = self#location ptyp_loc in\n let ptyp_loc_stack = self#location_stack ptyp_loc_stack in\n let ptyp_attributes = self#attributes ptyp_attributes in\n { ptyp_desc; ptyp_loc; ptyp_loc_stack; ptyp_attributes }\n\n method core_type_desc : core_type_desc -> core_type_desc =\n fun x ->\n match x with\n | Ptyp_any -> Ptyp_any\n | Ptyp_var a ->\n let a = self#string a in\n Ptyp_var a\n | Ptyp_arrow (a, b, c) ->\n let a = self#arg_label a in\n let b = self#core_type b in\n let c = self#core_type c in\n Ptyp_arrow (a, b, c)\n | Ptyp_tuple a ->\n let a = self#list self#core_type a in\n Ptyp_tuple a\n | Ptyp_constr (a, b) ->\n let a = self#longident_loc a in\n let b = self#list self#core_type b in\n Ptyp_constr (a, b)\n | Ptyp_object (a, b) ->\n let a = self#list self#object_field a in\n let b = self#closed_flag b in\n Ptyp_object (a, b)\n | Ptyp_class (a, b) ->\n let a = self#longident_loc a in\n let b = self#list self#core_type b in\n Ptyp_class (a, b)\n | Ptyp_alias (a, b) ->\n let a = self#core_type a in\n let b = self#string b in\n Ptyp_alias (a, b)\n | Ptyp_variant (a, b, c) ->\n let a = self#list self#row_field a in\n let b = self#closed_flag b in\n let c = self#option (self#list self#label) c in\n Ptyp_variant (a, b, c)\n | Ptyp_poly (a, b) ->\n let a = self#list (self#loc self#string) a in\n let b = self#core_type b in\n Ptyp_poly (a, b)\n | Ptyp_package a ->\n let a = self#package_type a in\n Ptyp_package a\n | Ptyp_extension a ->\n let a = self#extension a in\n Ptyp_extension a\n\n method package_type : package_type -> package_type =\n fun (a, b) ->\n let a = self#longident_loc a in\n let b =\n self#list\n (fun (a, b) ->\n let a = self#longident_loc a in\n let b = self#core_type b in\n (a, b))\n b\n in\n (a, b)\n\n method row_field : row_field -> row_field =\n fun { prf_desc; prf_loc; prf_attributes } ->\n let prf_desc = self#row_field_desc prf_desc in\n let prf_loc = self#location prf_loc in\n let prf_attributes = self#attributes prf_attributes in\n { prf_desc; prf_loc; prf_attributes }\n\n method row_field_desc : row_field_desc -> row_field_desc =\n fun x ->\n match x with\n | Rtag (a, b, c) ->\n let a = self#loc self#label a in\n let b = self#bool b in\n let c = self#list self#core_type c in\n Rtag (a, b, c)\n | Rinherit a ->\n let a = self#core_type a in\n Rinherit a\n\n method object_field : object_field -> object_field =\n fun { pof_desc; pof_loc; pof_attributes } ->\n let pof_desc = self#object_field_desc pof_desc in\n let pof_loc = self#location pof_loc in\n let pof_attributes = self#attributes pof_attributes in\n { pof_desc; pof_loc; pof_attributes }\n\n method object_field_desc : object_field_desc -> object_field_desc =\n fun x ->\n match x with\n | Otag (a, b) ->\n let a = self#loc self#label a in\n let b = self#core_type b in\n Otag (a, b)\n | Oinherit a ->\n let a = self#core_type a in\n Oinherit a\n\n method pattern : pattern -> pattern =\n fun { ppat_desc; ppat_loc; ppat_loc_stack; ppat_attributes } ->\n let ppat_desc = self#pattern_desc ppat_desc in\n let ppat_loc = self#location ppat_loc in\n let ppat_loc_stack = self#location_stack ppat_loc_stack in\n let ppat_attributes = self#attributes ppat_attributes in\n { ppat_desc; ppat_loc; ppat_loc_stack; ppat_attributes }\n\n method pattern_desc : pattern_desc -> pattern_desc =\n fun x ->\n match x with\n | Ppat_any -> Ppat_any\n | Ppat_var a ->\n let a = self#loc self#string a in\n Ppat_var a\n | Ppat_alias (a, b) ->\n let a = self#pattern a in\n let b = self#loc self#string b in\n Ppat_alias (a, b)\n | Ppat_constant a ->\n let a = self#constant a in\n Ppat_constant a\n | Ppat_interval (a, b) ->\n let a = self#constant a in\n let b = self#constant b in\n Ppat_interval (a, b)\n | Ppat_tuple a ->\n let a = self#list self#pattern a in\n Ppat_tuple a\n | Ppat_construct (a, b) ->\n let a = self#longident_loc a in\n let b = self#option self#pattern b in\n Ppat_construct (a, b)\n | Ppat_variant (a, b) ->\n let a = self#label a in\n let b = self#option self#pattern b in\n Ppat_variant (a, b)\n | Ppat_record (a, b) ->\n let a =\n self#list\n (fun (a, b) ->\n let a = self#longident_loc a in\n let b = self#pattern b in\n (a, b))\n a\n in\n let b = self#closed_flag b in\n Ppat_record (a, b)\n | Ppat_array a ->\n let a = self#list self#pattern a in\n Ppat_array a\n | Ppat_or (a, b) ->\n let a = self#pattern a in\n let b = self#pattern b in\n Ppat_or (a, b)\n | Ppat_constraint (a, b) ->\n let a = self#pattern a in\n let b = self#core_type b in\n Ppat_constraint (a, b)\n | Ppat_type a ->\n let a = self#longident_loc a in\n Ppat_type a\n | Ppat_lazy a ->\n let a = self#pattern a in\n Ppat_lazy a\n | Ppat_unpack a ->\n let a = self#loc (self#option self#string) a in\n Ppat_unpack a\n | Ppat_exception a ->\n let a = self#pattern a in\n Ppat_exception a\n | Ppat_extension a ->\n let a = self#extension a in\n Ppat_extension a\n | Ppat_open (a, b) ->\n let a = self#longident_loc a in\n let b = self#pattern b in\n Ppat_open (a, b)\n\n method expression : expression -> expression =\n fun { pexp_desc; pexp_loc; pexp_loc_stack; pexp_attributes } ->\n let pexp_desc = self#expression_desc pexp_desc in\n let pexp_loc = self#location pexp_loc in\n let pexp_loc_stack = self#location_stack pexp_loc_stack in\n let pexp_attributes = self#attributes pexp_attributes in\n { pexp_desc; pexp_loc; pexp_loc_stack; pexp_attributes }\n\n method expression_desc : expression_desc -> expression_desc =\n fun x ->\n match x with\n | Pexp_ident a ->\n let a = self#longident_loc a in\n Pexp_ident a\n | Pexp_constant a ->\n let a = self#constant a in\n Pexp_constant a\n | Pexp_let (a, b, c) ->\n let a = self#rec_flag a in\n let b = self#list self#value_binding b in\n let c = self#expression c in\n Pexp_let (a, b, c)\n | Pexp_function a ->\n let a = self#cases a in\n Pexp_function a\n | Pexp_fun (a, b, c, d) ->\n let a = self#arg_label a in\n let b = self#option self#expression b in\n let c = self#pattern c in\n let d = self#expression d in\n Pexp_fun (a, b, c, d)\n | Pexp_apply (a, b) ->\n let a = self#expression a in\n let b =\n self#list\n (fun (a, b) ->\n let a = self#arg_label a in\n let b = self#expression b in\n (a, b))\n b\n in\n Pexp_apply (a, b)\n | Pexp_match (a, b) ->\n let a = self#expression a in\n let b = self#cases b in\n Pexp_match (a, b)\n | Pexp_try (a, b) ->\n let a = self#expression a in\n let b = self#cases b in\n Pexp_try (a, b)\n | Pexp_tuple a ->\n let a = self#list self#expression a in\n Pexp_tuple a\n | Pexp_construct (a, b) ->\n let a = self#longident_loc a in\n let b = self#option self#expression b in\n Pexp_construct (a, b)\n | Pexp_variant (a, b) ->\n let a = self#label a in\n let b = self#option self#expression b in\n Pexp_variant (a, b)\n | Pexp_record (a, b) ->\n let a =\n self#list\n (fun (a, b) ->\n let a = self#longident_loc a in\n let b = self#expression b in\n (a, b))\n a\n in\n let b = self#option self#expression b in\n Pexp_record (a, b)\n | Pexp_field (a, b) ->\n let a = self#expression a in\n let b = self#longident_loc b in\n Pexp_field (a, b)\n | Pexp_setfield (a, b, c) ->\n let a = self#expression a in\n let b = self#longident_loc b in\n let c = self#expression c in\n Pexp_setfield (a, b, c)\n | Pexp_array a ->\n let a = self#list self#expression a in\n Pexp_array a\n | Pexp_ifthenelse (a, b, c) ->\n let a = self#expression a in\n let b = self#expression b in\n let c = self#option self#expression c in\n Pexp_ifthenelse (a, b, c)\n | Pexp_sequence (a, b) ->\n let a = self#expression a in\n let b = self#expression b in\n Pexp_sequence (a, b)\n | Pexp_while (a, b) ->\n let a = self#expression a in\n let b = self#expression b in\n Pexp_while (a, b)\n | Pexp_for (a, b, c, d, e) ->\n let a = self#pattern a in\n let b = self#expression b in\n let c = self#expression c in\n let d = self#direction_flag d in\n let e = self#expression e in\n Pexp_for (a, b, c, d, e)\n | Pexp_constraint (a, b) ->\n let a = self#expression a in\n let b = self#core_type b in\n Pexp_constraint (a, b)\n | Pexp_coerce (a, b, c) ->\n let a = self#expression a in\n let b = self#option self#core_type b in\n let c = self#core_type c in\n Pexp_coerce (a, b, c)\n | Pexp_send (a, b) ->\n let a = self#expression a in\n let b = self#loc self#label b in\n Pexp_send (a, b)\n | Pexp_new a ->\n let a = self#longident_loc a in\n Pexp_new a\n | Pexp_setinstvar (a, b) ->\n let a = self#loc self#label a in\n let b = self#expression b in\n Pexp_setinstvar (a, b)\n | Pexp_override a ->\n let a =\n self#list\n (fun (a, b) ->\n let a = self#loc self#label a in\n let b = self#expression b in\n (a, b))\n a\n in\n Pexp_override a\n | Pexp_letmodule (a, b, c) ->\n let a = self#loc (self#option self#string) a in\n let b = self#module_expr b in\n let c = self#expression c in\n Pexp_letmodule (a, b, c)\n | Pexp_letexception (a, b) ->\n let a = self#extension_constructor a in\n let b = self#expression b in\n Pexp_letexception (a, b)\n | Pexp_assert a ->\n let a = self#expression a in\n Pexp_assert a\n | Pexp_lazy a ->\n let a = self#expression a in\n Pexp_lazy a\n | Pexp_poly (a, b) ->\n let a = self#expression a in\n let b = self#option self#core_type b in\n Pexp_poly (a, b)\n | Pexp_object a ->\n let a = self#class_structure a in\n Pexp_object a\n | Pexp_newtype (a, b) ->\n let a = self#loc self#string a in\n let b = self#expression b in\n Pexp_newtype (a, b)\n | Pexp_pack a ->\n let a = self#module_expr a in\n Pexp_pack a\n | Pexp_open (a, b) ->\n let a = self#open_declaration a in\n let b = self#expression b in\n Pexp_open (a, b)\n | Pexp_letop a ->\n let a = self#letop a in\n Pexp_letop a\n | Pexp_extension a ->\n let a = self#extension a in\n Pexp_extension a\n | Pexp_unreachable -> Pexp_unreachable\n\n method case : case -> case =\n fun { pc_lhs; pc_guard; pc_rhs } ->\n let pc_lhs = self#pattern pc_lhs in\n let pc_guard = self#option self#expression pc_guard in\n let pc_rhs = self#expression pc_rhs in\n { pc_lhs; pc_guard; pc_rhs }\n\n method letop : letop -> letop =\n fun { let_; ands; body } ->\n let let_ = self#binding_op let_ in\n let ands = self#list self#binding_op ands in\n let body = self#expression body in\n { let_; ands; body }\n\n method binding_op : binding_op -> binding_op =\n fun { pbop_op; pbop_pat; pbop_exp; pbop_loc } ->\n let pbop_op = self#loc self#string pbop_op in\n let pbop_pat = self#pattern pbop_pat in\n let pbop_exp = self#expression pbop_exp in\n let pbop_loc = self#location pbop_loc in\n { pbop_op; pbop_pat; pbop_exp; pbop_loc }\n\n method value_description : value_description -> value_description =\n fun { pval_name; pval_type; pval_prim; pval_attributes; pval_loc } ->\n let pval_name = self#loc self#string pval_name in\n let pval_type = self#core_type pval_type in\n let pval_prim = self#list self#string pval_prim in\n let pval_attributes = self#attributes pval_attributes in\n let pval_loc = self#location pval_loc in\n { pval_name; pval_type; pval_prim; pval_attributes; pval_loc }\n\n method type_declaration : type_declaration -> type_declaration =\n fun {\n ptype_name;\n ptype_params;\n ptype_cstrs;\n ptype_kind;\n ptype_private;\n ptype_manifest;\n ptype_attributes;\n ptype_loc;\n } ->\n let ptype_name = self#loc self#string ptype_name in\n let ptype_params =\n self#list\n (fun (a, b) ->\n let a = self#core_type a in\n let b =\n (fun (a, b) ->\n let a = self#variance a in\n let b = self#injectivity b in\n (a, b))\n b\n in\n (a, b))\n ptype_params\n in\n let ptype_cstrs =\n self#list\n (fun (a, b, c) ->\n let a = self#core_type a in\n let b = self#core_type b in\n let c = self#location c in\n (a, b, c))\n ptype_cstrs\n in\n let ptype_kind = self#type_kind ptype_kind in\n let ptype_private = self#private_flag ptype_private in\n let ptype_manifest = self#option self#core_type ptype_manifest in\n let ptype_attributes = self#attributes ptype_attributes in\n let ptype_loc = self#location ptype_loc in\n {\n ptype_name;\n ptype_params;\n ptype_cstrs;\n ptype_kind;\n ptype_private;\n ptype_manifest;\n ptype_attributes;\n ptype_loc;\n }\n\n method type_kind : type_kind -> type_kind =\n fun x ->\n match x with\n | Ptype_abstract -> Ptype_abstract\n | Ptype_variant a ->\n let a = self#list self#constructor_declaration a in\n Ptype_variant a\n | Ptype_record a ->\n let a = self#list self#label_declaration a in\n Ptype_record a\n | Ptype_open -> Ptype_open\n\n method label_declaration : label_declaration -> label_declaration =\n fun { pld_name; pld_mutable; pld_type; pld_loc; pld_attributes } ->\n let pld_name = self#loc self#string pld_name in\n let pld_mutable = self#mutable_flag pld_mutable in\n let pld_type = self#core_type pld_type in\n let pld_loc = self#location pld_loc in\n let pld_attributes = self#attributes pld_attributes in\n { pld_name; pld_mutable; pld_type; pld_loc; pld_attributes }\n\n method constructor_declaration\n : constructor_declaration -> constructor_declaration =\n fun { pcd_name; pcd_args; pcd_res; pcd_loc; pcd_attributes } ->\n let pcd_name = self#loc self#string pcd_name in\n let pcd_args = self#constructor_arguments pcd_args in\n let pcd_res = self#option self#core_type pcd_res in\n let pcd_loc = self#location pcd_loc in\n let pcd_attributes = self#attributes pcd_attributes in\n { pcd_name; pcd_args; pcd_res; pcd_loc; pcd_attributes }\n\n method constructor_arguments\n : constructor_arguments -> constructor_arguments =\n fun x ->\n match x with\n | Pcstr_tuple a ->\n let a = self#list self#core_type a in\n Pcstr_tuple a\n | Pcstr_record a ->\n let a = self#list self#label_declaration a in\n Pcstr_record a\n\n method type_extension : type_extension -> type_extension =\n fun {\n ptyext_path;\n ptyext_params;\n ptyext_constructors;\n ptyext_private;\n ptyext_loc;\n ptyext_attributes;\n } ->\n let ptyext_path = self#longident_loc ptyext_path in\n let ptyext_params =\n self#list\n (fun (a, b) ->\n let a = self#core_type a in\n let b =\n (fun (a, b) ->\n let a = self#variance a in\n let b = self#injectivity b in\n (a, b))\n b\n in\n (a, b))\n ptyext_params\n in\n let ptyext_constructors =\n self#list self#extension_constructor ptyext_constructors\n in\n let ptyext_private = self#private_flag ptyext_private in\n let ptyext_loc = self#location ptyext_loc in\n let ptyext_attributes = self#attributes ptyext_attributes in\n {\n ptyext_path;\n ptyext_params;\n ptyext_constructors;\n ptyext_private;\n ptyext_loc;\n ptyext_attributes;\n }\n\n method extension_constructor\n : extension_constructor -> extension_constructor =\n fun { pext_name; pext_kind; pext_loc; pext_attributes } ->\n let pext_name = self#loc self#string pext_name in\n let pext_kind = self#extension_constructor_kind pext_kind in\n let pext_loc = self#location pext_loc in\n let pext_attributes = self#attributes pext_attributes in\n { pext_name; pext_kind; pext_loc; pext_attributes }\n\n method type_exception : type_exception -> type_exception =\n fun { ptyexn_constructor; ptyexn_loc; ptyexn_attributes } ->\n let ptyexn_constructor =\n self#extension_constructor ptyexn_constructor\n in\n let ptyexn_loc = self#location ptyexn_loc in\n let ptyexn_attributes = self#attributes ptyexn_attributes in\n { ptyexn_constructor; ptyexn_loc; ptyexn_attributes }\n\n method extension_constructor_kind\n : extension_constructor_kind -> extension_constructor_kind =\n fun x ->\n match x with\n | Pext_decl (a, b) ->\n let a = self#constructor_arguments a in\n let b = self#option self#core_type b in\n Pext_decl (a, b)\n | Pext_rebind a ->\n let a = self#longident_loc a in\n Pext_rebind a\n\n method class_type : class_type -> class_type =\n fun { pcty_desc; pcty_loc; pcty_attributes } ->\n let pcty_desc = self#class_type_desc pcty_desc in\n let pcty_loc = self#location pcty_loc in\n let pcty_attributes = self#attributes pcty_attributes in\n { pcty_desc; pcty_loc; pcty_attributes }\n\n method class_type_desc : class_type_desc -> class_type_desc =\n fun x ->\n match x with\n | Pcty_constr (a, b) ->\n let a = self#longident_loc a in\n let b = self#list self#core_type b in\n Pcty_constr (a, b)\n | Pcty_signature a ->\n let a = self#class_signature a in\n Pcty_signature a\n | Pcty_arrow (a, b, c) ->\n let a = self#arg_label a in\n let b = self#core_type b in\n let c = self#class_type c in\n Pcty_arrow (a, b, c)\n | Pcty_extension a ->\n let a = self#extension a in\n Pcty_extension a\n | Pcty_open (a, b) ->\n let a = self#open_description a in\n let b = self#class_type b in\n Pcty_open (a, b)\n\n method class_signature : class_signature -> class_signature =\n fun { pcsig_self; pcsig_fields } ->\n let pcsig_self = self#core_type pcsig_self in\n let pcsig_fields = self#list self#class_type_field pcsig_fields in\n { pcsig_self; pcsig_fields }\n\n method class_type_field : class_type_field -> class_type_field =\n fun { pctf_desc; pctf_loc; pctf_attributes } ->\n let pctf_desc = self#class_type_field_desc pctf_desc in\n let pctf_loc = self#location pctf_loc in\n let pctf_attributes = self#attributes pctf_attributes in\n { pctf_desc; pctf_loc; pctf_attributes }\n\n method class_type_field_desc\n : class_type_field_desc -> class_type_field_desc =\n fun x ->\n match x with\n | Pctf_inherit a ->\n let a = self#class_type a in\n Pctf_inherit a\n | Pctf_val a ->\n let a =\n (fun (a, b, c, d) ->\n let a = self#loc self#label a in\n let b = self#mutable_flag b in\n let c = self#virtual_flag c in\n let d = self#core_type d in\n (a, b, c, d))\n a\n in\n Pctf_val a\n | Pctf_method a ->\n let a =\n (fun (a, b, c, d) ->\n let a = self#loc self#label a in\n let b = self#private_flag b in\n let c = self#virtual_flag c in\n let d = self#core_type d in\n (a, b, c, d))\n a\n in\n Pctf_method a\n | Pctf_constraint a ->\n let a =\n (fun (a, b) ->\n let a = self#core_type a in\n let b = self#core_type b in\n (a, b))\n a\n in\n Pctf_constraint a\n | Pctf_attribute a ->\n let a = self#attribute a in\n Pctf_attribute a\n | Pctf_extension a ->\n let a = self#extension a in\n Pctf_extension a\n\n method class_infos : 'a. ('a -> 'a) -> 'a class_infos -> 'a class_infos =\n fun _a\n { pci_virt; pci_params; pci_name; pci_expr; pci_loc; pci_attributes } ->\n let pci_virt = self#virtual_flag pci_virt in\n let pci_params =\n self#list\n (fun (a, b) ->\n let a = self#core_type a in\n let b =\n (fun (a, b) ->\n let a = self#variance a in\n let b = self#injectivity b in\n (a, b))\n b\n in\n (a, b))\n pci_params\n in\n let pci_name = self#loc self#string pci_name in\n let pci_expr = _a pci_expr in\n let pci_loc = self#location pci_loc in\n let pci_attributes = self#attributes pci_attributes in\n { pci_virt; pci_params; pci_name; pci_expr; pci_loc; pci_attributes }\n\n method class_description : class_description -> class_description =\n self#class_infos self#class_type\n\n method class_type_declaration\n : class_type_declaration -> class_type_declaration =\n self#class_infos self#class_type\n\n method class_expr : class_expr -> class_expr =\n fun { pcl_desc; pcl_loc; pcl_attributes } ->\n let pcl_desc = self#class_expr_desc pcl_desc in\n let pcl_loc = self#location pcl_loc in\n let pcl_attributes = self#attributes pcl_attributes in\n { pcl_desc; pcl_loc; pcl_attributes }\n\n method class_expr_desc : class_expr_desc -> class_expr_desc =\n fun x ->\n match x with\n | Pcl_constr (a, b) ->\n let a = self#longident_loc a in\n let b = self#list self#core_type b in\n Pcl_constr (a, b)\n | Pcl_structure a ->\n let a = self#class_structure a in\n Pcl_structure a\n | Pcl_fun (a, b, c, d) ->\n let a = self#arg_label a in\n let b = self#option self#expression b in\n let c = self#pattern c in\n let d = self#class_expr d in\n Pcl_fun (a, b, c, d)\n | Pcl_apply (a, b) ->\n let a = self#class_expr a in\n let b =\n self#list\n (fun (a, b) ->\n let a = self#arg_label a in\n let b = self#expression b in\n (a, b))\n b\n in\n Pcl_apply (a, b)\n | Pcl_let (a, b, c) ->\n let a = self#rec_flag a in\n let b = self#list self#value_binding b in\n let c = self#class_expr c in\n Pcl_let (a, b, c)\n | Pcl_constraint (a, b) ->\n let a = self#class_expr a in\n let b = self#class_type b in\n Pcl_constraint (a, b)\n | Pcl_extension a ->\n let a = self#extension a in\n Pcl_extension a\n | Pcl_open (a, b) ->\n let a = self#open_description a in\n let b = self#class_expr b in\n Pcl_open (a, b)\n\n method class_structure : class_structure -> class_structure =\n fun { pcstr_self; pcstr_fields } ->\n let pcstr_self = self#pattern pcstr_self in\n let pcstr_fields = self#list self#class_field pcstr_fields in\n { pcstr_self; pcstr_fields }\n\n method class_field : class_field -> class_field =\n fun { pcf_desc; pcf_loc; pcf_attributes } ->\n let pcf_desc = self#class_field_desc pcf_desc in\n let pcf_loc = self#location pcf_loc in\n let pcf_attributes = self#attributes pcf_attributes in\n { pcf_desc; pcf_loc; pcf_attributes }\n\n method class_field_desc : class_field_desc -> class_field_desc =\n fun x ->\n match x with\n | Pcf_inherit (a, b, c) ->\n let a = self#override_flag a in\n let b = self#class_expr b in\n let c = self#option (self#loc self#string) c in\n Pcf_inherit (a, b, c)\n | Pcf_val a ->\n let a =\n (fun (a, b, c) ->\n let a = self#loc self#label a in\n let b = self#mutable_flag b in\n let c = self#class_field_kind c in\n (a, b, c))\n a\n in\n Pcf_val a\n | Pcf_method a ->\n let a =\n (fun (a, b, c) ->\n let a = self#loc self#label a in\n let b = self#private_flag b in\n let c = self#class_field_kind c in\n (a, b, c))\n a\n in\n Pcf_method a\n | Pcf_constraint a ->\n let a =\n (fun (a, b) ->\n let a = self#core_type a in\n let b = self#core_type b in\n (a, b))\n a\n in\n Pcf_constraint a\n | Pcf_initializer a ->\n let a = self#expression a in\n Pcf_initializer a\n | Pcf_attribute a ->\n let a = self#attribute a in\n Pcf_attribute a\n | Pcf_extension a ->\n let a = self#extension a in\n Pcf_extension a\n\n method class_field_kind : class_field_kind -> class_field_kind =\n fun x ->\n match x with\n | Cfk_virtual a ->\n let a = self#core_type a in\n Cfk_virtual a\n | Cfk_concrete (a, b) ->\n let a = self#override_flag a in\n let b = self#expression b in\n Cfk_concrete (a, b)\n\n method class_declaration : class_declaration -> class_declaration =\n self#class_infos self#class_expr\n\n method module_type : module_type -> module_type =\n fun { pmty_desc; pmty_loc; pmty_attributes } ->\n let pmty_desc = self#module_type_desc pmty_desc in\n let pmty_loc = self#location pmty_loc in\n let pmty_attributes = self#attributes pmty_attributes in\n { pmty_desc; pmty_loc; pmty_attributes }\n\n method module_type_desc : module_type_desc -> module_type_desc =\n fun x ->\n match x with\n | Pmty_ident a ->\n let a = self#longident_loc a in\n Pmty_ident a\n | Pmty_signature a ->\n let a = self#signature a in\n Pmty_signature a\n | Pmty_functor (a, b) ->\n let a = self#functor_parameter a in\n let b = self#module_type b in\n Pmty_functor (a, b)\n | Pmty_with (a, b) ->\n let a = self#module_type a in\n let b = self#list self#with_constraint b in\n Pmty_with (a, b)\n | Pmty_typeof a ->\n let a = self#module_expr a in\n Pmty_typeof a\n | Pmty_extension a ->\n let a = self#extension a in\n Pmty_extension a\n | Pmty_alias a ->\n let a = self#longident_loc a in\n Pmty_alias a\n\n method functor_parameter : functor_parameter -> functor_parameter =\n fun x ->\n match x with\n | Unit -> Unit\n | Named (a, b) ->\n let a = self#loc (self#option self#string) a in\n let b = self#module_type b in\n Named (a, b)\n\n method signature : signature -> signature = self#list self#signature_item\n\n method signature_item : signature_item -> signature_item =\n fun { psig_desc; psig_loc } ->\n let psig_desc = self#signature_item_desc psig_desc in\n let psig_loc = self#location psig_loc in\n { psig_desc; psig_loc }\n\n method signature_item_desc : signature_item_desc -> signature_item_desc =\n fun x ->\n match x with\n | Psig_value a ->\n let a = self#value_description a in\n Psig_value a\n | Psig_type (a, b) ->\n let a = self#rec_flag a in\n let b = self#list self#type_declaration b in\n Psig_type (a, b)\n | Psig_typesubst a ->\n let a = self#list self#type_declaration a in\n Psig_typesubst a\n | Psig_typext a ->\n let a = self#type_extension a in\n Psig_typext a\n | Psig_exception a ->\n let a = self#type_exception a in\n Psig_exception a\n | Psig_module a ->\n let a = self#module_declaration a in\n Psig_module a\n | Psig_modsubst a ->\n let a = self#module_substitution a in\n Psig_modsubst a\n | Psig_recmodule a ->\n let a = self#list self#module_declaration a in\n Psig_recmodule a\n | Psig_modtype a ->\n let a = self#module_type_declaration a in\n Psig_modtype a\n | Psig_open a ->\n let a = self#open_description a in\n Psig_open a\n | Psig_include a ->\n let a = self#include_description a in\n Psig_include a\n | Psig_class a ->\n let a = self#list self#class_description a in\n Psig_class a\n | Psig_class_type a ->\n let a = self#list self#class_type_declaration a in\n Psig_class_type a\n | Psig_attribute a ->\n let a = self#attribute a in\n Psig_attribute a\n | Psig_extension (a, b) ->\n let a = self#extension a in\n let b = self#attributes b in\n Psig_extension (a, b)\n\n method module_declaration : module_declaration -> module_declaration =\n fun { pmd_name; pmd_type; pmd_attributes; pmd_loc } ->\n let pmd_name = self#loc (self#option self#string) pmd_name in\n let pmd_type = self#module_type pmd_type in\n let pmd_attributes = self#attributes pmd_attributes in\n let pmd_loc = self#location pmd_loc in\n { pmd_name; pmd_type; pmd_attributes; pmd_loc }\n\n method module_substitution : module_substitution -> module_substitution =\n fun { pms_name; pms_manifest; pms_attributes; pms_loc } ->\n let pms_name = self#loc self#string pms_name in\n let pms_manifest = self#longident_loc pms_manifest in\n let pms_attributes = self#attributes pms_attributes in\n let pms_loc = self#location pms_loc in\n { pms_name; pms_manifest; pms_attributes; pms_loc }\n\n method module_type_declaration\n : module_type_declaration -> module_type_declaration =\n fun { pmtd_name; pmtd_type; pmtd_attributes; pmtd_loc } ->\n let pmtd_name = self#loc self#string pmtd_name in\n let pmtd_type = self#option self#module_type pmtd_type in\n let pmtd_attributes = self#attributes pmtd_attributes in\n let pmtd_loc = self#location pmtd_loc in\n { pmtd_name; pmtd_type; pmtd_attributes; pmtd_loc }\n\n method open_infos : 'a. ('a -> 'a) -> 'a open_infos -> 'a open_infos =\n fun _a { popen_expr; popen_override; popen_loc; popen_attributes } ->\n let popen_expr = _a popen_expr in\n let popen_override = self#override_flag popen_override in\n let popen_loc = self#location popen_loc in\n let popen_attributes = self#attributes popen_attributes in\n { popen_expr; popen_override; popen_loc; popen_attributes }\n\n method open_description : open_description -> open_description =\n self#open_infos self#longident_loc\n\n method open_declaration : open_declaration -> open_declaration =\n self#open_infos self#module_expr\n\n method include_infos\n : 'a. ('a -> 'a) -> 'a include_infos -> 'a include_infos =\n fun _a { pincl_mod; pincl_loc; pincl_attributes } ->\n let pincl_mod = _a pincl_mod in\n let pincl_loc = self#location pincl_loc in\n let pincl_attributes = self#attributes pincl_attributes in\n { pincl_mod; pincl_loc; pincl_attributes }\n\n method include_description : include_description -> include_description =\n self#include_infos self#module_type\n\n method include_declaration : include_declaration -> include_declaration =\n self#include_infos self#module_expr\n\n method with_constraint : with_constraint -> with_constraint =\n fun x ->\n match x with\n | Pwith_type (a, b) ->\n let a = self#longident_loc a in\n let b = self#type_declaration b in\n Pwith_type (a, b)\n | Pwith_module (a, b) ->\n let a = self#longident_loc a in\n let b = self#longident_loc b in\n Pwith_module (a, b)\n | Pwith_typesubst (a, b) ->\n let a = self#longident_loc a in\n let b = self#type_declaration b in\n Pwith_typesubst (a, b)\n | Pwith_modsubst (a, b) ->\n let a = self#longident_loc a in\n let b = self#longident_loc b in\n Pwith_modsubst (a, b)\n\n method module_expr : module_expr -> module_expr =\n fun { pmod_desc; pmod_loc; pmod_attributes } ->\n let pmod_desc = self#module_expr_desc pmod_desc in\n let pmod_loc = self#location pmod_loc in\n let pmod_attributes = self#attributes pmod_attributes in\n { pmod_desc; pmod_loc; pmod_attributes }\n\n method module_expr_desc : module_expr_desc -> module_expr_desc =\n fun x ->\n match x with\n | Pmod_ident a ->\n let a = self#longident_loc a in\n Pmod_ident a\n | Pmod_structure a ->\n let a = self#structure a in\n Pmod_structure a\n | Pmod_functor (a, b) ->\n let a = self#functor_parameter a in\n let b = self#module_expr b in\n Pmod_functor (a, b)\n | Pmod_apply (a, b) ->\n let a = self#module_expr a in\n let b = self#module_expr b in\n Pmod_apply (a, b)\n | Pmod_constraint (a, b) ->\n let a = self#module_expr a in\n let b = self#module_type b in\n Pmod_constraint (a, b)\n | Pmod_unpack a ->\n let a = self#expression a in\n Pmod_unpack a\n | Pmod_extension a ->\n let a = self#extension a in\n Pmod_extension a\n\n method structure : structure -> structure = self#list self#structure_item\n\n method structure_item : structure_item -> structure_item =\n fun { pstr_desc; pstr_loc } ->\n let pstr_desc = self#structure_item_desc pstr_desc in\n let pstr_loc = self#location pstr_loc in\n { pstr_desc; pstr_loc }\n\n method structure_item_desc : structure_item_desc -> structure_item_desc =\n fun x ->\n match x with\n | Pstr_eval (a, b) ->\n let a = self#expression a in\n let b = self#attributes b in\n Pstr_eval (a, b)\n | Pstr_value (a, b) ->\n let a = self#rec_flag a in\n let b = self#list self#value_binding b in\n Pstr_value (a, b)\n | Pstr_primitive a ->\n let a = self#value_description a in\n Pstr_primitive a\n | Pstr_type (a, b) ->\n let a = self#rec_flag a in\n let b = self#list self#type_declaration b in\n Pstr_type (a, b)\n | Pstr_typext a ->\n let a = self#type_extension a in\n Pstr_typext a\n | Pstr_exception a ->\n let a = self#type_exception a in\n Pstr_exception a\n | Pstr_module a ->\n let a = self#module_binding a in\n Pstr_module a\n | Pstr_recmodule a ->\n let a = self#list self#module_binding a in\n Pstr_recmodule a\n | Pstr_modtype a ->\n let a = self#module_type_declaration a in\n Pstr_modtype a\n | Pstr_open a ->\n let a = self#open_declaration a in\n Pstr_open a\n | Pstr_class a ->\n let a = self#list self#class_declaration a in\n Pstr_class a\n | Pstr_class_type a ->\n let a = self#list self#class_type_declaration a in\n Pstr_class_type a\n | Pstr_include a ->\n let a = self#include_declaration a in\n Pstr_include a\n | Pstr_attribute a ->\n let a = self#attribute a in\n Pstr_attribute a\n | Pstr_extension (a, b) ->\n let a = self#extension a in\n let b = self#attributes b in\n Pstr_extension (a, b)\n\n method value_binding : value_binding -> value_binding =\n fun { pvb_pat; pvb_expr; pvb_attributes; pvb_loc } ->\n let pvb_pat = self#pattern pvb_pat in\n let pvb_expr = self#expression pvb_expr in\n let pvb_attributes = self#attributes pvb_attributes in\n let pvb_loc = self#location pvb_loc in\n { pvb_pat; pvb_expr; pvb_attributes; pvb_loc }\n\n method module_binding : module_binding -> module_binding =\n fun { pmb_name; pmb_expr; pmb_attributes; pmb_loc } ->\n let pmb_name = self#loc (self#option self#string) pmb_name in\n let pmb_expr = self#module_expr pmb_expr in\n let pmb_attributes = self#attributes pmb_attributes in\n let pmb_loc = self#location pmb_loc in\n { pmb_name; pmb_expr; pmb_attributes; pmb_loc }\n\n method toplevel_phrase : toplevel_phrase -> toplevel_phrase =\n fun x ->\n match x with\n | Ptop_def a ->\n let a = self#structure a in\n Ptop_def a\n | Ptop_dir a ->\n let a = self#toplevel_directive a in\n Ptop_dir a\n\n method toplevel_directive : toplevel_directive -> toplevel_directive =\n fun { pdir_name; pdir_arg; pdir_loc } ->\n let pdir_name = self#loc self#string pdir_name in\n let pdir_arg = self#option self#directive_argument pdir_arg in\n let pdir_loc = self#location pdir_loc in\n { pdir_name; pdir_arg; pdir_loc }\n\n method directive_argument : directive_argument -> directive_argument =\n fun { pdira_desc; pdira_loc } ->\n let pdira_desc = self#directive_argument_desc pdira_desc in\n let pdira_loc = self#location pdira_loc in\n { pdira_desc; pdira_loc }\n\n method directive_argument_desc\n : directive_argument_desc -> directive_argument_desc =\n fun x ->\n match x with\n | Pdir_string a ->\n let a = self#string a in\n Pdir_string a\n | Pdir_int (a, b) ->\n let a = self#string a in\n let b = self#option self#char b in\n Pdir_int (a, b)\n | Pdir_ident a ->\n let a = self#longident a in\n Pdir_ident a\n | Pdir_bool a ->\n let a = self#bool a in\n Pdir_bool a\n\n method cases : cases -> cases = self#list self#case\n end\n\nclass virtual iter =\n object (self)\n method virtual bool : bool -> unit\n method virtual char : char -> unit\n method virtual int : int -> unit\n method virtual list : 'a. ('a -> unit) -> 'a list -> unit\n method virtual option : 'a. ('a -> unit) -> 'a option -> unit\n method virtual string : string -> unit\n\n method position : position -> unit =\n fun { pos_fname; pos_lnum; pos_bol; pos_cnum } ->\n self#string pos_fname;\n self#int pos_lnum;\n self#int pos_bol;\n self#int pos_cnum\n\n method location : location -> unit =\n fun { loc_start; loc_end; loc_ghost } ->\n self#position loc_start;\n self#position loc_end;\n self#bool loc_ghost\n\n method location_stack : location_stack -> unit = self#list self#location\n\n method loc : 'a. ('a -> unit) -> 'a loc -> unit =\n fun _a { txt; loc } ->\n _a txt;\n self#location loc\n\n method longident : longident -> unit =\n fun x ->\n match x with\n | Lident a -> self#string a\n | Ldot (a, b) ->\n self#longident a;\n self#string b\n | Lapply (a, b) ->\n self#longident a;\n self#longident b\n\n method longident_loc : longident_loc -> unit = self#loc self#longident\n method rec_flag : rec_flag -> unit = fun _ -> ()\n method direction_flag : direction_flag -> unit = fun _ -> ()\n method private_flag : private_flag -> unit = fun _ -> ()\n method mutable_flag : mutable_flag -> unit = fun _ -> ()\n method virtual_flag : virtual_flag -> unit = fun _ -> ()\n method override_flag : override_flag -> unit = fun _ -> ()\n method closed_flag : closed_flag -> unit = fun _ -> ()\n method label : label -> unit = self#string\n\n method arg_label : arg_label -> unit =\n fun x ->\n match x with\n | Nolabel -> ()\n | Labelled a -> self#string a\n | Optional a -> self#string a\n\n method variance : variance -> unit = fun _ -> ()\n method injectivity : injectivity -> unit = fun _ -> ()\n\n method constant : constant -> unit =\n fun x ->\n match x with\n | Pconst_integer (a, b) ->\n self#string a;\n self#option self#char b\n | Pconst_char a -> self#char a\n | Pconst_string (a, b, c) ->\n self#string a;\n self#location b;\n self#option self#string c\n | Pconst_float (a, b) ->\n self#string a;\n self#option self#char b\n\n method attribute : attribute -> unit =\n fun { attr_name; attr_payload; attr_loc } ->\n self#loc self#string attr_name;\n self#payload attr_payload;\n self#location attr_loc\n\n method extension : extension -> unit =\n fun (a, b) ->\n self#loc self#string a;\n self#payload b\n\n method attributes : attributes -> unit = self#list self#attribute\n\n method payload : payload -> unit =\n fun x ->\n match x with\n | PStr a -> self#structure a\n | PSig a -> self#signature a\n | PTyp a -> self#core_type a\n | PPat (a, b) ->\n self#pattern a;\n self#option self#expression b\n\n method core_type : core_type -> unit =\n fun { ptyp_desc; ptyp_loc; ptyp_loc_stack; ptyp_attributes } ->\n self#core_type_desc ptyp_desc;\n self#location ptyp_loc;\n self#location_stack ptyp_loc_stack;\n self#attributes ptyp_attributes\n\n method core_type_desc : core_type_desc -> unit =\n fun x ->\n match x with\n | Ptyp_any -> ()\n | Ptyp_var a -> self#string a\n | Ptyp_arrow (a, b, c) ->\n self#arg_label a;\n self#core_type b;\n self#core_type c\n | Ptyp_tuple a -> self#list self#core_type a\n | Ptyp_constr (a, b) ->\n self#longident_loc a;\n self#list self#core_type b\n | Ptyp_object (a, b) ->\n self#list self#object_field a;\n self#closed_flag b\n | Ptyp_class (a, b) ->\n self#longident_loc a;\n self#list self#core_type b\n | Ptyp_alias (a, b) ->\n self#core_type a;\n self#string b\n | Ptyp_variant (a, b, c) ->\n self#list self#row_field a;\n self#closed_flag b;\n self#option (self#list self#label) c\n | Ptyp_poly (a, b) ->\n self#list (self#loc self#string) a;\n self#core_type b\n | Ptyp_package a -> self#package_type a\n | Ptyp_extension a -> self#extension a\n\n method package_type : package_type -> unit =\n fun (a, b) ->\n self#longident_loc a;\n self#list\n (fun (a, b) ->\n self#longident_loc a;\n self#core_type b)\n b\n\n method row_field : row_field -> unit =\n fun { prf_desc; prf_loc; prf_attributes } ->\n self#row_field_desc prf_desc;\n self#location prf_loc;\n self#attributes prf_attributes\n\n method row_field_desc : row_field_desc -> unit =\n fun x ->\n match x with\n | Rtag (a, b, c) ->\n self#loc self#label a;\n self#bool b;\n self#list self#core_type c\n | Rinherit a -> self#core_type a\n\n method object_field : object_field -> unit =\n fun { pof_desc; pof_loc; pof_attributes } ->\n self#object_field_desc pof_desc;\n self#location pof_loc;\n self#attributes pof_attributes\n\n method object_field_desc : object_field_desc -> unit =\n fun x ->\n match x with\n | Otag (a, b) ->\n self#loc self#label a;\n self#core_type b\n | Oinherit a -> self#core_type a\n\n method pattern : pattern -> unit =\n fun { ppat_desc; ppat_loc; ppat_loc_stack; ppat_attributes } ->\n self#pattern_desc ppat_desc;\n self#location ppat_loc;\n self#location_stack ppat_loc_stack;\n self#attributes ppat_attributes\n\n method pattern_desc : pattern_desc -> unit =\n fun x ->\n match x with\n | Ppat_any -> ()\n | Ppat_var a -> self#loc self#string a\n | Ppat_alias (a, b) ->\n self#pattern a;\n self#loc self#string b\n | Ppat_constant a -> self#constant a\n | Ppat_interval (a, b) ->\n self#constant a;\n self#constant b\n | Ppat_tuple a -> self#list self#pattern a\n | Ppat_construct (a, b) ->\n self#longident_loc a;\n self#option self#pattern b\n | Ppat_variant (a, b) ->\n self#label a;\n self#option self#pattern b\n | Ppat_record (a, b) ->\n self#list\n (fun (a, b) ->\n self#longident_loc a;\n self#pattern b)\n a;\n self#closed_flag b\n | Ppat_array a -> self#list self#pattern a\n | Ppat_or (a, b) ->\n self#pattern a;\n self#pattern b\n | Ppat_constraint (a, b) ->\n self#pattern a;\n self#core_type b\n | Ppat_type a -> self#longident_loc a\n | Ppat_lazy a -> self#pattern a\n | Ppat_unpack a -> self#loc (self#option self#string) a\n | Ppat_exception a -> self#pattern a\n | Ppat_extension a -> self#extension a\n | Ppat_open (a, b) ->\n self#longident_loc a;\n self#pattern b\n\n method expression : expression -> unit =\n fun { pexp_desc; pexp_loc; pexp_loc_stack; pexp_attributes } ->\n self#expression_desc pexp_desc;\n self#location pexp_loc;\n self#location_stack pexp_loc_stack;\n self#attributes pexp_attributes\n\n method expression_desc : expression_desc -> unit =\n fun x ->\n match x with\n | Pexp_ident a -> self#longident_loc a\n | Pexp_constant a -> self#constant a\n | Pexp_let (a, b, c) ->\n self#rec_flag a;\n self#list self#value_binding b;\n self#expression c\n | Pexp_function a -> self#cases a\n | Pexp_fun (a, b, c, d) ->\n self#arg_label a;\n self#option self#expression b;\n self#pattern c;\n self#expression d\n | Pexp_apply (a, b) ->\n self#expression a;\n self#list\n (fun (a, b) ->\n self#arg_label a;\n self#expression b)\n b\n | Pexp_match (a, b) ->\n self#expression a;\n self#cases b\n | Pexp_try (a, b) ->\n self#expression a;\n self#cases b\n | Pexp_tuple a -> self#list self#expression a\n | Pexp_construct (a, b) ->\n self#longident_loc a;\n self#option self#expression b\n | Pexp_variant (a, b) ->\n self#label a;\n self#option self#expression b\n | Pexp_record (a, b) ->\n self#list\n (fun (a, b) ->\n self#longident_loc a;\n self#expression b)\n a;\n self#option self#expression b\n | Pexp_field (a, b) ->\n self#expression a;\n self#longident_loc b\n | Pexp_setfield (a, b, c) ->\n self#expression a;\n self#longident_loc b;\n self#expression c\n | Pexp_array a -> self#list self#expression a\n | Pexp_ifthenelse (a, b, c) ->\n self#expression a;\n self#expression b;\n self#option self#expression c\n | Pexp_sequence (a, b) ->\n self#expression a;\n self#expression b\n | Pexp_while (a, b) ->\n self#expression a;\n self#expression b\n | Pexp_for (a, b, c, d, e) ->\n self#pattern a;\n self#expression b;\n self#expression c;\n self#direction_flag d;\n self#expression e\n | Pexp_constraint (a, b) ->\n self#expression a;\n self#core_type b\n | Pexp_coerce (a, b, c) ->\n self#expression a;\n self#option self#core_type b;\n self#core_type c\n | Pexp_send (a, b) ->\n self#expression a;\n self#loc self#label b\n | Pexp_new a -> self#longident_loc a\n | Pexp_setinstvar (a, b) ->\n self#loc self#label a;\n self#expression b\n | Pexp_override a ->\n self#list\n (fun (a, b) ->\n self#loc self#label a;\n self#expression b)\n a\n | Pexp_letmodule (a, b, c) ->\n self#loc (self#option self#string) a;\n self#module_expr b;\n self#expression c\n | Pexp_letexception (a, b) ->\n self#extension_constructor a;\n self#expression b\n | Pexp_assert a -> self#expression a\n | Pexp_lazy a -> self#expression a\n | Pexp_poly (a, b) ->\n self#expression a;\n self#option self#core_type b\n | Pexp_object a -> self#class_structure a\n | Pexp_newtype (a, b) ->\n self#loc self#string a;\n self#expression b\n | Pexp_pack a -> self#module_expr a\n | Pexp_open (a, b) ->\n self#open_declaration a;\n self#expression b\n | Pexp_letop a -> self#letop a\n | Pexp_extension a -> self#extension a\n | Pexp_unreachable -> ()\n\n method case : case -> unit =\n fun { pc_lhs; pc_guard; pc_rhs } ->\n self#pattern pc_lhs;\n self#option self#expression pc_guard;\n self#expression pc_rhs\n\n method letop : letop -> unit =\n fun { let_; ands; body } ->\n self#binding_op let_;\n self#list self#binding_op ands;\n self#expression body\n\n method binding_op : binding_op -> unit =\n fun { pbop_op; pbop_pat; pbop_exp; pbop_loc } ->\n self#loc self#string pbop_op;\n self#pattern pbop_pat;\n self#expression pbop_exp;\n self#location pbop_loc\n\n method value_description : value_description -> unit =\n fun { pval_name; pval_type; pval_prim; pval_attributes; pval_loc } ->\n self#loc self#string pval_name;\n self#core_type pval_type;\n self#list self#string pval_prim;\n self#attributes pval_attributes;\n self#location pval_loc\n\n method type_declaration : type_declaration -> unit =\n fun {\n ptype_name;\n ptype_params;\n ptype_cstrs;\n ptype_kind;\n ptype_private;\n ptype_manifest;\n ptype_attributes;\n ptype_loc;\n } ->\n self#loc self#string ptype_name;\n self#list\n (fun (a, b) ->\n self#core_type a;\n (fun (a, b) ->\n self#variance a;\n self#injectivity b)\n b)\n ptype_params;\n self#list\n (fun (a, b, c) ->\n self#core_type a;\n self#core_type b;\n self#location c)\n ptype_cstrs;\n self#type_kind ptype_kind;\n self#private_flag ptype_private;\n self#option self#core_type ptype_manifest;\n self#attributes ptype_attributes;\n self#location ptype_loc\n\n method type_kind : type_kind -> unit =\n fun x ->\n match x with\n | Ptype_abstract -> ()\n | Ptype_variant a -> self#list self#constructor_declaration a\n | Ptype_record a -> self#list self#label_declaration a\n | Ptype_open -> ()\n\n method label_declaration : label_declaration -> unit =\n fun { pld_name; pld_mutable; pld_type; pld_loc; pld_attributes } ->\n self#loc self#string pld_name;\n self#mutable_flag pld_mutable;\n self#core_type pld_type;\n self#location pld_loc;\n self#attributes pld_attributes\n\n method constructor_declaration : constructor_declaration -> unit =\n fun { pcd_name; pcd_args; pcd_res; pcd_loc; pcd_attributes } ->\n self#loc self#string pcd_name;\n self#constructor_arguments pcd_args;\n self#option self#core_type pcd_res;\n self#location pcd_loc;\n self#attributes pcd_attributes\n\n method constructor_arguments : constructor_arguments -> unit =\n fun x ->\n match x with\n | Pcstr_tuple a -> self#list self#core_type a\n | Pcstr_record a -> self#list self#label_declaration a\n\n method type_extension : type_extension -> unit =\n fun {\n ptyext_path;\n ptyext_params;\n ptyext_constructors;\n ptyext_private;\n ptyext_loc;\n ptyext_attributes;\n } ->\n self#longident_loc ptyext_path;\n self#list\n (fun (a, b) ->\n self#core_type a;\n (fun (a, b) ->\n self#variance a;\n self#injectivity b)\n b)\n ptyext_params;\n self#list self#extension_constructor ptyext_constructors;\n self#private_flag ptyext_private;\n self#location ptyext_loc;\n self#attributes ptyext_attributes\n\n method extension_constructor : extension_constructor -> unit =\n fun { pext_name; pext_kind; pext_loc; pext_attributes } ->\n self#loc self#string pext_name;\n self#extension_constructor_kind pext_kind;\n self#location pext_loc;\n self#attributes pext_attributes\n\n method type_exception : type_exception -> unit =\n fun { ptyexn_constructor; ptyexn_loc; ptyexn_attributes } ->\n self#extension_constructor ptyexn_constructor;\n self#location ptyexn_loc;\n self#attributes ptyexn_attributes\n\n method extension_constructor_kind : extension_constructor_kind -> unit =\n fun x ->\n match x with\n | Pext_decl (a, b) ->\n self#constructor_arguments a;\n self#option self#core_type b\n | Pext_rebind a -> self#longident_loc a\n\n method class_type : class_type -> unit =\n fun { pcty_desc; pcty_loc; pcty_attributes } ->\n self#class_type_desc pcty_desc;\n self#location pcty_loc;\n self#attributes pcty_attributes\n\n method class_type_desc : class_type_desc -> unit =\n fun x ->\n match x with\n | Pcty_constr (a, b) ->\n self#longident_loc a;\n self#list self#core_type b\n | Pcty_signature a -> self#class_signature a\n | Pcty_arrow (a, b, c) ->\n self#arg_label a;\n self#core_type b;\n self#class_type c\n | Pcty_extension a -> self#extension a\n | Pcty_open (a, b) ->\n self#open_description a;\n self#class_type b\n\n method class_signature : class_signature -> unit =\n fun { pcsig_self; pcsig_fields } ->\n self#core_type pcsig_self;\n self#list self#class_type_field pcsig_fields\n\n method class_type_field : class_type_field -> unit =\n fun { pctf_desc; pctf_loc; pctf_attributes } ->\n self#class_type_field_desc pctf_desc;\n self#location pctf_loc;\n self#attributes pctf_attributes\n\n method class_type_field_desc : class_type_field_desc -> unit =\n fun x ->\n match x with\n | Pctf_inherit a -> self#class_type a\n | Pctf_val a ->\n (fun (a, b, c, d) ->\n self#loc self#label a;\n self#mutable_flag b;\n self#virtual_flag c;\n self#core_type d)\n a\n | Pctf_method a ->\n (fun (a, b, c, d) ->\n self#loc self#label a;\n self#private_flag b;\n self#virtual_flag c;\n self#core_type d)\n a\n | Pctf_constraint a ->\n (fun (a, b) ->\n self#core_type a;\n self#core_type b)\n a\n | Pctf_attribute a -> self#attribute a\n | Pctf_extension a -> self#extension a\n\n method class_infos : 'a. ('a -> unit) -> 'a class_infos -> unit =\n fun _a\n { pci_virt; pci_params; pci_name; pci_expr; pci_loc; pci_attributes } ->\n self#virtual_flag pci_virt;\n self#list\n (fun (a, b) ->\n self#core_type a;\n (fun (a, b) ->\n self#variance a;\n self#injectivity b)\n b)\n pci_params;\n self#loc self#string pci_name;\n _a pci_expr;\n self#location pci_loc;\n self#attributes pci_attributes\n\n method class_description : class_description -> unit =\n self#class_infos self#class_type\n\n method class_type_declaration : class_type_declaration -> unit =\n self#class_infos self#class_type\n\n method class_expr : class_expr -> unit =\n fun { pcl_desc; pcl_loc; pcl_attributes } ->\n self#class_expr_desc pcl_desc;\n self#location pcl_loc;\n self#attributes pcl_attributes\n\n method class_expr_desc : class_expr_desc -> unit =\n fun x ->\n match x with\n | Pcl_constr (a, b) ->\n self#longident_loc a;\n self#list self#core_type b\n | Pcl_structure a -> self#class_structure a\n | Pcl_fun (a, b, c, d) ->\n self#arg_label a;\n self#option self#expression b;\n self#pattern c;\n self#class_expr d\n | Pcl_apply (a, b) ->\n self#class_expr a;\n self#list\n (fun (a, b) ->\n self#arg_label a;\n self#expression b)\n b\n | Pcl_let (a, b, c) ->\n self#rec_flag a;\n self#list self#value_binding b;\n self#class_expr c\n | Pcl_constraint (a, b) ->\n self#class_expr a;\n self#class_type b\n | Pcl_extension a -> self#extension a\n | Pcl_open (a, b) ->\n self#open_description a;\n self#class_expr b\n\n method class_structure : class_structure -> unit =\n fun { pcstr_self; pcstr_fields } ->\n self#pattern pcstr_self;\n self#list self#class_field pcstr_fields\n\n method class_field : class_field -> unit =\n fun { pcf_desc; pcf_loc; pcf_attributes } ->\n self#class_field_desc pcf_desc;\n self#location pcf_loc;\n self#attributes pcf_attributes\n\n method class_field_desc : class_field_desc -> unit =\n fun x ->\n match x with\n | Pcf_inherit (a, b, c) ->\n self#override_flag a;\n self#class_expr b;\n self#option (self#loc self#string) c\n | Pcf_val a ->\n (fun (a, b, c) ->\n self#loc self#label a;\n self#mutable_flag b;\n self#class_field_kind c)\n a\n | Pcf_method a ->\n (fun (a, b, c) ->\n self#loc self#label a;\n self#private_flag b;\n self#class_field_kind c)\n a\n | Pcf_constraint a ->\n (fun (a, b) ->\n self#core_type a;\n self#core_type b)\n a\n | Pcf_initializer a -> self#expression a\n | Pcf_attribute a -> self#attribute a\n | Pcf_extension a -> self#extension a\n\n method class_field_kind : class_field_kind -> unit =\n fun x ->\n match x with\n | Cfk_virtual a -> self#core_type a\n | Cfk_concrete (a, b) ->\n self#override_flag a;\n self#expression b\n\n method class_declaration : class_declaration -> unit =\n self#class_infos self#class_expr\n\n method module_type : module_type -> unit =\n fun { pmty_desc; pmty_loc; pmty_attributes } ->\n self#module_type_desc pmty_desc;\n self#location pmty_loc;\n self#attributes pmty_attributes\n\n method module_type_desc : module_type_desc -> unit =\n fun x ->\n match x with\n | Pmty_ident a -> self#longident_loc a\n | Pmty_signature a -> self#signature a\n | Pmty_functor (a, b) ->\n self#functor_parameter a;\n self#module_type b\n | Pmty_with (a, b) ->\n self#module_type a;\n self#list self#with_constraint b\n | Pmty_typeof a -> self#module_expr a\n | Pmty_extension a -> self#extension a\n | Pmty_alias a -> self#longident_loc a\n\n method functor_parameter : functor_parameter -> unit =\n fun x ->\n match x with\n | Unit -> ()\n | Named (a, b) ->\n self#loc (self#option self#string) a;\n self#module_type b\n\n method signature : signature -> unit = self#list self#signature_item\n\n method signature_item : signature_item -> unit =\n fun { psig_desc; psig_loc } ->\n self#signature_item_desc psig_desc;\n self#location psig_loc\n\n method signature_item_desc : signature_item_desc -> unit =\n fun x ->\n match x with\n | Psig_value a -> self#value_description a\n | Psig_type (a, b) ->\n self#rec_flag a;\n self#list self#type_declaration b\n | Psig_typesubst a -> self#list self#type_declaration a\n | Psig_typext a -> self#type_extension a\n | Psig_exception a -> self#type_exception a\n | Psig_module a -> self#module_declaration a\n | Psig_modsubst a -> self#module_substitution a\n | Psig_recmodule a -> self#list self#module_declaration a\n | Psig_modtype a -> self#module_type_declaration a\n | Psig_open a -> self#open_description a\n | Psig_include a -> self#include_description a\n | Psig_class a -> self#list self#class_description a\n | Psig_class_type a -> self#list self#class_type_declaration a\n | Psig_attribute a -> self#attribute a\n | Psig_extension (a, b) ->\n self#extension a;\n self#attributes b\n\n method module_declaration : module_declaration -> unit =\n fun { pmd_name; pmd_type; pmd_attributes; pmd_loc } ->\n self#loc (self#option self#string) pmd_name;\n self#module_type pmd_type;\n self#attributes pmd_attributes;\n self#location pmd_loc\n\n method module_substitution : module_substitution -> unit =\n fun { pms_name; pms_manifest; pms_attributes; pms_loc } ->\n self#loc self#string pms_name;\n self#longident_loc pms_manifest;\n self#attributes pms_attributes;\n self#location pms_loc\n\n method module_type_declaration : module_type_declaration -> unit =\n fun { pmtd_name; pmtd_type; pmtd_attributes; pmtd_loc } ->\n self#loc self#string pmtd_name;\n self#option self#module_type pmtd_type;\n self#attributes pmtd_attributes;\n self#location pmtd_loc\n\n method open_infos : 'a. ('a -> unit) -> 'a open_infos -> unit =\n fun _a { popen_expr; popen_override; popen_loc; popen_attributes } ->\n _a popen_expr;\n self#override_flag popen_override;\n self#location popen_loc;\n self#attributes popen_attributes\n\n method open_description : open_description -> unit =\n self#open_infos self#longident_loc\n\n method open_declaration : open_declaration -> unit =\n self#open_infos self#module_expr\n\n method include_infos : 'a. ('a -> unit) -> 'a include_infos -> unit =\n fun _a { pincl_mod; pincl_loc; pincl_attributes } ->\n _a pincl_mod;\n self#location pincl_loc;\n self#attributes pincl_attributes\n\n method include_description : include_description -> unit =\n self#include_infos self#module_type\n\n method include_declaration : include_declaration -> unit =\n self#include_infos self#module_expr\n\n method with_constraint : with_constraint -> unit =\n fun x ->\n match x with\n | Pwith_type (a, b) ->\n self#longident_loc a;\n self#type_declaration b\n | Pwith_module (a, b) ->\n self#longident_loc a;\n self#longident_loc b\n | Pwith_typesubst (a, b) ->\n self#longident_loc a;\n self#type_declaration b\n | Pwith_modsubst (a, b) ->\n self#longident_loc a;\n self#longident_loc b\n\n method module_expr : module_expr -> unit =\n fun { pmod_desc; pmod_loc; pmod_attributes } ->\n self#module_expr_desc pmod_desc;\n self#location pmod_loc;\n self#attributes pmod_attributes\n\n method module_expr_desc : module_expr_desc -> unit =\n fun x ->\n match x with\n | Pmod_ident a -> self#longident_loc a\n | Pmod_structure a -> self#structure a\n | Pmod_functor (a, b) ->\n self#functor_parameter a;\n self#module_expr b\n | Pmod_apply (a, b) ->\n self#module_expr a;\n self#module_expr b\n | Pmod_constraint (a, b) ->\n self#module_expr a;\n self#module_type b\n | Pmod_unpack a -> self#expression a\n | Pmod_extension a -> self#extension a\n\n method structure : structure -> unit = self#list self#structure_item\n\n method structure_item : structure_item -> unit =\n fun { pstr_desc; pstr_loc } ->\n self#structure_item_desc pstr_desc;\n self#location pstr_loc\n\n method structure_item_desc : structure_item_desc -> unit =\n fun x ->\n match x with\n | Pstr_eval (a, b) ->\n self#expression a;\n self#attributes b\n | Pstr_value (a, b) ->\n self#rec_flag a;\n self#list self#value_binding b\n | Pstr_primitive a -> self#value_description a\n | Pstr_type (a, b) ->\n self#rec_flag a;\n self#list self#type_declaration b\n | Pstr_typext a -> self#type_extension a\n | Pstr_exception a -> self#type_exception a\n | Pstr_module a -> self#module_binding a\n | Pstr_recmodule a -> self#list self#module_binding a\n | Pstr_modtype a -> self#module_type_declaration a\n | Pstr_open a -> self#open_declaration a\n | Pstr_class a -> self#list self#class_declaration a\n | Pstr_class_type a -> self#list self#class_type_declaration a\n | Pstr_include a -> self#include_declaration a\n | Pstr_attribute a -> self#attribute a\n | Pstr_extension (a, b) ->\n self#extension a;\n self#attributes b\n\n method value_binding : value_binding -> unit =\n fun { pvb_pat; pvb_expr; pvb_attributes; pvb_loc } ->\n self#pattern pvb_pat;\n self#expression pvb_expr;\n self#attributes pvb_attributes;\n self#location pvb_loc\n\n method module_binding : module_binding -> unit =\n fun { pmb_name; pmb_expr; pmb_attributes; pmb_loc } ->\n self#loc (self#option self#string) pmb_name;\n self#module_expr pmb_expr;\n self#attributes pmb_attributes;\n self#location pmb_loc\n\n method toplevel_phrase : toplevel_phrase -> unit =\n fun x ->\n match x with\n | Ptop_def a -> self#structure a\n | Ptop_dir a -> self#toplevel_directive a\n\n method toplevel_directive : toplevel_directive -> unit =\n fun { pdir_name; pdir_arg; pdir_loc } ->\n self#loc self#string pdir_name;\n self#option self#directive_argument pdir_arg;\n self#location pdir_loc\n\n method directive_argument : directive_argument -> unit =\n fun { pdira_desc; pdira_loc } ->\n self#directive_argument_desc pdira_desc;\n self#location pdira_loc\n\n method directive_argument_desc : directive_argument_desc -> unit =\n fun x ->\n match x with\n | Pdir_string a -> self#string a\n | Pdir_int (a, b) ->\n self#string a;\n self#option self#char b\n | Pdir_ident a -> self#longident a\n | Pdir_bool a -> self#bool a\n\n method cases : cases -> unit = self#list self#case\n end\n\nclass virtual ['acc] fold =\n object (self)\n method virtual bool : bool -> 'acc -> 'acc\n method virtual char : char -> 'acc -> 'acc\n method virtual int : int -> 'acc -> 'acc\n method virtual list : 'a. ('a -> 'acc -> 'acc) -> 'a list -> 'acc -> 'acc\n\n method virtual option\n : 'a. ('a -> 'acc -> 'acc) -> 'a option -> 'acc -> 'acc\n\n method virtual string : string -> 'acc -> 'acc\n\n method position : position -> 'acc -> 'acc =\n fun { pos_fname; pos_lnum; pos_bol; pos_cnum } acc ->\n let acc = self#string pos_fname acc in\n let acc = self#int pos_lnum acc in\n let acc = self#int pos_bol acc in\n let acc = self#int pos_cnum acc in\n acc\n\n method location : location -> 'acc -> 'acc =\n fun { loc_start; loc_end; loc_ghost } acc ->\n let acc = self#position loc_start acc in\n let acc = self#position loc_end acc in\n let acc = self#bool loc_ghost acc in\n acc\n\n method location_stack : location_stack -> 'acc -> 'acc =\n self#list self#location\n\n method loc : 'a. ('a -> 'acc -> 'acc) -> 'a loc -> 'acc -> 'acc =\n fun _a { txt; loc } acc ->\n let acc = _a txt acc in\n let acc = self#location loc acc in\n acc\n\n method longident : longident -> 'acc -> 'acc =\n fun x acc ->\n match x with\n | Lident a -> self#string a acc\n | Ldot (a, b) ->\n let acc = self#longident a acc in\n let acc = self#string b acc in\n acc\n | Lapply (a, b) ->\n let acc = self#longident a acc in\n let acc = self#longident b acc in\n acc\n\n method longident_loc : longident_loc -> 'acc -> 'acc =\n self#loc self#longident\n\n method rec_flag : rec_flag -> 'acc -> 'acc = fun _ acc -> acc\n method direction_flag : direction_flag -> 'acc -> 'acc = fun _ acc -> acc\n method private_flag : private_flag -> 'acc -> 'acc = fun _ acc -> acc\n method mutable_flag : mutable_flag -> 'acc -> 'acc = fun _ acc -> acc\n method virtual_flag : virtual_flag -> 'acc -> 'acc = fun _ acc -> acc\n method override_flag : override_flag -> 'acc -> 'acc = fun _ acc -> acc\n method closed_flag : closed_flag -> 'acc -> 'acc = fun _ acc -> acc\n method label : label -> 'acc -> 'acc = self#string\n\n method arg_label : arg_label -> 'acc -> 'acc =\n fun x acc ->\n match x with\n | Nolabel -> acc\n | Labelled a -> self#string a acc\n | Optional a -> self#string a acc\n\n method variance : variance -> 'acc -> 'acc = fun _ acc -> acc\n method injectivity : injectivity -> 'acc -> 'acc = fun _ acc -> acc\n\n method constant : constant -> 'acc -> 'acc =\n fun x acc ->\n match x with\n | Pconst_integer (a, b) ->\n let acc = self#string a acc in\n let acc = self#option self#char b acc in\n acc\n | Pconst_char a -> self#char a acc\n | Pconst_string (a, b, c) ->\n let acc = self#string a acc in\n let acc = self#location b acc in\n let acc = self#option self#string c acc in\n acc\n | Pconst_float (a, b) ->\n let acc = self#string a acc in\n let acc = self#option self#char b acc in\n acc\n\n method attribute : attribute -> 'acc -> 'acc =\n fun { attr_name; attr_payload; attr_loc } acc ->\n let acc = self#loc self#string attr_name acc in\n let acc = self#payload attr_payload acc in\n let acc = self#location attr_loc acc in\n acc\n\n method extension : extension -> 'acc -> 'acc =\n fun (a, b) acc ->\n let acc = self#loc self#string a acc in\n let acc = self#payload b acc in\n acc\n\n method attributes : attributes -> 'acc -> 'acc = self#list self#attribute\n\n method payload : payload -> 'acc -> 'acc =\n fun x acc ->\n match x with\n | PStr a -> self#structure a acc\n | PSig a -> self#signature a acc\n | PTyp a -> self#core_type a acc\n | PPat (a, b) ->\n let acc = self#pattern a acc in\n let acc = self#option self#expression b acc in\n acc\n\n method core_type : core_type -> 'acc -> 'acc =\n fun { ptyp_desc; ptyp_loc; ptyp_loc_stack; ptyp_attributes } acc ->\n let acc = self#core_type_desc ptyp_desc acc in\n let acc = self#location ptyp_loc acc in\n let acc = self#location_stack ptyp_loc_stack acc in\n let acc = self#attributes ptyp_attributes acc in\n acc\n\n method core_type_desc : core_type_desc -> 'acc -> 'acc =\n fun x acc ->\n match x with\n | Ptyp_any -> acc\n | Ptyp_var a -> self#string a acc\n | Ptyp_arrow (a, b, c) ->\n let acc = self#arg_label a acc in\n let acc = self#core_type b acc in\n let acc = self#core_type c acc in\n acc\n | Ptyp_tuple a -> self#list self#core_type a acc\n | Ptyp_constr (a, b) ->\n let acc = self#longident_loc a acc in\n let acc = self#list self#core_type b acc in\n acc\n | Ptyp_object (a, b) ->\n let acc = self#list self#object_field a acc in\n let acc = self#closed_flag b acc in\n acc\n | Ptyp_class (a, b) ->\n let acc = self#longident_loc a acc in\n let acc = self#list self#core_type b acc in\n acc\n | Ptyp_alias (a, b) ->\n let acc = self#core_type a acc in\n let acc = self#string b acc in\n acc\n | Ptyp_variant (a, b, c) ->\n let acc = self#list self#row_field a acc in\n let acc = self#closed_flag b acc in\n let acc = self#option (self#list self#label) c acc in\n acc\n | Ptyp_poly (a, b) ->\n let acc = self#list (self#loc self#string) a acc in\n let acc = self#core_type b acc in\n acc\n | Ptyp_package a -> self#package_type a acc\n | Ptyp_extension a -> self#extension a acc\n\n method package_type : package_type -> 'acc -> 'acc =\n fun (a, b) acc ->\n let acc = self#longident_loc a acc in\n let acc =\n self#list\n (fun (a, b) acc ->\n let acc = self#longident_loc a acc in\n let acc = self#core_type b acc in\n acc)\n b acc\n in\n acc\n\n method row_field : row_field -> 'acc -> 'acc =\n fun { prf_desc; prf_loc; prf_attributes } acc ->\n let acc = self#row_field_desc prf_desc acc in\n let acc = self#location prf_loc acc in\n let acc = self#attributes prf_attributes acc in\n acc\n\n method row_field_desc : row_field_desc -> 'acc -> 'acc =\n fun x acc ->\n match x with\n | Rtag (a, b, c) ->\n let acc = self#loc self#label a acc in\n let acc = self#bool b acc in\n let acc = self#list self#core_type c acc in\n acc\n | Rinherit a -> self#core_type a acc\n\n method object_field : object_field -> 'acc -> 'acc =\n fun { pof_desc; pof_loc; pof_attributes } acc ->\n let acc = self#object_field_desc pof_desc acc in\n let acc = self#location pof_loc acc in\n let acc = self#attributes pof_attributes acc in\n acc\n\n method object_field_desc : object_field_desc -> 'acc -> 'acc =\n fun x acc ->\n match x with\n | Otag (a, b) ->\n let acc = self#loc self#label a acc in\n let acc = self#core_type b acc in\n acc\n | Oinherit a -> self#core_type a acc\n\n method pattern : pattern -> 'acc -> 'acc =\n fun { ppat_desc; ppat_loc; ppat_loc_stack; ppat_attributes } acc ->\n let acc = self#pattern_desc ppat_desc acc in\n let acc = self#location ppat_loc acc in\n let acc = self#location_stack ppat_loc_stack acc in\n let acc = self#attributes ppat_attributes acc in\n acc\n\n method pattern_desc : pattern_desc -> 'acc -> 'acc =\n fun x acc ->\n match x with\n | Ppat_any -> acc\n | Ppat_var a -> self#loc self#string a acc\n | Ppat_alias (a, b) ->\n let acc = self#pattern a acc in\n let acc = self#loc self#string b acc in\n acc\n | Ppat_constant a -> self#constant a acc\n | Ppat_interval (a, b) ->\n let acc = self#constant a acc in\n let acc = self#constant b acc in\n acc\n | Ppat_tuple a -> self#list self#pattern a acc\n | Ppat_construct (a, b) ->\n let acc = self#longident_loc a acc in\n let acc = self#option self#pattern b acc in\n acc\n | Ppat_variant (a, b) ->\n let acc = self#label a acc in\n let acc = self#option self#pattern b acc in\n acc\n | Ppat_record (a, b) ->\n let acc =\n self#list\n (fun (a, b) acc ->\n let acc = self#longident_loc a acc in\n let acc = self#pattern b acc in\n acc)\n a acc\n in\n let acc = self#closed_flag b acc in\n acc\n | Ppat_array a -> self#list self#pattern a acc\n | Ppat_or (a, b) ->\n let acc = self#pattern a acc in\n let acc = self#pattern b acc in\n acc\n | Ppat_constraint (a, b) ->\n let acc = self#pattern a acc in\n let acc = self#core_type b acc in\n acc\n | Ppat_type a -> self#longident_loc a acc\n | Ppat_lazy a -> self#pattern a acc\n | Ppat_unpack a -> self#loc (self#option self#string) a acc\n | Ppat_exception a -> self#pattern a acc\n | Ppat_extension a -> self#extension a acc\n | Ppat_open (a, b) ->\n let acc = self#longident_loc a acc in\n let acc = self#pattern b acc in\n acc\n\n method expression : expression -> 'acc -> 'acc =\n fun { pexp_desc; pexp_loc; pexp_loc_stack; pexp_attributes } acc ->\n let acc = self#expression_desc pexp_desc acc in\n let acc = self#location pexp_loc acc in\n let acc = self#location_stack pexp_loc_stack acc in\n let acc = self#attributes pexp_attributes acc in\n acc\n\n method expression_desc : expression_desc -> 'acc -> 'acc =\n fun x acc ->\n match x with\n | Pexp_ident a -> self#longident_loc a acc\n | Pexp_constant a -> self#constant a acc\n | Pexp_let (a, b, c) ->\n let acc = self#rec_flag a acc in\n let acc = self#list self#value_binding b acc in\n let acc = self#expression c acc in\n acc\n | Pexp_function a -> self#cases a acc\n | Pexp_fun (a, b, c, d) ->\n let acc = self#arg_label a acc in\n let acc = self#option self#expression b acc in\n let acc = self#pattern c acc in\n let acc = self#expression d acc in\n acc\n | Pexp_apply (a, b) ->\n let acc = self#expression a acc in\n let acc =\n self#list\n (fun (a, b) acc ->\n let acc = self#arg_label a acc in\n let acc = self#expression b acc in\n acc)\n b acc\n in\n acc\n | Pexp_match (a, b) ->\n let acc = self#expression a acc in\n let acc = self#cases b acc in\n acc\n | Pexp_try (a, b) ->\n let acc = self#expression a acc in\n let acc = self#cases b acc in\n acc\n | Pexp_tuple a -> self#list self#expression a acc\n | Pexp_construct (a, b) ->\n let acc = self#longident_loc a acc in\n let acc = self#option self#expression b acc in\n acc\n | Pexp_variant (a, b) ->\n let acc = self#label a acc in\n let acc = self#option self#expression b acc in\n acc\n | Pexp_record (a, b) ->\n let acc =\n self#list\n (fun (a, b) acc ->\n let acc = self#longident_loc a acc in\n let acc = self#expression b acc in\n acc)\n a acc\n in\n let acc = self#option self#expression b acc in\n acc\n | Pexp_field (a, b) ->\n let acc = self#expression a acc in\n let acc = self#longident_loc b acc in\n acc\n | Pexp_setfield (a, b, c) ->\n let acc = self#expression a acc in\n let acc = self#longident_loc b acc in\n let acc = self#expression c acc in\n acc\n | Pexp_array a -> self#list self#expression a acc\n | Pexp_ifthenelse (a, b, c) ->\n let acc = self#expression a acc in\n let acc = self#expression b acc in\n let acc = self#option self#expression c acc in\n acc\n | Pexp_sequence (a, b) ->\n let acc = self#expression a acc in\n let acc = self#expression b acc in\n acc\n | Pexp_while (a, b) ->\n let acc = self#expression a acc in\n let acc = self#expression b acc in\n acc\n | Pexp_for (a, b, c, d, e) ->\n let acc = self#pattern a acc in\n let acc = self#expression b acc in\n let acc = self#expression c acc in\n let acc = self#direction_flag d acc in\n let acc = self#expression e acc in\n acc\n | Pexp_constraint (a, b) ->\n let acc = self#expression a acc in\n let acc = self#core_type b acc in\n acc\n | Pexp_coerce (a, b, c) ->\n let acc = self#expression a acc in\n let acc = self#option self#core_type b acc in\n let acc = self#core_type c acc in\n acc\n | Pexp_send (a, b) ->\n let acc = self#expression a acc in\n let acc = self#loc self#label b acc in\n acc\n | Pexp_new a -> self#longident_loc a acc\n | Pexp_setinstvar (a, b) ->\n let acc = self#loc self#label a acc in\n let acc = self#expression b acc in\n acc\n | Pexp_override a ->\n self#list\n (fun (a, b) acc ->\n let acc = self#loc self#label a acc in\n let acc = self#expression b acc in\n acc)\n a acc\n | Pexp_letmodule (a, b, c) ->\n let acc = self#loc (self#option self#string) a acc in\n let acc = self#module_expr b acc in\n let acc = self#expression c acc in\n acc\n | Pexp_letexception (a, b) ->\n let acc = self#extension_constructor a acc in\n let acc = self#expression b acc in\n acc\n | Pexp_assert a -> self#expression a acc\n | Pexp_lazy a -> self#expression a acc\n | Pexp_poly (a, b) ->\n let acc = self#expression a acc in\n let acc = self#option self#core_type b acc in\n acc\n | Pexp_object a -> self#class_structure a acc\n | Pexp_newtype (a, b) ->\n let acc = self#loc self#string a acc in\n let acc = self#expression b acc in\n acc\n | Pexp_pack a -> self#module_expr a acc\n | Pexp_open (a, b) ->\n let acc = self#open_declaration a acc in\n let acc = self#expression b acc in\n acc\n | Pexp_letop a -> self#letop a acc\n | Pexp_extension a -> self#extension a acc\n | Pexp_unreachable -> acc\n\n method case : case -> 'acc -> 'acc =\n fun { pc_lhs; pc_guard; pc_rhs } acc ->\n let acc = self#pattern pc_lhs acc in\n let acc = self#option self#expression pc_guard acc in\n let acc = self#expression pc_rhs acc in\n acc\n\n method letop : letop -> 'acc -> 'acc =\n fun { let_; ands; body } acc ->\n let acc = self#binding_op let_ acc in\n let acc = self#list self#binding_op ands acc in\n let acc = self#expression body acc in\n acc\n\n method binding_op : binding_op -> 'acc -> 'acc =\n fun { pbop_op; pbop_pat; pbop_exp; pbop_loc } acc ->\n let acc = self#loc self#string pbop_op acc in\n let acc = self#pattern pbop_pat acc in\n let acc = self#expression pbop_exp acc in\n let acc = self#location pbop_loc acc in\n acc\n\n method value_description : value_description -> 'acc -> 'acc =\n fun { pval_name; pval_type; pval_prim; pval_attributes; pval_loc } acc ->\n let acc = self#loc self#string pval_name acc in\n let acc = self#core_type pval_type acc in\n let acc = self#list self#string pval_prim acc in\n let acc = self#attributes pval_attributes acc in\n let acc = self#location pval_loc acc in\n acc\n\n method type_declaration : type_declaration -> 'acc -> 'acc =\n fun {\n ptype_name;\n ptype_params;\n ptype_cstrs;\n ptype_kind;\n ptype_private;\n ptype_manifest;\n ptype_attributes;\n ptype_loc;\n } acc ->\n let acc = self#loc self#string ptype_name acc in\n let acc =\n self#list\n (fun (a, b) acc ->\n let acc = self#core_type a acc in\n let acc =\n (fun (a, b) acc ->\n let acc = self#variance a acc in\n let acc = self#injectivity b acc in\n acc)\n b acc\n in\n acc)\n ptype_params acc\n in\n let acc =\n self#list\n (fun (a, b, c) acc ->\n let acc = self#core_type a acc in\n let acc = self#core_type b acc in\n let acc = self#location c acc in\n acc)\n ptype_cstrs acc\n in\n let acc = self#type_kind ptype_kind acc in\n let acc = self#private_flag ptype_private acc in\n let acc = self#option self#core_type ptype_manifest acc in\n let acc = self#attributes ptype_attributes acc in\n let acc = self#location ptype_loc acc in\n acc\n\n method type_kind : type_kind -> 'acc -> 'acc =\n fun x acc ->\n match x with\n | Ptype_abstract -> acc\n | Ptype_variant a -> self#list self#constructor_declaration a acc\n | Ptype_record a -> self#list self#label_declaration a acc\n | Ptype_open -> acc\n\n method label_declaration : label_declaration -> 'acc -> 'acc =\n fun { pld_name; pld_mutable; pld_type; pld_loc; pld_attributes } acc ->\n let acc = self#loc self#string pld_name acc in\n let acc = self#mutable_flag pld_mutable acc in\n let acc = self#core_type pld_type acc in\n let acc = self#location pld_loc acc in\n let acc = self#attributes pld_attributes acc in\n acc\n\n method constructor_declaration : constructor_declaration -> 'acc -> 'acc =\n fun { pcd_name; pcd_args; pcd_res; pcd_loc; pcd_attributes } acc ->\n let acc = self#loc self#string pcd_name acc in\n let acc = self#constructor_arguments pcd_args acc in\n let acc = self#option self#core_type pcd_res acc in\n let acc = self#location pcd_loc acc in\n let acc = self#attributes pcd_attributes acc in\n acc\n\n method constructor_arguments : constructor_arguments -> 'acc -> 'acc =\n fun x acc ->\n match x with\n | Pcstr_tuple a -> self#list self#core_type a acc\n | Pcstr_record a -> self#list self#label_declaration a acc\n\n method type_extension : type_extension -> 'acc -> 'acc =\n fun {\n ptyext_path;\n ptyext_params;\n ptyext_constructors;\n ptyext_private;\n ptyext_loc;\n ptyext_attributes;\n } acc ->\n let acc = self#longident_loc ptyext_path acc in\n let acc =\n self#list\n (fun (a, b) acc ->\n let acc = self#core_type a acc in\n let acc =\n (fun (a, b) acc ->\n let acc = self#variance a acc in\n let acc = self#injectivity b acc in\n acc)\n b acc\n in\n acc)\n ptyext_params acc\n in\n let acc =\n self#list self#extension_constructor ptyext_constructors acc\n in\n let acc = self#private_flag ptyext_private acc in\n let acc = self#location ptyext_loc acc in\n let acc = self#attributes ptyext_attributes acc in\n acc\n\n method extension_constructor : extension_constructor -> 'acc -> 'acc =\n fun { pext_name; pext_kind; pext_loc; pext_attributes } acc ->\n let acc = self#loc self#string pext_name acc in\n let acc = self#extension_constructor_kind pext_kind acc in\n let acc = self#location pext_loc acc in\n let acc = self#attributes pext_attributes acc in\n acc\n\n method type_exception : type_exception -> 'acc -> 'acc =\n fun { ptyexn_constructor; ptyexn_loc; ptyexn_attributes } acc ->\n let acc = self#extension_constructor ptyexn_constructor acc in\n let acc = self#location ptyexn_loc acc in\n let acc = self#attributes ptyexn_attributes acc in\n acc\n\n method extension_constructor_kind\n : extension_constructor_kind -> 'acc -> 'acc =\n fun x acc ->\n match x with\n | Pext_decl (a, b) ->\n let acc = self#constructor_arguments a acc in\n let acc = self#option self#core_type b acc in\n acc\n | Pext_rebind a -> self#longident_loc a acc\n\n method class_type : class_type -> 'acc -> 'acc =\n fun { pcty_desc; pcty_loc; pcty_attributes } acc ->\n let acc = self#class_type_desc pcty_desc acc in\n let acc = self#location pcty_loc acc in\n let acc = self#attributes pcty_attributes acc in\n acc\n\n method class_type_desc : class_type_desc -> 'acc -> 'acc =\n fun x acc ->\n match x with\n | Pcty_constr (a, b) ->\n let acc = self#longident_loc a acc in\n let acc = self#list self#core_type b acc in\n acc\n | Pcty_signature a -> self#class_signature a acc\n | Pcty_arrow (a, b, c) ->\n let acc = self#arg_label a acc in\n let acc = self#core_type b acc in\n let acc = self#class_type c acc in\n acc\n | Pcty_extension a -> self#extension a acc\n | Pcty_open (a, b) ->\n let acc = self#open_description a acc in\n let acc = self#class_type b acc in\n acc\n\n method class_signature : class_signature -> 'acc -> 'acc =\n fun { pcsig_self; pcsig_fields } acc ->\n let acc = self#core_type pcsig_self acc in\n let acc = self#list self#class_type_field pcsig_fields acc in\n acc\n\n method class_type_field : class_type_field -> 'acc -> 'acc =\n fun { pctf_desc; pctf_loc; pctf_attributes } acc ->\n let acc = self#class_type_field_desc pctf_desc acc in\n let acc = self#location pctf_loc acc in\n let acc = self#attributes pctf_attributes acc in\n acc\n\n method class_type_field_desc : class_type_field_desc -> 'acc -> 'acc =\n fun x acc ->\n match x with\n | Pctf_inherit a -> self#class_type a acc\n | Pctf_val a ->\n (fun (a, b, c, d) acc ->\n let acc = self#loc self#label a acc in\n let acc = self#mutable_flag b acc in\n let acc = self#virtual_flag c acc in\n let acc = self#core_type d acc in\n acc)\n a acc\n | Pctf_method a ->\n (fun (a, b, c, d) acc ->\n let acc = self#loc self#label a acc in\n let acc = self#private_flag b acc in\n let acc = self#virtual_flag c acc in\n let acc = self#core_type d acc in\n acc)\n a acc\n | Pctf_constraint a ->\n (fun (a, b) acc ->\n let acc = self#core_type a acc in\n let acc = self#core_type b acc in\n acc)\n a acc\n | Pctf_attribute a -> self#attribute a acc\n | Pctf_extension a -> self#extension a acc\n\n method class_infos\n : 'a. ('a -> 'acc -> 'acc) -> 'a class_infos -> 'acc -> 'acc =\n fun _a\n { pci_virt; pci_params; pci_name; pci_expr; pci_loc; pci_attributes }\n acc ->\n let acc = self#virtual_flag pci_virt acc in\n let acc =\n self#list\n (fun (a, b) acc ->\n let acc = self#core_type a acc in\n let acc =\n (fun (a, b) acc ->\n let acc = self#variance a acc in\n let acc = self#injectivity b acc in\n acc)\n b acc\n in\n acc)\n pci_params acc\n in\n let acc = self#loc self#string pci_name acc in\n let acc = _a pci_expr acc in\n let acc = self#location pci_loc acc in\n let acc = self#attributes pci_attributes acc in\n acc\n\n method class_description : class_description -> 'acc -> 'acc =\n self#class_infos self#class_type\n\n method class_type_declaration : class_type_declaration -> 'acc -> 'acc =\n self#class_infos self#class_type\n\n method class_expr : class_expr -> 'acc -> 'acc =\n fun { pcl_desc; pcl_loc; pcl_attributes } acc ->\n let acc = self#class_expr_desc pcl_desc acc in\n let acc = self#location pcl_loc acc in\n let acc = self#attributes pcl_attributes acc in\n acc\n\n method class_expr_desc : class_expr_desc -> 'acc -> 'acc =\n fun x acc ->\n match x with\n | Pcl_constr (a, b) ->\n let acc = self#longident_loc a acc in\n let acc = self#list self#core_type b acc in\n acc\n | Pcl_structure a -> self#class_structure a acc\n | Pcl_fun (a, b, c, d) ->\n let acc = self#arg_label a acc in\n let acc = self#option self#expression b acc in\n let acc = self#pattern c acc in\n let acc = self#class_expr d acc in\n acc\n | Pcl_apply (a, b) ->\n let acc = self#class_expr a acc in\n let acc =\n self#list\n (fun (a, b) acc ->\n let acc = self#arg_label a acc in\n let acc = self#expression b acc in\n acc)\n b acc\n in\n acc\n | Pcl_let (a, b, c) ->\n let acc = self#rec_flag a acc in\n let acc = self#list self#value_binding b acc in\n let acc = self#class_expr c acc in\n acc\n | Pcl_constraint (a, b) ->\n let acc = self#class_expr a acc in\n let acc = self#class_type b acc in\n acc\n | Pcl_extension a -> self#extension a acc\n | Pcl_open (a, b) ->\n let acc = self#open_description a acc in\n let acc = self#class_expr b acc in\n acc\n\n method class_structure : class_structure -> 'acc -> 'acc =\n fun { pcstr_self; pcstr_fields } acc ->\n let acc = self#pattern pcstr_self acc in\n let acc = self#list self#class_field pcstr_fields acc in\n acc\n\n method class_field : class_field -> 'acc -> 'acc =\n fun { pcf_desc; pcf_loc; pcf_attributes } acc ->\n let acc = self#class_field_desc pcf_desc acc in\n let acc = self#location pcf_loc acc in\n let acc = self#attributes pcf_attributes acc in\n acc\n\n method class_field_desc : class_field_desc -> 'acc -> 'acc =\n fun x acc ->\n match x with\n | Pcf_inherit (a, b, c) ->\n let acc = self#override_flag a acc in\n let acc = self#class_expr b acc in\n let acc = self#option (self#loc self#string) c acc in\n acc\n | Pcf_val a ->\n (fun (a, b, c) acc ->\n let acc = self#loc self#label a acc in\n let acc = self#mutable_flag b acc in\n let acc = self#class_field_kind c acc in\n acc)\n a acc\n | Pcf_method a ->\n (fun (a, b, c) acc ->\n let acc = self#loc self#label a acc in\n let acc = self#private_flag b acc in\n let acc = self#class_field_kind c acc in\n acc)\n a acc\n | Pcf_constraint a ->\n (fun (a, b) acc ->\n let acc = self#core_type a acc in\n let acc = self#core_type b acc in\n acc)\n a acc\n | Pcf_initializer a -> self#expression a acc\n | Pcf_attribute a -> self#attribute a acc\n | Pcf_extension a -> self#extension a acc\n\n method class_field_kind : class_field_kind -> 'acc -> 'acc =\n fun x acc ->\n match x with\n | Cfk_virtual a -> self#core_type a acc\n | Cfk_concrete (a, b) ->\n let acc = self#override_flag a acc in\n let acc = self#expression b acc in\n acc\n\n method class_declaration : class_declaration -> 'acc -> 'acc =\n self#class_infos self#class_expr\n\n method module_type : module_type -> 'acc -> 'acc =\n fun { pmty_desc; pmty_loc; pmty_attributes } acc ->\n let acc = self#module_type_desc pmty_desc acc in\n let acc = self#location pmty_loc acc in\n let acc = self#attributes pmty_attributes acc in\n acc\n\n method module_type_desc : module_type_desc -> 'acc -> 'acc =\n fun x acc ->\n match x with\n | Pmty_ident a -> self#longident_loc a acc\n | Pmty_signature a -> self#signature a acc\n | Pmty_functor (a, b) ->\n let acc = self#functor_parameter a acc in\n let acc = self#module_type b acc in\n acc\n | Pmty_with (a, b) ->\n let acc = self#module_type a acc in\n let acc = self#list self#with_constraint b acc in\n acc\n | Pmty_typeof a -> self#module_expr a acc\n | Pmty_extension a -> self#extension a acc\n | Pmty_alias a -> self#longident_loc a acc\n\n method functor_parameter : functor_parameter -> 'acc -> 'acc =\n fun x acc ->\n match x with\n | Unit -> acc\n | Named (a, b) ->\n let acc = self#loc (self#option self#string) a acc in\n let acc = self#module_type b acc in\n acc\n\n method signature : signature -> 'acc -> 'acc = self#list self#signature_item\n\n method signature_item : signature_item -> 'acc -> 'acc =\n fun { psig_desc; psig_loc } acc ->\n let acc = self#signature_item_desc psig_desc acc in\n let acc = self#location psig_loc acc in\n acc\n\n method signature_item_desc : signature_item_desc -> 'acc -> 'acc =\n fun x acc ->\n match x with\n | Psig_value a -> self#value_description a acc\n | Psig_type (a, b) ->\n let acc = self#rec_flag a acc in\n let acc = self#list self#type_declaration b acc in\n acc\n | Psig_typesubst a -> self#list self#type_declaration a acc\n | Psig_typext a -> self#type_extension a acc\n | Psig_exception a -> self#type_exception a acc\n | Psig_module a -> self#module_declaration a acc\n | Psig_modsubst a -> self#module_substitution a acc\n | Psig_recmodule a -> self#list self#module_declaration a acc\n | Psig_modtype a -> self#module_type_declaration a acc\n | Psig_open a -> self#open_description a acc\n | Psig_include a -> self#include_description a acc\n | Psig_class a -> self#list self#class_description a acc\n | Psig_class_type a -> self#list self#class_type_declaration a acc\n | Psig_attribute a -> self#attribute a acc\n | Psig_extension (a, b) ->\n let acc = self#extension a acc in\n let acc = self#attributes b acc in\n acc\n\n method module_declaration : module_declaration -> 'acc -> 'acc =\n fun { pmd_name; pmd_type; pmd_attributes; pmd_loc } acc ->\n let acc = self#loc (self#option self#string) pmd_name acc in\n let acc = self#module_type pmd_type acc in\n let acc = self#attributes pmd_attributes acc in\n let acc = self#location pmd_loc acc in\n acc\n\n method module_substitution : module_substitution -> 'acc -> 'acc =\n fun { pms_name; pms_manifest; pms_attributes; pms_loc } acc ->\n let acc = self#loc self#string pms_name acc in\n let acc = self#longident_loc pms_manifest acc in\n let acc = self#attributes pms_attributes acc in\n let acc = self#location pms_loc acc in\n acc\n\n method module_type_declaration : module_type_declaration -> 'acc -> 'acc =\n fun { pmtd_name; pmtd_type; pmtd_attributes; pmtd_loc } acc ->\n let acc = self#loc self#string pmtd_name acc in\n let acc = self#option self#module_type pmtd_type acc in\n let acc = self#attributes pmtd_attributes acc in\n let acc = self#location pmtd_loc acc in\n acc\n\n method open_infos\n : 'a. ('a -> 'acc -> 'acc) -> 'a open_infos -> 'acc -> 'acc =\n fun _a { popen_expr; popen_override; popen_loc; popen_attributes } acc ->\n let acc = _a popen_expr acc in\n let acc = self#override_flag popen_override acc in\n let acc = self#location popen_loc acc in\n let acc = self#attributes popen_attributes acc in\n acc\n\n method open_description : open_description -> 'acc -> 'acc =\n self#open_infos self#longident_loc\n\n method open_declaration : open_declaration -> 'acc -> 'acc =\n self#open_infos self#module_expr\n\n method include_infos\n : 'a. ('a -> 'acc -> 'acc) -> 'a include_infos -> 'acc -> 'acc =\n fun _a { pincl_mod; pincl_loc; pincl_attributes } acc ->\n let acc = _a pincl_mod acc in\n let acc = self#location pincl_loc acc in\n let acc = self#attributes pincl_attributes acc in\n acc\n\n method include_description : include_description -> 'acc -> 'acc =\n self#include_infos self#module_type\n\n method include_declaration : include_declaration -> 'acc -> 'acc =\n self#include_infos self#module_expr\n\n method with_constraint : with_constraint -> 'acc -> 'acc =\n fun x acc ->\n match x with\n | Pwith_type (a, b) ->\n let acc = self#longident_loc a acc in\n let acc = self#type_declaration b acc in\n acc\n | Pwith_module (a, b) ->\n let acc = self#longident_loc a acc in\n let acc = self#longident_loc b acc in\n acc\n | Pwith_typesubst (a, b) ->\n let acc = self#longident_loc a acc in\n let acc = self#type_declaration b acc in\n acc\n | Pwith_modsubst (a, b) ->\n let acc = self#longident_loc a acc in\n let acc = self#longident_loc b acc in\n acc\n\n method module_expr : module_expr -> 'acc -> 'acc =\n fun { pmod_desc; pmod_loc; pmod_attributes } acc ->\n let acc = self#module_expr_desc pmod_desc acc in\n let acc = self#location pmod_loc acc in\n let acc = self#attributes pmod_attributes acc in\n acc\n\n method module_expr_desc : module_expr_desc -> 'acc -> 'acc =\n fun x acc ->\n match x with\n | Pmod_ident a -> self#longident_loc a acc\n | Pmod_structure a -> self#structure a acc\n | Pmod_functor (a, b) ->\n let acc = self#functor_parameter a acc in\n let acc = self#module_expr b acc in\n acc\n | Pmod_apply (a, b) ->\n let acc = self#module_expr a acc in\n let acc = self#module_expr b acc in\n acc\n | Pmod_constraint (a, b) ->\n let acc = self#module_expr a acc in\n let acc = self#module_type b acc in\n acc\n | Pmod_unpack a -> self#expression a acc\n | Pmod_extension a -> self#extension a acc\n\n method structure : structure -> 'acc -> 'acc = self#list self#structure_item\n\n method structure_item : structure_item -> 'acc -> 'acc =\n fun { pstr_desc; pstr_loc } acc ->\n let acc = self#structure_item_desc pstr_desc acc in\n let acc = self#location pstr_loc acc in\n acc\n\n method structure_item_desc : structure_item_desc -> 'acc -> 'acc =\n fun x acc ->\n match x with\n | Pstr_eval (a, b) ->\n let acc = self#expression a acc in\n let acc = self#attributes b acc in\n acc\n | Pstr_value (a, b) ->\n let acc = self#rec_flag a acc in\n let acc = self#list self#value_binding b acc in\n acc\n | Pstr_primitive a -> self#value_description a acc\n | Pstr_type (a, b) ->\n let acc = self#rec_flag a acc in\n let acc = self#list self#type_declaration b acc in\n acc\n | Pstr_typext a -> self#type_extension a acc\n | Pstr_exception a -> self#type_exception a acc\n | Pstr_module a -> self#module_binding a acc\n | Pstr_recmodule a -> self#list self#module_binding a acc\n | Pstr_modtype a -> self#module_type_declaration a acc\n | Pstr_open a -> self#open_declaration a acc\n | Pstr_class a -> self#list self#class_declaration a acc\n | Pstr_class_type a -> self#list self#class_type_declaration a acc\n | Pstr_include a -> self#include_declaration a acc\n | Pstr_attribute a -> self#attribute a acc\n | Pstr_extension (a, b) ->\n let acc = self#extension a acc in\n let acc = self#attributes b acc in\n acc\n\n method value_binding : value_binding -> 'acc -> 'acc =\n fun { pvb_pat; pvb_expr; pvb_attributes; pvb_loc } acc ->\n let acc = self#pattern pvb_pat acc in\n let acc = self#expression pvb_expr acc in\n let acc = self#attributes pvb_attributes acc in\n let acc = self#location pvb_loc acc in\n acc\n\n method module_binding : module_binding -> 'acc -> 'acc =\n fun { pmb_name; pmb_expr; pmb_attributes; pmb_loc } acc ->\n let acc = self#loc (self#option self#string) pmb_name acc in\n let acc = self#module_expr pmb_expr acc in\n let acc = self#attributes pmb_attributes acc in\n let acc = self#location pmb_loc acc in\n acc\n\n method toplevel_phrase : toplevel_phrase -> 'acc -> 'acc =\n fun x acc ->\n match x with\n | Ptop_def a -> self#structure a acc\n | Ptop_dir a -> self#toplevel_directive a acc\n\n method toplevel_directive : toplevel_directive -> 'acc -> 'acc =\n fun { pdir_name; pdir_arg; pdir_loc } acc ->\n let acc = self#loc self#string pdir_name acc in\n let acc = self#option self#directive_argument pdir_arg acc in\n let acc = self#location pdir_loc acc in\n acc\n\n method directive_argument : directive_argument -> 'acc -> 'acc =\n fun { pdira_desc; pdira_loc } acc ->\n let acc = self#directive_argument_desc pdira_desc acc in\n let acc = self#location pdira_loc acc in\n acc\n\n method directive_argument_desc : directive_argument_desc -> 'acc -> 'acc =\n fun x acc ->\n match x with\n | Pdir_string a -> self#string a acc\n | Pdir_int (a, b) ->\n let acc = self#string a acc in\n let acc = self#option self#char b acc in\n acc\n | Pdir_ident a -> self#longident a acc\n | Pdir_bool a -> self#bool a acc\n\n method cases : cases -> 'acc -> 'acc = self#list self#case\n end\n\nclass virtual ['acc] fold_map =\n object (self)\n method virtual bool : bool -> 'acc -> bool * 'acc\n method virtual char : char -> 'acc -> char * 'acc\n method virtual int : int -> 'acc -> int * 'acc\n\n method virtual list\n : 'a. ('a -> 'acc -> 'a * 'acc) -> 'a list -> 'acc -> 'a list * 'acc\n\n method virtual option\n : 'a. ('a -> 'acc -> 'a * 'acc) -> 'a option -> 'acc -> 'a option * 'acc\n\n method virtual string : string -> 'acc -> string * 'acc\n\n method position : position -> 'acc -> position * 'acc =\n fun { pos_fname; pos_lnum; pos_bol; pos_cnum } acc ->\n let pos_fname, acc = self#string pos_fname acc in\n let pos_lnum, acc = self#int pos_lnum acc in\n let pos_bol, acc = self#int pos_bol acc in\n let pos_cnum, acc = self#int pos_cnum acc in\n ({ pos_fname; pos_lnum; pos_bol; pos_cnum }, acc)\n\n method location : location -> 'acc -> location * 'acc =\n fun { loc_start; loc_end; loc_ghost } acc ->\n let loc_start, acc = self#position loc_start acc in\n let loc_end, acc = self#position loc_end acc in\n let loc_ghost, acc = self#bool loc_ghost acc in\n ({ loc_start; loc_end; loc_ghost }, acc)\n\n method location_stack : location_stack -> 'acc -> location_stack * 'acc =\n self#list self#location\n\n method loc\n : 'a. ('a -> 'acc -> 'a * 'acc) -> 'a loc -> 'acc -> 'a loc * 'acc =\n fun _a { txt; loc } acc ->\n let txt, acc = _a txt acc in\n let loc, acc = self#location loc acc in\n ({ txt; loc }, acc)\n\n method longident : longident -> 'acc -> longident * 'acc =\n fun x acc ->\n match x with\n | Lident a ->\n let a, acc = self#string a acc in\n (Lident a, acc)\n | Ldot (a, b) ->\n let a, acc = self#longident a acc in\n let b, acc = self#string b acc in\n (Ldot (a, b), acc)\n | Lapply (a, b) ->\n let a, acc = self#longident a acc in\n let b, acc = self#longident b acc in\n (Lapply (a, b), acc)\n\n method longident_loc : longident_loc -> 'acc -> longident_loc * 'acc =\n self#loc self#longident\n\n method rec_flag : rec_flag -> 'acc -> rec_flag * 'acc = fun x acc -> (x, acc)\n\n method direction_flag : direction_flag -> 'acc -> direction_flag * 'acc =\n fun x acc -> (x, acc)\n\n method private_flag : private_flag -> 'acc -> private_flag * 'acc =\n fun x acc -> (x, acc)\n\n method mutable_flag : mutable_flag -> 'acc -> mutable_flag * 'acc =\n fun x acc -> (x, acc)\n\n method virtual_flag : virtual_flag -> 'acc -> virtual_flag * 'acc =\n fun x acc -> (x, acc)\n\n method override_flag : override_flag -> 'acc -> override_flag * 'acc =\n fun x acc -> (x, acc)\n\n method closed_flag : closed_flag -> 'acc -> closed_flag * 'acc =\n fun x acc -> (x, acc)\n\n method label : label -> 'acc -> label * 'acc = self#string\n\n method arg_label : arg_label -> 'acc -> arg_label * 'acc =\n fun x acc ->\n match x with\n | Nolabel -> (Nolabel, acc)\n | Labelled a ->\n let a, acc = self#string a acc in\n (Labelled a, acc)\n | Optional a ->\n let a, acc = self#string a acc in\n (Optional a, acc)\n\n method variance : variance -> 'acc -> variance * 'acc = fun x acc -> (x, acc)\n\n method injectivity : injectivity -> 'acc -> injectivity * 'acc =\n fun x acc -> (x, acc)\n\n method constant : constant -> 'acc -> constant * 'acc =\n fun x acc ->\n match x with\n | Pconst_integer (a, b) ->\n let a, acc = self#string a acc in\n let b, acc = self#option self#char b acc in\n (Pconst_integer (a, b), acc)\n | Pconst_char a ->\n let a, acc = self#char a acc in\n (Pconst_char a, acc)\n | Pconst_string (a, b, c) ->\n let a, acc = self#string a acc in\n let b, acc = self#location b acc in\n let c, acc = self#option self#string c acc in\n (Pconst_string (a, b, c), acc)\n | Pconst_float (a, b) ->\n let a, acc = self#string a acc in\n let b, acc = self#option self#char b acc in\n (Pconst_float (a, b), acc)\n\n method attribute : attribute -> 'acc -> attribute * 'acc =\n fun { attr_name; attr_payload; attr_loc } acc ->\n let attr_name, acc = self#loc self#string attr_name acc in\n let attr_payload, acc = self#payload attr_payload acc in\n let attr_loc, acc = self#location attr_loc acc in\n ({ attr_name; attr_payload; attr_loc }, acc)\n\n method extension : extension -> 'acc -> extension * 'acc =\n fun (a, b) acc ->\n let a, acc = self#loc self#string a acc in\n let b, acc = self#payload b acc in\n ((a, b), acc)\n\n method attributes : attributes -> 'acc -> attributes * 'acc =\n self#list self#attribute\n\n method payload : payload -> 'acc -> payload * 'acc =\n fun x acc ->\n match x with\n | PStr a ->\n let a, acc = self#structure a acc in\n (PStr a, acc)\n | PSig a ->\n let a, acc = self#signature a acc in\n (PSig a, acc)\n | PTyp a ->\n let a, acc = self#core_type a acc in\n (PTyp a, acc)\n | PPat (a, b) ->\n let a, acc = self#pattern a acc in\n let b, acc = self#option self#expression b acc in\n (PPat (a, b), acc)\n\n method core_type : core_type -> 'acc -> core_type * 'acc =\n fun { ptyp_desc; ptyp_loc; ptyp_loc_stack; ptyp_attributes } acc ->\n let ptyp_desc, acc = self#core_type_desc ptyp_desc acc in\n let ptyp_loc, acc = self#location ptyp_loc acc in\n let ptyp_loc_stack, acc = self#location_stack ptyp_loc_stack acc in\n let ptyp_attributes, acc = self#attributes ptyp_attributes acc in\n ({ ptyp_desc; ptyp_loc; ptyp_loc_stack; ptyp_attributes }, acc)\n\n method core_type_desc : core_type_desc -> 'acc -> core_type_desc * 'acc =\n fun x acc ->\n match x with\n | Ptyp_any -> (Ptyp_any, acc)\n | Ptyp_var a ->\n let a, acc = self#string a acc in\n (Ptyp_var a, acc)\n | Ptyp_arrow (a, b, c) ->\n let a, acc = self#arg_label a acc in\n let b, acc = self#core_type b acc in\n let c, acc = self#core_type c acc in\n (Ptyp_arrow (a, b, c), acc)\n | Ptyp_tuple a ->\n let a, acc = self#list self#core_type a acc in\n (Ptyp_tuple a, acc)\n | Ptyp_constr (a, b) ->\n let a, acc = self#longident_loc a acc in\n let b, acc = self#list self#core_type b acc in\n (Ptyp_constr (a, b), acc)\n | Ptyp_object (a, b) ->\n let a, acc = self#list self#object_field a acc in\n let b, acc = self#closed_flag b acc in\n (Ptyp_object (a, b), acc)\n | Ptyp_class (a, b) ->\n let a, acc = self#longident_loc a acc in\n let b, acc = self#list self#core_type b acc in\n (Ptyp_class (a, b), acc)\n | Ptyp_alias (a, b) ->\n let a, acc = self#core_type a acc in\n let b, acc = self#string b acc in\n (Ptyp_alias (a, b), acc)\n | Ptyp_variant (a, b, c) ->\n let a, acc = self#list self#row_field a acc in\n let b, acc = self#closed_flag b acc in\n let c, acc = self#option (self#list self#label) c acc in\n (Ptyp_variant (a, b, c), acc)\n | Ptyp_poly (a, b) ->\n let a, acc = self#list (self#loc self#string) a acc in\n let b, acc = self#core_type b acc in\n (Ptyp_poly (a, b), acc)\n | Ptyp_package a ->\n let a, acc = self#package_type a acc in\n (Ptyp_package a, acc)\n | Ptyp_extension a ->\n let a, acc = self#extension a acc in\n (Ptyp_extension a, acc)\n\n method package_type : package_type -> 'acc -> package_type * 'acc =\n fun (a, b) acc ->\n let a, acc = self#longident_loc a acc in\n let b, acc =\n self#list\n (fun (a, b) acc ->\n let a, acc = self#longident_loc a acc in\n let b, acc = self#core_type b acc in\n ((a, b), acc))\n b acc\n in\n ((a, b), acc)\n\n method row_field : row_field -> 'acc -> row_field * 'acc =\n fun { prf_desc; prf_loc; prf_attributes } acc ->\n let prf_desc, acc = self#row_field_desc prf_desc acc in\n let prf_loc, acc = self#location prf_loc acc in\n let prf_attributes, acc = self#attributes prf_attributes acc in\n ({ prf_desc; prf_loc; prf_attributes }, acc)\n\n method row_field_desc : row_field_desc -> 'acc -> row_field_desc * 'acc =\n fun x acc ->\n match x with\n | Rtag (a, b, c) ->\n let a, acc = self#loc self#label a acc in\n let b, acc = self#bool b acc in\n let c, acc = self#list self#core_type c acc in\n (Rtag (a, b, c), acc)\n | Rinherit a ->\n let a, acc = self#core_type a acc in\n (Rinherit a, acc)\n\n method object_field : object_field -> 'acc -> object_field * 'acc =\n fun { pof_desc; pof_loc; pof_attributes } acc ->\n let pof_desc, acc = self#object_field_desc pof_desc acc in\n let pof_loc, acc = self#location pof_loc acc in\n let pof_attributes, acc = self#attributes pof_attributes acc in\n ({ pof_desc; pof_loc; pof_attributes }, acc)\n\n method object_field_desc\n : object_field_desc -> 'acc -> object_field_desc * 'acc =\n fun x acc ->\n match x with\n | Otag (a, b) ->\n let a, acc = self#loc self#label a acc in\n let b, acc = self#core_type b acc in\n (Otag (a, b), acc)\n | Oinherit a ->\n let a, acc = self#core_type a acc in\n (Oinherit a, acc)\n\n method pattern : pattern -> 'acc -> pattern * 'acc =\n fun { ppat_desc; ppat_loc; ppat_loc_stack; ppat_attributes } acc ->\n let ppat_desc, acc = self#pattern_desc ppat_desc acc in\n let ppat_loc, acc = self#location ppat_loc acc in\n let ppat_loc_stack, acc = self#location_stack ppat_loc_stack acc in\n let ppat_attributes, acc = self#attributes ppat_attributes acc in\n ({ ppat_desc; ppat_loc; ppat_loc_stack; ppat_attributes }, acc)\n\n method pattern_desc : pattern_desc -> 'acc -> pattern_desc * 'acc =\n fun x acc ->\n match x with\n | Ppat_any -> (Ppat_any, acc)\n | Ppat_var a ->\n let a, acc = self#loc self#string a acc in\n (Ppat_var a, acc)\n | Ppat_alias (a, b) ->\n let a, acc = self#pattern a acc in\n let b, acc = self#loc self#string b acc in\n (Ppat_alias (a, b), acc)\n | Ppat_constant a ->\n let a, acc = self#constant a acc in\n (Ppat_constant a, acc)\n | Ppat_interval (a, b) ->\n let a, acc = self#constant a acc in\n let b, acc = self#constant b acc in\n (Ppat_interval (a, b), acc)\n | Ppat_tuple a ->\n let a, acc = self#list self#pattern a acc in\n (Ppat_tuple a, acc)\n | Ppat_construct (a, b) ->\n let a, acc = self#longident_loc a acc in\n let b, acc = self#option self#pattern b acc in\n (Ppat_construct (a, b), acc)\n | Ppat_variant (a, b) ->\n let a, acc = self#label a acc in\n let b, acc = self#option self#pattern b acc in\n (Ppat_variant (a, b), acc)\n | Ppat_record (a, b) ->\n let a, acc =\n self#list\n (fun (a, b) acc ->\n let a, acc = self#longident_loc a acc in\n let b, acc = self#pattern b acc in\n ((a, b), acc))\n a acc\n in\n let b, acc = self#closed_flag b acc in\n (Ppat_record (a, b), acc)\n | Ppat_array a ->\n let a, acc = self#list self#pattern a acc in\n (Ppat_array a, acc)\n | Ppat_or (a, b) ->\n let a, acc = self#pattern a acc in\n let b, acc = self#pattern b acc in\n (Ppat_or (a, b), acc)\n | Ppat_constraint (a, b) ->\n let a, acc = self#pattern a acc in\n let b, acc = self#core_type b acc in\n (Ppat_constraint (a, b), acc)\n | Ppat_type a ->\n let a, acc = self#longident_loc a acc in\n (Ppat_type a, acc)\n | Ppat_lazy a ->\n let a, acc = self#pattern a acc in\n (Ppat_lazy a, acc)\n | Ppat_unpack a ->\n let a, acc = self#loc (self#option self#string) a acc in\n (Ppat_unpack a, acc)\n | Ppat_exception a ->\n let a, acc = self#pattern a acc in\n (Ppat_exception a, acc)\n | Ppat_extension a ->\n let a, acc = self#extension a acc in\n (Ppat_extension a, acc)\n | Ppat_open (a, b) ->\n let a, acc = self#longident_loc a acc in\n let b, acc = self#pattern b acc in\n (Ppat_open (a, b), acc)\n\n method expression : expression -> 'acc -> expression * 'acc =\n fun { pexp_desc; pexp_loc; pexp_loc_stack; pexp_attributes } acc ->\n let pexp_desc, acc = self#expression_desc pexp_desc acc in\n let pexp_loc, acc = self#location pexp_loc acc in\n let pexp_loc_stack, acc = self#location_stack pexp_loc_stack acc in\n let pexp_attributes, acc = self#attributes pexp_attributes acc in\n ({ pexp_desc; pexp_loc; pexp_loc_stack; pexp_attributes }, acc)\n\n method expression_desc : expression_desc -> 'acc -> expression_desc * 'acc =\n fun x acc ->\n match x with\n | Pexp_ident a ->\n let a, acc = self#longident_loc a acc in\n (Pexp_ident a, acc)\n | Pexp_constant a ->\n let a, acc = self#constant a acc in\n (Pexp_constant a, acc)\n | Pexp_let (a, b, c) ->\n let a, acc = self#rec_flag a acc in\n let b, acc = self#list self#value_binding b acc in\n let c, acc = self#expression c acc in\n (Pexp_let (a, b, c), acc)\n | Pexp_function a ->\n let a, acc = self#cases a acc in\n (Pexp_function a, acc)\n | Pexp_fun (a, b, c, d) ->\n let a, acc = self#arg_label a acc in\n let b, acc = self#option self#expression b acc in\n let c, acc = self#pattern c acc in\n let d, acc = self#expression d acc in\n (Pexp_fun (a, b, c, d), acc)\n | Pexp_apply (a, b) ->\n let a, acc = self#expression a acc in\n let b, acc =\n self#list\n (fun (a, b) acc ->\n let a, acc = self#arg_label a acc in\n let b, acc = self#expression b acc in\n ((a, b), acc))\n b acc\n in\n (Pexp_apply (a, b), acc)\n | Pexp_match (a, b) ->\n let a, acc = self#expression a acc in\n let b, acc = self#cases b acc in\n (Pexp_match (a, b), acc)\n | Pexp_try (a, b) ->\n let a, acc = self#expression a acc in\n let b, acc = self#cases b acc in\n (Pexp_try (a, b), acc)\n | Pexp_tuple a ->\n let a, acc = self#list self#expression a acc in\n (Pexp_tuple a, acc)\n | Pexp_construct (a, b) ->\n let a, acc = self#longident_loc a acc in\n let b, acc = self#option self#expression b acc in\n (Pexp_construct (a, b), acc)\n | Pexp_variant (a, b) ->\n let a, acc = self#label a acc in\n let b, acc = self#option self#expression b acc in\n (Pexp_variant (a, b), acc)\n | Pexp_record (a, b) ->\n let a, acc =\n self#list\n (fun (a, b) acc ->\n let a, acc = self#longident_loc a acc in\n let b, acc = self#expression b acc in\n ((a, b), acc))\n a acc\n in\n let b, acc = self#option self#expression b acc in\n (Pexp_record (a, b), acc)\n | Pexp_field (a, b) ->\n let a, acc = self#expression a acc in\n let b, acc = self#longident_loc b acc in\n (Pexp_field (a, b), acc)\n | Pexp_setfield (a, b, c) ->\n let a, acc = self#expression a acc in\n let b, acc = self#longident_loc b acc in\n let c, acc = self#expression c acc in\n (Pexp_setfield (a, b, c), acc)\n | Pexp_array a ->\n let a, acc = self#list self#expression a acc in\n (Pexp_array a, acc)\n | Pexp_ifthenelse (a, b, c) ->\n let a, acc = self#expression a acc in\n let b, acc = self#expression b acc in\n let c, acc = self#option self#expression c acc in\n (Pexp_ifthenelse (a, b, c), acc)\n | Pexp_sequence (a, b) ->\n let a, acc = self#expression a acc in\n let b, acc = self#expression b acc in\n (Pexp_sequence (a, b), acc)\n | Pexp_while (a, b) ->\n let a, acc = self#expression a acc in\n let b, acc = self#expression b acc in\n (Pexp_while (a, b), acc)\n | Pexp_for (a, b, c, d, e) ->\n let a, acc = self#pattern a acc in\n let b, acc = self#expression b acc in\n let c, acc = self#expression c acc in\n let d, acc = self#direction_flag d acc in\n let e, acc = self#expression e acc in\n (Pexp_for (a, b, c, d, e), acc)\n | Pexp_constraint (a, b) ->\n let a, acc = self#expression a acc in\n let b, acc = self#core_type b acc in\n (Pexp_constraint (a, b), acc)\n | Pexp_coerce (a, b, c) ->\n let a, acc = self#expression a acc in\n let b, acc = self#option self#core_type b acc in\n let c, acc = self#core_type c acc in\n (Pexp_coerce (a, b, c), acc)\n | Pexp_send (a, b) ->\n let a, acc = self#expression a acc in\n let b, acc = self#loc self#label b acc in\n (Pexp_send (a, b), acc)\n | Pexp_new a ->\n let a, acc = self#longident_loc a acc in\n (Pexp_new a, acc)\n | Pexp_setinstvar (a, b) ->\n let a, acc = self#loc self#label a acc in\n let b, acc = self#expression b acc in\n (Pexp_setinstvar (a, b), acc)\n | Pexp_override a ->\n let a, acc =\n self#list\n (fun (a, b) acc ->\n let a, acc = self#loc self#label a acc in\n let b, acc = self#expression b acc in\n ((a, b), acc))\n a acc\n in\n (Pexp_override a, acc)\n | Pexp_letmodule (a, b, c) ->\n let a, acc = self#loc (self#option self#string) a acc in\n let b, acc = self#module_expr b acc in\n let c, acc = self#expression c acc in\n (Pexp_letmodule (a, b, c), acc)\n | Pexp_letexception (a, b) ->\n let a, acc = self#extension_constructor a acc in\n let b, acc = self#expression b acc in\n (Pexp_letexception (a, b), acc)\n | Pexp_assert a ->\n let a, acc = self#expression a acc in\n (Pexp_assert a, acc)\n | Pexp_lazy a ->\n let a, acc = self#expression a acc in\n (Pexp_lazy a, acc)\n | Pexp_poly (a, b) ->\n let a, acc = self#expression a acc in\n let b, acc = self#option self#core_type b acc in\n (Pexp_poly (a, b), acc)\n | Pexp_object a ->\n let a, acc = self#class_structure a acc in\n (Pexp_object a, acc)\n | Pexp_newtype (a, b) ->\n let a, acc = self#loc self#string a acc in\n let b, acc = self#expression b acc in\n (Pexp_newtype (a, b), acc)\n | Pexp_pack a ->\n let a, acc = self#module_expr a acc in\n (Pexp_pack a, acc)\n | Pexp_open (a, b) ->\n let a, acc = self#open_declaration a acc in\n let b, acc = self#expression b acc in\n (Pexp_open (a, b), acc)\n | Pexp_letop a ->\n let a, acc = self#letop a acc in\n (Pexp_letop a, acc)\n | Pexp_extension a ->\n let a, acc = self#extension a acc in\n (Pexp_extension a, acc)\n | Pexp_unreachable -> (Pexp_unreachable, acc)\n\n method case : case -> 'acc -> case * 'acc =\n fun { pc_lhs; pc_guard; pc_rhs } acc ->\n let pc_lhs, acc = self#pattern pc_lhs acc in\n let pc_guard, acc = self#option self#expression pc_guard acc in\n let pc_rhs, acc = self#expression pc_rhs acc in\n ({ pc_lhs; pc_guard; pc_rhs }, acc)\n\n method letop : letop -> 'acc -> letop * 'acc =\n fun { let_; ands; body } acc ->\n let let_, acc = self#binding_op let_ acc in\n let ands, acc = self#list self#binding_op ands acc in\n let body, acc = self#expression body acc in\n ({ let_; ands; body }, acc)\n\n method binding_op : binding_op -> 'acc -> binding_op * 'acc =\n fun { pbop_op; pbop_pat; pbop_exp; pbop_loc } acc ->\n let pbop_op, acc = self#loc self#string pbop_op acc in\n let pbop_pat, acc = self#pattern pbop_pat acc in\n let pbop_exp, acc = self#expression pbop_exp acc in\n let pbop_loc, acc = self#location pbop_loc acc in\n ({ pbop_op; pbop_pat; pbop_exp; pbop_loc }, acc)\n\n method value_description\n : value_description -> 'acc -> value_description * 'acc =\n fun { pval_name; pval_type; pval_prim; pval_attributes; pval_loc } acc ->\n let pval_name, acc = self#loc self#string pval_name acc in\n let pval_type, acc = self#core_type pval_type acc in\n let pval_prim, acc = self#list self#string pval_prim acc in\n let pval_attributes, acc = self#attributes pval_attributes acc in\n let pval_loc, acc = self#location pval_loc acc in\n ({ pval_name; pval_type; pval_prim; pval_attributes; pval_loc }, acc)\n\n method type_declaration\n : type_declaration -> 'acc -> type_declaration * 'acc =\n fun {\n ptype_name;\n ptype_params;\n ptype_cstrs;\n ptype_kind;\n ptype_private;\n ptype_manifest;\n ptype_attributes;\n ptype_loc;\n } acc ->\n let ptype_name, acc = self#loc self#string ptype_name acc in\n let ptype_params, acc =\n self#list\n (fun (a, b) acc ->\n let a, acc = self#core_type a acc in\n let b, acc =\n (fun (a, b) acc ->\n let a, acc = self#variance a acc in\n let b, acc = self#injectivity b acc in\n ((a, b), acc))\n b acc\n in\n ((a, b), acc))\n ptype_params acc\n in\n let ptype_cstrs, acc =\n self#list\n (fun (a, b, c) acc ->\n let a, acc = self#core_type a acc in\n let b, acc = self#core_type b acc in\n let c, acc = self#location c acc in\n ((a, b, c), acc))\n ptype_cstrs acc\n in\n let ptype_kind, acc = self#type_kind ptype_kind acc in\n let ptype_private, acc = self#private_flag ptype_private acc in\n let ptype_manifest, acc =\n self#option self#core_type ptype_manifest acc\n in\n let ptype_attributes, acc = self#attributes ptype_attributes acc in\n let ptype_loc, acc = self#location ptype_loc acc in\n ( {\n ptype_name;\n ptype_params;\n ptype_cstrs;\n ptype_kind;\n ptype_private;\n ptype_manifest;\n ptype_attributes;\n ptype_loc;\n },\n acc )\n\n method type_kind : type_kind -> 'acc -> type_kind * 'acc =\n fun x acc ->\n match x with\n | Ptype_abstract -> (Ptype_abstract, acc)\n | Ptype_variant a ->\n let a, acc = self#list self#constructor_declaration a acc in\n (Ptype_variant a, acc)\n | Ptype_record a ->\n let a, acc = self#list self#label_declaration a acc in\n (Ptype_record a, acc)\n | Ptype_open -> (Ptype_open, acc)\n\n method label_declaration\n : label_declaration -> 'acc -> label_declaration * 'acc =\n fun { pld_name; pld_mutable; pld_type; pld_loc; pld_attributes } acc ->\n let pld_name, acc = self#loc self#string pld_name acc in\n let pld_mutable, acc = self#mutable_flag pld_mutable acc in\n let pld_type, acc = self#core_type pld_type acc in\n let pld_loc, acc = self#location pld_loc acc in\n let pld_attributes, acc = self#attributes pld_attributes acc in\n ({ pld_name; pld_mutable; pld_type; pld_loc; pld_attributes }, acc)\n\n method constructor_declaration\n : constructor_declaration -> 'acc -> constructor_declaration * 'acc =\n fun { pcd_name; pcd_args; pcd_res; pcd_loc; pcd_attributes } acc ->\n let pcd_name, acc = self#loc self#string pcd_name acc in\n let pcd_args, acc = self#constructor_arguments pcd_args acc in\n let pcd_res, acc = self#option self#core_type pcd_res acc in\n let pcd_loc, acc = self#location pcd_loc acc in\n let pcd_attributes, acc = self#attributes pcd_attributes acc in\n ({ pcd_name; pcd_args; pcd_res; pcd_loc; pcd_attributes }, acc)\n\n method constructor_arguments\n : constructor_arguments -> 'acc -> constructor_arguments * 'acc =\n fun x acc ->\n match x with\n | Pcstr_tuple a ->\n let a, acc = self#list self#core_type a acc in\n (Pcstr_tuple a, acc)\n | Pcstr_record a ->\n let a, acc = self#list self#label_declaration a acc in\n (Pcstr_record a, acc)\n\n method type_extension : type_extension -> 'acc -> type_extension * 'acc =\n fun {\n ptyext_path;\n ptyext_params;\n ptyext_constructors;\n ptyext_private;\n ptyext_loc;\n ptyext_attributes;\n } acc ->\n let ptyext_path, acc = self#longident_loc ptyext_path acc in\n let ptyext_params, acc =\n self#list\n (fun (a, b) acc ->\n let a, acc = self#core_type a acc in\n let b, acc =\n (fun (a, b) acc ->\n let a, acc = self#variance a acc in\n let b, acc = self#injectivity b acc in\n ((a, b), acc))\n b acc\n in\n ((a, b), acc))\n ptyext_params acc\n in\n let ptyext_constructors, acc =\n self#list self#extension_constructor ptyext_constructors acc\n in\n let ptyext_private, acc = self#private_flag ptyext_private acc in\n let ptyext_loc, acc = self#location ptyext_loc acc in\n let ptyext_attributes, acc = self#attributes ptyext_attributes acc in\n ( {\n ptyext_path;\n ptyext_params;\n ptyext_constructors;\n ptyext_private;\n ptyext_loc;\n ptyext_attributes;\n },\n acc )\n\n method extension_constructor\n : extension_constructor -> 'acc -> extension_constructor * 'acc =\n fun { pext_name; pext_kind; pext_loc; pext_attributes } acc ->\n let pext_name, acc = self#loc self#string pext_name acc in\n let pext_kind, acc = self#extension_constructor_kind pext_kind acc in\n let pext_loc, acc = self#location pext_loc acc in\n let pext_attributes, acc = self#attributes pext_attributes acc in\n ({ pext_name; pext_kind; pext_loc; pext_attributes }, acc)\n\n method type_exception : type_exception -> 'acc -> type_exception * 'acc =\n fun { ptyexn_constructor; ptyexn_loc; ptyexn_attributes } acc ->\n let ptyexn_constructor, acc =\n self#extension_constructor ptyexn_constructor acc\n in\n let ptyexn_loc, acc = self#location ptyexn_loc acc in\n let ptyexn_attributes, acc = self#attributes ptyexn_attributes acc in\n ({ ptyexn_constructor; ptyexn_loc; ptyexn_attributes }, acc)\n\n method extension_constructor_kind\n : extension_constructor_kind ->\n 'acc ->\n extension_constructor_kind * 'acc =\n fun x acc ->\n match x with\n | Pext_decl (a, b) ->\n let a, acc = self#constructor_arguments a acc in\n let b, acc = self#option self#core_type b acc in\n (Pext_decl (a, b), acc)\n | Pext_rebind a ->\n let a, acc = self#longident_loc a acc in\n (Pext_rebind a, acc)\n\n method class_type : class_type -> 'acc -> class_type * 'acc =\n fun { pcty_desc; pcty_loc; pcty_attributes } acc ->\n let pcty_desc, acc = self#class_type_desc pcty_desc acc in\n let pcty_loc, acc = self#location pcty_loc acc in\n let pcty_attributes, acc = self#attributes pcty_attributes acc in\n ({ pcty_desc; pcty_loc; pcty_attributes }, acc)\n\n method class_type_desc : class_type_desc -> 'acc -> class_type_desc * 'acc =\n fun x acc ->\n match x with\n | Pcty_constr (a, b) ->\n let a, acc = self#longident_loc a acc in\n let b, acc = self#list self#core_type b acc in\n (Pcty_constr (a, b), acc)\n | Pcty_signature a ->\n let a, acc = self#class_signature a acc in\n (Pcty_signature a, acc)\n | Pcty_arrow (a, b, c) ->\n let a, acc = self#arg_label a acc in\n let b, acc = self#core_type b acc in\n let c, acc = self#class_type c acc in\n (Pcty_arrow (a, b, c), acc)\n | Pcty_extension a ->\n let a, acc = self#extension a acc in\n (Pcty_extension a, acc)\n | Pcty_open (a, b) ->\n let a, acc = self#open_description a acc in\n let b, acc = self#class_type b acc in\n (Pcty_open (a, b), acc)\n\n method class_signature : class_signature -> 'acc -> class_signature * 'acc =\n fun { pcsig_self; pcsig_fields } acc ->\n let pcsig_self, acc = self#core_type pcsig_self acc in\n let pcsig_fields, acc =\n self#list self#class_type_field pcsig_fields acc\n in\n ({ pcsig_self; pcsig_fields }, acc)\n\n method class_type_field\n : class_type_field -> 'acc -> class_type_field * 'acc =\n fun { pctf_desc; pctf_loc; pctf_attributes } acc ->\n let pctf_desc, acc = self#class_type_field_desc pctf_desc acc in\n let pctf_loc, acc = self#location pctf_loc acc in\n let pctf_attributes, acc = self#attributes pctf_attributes acc in\n ({ pctf_desc; pctf_loc; pctf_attributes }, acc)\n\n method class_type_field_desc\n : class_type_field_desc -> 'acc -> class_type_field_desc * 'acc =\n fun x acc ->\n match x with\n | Pctf_inherit a ->\n let a, acc = self#class_type a acc in\n (Pctf_inherit a, acc)\n | Pctf_val a ->\n let a, acc =\n (fun (a, b, c, d) acc ->\n let a, acc = self#loc self#label a acc in\n let b, acc = self#mutable_flag b acc in\n let c, acc = self#virtual_flag c acc in\n let d, acc = self#core_type d acc in\n ((a, b, c, d), acc))\n a acc\n in\n (Pctf_val a, acc)\n | Pctf_method a ->\n let a, acc =\n (fun (a, b, c, d) acc ->\n let a, acc = self#loc self#label a acc in\n let b, acc = self#private_flag b acc in\n let c, acc = self#virtual_flag c acc in\n let d, acc = self#core_type d acc in\n ((a, b, c, d), acc))\n a acc\n in\n (Pctf_method a, acc)\n | Pctf_constraint a ->\n let a, acc =\n (fun (a, b) acc ->\n let a, acc = self#core_type a acc in\n let b, acc = self#core_type b acc in\n ((a, b), acc))\n a acc\n in\n (Pctf_constraint a, acc)\n | Pctf_attribute a ->\n let a, acc = self#attribute a acc in\n (Pctf_attribute a, acc)\n | Pctf_extension a ->\n let a, acc = self#extension a acc in\n (Pctf_extension a, acc)\n\n method class_infos\n : 'a.\n ('a -> 'acc -> 'a * 'acc) ->\n 'a class_infos ->\n 'acc ->\n 'a class_infos * 'acc =\n fun _a\n { pci_virt; pci_params; pci_name; pci_expr; pci_loc; pci_attributes }\n acc ->\n let pci_virt, acc = self#virtual_flag pci_virt acc in\n let pci_params, acc =\n self#list\n (fun (a, b) acc ->\n let a, acc = self#core_type a acc in\n let b, acc =\n (fun (a, b) acc ->\n let a, acc = self#variance a acc in\n let b, acc = self#injectivity b acc in\n ((a, b), acc))\n b acc\n in\n ((a, b), acc))\n pci_params acc\n in\n let pci_name, acc = self#loc self#string pci_name acc in\n let pci_expr, acc = _a pci_expr acc in\n let pci_loc, acc = self#location pci_loc acc in\n let pci_attributes, acc = self#attributes pci_attributes acc in\n ( { pci_virt; pci_params; pci_name; pci_expr; pci_loc; pci_attributes },\n acc )\n\n method class_description\n : class_description -> 'acc -> class_description * 'acc =\n self#class_infos self#class_type\n\n method class_type_declaration\n : class_type_declaration -> 'acc -> class_type_declaration * 'acc =\n self#class_infos self#class_type\n\n method class_expr : class_expr -> 'acc -> class_expr * 'acc =\n fun { pcl_desc; pcl_loc; pcl_attributes } acc ->\n let pcl_desc, acc = self#class_expr_desc pcl_desc acc in\n let pcl_loc, acc = self#location pcl_loc acc in\n let pcl_attributes, acc = self#attributes pcl_attributes acc in\n ({ pcl_desc; pcl_loc; pcl_attributes }, acc)\n\n method class_expr_desc : class_expr_desc -> 'acc -> class_expr_desc * 'acc =\n fun x acc ->\n match x with\n | Pcl_constr (a, b) ->\n let a, acc = self#longident_loc a acc in\n let b, acc = self#list self#core_type b acc in\n (Pcl_constr (a, b), acc)\n | Pcl_structure a ->\n let a, acc = self#class_structure a acc in\n (Pcl_structure a, acc)\n | Pcl_fun (a, b, c, d) ->\n let a, acc = self#arg_label a acc in\n let b, acc = self#option self#expression b acc in\n let c, acc = self#pattern c acc in\n let d, acc = self#class_expr d acc in\n (Pcl_fun (a, b, c, d), acc)\n | Pcl_apply (a, b) ->\n let a, acc = self#class_expr a acc in\n let b, acc =\n self#list\n (fun (a, b) acc ->\n let a, acc = self#arg_label a acc in\n let b, acc = self#expression b acc in\n ((a, b), acc))\n b acc\n in\n (Pcl_apply (a, b), acc)\n | Pcl_let (a, b, c) ->\n let a, acc = self#rec_flag a acc in\n let b, acc = self#list self#value_binding b acc in\n let c, acc = self#class_expr c acc in\n (Pcl_let (a, b, c), acc)\n | Pcl_constraint (a, b) ->\n let a, acc = self#class_expr a acc in\n let b, acc = self#class_type b acc in\n (Pcl_constraint (a, b), acc)\n | Pcl_extension a ->\n let a, acc = self#extension a acc in\n (Pcl_extension a, acc)\n | Pcl_open (a, b) ->\n let a, acc = self#open_description a acc in\n let b, acc = self#class_expr b acc in\n (Pcl_open (a, b), acc)\n\n method class_structure : class_structure -> 'acc -> class_structure * 'acc =\n fun { pcstr_self; pcstr_fields } acc ->\n let pcstr_self, acc = self#pattern pcstr_self acc in\n let pcstr_fields, acc = self#list self#class_field pcstr_fields acc in\n ({ pcstr_self; pcstr_fields }, acc)\n\n method class_field : class_field -> 'acc -> class_field * 'acc =\n fun { pcf_desc; pcf_loc; pcf_attributes } acc ->\n let pcf_desc, acc = self#class_field_desc pcf_desc acc in\n let pcf_loc, acc = self#location pcf_loc acc in\n let pcf_attributes, acc = self#attributes pcf_attributes acc in\n ({ pcf_desc; pcf_loc; pcf_attributes }, acc)\n\n method class_field_desc\n : class_field_desc -> 'acc -> class_field_desc * 'acc =\n fun x acc ->\n match x with\n | Pcf_inherit (a, b, c) ->\n let a, acc = self#override_flag a acc in\n let b, acc = self#class_expr b acc in\n let c, acc = self#option (self#loc self#string) c acc in\n (Pcf_inherit (a, b, c), acc)\n | Pcf_val a ->\n let a, acc =\n (fun (a, b, c) acc ->\n let a, acc = self#loc self#label a acc in\n let b, acc = self#mutable_flag b acc in\n let c, acc = self#class_field_kind c acc in\n ((a, b, c), acc))\n a acc\n in\n (Pcf_val a, acc)\n | Pcf_method a ->\n let a, acc =\n (fun (a, b, c) acc ->\n let a, acc = self#loc self#label a acc in\n let b, acc = self#private_flag b acc in\n let c, acc = self#class_field_kind c acc in\n ((a, b, c), acc))\n a acc\n in\n (Pcf_method a, acc)\n | Pcf_constraint a ->\n let a, acc =\n (fun (a, b) acc ->\n let a, acc = self#core_type a acc in\n let b, acc = self#core_type b acc in\n ((a, b), acc))\n a acc\n in\n (Pcf_constraint a, acc)\n | Pcf_initializer a ->\n let a, acc = self#expression a acc in\n (Pcf_initializer a, acc)\n | Pcf_attribute a ->\n let a, acc = self#attribute a acc in\n (Pcf_attribute a, acc)\n | Pcf_extension a ->\n let a, acc = self#extension a acc in\n (Pcf_extension a, acc)\n\n method class_field_kind\n : class_field_kind -> 'acc -> class_field_kind * 'acc =\n fun x acc ->\n match x with\n | Cfk_virtual a ->\n let a, acc = self#core_type a acc in\n (Cfk_virtual a, acc)\n | Cfk_concrete (a, b) ->\n let a, acc = self#override_flag a acc in\n let b, acc = self#expression b acc in\n (Cfk_concrete (a, b), acc)\n\n method class_declaration\n : class_declaration -> 'acc -> class_declaration * 'acc =\n self#class_infos self#class_expr\n\n method module_type : module_type -> 'acc -> module_type * 'acc =\n fun { pmty_desc; pmty_loc; pmty_attributes } acc ->\n let pmty_desc, acc = self#module_type_desc pmty_desc acc in\n let pmty_loc, acc = self#location pmty_loc acc in\n let pmty_attributes, acc = self#attributes pmty_attributes acc in\n ({ pmty_desc; pmty_loc; pmty_attributes }, acc)\n\n method module_type_desc\n : module_type_desc -> 'acc -> module_type_desc * 'acc =\n fun x acc ->\n match x with\n | Pmty_ident a ->\n let a, acc = self#longident_loc a acc in\n (Pmty_ident a, acc)\n | Pmty_signature a ->\n let a, acc = self#signature a acc in\n (Pmty_signature a, acc)\n | Pmty_functor (a, b) ->\n let a, acc = self#functor_parameter a acc in\n let b, acc = self#module_type b acc in\n (Pmty_functor (a, b), acc)\n | Pmty_with (a, b) ->\n let a, acc = self#module_type a acc in\n let b, acc = self#list self#with_constraint b acc in\n (Pmty_with (a, b), acc)\n | Pmty_typeof a ->\n let a, acc = self#module_expr a acc in\n (Pmty_typeof a, acc)\n | Pmty_extension a ->\n let a, acc = self#extension a acc in\n (Pmty_extension a, acc)\n | Pmty_alias a ->\n let a, acc = self#longident_loc a acc in\n (Pmty_alias a, acc)\n\n method functor_parameter\n : functor_parameter -> 'acc -> functor_parameter * 'acc =\n fun x acc ->\n match x with\n | Unit -> (Unit, acc)\n | Named (a, b) ->\n let a, acc = self#loc (self#option self#string) a acc in\n let b, acc = self#module_type b acc in\n (Named (a, b), acc)\n\n method signature : signature -> 'acc -> signature * 'acc =\n self#list self#signature_item\n\n method signature_item : signature_item -> 'acc -> signature_item * 'acc =\n fun { psig_desc; psig_loc } acc ->\n let psig_desc, acc = self#signature_item_desc psig_desc acc in\n let psig_loc, acc = self#location psig_loc acc in\n ({ psig_desc; psig_loc }, acc)\n\n method signature_item_desc\n : signature_item_desc -> 'acc -> signature_item_desc * 'acc =\n fun x acc ->\n match x with\n | Psig_value a ->\n let a, acc = self#value_description a acc in\n (Psig_value a, acc)\n | Psig_type (a, b) ->\n let a, acc = self#rec_flag a acc in\n let b, acc = self#list self#type_declaration b acc in\n (Psig_type (a, b), acc)\n | Psig_typesubst a ->\n let a, acc = self#list self#type_declaration a acc in\n (Psig_typesubst a, acc)\n | Psig_typext a ->\n let a, acc = self#type_extension a acc in\n (Psig_typext a, acc)\n | Psig_exception a ->\n let a, acc = self#type_exception a acc in\n (Psig_exception a, acc)\n | Psig_module a ->\n let a, acc = self#module_declaration a acc in\n (Psig_module a, acc)\n | Psig_modsubst a ->\n let a, acc = self#module_substitution a acc in\n (Psig_modsubst a, acc)\n | Psig_recmodule a ->\n let a, acc = self#list self#module_declaration a acc in\n (Psig_recmodule a, acc)\n | Psig_modtype a ->\n let a, acc = self#module_type_declaration a acc in\n (Psig_modtype a, acc)\n | Psig_open a ->\n let a, acc = self#open_description a acc in\n (Psig_open a, acc)\n | Psig_include a ->\n let a, acc = self#include_description a acc in\n (Psig_include a, acc)\n | Psig_class a ->\n let a, acc = self#list self#class_description a acc in\n (Psig_class a, acc)\n | Psig_class_type a ->\n let a, acc = self#list self#class_type_declaration a acc in\n (Psig_class_type a, acc)\n | Psig_attribute a ->\n let a, acc = self#attribute a acc in\n (Psig_attribute a, acc)\n | Psig_extension (a, b) ->\n let a, acc = self#extension a acc in\n let b, acc = self#attributes b acc in\n (Psig_extension (a, b), acc)\n\n method module_declaration\n : module_declaration -> 'acc -> module_declaration * 'acc =\n fun { pmd_name; pmd_type; pmd_attributes; pmd_loc } acc ->\n let pmd_name, acc = self#loc (self#option self#string) pmd_name acc in\n let pmd_type, acc = self#module_type pmd_type acc in\n let pmd_attributes, acc = self#attributes pmd_attributes acc in\n let pmd_loc, acc = self#location pmd_loc acc in\n ({ pmd_name; pmd_type; pmd_attributes; pmd_loc }, acc)\n\n method module_substitution\n : module_substitution -> 'acc -> module_substitution * 'acc =\n fun { pms_name; pms_manifest; pms_attributes; pms_loc } acc ->\n let pms_name, acc = self#loc self#string pms_name acc in\n let pms_manifest, acc = self#longident_loc pms_manifest acc in\n let pms_attributes, acc = self#attributes pms_attributes acc in\n let pms_loc, acc = self#location pms_loc acc in\n ({ pms_name; pms_manifest; pms_attributes; pms_loc }, acc)\n\n method module_type_declaration\n : module_type_declaration -> 'acc -> module_type_declaration * 'acc =\n fun { pmtd_name; pmtd_type; pmtd_attributes; pmtd_loc } acc ->\n let pmtd_name, acc = self#loc self#string pmtd_name acc in\n let pmtd_type, acc = self#option self#module_type pmtd_type acc in\n let pmtd_attributes, acc = self#attributes pmtd_attributes acc in\n let pmtd_loc, acc = self#location pmtd_loc acc in\n ({ pmtd_name; pmtd_type; pmtd_attributes; pmtd_loc }, acc)\n\n method open_infos\n : 'a.\n ('a -> 'acc -> 'a * 'acc) ->\n 'a open_infos ->\n 'acc ->\n 'a open_infos * 'acc =\n fun _a { popen_expr; popen_override; popen_loc; popen_attributes } acc ->\n let popen_expr, acc = _a popen_expr acc in\n let popen_override, acc = self#override_flag popen_override acc in\n let popen_loc, acc = self#location popen_loc acc in\n let popen_attributes, acc = self#attributes popen_attributes acc in\n ({ popen_expr; popen_override; popen_loc; popen_attributes }, acc)\n\n method open_description\n : open_description -> 'acc -> open_description * 'acc =\n self#open_infos self#longident_loc\n\n method open_declaration\n : open_declaration -> 'acc -> open_declaration * 'acc =\n self#open_infos self#module_expr\n\n method include_infos\n : 'a.\n ('a -> 'acc -> 'a * 'acc) ->\n 'a include_infos ->\n 'acc ->\n 'a include_infos * 'acc =\n fun _a { pincl_mod; pincl_loc; pincl_attributes } acc ->\n let pincl_mod, acc = _a pincl_mod acc in\n let pincl_loc, acc = self#location pincl_loc acc in\n let pincl_attributes, acc = self#attributes pincl_attributes acc in\n ({ pincl_mod; pincl_loc; pincl_attributes }, acc)\n\n method include_description\n : include_description -> 'acc -> include_description * 'acc =\n self#include_infos self#module_type\n\n method include_declaration\n : include_declaration -> 'acc -> include_declaration * 'acc =\n self#include_infos self#module_expr\n\n method with_constraint : with_constraint -> 'acc -> with_constraint * 'acc =\n fun x acc ->\n match x with\n | Pwith_type (a, b) ->\n let a, acc = self#longident_loc a acc in\n let b, acc = self#type_declaration b acc in\n (Pwith_type (a, b), acc)\n | Pwith_module (a, b) ->\n let a, acc = self#longident_loc a acc in\n let b, acc = self#longident_loc b acc in\n (Pwith_module (a, b), acc)\n | Pwith_typesubst (a, b) ->\n let a, acc = self#longident_loc a acc in\n let b, acc = self#type_declaration b acc in\n (Pwith_typesubst (a, b), acc)\n | Pwith_modsubst (a, b) ->\n let a, acc = self#longident_loc a acc in\n let b, acc = self#longident_loc b acc in\n (Pwith_modsubst (a, b), acc)\n\n method module_expr : module_expr -> 'acc -> module_expr * 'acc =\n fun { pmod_desc; pmod_loc; pmod_attributes } acc ->\n let pmod_desc, acc = self#module_expr_desc pmod_desc acc in\n let pmod_loc, acc = self#location pmod_loc acc in\n let pmod_attributes, acc = self#attributes pmod_attributes acc in\n ({ pmod_desc; pmod_loc; pmod_attributes }, acc)\n\n method module_expr_desc\n : module_expr_desc -> 'acc -> module_expr_desc * 'acc =\n fun x acc ->\n match x with\n | Pmod_ident a ->\n let a, acc = self#longident_loc a acc in\n (Pmod_ident a, acc)\n | Pmod_structure a ->\n let a, acc = self#structure a acc in\n (Pmod_structure a, acc)\n | Pmod_functor (a, b) ->\n let a, acc = self#functor_parameter a acc in\n let b, acc = self#module_expr b acc in\n (Pmod_functor (a, b), acc)\n | Pmod_apply (a, b) ->\n let a, acc = self#module_expr a acc in\n let b, acc = self#module_expr b acc in\n (Pmod_apply (a, b), acc)\n | Pmod_constraint (a, b) ->\n let a, acc = self#module_expr a acc in\n let b, acc = self#module_type b acc in\n (Pmod_constraint (a, b), acc)\n | Pmod_unpack a ->\n let a, acc = self#expression a acc in\n (Pmod_unpack a, acc)\n | Pmod_extension a ->\n let a, acc = self#extension a acc in\n (Pmod_extension a, acc)\n\n method structure : structure -> 'acc -> structure * 'acc =\n self#list self#structure_item\n\n method structure_item : structure_item -> 'acc -> structure_item * 'acc =\n fun { pstr_desc; pstr_loc } acc ->\n let pstr_desc, acc = self#structure_item_desc pstr_desc acc in\n let pstr_loc, acc = self#location pstr_loc acc in\n ({ pstr_desc; pstr_loc }, acc)\n\n method structure_item_desc\n : structure_item_desc -> 'acc -> structure_item_desc * 'acc =\n fun x acc ->\n match x with\n | Pstr_eval (a, b) ->\n let a, acc = self#expression a acc in\n let b, acc = self#attributes b acc in\n (Pstr_eval (a, b), acc)\n | Pstr_value (a, b) ->\n let a, acc = self#rec_flag a acc in\n let b, acc = self#list self#value_binding b acc in\n (Pstr_value (a, b), acc)\n | Pstr_primitive a ->\n let a, acc = self#value_description a acc in\n (Pstr_primitive a, acc)\n | Pstr_type (a, b) ->\n let a, acc = self#rec_flag a acc in\n let b, acc = self#list self#type_declaration b acc in\n (Pstr_type (a, b), acc)\n | Pstr_typext a ->\n let a, acc = self#type_extension a acc in\n (Pstr_typext a, acc)\n | Pstr_exception a ->\n let a, acc = self#type_exception a acc in\n (Pstr_exception a, acc)\n | Pstr_module a ->\n let a, acc = self#module_binding a acc in\n (Pstr_module a, acc)\n | Pstr_recmodule a ->\n let a, acc = self#list self#module_binding a acc in\n (Pstr_recmodule a, acc)\n | Pstr_modtype a ->\n let a, acc = self#module_type_declaration a acc in\n (Pstr_modtype a, acc)\n | Pstr_open a ->\n let a, acc = self#open_declaration a acc in\n (Pstr_open a, acc)\n | Pstr_class a ->\n let a, acc = self#list self#class_declaration a acc in\n (Pstr_class a, acc)\n | Pstr_class_type a ->\n let a, acc = self#list self#class_type_declaration a acc in\n (Pstr_class_type a, acc)\n | Pstr_include a ->\n let a, acc = self#include_declaration a acc in\n (Pstr_include a, acc)\n | Pstr_attribute a ->\n let a, acc = self#attribute a acc in\n (Pstr_attribute a, acc)\n | Pstr_extension (a, b) ->\n let a, acc = self#extension a acc in\n let b, acc = self#attributes b acc in\n (Pstr_extension (a, b), acc)\n\n method value_binding : value_binding -> 'acc -> value_binding * 'acc =\n fun { pvb_pat; pvb_expr; pvb_attributes; pvb_loc } acc ->\n let pvb_pat, acc = self#pattern pvb_pat acc in\n let pvb_expr, acc = self#expression pvb_expr acc in\n let pvb_attributes, acc = self#attributes pvb_attributes acc in\n let pvb_loc, acc = self#location pvb_loc acc in\n ({ pvb_pat; pvb_expr; pvb_attributes; pvb_loc }, acc)\n\n method module_binding : module_binding -> 'acc -> module_binding * 'acc =\n fun { pmb_name; pmb_expr; pmb_attributes; pmb_loc } acc ->\n let pmb_name, acc = self#loc (self#option self#string) pmb_name acc in\n let pmb_expr, acc = self#module_expr pmb_expr acc in\n let pmb_attributes, acc = self#attributes pmb_attributes acc in\n let pmb_loc, acc = self#location pmb_loc acc in\n ({ pmb_name; pmb_expr; pmb_attributes; pmb_loc }, acc)\n\n method toplevel_phrase : toplevel_phrase -> 'acc -> toplevel_phrase * 'acc =\n fun x acc ->\n match x with\n | Ptop_def a ->\n let a, acc = self#structure a acc in\n (Ptop_def a, acc)\n | Ptop_dir a ->\n let a, acc = self#toplevel_directive a acc in\n (Ptop_dir a, acc)\n\n method toplevel_directive\n : toplevel_directive -> 'acc -> toplevel_directive * 'acc =\n fun { pdir_name; pdir_arg; pdir_loc } acc ->\n let pdir_name, acc = self#loc self#string pdir_name acc in\n let pdir_arg, acc = self#option self#directive_argument pdir_arg acc in\n let pdir_loc, acc = self#location pdir_loc acc in\n ({ pdir_name; pdir_arg; pdir_loc }, acc)\n\n method directive_argument\n : directive_argument -> 'acc -> directive_argument * 'acc =\n fun { pdira_desc; pdira_loc } acc ->\n let pdira_desc, acc = self#directive_argument_desc pdira_desc acc in\n let pdira_loc, acc = self#location pdira_loc acc in\n ({ pdira_desc; pdira_loc }, acc)\n\n method directive_argument_desc\n : directive_argument_desc -> 'acc -> directive_argument_desc * 'acc =\n fun x acc ->\n match x with\n | Pdir_string a ->\n let a, acc = self#string a acc in\n (Pdir_string a, acc)\n | Pdir_int (a, b) ->\n let a, acc = self#string a acc in\n let b, acc = self#option self#char b acc in\n (Pdir_int (a, b), acc)\n | Pdir_ident a ->\n let a, acc = self#longident a acc in\n (Pdir_ident a, acc)\n | Pdir_bool a ->\n let a, acc = self#bool a acc in\n (Pdir_bool a, acc)\n\n method cases : cases -> 'acc -> cases * 'acc = self#list self#case\n end\n\nclass virtual ['ctx] map_with_context =\n object (self)\n method virtual bool : 'ctx -> bool -> bool\n method virtual char : 'ctx -> char -> char\n method virtual int : 'ctx -> int -> int\n method virtual list : 'a. ('ctx -> 'a -> 'a) -> 'ctx -> 'a list -> 'a list\n\n method virtual option\n : 'a. ('ctx -> 'a -> 'a) -> 'ctx -> 'a option -> 'a option\n\n method virtual string : 'ctx -> string -> string\n\n method position : 'ctx -> position -> position =\n fun ctx { pos_fname; pos_lnum; pos_bol; pos_cnum } ->\n let pos_fname = self#string ctx pos_fname in\n let pos_lnum = self#int ctx pos_lnum in\n let pos_bol = self#int ctx pos_bol in\n let pos_cnum = self#int ctx pos_cnum in\n { pos_fname; pos_lnum; pos_bol; pos_cnum }\n\n method location : 'ctx -> location -> location =\n fun ctx { loc_start; loc_end; loc_ghost } ->\n let loc_start = self#position ctx loc_start in\n let loc_end = self#position ctx loc_end in\n let loc_ghost = self#bool ctx loc_ghost in\n { loc_start; loc_end; loc_ghost }\n\n method location_stack : 'ctx -> location_stack -> location_stack =\n self#list self#location\n\n method loc : 'a. ('ctx -> 'a -> 'a) -> 'ctx -> 'a loc -> 'a loc =\n fun _a ctx { txt; loc } ->\n let txt = _a ctx txt in\n let loc = self#location ctx loc in\n { txt; loc }\n\n method longident : 'ctx -> longident -> longident =\n fun ctx x ->\n match x with\n | Lident a ->\n let a = self#string ctx a in\n Lident a\n | Ldot (a, b) ->\n let a = self#longident ctx a in\n let b = self#string ctx b in\n Ldot (a, b)\n | Lapply (a, b) ->\n let a = self#longident ctx a in\n let b = self#longident ctx b in\n Lapply (a, b)\n\n method longident_loc : 'ctx -> longident_loc -> longident_loc =\n self#loc self#longident\n\n method rec_flag : 'ctx -> rec_flag -> rec_flag = fun _ctx x -> x\n\n method direction_flag : 'ctx -> direction_flag -> direction_flag =\n fun _ctx x -> x\n\n method private_flag : 'ctx -> private_flag -> private_flag = fun _ctx x -> x\n method mutable_flag : 'ctx -> mutable_flag -> mutable_flag = fun _ctx x -> x\n method virtual_flag : 'ctx -> virtual_flag -> virtual_flag = fun _ctx x -> x\n\n method override_flag : 'ctx -> override_flag -> override_flag =\n fun _ctx x -> x\n\n method closed_flag : 'ctx -> closed_flag -> closed_flag = fun _ctx x -> x\n method label : 'ctx -> label -> label = self#string\n\n method arg_label : 'ctx -> arg_label -> arg_label =\n fun ctx x ->\n match x with\n | Nolabel -> Nolabel\n | Labelled a ->\n let a = self#string ctx a in\n Labelled a\n | Optional a ->\n let a = self#string ctx a in\n Optional a\n\n method variance : 'ctx -> variance -> variance = fun _ctx x -> x\n method injectivity : 'ctx -> injectivity -> injectivity = fun _ctx x -> x\n\n method constant : 'ctx -> constant -> constant =\n fun ctx x ->\n match x with\n | Pconst_integer (a, b) ->\n let a = self#string ctx a in\n let b = self#option self#char ctx b in\n Pconst_integer (a, b)\n | Pconst_char a ->\n let a = self#char ctx a in\n Pconst_char a\n | Pconst_string (a, b, c) ->\n let a = self#string ctx a in\n let b = self#location ctx b in\n let c = self#option self#string ctx c in\n Pconst_string (a, b, c)\n | Pconst_float (a, b) ->\n let a = self#string ctx a in\n let b = self#option self#char ctx b in\n Pconst_float (a, b)\n\n method attribute : 'ctx -> attribute -> attribute =\n fun ctx { attr_name; attr_payload; attr_loc } ->\n let attr_name = self#loc self#string ctx attr_name in\n let attr_payload = self#payload ctx attr_payload in\n let attr_loc = self#location ctx attr_loc in\n { attr_name; attr_payload; attr_loc }\n\n method extension : 'ctx -> extension -> extension =\n fun ctx (a, b) ->\n let a = self#loc self#string ctx a in\n let b = self#payload ctx b in\n (a, b)\n\n method attributes : 'ctx -> attributes -> attributes =\n self#list self#attribute\n\n method payload : 'ctx -> payload -> payload =\n fun ctx x ->\n match x with\n | PStr a ->\n let a = self#structure ctx a in\n PStr a\n | PSig a ->\n let a = self#signature ctx a in\n PSig a\n | PTyp a ->\n let a = self#core_type ctx a in\n PTyp a\n | PPat (a, b) ->\n let a = self#pattern ctx a in\n let b = self#option self#expression ctx b in\n PPat (a, b)\n\n method core_type : 'ctx -> core_type -> core_type =\n fun ctx { ptyp_desc; ptyp_loc; ptyp_loc_stack; ptyp_attributes } ->\n let ptyp_desc = self#core_type_desc ctx ptyp_desc in\n let ptyp_loc = self#location ctx ptyp_loc in\n let ptyp_loc_stack = self#location_stack ctx ptyp_loc_stack in\n let ptyp_attributes = self#attributes ctx ptyp_attributes in\n { ptyp_desc; ptyp_loc; ptyp_loc_stack; ptyp_attributes }\n\n method core_type_desc : 'ctx -> core_type_desc -> core_type_desc =\n fun ctx x ->\n match x with\n | Ptyp_any -> Ptyp_any\n | Ptyp_var a ->\n let a = self#string ctx a in\n Ptyp_var a\n | Ptyp_arrow (a, b, c) ->\n let a = self#arg_label ctx a in\n let b = self#core_type ctx b in\n let c = self#core_type ctx c in\n Ptyp_arrow (a, b, c)\n | Ptyp_tuple a ->\n let a = self#list self#core_type ctx a in\n Ptyp_tuple a\n | Ptyp_constr (a, b) ->\n let a = self#longident_loc ctx a in\n let b = self#list self#core_type ctx b in\n Ptyp_constr (a, b)\n | Ptyp_object (a, b) ->\n let a = self#list self#object_field ctx a in\n let b = self#closed_flag ctx b in\n Ptyp_object (a, b)\n | Ptyp_class (a, b) ->\n let a = self#longident_loc ctx a in\n let b = self#list self#core_type ctx b in\n Ptyp_class (a, b)\n | Ptyp_alias (a, b) ->\n let a = self#core_type ctx a in\n let b = self#string ctx b in\n Ptyp_alias (a, b)\n | Ptyp_variant (a, b, c) ->\n let a = self#list self#row_field ctx a in\n let b = self#closed_flag ctx b in\n let c = self#option (self#list self#label) ctx c in\n Ptyp_variant (a, b, c)\n | Ptyp_poly (a, b) ->\n let a = self#list (self#loc self#string) ctx a in\n let b = self#core_type ctx b in\n Ptyp_poly (a, b)\n | Ptyp_package a ->\n let a = self#package_type ctx a in\n Ptyp_package a\n | Ptyp_extension a ->\n let a = self#extension ctx a in\n Ptyp_extension a\n\n method package_type : 'ctx -> package_type -> package_type =\n fun ctx (a, b) ->\n let a = self#longident_loc ctx a in\n let b =\n self#list\n (fun ctx (a, b) ->\n let a = self#longident_loc ctx a in\n let b = self#core_type ctx b in\n (a, b))\n ctx b\n in\n (a, b)\n\n method row_field : 'ctx -> row_field -> row_field =\n fun ctx { prf_desc; prf_loc; prf_attributes } ->\n let prf_desc = self#row_field_desc ctx prf_desc in\n let prf_loc = self#location ctx prf_loc in\n let prf_attributes = self#attributes ctx prf_attributes in\n { prf_desc; prf_loc; prf_attributes }\n\n method row_field_desc : 'ctx -> row_field_desc -> row_field_desc =\n fun ctx x ->\n match x with\n | Rtag (a, b, c) ->\n let a = self#loc self#label ctx a in\n let b = self#bool ctx b in\n let c = self#list self#core_type ctx c in\n Rtag (a, b, c)\n | Rinherit a ->\n let a = self#core_type ctx a in\n Rinherit a\n\n method object_field : 'ctx -> object_field -> object_field =\n fun ctx { pof_desc; pof_loc; pof_attributes } ->\n let pof_desc = self#object_field_desc ctx pof_desc in\n let pof_loc = self#location ctx pof_loc in\n let pof_attributes = self#attributes ctx pof_attributes in\n { pof_desc; pof_loc; pof_attributes }\n\n method object_field_desc : 'ctx -> object_field_desc -> object_field_desc =\n fun ctx x ->\n match x with\n | Otag (a, b) ->\n let a = self#loc self#label ctx a in\n let b = self#core_type ctx b in\n Otag (a, b)\n | Oinherit a ->\n let a = self#core_type ctx a in\n Oinherit a\n\n method pattern : 'ctx -> pattern -> pattern =\n fun ctx { ppat_desc; ppat_loc; ppat_loc_stack; ppat_attributes } ->\n let ppat_desc = self#pattern_desc ctx ppat_desc in\n let ppat_loc = self#location ctx ppat_loc in\n let ppat_loc_stack = self#location_stack ctx ppat_loc_stack in\n let ppat_attributes = self#attributes ctx ppat_attributes in\n { ppat_desc; ppat_loc; ppat_loc_stack; ppat_attributes }\n\n method pattern_desc : 'ctx -> pattern_desc -> pattern_desc =\n fun ctx x ->\n match x with\n | Ppat_any -> Ppat_any\n | Ppat_var a ->\n let a = self#loc self#string ctx a in\n Ppat_var a\n | Ppat_alias (a, b) ->\n let a = self#pattern ctx a in\n let b = self#loc self#string ctx b in\n Ppat_alias (a, b)\n | Ppat_constant a ->\n let a = self#constant ctx a in\n Ppat_constant a\n | Ppat_interval (a, b) ->\n let a = self#constant ctx a in\n let b = self#constant ctx b in\n Ppat_interval (a, b)\n | Ppat_tuple a ->\n let a = self#list self#pattern ctx a in\n Ppat_tuple a\n | Ppat_construct (a, b) ->\n let a = self#longident_loc ctx a in\n let b = self#option self#pattern ctx b in\n Ppat_construct (a, b)\n | Ppat_variant (a, b) ->\n let a = self#label ctx a in\n let b = self#option self#pattern ctx b in\n Ppat_variant (a, b)\n | Ppat_record (a, b) ->\n let a =\n self#list\n (fun ctx (a, b) ->\n let a = self#longident_loc ctx a in\n let b = self#pattern ctx b in\n (a, b))\n ctx a\n in\n let b = self#closed_flag ctx b in\n Ppat_record (a, b)\n | Ppat_array a ->\n let a = self#list self#pattern ctx a in\n Ppat_array a\n | Ppat_or (a, b) ->\n let a = self#pattern ctx a in\n let b = self#pattern ctx b in\n Ppat_or (a, b)\n | Ppat_constraint (a, b) ->\n let a = self#pattern ctx a in\n let b = self#core_type ctx b in\n Ppat_constraint (a, b)\n | Ppat_type a ->\n let a = self#longident_loc ctx a in\n Ppat_type a\n | Ppat_lazy a ->\n let a = self#pattern ctx a in\n Ppat_lazy a\n | Ppat_unpack a ->\n let a = self#loc (self#option self#string) ctx a in\n Ppat_unpack a\n | Ppat_exception a ->\n let a = self#pattern ctx a in\n Ppat_exception a\n | Ppat_extension a ->\n let a = self#extension ctx a in\n Ppat_extension a\n | Ppat_open (a, b) ->\n let a = self#longident_loc ctx a in\n let b = self#pattern ctx b in\n Ppat_open (a, b)\n\n method expression : 'ctx -> expression -> expression =\n fun ctx { pexp_desc; pexp_loc; pexp_loc_stack; pexp_attributes } ->\n let pexp_desc = self#expression_desc ctx pexp_desc in\n let pexp_loc = self#location ctx pexp_loc in\n let pexp_loc_stack = self#location_stack ctx pexp_loc_stack in\n let pexp_attributes = self#attributes ctx pexp_attributes in\n { pexp_desc; pexp_loc; pexp_loc_stack; pexp_attributes }\n\n method expression_desc : 'ctx -> expression_desc -> expression_desc =\n fun ctx x ->\n match x with\n | Pexp_ident a ->\n let a = self#longident_loc ctx a in\n Pexp_ident a\n | Pexp_constant a ->\n let a = self#constant ctx a in\n Pexp_constant a\n | Pexp_let (a, b, c) ->\n let a = self#rec_flag ctx a in\n let b = self#list self#value_binding ctx b in\n let c = self#expression ctx c in\n Pexp_let (a, b, c)\n | Pexp_function a ->\n let a = self#cases ctx a in\n Pexp_function a\n | Pexp_fun (a, b, c, d) ->\n let a = self#arg_label ctx a in\n let b = self#option self#expression ctx b in\n let c = self#pattern ctx c in\n let d = self#expression ctx d in\n Pexp_fun (a, b, c, d)\n | Pexp_apply (a, b) ->\n let a = self#expression ctx a in\n let b =\n self#list\n (fun ctx (a, b) ->\n let a = self#arg_label ctx a in\n let b = self#expression ctx b in\n (a, b))\n ctx b\n in\n Pexp_apply (a, b)\n | Pexp_match (a, b) ->\n let a = self#expression ctx a in\n let b = self#cases ctx b in\n Pexp_match (a, b)\n | Pexp_try (a, b) ->\n let a = self#expression ctx a in\n let b = self#cases ctx b in\n Pexp_try (a, b)\n | Pexp_tuple a ->\n let a = self#list self#expression ctx a in\n Pexp_tuple a\n | Pexp_construct (a, b) ->\n let a = self#longident_loc ctx a in\n let b = self#option self#expression ctx b in\n Pexp_construct (a, b)\n | Pexp_variant (a, b) ->\n let a = self#label ctx a in\n let b = self#option self#expression ctx b in\n Pexp_variant (a, b)\n | Pexp_record (a, b) ->\n let a =\n self#list\n (fun ctx (a, b) ->\n let a = self#longident_loc ctx a in\n let b = self#expression ctx b in\n (a, b))\n ctx a\n in\n let b = self#option self#expression ctx b in\n Pexp_record (a, b)\n | Pexp_field (a, b) ->\n let a = self#expression ctx a in\n let b = self#longident_loc ctx b in\n Pexp_field (a, b)\n | Pexp_setfield (a, b, c) ->\n let a = self#expression ctx a in\n let b = self#longident_loc ctx b in\n let c = self#expression ctx c in\n Pexp_setfield (a, b, c)\n | Pexp_array a ->\n let a = self#list self#expression ctx a in\n Pexp_array a\n | Pexp_ifthenelse (a, b, c) ->\n let a = self#expression ctx a in\n let b = self#expression ctx b in\n let c = self#option self#expression ctx c in\n Pexp_ifthenelse (a, b, c)\n | Pexp_sequence (a, b) ->\n let a = self#expression ctx a in\n let b = self#expression ctx b in\n Pexp_sequence (a, b)\n | Pexp_while (a, b) ->\n let a = self#expression ctx a in\n let b = self#expression ctx b in\n Pexp_while (a, b)\n | Pexp_for (a, b, c, d, e) ->\n let a = self#pattern ctx a in\n let b = self#expression ctx b in\n let c = self#expression ctx c in\n let d = self#direction_flag ctx d in\n let e = self#expression ctx e in\n Pexp_for (a, b, c, d, e)\n | Pexp_constraint (a, b) ->\n let a = self#expression ctx a in\n let b = self#core_type ctx b in\n Pexp_constraint (a, b)\n | Pexp_coerce (a, b, c) ->\n let a = self#expression ctx a in\n let b = self#option self#core_type ctx b in\n let c = self#core_type ctx c in\n Pexp_coerce (a, b, c)\n | Pexp_send (a, b) ->\n let a = self#expression ctx a in\n let b = self#loc self#label ctx b in\n Pexp_send (a, b)\n | Pexp_new a ->\n let a = self#longident_loc ctx a in\n Pexp_new a\n | Pexp_setinstvar (a, b) ->\n let a = self#loc self#label ctx a in\n let b = self#expression ctx b in\n Pexp_setinstvar (a, b)\n | Pexp_override a ->\n let a =\n self#list\n (fun ctx (a, b) ->\n let a = self#loc self#label ctx a in\n let b = self#expression ctx b in\n (a, b))\n ctx a\n in\n Pexp_override a\n | Pexp_letmodule (a, b, c) ->\n let a = self#loc (self#option self#string) ctx a in\n let b = self#module_expr ctx b in\n let c = self#expression ctx c in\n Pexp_letmodule (a, b, c)\n | Pexp_letexception (a, b) ->\n let a = self#extension_constructor ctx a in\n let b = self#expression ctx b in\n Pexp_letexception (a, b)\n | Pexp_assert a ->\n let a = self#expression ctx a in\n Pexp_assert a\n | Pexp_lazy a ->\n let a = self#expression ctx a in\n Pexp_lazy a\n | Pexp_poly (a, b) ->\n let a = self#expression ctx a in\n let b = self#option self#core_type ctx b in\n Pexp_poly (a, b)\n | Pexp_object a ->\n let a = self#class_structure ctx a in\n Pexp_object a\n | Pexp_newtype (a, b) ->\n let a = self#loc self#string ctx a in\n let b = self#expression ctx b in\n Pexp_newtype (a, b)\n | Pexp_pack a ->\n let a = self#module_expr ctx a in\n Pexp_pack a\n | Pexp_open (a, b) ->\n let a = self#open_declaration ctx a in\n let b = self#expression ctx b in\n Pexp_open (a, b)\n | Pexp_letop a ->\n let a = self#letop ctx a in\n Pexp_letop a\n | Pexp_extension a ->\n let a = self#extension ctx a in\n Pexp_extension a\n | Pexp_unreachable -> Pexp_unreachable\n\n method case : 'ctx -> case -> case =\n fun ctx { pc_lhs; pc_guard; pc_rhs } ->\n let pc_lhs = self#pattern ctx pc_lhs in\n let pc_guard = self#option self#expression ctx pc_guard in\n let pc_rhs = self#expression ctx pc_rhs in\n { pc_lhs; pc_guard; pc_rhs }\n\n method letop : 'ctx -> letop -> letop =\n fun ctx { let_; ands; body } ->\n let let_ = self#binding_op ctx let_ in\n let ands = self#list self#binding_op ctx ands in\n let body = self#expression ctx body in\n { let_; ands; body }\n\n method binding_op : 'ctx -> binding_op -> binding_op =\n fun ctx { pbop_op; pbop_pat; pbop_exp; pbop_loc } ->\n let pbop_op = self#loc self#string ctx pbop_op in\n let pbop_pat = self#pattern ctx pbop_pat in\n let pbop_exp = self#expression ctx pbop_exp in\n let pbop_loc = self#location ctx pbop_loc in\n { pbop_op; pbop_pat; pbop_exp; pbop_loc }\n\n method value_description : 'ctx -> value_description -> value_description =\n fun ctx { pval_name; pval_type; pval_prim; pval_attributes; pval_loc } ->\n let pval_name = self#loc self#string ctx pval_name in\n let pval_type = self#core_type ctx pval_type in\n let pval_prim = self#list self#string ctx pval_prim in\n let pval_attributes = self#attributes ctx pval_attributes in\n let pval_loc = self#location ctx pval_loc in\n { pval_name; pval_type; pval_prim; pval_attributes; pval_loc }\n\n method type_declaration : 'ctx -> type_declaration -> type_declaration =\n fun ctx\n {\n ptype_name;\n ptype_params;\n ptype_cstrs;\n ptype_kind;\n ptype_private;\n ptype_manifest;\n ptype_attributes;\n ptype_loc;\n } ->\n let ptype_name = self#loc self#string ctx ptype_name in\n let ptype_params =\n self#list\n (fun ctx (a, b) ->\n let a = self#core_type ctx a in\n let b =\n (fun ctx (a, b) ->\n let a = self#variance ctx a in\n let b = self#injectivity ctx b in\n (a, b))\n ctx b\n in\n (a, b))\n ctx ptype_params\n in\n let ptype_cstrs =\n self#list\n (fun ctx (a, b, c) ->\n let a = self#core_type ctx a in\n let b = self#core_type ctx b in\n let c = self#location ctx c in\n (a, b, c))\n ctx ptype_cstrs\n in\n let ptype_kind = self#type_kind ctx ptype_kind in\n let ptype_private = self#private_flag ctx ptype_private in\n let ptype_manifest = self#option self#core_type ctx ptype_manifest in\n let ptype_attributes = self#attributes ctx ptype_attributes in\n let ptype_loc = self#location ctx ptype_loc in\n {\n ptype_name;\n ptype_params;\n ptype_cstrs;\n ptype_kind;\n ptype_private;\n ptype_manifest;\n ptype_attributes;\n ptype_loc;\n }\n\n method type_kind : 'ctx -> type_kind -> type_kind =\n fun ctx x ->\n match x with\n | Ptype_abstract -> Ptype_abstract\n | Ptype_variant a ->\n let a = self#list self#constructor_declaration ctx a in\n Ptype_variant a\n | Ptype_record a ->\n let a = self#list self#label_declaration ctx a in\n Ptype_record a\n | Ptype_open -> Ptype_open\n\n method label_declaration : 'ctx -> label_declaration -> label_declaration =\n fun ctx { pld_name; pld_mutable; pld_type; pld_loc; pld_attributes } ->\n let pld_name = self#loc self#string ctx pld_name in\n let pld_mutable = self#mutable_flag ctx pld_mutable in\n let pld_type = self#core_type ctx pld_type in\n let pld_loc = self#location ctx pld_loc in\n let pld_attributes = self#attributes ctx pld_attributes in\n { pld_name; pld_mutable; pld_type; pld_loc; pld_attributes }\n\n method constructor_declaration\n : 'ctx -> constructor_declaration -> constructor_declaration =\n fun ctx { pcd_name; pcd_args; pcd_res; pcd_loc; pcd_attributes } ->\n let pcd_name = self#loc self#string ctx pcd_name in\n let pcd_args = self#constructor_arguments ctx pcd_args in\n let pcd_res = self#option self#core_type ctx pcd_res in\n let pcd_loc = self#location ctx pcd_loc in\n let pcd_attributes = self#attributes ctx pcd_attributes in\n { pcd_name; pcd_args; pcd_res; pcd_loc; pcd_attributes }\n\n method constructor_arguments\n : 'ctx -> constructor_arguments -> constructor_arguments =\n fun ctx x ->\n match x with\n | Pcstr_tuple a ->\n let a = self#list self#core_type ctx a in\n Pcstr_tuple a\n | Pcstr_record a ->\n let a = self#list self#label_declaration ctx a in\n Pcstr_record a\n\n method type_extension : 'ctx -> type_extension -> type_extension =\n fun ctx\n {\n ptyext_path;\n ptyext_params;\n ptyext_constructors;\n ptyext_private;\n ptyext_loc;\n ptyext_attributes;\n } ->\n let ptyext_path = self#longident_loc ctx ptyext_path in\n let ptyext_params =\n self#list\n (fun ctx (a, b) ->\n let a = self#core_type ctx a in\n let b =\n (fun ctx (a, b) ->\n let a = self#variance ctx a in\n let b = self#injectivity ctx b in\n (a, b))\n ctx b\n in\n (a, b))\n ctx ptyext_params\n in\n let ptyext_constructors =\n self#list self#extension_constructor ctx ptyext_constructors\n in\n let ptyext_private = self#private_flag ctx ptyext_private in\n let ptyext_loc = self#location ctx ptyext_loc in\n let ptyext_attributes = self#attributes ctx ptyext_attributes in\n {\n ptyext_path;\n ptyext_params;\n ptyext_constructors;\n ptyext_private;\n ptyext_loc;\n ptyext_attributes;\n }\n\n method extension_constructor\n : 'ctx -> extension_constructor -> extension_constructor =\n fun ctx { pext_name; pext_kind; pext_loc; pext_attributes } ->\n let pext_name = self#loc self#string ctx pext_name in\n let pext_kind = self#extension_constructor_kind ctx pext_kind in\n let pext_loc = self#location ctx pext_loc in\n let pext_attributes = self#attributes ctx pext_attributes in\n { pext_name; pext_kind; pext_loc; pext_attributes }\n\n method type_exception : 'ctx -> type_exception -> type_exception =\n fun ctx { ptyexn_constructor; ptyexn_loc; ptyexn_attributes } ->\n let ptyexn_constructor =\n self#extension_constructor ctx ptyexn_constructor\n in\n let ptyexn_loc = self#location ctx ptyexn_loc in\n let ptyexn_attributes = self#attributes ctx ptyexn_attributes in\n { ptyexn_constructor; ptyexn_loc; ptyexn_attributes }\n\n method extension_constructor_kind\n : 'ctx -> extension_constructor_kind -> extension_constructor_kind =\n fun ctx x ->\n match x with\n | Pext_decl (a, b) ->\n let a = self#constructor_arguments ctx a in\n let b = self#option self#core_type ctx b in\n Pext_decl (a, b)\n | Pext_rebind a ->\n let a = self#longident_loc ctx a in\n Pext_rebind a\n\n method class_type : 'ctx -> class_type -> class_type =\n fun ctx { pcty_desc; pcty_loc; pcty_attributes } ->\n let pcty_desc = self#class_type_desc ctx pcty_desc in\n let pcty_loc = self#location ctx pcty_loc in\n let pcty_attributes = self#attributes ctx pcty_attributes in\n { pcty_desc; pcty_loc; pcty_attributes }\n\n method class_type_desc : 'ctx -> class_type_desc -> class_type_desc =\n fun ctx x ->\n match x with\n | Pcty_constr (a, b) ->\n let a = self#longident_loc ctx a in\n let b = self#list self#core_type ctx b in\n Pcty_constr (a, b)\n | Pcty_signature a ->\n let a = self#class_signature ctx a in\n Pcty_signature a\n | Pcty_arrow (a, b, c) ->\n let a = self#arg_label ctx a in\n let b = self#core_type ctx b in\n let c = self#class_type ctx c in\n Pcty_arrow (a, b, c)\n | Pcty_extension a ->\n let a = self#extension ctx a in\n Pcty_extension a\n | Pcty_open (a, b) ->\n let a = self#open_description ctx a in\n let b = self#class_type ctx b in\n Pcty_open (a, b)\n\n method class_signature : 'ctx -> class_signature -> class_signature =\n fun ctx { pcsig_self; pcsig_fields } ->\n let pcsig_self = self#core_type ctx pcsig_self in\n let pcsig_fields = self#list self#class_type_field ctx pcsig_fields in\n { pcsig_self; pcsig_fields }\n\n method class_type_field : 'ctx -> class_type_field -> class_type_field =\n fun ctx { pctf_desc; pctf_loc; pctf_attributes } ->\n let pctf_desc = self#class_type_field_desc ctx pctf_desc in\n let pctf_loc = self#location ctx pctf_loc in\n let pctf_attributes = self#attributes ctx pctf_attributes in\n { pctf_desc; pctf_loc; pctf_attributes }\n\n method class_type_field_desc\n : 'ctx -> class_type_field_desc -> class_type_field_desc =\n fun ctx x ->\n match x with\n | Pctf_inherit a ->\n let a = self#class_type ctx a in\n Pctf_inherit a\n | Pctf_val a ->\n let a =\n (fun ctx (a, b, c, d) ->\n let a = self#loc self#label ctx a in\n let b = self#mutable_flag ctx b in\n let c = self#virtual_flag ctx c in\n let d = self#core_type ctx d in\n (a, b, c, d))\n ctx a\n in\n Pctf_val a\n | Pctf_method a ->\n let a =\n (fun ctx (a, b, c, d) ->\n let a = self#loc self#label ctx a in\n let b = self#private_flag ctx b in\n let c = self#virtual_flag ctx c in\n let d = self#core_type ctx d in\n (a, b, c, d))\n ctx a\n in\n Pctf_method a\n | Pctf_constraint a ->\n let a =\n (fun ctx (a, b) ->\n let a = self#core_type ctx a in\n let b = self#core_type ctx b in\n (a, b))\n ctx a\n in\n Pctf_constraint a\n | Pctf_attribute a ->\n let a = self#attribute ctx a in\n Pctf_attribute a\n | Pctf_extension a ->\n let a = self#extension ctx a in\n Pctf_extension a\n\n method class_infos\n : 'a. ('ctx -> 'a -> 'a) -> 'ctx -> 'a class_infos -> 'a class_infos =\n fun _a ctx\n { pci_virt; pci_params; pci_name; pci_expr; pci_loc; pci_attributes } ->\n let pci_virt = self#virtual_flag ctx pci_virt in\n let pci_params =\n self#list\n (fun ctx (a, b) ->\n let a = self#core_type ctx a in\n let b =\n (fun ctx (a, b) ->\n let a = self#variance ctx a in\n let b = self#injectivity ctx b in\n (a, b))\n ctx b\n in\n (a, b))\n ctx pci_params\n in\n let pci_name = self#loc self#string ctx pci_name in\n let pci_expr = _a ctx pci_expr in\n let pci_loc = self#location ctx pci_loc in\n let pci_attributes = self#attributes ctx pci_attributes in\n { pci_virt; pci_params; pci_name; pci_expr; pci_loc; pci_attributes }\n\n method class_description : 'ctx -> class_description -> class_description =\n self#class_infos self#class_type\n\n method class_type_declaration\n : 'ctx -> class_type_declaration -> class_type_declaration =\n self#class_infos self#class_type\n\n method class_expr : 'ctx -> class_expr -> class_expr =\n fun ctx { pcl_desc; pcl_loc; pcl_attributes } ->\n let pcl_desc = self#class_expr_desc ctx pcl_desc in\n let pcl_loc = self#location ctx pcl_loc in\n let pcl_attributes = self#attributes ctx pcl_attributes in\n { pcl_desc; pcl_loc; pcl_attributes }\n\n method class_expr_desc : 'ctx -> class_expr_desc -> class_expr_desc =\n fun ctx x ->\n match x with\n | Pcl_constr (a, b) ->\n let a = self#longident_loc ctx a in\n let b = self#list self#core_type ctx b in\n Pcl_constr (a, b)\n | Pcl_structure a ->\n let a = self#class_structure ctx a in\n Pcl_structure a\n | Pcl_fun (a, b, c, d) ->\n let a = self#arg_label ctx a in\n let b = self#option self#expression ctx b in\n let c = self#pattern ctx c in\n let d = self#class_expr ctx d in\n Pcl_fun (a, b, c, d)\n | Pcl_apply (a, b) ->\n let a = self#class_expr ctx a in\n let b =\n self#list\n (fun ctx (a, b) ->\n let a = self#arg_label ctx a in\n let b = self#expression ctx b in\n (a, b))\n ctx b\n in\n Pcl_apply (a, b)\n | Pcl_let (a, b, c) ->\n let a = self#rec_flag ctx a in\n let b = self#list self#value_binding ctx b in\n let c = self#class_expr ctx c in\n Pcl_let (a, b, c)\n | Pcl_constraint (a, b) ->\n let a = self#class_expr ctx a in\n let b = self#class_type ctx b in\n Pcl_constraint (a, b)\n | Pcl_extension a ->\n let a = self#extension ctx a in\n Pcl_extension a\n | Pcl_open (a, b) ->\n let a = self#open_description ctx a in\n let b = self#class_expr ctx b in\n Pcl_open (a, b)\n\n method class_structure : 'ctx -> class_structure -> class_structure =\n fun ctx { pcstr_self; pcstr_fields } ->\n let pcstr_self = self#pattern ctx pcstr_self in\n let pcstr_fields = self#list self#class_field ctx pcstr_fields in\n { pcstr_self; pcstr_fields }\n\n method class_field : 'ctx -> class_field -> class_field =\n fun ctx { pcf_desc; pcf_loc; pcf_attributes } ->\n let pcf_desc = self#class_field_desc ctx pcf_desc in\n let pcf_loc = self#location ctx pcf_loc in\n let pcf_attributes = self#attributes ctx pcf_attributes in\n { pcf_desc; pcf_loc; pcf_attributes }\n\n method class_field_desc : 'ctx -> class_field_desc -> class_field_desc =\n fun ctx x ->\n match x with\n | Pcf_inherit (a, b, c) ->\n let a = self#override_flag ctx a in\n let b = self#class_expr ctx b in\n let c = self#option (self#loc self#string) ctx c in\n Pcf_inherit (a, b, c)\n | Pcf_val a ->\n let a =\n (fun ctx (a, b, c) ->\n let a = self#loc self#label ctx a in\n let b = self#mutable_flag ctx b in\n let c = self#class_field_kind ctx c in\n (a, b, c))\n ctx a\n in\n Pcf_val a\n | Pcf_method a ->\n let a =\n (fun ctx (a, b, c) ->\n let a = self#loc self#label ctx a in\n let b = self#private_flag ctx b in\n let c = self#class_field_kind ctx c in\n (a, b, c))\n ctx a\n in\n Pcf_method a\n | Pcf_constraint a ->\n let a =\n (fun ctx (a, b) ->\n let a = self#core_type ctx a in\n let b = self#core_type ctx b in\n (a, b))\n ctx a\n in\n Pcf_constraint a\n | Pcf_initializer a ->\n let a = self#expression ctx a in\n Pcf_initializer a\n | Pcf_attribute a ->\n let a = self#attribute ctx a in\n Pcf_attribute a\n | Pcf_extension a ->\n let a = self#extension ctx a in\n Pcf_extension a\n\n method class_field_kind : 'ctx -> class_field_kind -> class_field_kind =\n fun ctx x ->\n match x with\n | Cfk_virtual a ->\n let a = self#core_type ctx a in\n Cfk_virtual a\n | Cfk_concrete (a, b) ->\n let a = self#override_flag ctx a in\n let b = self#expression ctx b in\n Cfk_concrete (a, b)\n\n method class_declaration : 'ctx -> class_declaration -> class_declaration =\n self#class_infos self#class_expr\n\n method module_type : 'ctx -> module_type -> module_type =\n fun ctx { pmty_desc; pmty_loc; pmty_attributes } ->\n let pmty_desc = self#module_type_desc ctx pmty_desc in\n let pmty_loc = self#location ctx pmty_loc in\n let pmty_attributes = self#attributes ctx pmty_attributes in\n { pmty_desc; pmty_loc; pmty_attributes }\n\n method module_type_desc : 'ctx -> module_type_desc -> module_type_desc =\n fun ctx x ->\n match x with\n | Pmty_ident a ->\n let a = self#longident_loc ctx a in\n Pmty_ident a\n | Pmty_signature a ->\n let a = self#signature ctx a in\n Pmty_signature a\n | Pmty_functor (a, b) ->\n let a = self#functor_parameter ctx a in\n let b = self#module_type ctx b in\n Pmty_functor (a, b)\n | Pmty_with (a, b) ->\n let a = self#module_type ctx a in\n let b = self#list self#with_constraint ctx b in\n Pmty_with (a, b)\n | Pmty_typeof a ->\n let a = self#module_expr ctx a in\n Pmty_typeof a\n | Pmty_extension a ->\n let a = self#extension ctx a in\n Pmty_extension a\n | Pmty_alias a ->\n let a = self#longident_loc ctx a in\n Pmty_alias a\n\n method functor_parameter : 'ctx -> functor_parameter -> functor_parameter =\n fun ctx x ->\n match x with\n | Unit -> Unit\n | Named (a, b) ->\n let a = self#loc (self#option self#string) ctx a in\n let b = self#module_type ctx b in\n Named (a, b)\n\n method signature : 'ctx -> signature -> signature =\n self#list self#signature_item\n\n method signature_item : 'ctx -> signature_item -> signature_item =\n fun ctx { psig_desc; psig_loc } ->\n let psig_desc = self#signature_item_desc ctx psig_desc in\n let psig_loc = self#location ctx psig_loc in\n { psig_desc; psig_loc }\n\n method signature_item_desc\n : 'ctx -> signature_item_desc -> signature_item_desc =\n fun ctx x ->\n match x with\n | Psig_value a ->\n let a = self#value_description ctx a in\n Psig_value a\n | Psig_type (a, b) ->\n let a = self#rec_flag ctx a in\n let b = self#list self#type_declaration ctx b in\n Psig_type (a, b)\n | Psig_typesubst a ->\n let a = self#list self#type_declaration ctx a in\n Psig_typesubst a\n | Psig_typext a ->\n let a = self#type_extension ctx a in\n Psig_typext a\n | Psig_exception a ->\n let a = self#type_exception ctx a in\n Psig_exception a\n | Psig_module a ->\n let a = self#module_declaration ctx a in\n Psig_module a\n | Psig_modsubst a ->\n let a = self#module_substitution ctx a in\n Psig_modsubst a\n | Psig_recmodule a ->\n let a = self#list self#module_declaration ctx a in\n Psig_recmodule a\n | Psig_modtype a ->\n let a = self#module_type_declaration ctx a in\n Psig_modtype a\n | Psig_open a ->\n let a = self#open_description ctx a in\n Psig_open a\n | Psig_include a ->\n let a = self#include_description ctx a in\n Psig_include a\n | Psig_class a ->\n let a = self#list self#class_description ctx a in\n Psig_class a\n | Psig_class_type a ->\n let a = self#list self#class_type_declaration ctx a in\n Psig_class_type a\n | Psig_attribute a ->\n let a = self#attribute ctx a in\n Psig_attribute a\n | Psig_extension (a, b) ->\n let a = self#extension ctx a in\n let b = self#attributes ctx b in\n Psig_extension (a, b)\n\n method module_declaration : 'ctx -> module_declaration -> module_declaration\n =\n fun ctx { pmd_name; pmd_type; pmd_attributes; pmd_loc } ->\n let pmd_name = self#loc (self#option self#string) ctx pmd_name in\n let pmd_type = self#module_type ctx pmd_type in\n let pmd_attributes = self#attributes ctx pmd_attributes in\n let pmd_loc = self#location ctx pmd_loc in\n { pmd_name; pmd_type; pmd_attributes; pmd_loc }\n\n method module_substitution\n : 'ctx -> module_substitution -> module_substitution =\n fun ctx { pms_name; pms_manifest; pms_attributes; pms_loc } ->\n let pms_name = self#loc self#string ctx pms_name in\n let pms_manifest = self#longident_loc ctx pms_manifest in\n let pms_attributes = self#attributes ctx pms_attributes in\n let pms_loc = self#location ctx pms_loc in\n { pms_name; pms_manifest; pms_attributes; pms_loc }\n\n method module_type_declaration\n : 'ctx -> module_type_declaration -> module_type_declaration =\n fun ctx { pmtd_name; pmtd_type; pmtd_attributes; pmtd_loc } ->\n let pmtd_name = self#loc self#string ctx pmtd_name in\n let pmtd_type = self#option self#module_type ctx pmtd_type in\n let pmtd_attributes = self#attributes ctx pmtd_attributes in\n let pmtd_loc = self#location ctx pmtd_loc in\n { pmtd_name; pmtd_type; pmtd_attributes; pmtd_loc }\n\n method open_infos\n : 'a. ('ctx -> 'a -> 'a) -> 'ctx -> 'a open_infos -> 'a open_infos =\n fun _a ctx { popen_expr; popen_override; popen_loc; popen_attributes } ->\n let popen_expr = _a ctx popen_expr in\n let popen_override = self#override_flag ctx popen_override in\n let popen_loc = self#location ctx popen_loc in\n let popen_attributes = self#attributes ctx popen_attributes in\n { popen_expr; popen_override; popen_loc; popen_attributes }\n\n method open_description : 'ctx -> open_description -> open_description =\n self#open_infos self#longident_loc\n\n method open_declaration : 'ctx -> open_declaration -> open_declaration =\n self#open_infos self#module_expr\n\n method include_infos\n : 'a. ('ctx -> 'a -> 'a) -> 'ctx -> 'a include_infos -> 'a include_infos\n =\n fun _a ctx { pincl_mod; pincl_loc; pincl_attributes } ->\n let pincl_mod = _a ctx pincl_mod in\n let pincl_loc = self#location ctx pincl_loc in\n let pincl_attributes = self#attributes ctx pincl_attributes in\n { pincl_mod; pincl_loc; pincl_attributes }\n\n method include_description\n : 'ctx -> include_description -> include_description =\n self#include_infos self#module_type\n\n method include_declaration\n : 'ctx -> include_declaration -> include_declaration =\n self#include_infos self#module_expr\n\n method with_constraint : 'ctx -> with_constraint -> with_constraint =\n fun ctx x ->\n match x with\n | Pwith_type (a, b) ->\n let a = self#longident_loc ctx a in\n let b = self#type_declaration ctx b in\n Pwith_type (a, b)\n | Pwith_module (a, b) ->\n let a = self#longident_loc ctx a in\n let b = self#longident_loc ctx b in\n Pwith_module (a, b)\n | Pwith_typesubst (a, b) ->\n let a = self#longident_loc ctx a in\n let b = self#type_declaration ctx b in\n Pwith_typesubst (a, b)\n | Pwith_modsubst (a, b) ->\n let a = self#longident_loc ctx a in\n let b = self#longident_loc ctx b in\n Pwith_modsubst (a, b)\n\n method module_expr : 'ctx -> module_expr -> module_expr =\n fun ctx { pmod_desc; pmod_loc; pmod_attributes } ->\n let pmod_desc = self#module_expr_desc ctx pmod_desc in\n let pmod_loc = self#location ctx pmod_loc in\n let pmod_attributes = self#attributes ctx pmod_attributes in\n { pmod_desc; pmod_loc; pmod_attributes }\n\n method module_expr_desc : 'ctx -> module_expr_desc -> module_expr_desc =\n fun ctx x ->\n match x with\n | Pmod_ident a ->\n let a = self#longident_loc ctx a in\n Pmod_ident a\n | Pmod_structure a ->\n let a = self#structure ctx a in\n Pmod_structure a\n | Pmod_functor (a, b) ->\n let a = self#functor_parameter ctx a in\n let b = self#module_expr ctx b in\n Pmod_functor (a, b)\n | Pmod_apply (a, b) ->\n let a = self#module_expr ctx a in\n let b = self#module_expr ctx b in\n Pmod_apply (a, b)\n | Pmod_constraint (a, b) ->\n let a = self#module_expr ctx a in\n let b = self#module_type ctx b in\n Pmod_constraint (a, b)\n | Pmod_unpack a ->\n let a = self#expression ctx a in\n Pmod_unpack a\n | Pmod_extension a ->\n let a = self#extension ctx a in\n Pmod_extension a\n\n method structure : 'ctx -> structure -> structure =\n self#list self#structure_item\n\n method structure_item : 'ctx -> structure_item -> structure_item =\n fun ctx { pstr_desc; pstr_loc } ->\n let pstr_desc = self#structure_item_desc ctx pstr_desc in\n let pstr_loc = self#location ctx pstr_loc in\n { pstr_desc; pstr_loc }\n\n method structure_item_desc\n : 'ctx -> structure_item_desc -> structure_item_desc =\n fun ctx x ->\n match x with\n | Pstr_eval (a, b) ->\n let a = self#expression ctx a in\n let b = self#attributes ctx b in\n Pstr_eval (a, b)\n | Pstr_value (a, b) ->\n let a = self#rec_flag ctx a in\n let b = self#list self#value_binding ctx b in\n Pstr_value (a, b)\n | Pstr_primitive a ->\n let a = self#value_description ctx a in\n Pstr_primitive a\n | Pstr_type (a, b) ->\n let a = self#rec_flag ctx a in\n let b = self#list self#type_declaration ctx b in\n Pstr_type (a, b)\n | Pstr_typext a ->\n let a = self#type_extension ctx a in\n Pstr_typext a\n | Pstr_exception a ->\n let a = self#type_exception ctx a in\n Pstr_exception a\n | Pstr_module a ->\n let a = self#module_binding ctx a in\n Pstr_module a\n | Pstr_recmodule a ->\n let a = self#list self#module_binding ctx a in\n Pstr_recmodule a\n | Pstr_modtype a ->\n let a = self#module_type_declaration ctx a in\n Pstr_modtype a\n | Pstr_open a ->\n let a = self#open_declaration ctx a in\n Pstr_open a\n | Pstr_class a ->\n let a = self#list self#class_declaration ctx a in\n Pstr_class a\n | Pstr_class_type a ->\n let a = self#list self#class_type_declaration ctx a in\n Pstr_class_type a\n | Pstr_include a ->\n let a = self#include_declaration ctx a in\n Pstr_include a\n | Pstr_attribute a ->\n let a = self#attribute ctx a in\n Pstr_attribute a\n | Pstr_extension (a, b) ->\n let a = self#extension ctx a in\n let b = self#attributes ctx b in\n Pstr_extension (a, b)\n\n method value_binding : 'ctx -> value_binding -> value_binding =\n fun ctx { pvb_pat; pvb_expr; pvb_attributes; pvb_loc } ->\n let pvb_pat = self#pattern ctx pvb_pat in\n let pvb_expr = self#expression ctx pvb_expr in\n let pvb_attributes = self#attributes ctx pvb_attributes in\n let pvb_loc = self#location ctx pvb_loc in\n { pvb_pat; pvb_expr; pvb_attributes; pvb_loc }\n\n method module_binding : 'ctx -> module_binding -> module_binding =\n fun ctx { pmb_name; pmb_expr; pmb_attributes; pmb_loc } ->\n let pmb_name = self#loc (self#option self#string) ctx pmb_name in\n let pmb_expr = self#module_expr ctx pmb_expr in\n let pmb_attributes = self#attributes ctx pmb_attributes in\n let pmb_loc = self#location ctx pmb_loc in\n { pmb_name; pmb_expr; pmb_attributes; pmb_loc }\n\n method toplevel_phrase : 'ctx -> toplevel_phrase -> toplevel_phrase =\n fun ctx x ->\n match x with\n | Ptop_def a ->\n let a = self#structure ctx a in\n Ptop_def a\n | Ptop_dir a ->\n let a = self#toplevel_directive ctx a in\n Ptop_dir a\n\n method toplevel_directive : 'ctx -> toplevel_directive -> toplevel_directive\n =\n fun ctx { pdir_name; pdir_arg; pdir_loc } ->\n let pdir_name = self#loc self#string ctx pdir_name in\n let pdir_arg = self#option self#directive_argument ctx pdir_arg in\n let pdir_loc = self#location ctx pdir_loc in\n { pdir_name; pdir_arg; pdir_loc }\n\n method directive_argument : 'ctx -> directive_argument -> directive_argument\n =\n fun ctx { pdira_desc; pdira_loc } ->\n let pdira_desc = self#directive_argument_desc ctx pdira_desc in\n let pdira_loc = self#location ctx pdira_loc in\n { pdira_desc; pdira_loc }\n\n method directive_argument_desc\n : 'ctx -> directive_argument_desc -> directive_argument_desc =\n fun ctx x ->\n match x with\n | Pdir_string a ->\n let a = self#string ctx a in\n Pdir_string a\n | Pdir_int (a, b) ->\n let a = self#string ctx a in\n let b = self#option self#char ctx b in\n Pdir_int (a, b)\n | Pdir_ident a ->\n let a = self#longident ctx a in\n Pdir_ident a\n | Pdir_bool a ->\n let a = self#bool ctx a in\n Pdir_bool a\n\n method cases : 'ctx -> cases -> cases = self#list self#case\n end\n\nclass virtual ['res] lift =\n object (self)\n method virtual record : (string * 'res) list -> 'res\n method virtual constr : string -> 'res list -> 'res\n method virtual tuple : 'res list -> 'res\n method virtual bool : bool -> 'res\n method virtual char : char -> 'res\n method virtual int : int -> 'res\n method virtual list : 'a. ('a -> 'res) -> 'a list -> 'res\n method virtual option : 'a. ('a -> 'res) -> 'a option -> 'res\n method virtual string : string -> 'res\n\n method position : position -> 'res =\n fun { pos_fname; pos_lnum; pos_bol; pos_cnum } ->\n let pos_fname = self#string pos_fname in\n let pos_lnum = self#int pos_lnum in\n let pos_bol = self#int pos_bol in\n let pos_cnum = self#int pos_cnum in\n self#record\n [\n (\"pos_fname\", pos_fname);\n (\"pos_lnum\", pos_lnum);\n (\"pos_bol\", pos_bol);\n (\"pos_cnum\", pos_cnum);\n ]\n\n method location : location -> 'res =\n fun { loc_start; loc_end; loc_ghost } ->\n let loc_start = self#position loc_start in\n let loc_end = self#position loc_end in\n let loc_ghost = self#bool loc_ghost in\n self#record\n [\n (\"loc_start\", loc_start);\n (\"loc_end\", loc_end);\n (\"loc_ghost\", loc_ghost);\n ]\n\n method location_stack : location_stack -> 'res = self#list self#location\n\n method loc : 'a. ('a -> 'res) -> 'a loc -> 'res =\n fun _a { txt; loc } ->\n let txt = _a txt in\n let loc = self#location loc in\n self#record [ (\"txt\", txt); (\"loc\", loc) ]\n\n method longident : longident -> 'res =\n fun x ->\n match x with\n | Lident a ->\n let a = self#string a in\n self#constr \"Lident\" [ a ]\n | Ldot (a, b) ->\n let a = self#longident a in\n let b = self#string b in\n self#constr \"Ldot\" [ a; b ]\n | Lapply (a, b) ->\n let a = self#longident a in\n let b = self#longident b in\n self#constr \"Lapply\" [ a; b ]\n\n method longident_loc : longident_loc -> 'res = self#loc self#longident\n\n method rec_flag : rec_flag -> 'res =\n fun x ->\n match x with\n | Nonrecursive -> self#constr \"Nonrecursive\" []\n | Recursive -> self#constr \"Recursive\" []\n\n method direction_flag : direction_flag -> 'res =\n fun x ->\n match x with\n | Upto -> self#constr \"Upto\" []\n | Downto -> self#constr \"Downto\" []\n\n method private_flag : private_flag -> 'res =\n fun x ->\n match x with\n | Private -> self#constr \"Private\" []\n | Public -> self#constr \"Public\" []\n\n method mutable_flag : mutable_flag -> 'res =\n fun x ->\n match x with\n | Immutable -> self#constr \"Immutable\" []\n | Mutable -> self#constr \"Mutable\" []\n\n method virtual_flag : virtual_flag -> 'res =\n fun x ->\n match x with\n | Virtual -> self#constr \"Virtual\" []\n | Concrete -> self#constr \"Concrete\" []\n\n method override_flag : override_flag -> 'res =\n fun x ->\n match x with\n | Override -> self#constr \"Override\" []\n | Fresh -> self#constr \"Fresh\" []\n\n method closed_flag : closed_flag -> 'res =\n fun x ->\n match x with\n | Closed -> self#constr \"Closed\" []\n | Open -> self#constr \"Open\" []\n\n method label : label -> 'res = self#string\n\n method arg_label : arg_label -> 'res =\n fun x ->\n match x with\n | Nolabel -> self#constr \"Nolabel\" []\n | Labelled a ->\n let a = self#string a in\n self#constr \"Labelled\" [ a ]\n | Optional a ->\n let a = self#string a in\n self#constr \"Optional\" [ a ]\n\n method variance : variance -> 'res =\n fun x ->\n match x with\n | Covariant -> self#constr \"Covariant\" []\n | Contravariant -> self#constr \"Contravariant\" []\n | NoVariance -> self#constr \"NoVariance\" []\n\n method injectivity : injectivity -> 'res =\n fun x ->\n match x with\n | Injective -> self#constr \"Injective\" []\n | NoInjectivity -> self#constr \"NoInjectivity\" []\n\n method constant : constant -> 'res =\n fun x ->\n match x with\n | Pconst_integer (a, b) ->\n let a = self#string a in\n let b = self#option self#char b in\n self#constr \"Pconst_integer\" [ a; b ]\n | Pconst_char a ->\n let a = self#char a in\n self#constr \"Pconst_char\" [ a ]\n | Pconst_string (a, b, c) ->\n let a = self#string a in\n let b = self#location b in\n let c = self#option self#string c in\n self#constr \"Pconst_string\" [ a; b; c ]\n | Pconst_float (a, b) ->\n let a = self#string a in\n let b = self#option self#char b in\n self#constr \"Pconst_float\" [ a; b ]\n\n method attribute : attribute -> 'res =\n fun { attr_name; attr_payload; attr_loc } ->\n let attr_name = self#loc self#string attr_name in\n let attr_payload = self#payload attr_payload in\n let attr_loc = self#location attr_loc in\n self#record\n [\n (\"attr_name\", attr_name);\n (\"attr_payload\", attr_payload);\n (\"attr_loc\", attr_loc);\n ]\n\n method extension : extension -> 'res =\n fun (a, b) ->\n let a = self#loc self#string a in\n let b = self#payload b in\n self#tuple [ a; b ]\n\n method attributes : attributes -> 'res = self#list self#attribute\n\n method payload : payload -> 'res =\n fun x ->\n match x with\n | PStr a ->\n let a = self#structure a in\n self#constr \"PStr\" [ a ]\n | PSig a ->\n let a = self#signature a in\n self#constr \"PSig\" [ a ]\n | PTyp a ->\n let a = self#core_type a in\n self#constr \"PTyp\" [ a ]\n | PPat (a, b) ->\n let a = self#pattern a in\n let b = self#option self#expression b in\n self#constr \"PPat\" [ a; b ]\n\n method core_type : core_type -> 'res =\n fun { ptyp_desc; ptyp_loc; ptyp_loc_stack; ptyp_attributes } ->\n let ptyp_desc = self#core_type_desc ptyp_desc in\n let ptyp_loc = self#location ptyp_loc in\n let ptyp_loc_stack = self#location_stack ptyp_loc_stack in\n let ptyp_attributes = self#attributes ptyp_attributes in\n self#record\n [\n (\"ptyp_desc\", ptyp_desc);\n (\"ptyp_loc\", ptyp_loc);\n (\"ptyp_loc_stack\", ptyp_loc_stack);\n (\"ptyp_attributes\", ptyp_attributes);\n ]\n\n method core_type_desc : core_type_desc -> 'res =\n fun x ->\n match x with\n | Ptyp_any -> self#constr \"Ptyp_any\" []\n | Ptyp_var a ->\n let a = self#string a in\n self#constr \"Ptyp_var\" [ a ]\n | Ptyp_arrow (a, b, c) ->\n let a = self#arg_label a in\n let b = self#core_type b in\n let c = self#core_type c in\n self#constr \"Ptyp_arrow\" [ a; b; c ]\n | Ptyp_tuple a ->\n let a = self#list self#core_type a in\n self#constr \"Ptyp_tuple\" [ a ]\n | Ptyp_constr (a, b) ->\n let a = self#longident_loc a in\n let b = self#list self#core_type b in\n self#constr \"Ptyp_constr\" [ a; b ]\n | Ptyp_object (a, b) ->\n let a = self#list self#object_field a in\n let b = self#closed_flag b in\n self#constr \"Ptyp_object\" [ a; b ]\n | Ptyp_class (a, b) ->\n let a = self#longident_loc a in\n let b = self#list self#core_type b in\n self#constr \"Ptyp_class\" [ a; b ]\n | Ptyp_alias (a, b) ->\n let a = self#core_type a in\n let b = self#string b in\n self#constr \"Ptyp_alias\" [ a; b ]\n | Ptyp_variant (a, b, c) ->\n let a = self#list self#row_field a in\n let b = self#closed_flag b in\n let c = self#option (self#list self#label) c in\n self#constr \"Ptyp_variant\" [ a; b; c ]\n | Ptyp_poly (a, b) ->\n let a = self#list (self#loc self#string) a in\n let b = self#core_type b in\n self#constr \"Ptyp_poly\" [ a; b ]\n | Ptyp_package a ->\n let a = self#package_type a in\n self#constr \"Ptyp_package\" [ a ]\n | Ptyp_extension a ->\n let a = self#extension a in\n self#constr \"Ptyp_extension\" [ a ]\n\n method package_type : package_type -> 'res =\n fun (a, b) ->\n let a = self#longident_loc a in\n let b =\n self#list\n (fun (a, b) ->\n let a = self#longident_loc a in\n let b = self#core_type b in\n self#tuple [ a; b ])\n b\n in\n self#tuple [ a; b ]\n\n method row_field : row_field -> 'res =\n fun { prf_desc; prf_loc; prf_attributes } ->\n let prf_desc = self#row_field_desc prf_desc in\n let prf_loc = self#location prf_loc in\n let prf_attributes = self#attributes prf_attributes in\n self#record\n [\n (\"prf_desc\", prf_desc);\n (\"prf_loc\", prf_loc);\n (\"prf_attributes\", prf_attributes);\n ]\n\n method row_field_desc : row_field_desc -> 'res =\n fun x ->\n match x with\n | Rtag (a, b, c) ->\n let a = self#loc self#label a in\n let b = self#bool b in\n let c = self#list self#core_type c in\n self#constr \"Rtag\" [ a; b; c ]\n | Rinherit a ->\n let a = self#core_type a in\n self#constr \"Rinherit\" [ a ]\n\n method object_field : object_field -> 'res =\n fun { pof_desc; pof_loc; pof_attributes } ->\n let pof_desc = self#object_field_desc pof_desc in\n let pof_loc = self#location pof_loc in\n let pof_attributes = self#attributes pof_attributes in\n self#record\n [\n (\"pof_desc\", pof_desc);\n (\"pof_loc\", pof_loc);\n (\"pof_attributes\", pof_attributes);\n ]\n\n method object_field_desc : object_field_desc -> 'res =\n fun x ->\n match x with\n | Otag (a, b) ->\n let a = self#loc self#label a in\n let b = self#core_type b in\n self#constr \"Otag\" [ a; b ]\n | Oinherit a ->\n let a = self#core_type a in\n self#constr \"Oinherit\" [ a ]\n\n method pattern : pattern -> 'res =\n fun { ppat_desc; ppat_loc; ppat_loc_stack; ppat_attributes } ->\n let ppat_desc = self#pattern_desc ppat_desc in\n let ppat_loc = self#location ppat_loc in\n let ppat_loc_stack = self#location_stack ppat_loc_stack in\n let ppat_attributes = self#attributes ppat_attributes in\n self#record\n [\n (\"ppat_desc\", ppat_desc);\n (\"ppat_loc\", ppat_loc);\n (\"ppat_loc_stack\", ppat_loc_stack);\n (\"ppat_attributes\", ppat_attributes);\n ]\n\n method pattern_desc : pattern_desc -> 'res =\n fun x ->\n match x with\n | Ppat_any -> self#constr \"Ppat_any\" []\n | Ppat_var a ->\n let a = self#loc self#string a in\n self#constr \"Ppat_var\" [ a ]\n | Ppat_alias (a, b) ->\n let a = self#pattern a in\n let b = self#loc self#string b in\n self#constr \"Ppat_alias\" [ a; b ]\n | Ppat_constant a ->\n let a = self#constant a in\n self#constr \"Ppat_constant\" [ a ]\n | Ppat_interval (a, b) ->\n let a = self#constant a in\n let b = self#constant b in\n self#constr \"Ppat_interval\" [ a; b ]\n | Ppat_tuple a ->\n let a = self#list self#pattern a in\n self#constr \"Ppat_tuple\" [ a ]\n | Ppat_construct (a, b) ->\n let a = self#longident_loc a in\n let b = self#option self#pattern b in\n self#constr \"Ppat_construct\" [ a; b ]\n | Ppat_variant (a, b) ->\n let a = self#label a in\n let b = self#option self#pattern b in\n self#constr \"Ppat_variant\" [ a; b ]\n | Ppat_record (a, b) ->\n let a =\n self#list\n (fun (a, b) ->\n let a = self#longident_loc a in\n let b = self#pattern b in\n self#tuple [ a; b ])\n a\n in\n let b = self#closed_flag b in\n self#constr \"Ppat_record\" [ a; b ]\n | Ppat_array a ->\n let a = self#list self#pattern a in\n self#constr \"Ppat_array\" [ a ]\n | Ppat_or (a, b) ->\n let a = self#pattern a in\n let b = self#pattern b in\n self#constr \"Ppat_or\" [ a; b ]\n | Ppat_constraint (a, b) ->\n let a = self#pattern a in\n let b = self#core_type b in\n self#constr \"Ppat_constraint\" [ a; b ]\n | Ppat_type a ->\n let a = self#longident_loc a in\n self#constr \"Ppat_type\" [ a ]\n | Ppat_lazy a ->\n let a = self#pattern a in\n self#constr \"Ppat_lazy\" [ a ]\n | Ppat_unpack a ->\n let a = self#loc (self#option self#string) a in\n self#constr \"Ppat_unpack\" [ a ]\n | Ppat_exception a ->\n let a = self#pattern a in\n self#constr \"Ppat_exception\" [ a ]\n | Ppat_extension a ->\n let a = self#extension a in\n self#constr \"Ppat_extension\" [ a ]\n | Ppat_open (a, b) ->\n let a = self#longident_loc a in\n let b = self#pattern b in\n self#constr \"Ppat_open\" [ a; b ]\n\n method expression : expression -> 'res =\n fun { pexp_desc; pexp_loc; pexp_loc_stack; pexp_attributes } ->\n let pexp_desc = self#expression_desc pexp_desc in\n let pexp_loc = self#location pexp_loc in\n let pexp_loc_stack = self#location_stack pexp_loc_stack in\n let pexp_attributes = self#attributes pexp_attributes in\n self#record\n [\n (\"pexp_desc\", pexp_desc);\n (\"pexp_loc\", pexp_loc);\n (\"pexp_loc_stack\", pexp_loc_stack);\n (\"pexp_attributes\", pexp_attributes);\n ]\n\n method expression_desc : expression_desc -> 'res =\n fun x ->\n match x with\n | Pexp_ident a ->\n let a = self#longident_loc a in\n self#constr \"Pexp_ident\" [ a ]\n | Pexp_constant a ->\n let a = self#constant a in\n self#constr \"Pexp_constant\" [ a ]\n | Pexp_let (a, b, c) ->\n let a = self#rec_flag a in\n let b = self#list self#value_binding b in\n let c = self#expression c in\n self#constr \"Pexp_let\" [ a; b; c ]\n | Pexp_function a ->\n let a = self#cases a in\n self#constr \"Pexp_function\" [ a ]\n | Pexp_fun (a, b, c, d) ->\n let a = self#arg_label a in\n let b = self#option self#expression b in\n let c = self#pattern c in\n let d = self#expression d in\n self#constr \"Pexp_fun\" [ a; b; c; d ]\n | Pexp_apply (a, b) ->\n let a = self#expression a in\n let b =\n self#list\n (fun (a, b) ->\n let a = self#arg_label a in\n let b = self#expression b in\n self#tuple [ a; b ])\n b\n in\n self#constr \"Pexp_apply\" [ a; b ]\n | Pexp_match (a, b) ->\n let a = self#expression a in\n let b = self#cases b in\n self#constr \"Pexp_match\" [ a; b ]\n | Pexp_try (a, b) ->\n let a = self#expression a in\n let b = self#cases b in\n self#constr \"Pexp_try\" [ a; b ]\n | Pexp_tuple a ->\n let a = self#list self#expression a in\n self#constr \"Pexp_tuple\" [ a ]\n | Pexp_construct (a, b) ->\n let a = self#longident_loc a in\n let b = self#option self#expression b in\n self#constr \"Pexp_construct\" [ a; b ]\n | Pexp_variant (a, b) ->\n let a = self#label a in\n let b = self#option self#expression b in\n self#constr \"Pexp_variant\" [ a; b ]\n | Pexp_record (a, b) ->\n let a =\n self#list\n (fun (a, b) ->\n let a = self#longident_loc a in\n let b = self#expression b in\n self#tuple [ a; b ])\n a\n in\n let b = self#option self#expression b in\n self#constr \"Pexp_record\" [ a; b ]\n | Pexp_field (a, b) ->\n let a = self#expression a in\n let b = self#longident_loc b in\n self#constr \"Pexp_field\" [ a; b ]\n | Pexp_setfield (a, b, c) ->\n let a = self#expression a in\n let b = self#longident_loc b in\n let c = self#expression c in\n self#constr \"Pexp_setfield\" [ a; b; c ]\n | Pexp_array a ->\n let a = self#list self#expression a in\n self#constr \"Pexp_array\" [ a ]\n | Pexp_ifthenelse (a, b, c) ->\n let a = self#expression a in\n let b = self#expression b in\n let c = self#option self#expression c in\n self#constr \"Pexp_ifthenelse\" [ a; b; c ]\n | Pexp_sequence (a, b) ->\n let a = self#expression a in\n let b = self#expression b in\n self#constr \"Pexp_sequence\" [ a; b ]\n | Pexp_while (a, b) ->\n let a = self#expression a in\n let b = self#expression b in\n self#constr \"Pexp_while\" [ a; b ]\n | Pexp_for (a, b, c, d, e) ->\n let a = self#pattern a in\n let b = self#expression b in\n let c = self#expression c in\n let d = self#direction_flag d in\n let e = self#expression e in\n self#constr \"Pexp_for\" [ a; b; c; d; e ]\n | Pexp_constraint (a, b) ->\n let a = self#expression a in\n let b = self#core_type b in\n self#constr \"Pexp_constraint\" [ a; b ]\n | Pexp_coerce (a, b, c) ->\n let a = self#expression a in\n let b = self#option self#core_type b in\n let c = self#core_type c in\n self#constr \"Pexp_coerce\" [ a; b; c ]\n | Pexp_send (a, b) ->\n let a = self#expression a in\n let b = self#loc self#label b in\n self#constr \"Pexp_send\" [ a; b ]\n | Pexp_new a ->\n let a = self#longident_loc a in\n self#constr \"Pexp_new\" [ a ]\n | Pexp_setinstvar (a, b) ->\n let a = self#loc self#label a in\n let b = self#expression b in\n self#constr \"Pexp_setinstvar\" [ a; b ]\n | Pexp_override a ->\n let a =\n self#list\n (fun (a, b) ->\n let a = self#loc self#label a in\n let b = self#expression b in\n self#tuple [ a; b ])\n a\n in\n self#constr \"Pexp_override\" [ a ]\n | Pexp_letmodule (a, b, c) ->\n let a = self#loc (self#option self#string) a in\n let b = self#module_expr b in\n let c = self#expression c in\n self#constr \"Pexp_letmodule\" [ a; b; c ]\n | Pexp_letexception (a, b) ->\n let a = self#extension_constructor a in\n let b = self#expression b in\n self#constr \"Pexp_letexception\" [ a; b ]\n | Pexp_assert a ->\n let a = self#expression a in\n self#constr \"Pexp_assert\" [ a ]\n | Pexp_lazy a ->\n let a = self#expression a in\n self#constr \"Pexp_lazy\" [ a ]\n | Pexp_poly (a, b) ->\n let a = self#expression a in\n let b = self#option self#core_type b in\n self#constr \"Pexp_poly\" [ a; b ]\n | Pexp_object a ->\n let a = self#class_structure a in\n self#constr \"Pexp_object\" [ a ]\n | Pexp_newtype (a, b) ->\n let a = self#loc self#string a in\n let b = self#expression b in\n self#constr \"Pexp_newtype\" [ a; b ]\n | Pexp_pack a ->\n let a = self#module_expr a in\n self#constr \"Pexp_pack\" [ a ]\n | Pexp_open (a, b) ->\n let a = self#open_declaration a in\n let b = self#expression b in\n self#constr \"Pexp_open\" [ a; b ]\n | Pexp_letop a ->\n let a = self#letop a in\n self#constr \"Pexp_letop\" [ a ]\n | Pexp_extension a ->\n let a = self#extension a in\n self#constr \"Pexp_extension\" [ a ]\n | Pexp_unreachable -> self#constr \"Pexp_unreachable\" []\n\n method case : case -> 'res =\n fun { pc_lhs; pc_guard; pc_rhs } ->\n let pc_lhs = self#pattern pc_lhs in\n let pc_guard = self#option self#expression pc_guard in\n let pc_rhs = self#expression pc_rhs in\n self#record\n [ (\"pc_lhs\", pc_lhs); (\"pc_guard\", pc_guard); (\"pc_rhs\", pc_rhs) ]\n\n method letop : letop -> 'res =\n fun { let_; ands; body } ->\n let let_ = self#binding_op let_ in\n let ands = self#list self#binding_op ands in\n let body = self#expression body in\n self#record [ (\"let_\", let_); (\"ands\", ands); (\"body\", body) ]\n\n method binding_op : binding_op -> 'res =\n fun { pbop_op; pbop_pat; pbop_exp; pbop_loc } ->\n let pbop_op = self#loc self#string pbop_op in\n let pbop_pat = self#pattern pbop_pat in\n let pbop_exp = self#expression pbop_exp in\n let pbop_loc = self#location pbop_loc in\n self#record\n [\n (\"pbop_op\", pbop_op);\n (\"pbop_pat\", pbop_pat);\n (\"pbop_exp\", pbop_exp);\n (\"pbop_loc\", pbop_loc);\n ]\n\n method value_description : value_description -> 'res =\n fun { pval_name; pval_type; pval_prim; pval_attributes; pval_loc } ->\n let pval_name = self#loc self#string pval_name in\n let pval_type = self#core_type pval_type in\n let pval_prim = self#list self#string pval_prim in\n let pval_attributes = self#attributes pval_attributes in\n let pval_loc = self#location pval_loc in\n self#record\n [\n (\"pval_name\", pval_name);\n (\"pval_type\", pval_type);\n (\"pval_prim\", pval_prim);\n (\"pval_attributes\", pval_attributes);\n (\"pval_loc\", pval_loc);\n ]\n\n method type_declaration : type_declaration -> 'res =\n fun {\n ptype_name;\n ptype_params;\n ptype_cstrs;\n ptype_kind;\n ptype_private;\n ptype_manifest;\n ptype_attributes;\n ptype_loc;\n } ->\n let ptype_name = self#loc self#string ptype_name in\n let ptype_params =\n self#list\n (fun (a, b) ->\n let a = self#core_type a in\n let b =\n (fun (a, b) ->\n let a = self#variance a in\n let b = self#injectivity b in\n self#tuple [ a; b ])\n b\n in\n self#tuple [ a; b ])\n ptype_params\n in\n let ptype_cstrs =\n self#list\n (fun (a, b, c) ->\n let a = self#core_type a in\n let b = self#core_type b in\n let c = self#location c in\n self#tuple [ a; b; c ])\n ptype_cstrs\n in\n let ptype_kind = self#type_kind ptype_kind in\n let ptype_private = self#private_flag ptype_private in\n let ptype_manifest = self#option self#core_type ptype_manifest in\n let ptype_attributes = self#attributes ptype_attributes in\n let ptype_loc = self#location ptype_loc in\n self#record\n [\n (\"ptype_name\", ptype_name);\n (\"ptype_params\", ptype_params);\n (\"ptype_cstrs\", ptype_cstrs);\n (\"ptype_kind\", ptype_kind);\n (\"ptype_private\", ptype_private);\n (\"ptype_manifest\", ptype_manifest);\n (\"ptype_attributes\", ptype_attributes);\n (\"ptype_loc\", ptype_loc);\n ]\n\n method type_kind : type_kind -> 'res =\n fun x ->\n match x with\n | Ptype_abstract -> self#constr \"Ptype_abstract\" []\n | Ptype_variant a ->\n let a = self#list self#constructor_declaration a in\n self#constr \"Ptype_variant\" [ a ]\n | Ptype_record a ->\n let a = self#list self#label_declaration a in\n self#constr \"Ptype_record\" [ a ]\n | Ptype_open -> self#constr \"Ptype_open\" []\n\n method label_declaration : label_declaration -> 'res =\n fun { pld_name; pld_mutable; pld_type; pld_loc; pld_attributes } ->\n let pld_name = self#loc self#string pld_name in\n let pld_mutable = self#mutable_flag pld_mutable in\n let pld_type = self#core_type pld_type in\n let pld_loc = self#location pld_loc in\n let pld_attributes = self#attributes pld_attributes in\n self#record\n [\n (\"pld_name\", pld_name);\n (\"pld_mutable\", pld_mutable);\n (\"pld_type\", pld_type);\n (\"pld_loc\", pld_loc);\n (\"pld_attributes\", pld_attributes);\n ]\n\n method constructor_declaration : constructor_declaration -> 'res =\n fun { pcd_name; pcd_args; pcd_res; pcd_loc; pcd_attributes } ->\n let pcd_name = self#loc self#string pcd_name in\n let pcd_args = self#constructor_arguments pcd_args in\n let pcd_res = self#option self#core_type pcd_res in\n let pcd_loc = self#location pcd_loc in\n let pcd_attributes = self#attributes pcd_attributes in\n self#record\n [\n (\"pcd_name\", pcd_name);\n (\"pcd_args\", pcd_args);\n (\"pcd_res\", pcd_res);\n (\"pcd_loc\", pcd_loc);\n (\"pcd_attributes\", pcd_attributes);\n ]\n\n method constructor_arguments : constructor_arguments -> 'res =\n fun x ->\n match x with\n | Pcstr_tuple a ->\n let a = self#list self#core_type a in\n self#constr \"Pcstr_tuple\" [ a ]\n | Pcstr_record a ->\n let a = self#list self#label_declaration a in\n self#constr \"Pcstr_record\" [ a ]\n\n method type_extension : type_extension -> 'res =\n fun {\n ptyext_path;\n ptyext_params;\n ptyext_constructors;\n ptyext_private;\n ptyext_loc;\n ptyext_attributes;\n } ->\n let ptyext_path = self#longident_loc ptyext_path in\n let ptyext_params =\n self#list\n (fun (a, b) ->\n let a = self#core_type a in\n let b =\n (fun (a, b) ->\n let a = self#variance a in\n let b = self#injectivity b in\n self#tuple [ a; b ])\n b\n in\n self#tuple [ a; b ])\n ptyext_params\n in\n let ptyext_constructors =\n self#list self#extension_constructor ptyext_constructors\n in\n let ptyext_private = self#private_flag ptyext_private in\n let ptyext_loc = self#location ptyext_loc in\n let ptyext_attributes = self#attributes ptyext_attributes in\n self#record\n [\n (\"ptyext_path\", ptyext_path);\n (\"ptyext_params\", ptyext_params);\n (\"ptyext_constructors\", ptyext_constructors);\n (\"ptyext_private\", ptyext_private);\n (\"ptyext_loc\", ptyext_loc);\n (\"ptyext_attributes\", ptyext_attributes);\n ]\n\n method extension_constructor : extension_constructor -> 'res =\n fun { pext_name; pext_kind; pext_loc; pext_attributes } ->\n let pext_name = self#loc self#string pext_name in\n let pext_kind = self#extension_constructor_kind pext_kind in\n let pext_loc = self#location pext_loc in\n let pext_attributes = self#attributes pext_attributes in\n self#record\n [\n (\"pext_name\", pext_name);\n (\"pext_kind\", pext_kind);\n (\"pext_loc\", pext_loc);\n (\"pext_attributes\", pext_attributes);\n ]\n\n method type_exception : type_exception -> 'res =\n fun { ptyexn_constructor; ptyexn_loc; ptyexn_attributes } ->\n let ptyexn_constructor =\n self#extension_constructor ptyexn_constructor\n in\n let ptyexn_loc = self#location ptyexn_loc in\n let ptyexn_attributes = self#attributes ptyexn_attributes in\n self#record\n [\n (\"ptyexn_constructor\", ptyexn_constructor);\n (\"ptyexn_loc\", ptyexn_loc);\n (\"ptyexn_attributes\", ptyexn_attributes);\n ]\n\n method extension_constructor_kind : extension_constructor_kind -> 'res =\n fun x ->\n match x with\n | Pext_decl (a, b) ->\n let a = self#constructor_arguments a in\n let b = self#option self#core_type b in\n self#constr \"Pext_decl\" [ a; b ]\n | Pext_rebind a ->\n let a = self#longident_loc a in\n self#constr \"Pext_rebind\" [ a ]\n\n method class_type : class_type -> 'res =\n fun { pcty_desc; pcty_loc; pcty_attributes } ->\n let pcty_desc = self#class_type_desc pcty_desc in\n let pcty_loc = self#location pcty_loc in\n let pcty_attributes = self#attributes pcty_attributes in\n self#record\n [\n (\"pcty_desc\", pcty_desc);\n (\"pcty_loc\", pcty_loc);\n (\"pcty_attributes\", pcty_attributes);\n ]\n\n method class_type_desc : class_type_desc -> 'res =\n fun x ->\n match x with\n | Pcty_constr (a, b) ->\n let a = self#longident_loc a in\n let b = self#list self#core_type b in\n self#constr \"Pcty_constr\" [ a; b ]\n | Pcty_signature a ->\n let a = self#class_signature a in\n self#constr \"Pcty_signature\" [ a ]\n | Pcty_arrow (a, b, c) ->\n let a = self#arg_label a in\n let b = self#core_type b in\n let c = self#class_type c in\n self#constr \"Pcty_arrow\" [ a; b; c ]\n | Pcty_extension a ->\n let a = self#extension a in\n self#constr \"Pcty_extension\" [ a ]\n | Pcty_open (a, b) ->\n let a = self#open_description a in\n let b = self#class_type b in\n self#constr \"Pcty_open\" [ a; b ]\n\n method class_signature : class_signature -> 'res =\n fun { pcsig_self; pcsig_fields } ->\n let pcsig_self = self#core_type pcsig_self in\n let pcsig_fields = self#list self#class_type_field pcsig_fields in\n self#record\n [ (\"pcsig_self\", pcsig_self); (\"pcsig_fields\", pcsig_fields) ]\n\n method class_type_field : class_type_field -> 'res =\n fun { pctf_desc; pctf_loc; pctf_attributes } ->\n let pctf_desc = self#class_type_field_desc pctf_desc in\n let pctf_loc = self#location pctf_loc in\n let pctf_attributes = self#attributes pctf_attributes in\n self#record\n [\n (\"pctf_desc\", pctf_desc);\n (\"pctf_loc\", pctf_loc);\n (\"pctf_attributes\", pctf_attributes);\n ]\n\n method class_type_field_desc : class_type_field_desc -> 'res =\n fun x ->\n match x with\n | Pctf_inherit a ->\n let a = self#class_type a in\n self#constr \"Pctf_inherit\" [ a ]\n | Pctf_val a ->\n let a =\n (fun (a, b, c, d) ->\n let a = self#loc self#label a in\n let b = self#mutable_flag b in\n let c = self#virtual_flag c in\n let d = self#core_type d in\n self#tuple [ a; b; c; d ])\n a\n in\n self#constr \"Pctf_val\" [ a ]\n | Pctf_method a ->\n let a =\n (fun (a, b, c, d) ->\n let a = self#loc self#label a in\n let b = self#private_flag b in\n let c = self#virtual_flag c in\n let d = self#core_type d in\n self#tuple [ a; b; c; d ])\n a\n in\n self#constr \"Pctf_method\" [ a ]\n | Pctf_constraint a ->\n let a =\n (fun (a, b) ->\n let a = self#core_type a in\n let b = self#core_type b in\n self#tuple [ a; b ])\n a\n in\n self#constr \"Pctf_constraint\" [ a ]\n | Pctf_attribute a ->\n let a = self#attribute a in\n self#constr \"Pctf_attribute\" [ a ]\n | Pctf_extension a ->\n let a = self#extension a in\n self#constr \"Pctf_extension\" [ a ]\n\n method class_infos : 'a. ('a -> 'res) -> 'a class_infos -> 'res =\n fun _a\n { pci_virt; pci_params; pci_name; pci_expr; pci_loc; pci_attributes } ->\n let pci_virt = self#virtual_flag pci_virt in\n let pci_params =\n self#list\n (fun (a, b) ->\n let a = self#core_type a in\n let b =\n (fun (a, b) ->\n let a = self#variance a in\n let b = self#injectivity b in\n self#tuple [ a; b ])\n b\n in\n self#tuple [ a; b ])\n pci_params\n in\n let pci_name = self#loc self#string pci_name in\n let pci_expr = _a pci_expr in\n let pci_loc = self#location pci_loc in\n let pci_attributes = self#attributes pci_attributes in\n self#record\n [\n (\"pci_virt\", pci_virt);\n (\"pci_params\", pci_params);\n (\"pci_name\", pci_name);\n (\"pci_expr\", pci_expr);\n (\"pci_loc\", pci_loc);\n (\"pci_attributes\", pci_attributes);\n ]\n\n method class_description : class_description -> 'res =\n self#class_infos self#class_type\n\n method class_type_declaration : class_type_declaration -> 'res =\n self#class_infos self#class_type\n\n method class_expr : class_expr -> 'res =\n fun { pcl_desc; pcl_loc; pcl_attributes } ->\n let pcl_desc = self#class_expr_desc pcl_desc in\n let pcl_loc = self#location pcl_loc in\n let pcl_attributes = self#attributes pcl_attributes in\n self#record\n [\n (\"pcl_desc\", pcl_desc);\n (\"pcl_loc\", pcl_loc);\n (\"pcl_attributes\", pcl_attributes);\n ]\n\n method class_expr_desc : class_expr_desc -> 'res =\n fun x ->\n match x with\n | Pcl_constr (a, b) ->\n let a = self#longident_loc a in\n let b = self#list self#core_type b in\n self#constr \"Pcl_constr\" [ a; b ]\n | Pcl_structure a ->\n let a = self#class_structure a in\n self#constr \"Pcl_structure\" [ a ]\n | Pcl_fun (a, b, c, d) ->\n let a = self#arg_label a in\n let b = self#option self#expression b in\n let c = self#pattern c in\n let d = self#class_expr d in\n self#constr \"Pcl_fun\" [ a; b; c; d ]\n | Pcl_apply (a, b) ->\n let a = self#class_expr a in\n let b =\n self#list\n (fun (a, b) ->\n let a = self#arg_label a in\n let b = self#expression b in\n self#tuple [ a; b ])\n b\n in\n self#constr \"Pcl_apply\" [ a; b ]\n | Pcl_let (a, b, c) ->\n let a = self#rec_flag a in\n let b = self#list self#value_binding b in\n let c = self#class_expr c in\n self#constr \"Pcl_let\" [ a; b; c ]\n | Pcl_constraint (a, b) ->\n let a = self#class_expr a in\n let b = self#class_type b in\n self#constr \"Pcl_constraint\" [ a; b ]\n | Pcl_extension a ->\n let a = self#extension a in\n self#constr \"Pcl_extension\" [ a ]\n | Pcl_open (a, b) ->\n let a = self#open_description a in\n let b = self#class_expr b in\n self#constr \"Pcl_open\" [ a; b ]\n\n method class_structure : class_structure -> 'res =\n fun { pcstr_self; pcstr_fields } ->\n let pcstr_self = self#pattern pcstr_self in\n let pcstr_fields = self#list self#class_field pcstr_fields in\n self#record\n [ (\"pcstr_self\", pcstr_self); (\"pcstr_fields\", pcstr_fields) ]\n\n method class_field : class_field -> 'res =\n fun { pcf_desc; pcf_loc; pcf_attributes } ->\n let pcf_desc = self#class_field_desc pcf_desc in\n let pcf_loc = self#location pcf_loc in\n let pcf_attributes = self#attributes pcf_attributes in\n self#record\n [\n (\"pcf_desc\", pcf_desc);\n (\"pcf_loc\", pcf_loc);\n (\"pcf_attributes\", pcf_attributes);\n ]\n\n method class_field_desc : class_field_desc -> 'res =\n fun x ->\n match x with\n | Pcf_inherit (a, b, c) ->\n let a = self#override_flag a in\n let b = self#class_expr b in\n let c = self#option (self#loc self#string) c in\n self#constr \"Pcf_inherit\" [ a; b; c ]\n | Pcf_val a ->\n let a =\n (fun (a, b, c) ->\n let a = self#loc self#label a in\n let b = self#mutable_flag b in\n let c = self#class_field_kind c in\n self#tuple [ a; b; c ])\n a\n in\n self#constr \"Pcf_val\" [ a ]\n | Pcf_method a ->\n let a =\n (fun (a, b, c) ->\n let a = self#loc self#label a in\n let b = self#private_flag b in\n let c = self#class_field_kind c in\n self#tuple [ a; b; c ])\n a\n in\n self#constr \"Pcf_method\" [ a ]\n | Pcf_constraint a ->\n let a =\n (fun (a, b) ->\n let a = self#core_type a in\n let b = self#core_type b in\n self#tuple [ a; b ])\n a\n in\n self#constr \"Pcf_constraint\" [ a ]\n | Pcf_initializer a ->\n let a = self#expression a in\n self#constr \"Pcf_initializer\" [ a ]\n | Pcf_attribute a ->\n let a = self#attribute a in\n self#constr \"Pcf_attribute\" [ a ]\n | Pcf_extension a ->\n let a = self#extension a in\n self#constr \"Pcf_extension\" [ a ]\n\n method class_field_kind : class_field_kind -> 'res =\n fun x ->\n match x with\n | Cfk_virtual a ->\n let a = self#core_type a in\n self#constr \"Cfk_virtual\" [ a ]\n | Cfk_concrete (a, b) ->\n let a = self#override_flag a in\n let b = self#expression b in\n self#constr \"Cfk_concrete\" [ a; b ]\n\n method class_declaration : class_declaration -> 'res =\n self#class_infos self#class_expr\n\n method module_type : module_type -> 'res =\n fun { pmty_desc; pmty_loc; pmty_attributes } ->\n let pmty_desc = self#module_type_desc pmty_desc in\n let pmty_loc = self#location pmty_loc in\n let pmty_attributes = self#attributes pmty_attributes in\n self#record\n [\n (\"pmty_desc\", pmty_desc);\n (\"pmty_loc\", pmty_loc);\n (\"pmty_attributes\", pmty_attributes);\n ]\n\n method module_type_desc : module_type_desc -> 'res =\n fun x ->\n match x with\n | Pmty_ident a ->\n let a = self#longident_loc a in\n self#constr \"Pmty_ident\" [ a ]\n | Pmty_signature a ->\n let a = self#signature a in\n self#constr \"Pmty_signature\" [ a ]\n | Pmty_functor (a, b) ->\n let a = self#functor_parameter a in\n let b = self#module_type b in\n self#constr \"Pmty_functor\" [ a; b ]\n | Pmty_with (a, b) ->\n let a = self#module_type a in\n let b = self#list self#with_constraint b in\n self#constr \"Pmty_with\" [ a; b ]\n | Pmty_typeof a ->\n let a = self#module_expr a in\n self#constr \"Pmty_typeof\" [ a ]\n | Pmty_extension a ->\n let a = self#extension a in\n self#constr \"Pmty_extension\" [ a ]\n | Pmty_alias a ->\n let a = self#longident_loc a in\n self#constr \"Pmty_alias\" [ a ]\n\n method functor_parameter : functor_parameter -> 'res =\n fun x ->\n match x with\n | Unit -> self#constr \"Unit\" []\n | Named (a, b) ->\n let a = self#loc (self#option self#string) a in\n let b = self#module_type b in\n self#constr \"Named\" [ a; b ]\n\n method signature : signature -> 'res = self#list self#signature_item\n\n method signature_item : signature_item -> 'res =\n fun { psig_desc; psig_loc } ->\n let psig_desc = self#signature_item_desc psig_desc in\n let psig_loc = self#location psig_loc in\n self#record [ (\"psig_desc\", psig_desc); (\"psig_loc\", psig_loc) ]\n\n method signature_item_desc : signature_item_desc -> 'res =\n fun x ->\n match x with\n | Psig_value a ->\n let a = self#value_description a in\n self#constr \"Psig_value\" [ a ]\n | Psig_type (a, b) ->\n let a = self#rec_flag a in\n let b = self#list self#type_declaration b in\n self#constr \"Psig_type\" [ a; b ]\n | Psig_typesubst a ->\n let a = self#list self#type_declaration a in\n self#constr \"Psig_typesubst\" [ a ]\n | Psig_typext a ->\n let a = self#type_extension a in\n self#constr \"Psig_typext\" [ a ]\n | Psig_exception a ->\n let a = self#type_exception a in\n self#constr \"Psig_exception\" [ a ]\n | Psig_module a ->\n let a = self#module_declaration a in\n self#constr \"Psig_module\" [ a ]\n | Psig_modsubst a ->\n let a = self#module_substitution a in\n self#constr \"Psig_modsubst\" [ a ]\n | Psig_recmodule a ->\n let a = self#list self#module_declaration a in\n self#constr \"Psig_recmodule\" [ a ]\n | Psig_modtype a ->\n let a = self#module_type_declaration a in\n self#constr \"Psig_modtype\" [ a ]\n | Psig_open a ->\n let a = self#open_description a in\n self#constr \"Psig_open\" [ a ]\n | Psig_include a ->\n let a = self#include_description a in\n self#constr \"Psig_include\" [ a ]\n | Psig_class a ->\n let a = self#list self#class_description a in\n self#constr \"Psig_class\" [ a ]\n | Psig_class_type a ->\n let a = self#list self#class_type_declaration a in\n self#constr \"Psig_class_type\" [ a ]\n | Psig_attribute a ->\n let a = self#attribute a in\n self#constr \"Psig_attribute\" [ a ]\n | Psig_extension (a, b) ->\n let a = self#extension a in\n let b = self#attributes b in\n self#constr \"Psig_extension\" [ a; b ]\n\n method module_declaration : module_declaration -> 'res =\n fun { pmd_name; pmd_type; pmd_attributes; pmd_loc } ->\n let pmd_name = self#loc (self#option self#string) pmd_name in\n let pmd_type = self#module_type pmd_type in\n let pmd_attributes = self#attributes pmd_attributes in\n let pmd_loc = self#location pmd_loc in\n self#record\n [\n (\"pmd_name\", pmd_name);\n (\"pmd_type\", pmd_type);\n (\"pmd_attributes\", pmd_attributes);\n (\"pmd_loc\", pmd_loc);\n ]\n\n method module_substitution : module_substitution -> 'res =\n fun { pms_name; pms_manifest; pms_attributes; pms_loc } ->\n let pms_name = self#loc self#string pms_name in\n let pms_manifest = self#longident_loc pms_manifest in\n let pms_attributes = self#attributes pms_attributes in\n let pms_loc = self#location pms_loc in\n self#record\n [\n (\"pms_name\", pms_name);\n (\"pms_manifest\", pms_manifest);\n (\"pms_attributes\", pms_attributes);\n (\"pms_loc\", pms_loc);\n ]\n\n method module_type_declaration : module_type_declaration -> 'res =\n fun { pmtd_name; pmtd_type; pmtd_attributes; pmtd_loc } ->\n let pmtd_name = self#loc self#string pmtd_name in\n let pmtd_type = self#option self#module_type pmtd_type in\n let pmtd_attributes = self#attributes pmtd_attributes in\n let pmtd_loc = self#location pmtd_loc in\n self#record\n [\n (\"pmtd_name\", pmtd_name);\n (\"pmtd_type\", pmtd_type);\n (\"pmtd_attributes\", pmtd_attributes);\n (\"pmtd_loc\", pmtd_loc);\n ]\n\n method open_infos : 'a. ('a -> 'res) -> 'a open_infos -> 'res =\n fun _a { popen_expr; popen_override; popen_loc; popen_attributes } ->\n let popen_expr = _a popen_expr in\n let popen_override = self#override_flag popen_override in\n let popen_loc = self#location popen_loc in\n let popen_attributes = self#attributes popen_attributes in\n self#record\n [\n (\"popen_expr\", popen_expr);\n (\"popen_override\", popen_override);\n (\"popen_loc\", popen_loc);\n (\"popen_attributes\", popen_attributes);\n ]\n\n method open_description : open_description -> 'res =\n self#open_infos self#longident_loc\n\n method open_declaration : open_declaration -> 'res =\n self#open_infos self#module_expr\n\n method include_infos : 'a. ('a -> 'res) -> 'a include_infos -> 'res =\n fun _a { pincl_mod; pincl_loc; pincl_attributes } ->\n let pincl_mod = _a pincl_mod in\n let pincl_loc = self#location pincl_loc in\n let pincl_attributes = self#attributes pincl_attributes in\n self#record\n [\n (\"pincl_mod\", pincl_mod);\n (\"pincl_loc\", pincl_loc);\n (\"pincl_attributes\", pincl_attributes);\n ]\n\n method include_description : include_description -> 'res =\n self#include_infos self#module_type\n\n method include_declaration : include_declaration -> 'res =\n self#include_infos self#module_expr\n\n method with_constraint : with_constraint -> 'res =\n fun x ->\n match x with\n | Pwith_type (a, b) ->\n let a = self#longident_loc a in\n let b = self#type_declaration b in\n self#constr \"Pwith_type\" [ a; b ]\n | Pwith_module (a, b) ->\n let a = self#longident_loc a in\n let b = self#longident_loc b in\n self#constr \"Pwith_module\" [ a; b ]\n | Pwith_typesubst (a, b) ->\n let a = self#longident_loc a in\n let b = self#type_declaration b in\n self#constr \"Pwith_typesubst\" [ a; b ]\n | Pwith_modsubst (a, b) ->\n let a = self#longident_loc a in\n let b = self#longident_loc b in\n self#constr \"Pwith_modsubst\" [ a; b ]\n\n method module_expr : module_expr -> 'res =\n fun { pmod_desc; pmod_loc; pmod_attributes } ->\n let pmod_desc = self#module_expr_desc pmod_desc in\n let pmod_loc = self#location pmod_loc in\n let pmod_attributes = self#attributes pmod_attributes in\n self#record\n [\n (\"pmod_desc\", pmod_desc);\n (\"pmod_loc\", pmod_loc);\n (\"pmod_attributes\", pmod_attributes);\n ]\n\n method module_expr_desc : module_expr_desc -> 'res =\n fun x ->\n match x with\n | Pmod_ident a ->\n let a = self#longident_loc a in\n self#constr \"Pmod_ident\" [ a ]\n | Pmod_structure a ->\n let a = self#structure a in\n self#constr \"Pmod_structure\" [ a ]\n | Pmod_functor (a, b) ->\n let a = self#functor_parameter a in\n let b = self#module_expr b in\n self#constr \"Pmod_functor\" [ a; b ]\n | Pmod_apply (a, b) ->\n let a = self#module_expr a in\n let b = self#module_expr b in\n self#constr \"Pmod_apply\" [ a; b ]\n | Pmod_constraint (a, b) ->\n let a = self#module_expr a in\n let b = self#module_type b in\n self#constr \"Pmod_constraint\" [ a; b ]\n | Pmod_unpack a ->\n let a = self#expression a in\n self#constr \"Pmod_unpack\" [ a ]\n | Pmod_extension a ->\n let a = self#extension a in\n self#constr \"Pmod_extension\" [ a ]\n\n method structure : structure -> 'res = self#list self#structure_item\n\n method structure_item : structure_item -> 'res =\n fun { pstr_desc; pstr_loc } ->\n let pstr_desc = self#structure_item_desc pstr_desc in\n let pstr_loc = self#location pstr_loc in\n self#record [ (\"pstr_desc\", pstr_desc); (\"pstr_loc\", pstr_loc) ]\n\n method structure_item_desc : structure_item_desc -> 'res =\n fun x ->\n match x with\n | Pstr_eval (a, b) ->\n let a = self#expression a in\n let b = self#attributes b in\n self#constr \"Pstr_eval\" [ a; b ]\n | Pstr_value (a, b) ->\n let a = self#rec_flag a in\n let b = self#list self#value_binding b in\n self#constr \"Pstr_value\" [ a; b ]\n | Pstr_primitive a ->\n let a = self#value_description a in\n self#constr \"Pstr_primitive\" [ a ]\n | Pstr_type (a, b) ->\n let a = self#rec_flag a in\n let b = self#list self#type_declaration b in\n self#constr \"Pstr_type\" [ a; b ]\n | Pstr_typext a ->\n let a = self#type_extension a in\n self#constr \"Pstr_typext\" [ a ]\n | Pstr_exception a ->\n let a = self#type_exception a in\n self#constr \"Pstr_exception\" [ a ]\n | Pstr_module a ->\n let a = self#module_binding a in\n self#constr \"Pstr_module\" [ a ]\n | Pstr_recmodule a ->\n let a = self#list self#module_binding a in\n self#constr \"Pstr_recmodule\" [ a ]\n | Pstr_modtype a ->\n let a = self#module_type_declaration a in\n self#constr \"Pstr_modtype\" [ a ]\n | Pstr_open a ->\n let a = self#open_declaration a in\n self#constr \"Pstr_open\" [ a ]\n | Pstr_class a ->\n let a = self#list self#class_declaration a in\n self#constr \"Pstr_class\" [ a ]\n | Pstr_class_type a ->\n let a = self#list self#class_type_declaration a in\n self#constr \"Pstr_class_type\" [ a ]\n | Pstr_include a ->\n let a = self#include_declaration a in\n self#constr \"Pstr_include\" [ a ]\n | Pstr_attribute a ->\n let a = self#attribute a in\n self#constr \"Pstr_attribute\" [ a ]\n | Pstr_extension (a, b) ->\n let a = self#extension a in\n let b = self#attributes b in\n self#constr \"Pstr_extension\" [ a; b ]\n\n method value_binding : value_binding -> 'res =\n fun { pvb_pat; pvb_expr; pvb_attributes; pvb_loc } ->\n let pvb_pat = self#pattern pvb_pat in\n let pvb_expr = self#expression pvb_expr in\n let pvb_attributes = self#attributes pvb_attributes in\n let pvb_loc = self#location pvb_loc in\n self#record\n [\n (\"pvb_pat\", pvb_pat);\n (\"pvb_expr\", pvb_expr);\n (\"pvb_attributes\", pvb_attributes);\n (\"pvb_loc\", pvb_loc);\n ]\n\n method module_binding : module_binding -> 'res =\n fun { pmb_name; pmb_expr; pmb_attributes; pmb_loc } ->\n let pmb_name = self#loc (self#option self#string) pmb_name in\n let pmb_expr = self#module_expr pmb_expr in\n let pmb_attributes = self#attributes pmb_attributes in\n let pmb_loc = self#location pmb_loc in\n self#record\n [\n (\"pmb_name\", pmb_name);\n (\"pmb_expr\", pmb_expr);\n (\"pmb_attributes\", pmb_attributes);\n (\"pmb_loc\", pmb_loc);\n ]\n\n method toplevel_phrase : toplevel_phrase -> 'res =\n fun x ->\n match x with\n | Ptop_def a ->\n let a = self#structure a in\n self#constr \"Ptop_def\" [ a ]\n | Ptop_dir a ->\n let a = self#toplevel_directive a in\n self#constr \"Ptop_dir\" [ a ]\n\n method toplevel_directive : toplevel_directive -> 'res =\n fun { pdir_name; pdir_arg; pdir_loc } ->\n let pdir_name = self#loc self#string pdir_name in\n let pdir_arg = self#option self#directive_argument pdir_arg in\n let pdir_loc = self#location pdir_loc in\n self#record\n [\n (\"pdir_name\", pdir_name);\n (\"pdir_arg\", pdir_arg);\n (\"pdir_loc\", pdir_loc);\n ]\n\n method directive_argument : directive_argument -> 'res =\n fun { pdira_desc; pdira_loc } ->\n let pdira_desc = self#directive_argument_desc pdira_desc in\n let pdira_loc = self#location pdira_loc in\n self#record [ (\"pdira_desc\", pdira_desc); (\"pdira_loc\", pdira_loc) ]\n\n method directive_argument_desc : directive_argument_desc -> 'res =\n fun x ->\n match x with\n | Pdir_string a ->\n let a = self#string a in\n self#constr \"Pdir_string\" [ a ]\n | Pdir_int (a, b) ->\n let a = self#string a in\n let b = self#option self#char b in\n self#constr \"Pdir_int\" [ a; b ]\n | Pdir_ident a ->\n let a = self#longident a in\n self#constr \"Pdir_ident\" [ a ]\n | Pdir_bool a ->\n let a = self#bool a in\n self#constr \"Pdir_bool\" [ a ]\n\n method cases : cases -> 'res = self#list self#case\n end\n\n[@@@end]\n","type deriver = ..\n\nlet all = Hashtbl.create 42\n\nlet register name deriver =\n if Hashtbl.mem all name then\n Printf.ksprintf failwith\n \"Ppx_deriviers.register: %S is already registered\" name;\n Hashtbl.add all name deriver\n\nlet lookup name =\n match Hashtbl.find all name with\n | drv -> Some drv\n | exception Not_found -> None\n\nlet derivers () =\n Hashtbl.fold (fun name drv acc -> (name, drv) :: acc) all []\n","module T = struct\n type 'a map = 'a -> 'a\n type 'a iter = 'a -> unit\n type ('a, 'acc) fold = 'a -> 'acc -> 'acc\n type ('a, 'acc) fold_map = 'a -> 'acc -> 'a * 'acc\n type ('ctx, 'a) map_with_context = 'ctx -> 'a -> 'a\n type ('a, 'res) lift = 'a -> 'res\nend\n\nclass map =\n let any x = x in\n object\n method int : int T.map = any\n method string : string T.map = any\n method bool : bool T.map = any\n method char : char T.map = any\n\n method option : 'a. 'a T.map -> 'a option T.map =\n fun f x -> match x with None -> None | Some x -> Some (f x)\n\n method list : 'a. 'a T.map -> 'a list T.map = List.map\n method array : 'a. 'a T.map -> 'a array T.map = Array.map\n end\n\nclass iter =\n let any = ignore in\n object\n method int : int T.iter = any\n method string : string T.iter = any\n method bool : bool T.iter = any\n method char : char T.iter = any\n\n method option : 'a. 'a T.iter -> 'a option T.iter =\n fun f x -> match x with None -> () | Some x -> f x\n\n method list : 'a. 'a T.iter -> 'a list T.iter = List.iter\n method array : 'a. 'a T.iter -> 'a array T.iter = Array.iter\n end\n\nclass ['acc] fold =\n let any _ acc = acc in\n object\n method int : (int, 'acc) T.fold = any\n method string : (string, 'acc) T.fold = any\n method bool : (bool, 'acc) T.fold = any\n method char : (char, 'acc) T.fold = any\n\n method option : 'a. ('a, 'acc) T.fold -> ('a option, 'acc) T.fold =\n fun f x acc -> match x with None -> acc | Some x -> f x acc\n\n method list : 'a. ('a, 'acc) T.fold -> ('a list, 'acc) T.fold =\n let rec loop f l acc =\n match l with [] -> acc | x :: l -> loop f l (f x acc)\n in\n loop\n\n method array : 'a. ('a, 'acc) T.fold -> ('a array, 'acc) T.fold =\n fun f a acc ->\n let r = ref acc in\n for i = 0 to Array.length a - 1 do\n r := f (Array.unsafe_get a i) !r\n done;\n !r\n end\n\nclass ['acc] fold_map =\n let any x acc = (x, acc) in\n object\n method int : (int, 'acc) T.fold_map = any\n method string : (string, 'acc) T.fold_map = any\n method bool : (bool, 'acc) T.fold_map = any\n method char : (char, 'acc) T.fold_map = any\n\n method option : 'a. ('a, 'acc) T.fold_map -> ('a option, 'acc) T.fold_map =\n fun f x acc ->\n match x with\n | None -> (None, acc)\n | Some x ->\n let x, acc = f x acc in\n (Some x, acc)\n\n method list : 'a. ('a, 'acc) T.fold_map -> ('a list, 'acc) T.fold_map =\n let rec loop f l acc =\n match l with\n | [] -> ([], acc)\n | x :: l ->\n let x, acc = f x acc in\n let l, acc = loop f l acc in\n (x :: l, acc)\n in\n loop\n\n method array : 'a. ('a, 'acc) T.fold_map -> ('a array, 'acc) T.fold_map =\n fun f a acc ->\n let len = Array.length a in\n if len = 0 then (a, acc)\n else\n let x, acc = f (Array.unsafe_get a 0) acc in\n let a' = Array.make len x in\n let r = ref acc in\n for i = 1 to len - 1 do\n let x, acc = f (Array.unsafe_get a i) !r in\n Array.unsafe_set a' i x;\n r := acc\n done;\n (a', !r)\n end\n\nclass ['ctx] map_with_context =\n let any _ x = x in\n object\n method int : ('ctx, int) T.map_with_context = any\n method string : ('ctx, string) T.map_with_context = any\n method bool : ('ctx, bool) T.map_with_context = any\n method char : ('ctx, char) T.map_with_context = any\n\n method option\n : 'a.\n ('ctx, 'a) T.map_with_context -> ('ctx, 'a option) T.map_with_context\n =\n fun f ctx x -> match x with None -> None | Some x -> Some (f ctx x)\n\n method list\n : 'a.\n ('ctx, 'a) T.map_with_context -> ('ctx, 'a list) T.map_with_context =\n fun f ctx l -> List.map (f ctx) l\n\n method array\n : 'a.\n ('ctx, 'a) T.map_with_context -> ('ctx, 'a array) T.map_with_context =\n fun f ctx a -> Array.map (f ctx) a\n end\n\nclass virtual ['res] lift =\n object (self)\n method virtual other : 'a. ('a, 'res) T.lift\n method virtual int : (int, 'res) T.lift\n method virtual string : (string, 'res) T.lift\n method virtual bool : (bool, 'res) T.lift\n method virtual char : (char, 'res) T.lift\n method virtual array : 'a. ('a, 'res) T.lift -> ('a array, 'res) T.lift\n method virtual float : (float, 'res) T.lift\n method virtual int32 : (int32, 'res) T.lift\n method virtual int64 : (int64, 'res) T.lift\n method virtual nativeint : (nativeint, 'res) T.lift\n method virtual unit : (unit, 'res) T.lift\n method virtual record : (string * 'res) list -> 'res\n method virtual constr : string -> 'res list -> 'res\n method virtual tuple : 'res list -> 'res\n\n method option : 'a. ('a, 'res) T.lift -> ('a option, 'res) T.lift =\n fun f x ->\n match x with\n | None -> self#constr \"None\" []\n | Some x -> self#constr \"Some\" [ f x ]\n\n method list : 'a. ('a, 'res) T.lift -> ('a list, 'res) T.lift =\n fun f l ->\n match l with\n | [] -> self#constr \"[]\" []\n | x :: l -> self#constr \"::\" [ f x; self#list f l ]\n end\n\nclass type ['res] std_lifters =\n object\n method other : 'a. ('a, 'res) T.lift\n method int : (int, 'res) T.lift\n method string : (string, 'res) T.lift\n method bool : (bool, 'res) T.lift\n method char : (char, 'res) T.lift\n method array : 'a. ('a, 'res) T.lift -> ('a array, 'res) T.lift\n method record : (string * 'res) list -> 'res\n method constr : string -> 'res list -> 'res\n method tuple : 'res list -> 'res\n method float : (float, 'res) T.lift\n method int32 : (int32, 'res) T.lift\n method int64 : (int64, 'res) T.lift\n method nativeint : (nativeint, 'res) T.lift\n method unit : (unit, 'res) T.lift\n method option : 'a. ('a, 'res) T.lift -> ('a option, 'res) T.lift\n method list : 'a. ('a, 'res) T.lift -> ('a list, 'res) T.lift\n end\n","open! Import\n\nmodule T = struct\n type t = longident = Lident of string | Ldot of t * string | Lapply of t * t\n\n let compare : t -> t -> int = Poly.compare\n\n let is_normal_ident_char = function\n | 'A' .. 'Z' | 'a' .. 'z' | '0' .. '9' | '_' | '\\'' -> true\n | _ -> false\n\n let is_normal_ident = function\n | \"asr\" | \"land\" | \"lor\" | \"lsl\" | \"lsr\" | \"lxor\" | \"mod\" | \"or\" -> false\n | string -> String.for_all string ~f:is_normal_ident_char\n\n let short_name string =\n if is_normal_ident string then string else \"( \" ^ string ^ \" )\"\n\n let rec name = function\n | Lident s -> short_name s\n | Ldot (a, b) -> name a ^ \".\" ^ short_name b\n | Lapply (a, b) -> Printf.sprintf \"%s(%s)\" (name a) (name b)\n\n let sexp_of_t t = Sexp.Atom (name t)\nend\n\ninclude T\n\nlet rec flat accu = function\n | Lident s -> s :: accu\n | Ldot (lid, s) -> flat (s :: accu) lid\n | Lapply (_, _) -> invalid_arg \"Ppxlib.Longident.flatten\"\n\nlet flatten_exn lid = flat [] lid\n\nlet last_exn = function\n | Lident s -> s\n | Ldot (_, s) -> s\n | Lapply (_, _) -> invalid_arg \"Ppxlib.Longident.flatten\"\n\nlet unflatten ~init l = List.fold_left l ~init ~f:(fun acc s -> Ldot (acc, s))\n\n(* for cases without dotted operators (e.g. [parse \"A.B.C\"]) *)\nlet parse_simple s =\n match String.split_on_char s ~sep:'.' with\n | [] -> assert false\n | s :: l -> unflatten ~init:(Lident s) l\n\n(* handle [\"A.B.(+.+)\"] or [\"Vec.(.%.()<-)\"] *)\nlet parse s =\n let invalid () =\n invalid_arg (Printf.sprintf \"Ppxlib.Longident.parse: %S\" s)\n in\n match (String.index_opt s '(', String.rindex_opt s ')') with\n | None, None -> parse_simple s\n | None, _ | _, None -> invalid ()\n | Some l, Some r -> (\n if Int.(r <> String.length s - 1) then invalid ();\n let group =\n if Int.(r = l + 1) then \"()\"\n else String.trim (String.sub s ~pos:(l + 1) ~len:(r - l - 1))\n in\n if Int.(l = 0) then Lident group\n else if Char.(s.[l - 1] <> '.') then invalid ()\n else\n let before = String.sub s ~pos:0 ~len:(l - 1) in\n match String.split_on_char before ~sep:'.' with\n | [] -> assert false\n | s :: l -> Ldot (unflatten ~init:(Lident s) l, group))\n\nmodule Map = Map.Make (T)\nmodule Set = Set.Make (T)\n","open! Import\n\ntype t = {\n file_path : string;\n main_module_name : string;\n submodule_path : string loc list;\n value : string loc option;\n in_expr : bool;\n}\n\nlet top_level ~file_path =\n let main_module_name =\n file_path |> Caml.Filename.basename |> Caml.Filename.remove_extension\n |> String.capitalize_ascii\n in\n {\n file_path;\n main_module_name;\n submodule_path = [];\n value = None;\n in_expr = false;\n }\n\nlet file_path t = t.file_path\nlet main_module_name t = t.main_module_name\n\nlet submodule_path t =\n List.rev_map ~f:(fun located -> located.txt) t.submodule_path\n\nlet value t = Option.map ~f:(fun located -> located.txt) t.value\n\nlet fully_qualified_path t =\n let value = value t in\n let submodule_path =\n List.rev_map ~f:(fun located -> Some located.txt) t.submodule_path\n in\n let names = (Some t.main_module_name :: submodule_path) @ [ value ] in\n String.concat ~sep:\".\" @@ List.filter_opt names\n\nlet enter_expr t = { t with in_expr = true }\n\nlet enter_module ~loc module_name t =\n if t.in_expr then t\n else\n { t with submodule_path = { txt = module_name; loc } :: t.submodule_path }\n\nlet enter_value ~loc value_name t =\n if t.in_expr then t else { t with value = Some { txt = value_name; loc } }\n\nlet to_string_path t = String.concat ~sep:\".\" (t.file_path :: submodule_path t)\nlet with_string_path f ~loc ~path = f ~loc ~path:(to_string_path path);;\n\nlet module M = struct\n let a = \"lol\"\nend in\nM.a\n","open Import\nmodule L = Astlib.Location\n\ntype t = location = {\n loc_start : Lexing.position;\n loc_end : Lexing.position;\n loc_ghost : bool;\n}\n\nlet in_file name =\n let loc = { pos_fname = name; pos_lnum = 1; pos_bol = 0; pos_cnum = -1 } in\n { loc_start = loc; loc_end = loc; loc_ghost = true }\n\nlet set_filename loc fn =\n let loc_start = { loc.loc_start with pos_fname = fn } in\n let loc_end = { loc.loc_end with pos_fname = fn } in\n { loc with loc_start; loc_end }\n\nlet none = in_file \"_none_\"\n\nlet init lexbuf fname =\n let open Lexing in\n lexbuf.lex_curr_p <-\n { pos_fname = fname; pos_lnum = 1; pos_bol = 0; pos_cnum = 0 }\n\nlet raise_errorf ?loc fmt = L.raise_errorf ?loc fmt\nlet report_exception = L.report_exception\n\nlet of_lexbuf (lexbuf : Lexing.lexbuf) =\n {\n loc_start = lexbuf.lex_start_p;\n loc_end = lexbuf.lex_curr_p;\n loc_ghost = false;\n }\n\nlet print ppf t =\n Caml.Format.fprintf ppf \"File \\\"%s\\\", line %d, characters %d-%d:\"\n t.loc_start.pos_fname t.loc_start.pos_lnum\n (t.loc_start.pos_cnum - t.loc_start.pos_bol)\n (t.loc_end.pos_cnum - t.loc_start.pos_bol)\n\ntype nonrec 'a loc = 'a loc = { txt : 'a; loc : t }\n\nlet compare_pos p1 p2 =\n let open Lexing in\n let column p =\n (* Manual extract:\n The difference between pos_cnum and pos_bol is the character offset\n within the line (i.e. the column number, assuming each character is\n one column wide). *)\n p.pos_cnum - p.pos_bol\n in\n match Int.compare p1.pos_lnum p2.pos_lnum with\n | 0 -> Int.compare (column p1) (column p2)\n | n -> n\n\nlet min_pos p1 p2 = if compare_pos p1 p2 <= 0 then p1 else p2\nlet max_pos p1 p2 = if compare_pos p1 p2 >= 0 then p1 else p2\n\nlet compare loc1 loc2 =\n match compare_pos loc1.loc_start loc2.loc_start with\n | 0 -> compare_pos loc1.loc_end loc2.loc_end\n | n -> n\n\nmodule Error = struct\n include Ppxlib_ast.Location_error\n\n let createf ~loc fmt = Format.kasprintf (fun str -> make ~loc ~sub:[] str) fmt\nend\n\nlet error_extensionf ~loc fmt =\n Format.kasprintf\n (fun str -> Error.to_extension @@ Error.make ~loc ~sub:[] str)\n fmt\n\nexception Error = L.Error\n\nlet () =\n Caml.Printexc.register_printer (function\n | Error e -> Some (Error.message e)\n | _ -> None)\n","open Import\n\ntype t = Astlib.Location.Error.t\n\nlet to_extension (error : Astlib.Location.Error.t) =\n let open Astlib.Location.Error in\n let open Ast_helper in\n if not (is_well_formed error) then\n raise (Invalid_argument \"to_extension: expected kind Report_error\");\n let sub_msgs = sub_msgs error in\n let main_msg = main_msg error in\n let err_extension_name loc = { Location.loc; txt = \"ocaml.error\" } in\n let mk_string_constant x = Str.eval (Exp.constant (Const.string x)) in\n let extension_of_sub_msg (sub_msg : string Location.loc) =\n Str.extension\n (err_extension_name sub_msg.loc, PStr [ mk_string_constant sub_msg.txt ])\n in\n ( err_extension_name main_msg.loc,\n Parsetree.PStr\n (mk_string_constant main_msg.txt :: List.map extension_of_sub_msg sub_msgs)\n )\n\nlet register_error_of_exn = Astlib.Location.register_error_of_exn\n\nlet message error =\n let { Astlib.Location.txt; _ } = Astlib.Location.Error.main_msg error in\n txt\n\nlet set_message = Astlib.Location.Error.set_main_msg\n\nlet make ~loc txt ~sub =\n let sub = List.map (fun (loc, txt) -> { Astlib.Location.loc; txt }) sub in\n Astlib.Location.Error.make ~sub { loc; txt }\n\nlet update_loc = Astlib.Location.Error.set_main_loc\n\nlet get_location error =\n let { Astlib.Location.loc; _ } = Astlib.Location.Error.main_msg error in\n loc\n\nlet of_exn = Astlib.Location.Error.of_exn\nlet raise error = raise (Astlib.Location.Error error)\n","module Base = struct\n type t = { tool_name : string; code_path : Code_path.t; input_name : string }\n\n let top_level ~tool_name ~file_path ~input_name =\n let code_path = Code_path.top_level ~file_path in\n { tool_name; code_path; input_name }\n\n let code_path t = t.code_path\n let input_name t = t.input_name\n let tool_name t = t.tool_name\n let enter_expr t = { t with code_path = Code_path.enter_expr t.code_path }\n\n let enter_module ~loc name t =\n { t with code_path = Code_path.enter_module ~loc name t.code_path }\n\n let enter_value ~loc name t =\n { t with code_path = Code_path.enter_value ~loc name t.code_path }\nend\n\nmodule Extension = struct\n type t = { extension_point_loc : Location.t; base : Base.t }\n\n let make ~extension_point_loc ~base () = { extension_point_loc; base }\n let extension_point_loc t = t.extension_point_loc\n let code_path t = t.base.code_path\n let input_name t = t.base.input_name\n let tool_name t = t.base.tool_name\n\n let with_loc_and_path f ~ctxt =\n f ~loc:ctxt.extension_point_loc\n ~path:(Code_path.to_string_path ctxt.base.code_path)\nend\n\nmodule Deriver = struct\n type t = { derived_item_loc : Location.t; inline : bool; base : Base.t }\n\n let make ~derived_item_loc ~inline ~base () =\n { derived_item_loc; base; inline }\n\n let derived_item_loc t = t.derived_item_loc\n let code_path t = t.base.code_path\n let input_name t = t.base.input_name\n let tool_name t = t.base.tool_name\n let inline t = t.inline\n\n let with_loc_and_path f ~ctxt =\n f ~loc:ctxt.derived_item_loc\n ~path:(Code_path.to_string_path ctxt.base.code_path)\nend\n","open! Import\n\nclass map =\n object\n inherit Ppxlib_traverse_builtins.map\n inherit Ast.map\n end\n\nclass iter =\n object\n inherit Ppxlib_traverse_builtins.iter\n inherit Ast.iter\n end\n\nclass ['acc] fold =\n object\n inherit ['acc] Ppxlib_traverse_builtins.fold\n inherit ['acc] Ast.fold\n end\n\nclass ['acc] fold_map =\n object\n inherit ['acc] Ppxlib_traverse_builtins.fold_map\n inherit ['acc] Ast.fold_map\n end\n\nclass ['ctx] map_with_context =\n object\n inherit ['ctx] Ppxlib_traverse_builtins.map_with_context\n inherit ['ctx] Ast.map_with_context\n end\n\nclass virtual ['res] lift =\n object\n inherit ['res] Ppxlib_traverse_builtins.lift\n inherit ['res] Ast.lift\n end\n\nlet module_name = function None -> \"_\" | Some name -> name\nlet enter name path = if String.is_empty path then name else path ^ \".\" ^ name\nlet enter_opt name_opt path = enter (module_name name_opt) path\n\nclass map_with_path =\n object\n inherit [string] map_with_context as super\n\n (* WAS:\n method! structure_item_desc path x =\n match x with\n | Pstr_module mb -> super#structure_item_desc (enter mb.pmb_name.txt path) x\n | _ -> super#structure_item_desc path x\n\n Overriding [module_binding] seems to be OK because it does not catch\n local module bindings because at the moment the parsetree doesn't make\n use of [module_binding] for local modules, but that might change in the\n future, so this might be something to keep in mind.\n\n The following:\n\n module A = struct .. end\n module A = struct .. end\n\n is disallowed, but\n\n let _ = .. let module A = struct .. end in ..\n module A = struct .. end\n let _ = .. let module A = struct .. end in ..\n\n isn't, and the \"path\" constructed here would be able to differentiate\n between them. *)\n method! module_binding path mb =\n super#module_binding (enter_opt mb.pmb_name.txt path) mb\n\n method! module_declaration path md =\n super#module_declaration (enter_opt md.pmd_name.txt path) md\n\n method! module_type_declaration path mtd =\n super#module_type_declaration (enter mtd.pmtd_name.txt path) mtd\n end\n\nlet var_names_of =\n object\n inherit [string list] fold as super\n\n method! pattern p acc =\n let acc = super#pattern p acc in\n match p.ppat_desc with Ppat_var { txt; _ } -> txt :: acc | _ -> acc\n end\n\nlet ec_enter_module_opt ~loc name_opt ctxt =\n Expansion_context.Base.enter_module ~loc (module_name name_opt) ctxt\n\nclass map_with_expansion_context =\n object (self)\n inherit [Expansion_context.Base.t] map_with_context as super\n\n method! expression ctxt expr =\n super#expression (Expansion_context.Base.enter_expr ctxt) expr\n\n method! module_binding ctxt mb =\n super#module_binding\n (ec_enter_module_opt ~loc:mb.pmb_loc mb.pmb_name.txt ctxt)\n mb\n\n method! module_declaration ctxt md =\n super#module_declaration\n (ec_enter_module_opt ~loc:md.pmd_loc md.pmd_name.txt ctxt)\n md\n\n method! module_type_declaration ctxt mtd =\n super#module_type_declaration\n (Expansion_context.Base.enter_module ~loc:mtd.pmtd_loc mtd.pmtd_name.txt\n ctxt)\n mtd\n\n method! value_description ctxt vd =\n super#value_description\n (Expansion_context.Base.enter_value ~loc:vd.pval_loc vd.pval_name.txt\n ctxt)\n vd\n\n method! value_binding ctxt { pvb_pat; pvb_expr; pvb_attributes; pvb_loc } =\n let all_var_names = var_names_of#pattern pvb_pat [] in\n let var_name = Stdppx.List.last all_var_names in\n let in_binding_ctxt =\n match var_name with\n | None -> ctxt\n | Some var_name ->\n Expansion_context.Base.enter_value ~loc:pvb_loc var_name ctxt\n in\n let pvb_pat = self#pattern ctxt pvb_pat in\n let pvb_expr = self#expression in_binding_ctxt pvb_expr in\n let pvb_attributes = self#attributes in_binding_ctxt pvb_attributes in\n let pvb_loc = self#location ctxt pvb_loc in\n { pvb_pat; pvb_expr; pvb_attributes; pvb_loc }\n end\n\nclass sexp_of =\n object\n inherit [Sexp.t] Ast.lift\n method int = sexp_of_int\n method string = sexp_of_string\n method bool = sexp_of_bool\n method char = sexp_of_char\n method float = sexp_of_float\n method int32 = sexp_of_int32\n method int64 = sexp_of_int64\n method nativeint = sexp_of_nativeint\n method unit = sexp_of_unit\n method option = sexp_of_option\n method list = sexp_of_list\n method array : 'a. ('a -> Sexp.t) -> 'a array -> Sexp.t = sexp_of_array\n method other : 'a. 'a -> Sexp.t = fun _ -> Sexp.Atom \"_\"\n\n method record fields =\n List\n (List.map fields ~f:(fun (label, sexp) ->\n Sexp.List [ Atom label; sexp ]))\n\n method constr tag args =\n match args with [] -> Atom tag | _ -> List (Atom tag :: args)\n\n method tuple l = List l\n end\n\nlet sexp_of = new sexp_of\n","open! Import\n\nexception Cutoff_met\n\n(* As found here http://rosettacode.org/wiki/Levenshtein_distance#OCaml *)\nlet levenshtein_distance s t cutoff =\n let m = String.length s and n = String.length t in\n if cutoff = 0 || abs (m - n) >= cutoff then None\n else\n (* for all i and j, d.(i).(j) will hold the Levenshtein distance between the\n first i characters of s and the first j characters of t *)\n let d = Array.make_matrix ~dimx:(m + 1) ~dimy:(n + 1) 0 in\n for i = 0 to m do\n (* the distance of any first string to an empty second string *)\n d.(i).(0) <- i\n done;\n for j = 0 to n do\n (* the distance of any second string to an empty first string *)\n d.(0).(j) <- j\n done;\n (* the minimum of each line together with the column index will be used\n to notice cutoff exceeding and return early in that case *)\n let line_min = ref 0 in\n let distance =\n try\n for j = 1 to n do\n if !line_min >= cutoff - 1 && j >= cutoff - 1 then raise Cutoff_met;\n line_min := max m n;\n for i = 1 to m do\n let value =\n if Char.equal s.[i - 1] t.[j - 1] then d.(i - 1).(j - 1)\n (* no operation required *)\n else\n min\n (d.(i - 1).(j) + 1) (* a deletion *)\n (min\n (d.(i).(j - 1) + 1) (* an insertion *)\n (d.(i - 1).(j - 1) + 1) (* a substitution *))\n in\n d.(i).(j) <- value;\n line_min := min !line_min value\n done\n done;\n if d.(m).(n) < cutoff then Some d.(m).(n) else None\n with Cutoff_met -> None\n in\n distance\n\nlet spellcheck names name =\n let cutoff =\n match String.length name with\n | 1 | 2 -> 0\n | 3 | 4 -> 1\n | 5 | 6 -> 2\n | _ -> 3\n in\n let _, suggestions =\n List.fold_left names ~init:(Int.max_int, [])\n ~f:(fun ((best_distance, names_at_best_distance) as acc) registered_name\n ->\n match levenshtein_distance name registered_name cutoff with\n | None -> acc\n | Some dist ->\n if dist < best_distance then (dist, [ registered_name ])\n else if dist > best_distance then acc\n else (dist, registered_name :: names_at_best_distance))\n in\n match List.rev suggestions |> List.filter ~f:(String.( <> ) name) with\n | [] -> None\n | last :: rev_rest ->\n Some\n (Printf.sprintf \"Hint: Did you mean %s%s%s?\"\n (String.concat ~sep:\", \" (List.rev rev_rest))\n (if List.is_empty rev_rest then \"\" else \" or \")\n last)\n","open! Import\n\nexception Expected of Location.t * string\n\nlet fail loc expected = raise (Expected (loc, expected))\n\ntype context = {\n (* [matched] counts how many constructors have been matched. This is used to find what\n pattern matches the most some piece of ast in [Ast_pattern.alt]. In the case where\n all branches fail to match, we report the error from the one that matches the\n most.\n\n This is only incremented by combinators that can fail. *)\n mutable matched : int;\n}\n\ntype ('matched_value, 'k, 'k_result) t =\n | T of (context -> Location.t -> 'matched_value -> 'k -> 'k_result)\n","open Import\nmodule M =\n struct\n let attribute ~loc ~name ~payload =\n { attr_name = name; attr_payload = payload; attr_loc = loc }\n let binding_op ~loc ~op ~pat ~exp =\n { pbop_op = op; pbop_pat = pat; pbop_exp = exp; pbop_loc = loc }\n let case ~lhs ~guard ~rhs =\n { pc_lhs = lhs; pc_guard = guard; pc_rhs = rhs }\n let pcl_constr ~loc x0 x1 =\n { pcl_attributes = []; pcl_loc = loc; pcl_desc = (Pcl_constr (x0, x1))\n }\n let pcl_structure ~loc x0 =\n { pcl_attributes = []; pcl_loc = loc; pcl_desc = (Pcl_structure x0) }\n let pcl_fun ~loc x0 x1 x2 x3 =\n {\n pcl_attributes = [];\n pcl_loc = loc;\n pcl_desc = (Pcl_fun (x0, x1, x2, x3))\n }\n let pcl_apply ~loc x0 x1 =\n { pcl_attributes = []; pcl_loc = loc; pcl_desc = (Pcl_apply (x0, x1)) }\n let pcl_let ~loc x0 x1 x2 =\n { pcl_attributes = []; pcl_loc = loc; pcl_desc = (Pcl_let (x0, x1, x2))\n }\n let pcl_constraint ~loc x0 x1 =\n {\n pcl_attributes = [];\n pcl_loc = loc;\n pcl_desc = (Pcl_constraint (x0, x1))\n }\n let pcl_extension ~loc x0 =\n { pcl_attributes = []; pcl_loc = loc; pcl_desc = (Pcl_extension x0) }\n let pcl_open ~loc x0 x1 =\n { pcl_attributes = []; pcl_loc = loc; pcl_desc = (Pcl_open (x0, x1)) }\n let pcf_inherit ~loc x0 x1 x2 =\n {\n pcf_attributes = [];\n pcf_loc = loc;\n pcf_desc = (Pcf_inherit (x0, x1, x2))\n }\n let pcf_val ~loc x0 =\n { pcf_attributes = []; pcf_loc = loc; pcf_desc = (Pcf_val x0) }\n let pcf_method ~loc x0 =\n { pcf_attributes = []; pcf_loc = loc; pcf_desc = (Pcf_method x0) }\n let pcf_constraint ~loc x0 =\n { pcf_attributes = []; pcf_loc = loc; pcf_desc = (Pcf_constraint x0) }\n let pcf_initializer ~loc x0 =\n { pcf_attributes = []; pcf_loc = loc; pcf_desc = (Pcf_initializer x0) }\n let pcf_attribute ~loc x0 =\n { pcf_attributes = []; pcf_loc = loc; pcf_desc = (Pcf_attribute x0) }\n let pcf_extension ~loc x0 =\n { pcf_attributes = []; pcf_loc = loc; pcf_desc = (Pcf_extension x0) }\n let class_infos ~loc ~virt ~params ~name ~expr =\n {\n pci_virt = virt;\n pci_params = params;\n pci_name = name;\n pci_expr = expr;\n pci_loc = loc;\n pci_attributes = []\n }\n let class_signature ~self ~fields =\n { pcsig_self = self; pcsig_fields = fields }\n let class_structure ~self ~fields =\n { pcstr_self = self; pcstr_fields = fields }\n let pcty_constr ~loc x0 x1 =\n {\n pcty_attributes = [];\n pcty_loc = loc;\n pcty_desc = (Pcty_constr (x0, x1))\n }\n let pcty_signature ~loc x0 =\n { pcty_attributes = []; pcty_loc = loc; pcty_desc = (Pcty_signature x0)\n }\n let pcty_arrow ~loc x0 x1 x2 =\n {\n pcty_attributes = [];\n pcty_loc = loc;\n pcty_desc = (Pcty_arrow (x0, x1, x2))\n }\n let pcty_extension ~loc x0 =\n { pcty_attributes = []; pcty_loc = loc; pcty_desc = (Pcty_extension x0)\n }\n let pcty_open ~loc x0 x1 =\n {\n pcty_attributes = [];\n pcty_loc = loc;\n pcty_desc = (Pcty_open (x0, x1))\n }\n let pctf_inherit ~loc x0 =\n { pctf_attributes = []; pctf_loc = loc; pctf_desc = (Pctf_inherit x0) }\n let pctf_val ~loc x0 =\n { pctf_attributes = []; pctf_loc = loc; pctf_desc = (Pctf_val x0) }\n let pctf_method ~loc x0 =\n { pctf_attributes = []; pctf_loc = loc; pctf_desc = (Pctf_method x0) }\n let pctf_constraint ~loc x0 =\n {\n pctf_attributes = [];\n pctf_loc = loc;\n pctf_desc = (Pctf_constraint x0)\n }\n let pctf_attribute ~loc x0 =\n { pctf_attributes = []; pctf_loc = loc; pctf_desc = (Pctf_attribute x0)\n }\n let pctf_extension ~loc x0 =\n { pctf_attributes = []; pctf_loc = loc; pctf_desc = (Pctf_extension x0)\n }\n let constructor_declaration ~loc ~name ~args ~res =\n {\n pcd_name = name;\n pcd_args = args;\n pcd_res = res;\n pcd_loc = loc;\n pcd_attributes = []\n }\n let ptyp_any ~loc =\n {\n ptyp_loc_stack = [];\n ptyp_attributes = [];\n ptyp_loc = loc;\n ptyp_desc = Ptyp_any\n }\n let ptyp_var ~loc x0 =\n {\n ptyp_loc_stack = [];\n ptyp_attributes = [];\n ptyp_loc = loc;\n ptyp_desc = (Ptyp_var x0)\n }\n let ptyp_arrow ~loc x0 x1 x2 =\n {\n ptyp_loc_stack = [];\n ptyp_attributes = [];\n ptyp_loc = loc;\n ptyp_desc = (Ptyp_arrow (x0, x1, x2))\n }\n let ptyp_tuple ~loc x0 =\n {\n ptyp_loc_stack = [];\n ptyp_attributes = [];\n ptyp_loc = loc;\n ptyp_desc = (Ptyp_tuple x0)\n }\n let ptyp_constr ~loc x0 x1 =\n {\n ptyp_loc_stack = [];\n ptyp_attributes = [];\n ptyp_loc = loc;\n ptyp_desc = (Ptyp_constr (x0, x1))\n }\n let ptyp_object ~loc x0 x1 =\n {\n ptyp_loc_stack = [];\n ptyp_attributes = [];\n ptyp_loc = loc;\n ptyp_desc = (Ptyp_object (x0, x1))\n }\n let ptyp_class ~loc x0 x1 =\n {\n ptyp_loc_stack = [];\n ptyp_attributes = [];\n ptyp_loc = loc;\n ptyp_desc = (Ptyp_class (x0, x1))\n }\n let ptyp_alias ~loc x0 x1 =\n {\n ptyp_loc_stack = [];\n ptyp_attributes = [];\n ptyp_loc = loc;\n ptyp_desc = (Ptyp_alias (x0, x1))\n }\n let ptyp_variant ~loc x0 x1 x2 =\n {\n ptyp_loc_stack = [];\n ptyp_attributes = [];\n ptyp_loc = loc;\n ptyp_desc = (Ptyp_variant (x0, x1, x2))\n }\n let ptyp_poly ~loc x0 x1 =\n {\n ptyp_loc_stack = [];\n ptyp_attributes = [];\n ptyp_loc = loc;\n ptyp_desc = (Ptyp_poly (x0, x1))\n }\n let ptyp_package ~loc x0 =\n {\n ptyp_loc_stack = [];\n ptyp_attributes = [];\n ptyp_loc = loc;\n ptyp_desc = (Ptyp_package x0)\n }\n let ptyp_extension ~loc x0 =\n {\n ptyp_loc_stack = [];\n ptyp_attributes = [];\n ptyp_loc = loc;\n ptyp_desc = (Ptyp_extension x0)\n }\n let pdir_string ~loc x0 =\n { pdira_loc = loc; pdira_desc = (Pdir_string x0) }\n let pdir_int ~loc x0 x1 =\n { pdira_loc = loc; pdira_desc = (Pdir_int (x0, x1)) }\n let pdir_ident ~loc x0 =\n { pdira_loc = loc; pdira_desc = (Pdir_ident x0) }\n let pdir_bool ~loc x0 = { pdira_loc = loc; pdira_desc = (Pdir_bool x0) }\n let pexp_ident ~loc x0 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_ident x0)\n }\n let pexp_constant ~loc x0 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_constant x0)\n }\n let pexp_let ~loc x0 x1 x2 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_let (x0, x1, x2))\n }\n let pexp_function ~loc x0 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_function x0)\n }\n let pexp_fun ~loc x0 x1 x2 x3 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_fun (x0, x1, x2, x3))\n }\n let pexp_apply ~loc x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_apply (x0, x1))\n }\n let pexp_match ~loc x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_match (x0, x1))\n }\n let pexp_try ~loc x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_try (x0, x1))\n }\n let pexp_tuple ~loc x0 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_tuple x0)\n }\n let pexp_construct ~loc x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_construct (x0, x1))\n }\n let pexp_variant ~loc x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_variant (x0, x1))\n }\n let pexp_record ~loc x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_record (x0, x1))\n }\n let pexp_field ~loc x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_field (x0, x1))\n }\n let pexp_setfield ~loc x0 x1 x2 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_setfield (x0, x1, x2))\n }\n let pexp_array ~loc x0 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_array x0)\n }\n let pexp_ifthenelse ~loc x0 x1 x2 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_ifthenelse (x0, x1, x2))\n }\n let pexp_sequence ~loc x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_sequence (x0, x1))\n }\n let pexp_while ~loc x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_while (x0, x1))\n }\n let pexp_for ~loc x0 x1 x2 x3 x4 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_for (x0, x1, x2, x3, x4))\n }\n let pexp_constraint ~loc x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_constraint (x0, x1))\n }\n let pexp_coerce ~loc x0 x1 x2 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_coerce (x0, x1, x2))\n }\n let pexp_send ~loc x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_send (x0, x1))\n }\n let pexp_new ~loc x0 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_new x0)\n }\n let pexp_setinstvar ~loc x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_setinstvar (x0, x1))\n }\n let pexp_override ~loc x0 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_override x0)\n }\n let pexp_letmodule ~loc x0 x1 x2 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_letmodule (x0, x1, x2))\n }\n let pexp_letexception ~loc x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_letexception (x0, x1))\n }\n let pexp_assert ~loc x0 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_assert x0)\n }\n let pexp_lazy ~loc x0 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_lazy x0)\n }\n let pexp_poly ~loc x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_poly (x0, x1))\n }\n let pexp_object ~loc x0 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_object x0)\n }\n let pexp_newtype ~loc x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_newtype (x0, x1))\n }\n let pexp_pack ~loc x0 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_pack x0)\n }\n let pexp_open ~loc x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_open (x0, x1))\n }\n let pexp_letop ~loc x0 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_letop x0)\n }\n let pexp_extension ~loc x0 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_extension x0)\n }\n let pexp_unreachable ~loc =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = Pexp_unreachable\n }\n let extension_constructor ~loc ~name ~kind =\n {\n pext_name = name;\n pext_kind = kind;\n pext_loc = loc;\n pext_attributes = []\n }\n let include_infos ~loc mod_ =\n { pincl_mod = mod_; pincl_loc = loc; pincl_attributes = [] }\n let label_declaration ~loc ~name ~mutable_ ~type_ =\n {\n pld_name = name;\n pld_mutable = mutable_;\n pld_type = type_;\n pld_loc = loc;\n pld_attributes = []\n }\n let letop ~let_ ~ands ~body = { let_; ands; body }\n let location ~start ~end_ ~ghost =\n { loc_start = start; loc_end = end_; loc_ghost = ghost }\n let module_binding ~loc ~name ~expr =\n { pmb_name = name; pmb_expr = expr; pmb_attributes = []; pmb_loc = loc\n }\n let module_declaration ~loc ~name ~type_ =\n { pmd_name = name; pmd_type = type_; pmd_attributes = []; pmd_loc = loc\n }\n let pmod_ident ~loc x0 =\n { pmod_attributes = []; pmod_loc = loc; pmod_desc = (Pmod_ident x0) }\n let pmod_structure ~loc x0 =\n { pmod_attributes = []; pmod_loc = loc; pmod_desc = (Pmod_structure x0)\n }\n let pmod_functor ~loc x0 x1 =\n {\n pmod_attributes = [];\n pmod_loc = loc;\n pmod_desc = (Pmod_functor (x0, x1))\n }\n let pmod_apply ~loc x0 x1 =\n {\n pmod_attributes = [];\n pmod_loc = loc;\n pmod_desc = (Pmod_apply (x0, x1))\n }\n let pmod_constraint ~loc x0 x1 =\n {\n pmod_attributes = [];\n pmod_loc = loc;\n pmod_desc = (Pmod_constraint (x0, x1))\n }\n let pmod_unpack ~loc x0 =\n { pmod_attributes = []; pmod_loc = loc; pmod_desc = (Pmod_unpack x0) }\n let pmod_extension ~loc x0 =\n { pmod_attributes = []; pmod_loc = loc; pmod_desc = (Pmod_extension x0)\n }\n let module_substitution ~loc ~name ~manifest =\n {\n pms_name = name;\n pms_manifest = manifest;\n pms_attributes = [];\n pms_loc = loc\n }\n let pmty_ident ~loc x0 =\n { pmty_attributes = []; pmty_loc = loc; pmty_desc = (Pmty_ident x0) }\n let pmty_signature ~loc x0 =\n { pmty_attributes = []; pmty_loc = loc; pmty_desc = (Pmty_signature x0)\n }\n let pmty_functor ~loc x0 x1 =\n {\n pmty_attributes = [];\n pmty_loc = loc;\n pmty_desc = (Pmty_functor (x0, x1))\n }\n let pmty_with ~loc x0 x1 =\n {\n pmty_attributes = [];\n pmty_loc = loc;\n pmty_desc = (Pmty_with (x0, x1))\n }\n let pmty_typeof ~loc x0 =\n { pmty_attributes = []; pmty_loc = loc; pmty_desc = (Pmty_typeof x0) }\n let pmty_extension ~loc x0 =\n { pmty_attributes = []; pmty_loc = loc; pmty_desc = (Pmty_extension x0)\n }\n let pmty_alias ~loc x0 =\n { pmty_attributes = []; pmty_loc = loc; pmty_desc = (Pmty_alias x0) }\n let module_type_declaration ~loc ~name ~type_ =\n {\n pmtd_name = name;\n pmtd_type = type_;\n pmtd_attributes = [];\n pmtd_loc = loc\n }\n let otag ~loc x0 x1 =\n { pof_attributes = []; pof_loc = loc; pof_desc = (Otag (x0, x1)) }\n let oinherit ~loc x0 =\n { pof_attributes = []; pof_loc = loc; pof_desc = (Oinherit x0) }\n let open_infos ~loc ~expr ~override =\n {\n popen_expr = expr;\n popen_override = override;\n popen_loc = loc;\n popen_attributes = []\n }\n let ppat_any ~loc =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = Ppat_any\n }\n let ppat_var ~loc x0 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_var x0)\n }\n let ppat_alias ~loc x0 x1 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_alias (x0, x1))\n }\n let ppat_constant ~loc x0 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_constant x0)\n }\n let ppat_interval ~loc x0 x1 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_interval (x0, x1))\n }\n let ppat_tuple ~loc x0 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_tuple x0)\n }\n let ppat_construct ~loc x0 x1 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_construct (x0, x1))\n }\n let ppat_variant ~loc x0 x1 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_variant (x0, x1))\n }\n let ppat_record ~loc x0 x1 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_record (x0, x1))\n }\n let ppat_array ~loc x0 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_array x0)\n }\n let ppat_or ~loc x0 x1 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_or (x0, x1))\n }\n let ppat_constraint ~loc x0 x1 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_constraint (x0, x1))\n }\n let ppat_type ~loc x0 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_type x0)\n }\n let ppat_lazy ~loc x0 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_lazy x0)\n }\n let ppat_unpack ~loc x0 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_unpack x0)\n }\n let ppat_exception ~loc x0 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_exception x0)\n }\n let ppat_extension ~loc x0 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_extension x0)\n }\n let ppat_open ~loc x0 x1 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_open (x0, x1))\n }\n let position ~fname ~lnum ~bol ~cnum =\n { pos_fname = fname; pos_lnum = lnum; pos_bol = bol; pos_cnum = cnum }\n let rtag ~loc x0 x1 x2 =\n { prf_attributes = []; prf_loc = loc; prf_desc = (Rtag (x0, x1, x2)) }\n let rinherit ~loc x0 =\n { prf_attributes = []; prf_loc = loc; prf_desc = (Rinherit x0) }\n let psig_value ~loc x0 = { psig_loc = loc; psig_desc = (Psig_value x0) }\n let psig_type ~loc x0 x1 =\n { psig_loc = loc; psig_desc = (Psig_type (x0, x1)) }\n let psig_typesubst ~loc x0 =\n { psig_loc = loc; psig_desc = (Psig_typesubst x0) }\n let psig_typext ~loc x0 =\n { psig_loc = loc; psig_desc = (Psig_typext x0) }\n let psig_exception ~loc x0 =\n { psig_loc = loc; psig_desc = (Psig_exception x0) }\n let psig_module ~loc x0 =\n { psig_loc = loc; psig_desc = (Psig_module x0) }\n let psig_modsubst ~loc x0 =\n { psig_loc = loc; psig_desc = (Psig_modsubst x0) }\n let psig_recmodule ~loc x0 =\n { psig_loc = loc; psig_desc = (Psig_recmodule x0) }\n let psig_modtype ~loc x0 =\n { psig_loc = loc; psig_desc = (Psig_modtype x0) }\n let psig_open ~loc x0 = { psig_loc = loc; psig_desc = (Psig_open x0) }\n let psig_include ~loc x0 =\n { psig_loc = loc; psig_desc = (Psig_include x0) }\n let psig_class ~loc x0 = { psig_loc = loc; psig_desc = (Psig_class x0) }\n let psig_class_type ~loc x0 =\n { psig_loc = loc; psig_desc = (Psig_class_type x0) }\n let psig_attribute ~loc x0 =\n { psig_loc = loc; psig_desc = (Psig_attribute x0) }\n let psig_extension ~loc x0 x1 =\n { psig_loc = loc; psig_desc = (Psig_extension (x0, x1)) }\n let pstr_eval ~loc x0 x1 =\n { pstr_loc = loc; pstr_desc = (Pstr_eval (x0, x1)) }\n let pstr_value ~loc x0 x1 =\n { pstr_loc = loc; pstr_desc = (Pstr_value (x0, x1)) }\n let pstr_primitive ~loc x0 =\n { pstr_loc = loc; pstr_desc = (Pstr_primitive x0) }\n let pstr_type ~loc x0 x1 =\n { pstr_loc = loc; pstr_desc = (Pstr_type (x0, x1)) }\n let pstr_typext ~loc x0 =\n { pstr_loc = loc; pstr_desc = (Pstr_typext x0) }\n let pstr_exception ~loc x0 =\n { pstr_loc = loc; pstr_desc = (Pstr_exception x0) }\n let pstr_module ~loc x0 =\n { pstr_loc = loc; pstr_desc = (Pstr_module x0) }\n let pstr_recmodule ~loc x0 =\n { pstr_loc = loc; pstr_desc = (Pstr_recmodule x0) }\n let pstr_modtype ~loc x0 =\n { pstr_loc = loc; pstr_desc = (Pstr_modtype x0) }\n let pstr_open ~loc x0 = { pstr_loc = loc; pstr_desc = (Pstr_open x0) }\n let pstr_class ~loc x0 = { pstr_loc = loc; pstr_desc = (Pstr_class x0) }\n let pstr_class_type ~loc x0 =\n { pstr_loc = loc; pstr_desc = (Pstr_class_type x0) }\n let pstr_include ~loc x0 =\n { pstr_loc = loc; pstr_desc = (Pstr_include x0) }\n let pstr_attribute ~loc x0 =\n { pstr_loc = loc; pstr_desc = (Pstr_attribute x0) }\n let pstr_extension ~loc x0 x1 =\n { pstr_loc = loc; pstr_desc = (Pstr_extension (x0, x1)) }\n let toplevel_directive ~loc ~name ~arg =\n { pdir_name = name; pdir_arg = arg; pdir_loc = loc }\n let type_declaration ~loc ~name ~params ~cstrs ~kind ~private_ \n ~manifest =\n {\n ptype_name = name;\n ptype_params = params;\n ptype_cstrs = cstrs;\n ptype_kind = kind;\n ptype_private = private_;\n ptype_manifest = manifest;\n ptype_attributes = [];\n ptype_loc = loc\n }\n let type_exception ~loc constructor =\n {\n ptyexn_constructor = constructor;\n ptyexn_loc = loc;\n ptyexn_attributes = []\n }\n let type_extension ~loc ~path ~params ~constructors ~private_ =\n {\n ptyext_path = path;\n ptyext_params = params;\n ptyext_constructors = constructors;\n ptyext_private = private_;\n ptyext_loc = loc;\n ptyext_attributes = []\n }\n let value_binding ~loc ~pat ~expr =\n { pvb_pat = pat; pvb_expr = expr; pvb_attributes = []; pvb_loc = loc }\n let value_description ~loc ~name ~type_ ~prim =\n {\n pval_name = name;\n pval_type = type_;\n pval_prim = prim;\n pval_attributes = [];\n pval_loc = loc\n }\n end\nmodule Make(Loc:sig val loc : Location.t end) =\n struct\n let loc = Loc.loc\n let attribute ~name ~payload =\n { attr_name = name; attr_payload = payload; attr_loc = loc }\n let binding_op ~op ~pat ~exp =\n { pbop_op = op; pbop_pat = pat; pbop_exp = exp; pbop_loc = loc }\n let case ~lhs ~guard ~rhs =\n { pc_lhs = lhs; pc_guard = guard; pc_rhs = rhs }\n let pcl_constr x0 x1 =\n { pcl_attributes = []; pcl_loc = loc; pcl_desc = (Pcl_constr (x0, x1))\n }\n let pcl_structure x0 =\n { pcl_attributes = []; pcl_loc = loc; pcl_desc = (Pcl_structure x0) }\n let pcl_fun x0 x1 x2 x3 =\n {\n pcl_attributes = [];\n pcl_loc = loc;\n pcl_desc = (Pcl_fun (x0, x1, x2, x3))\n }\n let pcl_apply x0 x1 =\n { pcl_attributes = []; pcl_loc = loc; pcl_desc = (Pcl_apply (x0, x1)) }\n let pcl_let x0 x1 x2 =\n { pcl_attributes = []; pcl_loc = loc; pcl_desc = (Pcl_let (x0, x1, x2))\n }\n let pcl_constraint x0 x1 =\n {\n pcl_attributes = [];\n pcl_loc = loc;\n pcl_desc = (Pcl_constraint (x0, x1))\n }\n let pcl_extension x0 =\n { pcl_attributes = []; pcl_loc = loc; pcl_desc = (Pcl_extension x0) }\n let pcl_open x0 x1 =\n { pcl_attributes = []; pcl_loc = loc; pcl_desc = (Pcl_open (x0, x1)) }\n let pcf_inherit x0 x1 x2 =\n {\n pcf_attributes = [];\n pcf_loc = loc;\n pcf_desc = (Pcf_inherit (x0, x1, x2))\n }\n let pcf_val x0 =\n { pcf_attributes = []; pcf_loc = loc; pcf_desc = (Pcf_val x0) }\n let pcf_method x0 =\n { pcf_attributes = []; pcf_loc = loc; pcf_desc = (Pcf_method x0) }\n let pcf_constraint x0 =\n { pcf_attributes = []; pcf_loc = loc; pcf_desc = (Pcf_constraint x0) }\n let pcf_initializer x0 =\n { pcf_attributes = []; pcf_loc = loc; pcf_desc = (Pcf_initializer x0) }\n let pcf_attribute x0 =\n { pcf_attributes = []; pcf_loc = loc; pcf_desc = (Pcf_attribute x0) }\n let pcf_extension x0 =\n { pcf_attributes = []; pcf_loc = loc; pcf_desc = (Pcf_extension x0) }\n let class_infos ~virt ~params ~name ~expr =\n {\n pci_virt = virt;\n pci_params = params;\n pci_name = name;\n pci_expr = expr;\n pci_loc = loc;\n pci_attributes = []\n }\n let class_signature ~self ~fields =\n { pcsig_self = self; pcsig_fields = fields }\n let class_structure ~self ~fields =\n { pcstr_self = self; pcstr_fields = fields }\n let pcty_constr x0 x1 =\n {\n pcty_attributes = [];\n pcty_loc = loc;\n pcty_desc = (Pcty_constr (x0, x1))\n }\n let pcty_signature x0 =\n { pcty_attributes = []; pcty_loc = loc; pcty_desc = (Pcty_signature x0)\n }\n let pcty_arrow x0 x1 x2 =\n {\n pcty_attributes = [];\n pcty_loc = loc;\n pcty_desc = (Pcty_arrow (x0, x1, x2))\n }\n let pcty_extension x0 =\n { pcty_attributes = []; pcty_loc = loc; pcty_desc = (Pcty_extension x0)\n }\n let pcty_open x0 x1 =\n {\n pcty_attributes = [];\n pcty_loc = loc;\n pcty_desc = (Pcty_open (x0, x1))\n }\n let pctf_inherit x0 =\n { pctf_attributes = []; pctf_loc = loc; pctf_desc = (Pctf_inherit x0) }\n let pctf_val x0 =\n { pctf_attributes = []; pctf_loc = loc; pctf_desc = (Pctf_val x0) }\n let pctf_method x0 =\n { pctf_attributes = []; pctf_loc = loc; pctf_desc = (Pctf_method x0) }\n let pctf_constraint x0 =\n {\n pctf_attributes = [];\n pctf_loc = loc;\n pctf_desc = (Pctf_constraint x0)\n }\n let pctf_attribute x0 =\n { pctf_attributes = []; pctf_loc = loc; pctf_desc = (Pctf_attribute x0)\n }\n let pctf_extension x0 =\n { pctf_attributes = []; pctf_loc = loc; pctf_desc = (Pctf_extension x0)\n }\n let constructor_declaration ~name ~args ~res =\n {\n pcd_name = name;\n pcd_args = args;\n pcd_res = res;\n pcd_loc = loc;\n pcd_attributes = []\n }\n let ptyp_any =\n {\n ptyp_loc_stack = [];\n ptyp_attributes = [];\n ptyp_loc = loc;\n ptyp_desc = Ptyp_any\n }\n let ptyp_var x0 =\n {\n ptyp_loc_stack = [];\n ptyp_attributes = [];\n ptyp_loc = loc;\n ptyp_desc = (Ptyp_var x0)\n }\n let ptyp_arrow x0 x1 x2 =\n {\n ptyp_loc_stack = [];\n ptyp_attributes = [];\n ptyp_loc = loc;\n ptyp_desc = (Ptyp_arrow (x0, x1, x2))\n }\n let ptyp_tuple x0 =\n {\n ptyp_loc_stack = [];\n ptyp_attributes = [];\n ptyp_loc = loc;\n ptyp_desc = (Ptyp_tuple x0)\n }\n let ptyp_constr x0 x1 =\n {\n ptyp_loc_stack = [];\n ptyp_attributes = [];\n ptyp_loc = loc;\n ptyp_desc = (Ptyp_constr (x0, x1))\n }\n let ptyp_object x0 x1 =\n {\n ptyp_loc_stack = [];\n ptyp_attributes = [];\n ptyp_loc = loc;\n ptyp_desc = (Ptyp_object (x0, x1))\n }\n let ptyp_class x0 x1 =\n {\n ptyp_loc_stack = [];\n ptyp_attributes = [];\n ptyp_loc = loc;\n ptyp_desc = (Ptyp_class (x0, x1))\n }\n let ptyp_alias x0 x1 =\n {\n ptyp_loc_stack = [];\n ptyp_attributes = [];\n ptyp_loc = loc;\n ptyp_desc = (Ptyp_alias (x0, x1))\n }\n let ptyp_variant x0 x1 x2 =\n {\n ptyp_loc_stack = [];\n ptyp_attributes = [];\n ptyp_loc = loc;\n ptyp_desc = (Ptyp_variant (x0, x1, x2))\n }\n let ptyp_poly x0 x1 =\n {\n ptyp_loc_stack = [];\n ptyp_attributes = [];\n ptyp_loc = loc;\n ptyp_desc = (Ptyp_poly (x0, x1))\n }\n let ptyp_package x0 =\n {\n ptyp_loc_stack = [];\n ptyp_attributes = [];\n ptyp_loc = loc;\n ptyp_desc = (Ptyp_package x0)\n }\n let ptyp_extension x0 =\n {\n ptyp_loc_stack = [];\n ptyp_attributes = [];\n ptyp_loc = loc;\n ptyp_desc = (Ptyp_extension x0)\n }\n let pdir_string x0 = { pdira_loc = loc; pdira_desc = (Pdir_string x0) }\n let pdir_int x0 x1 =\n { pdira_loc = loc; pdira_desc = (Pdir_int (x0, x1)) }\n let pdir_ident x0 = { pdira_loc = loc; pdira_desc = (Pdir_ident x0) }\n let pdir_bool x0 = { pdira_loc = loc; pdira_desc = (Pdir_bool x0) }\n let pexp_ident x0 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_ident x0)\n }\n let pexp_constant x0 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_constant x0)\n }\n let pexp_let x0 x1 x2 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_let (x0, x1, x2))\n }\n let pexp_function x0 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_function x0)\n }\n let pexp_fun x0 x1 x2 x3 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_fun (x0, x1, x2, x3))\n }\n let pexp_apply x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_apply (x0, x1))\n }\n let pexp_match x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_match (x0, x1))\n }\n let pexp_try x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_try (x0, x1))\n }\n let pexp_tuple x0 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_tuple x0)\n }\n let pexp_construct x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_construct (x0, x1))\n }\n let pexp_variant x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_variant (x0, x1))\n }\n let pexp_record x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_record (x0, x1))\n }\n let pexp_field x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_field (x0, x1))\n }\n let pexp_setfield x0 x1 x2 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_setfield (x0, x1, x2))\n }\n let pexp_array x0 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_array x0)\n }\n let pexp_ifthenelse x0 x1 x2 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_ifthenelse (x0, x1, x2))\n }\n let pexp_sequence x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_sequence (x0, x1))\n }\n let pexp_while x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_while (x0, x1))\n }\n let pexp_for x0 x1 x2 x3 x4 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_for (x0, x1, x2, x3, x4))\n }\n let pexp_constraint x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_constraint (x0, x1))\n }\n let pexp_coerce x0 x1 x2 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_coerce (x0, x1, x2))\n }\n let pexp_send x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_send (x0, x1))\n }\n let pexp_new x0 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_new x0)\n }\n let pexp_setinstvar x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_setinstvar (x0, x1))\n }\n let pexp_override x0 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_override x0)\n }\n let pexp_letmodule x0 x1 x2 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_letmodule (x0, x1, x2))\n }\n let pexp_letexception x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_letexception (x0, x1))\n }\n let pexp_assert x0 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_assert x0)\n }\n let pexp_lazy x0 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_lazy x0)\n }\n let pexp_poly x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_poly (x0, x1))\n }\n let pexp_object x0 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_object x0)\n }\n let pexp_newtype x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_newtype (x0, x1))\n }\n let pexp_pack x0 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_pack x0)\n }\n let pexp_open x0 x1 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_open (x0, x1))\n }\n let pexp_letop x0 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_letop x0)\n }\n let pexp_extension x0 =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = (Pexp_extension x0)\n }\n let pexp_unreachable =\n {\n pexp_loc_stack = [];\n pexp_attributes = [];\n pexp_loc = loc;\n pexp_desc = Pexp_unreachable\n }\n let extension_constructor ~name ~kind =\n {\n pext_name = name;\n pext_kind = kind;\n pext_loc = loc;\n pext_attributes = []\n }\n let include_infos mod_ =\n { pincl_mod = mod_; pincl_loc = loc; pincl_attributes = [] }\n let label_declaration ~name ~mutable_ ~type_ =\n {\n pld_name = name;\n pld_mutable = mutable_;\n pld_type = type_;\n pld_loc = loc;\n pld_attributes = []\n }\n let letop ~let_ ~ands ~body = { let_; ands; body }\n let location ~start ~end_ ~ghost =\n { loc_start = start; loc_end = end_; loc_ghost = ghost }\n let module_binding ~name ~expr =\n { pmb_name = name; pmb_expr = expr; pmb_attributes = []; pmb_loc = loc\n }\n let module_declaration ~name ~type_ =\n { pmd_name = name; pmd_type = type_; pmd_attributes = []; pmd_loc = loc\n }\n let pmod_ident x0 =\n { pmod_attributes = []; pmod_loc = loc; pmod_desc = (Pmod_ident x0) }\n let pmod_structure x0 =\n { pmod_attributes = []; pmod_loc = loc; pmod_desc = (Pmod_structure x0)\n }\n let pmod_functor x0 x1 =\n {\n pmod_attributes = [];\n pmod_loc = loc;\n pmod_desc = (Pmod_functor (x0, x1))\n }\n let pmod_apply x0 x1 =\n {\n pmod_attributes = [];\n pmod_loc = loc;\n pmod_desc = (Pmod_apply (x0, x1))\n }\n let pmod_constraint x0 x1 =\n {\n pmod_attributes = [];\n pmod_loc = loc;\n pmod_desc = (Pmod_constraint (x0, x1))\n }\n let pmod_unpack x0 =\n { pmod_attributes = []; pmod_loc = loc; pmod_desc = (Pmod_unpack x0) }\n let pmod_extension x0 =\n { pmod_attributes = []; pmod_loc = loc; pmod_desc = (Pmod_extension x0)\n }\n let module_substitution ~name ~manifest =\n {\n pms_name = name;\n pms_manifest = manifest;\n pms_attributes = [];\n pms_loc = loc\n }\n let pmty_ident x0 =\n { pmty_attributes = []; pmty_loc = loc; pmty_desc = (Pmty_ident x0) }\n let pmty_signature x0 =\n { pmty_attributes = []; pmty_loc = loc; pmty_desc = (Pmty_signature x0)\n }\n let pmty_functor x0 x1 =\n {\n pmty_attributes = [];\n pmty_loc = loc;\n pmty_desc = (Pmty_functor (x0, x1))\n }\n let pmty_with x0 x1 =\n {\n pmty_attributes = [];\n pmty_loc = loc;\n pmty_desc = (Pmty_with (x0, x1))\n }\n let pmty_typeof x0 =\n { pmty_attributes = []; pmty_loc = loc; pmty_desc = (Pmty_typeof x0) }\n let pmty_extension x0 =\n { pmty_attributes = []; pmty_loc = loc; pmty_desc = (Pmty_extension x0)\n }\n let pmty_alias x0 =\n { pmty_attributes = []; pmty_loc = loc; pmty_desc = (Pmty_alias x0) }\n let module_type_declaration ~name ~type_ =\n {\n pmtd_name = name;\n pmtd_type = type_;\n pmtd_attributes = [];\n pmtd_loc = loc\n }\n let otag x0 x1 =\n { pof_attributes = []; pof_loc = loc; pof_desc = (Otag (x0, x1)) }\n let oinherit x0 =\n { pof_attributes = []; pof_loc = loc; pof_desc = (Oinherit x0) }\n let open_infos ~expr ~override =\n {\n popen_expr = expr;\n popen_override = override;\n popen_loc = loc;\n popen_attributes = []\n }\n let ppat_any =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = Ppat_any\n }\n let ppat_var x0 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_var x0)\n }\n let ppat_alias x0 x1 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_alias (x0, x1))\n }\n let ppat_constant x0 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_constant x0)\n }\n let ppat_interval x0 x1 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_interval (x0, x1))\n }\n let ppat_tuple x0 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_tuple x0)\n }\n let ppat_construct x0 x1 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_construct (x0, x1))\n }\n let ppat_variant x0 x1 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_variant (x0, x1))\n }\n let ppat_record x0 x1 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_record (x0, x1))\n }\n let ppat_array x0 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_array x0)\n }\n let ppat_or x0 x1 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_or (x0, x1))\n }\n let ppat_constraint x0 x1 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_constraint (x0, x1))\n }\n let ppat_type x0 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_type x0)\n }\n let ppat_lazy x0 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_lazy x0)\n }\n let ppat_unpack x0 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_unpack x0)\n }\n let ppat_exception x0 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_exception x0)\n }\n let ppat_extension x0 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_extension x0)\n }\n let ppat_open x0 x1 =\n {\n ppat_loc_stack = [];\n ppat_attributes = [];\n ppat_loc = loc;\n ppat_desc = (Ppat_open (x0, x1))\n }\n let position ~fname ~lnum ~bol ~cnum =\n { pos_fname = fname; pos_lnum = lnum; pos_bol = bol; pos_cnum = cnum }\n let rtag x0 x1 x2 =\n { prf_attributes = []; prf_loc = loc; prf_desc = (Rtag (x0, x1, x2)) }\n let rinherit x0 =\n { prf_attributes = []; prf_loc = loc; prf_desc = (Rinherit x0) }\n let psig_value x0 = { psig_loc = loc; psig_desc = (Psig_value x0) }\n let psig_type x0 x1 =\n { psig_loc = loc; psig_desc = (Psig_type (x0, x1)) }\n let psig_typesubst x0 =\n { psig_loc = loc; psig_desc = (Psig_typesubst x0) }\n let psig_typext x0 = { psig_loc = loc; psig_desc = (Psig_typext x0) }\n let psig_exception x0 =\n { psig_loc = loc; psig_desc = (Psig_exception x0) }\n let psig_module x0 = { psig_loc = loc; psig_desc = (Psig_module x0) }\n let psig_modsubst x0 = { psig_loc = loc; psig_desc = (Psig_modsubst x0) }\n let psig_recmodule x0 =\n { psig_loc = loc; psig_desc = (Psig_recmodule x0) }\n let psig_modtype x0 = { psig_loc = loc; psig_desc = (Psig_modtype x0) }\n let psig_open x0 = { psig_loc = loc; psig_desc = (Psig_open x0) }\n let psig_include x0 = { psig_loc = loc; psig_desc = (Psig_include x0) }\n let psig_class x0 = { psig_loc = loc; psig_desc = (Psig_class x0) }\n let psig_class_type x0 =\n { psig_loc = loc; psig_desc = (Psig_class_type x0) }\n let psig_attribute x0 =\n { psig_loc = loc; psig_desc = (Psig_attribute x0) }\n let psig_extension x0 x1 =\n { psig_loc = loc; psig_desc = (Psig_extension (x0, x1)) }\n let pstr_eval x0 x1 =\n { pstr_loc = loc; pstr_desc = (Pstr_eval (x0, x1)) }\n let pstr_value x0 x1 =\n { pstr_loc = loc; pstr_desc = (Pstr_value (x0, x1)) }\n let pstr_primitive x0 =\n { pstr_loc = loc; pstr_desc = (Pstr_primitive x0) }\n let pstr_type x0 x1 =\n { pstr_loc = loc; pstr_desc = (Pstr_type (x0, x1)) }\n let pstr_typext x0 = { pstr_loc = loc; pstr_desc = (Pstr_typext x0) }\n let pstr_exception x0 =\n { pstr_loc = loc; pstr_desc = (Pstr_exception x0) }\n let pstr_module x0 = { pstr_loc = loc; pstr_desc = (Pstr_module x0) }\n let pstr_recmodule x0 =\n { pstr_loc = loc; pstr_desc = (Pstr_recmodule x0) }\n let pstr_modtype x0 = { pstr_loc = loc; pstr_desc = (Pstr_modtype x0) }\n let pstr_open x0 = { pstr_loc = loc; pstr_desc = (Pstr_open x0) }\n let pstr_class x0 = { pstr_loc = loc; pstr_desc = (Pstr_class x0) }\n let pstr_class_type x0 =\n { pstr_loc = loc; pstr_desc = (Pstr_class_type x0) }\n let pstr_include x0 = { pstr_loc = loc; pstr_desc = (Pstr_include x0) }\n let pstr_attribute x0 =\n { pstr_loc = loc; pstr_desc = (Pstr_attribute x0) }\n let pstr_extension x0 x1 =\n { pstr_loc = loc; pstr_desc = (Pstr_extension (x0, x1)) }\n let toplevel_directive ~name ~arg =\n { pdir_name = name; pdir_arg = arg; pdir_loc = loc }\n let type_declaration ~name ~params ~cstrs ~kind ~private_ ~manifest \n =\n {\n ptype_name = name;\n ptype_params = params;\n ptype_cstrs = cstrs;\n ptype_kind = kind;\n ptype_private = private_;\n ptype_manifest = manifest;\n ptype_attributes = [];\n ptype_loc = loc\n }\n let type_exception constructor =\n {\n ptyexn_constructor = constructor;\n ptyexn_loc = loc;\n ptyexn_attributes = []\n }\n let type_extension ~path ~params ~constructors ~private_ =\n {\n ptyext_path = path;\n ptyext_params = params;\n ptyext_constructors = constructors;\n ptyext_private = private_;\n ptyext_loc = loc;\n ptyext_attributes = []\n }\n let value_binding ~pat ~expr =\n { pvb_pat = pat; pvb_expr = expr; pvb_attributes = []; pvb_loc = loc }\n let value_description ~name ~type_ ~prim =\n {\n pval_name = name;\n pval_type = type_;\n pval_prim = prim;\n pval_attributes = [];\n pval_loc = loc\n }\n end\n","open! Import\n\nmodule Default = struct\n module Located = struct\n type 'a t = 'a Loc.t\n\n let loc (x : _ t) = x.loc\n let mk ~loc x = { loc; txt = x }\n let map f t = { t with txt = f t.txt }\n let map_lident x = map (fun x -> Longident.Lident x) x\n let lident ~loc x = mk ~loc (Longident.parse x)\n end\n\n include Ast_builder_generated.M\n\n let pstr_value_list ~loc rec_flag = function\n | [] -> []\n | vbs -> [ pstr_value ~loc rec_flag vbs ]\n\n let nonrec_type_declaration ~loc:_ ~name:_ ~params:_ ~cstrs:_ ~kind:_\n ~private_:_ ~manifest:_ =\n failwith\n \"Ppxlib.Ast_builder.nonrec_type_declaration: don't use this function\"\n\n let eint ~loc t = pexp_constant ~loc (Pconst_integer (Int.to_string t, None))\n let echar ~loc t = pexp_constant ~loc (Pconst_char t)\n let estring ~loc t = pexp_constant ~loc (Pconst_string (t, loc, None))\n let efloat ~loc t = pexp_constant ~loc (Pconst_float (t, None))\n\n let eint32 ~loc t =\n pexp_constant ~loc (Pconst_integer (Int32.to_string t, Some 'l'))\n\n let eint64 ~loc t =\n pexp_constant ~loc (Pconst_integer (Int64.to_string t, Some 'L'))\n\n let enativeint ~loc t =\n pexp_constant ~loc (Pconst_integer (Nativeint.to_string t, Some 'n'))\n\n let pint ~loc t = ppat_constant ~loc (Pconst_integer (Int.to_string t, None))\n let pchar ~loc t = ppat_constant ~loc (Pconst_char t)\n let pstring ~loc t = ppat_constant ~loc (Pconst_string (t, loc, None))\n let pfloat ~loc t = ppat_constant ~loc (Pconst_float (t, None))\n\n let pint32 ~loc t =\n ppat_constant ~loc (Pconst_integer (Int32.to_string t, Some 'l'))\n\n let pint64 ~loc t =\n ppat_constant ~loc (Pconst_integer (Int64.to_string t, Some 'L'))\n\n let pnativeint ~loc t =\n ppat_constant ~loc (Pconst_integer (Nativeint.to_string t, Some 'n'))\n\n let ebool ~loc t =\n pexp_construct ~loc (Located.lident ~loc (Bool.to_string t)) None\n\n let pbool ~loc t =\n ppat_construct ~loc (Located.lident ~loc (Bool.to_string t)) None\n\n let evar ~loc v = pexp_ident ~loc (Located.mk ~loc (Longident.parse v))\n let pvar ~loc v = ppat_var ~loc (Located.mk ~loc v)\n let eunit ~loc = pexp_construct ~loc (Located.lident ~loc \"()\") None\n let punit ~loc = ppat_construct ~loc (Located.lident ~loc \"()\") None\n let pexp_tuple ~loc l = match l with [ x ] -> x | _ -> pexp_tuple ~loc l\n let ppat_tuple ~loc l = match l with [ x ] -> x | _ -> ppat_tuple ~loc l\n let ptyp_tuple ~loc l = match l with [ x ] -> x | _ -> ptyp_tuple ~loc l\n\n let pexp_tuple_opt ~loc l =\n match l with [] -> None | _ :: _ -> Some (pexp_tuple ~loc l)\n\n let ppat_tuple_opt ~loc l =\n match l with [] -> None | _ :: _ -> Some (ppat_tuple ~loc l)\n\n let ptyp_poly ~loc vars ty =\n match vars with [] -> ty | _ -> ptyp_poly ~loc vars ty\n\n let pexp_apply ~loc e el =\n match (e, el) with\n | _, [] -> e\n | { pexp_desc = Pexp_apply (e, args); pexp_attributes = []; _ }, _ ->\n { e with pexp_desc = Pexp_apply (e, args @ el) }\n | _ -> pexp_apply ~loc e el\n\n let eapply ~loc e el =\n pexp_apply ~loc e (List.map el ~f:(fun e -> (Asttypes.Nolabel, e)))\n\n let eabstract ~loc ps e =\n List.fold_right ps ~init:e ~f:(fun p e ->\n pexp_fun ~loc Asttypes.Nolabel None p e)\n\n let esequence ~loc el =\n match el with\n | [] -> eunit ~loc\n | hd :: tl ->\n List.fold_left tl ~init:hd ~f:(fun acc e -> pexp_sequence ~loc acc e)\n\n let pconstruct cd arg =\n ppat_construct ~loc:cd.pcd_loc (Located.map_lident cd.pcd_name) arg\n\n let econstruct cd arg =\n pexp_construct ~loc:cd.pcd_loc (Located.map_lident cd.pcd_name) arg\n\n let rec elist ~loc l =\n match l with\n | [] -> pexp_construct ~loc (Located.mk ~loc (Longident.Lident \"[]\")) None\n | x :: l ->\n pexp_construct ~loc\n (Located.mk ~loc (Longident.Lident \"::\"))\n (Some (pexp_tuple ~loc [ x; elist ~loc l ]))\n\n let rec plist ~loc l =\n match l with\n | [] -> ppat_construct ~loc (Located.mk ~loc (Longident.Lident \"[]\")) None\n | x :: l ->\n ppat_construct ~loc\n (Located.mk ~loc (Longident.Lident \"::\"))\n (Some (ppat_tuple ~loc [ x; plist ~loc l ]))\n\n let unapplied_type_constr_conv_without_apply ~loc (ident : Longident.t) ~f =\n match ident with\n | Lident n -> pexp_ident ~loc { txt = Lident (f n); loc }\n | Ldot (path, n) -> pexp_ident ~loc { txt = Ldot (path, f n); loc }\n | Lapply _ ->\n Location.raise_errorf ~loc \"unexpected applicative functor type\"\n\n let type_constr_conv ~loc:apply_loc { Loc.loc; txt = longident } ~f args =\n let loc = { loc with loc_ghost = true } in\n match (longident : Longident.t) with\n | Lident _ | Ldot ((Lident _ | Ldot _), _) | Lapply _ -> (\n let ident =\n unapplied_type_constr_conv_without_apply longident ~loc ~f\n in\n match args with\n | [] -> ident\n | _ :: _ -> eapply ~loc:apply_loc ident args)\n | Ldot ((Lapply _ as module_path), n) ->\n let suffix_n functor_ = String.uncapitalize_ascii functor_ ^ \"__\" ^ n in\n let rec gather_lapply functor_args : Longident.t -> Longident.t * _ =\n function\n | Lapply (rest, arg) -> gather_lapply (arg :: functor_args) rest\n | Lident functor_ -> (Lident (suffix_n functor_), functor_args)\n | Ldot (functor_path, functor_) ->\n (Ldot (functor_path, suffix_n functor_), functor_args)\n in\n let ident, functor_args = gather_lapply [] module_path in\n eapply ~loc:apply_loc\n (unapplied_type_constr_conv_without_apply ident ~loc ~f)\n (List.map functor_args ~f:(fun path ->\n pexp_pack ~loc (pmod_ident ~loc { txt = path; loc }))\n @ args)\n\n let unapplied_type_constr_conv ~loc longident ~f =\n type_constr_conv longident ~loc ~f []\n\n let eta_reduce =\n let rec gather_params acc expr =\n match expr with\n | {\n pexp_desc =\n Pexp_fun (label, None (* no default expression *), subpat, body);\n pexp_attributes = [];\n pexp_loc = _;\n pexp_loc_stack = _;\n } -> (\n match subpat with\n | {\n ppat_desc = Ppat_var name;\n ppat_attributes = [];\n ppat_loc = _;\n ppat_loc_stack = _;\n } ->\n gather_params ((label, name, None) :: acc) body\n | {\n ppat_desc =\n Ppat_constraint\n ( {\n ppat_desc = Ppat_var name;\n ppat_attributes = [];\n ppat_loc = _;\n ppat_loc_stack = _;\n },\n ty );\n ppat_attributes = [];\n ppat_loc = _;\n ppat_loc_stack = _;\n } ->\n (* We reduce [fun (x : ty) -> f x] by rewriting it [(f : ty -> _)]. *)\n gather_params ((label, name, Some ty) :: acc) body\n | _ -> (List.rev acc, expr))\n | _ -> (List.rev acc, expr)\n in\n let annotate ~loc expr params =\n if List.exists params ~f:(fun (_, _, ty) -> Option.is_some ty) then\n let ty =\n List.fold_right params ~init:(ptyp_any ~loc)\n ~f:(fun (param_label, param, ty_opt) acc ->\n let loc = param.loc in\n let ty =\n match ty_opt with None -> ptyp_any ~loc | Some ty -> ty\n in\n ptyp_arrow ~loc param_label ty acc)\n in\n pexp_constraint ~loc expr ty\n else expr\n in\n let rec gather_args n x =\n if n = 0 then Some (x, [])\n else\n match x with\n | {\n pexp_desc = Pexp_apply (body, args);\n pexp_attributes = [];\n pexp_loc = _;\n pexp_loc_stack = _;\n } ->\n if List.length args <= n then\n match gather_args (n - List.length args) body with\n | None -> None\n | Some (body, args') -> Some (body, args' @ args)\n else None\n | _ -> None\n in\n fun expr ->\n let params, body = gather_params [] expr in\n match gather_args (List.length params) body with\n | None -> None\n | Some (({ pexp_desc = Pexp_ident _; _ } as f_ident), args) -> (\n match\n List.for_all2 args params\n ~f:(fun (arg_label, arg) (param_label, param, _) ->\n Poly.( = ) (arg_label : arg_label) param_label\n &&\n match arg with\n | {\n pexp_desc = Pexp_ident { txt = Lident name'; _ };\n pexp_attributes = [];\n pexp_loc = _;\n pexp_loc_stack = _;\n } ->\n String.( = ) name' param.txt\n | _ -> false)\n with\n | false -> None\n | true -> Some (annotate ~loc:expr.pexp_loc f_ident params))\n | _ -> None\n\n let eta_reduce_if_possible expr = Option.value (eta_reduce expr) ~default:expr\n\n let eta_reduce_if_possible_and_nonrec expr ~rec_flag =\n match rec_flag with\n | Recursive -> expr\n | Nonrecursive -> eta_reduce_if_possible expr\nend\n\nmodule type Loc = Ast_builder_intf.Loc\nmodule type S = Ast_builder_intf.S\n\nmodule Make (Loc : sig\n val loc : Location.t\nend) : S = struct\n include Ast_builder_generated.Make (Loc)\n\n let pstr_value_list = Default.pstr_value_list\n\n let nonrec_type_declaration ~name ~params ~cstrs ~kind ~private_ ~manifest =\n Default.nonrec_type_declaration ~loc ~name ~params ~cstrs ~kind ~private_\n ~manifest\n\n module Located = struct\n include Default.Located\n\n let loc _ = Loc.loc\n let mk x = mk ~loc:Loc.loc x\n let lident x = lident ~loc:Loc.loc x\n end\n\n let pexp_tuple l = Default.pexp_tuple ~loc l\n let ppat_tuple l = Default.ppat_tuple ~loc l\n let ptyp_tuple l = Default.ptyp_tuple ~loc l\n let pexp_tuple_opt l = Default.pexp_tuple_opt ~loc l\n let ppat_tuple_opt l = Default.ppat_tuple_opt ~loc l\n let ptyp_poly vars ty = Default.ptyp_poly ~loc vars ty\n let pexp_apply e el = Default.pexp_apply ~loc e el\n let eint t = Default.eint ~loc t\n let echar t = Default.echar ~loc t\n let estring t = Default.estring ~loc t\n let efloat t = Default.efloat ~loc t\n let eint32 t = Default.eint32 ~loc t\n let eint64 t = Default.eint64 ~loc t\n let enativeint t = Default.enativeint ~loc t\n let ebool t = Default.ebool ~loc t\n let evar t = Default.evar ~loc t\n let pint t = Default.pint ~loc t\n let pchar t = Default.pchar ~loc t\n let pstring t = Default.pstring ~loc t\n let pfloat t = Default.pfloat ~loc t\n let pint32 t = Default.pint32 ~loc t\n let pint64 t = Default.pint64 ~loc t\n let pnativeint t = Default.pnativeint ~loc t\n let pbool t = Default.pbool ~loc t\n let pvar t = Default.pvar ~loc t\n let eunit = Default.eunit ~loc\n let punit = Default.punit ~loc\n let econstruct = Default.econstruct\n let pconstruct = Default.pconstruct\n let eapply e el = Default.eapply ~loc e el\n let eabstract ps e = Default.eabstract ~loc ps e\n let esequence el = Default.esequence ~loc el\n let elist l = Default.elist ~loc l\n let plist l = Default.plist ~loc l\n\n let type_constr_conv ident ~f args =\n Default.type_constr_conv ~loc ident ~f args\n\n let unapplied_type_constr_conv ident ~f =\n Default.unapplied_type_constr_conv ~loc ident ~f\n\n let eta_reduce = Default.eta_reduce\n let eta_reduce_if_possible = Default.eta_reduce_if_possible\n\n let eta_reduce_if_possible_and_nonrec =\n Default.eta_reduce_if_possible_and_nonrec\nend\n\nlet make loc =\n (module Make (struct\n let loc = loc\n end) : S)\n","open! Import\nmodule Printexc = Caml.Printexc\n\n(* Small helper to find out who is the caller of a function *)\n\ntype t = Printexc.location option\n\nlet get ~skip =\n let skip = __FILE__ :: skip in\n let stack = Printexc.get_callstack 16 in\n let len = Printexc.raw_backtrace_length stack in\n let rec loop pos =\n if pos = len then None\n else\n match\n Printexc.get_raw_backtrace_slot stack pos\n |> Printexc.convert_raw_backtrace_slot |> Printexc.Slot.location\n with\n | None -> None\n | Some loc ->\n if List.mem ~set:skip loc.filename then loop (pos + 1) else Some loc\n in\n loop 0\n","open! Import\nopen Ast_builder.Default\nmodule Buffer = Caml.Buffer\nmodule Format = Caml.Format\n\nlet lident x = Longident.Lident x\n\nlet core_type_of_type_declaration td =\n let loc = td.ptype_name.loc in\n ptyp_constr ~loc\n (Located.map lident td.ptype_name)\n (List.map td.ptype_params ~f:fst)\n\nlet strip_gen_symbol_suffix =\n let chop n ~or_more string pos f =\n let target = !pos - n in\n while !pos > 0 && (or_more || !pos > target) && f string.[!pos - 1] do\n pos := !pos - 1\n done;\n !pos <= target\n in\n fun string ->\n let pos = ref (String.length string) in\n if\n chop 1 ~or_more:false string pos (Char.equal '_')\n && chop 3 ~or_more:true string pos (function\n | '0' .. '9' -> true\n | _ -> false)\n && chop 2 ~or_more:false string pos (Char.equal '_')\n then String.prefix string !pos\n else string\n\nlet gen_symbol =\n let cnt = ref 0 in\n fun ?(prefix = \"_x\") () ->\n cnt := !cnt + 1;\n let prefix = strip_gen_symbol_suffix prefix in\n Printf.sprintf \"%s__%03i_\" prefix !cnt\n\nlet name_type_params_in_td (td : type_declaration) : type_declaration =\n let prefix_string i =\n (* a, b, ..., y, z, aa, bb, ... *)\n String.make ((i / 26) + 1) (Char.chr (Char.code 'a' + (i mod 26)))\n in\n let name_param i (tp, variance) =\n let ptyp_desc =\n match tp.ptyp_desc with\n | Ptyp_any -> Ptyp_var (gen_symbol ~prefix:(prefix_string i) ())\n | Ptyp_var _ as v -> v\n | _ -> Location.raise_errorf ~loc:tp.ptyp_loc \"not a type parameter\"\n in\n ({ tp with ptyp_desc }, variance)\n in\n { td with ptype_params = List.mapi td.ptype_params ~f:name_param }\n\nlet combinator_type_of_type_declaration td ~f =\n let td = name_type_params_in_td td in\n let result_type =\n f ~loc:td.ptype_name.loc (core_type_of_type_declaration td)\n in\n List.fold_right td.ptype_params ~init:result_type\n ~f:(fun (tp, _variance) acc ->\n let loc = tp.ptyp_loc in\n ptyp_arrow ~loc Nolabel (f ~loc tp) acc)\n\nlet string_of_core_type ct =\n let buf = Buffer.create 128 in\n let ppf = Format.formatter_of_buffer buf in\n Pprintast.core_type ppf ct;\n Format.pp_print_flush ppf ();\n Buffer.contents buf\n\nlet get_type_param_name (ty, _) =\n let loc = ty.ptyp_loc in\n match ty.ptyp_desc with\n | Ptyp_var name -> Located.mk ~loc name\n | _ -> Location.raise_errorf ~loc \"not a type parameter\"\n\nexception Type_is_recursive\n\nclass type_is_recursive rec_flag tds =\n object (self)\n inherit Ast_traverse.iter as super\n val type_names : string list = List.map tds ~f:(fun td -> td.ptype_name.txt)\n method return_true () = raise_notrace Type_is_recursive\n\n method! core_type ctype =\n match ctype.ptyp_desc with\n | Ptyp_arrow _ -> ()\n | Ptyp_constr ({ txt = Longident.Lident id; _ }, _)\n when List.mem ~set:type_names id ->\n self#return_true ()\n | _ -> super#core_type ctype\n\n method! constructor_declaration cd =\n (* Don't recurse through cd.pcd_res *)\n match cd.pcd_args with\n | Pcstr_tuple args -> List.iter args ~f:self#core_type\n | Pcstr_record fields -> List.iter fields ~f:self#label_declaration\n\n method! attributes _ = (* Don't recurse through attributes *)\n ()\n\n method go () =\n match rec_flag with\n | Nonrecursive -> Nonrecursive\n | Recursive -> (\n match List.iter tds ~f:self#type_declaration with\n | exception Type_is_recursive -> Recursive\n | () -> Nonrecursive)\n end\n\nlet really_recursive rec_flag tds = (new type_is_recursive rec_flag tds)#go ()\nlet rec last x l = match l with [] -> x | x :: l -> last x l\n\nlet loc_of_name_and_payload name payload =\n match payload with\n | PStr [] -> name.loc\n | PStr (x :: l) -> { x.pstr_loc with loc_end = (last x l).pstr_loc.loc_end }\n | PSig [] -> name.loc\n | PSig (x :: l) -> { x.psig_loc with loc_end = (last x l).psig_loc.loc_end }\n | PTyp t -> t.ptyp_loc\n | PPat (x, None) -> x.ppat_loc\n | PPat (x, Some e) -> { x.ppat_loc with loc_end = e.pexp_loc.loc_end }\n\nlet loc_of_payload { attr_name; attr_payload; attr_loc = _ } =\n loc_of_name_and_payload attr_name attr_payload\n\nlet loc_of_attribute { attr_name; attr_payload; attr_loc = _ } =\n (* TODO: fix this in the compiler, and move the logic to omp when converting\n from older asts. *)\n (* \"ocaml.doc\" attributes are generated with [Location.none], which is not helpful for\n error messages. *)\n if Poly.( = ) attr_name.loc Location.none then\n loc_of_name_and_payload attr_name attr_payload\n else\n {\n attr_name.loc with\n loc_end = (loc_of_name_and_payload attr_name attr_payload).loc_end;\n }\n\nlet loc_of_extension (name, payload) =\n if Poly.( = ) name.loc Location.none then loc_of_name_and_payload name payload\n else\n { name.loc with loc_end = (loc_of_name_and_payload name payload).loc_end }\n\nlet curry_applications expr =\n let open Ast_builder_generated.M in\n match expr.pexp_desc with\n | Pexp_apply (f, orig_forward_args) ->\n let loc = expr.pexp_loc in\n let rec loop = function\n | [] -> f\n | last_arg :: rev_front_args ->\n pexp_apply ~loc (loop rev_front_args) [ last_arg ]\n in\n loop (List.rev orig_forward_args)\n | _ -> expr\n\nlet rec assert_no_attributes = function\n | [] -> ()\n | { attr_name = name; attr_loc = _; attr_payload = _ } :: rest\n when Name.ignore_checks name.Location.txt ->\n assert_no_attributes rest\n | attr :: _ ->\n let loc = loc_of_attribute attr in\n Location.raise_errorf ~loc \"Attributes not allowed here\"\n\nlet assert_no_attributes_in =\n object\n inherit Ast_traverse.iter\n method! attribute a = assert_no_attributes [ a ]\n end\n\nlet attribute_of_warning loc s =\n {\n attr_name = { loc; txt = \"ocaml.ppwarning\" };\n attr_payload = PStr [ pstr_eval ~loc (estring ~loc s) [] ];\n attr_loc = loc;\n }\n\nlet is_polymorphic_variant =\n let rec check = function\n | { ptyp_desc = Ptyp_variant _; _ } -> `Definitely\n | { ptyp_desc = Ptyp_alias (typ, _); _ } -> check typ\n | { ptyp_desc = Ptyp_constr _; _ } -> `Maybe\n | _ -> `Surely_not\n (* Type vars go here even though they could be polymorphic\n variants, however we don't handle it if they get substituted\n by a polymorphic variant that is then included. *)\n in\n fun td ~sig_ ->\n match td.ptype_kind with\n | Ptype_variant _ | Ptype_record _ | Ptype_open -> `Surely_not\n | Ptype_abstract -> (\n match td.ptype_manifest with\n | None -> if sig_ then `Maybe else `Surely_not\n | Some typ -> check typ)\n\nlet mk_named_sig ~loc ~sg_name ~handle_polymorphic_variant = function\n | [ td ]\n when String.equal td.ptype_name.txt \"t\" && List.is_empty td.ptype_cstrs ->\n if\n (not handle_polymorphic_variant)\n && Poly.( = ) (is_polymorphic_variant td ~sig_:true) `Definitely\n then None\n else\n let arity = List.length td.ptype_params in\n if arity >= 4 then None\n else\n let mty =\n if arity = 0 then sg_name else Printf.sprintf \"%s%d\" sg_name arity\n in\n let td = name_type_params_in_td td in\n let for_subst =\n Ast_helper.Type.mk ~loc td.ptype_name ~params:td.ptype_params\n ~manifest:\n (ptyp_constr ~loc\n (Located.map_lident td.ptype_name)\n (List.map ~f:fst td.ptype_params))\n in\n Some\n (include_infos ~loc\n (pmty_with ~loc\n (pmty_ident ~loc (Located.lident mty ~loc))\n [ Pwith_typesubst (Located.lident ~loc \"t\", for_subst) ]))\n | _ -> None\n","open Import\nopen Ast_pattern0\nlet nolabel =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Nolabel -> (ctx.matched <- (ctx.matched + 1); k)\n | _ -> fail loc \"Nolabel\")\nlet labelled (T f0) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Labelled x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"Labelled\")\nlet optional (T f0) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Optional x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"Optional\")\nlet attribute ~name:(T name) ~payload:(T payload) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n let k = name ctx (x.attr_name).loc (x.attr_name).txt k in\n let k = payload ctx loc x.attr_payload k in k)\nlet binding_op ~op:(T op) ~pat:(T pat) ~exp:(T exp) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n let k = op ctx (x.pbop_op).loc (x.pbop_op).txt k in\n let k = pat ctx loc x.pbop_pat k in\n let k = exp ctx loc x.pbop_exp k in k)\nlet case ~lhs:(T lhs) ~guard:(T guard) ~rhs:(T rhs) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n let k = lhs ctx loc x.pc_lhs k in\n let k = guard ctx loc x.pc_guard k in\n let k = rhs ctx loc x.pc_rhs k in k)\nlet pcl_loc (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pcl_loc in\n let k = f1 ctx loc loc k in let k = f2 ctx loc x k in k)\nlet pcl_attributes (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pcl_loc in\n let k = f1 ctx loc x.pcl_attributes k in\n let x = { x with pcl_attributes = [] } in\n let k = f2 ctx loc x k in k)\nlet pcl_constr (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pcl_attributes;\n (let loc = x.pcl_loc in\n let x = x.pcl_desc in\n match x with\n | Pcl_constr (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx x0.loc x0.txt k in\n let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"constr\"))\nlet pcl_structure (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pcl_attributes;\n (let loc = x.pcl_loc in\n let x = x.pcl_desc in\n match x with\n | Pcl_structure x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"structure\"))\nlet pcl_fun (T f0) (T f1) (T f2) (T f3) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pcl_attributes;\n (let loc = x.pcl_loc in\n let x = x.pcl_desc in\n match x with\n | Pcl_fun (x0, x1, x2, x3) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in\n let k = f1 ctx loc x1 k in\n let k = f2 ctx loc x2 k in let k = f3 ctx loc x3 k in k))\n | _ -> fail loc \"fun\"))\nlet pcl_apply (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pcl_attributes;\n (let loc = x.pcl_loc in\n let x = x.pcl_desc in\n match x with\n | Pcl_apply (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"apply\"))\nlet pcl_let (T f0) (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pcl_attributes;\n (let loc = x.pcl_loc in\n let x = x.pcl_desc in\n match x with\n | Pcl_let (x0, x1, x2) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in\n let k = f1 ctx loc x1 k in let k = f2 ctx loc x2 k in k))\n | _ -> fail loc \"let\"))\nlet pcl_constraint (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pcl_attributes;\n (let loc = x.pcl_loc in\n let x = x.pcl_desc in\n match x with\n | Pcl_constraint (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"constraint\"))\nlet pcl_extension (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pcl_attributes;\n (let loc = x.pcl_loc in\n let x = x.pcl_desc in\n match x with\n | Pcl_extension x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"extension\"))\nlet pcl_open (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pcl_attributes;\n (let loc = x.pcl_loc in\n let x = x.pcl_desc in\n match x with\n | Pcl_open (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"open\"))\nlet pcf_loc (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pcf_loc in\n let k = f1 ctx loc loc k in let k = f2 ctx loc x k in k)\nlet pcf_attributes (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pcf_loc in\n let k = f1 ctx loc x.pcf_attributes k in\n let x = { x with pcf_attributes = [] } in\n let k = f2 ctx loc x k in k)\nlet pcf_inherit (T f0) (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pcf_attributes;\n (let loc = x.pcf_loc in\n let x = x.pcf_desc in\n match x with\n | Pcf_inherit (x0, x1, x2) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in\n let k = f1 ctx loc x1 k in let k = f2 ctx loc x2 k in k))\n | _ -> fail loc \"inherit\"))\nlet pcf_val (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pcf_attributes;\n (let loc = x.pcf_loc in\n let x = x.pcf_desc in\n match x with\n | Pcf_val x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"val\"))\nlet pcf_method (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pcf_attributes;\n (let loc = x.pcf_loc in\n let x = x.pcf_desc in\n match x with\n | Pcf_method x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"method\"))\nlet pcf_constraint (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pcf_attributes;\n (let loc = x.pcf_loc in\n let x = x.pcf_desc in\n match x with\n | Pcf_constraint x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"constraint\"))\nlet pcf_initializer (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pcf_attributes;\n (let loc = x.pcf_loc in\n let x = x.pcf_desc in\n match x with\n | Pcf_initializer x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"initializer\"))\nlet pcf_attribute (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pcf_attributes;\n (let loc = x.pcf_loc in\n let x = x.pcf_desc in\n match x with\n | Pcf_attribute x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"attribute\"))\nlet pcf_extension (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pcf_attributes;\n (let loc = x.pcf_loc in\n let x = x.pcf_desc in\n match x with\n | Pcf_extension x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"extension\"))\nlet cfk_virtual (T f0) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Cfk_virtual x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"virtual\")\nlet cfk_concrete (T f0) (T f1) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Cfk_concrete (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"concrete\")\nlet class_infos_attributes (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pci_loc in\n let k = f1 ctx loc x.pci_attributes k in\n let x = { x with pci_attributes = [] } in\n let k = f2 ctx loc x k in k)\nlet class_infos ~virt:(T virt) ~params:(T params) ~name:(T name) ~expr:(T\n expr) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pci_attributes;\n (let k = virt ctx loc x.pci_virt k in\n let k = params ctx loc x.pci_params k in\n let k = name ctx (x.pci_name).loc (x.pci_name).txt k in\n let k = expr ctx loc x.pci_expr k in k))\nlet class_signature ~self:(T self) ~fields:(T fields) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n let k = self ctx loc x.pcsig_self k in\n let k = fields ctx loc x.pcsig_fields k in k)\nlet class_structure ~self:(T self) ~fields:(T fields) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n let k = self ctx loc x.pcstr_self k in\n let k = fields ctx loc x.pcstr_fields k in k)\nlet pcty_loc (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pcty_loc in\n let k = f1 ctx loc loc k in let k = f2 ctx loc x k in k)\nlet pcty_attributes (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pcty_loc in\n let k = f1 ctx loc x.pcty_attributes k in\n let x = { x with pcty_attributes = [] } in\n let k = f2 ctx loc x k in k)\nlet pcty_constr (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pcty_attributes;\n (let loc = x.pcty_loc in\n let x = x.pcty_desc in\n match x with\n | Pcty_constr (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx x0.loc x0.txt k in\n let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"constr\"))\nlet pcty_signature (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pcty_attributes;\n (let loc = x.pcty_loc in\n let x = x.pcty_desc in\n match x with\n | Pcty_signature x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"signature\"))\nlet pcty_arrow (T f0) (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pcty_attributes;\n (let loc = x.pcty_loc in\n let x = x.pcty_desc in\n match x with\n | Pcty_arrow (x0, x1, x2) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in\n let k = f1 ctx loc x1 k in let k = f2 ctx loc x2 k in k))\n | _ -> fail loc \"arrow\"))\nlet pcty_extension (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pcty_attributes;\n (let loc = x.pcty_loc in\n let x = x.pcty_desc in\n match x with\n | Pcty_extension x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"extension\"))\nlet pcty_open (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pcty_attributes;\n (let loc = x.pcty_loc in\n let x = x.pcty_desc in\n match x with\n | Pcty_open (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"open\"))\nlet pctf_loc (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pctf_loc in\n let k = f1 ctx loc loc k in let k = f2 ctx loc x k in k)\nlet pctf_attributes (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pctf_loc in\n let k = f1 ctx loc x.pctf_attributes k in\n let x = { x with pctf_attributes = [] } in\n let k = f2 ctx loc x k in k)\nlet pctf_inherit (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pctf_attributes;\n (let loc = x.pctf_loc in\n let x = x.pctf_desc in\n match x with\n | Pctf_inherit x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"inherit\"))\nlet pctf_val (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pctf_attributes;\n (let loc = x.pctf_loc in\n let x = x.pctf_desc in\n match x with\n | Pctf_val x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"val\"))\nlet pctf_method (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pctf_attributes;\n (let loc = x.pctf_loc in\n let x = x.pctf_desc in\n match x with\n | Pctf_method x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"method\"))\nlet pctf_constraint (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pctf_attributes;\n (let loc = x.pctf_loc in\n let x = x.pctf_desc in\n match x with\n | Pctf_constraint x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"constraint\"))\nlet pctf_attribute (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pctf_attributes;\n (let loc = x.pctf_loc in\n let x = x.pctf_desc in\n match x with\n | Pctf_attribute x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"attribute\"))\nlet pctf_extension (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pctf_attributes;\n (let loc = x.pctf_loc in\n let x = x.pctf_desc in\n match x with\n | Pctf_extension x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"extension\"))\nlet closed =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Closed -> (ctx.matched <- (ctx.matched + 1); k)\n | _ -> fail loc \"Closed\")\nlet open_ =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Open -> (ctx.matched <- (ctx.matched + 1); k)\n | _ -> fail loc \"Open\")\nlet pconst_integer (T f0) (T f1) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Pconst_integer (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"integer\")\nlet pconst_char (T f0) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Pconst_char x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"char\")\nlet pconst_string (T f0) (T f1) (T f2) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Pconst_string (x0, x1, x2) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in\n let k = f1 ctx loc x1 k in let k = f2 ctx loc x2 k in k))\n | _ -> fail loc \"string\")\nlet pconst_float (T f0) (T f1) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Pconst_float (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"float\")\nlet pcstr_tuple (T f0) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Pcstr_tuple x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"tuple\")\nlet pcstr_record (T f0) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Pcstr_record x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"record\")\nlet constructor_declaration_attributes (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pcd_loc in\n let k = f1 ctx loc x.pcd_attributes k in\n let x = { x with pcd_attributes = [] } in\n let k = f2 ctx loc x k in k)\nlet constructor_declaration ~name:(T name) ~args:(T args) ~res:(T res) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pcd_attributes;\n (let k = name ctx (x.pcd_name).loc (x.pcd_name).txt k in\n let k = args ctx loc x.pcd_args k in\n let k = res ctx loc x.pcd_res k in k))\nlet ptyp_loc (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.ptyp_loc in\n let k = f1 ctx loc loc k in let k = f2 ctx loc x k in k)\nlet ptyp_attributes (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.ptyp_loc in\n let k = f1 ctx loc x.ptyp_attributes k in\n let x = { x with ptyp_attributes = [] } in\n let k = f2 ctx loc x k in k)\nlet ptyp_any =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ptyp_attributes;\n (let loc = x.ptyp_loc in\n let x = x.ptyp_desc in\n match x with\n | Ptyp_any -> (ctx.matched <- (ctx.matched + 1); k)\n | _ -> fail loc \"any\"))\nlet ptyp_var (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ptyp_attributes;\n (let loc = x.ptyp_loc in\n let x = x.ptyp_desc in\n match x with\n | Ptyp_var x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"var\"))\nlet ptyp_arrow (T f0) (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ptyp_attributes;\n (let loc = x.ptyp_loc in\n let x = x.ptyp_desc in\n match x with\n | Ptyp_arrow (x0, x1, x2) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in\n let k = f1 ctx loc x1 k in let k = f2 ctx loc x2 k in k))\n | _ -> fail loc \"arrow\"))\nlet ptyp_tuple (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ptyp_attributes;\n (let loc = x.ptyp_loc in\n let x = x.ptyp_desc in\n match x with\n | Ptyp_tuple x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"tuple\"))\nlet ptyp_constr (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ptyp_attributes;\n (let loc = x.ptyp_loc in\n let x = x.ptyp_desc in\n match x with\n | Ptyp_constr (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx x0.loc x0.txt k in\n let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"constr\"))\nlet ptyp_object (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ptyp_attributes;\n (let loc = x.ptyp_loc in\n let x = x.ptyp_desc in\n match x with\n | Ptyp_object (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"object\"))\nlet ptyp_class (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ptyp_attributes;\n (let loc = x.ptyp_loc in\n let x = x.ptyp_desc in\n match x with\n | Ptyp_class (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx x0.loc x0.txt k in\n let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"class\"))\nlet ptyp_alias (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ptyp_attributes;\n (let loc = x.ptyp_loc in\n let x = x.ptyp_desc in\n match x with\n | Ptyp_alias (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"alias\"))\nlet ptyp_variant (T f0) (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ptyp_attributes;\n (let loc = x.ptyp_loc in\n let x = x.ptyp_desc in\n match x with\n | Ptyp_variant (x0, x1, x2) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in\n let k = f1 ctx loc x1 k in let k = f2 ctx loc x2 k in k))\n | _ -> fail loc \"variant\"))\nlet ptyp_poly (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ptyp_attributes;\n (let loc = x.ptyp_loc in\n let x = x.ptyp_desc in\n match x with\n | Ptyp_poly (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"poly\"))\nlet ptyp_package (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ptyp_attributes;\n (let loc = x.ptyp_loc in\n let x = x.ptyp_desc in\n match x with\n | Ptyp_package x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"package\"))\nlet ptyp_extension (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ptyp_attributes;\n (let loc = x.ptyp_loc in\n let x = x.ptyp_desc in\n match x with\n | Ptyp_extension x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"extension\"))\nlet upto =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Upto -> (ctx.matched <- (ctx.matched + 1); k)\n | _ -> fail loc \"Upto\")\nlet downto_ =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Downto -> (ctx.matched <- (ctx.matched + 1); k)\n | _ -> fail loc \"Downto\")\nlet pdira_loc (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pdira_loc in\n let k = f1 ctx loc loc k in let k = f2 ctx loc x k in k)\nlet pdir_string (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pdira_loc in\n let x = x.pdira_desc in\n match x with\n | Pdir_string x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"string\")\nlet pdir_int (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pdira_loc in\n let x = x.pdira_desc in\n match x with\n | Pdir_int (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"int\")\nlet pdir_ident (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pdira_loc in\n let x = x.pdira_desc in\n match x with\n | Pdir_ident x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"ident\")\nlet pdir_bool (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pdira_loc in\n let x = x.pdira_desc in\n match x with\n | Pdir_bool x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"bool\")\nlet pexp_loc (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pexp_loc in\n let k = f1 ctx loc loc k in let k = f2 ctx loc x k in k)\nlet pexp_attributes (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pexp_loc in\n let k = f1 ctx loc x.pexp_attributes k in\n let x = { x with pexp_attributes = [] } in\n let k = f2 ctx loc x k in k)\nlet pexp_ident (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_ident x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx x0.loc x0.txt k in k))\n | _ -> fail loc \"ident\"))\nlet pexp_constant (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_constant x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"constant\"))\nlet pexp_let (T f0) (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_let (x0, x1, x2) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in\n let k = f1 ctx loc x1 k in let k = f2 ctx loc x2 k in k))\n | _ -> fail loc \"let\"))\nlet pexp_function (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_function x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"function\"))\nlet pexp_fun (T f0) (T f1) (T f2) (T f3) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_fun (x0, x1, x2, x3) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in\n let k = f1 ctx loc x1 k in\n let k = f2 ctx loc x2 k in let k = f3 ctx loc x3 k in k))\n | _ -> fail loc \"fun\"))\nlet pexp_apply (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_apply (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"apply\"))\nlet pexp_match (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_match (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"match\"))\nlet pexp_try (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_try (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"try\"))\nlet pexp_tuple (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_tuple x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"tuple\"))\nlet pexp_construct (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_construct (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx x0.loc x0.txt k in\n let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"construct\"))\nlet pexp_variant (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_variant (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"variant\"))\nlet pexp_record (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_record (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"record\"))\nlet pexp_field (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_field (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in\n let k = f1 ctx x1.loc x1.txt k in k))\n | _ -> fail loc \"field\"))\nlet pexp_setfield (T f0) (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_setfield (x0, x1, x2) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in\n let k = f1 ctx x1.loc x1.txt k in\n let k = f2 ctx loc x2 k in k))\n | _ -> fail loc \"setfield\"))\nlet pexp_array (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_array x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"array\"))\nlet pexp_ifthenelse (T f0) (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_ifthenelse (x0, x1, x2) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in\n let k = f1 ctx loc x1 k in let k = f2 ctx loc x2 k in k))\n | _ -> fail loc \"ifthenelse\"))\nlet pexp_sequence (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_sequence (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"sequence\"))\nlet pexp_while (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_while (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"while\"))\nlet pexp_for (T f0) (T f1) (T f2) (T f3) (T f4) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_for (x0, x1, x2, x3, x4) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in\n let k = f1 ctx loc x1 k in\n let k = f2 ctx loc x2 k in\n let k = f3 ctx loc x3 k in let k = f4 ctx loc x4 k in k))\n | _ -> fail loc \"for\"))\nlet pexp_constraint (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_constraint (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"constraint\"))\nlet pexp_coerce (T f0) (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_coerce (x0, x1, x2) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in\n let k = f1 ctx loc x1 k in let k = f2 ctx loc x2 k in k))\n | _ -> fail loc \"coerce\"))\nlet pexp_send (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_send (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in\n let k = f1 ctx x1.loc x1.txt k in k))\n | _ -> fail loc \"send\"))\nlet pexp_new (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_new x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx x0.loc x0.txt k in k))\n | _ -> fail loc \"new\"))\nlet pexp_setinstvar (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_setinstvar (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx x0.loc x0.txt k in\n let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"setinstvar\"))\nlet pexp_override (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_override x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"override\"))\nlet pexp_letmodule (T f0) (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_letmodule (x0, x1, x2) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx x0.loc x0.txt k in\n let k = f1 ctx loc x1 k in let k = f2 ctx loc x2 k in k))\n | _ -> fail loc \"letmodule\"))\nlet pexp_letexception (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_letexception (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"letexception\"))\nlet pexp_assert (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_assert x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"assert\"))\nlet pexp_lazy (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_lazy x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"lazy\"))\nlet pexp_poly (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_poly (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"poly\"))\nlet pexp_object (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_object x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"object\"))\nlet pexp_newtype (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_newtype (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx x0.loc x0.txt k in\n let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"newtype\"))\nlet pexp_pack (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_pack x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"pack\"))\nlet pexp_open (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_open (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"open\"))\nlet pexp_letop (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_letop x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"letop\"))\nlet pexp_extension (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_extension x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"extension\"))\nlet pexp_unreachable =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pexp_attributes;\n (let loc = x.pexp_loc in\n let x = x.pexp_desc in\n match x with\n | Pexp_unreachable -> (ctx.matched <- (ctx.matched + 1); k)\n | _ -> fail loc \"unreachable\"))\nlet extension_constructor_attributes (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pext_loc in\n let k = f1 ctx loc x.pext_attributes k in\n let x = { x with pext_attributes = [] } in\n let k = f2 ctx loc x k in k)\nlet extension_constructor ~name:(T name) ~kind:(T kind) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pext_attributes;\n (let k = name ctx (x.pext_name).loc (x.pext_name).txt k in\n let k = kind ctx loc x.pext_kind k in k))\nlet pext_decl (T f0) (T f1) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Pext_decl (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"decl\")\nlet pext_rebind (T f0) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Pext_rebind x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx x0.loc x0.txt k in k))\n | _ -> fail loc \"rebind\")\nlet unit =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Unit -> (ctx.matched <- (ctx.matched + 1); k)\n | _ -> fail loc \"Unit\")\nlet named (T f0) (T f1) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Named (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx x0.loc x0.txt k in\n let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"Named\")\nlet include_infos_attributes (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pincl_loc in\n let k = f1 ctx loc x.pincl_attributes k in\n let x = { x with pincl_attributes = [] } in\n let k = f2 ctx loc x k in k)\nlet include_infos ~mod_:(T mod_) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pincl_attributes;\n (let k = mod_ ctx loc x.pincl_mod k in k))\nlet injective =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Injective -> (ctx.matched <- (ctx.matched + 1); k)\n | _ -> fail loc \"Injective\")\nlet noinjectivity =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | NoInjectivity -> (ctx.matched <- (ctx.matched + 1); k)\n | _ -> fail loc \"NoInjectivity\")\nlet label_declaration_attributes (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pld_loc in\n let k = f1 ctx loc x.pld_attributes k in\n let x = { x with pld_attributes = [] } in\n let k = f2 ctx loc x k in k)\nlet label_declaration ~name:(T name) ~mutable_:(T mutable_) ~type_:(T\n type_) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pld_attributes;\n (let k = name ctx (x.pld_name).loc (x.pld_name).txt k in\n let k = mutable_ ctx loc x.pld_mutable k in\n let k = type_ ctx loc x.pld_type k in k))\nlet letop ~let_:(T let_) ~ands:(T ands) ~body:(T body) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n let k = let_ ctx loc x.let_ k in\n let k = ands ctx loc x.ands k in\n let k = body ctx loc x.body k in k)\nlet location ~start:(T start) ~end_:(T end_) ~ghost:(T ghost) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n let k = start ctx loc x.loc_start k in\n let k = end_ ctx loc x.loc_end k in\n let k = ghost ctx loc x.loc_ghost k in k)\nlet lident (T f0) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Lident x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"Lident\")\nlet ldot (T f0) (T f1) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Ldot (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"Ldot\")\nlet lapply (T f0) (T f1) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Lapply (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"Lapply\")\nlet module_binding_attributes (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pmb_loc in\n let k = f1 ctx loc x.pmb_attributes k in\n let x = { x with pmb_attributes = [] } in\n let k = f2 ctx loc x k in k)\nlet module_binding ~name:(T name) ~expr:(T expr) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pmb_attributes;\n (let k = name ctx (x.pmb_name).loc (x.pmb_name).txt k in\n let k = expr ctx loc x.pmb_expr k in k))\nlet module_declaration_attributes (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pmd_loc in\n let k = f1 ctx loc x.pmd_attributes k in\n let x = { x with pmd_attributes = [] } in\n let k = f2 ctx loc x k in k)\nlet module_declaration ~name:(T name) ~type_:(T type_) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pmd_attributes;\n (let k = name ctx (x.pmd_name).loc (x.pmd_name).txt k in\n let k = type_ ctx loc x.pmd_type k in k))\nlet pmod_loc (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pmod_loc in\n let k = f1 ctx loc loc k in let k = f2 ctx loc x k in k)\nlet pmod_attributes (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pmod_loc in\n let k = f1 ctx loc x.pmod_attributes k in\n let x = { x with pmod_attributes = [] } in\n let k = f2 ctx loc x k in k)\nlet pmod_ident (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pmod_attributes;\n (let loc = x.pmod_loc in\n let x = x.pmod_desc in\n match x with\n | Pmod_ident x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx x0.loc x0.txt k in k))\n | _ -> fail loc \"ident\"))\nlet pmod_structure (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pmod_attributes;\n (let loc = x.pmod_loc in\n let x = x.pmod_desc in\n match x with\n | Pmod_structure x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"structure\"))\nlet pmod_functor (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pmod_attributes;\n (let loc = x.pmod_loc in\n let x = x.pmod_desc in\n match x with\n | Pmod_functor (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"functor\"))\nlet pmod_apply (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pmod_attributes;\n (let loc = x.pmod_loc in\n let x = x.pmod_desc in\n match x with\n | Pmod_apply (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"apply\"))\nlet pmod_constraint (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pmod_attributes;\n (let loc = x.pmod_loc in\n let x = x.pmod_desc in\n match x with\n | Pmod_constraint (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"constraint\"))\nlet pmod_unpack (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pmod_attributes;\n (let loc = x.pmod_loc in\n let x = x.pmod_desc in\n match x with\n | Pmod_unpack x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"unpack\"))\nlet pmod_extension (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pmod_attributes;\n (let loc = x.pmod_loc in\n let x = x.pmod_desc in\n match x with\n | Pmod_extension x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"extension\"))\nlet module_substitution_attributes (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pms_loc in\n let k = f1 ctx loc x.pms_attributes k in\n let x = { x with pms_attributes = [] } in\n let k = f2 ctx loc x k in k)\nlet module_substitution ~name:(T name) ~manifest:(T manifest) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pms_attributes;\n (let k = name ctx (x.pms_name).loc (x.pms_name).txt k in\n let k =\n manifest ctx (x.pms_manifest).loc (x.pms_manifest).txt k in\n k))\nlet pmty_loc (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pmty_loc in\n let k = f1 ctx loc loc k in let k = f2 ctx loc x k in k)\nlet pmty_attributes (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pmty_loc in\n let k = f1 ctx loc x.pmty_attributes k in\n let x = { x with pmty_attributes = [] } in\n let k = f2 ctx loc x k in k)\nlet pmty_ident (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pmty_attributes;\n (let loc = x.pmty_loc in\n let x = x.pmty_desc in\n match x with\n | Pmty_ident x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx x0.loc x0.txt k in k))\n | _ -> fail loc \"ident\"))\nlet pmty_signature (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pmty_attributes;\n (let loc = x.pmty_loc in\n let x = x.pmty_desc in\n match x with\n | Pmty_signature x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"signature\"))\nlet pmty_functor (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pmty_attributes;\n (let loc = x.pmty_loc in\n let x = x.pmty_desc in\n match x with\n | Pmty_functor (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"functor\"))\nlet pmty_with (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pmty_attributes;\n (let loc = x.pmty_loc in\n let x = x.pmty_desc in\n match x with\n | Pmty_with (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"with\"))\nlet pmty_typeof (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pmty_attributes;\n (let loc = x.pmty_loc in\n let x = x.pmty_desc in\n match x with\n | Pmty_typeof x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"typeof\"))\nlet pmty_extension (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pmty_attributes;\n (let loc = x.pmty_loc in\n let x = x.pmty_desc in\n match x with\n | Pmty_extension x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"extension\"))\nlet pmty_alias (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pmty_attributes;\n (let loc = x.pmty_loc in\n let x = x.pmty_desc in\n match x with\n | Pmty_alias x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx x0.loc x0.txt k in k))\n | _ -> fail loc \"alias\"))\nlet module_type_declaration_attributes (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pmtd_loc in\n let k = f1 ctx loc x.pmtd_attributes k in\n let x = { x with pmtd_attributes = [] } in\n let k = f2 ctx loc x k in k)\nlet module_type_declaration ~name:(T name) ~type_:(T type_) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pmtd_attributes;\n (let k = name ctx (x.pmtd_name).loc (x.pmtd_name).txt k in\n let k = type_ ctx loc x.pmtd_type k in k))\nlet immutable =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Immutable -> (ctx.matched <- (ctx.matched + 1); k)\n | _ -> fail loc \"Immutable\")\nlet mutable_ =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Mutable -> (ctx.matched <- (ctx.matched + 1); k)\n | _ -> fail loc \"Mutable\")\nlet pof_loc (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pof_loc in\n let k = f1 ctx loc loc k in let k = f2 ctx loc x k in k)\nlet pof_attributes (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pof_loc in\n let k = f1 ctx loc x.pof_attributes k in\n let x = { x with pof_attributes = [] } in\n let k = f2 ctx loc x k in k)\nlet otag (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pof_attributes;\n (let loc = x.pof_loc in\n let x = x.pof_desc in\n match x with\n | Otag (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx x0.loc x0.txt k in\n let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"Otag\"))\nlet oinherit (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pof_attributes;\n (let loc = x.pof_loc in\n let x = x.pof_desc in\n match x with\n | Oinherit x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"Oinherit\"))\nlet open_infos_attributes (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.popen_loc in\n let k = f1 ctx loc x.popen_attributes k in\n let x = { x with popen_attributes = [] } in\n let k = f2 ctx loc x k in k)\nlet open_infos ~expr:(T expr) ~override:(T override) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.popen_attributes;\n (let k = expr ctx loc x.popen_expr k in\n let k = override ctx loc x.popen_override k in k))\nlet override =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Override -> (ctx.matched <- (ctx.matched + 1); k)\n | _ -> fail loc \"Override\")\nlet fresh =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Fresh -> (ctx.matched <- (ctx.matched + 1); k)\n | _ -> fail loc \"Fresh\")\nlet ppat_loc (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.ppat_loc in\n let k = f1 ctx loc loc k in let k = f2 ctx loc x k in k)\nlet ppat_attributes (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.ppat_loc in\n let k = f1 ctx loc x.ppat_attributes k in\n let x = { x with ppat_attributes = [] } in\n let k = f2 ctx loc x k in k)\nlet ppat_any =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ppat_attributes;\n (let loc = x.ppat_loc in\n let x = x.ppat_desc in\n match x with\n | Ppat_any -> (ctx.matched <- (ctx.matched + 1); k)\n | _ -> fail loc \"any\"))\nlet ppat_var (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ppat_attributes;\n (let loc = x.ppat_loc in\n let x = x.ppat_desc in\n match x with\n | Ppat_var x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx x0.loc x0.txt k in k))\n | _ -> fail loc \"var\"))\nlet ppat_alias (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ppat_attributes;\n (let loc = x.ppat_loc in\n let x = x.ppat_desc in\n match x with\n | Ppat_alias (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in\n let k = f1 ctx x1.loc x1.txt k in k))\n | _ -> fail loc \"alias\"))\nlet ppat_constant (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ppat_attributes;\n (let loc = x.ppat_loc in\n let x = x.ppat_desc in\n match x with\n | Ppat_constant x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"constant\"))\nlet ppat_interval (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ppat_attributes;\n (let loc = x.ppat_loc in\n let x = x.ppat_desc in\n match x with\n | Ppat_interval (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"interval\"))\nlet ppat_tuple (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ppat_attributes;\n (let loc = x.ppat_loc in\n let x = x.ppat_desc in\n match x with\n | Ppat_tuple x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"tuple\"))\nlet ppat_construct (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ppat_attributes;\n (let loc = x.ppat_loc in\n let x = x.ppat_desc in\n match x with\n | Ppat_construct (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx x0.loc x0.txt k in\n let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"construct\"))\nlet ppat_variant (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ppat_attributes;\n (let loc = x.ppat_loc in\n let x = x.ppat_desc in\n match x with\n | Ppat_variant (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"variant\"))\nlet ppat_record (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ppat_attributes;\n (let loc = x.ppat_loc in\n let x = x.ppat_desc in\n match x with\n | Ppat_record (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"record\"))\nlet ppat_array (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ppat_attributes;\n (let loc = x.ppat_loc in\n let x = x.ppat_desc in\n match x with\n | Ppat_array x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"array\"))\nlet ppat_or (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ppat_attributes;\n (let loc = x.ppat_loc in\n let x = x.ppat_desc in\n match x with\n | Ppat_or (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"or\"))\nlet ppat_constraint (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ppat_attributes;\n (let loc = x.ppat_loc in\n let x = x.ppat_desc in\n match x with\n | Ppat_constraint (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"constraint\"))\nlet ppat_type (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ppat_attributes;\n (let loc = x.ppat_loc in\n let x = x.ppat_desc in\n match x with\n | Ppat_type x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx x0.loc x0.txt k in k))\n | _ -> fail loc \"type\"))\nlet ppat_lazy (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ppat_attributes;\n (let loc = x.ppat_loc in\n let x = x.ppat_desc in\n match x with\n | Ppat_lazy x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"lazy\"))\nlet ppat_unpack (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ppat_attributes;\n (let loc = x.ppat_loc in\n let x = x.ppat_desc in\n match x with\n | Ppat_unpack x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx x0.loc x0.txt k in k))\n | _ -> fail loc \"unpack\"))\nlet ppat_exception (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ppat_attributes;\n (let loc = x.ppat_loc in\n let x = x.ppat_desc in\n match x with\n | Ppat_exception x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"exception\"))\nlet ppat_extension (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ppat_attributes;\n (let loc = x.ppat_loc in\n let x = x.ppat_desc in\n match x with\n | Ppat_extension x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"extension\"))\nlet ppat_open (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ppat_attributes;\n (let loc = x.ppat_loc in\n let x = x.ppat_desc in\n match x with\n | Ppat_open (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx x0.loc x0.txt k in\n let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"open\"))\nlet pstr (T f0) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | PStr x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"PStr\")\nlet psig (T f0) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | PSig x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"PSig\")\nlet ptyp (T f0) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | PTyp x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"PTyp\")\nlet ppat (T f0) (T f1) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | PPat (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"PPat\")\nlet position ~fname:(T fname) ~lnum:(T lnum) ~bol:(T bol) ~cnum:(T cnum) \n =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n let k = fname ctx loc x.pos_fname k in\n let k = lnum ctx loc x.pos_lnum k in\n let k = bol ctx loc x.pos_bol k in\n let k = cnum ctx loc x.pos_cnum k in k)\nlet private_ =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Private -> (ctx.matched <- (ctx.matched + 1); k)\n | _ -> fail loc \"Private\")\nlet public =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Public -> (ctx.matched <- (ctx.matched + 1); k)\n | _ -> fail loc \"Public\")\nlet nonrecursive =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Nonrecursive -> (ctx.matched <- (ctx.matched + 1); k)\n | _ -> fail loc \"Nonrecursive\")\nlet recursive =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Recursive -> (ctx.matched <- (ctx.matched + 1); k)\n | _ -> fail loc \"Recursive\")\nlet prf_loc (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.prf_loc in\n let k = f1 ctx loc loc k in let k = f2 ctx loc x k in k)\nlet prf_attributes (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.prf_loc in\n let k = f1 ctx loc x.prf_attributes k in\n let x = { x with prf_attributes = [] } in\n let k = f2 ctx loc x k in k)\nlet rtag (T f0) (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.prf_attributes;\n (let loc = x.prf_loc in\n let x = x.prf_desc in\n match x with\n | Rtag (x0, x1, x2) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx x0.loc x0.txt k in\n let k = f1 ctx loc x1 k in let k = f2 ctx loc x2 k in k))\n | _ -> fail loc \"Rtag\"))\nlet rinherit (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.prf_attributes;\n (let loc = x.prf_loc in\n let x = x.prf_desc in\n match x with\n | Rinherit x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"Rinherit\"))\nlet psig_loc (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.psig_loc in\n let k = f1 ctx loc loc k in let k = f2 ctx loc x k in k)\nlet psig_value (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.psig_loc in\n let x = x.psig_desc in\n match x with\n | Psig_value x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"value\")\nlet psig_type (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.psig_loc in\n let x = x.psig_desc in\n match x with\n | Psig_type (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"type\")\nlet psig_typesubst (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.psig_loc in\n let x = x.psig_desc in\n match x with\n | Psig_typesubst x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"typesubst\")\nlet psig_typext (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.psig_loc in\n let x = x.psig_desc in\n match x with\n | Psig_typext x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"typext\")\nlet psig_exception (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.psig_loc in\n let x = x.psig_desc in\n match x with\n | Psig_exception x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"exception\")\nlet psig_module (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.psig_loc in\n let x = x.psig_desc in\n match x with\n | Psig_module x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"module\")\nlet psig_modsubst (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.psig_loc in\n let x = x.psig_desc in\n match x with\n | Psig_modsubst x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"modsubst\")\nlet psig_recmodule (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.psig_loc in\n let x = x.psig_desc in\n match x with\n | Psig_recmodule x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"recmodule\")\nlet psig_modtype (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.psig_loc in\n let x = x.psig_desc in\n match x with\n | Psig_modtype x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"modtype\")\nlet psig_open (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.psig_loc in\n let x = x.psig_desc in\n match x with\n | Psig_open x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"open\")\nlet psig_include (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.psig_loc in\n let x = x.psig_desc in\n match x with\n | Psig_include x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"include\")\nlet psig_class (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.psig_loc in\n let x = x.psig_desc in\n match x with\n | Psig_class x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"class\")\nlet psig_class_type (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.psig_loc in\n let x = x.psig_desc in\n match x with\n | Psig_class_type x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"class_type\")\nlet psig_attribute (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.psig_loc in\n let x = x.psig_desc in\n match x with\n | Psig_attribute x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"attribute\")\nlet psig_extension (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.psig_loc in\n let x = x.psig_desc in\n match x with\n | Psig_extension (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"extension\")\nlet pstr_loc (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pstr_loc in\n let k = f1 ctx loc loc k in let k = f2 ctx loc x k in k)\nlet pstr_eval (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pstr_loc in\n let x = x.pstr_desc in\n match x with\n | Pstr_eval (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"eval\")\nlet pstr_value (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pstr_loc in\n let x = x.pstr_desc in\n match x with\n | Pstr_value (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"value\")\nlet pstr_primitive (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pstr_loc in\n let x = x.pstr_desc in\n match x with\n | Pstr_primitive x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"primitive\")\nlet pstr_type (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pstr_loc in\n let x = x.pstr_desc in\n match x with\n | Pstr_type (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"type\")\nlet pstr_typext (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pstr_loc in\n let x = x.pstr_desc in\n match x with\n | Pstr_typext x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"typext\")\nlet pstr_exception (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pstr_loc in\n let x = x.pstr_desc in\n match x with\n | Pstr_exception x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"exception\")\nlet pstr_module (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pstr_loc in\n let x = x.pstr_desc in\n match x with\n | Pstr_module x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"module\")\nlet pstr_recmodule (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pstr_loc in\n let x = x.pstr_desc in\n match x with\n | Pstr_recmodule x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"recmodule\")\nlet pstr_modtype (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pstr_loc in\n let x = x.pstr_desc in\n match x with\n | Pstr_modtype x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"modtype\")\nlet pstr_open (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pstr_loc in\n let x = x.pstr_desc in\n match x with\n | Pstr_open x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"open\")\nlet pstr_class (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pstr_loc in\n let x = x.pstr_desc in\n match x with\n | Pstr_class x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"class\")\nlet pstr_class_type (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pstr_loc in\n let x = x.pstr_desc in\n match x with\n | Pstr_class_type x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"class_type\")\nlet pstr_include (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pstr_loc in\n let x = x.pstr_desc in\n match x with\n | Pstr_include x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"include\")\nlet pstr_attribute (T f0) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pstr_loc in\n let x = x.pstr_desc in\n match x with\n | Pstr_attribute x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"attribute\")\nlet pstr_extension (T f0) (T f1) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pstr_loc in\n let x = x.pstr_desc in\n match x with\n | Pstr_extension (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"extension\")\nlet toplevel_directive ~name:(T name) ~arg:(T arg) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n let k = name ctx (x.pdir_name).loc (x.pdir_name).txt k in\n let k = arg ctx loc x.pdir_arg k in k)\nlet ptop_def (T f0) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Ptop_def x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"def\")\nlet ptop_dir (T f0) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Ptop_dir x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"dir\")\nlet type_declaration_attributes (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.ptype_loc in\n let k = f1 ctx loc x.ptype_attributes k in\n let x = { x with ptype_attributes = [] } in\n let k = f2 ctx loc x k in k)\nlet type_declaration ~name:(T name) ~params:(T params) ~cstrs:(T cstrs) \n ~kind:(T kind) ~private_:(T private_) ~manifest:(T manifest) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ptype_attributes;\n (let k = name ctx (x.ptype_name).loc (x.ptype_name).txt k in\n let k = params ctx loc x.ptype_params k in\n let k = cstrs ctx loc x.ptype_cstrs k in\n let k = kind ctx loc x.ptype_kind k in\n let k = private_ ctx loc x.ptype_private k in\n let k = manifest ctx loc x.ptype_manifest k in k))\nlet type_exception_attributes (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.ptyexn_loc in\n let k = f1 ctx loc x.ptyexn_attributes k in\n let x = { x with ptyexn_attributes = [] } in\n let k = f2 ctx loc x k in k)\nlet type_exception ~constructor:(T constructor) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ptyexn_attributes;\n (let k = constructor ctx loc x.ptyexn_constructor k in k))\nlet type_extension_attributes (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.ptyext_loc in\n let k = f1 ctx loc x.ptyext_attributes k in\n let x = { x with ptyext_attributes = [] } in\n let k = f2 ctx loc x k in k)\nlet type_extension ~path:(T path) ~params:(T params) ~constructors:(T\n constructors) ~private_:(T private_) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.ptyext_attributes;\n (let k = path ctx (x.ptyext_path).loc (x.ptyext_path).txt k in\n let k = params ctx loc x.ptyext_params k in\n let k = constructors ctx loc x.ptyext_constructors k in\n let k = private_ ctx loc x.ptyext_private k in k))\nlet ptype_abstract =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Ptype_abstract -> (ctx.matched <- (ctx.matched + 1); k)\n | _ -> fail loc \"abstract\")\nlet ptype_variant (T f0) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Ptype_variant x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"variant\")\nlet ptype_record (T f0) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Ptype_record x0 ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx loc x0 k in k))\n | _ -> fail loc \"record\")\nlet ptype_open =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Ptype_open -> (ctx.matched <- (ctx.matched + 1); k)\n | _ -> fail loc \"open\")\nlet value_binding_attributes (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pvb_loc in\n let k = f1 ctx loc x.pvb_attributes k in\n let x = { x with pvb_attributes = [] } in\n let k = f2 ctx loc x k in k)\nlet value_binding ~pat:(T pat) ~expr:(T expr) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pvb_attributes;\n (let k = pat ctx loc x.pvb_pat k in\n let k = expr ctx loc x.pvb_expr k in k))\nlet value_description_attributes (T f1) (T f2) =\n T\n (fun ctx ->\n fun _loc ->\n fun x ->\n fun k ->\n let loc = x.pval_loc in\n let k = f1 ctx loc x.pval_attributes k in\n let x = { x with pval_attributes = [] } in\n let k = f2 ctx loc x k in k)\nlet value_description ~name:(T name) ~type_:(T type_) ~prim:(T prim) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n Common.assert_no_attributes x.pval_attributes;\n (let k = name ctx (x.pval_name).loc (x.pval_name).txt k in\n let k = type_ ctx loc x.pval_type k in\n let k = prim ctx loc x.pval_prim k in k))\nlet covariant =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Covariant -> (ctx.matched <- (ctx.matched + 1); k)\n | _ -> fail loc \"Covariant\")\nlet contravariant =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Contravariant -> (ctx.matched <- (ctx.matched + 1); k)\n | _ -> fail loc \"Contravariant\")\nlet novariance =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | NoVariance -> (ctx.matched <- (ctx.matched + 1); k)\n | _ -> fail loc \"NoVariance\")\nlet virtual_ =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Virtual -> (ctx.matched <- (ctx.matched + 1); k)\n | _ -> fail loc \"Virtual\")\nlet concrete =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Concrete -> (ctx.matched <- (ctx.matched + 1); k)\n | _ -> fail loc \"Concrete\")\nlet pwith_type (T f0) (T f1) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Pwith_type (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx x0.loc x0.txt k in\n let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"type\")\nlet pwith_module (T f0) (T f1) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Pwith_module (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx x0.loc x0.txt k in\n let k = f1 ctx x1.loc x1.txt k in k))\n | _ -> fail loc \"module\")\nlet pwith_typesubst (T f0) (T f1) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Pwith_typesubst (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx x0.loc x0.txt k in\n let k = f1 ctx loc x1 k in k))\n | _ -> fail loc \"typesubst\")\nlet pwith_modsubst (T f0) (T f1) =\n T\n (fun ctx ->\n fun loc ->\n fun x ->\n fun k ->\n match x with\n | Pwith_modsubst (x0, x1) ->\n (ctx.matched <- (ctx.matched + 1);\n (let k = f0 ctx x0.loc x0.txt k in\n let k = f1 ctx x1.loc x1.txt k in k))\n | _ -> fail loc \"modsubst\")\n","open! Import\ninclude Ast_pattern0\n\nlet save_context ctx = ctx.matched\nlet restore_context ctx backup = ctx.matched <- backup\nlet incr_matched c = c.matched <- c.matched + 1\n\nlet parse (T f) loc ?on_error x k =\n try f { matched = 0 } loc x k\n with Expected (loc, expected) -> (\n match on_error with\n | None -> Location.raise_errorf ~loc \"%s expected\" expected\n | Some f -> f ())\n\nmodule Packed = struct\n type ('a, 'b) t = T : ('a, 'b, 'c) Ast_pattern0.t * 'b -> ('a, 'c) t\n\n let create t f = T (t, f)\n let parse (T (t, f)) loc x = parse t loc x f\nend\n\nlet __ =\n T\n (fun ctx _loc x k ->\n incr_matched ctx;\n k x)\n\nlet __' =\n T\n (fun ctx loc x k ->\n incr_matched ctx;\n k { loc; txt = x })\n\nlet drop =\n T\n (fun ctx _loc _ k ->\n incr_matched ctx;\n k)\n\nlet as__ (T f1) =\n T\n (fun ctx loc x k ->\n let k = f1 ctx loc x (k x) in\n k)\n\nlet cst ~to_string ?(equal = Poly.equal) v =\n T\n (fun ctx loc x k ->\n if equal x v then (\n incr_matched ctx;\n k)\n else fail loc (to_string v))\n\nlet int v = cst ~to_string:Int.to_string v\nlet char v = cst ~to_string:(Printf.sprintf \"%C\") v\nlet string v = cst ~to_string:(Printf.sprintf \"%S\") v\nlet float v = cst ~to_string:Float.to_string v\nlet int32 v = cst ~to_string:Int32.to_string v\nlet int64 v = cst ~to_string:Int64.to_string v\nlet nativeint v = cst ~to_string:Nativeint.to_string v\nlet bool v = cst ~to_string:Bool.to_string v\n\nlet false_ =\n T\n (fun ctx loc x k ->\n match x with\n | false ->\n ctx.matched <- ctx.matched + 1;\n k\n | _ -> fail loc \"false\")\n\nlet true_ =\n T\n (fun ctx loc x k ->\n match x with\n | true ->\n ctx.matched <- ctx.matched + 1;\n k\n | _ -> fail loc \"true\")\n\nlet nil =\n T\n (fun ctx loc x k ->\n match x with\n | [] ->\n ctx.matched <- ctx.matched + 1;\n k\n | _ -> fail loc \"[]\")\n\nlet ( ^:: ) (T f0) (T f1) =\n T\n (fun ctx loc x k ->\n match x with\n | x0 :: x1 ->\n ctx.matched <- ctx.matched + 1;\n let k = f0 ctx loc x0 k in\n let k = f1 ctx loc x1 k in\n k\n | _ -> fail loc \"::\")\n\nlet none =\n T\n (fun ctx loc x k ->\n match x with\n | None ->\n ctx.matched <- ctx.matched + 1;\n k\n | _ -> fail loc \"None\")\n\nlet some (T f0) =\n T\n (fun ctx loc x k ->\n match x with\n | Some x0 ->\n ctx.matched <- ctx.matched + 1;\n let k = f0 ctx loc x0 k in\n k\n | _ -> fail loc \"Some\")\n\nlet pair (T f1) (T f2) =\n T\n (fun ctx loc (x1, x2) k ->\n let k = f1 ctx loc x1 k in\n let k = f2 ctx loc x2 k in\n k)\n\nlet ( ** ) = pair\n\nlet triple (T f1) (T f2) (T f3) =\n T\n (fun ctx loc (x1, x2, x3) k ->\n let k = f1 ctx loc x1 k in\n let k = f2 ctx loc x2 k in\n let k = f3 ctx loc x3 k in\n k)\n\nlet alt (T f1) (T f2) =\n T\n (fun ctx loc x k ->\n let backup = save_context ctx in\n try f1 ctx loc x k\n with e1 -> (\n let m1 = save_context ctx in\n restore_context ctx backup;\n try f2 ctx loc x k\n with e2 ->\n let m2 = save_context ctx in\n if m1 >= m2 then (\n restore_context ctx m1;\n raise e1)\n else raise e2))\n\nlet ( ||| ) = alt\nlet map (T func) ~f = T (fun ctx loc x k -> func ctx loc x (f k))\nlet map' (T func) ~f = T (fun ctx loc x k -> func ctx loc x (f loc k))\nlet map_result (T func) ~f = T (fun ctx loc x k -> f (func ctx loc x k))\nlet ( >>| ) t f = map t ~f\nlet map0 (T func) ~f = T (fun ctx loc x k -> func ctx loc x (k f))\nlet map1 (T func) ~f = T (fun ctx loc x k -> func ctx loc x (fun a -> k (f a)))\n\nlet map2 (T func) ~f =\n T (fun ctx loc x k -> func ctx loc x (fun a b -> k (f a b)))\n\nlet map0' (T func) ~f = T (fun ctx loc x k -> func ctx loc x (k (f loc)))\n\nlet map1' (T func) ~f =\n T (fun ctx loc x k -> func ctx loc x (fun a -> k (f loc a)))\n\nlet map2' (T func) ~f =\n T (fun ctx loc x k -> func ctx loc x (fun a b -> k (f loc a b)))\n\nlet alt_option some none =\n alt (map1 some ~f:(fun x -> Some x)) (map0 none ~f:None)\n\nlet many (T f) =\n T (fun ctx loc l k -> k (List.map l ~f:(fun x -> f ctx loc x (fun x -> x))))\n\nlet loc (T f) = T (fun ctx _loc (x : _ Loc.t) k -> f ctx x.loc x.txt k)\nlet pack0 t = map t ~f:(fun f -> f ())\nlet pack2 t = map t ~f:(fun f x y -> f (x, y))\nlet pack3 t = map t ~f:(fun f x y z -> f (x, y, z))\n\ninclude Ast_pattern_generated\n\nlet echar t = pexp_constant (pconst_char t)\nlet estring t = pexp_constant (pconst_string t drop drop)\nlet efloat t = pexp_constant (pconst_float t drop)\nlet pchar t = ppat_constant (pconst_char t)\nlet pstring t = ppat_constant (pconst_string t drop drop)\nlet pfloat t = ppat_constant (pconst_float t drop)\nlet int' (T f) = T (fun ctx loc x k -> f ctx loc (int_of_string x) k)\nlet int32' (T f) = T (fun ctx loc x k -> f ctx loc (Int32.of_string x) k)\nlet int64' (T f) = T (fun ctx loc x k -> f ctx loc (Int64.of_string x) k)\n\nlet nativeint' (T f) =\n T (fun ctx loc x k -> f ctx loc (Nativeint.of_string x) k)\n\nlet const_int t = pconst_integer (int' t) none\nlet const_int32 t = pconst_integer (int32' t) (some (char 'l'))\nlet const_int64 t = pconst_integer (int64' t) (some (char 'L'))\nlet const_nativeint t = pconst_integer (nativeint' t) (some (char 'n'))\nlet eint t = pexp_constant (const_int t)\nlet eint32 t = pexp_constant (const_int32 t)\nlet eint64 t = pexp_constant (const_int64 t)\nlet enativeint t = pexp_constant (const_nativeint t)\nlet pint t = ppat_constant (const_int t)\nlet pint32 t = ppat_constant (const_int32 t)\nlet pint64 t = ppat_constant (const_int64 t)\nlet pnativeint t = ppat_constant (const_nativeint t)\nlet single_expr_payload t = pstr (pstr_eval t nil ^:: nil)\nlet no_label t = cst Asttypes.Nolabel ~to_string:(fun _ -> \"Nolabel\") ** t\n\nlet extension (T f1) (T f2) =\n T\n (fun ctx loc ((name : _ Loc.t), payload) k ->\n let k = f1 ctx name.loc name.txt k in\n let k = f2 ctx loc payload k in\n k)\n\nlet rec parse_elist (e : Parsetree.expression) acc =\n Common.assert_no_attributes e.pexp_attributes;\n match e.pexp_desc with\n | Pexp_construct ({ txt = Lident \"[]\"; _ }, None) -> List.rev acc\n | Pexp_construct ({ txt = Lident \"::\"; _ }, Some arg) -> (\n Common.assert_no_attributes arg.pexp_attributes;\n match arg.pexp_desc with\n | Pexp_tuple [ hd; tl ] -> parse_elist tl (hd :: acc)\n | _ -> fail arg.pexp_loc \"list\")\n | _ -> fail e.pexp_loc \"list\"\n\nlet elist (T f) =\n T\n (fun ctx _loc e k ->\n let l = parse_elist e [] in\n incr_matched ctx;\n k (List.map l ~f:(fun x -> f ctx x.Parsetree.pexp_loc x (fun x -> x))))\n\nlet esequence (T f) =\n T\n (fun ctx _loc e k ->\n let rec parse_seq expr acc =\n match expr.pexp_desc with\n | Pexp_sequence (expr, next) -> parse_seq next (expr :: acc)\n | _ -> expr :: acc\n in\n k\n (List.rev_map (parse_seq e []) ~f:(fun expr ->\n f ctx expr.pexp_loc expr (fun x -> x))))\n\nlet of_func f = T f\nlet to_func (T f) = f\n","open! Import\nopen Common\n\ntype (_, _) equality = Eq : ('a, 'a) equality | Ne : (_, _) equality\n\nmodule Context = struct\n type 'a t =\n | Class_expr : class_expr t\n | Class_field : class_field t\n | Class_type : class_type t\n | Class_type_field : class_type_field t\n | Core_type : core_type t\n | Expression : expression t\n | Module_expr : module_expr t\n | Module_type : module_type t\n | Pattern : pattern t\n | Signature_item : signature_item t\n | Structure_item : structure_item t\n | Ppx_import : type_declaration t\n\n type packed = T : _ t -> packed\n\n let class_expr = Class_expr\n let class_field = Class_field\n let class_type = Class_type\n let class_type_field = Class_type_field\n let core_type = Core_type\n let expression = Expression\n let module_expr = Module_expr\n let module_type = Module_type\n let pattern = Pattern\n let signature_item = Signature_item\n let structure_item = Structure_item\n\n let desc : type a. a t -> string = function\n | Class_expr -> \"class expression\"\n | Class_field -> \"class field\"\n | Class_type -> \"class type\"\n | Class_type_field -> \"class type field\"\n | Core_type -> \"core type\"\n | Expression -> \"expression\"\n | Module_expr -> \"module expression\"\n | Module_type -> \"module type\"\n | Pattern -> \"pattern\"\n | Signature_item -> \"signature item\"\n | Structure_item -> \"structure item\"\n | Ppx_import -> \"type declaration\"\n\n let eq : type a b. a t -> b t -> (a, b) equality =\n fun a b ->\n match (a, b) with\n | Class_expr, Class_expr -> Eq\n | Class_field, Class_field -> Eq\n | Class_type, Class_type -> Eq\n | Class_type_field, Class_type_field -> Eq\n | Core_type, Core_type -> Eq\n | Expression, Expression -> Eq\n | Module_expr, Module_expr -> Eq\n | Module_type, Module_type -> Eq\n | Pattern, Pattern -> Eq\n | Signature_item, Signature_item -> Eq\n | Structure_item, Structure_item -> Eq\n | Ppx_import, Ppx_import -> Eq\n | _ ->\n assert (Poly.( <> ) (T a) (T b));\n Ne\n\n let get_ppx_import_extension type_decl =\n match type_decl with\n | { ptype_manifest = Some { ptyp_desc = Ptyp_extension (name, _); _ }; _ }\n ->\n let virtual_payload =\n Ast_builder.Default.pstr_type ~loc:type_decl.ptype_loc Recursive\n [ type_decl ]\n in\n let attr = [] in\n Some ((name, PStr [ virtual_payload ]), attr)\n | _ -> None\n\n let get_extension : type a. a t -> a -> (extension * attributes) option =\n fun t x ->\n match (t, x) with\n | Class_expr, { pcl_desc = Pcl_extension e; pcl_attributes = a; _ } ->\n Some (e, a)\n | Class_field, { pcf_desc = Pcf_extension e; pcf_attributes = a; _ } ->\n Some (e, a)\n | Class_type, { pcty_desc = Pcty_extension e; pcty_attributes = a; _ } ->\n Some (e, a)\n | Class_type_field, { pctf_desc = Pctf_extension e; pctf_attributes = a; _ }\n ->\n Some (e, a)\n | Core_type, { ptyp_desc = Ptyp_extension e; ptyp_attributes = a; _ } ->\n Some (e, a)\n | Expression, { pexp_desc = Pexp_extension e; pexp_attributes = a; _ } ->\n Some (e, a)\n | Module_expr, { pmod_desc = Pmod_extension e; pmod_attributes = a; _ } ->\n Some (e, a)\n | Module_type, { pmty_desc = Pmty_extension e; pmty_attributes = a; _ } ->\n Some (e, a)\n | Pattern, { ppat_desc = Ppat_extension e; ppat_attributes = a; _ } ->\n Some (e, a)\n | Signature_item, { psig_desc = Psig_extension (e, a); _ } -> Some (e, a)\n | Structure_item, { pstr_desc = Pstr_extension (e, a); _ } -> Some (e, a)\n | Ppx_import, type_decl -> get_ppx_import_extension type_decl\n | _ -> None\n\n let merge_attributes : type a. a t -> a -> attributes -> a =\n fun t x attrs ->\n match t with\n | Class_expr -> { x with pcl_attributes = x.pcl_attributes @ attrs }\n | Class_field -> { x with pcf_attributes = x.pcf_attributes @ attrs }\n | Class_type -> { x with pcty_attributes = x.pcty_attributes @ attrs }\n | Class_type_field -> { x with pctf_attributes = x.pctf_attributes @ attrs }\n | Core_type -> { x with ptyp_attributes = x.ptyp_attributes @ attrs }\n | Expression -> { x with pexp_attributes = x.pexp_attributes @ attrs }\n | Module_expr -> { x with pmod_attributes = x.pmod_attributes @ attrs }\n | Module_type -> { x with pmty_attributes = x.pmty_attributes @ attrs }\n | Pattern -> { x with ppat_attributes = x.ppat_attributes @ attrs }\n | Signature_item ->\n assert_no_attributes attrs;\n x\n | Structure_item ->\n assert_no_attributes attrs;\n x\n | Ppx_import ->\n assert_no_attributes attrs;\n x\nend\n\nlet registrar =\n Name.Registrar.create ~kind:\"extension\" ~current_file:__FILE__\n ~string_of_context:(fun (Context.T ctx) -> Some (Context.desc ctx))\n\nmodule Make (Callback : sig\n type 'a t\nend) =\nstruct\n type ('a, 'b) payload_parser =\n | Payload_parser :\n ('a, 'b, 'c) Ast_pattern.t * 'b Callback.t\n -> ('a, 'c) payload_parser\n\n type ('context, 'payload) t = {\n name : Name.Pattern.t;\n context : 'context Context.t;\n payload : (payload, 'payload) payload_parser;\n with_arg : bool;\n }\n\n let declare :\n type a.\n with_arg:bool ->\n string ->\n a Context.t ->\n (payload, 'b, 'payload) Ast_pattern.t ->\n 'b Callback.t ->\n (a, 'payload) t =\n fun ~with_arg name context pattern k ->\n (* Check that there is no collisions between ppx_import and core_type\n extensions *)\n (match context with\n | Context.Ppx_import ->\n Name.Registrar.check_collisions registrar (Context.T Core_type) name\n | Context.Core_type ->\n Name.Registrar.check_collisions registrar (Context.T Ppx_import) name\n | _ -> ());\n Name.Registrar.register ~kind:`Extension registrar (Context.T context) name;\n {\n name = Name.Pattern.make name;\n context;\n payload = Payload_parser (pattern, k);\n with_arg;\n }\n\n let find ts (ext : extension) =\n let { txt = name; loc } = fst ext in\n let name, arg = Name.split_path name in\n match List.filter ts ~f:(fun t -> Name.Pattern.matches t.name name) with\n | [] -> None\n | _ :: _ :: _ as l ->\n Location.raise_errorf ~loc \"Multiple match for extensions: %s\"\n (String.concat ~sep:\", \"\n (List.map l ~f:(fun t -> Name.Pattern.name t.name)))\n | [ t ] ->\n if (not t.with_arg) && Option.is_some arg then\n Location.raise_errorf ~loc\n \"Extension %s doesn't expect a path argument\" name;\n let arg =\n Option.map arg ~f:(fun s ->\n let shift = String.length name + 1 in\n let start = loc.loc_start in\n {\n txt = Longident.parse s;\n loc =\n {\n loc with\n loc_start = { start with pos_cnum = start.pos_cnum + shift };\n };\n })\n in\n Some (t, arg)\nend\n\nmodule Expert = struct\n include Make (struct\n type 'a t = arg:Longident.t Loc.t option -> 'a\n end)\n\n let declare_with_path_arg name ctx patt f =\n declare ~with_arg:true name ctx patt f\n\n let declare name ctx patt f =\n declare ~with_arg:false name ctx patt (fun ~arg:_ -> f)\n\n let convert ts ~loc ext =\n match find ts ext with\n | None -> None\n | Some ({ payload = Payload_parser (pattern, f); _ }, arg) ->\n Some (Ast_pattern.parse pattern loc (snd ext) (f ~arg))\nend\n\nmodule M = Make (struct\n type 'a t =\n ctxt:Expansion_context.Extension.t -> arg:Longident.t Loc.t option -> 'a\nend)\n\ntype 'a expander_result = Simple of 'a | Inline of 'a list\n\nmodule For_context = struct\n type 'a t = ('a, 'a expander_result) M.t\n\n let convert ts ~ctxt ext =\n let loc = Expansion_context.Extension.extension_point_loc ctxt in\n match M.find ts ext with\n | None -> None\n | Some ({ payload = M.Payload_parser (pattern, f); _ }, arg) -> (\n match Ast_pattern.parse pattern loc (snd ext) (f ~ctxt ~arg) with\n | Simple x -> Some x\n | Inline _ -> failwith \"Extension.convert\")\n\n let convert_inline ts ~ctxt ext =\n let loc = Expansion_context.Extension.extension_point_loc ctxt in\n match M.find ts ext with\n | None -> None\n | Some ({ payload = M.Payload_parser (pattern, f); _ }, arg) -> (\n match Ast_pattern.parse pattern loc (snd ext) (f ~ctxt ~arg) with\n | Simple x -> Some [ x ]\n | Inline l -> Some l)\nend\n\ntype t = T : _ For_context.t -> t\n\nlet check_context_for_inline : type a. func:string -> a Context.t -> unit =\n fun ~func ctx ->\n match ctx with\n | Context.Class_field -> ()\n | Context.Class_type_field -> ()\n | Context.Signature_item -> ()\n | Context.Structure_item -> ()\n | context ->\n Printf.ksprintf invalid_arg \"%s: %s can't be inlined\" func\n (Context.desc context)\n\nlet rec filter_by_context :\n type a. a Context.t -> t list -> a For_context.t list =\n fun context expanders ->\n match expanders with\n | [] -> []\n | T t :: rest -> (\n match Context.eq context t.context with\n | Eq -> t :: filter_by_context context rest\n | Ne -> filter_by_context context rest)\n\nlet fail ctx (name, _) =\n if\n not\n (Name.Whitelisted.is_whitelisted ~kind:`Extension name.txt\n || Name.ignore_checks name.txt)\n then\n Name.Registrar.raise_errorf registrar (Context.T ctx)\n \"Extension `%s' was not translated\" name\n\nlet check_unused =\n object\n inherit Ast_traverse.iter as super\n\n method! extension (name, _) =\n Location.raise_errorf ~loc:name.loc\n \"extension not expected here, Ppxlib.Extension needs updating!\"\n\n method! core_type_desc =\n function\n | Ptyp_extension ext -> fail Core_type ext | x -> super#core_type_desc x\n\n method! pattern_desc =\n function\n | Ppat_extension ext -> fail Pattern ext | x -> super#pattern_desc x\n\n method! expression_desc =\n function\n | Pexp_extension ext -> fail Expression ext | x -> super#expression_desc x\n\n method! class_type_desc =\n function\n | Pcty_extension ext -> fail Class_type ext | x -> super#class_type_desc x\n\n method! class_type_field_desc =\n function\n | Pctf_extension ext -> fail Class_type_field ext\n | x -> super#class_type_field_desc x\n\n method! class_expr_desc =\n function\n | Pcl_extension ext -> fail Class_expr ext | x -> super#class_expr_desc x\n\n method! class_field_desc =\n function\n | Pcf_extension ext -> fail Class_field ext\n | x -> super#class_field_desc x\n\n method! module_type_desc =\n function\n | Pmty_extension ext -> fail Module_type ext\n | x -> super#module_type_desc x\n\n method! signature_item_desc =\n function\n | Psig_extension (ext, _) -> fail Signature_item ext\n | x -> super#signature_item_desc x\n\n method! module_expr_desc =\n function\n | Pmod_extension ext -> fail Module_expr ext\n | x -> super#module_expr_desc x\n\n method! structure_item_desc =\n function\n | Pstr_extension (ext, _) -> fail Structure_item ext\n | x -> super#structure_item_desc x\n end\n\nmodule V3 = struct\n type nonrec t = t\n\n let declare name context pattern k =\n let pattern = Ast_pattern.map_result pattern ~f:(fun x -> Simple x) in\n T\n (M.declare ~with_arg:false name context pattern (fun ~ctxt ~arg:_ ->\n k ~ctxt))\n\n let declare_inline name context pattern k =\n check_context_for_inline context ~func:\"Extension.declare_inline\";\n let pattern = Ast_pattern.map_result pattern ~f:(fun x -> Inline x) in\n T\n (M.declare ~with_arg:false name context pattern (fun ~ctxt ~arg:_ ->\n k ~ctxt))\nend\n\nlet declare name context pattern f =\n V3.declare name context pattern\n (Expansion_context.Extension.with_loc_and_path f)\n\nlet declare_inline name context pattern f =\n V3.declare_inline name context pattern\n (Expansion_context.Extension.with_loc_and_path f)\n\nlet declare_with_path_arg name context pattern k =\n let k' = Expansion_context.Extension.with_loc_and_path k in\n let pattern = Ast_pattern.map_result pattern ~f:(fun x -> Simple x) in\n T (M.declare ~with_arg:true name context pattern k')\n\nlet declare_inline_with_path_arg name context pattern k =\n let k' = Expansion_context.Extension.with_loc_and_path k in\n check_context_for_inline context\n ~func:\"Extension.declare_inline_with_path_arg\";\n let pattern = Ast_pattern.map_result pattern ~f:(fun x -> Inline x) in\n T (M.declare ~with_arg:true name context pattern k')\n\nlet __declare_ppx_import name expand =\n (* This pattern is used to unwrap the type declaration from the payload\n assembled by [Context.get_ppx_import_extension] *)\n let pattern = Ast_pattern.(pstr (pstr_type recursive (__ ^:: nil) ^:: nil)) in\n V3.declare name Context.Ppx_import pattern expand\n\nmodule V2 = struct\n type nonrec t = t\n\n let declare = declare\n let declare_inline = declare_inline\nend\n","(*$ open Ppxlib_cinaps_helpers $*)\nopen! Import\nopen Common\nmodule E = Extension\nmodule EC = Extension.Context\nmodule A = Attribute\nmodule AC = Attribute.Context\n\nmodule Rule = struct\n module Attr_group_inline = struct\n type ('a, 'b, 'c) unpacked = {\n attribute : ('b, 'c) Attribute.t;\n expect : bool;\n expand :\n ctxt:Expansion_context.Deriver.t ->\n Asttypes.rec_flag ->\n 'b list ->\n 'c option list ->\n 'a list;\n }\n\n type ('a, 'b) t = T : ('a, 'b, _) unpacked -> ('a, 'b) t\n\n let attr_name (T t) = Attribute.name t.attribute\n\n let split_normal_and_expect l =\n List.partition l ~f:(fun (T t) -> not t.expect)\n end\n\n module Attr_inline = struct\n type ('a, 'b, 'c) unpacked = {\n attribute : ('b, 'c) Attribute.t;\n expect : bool;\n expand : ctxt:Expansion_context.Deriver.t -> 'b -> 'c -> 'a list;\n }\n\n type ('a, 'b) t = T : ('a, 'b, _) unpacked -> ('a, 'b) t\n\n let attr_name (T t) = Attribute.name t.attribute\n\n let split_normal_and_expect l =\n List.partition l ~f:(fun (T t) -> not t.expect)\n end\n\n module Special_function = struct\n type t = {\n name : string;\n ident : Longident.t;\n expand : Parsetree.expression -> Parsetree.expression option;\n }\n end\n\n module Constant_kind = struct\n type t = Float | Integer\n end\n\n module Constant = struct\n type t = {\n suffix : char;\n kind : Constant_kind.t;\n expand : Location.t -> string -> Parsetree.expression;\n }\n end\n\n module Field = struct\n type 'a t =\n | Extension : Extension.t t\n | Special_function : Special_function.t t\n | Constant : Constant.t t\n | Attr_str_type_decl\n : (structure_item, type_declaration) Attr_group_inline.t t\n | Attr_sig_type_decl\n : (signature_item, type_declaration) Attr_group_inline.t t\n | Attr_str_module_type_decl\n : (structure_item, module_type_declaration) Attr_inline.t t\n | Attr_sig_module_type_decl\n : (signature_item, module_type_declaration) Attr_inline.t t\n | Attr_str_type_ext : (structure_item, type_extension) Attr_inline.t t\n | Attr_sig_type_ext : (signature_item, type_extension) Attr_inline.t t\n | Attr_str_exception : (structure_item, type_exception) Attr_inline.t t\n | Attr_sig_exception : (signature_item, type_exception) Attr_inline.t t\n\n type (_, _) equality = Eq : ('a, 'a) equality | Ne : (_, _) equality\n\n let eq : type a b. a t -> b t -> (a, b) equality =\n fun a b ->\n match (a, b) with\n | Extension, Extension -> Eq\n | Special_function, Special_function -> Eq\n | Constant, Constant -> Eq\n | Attr_str_type_decl, Attr_str_type_decl -> Eq\n | Attr_sig_type_decl, Attr_sig_type_decl -> Eq\n | Attr_str_type_ext, Attr_str_type_ext -> Eq\n | Attr_sig_type_ext, Attr_sig_type_ext -> Eq\n | Attr_str_exception, Attr_str_exception -> Eq\n | Attr_sig_exception, Attr_sig_exception -> Eq\n | Attr_str_module_type_decl, Attr_str_module_type_decl -> Eq\n | Attr_sig_module_type_decl, Attr_sig_module_type_decl -> Eq\n | _ -> Ne\n end\n\n type t = T : 'a Field.t * 'a -> t\n\n type ('a, 'b, 'c) attr_group_inline =\n ('b, 'c) Attribute.t ->\n (ctxt:Expansion_context.Deriver.t ->\n Asttypes.rec_flag ->\n 'b list ->\n 'c option list ->\n 'a list) ->\n t\n\n type ('a, 'b, 'c) attr_inline =\n ('b, 'c) Attribute.t ->\n (ctxt:Expansion_context.Deriver.t -> 'b -> 'c -> 'a list) ->\n t\n\n let rec filter : type a. a Field.t -> t list -> a list =\n fun field l ->\n match l with\n | [] -> []\n | T (field', x) :: l -> (\n match Field.eq field field' with\n | Field.Eq -> x :: filter field l\n | Field.Ne -> filter field l)\n\n let extension ext = T (Extension, ext)\n\n let special_function id f =\n T (Special_function, { name = id; ident = Longident.parse id; expand = f })\n\n let constant kind suffix expand = T (Constant, { suffix; kind; expand })\n\n let attr_str_type_decl attribute expand =\n T (Attr_str_type_decl, T { attribute; expand; expect = false })\n\n let attr_sig_type_decl attribute expand =\n T (Attr_sig_type_decl, T { attribute; expand; expect = false })\n\n let attr_str_module_type_decl attribute expand =\n T (Attr_str_module_type_decl, T { attribute; expand; expect = false })\n\n let attr_sig_module_type_decl attribute expand =\n T (Attr_sig_module_type_decl, T { attribute; expand; expect = false })\n\n let attr_str_type_ext attribute expand =\n T (Attr_str_type_ext, T { attribute; expand; expect = false })\n\n let attr_sig_type_ext attribute expand =\n T (Attr_sig_type_ext, T { attribute; expand; expect = false })\n\n let attr_str_exception attribute expand =\n T (Attr_str_exception, T { attribute; expand; expect = false })\n\n let attr_sig_exception attribute expand =\n T (Attr_sig_exception, T { attribute; expand; expect = false })\n\n let attr_str_type_decl_expect attribute expand =\n T (Attr_str_type_decl, T { attribute; expand; expect = true })\n\n let attr_sig_type_decl_expect attribute expand =\n T (Attr_sig_type_decl, T { attribute; expand; expect = true })\n\n let attr_str_module_type_decl_expect attribute expand =\n T (Attr_str_module_type_decl, T { attribute; expand; expect = true })\n\n let attr_sig_module_type_decl_expect attribute expand =\n T (Attr_sig_module_type_decl, T { attribute; expand; expect = true })\n\n let attr_str_type_ext_expect attribute expand =\n T (Attr_str_type_ext, T { attribute; expand; expect = true })\n\n let attr_sig_type_ext_expect attribute expand =\n T (Attr_sig_type_ext, T { attribute; expand; expect = true })\n\n let attr_str_exception_expect attribute expand =\n T (Attr_str_exception, T { attribute; expand; expect = true })\n\n let attr_sig_exception_expect attribute expand =\n T (Attr_sig_exception, T { attribute; expand; expect = true })\nend\n\nmodule Generated_code_hook = struct\n type 'a single_or_many = Single of 'a | Many of 'a list\n\n type t = {\n f : 'a. 'a Extension.Context.t -> Location.t -> 'a single_or_many -> unit;\n }\n\n let nop = { f = (fun _ _ _ -> ()) }\n let replace t context loc x = t.f context loc x\n\n let insert_after t context (loc : Location.t) x =\n match x with\n | Many [] -> ()\n | _ -> t.f context { loc with loc_start = loc.loc_end } x\nend\n\nlet rec map_node_rec context ts super_call loc base_ctxt x =\n let ctxt =\n Expansion_context.Extension.make ~extension_point_loc:loc ~base:base_ctxt ()\n in\n match EC.get_extension context x with\n | None -> super_call base_ctxt x\n | Some (ext, attrs) -> (\n match E.For_context.convert ts ~ctxt ext with\n | None -> super_call base_ctxt x\n | Some x ->\n map_node_rec context ts super_call loc base_ctxt\n (EC.merge_attributes context x attrs))\n\nlet map_node context ts super_call loc base_ctxt x ~hook =\n let ctxt =\n Expansion_context.Extension.make ~extension_point_loc:loc ~base:base_ctxt ()\n in\n match EC.get_extension context x with\n | None -> super_call base_ctxt x\n | Some (ext, attrs) -> (\n match E.For_context.convert ts ~ctxt ext with\n | None -> super_call base_ctxt x\n | Some x ->\n let generated_code =\n map_node_rec context ts super_call loc base_ctxt\n (EC.merge_attributes context x attrs)\n in\n Generated_code_hook.replace hook context loc (Single generated_code);\n generated_code)\n\nlet rec map_nodes context ts super_call get_loc base_ctxt l ~hook\n ~in_generated_code =\n match l with\n | [] -> []\n | x :: l -> (\n match EC.get_extension context x with\n | None ->\n (* These two lets force the evaluation order, so that errors are reported in the\n same order as they appear in the source file. *)\n let x = super_call base_ctxt x in\n let l =\n map_nodes context ts super_call get_loc base_ctxt l ~hook\n ~in_generated_code\n in\n x :: l\n | Some (ext, attrs) -> (\n let extension_point_loc = get_loc x in\n let ctxt =\n Expansion_context.Extension.make ~extension_point_loc\n ~base:base_ctxt ()\n in\n match E.For_context.convert_inline ts ~ctxt ext with\n | None ->\n let x = super_call base_ctxt x in\n let l =\n map_nodes context ts super_call get_loc base_ctxt l ~hook\n ~in_generated_code\n in\n x :: l\n | Some x ->\n assert_no_attributes attrs;\n let generated_code =\n map_nodes context ts super_call get_loc base_ctxt x ~hook\n ~in_generated_code:true\n in\n if not in_generated_code then\n Generated_code_hook.replace hook context extension_point_loc\n (Many generated_code);\n generated_code\n @ map_nodes context ts super_call get_loc base_ctxt l ~hook\n ~in_generated_code))\n\nlet map_nodes = map_nodes ~in_generated_code:false\n\nlet table_of_special_functions special_functions =\n match\n List.map special_functions\n ~f:(fun { Rule.Special_function.ident; expand; _ } -> (ident, expand))\n (* We expect the lookup to fail most of the time, by making the table big (and\n sparse), we make it more likely to fail quickly *)\n |> Hashtbl.of_alist ~size:(max 1024 (List.length special_functions * 2))\n with\n | Ok table -> table\n | Error ident ->\n Printf.ksprintf invalid_arg\n \"Context_free.V1.map_top_down: %s present twice in list of special \\\n functions\"\n (List.find_map_exn special_functions ~f:(fun r ->\n if Poly.equal r.ident ident then Some r.name else None))\n\n(* [get_group attr l] returns the list of the attributes for each\n node in [l].\n If [l] is empty or if none of the nodes in [l] have an attribute attached,\n [get_group] returns [None].\n If [l] is not empty and at least one of the nodes in [l] has an attribue\n attached, [get_group] returns the equivalent of\n [Some (List.map ~f:(Attribute.get attr) l)]. *)\nlet rec get_group attr l =\n match l with\n | [] -> None\n | x :: l -> (\n match (Attribute.get attr x, get_group attr l) with\n | None, None -> None\n | None, Some vals -> Some (None :: vals)\n | Some value, None -> Some (Some value :: List.map l ~f:(fun _ -> None))\n | Some value, Some vals -> Some (Some value :: vals))\n\n(* Same as [List.rev] then [List.concat] but expecting the input to be of length <= 2 *)\nlet rev_concat = function\n | [] -> []\n | [ x ] -> x\n | [ x; y ] -> y @ x\n | l -> List.concat (List.rev l)\n\nlet sort_attr_group_inline l =\n List.sort l ~cmp:(fun a b ->\n String.compare\n (Rule.Attr_group_inline.attr_name a)\n (Rule.Attr_group_inline.attr_name b))\n\nlet sort_attr_inline l =\n List.sort l ~cmp:(fun a b ->\n String.compare\n (Rule.Attr_inline.attr_name a)\n (Rule.Attr_inline.attr_name b))\n\nlet context_free_attribute_modification ~loc =\n Location.raise_errorf ~loc\n \"A context-free rule deleted or added attribues of a str/sig item\"\n\n(* Returns the code generated by attribute handlers. We don't remove these attributes, as\n another pass might interpret them later. For instance both ppx_deriving and\n ppxlib_deriving interprets [@@deriving] attributes.\n\n This complexity is horrible, but in practice we don't care as [attrs] is always a list\n of one element; it only has [@@deriving].\n*)\nlet handle_attr_group_inline attrs rf ~items ~expanded_items ~loc ~base_ctxt =\n List.fold_left attrs ~init:[] ~f:(fun acc (Rule.Attr_group_inline.T group) ->\n match\n ( get_group group.attribute items,\n get_group group.attribute expanded_items )\n with\n | None, None -> acc\n | None, Some _ | Some _, None -> context_free_attribute_modification ~loc\n | Some values, Some _ ->\n let ctxt =\n Expansion_context.Deriver.make ~derived_item_loc:loc\n ~inline:group.expect ~base:base_ctxt ()\n in\n let expect_items = group.expand ~ctxt rf expanded_items values in\n expect_items :: acc)\n\nlet handle_attr_inline attrs ~item ~expanded_item ~loc ~base_ctxt =\n List.fold_left attrs ~init:[] ~f:(fun acc (Rule.Attr_inline.T a) ->\n match\n (Attribute.get a.attribute item, Attribute.get a.attribute expanded_item)\n with\n | None, None -> acc\n | None, Some _ | Some _, None -> context_free_attribute_modification ~loc\n | Some value, Some _ ->\n let ctxt =\n Expansion_context.Deriver.make ~derived_item_loc:loc\n ~inline:a.expect ~base:base_ctxt ()\n in\n let expect_items = a.expand ~ctxt expanded_item value in\n expect_items :: acc)\n\nmodule Expect_mismatch_handler = struct\n type t = {\n f : 'a. 'a Attribute.Floating.Context.t -> Location.t -> 'a list -> unit;\n }\n\n let nop = { f = (fun _ _ _ -> ()) }\nend\n\nclass map_top_down ?(expect_mismatch_handler = Expect_mismatch_handler.nop)\n ?(generated_code_hook = Generated_code_hook.nop) rules =\n let hook = generated_code_hook in\n\n let special_functions =\n Rule.filter Special_function rules |> table_of_special_functions\n in\n let constants =\n Rule.filter Constant rules\n |> List.map ~f:(fun (c : Rule.Constant.t) -> ((c.suffix, c.kind), c.expand))\n |> Hashtbl.of_alist_exn\n in\n let extensions = Rule.filter Extension rules in\n let class_expr = E.filter_by_context EC.class_expr extensions\n and class_field = E.filter_by_context EC.class_field extensions\n and class_type = E.filter_by_context EC.class_type extensions\n and class_type_field = E.filter_by_context EC.class_type_field extensions\n and core_type = E.filter_by_context EC.core_type extensions\n and expression = E.filter_by_context EC.expression extensions\n and module_expr = E.filter_by_context EC.module_expr extensions\n and module_type = E.filter_by_context EC.module_type extensions\n and pattern = E.filter_by_context EC.pattern extensions\n and signature_item = E.filter_by_context EC.signature_item extensions\n and structure_item = E.filter_by_context EC.structure_item extensions\n and ppx_import = E.filter_by_context EC.Ppx_import extensions in\n\n let attr_str_type_decls, attr_str_type_decls_expect =\n Rule.filter Attr_str_type_decl rules\n |> sort_attr_group_inline |> Rule.Attr_group_inline.split_normal_and_expect\n in\n let attr_sig_type_decls, attr_sig_type_decls_expect =\n Rule.filter Attr_sig_type_decl rules\n |> sort_attr_group_inline |> Rule.Attr_group_inline.split_normal_and_expect\n in\n\n let attr_str_module_type_decls, attr_str_module_type_decls_expect =\n Rule.filter Attr_str_module_type_decl rules\n |> sort_attr_inline |> Rule.Attr_inline.split_normal_and_expect\n in\n let attr_sig_module_type_decls, attr_sig_module_type_decls_expect =\n Rule.filter Attr_sig_module_type_decl rules\n |> sort_attr_inline |> Rule.Attr_inline.split_normal_and_expect\n in\n\n let attr_str_type_exts, attr_str_type_exts_expect =\n Rule.filter Attr_str_type_ext rules\n |> sort_attr_inline |> Rule.Attr_inline.split_normal_and_expect\n in\n let attr_sig_type_exts, attr_sig_type_exts_expect =\n Rule.filter Attr_sig_type_ext rules\n |> sort_attr_inline |> Rule.Attr_inline.split_normal_and_expect\n in\n\n let attr_str_exceptions, attr_str_exceptions_expect =\n Rule.filter Attr_str_exception rules\n |> sort_attr_inline |> Rule.Attr_inline.split_normal_and_expect\n in\n let attr_sig_exceptions, attr_sig_exceptions_expect =\n Rule.filter Attr_sig_exception rules\n |> sort_attr_inline |> Rule.Attr_inline.split_normal_and_expect\n in\n\n let map_node = map_node ~hook in\n let map_nodes = map_nodes ~hook in\n\n object (self)\n inherit Ast_traverse.map_with_expansion_context as super\n\n (* No point recursing into every location *)\n method! location _ x = x\n\n method! core_type base_ctxt x =\n map_node EC.core_type core_type super#core_type x.ptyp_loc base_ctxt x\n\n method! pattern base_ctxt x =\n map_node EC.pattern pattern super#pattern x.ppat_loc base_ctxt x\n\n method! expression base_ctxt e =\n let e =\n match e.pexp_desc with\n | Pexp_extension _ ->\n map_node EC.expression expression\n (fun _ e -> e)\n e.pexp_loc base_ctxt e\n | _ -> e\n in\n let expand_constant kind char text =\n match Hashtbl.find_opt constants (char, kind) with\n | None -> super#expression base_ctxt e\n | Some expand -> self#expression base_ctxt (expand e.pexp_loc text)\n in\n match e.pexp_desc with\n | Pexp_apply (({ pexp_desc = Pexp_ident id; _ } as func), args) -> (\n match Hashtbl.find_opt special_functions id.txt with\n | None ->\n self#pexp_apply_without_traversing_function base_ctxt e func args\n | Some pattern -> (\n match pattern e with\n | None ->\n self#pexp_apply_without_traversing_function base_ctxt e func\n args\n | Some e -> self#expression base_ctxt e))\n | Pexp_ident id -> (\n match Hashtbl.find_opt special_functions id.txt with\n | None -> super#expression base_ctxt e\n | Some pattern -> (\n match pattern e with\n | None -> super#expression base_ctxt e\n | Some e -> self#expression base_ctxt e))\n | Pexp_constant (Pconst_integer (s, Some c)) ->\n expand_constant Integer c s\n | Pexp_constant (Pconst_float (s, Some c)) -> expand_constant Float c s\n | _ -> super#expression base_ctxt e\n\n (* Pre-conditions:\n - e.pexp_desc = Pexp_apply(func, args)\n - func.pexp_desc = Pexp_ident _\n *)\n method private pexp_apply_without_traversing_function base_ctxt e func args\n =\n let { pexp_desc = _; pexp_loc; pexp_attributes; pexp_loc_stack } = e in\n let func =\n let { pexp_desc; pexp_loc; pexp_attributes; pexp_loc_stack } = func in\n let pexp_attributes = self#attributes base_ctxt pexp_attributes in\n {\n pexp_desc;\n pexp_loc (* location doesn't need to be traversed *);\n pexp_attributes;\n pexp_loc_stack;\n }\n in\n let args =\n List.map args ~f:(fun (lab, exp) ->\n (lab, self#expression base_ctxt exp))\n in\n let pexp_attributes = self#attributes base_ctxt pexp_attributes in\n {\n pexp_loc;\n pexp_attributes;\n pexp_desc = Pexp_apply (func, args);\n pexp_loc_stack;\n }\n\n method! class_type base_ctxt x =\n map_node EC.class_type class_type super#class_type x.pcty_loc base_ctxt x\n\n method! class_type_field base_ctxt x =\n map_node EC.class_type_field class_type_field super#class_type_field\n x.pctf_loc base_ctxt x\n\n method! class_expr base_ctxt x =\n map_node EC.class_expr class_expr super#class_expr x.pcl_loc base_ctxt x\n\n method! class_field base_ctxt x =\n map_node EC.class_field class_field super#class_field x.pcf_loc base_ctxt\n x\n\n method! module_type base_ctxt x =\n map_node EC.module_type module_type super#module_type x.pmty_loc base_ctxt\n x\n\n method! module_expr base_ctxt x =\n map_node EC.module_expr module_expr super#module_expr x.pmod_loc base_ctxt\n x\n\n method! structure_item base_ctxt x =\n map_node EC.structure_item structure_item super#structure_item x.pstr_loc\n base_ctxt x\n\n method! signature_item base_ctxt x =\n map_node EC.signature_item signature_item super#signature_item x.psig_loc\n base_ctxt x\n\n method! class_structure base_ctxt { pcstr_self; pcstr_fields } =\n let pcstr_self = self#pattern base_ctxt pcstr_self in\n let pcstr_fields =\n map_nodes EC.class_field class_field super#class_field\n (fun x -> x.pcf_loc)\n base_ctxt pcstr_fields\n in\n { pcstr_self; pcstr_fields }\n\n method! type_declaration base_ctxt x =\n map_node EC.Ppx_import ppx_import super#type_declaration x.ptype_loc\n base_ctxt x\n\n method! class_signature base_ctxt { pcsig_self; pcsig_fields } =\n let pcsig_self = self#core_type base_ctxt pcsig_self in\n let pcsig_fields =\n map_nodes EC.class_type_field class_type_field super#class_type_field\n (fun x -> x.pctf_loc)\n base_ctxt pcsig_fields\n in\n { pcsig_self; pcsig_fields }\n\n (* TODO: try to factorize #structure and #signature without meta-programming *)\n (*$*)\n method! structure base_ctxt st =\n let rec with_extra_items item ~extra_items ~expect_items ~rest\n ~in_generated_code =\n let extra_items =\n loop (rev_concat extra_items) ~in_generated_code:true\n in\n if not in_generated_code then\n Generated_code_hook.insert_after hook Structure_item item.pstr_loc\n (Many extra_items);\n let original_rest = rest in\n let rest = loop rest ~in_generated_code in\n (match expect_items with\n | [] -> ()\n | _ ->\n let expected = rev_concat expect_items in\n let pos = item.pstr_loc.loc_end in\n Code_matcher.match_structure original_rest ~pos ~expected\n ~mismatch_handler:(fun loc repl ->\n expect_mismatch_handler.f Structure_item loc repl));\n item :: (extra_items @ rest)\n and loop st ~in_generated_code =\n match st with\n | [] -> []\n | item :: rest -> (\n let loc = item.pstr_loc in\n match item.pstr_desc with\n | Pstr_extension (ext, attrs) -> (\n let extension_point_loc = item.pstr_loc in\n let ctxt =\n Expansion_context.Extension.make ~extension_point_loc\n ~base:base_ctxt ()\n in\n match E.For_context.convert_inline structure_item ~ctxt ext with\n | None ->\n let item = super#structure_item base_ctxt item in\n let rest = self#structure base_ctxt rest in\n item :: rest\n | Some items ->\n assert_no_attributes attrs;\n let items = loop items ~in_generated_code:true in\n if not in_generated_code then\n Generated_code_hook.replace hook Structure_item\n item.pstr_loc (Many items);\n items @ loop rest ~in_generated_code)\n | _ -> (\n let expanded_item = super#structure_item base_ctxt item in\n match (item.pstr_desc, expanded_item.pstr_desc) with\n | Pstr_type (rf, tds), Pstr_type (exp_rf, exp_tds) ->\n (* No context-free rule can rewrite rec flags atm, this\n assert acts as a failsafe in case it ever changes *)\n assert (Poly.(rf = exp_rf));\n let extra_items =\n handle_attr_group_inline attr_str_type_decls rf ~items:tds\n ~expanded_items:exp_tds ~loc ~base_ctxt\n in\n let expect_items =\n handle_attr_group_inline attr_str_type_decls_expect rf\n ~items:tds ~expanded_items:exp_tds ~loc ~base_ctxt\n in\n with_extra_items expanded_item ~extra_items ~expect_items\n ~rest ~in_generated_code\n | Pstr_modtype mtd, Pstr_modtype exp_mtd ->\n let extra_items =\n handle_attr_inline attr_str_module_type_decls ~item:mtd\n ~expanded_item:exp_mtd ~loc ~base_ctxt\n in\n let expect_items =\n handle_attr_inline attr_str_module_type_decls_expect\n ~item:mtd ~expanded_item:exp_mtd ~loc ~base_ctxt\n in\n with_extra_items expanded_item ~extra_items ~expect_items\n ~rest ~in_generated_code\n | Pstr_typext te, Pstr_typext exp_te ->\n let extra_items =\n handle_attr_inline attr_str_type_exts ~item:te\n ~expanded_item:exp_te ~loc ~base_ctxt\n in\n let expect_items =\n handle_attr_inline attr_str_type_exts_expect ~item:te\n ~expanded_item:exp_te ~loc ~base_ctxt\n in\n with_extra_items expanded_item ~extra_items ~expect_items\n ~rest ~in_generated_code\n | Pstr_exception ec, Pstr_exception exp_ec ->\n let extra_items =\n handle_attr_inline attr_str_exceptions ~item:ec\n ~expanded_item:exp_ec ~loc ~base_ctxt\n in\n let expect_items =\n handle_attr_inline attr_str_exceptions_expect ~item:ec\n ~expanded_item:exp_ec ~loc ~base_ctxt\n in\n with_extra_items expanded_item ~extra_items ~expect_items\n ~rest ~in_generated_code\n | _, _ ->\n let rest = self#structure base_ctxt rest in\n expanded_item :: rest))\n in\n loop st ~in_generated_code:false\n\n (*$ str_to_sig _last_text_block *)\n method! signature base_ctxt sg =\n let rec with_extra_items item ~extra_items ~expect_items ~rest\n ~in_generated_code =\n let extra_items =\n loop (rev_concat extra_items) ~in_generated_code:true\n in\n if not in_generated_code then\n Generated_code_hook.insert_after hook Signature_item item.psig_loc\n (Many extra_items);\n let original_rest = rest in\n let rest = loop rest ~in_generated_code in\n (match expect_items with\n | [] -> ()\n | _ ->\n let expected = rev_concat expect_items in\n let pos = item.psig_loc.loc_end in\n Code_matcher.match_signature original_rest ~pos ~expected\n ~mismatch_handler:(fun loc repl ->\n expect_mismatch_handler.f Signature_item loc repl));\n item :: (extra_items @ rest)\n and loop sg ~in_generated_code =\n match sg with\n | [] -> []\n | item :: rest -> (\n let loc = item.psig_loc in\n match item.psig_desc with\n | Psig_extension (ext, attrs) -> (\n let extension_point_loc = item.psig_loc in\n let ctxt =\n Expansion_context.Extension.make ~extension_point_loc\n ~base:base_ctxt ()\n in\n match E.For_context.convert_inline signature_item ~ctxt ext with\n | None ->\n let item = super#signature_item base_ctxt item in\n let rest = self#signature base_ctxt rest in\n item :: rest\n | Some items ->\n assert_no_attributes attrs;\n let items = loop items ~in_generated_code:true in\n if not in_generated_code then\n Generated_code_hook.replace hook Signature_item\n item.psig_loc (Many items);\n items @ loop rest ~in_generated_code)\n | _ -> (\n let expanded_item = super#signature_item base_ctxt item in\n match (item.psig_desc, expanded_item.psig_desc) with\n | Psig_type (rf, tds), Psig_type (exp_rf, exp_tds) ->\n (* No context-free rule can rewrite rec flags atm, this\n assert acts as a failsafe in case it ever changes *)\n assert (Poly.(rf = exp_rf));\n let extra_items =\n handle_attr_group_inline attr_sig_type_decls rf ~items:tds\n ~expanded_items:exp_tds ~loc ~base_ctxt\n in\n let expect_items =\n handle_attr_group_inline attr_sig_type_decls_expect rf\n ~items:tds ~expanded_items:exp_tds ~loc ~base_ctxt\n in\n with_extra_items expanded_item ~extra_items ~expect_items\n ~rest ~in_generated_code\n | Psig_modtype mtd, Psig_modtype exp_mtd ->\n let extra_items =\n handle_attr_inline attr_sig_module_type_decls ~item:mtd\n ~expanded_item:exp_mtd ~loc ~base_ctxt\n in\n let expect_items =\n handle_attr_inline attr_sig_module_type_decls_expect\n ~item:mtd ~expanded_item:exp_mtd ~loc ~base_ctxt\n in\n with_extra_items expanded_item ~extra_items ~expect_items\n ~rest ~in_generated_code\n | Psig_typext te, Psig_typext exp_te ->\n let extra_items =\n handle_attr_inline attr_sig_type_exts ~item:te\n ~expanded_item:exp_te ~loc ~base_ctxt\n in\n let expect_items =\n handle_attr_inline attr_sig_type_exts_expect ~item:te\n ~expanded_item:exp_te ~loc ~base_ctxt\n in\n with_extra_items expanded_item ~extra_items ~expect_items\n ~rest ~in_generated_code\n | Psig_exception ec, Psig_exception exp_ec ->\n let extra_items =\n handle_attr_inline attr_sig_exceptions ~item:ec\n ~expanded_item:exp_ec ~loc ~base_ctxt\n in\n let expect_items =\n handle_attr_inline attr_sig_exceptions_expect ~item:ec\n ~expanded_item:exp_ec ~loc ~base_ctxt\n in\n with_extra_items expanded_item ~extra_items ~expect_items\n ~rest ~in_generated_code\n | _, _ ->\n let rest = self#signature base_ctxt rest in\n expanded_item :: rest))\n in\n loop sg ~in_generated_code:false\n\n (*$*)\n end\n","(*$ open Ppxlib_cinaps_helpers $*)\nopen Import\nopen Utils\nmodule Arg = Caml.Arg\n\nlet exe_name = Caml.Filename.basename Caml.Sys.executable_name\nlet args = ref []\nlet add_arg key spec ~doc = args := (key, spec, doc) :: !args\nlet loc_fname = ref None\nlet perform_checks = ref Options.perform_checks\nlet perform_checks_on_extensions = ref Options.perform_checks_on_extensions\nlet perform_locations_check = ref Options.perform_locations_check\nlet debug_attribute_drop = ref false\nlet apply_list = ref None\nlet preprocessor = ref None\nlet no_merge = ref false\nlet request_print_passes = ref false\nlet request_print_transformations = ref false\nlet use_color = ref true\nlet diff_command = ref Options.diff_command\nlet pretty = ref false\nlet styler = ref None\nlet output_metadata_filename = ref None\nlet corrected_suffix = ref \".ppx-corrected\"\n\nmodule Lint_error = struct\n type t = Location.t * string\n\n let of_string loc s = (loc, s)\nend\n\nmodule Cookies = struct\n type t = T\n\n let given_through_cli = ref []\n\n let get T name pattern =\n Option.map (Astlib.Ast_metadata.get_cookie name) ~f:(fun e ->\n let e = Selected_ast.of_ocaml Expression e in\n Ast_pattern.parse pattern e.pexp_loc e Fn.id)\n\n let set T name expr =\n Astlib.Ast_metadata.set_cookie name (Selected_ast.to_ocaml Expression expr)\n\n let handlers = ref []\n let add_handler f = handlers := !handlers @ [ f ]\n\n let add_simple_handler name pattern ~f =\n add_handler (fun T -> f (get T name pattern))\n\n let acknowledge_cookies T = List.iter !handlers ~f:(fun f -> f T)\n let post_handlers = ref []\n let add_post_handler f = post_handlers := !post_handlers @ [ f ]\n let call_post_handlers T = List.iter !post_handlers ~f:(fun f -> f T)\nend\n\nmodule Instrument = struct\n type pos = Before | After\n\n type t = {\n transformation :\n Expansion_context.Base.t -> Parsetree.structure -> Parsetree.structure;\n position : pos;\n }\n\n module V2 = struct\n let make transformation ~position = { transformation; position }\n end\n\n let make transformation ~position =\n let transformation _ st = transformation st in\n V2.make transformation ~position\nend\n\nmodule Transform = struct\n type t = {\n name : string;\n aliases : string list;\n impl :\n (Expansion_context.Base.t -> Parsetree.structure -> Parsetree.structure)\n option;\n intf :\n (Expansion_context.Base.t -> Parsetree.signature -> Parsetree.signature)\n option;\n lint_impl :\n (Expansion_context.Base.t -> Parsetree.structure -> Lint_error.t list)\n option;\n lint_intf :\n (Expansion_context.Base.t -> Parsetree.signature -> Lint_error.t list)\n option;\n preprocess_impl :\n (Expansion_context.Base.t -> Parsetree.structure -> Parsetree.structure)\n option;\n preprocess_intf :\n (Expansion_context.Base.t -> Parsetree.signature -> Parsetree.signature)\n option;\n enclose_impl :\n (Expansion_context.Base.t ->\n Location.t option ->\n Parsetree.structure * Parsetree.structure)\n option;\n enclose_intf :\n (Expansion_context.Base.t ->\n Location.t option ->\n Parsetree.signature * Parsetree.signature)\n option;\n instrument : Instrument.t option;\n rules : Context_free.Rule.t list;\n registered_at : Caller_id.t;\n }\n\n let has_name t name =\n String.equal name t.name || List.exists ~f:(String.equal name) t.aliases\n\n let all : t list ref = ref []\n\n let print_caller_id oc (caller_id : Caller_id.t) =\n match caller_id with\n | None -> output_string oc \"\"\n | Some loc -> Printf.fprintf oc \"%s:%d\" loc.filename loc.line_number\n\n let register ?(extensions = []) ?(rules = []) ?enclose_impl ?enclose_intf\n ?impl ?intf ?lint_impl ?lint_intf ?preprocess_impl ?preprocess_intf\n ?instrument ?(aliases = []) name =\n let rules = List.map extensions ~f:Context_free.Rule.extension @ rules in\n let caller_id = Caller_id.get ~skip:[ Caml.__FILE__ ] in\n (match List.filter !all ~f:(fun ct -> has_name ct name) with\n | [] -> ()\n | ct :: _ ->\n Printf.eprintf \"Warning: code transformation %s registered twice.\\n\"\n name;\n Printf.eprintf \" - first time was at %a\\n\" print_caller_id\n ct.registered_at;\n Printf.eprintf \" - second time is at %a\\n\" print_caller_id caller_id);\n let ct =\n {\n name;\n aliases;\n rules;\n enclose_impl;\n enclose_intf;\n impl;\n intf;\n lint_impl;\n preprocess_impl;\n preprocess_intf;\n lint_intf;\n instrument;\n registered_at = caller_id;\n }\n in\n all := ct :: !all\n\n let rec last prev l = match l with [] -> prev | x :: l -> last x l\n\n let loc_of_list ~get_loc l =\n match l with\n | [] -> None\n | x :: l ->\n let first : Location.t = get_loc x in\n let last = get_loc (last x l) in\n Some { first with loc_end = last.loc_end }\n\n let merge_into_generic_mappers t ~hook ~expect_mismatch_handler ~tool_name\n ~input_name =\n let { rules; enclose_impl; enclose_intf; impl; intf; _ } = t in\n let map =\n new Context_free.map_top_down\n rules ~generated_code_hook:hook ~expect_mismatch_handler\n in\n let gen_header_and_footer context whole_loc f =\n let header, footer = f whole_loc in\n (match whole_loc with\n | Some (loc : Location.t) -> (\n let loc_header = { loc with loc_end = loc.loc_start } in\n let loc_footer = { loc with loc_start = loc.loc_end } in\n (match header with\n | [] -> ()\n | _ -> hook.f context loc_header (Many header));\n match footer with\n | [] -> ()\n | _ -> hook.f context loc_footer (Many footer))\n | None -> (\n match header @ footer with\n | [] -> ()\n | l ->\n let pos =\n {\n Lexing.pos_fname = \"\";\n pos_lnum = 1;\n pos_bol = 0;\n pos_cnum = 0;\n }\n in\n let loc =\n { Location.loc_start = pos; loc_end = pos; loc_ghost = false }\n in\n hook.f context loc (Many l)));\n (header, footer)\n in\n let input_name =\n match input_name with Some input_name -> input_name | None -> \"_none_\"\n in\n let map_impl ctxt st_with_attrs =\n let st =\n let attrs, st =\n List.split_while st_with_attrs ~f:(function\n | { pstr_desc = Pstr_attribute _; _ } -> true\n | _ -> false)\n in\n let file_path = File_path.get_default_path_str st in\n let base_ctxt =\n Expansion_context.Base.top_level ~tool_name ~file_path ~input_name\n in\n let header, footer =\n match enclose_impl with\n | None -> ([], [])\n | Some f ->\n let whole_loc =\n loc_of_list st ~get_loc:(fun st -> st.Parsetree.pstr_loc)\n in\n gen_header_and_footer Structure_item whole_loc (f base_ctxt)\n in\n let attrs = map#structure base_ctxt attrs in\n let st = map#structure base_ctxt st in\n List.concat [ attrs; header; st; footer ]\n in\n match impl with None -> st | Some f -> f ctxt st\n in\n let map_intf ctxt sg_with_attrs =\n let sg =\n let attrs, sg =\n List.split_while sg_with_attrs ~f:(function\n | { psig_desc = Psig_attribute _; _ } -> true\n | _ -> false)\n in\n let file_path = File_path.get_default_path_sig sg in\n let base_ctxt =\n Expansion_context.Base.top_level ~tool_name ~file_path ~input_name\n in\n let header, footer =\n match enclose_intf with\n | None -> ([], [])\n | Some f ->\n let whole_loc =\n loc_of_list sg ~get_loc:(fun sg -> sg.Parsetree.psig_loc)\n in\n gen_header_and_footer Signature_item whole_loc (f base_ctxt)\n in\n let attrs = map#signature base_ctxt attrs in\n let sg = map#signature base_ctxt sg in\n List.concat [ attrs; header; sg; footer ]\n in\n match intf with None -> sg | Some f -> f ctxt sg\n in\n { t with impl = Some map_impl; intf = Some map_intf }\n\n let builtin_of_context_free_rewriters ~hook ~rules ~enclose_impl ~enclose_intf\n ~input_name =\n merge_into_generic_mappers ~hook ~input_name\n {\n name = \"\";\n aliases = [];\n impl = None;\n intf = None;\n lint_impl = None;\n lint_intf = None;\n preprocess_impl = None;\n preprocess_intf = None;\n enclose_impl;\n enclose_intf;\n instrument = None;\n rules;\n registered_at = Caller_id.get ~skip:[];\n }\n\n let partition_transformations ts =\n let before_instrs, after_instrs, rest =\n List.fold_left ts ~init:([], [], []) ~f:(fun (bef_i, aft_i, rest) t ->\n let reduced_t =\n {\n t with\n lint_impl = None;\n lint_intf = None;\n preprocess_impl = None;\n preprocess_intf = None;\n }\n in\n let f instr =\n (instr.Instrument.position, instr.Instrument.transformation)\n in\n match Option.map t.instrument ~f with\n | Some (Before, transf) ->\n ( { reduced_t with impl = Some transf; rules = [] } :: bef_i,\n aft_i,\n reduced_t :: rest )\n | Some (After, transf) ->\n ( bef_i,\n { reduced_t with impl = Some transf; rules = [] } :: aft_i,\n reduced_t :: rest )\n | None -> (bef_i, aft_i, reduced_t :: rest))\n in\n ( `Linters\n (List.filter_map ts ~f:(fun t ->\n if Option.is_some t.lint_impl || Option.is_some t.lint_intf then\n Some\n {\n name = Printf.sprintf \"\" t.name;\n aliases = [];\n impl = None;\n intf = None;\n lint_impl = t.lint_impl;\n lint_intf = t.lint_intf;\n enclose_impl = None;\n enclose_intf = None;\n preprocess_impl = None;\n preprocess_intf = None;\n instrument = None;\n rules = [];\n registered_at = t.registered_at;\n }\n else None)),\n `Preprocess\n (List.filter_map ts ~f:(fun t ->\n if\n Option.is_some t.preprocess_impl\n || Option.is_some t.preprocess_intf\n then\n Some\n {\n name = Printf.sprintf \"\" t.name;\n aliases = [];\n impl = t.preprocess_impl;\n intf = t.preprocess_intf;\n lint_impl = None;\n lint_intf = None;\n enclose_impl = None;\n enclose_intf = None;\n preprocess_impl = None;\n preprocess_intf = None;\n instrument = None;\n rules = [];\n registered_at = t.registered_at;\n }\n else None)),\n `Before_instrs before_instrs,\n `After_instrs after_instrs,\n `Rest rest )\nend\n\nmodule V2 = struct\n let register_transformation = Transform.register\n\n let register_transformation_using_ocaml_current_ast ?impl ?intf ?aliases name\n =\n let impl =\n Option.map impl ~f:(Ppxlib_ast.Selected_ast.of_ocaml_mapper Structure)\n in\n let intf =\n Option.map intf ~f:(Ppxlib_ast.Selected_ast.of_ocaml_mapper Signature)\n in\n register_transformation ?impl ?intf ?aliases name\nend\n\nlet add_ctxt_arg (f : 'a -> 'b) : Expansion_context.Base.t -> 'a -> 'b =\n fun _ x -> f x\n\nlet register_transformation ?extensions ?rules ?enclose_impl ?enclose_intf ?impl\n ?intf ?lint_impl ?lint_intf ?preprocess_impl ?preprocess_intf =\n let impl = Option.map impl ~f:add_ctxt_arg in\n let intf = Option.map intf ~f:add_ctxt_arg in\n let preprocess_impl = Option.map preprocess_impl ~f:add_ctxt_arg in\n let preprocess_intf = Option.map preprocess_intf ~f:add_ctxt_arg in\n let lint_impl = Option.map lint_impl ~f:add_ctxt_arg in\n let lint_intf = Option.map lint_intf ~f:add_ctxt_arg in\n let enclose_impl = Option.map enclose_impl ~f:add_ctxt_arg in\n let enclose_intf = Option.map enclose_intf ~f:add_ctxt_arg in\n V2.register_transformation ?extensions ?rules ?enclose_impl ?enclose_intf\n ?impl ?intf ?lint_impl ?lint_intf ?preprocess_impl ?preprocess_intf\n\nlet register_code_transformation ~name ?(aliases = []) ~impl ~intf =\n register_transformation name ~impl ~intf ~aliases\n [@@warning \"-16\"]\n(* This function triggers a warning 16 as of ocaml 4.12 *)\n\nlet register_transformation_using_ocaml_current_ast ?impl ?intf =\n let impl = Option.map impl ~f:add_ctxt_arg in\n let intf = Option.map intf ~f:add_ctxt_arg in\n V2.register_transformation_using_ocaml_current_ast ?impl ?intf\n\nlet debug_dropped_attribute name ~old_dropped ~new_dropped =\n let print_diff what a b =\n let diff =\n List.filter a ~f:(fun (name : _ Loc.t) ->\n not\n (List.exists b ~f:(fun (name' : _ Location.loc) ->\n name.txt == name'.txt)))\n in\n if not (List.is_empty diff) then (\n Printf.eprintf \"The following attributes %s after applying %s:\\n\" what\n name;\n List.iter diff ~f:(fun { Location.txt; loc } ->\n Caml.Format.eprintf \"- %a: %s\\n\" Location.print loc txt);\n Caml.Format.eprintf \"@.\")\n in\n print_diff \"disappeared\" new_dropped old_dropped;\n print_diff \"reappeared\" old_dropped new_dropped\n\nlet get_whole_ast_passes ~hook ~expect_mismatch_handler ~tool_name ~input_name =\n let cts =\n match !apply_list with\n | None -> List.rev !Transform.all\n | Some names ->\n List.map names ~f:(fun name ->\n List.find !Transform.all ~f:(fun (ct : Transform.t) ->\n Transform.has_name ct name))\n in\n let ( `Linters linters,\n `Preprocess preprocess,\n `Before_instrs before_instrs,\n `After_instrs after_instrs,\n `Rest cts ) =\n Transform.partition_transformations cts\n in\n (* Allow only one preprocessor to assure deterministic order *)\n (if List.length preprocess > 1 then\n let pp =\n String.concat ~sep:\", \" (List.map preprocess ~f:(fun t -> t.name))\n in\n let err =\n Printf.sprintf \"At most one preprocessor is allowed, while got: %s\" pp\n in\n failwith err);\n let make_generic transforms =\n if !no_merge then\n List.map transforms\n ~f:\n (Transform.merge_into_generic_mappers ~hook ~tool_name\n ~expect_mismatch_handler ~input_name)\n else\n (let get_enclosers ~f =\n List.filter_map transforms ~f:(fun (ct : Transform.t) ->\n match f ct with None -> None | Some x -> Some (ct.name, x))\n (* Sort them to ensure deterministic ordering *)\n |> List.sort ~cmp:(fun (a, _) (b, _) -> String.compare a b)\n |> List.map ~f:snd\n in\n\n let rules =\n List.map transforms ~f:(fun (ct : Transform.t) -> ct.rules)\n |> List.concat\n and impl_enclosers = get_enclosers ~f:(fun ct -> ct.enclose_impl)\n and intf_enclosers = get_enclosers ~f:(fun ct -> ct.enclose_intf) in\n match (rules, impl_enclosers, intf_enclosers) with\n | [], [], [] -> transforms\n | _ ->\n let merge_encloser = function\n | [] -> None\n | enclosers ->\n Some\n (fun ctxt loc ->\n let headers, footers =\n List.map enclosers ~f:(fun f -> f ctxt loc) |> List.split\n in\n let headers = List.concat headers in\n let footers = List.concat (List.rev footers) in\n (headers, footers))\n in\n Transform.builtin_of_context_free_rewriters ~rules ~hook\n ~expect_mismatch_handler\n ~enclose_impl:(merge_encloser impl_enclosers)\n ~enclose_intf:(merge_encloser intf_enclosers)\n ~tool_name ~input_name\n :: transforms)\n |> List.filter ~f:(fun (ct : Transform.t) ->\n match (ct.impl, ct.intf) with None, None -> false | _ -> true)\n in\n linters @ preprocess @ before_instrs @ make_generic cts @ after_instrs\n\nlet apply_transforms (type t) ~tool_name ~file_path ~field ~lint_field\n ~dropped_so_far ~hook ~expect_mismatch_handler ~input_name ~f_exception\n ~embed_errors x =\n let exception\n Wrapper of t list * label loc list * (location * label) list * exn\n in\n let cts =\n get_whole_ast_passes ~tool_name ~hook ~expect_mismatch_handler ~input_name\n in\n let return (x, _dropped, lint_errors) =\n ( x,\n List.map lint_errors ~f:(fun (loc, s) ->\n Common.attribute_of_warning loc s) )\n in\n try\n let acc =\n List.fold_left cts ~init:(x, [], [])\n ~f:(fun (x, dropped, (lint_errors : _ list)) (ct : Transform.t) ->\n let input_name =\n match input_name with\n | Some input_name -> input_name\n | None -> \"_none_\"\n in\n let ctxt =\n Expansion_context.Base.top_level ~tool_name ~file_path ~input_name\n in\n let lint_errors =\n match lint_field ct with\n | None -> lint_errors\n | Some f -> (\n try lint_errors @ f ctxt x\n with exn when embed_errors ->\n raise @@ Wrapper (x, dropped, lint_errors, exn))\n in\n match field ct with\n | None -> (x, dropped, lint_errors)\n | Some f ->\n let x =\n try f ctxt x\n with exn when embed_errors ->\n raise @@ Wrapper (x, dropped, lint_errors, exn)\n in\n let dropped =\n if !debug_attribute_drop then (\n let new_dropped = dropped_so_far x in\n debug_dropped_attribute ct.name ~old_dropped:dropped\n ~new_dropped;\n new_dropped)\n else []\n in\n (x, dropped, lint_errors))\n in\n Ok (return acc)\n with Wrapper (x, dropped, lint_errors, exn) ->\n Error (return (f_exception exn :: x, dropped, lint_errors))\n\n(*$*)\n\nlet error_to_str_extension error =\n let loc = Location.none in\n let ext = Location.Error.to_extension error in\n Ast_builder.Default.pstr_extension ~loc ext []\n\nlet exn_to_str_extension exn =\n match Location.Error.of_exn exn with\n | None -> raise exn\n | Some error -> error_to_str_extension error\n\n(*$ str_to_sig _last_text_block *)\n\nlet error_to_sig_extension error =\n let loc = Location.none in\n let ext = Location.Error.to_extension error in\n Ast_builder.Default.psig_extension ~loc ext []\n\nlet exn_to_sig_extension exn =\n match Location.Error.of_exn exn with\n | None -> raise exn\n | Some error -> error_to_sig_extension error\n\n(*$*)\n\nlet error_to_extension error ~(kind : Kind.t) =\n match kind with\n | Intf -> Intf_or_impl.Intf [ error_to_sig_extension error ]\n | Impl -> Intf_or_impl.Impl [ error_to_str_extension error ]\n\nlet exn_to_extension exn ~(kind : Kind.t) =\n match Location.Error.of_exn exn with\n | None -> raise exn\n | Some error -> error_to_extension error ~kind\n\n(* +-----------------------------------------------------------------+\n | Actual rewriting of structure/signatures |\n +-----------------------------------------------------------------+ *)\n\nlet print_passes () =\n let tool_name = \"ppxlib_driver\" in\n let hook = Context_free.Generated_code_hook.nop in\n let expect_mismatch_handler = Context_free.Expect_mismatch_handler.nop in\n let cts =\n get_whole_ast_passes ~hook ~expect_mismatch_handler ~tool_name\n ~input_name:None\n in\n if !perform_checks then\n Printf.printf \"\\n\";\n List.iter cts ~f:(fun ct -> Printf.printf \"%s\\n\" ct.Transform.name);\n if !perform_checks then (\n Printf.printf \"\\n\";\n if !perform_checks_on_extensions then\n Printf.printf \"\\n\")\n\n(*$*)\n\nlet map_structure_gen st ~tool_name ~hook ~expect_mismatch_handler ~input_name\n ~embed_errors =\n Cookies.acknowledge_cookies T;\n if !perform_checks then (\n Attribute.reset_checks ();\n Attribute.collect#structure st);\n let lint lint_errors st =\n let st =\n match lint_errors with\n | [] -> st\n | _ ->\n List.map lint_errors\n ~f:(fun ({ attr_name = { loc; _ }; _ } as attr) ->\n Ast_builder.Default.pstr_attribute ~loc attr)\n @ st\n in\n st\n in\n let cookies_and_check st =\n Cookies.call_post_handlers T;\n if !perform_checks then (\n (* TODO: these two passes could be merged, we now have more passes for\n checks than for actual rewriting. *)\n Attribute.check_unused#structure st;\n if !perform_checks_on_extensions then Extension.check_unused#structure st;\n Attribute.check_all_seen ();\n if !perform_locations_check then\n let open Location_check in\n ignore\n ((enforce_invariants !loc_fname)#structure st\n Non_intersecting_ranges.empty\n : Non_intersecting_ranges.t));\n st\n in\n let file_path = File_path.get_default_path_str st in\n match\n apply_transforms st ~tool_name ~file_path\n ~field:(fun (ct : Transform.t) -> ct.impl)\n ~lint_field:(fun (ct : Transform.t) -> ct.lint_impl)\n ~dropped_so_far:Attribute.dropped_so_far_structure ~hook\n ~expect_mismatch_handler ~input_name\n ~f_exception:(fun exn -> exn_to_str_extension exn)\n ~embed_errors\n with\n | Error (st, lint_errors) -> Error (lint lint_errors st)\n | Ok (st, lint_errors) -> Ok (st |> lint lint_errors |> cookies_and_check)\n\nlet map_structure st =\n match\n map_structure_gen st\n ~tool_name:(Astlib.Ast_metadata.tool_name ())\n ~hook:Context_free.Generated_code_hook.nop\n ~expect_mismatch_handler:Context_free.Expect_mismatch_handler.nop\n ~input_name:None ~embed_errors:false\n with\n | Ok ast | Error ast -> ast\n\n(*$ str_to_sig _last_text_block *)\n\nlet map_signature_gen sg ~tool_name ~hook ~expect_mismatch_handler ~input_name\n ~embed_errors =\n Cookies.acknowledge_cookies T;\n if !perform_checks then (\n Attribute.reset_checks ();\n Attribute.collect#signature sg);\n let lint lint_errors sg =\n let sg =\n match lint_errors with\n | [] -> sg\n | _ ->\n List.map lint_errors\n ~f:(fun ({ attr_name = { loc; _ }; _ } as attr) ->\n Ast_builder.Default.psig_attribute ~loc attr)\n @ sg\n in\n sg\n in\n let cookies_and_check sg =\n Cookies.call_post_handlers T;\n if !perform_checks then (\n (* TODO: these two passes could be merged, we now have more passes for\n checks than for actual rewriting. *)\n Attribute.check_unused#signature sg;\n if !perform_checks_on_extensions then Extension.check_unused#signature sg;\n Attribute.check_all_seen ();\n if !perform_locations_check then\n let open Location_check in\n ignore\n ((enforce_invariants !loc_fname)#signature sg\n Non_intersecting_ranges.empty\n : Non_intersecting_ranges.t));\n sg\n in\n let file_path = File_path.get_default_path_sig sg in\n match\n apply_transforms sg ~tool_name ~file_path\n ~field:(fun (ct : Transform.t) -> ct.intf)\n ~lint_field:(fun (ct : Transform.t) -> ct.lint_intf)\n ~dropped_so_far:Attribute.dropped_so_far_signature ~hook\n ~expect_mismatch_handler ~input_name\n ~f_exception:(fun exn -> exn_to_sig_extension exn)\n ~embed_errors\n with\n | Error (sg, lint_errors) -> Error (lint lint_errors sg)\n | Ok (sg, lint_errors) -> Ok (sg |> lint lint_errors |> cookies_and_check)\n\nlet map_signature sg =\n match\n map_signature_gen sg\n ~tool_name:(Astlib.Ast_metadata.tool_name ())\n ~hook:Context_free.Generated_code_hook.nop\n ~expect_mismatch_handler:Context_free.Expect_mismatch_handler.nop\n ~input_name:None ~embed_errors:false\n with\n | Ok ast | Error ast -> ast\n\n(*$*)\n\n(* +-----------------------------------------------------------------+\n | Entry points |\n +-----------------------------------------------------------------+ *)\n\nlet string_contains_binary_ast s =\n let test magic_number =\n String.is_prefix s ~prefix:(String.sub magic_number ~pos:0 ~len:9)\n in\n test Ast_magic.ast_intf_magic_number || test Ast_magic.ast_impl_magic_number\n\nlet versioned_errorf input_version input_file_name =\n Printf.ksprintf (fun msg ->\n let err =\n Location.Error.make ~loc:(Location.in_file input_file_name) msg ~sub:[]\n in\n Error (err, input_version))\n\nlet remove_no_error fn = try Caml.Sys.remove fn with Sys_error _ -> ()\n\nlet protectx x ~f ~finally =\n match f x with\n | v ->\n finally x;\n v\n | exception e ->\n finally x;\n raise e\n\nlet with_preprocessed_file fn ~f =\n match !preprocessor with\n | None -> f fn\n | Some pp ->\n protectx (Caml.Filename.temp_file \"ocamlpp\" \"\") ~finally:remove_no_error\n ~f:(fun tmpfile ->\n match System.run_preprocessor ~pp ~input:fn ~output:tmpfile with\n | Ok () -> f tmpfile\n | Error (failed_command, fall_back_version) ->\n versioned_errorf fall_back_version fn\n \"Error while running external preprocessor\\nCommand line: %s\\n\"\n failed_command)\n\nlet relocate_mapper =\n object\n inherit [string * string] Ast_traverse.map_with_context\n\n method! position (old_fn, new_fn) pos =\n if String.equal pos.pos_fname old_fn then { pos with pos_fname = new_fn }\n else pos\n end\n\n(* Set the input name globally. This is used by some ppx rewriters\n such as bisect_ppx. *)\nlet set_input_name = Astlib.Location.set_input_name\n\nlet load_input ~(kind : Kind.t) ~input_name ~relocate fn =\n set_input_name input_name;\n let input_source = if String.equal fn \"-\" then Ast_io.Stdin else File fn in\n let input_kind = Ast_io.Possibly_source (kind, input_name) in\n match Ast_io.read input_source ~input_kind with\n | Ok { input_name = ast_input_name; input_version; ast } ->\n let ast_kind = Intf_or_impl.kind ast in\n if not (Kind.equal kind ast_kind) then\n versioned_errorf input_version fn\n \"File contains a binary %s AST but an %s was expected\"\n (Kind.describe ast_kind) (Kind.describe kind)\n else if String.equal ast_input_name input_name || not relocate then (\n set_input_name ast_input_name;\n Ok (ast_input_name, input_version, ast))\n else\n Ok\n ( input_name,\n input_version,\n Intf_or_impl.map_with_context ast relocate_mapper\n (ast_input_name, input_name) )\n | Error (Unknown_version (unknown_magic, fall_back_version)) ->\n versioned_errorf fall_back_version fn\n \"File is a binary ast for an unknown version of OCaml with magic \\\n number '%s'\"\n unknown_magic\n | Error (System_error (error, fall_back_version))\n | Error (Source_parse_error (error, fall_back_version)) ->\n Error (error, fall_back_version)\n | Error Not_a_binary_ast -> assert false\n\nlet load_input_run_as_ppx fn =\n (* If there's an error while loading in run_as_ppx mode, the kind of AST (impl/intf) is still unknown.\n That's why, as opposed to load_input, this function raises errors instead of returning a result:\n handling an error by returning an AST with the error packed as extension node wouldn't be possible. *)\n match Ast_io.read (File fn) ~input_kind:Ast_io.Necessarily_binary with\n | Ok { input_name = ast_input_name; input_version; ast } ->\n let ast =\n match !loc_fname with\n | None ->\n set_input_name ast_input_name;\n ast\n | Some input_name ->\n set_input_name input_name;\n if String.equal ast_input_name input_name then ast\n else\n Intf_or_impl.map_with_context ast relocate_mapper\n (ast_input_name, input_name)\n in\n (* With `--as-ppx`, ocaml calls the standalone separately for every structure/signature item\n with the filename as metadata that it gets from the previous call. relocate_mapper only\n relocates positions whose position filename coincides with that metadata filename.\n So always return the metadata filename itself, even if `-loc-filename` is provided. *)\n (ast_input_name, input_version, ast)\n | Error (Unknown_version (unknown_magic, _)) ->\n Location.raise_errorf ~loc:(Location.in_file fn)\n \"The input is a binary ast for an unknown version of OCaml with magic \\\n number '%s'\"\n unknown_magic\n | Error Not_a_binary_ast ->\n Location.raise_errorf ~loc:(Location.in_file fn)\n \"Expected a binary AST as input\"\n | Error (System_error (error, _)) | Error (Source_parse_error (error, _)) ->\n let open Location.Error in\n Location.set_filename (get_location error) fn |> update_loc error |> raise\n\nlet load_source_file fn =\n let s = In_channel.read_all fn in\n if string_contains_binary_ast s then\n Location.raise_errorf ~loc:(Location.in_file fn)\n \"ppxlib_driver: cannot use -reconcile with binary AST files\";\n s\n\ntype output_mode =\n | Pretty_print\n | Dump_ast\n | Dparsetree\n | Reconcile of Reconcile.mode\n | Null\n\n(*$*)\nlet extract_cookies_str st =\n let st =\n match st with\n | ({\n pstr_desc =\n Pstr_attribute { attr_name = { txt = \"ocaml.ppx.context\"; _ }; _ };\n _;\n } as prefix)\n :: st ->\n let prefix = Ppxlib_ast.Selected_ast.to_ocaml Structure [ prefix ] in\n assert (\n List.is_empty\n (Astlib.Ast_metadata.drop_ppx_context_str ~restore:true prefix));\n st\n | _ -> st\n in\n (* The cli cookies have to be set after restoring the ppx context,\n since restoring the ppx context resets the cookies *)\n List.iter !Cookies.given_through_cli ~f:(fun (name, expr) ->\n Cookies.set T name expr);\n st\n\nlet add_cookies_str st =\n let prefix =\n Astlib.Ast_metadata.add_ppx_context_str ~tool_name:\"ppxlib_driver\" []\n |> Ppxlib_ast.Selected_ast.of_ocaml Structure\n in\n prefix @ st\n\n(*$ str_to_sig _last_text_block *)\nlet extract_cookies_sig sg =\n let sg =\n match sg with\n | ({\n psig_desc =\n Psig_attribute { attr_name = { txt = \"ocaml.ppx.context\"; _ }; _ };\n _;\n } as prefix)\n :: sg ->\n let prefix = Ppxlib_ast.Selected_ast.to_ocaml Signature [ prefix ] in\n assert (\n List.is_empty\n (Astlib.Ast_metadata.drop_ppx_context_sig ~restore:true prefix));\n sg\n | _ -> sg\n in\n (* The cli cookies have to be set after restoring the ppx context,\n since restoring the ppx context resets the cookies *)\n List.iter !Cookies.given_through_cli ~f:(fun (name, expr) ->\n Cookies.set T name expr);\n sg\n\nlet add_cookies_sig sg =\n let prefix =\n Astlib.Ast_metadata.add_ppx_context_sig ~tool_name:\"ppxlib_driver\" []\n |> Ppxlib_ast.Selected_ast.of_ocaml Signature\n in\n prefix @ sg\n\n(*$*)\n\nlet extract_cookies (ast : Intf_or_impl.t) : Intf_or_impl.t =\n match ast with\n | Intf x -> Intf (extract_cookies_sig x)\n | Impl x -> Impl (extract_cookies_str x)\n\nlet add_cookies (ast : Intf_or_impl.t) : Intf_or_impl.t =\n match ast with\n | Intf x -> Intf (add_cookies_sig x)\n | Impl x -> Impl (add_cookies_str x)\n\nlet corrections = ref []\nlet add_to_list r x = r := x :: !r\n\nlet register_correction ~loc ~repl =\n add_to_list corrections\n (Reconcile.Replacement.make_text () ~start:loc.loc_start ~stop:loc.loc_end\n ~repl)\n\nlet process_file_hooks = ref []\nlet register_process_file_hook f = add_to_list process_file_hooks f\n\nmodule File_property = struct\n type 'a t = {\n name : string;\n mutable data : 'a option;\n sexp_of_t : 'a -> Sexp.t;\n }\n\n type packed = T : _ t -> packed\n\n let all = ref []\n let register t = add_to_list all (T t)\n let reset_all () = List.iter !all ~f:(fun (T t) -> t.data <- None)\n\n let dump_and_reset_all () =\n List.filter_map (List.rev !all) ~f:(fun (T t) ->\n match t.data with\n | None -> None\n | Some v ->\n t.data <- None;\n Some (t.name, t.sexp_of_t v))\nend\n\nmodule Create_file_property (Name : sig\n val name : string\nend)\n(T : Sexpable.S) =\nstruct\n let t : _ File_property.t =\n { name = Name.name; data = None; sexp_of_t = T.sexp_of_t }\n\n let () = File_property.register t\n let set x = t.data <- Some x\nend\n\nlet process_ast (ast : Intf_or_impl.t) ~input_name ~tool_name ~hook\n ~expect_mismatch_handler ~embed_errors =\n match ast with\n | Intf x ->\n let ast =\n match\n map_signature_gen x ~tool_name ~hook ~expect_mismatch_handler\n ~input_name:(Some input_name) ~embed_errors\n with\n | Error ast | Ok ast -> ast\n in\n Intf_or_impl.Intf ast\n | Impl x ->\n let ast =\n match\n map_structure_gen x ~tool_name ~hook ~expect_mismatch_handler\n ~input_name:(Some input_name) ~embed_errors\n with\n | Error ast | Ok ast -> ast\n in\n Intf_or_impl.Impl ast\n\nlet process_file (kind : Kind.t) fn ~input_name ~relocate ~output_mode\n ~embed_errors ~output =\n File_property.reset_all ();\n List.iter (List.rev !process_file_hooks) ~f:(fun f -> f ());\n corrections := [];\n let replacements = ref [] in\n let tool_name = \"ppx_driver\" in\n let hook : Context_free.Generated_code_hook.t =\n match output_mode with\n | Reconcile (Using_line_directives | Delimiting_generated_blocks) ->\n {\n f =\n (fun context (loc : Location.t) generated ->\n add_to_list replacements\n (Reconcile.Replacement.make () ~context:(Extension context)\n ~start:loc.loc_start ~stop:loc.loc_end ~repl:generated));\n }\n | _ -> Context_free.Generated_code_hook.nop\n in\n let expect_mismatch_handler : Context_free.Expect_mismatch_handler.t =\n {\n f =\n (fun context (loc : Location.t) generated ->\n add_to_list corrections\n (Reconcile.Replacement.make () ~context:(Floating_attribute context)\n ~start:loc.loc_start ~stop:loc.loc_end ~repl:(Many generated)));\n }\n in\n\n let input_name, input_version, ast =\n let preprocessed_and_loaded =\n with_preprocessed_file fn ~f:(load_input ~kind ~input_name ~relocate)\n in\n match preprocessed_and_loaded with\n | Ok (input_fname, input_version, ast) -> (\n try\n let ast =\n extract_cookies ast\n |> process_ast ~input_name ~tool_name ~hook ~expect_mismatch_handler\n ~embed_errors\n in\n (input_fname, input_version, ast)\n with exn when embed_errors ->\n (input_fname, input_version, exn_to_extension exn ~kind))\n | Error (error, input_version) when embed_errors ->\n (input_name, input_version, error_to_extension error ~kind)\n | Error (error, _) ->\n let open Location.Error in\n Location.set_filename (get_location error) fn\n |> update_loc error |> raise\n in\n Option.iter !output_metadata_filename ~f:(fun fn ->\n let metadata = File_property.dump_and_reset_all () in\n Out_channel.write_all fn\n ~data:\n (List.map metadata ~f:(fun (s, sexp) ->\n Sexp.to_string_hum (Sexp.List [ Atom s; sexp ]) ^ \"\\n\")\n |> String.concat ~sep:\"\"));\n\n let input_contents = lazy (load_source_file fn) in\n let corrected = fn ^ !corrected_suffix in\n let mismatches_found =\n match !corrections with\n | [] ->\n if Caml.Sys.file_exists corrected then Caml.Sys.remove corrected;\n false\n | corrections ->\n Reconcile.reconcile corrections\n ~contents:(Lazy.force input_contents)\n ~output:(Some corrected) ~input_filename:fn ~input_name\n ~target:Corrected ?styler:!styler ~kind;\n true\n in\n\n (match output_mode with\n | Null -> ()\n | Pretty_print ->\n with_output output ~binary:false ~f:(fun oc ->\n let ppf = Caml.Format.formatter_of_out_channel oc in\n (match ast with\n | Intf ast -> Pprintast.signature ppf ast\n | Impl ast -> Pprintast.structure ppf ast);\n let null_ast =\n match ast with Intf [] | Impl [] -> true | _ -> false\n in\n if not null_ast then Caml.Format.pp_print_newline ppf ())\n | Dump_ast ->\n with_output output ~binary:true ~f:(fun oc ->\n Ast_io.write oc\n { input_name; input_version; ast }\n ~add_ppx_context:true)\n | Dparsetree ->\n with_output output ~binary:false ~f:(fun oc ->\n let ppf = Caml.Format.formatter_of_out_channel oc in\n let ast = add_cookies ast in\n (match ast with\n | Intf ast -> Sexp.pp_hum ppf (Ast_traverse.sexp_of#signature ast)\n | Impl ast -> Sexp.pp_hum ppf (Ast_traverse.sexp_of#structure ast));\n Caml.Format.pp_print_newline ppf ())\n | Reconcile mode ->\n Reconcile.reconcile !replacements\n ~contents:(Lazy.force input_contents)\n ~output ~input_filename:fn ~input_name ~target:(Output mode)\n ?styler:!styler ~kind);\n\n if\n mismatches_found && match !diff_command with Some \"-\" -> false | _ -> true\n then (\n Ppxlib_print_diff.print () ~file1:fn ~file2:corrected ~use_color:!use_color\n ?diff_command:!diff_command;\n Caml.exit 1)\n\nlet output_mode = ref Pretty_print\nlet output = ref None\nlet kind = ref None\nlet input = ref None\nlet embed_errors = ref false\n\nlet set_input fn =\n match !input with\n | None -> input := Some fn\n | Some _ -> raise (Arg.Bad \"too many input files\")\n\nlet set_kind k =\n match !kind with\n | Some k' when not (Kind.equal k k') ->\n raise (Arg.Bad \"must specify at most one of -impl or -intf\")\n | _ -> kind := Some k\n\nlet set_output_mode mode =\n match (!output_mode, mode) with\n | Pretty_print, _ -> output_mode := mode\n | _, Pretty_print -> assert false\n | Dump_ast, Dump_ast | Dparsetree, Dparsetree -> ()\n | Reconcile a, Reconcile b when Poly.equal a b -> ()\n | x, y ->\n let arg_of_output_mode = function\n | Pretty_print -> assert false\n | Dump_ast -> \"-dump-ast\"\n | Dparsetree -> \"-dparsetree\"\n | Reconcile Using_line_directives -> \"-reconcile\"\n | Reconcile Delimiting_generated_blocks -> \"-reconcile-with-comments\"\n | Null -> \"-null\"\n in\n raise\n (Arg.Bad\n (Printf.sprintf \"%s and %s are incompatible\" (arg_of_output_mode x)\n (arg_of_output_mode y)))\n\nlet print_transformations () =\n List.iter !Transform.all ~f:(fun (ct : Transform.t) ->\n Printf.printf \"%s\\n\" ct.name)\n\nlet parse_apply_list s =\n let names =\n if String.equal s \"\" then [] else String.split_on_char s ~sep:','\n in\n List.iter names ~f:(fun name ->\n if\n not\n (List.exists !Transform.all ~f:(fun (ct : Transform.t) ->\n Transform.has_name ct name))\n then\n raise\n (Caml.Arg.Bad\n (Printf.sprintf \"code transformation '%s' does not exist\" name)));\n names\n\ntype mask = {\n mutable apply : string list option;\n mutable dont_apply : string list option;\n}\n\nlet mask = { apply = None; dont_apply = None }\n\nlet handle_apply s =\n if Option.is_some mask.apply then\n raise (Arg.Bad \"-apply called too many times\");\n (* This is not strictly necessary but it's more intuitive *)\n if Option.is_some mask.dont_apply then\n raise (Arg.Bad \"-apply must be called before -dont-apply\");\n mask.apply <- Some (parse_apply_list s)\n\nlet handle_dont_apply s =\n if Option.is_some mask.dont_apply then\n raise (Arg.Bad \"-apply called too many times\");\n mask.dont_apply <- Some (parse_apply_list s)\n\nlet interpret_mask () =\n if Option.is_some mask.apply || Option.is_some mask.dont_apply then\n let selected_transform_name ct =\n let is_candidate =\n match mask.apply with\n | None -> true\n | Some names -> List.exists names ~f:(Transform.has_name ct)\n in\n let is_selected =\n match mask.dont_apply with\n | None -> is_candidate\n | Some names ->\n is_candidate && not (List.exists names ~f:(Transform.has_name ct))\n in\n if is_selected then Some ct.name else None\n in\n apply_list :=\n Some (List.filter_map !Transform.all ~f:selected_transform_name)\n\nlet set_cookie s =\n match String.lsplit2 s ~on:'=' with\n | None ->\n raise (Arg.Bad \"invalid cookie, must be of the form \\\"=\\\"\")\n | Some (name, value) ->\n let lexbuf = Lexing.from_string value in\n lexbuf.Lexing.lex_curr_p <-\n {\n Lexing.pos_fname = \"\";\n pos_lnum = 1;\n pos_bol = 0;\n pos_cnum = 0;\n };\n let expr = Parse.expression lexbuf in\n Cookies.given_through_cli := (name, expr) :: !Cookies.given_through_cli\n\nlet shared_args =\n [\n ( \"-loc-filename\",\n Arg.String (fun s -> loc_fname := Some s),\n \" File name to use in locations\" );\n ( \"-reserve-namespace\",\n Arg.String Name.Reserved_namespaces.reserve,\n \" Mark the given namespace as reserved\" );\n (\"-no-check\", Arg.Clear perform_checks, \" Disable checks (unsafe)\");\n (\"-check\", Arg.Set perform_checks, \" Enable checks\");\n ( \"-no-check-on-extensions\",\n Arg.Clear perform_checks_on_extensions,\n \" Disable checks on extension point only\" );\n ( \"-check-on-extensions\",\n Arg.Set perform_checks_on_extensions,\n \" Enable checks on extension point only\" );\n ( \"-no-locations-check\",\n Arg.Clear perform_locations_check,\n \" Disable locations check only\" );\n ( \"-locations-check\",\n Arg.Set perform_locations_check,\n \" Enable locations check only\" );\n ( \"-apply\",\n Arg.String handle_apply,\n \" Apply these transformations in order (comma-separated list)\" );\n ( \"-dont-apply\",\n Arg.String handle_dont_apply,\n \" Exclude these transformations\" );\n ( \"-no-merge\",\n Arg.Set no_merge,\n \" Do not merge context free transformations (better for debugging \\\n rewriters). As a result, the context-free transformations are not all \\\n applied before all impl and intf.\" );\n (\"-cookie\", Arg.String set_cookie, \"NAME=EXPR Set the cookie NAME to EXPR\");\n (\"--cookie\", Arg.String set_cookie, \" Same as -cookie\");\n ]\n\nlet () =\n List.iter shared_args ~f:(fun (key, spec, doc) -> add_arg key spec ~doc)\n\nlet as_pp () =\n set_output_mode Dump_ast;\n embed_errors := true\n\nlet standalone_args =\n [\n ( \"-as-ppx\",\n Arg.Unit (fun () -> raise (Arg.Bad \"-as-ppx must be the first argument\")),\n \" Run as a -ppx rewriter (must be the first argument)\" );\n ( \"--as-ppx\",\n Arg.Unit (fun () -> raise (Arg.Bad \"--as-ppx must be the first argument\")),\n \" Same as -as-ppx\" );\n (\"-as-pp\", Arg.Unit as_pp, \" Shorthand for: -dump-ast -embed-errors\");\n (\"--as-pp\", Arg.Unit as_pp, \" Same as -as-pp\");\n ( \"-o\",\n Arg.String (fun s -> output := Some s),\n \" Output file (use '-' for stdout)\" );\n (\"-\", Arg.Unit (fun () -> set_input \"-\"), \" Read input from stdin\");\n ( \"-dump-ast\",\n Arg.Unit (fun () -> set_output_mode Dump_ast),\n \" Dump the marshaled ast to the output file instead of pretty-printing it\"\n );\n ( \"--dump-ast\",\n Arg.Unit (fun () -> set_output_mode Dump_ast),\n \" Same as -dump-ast\" );\n ( \"-dparsetree\",\n Arg.Unit (fun () -> set_output_mode Dparsetree),\n \" Print the parsetree (same as ocamlc -dparsetree)\" );\n ( \"-embed-errors\",\n Arg.Set embed_errors,\n \" Embed errors in the output AST (default: true when -dump-ast, false \\\n otherwise)\" );\n ( \"-null\",\n Arg.Unit (fun () -> set_output_mode Null),\n \" Produce no output, except for errors\" );\n ( \"-impl\",\n Arg.Unit (fun () -> set_kind Impl),\n \" Treat the input as a .ml file\" );\n (\"--impl\", Arg.Unit (fun () -> set_kind Impl), \" Same as -impl\");\n ( \"-intf\",\n Arg.Unit (fun () -> set_kind Intf),\n \" Treat the input as a .mli file\" );\n (\"--intf\", Arg.Unit (fun () -> set_kind Intf), \" Same as -intf\");\n ( \"-debug-attribute-drop\",\n Arg.Set debug_attribute_drop,\n \" Debug attribute dropping\" );\n ( \"-print-transformations\",\n Arg.Set request_print_transformations,\n \" Print linked-in code transformations, in the order they are applied\" );\n ( \"-print-passes\",\n Arg.Set request_print_passes,\n \" Print the actual passes over the whole AST in the order they are \\\n applied\" );\n ( \"-ite-check\",\n Arg.Unit\n (fun () ->\n Printf.eprintf\n \"Warning: the -ite-check flag is deprecated and has no effect.\\n%!\";\n Extra_warnings.care_about_ite_branch := true),\n \" (no effect -- kept for compatibility)\" );\n ( \"-pp\",\n Arg.String (fun s -> preprocessor := Some s),\n \" Pipe sources through preprocessor (incompatible \\\n with -as-ppx)\" );\n ( \"-reconcile\",\n Arg.Unit (fun () -> set_output_mode (Reconcile Using_line_directives)),\n \" (WIP) Pretty print the output using a mix of the input source and the \\\n generated code\" );\n ( \"-reconcile-with-comments\",\n Arg.Unit\n (fun () -> set_output_mode (Reconcile Delimiting_generated_blocks)),\n \" (WIP) same as -reconcile but uses comments to enclose the generated \\\n code\" );\n (\"-no-color\", Arg.Clear use_color, \" Don't use colors when printing errors\");\n ( \"-diff-cmd\",\n Arg.String (fun s -> diff_command := Some s),\n \" Diff command when using code expectations (use - to disable diffing)\" );\n ( \"-pretty\",\n Arg.Set pretty,\n \" Instruct code generators to improve the prettiness of the generated \\\n code\" );\n (\"-styler\", Arg.String (fun s -> styler := Some s), \" Code styler\");\n ( \"-output-metadata\",\n Arg.String (fun s -> output_metadata_filename := Some s),\n \"FILE Where to store the output metadata\" );\n ( \"-corrected-suffix\",\n Arg.Set_string corrected_suffix,\n \"SUFFIX Suffix to append to corrected files\" );\n ]\n\nlet get_args ?(standalone_args = standalone_args) () =\n standalone_args @ List.rev !args\n\nlet standalone_main () =\n let usage = Printf.sprintf \"%s [extra_args] []\" exe_name in\n let args = get_args () in\n Arg.parse (Arg.align args) set_input usage;\n interpret_mask ();\n if !request_print_transformations then (\n print_transformations ();\n Caml.exit 0);\n if !request_print_passes then (\n print_passes ();\n Caml.exit 0);\n match !input with\n | None ->\n Printf.eprintf \"%s: no input file given\\n%!\" exe_name;\n Caml.exit 2\n | Some fn ->\n let kind =\n match !kind with\n | Some k -> k\n | None -> (\n match Kind.of_filename fn with\n | Some k -> k\n | None ->\n Printf.eprintf\n \"%s: don't know what to do with '%s', use -impl or -intf.\\n\"\n exe_name fn;\n Caml.exit 2)\n in\n let input_name, relocate =\n match !loc_fname with None -> (fn, false) | Some fn -> (fn, true)\n in\n process_file kind fn ~input_name ~relocate ~output_mode:!output_mode\n ~output:!output ~embed_errors:!embed_errors\n\nlet rewrite_binary_ast_file input_fn output_fn =\n let input_name, input_version, ast = load_input_run_as_ppx input_fn in\n let ast =\n try\n let ast = extract_cookies ast in\n let tool_name = Astlib.Ast_metadata.tool_name () in\n let hook = Context_free.Generated_code_hook.nop in\n let expect_mismatch_handler = Context_free.Expect_mismatch_handler.nop in\n process_ast ast ~input_name ~tool_name ~hook ~expect_mismatch_handler\n ~embed_errors:true\n with exn -> exn_to_extension exn ~kind:(Intf_or_impl.kind ast)\n in\n with_output (Some output_fn) ~binary:true ~f:(fun oc ->\n Ast_io.write oc { input_name; input_version; ast } ~add_ppx_context:true)\n\nlet parse_input passed_in_args ~valid_args ~incorrect_input_msg =\n try\n Arg.parse_argv passed_in_args (Arg.align valid_args)\n (fun _ -> raise (Arg.Bad \"anonymous arguments not accepted\"))\n incorrect_input_msg\n with\n | Arg.Bad msg ->\n Printf.eprintf \"%s\" msg;\n Caml.exit 2\n | Arg.Help msg ->\n Printf.eprintf \"%s\" msg;\n Caml.exit 0\n\nlet run_as_ppx_rewriter_main ~standalone_args ~usage input =\n let valid_args = get_args ~standalone_args () in\n match List.rev @@ Array.to_list @@ input with\n | output_fn :: input_fn :: flags_and_prog_name\n when List.length flags_and_prog_name > 0 ->\n let prog_name_and_flags = List.rev flags_and_prog_name |> Array.of_list in\n parse_input prog_name_and_flags ~valid_args ~incorrect_input_msg:usage;\n interpret_mask ();\n rewrite_binary_ast_file input_fn output_fn;\n Caml.exit 0\n | [ help; _ ] when String.equal help \"-help\" || String.equal help \"--help\" ->\n parse_input input ~valid_args ~incorrect_input_msg:usage;\n assert false\n | _ ->\n Printf.eprintf \"Usage: %s\\n%!\" usage;\n Caml.exit 2\n\nlet standalone_run_as_ppx_rewriter () =\n let n = Array.length Caml.Sys.argv in\n let usage =\n Printf.sprintf \"%s -as-ppx [extra_args] \" exe_name\n in\n let argv = Array.make (n - 1) \"\" in\n argv.(0) <- Caml.Sys.argv.(0);\n for i = 1 to n - 2 do\n argv.(i) <- Caml.Sys.argv.(i + 1)\n done;\n let standalone_args =\n List.map standalone_args ~f:(fun (arg, spec, _doc) ->\n (arg, spec, \" Unused with -as-ppx\"))\n in\n run_as_ppx_rewriter_main ~standalone_args ~usage argv\n\nlet standalone () =\n Astlib.init_error_reporting_style_using_env_vars ();\n try\n if\n Array.length Caml.Sys.argv >= 2\n &&\n match Caml.Sys.argv.(1) with \"-as-ppx\" | \"--as-ppx\" -> true | _ -> false\n then standalone_run_as_ppx_rewriter ()\n else standalone_main ();\n Caml.exit 0\n with exn ->\n Location.report_exception Caml.Format.err_formatter exn;\n Caml.exit 1\n\nlet run_as_ppx_rewriter () =\n let usage = Printf.sprintf \"%s [extra_args] \" exe_name in\n let input = Caml.Sys.argv in\n try run_as_ppx_rewriter_main ~standalone_args:[] ~usage input\n with exn ->\n Location.report_exception Caml.Format.err_formatter exn;\n Caml.exit 1\n\nlet pretty () = !pretty\n\nlet enable_checks () =\n (* We do not enable the locations check here, we currently require that one\n to be specifically enabled. *)\n perform_checks := true;\n perform_checks_on_extensions := true\n\nlet enable_location_check () = perform_locations_check := true\nlet disable_location_check () = perform_locations_check := false\nlet map_structure st = map_structure st\n","open! Import\n\nlet mk_attr_noloc txt = Ast_helper.Attr.mk Location.{ txt; loc = none }\nlet hide_attribute : attribute = mk_attr_noloc \"merlin.hide\" (PStr [])\nlet focus_attribute : attribute = mk_attr_noloc \"merlin.focus\" (PStr [])\n\nlet hide_pattern ({ ppat_attributes; _ } as p) =\n { p with ppat_attributes = hide_attribute :: ppat_attributes }\n\nlet focus_pattern ({ ppat_attributes; _ } as p) =\n { p with ppat_attributes = focus_attribute :: ppat_attributes }\n\nlet hide_expression ({ pexp_attributes; _ } as e) =\n { e with pexp_attributes = hide_attribute :: pexp_attributes }\n\nlet focus_expression ({ pexp_attributes; _ } as e) =\n { e with pexp_attributes = focus_attribute :: pexp_attributes }\n","open Import\nopen Ast_builder.Default\n\nlet underscore_binding exp =\n let loc = exp.pexp_loc in\n value_binding ~loc ~pat:(ppat_any ~loc) ~expr:exp\n\nlet vars_of =\n object\n inherit [Longident.t Located.t list] Ast_traverse.fold as super\n\n method! pattern patt acc =\n match patt.ppat_desc with\n | Ppat_var v -> Located.map (fun var -> Longident.Lident var) v :: acc\n | _ -> super#pattern patt acc\n end\n\n(* For every [let x = ...] structure item, add a [let _ = x] *)\nlet add_dummy_user_for_values =\n object\n inherit Ast_traverse.map as super\n\n method! structure st =\n let rec loop st acc =\n match st with\n | [] -> List.rev acc\n | ({ pstr_desc = Pstr_value (_, vbs); pstr_loc = loc } as item) :: rest\n ->\n let vars =\n List.fold_left vbs ~init:[] ~f:(fun acc vb ->\n vars_of#pattern vb.pvb_pat acc)\n in\n let ign =\n pstr_value_list ~loc Nonrecursive\n (List.rev_map vars ~f:(fun v ->\n underscore_binding (pexp_ident ~loc:v.loc v)))\n in\n loop rest (ign @ (item :: acc))\n | item :: rest -> loop rest (item :: acc)\n in\n loop (super#structure st) []\n end\n\nlet binds_module_names =\n object\n inherit [bool] Ast_traverse.fold as super\n\n method! module_binding mb acc =\n match mb.pmb_name.txt with\n | Some (_ : string) -> true\n | None -> super#module_binding mb acc\n\n method! module_declaration md acc =\n match md.pmd_name.txt with\n | Some (_ : string) -> true\n | None -> super#module_declaration md acc\n\n method! module_substitution ms _ =\n match ms.pms_name.txt with (_ : string) -> true\n\n method! functor_parameter fp acc =\n match fp with\n | Unit -> acc\n | Named (name, _) -> (\n match name.txt with\n | Some (_ : string) -> true\n | None -> super#functor_parameter fp acc)\n\n method! pattern pat acc =\n match pat.ppat_desc with\n | Ppat_unpack name -> (\n match name.txt with Some (_ : string) -> true | None -> acc)\n | _ -> super#pattern pat acc\n\n method! expression expr acc =\n match expr.pexp_desc with\n | Pexp_letmodule (name, _, _) -> (\n match name.txt with\n | Some (_ : string) -> true\n | None -> super#expression expr acc)\n | _ -> super#expression expr acc\n end\n","open! Import\ninclude Clause_syntax_intf\n\nmodule Variant = struct\n type ast = constructor_declaration\n\n type t =\n { ast : ast\n ; position : int\n }\n\n let create_list list =\n List.mapi list ~f:(fun position ast ->\n let loc = ast.pcd_loc in\n match ast.pcd_res with\n | Some _ -> unsupported ~loc \"GADT\"\n | None -> { ast; position })\n ;;\n\n let salt t = Some t.position\n let location t = t.ast.pcd_loc\n\n let weight_attribute =\n Attribute.declare\n \"quickcheck.weight\"\n Attribute.Context.constructor_declaration\n Ast_pattern.(pstr (pstr_eval __ nil ^:: nil))\n (fun x -> x)\n ;;\n\n let weight t =\n match Attribute.get weight_attribute t.ast with\n | Some expr -> expr\n | None -> efloat ~loc:{ (location t) with loc_ghost = true } \"1.\"\n ;;\n\n let core_type_list t =\n match t.ast.pcd_args with\n | Pcstr_tuple list -> list\n | Pcstr_record label_decl_list ->\n List.map label_decl_list ~f:(fun label_decl -> label_decl.pld_type)\n ;;\n\n let pattern t ~loc pat_list =\n let arg =\n match t.ast.pcd_args with\n | Pcstr_tuple _ ->\n (match pat_list with\n | [] -> None\n | [ pat ] -> Some pat\n | _ -> Some (ppat_tuple ~loc pat_list))\n | Pcstr_record label_decl_list ->\n let alist =\n List.map2_exn label_decl_list pat_list ~f:(fun label_decl pat ->\n lident_loc label_decl.pld_name, pat)\n in\n Some (ppat_record ~loc alist Closed)\n in\n ppat_construct ~loc (lident_loc t.ast.pcd_name) arg\n ;;\n\n let expression t ~loc _ expr_list =\n let arg =\n match t.ast.pcd_args with\n | Pcstr_tuple _ ->\n (match expr_list with\n | [] -> None\n | [ expr ] -> Some expr\n | _ -> Some (pexp_tuple ~loc expr_list))\n | Pcstr_record label_decl_list ->\n let alist =\n List.map2_exn label_decl_list expr_list ~f:(fun label_decl expr ->\n lident_loc label_decl.pld_name, expr)\n in\n Some (pexp_record ~loc alist None)\n in\n pexp_construct ~loc (lident_loc t.ast.pcd_name) arg\n ;;\nend\n\nmodule Polymorphic_variant = struct\n type ast = row_field\n type t = ast\n\n let create_list = Fn.id\n\n let salt t =\n match t.prf_desc with\n | Rtag (label, _, _) -> Some (Ocaml_common.Btype.hash_variant label.txt)\n | Rinherit _ -> None\n ;;\n\n let location t = t.prf_loc\n\n let weight_attribute =\n Attribute.declare\n \"quickcheck.weight\"\n Attribute.Context.rtag\n Ast_pattern.(pstr (pstr_eval __ nil ^:: nil))\n (fun x -> x)\n ;;\n\n let weight t =\n match Attribute.get weight_attribute t with\n | Some expr -> expr\n | None -> efloat ~loc:{ (location t) with loc_ghost = true } \"1.\"\n ;;\n\n let core_type_list t =\n match t.prf_desc with\n | Rtag (_, _, core_type_list) -> core_type_list\n | Rinherit core_type -> [ core_type ]\n ;;\n\n let pattern t ~loc pat_list =\n match t.prf_desc, pat_list with\n | Rtag (label, true, []), [] -> ppat_variant ~loc label.txt None\n | Rtag (label, false, [ _ ]), [ pat ] -> ppat_variant ~loc label.txt (Some pat)\n | Rtag (label, false, [ _ ]), _ :: _ :: _ ->\n ppat_variant ~loc label.txt (Some (ppat_tuple ~loc pat_list))\n | Rinherit { ptyp_desc; _ }, [ { ppat_desc; _ } ] ->\n (match ptyp_desc with\n | Ptyp_constr (id, []) ->\n (match ppat_desc with\n | Ppat_var var -> ppat_alias ~loc (ppat_type ~loc id) var\n | _ ->\n internal_error\n ~loc\n \"cannot bind a # pattern to anything other than a variable\")\n | _ ->\n unsupported ~loc \"inherited polymorphic variant type that is not a type name\")\n | Rtag (_, true, _ :: _), _ | Rtag (_, false, ([] | _ :: _ :: _)), _ ->\n unsupported ~loc \"intersection type\"\n | Rtag (_, true, []), _ :: _\n | Rtag (_, false, [ _ ]), []\n | Rinherit _, ([] | _ :: _ :: _) ->\n internal_error ~loc \"wrong number of arguments for variant clause\"\n ;;\n\n let expression t ~loc core_type expr_list =\n match t.prf_desc, expr_list with\n | Rtag (label, true, []), [] -> pexp_variant ~loc label.txt None\n | Rtag (label, false, [ _ ]), [ expr ] -> pexp_variant ~loc label.txt (Some expr)\n | Rtag (label, false, [ _ ]), _ :: _ :: _ ->\n pexp_variant ~loc label.txt (Some (pexp_tuple ~loc expr_list))\n | Rinherit inherited_type, [ expr ] ->\n pexp_coerce ~loc expr (Some inherited_type) core_type\n | Rtag (_, true, _ :: _), _ | Rtag (_, false, ([] | _ :: _ :: _)), _ ->\n unsupported ~loc \"intersection type\"\n | Rtag (_, true, []), _ :: _\n | Rtag (_, false, [ _ ]), []\n | Rinherit _, ([] | _ :: _ :: _) ->\n internal_error ~loc \"wrong number of arguments for variant clause\"\n ;;\nend\n","open! Import\ninclude Field_syntax_intf\n\nmodule Tuple = struct\n type ast = core_type\n type t = ast\n\n let create = Fn.id\n let location t = t.ptyp_loc\n let core_type t = t\n let pattern _ ~loc pat_list = ppat_tuple ~loc pat_list\n let expression _ ~loc expr_list = pexp_tuple ~loc expr_list\nend\n\nmodule Record = struct\n type ast = label_declaration\n type t = ast\n\n let create ast =\n match ast.pld_mutable with\n | Immutable -> ast\n | Mutable ->\n (* We intend to support mutable fields and values shortly, but we leave it to a\n separate feature. Integrating mutable values with replayability and shrinking is\n tricky, and we at least have to figure out what caveats to document. *)\n unsupported ~loc:ast.pld_loc \"mutable record field\"\n ;;\n\n let location t = t.pld_loc\n let core_type t = t.pld_type\n\n let pattern list ~loc pat_list =\n let alist =\n List.map2_exn list pat_list ~f:(fun t pat -> lident_loc t.pld_name, pat)\n in\n ppat_record ~loc alist Closed\n ;;\n\n let expression list ~loc expr_list =\n let alist =\n List.map2_exn list expr_list ~f:(fun t expr -> lident_loc t.pld_name, expr)\n in\n pexp_record ~loc alist None\n ;;\nend\n","open! Import\n\nlet any ~loc = [%expr Base_quickcheck.Shrinker.atomic]\nlet arrow ~loc = [%expr Base_quickcheck.Shrinker.atomic]\n\nlet compound_sequence ~loc ~make_compound_expr ~field_pats ~field_exprs ~shrinker_exprs =\n [%expr\n Base.Sequence.round_robin\n [%e\n elist\n ~loc\n (List.map3_exn\n field_pats\n field_exprs\n shrinker_exprs\n ~f:(fun field_pat field_expr shrinker ->\n let loc = { shrinker.pexp_loc with loc_ghost = true } in\n [%expr\n Base.Sequence.map\n (Base_quickcheck.Shrinker.shrink [%e shrinker] [%e field_expr])\n ~f:(fun [%p field_pat] -> [%e make_compound_expr ~loc field_exprs])]))]]\n;;\n\nlet compound\n (type field)\n ~shrinker_of_core_type\n ~loc\n ~fields\n (module Field : Field_syntax.S with type ast = field)\n =\n let fields = List.map fields ~f:Field.create in\n let field_pats, field_exprs = gensyms \"x\" (List.map fields ~f:Field.location) in\n let shrinker_exprs =\n List.map fields ~f:(fun field -> shrinker_of_core_type (Field.core_type field))\n in\n [%expr\n Base_quickcheck.Shrinker.create (fun [%p Field.pattern fields ~loc field_pats] ->\n [%e\n compound_sequence\n ~loc\n ~make_compound_expr:(Field.expression fields)\n ~field_pats\n ~field_exprs\n ~shrinker_exprs])]\n;;\n\nlet variant\n (type clause)\n ~shrinker_of_core_type\n ~loc\n ~variant_type\n ~clauses\n (module Clause : Clause_syntax.S with type ast = clause)\n =\n let clauses = Clause.create_list clauses in\n [%expr\n Base_quickcheck.Shrinker.create\n [%e\n pexp_function\n ~loc\n (List.map clauses ~f:(fun clause ->\n let loc = { (Clause.location clause) with loc_ghost = true } in\n let core_type_list = Clause.core_type_list clause in\n let field_pats, field_exprs =\n gensyms\n \"x\"\n (List.map core_type_list ~f:(fun core_type -> core_type.ptyp_loc))\n in\n let shrinker_exprs = List.map core_type_list ~f:shrinker_of_core_type in\n let lhs = Clause.pattern clause ~loc field_pats in\n let rhs =\n compound_sequence\n ~loc\n ~make_compound_expr:(Clause.expression clause variant_type)\n ~field_pats\n ~field_exprs\n ~shrinker_exprs\n in\n case ~lhs ~guard:None ~rhs))]]\n;;\n","open! Import\n\nlet arrow\n ~generator_of_core_type\n ~observer_of_core_type\n ~loc\n ~arg_label\n ~input_type\n ~output_type\n =\n let input_observer =\n match arg_label with\n | Nolabel | Labelled _ -> observer_of_core_type input_type\n | Optional _ ->\n [%expr Base_quickcheck.Observer.option [%e observer_of_core_type input_type]]\n in\n let output_generator = generator_of_core_type output_type in\n let unlabelled =\n [%expr Base_quickcheck.Generator.fn [%e input_observer] [%e output_generator]]\n in\n match arg_label with\n | Nolabel -> unlabelled\n | Labelled _ | Optional _ ->\n [%expr\n Base_quickcheck.Generator.map\n ~f:[%e fn_map_label ~loc ~from:Nolabel ~to_:arg_label]\n [%e unlabelled]]\n;;\n\nlet compound_generator ~loc ~make_compound_expr generator_list =\n let loc = { loc with loc_ghost = true } in\n let size_pat, size_expr = gensym \"size\" loc in\n let random_pat, random_expr = gensym \"random\" loc in\n [%expr\n Base_quickcheck.Generator.create (fun ~size:[%p size_pat] ~random:[%p random_pat] ->\n [%e\n make_compound_expr\n ~loc\n (List.map generator_list ~f:(fun generator ->\n let loc = { generator.pexp_loc with loc_ghost = true } in\n [%expr\n Base_quickcheck.Generator.generate\n [%e generator]\n ~size:[%e size_expr]\n ~random:[%e random_expr]]))])]\n;;\n\nlet compound\n (type field)\n ~generator_of_core_type\n ~loc\n ~fields\n (module Field : Field_syntax.S with type ast = field)\n =\n let fields = List.map fields ~f:Field.create in\n compound_generator\n ~loc\n ~make_compound_expr:(Field.expression fields)\n (List.map fields ~f:(fun field -> generator_of_core_type (Field.core_type field)))\n;;\n\nlet does_refer_to name_set =\n object (self)\n inherit [bool] Ast_traverse.fold as super\n\n method! core_type ty acc =\n match ty.ptyp_desc with\n | Ptyp_constr (name, args) ->\n acc\n || Set.mem name_set (Longident.name name.txt)\n || List.exists args ~f:(fun arg -> self#core_type arg false)\n | _ -> super#core_type ty acc\n end\n;;\n\nlet clause_is_recursive\n (type clause)\n ~clause\n ~rec_names\n (module Clause : Clause_syntax.S with type t = clause)\n =\n List.exists (Clause.core_type_list clause) ~f:(fun ty ->\n (does_refer_to rec_names)#core_type ty false)\n;;\n\nlet variant\n (type clause)\n ~generator_of_core_type\n ~loc\n ~variant_type\n ~clauses\n ~rec_names\n (module Clause : Clause_syntax.S with type ast = clause)\n =\n let clauses = Clause.create_list clauses in\n let make_generator clause =\n compound_generator\n ~loc:(Clause.location clause)\n ~make_compound_expr:(Clause.expression clause variant_type)\n (List.map (Clause.core_type_list clause) ~f:generator_of_core_type)\n in\n let make_pair clause =\n pexp_tuple\n ~loc:{ (Clause.location clause) with loc_ghost = true }\n [ Clause.weight clause; make_generator clause ]\n in\n match\n List.partition_tf clauses ~f:(fun clause ->\n clause_is_recursive ~clause ~rec_names (module Clause))\n with\n | [], clauses | clauses, [] ->\n let pairs = List.map clauses ~f:make_pair in\n [%expr Base_quickcheck.Generator.weighted_union [%e elist ~loc pairs]]\n | recursive_clauses, nonrecursive_clauses ->\n let size_pat, size_expr = gensym \"size\" loc in\n let nonrec_pat, nonrec_expr = gensym \"gen\" loc in\n let rec_pat, rec_expr = gensym \"gen\" loc in\n let nonrec_pats, nonrec_exprs =\n gensyms \"pair\" (List.map nonrecursive_clauses ~f:Clause.location)\n in\n let rec_pats, rec_exprs =\n gensyms \"pair\" (List.map recursive_clauses ~f:Clause.location)\n in\n let bindings =\n List.map2_exn nonrec_pats nonrecursive_clauses ~f:(fun pat clause ->\n let loc = { (Clause.location clause) with loc_ghost = true } in\n let expr = make_pair clause in\n value_binding ~loc ~pat ~expr)\n @ List.map2_exn rec_pats recursive_clauses ~f:(fun pat clause ->\n let loc = { (Clause.location clause) with loc_ghost = true } in\n let weight_expr = Clause.weight clause in\n let gen_expr =\n [%expr\n Base_quickcheck.Generator.bind\n Base_quickcheck.Generator.size\n ~f:(fun [%p size_pat] ->\n Base_quickcheck.Generator.with_size\n ~size:(Base.Int.pred [%e size_expr])\n [%e make_generator clause])]\n in\n let expr = pexp_tuple ~loc [ weight_expr; gen_expr ] in\n value_binding ~loc ~pat ~expr)\n in\n let body =\n [%expr\n let [%p nonrec_pat] =\n Base_quickcheck.Generator.weighted_union [%e elist ~loc nonrec_exprs]\n and [%p rec_pat] =\n Base_quickcheck.Generator.weighted_union\n [%e elist ~loc (nonrec_exprs @ rec_exprs)]\n in\n Base_quickcheck.Generator.bind Base_quickcheck.Generator.size ~f:(function\n | 0 -> [%e nonrec_expr]\n | _ -> [%e rec_expr])]\n in\n pexp_let ~loc Nonrecursive bindings body\n;;\n","open! Import\n\nlet any ~loc = [%expr Base_quickcheck.Observer.opaque]\n\nlet arrow\n ~observer_of_core_type\n ~generator_of_core_type\n ~loc\n ~arg_label\n ~input_type\n ~output_type\n =\n let input_generator =\n match arg_label with\n | Nolabel | Labelled _ -> generator_of_core_type input_type\n | Optional _ ->\n [%expr Base_quickcheck.Generator.option [%e generator_of_core_type input_type]]\n in\n let output_observer = observer_of_core_type output_type in\n let unlabelled =\n [%expr Base_quickcheck.Observer.fn [%e input_generator] [%e output_observer]]\n in\n match arg_label with\n | Nolabel -> unlabelled\n | Labelled _ | Optional _ ->\n [%expr\n Base_quickcheck.Observer.unmap\n ~f:[%e fn_map_label ~loc ~from:arg_label ~to_:Nolabel]\n [%e unlabelled]]\n;;\n\nlet compound_hash ~loc ~size_expr ~hash_expr ~hash_pat ~observer_exprs ~field_exprs =\n let alist = List.zip_exn observer_exprs field_exprs in\n List.fold_right alist ~init:hash_expr ~f:(fun (observer_expr, field_expr) body_expr ->\n [%expr\n let [%p hash_pat] =\n Base_quickcheck.Observer.observe\n [%e observer_expr]\n [%e field_expr]\n ~size:[%e size_expr]\n ~hash:[%e hash_expr]\n in\n [%e body_expr]])\n;;\n\nlet compound\n (type field)\n ~observer_of_core_type\n ~loc\n ~fields\n (module Field : Field_syntax.S with type ast = field)\n =\n let fields = List.map fields ~f:Field.create in\n let field_pats, field_exprs = gensyms \"x\" (List.map fields ~f:Field.location) in\n let pat = Field.pattern fields ~loc field_pats in\n let observer_exprs =\n List.map fields ~f:(fun field -> observer_of_core_type (Field.core_type field))\n in\n let size_pat, size_expr = gensym \"size\" loc in\n let hash_pat, hash_expr = gensym \"hash\" loc in\n [%expr\n Base_quickcheck.Observer.create\n (fun [%p pat] ~size:[%p size_pat] ~hash:[%p hash_pat] ->\n [%e\n compound_hash ~loc ~size_expr ~hash_expr ~hash_pat ~observer_exprs ~field_exprs])]\n;;\n\nlet variant\n (type clause)\n ~observer_of_core_type\n ~loc\n ~clauses\n (module Clause : Clause_syntax.S with type ast = clause)\n =\n let clauses = Clause.create_list clauses in\n let pat, expr = gensym \"x\" loc in\n let size_pat, size_expr = gensym \"size\" loc in\n let hash_pat, hash_expr = gensym \"hash\" loc in\n [%expr\n Base_quickcheck.Observer.create\n (fun [%p pat] ~size:[%p size_pat] ~hash:[%p hash_pat] ->\n [%e\n pexp_match\n ~loc\n expr\n (List.map clauses ~f:(fun clause ->\n let core_type_list = Clause.core_type_list clause in\n let observer_exprs = List.map core_type_list ~f:observer_of_core_type in\n let field_pats, field_exprs =\n gensyms\n \"x\"\n (List.map core_type_list ~f:(fun core_type -> core_type.ptyp_loc))\n in\n let lhs = Clause.pattern clause ~loc field_pats in\n let body =\n compound_hash\n ~loc\n ~size_expr\n ~hash_expr\n ~hash_pat\n ~observer_exprs\n ~field_exprs\n in\n let rhs =\n match Clause.salt clause with\n | None -> body\n | Some salt ->\n pexp_let\n ~loc\n Nonrecursive\n [ value_binding\n ~loc\n ~pat:hash_pat\n ~expr:\n [%expr\n Base.hash_fold_int [%e hash_expr] [%e eint ~loc salt]]\n ]\n body\n in\n case ~lhs ~guard:None ~rhs))])]\n;;\n","open! Import\n\nlet custom_extension ~loc tag payload =\n match String.equal tag.txt \"custom\" with\n | false -> unsupported ~loc \"uknown extension: %s\" tag.txt\n | true ->\n (match payload with\n | PStr [ { pstr_desc = Pstr_eval (expr, attributes); _ } ] ->\n assert_no_attributes attributes;\n expr\n | _ -> invalid ~loc \"[%%custom] extension expects a single expression as its payload\")\n;;\n\nlet generator_attribute =\n Attribute.declare\n \"quickcheck.generator\"\n Attribute.Context.core_type\n Ast_pattern.(pstr (pstr_eval __ nil ^:: nil))\n (fun x -> x)\n;;\n\nlet rec generator_of_core_type core_type ~gen_env ~obs_env =\n let loc = { core_type.ptyp_loc with loc_ghost = true } in\n match Attribute.get generator_attribute core_type with\n | Some expr -> expr\n | None ->\n (match core_type.ptyp_desc with\n | Ptyp_constr (constr, args) ->\n type_constr_conv\n ~loc\n ~f:generator_name\n constr\n (List.map args ~f:(generator_of_core_type ~gen_env ~obs_env))\n | Ptyp_var tyvar -> Environment.lookup gen_env ~loc ~tyvar\n | Ptyp_arrow (arg_label, input_type, output_type) ->\n Ppx_generator_expander.arrow\n ~generator_of_core_type:(generator_of_core_type ~gen_env ~obs_env)\n ~observer_of_core_type:(observer_of_core_type ~gen_env ~obs_env)\n ~loc\n ~arg_label\n ~input_type\n ~output_type\n | Ptyp_tuple fields ->\n Ppx_generator_expander.compound\n ~generator_of_core_type:(generator_of_core_type ~gen_env ~obs_env)\n ~loc\n ~fields\n (module Field_syntax.Tuple)\n | Ptyp_variant (clauses, Closed, None) ->\n Ppx_generator_expander.variant\n ~generator_of_core_type:(generator_of_core_type ~gen_env ~obs_env)\n ~loc\n ~variant_type:core_type\n ~clauses\n ~rec_names:(Set.empty (module String))\n (module Clause_syntax.Polymorphic_variant)\n | Ptyp_variant (_, Open, _) -> unsupported ~loc \"polymorphic variant type with [>]\"\n | Ptyp_variant (_, _, Some _) -> unsupported ~loc \"polymorphic variant type with [<]\"\n | Ptyp_extension (tag, payload) -> custom_extension ~loc tag payload\n | Ptyp_any\n | Ptyp_object _\n | Ptyp_class _\n | Ptyp_alias _\n | Ptyp_poly _\n | Ptyp_package _ -> unsupported ~loc \"%s\" (short_string_of_core_type core_type))\n\nand observer_of_core_type core_type ~obs_env ~gen_env =\n let loc = { core_type.ptyp_loc with loc_ghost = true } in\n match core_type.ptyp_desc with\n | Ptyp_constr (constr, args) ->\n type_constr_conv\n ~loc\n ~f:observer_name\n constr\n (List.map args ~f:(observer_of_core_type ~obs_env ~gen_env))\n | Ptyp_var tyvar -> Environment.lookup obs_env ~loc ~tyvar\n | Ptyp_arrow (arg_label, input_type, output_type) ->\n Ppx_observer_expander.arrow\n ~observer_of_core_type:(observer_of_core_type ~obs_env ~gen_env)\n ~generator_of_core_type:(generator_of_core_type ~obs_env ~gen_env)\n ~loc\n ~arg_label\n ~input_type\n ~output_type\n | Ptyp_tuple fields ->\n Ppx_observer_expander.compound\n ~observer_of_core_type:(observer_of_core_type ~obs_env ~gen_env)\n ~loc\n ~fields\n (module Field_syntax.Tuple)\n | Ptyp_variant (clauses, Closed, None) ->\n Ppx_observer_expander.variant\n ~observer_of_core_type:(observer_of_core_type ~obs_env ~gen_env)\n ~loc\n ~clauses\n (module Clause_syntax.Polymorphic_variant)\n | Ptyp_variant (_, Open, _) -> unsupported ~loc \"polymorphic variant type with [>]\"\n | Ptyp_variant (_, _, Some _) -> unsupported ~loc \"polymorphic variant type with [<]\"\n | Ptyp_extension (tag, payload) -> custom_extension ~loc tag payload\n | Ptyp_any -> Ppx_observer_expander.any ~loc\n | Ptyp_object _ | Ptyp_class _ | Ptyp_alias _ | Ptyp_poly _ | Ptyp_package _ ->\n unsupported ~loc \"%s\" (short_string_of_core_type core_type)\n;;\n\nlet rec shrinker_of_core_type core_type ~env =\n let loc = { core_type.ptyp_loc with loc_ghost = true } in\n match core_type.ptyp_desc with\n | Ptyp_constr (constr, args) ->\n type_constr_conv\n ~loc\n ~f:shrinker_name\n constr\n (List.map args ~f:(shrinker_of_core_type ~env))\n | Ptyp_var tyvar -> Environment.lookup env ~loc ~tyvar\n | Ptyp_arrow _ -> Ppx_shrinker_expander.arrow ~loc\n | Ptyp_tuple fields ->\n Ppx_shrinker_expander.compound\n ~shrinker_of_core_type:(shrinker_of_core_type ~env)\n ~loc\n ~fields\n (module Field_syntax.Tuple)\n | Ptyp_variant (clauses, Closed, None) ->\n Ppx_shrinker_expander.variant\n ~shrinker_of_core_type:(shrinker_of_core_type ~env)\n ~loc\n ~variant_type:core_type\n ~clauses\n (module Clause_syntax.Polymorphic_variant)\n | Ptyp_variant (_, Open, _) -> unsupported ~loc \"polymorphic variant type with [>]\"\n | Ptyp_variant (_, _, Some _) -> unsupported ~loc \"polymorphic variant type with [<]\"\n | Ptyp_extension (tag, payload) -> custom_extension ~loc tag payload\n | Ptyp_any -> Ppx_shrinker_expander.any ~loc\n | Ptyp_object _ | Ptyp_class _ | Ptyp_alias _ | Ptyp_poly _ | Ptyp_package _ ->\n unsupported ~loc \"%s\" (short_string_of_core_type core_type)\n;;\n\ntype impl =\n { loc : location\n ; pat : pattern\n ; var : expression\n ; exp : expression\n }\n\nlet generator_impl type_decl ~rec_names =\n let loc = type_decl.ptype_loc in\n let pat = pgenerator type_decl.ptype_name in\n let var = egenerator type_decl.ptype_name in\n let exp =\n let pat_list, `Covariant gen_env, `Contravariant obs_env =\n Environment.create_with_variance\n ~loc\n ~covariant:\"generator\"\n ~contravariant:\"observer\"\n type_decl.ptype_params\n in\n let body =\n match type_decl.ptype_kind with\n | Ptype_open -> unsupported ~loc \"open type\"\n | Ptype_variant clauses ->\n Ppx_generator_expander.variant\n ~generator_of_core_type:(generator_of_core_type ~gen_env ~obs_env)\n ~loc\n ~variant_type:[%type: _]\n ~clauses\n ~rec_names\n (module Clause_syntax.Variant)\n | Ptype_record fields ->\n Ppx_generator_expander.compound\n ~generator_of_core_type:(generator_of_core_type ~gen_env ~obs_env)\n ~loc\n ~fields\n (module Field_syntax.Record)\n | Ptype_abstract ->\n (match type_decl.ptype_manifest with\n | Some core_type -> generator_of_core_type core_type ~gen_env ~obs_env\n | None -> unsupported ~loc \"abstract type\")\n in\n List.fold_right pat_list ~init:body ~f:(fun pat body ->\n [%expr fun [%p pat] -> [%e body]])\n in\n { loc; pat; var; exp }\n;;\n\nlet observer_impl type_decl ~rec_names:_ =\n let loc = type_decl.ptype_loc in\n let pat = pobserver type_decl.ptype_name in\n let var = eobserver type_decl.ptype_name in\n let exp =\n let pat_list, `Covariant obs_env, `Contravariant gen_env =\n Environment.create_with_variance\n ~loc\n ~covariant:\"observer\"\n ~contravariant:\"generator\"\n type_decl.ptype_params\n in\n let body =\n match type_decl.ptype_kind with\n | Ptype_open -> unsupported ~loc \"open type\"\n | Ptype_variant clauses ->\n Ppx_observer_expander.variant\n ~observer_of_core_type:(observer_of_core_type ~obs_env ~gen_env)\n ~loc\n ~clauses\n (module Clause_syntax.Variant)\n | Ptype_record fields ->\n Ppx_observer_expander.compound\n ~observer_of_core_type:(observer_of_core_type ~obs_env ~gen_env)\n ~loc\n ~fields\n (module Field_syntax.Record)\n | Ptype_abstract ->\n (match type_decl.ptype_manifest with\n | Some core_type -> observer_of_core_type core_type ~obs_env ~gen_env\n | None -> unsupported ~loc \"abstract type\")\n in\n List.fold_right pat_list ~init:body ~f:(fun pat body ->\n [%expr fun [%p pat] -> [%e body]])\n in\n { loc; pat; var; exp }\n;;\n\nlet shrinker_impl type_decl ~rec_names:_ =\n let loc = type_decl.ptype_loc in\n let pat = pshrinker type_decl.ptype_name in\n let var = eshrinker type_decl.ptype_name in\n let exp =\n let pat_list, env =\n Environment.create ~loc ~prefix:\"shrinker\" type_decl.ptype_params\n in\n let body =\n match type_decl.ptype_kind with\n | Ptype_open -> unsupported ~loc \"open type\"\n | Ptype_variant clauses ->\n Ppx_shrinker_expander.variant\n ~shrinker_of_core_type:(shrinker_of_core_type ~env)\n ~loc\n ~variant_type:[%type: _]\n ~clauses\n (module Clause_syntax.Variant)\n | Ptype_record fields ->\n Ppx_shrinker_expander.compound\n ~shrinker_of_core_type:(shrinker_of_core_type ~env)\n ~loc\n ~fields\n (module Field_syntax.Record)\n | Ptype_abstract ->\n (match type_decl.ptype_manifest with\n | Some core_type -> shrinker_of_core_type core_type ~env\n | None -> unsupported ~loc \"abstract type\")\n in\n List.fold_right pat_list ~init:body ~f:(fun pat body ->\n [%expr fun [%p pat] -> [%e body]])\n in\n { loc; pat; var; exp }\n;;\n\nlet maybe_mutually_recursive decls ~loc ~rec_flag ~of_lazy ~impl =\n let decls = List.map decls ~f:name_type_params_in_td in\n let rec_names =\n match rec_flag with\n | Nonrecursive -> Set.empty (module String)\n | Recursive ->\n Set.of_list (module String) (List.map decls ~f:(fun decl -> decl.ptype_name.txt))\n in\n let impls = List.map decls ~f:(fun decl -> impl decl ~rec_names) in\n match rec_flag with\n | Nonrecursive ->\n pstr_value_list\n ~loc\n Nonrecursive\n (List.map impls ~f:(fun impl ->\n value_binding ~loc:impl.loc ~pat:impl.pat ~expr:impl.exp))\n | Recursive ->\n let pats = List.map impls ~f:(fun impl -> impl.pat) in\n let bindings =\n let inner_bindings =\n List.map impls ~f:(fun inner ->\n value_binding\n ~loc:inner.loc\n ~pat:inner.pat\n ~expr:[%expr [%e of_lazy] [%e inner.var]])\n in\n List.map impls ~f:(fun impl ->\n let body = pexp_let ~loc:impl.loc Nonrecursive inner_bindings impl.exp in\n let lazy_expr = [%expr lazy [%e body]] in\n value_binding ~loc:impl.loc ~pat:impl.pat ~expr:lazy_expr)\n in\n let body =\n pexp_tuple\n ~loc\n (List.map impls ~f:(fun impl -> [%expr [%e of_lazy] [%e impl.var]]))\n in\n pstr_value_list\n ~loc\n Nonrecursive\n [ value_binding\n ~loc\n ~pat:(ppat_tuple ~loc pats)\n ~expr:(pexp_let ~loc Recursive bindings body)\n ]\n;;\n\nlet generator_impl_list decls ~loc ~rec_flag =\n maybe_mutually_recursive\n decls\n ~loc\n ~rec_flag\n ~of_lazy:[%expr Base_quickcheck.Generator.of_lazy]\n ~impl:generator_impl\n;;\n\nlet observer_impl_list decls ~loc ~rec_flag =\n maybe_mutually_recursive\n decls\n ~loc\n ~rec_flag\n ~of_lazy:[%expr Base_quickcheck.Observer.of_lazy]\n ~impl:observer_impl\n;;\n\nlet shrinker_impl_list decls ~loc ~rec_flag =\n maybe_mutually_recursive\n decls\n ~loc\n ~rec_flag\n ~of_lazy:[%expr Base_quickcheck.Shrinker.of_lazy]\n ~impl:shrinker_impl\n;;\n\nlet intf type_decl ~f ~covar ~contravar =\n let covar = Longident.parse (\"Base_quickcheck.\" ^ covar ^ \".t\") in\n let contravar = Longident.parse (\"Base_quickcheck.\" ^ contravar ^ \".t\") in\n let type_decl = name_type_params_in_td type_decl in\n let loc = type_decl.ptype_loc in\n let name = loc_map type_decl.ptype_name ~f in\n let result =\n ptyp_constr\n ~loc\n { loc; txt = covar }\n [ ptyp_constr\n ~loc\n (lident_loc type_decl.ptype_name)\n (List.map type_decl.ptype_params ~f:fst)\n ]\n in\n let type_ =\n List.fold_right\n type_decl.ptype_params\n ~init:result\n ~f:(fun (core_type, (variance, injectivity)) result ->\n let id =\n match (variance, injectivity) with\n | ((NoVariance | Covariant), NoInjectivity) -> covar\n | (Contravariant, NoInjectivity) -> contravar\n | (_, Injective) -> Location.raise_errorf ~loc \"Injective type parameters aren't supported.\"\n in\n let arg = ptyp_constr ~loc { loc; txt = id } [ core_type ] in\n [%type: [%t arg] -> [%t result]])\n in\n psig_value ~loc (value_description ~loc ~name ~type_ ~prim:[])\n;;\n\nlet shrinker_intf = intf ~f:shrinker_name ~covar:\"Shrinker\" ~contravar:\"Shrinker\"\nlet generator_intf = intf ~f:generator_name ~covar:\"Generator\" ~contravar:\"Observer\"\nlet observer_intf = intf ~f:observer_name ~covar:\"Observer\" ~contravar:\"Generator\"\nlet generator_intf_list type_decl_list = List.map type_decl_list ~f:generator_intf\nlet observer_intf_list type_decl_list = List.map type_decl_list ~f:observer_intf\nlet shrinker_intf_list type_decl_list = List.map type_decl_list ~f:shrinker_intf\n\nlet sig_type_decl =\n Deriving.Generator.make_noarg (fun ~loc:_ ~path:_ (_, decls) ->\n generator_intf_list decls @ observer_intf_list decls @ shrinker_intf_list decls)\n;;\n\nlet str_type_decl =\n Deriving.Generator.make_noarg (fun ~loc ~path:_ (rec_flag, decls) ->\n let rec_flag = really_recursive rec_flag decls in\n generator_impl_list ~loc ~rec_flag decls\n @ observer_impl_list ~loc ~rec_flag decls\n @ shrinker_impl_list ~loc ~rec_flag decls)\n;;\n\nlet generator_extension ~loc:_ ~path:_ core_type =\n generator_of_core_type core_type ~gen_env:Environment.empty ~obs_env:Environment.empty\n;;\n\nlet observer_extension ~loc:_ ~path:_ core_type =\n observer_of_core_type core_type ~obs_env:Environment.empty ~gen_env:Environment.empty\n;;\n\nlet shrinker_extension ~loc:_ ~path:_ core_type =\n shrinker_of_core_type core_type ~env:Environment.empty\n;;\n","open! Base\nopen Ppxlib\nopen Ppx_quickcheck_expander\n\nlet (_ : Deriving.t) = Deriving.add \"quickcheck\" ~sig_type_decl ~str_type_decl\nlet (_ : Deriving.t) = Deriving.add \"quickcheck.generator\" ~extension:generator_extension\nlet (_ : Deriving.t) = Deriving.add \"quickcheck.observer\" ~extension:observer_extension\nlet (_ : Deriving.t) = Deriving.add \"quickcheck.shrinker\" ~extension:shrinker_extension\n","module Kimchi_backend_common = struct\n module Field = Kimchi_backend_common.Field\n module Scalar_challenge = Kimchi_backend_common.Scalar_challenge\nend\n\nmodule Field = Kimchi_backend_common.Field\n\nmodule Pasta = struct\n module Basic = Kimchi_pasta.Basic\n module Pallas_based_plonk = Kimchi_pasta.Pallas_based_plonk\n module Pasta = Kimchi_pasta.Pasta\n module Vesta_based_plonk = Kimchi_pasta.Vesta_based_plonk\nend\n","module Tick = struct\n include Kimchi_backend.Pasta.Vesta_based_plonk\n module Inner_curve = Kimchi_backend.Pasta.Pasta.Pallas\nend\n\nmodule Tock = struct\n include Kimchi_backend.Pasta.Pallas_based_plonk\n module Inner_curve = Kimchi_backend.Pasta.Pasta.Vesta\nend\n","(* Based on this paper. https://eprint.iacr.org/2019/403 *)\n\nopen Core_kernel\n\nmodule Spec = struct\n type 'f t = { b : 'f } [@@deriving bin_io]\nend\n\nmodule Params = struct\n type 'f t =\n { u : 'f\n ; fu : 'f\n ; sqrt_neg_three_u_squared_minus_u_over_2 : 'f\n ; sqrt_neg_three_u_squared : 'f\n ; inv_three_u_squared : 'f\n ; b : 'f\n }\n [@@deriving fields, bin_io]\n\n let spec { b; _ } = { Spec.b }\n\n let map\n { u\n ; fu\n ; sqrt_neg_three_u_squared_minus_u_over_2\n ; sqrt_neg_three_u_squared\n ; inv_three_u_squared\n ; b\n } ~f =\n { u = f u\n ; fu = f fu\n ; sqrt_neg_three_u_squared_minus_u_over_2 =\n f sqrt_neg_three_u_squared_minus_u_over_2\n ; sqrt_neg_three_u_squared = f sqrt_neg_three_u_squared\n ; inv_three_u_squared = f inv_three_u_squared\n ; b = f b\n }\n\n (* A deterministic function for constructing a valid choice of parameters for a\n given field. *)\n let create (type t) (module F : Field_intf.S_unchecked with type t = t)\n { Spec.b } =\n let open F in\n let first_map f =\n let rec go i = match f i with Some x -> x | None -> go (i + one) in\n go zero\n in\n let curve_eqn u = (u * u * u) + b in\n let u, fu =\n first_map (fun u ->\n let fu = curve_eqn u in\n if equal u zero || equal fu zero then None else Some (u, fu) )\n in\n let three_u_squared = u * u * of_int 3 in\n let sqrt_neg_three_u_squared = sqrt (negate three_u_squared) in\n { u\n ; fu\n ; sqrt_neg_three_u_squared_minus_u_over_2 =\n (sqrt_neg_three_u_squared - u) / of_int 2\n ; sqrt_neg_three_u_squared\n ; inv_three_u_squared = one / three_u_squared\n ; b\n }\nend\n\nmodule Make\n (Constant : Field_intf.S) (F : sig\n include Field_intf.S\n\n val constant : Constant.t -> t\n end) (P : sig\n val params : Constant.t Params.t\n end) =\nstruct\n open F\n open P\n\n let square x = x * x\n\n let potential_xs t =\n let t2 = t * t in\n let alpha =\n let alpha_inv = (t2 + constant params.fu) * t2 in\n one / alpha_inv\n in\n let x1 =\n let temp = square t2 * alpha * constant params.sqrt_neg_three_u_squared in\n constant params.sqrt_neg_three_u_squared_minus_u_over_2 - temp\n in\n let x2 = negate (constant params.u) - x1 in\n let x3 =\n let t2_plus_fu = t2 + constant params.fu in\n let t2_inv = alpha * t2_plus_fu in\n let temp =\n square t2_plus_fu * t2_inv * constant params.inv_three_u_squared\n in\n constant params.u - temp\n in\n (x1, x2, x3)\nend\n\nlet to_group (type t) (module F : Field_intf.S_unchecked with type t = t)\n ~params t =\n let module M =\n Make\n (F)\n (struct\n include F\n\n let constant = Fn.id\n end)\n (struct\n let params = params\n end)\n in\n let b = params.b in\n let try_decode x =\n let f x = F.((x * x * x) + b) in\n let y = f x in\n if F.is_square y then Some (x, F.sqrt y) else None\n in\n let x1, x2, x3 = M.potential_xs t in\n List.find_map [ x1; x2; x3 ] ~f:try_decode |> Option.value_exn\n\nlet%test_module \"test\" =\n ( module struct\n module Fp = struct\n include\n Snarkette.Fields.Make_fp\n (Snarkette.Nat)\n (struct\n let order =\n Snarkette.Nat.of_string\n \"5543634365110765627805495722742127385843376434033820803590214255538854698464778703795540858859767700241957783601153\"\n end)\n\n let b = of_int 7\n end\n\n module Make_tests (F : sig\n include Field_intf.S_unchecked\n\n val gen : t Quickcheck.Generator.t\n\n val b : t\n end) =\n struct\n module F = struct\n include F\n\n let constant = Fn.id\n end\n\n open F\n\n let params = Params.create (module F) { b }\n\n let curve_eqn u = (u * u * u) + params.b\n\n (* Filter the two points which cause the group-map to blow up. This\n is not an issue in practice because the points we feed into this function\n will be the output of poseidon, and thus (modeling poseidon as a random oracle)\n will not be either of those two points. *)\n let gen =\n Quickcheck.Generator.filter F.gen ~f:(fun t ->\n let t2 = t * t in\n let alpha_inv = (t2 + constant params.fu) * t2 in\n not (equal alpha_inv zero) )\n\n module M =\n Make (F) (F)\n (struct\n let params = params\n end)\n\n let%test_unit \"full map works\" =\n Quickcheck.test ~sexp_of:F.sexp_of_t gen ~f:(fun t ->\n let x, y = to_group (module F) ~params t in\n assert (equal (curve_eqn x) (y * y)) )\n end\n\n module T0 = Make_tests (Fp)\n end )\n","open Core_kernel\nopen Async_kernel\n\nlet autogen_path = \"/tmp/coda_cache_dir\"\n\nlet s3_install_path = \"/tmp/s3_cache_dir\"\n\nlet s3_keys_bucket_prefix =\n \"https://s3-us-west-2.amazonaws.com/snark-keys.o1test.net\"\n\nlet manual_install_path = \"/var/lib/coda\"\n\nlet brew_install_path = \"/usr/local/var/coda\"\n\nlet cache = []\n\nlet env_path = manual_install_path\n\nlet possible_paths base =\n List.map\n [ env_path\n ; brew_install_path\n ; s3_install_path\n ; autogen_path\n ; manual_install_path\n ] ~f:(fun d -> d ^ \"/\" ^ base)\n\nlet load_from_s3 _s3_bucket_prefix _s3_install_path ~logger:_ =\n Deferred.Or_error.fail (Error.createf \"Cannot load files from S3\")\n","(*\n\n This follows the approach of SvdW06 to construct a \"near injection\" from\n a field into an elliptic curve defined over that field. WB19 is also a useful\n reference that details several constructions which are more appropriate in other\n contexts.\n\n Fix an elliptic curve E given by y^2 = x^3 + ax + b over a field \"F\"\n Let f(x) = x^3 + ax + b.\n\n Define the variety V to be\n (x1, x2, x3, x4) : f(x1) f(x2) f(x3) = x4^2.\n\n By a not-too-hard we have a map `V -> E`. Thus, a map of type `F -> V` yields a\n map of type `F -> E` by composing.\n\n Our goal is to construct such a map of type `F -> V`. The paper SvdW06 constructs\n a family of such maps, defined by a collection of values which we'll term `params`.\n\n Define `params` to be the type of records of the form\n { u: F\n ; u_over_2: F\n ; projection_point: { z : F; y : F }\n ; conic_c: F\n ; a: F\n ; b: F }\n such that\n - a and b are the coefficients of our curve's defining equation.\n - u satisfies\n i. 0 <> 3/4 u^2 + a\n ii. 0 <> f(u)\n iii. -f(u) is not a square.\n - conic_c = 3/4 u^2 + a\n - {z; y} satisfy\n i. z^2 + conic_c * y^2 = -f(u)\n\n We will define a map of type `params -> (F -> V)`. Thus, fixing a choice of\n a value of type params, we obtain a map `F -> V` as desired.\n\nSvdW06: Shallue and van de Woestijne, \"Construction of rational points on elliptic curves over finite fields.\" Proc. ANTS 2006. https://works.bepress.com/andrew_shallue/1/download/\nWB19: Riad S. Wahby and Dan Boneh, Fast and simple constant-time hashing to the BLS12-381 elliptic curve. https://eprint.iacr.org/2019/403\n*)\n\n(* we have φ(t) : F -> S\n and φ1(λ) : S -> V with\n V(F) : f(x1)f(x2)f(x3) = x4^2,\n (f is y^2 = x^3 + Bx + C)) (note choice of constant names\n -- A is coeff of x^2 so A = 0 for us)\n\n To construct a rational point on V(F), the authors define\n the surface S(F) and the rational map φ1:S(F)→ V(F), which\n is invertible on its image [SvdW06, Lemma 6]:\n S(F) : y^2(u^2 + uv + v^2 + a) = −f(u)\n\n φ(t) : t → ( u, α(t)/β(t) - u/2, β(t) )\n φ1: (u, v, y) → ( v, −u − v, u + y^2,\n f(u + y^2)·(y^2 + uv + v^2 + ay)/y )\n*)\n\nopen Core_kernel\nmodule Field_intf = Field_intf\nmodule Bw19 = Bw19\n\nlet ( = ) = `Don't_use_polymorphic_compare\n\nlet _ = ( = )\n\nmodule Intf (F : sig\n type t\nend) =\nstruct\n module type S = sig\n val to_group : F.t -> F.t * F.t\n end\nend\n\nmodule type S = sig\n module Spec : sig\n type _ t [@@deriving bin_io]\n end\n\n module Params : sig\n type 'f t [@@deriving bin_io]\n\n val map : 'a t -> f:('a -> 'b) -> 'b t\n\n val spec : 'f t -> 'f Spec.t\n\n val create :\n (module Field_intf.S_unchecked with type t = 'f) -> 'f Spec.t -> 'f t\n end\n\n module Make\n (Constant : Field_intf.S) (F : sig\n include Field_intf.S\n\n val constant : Constant.t -> t\n end) (Params : sig\n val params : Constant.t Params.t\n end) : sig\n val potential_xs : F.t -> F.t * F.t * F.t\n end\n\n val to_group :\n (module Field_intf.S_unchecked with type t = 'f)\n -> params:'f Params.t\n -> 'f\n -> 'f * 'f\nend\n\nmodule Conic = struct\n type 'f t = { z : 'f; y : 'f } [@@deriving bin_io]\n\n let map { z; y } ~f = { z = f z; y = f y }\nend\n\nmodule S = struct\n (* S = S(u, v, y) : y^2(u^2 + uv + v^2 + a) = −f(u)\n from (12)\n *)\n type 'f t = { u : 'f; v : 'f; y : 'f }\nend\n\nmodule V = struct\n (* V = V(x1, x2, x3, x4) : f(x1)f(x2)f(x3) = x4^2\n from (8)\n *)\n type 'f t = 'f * 'f * 'f * 'f\nend\n\nmodule Spec = struct\n type 'f t = { a : 'f; b : 'f } [@@deriving fields, bin_io]\nend\n\nmodule Params = struct\n type 'f t =\n { u : 'f\n ; u_over_2 : 'f\n ; projection_point : 'f Conic.t\n ; conic_c : 'f\n ; spec : 'f Spec.t\n }\n [@@deriving fields, bin_io]\n\n let map { u; u_over_2; projection_point; conic_c; spec = { a; b } } ~f =\n { u = f u\n ; u_over_2 = f u_over_2\n ; projection_point = Conic.map ~f projection_point\n ; conic_c = f conic_c\n ; spec = { a = f a; b = f b }\n }\n\n (* A deterministic function for constructing a valid choice of parameters for a\n given field.\n\n We start by finding the first `u` satisfying the constraints described above,\n then find the first `y` satisyfing the condition described above. The other\n values are derived from these two choices*.\n\n *Actually we have one bit of freedom in choosing `z` as z = sqrt(conic_c y^2 - conic_d),\n since there are two square roots.\n *)\n\n let create (type t) (module F : Field_intf.S_unchecked with type t = t)\n ({ Spec.a; b } as spec) =\n let open F in\n let first_map f =\n let rec go i = match f i with Some x -> x | None -> go (i + one) in\n go zero\n in\n let first f = first_map (fun x -> Option.some_if (f x) x) in\n let three_fourths = of_int 3 / of_int 4 in\n let curve_eqn u = (u * u * u) + (a * u) + b in\n let u =\n first (fun u ->\n (* from (15), A = 0, B = Params.a *)\n let check = (three_fourths * u * u) + a in\n let fu = curve_eqn u in\n (not (equal check zero))\n && (not (equal fu zero))\n && not (is_square (negate fu))\n (* imeckler: I added this condition. It prevents the possibility of having\n a point (z, 0) on the conic, which is useful because in the map from the\n conic to S we divide by the \"y\" coordinate of the conic. It's not strictly\n necessary when we have a random input in a large field, but it is still nice to avoid the\n bad case in theory (and for the tests below with a small field). *) )\n in\n (* The coefficients defining the conic z^2 + c y^2 = d\n in (15). *)\n let conic_c = (three_fourths * u * u) + a in\n let conic_d = negate (curve_eqn u) in\n let projection_point =\n first_map (fun y ->\n let z2 = conic_d - (conic_c * y * y) in\n if F.is_square z2 then Some { Conic.z = F.sqrt z2; y } else None )\n in\n { u; u_over_2 = u / of_int 2; conic_c; projection_point; spec }\nend\n\nmodule Make\n (Constant : Field_intf.S) (F : sig\n include Field_intf.S\n\n val constant : Constant.t -> t\n end) (P : sig\n val params : Constant.t Params.t\n end) =\nstruct\n open F\n\n (* For a curve z^2 + c y^2 = d and a point (z0, y0) on the curve, there\n is one other point on the curve which is also on the line through (z0, y0)\n with slope t. This function returns that point. *)\n let field_to_conic t =\n let z0, y0 =\n ( constant P.params.projection_point.z\n , constant P.params.projection_point.y )\n in\n let ct = constant P.params.conic_c * t in\n let s = of_int 2 * ((ct * y0) + z0) / ((ct * t) + one) in\n { Conic.z = z0 - s; y = y0 - (s * t) }\n\n (* From (16) : φ(λ) : F → S : λ → ( u, α(λ)/β(λ) - u/2, β(λ) ) *)\n let conic_to_s { Conic.z; y } =\n { S.u = constant P.params.u\n ; v = (z / y) - constant P.params.u_over_2 (* From (16) *)\n ; y\n }\n\n (* This is here for explanatory purposes. See s_to_v_truncated. *)\n let _s_to_v { S.u; v; y } : _ V.t =\n let curve_eqn x =\n (x * x * x) + (constant P.params.spec.a * x) + constant P.params.spec.b\n in\n let h = (u * u) + (u * v) + (v * v) + constant P.params.spec.a in\n (v, negate (u + v), u + (y * y), curve_eqn (u + (y * y)) * h / y)\n\n (* from (13) *)\n\n (* We don't actually need to compute the final coordinate in V *)\n let s_to_v_truncated { S.u; v; y } = (v, negate (u + v), u + (y * y))\n\n let potential_xs =\n let ( @ ) = Fn.compose in\n s_to_v_truncated @ conic_to_s @ field_to_conic\nend\n\nlet to_group (type t) (module F : Field_intf.S_unchecked with type t = t)\n ~params t =\n let module M =\n Make\n (F)\n (struct\n include F\n\n let constant = Fn.id\n end)\n (struct\n let params = params\n end)\n in\n let { Spec.a; b } = params.spec in\n let try_decode x =\n let f x = F.((x * x * x) + (a * x) + b) in\n let y = f x in\n if F.is_square y then Some (x, F.sqrt y) else None\n in\n let x1, x2, x3 = M.potential_xs t in\n List.find_map [ x1; x2; x3 ] ~f:try_decode |> Option.value_exn\n\nlet%test_module \"test\" =\n ( module struct\n module Fp = struct\n include\n Snarkette.Fields.Make_fp\n (Snarkette.Nat)\n (struct\n let order = Snarkette.Nat.of_int 100003\n end)\n\n let a = of_int 1\n\n let b = of_int 3\n end\n\n module F13 = struct\n type t = int [@@deriving sexp]\n\n let p = 13\n\n let ( + ) x y = (x + y) mod p\n\n let ( * ) x y = x * y mod p\n\n let negate x = (p - x) mod p\n\n let ( - ) x y = (x - y + p) mod p\n\n let equal = Int.equal\n\n let ( / ) x y =\n let rec go i = if equal x (i * y) then i else go (i + 1) in\n if equal y 0 then failwith \"Divide by 0\" else go 1\n\n let sqrt' x =\n let rec go i =\n if Int.equal i p then None\n else if equal (i * i) x then Some i\n else go Int.(i + 1)\n in\n go 0\n\n let sqrt x = Option.value_exn (sqrt' x)\n\n let is_square x = Option.is_some (sqrt' x)\n\n let zero = 0\n\n let one = 1\n\n let of_int = Fn.id\n\n let gen = Int.gen_incl 0 Int.(p - 1)\n\n let a = 1\n\n let b = 3\n end\n\n module Make_tests (F : sig\n include Field_intf.S_unchecked\n\n val gen : t Quickcheck.Generator.t\n\n val a : t\n\n val b : t\n end) =\n struct\n module F = struct\n include F\n\n let constant = Fn.id\n end\n\n open F\n\n let params = Params.create (module F) { a; b }\n\n let curve_eqn u = (u * u * u) + (params.spec.a * u) + params.spec.b\n\n let conic_d =\n let open F in\n negate (curve_eqn params.u)\n\n let on_conic { Conic.z; y } =\n F.(equal ((z * z) + (params.conic_c * y * y)) conic_d)\n\n let on_s { S.u; v; y } =\n F.(equal conic_d (y * y * ((u * u) + (u * v) + (v * v) + a)))\n\n let on_v (x1, x2, x3, x4) =\n F.(equal (curve_eqn x1 * curve_eqn x2 * curve_eqn x3) (x4 * x4))\n\n (* Filter the two points which cause the group-map to blow up. This\n is not an issue in practice because the points we feed into this function\n will be the output of blake2s, and thus (modeling blake2s as a random oracle)\n will not be either of those two points. *)\n let gen =\n Quickcheck.Generator.filter F.gen ~f:(fun t ->\n not F.(equal ((params.conic_c * t * t) + one) zero) )\n\n module M =\n Make (F) (F)\n (struct\n let params = params\n end)\n\n let%test \"projection point well-formed\" = on_conic params.projection_point\n\n let%test_unit \"field-to-conic\" =\n Quickcheck.test ~sexp_of:F.sexp_of_t gen ~f:(fun t ->\n assert (on_conic (M.field_to_conic t)) )\n\n let%test_unit \"conic-to-S\" =\n let conic_gen =\n Quickcheck.Generator.filter_map F.gen ~f:(fun y ->\n let z2 = conic_d - (params.conic_c * y * y) in\n if is_square z2 then Some { Conic.z = sqrt z2; y } else None )\n in\n Quickcheck.test conic_gen ~f:(fun p -> assert (on_s (M.conic_to_s p)))\n\n let%test_unit \"field-to-S\" =\n Quickcheck.test ~sexp_of:F.sexp_of_t gen ~f:(fun t ->\n assert (on_s (Fn.compose M.conic_to_s M.field_to_conic t)) )\n\n (* Schwarz-zippel says if this tests succeeds once, then the probability that\n the implementation is correct is at least 1 - (D / field-size), where D is\n the total degree of the polynomial defining_equation_of_V(s_to_v(t)) which should\n be less than, say, 10. So, this test succeeding gives good evidence of the\n correctness of the implementation (assuming that the implementation is just a\n polynomial, which it is by parametricity!) *)\n let%test_unit \"field-to-V\" =\n Quickcheck.test ~sexp_of:F.sexp_of_t gen ~f:(fun t ->\n let s = M.conic_to_s (M.field_to_conic t) in\n assert (on_v (M._s_to_v s)) )\n\n let%test_unit \"full map works\" =\n Quickcheck.test ~sexp_of:F.sexp_of_t gen ~f:(fun t ->\n let x, y = to_group (module F) ~params t in\n assert (equal (curve_eqn x) (y * y)) )\n end\n\n module T0 = Make_tests (F13)\n module T1 = Make_tests (Fp)\n end )\n","(*\n * Copyright (c) 2006-2009 Citrix Systems Inc.\n * Copyright (c) 2010 Thomas Gazagnaire \n * Copyright (c) 2014-2016 Anil Madhavapeddy \n * Copyright (c) 2016 David Kaloper Meršinjak\n * Copyright (c) 2018 Romain Calascibetta \n *\n * Permission to use, copy, modify, and distribute this software for any\n * purpose with or without fee is hereby granted, provided that the above\n * copyright notice and this permission notice appear in all copies.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES\n * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF\n * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR\n * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES\n * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN\n * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF\n * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.\n *\n *)\n\ntype alphabet =\n { emap : int array\n ; dmap : int array }\n\ntype sub = string * int * int\n\nlet (//) x y =\n if y < 1 then raise Division_by_zero ;\n if x > 0 then 1 + ((x - 1) / y) else 0\n[@@inline]\n\nlet unsafe_get_uint8 t off = Char.code (String.unsafe_get t off)\nlet unsafe_set_uint8 t off v = Bytes.unsafe_set t off (Char.chr v)\nlet unsafe_set_uint16 = Unsafe.unsafe_set_uint16\n\nexternal unsafe_get_uint16 : string -> int -> int = \"%caml_string_get16u\" [@@noalloc]\nexternal swap16 : int -> int = \"%bswap16\" [@@noalloc]\n\nlet none = (-1)\n\n(* We mostly want to have an optional array for [dmap] (e.g. [int option\n array]). So we consider the [none] value as [-1]. *)\n\nlet make_alphabet alphabet =\n if String.length alphabet <> 64 then invalid_arg \"Length of alphabet must be 64\" ;\n if String.contains alphabet '=' then invalid_arg \"Alphabet can not contain padding character\" ;\n let emap = Array.init (String.length alphabet) (fun i -> Char.code (String.get alphabet i)) in\n let dmap = Array.make 256 none in\n String.iteri (fun idx chr -> Array.set dmap (Char.code chr) idx) alphabet ;\n { emap; dmap; }\n\nlet length_alphabet { emap; _ } = Array.length emap\nlet alphabet { emap; _ } = emap\n\nlet default_alphabet = make_alphabet \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\"\nlet uri_safe_alphabet = make_alphabet \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_\"\n\nlet unsafe_set_be_uint16 =\n if Sys.big_endian\n then fun t off v -> unsafe_set_uint16 t off v\n else fun t off v -> unsafe_set_uint16 t off (swap16 v)\n\n(* We make this exception to ensure to keep a control about which exception we\n can raise and avoid appearance of unknown exceptions like an ex-nihilo\n magic rabbit (or magic money?). *)\nexception Out_of_bounds\nexception Too_much_input\n\nlet get_uint8 t off =\n if off < 0 || off >= String.length t then raise Out_of_bounds ;\n unsafe_get_uint8 t off\n\nlet padding = int_of_char '='\n\nlet error_msgf fmt = Format.ksprintf (fun err -> Error (`Msg err)) fmt\n\nlet encode_sub pad { emap; _ } ?(off = 0) ?len input =\n let len = match len with\n | Some len -> len\n | None -> String.length input - off in\n\n if len < 0 || off < 0 || off > String.length input - len\n then error_msgf \"Invalid bounds\"\n else\n let n = len in\n let n' = n // 3 * 4 in\n let res = Bytes.create n' in\n\n let emap i = Array.unsafe_get emap i in\n\n let emit b1 b2 b3 i =\n unsafe_set_be_uint16 res i\n ((emap (b1 lsr 2 land 0x3f) lsl 8)\n lor (emap ((b1 lsl 4) lor (b2 lsr 4) land 0x3f))) ;\n unsafe_set_be_uint16 res (i + 2)\n ((emap ((b2 lsl 2) lor (b3 lsr 6) land 0x3f) lsl 8)\n lor (emap (b3 land 0x3f))) in\n\n let rec enc j i =\n if i = n then ()\n else if i = n - 1\n then emit (unsafe_get_uint8 input (off + i)) 0 0 j\n else if i = n - 2\n then emit (unsafe_get_uint8 input (off + i)) (unsafe_get_uint8 input (off + i + 1)) 0 j\n else\n (emit\n (unsafe_get_uint8 input (off + i))\n (unsafe_get_uint8 input (off + i + 1))\n (unsafe_get_uint8 input (off + i + 2))\n j ;\n enc (j + 4) (i + 3)) in\n\n let rec unsafe_fix = function\n | 0 -> ()\n | i -> unsafe_set_uint8 res (n' - i) padding ; unsafe_fix (i - 1) in\n\n enc 0 0 ;\n\n let pad_to_write = ((3 - n mod 3) mod 3) in\n\n if pad\n then begin unsafe_fix pad_to_write ; Ok (Bytes.unsafe_to_string res, 0, n') end\n else Ok (Bytes.unsafe_to_string res, 0, (n' - pad_to_write))\n(* [pad = false], we don't want to write them. *)\n\nlet encode ?(pad = true) ?(alphabet = default_alphabet) ?off ?len input =\n match encode_sub pad alphabet ?off ?len input with\n | Ok (res, off, len) -> Ok (String.sub res off len)\n | Error _ as err -> err\n\nlet encode_string ?pad ?alphabet input =\n match encode ?pad ?alphabet input with\n | Ok res -> res\n | Error _ -> assert false\n\nlet encode_sub ?(pad = true) ?(alphabet = default_alphabet) ?off ?len input =\n encode_sub pad alphabet ?off ?len input\n\nlet encode_exn ?pad ?alphabet ?off ?len input =\n match encode ?pad ?alphabet ?off ?len input with\n | Ok v -> v\n | Error (`Msg err) -> invalid_arg err\n\nlet decode_sub ?(pad = true) { dmap; _ } ?(off = 0) ?len input =\n let len = match len with\n | Some len -> len\n | None -> String.length input - off in\n\n if len < 0 || off < 0 || off > String.length input - len\n then error_msgf \"Invalid bounds\"\n else\n\n let n = (len // 4) * 4 in\n let n' = (n // 4) * 3 in\n let res = Bytes.create n' in\n let invalid_pad_overflow = pad in\n\n let get_uint8_or_padding =\n if pad then (fun t i -> if i >= len then raise Out_of_bounds ; get_uint8 t (off + i) )\n else (fun t i -> try if i < len then get_uint8 t (off + i) else padding with Out_of_bounds -> padding ) in\n\n let set_be_uint16 t off v =\n (* can not write 2 bytes. *)\n if off < 0 || off + 1 > Bytes.length t then ()\n (* can not write 1 byte but can write 1 byte *)\n else if off < 0 || off + 2 > Bytes.length t then unsafe_set_uint8 t off (v lsr 8)\n (* can write 2 bytes. *)\n else unsafe_set_be_uint16 t off v in\n\n let set_uint8 t off v =\n if off < 0 || off >= Bytes.length t then ()\n else unsafe_set_uint8 t off v in\n\n let emit a b c d j =\n let x = (a lsl 18) lor (b lsl 12) lor (c lsl 6) lor d in\n set_be_uint16 res j (x lsr 8) ;\n set_uint8 res (j + 2) (x land 0xff) in\n\n let dmap i =\n let x = Array.unsafe_get dmap i in\n if x = none then raise Not_found ; x in\n\n let only_padding pad idx =\n\n (* because we round length of [res] to the upper bound of how many\n characters we should have from [input], we got at this stage only padding\n characters and we need to delete them, so for each [====], we delete 3\n bytes. *)\n\n let pad = ref (pad + 3) in\n let idx = ref idx in\n\n while !idx + 4 < len do\n (* use [unsafe_get_uint16] instead [unsafe_get_uint32] to avoid allocation\n of [int32]. Of course, [3d3d3d3d] is [====]. *)\n if unsafe_get_uint16 input (off + !idx) <> 0x3d3d\n || unsafe_get_uint16 input (off + !idx + 2) <> 0x3d3d\n then raise Not_found ;\n (* We got something bad, should be a valid character according to\n [alphabet] but outside the scope. *)\n\n idx := !idx + 4 ;\n pad := !pad + 3 ;\n done ;\n while !idx < len do\n if unsafe_get_uint8 input (off + !idx) <> padding\n then raise Not_found ;\n\n incr idx ;\n done ; !pad in\n\n let rec dec j i =\n if i = n then 0\n else begin\n let (d, pad) =\n let x = get_uint8_or_padding input (i + 3) in\n try (dmap x, 0) with Not_found when x = padding -> (0, 1) in\n (* [Not_found] iff [x ∉ alphabet and x <> '='] can leak. *)\n let (c, pad) =\n let x = get_uint8_or_padding input (i + 2) in\n try (dmap x, pad) with Not_found when x = padding && pad = 1 -> (0, 2) in\n (* [Not_found] iff [x ∉ alphabet and x <> '='] can leak. *)\n let (b, pad) =\n let x = get_uint8_or_padding input (i + 1) in\n try (dmap x, pad) with Not_found when x = padding && pad = 2 -> (0, 3) in\n (* [Not_found] iff [x ∉ alphabet and x <> '='] can leak. *)\n let (a, pad) =\n let x = get_uint8_or_padding input i in\n try (dmap x, pad) with Not_found when x = padding && pad = 3 -> (0, 4) in\n (* [Not_found] iff [x ∉ alphabet and x <> '='] can leak. *)\n\n emit a b c d j ;\n\n if i + 4 = n\n (* end of input in anyway *)\n then match pad with\n | 0 ->\n 0\n | 4 ->\n (* assert (invalid_pad_overflow = false) ; *)\n 3\n (* [get_uint8] lies and if we get [4], that mean we got one or more (at\n most 4) padding character. In this situation, because we round length\n of [res] (see [n // 4]), we need to delete 3 bytes. *)\n | pad ->\n pad\n else match pad with\n | 0 -> dec (j + 3) (i + 4)\n | 4 ->\n (* assert (invalid_pad_overflow = false) ; *)\n only_padding 3 (i + 4)\n (* Same situation than above but we should get only more padding\n characters then. *)\n | pad ->\n if invalid_pad_overflow = true then raise Too_much_input ;\n only_padding pad (i + 4) end in\n\n match dec 0 0 with\n | 0 -> Ok (Bytes.unsafe_to_string res, 0, n')\n | pad -> Ok (Bytes.unsafe_to_string res, 0, (n' - pad))\n | exception Out_of_bounds -> error_msgf \"Wrong padding\"\n (* appear only when [pad = true] and when length of input is not a multiple of 4. *)\n | exception Not_found ->\n (* appear when one character of [input] ∉ [alphabet] and this character <> '=' *)\n error_msgf \"Malformed input\"\n | exception Too_much_input ->\n error_msgf \"Too much input\"\n\nlet decode ?pad ?(alphabet = default_alphabet) ?off ?len input =\n match decode_sub ?pad alphabet ?off ?len input with\n | Ok (res, off, len) -> Ok (String.sub res off len)\n | Error _ as err -> err\n\nlet decode_sub ?pad ?(alphabet = default_alphabet) ?off ?len input =\n decode_sub ?pad alphabet ?off ?len input\n\nlet decode_exn ?pad ?alphabet ?off ?len input =\n match decode ?pad ?alphabet ?off ?len input with\n | Ok res -> res\n | Error (`Msg err) -> invalid_arg err\n","open Core_kernel\n\nmodule Aux (Impl : Snarky_backendless.Snark_intf.Run) = struct\n open Impl\n\n let non_residue : Field.Constant.t Lazy.t =\n let open Field.Constant in\n let rec go i = if not (is_square i) then i else go (i + one) in\n lazy (go (of_int 2))\n\n let sqrt_exn x =\n let y =\n exists Field.typ ~compute:(fun () ->\n Field.Constant.sqrt (As_prover.read_var x) )\n in\n assert_square y x ; y\n\n (* let sqrt_flagged : Field.t -> Field.t * Boolean.var = *)\n let sqrt_flagged x =\n (*\n imeckler: I learned this trick from Dan Boneh\n\n m a known non residue\n\n exists is_square : bool, y.\n if is_square then assert y*y = x else assert y*y = m * x\n\n <=>\n\n assert (y*y = if is_square then x else m * x)\n *)\n let is_square =\n exists Boolean.typ ~compute:(fun () ->\n Field.Constant.is_square (As_prover.read_var x) )\n in\n let m = Lazy.force non_residue in\n (sqrt_exn (Field.if_ is_square ~then_:x ~else_:(Field.scale x m)), is_square)\nend\n\nlet wrap (type f) ((module Impl) : f Snarky_backendless.Snark0.m) ~potential_xs\n ~y_squared =\n let open Impl in\n let module A = Aux (Impl) in\n let open A in\n stage (fun x ->\n let x1, x2, x3 = potential_xs x in\n let y1, b1 = sqrt_flagged (y_squared ~x:x1)\n and y2, b2 = sqrt_flagged (y_squared ~x:x2)\n and y3, b3 = sqrt_flagged (y_squared ~x:x3) in\n Boolean.Assert.any [ b1; b2; b3 ] ;\n let x1_is_first = (b1 :> Field.t)\n and x2_is_first = (Boolean.((not b1) && b2) :> Field.t)\n and x3_is_first = (Boolean.((not b1) && (not b2) && b3) :> Field.t) in\n ( Field.((x1_is_first * x1) + (x2_is_first * x2) + (x3_is_first * x3))\n , Field.((x1_is_first * y1) + (x2_is_first * y2) + (x3_is_first * y3)) ) )\n\nmodule Make\n (M : Snarky_backendless.Snark_intf.Run) (P : sig\n val params : M.field Group_map.Params.t\n end) =\nstruct\n open P\n include Group_map.Make (M.Field.Constant) (M.Field) (P)\n open M\n\n let to_group =\n let { Group_map.Spec.a; b } = Group_map.Params.spec params in\n unstage\n (wrap\n (module M)\n ~potential_xs\n ~y_squared:Field.(fun ~x -> (x * x * x) + scale x a + constant b) )\nend\n","open Core_kernel\nmodule Params = Group_map.Params\n\nlet to_group (type t)\n (module F : Group_map.Field_intf.S_unchecked with type t = t) ~params t =\n let module M =\n Group_map.Make\n (F)\n (struct\n include F\n\n let constant = Fn.id\n end)\n (struct\n let params = params\n end)\n in\n let { Group_map.Spec.a; b } = Params.spec params in\n let try_decode x =\n let f x = F.((x * x * x) + (a * x) + b) in\n let y = f x in\n if F.is_square y then Some (x, F.sqrt y) else None\n in\n let x1, x2, x3 = M.potential_xs t in\n List.find_map [ x1; x2; x3 ] ~f:try_decode |> Option.value_exn\n\nmodule Checked = struct\n open Snarky_backendless\n\n let wrap = Checked_map.wrap\n\n let to_group (type f) (module M : Snark_intf.Run with type field = f) ~params\n t =\n let module G =\n Checked_map.Make\n (M)\n (struct\n let params = params\n end)\n in\n G.to_group t\nend\n","open Core_kernel\nopen Pickles_types\n\nmodule Constant = struct\n type t = int\nend\n\n(* TODO: Optimization(?) Have this have length n - 1 since the last one is\n determined by the remaining ones. *)\ntype ('f, 'n) t =\n ('f Snarky_backendless.Cvar.t Snarky_backendless.Boolean.t, 'n) Vector.t\n\nmodule T (Impl : Snarky_backendless.Snark_intf.Run) = struct\n type nonrec 'n t = (Impl.field, 'n) t\nend\n\nmodule Make (Impl : Snarky_backendless.Snark_intf.Run) = struct\n module Constant = Constant\n open Impl\n include T (Impl)\n\n let of_index i ~length =\n let v = Vector.init length ~f:(fun j -> Field.equal (Field.of_int j) i) in\n Boolean.Assert.any (Vector.to_list v) ;\n v\n\n let of_vector_unsafe = Fn.id\n\n let typ (n : 'n Nat.t) : ('n t, Constant.t) Typ.t =\n let (Typ typ) = Vector.typ Boolean.typ n in\n let typ : _ Typ.t =\n Typ\n { typ with\n check =\n (fun x ->\n Impl.Internal_Basic.Checked.bind (typ.check x) ~f:(fun () ->\n make_checked (fun () ->\n Boolean.Assert.exactly_one (Vector.to_list x) ) ) )\n }\n in\n Typ.transport typ\n ~there:(fun i -> Vector.init n ~f:(( = ) i))\n ~back:(fun v ->\n let i, _ =\n List.findi (Vector.to_list v) ~f:(fun _ b -> b) |> Option.value_exn\n in\n i )\nend\n","open Core_kernel\n\n[%%versioned\nmodule Stable = struct\n module V2 = struct\n type t = { h : Domain.Stable.V1.t }\n [@@deriving fields, sexp, compare, yojson]\n\n let to_latest = Fn.id\n end\nend]\n","open Core_kernel\nopen Pickles_types\n\nmodule T (Impl : Snarky_backendless.Snark_intf.Run) (N : Vector.Nat_intf) =\nstruct\n open Impl\n\n type t = Field.t\n\n let length = 64 * Nat.to_int N.n\n\n module Constant = Constant.Make (N)\n\n let typ : (Field.t, Constant.t) Typ.t =\n Typ.field\n |> Typ.transport\n ~there:(fun x -> Field.Constant.project (Constant.to_bits x))\n ~back:(fun x ->\n Constant.of_bits (List.take (Field.Constant.unpack x) length) )\nend\n","open Pickles_types\n\ntype 'f t = 'f Snarky_backendless.Cvar.t\n\nmodule Constant = Constant.Make (Nat.N2)\n\nmodule type S = sig\n module Impl : Snarky_backendless.Snark_intf.Run\n\n open Impl\n\n type nonrec t = field t\n\n module Constant : sig\n type t = Constant.t [@@deriving sexp_of]\n\n val to_bits : t -> bool list\n\n val of_bits : bool list -> t\n\n val dummy : t\n end\n\n val typ : (t, Constant.t) Typ.t\n\n val length : int\nend\n\nmodule Make (Impl : Snarky_backendless.Snark_intf.Run) :\n S with module Impl := Impl =\n Make.T (Impl) (Nat.N2)\n","open Pickles_types\nopen Core_kernel\nmodule Limbs = Nat.N4\n\nmodule Constant = struct\n include Limb_vector.Constant.Make (Limbs)\n\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n type t =\n Limb_vector.Constant.Hex64.Stable.V1.t Vector.Vector_4.Stable.V1.t\n [@@deriving compare, sexp, yojson, hash, equal]\n\n let to_latest = Fn.id\n end\n end]\n\n (* Force the typechecker to verify that these types are equal. *)\n let (_ : (t, Stable.Latest.t) Type_equal.t) = Type_equal.T\n\n open Backend\n\n let to_tick_field x = Tick.Field.of_bits (to_bits x)\n\n let to_tock_field x = Tock.Field.of_bits (to_bits x)\n\n let of_tick_field x = of_bits (Tick.Field.to_bits x)\nend\n\nmodule Make (Impl : Snarky_backendless.Snark_intf.Run) = struct\n open Impl\n\n type t = Field.t\n\n let to_bits = Field.choose_preimage_var ~length:Field.size_in_bits\n\n module Unsafe = struct\n let to_bits_unboolean x =\n with_label __LOC__ (fun () ->\n let length = Field.size_in_bits in\n let res =\n exists\n (Typ.list Boolean.typ_unchecked ~length)\n ~compute:As_prover.(fun () -> Field.Constant.unpack (read_var x))\n in\n Field.Assert.equal x (Field.project res) ;\n res )\n end\n\n let () = assert (Field.size_in_bits < 64 * Nat.to_int Limbs.n)\n\n module Constant = struct\n include Constant\n\n let to_bits x = List.take (to_bits x) Field.size_in_bits\n end\n\n let typ =\n Typ.transport Field.typ\n ~there:(Fn.compose Field.Constant.project Constant.to_bits)\n ~back:(Fn.compose Constant.of_bits Field.Constant.unpack)\nend\n","module D = Digest\nopen Core_kernel\nopen Pickles_types\nopen Hlist\nmodule Sc = Kimchi_backend_common.Scalar_challenge\n\ntype 'f impl = (module Snarky_backendless.Snark_intf.Run with type field = 'f)\n\ntype ('a, 'b, 'c) basic =\n | Unit : (unit, unit, < .. >) basic\n | Field\n : ('field1, 'field2, < field1 : 'field1 ; field2 : 'field2 ; .. >) basic\n | Bool : ('bool1, 'bool2, < bool1 : 'bool1 ; bool2 : 'bool2 ; .. >) basic\n | Digest\n : ( 'digest1\n , 'digest2\n , < digest1 : 'digest1 ; digest2 : 'digest2 ; .. > )\n basic\n | Challenge\n : ( 'challenge1\n , 'challenge2\n , < challenge1 : 'challenge1 ; challenge2 : 'challenge2 ; .. > )\n basic\n | Bulletproof_challenge\n : ( 'bp_chal1\n , 'bp_chal2\n , < bulletproof_challenge1 : 'bp_chal1\n ; bulletproof_challenge2 : 'bp_chal2\n ; .. > )\n basic\n | Branch_data\n : ( 'branch_data1\n , 'branch_data2\n , < branch_data1 : 'branch_data1 ; branch_data2 : 'branch_data2 ; .. >\n )\n basic\n\nmodule type Bool_intf = sig\n type var\n\n val true_ : var\n\n val false_ : var\nend\n\nmodule rec T : sig\n type (_, _, _) t =\n | B : ('a, 'b, 'env) basic -> ('a, 'b, 'env) t\n | Scalar :\n ('a, 'b, (< challenge1 : 'a ; challenge2 : 'b ; .. > as 'env)) basic\n -> ('a Sc.t, 'b Sc.t, 'env) t\n | Vector :\n ('t1, 't2, 'env) t * 'n Nat.t\n -> (('t1, 'n) Vector.t, ('t2, 'n) Vector.t, 'env) t\n | Array : ('t1, 't2, 'env) t * int -> ('t1 array, 't2 array, 'env) t\n | Struct :\n ('xs1, 'xs2, 'env) H2_1.T(T).t\n -> ('xs1 Hlist.HlistId.t, 'xs2 Hlist.HlistId.t, 'env) t\n | Opt :\n { inner : ('a1, 'a2, (< bool1 : bool ; bool2 : 'bool ; .. > as 'env)) t\n ; flag : Plonk_types.Opt.Flag.t\n ; dummy1 : 'a1\n ; dummy2 : 'a2\n ; bool : (module Bool_intf with type var = 'bool)\n }\n -> ('a1 option, ('a2, 'bool) Plonk_types.Opt.t, 'env) t\n | Opt_unflagged :\n { inner : ('a1, 'a2, (< bool1 : bool ; bool2 : 'bool ; .. > as 'env)) t\n ; flag : Plonk_types.Opt.Flag.t\n ; dummy1 : 'a1\n ; dummy2 : 'a2\n }\n -> ('a1 option, 'a2 option, 'env) t\n | Constant : 'a * ('a -> 'a -> unit) * ('a, 'b, 'env) t -> ('a, 'b, 'env) t\nend =\n T\n\ntype ('scalar, 'env) pack =\n { pack : 'a 'b. ('a, 'b, 'env) basic -> 'a option -> 'b -> 'scalar array }\n\nlet rec pack :\n type t v env.\n zero:'scalar\n -> one:'scalar\n -> ('scalar, env) pack\n -> (t, v, env) T.t\n -> t option\n -> v\n -> 'scalar array =\n fun ~zero ~one p spec t_constant_opt t ->\n match spec with\n | B spec ->\n p.pack spec t_constant_opt t\n | Scalar chal ->\n let t_constant_opt =\n Option.map t_constant_opt ~f:(fun { Sc.inner = x } -> x)\n in\n let { Sc.inner = t } = t in\n p.pack chal t_constant_opt t\n | Vector (spec, _) ->\n let t_constant_opt = Option.map ~f:Vector.to_array t_constant_opt in\n let t = Vector.to_array t in\n pack ~zero ~one p (Array (spec, Array.length t)) t_constant_opt t\n | Struct [] ->\n [||]\n | Struct (spec :: specs) ->\n let (hd :: tl) = t in\n let hd_constant_opt, tl_constant_opt =\n match t_constant_opt with\n | None ->\n (None, None)\n | Some (hd :: tl) ->\n (Some hd, Some tl)\n in\n let hd = pack ~zero ~one p spec hd_constant_opt hd in\n Array.append hd (pack ~zero ~one p (Struct specs) tl_constant_opt tl)\n | Array (spec, _) ->\n Array.concat_mapi t ~f:(fun i t ->\n let t_constant_opt =\n Option.map t_constant_opt ~f:(fun t_const -> t_const.(i))\n in\n pack ~zero ~one p spec t_constant_opt t )\n | Opt { inner; dummy1; dummy2; flag = _; bool = _ } -> (\n match t with\n | None ->\n let t_constant_opt = Option.map t_constant_opt ~f:(fun _ -> dummy1) in\n Array.append [| zero |]\n (pack ~zero ~one p inner t_constant_opt dummy2)\n | Some x ->\n let t_constant_opt =\n Option.map ~f:(fun x -> Option.value_exn x) t_constant_opt\n in\n Array.append [| one |] (pack ~zero ~one p inner t_constant_opt x)\n | Maybe (b, x) ->\n let b_constant_opt = Option.map ~f:Option.is_some t_constant_opt in\n let x_constant_opt =\n Option.map ~f:(Option.value ~default:dummy1) t_constant_opt\n in\n Array.append\n (p.pack Bool b_constant_opt b)\n (pack ~zero ~one p inner x_constant_opt x) )\n | Opt_unflagged { inner; dummy1; dummy2; flag = _ } -> (\n match t with\n | None ->\n let t_constant_opt = Option.map t_constant_opt ~f:(fun _ -> dummy1) in\n pack ~zero ~one p inner t_constant_opt dummy2\n | Some x ->\n let t_constant_opt =\n Option.map ~f:(fun x -> Option.value_exn x) t_constant_opt\n in\n pack ~zero ~one p inner t_constant_opt x )\n | Constant (x, _, inner) ->\n pack ~zero ~one p inner (Some x) t\n\ntype ('f, 'env) typ =\n { typ :\n 'var 'value.\n ('value, 'var, 'env) basic -> ('var, 'value, 'f) Snarky_backendless.Typ.t\n }\n\nlet rec typ :\n type f var value env.\n (f, env) typ\n -> (value, var, env) T.t\n -> (var, value, f) Snarky_backendless.Typ.t =\n let open Snarky_backendless.Typ in\n fun t spec ->\n match[@warning \"-45\"] spec with\n | B spec ->\n t.typ spec\n | Scalar chal ->\n Sc.typ (t.typ chal)\n | Vector (spec, n) ->\n Vector.typ (typ t spec) n\n | Array (spec, n) ->\n array ~length:n (typ t spec)\n | Struct [] ->\n let open Hlist.HlistId in\n transport (unit ()) ~there:(fun [] -> ()) ~back:(fun () -> [])\n |> transport_var ~there:(fun [] -> ()) ~back:(fun () -> [])\n | Struct (spec :: specs) ->\n let open Hlist.HlistId in\n tuple2 (typ t spec) (typ t (Struct specs))\n |> transport\n ~there:(fun (x :: xs) -> (x, xs))\n ~back:(fun (x, xs) -> x :: xs)\n |> transport_var\n ~there:(fun (x :: xs) -> (x, xs))\n ~back:(fun (x, xs) -> x :: xs)\n | Opt { inner; flag; dummy1; dummy2; bool = (module B) } ->\n let bool = typ t (B Bool) in\n let open B in\n (* Always use the same \"maybe\" layout which is a boolean and then the value *)\n Plonk_types.Opt.constant_layout_typ bool flag ~dummy:dummy1\n ~dummy_var:dummy2 ~true_ ~false_ (typ t inner)\n | Opt_unflagged { inner; flag; dummy1; dummy2 } -> (\n match flag with\n | Plonk_types.Opt.Flag.No ->\n let open Snarky_backendless.Typ in\n unit ()\n |> Snarky_backendless.Typ.transport\n ~there:(function Some _ -> assert false | None -> ())\n ~back:(fun () -> None)\n |> Snarky_backendless.Typ.transport_var\n ~there:(function Some _ -> assert false | None -> ())\n ~back:(fun _ -> None)\n | Plonk_types.Opt.Flag.(Yes | Maybe) ->\n typ t inner\n |> Snarky_backendless.Typ.transport\n ~there:(function Some x -> x | None -> dummy1)\n ~back:(fun x -> Some x)\n |> Snarky_backendless.Typ.transport_var\n ~there:(function Some x -> x | None -> dummy2)\n ~back:(fun x -> Some x) )\n | Constant (x, assert_eq, spec) ->\n let (Typ typ) = typ t spec in\n let constant_var =\n let fields, aux = typ.value_to_fields x in\n let fields =\n Array.map fields ~f:(fun x -> Snarky_backendless.Cvar.Constant x)\n in\n typ.var_of_fields (fields, aux)\n in\n let open Snarky_backendless.Typ in\n unit ()\n |> transport ~there:(fun y -> assert_eq x y) ~back:(fun () -> x)\n |> transport_var ~there:(fun _ -> ()) ~back:(fun () -> constant_var)\n\nmodule ETyp = struct\n type ('var, 'value, 'f) t =\n | T :\n ('inner, 'value, 'f) Snarky_backendless.Typ.t\n * ('inner -> 'var)\n * ('var -> 'inner)\n -> ('var, 'value, 'f) t\nend\n\ntype ('f, 'env) etyp =\n { etyp : 'var 'value. ('value, 'var, 'env) basic -> ('var, 'value, 'f) ETyp.t\n }\n\nlet rec etyp :\n type f var value env.\n (f, env) etyp -> (value, var, env) T.t -> (var, value, f) ETyp.t =\n let open Snarky_backendless.Typ in\n fun e spec ->\n match[@warning \"-45\"] spec with\n | B spec ->\n e.etyp spec\n | Scalar chal ->\n let (T (typ, f, f_inv)) = e.etyp chal in\n T (Sc.typ typ, Sc.map ~f, Sc.map ~f:f_inv)\n | Vector (spec, n) ->\n let (T (typ, f, f_inv)) = etyp e spec in\n T (Vector.typ typ n, Vector.map ~f, Vector.map ~f:f_inv)\n | Array (spec, n) ->\n let (T (typ, f, f_inv)) = etyp e spec in\n T (array ~length:n typ, Array.map ~f, Array.map ~f:f_inv)\n | Struct [] ->\n let open Hlist.HlistId in\n let there [] = () in\n let back () = [] in\n T\n ( transport (unit ()) ~there ~back |> transport_var ~there ~back\n , Fn.id\n , Fn.id )\n | Struct (spec :: specs) ->\n let open Hlist.HlistId in\n let (T (t1, f1, f1_inv)) = etyp e spec in\n let (T (t2, f2, f2_inv)) = etyp e (Struct specs) in\n T\n ( tuple2 t1 t2\n |> transport\n ~there:(fun (x :: xs) -> (x, xs))\n ~back:(fun (x, xs) -> x :: xs)\n , (fun (x, xs) -> f1 x :: f2 xs)\n , fun (x :: xs) -> (f1_inv x, f2_inv xs) )\n | Opt { inner; flag; dummy1; dummy2; bool = (module B) } ->\n let (T (bool, f_bool, f_bool')) = etyp e (B Bool) in\n let (T (a, f_a, f_a')) = etyp e inner in\n let opt_map ~f1 ~f2 (x : _ Plonk_types.Opt.t) : _ Plonk_types.Opt.t =\n match x with\n | None ->\n None\n | Some x ->\n Some (f1 x)\n | Maybe (b, x) ->\n Maybe (f2 b, f1 x)\n in\n let f = opt_map ~f1:f_a ~f2:f_bool in\n let f' = opt_map ~f1:f_a' ~f2:f_bool' in\n T\n ( Plonk_types.Opt.constant_layout_typ ~dummy:dummy1\n ~dummy_var:(f_a' dummy2) ~true_:(f_bool' B.true_)\n ~false_:(f_bool' B.false_) bool flag a\n , f\n , f' )\n | Opt_unflagged { inner; dummy1; dummy2; flag = _ } ->\n let (T (typ, f, f_inv)) = etyp e inner in\n let f x = Some (f x) in\n let f_inv = function None -> f_inv dummy2 | Some x -> f_inv x in\n let typ =\n typ\n |> Snarky_backendless.Typ.transport\n ~there:(Option.value ~default:dummy1) ~back:(fun x -> Some x)\n in\n T (typ, f, f_inv)\n | Constant (x, _assert_eq, spec) ->\n let (T (Typ typ, f, f')) = etyp e spec in\n let constant_var =\n let fields, aux = typ.value_to_fields x in\n let fields =\n Array.map fields ~f:(fun x -> Snarky_backendless.Cvar.Constant x)\n in\n typ.var_of_fields (fields, aux)\n in\n (* We skip any constraints that would be added here, but we *do* use\n the underlying [Typ.t] to make sure that we allocate public inputs\n correctly.\n *)\n T\n ( Typ\n { typ with\n check =\n (fun _ -> Snarky_backendless.Checked_runner.Simple.return ())\n }\n , (fun _ -> f constant_var)\n , f' )\n\nmodule Common (Impl : Snarky_backendless.Snark_intf.Run) = struct\n module Digest = D.Make (Impl)\n module Challenge = Limb_vector.Challenge.Make (Impl)\n open Impl\n\n module Env = struct\n type ('other_field, 'other_field_var, 'a) t =\n < field1 : 'other_field\n ; field2 : 'other_field_var\n ; bool1 : bool\n ; bool2 : Boolean.var\n ; digest1 : Digest.Constant.t\n ; digest2 : Digest.t\n ; challenge1 : Challenge.Constant.t\n ; challenge2 : Challenge.t\n ; bulletproof_challenge1 :\n Challenge.Constant.t Sc.t Bulletproof_challenge.t\n ; bulletproof_challenge2 : Challenge.t Sc.t Bulletproof_challenge.t\n ; branch_data1 : Branch_data.t\n ; branch_data2 : Impl.field Branch_data.Checked.t\n ; .. >\n as\n 'a\n end\nend\n\nlet pack_basic (type field other_field other_field_var)\n ((module Impl) : field impl) =\n let open Impl in\n let module C = Common (Impl) in\n let open C in\n let pack :\n type a b.\n (a, b, ((other_field, other_field_var, 'e) Env.t as 'e)) basic\n -> a option\n -> b\n -> [ `Field of other_field_var | `Packed_bits of Field.t * int ] array =\n fun basic x_constant_opt x ->\n (* TODO *)\n ignore x_constant_opt ;\n match basic with\n | Unit ->\n [||]\n | Field ->\n [| `Field x |]\n | Bool ->\n [| `Packed_bits ((x :> Field.t), 1) |]\n | Digest ->\n [| `Packed_bits (x, Field.size_in_bits) |]\n | Challenge ->\n [| `Packed_bits (x, Challenge.length) |]\n | Branch_data ->\n [| `Packed_bits\n ( Branch_data.Checked.pack (module Impl) x\n , Branch_data.length_in_bits )\n |]\n | Bulletproof_challenge ->\n let { Sc.inner = pre } = Bulletproof_challenge.pack x in\n [| `Packed_bits (pre, Challenge.length) |]\n in\n { pack }\n\nlet pack (type f) ((module Impl) as impl : f impl) t =\n let open Impl in\n pack (pack_basic impl) t\n ~zero:(`Packed_bits (Field.zero, 1))\n ~one:(`Packed_bits (Field.one, 1))\n None\n\nlet typ_basic (type field other_field other_field_var)\n (module Impl : Snarky_backendless.Snark_intf.Run with type field = field)\n ~assert_16_bits (field : (other_field_var, other_field) Impl.Typ.t) =\n let open Impl in\n let module C = Common (Impl) in\n let open C in\n let typ :\n type a b.\n (a, b, ((other_field, other_field_var, 'e) Env.t as 'e)) basic\n -> (b, a) Impl.Typ.t =\n fun basic ->\n match basic with\n | Unit ->\n Typ.unit\n | Field ->\n field\n | Bool ->\n Boolean.typ\n | Branch_data ->\n Branch_data.typ (module Impl) ~assert_16_bits\n | Digest ->\n Digest.typ\n | Challenge ->\n Challenge.typ\n | Bulletproof_challenge ->\n Bulletproof_challenge.typ Challenge.typ\n in\n { typ }\n\nlet typ ~assert_16_bits impl field t =\n typ (typ_basic ~assert_16_bits impl field) t\n\nlet packed_typ_basic (type field other_field other_field_var)\n (module Impl : Snarky_backendless.Snark_intf.Run with type field = field)\n (field : (other_field_var, other_field, field) ETyp.t) =\n let open Impl in\n let module Digest = D.Make (Impl) in\n let module Challenge = Limb_vector.Challenge.Make (Impl) in\n let module Env = struct\n type ('other_field, 'other_field_var, 'a) t =\n < field1 : 'other_field\n ; field2 : 'other_field_var\n ; bool1 : bool\n ; bool2 : Boolean.var\n ; digest1 : Digest.Constant.t\n ; digest2 : Field.t\n ; challenge1 : Challenge.Constant.t\n ; challenge2 : (* Challenge.t *) Field.t\n ; bulletproof_challenge1 :\n Challenge.Constant.t Sc.t Bulletproof_challenge.t\n ; bulletproof_challenge2 : Field.t Sc.t Bulletproof_challenge.t\n ; branch_data1 : Branch_data.t\n ; branch_data2 : Field.t\n ; .. >\n as\n 'a\n end in\n let etyp :\n type a b.\n (a, b, ((other_field, other_field_var, 'e) Env.t as 'e)) basic\n -> (b, a, field) ETyp.t = function\n | Unit ->\n T (Typ.unit, Fn.id, Fn.id)\n | Field ->\n field\n | Bool ->\n T (Boolean.typ, Fn.id, Fn.id)\n | Digest ->\n T (Digest.typ, Fn.id, Fn.id)\n | Challenge ->\n T (Challenge.typ, Fn.id, Fn.id)\n | Branch_data ->\n T (Branch_data.packed_typ (module Impl), Fn.id, Fn.id)\n | Bulletproof_challenge ->\n let typ =\n let there bp_challenge =\n let { Sc.inner = pre } = Bulletproof_challenge.pack bp_challenge in\n pre\n in\n let back pre = Bulletproof_challenge.unpack { Sc.inner = pre } in\n Typ.transport Challenge.typ ~there ~back\n |> Typ.transport_var ~there ~back\n in\n T (typ, Fn.id, Fn.id)\n in\n { etyp }\n\nlet packed_typ impl field t = etyp (packed_typ_basic impl field) t\n","open Core_kernel\nopen Pickles_types\nmodule Domain = Plonk_checks.Domain\n\nmodule Make (Impl : Snarky_backendless.Snark_intf.Run) = struct\n open Impl\n\n type ('a, 'n) t = 'n One_hot_vector.T(Impl).t * ('a, 'n) Vector.t\n\n (* TODO: Use version in common. *)\n let seal (x : Impl.Field.t) : Impl.Field.t =\n let open Impl in\n match Field.to_constant_and_terms x with\n | None, [ (x, i) ] when Field.Constant.(equal x one) ->\n Snarky_backendless.Cvar.Var i\n | Some c, [] ->\n Field.constant c\n | _ ->\n let y = exists Field.typ ~compute:As_prover.(fun () -> read_var x) in\n Field.Assert.equal x y ; y\n\n let mask (type n) (bits : n One_hot_vector.T(Impl).t) xs =\n with_label __LOC__ (fun () ->\n Vector.map\n (Vector.zip (bits :> (Boolean.var, n) Vector.t) xs)\n ~f:(fun (b, x) -> Field.((b :> t) * x))\n |> Vector.fold ~init:Field.zero ~f:Field.( + ) )\n\n let choose : type a n. (a, n) t -> f:(a -> Field.t) -> Field.t =\n fun (bits, xs) ~f -> mask bits (Vector.map xs ~f)\n\n module Degree_bound = struct\n type nonrec 'n t = (int, 'n) t\n\n let shifted_pow ~crs_max_degree t x =\n let pow = Field.(Pcs_batch.pow ~one ~mul) in\n choose t ~f:(fun deg ->\n let d = deg mod crs_max_degree in\n pow x (crs_max_degree - d) )\n end\n\n module Domain = struct\n let num_shifts = Nat.to_int Pickles_types.Plonk_types.Permuts.n\n\n (** Compute the 'shifts' used by the kimchi permutation argument.\n\n These values are selected deterministically-randomly to appear outside\n of the domain, so that every choice of [i] and [shift] results in a\n distinct value for [shift * domain_generator ^ i].\n\n Note that, for each different domain size, we attempt to use the same\n [shifts], and only sample different ones if the shifts are already a\n member of the domain (ie. there exists some [i] such that\n [shift = domain_generator ^ i]). This ensures that the invariant above\n is satisfied.\n Optimisation: since the shifts for the domains that we use in practise\n are all the same -- none of them have 2-adic order < largest domain\n size -- we can hard-code the shifts instead of using a one-hot mask,\n and this function adds no constraints to the circuit.\n *)\n let shifts (type n) ((which, log2s) : (int, n) t)\n ~(shifts : log2_size:int -> Field.Constant.t array) :\n Field.t Pickles_types.Plonk_types.Shifts.t =\n let all_shifts = Vector.map log2s ~f:(fun d -> shifts ~log2_size:d) in\n match all_shifts with\n | [] ->\n failwith \"Pseudo.Domain.shifts: no domains were given\"\n | shifts :: other_shiftss ->\n (* Runtime check that the shifts across all domains are consistent.\n The optimisation below will not work if this is not true; if the\n domain size or the shifts are modified such that this becomes\n false, [disabled_not_the_same] can be set to true to enable\n dynamic selection within the circuit.\n *)\n let all_the_same =\n Vector.for_all other_shiftss\n ~f:(Array.for_all2_exn ~f:Field.Constant.equal shifts)\n in\n (* Set to true if we do not want to allow dynamic selection of the\n shifts at runtime.\n This is possible because of the optimisation outlined in the\n doc-comment above, but this option and the original code is left\n here in case we transition to a larger domain size that uses\n different shifts than those for smaller domains.\n *)\n let disabled_not_the_same = true in\n if all_the_same then Array.map ~f:Field.constant shifts\n else if disabled_not_the_same then\n failwith \"Pseudo.Domain.shifts: found variable shifts\"\n else\n let get_ith_shift i =\n mask which\n (Vector.map all_shifts ~f:(fun a -> Field.constant a.(i)))\n in\n Array.init num_shifts ~f:get_ith_shift\n\n let generator (type n) ((which, log2s) : (int, n) t) ~domain_generator =\n mask which (Vector.map log2s ~f:(fun d -> domain_generator ~log2_size:d))\n\n type nonrec 'n t = (Domain.t, 'n) t\n\n let to_domain ~shifts:s ~domain_generator (type n) (t : n t) :\n Field.t Plonk_checks.plonk_domain =\n let log2_sizes = Vector.map (snd t) ~f:Domain.log2_size in\n let shifts = shifts (fst t, log2_sizes) ~shifts:s in\n let generator = generator (fst t, log2_sizes) ~domain_generator in\n let max_log2 =\n let _, ds = t in\n List.fold (Vector.to_list ds) ~init:0 ~f:(fun acc d ->\n Int.max acc (Domain.log2_size d) )\n in\n object\n method shifts = shifts\n\n method generator = generator\n\n method vanishing_polynomial x =\n let pow2_pows =\n let res = Array.create ~len:(max_log2 + 1) x in\n for i = 1 to max_log2 do\n res.(i) <- Field.square res.(i - 1)\n done ;\n res\n in\n let open Field in\n seal (choose t ~f:(fun d -> pow2_pows.(Domain.log2_size d)) - one)\n end\n end\nend\n","(* version_bytes.ml -- version bytes for Base58Check encodings *)\n\ntype t = char\n\n(** Base58Check version bytes for individual types\n Each of the following values should be distinct\n*)\n\nlet coinbase : t = '\\x01'\n\nlet secret_box_byteswr : t = '\\x02'\n\nlet fee_transfer_single : t = '\\x03'\n\nlet frontier_hash : t = '\\x04'\n\nlet ledger_hash : t = '\\x05'\n\nlet lite_precomputed : t = '\\x06'\n\nlet proof : t = '\\x0A'\n\nlet random_oracle_base : t = '\\x0B'\n\nlet receipt_chain_hash : t = '\\x0C'\n\nlet epoch_seed : t = '\\x0D'\n\nlet staged_ledger_hash_aux_hash : t = '\\x0E'\n\nlet staged_ledger_hash_pending_coinbase_aux : t = '\\x0F'\n\nlet state_hash : t = '\\x10'\n\nlet state_body_hash : t = '\\x11'\n\n(* don't use \\x12, which was for pre-Berkeley hard fork transaction hashes *)\n\n(* used only to deserialize transaction ids, pre-Berkeley hard fork *)\nlet signed_command_v1 : t = '\\x13'\n\nlet user_command_memo : t = '\\x14'\n\nlet vrf_truncated_output : t = '\\x15'\n\nlet web_pipe : t = '\\x16'\n\nlet coinbase_stack_data : t = '\\x17'\n\nlet coinbase_stack_hash : t = '\\x18'\n\nlet pending_coinbase_hash_builder : t = '\\x19'\n\nlet zkapp_command : t = '\\x1A'\n\nlet verification_key : t = '\\x1B'\n\nlet token_id_key : t = '\\x1C'\n\nlet transaction_hash : t = '\\x1D'\n\n(** used for testing only *)\n\nlet ledger_test_hash : t = '\\x30'\n\n(** The following version bytes are non-sequential; existing\n user key infrastructure depends on them. don't change them!\n*)\n\nlet private_key : t = '\\x5A'\n\nlet non_zero_curve_point_compressed : t = '\\xCB'\n\nlet signature : t = '\\x9A'\n","open Core_kernel\n\nmodule type Iso_intf = sig\n type original\n\n type standardized [@@deriving yojson]\n\n val encode : original -> standardized\n\n val decode : standardized -> original\nend\n\nmodule type S = sig\n type t\n\n val to_yojson : t -> Yojson.Safe.t\n\n val of_yojson : Yojson.Safe.t -> t Ppx_deriving_yojson_runtime.error_or\nend\n\nmodule Make (Iso : Iso_intf) = struct\n let to_yojson t = Iso.encode t |> Iso.standardized_to_yojson\n\n let of_yojson json =\n Result.map ~f:Iso.decode (Iso.standardized_of_yojson json)\n\n module For_tests = struct\n let check_encoding t ~equal =\n match of_yojson (to_yojson t) with\n | Ok result ->\n equal t result\n | Error e ->\n failwithf !\"%s\" e ()\n end\nend\n\nmodule For_tests = struct\n let check_encoding (type t) (module M : S with type t = t) t ~equal =\n match M.of_yojson (M.to_yojson t) with\n | Ok result ->\n equal t result\n | Error e ->\n failwithf !\"%s\" e ()\nend\n\nmodule Make_of_int (Iso : sig\n type t\n\n val to_int : t -> int\n\n val of_int : int -> t\nend) =\nMake (struct\n type original = Iso.t\n\n type standardized = int [@@deriving yojson]\n\n let encode = Iso.to_int\n\n let decode = Iso.of_int\nend)\n\nmodule Make_of_string (Iso : sig\n type t\n\n val to_string : t -> string\n\n val of_string : string -> t\nend) =\nMake (struct\n type original = Iso.t\n\n type standardized = string [@@deriving yojson]\n\n let encode = Iso.to_string\n\n let decode = Iso.of_string\nend)\n\nmodule Make_base58_check (T : sig\n type t [@@deriving bin_io]\n\n val description : string\n\n val version_byte : char\nend) =\nstruct\n module Base58_check = Base58_check.Make (T)\n\n let to_base58_check t = Base58_check.encode (Binable.to_string (module T) t)\n\n let of_base58_check s =\n let open Or_error.Let_syntax in\n let%bind decoded = Base58_check.decode s in\n Or_error.try_with (fun () -> Binable.of_string (module T) decoded)\n\n let of_base58_check_exn s = of_base58_check s |> Or_error.ok_exn\n\n let to_yojson t = `String (to_base58_check t)\n\n let of_yojson = function\n | `String s ->\n Result.map_error (of_base58_check s) ~f:Error.to_string_hum\n | json ->\n failwithf \"of_yojson: expect JSON string, got %s\"\n (Yojson.Safe.to_string json)\n ()\nend\n\nmodule type Base58_check_base_intf = sig\n type t\n\n (** Base58Check decoding *)\n val of_base58_check : string -> t Base.Or_error.t\n\n (** Base58Check decoding *)\n val of_base58_check_exn : string -> t\nend\n\nmodule type Base58_check_intf = sig\n type t\n\n (** explicit Base58Check encoding *)\n val to_base58_check : t -> string\n\n include Base58_check_base_intf with type t := t\nend\n\nmodule Make_base64 (T : sig\n type t [@@deriving bin_io]\nend) =\nstruct\n let to_base64 (t : T.t) : string =\n Binable.to_string (module T) t\n |> (* raises only on errors from invalid optional arguments *)\n Base64.encode_exn\n\n let of_base64 b64 : T.t Or_error.t =\n match Base64.decode b64 with\n | Ok s -> (\n try Ok (Binable.of_string (module T) s)\n with Bin_prot.Common.Read_error _ as e ->\n Error (Error.of_exn ~backtrace:`Get e) )\n | Error (`Msg msg) ->\n Error (Error.of_string msg)\nend\n\nmodule type Base64_intf = sig\n type t\n\n val to_base64 : t -> string\n\n val of_base64 : string -> t Or_error.t\nend\n","open Snarky_backendless\nopen Webkit_trace_event\nopen Webkit_trace_event.Output.JSON\nopen Yojson\n\nlet to_string ?buf ?len ?std events =\n to_string ?buf ?len ?std @@ json_of_events events\n\nlet to_channel ?buf ?len ?std out_channel events =\n to_channel ?buf ?len ?std out_channel @@ json_of_events events\n\nlet to_file ?buf ?len ?std filename events =\n let oc = open_out filename in\n to_channel ?buf ?len ?std oc events ;\n close_out oc\n\nmodule Constraints (Snarky_backendless : Snark_intf.Basic) = struct\n (** Create flamechart events for Snarky_backendless constraints.\n\n This creates a chart of labels, associating each label with a 'timestamp'\n equal to the number of constraints at its start and end. *)\n open Snarky_backendless\n\n (** Generate a flamechart for the labels of a checked computation. *)\n let log ?weight (t : unit -> _ Checked.t) : events =\n let rev_events = ref [] in\n let _total =\n constraint_count ?weight t ~log:(fun ?(start = false) label count ->\n rev_events :=\n create_event label\n ~phase:(if start then Measure_start else Measure_end)\n ~timestamp:count\n :: !rev_events )\n in\n List.rev !rev_events\n\n (** Same as [log], but for functions which take [Var.t] arguments.\n Use [apply_args] to apply the corresponding OCaml-typed arguments.\n For example: {[\nopen Snarky_backendless\nmodule Snark = Snark.Make (Backends.Bn128.Default)\nopen Snark\nmodule Constraints = Snarky_log.Constraints (Snark)\n\nlet () = Snarky_log.to_file \"output.json\" @@\n Constraints.log_func ~input:Data_spec.[Field.typ; Field.typ] Field.Checked.mul\n ~apply_args:(fun mul -> mul Field.one Field.one)\n }] *)\n let log_func ~input_typ ~return_typ ~(apply_args : 'k_value -> _ Checked.t)\n (f : 'k_var) : events =\n let f' = conv (fun c -> c) input_typ return_typ f in\n log (fun () -> apply_args f')\nend\n","module B = Bigint\nmodule H_list = Snarky_backendless.H_list\nmodule Challenge = Limb_vector.Challenge\nmodule Types = Composition_types\nmodule Digest = Types.Digest\nmodule Spec = Types.Spec\nmodule Branch_data = Composition_types.Branch_data\nmodule Step_bp_vec = Types.Step_bp_vec\nmodule Nvector = Types.Nvector\nmodule Bulletproof_challenge = Types.Bulletproof_challenge\nmodule Domain = Pickles_base.Domain\nmodule Domains = Pickles_base.Domains\nmodule Scalar_challenge = Kimchi_backend_common.Scalar_challenge\n\nlet debug = false\n","open Core_kernel\nopen Pickles_types\n\nlet rec absorb :\n type a g1 g1_opt f scalar.\n absorb_field:(f -> unit)\n -> absorb_scalar:(scalar -> unit)\n -> g1_to_field_elements:(g1 -> f list)\n -> mask_g1_opt:(g1_opt -> g1)\n -> ( a\n , < scalar : scalar ; g1 : g1 ; g1_opt : g1_opt ; base_field : f > )\n Type.t\n -> a\n -> unit =\n fun ~absorb_field ~absorb_scalar ~g1_to_field_elements ~mask_g1_opt ty t ->\n match ty with\n | Type.PC ->\n List.iter ~f:absorb_field (g1_to_field_elements t)\n | Type.Field ->\n absorb_field t\n | Type.Scalar ->\n absorb_scalar t\n | Type.Without_degree_bound ->\n Array.iter\n ~f:(Fn.compose (List.iter ~f:absorb_field) g1_to_field_elements)\n t\n | Type.With_degree_bound ->\n let Pickles_types.Plonk_types.Poly_comm.With_degree_bound.\n { unshifted; shifted } =\n t\n in\n let absorb x =\n absorb ~absorb_field ~absorb_scalar ~g1_to_field_elements ~mask_g1_opt\n Type.PC (mask_g1_opt x)\n in\n Array.iter unshifted ~f:absorb ;\n absorb shifted\n | ty1 :: ty2 ->\n let absorb t =\n absorb t ~absorb_field ~absorb_scalar ~g1_to_field_elements ~mask_g1_opt\n in\n let t1, t2 = t in\n absorb ty1 t1 ; absorb ty2 t2\n\n(** [ones_vector (module I) ~first_zero n] returns a vector of booleans of\n length n which is all ones until position [first_zero], at which it is zero,\n and zero thereafter. *)\nlet ones_vector :\n type f n.\n first_zero:f Snarky_backendless.Cvar.t\n -> (module Snarky_backendless.Snark_intf.Run with type field = f)\n -> n Nat.t\n -> (f Snarky_backendless.Cvar.t Snarky_backendless.Boolean.t, n) Vector.t =\n fun ~first_zero (module Impl) n ->\n let open Impl in\n let rec go :\n type m. Boolean.var -> int -> m Nat.t -> (Boolean.var, m) Vector.t =\n fun value i m ->\n match[@warning \"-45\"] m with\n | Pickles_types.Nat.Z ->\n Pickles_types.Vector.[]\n | Pickles_types.Nat.S m ->\n let value =\n Boolean.(value && not (Field.equal first_zero (Field.of_int i)))\n in\n Pickles_types.Vector.(value :: go value (i + 1) m)\n in\n go Boolean.true_ 0 n\n\nlet seal (type f)\n (module Impl : Snarky_backendless.Snark_intf.Run with type field = f)\n (x : Impl.Field.t) : Impl.Field.t =\n let open Impl in\n match Field.to_constant_and_terms x with\n | None, [ (x, i) ] when Field.Constant.(equal x one) ->\n Snarky_backendless.Cvar.Var i\n | Some c, [] ->\n Field.constant c\n | _ ->\n let y = exists Field.typ ~compute:As_prover.(fun () -> read_var x) in\n Field.Assert.equal x y ; y\n\nlet lowest_128_bits (type f) ~constrain_low_bits ~assert_128_bits\n (module Impl : Snarky_backendless.Snark_intf.Run with type field = f) x =\n let open Impl in\n let pow2 =\n (* 2 ^ n *)\n let rec pow2 x i =\n if i = 0 then x else pow2 Field.Constant.(x + x) (i - 1)\n in\n fun n -> pow2 Field.Constant.one n\n in\n let lo, hi =\n exists\n Typ.(field * field)\n ~compute:(fun () ->\n let lo, hi =\n Field.Constant.unpack (As_prover.read_var x)\n |> Fn.flip List.split_n 128\n in\n (Field.Constant.project lo, Field.Constant.project hi) )\n in\n assert_128_bits hi ;\n if constrain_low_bits then assert_128_bits lo ;\n Field.Assert.equal x Field.(lo + scale hi (pow2 128)) ;\n lo\n","module SC = Scalar_challenge\n\ntype t = Import.Challenge.Constant.t Import.Scalar_challenge.t\n\nmodule Wrap_inner_curve = struct\n let base : Backend.Tock.Field.t = Pasta_bindings.Vesta.endo_base ()\n\n let scalar : Backend.Tick.Field.t = Pasta_bindings.Vesta.endo_scalar ()\n\n let to_field (t : t) : Backend.Tick.Field.t =\n SC.to_field_constant (module Backend.Tick.Field) ~endo:scalar t\nend\n\nmodule Step_inner_curve = struct\n let base : Backend.Tick.Field.t = Pasta_bindings.Pallas.endo_base ()\n\n let scalar : Backend.Tock.Field.t = Pasta_bindings.Pallas.endo_scalar ()\n\n let to_field (t : t) : Backend.Tock.Field.t =\n SC.to_field_constant (module Backend.Tock.Field) ~endo:scalar t\nend\n","open Core_kernel\nopen Pickles_types\nopen Import\nopen Backend\n\nmodule Max_degree = struct\n let step_log2 = Nat.to_int Backend.Tick.Rounds.n\n\n let step = 1 lsl step_log2\n\n let wrap_log2 = Nat.to_int Backend.Tock.Rounds.n\n\n let _wrap = 1 lsl wrap_log2\nend\n\nlet tick_shifts, tock_shifts =\n let mk g =\n let f =\n Memo.general ~cache_size_bound:20 ~hashable:Int.hashable (fun log2_size ->\n g log2_size )\n in\n fun ~log2_size -> f log2_size\n in\n ( mk Kimchi_bindings.Protocol.VerifierIndex.Fp.shifts\n , mk Kimchi_bindings.Protocol.VerifierIndex.Fq.shifts )\n\nlet wrap_domains ~proofs_verified =\n let h =\n match proofs_verified with 0 -> 13 | 1 -> 14 | 2 -> 15 | _ -> assert false\n in\n { Domains.h = Domain.Pow_2_roots_of_unity h }\n\nlet actual_wrap_domain_size ~log_2_domain_size =\n let d =\n match log_2_domain_size with\n | 13 ->\n 0\n | 14 ->\n 1\n | 15 ->\n 2\n | _ ->\n assert false\n in\n Pickles_base.Proofs_verified.of_int d\n\nlet hash_messages_for_next_step_proof ~app_state\n (t : _ Types.Step.Proof_state.Messages_for_next_step_proof.t) =\n let g (x, y) = [ x; y ] in\n Tick_field_sponge.digest Tick_field_sponge.params\n (Types.Step.Proof_state.Messages_for_next_step_proof.to_field_elements t ~g\n ~comm:(fun (x : Tock.Curve.Affine.t) -> Array.of_list (g x))\n ~app_state )\n\nlet dlog_pcs_batch (type nat proofs_verified total)\n ((without_degree_bound, _pi) :\n total Nat.t * (proofs_verified, nat, total) Nat.Adds.t ) =\n Pcs_batch.create ~without_degree_bound ~with_degree_bound:[]\n\nlet when_profiling profiling default =\n match Option.map (Sys.getenv_opt \"PICKLES_PROFILING\") ~f:String.lowercase with\n | None | Some (\"0\" | \"false\") ->\n default\n | Some _ ->\n profiling\n\nlet time lab f =\n when_profiling\n (fun () ->\n let start = Time.now () in\n let x = f () in\n let stop = Time.now () in\n printf \"%s: %s\\n%!\" lab (Time.Span.to_string_hum (Time.diff stop start)) ;\n x )\n f ()\n\nlet bits_to_bytes bits =\n let byte_of_bits bs =\n List.foldi bs ~init:0 ~f:(fun i acc b ->\n if b then acc lor (1 lsl i) else acc )\n |> Char.of_int_exn\n in\n List.map (List.groupi bits ~break:(fun i _ _ -> i mod 8 = 0)) ~f:byte_of_bits\n |> String.of_char_list\n\nlet group_map m ~a ~b =\n let params = Group_map.Params.create m { a; b } in\n stage (fun x -> Group_map.to_group m ~params x)\n\nmodule Shifts = struct\n let tock2 : Backend.Tock.Field.t Shifted_value.Type2.Shift.t =\n Shifted_value.Type2.Shift.create (module Backend.Tock.Field)\n\n let tick1 : Backend.Tick.Field.t Shifted_value.Type1.Shift.t =\n Shifted_value.Type1.Shift.create (module Backend.Tick.Field)\nend\n\nmodule Lookup_parameters = struct\n let tick_zero : _ Composition_types.Zero_values.t =\n Composition_types.Zero_values.\n { value =\n { challenge = Challenge.Constant.zero\n ; scalar =\n Shifted_value.Type2.Shifted_value Impls.Wrap.Field.Constant.zero\n }\n ; var =\n { challenge = Impls.Step.Field.zero\n ; scalar =\n Shifted_value.Type2.Shifted_value\n (Impls.Step.Field.zero, Impls.Step.Boolean.false_)\n }\n }\n\n let tock_zero : _ Composition_types.Zero_values.t =\n Composition_types.Zero_values.\n { value =\n { challenge = Challenge.Constant.zero\n ; scalar =\n Shifted_value.Type2.Shifted_value Impls.Wrap.Field.Constant.zero\n }\n ; var =\n { challenge = Impls.Wrap.Field.zero\n ; scalar = Shifted_value.Type2.Shifted_value Impls.Wrap.Field.zero\n }\n }\nend\n\nlet finite_exn : 'a Kimchi_types.or_infinity -> 'a * 'a = function\n | Kimchi_types.Finite (x, y) ->\n (x, y)\n | Kimchi_types.Infinity ->\n invalid_arg \"finite_exn\"\n\nlet or_infinite_conv : ('a * 'a) Or_infinity.t -> 'a Kimchi_types.or_infinity =\n function\n | Finite (x, y) ->\n Finite (x, y)\n | Infinity ->\n Infinity\n\nmodule Ipa = struct\n open Backend\n\n (* TODO: Make all this completely generic over backend *)\n\n let compute_challenge ~endo_to_field _ c = endo_to_field c\n\n let compute_challenges ~endo_to_field field chals =\n Vector.map chals ~f:(fun prechallenge ->\n Bulletproof_challenge.pack prechallenge\n |> compute_challenge field ~endo_to_field )\n\n module Wrap = struct\n let field =\n (module Tock.Field : Kimchi_backend.Field.S with type t = Tock.Field.t)\n\n let endo_to_field = Endo.Step_inner_curve.to_field\n\n let compute_challenge c = compute_challenge field ~endo_to_field c\n\n let compute_challenges cs = compute_challenges field ~endo_to_field cs\n\n let compute_sg chals =\n let comm =\n Kimchi_bindings.Protocol.SRS.Fq.b_poly_commitment\n (Backend.Tock.Keypair.load_urs ())\n (Pickles_types.Vector.to_array (compute_challenges chals))\n in\n comm.unshifted.(0) |> finite_exn\n end\n\n module Step = struct\n let field =\n (module Tick.Field : Kimchi_backend.Field.S with type t = Tick.Field.t)\n\n let endo_to_field = Endo.Wrap_inner_curve.to_field\n\n let compute_challenge c = compute_challenge field ~endo_to_field c\n\n let compute_challenges cs = compute_challenges field ~endo_to_field cs\n\n let compute_sg chals =\n let comm =\n Kimchi_bindings.Protocol.SRS.Fp.b_poly_commitment\n (Backend.Tick.Keypair.load_urs ())\n (Pickles_types.Vector.to_array (compute_challenges chals))\n in\n comm.unshifted.(0) |> finite_exn\n\n let accumulator_check comm_chals =\n let chals =\n Array.concat\n @@ List.map comm_chals ~f:(fun (_, chals) -> Vector.to_array chals)\n in\n let comms =\n Array.of_list_map comm_chals ~f:(fun (comm, _) ->\n Or_infinity.Finite comm )\n in\n let urs = Backend.Tick.Keypair.load_urs () in\n Promise.run_in_thread (fun () ->\n Kimchi_bindings.Protocol.SRS.Fp.batch_accumulator_check urs\n (Array.map comms ~f:or_infinite_conv)\n chals )\n end\nend\n\nlet tock_unpadded_public_input_of_statement prev_statement =\n let input =\n let (T (typ, _conv, _conv_inv)) = Impls.Wrap.input () in\n Impls.Wrap.generate_public_input typ prev_statement\n in\n List.init\n (Backend.Tock.Field.Vector.length input)\n ~f:(Backend.Tock.Field.Vector.get input)\n\nlet tock_public_input_of_statement s = tock_unpadded_public_input_of_statement s\n\nlet tick_public_input_of_statement ~max_proofs_verified ~feature_flags\n (prev_statement : _ Types.Step.Statement.t) =\n let input =\n let (T (input, _conv, _conv_inv)) =\n Impls.Step.input ~proofs_verified:max_proofs_verified\n ~wrap_rounds:Tock.Rounds.n ~feature_flags\n in\n Impls.Step.generate_public_input input prev_statement\n in\n List.init\n (Backend.Tick.Field.Vector.length input)\n ~f:(Backend.Tick.Field.Vector.get input)\n\nlet ft_comm ~add:( + ) ~scale ~endoscale:_ ~negate\n ~verification_key:(m : _ Plonk_verification_key_evals.t) ~alpha:_\n ~(plonk : _ Types.Wrap.Proof_state.Deferred_values.Plonk.In_circuit.t)\n ~t_comm =\n let ( * ) x g = scale g x in\n let _, [ sigma_comm_last ] =\n Vector.split m.sigma_comm (snd (Plonk_types.Permuts_minus_1.add Nat.N1.n))\n in\n let f_comm = List.reduce_exn ~f:( + ) [ plonk.perm * sigma_comm_last ] in\n let chunked_t_comm =\n let n = Array.length t_comm in\n let res = ref t_comm.(n - 1) in\n for i = n - 2 downto 0 do\n res := t_comm.(i) + scale !res plonk.zeta_to_srs_length\n done ;\n !res\n in\n f_comm + chunked_t_comm\n + negate (scale chunked_t_comm plonk.zeta_to_domain_size)\n\nlet combined_evaluation (type f)\n (module Impl : Snarky_backendless.Snark_intf.Run with type field = f)\n ~(xi : Impl.Field.t) (without_degree_bound : _ list) =\n let open Impl in\n let open Field in\n let mul_and_add ~(acc : Field.t) ~(xi : Field.t)\n (fx : (Field.t, Boolean.var) Plonk_types.Opt.t) : Field.t =\n match fx with\n | None ->\n acc\n | Some fx ->\n fx + (xi * acc)\n | Maybe (b, fx) ->\n Field.if_ b ~then_:(fx + (xi * acc)) ~else_:acc\n in\n with_label __LOC__ (fun () ->\n Pcs_batch.combine_split_evaluations ~mul_and_add\n ~init:(function\n | Some x ->\n x\n | None ->\n Field.zero\n | Maybe (b, x) ->\n (b :> Field.t) * x )\n ~xi without_degree_bound )\n","open Core_kernel\nmodule Js = Js_of_ocaml.Js\nmodule Backend = Kimchi_backend.Pasta.Vesta_based_plonk\nmodule Impl = Pickles.Impls.Step\nmodule Field = Impl.Field\nmodule Boolean = Impl.Boolean\nmodule As_prover = Impl.As_prover\nmodule Typ = Impl.Typ\n\n(* light-weight wrapper around snarky-ml core *)\n\nlet typ (size_in_fields : int) = Typ.array ~length:size_in_fields Field.typ\n\nlet exists (size_in_fields : int) (compute : unit -> Field.Constant.t array) =\n Impl.exists (typ size_in_fields) ~compute\n\nlet exists_var (compute : unit -> Field.Constant.t) =\n Impl.exists Field.typ ~compute\n\nmodule Run = struct\n let as_prover = Impl.as_prover\n\n let in_prover_block () = As_prover.in_prover_block () |> Js.bool\n\n let run_and_check (f : unit -> unit) =\n try\n Impl.run_and_check_exn (fun () ->\n f () ;\n fun () -> () )\n with exn -> Util.raise_exn exn\n\n let run_unchecked (f : unit -> unit) =\n try\n Impl.run_and_check_exn (fun () ->\n Snarky_backendless.Snark0.set_eval_constraints false ;\n f () ;\n Snarky_backendless.Snark0.set_eval_constraints true ;\n fun () -> () )\n with exn -> Util.raise_exn exn\n\n let constraint_system (main : unit -> unit) =\n let cs =\n Impl.constraint_system ~input_typ:Impl.Typ.unit ~return_typ:Impl.Typ.unit\n (fun () -> main)\n in\n object%js\n val rows = Backend.R1CS_constraint_system.get_rows_len cs\n\n val digest =\n Backend.R1CS_constraint_system.digest cs |> Md5.to_hex |> Js.string\n\n val json =\n Backend.R1CS_constraint_system.to_json cs\n |> Js.string |> Util.json_parse\n end\nend\n\nmodule Field' = struct\n (** add x, y to get a new AST node Add(x, y); handles if x, y are constants *)\n let add x y = Field.add x y\n\n (** scale x by a constant to get a new AST node Scale(c, x); handles if x is a constant; handles c=0,1 *)\n let scale c x = Field.scale x c\n\n (** witnesses z = x*y and constrains it with [assert_r1cs]; handles constants *)\n let mul x y = Field.mul x y\n\n (** evaluates a CVar by unfolding the AST and reading Vars from a list of public input + aux values *)\n let read_var (x : Field.t) = As_prover.read_var x\n\n (** x === y without handling of constants *)\n let assert_equal x y = Impl.assert_ (Impl.Constraint.equal x y)\n\n (** x*y === z without handling of constants *)\n let assert_mul x y z = Impl.assert_ (Impl.Constraint.r1cs x y z)\n\n (** x*x === y without handling of constants *)\n let assert_square x y = Impl.assert_ (Impl.Constraint.square x y)\n\n (** x*x === x without handling of constants *)\n let assert_boolean x = Impl.assert_ (Impl.Constraint.boolean x)\n\n (** check x < y and x <= y.\n this is used in all comparisons, including with assert *)\n let compare (bit_length : int) x y =\n let ({ less; less_or_equal } : Field.comparison_result) =\n Field.compare ~bit_length x y\n in\n (less, less_or_equal)\n\n let to_bits (length : int) x =\n Field.choose_preimage_var ~length x |> Array.of_list\n\n let from_bits bits = Array.to_list bits |> Field.project\n\n (** returns x truncated to the lowest [16 * length_div_16] bits\n => can be used to assert that x fits in [16 * length_div_16] bits.\n\n more efficient than [to_bits] because it uses the [EC_endoscalar] gate;\n does 16 bits per row (vs 1 bits per row that you can do with generic gates).\n *)\n let truncate_to_bits16 (length_div_16 : int) x =\n let _a, _b, x0 =\n Pickles.Scalar_challenge.to_field_checked' ~num_bits:(length_div_16 * 16)\n (module Impl)\n { inner = x }\n in\n x0\n\n (* can be implemented with Field.to_constant_and_terms *)\n let seal x = Pickles.Util.seal (module Impl) x\n\n let to_constant_and_terms x = Field.to_constant_and_terms x\nend\n\nmodule Bool = struct\n let not x = Boolean.not x\n\n let and_ x y = Boolean.(x &&& y)\n\n let or_ x y = Boolean.(x ||| y)\n\n let assert_equal x y = Boolean.Assert.(x = y)\n\n let equals x y = Boolean.equal x y\nend\n\nmodule Group = struct\n let ec_add p1 p2 p3 inf same_x slope inf_z x21_inv =\n let open Impl in\n with_label \"Elliptic Curve Addition\" (fun () ->\n assert_\n { annotation = Some __LOC__\n ; basic =\n Kimchi_backend_common.Plonk_constraint_system.Plonk_constraint.T\n (EC_add_complete\n { p1; p2; p3; inf; same_x; slope; inf_z; x21_inv } )\n } ;\n p3 )\n\n let scale p (scalar_bits : Boolean.var array) =\n Pickles.Step_main_inputs.Ops.scale_fast_msb_bits p\n (Shifted_value scalar_bits)\nend\n\nmodule Circuit = struct\n module Main = struct\n let of_js (main : Field.t array -> unit) =\n let main' public_input () = main public_input in\n main'\n end\n\n let compile main public_input_size =\n let input_typ = typ public_input_size in\n let return_typ = Impl.Typ.unit in\n let cs = Impl.constraint_system ~input_typ ~return_typ (Main.of_js main) in\n Impl.Keypair.generate ~prev_challenges:0 cs\n\n let prove main public_input_size public_input keypair =\n let pk = Impl.Keypair.pk keypair in\n let input_typ = typ public_input_size in\n let return_typ = Impl.Typ.unit in\n Impl.generate_witness_conv ~input_typ ~return_typ\n ~f:(fun { Impl.Proof_inputs.auxiliary_inputs; public_inputs } () ->\n Backend.Proof.create pk ~auxiliary:auxiliary_inputs\n ~primary:public_inputs )\n (Main.of_js main) public_input\n\n let verify public_input proof vk =\n let public_input_vec = Backend.Field.Vector.create () in\n Array.iter public_input ~f:(fun x ->\n Backend.Field.Vector.emplace_back public_input_vec x ) ;\n Backend.Proof.verify proof vk public_input_vec |> Js.bool\n\n module Keypair = struct\n let get_vk t = Impl.Keypair.vk t\n\n external prover_to_json :\n Kimchi_bindings.Protocol.Index.Fp.t -> Js.js_string Js.t\n = \"prover_to_json\"\n\n let get_cs_json t =\n (Impl.Keypair.pk t).index |> prover_to_json |> Util.json_parse\n end\nend\n\nmodule Poseidon = struct\n let update (state : Field.t Random_oracle.State.t) (input : Field.t array) :\n Field.t Random_oracle.State.t =\n Random_oracle.Checked.update ~state input\n\n let hash_to_group (xs : Field.t array) =\n let input = Random_oracle.Checked.hash xs in\n Snark_params.Group_map.Checked.to_group input\n\n (* sponge *)\n\n let to_unchecked (x : Field.t) =\n match x with Constant y -> y | y -> As_prover.read_var y\n\n module Poseidon_sponge_checked =\n Sponge.Make_sponge (Pickles.Step_main_inputs.Sponge.Permutation)\n module Poseidon_sponge =\n Sponge.Make_sponge (Sponge.Poseidon (Pickles.Tick_field_sponge.Inputs))\n\n let sponge_params_checked =\n Sponge.Params.(\n map pasta_p_kimchi\n ~f:(Fn.compose Impl.Field.constant Impl.Field.Constant.of_string))\n\n let sponge_params =\n Sponge.Params.(map pasta_p_kimchi ~f:Impl.Field.Constant.of_string)\n\n type sponge =\n | Checked of Poseidon_sponge_checked.t\n | Unchecked of Poseidon_sponge.t\n\n (* returns a \"sponge\" that stays opaque to JS *)\n let sponge_create (is_checked : bool Js.t) : sponge =\n if Js.to_bool is_checked then\n Checked (Poseidon_sponge_checked.create ?init:None sponge_params_checked)\n else Unchecked (Poseidon_sponge.create ?init:None sponge_params)\n\n let sponge_absorb (sponge : sponge) (field : Field.t) : unit =\n match sponge with\n | Checked s ->\n Poseidon_sponge_checked.absorb s field\n | Unchecked s ->\n Poseidon_sponge.absorb s (to_unchecked @@ field)\n\n let sponge_squeeze (sponge : sponge) : Field.t =\n match sponge with\n | Checked s ->\n Poseidon_sponge_checked.squeeze s\n | Unchecked s ->\n Poseidon_sponge.squeeze s |> Impl.Field.constant\nend\n\nlet snarky =\n object%js\n method exists = exists\n\n method existsVar = exists_var\n\n val run =\n let open Run in\n object%js\n method asProver = as_prover\n\n val inProverBlock = in_prover_block\n\n method runAndCheck = run_and_check\n\n method runUnchecked = run_unchecked\n\n method constraintSystem = constraint_system\n end\n\n val field =\n let open Field' in\n object%js\n method add = add\n\n method scale = scale\n\n method mul = mul\n\n method readVar = read_var\n\n method assertEqual = assert_equal\n\n method assertMul = assert_mul\n\n method assertSquare = assert_square\n\n method assertBoolean = assert_boolean\n\n method compare = compare\n\n method toBits = to_bits\n\n method fromBits = from_bits\n\n method truncateToBits16 = truncate_to_bits16\n\n method seal = seal\n\n method toConstantAndTerms = to_constant_and_terms\n end\n\n val bool =\n object%js\n method not = Bool.not\n\n method and_ = Bool.and_\n\n method or_ = Bool.or_\n\n method assertEqual = Bool.assert_equal\n\n method equals = Bool.equals\n end\n\n val group =\n object%js\n method ecadd = Group.ec_add\n\n method scale = Group.scale\n end\n\n val circuit =\n object%js\n method compile = Circuit.compile\n\n method prove = Circuit.prove\n\n method verify = Circuit.verify\n\n val keypair =\n object%js\n method getVerificationKey = Circuit.Keypair.get_vk\n\n method getConstraintSystemJSON = Circuit.Keypair.get_cs_json\n end\n end\n\n val poseidon =\n object%js\n method update = Poseidon.update\n\n method hashToGroup = Poseidon.hash_to_group\n\n val sponge =\n object%js\n method create = Poseidon.sponge_create\n\n method absorb = Poseidon.sponge_absorb\n\n method squeeze = Poseidon.sponge_squeeze\n end\n end\n end\n","module D = Composition_types.Digest\nopen Core_kernel\n\nmodule Rounds = struct\n let rounds_full = 55\n\n let initial_ark = false\n\n let rounds_partial = 0\nend\n\nlet high_entropy_bits = 128\n\nmodule type S = sig\n module Inputs : sig\n include module type of Rounds\n\n module Field : Kimchi_backend_common.Field.S\n\n type field := Field.t\n\n val to_the_alpha : field -> field\n\n val alpha : int\n\n module Operations : Sponge.Intf.Operations with type Field.t = field\n end\n\n type field := Inputs.Field.t\n\n (* The name does not really reflect the behavior *and* is somewhat confusing w.r.t\n Inputs.Field. This is almost Sponge.Intf.Sponge *)\n module Field : sig\n type f := Sponge.Poseidon(Inputs).Field.t\n\n type params := f Sponge.Params.t\n\n type state := f Sponge.State.t\n\n type t = f Sponge.t (* TODO: Make this type abstract *)\n\n val create : ?init:state -> params -> t\n\n val make :\n state:state -> params:params -> sponge_state:Sponge.sponge_state -> t\n\n val absorb : t -> f -> unit\n\n val squeeze : t -> f\n\n val copy : t -> t\n\n val state : t -> state\n end\n\n (* TODO: Resuce module types of Sponge.Intf.Sponge *)\n module Bits : sig\n type t\n\n val create : ?init:field Sponge.State.t -> field Sponge.Params.t -> t\n\n val absorb : t -> field -> unit\n\n val squeeze : t -> length:int -> bool list\n\n val copy : t -> t\n\n val state : t -> field Sponge.State.t\n\n val squeeze_field : t -> field\n end\n\n val digest :\n field Sponge.Params.t\n -> Inputs.Field.t Core_kernel.Array.t\n -> (int64, Composition_types.Digest.Limbs.n) Pickles_types.Vector.t\nend\n\nmodule Make (Field : Kimchi_backend.Field.S) :\n S with module Inputs.Field = Field = struct\n module Inputs = struct\n include Rounds\n module Field = Field\n\n let alpha = 7\n\n (* x^7 *)\n let to_the_alpha x =\n (* square |> mul x |> square |> mul x *)\n (* 7 = 1 + 2 (1 + 2) *)\n let open Field in\n let res = square x in\n res *= x ;\n (* x^3 *)\n Mutable.square res ;\n (* x^6 *)\n res *= x ;\n (* x^7 *)\n res\n\n module Operations = struct\n module Field = Field\n\n let add_assign ~state i x = Field.(state.(i) += x)\n\n let apply_affine_map (matrix, constants) v =\n let dotv row =\n Array.reduce_exn (Array.map2_exn row v ~f:Field.( * )) ~f:Field.( + )\n in\n let res = Array.map matrix ~f:dotv in\n for i = 0 to Array.length res - 1 do\n Field.(res.(i) += constants.(i))\n done ;\n res\n\n let copy a = Array.map a ~f:(fun x -> Field.(x + zero))\n end\n end\n\n module Field = Sponge.Make_sponge (Sponge.Poseidon (Inputs))\n\n module Bits =\n Sponge.Bit_sponge.Make\n (Bool)\n (struct\n include Inputs.Field\n\n let high_entropy_bits = high_entropy_bits\n\n let finalize_discarded = ignore\n end)\n (Inputs.Field)\n (Field)\n\n let digest params elts =\n let sponge = Bits.create params in\n Array.iter elts ~f:(Bits.absorb sponge) ;\n Bits.squeeze_field sponge |> Inputs.Field.to_bits |> D.Constant.of_bits\nend\n\nmodule Test\n (Impl : Snarky_backendless.Snark_intf.Run)\n (S_constant : Sponge.Intf.Sponge\n with module Field := Impl.Field.Constant\n and module State := Sponge.State\n and type input := Impl.field\n and type digest := Impl.field)\n (S_checked : Sponge.Intf.Sponge\n with module Field := Impl.Field\n and module State := Sponge.State\n and type input := Impl.Field.t\n and type digest := Impl.Field.t) =\nstruct\n open Impl\n\n let test params : unit =\n let n = 10 in\n let a = Array.init n ~f:(fun _ -> Field.Constant.random ()) in\n Impl.Internal_Basic.Test.test_equal ~sexp_of_t:Field.Constant.sexp_of_t\n ~equal:Field.Constant.equal\n (Typ.array ~length:n Field.typ)\n Field.typ\n (fun a ->\n make_checked (fun () ->\n let s =\n S_checked.create (Sponge.Params.map ~f:Field.constant params)\n in\n Array.iter a ~f:(S_checked.absorb s) ;\n S_checked.squeeze s ) )\n (fun a ->\n let s = S_constant.create params in\n Array.iter a ~f:(S_constant.absorb s) ;\n S_constant.squeeze s )\n a\nend\n","include Make_sponge.Make (Backend.Tick.Field)\n\nlet params =\n (* HACK *)\n Sponge.Params.(\n let testbit n i = Bigint.(equal (shift_right n i land one) one) in\n map pasta_p_kimchi ~f:(fun s ->\n Backend.Tick.Field.of_bits\n (List.init Backend.Tick.Field.size_in_bits\n ~f:(testbit (Bigint.of_string s)) ) ))\n","open Core_kernel\nopen Pickles_types\nopen Backend\nopen Composition_types\nopen Common\n\nlet _wrap_domains = Common.wrap_domains\n\nlet evals =\n let open Plonk_types in\n let e =\n Evals.map (Evaluation_lengths.create ~of_int:Fn.id) ~f:(fun n ->\n let a () = Array.create ~len:n (Ro.tock ()) in\n (a (), a ()) )\n in\n let ex =\n { All_evals.With_public_input.evals = e\n ; public_input = (Ro.tock (), Ro.tock ())\n }\n in\n { All_evals.ft_eval1 = Ro.tock (); evals = ex }\n\nlet evals_combined =\n Plonk_types.All_evals.map evals ~f1:Fn.id\n ~f2:(Array.reduce_exn ~f:Backend.Tock.Field.( + ))\n\nmodule Ipa = struct\n module Wrap = struct\n let challenges =\n Vector.init Tock.Rounds.n ~f:(fun _ ->\n let prechallenge = Ro.scalar_chal () in\n { Bulletproof_challenge.prechallenge } )\n\n let challenges_computed =\n Vector.map challenges ~f:(fun { prechallenge } : Tock.Field.t ->\n Ipa.Wrap.compute_challenge prechallenge )\n\n let sg =\n lazy (time \"dummy wrap sg\" (fun () -> Ipa.Wrap.compute_sg challenges))\n end\n\n module Step = struct\n let challenges =\n Vector.init Tick.Rounds.n ~f:(fun _ ->\n let prechallenge = Ro.scalar_chal () in\n { Bulletproof_challenge.prechallenge } )\n\n let challenges_computed =\n Vector.map challenges ~f:(fun { prechallenge } : Tick.Field.t ->\n Ipa.Step.compute_challenge prechallenge )\n\n let sg =\n lazy (time \"dummy wrap sg\" (fun () -> Ipa.Step.compute_sg challenges))\n end\nend\n","open Core_kernel\nopen Pickles_types\nopen Hlist\nopen Common\nopen Import\nopen Types\nopen Wrap_main_inputs\nopen Impl\nmodule SC = Scalar_challenge\n\n(* Let's define an OCaml encoding for inductive NP sets. Let A be an inductive NP set.\n\n To encode A, we require types [var(A)] and [value(A)] corresponding to\n \\mathcal{U}(A) the underlying set of A.\n\n Let r_1, ..., r_n be the inductive rules of A.\n For each i, let (A_{i, 1}, ..., A_{i, k_i}) be the predecessor inductive sets for rule i.\n\n We define a few type level lists.\n\n - For each rule r_i,\n [prev_vars(r_i) := var(A_{i, 1}) * (var(A_{i, 2}) * (... * var(A_{i, k_i})))]\n [prev_values(r_i) := value(A_{i, 1}) * (value(A_{i, 2}) * (... * value(A_{i, k_i})))]\n\n - [prev_varss(A) := map prev_vars (r_1, ..., r_n)]\n - [prev_valuess(A) := map prev_values (r_1, ..., r_n)]\n\n We use corresponding type variable names throughout this file.\n*)\n\nmodule Old_bulletproof_chals = struct\n type t =\n | T :\n 'max_local_max_proofs_verified Nat.t\n * 'max_local_max_proofs_verified Challenges_vector.t\n -> t\nend\n\nlet pack_statement max_proofs_verified t =\n let open Types.Step in\n Spec.pack\n (module Impl)\n (Statement.spec max_proofs_verified Backend.Tock.Rounds.n)\n (Statement.to_data t)\n\nlet shifts ~log2_size = Common.tock_shifts ~log2_size\n\nlet domain_generator ~log2_size =\n Backend.Tock.Field.domain_generator ~log2_size |> Impl.Field.constant\n\nlet _split_field_typ : (Field.t * Boolean.var, Field.Constant.t) Typ.t =\n Typ.transport\n Typ.(field * Boolean.typ)\n ~there:(fun (x : Field.Constant.t) ->\n let n = Bigint.of_field x in\n let is_odd = Bigint.test_bit n 0 in\n let y = Field.Constant.((if is_odd then x - one else x) / of_int 2) in\n (y, is_odd) )\n ~back:(fun (hi, is_odd) ->\n let open Field.Constant in\n let x = hi + hi in\n if is_odd then x + one else x )\n\n(* Split a field element into its high bits (packed) and the low bit.\n\n It does not check that the \"high bits\" actually fit into n - 1 bits,\n this is deferred to a call to scale_fast2, which performs this check.\n*)\nlet split_field (x : Field.t) : Field.t * Boolean.var =\n let ((y, is_odd) as res) =\n exists\n Typ.(field * Boolean.typ)\n ~compute:(fun () ->\n let x = As_prover.read_var x in\n let n = Bigint.of_field x in\n let is_odd = Bigint.test_bit n 0 in\n let y = Field.Constant.((if is_odd then x - one else x) / of_int 2) in\n (y, is_odd) )\n in\n Field.(Assert.equal ((of_int 2 * y) + (is_odd :> t)) x) ;\n res\n\n(* The SNARK function for wrapping any proof coming from the given set of keys *)\nlet wrap_main\n (type max_proofs_verified branches prev_varss max_local_max_proofs_verifieds)\n ~feature_flags\n (full_signature :\n ( max_proofs_verified\n , branches\n , max_local_max_proofs_verifieds )\n Full_signature.t ) (pi_branches : (prev_varss, branches) Hlist.Length.t)\n (step_keys :\n ( Wrap_main_inputs.Inner_curve.Constant.t Wrap_verifier.index'\n , branches )\n Vector.t\n Lazy.t ) (step_widths : (int, branches) Vector.t)\n (step_domains : (Domains.t, branches) Vector.t) ~srs\n (max_proofs_verified :\n (module Nat.Add.Intf with type n = max_proofs_verified) ) :\n (max_proofs_verified, max_local_max_proofs_verifieds) Requests.Wrap.t\n * ( ( _\n , _\n , _ Shifted_value.Type1.t\n , _\n , _\n , _\n , _\n , _\n , _\n , _\n , _ )\n Types.Wrap.Statement.In_circuit.t\n -> unit ) =\n Timer.clock __LOC__ ;\n let module Max_proofs_verified = ( val max_proofs_verified : Nat.Add.Intf\n with type n = max_proofs_verified )\n in\n let T = Max_proofs_verified.eq in\n let branches = Hlist.Length.to_nat pi_branches in\n Timer.clock __LOC__ ;\n let (module Req) =\n Requests.Wrap.(\n (create () : (max_proofs_verified, max_local_max_proofs_verifieds) t))\n in\n Timer.clock __LOC__ ;\n let { Full_signature.padded = _; maxes = (module Max_widths_by_slot) } =\n full_signature\n in\n Timer.clock __LOC__ ;\n let main\n ({ proof_state =\n { deferred_values =\n { plonk\n ; xi\n ; combined_inner_product\n ; b\n ; branch_data\n ; bulletproof_challenges\n }\n ; sponge_digest_before_evaluations\n ; messages_for_next_wrap_proof = messages_for_next_wrap_proof_digest\n }\n ; messages_for_next_step_proof = _\n } :\n ( _\n , _\n , _ Shifted_value.Type1.t\n , _\n , _\n , _\n , _\n , _\n , _\n , _\n , Field.t )\n Types.Wrap.Statement.In_circuit.t ) =\n let logger = Internal_tracing_context_logger.get () in\n with_label __LOC__ (fun () ->\n let which_branch' =\n exists\n (Typ.transport Field.typ ~there:Field.Constant.of_int\n ~back:(fun _ -> failwith \"unimplemented\") )\n ~request:(fun () -> Req.Which_branch)\n in\n let which_branch =\n Wrap_verifier.One_hot_vector.of_index which_branch' ~length:branches\n in\n let actual_proofs_verified_mask =\n Util.ones_vector\n (module Impl)\n ~first_zero:\n (Wrap_verifier.Pseudo.choose\n (which_branch, step_widths)\n ~f:Field.of_int )\n Max_proofs_verified.n\n |> Vector.rev\n in\n let domain_log2 =\n Wrap_verifier.Pseudo.choose\n ( which_branch\n , Vector.map ~f:(fun ds -> Domain.log2_size ds.h) step_domains )\n ~f:Field.of_int\n in\n let () =\n with_label __LOC__ (fun () ->\n (* Check that the branch_data public-input is correct *)\n Branch_data.Checked.pack\n (module Impl)\n { proofs_verified_mask =\n Vector.extend_front_exn actual_proofs_verified_mask Nat.N2.n\n Boolean.false_\n ; domain_log2\n }\n |> Field.Assert.equal branch_data )\n in\n let prev_proof_state =\n with_label __LOC__ (fun () ->\n let open Types.Step.Proof_state in\n let typ =\n typ\n (module Impl)\n Common.Lookup_parameters.tock_zero\n ~assert_16_bits:(Wrap_verifier.assert_n_bits ~n:16)\n (Vector.init Max_proofs_verified.n ~f:(fun _ ->\n Plonk_types.Features.none ) )\n (Shifted_value.Type2.typ Field.typ)\n in\n exists typ ~request:(fun () -> Req.Proof_state) )\n in\n let step_plonk_index =\n with_label __LOC__ (fun () ->\n Wrap_verifier.choose_key which_branch\n (Vector.map (Lazy.force step_keys)\n ~f:(Plonk_verification_key_evals.map ~f:Inner_curve.constant) ) )\n in\n let prev_step_accs =\n with_label __LOC__ (fun () ->\n exists (Vector.typ Inner_curve.typ Max_proofs_verified.n)\n ~request:(fun () -> Req.Step_accs) )\n in\n let old_bp_chals =\n with_label __LOC__ (fun () ->\n let typ =\n let module T =\n H1.Typ (Impls.Wrap) (Nat) (Challenges_vector)\n (Challenges_vector.Constant)\n (struct\n let f (type n) (n : n Nat.t) =\n Vector.typ\n (Vector.typ Field.typ Backend.Tock.Rounds.n)\n n\n end)\n in\n T.f Max_widths_by_slot.maxes\n in\n let module Z = H1.Zip (Nat) (Challenges_vector) in\n let module M =\n H1.Map\n (H1.Tuple2 (Nat) (Challenges_vector))\n (E01 (Old_bulletproof_chals))\n (struct\n let f (type n)\n ((n, v) : n H1.Tuple2(Nat)(Challenges_vector).t) =\n Old_bulletproof_chals.T (n, v)\n end)\n in\n let module V = H1.To_vector (Old_bulletproof_chals) in\n Z.f Max_widths_by_slot.maxes\n (exists typ ~request:(fun () -> Req.Old_bulletproof_challenges))\n |> M.f\n |> V.f Max_widths_by_slot.length )\n in\n let new_bulletproof_challenges =\n with_label __LOC__ (fun () ->\n let evals =\n let ty =\n let ty =\n Plonk_types.All_evals.typ (module Impl) feature_flags\n in\n Vector.typ ty Max_proofs_verified.n\n in\n exists ty ~request:(fun () -> Req.Evals)\n in\n let chals =\n let wrap_domains =\n let all_possible_domains =\n Wrap_verifier.all_possible_domains ()\n in\n let wrap_domain_indices =\n exists (Vector.typ Field.typ Max_proofs_verified.n)\n ~request:(fun () -> Req.Wrap_domain_indices)\n in\n Vector.map wrap_domain_indices ~f:(fun index ->\n let which_branch =\n Wrap_verifier.One_hot_vector.of_index index\n ~length:Wrap_verifier.num_possible_domains\n in\n Wrap_verifier.Pseudo.Domain.to_domain ~shifts\n ~domain_generator\n (which_branch, all_possible_domains) )\n in\n Vector.mapn\n [ (* This is padded to max_proofs_verified for the benefit of wrapping with dummy unfinalized proofs *)\n prev_proof_state.unfinalized_proofs\n ; old_bp_chals\n ; evals\n ; wrap_domains\n ]\n ~f:(fun\n [ { deferred_values\n ; sponge_digest_before_evaluations\n ; should_finalize\n }\n ; old_bulletproof_challenges\n ; evals\n ; wrap_domain\n ]\n ->\n let sponge =\n let s = Sponge.create sponge_params in\n Sponge.absorb s sponge_digest_before_evaluations ;\n s\n in\n\n (* the type of the local max proofs-verified depends on\n which kind of step proof we are wrapping. *)\n (* For each i in [0..max_proofs_verified-1], we have\n max_local_max_proofs_verified, which is the largest\n Local_max_proofs_verified which is the i^th inner proof of a step proof.\n\n Need to compute this value from the which_branch.\n *)\n let (T\n ( _max_local_max_proofs_verified\n , old_bulletproof_challenges ) ) =\n old_bulletproof_challenges\n in\n let old_bulletproof_challenges =\n Wrap_hack.Checked.pad_challenges\n old_bulletproof_challenges\n in\n let finalized, chals =\n with_label __LOC__ (fun () ->\n Wrap_verifier.finalize_other_proof\n (module Wrap_hack.Padded_length)\n ~domain:(wrap_domain :> _ Plonk_checks.plonk_domain)\n ~sponge ~old_bulletproof_challenges deferred_values\n evals )\n in\n Boolean.(Assert.any [ finalized; not should_finalize ]) ;\n chals )\n in\n chals )\n in\n let prev_statement =\n let prev_messages_for_next_wrap_proof =\n Vector.map2 prev_step_accs old_bp_chals\n ~f:(fun sacc (T (max_local_max_proofs_verified, chals)) ->\n Wrap_hack.Checked.hash_messages_for_next_wrap_proof\n max_local_max_proofs_verified\n { challenge_polynomial_commitment = sacc\n ; old_bulletproof_challenges = chals\n } )\n in\n { Types.Step.Statement.messages_for_next_wrap_proof =\n prev_messages_for_next_wrap_proof\n ; proof_state = prev_proof_state\n }\n in\n let openings_proof =\n let shift = Shifts.tick1 in\n exists\n (Plonk_types.Openings.Bulletproof.typ\n ( Typ.transport Wrap_verifier.Other_field.Packed.typ\n ~there:(fun x ->\n (* When storing, make it a shifted value *)\n match\n Shifted_value.Type1.of_field\n (module Backend.Tick.Field)\n ~shift x\n with\n | Shifted_value x ->\n x )\n ~back:(fun x ->\n Shifted_value.Type1.to_field\n (module Backend.Tick.Field)\n ~shift (Shifted_value x) )\n (* When reading, unshift *)\n |> Typ.transport_var\n (* For the var, we just wrap the now shifted underlying value. *)\n ~there:(fun (Shifted_value.Type1.Shifted_value x) -> x)\n ~back:(fun x -> Shifted_value x) )\n Inner_curve.typ\n ~length:(Nat.to_int Backend.Tick.Rounds.n) )\n ~request:(fun () -> Req.Openings_proof)\n in\n let ( sponge_digest_before_evaluations_actual\n , (`Success bulletproof_success, bulletproof_challenges_actual) ) =\n let messages =\n with_label __LOC__ (fun () ->\n exists\n (Plonk_types.Messages.typ\n (module Impl)\n Inner_curve.typ ~bool:Boolean.typ feature_flags\n ~dummy:Inner_curve.Params.one\n ~commitment_lengths:\n (Commitment_lengths.create ~of_int:Fn.id) )\n ~request:(fun () -> Req.Messages) )\n in\n let sponge = Wrap_verifier.Opt.create sponge_params in\n with_label __LOC__ (fun () ->\n [%log internal] \"Wrap_verifier_incrementally_verify_proof\" ;\n let res =\n Wrap_verifier.incrementally_verify_proof max_proofs_verified\n ~actual_proofs_verified_mask ~step_domains\n ~verification_key:step_plonk_index ~srs ~xi ~sponge\n ~public_input:\n (Array.map\n (pack_statement Max_proofs_verified.n prev_statement)\n ~f:(function\n | `Field (Shifted_value x) ->\n `Field (split_field x)\n | `Packed_bits (x, n) ->\n `Packed_bits (x, n) ) )\n ~sg_old:prev_step_accs\n ~advice:{ b; combined_inner_product }\n ~messages ~which_branch ~openings_proof ~plonk\n in\n [%log internal] \"Wrap_verifier_incrementally_verify_proof_done\" ;\n res )\n in\n with_label __LOC__ (fun () ->\n Boolean.Assert.is_true bulletproof_success ) ;\n with_label __LOC__ (fun () ->\n Field.Assert.equal messages_for_next_wrap_proof_digest\n (Wrap_hack.Checked.hash_messages_for_next_wrap_proof\n Max_proofs_verified.n\n { Types.Wrap.Proof_state.Messages_for_next_wrap_proof\n .challenge_polynomial_commitment =\n openings_proof.challenge_polynomial_commitment\n ; old_bulletproof_challenges = new_bulletproof_challenges\n } ) ) ;\n with_label __LOC__ (fun () ->\n Field.Assert.equal sponge_digest_before_evaluations\n sponge_digest_before_evaluations_actual ) ;\n Array.iter2_exn bulletproof_challenges_actual\n (Vector.to_array bulletproof_challenges)\n ~f:(fun\n { prechallenge = { inner = x1 } }\n ({ prechallenge = { inner = x2 } } :\n _ SC.t Bulletproof_challenge.t )\n -> with_label __LOC__ (fun () -> Field.Assert.equal x1 x2) ) ;\n () )\n in\n Timer.clock __LOC__ ;\n ((module Req), main)\n","open Pickles_types\nopen Plonk_types\n\nlet create (type a) ~(of_int : int -> a) :\n (a Columns_vec.t, a, a) Messages.Poly.t =\n let one = of_int 1 in\n { w = Vector.init Plonk_types.Columns.n ~f:(fun _ -> one)\n ; z = one\n ; t = of_int 7\n }\n","let create ~of_int =\n let one = of_int 1 in\n let open Pickles_types in\n let open Plonk_types in\n Evals.\n { w = Vector.init Columns.n ~f:(fun _ -> one)\n ; coefficients = Vector.init Columns.n ~f:(fun _ -> one)\n ; z = one\n ; s = Vector.init Permuts_minus_1.n ~f:(fun _ -> one)\n ; generic_selector = one\n ; poseidon_selector = one\n ; complete_add_selector = one\n ; mul_selector = one\n ; emul_selector = one\n ; endomul_scalar_selector = one\n ; (* FIXME *)\n range_check0_selector = None\n ; range_check1_selector = None\n ; foreign_field_add_selector = None\n ; foreign_field_mul_selector = None\n ; xor_selector = None\n ; rot_selector = None\n ; lookup_aggregation = None\n ; lookup_table = None\n ; lookup_sorted = Vector.init Nat.N5.n ~f:(fun _ -> None)\n ; runtime_lookup_table = None\n ; runtime_lookup_table_selector = None\n ; xor_lookup_selector = None\n ; lookup_gate_lookup_selector = None\n ; range_check_lookup_selector = None\n ; foreign_field_mul_lookup_selector = None\n }\n","open Core_kernel\nopen Backend\nopen Import\n\nlet bits_random_oracle =\n let h = Digestif.blake2s 32 in\n fun ~length s ->\n Digestif.digest_string h s |> Digestif.to_raw_string h |> String.to_list\n |> List.concat_map ~f:(fun c ->\n let c = Char.to_int c in\n List.init 8 ~f:(fun i -> (c lsr i) land 1 = 1) )\n |> fun a -> List.take a length\n\nlet ro lab length f =\n let r = ref 0 in\n fun () ->\n incr r ;\n f (bits_random_oracle ~length (sprintf \"%s_%d\" lab !r))\n\nlet tock = ro \"fq\" Tock.Field.size_in_bits Tock.Field.of_bits\n\nlet tick = ro \"fp\" Tick.Field.size_in_bits Tick.Field.of_bits\n\nlet chal = ro \"chal\" Challenge.Constant.length Challenge.Constant.of_bits\n\nlet scalar_chal () = Scalar_challenge.create (chal ())\n","module P = Proof\n\nmodule type Statement_intf = Intf.Statement\n\nmodule type Statement_var_intf = Intf.Statement_var\n\nmodule type Statement_value_intf = Intf.Statement_value\n\nmodule SC = Scalar_challenge\nopen Core_kernel\nopen Async_kernel\nopen Import\nopen Pickles_types\nopen Poly_types\nopen Hlist\nopen Backend\n\nexception Return_digest of Md5.t\n\nlet profile_constraints = false\n\nlet verify_promise = Verify.verify\n\nopen Kimchi_backend\nmodule Proof_ = P.Base\nmodule Proof = P\n\nlet pad_messages_for_next_wrap_proof\n (type local_max_proofs_verifieds max_local_max_proofs_verifieds\n max_proofs_verified )\n (module M : Hlist.Maxes.S\n with type ns = max_local_max_proofs_verifieds\n and type length = max_proofs_verified )\n (messages_for_next_wrap_proofs :\n local_max_proofs_verifieds\n H1.T(Proof_.Messages_for_next_proof_over_same_field.Wrap).t ) =\n let dummy_chals = Dummy.Ipa.Wrap.challenges in\n let module Messages =\n H1.T (Proof_.Messages_for_next_proof_over_same_field.Wrap) in\n let module Maxes = H1.T (Nat) in\n let (T (messages_len, _)) = Messages.length messages_for_next_wrap_proofs in\n let (T (maxes_len, _)) = Maxes.length M.maxes in\n let (T difference) =\n let rec sub : type n m. n Nat.t -> m Nat.t -> Nat.e =\n fun x y ->\n let open Nat in\n match (x, y) with\n | _, Z ->\n T x\n | Z, S _ ->\n assert false\n | S x, S y ->\n sub x y\n in\n sub maxes_len messages_len\n in\n let rec go :\n type len ms ns. len Nat.t -> ms Maxes.t -> ns Messages.t -> ms Messages.t\n =\n fun pad maxes messages_for_next_wrap_proofs ->\n match (pad, maxes, messages_for_next_wrap_proofs) with\n | S pad, m :: maxes, _ ->\n { challenge_polynomial_commitment = Lazy.force Dummy.Ipa.Step.sg\n ; old_bulletproof_challenges = Vector.init m ~f:(fun _ -> dummy_chals)\n }\n :: go pad maxes messages_for_next_wrap_proofs\n | S _, [], _ ->\n assert false\n | Z, [], [] ->\n []\n | ( Z\n , m :: maxes\n , messages_for_next_wrap_proof :: messages_for_next_wrap_proofs ) ->\n let messages_for_next_wrap_proof =\n { messages_for_next_wrap_proof with\n old_bulletproof_challenges =\n Vector.extend_exn\n messages_for_next_wrap_proof.old_bulletproof_challenges m\n dummy_chals\n }\n in\n messages_for_next_wrap_proof :: go Z maxes messages_for_next_wrap_proofs\n | Z, [], _ :: _ | Z, _ :: _, [] ->\n assert false\n in\n go difference M.maxes messages_for_next_wrap_proofs\n\nmodule type Proof_intf = sig\n type statement\n\n type t\n\n val verification_key : Verification_key.t Lazy.t\n\n val id : Cache.Wrap.Key.Verification.t Lazy.t\n\n val verify : (statement * t) list -> unit Or_error.t Deferred.t\n\n val verify_promise : (statement * t) list -> unit Or_error.t Promise.t\nend\n\nmodule Prover = struct\n type ('prev_values, 'local_widths, 'local_heights, 'a_value, 'proof) t =\n ?handler:\n ( Snarky_backendless.Request.request\n -> Snarky_backendless.Request.response )\n -> 'a_value\n -> 'proof\nend\n\ntype ('max_proofs_verified, 'branches, 'prev_varss) wrap_main_generic =\n { wrap_main :\n 'max_local_max_proofs_verifieds.\n Domains.t\n -> ( 'max_proofs_verified\n , 'branches\n , 'max_local_max_proofs_verifieds )\n Full_signature.t\n -> ('prev_varss, 'branches) Hlist.Length.t\n -> ( Wrap_main_inputs.Inner_curve.Constant.t Wrap_verifier.index'\n , 'branches )\n Vector.t\n Lazy.t\n -> (int, 'branches) Pickles_types.Vector.t\n -> (Import.Domains.t, 'branches) Pickles_types.Vector.t\n -> (module Pickles_types.Nat.Add.Intf with type n = 'max_proofs_verified)\n -> ('max_proofs_verified, 'max_local_max_proofs_verifieds) Requests.Wrap.t\n * ( ( ( Impls.Wrap.Field.t\n , Wrap_verifier.Challenge.t Kimchi_types.scalar_challenge\n , Wrap_verifier.Other_field.Packed.t Shifted_value.Type1.t\n , ( Wrap_verifier.Other_field.Packed.t Shifted_value.Type1.t\n , Impls.Wrap.Boolean.var )\n Plonk_types.Opt.t\n , ( Impls.Wrap.Impl.Field.t Composition_types.Scalar_challenge.t\n Composition_types.Wrap.Proof_state.Deferred_values.Plonk\n .In_circuit\n .Lookup\n .t\n , Impls.Wrap.Boolean.var )\n Pickles_types__Plonk_types.Opt.t\n , Impls.Wrap.Boolean.var )\n Composition_types.Wrap.Proof_state.Deferred_values.Plonk\n .In_circuit\n .t\n , Wrap_verifier.Challenge.t Kimchi_types.scalar_challenge\n , Wrap_verifier.Other_field.Packed.t\n Pickles_types__Shifted_value.Type1.t\n , Impls.Wrap.Field.t\n , Impls.Wrap.Field.t\n , Impls.Wrap.Field.t\n , ( Impls.Wrap.Field.t Import.Scalar_challenge.t\n Import.Types.Bulletproof_challenge.t\n , Backend.Tick.Rounds.n )\n Vector.T.t\n , Impls.Wrap.Field.t )\n Composition_types.Wrap.Statement.t\n -> unit )\n (** An override for wrap_main, which allows for adversarial testing\n with an 'invalid' pickles statement by passing a dummy proof.\n *)\n ; tweak_statement :\n 'actual_proofs_verified 'b 'e.\n ( Import.Challenge.Constant.t\n , Import.Challenge.Constant.t Import.Types.Scalar_challenge.t\n , Backend.Tick.Field.t Pickles_types.Shifted_value.Type1.t\n , ( Backend.Tick.Field.t Pickles_types.Shifted_value.Type1.t\n , bool )\n Import.Types.Opt.t\n , ( Import.Challenge.Constant.t Import.Types.Scalar_challenge.t\n Composition_types.Wrap.Proof_state.Deferred_values.Plonk.In_circuit\n .Lookup\n .t\n , bool )\n Import.Types.Opt.t\n , bool\n , 'max_proofs_verified\n Proof.Base.Messages_for_next_proof_over_same_field.Wrap.t\n , (int64, Composition_types.Digest.Limbs.n) Pickles_types.Vector.vec\n , ( 'b\n , ( Kimchi_pasta.Pallas_based_plonk.Proof.G.Affine.t\n , 'actual_proofs_verified )\n Pickles_types.Vector.t\n , ( ( Import.Challenge.Constant.t Import.Scalar_challenge.t\n Import.Bulletproof_challenge.t\n , 'e )\n Pickles_types.Vector.t\n , 'actual_proofs_verified )\n Pickles_types.Vector.t )\n Proof.Base.Messages_for_next_proof_over_same_field.Step.t\n , Import.Challenge.Constant.t Import.Types.Scalar_challenge.t\n Import.Types.Bulletproof_challenge.t\n Import.Types.Step_bp_vec.t\n , Import.Types.Branch_data.t )\n Import.Types.Wrap.Statement.In_circuit.t\n -> ( Import.Challenge.Constant.t\n , Import.Challenge.Constant.t Import.Types.Scalar_challenge.t\n , Backend.Tick.Field.t Pickles_types.Shifted_value.Type1.t\n , ( Backend.Tick.Field.t Pickles_types.Shifted_value.Type1.t\n , bool )\n Import.Types.Opt.t\n , ( Import.Challenge.Constant.t Import.Types.Scalar_challenge.t\n Composition_types.Wrap.Proof_state.Deferred_values.Plonk.In_circuit\n .Lookup\n .t\n , bool )\n Import.Types.Opt.t\n , bool\n , 'max_proofs_verified\n Proof.Base.Messages_for_next_proof_over_same_field.Wrap.t\n , ( Limb_vector.Constant.Hex64.t\n , Composition_types.Digest.Limbs.n )\n Pickles_types.Vector.vec\n , ( 'b\n , ( Kimchi_pasta.Pallas_based_plonk.Proof.G.Affine.t\n , 'actual_proofs_verified )\n Pickles_types.Vector.t\n , ( ( Import.Challenge.Constant.t Import.Scalar_challenge.t\n Import.Bulletproof_challenge.t\n , 'e )\n Pickles_types.Vector.t\n , 'actual_proofs_verified )\n Pickles_types.Vector.t )\n Proof.Base.Messages_for_next_proof_over_same_field.Step.t\n , Import.Challenge.Constant.t Import.Types.Scalar_challenge.t\n Import.Types.Bulletproof_challenge.t\n Import.Types.Step_bp_vec.t\n , Import.Types.Branch_data.t )\n Import.Types.Wrap.Statement.In_circuit.t\n (** A function to modify the statement passed into the wrap proof,\n which will be later passed to recursion pickles rules.\n\n This function can be used to modify the pickles statement in an\n adversarial way, along with [wrap_main] above that allows that\n statement to be accepted.\n *)\n }\n\nmodule Make\n (Arg_var : Statement_var_intf)\n (Arg_value : Statement_value_intf)\n (Ret_var : T0)\n (Ret_value : T0)\n (Auxiliary_var : T0)\n (Auxiliary_value : T0) =\nstruct\n module IR =\n Inductive_rule.T (Arg_var) (Arg_value) (Ret_var) (Ret_value) (Auxiliary_var)\n (Auxiliary_value)\n module HIR = H4.T (IR)\n\n let max_local_max_proofs_verifieds ~self (type n)\n (module Max_proofs_verified : Nat.Intf with type n = n) branches choices =\n let module Local_max_proofs_verifieds = struct\n type t = (int, Max_proofs_verified.n) Vector.t\n end in\n let module M =\n H4.Map (IR) (E04 (Local_max_proofs_verifieds))\n (struct\n module V = H4.To_vector (Int)\n module HT = H4.T (Tag)\n\n module M =\n H4.Map (Tag) (E04 (Int))\n (struct\n let f (type a b c d) (t : (a, b, c, d) Tag.t) : int =\n if Type_equal.Id.same t.id self then\n Nat.to_int Max_proofs_verified.n\n else\n let (module M) = Types_map.max_proofs_verified t in\n Nat.to_int M.n\n end)\n\n let f :\n type a b c d. (a, b, c, d) IR.t -> Local_max_proofs_verifieds.t =\n fun rule ->\n let (T (_, l)) = HT.length rule.prevs in\n Vector.extend_front_exn\n (V.f l (M.f rule.prevs))\n Max_proofs_verified.n 0\n end)\n in\n let module V = H4.To_vector (Local_max_proofs_verifieds) in\n let padded = V.f branches (M.f choices) |> Vector.transpose in\n (padded, Maxes.m padded)\n\n module Lazy_keys = struct\n type t =\n (Impls.Step.Keypair.t * Dirty.t) Lazy.t\n * (Kimchi_bindings.Protocol.VerifierIndex.Fp.t * Dirty.t) Lazy.t\n\n (* TODO Think this is right.. *)\n end\n\n let log_step main _typ name index =\n let module Constraints = Snarky_log.Constraints (Impls.Step.Internal_Basic) in\n let log =\n let weight =\n let sys = Backend.Tick.R1CS_constraint_system.create () in\n fun ({ annotation; basic } : Impls.Step.Constraint.t) ->\n let prev =\n Kimchi_pasta_constraint_system.Vesta_constraint_system.next_row sys\n in\n Backend.Tick.R1CS_constraint_system.add_constraint sys\n ?label:annotation basic ;\n let next =\n Kimchi_pasta_constraint_system.Vesta_constraint_system.next_row sys\n in\n next - prev\n in\n Constraints.log ~weight (fun () -> Impls.Step.make_checked main)\n in\n if profile_constraints then\n Snarky_log.to_file (sprintf \"step-snark-%s-%d.json\" name index) log\n\n let log_wrap main typ name id =\n let module Constraints = Snarky_log.Constraints (Impls.Wrap.Internal_Basic) in\n let log =\n let sys = Backend.Tock.R1CS_constraint_system.create () in\n let weight ({ annotation; basic } : Impls.Wrap.Constraint.t) =\n let prev =\n Kimchi_pasta_constraint_system.Pallas_constraint_system.next_row sys\n in\n Backend.Tock.R1CS_constraint_system.add_constraint sys ?label:annotation\n basic ;\n let next =\n Kimchi_pasta_constraint_system.Pallas_constraint_system.next_row sys\n in\n next - prev\n in\n let log =\n Constraints.log ~weight\n Impls.Wrap.(\n fun () ->\n make_checked (fun () : unit ->\n let x = with_label __LOC__ (fun () -> exists typ) in\n main x () ))\n in\n log\n in\n if profile_constraints then\n Snarky_log.to_file\n (sprintf\n !\"wrap-%s-%{sexp:Type_equal.Id.Uid.t}.json\"\n name (Type_equal.Id.uid id) )\n log\n\n let compile :\n type var value prev_varss prev_valuess widthss heightss max_proofs_verified branches.\n self:(var, value, max_proofs_verified, branches) Tag.t\n -> cache:Key_cache.Spec.t list\n -> ?disk_keys:\n (Cache.Step.Key.Verification.t, branches) Vector.t\n * Cache.Wrap.Key.Verification.t\n -> ?return_early_digest_exception:bool\n -> ?override_wrap_domain:Pickles_base.Proofs_verified.t\n -> ?override_wrap_main:\n (max_proofs_verified, branches, prev_varss) wrap_main_generic\n -> branches:(module Nat.Intf with type n = branches)\n -> max_proofs_verified:\n (module Nat.Add.Intf with type n = max_proofs_verified)\n -> name:string\n -> constraint_constants:Snark_keys_header.Constraint_constants.t\n -> public_input:\n ( var\n , value\n , Arg_var.t\n , Arg_value.t\n , Ret_var.t\n , Ret_value.t )\n Inductive_rule.public_input\n -> auxiliary_typ:(Auxiliary_var.t, Auxiliary_value.t) Impls.Step.Typ.t\n -> choices:\n ( self:(var, value, max_proofs_verified, branches) Tag.t\n -> (prev_varss, prev_valuess, widthss, heightss) H4.T(IR).t )\n -> unit\n -> ( prev_valuess\n , widthss\n , heightss\n , Arg_value.t\n , ( Ret_value.t\n * Auxiliary_value.t\n * (max_proofs_verified, max_proofs_verified) Proof.t )\n Promise.t )\n H3_2.T(Prover).t\n * _\n * _\n * _ =\n fun ~self ~cache ?disk_keys ?(return_early_digest_exception = false)\n ?override_wrap_domain ?override_wrap_main ~branches:(module Branches)\n ~max_proofs_verified ~name ~constraint_constants ~public_input\n ~auxiliary_typ ~choices () ->\n let snark_keys_header kind constraint_system_hash =\n { Snark_keys_header.header_version = Snark_keys_header.header_version\n ; kind\n ; constraint_constants\n ; commits =\n { mina = Mina_version.commit_id\n ; marlin = Mina_version.marlin_commit_id\n }\n ; length = (* This is a dummy, it gets filled in on read/write. *) 0\n ; commit_date = Mina_version.commit_date\n ; constraint_system_hash\n ; identifying_hash =\n (* TODO: Proper identifying hash. *)\n constraint_system_hash\n }\n in\n Timer.start __LOC__ ;\n let module Max_proofs_verified = ( val max_proofs_verified : Nat.Add.Intf\n with type n = max_proofs_verified )\n in\n let T = Max_proofs_verified.eq in\n let choices = choices ~self in\n let (T (prev_varss_n, prev_varss_length)) = HIR.length choices in\n let T = Nat.eq_exn prev_varss_n Branches.n in\n let padded, (module Maxes) =\n max_local_max_proofs_verifieds\n ( module struct\n include Max_proofs_verified\n end )\n prev_varss_length choices ~self:self.id\n in\n let full_signature = { Full_signature.padded; maxes = (module Maxes) } in\n Timer.clock __LOC__ ;\n let feature_flags =\n let rec go :\n type a b c d.\n (a, b, c, d) H4.T(IR).t\n -> Plonk_types.Opt.Flag.t Plonk_types.Features.t =\n fun rules ->\n match rules with\n | [] ->\n Plonk_types.Features.none\n | [ r ] ->\n Plonk_types.Features.map r.feature_flags ~f:(function\n | true ->\n Plonk_types.Opt.Flag.Yes\n | false ->\n Plonk_types.Opt.Flag.No )\n | r :: rules ->\n let feature_flags = go rules in\n Plonk_types.Features.map2 r.feature_flags feature_flags\n ~f:(fun enabled flag ->\n match (enabled, flag) with\n | true, Yes ->\n Plonk_types.Opt.Flag.Yes\n | false, No ->\n No\n | _, Maybe | true, No | false, Yes ->\n Maybe )\n in\n go choices\n in\n let wrap_domains =\n match override_wrap_domain with\n | None ->\n let module M =\n Wrap_domains.Make (Arg_var) (Arg_value) (Ret_var) (Ret_value)\n (Auxiliary_var)\n (Auxiliary_value)\n in\n M.f full_signature prev_varss_n prev_varss_length ~max_proofs_verified\n ~feature_flags\n | Some override ->\n Common.wrap_domains\n ~proofs_verified:(Pickles_base.Proofs_verified.to_int override)\n in\n Timer.clock __LOC__ ;\n let module Branch_data = struct\n type ('vars, 'vals, 'n, 'm) t =\n ( Arg_var.t\n , Arg_value.t\n , Ret_var.t\n , Ret_value.t\n , Auxiliary_var.t\n , Auxiliary_value.t\n , Max_proofs_verified.n\n , Branches.n\n , 'vars\n , 'vals\n , 'n\n , 'm )\n Step_branch_data.t\n end in\n let proofs_verifieds =\n let module M =\n H4.Map (IR) (E04 (Int))\n (struct\n module M = H4.T (Tag)\n\n let f : type a b c d. (a, b, c, d) IR.t -> int =\n fun r ->\n let (T (n, _)) = M.length r.prevs in\n Nat.to_int n\n end)\n in\n let module V = H4.To_vector (Int) in\n V.f prev_varss_length (M.f choices)\n in\n let step_data =\n let i = ref 0 in\n Timer.clock __LOC__ ;\n let rec f :\n type a b c d.\n (a, b, c, d) H4.T(IR).t -> (a, b, c, d) H4.T(Branch_data).t = function\n | [] ->\n []\n | rule :: rules ->\n let first =\n Timer.clock __LOC__ ;\n let res =\n Common.time \"make step data\" (fun () ->\n Step_branch_data.create ~index:!i ~feature_flags\n ~actual_feature_flags:rule.feature_flags\n ~max_proofs_verified:Max_proofs_verified.n\n ~branches:Branches.n ~self ~public_input ~auxiliary_typ\n Arg_var.to_field_elements Arg_value.to_field_elements rule\n ~wrap_domains ~proofs_verifieds )\n in\n Timer.clock __LOC__ ; incr i ; res\n in\n first :: f rules\n in\n f choices\n in\n Timer.clock __LOC__ ;\n let step_domains =\n let module M =\n H4.Map (Branch_data) (E04 (Domains))\n (struct\n let f (T b : _ Branch_data.t) = b.domains\n end)\n in\n let module V = H4.To_vector (Domains) in\n V.f prev_varss_length (M.f step_data)\n in\n let cache_handle = ref (Lazy.return `Cache_hit) in\n let accum_dirty t = cache_handle := Cache_handle.(!cache_handle + t) in\n Timer.clock __LOC__ ;\n let step_keypairs =\n let disk_keys =\n Option.map disk_keys ~f:(fun (xs, _) -> Vector.to_array xs)\n in\n let module M =\n H4.Map (Branch_data) (E04 (Lazy_keys))\n (struct\n let etyp =\n Impls.Step.input ~proofs_verified:Max_proofs_verified.n\n ~wrap_rounds:Tock.Rounds.n ~feature_flags\n\n let f (T b : _ Branch_data.t) =\n let (T (typ, _conv, conv_inv)) = etyp in\n let main () () =\n let res = b.main ~step_domains () in\n Impls.Step.with_label \"conv_inv\" (fun () -> conv_inv res)\n in\n let () = if true then log_step main typ name b.index in\n let open Impls.Step in\n (* HACK: TODO docs *)\n if return_early_digest_exception then\n raise\n (Return_digest\n ( constraint_system ~input_typ:Typ.unit ~return_typ:typ main\n |> R1CS_constraint_system.digest ) ) ;\n\n let k_p =\n lazy\n (let cs =\n constraint_system ~input_typ:Typ.unit ~return_typ:typ main\n in\n let cs_hash =\n Md5.to_hex (R1CS_constraint_system.digest cs)\n in\n ( Type_equal.Id.uid self.id\n , snark_keys_header\n { type_ = \"step-proving-key\"\n ; identifier = name ^ \"-\" ^ b.rule.identifier\n }\n cs_hash\n , b.index\n , cs ) )\n in\n let k_v =\n match disk_keys with\n | Some ks ->\n Lazy.return ks.(b.index)\n | None ->\n lazy\n (let id, _header, index, cs = Lazy.force k_p in\n let digest = R1CS_constraint_system.digest cs in\n ( id\n , snark_keys_header\n { type_ = \"step-verification-key\"\n ; identifier = name ^ \"-\" ^ b.rule.identifier\n }\n (Md5.to_hex digest)\n , index\n , digest ) )\n in\n let ((pk, vk) as res) =\n Common.time \"step read or generate\" (fun () ->\n Cache.Step.read_or_generate\n ~prev_challenges:(Nat.to_int (fst b.proofs_verified))\n cache k_p k_v\n (Snarky_backendless.Typ.unit ())\n typ main )\n in\n accum_dirty (Lazy.map pk ~f:snd) ;\n accum_dirty (Lazy.map vk ~f:snd) ;\n res\n end)\n in\n M.f step_data\n in\n Timer.clock __LOC__ ;\n let step_vks =\n let module V = H4.To_vector (Lazy_keys) in\n lazy\n (Vector.map (V.f prev_varss_length step_keypairs) ~f:(fun (_, vk) ->\n Tick.Keypair.vk_commitments (fst (Lazy.force vk)) ) )\n in\n Timer.clock __LOC__ ;\n let wrap_requests, wrap_main =\n match override_wrap_main with\n | None ->\n let srs = Tick.Keypair.load_urs () in\n Wrap_main.wrap_main ~feature_flags ~srs full_signature\n prev_varss_length step_vks proofs_verifieds step_domains\n max_proofs_verified\n | Some { wrap_main; tweak_statement = _ } ->\n (* Instead of creating a proof using the pickles wrap circuit, we\n have been asked to create proof in an 'adversarial' way, where\n the wrap circuit is some other circuit.\n The [wrap_main] value passed in as part of [override_wrap_main]\n defines the alternative circuit to run; this will usually be a\n dummy circuit that verifies any public input for the purposes of\n testing.\n *)\n wrap_main wrap_domains full_signature prev_varss_length step_vks\n proofs_verifieds step_domains max_proofs_verified\n in\n Timer.clock __LOC__ ;\n let (wrap_pk, wrap_vk), disk_key =\n let open Impls.Wrap in\n let (T (typ, conv, _conv_inv)) = input () in\n let main x () : unit = wrap_main (conv x) in\n let () = if true then log_wrap main typ name self.id in\n let self_id = Type_equal.Id.uid self.id in\n let disk_key_prover =\n lazy\n (let cs =\n constraint_system ~input_typ:typ\n ~return_typ:(Snarky_backendless.Typ.unit ())\n main\n in\n let cs_hash = Md5.to_hex (R1CS_constraint_system.digest cs) in\n ( self_id\n , snark_keys_header\n { type_ = \"wrap-proving-key\"; identifier = name }\n cs_hash\n , cs ) )\n in\n let disk_key_verifier =\n match disk_keys with\n | None ->\n lazy\n (let id, _header, cs = Lazy.force disk_key_prover in\n let digest = R1CS_constraint_system.digest cs in\n ( id\n , snark_keys_header\n { type_ = \"wrap-verification-key\"; identifier = name }\n (Md5.to_hex digest)\n , digest ) )\n | Some (_, (_id, header, digest)) ->\n Lazy.return (self_id, header, digest)\n in\n let r =\n Common.time \"wrap read or generate \" (fun () ->\n Cache.Wrap.read_or_generate (* Due to Wrap_hack *)\n ~prev_challenges:2 cache disk_key_prover disk_key_verifier typ\n (Snarky_backendless.Typ.unit ())\n main )\n in\n (r, disk_key_verifier)\n in\n Timer.clock __LOC__ ;\n let wrap_vk =\n Lazy.map wrap_vk ~f:(fun ((wrap_vk, _) as res) ->\n let computed_domain_size = wrap_vk.index.domain.log_size_of_group in\n let (Pow_2_roots_of_unity proposed_domain_size) = wrap_domains.h in\n if computed_domain_size <> proposed_domain_size then\n failwithf\n \"This circuit was compiled for proofs using the wrap domain of \\\n size %d, but the actual wrap domain size for the circuit has \\\n size %d. You should pass the ~override_wrap_domain argument to \\\n set the correct domain size.\"\n proposed_domain_size computed_domain_size () ;\n res )\n in\n accum_dirty (Lazy.map wrap_pk ~f:snd) ;\n accum_dirty (Lazy.map wrap_vk ~f:snd) ;\n let wrap_vk = Lazy.map wrap_vk ~f:fst in\n let module S =\n Step.Make (Arg_var) (Arg_value)\n (struct\n include Max_proofs_verified\n end)\n in\n let (typ : (var, value) Impls.Step.Typ.t) =\n match public_input with\n | Input typ ->\n typ\n | Output typ ->\n typ\n | Input_and_output (input_typ, output_typ) ->\n Impls.Step.Typ.(input_typ * output_typ)\n in\n let provers =\n let f :\n type prev_vars prev_values local_widths local_heights.\n (prev_vars, prev_values, local_widths, local_heights) Branch_data.t\n -> Lazy_keys.t\n -> ?handler:\n ( Snarky_backendless.Request.request\n -> Snarky_backendless.Request.response )\n -> Arg_value.t\n -> ( Ret_value.t\n * Auxiliary_value.t\n * (Max_proofs_verified.n, Max_proofs_verified.n) Proof.t )\n Promise.t =\n fun (T b as branch_data) (step_pk, step_vk) ->\n let _, prev_vars_length = b.proofs_verified in\n let step handler next_state =\n let wrap_vk = Lazy.force wrap_vk in\n S.f ?handler branch_data next_state ~prevs_length:prev_vars_length\n ~self ~step_domains ~self_dlog_plonk_index:wrap_vk.commitments\n ~public_input ~auxiliary_typ ~feature_flags\n (Impls.Step.Keypair.pk (fst (Lazy.force step_pk)))\n wrap_vk.index\n in\n let step_vk = fst (Lazy.force step_vk) in\n let wrap ?handler next_state =\n let wrap_vk = Lazy.force wrap_vk in\n let%bind.Promise ( proof\n , return_value\n , auxiliary_value\n , actual_wrap_domains ) =\n step handler ~maxes:(module Maxes) next_state\n in\n let proof =\n { proof with\n statement =\n { proof.statement with\n messages_for_next_wrap_proof =\n pad_messages_for_next_wrap_proof\n (module Maxes)\n proof.statement.messages_for_next_wrap_proof\n }\n }\n in\n let%map.Promise proof =\n let tweak_statement =\n match override_wrap_main with\n | None ->\n None\n | Some { tweak_statement; wrap_main = _ } ->\n (* Extract the [tweak_statement] part of the\n [override_wrap_main], so that we can run an adversarial\n test.\n\n This function modifies the statement that will be proved\n over, and which gets passed to later recursive pickles\n rules.\n *)\n Some tweak_statement\n in\n Wrap.wrap ~max_proofs_verified:Max_proofs_verified.n ~feature_flags\n ~actual_feature_flags:b.feature_flags full_signature.maxes\n wrap_requests ?tweak_statement\n ~dlog_plonk_index:wrap_vk.commitments wrap_main ~typ ~step_vk\n ~step_plonk_indices:(Lazy.force step_vks) ~actual_wrap_domains\n (Impls.Wrap.Keypair.pk (fst (Lazy.force wrap_pk)))\n proof\n in\n ( return_value\n , auxiliary_value\n , Proof.T\n { proof with\n statement =\n { proof.statement with\n messages_for_next_step_proof =\n { proof.statement.messages_for_next_step_proof with\n app_state = ()\n }\n }\n } )\n in\n wrap\n in\n let rec go :\n type xs1 xs2 xs3 xs4.\n (xs1, xs2, xs3, xs4) H4.T(Branch_data).t\n -> (xs1, xs2, xs3, xs4) H4.T(E04(Lazy_keys)).t\n -> ( xs2\n , xs3\n , xs4\n , Arg_value.t\n , ( Ret_value.t\n * Auxiliary_value.t\n * (max_proofs_verified, max_proofs_verified) Proof.t )\n Promise.t )\n H3_2.T(Prover).t =\n fun bs ks ->\n match (bs, ks) with\n | [], [] ->\n []\n | b :: bs, k :: ks ->\n f b k :: go bs ks\n in\n go step_data step_keypairs\n in\n Timer.clock __LOC__ ;\n let data : _ Types_map.Compiled.t =\n { branches = Branches.n\n ; proofs_verifieds\n ; max_proofs_verified\n ; public_input = typ\n ; wrap_key = Lazy.map wrap_vk ~f:Verification_key.commitments\n ; wrap_vk = Lazy.map wrap_vk ~f:Verification_key.index\n ; wrap_domains\n ; step_domains\n ; feature_flags\n }\n in\n Timer.clock __LOC__ ;\n Types_map.add_exn self data ;\n (provers, wrap_vk, disk_key, !cache_handle)\nend\n\nmodule Side_loaded = struct\n module V = Verification_key\n\n module Verification_key = struct\n include Side_loaded_verification_key\n\n let to_input (t : t) =\n to_input ~field_of_int:Impls.Step.Field.Constant.of_int t\n\n let of_compiled tag : t =\n let d = Types_map.lookup_compiled tag.Tag.id in\n let actual_wrap_domain_size =\n Common.actual_wrap_domain_size\n ~log_2_domain_size:(Lazy.force d.wrap_vk).domain.log_size_of_group\n in\n { wrap_vk = Some (Lazy.force d.wrap_vk)\n ; wrap_index = Lazy.force d.wrap_key\n ; max_proofs_verified =\n Pickles_base.Proofs_verified.of_nat (Nat.Add.n d.max_proofs_verified)\n ; actual_wrap_domain_size\n }\n\n module Max_width = Width.Max\n end\n\n let in_circuit tag vk = Types_map.set_ephemeral tag { index = `In_circuit vk }\n\n let in_prover tag vk = Types_map.set_ephemeral tag { index = `In_prover vk }\n\n let create ~name ~max_proofs_verified ~feature_flags ~typ =\n Types_map.add_side_loaded ~name\n { max_proofs_verified\n ; public_input = typ\n ; branches = Verification_key.Max_branches.n\n ; feature_flags\n }\n\n module Proof = struct\n include Proof.Proofs_verified_max\n\n let of_proof : _ Proof.t -> t = Wrap_hack.pad_proof\n end\n\n let verify_promise (type t) ~(typ : (_, t) Impls.Step.Typ.t)\n (ts : (Verification_key.t * t * Proof.t) list) =\n let m =\n ( module struct\n type nonrec t = t\n\n let to_field_elements =\n let (Typ typ) = typ in\n fun x -> fst (typ.value_to_fields x)\n end : Intf.Statement_value\n with type t = t )\n in\n (* TODO: This should be the actual max width on a per proof basis *)\n let max_proofs_verified =\n (module Verification_key.Max_width : Nat.Intf\n with type n = Verification_key.Max_width.n )\n in\n with_return (fun { return } ->\n List.map ts ~f:(fun (vk, x, p) ->\n let vk : V.t =\n { commitments = vk.wrap_index\n ; index =\n ( match vk.wrap_vk with\n | None ->\n return\n (Promise.return\n (Or_error.errorf \"Pickles.verify: wrap_vk not found\") )\n | Some x ->\n x )\n ; data =\n (* This isn't used in verify_heterogeneous, so we can leave this dummy *)\n { constraints = 0 }\n }\n in\n Verify.Instance.T (max_proofs_verified, m, vk, x, p) )\n |> Verify.verify_heterogenous )\n\n let verify ~typ ts = verify_promise ~typ ts |> Promise.to_deferred\n\n let srs_precomputation () : unit =\n let srs = Tock.Keypair.load_urs () in\n List.iter [ 0; 1; 2 ] ~f:(fun i ->\n Kimchi_bindings.Protocol.SRS.Fq.add_lagrange_basis srs\n (Domain.log2_size (Common.wrap_domains ~proofs_verified:i).h) )\nend\n\nlet compile_with_wrap_main_override_promise :\n type var value a_var a_value ret_var ret_value auxiliary_var auxiliary_value prev_varss prev_valuess widthss heightss max_proofs_verified branches.\n ?self:(var, value, max_proofs_verified, branches) Tag.t\n -> ?cache:Key_cache.Spec.t list\n -> ?disk_keys:\n (Cache.Step.Key.Verification.t, branches) Vector.t\n * Cache.Wrap.Key.Verification.t\n -> ?return_early_digest_exception:bool\n -> ?override_wrap_domain:Pickles_base.Proofs_verified.t\n -> ?override_wrap_main:\n (max_proofs_verified, branches, prev_varss) wrap_main_generic\n -> public_input:\n ( var\n , value\n , a_var\n , a_value\n , ret_var\n , ret_value )\n Inductive_rule.public_input\n -> auxiliary_typ:(auxiliary_var, auxiliary_value) Impls.Step.Typ.t\n -> branches:(module Nat.Intf with type n = branches)\n -> max_proofs_verified:\n (module Nat.Add.Intf with type n = max_proofs_verified)\n -> name:string\n -> constraint_constants:Snark_keys_header.Constraint_constants.t\n -> choices:\n ( self:(var, value, max_proofs_verified, branches) Tag.t\n -> ( prev_varss\n , prev_valuess\n , widthss\n , heightss\n , a_var\n , a_value\n , ret_var\n , ret_value\n , auxiliary_var\n , auxiliary_value )\n H4_6.T(Inductive_rule).t )\n -> unit\n -> (var, value, max_proofs_verified, branches) Tag.t\n * Cache_handle.t\n * (module Proof_intf\n with type t = (max_proofs_verified, max_proofs_verified) Proof.t\n and type statement = value )\n * ( prev_valuess\n , widthss\n , heightss\n , a_value\n , ( ret_value\n * auxiliary_value\n * (max_proofs_verified, max_proofs_verified) Proof.t )\n Promise.t )\n H3_2.T(Prover).t =\n (* This function is an adapter between the user-facing Pickles.compile API\n and the underlying Make(_).compile function which builds the circuits.\n *)\n fun ?self ?(cache = []) ?disk_keys ?(return_early_digest_exception = false)\n ?override_wrap_domain ?override_wrap_main ~public_input ~auxiliary_typ\n ~branches ~max_proofs_verified ~name ~constraint_constants ~choices () ->\n let self =\n match self with\n | None ->\n Tag.(create ~kind:Compiled name)\n | Some self ->\n self\n in\n (* Extract to_fields methods from the public input declaration. *)\n let (a_var_to_fields : a_var -> _), (a_value_to_fields : a_value -> _) =\n match public_input with\n | Input (Typ typ) ->\n ( (fun x -> fst (typ.var_to_fields x))\n , fun x -> fst (typ.value_to_fields x) )\n | Output _ ->\n ((fun () -> [||]), fun () -> [||])\n | Input_and_output (Typ typ, _) ->\n ( (fun x -> fst (typ.var_to_fields x))\n , fun x -> fst (typ.value_to_fields x) )\n in\n let module A_var = struct\n type t = a_var\n\n let to_field_elements = a_var_to_fields\n end in\n let module A_value = struct\n type t = a_value\n\n let to_field_elements = a_value_to_fields\n end in\n let module Ret_var = struct\n type t = ret_var\n end in\n let module Ret_value = struct\n type t = ret_value\n end in\n let module Auxiliary_var = struct\n type t = auxiliary_var\n end in\n let module Auxiliary_value = struct\n type t = auxiliary_value\n end in\n let module M =\n Make (A_var) (A_value) (Ret_var) (Ret_value) (Auxiliary_var)\n (Auxiliary_value)\n in\n let rec conv_irs :\n type v1ss v2ss wss hss.\n ( v1ss\n , v2ss\n , wss\n , hss\n , a_var\n , a_value\n , ret_var\n , ret_value\n , auxiliary_var\n , auxiliary_value )\n H4_6.T(Inductive_rule).t\n -> (v1ss, v2ss, wss, hss) H4.T(M.IR).t = function\n | [] ->\n []\n | r :: rs ->\n r :: conv_irs rs\n in\n let provers, wrap_vk, wrap_disk_key, cache_handle =\n M.compile ~return_early_digest_exception ~self ~cache ?disk_keys\n ?override_wrap_domain ?override_wrap_main ~branches ~max_proofs_verified\n ~name ~public_input ~auxiliary_typ ~constraint_constants\n ~choices:(fun ~self -> conv_irs (choices ~self))\n ()\n in\n let (module Max_proofs_verified) = max_proofs_verified in\n let T = Max_proofs_verified.eq in\n let module Value = struct\n type t = value\n\n let typ : (var, value) Impls.Step.Typ.t =\n match public_input with\n | Input typ ->\n typ\n | Output typ ->\n typ\n | Input_and_output (input_typ, output_typ) ->\n Impls.Step.Typ.(input_typ * output_typ)\n\n let to_field_elements =\n let (Typ typ) = typ in\n fun x -> fst (typ.value_to_fields x)\n end in\n let module P = struct\n type statement = value\n\n module Max_local_max_proofs_verified = Max_proofs_verified\n\n include\n Proof.Make\n (struct\n include Max_proofs_verified\n end)\n (struct\n include Max_local_max_proofs_verified\n end)\n\n let id = wrap_disk_key\n\n let verification_key = wrap_vk\n\n let verify_promise ts =\n verify_promise\n ( module struct\n include Max_proofs_verified\n end )\n (module Value)\n (Lazy.force verification_key)\n ts\n\n let verify ts = verify_promise ts |> Promise.to_deferred\n end in\n (self, cache_handle, (module P), provers)\n\nlet wrap_main_dummy_override _ _ _ _ _ _ _ =\n let requests =\n (* The requests that the logic in [Wrap.wrap] use to pass\n values into and out of the wrap proof circuit.\n Since these are unnecessary for the dummy circuit below, we\n generate them without using them.\n *)\n Requests.Wrap.create ()\n in\n (* A replacement for the 'wrap' circuit, which makes no\n assertions about the statement that it receives as its first\n argument.\n *)\n let wrap_main _ =\n let module SC' = SC in\n let open Impls.Wrap in\n let open Wrap_main_inputs in\n (* Create some variables to be used in constraints below. *)\n let x = exists Field.typ ~compute:(fun () -> Field.Constant.of_int 3) in\n let y = exists Field.typ ~compute:(fun () -> Field.Constant.of_int 0) in\n let z = exists Field.typ ~compute:(fun () -> Field.Constant.of_int 0) in\n (* Every circuit must use at least 1 of each constraint; we\n use them here.\n *)\n let () =\n let g = Inner_curve.one in\n let sponge = Sponge.create sponge_params in\n Sponge.absorb sponge x ;\n ignore (Sponge.squeeze_field sponge : Field.t) ;\n ignore\n ( SC'.to_field_checked'\n (module Impl)\n ~num_bits:16\n (Kimchi_backend_common.Scalar_challenge.create x)\n : Field.t * Field.t * Field.t ) ;\n ignore (Ops.scale_fast g ~num_bits:5 (Shifted_value x) : Inner_curve.t) ;\n ignore\n ( Wrap_verifier.Scalar_challenge.endo g ~num_bits:4\n (Kimchi_backend_common.Scalar_challenge.create x)\n : Field.t * Field.t )\n in\n (* Pad the circuit so that its domain size matches the one\n that would have been used by the true wrap_main.\n *)\n for _ = 0 to 64000 do\n assert_r1cs x y z\n done\n in\n (requests, wrap_main)\n\nmodule Make_adversarial_test (M : sig\n val tweak_statement :\n ( Import.Challenge.Constant.t\n , Import.Challenge.Constant.t Import.Types.Scalar_challenge.t\n , Backend.Tick.Field.t Pickles_types.Shifted_value.Type1.t\n , ( Backend.Tick.Field.t Pickles_types.Shifted_value.Type1.t\n , bool )\n Import.Types.Opt.t\n , ( Import.Challenge.Constant.t Import.Types.Scalar_challenge.t\n Composition_types.Wrap.Proof_state.Deferred_values.Plonk.In_circuit\n .Lookup\n .t\n , bool )\n Import.Types.Opt.t\n , bool\n , 'max_proofs_verified\n Proof.Base.Messages_for_next_proof_over_same_field.Wrap.t\n , (int64, Composition_types.Digest.Limbs.n) Pickles_types.Vector.vec\n , ( 'b\n , ( Kimchi_pasta.Pallas_based_plonk.Proof.G.Affine.t\n , 'actual_proofs_verified )\n Pickles_types.Vector.t\n , ( ( Import.Challenge.Constant.t Import.Scalar_challenge.t\n Import.Bulletproof_challenge.t\n , 'e )\n Pickles_types.Vector.t\n , 'actual_proofs_verified )\n Pickles_types.Vector.t )\n Proof.Base.Messages_for_next_proof_over_same_field.Step.t\n , Import.Challenge.Constant.t Import.Types.Scalar_challenge.t\n Import.Types.Bulletproof_challenge.t\n Import.Types.Step_bp_vec.t\n , Import.Types.Branch_data.t )\n Import.Types.Wrap.Statement.In_circuit.t\n -> ( Import.Challenge.Constant.t\n , Import.Challenge.Constant.t Import.Types.Scalar_challenge.t\n , Backend.Tick.Field.t Pickles_types.Shifted_value.Type1.t\n , ( Backend.Tick.Field.t Pickles_types.Shifted_value.Type1.t\n , bool )\n Import.Types.Opt.t\n , ( Import.Challenge.Constant.t Import.Types.Scalar_challenge.t\n Composition_types.Wrap.Proof_state.Deferred_values.Plonk.In_circuit\n .Lookup\n .t\n , bool )\n Import.Types.Opt.t\n , bool\n , 'max_proofs_verified\n Proof.Base.Messages_for_next_proof_over_same_field.Wrap.t\n , ( Limb_vector.Constant.Hex64.t\n , Composition_types.Digest.Limbs.n )\n Pickles_types.Vector.vec\n , ( 'b\n , ( Kimchi_pasta.Pallas_based_plonk.Proof.G.Affine.t\n , 'actual_proofs_verified )\n Pickles_types.Vector.t\n , ( ( Import.Challenge.Constant.t Import.Scalar_challenge.t\n Import.Bulletproof_challenge.t\n , 'e )\n Pickles_types.Vector.t\n , 'actual_proofs_verified )\n Pickles_types.Vector.t )\n Proof.Base.Messages_for_next_proof_over_same_field.Step.t\n , Import.Challenge.Constant.t Import.Types.Scalar_challenge.t\n Import.Types.Bulletproof_challenge.t\n Import.Types.Step_bp_vec.t\n , Import.Types.Branch_data.t )\n Import.Types.Wrap.Statement.In_circuit.t\n\n val check_verifier_error : Error.t -> unit\nend) =\nstruct\n open Impls.Step\n\n let constraint_constants : Snark_keys_header.Constraint_constants.t =\n { sub_windows_per_window = 0\n ; ledger_depth = 0\n ; work_delay = 0\n ; block_window_duration_ms = 0\n ; transaction_capacity = Log_2 0\n ; pending_coinbase_depth = 0\n ; coinbase_amount = Unsigned.UInt64.of_int 0\n ; supercharged_coinbase_factor = 0\n ; account_creation_fee = Unsigned.UInt64.of_int 0\n ; fork = None\n }\n\n let rule self : _ Inductive_rule.t =\n { identifier = \"main\"\n ; prevs = [ self; self ]\n ; main =\n (fun { public_input = () } ->\n let dummy_proof =\n As_prover.Ref.create (fun () ->\n Proof.dummy Nat.N2.n Nat.N2.n Nat.N2.n ~domain_log2:15 )\n in\n { previous_proof_statements =\n [ { public_input = ()\n ; proof = dummy_proof\n ; proof_must_verify = Boolean.false_\n }\n ; { public_input = ()\n ; proof = dummy_proof\n ; proof_must_verify = Boolean.false_\n }\n ]\n ; public_output = ()\n ; auxiliary_output = ()\n } )\n ; feature_flags = Plonk_types.Features.none_bool\n }\n\n let override_wrap_main =\n { wrap_main = wrap_main_dummy_override\n ; tweak_statement = M.tweak_statement\n }\n\n let tag, _, p, ([ step ] : _ H3_2.T(Prover).t) =\n compile_with_wrap_main_override_promise () ~override_wrap_main\n ~public_input:(Input Typ.unit) ~auxiliary_typ:Typ.unit\n ~branches:(module Nat.N1)\n ~max_proofs_verified:(module Nat.N2)\n ~name:\"blockchain-snark\"\n ~constraint_constants:\n (* Dummy values *)\n { sub_windows_per_window = 0\n ; ledger_depth = 0\n ; work_delay = 0\n ; block_window_duration_ms = 0\n ; transaction_capacity = Log_2 0\n ; pending_coinbase_depth = 0\n ; coinbase_amount = Unsigned.UInt64.of_int 0\n ; supercharged_coinbase_factor = 0\n ; account_creation_fee = Unsigned.UInt64.of_int 0\n ; fork = None\n }\n ~choices:(fun ~self -> [ rule self ])\n\n module Proof = (val p)\n\n let proof_with_stmt =\n let (), (), p = Promise.block_on_async_exn (fun () -> step ()) in\n ((), p)\n\n let%test \"should not be able to verify invalid proof\" =\n match\n Promise.block_on_async_exn (fun () ->\n Proof.verify_promise [ proof_with_stmt ] )\n with\n | Ok () ->\n false\n | Error err ->\n M.check_verifier_error err ; true\n\n module Recurse_on_bad_proof = struct\n open Impls.Step\n\n type _ Snarky_backendless.Request.t +=\n | Proof : Proof.t Snarky_backendless.Request.t\n\n let handler (proof : Proof.t)\n (Snarky_backendless.Request.With { request; respond }) =\n match request with\n | Proof ->\n respond (Provide proof)\n | _ ->\n respond Unhandled\n\n let _tag, _, p, ([ step ] : _ H3_2.T(Prover).t) =\n Common.time \"compile\" (fun () ->\n compile_with_wrap_main_override_promise ()\n ~public_input:(Input Typ.unit) ~auxiliary_typ:Typ.unit\n ~branches:(module Nat.N1)\n ~max_proofs_verified:(module Nat.N2)\n ~name:\"recurse-on-bad\" ~constraint_constants\n ~choices:(fun ~self:_ ->\n [ { identifier = \"main\"\n ; feature_flags = Plonk_types.Features.none_bool\n ; prevs = [ tag; tag ]\n ; main =\n (fun { public_input = () } ->\n let proof =\n exists (Typ.Internal.ref ()) ~request:(fun () -> Proof)\n in\n { previous_proof_statements =\n [ { public_input = ()\n ; proof\n ; proof_must_verify = Boolean.true_\n }\n ; { public_input = ()\n ; proof\n ; proof_must_verify = Boolean.true_\n }\n ]\n ; public_output = ()\n ; auxiliary_output = ()\n } )\n }\n ] ) )\n\n module Proof = (val p)\n end\n\n let%test \"should not be able to create a recursive proof from an invalid \\\n proof\" =\n try\n let (), (), proof =\n Promise.block_on_async_exn (fun () ->\n Recurse_on_bad_proof.step\n ~handler:(Recurse_on_bad_proof.handler (snd proof_with_stmt))\n () )\n in\n Or_error.is_error\n @@ Promise.block_on_async_exn (fun () ->\n Recurse_on_bad_proof.Proof.verify_promise [ ((), proof) ] )\n with _ -> true\nend\n","module Make\n (Impl : Snarky_backendless.Snark_intf.Run) (B : sig\n open Impl\n\n val params : field Sponge.Params.t\n\n val to_the_alpha : field -> field\n\n module Operations : sig\n val apply_affine_map :\n field array array * field array -> field array -> field array\n end\n end) =\nstruct\n include Make_sponge.Rounds\n\n let round_table start =\n let ({ round_constants; mds } : _ Sponge.Params.t) = B.params in\n (* sbox -> mds -> ark *)\n let apply_round i s =\n let s' = Array.map s ~f:B.to_the_alpha in\n B.Operations.apply_affine_map (mds, round_constants.(i)) s'\n in\n let res =\n Array.init (rounds_full + 1) ~f:(fun _ ->\n Array.create ~len:3 Impl.Field.Constant.zero )\n in\n res.(0) <- start ;\n for i = 0 to rounds_full - 1 do\n res.(i + 1) <- apply_round i res.(i)\n done ;\n res\n\n module Field = Impl.Field\n\n let block_cipher (_params : _ Sponge.Params.t) init =\n let open Impl in\n Impl.with_label __LOC__ (fun () ->\n let t =\n exists\n (Typ.array\n ~length:Int.(rounds_full + 1)\n (Typ.array ~length:3 Field.typ) )\n ~compute:\n As_prover.(fun () -> round_table (Array.map init ~f:read_var))\n in\n t.(0) <- init ;\n (let open Kimchi_backend_common.Plonk_constraint_system.Plonk_constraint in\n with_label __LOC__ (fun () ->\n Impl.assert_\n { basic = T (Poseidon { state = t })\n ; annotation = Some \"plonk-poseidon\"\n } )) ;\n t.(Int.(Array.length t - 1)) )\n\n let add_assign ~state i x =\n state.(i) <- Util.seal (module Impl) Field.(state.(i) + x)\n\n let copy = Array.copy\nend\n","include Make_sponge.Make (Backend.Tock.Field)\n\nlet params =\n (* HACK *)\n Sponge.Params.(\n let testbit n i = Bigint.(equal (shift_right n i land one) one) in\n map pasta_q_kimchi ~f:(fun s ->\n Backend.Tock.Field.of_bits\n (List.init Backend.Tock.Field.size_in_bits\n ~f:(testbit (Bigint.of_string s)) ) ))\n","open Core_kernel\nopen Backend\nopen Pickles_types\n\n(* The actual \"accumulator\" for the wrap proof contains a vector of elements,\n each of which is a vector of bulletproof challenges.\n\n The number of such vectors is equal to the maximum proofs-verified\n amongst all the step branches that that proof is wrapping.\n\n To simplify the implementation when the number of proofs-verified\n varies across proof systems (being either 0, 1, or 2) we secretly\n pad the accumulator so that it always has exactly 2 vectors, padding\n with dummy vectors.\n\n We also then pad with the corresponding dummy commitments when proving\n wrap statements, as in `pad_accumulator` which is used in wrap.ml.\n\n We add them to the **front**, not the back, of the vector of the actual\n \"real\" accumulator values so that we can precompute the sponge states\n resulting from absorbing the padding challenges\n*)\n\nmodule Padded_length = Nat.N2\n\n(* Pad up to length 2 by preprending dummy values. *)\nlet pad_vector (type a) ~dummy (v : (a, _) Vector.t) =\n Vector.extend_front_exn v Padded_length.n dummy\n\n(* Specialized padding function. *)\nlet pad_challenges (chalss : (_ Vector.t, _) Vector.t) =\n pad_vector ~dummy:Dummy.Ipa.Wrap.challenges_computed chalss\n\n(* Specialized padding function. *)\nlet pad_accumulator (xs : (Tock.Proof.Challenge_polynomial.t, _) Vector.t) =\n pad_vector xs\n ~dummy:\n { Tock.Proof.Challenge_polynomial.commitment =\n Lazy.force Dummy.Ipa.Wrap.sg\n ; challenges = Vector.to_array Dummy.Ipa.Wrap.challenges_computed\n }\n |> Vector.to_list\n\n(* Hash the me only, padding first. *)\nlet hash_messages_for_next_wrap_proof (type n) (_max_proofs_verified : n Nat.t)\n (t :\n ( Tick.Curve.Affine.t\n , (_, n) Vector.t )\n Composition_types.Wrap.Proof_state.Messages_for_next_wrap_proof.t ) =\n let t =\n { t with\n old_bulletproof_challenges = pad_challenges t.old_bulletproof_challenges\n }\n in\n Tock_field_sponge.digest Tock_field_sponge.params\n (Composition_types.Wrap.Proof_state.Messages_for_next_wrap_proof\n .to_field_elements t ~g1:(fun ((x, y) : Tick.Curve.Affine.t) -> [ x; y ])\n )\n\n(* Pad the messages_for_next_wrap_proof of a proof *)\nlet pad_proof (type mlmb) (T p : (mlmb, _) Proof.t) :\n Proof.Proofs_verified_max.t =\n T\n { p with\n statement =\n { p.statement with\n proof_state =\n { p.statement.proof_state with\n messages_for_next_wrap_proof =\n { p.statement.proof_state.messages_for_next_wrap_proof with\n old_bulletproof_challenges =\n pad_vector\n p.statement.proof_state.messages_for_next_wrap_proof\n .old_bulletproof_challenges\n ~dummy:Dummy.Ipa.Wrap.challenges\n }\n }\n }\n }\n\nmodule Checked = struct\n let pad_challenges (chalss : (_ Vector.t, _) Vector.t) =\n pad_vector\n ~dummy:\n (Vector.map ~f:Impls.Wrap.Field.constant\n Dummy.Ipa.Wrap.challenges_computed )\n chalss\n\n let pad_commitments (commitments : _ Vector.t) =\n pad_vector\n ~dummy:\n (Tuple_lib.Double.map ~f:Impls.Step.Field.constant\n (Lazy.force Dummy.Ipa.Wrap.sg) )\n commitments\n\n (* We precompute the sponge states that would result from absorbing\n 0, 1, or 2 dummy challenge vectors. This is used to speed up hashing\n inside the circuit. *)\n let dummy_messages_for_next_wrap_proof_sponge_states =\n lazy\n (let module S = Tock_field_sponge.Field in\n let full_state s = (S.state s, s.sponge_state) in\n let sponge = S.create Tock_field_sponge.params in\n let s0 = full_state sponge in\n Vector.iter ~f:(S.absorb sponge) Dummy.Ipa.Wrap.challenges_computed ;\n let s1 = full_state sponge in\n Vector.iter ~f:(S.absorb sponge) Dummy.Ipa.Wrap.challenges_computed ;\n let s2 = full_state sponge in\n [| s0; s1; s2 |] )\n\n let hash_constant_messages_for_next_wrap_proof =\n hash_messages_for_next_wrap_proof\n\n (* TODO: No need to hash the entire bulletproof challenges. Could\n just hash the segment of the public input LDE corresponding to them\n that we compute when verifying the previous proof. That is a commitment\n to them. *)\n let hash_messages_for_next_wrap_proof (type n) (max_proofs_verified : n Nat.t)\n (t :\n ( Wrap_main_inputs.Inner_curve.t\n , ((Impls.Wrap.Field.t, Backend.Tock.Rounds.n) Vector.t, n) Vector.t )\n Composition_types.Wrap.Proof_state.Messages_for_next_wrap_proof.t ) =\n let open Wrap_main_inputs in\n let sponge =\n (* The sponge states we would reach if we absorbed the padding challenges *)\n let s = Sponge.create sponge_params in\n let state, sponge_state =\n (Lazy.force dummy_messages_for_next_wrap_proof_sponge_states).(2\n - Nat\n .to_int\n max_proofs_verified)\n in\n { s with\n state = Array.map state ~f:Impls.Wrap.Field.constant\n ; sponge_state\n }\n in\n Array.iter ~f:(Sponge.absorb sponge)\n (Composition_types.Wrap.Proof_state.Messages_for_next_wrap_proof\n .to_field_elements ~g1:Inner_curve.to_field_elements t ) ;\n Sponge.squeeze_field sponge\n\n (* Check that the pre-absorbing technique works. I.e., that it's consistent with\n the actual definition of hash_messages_for_next_wrap_proof. *)\n let%test_unit \"hash_messages_for_next_wrap_proof correct\" =\n let open Impls.Wrap in\n let test (type n) (n : n Nat.t) =\n let messages_for_next_wrap_proof :\n _ Composition_types.Wrap.Proof_state.Messages_for_next_wrap_proof.t =\n let g = Wrap_main_inputs.Inner_curve.Constant.random () in\n { Composition_types.Wrap.Proof_state.Messages_for_next_wrap_proof\n .challenge_polynomial_commitment = g\n ; old_bulletproof_challenges =\n Vector.init n ~f:(fun _ ->\n Vector.init Tock.Rounds.n ~f:(fun _ -> Tock.Field.random ()) )\n }\n in\n Internal_Basic.Test.test_equal ~sexp_of_t:Field.Constant.sexp_of_t\n ~equal:Field.Constant.equal\n (Composition_types.Wrap.Proof_state.Messages_for_next_wrap_proof.typ\n Wrap_main_inputs.Inner_curve.typ\n (Vector.typ Field.typ Backend.Tock.Rounds.n)\n ~length:n )\n Field.typ\n (fun t -> make_checked (fun () -> hash_messages_for_next_wrap_proof n t))\n (fun t ->\n hash_constant_messages_for_next_wrap_proof n t\n |> Digest.Constant.to_bits |> Impls.Wrap.Field.Constant.project )\n messages_for_next_wrap_proof\n in\n test Nat.N0.n ; test Nat.N1.n ; test Nat.N2.n\nend\n","open Pickles_types\nopen Import\nopen Backend\n\ntype dlog_opening = (Tock.Curve.Affine.t, Tock.Field.t) Types.Step.Bulletproof.t\n\nmodule Constant = struct\n (* Out-of-circuit type for wrap proofs *)\n type t =\n { messages : Tock.Curve.Affine.t Plonk_types.Messages.t\n ; opening : dlog_opening\n }\n [@@deriving hlist]\nend\n\nopen Step_main_inputs\n\nmodule Checked = struct\n (* In-circuit type for wrap proofs *)\n type t =\n { messages :\n (Inner_curve.t, Impl.Boolean.var) Plonk_types.Messages.In_circuit.t\n ; opening :\n ( Inner_curve.t\n , Impls.Step.Other_field.t Shifted_value.Type2.t )\n Types.Step.Bulletproof.t\n }\n [@@deriving hlist]\nend\n\nopen Impls.Step\n\nlet typ : (Checked.t, Constant.t) Typ.t =\n let shift = Shifted_value.Type2.Shift.create (module Tock.Field) in\n Typ.of_hlistable ~var_to_hlist:Checked.to_hlist ~var_of_hlist:Checked.of_hlist\n ~value_to_hlist:Constant.to_hlist ~value_of_hlist:Constant.of_hlist\n [ Plonk_types.Messages.typ\n (module Impl)\n Inner_curve.typ Plonk_types.Features.none ~bool:Boolean.typ\n ~dummy:Inner_curve.Params.one\n ~commitment_lengths:(Commitment_lengths.create ~of_int:(fun x -> x))\n ; Types.Step.Bulletproof.typ ~length:(Nat.to_int Tock.Rounds.n)\n ( Typ.transport Other_field.typ\n ~there:(fun x ->\n (* When storing, make it a shifted value *)\n match\n Shifted_value.Type2.of_field (module Tock.Field) ~shift x\n with\n | Shifted_value x ->\n x )\n ~back:(fun x ->\n Shifted_value.Type2.to_field\n (module Tock.Field)\n ~shift (Shifted_value x) )\n (* When reading, unshift *)\n |> Typ.transport_var\n (* For the var, we just wrap the now shifted underlying value. *)\n ~there:(fun (Shifted_value.Type2.Shifted_value x) -> x)\n ~back:(fun x -> Shifted_value x) )\n Inner_curve.typ\n ]\n","open Core_kernel\n\ntype ('var, 'value, 'n1, 'n2) id = ('var * 'value * 'n1 * 'n2) Type_equal.Id.t\n\ntype kind = Side_loaded | Compiled\n\ntype ('var, 'value, 'n1, 'n2) t =\n { kind : kind; id : ('var, 'value, 'n1, 'n2) id }\n[@@deriving fields]\n\nlet create ?(kind = Compiled) name =\n { kind; id = Type_equal.Id.create ~name sexp_of_opaque }\n","open Pickles_types.Poly_types\nopen Pickles_types.Hlist\n\nmodule B = struct\n type t = Impls.Step.Boolean.var\nend\n\nmodule Previous_proof_statement = struct\n type ('prev_var, 'width) t =\n { public_input : 'prev_var\n ; proof : ('width, 'width) Proof.t Impls.Step.As_prover.Ref.t\n ; proof_must_verify : B.t\n }\n\n module Constant = struct\n type ('prev_value, 'width) t =\n { public_input : 'prev_value\n ; proof : ('width, 'width) Proof.t\n ; proof_must_verify : bool\n }\n end\nend\n\n(** This type relates the types of the input and output types of an inductive\n rule's [main] function to the type of the public input to the resulting\n circuit.\n*)\ntype ('var, 'value, 'input_var, 'input_value, 'ret_var, 'ret_value) public_input =\n | Input :\n ('var, 'value) Impls.Step.Typ.t\n -> ('var, 'value, 'var, 'value, unit, unit) public_input\n | Output :\n ('ret_var, 'ret_value) Impls.Step.Typ.t\n -> ('ret_var, 'ret_value, unit, unit, 'ret_var, 'ret_value) public_input\n | Input_and_output :\n ('var, 'value) Impls.Step.Typ.t * ('ret_var, 'ret_value) Impls.Step.Typ.t\n -> ( 'var * 'ret_var\n , 'value * 'ret_value\n , 'var\n , 'value\n , 'ret_var\n , 'ret_value )\n public_input\n\n(** The input type of an inductive rule's main function. *)\ntype 'public_input main_input =\n { public_input : 'public_input\n (** The publicly-exposed input to the circuit's main function. *)\n }\n\n(** The return type of an inductive rule's main function. *)\ntype ('prev_vars, 'widths, 'public_output, 'auxiliary_output) main_return =\n { previous_proof_statements :\n ('prev_vars, 'widths) H2.T(Previous_proof_statement).t\n (** A list of booleans, determining whether each previous proof must\n verify.\n *)\n ; public_output : 'public_output\n (** The publicly-exposed output from the circuit's main function. *)\n ; auxiliary_output : 'auxiliary_output\n (** The auxiliary output from the circuit's main function. This value\n is returned to the prover, but not exposed to or used by verifiers.\n *)\n }\n\n(** This type models an \"inductive rule\". It includes\n - the list of previous statements which this one assumes\n - the snarky main function\n\n The types parameters are:\n - ['prev_vars] the tuple-list of public input circuit types to the previous\n proofs.\n - For example, [Boolean.var * (Boolean.var * unit)] represents 2 previous\n proofs whose public inputs are booleans\n - ['prev_values] the tuple-list of public input non-circuit types to the\n previous proofs.\n - For example, [bool * (bool * unit)] represents 2 previous proofs whose\n public inputs are booleans.\n - ['widths] is a tuple list of the maximum number of previous proofs each\n previous proof itself had.\n - For example, [Nat.z Nat.s * (Nat.z * unit)] represents 2 previous\n proofs where the first has at most 1 previous proof and the second had\n zero previous proofs.\n - ['heights] is a tuple list of the number of inductive rules in each of\n the previous proofs\n - For example, [Nat.z Nat.s Nat.s * (Nat.z Nat.s * unit)] represents 2\n previous proofs where the first had 2 inductive rules and the second\n had 1.\n - ['a_var] is the in-circuit type of the [main] function's public input.\n - ['a_value] is the out-of-circuit type of the [main] function's public\n input.\n - ['ret_var] is the in-circuit type of the [main] function's public output.\n - ['ret_value] is the out-of-circuit type of the [main] function's public\n output.\n - ['auxiliary_var] is the in-circuit type of the [main] function's\n auxiliary data, to be returned to the prover but not exposed in the\n public input.\n - ['auxiliary_value] is the out-of-circuit type of the [main] function's\n auxiliary data, to be returned to the prover but not exposed in the\n public input.\n*)\ntype ( 'prev_vars\n , 'prev_values\n , 'widths\n , 'heights\n , 'a_var\n , 'a_value\n , 'ret_var\n , 'ret_value\n , 'auxiliary_var\n , 'auxiliary_value )\n t =\n { identifier : string\n ; prevs : ('prev_vars, 'prev_values, 'widths, 'heights) H4.T(Tag).t\n ; main :\n 'a_var main_input\n -> ('prev_vars, 'widths, 'ret_var, 'auxiliary_var) main_return\n ; feature_flags : bool Pickles_types.Plonk_types.Features.t\n }\n\nmodule T\n (Statement : T0)\n (Statement_value : T0)\n (Return_var : T0)\n (Return_value : T0)\n (Auxiliary_var : T0)\n (Auxiliary_value : T0) =\nstruct\n type nonrec ('prev_vars, 'prev_values, 'widths, 'heights) t =\n ( 'prev_vars\n , 'prev_values\n , 'widths\n , 'heights\n , Statement.t\n , Statement_value.t\n , Return_var.t\n , Return_value.t\n , Auxiliary_var.t\n , Auxiliary_value.t )\n t\nend\n","open Core_kernel\nopen Pickles_types\nopen Import\nopen Backend\n\n(* We maintain a global hash table which stores for each inductive proof system some\n data.\n*)\ntype inner_curve_var =\n Tick.Field.t Snarky_backendless.Cvar.t\n * Tick.Field.t Snarky_backendless.Cvar.t\n\nmodule Basic = struct\n type ('var, 'value, 'n1, 'n2) t =\n { max_proofs_verified : (module Nat.Add.Intf with type n = 'n1)\n ; public_input : ('var, 'value) Impls.Step.Typ.t\n ; branches : 'n2 Nat.t\n ; wrap_domains : Domains.t\n ; wrap_key : Tick.Inner_curve.Affine.t Plonk_verification_key_evals.t\n ; wrap_vk : Impls.Wrap.Verification_key.t\n ; feature_flags : Plonk_types.Opt.Flag.t Plonk_types.Features.t\n }\nend\n\nmodule Side_loaded = struct\n module Ephemeral = struct\n type t =\n { index :\n [ `In_circuit of Side_loaded_verification_key.Checked.t\n | `In_prover of Side_loaded_verification_key.t\n | `In_both of\n Side_loaded_verification_key.t\n * Side_loaded_verification_key.Checked.t ]\n }\n end\n\n module Permanent = struct\n type ('var, 'value, 'n1, 'n2) t =\n { max_proofs_verified : (module Nat.Add.Intf with type n = 'n1)\n ; public_input : ('var, 'value) Impls.Step.Typ.t\n ; feature_flags : Plonk_types.Opt.Flag.t Plonk_types.Features.t\n ; branches : 'n2 Nat.t\n }\n end\n\n type ('var, 'value, 'n1, 'n2) t =\n { ephemeral : Ephemeral.t option\n ; permanent : ('var, 'value, 'n1, 'n2) Permanent.t\n }\n\n type packed =\n | T : ('var, 'value, 'n1, 'n2) Tag.id * ('var, 'value, 'n1, 'n2) t -> packed\n\n let to_basic\n { permanent =\n { max_proofs_verified; public_input; branches; feature_flags }\n ; ephemeral\n } =\n let wrap_key, wrap_vk =\n match ephemeral with\n | Some { index = `In_prover i | `In_both (i, _) } ->\n (i.wrap_index, i.wrap_vk)\n | _ ->\n failwithf \"Side_loaded.to_basic: Expected `In_prover (%s)\" __LOC__ ()\n in\n let proofs_verified = Nat.to_int (Nat.Add.n max_proofs_verified) in\n let wrap_vk = Option.value_exn ~here:[%here] wrap_vk in\n { Basic.max_proofs_verified\n ; wrap_vk\n ; public_input\n ; branches\n ; wrap_domains = Common.wrap_domains ~proofs_verified\n ; wrap_key\n ; feature_flags\n }\nend\n\nmodule Compiled = struct\n type ('a_var, 'a_value, 'max_proofs_verified, 'branches) basic =\n { public_input : ('a_var, 'a_value) Impls.Step.Typ.t\n ; proofs_verifieds : (int, 'branches) Vector.t\n (* For each branch in this rule, how many predecessor proofs does it have? *)\n ; wrap_domains : Domains.t\n ; step_domains : (Domains.t, 'branches) Vector.t\n ; feature_flags : Plonk_types.Opt.Flag.t Plonk_types.Features.t\n }\n\n (* This is the data associated to an inductive proof system with statement type\n ['a_var], which has ['branches] many \"variants\" each of which depends on at most\n ['max_proofs_verified] many previous statements. *)\n type ('a_var, 'a_value, 'max_proofs_verified, 'branches) t =\n { branches : 'branches Nat.t\n ; max_proofs_verified :\n (module Nat.Add.Intf with type n = 'max_proofs_verified)\n ; proofs_verifieds : (int, 'branches) Vector.t\n (* For each branch in this rule, how many predecessor proofs does it have? *)\n ; public_input : ('a_var, 'a_value) Impls.Step.Typ.t\n ; wrap_key : Tick.Inner_curve.Affine.t Plonk_verification_key_evals.t Lazy.t\n ; wrap_vk : Impls.Wrap.Verification_key.t Lazy.t\n ; wrap_domains : Domains.t\n ; step_domains : (Domains.t, 'branches) Vector.t\n ; feature_flags : Plonk_types.Opt.Flag.t Plonk_types.Features.t\n }\n\n type packed =\n | T : ('var, 'value, 'n1, 'n2) Tag.id * ('var, 'value, 'n1, 'n2) t -> packed\n\n let to_basic\n { branches = _\n ; max_proofs_verified\n ; proofs_verifieds = _\n ; public_input\n ; wrap_vk\n ; wrap_domains\n ; step_domains\n ; wrap_key\n ; feature_flags\n } =\n { Basic.max_proofs_verified\n ; wrap_domains\n ; public_input\n ; branches = Vector.length step_domains\n ; wrap_key = Lazy.force wrap_key\n ; wrap_vk = Lazy.force wrap_vk\n ; feature_flags\n }\nend\n\nmodule For_step = struct\n type ('a_var, 'a_value, 'max_proofs_verified, 'branches) t =\n { branches : 'branches Nat.t\n ; max_proofs_verified :\n (module Nat.Add.Intf with type n = 'max_proofs_verified)\n ; proofs_verifieds :\n [ `Known of (Impls.Step.Field.t, 'branches) Vector.t | `Side_loaded ]\n ; public_input : ('a_var, 'a_value) Impls.Step.Typ.t\n ; wrap_key : inner_curve_var Plonk_verification_key_evals.t\n ; wrap_domain :\n [ `Known of Domain.t\n | `Side_loaded of\n Impls.Step.field Pickles_base.Proofs_verified.One_hot.Checked.t ]\n ; step_domains : [ `Known of (Domains.t, 'branches) Vector.t | `Side_loaded ]\n ; feature_flags : Plonk_types.Opt.Flag.t Plonk_types.Features.t\n }\n\n let of_side_loaded (type a b c d)\n ({ ephemeral\n ; permanent =\n { branches; max_proofs_verified; public_input; feature_flags }\n } :\n (a, b, c, d) Side_loaded.t ) : (a, b, c, d) t =\n let index =\n match ephemeral with\n | Some { index = `In_circuit i | `In_both (_, i) } ->\n i\n | _ ->\n failwithf \"For_step.side_loaded: Expected `In_circuit (%s)\" __LOC__ ()\n in\n let T = Nat.eq_exn branches Side_loaded_verification_key.Max_branches.n in\n { branches\n ; max_proofs_verified\n ; public_input\n ; proofs_verifieds = `Side_loaded\n ; wrap_key = index.wrap_index\n ; wrap_domain = `Side_loaded index.actual_wrap_domain_size\n ; step_domains = `Side_loaded\n ; feature_flags\n }\n\n let of_compiled\n ({ branches\n ; max_proofs_verified\n ; proofs_verifieds\n ; public_input\n ; wrap_key\n ; wrap_domains\n ; step_domains\n ; feature_flags\n ; wrap_vk = _\n } :\n _ Compiled.t ) =\n { branches\n ; max_proofs_verified\n ; proofs_verifieds =\n `Known (Vector.map proofs_verifieds ~f:Impls.Step.Field.of_int)\n ; public_input\n ; wrap_key =\n Plonk_verification_key_evals.map (Lazy.force wrap_key)\n ~f:Step_main_inputs.Inner_curve.constant\n ; wrap_domain = `Known wrap_domains.h\n ; step_domains = `Known step_domains\n ; feature_flags\n }\nend\n\ntype t =\n { compiled : Compiled.packed Type_equal.Id.Uid.Table.t\n ; side_loaded : Side_loaded.packed Type_equal.Id.Uid.Table.t\n }\n\nlet univ : t =\n { compiled = Type_equal.Id.Uid.Table.create ()\n ; side_loaded = Type_equal.Id.Uid.Table.create ()\n }\n\nlet find t k =\n match Hashtbl.find t k with None -> failwith \"key not found\" | Some x -> x\n\nlet lookup_compiled :\n type var value n m.\n (var, value, n, m) Tag.id -> (var, value, n, m) Compiled.t =\n fun t ->\n let (T (other_id, d)) = find univ.compiled (Type_equal.Id.uid t) in\n let T = Type_equal.Id.same_witness_exn t other_id in\n d\n\nlet lookup_side_loaded :\n type var value n m.\n (var, value, n, m) Tag.id -> (var, value, n, m) Side_loaded.t =\n fun t ->\n let (T (other_id, d)) = find univ.side_loaded (Type_equal.Id.uid t) in\n let T = Type_equal.Id.same_witness_exn t other_id in\n d\n\nlet lookup_basic :\n type var value n m. (var, value, n, m) Tag.t -> (var, value, n, m) Basic.t =\n fun t ->\n match t.kind with\n | Compiled ->\n Compiled.to_basic (lookup_compiled t.id)\n | Side_loaded ->\n Side_loaded.to_basic (lookup_side_loaded t.id)\n\nlet max_proofs_verified :\n type n1. (_, _, n1, _) Tag.t -> (module Nat.Add.Intf with type n = n1) =\n fun tag ->\n match tag.kind with\n | Compiled ->\n (lookup_compiled tag.id).max_proofs_verified\n | Side_loaded ->\n (lookup_side_loaded tag.id).permanent.max_proofs_verified\n\nlet public_input :\n type var value. (var, value, _, _) Tag.t -> (var, value) Impls.Step.Typ.t =\n fun tag ->\n match tag.kind with\n | Compiled ->\n (lookup_compiled tag.id).public_input\n | Side_loaded ->\n (lookup_side_loaded tag.id).permanent.public_input\n\nlet feature_flags :\n type var value.\n (var, value, _, _) Tag.t -> Plonk_types.Opt.Flag.t Plonk_types.Features.t =\n fun tag ->\n match tag.kind with\n | Compiled ->\n (lookup_compiled tag.id).feature_flags\n | Side_loaded ->\n (lookup_side_loaded tag.id).permanent.feature_flags\n\nlet _value_to_field_elements :\n type a. (_, a, _, _) Tag.t -> a -> Backend.Tick.Field.t array =\n fun t ->\n let (Typ typ) = public_input t in\n fun x -> fst (typ.value_to_fields x)\n\nlet _lookup_map (type var value c d) (t : (var, value, c, d) Tag.t) ~self\n ~default\n ~(f :\n [ `Compiled of (var, value, c, d) Compiled.t\n | `Side_loaded of (var, value, c, d) Side_loaded.t ]\n -> _ ) =\n match Type_equal.Id.same_witness t.id self with\n | Some _ ->\n default\n | None -> (\n match t.kind with\n | Compiled ->\n let (T (other_id, d)) = find univ.compiled (Type_equal.Id.uid t.id) in\n let T = Type_equal.Id.same_witness_exn t.id other_id in\n f (`Compiled d)\n | Side_loaded ->\n let (T (other_id, d)) =\n find univ.side_loaded (Type_equal.Id.uid t.id)\n in\n let T = Type_equal.Id.same_witness_exn t.id other_id in\n f (`Side_loaded d) )\n\nlet add_side_loaded ~name permanent =\n let (Tag.{ id; _ } as tag) = Tag.(create ~kind:Side_loaded name) in\n Hashtbl.add_exn univ.side_loaded ~key:(Type_equal.Id.uid id)\n ~data:(T (id, { ephemeral = None; permanent })) ;\n tag\n\nlet set_ephemeral { Tag.kind; id } (eph : Side_loaded.Ephemeral.t) =\n assert (match kind with Side_loaded -> true | Compiled -> false) ;\n Hashtbl.update univ.side_loaded (Type_equal.Id.uid id) ~f:(function\n | None ->\n assert false\n | Some (T (id, d)) ->\n let ephemeral =\n match (d.ephemeral, eph.index) with\n | None, _ | Some _, `In_prover _ ->\n (* Giving prover only always resets. *)\n Some eph\n | Some { index = `In_prover prover }, `In_circuit circuit\n | Some { index = `In_both (prover, _) }, `In_circuit circuit ->\n (* In-circuit extends prover if one was given. *)\n Some { index = `In_both (prover, circuit) }\n | _ ->\n (* Otherwise, just use the given value. *)\n Some eph\n in\n T (id, { d with ephemeral }) )\n\nlet add_exn (type var value c d) (tag : (var, value, c, d) Tag.t)\n (data : (var, value, c, d) Compiled.t) =\n Hashtbl.add_exn univ.compiled ~key:(Type_equal.Id.uid tag.id)\n ~data:(Compiled.T (tag.id, data))\n","open Backend\nopen Pickles_types\nopen Import\nmodule Impl = Impls.Step\nmodule One_hot_vector = One_hot_vector.Make (Impl)\n\n(* Let F, K be the two fields (either (Fp, Fq) or (Fq, Fp)).\n Each proof over F has an accumulator state which contains\n - a set of IPA challenges c_0, ..., c_{k-1}, which can be interpreted as F elements.\n - a polynomial commitment challenge_polynomial_commitment, which has coordinates in K.\n\n This part of the accumulator state is finalized by checking that challenge_polynomial_commitment\n is a commitment to the polynomial\n\n f_c := prod_{i = 0}^{k-1} (1 + c_i x^{2^{k-1 - i}})\n\n When incrementally-verifying such a proof in a K-circuit (since we need K-arithmetic to perform\n the group operations on the F-polynomial-commitments that constitute the proof),\n instead of checking this, we get an evaluation E_c at a random point zeta and check\n that challenge_polynomial_commitment opens to E_c at zeta. Then we will need to check that\n E_c = f_c(zeta) = prod_{i = 0}^{k-1} (1 + c_i zeta^{2^{k-1 - i}}).\n\n However, because we are then in a K-circuit, we cannot actually compute f_c(zeta), which requires\n F-arithmetic.\n\n Therefore, after incrementally verifying the F-proof, the challenges (c_0, ..., c_{k-1}) which are\n part of the accumulator of the F-proof we just incrementally verified, must remain part of\n the accumulator of the K-proof, along with E_c (or at least some kind of commitment to it, which is\n what we actually do).\n\n Then, when we incrementally verify that K-proof in an F-circuit, we will check that E_c was\n computed correctly using c_0, ..., c_{k-1} and they along with E_c can be discarded.\n\n So, to summarize, the accumulator state for each proof P (corresponding to an F-circuit)\n contains\n - a set of IPA challenges (thought of as K-elements) for every proof that it incrementally verified inside its circuit\n - a challenge_polynomial_commitment (coordinates in F) for every proof that it incrementally verified inside its circuit\n - a challenge_polynomial_commitment (coordinates in K) corresponding to P's own inner-product argument\n - a set of IPA challenges (thought of as F-elements) corresponding to P's own inner-product argument\n*)\n\ntype challenge = Challenge.Make(Impl).t\n\ntype scalar_challenge = challenge Scalar_challenge.t\n\n(** Represents a proof (along with its accumulation state) which wraps a\n \"step\" proof S on the other curve.\n\n To have some notation, the proof S itself comes from a circuit that verified\n up to 'max_proofs_verified many wrap proofs W_0, ..., W_max_proofs_verified.\n*)\ntype ('app_state, 'max_proofs_verified, 'num_branches) t =\n { app_state : 'app_state\n (** The user-level statement corresponding to this proof. *)\n ; wrap_proof : Wrap_proof.Checked.t\n (** The polynomial commitments, polynomial evaluations, and opening proof corresponding to\n this latest wrap proof.\n *)\n ; proof_state :\n ( challenge\n , scalar_challenge\n , Impl.Field.t Shifted_value.Type1.t\n , ( Impl.Field.t Pickles_types.Shifted_value.Type1.t\n , Impl.Boolean.var )\n Plonk_types.Opt.t\n , ( scalar_challenge\n Types.Wrap.Proof_state.Deferred_values.Plonk.In_circuit.Lookup.t\n , Impl.Boolean.var )\n Plonk_types.Opt.t\n , Impl.Boolean.var\n , unit\n , Digest.Make(Impl).t\n , scalar_challenge Types.Bulletproof_challenge.t Types.Step_bp_vec.t\n , Impl.field Branch_data.Checked.t )\n Types.Wrap.Proof_state.In_circuit.t\n (** The accumulator state corresponding to the above proof. Contains\n - `deferred_values`: The values necessary for finishing the deferred \"scalar field\" computations.\n That is, computations which are over the \"step\" circuit's internal field that the\n previous \"wrap\" circuit was unable to verify directly, due to its internal field\n being different.\n - `sponge_digest_before_evaluations`: the sponge state: TODO\n - `messages_for_next_wrap_proof`\n *)\n ; prev_proof_evals :\n ( Impl.Field.t\n , Impl.Field.t array\n , Impl.Boolean.var )\n Plonk_types.All_evals.In_circuit.t\n (** The evaluations from the step proof that this proof wraps *)\n ; prev_challenges :\n ((Impl.Field.t, Tick.Rounds.n) Vector.t, 'max_proofs_verified) Vector.t\n (** The challenges c_0, ... c_{k - 1} corresponding to each W_i. *)\n ; prev_challenge_polynomial_commitments :\n (Step_main_inputs.Inner_curve.t, 'max_proofs_verified) Vector.t\n (** The commitments to the \"challenge polynomials\" \\prod_{i = 0}^k (1 + c_{k - 1 - i} x^{2^i})\n corresponding to each of the \"prev_challenges\".\n *)\n }\n[@@deriving hlist]\n\nmodule No_app_state = struct\n type nonrec (_, 'max_proofs_verified, 'num_branches) t =\n (unit, 'max_proofs_verified, 'num_branches) t\nend\n\nmodule Constant = struct\n type challenge = Challenge.Constant.t\n\n type scalar_challenge = challenge Scalar_challenge.t\n\n type ('statement, 'max_proofs_verified) t =\n { app_state : 'statement\n ; wrap_proof : Wrap_proof.Constant.t\n ; proof_state :\n ( challenge\n , scalar_challenge\n , Tick.Field.t Shifted_value.Type1.t\n , Tick.Field.t Shifted_value.Type1.t option\n , scalar_challenge\n Types.Wrap.Proof_state.Deferred_values.Plonk.In_circuit.Lookup.t\n option\n , bool\n , unit\n , Digest.Constant.t\n , scalar_challenge Types.Bulletproof_challenge.t Types.Step_bp_vec.t\n , Branch_data.t )\n Types.Wrap.Proof_state.In_circuit.t\n ; prev_proof_evals :\n (Tick.Field.t, Tick.Field.t array) Plonk_types.All_evals.t\n ; prev_challenges :\n ((Tick.Field.t, Tick.Rounds.n) Vector.t, 'max_proofs_verified) Vector.t\n ; prev_challenge_polynomial_commitments :\n (Tick.Inner_curve.Affine.t, 'max_proofs_verified) Vector.t\n }\n [@@deriving hlist]\n\n module No_app_state = struct\n type nonrec (_, 'max_proofs_verified, _) t = (unit, 'max_proofs_verified) t\n end\nend\n\nlet typ (type n avar aval) ~feature_flags\n (statement : (avar, aval) Impls.Step.Typ.t) (max_proofs_verified : n Nat.t)\n =\n let module Sc = Scalar_challenge in\n let open Impls.Step in\n let open Step_main_inputs in\n let open Step_verifier in\n Snarky_backendless.Typ.of_hlistable ~var_to_hlist:to_hlist\n ~var_of_hlist:of_hlist ~value_to_hlist:Constant.to_hlist\n ~value_of_hlist:Constant.of_hlist\n [ statement\n ; Wrap_proof.typ\n ; Types.Wrap.Proof_state.In_circuit.typ\n (module Impl)\n ~challenge:Challenge.typ ~scalar_challenge:Challenge.typ ~feature_flags\n ~dummy_scalar:(Shifted_value.Type1.Shifted_value Field.Constant.zero)\n ~dummy_scalar_challenge:(Sc.create Limb_vector.Challenge.Constant.zero)\n (Shifted_value.Type1.typ Field.typ)\n (Snarky_backendless.Typ.unit ())\n Digest.typ\n (Branch_data.typ\n (module Impl)\n ~assert_16_bits:(Step_verifier.assert_n_bits ~n:16) )\n ; Plonk_types.All_evals.typ\n (module Impl)\n (* Assume we have lookup iff we have runtime tables *)\n feature_flags\n ; Vector.typ (Vector.typ Field.typ Tick.Rounds.n) max_proofs_verified\n ; Vector.typ Inner_curve.typ max_proofs_verified\n ]\n","open Core_kernel\nopen Backend\nopen Impls.Step\nopen Pickles_types\nopen Common\nopen Import\nmodule Shifted_value = Shifted_value.Type2\n\n(* Unfinalized dlog-based proof, along with a flag which is true iff it\n is expected to verify. This allows for situations like the blockchain\n SNARK where we let the previous proof fail in the base case.\n*)\ntype t =\n ( Field.t\n , Field.t Scalar_challenge.t\n , Other_field.t Shifted_value.t\n , ( Field.t Scalar_challenge.t Bulletproof_challenge.t\n , Tock.Rounds.n )\n Pickles_types.Vector.t\n , Field.t\n , Boolean.var )\n Types.Step.Proof_state.Per_proof.In_circuit.t\n\nmodule Plonk_checks = struct\n include Plonk_checks\n include Plonk_checks.Make (Shifted_value) (Plonk_checks.Scalars.Tock)\nend\n\nmodule Constant = struct\n type t =\n ( Challenge.Constant.t\n , Challenge.Constant.t Scalar_challenge.t\n , Tock.Field.t Shifted_value.t\n , ( Challenge.Constant.t Scalar_challenge.t Bulletproof_challenge.t\n , Tock.Rounds.n )\n Vector.t\n , Digest.Constant.t\n , bool )\n Types.Step.Proof_state.Per_proof.In_circuit.t\n\n let shift = Shifted_value.Shift.create (module Tock.Field)\n\n let dummy : t Lazy.t =\n lazy\n (let one_chal = Challenge.Constant.dummy in\n let open Ro in\n let alpha = scalar_chal () in\n let beta = chal () in\n let gamma = chal () in\n let zeta = scalar_chal () in\n let chals :\n _ Composition_types.Wrap.Proof_state.Deferred_values.Plonk.Minimal.t\n =\n { alpha = Common.Ipa.Wrap.endo_to_field alpha\n ; beta = Challenge.Constant.to_tock_field beta\n ; gamma = Challenge.Constant.to_tock_field gamma\n ; zeta = Common.Ipa.Wrap.endo_to_field zeta\n ; joint_combiner = None\n ; feature_flags = Plonk_types.Features.none_bool\n }\n in\n let evals =\n Plonk_types.Evals.to_in_circuit Dummy.evals_combined.evals.evals\n in\n let env =\n let module Env_bool = struct\n type t = bool\n\n let true_ = true\n\n let false_ = false\n\n let ( &&& ) = ( && )\n\n let ( ||| ) = ( || )\n\n let any = List.exists ~f:Fn.id\n end in\n let module Env_field = struct\n include Tock.Field\n\n type bool = Env_bool.t\n\n let if_ (b : bool) ~then_ ~else_ = if b then then_ () else else_ ()\n end in\n Plonk_checks.scalars_env\n (module Env_bool)\n (module Env_field)\n ~srs_length_log2:Common.Max_degree.wrap_log2\n ~endo:Endo.Wrap_inner_curve.base ~mds:Tock_field_sponge.params.mds\n ~field_of_hex:\n (Core_kernel.Fn.compose Tock.Field.of_bigint (fun x ->\n Kimchi_pasta.Pasta.Bigint256.of_hex_string x ) )\n ~domain:\n (Plonk_checks.domain\n (module Tock.Field)\n (wrap_domains ~proofs_verified:2).h ~shifts:Common.tock_shifts\n ~domain_generator:Tock.Field.domain_generator )\n chals evals\n in\n let plonk =\n let module Field = struct\n include Tock.Field\n end in\n Plonk_checks.derive_plonk (module Field) ~env ~shift chals evals\n |> Composition_types.Step.Proof_state.Deferred_values.Plonk.In_circuit\n .of_wrap\n ~assert_none:(fun x ->\n assert (Option.is_none (Plonk_types.Opt.to_option x)) )\n ~assert_false:(fun x -> assert (not x))\n in\n { deferred_values =\n { plonk = { plonk with alpha; beta; gamma; zeta }\n ; combined_inner_product = Shifted_value (tock ())\n ; xi = Scalar_challenge.create one_chal\n ; bulletproof_challenges = Dummy.Ipa.Wrap.challenges\n ; b = Shifted_value (tock ())\n }\n ; should_finalize = false\n ; sponge_digest_before_evaluations = Digest.Constant.dummy\n } )\nend\n\nlet typ ~wrap_rounds:_ : (t, Constant.t) Typ.t =\n Types.Step.Proof_state.Per_proof.typ\n (module Impl)\n (Shifted_value.typ Other_field.typ)\n ~assert_16_bits:(Step_verifier.assert_n_bits ~n:16)\n ~zero:Common.Lookup_parameters.tick_zero\n\nlet dummy : unit -> t =\n Memo.unit (fun () ->\n let (Typ { var_of_fields; value_to_fields; _ }) =\n typ ~wrap_rounds:Backend.Tock.Rounds.n\n in\n let xs, aux = value_to_fields (Lazy.force Constant.dummy) in\n var_of_fields (Array.map ~f:Field.constant xs, aux) )\n","open Import\nopen Types\nopen Pickles_types\nopen Hlist\nopen Snarky_backendless.Request\nopen Backend\n\nmodule Wrap = struct\n module type S = sig\n type max_proofs_verified\n\n type max_local_max_proofs_verifieds\n\n open Impls.Wrap\n open Snarky_backendless.Request\n\n type _ t +=\n | Evals :\n ( (Field.Constant.t, Field.Constant.t array) Plonk_types.All_evals.t\n , max_proofs_verified )\n Vector.t\n t\n | Which_branch : int t\n | Step_accs : (Tock.Inner_curve.Affine.t, max_proofs_verified) Vector.t t\n | Old_bulletproof_challenges :\n max_local_max_proofs_verifieds H1.T(Challenges_vector.Constant).t t\n | Proof_state :\n ( ( ( Challenge.Constant.t\n , Challenge.Constant.t Scalar_challenge.t\n , Field.Constant.t Shifted_value.Type2.t\n , ( Challenge.Constant.t Scalar_challenge.t Bulletproof_challenge.t\n , Tock.Rounds.n )\n Vector.t\n , Digest.Constant.t\n , bool )\n Types.Step.Proof_state.Per_proof.In_circuit.t\n , max_proofs_verified )\n Vector.t\n , Digest.Constant.t )\n Types.Step.Proof_state.t\n t\n | Messages : Tock.Inner_curve.Affine.t Plonk_types.Messages.t t\n | Openings_proof :\n ( Tock.Inner_curve.Affine.t\n , Tick.Field.t )\n Plonk_types.Openings.Bulletproof.t\n t\n | Wrap_domain_indices : (Field.Constant.t, max_proofs_verified) Vector.t t\n end\n\n type ('mb, 'ml) t =\n (module S\n with type max_proofs_verified = 'mb\n and type max_local_max_proofs_verifieds = 'ml )\n\n let create : type mb ml. unit -> (mb, ml) t =\n fun () ->\n let module R = struct\n type nonrec max_proofs_verified = mb\n\n type nonrec max_local_max_proofs_verifieds = ml\n\n open Snarky_backendless.Request\n\n type 'a vec = ('a, max_proofs_verified) Vector.t\n\n type _ t +=\n | Evals :\n (Tock.Field.t, Tock.Field.t array) Plonk_types.All_evals.t vec t\n | Which_branch : int t\n | Step_accs : Tock.Inner_curve.Affine.t vec t\n | Old_bulletproof_challenges :\n max_local_max_proofs_verifieds H1.T(Challenges_vector.Constant).t t\n | Proof_state :\n ( ( ( Challenge.Constant.t\n , Challenge.Constant.t Scalar_challenge.t\n , Tock.Field.t Shifted_value.Type2.t\n , ( Challenge.Constant.t Scalar_challenge.t\n Bulletproof_challenge.t\n , Tock.Rounds.n )\n Vector.t\n , Digest.Constant.t\n , bool )\n Types.Step.Proof_state.Per_proof.In_circuit.t\n , max_proofs_verified )\n Vector.t\n , Digest.Constant.t )\n Types.Step.Proof_state.t\n t\n | Messages : Tock.Inner_curve.Affine.t Plonk_types.Messages.t t\n | Openings_proof :\n ( Tock.Inner_curve.Affine.t\n , Tick.Field.t )\n Plonk_types.Openings.Bulletproof.t\n t\n | Wrap_domain_indices : (Tock.Field.t, max_proofs_verified) Vector.t t\n end in\n (module R)\nend\n\nmodule Step = struct\n module type S = sig\n type statement\n\n type return_value\n\n type prev_values\n\n type proofs_verified\n\n (* TODO: As an optimization this can be the local proofs-verified size *)\n type max_proofs_verified\n\n type local_signature\n\n type local_branches\n\n type auxiliary_value\n\n type _ t +=\n | Compute_prev_proof_parts :\n ( prev_values\n , local_signature )\n H2.T(Inductive_rule.Previous_proof_statement.Constant).t\n -> unit t\n | Proof_with_datas :\n ( prev_values\n , local_signature\n , local_branches )\n H3.T(Per_proof_witness.Constant.No_app_state).t\n t\n | Wrap_index : Tock.Curve.Affine.t Plonk_verification_key_evals.t t\n | App_state : statement t\n | Return_value : return_value -> unit t\n | Auxiliary_value : auxiliary_value -> unit t\n | Unfinalized_proofs :\n (Unfinalized.Constant.t, proofs_verified) Vector.t t\n | Messages_for_next_wrap_proof :\n (Digest.Constant.t, max_proofs_verified) Vector.t t\n | Wrap_domain_indices :\n (Pickles_base.Proofs_verified.t, proofs_verified) Vector.t t\n end\n\n let create :\n type proofs_verified local_signature local_branches statement return_value auxiliary_value prev_values max_proofs_verified.\n unit\n -> (module S\n with type local_signature = local_signature\n and type local_branches = local_branches\n and type statement = statement\n and type return_value = return_value\n and type auxiliary_value = auxiliary_value\n and type prev_values = prev_values\n and type proofs_verified = proofs_verified\n and type max_proofs_verified = max_proofs_verified ) =\n fun () ->\n let module R = struct\n type nonrec max_proofs_verified = max_proofs_verified\n\n type nonrec proofs_verified = proofs_verified\n\n type nonrec statement = statement\n\n type nonrec return_value = return_value\n\n type nonrec auxiliary_value = auxiliary_value\n\n type nonrec prev_values = prev_values\n\n type nonrec local_signature = local_signature\n\n type nonrec local_branches = local_branches\n\n type _ t +=\n | Compute_prev_proof_parts :\n ( prev_values\n , local_signature )\n H2.T(Inductive_rule.Previous_proof_statement.Constant).t\n -> unit t\n | Proof_with_datas :\n ( prev_values\n , local_signature\n , local_branches )\n H3.T(Per_proof_witness.Constant.No_app_state).t\n t\n | Wrap_index : Tock.Curve.Affine.t Plonk_verification_key_evals.t t\n | App_state : statement t\n | Return_value : return_value -> unit t\n | Auxiliary_value : auxiliary_value -> unit t\n | Unfinalized_proofs :\n (Unfinalized.Constant.t, proofs_verified) Vector.t t\n | Messages_for_next_wrap_proof :\n (Digest.Constant.t, max_proofs_verified) Vector.t t\n | Wrap_domain_indices :\n (Pickles_base.Proofs_verified.t, proofs_verified) Vector.t t\n end in\n (module R)\nend\n","open Core_kernel\n\nlet l = ref \"\"\n\nlet r = ref (Time.now ())\n\nlet start =\n Common.when_profiling\n (fun loc ->\n r := Time.now () ;\n l := loc )\n ignore\n\nlet clock =\n Common.when_profiling\n (fun loc ->\n let t = Time.now () in\n printf \"%s -> %s: %s\\n%!\" !l loc\n (Time.Span.to_string_hum (Time.diff t !r)) ;\n r := t ;\n l := loc )\n ignore\n","open Core_kernel\nopen Import\n\nlet zk_rows = 3\n\nlet rough_domains =\n let d = Domain.Pow_2_roots_of_unity 20 in\n { Domains.h = d }\n\nlet domains (type field)\n (module Impl : Snarky_backendless.Snark_intf.Run with type field = field)\n (Spec.ETyp.T (typ, conv, _conv_inv))\n (Spec.ETyp.T (return_typ, _ret_conv, ret_conv_inv)) main =\n let main x () = ret_conv_inv (main (conv x)) in\n\n let domains2 sys =\n let open Domain in\n let public_input_size =\n Set_once.get_exn\n (Impl.R1CS_constraint_system.get_public_input_size sys)\n [%here]\n in\n let rows =\n zk_rows + public_input_size + Impl.R1CS_constraint_system.get_rows_len sys\n in\n { Domains.h = Pow_2_roots_of_unity Int.(ceil_log2 rows) }\n in\n domains2 (Impl.constraint_system ~input_typ:typ ~return_typ main)\n","open Core_kernel\nopen Pickles_types\nopen Import\nopen Kimchi_pasta.Pasta\n\nmodule Verifier_index_json = struct\n module Lookup = struct\n type 't lookup_selectors =\n 't Kimchi_types.VerifierIndex.Lookup.lookup_selectors =\n { lookup : 't option\n ; xor : 't option\n ; range_check : 't option\n ; ffmul : 't option\n }\n [@@deriving yojson]\n\n type lookup_pattern = Kimchi_types.lookup_pattern =\n | Xor\n | Lookup\n | RangeCheck\n | ForeignFieldMul\n [@@deriving yojson]\n\n type lookup_patterns = Kimchi_types.lookup_patterns =\n { xor : bool\n ; lookup : bool\n ; range_check : bool\n ; foreign_field_mul : bool\n }\n [@@deriving yojson]\n\n type lookup_features = Kimchi_types.lookup_features =\n { patterns : lookup_patterns\n ; joint_lookup_used : bool\n ; uses_runtime_tables : bool\n }\n [@@deriving yojson]\n\n type lookup_info = Kimchi_types.VerifierIndex.Lookup.lookup_info =\n { max_per_row : int; max_joint_size : int; features : lookup_features }\n [@@deriving yojson]\n\n type 'polyComm t = 'polyComm Kimchi_types.VerifierIndex.Lookup.t =\n { joint_lookup_used : bool\n ; lookup_table : 'polyComm array\n ; lookup_selectors : 'polyComm lookup_selectors\n ; table_ids : 'polyComm option\n ; lookup_info : lookup_info\n ; runtime_tables_selector : 'polyComm option\n }\n [@@deriving yojson]\n end\n\n type 'fr domain = 'fr Kimchi_types.VerifierIndex.domain =\n { log_size_of_group : int; group_gen : 'fr }\n [@@deriving yojson]\n\n type 'polyComm verification_evals =\n 'polyComm Kimchi_types.VerifierIndex.verification_evals =\n { sigma_comm : 'polyComm array\n ; coefficients_comm : 'polyComm array\n ; generic_comm : 'polyComm\n ; psm_comm : 'polyComm\n ; complete_add_comm : 'polyComm\n ; mul_comm : 'polyComm\n ; emul_comm : 'polyComm\n ; endomul_scalar_comm : 'polyComm\n }\n [@@deriving yojson]\n\n type ('fr, 'sRS, 'polyComm) verifier_index =\n ('fr, 'sRS, 'polyComm) Kimchi_types.VerifierIndex.verifier_index =\n { domain : 'fr domain\n ; max_poly_size : int\n ; public : int\n ; prev_challenges : int\n ; srs : 'sRS\n ; evals : 'polyComm verification_evals\n ; shifts : 'fr array\n ; lookup_index : 'polyComm Lookup.t option\n }\n [@@deriving yojson]\n\n type 'f or_infinity = 'f Kimchi_types.or_infinity =\n | Infinity\n | Finite of ('f * 'f)\n [@@deriving yojson]\n\n type 'g polycomm = 'g Kimchi_types.poly_comm =\n { unshifted : 'g array; shifted : 'g option }\n [@@deriving yojson]\n\n let to_yojson fp fq =\n verifier_index_to_yojson fp\n (fun _ -> `Null)\n (polycomm_to_yojson (or_infinity_to_yojson fq))\nend\n\nmodule Data = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = { constraints : int } [@@deriving yojson]\n\n let to_latest = Fn.id\n end\n end]\nend\n\nmodule Repr = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t =\n { commitments :\n Backend.Tock.Curve.Affine.Stable.V1.t\n Plonk_verification_key_evals.Stable.V2.t\n ; data : Data.Stable.V1.t\n }\n [@@deriving to_yojson]\n\n let to_latest = Fn.id\n end\n end]\nend\n\n[%%versioned_binable\nmodule Stable = struct\n module V2 = struct\n type t =\n { commitments : Backend.Tock.Curve.Affine.t Plonk_verification_key_evals.t\n ; index :\n (Impls.Wrap.Verification_key.t\n [@to_yojson\n Verifier_index_json.to_yojson Backend.Tock.Field.to_yojson\n Backend.Tick.Field.to_yojson] )\n ; data : Data.t\n }\n [@@deriving fields, to_yojson]\n\n let to_latest = Fn.id\n\n let of_repr srs { Repr.commitments = c; data = d } =\n let t : Impls.Wrap.Verification_key.t =\n let log2_size = Int.ceil_log2 d.constraints in\n let public =\n let (T (input, _conv, _conv_inv)) = Impls.Wrap.input () in\n let (Typ typ) = input in\n typ.size_in_field_elements\n in\n { domain =\n { log_size_of_group = log2_size\n ; group_gen = Backend.Tock.Field.domain_generator ~log2_size\n }\n ; max_poly_size = 1 lsl Nat.to_int Rounds.Wrap.n\n ; public\n ; prev_challenges = 2 (* Due to Wrap_hack *)\n ; srs\n ; evals =\n (let g (x, y) =\n { Kimchi_types.unshifted = [| Kimchi_types.Finite (x, y) |]\n ; shifted = None\n }\n in\n { sigma_comm = Array.map ~f:g (Vector.to_array c.sigma_comm)\n ; coefficients_comm =\n Array.map ~f:g (Vector.to_array c.coefficients_comm)\n ; generic_comm = g c.generic_comm\n ; mul_comm = g c.mul_comm\n ; psm_comm = g c.psm_comm\n ; emul_comm = g c.emul_comm\n ; complete_add_comm = g c.complete_add_comm\n ; endomul_scalar_comm = g c.endomul_scalar_comm\n } )\n ; shifts = Common.tock_shifts ~log2_size\n ; lookup_index = None\n }\n in\n { commitments = c; data = d; index = t }\n\n include\n Binable.Of_binable\n (Repr.Stable.V2)\n (struct\n type nonrec t = t\n\n let to_binable { commitments; data; index = _ } =\n { Repr.commitments; data }\n\n let of_binable r = of_repr (Backend.Tock.Keypair.load_urs ()) r\n end)\n end\nend]\n\nlet to_yojson = Stable.Latest.to_yojson\n\nlet dummy_commitments g =\n let open Plonk_types in\n { Plonk_verification_key_evals.sigma_comm =\n Vector.init Permuts.n ~f:(fun _ -> g)\n ; coefficients_comm = Vector.init Columns.n ~f:(fun _ -> g)\n ; generic_comm = g\n ; psm_comm = g\n ; complete_add_comm = g\n ; mul_comm = g\n ; emul_comm = g\n ; endomul_scalar_comm = g\n }\n\nlet dummy =\n lazy\n (let rows = Domain.size (Common.wrap_domains ~proofs_verified:2).h in\n let g = Backend.Tock.Curve.(to_affine_exn one) in\n { Repr.commitments = dummy_commitments g; data = { constraints = rows } }\n |> Stable.Latest.of_repr (Kimchi_bindings.Protocol.SRS.Fq.create 1) )\n","open Core_kernel\nopen Pickles_types\nopen Import\nopen Poly_types\n\n(* Compute the domains corresponding to wrap_main *)\n\n(* TODO: this functor does not depend on any of its argument why? *)\n\nmodule Make\n (A : T0)\n (A_value : T0)\n (Ret_var : T0)\n (Ret_value : T0)\n (Auxiliary_var : T0)\n (Auxiliary_value : T0) =\nstruct\n let f_debug full_signature _num_choices choices_length ~feature_flags\n ~max_proofs_verified =\n let num_choices = Hlist.Length.to_nat choices_length in\n let dummy_step_domains =\n Vector.init num_choices ~f:(fun _ -> Fix_domains.rough_domains)\n in\n let dummy_step_widths =\n Vector.init num_choices ~f:(fun _ ->\n Nat.to_int (Nat.Add.n max_proofs_verified) )\n in\n let dummy_step_keys =\n lazy\n (Vector.init num_choices ~f:(fun _ ->\n let g = Backend.Tock.Inner_curve.(to_affine_exn one) in\n Verification_key.dummy_commitments g ) )\n in\n Timer.clock __LOC__ ;\n let srs = Backend.Tick.Keypair.load_urs () in\n let _, main =\n Wrap_main.wrap_main ~feature_flags ~srs full_signature choices_length\n dummy_step_keys dummy_step_widths dummy_step_domains max_proofs_verified\n in\n Timer.clock __LOC__ ;\n let t =\n Fix_domains.domains\n (module Impls.Wrap)\n (Impls.Wrap.input ())\n (T (Snarky_backendless.Typ.unit (), Fn.id, Fn.id))\n main\n in\n Timer.clock __LOC__ ; t\n\n let f full_signature num_choices choices_length ~feature_flags\n ~max_proofs_verified =\n let res =\n Common.wrap_domains\n ~proofs_verified:(Nat.to_int (Nat.Add.n max_proofs_verified))\n in\n ( if debug then\n let res' =\n f_debug full_signature num_choices choices_length ~feature_flags\n ~max_proofs_verified\n in\n [%test_eq: Domains.t] res res' ) ;\n res\nend\n[@@warning \"-60\"]\n","module SC = Scalar_challenge\nmodule P = Proof\nopen Pickles_types\nopen Hlist\nopen Common\nopen Import\nopen Types\nopen Backend\n\n(* This contains the \"wrap\" prover *)\n\nlet challenge_polynomial =\n Wrap_verifier.challenge_polynomial (module Backend.Tick.Field)\n\nmodule Type1 =\n Plonk_checks.Make\n (Shifted_value.Type1)\n (struct\n let constant_term = Plonk_checks.Scalars.Tick.constant_term\n\n let index_terms = Plonk_checks.Scalars.Tick.index_terms\n end)\n\nlet _vector_of_list (type a t)\n (module V : Snarky_intf.Vector.S with type elt = a and type t = t)\n (xs : a list) : t =\n let r = V.create () in\n List.iter xs ~f:(V.emplace_back r) ;\n r\n\nlet tick_rounds = Nat.to_int Tick.Rounds.n\n\nlet combined_inner_product (type actual_proofs_verified) ~env ~domain ~ft_eval1\n ~actual_proofs_verified:\n (module AB : Nat.Add.Intf with type n = actual_proofs_verified)\n (e : _ Plonk_types.All_evals.With_public_input.t)\n ~(old_bulletproof_challenges : (_, actual_proofs_verified) Vector.t) ~r\n ~plonk ~xi ~zeta ~zetaw =\n let combined_evals =\n Plonk_checks.evals_of_split_evals ~zeta ~zetaw\n (module Tick.Field)\n ~rounds:tick_rounds e.evals\n in\n let ft_eval0 : Tick.Field.t =\n Type1.ft_eval0\n (module Tick.Field)\n plonk ~env ~domain\n (Plonk_types.Evals.to_in_circuit combined_evals)\n (fst e.public_input)\n in\n let T = AB.eq in\n let challenge_polys =\n Vector.map\n ~f:(fun chals -> unstage (challenge_polynomial (Vector.to_array chals)))\n old_bulletproof_challenges\n in\n let a = Plonk_types.Evals.to_list e.evals in\n let combine ~which_eval ~ft pt =\n let f (x, y) = match which_eval with `Fst -> x | `Snd -> y in\n let a = List.map ~f a in\n let v : Tick.Field.t array list =\n List.append\n (List.map (Vector.to_list challenge_polys) ~f:(fun f -> [| f pt |]))\n ([| f e.public_input |] :: [| ft |] :: a)\n in\n let open Tick.Field in\n Pcs_batch.combine_split_evaluations ~xi ~init:Fn.id\n ~mul_and_add:(fun ~acc ~xi fx -> fx + (xi * acc))\n v\n in\n let open Tick.Field in\n combine ~which_eval:`Fst ~ft:ft_eval0 zeta\n + (r * combine ~which_eval:`Snd ~ft:ft_eval1 zetaw)\n\nmodule Deferred_values = Types.Wrap.Proof_state.Deferred_values\n\ntype scalar_challenge_constant = Challenge.Constant.t Scalar_challenge.t\n\ntype deferred_values_and_hints =\n { x_hat_evals : Backend.Tick.Field.t * Backend.Tick.Field.t\n ; sponge_digest_before_evaluations : Tick.Field.t\n ; deferred_values :\n ( ( Challenge.Constant.t\n , scalar_challenge_constant\n , Backend.Tick.Field.t Pickles_types.Shifted_value.Type1.t\n , (Tick.Field.t Shifted_value.Type1.t, bool) Opt.t\n , ( scalar_challenge_constant Deferred_values.Plonk.In_circuit.Lookup.t\n , bool )\n Opt.t\n , bool )\n Deferred_values.Plonk.In_circuit.t\n , scalar_challenge_constant\n , Tick.Field.t Shifted_value.Type1.t\n , Challenge.Constant.t Scalar_challenge.t Bulletproof_challenge.t\n Step_bp_vec.t\n , Branch_data.t )\n Deferred_values.t\n }\n\nlet deferred_values (type n) ~(sgs : (Backend.Tick.Curve.Affine.t, n) Vector.t)\n ~actual_feature_flags\n ~(prev_challenges : ((Backend.Tick.Field.t, _) Vector.t, n) Vector.t)\n ~(step_vk : Kimchi_bindings.Protocol.VerifierIndex.Fp.t)\n ~(public_input : Backend.Tick.Field.t list) ~(proof : Backend.Tick.Proof.t)\n ~(actual_proofs_verified : n Nat.t) : deferred_values_and_hints =\n let module O = Tick.Oracles in\n let o =\n O.create step_vk\n Vector.(\n map2 sgs prev_challenges ~f:(fun commitment cs ->\n { Tick.Proof.Challenge_polynomial.commitment\n ; challenges = Vector.to_array cs\n } )\n |> to_list)\n public_input proof\n in\n let x_hat = O.(p_eval_1 o, p_eval_2 o) in\n let scalar_chal f =\n Scalar_challenge.map ~f:Challenge.Constant.of_tick_field (f o)\n in\n let plonk0 =\n { Types.Wrap.Proof_state.Deferred_values.Plonk.Minimal.alpha =\n scalar_chal O.alpha\n ; beta = O.beta o\n ; gamma = O.gamma o\n ; zeta = scalar_chal O.zeta\n ; joint_combiner =\n (* TODO: Needs to be changed when lookups are fully implemented *)\n Option.map (O.joint_combiner_chal o)\n ~f:(Scalar_challenge.map ~f:Challenge.Constant.of_tick_field)\n ; feature_flags = actual_feature_flags\n }\n in\n let r = scalar_chal O.u in\n let xi = scalar_chal O.v in\n let module As_field = struct\n let to_field =\n SC.to_field_constant\n (module Tick.Field)\n ~endo:Endo.Wrap_inner_curve.scalar\n\n let r = to_field r\n\n let xi = to_field xi\n\n let zeta = to_field plonk0.zeta\n\n let alpha = to_field plonk0.alpha\n\n let joint_combiner = Option.map ~f:to_field plonk0.joint_combiner\n end in\n let domain = Domain.Pow_2_roots_of_unity step_vk.domain.log_size_of_group in\n let zetaw = Tick.Field.mul As_field.zeta step_vk.domain.group_gen in\n let tick_plonk_minimal =\n { plonk0 with\n zeta = As_field.zeta\n ; alpha = As_field.alpha\n ; joint_combiner = As_field.joint_combiner\n }\n in\n let tick_combined_evals =\n Plonk_checks.evals_of_split_evals\n (module Tick.Field)\n proof.openings.evals ~rounds:(Nat.to_int Tick.Rounds.n)\n ~zeta:As_field.zeta ~zetaw\n |> Plonk_types.Evals.to_in_circuit\n in\n let tick_domain =\n Plonk_checks.domain\n (module Tick.Field)\n domain ~shifts:Common.tick_shifts\n ~domain_generator:Backend.Tick.Field.domain_generator\n in\n let tick_env =\n let module Env_bool = struct\n type t = bool\n\n let true_ = true\n\n let false_ = false\n\n let ( &&& ) = ( && )\n\n let ( ||| ) = ( || )\n\n let any = List.exists ~f:Fn.id\n end in\n let module Env_field = struct\n include Tick.Field\n\n type bool = Env_bool.t\n\n let if_ (b : bool) ~then_ ~else_ = if b then then_ () else else_ ()\n end in\n Plonk_checks.scalars_env\n (module Env_bool)\n (module Env_field)\n ~endo:Endo.Step_inner_curve.base ~mds:Tick_field_sponge.params.mds\n ~srs_length_log2:Common.Max_degree.step_log2\n ~field_of_hex:(fun s ->\n Kimchi_pasta.Pasta.Bigint256.of_hex_string s\n |> Kimchi_pasta.Pasta.Fp.of_bigint )\n ~domain:tick_domain tick_plonk_minimal tick_combined_evals\n in\n let plonk =\n let module Field = struct\n include Tick.Field\n end in\n Type1.derive_plonk\n (module Field)\n ~shift:Shifts.tick1 ~env:tick_env tick_plonk_minimal tick_combined_evals\n and new_bulletproof_challenges, b =\n let prechals =\n Array.map (O.opening_prechallenges o) ~f:(fun x ->\n Scalar_challenge.map ~f:Challenge.Constant.of_tick_field x )\n in\n let chals = Array.map prechals ~f:(fun x -> Ipa.Step.compute_challenge x) in\n let challenge_poly = unstage (challenge_polynomial chals) in\n let open As_field in\n let b =\n let open Tick.Field in\n challenge_poly zeta + (r * challenge_poly zetaw)\n in\n let prechals = Array.map prechals ~f:Bulletproof_challenge.unpack in\n (prechals, b)\n in\n let shift_value =\n Shifted_value.Type1.of_field (module Tick.Field) ~shift:Shifts.tick1\n and chal = Challenge.Constant.of_tick_field in\n { deferred_values =\n { Types.Wrap.Proof_state.Deferred_values.xi\n ; b = shift_value b\n ; bulletproof_challenges =\n Vector.of_array_and_length_exn new_bulletproof_challenges\n Tick.Rounds.n\n ; combined_inner_product =\n shift_value\n As_field.(\n combined_inner_product (* Note: We do not pad here. *)\n ~actual_proofs_verified:(Nat.Add.create actual_proofs_verified)\n { evals = proof.openings.evals; public_input = x_hat }\n ~r ~xi ~zeta ~zetaw ~old_bulletproof_challenges:prev_challenges\n ~env:tick_env ~domain:tick_domain\n ~ft_eval1:proof.openings.ft_eval1 ~plonk:tick_plonk_minimal)\n ; branch_data =\n { proofs_verified =\n ( match actual_proofs_verified with\n | Z ->\n Branch_data.Proofs_verified.N0\n | S Z ->\n N1\n | S (S Z) ->\n N2\n | S _ ->\n assert false )\n ; domain_log2 =\n Branch_data.Domain_log2.of_int_exn\n step_vk.domain.log_size_of_group\n }\n ; plonk =\n { plonk with\n zeta = plonk0.zeta\n ; alpha = plonk0.alpha\n ; beta = chal plonk0.beta\n ; gamma = chal plonk0.gamma\n ; lookup =\n Opt.map plonk.lookup ~f:(fun _ ->\n { Composition_types.Wrap.Proof_state.Deferred_values.Plonk\n .In_circuit\n .Lookup\n .joint_combiner = Option.value_exn plonk0.joint_combiner\n } )\n }\n }\n ; x_hat_evals = x_hat\n ; sponge_digest_before_evaluations = O.digest_before_evaluations o\n }\n\n(* Testing\n -------\n\n Invocation:\n dune exec src/lib/pickles/.pickles.inline-tests/inline_test_runner_pickles.exe \\\n --profile=dev --display short -- inline-test-runner pickles -only-test wrap.ml\n*)\nlet%test_module \"gate finalization\" =\n ( module struct\n type test_options =\n { true_is_yes : Plonk_types.Features.options\n ; true_is_maybe : Plonk_types.Features.options\n ; all_maybes : Plonk_types.Features.options\n }\n\n (* Helper function to convert actual feature flags into 3 test configurations of feature flags\n @param actual_feature_flags The actual feature flags in terms of true/false\n\n @return Corresponding feature flags configs composed of Yes/No/Maybe options\n - one where true is mapped to Yes and false is mapped to No\n - one where true is mapped to Maybe and false is mapped to No\n - one where true and false are both mapped to Maybe *)\n let generate_test_feature_flag_configs\n (actual_feature_flags : Plonk_types.Features.flags) : test_options =\n (* Set up a helper to convert actual feature flags composed of booleans into\n feature flags composed of Yes/No/Maybe options.\n @param actual_feature_flags The actual feature flags in terms of true/false\n @param true_opt Plonk_types.Opt type to use for true/enabled features\n @param false_opt Plonk_types.Opt type to use for false/disabled features\n @return Corresponding feature flags composed of Yes/No/Maybe values *)\n let compute_feature_flags\n (actual_feature_flags : Plonk_types.Features.flags)\n (true_opt : Plonk_types.Opt.Flag.t)\n (false_opt : Plonk_types.Opt.Flag.t) : Plonk_types.Features.options =\n Plonk_types.Features.map actual_feature_flags ~f:(function\n | true ->\n true_opt\n | false ->\n false_opt )\n in\n\n (* Generate the 3 configurations of the actual feature flags using\n helper *)\n let open Plonk_types.Opt.Flag in\n { true_is_yes = compute_feature_flags actual_feature_flags Yes No\n ; true_is_maybe = compute_feature_flags actual_feature_flags Maybe No\n ; all_maybes = compute_feature_flags actual_feature_flags Maybe Maybe\n }\n\n (* Run the recursive proof tests on the supplied inputs.\n\n @param actual_feature_flags User-specified feature flags, matching those\n required by the backend circuit\n @param public_input list of public inputs (can be empty)\n @param vk Verifier index for backend circuit\n @param proof Backend proof\n\n @return true or throws and exception\n *)\n let run_recursive_proof_test\n (actual_feature_flags : Plonk_types.Features.flags)\n (feature_flags : Plonk_types.Features.options)\n (public_input : Pasta_bindings.Fp.t list)\n (vk : Kimchi_bindings.Protocol.VerifierIndex.Fp.t)\n (proof : Backend.Tick.Proof.t) : Impls.Step.Boolean.value =\n (* Constants helper - takes an OCaml value and converts it to a snarky value, where\n all values here are constant literals. N.b. this should be\n encapsulated as Snarky internals, but it never got merged. *)\n let constant (Typ typ : _ Snarky_backendless.Typ.t) x =\n let xs, aux = typ.value_to_fields x in\n typ.var_of_fields (Array.map xs ~f:Impls.Step.Field.constant, aux)\n in\n\n (* Compute deferred values - in the Pickles recursive proof system, deferred values\n are values from 2 proofs earlier in the recursion hierarchy. Every recursion\n goes through a two-phase process of step and wrap, like so\n\n step <- wrap <- step <- ... <- wrap <- step,\n `<-----------'\n deferred\n\n where there may be multiple children at each level (but let's ignore that!).\n Deferred values are values (part of the public input) that must be passed between\n the two phases in order to be verified correctly-- it works like this.\n\n - The wrap proof is passed the deferred values for its step proof as part of its public input.\n - The wrap proof starts verifying the step proof. As part of this verification it must\n perform all of the group element checks (since it's over the Vesta base field); however,\n at this stage it just assumes that the deferred values of its public input are correct\n (i.e. it defers checking them).\n - The next step proof verifies the wrap proof with a similar process, but using the other\n curve (e.g. Pallas). There are two important things to note:\n - Since it is using the other curve, it can compute the commitments to the public inputs\n of the previous wrap circuit that were passed into it. In other words, the next step\n proof receives data from the previous wrap proof about the previous step proof. Yeah,\n from two proofs back! (e.g. the deferred values)\n - The next step proof also computes the deferred values inside the circuit and verifies\n that they match those used by the previous wrap proof.\n\n The code below generates the deferred values so that we can verifiy that we can actually\n compute those values correctly inside the circuit. Special thanks to Matthew Ryan for\n explaining this in detail. *)\n let { deferred_values; x_hat_evals; sponge_digest_before_evaluations } =\n deferred_values ~actual_feature_flags ~sgs:[] ~prev_challenges:[]\n ~step_vk:vk ~public_input ~proof ~actual_proofs_verified:Nat.N0.n\n in\n\n (* Define Typ.t for Deferred_values.t -- A Type.t defines how to convert a value of some type\n in OCaml into a var in circuit/Snarky.\n\n This complex function is called with two sets of inputs: once for the step circuit and\n once for the wrap circuit. It was decided not to use a functor for this. *)\n let deferred_values_typ =\n let open Impls.Step in\n let open Step_main_inputs in\n let open Step_verifier in\n Wrap.Proof_state.Deferred_values.In_circuit.typ\n (module Impls.Step)\n ~feature_flags ~challenge:Challenge.typ\n ~scalar_challenge:Challenge.typ\n ~dummy_scalar:(Shifted_value.Type1.Shifted_value Field.Constant.zero)\n ~dummy_scalar_challenge:\n (Kimchi_backend_common.Scalar_challenge.create\n Limb_vector.Challenge.Constant.zero )\n (Shifted_value.Type1.typ Field.typ)\n (Branch_data.typ\n (module Impl)\n ~assert_16_bits:(Step_verifier.assert_n_bits ~n:16) )\n in\n\n (* Use deferred_values_typ and the constant helper to prepare deferred_values\n for use in the circuit. We change some [Opt.t] to [Option.t] because that is\n what Type.t is configured to accept. *)\n let deferred_values =\n constant deferred_values_typ\n { deferred_values with\n plonk =\n { deferred_values.plonk with\n lookup = Opt.to_option_unsafe deferred_values.plonk.lookup\n }\n }\n (* Prepare all of the evaluations (i.e. all of the columns in the proof that we open)\n for use in the circuit *)\n and evals =\n constant\n (Plonk_types.All_evals.typ (module Impls.Step) feature_flags)\n { evals = { public_input = x_hat_evals; evals = proof.openings.evals }\n ; ft_eval1 = proof.openings.ft_eval1\n }\n in\n\n (* Run the circuit without generating a proof using run_and_check *)\n Impls.Step.run_and_check (fun () ->\n (* Set up the step sponge from the wrap sponge -- we cannot use the same poseidon\n sponge in both step and wrap because they have different fields.\n\n In order to continue the Fiat-Shamir heuristic across field boundaries we use\n the wrap sponge for everything in the wrap proof, squeeze it one final time and\n expose the squoze value in the public input to the step proof, which absorbs\n said squoze value into the step sponge. :-) This means the step sponge has absorbed\n everything from the proof so far by proxy and that is also over the native field! *)\n let res, _chals =\n let sponge =\n let open Step_main_inputs in\n let sponge = Sponge.create sponge_params in\n Sponge.absorb sponge\n (`Field (Impl.Field.constant sponge_digest_before_evaluations)) ;\n sponge\n in\n\n (* Call finalisation with all of the required details *)\n Step_verifier.finalize_other_proof\n (module Nat.N0)\n ~feature_flags\n ~step_domains:\n (`Known\n [ { h = Pow_2_roots_of_unity vk.domain.log_size_of_group } ]\n )\n ~sponge ~prev_challenges:[] deferred_values evals\n in\n\n (* Read the boolean result from the circuit and make it available\n to the OCaml world. *)\n Impls.Step.(As_prover.(fun () -> read Boolean.typ res)) )\n |> Or_error.ok_exn\n\n (* Common srs value for all tests *)\n let srs =\n Kimchi_bindings.Protocol.SRS.Fp.create (1 lsl Common.Max_degree.step_log2)\n\n type example =\n Kimchi_bindings.Protocol.SRS.Fp.t\n -> Kimchi_bindings.Protocol.Index.Fp.t\n * Pasta_bindings.Fp.t list\n * ( Pasta_bindings.Fq.t Kimchi_types.or_infinity\n , Pasta_bindings.Fp.t )\n Kimchi_types.prover_proof\n\n module type SETUP = sig\n val example : example\n\n (* Feature flags tused for backend proof *)\n val actual_feature_flags : bool Plonk_types.Features.t\n end\n\n (* [Make] is the test functor.\n\n Given a test setup, compute different test configurations and define 3\n test for said configurations. *)\n module Make (S : SETUP) = struct\n (* Generate foreign field multiplication test backend proof using Kimchi,\n obtaining the proof and corresponding prover index.\n\n Note: we only want to pay the cost of generating this proof once and\n then reuse it many times for the different recursive proof tests. *)\n let index, public_input, proof = S.example srs\n\n (* Obtain verifier key from prover index and convert backend proof to\n snarky proof *)\n let vk = Kimchi_bindings.Protocol.VerifierIndex.Fp.create index\n\n let proof = Backend.Tick.Proof.of_backend proof\n\n let test_feature_flags_configs =\n generate_test_feature_flag_configs S.actual_feature_flags\n\n let runtest feature_flags =\n run_recursive_proof_test S.actual_feature_flags feature_flags\n public_input vk proof\n\n let%test \"true -> yes\" = runtest test_feature_flags_configs.true_is_yes\n\n let%test \"true -> maybe\" =\n runtest test_feature_flags_configs.true_is_maybe\n\n let%test \"all maybes\" = runtest test_feature_flags_configs.all_maybes\n end\n\n (* Small combinators to lift gate example signatures to the expected\n signatures for the tests. This amounts to generating the list of public\n inputs from either no public inputs, a single one or a pair of inputs\n returned by the gate example. *)\n\n let no_public_input gate_example srs =\n let index, proof = gate_example srs in\n (index, [], proof)\n\n let public_input_1 gate_example srs =\n let index, public_input, proof = gate_example srs in\n (index, [ public_input ], proof)\n\n let public_input_2 gate_example srs =\n let index, (public_input1, public_input2), proof = gate_example srs in\n (index, [ public_input1; public_input2 ], proof)\n\n let%test_module \"lookup\" =\n ( module Make (struct\n let example =\n public_input_1 (fun srs ->\n Kimchi_bindings.Protocol.Proof.Fp.example_with_lookup srs )\n\n let actual_feature_flags =\n { Plonk_types.Features.none_bool with\n lookup = true\n ; runtime_tables = true\n }\n end) )\n\n (*\n let%test_module \"foreign field multiplication\" =\n ( module Make (struct\n let example =\n no_public_input\n Kimchi_bindings.Protocol.Proof.Fp.example_with_foreign_field_mul\n\n let actual_feature_flags =\n { Plonk_types.Features.none_bool with\n range_check0 = true\n ; range_check1 = true\n ; foreign_field_add = true\n ; foreign_field_mul = true\n }\n end) )\n *)\n\n let%test_module \"range check\" =\n ( module Make (struct\n let example =\n no_public_input\n Kimchi_bindings.Protocol.Proof.Fp.example_with_range_check\n\n let actual_feature_flags =\n { Plonk_types.Features.none_bool with\n range_check0 = true\n ; range_check1 = true\n }\n end) )\n\n let%test_module \"range check 64 bits\" =\n ( module Make (struct\n let example =\n no_public_input\n Kimchi_bindings.Protocol.Proof.Fp.example_with_range_check0\n\n let actual_feature_flags =\n { Plonk_types.Features.none_bool with range_check0 = true }\n end) )\n\n let%test_module \"xor\" =\n ( module Make (struct\n let example =\n public_input_2 Kimchi_bindings.Protocol.Proof.Fp.example_with_xor\n\n let actual_feature_flags =\n { Plonk_types.Features.none_bool with xor = true }\n end) )\n\n let%test_module \"rot\" =\n ( module Make (struct\n let example =\n public_input_2 Kimchi_bindings.Protocol.Proof.Fp.example_with_rot\n\n let actual_feature_flags =\n { Plonk_types.Features.none_bool with\n range_check0 = true\n ; rot = true\n }\n end) )\n\n let%test_module \"foreign field addition\" =\n ( module Make (struct\n let example =\n public_input_1 Kimchi_bindings.Protocol.Proof.Fp.example_with_ffadd\n\n let actual_feature_flags =\n { Plonk_types.Features.none_bool with\n range_check0 = true\n ; range_check1 = true\n ; foreign_field_add = true\n }\n end) )\n end )\n\nmodule Step_acc = Tock.Inner_curve.Affine\n\n(* The prover for wrapping a proof *)\nlet wrap\n (type actual_proofs_verified max_proofs_verified\n max_local_max_proofs_verifieds )\n ~(max_proofs_verified : max_proofs_verified Nat.t)\n (module Max_local_max_proof_verifieds : Hlist.Maxes.S\n with type ns = max_local_max_proofs_verifieds\n and type length = max_proofs_verified )\n (( module\n Req ) :\n (max_proofs_verified, max_local_max_proofs_verifieds) Requests.Wrap.t )\n ~dlog_plonk_index wrap_main ~(typ : _ Impls.Step.Typ.t) ~step_vk\n ~actual_wrap_domains ~step_plonk_indices:_ ~feature_flags\n ~actual_feature_flags ?tweak_statement pk\n ({ statement = prev_statement; prev_evals; proof; index = which_index } :\n ( _\n , _\n , (_, actual_proofs_verified) Vector.t\n , (_, actual_proofs_verified) Vector.t\n , max_local_max_proofs_verifieds\n H1.T(P.Base.Messages_for_next_proof_over_same_field.Wrap).t\n , ( (Tock.Field.t, Tock.Field.t array) Plonk_types.All_evals.t\n , max_proofs_verified )\n Vector.t )\n P.Base.Step.t ) =\n let logger = Internal_tracing_context_logger.get () in\n [%log internal] \"Pickles_wrap_proof\" ;\n let messages_for_next_wrap_proof =\n let module M =\n H1.Map\n (P.Base.Messages_for_next_proof_over_same_field.Wrap)\n (P.Base.Messages_for_next_proof_over_same_field.Wrap.Prepared)\n (struct\n let f = P.Base.Messages_for_next_proof_over_same_field.Wrap.prepare\n end)\n in\n M.f prev_statement.messages_for_next_wrap_proof\n in\n let prev_statement_with_hashes : _ Types.Step.Statement.t =\n { proof_state =\n { prev_statement.proof_state with\n messages_for_next_step_proof =\n (let to_field_elements =\n let (Typ typ) = typ in\n fun x -> fst (typ.value_to_fields x)\n in\n (* TODO: Careful here... the length of\n old_buletproof_challenges inside the messages_for_next_step_proof\n might not be correct *)\n Common.hash_messages_for_next_step_proof\n ~app_state:to_field_elements\n (P.Base.Messages_for_next_proof_over_same_field.Step.prepare\n ~dlog_plonk_index\n prev_statement.proof_state.messages_for_next_step_proof ) )\n }\n ; messages_for_next_wrap_proof =\n (let module M =\n H1.Map\n (P.Base.Messages_for_next_proof_over_same_field.Wrap.Prepared)\n (E01 (Digest.Constant))\n (struct\n let f (type n)\n (m :\n n\n P.Base.Messages_for_next_proof_over_same_field.Wrap\n .Prepared\n .t ) =\n Wrap_hack.hash_messages_for_next_wrap_proof\n (Vector.length m.old_bulletproof_challenges)\n m\n end)\n in\n let module V = H1.To_vector (Digest.Constant) in\n V.f Max_local_max_proof_verifieds.length\n (M.f messages_for_next_wrap_proof) )\n }\n in\n let handler (Snarky_backendless.Request.With { request; respond }) =\n let open Req in\n let k x = respond (Provide x) in\n match request with\n | Evals ->\n k prev_evals\n | Step_accs ->\n let module M =\n H1.Map\n (P.Base.Messages_for_next_proof_over_same_field.Wrap.Prepared)\n (E01 (Step_acc))\n (struct\n let f :\n type a.\n a\n P.Base.Messages_for_next_proof_over_same_field.Wrap.Prepared\n .t\n -> Step_acc.t =\n fun t -> t.challenge_polynomial_commitment\n end)\n in\n let module V = H1.To_vector (Step_acc) in\n k\n (V.f Max_local_max_proof_verifieds.length\n (M.f messages_for_next_wrap_proof) )\n | Old_bulletproof_challenges ->\n let module M =\n H1.Map\n (P.Base.Messages_for_next_proof_over_same_field.Wrap.Prepared)\n (Challenges_vector.Constant)\n (struct\n let f\n (t :\n _\n P.Base.Messages_for_next_proof_over_same_field.Wrap.Prepared\n .t ) =\n t.old_bulletproof_challenges\n end)\n in\n k (M.f messages_for_next_wrap_proof)\n | Messages ->\n k proof.messages\n | Openings_proof ->\n k proof.openings.proof\n | Proof_state ->\n k prev_statement_with_hashes.proof_state\n | Which_branch ->\n k which_index\n | Wrap_domain_indices ->\n let all_possible_domains = Wrap_verifier.all_possible_domains () in\n let wrap_domain_indices =\n Vector.map actual_wrap_domains ~f:(fun domain_size ->\n let domain_index =\n Vector.foldi ~init:0 all_possible_domains\n ~f:(fun j acc (Pow_2_roots_of_unity domain) ->\n if Int.equal domain domain_size then j else acc )\n in\n Tock.Field.of_int domain_index )\n in\n k\n (Vector.extend_front_exn wrap_domain_indices max_proofs_verified\n Tock.Field.one )\n | _ ->\n Snarky_backendless.Request.unhandled\n in\n\n let public_input =\n tick_public_input_of_statement ~max_proofs_verified\n prev_statement_with_hashes ~feature_flags\n in\n let prev_challenges =\n Vector.map ~f:Ipa.Step.compute_challenges\n prev_statement.proof_state.messages_for_next_step_proof\n .old_bulletproof_challenges\n in\n let actual_proofs_verified = Vector.length prev_challenges in\n let lte =\n Nat.lte_exn actual_proofs_verified\n (Length.to_nat Max_local_max_proof_verifieds.length)\n in\n let sgs =\n let module M =\n H1.Map\n (P.Base.Messages_for_next_proof_over_same_field.Wrap.Prepared)\n (E01 (Tick.Curve.Affine))\n (struct\n let f :\n type n.\n n P.Base.Messages_for_next_proof_over_same_field.Wrap.Prepared.t\n -> _ =\n fun t -> t.challenge_polynomial_commitment\n end)\n in\n let module V = H1.To_vector (Tick.Curve.Affine) in\n Vector.trim_front\n (V.f Max_local_max_proof_verifieds.length\n (M.f messages_for_next_wrap_proof) )\n lte\n in\n [%log internal] \"Wrap_compute_deferred_values\" ;\n let { deferred_values; x_hat_evals; sponge_digest_before_evaluations } =\n deferred_values ~sgs ~prev_challenges ~step_vk ~public_input ~proof\n ~actual_proofs_verified ~actual_feature_flags\n in\n [%log internal] \"Wrap_compute_deferred_values_done\" ;\n let next_statement : _ Types.Wrap.Statement.In_circuit.t =\n let messages_for_next_wrap_proof :\n _ P.Base.Messages_for_next_proof_over_same_field.Wrap.t =\n { challenge_polynomial_commitment =\n proof.openings.proof.challenge_polynomial_commitment\n ; old_bulletproof_challenges =\n Vector.map prev_statement.proof_state.unfinalized_proofs ~f:(fun t ->\n t.deferred_values.bulletproof_challenges )\n }\n in\n { proof_state =\n { deferred_values\n ; sponge_digest_before_evaluations =\n Digest.Constant.of_tick_field sponge_digest_before_evaluations\n ; messages_for_next_wrap_proof\n }\n ; messages_for_next_step_proof =\n prev_statement.proof_state.messages_for_next_step_proof\n }\n in\n let next_statement =\n match tweak_statement with\n | None ->\n next_statement\n | Some f ->\n (* For adversarial tests, we want to simulate an adversary creating a\n proof that doesn't match the pickles protocol.\n In order to do this, we pass a function [tweak_statement] that takes\n the valid statement that we computed above and 'tweaks' it so that\n the statement is no longer valid. This modified statement is then\n propagated as part of any later recursion.\n *)\n f next_statement\n in\n let messages_for_next_wrap_proof_prepared =\n P.Base.Messages_for_next_proof_over_same_field.Wrap.prepare\n next_statement.proof_state.messages_for_next_wrap_proof\n in\n let next_accumulator =\n Vector.map2\n (Vector.extend_front_exn\n prev_statement.proof_state.messages_for_next_step_proof\n .challenge_polynomial_commitments max_proofs_verified\n (Lazy.force Dummy.Ipa.Wrap.sg) )\n messages_for_next_wrap_proof_prepared.old_bulletproof_challenges\n ~f:(fun sg chals ->\n { Tock.Proof.Challenge_polynomial.commitment = sg\n ; challenges = Vector.to_array chals\n } )\n |> Wrap_hack.pad_accumulator\n in\n let%map.Promise next_proof =\n let (T (input, conv, _conv_inv)) = Impls.Wrap.input () in\n Common.time \"wrap proof\" (fun () ->\n [%log internal] \"Wrap_generate_witness_conv\" ;\n Impls.Wrap.generate_witness_conv\n ~f:(fun { Impls.Wrap.Proof_inputs.auxiliary_inputs; public_inputs } () ->\n [%log internal] \"Backend_tock_proof_create_async\" ;\n let%map.Promise proof =\n Backend.Tock.Proof.create_async ~primary:public_inputs\n ~auxiliary:auxiliary_inputs pk ~message:next_accumulator\n in\n [%log internal] \"Backend_tock_proof_create_async_done\" ;\n proof )\n ~input_typ:input\n ~return_typ:(Snarky_backendless.Typ.unit ())\n (fun x () : unit ->\n Impls.Wrap.handle (fun () : unit -> wrap_main (conv x)) handler )\n { messages_for_next_step_proof =\n prev_statement_with_hashes.proof_state\n .messages_for_next_step_proof\n ; proof_state =\n { next_statement.proof_state with\n messages_for_next_wrap_proof =\n Wrap_hack.hash_messages_for_next_wrap_proof\n max_proofs_verified messages_for_next_wrap_proof_prepared\n ; deferred_values =\n { next_statement.proof_state.deferred_values with\n plonk =\n { next_statement.proof_state.deferred_values.plonk with\n lookup =\n (* TODO: This assumes wrap circuits do not use lookup *)\n None\n }\n }\n }\n } )\n in\n [%log internal] \"Pickles_wrap_proof_done\" ;\n ( { proof = Wrap_wire_proof.of_kimchi_proof next_proof\n ; statement =\n Types.Wrap.Statement.to_minimal next_statement\n ~to_option:Opt.to_option_unsafe\n ; prev_evals =\n { Plonk_types.All_evals.evals =\n { public_input = x_hat_evals; evals = proof.openings.evals }\n ; ft_eval1 = proof.openings.ft_eval1\n }\n }\n : _ P.Base.Wrap.t )\n","module SC = Scalar_challenge\nopen Core_kernel\nopen Pickles_types\nopen Common\nopen Import\nopen Backend\n\n(* TODO: Just stick this in plonk_checks.ml *)\nmodule Plonk_checks = struct\n include Plonk_checks\n module Type1 =\n Plonk_checks.Make (Shifted_value.Type1) (Plonk_checks.Scalars.Tick)\nend\n\nlet expand_deferred (type n most_recent_width)\n ~(evals :\n ( Backend.Tick.Field.t\n , Backend.Tick.Field.t array )\n Pickles_types.Plonk_types.All_evals.t )\n ~(old_bulletproof_challenges :\n ( Challenge.Constant.t Scalar_challenge.Stable.Latest.t\n Bulletproof_challenge.t\n Step_bp_vec.t\n , most_recent_width )\n Pickles_types.Vector.t )\n ~(proof_state :\n ( Challenge.Constant.t\n , Challenge.Constant.t Scalar_challenge.t\n , Backend.Tick.Field.t Pickles_types.Shifted_value.Type1.t\n , bool\n , n Pickles__.Proof.Base.Messages_for_next_proof_over_same_field.Wrap.t\n , Digest.Constant.t\n , Challenge.Constant.t Scalar_challenge.t Bulletproof_challenge.t\n Step_bp_vec.t\n , Branch_data.t )\n Composition_types.Wrap.Proof_state.Minimal.Stable.V1.t ) :\n _ Types.Wrap.Proof_state.Deferred_values.t =\n let module Tick_field = Backend.Tick.Field in\n let tick_field : _ Plonk_checks.field = (module Tick_field) in\n Timer.start __LOC__ ;\n let open Types.Wrap.Proof_state in\n let sc = SC.to_field_constant tick_field ~endo:Endo.Wrap_inner_curve.scalar in\n Timer.clock __LOC__ ;\n let plonk0 = proof_state.deferred_values.plonk in\n let { Deferred_values.Minimal.branch_data; bulletproof_challenges; _ } =\n Deferred_values.Minimal.map_challenges ~f:Challenge.Constant.to_tick_field\n ~scalar:sc proof_state.deferred_values\n in\n let zeta = sc plonk0.zeta in\n let alpha = sc plonk0.alpha in\n let step_domain = Branch_data.domain branch_data in\n let w =\n Tick.Field.domain_generator ~log2_size:(Domain.log2_size step_domain)\n in\n let zetaw = Tick.Field.mul zeta w in\n let tick_plonk_minimal :\n _ Composition_types.Wrap.Proof_state.Deferred_values.Plonk.Minimal.t =\n let chal = Challenge.Constant.to_tick_field in\n { zeta\n ; alpha\n ; beta = chal plonk0.beta\n ; gamma = chal plonk0.gamma\n ; joint_combiner = Option.map ~f:sc plonk0.joint_combiner\n ; feature_flags = plonk0.feature_flags\n }\n in\n let tick_combined_evals =\n Plonk_checks.evals_of_split_evals\n (module Tick.Field)\n evals.evals.evals ~rounds:(Nat.to_int Tick.Rounds.n) ~zeta ~zetaw\n |> Plonk_types.Evals.to_in_circuit\n in\n let tick_domain =\n Plonk_checks.domain\n (module Tick.Field)\n step_domain ~shifts:Common.tick_shifts\n ~domain_generator:Backend.Tick.Field.domain_generator\n in\n let tick_env =\n let module Env_bool = struct\n type t = bool\n\n let true_ = true\n\n let false_ = false\n\n let ( &&& ) = ( && )\n\n let ( ||| ) = ( || )\n\n let any = List.exists ~f:Fn.id\n end in\n let module Env_field = struct\n include Tick.Field\n\n type bool = Env_bool.t\n\n let if_ (b : bool) ~then_ ~else_ = if b then then_ () else else_ ()\n end in\n Plonk_checks.scalars_env\n (module Env_bool)\n (module Env_field)\n ~endo:Endo.Step_inner_curve.base ~mds:Tick_field_sponge.params.mds\n ~srs_length_log2:Common.Max_degree.step_log2\n ~field_of_hex:(fun s ->\n Kimchi_pasta.Pasta.Bigint256.of_hex_string s\n |> Kimchi_pasta.Pasta.Fp.of_bigint )\n ~domain:tick_domain tick_plonk_minimal tick_combined_evals\n in\n let plonk =\n let p =\n let module Field = struct\n include Tick.Field\n end in\n Plonk_checks.Type1.derive_plonk\n (module Field)\n ~shift:Shifts.tick1 ~env:tick_env tick_plonk_minimal tick_combined_evals\n in\n { p with\n zeta = plonk0.zeta\n ; alpha = plonk0.alpha\n ; beta = plonk0.beta\n ; gamma = plonk0.gamma\n ; lookup =\n Option.map (Plonk_types.Opt.to_option_unsafe p.lookup) ~f:(fun _ ->\n { Types.Wrap.Proof_state.Deferred_values.Plonk.In_circuit.Lookup\n .joint_combiner = Option.value_exn plonk0.joint_combiner\n } )\n }\n in\n Timer.clock __LOC__ ;\n let absorb, squeeze =\n let open Tick_field_sponge.Bits in\n let sponge =\n let s = create Tick_field_sponge.params in\n absorb s\n (Digest.Constant.to_tick_field\n proof_state.sponge_digest_before_evaluations ) ;\n s\n in\n let squeeze () =\n let underlying =\n Challenge.Constant.of_bits\n (squeeze sponge ~length:Challenge.Constant.length)\n in\n Scalar_challenge.create underlying\n in\n (absorb sponge, squeeze)\n in\n let old_bulletproof_challenges =\n Vector.map ~f:Ipa.Step.compute_challenges old_bulletproof_challenges\n in\n (let challenges_digest =\n let open Tick_field_sponge.Field in\n let sponge = create Tick_field_sponge.params in\n Vector.iter old_bulletproof_challenges ~f:(Vector.iter ~f:(absorb sponge)) ;\n squeeze sponge\n in\n absorb challenges_digest ;\n absorb evals.ft_eval1 ;\n let xs = Plonk_types.Evals.to_absorption_sequence evals.evals.evals in\n let x1, x2 = evals.evals.public_input in\n absorb x1 ;\n absorb x2 ;\n List.iter xs ~f:(fun (x1, x2) ->\n Array.iter ~f:absorb x1 ; Array.iter ~f:absorb x2 ) ) ;\n let xi_chal = squeeze () in\n let xi = sc xi_chal in\n let r_chal = squeeze () in\n let r = sc r_chal in\n Timer.clock __LOC__ ;\n (* TODO: The deferred values \"bulletproof_challenges\" should get routed\n into a \"batch dlog Tick acc verifier\" *)\n let actual_proofs_verified = Vector.length old_bulletproof_challenges in\n Timer.clock __LOC__ ;\n let combined_inner_product_actual =\n Wrap.combined_inner_product ~env:tick_env ~plonk:tick_plonk_minimal\n ~domain:tick_domain ~ft_eval1:evals.ft_eval1\n ~actual_proofs_verified:(Nat.Add.create actual_proofs_verified)\n evals.evals ~old_bulletproof_challenges ~r ~xi ~zeta ~zetaw\n in\n Timer.clock __LOC__ ;\n let bulletproof_challenges =\n Ipa.Step.compute_challenges bulletproof_challenges\n in\n Timer.clock __LOC__ ;\n let b_actual =\n let challenge_poly =\n unstage\n (Wrap.challenge_polynomial (Vector.to_array bulletproof_challenges))\n in\n Tick.Field.(challenge_poly zeta + (r * challenge_poly zetaw))\n in\n let to_shifted =\n Shifted_value.Type1.of_field (module Tick.Field) ~shift:Shifts.tick1\n in\n { xi = xi_chal\n ; plonk\n ; combined_inner_product = to_shifted combined_inner_product_actual\n ; branch_data\n ; bulletproof_challenges\n ; b = to_shifted b_actual\n }\n","module SC = Scalar_challenge\nopen Pickles_types\nopen Common\nopen Import\n\nmodule Instance = struct\n type t =\n | T :\n (module Nat.Intf with type n = 'n)\n * (module Intf.Statement_value with type t = 'a)\n * Verification_key.t\n * 'a\n * ('n, 'n) Proof.t\n -> t\nend\n\nlet verify_heterogenous (ts : Instance.t list) =\n let module Tick_field = Backend.Tick.Field in\n let logger = Internal_tracing_context_logger.get () in\n [%log internal] \"Verify_heterogenous\"\n ~metadata:[ (\"count\", `Int (List.length ts)) ] ;\n let tick_field : _ Plonk_checks.field = (module Tick_field) in\n let check, result =\n let r = ref [] in\n let result () =\n match !r with\n | [] ->\n Ok ()\n | _ ->\n Error\n ( Error.tag ~tag:\"Pickles.verify\"\n @@ Error.of_list\n @@ List.map !r ~f:(fun lab -> Error.of_string (Lazy.force lab)) )\n in\n ((fun (lab, b) -> if not b then r := lab :: !r), result)\n in\n [%log internal] \"Compute_plonks_and_chals\" ;\n let _computed_bp_chals, deferred_values =\n List.map ts\n ~f:(fun\n (T\n ( _max_proofs_verified\n , _statement\n , key\n , _app_state\n , T\n { statement =\n { proof_state\n ; messages_for_next_step_proof =\n { old_bulletproof_challenges; _ }\n }\n ; prev_evals = evals\n ; proof = _\n } ) )\n ->\n Timer.start __LOC__ ;\n let non_chunking =\n let exception Is_chunked in\n match\n Pickles_types.Plonk_types.Evals.map evals.evals.evals\n ~f:(fun (x, y) ->\n if Array.length x > 1 || Array.length y > 1 then\n raise Is_chunked )\n with\n | exception Is_chunked ->\n false\n | _unit_evals ->\n (* we do not care about _unit_evals, if we reached this point, we\n know all evals have length 1 for they cannot have length 0 *)\n true\n in\n check (lazy \"only uses single chunks\", non_chunking) ;\n check\n ( lazy \"feature flags are consistent with evaluations\"\n , Pickles_types.Plonk_types.Evals.validate_feature_flags\n ~feature_flags:proof_state.deferred_values.plonk.feature_flags\n evals.evals.evals ) ;\n Timer.start __LOC__ ;\n let open Types.Wrap.Proof_state in\n let step_domain =\n Branch_data.domain proof_state.deferred_values.branch_data\n in\n check\n ( lazy \"domain size is small enough\"\n , Domain.log2_size step_domain <= Nat.to_int Backend.Tick.Rounds.n ) ;\n let sc =\n SC.to_field_constant tick_field ~endo:Endo.Wrap_inner_curve.scalar\n in\n Timer.clock __LOC__ ;\n let { Deferred_values.Minimal.plonk = _\n ; branch_data = _\n ; bulletproof_challenges\n } =\n Deferred_values.Minimal.map_challenges\n ~f:Challenge.Constant.to_tick_field ~scalar:sc\n proof_state.deferred_values\n in\n Timer.clock __LOC__ ;\n let deferred_values =\n Wrap_deferred_values.expand_deferred ~evals\n ~old_bulletproof_challenges ~proof_state\n in\n Timer.clock __LOC__ ;\n let deferred_values = { deferred_values with bulletproof_challenges } in\n let () =\n let [ Pow_2_roots_of_unity greatest_wrap_domain\n ; _\n ; Pow_2_roots_of_unity least_wrap_domain\n ] =\n Wrap_verifier.all_possible_domains ()\n in\n let actual_wrap_domain = key.index.domain.log_size_of_group in\n check\n ( lazy\n (sprintf !\"wrap_domain: %i > %i\" actual_wrap_domain\n least_wrap_domain )\n , Int.( <= ) actual_wrap_domain least_wrap_domain ) ;\n check\n ( lazy\n (sprintf !\"wrap_domain: %i < %i\" actual_wrap_domain\n greatest_wrap_domain )\n , Int.( >= ) actual_wrap_domain greatest_wrap_domain )\n in\n (bulletproof_challenges, deferred_values) )\n |> List.unzip\n in\n [%log internal] \"Compute_plonks_and_chals_done\" ;\n let open Backend.Tock.Proof in\n let open Promise.Let_syntax in\n [%log internal] \"Accumulator_check\" ;\n let%bind accumulator_check =\n Ipa.Step.accumulator_check\n (List.map ts ~f:(fun (T (_, _, _, _, T t)) ->\n ( t.statement.proof_state.messages_for_next_wrap_proof\n .challenge_polynomial_commitment\n , Ipa.Step.compute_challenges\n t.statement.proof_state.deferred_values.bulletproof_challenges ) )\n )\n in\n [%log internal] \"Accumulator_check_done\" ;\n Common.time \"batch_step_dlog_check\" (fun () ->\n check (lazy \"batch_step_dlog_check\", accumulator_check) ) ;\n [%log internal] \"Compute_batch_verify_inputs\" ;\n let batch_verify_inputs =\n List.map2_exn ts deferred_values\n ~f:(fun\n (T\n ( (module Max_proofs_verified)\n , (module A_value)\n , key\n , app_state\n , T t ) )\n deferred_values\n ->\n let prepared_statement : _ Types.Wrap.Statement.In_circuit.t =\n { messages_for_next_step_proof =\n Common.hash_messages_for_next_step_proof\n ~app_state:A_value.to_field_elements\n (Reduced_messages_for_next_proof_over_same_field.Step.prepare\n ~dlog_plonk_index:key.commitments\n { t.statement.messages_for_next_step_proof with app_state } )\n ; proof_state =\n { deferred_values =\n { plonk = deferred_values.plonk\n ; combined_inner_product =\n deferred_values.combined_inner_product\n ; b = deferred_values.b\n ; xi = deferred_values.xi\n ; bulletproof_challenges =\n deferred_values.bulletproof_challenges\n ; branch_data = deferred_values.branch_data\n }\n ; sponge_digest_before_evaluations =\n t.statement.proof_state.sponge_digest_before_evaluations\n ; messages_for_next_wrap_proof =\n Wrap_hack.hash_messages_for_next_wrap_proof\n Max_proofs_verified.n\n (Reduced_messages_for_next_proof_over_same_field.Wrap\n .prepare\n t.statement.proof_state.messages_for_next_wrap_proof )\n }\n }\n in\n let input =\n tock_unpadded_public_input_of_statement prepared_statement\n in\n let message =\n Wrap_hack.pad_accumulator\n (Vector.map2\n ~f:(fun g cs ->\n { Challenge_polynomial.challenges =\n Vector.to_array (Ipa.Wrap.compute_challenges cs)\n ; commitment = g\n } )\n (Vector.extend_front_exn\n t.statement.messages_for_next_step_proof\n .challenge_polynomial_commitments Max_proofs_verified.n\n (Lazy.force Dummy.Ipa.Wrap.sg) )\n t.statement.proof_state.messages_for_next_wrap_proof\n .old_bulletproof_challenges )\n in\n (key.index, Wrap_wire_proof.to_kimchi_proof t.proof, input, Some message) )\n in\n [%log internal] \"Compute_batch_verify_inputs_done\" ;\n [%log internal] \"Dlog_check_batch_verify\" ;\n let%map dlog_check = batch_verify batch_verify_inputs in\n [%log internal] \"Dlog_check_batch_verify_done\" ;\n Common.time \"dlog_check\" (fun () -> check (lazy \"dlog_check\", dlog_check)) ;\n result ()\n\nlet verify (type a n) (max_proofs_verified : (module Nat.Intf with type n = n))\n (a_value : (module Intf.Statement_value with type t = a))\n (key : Verification_key.t) (ts : (a * (n, n) Proof.t) list) =\n verify_heterogenous\n (List.map ts ~f:(fun (x, p) ->\n Instance.T (max_proofs_verified, a_value, key, x, p) ) )\n","open Pickles_types\nopen Hlist\nopen Import\nopen Impls.Step\nopen Step_verifier\nmodule B = Inductive_rule.B\n\n(* Converts from the one hot vector representation of a number\n 0 <= i < n\n\n 0 1 ... i-1 i i+1 n-1\n [ 0; 0; ... 0; 1; 0; ...; 0 ]\n\n to the numeric representation i. *)\n\nlet _one_hot_vector_to_num (type n) (v : n Per_proof_witness.One_hot_vector.t) :\n Field.t =\n let n = Vector.length (v :> (Boolean.var, n) Vector.t) in\n Pseudo.choose (v, Vector.init n ~f:Field.of_int) ~f:Fn.id\n\nlet verify_one ~srs\n ({ app_state\n ; wrap_proof\n ; proof_state\n ; prev_proof_evals\n ; prev_challenges\n ; prev_challenge_polynomial_commitments\n } :\n _ Per_proof_witness.t ) (d : _ Types_map.For_step.t)\n (messages_for_next_wrap_proof : Digest.t) (unfinalized : Unfinalized.t)\n (should_verify : B.t) : _ Vector.t * B.t =\n Boolean.Assert.( = ) unfinalized.should_finalize should_verify ;\n let deferred_values = proof_state.deferred_values in\n let finalized, chals =\n with_label __LOC__ (fun () ->\n let sponge_digest = proof_state.sponge_digest_before_evaluations in\n let sponge =\n let open Step_main_inputs in\n let sponge = Sponge.create sponge_params in\n Sponge.absorb sponge (`Field sponge_digest) ;\n sponge\n in\n (* TODO: Refactor args into an \"unfinalized proof\" struct *)\n finalize_other_proof d.max_proofs_verified ~step_domains:d.step_domains\n ~feature_flags:d.feature_flags ~sponge ~prev_challenges\n deferred_values prev_proof_evals )\n in\n let branch_data = deferred_values.branch_data in\n let sponge_after_index, hash_messages_for_next_step_proof =\n let to_field_elements =\n let (Typ typ) = d.public_input in\n fun x -> fst (typ.var_to_fields x)\n in\n let sponge_after_index, hash_messages_for_next_step_proof =\n (* TODO: Don't rehash when it's not necessary *)\n hash_messages_for_next_step_proof_opt ~index:d.wrap_key to_field_elements\n in\n (sponge_after_index, unstage hash_messages_for_next_step_proof)\n in\n let statement =\n let prev_messages_for_next_step_proof =\n with_label __LOC__ (fun () ->\n hash_messages_for_next_step_proof ~widths:d.proofs_verifieds\n ~max_width:(Nat.Add.n d.max_proofs_verified)\n ~proofs_verified_mask:\n (Vector.trim_front branch_data.proofs_verified_mask\n (Nat.lte_exn\n (Vector.length prev_challenge_polynomial_commitments)\n Nat.N2.n ) )\n (* Use opt sponge for cutting off the bulletproof challenges early *)\n { app_state\n ; dlog_plonk_index = d.wrap_key\n ; challenge_polynomial_commitments =\n prev_challenge_polynomial_commitments\n ; old_bulletproof_challenges = prev_challenges\n } )\n in\n { Types.Wrap.Statement.messages_for_next_step_proof =\n prev_messages_for_next_step_proof\n ; proof_state = { proof_state with messages_for_next_wrap_proof }\n }\n in\n let verified =\n with_label __LOC__ (fun () ->\n verify ~srs ~feature_flags:d.feature_flags\n ~lookup_parameters:\n { use = Plonk_checks.lookup_tables_used d.feature_flags\n ; zero =\n { var =\n { challenge = Field.zero\n ; scalar = Shifted_value Field.zero\n }\n ; value =\n { challenge = Limb_vector.Challenge.Constant.zero\n ; scalar =\n Shifted_value.Type1.Shifted_value Field.Constant.zero\n }\n }\n }\n ~proofs_verified:d.max_proofs_verified ~wrap_domain:d.wrap_domain\n ~is_base_case:(Boolean.not should_verify)\n ~sponge_after_index ~sg_old:prev_challenge_polynomial_commitments\n ~proof:wrap_proof ~wrap_verification_key:d.wrap_key statement\n unfinalized )\n in\n if debug then\n as_prover\n As_prover.(\n fun () ->\n let finalized = read Boolean.typ finalized in\n let verified = read Boolean.typ verified in\n let should_verify = read Boolean.typ should_verify in\n printf \"finalized: %b\\n%!\" finalized ;\n printf \"verified: %b\\n%!\" verified ;\n printf \"should_verify: %b\\n\\n%!\" should_verify) ;\n (chals, Boolean.(verified &&& finalized ||| not should_verify))\n\n(* The SNARK function corresponding to the input inductive rule. *)\nlet step_main :\n type proofs_verified self_branches prev_vars prev_values var value a_var a_value ret_var ret_value auxiliary_var auxiliary_value max_proofs_verified local_branches local_signature.\n (module Requests.Step.S\n with type local_signature = local_signature\n and type local_branches = local_branches\n and type statement = a_value\n and type prev_values = prev_values\n and type max_proofs_verified = max_proofs_verified\n and type proofs_verified = proofs_verified\n and type return_value = ret_value\n and type auxiliary_value = auxiliary_value )\n -> (module Nat.Add.Intf with type n = max_proofs_verified)\n -> self_branches:self_branches Nat.t\n (* How many branches does this proof system have *)\n -> local_signature:local_signature H1.T(Nat).t\n (* The specification, for each proof that this step circuit verifies, of the maximum width used\n by that proof system. *)\n -> local_signature_length:(local_signature, proofs_verified) Hlist.Length.t\n -> local_branches:\n (* For each inner proof of type T , the number of branches that type T has. *)\n local_branches H1.T(Nat).t\n -> local_branches_length:(local_branches, proofs_verified) Hlist.Length.t\n -> proofs_verified:(prev_vars, proofs_verified) Hlist.Length.t\n -> lte:(proofs_verified, max_proofs_verified) Nat.Lte.t\n -> public_input:\n ( var\n , value\n , a_var\n , a_value\n , ret_var\n , ret_value )\n Inductive_rule.public_input\n -> auxiliary_typ:(auxiliary_var, auxiliary_value) Typ.t\n -> basic:\n ( var\n , value\n , max_proofs_verified\n , self_branches )\n Types_map.Compiled.basic\n -> self:(var, value, max_proofs_verified, self_branches) Tag.t\n -> ( prev_vars\n , prev_values\n , local_signature\n , local_branches\n , a_var\n , a_value\n , ret_var\n , ret_value\n , auxiliary_var\n , auxiliary_value )\n Inductive_rule.t\n -> ( unit\n -> ( (Unfinalized.t, max_proofs_verified) Vector.t\n , Field.t\n , (Field.t, max_proofs_verified) Vector.t )\n Types.Step.Statement.t )\n Staged.t =\n fun (module Req) max_proofs_verified ~self_branches ~local_signature\n ~local_signature_length ~local_branches ~local_branches_length\n ~proofs_verified ~lte ~public_input ~auxiliary_typ ~basic ~self rule ->\n let module Typ_with_max_proofs_verified = struct\n type ('var, 'value, 'local_max_proofs_verified, 'local_branches) t =\n ( ( 'var\n , 'local_max_proofs_verified\n , 'local_branches )\n Per_proof_witness.No_app_state.t\n , ( 'value\n , 'local_max_proofs_verified\n , 'local_branches )\n Per_proof_witness.Constant.No_app_state.t )\n Typ.t\n end in\n let feature_flags (d : _ Tag.t) =\n if Type_equal.Id.same self.id d.id then basic.feature_flags\n else Types_map.feature_flags d\n in\n let feature_flags =\n let rec go :\n type pvars pvals ns1 ns2 br.\n (pvars, pvals, ns1, ns2) H4.T(Tag).t\n -> (pvars, br) Length.t\n -> (Plonk_types.Opt.Flag.t Plonk_types.Features.t, br) Vector.t =\n fun ds ld ->\n match[@warning \"-4\"] (ds, ld) with\n | [], Z ->\n []\n | d :: ds, S ld ->\n feature_flags d :: go ds ld\n | [], _ ->\n .\n | _ :: _, _ ->\n .\n in\n go rule.prevs proofs_verified\n in\n let prev_proof_typs =\n let rec join :\n type pvars pvals ns1 ns2 br.\n (pvars, pvals, ns1, ns2) H4.T(Tag).t\n -> ns1 H1.T(Nat).t\n -> ns2 H1.T(Nat).t\n -> (pvars, br) Length.t\n -> (ns1, br) Length.t\n -> (ns2, br) Length.t\n -> (Plonk_types.Opt.Flag.t Plonk_types.Features.t, br) Vector.t\n -> (pvars, pvals, ns1, ns2) H4.T(Typ_with_max_proofs_verified).t =\n fun ds ns1 ns2 ld ln1 ln2 feature_flagss ->\n match[@warning \"-4\"] (ds, ns1, ns2, ld, ln1, ln2, feature_flagss) with\n | [], [], [], Z, Z, Z, [] ->\n []\n | ( _d :: ds\n , n1 :: ns1\n , _n2 :: ns2\n , S ld\n , S ln1\n , S ln2\n , feature_flags :: feature_flagss ) ->\n let t = Per_proof_witness.typ Typ.unit n1 ~feature_flags in\n t :: join ds ns1 ns2 ld ln1 ln2 feature_flagss\n | [], _, _, _, _, _, _ ->\n .\n | _ :: _, _, _, _, _, _, _ ->\n .\n in\n join rule.prevs local_signature local_branches proofs_verified\n local_signature_length local_branches_length feature_flags\n in\n let module Prev_typ =\n H4.Typ (Impls.Step) (Typ_with_max_proofs_verified)\n (Per_proof_witness.No_app_state)\n (Per_proof_witness.Constant.No_app_state)\n (struct\n let f = Fn.id\n end)\n in\n let (input_typ, output_typ)\n : (a_var, a_value) Typ.t * (ret_var, ret_value) Typ.t =\n match public_input with\n | Input typ ->\n (typ, Typ.unit)\n | Output typ ->\n (Typ.unit, typ)\n | Input_and_output (input_typ, output_typ) ->\n (input_typ, output_typ)\n in\n let main () : _ Types.Step.Statement.t =\n let open Impls.Step in\n let logger = Internal_tracing_context_logger.get () in\n with_label \"step_main\" (fun () ->\n let module Max_proofs_verified = ( val max_proofs_verified : Nat.Add.Intf\n with type n = max_proofs_verified\n )\n in\n let T = Max_proofs_verified.eq in\n let app_state = exists input_typ ~request:(fun () -> Req.App_state) in\n let { Inductive_rule.previous_proof_statements\n ; public_output = ret_var\n ; auxiliary_output = auxiliary_var\n } =\n (* Run the application logic of the rule on the predecessor statements *)\n with_label \"rule_main\" (fun () ->\n rule.main { public_input = app_state } )\n in\n let () =\n exists Typ.unit ~request:(fun () ->\n let ret_value = As_prover.read output_typ ret_var in\n Req.Return_value ret_value )\n in\n let () =\n exists Typ.unit ~request:(fun () ->\n let auxiliary_value =\n As_prover.read auxiliary_typ auxiliary_var\n in\n Req.Auxiliary_value auxiliary_value )\n in\n (* Compute proof parts outside of the prover before requesting values.\n *)\n exists Typ.unit ~request:(fun () ->\n let previous_proof_statements =\n let rec go :\n type prev_vars prev_values ns1 ns2.\n ( prev_vars\n , ns1 )\n H2.T(Inductive_rule.Previous_proof_statement).t\n -> (prev_vars, prev_values, ns1, ns2) H4.T(Tag).t\n -> ( prev_values\n , ns1 )\n H2.T(Inductive_rule.Previous_proof_statement.Constant).t =\n fun previous_proof_statement tags ->\n match (previous_proof_statement, tags) with\n | [], [] ->\n []\n | ( { public_input; proof; proof_must_verify } :: stmts\n , tag :: tags ) ->\n let public_input =\n (fun (type var value n m) (tag : (var, value, n, m) Tag.t)\n (var : var) : value ->\n let typ : (var, value) Typ.t =\n match Type_equal.Id.same_witness self.id tag.id with\n | Some T ->\n basic.public_input\n | None ->\n Types_map.public_input tag\n in\n As_prover.read typ var )\n tag public_input\n in\n { public_input\n ; proof = As_prover.Ref.get proof\n ; proof_must_verify =\n As_prover.read Boolean.typ proof_must_verify\n }\n :: go stmts tags\n in\n go previous_proof_statements rule.prevs\n in\n Req.Compute_prev_proof_parts previous_proof_statements ) ;\n let dlog_plonk_index =\n exists\n ~request:(fun () -> Req.Wrap_index)\n (Plonk_verification_key_evals.typ Inner_curve.typ)\n and prevs =\n exists (Prev_typ.f prev_proof_typs) ~request:(fun () ->\n Req.Proof_with_datas )\n and unfinalized_proofs_unextended =\n exists\n (Vector.typ'\n (Vector.map\n ~f:(fun _feature_flags ->\n Unfinalized.typ ~wrap_rounds:Backend.Tock.Rounds.n )\n feature_flags ) )\n ~request:(fun () -> Req.Unfinalized_proofs)\n and messages_for_next_wrap_proof =\n exists (Vector.typ Digest.typ Max_proofs_verified.n)\n ~request:(fun () -> Req.Messages_for_next_wrap_proof)\n and actual_wrap_domains =\n exists\n (Vector.typ (Typ.Internal.ref ()) (Length.to_nat proofs_verified))\n ~request:(fun () -> Req.Wrap_domain_indices)\n in\n let prevs =\n (* Inject the app-state values into the per-proof witnesses. *)\n let rec go :\n type vars ns1 ns2.\n (vars, ns1, ns2) H3.T(Per_proof_witness.No_app_state).t\n -> (vars, ns1) H2.T(Inductive_rule.Previous_proof_statement).t\n -> (vars, ns1, ns2) H3.T(Per_proof_witness).t =\n fun proofs stmts ->\n match (proofs, stmts) with\n | [], [] ->\n []\n | proof :: proofs, stmt :: stmts ->\n { proof with app_state = stmt.public_input } :: go proofs stmts\n in\n go prevs previous_proof_statements\n in\n let srs = Backend.Tock.Keypair.load_urs () in\n [%log internal] \"Step_compute_bulletproof_challenges\" ;\n let bulletproof_challenges =\n with_label \"prevs_verified\" (fun () ->\n let rec go :\n type vars vals ns1 ns2 n.\n (vars, ns1, ns2) H3.T(Per_proof_witness).t\n -> (vars, vals, ns1, ns2) H4.T(Types_map.For_step).t\n -> vars H1.T(E01(Digest)).t\n -> vars H1.T(E01(Unfinalized)).t\n -> (vars, ns1) H2.T(Inductive_rule.Previous_proof_statement).t\n -> (vars, n) Length.t\n -> actual_wrap_domains:\n ( Pickles_base.Proofs_verified.t As_prover.Ref.t\n , n )\n Vector.t\n -> (_, n) Vector.t * B.t list =\n fun proofs datas messages_for_next_wrap_proofs unfinalizeds stmts\n pi ~actual_wrap_domains ->\n match\n ( proofs\n , datas\n , messages_for_next_wrap_proofs\n , unfinalizeds\n , stmts\n , pi\n , actual_wrap_domains )\n with\n | [], [], [], [], [], Z, [] ->\n ([], [])\n | ( p :: proofs\n , d :: datas\n , messages_for_next_wrap_proof\n :: messages_for_next_wrap_proofs\n , unfinalized :: unfinalizeds\n , { proof_must_verify = should_verify; _ } :: stmts\n , S pi\n , actual_wrap_domain :: actual_wrap_domains ) ->\n let () =\n (* Fail with an error if the proof's domain differs from\n the hard-coded one otherwise.\n *)\n match d.wrap_domain with\n | `Known wrap_domain ->\n as_prover (fun () ->\n let actual_wrap_domain =\n As_prover.Ref.get actual_wrap_domain\n |> Pickles_base.Proofs_verified.to_int\n in\n let actual_wrap_domain =\n Common.wrap_domains\n ~proofs_verified:actual_wrap_domain\n in\n match (wrap_domain, actual_wrap_domain.h) with\n | ( Pow_2_roots_of_unity expected\n , Pow_2_roots_of_unity actual )\n when expected <> actual ->\n failwithf\n \"This circuit was compiled for proofs \\\n using the wrap domain of size %d, but a \\\n proof was given with size %d. You should \\\n pass the ~override_wrap_domain argument \\\n to set the correct domain size.\"\n expected actual ()\n | Pow_2_roots_of_unity _, Pow_2_roots_of_unity _\n ->\n () )\n | `Side_loaded _ ->\n ()\n in\n let chals, v =\n verify_one ~srs p d messages_for_next_wrap_proof\n unfinalized should_verify\n in\n let chalss, vs =\n go proofs datas messages_for_next_wrap_proofs unfinalizeds\n stmts pi ~actual_wrap_domains\n in\n (chals :: chalss, v :: vs)\n in\n let chalss, vs =\n let messages_for_next_wrap_proofs =\n with_label \"messages_for_next_wrap_proofs\" (fun () ->\n let module V = H1.Of_vector (Digest) in\n V.f proofs_verified\n (Vector.trim_front messages_for_next_wrap_proof lte) )\n and unfinalized_proofs =\n let module H = H1.Of_vector (Unfinalized) in\n H.f proofs_verified unfinalized_proofs_unextended\n and datas =\n let self_data :\n ( var\n , value\n , max_proofs_verified\n , self_branches )\n Types_map.For_step.t =\n { branches = self_branches\n ; proofs_verifieds =\n `Known\n (Vector.map basic.proofs_verifieds ~f:Field.of_int)\n ; max_proofs_verified\n ; public_input = basic.public_input\n ; wrap_domain = `Known basic.wrap_domains.h\n ; step_domains = `Known basic.step_domains\n ; wrap_key = dlog_plonk_index\n ; feature_flags = basic.feature_flags\n }\n in\n let module M =\n H4.Map (Tag) (Types_map.For_step)\n (struct\n let f :\n type a1 a2 n m.\n (a1, a2, n, m) Tag.t\n -> (a1, a2, n, m) Types_map.For_step.t =\n fun tag ->\n match Type_equal.Id.same_witness self.id tag.id with\n | Some T ->\n self_data\n | None -> (\n match tag.kind with\n | Compiled ->\n Types_map.For_step.of_compiled\n (Types_map.lookup_compiled tag.id)\n | Side_loaded ->\n Types_map.For_step.of_side_loaded\n (Types_map.lookup_side_loaded tag.id) )\n end)\n in\n M.f rule.prevs\n in\n go prevs datas messages_for_next_wrap_proofs unfinalized_proofs\n previous_proof_statements proofs_verified ~actual_wrap_domains\n in\n Boolean.Assert.all vs ; chalss )\n in\n [%log internal] \"Step_compute_bulletproof_challenges_done\" ;\n let messages_for_next_step_proof =\n let challenge_polynomial_commitments =\n let module M =\n H3.Map (Per_proof_witness) (E03 (Inner_curve))\n (struct\n let f :\n type a b c. (a, b, c) Per_proof_witness.t -> Inner_curve.t\n =\n fun acc ->\n acc.wrap_proof.opening.challenge_polynomial_commitment\n end)\n in\n let module V = H3.To_vector (Inner_curve) in\n V.f proofs_verified (M.f prevs)\n in\n with_label \"hash_messages_for_next_step_proof\" (fun () ->\n let hash_messages_for_next_step_proof =\n let to_field_elements =\n let (Typ typ) = basic.public_input in\n fun x -> fst (typ.var_to_fields x)\n in\n unstage\n (hash_messages_for_next_step_proof ~index:dlog_plonk_index\n to_field_elements )\n in\n let (app_state : var) =\n match public_input with\n | Input _ ->\n app_state\n | Output _ ->\n ret_var\n | Input_and_output _ ->\n (app_state, ret_var)\n in\n hash_messages_for_next_step_proof\n { app_state\n ; dlog_plonk_index\n ; challenge_polynomial_commitments\n ; old_bulletproof_challenges =\n (* Note: the bulletproof_challenges here are unpadded! *)\n bulletproof_challenges\n } )\n in\n let unfinalized_proofs =\n Vector.extend_front unfinalized_proofs_unextended lte\n Max_proofs_verified.n (Unfinalized.dummy ())\n in\n ( { Types.Step.Statement.proof_state =\n { unfinalized_proofs; messages_for_next_step_proof }\n ; messages_for_next_wrap_proof\n }\n : ( (Unfinalized.t, max_proofs_verified) Vector.t\n , Field.t\n , (Field.t, max_proofs_verified) Vector.t )\n Types.Step.Statement.t ) )\n in\n stage main\n","open Core_kernel\nopen Pickles_types\nopen Hlist\nopen Import\n\n(* The data obtained from \"compiling\" an inductive rule into a circuit. *)\ntype ( 'a_var\n , 'a_value\n , 'ret_var\n , 'ret_value\n , 'auxiliary_var\n , 'auxiliary_value\n , 'max_proofs_verified\n , 'branches\n , 'prev_vars\n , 'prev_values\n , 'local_widths\n , 'local_heights )\n t =\n | T :\n { proofs_verified :\n 'proofs_verified Nat.t * ('prev_vars, 'proofs_verified) Hlist.Length.t\n ; index : int\n ; lte : ('proofs_verified, 'max_proofs_verified) Nat.Lte.t\n ; domains : Domains.t\n ; rule :\n ( 'prev_vars\n , 'prev_values\n , 'local_widths\n , 'local_heights\n , 'a_var\n , 'a_value\n , 'ret_var\n , 'ret_value\n , 'auxiliary_var\n , 'auxiliary_value )\n Inductive_rule.t\n ; main :\n step_domains:(Domains.t, 'branches) Vector.t\n -> unit\n -> ( (Unfinalized.t, 'max_proofs_verified) Vector.t\n , Impls.Step.Field.t\n , (Impls.Step.Field.t, 'max_proofs_verified) Vector.t )\n Types.Step.Statement.t\n ; requests :\n (module Requests.Step.S\n with type statement = 'a_value\n and type max_proofs_verified = 'max_proofs_verified\n and type proofs_verified = 'proofs_verified\n and type prev_values = 'prev_values\n and type local_signature = 'local_widths\n and type local_branches = 'local_heights\n and type return_value = 'ret_value\n and type auxiliary_value = 'auxiliary_value )\n ; feature_flags : bool Plonk_types.Features.t\n }\n -> ( 'a_var\n , 'a_value\n , 'ret_var\n , 'ret_value\n , 'auxiliary_var\n , 'auxiliary_value\n , 'max_proofs_verified\n , 'branches\n , 'prev_vars\n , 'prev_values\n , 'local_widths\n , 'local_heights )\n t\n\n(* Compile an inductive rule. *)\nlet create\n (type branches max_proofs_verified var value a_var a_value ret_var ret_value)\n ~index ~(self : (var, value, max_proofs_verified, branches) Tag.t)\n ~wrap_domains\n ~(feature_flags : Plonk_types.Opt.Flag.t Plonk_types.Features.t)\n ~(actual_feature_flags : bool Plonk_types.Features.t)\n ~(max_proofs_verified : max_proofs_verified Nat.t)\n ~(proofs_verifieds : (int, branches) Vector.t) ~(branches : branches Nat.t)\n ~(public_input :\n ( var\n , value\n , a_var\n , a_value\n , ret_var\n , ret_value )\n Inductive_rule.public_input ) ~auxiliary_typ _var_to_field_elements\n _value_to_field_elements (rule : _ Inductive_rule.t) =\n Timer.clock __LOC__ ;\n let module HT = H4.T (Tag) in\n let (T (self_width, proofs_verified)) = HT.length rule.prevs in\n let rec extract_lengths :\n type a b n m k.\n (a, b, n, m) HT.t\n -> (a, k) Length.t\n -> n H1.T(Nat).t * m H1.T(Nat).t * (n, k) Length.t * (m, k) Length.t =\n fun ts len ->\n match (ts, len) with\n | [], Z ->\n ([], [], Z, Z)\n | t :: ts, S len -> (\n let ns, ms, len_ns, len_ms = extract_lengths ts len in\n match Type_equal.Id.same_witness self.id t.id with\n | Some T ->\n (max_proofs_verified :: ns, branches :: ms, S len_ns, S len_ms)\n | None ->\n let (module M), branches =\n match t.kind with\n | Compiled ->\n let d = Types_map.lookup_compiled t.id in\n (d.max_proofs_verified, d.branches)\n | Side_loaded ->\n let d = Types_map.lookup_side_loaded t.id in\n (d.permanent.max_proofs_verified, d.permanent.branches)\n in\n let T = M.eq in\n (M.n :: ns, branches :: ms, S len_ns, S len_ms) )\n in\n Timer.clock __LOC__ ;\n let widths, heights, local_signature_length, local_branches_length =\n extract_lengths rule.prevs proofs_verified\n in\n let lte = Nat.lte_exn self_width max_proofs_verified in\n let requests = Requests.Step.create () in\n let (typ : (var, value) Impls.Step.Typ.t) =\n match public_input with\n | Input typ ->\n typ\n | Output typ ->\n typ\n | Input_and_output (input_typ, output_typ) ->\n Impls.Step.Typ.(input_typ * output_typ)\n in\n Timer.clock __LOC__ ;\n let step ~step_domains =\n Step_main.step_main requests\n (Nat.Add.create max_proofs_verified)\n rule\n ~basic:\n { public_input = typ\n ; proofs_verifieds\n ; wrap_domains\n ; step_domains\n ; feature_flags\n }\n ~public_input ~auxiliary_typ ~self_branches:branches ~proofs_verified\n ~local_signature:widths ~local_signature_length ~local_branches:heights\n ~local_branches_length ~lte ~self\n |> unstage\n in\n Timer.clock __LOC__ ;\n let own_domains =\n let main =\n step\n ~step_domains:\n (Vector.init branches ~f:(fun _ -> Fix_domains.rough_domains))\n in\n let etyp =\n Impls.Step.input ~proofs_verified:max_proofs_verified\n ~wrap_rounds:Backend.Tock.Rounds.n ~feature_flags\n (* TODO *)\n in\n Fix_domains.domains\n (module Impls.Step)\n (T (Snarky_backendless.Typ.unit (), Fn.id, Fn.id))\n etyp main\n in\n Timer.clock __LOC__ ;\n T\n { proofs_verified = (self_width, proofs_verified)\n ; index\n ; lte\n ; rule\n ; domains = own_domains\n ; main = step\n ; requests\n ; feature_flags = actual_feature_flags\n }\n","module SC = Scalar_challenge\nopen Pickles_types\nopen Poly_types\nopen Hlist\nopen Backend\nopen Tuple_lib\nopen Import\nopen Types\nopen Common\n\n(* This contains the \"step\" prover *)\n\nmodule Make\n (A : T0) (A_value : sig\n type t\n end)\n (Max_proofs_verified : Nat.Add.Intf_transparent) =\nstruct\n let _double_zip = Double.map2 ~f:Core_kernel.Tuple2.create\n\n module E = struct\n type t = Tock.Field.t array Double.t Plonk_types.Evals.t * Tock.Field.t\n end\n\n module Plonk_checks = struct\n include Plonk_checks\n module Type1 = Plonk_checks.Make (Shifted_value.Type1) (Scalars.Tick)\n module Type2 = Plonk_checks.Make (Shifted_value.Type2) (Scalars.Tock)\n end\n\n (* The prover corresponding to the given inductive rule. *)\n let f\n (type (* The maximum number of proofs verified by one of the proof systems verified by this rule :)\n\n In other words: each of the proofs verified by this rule comes from some pickles proof system.\n\n The ith one of those proof systems has a maximum number of proofs N_i that is verified by\n a rule in proof system i. max_local_max_proof_verifieds is the max of the N_i.\n *)\n max_local_max_proof_verifieds self_branches prev_vars prev_values\n local_widths local_heights prevs_length var value ret_var ret_value\n auxiliary_var auxiliary_value ) ?handler\n (T branch_data :\n ( A.t\n , A_value.t\n , ret_var\n , ret_value\n , auxiliary_var\n , auxiliary_value\n , Max_proofs_verified.n\n , self_branches\n , prev_vars\n , prev_values\n , local_widths\n , local_heights )\n Step_branch_data.t ) (next_state : A_value.t)\n ~maxes:\n (module Maxes : Pickles_types.Hlist.Maxes.S\n with type length = Max_proofs_verified.n\n and type ns = max_local_max_proof_verifieds )\n ~(prevs_length : (prev_vars, prevs_length) Length.t) ~self ~step_domains\n ~feature_flags ~self_dlog_plonk_index\n ~(public_input :\n ( var\n , value\n , A.t\n , A_value.t\n , ret_var\n , ret_value )\n Inductive_rule.public_input )\n ~(auxiliary_typ : (auxiliary_var, auxiliary_value) Impls.Step.Typ.t) pk\n self_dlog_vk :\n ( ( value\n , (_, Max_proofs_verified.n) Vector.t\n , (_, prevs_length) Vector.t\n , (_, prevs_length) Vector.t\n , _\n , (_, Max_proofs_verified.n) Vector.t )\n Proof.Base.Step.t\n * ret_value\n * auxiliary_value\n * (int, prevs_length) Vector.t )\n Promise.t =\n let logger = Internal_tracing_context_logger.get () in\n [%log internal] \"Pickles_step_proof\" ;\n let _ = auxiliary_typ in\n (* unused *)\n let _, prev_vars_length = branch_data.proofs_verified in\n let T = Length.contr prev_vars_length prevs_length in\n let (module Req) = branch_data.requests in\n let T =\n Hlist.Length.contr (snd branch_data.proofs_verified) prev_vars_length\n in\n let prev_values_length =\n let module L12 = H4.Length_1_to_2 (Tag) in\n L12.f branch_data.rule.prevs prev_vars_length\n in\n let lte = branch_data.lte in\n let module X_hat = struct\n type t = Tock.Field.t Double.t\n end in\n let module Statement_with_hashes = struct\n type t =\n ( Challenge.Constant.t\n , Challenge.Constant.t Scalar_challenge.t\n , Tick.Field.t Shifted_value.Type1.t\n , Tick.Field.t Shifted_value.Type1.t option\n , Challenge.Constant.t Scalar_challenge.t\n Types.Wrap.Proof_state.Deferred_values.Plonk.In_circuit.Lookup.t\n option\n , bool\n , Digest.Constant.t\n , Digest.Constant.t\n , Digest.Constant.t\n , Challenge.Constant.t Scalar_challenge.t Bulletproof_challenge.t\n Step_bp_vec.t\n , Branch_data.t )\n Wrap.Statement.In_circuit.t\n end in\n let challenge_polynomial =\n Wrap_verifier.challenge_polynomial (module Backend.Tock.Field)\n in\n let expand_proof :\n type var value local_max_proofs_verified m.\n Impls.Wrap.Verification_key.t\n -> 'a\n -> value\n -> (local_max_proofs_verified, local_max_proofs_verified) Proof.t\n -> (var, value, local_max_proofs_verified, m) Tag.t\n -> must_verify:bool\n -> [ `Sg of Tock.Curve.Affine.t ]\n * Unfinalized.Constant.t\n * Statement_with_hashes.t\n * X_hat.t\n * ( value\n , local_max_proofs_verified\n , m )\n Per_proof_witness.Constant.No_app_state.t\n * [ `Actual_wrap_domain of int ] =\n fun dlog_vk dlog_index app_state (T t) tag ~must_verify ->\n let t =\n { t with\n statement =\n { t.statement with\n messages_for_next_step_proof =\n { t.statement.messages_for_next_step_proof with app_state }\n }\n }\n in\n let proof = Wrap_wire_proof.to_kimchi_proof t.proof in\n let data = Types_map.lookup_basic tag in\n let plonk0 = t.statement.proof_state.deferred_values.plonk in\n let plonk =\n let domain =\n Branch_data.domain t.statement.proof_state.deferred_values.branch_data\n in\n let to_field =\n SC.to_field_constant\n (module Tick.Field)\n ~endo:Endo.Wrap_inner_curve.scalar\n in\n let alpha = to_field plonk0.alpha in\n let zeta = to_field plonk0.zeta in\n let zetaw =\n Tick.Field.(\n zeta * domain_generator ~log2_size:(Domain.log2_size domain))\n in\n let combined_evals =\n Plonk_checks.evals_of_split_evals\n (module Tick.Field)\n t.prev_evals.evals.evals ~rounds:(Nat.to_int Tick.Rounds.n) ~zeta\n ~zetaw\n |> Plonk_types.Evals.to_in_circuit\n in\n let plonk_minimal =\n { Composition_types.Wrap.Proof_state.Deferred_values.Plonk.Minimal\n .zeta\n ; alpha\n ; beta = Challenge.Constant.to_tick_field plonk0.beta\n ; gamma = Challenge.Constant.to_tick_field plonk0.gamma\n ; joint_combiner = Option.map ~f:to_field plonk0.joint_combiner\n ; feature_flags = plonk0.feature_flags\n }\n in\n let env =\n let module Env_bool = struct\n type t = bool\n\n let true_ = true\n\n let false_ = false\n\n let ( &&& ) = ( && )\n\n let ( ||| ) = ( || )\n\n let any = List.exists ~f:Fn.id\n end in\n let module Env_field = struct\n include Tick.Field\n\n type bool = Env_bool.t\n\n let if_ (b : bool) ~then_ ~else_ = if b then then_ () else else_ ()\n end in\n Plonk_checks.scalars_env\n (module Env_bool)\n (module Env_field)\n ~srs_length_log2:Common.Max_degree.step_log2\n ~endo:Endo.Step_inner_curve.base ~mds:Tick_field_sponge.params.mds\n ~field_of_hex:(fun s ->\n Kimchi_pasta.Pasta.Bigint256.of_hex_string s\n |> Kimchi_pasta.Pasta.Fp.of_bigint )\n ~domain:\n (Plonk_checks.domain\n (module Tick.Field)\n domain ~shifts:Common.tick_shifts\n ~domain_generator:Backend.Tick.Field.domain_generator )\n plonk_minimal combined_evals\n in\n time \"plonk_checks\" (fun () ->\n let module Field = struct\n include Tick.Field\n end in\n Plonk_checks.Type1.derive_plonk\n (module Field)\n ~env ~shift:Shifts.tick1 plonk_minimal combined_evals )\n in\n let (module Local_max_proofs_verified) = data.max_proofs_verified in\n let T = Local_max_proofs_verified.eq in\n let statement = t.statement in\n let prev_challenges =\n (* TODO: This is redone in the call to Reduced_messages_for_next_proof_over_same_field.Wrap.prepare *)\n Vector.map ~f:Ipa.Wrap.compute_challenges\n statement.proof_state.messages_for_next_wrap_proof\n .old_bulletproof_challenges\n in\n let deferred_values_computed =\n Wrap_deferred_values.expand_deferred ~evals:t.prev_evals\n ~old_bulletproof_challenges:\n statement.messages_for_next_step_proof.old_bulletproof_challenges\n ~proof_state:statement.proof_state\n in\n let prev_statement_with_hashes :\n ( _\n , _\n , _ Shifted_value.Type1.t\n , _\n , _\n , _\n , _\n , _\n , _\n , _\n , _ )\n Wrap.Statement.In_circuit.t =\n { messages_for_next_step_proof =\n (let to_field_elements =\n let (Typ typ) = data.public_input in\n fun x -> fst (typ.value_to_fields x)\n in\n (* TODO: Only do this hashing when necessary *)\n Common.hash_messages_for_next_step_proof\n (Reduced_messages_for_next_proof_over_same_field.Step.prepare\n ~dlog_plonk_index:dlog_index\n statement.messages_for_next_step_proof )\n ~app_state:to_field_elements )\n ; proof_state =\n { deferred_values =\n (let deferred_values = deferred_values_computed in\n { plonk =\n { plonk with\n zeta = plonk0.zeta\n ; alpha = plonk0.alpha\n ; beta = plonk0.beta\n ; gamma = plonk0.gamma\n ; lookup =\n Option.map (Opt.to_option_unsafe plonk.lookup)\n ~f:(fun _ ->\n { Composition_types.Wrap.Proof_state\n .Deferred_values\n .Plonk\n .In_circuit\n .Lookup\n .joint_combiner =\n Option.value_exn plonk0.joint_combiner\n } )\n }\n ; combined_inner_product =\n deferred_values.combined_inner_product\n ; b = deferred_values.b\n ; xi = deferred_values.xi\n ; bulletproof_challenges =\n statement.proof_state.deferred_values\n .bulletproof_challenges\n ; branch_data = deferred_values.branch_data\n } )\n ; sponge_digest_before_evaluations =\n statement.proof_state.sponge_digest_before_evaluations\n ; messages_for_next_wrap_proof =\n Wrap_hack.hash_messages_for_next_wrap_proof\n Local_max_proofs_verified.n\n { old_bulletproof_challenges = prev_challenges\n ; challenge_polynomial_commitment =\n statement.proof_state.messages_for_next_wrap_proof\n .challenge_polynomial_commitment\n }\n }\n }\n in\n let module O = Tock.Oracles in\n let o =\n let public_input =\n tock_public_input_of_statement prev_statement_with_hashes\n in\n O.create dlog_vk\n ( Vector.map2\n (Vector.extend_front_exn\n statement.messages_for_next_step_proof\n .challenge_polynomial_commitments Local_max_proofs_verified.n\n (Lazy.force Dummy.Ipa.Wrap.sg) )\n (* This should indeed have length Max_proofs_verified... No! It should have type Max_proofs_verified_a. That is, the max_proofs_verified specific to a proof of this type...*)\n prev_challenges\n ~f:(fun commitment chals ->\n { Tock.Proof.Challenge_polynomial.commitment\n ; challenges = Vector.to_array chals\n } )\n |> Wrap_hack.pad_accumulator )\n public_input proof\n in\n let ((x_hat_1, _x_hat_2) as x_hat) = O.(p_eval_1 o, p_eval_2 o) in\n let scalar_chal f =\n Scalar_challenge.map ~f:Challenge.Constant.of_tock_field (f o)\n in\n let plonk0 =\n { Types.Wrap.Proof_state.Deferred_values.Plonk.Minimal.alpha =\n scalar_chal O.alpha\n ; beta = O.beta o\n ; gamma = O.gamma o\n ; zeta = scalar_chal O.zeta\n ; joint_combiner =\n Option.map\n ~f:(Scalar_challenge.map ~f:Challenge.Constant.of_tock_field)\n (O.joint_combiner_chal o)\n ; feature_flags =\n t.statement.proof_state.deferred_values.plonk.feature_flags\n }\n in\n let xi = scalar_chal O.v in\n let r = scalar_chal O.u in\n let sponge_digest_before_evaluations = O.digest_before_evaluations o in\n let to_field =\n SC.to_field_constant\n (module Tock.Field)\n ~endo:Endo.Step_inner_curve.scalar\n in\n let module As_field = struct\n let r = to_field r\n\n let xi = to_field xi\n\n let zeta = to_field plonk0.zeta\n\n let alpha = to_field plonk0.alpha\n\n let joint_combiner = O.joint_combiner o\n end in\n let w =\n Tock.Field.domain_generator ~log2_size:dlog_vk.domain.log_size_of_group\n in\n let zetaw = Tock.Field.mul As_field.zeta w in\n let new_bulletproof_challenges, b =\n let prechals =\n Array.map (O.opening_prechallenges o) ~f:(fun x ->\n Scalar_challenge.map ~f:Challenge.Constant.of_tock_field x )\n in\n let chals =\n Array.map prechals ~f:(fun x -> Ipa.Wrap.compute_challenge x)\n in\n let challenge_polynomial = unstage (challenge_polynomial chals) in\n let open As_field in\n let b =\n let open Tock.Field in\n challenge_polynomial zeta + (r * challenge_polynomial zetaw)\n in\n let prechals =\n Vector.of_list_and_length_exn\n (Array.map prechals ~f:Bulletproof_challenge.unpack |> Array.to_list)\n Tock.Rounds.n\n in\n (prechals, b)\n in\n let challenge_polynomial_commitment =\n if not must_verify then Ipa.Wrap.compute_sg new_bulletproof_challenges\n else proof.openings.proof.challenge_polynomial_commitment\n in\n let witness : _ Per_proof_witness.Constant.No_app_state.t =\n { app_state = ()\n ; proof_state =\n { prev_statement_with_hashes.proof_state with\n messages_for_next_wrap_proof = ()\n }\n ; prev_proof_evals = t.prev_evals\n ; prev_challenge_polynomial_commitments =\n Vector.extend_front_exn\n t.statement.messages_for_next_step_proof\n .challenge_polynomial_commitments Local_max_proofs_verified.n\n (Lazy.force Dummy.Ipa.Wrap.sg)\n (* TODO: This computation is also redone elsewhere. *)\n ; prev_challenges =\n Vector.extend_front_exn\n (Vector.map\n t.statement.messages_for_next_step_proof\n .old_bulletproof_challenges ~f:Ipa.Step.compute_challenges )\n Local_max_proofs_verified.n Dummy.Ipa.Step.challenges_computed\n ; wrap_proof =\n { opening =\n { proof.openings.proof with challenge_polynomial_commitment }\n ; messages = proof.messages\n }\n }\n in\n let tock_domain =\n Plonk_checks.domain\n (module Tock.Field)\n (Pow_2_roots_of_unity dlog_vk.domain.log_size_of_group)\n ~shifts:Common.tock_shifts\n ~domain_generator:Backend.Tock.Field.domain_generator\n in\n let tock_combined_evals =\n Plonk_checks.evals_of_split_evals\n (module Tock.Field)\n proof.openings.evals ~rounds:(Nat.to_int Tock.Rounds.n)\n ~zeta:As_field.zeta ~zetaw\n |> Plonk_types.Evals.to_in_circuit\n in\n let tock_plonk_minimal =\n { plonk0 with\n zeta = As_field.zeta\n ; alpha = As_field.alpha\n ; joint_combiner = As_field.joint_combiner\n }\n in\n let tock_env =\n let module Env_bool = struct\n type t = bool\n\n let true_ = true\n\n let false_ = false\n\n let ( &&& ) = ( && )\n\n let ( ||| ) = ( || )\n\n let any = List.exists ~f:Fn.id\n end in\n let module Env_field = struct\n include Tock.Field\n\n type bool = Env_bool.t\n\n let if_ (b : bool) ~then_ ~else_ = if b then then_ () else else_ ()\n end in\n Plonk_checks.scalars_env\n (module Env_bool)\n (module Env_field)\n ~domain:tock_domain ~srs_length_log2:Common.Max_degree.wrap_log2\n ~field_of_hex:(fun s ->\n Kimchi_pasta.Pasta.Bigint256.of_hex_string s\n |> Kimchi_pasta.Pasta.Fq.of_bigint )\n ~endo:Endo.Wrap_inner_curve.base ~mds:Tock_field_sponge.params.mds\n tock_plonk_minimal tock_combined_evals\n in\n let combined_inner_product =\n let e = proof.openings.evals in\n let b_polys =\n Vector.map\n ~f:(fun chals ->\n unstage (challenge_polynomial (Vector.to_array chals)) )\n (Wrap_hack.pad_challenges prev_challenges)\n in\n let a = Plonk_types.Evals.to_list e in\n let open As_field in\n let combine ~which_eval ~ft_eval pt =\n let f (x, y) = match which_eval with `Fst -> x | `Snd -> y in\n let v : Tock.Field.t array list =\n let a = List.map ~f a in\n List.append\n (Vector.to_list (Vector.map b_polys ~f:(fun f -> [| f pt |])))\n ([| f x_hat |] :: [| ft_eval |] :: a)\n in\n let open Tock.Field in\n Pcs_batch.combine_split_evaluations ~xi ~init:Fn.id\n ~mul_and_add:(fun ~acc ~xi fx -> fx + (xi * acc))\n v\n in\n let ft_eval0 =\n Plonk_checks.Type2.ft_eval0\n (module Tock.Field)\n ~domain:tock_domain ~env:tock_env tock_plonk_minimal\n tock_combined_evals x_hat_1\n in\n let open Tock.Field in\n combine ~which_eval:`Fst ~ft_eval:ft_eval0 As_field.zeta\n + (r * combine ~which_eval:`Snd ~ft_eval:proof.openings.ft_eval1 zetaw)\n in\n let chal = Challenge.Constant.of_tock_field in\n let plonk =\n let module Field = struct\n include Tock.Field\n end in\n (* Wrap proof, no features *)\n Plonk_checks.Type2.derive_plonk\n (module Field)\n ~env:tock_env ~shift:Shifts.tock2 tock_plonk_minimal\n tock_combined_evals\n |> Composition_types.Step.Proof_state.Deferred_values.Plonk.In_circuit\n .of_wrap\n ~assert_none:(fun x -> assert (Option.is_none (Opt.to_option x)))\n ~assert_false:(fun x -> assert (not x))\n in\n let shifted_value =\n Shifted_value.Type2.of_field (module Tock.Field) ~shift:Shifts.tock2\n in\n ( `Sg challenge_polynomial_commitment\n , { Types.Step.Proof_state.Per_proof.deferred_values =\n { plonk =\n { plonk with\n zeta = plonk0.zeta\n ; alpha = plonk0.alpha\n ; beta = chal plonk0.beta\n ; gamma = chal plonk0.gamma\n }\n ; combined_inner_product = shifted_value combined_inner_product\n ; xi\n ; bulletproof_challenges = new_bulletproof_challenges\n ; b = shifted_value b\n }\n ; should_finalize = must_verify\n ; sponge_digest_before_evaluations =\n Digest.Constant.of_tock_field sponge_digest_before_evaluations\n }\n , prev_statement_with_hashes\n , x_hat\n , witness\n , `Actual_wrap_domain dlog_vk.domain.log_size_of_group )\n in\n let challenge_polynomial_commitments = ref None in\n let unfinalized_proofs = ref None in\n let statements_with_hashes = ref None in\n let x_hats = ref None in\n let witnesses = ref None in\n let prev_proofs = ref None in\n let return_value = ref None in\n let auxiliary_value = ref None in\n let actual_wrap_domains = ref None in\n let compute_prev_proof_parts prev_proof_requests =\n let ( challenge_polynomial_commitments'\n , unfinalized_proofs'\n , statements_with_hashes'\n , x_hats'\n , witnesses'\n , prev_proofs'\n , actual_wrap_domains' ) =\n let[@warning \"-4\"] rec go :\n type vars values ns ms k.\n (vars, values, ns, ms) H4.T(Tag).t\n -> ( values\n , ns )\n H2.T(Inductive_rule.Previous_proof_statement.Constant).t\n -> (vars, k) Length.t\n -> (Tock.Curve.Affine.t, k) Vector.t\n * (Unfinalized.Constant.t, k) Vector.t\n * (Statement_with_hashes.t, k) Vector.t\n * (X_hat.t, k) Vector.t\n * ( values\n , ns\n , ms )\n H3.T(Per_proof_witness.Constant.No_app_state).t\n * (ns, ns) H2.T(Proof).t\n * (int, k) Vector.t =\n fun ts prev_proof_stmts l ->\n match (ts, prev_proof_stmts, l) with\n | [], [], Z ->\n ([], [], [], [], [], [], [])\n | ( t :: ts\n , { public_input = app_state\n ; proof = p\n ; proof_must_verify = must_verify\n }\n :: prev_proof_stmts\n , S l ) ->\n let dlog_vk, dlog_index =\n if Type_equal.Id.same self.Tag.id t.id then\n (self_dlog_vk, self_dlog_plonk_index)\n else\n let d = Types_map.lookup_basic t in\n (d.wrap_vk, d.wrap_key)\n in\n let `Sg sg, u, s, x, w, `Actual_wrap_domain domain =\n expand_proof dlog_vk dlog_index app_state p t ~must_verify\n and sgs, us, ss, xs, ws, ps, domains = go ts prev_proof_stmts l in\n ( sg :: sgs\n , u :: us\n , s :: ss\n , x :: xs\n , w :: ws\n , p :: ps\n , domain :: domains )\n | _, _ :: _, _ ->\n .\n | _, [], _ ->\n .\n in\n go branch_data.rule.prevs prev_proof_requests prev_vars_length\n in\n challenge_polynomial_commitments := Some challenge_polynomial_commitments' ;\n unfinalized_proofs := Some unfinalized_proofs' ;\n statements_with_hashes := Some statements_with_hashes' ;\n x_hats := Some x_hats' ;\n witnesses := Some witnesses' ;\n prev_proofs := Some prev_proofs' ;\n actual_wrap_domains := Some actual_wrap_domains'\n in\n let unfinalized_proofs = lazy (Option.value_exn !unfinalized_proofs) in\n let unfinalized_proofs_extended =\n lazy\n (Vector.extend_front\n (Lazy.force unfinalized_proofs)\n lte Max_proofs_verified.n\n (Lazy.force Unfinalized.Constant.dummy) )\n in\n let module Extract = struct\n module type S = sig\n type res\n\n val f : _ Proof.t -> res\n end\n end in\n let extract_from_proofs (type res)\n (module Extract : Extract.S with type res = res) =\n let rec go :\n type vars values ns ms len.\n (ns, ns) H2.T(Proof).t\n -> (values, vars, ns, ms) H4.T(Tag).t\n -> (vars, len) Length.t\n -> (res, len) Vector.t =\n fun prevs tags len ->\n match (prevs, tags, len) with\n | [], [], Z ->\n []\n | t :: prevs, _ :: tags, S len ->\n Extract.f t :: go prevs tags len\n in\n go\n (Option.value_exn !prev_proofs)\n branch_data.rule.prevs prev_values_length\n in\n let messages_for_next_step_proof :\n _ Reduced_messages_for_next_proof_over_same_field.Step.t Lazy.t =\n lazy\n (let old_bulletproof_challenges =\n extract_from_proofs\n ( module struct\n type res =\n Challenge.Constant.t Scalar_challenge.t Bulletproof_challenge.t\n Step_bp_vec.t\n\n let f (T t : _ Proof.t) =\n t.statement.proof_state.deferred_values.bulletproof_challenges\n end )\n in\n let (return_value : ret_value) = Option.value_exn !return_value in\n let (app_state : value) =\n match public_input with\n | Input _ ->\n next_state\n | Output _ ->\n return_value\n | Input_and_output _ ->\n (next_state, return_value)\n in\n (* Have the sg be available in the opening proof and verify it. *)\n { app_state\n ; challenge_polynomial_commitments =\n Option.value_exn !challenge_polynomial_commitments\n ; old_bulletproof_challenges\n } )\n in\n let messages_for_next_step_proof_prepared =\n lazy\n (Reduced_messages_for_next_proof_over_same_field.Step.prepare\n ~dlog_plonk_index:self_dlog_plonk_index\n (Lazy.force messages_for_next_step_proof) )\n in\n let messages_for_next_wrap_proof_padded =\n let rec pad :\n type n k maxes.\n (Digest.Constant.t, k) Vector.t\n -> maxes H1.T(Nat).t\n -> (maxes, n) Hlist.Length.t\n -> (Digest.Constant.t, n) Vector.t =\n fun xs maxes l ->\n match (xs, maxes, l) with\n | [], [], Z ->\n []\n | _x :: _xs, [], Z ->\n assert false\n | x :: xs, _ :: ms, S n ->\n x :: pad xs ms n\n | [], _m :: ms, S n ->\n let t : _ Types.Wrap.Proof_state.Messages_for_next_wrap_proof.t =\n { challenge_polynomial_commitment = Lazy.force Dummy.Ipa.Step.sg\n ; old_bulletproof_challenges =\n Vector.init Max_proofs_verified.n ~f:(fun _ ->\n Dummy.Ipa.Wrap.challenges_computed )\n }\n in\n Wrap_hack.hash_messages_for_next_wrap_proof Max_proofs_verified.n t\n :: pad [] ms n\n in\n lazy\n (Vector.rev\n (pad\n (Vector.map\n (Vector.rev (Option.value_exn !statements_with_hashes))\n ~f:(fun s -> s.proof_state.messages_for_next_wrap_proof) )\n Maxes.maxes Maxes.length ) )\n in\n let handler (Snarky_backendless.Request.With { request; respond } as r) =\n let k x = respond (Provide x) in\n match request with\n | Req.Compute_prev_proof_parts prev_proof_requests ->\n [%log internal] \"Step_compute_prev_proof_parts\" ;\n compute_prev_proof_parts prev_proof_requests ;\n [%log internal] \"Step_compute_prev_proof_parts_done\" ;\n k ()\n | Req.Proof_with_datas ->\n k (Option.value_exn !witnesses)\n | Req.Wrap_index ->\n k self_dlog_plonk_index\n | Req.App_state ->\n k next_state\n | Req.Return_value res ->\n return_value := Some res ;\n k ()\n | Req.Auxiliary_value res ->\n auxiliary_value := Some res ;\n k ()\n | Req.Unfinalized_proofs ->\n k (Lazy.force unfinalized_proofs)\n | Req.Messages_for_next_wrap_proof ->\n k (Lazy.force messages_for_next_wrap_proof_padded)\n | Req.Wrap_domain_indices ->\n let all_possible_domains = Wrap_verifier.all_possible_domains () in\n let wrap_domain_indices =\n Vector.map (Option.value_exn !actual_wrap_domains)\n ~f:(fun domain_size ->\n let domain_index =\n Vector.foldi ~init:0 all_possible_domains\n ~f:(fun j acc (Pow_2_roots_of_unity domain) ->\n if Int.equal domain domain_size then j else acc )\n in\n Pickles_base.Proofs_verified.of_int domain_index )\n in\n k wrap_domain_indices\n | _ -> (\n match handler with\n | Some f ->\n f r\n | None ->\n Snarky_backendless.Request.unhandled )\n in\n let prev_challenge_polynomial_commitments =\n lazy\n (let to_fold_in =\n extract_from_proofs\n ( module struct\n type res = Tick.Curve.Affine.t\n\n let f (T t : _ Proof.t) =\n t.statement.proof_state.messages_for_next_wrap_proof\n .challenge_polynomial_commitment\n end )\n in\n (* emphatically NOT padded with dummies *)\n Vector.(\n map2 to_fold_in\n (Lazy.force messages_for_next_step_proof_prepared)\n .old_bulletproof_challenges ~f:(fun commitment chals ->\n { Tick.Proof.Challenge_polynomial.commitment\n ; challenges = Vector.to_array chals\n } )\n |> to_list) )\n in\n let%map.Promise (next_proof : Tick.Proof.t), _next_statement_hashed =\n let (T (input, _conv, conv_inv)) =\n Impls.Step.input ~proofs_verified:Max_proofs_verified.n\n ~wrap_rounds:Tock.Rounds.n ~feature_flags\n in\n let { Domains.h } = Vector.nth_exn step_domains branch_data.index in\n ksprintf Common.time \"step-prover %d (%d)\" branch_data.index\n (Domain.size h)\n (fun () ->\n let promise_or_error =\n (* Use a try_with to give an informative backtrace.\n If we don't do this, the backtrace will be obfuscated by the\n Promise, and it's significantly harder to track down errors.\n This only applies to errors in the 'witness generation' stage;\n proving errors are emitted inside the promise, and are therefore\n unaffected.\n *)\n Or_error.try_with ~backtrace:true (fun () ->\n [%log internal] \"Step_generate_witness_conv\" ;\n Impls.Step.generate_witness_conv\n ~f:(fun { Impls.Step.Proof_inputs.auxiliary_inputs\n ; public_inputs\n } next_statement_hashed ->\n [%log internal] \"Backend_tick_proof_create_async\" ;\n let%map.Promise proof =\n Backend.Tick.Proof.create_async ~primary:public_inputs\n ~auxiliary:auxiliary_inputs\n ~message:\n (Lazy.force prev_challenge_polynomial_commitments)\n pk\n in\n [%log internal] \"Backend_tick_proof_create_async_done\" ;\n (proof, next_statement_hashed) )\n ~input_typ:Impls.Step.Typ.unit ~return_typ:input\n (fun () () ->\n Impls.Step.handle\n (fun () -> conv_inv (branch_data.main ~step_domains ()))\n handler ) )\n in\n (* Re-raise any captured errors, complete with their backtrace. *)\n Or_error.ok_exn promise_or_error )\n ()\n in\n let prev_evals =\n extract_from_proofs\n ( module struct\n type res = E.t\n\n let f (T t : _ Proof.t) =\n let proof = Wrap_wire_proof.to_kimchi_proof t.proof in\n (proof.openings.evals, proof.openings.ft_eval1)\n end )\n in\n let messages_for_next_wrap_proof =\n let rec go :\n type a.\n (a, a) H2.T(Proof).t\n -> a H1.T(Proof.Base.Messages_for_next_proof_over_same_field.Wrap).t =\n function\n | [] ->\n []\n | T t :: tl ->\n t.statement.proof_state.messages_for_next_wrap_proof :: go tl\n in\n go (Option.value_exn !prev_proofs)\n in\n let next_statement : _ Types.Step.Statement.t =\n { proof_state =\n { unfinalized_proofs = Lazy.force unfinalized_proofs_extended\n ; messages_for_next_step_proof =\n Lazy.force messages_for_next_step_proof\n }\n ; messages_for_next_wrap_proof\n }\n in\n [%log internal] \"Pickles_step_proof_done\" ;\n ( { Proof.Base.Step.proof = next_proof\n ; statement = next_statement\n ; index = branch_data.index\n ; prev_evals =\n Vector.extend_front\n (Vector.map2 prev_evals (Option.value_exn !x_hats)\n ~f:(fun (es, ft_eval1) x_hat ->\n Plonk_types.All_evals.\n { ft_eval1\n ; evals =\n { With_public_input.evals = es; public_input = x_hat }\n } ) )\n lte Max_proofs_verified.n Dummy.evals\n }\n , Option.value_exn !return_value\n , Option.value_exn !auxiliary_value\n , Option.value_exn !actual_wrap_domains )\nend\n","type t = [ `Cache_hit | `Generated_something | `Locally_generated ]\n\nlet ( + ) x y =\n match (x, y) with\n | `Generated_something, _ | _, `Generated_something ->\n `Generated_something\n | `Locally_generated, _ | _, `Locally_generated ->\n `Locally_generated\n | `Cache_hit, `Cache_hit ->\n `Cache_hit\n","type t = Dirty.t Lazy.t\n\nlet generate_or_load (t : t) = Lazy.force t\n\nlet ( + ) (t1 : t) (t2 : t) : t = lazy Dirty.(Lazy.force t1 + Lazy.force t2)\n","\nlet params =\n lazy\n (let module T =\n struct\n type t =\n Pickles.Backend.Tick.Field.Stable.Latest.t Group_map.Params.t\n [@@deriving bin_io_unversioned]\n end in\n Core_kernel.Binable.of_string (module T)\n \"\\002\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000i\\2196c[?\\152\\181p\\196\\252\\251\\244\\181\\140\\151w\\n\\154\\140\\220>\\209\\197|\\215\\162<\\2361\\247\\026\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\003\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\005\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\");;\n","let () = Pickles.Backend.Tock.Keypair.set_urs_info Cache_dir.cache\n\nlet () = Pickles.Backend.Tick.Keypair.set_urs_info Cache_dir.cache\n\nmodule Tock = struct\n module Full = Pickles.Impls.Wrap\n module Run = Pickles.Impls.Wrap\n\n let group_map_params () = Lazy.force Group_map_params.params\n\n include Full.Internal_Basic\n module Number = Snarky_backendless.Number.Make (Full.Internal_Basic)\n module Enumerable = Snarky_backendless.Enumerable.Make (Full.Internal_Basic)\n module Inner_curve = Pickles.Backend.Tock.Inner_curve\nend\n\nmodule Tick = struct\n module Full = Pickles.Impls.Step\n module Run = Pickles.Impls.Step\n\n let group_map_params =\n Group_map.Params.create\n (module Pickles.Backend.Tock.Field)\n Pickles.Backend.Tock.Inner_curve.Params.{ a; b }\n\n include Full.Internal_Basic\n module Number = Snarky_backendless.Number.Make (Full.Internal_Basic)\n module Enumerable = Snarky_backendless.Enumerable.Make (Full.Internal_Basic)\n module Inner_curve = Pickles.Backend.Tick.Inner_curve\nend\n","open Core_kernel\ninclude Bigint\n\nlet of_bool (b : bool) : t = if b then one else zero\n\nlet of_bit_fold_lsb ({ fold } : bool Fold_lib.Fold.t) : t =\n fold ~init:(0, zero) ~f:(fun (i, acc) b ->\n (Int.(i + 1), bit_or (shift_left (of_bool b) i) acc) )\n |> snd\n\nlet of_bits_lsb : bool list -> t =\n List.foldi ~init:zero ~f:(fun i acc b ->\n bit_or (shift_left (of_bool b) i) acc )\n","open Core_kernel\n\nmodule Make_test (F : Intf.Basic) = struct\n let test arg_typ gen_arg sexp_of_arg label unchecked checked =\n let open F.Impl in\n let converted x =\n let r =\n run_and_check\n (let open Checked.Let_syntax in\n let%bind x = exists arg_typ ~compute:(As_prover.return x) in\n checked x >>| As_prover.read F.typ)\n |> Or_error.ok_exn\n in\n r\n in\n let open Quickcheck in\n test ~trials:50 gen_arg ~f:(fun x ->\n let r1 = unchecked x in\n let r2 = converted x in\n if not (F.Unchecked.equal r1 r2) then\n failwithf\n !\"%s test failure: %{sexp:arg} -> %{sexp:F.Unchecked.t} vs \\\n %{sexp:F.Unchecked.t}\"\n label x r1 r2 ()\n else () )\n\n let test1 l f g = test F.typ F.Unchecked.gen F.Unchecked.sexp_of_t l f g\n\n let test2 l f g =\n let open F in\n test (Impl.Typ.( * ) typ typ)\n (Quickcheck.Generator.tuple2 Unchecked.gen Unchecked.gen)\n [%sexp_of: Unchecked.t * Unchecked.t] l (Tuple2.uncurry f)\n (Tuple2.uncurry g)\nend\n\nmodule Make (F : Intf.Basic) = struct\n open F.Impl\n open Let_syntax\n open F\n\n let typ = F.typ\n\n let constant = F.constant\n\n let scale = F.scale\n\n let assert_r1cs = F.assert_r1cs\n\n let equal x y =\n Checked.all\n (List.map2_exn (F.to_list x) (F.to_list y) ~f:Field.Checked.equal)\n >>= Boolean.all\n\n let assert_equal x y =\n assert_all\n (List.map2_exn\n ~f:(fun x y -> Constraint.equal x y)\n (F.to_list x) (F.to_list y) )\n\n let ( + ) = F.( + )\n\n let%test_unit \"add\" =\n let module M = Make_test (F) in\n M.test2 \"add\" Unchecked.( + ) (fun x y -> return (x + y))\n\n let ( - ) = F.( - )\n\n let negate = F.negate\n\n let zero = constant Unchecked.zero\n\n let one = constant Unchecked.one\n\n let div_unsafe x y =\n match (to_constant x, to_constant y) with\n | Some x, Some y ->\n return (constant Unchecked.(x / y))\n | _, _ ->\n let%bind x_over_y =\n exists typ\n ~compute:\n As_prover.(map2 (read typ x) (read typ y) ~f:Unchecked.( / ))\n in\n let%map () = assert_r1cs y x_over_y x in\n x_over_y\n\n let assert_square =\n match assert_square with\n | `Custom f ->\n f\n | `Define ->\n fun a a2 -> assert_r1cs a a a2\n\n let ( * ) =\n match ( * ) with\n | `Custom f ->\n f\n | `Define -> (\n fun x y ->\n match (to_constant x, to_constant y) with\n | Some x, Some y ->\n return (constant Unchecked.(x * y))\n | _, _ ->\n let%bind res =\n exists typ\n ~compute:\n As_prover.(\n map2 (read typ x) (read typ y) ~f:Unchecked.( * ))\n in\n let%map () = assert_r1cs x y res in\n res )\n\n let%test_unit \"mul\" =\n let module M = Make_test (F) in\n M.test2 \"mul\" Unchecked.( * ) ( * )\n\n let square =\n match square with\n | `Custom f ->\n f\n | `Define -> (\n fun x ->\n match to_constant x with\n | Some x ->\n return (constant (Unchecked.square x))\n | None ->\n let%bind res =\n exists typ\n ~compute:As_prover.(map (read typ x) ~f:Unchecked.square)\n in\n let%map () = assert_square x res in\n res )\n\n let%test_unit \"square\" =\n let module M = Make_test (F) in\n M.test1 \"square\" Unchecked.square square\n\n let inv_exn =\n match inv_exn with\n | `Custom f ->\n f\n | `Define -> (\n fun t ->\n match to_constant t with\n | Some x ->\n return (constant (Unchecked.inv x))\n | None ->\n let%bind res =\n exists typ\n ~compute:As_prover.(map (read typ t) ~f:Unchecked.inv)\n in\n let%map () = assert_r1cs t res one in\n res )\nend\n\nmodule Make_applicative\n (F : Intf.S)\n (A : Intf.Traversable_applicative with module Impl := F.Impl) =\nstruct\n type t = F.t A.t\n\n type 'a t_ = 'a F.t_ A.t\n\n let constant = A.map ~f:F.constant\n\n let to_constant =\n let exception None_exn in\n fun t ->\n try\n Some\n (A.map t ~f:(fun x ->\n match F.to_constant x with Some x -> x | None -> raise None_exn )\n )\n with None_exn -> None\n\n let if_ b ~then_ ~else_ =\n A.sequence (A.map2 then_ else_ ~f:(fun t e -> F.if_ b ~then_:t ~else_:e))\n\n let scale t x = A.map t ~f:(fun a -> F.scale a x)\n\n let scale' t x = A.map t ~f:(fun a -> F.scale x a)\n\n let negate t = A.map t ~f:F.negate\n\n let ( + ) = A.map2 ~f:F.( + )\n\n let ( - ) = A.map2 ~f:F.( - )\n\n let map_ t ~f = A.map t ~f:(F.map_ ~f)\n\n let map2_ t1 t2 ~f = A.map2 t1 t2 ~f:(fun x1 x2 -> F.map2_ x1 x2 ~f)\nend\n\nmodule F (Impl : Snarky_backendless.Snark_intf.S) :\n Intf.S with type 'a Base.t_ = 'a and type 'a A.t = 'a and module Impl = Impl =\nstruct\n module T = struct\n module Unchecked = struct\n include Impl.Field\n module Nat = Snarkette.Nat\n\n let order = Snarkette.Nat.of_string (Bigint.to_string Impl.Field.size)\n\n let to_yojson x = `String (to_string x)\n\n let of_yojson = function\n | `String s ->\n Ok (of_string s)\n | _ ->\n Error \"Field.of_yojson: expected string\"\n end\n\n module Impl = Impl\n open Impl\n\n let map_ t ~f = f t\n\n let map2_ t1 t2 ~f = f t1 t2\n\n module Base = struct\n type 'a t_ = 'a\n\n module Unchecked = struct\n type t = Field.t t_\n\n let to_yojson x = `String (Field.to_string x)\n\n let of_yojson = function\n | `String s ->\n Ok (Field.of_string s)\n | _ ->\n Error \"Field.of_yojson: expected string\"\n end\n\n type t = Field.Var.t t_\n\n let map_ = map_\n end\n\n module A = struct\n type 'a t = 'a\n\n let map = map_\n\n let map2 = map2_\n\n let sequence = Fn.id\n end\n\n type 'a t_ = 'a\n\n let to_list x = [ x ]\n\n type t = Field.Var.t\n\n let if_ = Field.Checked.if_\n\n let typ = Field.typ\n\n let constant = Field.Var.constant\n\n let to_constant = Field.Var.to_constant\n\n let scale = Field.Var.scale\n\n let mul_field = Field.Checked.mul\n\n let assert_r1cs a b c = assert_r1cs a b c\n\n let ( + ) = Field.Checked.( + )\n\n let ( - ) = Field.Checked.( - )\n\n let negate t = Field.Var.scale t Unchecked.(negate one)\n\n let assert_square = `Custom (fun a c -> assert_square a c)\n\n let ( * ) = `Custom Field.Checked.mul\n\n let square = `Custom Field.Checked.square\n\n let inv_exn = `Custom Field.Checked.inv\n\n let real_part = Fn.id\n end\n\n include T\n include Make (T)\nend\n\n(* Given a field F and s : F (called [non_residue] below)\n such that x^2 - s does not have a root in F, construct\n the field F(sqrt(s)) = F[x] / (x^2 - s) *)\nmodule E2\n (F : Intf.S) (Params : sig\n val non_residue : F.Unchecked.t\n\n val mul_by_non_residue : F.t -> F.t\n end) : sig\n include\n Intf.S_with_primitive_element\n with module Impl = F.Impl\n and module Base = F\n and type 'a A.t = 'a * 'a\n\n val unitary_inverse : t -> t\nend = struct\n open Params\n\n module T = struct\n module Base = F\n module Impl = F.Impl\n open Impl\n module Unchecked = Snarkette.Fields.Make_fp2 (F.Unchecked) (Params)\n\n module A = struct\n type 'a t = 'a * 'a\n\n let map (x, y) ~f = (f x, f y)\n\n let map2 (x1, y1) (x2, y2) ~f = (f x1 x2, f y1 y2)\n\n let sequence (x, y) =\n let%map x = x and y = y in\n (x, y)\n end\n\n let to_list (x, y) = F.to_list x @ F.to_list y\n\n (* A value [(a, b) : t] should be thought of as the field element\n a + b sqrt(s). Then all operations are just what follow algebraically. *)\n\n include Make_applicative (Base) (A)\n\n let mul_field (a, b) x =\n let%map a = Base.mul_field a x and b = Base.mul_field b x in\n (a, b)\n\n let typ = Typ.tuple2 F.typ F.typ\n\n (*\n (a + b sqrt(s))^2\n = a^2 + b^2 s + 2 a b sqrt(s)\n\n So it is clear that the second coordinate of the below definition is correct. Let's\n examine the first coordinate.\n\n t - ab - ab sqrt(s)\n = (a + b) (a + s b) - ab - s a b\n = a^2 + a b + s a b + s b^2 - a b - s a b\n = a^2 + s b^2\n\n so this is correct as well.\n *)\n let square (a, b) =\n let open F in\n let%map ab = a * b and t = (a + b) * (a + mul_by_non_residue b) in\n (t - ab - mul_by_non_residue ab, ab + ab)\n\n let assert_square (a, b) (a2, b2) =\n let open F in\n let ab = scale b2 Field.(one / of_int 2) in\n let%map () = assert_r1cs a b ab\n and () =\n assert_r1cs (a + b)\n (a + mul_by_non_residue b)\n (a2 + ab + mul_by_non_residue ab)\n in\n ()\n\n (*\n (a1 + b1 sqrt(s)) (a2 + b2 sqrt(s))\n = (a1 a2 + b1 b2 s) + (a2 b1 + a1 b2) sqrt(s)\n\n So it is clear that the first coordinate is correct. Let's examine the second\n coordinate.\n\n t - a1 a2 - b1 b2\n = (a1 + b1) (a2 + b2) - a1 a2 - b1 b2\n = a1 a2 + b2 b2 + a1 b2 + a2 b1 - a1 a2 - b1 b2\n = a1 b2 + a2 b1\n\n So this is correct as well.\n *)\n let ( * ) (a1, b1) (a2, b2) =\n let open F in\n let%map a = a1 * a2 and b = b1 * b2 and t = (a1 + b1) * (a2 + b2) in\n (a + mul_by_non_residue b, t - a - b)\n\n let mul_by_primitive_element (a, b) = (mul_by_non_residue b, a)\n\n let assert_r1cs (a1, b1) (a2, b2) (a3, b3) =\n let open F in\n let%bind b = b1 * b2 in\n let a = a3 - mul_by_non_residue b in\n let%map () = assert_r1cs a1 a2 a\n and () = assert_r1cs (a1 + b1) (a2 + b2) (b3 + a + b) in\n ()\n\n let square = `Custom square\n\n let ( * ) = `Custom ( * )\n\n let inv_exn = `Define\n\n let assert_square = `Custom assert_square\n\n let real_part (x, _) = Base.real_part x\n end\n\n include T\n include Make (T)\n\n let unitary_inverse (a, b) = (a, Base.negate b)\nend\n\n(* Given a prime order field F and s : F (called [non_residue] below)\n such that x^3 - s is irreducible, construct\n the field F(cube_root(s)) = F[x] / (x^3 - s).\n\n Let S = cube_root(s) in the following.\n*)\n\nmodule T3 = struct\n type 'a t = 'a * 'a * 'a\n\n let map (x, y, z) ~f = (f x, f y, f z)\n\n let map2 (x1, y1, z1) (x2, y2, z2) ~f = (f x1 x2, f y1 y2, f z1 z2)\nend\n\nmodule E3\n (F : Intf.S) (Params : sig\n val non_residue : F.Unchecked.t\n\n val frobenius_coeffs_c1 : F.Unchecked.t array\n\n val frobenius_coeffs_c2 : F.Unchecked.t array\n\n val mul_by_non_residue : F.t -> F.t\n end) :\n Intf.S_with_primitive_element\n with module Impl = F.Impl\n and module Base = F\n and type 'a A.t = 'a * 'a * 'a = struct\n module T = struct\n module Base = F\n module Unchecked = Snarkette.Fields.Make_fp3 (F.Unchecked) (Params)\n module Impl = F.Impl\n open Impl\n\n module A = struct\n include T3\n\n let sequence (x, y, z) =\n let%map x = x and y = y and z = z in\n (x, y, z)\n end\n\n let to_list (x, y, z) = F.to_list x @ F.to_list y @ F.to_list z\n\n include Make_applicative (Base) (A)\n\n let typ = Typ.tuple3 F.typ F.typ F.typ\n\n let mul_field (a, b, c) x =\n let%map a = Base.mul_field a x\n and b = Base.mul_field b x\n and c = Base.mul_field c x in\n (a, b, c)\n\n (*\n (a1 + S b1 + S^2 c1) (a2 + S b2 + S^2 c2)\n = a1 a2 + S a1 b2 + S^2 a1 c2\n + S b1 a2 + S^2 b1 b2 + S^3 b1 c2\n + S^2 c1 a2 + S^3 c1 b2 + S^4 c1 c2\n = a1 a2 + S a1 b2 + S^2 a1 c2\n + S b1 a2 + S^2 b1 b2 + s b1 c2\n + S^2 c1 a2 + s c1 b2 + s S c1 c2\n = (a1 a2 + s b1 c2 + s c1 b2)\n + S (a1 b2 + b1 a2 + s c1 c2)\n + S^2 (a1 c2 + c1 a2 + b1 b2)\n\n Let us examine the three coordinates in turn.\n\n First coordinate:\n a + s (t1 - b - c)\n = a1 a2 + s ( (b1 + c1) (b2 + c2) - b - c)\n = a1 a2 + s (b1 c2 + b2 c1)\n which is evidently correct.\n\n Second coordinate:\n t2 - a - b + s c\n (a1 + b1) (a2 + b2) - a - b + s c\n a1 b2 + b1 a2 + s c\n which is evidently correct.\n\n Third coordinate:\n t3 - a + b - c\n = (a1 + c1) (a2 + c2) - a + b - c\n = a1 c2 + c1 a2 + b\n which is evidently correct.\n *)\n let ( * ) (a1, b1, c1) (a2, b2, c2) =\n with_label __LOC__ (fun () ->\n let open F in\n let%map a = a1 * a2\n and b = b1 * b2\n and c = c1 * c2\n and t1 = (b1 + c1) * (b2 + c2)\n and t2 = (a1 + b1) * (a2 + b2)\n and t3 = (a1 + c1) * (a2 + c2) in\n ( a + Params.mul_by_non_residue (t1 - b - c)\n , t2 - a - b + Params.mul_by_non_residue c\n , t3 - a + b - c ) )\n\n (*\n (a + S b + S^2 c)^2\n = a^2 + S a b + S^2 a c\n + S a b + S^2 b^2 + S^3 b c\n + S^2 a c + S^3 b c + S^4 c^2\n = a^2 + S a b + S^2 a c\n + S a b + S^2 b^2 + s b c\n + S^2 a c + s b c + S s c^2\n = (a^2 + 2 s b c)\n + S (2 a b + s c^2)\n + S^2 (b^2 + 2 a c)\n\n Let us examine the three coordinates in turn.\n\n First coordinate:\n s0 + s s3\n = a^2 + 2 s b c\n which is evidently correct.\n\n Second coordinate:\n s1 + s s4\n = 2 a b + s c^2\n which is evidently correct.\n\n Third coordinate:\n s1 + s2 + s3 - s0 - s4\n = 2 a b + (a - b + c)^2 + 2 b c - a^2 - c^2\n = 2 a b + a^2 - 2 a b + 2 a c - 2 b c + b^2 + c^2 + 2 b c - a^2 - c^2\n = 2 a c + b^2\n which is evidently correct.\n *)\n let square (a, b, c) =\n let open F in\n let%map s0 = square a\n and ab = a * b\n and bc = b * c\n and s2 = square (a - b + c)\n and s4 = square c in\n let s1 = ab + ab in\n let s3 = bc + bc in\n ( s0 + Params.mul_by_non_residue s3\n , s1 + Params.mul_by_non_residue s4\n , s1 + s2 + s3 - s0 - s4 )\n\n let mul_by_primitive_element (a, b, c) = (Params.mul_by_non_residue c, a, b)\n\n let assert_r1cs (a1, b1, c1) (a2, b2, c2) (a3, b3, c3) =\n with_label __LOC__ (fun () ->\n let open F in\n let%bind b = b1 * b2 and c = c1 * c2 and t1 = (b1 + c1) * (b2 + c2) in\n let a = a3 - Params.mul_by_non_residue (t1 - b - c) in\n let%map () = assert_r1cs a1 a2 a\n and () =\n assert_r1cs (a1 + b1) (a2 + b2)\n (b3 + a + b - Params.mul_by_non_residue c)\n and () = assert_r1cs (a1 + c1) (a2 + c2) (c3 + a - b + c) in\n () )\n\n let square = `Custom square\n\n let ( * ) = `Custom ( * )\n\n let inv_exn = `Define\n\n let assert_square = `Define\n\n let real_part (a, _, _) = F.real_part a\n end\n\n include T\n include Make (T)\nend\n\nmodule F3\n (F : Intf.S with type 'a A.t = 'a and type 'a Base.t_ = 'a) (Params : sig\n val non_residue : F.Unchecked.t\n\n val frobenius_coeffs_c1 : F.Unchecked.t array\n\n val frobenius_coeffs_c2 : F.Unchecked.t array\n end) :\n Intf.S_with_primitive_element\n with module Impl = F.Impl\n and module Base = F\n and type 'a A.t = 'a * 'a * 'a = struct\n module T = struct\n module Base = F\n module Unchecked = Snarkette.Fields.Make_fp3 (F.Unchecked) (Params)\n module Impl = F.Impl\n open Impl\n\n let mul_by_primitive_element (a, b, c) = (F.scale c Params.non_residue, a, b)\n\n module A = struct\n include T3\n\n let sequence (x, y, z) =\n let%map x = x and y = y and z = z in\n (x, y, z)\n end\n\n let to_list (x, y, z) = [ x; y; z ]\n\n include Make_applicative (Base) (A)\n\n let typ = Typ.tuple3 F.typ F.typ F.typ\n\n let mul_field (a, b, c) x =\n let%map a = Base.mul_field a x\n and b = Base.mul_field b x\n and c = Base.mul_field c x in\n (a, b, c)\n\n let assert_r1cs (a0, a1, a2) (b0, b1, b2) (c0, c1, c2) =\n let open F in\n let%bind v0 = a0 * b0 and v4 = a2 * b2 in\n let beta = Params.non_residue in\n let beta_inv = F.Unchecked.inv beta in\n let%map () =\n assert_r1cs\n (a0 + a1 + a2)\n (b0 + b1 + b2)\n ( c1 + c2 + F.scale c0 beta_inv\n + F.(scale v0 Unchecked.(one - beta_inv))\n + F.(scale v4 Unchecked.(one - beta)) )\n and () =\n assert_r1cs\n (a0 - a1 + a2)\n (b0 - b1 + b2)\n ( c2 - c1\n + F.(scale v0 Unchecked.(one + beta_inv))\n - F.scale c0 beta_inv\n + F.(scale v4 Unchecked.(one + beta)) )\n and () =\n let two = Impl.Field.of_int 2 in\n let four = Impl.Field.of_int 4 in\n let sixteen = Impl.Field.of_int 16 in\n let eight_beta_inv = Impl.Field.(mul (of_int 8) beta_inv) in\n assert_r1cs\n (a0 + F.scale a1 two + F.scale a2 four)\n (b0 + F.scale b1 two + F.scale b2 four)\n ( F.scale c1 two + F.scale c2 four + F.scale c0 eight_beta_inv\n + F.(scale v0 Unchecked.(one - eight_beta_inv))\n + F.(scale v4 Unchecked.(sixteen - (beta + beta))) )\n in\n ()\n\n let ( * ) = `Define\n\n let inv_exn = `Define\n\n let square = `Define\n\n let assert_square = `Define\n\n let real_part (a, _, _) = F.real_part a\n end\n\n include T\n include Make (T)\nend\n\nmodule Cyclotomic_square = struct\n module Make_F4 (F2 : Intf.S_with_primitive_element) = struct\n let cyclotomic_square (c0, c1) =\n let open F2 in\n let open Impl in\n let%map b_squared = square (c0 + c1) and a = square c1 in\n let c = b_squared - a in\n let d = mul_by_primitive_element a in\n let e = c - d in\n let f = scale d (Field.of_int 2) + one in\n let g = e - one in\n (f, g)\n end\n\n module Make_F6\n (F2 : Intf.S_with_primitive_element\n with type 'a A.t = 'a * 'a\n and type 'a Base.t_ = 'a)\n (Params : sig\n val cubic_non_residue : F2.Impl.Field.t\n end) =\n struct\n let cyclotomic_square ((x00, x01, x02), (x10, x11, x12)) =\n let open F2.Impl in\n let ((a0, a1) as a) = (x00, x11) in\n let ((b0, b1) as b) = (x10, x02) in\n let ((c0, c1) as c) = (x01, x12) in\n let%map asq0, asq1 = F2.square a\n and bsq0, bsq1 = F2.square b\n and csq0, csq1 = F2.square c in\n let fpos x y =\n Field.(Var.(add (scale x (of_int 3)) (scale y (of_int 2))))\n in\n let fneg x y =\n Field.(Var.(sub (scale x (of_int 3)) (scale y (of_int 2))))\n in\n ( (fneg asq0 a0, fneg bsq0 c0, fneg csq0 b1)\n , ( fpos (Field.Var.scale csq1 Params.cubic_non_residue) b0\n , fpos asq1 a1\n , fpos bsq1 c1 ) )\n end\nend\n\nmodule F6\n (Fq : Intf.S with type 'a A.t = 'a and type 'a Base.t_ = 'a)\n (Fq2 : Intf.S_with_primitive_element\n with module Impl = Fq.Impl\n and type 'a A.t = 'a * 'a\n and type 'a Base.t_ = 'a Fq.t_)\n (Fq3 : sig\n include\n Intf.S_with_primitive_element\n with module Impl = Fq.Impl\n and type 'a A.t = 'a * 'a * 'a\n and type 'a Base.t_ = 'a Fq.t_\n\n module Params : sig\n val non_residue : Fq.Unchecked.t\n\n val frobenius_coeffs_c1 : Fq.Unchecked.t array\n\n val frobenius_coeffs_c2 : Fq.Unchecked.t array\n end\n end) (Params : sig\n val frobenius_coeffs_c1 : Fq.Unchecked.t array\n end) =\nstruct\n include\n E2\n (Fq3)\n (struct\n let non_residue : Fq3.Unchecked.t = Fq.Unchecked.(zero, one, zero)\n\n let mul_by_non_residue = Fq3.mul_by_primitive_element\n end)\n\n let fq_mul_by_non_residue x = Fq.scale x Fq3.Params.non_residue\n\n let special_mul (a0, a1) (b0, b1) =\n let open Impl in\n let%bind v1 = Fq3.(a1 * b1) in\n let%bind v0 =\n let a00, a01, a02 = a0 in\n let _, _, b02 = b0 in\n let%map a00b02 = Fq.(a00 * b02)\n and a01b02 = Fq.(a01 * b02)\n and a02b02 = Fq.(a02 * b02) in\n (fq_mul_by_non_residue a01b02, fq_mul_by_non_residue a02b02, a00b02)\n in\n let beta_v1 = Fq3.mul_by_primitive_element v1 in\n let%map t = Fq3.((a0 + a1) * (b0 + b1)) in\n Fq3.(v0 + beta_v1, t - v0 - v1)\n\n let assert_special_mul ((((a00, a01, a02) as a0), a1) : t)\n ((((_, _, b02) as b0), b1) : t) ((c00, c01, c02), c1) =\n let open Impl in\n let%bind ((v10, v11, v12) as v1) = Fq3.(a1 * b1) in\n let%bind v0 =\n exists Fq3.typ\n ~compute:\n As_prover.(\n map2 ~f:Fq3.Unchecked.( * ) (read Fq3.typ a0) (read Fq3.typ b0))\n (* v0\n = (a00 + s a01 s^2 a02) (s^2 b02)\n = non_residue a01 b02 + non_residue s a02 b02 + s^2 a00 b02 *)\n in\n let%map () =\n let%map () =\n Fq.assert_r1cs a01\n (Fq.scale b02 Fq3.Params.non_residue)\n (Field.Var.linear_combination\n [ (Field.one, c00); (Field.negate Fq3.Params.non_residue, v12) ] )\n and () =\n Fq.assert_r1cs a02 (Fq.scale b02 Fq3.Params.non_residue) Fq.(c01 - v10)\n and () = Fq.assert_r1cs a00 b02 Fq.(c02 - v11) in\n ()\n and () = Fq3.assert_r1cs Fq3.(a0 + a1) Fq3.(b0 + b1) Fq3.(c1 + v0 + v1) in\n ()\n\n let special_div_unsafe a b =\n let open Impl in\n let%bind result =\n exists typ\n ~compute:As_prover.(map2 ~f:Unchecked.( / ) (read typ a) (read typ b))\n in\n (* result * b = a *)\n let%map () = assert_special_mul result b a in\n result\n\n (* TODO: Make sure this is ok *)\n let special_div = special_div_unsafe\n\n include\n Cyclotomic_square.Make_F6\n (Fq2)\n (struct\n let cubic_non_residue = Fq3.Params.non_residue\n end)\n\n let frobenius ((c00, c01, c02), (c10, c11, c12)) power =\n let module Field = Impl.Field in\n let p3 = power mod 3 in\n let p6 = power mod 6 in\n let ( * ) s x = Field.Var.scale x s in\n ( ( c00\n , Fq3.Params.frobenius_coeffs_c1.(p3) * c01\n , Fq3.Params.frobenius_coeffs_c2.(p3) * c02 )\n , ( Params.frobenius_coeffs_c1.(p6) * c10\n , Field.mul\n Params.frobenius_coeffs_c1.(p6)\n Fq3.Params.frobenius_coeffs_c1.(p3)\n * c11\n , Field.mul\n Params.frobenius_coeffs_c1.(p6)\n Fq3.Params.frobenius_coeffs_c2.(p3)\n * c12 ) )\nend\n\nmodule F4\n (Fq2 : Intf.S_with_primitive_element\n with type 'a A.t = 'a * 'a\n and type 'a Base.t_ = 'a)\n (Params : sig\n val frobenius_coeffs_c1 : Fq2.Impl.Field.t array\n end) =\nstruct\n include\n E2\n (Fq2)\n (struct\n let non_residue = Fq2.Impl.Field.(zero, one)\n\n let mul_by_non_residue = Fq2.mul_by_primitive_element\n end)\n\n let special_mul = ( * )\n\n (* TODO: Make sure this is ok *)\n let special_div = div_unsafe\n\n include Cyclotomic_square.Make_F4 (Fq2)\n\n let frobenius ((c00, c01), (c10, c11)) power =\n let module Field = Impl.Field in\n let p2 = Params.frobenius_coeffs_c1.(Int.( * ) (power mod 2) 2) in\n let p4 = Params.frobenius_coeffs_c1.(power mod 4) in\n let ( * ) s x = Field.Var.scale x s in\n ((c00, p2 * c01), (p4 * c10, Field.(p4 * p2) * c11))\nend\n","module Bignum_bigint = Bigint\nopen Core_kernel\n\nmodule type Params_intf = sig\n type field\n\n val a : field\n\n val b : field\nend\n\nmodule type Scalar_intf = sig\n type (_, _) typ\n\n type (_, _) checked\n\n type boolean_var\n\n type var\n\n type t [@@deriving equal, sexp]\n\n val typ : (var, t) typ\n\n val length_in_bits : int\n\n val test_bit : t -> int -> bool\n\n module Checked : sig\n val equal : var -> var -> (boolean_var, _) checked\n\n module Assert : sig\n val equal : var -> var -> (unit, _) checked\n end\n end\nend\n\nmodule type Shifted_intf = sig\n type _ checked\n\n type boolean_var\n\n type curve_var\n\n type t\n\n val zero : t\n\n val add : t -> curve_var -> t checked\n\n (* This is only safe if the result is guaranteed to not be zero. *)\n\n val unshift_nonzero : t -> curve_var checked\n\n val if_ : boolean_var -> then_:t -> else_:t -> t checked\n\n module Assert : sig\n val equal : t -> t -> unit checked\n end\nend\n\nmodule type Weierstrass_checked_intf = sig\n module Impl : Snarky_backendless.Snark_intf.S\n\n open Impl\n\n type unchecked\n\n type t\n\n val typ : (t, unchecked) Typ.t\n\n module Shifted : sig\n module type S =\n Shifted_intf\n with type 'a checked := 'a Checked.t\n and type curve_var := t\n and type boolean_var := Boolean.var\n\n type 'a m = (module S with type t = 'a)\n\n val create : unit -> (module S) Checked.t\n end\n\n val negate : t -> t\n\n val constant : unchecked -> t\n\n val add_unsafe :\n t -> t -> [ `I_thought_about_this_very_carefully of t ] Checked.t\n\n val if_ : Boolean.var -> then_:t -> else_:t -> t Checked.t\n\n val double : t -> t Checked.t\n\n val if_value : Boolean.var -> then_:unchecked -> else_:unchecked -> t\n\n val scale :\n 's Shifted.m\n -> t\n -> Boolean.var Bitstring_lib.Bitstring.Lsb_first.t\n -> init:'s\n -> 's Checked.t\n\n val scale_known :\n 's Shifted.m\n -> unchecked\n -> Boolean.var Bitstring_lib.Bitstring.Lsb_first.t\n -> init:'s\n -> 's Checked.t\n\n val sum : 's Shifted.m -> t list -> init:'s -> 's Checked.t\n\n module Assert : sig\n val on_curve : t -> unit Checked.t\n\n val equal : t -> t -> unit Checked.t\n end\nend\n\nmodule Make_weierstrass_checked\n (F : Snarky_field_extensions.Intf.S) (Scalar : sig\n type t\n\n val of_int : int -> t\n end) (Curve : sig\n type t\n\n val random : unit -> t\n\n val to_affine_exn : t -> F.Unchecked.t * F.Unchecked.t\n\n val of_affine : F.Unchecked.t * F.Unchecked.t -> t\n\n val double : t -> t\n\n val ( + ) : t -> t -> t\n\n val negate : t -> t\n\n val scale : t -> Scalar.t -> t\n end)\n (Params : Params_intf with type field := F.Unchecked.t) (Override : sig\n val add : (F.t * F.t -> F.t * F.t -> (F.t * F.t) F.Impl.Checked.t) option\n end) :\n Weierstrass_checked_intf\n with module Impl := F.Impl\n and type unchecked := Curve.t\n and type t = F.t * F.t = struct\n open F.Impl\n\n type t = F.t * F.t\n\n let assert_on_curve (x, y) =\n let open F in\n let%bind x2 = square x in\n let%bind x3 = x2 * x in\n let%bind ax = constant Params.a * x in\n assert_square y (x3 + ax + constant Params.b)\n\n let typ : (t, Curve.t) Typ.t =\n let (Typ unchecked) =\n Typ.transport\n Typ.(tuple2 F.typ F.typ)\n ~there:Curve.to_affine_exn ~back:Curve.of_affine\n in\n Typ { unchecked with check = assert_on_curve }\n\n let negate ((x, y) : t) : t = (x, F.negate y)\n\n let constant (t : Curve.t) : t =\n let x, y = Curve.to_affine_exn t in\n F.(constant x, constant y)\n\n let assert_equal (x1, y1) (x2, y2) =\n let%map () = F.assert_equal x1 x2 and () = F.assert_equal y1 y2 in\n ()\n\n module Assert = struct\n let on_curve = assert_on_curve\n\n let equal = assert_equal\n end\n\n open Let_syntax\n\n let%snarkydef_ add' ~div (ax, ay) (bx, by) =\n let open F in\n let%bind lambda = div (by - ay) (bx - ax) in\n let%bind cx =\n exists typ\n ~compute:\n (let open As_prover in\n let open Let_syntax in\n let%map ax = read typ ax\n and bx = read typ bx\n and lambda = read typ lambda in\n Unchecked.(square lambda - (ax + bx)))\n in\n let%bind () =\n (* lambda^2 = cx + ax + bx\n cx = lambda^2 - (ax + bc)\n *)\n assert_square lambda F.(cx + ax + bx)\n in\n let%bind cy =\n exists typ\n ~compute:\n (let open As_prover in\n let open Let_syntax in\n let%map ax = read typ ax\n and ay = read typ ay\n and cx = read typ cx\n and lambda = read typ lambda in\n Unchecked.((lambda * (ax - cx)) - ay))\n in\n let%map () = assert_r1cs lambda (ax - cx) (cy + ay) in\n (cx, cy)\n\n let add' ~div p1 p2 =\n match Override.add with Some add -> add p1 p2 | None -> add' ~div p1 p2\n\n (* This function MUST NOT be called UNLESS you are certain the two points\n on which it is called are not equal. If it is called on equal points,\n the prover can return almost any curve point they want to from this function. *)\n let add_unsafe p q =\n let%map r = add' ~div:F.div_unsafe p q in\n `I_thought_about_this_very_carefully r\n\n let add_exn p q = add' ~div:(fun x y -> F.inv_exn y >>= F.(( * ) x)) p q\n\n (* TODO-someday: Make it so this doesn't have to compute both branches *)\n let if_ b ~then_:(tx, ty) ~else_:(ex, ey) =\n let%map x = F.if_ b ~then_:tx ~else_:ex\n and y = F.if_ b ~then_:ty ~else_:ey in\n (x, y)\n\n module Shifted = struct\n module type S =\n Shifted_intf\n with type 'a checked := 'a Checked.t\n and type curve_var := t\n and type boolean_var := Boolean.var\n\n type 'a m = (module S with type t = 'a)\n\n module Make (M : sig\n val shift : t\n end) : S = struct\n open M\n\n type nonrec t = t\n\n let zero = shift\n\n let if_ = if_\n\n let unshift_nonzero shifted = add_exn (negate shift) shifted\n\n let add shifted x = add_exn shifted x\n\n module Assert = struct\n let equal = assert_equal\n end\n end\n\n let create () : (module S) Checked.t =\n let%map shift =\n exists typ ~compute:As_prover.(map (return ()) ~f:Curve.random)\n in\n let module M = Make (struct\n let shift = shift\n end) in\n (module M : S)\n end\n\n let%snarkydef_ double (ax, ay) =\n let open F in\n let%bind x_squared = square ax in\n let%bind lambda =\n exists typ\n ~compute:\n As_prover.(\n map2 (read typ x_squared) (read typ ay) ~f:(fun x_squared ay ->\n let open F.Unchecked in\n (x_squared + x_squared + x_squared + Params.a) * inv (ay + ay) ))\n in\n let%bind bx =\n exists typ\n ~compute:\n As_prover.(\n map2 (read typ lambda) (read typ ax) ~f:(fun lambda ax ->\n let open F.Unchecked in\n square lambda - (ax + ax) ))\n in\n let%bind by =\n exists typ\n ~compute:\n (let open As_prover in\n let open Let_syntax in\n let%map lambda = read typ lambda\n and ax = read typ ax\n and ay = read typ ay\n and bx = read typ bx in\n F.Unchecked.((lambda * (ax - bx)) - ay))\n in\n let two = Field.of_int 2 in\n let%map () =\n assert_r1cs (F.scale lambda two) ay\n (F.scale x_squared (Field.of_int 3) + F.constant Params.a)\n and () = assert_square lambda (bx + F.scale ax two)\n and () = assert_r1cs lambda (ax - bx) (by + ay) in\n (bx, by)\n\n let if_value (cond : Boolean.var) ~then_ ~else_ =\n let x1, y1 = Curve.to_affine_exn then_ in\n let x2, y2 = Curve.to_affine_exn else_ in\n let cond = (cond :> Field.Var.t) in\n let choose a1 a2 =\n let open Field.Checked in\n F.map2_ a1 a2 ~f:(fun a1 a2 ->\n (a1 * cond) + (a2 * (Field.Var.constant Field.one - cond)) )\n in\n (choose x1 x2, choose y1 y2)\n\n let%snarkydef_ scale (type shifted)\n (module Shifted : Shifted.S with type t = shifted) t\n (c : Boolean.var Bitstring_lib.Bitstring.Lsb_first.t) ~(init : shifted) :\n shifted Checked.t =\n let c = Bitstring_lib.Bitstring.Lsb_first.to_list c in\n let open Let_syntax in\n let rec go i bs0 acc pt =\n match bs0 with\n | [] ->\n return acc\n | b :: bs ->\n let%bind acc' =\n with_label (sprintf \"acc_%d\" i) (fun () ->\n let%bind add_pt = Shifted.add acc pt in\n let don't_add_pt = acc in\n Shifted.if_ b ~then_:add_pt ~else_:don't_add_pt )\n and pt' = double pt in\n go (i + 1) bs acc' pt'\n in\n go 0 c init t\n\n (* This 'looks up' a field element from a lookup table of size 2^2 = 4 with\n a 2 bit index. See https://github.com/zcash/zcash/issues/2234#issuecomment-383736266 for\n a discussion of this trick.\n *)\n let lookup_point (b0, b1) (t1, t2, t3, t4) =\n let%map b0_and_b1 = Boolean.( && ) b0 b1 in\n let lookup_one (a1, a2, a3, a4) =\n let open F.Unchecked in\n let ( * ) x b = F.map_ x ~f:(fun x -> Field.Var.scale b x) in\n let ( +^ ) = F.( + ) in\n F.constant a1\n +^ ((a2 - a1) * (b0 :> Field.Var.t))\n +^ ((a3 - a1) * (b1 :> Field.Var.t))\n +^ ((a4 + a1 - a2 - a3) * (b0_and_b1 :> Field.Var.t))\n in\n let x1, y1 = Curve.to_affine_exn t1\n and x2, y2 = Curve.to_affine_exn t2\n and x3, y3 = Curve.to_affine_exn t3\n and x4, y4 = Curve.to_affine_exn t4 in\n (lookup_one (x1, x2, x3, x4), lookup_one (y1, y2, y3, y4))\n\n (* Similar to the above, but doing lookup in a size 1 table *)\n let lookup_single_bit (b : Boolean.var) (t1, t2) =\n let lookup_one (a1, a2) =\n let open F in\n constant a1\n + map_ Unchecked.(a2 - a1) ~f:(Field.Var.scale (b :> Field.Var.t))\n in\n let x1, y1 = Curve.to_affine_exn t1 and x2, y2 = Curve.to_affine_exn t2 in\n (lookup_one (x1, x2), lookup_one (y1, y2))\n\n let scale_known (type shifted)\n (module Shifted : Shifted.S with type t = shifted) (t : Curve.t)\n (b : Boolean.var Bitstring_lib.Bitstring.Lsb_first.t) ~init =\n let b = Bitstring_lib.Bitstring.Lsb_first.to_list b in\n let sigma = t in\n let n = List.length b in\n let sigma_count = (n + 1) / 2 in\n\n (* = ceil (n / 2.0) *)\n (* We implement a complicated optimzation so that in total\n this costs roughly (1 + 3) * (n / 2) constraints, rather than\n the naive 4*n + 3*n. If scalars were represented with some\n kind of signed digit representation we could probably get it\n down to 2 * (n / 3) + 3 * (n / 3).\n *)\n (* Assume n is even *)\n (* Define\n to_term_unshifted i (b0, b1) =\n match b0, b1 with\n | false, false -> oo\n | true, false -> 2^i * t\n | false, true -> 2^{i+1} * t\n | true, true -> 2^i * t + 2^{i + 1} t\n\n to_term i (b0, b1) =\n sigma + to_term_unshifted i (b0, b1) =\n match b0, b1 with\n | false, false -> sigma\n | true, false -> sigma + 2^i * t\n | false, true -> sigma + 2^{i+1} * t\n | true, true -> sigma + 2^i * t + 2^{i + 1} t\n *)\n let to_term ~two_to_the_i ~two_to_the_i_plus_1 bits =\n lookup_point bits\n ( sigma\n , Curve.(sigma + two_to_the_i)\n , Curve.(sigma + two_to_the_i_plus_1)\n , Curve.(sigma + two_to_the_i + two_to_the_i_plus_1) )\n in\n\n (*\n Say b = b0, b1, .., b_{n-1}.\n We compute\n\n (to_term 0 (b0, b1)\n + to_term 2 (b2, b3)\n + to_term 4 (b4, b5)\n + ...\n + to_term (n-2) (b_{n-2}, b_{n-1}))\n - (n/2) * sigma\n =\n (n/2)*sigma + (b0*2^0 + b1*21 + ... + b_{n-1}*2^{n-1}) t - (n/2) * sigma\n =\n (n/2)*sigma + b * t - (n/2)*sigma\n = b * t\n *)\n let open Let_syntax in\n (* TODO #1152\n Can get away with using an unsafe add if we modify this a bit. *)\n let rec go acc two_to_the_i bits =\n match bits with\n | [] ->\n return acc\n | [ b_i ] ->\n let term =\n lookup_single_bit b_i (sigma, Curve.(sigma + two_to_the_i))\n in\n Shifted.add acc term\n | b_i :: b_i_plus_1 :: rest ->\n let two_to_the_i_plus_1 = Curve.double two_to_the_i in\n let%bind term =\n to_term ~two_to_the_i ~two_to_the_i_plus_1 (b_i, b_i_plus_1)\n in\n let%bind acc = Shifted.add acc term in\n go acc (Curve.double two_to_the_i_plus_1) rest\n in\n let%bind result_with_shift = go init t b in\n let unshift =\n Curve.scale (Curve.negate sigma) (Scalar.of_int sigma_count)\n in\n Shifted.add result_with_shift (constant unshift)\n\n let to_constant (x, y) =\n let open Option.Let_syntax in\n let%map x = F.to_constant x and y = F.to_constant y in\n Curve.of_affine (x, y)\n\n let scale m t c ~init =\n match to_constant t with\n | Some t ->\n scale_known m t c ~init\n | None ->\n scale m t c ~init\n\n let sum (type shifted) (module Shifted : Shifted.S with type t = shifted) xs\n ~init =\n let open Let_syntax in\n let rec go acc = function\n | [] ->\n return acc\n | t :: ts ->\n let%bind acc' = Shifted.add acc t in\n go acc' ts\n in\n go init xs\nend\n","module Length = struct\n type 'a t = ('a list, int) Sigs.predicate2\n\n let equal l len = Caml.List.compare_length_with l len = 0\n\n let unequal l len = Caml.List.compare_length_with l len <> 0\n\n let gte l len = Caml.List.compare_length_with l len >= 0\n\n let gt l len = Caml.List.compare_length_with l len > 0\n\n let lte l len = Caml.List.compare_length_with l len <= 0\n\n let lt l len = Caml.List.compare_length_with l len < 0\n\n module Compare = struct\n let ( = ) = equal\n\n let ( <> ) = unequal\n\n let ( >= ) = gte\n\n let ( > ) = gt\n\n let ( <= ) = lte\n\n let ( < ) = lt\n end\nend\n","open Core_kernel\ninclude Result\nopen Let_syntax\n\nmodule List = struct\n let map ls ~f =\n let%map r =\n List.fold_result ls ~init:[] ~f:(fun t el ->\n let%map h = f el in\n h :: t )\n in\n List.rev r\nend\n","(* bits_intf.ml *)\n\n[%%import \"/src/config.mlh\"]\n\nopen Fold_lib\n\nmodule type Basic = sig\n type t\n\n val fold : t -> bool Fold.t\n\n val size_in_bits : int\nend\n\nmodule type S = sig\n include Basic\n\n val iter : t -> f:(bool -> unit) -> unit\n\n val to_bits : t -> bool list\nend\n\nmodule type Convertible_bits = sig\n include S\n\n val of_bits : bool list -> t\nend\n\n[%%ifdef consensus_mechanism]\n\nopen Tuple_lib\n\nmodule Snarkable = struct\n module type Basic = sig\n type (_, _) typ\n\n type _ checked\n\n type boolean_var\n\n val size_in_bits : int\n\n module Packed : sig\n type var\n\n type value\n\n val typ : (var, value) typ\n\n val size_in_bits : int\n end\n\n module Unpacked : sig\n type var\n\n type value\n\n val typ : (var, value) typ\n\n val var_to_bits : var -> boolean_var Bitstring_lib.Bitstring.Lsb_first.t\n\n val var_of_bits : boolean_var Bitstring_lib.Bitstring.Lsb_first.t -> var\n\n val var_to_triples : var -> boolean_var Triple.t list\n\n val var_of_value : value -> var\n\n val size_in_bits : int\n end\n end\n\n module type Lossy = sig\n include Basic\n\n val project_value : Unpacked.value -> Packed.value\n\n val unpack_value : Packed.value -> Unpacked.value\n\n val project_var : Unpacked.var -> Packed.var\n\n val choose_preimage_var : Packed.var -> Unpacked.var checked\n end\n\n module type Faithful = sig\n include Basic\n\n val pack_value : Unpacked.value -> Packed.value\n\n val unpack_value : Packed.value -> Unpacked.value\n\n val pack_var : Unpacked.var -> Packed.var\n\n val unpack_var : Packed.var -> Unpacked.var checked\n end\n\n module type Small = sig\n type comparison_result\n\n type field_var\n\n include Faithful with type Packed.var = private field_var\n\n val compare_var : Unpacked.var -> Unpacked.var -> comparison_result checked\n\n val increment_var : Unpacked.var -> Unpacked.var checked\n\n val increment_if_var : Unpacked.var -> boolean_var -> Unpacked.var checked\n\n val assert_equal_var : Unpacked.var -> Unpacked.var -> unit checked\n\n val equal_var : Unpacked.var -> Unpacked.var -> boolean_var checked\n\n val var_of_field : field_var -> Unpacked.var checked\n\n val var_of_field_unsafe : field_var -> Packed.var\n\n val if_ :\n boolean_var\n -> then_:Unpacked.var\n -> else_:Unpacked.var\n -> Unpacked.var checked\n end\nend\n\n[%%endif]\n","open Core_kernel\n\nmodule Make (Impl : Snarky_backendless.Snark_intf.S) = struct\n open Impl\n open Let_syntax\n\n let pack_int bs =\n assert (List.length bs < 62) ;\n let rec go pt acc = function\n | [] ->\n acc\n | b :: bs ->\n if b then go (2 * pt) (pt + acc) bs else go (2 * pt) acc bs\n in\n go 1 0 bs\n\n let boolean_assert_lte (x : Boolean.var) (y : Boolean.var) =\n (*\n x <= y\n y == 1 or x = 0\n (y - 1) * x = 0\n *)\n assert_r1cs\n Field.Var.(sub (y :> Field.Var.t) (constant Field.one))\n (x :> Field.Var.t)\n (Field.Var.constant Field.zero)\n\n let assert_decreasing : Boolean.var list -> unit Checked.t =\n let rec go prev (bs0 : Boolean.var list) =\n match bs0 with\n | [] ->\n return ()\n | b :: bs ->\n let%bind () = boolean_assert_lte b prev in\n go b bs\n in\n function [] -> return () | b :: bs -> go b bs\n\n let nth_bit x ~n = (x lsr n) land 1 = 1\n\n let apply_mask mask bs = Checked.all (List.map2_exn mask bs ~f:Boolean.( && ))\n\n let pack_unsafe (bs0 : Boolean.var list) =\n let n = List.length bs0 in\n assert (n <= Field.size_in_bits) ;\n let rec go acc two_to_the_i = function\n | b :: bs ->\n go\n (Field.Var.add acc (Field.Var.scale b two_to_the_i))\n (Field.add two_to_the_i two_to_the_i)\n bs\n | [] ->\n acc\n in\n go (Field.Var.constant Field.zero) Field.one (bs0 :> Field.Var.t list)\n\n type _ Snarky_backendless.Request.t +=\n | N_ones : bool list Snarky_backendless.Request.t\n\n let n_ones ~total_length n =\n let%bind bs =\n exists\n (Typ.list ~length:total_length Boolean.typ)\n ~request:(As_prover.return N_ones)\n ~compute:\n As_prover.(\n map (read_var n) ~f:(fun n ->\n List.init total_length ~f:(fun i ->\n Bigint.(\n compare (of_field (Field.of_int i)) (of_field n) < 0) ) ))\n in\n let%map () =\n Field.Checked.Assert.equal\n (Field.Var.sum (bs :> Field.Var.t list))\n (* This can't overflow since the field is huge *)\n n\n and () = assert_decreasing bs in\n bs\n\n let assert_num_bits_upper_bound bs u =\n let total_length = List.length bs in\n assert (total_length < Field.size_in_bits) ;\n let%bind mask = n_ones ~total_length u in\n let%bind masked = apply_mask mask bs in\n with_label __LOC__ (fun () ->\n Field.Checked.Assert.equal (pack_unsafe masked) (pack_unsafe bs) )\n\n let num_bits_int =\n let rec go acc n = if n = 0 then acc else go (1 + acc) (n lsr 1) in\n go 0\n\n let size_in_bits_size_in_bits = num_bits_int Field.size_in_bits\n\n type _ Snarky_backendless.Request.t +=\n | Num_bits_upper_bound : Field.t Snarky_backendless.Request.t\n\n let num_bits_upper_bound_unchecked x =\n let num_bits =\n match\n List.find_mapi\n (List.rev (Field.unpack x))\n ~f:(fun i x -> if x then Some i else None)\n with\n | Some leading_zeroes ->\n Field.size_in_bits - leading_zeroes\n | None ->\n 0\n in\n num_bits\n\n (* Someday: this could definitely be made more efficient *)\n let num_bits_upper_bound_unpacked : Boolean.var list -> Field.Var.t Checked.t\n =\n fun x_unpacked ->\n let%bind res =\n exists Typ.field\n ~request:(As_prover.return Num_bits_upper_bound)\n ~compute:\n As_prover.(\n map\n (read_var (Field.Var.project x_unpacked))\n ~f:(fun x -> Field.of_int (num_bits_upper_bound_unchecked x)))\n in\n let%map () = assert_num_bits_upper_bound x_unpacked res in\n res\n\n let num_bits_upper_bound ~max_length (x : Field.Var.t) : Field.Var.t Checked.t\n =\n Field.Checked.unpack x ~length:max_length >>= num_bits_upper_bound_unpacked\n\n let%test_module \"Snark_util\" =\n ( module struct\n let () = Random.init 123456789\n\n let random_bitstring length =\n List.init length ~f:(fun _ -> Random.bool ())\n\n let random_n_bit_field_elt n = Field.project (random_bitstring n)\n\n let%test_unit \"compare\" =\n let bit_length = Field.size_in_bits - 2 in\n let random () = random_n_bit_field_elt bit_length in\n let test () =\n let x = random () in\n let y = random () in\n let less, less_or_equal =\n run_and_check\n (let%map { less; less_or_equal } =\n Field.Checked.compare ~bit_length (Field.Var.constant x)\n (Field.Var.constant y)\n in\n As_prover.(\n map2 (read Boolean.typ less)\n (read Boolean.typ less_or_equal)\n ~f:Tuple2.create) )\n |> Or_error.ok_exn\n in\n let r = Bigint.(compare (of_field x) (of_field y)) in\n assert (Bool.equal less (r < 0)) ;\n assert (Bool.equal less_or_equal (r <= 0))\n in\n for _i = 0 to 100 do\n test ()\n done\n\n let%test_unit \"boolean_assert_lte\" =\n Or_error.ok_exn\n (check\n (Checked.all_unit\n [ boolean_assert_lte Boolean.false_ Boolean.false_\n ; boolean_assert_lte Boolean.false_ Boolean.true_\n ; boolean_assert_lte Boolean.true_ Boolean.true_\n ] ) ) ;\n assert (\n Or_error.is_error\n (check (boolean_assert_lte Boolean.true_ Boolean.false_)) )\n\n let%test_unit \"assert_decreasing\" =\n let decreasing bs =\n check (assert_decreasing (List.map ~f:Boolean.var_of_value bs))\n in\n Or_error.ok_exn (decreasing [ true; true; true; false ]) ;\n Or_error.ok_exn (decreasing [ true; true; false; false ]) ;\n assert (Or_error.is_error (decreasing [ true; true; false; true ]))\n\n let%test_unit \"n_ones\" =\n let total_length = 6 in\n let test n =\n let t () =\n n_ones ~total_length (Field.Var.constant (Field.of_int n))\n in\n let handle_with (resp : bool list) =\n handle t (fun (With { request; respond }) ->\n match request with\n | N_ones ->\n respond (Provide resp)\n | _ ->\n unhandled )\n in\n let correct = Int.pow 2 n - 1 in\n let to_bits k =\n List.init total_length ~f:(fun i -> (k lsr i) land 1 = 1)\n in\n for i = 0 to Int.pow 2 total_length - 1 do\n if i = correct then\n Or_error.ok_exn (check (handle_with (to_bits i)))\n else assert (Or_error.is_error (check (handle_with (to_bits i))))\n done\n in\n for n = 0 to total_length do\n test n\n done\n\n let%test_unit \"num_bits_int\" =\n assert (num_bits_int 1 = 1) ;\n assert (num_bits_int 5 = 3) ;\n assert (num_bits_int 17 = 5)\n\n let%test_unit \"num_bits_upper_bound_unchecked\" =\n let f k bs =\n assert (num_bits_upper_bound_unchecked (Field.project bs) = k)\n in\n f 3 [ true; true; true; false; false ] ;\n f 4 [ true; true; true; true; false ] ;\n f 3 [ true; false; true; false; false ] ;\n f 5 [ true; false; true; false; true ]\n\n (*let%test_unit \"num_bits_upper_bound\" =\n let max_length = Field.size_in_bits - 1 in\n let test x =\n let handle_with resp =\n handle\n (num_bits_upper_bound ~max_length (Field.Var.constant x))\n (fun (With {request; respond}) ->\n match request with\n | Num_bits_upper_bound -> respond (Field.of_int resp)\n | _ -> unhandled)\n in\n let true_answer = num_bits_upper_bound_unchecked x in\n for i = 0 to true_answer - 1 do\n if check (handle_with i) ()\n then begin\n let n = Bigint.of_field x in\n failwithf !\"Shouldn't have passed: x=%s, i=%d\"\n (String.init max_length ~f:(fun j -> if Bigint.test_bit n j then '1' else '0'))\n i ();\n end;\n done;\n assert (check (handle_with true_answer) ())\n in\n test (random_n_bit_field_elt max_length)*)\n end )\nend\n","open Snark_bits\n\nmodule type S = sig\n include Snarky_backendless.Snark_intf.S\n\n module Snarkable : sig\n module type S = sig\n type var\n\n type value\n\n val typ : (var, value) Typ.t\n end\n\n module Bits : sig\n module type Faithful =\n Bits_intf.Snarkable.Faithful\n with type ('a, 'b) typ := ('a, 'b) Typ.t\n and type 'a checked := 'a Checked.t\n and type boolean_var := Boolean.var\n\n module type Lossy =\n Bits_intf.Snarkable.Lossy\n with type ('a, 'b) typ := ('a, 'b) Typ.t\n and type 'a checked := 'a Checked.t\n and type boolean_var := Boolean.var\n end\n end\nend\n","(* data_hash.ml *)\n\n[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Snark_params.Tick\n\n[%%ifdef consensus_mechanism]\n\nopen Bitstring_lib\n\n[%%endif]\n\nmodule type Full_size = Data_hash_intf.Full_size\n\nmodule Make_basic (M : sig\n val length_in_bits : int\nend) =\nstruct\n type t = Field.t [@@deriving sexp, compare, hash]\n\n let to_decimal_string (t : Field.t) = Field.to_string t\n\n let of_decimal_string (s : string) = Field.of_string s\n\n let to_bytes t =\n Fold_lib.(Fold.bool_t_to_string (Fold.of_list (Field.unpack t)))\n\n let length_in_bits = M.length_in_bits\n\n let () = assert (Int.(length_in_bits <= Field.size_in_bits))\n\n let to_input t = Random_oracle.Input.Chunked.field t\n\n [%%ifdef consensus_mechanism]\n\n (* this is in consensus code, because Bigint comes\n from snarky functors\n *)\n let gen : t Quickcheck.Generator.t =\n let m =\n if Int.(length_in_bits = Field.size_in_bits) then\n Bignum_bigint.(Field.size - one)\n else Bignum_bigint.(pow (of_int 2) (of_int length_in_bits) - one)\n in\n Quickcheck.Generator.map\n Bignum_bigint.(gen_incl zero m)\n ~f:(fun x -> Bigint.(to_field (of_bignum_bigint x)))\n\n type var =\n { digest : Random_oracle.Checked.Digest.t\n ; mutable bits : Boolean.var Bitstring.Lsb_first.t option\n }\n\n let var_of_t t =\n let n = Bigint.of_field t in\n { digest = Field.Var.constant t\n ; bits =\n Some\n (Bitstring.Lsb_first.of_list\n (List.init M.length_in_bits ~f:(fun i ->\n Boolean.var_of_value (Bigint.test_bit n i) ) ) )\n }\n\n open Let_syntax\n\n let var_to_hash_packed { digest; _ } = digest\n\n (* TODO: Audit this usage of choose_preimage *)\n let unpack =\n if Int.( = ) length_in_bits Field.size_in_bits then fun x ->\n Field.Checked.choose_preimage_var x ~length:length_in_bits\n >>| fun x -> (x :> Boolean.var list)\n else Field.Checked.unpack ~length:length_in_bits\n\n let%snarkydef_ var_to_bits t =\n match t.bits with\n | Some bits ->\n return (bits :> Boolean.var list)\n | None ->\n let%map bits = unpack t.digest in\n t.bits <- Some (Bitstring.Lsb_first.of_list bits) ;\n bits\n\n let var_to_input (t : var) = Random_oracle.Input.Chunked.field t.digest\n\n (* TODO : use Random oracle.Digest to satisfy Bits_intf.S, move out of\n consensus_mechanism guard\n *)\n module Bs =\n Snark_bits.Bits.Make_field\n (Snark_params.Tick.Field)\n (Snark_params.Tick.Bigint)\n\n include (Bs : module type of Bs with type t := t)\n\n let assert_equal x y = Field.Checked.Assert.equal x.digest y.digest\n\n let equal_var x y = Field.Checked.equal x.digest y.digest\n\n let typ : (var, t) Typ.t =\n Typ.transport_var Typ.field\n ~there:(fun { digest; bits = _ } -> digest)\n ~back:(fun digest -> { digest; bits = None })\n\n [%%endif]\nend\n\nmodule T0 = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n [@@@with_all_version_tags]\n\n type t = (Field.t[@version_asserted]) [@@deriving sexp, compare, hash]\n\n let to_latest = Fn.id\n end\n end]\nend\n\nmodule Make_full_size (B58_data : Data_hash_intf.Data_hash_descriptor) = struct\n module Basic = Make_basic (struct\n let length_in_bits = Field.size_in_bits\n end)\n\n include Basic\n\n module Base58_check = Codable.Make_base58_check (struct\n (* for compatibility with legacy Base58Check serializations *)\n include T0.Stable.Latest.With_all_version_tags\n\n (* the serialization here is only used for the hash impl which is only\n used for hashtbl, it's ok to disagree with the \"real\" serialization *)\n include Hashable.Make_binable (T0.Stable.Latest)\n include B58_data\n end)\n\n [%%define_locally\n Base58_check.\n (to_base58_check, of_base58_check, of_base58_check_exn, to_yojson, of_yojson)]\n\n module T = struct\n type t = Field.t [@@deriving sexp, compare, hash]\n end\n\n include Comparable.Make (T)\n include Hashable.Make (T)\n\n let of_hash = Fn.id\n\n let to_field = Fn.id\n\n [%%ifdef consensus_mechanism]\n\n let var_of_hash_packed digest = { digest; bits = None }\n\n let var_to_field { digest; _ } = digest\n\n let if_ cond ~then_ ~else_ =\n let%map digest =\n Field.Checked.if_ cond ~then_:then_.digest ~else_:else_.digest\n in\n { digest; bits = None }\n\n [%%endif]\nend\n","type t\n\nexternal create : unit -> t = \"caml_pasta_fp_poseidon_params_create\"\n\nexternal block_cipher : t -> Kimchi_bindings.FieldVectors.Fp.t -> unit\n = \"caml_pasta_fp_poseidon_block_cipher\"\n","let length_in_bytes = 20\n\nmodule T : sig\n type t = private string\n\n val create : string -> t\nend = struct\n type t = string\n\n let padding_char = '*'\n\n let create s : t =\n let string_length = String.length s in\n assert (string_length <= length_in_bytes) ;\n let diff = length_in_bytes - string_length in\n let r = s ^ String.init diff (fun _ -> padding_char) in\n assert (String.length r = length_in_bytes) ;\n r\nend\n\ninclude T\n\nlet protocol_state = create \"MinaProtoState\"\n\nlet protocol_state_body = create \"MinaProtoStateBody\"\n\nlet account = create \"MinaAccount\"\n\nlet side_loaded_vk = create \"MinaSideLoadedVk\"\n\nlet zkapp_account = create \"MinaZkappAccount\"\n\nlet zkapp_payload = create \"MinaZkappPayload\"\n\nlet zkapp_body = create \"MinaZkappBody\"\n\nlet merkle_tree i = create (Printf.sprintf \"MinaMklTree%03d\" i)\n\nlet coinbase_merkle_tree i = create (Printf.sprintf \"MinaCbMklTree%03d\" i)\n\nlet merge_snark = create \"MinaMergeSnark\"\n\nlet base_snark = create \"MinaBaseSnark\"\n\nlet transition_system_snark = create \"MinaTransitionSnark\"\n\nlet signature_testnet = create \"CodaSignature\"\n\nlet signature_mainnet = create \"MinaSignatureMainnet\"\n\nlet signature_other chain_name = create (chain_name ^ \"Signature\")\n\nlet receipt_chain_user_command = create \"MinaReceiptUC\"\n\n(* leaving this one with \"Coda\", to preserve the existing hashes *)\nlet receipt_chain_zkapp = create \"CodaReceiptZkapp\"\n\nlet epoch_seed = create \"MinaEpochSeed\"\n\nlet vrf_message = create \"MinaVrfMessage\"\n\nlet vrf_output = create \"MinaVrfOutput\"\n\nlet vrf_evaluation = create \"MinaVrfEvaluation\"\n\nlet pending_coinbases = create \"PendingCoinbases\"\n\nlet coinbase_stack_data = create \"CoinbaseStackData\"\n\n(* length is limited, so we drop some characters here *)\nlet coinbase_stack_state_hash = create \"CoinbaseStackStaHash\"\n\nlet coinbase_stack = create \"CoinbaseStack\"\n\nlet coinbase = create \"Coinbase\"\n\nlet checkpoint_list = create \"MinaCheckpoints\"\n\nlet bowe_gabizon_hash = create \"MinaTockBGHash\"\n\nlet zkapp_precondition = create \"MinaZkappPred\"\n\n(*for Zkapp_precondition.Account.t*)\nlet zkapp_precondition_account = create \"MinaZkappPredAcct\"\n\nlet zkapp_precondition_protocol_state = create \"MinaZkappPredPS\"\n\n(*for Account_update.Account_precondition.t*)\nlet account_update_account_precondition = create \"MinaAcctUpdAcctPred\"\n\nlet account_update = create \"MinaAcctUpdate\"\n\nlet account_update_cons = create \"MinaAcctUpdateCons\"\n\nlet account_update_node = create \"MinaAcctUpdateNode\"\n\nlet account_update_stack_frame = create \"MinaAcctUpdStckFrm\"\n\nlet account_update_stack_frame_cons = create \"MinaActUpStckFrmCons\"\n\nlet zkapp_uri = create \"MinaZkappUri\"\n\nlet zkapp_event = create \"MinaZkappEvent\"\n\nlet zkapp_events = create \"MinaZkappEvents\"\n\nlet zkapp_actions = create \"MinaZkappSeqEvents\"\n\nlet zkapp_memo = create \"MinaZkappMemo\"\n\nlet zkapp_test = create \"MinaZkappTest\"\n\nlet derive_token_id = create \"MinaDeriveTokenId\"\n","open Core_kernel\nopen Hash_prefixes\n\nlet salt (s : Hash_prefixes.t) = Random_oracle.salt (s :> string)\n\nlet salt_legacy (s : Hash_prefixes.t) = Random_oracle.Legacy.salt (s :> string)\n\nlet receipt_chain_signed_command = salt_legacy receipt_chain_user_command\n\nlet receipt_chain_zkapp_command = salt receipt_chain_user_command\n\nlet receipt_chain_zkapp = salt receipt_chain_zkapp\n\nlet coinbase = salt coinbase\n\nlet pending_coinbases = salt pending_coinbases\n\nlet coinbase_stack_data = salt coinbase_stack_data\n\nlet coinbase_stack_state_hash = salt coinbase_stack_state_hash\n\nlet coinbase_stack = salt coinbase_stack\n\nlet checkpoint_list = salt checkpoint_list\n\nlet merge_snark = salt merge_snark\n\nlet base_snark = salt base_snark\n\nlet protocol_state = salt protocol_state\n\nlet protocol_state_body = salt protocol_state_body\n\nlet merkle_tree =\n let f i = salt (merkle_tree i) in\n (* Cache up to the compiled ledger depth. *)\n let cached = ref [||] in\n fun i ->\n let len = Array.length !cached in\n if i >= len then\n cached :=\n Array.append !cached\n (Array.init (i + 1 - len) ~f:(fun i -> f (i + len))) ;\n !cached.(i)\n\nlet coinbase_merkle_tree =\n let f i = salt (coinbase_merkle_tree i) in\n let cached = ref [||] in\n fun i ->\n let len = Array.length !cached in\n if i >= len then\n cached :=\n Array.append !cached\n (Array.init (i + 1 - len) ~f:(fun i -> f (i + len))) ;\n !cached.(i)\n\nlet vrf_message = salt vrf_message\n\nlet signature_for_mainnet = salt signature_mainnet\n\nlet signature_for_testnet = salt signature_testnet\n\nlet signature_for_other chain_name = salt @@ signature_other chain_name\n\nlet signature ?(signature_kind = Mina_signature_kind.t) =\n match signature_kind with\n | Mainnet ->\n signature_for_mainnet\n | Testnet ->\n signature_for_testnet\n | Other_network chain_name ->\n signature_for_other chain_name\n\nlet signature_for_mainnet_legacy = salt_legacy signature_mainnet\n\nlet signature_for_testnet_legacy = salt_legacy signature_testnet\n\nlet signature_for_other_legacy chain_name =\n salt_legacy @@ signature_other chain_name\n\nlet signature_legacy ?(signature_kind = Mina_signature_kind.t) =\n match signature_kind with\n | Mainnet ->\n signature_for_mainnet_legacy\n | Testnet ->\n signature_for_testnet_legacy\n | Other_network chain_name ->\n signature_for_other_legacy chain_name\n\nlet vrf_output = salt vrf_output\n\nlet vrf_evaluation = salt vrf_evaluation\n\nlet epoch_seed = salt epoch_seed\n\nlet transition_system_snark = salt transition_system_snark\n\nlet account = salt account\n\nlet side_loaded_vk = salt side_loaded_vk\n\nlet zkapp_account = salt zkapp_account\n\nlet zkapp_payload = salt zkapp_payload\n\nlet zkapp_body = salt zkapp_body\n\nlet zkapp_precondition = salt zkapp_precondition\n\nlet zkapp_precondition_account = salt zkapp_precondition_account\n\nlet zkapp_precondition_protocol_state = salt zkapp_precondition_protocol_state\n\nlet account_update = salt account_update\n\nlet account_update_account_precondition =\n salt account_update_account_precondition\n\nlet account_update_cons = salt account_update_cons\n\nlet account_update_node = salt account_update_node\n\nlet account_update_stack_frame = salt account_update_stack_frame\n\nlet account_update_stack_frame_cons = salt account_update_stack_frame_cons\n\nlet zkapp_uri = salt zkapp_uri\n\nlet zkapp_event = salt zkapp_event\n\nlet zkapp_events = salt zkapp_events\n\nlet zkapp_actions = salt zkapp_actions\n\nlet zkapp_memo = salt zkapp_memo\n\nlet zkapp_test = salt zkapp_test\n\nlet derive_token_id = salt derive_token_id\n","open Core_kernel\nopen Fold_lib\n\nmodule Make (Impl : Snarky_backendless.Snark_intf.S) = struct\n let triple_string trips =\n let to_string b = if b then \"1\" else \"0\" in\n String.concat ~sep:\" \"\n (List.map trips ~f:(fun (b1, b2, b3) ->\n to_string b1 ^ to_string b2 ^ to_string b3 ) )\n\n let checked_to_unchecked typ1 typ2 checked input =\n let open Impl in\n let checked_result =\n run_and_check\n (let%bind input = exists typ1 ~compute:(As_prover.return input) in\n let%map result = checked input in\n As_prover.read typ2 result )\n |> Or_error.ok_exn\n in\n checked_result\n\n let test_to_triples typ fold var_to_triples input =\n let open Impl in\n let checked =\n run_and_check\n (let%bind input = exists typ ~compute:(As_prover.return input) in\n let%map result = var_to_triples input in\n As_prover.all\n (List.map result\n ~f:\n (As_prover.read\n (Typ.tuple3 Boolean.typ Boolean.typ Boolean.typ) ) ) )\n |> Or_error.ok_exn\n in\n let unchecked = Fold.to_list (fold input) in\n if not ([%equal: (bool * bool * bool) list] checked unchecked) then\n failwithf\n !\"Got %s (%d)\\nexpected %s (%d)\"\n (triple_string checked) (List.length checked) (triple_string unchecked)\n (List.length unchecked) ()\n\n let test_equal ?(equal = Poly.( = )) typ1 typ2 checked unchecked input =\n let checked_result = checked_to_unchecked typ1 typ2 checked input in\n assert (equal checked_result (unchecked input))\n\n let arbitrary_string ~len =\n String.init (Random.int len) ~f:(fun _ ->\n Char.of_int_exn (Random.int_incl 0 255) )\n\n let with_randomness r f =\n let s = Caml.Random.get_state () in\n Random.init r ;\n try\n let x = f () in\n Caml.Random.set_state s ; x\n with e -> Caml.Random.set_state s ; raise e\n\n (** utility function to print digests to put in tests, see `check_serialization' below *)\n let print_digest digest = printf \"\\\"\" ; printf \"%s\" digest ; printf \"\\\"\\n%!\"\n\n (** use this function to test Bin_prot serialization of types *)\n let check_serialization (type t) (module M : Binable.S with type t = t)\n (t : t) known_good_digest =\n (* serialize value *)\n let sz = M.bin_size_t t in\n let buf = Bin_prot.Common.create_buf sz in\n ignore (M.bin_write_t buf ~pos:0 t : int) ;\n let bytes = Bytes.create sz in\n Bin_prot.Common.blit_buf_bytes buf bytes ~len:sz ;\n (* compute MD5 digest of serialization *)\n let digest = Md5.digest_bytes bytes |> Md5.to_hex in\n let result = String.equal digest known_good_digest in\n if not result then (\n printf \"Expected digest: \" ;\n print_digest known_good_digest ;\n printf \"Got digest: \" ;\n print_digest digest ) ;\n result\nend\n\ninclude Make (Snark_params.Tick)\n","(* compressed_poly.ml -- versioned type with parameters for compressed curve point *)\n\n[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\n\nmodule Poly = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n [@@@with_all_version_tags]\n\n type ('field, 'boolean) t =\n ('field, 'boolean) Mina_wire_types.Public_key.Compressed.Poly.V1.t =\n { x : 'field; is_odd : 'boolean }\n [@@deriving compare, equal, hash, hlist]\n end\n end]\nend\n","open Core_kernel\nmodule Js = Js_of_ocaml.Js\nmodule Impl = Pickles.Impls.Step\nmodule Field = Impl.Field\n\n(* Ledger - local mina transaction logic for prototyping and testing zkapps *)\n\ntype public_key = Signature_lib.Public_key.Compressed.t\n\nmodule Account_update = Mina_base.Account_update\nmodule Zkapp_command = Mina_base.Zkapp_command\n\nlet ledger_class : < .. > Js.t =\n Js.Unsafe.eval_string {js|(function(v) { this.value = v; return this })|js}\n\nmodule Ledger : Mina_base.Ledger_intf.S = struct\n module Account = Mina_base.Account\n module Account_id = Mina_base.Account_id\n module Ledger_hash = Mina_base.Ledger_hash\n module Token_id = Mina_base.Token_id\n\n type t_ =\n { next_location : int\n ; accounts : Account.t Int.Map.t\n ; locations : int Account_id.Map.t\n }\n\n type t = t_ ref\n\n type location = int\n\n let get (t : t) (loc : location) : Account.t option = Map.find !t.accounts loc\n\n let location_of_account (t : t) (a : Account_id.t) : location option =\n Map.find !t.locations a\n\n let set (t : t) (loc : location) (a : Account.t) : unit =\n t := { !t with accounts = Map.set !t.accounts ~key:loc ~data:a }\n\n let next_location (t : t) : int =\n let loc = !t.next_location in\n t := { !t with next_location = loc + 1 } ;\n loc\n\n let get_or_create (t : t) (id : Account_id.t) :\n (Mina_base.Ledger_intf.account_state * Account.t * location) Or_error.t =\n let loc = location_of_account t id in\n let res =\n match loc with\n | None ->\n let loc = next_location t in\n let a = Account.create id Currency.Balance.zero in\n t := { !t with locations = Map.set !t.locations ~key:id ~data:loc } ;\n set t loc a ;\n (`Added, a, loc)\n | Some loc ->\n (`Existed, Option.value_exn (get t loc), loc)\n in\n Ok res\n\n let create_new_account (t : t) (id : Account_id.t) (a : Account.t) :\n unit Or_error.t =\n match location_of_account t id with\n | Some _ ->\n Or_error.errorf !\"account %{sexp: Account_id.t} already present\" id\n | None ->\n let loc = next_location t in\n t := { !t with locations = Map.set !t.locations ~key:id ~data:loc } ;\n set t loc a ;\n Ok ()\n\n let remove_accounts_exn (t : t) (ids : Account_id.t list) : unit =\n let locs = List.filter_map ids ~f:(fun id -> Map.find !t.locations id) in\n t :=\n { !t with\n locations = List.fold ids ~init:!t.locations ~f:Map.remove\n ; accounts = List.fold locs ~init:!t.accounts ~f:Map.remove\n }\n\n (* TODO *)\n let merkle_root (_ : t) : Ledger_hash.t = Field.Constant.zero\n\n let empty ~depth:_ () : t =\n ref\n { next_location = 0\n ; accounts = Int.Map.empty\n ; locations = Account_id.Map.empty\n }\n\n let with_ledger (type a) ~depth ~(f : t -> a) : a = f (empty ~depth ())\n\n let create_masked (t : t) : t = ref !t\n\n let apply_mask (t : t) ~(masked : t) = t := !masked\nend\n\nmodule Transaction_logic = Mina_transaction_logic.Make (Ledger)\n\ntype ledger_class = < value : Ledger.t Js.prop >\n\nlet ledger_constr : (Ledger.t -> ledger_class Js.t) Js.constr =\n Obj.magic ledger_class\n\nlet create_new_account_exn (t : Ledger.t) account_id account =\n Ledger.create_new_account t account_id account |> Or_error.ok_exn\n\nlet default_token_id =\n Mina_base.Token_id.default |> Mina_base.Token_id.to_field_unsafe\n\nlet account_id (pk : public_key) token =\n Mina_base.Account_id.create pk (Mina_base.Token_id.of_field token)\n\nmodule To_js = struct\n let option (transform : 'a -> 'b) (x : 'a option) =\n Js.Optdef.option (Option.map x ~f:transform)\nend\n\nlet check_account_update_signatures zkapp_command =\n let ({ fee_payer; account_updates; memo } : Zkapp_command.t) =\n zkapp_command\n in\n let tx_commitment = Zkapp_command.commitment zkapp_command in\n let full_tx_commitment =\n Zkapp_command.Transaction_commitment.create_complete tx_commitment\n ~memo_hash:(Mina_base.Signed_command_memo.hash memo)\n ~fee_payer_hash:\n (Zkapp_command.Digest.Account_update.create\n (Account_update.of_fee_payer fee_payer) )\n in\n let key_to_string = Signature_lib.Public_key.Compressed.to_base58_check in\n let check_signature who s pk msg =\n match Signature_lib.Public_key.decompress pk with\n | None ->\n failwith\n (sprintf \"Check signature: Invalid key on %s: %s\" who\n (key_to_string pk) )\n | Some pk_ ->\n if\n not\n (Signature_lib.Schnorr.Chunked.verify s\n (Kimchi_pasta.Pasta.Pallas.of_affine pk_)\n (Random_oracle_input.Chunked.field msg) )\n then\n failwith\n (sprintf \"Check signature: Invalid signature on %s for key %s\" who\n (key_to_string pk) )\n else ()\n in\n\n check_signature \"fee payer\" fee_payer.authorization fee_payer.body.public_key\n full_tx_commitment ;\n List.iteri (Zkapp_command.Call_forest.to_account_updates account_updates)\n ~f:(fun i p ->\n let commitment =\n if p.body.use_full_commitment then full_tx_commitment else tx_commitment\n in\n match p.authorization with\n | Signature s ->\n check_signature\n (sprintf \"account_update %d\" i)\n s p.body.public_key commitment\n | Proof _ | None_given ->\n () )\n\nlet add_account_exn (l : Ledger.t) pk (balance : string) =\n let account_id = account_id pk default_token_id in\n let bal_u64 = Unsigned.UInt64.of_string balance in\n let balance = Currency.Balance.of_uint64 bal_u64 in\n let a : Mina_base.Account.t = Mina_base.Account.create account_id balance in\n create_new_account_exn l account_id a\n\nlet create () : ledger_class Js.t =\n let l = Ledger.empty ~depth:20 () in\n new%js ledger_constr l\n\nlet account_to_json =\n let deriver = Mina_base.Account.deriver @@ Fields_derivers_zkapps.o () in\n let to_json' = Fields_derivers_zkapps.to_json deriver in\n let to_json (account : Mina_base.Account.t) : Js.Unsafe.any =\n account |> to_json' |> Yojson.Safe.to_string |> Js.string |> Util.json_parse\n in\n to_json\n\nlet get_account l (pk : public_key) (token : Impl.field) :\n Js.Unsafe.any Js.optdef =\n let loc = Ledger.location_of_account l##.value (account_id pk token) in\n let account = Option.bind loc ~f:(Ledger.get l##.value) in\n To_js.option account_to_json account\n\nlet add_account l (pk : public_key) (balance : Js.js_string Js.t) =\n add_account_exn l##.value pk (Js.to_string balance)\n\nlet protocol_state_of_json =\n let deriver =\n Mina_base.Zkapp_precondition.Protocol_state.View.deriver\n @@ Fields_derivers_zkapps.o ()\n in\n let of_json = Fields_derivers_zkapps.of_json deriver in\n fun (json : Js.js_string Js.t) :\n Mina_base.Zkapp_precondition.Protocol_state.View.t ->\n json |> Js.to_string |> Yojson.Safe.from_string |> of_json\n\nlet apply_zkapp_command_transaction l (txn : Zkapp_command.t)\n (account_creation_fee : string)\n (network_state : Mina_base.Zkapp_precondition.Protocol_state.View.t) =\n check_account_update_signatures txn ;\n let ledger = l##.value in\n let application_result =\n Transaction_logic.apply_zkapp_command_unchecked\n ~global_slot:network_state.global_slot_since_genesis\n ~state_view:network_state\n ~constraint_constants:\n { Genesis_constants.Constraint_constants.compiled with\n account_creation_fee = Currency.Fee.of_string account_creation_fee\n }\n ledger txn\n in\n let applied, _ =\n match application_result with\n | Ok res ->\n res\n | Error err ->\n Util.raise_error (Error.to_string_hum err)\n in\n match applied.command.status with\n | Applied ->\n ()\n | Failed failures ->\n Util.raise_error\n ( Mina_base.Transaction_status.Failure.Collection.to_yojson failures\n |> Yojson.Safe.to_string )\n\nlet apply_json_transaction l (tx_json : Js.js_string Js.t)\n (account_creation_fee : Js.js_string Js.t) (network_json : Js.js_string Js.t)\n =\n let txn =\n Zkapp_command.of_json @@ Yojson.Safe.from_string @@ Js.to_string tx_json\n in\n let network_state = protocol_state_of_json network_json in\n apply_zkapp_command_transaction l txn\n (Js.to_string account_creation_fee)\n network_state\n\nlet method_ class_ (name : string) (f : _ Js.t -> _) =\n let prototype = Js.Unsafe.get class_ (Js.string \"prototype\") in\n Js.Unsafe.set prototype (Js.string name) (Js.wrap_meth_callback f)\n\nlet () =\n let static_method name f =\n Js.Unsafe.set ledger_class (Js.string name) (Js.wrap_callback f)\n in\n let method_ name (f : ledger_class Js.t -> _) = method_ ledger_class name f in\n static_method \"create\" create ;\n\n method_ \"getAccount\" get_account ;\n method_ \"addAccount\" add_account ;\n method_ \"applyJsonTransaction\" apply_json_transaction\n","(* public_key.ml *)\n\ninclude Non_zero_curve_point\nmodule Inner_curve = Snark_params.Tick.Inner_curve\n\nlet of_private_key_exn p = of_inner_curve_exn Inner_curve.(scale one p)\n","module type S = sig\n type t [@@deriving equal, sexp]\n\n module Stable : sig\n module V1 : sig\n type nonrec t = t [@@deriving bin_io, equal, sexp]\n end\n\n module Latest : module type of V1\n end\nend\n\nmodule type Hash = sig\n type t [@@deriving compare]\n\n include S with type t := t\n\n val merge : height:int -> t -> t -> t\nend\n\nmodule type Key = S\n\nmodule type Account = sig\n type hash\n\n include S\n\n val data_hash : t -> hash\nend\n","\nlet (blockchain_proof, transaction_proof) =\n ((Core_kernel.Binable.of_string (module\n Pickles.Proof.Proofs_verified_2.Stable.Latest)\n \"\\252\\012\\197i\\202m3\\161\\b\\252\\139\\134\\018}\\250\\015\\240\\195\\000\\252\\137\\000\\179\\254\\154\\214\\139{\\252\\017(\\185j\\141\\210\\243\\179\\000\\252\\193\\0075\\134p\\184\\207s\\252\\156\\231\\235\\195%\\236\\155r\\000\\252%O\\171W(\\182[\\n\\252\\242\\128\\235:\\131\\152\\175\\177\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\252\\185*\\167V\\180ps\\173\\252\\252\\158\\241\\213#\\249O6\\000\\252\\000|/\\142b\\028\\135Y\\252\\135\\204&\\162s\\246\\199\\156\\000\\252\\175\\242\\182\\158\\029\\130T#\\252~\\245}\\246\\209k\\185\\213\\000\\252\\246\\134\\144\\160\\208\\247{\\020\\252h*$@\\206b^b\\000\\252\\014\\173V2c\\027\\198\\175\\252\\251\\225\\031\\161\\016r\\128\\t\\000\\252\\145A\\172\\202\\190\\030X\\249\\252\\166\\201\\183>\\153\\213\\030W\\000\\252\\189\\195d\\205\\163PN\\170\\252h\\197\\254\\193\\n\\231\\020\\216\\000\\252m\\222^\\130\\223\\172\\029\\178\\252\\165\\007\\219\\197\\023\\162\\b\\254\\000\\252\\127\\170\\230\\233\\214\\015N\\130\\252,\\127\\185N\\152:\\246\\252\\000\\252\\202\\004\\027q+\\1361\\195\\252)&\\174\\182\\199\\1729\\145\\000\\252\\239Q\\129\\253G\\143\\015\\220\\252\\135\\149;\\196Cz\\169\\000\\000\\252\\1912\\134\\209\\030\\2168`\\252\\171\\005\\170\\162p\\188\\179\\249\\000\\252ZG\\175\\229\\224\\210u\\148\\252\\246\\210\\195\\174\\002\\167\\203\\209\\000\\252\\004|-\\249\\246\\015x\\190\\252T\\226\\2512\\145X=\\225\\000\\252\\019u1\\184\\018\\183p\\198\\252\\b>H\\1543\\204u\\022\\000\\252\\209\\184\\202\\177\\162\\176\\193H\\252\\206\\177q\\192\\227\\004f\\027\\000\\000\\002\\016\\000\\000\\000\\000\\000b\\153TI\\021\\240\\155\\231\\193y\\017D-%H@S\\180Y\\005\\219\\159AV0a\\253}\\1882\\211\\015\\172\\215R\\133\\247\\193\\162O\\199\\177\\230\\226|<\\022:U\\166\\177\\23169\\003\\029\\004\\235\\165^P\\004\\005\\022\\252o\\191\\230\\172\\201\\179\\1303\\252c\\024v\\249XC\\151y\\000\\252\\151\\135\\136\\233\\006+:\\221\\252\\199\\161D)@\\230z\\221\\000\\252\\203\\159\\156\\2440\\229\\232\\198\\252\\221\\156\\160\\205e\\187\\221\\007\\000\\252\\019\\026i\\135\\162Y,S\\252{oe*\\176\\188!\\169\\000\\252\\139\\007\\016\\143\\177w\\156\\226\\252\\238\\012k\\223\\000_\\\\\\248\\000\\252\\135\\156\\176\\007-\\167\\189\\029\\252\\160&_\\233\\226\\151\\027M\\000\\252\\017_\\128V|tu\\156\\252\\232\\241\\206\\250ic\\254\\161\\000\\252M`\\233\\219\\223\\138+\\\\\\252\\155\\247\\016\\242\\140q\\140Z\\000\\252Hk\\224Q\\\\\\179\\192\\\"\\252\\237m\\169@s\\139\\136\\166\\000\\252ndv^\\181\\215\\007\\144\\252\\018\\142N\\2199\\139\\198\\193\\000\\252\\201+?7^\\227ED\\252\\229\\205\\140\\252\\021\\199@\\157\\000\\252N\\170\\188K\\132\\130\\152B\\252\\188\\183\\175\\208\\215'\\169\\151\\000\\252wn\\253\\255[=\\202\\153\\252\\148B\\\\\\021Uj\\230\\239\\000\\252T\\153\\151!q\\178}K\\252@\\200\\147a\\224\\162\\031\\149\\000\\252\\179G\\007\\178\\190\\204\\209,\\252\\029\\002d\\242<\\222\\209[\\000\\000\\252o\\191\\230\\172\\201\\179\\1303\\252c\\024v\\249XC\\151y\\000\\252\\151\\135\\136\\233\\006+:\\221\\252\\199\\161D)@\\230z\\221\\000\\252\\203\\159\\156\\2440\\229\\232\\198\\252\\221\\156\\160\\205e\\187\\221\\007\\000\\252\\019\\026i\\135\\162Y,S\\252{oe*\\176\\188!\\169\\000\\252\\139\\007\\016\\143\\177w\\156\\226\\252\\238\\012k\\223\\000_\\\\\\248\\000\\252\\135\\156\\176\\007-\\167\\189\\029\\252\\160&_\\233\\226\\151\\027M\\000\\252\\017_\\128V|tu\\156\\252\\232\\241\\206\\250ic\\254\\161\\000\\252M`\\233\\219\\223\\138+\\\\\\252\\155\\247\\016\\242\\140q\\140Z\\000\\252Hk\\224Q\\\\\\179\\192\\\"\\252\\237m\\169@s\\139\\136\\166\\000\\252ndv^\\181\\215\\007\\144\\252\\018\\142N\\2199\\139\\198\\193\\000\\252\\201+?7^\\227ED\\252\\229\\205\\140\\252\\021\\199@\\157\\000\\252N\\170\\188K\\132\\130\\152B\\252\\188\\183\\175\\208\\215'\\169\\151\\000\\252wn\\253\\255[=\\202\\153\\252\\148B\\\\\\021Uj\\230\\239\\000\\252T\\153\\151!q\\178}K\\252@\\200\\147a\\224\\162\\031\\149\\000\\252\\179G\\007\\178\\190\\204\\209,\\252\\029\\002d\\242<\\222\\209[\\000\\000\\000\\000\\002H\\1816\\232FT\\165_O\\253\\255\\253\\245\\145\\189\\157<\\161pK\\206\\240\\\\\\165\\157\\194dH\\222\\223\\211\\017k\\026,D\\221!\\199\\205YU\\239\\025\\195\\243\\171\\184B\\014\\027z\\229\\023\\020\\222\\215\\138\\132M\\\"\\007\\245\\005H\\1816\\232FT\\165_O\\253\\255\\253\\245\\145\\189\\157<\\161pK\\206\\240\\\\\\165\\157\\194dH\\222\\223\\211\\017k\\026,D\\221!\\199\\205YU\\239\\025\\195\\243\\171\\184B\\014\\027z\\229\\023\\020\\222\\215\\138\\132M\\\"\\007\\245\\005\\002\\252\\185*\\167V\\180ps\\173\\252\\252\\158\\241\\213#\\249O6\\000\\252\\000|/\\142b\\028\\135Y\\252\\135\\204&\\162s\\246\\199\\156\\000\\252\\175\\242\\182\\158\\029\\130T#\\252~\\245}\\246\\209k\\185\\213\\000\\252\\246\\134\\144\\160\\208\\247{\\020\\252h*$@\\206b^b\\000\\252\\014\\173V2c\\027\\198\\175\\252\\251\\225\\031\\161\\016r\\128\\t\\000\\252\\145A\\172\\202\\190\\030X\\249\\252\\166\\201\\183>\\153\\213\\030W\\000\\252\\189\\195d\\205\\163PN\\170\\252h\\197\\254\\193\\n\\231\\020\\216\\000\\252m\\222^\\130\\223\\172\\029\\178\\252\\165\\007\\219\\197\\023\\162\\b\\254\\000\\252\\127\\170\\230\\233\\214\\015N\\130\\252,\\127\\185N\\152:\\246\\252\\000\\252\\202\\004\\027q+\\1361\\195\\252)&\\174\\182\\199\\1729\\145\\000\\252\\239Q\\129\\253G\\143\\015\\220\\252\\135\\149;\\196Cz\\169\\000\\000\\252\\1912\\134\\209\\030\\2168`\\252\\171\\005\\170\\162p\\188\\179\\249\\000\\252ZG\\175\\229\\224\\210u\\148\\252\\246\\210\\195\\174\\002\\167\\203\\209\\000\\252\\004|-\\249\\246\\015x\\190\\252T\\226\\2512\\145X=\\225\\000\\252\\019u1\\184\\018\\183p\\198\\252\\b>H\\1543\\204u\\022\\000\\252\\209\\184\\202\\177\\162\\176\\193H\\252\\206\\177q\\192\\227\\004f\\027\\000\\000\\252\\185*\\167V\\180ps\\173\\252\\252\\158\\241\\213#\\249O6\\000\\252\\000|/\\142b\\028\\135Y\\252\\135\\204&\\162s\\246\\199\\156\\000\\252\\175\\242\\182\\158\\029\\130T#\\252~\\245}\\246\\209k\\185\\213\\000\\252\\246\\134\\144\\160\\208\\247{\\020\\252h*$@\\206b^b\\000\\252\\014\\173V2c\\027\\198\\175\\252\\251\\225\\031\\161\\016r\\128\\t\\000\\252\\145A\\172\\202\\190\\030X\\249\\252\\166\\201\\183>\\153\\213\\030W\\000\\252\\189\\195d\\205\\163PN\\170\\252h\\197\\254\\193\\n\\231\\020\\216\\000\\252m\\222^\\130\\223\\172\\029\\178\\252\\165\\007\\219\\197\\023\\162\\b\\254\\000\\252\\127\\170\\230\\233\\214\\015N\\130\\252,\\127\\185N\\152:\\246\\252\\000\\252\\202\\004\\027q+\\1361\\195\\252)&\\174\\182\\199\\1729\\145\\000\\252\\239Q\\129\\253G\\143\\015\\220\\252\\135\\149;\\196Cz\\169\\000\\000\\252\\1912\\134\\209\\030\\2168`\\252\\171\\005\\170\\162p\\188\\179\\249\\000\\252ZG\\175\\229\\224\\210u\\148\\252\\246\\210\\195\\174\\002\\167\\203\\209\\000\\252\\004|-\\249\\246\\015x\\190\\252T\\226\\2512\\145X=\\225\\000\\252\\019u1\\184\\018\\183p\\198\\252\\b>H\\1543\\204u\\022\\000\\252\\209\\184\\202\\177\\162\\176\\193H\\252\\206\\177q\\192\\227\\004f\\027\\000\\000:{\\221-N#sE\\216t.\\146\\191u'\\001f@\\238\\128u\\005\\150fI\\237\\246\\129\\015\\128\\21106\\004j\\2083\\133\\221\\031i\\128%\\012\\175\\253p\\b\\001\\136(\\0201\\130L\\169\\1533\\135\\n\\202O\\\\\\131e;\\183=D\\236o\\189M\\132\\028\\133u!\\158\\199\\015\\001\\021JS\\128h\\141\\012~\\202;\\222\\216\\131\\245\\128\\135\\239\\247\\143~\\191\\222\\131\\007qF\\128\\191~\\151\\198\\014\\001\\025\\170\\164\\1530\\233\\178\\162D\\027h\\209\\157c\\215\\019\\160V\\151\\242\\128s\\01739R\\148\\246d\\187b\\017\\001\\197\\021\\245\\023\\014\\220?\\tqX\\248\\217\\137H\\230\\178E\\192x\\222H\\020\\241Qx\\158\\243I\\249\\020\\004\\002\\001C\\193@,\\255\\146\\128\\005\\251d\\017B\\n\\208V\\246r\\176\\002uU},\\214\\237E\\235UI\\252\\191:\\001\\225U\\015BBE\\198\\181\\209\\021\\187\\255Mt\\157:8\\206\\176U\\210\\011\\255;&\\196\\226\\129(\\177\\251-\\001\\170}C.F\\236\\b<\\238\\233\\210M\\251C\\131q:B\\134\\164\\169\\247kL\\153\\216\\217\\\\\\152\\206\\2161\\001I\\183\\002\\137\\241\\162\\241\\191\\219\\021u\\157\\158n\\155Zmz\\237\\175\\134\\027%\\235Y\\145\\161\\243;\\208\\152\\015\\001\\b\\219\\140\\\"\\230\\2379\\250\\166Z\\159\\179\\218\\232\\136{\\027s\\155\\172u\\219R3\\157\\142M\\238\\250\\190o8\\001\\232\\017\\152\\1737?\\255\\211\\156\\229\\158\\154\\137l\\220\\007DE\\\"\\194_=\\020yJ\\210\\173\\235j44$\\001$P\\132\\011V\\2425^o\\198\\165\\208\\203-;\\023\\1607=K\\248\\025\\180\\026c\\028\\182-\\128q\\t\\020\\001\\179\\1366`=\\179Wo\\247\\018\\141E\\144h\\150\\195\\173V\\251\\025 \\001\\001\\173\\011\\219y\\178\\241oM\\020'\\224\\218\\254p\\192c\\016\\250F\\006\\185>\\180B\\130S\\143\\131\\218(\\241?\\001\\149\\209b,\\192\\167\\242\\219\\138\\153\\216\\021e4\\213r\\007\\170\\243\\187\\198\\165\\166\\161\\163\\021\\205\\146Bh\\130\\031\\001R\\210\\183\\129\\190\\0280\\012\\029\\203@ _`$\\007Z\\153\\011>\\214@h^\\164\\134/e\\233F\\233\\026\\0016\\137\\142\\0005\\254\\190\\022\\238\\149\\216\\1441\\223Z\\016\\213a\\217\\152\\174\\208f/]x\\187\\012\\023\\203\\216\\012\\001q#\\154.\\129wF\\242\\151\\015\\170\\222\\241\\174CQ\\\\\\138\\223\\252 \\177o\\025F\\183\\194\\231@\\178\\1902\\001!\\018\\186\\127\\215IgAV;\\148\\136xa*_\\234\\017\\254\\225\\127H\\187\\176\\011\\174\\207{\\223x\\228#\\001\\238\\220$)\\001\\238\\171\\172\\203\\182]%q\\255\\194h\\255\\245\\187f\\247T%\\165\\167\\183Y\\255\\226\\179(\\015\\001{\\r<\\248\\148\\003s\\150\\2073\\2122\\198\\017\\255\\2116\\249\\134ZJ\\143\\210\\031M\\184\\211Gn`h;\\001]\\2030\\190\\252\\242\\243\\217\\150.N.L\\162\\n\\214Lzr\\1990p\\148r\\026GQw\\159\\202\\\"#\\001\\196n\\176;\\144j\\254\\004=\\\"P\\198\\231\\028\\248Pwv\\193\\188\\\"F\\\"y\\128\\252Bw\\004\\254*\\005\\001\\n\\204+o\\253\\166\\002\\250\\226\\0075\\235\\224\\134\\198\\144\\255\\248\\139[\\011\\240\\221\\237\\177\\159\\003:\\190m\\240&\\0017\\140\\201R\\023\\239\\223\\136H\\228l\\219\\2397\\236L\\160\\239#\\169\\185$\\158\\226H\\029\\185\\025S\\144\\130\\011\\001\\225\\\\\\224\\1936\\218c\\206_9\\161\\134-\\155\\005\\004\\184~\\198\\179\\004\\224\\136\\007\\153}\\134K*\\229\\231\\003\\001\\rV!7\\211\\241qk\\016[2\\227\\140\\b\\027\\207\\250 x\\190\\162\\136\\141'o5IJE\\029\\1530\\001\\187\\193\\218H\\155\\205ze\\027\\162Q\\026^\\177\\187\\132\\197@\\014w\\130+UZ\\238\\223\\240Z\\172Z\\153\\024\\001W\\205\\189J{iYG\\001\\127\\241\\0124\\209\\239\\t\\228\\t\\178\\213k\\230\\199\\\\\\188\\194t\\172\\031(\\019\\011\\001\\230|F\\210\\155\\188\\243\\244\\152s\\002p?c\\1406\\012\\000c\\152\\140L\\252\\242\\250-\\004\\235\\249\\201a\\002\\0016Q\\227\\152o^$\\133s\\209W\\185\\141\\132\\028\\217]\\t\\190\\204\\228\\006J\\bQ+\\255i8\\129_\\017\\001\\145\\023\\209\\237E\\027\\137\\203\\187Cu1\\210@\\192\\181Fj\\214Q\\031\\205\\025\\190\\000\\026\\188\\244a\\180~\\011\\001l\\195g\\015\\236\\199\\203@\\rF\\236\\199\\143? \\007\\160\\206\\162^:\\204v0i\\222|1K\\247\\191,\\001\\165c\\201\\149\\241\\255\\143\\199\\234\\160\\027\\019\\178\\193m\\244\\2136B\\161\\155\\168o\\007\\206\\225\\237\\239\\2512-\\030\\001\\139\\159r\\164\\172\\2037\\225A\\027\\148*\\\\y\\190\\247\\191\\021\\182t\\164\\178\\186\\174\\161\\173#5'x\\021\\022\\001y=Q\\211\\206\\254\\164\\247C\\200n\\150,\\n\\195\\023\\235~\\002\\193\\146\\b\\020h\\t\\150}(\\004\\144^;\\001\\249\\166\\162\\185\\201\\nF\\183C\\144\\1632\\024\\2457\\205aW\\238m\\026l\\187\\155yrn9r\\159\\1879\\001\\000\\012Fi\\180\\220\\175\\1870\\186TB\\150,\\0145(\\024\\179\\151\\021j\\165\\156\\000~\\031*\\249\\137\\1858\\001@_\\183\\017\\234\\233\\252\\167\\136u\\219\\141\\182a\\137\\197mBo\\234\\006\\143(&\\254\\\\\\176\\176\\175\\224j\\014\\000\\001\\014P\\025\\239Y[yo\\135.\\218\\232t\\223>k\\209\\233D$\\174\\215\\186Mz\\197\\254Z\\226%$\\021\\001\\206\\206\\146J\\241(\\155\\\"o\\187l\\190\\248\\t\\185D\\\"\\169\\217\\031\\007\\130\\173\\160\\216~\\252\\131\\208\\025\\185\\027\\001JN\\233\\216\\206\\243~pMW\\131n+\\212,idf\\226q\\151\\225f\\229\\164\\172\\135\\175o\\023\\169$\\001\\222~W\\237\\0025\\237\\019\\021\\238|vX/\\232^\\2414\\016W\\026u7\\188\\215\\1899\\025\\242f\\236\\030\\001~\\168\\192\\251%~Q\\024\\229H\\217\\199\\213\\159XX\\202\\021;\\159xPb1=%\\014$\\226\\003)\\020\\001\\157S\\200[\\219\\200\\185\\248\\149\\253<\\242\\133@\\154\\222$\\208w\\198\\177\\251\\136K\\232\\237\\003\\166\\t z\\021\\001\\153\\132\\222Z\\211\\t\\028R?\\144\\219g\\146Rk6\\179\\208\\147k\\218\\138\\168\\170\\130\\017'H\\225\\170\\251-\\001\\210=DU\\\\V\\147$\\006}\\130\\129v2\\164\\180\\139\\227\\020&q\\001\\160\\152s\\025ru\\208(O\\005\\001\\141\\030\\248\\226J\\2075\\230\\143@D\\1282CR\\233!d[\\195T\\176VD\\231\\189N\\179\\168\\014\\157\\019\\001\\173\\177\\175\\207\\175\\254uiekT\\213\\2069\\247\\193\\026U\\149\\143c\\2442\\239\\186\\154\\169c4\\227\\240\\019\\001\\r\\025\\237\\186\\203\\156\\240+\\191\\\\\\028\\016S\\212\\\"G\\149&\\133P8\\192rw*\\n\\151\\015:T\\213%\\001\\137\\172pR\\195oP\\168\\155\\205\\006\\011\\166\\127\\169Dm\\254\\176\\182\\216\\nt\\239a}\\212\\175f\\204 9\\001\\172]\\016U\\230\\220\\133\\230\\150\\205\\226\\228\\205X\\228\\017uVb-\\230\\022\\192K4'\\235\\207Ny!9\\001\\162\\224T\\198[\\145K.\\204\\163\\169\\186\\1635\\160\\214\\165\\001\\156\\251\\177\\156\\224s\\234\\213.\\031\\015\\150?0\\000\\001\\222d\\191\\243\\0223\\131\\175\\\"hwM)\\249s\\130ei%\\163\\132n\\b\\209\\185\\219\\253\\129\\007\\tP\\b\\001\\026y\\201 g\\175:\\147\\227\\142;z\\181Q\\2370\\203%\\152\\190=S\\026\\252\\179\\022\\031\\244dRy\\012\\001\\195\\024\\029\\135\\208\\171J\\153\\206\\200\\133\\179\\212\\222Q\\176\\188\\163+0n\\190\\206\\141\\202\\026\\135+\\192\\239\\196\\029\\001(\\136\\194qd\\185\\0114\\026\\151\\168\\130\\197EOXh\\168\\214\\135\\150\\179\\241\\142\\245B\\128\\238?\\150(:\\001\\207\\230\\245\\252\\199R9=\\203\\252\\148\\018V\\194\\186\\132\\153\\211\\\"(\\174\\026\\221\\018\\r\\015\\190\\204\\2178\\1463\\001\\023\\230\\252\\218\\000c!\\210oh\\226\\150\\139\\bHv6\\007\\2482\\249\\173\\176\\186\\167\\026\\021\\185/y\\136%\\001\\255\\219N\\144\\157w)eu\\239\\022-\\1831X\\022\\147\\168\\174\\026&(\\233\\215\\177\\020\\246\\230H20\\n\\001@\\018\\138\\2202<\\236\\210K_M\\239\\2484\\190\\150\\012\\144\\165\\201}\\022\\206m\\018>\\222\\140\\149\\178\\191<\\001\\146\\245\\252\\220\\012L\\211\\246\\222ByH\\176x1.\\0117D\\182I2\\181Z\\246\\020\\028\\232\\254n\\216,\\001L\\177\\225\\188\\236\\132?\\171~7x\\015D\\136\\rX\\235\\250<(\\180\\192\\201\\019\\174AIZ[\\207[\\025\\001\\192\\200M\\254\\161S\\006\\187\\150'\\021\\185!\\192\\017\\127\\222\\159?\\157\\255\\169sO\\202\\151|\\174\\134T\\1447\\001\\173l\\242Y\\255\\234\\209\\141:\\2538/A\\014w\\026=]\\015&\\020T\\250i\\150\\147\\216\\028E\\204\\128<\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\223\\020\\139\\015&\\240\\031\\139Vn\\220\\030Ql\\169!J\\017\\026\\218\\152\\250\\212J\\199\\014.\\164I\\tW;\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\000\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\000_\\237f\\144(\\136\\155\\028\\146\\165\\241Ac3\\249pC\\228\\027rG\\148\\190z\\212\\148\\177\\t\\235F0\\b\\164\\027o\\160\\129\\149\\020\\157\\254pe\\136\\211o\\168M\\025v\\137\\174\\247\\138\\192t\\153tvYg\\134\\129\\003iyJ\\160\\136\\n=\\235\\242\\019\\1967\\\"\\206\\160\\246J\\151hZz\\179\\147\\218\\244\\137\\146\\240\\0222\\172\\021vgd%\\232v7\\005\\196\\167,N\\160\\197\\169\\028\\029\\238\\1686d\\015Fr.r\\\"O\\232\\249D2LE\\131\\222\\171Jw\\025\\234R;OV&_Y\\027\\245D\\223c\\203H\\018\\162\\213\\236\\031\\025\\127\\028\\020\\169\\n:(\\131\\225u\\236\\213\\219\\164\\213(I\\002\\181k\\170\\162\\209\\029\\238fw\\004u\\015\\144_ V \\188\\131\\199\\226s\\196\\017[F_\\160,\\205\\011\\011\\155\\158vH\\221\\133\\229\\215\\200\\158\\146\\243\\005\\176\\162\\001/\\158\\001J\\154S\\148\\r\\\"1v\\231\\\\+\\n\\015|fS~\\175mR\\192\\192\\244\\r]\\143\\198n\\2295\\212K\\\"96N\\007\\137A\\250\\184G\\182\\140\\028m\\175L\\211<\\239'\\239\\160\\133@R\\225\\018j\\135\\014\\003\\2516\\164nx\\133T\\152_\\019\\240h\\199J\\226J7\\232N\\156\\006l\\215!\\0005\\170\\2109\\225\\150\\006\\031\\030\\235\\243AH\\194e\\132\\002\\019=P\\007\\0167f\\138\\2182\\186q\\2514*\\224\\001\\151\\255\\249A':\\190\\159\\180\\187EGm\\192\\235\\162\\229\\206\\030\\253\\219\\153\\208\\002`\\213b\\190\\185\\172\\154\\030~\\221\\139\\182\\127\\171\\248H\\210\\007\\152\\221\\196K\\243\\179\\227C4\\203\\128`\\250\\2107\\172\\171\\193R\\1330\\209\\194\\129\\219\\026\\029p\\031R\\152o\\238\\174\\154G6eE\\184\\011\\217<%\\1734\\193\\021\\150\\011i\\237Oe\\142^\\202Y\\180\\148w\\170\\249\\127c\\023[\\247\\235\\130d\\0249\\166\\214d&#\\175{\\153bo\\168\\223j\\138\\137\\177\\138?-\\014\\192S#\\245\\179\\127i\\227z`\\\"+9m*\\133\\tp\\196\\183e\\154\\249\\207\\005\\r\\212\\0209:Z%\\017V\\t\\236U\\151x\\129|\\191\\230\\006_\\141EI\\003p\\175\\158\\156e\\217.\\253\\147\\150\\215\\177\\022$+9\\181\\209p@\\006#\\015\\166\\227\\253\\028\\022>\\217\\242\\246\\209\\247\\019?\\141^M\\238\\249H\\027j\\153\\220\\151\\167\\020\\228z(?DJ\\172\\233\\224'\\21178\\018\\214T\\228\\253\\246#:d\\182J\\223\\211\\173F'\\205\\230\\165\\214\\215\\027\\137\\131\\246?fL)L\\197K1\\232\\197\\149\\207\\216\\155d|\\207\\011\\249T#\\182\\021\\005\\201\\161$\\249\\165\\001\\183\\248R\\000\\0052\\204\\tj\\025\\213\\227h)\\174\\\\wo\\2448\\019Kk\\169}\\012\\133\\235\\022\\154\\005\\219t \\214\\028=\\026\\134{\\254\\132g _0?$\\185L\\151\\020;\\182\\b\\143#\\026\\137\\203q\\146\\195\\206\\185hGQ\\127\\r\\139\\204K\\131\\145\\017\\027\\143\\214'P\\244\\219/\\005\\004\\154-\\001\\145tg\\242\\200\\\"\\026\\217\\244\\225\\184\\177\\000|O\\246;\\006zDmw\\158\\031\\185\\206\\0056z\\230\\244\\028\\255\\230\\253\\137g\\019\\011\\161gH\\199<\\003i\\252sOj\\175\\243.\\224 +\\146ng\\209\\003\\202\\136\\208\\2323\\190\\006x\\244\\247R\\145\\166\\152\\2392\\226/\\204\\011\\231\\224\\244v\\205\\238\\\"\\196\\tV\\231 \\188\\186\\143{\\149i\\147B\\185\\t\\135\\198\\207\\220q0!\\234&b\\250\\019~R\\027\\016\\231\\rG\\128Y\\024\\2476\\190\\159\\161\\234P\\192i)^\\128\\145S\\211\\0145_\\n\\nGB\\237\\1294Q\\166\\249wh\\132\\r\\145zV\\249\\182g\\023\\004\\0258\\207\\217S\\n\\2127en\\021\\006\\236!Qz\\128\\137\\2258\\218~\\209M\\180^\\216\\161\\177\\232\\240\\241\\163\\174E\\175*\\174\\201*\\000\\132\\150|2pt\\003\\168hs\\237\\2032S\\218\\rB\\245\\178I\\018\\025\\230\\152\\189\\191Y\\147\\205:\\028:%S\\150\\252l\\194\\022)\\206\\246\\163\\141\\156\\152nP1k\\180.\\031(\\163\\225\\175\\135\\031ui\\250\\203\\rF\\207\\235u\\213?\\170\\219\\220`UL\\153\\188\\221j\\133%\\242\\166\\244\\231\\176\\168#\\237@\\221P\\252\\r\\000i\\n\\152\\217K!p\\237\\251?V\\155\\214\\222\\239\\169\\204\\161;\\t=\\149\\155\\019n\\224\\029/\\152k\\r$n\\142\\134\\243\\219QJ=\\253\\172\\247u\\006h\\011\\2340\\208\\232E\\195\\192\\214W\\250Ld\\201Z\\027%(\\018\\246\\168\\135\\249\\155\\197\\0213\\230Q\\152\\016\\199\\157\\215\\254|\\216\\015\\141\\140\\180\\131\\164\\246Rdg\\202s\\030;\\215wf\\000\\135\\168\\214\\165\\168?d\\000\\006\\188\\167\\1936\\223\\2045\\147\\b\\235\\196D\\254\\000\\230\\130k\\024s\\023k\\187\\196\\195Z@\\203\\002\\248\\217r\\024\\202\\205\\152\\242c\\221X\\181\\174\\143\\193\\184\\021\\242\\201\\197\\221)?\\199\\162\\232\\019p`P5\\249`\\203\\136T\\251\\1315\\025\\134\\204\\1363\\253\\223z\\255:\\252\\176\\021SI\\175P\\145\\227\\205\\024\\192\\146\\237\\149{\\227q\\215\\155\\202>\\0263\\191\\015\\131\\136\\172\\024\\145%\\148A\\004\\231\\\"\\191\\0118O\\193H;\\165\\r\\137F\\004\\220UF\\2284\\196\\202\\182\\000\\028\\194\\188Y\\250\\199\\152Z*zJ\\132\\167V_\\021\\242\\181\\202L\\r\\205\\241\\159\\153\\147q\\t\\185k!\\231\\165A\\209B\\001$\\022Q6\\232\\t?V\\196\\142T\\000\\254\\213\\194\\168j\\232\\2193\\133c\\245\\167\\2341\\166k-\\b3\\226\\183:\\214\\012\\166ac>\\212\\151\\030\\195\\165\\0018\\219\\182|}HB\\191\\254\\239\\177\\003\\229\\141\\147@\\026\\247\\004\\244\\204\\029\\246\\129>q\\241!\\251\\170f\\029\\203\\128\\148^\\241\\024>\\195\\207\\016\\183\\1987\\024JP;\\026\\174\\145\\b\\011R\\190\\155\\240\\240\\187\\017\\145\\157Pm\\240;\\184\\159\\246\\181:\\146\\214\\248\\015\\001\\150\\029\\197@%\\\\\\152T ~X\\178O\\210)\\239\\177n\\018\\005\\166K\\\\\\187\\152ef\\175\\132\\026\\236jM\\141\\165B\\000]9v\\021\\151\\154\\248&\\011\\204\\233'\\149\\244\\0188\\2074\\215{C`\\225\\228\\020\\209\\199\\147}\\172ky\\231M\\2299\\243r\\141\\022\\128\\225\\th\\027Ko\\128\\017\\254\\166\\167X\\248\\233'\\220.\\022\\236\\243\\196\\025\\190o\\149v\\022xd\\2555\\157j {r?\\024\\127w\\134\\021\\210\\240s+7\\175\\022\\153w\\148\\207\\131Id\\216y9'\\166u><\\022\\185\\137!\\213=\\024T\\002\\232t\\243\\024\\168\\025\\253\\242\\243\\172fg& E\\170\\138&fN|\\166\\254\\147\\241Q\\240iP\\139\\130j\\213\\208lqT\\147\\024\\203\\201\\017\\218kt\\208n\\254(\\006\\000.S`[\\128\\026\\215\\254\\167E\\233vj\\221\\141\\169\\2373X\\157u\\143\\1799\\254\\212\\0122\\156Y\\170'\\183z\\135\\136\\176\\127|\\209\\201\\198\\022\\024u\\\\\\202=\\r0:{\\ta$\\206\\012\\002\\220_E\\026\\015\\003.\\030hs\\029\\000\\184G \\003\\136#w~\\198R-\\154\\030\\1586Y \\195\\231\\206\\006J\\222\\012.\\030\\217mb\\229J\\nI\\211\\164L\\145\\158\\180\\176\\1373=d\\1626\\237\\205\\161\\146\\018t\\172i\\003\\186\\2177\\204\\227\\167\\141\\250$-\\140S\\232\\148g\\204\\152m\\2533-\\185\\135\\215lf\\231sZG\\2394\\233\\015(\\195}i,\\132s\\170\\154$k\\184^\\\\C#\\205\\012Zi\\228\\185\\206\\026\\225`\\249aD|1\\174.\\216-8qxB\\189\\227\\023\\021~\\223\\024j[*Z\\194\\1605\\160i\\177\\138\\027\\183\\144\\216\\161\\182\\014&i\\148\\226p\\242\\132\\165W\\196\\024\\175\\235\\250\\172\\162yL\\138\\246\\164v\\203\\027\\148x\\194\\005\\232\\169\\001\\023\\015qq\\021\\229\\151\\019\\200O\\136\\186\\190.\\192)%\\024\\006\\r,\\200+T\\233\\169\\201\\162\\210\\168|\\233\\030\\021]\\217<\\155,?\\206\\227\\015\\163I`\\242G/\\205\\004\\217\\222\\132\\134\\2465\\201\\185mwo\\1741\\\"\\031\\168O\\148\\160\\214\\214K\\224\\185pI\\185*\\226\\197\\138\\140\\185>y!y\\250\\181\\127\\163,F\\149\\171\\231$,|j\\165\\018;A\\170\\142\\172\\232Z~\\238\\184\\235\\178\\\"\\025\\2015;\\146vq\\017\\153\\170\\168\\001\\130\\023\\022\\235\\162\\235\\218\\159\\234\\196B\\226\\158\\249)?\\\\Ev\\147=S\\026n<\\007Q\\1425\\\"A\\005_=\\220\\245\\178\\225$S\\1846\\156B\\014v\\173\\160\\251ln\\023?\\\"q\\170\\025\\236m\\184\\001\\001\\018a\\022\\005\\00056-\\152o \\197\\152\\229<=\\224\\184\\252A0\\004\\132$1r\\175\\137<\\201\\156\\161\\153\\170\\022\\022<\\240\\149\\030j8_\\180\\234\\139^,\\240\\232\\158T\\128z\\153\\147\\139\\n\\182\\156w\\241\\185\\178\\016\\160]\\021.7\\190\\250\\157\\128\\198(\\251\\139?\\127S\\022\\145,\\023T&\\160\\173\\154\\131\\219x\\bG\\2146\\241\\204\\171\\t\\224\\r6\\204+`v\\1941\\132\\004l\\n*\\006 \\133!VD\\254)T\\154bR\\002PU\\189\\251\\028k\\223#\\014\\192z\\145S\\025\\198\\006\\173\\147\\012A\\221\\127\\tr\\\"\\173\\162wjHNu_\\235-I\\028\\238\\128+\\234\\244\\221\\186\\243\\182\\150\\152h\\157~v\\182p\\202\\166]\\219\\217!\\151\\\"z\\176\\200\\223\\1866$\\181\\201\\141:\\136\\030\\170\\213`\\r\\137\\146\\r\\255\\131\\002Py\\210{\\222<\\234\\221\\020B[\\252\\138@\\211\\016\\192D\\022(\\001%\\025\\215o\\239\\001\\007CM\\197k\\177t\\231\\209a\\012\\222/\\200mj\\167+u\\173\\026\\205q\\200\\175\\225\\167\\025\\242\\229\\232?\\206yA\\251\\1541>+\\146bH\\n\\250hg]\\207\\171d\\178\\n\\229\\128\\t=$\\004\\006\\246hK1<\\228\\006i\\189[\\161\\200\\223>\\213<\\237/G<\\003z\\241\\154\\b\\154\\204\\148\\217\\195\\231\\189\\223f\\163#\\216+\\245E\\025\\187\\143/[\\221H\\254\\206\\180Z\\139\\222\\n\\167\\1609\\150\\161\\006B\\017\\181+\\195M&Xxu\\007$\\232\\213R\\174\\156\\232\\250\\229I,}\\020\\169\\230nu\\023\\206*\\018\\131\\\"j\\156\\211\\011\\147\\130\\151\\180{\\233\\154\\000\\252\\192\\190k\\t\\167?\\024'\\252\\012b\\130\\240o\\142W\\253\\000\\252\\213\\243:\\146\\006x\\177\\001\\252\\012\\169\\223\\006\\143(kw\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\252\\185*\\167V\\180ps\\173\\252\\252\\158\\241\\213#\\249O6\\000\\252\\000|/\\142b\\028\\135Y\\252\\135\\204&\\162s\\246\\199\\156\\000\\252\\175\\242\\182\\158\\029\\130T#\\252~\\245}\\246\\209k\\185\\213\\000\\252\\246\\134\\144\\160\\208\\247{\\020\\252h*$@\\206b^b\\000\\252\\014\\173V2c\\027\\198\\175\\252\\251\\225\\031\\161\\016r\\128\\t\\000\\252\\145A\\172\\202\\190\\030X\\249\\252\\166\\201\\183>\\153\\213\\030W\\000\\252\\189\\195d\\205\\163PN\\170\\252h\\197\\254\\193\\n\\231\\020\\216\\000\\252m\\222^\\130\\223\\172\\029\\178\\252\\165\\007\\219\\197\\023\\162\\b\\254\\000\\252\\127\\170\\230\\233\\214\\015N\\130\\252,\\127\\185N\\152:\\246\\252\\000\\252\\202\\004\\027q+\\1361\\195\\252)&\\174\\182\\199\\1729\\145\\000\\252\\239Q\\129\\253G\\143\\015\\220\\252\\135\\149;\\196Cz\\169\\000\\000\\252\\1912\\134\\209\\030\\2168`\\252\\171\\005\\170\\162p\\188\\179\\249\\000\\252ZG\\175\\229\\224\\210u\\148\\252\\246\\210\\195\\174\\002\\167\\203\\209\\000\\252\\004|-\\249\\246\\015x\\190\\252T\\226\\2512\\145X=\\225\\000\\252\\019u1\\184\\018\\183p\\198\\252\\b>H\\1543\\204u\\022\\000\\252\\209\\184\\202\\177\\162\\176\\193H\\252\\206\\177q\\192\\227\\004f\\027\\000\\000\\000\\014\\000\\000\\000\\000\\000b\\153TI\\021\\240\\155\\231\\193y\\017D-%H@S\\180Y\\005\\219\\159AV0a\\253}\\1882\\211\\015\\172\\215R\\133\\247\\193\\162O\\199\\177\\230\\226|<\\022:U\\166\\177\\23169\\003\\029\\004\\235\\165^P\\004\\005\\022\\252o\\191\\230\\172\\201\\179\\1303\\252c\\024v\\249XC\\151y\\000\\252\\151\\135\\136\\233\\006+:\\221\\252\\199\\161D)@\\230z\\221\\000\\252\\203\\159\\156\\2440\\229\\232\\198\\252\\221\\156\\160\\205e\\187\\221\\007\\000\\252\\019\\026i\\135\\162Y,S\\252{oe*\\176\\188!\\169\\000\\252\\139\\007\\016\\143\\177w\\156\\226\\252\\238\\012k\\223\\000_\\\\\\248\\000\\252\\135\\156\\176\\007-\\167\\189\\029\\252\\160&_\\233\\226\\151\\027M\\000\\252\\017_\\128V|tu\\156\\252\\232\\241\\206\\250ic\\254\\161\\000\\252M`\\233\\219\\223\\138+\\\\\\252\\155\\247\\016\\242\\140q\\140Z\\000\\252Hk\\224Q\\\\\\179\\192\\\"\\252\\237m\\169@s\\139\\136\\166\\000\\252ndv^\\181\\215\\007\\144\\252\\018\\142N\\2199\\139\\198\\193\\000\\252\\201+?7^\\227ED\\252\\229\\205\\140\\252\\021\\199@\\157\\000\\252N\\170\\188K\\132\\130\\152B\\252\\188\\183\\175\\208\\215'\\169\\151\\000\\252wn\\253\\255[=\\202\\153\\252\\148B\\\\\\021Uj\\230\\239\\000\\252T\\153\\151!q\\178}K\\252@\\200\\147a\\224\\162\\031\\149\\000\\252\\179G\\007\\178\\190\\204\\209,\\252\\029\\002d\\242<\\222\\209[\\000\\000\\252o\\191\\230\\172\\201\\179\\1303\\252c\\024v\\249XC\\151y\\000\\252\\151\\135\\136\\233\\006+:\\221\\252\\199\\161D)@\\230z\\221\\000\\252\\203\\159\\156\\2440\\229\\232\\198\\252\\221\\156\\160\\205e\\187\\221\\007\\000\\252\\019\\026i\\135\\162Y,S\\252{oe*\\176\\188!\\169\\000\\252\\139\\007\\016\\143\\177w\\156\\226\\252\\238\\012k\\223\\000_\\\\\\248\\000\\252\\135\\156\\176\\007-\\167\\189\\029\\252\\160&_\\233\\226\\151\\027M\\000\\252\\017_\\128V|tu\\156\\252\\232\\241\\206\\250ic\\254\\161\\000\\252M`\\233\\219\\223\\138+\\\\\\252\\155\\247\\016\\242\\140q\\140Z\\000\\252Hk\\224Q\\\\\\179\\192\\\"\\252\\237m\\169@s\\139\\136\\166\\000\\252ndv^\\181\\215\\007\\144\\252\\018\\142N\\2199\\139\\198\\193\\000\\252\\201+?7^\\227ED\\252\\229\\205\\140\\252\\021\\199@\\157\\000\\252N\\170\\188K\\132\\130\\152B\\252\\188\\183\\175\\208\\215'\\169\\151\\000\\252wn\\253\\255[=\\202\\153\\252\\148B\\\\\\021Uj\\230\\239\\000\\252T\\153\\151!q\\178}K\\252@\\200\\147a\\224\\162\\031\\149\\000\\252\\179G\\007\\178\\190\\204\\209,\\252\\029\\002d\\242<\\222\\209[\\000\\000\\000\\000\\000\\000\\001+\\178z\\189\\247\\143\\2441kS\\153\\134\\228\\129.A\\145\\194\\241\\n\\242\\157v\\230\\254R~\\231=!\\028yl\\212\\198\\242\\150\\168\\251\\127\\131#\\239X\\007\\\\zs\\0160C\\178B\\029\\208)\\143\\162\\135]A\\t\\007\\001\\232\\236M\\246\\175l\\000\\155x\\165[\\244t(\\230\\019h\\002\\022w\\232\\189?\\205\\030\\231\\189\\135\\244\\194\\179\\007\\001\\171\\127\\188\\169\\169\\025\\150?7\\222\\003\\216\\141\\161&\\160\\205\\230\\147\\214\\003l\\004\\147xZa\\210\\217|+\\021\\001\\230\\134'\\178\\191Y\\0017\\206(\\161\\160\\185\\131m^\\1274U]Pz\\190\\235B\\022n\\209w\\0182\\019\\001\\202\\255\\136td\\134E\\219\\019a\\176lK\\1963\\255\\243\\153\\1332\\245?\\220\\222\\1769\\1510\\217\\028!.\\001\\031\\250V\\151\\255/)\\b\\214\\187\\140\\195\\139\\006%\\214\\255-\\223\\b\\131M]\\252#S(\\015\\137\\000\\254\\007\\001|\\226\\192\\159]\\201g\\171\\027^\\014\\145\\242\\206Fp\\177\\135\\157a\\020tfM\\012(\\207?\\232\\173\\158$\\001\\239|%z\\143U\\142i\\012\\022\\230U3jT\\150\\205I)-C\\253]Q\\198\\138\\n\\001\\199\\1712\\\"\\001\\245*\\234Y\\196\\237\\148z\\127B\\016\\135\\176\\031\\184\\175\\225\\031`\\135`\\025\\019\\146\\185\\156= Hr'$\\001\\252\\245\\213\\132?Tn\\194\\025\\248\\233LIj\\175\\225\\003\\212x\\148\\181.V\\003\\248\\145\\161W\\184s\\203/\\001\\216\\161\\018p\\254B\\018\\129\\245Ap4\\191\\1863\\149\\251 /\\1654t\\012\\r,I\\175_l\\246\\133&\\001\\168\\215\\239\\213}\\244\\207\\213\\138\\198B=\\189\\144k\\003\\022KRT\\219\\151\\215\\228\\138\\006\\244\\235z\\b\\217#\\0016\\002\\\"\\186\\135\\255W&\\208\\185h\\235|_d\\173\\181\\215\\1512{-\\221Mr\\219\\b6J>\\028\\006\\001\\027\\014\\230\\015\\235\\209Y\\014\\025D\\176\\168\\001\\176\\143\\231&\\204\\2397\\163R\\031\\161`\\005%tp\\015\\003,\\0016/\\136m\\132\\216\\205\\022\\183\\146q;\\002\\bR@\\162\\132d\\000\\254\\167Dt\\252W\\155\\193\\144\\246\\179#\\001\\127nv'\\218\\003\\201\\206\\241\\176\\232F\\219\\146u\\192J\\028\\018\\148=\\180\\247\\\\\\128w\\197n\\151\\rI\\003\\001q\\152\\173\\221\\1574D\\148\\r\\175\\007=\\130g\\185\\226\\153\\180\\243\\181\\1843\\011d\\154\\132\\197\\222\\014\\189&\\014\\001I\\205\\143\\176\\142\\148\\234\\158\\149\\225\\165\\250H\\156\\023\\011\\240\\b\\197\\146\\144!\\224\\248\\185\\173;\\2229j\\254\\031\\001\\170\\\\[\\166\\023HT;Z!\\227\\233?\\158k|x\\252:\\219\\211\\194\\2485]\\135k-\\176\\020\\220*\\001\\208\\018Gy\\165\\174\\157&\\2271H\\t\\003%XFE\\159\\194\\025\\179\\015{S\\178\\246\\146\\235jMa,\\001\\217\\201\\179H\\176\\229~y\\178\\246Zy\\020vn\\238\\254\\154\\165|<\\b\\177{\\176\\\"z\\243!\\131|$\\001h\\215\\b\\021\\197\\241k\\191|\\191\\205\\176\\0024\\255J*\\157H#ss\\184\\211\\243\\127v\\248\\154\\011 \\n\\001\\240\\157?\\185\\133\\198\\149\\159L\\156$Bb\\176z\\140<\\161\\248#\\239\\238\\144\\134\\007Z-\\1301*\\172-\\001cK\\156\\138\\169\\182\\188\\131E\\130\\026\\232s~O\\202\\132{\\204\\2303\\025\\154\\162\\129\\029\\170Z\\245f\\0069\\001\\031\\001*yV\\176\\143\\242\\166]k\\250\\203\\r\\158\\131x\\007]\\134\\196\\177\\235\\127 %\\012\\206\\254a\\242\\17061\\000\\001\\219\\185N\\182+\\183\\223\\190U\\151'#\\173+D\\234i\\183Kx\\029\\132f\\030\\219\\015\\130a\\196\\210b\\007\\001\\b\\233\\155\\220\\240\\133\\201(\\245\\025[\\185\\214x\\156\\206&ls\\248\\241s\\231~%\\140\\192\\145q%\\222?\\001\\216\\162\\189\\210\\028\\162\\025\\221|\\r\\161q\\240\\127\\205l\\196\\031a\\253w\\239v\\176\\136:\\025.\\150i\\137\\004\\001\\1931\\003\\169g8)\\185\\199\\234\\255R\\221d\\215\\243\\149\\006te\\129@\\026\\025\\135\\166\\151]\\180\\178\\139\\012\\001,\\029\\146\\141\\252\\\"\\227\\005\\194\\205\\192F5\\226\\252\\228\\145\\148\\241\\246\\1766!\\187a\\181\\233\\240F\\248\\028\\\"\\001\\245\\169\\182\\166\\249\\031\\031}Cl[8\\148 \\153[\\154\\130\\128\\160\\171\\203\\131\\255\\195\\153\\211\\224\\232\\195\\181\\025\\001\\254\\167\\017\\239!=:D\\020\\175D '\\012\\021U\\180\\216,,\\249]A\\252C\\016\\183\\164\\203\\b\\128\\022\\001\\220k\\224\\182$\\178\\255\\169\\218\\181\\155}\\212\\143\\019L\\130\\192\\205\\225\\136\\162\\248\\199y\\174\\244\\162N\\207%\\n\\001&7bQ\\224\\155\\248m:\\238@\\194\\244\\250\\027\\232Hq?'\\13104\\2247JMY\\017o\\195\\028\\001\\026\\249A\\180a\\187\\007\\231,i\\131\\130\\200V\\252\\006\\235\\207\\223>\\158\\183\\200x\\194\\b\\148F\\1751R\\020\\001Cs\\203R\\152\\181\\132eim=\\181\\2134\\162j\\217\\024\\238\\162Ru}\\187.\\030\\139\\157\\132\\020'\\020\\001g\\233\\236\\138\\198v;\\145u\\235\\133\\212}\\170@\\247 \\018\\166=~\\248-\\138p\\230\\145i+oE\\022\\001\\016\\233\\238\\174\\016\\200s\\194\\141\\015\\020\\192\\158R\\215\\1310\\254w\\229\\002C\\198kM\\153'\\251\\247r\\143\\015\\001\\210\\146S\\003p\\017\\200\\198\\139iDT\\005%6~n\\142ea\\144\\188n\\165>fA\\b\\132\\184\\215=\\001l$ \\220\\001\\025\\tA!\\176so\\133X\\005\\141\\148;\\183\\138\\192\\251tF\\153\\139_x#6\\161\\142\\138)\\208PM\\154j\\223,;t+\\001\\183!\\131]\\179p\\131j\\220\\021\\197\\134\\023\\133u\\019\\028\\231\\166\\134\\255\\029\\184\\1716\\216\\127\\212\\156\\228\\2102\\001\\140e\\254\\2535\\031 \\029\\019\\131\\142\\192\\031\\208\\172\\1714\\204\\171\\132\\\"\\024\\144\\230\\001Ca-\\199\\160n\\020\\001+\\173q\\005e\\000\\011\\029aH\\159\\191(sj_T\\164\\250]\\215\\141&\\001\\248\\144\\162\\192\\153\\133G+\\001r\\025\\005\\193m\\005B7\\011A\\142\\162K\\017\\031\\000E\\200`~\\207r\\178\\240\\206]\\145\\026\\199\\021\\133<\\001\\024\\218F;3z\\187\\187\\224\\133\\b@\\238\\179\\140\\191{\\180\\183v\\021I*\\196\\238\\186F~\\207y\\011\\002\\001`T[\\018\\161@S\\129\\177\\225x\\222m\\177\\233#\\026\\253\\151\\011+v\\177\\209\\222\\018\\179\\b]\\027\\153=\\001bT\\171\\173\\207\\223\\172\\131\\219\\156\\211\\029\\183\\195\\2518`\\004\\200\\152\\005\\227\\253\\227\\236\\003\\250OEt\\225\\018\\001#\\007Q\\194\\241\\172\\027\\014\\2238\\210\\145~\\012Q\\207\\241\\189k\\188\\229b\\149\\170\\244*I\\154#\\141{9\\001\\250Q\\246\\242.P\\174\\210j\\230\\189\\190\\212-\\172a\\178;]aA\\132\\014B\\148\\249\\131\\020\\196?\\r\\b\\001nd\\197\\029\\213\\018E\\1845l\\234Q\\251[\\016t\\028Z\\144yw^\\r\\242\\166\\169\\028%\\185\\131+%\\001\\203\\189\\209J%\\231\\167\\007\\236\\158k\\164\\235\\230\\236\\246\\184\\\\q\\n^\\t\\172\\150\\221R\\024{\\175'\\224\\016\\001\\027\\237%-\\246\\160L\\141\\225\\202\\237\\173O\\173\\137`h:B\\022\\198\\208-w+y\\021m\\218\\020\\234>\\001\\190\\242\\182\\160\\247\\149\\187\\216\\020\\006\\131\\023n\\000%\\201e}W$\\224\\237Tmr\\204\\000c\\159g\\007\\020\\001]\\213\\212@\\213_0f\\236\\137\\175\\005\\242\\026\\228\\145\\201{\\189\\230\\025\\250\\152\\252rQ\\225\\234\\249\\b;\\025\\000\\001\\217a\\003\\155P\\239\\232\\176\\r\\019\\133\\185|\\000\\185\\200\\237\\012;H\\0051&vP\\221\\229q\\017\\172t\\017\\001k\\132?\\218K\\028\\019n\\155\\187\\245I=\\147\\145\\012`\\247\\160\\1684\\233\\237\\240\\003\\023Wr\\247\\182\\170\\019\\001\\148\\151\\018\\200-Zi\\1799\\191Q\\1314n\\198\\237\\163\\190\\207={D&\\248\\227\\bY5Ht\\130\\b\\001\\220L\\245o\\181\\179~O\\005\\253\\205\\021\\198Z\\175G\\002K\\127\\188\\246\\253\\204\\028Z\\2155\\203>V_\\007\\001~el\\158y\\174 \\207\\153\\143\\176#\\167\\018\\001\\224\\243\\151\\213[\\\"\\019DDF\\162\\150\\1355\\000\\003\\\"\\001\\183\\181\\192\\0140\\252\\1361\\194\\004\\t\\158\\154Fmt\\216\\251\\183\\236\\209\\235\\247\\183jD\\221\\203;\\163\\1892\\001*]\\217A\\168\\207\\b,\\160Tg\\158.\\169\\005\\150\\005(;\\nV\\239)\\027)\\003\\209?\\218\\141\\2303\\001\\027\\162z\\209\\210\\021\\209\\239\\144\\007/ !\\143\\154\\237\\189\\247\\197\\\"\\134\\130rGE\\001\\225\\182\\227T\\1462\\001\\223X\\1939\\179\\012vG\\128q.\\140\\209ib\\021\\2546\\134~\\1476\\157p\\187D\\226\\190\\128gB\\024\\001\\139\\225\\168\\152\\238n\\130\\177\\031\\223r\\232\\251\\017\\247&D\\t\\142\\140\\183\\015\\006\\176\\233\\227\\192\\246\\161Z\\253>\\001\\245\\244\\\"\\151\\227\\222\\253\\228\\235\\031\\224\\011_b]R\\029>g\\201\\014\\169d\\184\\129Ui\\182\\238o\\0215\\001\\244\\144h}D\\172:\\007\\254Y\\006%\\240b\\236NW\\003ZhX\\168\\164\\216\\130;\\029\\1417\\150\\2248\\0017\\243\\145\\130\\204\\246\\\\LX\\135\\020\\024\\194\\147{\\211\\159\\023z86\\241)\\167|\\193~rD~W\\004\\001\\023\\022\\153Cf\\029\\180\\023\\128\\158\\135\\130]\\214\\018Q\\156\\018ga~\\165\\147\\153\\217 \\001\\225\\234\\234\\181\\162&\\135DV\\210\\004\\244\\018T(c~\\203\\018\\180]\\206o\\031+\\181CpW\\167],\\0019\\024\\244\\030\\168\\138^\\213^\\176\\020\\242\\025\\214\\132\\143\\251\\235\\\"\\149F#z \\0231\\246\\216Wd,<\\001(\\129\\219\\244kx\\215l\\028\\131\\2286\\189\\160\\133\\012E\\168\\167\\023\\174~\\153(\\130\\170\\241\\207/\\137\\242\\019\\001\\133dZ[\\181jE\\195\\196Md\\221\\227\\172\\240\\020f\\028\\136+\\129\\147T\\\"\\201'u\\027!\\137\\2275\\001\\175\\156\\238U\\220\\131\\172\\011\\175\\169\\024\\166\\181\\1661\\005\\178)\\006N\\162\\\"\\142\\185\\194\\163\\130\\211\\215\\179\\253$\\001\\241\\134r\\239<\\134M\\249\\199U\\200ad\\\\&\\167\\020\\212\\187\\207\\030`l)r\\249\\023\\149\\224\\017\\203\\031\\001A\\222\\168$\\183\\168)M\\247\\228U'\\202\\220\\143\\185^O\\187\\230\\235\\230z\\194ko\\197\\146Kr\\179!\\001\\220-\\145\\200\\201\\141\\151\\243\\193\\172\\201%\\229bry\\238\\186\\158\\179\\224\\2557\\203\\031\\223\\015N4\\171\\1613\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\250_\\130\\146A-\\205\\129F\\016m\\136D\\248\\159\\231\\138\\242\\187Nc\\162\\193,\\239v>K\\202\\n\\192,\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\000\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\000_\\237f\\144(\\136\\155\\028\\146\\165\\241Ac3\\249pC\\228\\027rG\\148\\190z\\212\\148\\177\\t\\235F0\\b\\164\\027o\\160\\129\\149\\020\\157\\254pe\\136\\211o\\168M\\025v\\137\\174\\247\\138\\192t\\153tvYg\\134\\129\\003iyJ\\160\\136\\n=\\235\\242\\019\\1967\\\"\\206\\160\\246J\\151hZz\\179\\147\\218\\244\\137\\146\\240\\0222\\172\\021vgd%\\232v7\\005\\196\\167,N\\160\\197\\169\\028\\029\\238\\1686d\\015Fr.r\\\"O\\232\\249D2LE\\131\\222\\171Jw\\025\\234R;OV&_Y\\027\\245D\\223c\\203H\\018\\162\\213\\236\\031\\025\\127\\028\\020\\169\\n:(\\131\\225u\\236\\213\\219\\164\\213(I\\002\\181k\\170\\162\\209\\029\\238fw\\004u\\015\\144_ V \\188\\131\\199\\226s\\196\\017[F_\\160,\\205\\011\\011\\155\\158vH\\221\\133\\229\\215\\200\\158\\146\\243\\005\\176\\162\\001/\\158\\001J\\154S\\148\\r\\\"1v\\231\\\\+\\n\\015|fS~\\175mR\\192\\192\\244\\r]\\143\\198n\\2295\\212K\\\"96N\\007\\137A\\250\\184G\\182\\140\\028m\\175L\\211<\\239'\\239\\160\\133@R\\225\\018j\\135\\014\\003\\2516\\164nx\\133T\\152_\\019\\240h\\199J\\226J7\\232N\\156\\006l\\215!\\0005\\170\\2109\\225\\150\\006\\031\\030\\235\\243AH\\194e\\132\\002\\019=P\\007\\0167f\\138\\2182\\186q\\2514*\\224\\001\\151\\255\\249A':\\190\\159\\180\\187EGm\\192\\235\\162\\229\\206\\030\\253\\219\\153\\208\\002`\\213b\\190\\185\\172\\154\\030~\\221\\139\\182\\127\\171\\248H\\210\\007\\152\\221\\196K\\243\\179\\227C4\\203\\128`\\250\\2107\\172\\171\\193R\\1330\\209\\194\\129\\219\\026\\029p\\031R\\152o\\238\\174\\154G6eE\\184\\011\\217<%\\1734\\193\\021\\150\\011i\\237Oe\\142^\\202Y\\180\\148w\\170\\249\\127c\\023[\\247\\235\\130d\\0249\\166\\214d&#\\175{\\153bo\\168\\223j\\138\\137\\177\\138?-\\014\\192S#\\245\\179\\127i\\227z`\\\"+9m*\\133\\tp\\196\\183e\\154\\249\\207\\005\\r\\212\\0209:Z%\\017V\\t\\236U\\151x\\129|\\191\\230\\006_\\141EI\\003p\\175\\158\\156e\\217.\\253\\147\\150\\215\\177\\022$+9\\181\\209p@\\006#\\015\\166\\227\\253\\028\\022>\\217\\242\\246\\209\\247\\019?\\141^M\\238\\249H\\027j\\153\\220\\151\\167\\020\\228z(?DJ\\172\\233\\224'\\21178\\018\\214T\\228\\253\\246#:d\\182J\\223\\211\\173F'\\205\\230\\165\\214\\215\\027\\137\\131\\246?fL)L\\197K1\\232\\197\\149\\207\\216\\155d|\\207\\011\\249T#\\182\\021\\005\\201\\161$\\249\\165\\001\\183\\248R\\000\\0052\\204\\tj\\025\\213\\227h)\\174\\\\wo\\2448\\019Kk\\169}\\012\\133\\235\\022\\154\\005\\219t \\214\\028=\\026\\134{\\254\\132g _0?$\\185L\\151\\020;\\182\\b\\143#\\026\\137\\203q\\146\\195\\206\\185hGQ\\127\\r\\139\\204K\\131\\145\\017\\027\\143\\214'P\\244\\219/\\005\\004\\154-\\001\\145tg\\242\\200\\\"\\026\\217\\244\\225\\184\\177\\000|O\\246;\\006zDmw\\158\\031\\185\\206\\0056z\\230\\244\\028\\255\\230\\253\\137g\\019\\011\\161gH\\199<\\003i\\252sOj\\175\\243.\\224 +\\146ng\\209\\003\\202\\136\\208\\2323\\190\\006x\\244\\247R\\145\\166\\152\\2392\\226/\\204\\011\\231\\224\\244v\\205\\238\\\"\\196\\tV\\231 \\188\\186\\143{\\149i\\147B\\185\\t\\135\\198\\207\\220q0!\\234&b\\250\\019~R\\027\\016\\231\\rG\\128Y\\024\\2476\\190\\159\\161\\234P\\192i)^\\128\\145S\\211\\0145_\\n\\nGB\\237\\1294Q\\166\\249wh\\132\\r\\145zV\\249\\182g\\023\\004\\0258\\207\\217S\\n\\2127en\\021\\006\\236!Qz\\128\\137\\2258\\218~\\209M\\180^\\216\\161\\177\\232\\240\\241\\163\\174E\\175*\\174\\201*\\000\\132\\150|2pt\\003\\168hs\\237\\2032S\\218\\rB\\245\\178I\\018\\025\\230\\152\\189\\191Y\\147\\205:\\028:%S\\150\\252l\\194\\022)\\206\\246\\163\\141\\156\\152nP1k\\180.\\031(\\163\\225\\175\\135\\031ui\\250\\203\\rF\\207\\235u\\213?\\170\\219\\220`UL\\153\\188\\221j\\133%\\242\\166\\244\\231\\176\\168#\\237@\\221P\\252\\r\\000i\\n\\152\\217K!p\\237\\251?V\\155\\214\\222\\239\\169\\204\\161;\\t=\\149\\155\\019n\\224\\029/\\152k\\r$n\\142\\134\\243\\219QJ=\\253\\172\\247u\\006h\\011\\2340\\208\\232E\\195\\192\\214W\\250Ld\\201Z\\027%(\\018\\246\\168\\135\\249\\155\\197\\0213\\230Q\\152\\016\\199\\157\\215\\254|\\216\\015\\141\\140\\180\\131\\164\\246Rdg\\202s\\030;\\215wf\\000\\135\\168\\214\\165\\168?d\\000\\006\\188\\167\\1936\\223\\2045\\147\\b\\235\\196D\\254\\000\\230\\130k\\024s\\023k\\187\\196\\195Z@\\203\\002\\248\\217r\\024\\202\\205\\152\\242c\\221X\\181\\174\\143\\193\\184\\021\\242\\201\\197\\221)?\\199\\162\\232\\019p`P5\\249`\\203\\136T\\251\\1315\\025\\134\\204\\1363\\253\\223z\\255:\\252\\176\\021SI\\175P\\145\\227\\205\\024\\192\\146\\237\\149{\\227q\\215\\155\\202>\\0263\\191\\015\\131\\136\\172\\024\\145%\\148A\\004\\231\\\"\\191\\0118O\\193H;\\165\\r\\137F\\004\\220UF\\2284\\196\\202\\182\\000\\028\\194\\188Y\\250\\199\\152Z*zJ\\132\\167V_\\021\\242\\181\\202L\\r\\205\\241\\159\\153\\147q\\t\\185k!\\231\\165A\\209B\\001$\\022Q6\\232\\t?V\\196\\142T\\000\\254\\213\\194\\168j\\232\\2193\\133c\\245\\167\\2341\\166k-\\b3\\226\\183:\\214\\012\\166ac>\\212\\151\\030\\195\\165\\0018\\219\\182|}HB\\191\\254\\239\\177\\003\\229\\141\\147@\\026\\247\\004\\244\\204\\029\\246\\129>q\\241!\\251\\170f\\029\\203\\128\\148^\\241\\024>\\195\\207\\016\\183\\1987\\024JP;\\026\\174\\145\\b\\011R\\190\\155\\240\\240\\187\\017\\145\\157Pm\\240;\\184\\159\\246\\181:\\146\\214\\248\\015\\001\\150\\029\\197@%\\\\\\152T ~X\\178O\\210)\\239\\177n\\018\\005\\166K\\\\\\187\\152ef\\175\\132\\026\\236jM\\141\\165B\\000]9v\\021\\151\\154\\248&\\011\\204\\233'\\149\\244\\0188\\2074\\215{C`\\225\\228\\020\\209\\199\\147}\\172ky\\231M\\2299\\243r\\141\\022\\128\\225\\th\\027Ko\\128\\017\\254\\166\\167X\\248\\233'\\220.\\022\\236\\243\\196\\025\\190o\\149v\\022xd\\2555\\157j {r?\\024\\127w\\134\\021\\210\\240s+7\\175\\022\\153w\\148\\207\\131Id\\216y9'\\166u><\\022\\185\\137!\\213=\\024T\\002\\232t\\243\\024\\168\\025\\253\\242\\243\\172fg& E\\170\\138&fN|\\166\\254\\147\\241Q\\240iP\\139\\130j\\213\\208lqT\\147\\024\\203\\201\\017\\218kt\\208n\\254(\\006\\000.S`[\\128\\026\\215\\254\\167E\\233vj\\221\\141\\169\\2373X\\157u\\143\\1799\\254\\212\\0122\\156Y\\170'\\183z\\135\\136\\176\\127|\\209\\201\\198\\022\\024u\\\\\\202=\\r0:{\\ta$\\206\\012\\002\\220_E\\026\\015\\003.\\030hs\\029\\000\\184G \\003\\136#w~\\198R-\\154\\030\\1586Y \\195\\231\\206\\006J\\222\\012.\\030\\217mb\\229J\\nI\\211\\164L\\145\\158\\180\\176\\1373=d\\1626\\237\\205\\161\\146\\018t\\172i\\003\\186\\2177\\204\\227\\167\\141\\250$-\\140S\\232\\148g\\204\\152m\\2533-\\185\\135\\215lf\\231sZG\\2394\\233\\015(\\195}i,\\132s\\170\\154$k\\184^\\\\C#\\205\\012Zi\\228\\185\\206\\026\\225`\\249aD|1\\174.\\216-8qxB\\189\\227\\023\\021~\\223\\024j[*Z\\194\\1605\\160i\\177\\138\\027\\183\\144\\216\\161\\182\\014&i\\148\\226p\\242\\132\\165W\\196\\024\\175\\235\\250\\172\\162yL\\138\\246\\164v\\203\\027\\148x\\194\\005\\232\\169\\001\\023\\015qq\\021\\229\\151\\019\\200O\\136\\186\\190.\\192)%\\024\\006\\r,\\200+T\\233\\169\\201\\162\\210\\168|\\233\\030\\021]\\217<\\155,?\\206\\227\\015\\163I`\\242G/\\205\\004\\217\\222\\132\\134\\2465\\201\\185mwo\\1741\\\"\\031\\168O\\148\\160\\214\\214K\\224\\185pI\\185*\\226\\197\\138\\140\\185>y!y\\250\\181\\127\\163,F\\149\\171\\231$,|j\\165\\018;A\\170\\142\\172\\232Z~\\238\\184\\235\\178\\\"\\025\\2015;\\146vq\\017\\153\\170\\168\\001\\130\\023\\022\\235\\162\\235\\218\\159\\234\\196B\\226\\158\\249)?\\\\Ev\\147=S\\026n<\\007Q\\1425\\\"A\\005_=\\220\\245\\178\\225$S\\1846\\156B\\014v\\173\\160\\251ln\\023?\\\"q\\170\\025\\236m\\184\\001\\001\\018a\\022\\005\\00056-\\152o \\197\\152\\229<=\\224\\184\\252A0\\004\\132$1r\\175\\137<\\201\\156\\161\\153\\170\\022\\022<\\240\\149\\030j8_\\180\\234\\139^,\\240\\232\\158T\\128z\\153\\147\\139\\n\\182\\156w\\241\\185\\178\\016\\160]\\021.7\\190\\250\\157\\128\\198(\\251\\139?\\127S\\022\\145,\\023T&\\160\\173\\154\\131\\219x\\bG\\2146\\241\\204\\171\\t\\224\\r6\\204+`v\\1941\\132\\004l\\n*\\006 \\133!VD\\254)T\\154bR\\002PU\\189\\251\\028k\\223#\\014\\192z\\145S\\025\\198\\006\\173\\147\\012A\\221\\127\\tr\\\"\\173\\162wjHNu_\\235-I\\028\\238\\128+\\234\\244\\221\\186\\243\\182\\150\\152h\\157~v\\182p\\202\\166]\\219\\217!\\151\\\"z\\176\\200\\223\\1866$\\181\\201\\141:\\136\\030\\170\\213`\\r\\137\\146\\r\\255\\131\\002Py\\210{\\222<\\234\\221\\020B[\\252\\138@\\211\\016\\192D\\022(\\001%\\025\\215o\\239\\001\\007CM\\197k\\177t\\231\\209a\\012\\222/\\200mj\\167+u\\173\\026\\205q\\200\\175\\225\\167\\025\\242\\229\\232?\\206yA\\251\\1541>+\\146bH\\n\\250hg]\\207\\171d\\178\\n\\229\\128\\t=$\\004\\006\\246hK1<\\228\\006i\\189[\\161\\200\\223>\\213<\\237/G<\\003z\\241\\154\\b\\154\\204\\148\\217\\195\\231\\189\\223f\\163#\\216+\\245E\\025\\187\\143/[\\221H\\254\\206\\180Z\\139\\222\\n\\167\\1609\\150\\161\\006B\\017\\181+\\195M&Xxu\\007$\\232\\213R\\174\\156\\232\\250\\229I,}\\020\\169\\230nu\\023\\206*\\018\\131\\\"j\\156\\211\\011\\147\\130\\151\\180\\001\\1770K \\166yd\\132<\\236\\003\\224\\226FW.\\\\\\137>\\220\\201\\145:\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\187*\\237\\202#z\\207\\025qG=3\\212[e\\143T\\238xc\\240\\169\\223S|\\147\\018\\n\\163\\181t\\027\"));;\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\n\nlet blockchain_dummy = Dummy_values.blockchain_proof\n\nlet transaction_dummy = Dummy_values.transaction_proof\n\n[%%versioned\nmodule Stable = struct\n module V2 = struct\n type t = Pickles.Proof.Proofs_verified_2.Stable.V2.t\n [@@deriving sexp, yojson, compare]\n\n let to_latest = Fn.id\n\n let to_yojson_full = Pickles.Proof.Proofs_verified_2.to_yojson_full\n end\nend]\n\n[%%define_locally Stable.Latest.(to_yojson, of_yojson, to_yojson_full)]\n","open Core_kernel\n\ntype uint64 = Unsigned.uint64\n\ntype uint32 = Unsigned.uint32\n\nmodule type S = sig\n type t [@@deriving sexp, hash, compare, yojson]\n\n val length_in_bits : int\n\n include Hashable.S with type t := t\n\n include Unsigned.S with type t := t\n\n val ( < ) : t -> t -> bool\n\n val ( > ) : t -> t -> bool\n\n val ( = ) : t -> t -> bool\n\n val ( <= ) : t -> t -> bool\n\n val ( >= ) : t -> t -> bool\n\n val to_bigint : t -> Bigint.t\nend\n\nmodule type F = functor\n (Unsigned : Unsigned.S)\n (M : sig\n val length : int\n end)\n -> S with type t = Unsigned.t\n[@@warning \"-67\"]\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Fold_lib\ninclude Intf\nmodule Intf = Intf\nopen Snark_bits\n\n[%%ifdef consensus_mechanism]\n\nmodule Make_checked\n (N : Unsigned_extended.S)\n (Bits : Bits_intf.Convertible_bits with type t := N.t) =\nstruct\n open Snark_params.Tick\n\n type var = Field.Var.t\n\n let () = assert (Int.(N.length_in_bits < Field.size_in_bits))\n\n let to_input (t : var) =\n Random_oracle.Input.Chunked.packed (t, N.length_in_bits)\n\n let to_input_legacy (t : var) =\n let to_bits (t : var) =\n with_label (sprintf \"to_bits: %s\" __LOC__) (fun () ->\n Field.Checked.choose_preimage_var t ~length:N.length_in_bits )\n in\n Checked.map (to_bits t) ~f:(fun bits ->\n Random_oracle.Input.Legacy.bitstring bits )\n\n let constant n =\n Field.Var.constant\n (Bigint.to_field (Bigint.of_bignum_bigint (N.to_bigint n)))\n\n let () = assert (Int.(N.length_in_bits mod 16 = 0))\n\n let range_check' (t : var) =\n let _, _, actual_packed =\n Pickles.Scalar_challenge.to_field_checked' ~num_bits:N.length_in_bits m\n (Kimchi_backend_common.Scalar_challenge.create t)\n in\n actual_packed\n\n let range_check t =\n let%bind actual = make_checked (fun () -> range_check' t) in\n Field.Checked.Assert.equal actual t\n\n let range_check_flag t =\n let open Pickles.Impls.Step in\n let actual = range_check' t in\n Field.equal actual t\n\n let of_field (x : Field.t) : N.t =\n let of_bits bs =\n (* TODO: Make this efficient *)\n List.foldi bs ~init:N.zero ~f:(fun i acc b ->\n if b then N.(logor (shift_left one i) acc) else acc )\n in\n of_bits (List.take (Field.unpack x) N.length_in_bits)\n\n let to_field (x : N.t) : Field.t = Field.project (Fold.to_list (Bits.fold x))\n\n let typ : (var, N.t) Typ.t =\n let (Typ field_typ) = Field.typ in\n Typ.transport\n (Typ { field_typ with check = range_check })\n ~there:to_field ~back:of_field\n\n let () = assert (N.length_in_bits * 2 < Field.size_in_bits + 1)\n\n let div_mod (x : var) (y : var) =\n let%bind q, r =\n exists (Typ.tuple2 typ typ)\n ~compute:\n As_prover.(\n let%map x = read typ x and y = read typ y in\n (N.div x y, N.rem x y))\n in\n\n (* q * y + r = x\n\n q * y = x - r\n *)\n let%map () = assert_r1cs q y (Field.Var.sub x r) in\n (q, r)\n\n type t = var\n\n let is_succ ~pred ~succ =\n let open Snark_params.Tick in\n let open Field in\n Checked.(equal (pred + Var.constant one) succ)\n\n let gte x y =\n let open Pickles.Impls.Step in\n let xy = Pickles.Util.seal m Field.(x - y) in\n let yx = Pickles.Util.seal m (Field.negate xy) in\n let x_gte_y = range_check_flag xy in\n let y_gte_x = range_check_flag yx in\n Boolean.Assert.any [ x_gte_y; y_gte_x ] ;\n x_gte_y\n\n let op op a b = make_checked (fun () -> op a b)\n\n let ( >= ) a b = op gte a b\n\n let ( <= ) a b = b >= a\n\n let ( < ) a b =\n make_checked (fun () ->\n let open Pickles.Impls.Step in\n Boolean.( &&& ) (gte b a) (Boolean.not (Field.equal b a)) )\n\n let ( > ) a b = b < a\n\n module Assert = struct\n let equal = Field.Checked.Assert.equal\n end\n\n let to_field = Fn.id\n\n module Unsafe = struct\n let of_field = Fn.id\n end\n\n let min a b =\n let%bind a_lte_b = a <= b in\n Field.Checked.if_ a_lte_b ~then_:a ~else_:b\n\n let if_ = Field.Checked.if_\n\n let succ_if (t : var) (c : Boolean.var) =\n Checked.return (Field.Var.add t (c :> Field.Var.t))\n\n let succ (t : var) =\n Checked.return (Field.Var.add t (Field.Var.constant Field.one))\n\n let seal x = make_checked (fun () -> Pickles.Util.seal m x)\n\n let add (x : var) (y : var) =\n let%bind res = seal (Field.Var.add x y) in\n let%map () = range_check res in\n res\n\n let mul (x : var) (y : var) =\n let%bind res = Field.Checked.mul x y in\n let%map () = range_check res in\n res\n\n let subtract_unpacking_or_zero x y =\n let open Pickles.Impls.Step in\n let res = Pickles.Util.seal m Field.(x - y) in\n let neg_res = Pickles.Util.seal m (Field.negate res) in\n let x_gte_y = range_check_flag res in\n let y_gte_x = range_check_flag neg_res in\n Boolean.Assert.any [ x_gte_y; y_gte_x ] ;\n (* If y_gte_x is false, then x_gte_y is true, so x >= y and\n thus there was no underflow.\n\n If y_gte_x is true, then y >= x, which means there was underflow\n iff y != x.\n\n Thus, underflow = (neg_res_good && y != x)\n *)\n let underflow = Boolean.( &&& ) y_gte_x (Boolean.not (Field.equal x y)) in\n (`Underflow underflow, Field.if_ underflow ~then_:Field.zero ~else_:res)\n\n let sub_or_zero a b = make_checked (fun () -> subtract_unpacking_or_zero a b)\n\n (* Unpacking protects against underflow *)\n let sub (x : var) (y : var) =\n let%bind res = seal (Field.Var.sub x y) in\n let%map () = range_check res in\n res\n\n let equal a b = Field.Checked.equal a b\n\n let ( = ) = equal\n\n let zero = Field.Var.constant Field.zero\nend\n\n[%%endif]\n\nopen Snark_params.Tick\n\nmodule Make (N : sig\n type t [@@deriving sexp, compare, hash]\n\n include Unsigned_extended.S with type t := t\n\n val random : unit -> t\nend)\n(Bits : Bits_intf.Convertible_bits with type t := N.t) =\nstruct\n type t = N.t [@@deriving sexp, compare, hash, yojson]\n\n (* can't be automatically derived *)\n let dhall_type = Ppx_dhall_type.Dhall_type.Text\n\n let max_value = N.max_int\n\n include Comparable.Make (N)\n\n include (N : module type of N with type t := t)\n\n let sub x y = if x < y then None else Some (N.sub x y)\n\n let to_field n = Bigint.to_field (Bigint.of_bignum_bigint (N.to_bigint n))\n\n [%%ifdef consensus_mechanism]\n\n module Checked = Make_checked (N) (Bits)\n\n (* warning: this typ does not work correctly with the generic if_ *)\n let typ = Checked.typ\n\n [%%endif]\n\n module Bits = Bits\n\n let to_bits = Bits.to_bits\n\n let of_bits = Bits.of_bits\n\n let to_input (t : t) =\n Random_oracle.Input.Chunked.packed (to_field t, N.length_in_bits)\n\n let to_input_legacy t = Random_oracle.Input.Legacy.bitstring (to_bits t)\n\n let fold t = Fold.group3 ~default:false (Bits.fold t)\n\n let gen =\n Quickcheck.Generator.map\n ~f:(fun n -> N.of_string (Bignum_bigint.to_string n))\n (Bignum_bigint.gen_incl Bignum_bigint.zero\n (Bignum_bigint.of_string N.(to_string max_int)) )\n\n let gen_incl min max =\n let open Quickcheck.Let_syntax in\n let%map n =\n Bignum_bigint.gen_incl\n (Bignum_bigint.of_string (N.to_string min))\n (Bignum_bigint.of_string (N.to_string max))\n in\n N.of_string (Bignum_bigint.to_string n)\nend\n\nmodule Make32 () : UInt32 = struct\n open Unsigned_extended\n\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n [@@@with_all_version_tags]\n\n type t = UInt32.Stable.V1.t\n [@@deriving sexp, equal, compare, hash, yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n include\n Make\n (struct\n include UInt32\n\n let random () =\n let mask = if Random.bool () then one else zero in\n let open UInt32.Infix in\n logor (mask lsl 31)\n ( Int32.max_value |> Random.int32 |> Int64.of_int32\n |> UInt32.of_int64 )\n end)\n (Bits.UInt32)\n\n let to_uint32 = Unsigned_extended.UInt32.to_uint32\n\n let of_uint32 = Unsigned_extended.UInt32.of_uint32\nend\n\nmodule Make64 () : UInt64 = struct\n open Unsigned_extended\n\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n [@@@with_all_version_tags]\n\n type t = UInt64.Stable.V1.t\n [@@deriving sexp, equal, compare, hash, yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n include\n Make\n (struct\n include UInt64\n\n let random () =\n let mask = if Random.bool () then one else zero in\n let open UInt64.Infix in\n logor (mask lsl 63)\n (Int64.max_value |> Random.int64 |> UInt64.of_int64)\n end)\n (Bits.UInt64)\n\n let to_uint64 = Unsigned_extended.UInt64.to_uint64\n\n let of_uint64 = Unsigned_extended.UInt64.of_uint64\nend\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Fold_lib\nopen Tuple_lib\nopen Unsigned\nopen Snark_bits\nopen Snark_params.Tick\n\nmodule type S_unchecked = sig\n type t [@@deriving sexp, compare, hash, yojson]\n\n include Comparable.S with type t := t\n\n include Hashable.S with type t := t\n\n (* not automatically derived *)\n val dhall_type : Ppx_dhall_type.Dhall_type.t\n\n val max_value : t\n\n val length_in_bits : int\n\n val gen : t Quickcheck.Generator.t\n\n val gen_incl : t -> t -> t Quickcheck.Generator.t\n\n val zero : t\n\n val one : t\n\n val succ : t -> t\n\n val add : t -> t -> t\n\n val sub : t -> t -> t option\n\n val of_int : int -> t\n\n val to_int : t -> int\n\n (* Someday: I think this only does ones greater than zero, but it doesn't really matter for\n selecting the nonce *)\n\n val random : unit -> t\n\n val of_string : string -> t\n\n val to_string : t -> string\n\n module Bits : Bits_intf.Convertible_bits with type t := t\n\n val to_bits : t -> bool list\n\n val of_bits : bool list -> t\n\n val to_field : t -> Field.t\n\n val to_input : t -> Field.t Random_oracle.Input.Chunked.t\n\n val to_input_legacy : t -> (_, bool) Random_oracle.Legacy.Input.t\n\n val fold : t -> bool Triple.t Fold.t\nend\n\n[%%ifdef consensus_mechanism]\n\nmodule type S_checked = sig\n type unchecked\n\n type var\n\n val constant : unchecked -> var\n\n type t = var\n\n val zero : t\n\n val succ : t -> t Checked.t\n\n val add : t -> t -> t Checked.t\n\n val mul : t -> t -> t Checked.t\n\n (** [sub_or_zero x y] computes [x - y].\n\n - If the argument to [`Underflow] is true, [x < y] and the returned integer\n value is pinned to [zero].\n - If the argument to [`Underflow] is false, [x >= y] and the returned\n integer value is equal to [x - y]\n *)\n val sub_or_zero : t -> t -> ([ `Underflow of Boolean.var ] * t) Checked.t\n\n (** [sub ~m x y] computes [x - y] and ensures that [0 <= x - y] *)\n val sub : t -> t -> t Checked.t\n\n val is_succ : pred:t -> succ:t -> Boolean.var Checked.t\n\n val min : t -> t -> t Checked.t\n\n val to_input : t -> Field.Var.t Random_oracle.Input.Chunked.t\n\n val to_input_legacy :\n t -> (_, Boolean.var) Random_oracle.Legacy.Input.t Checked.t\n\n val succ_if : t -> Boolean.var -> t Checked.t\n\n val if_ : Boolean.var -> then_:t -> else_:t -> t Checked.t\n\n (** warning: this typ does not work correctly with the generic if_ *)\n val typ : (t, unchecked) Snark_params.Tick.Typ.t\n\n val equal : t -> t -> Boolean.var Checked.t\n\n val div_mod : t -> t -> (t * t) Checked.t\n\n val ( = ) : t -> t -> Boolean.var Checked.t\n\n val ( < ) : t -> t -> Boolean.var Checked.t\n\n val ( > ) : t -> t -> Boolean.var Checked.t\n\n val ( <= ) : t -> t -> Boolean.var Checked.t\n\n val ( >= ) : t -> t -> Boolean.var Checked.t\n\n module Assert : sig\n val equal : t -> t -> unit Checked.t\n end\n\n val to_field : t -> Field.Var.t\n\n module Unsafe : sig\n val of_field : Field.Var.t -> t\n end\nend\n\n[%%endif]\n\nmodule type S = sig\n include S_unchecked\n\n [%%ifdef consensus_mechanism]\n\n module Checked : S_checked with type unchecked := t\n\n (** warning: this typ does not work correctly with the generic if_ *)\n val typ : (Checked.t, t) Snark_params.Tick.Typ.t\n\n [%%endif]\nend\n\nmodule type UInt32_A = sig\n [%%versioned:\n module Stable : sig\n module V1 : sig\n [@@@with_all_version_tags]\n\n type t [@@deriving sexp, equal, compare, hash, yojson]\n end\n end]\n\n include S with type t := t\n\n val to_uint32 : t -> uint32\n\n val of_uint32 : uint32 -> t\nend\n[@@warning \"-32\"]\n\nmodule type UInt32 = UInt32_A with type Stable.V1.t = Unsigned_extended.UInt32.t\n\nmodule type UInt64_A = sig\n [%%versioned:\n module Stable : sig\n module V1 : sig\n [@@@with_all_version_tags]\n\n type t [@@deriving sexp, equal, compare, hash, yojson]\n end\n end]\n\n include S with type t := Stable.Latest.t\n\n val to_uint64 : t -> uint64\n\n val of_uint64 : uint64 -> t\nend\n[@@warning \"-32\"]\n\nmodule type UInt64 = UInt64_A with type Stable.V1.t = Unsigned_extended.UInt64.t\n\nmodule type F = functor\n (N : sig\n type t [@@deriving bin_io, sexp, compare, hash]\n\n include Unsigned_extended.S with type t := t\n\n val random : unit -> t\n end)\n (Bits : Bits_intf.Convertible_bits with type t := N.t)\n -> S with type t := N.t and module Bits := Bits\n\n[%%ifdef consensus_mechanism]\n\nmodule type F_checked = functor\n (N : Unsigned_extended.S)\n (Bits : Bits_intf.Convertible_bits with type t := N.t)\n -> S_checked with type unchecked := N.t\n[@@warning \"-67\"]\n\n[%%endif]\n","include Nat.Make32 ()\n","module T = Nat.Make32 ()\n\n(** See documentation of the {!Mina_wire_types} library *)\nmodule Wire_types = Mina_wire_types.Mina_numbers.Account_nonce\n\nmodule Make_sig (A : Wire_types.Types.S) = struct\n module type S = sig\n include Nat.Intf.UInt32_A with type Stable.V1.t = A.V1.t\n\n include Codable.S with type t := t\n end\nend\n\nmodule Make_str (_ : Wire_types.Concrete) = struct\n include T\n\n (* while we could use an int encoding for yojson (an OCaml int is 63-bits)\n we've committed to a string encoding\n *)\n include Codable.Make_of_string (T)\nend\n\ninclude Wire_types.Make (Make_sig) (Make_str)\n","module type S_base = sig\n [%%versioned:\n module Stable : sig\n module V1 : sig\n type t [@@deriving hash, sexp, compare, equal, yojson]\n end\n end]\n\n val to_uint32 : t -> Unsigned.uint32\n\n val of_uint32 : Unsigned.uint32 -> t\n\n val to_string : t -> string\n\n val of_string : string -> t\n\n val gen : t Core_kernel.Quickcheck.Generator.t\n\n val gen_incl : t -> t -> t Core_kernel.Quickcheck.Generator.t\n\n val dhall_type : Ppx_dhall_type.Dhall_type.t\n\n val zero : t\n\n val one : t\n\n val succ : t -> t\n\n val of_int : int -> t\n\n val to_int : t -> int\n\n val max_value : t\n\n val to_input : t -> Snark_params.Tick.Field.t Random_oracle.Input.Chunked.t\n\n val to_input_legacy : t -> ('a, bool) Random_oracle.Legacy.Input.t\n\n val to_field : t -> Snark_params.Tick.Field.t\n\n val random : unit -> t\n\n include Core_kernel.Comparable.S with type t := t\nend\n\nmodule type S = sig\n include S_base\n\n type global_slot_span\n\n module Checked : sig\n include Intf.S_checked with type unchecked := t\n\n type global_slot_span_checked\n\n open Snark_params.Tick\n\n val add : t -> global_slot_span_checked -> t Checked.t\n\n val sub : t -> global_slot_span_checked -> t Checked.t\n\n val diff : t -> t -> global_slot_span_checked Checked.t\n\n val diff_or_zero :\n t\n -> t\n -> ([ `Underflow of Boolean.var ] * global_slot_span_checked) Checked.t\n end\n\n val typ : (Checked.t, t) Snark_params.Tick.Typ.t\n\n val add : t -> global_slot_span -> t\n\n val sub : t -> global_slot_span -> t option\n\n val diff : t -> t -> global_slot_span option\nend\n\nmodule type S_span = sig\n include S_base\n\n module Checked : Intf.S_checked with type unchecked := t\n\n val typ : (Checked.t, t) Snark_params.Tick.Typ.t\n\n val add : t -> t -> t\n\n val sub : t -> t -> t option\nend\n","(** Legacy global slot implementation *)\n\n(* Used *only* for V1 payments, delegation valid_until field *)\n\n(** See documentation of the {!Mina_wire_types} library *)\nmodule Wire_types = Mina_wire_types.Mina_numbers.Global_slot_legacy\n\nmodule Make_sig (A : Wire_types.Types.S) = struct\n module type S = Nat.Intf.UInt32_A with type Stable.V1.t = A.V1.t\nend\n\nmodule T = Nat.Make32 ()\n\nmodule Make_str (_ : Wire_types.Concrete) = struct\n include T\nend\n\ninclude Wire_types.Make (Make_sig) (Make_str)\n","open Core_kernel\n\ntype uint32 = Unsigned.uint32\n\nmodule type S = sig\n [%%versioned:\n module Stable : sig\n module V1 : sig\n type t [@@deriving sexp, compare]\n end\n end]\n\n module T : Intf.UInt32\n\n val to_uint32 : t -> uint32\n\n val of_uint32 : uint32 -> t\nend\n\nmodule Make (M : S) = struct\n type global_slot_span = Global_slot_span.t\n\n module T = M.T\n\n let to_uint32 = M.to_uint32\n\n let of_uint32 = M.of_uint32\n\n module Checked = struct\n include T.Checked\n\n type global_slot_span_checked = Global_slot_span.Checked.t\n\n let constant t = constant (to_uint32 t)\n\n open Snark_params.Tick\n\n let add t (span : global_slot_span_checked) =\n let t' = Global_slot_span.Checked.to_field span |> Unsafe.of_field in\n add t t'\n\n let sub t (span : global_slot_span_checked) =\n let t' = Global_slot_span.Checked.to_field span |> Unsafe.of_field in\n sub t t'\n\n let diff t1 t2 : global_slot_span_checked Checked.t =\n let%map diff = T.Checked.sub t1 t2 in\n let field = T.Checked.to_field diff in\n (* `of_field` is the identity function, here applied to a checked field *)\n Global_slot_span.Checked.Unsafe.of_field field\n\n let typ = Typ.transport T.Checked.typ ~there:to_uint32 ~back:of_uint32\n\n let diff_or_zero t1 t2 =\n let%map underflow, diff = T.Checked.sub_or_zero t1 t2 in\n let field = T.Checked.to_field diff in\n (* `of_field` is the identity function, here applied to a checked field *)\n let span = Global_slot_span.Checked.Unsafe.of_field field in\n (underflow, span)\n end\n\n let to_string t = Unsigned.UInt32.to_string @@ to_uint32 t\n\n let of_string s = of_uint32 @@ Unsigned.UInt32.of_string s\n\n let typ = Checked.typ\n\n let gen =\n let%map.Quickcheck u32 = T.gen in\n of_uint32 u32\n\n let gen_incl t1 t2 =\n let u32_1 = to_uint32 t1 in\n let u32_2 = to_uint32 t2 in\n let%map.Quickcheck u32 = T.gen_incl u32_1 u32_2 in\n of_uint32 u32\n\n let dhall_type = Ppx_dhall_type.Dhall_type.Text\n\n let zero = of_uint32 T.zero\n\n let one = of_uint32 T.one\n\n let succ t =\n let u32 = to_uint32 t in\n of_uint32 (T.succ u32)\n\n let max_value = of_uint32 Unsigned.UInt32.max_int\n\n let to_field t = T.to_field (to_uint32 t)\n\n let to_input t = T.to_input (to_uint32 t)\n\n let to_input_legacy t = T.to_input_legacy (to_uint32 t)\n\n include Comparable.Make (M.Stable.Latest)\n\n let add t span =\n let u32_slot = to_uint32 t in\n let u32_span = Global_slot_span.to_uint32 span in\n let u32_sum = T.add u32_slot u32_span in\n of_uint32 u32_sum\n\n let sub t span =\n let u32_slot = to_uint32 t in\n let u32_span = Global_slot_span.to_uint32 span in\n Option.map (T.sub u32_slot u32_span) ~f:of_uint32\n\n let diff t1 t2 =\n let u32_1 = to_uint32 t1 in\n let u32_2 = to_uint32 t2 in\n Option.map (T.sub u32_1 u32_2) ~f:Global_slot_span.of_uint32\n\n let of_int n = of_uint32 (T.of_int n)\n\n let to_int t = T.to_int (to_uint32 t)\n\n let random () = of_uint32 (T.random ())\nend\n","module T = Nat.Make32 ()\n\ninclude T\ninclude Codable.Make_of_string (T)\n","module T = Nat.Make32 ()\n\nmodule Wire_types = Mina_wire_types.Mina_numbers.Index\n\nmodule Make_sig (A : Wire_types.Types.S) = struct\n module type S = sig\n include Nat.Intf.UInt32_A with type Stable.V1.t = A.V1.t\n end\nend\n\nmodule Make_str (_ : Wire_types.Concrete) = struct\n include T\n\n let to_bits = Bits.to_bits\n\n let of_bits = Bits.of_bits\nend\n\ninclude Wire_types.Make (Make_sig) (Make_str)\n","module T = Nat.Make32 ()\n\n(** See documentation of the {!Mina_wire_types} library *)\nmodule Wire_types = Mina_wire_types.Mina_numbers.Length\n\nmodule Make_sig (A : Wire_types.Types.S) = struct\n module type S = sig\n include Nat.Intf.UInt32_A with type Stable.V1.t = A.V1.t\n end\nend\n\nmodule Make_str (_ : Wire_types.Concrete) = struct\n include T\n\n let to_bits = Bits.to_bits\n\n let of_bits = Bits.of_bits\nend\n\ninclude Wire_types.Make (Make_sig) (Make_str)\n","module Account_nonce = Account_nonce\nmodule Length = Length\nmodule Index = Index\nmodule Nat = Nat\nmodule Global_slot_legacy = Global_slot_legacy\nmodule Global_slot_since_genesis = Global_slot_since_genesis\nmodule Global_slot_since_hard_fork = Global_slot_since_hard_fork\nmodule Global_slot_span = Global_slot_span\nmodule Hd_index = Hd_index\nmodule Zkapp_version = Zkapp_version\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Snark_bits\nopen Snark_params.Tick\n\ntype uint64 = Unsigned.uint64\n\nmodule type Basic = sig\n type t [@@deriving sexp, compare, hash, yojson]\n\n type magnitude = t [@@deriving sexp, compare]\n\n (* not automatically derived *)\n val dhall_type : Ppx_dhall_type.Dhall_type.t\n\n val max_int : t\n\n val length_in_bits : int\n\n include Comparable.S with type t := t\n\n val gen_incl : t -> t -> t Quickcheck.Generator.t\n\n val gen : t Quickcheck.Generator.t\n\n include Bits_intf.Convertible_bits with type t := t\n\n val to_input : t -> Field.t Random_oracle.Input.Chunked.t\n\n val to_input_legacy : t -> (_, bool) Random_oracle.Legacy.Input.t\n\n val zero : t\n\n val one : t\n\n val of_string : string -> t\n\n val to_string : t -> string\n\n val of_mina_string_exn : string -> t\n\n val to_mina_string : t -> string\n\n val to_uint64 : t -> uint64\n\n val of_uint64 : uint64 -> t\n\n (* The functions below are unsafe, because they could overflow or\n underflow. They perform appropriate checks to guard against this\n and either raise Currency_overflow exception or return None\n depending on the error-handling strategy.\n\n It is advisable to use nanomina and mina wherever possible and\n limit the use of _exn veriants to places where a fixed value is\n being converted and hence overflow cannot happen. *)\n val of_mina_int_exn : int -> t\n\n val of_nanomina_int_exn : int -> t\n\n val of_mina_int : int -> t option\n\n val of_nanomina_int : int -> t option\n\n val to_mina_int : t -> int\n\n val to_nanomina_int : t -> int\n\n [%%ifdef consensus_mechanism]\n\n type var\n\n val typ : (var, t) Typ.t\n\n val var_of_t : t -> var\n\n val var_to_bits :\n var -> Boolean.var Bitstring_lib.Bitstring.Lsb_first.t Checked.t\n\n val var_to_input : var -> Field.Var.t Random_oracle.Input.Chunked.t\n\n val var_to_input_legacy :\n var -> (Field.Var.t, Boolean.var) Random_oracle.Input.Legacy.t Checked.t\n\n val equal_var : var -> var -> Boolean.var Checked.t\n\n val pack_var : var -> Field.Var.t\n\n [%%endif]\nend\n\nmodule type Arithmetic_intf = sig\n type t\n\n val add : t -> t -> t option\n\n val add_flagged : t -> t -> t * [ `Overflow of bool ]\n\n val sub : t -> t -> t option\n\n val sub_flagged : t -> t -> t * [ `Underflow of bool ]\n\n val ( + ) : t -> t -> t option\n\n val ( - ) : t -> t -> t option\n\n val scale : t -> int -> t option\nend\n\nmodule type Signed_intf = sig\n type magnitude\n\n type signed_fee\n\n [%%ifdef consensus_mechanism]\n\n type magnitude_var\n\n [%%endif]\n\n type t = (magnitude, Sgn.t) Signed_poly.t\n [@@deriving sexp, hash, compare, equal, yojson]\n\n val gen : t Quickcheck.Generator.t\n\n val create : magnitude:magnitude -> sgn:Sgn.t -> t\n\n val sgn : t -> Sgn.t\n\n val magnitude : t -> magnitude\n\n val zero : t\n\n val is_zero : t -> bool\n\n val is_positive : t -> bool\n\n val is_negative : t -> bool\n\n val to_input : t -> Field.t Random_oracle.Input.Chunked.t\n\n val to_input_legacy : t -> (_, bool) Random_oracle.Legacy.Input.t\n\n val add : t -> t -> t option\n\n val add_flagged : t -> t -> t * [ `Overflow of bool ]\n\n val ( + ) : t -> t -> t option\n\n val negate : t -> t\n\n val of_unsigned : magnitude -> t\n\n val to_fee : t -> signed_fee\n\n val of_fee : signed_fee -> t\n\n [%%ifdef consensus_mechanism]\n\n type var (* = (magnitude_var, Sgn.var) Signed_poly.t *)\n\n val create_var : magnitude:magnitude_var -> sgn:Sgn.var -> var\n\n val typ : (var, t) Typ.t\n\n module Checked : sig\n type signed_fee_var\n\n val constant : t -> var\n\n val of_unsigned : magnitude_var -> var\n\n val sgn : var -> Sgn.var Checked.t\n\n val magnitude : var -> magnitude_var Checked.t\n\n val negate : var -> var\n\n val if_ : Boolean.var -> then_:var -> else_:var -> var Checked.t\n\n val to_input : var -> Field.Var.t Random_oracle.Input.Chunked.t Checked.t\n\n val to_input_legacy :\n var -> (_, Boolean.var) Random_oracle.Legacy.Input.t Checked.t\n\n val add : var -> var -> var Checked.t\n\n val add_flagged :\n var -> var -> (var * [ `Overflow of Boolean.var ]) Checked.t\n\n val assert_equal : var -> var -> unit Checked.t\n\n val equal : var -> var -> Boolean.var Checked.t\n\n val ( + ) : var -> var -> var Checked.t\n\n val to_field_var : var -> Field.Var.t Checked.t\n\n val to_fee : var -> signed_fee_var\n\n val of_fee : signed_fee_var -> var\n\n type t = var\n end\n\n [%%endif]\nend\n\n[%%ifdef consensus_mechanism]\n\nmodule type Checked_arithmetic_intf = sig\n type value\n\n type var\n\n type t = var\n\n type signed_var\n\n val if_ : Boolean.var -> then_:var -> else_:var -> var Checked.t\n\n val add : var -> var -> var Checked.t\n\n val sub : var -> var -> var Checked.t\n\n val sub_flagged :\n var -> var -> (var * [ `Underflow of Boolean.var ]) Checked.t\n\n val sub_or_zero : var -> var -> var Checked.t\n\n val add_flagged : var -> var -> (var * [ `Overflow of Boolean.var ]) Checked.t\n\n val ( + ) : var -> var -> var Checked.t\n\n val ( - ) : var -> var -> var Checked.t\n\n val add_signed : var -> signed_var -> var Checked.t\n\n val add_signed_flagged :\n var -> signed_var -> (var * [ `Overflow of Boolean.var ]) Checked.t\n\n val assert_equal : var -> var -> unit Checked.t\n\n val equal : var -> var -> Boolean.var Checked.t\n\n val ( = ) : t -> t -> Boolean.var Checked.t\n\n val ( < ) : t -> t -> Boolean.var Checked.t\n\n val ( > ) : t -> t -> Boolean.var Checked.t\n\n val ( <= ) : t -> t -> Boolean.var Checked.t\n\n val ( >= ) : t -> t -> Boolean.var Checked.t\n\n val scale : Field.Var.t -> var -> var Checked.t\nend\n\n[%%endif]\n\nmodule type S = sig\n include Basic\n\n include Arithmetic_intf with type t := t\n\n [%%ifdef consensus_mechanism]\n\n module Signed :\n Signed_intf with type magnitude := t and type magnitude_var := var\n\n module Checked :\n Checked_arithmetic_intf\n with type var := var\n and type signed_var := Signed.var\n and type value := t\n\n [%%else]\n\n module Signed : Signed_intf with type magnitude := t\n\n [%%endif]\n\n val add_signed_flagged : t -> Signed.t -> t * [ `Overflow of bool ]\nend\n\nmodule type Full = sig\n [%%ifdef consensus_mechanism]\n\n open Snark_params.Tick\n\n module Signed_var : sig\n type 'mag repr = ('mag, Sgn.var) Signed_poly.t\n\n (* Invariant: At least one of these is Some *)\n type nonrec 'mag t =\n { repr : 'mag repr; mutable value : Field.Var.t option }\n end\n\n [%%endif]\n\n module Signed_poly = Signed_poly\n\n module Fee : sig\n [%%versioned:\n module Stable : sig\n module V1 : sig\n [@@@with_all_version_tags]\n\n type t [@@deriving sexp, compare, hash, yojson, equal]\n\n (* not automatically derived *)\n val dhall_type : Ppx_dhall_type.Dhall_type.t\n end\n end]\n\n include Basic with type t := Stable.Latest.t\n\n include Arithmetic_intf with type t := t\n\n include Codable.S with type t := t\n\n val minimum_user_command_fee : t\n\n val default_transaction_fee : t\n\n val default_snark_worker_fee : t\n\n (* TODO: Get rid of signed fee, use signed amount *)\n [%%ifdef consensus_mechanism]\n\n module Signed :\n Signed_intf\n with type magnitude := t\n and type magnitude_var := var\n and type signed_fee := (t, Sgn.t) Signed_poly.t\n and type Checked.signed_fee_var := Field.Var.t Signed_var.t\n\n [%%else]\n\n module Signed :\n Signed_intf\n with type magnitude := t\n and type signed_fee := (t, Sgn.t) Signed_poly.t\n\n [%%endif]\n\n [%%ifdef consensus_mechanism]\n\n module Checked : sig\n include\n Checked_arithmetic_intf\n with type var := var\n and type signed_var := Signed.var\n and type value := t\n\n val add_signed : var -> Signed.var -> var Checked.t\n end\n\n [%%endif]\n end\n [@@warning \"-32\"]\n\n module Amount : sig\n [%%versioned:\n module Stable : sig\n module V1 : sig\n [@@@with_all_version_tags]\n\n type t [@@deriving sexp, compare, hash, equal, yojson]\n\n (* not automatically derived *)\n val dhall_type : Ppx_dhall_type.Dhall_type.t\n end\n end]\n\n include Basic with type t := Stable.Latest.t\n\n include Arithmetic_intf with type t := t\n\n include Codable.S with type t := t\n\n [%%ifdef consensus_mechanism]\n\n module Signed :\n Signed_intf\n with type magnitude := t\n and type magnitude_var := var\n and type signed_fee := Fee.Signed.t\n and type Checked.signed_fee_var := Fee.Signed.Checked.t\n\n [%%else]\n\n module Signed :\n Signed_intf with type magnitude := t and type signed_fee := Fee.Signed.t\n\n [%%endif]\n\n (* TODO: Delete these functions *)\n\n val of_fee : Fee.t -> t\n\n val to_fee : t -> Fee.t\n\n val add_fee : t -> Fee.t -> t option\n\n val add_signed_flagged : t -> Signed.t -> t * [ `Overflow of bool ]\n\n [%%ifdef consensus_mechanism]\n\n module Checked : sig\n include\n Checked_arithmetic_intf\n with type var := var\n and type signed_var := Signed.var\n and type value := t\n\n val add_signed : var -> Signed.var -> var Checked.t\n\n val add_signed_flagged :\n var -> Signed.var -> (var * [ `Overflow of Boolean.var ]) Checked.t\n\n val of_fee : Fee.var -> var\n\n val to_fee : var -> Fee.var\n\n val to_field : var -> Field.Var.t\n\n module Unsafe : sig\n val of_field : Field.Var.t -> t\n end\n end\n\n [%%endif]\n end\n [@@warning \"-32\"]\n\n module Balance : sig\n [%%versioned:\n module Stable : sig\n module V1 : sig\n type t [@@deriving sexp, compare, hash, yojson, equal]\n\n (* not automatically derived *)\n val dhall_type : Ppx_dhall_type.Dhall_type.t\n end\n end]\n\n include Basic with type t := Stable.Latest.t\n\n val to_amount : t -> Amount.t\n\n val add_amount : t -> Amount.t -> t option\n\n val add_amount_flagged : t -> Amount.t -> t * [ `Overflow of bool ]\n\n val sub_amount : t -> Amount.t -> t option\n\n val sub_amount_flagged : t -> Amount.t -> t * [ `Underflow of bool ]\n\n val add_signed_amount_flagged :\n t -> Amount.Signed.t -> t * [ `Overflow of bool ]\n\n val ( + ) : t -> Amount.t -> t option\n\n val ( - ) : t -> Amount.t -> t option\n\n [%%ifdef consensus_mechanism]\n\n module Checked : sig\n type t = var\n\n val to_amount : t -> Amount.var\n\n val add_signed_amount : var -> Amount.Signed.var -> var Checked.t\n\n val add_amount : var -> Amount.var -> var Checked.t\n\n val sub_amount : var -> Amount.var -> var Checked.t\n\n val sub_amount_flagged :\n var -> Amount.var -> (var * [ `Underflow of Boolean.var ]) Checked.t\n\n val add_amount_flagged :\n var -> Amount.var -> (var * [ `Overflow of Boolean.var ]) Checked.t\n\n val add_signed_amount_flagged :\n var\n -> Amount.Signed.var\n -> (var * [ `Overflow of Boolean.var ]) Checked.t\n\n val sub_or_zero : var -> var -> var Checked.t\n\n val sub_amount_or_zero : var -> Amount.var -> var Checked.t\n\n val ( + ) : var -> Amount.var -> var Checked.t\n\n val ( - ) : var -> Amount.var -> var Checked.t\n\n val equal : var -> var -> Boolean.var Checked.t\n\n val ( = ) : var -> var -> Boolean.var Checked.t\n\n val ( < ) : var -> var -> Boolean.var Checked.t\n\n val ( > ) : var -> var -> Boolean.var Checked.t\n\n val ( <= ) : var -> var -> Boolean.var Checked.t\n\n val ( >= ) : var -> var -> Boolean.var Checked.t\n\n val if_ : Boolean.var -> then_:var -> else_:var -> var Checked.t\n\n val to_field : var -> Field.Var.t\n\n module Unsafe : sig\n val of_field : Field.Var.t -> var\n end\n end\n\n [%%endif]\n end\n [@@warning \"-32\"]\n\n module Fee_rate : sig\n type t\n\n include Arithmetic_intf with type t := t\n\n include Comparable.S with type t := t\n\n include Sexpable.S with type t := t\n\n val of_q : Q.t -> t option\n\n val of_q_exn : Q.t -> t\n\n val to_q : t -> Q.t\n\n (** construct a fee rate from a fee and a weight *)\n val make : Fee.t -> int -> t option\n\n (** construct a fee rate from a fee and a weight *)\n val make_exn : Fee.t -> int -> t\n\n (** convert to uint64, if the fee rate is equivalent to an integer. *)\n val to_uint64 : t -> uint64 option\n\n (** convert to uint64, if the fee rate is equivalent to an integer. *)\n val to_uint64_exn : t -> uint64\n\n val mul : t -> t -> t option\n\n val scale_exn : t -> int -> t\n\n val div : t -> t -> t option\n\n val ( * ) : t -> t -> t option\n end\nend\n","(*\n RE - A regular expression library\n\n Copyright (C) 2001 Jerome Vouillon\n email: Jerome.Vouillon@pps.jussieu.fr\n\n This library is free software; you can redistribute it and/or\n modify it under the terms of the GNU Lesser General Public\n License as published by the Free Software Foundation, with\n linking exception; either version 2.1 of the License, or (at\n your option) any later version.\n\n This library is distributed in the hope that it will be useful,\n but WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n Lesser General Public License for more details.\n\n You should have received a copy of the GNU Lesser General Public\n License along with this library; if not, write to the Free Software\n Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n*)\n\nlet rec iter n f v = if n = 0 then v else iter (n - 1) f (f v)\n\n(****)\n\nlet unknown = -2\nlet break = -3\n\ntype match_info =\n | Match of Group.t\n | Failed\n | Running\n\ntype state =\n { idx : int;\n (* Index of the current position in the position table.\n Not yet computed transitions point to a dummy state where\n [idx] is set to [unknown];\n If [idx] is set to [break] for states that either always\n succeed or always fail. *)\n real_idx : int;\n (* The real index, in case [idx] is set to [break] *)\n next : state array;\n (* Transition table, indexed by color *)\n mutable final :\n (Category.t *\n (Automata.idx * Automata.status)) list;\n (* Mapping from the category of the next character to\n - the index where the next position should be saved\n - possibly, the list of marks (and the corresponding indices)\n corresponding to the best match *)\n desc : Automata.State.t\n (* Description of this state of the automata *) }\n\n(* Automata (compiled regular expression) *)\ntype re =\n { initial : Automata.expr;\n (* The whole regular expression *)\n mutable initial_states : (Category.t * state) list;\n (* Initial states, indexed by initial category *)\n colors : Bytes.t;\n (* Color table *)\n color_repr : Bytes.t;\n (* Table from colors to one character of this color *)\n ncolor : int;\n (* Number of colors. *)\n lnl : int;\n (* Color of the last newline. -1 if unnecessary *)\n tbl : Automata.working_area;\n (* Temporary table used to compute the first available index\n when computing a new state *)\n states : state Automata.State.Table.t;\n (* States of the deterministic automata *)\n group_count : int\n (* Number of groups in the regular expression *) }\n\nlet pp_re ch re = Automata.pp ch re.initial\n\nlet print_re = pp_re\n\n(* Information used during matching *)\ntype info =\n { re : re;\n (* The automata *)\n colors : Bytes.t;\n (* Color table ([x.colors = x.re.colors])\n Shortcut used for performance reasons *)\n mutable positions : int array;\n (* Array of mark positions\n The mark are off by one for performance reasons *)\n pos : int;\n (* Position where the match is started *)\n last : int\n (* Position where the match should stop *) }\n\n\n(****)\n\nlet category re ~color =\n if color = -1 then\n Category.inexistant\n (* Special category for the last newline *)\n else if color = re.lnl then\n Category.(lastnewline ++ newline ++ not_letter)\n else\n Category.from_char (Bytes.get re.color_repr color)\n\n(****)\n\nlet dummy_next = [||]\n\nlet unknown_state =\n { idx = unknown; real_idx = 0;\n next = dummy_next; final = [];\n desc = Automata.State.dummy }\n\nlet mk_state ncol desc =\n let break_state =\n match Automata.status desc with\n | Automata.Running -> false\n | Automata.Failed\n | Automata.Match _ -> true\n in\n { idx = if break_state then break else desc.Automata.State.idx;\n real_idx = desc.Automata.State.idx;\n next = if break_state then dummy_next else Array.make ncol unknown_state;\n final = [];\n desc }\n\nlet find_state re desc =\n try\n Automata.State.Table.find re.states desc\n with Not_found ->\n let st = mk_state re.ncolor desc in\n Automata.State.Table.add re.states desc st;\n st\n\n(**** Match with marks ****)\n\nlet delta info cat ~color st =\n let desc = Automata.delta info.re.tbl cat color st.desc in\n let len = Array.length info.positions in\n if desc.Automata.State.idx = len && len > 0 then begin\n let pos = info.positions in\n info.positions <- Array.make (2 * len) 0;\n Array.blit pos 0 info.positions 0 len\n end;\n desc\n\nlet validate info (s:string) ~pos st =\n let color = Char.code (Bytes.get info.colors (Char.code s.[pos])) in\n let cat = category info.re ~color in\n let desc' = delta info cat ~color st in\n let st' = find_state info.re desc' in\n st.next.(color) <- st'\n\n(*\nlet rec loop info s pos st =\n if pos < info.last then\n let st' = st.next.(Char.code info.cols.[Char.code s.[pos]]) in\n let idx = st'.idx in\n if idx >= 0 then begin\n info.positions.(idx) <- pos;\n loop info s (pos + 1) st'\n end else if idx = break then begin\n info.positions.(st'.real_idx) <- pos;\n st'\n end else begin (* Unknown *)\n validate info s pos st;\n loop info s pos st\n end\n else\n st\n*)\n\nlet rec loop info (s:string) ~pos st =\n if pos < info.last then\n let st' = st.next.(Char.code (Bytes.get info.colors (Char.code s.[pos]))) in\n loop2 info s ~pos st st'\n else\n st\n\nand loop2 info s ~pos st st' =\n if st'.idx >= 0 then begin\n let pos = pos + 1 in\n if pos < info.last then begin\n (* It is important to place these reads before the write *)\n (* But then, we don't have enough registers left to store the\n right position. So, we store the position plus one. *)\n let st'' =\n st'.next.(Char.code (Bytes.get info.colors (Char.code s.[pos]))) in\n info.positions.(st'.idx) <- pos;\n loop2 info s ~pos st' st''\n end else begin\n info.positions.(st'.idx) <- pos;\n st'\n end\n end else if st'.idx = break then begin\n info.positions.(st'.real_idx) <- pos + 1;\n st'\n end else begin (* Unknown *)\n validate info s ~pos st;\n loop info s ~pos st\n end\n\nlet rec loop_no_mark info s ~pos ~last st =\n if pos < last then\n let st' = st.next.(Char.code (Bytes.get info.colors (Char.code s.[pos]))) in\n if st'.idx >= 0 then\n loop_no_mark info s ~pos:(pos + 1) ~last st'\n else if st'.idx = break then\n st'\n else begin (* Unknown *)\n validate info s ~pos st;\n loop_no_mark info s ~pos ~last st\n end\n else\n st\n\nlet final info st cat =\n try\n List.assq cat st.final\n with Not_found ->\n let st' = delta info cat ~color:(-1) st in\n let res = (st'.Automata.State.idx, Automata.status st') in\n st.final <- (cat, res) :: st.final;\n res\n\nlet find_initial_state re cat =\n try\n List.assq cat re.initial_states\n with Not_found ->\n let st = find_state re (Automata.State.create cat re.initial) in\n re.initial_states <- (cat, st) :: re.initial_states;\n st\n\nlet get_color re (s:string) pos =\n if pos < 0 then\n -1\n else\n let slen = String.length s in\n if pos >= slen then\n -1\n else if pos = slen - 1 && re.lnl <> -1 && s.[pos] = '\\n' then\n (* Special case for the last newline *)\n re.lnl\n else\n Char.code (Bytes.get re.colors (Char.code s.[pos]))\n\nlet rec handle_last_newline info ~pos st ~groups =\n let st' = st.next.(info.re.lnl) in\n if st'.idx >= 0 then begin\n if groups then info.positions.(st'.idx) <- pos + 1;\n st'\n end else if st'.idx = break then begin\n if groups then info.positions.(st'.real_idx) <- pos + 1;\n st'\n end else begin (* Unknown *)\n let color = info.re.lnl in\n let real_c = Char.code (Bytes.get info.colors (Char.code '\\n')) in\n let cat = category info.re ~color in\n let desc' = delta info cat ~color:real_c st in\n let st' = find_state info.re desc' in\n st.next.(color) <- st';\n handle_last_newline info ~pos st ~groups\n end\n\nlet rec scan_str info (s:string) initial_state ~groups =\n let pos = info.pos in\n let last = info.last in\n if (last = String.length s\n && info.re.lnl <> -1\n && last > pos\n && String.get s (last - 1) = '\\n')\n then begin\n let info = { info with last = last - 1 } in\n let st = scan_str info s initial_state ~groups in\n if st.idx = break then\n st\n else\n handle_last_newline info ~pos:(last - 1) st ~groups\n end else if groups then\n loop info s ~pos initial_state\n else\n loop_no_mark info s ~pos ~last initial_state\n\nlet match_str ~groups ~partial re s ~pos ~len =\n let slen = String.length s in\n let last = if len = -1 then slen else pos + len in\n let info =\n { re ; colors = re.colors; pos ; last\n ; positions =\n if groups then begin\n let n = Automata.index_count re.tbl + 1 in\n if n <= 10 then\n [|0;0;0;0;0;0;0;0;0;0|]\n else\n Array.make n 0\n end else\n [||] }\n in\n let initial_cat =\n if pos = 0 then\n Category.(search_boundary ++ inexistant)\n else\n Category.(search_boundary\n ++ category re ~color:(get_color re s (pos - 1)))\n in\n let initial_state = find_initial_state re initial_cat in\n let st = scan_str info s initial_state ~groups in\n let res =\n if st.idx = break || partial then\n Automata.status st.desc\n else\n let final_cat =\n if last = slen then\n Category.(search_boundary ++ inexistant)\n else\n Category.(search_boundary ++ category re ~color:(get_color re s last))\n in\n let (idx, res) = final info st final_cat in\n if groups then info.positions.(idx) <- last + 1;\n res\n in\n match res with\n Automata.Match (marks, pmarks) ->\n Match { s ; marks; pmarks ; gpos = info.positions; gcount = re.group_count}\n | Automata.Failed -> Failed\n | Automata.Running -> Running\n\nlet mk_re ~initial ~colors ~color_repr ~ncolor ~lnl ~group_count =\n { initial ;\n initial_states = [];\n colors;\n color_repr;\n ncolor;\n lnl;\n tbl = Automata.create_working_area ();\n states = Automata.State.Table.create 97;\n group_count }\n\n(**** Character sets ****)\n\nlet cseq c c' = Cset.seq (Char.code c) (Char.code c')\nlet cadd c s = Cset.add (Char.code c) s\n\nlet trans_set cache cm s =\n match Cset.one_char s with\n | Some i -> Cset.csingle (Bytes.get cm i)\n | None ->\n let v = (Cset.hash_rec s, s) in\n try\n Cset.CSetMap.find v !cache\n with Not_found ->\n let l =\n Cset.fold_right\n s\n ~f:(fun (i, j) l -> Cset.union (cseq (Bytes.get cm i)\n (Bytes.get cm j)) l)\n ~init:Cset.empty\n in\n cache := Cset.CSetMap.add v l !cache;\n l\n\n(****)\n\ntype regexp =\n Set of Cset.t\n | Sequence of regexp list\n | Alternative of regexp list\n | Repeat of regexp * int * int option\n | Beg_of_line | End_of_line\n | Beg_of_word | End_of_word | Not_bound\n | Beg_of_str | End_of_str\n | Last_end_of_line | Start | Stop\n | Sem of Automata.sem * regexp\n | Sem_greedy of Automata.rep_kind * regexp\n | Group of regexp | No_group of regexp | Nest of regexp\n | Case of regexp | No_case of regexp\n | Intersection of regexp list\n | Complement of regexp list\n | Difference of regexp * regexp\n | Pmark of Pmark.t * regexp\n\nmodule View = struct\n type t = regexp =\n Set of Cset.t\n | Sequence of regexp list\n | Alternative of regexp list\n | Repeat of regexp * int * int option\n | Beg_of_line | End_of_line\n | Beg_of_word | End_of_word | Not_bound\n | Beg_of_str | End_of_str\n | Last_end_of_line | Start | Stop\n | Sem of Automata.sem * regexp\n | Sem_greedy of Automata.rep_kind * regexp\n | Group of regexp | No_group of regexp | Nest of regexp\n | Case of regexp | No_case of regexp\n | Intersection of regexp list\n | Complement of regexp list\n | Difference of regexp * regexp\n | Pmark of Pmark.t * regexp\n\n let view t = t\nend\n\nlet rec pp fmt t =\n let open Fmt in\n let var s re = sexp fmt s pp re in\n let seq s rel = sexp fmt s (list pp) rel in\n match t with\n | Set s -> sexp fmt \"Set\" Cset.pp s\n | Sequence sq -> seq \"Sequence\" sq\n | Alternative alt -> seq \"Alternative\" alt\n | Repeat (re, start, stop) ->\n let pp' fmt () = fprintf fmt \"%a@ %d%a\" pp re start optint stop in\n sexp fmt \"Repeat\" pp' ()\n | Beg_of_line -> str fmt \"Beg_of_line\"\n | End_of_line -> str fmt \"End_of_line\"\n | Beg_of_word -> str fmt \"Beg_of_word\"\n | End_of_word -> str fmt \"End_of_word\"\n | Not_bound -> str fmt \"Not_bound\"\n | Beg_of_str -> str fmt \"Beg_of_str\"\n | End_of_str -> str fmt \"End_of_str\"\n | Last_end_of_line -> str fmt \"Last_end_of_line\"\n | Start -> str fmt \"Start\"\n | Stop -> str fmt \"Stop\"\n | Sem (sem, re) ->\n sexp fmt \"Sem\" (pair Automata.pp_sem pp) (sem, re)\n | Sem_greedy (k, re) ->\n sexp fmt \"Sem_greedy\" (pair Automata.pp_rep_kind pp) (k, re)\n | Group c -> var \"Group\" c\n | No_group c -> var \"No_group\" c\n | Nest c -> var \"Nest\" c\n | Case c -> var \"Case\" c\n | No_case c -> var \"No_case\" c\n | Intersection c -> seq \"Intersection\" c\n | Complement c -> seq \"Complement\" c\n | Difference (a, b) -> sexp fmt \"Difference\" (pair pp pp) (a, b)\n | Pmark (m, r) -> sexp fmt \"Pmark\" (pair Pmark.pp pp) (m, r)\n\nlet rec is_charset = function\n | Set _ ->\n true\n | Alternative l | Intersection l | Complement l ->\n List.for_all is_charset l\n | Difference (r, r') ->\n is_charset r && is_charset r'\n | Sem (_, r) | Sem_greedy (_, r)\n | No_group r | Case r | No_case r ->\n is_charset r\n | Sequence _ | Repeat _ | Beg_of_line | End_of_line\n | Beg_of_word | End_of_word | Beg_of_str | End_of_str\n | Not_bound | Last_end_of_line | Start | Stop\n | Group _ | Nest _ | Pmark (_,_)->\n false\n\n(*XXX Use a better algorithm allowing non-contiguous regions? *)\n\nlet cupper =\n Cset.union (cseq 'A' 'Z')\n (Cset.union (cseq '\\192' '\\214') (cseq '\\216' '\\222'))\nlet clower = Cset.offset 32 cupper\nlet calpha =\n List.fold_right cadd ['\\170'; '\\181'; '\\186'; '\\223'; '\\255']\n (Cset.union clower cupper)\nlet cdigit = cseq '0' '9'\nlet calnum = Cset.union calpha cdigit\nlet cword = cadd '_' calnum\n\nlet colorize c regexp =\n let lnl = ref false in\n let rec colorize regexp =\n match regexp with\n Set s -> Color_map.split s c\n | Sequence l -> List.iter colorize l\n | Alternative l -> List.iter colorize l\n | Repeat (r, _, _) -> colorize r\n | Beg_of_line | End_of_line -> Color_map.split (Cset.csingle '\\n') c\n | Beg_of_word | End_of_word\n | Not_bound -> Color_map.split cword c\n | Beg_of_str | End_of_str\n | Start | Stop -> ()\n | Last_end_of_line -> lnl := true\n | Sem (_, r)\n | Sem_greedy (_, r)\n | Group r | No_group r\n | Nest r | Pmark (_,r) -> colorize r\n | Case _ | No_case _\n | Intersection _\n | Complement _\n | Difference _ -> assert false\n in\n colorize regexp;\n !lnl\n\n(**** Compilation ****)\n\nlet rec equal x1 x2 =\n match x1, x2 with\n Set s1, Set s2 ->\n s1 = s2\n | Sequence l1, Sequence l2 ->\n eq_list l1 l2\n | Alternative l1, Alternative l2 ->\n eq_list l1 l2\n | Repeat (x1', i1, j1), Repeat (x2', i2, j2) ->\n i1 = i2 && j1 = j2 && equal x1' x2'\n | Beg_of_line, Beg_of_line\n | End_of_line, End_of_line\n | Beg_of_word, Beg_of_word\n | End_of_word, End_of_word\n | Not_bound, Not_bound\n | Beg_of_str, Beg_of_str\n | End_of_str, End_of_str\n | Last_end_of_line, Last_end_of_line\n | Start, Start\n | Stop, Stop ->\n true\n | Sem (sem1, x1'), Sem (sem2, x2') ->\n sem1 = sem2 && equal x1' x2'\n | Sem_greedy (k1, x1'), Sem_greedy (k2, x2') ->\n k1 = k2 && equal x1' x2'\n | Group _, Group _ -> (* Do not merge groups! *)\n false\n | No_group x1', No_group x2' ->\n equal x1' x2'\n | Nest x1', Nest x2' ->\n equal x1' x2'\n | Case x1', Case x2' ->\n equal x1' x2'\n | No_case x1', No_case x2' ->\n equal x1' x2'\n | Intersection l1, Intersection l2 ->\n eq_list l1 l2\n | Complement l1, Complement l2 ->\n eq_list l1 l2\n | Difference (x1', x1''), Difference (x2', x2'') ->\n equal x1' x2' && equal x1'' x2''\n | Pmark (m1, r1), Pmark (m2, r2) ->\n Pmark.equal m1 m2 && equal r1 r2\n | _ ->\n false\n\nand eq_list l1 l2 =\n match l1, l2 with\n [], [] ->\n true\n | x1 :: r1, x2 :: r2 ->\n equal x1 x2 && eq_list r1 r2\n | _ ->\n false\n\nlet sequence = function\n | [x] -> x\n | l -> Sequence l\n\nlet rec merge_sequences = function\n | [] ->\n []\n | Alternative l' :: r ->\n merge_sequences (l' @ r)\n | Sequence (x :: y) :: r ->\n begin match merge_sequences r with\n Sequence (x' :: y') :: r' when equal x x' ->\n Sequence [x; Alternative [sequence y; sequence y']] :: r'\n | r' ->\n Sequence (x :: y) :: r'\n end\n | x :: r ->\n x :: merge_sequences r\n\nmodule A = Automata\n\nlet enforce_kind ids kind kind' cr =\n match kind, kind' with\n `First, `First -> cr\n | `First, k -> A.seq ids k cr (A.eps ids)\n | _ -> cr\n\n(* XXX should probably compute a category mask *)\nlet rec translate ids kind ign_group ign_case greedy pos cache c = function\n | Set s ->\n (A.cst ids (trans_set cache c s), kind)\n | Sequence l ->\n (trans_seq ids kind ign_group ign_case greedy pos cache c l, kind)\n | Alternative l ->\n begin match merge_sequences l with\n [r'] ->\n let (cr, kind') =\n translate ids kind ign_group ign_case greedy pos cache c r' in\n (enforce_kind ids kind kind' cr, kind)\n | merged_sequences ->\n (A.alt ids\n (List.map\n (fun r' ->\n let (cr, kind') =\n translate ids kind ign_group ign_case greedy\n pos cache c r' in\n enforce_kind ids kind kind' cr)\n merged_sequences),\n kind)\n end\n | Repeat (r', i, j) ->\n let (cr, kind') =\n translate ids kind ign_group ign_case greedy pos cache c r' in\n let rem =\n match j with\n None ->\n A.rep ids greedy kind' cr\n | Some j ->\n let f =\n match greedy with\n `Greedy ->\n fun rem ->\n A.alt ids\n [A.seq ids kind' (A.rename ids cr) rem; A.eps ids]\n | `Non_greedy ->\n fun rem ->\n A.alt ids\n [A.eps ids; A.seq ids kind' (A.rename ids cr) rem]\n in\n iter (j - i) f (A.eps ids)\n in\n (iter i (fun rem -> A.seq ids kind' (A.rename ids cr) rem) rem, kind)\n | Beg_of_line ->\n (A.after ids Category.(inexistant ++ newline), kind)\n | End_of_line ->\n (A.before ids Category.(inexistant ++ newline), kind)\n | Beg_of_word ->\n (A.seq ids `First\n (A.after ids Category.(inexistant ++ not_letter))\n (A.before ids Category.(inexistant ++ letter)),\n kind)\n | End_of_word ->\n (A.seq ids `First\n (A.after ids Category.(inexistant ++ letter))\n (A.before ids Category.(inexistant ++ not_letter)),\n kind)\n | Not_bound ->\n (A.alt ids [A.seq ids `First\n (A.after ids Category.letter)\n (A.before ids Category.letter);\n A.seq ids `First\n (A.after ids Category.letter)\n (A.before ids Category.letter)],\n kind)\n | Beg_of_str ->\n (A.after ids Category.inexistant, kind)\n | End_of_str ->\n (A.before ids Category.inexistant, kind)\n | Last_end_of_line ->\n (A.before ids Category.(inexistant ++ lastnewline), kind)\n | Start ->\n (A.after ids Category.search_boundary, kind)\n | Stop ->\n (A.before ids Category.search_boundary, kind)\n | Sem (kind', r') ->\n let (cr, kind'') =\n translate ids kind' ign_group ign_case greedy pos cache c r' in\n (enforce_kind ids kind' kind'' cr,\n kind')\n | Sem_greedy (greedy', r') ->\n translate ids kind ign_group ign_case greedy' pos cache c r'\n | Group r' ->\n if ign_group then\n translate ids kind ign_group ign_case greedy pos cache c r'\n else\n let p = !pos in\n pos := !pos + 2;\n let (cr, kind') =\n translate ids kind ign_group ign_case greedy pos cache c r' in\n (A.seq ids `First (A.mark ids p) (\n A.seq ids `First cr (A.mark ids (p + 1))),\n kind')\n | No_group r' ->\n translate ids kind true ign_case greedy pos cache c r'\n | Nest r' ->\n let b = !pos in\n let (cr, kind') =\n translate ids kind ign_group ign_case greedy pos cache c r'\n in\n let e = !pos - 1 in\n if e < b then\n (cr, kind')\n else\n (A.seq ids `First (A.erase ids b e) cr, kind')\n | Difference _ | Complement _ | Intersection _ | No_case _ | Case _ ->\n assert false\n | Pmark (i, r') ->\n let (cr, kind') =\n translate ids kind ign_group ign_case greedy pos cache c r' in\n (A.seq ids `First (A.pmark ids i) cr, kind')\n\nand trans_seq ids kind ign_group ign_case greedy pos cache c = function\n | [] ->\n A.eps ids\n | [r] ->\n let (cr', kind') =\n translate ids kind ign_group ign_case greedy pos cache c r in\n enforce_kind ids kind kind' cr'\n | r :: rem ->\n let (cr', kind') =\n translate ids kind ign_group ign_case greedy pos cache c r in\n let cr'' =\n trans_seq ids kind ign_group ign_case greedy pos cache c rem in\n if A.is_eps cr'' then\n cr'\n else if A.is_eps cr' then\n cr''\n else\n A.seq ids kind' cr' cr''\n\n(**** Case ****)\n\nlet case_insens s =\n Cset.union s (Cset.union (Cset.offset 32 (Cset.inter s cupper))\n (Cset.offset (-32) (Cset.inter s clower)))\n\nlet as_set = function\n | Set s -> s\n | _ -> assert false\n\n(* XXX Should split alternatives into (1) charsets and (2) more\n complex regular expressions; alternative should therefore probably\n be flatten here *)\nlet rec handle_case ign_case = function\n | Set s ->\n Set (if ign_case then case_insens s else s)\n | Sequence l ->\n Sequence (List.map (handle_case ign_case) l)\n | Alternative l ->\n let l' = List.map (handle_case ign_case) l in\n if is_charset (Alternative l') then\n Set (List.fold_left (fun s r -> Cset.union s (as_set r)) Cset.empty l')\n else\n Alternative l'\n | Repeat (r, i, j) ->\n Repeat (handle_case ign_case r, i, j)\n | Beg_of_line | End_of_line | Beg_of_word | End_of_word | Not_bound\n | Beg_of_str | End_of_str | Last_end_of_line | Start | Stop as r ->\n r\n | Sem (k, r) ->\n let r' = handle_case ign_case r in\n if is_charset r' then r' else Sem (k, r')\n | Sem_greedy (k, r) ->\n let r' = handle_case ign_case r in\n if is_charset r' then r' else Sem_greedy (k, r')\n | Group r ->\n Group (handle_case ign_case r)\n | No_group r ->\n let r' = handle_case ign_case r in\n if is_charset r' then r' else No_group r'\n | Nest r ->\n let r' = handle_case ign_case r in\n if is_charset r' then r' else Nest r'\n | Case r ->\n handle_case false r\n | No_case r ->\n handle_case true r\n | Intersection l ->\n let l' = List.map (fun r -> handle_case ign_case r) l in\n Set (List.fold_left (fun s r -> Cset.inter s (as_set r)) Cset.cany l')\n | Complement l ->\n let l' = List.map (fun r -> handle_case ign_case r) l in\n Set (Cset.diff Cset.cany\n (List.fold_left (fun s r -> Cset.union s (as_set r))\n Cset.empty l'))\n | Difference (r, r') ->\n Set (Cset.inter (as_set (handle_case ign_case r))\n (Cset.diff Cset.cany (as_set (handle_case ign_case r'))))\n | Pmark (i,r) -> Pmark (i,handle_case ign_case r)\n\n(****)\n\nlet compile_1 regexp =\n let regexp = handle_case false regexp in\n let c = Color_map.make () in\n let need_lnl = colorize c regexp in\n let (colors, color_repr, ncolor) = Color_map.flatten c in\n let lnl = if need_lnl then ncolor else -1 in\n let ncolor = if need_lnl then ncolor + 1 else ncolor in\n let ids = A.create_ids () in\n let pos = ref 0 in\n let (r, kind) =\n translate ids\n `First false false `Greedy pos (ref Cset.CSetMap.empty) colors regexp in\n let r = enforce_kind ids `First kind r in\n (*Format.eprintf \"<%d %d>@.\" !ids ncol;*)\n mk_re ~initial:r ~colors ~color_repr ~ncolor ~lnl ~group_count:(!pos / 2)\n\n(****)\n\nlet rec anchored = function\n | Sequence l ->\n List.exists anchored l\n | Alternative l ->\n List.for_all anchored l\n | Repeat (r, i, _) ->\n i > 0 && anchored r\n | Set _ | Beg_of_line | End_of_line | Beg_of_word | End_of_word\n | Not_bound | End_of_str | Last_end_of_line | Stop\n | Intersection _ | Complement _ | Difference _ ->\n false\n | Beg_of_str | Start ->\n true\n | Sem (_, r) | Sem_greedy (_, r) | Group r | No_group r | Nest r\n | Case r | No_case r | Pmark (_, r) ->\n anchored r\n\n(****)\n\ntype t = regexp\n\nlet str s =\n let l = ref [] in\n for i = String.length s - 1 downto 0 do\n l := Set (Cset.csingle s.[i]) :: !l\n done;\n Sequence !l\nlet char c = Set (Cset.csingle c)\n\nlet alt = function\n | [r] -> r\n | l -> Alternative l\nlet seq = function\n | [r] -> r\n | l -> Sequence l\n\nlet empty = alt []\nlet epsilon = seq []\nlet repn r i j =\n if i < 0 then invalid_arg \"Re.repn\";\n begin match j with\n | Some j when j < i -> invalid_arg \"Re.repn\"\n | _ -> ()\n end;\n Repeat (r, i, j)\nlet rep r = repn r 0 None\nlet rep1 r = repn r 1 None\nlet opt r = repn r 0 (Some 1)\nlet bol = Beg_of_line\nlet eol = End_of_line\nlet bow = Beg_of_word\nlet eow = End_of_word\nlet word r = seq [bow; r; eow]\nlet not_boundary = Not_bound\nlet bos = Beg_of_str\nlet eos = End_of_str\nlet whole_string r = seq [bos; r; eos]\nlet leol = Last_end_of_line\nlet start = Start\nlet stop = Stop\nlet longest r = Sem (`Longest, r)\nlet shortest r = Sem (`Shortest, r)\nlet first r = Sem (`First, r)\nlet greedy r = Sem_greedy (`Greedy, r)\nlet non_greedy r = Sem_greedy (`Non_greedy, r)\nlet group r = Group r\nlet no_group r = No_group r\nlet nest r = Nest r\nlet mark r = let i = Pmark.gen () in (i,Pmark (i,r))\n\nlet set str =\n let s = ref Cset.empty in\n for i = 0 to String.length str - 1 do\n s := Cset.union (Cset.csingle str.[i]) !s\n done;\n Set !s\n\nlet rg c c' = Set (cseq c c')\n\nlet inter l =\n let r = Intersection l in\n if is_charset r then\n r\n else\n invalid_arg \"Re.inter\"\n\nlet compl l =\n let r = Complement l in\n if is_charset r then\n r\n else\n invalid_arg \"Re.compl\"\n\nlet diff r r' =\n let r'' = Difference (r, r') in\n if is_charset r'' then\n r''\n else\n invalid_arg \"Re.diff\"\n\nlet any = Set Cset.cany\nlet notnl = Set (Cset.diff Cset.cany (Cset.csingle '\\n'))\n\nlet lower = alt [rg 'a' 'z'; char '\\181'; rg '\\223' '\\246'; rg '\\248' '\\255']\nlet upper = alt [rg 'A' 'Z'; rg '\\192' '\\214'; rg '\\216' '\\222']\nlet alpha = alt [lower; upper; char '\\170'; char '\\186']\nlet digit = rg '0' '9'\nlet alnum = alt [alpha; digit]\nlet wordc = alt [alnum; char '_']\nlet ascii = rg '\\000' '\\127'\nlet blank = set \"\\t \"\nlet cntrl = alt [rg '\\000' '\\031'; rg '\\127' '\\159']\nlet graph = alt [rg '\\033' '\\126'; rg '\\160' '\\255']\nlet print = alt [rg '\\032' '\\126'; rg '\\160' '\\255']\nlet punct =\n alt [rg '\\033' '\\047'; rg '\\058' '\\064'; rg '\\091' '\\096';\n rg '\\123' '\\126'; rg '\\160' '\\169'; rg '\\171' '\\180';\n rg '\\182' '\\185'; rg '\\187' '\\191'; char '\\215'; char '\\247']\nlet space = alt [char ' '; rg '\\009' '\\013']\nlet xdigit = alt [digit; rg 'a' 'f'; rg 'A' 'F']\n\nlet case r = Case r\nlet no_case r = No_case r\n\n(****)\n\nlet compile r =\n compile_1 (\n if anchored r then\n group r\n else\n seq [shortest (rep any); group r]\n )\n\nlet exec_internal name ?(pos=0) ?(len = -1) ~partial ~groups re s =\n if pos < 0 || len < -1 || pos + len > String.length s then\n invalid_arg name;\n match_str ~groups ~partial re s ~pos ~len\n\nlet exec ?pos ?len re s =\n match exec_internal \"Re.exec\" ?pos ?len ~groups:true ~partial:false re s with\n Match substr -> substr\n | _ -> raise Not_found\n\nlet exec_opt ?pos ?len re s =\n match exec_internal \"Re.exec_opt\" ?pos ?len ~groups:true ~partial:false\n re s with\n Match substr -> Some substr\n | _ -> None\n\nlet execp ?pos ?len re s =\n match exec_internal ~groups:false ~partial:false \"Re.execp\" ?pos ?len re s with\n Match _substr -> true\n | _ -> false\n\nlet exec_partial ?pos ?len re s =\n match exec_internal ~groups:false ~partial:true \"Re.exec_partial\"\n ?pos ?len re s with\n Match _ -> `Full\n | Running -> `Partial\n | Failed -> `Mismatch\n\nmodule Mark = struct\n\n type t = Pmark.t\n\n let test (g : Group.t) p =\n Pmark.Set.mem p g.pmarks\n\n let all (g : Group.t) = g.pmarks\n\n module Set = Pmark.Set\n\n let equal = Pmark.equal\n\n let compare = Pmark.compare\n\nend\n\ntype split_token =\n [ `Text of string\n | `Delim of Group.t\n ]\n\nmodule Rseq = struct\n let all ?(pos=0) ?len re s : _ Seq.t =\n if pos < 0 then invalid_arg \"Re.all\";\n (* index of the first position we do not consider.\n !pos < limit is an invariant *)\n let limit = match len with\n | None -> String.length s\n | Some l ->\n if l<0 || pos+l > String.length s then invalid_arg \"Re.all\";\n pos+l\n in\n (* iterate on matches. When a match is found, search for the next\n one just after its end *)\n let rec aux pos () =\n if pos >= limit\n then Seq.Nil (* no more matches *)\n else\n match match_str ~groups:true ~partial:false re s\n ~pos ~len:(limit - pos) with\n | Match substr ->\n let p1, p2 = Group.offset substr 0 in\n let pos = if p1=p2 then p2+1 else p2 in\n Seq.Cons (substr, aux pos)\n | Running\n | Failed -> Seq.Nil\n in\n aux pos\n\n let matches ?pos ?len re s : _ Seq.t =\n all ?pos ?len re s\n |> Seq.map (fun sub -> Group.get sub 0)\n\n let split_full ?(pos=0) ?len re s : _ Seq.t =\n if pos < 0 then invalid_arg \"Re.split\";\n let limit = match len with\n | None -> String.length s\n | Some l ->\n if l<0 || pos+l > String.length s then invalid_arg \"Re.split\";\n pos+l\n in\n (* i: start of delimited string\n pos: first position after last match of [re]\n limit: first index we ignore (!pos < limit is an invariant) *)\n let pos0 = pos in\n let rec aux state i pos () = match state with\n | `Idle when pos >= limit ->\n if i < limit then (\n let sub = String.sub s i (limit - i) in\n Seq.Cons (`Text sub, aux state (i+1) pos)\n ) else Seq.Nil\n | `Idle ->\n begin match match_str ~groups:true ~partial:false re s ~pos\n ~len:(limit - pos) with\n | Match substr ->\n let p1, p2 = Group.offset substr 0 in\n let pos = if p1=p2 then p2+1 else p2 in\n let old_i = i in\n let i = p2 in\n if p1 > pos0 then (\n (* string does not start by a delimiter *)\n let text = String.sub s old_i (p1 - old_i) in\n let state = `Yield (`Delim substr) in\n Seq.Cons (`Text text, aux state i pos)\n ) else Seq.Cons (`Delim substr, aux state i pos)\n | Running -> Seq.Nil\n | Failed ->\n if i < limit\n then (\n let text = String.sub s i (limit - i) in\n (* yield last string *)\n Seq.Cons (`Text text, aux state limit pos)\n ) else\n Seq.Nil\n end\n | `Yield x ->\n Seq.Cons (x, aux `Idle i pos)\n in\n aux `Idle pos pos\n\n let split ?pos ?len re s : _ Seq.t =\n let seq = split_full ?pos ?len re s in\n let rec filter seq () = match seq () with\n | Seq.Nil -> Seq.Nil\n | Seq.Cons (`Delim _, tl) -> filter tl ()\n | Seq.Cons (`Text s,tl) -> Seq.Cons (s, filter tl)\n in filter seq\nend\n\nmodule Rlist = struct\n let list_of_seq (s:'a Seq.t) : 'a list =\n Seq.fold_left (fun l x -> x :: l) [] s |> List.rev\n\n let all ?pos ?len re s = Rseq.all ?pos ?len re s |> list_of_seq\n\n let matches ?pos ?len re s = Rseq.matches ?pos ?len re s |> list_of_seq\n\n let split_full ?pos ?len re s = Rseq.split_full ?pos ?len re s |> list_of_seq\n\n let split ?pos ?len re s = Rseq.split ?pos ?len re s |> list_of_seq\nend\n\nmodule Gen = struct\n type 'a gen = unit -> 'a option\n let gen_of_seq (s:'a Seq.t) : 'a gen =\n let r = ref s in\n fun () -> match !r () with\n | Seq.Nil -> None\n | Seq.Cons (x, tl) ->\n r := tl;\n Some x\n\n let split ?pos ?len re s : _ gen =\n Rseq.split ?pos ?len re s |> gen_of_seq\n\n let split_full ?pos ?len re s : _ gen =\n Rseq.split_full ?pos ?len re s |> gen_of_seq\n\n let all ?pos ?len re s = Rseq.all ?pos ?len re s |> gen_of_seq\n\n let matches ?pos ?len re s = Rseq.matches ?pos ?len re s |> gen_of_seq\nend\n\nlet replace ?(pos=0) ?len ?(all=true) re ~f s =\n if pos < 0 then invalid_arg \"Re.replace\";\n let limit = match len with\n | None -> String.length s\n | Some l ->\n if l<0 || pos+l > String.length s then invalid_arg \"Re.replace\";\n pos+l\n in\n (* buffer into which we write the result *)\n let buf = Buffer.create (String.length s) in\n (* iterate on matched substrings. *)\n let rec iter pos =\n if pos < limit\n then\n match match_str ~groups:true ~partial:false re s ~pos ~len:(limit-pos) with\n | Match substr ->\n let p1, p2 = Group.offset substr 0 in\n (* add string between previous match and current match *)\n Buffer.add_substring buf s pos (p1-pos);\n (* what should we replace the matched group with? *)\n let replacing = f substr in\n Buffer.add_string buf replacing;\n if all then\n (* if we matched a non-char e.g. ^ we must manually advance by 1 *)\n iter (\n if p1=p2 then (\n (* a non char could be past the end of string. e.g. $ *)\n if p2 < limit then Buffer.add_char buf s.[p2];\n p2+1\n ) else\n p2)\n else\n Buffer.add_substring buf s p2 (limit-p2)\n | Running -> ()\n | Failed ->\n Buffer.add_substring buf s pos (limit-pos)\n in\n iter pos;\n Buffer.contents buf\n\nlet replace_string ?pos ?len ?all re ~by s =\n replace ?pos ?len ?all re s ~f:(fun _ -> by)\n\nlet witness t =\n let rec witness = function\n | Set c -> String.make 1 (Char.chr (Cset.pick c))\n | Sequence xs -> String.concat \"\" (List.map witness xs)\n | Alternative (x :: _) -> witness x\n | Alternative [] -> assert false\n | Repeat (r, from, _to) ->\n let w = witness r in\n let b = Buffer.create (String.length w * from) in\n for _i=1 to from do\n Buffer.add_string b w\n done;\n Buffer.contents b\n | No_case r -> witness r\n | Intersection _\n | Complement _\n | Difference (_, _) -> assert false\n | Group r\n | No_group r\n | Nest r\n | Sem (_, r)\n | Pmark (_, r)\n | Case r\n | Sem_greedy (_, r) -> witness r\n | Beg_of_line\n | End_of_line\n | Beg_of_word\n | End_of_word\n | Not_bound\n | Beg_of_str\n | Last_end_of_line\n | Start\n | Stop\n | End_of_str -> \"\" in\n witness (handle_case false t)\n\ntype 'a seq = 'a Seq.t\nmodule Seq = Rseq\nmodule List = Rlist\nmodule Group = Group\n\n(** {2 Deprecated functions} *)\n\ntype 'a gen = 'a Gen.gen\nlet all_gen = Gen.all\nlet matches_gen = Gen.matches\nlet split_gen = Gen.split\nlet split_full_gen = Gen.split_full\n\nlet all_seq = Seq.all\nlet matches_seq = Seq.matches\nlet split_seq = Seq.split\nlet split_full_seq = Seq.split_full\n\n\ntype substrings = Group.t\n\nlet get = Group.get\nlet get_ofs = Group.offset\nlet get_all = Group.all\nlet get_all_ofs = Group.all_offset\nlet test = Group.test\n\ntype markid = Mark.t\n\nlet marked = Mark.test\nlet mark_set = Mark.all\n\n(**********************************)\n\n(*\nInformation about the previous character:\n- does not exists\n- is a letter\n- is not a letter\n- is a newline\n- is last newline\n\nBeginning of word:\n- previous is not a letter or does not exist\n- current is a letter or does not exist\n\nEnd of word:\n- previous is a letter or does not exist\n- current is not a letter or does not exist\n\nBeginning of line:\n- previous is a newline or does not exist\n\nBeginning of buffer:\n- previous does not exist\n\nEnd of buffer\n- current does not exist\n\nEnd of line\n- current is a newline or does not exist\n*)\n\n(*\nRep: e = T,e | ()\n - semantics of the comma (shortest/longest/first)\n - semantics of the union (greedy/non-greedy)\n\nBounded repetition\n a{0,3} = (a,(a,a?)?)?\n*)\n\ntype groups = Group.t\n\ninclude Rlist\n","include Ast\n\nlet string_of_pos (pos : Lexing.position) =\n Format.sprintf \"Line %d col %d\" pos.pos_lnum (pos.pos_cnum - pos.pos_bol + 1)\n\nlet parse s =\n let lexbuf = Lexing.from_string s in\n try Ok (Parser.doc Lexer.token lexbuf) with\n | Parser.Error ->\n let pos = lexbuf.lex_start_p in\n Error (Format.sprintf \"%s: Syntax error\" (string_of_pos pos))\n | Lexer.Error msg ->\n let pos = lexbuf.lex_curr_p in\n Error (Format.sprintf \"%s: %s\" (string_of_pos pos) msg)\n","open Core_kernel\nopen Fieldslib\n\nmodule Js_layout = struct\n module Input = struct\n type 'a t =\n < js_layout : [> `Assoc of (string * Yojson.Safe.t) list ] ref ; .. >\n as\n 'a\n end\n\n module Accumulator = struct\n type field = { key : string; value : Yojson.Safe.t; docs : Yojson.Safe.t }\n\n let to_key ({ key; _ } : field) = `String key\n\n let to_entry ({ key; value; _ } : field) : string * Yojson.Safe.t =\n (key, value)\n\n let to_doc_entry ({ key; docs; _ } : field) : string * Yojson.Safe.t =\n (key, docs)\n\n type 'a t = < js_layout_accumulator : field option list ref ; .. > as 'a\n constraint 'a t = 'a Input.t\n end\n\n let docs (s : Fields_derivers.Annotations.Fields.T.t) : Yojson.Safe.t =\n match s.doc with Some t -> `String t | None -> `Null\n\n let add_field ~t_fields_annots t_field field (acc : _ Accumulator.t) :\n _ * _ Accumulator.t =\n let annotations =\n Fields_derivers.Annotations.Fields.of_annots t_fields_annots\n (Field.name field)\n in\n let rest = !(acc#js_layout_accumulator) in\n let key =\n Option.value annotations.name\n ~default:(Fields_derivers.name_under_to_camel field)\n in\n let value = !(t_field#js_layout) in\n let new_field =\n if annotations.skip || !(t_field#skip) then None\n else Some Accumulator.{ key; value; docs = docs annotations }\n in\n acc#js_layout_accumulator := new_field :: rest ;\n ((fun _ -> failwith \"Unused\"), acc)\n\n let finish name ~t_toplevel_annots (_creator, obj) =\n let annotations =\n Fields_derivers.Annotations.Top.of_annots ~name t_toplevel_annots\n in\n let accumulator =\n List.filter_map ~f:Fn.id !(obj#js_layout_accumulator) |> List.rev\n in\n obj#js_layout :=\n `Assoc\n [ (\"type\", `String \"object\")\n ; (\"name\", `String annotations.name)\n ; ( \"docs\"\n , match annotations.doc with Some s -> `String s | None -> `Null )\n ; (\"keys\", `List (List.map ~f:Accumulator.to_key accumulator))\n ; (\"entries\", `Assoc (List.map ~f:Accumulator.to_entry accumulator))\n ; ( \"docEntries\"\n , `Assoc (List.map ~f:Accumulator.to_doc_entry accumulator) )\n ] ;\n obj\n\n type leaf_type =\n | String\n | Number\n | Null\n | Field\n | Bool\n | UInt32\n | UInt64\n | PublicKey\n | Sign\n | Custom of string\n\n let leaf_type_to_string = function\n | String ->\n \"string\"\n | Number ->\n \"number\"\n | Null ->\n \"null\"\n | Field ->\n \"Field\"\n | Bool ->\n \"Bool\"\n | UInt32 ->\n \"UInt32\"\n | UInt64 ->\n \"UInt64\"\n | PublicKey ->\n \"PublicKey\"\n | Sign ->\n \"Sign\"\n | Custom s ->\n s\n\n type option_type =\n | Flagged_option\n | Closed_interval of (string * string)\n | Or_undefined\n\n let leaf_type (s : leaf_type) =\n `Assoc [ (\"type\", `String (leaf_type_to_string s)) ]\n\n let of_layout layout obj =\n obj#js_layout := layout ;\n obj\n\n let skip obj =\n obj#skip := true ;\n obj#js_layout := leaf_type Null ;\n obj\n\n let int obj =\n obj#js_layout := leaf_type Number ;\n obj\n\n let string obj =\n obj#js_layout := leaf_type String ;\n obj\n\n let bool obj =\n obj#js_layout := leaf_type Bool ;\n obj\n\n let list ?static_length x obj : _ Input.t =\n let inner = !(x#js_layout) in\n let static_length =\n match static_length with Some length -> `Int length | None -> `Null\n in\n obj#js_layout :=\n `Assoc\n [ (\"type\", `String \"array\")\n ; (\"inner\", inner)\n ; (\"staticLength\", static_length)\n ] ;\n obj\n\n let record (entries : (string * 'a) list) (obj : _ Input.t) : _ Input.t =\n obj#js_layout :=\n `Assoc\n [ (\"type\", `String \"object\")\n ; (\"name\", `String \"Anonymous\")\n ; (\"docs\", `Null)\n ; (\"keys\", `List (List.map ~f:(fun (key, _) -> `String key) entries))\n ; ( \"entries\"\n , `Assoc (List.map ~f:(fun (key, inner) -> (key, inner)) entries) )\n ; ( \"docEntries\"\n , `Assoc (List.map ~f:(fun (key, _) -> (key, `String \"\")) entries) )\n ] ;\n obj\n\n let option x obj ~(js_type : option_type) : _ Input.t =\n let inner = !(x#js_layout) in\n let layout =\n match js_type with\n | Flagged_option ->\n `Assoc\n [ (\"type\", `String \"option\")\n ; (\"optionType\", `String \"flaggedOption\")\n ; (\"inner\", inner)\n ]\n | Closed_interval (min, max) ->\n `Assoc\n [ (\"type\", `String \"option\")\n ; (\"optionType\", `String \"closedInterval\")\n ; (\"rangeMin\", `String min)\n ; (\"rangeMax\", `String max)\n ; (\"inner\", inner)\n ]\n | Or_undefined ->\n `Assoc\n [ (\"type\", `String \"option\")\n ; (\"optionType\", `String \"orUndefined\")\n ; (\"inner\", inner)\n ]\n in\n obj#js_layout := layout ;\n obj\n\n let wrapped x obj =\n obj#js_layout := !(x#js_layout) ;\n obj\n\n let needs_custom_js ~name (x : _ Input.t) (obj : _ Input.t) =\n match !(obj#js_layout) with\n | `Assoc layout ->\n obj#js_layout :=\n `Assoc\n ( layout\n @ [ (\"checkedType\", !(x#js_layout))\n ; (\"checkedTypeName\", `String name)\n ] ) ;\n obj\n | _ ->\n failwith \"impossible\"\nend\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Snark_params.Tick\n\n[%%ifdef consensus_mechanism]\n\nopen Snark_bits\n\n[%%endif]\n\nmodule type Data_hash_descriptor = sig\n val version_byte : char\n\n val description : string\nend\n\nmodule type Basic = sig\n type t = Field.t [@@deriving sexp, yojson]\n\n val to_decimal_string : t -> string\n\n val of_decimal_string : string -> t\n\n val to_bytes : t -> string\n\n [%%ifdef consensus_mechanism]\n\n val gen : t Quickcheck.Generator.t\n\n type var\n\n val var_to_hash_packed : var -> Random_oracle.Checked.Digest.t\n\n val var_to_input : var -> Field.Var.t Random_oracle.Input.Chunked.t\n\n val var_to_bits : var -> Boolean.var list Checked.t\n\n val typ : (var, t) Typ.t\n\n val assert_equal : var -> var -> unit Checked.t\n\n val equal_var : var -> var -> Boolean.var Checked.t\n\n val var_of_t : t -> var\n\n (* TODO : define bit ops using Random_oracle instead of Pedersen.Digest,\n move this outside of consensus_mechanism guard\n *)\n include Bits_intf.S with type t := t\n\n [%%endif]\n\n val to_base58_check : t -> string\n\n val of_base58_check : string -> t Base.Or_error.t\n\n val of_base58_check_exn : string -> t\n\n val to_input : t -> Field.t Random_oracle.Input.Chunked.t\nend\n\nmodule type Full_size = sig\n include Basic\n\n include Comparable.S with type t := t\n\n include Hashable with type t := t\n\n [%%ifdef consensus_mechanism]\n\n val if_ : Boolean.var -> then_:var -> else_:var -> var Checked.t\n\n val var_of_hash_packed : Random_oracle.Checked.Digest.t -> var\n\n val var_to_field : var -> Random_oracle.Checked.Digest.t\n\n [%%endif]\n\n val of_hash : Field.t -> t\n\n val to_field : t -> Field.t\nend\n","module type S = sig\n open Async_kernel\n open Core_kernel\n open Snark_params\n open Snark_bits\n\n module Time : sig\n type t [@@deriving sexp, compare, yojson]\n\n val zero : t\n\n val max_value : t\n\n include Comparable.S with type t := t\n\n include Hashable.S with type t := t\n\n module Controller : sig\n type t [@@deriving sexp, equal, compare]\n\n val create : t -> t\n\n val basic : logger:Logger.t -> t\n\n (** Override the time offset set by the [MINA_TIME_OFFSET] environment\n variable for all block time controllers.\n [enable_setting_offset] must have been called first, and\n [disable_setting_offset] must not have been called, otherwise this\n raises a [Failure].\n *)\n val set_time_offset : Time.Span.t -> unit\n\n (** Get the current time offset, either from the [MINA_TIME_OFFSET]\n environment variable, or as last set by [set_time_offset].\n *)\n val get_time_offset : logger:Logger.t -> Time.Span.t\n\n (** Disallow setting the time offset. This should be run at every\n entrypoint which does not explicitly need to update the time offset.\n *)\n val disable_setting_offset : unit -> unit\n\n (** Allow setting the time offset. This may only be run if\n [disable_setting_offset] has not already been called, otherwise it will\n raise a [Failure].\n *)\n val enable_setting_offset : unit -> unit\n end\n\n [%%versioned:\n module Stable : sig\n [@@@no_toplevel_latest_type]\n\n module V1 : sig\n type nonrec t = t [@@deriving sexp, compare, equal, hash, yojson]\n\n include Hashable.S with type t := t\n end\n end]\n\n module Bits : Bits_intf.Convertible_bits with type t := t\n\n include\n Tick.Snarkable.Bits.Faithful\n with type Unpacked.value = t\n and type Packed.value = t\n and type Packed.var = private Tick.Field.Var.t\n\n val to_input : t -> Tick.Field.t Random_oracle_input.Chunked.t\n\n module Checked : sig\n open Snark_params.Tick\n\n type t\n\n val typ : (t, Stable.Latest.t) Typ.t\n\n val to_input : t -> Field.Var.t Random_oracle_input.Chunked.t\n\n val ( = ) : t -> t -> Boolean.var Checked.t\n\n val ( < ) : t -> t -> Boolean.var Checked.t\n\n val ( > ) : t -> t -> Boolean.var Checked.t\n\n val ( <= ) : t -> t -> Boolean.var Checked.t\n\n val ( >= ) : t -> t -> Boolean.var Checked.t\n\n val to_field : t -> Field.Var.t\n\n module Unsafe : sig\n val of_field : Field.Var.t -> t\n end\n end\n\n module Span : sig\n type t [@@deriving sexp, compare, equal, yojson]\n\n module Stable : sig\n module V1 : sig\n type nonrec t = t\n [@@deriving bin_io, equal, sexp, compare, hash, yojson, version]\n end\n end\n\n val of_time_span : Time.Span.t -> t\n\n val to_time_span : t -> Time.Span.t\n\n module Bits : Bits_intf.Convertible_bits with type t := t\n\n include\n Tick.Snarkable.Bits.Faithful\n with type Unpacked.value = t\n and type Packed.value = t\n\n val to_time_ns_span : t -> Core_kernel.Time_ns.Span.t\n\n val of_time_ns_span : Core_kernel.Time_ns.Span.t -> t\n\n val to_string_hum : t -> string\n\n val to_ms : t -> Int64.t\n\n val of_ms : Int64.t -> t\n\n val ( + ) : t -> t -> t\n\n val ( - ) : t -> t -> t\n\n val ( * ) : t -> t -> t\n\n val ( < ) : t -> t -> bool\n\n val ( > ) : t -> t -> bool\n\n val ( = ) : t -> t -> bool\n\n val ( <= ) : t -> t -> bool\n\n val ( >= ) : t -> t -> bool\n\n val min : t -> t -> t\n\n val zero : t\n\n val to_input : t -> Tick.Field.t Random_oracle_input.Chunked.t\n\n module Checked : sig\n type t\n\n val typ : (t, Stable.V1.t) Snark_params.Tick.Typ.t\n\n open Snark_params.Tick\n\n val to_input : t -> Tick.Field.Var.t Random_oracle_input.Chunked.t\n\n val to_field : t -> Field.Var.t\n\n module Unsafe : sig\n val of_field : Field.Var.t -> t\n end\n end\n end\n\n val field_var_to_unpacked : Tick.Field.Var.t -> Unpacked.var Tick.Checked.t\n\n val diff_checked :\n Unpacked.var -> Unpacked.var -> Span.Unpacked.var Tick.Checked.t\n\n val unpacked_to_number : Span.Unpacked.var -> Tick.Number.t\n\n val add : t -> Span.t -> t\n\n val diff : t -> t -> Span.t\n\n val sub : t -> Span.t -> t\n\n val to_span_since_epoch : t -> Span.t\n\n val of_span_since_epoch : Span.t -> t\n\n val modulus : t -> Span.t -> Span.t\n\n val of_time : Time.t -> t\n\n val to_time_exn : t -> Time.t\n\n val now : Controller.t -> t\n\n val to_int64 : t -> Int64.t\n\n val of_int64 : Int64.t -> t\n\n val of_uint64 : Unsigned.UInt64.t -> t\n\n val to_uint64 : t -> Unsigned.UInt64.t\n\n val of_time_ns : Time_ns.t -> t\n\n val to_string_exn : t -> string\n\n (** Strip time offset *)\n val to_string_system_time_exn : Controller.t -> t -> string\n\n (** Strip time offset *)\n val to_system_time : Controller.t -> t -> t\n\n val of_string_exn : string -> t\n\n val gen_incl : t -> t -> t Quickcheck.Generator.t\n\n val gen : t Quickcheck.Generator.t\n end\n\n include module type of Time with type t = Time.t\n\n module Timeout : sig\n type 'a t\n\n type time\n\n val create : Controller.t -> Span.t -> f:(time -> 'a) -> 'a t\n\n val to_deferred : 'a t -> 'a Async_kernel.Deferred.t\n\n val peek : 'a t -> 'a option\n\n val cancel : Controller.t -> 'a t -> 'a -> unit\n\n val remaining_time : 'a t -> Span.t\n\n val await :\n timeout_duration:Span.t\n -> Controller.t\n -> 'a Deferred.t\n -> [ `Ok of 'a | `Timeout ] Deferred.t\n\n val await_exn :\n timeout_duration:Span.t -> Controller.t -> 'a Deferred.t -> 'a Deferred.t\n end\n with type time := t\nend\n","(* quickcheck_lib.ml *)\n\nopen Core_kernel\nopen Quickcheck.Generator\nopen Quickcheck.Let_syntax\n\nlet of_array array = Quickcheck.Generator.of_list @@ Array.to_list array\n\nlet rec map_gens ls ~f =\n match ls with\n | [] ->\n return []\n | h :: t ->\n let%bind h' = f h in\n let%map t' = map_gens t ~f in\n h' :: t'\n\nlet replicate_gen g n = map_gens (List.init n ~f:Fn.id) ~f:(Fn.const g)\n\nlet init_gen ~f n =\n let rec go : 'a list -> int -> 'a list Quickcheck.Generator.t =\n fun xs n' ->\n if n' < n then f n' >>= fun x -> go (x :: xs) (n' + 1)\n else return @@ List.rev xs\n in\n go [] 0\n\nlet init_gen_array ~f n = map ~f:Array.of_list @@ init_gen ~f n\n\nlet gen_pair g =\n let%map a = g and b = g in\n (a, b)\n\nlet shuffle_arr_inplace arr =\n (* Fisher-Yates shuffle, you need fast swaps for decent performance, so we\n want an array if we're not getting unnecessarily fancy. *)\n let rec go n =\n if n < Array.length arr then (\n let%bind swap_idx = Int.gen_uniform_incl n (Array.length arr - 1) in\n Array.swap arr n swap_idx ;\n go (n + 1) )\n else return arr\n in\n go 0\n\nlet shuffle_arr arr = shuffle_arr_inplace @@ Array.copy arr\n\nlet shuffle list =\n Array.of_list list |> shuffle_arr_inplace |> map ~f:Array.to_list\n\n(* Generate a list with a Dirichlet distribution, used for coming up with random\n splits of a quantity. Symmetric Dirichlet distribution with alpha = 1.\n*)\nlet gen_symm_dirichlet : int -> float list Quickcheck.Generator.t =\n fun n ->\n let open Quickcheck.Generator.Let_syntax in\n let%map gammas =\n map_gens\n (List.init n ~f:(Fn.const ()))\n ~f:(fun _ ->\n let open Quickcheck.Generator.Let_syntax in\n (* technically this should be (0, 1] and not (0, 1) but I expect it\n doesn't matter for our purposes. *)\n let%map uniform = Float.gen_uniform_excl 0. 1. in\n Float.log uniform )\n in\n let sum = List.fold gammas ~init:0. ~f:(fun x y -> x +. y) in\n List.map gammas ~f:(fun gamma -> gamma /. sum)\n\nmodule type Int_s = sig\n type t\n\n val zero : t\n\n val ( + ) : t -> t -> t\n\n val ( - ) : t -> t -> t\n\n val ( > ) : t -> t -> bool\n\n val of_int : int -> t\n\n val to_int : t -> int\nend\n\nlet gen_division_generic (type t) (module M : Int_s with type t = t) (n : t)\n (k : int) : M.t list Quickcheck.Generator.t =\n if k = 0 then Quickcheck.Generator.return []\n else\n let open Quickcheck.Generator.Let_syntax in\n (* Using a symmetric Dirichlet distribution with concentration parameter 1\n defined above gives a distribution with uniform probability density over\n all possible splits of the quantity. See the Wikipedia article for some\n more detail: https://en.wikipedia.org/wiki/Dirichlet_distribution,\n particularly the sections about the flat Dirichlet distribution and\n string cutting.\n *)\n let%bind dirichlet = gen_symm_dirichlet k in\n let n_float = Float.of_int @@ M.to_int n in\n let float_to_mt : float -> t =\n fun fl ->\n match Float.iround_down fl with\n | Some int ->\n M.of_int int\n | None ->\n failwith \"gen_division_generic: out of range\"\n in\n let res = List.map dirichlet ~f:(fun x -> float_to_mt @@ (x *. n_float)) in\n let total = List.fold res ~f:M.( + ) ~init:M.zero in\n return\n ( match res with\n | [] ->\n failwith\n \"empty result list in gen_symm_dirichlet, this should be \\\n impossible. \"\n | head :: rest ->\n (* Going through floating point land may have caused some rounding error. We\n tack it onto the first result so that the sum of the output is equal to n.\n *)\n if M.( > ) n total then M.(head + (n - total)) :: rest\n else M.(head - (total - n)) :: rest )\n\nlet gen_division = gen_division_generic (module Int)\n\nlet gen_division_currency =\n gen_division_generic\n ( module struct\n include Currency.Amount\n\n let ( + ) a b = Option.value_exn (a + b)\n\n let ( - ) a b = Option.value_exn (a - b)\n\n let of_int = of_nanomina_int_exn\n\n let to_int = to_nanomina_int\n end )\n\nlet imperative_fixed_point root ~f =\n let%map f' = fixed_point f in\n f' root\n\nlet gen_imperative_rose_tree ?(p = 0.75) (root_gen : 'a t)\n (node_gen : ('a -> 'a) t) =\n let%bind root = root_gen in\n imperative_fixed_point root ~f:(fun self ->\n match%bind size with\n | 0 ->\n return (fun parent -> Rose_tree.T (parent, []))\n | n ->\n let%bind fork_count = geometric ~p 1 >>| Int.max n in\n let%bind fork_sizes = gen_division n fork_count in\n let positive_fork_sizes =\n List.filter fork_sizes ~f:(fun s -> s > 0)\n in\n let%map forks =\n map_gens positive_fork_sizes ~f:(fun s ->\n tuple2 node_gen (with_size ~size:(s - 1) self) )\n in\n fun parent ->\n Rose_tree.T\n (parent, List.map forks ~f:(fun (this, f) -> f (this parent))) )\n\nlet gen_imperative_ktree ?(p = 0.75) (root_gen : 'a t) (node_gen : ('a -> 'a) t)\n =\n let%bind root = root_gen in\n imperative_fixed_point root ~f:(fun self ->\n match%bind size with\n | 0 ->\n return (fun _ -> [])\n (* this case is optional but more effecient *)\n | 1 ->\n let%map this = node_gen in\n fun parent -> [ this parent ]\n | n ->\n let%bind this = node_gen in\n let%bind fork_count = geometric ~p 1 >>| Int.max n in\n let%bind fork_sizes = gen_division (n - 1) fork_count in\n let%map forks =\n map_gens fork_sizes ~f:(fun s -> with_size ~size:s self)\n in\n fun parent ->\n let x = this parent in\n x :: List.bind forks ~f:(fun f -> f x) )\n\nlet gen_imperative_list (root_gen : 'a t) (node_gen : ('a -> 'a) t) =\n let%bind root = root_gen in\n imperative_fixed_point root ~f:(fun self ->\n match%bind size with\n | 0 ->\n return (fun _ -> [])\n | n ->\n let%bind this = node_gen in\n let%map f = with_size ~size:(n - 1) self in\n fun parent -> parent :: f (this parent) )\n\nlet%test_module \"Quickcheck lib tests\" =\n ( module struct\n let%test_unit \"gen_imperative_list\" =\n let increment = ( + ) 2 in\n let root = 1 in\n let root_gen = return root in\n let gen =\n Int.gen_incl 2 100\n >>= fun size ->\n Quickcheck.Generator.with_size ~size\n (gen_imperative_list root_gen (return increment))\n in\n Quickcheck.test gen ~f:(fun list ->\n match list with\n | [] ->\n failwith \"We assume that our list has at least one element\"\n | x :: xs ->\n assert (x = root) ;\n let result =\n List.fold_result xs ~init:x ~f:(fun elem next_elem ->\n if next_elem = increment elem then Result.return next_elem\n else\n Or_error.errorf\n !\"elements do not add up correctly %d %d\"\n elem next_elem )\n in\n assert (Result.is_ok result) )\n end )\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\n\nlet field_of_bool =\n Snark_params.Tick.(fun b -> if b then Field.one else Field.zero)\n\nlet bit_length_to_triple_length n =\n let r = n mod 3 in\n let k = n / 3 in\n if r = 0 then k else k + 1\n\nlet split_last_exn =\n let rec go acc x xs =\n match xs with [] -> (List.rev acc, x) | x' :: xs -> go (x :: acc) x' xs\n in\n function [] -> failwith \"split_last: Empty list\" | x :: xs -> go [] x xs\n\nlet two_to_the i = Bignum_bigint.(pow (of_int 2) (of_int i))\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Mina_base_import\n\nmodule type S = sig\n module Digest : sig\n [%%versioned:\n module Stable : sig\n module V1 : sig\n type t [@@deriving sexp, equal, compare, hash, yojson]\n end\n end]\n\n val of_field : Snark_params.Tick.Field.t -> t\n\n val to_field_unsafe : t -> Snark_params.Tick.Field.t\n\n include Stringable.S with type t := t\n\n (* so we can easily import these into Token_id *)\n module Binables : sig\n include Comparable_binable with type t := t\n\n include Hashable_binable with type t := t\n end\n\n include module type of Binables\n\n val to_input : t -> Snark_params.Tick.Field.t Random_oracle.Input.Chunked.t\n\n val default : t\n\n val gen : t Quickcheck.Generator.t\n\n val gen_non_default : t Quickcheck.Generator.t\n\n [%%ifdef consensus_mechanism]\n\n module Checked : sig\n open Pickles.Impls.Step\n\n type t\n\n val to_input : t -> Field.t Random_oracle.Input.Chunked.t\n\n val constant : Stable.Latest.t -> t\n\n val equal : t -> t -> Boolean.var\n\n val if_ : Boolean.var -> then_:t -> else_:t -> t\n\n val of_field : Pickles.Impls.Step.Field.t -> t\n\n val to_field_unsafe : t -> Pickles.Impls.Step.Field.t\n\n module Assert : sig\n val equal : t -> t -> unit\n end\n end\n\n val typ : (Checked.t, t) Snark_params.Tick.Typ.t\n\n [%%endif]\n end\n\n [%%versioned:\n module Stable : sig\n module V2 : sig\n type t [@@deriving sexp, equal, compare, hash, yojson]\n end\n end]\n\n val create : Public_key.Compressed.t -> Digest.t -> t\n\n val derive_token_id : owner:t -> Digest.t\n\n val empty : t\n\n val invalid : t\n\n val public_key : t -> Public_key.Compressed.t\n\n val of_public_key : Public_key.t -> t\n\n val token_id : t -> Digest.t\n\n val to_input : t -> Snark_params.Tick.Field.t Random_oracle.Input.Chunked.t\n\n val gen : t Quickcheck.Generator.t\n\n include Comparable.S with type t := t\n\n include Hashable.S_binable with type t := t\n\n [%%ifdef consensus_mechanism]\n\n type var\n\n val typ : (var, t) Snark_params.Tick.Typ.t\n\n val var_of_t : t -> var\n\n module Checked : sig\n open Snark_params\n open Tick\n\n val create : Public_key.Compressed.var -> Digest.Checked.t -> var\n\n val public_key : var -> Public_key.Compressed.var\n\n val token_id : var -> Digest.Checked.t\n\n val to_input :\n var -> Snark_params.Tick.Field.Var.t Random_oracle.Input.Chunked.t\n\n val equal : var -> var -> Boolean.var Checked.t\n\n val if_ : Boolean.var -> then_:var -> else_:var -> var Checked.t\n\n val derive_token_id : owner:var -> Digest.Checked.t\n end\n\n [%%endif]\nend\n","(* hash_prefix.ml *)\n\ninclude Hash_prefix_states\n","(* data_hash.ml *)\n\ninclude Data_hash_lib.Data_hash\n","open Core_kernel\n\nmodule Legacy_token = Mina_numbers.Nat.Make64 ()\n\n[%%versioned\nmodule Stable = struct\n module V2 = struct\n type t = Account_id.Digest.Stable.V1.t\n [@@deriving sexp, yojson, equal, compare, hash]\n\n let to_latest = Fn.id\n end\n\n (* for transactions in pre-Berkeley hard fork *)\n module V1 = struct\n [@@@with_all_version_tags]\n\n type t = Legacy_token.Stable.V1.t\n [@@deriving sexp, equal, compare, hash, yojson]\n\n let to_latest _ = failwith \"Not implemented\"\n end\nend]\n\n[%%define_locally\nAccount_id.Digest.\n ( default\n , typ\n , to_input\n , gen\n , gen_non_default\n , to_field_unsafe\n , of_field\n , to_string\n , of_string\n , comparator\n , ( <> ) )]\n\ninclude Account_id.Digest.Binables\n\n(* someday, allow this in %%define_locally *)\nmodule Checked = Account_id.Digest.Checked\n\nlet deriver obj =\n (* this doesn't use js_type:Field because it is converted to JSON differently than a normal Field *)\n Fields_derivers_zkapps.iso_string obj ~name:\"TokenId\"\n ~js_type:(Custom \"TokenId\") ~doc:\"String representing a token ID\" ~to_string\n ~of_string:(Fields_derivers_zkapps.except ~f:of_string `Token_id)\n","(** Fee excesses associated with transactions or transitions.\n\n These are represented as a 'left' and 'right' excess, which describe the\n unresolved fee excesses in the fee tokens of the first (or leftmost) and\n last (or rightmost) transactions in the transition.\n\n Assumptions:\n * Transactions are grouped by their fee token.\n * The 'fee transfer' transaction to dispense those fees is part of this\n group.\n * The fee excess for each token is 0 across the group.\n * No transactions with fees paid in another token are executed while the\n previous fee token's excess is non-zero.\n\n By maintaining these assumptions, we can ensure that the un-settled fee\n excesses can be represented by excesses in (at most) 2 tokens.\n Consider, for example, any consecutive subsequence of the transactions\n\n ..[txn@2][ft@2][txn@3][txn@3][ft@3][txn@4][ft@4][txn@5][txn@5][ft@5][txn@6][ft@6]..\n\n where [txn@i] and [ft@i] are transactions and fee transfers respectively\n paid in token i.\n The only groups which may have non-zero fee excesses are those which\n contain the start and end of the subsequence.\n\n The code below also defines a canonical representation where fewer than 2\n tokens have non-zero excesses. See [rebalance] below for details and the\n implementation.\n*)\n\n[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\n\n[%%ifndef consensus_mechanism]\n\nopen Mina_base_import\n\n[%%endif]\n\nopen Currency\n\n[%%ifdef consensus_mechanism]\n\nopen Snark_params\nopen Tick\n\n[%%endif]\n\nmodule Poly = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type ('token, 'fee) t =\n ('token, 'fee) Mina_wire_types.Mina_base.Fee_excess.Poly.V1.t =\n { fee_token_l : 'token\n ; fee_excess_l : 'fee\n ; fee_token_r : 'token\n ; fee_excess_r : 'fee\n }\n [@@deriving compare, equal, hash, sexp, hlist]\n\n let to_yojson token_to_yojson fee_to_yojson\n { fee_token_l; fee_excess_l; fee_token_r; fee_excess_r } =\n `List\n [ `Assoc\n [ (\"token\", token_to_yojson fee_token_l)\n ; (\"amount\", fee_to_yojson fee_excess_l)\n ]\n ; `Assoc\n [ (\"token\", token_to_yojson fee_token_r)\n ; (\"amount\", fee_to_yojson fee_excess_r)\n ]\n ]\n\n let of_yojson token_of_yojson fee_of_yojson = function\n | `List [ `Assoc [ left0; left1 ]; `Assoc [ right0; right1 ] ] -> (\n (* allow for reversed field order: \"be liberal in what you accept\" *)\n let token_and_excess pair0 pair1 =\n match (pair0, pair1) with\n | (\"token\", token), (\"amount\", excess) ->\n Some (token, excess)\n | (\"amount\", excess), (\"token\", token) ->\n Some (token, excess)\n | _ ->\n None\n in\n let left = token_and_excess left0 left1 in\n let right = token_and_excess right0 right1 in\n match (left, right) with\n | Some (fee_token_l, fee_excess_l), Some (fee_token_r, fee_excess_r)\n ->\n let open Result.Let_syntax in\n let%map fee_token_l = token_of_yojson fee_token_l\n and fee_excess_l = fee_of_yojson fee_excess_l\n and fee_token_r = token_of_yojson fee_token_r\n and fee_excess_r = fee_of_yojson fee_excess_r in\n { fee_token_l; fee_excess_l; fee_token_r; fee_excess_r }\n | _ ->\n Error \"Fee_excess.Poly.Stable.V1.t, unexpected JSON field\" )\n | _ ->\n Error \"Fee_excess.Poly.Stable.V1.t\"\n end\n end]\n\n [%%define_locally Stable.Latest.(to_yojson, of_yojson)]\n\n [%%ifdef consensus_mechanism]\n\n let typ (token_typ : ('token_var, 'token) Typ.t)\n (fee_typ : ('fee_var, 'fee) Typ.t) :\n (('token_var, 'fee_var) t, ('token, 'fee) t) Typ.t =\n Typ.of_hlistable\n [ token_typ; fee_typ; token_typ; fee_typ ]\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist\n\n [%%endif]\nend\n\n[%%versioned\nmodule Stable = struct\n module V1 = struct\n type t =\n ( Token_id.Stable.V2.t\n , (Fee.Stable.V1.t, Sgn.Stable.V1.t) Signed_poly.Stable.V1.t )\n Poly.Stable.V1.t\n [@@deriving compare, equal, hash, sexp, yojson]\n\n let to_latest = Fn.id\n end\nend]\n\ntype ('token, 'fee) poly = ('token, 'fee) Poly.t =\n { fee_token_l : 'token\n ; fee_excess_l : 'fee\n ; fee_token_r : 'token\n ; fee_excess_r : 'fee\n }\n[@@deriving compare, equal, hash, sexp]\n\nlet poly_to_yojson = Poly.to_yojson\n\nlet poly_of_yojson = Poly.of_yojson\n\n[%%ifdef consensus_mechanism]\n\ntype var = (Token_id.Checked.t, Fee.Signed.var) poly\n\nlet typ : (var, t) Typ.t = Poly.typ Token_id.typ Fee.Signed.typ\n\nlet var_of_t ({ fee_token_l; fee_excess_l; fee_token_r; fee_excess_r } : t) :\n var =\n { fee_token_l = Token_id.Checked.constant fee_token_l\n ; fee_excess_l = Fee.Signed.Checked.constant fee_excess_l\n ; fee_token_r = Token_id.Checked.constant fee_token_r\n ; fee_excess_r = Fee.Signed.Checked.constant fee_excess_r\n }\n\n[%%endif]\n\nlet to_input { fee_token_l; fee_excess_l; fee_token_r; fee_excess_r } =\n let open Random_oracle.Input.Chunked in\n List.reduce_exn ~f:append\n [ Token_id.to_input fee_token_l\n ; Fee.Signed.to_input fee_excess_l\n ; Token_id.to_input fee_token_r\n ; Fee.Signed.to_input fee_excess_r\n ]\n\n[%%ifdef consensus_mechanism]\n\nlet to_input_checked { fee_token_l; fee_excess_l; fee_token_r; fee_excess_r } =\n let fee_token_l = Token_id.Checked.to_input fee_token_l\n and fee_token_r = Token_id.Checked.to_input fee_token_r in\n let%map fee_excess_l = Fee.Signed.Checked.to_input fee_excess_l\n and fee_excess_r = Fee.Signed.Checked.to_input fee_excess_r in\n List.reduce_exn ~f:Random_oracle.Input.Chunked.append\n [ fee_token_l; fee_excess_l; fee_token_r; fee_excess_r ]\n\nlet assert_equal_checked (t1 : var) (t2 : var) =\n Checked.all_unit\n [ [%with_label_ \"fee_token_l\"] (fun () ->\n make_checked (fun () ->\n Token_id.Checked.Assert.equal t1.fee_token_l t2.fee_token_l ) )\n ; [%with_label_ \"fee_excess_l\"] (fun () ->\n Fee.Signed.Checked.assert_equal t1.fee_excess_l t2.fee_excess_l )\n ; [%with_label_ \"fee_token_r\"] (fun () ->\n make_checked (fun () ->\n Token_id.Checked.Assert.equal t1.fee_token_r t2.fee_token_r ) )\n ; [%with_label_ \"fee_excess_r\"] (fun () ->\n Fee.Signed.Checked.assert_equal t1.fee_excess_r t2.fee_excess_r )\n ]\n\n[%%endif]\n\n(** Eliminate a fee excess, either by combining it with one to the left/right,\n or by checking that it is zero.\n*)\nlet eliminate_fee_excess (fee_token_l, fee_excess_l) (fee_token_m, fee_excess_m)\n (fee_token_r, fee_excess_r) =\n let add_err x y =\n match Fee.Signed.add x y with\n | Some z ->\n Or_error.return z\n | None ->\n Or_error.errorf \"Error adding fees: overflow.\"\n in\n let open Or_error.Let_syntax in\n if\n Token_id.equal fee_token_l fee_token_m\n || Fee.(equal zero) fee_excess_l.Signed_poly.magnitude\n then\n let%map fee_excess_l = add_err fee_excess_l fee_excess_m in\n ((fee_token_m, fee_excess_l), (fee_token_r, fee_excess_r))\n else if\n Token_id.equal fee_token_r fee_token_m\n || Fee.(equal zero fee_excess_r.Signed_poly.magnitude)\n then\n let%map fee_excess_r = add_err fee_excess_r fee_excess_m in\n ((fee_token_l, fee_excess_l), (fee_token_m, fee_excess_r))\n else if Fee.(equal zero) fee_excess_m.Signed_poly.magnitude then\n return ((fee_token_l, fee_excess_l), (fee_token_r, fee_excess_r))\n else\n Or_error.errorf\n !\"Error eliminating fee excess: Excess for token %{sexp: Token_id.t} \\\n %{sexp: Fee.Signed.t} was nonzero\"\n fee_token_m fee_excess_m\n\n[%%ifdef consensus_mechanism]\n\n(* We use field elements instead of a currency type here, under the following\n assumptions:\n * the additions and subtractions performed upon members of the currency\n type do not overflow the field size\n - The currency type is currently 64-bit, which is much smaller than the\n field size.\n * it is acceptable for the currency type to overflow/underflow, as long as\n a subsequent subtraction/addition brings it back into the range for the\n currency type.\n - These situations will be rejected by the unchecked code that checks\n each addition/subtraction, but this superset of that behaviour seems\n well-defined, and is still 'correct' in the sense that currency is\n preserved.\n\n This optimisation saves serveral hundred constraints in the proof by not\n unpacking the result of each arithmetic operation.\n*)\nlet%snarkydef_ eliminate_fee_excess_checked (fee_token_l, fee_excess_l)\n (fee_token_m, fee_excess_m) (fee_token_r, fee_excess_r) =\n let open Tick in\n let open Checked.Let_syntax in\n let combine (fee_token, fee_excess) fee_excess_m =\n let%bind fee_token_equal =\n make_checked (fun () -> Token_id.Checked.equal fee_token fee_token_m)\n in\n let%bind fee_excess_zero =\n Field.(Checked.equal (Var.constant zero)) fee_excess\n in\n let%bind may_move = Boolean.(fee_token_equal ||| fee_excess_zero) in\n let%bind fee_token =\n make_checked (fun () ->\n Token_id.Checked.if_ fee_excess_zero ~then_:fee_token_m\n ~else_:fee_token )\n in\n let%map fee_excess_to_move =\n Field.Checked.if_ may_move ~then_:fee_excess_m\n ~else_:Field.(Var.constant zero)\n in\n ( (fee_token, Field.Var.add fee_excess fee_excess_to_move)\n , Field.Var.sub fee_excess_m fee_excess_to_move )\n in\n (* NOTE: Below, we may update the tokens on both sides, even though we only\n promote the excess to one of them. This differs from the unchecked\n version, but\n * the token may only be changed if it is associated with 0 fee excess\n * any intermediate 0 fee excesses can always be either combined or erased\n in later eliminations\n * a fee excess of 0 on the left or right will have its token erased to the\n default\n *)\n let%bind (fee_token_l, fee_excess_l), fee_excess_m =\n combine (fee_token_l, fee_excess_l) fee_excess_m\n in\n let%bind (fee_token_r, fee_excess_r), fee_excess_m =\n combine (fee_token_r, fee_excess_r) fee_excess_m\n in\n let%map () =\n [%with_label_ \"Fee excess is eliminated\"]\n Field.(fun () -> Checked.Assert.equal (Var.constant zero) fee_excess_m)\n in\n ((fee_token_l, fee_excess_l), (fee_token_r, fee_excess_r))\n\n[%%endif]\n\n(* 'Rebalance' to a canonical form, where\n - if there is only 1 nonzero excess, it is to the left\n - any zero fee excess has the default token\n - if the fee tokens are the same, the excesses are combined\n*)\nlet rebalance ({ fee_token_l; fee_excess_l; fee_token_r; fee_excess_r } : t) =\n let open Or_error.Let_syntax in\n (* Use the same token for both if [fee_excess_l] is zero. *)\n let fee_token_l =\n if Fee.(equal zero) fee_excess_l.magnitude then fee_token_r else fee_token_l\n in\n (* Rebalancing. *)\n let%map fee_excess_l, fee_excess_r =\n if Token_id.equal fee_token_l fee_token_r then\n match Fee.Signed.add fee_excess_l fee_excess_r with\n | Some fee_excess_l ->\n return (fee_excess_l, Fee.Signed.zero)\n | None ->\n Or_error.errorf !\"Error adding fees: overflow\"\n else return (fee_excess_l, fee_excess_r)\n in\n (* Use the default token if the excess is zero.\n This allows [verify_complete_merge] to verify a proof without knowledge of\n the particular fee tokens used.\n *)\n let fee_token_l =\n if Fee.(equal zero) fee_excess_l.magnitude then Token_id.default\n else fee_token_l\n in\n let fee_token_r =\n if Fee.(equal zero) fee_excess_r.magnitude then Token_id.default\n else fee_token_r\n in\n { fee_token_l; fee_excess_l; fee_token_r; fee_excess_r }\n\n[%%ifdef consensus_mechanism]\n\nlet rebalance_checked { fee_token_l; fee_excess_l; fee_token_r; fee_excess_r } =\n let open Checked.Let_syntax in\n (* Use the same token for both if [fee_excess_l] is zero. *)\n let%bind fee_token_l =\n let%bind excess_is_zero =\n Field.(Checked.equal (Var.constant zero) fee_excess_l)\n in\n make_checked (fun () ->\n Token_id.Checked.if_ excess_is_zero ~then_:fee_token_r\n ~else_:fee_token_l )\n in\n (* Rebalancing. *)\n let%bind fee_excess_l, fee_excess_r =\n let%bind tokens_equal =\n make_checked (fun () -> Token_id.Checked.equal fee_token_l fee_token_r)\n in\n let%map amount_to_move =\n Field.Checked.if_ tokens_equal ~then_:fee_excess_r\n ~else_:Field.(Var.constant zero)\n in\n ( Field.Var.add fee_excess_l amount_to_move\n , Field.Var.sub fee_excess_r amount_to_move )\n in\n (* Use the default token if the excess is zero. *)\n let%bind fee_token_l =\n let%bind excess_is_zero =\n Field.(Checked.equal (Var.constant zero) fee_excess_l)\n in\n make_checked (fun () ->\n Token_id.Checked.if_ excess_is_zero\n ~then_:Token_id.(Checked.constant default)\n ~else_:fee_token_l )\n in\n let%map fee_token_r =\n let%bind excess_is_zero =\n Field.(Checked.equal (Var.constant zero) fee_excess_r)\n in\n make_checked (fun () ->\n Token_id.Checked.if_ excess_is_zero\n ~then_:Token_id.(Checked.constant default)\n ~else_:fee_token_r )\n in\n { fee_token_l; fee_excess_l; fee_token_r; fee_excess_r }\n\n[%%endif]\n\n(** Combine the fee excesses from two transitions. *)\nlet combine\n ({ fee_token_l = fee_token1_l\n ; fee_excess_l = fee_excess1_l\n ; fee_token_r = fee_token1_r\n ; fee_excess_r = fee_excess1_r\n } :\n t )\n ({ fee_token_l = fee_token2_l\n ; fee_excess_l = fee_excess2_l\n ; fee_token_r = fee_token2_r\n ; fee_excess_r = fee_excess2_r\n } :\n t ) : t Or_error.t =\n let open Or_error.Let_syntax in\n (* Eliminate fee_excess1_r. *)\n let%bind (fee_token1_l, fee_excess1_l), (fee_token2_l, fee_excess2_l) =\n (* [1l; 1r; 2l; 2r] -> [1l; 2l; 2r] *)\n eliminate_fee_excess\n (fee_token1_l, fee_excess1_l)\n (fee_token1_r, fee_excess1_r)\n (fee_token2_l, fee_excess2_l)\n in\n (* Eliminate fee_excess2_l. *)\n let%bind (fee_token1_l, fee_excess1_l), (fee_token2_r, fee_excess2_r) =\n (* [1l; 2l; 2r] -> [1l; 2r] *)\n eliminate_fee_excess\n (fee_token1_l, fee_excess1_l)\n (fee_token2_l, fee_excess2_l)\n (fee_token2_r, fee_excess2_r)\n in\n rebalance\n { fee_token_l = fee_token1_l\n ; fee_excess_l = fee_excess1_l\n ; fee_token_r = fee_token2_r\n ; fee_excess_r = fee_excess2_r\n }\n\n[%%ifdef consensus_mechanism]\n\nlet%snarkydef_ combine_checked\n { fee_token_l = fee_token1_l\n ; fee_excess_l = fee_excess1_l\n ; fee_token_r = fee_token1_r\n ; fee_excess_r = fee_excess1_r\n }\n { fee_token_l = fee_token2_l\n ; fee_excess_l = fee_excess2_l\n ; fee_token_r = fee_token2_r\n ; fee_excess_r = fee_excess2_r\n } =\n let open Checked.Let_syntax in\n (* Represent amounts as field elements. *)\n let%bind fee_excess1_l = Fee.Signed.Checked.to_field_var fee_excess1_l in\n let%bind fee_excess1_r = Fee.Signed.Checked.to_field_var fee_excess1_r in\n let%bind fee_excess2_l = Fee.Signed.Checked.to_field_var fee_excess2_l in\n let%bind fee_excess2_r = Fee.Signed.Checked.to_field_var fee_excess2_r in\n (* Eliminations. *)\n let%bind (fee_token1_l, fee_excess1_l), (fee_token2_l, fee_excess2_l) =\n (* [1l; 1r; 2l; 2r] -> [1l; 2l; 2r] *)\n [%with_label_ \"Eliminate fee_excess1_r\"] (fun () ->\n eliminate_fee_excess_checked\n (fee_token1_l, fee_excess1_l)\n (fee_token1_r, fee_excess1_r)\n (fee_token2_l, fee_excess2_l) )\n in\n let%bind (fee_token1_l, fee_excess1_l), (fee_token2_r, fee_excess2_r) =\n (* [1l; 2l; 2r] -> [1l; 2r] *)\n [%with_label_ \"Eliminate fee_excess2_l\"] (fun () ->\n eliminate_fee_excess_checked\n (fee_token1_l, fee_excess1_l)\n (fee_token2_l, fee_excess2_l)\n (fee_token2_r, fee_excess2_r) )\n in\n let%bind { fee_token_l; fee_excess_l; fee_token_r; fee_excess_r } =\n rebalance_checked\n { fee_token_l = fee_token1_l\n ; fee_excess_l = fee_excess1_l\n ; fee_token_r = fee_token2_r\n ; fee_excess_r = fee_excess2_r\n }\n in\n let convert_to_currency excess =\n let%bind currency_excess =\n exists Fee.Signed.typ\n ~compute:\n As_prover.(\n let%map excess = read Field.typ excess in\n let is_neg =\n Bigint.test_bit (Bigint.of_field excess) (Field.size_in_bits - 1)\n in\n let sgn = if is_neg then Sgn.Neg else Sgn.Pos in\n let excess =\n if is_neg then Field.(mul (negate one) excess) else excess\n in\n let magnitude =\n (* TODO: Add a native coercion [Bigint -> UInt64] in Snarky's FFI\n bindings, use it here.\n *)\n let n = Bigint.of_field excess in\n let total = ref Unsigned_extended.UInt64.zero in\n for i = 0 to Unsigned_extended.UInt64.length_in_bits - 1 do\n if Bigint.test_bit n i then\n total :=\n Unsigned_extended.UInt64.(add !total (shift_left one i))\n done ;\n Fee.of_uint64 !total\n in\n Fee.Signed.create ~magnitude ~sgn)\n in\n let%bind excess_from_currency =\n Fee.Signed.Checked.to_field_var currency_excess\n in\n let%map () =\n [%with_label_ \"Fee excess does not overflow\"] (fun () ->\n Field.Checked.Assert.equal excess excess_from_currency )\n in\n currency_excess\n in\n (* Convert to currency. *)\n let%bind fee_excess_l =\n [%with_label_ \"Check for overflow in fee_excess_l\"] (fun () ->\n convert_to_currency fee_excess_l )\n in\n let%map fee_excess_r =\n [%with_label_ \"Check for overflow in fee_excess_r\"] (fun () ->\n convert_to_currency fee_excess_r )\n in\n { fee_token_l; fee_excess_l; fee_token_r; fee_excess_r }\n\n[%%endif]\n\nlet empty =\n { fee_token_l = Token_id.default\n ; fee_excess_l = Fee.Signed.zero\n ; fee_token_r = Token_id.default\n ; fee_excess_r = Fee.Signed.zero\n }\n\nlet is_empty { fee_token_l; fee_excess_l; fee_token_r; fee_excess_r } =\n Fee.Signed.(equal zero) fee_excess_l\n && Fee.Signed.(equal zero) fee_excess_r\n && Token_id.(equal default) fee_token_l\n && Token_id.(equal default) fee_token_r\n\nlet zero = empty\n\nlet is_zero = is_empty\n\nlet of_single (fee_token_l, fee_excess_l) =\n (* This is safe, we know that we will not hit overflow above. *)\n Or_error.ok_exn\n @@ rebalance\n { fee_token_l\n ; fee_excess_l\n ; fee_token_r = Token_id.default\n ; fee_excess_r = Fee.Signed.zero\n }\n\nlet of_one_or_two excesses =\n let unreduced =\n match excesses with\n | `One (fee_token_l, fee_excess_l) ->\n { fee_token_l\n ; fee_excess_l\n ; fee_token_r = Token_id.default\n ; fee_excess_r = Fee.Signed.zero\n }\n | `Two ((fee_token_l, fee_excess_l), (fee_token_r, fee_excess_r)) ->\n { fee_token_l; fee_excess_l; fee_token_r; fee_excess_r }\n in\n rebalance unreduced\n\nlet to_one_or_two ({ fee_token_l; fee_excess_l; fee_token_r; fee_excess_r } : t)\n =\n if Fee.(equal zero) fee_excess_r.magnitude then\n `One (fee_token_l, fee_excess_l)\n else `Two ((fee_token_l, fee_excess_l), (fee_token_r, fee_excess_r))\n\n[%%ifdef consensus_mechanism]\n\nlet gen_single ?(token_id = Token_id.gen) ?(excess = Fee.Signed.gen) () :\n (Token_id.t * Fee.Signed.t) Quickcheck.Generator.t =\n Quickcheck.Generator.tuple2 token_id excess\n\nlet gen : t Quickcheck.Generator.t =\n let open Quickcheck.Generator.Let_syntax in\n let%map excesses = One_or_two.gen @@ gen_single () in\n match of_one_or_two excesses with\n | Ok ret ->\n ret\n | Error _ -> (\n (* There is an overflow, just choose the first excess. *)\n match excesses with\n | `One (fee_token_l, fee_excess_l) | `Two ((fee_token_l, fee_excess_l), _)\n ->\n { fee_token_l\n ; fee_excess_l\n ; fee_token_r = Token_id.default\n ; fee_excess_r = Fee.Signed.zero\n } )\n\n[%%endif]\n","open Core_kernel\nopen Snark_params.Tick\n\nmodule type S = sig\n include Data_hash.Full_size\n\n [%%versioned:\n module Stable : sig\n [@@@no_toplevel_latest_type]\n\n module V1 : sig\n type t = Field.t [@@deriving sexp, compare, hash, yojson]\n\n val to_latest : t -> t\n\n include Comparable.S with type t := t\n\n include Hashable_binable with type t := t\n end\n end]\nend\n","include Ledger_hash0\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Snark_params.Tick\n\nmodule type S = sig\n exception Too_long_user_memo_input\n\n exception Too_long_digestible_string\n\n type t [@@deriving sexp, equal, compare, hash, yojson]\n\n module Stable : sig\n module V1 : sig\n type nonrec t = t\n [@@deriving bin_io, sexp, equal, compare, hash, yojson, version]\n\n module With_all_version_tags : Bin_prot.Binable.S with type t = t\n end\n\n module Latest = V1\n end\n\n [%%ifdef consensus_mechanism]\n\n module Checked : sig\n type unchecked = t\n\n type t = private Boolean.var array\n\n val constant : unchecked -> t\n end\n\n (** typ representation *)\n val typ : (Checked.t, t) Typ.t\n\n [%%endif]\n\n val dummy : t\n\n val empty : t\n\n val to_base58_check : t -> string\n\n val of_base58_check : string -> t Or_error.t\n\n val of_base58_check_exn : string -> t\n\n (** for a memo of bytes, return a plaintext string\n for a memo of a digest, return a hex-encoded string, prefixed by '0x'\n *)\n val to_string_hum : t -> string\n\n (** is the memo a digest *)\n val is_digest : t -> bool\n\n (** is the memo well-formed *)\n val is_valid : t -> bool\n\n (** bound on length of strings to digest *)\n val max_digestible_string_length : int\n\n (** bound on length of strings or bytes in memo *)\n val max_input_length : int\n\n (** create a memo by digesting a string; raises [Too_long_digestible_string] if\n length exceeds [max_digestible_string_length]\n *)\n val create_by_digesting_string_exn : string -> t\n\n (** create a memo by digesting a string; returns error if\n length exceeds [max_digestible_string_length]\n *)\n val create_by_digesting_string : string -> t Or_error.t\n\n (** create a memo from bytes of length up to max_input_length;\n raise [Too_long_user_memo_input] if length is greater\n *)\n val create_from_bytes_exn : bytes -> t\n\n (** create a memo from bytes of length up to max_input_length; returns\n error is length is greater\n *)\n val create_from_bytes : bytes -> t Or_error.t\n\n (** create a memo from a string of length up to max_input_length;\n raise [Too_long_user_memo_input] if length is greater\n *)\n val create_from_string_exn : string -> t\n\n (** create a memo from a string of length up to max_input_length;\n returns error if length is greater\n *)\n val create_from_string : string -> t Or_error.t\n\n (** convert a memo to a list of bools\n *)\n val to_bits : t -> bool list\n\n (** Quickcheck generator for memos. *)\n val gen : t Quickcheck.Generator.t\n\n (** Compute a standalone hash of the current memo. *)\n val hash : t -> Field.t\n\n (* This type definition was generated by hovering over `deriver` in signed_command_memo.ml and copying the type *)\n val deriver :\n (< contramap : (t -> Yojson.Safe.t) ref\n ; graphql_arg :\n (unit -> Yojson.Safe.t Fields_derivers_graphql.Schema.Arg.arg_typ)\n ref\n ; graphql_fields :\n Yojson.Safe.t Fields_derivers_zkapps.Graphql.Fields.Input.T.t ref\n ; graphql_query : string option ref\n ; graphql_query_accumulator : (string * string option) list ref\n ; map : (Yojson.Safe.t -> t) ref\n ; nullable_graphql_arg :\n ( unit\n -> Yojson.Safe.t option Fields_derivers_graphql.Schema.Arg.arg_typ\n )\n ref\n ; nullable_graphql_fields :\n Yojson.Safe.t option Fields_derivers_zkapps.Graphql.Fields.Input.T.t\n ref\n ; of_json : (Yojson.Safe.t -> Yojson.Safe.t) ref\n ; to_json : (Yojson.Safe.t -> Yojson.Safe.t) ref\n ; js_layout : Yojson.Safe.t ref\n ; .. >\n as\n 'a )\n Fields_derivers_zkapps.Unified_input.t\n Fields_derivers_zkapps.Unified_input.t\n Fields_derivers_zkapps.Unified_input.t\n -> 'a Fields_derivers_zkapps.Unified_input.t\n\n type raw =\n | Digest of string (** The digest of the string, encoded by base58-check *)\n | Bytes of string (** A string containing the raw bytes in the memo. *)\n\n (** Convert into a raw representation.\n\n Raises if the tag or length are invalid.\n *)\n val to_raw_exn : t -> raw\n\n (** Convert back into the raw input bytes.\n\n Raises if the tag or length are invalid, or if the memo was a digest.\n Equivalent to [to_raw_exn] and then a match on [Bytes].\n *)\n val to_raw_bytes_exn : t -> string\n\n (** Convert from a raw representation.\n\n Raises if the digest is not a valid base58-check string, or if the bytes\n string is too long.\n *)\n val of_raw_exn : raw -> t\nend\n","(* transaction_union_payload.ml *)\n\n[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\nopen Currency\n\n[%%ifdef consensus_mechanism]\n\nopen Snark_params.Tick\n\n[%%endif]\n\nopen Signature_lib\nmodule Tag = Transaction_union_tag\n\nmodule Body = struct\n type ('tag, 'public_key, 'token_id, 'amount, 'bool) t_ =\n { tag : 'tag\n ; source_pk : 'public_key\n ; receiver_pk : 'public_key\n ; token_id : 'token_id\n ; amount : 'amount\n }\n [@@deriving sexp, hlist]\n\n type t =\n (Tag.t, Public_key.Compressed.t, Token_id.t, Currency.Amount.t, bool) t_\n [@@deriving sexp]\n\n let of_user_command_payload_body ~fee_payer_pk = function\n | Signed_command_payload.Body.Payment { receiver_pk; amount } ->\n { tag = Tag.Payment\n ; source_pk = fee_payer_pk\n ; receiver_pk\n ; token_id = Token_id.default\n ; amount\n }\n | Stake_delegation (Set_delegate { new_delegate }) ->\n { tag = Tag.Stake_delegation\n ; source_pk = fee_payer_pk\n ; receiver_pk = new_delegate\n ; token_id = Token_id.default\n ; amount = Currency.Amount.zero\n }\n\n let gen ~fee =\n let open Quickcheck.Generator.Let_syntax in\n let%bind tag = Tag.gen in\n let%map amount =\n let min, max =\n let max_amount_without_overflow =\n Amount.(sub max_int (of_fee fee))\n |> Option.value_exn ?here:None ?message:None ?error:None\n in\n match tag with\n | Payment ->\n (Amount.zero, max_amount_without_overflow)\n | Stake_delegation ->\n (Amount.zero, Amount.zero)\n | Fee_transfer ->\n (Amount.zero, max_amount_without_overflow)\n | Coinbase ->\n (* In this case,\n amount - fee should be defined. In other words,\n amount >= fee *)\n (Amount.of_fee fee, Amount.max_int)\n in\n Amount.gen_incl min max\n and source_pk = Public_key.Compressed.gen\n and receiver_pk = Public_key.Compressed.gen\n and token_id =\n match tag with\n | Payment ->\n Token_id.gen\n | Stake_delegation ->\n return Token_id.default\n | Fee_transfer ->\n return Token_id.default\n | Coinbase ->\n return Token_id.default\n in\n { tag; source_pk; receiver_pk; token_id; amount }\n\n [%%ifdef consensus_mechanism]\n\n type var =\n ( Tag.Unpacked.var\n , Public_key.Compressed.var\n , Token_id.Checked.t\n , Currency.Amount.var\n , Boolean.var )\n t_\n\n let typ =\n Typ.of_hlistable\n [ Tag.unpacked_typ\n ; Public_key.Compressed.typ\n ; Public_key.Compressed.typ\n ; Token_id.typ\n ; Currency.Amount.typ\n ]\n ~var_to_hlist:t__to_hlist ~value_to_hlist:t__to_hlist\n ~var_of_hlist:t__of_hlist ~value_of_hlist:t__of_hlist\n\n module Checked = struct\n let constant ({ tag; source_pk; receiver_pk; token_id; amount } : t) : var =\n { tag = Tag.unpacked_of_t tag\n ; source_pk = Public_key.Compressed.var_of_t source_pk\n ; receiver_pk = Public_key.Compressed.var_of_t receiver_pk\n ; token_id = Token_id.Checked.constant token_id\n ; amount = Currency.Amount.var_of_t amount\n }\n\n let to_input_legacy { tag; source_pk; receiver_pk; token_id; amount } =\n let%map amount = Currency.Amount.var_to_input_legacy amount\n and () =\n make_checked (fun () ->\n Token_id.Checked.Assert.equal token_id\n (Token_id.Checked.constant Token_id.default) )\n in\n let token_id = Signed_command_payload.Legacy_token_id.default_checked in\n Array.reduce_exn ~f:Random_oracle.Input.Legacy.append\n [| Tag.Unpacked.to_input_legacy tag\n ; Public_key.Compressed.Checked.to_input_legacy source_pk\n ; Public_key.Compressed.Checked.to_input_legacy receiver_pk\n ; token_id\n ; amount\n ; Random_oracle.Input.Legacy.bitstring [ Boolean.false_ ]\n |]\n end\n\n [%%endif]\n\n let to_input_legacy { tag; source_pk; receiver_pk; token_id; amount } =\n assert (Token_id.equal token_id Token_id.default) ;\n Array.reduce_exn ~f:Random_oracle.Input.Legacy.append\n [| Tag.to_input_legacy tag\n ; Public_key.Compressed.to_input_legacy source_pk\n ; Public_key.Compressed.to_input_legacy receiver_pk\n ; Signed_command_payload.Legacy_token_id.default\n ; Currency.Amount.to_input_legacy amount\n ; Random_oracle.Input.Legacy.bitstring [ false ]\n |]\nend\n\nmodule Payload_common = struct\n module Poly = struct\n type ('fee, 'public_key, 'token_id, 'nonce, 'global_slot, 'memo) t =\n { fee : 'fee\n ; fee_token : 'token_id\n ; fee_payer_pk : 'public_key\n ; nonce : 'nonce\n ; valid_until : 'global_slot\n ; memo : 'memo\n }\n [@@deriving sexp, hlist]\n end\n\n let to_signed_command_payload_common\n { Poly.fee; fee_payer_pk; nonce; valid_until; memo; fee_token = _ } =\n { Signed_command_payload.Common.Poly.fee\n ; fee_payer_pk\n ; nonce\n ; valid_until\n ; memo\n }\n\n type t =\n ( Currency.Fee.t\n , Public_key.Compressed.t\n , Token_id.t\n , Mina_numbers.Account_nonce.t\n , Mina_numbers.Global_slot_since_genesis.t\n , Signed_command_memo.t )\n Poly.t\n [@@deriving sexp]\n\n [%%ifdef consensus_mechanism]\n\n module Checked = struct\n type value = t\n\n type t =\n ( Currency.Fee.Checked.t\n , Public_key.Compressed.var\n , Token_id.Checked.t\n , Mina_numbers.Account_nonce.Checked.t\n , Mina_numbers.Global_slot_since_genesis.Checked.t\n , Signed_command_memo.Checked.t )\n Poly.t\n\n let constant\n ({ fee; fee_payer_pk; nonce; valid_until; memo; fee_token } : value) : t\n =\n { fee = Currency.Fee.var_of_t fee\n ; fee_payer_pk = Public_key.Compressed.var_of_t fee_payer_pk\n ; fee_token = Token_id.Checked.constant fee_token\n ; nonce = Mina_numbers.Account_nonce.Checked.constant nonce\n ; memo = Signed_command_memo.Checked.constant memo\n ; valid_until =\n Mina_numbers.Global_slot_since_genesis.Checked.constant valid_until\n }\n end\n\n let typ : (Checked.t, t) Typ.t =\n let open Poly in\n Typ.of_hlistable\n [ Currency.Fee.typ\n ; Token_id.typ\n ; Public_key.Compressed.typ\n ; Mina_numbers.Account_nonce.typ\n ; Mina_numbers.Global_slot_since_genesis.typ\n ; Signed_command_memo.typ\n ]\n ~var_to_hlist:to_hlist ~value_to_hlist:to_hlist ~var_of_hlist:of_hlist\n ~value_of_hlist:of_hlist\n\n [%%endif]\nend\n\ntype t = (Payload_common.t, Body.t) Signed_command_payload.Poly.t\n[@@deriving sexp]\n\ntype payload = t [@@deriving sexp]\n\nlet of_user_command_payload\n ({ common = { memo; fee; fee_payer_pk; nonce; valid_until }; body } :\n Signed_command_payload.t ) : t =\n { common =\n { fee\n ; fee_token = Token_id.default\n ; fee_payer_pk\n ; nonce\n ; valid_until\n ; memo\n }\n ; body = Body.of_user_command_payload_body ~fee_payer_pk body\n }\n\nlet gen =\n let open Quickcheck.Generator.Let_syntax in\n let%bind common = Signed_command_payload.Common.gen in\n let%map body = Body.gen ~fee:common.fee in\n Signed_command_payload.Poly.{ common; body }\n\n[%%ifdef consensus_mechanism]\n\ntype var = (Payload_common.Checked.t, Body.var) Signed_command_payload.Poly.t\n\ntype payload_var = var\n\nlet typ : (var, t) Typ.t =\n let to_hlist = Signed_command_payload.Poly.to_hlist in\n let of_hlist = Signed_command_payload.Poly.of_hlist in\n Typ.of_hlistable\n [ Payload_common.typ; Body.typ ]\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist\n\nlet payload_typ = typ\n\nmodule Checked = struct\n let to_input_legacy ({ common; body } : var) =\n let%map common =\n Signed_command_payload.Common.Checked.to_input_legacy\n (Payload_common.to_signed_command_payload_common common)\n and body = Body.Checked.to_input_legacy body in\n Random_oracle.Input.Legacy.append common body\n\n let constant ({ common; body } : t) : var =\n { common = Payload_common.Checked.constant common\n ; body = Body.Checked.constant body\n }\nend\n\n[%%endif]\n\nlet to_input_legacy ({ common; body } : t) =\n Random_oracle.Input.Legacy.append\n (Signed_command_payload.Common.to_input_legacy\n (Payload_common.to_signed_command_payload_common common) )\n (Body.to_input_legacy body)\n\nlet excess (payload : t) : Amount.Signed.t =\n let tag = payload.body.tag in\n let fee = payload.common.fee in\n let amount = payload.body.amount in\n match tag with\n | Payment | Stake_delegation ->\n (* For all user commands, the fee excess is just the fee. *)\n Amount.Signed.of_unsigned (Amount.of_fee fee)\n | Fee_transfer ->\n Option.value_exn (Amount.add_fee amount fee)\n |> Amount.Signed.of_unsigned |> Amount.Signed.negate\n | Coinbase ->\n Amount.Signed.zero\n\nlet fee_excess ({ body = { tag; amount; _ }; common = { fee; _ } } : t) =\n match tag with\n | Payment | Stake_delegation ->\n (* For all user commands, the fee excess is just the fee. *)\n Fee_excess.of_single (Token_id.default, Fee.Signed.of_unsigned fee)\n | Fee_transfer ->\n let excess =\n Option.value_exn (Amount.add_fee amount fee)\n |> Amount.to_fee |> Fee.Signed.of_unsigned |> Fee.Signed.negate\n in\n Fee_excess.of_single (Token_id.default, excess)\n | Coinbase ->\n Fee_excess.of_single (Token_id.default, Fee.Signed.zero)\n\nlet expected_supply_increase (payload : payload) =\n let tag = payload.body.tag in\n match tag with\n | Coinbase ->\n payload.body.amount\n | Payment | Stake_delegation | Fee_transfer ->\n Amount.zero\n","(* user_command_intf.ml *)\n\n[%%import \"/src/config.mlh\"]\n\nopen Mina_base_import\nopen Core_kernel\nopen Snark_params.Tick\nopen Mina_numbers\n\nmodule type Gen_intf = sig\n type t\n\n module Gen : sig\n (** Generate a single transaction between\n * Generate random keys for sender and receiver\n * for fee $\\in [Currency.Fee.minimum_user_command_fee,\n * Currency.Fee.minimum_user_command_fee+fee_range]$\n * and an amount $\\in [1,max_amount]$\n *)\n val payment :\n ?sign_type:[ `Fake | `Real ]\n -> key_gen:\n (Signature_keypair.t * Signature_keypair.t) Quickcheck.Generator.t\n -> ?nonce:Account_nonce.t\n -> ?min_amount:int\n -> max_amount:int\n -> fee_range:int\n -> unit\n -> t Quickcheck.Generator.t\n\n (** Generate a single transaction between\n * $a, b \\in keys$\n * for fee $\\in [Currency.Fee.minimum_user_command_fee,\n * Currency.Fee.minimum_user_command_fee+fee_range]$\n * and an amount $\\in [1,max_amount]$\n *)\n val payment_with_random_participants :\n ?sign_type:[ `Fake | `Real ]\n -> keys:Signature_keypair.t array\n -> ?nonce:Account_nonce.t\n -> ?min_amount:int\n -> max_amount:int\n -> fee_range:int\n -> unit\n -> t Quickcheck.Generator.t\n\n val stake_delegation :\n key_gen:\n (Signature_keypair.t * Signature_keypair.t) Quickcheck.Generator.t\n -> ?nonce:Account_nonce.t\n -> fee_range:int\n -> unit\n -> t Quickcheck.Generator.t\n\n val stake_delegation_with_random_participants :\n keys:Signature_keypair.t array\n -> ?nonce:Account_nonce.t\n -> fee_range:int\n -> unit\n -> t Quickcheck.Generator.t\n\n (** Generate a valid sequence of payments based on the initial state of a\n ledger. Use this together with Ledger.gen_initial_ledger_state.\n *)\n val sequence :\n ?length:int\n -> ?sign_type:[ `Fake | `Real ]\n -> ( Signature_lib.Keypair.t\n * Currency.Amount.t\n * Mina_numbers.Account_nonce.t\n * Account_timing.t )\n array\n -> t list Quickcheck.Generator.t\n end\nend\n\nmodule type S = sig\n type t [@@deriving sexp, yojson, hash]\n\n (* type of signed commands, pre-Berkeley hard fork *)\n type t_v1\n\n include Comparable.S with type t := t\n\n include Hashable.S with type t := t\n\n val payload : t -> Signed_command_payload.t\n\n val fee : t -> Currency.Fee.t\n\n val nonce : t -> Account_nonce.t\n\n val signer : t -> Public_key.t\n\n val fee_token : t -> Token_id.t\n\n val fee_payer_pk : t -> Public_key.Compressed.t\n\n val fee_payer : t -> Account_id.t\n\n val fee_excess : t -> Fee_excess.t\n\n val token : t -> Token_id.t\n\n val receiver_pk : t -> Public_key.Compressed.t\n\n val receiver : t -> Account_id.t\n\n val public_keys : t -> Public_key.Compressed.t list\n\n val amount : t -> Currency.Amount.t option\n\n val memo : t -> Signed_command_memo.t\n\n val valid_until : t -> Global_slot_since_genesis.t\n\n (* for filtering *)\n val minimum_fee : Currency.Fee.t\n\n val has_insufficient_fee : t -> bool\n\n val tag : t -> Transaction_union_tag.t\n\n val tag_string : t -> string\n\n val to_input_legacy :\n Signed_command_payload.t -> (Field.t, bool) Random_oracle_input.Legacy.t\n\n include Gen_intf with type t := t\n\n module With_valid_signature : sig\n module Stable : sig\n module Latest : sig\n type nonrec t\n [@@deriving sexp, equal, bin_io, yojson, version, compare, hash]\n\n include Gen_intf with type t := t\n end\n\n module V2 = Latest\n end\n\n type t = Stable.Latest.t [@@deriving sexp, yojson, compare, hash]\n\n include Gen_intf with type t := t\n\n include Comparable.S with type t := t\n end\n\n val sign_payload :\n ?signature_kind:Mina_signature_kind.t\n -> Signature_lib.Private_key.t\n -> Signed_command_payload.t\n -> Signature.t\n\n val sign :\n ?signature_kind:Mina_signature_kind.t\n -> Signature_keypair.t\n -> Signed_command_payload.t\n -> With_valid_signature.t\n\n val check_signature : ?signature_kind:Mina_signature_kind.t -> t -> bool\n\n val create_with_signature_checked :\n ?signature_kind:Mina_signature_kind.t\n -> Signature.t\n -> Public_key.Compressed.t\n -> Signed_command_payload.t\n -> With_valid_signature.t option\n\n val check_valid_keys : t -> bool\n\n module For_tests : sig\n (** the signature kind is an argument, to match `sign`, but ignored *)\n val fake_sign :\n ?signature_kind:Mina_signature_kind.t\n -> Signature_keypair.t\n -> Signed_command_payload.t\n -> With_valid_signature.t\n end\n\n (** checks signature and keys *)\n val check : t -> With_valid_signature.t option\n\n val check_only_for_signature : t -> With_valid_signature.t option\n\n val to_valid_unsafe :\n t\n -> [ `If_this_is_used_it_should_have_a_comment_justifying_it of\n With_valid_signature.t ]\n\n (** Forget the signature check. *)\n val forget_check : With_valid_signature.t -> t\n\n (** returned status always `Accessed for fee payer *)\n val account_access_statuses :\n t\n -> Transaction_status.t\n -> (Account_id.t * [ `Accessed | `Not_accessed ]) list\n\n (** all account ids mentioned in a command *)\n val accounts_referenced : t -> Account_id.t list\n\n val filter_by_participant : t list -> Public_key.Compressed.t -> t list\n\n val of_base58_check_exn_v1 : string -> t_v1 Or_error.t\n\n val to_base58_check_v1 : t_v1 -> string\n\n include Codable.Base64_intf with type t := t\nend\n\nmodule type Full = sig\n module Payload = Signed_command_payload\n\n module Poly : sig\n [%%versioned:\n module Stable : sig\n module V1 : sig\n type ('payload, 'pk, 'signature) t =\n ( 'payload\n , 'pk\n , 'signature )\n Mina_wire_types.Mina_base.Signed_command.Poly.V1.t =\n { payload : 'payload; signer : 'pk; signature : 'signature }\n [@@deriving sexp, hash, yojson, equal, compare]\n end\n end]\n end\n\n [%%versioned:\n module Stable : sig\n [@@@with_top_version_tag]\n\n module V2 : sig\n type t =\n ( Payload.Stable.V2.t\n , Public_key.Stable.V1.t\n , Signature.Stable.V1.t )\n Poly.Stable.V1.t\n [@@deriving sexp, hash, yojson, version]\n\n include Comparable.S with type t := t\n\n include Hashable.S with type t := t\n\n val account_access_statuses :\n t\n -> Transaction_status.t\n -> (Account_id.t * [ `Accessed | `Not_accessed ]) list\n\n val accounts_referenced : t -> Account_id.t list\n end\n\n module V1 : sig\n type t =\n ( Payload.Stable.V1.t\n , Public_key.Stable.V1.t\n , Signature.Stable.V1.t )\n Poly.Stable.V1.t\n [@@deriving compare, sexp, hash, yojson]\n\n val to_latest : t -> Latest.t\n end\n end]\n\n include S with type t = Stable.V2.t and type t_v1 = Stable.V1.t\nend\n","[%%import \"/src/config.mlh\"]\n\n[%%ifdef consensus_mechanism]\n\ninclude Pickles.Side_loaded.Verification_key\n\n[%%else]\n\nopen Core_kernel\n\nmodule G = struct\n open Snark_params.Tick\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Field.Stable.V1.t * Field.Stable.V1.t\n [@@deriving sexp, equal, compare, hash, yojson]\n\n let to_latest = Fn.id\n end\n end]\nend\n\nmodule R = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t =\n G.Stable.V1.t Pickles_base.Side_loaded_verification_key.Repr.Stable.V2.t\n [@@deriving sexp, compare, equal, yojson]\n\n let to_latest = Fn.id\n end\n end]\nend\n\n[%%versioned_binable\nmodule Stable = struct\n module V2 = struct\n type t =\n ( G.Stable.V1.t\n , unit )\n Pickles_base.Side_loaded_verification_key.Poly.Stable.V2.t\n [@@deriving hash]\n\n open Pickles_base.Side_loaded_verification_key\n\n let to_latest = Fn.id\n\n let to_repr { Poly.step_data; max_width; wrap_index; wrap_vk = _ } =\n { Repr.Stable.V2.step_data; max_width; wrap_index }\n\n let of_repr { Repr.Stable.V2.step_data; max_width; wrap_index = c } =\n { Poly.step_data; max_width; wrap_index = c; wrap_vk = Some () }\n\n include\n Binable.Of_binable\n (R.Stable.V2)\n (struct\n type nonrec t = t\n\n let to_binable = to_repr\n\n let of_binable = of_repr\n end)\n\n let sexp_of_t t = R.sexp_of_t (to_repr t)\n\n let t_of_sexp sexp = of_repr (R.t_of_sexp sexp)\n\n let to_yojson t = R.to_yojson (to_repr t)\n\n let of_yojson json = Result.map ~f:of_repr (R.of_yojson json)\n\n let equal x y = R.equal (to_repr x) (to_repr y)\n\n let compare x y = R.compare (to_repr x) (to_repr y)\n end\nend]\n\nlet to_input x =\n Pickles_base.Side_loaded_verification_key.to_input\n ~field_of_int:Snark_params.Tick.Field.of_int x\n\nlet dummy : t =\n let open Pickles_types in\n { step_data = At_most.[]\n ; max_width = Pickles_base.Side_loaded_verification_key.Width.zero\n ; wrap_index =\n (let g = Snarkette.Pasta.Pallas.(to_affine_exn one) in\n { sigma_comm = Vector.init Dlog_plonk_types.Permuts.n ~f:(fun _ -> g)\n ; coefficients_comm =\n Vector.init Dlog_plonk_types.Columns.n ~f:(fun _ -> g)\n ; generic_comm = g\n ; psm_comm = g\n ; complete_add_comm = g\n ; mul_comm = g\n ; emul_comm = g\n ; endomul_scalar_comm = g\n } )\n ; wrap_vk = None\n }\n\n[%%endif]\n","(* state_hash.ml *)\nopen Core_kernel\nmodule T = Data_hash_lib.State_hash\ninclude T\n\nmodule State_hashes = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t =\n { mutable state_body_hash : State_body_hash.Stable.V1.t option\n ; state_hash : T.Stable.V1.t\n }\n [@@deriving equal, sexp, to_yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n let state_hash { state_hash; _ } = state_hash\n\n let state_body_hash t ~compute_hashes =\n match t.state_body_hash with\n | Some state_body_hash ->\n state_body_hash\n | None ->\n let { state_hash; state_body_hash } = compute_hashes () in\n assert (T.equal state_hash t.state_hash) ;\n assert (Option.is_some state_body_hash) ;\n t.state_body_hash <- state_body_hash ;\n Option.value_exn state_body_hash\nend\n\nmodule With_state_hashes = struct\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V1 = struct\n type 'a t = ('a, State_hashes.Stable.V1.t) With_hash.Stable.V1.t\n [@@deriving equal, sexp, to_yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n type 'a t = ('a, State_hashes.t) With_hash.t\n [@@deriving equal, sexp, to_yojson]\n\n open With_hash\n open State_hashes.Stable.Latest\n\n let data { data; _ } = data\n\n let hashes { hash = hashes; _ } = hashes\n\n let state_hash { hash = { state_hash; _ }; _ } = state_hash\n\n let state_body_hash { hash; data } ~compute_hashes =\n State_hashes.state_body_hash hash ~compute_hashes:(fun () ->\n compute_hashes data )\nend\n","(* verification_key_wire.ml *)\n\nopen Core_kernel\nopen Zkapp_basic\n\n(* the digest functions are declared locally in Zkapp_account, which depends on\n this module; the definitions here avoid a cyclic dependency\n*)\n\nlet digest_vk (t : Side_loaded_verification_key.t) =\n Random_oracle.(\n hash ~init:Hash_prefix_states.side_loaded_vk\n (pack_input (Side_loaded_verification_key.to_input t)))\n\nlet dummy_vk_hash =\n Memo.unit (fun () -> digest_vk Side_loaded_verification_key.dummy)\n\n[%%versioned_binable\nmodule Stable = struct\n module V1 = struct\n module T = struct\n type t = (Side_loaded_verification_key.t, F.t) With_hash.t\n [@@deriving sexp, yojson, equal, compare, hash]\n end\n\n include T\n\n let to_latest = Fn.id\n\n module M = struct\n type nonrec t = t\n\n (* don't send hash over the wire; restore hash on receipt *)\n\n let to_binable (t : t) = t.data\n\n let of_binable vk : t =\n let data = vk in\n let hash = digest_vk vk in\n { data; hash }\n end\n\n include\n Binable.Of_binable_without_uuid\n (Side_loaded_verification_key.Stable.V2)\n (M)\n end\nend]\n","open Core_kernel\nopen Mina_base_import\nopen Snark_params\nopen Snarky_backendless\nopen Tick\nopen Let_syntax\n\nlet merge_var ~height h1 h2 =\n Random_oracle.Checked.hash ~init:(Hash_prefix.merkle_tree height) [| h1; h2 |]\n\nmodule Merkle_tree =\n Snarky_backendless.Merkle_tree.Checked\n (Tick)\n (struct\n type value = Field.t\n\n type var = Field.Var.t\n\n let typ = Field.typ\n\n let merge ~height h1 h2 =\n Tick.make_checked (fun () -> merge_var ~height h1 h2)\n\n let assert_equal h1 h2 = Field.Checked.Assert.equal h1 h2\n\n let if_ = Field.Checked.if_\n end)\n (struct\n include Account\n\n let hash = Checked.digest\n end)\n\ninclude Ledger_hash0\n\n(* End boilerplate *)\nlet merge ~height (h1 : t) (h2 : t) =\n Random_oracle.hash\n ~init:(Hash_prefix.merkle_tree height)\n [| (h1 :> field); (h2 :> field) |]\n |> of_hash\n\nlet empty_hash = of_hash Outside_hash_image.t\n\nlet%bench \"Ledger_hash.merge ~height:1 empty_hash empty_hash\" =\n merge ~height:1 empty_hash empty_hash\n\nlet of_digest = Fn.compose Fn.id of_hash\n\ntype path = Random_oracle.Digest.t list\n\ntype _ Request.t +=\n | Get_path : Account.Index.t -> path Request.t\n | Get_element : Account.Index.t -> (Account.t * path) Request.t\n | Set : Account.Index.t * Account.t -> unit Request.t\n | Find_index : Account_id.t -> Account.Index.t Request.t\n\nlet reraise_merkle_requests (With { request; respond }) =\n match request with\n | Merkle_tree.Get_path addr ->\n respond (Delegate (Get_path addr))\n | Merkle_tree.Set (addr, account) ->\n respond (Delegate (Set (addr, account)))\n | Merkle_tree.Get_element addr ->\n respond (Delegate (Get_element addr))\n | _ ->\n unhandled\n\nlet get ~depth t addr =\n handle\n (fun () -> Merkle_tree.get_req ~depth (var_to_hash_packed t) addr)\n reraise_merkle_requests\n\n(*\n [modify_account t aid ~filter ~f] implements the following spec:\n\n - finds an account [account] in [t] for [aid] at path [addr] where [filter\n account] holds.\n note that the account is not guaranteed to have identifier [aid]; it might\n be a new account created to satisfy this request.\n - returns a root [t'] of a tree of depth [depth] which is [t] but with the\n account [f account] at path [addr].\n*)\nlet%snarkydef_ modify_account ~depth t aid\n ~(filter : Account.var -> 'a Checked.t) ~f =\n let%bind addr =\n request_witness\n (Account.Index.Unpacked.typ ~ledger_depth:depth)\n As_prover.(map (read Account_id.typ aid) ~f:(fun s -> Find_index s))\n in\n handle\n (fun () ->\n Merkle_tree.modify_req ~depth (var_to_hash_packed t) addr\n ~f:(fun account ->\n let%bind x = filter account in\n f x account ) )\n reraise_merkle_requests\n >>| var_of_hash_packed\n\n(*\n [modify_account_send t aid ~f] implements the following spec:\n\n - finds an account [account] in [t] at path [addr] whose account id is [aid]\n OR it is a fee transfer and is an empty account\n - returns a root [t'] of a tree of depth [depth] which is [t] but with the\n account [f account] at path [addr].\n*)\nlet%snarkydef_ modify_account_send ~depth t aid ~is_writeable ~f =\n modify_account ~depth t aid\n ~filter:(fun account ->\n [%with_label_ \"modify_account_send filter\"] (fun () ->\n let%bind account_already_there =\n Account_id.Checked.equal (Account.identifier_of_var account) aid\n in\n let%bind account_not_there =\n Public_key.Compressed.Checked.equal account.public_key\n Public_key.Compressed.(var_of_t empty)\n in\n let%bind not_there_but_writeable =\n Boolean.(account_not_there && is_writeable)\n in\n let%bind () =\n [%with_label_ \"account is either present or empty and writeable\"]\n (fun () ->\n Boolean.Assert.any\n [ account_already_there; not_there_but_writeable ] )\n in\n return not_there_but_writeable ) )\n ~f:(fun is_empty_and_writeable x -> f ~is_empty_and_writeable x)\n\n(*\n [modify_account_recv t aid ~f] implements the following spec:\n\n - finds an account [account] in [t] at path [addr] whose account id is [aid]\n OR which is an empty account\n - returns a root [t'] of a tree of depth [depth] which is [t] but with the\n account [f account] at path [addr].\n*)\nlet%snarkydef_ modify_account_recv ~depth t aid ~f =\n modify_account ~depth t aid\n ~filter:(fun account ->\n [%with_label_ \"modify_account_recv filter\"] (fun () ->\n let%bind account_already_there =\n Account_id.Checked.equal (Account.identifier_of_var account) aid\n in\n let%bind account_not_there =\n Public_key.Compressed.Checked.equal account.public_key\n Public_key.Compressed.(var_of_t empty)\n in\n let%bind () =\n [%with_label_ \"account is either present or empty\"] (fun () ->\n Boolean.Assert.any [ account_already_there; account_not_there ] )\n in\n return account_not_there ) )\n ~f:(fun is_empty_and_writeable x -> f ~is_empty_and_writeable x)\n","open Snark_params\nopen Snarky_backendless\nopen Tick\n\nmodule type S = sig\n include Ledger_hash_intf0.S\n\n type path = Random_oracle.Digest.t list\n\n type _ Request.t +=\n | Get_path : Account.Index.t -> path Request.t\n | Get_element : Account.Index.t -> (Account.t * path) Request.t\n | Set : Account.Index.t * Account.t -> unit Request.t\n | Find_index : Account_id.t -> Account.Index.t Request.t\n\n val get :\n depth:int -> var -> Account.Index.Unpacked.var -> Account.var Checked.t\n\n val merge : height:int -> t -> t -> t\n\n (** string representation of hash is Base58Check of bin_io representation *)\n val to_base58_check : t -> string\n\n val of_base58_check : string -> t Base.Or_error.t\n\n val empty_hash : t\n\n val of_digest : Random_oracle.Digest.t -> t\n\n val modify_account :\n depth:int\n -> var\n -> Account_id.var\n -> filter:(Account.var -> 'a Checked.t)\n -> f:('a -> Account.var -> Account.var Checked.t)\n -> var Checked.t\n\n val modify_account_send :\n depth:int\n -> var\n -> Account_id.var\n -> is_writeable:Boolean.var\n -> f:\n ( is_empty_and_writeable:Boolean.var\n -> Account.var\n -> Account.var Checked.t )\n -> var Checked.t\n\n val modify_account_recv :\n depth:int\n -> var\n -> Account_id.var\n -> f:\n ( is_empty_and_writeable:Boolean.var\n -> Account.var\n -> Account.var Checked.t )\n -> var Checked.t\nend\n","include Ledger_hash\n\nlet of_ledger_hash (h : Ledger_hash.t) : t = h\n\nlet to_ledger_hash (t : t) : Ledger_hash.t = t\n","open Core_kernel\n\nmodule type S = sig\n module Stable : sig\n module V1 : sig\n type t = private Zkapp_basic.F.t\n\n val to_yojson : t -> Yojson.Safe.t\n\n val of_yojson : Yojson.Safe.t -> t Ppx_deriving_yojson_runtime.error_or\n\n val bin_size_t : t Bin_prot.Size.sizer\n\n val bin_write_t : t Bin_prot.Write.writer\n\n val bin_read_t : t Bin_prot.Read.reader\n\n val __bin_read_t__ : (int -> t) Bin_prot.Read.reader\n\n val bin_shape_t : Bin_prot.Shape.t\n\n val bin_writer_t : t Bin_prot.Type_class.writer\n\n val bin_reader_t : t Bin_prot.Type_class.reader\n\n val bin_t : t Bin_prot.Type_class.t\n\n val __versioned__ : unit\n\n val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t\n\n val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t\n\n val compare : t -> t -> int\n\n val equal : t -> t -> bool\n\n val hash_fold_t :\n Base_internalhash_types.state -> t -> Base_internalhash_types.state\n\n val hash : t -> int\n end\n\n module Latest = V1\n end\n\n type t = Stable.V1.t\n\n val to_yojson : t -> Yojson.Safe.t\n\n val of_yojson : Yojson.Safe.t -> t Ppx_deriving_yojson_runtime.error_or\n\n val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t\n\n val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t\n\n val compare : t -> t -> int\n\n val equal : t -> t -> bool\n\n val hash_fold_t :\n Base_internalhash_types.state -> t -> Base_internalhash_types.state\n\n val hash : t -> int\nend\n\nmodule type S_checked = sig\n open Pickles.Impls.Step\n\n type t = private Field.t\n\n val if_ : Boolean.var -> then_:t -> else_:t -> t\n\n val equal : t -> t -> Boolean.var\n\n module Assert : sig\n val equal : t -> t -> unit\n end\nend\n\nmodule type S_aux = sig\n type t\n\n type checked\n\n val typ : (checked, t) Pickles.Impls.Step.Typ.t\n\n val constant : t -> checked\nend\n","[%%import \"/src/config.mlh\"]\n\nopen Core_kernel\n\n[%%ifdef consensus_mechanism]\n\nopen Snark_params.Tick\n\n[%%endif]\n\nmodule Poly = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type 'comm t = { account_update : 'comm; calls : 'comm }\n [@@deriving hlist, sexp, yojson]\n end\n end]\n\n let to_field_elements (t : 'c t) : 'c array =\n let [ x0; x1 ] = to_hlist t in\n [| x0; x1 |]\nend\n\n[%%versioned\nmodule Stable = struct\n module V2 = struct\n type t = Zkapp_command.Transaction_commitment.Stable.V1.t Poly.Stable.V1.t\n [@@deriving sexp, yojson]\n\n let to_latest = Fn.id\n end\nend]\n\nlet to_field_elements : t -> _ = Poly.to_field_elements\n\nlet of_tree (type account_update)\n ({ account_update = _; account_update_digest; calls } :\n ( account_update\n , Zkapp_command.Digest.Account_update.t\n , Zkapp_command.Digest.Forest.t )\n Zkapp_command.Call_forest.Tree.t ) : t =\n { account_update =\n (account_update_digest :> Zkapp_command.Transaction_commitment.t)\n ; calls =\n ( Zkapp_command.Call_forest.hash calls\n :> Zkapp_command.Transaction_commitment.t )\n }\n\nlet zkapp_statements_of_forest' (type data)\n (forest : data Zkapp_command.Call_forest.With_hashes_and_data.t) :\n (data * t) Zkapp_command.Call_forest.With_hashes_and_data.t =\n Zkapp_command.Call_forest.mapi_with_trees forest\n ~f:(fun _i (account_update, data) tree ->\n (account_update, (data, of_tree tree)) )\n\nlet zkapp_statements_of_forest (type account_update)\n (forest : (account_update, _, _) Zkapp_command.Call_forest.t) :\n (account_update * t, _, _) Zkapp_command.Call_forest.t =\n Zkapp_command.Call_forest.mapi_with_trees forest\n ~f:(fun _i account_update tree -> (account_update, of_tree tree))\n\n[%%ifdef consensus_mechanism]\n\nmodule Checked = struct\n type t = Zkapp_command.Transaction_commitment.Checked.t Poly.t\n\n let to_field_elements : t -> _ = Poly.to_field_elements\n\n open Pickles.Impls.Step\n\n module Assert = struct\n let equal (t1 : t) (t2 : t) =\n Array.iter2_exn ~f:Field.Assert.equal (to_field_elements t1)\n (to_field_elements t2)\n end\nend\n\nlet typ =\n let open Poly in\n Typ.of_hlistable\n Zkapp_command.Transaction_commitment.[ typ; typ ]\n ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist ~value_to_hlist:to_hlist\n ~value_of_hlist:of_hlist\n\n[%%endif]\n","open Snark_params.Tick.Run\n\ntype 'a t = 'a As_prover.Ref.t\n\nlet get = As_prover.Ref.get\n\nlet create = As_prover.Ref.create\n\nlet if_ b ~then_ ~else_ =\n create (fun () ->\n get (if Impl.As_prover.read Boolean.typ b then then_ else else_) )\n\nlet map t ~f = create (fun () -> f (get t))\n\nlet typ = Typ.Internal.ref\n","open Core_kernel\n\n(* Same as the type of the field account_updates in Mina_base.Zkapp_command.t *)\ntype t =\n ( Account_update.t\n , Zkapp_command.Digest.Account_update.t\n , Zkapp_command.Digest.Forest.t )\n Zkapp_command.Call_forest.t\n\ntype account_update =\n (Account_update.t, Zkapp_command.Digest.Account_update.t) With_hash.t\n\nlet empty () = []\n\nlet if_ = Zkapp_command.value_if\n\nlet is_empty = List.is_empty\n\nlet pop_exn : t -> (Account_update.t * t) * t = function\n | { stack_hash = _\n ; elt = { account_update; calls; account_update_digest = _ }\n }\n :: xs ->\n ((account_update, calls), xs)\n | _ ->\n failwith \"pop_exn\"\n\nlet push ~account_update ~calls t =\n Zkapp_command.Call_forest.cons ~calls account_update t\n\nlet hash (t : t) = Zkapp_command.Call_forest.hash t\n\nopen Snark_params.Tick.Run\n\nmodule Checked = struct\n module F = Zkapp_command.Digest.Forest.Checked\n module V = Prover_value\n\n type account_update =\n { account_update :\n ( Account_update.Body.Checked.t\n , Zkapp_command.Digest.Account_update.Checked.t )\n With_hash.t\n ; control : Control.t Prover_value.t\n }\n\n let account_update_typ () :\n ( account_update\n , (Account_update.t, Zkapp_command.Digest.Account_update.t) With_hash.t\n )\n Typ.t =\n let (Typ typ) =\n Typ.(\n Account_update.Body.typ () * Prover_value.typ ()\n * Zkapp_command.Digest.Account_update.typ)\n |> Typ.transport\n ~back:(fun ((body, authorization), hash) ->\n { With_hash.data = { Account_update.body; authorization }; hash }\n )\n ~there:(fun { With_hash.data = { Account_update.body; authorization }\n ; hash\n } -> ((body, authorization), hash) )\n |> Typ.transport_var\n ~back:(fun ((account_update, control), hash) ->\n { account_update = { hash; data = account_update }; control } )\n ~there:(fun { account_update = { hash; data = account_update }\n ; control\n } -> ((account_update, control), hash) )\n in\n Typ\n { typ with\n check =\n (fun ( { account_update = { hash; data = account_update }\n ; control = _\n } as x ) ->\n Impl.make_checked (fun () ->\n Impl.run_checked (typ.check x) ;\n Field.Assert.equal\n (hash :> Field.t)\n ( Zkapp_command.Call_forest.Digest.Account_update.Checked\n .create account_update\n :> Field.t ) ) )\n }\n\n type t =\n ( ( Account_update.t\n , Zkapp_command.Digest.Account_update.t\n , Zkapp_command.Digest.Forest.t )\n Zkapp_command.Call_forest.t\n V.t\n , F.t )\n With_hash.t\n\n let if_ b ~then_:(t : t) ~else_:(e : t) : t =\n { hash = F.if_ b ~then_:t.hash ~else_:e.hash\n ; data = V.if_ b ~then_:t.data ~else_:e.data\n }\n\n let empty =\n Zkapp_command.Digest.Forest.constant\n Zkapp_command.Call_forest.With_hashes.empty\n\n let is_empty ({ hash = x; _ } : t) = F.equal empty x\n\n let empty () : t = { hash = empty; data = V.create (fun () -> []) }\n\n let pop_exn ({ hash = h; data = r } : t) : (account_update * t) * t =\n with_label \"Zkapp_call_forest.pop_exn\" (fun () ->\n let hd_r =\n V.create (fun () -> V.get r |> List.hd_exn |> With_stack_hash.elt)\n in\n let account_update = V.create (fun () -> (V.get hd_r).account_update) in\n let auth =\n V.(create (fun () -> (V.get account_update).authorization))\n in\n let account_update =\n exists (Account_update.Body.typ ()) ~compute:(fun () ->\n (V.get account_update).body )\n in\n let account_update =\n With_hash.of_data account_update\n ~hash_data:Zkapp_command.Digest.Account_update.Checked.create\n in\n let subforest : t =\n let subforest = V.create (fun () -> (V.get hd_r).calls) in\n let subforest_hash =\n exists Zkapp_command.Digest.Forest.typ ~compute:(fun () ->\n Zkapp_command.Call_forest.hash (V.get subforest) )\n in\n { hash = subforest_hash; data = subforest }\n in\n let tl_hash =\n exists Zkapp_command.Digest.Forest.typ ~compute:(fun () ->\n V.get r |> List.tl_exn |> Zkapp_command.Call_forest.hash )\n in\n let tree_hash =\n Zkapp_command.Digest.Tree.Checked.create\n ~account_update:account_update.hash ~calls:subforest.hash\n in\n let hash_cons =\n Zkapp_command.Digest.Forest.Checked.cons tree_hash tl_hash\n in\n F.Assert.equal hash_cons h ;\n ( ( ({ account_update; control = auth }, subforest)\n , { hash = tl_hash\n ; data = V.(create (fun () -> List.tl_exn (get r)))\n } )\n : (account_update * t) * t ) )\n\n let pop ~dummy ~dummy_tree_hash ({ hash = h; data = r } : t) :\n (account_update * t) * t =\n with_label \"Zkapp_call_forest.pop\" (fun () ->\n let hd_r =\n V.create (fun () ->\n match V.get r with\n | hd :: _ ->\n With_stack_hash.elt hd\n | [] ->\n dummy )\n in\n let account_update = V.create (fun () -> (V.get hd_r).account_update) in\n let auth =\n V.(create (fun () -> (V.get account_update).authorization))\n in\n let account_update =\n exists (Account_update.Body.typ ()) ~compute:(fun () ->\n (V.get account_update).body )\n in\n let account_update =\n With_hash.of_data account_update\n ~hash_data:Zkapp_command.Digest.Account_update.Checked.create\n in\n let subforest : t =\n let subforest = V.create (fun () -> (V.get hd_r).calls) in\n let subforest_hash =\n exists Zkapp_command.Digest.Forest.typ ~compute:(fun () ->\n Zkapp_command.Call_forest.hash (V.get subforest) )\n in\n { hash = subforest_hash; data = subforest }\n in\n let tl_hash =\n exists Zkapp_command.Digest.Forest.typ ~compute:(fun () ->\n match V.get r with\n | _ :: tl ->\n Zkapp_command.Call_forest.hash tl\n | [] ->\n Zkapp_command.Digest.Forest.empty )\n in\n let tree_hash =\n Zkapp_command.Digest.Tree.Checked.create\n ~account_update:account_update.hash ~calls:subforest.hash\n in\n let hash_cons =\n Zkapp_command.Digest.Forest.Checked.cons tree_hash tl_hash\n in\n let () =\n let correct = F.equal hash_cons h in\n let empty = F.equal F.empty h in\n let is_dummy =\n Zkapp_command.Digest.Tree.Checked.equal tree_hash dummy_tree_hash\n in\n Boolean.(Assert.any [ correct; empty &&& is_dummy ])\n in\n ( ( ({ account_update; control = auth }, subforest)\n , { hash = tl_hash\n ; data =\n V.(\n create (fun () ->\n match get r with _ :: tl -> tl | [] -> [] ))\n } )\n : (account_update * t) * t ) )\n\n let push\n ~account_update:\n { account_update = { hash = account_update_hash; data = account_update }\n ; control = auth\n } ~calls:({ hash = calls_hash; data = calls } : t)\n ({ hash = tl_hash; data = tl_data } : t) : t =\n with_label \"Zkapp_call_forest.push\" (fun () ->\n let tree_hash =\n Zkapp_command.Digest.Tree.Checked.create\n ~account_update:account_update_hash ~calls:calls_hash\n in\n let hash_cons =\n Zkapp_command.Digest.Forest.Checked.cons tree_hash tl_hash\n in\n let data =\n V.create (fun () ->\n let body =\n As_prover.read (Account_update.Body.typ ()) account_update\n in\n let authorization = V.get auth in\n let tl = V.get tl_data in\n let account_update : Account_update.t = { body; authorization } in\n let calls = V.get calls in\n let res =\n Zkapp_command.Call_forest.cons ~calls account_update tl\n in\n (* Sanity check; we're re-hashing anyway, might as well make sure it's\n consistent.\n *)\n assert (\n Zkapp_command.Digest.Forest.(\n equal\n (As_prover.read typ hash_cons)\n (Zkapp_command.Call_forest.hash res)) ) ;\n res )\n in\n ({ hash = hash_cons; data } : t) )\n\n let hash ({ hash; _ } : t) = hash\nend\n\nlet typ : (Checked.t, t) Typ.t =\n Typ.(Zkapp_command.Digest.Forest.typ * Prover_value.typ ())\n |> Typ.transport\n ~back:(fun (_digest, forest) ->\n Zkapp_command.Call_forest.map\n ~f:(fun account_update -> account_update)\n forest )\n ~there:(fun forest ->\n ( Zkapp_command.Call_forest.hash forest\n , Zkapp_command.Call_forest.map\n ~f:(fun account_update -> account_update)\n forest ) )\n |> Typ.transport_var\n ~back:(fun (digest, forest) -> { With_hash.hash = digest; data = forest })\n ~there:(fun { With_hash.hash = digest; data = forest } ->\n (digest, forest) )\n","open Core_kernel\nopen Mina_base_import\n\nmodule type Full = sig\n module Single : sig\n module Stable : sig\n module V2 : sig\n type t = private\n { receiver_pk : Public_key.Compressed.Stable.V1.t\n ; fee : Currency.Fee.Stable.V1.t\n ; fee_token : Token_id.Stable.V2.t\n }\n [@@deriving bin_io, sexp, compare, equal, yojson, version, hash]\n end\n\n module Latest = V2\n end\n\n type t = Stable.Latest.t = private\n { receiver_pk : Public_key.Compressed.t\n ; fee : Currency.Fee.t\n ; fee_token : Token_id.t\n }\n [@@deriving sexp, compare, yojson, hash]\n\n include Comparable.S with type t := t\n\n include Codable.Base58_check_intf with type t := t\n\n val create :\n receiver_pk:Public_key.Compressed.t\n -> fee:Currency.Fee.t\n -> fee_token:Token_id.t\n -> t\n\n val receiver_pk : t -> Public_key.Compressed.t\n\n val receiver : t -> Account_id.t\n\n val fee : t -> Currency.Fee.t\n\n val fee_token : t -> Token_id.t\n\n module Gen : sig\n val with_random_receivers :\n ?min_fee:int\n -> max_fee:int\n -> token:Token_id.t Quickcheck.Generator.t\n -> Signature_keypair.t array\n -> t Quickcheck.Generator.t\n end\n end\n\n module Stable : sig\n module V2 : sig\n type t = private Single.Stable.V2.t One_or_two.Stable.V1.t\n [@@deriving bin_io, sexp, compare, equal, yojson, version, hash]\n end\n\n module Latest = V2\n end\n\n type t = Stable.Latest.t [@@deriving sexp, compare, yojson, hash]\n\n type single = Single.t = private\n { receiver_pk : Public_key.Compressed.t\n ; fee : Currency.Fee.t\n ; fee_token : Token_id.t\n }\n [@@deriving sexp, compare, yojson, hash]\n\n include Comparable.S with type t := t\n\n val create : Single.t -> Single.t option -> t Or_error.t\n\n val create_single :\n receiver_pk:Public_key.Compressed.t\n -> fee:Currency.Fee.t\n -> fee_token:Token_id.t\n -> t\n\n val to_singles : t -> Single.t One_or_two.t\n\n val of_singles : Single.t One_or_two.t -> t Or_error.t\n\n val fee_excess : t -> Fee_excess.t Or_error.t\n\n val fee_token : single -> Token_id.t\n\n val fee_tokens : t -> Token_id.t One_or_two.t\n\n val receiver_pks : t -> Public_key.Compressed.t list\n\n val receivers : t -> Account_id.t list\n\n val fee_payer_pk : t -> Public_key.Compressed.t\n\n val map : t -> f:(Single.t -> 'b) -> 'b One_or_two.t\n\n val fold : t -> init:'acc -> f:('acc -> Single.t -> 'acc) -> 'acc\n\n val to_list : t -> Single.t list\n\n val to_numbered_list : t -> (int * Single.t) list\nend\n","open Core_kernel\nopen Mina_base_import\n\nmodule type Full = sig\n [%%versioned:\n module Stable : sig\n module V1 : sig\n type t = private\n { receiver_pk : Public_key.Compressed.Stable.V1.t\n ; fee : Currency.Fee.Stable.V1.t\n }\n [@@deriving sexp, compare, equal, yojson, hash]\n end\n end]\n\n val create : receiver_pk:Public_key.Compressed.t -> fee:Currency.Fee.t -> t\n\n include Comparable.S with type t := t\n\n include Codable.Base58_check_intf with type t := t\n\n val receiver_pk : t -> Public_key.Compressed.t\n\n val receiver : t -> Account_id.t\n\n val fee : t -> Currency.Fee.t\n\n val to_fee_transfer : t -> Fee_transfer.Single.t\n\n module Gen : sig\n (** [gen ?min_fee max_fee] generates fee transfers between [min_fee] and\n [max_fee].\n\n @param min_fee defaults to zero *)\n val gen :\n ?min_fee:Currency.Fee.t -> Currency.Fee.t -> t Quickcheck.Generator.t\n\n (** [with_random_receivers ~key ?min_fee coinbase_amount] creates coinbase\n fee transfers with fees between [min_fee] and [coinbase_amount]\n\n @param min_fee defaults to {!val:Currency.Fee.zero}\n *)\n val with_random_receivers :\n keys:Signature_keypair.t array\n -> ?min_fee:Currency.Fee.t\n -> Currency.Amount.t\n -> t Quickcheck.Generator.t\n end\nend\n","open Core_kernel\nopen Mina_base_import\n\nmodule type Full = sig\n module Fee_transfer = Coinbase_fee_transfer\n\n module Stable : sig\n module V1 : sig\n type t = private\n { receiver : Public_key.Compressed.Stable.V1.t\n ; amount : Currency.Amount.Stable.V1.t\n ; fee_transfer : Fee_transfer.Stable.V1.t option\n }\n [@@deriving sexp, bin_io, compare, equal, version, hash, yojson]\n end\n\n module Latest = V1\n end\n\n (* bin_io intentionally omitted in deriving list *)\n type t = Stable.Latest.t = private\n { receiver : Public_key.Compressed.t\n ; amount : Currency.Amount.t\n ; fee_transfer : Fee_transfer.t option\n }\n [@@deriving sexp, compare, equal, hash, yojson]\n\n include Codable.Base58_check_intf with type t := t\n\n val receiver_pk : t -> Public_key.Compressed.t\n\n val receiver : t -> Account_id.t\n\n val fee_payer_pk : t -> Public_key.Compressed.t\n\n val amount : t -> Currency.Amount.t\n\n val fee_transfer : t -> Fee_transfer.t option\n\n val account_access_statuses :\n t\n -> Transaction_status.t\n -> (Account_id.t * [ `Accessed | `Not_accessed ]) list\n\n val accounts_referenced : t -> Account_id.t list\n\n val create :\n amount:Currency.Amount.t\n -> receiver:Public_key.Compressed.t\n -> fee_transfer:Fee_transfer.t option\n -> t Or_error.t\n\n val expected_supply_increase : t -> Currency.Amount.t Or_error.t\n\n val fee_excess : t -> Fee_excess.t Or_error.t\n\n module Gen : sig\n val gen :\n constraint_constants:Genesis_constants.Constraint_constants.t\n -> (t * [ `Supercharged_coinbase of bool ]) Quickcheck.Generator.t\n\n (** Creates coinbase with reward between [min_amount] and [max_amount]. The generated amount[coinbase_amount] is then used as the upper bound for the fee transfer. *)\n val with_random_receivers :\n keys:Signature_keypair.t array\n -> min_amount:int\n -> max_amount:int\n -> fee_transfer:\n ( coinbase_amount:Currency.Amount.t\n -> Fee_transfer.t Quickcheck.Generator.t )\n -> t Quickcheck.Generator.t\n end\nend\n","(** Pending_coinbase is to keep track of all the coinbase transactions that have been applied to the ledger but for which there is no ledger proof yet. Every ledger proof corresponds to a sequence of coinbase transactions which is part of all the transactions it proves. Each of these sequences[Stack] are stored using the merkle tree representation. The stacks are operated in a FIFO manner by keeping track of its positions in the merkle tree. Whenever a ledger proof is emitted, the oldest stack is removed from the tree and when a new coinbase is applied, the latest stack is updated with the new coinbase.\n The operations on the merkle tree of coinbase stacks include:\n 1) adding a new singleton stack\n 2) updating the latest stack when a new coinbase is added to it\n 2) deleting the oldest stack\n\n A stack can be either be created or modified by pushing a coinbase on to it.\n\n This module also provides an interface for the checked computations required required to prove it in snark\n\n Stack operations are done for transaction snarks and tree operations are done for the blockchain snark*)\n\nopen Core_kernel\nopen Snark_params\nopen Snarky_backendless\nopen Tick\nopen Signature_lib\nopen Currency\n\nmodule type S = sig\n type t [@@deriving sexp, to_yojson]\n\n module Stable : sig\n module V2 : sig\n type nonrec t = t [@@deriving bin_io, sexp, to_yojson, version]\n end\n\n module Latest = V2\n end\n\n module Coinbase_data : sig\n module Stable : sig\n module V1 : sig\n type t = Public_key.Compressed.Stable.V1.t * Amount.Stable.V1.t\n [@@deriving sexp, bin_io, to_yojson]\n end\n\n module Latest = V1\n end\n\n type t = Stable.Latest.t [@@deriving sexp, to_yojson]\n\n type var = Public_key.Compressed.var * Amount.var\n\n val typ : (var, t) Typ.t\n\n val empty : t\n\n val of_coinbase : Coinbase.t -> t\n\n val genesis : t\n\n val var_of_t : t -> var\n end\n\n module type Data_hash_intf = sig\n type t = private Field.t [@@deriving sexp, compare, equal, yojson, hash]\n\n type var\n\n val var_of_t : t -> var\n\n val typ : (var, t) Typ.t\n\n val var_to_hash_packed : var -> Field.Var.t\n\n val equal_var : var -> var -> Boolean.var Tick.Checked.t\n\n val to_bytes : t -> string\n\n val to_bits : t -> bool list\n\n val to_base58_check : t -> string\n\n val of_base58_check_exn : string -> t\n\n val gen : t Quickcheck.Generator.t\n end\n\n module rec Hash : sig\n include Data_hash_intf\n\n val merge : height:int -> t -> t -> t\n\n val empty_hash : t\n\n val of_digest : Random_oracle.Digest.t -> t\n end\n\n module Hash_versioned : sig\n [%%versioned:\n module Stable : sig\n module V1 : sig\n type nonrec t = Hash.t [@@deriving sexp, compare, equal, yojson, hash]\n end\n end]\n end\n\n module Stack_versioned : sig\n [%%versioned:\n module Stable : sig\n module V1 : sig\n type nonrec t [@@deriving sexp, compare, equal, yojson, hash]\n end\n end]\n end\n\n module Stack : sig\n type t = Stack_versioned.t [@@deriving sexp, compare, equal, yojson, hash]\n\n type var\n\n val data_hash : t -> Hash.t\n\n val var_of_t : t -> var\n\n val typ : (var, t) Typ.t\n\n val gen : t Quickcheck.Generator.t\n\n val to_input : t -> Field.t Random_oracle.Input.Chunked.t\n\n val to_bits : t -> bool list\n\n val to_bytes : t -> string\n\n val equal_var : var -> var -> Boolean.var Tick.Checked.t\n\n val var_to_input : var -> Field.Var.t Random_oracle.Input.Chunked.t\n\n val empty : t\n\n (** Creates a new stack with the state stack from an existing stack*)\n val create_with : t -> t\n\n val equal_data : t -> t -> bool\n\n val equal_state_hash : t -> t -> bool\n\n (** The two stacks are connected. This should be used instead of `equal` to\n check one transaction snark statement follow the other.*)\n val connected : ?prev:t option -> first:t -> second:t -> unit -> bool\n\n val push_coinbase : Coinbase.t -> t -> t\n\n val push_state :\n State_body_hash.t -> Mina_numbers.Global_slot_since_genesis.t -> t -> t\n\n module Checked : sig\n type t = var\n\n val push_coinbase : Coinbase_data.var -> t -> t Tick.Checked.t\n\n val push_state :\n State_body_hash.var\n -> Mina_numbers.Global_slot_since_genesis.Checked.var\n -> t\n -> t Tick.Checked.t\n\n val if_ : Boolean.var -> then_:t -> else_:t -> t Tick.Checked.t\n\n val check_merge :\n transition1:t * t -> transition2:t * t -> Boolean.var Tick.Checked.t\n\n val empty : t\n\n val create_with : t -> t\n end\n end\n\n module State_stack : sig\n [%%versioned:\n module Stable : sig\n module V1 : sig\n type t\n end\n end]\n end\n\n module Update : sig\n module Action : sig\n [%%versioned:\n module Stable : sig\n module V1 : sig\n type t =\n | Update_none\n | Update_one\n | Update_two_coinbase_in_first\n | Update_two_coinbase_in_second\n [@@deriving sexp, to_yojson]\n end\n end]\n\n type var = Boolean.var * Boolean.var\n\n val typ : (var, t) Typ.t\n\n val var_of_t : t -> var\n end\n\n module Poly : sig\n [%%versioned:\n module Stable : sig\n module V1 : sig\n type ('action, 'coinbase_amount) t =\n { action : 'action; coinbase_amount : 'coinbase_amount }\n [@@deriving sexp]\n end\n end]\n end\n\n [%%versioned:\n module Stable : sig\n module V1 : sig\n type t = (Action.Stable.V1.t, Amount.Stable.V1.t) Poly.Stable.V1.t\n [@@deriving sexp, to_yojson]\n end\n end]\n\n type var = (Action.var, Amount.var) Poly.t\n\n val genesis : t\n\n val typ : (var, t) Typ.t\n\n val var_of_t : t -> var\n end\n\n val create : depth:int -> unit -> t Or_error.t\n\n (** Delete the oldest stack*)\n val remove_coinbase_stack : depth:int -> t -> (Stack.t * t) Or_error.t\n\n (** Root of the merkle tree that has stacks as leaves*)\n val merkle_root : t -> Hash.t\n\n val handler :\n depth:int -> t -> is_new_stack:bool -> (request -> response) Staged.t\n\n (** Update the current working stack or if [is_new_stack] add as the new working stack*)\n val update_coinbase_stack :\n depth:int -> t -> Stack.t -> is_new_stack:bool -> t Or_error.t\n\n (** Stack that is currently being updated. if [is_new_stack] then a new stack is returned*)\n val latest_stack : t -> is_new_stack:bool -> Stack.t Or_error.t\n\n (** The stack that corresponds to the next ledger proof that is to be generated*)\n val oldest_stack : t -> Stack.t Or_error.t\n\n (** Hash of the auxiliary data (everything except the merkle root (Hash.t))*)\n val hash_extra : t -> string\n\n module Checked : sig\n type var = Hash.var\n\n type path\n\n module Address : sig\n type value\n\n type var\n\n val typ : depth:int -> (var, value) Typ.t\n end\n\n type _ Request.t +=\n | Coinbase_stack_path : Address.value -> path Request.t\n | Get_coinbase_stack : Address.value -> (Stack.t * path) Request.t\n | Set_coinbase_stack : Address.value * Stack.t -> unit Request.t\n | Set_oldest_coinbase_stack : Address.value * Stack.t -> unit Request.t\n | Find_index_of_newest_stacks :\n Update.Action.t\n -> (Address.value * Address.value) Request.t\n | Find_index_of_oldest_stack : Address.value Request.t\n | Get_previous_stack : State_stack.t Request.t\n\n val get : depth:int -> var -> Address.var -> Stack.var Tick.Checked.t\n\n (**\n [update_stack t ~is_new_stack updated_stack] implements the following spec:\n - gets the address[addr] of the latest stack or a new stack\n - finds a coinbase stack in [t] at path [addr] and pushes the coinbase_data on to the stack\n - returns a root [t'] of the tree\n *)\n val add_coinbase :\n constraint_constants:Genesis_constants.Constraint_constants.t\n -> var\n -> Update.var\n -> coinbase_receiver:Public_key.Compressed.var\n -> supercharge_coinbase:Boolean.var\n -> State_body_hash.var\n -> Mina_numbers.Global_slot_since_genesis.Checked.t\n -> var Tick.Checked.t\n\n (**\n [pop_coinbases t pk updated_stack] implements the following spec:\n\n - gets the address[addr] of the oldest stack.\n - finds a coinbase stack in [t] at path [addr] and replaces it with empty stack if a [proof_emitted] is true\n - returns a root [t'] of the tree\n *)\n val pop_coinbases :\n constraint_constants:Genesis_constants.Constraint_constants.t\n -> var\n -> proof_emitted:Boolean.var\n -> (var * Stack.var) Tick.Checked.t\n end\nend\n","open Async_kernel\n\nlet run_in_thread f = Deferred.return (f ())\n\nlet block_on_async_exn f =\n let res = f () in\n match Async_kernel.Deferred.peek res with\n | Some res ->\n res\n | None ->\n failwith\n \"block_on_async_exn: Cannot block thread, and the deferred computation \\\n did not resolve immediately.\"\n","module type Full = sig\n open Core_kernel\n open Snark_params.Tick\n\n type t [@@deriving sexp, equal, compare, hash, yojson]\n\n include Hashable with type t := t\n\n type value [@@deriving sexp, equal, compare, hash]\n\n type var\n\n val var_of_t : t -> var\n\n val typ : (var, t) Typ.t\n\n val var_to_input : var -> Field.Var.t Random_oracle.Input.Chunked.t\n\n val to_input : t -> Field.t Random_oracle.Input.Chunked.t\n\n val genesis :\n constraint_constants:Genesis_constants.Constraint_constants.t\n -> genesis_ledger_hash:Ledger_hash.t\n -> t\n\n module Stable : sig\n module V1 : sig\n type nonrec t = t\n [@@deriving bin_io, sexp, equal, compare, hash, yojson, version]\n end\n\n module Latest : module type of V1\n end\n\n module Aux_hash : sig\n type t\n\n module Stable : sig\n module V1 : sig\n type nonrec t = t\n [@@deriving bin_io, sexp, equal, compare, hash, yojson, version]\n end\n\n module Latest : module type of V1\n end\n\n val of_bytes : string -> t\n\n val to_bytes : t -> string\n\n val to_base58_check : t -> string\n\n val of_base58_check_exn : string -> t\n\n val compare : t -> t -> int\n\n val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t\n\n val dummy : t\n\n val of_sha256 : Digestif.SHA256.t -> t\n\n val gen : t Quickcheck.Generator.t\n end\n\n module Pending_coinbase_aux : sig\n type t\n\n module Stable : sig\n module V1 : sig\n type nonrec t = t\n [@@deriving bin_io, sexp, equal, compare, hash, yojson, version]\n end\n\n module Latest : module type of V1\n end\n\n val to_base58_check : t -> string\n\n val of_base58_check_exn : string -> t\n\n val dummy : t\n end\n\n val ledger_hash : t -> Ledger_hash.t\n\n val aux_hash : t -> Aux_hash.t\n\n val pending_coinbase_aux : t -> Pending_coinbase_aux.t\n\n val pending_coinbase_hash : t -> Pending_coinbase.Hash.t\n\n val pending_coinbase_hash_var : var -> Pending_coinbase.Hash.var\n\n val of_aux_ledger_and_coinbase_hash :\n Aux_hash.t -> Ledger_hash.t -> Pending_coinbase.t -> t\nend\n","open Core_kernel\n\n[%%versioned\nmodule Stable = struct\n module V1 = struct\n type ('caller, 'zkapp_command) t =\n { caller : 'caller; caller_caller : 'caller; calls : 'zkapp_command }\n [@@deriving make, fields, sexp, yojson]\n end\nend]\n\ntype value =\n ( Token_id.t\n , ( Account_update.t\n , Zkapp_command.Digest.Account_update.t\n , Zkapp_command.Digest.Forest.t )\n Zkapp_command.Call_forest.t )\n t\n\ntype ('caller, 'zkapp_command) frame = ('caller, 'zkapp_command) t\n\nlet empty : value =\n { caller = Token_id.default; caller_caller = Token_id.default; calls = [] }\n\nmodule type Stack_frame_digest_intf = sig\n include Digest_intf.S\n\n val create :\n ( Token_id.t\n , ( 'p\n , Zkapp_command.Digest.Account_update.t\n , Zkapp_command.Digest.Forest.t )\n Zkapp_command.Call_forest.t )\n frame\n -> t\n\n val gen : t Quickcheck.Generator.t\n\n open Pickles.Impls.Step\n\n module Checked : sig\n include Digest_intf.S_checked\n\n val create :\n hash_zkapp_command:\n ('zkapp_command -> Zkapp_command.Digest.Forest.Checked.t)\n -> (Token_id.Checked.t, 'zkapp_command) frame\n -> t\n end\n\n val typ : (Checked.t, t) Typ.t\nend\n\nmodule Wire_types = Mina_wire_types.Mina_base.Stack_frame.Digest\n\nmodule Make_sig (A : Wire_types.Types.S) = struct\n module type S = Stack_frame_digest_intf with type Stable.V1.t = A.V1.t\nend\n\nmodule Make_str (A : Wire_types.Concrete) = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Kimchi_backend.Pasta.Basic.Fp.Stable.V1.t\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n open Pickles.Impls.Step\n\n let gen = Field.Constant.gen\n\n let to_input (type p)\n ({ caller; caller_caller; calls } :\n ( Token_id.t\n , ( p\n , Zkapp_command.Digest.Account_update.t\n , Zkapp_command.Digest.Forest.t )\n Zkapp_command.Call_forest.t )\n frame ) =\n List.reduce_exn ~f:Random_oracle.Input.Chunked.append\n [ Token_id.to_input caller\n ; Token_id.to_input caller_caller\n ; Random_oracle.Input.Chunked.field\n (Zkapp_command.Call_forest.hash calls :> Field.Constant.t)\n ]\n\n let create frame =\n Random_oracle.hash ~init:Hash_prefix_states.account_update_stack_frame\n (Random_oracle.pack_input (to_input frame))\n\n module Checked = struct\n include Field\n\n let to_input (type zkapp_command)\n ~(hash_zkapp_command :\n zkapp_command -> Zkapp_command.Digest.Forest.Checked.t )\n ({ caller; caller_caller; calls } : _ frame) =\n List.reduce_exn ~f:Random_oracle.Input.Chunked.append\n [ Token_id.Checked.to_input caller\n ; Token_id.Checked.to_input caller_caller\n ; Random_oracle.Input.Chunked.field (hash_zkapp_command calls :> Field.t)\n ]\n\n let create ~hash_zkapp_command frame =\n Random_oracle.Checked.hash\n ~init:Hash_prefix_states.account_update_stack_frame\n (Random_oracle.Checked.pack_input (to_input ~hash_zkapp_command frame))\n end\n\n let typ = Field.typ\nend\n\nmodule Digest = Wire_types.Make (Make_sig) (Make_str)\n\nmodule Checked = struct\n type nonrec 'zkapp_command t = (Token_id.Checked.t, 'zkapp_command) t\n\n let if_ f b ~then_ ~else_ : _ t =\n { caller = Token_id.Checked.if_ b ~then_:then_.caller ~else_:else_.caller\n ; caller_caller =\n Token_id.Checked.if_ b ~then_:then_.caller_caller\n ~else_:else_.caller_caller\n ; calls = f b ~then_:then_.calls ~else_:else_.calls\n }\nend\n","open Core_kernel\nopen Mina_base_import\nopen Snark_params.Tick\n\n[%%versioned\nmodule Stable = struct\n module V2 = struct\n type t =\n ( Ledger_hash.Stable.V1.t\n , Account_id.Stable.V2.t\n , Account.Stable.V2.t )\n Sparse_ledger_lib.Sparse_ledger.T.Stable.V2.t\n [@@deriving yojson, sexp]\n\n let to_latest = Fn.id\n end\nend]\n\ntype sparse_ledger = t [@@deriving sexp, to_yojson]\n\nmodule Hash = struct\n include Ledger_hash\n\n let merge = Ledger_hash.merge\nend\n\nmodule Account = struct\n include Account\n\n let data_hash = Fn.compose Ledger_hash.of_digest Account.digest\nend\n\nmodule Global_state = struct\n type t =\n { first_pass_ledger : sparse_ledger\n ; second_pass_ledger : sparse_ledger\n ; fee_excess : Currency.Amount.Signed.t\n ; supply_increase : Currency.Amount.Signed.t\n ; protocol_state : Zkapp_precondition.Protocol_state.View.t\n ; block_global_slot : Mina_numbers.Global_slot_since_genesis.t\n }\n [@@deriving sexp, to_yojson]\nend\n\nmodule M = Sparse_ledger_lib.Sparse_ledger.Make (Hash) (Account_id) (Account)\n\ntype account_state = [ `Added | `Existed ] [@@deriving equal]\n\n(** Create a new 'empty' ledger.\n This ledger has an invalid root hash, and cannot be used except as a\n placeholder.\n*)\nlet empty ~depth () = M.of_hash ~depth Outside_hash_image.t\n\nmodule L = struct\n type t = M.t ref\n\n type location = int\n\n let get : t -> location -> Account.t option =\n fun t loc ->\n Option.try_with (fun () ->\n let account = M.get_exn !t loc in\n if Public_key.Compressed.(equal empty account.public_key) then None\n else Some account )\n |> Option.bind ~f:Fn.id\n\n let location_of_account : t -> Account_id.t -> location option =\n fun t id ->\n try\n let loc = M.find_index_exn !t id in\n let account = M.get_exn !t loc in\n if Public_key.Compressed.(equal empty account.public_key) then None\n else Some loc\n with _ -> None\n\n let set : t -> location -> Account.t -> unit =\n fun t loc a -> t := M.set_exn !t loc a\n\n let get_or_create_exn :\n t -> Account_id.t -> account_state * Account.t * location =\n fun t id ->\n let loc = M.find_index_exn !t id in\n let account = M.get_exn !t loc in\n if Public_key.Compressed.(equal empty account.public_key) then (\n let public_key = Account_id.public_key id in\n let account' : Account.t =\n { account with\n delegate = Some public_key\n ; public_key\n ; token_id = Account_id.token_id id\n }\n in\n set t loc account' ;\n (`Added, account', loc) )\n else (`Existed, account, loc)\n\n let get_or_create t id = Or_error.try_with (fun () -> get_or_create_exn t id)\n\n let get_or_create_account :\n t -> Account_id.t -> Account.t -> (account_state * location) Or_error.t =\n fun t id to_set ->\n Or_error.try_with (fun () ->\n let loc = M.find_index_exn !t id in\n let a = M.get_exn !t loc in\n if Public_key.Compressed.(equal empty a.public_key) then (\n set t loc to_set ;\n (`Added, loc) )\n else (`Existed, loc) )\n\n let create_new_account t id to_set =\n get_or_create_account t id to_set |> Or_error.map ~f:ignore\n\n let remove_accounts_exn : t -> Account_id.t list -> unit =\n fun _t _xs -> failwith \"remove_accounts_exn: not implemented\"\n\n let merkle_root : t -> Ledger_hash.t = fun t -> M.merkle_root !t\n\n let with_ledger : depth:int -> f:(t -> 'a) -> 'a =\n fun ~depth:_ ~f:_ -> failwith \"with_ledger: not implemented\"\n\n (** Create a new ledger mask 'on top of' the given ledger.\n\n Warning: For technical reasons, this mask cannot be applied directly to\n the parent ledger; instead, use\n [apply_mask parent_ledger ~masked:this_ledger] to update the parent\n ledger as necessary.\n *)\n let create_masked t = ref !t\n\n (** [apply_mask ledger ~masked] applies any updates in [masked] to the ledger\n [ledger]. [masked] should be created by calling [create_masked ledger].\n\n Warning: This function may behave unexpectedly if [ledger] was modified\n after calling [create_masked], or the given [ledger] was not used to\n create [masked].\n *)\n let apply_mask t ~masked = t := !masked\n\n (** Create a new 'empty' ledger.\n This ledger has an invalid root hash, and cannot be used except as a\n placeholder.\n *)\n let empty ~depth () = ref (empty ~depth ())\nend\n\n[%%define_locally\nM.\n ( of_hash\n , to_yojson\n , get_exn\n , path_exn\n , set_exn\n , find_index_exn\n , add_path\n , merkle_root\n , iteri )]\n\nlet of_root ~depth (h : Ledger_hash.t) =\n of_hash ~depth (Ledger_hash.of_digest (h :> Random_oracle.Digest.t))\n\nlet get_or_initialize_exn account_id t idx =\n let account = get_exn t idx in\n if Public_key.Compressed.(equal empty account.public_key) then\n let public_key = Account_id.public_key account_id in\n let token_id = Account_id.token_id account_id in\n let delegate =\n (* Only allow delegation if this account is for the default token. *)\n if Token_id.(equal default) token_id then Some public_key else None\n in\n ( `Added\n , { account with\n delegate\n ; public_key\n ; token_id = Account_id.token_id account_id\n } )\n else (`Existed, account)\n\nlet has_locked_tokens_exn ~global_slot ~account_id t =\n let idx = find_index_exn t account_id in\n let _, account = get_or_initialize_exn account_id t idx in\n Account.has_locked_tokens ~global_slot account\n\nlet merkle_root t = Ledger_hash.of_hash (merkle_root t :> Random_oracle.Digest.t)\n\nlet depth t = M.depth t\n\nlet handler t =\n let ledger = ref t in\n let path_exn idx =\n List.map (path_exn !ledger idx) ~f:(function `Left h -> h | `Right h -> h)\n in\n stage (fun (With { request; respond }) ->\n match request with\n | Ledger_hash.Get_element idx ->\n let elt = get_exn !ledger idx in\n let path = (path_exn idx :> Random_oracle.Digest.t list) in\n respond (Provide (elt, path))\n | Ledger_hash.Get_path idx ->\n let path = (path_exn idx :> Random_oracle.Digest.t list) in\n respond (Provide path)\n | Ledger_hash.Set (idx, account) ->\n ledger := set_exn !ledger idx account ;\n respond (Provide ())\n | Ledger_hash.Find_index pk ->\n let index = find_index_exn !ledger pk in\n respond (Provide index)\n | _ ->\n unhandled )\n","module type Full = sig\n open Core_kernel\n open Snark_params\n open Tick\n open Mina_base_import\n\n [@@@warning \"-32\"]\n\n [%%versioned:\n module Stable : sig\n module V1 : sig\n type t =\n { fee : Currency.Fee.Stable.V1.t\n ; prover : Public_key.Compressed.Stable.V1.t\n }\n [@@deriving sexp, yojson, equal, compare]\n end\n end]\n\n [@@@warning \"+32\"]\n\n type t = Stable.Latest.t =\n { fee : Currency.Fee.Stable.V1.t\n ; prover : Public_key.Compressed.Stable.V1.t\n }\n [@@deriving sexp, yojson, equal, compare]\n\n val create : fee:Currency.Fee.t -> prover:Public_key.Compressed.t -> t\n\n module Digest : sig\n type t [@@deriving sexp, equal, yojson, hash, compare]\n\n module Stable : sig\n module V1 : sig\n type nonrec t = t\n [@@deriving sexp, bin_io, hash, compare, equal, yojson, version]\n end\n\n module Latest = V1\n end\n\n module Checked : sig\n type t\n\n val to_input : t -> Field.Var.t Random_oracle.Input.Chunked.t\n end\n\n val to_input : t -> Field.t Random_oracle.Input.Chunked.t\n\n val typ : (Checked.t, t) Typ.t\n\n val default : t\n end\n\n val digest : t -> Digest.t\nend\n","open Core_kernel\n\n[%%versioned\nmodule Stable = struct\n module V2 = struct\n type t =\n { pending_coinbases : Pending_coinbase.Stable.V2.t; is_new_stack : bool }\n [@@deriving sexp, to_yojson]\n\n let to_latest = Fn.id\n end\nend]\n","open Core_kernel\n\nmodule type Full = sig\n include Digest_intf.S\n\n val cons : Stack_frame.Digest.t -> t -> t\n\n val empty : t\n\n val gen : t Quickcheck.Generator.t\n\n module Checked : sig\n include Digest_intf.S_checked\n\n val cons : Stack_frame.Digest.Checked.t -> t -> t\n end\n\n include Digest_intf.S_aux with type t := t and type checked := Checked.t\nend\n","open Core_kernel\nmodule Wire_types = Mina_wire_types.Mina_base.Call_stack_digest\n\nmodule Make_sig (A : Wire_types.Types.S) = struct\n module type S = Call_stack_digest_intf.Full with type Stable.V1.t = A.V1.t\nend\n\nmodule Make_str (A : Wire_types.Concrete) = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Kimchi_backend.Pasta.Basic.Fp.Stable.V1.t\n [@@deriving sexp, compare, equal, hash, yojson]\n\n let to_latest = Fn.id\n end\n end]\n\n open Pickles.Impls.Step\n\n let cons (h : Stack_frame.Digest.t) (t : t) : t =\n Random_oracle.hash ~init:Hash_prefix_states.account_update_stack_frame_cons\n [| (h :> Field.Constant.t); t |]\n\n let empty = Field.Constant.zero\n\n let gen = Field.Constant.gen\n\n module Checked = struct\n include Field\n\n let cons (h : Stack_frame.Digest.Checked.t) (t : t) : t =\n Random_oracle.Checked.hash\n ~init:Hash_prefix_states.account_update_stack_frame_cons\n [| (h :> Field.t); t |]\n end\n\n let constant = Field.constant\n\n let typ = Field.typ\nend\n\ninclude Wire_types.Make (Make_sig) (Make_str)\n","open Core_kernel\n\ntype account_state = [ `Added | `Existed ] [@@deriving equal]\n\nmodule type S = sig\n type t\n\n type location\n\n val get : t -> location -> Account.t option\n\n val location_of_account : t -> Account_id.t -> location option\n\n val set : t -> location -> Account.t -> unit\n\n val get_or_create :\n t -> Account_id.t -> (account_state * Account.t * location) Or_error.t\n\n val create_new_account : t -> Account_id.t -> Account.t -> unit Or_error.t\n\n val remove_accounts_exn : t -> Account_id.t list -> unit\n\n val merkle_root : t -> Ledger_hash.t\n\n val with_ledger : depth:int -> f:(t -> 'a) -> 'a\n\n val empty : depth:int -> unit -> t\n\n val create_masked : t -> t\n\n val apply_mask : t -> masked:t -> unit\nend\n","module Import = Mina_base_import\nmodule Util = Mina_base_util\nmodule Account = Account\nmodule Account_id = Account_id\nmodule Account_timing = Account_timing\nmodule Call_stack_digest = Call_stack_digest\nmodule Coinbase = Coinbase\nmodule Coinbase_fee_transfer = Coinbase_fee_transfer\nmodule Control = Control\nmodule Data_as_hash = Data_as_hash\nmodule Data_hash = Data_hash\nmodule Epoch_data = Epoch_data\nmodule Epoch_ledger = Epoch_ledger\nmodule Epoch_seed = Epoch_seed\nmodule Fee_excess = Fee_excess\nmodule Fee_transfer = Fee_transfer\nmodule Fee_with_prover = Fee_with_prover\nmodule Frozen_ledger_hash = Frozen_ledger_hash\nmodule Frozen_ledger_hash0 = Frozen_ledger_hash0\nmodule Hash_prefix = Hash_prefix\nmodule Ledger_hash = Ledger_hash\nmodule Ledger_hash0 = Ledger_hash0\nmodule Ledger_hash_intf = Ledger_hash_intf\nmodule Ledger_hash_intf0 = Ledger_hash_intf0\nmodule Ledger_intf = Ledger_intf\nmodule Account_update = Account_update\nmodule Payment_payload = Payment_payload\nmodule Pending_coinbase = Pending_coinbase\nmodule Pending_coinbase_intf = Pending_coinbase_intf\nmodule Pending_coinbase_witness = Pending_coinbase_witness\nmodule Permissions = Permissions\nmodule Proof = Proof\nmodule Protocol_constants_checked = Protocol_constants_checked\nmodule Prover_value = Prover_value\nmodule Receipt = Receipt\nmodule Side_loaded_verification_key = Side_loaded_verification_key\nmodule Signature = Signature\nmodule Signed_command = Signed_command\nmodule Signed_command_intf = Signed_command_intf\nmodule Signed_command_memo = Signed_command_memo\nmodule Signed_command_payload = Signed_command_payload\nmodule Zkapp_account = Zkapp_account\nmodule Zkapp_basic = Zkapp_basic\nmodule Zkapp_call_forest = Zkapp_call_forest\nmodule Zkapp_command = Zkapp_command\nmodule Zkapp_precondition = Zkapp_precondition\nmodule Zkapp_state = Zkapp_state\nmodule Zkapp_statement = Zkapp_statement\nmodule Sok_message = Sok_message\nmodule Sparse_ledger_base = Sparse_ledger_base\nmodule Stack_frame = Stack_frame\nmodule Staged_ledger_hash = Staged_ledger_hash\nmodule Stake_delegation = Stake_delegation\nmodule State_body_hash = State_body_hash\nmodule State_hash = State_hash\nmodule Token_id = Token_id\nmodule Transaction_status = Transaction_status\nmodule Transaction_union_payload = Transaction_union_payload\nmodule Transaction_union_tag = Transaction_union_tag\nmodule User_command = User_command\nmodule Verification_key_wire = Verification_key_wire\nmodule With_stack_hash = With_stack_hash\nmodule With_status = With_status\n","module Js = struct\n type t\n\n type 'a js_array = t\n\n type ('a, 'b) meth_callback = t\n\n external string : string -> t = \"caml_jsstring_of_string\"\n\n external to_string : t -> string = \"caml_string_of_jsstring\"\n\n external bytestring : string -> t = \"caml_jsbytes_of_string\"\n\n external to_bytestring : t -> string = \"caml_string_of_jsbytes\"\n\n external bool : bool -> t = \"caml_js_from_bool\"\n\n external to_bool : t -> bool = \"caml_js_to_bool\"\n\n external array : 'a array -> t = \"caml_js_from_array\"\n\n external to_array : t -> 'a array = \"caml_js_to_array\"\n\n external number_of_float : float -> t = \"caml_js_from_float\"\n\n external float_of_number : t -> float = \"caml_js_to_float\"\n\n external typeof : t -> t = \"caml_js_typeof\"\n\n external instanceof : t -> t -> bool = \"caml_js_instanceof\"\n\n external debugger : unit -> unit = \"debugger\"\n\n external get : t -> t -> t = \"caml_js_get\"\n\n external set : t -> t -> t -> unit = \"caml_js_set\"\n\n external delete : t -> t -> unit = \"caml_js_delete\"\n\n external call : t -> t -> t array -> t = \"caml_js_call\"\n\n external fun_call : t -> t array -> t = \"caml_js_fun_call\"\n\n external meth_call : t -> string -> t array -> t = \"caml_js_meth_call\"\n\n external new_obj : t -> t array -> t = \"caml_js_new\"\n\n external new_obj_arr : t -> t js_array -> t = \"caml_ojs_new_arr\"\n\n external obj : (string * t) array -> t = \"caml_js_object\"\n\n external equals : t -> t -> bool = \"caml_js_equals\"\n\n external pure_expr : (unit -> 'a) -> 'a = \"caml_js_pure_expr\"\n\n external eval_string : string -> 'a = \"caml_js_eval_string\"\n\n external js_expr : string -> 'a = \"caml_js_expr\"\n\n external pure_js_expr : string -> 'a = \"caml_pure_js_expr\"\n\n external callback_with_arguments :\n (t js_array -> 'b) -> ('c, t js_array -> 'b) meth_callback\n = \"caml_js_wrap_callback_arguments\"\n\n external callback_with_arity : int -> ('a -> 'b) -> ('c, 'a -> 'b) meth_callback\n = \"caml_js_wrap_callback_strict\"\n\n external meth_callback : ('b -> 'a) -> ('b, 'a) meth_callback\n = \"caml_js_wrap_meth_callback_unsafe\"\n\n external meth_callback_with_arity : int -> ('b -> 'a) -> ('b, 'a) meth_callback\n = \"caml_js_wrap_meth_callback_strict\"\n\n external meth_callback_with_arguments :\n ('b -> t js_array -> 'a) -> ('b, t js_array -> 'a) meth_callback\n = \"caml_js_wrap_meth_callback_arguments\"\n\n external wrap_callback : ('a -> 'b) -> ('c, 'a -> 'b) meth_callback\n = \"caml_js_wrap_callback\"\n\n external wrap_meth_callback : ('a -> 'b) -> ('a, 'b) meth_callback\n = \"caml_js_wrap_meth_callback\"\nend\n\nmodule Sys = struct\n type 'a callback = 'a\n\n external create_file : name:string -> content:string -> unit = \"caml_create_file\"\n\n external read_file : name:string -> string = \"caml_read_file_content\"\n\n external set_channel_output' : out_channel -> (js_string:Js.t -> unit) callback -> unit\n = \"caml_ml_set_channel_output\"\n\n external set_channel_input' : in_channel -> (unit -> string) callback -> unit\n = \"caml_ml_set_channel_refill\"\n\n external mount_point : unit -> string list = \"caml_list_mount_point\"\n\n external mount_autoload : string -> (string -> string -> string option) callback -> unit\n = \"caml_mount_autoload\"\n\n external unmount : string -> unit = \"caml_unmount\"\nend\n\nmodule Error : sig\n type t\n\n val raise_ : t -> 'a\n\n val attach_js_backtrace : exn -> force:bool -> exn\n (** Attach a JavasScript error to an OCaml exception. if [force = false] and a\n JavasScript error is already attached, it will do nothing. This function is useful to\n store and retrieve information about JavaScript stack traces.\n\n Attaching JavasScript errors will happen automatically when compiling with\n [--enable with-js-error]. *)\n\n val of_exn : exn -> t option\n (** Extract a JavaScript error attached to an OCaml exception, if any. This is useful to\n inspect an eventual stack strace, especially when sourcemap is enabled. *)\n\n exception Exn of t\n (** The [Error] exception wrap javascript exceptions when caught by OCaml code.\n In case the javascript exception is not an instance of javascript [Error],\n it will be serialized and wrapped into a [Failure] exception.\n *)\nend = struct\n type t\n\n exception Exn of t\n\n let _ = Callback.register_exception \"jsError\" (Exn (Obj.magic [||]))\n\n let raise_ : t -> 'a = Js.js_expr \"(function (exn) { throw exn })\"\n\n external of_exn : exn -> t option = \"caml_js_error_option_of_exception\"\n\n external attach_js_backtrace : exn -> force:bool -> exn = \"caml_exn_with_js_backtrace\"\nend\n\n[@@@ocaml.warning \"-32-60\"]\n\nmodule For_compatibility_only = struct\n (* Add primitives for compatibility reasons. Existing users might\n depend on it (e.g. gen_js_api), we dont want the ocaml compiler\n to complain about theses missing primitives. *)\n\n external caml_js_from_string : string -> Js.t = \"caml_js_from_string\"\n\n external caml_js_to_byte_string : Js.t -> string = \"caml_js_to_byte_string\"\n\n external caml_js_to_string : Js.t -> string = \"caml_js_to_string\"\n\n external caml_list_of_js_array : 'a Js.js_array -> 'a list = \"caml_list_of_js_array\"\n\n external caml_list_to_js_array : 'a list -> 'a Js.js_array = \"caml_list_to_js_array\"\n\n external variable : string -> 'a = \"caml_js_var\"\nend\n\nmodule Typed_array = struct\n type ('a, 'b) typedArray = Js.t\n\n type arrayBuffer = Js.t\n\n type uint8Array = Js.t\n\n external kind : ('a, 'b) typedArray -> ('a, 'b) Bigarray.kind\n = \"caml_ba_kind_of_typed_array\"\n\n external from_genarray :\n ('a, 'b, Bigarray.c_layout) Bigarray.Genarray.t -> ('a, 'b) typedArray\n = \"caml_ba_to_typed_array\"\n\n external to_genarray :\n ('a, 'b) typedArray -> ('a, 'b, Bigarray.c_layout) Bigarray.Genarray.t\n = \"caml_ba_from_typed_array\"\n\n module Bigstring = struct\n type t = (char, Bigarray.int8_unsigned_elt, Bigarray.c_layout) Bigarray.Array1.t\n\n external to_arrayBuffer : t -> arrayBuffer = \"bigstring_to_array_buffer\"\n\n external to_uint8Array : t -> uint8Array = \"bigstring_to_typed_array\"\n\n external of_arrayBuffer : arrayBuffer -> t = \"bigstring_of_array_buffer\"\n\n external of_uint8Array : uint8Array -> t = \"bigstring_of_typed_array\"\n end\n\n external of_uint8Array : uint8Array -> string = \"caml_string_of_array\"\nend\n\nmodule Int64 = struct\n external create_int64_lo_mi_hi : int -> int -> int -> Int64.t\n = \"caml_int64_create_lo_mi_hi\"\nend\n","(* Js_of_ocaml library\n * http://www.ocsigen.org/js_of_ocaml/\n * Copyright (C) 2010 Jérôme Vouillon\n * Laboratoire PPS - CNRS Université Paris Diderot\n *\n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, with linking exception;\n * either version 2.1 of the License, or (at your option) any later version.\n *\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n *)\nopen! Import\n\n(* This local module [Js] is needed so that the ppx_js extension work within that file. *)\nmodule Js = struct\n type +'a t\n\n type (-'a, +'b) meth_callback\n\n module Unsafe = struct\n type top\n\n type any = top t\n\n type any_js_array = any\n\n external inject : 'a -> any = \"%identity\"\n\n external coerce : _ t -> _ t = \"%identity\"\n\n external get : 'a -> 'b -> 'c = \"caml_js_get\"\n\n external set : 'a -> 'b -> 'c -> unit = \"caml_js_set\"\n\n external delete : 'a -> 'b -> unit = \"caml_js_delete\"\n\n external call : 'a -> 'b -> any array -> 'c = \"caml_js_call\"\n\n external fun_call : 'a -> any array -> 'b = \"caml_js_fun_call\"\n\n external meth_call : 'a -> string -> any array -> 'b = \"caml_js_meth_call\"\n\n external new_obj : 'a -> any array -> 'b = \"caml_js_new\"\n\n external new_obj_arr : 'a -> any_js_array -> 'b = \"caml_ojs_new_arr\"\n\n external obj : (string * any) array -> 'a = \"caml_js_object\"\n\n external equals : 'a -> 'b -> bool = \"caml_js_equals\"\n\n external pure_expr : (unit -> 'a) -> 'a = \"caml_js_pure_expr\"\n\n external eval_string : string -> 'a = \"caml_js_eval_string\"\n\n external js_expr : string -> 'a = \"caml_js_expr\"\n\n external pure_js_expr : string -> 'a = \"caml_pure_js_expr\"\n\n let global = pure_js_expr \"globalThis\"\n\n external callback : ('a -> 'b) -> ('c, 'a -> 'b) meth_callback = \"%identity\"\n\n external callback_with_arguments :\n (any_js_array -> 'b) -> ('c, any_js_array -> 'b) meth_callback\n = \"caml_js_wrap_callback_arguments\"\n\n external callback_with_arity : int -> ('a -> 'b) -> ('c, 'a -> 'b) meth_callback\n = \"caml_js_wrap_callback_strict\"\n\n external meth_callback : ('b -> 'a) -> ('b, 'a) meth_callback\n = \"caml_js_wrap_meth_callback_unsafe\"\n\n external meth_callback_with_arity : int -> ('b -> 'a) -> ('b, 'a) meth_callback\n = \"caml_js_wrap_meth_callback_strict\"\n\n external meth_callback_with_arguments :\n ('b -> any_js_array -> 'a) -> ('b, any_js_array -> 'a) meth_callback\n = \"caml_js_wrap_meth_callback_arguments\"\n\n (* DEPRECATED *)\n external variable : string -> 'a = \"caml_js_var\"\n end\n\n (****)\n\n type 'a opt = 'a\n\n type 'a optdef = 'a\n\n external debugger : unit -> unit = \"debugger\"\n\n let null : 'a opt = Unsafe.pure_js_expr \"null\"\n\n external some : 'a -> 'a opt = \"%identity\"\n\n let undefined : 'a optdef = Unsafe.pure_js_expr \"undefined\"\n\n external def : 'a -> 'a optdef = \"%identity\"\n\n module type OPT = sig\n type 'a t\n\n val empty : 'a t\n\n val return : 'a -> 'a t\n\n val map : 'a t -> ('a -> 'b) -> 'b t\n\n val bind : 'a t -> ('a -> 'b t) -> 'b t\n\n val test : 'a t -> bool\n\n val iter : 'a t -> ('a -> unit) -> unit\n\n val case : 'a t -> (unit -> 'b) -> ('a -> 'b) -> 'b\n\n val get : 'a t -> (unit -> 'a) -> 'a\n\n val option : 'a option -> 'a t\n\n val to_option : 'a t -> 'a option\n end\n\n module Opt : OPT with type 'a t = 'a opt = struct\n type 'a t = 'a opt\n\n let empty = null\n\n let return = some\n\n let map x f = if Unsafe.equals x null then null else return (f x)\n\n let bind x f = if Unsafe.equals x null then null else f x\n\n let test x = not (Unsafe.equals x null)\n\n let iter x f = if not (Unsafe.equals x null) then f x\n\n let case x f g = if Unsafe.equals x null then f () else g x\n\n let get x f = if Unsafe.equals x null then f () else x\n\n let option x =\n match x with\n | None -> empty\n | Some x -> return x\n\n let to_option x = case x (fun () -> None) (fun x -> Some x)\n end\n\n module Optdef : OPT with type 'a t = 'a optdef = struct\n type 'a t = 'a optdef\n\n let empty = undefined\n\n let return = def\n\n let map x f = if x == undefined then undefined else return (f x)\n\n let bind x f = if x == undefined then undefined else f x\n\n let test x = x != undefined\n\n let iter x f = if x != undefined then f x\n\n let case x f g = if x == undefined then f () else g x\n\n let get x f = if x == undefined then f () else x\n\n let option x =\n match x with\n | None -> empty\n | Some x -> return x\n\n let to_option x = case x (fun () -> None) (fun x -> Some x)\n end\n\n (****)\n\n let coerce x f g = Opt.get (f x) (fun () -> g x)\n\n let coerce_opt x f g = Opt.get (Opt.bind x f) (fun () -> g x)\n\n (****)\n\n type +'a meth\n\n type +'a gen_prop\n\n type 'a readonly_prop = < get : 'a > gen_prop\n\n type 'a writeonly_prop = < set : 'a -> unit > gen_prop\n\n type 'a prop = < get : 'a ; set : 'a -> unit > gen_prop\n\n type 'a optdef_prop = < get : 'a optdef ; set : 'a -> unit > gen_prop\n\n type +'a constr\n\n (****)\n\n type 'a callback = (unit, 'a) meth_callback\n\n external wrap_callback : ('a -> 'b) -> ('c, 'a -> 'b) meth_callback\n = \"caml_js_wrap_callback\"\n\n external wrap_meth_callback : ('a -> 'b) -> ('a, 'b) meth_callback\n = \"caml_js_wrap_meth_callback\"\n\n (****)\n\n let _true = Unsafe.pure_js_expr \"true\"\n\n let _false = Unsafe.pure_js_expr \"false\"\n\n type match_result_handle\n\n type string_array\n\n class type js_string =\n object\n method toString : js_string t meth\n\n method valueOf : js_string t meth\n\n method charAt : int -> js_string t meth\n\n method charCodeAt : int -> float meth\n\n (* This may return NaN... *)\n method concat : js_string t -> js_string t meth\n\n method concat_2 : js_string t -> js_string t -> js_string t meth\n\n method concat_3 : js_string t -> js_string t -> js_string t -> js_string t meth\n\n method concat_4 :\n js_string t -> js_string t -> js_string t -> js_string t -> js_string t meth\n\n method indexOf : js_string t -> int meth\n\n method indexOf_from : js_string t -> int -> int meth\n\n method lastIndexOf : js_string t -> int meth\n\n method lastIndexOf_from : js_string t -> int -> int meth\n\n method localeCompare : js_string t -> float meth\n\n method _match : regExp t -> match_result_handle t opt meth\n\n method replace : regExp t -> js_string t -> js_string t meth\n\n method replace_string : js_string t -> js_string t -> js_string t meth\n\n method search : regExp t -> int meth\n\n method slice : int -> int -> js_string t meth\n\n method slice_end : int -> js_string t meth\n\n method split : js_string t -> string_array t meth\n\n method split_limited : js_string t -> int -> string_array t meth\n\n method split_regExp : regExp t -> string_array t meth\n\n method split_regExpLimited : regExp t -> int -> string_array t meth\n\n method substring : int -> int -> js_string t meth\n\n method substring_toEnd : int -> js_string t meth\n\n method toLowerCase : js_string t meth\n\n method toLocaleLowerCase : js_string t meth\n\n method toUpperCase : js_string t meth\n\n method toLocaleUpperCase : js_string t meth\n\n method trim : js_string t meth\n\n method length : int readonly_prop\n end\n\n and regExp =\n object\n method exec : js_string t -> match_result_handle t opt meth\n\n method test : js_string t -> bool t meth\n\n method toString : js_string t meth\n\n method source : js_string t readonly_prop\n\n method global : bool t readonly_prop\n\n method ignoreCase : bool t readonly_prop\n\n method multiline : bool t readonly_prop\n\n method lastIndex : int prop\n end\n\n (* string is used by ppx_js, it needs to come before any use of the\n new syntax in this file *)\n external string : string -> js_string t = \"caml_jsstring_of_string\"\n\n external to_string : js_string t -> string = \"caml_string_of_jsstring\"\nend\n\ninclude Js\n\nclass type string_constr =\n object\n method fromCharCode : int -> js_string t meth\n end\n\nlet string_constr = Unsafe.global##._String\n\nlet regExp = Unsafe.global##._RegExp\n\nlet regExp_copy = regExp\n\nlet regExp_withFlags = regExp\n\nclass type ['a] js_array =\n object\n method toString : js_string t meth\n\n method toLocaleString : js_string t meth\n\n method concat : 'a js_array t -> 'a js_array t meth\n\n method join : js_string t -> js_string t meth\n\n method pop : 'a optdef meth\n\n method push : 'a -> int meth\n\n method push_2 : 'a -> 'a -> int meth\n\n method push_3 : 'a -> 'a -> 'a -> int meth\n\n method push_4 : 'a -> 'a -> 'a -> 'a -> int meth\n\n method reverse : 'a js_array t meth\n\n method shift : 'a optdef meth\n\n method slice : int -> int -> 'a js_array t meth\n\n method slice_end : int -> 'a js_array t meth\n\n method sort : ('a -> 'a -> float) callback -> 'a js_array t meth\n\n method sort_asStrings : 'a js_array t meth\n\n method splice : int -> int -> 'a js_array t meth\n\n method splice_1 : int -> int -> 'a -> 'a js_array t meth\n\n method splice_2 : int -> int -> 'a -> 'a -> 'a js_array t meth\n\n method splice_3 : int -> int -> 'a -> 'a -> 'a -> 'a js_array t meth\n\n method splice_4 : int -> int -> 'a -> 'a -> 'a -> 'a -> 'a js_array t meth\n\n method unshift : 'a -> int meth\n\n method unshift_2 : 'a -> 'a -> int meth\n\n method unshift_3 : 'a -> 'a -> 'a -> int meth\n\n method unshift_4 : 'a -> 'a -> 'a -> 'a -> int meth\n\n method some : ('a -> int -> 'a js_array t -> bool t) callback -> bool t meth\n\n method every : ('a -> int -> 'a js_array t -> bool t) callback -> bool t meth\n\n method forEach : ('a -> int -> 'a js_array t -> unit) callback -> unit meth\n\n method map : ('a -> int -> 'a js_array t -> 'b) callback -> 'b js_array t meth\n\n method filter : ('a -> int -> 'a js_array t -> bool t) callback -> 'a js_array t meth\n\n method reduce_init :\n ('b -> 'a -> int -> 'a js_array t -> 'b) callback -> 'b -> 'b meth\n\n method reduce : ('a -> 'a -> int -> 'a js_array t -> 'a) callback -> 'a meth\n\n method reduceRight_init :\n ('b -> 'a -> int -> 'a js_array t -> 'b) callback -> 'b -> 'b meth\n\n method reduceRight : ('a -> 'a -> int -> 'a js_array t -> 'a) callback -> 'a meth\n\n method length : int prop\n end\n\nlet object_constructor = Unsafe.global##._Object\n\nlet object_keys o : js_string t js_array t = object_constructor##keys o\n\nlet array_constructor = Unsafe.global##._Array\n\nlet array_empty = array_constructor\n\nlet array_length = array_constructor\n\nlet array_get : 'a #js_array t -> int -> 'a optdef = Unsafe.get\n\nlet array_set : 'a #js_array t -> int -> 'a -> unit = Unsafe.set\n\nlet array_map_poly :\n 'a #js_array t -> ('a -> int -> 'a #js_array t -> 'b) callback -> 'b #js_array t =\n fun a cb -> (Unsafe.coerce a)##map cb\n\nlet array_map f a = array_map_poly a (wrap_callback (fun x _idx _ -> f x))\n\nlet array_mapi f a = array_map_poly a (wrap_callback (fun x idx _ -> f idx x))\n\nclass type match_result =\n object\n inherit [js_string t] js_array\n\n method index : int readonly_prop\n\n method input : js_string t readonly_prop\n end\n\nlet str_array : string_array t -> js_string t js_array t = Unsafe.coerce\n\nlet match_result : match_result_handle t -> match_result t = Unsafe.coerce\n\nclass type number =\n object\n method toString : js_string t meth\n\n method toString_radix : int -> js_string t meth\n\n method toLocaleString : js_string t meth\n\n method toFixed : int -> js_string t meth\n\n method toExponential : js_string t meth\n\n method toExponential_digits : int -> js_string t meth\n\n method toPrecision : int -> js_string t meth\n end\n\nexternal number_of_float : float -> number t = \"caml_js_from_float\"\n\nexternal float_of_number : number t -> float = \"caml_js_to_float\"\n\nclass type date =\n object\n method toString : js_string t meth\n\n method toDateString : js_string t meth\n\n method toTimeString : js_string t meth\n\n method toLocaleString : js_string t meth\n\n method toLocaleDateString : js_string t meth\n\n method toLocaleTimeString : js_string t meth\n\n method valueOf : float meth\n\n method getTime : float meth\n\n method getFullYear : int meth\n\n method getUTCFullYear : int meth\n\n method getMonth : int meth\n\n method getUTCMonth : int meth\n\n method getDate : int meth\n\n method getUTCDate : int meth\n\n method getDay : int meth\n\n method getUTCDay : int meth\n\n method getHours : int meth\n\n method getUTCHours : int meth\n\n method getMinutes : int meth\n\n method getUTCMinutes : int meth\n\n method getSeconds : int meth\n\n method getUTCSeconds : int meth\n\n method getMilliseconds : int meth\n\n method getUTCMilliseconds : int meth\n\n method getTimezoneOffset : int meth\n\n method setTime : float -> float meth\n\n method setFullYear : int -> float meth\n\n method setUTCFullYear : int -> float meth\n\n method setMonth : int -> float meth\n\n method setUTCMonth : int -> float meth\n\n method setDate : int -> float meth\n\n method setUTCDate : int -> float meth\n\n method setDay : int -> float meth\n\n method setUTCDay : int -> float meth\n\n method setHours : int -> float meth\n\n method setUTCHours : int -> float meth\n\n method setMinutes : int -> float meth\n\n method setUTCMinutes : int -> float meth\n\n method setSeconds : int -> float meth\n\n method setUTCSeconds : int -> float meth\n\n method setMilliseconds : int -> float meth\n\n method setUTCMilliseconds : int -> float meth\n\n method toUTCString : js_string t meth\n\n method toISOString : js_string t meth\n\n method toJSON : 'a -> js_string t meth\n end\n\nclass type date_constr =\n object\n method parse : js_string t -> float meth\n\n method _UTC_month : int -> int -> float meth\n\n method _UTC_day : int -> int -> float meth\n\n method _UTC_hour : int -> int -> int -> int -> float meth\n\n method _UTC_min : int -> int -> int -> int -> int -> float meth\n\n method _UTC_sec : int -> int -> int -> int -> int -> int -> float meth\n\n method _UTC_ms : int -> int -> int -> int -> int -> int -> int -> float meth\n\n method now : float meth\n end\n\nlet date_constr = Unsafe.global##._Date\n\nlet date : date_constr t = date_constr\n\nlet date_now : date t constr = date_constr\n\nlet date_fromTimeValue : (float -> date t) constr = date_constr\n\nlet date_month : (int -> int -> date t) constr = date_constr\n\nlet date_day : (int -> int -> int -> date t) constr = date_constr\n\nlet date_hour : (int -> int -> int -> int -> date t) constr = date_constr\n\nlet date_min : (int -> int -> int -> int -> int -> date t) constr = date_constr\n\nlet date_sec : (int -> int -> int -> int -> int -> int -> date t) constr = date_constr\n\nlet date_ms : (int -> int -> int -> int -> int -> int -> int -> date t) constr =\n date_constr\n\nclass type math =\n object\n method _E : float readonly_prop\n\n method _LN2 : float readonly_prop\n\n method _LN10 : float readonly_prop\n\n method _LOG2E : float readonly_prop\n\n method _LOG10E : float readonly_prop\n\n method _PI : float readonly_prop\n\n method _SQRT1_2_ : float readonly_prop\n\n method _SQRT2 : float readonly_prop\n\n method abs : float -> float meth\n\n method acos : float -> float meth\n\n method asin : float -> float meth\n\n method atan : float -> float meth\n\n method atan2 : float -> float -> float meth\n\n method ceil : float -> float meth\n\n method cos : float -> float meth\n\n method exp : float -> float meth\n\n method floor : float -> float meth\n\n method log : float -> float meth\n\n method max : float -> float -> float meth\n\n method max_3 : float -> float -> float -> float meth\n\n method max_4 : float -> float -> float -> float -> float meth\n\n method min : float -> float -> float meth\n\n method min_3 : float -> float -> float -> float meth\n\n method min_4 : float -> float -> float -> float -> float meth\n\n method pow : float -> float -> float meth\n\n method random : float meth\n\n method round : float -> float meth\n\n method sin : float -> float meth\n\n method sqrt : float -> float meth\n\n method tan : float -> float meth\n end\n\nlet math = Unsafe.global##._Math\n\nclass type error =\n object\n method name : js_string t prop\n\n method message : js_string t prop\n\n method stack : js_string t optdef prop\n\n method toString : js_string t meth\n end\n\nlet error_constr = Unsafe.global##._Error\n\nmodule Js_error = struct\n type error_t = error t\n\n include Jsoo_runtime.Error\n\n external of_error : error_t -> t = \"%identity\"\n\n external to_error : t -> error_t = \"%identity\"\n\n let name e = to_string (to_error e)##.name\n\n let message e = to_string (to_error e)##.message\n\n let stack (e : t) : string option =\n Opt.to_option (Opt.map (to_error e)##.stack to_string)\n\n let to_string e = to_string (to_error e)##toString\nend\n\nmodule Magic = struct\n module type T = sig\n exception Error of error t\n end\n\n type ('a, 'b) eq = Eq : ('a, 'a) eq\n\n let (eq : (error t, Js_error.t) eq) = Obj.magic Eq\n\n let m =\n match eq with\n | Eq ->\n (module struct\n exception Error = Js_error.Exn\n end : T)\n\n module Error = (val m : T)\nend\n\ninclude Magic.Error\n\nlet raise_js_error e = Js_error.raise_ (Js_error.of_error e)\n\nlet string_of_error e = Js_error.to_string (Js_error.of_error e)\n\nlet exn_with_js_backtrace = Js_error.attach_js_backtrace\n\nexternal js_error_of_exn : exn -> error t opt = \"caml_js_error_of_exception\"\n\nclass type json =\n object\n method parse : js_string t -> 'a meth\n\n method stringify : 'a -> js_string t meth\n end\n\nlet _JSON : json t = Unsafe.global##._JSON\n\nlet decodeURI (s : js_string t) : js_string t =\n Unsafe.fun_call Unsafe.global##.decodeURI [| Unsafe.inject s |]\n\nlet decodeURIComponent (s : js_string t) : js_string t =\n Unsafe.fun_call Unsafe.global##.decodeURIComponent [| Unsafe.inject s |]\n\nlet encodeURI (s : js_string t) : js_string t =\n Unsafe.fun_call Unsafe.global##.encodeURI [| Unsafe.inject s |]\n\nlet encodeURIComponent (s : js_string t) : js_string t =\n Unsafe.fun_call Unsafe.global##.encodeURIComponent [| Unsafe.inject s |]\n\nlet escape (s : js_string t) : js_string t =\n Unsafe.fun_call Unsafe.global##.escape [| Unsafe.inject s |]\n\nlet unescape (s : js_string t) : js_string t =\n Unsafe.fun_call Unsafe.global##.unescape [| Unsafe.inject s |]\n\nexternal bool : bool -> bool t = \"caml_js_from_bool\"\n\nexternal to_bool : bool t -> bool = \"caml_js_to_bool\"\n\nexternal array : 'a array -> 'a js_array t = \"caml_js_from_array\"\n\nexternal to_array : 'a js_array t -> 'a array = \"caml_js_to_array\"\n\nexternal bytestring : string -> js_string t = \"caml_jsbytes_of_string\"\n\nexternal to_bytestring : js_string t -> string = \"caml_string_of_jsbytes\"\n\nexternal typeof : _ t -> js_string t = \"caml_js_typeof\"\n\nexternal instanceof : _ t -> _ constr -> bool = \"caml_js_instanceof\"\n\nlet isNaN (i : 'a) : bool =\n to_bool (Unsafe.fun_call Unsafe.global##.isNaN [| Unsafe.inject i |])\n\nlet parseInt (s : js_string t) : int =\n let s = Unsafe.fun_call Unsafe.global##.parseInt [| Unsafe.inject s |] in\n if isNaN s then failwith \"parseInt\" else s\n\nlet parseFloat (s : js_string t) : float =\n let s = Unsafe.fun_call Unsafe.global##.parseFloat [| Unsafe.inject s |] in\n if isNaN s then failwith \"parseFloat\" else s\n\nlet _ =\n Printexc.register_printer (function\n | Js_error.Exn e -> Some (Js_error.to_string e)\n | _ -> None)\n\nlet _ =\n Printexc.register_printer (fun e ->\n let e : < .. > t = Obj.magic e in\n if instanceof e array_constructor then None else Some (to_string e##toString))\n\nlet export_js (field : js_string t) x =\n Unsafe.set (Unsafe.pure_js_expr \"jsoo_exports\") field x\n\nlet export field x = export_js (string field) x\n\nlet export_all obj =\n let keys = object_keys obj in\n keys##forEach\n (wrap_callback (fun (key : js_string t) _ _ -> export_js key (Unsafe.get obj key)))\n\n(****)\n\n(* DEPRECATED *)\n\ntype float_prop = float prop\n\nexternal float : float -> float = \"%identity\"\n\nexternal to_float : float -> float = \"%identity\"\n","open Core_kernel\nmodule Js = Js_of_ocaml.Js\n\nlet _console_log_string s = Js_of_ocaml.Firebug.console##log (Js.string s)\n\nlet _console_log s = Js_of_ocaml.Firebug.console##log s\n\nlet _console_dir s : unit =\n let f =\n Js.Unsafe.eval_string {js|(function(s) { console.dir(s, {depth: 5}); })|js}\n in\n Js.Unsafe.(fun_call f [| inject s |])\n\nlet raise_error s =\n Js.Js_error.(raise_ @@ of_error (new%js Js.error_constr (Js.string s)))\n\nexternal raise_exn_js : exn -> Js.js_string Js.t -> 'a = \"custom_reraise_exn\"\n\nlet raise_exn exn = raise_exn_js exn (Js.string (Exn.to_string exn))\n\nlet json_parse (str : Js.js_string Js.t) =\n Js.Unsafe.(fun_call global ##. JSON##.parse [| inject str |])\n","module Js = Js_of_ocaml.Js\n\nlet export () =\n Js.export \"Snarky\" Snarky_bindings.snarky ;\n Js.export \"Ledger\" Local_ledger.ledger_class ;\n Js.export \"Pickles\" Pickles_bindings.pickles ;\n Js.export \"Test\" Consistency_test.test\n\nlet export_global () =\n let snarky_obj =\n Js.Unsafe.(\n let i = inject in\n obj\n [| (\"Snarky\", i Snarky_bindings.snarky)\n ; (\"Ledger\", i Local_ledger.ledger_class)\n ; (\"Pickles\", i Pickles_bindings.pickles)\n ; (\"Test\", i Consistency_test.test)\n |])\n in\n Js.Unsafe.(set global (Js.string \"__snarky\") snarky_obj)\n","let () = Snarky_js_bindings_lib.export_global ()\n\nlet () = Snarky_js_bindings_lib.export ()\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. *)\n(* *)\n(* All rights reserved. This file is distributed under the terms of *)\n(* the GNU Lesser General Public License version 2.1, with the *)\n(* special exception on linking described in the file LICENSE. *)\n(* *)\n(**************************************************************************)\n\n(* Ensure that [at_exit] functions are called at the end of every program *)\n\nlet _ = do_at_exit()\n"]} \ No newline at end of file diff --git a/compiled/web_bindings/snarky_js_web.bc.js b/compiled/web_bindings/snarky_js_web.bc.js index a0f2b946..a622c094 100644 --- a/compiled/web_bindings/snarky_js_web.bc.js +++ b/compiled/web_bindings/snarky_js_web.bc.js @@ -1,7 +1,7 @@ "use strict";(function(_){typeof globalThis!="object"&&(this?u():(_.defineProperty(_.prototype,"_T_",{configurable:!0,get:u}),_T_));function u(){var d=this||self;d.globalThis=d,delete _.prototype._T_}})(Object),function(_){var u=_;(function(){var d={days:["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],shortDays:["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],months:["January","February","March","April","May","June","July","August","September","October","November","December"],shortMonths:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"],AM:"AM",PM:"PM",am:"am",pm:"pm",formats:{D:"%m/%d/%y",F:"%Y-%m-%d",R:"%H:%M",T:"%H:%M:%S",X:"%T",c:"%a %b %d %X %Y",r:"%I:%M:%S %p",v:"%e-%b-%Y",x:"%D"}},$=new G(d,0,!1),w=typeof module<"u",q;w?(q=module.exports=L,q.strftime=U,u&&(u.strftime=L)):(q=u||function(){return this||(0,eval)("this")}(),q.strftime=L);var z=w?"require('strftime')":"strftime",P={};function N(e_,r_){P[e_]||(typeof console<"u"&&typeof console.warn=="function"&&console.warn("[WARNING] "+e_+" is deprecated and will be removed in version 1.0. Instead, use `"+r_+"`."),P[e_]=!0)}q.strftimeTZ=Y,q.strftimeUTC=W,q.localizedStrftime=K;function V(e_){e_.localize=$.localize.bind($),e_.timezone=$.timezone.bind($),e_.utc=$.utc.bind($)}V(L);function L(e_,r_,n_){r_&&r_.days&&(n_=r_,r_=void 0),n_&&N("`"+z+"(format, [date], [locale])`","var s = "+z+".localize(locale); s(format, [date])");var a_=n_?$.localize(n_):$;return a_(e_,r_)}V(U);function U(e_,r_,n_){n_?N("`"+z+".strftime(format, [date], [locale])`","var s = "+z+".localize(locale); s(format, [date])"):N("`"+z+".strftime(format, [date])`",z+"(format, [date])");var a_=n_?$.localize(n_):$;return a_(e_,r_)}function Y(e_,r_,n_,a_){(typeof n_=="number"||typeof n_=="string")&&a_==null&&(a_=n_,n_=void 0),n_?N("`"+z+".strftimeTZ(format, date, locale, tz)`","var s = "+z+".localize(locale).timezone(tz); s(format, [date])` or `var s = "+z+".localize(locale); s.timezone(tz)(format, [date])"):N("`"+z+".strftimeTZ(format, date, tz)`","var s = "+z+".timezone(tz); s(format, [date])` or `"+z+".timezone(tz)(format, [date])");var c_=(n_?$.localize(n_):$).timezone(a_);return c_(e_,r_)}var R=$.utc();function W(e_,r_,n_){n_?N("`"+z+".strftimeUTC(format, date, locale)`","var s = "+z+".localize(locale).utc(); s(format, [date])"):N("`"+z+".strftimeUTC(format, [date])`","var s = "+z+".utc(); s(format, [date])");var a_=n_?R.localize(n_):R;return a_(e_,r_)}function K(e_){return N("`"+z+".localizedStrftime(locale)`",z+".localize(locale)"),$.localize(e_)}typeof Date.now!="function"&&(Date.now=function(){return+new Date});function G(e_,r_,n_){var a_=e_||d,c_=r_||0,l_=n_||!1,s_=0,u_;function f_(b_,p_){var d_;if(p_)d_=p_.getTime(),l_&&(p_=new Date(p_.getTime()+t_(p_)+c_));else{var g_=Date.now();g_>s_&&(s_=g_,u_=new Date(s_),d_=s_,l_&&(u_=new Date(s_+t_(u_)+c_))),p_=u_}return o_(b_,p_,a_,d_)}function o_(b_,p_,d_,g_){for(var y_="",v_=null,w_=!1,j_=b_.length,E_=!1,L_=0;L_9?e_:(r_==null&&(r_="0"),r_+e_)}function J(e_){return e_>99?e_:e_>9?"0"+e_:"00"+e_}function I(e_){return e_===0?12:e_>12?e_-12:e_}function Q(e_,r_){r_=r_||"sunday";var n_=e_.getDay();r_==="monday"&&(n_===0?n_=6:n_--);var a_=Date.UTC(e_.getFullYear(),0,1),c_=Date.UTC(e_.getFullYear(),e_.getMonth(),e_.getDate()),l_=Math.floor((c_-a_)/864e5),s_=(l_+7-n_)/7;return Math.floor(s_)}function __(e_){var r_=e_%10,n_=e_%100;if(n_>=11&&n_<=13||r_===0||r_>=4)return"th";switch(r_){case 1:return"st";case 2:return"nd";case 3:return"rd"}}function t_(e_){return(e_.getTimezoneOffset()||0)*6e4}})()}(globalThis),function(globalThis){"use strict";var joo_global_object=globalThis;function Base_am_testing(_){return 0}function caml_mul(_,u){return Math.imul(_,u)}function caml_hash_mix_int(_,u){return u=caml_mul(u,-862048943),u=u<<15|u>>>32-15,u=caml_mul(u,461845907),_^=u,_=_<<13|_>>>32-13,(_+(_<<2)|0)+-430675100|0}function caml_hash_mix_jsbytes(_,u){var d=u.length,$,w;for($=0;$+4<=d;$+=4)w=u.charCodeAt($)|u.charCodeAt($+1)<<8|u.charCodeAt($+2)<<16|u.charCodeAt($+3)<<24,_=caml_hash_mix_int(_,w);switch(w=0,d&3){case 3:w=u.charCodeAt($+2)<<16;case 2:w|=u.charCodeAt($+1)<<8;case 1:w|=u.charCodeAt($),_=caml_hash_mix_int(_,w)}return _^=d,_}var log2_ok=Math.log2&&Math.log2(11235582092889474e291)==1020;function jsoo_floor_log2(_){if(log2_ok)return Math.floor(Math.log2(_));var u=0;if(_==0)return-1/0;if(_>=1)for(;_>=2;)_/=2,u++;else for(;_<1;)_*=2,u--;return u}var caml_int64_offset=Math.pow(2,-24);function caml_raise_constant(_){throw _}var caml_global_data=[0];function caml_raise_zero_divide(){caml_raise_constant(caml_global_data.Division_by_zero)}function MlInt64(_,u,d){this.lo=_&16777215,this.mi=u&16777215,this.hi=d&65535}MlInt64.prototype.caml_custom="_j",MlInt64.prototype.copy=function(){return new MlInt64(this.lo,this.mi,this.hi)},MlInt64.prototype.ucompare=function(_){return this.hi>_.hi?1:this.hi<_.hi?-1:this.mi>_.mi?1:this.mi<_.mi?-1:this.lo>_.lo?1:this.lo<_.lo?-1:0},MlInt64.prototype.compare=function(_){var u=this.hi<<16,d=_.hi<<16;return u>d?1:u_.mi?1:this.mi<_.mi?-1:this.lo>_.lo?1:this.lo<_.lo?-1:0},MlInt64.prototype.neg=function(){var _=-this.lo,u=-this.mi+(_>>24),d=-this.hi+(u>>24);return new MlInt64(_,u,d)},MlInt64.prototype.add=function(_){var u=this.lo+_.lo,d=this.mi+_.mi+(u>>24),$=this.hi+_.hi+(d>>24);return new MlInt64(u,d,$)},MlInt64.prototype.sub=function(_){var u=this.lo-_.lo,d=this.mi-_.mi+(u>>24),$=this.hi-_.hi+(d>>24);return new MlInt64(u,d,$)},MlInt64.prototype.mul=function(_){var u=this.lo*_.lo,d=(u*caml_int64_offset|0)+this.mi*_.lo+this.lo*_.mi,$=(d*caml_int64_offset|0)+this.hi*_.lo+this.mi*_.mi+this.lo*_.hi;return new MlInt64(u,d,$)},MlInt64.prototype.isZero=function(){return(this.lo|this.mi|this.hi)==0},MlInt64.prototype.isNeg=function(){return this.hi<<16<0},MlInt64.prototype.and=function(_){return new MlInt64(this.lo&_.lo,this.mi&_.mi,this.hi&_.hi)},MlInt64.prototype.or=function(_){return new MlInt64(this.lo|_.lo,this.mi|_.mi,this.hi|_.hi)},MlInt64.prototype.xor=function(_){return new MlInt64(this.lo^_.lo,this.mi^_.mi,this.hi^_.hi)},MlInt64.prototype.shift_left=function(_){return _=_&63,_==0?this:_<24?new MlInt64(this.lo<<_,this.mi<<_|this.lo>>24-_,this.hi<<_|this.mi>>24-_):_<48?new MlInt64(0,this.lo<<_-24,this.mi<<_-24|this.lo>>48-_):new MlInt64(0,0,this.lo<<_-48)},MlInt64.prototype.shift_right_unsigned=function(_){return _=_&63,_==0?this:_<24?new MlInt64(this.lo>>_|this.mi<<24-_,this.mi>>_|this.hi<<24-_,this.hi>>_):_<48?new MlInt64(this.mi>>_-24|this.hi<<48-_,this.hi>>_-24,0):new MlInt64(this.hi>>_-48,0,0)},MlInt64.prototype.shift_right=function(_){if(_=_&63,_==0)return this;var u=this.hi<<16>>16;if(_<24)return new MlInt64(this.lo>>_|this.mi<<24-_,this.mi>>_|u<<24-_,this.hi<<16>>_>>>16);var d=this.hi<<16>>31;return _<48?new MlInt64(this.mi>>_-24|this.hi<<48-_,this.hi<<16>>_-24>>16,d&65535):new MlInt64(this.hi<<16>>_-32,d,d)},MlInt64.prototype.lsl1=function(){this.hi=this.hi<<1|this.mi>>23,this.mi=(this.mi<<1|this.lo>>23)&16777215,this.lo=this.lo<<1&16777215},MlInt64.prototype.lsr1=function(){this.lo=(this.lo>>>1|this.mi<<23)&16777215,this.mi=(this.mi>>>1|this.hi<<23)&16777215,this.hi=this.hi>>>1},MlInt64.prototype.udivmod=function(_){for(var u=0,d=this.copy(),$=_.copy(),w=new MlInt64(0,0,0);d.ucompare($)>0;)u++,$.lsl1();for(;u>=0;)u--,w.lsl1(),d.ucompare($)>=0&&(w.lo++,d=d.sub($)),$.lsr1();return{quotient:w,modulus:d}},MlInt64.prototype.div=function(_){var u=this;_.isZero()&&caml_raise_zero_divide();var d=u.hi^_.hi;u.hi&32768&&(u=u.neg()),_.hi&32768&&(_=_.neg());var $=u.udivmod(_).quotient;return d&32768&&($=$.neg()),$},MlInt64.prototype.mod=function(_){var u=this;_.isZero()&&caml_raise_zero_divide();var d=u.hi;u.hi&32768&&(u=u.neg()),_.hi&32768&&(_=_.neg());var $=u.udivmod(_).modulus;return d&32768&&($=$.neg()),$},MlInt64.prototype.toInt=function(){return this.lo|this.mi<<24},MlInt64.prototype.toFloat=function(){return(this.hi<<16)*Math.pow(2,32)+this.mi*Math.pow(2,24)+this.lo},MlInt64.prototype.toArray=function(){return[this.hi>>8,this.hi&255,this.mi>>16,this.mi>>8&255,this.mi&255,this.lo>>16,this.lo>>8&255,this.lo&255]},MlInt64.prototype.lo32=function(){return this.lo|(this.mi&255)<<24},MlInt64.prototype.hi32=function(){return this.mi>>>8&65535|this.hi<<16};function caml_int64_create_lo_mi_hi(_,u,d){return new MlInt64(_,u,d)}function caml_int64_bits_of_float(_){if(!isFinite(_))return isNaN(_)?caml_int64_create_lo_mi_hi(1,0,32752):_>0?caml_int64_create_lo_mi_hi(0,0,32752):caml_int64_create_lo_mi_hi(0,0,65520);var u=_==0&&1/_==-1/0?32768:_>=0?0:32768;u&&(_=-_);var d=jsoo_floor_log2(_)+1023;d<=0?(d=0,_/=Math.pow(2,-1026)):(_/=Math.pow(2,d-1027),_<16&&(_*=2,d-=1),d==0&&(_/=2));var $=Math.pow(2,24),w=_|0;_=(_-w)*$;var q=_|0;_=(_-q)*$;var z=_|0;return w=w&15|u|d<<4,caml_int64_create_lo_mi_hi(z,q,w)}function caml_int64_lo32(_){return _.lo32()}function caml_int64_hi32(_){return _.hi32()}function caml_hash_mix_int64(_,u){return _=caml_hash_mix_int(_,caml_int64_lo32(u)),_=caml_hash_mix_int(_,caml_int64_hi32(u)),_}function caml_hash_mix_float(_,u){return caml_hash_mix_int64(_,caml_int64_bits_of_float(u))}function caml_str_repeat(_,u){if(_==0)return"";if(u.repeat)return u.repeat(_);for(var d="",$=0;;){if(_&1&&(d+=u),_>>=1,_==0)return d;u+=u,$++,$==9&&u.slice(0,1)}}function caml_subarray_to_jsbytes(_,u,d){var $=String.fromCharCode;if(u==0&&d<=4096&&d==_.length)return $.apply(null,_);for(var w="";0127)return!1;return!0}else return!/[^\x00-\x7f]/.test(_)}function caml_utf16_of_utf8(_){for(var u="",d="",$,w,q,z,P=0,N=_.length;P512?(d.substr(0,1),u+=d,d="",u+=_.slice(P,V)):d+=_.slice(P,V),V==N)break;P=V}z=1,++P=55295&&z<57344)&&(z=2)):(z=3,++P1114111)&&(z=3)))))),z<4?(P-=z,d+="\uFFFD"):z>65535?d+=String.fromCharCode(55232+(z>>10),56320+(z&1023)):d+=String.fromCharCode(z),d.length>1024&&(d.substr(0,1),u+=d,d="")}return u+d}function MlBytes(_,u,d){this.t=_,this.c=u,this.l=d}MlBytes.prototype.toString=function(){switch(this.t){case 9:return this.c;default:caml_convert_string_to_bytes(this);case 0:if(jsoo_is_ascii(this.c))return this.t=9,this.c;this.t=8;case 8:return this.c}},MlBytes.prototype.toUtf16=function(){var _=this.toString();return this.t==9?_:caml_utf16_of_utf8(_)},MlBytes.prototype.slice=function(){var _=this.t==4?this.c.slice():this.c;return new MlBytes(this.t,_,this.l)};function caml_ml_bytes_content(_){switch(_.t&6){default:caml_convert_string_to_bytes(_);case 0:return _.c;case 4:return _.c}}function caml_hash_mix_bytes(_,u){var d=caml_ml_bytes_content(u);return typeof d=="string"?caml_hash_mix_jsbytes(_,d):caml_hash_mix_bytes_arr(_,d)}function caml_int32_bits_of_float(_){var u=new globalThis.Float32Array(1);u[0]=_;var d=new globalThis.Int32Array(u.buffer);return d[0]|0}function caml_int64_to_bytes(_){return _.toArray()}function caml_ba_serialize(_,u,d){if(_.write(32,u.dims.length),_.write(32,u.kind|u.layout<<8),u.caml_custom=="_bigarr02")for(var $=0;$>4;if(w==2047)return u|d|$&15?NaN:$&32768?-1/0:1/0;var q=Math.pow(2,-24),z=(u*q+d)*q+($&15);return w>0?(z+=16,z*=Math.pow(2,w-1027)):z*=Math.pow(2,-1026),$&32768&&(z=-z),z}function caml_ba_get_size(_){for(var u=_.length,d=1,$=0;$>>24&255|(u&65535)<<8,u>>>16&65535)}function caml_array_bound_error(){caml_invalid_argument("index out of bounds")}var caml_ba_custom_name="_bigarr02";function Ml_Bigarray(_,u,d,$){this.kind=_,this.layout=u,this.dims=d,this.data=$}Ml_Bigarray.prototype.caml_custom=caml_ba_custom_name,Ml_Bigarray.prototype.offset=function(_){var u=0;if(typeof _=="number"&&(_=[_]),_ instanceof Array||caml_invalid_argument("bigarray.js: invalid offset"),this.dims.length!=_.length&&caml_invalid_argument("Bigarray.get/set: bad number of dimensions"),this.layout==0)for(var d=0;d=this.dims[d])&&caml_array_bound_error(),u=u*this.dims[d]+_[d];else for(var d=this.dims.length-1;d>=0;d--)(_[d]<1||_[d]>this.dims[d])&&caml_array_bound_error(),u=u*this.dims[d]+(_[d]-1);return u},Ml_Bigarray.prototype.get=function(_){switch(this.kind){case 7:var u=this.data[_*2+0],d=this.data[_*2+1];return caml_int64_create_lo_hi(u,d);case 10:case 11:var $=this.data[_*2+0],w=this.data[_*2+1];return[254,$,w];default:return this.data[_]}},Ml_Bigarray.prototype.set=function(_,u){switch(this.kind){case 7:this.data[_*2+0]=caml_int64_lo32(u),this.data[_*2+1]=caml_int64_hi32(u);break;case 10:case 11:this.data[_*2+0]=u[1],this.data[_*2+1]=u[2];break;default:this.data[_]=u;break}return 0},Ml_Bigarray.prototype.fill=function(_){switch(this.kind){case 7:var u=caml_int64_lo32(_),d=caml_int64_hi32(_);if(u==d)this.data.fill(u);else for(var $=0;$z)return 1;if(q!=z){if(!u)return NaN;if(q==q)return 1;if(z==z)return-1}}break;case 7:for(var w=0;w_.data[w+1])return 1;if(this.data[w]>>>0<_.data[w]>>>0)return-1;if(this.data[w]>>>0>_.data[w]>>>0)return 1}break;case 2:case 3:case 4:case 5:case 6:case 8:case 9:case 12:for(var w=0;w_.data[w])return 1}break}return 0};function Ml_Bigarray_c_1_1(_,u,d,$){this.kind=_,this.layout=u,this.dims=d,this.data=$}Ml_Bigarray_c_1_1.prototype=new Ml_Bigarray,Ml_Bigarray_c_1_1.prototype.offset=function(_){return typeof _!="number"&&(_ instanceof Array&&_.length==1?_=_[0]:caml_invalid_argument("Ml_Bigarray_c_1_1.offset")),(_<0||_>=this.dims[0])&&caml_array_bound_error(),_},Ml_Bigarray_c_1_1.prototype.get=function(_){return this.data[_]},Ml_Bigarray_c_1_1.prototype.set=function(_,u){return this.data[_]=u,0},Ml_Bigarray_c_1_1.prototype.fill=function(_){return this.data.fill(_),0};function caml_ba_create_unsafe(_,u,d,$){var w=caml_ba_get_size_per_element(_);return caml_ba_get_size(d)*w!=$.length&&caml_invalid_argument("length doesn't match dims"),u==0&&d.length==1&&w==1?new Ml_Bigarray_c_1_1(_,u,d,$):new Ml_Bigarray(_,u,d,$)}function caml_bytes_of_jsbytes(_){return new MlBytes(0,_,_.length)}function caml_string_of_jsbytes(_){return caml_bytes_of_jsbytes(_)}function caml_failwith(_){caml_global_data.Failure||(caml_global_data.Failure=[248,caml_string_of_jsbytes("Failure"),-3]),caml_raise_with_string(caml_global_data.Failure,_)}function caml_ba_deserialize(_,u,d){var $=_.read32s();($<0||$>16)&&caml_failwith("input_value: wrong number of bigarray dimensions");var w=_.read32s(),q=w&255,z=w>>8&1,P=[];if(d=="_bigarr02")for(var N=0;N<$;N++){var V=_.read16u();if(V==65535){var L=_.read32u(),U=_.read32u();L!=0&&caml_failwith("input_value: bigarray dimension overflow in 32bit"),V=U}P.push(V)}else for(var N=0;N<$;N++)P.push(_.read32u());var Y=caml_ba_get_size(P),R=caml_ba_create_buffer(q,Y),W=caml_ba_create_unsafe(q,z,P,R);switch(q){case 2:for(var N=0;N256&&(u=256);var $=0,w=0;for(w=0;w+4<=_.data.length;w+=4)$=_.data[w+0]|_.data[w+1]<<8|_.data[w+2]<<16|_.data[w+3]<<24,d=caml_hash_mix_int(d,$);switch($=0,u&3){case 3:$=_.data[w+2]<<16;case 2:$|=_.data[w+1]<<8;case 1:$|=_.data[w+0],d=caml_hash_mix_int(d,$)}break;case 4:case 5:u>128&&(u=128);var $=0,w=0;for(w=0;w+2<=_.data.length;w+=2)$=_.data[w+0]|_.data[w+1]<<16,d=caml_hash_mix_int(d,$);u&1&&(d=caml_hash_mix_int(d,_.data[w]));break;case 6:u>64&&(u=64);for(var w=0;w64&&(u=64);for(var w=0;w32&&(u=32),u*=2;for(var w=0;w64&&(u=64);for(var w=0;w32&&(u=32);for(var w=0;w>>16,_=caml_mul(_,-2048144789),_^=_>>>13,_=caml_mul(_,-1028477387),_^=_>>>16,_}function caml_is_ml_bytes(_){return _ instanceof MlBytes}function caml_is_ml_string(_){return caml_is_ml_bytes(_)}function caml_hash(_,u,d,$){var w,q,z,P,N,V,L,U,Y;for(P=u,(P<0||P>256)&&(P=256),N=_,V=d,w=[$],q=0,z=1;q0;)if(L=w[q++],L&&L.caml_custom){if(caml_custom_ops[L.caml_custom]&&caml_custom_ops[L.caml_custom].hash){var R=caml_custom_ops[L.caml_custom].hash(L);V=caml_hash_mix_int(V,R),N--}}else if(L instanceof Array&&L[0]===(L[0]|0))switch(L[0]){case 248:V=caml_hash_mix_int(V,L[2]),N--;break;case 250:w[--q]=L[1];break;default:var W=L.length-1<<10|L[0];for(V=caml_hash_mix_int(V,W),U=1,Y=L.length;U=P);U++)w[z++]=L[U];break}else caml_is_ml_bytes(L)?(V=caml_hash_mix_bytes(V,L),N--):caml_is_ml_string(L)?(V=caml_hash_mix_string(V,L),N--):typeof L=="string"?(V=caml_hash_mix_jsbytes(V,L),N--):L===(L|0)?(V=caml_hash_mix_int(V,L+L+1),N--):L===+L&&(V=caml_hash_mix_float(V,L),N--);return V=caml_hash_mix_final(V),V&1073741823}function Base_hash_double(_){return caml_hash(1,1,0,_)}function Base_hash_string(_){return caml_hash(1,1,0,_)}function Base_int_math_int32_clz(_){var u=32,d;return d=_>>16,d!=0&&(u=u-16,_=d),d=_>>8,d!=0&&(u=u-8,_=d),d=_>>4,d!=0&&(u=u-4,_=d),d=_>>2,d!=0&&(u=u-2,_=d),d=_>>1,d!=0?u-2:u-_}function Base_int_math_int32_ctz(_){if(_===0)return 32;var u=1;return _&65535||(u=u+16,_=_>>16),_&255||(u=u+8,_=_>>8),_&15||(u=u+4,_=_>>4),_&3||(u=u+2,_=_>>2),u-(_&1)}function caml_int64_shift_right_unsigned(_,u){return _.shift_right_unsigned(u)}function caml_int64_is_zero(_){return+_.isZero()}function caml_int64_to_int32(_){return _.toInt()}function Base_int_math_int64_clz(_){var u=64,d;return d=caml_int64_shift_right_unsigned(_,32),caml_int64_is_zero(d)||(u=u-32,_=d),d=caml_int64_shift_right_unsigned(_,16),caml_int64_is_zero(d)||(u=u-16,_=d),d=caml_int64_shift_right_unsigned(_,8),caml_int64_is_zero(d)||(u=u-8,_=d),d=caml_int64_shift_right_unsigned(_,4),caml_int64_is_zero(d)||(u=u-4,_=d),d=caml_int64_shift_right_unsigned(_,2),caml_int64_is_zero(d)||(u=u-2,_=d),d=caml_int64_shift_right_unsigned(_,1),caml_int64_is_zero(d)?u-caml_int64_to_int32(_):u-2}function caml_int64_and(_,u){return _.and(u)}function caml_int64_of_int32(_){return new MlInt64(_&16777215,_>>24&16777215,_>>31&65535)}function Base_int_math_int64_ctz(_){if(caml_int64_is_zero(_))return 64;var u=1;function d(q){return caml_int64_is_zero(q)}function $(q,z){return caml_int64_and(q,z)}function w(q){return caml_int64_create_lo_mi_hi(q,0,0)}return d($(_,caml_int64_create_lo_mi_hi(16777215,255,0)))&&(u=u+32,_=caml_int64_shift_right_unsigned(_,32)),d($(_,w(65535)))&&(u=u+16,_=caml_int64_shift_right_unsigned(_,16)),d($(_,w(255)))&&(u=u+8,_=caml_int64_shift_right_unsigned(_,8)),d($(_,w(15)))&&(u=u+4,_=caml_int64_shift_right_unsigned(_,4)),d($(_,w(3)))&&(u=u+2,_=caml_int64_shift_right_unsigned(_,2)),u-caml_int64_to_int32(caml_int64_and(_,w(1)))}function caml_int64_mul(_,u){return _.mul(u)}function Base_int_math_int64_pow_stub(_,u){for(var d=caml_int64_create_lo_hi(1,0),$=[d,_,d,d],w=d;!caml_int64_is_zero(u);)$[1]=caml_int64_mul($[1],$[3]),$[2]=caml_int64_mul($[1],$[1]),$[3]=caml_int64_mul($[2],$[1]),w=caml_int64_mul(w,$[caml_int64_lo32(u)&3]),u=caml_int64_shift_right_unsigned(u,2);return w}function Base_int_math_int_clz(_){return Base_int_math_int32_clz(_)}function Base_int_math_int_ctz(_){return Base_int_math_int32_ctz(_)}function Base_int_math_int_popcount(_){return _=_-(_>>>1&1431655765),_=(_&858993459)+(_>>>2&858993459),(_+(_>>>4)&252645135)*16843009>>>24}function Base_int_math_int_pow_stub(_,u){for(var d=1,$=[d,_,d,d],w=d;!u==0;)$[1]=$[1]*$[3]|0,$[2]=$[1]*$[1]|0,$[3]=$[2]*$[1]|0,w=w*$[u&3]|0,u=u>>2;return w}function Base_int_math_nativeint_clz(_){return Base_int_math_int32_clz(_)}function Base_int_math_nativeint_ctz(_){return Base_int_math_int32_ctz(_)}var Base_internalhash_fold_float=caml_hash_mix_float,Base_internalhash_fold_int=caml_hash_mix_int,Base_internalhash_fold_int64=caml_hash_mix_int64,Base_internalhash_fold_string=caml_hash_mix_string;function Base_internalhash_get_hash_value(_){var u=caml_hash_mix_final(_);return u&1073741823}function incr_nat(_,u,d,$){for(var w=$,q=0;q>>0)+w;if(_.data[u+q]=z|0,z==z>>>0){w=0;break}else w=1}return w}function add_nat(_,u,d,$,w,q,z){for(var P=z,N=0;N>>0)+($.data[w+N]>>>0)+P;_.data[u+N]=V,V==V>>>0?P=0:P=1}return incr_nat(_,u+q,d-q,P)}function caml_js_from_array(_){return _.slice(1)}function caml_ba_create(_,u,d){var $=caml_js_from_array(d),w=caml_ba_create_buffer(_,caml_ba_get_size($));return caml_ba_create_unsafe(_,u,$,w)}function bigstring_alloc(_,u){return caml_ba_create(12,0,[0,u])}function caml_ml_bytes_length(_){return _.l}function caml_convert_bytes_to_array(_){if(globalThis.Uint8Array)var u=new globalThis.Uint8Array(_.l);else var u=new Array(_.l);for(var d=_.c,$=d.length,w=0;w<$;w++)u[w]=d.charCodeAt(w);for($=_.l;w<$;w++)u[w]=0;return _.c=u,_.t=4,u}function caml_blit_bytes(_,u,d,$,w){if(w==0)return 0;if($==0&&(w>=d.l||d.t==2&&w>=d.c.length))d.c=_.t==4?caml_subarray_to_jsbytes(_.c,u,w):u==0&&_.c.length==w?_.c:_.c.substr(u,w),d.t=d.c.length==d.l?0:2;else if(d.t==2&&$==d.c.length)d.c+=_.t==4?caml_subarray_to_jsbytes(_.c,u,w):u==0&&_.c.length==w?_.c:_.c.substr(u,w),d.t=d.c.length==d.l?0:2;else{d.t!=4&&caml_convert_bytes_to_array(d);var q=_.c,z=d.c;if(_.t==4)if($<=u)for(var P=0;P=0;P--)z[$+P]=q[u+P];else{for(var N=Math.min(w,q.length-u),P=0;P_.data.length&&caml_array_bound_error(),$+w>caml_ml_bytes_length(d)&&caml_array_bound_error();var z=_.data.slice(q,q+w);return caml_blit_bytes(caml_bytes_of_array(z),0,d,$,w),0}function bigstring_blit_bigstring_bytes_stub(_,u,d,$,w){return caml_bigstring_blit_ba_to_bytes(_,u,d,$,w)}function caml_array_of_bytes(_){return _.t!=4&&caml_convert_bytes_to_array(_),_.c}function caml_bigstring_blit_bytes_to_ba(_,u,d,$,w){if(d.kind!=12&&caml_invalid_argument("caml_bigstring_blit_string_to_ba: kind mismatch"),w==0)return 0;var q=d.offset($);u+w>caml_ml_bytes_length(_)&&caml_array_bound_error(),q+w>d.data.length&&caml_array_bound_error();var z=caml_array_of_bytes(_).slice(u,u+w);return d.data.set(z,q),0}function bigstring_blit_bytes_bigstring_stub(_,u,d,$,w){return caml_bigstring_blit_bytes_to_ba(_,u,d,$,w)}function caml_ml_string_length(_){return caml_ml_bytes_length(_)}function caml_bytes_unsafe_get(_,u){switch(_.t&6){default:if(u>=_.c.length)return 0;case 0:return _.c.charCodeAt(u);case 4:return _.c[u]}}function caml_string_unsafe_get(_,u){return caml_bytes_unsafe_get(_,u)}function caml_array_of_string(_){for(var u=caml_ml_string_length(_),d=new Array(u),$=0;$caml_ml_string_length(_)&&caml_array_bound_error(),q+w>d.data.length&&caml_array_bound_error();var z=caml_array_of_string(_).slice(u,u+w);return d.data.set(z,q),0}function bigstring_blit_string_bigstring_stub(_,u,d,$,w){return caml_bigstring_blit_string_to_ba(_,u,d,$,w)}function caml_bigstring_blit_ba_to_ba(_,u,d,$,w){if(_.kind!=12&&caml_invalid_argument("caml_bigstring_blit_ba_to_ba: kind mismatch"),d.kind!=12&&caml_invalid_argument("caml_bigstring_blit_ba_to_ba: kind mismatch"),w==0)return 0;var q=_.offset(u),z=d.offset($);q+w>_.data.length&&caml_array_bound_error(),z+w>d.data.length&&caml_array_bound_error();var P=_.data.subarray(q,q+w);return d.data.set(P,$),0}function bigstring_blit_stub(_,u,d,$,w){return caml_bigstring_blit_ba_to_ba(_,u,d,$,w)}function caml_bytes_unsafe_set(_,u,d){if(d&=255,_.t!=4){if(u==_.c.length)return _.c+=String.fromCharCode(d),u+1==_.l&&(_.t=0),0;caml_convert_bytes_to_array(_)}return _.c[u]=d,0}function caml_string_unsafe_set(_,u,d){return caml_bytes_unsafe_set(_,u,d)}function caml_ba_get_1(_,u){return _.get(_.offset(u))}function bigstringaf_blit_to_bytes(_,u,d,$,w){for(var q=0;q>>0>=_.length-1&&caml_array_bound_error(),_}function caml_check_bound_bigstring(_,u){u>>>0>=_.data.length&&caml_array_bound_error()}function bin_prot_blit_buf_float_array_stub(_,u,d,$,w){if(w==0)return 0;caml_check_bound($,d),caml_check_bound($,d+w-1),caml_check_bound_bigstring(u,_),caml_check_bound_bigstring(u,_+w*8-1);var q=new joo_global_object.Float64Array(w),z=new joo_global_object.Uint8Array(q.buffer);z.set(u.data.subarray(_,_+w*8));for(var P=0;P=1;q--)d[$+q]=_[u+q];return 0}function caml_array_concat(_){for(var u=[0];_!==0;){for(var d=_[1],$=1;$=_.length-1)&&caml_array_bound_error(),_[u+1]=d,0}function caml_array_sub(_,u,d){var $=new Array(d+1);$[0]=0;for(var w=1,q=u+1;w<=d;w++,q++)$[w]=_[q];return $}function caml_ba_blit(_,u){u.dims.length!=_.dims.length&&caml_invalid_argument("Bigarray.blit: dimension mismatch");for(var d=0;d=_.dims.length)&&caml_invalid_argument("Bigarray.dim"),_.dims[u]}function caml_ba_dim_1(_){return caml_ba_dim(_,0)}function caml_ba_dim_2(_){return caml_ba_dim(_,1)}function caml_ba_get_2(_,u,d){return _.get(_.offset([u,d]))}function caml_ba_layout(_){return _.layout}function caml_ba_set_1(_,u,d){return _.set(_.offset(u),d),0}function caml_ba_set_2(_,u,d,$){return _.set(_.offset([u,d]),$),0}function caml_ba_sub(_,u,d){var $,w=1;if(_.layout==0){for(var q=1;q<_.dims.length;q++)w=w*_.dims[q];$=0}else{for(var q=0;q<_.dims.length-1;q++)w=w*_.dims[q];$=_.dims.length-1,u=u-1}(u<0||d<0||u+d>_.dims[$])&&caml_invalid_argument("Bigarray.sub: bad sub-array");for(var z=[],q=0;q<_.dims.length;q++)z[q]=_.dims[q];z[$]=d,w*=caml_ba_get_size_per_element(_.kind);var P=_.data.subarray(u*w,(u+d)*w);return caml_ba_create_unsafe(_.kind,_.layout,z,P)}function caml_ba_uint8_get16(_,u){var d=_.offset(u);d+1>=_.data.length&&caml_array_bound_error();var $=_.get(d),w=_.get(d+1);return $|w<<8}function caml_ba_uint8_get32(_,u){var d=_.offset(u);d+3>=_.data.length&&caml_array_bound_error();var $=_.get(d+0),w=_.get(d+1),q=_.get(d+2),z=_.get(d+3);return $<<0|w<<8|q<<16|z<<24}function caml_ba_uint8_get64(_,u){var d=_.offset(u);d+7>=_.data.length&&caml_array_bound_error();var $=_.get(d+0),w=_.get(d+1),q=_.get(d+2),z=_.get(d+3),P=_.get(d+4),N=_.get(d+5),V=_.get(d+6),L=_.get(d+7);return caml_int64_of_bytes([L,V,N,P,z,q,w,$])}function caml_ba_uint8_set16(_,u,d){var $=_.offset(u);return $+1>=_.data.length&&caml_array_bound_error(),_.set($+0,d&255),_.set($+1,d>>>8&255),0}function caml_ba_uint8_set32(_,u,d){var $=_.offset(u);return $+3>=_.data.length&&caml_array_bound_error(),_.set($+0,d&255),_.set($+1,d>>>8&255),_.set($+2,d>>>16&255),_.set($+3,d>>>24&255),0}function caml_ba_uint8_set64(_,u,w){var $=_.offset(u);$+7>=_.data.length&&caml_array_bound_error();for(var w=caml_int64_to_bytes(w),q=0;q<8;q++)_.set($+q,w[7-q]);return 0}function caml_backtrace_status(){return 0}var plonk_wasm=joo_global_object.plonk_wasm,caml_bigint_256_bytes_per_limb=plonk_wasm.caml_bigint_256_bytes_per_limb,caml_bigint_256_compare=plonk_wasm.caml_bigint_256_compare,caml_bigint_256_div=plonk_wasm.caml_bigint_256_div,caml_bigint_256_num_limbs=plonk_wasm.caml_bigint_256_num_limbs;function caml_bytes_to_uint8array(_){for(var u=caml_ml_bytes_length(_),d=new joo_global_object.Uint8Array(u),$=0;$512?(d.substr(0,1),u+=d,d="",u+=_.slice(q,P)):d+=_.slice(q,P),P==z)break;q=P}$<2048?(d+=String.fromCharCode(192|$>>6),d+=String.fromCharCode(128|$&63)):$<55296||$>=57343?d+=String.fromCharCode(224|$>>12,128|$>>6&63,128|$&63):$>=56319||q+1==z||(w=_.charCodeAt(q+1))<56320||w>57343?d+="\xEF\xBF\xBD":(q++,$=($<<10)+w-56613888,d+=String.fromCharCode(240|$>>18,128|$>>12&63,128|$>>6&63,128|$&63)),d.length>1024&&(d.substr(0,1),u+=d,d="")}return u+d}function caml_bytes_of_utf16_jsstring(_){var u=9;return jsoo_is_ascii(_)||(u=8,_=caml_utf8_of_utf16(_)),new MlBytes(u,_,_.length)}function caml_string_of_jsstring(_){return caml_bytes_of_utf16_jsstring(_)}function caml_bigint_256_to_string(_){return caml_string_of_jsstring(plonk_wasm.caml_bigint_256_to_string(_))}function caml_bytes_of_string(_){return _}function caml_blit_string(_,u,d,$,w){return caml_blit_bytes(_,u,d,$,w),0}function caml_bswap16(_){return(_&255)<<8|(_&65280)>>8}function caml_bytes_compare(_,u){return _.t&6&&caml_convert_string_to_bytes(_),u.t&6&&caml_convert_string_to_bytes(u),_.cu.c?1:0}function caml_bytes_equal(_,u){return _===u?1:(_.t&6&&caml_convert_string_to_bytes(_),u.t&6&&caml_convert_string_to_bytes(u),_.c==u.c?1:0)}function caml_bytes_bound_error(){caml_invalid_argument("index out of bounds")}function caml_bytes_get(_,u){return u>>>0>=_.l&&caml_bytes_bound_error(),caml_bytes_unsafe_get(_,u)}function caml_bytes_get16(_,u){u>>>0>=_.l-1&&caml_bytes_bound_error();var d=caml_bytes_unsafe_get(_,u),$=caml_bytes_unsafe_get(_,u+1);return $<<8|d}function caml_bytes_lessequal(_,u){return _.t&6&&caml_convert_string_to_bytes(_),u.t&6&&caml_convert_string_to_bytes(u),_.c<=u.c?1:0}function caml_bytes_greaterequal(_,u){return caml_bytes_lessequal(u,_)}function caml_bytes_lessthan(_,u){return _.t&6&&caml_convert_string_to_bytes(_),u.t&6&&caml_convert_string_to_bytes(u),_.c>>0>=_.l&&caml_bytes_bound_error(),caml_bytes_unsafe_set(_,u,d)}function caml_bytes_set16(_,u,d){u>>>0>=_.l-1&&caml_bytes_bound_error();var $=255&d>>8,w=255&d;return caml_bytes_unsafe_set(_,u+0,w),caml_bytes_unsafe_set(_,u+1,$),0}function caml_bytes_set32(_,u,d){u>>>0>=_.l-3&&caml_bytes_bound_error();var $=255&d>>24,w=255&d>>16,q=255&d>>8,z=255&d;return caml_bytes_unsafe_set(_,u+0,z),caml_bytes_unsafe_set(_,u+1,q),caml_bytes_unsafe_set(_,u+2,w),caml_bytes_unsafe_set(_,u+3,$),0}function caml_bytes_set64(_,u,d){u>>>0>=_.l-7&&caml_bytes_bound_error();for(var $=caml_int64_to_bytes(d),w=0;w<8;w++)caml_bytes_unsafe_set(_,u+7-w,$[w]);return 0}function caml_call_gen(_,u){if(_.fun)return caml_call_gen(_.fun,u);if(typeof _!="function")return _;var d=_.length|0;if(d===0)return _.apply(null,u);var $=u.length|0,w=d-$|0;return w==0?_.apply(null,u):w<0?caml_call_gen(_.apply(null,u.slice(0,d)),u.slice(d)):function(){for(var q=arguments.length==0?1:arguments.length,z=new Array(u.length+q),P=0;P=22250738585072014e-324?0:_!=0?1:2:isNaN(_)?4:3}function caml_compare_val_get_custom(_){return caml_custom_ops[_.caml_custom]&&caml_custom_ops[_.caml_custom].compare}function caml_compare_val_number_custom(_,u,d,$){var w=caml_compare_val_get_custom(u);if(w){var q=d>0?w(u,_,$):w(_,u,$);if($&&q!=q)return d;if(+q!=+q)return+q;if(q|0)return q|0}return d}function caml_compare_val_tag(_){if(typeof _=="number")return 1e3;if(caml_is_ml_bytes(_))return 252;if(caml_is_ml_string(_))return 1252;if(_ instanceof Array&&_[0]===_[0]>>>0&&_[0]<=255){var u=_[0]|0;return u==254?0:u}else{if(_ instanceof String)return 12520;if(typeof _=="string")return 12520;if(_ instanceof Number)return 1e3;if(_&&_.caml_custom)return 1255;if(_&&_.compare)return 1256;if(typeof _=="function")return 1247;if(typeof _=="symbol")return 1251}return 1001}function caml_int_compare(_,u){return _u)return 1;if(_!=u){if(!d)return NaN;if(_==_)return 1;if(u==u)return-1}break;case 1001:if(_u)return 1;if(_!=u){if(!d)return NaN;if(_==_)return 1;if(u==u)return-1}break;case 1251:if(_!==u)return d?1:NaN;break;case 1252:var _=caml_jsbytes_of_string(_),u=caml_jsbytes_of_string(u);if(_!==u){if(_u)return 1}break;case 12520:var _=_.toString(),u=u.toString();if(_!==u){if(_u)return 1}break;case 246:case 254:default:if(_.length!=u.length)return _.length1&&$.push(_,u,1);break}}if($.length==0)return 0;var N=$.pop();u=$.pop(),_=$.pop(),N+1<_.length&&$.push(_,u,N+1),_=_[N],u=u[N]}}function caml_compare(_,u){return caml_compare_val(_,u,!0)}function caml_convert_raw_backtrace(){return[0]}function caml_convert_raw_backtrace_slot(){caml_failwith("caml_convert_raw_backtrace_slot")}function caml_div(_,u){return u==0&&caml_raise_zero_divide(),_/u|0}var caml_ephe_key_offset=3;function caml_weak_create(_){_<0&&caml_invalid_argument("Weak.create");var u=[251,"caml_ephe_list_head"];return u.length=caml_ephe_key_offset+_,u}var caml_ephe_create=caml_weak_create,caml_ephe_data_offset=2;function caml_ephe_get_data(_){return _[caml_ephe_data_offset]===void 0?0:[0,_[caml_ephe_data_offset]]}function caml_ephe_set_data(_,u){return _[caml_ephe_data_offset]=u,0}function caml_weak_set(_,u,d){return(u<0||caml_ephe_key_offset+u>=_.length)&&caml_invalid_argument("Weak.set"),_[caml_ephe_key_offset+u]=d,0}function caml_ephe_set_key(_,u,d){return caml_weak_set(_,u,[0,d])}function caml_equal(_,u){return+(caml_compare_val(_,u,!1)==0)}function caml_fill_bytes(_,u,d,$){if(d>0)if(u==0&&(d>=_.l||_.t==2&&d>=_.c.length))$==0?(_.c="",_.t=2):(_.c=caml_str_repeat(d,String.fromCharCode($)),_.t=d==_.l?0:2);else for(_.t!=4&&caml_convert_bytes_to_array(_),d+=u;uu||_===_?1:u===u?-1:0}function caml_float_of_string(_){var u;if(_=caml_jsbytes_of_string(_),u=+_,_.length>0&&u===u||(_=_.replace(/_/g,""),u=+_,_.length>0&&u===u||/^[+-]?nan$/i.test(_)))return u;var d=/^ *([+-]?)0x([0-9a-f]+)\.?([0-9a-f]*)(p([+-]?[0-9]+))?/i.exec(_);if(d){var $=d[3].replace(/0+$/,""),w=parseInt(d[1]+d[2]+$,16),q=(d[5]|0)-4*$.length;return u=w*Math.pow(2,q),u}if(/^\+?inf(inity)?$/i.test(_))return 1/0;if(/^-inf(inity)?$/i.test(_))return-1/0;caml_failwith("float_of_string")}function caml_parse_format(_){_=caml_jsbytes_of_string(_);var u=_.length;u>31&&caml_invalid_argument("format_int: format too long");for(var d={justify:"+",signstyle:"-",filler:" ",alternate:!1,base:0,signedconv:!1,width:0,uppercase:!1,sign:1,prec:-1,conv:"f"},$=0;$=0&&w<=9;)d.width=d.width*10+w,$++;$--;break;case".":for(d.prec=0,$++;w=_.charCodeAt($)-48,w>=0&&w<=9;)d.prec=d.prec*10+w,$++;$--;case"d":case"i":d.signedconv=!0;case"u":d.base=10;break;case"x":d.base=16;break;case"X":d.base=16,d.uppercase=!0;break;case"o":d.base=8;break;case"e":case"f":case"g":d.signedconv=!0,d.conv=w;break;case"E":case"F":case"G":d.signedconv=!0,d.uppercase=!0,d.conv=w.toLowerCase();break}}return d}function caml_finish_formatting(_,u){_.uppercase&&(u=u.toUpperCase());var d=u.length;_.signedconv&&(_.sign<0||_.signstyle!="-")&&d++,_.alternate&&(_.base==8&&(d+=1),_.base==16&&(d+=2));var $="";if(_.justify=="+"&&_.filler==" ")for(var w=d;w<_.width;w++)$+=" ";if(_.signedconv&&(_.sign<0?$+="-":_.signstyle!="-"&&($+=_.signstyle)),_.alternate&&_.base==8&&($+="0"),_.alternate&&_.base==16&&($+="0x"),_.justify=="+"&&_.filler=="0")for(var w=d;w<_.width;w++)$+="0";if($+=u,_.justify=="-")for(var w=d;w<_.width;w++)$+=" ";return caml_string_of_jsbytes($)}function caml_format_float(_,u){function d(L,U){if(Math.abs(L)<1)return L.toFixed(U);var Y=parseInt(L.toString().split("+")[1]);return Y>20?(Y-=20,L/=Math.pow(10,Y),L+=new Array(Y+1).join("0"),U>0&&(L=L+"."+new Array(U+1).join("0")),L):L.toFixed(U)}var $,w=caml_parse_format(_),q=w.prec<0?6:w.prec;if((u<0||u==0&&1/u==-1/0)&&(w.sign=-1,u=-u),isNaN(u))$="nan",w.filler=" ";else if(!isFinite(u))$="inf",w.filler=" ";else switch(w.conv){case"e":var $=u.toExponential(q),z=$.length;$.charAt(z-3)=="e"&&($=$.slice(0,z-1)+"0"+$.slice(z-1));break;case"f":$=d(u,q);break;case"g":q=q||1,$=u.toExponential(q-1);var P=$.indexOf("e"),N=+$.slice(P+1);if(N<-4||u>=1e21||u.toFixed(0).length>q){for(var z=P-1;$.charAt(z)=="0";)z--;$.charAt(z)=="."&&z--,$=$.slice(0,z+1)+$.slice(P),z=$.length,$.charAt(z-3)=="e"&&($=$.slice(0,z-1)+"0"+$.slice(z-1));break}else{var V=q;if(N<0)V-=N+1,$=u.toFixed(V);else for(;$=u.toFixed(V),$.length>q+1;)V--;if(V){for(var z=$.length-1;$.charAt(z)=="0";)z--;$.charAt(z)=="."&&z--,$=$.slice(0,z+1)}}break}return caml_finish_formatting(w,$)}function caml_format_int(_,u){if(caml_jsbytes_of_string(_)=="%d")return caml_string_of_jsbytes(""+u);var d=caml_parse_format(_);u<0&&(d.signedconv?(d.sign=-1,u=-u):u>>>=0);var $=u.toString(d.base);if(d.prec>=0){d.filler=" ";var w=d.prec-$.length;w>0&&($=caml_str_repeat(w,"0")+$)}return caml_finish_formatting(d,$)}function rust_affine_to_caml_affine(_){var u=_.infinity;if(u)return _.free(),0;var d=_.x,$=_.y;return _.free(),[0,[0,d,$]]}function js_class_vector_of_rust_vector(_,u){for(var d=_.length,$=new Array(d),w=0,q=0;w=1;)_*=.5,d++;return u&&(_=-_),[0,_,d]}function fs_node_supported(){return typeof globalThis.process<"u"&&typeof globalThis.process.versions<"u"&&typeof globalThis.process.versions.node<"u"}function make_path_is_absolute(){function _(d){if(d.charAt(0)==="/")return["",d.substring(1)]}function u(d){var $=/^([a-zA-Z]:|[\\/]{2}[^\\/]+[\\/]+[^\\/]+)?([\\/])?([\s\S]*?)$/,w=$.exec(d),q=w[1]||"",z=Boolean(q&&q.charAt(1)!==":");if(Boolean(w[2]||z)){var P=w[1]||"",N=w[2]||"";return[P,d.substring(P.length+N.length)]}}return fs_node_supported()&&globalThis.process&&globalThis.process.platform&&globalThis.process.platform==="win32"?u:_}var path_is_absolute=make_path_is_absolute();function caml_trailing_slash(_){return _.slice(-1)!=="/"?_+"/":_}if(fs_node_supported()&&globalThis.process&&globalThis.process.cwd)var caml_current_dir=globalThis.process.cwd().replace(/\\/g,"/");else var caml_current_dir="/static";caml_current_dir=caml_trailing_slash(caml_current_dir);function caml_make_path(_){_=caml_jsstring_of_string(_),path_is_absolute(_)||(_=caml_current_dir+_);for(var u=path_is_absolute(_),d=u[1].split("/"),$=[],w=0;w1&&$.pop();break;case".":break;default:$.push(d[w]);break}return $.unshift(u[0]),$.orig=_,$}var unix_error=["E2BIG","EACCES","EAGAIN","EBADF","EBUSY","ECHILD","EDEADLK","EDOM","EEXIST","EFAULT","EFBIG","EINTR","EINVAL","EIO","EISDIR","EMFILE","EMLINK","ENAMETOOLONG","ENFILE","ENODEV","ENOENT","ENOEXEC","ENOLCK","ENOMEM","ENOSPC","ENOSYS","ENOTDIR","ENOTEMPTY","ENOTTY","ENXIO","EPERM","EPIPE","ERANGE","EROFS","ESPIPE","ESRCH","EXDEV","EWOULDBLOCK","EINPROGRESS","EALREADY","ENOTSOCK","EDESTADDRREQ","EMSGSIZE","EPROTOTYPE","ENOPROTOOPT","EPROTONOSUPPORT","ESOCKTNOSUPPORT","EOPNOTSUPP","EPFNOSUPPORT","EAFNOSUPPORT","EADDRINUSE","EADDRNOTAVAIL","ENETDOWN","ENETUNREACH","ENETRESET","ECONNABORTED","ECONNRESET","ENOBUFS","EISCONN","ENOTCONN","ESHUTDOWN","ETOOMANYREFS","ETIMEDOUT","ECONNREFUSED","EHOSTDOWN","EHOSTUNREACH","ELOOP","EOVERFLOW"];function make_unix_err_args(_,u,d,$){var w=unix_error.indexOf(_);w<0&&($==null&&($=-9999),w=[0,$]);var q=[w,caml_string_of_jsstring(u||""),caml_string_of_jsstring(d||"")];return q}var caml_named_values={};function caml_named_value(_){return caml_named_values[_]}function caml_raise_with_args(_,u){throw[0,_].concat(u)}function caml_raise_sys_error(_){caml_raise_with_string(caml_global_data.Sys_error,_)}function caml_raise_no_such_file(_){caml_raise_sys_error(_+": No such file or directory")}function MlFile(){}function MlFakeFile(_){this.data=_}MlFakeFile.prototype=new MlFile,MlFakeFile.prototype.truncate=function(_){var u=this.data;this.data=caml_create_bytes(_|0),caml_blit_bytes(u,0,this.data,0,_)},MlFakeFile.prototype.length=function(){return caml_ml_bytes_length(this.data)},MlFakeFile.prototype.write=function(_,u,d,$){var w=this.length();if(_+$>=w){var q=caml_create_bytes(_+$),z=this.data;this.data=q,caml_blit_bytes(z,0,this.data,0,w)}return caml_blit_string(u,d,this.data,_,$),0},MlFakeFile.prototype.read=function(_,u,d,$){var w=this.length();return caml_blit_bytes(this.data,_,u,d,$),0},MlFakeFile.prototype.read_one=function(_){return caml_bytes_get(this.data,_)},MlFakeFile.prototype.close=function(){},MlFakeFile.prototype.constructor=MlFakeFile;function MlFakeDevice(_,u){this.content={},this.root=_,this.lookupFun=u}MlFakeDevice.prototype.nm=function(_){return this.root+_},MlFakeDevice.prototype.create_dir_if_needed=function(_){for(var u=_.split("/"),d="",$=0;$>1|1,u<$[N+1]?P=N-2:z=N;return caml_method_cache[d]=z+1,u==$[z+1]?$[z]:0}function caml_greaterequal(_,u){return+(caml_compare_val(_,u,!1)>=0)}function caml_greaterthan(_,u){return+(caml_compare_val(_,u,!1)>0)}function caml_hexstring_of_float(_,u,d){if(!isFinite(_))return isNaN(_)?caml_string_of_jsstring("nan"):caml_string_of_jsstring(_>0?"infinity":"-infinity");var $=_==0&&1/_==-1/0?1:_>=0?0:1;$&&(_=-_);var w=0;if(_!=0)if(_<1)for(;_<1&&w>-1022;)_*=2,w--;else for(;_>=2;)_/=2,w++;var q=w<0?"":"+",z="";if($)z="-";else switch(d){case 43:z="+";break;case 32:z=" ";break;default:break}if(u>=0&&u<13){var P=Math.pow(2,u*4);_=Math.round(_*P)/P}var N=_.toString(16);if(u>=0){var V=N.indexOf(".");if(V<0)N+="."+caml_str_repeat(u,"0");else{var L=V+1+u;N.length>24},read16u:function(){var _=this.s,u=this.i;return this.i=u+2,_.charCodeAt(u)<<8|_.charCodeAt(u+1)},read16s:function(){var _=this.s,u=this.i;return this.i=u+2,_.charCodeAt(u)<<24>>16|_.charCodeAt(u+1)},read32u:function(){var _=this.s,u=this.i;return this.i=u+4,(_.charCodeAt(u)<<24|_.charCodeAt(u+1)<<16|_.charCodeAt(u+2)<<8|_.charCodeAt(u+3))>>>0},read32s:function(){var _=this.s,u=this.i;return this.i=u+4,_.charCodeAt(u)<<24|_.charCodeAt(u+1)<<16|_.charCodeAt(u+2)<<8|_.charCodeAt(u+3)},readstr:function(_){var u=this.i;return this.i=u+_,caml_string_of_jsbytes(this.s.substring(u,u+_))}};function caml_float_of_bytes(_){return caml_int64_float_of_bits(caml_int64_of_bytes(_))}function caml_input_value_from_reader(_,u){var d=_.read32u(),$=_.read32u(),w=_.read32u(),q=_.read32u(),z=_.read32u(),P=[],N=w>0?[]:null,V=0;function L(){var K=_.read8u();if(K>=64)if(K>=128){var G=K&15,X=K>>4&7,J=[G];return X==0||(N&&(N[V++]=J),P.push(J,X)),J}else return K&63;else if(K>=32){var I=K&31,J=_.readstr(I);return N&&(N[V++]=J),J}else switch(K){case 0:return _.read8s();case 1:return _.read16s();case 2:return _.read32s();case 3:caml_failwith("input_value: integer too large");break;case 4:var Q=_.read8u();return N[V-Q];case 5:var Q=_.read16u();return N[V-Q];case 6:var Q=_.read32u();return N[V-Q];case 8:var __=_.read32u(),G=__&255,X=__>>10,J=[G];return X==0||(N&&(N[V++]=J),P.push(J,X)),J;case 19:caml_failwith("input_value: data block too large");break;case 9:var I=_.read8u(),J=_.readstr(I);return N&&(N[V++]=J),J;case 10:var I=_.read32u(),J=_.readstr(I);return N&&(N[V++]=J),J;case 12:for(var r_=new Array(8),t_=0;t_<8;t_++)r_[7-t_]=_.read8u();var J=caml_float_of_bytes(r_);return N&&(N[V++]=J),J;case 11:for(var r_=new Array(8),t_=0;t_<8;t_++)r_[t_]=_.read8u();var J=caml_float_of_bytes(r_);return N&&(N[V++]=J),J;case 14:var I=_.read8u(),J=new Array(I+1);J[0]=254;var r_=new Array(8);N&&(N[V++]=J);for(var t_=1;t_<=I;t_++){for(var e_=0;e_<8;e_++)r_[7-e_]=_.read8u();J[t_]=caml_float_of_bytes(r_)}return J;case 13:var I=_.read8u(),J=new Array(I+1);J[0]=254;var r_=new Array(8);N&&(N[V++]=J);for(var t_=1;t_<=I;t_++){for(var e_=0;e_<8;e_++)r_[e_]=_.read8u();J[t_]=caml_float_of_bytes(r_)}return J;case 7:var I=_.read32u(),J=new Array(I+1);J[0]=254,N&&(N[V++]=J);for(var r_=new Array(8),t_=1;t_<=I;t_++){for(var e_=0;e_<8;e_++)r_[7-e_]=_.read8u();J[t_]=caml_float_of_bytes(r_)}return J;case 15:var I=_.read32u(),J=new Array(I+1);J[0]=254;for(var r_=new Array(8),t_=1;t_<=I;t_++){for(var e_=0;e_<8;e_++)r_[e_]=_.read8u();J[t_]=caml_float_of_bytes(r_)}return J;case 16:case 17:caml_failwith("input_value: code pointer");break;case 18:case 24:case 25:for(var n_,a_="";(n_=_.read8u())!=0;)a_+=String.fromCharCode(n_);var c_=caml_custom_ops[a_],l_;switch(c_||caml_failwith("input_value: unknown custom block identifier"),K){case 18:break;case 25:c_.fixed_length||caml_failwith("input_value: expected a fixed-size custom block"),l_=c_.fixed_length;break;case 24:l_=_.read32u(),_.read32s(),_.read32s();break}var s_=_.i,X=[0],J=c_.deserialize(_,X);return l_!=null&&l_!=X[0]&&caml_failwith("input_value: incorrect length of serialized custom block"),N&&(N[V++]=J),J;default:caml_failwith("input_value: ill-formed message")}}for(var U=L();P.length>0;){var Y=P.pop(),R=P.pop(),W=R.length;W>>8|(_&4278190080)>>>24}function caml_int64_add(_,u){return _.add(u)}function caml_int64_bswap(_){var u=caml_int64_to_bytes(_);return caml_int64_of_bytes([u[7],u[6],u[5],u[4],u[3],u[2],u[1],u[0]])}function caml_int64_div(_,u){return _.div(u)}function caml_int64_is_negative(_){return+_.isNeg()}function caml_int64_neg(_){return _.neg()}function caml_int64_format(_,u){var d=caml_parse_format(_);d.signedconv&&caml_int64_is_negative(u)&&(d.sign=-1,u=caml_int64_neg(u));var $="",w=caml_int64_of_int32(d.base),q="0123456789abcdef";do{var z=u.udivmod(w);u=z.quotient,$=q.charAt(caml_int64_to_int32(z.modulus))+$}while(!caml_int64_is_zero(u));if(d.prec>=0){d.filler=" ";var P=d.prec-$.length;P>0&&($=caml_str_repeat(P,"0")+$)}return caml_finish_formatting(d,$)}function caml_int64_mod(_,u){return _.mod(u)}function caml_int64_of_float(_){return _<0&&(_=Math.ceil(_)),new MlInt64(_&16777215,Math.floor(_*caml_int64_offset)&16777215,Math.floor(_*caml_int64_offset*caml_int64_offset)&65535)}function caml_int64_ult(_,u){return _.ucompare(u)<0}function caml_parse_sign_and_base(_){var u=0,d=caml_ml_string_length(_),$=10,w=1;if(d>0)switch(caml_string_unsafe_get(_,u)){case 45:u++,w=-1;break;case 43:u++,w=1;break}if(u+1=48&&_<=57?_-48:_>=65&&_<=90?_-55:_>=97&&_<=122?_-87:-1}function caml_int64_of_string(_){var u=caml_parse_sign_and_base(_),d=u[0],$=u[1],w=u[2],q=caml_int64_of_int32(w),z=new MlInt64(16777215,268435455,65535).udivmod(q).quotient,P=caml_string_unsafe_get(_,d),N=caml_parse_digit(P);(N<0||N>=w)&&caml_failwith("int_of_string");for(var V=caml_int64_of_int32(N);;)if(d++,P=caml_string_unsafe_get(_,d),P!=95){if(N=caml_parse_digit(P),N<0||N>=w)break;caml_int64_ult(z,V)&&caml_failwith("int_of_string"),N=caml_int64_of_int32(N),V=caml_int64_add(caml_int64_mul(q,V),N),caml_int64_ult(V,N)&&caml_failwith("int_of_string")}return d!=caml_ml_string_length(_)&&caml_failwith("int_of_string"),w==10&&caml_int64_ult(new MlInt64(0,0,32768),V)&&caml_failwith("int_of_string"),$<0&&(V=caml_int64_neg(V)),V}function caml_int64_or(_,u){return _.or(u)}function caml_int64_shift_left(_,u){return _.shift_left(u)}function caml_int64_shift_right(_,u){return _.shift_right(u)}function caml_int64_sub(_,u){return _.sub(u)}function caml_int64_to_float(_){return _.toFloat()}function caml_int64_xor(_,u){return _.xor(u)}function caml_int_of_string(_){var u=caml_parse_sign_and_base(_),d=u[0],$=u[1],w=u[2],q=caml_ml_string_length(_),z=-1>>>0,P=d=w)&&caml_failwith("int_of_string");var V=N;for(d++;d=w)break;V=w*V+N,V>z&&caml_failwith("int_of_string")}return d!=q&&caml_failwith("int_of_string"),V=$*V,w==10&&(V|0)!=V&&caml_failwith("int_of_string"),V|0}function caml_js_eval_string(s){return eval(caml_jsstring_of_string(s))}function caml_js_wrap_callback(_){return function(){var u=arguments.length;if(u>0){for(var d=new Array(u),$=0;$1023&&(u-=1023,_*=Math.pow(2,1023),u>1023&&(u-=1023,_*=Math.pow(2,1023))),u<-1023&&(u+=1023,_*=Math.pow(2,-1023)),_*=Math.pow(2,u),_}function caml_lessequal(_,u){return+(caml_compare_val(_,u,!1)<=0)}function caml_lessthan(_,u){return+(caml_compare_val(_,u,!1)<0)}function caml_lex_array(_){_=caml_jsbytes_of_string(_);for(var u=_.length/2,d=new Array(u),$=0;$>16;return d}function caml_lex_engine(_,u,d){var $=2,w=3,q=5,z=6,P=7,N=8,V=9,L=1,U=2,Y=3,R=4,W=5;_.lex_default||(_.lex_base=caml_lex_array(_[L]),_.lex_backtrk=caml_lex_array(_[U]),_.lex_check=caml_lex_array(_[W]),_.lex_trans=caml_lex_array(_[R]),_.lex_default=caml_lex_array(_[Y]));var K,G=u,X=caml_array_of_bytes(d[$]);for(G>=0?(d[P]=d[q]=d[z],d[N]=-1):G=-G-1;;){var J=_.lex_base[G];if(J<0)return-J-1;var I=_.lex_backtrk[G];if(I>=0&&(d[P]=d[z],d[N]=I),d[z]>=d[w]){if(d[V]==0)return-G-1;K=256}else K=X[d[z]],d[z]++;if(_.lex_check[J+K]==G?G=_.lex_trans[J+K]:G=_.lex_default[G],G<0)if(d[z]=d[P],d[N]==-1)caml_failwith("lexing: empty token");else return d[N];else K==256&&(d[V]=0)}}function caml_list_of_js_array(_){for(var u=0,d=_.length-1;d>=0;d--){var $=_[d];u=[0,$,u]}return u}function caml_log10_float(_){return Math.log10(_)}function caml_make_float_vect(u){u<0&&caml_array_bound_error();var u=u+1|0,d=new Array(u);d[0]=254;for(var $=1;$>>32-U,V)}function d(P,N,V,L,U,Y,R){return u(N&V|~N&L,P,N,U,Y,R)}function $(P,N,V,L,U,Y,R){return u(N&L|V&~L,P,N,U,Y,R)}function w(P,N,V,L,U,Y,R){return u(N^V^L,P,N,U,Y,R)}function q(P,N,V,L,U,Y,R){return u(V^(N|~L),P,N,U,Y,R)}function z(P,N){var V=N;for(P[V>>2]|=128<<8*(V&3),V=(V&-4)+8;(V&63)<60;V+=4)P[(V>>2)-1]=0;P[(V>>2)-1]=N<<3,P[V>>2]=N>>29&536870911;var L=[1732584193,4023233417,2562383102,271733878];for(V=0;V>8*G&255;return K}return function(P,N,V){var L=[],U=caml_ml_bytes_content(P);if(typeof U=="string"){for(var Y=U,R=0;R>2]=Y.charCodeAt(W)|Y.charCodeAt(W+1)<<8|Y.charCodeAt(W+2)<<16|Y.charCodeAt(W+3)<<24}for(;R>2]|=Y.charCodeAt(R+N)<<8*(R&3)}else{for(var K=U,R=0;R>2]=K[W]|K[W+1]<<8|K[W+2]<<16|K[W+3]<<24}for(;R>2]|=K[R+N]<<8*(R&3)}return caml_string_of_array(z(L,V))}}();function caml_md5_string(_,u,d){return caml_md5_bytes(_,u,d)}function caml_ml_channel_size(_){var u=caml_ml_channels[_];return u.file.length()}function caml_ml_channel_size_64(_){var u=caml_ml_channels[_];return caml_int64_of_float(u.file.length())}function caml_sys_close(_){return delete caml_global_data.fds[_],0}function caml_ml_flush(_){var u=caml_ml_channels[_];if(u.opened||caml_raise_sys_error("Cannot flush a closed channel"),!u.buffer||u.buffer=="")return 0;if(u.fd&&caml_global_data.fds[u.fd]&&caml_global_data.fds[u.fd].output){var d=caml_global_data.fds[u.fd].output;switch(d.length){case 2:d(_,u.buffer);break;default:d(u.buffer)}}return u.buffer="",0}function caml_ml_close_channel(_){var u=caml_ml_channels[_];return caml_ml_flush(_),u.opened=!1,u.file.close(),caml_sys_close(u.fd),0}function caml_ml_debug_info_status(){return 0}function caml_ml_refill_input(_){var u=_.refill(),d=caml_ml_string_length(u);return d==0&&(_.refill=null),_.file.write(_.file.length(),u,0,d),d}function caml_ml_input(_,u,d,$){var w=caml_ml_channels[_],q=w.file.length()-w.offset;return q==0&&w.refill!=null&&(q=caml_ml_refill_input(w)),q<$&&($=q),w.file.read(w.offset,u,d,$),w.offset+=$,$}function caml_ml_may_refill_input(_){var u=caml_ml_channels[_];u.refill!=null&&u.file.length()==u.offset&&caml_ml_refill_input(u)}function caml_raise_end_of_file(){caml_raise_constant(caml_global_data.End_of_file)}function caml_ml_input_char(_){var u=caml_ml_channels[_];caml_ml_may_refill_input(_),u.offset>=u.file.length()&&caml_raise_end_of_file();var d=u.file.read_one(u.offset);return u.offset++,d}function caml_ml_input_int(_){for(var u=caml_ml_channels[_],d=u.file;u.offset+3>=d.length();){var $=caml_ml_refill_input(u);$==0&&caml_raise_end_of_file()}var w=u.offset,q=d.read_one(w)<<24|d.read_one(w+1)<<16|d.read_one(w+2)<<8|d.read_one(w+3);return u.offset+=4,q}function caml_std_output(_,u){var d=caml_ml_channels[_],$=caml_string_of_jsbytes(u),w=caml_ml_string_length($);return d.file.write(d.offset,$,0,w),d.offset+=w,0}function js_print_stderr(u){var u=caml_utf16_of_utf8(u),d=globalThis;if(d.process&&d.process.stdout&&d.process.stdout.write)d.process.stderr.write(u);else{u.charCodeAt(u.length-1)==10&&(u=u.substr(0,u.length-1));var $=d.console;$&&$.error&&$.error(u)}}function js_print_stdout(u){var u=caml_utf16_of_utf8(u),d=globalThis;if(d.process&&d.process.stdout&&d.process.stdout.write)d.process.stdout.write(u);else{u.charCodeAt(u.length-1)==10&&(u=u.substr(0,u.length-1));var $=d.console;$&&$.log&&$.log(u)}}function caml_sys_open_internal(_,u,d,$){caml_global_data.fds===void 0&&(caml_global_data.fds=new Array),$=$||{};var w={};return w.file=d,w.offset=$.append?d.length():0,w.flags=$,w.output=u,caml_global_data.fds[_]=w,(!caml_global_data.fd_last_idx||_>caml_global_data.fd_last_idx)&&(caml_global_data.fd_last_idx=_),_}function caml_sys_open(_,u,d){for(var $={};u;){switch(u[1]){case 0:$.rdonly=1;break;case 1:$.wronly=1;break;case 2:$.append=1;break;case 3:$.create=1;break;case 4:$.truncate=1;break;case 5:$.excl=1;break;case 6:$.binary=1;break;case 7:$.text=1;break;case 8:$.nonblock=1;break}u=u[2]}$.rdonly&&$.wronly&&caml_raise_sys_error(caml_jsbytes_of_string(_)+" : flags Open_rdonly and Open_wronly are not compatible"),$.text&&$.binary&&caml_raise_sys_error(caml_jsbytes_of_string(_)+" : flags Open_text and Open_binary are not compatible");var w=resolve_fs_device(_),q=w.device.open(w.rest,$),z=caml_global_data.fd_last_idx?caml_global_data.fd_last_idx:0;return caml_sys_open_internal(z+1,caml_std_output,q,$)}caml_sys_open_internal(0,caml_std_output,new MlFakeFile(caml_create_bytes(0))),caml_sys_open_internal(1,js_print_stdout,new MlFakeFile(caml_create_bytes(0))),caml_sys_open_internal(2,js_print_stderr,new MlFakeFile(caml_create_bytes(0)));function caml_ml_open_descriptor_in(_){var u=caml_global_data.fds[_];u.flags.wronly&&caml_raise_sys_error("fd "+_+" is writeonly");var d=null;if(_==0&&fs_node_supported()){var $=require("fs");d=function(){return caml_string_of_jsstring($.readFileSync(0,"utf8"))}}var w={file:u.file,offset:u.offset,fd:_,opened:!0,out:!1,refill:d};return caml_ml_channels[w.fd]=w,w.fd}function caml_ml_open_descriptor_out(_){var u=caml_global_data.fds[_];u.flags.rdonly&&caml_raise_sys_error("fd "+_+" is readonly");var d={file:u.file,offset:u.offset,fd:_,opened:!0,out:!0,buffer:""};return caml_ml_channels[d.fd]=d,d.fd}function caml_ml_out_channels_list(){for(var _=0,u=0;u>24&255,u>>16&255,u>>8&255,u&255],$=caml_string_of_array(d);return caml_ml_output(_,$,0,4),0}function caml_ml_pos_in(_){return caml_ml_channels[_].offset}function caml_ml_pos_in_64(_){return caml_int64_of_float(caml_ml_channels[_].offset)}function caml_ml_pos_out(_){return caml_ml_flush(_),caml_ml_channels[_].offset}function caml_ml_pos_out_64(_){return caml_ml_flush(_),caml_int64_of_float(caml_ml_channels[_].offset)}function caml_ml_seek_in(_,u){var d=caml_ml_channels[_];return d.refill!=null&&caml_raise_sys_error("Illegal seek"),d.offset=u,0}function caml_ml_seek_in_64(_,u){var d=caml_ml_channels[_];return d.refill!=null&&caml_raise_sys_error("Illegal seek"),d.offset=caml_int64_to_float(u),0}function caml_ml_seek_out(_,u){return caml_ml_flush(_),caml_ml_channels[_].offset=u,0}function caml_ml_seek_out_64(_,u){return caml_ml_flush(_),caml_ml_channels[_].offset=caml_int64_to_float(u),0}function caml_ml_set_binary_mode(_,u){var d=caml_ml_channels[_],$=caml_global_data.fds[d.fd];return $.flags.text=!u,$.flags.binary=u,0}function caml_ml_set_channel_name(){return 0}function caml_mod(_,u){return u==0&&caml_raise_zero_divide(),_%u}function caml_modf_float(_){if(isFinite(_)){var u=1/_<0;_=Math.abs(_);var d=Math.floor(_),$=_-d;return u&&(d=-d,$=-$),[0,$,d]}return isNaN(_)?[0,NaN,NaN]:[0,1/_,_]}function caml_lex_run_mem(_,u,d,$){for(;;){var w=_.charCodeAt(u);if(u++,w==255)return;var q=_.charCodeAt(u);u++,q==255?d[w+1]=$:d[w+1]=d[q+1]}}function caml_lex_run_tag(_,u,d){for(;;){var $=_.charCodeAt(u);if(u++,$==255)return;var w=_.charCodeAt(u);u++,w==255?d[$+1]=-1:d[$+1]=d[w+1]}}function caml_new_lex_engine(_,u,d){var $=2,w=3,q=5,z=6,P=7,N=8,V=9,L=10,U=1,Y=2,R=3,W=4,K=5,G=6,X=7,J=8,I=9,Q=10,__=11;_.lex_default||(_.lex_base=caml_lex_array(_[U]),_.lex_backtrk=caml_lex_array(_[Y]),_.lex_check=caml_lex_array(_[K]),_.lex_trans=caml_lex_array(_[W]),_.lex_default=caml_lex_array(_[R])),_.lex_default_code||(_.lex_base_code=caml_lex_array(_[G]),_.lex_backtrk_code=caml_lex_array(_[X]),_.lex_check_code=caml_lex_array(_[Q]),_.lex_trans_code=caml_lex_array(_[I]),_.lex_default_code=caml_lex_array(_[J])),_.lex_code==null&&(_.lex_code=caml_jsbytes_of_string(_[__]));var t_,e_=u,r_=caml_array_of_bytes(d[$]);for(e_>=0?(d[P]=d[q]=d[z],d[N]=-1):e_=-e_-1;;){var n_=_.lex_base[e_];if(n_<0){var a_=_.lex_base_code[e_];return caml_lex_run_tag(_.lex_code,a_,d[L]),-n_-1}var c_=_.lex_backtrk[e_];if(c_>=0){var a_=_.lex_backtrk_code[e_];caml_lex_run_tag(_.lex_code,a_,d[L]),d[P]=d[z],d[N]=c_}if(d[z]>=d[w]){if(d[V]==0)return-e_-1;t_=256}else t_=r_[d[z]],d[z]++;var l_=e_;if(_.lex_check[n_+t_]==e_?e_=_.lex_trans[n_+t_]:e_=_.lex_default[e_],e_<0)if(d[z]=d[P],d[N]==-1)caml_failwith("lexing: empty token");else return d[N];else{var s_=_.lex_base_code[l_],a_;_.lex_check_code[s_+t_]==l_?a_=_.lex_trans_code[s_+t_]:a_=_.lex_default_code[l_],a_>0&&caml_lex_run_mem(_.lex_code,a_,d[L],d[z]),t_==256&&(d[V]=0)}}}function caml_notequal(_,u){return+(caml_compare_val(_,u,!1)!=0)}function caml_obj_block(_,u){var d=new Array(u+1);d[0]=_;for(var $=1;$<=u;$++)d[$]=0;return d}function caml_obj_make_forward(_,u){return _[0]=250,_[1]=u,0}function caml_obj_tag(_){return _ instanceof Array&&_[0]==_[0]>>>0?_[0]:caml_is_ml_bytes(_)||caml_is_ml_string(_)?252:_ instanceof Function||typeof _=="function"?247:_&&_.caml_custom?255:1e3}function caml_out_channel_pos_fd(_){var u=caml_ml_channels[_];return u.offset}var MlObjectTable;typeof globalThis.WeakMap>"u"?MlObjectTable=function(){function _(u){this.objs=u}return _.prototype.get=function(u){for(var d=0;d=0;$-=8)this.chunk[this.chunk_idx++]=d>>$&255},write_at:function(w,d,$){for(var w=w,q=d-8;q>=0;q-=8)this.chunk[w++]=$>>q&255},write_code:function(u,d,$){this.chunk[this.chunk_idx++]=d;for(var w=u-8;w>=0;w-=8)this.chunk[this.chunk_idx++]=$>>w&255},write_shared:function(u){u<1<<8?this.write_code(8,4,u):u<1<<16?this.write_code(16,5,u):this.write_code(32,6,u)},pos:function(){return this.chunk_idx},finalize:function(){return this.block_len=this.chunk_idx-20,this.chunk_idx=0,this.write(32,2224400062),this.write(32,this.block_len),this.write(32,this.obj_counter),this.write(32,this.size_32),this.write(32,this.size_64),this.chunk}},function(u,d){d=caml_list_to_js_array(d);var $=d.indexOf(0)!==-1,w=d.indexOf(1)!==-1;w&&globalThis.console.warn("in caml_output_val: flag Marshal.Closures is not supported.");var q=new _,z=[],P=$?null:new MlObjectTable;function N(U){if($)return!1;var Y=P.recall(U);return Y?(q.write_shared(Y),!0):(P.store(U),!1)}function V(U){if(U.caml_custom){if(N(U))return;var Y=U.caml_custom,R=caml_custom_ops[Y],W=[0,0];if(R.serialize||caml_invalid_argument("output_value: abstract value (Custom)"),caml_legacy_custom_code){q.write(8,18);for(var K=0;K>2),q.size_64+=2+(W[1]+7>>3)}else if(U instanceof Array&&U[0]===(U[0]|0)){if(U[0]==251&&caml_failwith("output_value: abstract value (Abstract)"),U.length>1&&N(U))return;U[0]<16&&U.length-1<8?q.write(8,128+U[0]+(U.length-1<<4)):q.write_code(32,8,U.length-1<<10|U[0]),q.size_32+=U.length,q.size_64+=U.length,U.length>1&&z.push(U,1)}else if(caml_is_ml_bytes(U)){if(caml_is_ml_bytes(caml_string_of_jsbytes(""))||caml_failwith("output_value: [Bytes.t] cannot safely be marshaled with [--enable use-js-string]"),N(U))return;var J=caml_ml_bytes_length(U);J<32?q.write(8,32+J):J<256?q.write_code(8,9,J):q.write_code(32,10,J);for(var K=0;K=0&&U<64?q.write(8,64+U):U>=-(1<<7)&&U<1<<7?q.write_code(8,0,U):U>=-(1<<15)&&U<1<<15?q.write_code(16,1,U):q.write_code(32,2,U)}for(V(u);z.length>0;){var L=z.pop(),u=z.pop();L+1d&&caml_failwith("Marshal.to_buffer: buffer overflow"),caml_blit_bytes(q,0,_,u,q.length),0}function caml_pallas_add(_,u){var d=plonk_wasm.caml_pallas_add(_,u);return free_on_finalize(d),d}function caml_pallas_double(_){var u=plonk_wasm.caml_pallas_double(_);return free_on_finalize(u),u}var caml_pallas_endo_base=plonk_wasm.caml_pallas_endo_base,caml_pallas_endo_scalar=plonk_wasm.caml_pallas_endo_scalar;function caml_pallas_negate(_){var u=plonk_wasm.caml_pallas_negate(_);return free_on_finalize(u),u}function caml_pallas_of_affine_coordinates(_,u){var d=plonk_wasm.caml_pallas_of_affine_coordinates(_,u);return free_on_finalize(d),d}function caml_pallas_one(){var _=plonk_wasm.caml_pallas_one();return free_on_finalize(_),_}function caml_pallas_random(){var _=plonk_wasm.caml_pallas_random();return free_on_finalize(_),_}function caml_pallas_scale(_,u){var d=plonk_wasm.caml_pallas_scale(_,u);return free_on_finalize(d),d}function caml_pallas_sub(_,u){var d=plonk_wasm.caml_pallas_sub(_,u);return free_on_finalize(d),d}function caml_pallas_to_affine(_){var u=plonk_wasm.caml_pallas_to_affine(_);return rust_affine_to_caml_affine(u)}var caml_pasta_fp_add=plonk_wasm.caml_pasta_fp_add;function caml_pasta_fp_copy(_,u){for(var d=0,$=_.length;d<$;d++)_[d]=u[d]}var caml_pasta_fp_div=plonk_wasm.caml_pasta_fp_div,caml_pasta_fp_domain_generator=plonk_wasm.caml_pasta_fp_domain_generator,caml_pasta_fp_equal=plonk_wasm.caml_pasta_fp_equal;function caml_option_of_maybe_undefined(_){return _===void 0?0:[0,_]}function caml_pasta_fp_inv(_){return caml_option_of_maybe_undefined(plonk_wasm.caml_pasta_fp_inv(_))}function caml_pasta_fp_is_square(_){return caml_js_to_bool(plonk_wasm.caml_pasta_fp_is_square(_))}var caml_pasta_fp_mul=plonk_wasm.caml_pasta_fp_mul;function caml_pasta_fp_mut_add(_,u){caml_pasta_fp_copy(_,caml_pasta_fp_add(_,u))}function caml_pasta_fp_mut_mul(_,u){caml_pasta_fp_copy(_,caml_pasta_fp_mul(_,u))}var caml_pasta_fp_square=plonk_wasm.caml_pasta_fp_square;function caml_pasta_fp_mut_square(_){caml_pasta_fp_copy(_,caml_pasta_fp_square(_))}var caml_pasta_fp_sub=plonk_wasm.caml_pasta_fp_sub;function caml_pasta_fp_mut_sub(_,u){caml_pasta_fp_copy(_,caml_pasta_fp_sub(_,u))}var caml_pasta_fp_negate=plonk_wasm.caml_pasta_fp_negate,caml_pasta_fp_of_bigint=plonk_wasm.caml_pasta_fp_of_bigint;function caml_pasta_fp_of_bytes(_){return plonk_wasm.caml_pasta_fp_of_bytes(caml_bytes_to_uint8array(_))}var caml_pasta_fp_of_int=plonk_wasm.caml_pasta_fp_of_int;function caml_pasta_fp_of_string(_){return plonk_wasm.caml_pasta_fp_of_string(caml_jsstring_of_string(_))}function caml_pasta_fp_plonk_circuit_serialize(_,u){return caml_string_of_jsstring(plonk_wasm.caml_pasta_fp_plonk_circuit_serialize(_,u))}function caml_plonk_wire_to_rust(_){return plonk_wasm.Wire.create(_[1],_[2])}function caml_plonk_wires_to_rust(_){return new plonk_wasm.WasmGateWires(caml_plonk_wire_to_rust(_[1]),caml_plonk_wire_to_rust(_[2]),caml_plonk_wire_to_rust(_[3]),caml_plonk_wire_to_rust(_[4]),caml_plonk_wire_to_rust(_[5]),caml_plonk_wire_to_rust(_[6]),caml_plonk_wire_to_rust(_[7]))}function caml_fp_plonk_gate_to_rust(_){return new plonk_wasm.WasmFpGate(_[1],caml_plonk_wires_to_rust(_[2]),caml_u8array_vector_to_rust_flat_vector(_[3]))}function caml_pasta_fp_plonk_gate_vector_add(_,u){return plonk_wasm.caml_pasta_fp_plonk_gate_vector_add(_,caml_fp_plonk_gate_to_rust(u))}function caml_pasta_fp_plonk_gate_vector_create(){return free_on_finalize(plonk_wasm.caml_pasta_fp_plonk_gate_vector_create())}function caml_pasta_fp_plonk_gate_vector_digest(_,u){var d=plonk_wasm.caml_pasta_fp_plonk_gate_vector_digest(_,u);return caml_bytes_of_uint8array(d)}function caml_plonk_wire_of_rust(_){var u=[0,_.row,_.col];return _.free(),u}function caml_plonk_wires_of_rust(_){var u=[0,caml_plonk_wire_of_rust(_[0]),caml_plonk_wire_of_rust(_[1]),caml_plonk_wire_of_rust(_[2]),caml_plonk_wire_of_rust(_[3]),caml_plonk_wire_of_rust(_[4]),caml_plonk_wire_of_rust(_[5]),caml_plonk_wire_of_rust(_[6])];return _.free(),u}function caml_u8array_vector_of_rust_flat_vector(_,u){var d=_.length,$=d/u,w=new Array($+1);w[0]=0;for(var q=1,z=0;q<=$;q++){for(var P=new joo_global_object.Uint8Array(u),N=0;N>>0>=caml_ml_string_length(_)&&caml_string_bound_error(),caml_string_unsafe_get(_,u)}function caml_string_get16(_,u){u>>>0>=caml_ml_string_length(_)-1&&caml_string_bound_error();var d=caml_string_unsafe_get(_,u),$=caml_string_unsafe_get(_,u+1);return $<<8|d}function caml_string_get32(_,u){u>>>0>=caml_ml_string_length(_)-3&&caml_string_bound_error();var d=caml_string_unsafe_get(_,u),$=caml_string_unsafe_get(_,u+1),w=caml_string_unsafe_get(_,u+2),q=caml_string_unsafe_get(_,u+3);return q<<24|w<<16|$<<8|d}function caml_string_get64(_,u){u>>>0>=caml_ml_string_length(_)-7&&caml_string_bound_error();for(var d=new Array(8),$=0;$<8;$++)d[7-$]=caml_string_unsafe_get(_,u+$);return caml_int64_of_bytes(d)}function caml_string_lessequal(_,u){return caml_bytes_lessequal(_,u)}function caml_string_greaterequal(_,u){return caml_string_lessequal(u,_)}function caml_string_lessthan(_,u){return caml_bytes_lessthan(_,u)}function caml_string_greaterthan(_,u){return caml_string_lessthan(u,_)}function caml_string_notequal(_,u){return 1-caml_string_equal(_,u)}var caml_argv=function(){var _=globalThis,u="a.out",d=[];if(_.process&&_.process.argv&&_.process.argv.length>1){var $=_.process.argv;u=$[1],d=$.slice(2)}for(var w=caml_string_of_jsstring(u),q=[0,w],z=0;z=0;$--)if(_.data[u+$]!=0)return $+1;return 1}function compare_nat(_,u,d,$,w,q){var z=num_digits_nat(_,u,d),P=num_digits_nat($,w,q);if(z>P)return 1;if(z=0;N--){if(_.data[u+N]>>>0>$.data[w+N]>>>0)return 1;if(_.data[u+N]>>>0<$.data[w+N]>>>0)return-1}return 0}var core_array_unsafe_float_blit=caml_array_blit,core_array_unsafe_int_blit=caml_array_blit;function core_kernel_gc_minor_words(){return 0}function core_kernel_time_ns_format(_,u){var d=new Date(_*1e3),$=caml_jsbytes_of_string(u),w=joo_global_object.strftime($,d);return caml_string_of_jsbytes(w)}function caml_md5_chan(_,u){var d=caml_ml_channels[_],$=d.file.length();u<0&&(u=$-d.offset),d.offset+u>$&&caml_raise_end_of_file();var w=caml_create_bytes(u);return d.file.read(d.offset,w,0,u),caml_md5_string(w,0,u)}function core_md5_fd(_){var u=caml_ml_open_descriptor_in(_);try{return caml_md5_chan(u,-1)}finally{caml_ml_close_channel(u)}}function MlNat(_){this.data=new globalThis.Int32Array(_),this.length=this.data.length+2}MlNat.prototype.caml_custom="_nat";function create_nat(_){for(var u=new MlNat(_),d=0;d<_;d++)u.data[d]=-1;return u}function custom_reraise_exn(_,u){var d=_[2];throw d instanceof globalThis.Error?d:Error(u)}function decr_nat(_,u,d,$){for(var w=$==1?0:1,q=0;q>>0)-w;if(_.data[u+q]=z,z>=0){w=0;break}else w=1}return w==1?0:1}function deferred_bind(_,u){var d={promise:_.promise.then(u).then(function($){return $.promise}).then(function($){return d.value=$,d.isDetermined=!0,$}).catch(function($){throw d.error=$,d.isError=!0,d.isDetermined=!0,$}),isError:!1,isDetermined:!1};return d}function deferred_map(_,u){var d={promise:_.promise.then(u).then(function($){return d.value=$,d.isDetermined=!0,$}).catch(function($){throw d.error=$,d.isError=!0,d.isDetermined=!0,$}),isError:!1,isDetermined:!1};return d}function deferred_return(_){return{promise:Promise.resolve(_),value:_,isError:!1,isDetermined:!0}}function deferred_run(_){var u={promise:Promise.resolve().then(_).then(function(d){return u.value=d,u.isDetermined=!0,d}).catch(function(d){throw u.error=d,u.isError=!0,u.isDetermined=!0,d}),isError:!1,isDetermined:!1};return u}function deferred_to_promise(_){return _.promise}function deferred_upon_exn(_,u){_.promise.then(function(){u(_.value)})}function div_helper(_,u,d){var $=_*65536+(u>>>16),w=Math.floor($/d)*65536,q=$%d*65536,z=q+(u&65535);return[w+Math.floor(z/d),z%d]}function div_digit_nat(_,u,d,$,w,q,z,P,N){for(var V=w.data[q+z-1]>>>0,L=z-2;L>=0;L--){var U=div_helper(V,w.data[q+L]>>>0,P.data[N]>>>0);_.data[u+L]=U[0],V=U[1]}return d.data[$]=V,0}function num_leading_zero_bits_in_digit(_,u){var d=_.data[u],$=0;return d&4294901760&&($+=16,d>>>=16),d&65280&&($+=8,d>>>=8),d&240&&($+=4,d>>>=4),d&12&&($+=2,d>>>=2),d&2&&($+=1,d>>>=1),d&1&&($+=1),32-$}function shift_left_nat(_,u,d,$,w,q){if(q==0)return $.data[w]=0,0;for(var z=0,P=0;P>>0;_.data[u+P]=N<>>32-q}return $.data[w]=z,0}function shift_right_nat(_,u,d,$,w,q){if(q==0)return $.data[w]=0,0;for(var z=0,P=d-1;P>=0;P--){var N=_.data[u+P]>>>0;_.data[u+P]=N>>>q|z,z=N<<32-q}return $.data[w]=z,0}function set_to_zero_nat(_,u,d){for(var $=0;$>>0,L=0;L>>0)+($.data[w+L]>>>0)*(V&65535)+N,Y=($.data[w+L]>>>0)*(V>>>16);N=Math.floor(Y/65536);var R=U+Y%65536*65536;_.data[u+L]=R,N+=Math.floor(R/4294967296)}return q>>0)-($.data[w+N]>>>0)-P;_.data[u+N]=V,V>=0?P=0:P=1}return decr_nat(_,u+q,d-q,P==1?0:1)}function div_nat(_,u,d,$,w,q){if(q==1)return div_digit_nat(_,u+1,_,u,_,u,d,$,w),0;var z=num_leading_zero_bits_in_digit($,w+q-1);shift_left_nat($,w,q,nat_of_array([0]),0,z),shift_left_nat(_,u,d,nat_of_array([0]),0,z);for(var P=($.data[w+q-1]>>>0)+1,N=create_nat(q+1),V=d-1;V>=q;V--){var L=P==4294967296?_.data[u+V]>>>0:div_helper(_.data[u+V]>>>0,_.data[u+V-1]>>>0,P)[0];for(set_to_zero_nat(N,0,q+1),mult_digit_nat(N,0,q+1,$,w,q,nat_of_array([L]),0),sub_nat(_,u+V-q,q+1,N,0,q+1,1);_.data[u+V]!=0||compare_nat(_,u+V-q,q,$,w,q)>=0;)L=L+1,sub_nat(_,u+V-q,q+1,$,w,q,1);_.data[u+V]=L}return shift_right_nat(_,u,q,nat_of_array([0]),0,z),shift_right_nat($,w,q,nat_of_array([0]),0,z),0}var expect_test_collector_saved_stderr,expect_test_collector_saved_stdout;function expect_test_collector_after_test(_,u){return caml_ml_channels[_]=expect_test_collector_saved_stdout,caml_ml_channels[u]=expect_test_collector_saved_stderr,0}function expect_test_collector_before_test(_,u,d){expect_test_collector_saved_stderr=caml_ml_channels[d],expect_test_collector_saved_stdout=caml_ml_channels[u];var $=caml_ml_channels[_];return caml_ml_channels[u]=$,caml_ml_channels[d]=$,0}function caml_random_oracles_of_rust(_){var u=_.joint_combiner_chal,d=_.joint_combiner,$=void 0;return u!==void 0&&d!==void 0&&($=[0,[0,u],d]),[0,caml_option_of_maybe_undefined($),_.beta,_.gamma,[0,_.alpha_chal],_.alpha,_.zeta,_.v,_.u,[0,_.zeta_chal],[0,_.v_chal],[0,_.u_chal]]}function caml_oracles_of_rust(_){return[0,caml_random_oracles_of_rust(_.o),[0,_.p_eval0,_.p_eval1],caml_u8array_vector_of_rust_flat_vector(_.opening_prechallenges,32),_.digest_before_evaluations]}function fp_oracles_create(_,u,d){return caml_oracles_of_rust(plonk_wasm.fp_oracles_create(caml_array_to_rust_vector(_,caml_vesta_poly_comm_to_rust),caml_pasta_fp_plonk_verifier_index_to_rust(u),caml_pasta_fp_proof_to_rust(d)))}function fq_oracles_create(_,u,d){return caml_oracles_of_rust(plonk_wasm.fq_oracles_create(caml_array_to_rust_vector(_,caml_pallas_poly_comm_to_rust),caml_pasta_fq_plonk_verifier_index_to_rust(u),caml_pasta_fq_proof_to_rust(d)))}function serialize_nat(_,u,d){var $=u.data.length;_.write(32,$);for(var w=0;w<$;w++)_.write(32,u.data[w]);d[0]=$*4,d[1]=$*8}function deserialize_nat(_,u){for(var d=_.read32s(),$=new MlNat(d),w=0;w=$&&caml_failwith("int_of_string");var q=caml_string_unsafe_get(_,d);q===45?(d++,w=!0):q===43&&d++;var z=!0;u.hi=u.hi>>>0;for(var P=caml_int64_of_int32(10),N=u.udivmod(P).quotient,V=caml_int64_of_int32(0);d<$;d++){var q=caml_string_unsafe_get(_,d),L=caml_parse_digit(q);if(L<0||L>=10)break;if(z=!1,caml_int64_ult(N,V)||(L=caml_int64_of_int32(L),V=caml_int64_add(caml_int64_mul(P,V),L),caml_int64_ult(V,L)))return u}return z&&caml_failwith("int_of_string"),w&&(V=caml_int64_neg(V)),V.hi=V.hi>>>0,V}var UInt32=function(){function _(u){this.value=u>>>0}return _.prototype.caml_custom="integers:uint32",_}();function integers_uint32_of_int64(_){return new UInt32(caml_int64_to_int32(_))}function integers_uint32_of_string(_){var u=caml_int64_create_lo_mi_hi(16777215,16777215,65535);return integers_uint32_of_int64(integers_uint_of_string(_,u))}function integers_uint16_of_string(_){var u=integers_uint32_of_string(_);return u.value&65535}function integers_uint32_add(_,u){return new UInt32(_.value+u.value)}function integers_uint32_div(_,u){return new UInt32(_.value/u.value)}function integers_uint32_logand(_,u){return new UInt32(_.value&u.value)}function integers_uint32_logor(_,u){return new UInt32(_.value|u.value)}function integers_uint32_logxor(_,u){return new UInt32(_.value^u.value)}function integers_uint32_max(_){return new UInt32(4294967295)}function integers_uint32_to_int64(_){return caml_int64_create_lo_mi_hi(_.value&16777215,_.value>>>24&16777215,0)}function integers_uint32_mul(_,u){var d=integers_uint32_to_int64(_),$=integers_uint32_to_int64(u);return new UInt32(caml_int64_to_int32(caml_int64_mul(d,$)))}function integers_uint32_of_int(_){return new UInt32(_)}function integers_uint32_of_int32(_){return new UInt32(_)}function integers_uint32_rem(_,u){return u.value==0&&caml_raise_zero_divide(),new UInt32(_.value%u.value)}function integers_uint32_shift_left(_,u){return new UInt32(_.value<>>u)}function integers_uint32_sub(_,u){return new UInt32(_.value-u.value)}function integers_uint32_to_int(_){return _.value|0}function caml_new_string(_){return caml_string_of_jsbytes(_)}function integers_uint32_to_string(_){return caml_new_string(_.value.toString())}var UInt64=function(){function _(u){this.value=u}return _.prototype.caml_custom="integers:uint64",_}();function integers_uint64_add(_,u){return new UInt64(caml_int64_add(_.value,u.value))}function integers_uint64_div(_,u){return u.value.isZero()&&caml_raise_zero_divide(),_.value.hi=_.value.hi>>>0,u.value.hi=u.value.hi>>>0,new UInt64(_.value.udivmod(u.value).quotient)}function integers_uint64_logand(_,u){return new UInt64(caml_int64_and(_.value,u.value))}function integers_uint64_logor(_,u){return new UInt64(caml_int64_or(_.value,u.value))}function integers_uint64_logxor(_,u){return new UInt64(caml_int64_xor(_.value,u.value))}function integers_uint64_max(_){var u=caml_int64_create_lo_mi_hi(16777215,16777215,65535);return u.hi=u.hi>>>0,new UInt64(u)}function integers_uint64_mul(_,u){return new UInt64(caml_int64_mul(_.value,u.value))}function integers_uint64_of_int(_){return new UInt64(caml_int64_of_int32(_))}function integers_uint64_of_int64(_){return new UInt64(caml_int64_create_lo_mi_hi(_.lo,_.mi,_.hi>>>0))}function integers_uint64_of_string(_){var u=caml_int64_create_lo_mi_hi(16777215,16777215,65535);return new UInt64(integers_uint_of_string(_,u))}function integers_uint64_of_uint32(_){return new UInt64(caml_int64_of_int32(_))}function integers_uint64_rem(_,u){return u.value.isZero()&&caml_raise_zero_divide(),_.value.hi=_.value.hi>>>0,u.value.hi=u.value.hi>>>0,new UInt64(_.value.udivmod(u.value).modulus)}function integers_uint64_shift_left(_,u){return new UInt64(caml_int64_shift_left(_.value,u))}function integers_uint64_shift_right(_,u){return new UInt64(caml_int64_shift_right_unsigned(_.value,u))}function integers_uint64_sub(_,u){return new UInt64(caml_int64_sub(_.value,u.value))}function integers_uint64_to_int(_){return caml_int64_to_int32(_.value)}function integers_uint64_to_int64(_){return _=_.value,caml_int64_create_lo_mi_hi(_.lo,_.mi,_.hi|0)}function integers_uint64_to_string(_){return caml_int64_format(caml_new_string("%u"),_.value)}function integers_uint8_of_string(_){var u=integers_uint32_of_string(_);return _.value&255}function integers_uint_size(_){return 4}function integers_ulong_size(_){return 4}function integers_ulonglong_size(_){return 8}function integers_uint8_deserialize(_,u){return u[0]=1,_.read8u()}function integers_uint16_deserialize(_,u){return u[0]=2,_.read16u()}function integers_uint32_serialize(_,u,d){_.write(32,u.value),d[0]=4,d[1]=4}function integers_uint32_deserialize(_,u){return u[0]=4,new UInt32(_.read32u())}function integers_uint32_hash(_){return _.value}function integers_uint32_compare(_,u){return _.value>u.value?1:_.value>>0,u.value.hi=u.value.hi>>>0,_.value.ucompare(u.value)}function integers_uint64_hash(_){return caml_int64_hash(_.value)}function integers_uint64_marshal(_,u,d){caml_int64_marshal(_,u.value,d)}function integers_uint64_unmarshal(_,u){return new UInt64(caml_int64_unmarshal(_,u))}function integers_unsigned_init(_){return caml_custom_ops["integers:uint8"]={deserialize:integers_uint8_deserialize,fixed_length:1},caml_custom_ops["integers:uint16"]={deserialize:integers_uint16_deserialize,fixed_length:2},caml_custom_ops["integers:uint32"]={serialize:integers_uint32_serialize,deserialize:integers_uint32_deserialize,fixed_length:4,hash:integers_uint32_hash,compare:integers_uint32_compare},caml_custom_ops["integers:uint64"]={serialize:integers_uint64_marshal,deserialize:integers_uint64_unmarshal,hash:integers_uint64_hash,compare:integers_uint64_compare},_}function integers_ushort_size(_){return 4}function is_digit_int(_,u){return _.data[u]>=0?1:0}function is_digit_zero(_,u){return _.data[u]==0?1:0}function land_digit_nat(_,u,d,$){return _.data[u]&=d.data[$],0}function lor_digit_nat(_,u,d,$){return _.data[u]|=d.data[$],0}var bigInt=function(_){"use strict";var u=1e7,d=7,$=9007199254740992,w=R($),q="0123456789abcdefghijklmnopqrstuvwxyz",z=joo_global_object.BigInt,P=typeof z=="function";function N(k_,M_,h_,G_){return typeof k_>"u"?N[0]:typeof M_<"u"?+M_==10&&!h_?U_(k_):W_(k_,M_,h_,G_):U_(k_)}function V(k_,M_){this.value=k_,this.sign=M_,this.isSmall=!1,this.caml_custom="_z"}V.prototype=Object.create(N.prototype);function L(k_){this.value=k_,this.sign=k_<0,this.isSmall=!0,this.caml_custom="_z"}L.prototype=Object.create(N.prototype);function U(k_){this.value=k_,this.caml_custom="_z"}U.prototype=Object.create(N.prototype);function Y(k_){return-$0?Math.floor(k_):Math.ceil(k_)}function J(k_,M_){var h_=k_.length,G_=M_.length,D_=new Array(h_),H_=0,J_=u,R_,I_;for(I_=0;I_=J_?1:0,D_[I_]=R_-H_*J_;for(;I_0&&D_.push(H_),D_}function I(k_,M_){return k_.length>=M_.length?J(k_,M_):J(M_,k_)}function Q(k_,M_){var h_=k_.length,G_=new Array(h_),D_=u,H_,J_;for(J_=0;J_0;)G_[J_++]=M_%D_,M_=Math.floor(M_/D_);return G_}V.prototype.add=function(k_){var M_=U_(k_);if(this.sign!==M_.sign)return this.subtract(M_.negate());var h_=this.value,G_=M_.value;return M_.isSmall?new V(Q(h_,Math.abs(G_)),this.sign):new V(I(h_,G_),this.sign)},V.prototype.plus=V.prototype.add,L.prototype.add=function(k_){var M_=U_(k_),h_=this.value;if(h_<0!==M_.sign)return this.subtract(M_.negate());var G_=M_.value;if(M_.isSmall){if(Y(h_+G_))return new L(h_+G_);G_=R(Math.abs(G_))}return new V(Q(G_,Math.abs(h_)),h_<0)},L.prototype.plus=L.prototype.add,U.prototype.add=function(k_){return new U(this.value+U_(k_).value)},U.prototype.plus=U.prototype.add;function __(k_,M_){var h_=k_.length,G_=M_.length,D_=new Array(h_),H_=0,J_=u,R_,I_;for(R_=0;R_=0?G_=__(k_,M_):(G_=__(M_,k_),h_=!h_),G_=W(G_),typeof G_=="number"?(h_&&(G_=-G_),new L(G_)):new V(G_,h_)}function e_(k_,M_,h_){var G_=k_.length,D_=new Array(G_),H_=-M_,J_=u,R_,I_;for(R_=0;R_=0)},L.prototype.minus=L.prototype.subtract,U.prototype.subtract=function(k_){return new U(this.value-U_(k_).value)},U.prototype.minus=U.prototype.subtract,V.prototype.negate=function(){return new V(this.value,!this.sign)},L.prototype.negate=function(){var k_=this.sign,M_=new L(-this.value);return M_.sign=!k_,M_},U.prototype.negate=function(){return new U(-this.value)},V.prototype.abs=function(){return new V(this.value,!1)},L.prototype.abs=function(){return new L(Math.abs(this.value))},U.prototype.abs=function(){return new U(this.value>=0?this.value:-this.value)};function r_(k_,M_){var h_=k_.length,G_=M_.length,D_=h_+G_,H_=G(D_),J_=u,R_,I_,e0,a0,_0;for(e0=0;e00;)G_[R_++]=H_%D_,H_=Math.floor(H_/D_);return G_}function a_(k_,M_){for(var h_=[];M_-- >0;)h_.push(0);return h_.concat(k_)}function c_(k_,M_){var h_=Math.max(k_.length,M_.length);if(h_<=30)return r_(k_,M_);h_=Math.ceil(h_/2);var G_=k_.slice(h_),D_=k_.slice(0,h_),H_=M_.slice(h_),J_=M_.slice(0,h_),R_=c_(D_,J_),I_=c_(G_,H_),e0=c_(I(D_,G_),I(J_,H_)),a0=I(I(R_,a_(__(__(e0,R_),I_),h_)),a_(I_,2*h_));return K(a0),a0}function l_(k_,M_){return-(.012*k_)-.012*M_+15e-6*k_*M_>0}V.prototype.multiply=function(k_){var M_=U_(k_),h_=this.value,G_=M_.value,D_=this.sign!==M_.sign,H_;if(M_.isSmall){if(G_===0)return N[0];if(G_===1)return this;if(G_===-1)return this.negate();if(H_=Math.abs(G_),H_=0;_0--){for(a0=D_-1,I_[_0+G_]!==J_&&(a0=Math.floor((I_[_0+G_]*D_+I_[_0+G_-1])/J_)),Q_=0,r0=0,y0=e0.length,n0=0;n0G_&&(e0=(e0+1)*J_),R_=Math.ceil(e0/a0);do{if(_0=n_(M_,R_),p_(_0,H_)<=0)break;R_--}while(R_);D_.push(R_),H_=__(H_,_0)}return D_.reverse(),[W(D_),W(H_)]}function m_(k_,M_){var h_=k_.length,G_=G(h_),D_=u,H_,J_,R_,I_;for(R_=0,H_=h_-1;H_>=0;--H_)I_=R_*D_+k_[H_],J_=X(I_/M_),R_=I_-J_*M_,G_[H_]=J_|0;return[G_,R_|0]}function b_(k_,M_){var h_,G_=U_(M_);if(P)return[new U(k_.value/G_.value),new U(k_.value%G_.value)];var D_=k_.value,H_=G_.value,J_;if(H_===0)throw new Error("Cannot divide by zero");if(k_.isSmall)return G_.isSmall?[new L(X(D_/H_)),new L(D_%H_)]:[N[0],k_];if(G_.isSmall){if(H_===1)return[k_,N[0]];if(H_==-1)return[k_.negate(),N[0]];var R_=Math.abs(H_);if(R_M_.length?1:-1;for(var h_=k_.length-1;h_>=0;h_--)if(k_[h_]!==M_[h_])return k_[h_]>M_[h_]?1:-1;return 0}V.prototype.compareAbs=function(k_){var M_=U_(k_),h_=this.value,G_=M_.value;return M_.isSmall?1:p_(h_,G_)},L.prototype.compareAbs=function(k_){var M_=U_(k_),h_=Math.abs(this.value),G_=M_.value;return M_.isSmall?(G_=Math.abs(G_),h_===G_?0:h_>G_?1:-1):-1},U.prototype.compareAbs=function(k_){var M_=this.value,h_=U_(k_).value;return M_=M_>=0?M_:-M_,h_=h_>=0?h_:-h_,M_===h_?0:M_>h_?1:-1},V.prototype.compare=function(k_){if(k_===1/0)return-1;if(k_===-1/0)return 1;var M_=U_(k_),h_=this.value,G_=M_.value;return this.sign!==M_.sign?M_.sign?1:-1:M_.isSmall?this.sign?-1:1:p_(h_,G_)*(this.sign?-1:1)},V.prototype.compareTo=V.prototype.compare,L.prototype.compare=function(k_){if(k_===1/0)return-1;if(k_===-1/0)return 1;var M_=U_(k_),h_=this.value,G_=M_.value;return M_.isSmall?h_==G_?0:h_>G_?1:-1:h_<0!==M_.sign?h_<0?-1:1:h_<0?1:-1},L.prototype.compareTo=L.prototype.compare,U.prototype.compare=function(k_){if(k_===1/0)return-1;if(k_===-1/0)return 1;var M_=this.value,h_=U_(k_).value;return M_===h_?0:M_>h_?1:-1},U.prototype.compareTo=U.prototype.compare,V.prototype.equals=function(k_){return this.compare(k_)===0},U.prototype.eq=U.prototype.equals=L.prototype.eq=L.prototype.equals=V.prototype.eq=V.prototype.equals,V.prototype.notEquals=function(k_){return this.compare(k_)!==0},U.prototype.neq=U.prototype.notEquals=L.prototype.neq=L.prototype.notEquals=V.prototype.neq=V.prototype.notEquals,V.prototype.greater=function(k_){return this.compare(k_)>0},U.prototype.gt=U.prototype.greater=L.prototype.gt=L.prototype.greater=V.prototype.gt=V.prototype.greater,V.prototype.lesser=function(k_){return this.compare(k_)<0},U.prototype.lt=U.prototype.lesser=L.prototype.lt=L.prototype.lesser=V.prototype.lt=V.prototype.lesser,V.prototype.greaterOrEquals=function(k_){return this.compare(k_)>=0},U.prototype.geq=U.prototype.greaterOrEquals=L.prototype.geq=L.prototype.greaterOrEquals=V.prototype.geq=V.prototype.greaterOrEquals,V.prototype.lesserOrEquals=function(k_){return this.compare(k_)<=0},U.prototype.leq=U.prototype.lesserOrEquals=L.prototype.leq=L.prototype.lesserOrEquals=V.prototype.leq=V.prototype.lesserOrEquals,V.prototype.isEven=function(){return(this.value[0]&1)===0},L.prototype.isEven=function(){return(this.value&1)===0},U.prototype.isEven=function(){return(this.value&z(1))===z(0)},V.prototype.isOdd=function(){return(this.value[0]&1)===1},L.prototype.isOdd=function(){return(this.value&1)===1},U.prototype.isOdd=function(){return(this.value&z(1))===z(1)},V.prototype.isPositive=function(){return!this.sign},L.prototype.isPositive=function(){return this.value>0},U.prototype.isPositive=L.prototype.isPositive,V.prototype.isNegative=function(){return this.sign},L.prototype.isNegative=function(){return this.value<0},U.prototype.isNegative=L.prototype.isNegative,V.prototype.isUnit=function(){return!1},L.prototype.isUnit=function(){return Math.abs(this.value)===1},U.prototype.isUnit=function(){return this.abs().value===z(1)},V.prototype.isZero=function(){return!1},L.prototype.isZero=function(){return this.value===0},U.prototype.isZero=function(){return this.value===z(0)},V.prototype.isDivisibleBy=function(k_){var M_=U_(k_);return M_.isZero()?!1:M_.isUnit()?!0:M_.compareAbs(2)===0?this.isEven():this.mod(M_).isZero()},U.prototype.isDivisibleBy=L.prototype.isDivisibleBy=V.prototype.isDivisibleBy;function d_(k_){var M_=k_.abs();if(M_.isUnit())return!1;if(M_.equals(2)||M_.equals(3)||M_.equals(5))return!0;if(M_.isEven()||M_.isDivisibleBy(3)||M_.isDivisibleBy(5))return!1;if(M_.lesser(49))return!0}function g_(k_,M_){for(var h_=k_.prev(),G_=h_,D_=0,H_,J_,R_,I_;G_.isEven();)G_=G_.divide(2),D_++;_:for(R_=0;R_-$?new L(k_-1):new V(w,!0)},U.prototype.prev=function(){return new U(this.value-z(1))};for(var y_=[1];2*y_[y_.length-1]<=u;)y_.push(2*y_[y_.length-1]);var v_=y_.length,w_=y_[v_-1];function j_(k_){return Math.abs(k_)<=u}V.prototype.shiftLeft=function(k_){var M_=U_(k_).toJSNumber();if(!j_(M_))throw new Error(String(M_)+" is too large for shifting.");if(M_<0)return this.shiftRight(-M_);var h_=this;if(h_.isZero())return h_;for(;M_>=v_;)h_=h_.multiply(w_),M_-=v_-1;return h_.multiply(y_[M_])},U.prototype.shiftLeft=L.prototype.shiftLeft=V.prototype.shiftLeft,V.prototype.shiftRight=function(k_){var M_,h_=U_(k_).toJSNumber();if(!j_(h_))throw new Error(String(h_)+" is too large for shifting.");if(h_<0)return this.shiftLeft(-h_);for(var G_=this;h_>=v_;){if(G_.isZero()||G_.isNegative()&&G_.isUnit())return G_;M_=b_(G_,w_),G_=M_[1].isNegative()?M_[0].prev():M_[0],h_-=v_-1}return M_=b_(G_,y_[h_]),M_[1].isNegative()?M_[0].prev():M_[0]},U.prototype.shiftRight=L.prototype.shiftRight=V.prototype.shiftRight;function E_(k_,M_,h_){M_=U_(M_);for(var G_=k_.isNegative(),D_=M_.isNegative(),H_=G_?k_.not():k_,J_=D_?M_.not():M_,R_=0,I_=0,e0=null,a0=null,_0=[];!H_.isZero()||!J_.isZero();)e0=b_(H_,w_),R_=e0[1].toJSNumber(),G_&&(R_=w_-1-R_),a0=b_(J_,w_),I_=a0[1].toJSNumber(),D_&&(I_=w_-1-I_),H_=e0[0],J_=a0[0],_0.push(h_(R_,I_));for(var Q_=h_(G_?1:0,D_?1:0)!==0?bigInt(-1):bigInt(0),r0=_0.length-1;r0>=0;r0-=1)Q_=Q_.multiply(w_).add(bigInt(_0[r0]));return Q_}V.prototype.not=function(){return this.negate().prev()},U.prototype.not=L.prototype.not=V.prototype.not,V.prototype.and=function(k_){return E_(this,k_,function(M_,h_){return M_&h_})},U.prototype.and=L.prototype.and=V.prototype.and,V.prototype.or=function(k_){return E_(this,k_,function(M_,h_){return M_|h_})},U.prototype.or=L.prototype.or=V.prototype.or,V.prototype.xor=function(k_){return E_(this,k_,function(M_,h_){return M_^h_})},U.prototype.xor=L.prototype.xor=V.prototype.xor;var L_=1<<30,z_=(u&-u)*(u&-u)|L_;function Y_(k_){var M_=k_.value,h_=typeof M_=="number"?M_|L_:typeof M_=="bigint"?M_|z(L_):M_[0]+M_[1]*u|z_;return h_&-h_}function O_(k_,M_){if(M_.compareTo(k_)<=0){var h_=O_(k_,M_.square(M_)),G_=h_.p,D_=h_.e,H_=G_.multiply(M_);return H_.compareTo(k_)<=0?{p:H_,e:D_*2+1}:{p:G_,e:D_*2}}return{p:bigInt(1),e:0}}V.prototype.bitLength=function(){var k_=this;return k_.compareTo(bigInt(0))<0&&(k_=k_.negate().subtract(bigInt(1))),k_.compareTo(bigInt(0))===0?bigInt(0):bigInt(O_(k_,bigInt(2)).e).add(bigInt(1))},U.prototype.bitLength=L.prototype.bitLength=V.prototype.bitLength;function N_(k_,M_){return k_=U_(k_),M_=U_(M_),k_.greater(M_)?k_:M_}function F_(k_,M_){return k_=U_(k_),M_=U_(M_),k_.lesser(M_)?k_:M_}function T_(k_,M_){if(k_=U_(k_).abs(),M_=U_(M_).abs(),k_.equals(M_))return k_;if(k_.isZero())return M_;if(M_.isZero())return k_;for(var h_=N[1],G_,D_;k_.isEven()&&M_.isEven();)G_=F_(Y_(k_),Y_(M_)),k_=k_.divide(G_),M_=M_.divide(G_),h_=h_.multiply(G_);for(;k_.isEven();)k_=k_.divide(Y_(k_));do{for(;M_.isEven();)M_=M_.divide(Y_(M_));k_.greater(M_)&&(D_=M_,M_=k_,k_=D_),M_=M_.subtract(k_)}while(!M_.isZero());return h_.isUnit()?k_:k_.multiply(h_)}function Z_(k_,M_){return k_=U_(k_).abs(),M_=U_(M_).abs(),k_.divide(T_(k_,M_)).multiply(M_)}function B_(k_,M_){k_=U_(k_),M_=U_(M_);var h_=F_(k_,M_),G_=N_(k_,M_),D_=G_.subtract(h_).add(1);if(D_.isSmall)return h_.add(Math.floor(Math.random()*D_));for(var H_=P_(D_,u).value,J_=[],R_=!0,I_=0;I_=J_){if(I_==="1"&&J_===1)continue;throw new Error(I_+" is not a valid digit in base "+M_+".")}}M_=U_(M_);var e0=[],a0=k_[0]==="-";for(H_=a0?1:0;H_"&&H_=0;H_--)G_=G_.add(k_[H_].times(D_)),D_=D_.times(M_);return h_?G_.negate():G_}function A_(k_,M_){return M_=M_||q,k_"}function P_(k_,M_){if(M_=bigInt(M_),M_.isZero()){if(k_.isZero())return{value:[0],isNegative:!1};throw new Error("Cannot convert nonzero numbers to base 0.")}if(M_.equals(-1)){if(k_.isZero())return{value:[0],isNegative:!1};if(k_.isNegative())return{value:[].concat.apply([],Array.apply(null,Array(-k_.toJSNumber())).map(Array.prototype.valueOf,[1,0])),isNegative:!1};var h_=Array.apply(null,Array(k_.toJSNumber()-1)).map(Array.prototype.valueOf,[0,1]);return h_.unshift([1]),{value:[].concat.apply([],h_),isNegative:!1}}var G_=!1;if(k_.isNegative()&&M_.isPositive()&&(G_=!0,k_=k_.abs()),M_.isUnit())return k_.isZero()?{value:[0],isNegative:!1}:{value:Array.apply(null,Array(k_.toJSNumber())).map(Number.prototype.valueOf,1),isNegative:G_};for(var D_=[],H_=k_,J_;H_.isNegative()||H_.compareAbs(M_)>=0;){J_=H_.divmod(M_),H_=J_.quotient;var R_=J_.remainder;R_.isNegative()&&(R_=M_.minus(R_).abs(),H_=H_.next()),D_.push(R_.toJSNumber())}return D_.push(H_.toJSNumber()),{value:D_.reverse(),isNegative:G_}}function $_(k_,M_,h_){var G_=P_(k_,M_);return(G_.isNegative?"-":"")+G_.value.map(function(D_){return A_(D_,h_)}).join("")}V.prototype.toArray=function(k_){return P_(this,k_)},L.prototype.toArray=function(k_){return P_(this,k_)},U.prototype.toArray=function(k_){return P_(this,k_)},V.prototype.toString=function(k_,M_){if(k_===_&&(k_=10),k_!==10)return $_(this,k_,M_);for(var h_=this.value,G_=h_.length,D_=String(h_[--G_]),H_="0000000",J_;--G_>=0;)J_=String(h_[G_]),D_+=H_.slice(J_.length)+J_;var R_=this.sign?"-":"";return R_+D_},L.prototype.toString=function(k_,M_){return k_===_&&(k_=10),k_!=10?$_(this,k_,M_):String(this.value)},U.prototype.toString=L.prototype.toString,U.prototype.toJSON=V.prototype.toJSON=L.prototype.toJSON=function(){return this.toString()},V.prototype.valueOf=function(){return parseInt(this.toString(),10)},V.prototype.toJSNumber=V.prototype.valueOf,L.prototype.valueOf=function(){return this.value},L.prototype.toJSNumber=L.prototype.valueOf,U.prototype.valueOf=U.prototype.toJSNumber=function(){return parseInt(this.toString(),10)};function C_(k_){if(Y(+k_)){var M_=+k_;if(M_===X(M_))return P?new U(z(M_)):new L(M_);throw new Error("Invalid integer: "+k_)}var h_=k_[0]==="-";h_&&(k_=k_.slice(1));var G_=k_.split(/e/i);if(G_.length>2)throw new Error("Invalid integer: "+G_.join("e"));if(G_.length===2){var D_=G_[1];if(D_[0]==="+"&&(D_=D_.slice(1)),D_=+D_,D_!==X(D_)||!Y(D_))throw new Error("Invalid integer: "+D_+" is not a valid exponent.");var H_=G_[0],J_=H_.indexOf(".");if(J_>=0&&(D_-=H_.length-J_-1,H_=H_.slice(0,J_)+H_.slice(J_+1)),D_<0)throw new Error("Cannot include negative exponent part for integers");H_+=new Array(D_+1).join("0"),k_=H_}var R_=/^([0-9][0-9]*)$/.test(k_);if(!R_)throw new Error("Invalid integer: "+k_);if(P)return new U(z(h_?"-"+k_:k_));for(var I_=[],e0=k_.length,a0=d,_0=e0-a0;e0>0;)I_.push(+k_.slice(_0,e0)),_0-=a0,_0<0&&(_0=0),e0-=a0;return K(I_),new V(I_,h_)}function S_(k_){if(P)return new U(z(k_));if(Y(k_)){if(k_!==X(k_))throw new Error(k_+" is not an integer.");return new L(k_)}return C_(k_.toString())}function U_(k_){return typeof k_=="number"?S_(k_):typeof k_=="string"?C_(k_):typeof k_=="bigint"?new U(k_):k_}for(var K_=0;K_<1e3;K_++)N[K_]=U_(K_),K_>0&&(N[-K_]=U_(-K_));return N.one=N[1],N.zero=N[0],N.minusOne=N[-1],N.max=N_,N.min=F_,N.gcd=T_,N.lcm=Z_,N.isInstance=function(k_){return k_ instanceof V||k_ instanceof L||k_ instanceof U},N.randBetween=B_,N.fromArray=function(k_,M_,h_){return q_(k_.map(U_),U_(M_||10),h_)},N}();function ml_z_normalize(_){var u=_.toJSNumber()|0;return _.equals(bigInt(u))?u:_}function ml_z_abs(_){return ml_z_normalize(bigInt(_).abs())}function ml_z_add(_,u){return ml_z_normalize(bigInt(_).add(bigInt(u)))}function ml_z_compare(_,u){return bigInt(_).compare(bigInt(u))}function ml_z_div(_,u){return u=bigInt(u),u.equals(bigInt(0))&&caml_raise_zero_divide(),ml_z_normalize(bigInt(_).divide(bigInt(u)))}function ml_z_divexact(_,u){return ml_z_div(_,u)}function ml_z_equal(_,u){return bigInt(_).equals(bigInt(u))}function ml_z_fits_int(_){return _==(_|0)?1:0}function ml_z_fits_int32(_){return ml_z_fits_int(_)}function ml_z_format(d,u){u=bigInt(u);for(var d=caml_jsbytes_of_string(d),$=10,w=0,q=0,z=0,P=0,N="",V=" ",L=0,U="";d[L]=="%";)L++;for(;;L++)if(d[L]=="#")z=1;else if(d[L]=="0")V="0";else if(d[L]=="-")P=1;else if(d[L]==" "||d[L]=="+")N=d[L];else break;for(u.lt(bigInt(0))&&(N="-",u=u.negate());d[L]>="0"&&d[L]<="9";L++)q=10*q+ +d[L];switch(d[L]){case"i":case"d":case"u":break;case"b":$=2,z&&(U="0b");break;case"o":$=8,z&&(U="0o");break;case"x":$=16,z&&(U="0x");break;case"X":$=16,z&&(U="0X"),w=1;break;default:caml_failwith("Unsupported format '"+d+"'")}P&&(V=" ");var Y=u.toString($);w===1&&(Y=Y.toUpperCase());var R=Y.length;if(V==" ")if(P)for(Y=N+U+Y;Y.length=0;z--)_.write(8,$.value[z]>>>0&255),_.write(8,$.value[z]>>>8&255),_.write(8,$.value[z]>>>16&255),_.write(8,$.value[z]>>>24&255);d[0]=4*(1+((q+3)/4|0)),d[1]=8*(1+((q+7)/8|0))}function caml_zarith_unmarshal(_,u){var d;switch(_.read8u()){case 1:d=!0;break;case 0:d=!1;break;default:caml_failwith("input_value: z (malformed input)")}for(var $=_.read32u(),w=bigInt(0),q=0;q<$/4;q++){var z=bigInt(_.read8u());z=z.add(_.read8u()<<8),z=z.add(_.read8u()<<16),z=z.add(_.read8u()<<24>>>0),w=z.shiftLeft(q*32).add(w)}return d&&(w=w.negate()),u[0]=$+4,ml_z_normalize(w)}function ml_z_init(_){return caml_custom_ops._z={serialize:caml_zarith_marshal,deserialize:caml_zarith_unmarshal,hash:ml_z_hash,compare:ml_z_compare},0}function ml_z_logand(_,u){return ml_z_normalize(bigInt(_).and(bigInt(u)))}function ml_z_lognot(_){return ml_z_normalize(bigInt(_).not())}function ml_z_logor(_,u){return ml_z_normalize(bigInt(_).or(bigInt(u)))}function ml_z_logxor(_,u){return ml_z_normalize(bigInt(_).xor(bigInt(u)))}function ml_z_mul(_,u){return ml_z_normalize(bigInt(_).multiply(bigInt(u)))}function ml_z_neg(_){return ml_z_normalize(bigInt(_).negate())}function ml_z_numbits(_){_=bigInt(_).abs();for(var u=0,d=bigInt.one;d.leq(_);)u+=1,d=d.multiply(2);return u}function ml_z_of_bits(_){for(var u=bigInt.zero,d=bigInt(256),$=bigInt.one,w=0;w>>0,$=caml_int64_hi32(_)>>>0,w=bigInt(d).add(bigInt($).shiftLeft(32));return u&&(w=w.negate()),ml_z_normalize(w)}function ml_z_of_nativeint(_){return ml_z_of_int(_)}function jsoo_z_of_js_string_base(_,u){if(_==0){_=10;var d=0,$=1;if(u[d]=="-"?($=-1,d++):u[d]=="+"&&d++,u[d]=="0"){if(d++,u.length==d)return 0;var w=u[d];w=="o"||w=="O"?_=8:w=="x"||w=="X"?_=16:(w=="b"||w=="B")&&(_=2),_!=10&&(u=u.substring(d+1),$==-1&&(u="-"+u))}}u[0]=="+"&&(u=u.substring(1)),u=u.replace(/^0+/,""),(u=="-"||u=="")&&(u="0");function q(N){if(N>=48&&N<=57)return N-48;if(N>=97&&N<=102)return N-97+10;if(N>=65&&N<=70)return N-65+10}var z=0;for(u[z]=="-"&&z++;z=_)&&caml_invalid_argument("Z.of_substring_base: invalid digit")}return ml_z_normalize(bigInt(u,_))}function ml_z_of_substring_base(_,u,d,$){return u=caml_jsbytes_of_string(u),(d!=0||$!=u.length)&&(u.length-d<$&&caml_invalid_argument("Z.of_substring_base: invalid offset or length"),u=u.slice(d,d+$)),jsoo_z_of_js_string_base(_,u)}function ml_z_popcount(_){_=bigInt(_);var u=bigInt(0),d=bigInt(1);_.lt(u)&&caml_raise_constant(caml_named_value("ml_z_overflow"));var $;for($=0;!_.equals(u);$++)_=_.and(_.prev());return $!=($|0)&&caml_raise_constant(caml_named_value("ml_z_overflow")),$|0}function ml_z_pow(_,u){return u=bigInt(u),u.lt(bigInt(0))&&caml_invalid_argument("Z.pow: exponent must be nonnegative"),ml_z_normalize(bigInt(_).pow(u))}function ml_z_pred(_){return ml_z_normalize(bigInt(_).prev())}function ml_z_rem(_,u){return u=bigInt(u),u.equals(bigInt(0))&&caml_raise_zero_divide(),ml_z_normalize(bigInt(_).mod(u))}function ml_z_shift_left(_,u){return ml_z_normalize(bigInt(_).shiftLeft(u))}function ml_z_shift_right(_,u){return ml_z_normalize(bigInt(_).shiftRight(u))}function ml_z_sign(_){return bigInt(_).compare(bigInt.zero)}function ml_z_sub(_,u){return ml_z_normalize(bigInt(_).subtract(bigInt(u)))}function ml_z_succ(_){return ml_z_normalize(bigInt(_).next())}function ml_z_testbit(_,u){return _=bigInt(_),_.shiftRight(u).and(bigInt(1)).toJSNumber()|0}function ml_z_to_bits(_){_=bigInt(_).abs();for(var u="";!_.equals(bigInt(0));)u+=String.fromCharCode(_.mod(bigInt(256))),_=_.divide(bigInt(256));for(;u.length%4!=0;)u+=String.fromCharCode(0);return caml_string_of_jsbytes(u)}function ml_z_to_int(_){if(_==(_|0))return _|0;caml_raise_constant(caml_named_value("ml_z_overflow"))}function ml_z_to_int32(_){return ml_z_to_int(_)}function ml_z_fits_int64(_){return _=bigInt(_),_.compare(bigInt("9223372036854775807"))<=0&&_.compare(bigInt("-9223372036854775808"))>=0?1:0}function ml_z_to_int64(_){_=bigInt(_),ml_z_fits_int64(_)||caml_raise_constant(caml_named_value("ml_z_overflow"));var u=bigInt(4294967295),d=_.and(u).toJSNumber(),$=_.shiftRight(32).and(u).toJSNumber(),w=caml_int64_create_lo_hi(d,$);return w}function ml_z_to_nativeint(_){return ml_z_to_int(_)}function mult_nat(_,u,d,$,w,q,z,P,N){for(var V=0,L=0;L"),null$3=caml_string_of_jsbytes(""),tp_loc$0=caml_string_of_jsbytes("shape/src/bin_shape.ml.Sorted_table.t"),tp_loc$1=caml_string_of_jsbytes("shape/src/bin_shape.ml.Canonical_exp_constructor.t"),tp_loc$2=caml_string_of_jsbytes("shape/src/bin_shape.ml.Canonical_full.Exp1.t0"),loc$0=caml_string_of_jsbytes("blit_buf_string"),loc=caml_string_of_jsbytes("blit_string_buf"),enable_everything=[0,0,0],am_running_inline_test_env_var=caml_string_of_jsbytes("TESTING_FRAMEWORK"),flags=[0,0,0],flags$0=[0,1,[0,3,0]],am_recording_environment_varia=caml_string_of_jsbytes("PPX_MODULE_TIMER"),name$2=caml_string_of_jsbytes("int"),name$3=caml_string_of_jsbytes("int32"),name$4=caml_string_of_jsbytes("int64"),name$5=caml_string_of_jsbytes("nativeint"),name$6=caml_string_of_jsbytes("char"),name$7=caml_string_of_jsbytes("float"),name$8=caml_string_of_jsbytes("string"),name$9=caml_string_of_jsbytes("bytes"),name$10=caml_string_of_jsbytes("bool"),name$11=caml_string_of_jsbytes("unit"),name$12=caml_string_of_jsbytes("option"),name$13=caml_string_of_jsbytes("list"),name$14=caml_string_of_jsbytes("array"),name$15=caml_string_of_jsbytes("lazy_t"),name$16=caml_string_of_jsbytes("ref"),name$17=caml_string_of_jsbytes("function"),name$18=caml_string_of_jsbytes("tuple0"),name$19=caml_string_of_jsbytes("tuple2"),name$20=caml_string_of_jsbytes("tuple3"),name$21=caml_string_of_jsbytes("tuple4"),name$22=caml_string_of_jsbytes("tuple5"),ocaml_lex_tables$0=[0,caml_string_of_jsbytes(`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\f\0\0\0\0\0\0\0\0\x1B\0\0\0\0\0U\0\xFD\xFF\xFE\xFF\0.\0/\0(\0\0.\x000\0\x07\0O\0\0>\0\b\0\xFF\xFF \0C\0C\0g\0d\0i\0_\0k\0_\0q\0 +`);return N<0?w.buffer+=P:(w.buffer+=P.substr(0,N+1),caml_ml_flush(_),w.buffer+=P.substr(N+1)),0}function caml_ml_output(_,u,d,$){return caml_ml_output_bytes(_,u,d,$)}function caml_ml_output_char(_,u){var d=caml_string_of_jsbytes(String.fromCharCode(u));return caml_ml_output(_,d,0,1),0}function caml_ml_output_int(_,u){var d=[u>>24&255,u>>16&255,u>>8&255,u&255],$=caml_string_of_array(d);return caml_ml_output(_,$,0,4),0}function caml_ml_pos_in(_){return caml_ml_channels[_].offset}function caml_ml_pos_in_64(_){return caml_int64_of_float(caml_ml_channels[_].offset)}function caml_ml_pos_out(_){return caml_ml_flush(_),caml_ml_channels[_].offset}function caml_ml_pos_out_64(_){return caml_ml_flush(_),caml_int64_of_float(caml_ml_channels[_].offset)}function caml_ml_seek_in(_,u){var d=caml_ml_channels[_];return d.refill!=null&&caml_raise_sys_error("Illegal seek"),d.offset=u,0}function caml_ml_seek_in_64(_,u){var d=caml_ml_channels[_];return d.refill!=null&&caml_raise_sys_error("Illegal seek"),d.offset=caml_int64_to_float(u),0}function caml_ml_seek_out(_,u){return caml_ml_flush(_),caml_ml_channels[_].offset=u,0}function caml_ml_seek_out_64(_,u){return caml_ml_flush(_),caml_ml_channels[_].offset=caml_int64_to_float(u),0}function caml_ml_set_binary_mode(_,u){var d=caml_ml_channels[_],$=caml_global_data.fds[d.fd];return $.flags.text=!u,$.flags.binary=u,0}function caml_ml_set_channel_name(){return 0}function caml_mod(_,u){return u==0&&caml_raise_zero_divide(),_%u}function caml_modf_float(_){if(isFinite(_)){var u=1/_<0;_=Math.abs(_);var d=Math.floor(_),$=_-d;return u&&(d=-d,$=-$),[0,$,d]}return isNaN(_)?[0,NaN,NaN]:[0,1/_,_]}function caml_lex_run_mem(_,u,d,$){for(;;){var w=_.charCodeAt(u);if(u++,w==255)return;var q=_.charCodeAt(u);u++,q==255?d[w+1]=$:d[w+1]=d[q+1]}}function caml_lex_run_tag(_,u,d){for(;;){var $=_.charCodeAt(u);if(u++,$==255)return;var w=_.charCodeAt(u);u++,w==255?d[$+1]=-1:d[$+1]=d[w+1]}}function caml_new_lex_engine(_,u,d){var $=2,w=3,q=5,z=6,P=7,N=8,V=9,L=10,U=1,Y=2,R=3,W=4,K=5,G=6,X=7,J=8,I=9,Q=10,__=11;_.lex_default||(_.lex_base=caml_lex_array(_[U]),_.lex_backtrk=caml_lex_array(_[Y]),_.lex_check=caml_lex_array(_[K]),_.lex_trans=caml_lex_array(_[W]),_.lex_default=caml_lex_array(_[R])),_.lex_default_code||(_.lex_base_code=caml_lex_array(_[G]),_.lex_backtrk_code=caml_lex_array(_[X]),_.lex_check_code=caml_lex_array(_[Q]),_.lex_trans_code=caml_lex_array(_[I]),_.lex_default_code=caml_lex_array(_[J])),_.lex_code==null&&(_.lex_code=caml_jsbytes_of_string(_[__]));var t_,e_=u,r_=caml_array_of_bytes(d[$]);for(e_>=0?(d[P]=d[q]=d[z],d[N]=-1):e_=-e_-1;;){var n_=_.lex_base[e_];if(n_<0){var a_=_.lex_base_code[e_];return caml_lex_run_tag(_.lex_code,a_,d[L]),-n_-1}var c_=_.lex_backtrk[e_];if(c_>=0){var a_=_.lex_backtrk_code[e_];caml_lex_run_tag(_.lex_code,a_,d[L]),d[P]=d[z],d[N]=c_}if(d[z]>=d[w]){if(d[V]==0)return-e_-1;t_=256}else t_=r_[d[z]],d[z]++;var l_=e_;if(_.lex_check[n_+t_]==e_?e_=_.lex_trans[n_+t_]:e_=_.lex_default[e_],e_<0)if(d[z]=d[P],d[N]==-1)caml_failwith("lexing: empty token");else return d[N];else{var s_=_.lex_base_code[l_],a_;_.lex_check_code[s_+t_]==l_?a_=_.lex_trans_code[s_+t_]:a_=_.lex_default_code[l_],a_>0&&caml_lex_run_mem(_.lex_code,a_,d[L],d[z]),t_==256&&(d[V]=0)}}}function caml_notequal(_,u){return+(caml_compare_val(_,u,!1)!=0)}function caml_obj_block(_,u){var d=new Array(u+1);d[0]=_;for(var $=1;$<=u;$++)d[$]=0;return d}function caml_obj_make_forward(_,u){return _[0]=250,_[1]=u,0}function caml_obj_tag(_){return _ instanceof Array&&_[0]==_[0]>>>0?_[0]:caml_is_ml_bytes(_)||caml_is_ml_string(_)?252:_ instanceof Function||typeof _=="function"?247:_&&_.caml_custom?255:1e3}function caml_out_channel_pos_fd(_){var u=caml_ml_channels[_];return u.offset}var MlObjectTable;typeof globalThis.WeakMap>"u"?MlObjectTable=function(){function _(u){this.objs=u}return _.prototype.get=function(u){for(var d=0;d=0;$-=8)this.chunk[this.chunk_idx++]=d>>$&255},write_at:function(w,d,$){for(var w=w,q=d-8;q>=0;q-=8)this.chunk[w++]=$>>q&255},write_code:function(u,d,$){this.chunk[this.chunk_idx++]=d;for(var w=u-8;w>=0;w-=8)this.chunk[this.chunk_idx++]=$>>w&255},write_shared:function(u){u<1<<8?this.write_code(8,4,u):u<1<<16?this.write_code(16,5,u):this.write_code(32,6,u)},pos:function(){return this.chunk_idx},finalize:function(){return this.block_len=this.chunk_idx-20,this.chunk_idx=0,this.write(32,2224400062),this.write(32,this.block_len),this.write(32,this.obj_counter),this.write(32,this.size_32),this.write(32,this.size_64),this.chunk}},function(u,d){d=caml_list_to_js_array(d);var $=d.indexOf(0)!==-1,w=d.indexOf(1)!==-1;w&&globalThis.console.warn("in caml_output_val: flag Marshal.Closures is not supported.");var q=new _,z=[],P=$?null:new MlObjectTable;function N(U){if($)return!1;var Y=P.recall(U);return Y?(q.write_shared(Y),!0):(P.store(U),!1)}function V(U){if(U.caml_custom){if(N(U))return;var Y=U.caml_custom,R=caml_custom_ops[Y],W=[0,0];if(R.serialize||caml_invalid_argument("output_value: abstract value (Custom)"),caml_legacy_custom_code){q.write(8,18);for(var K=0;K>2),q.size_64+=2+(W[1]+7>>3)}else if(U instanceof Array&&U[0]===(U[0]|0)){if(U[0]==251&&caml_failwith("output_value: abstract value (Abstract)"),U.length>1&&N(U))return;U[0]<16&&U.length-1<8?q.write(8,128+U[0]+(U.length-1<<4)):q.write_code(32,8,U.length-1<<10|U[0]),q.size_32+=U.length,q.size_64+=U.length,U.length>1&&z.push(U,1)}else if(caml_is_ml_bytes(U)){if(caml_is_ml_bytes(caml_string_of_jsbytes(""))||caml_failwith("output_value: [Bytes.t] cannot safely be marshaled with [--enable use-js-string]"),N(U))return;var J=caml_ml_bytes_length(U);J<32?q.write(8,32+J):J<256?q.write_code(8,9,J):q.write_code(32,10,J);for(var K=0;K=0&&U<64?q.write(8,64+U):U>=-(1<<7)&&U<1<<7?q.write_code(8,0,U):U>=-(1<<15)&&U<1<<15?q.write_code(16,1,U):q.write_code(32,2,U)}for(V(u);z.length>0;){var L=z.pop(),u=z.pop();L+1d&&caml_failwith("Marshal.to_buffer: buffer overflow"),caml_blit_bytes(q,0,_,u,q.length),0}function caml_pallas_add(_,u){var d=plonk_wasm.caml_pallas_add(_,u);return free_on_finalize(d),d}function caml_pallas_double(_){var u=plonk_wasm.caml_pallas_double(_);return free_on_finalize(u),u}var caml_pallas_endo_base=plonk_wasm.caml_pallas_endo_base,caml_pallas_endo_scalar=plonk_wasm.caml_pallas_endo_scalar;function caml_pallas_negate(_){var u=plonk_wasm.caml_pallas_negate(_);return free_on_finalize(u),u}function caml_pallas_of_affine_coordinates(_,u){var d=plonk_wasm.caml_pallas_of_affine_coordinates(_,u);return free_on_finalize(d),d}function caml_pallas_one(){var _=plonk_wasm.caml_pallas_one();return free_on_finalize(_),_}function caml_pallas_random(){var _=plonk_wasm.caml_pallas_random();return free_on_finalize(_),_}function caml_pallas_scale(_,u){var d=plonk_wasm.caml_pallas_scale(_,u);return free_on_finalize(d),d}function caml_pallas_sub(_,u){var d=plonk_wasm.caml_pallas_sub(_,u);return free_on_finalize(d),d}function caml_pallas_to_affine(_){var u=plonk_wasm.caml_pallas_to_affine(_);return rust_affine_to_caml_affine(u)}var caml_pasta_fp_add=plonk_wasm.caml_pasta_fp_add;function caml_pasta_fp_copy(_,u){for(var d=0,$=_.length;d<$;d++)_[d]=u[d]}var caml_pasta_fp_div=plonk_wasm.caml_pasta_fp_div,caml_pasta_fp_domain_generator=plonk_wasm.caml_pasta_fp_domain_generator,caml_pasta_fp_equal=plonk_wasm.caml_pasta_fp_equal;function caml_option_of_maybe_undefined(_){return _===void 0?0:[0,_]}function caml_pasta_fp_inv(_){return caml_option_of_maybe_undefined(plonk_wasm.caml_pasta_fp_inv(_))}function caml_pasta_fp_is_square(_){return caml_js_to_bool(plonk_wasm.caml_pasta_fp_is_square(_))}var caml_pasta_fp_mul=plonk_wasm.caml_pasta_fp_mul;function caml_pasta_fp_mut_add(_,u){caml_pasta_fp_copy(_,caml_pasta_fp_add(_,u))}function caml_pasta_fp_mut_mul(_,u){caml_pasta_fp_copy(_,caml_pasta_fp_mul(_,u))}var caml_pasta_fp_square=plonk_wasm.caml_pasta_fp_square;function caml_pasta_fp_mut_square(_){caml_pasta_fp_copy(_,caml_pasta_fp_square(_))}var caml_pasta_fp_sub=plonk_wasm.caml_pasta_fp_sub;function caml_pasta_fp_mut_sub(_,u){caml_pasta_fp_copy(_,caml_pasta_fp_sub(_,u))}var caml_pasta_fp_negate=plonk_wasm.caml_pasta_fp_negate,caml_pasta_fp_of_bigint=plonk_wasm.caml_pasta_fp_of_bigint;function caml_pasta_fp_of_bytes(_){return plonk_wasm.caml_pasta_fp_of_bytes(caml_bytes_to_uint8array(_))}var caml_pasta_fp_of_int=plonk_wasm.caml_pasta_fp_of_int;function caml_pasta_fp_of_string(_){return plonk_wasm.caml_pasta_fp_of_string(caml_jsstring_of_string(_))}function caml_pasta_fp_plonk_circuit_serialize(_,u){return caml_string_of_jsstring(plonk_wasm.caml_pasta_fp_plonk_circuit_serialize(_,u))}function caml_plonk_wire_to_rust(_){return plonk_wasm.Wire.create(_[1],_[2])}function caml_plonk_wires_to_rust(_){return new plonk_wasm.WasmGateWires(caml_plonk_wire_to_rust(_[1]),caml_plonk_wire_to_rust(_[2]),caml_plonk_wire_to_rust(_[3]),caml_plonk_wire_to_rust(_[4]),caml_plonk_wire_to_rust(_[5]),caml_plonk_wire_to_rust(_[6]),caml_plonk_wire_to_rust(_[7]))}function caml_fp_plonk_gate_to_rust(_){return new plonk_wasm.WasmFpGate(_[1],caml_plonk_wires_to_rust(_[2]),caml_u8array_vector_to_rust_flat_vector(_[3]))}function caml_pasta_fp_plonk_gate_vector_add(_,u){return plonk_wasm.caml_pasta_fp_plonk_gate_vector_add(_,caml_fp_plonk_gate_to_rust(u))}function caml_pasta_fp_plonk_gate_vector_create(){return free_on_finalize(plonk_wasm.caml_pasta_fp_plonk_gate_vector_create())}function caml_pasta_fp_plonk_gate_vector_digest(_,u){var d=plonk_wasm.caml_pasta_fp_plonk_gate_vector_digest(_,u);return caml_bytes_of_uint8array(d)}function caml_plonk_wire_of_rust(_){var u=[0,_.row,_.col];return _.free(),u}function caml_plonk_wires_of_rust(_){var u=[0,caml_plonk_wire_of_rust(_[0]),caml_plonk_wire_of_rust(_[1]),caml_plonk_wire_of_rust(_[2]),caml_plonk_wire_of_rust(_[3]),caml_plonk_wire_of_rust(_[4]),caml_plonk_wire_of_rust(_[5]),caml_plonk_wire_of_rust(_[6])];return _.free(),u}function caml_u8array_vector_of_rust_flat_vector(_,u){var d=_.length,$=d/u,w=new Array($+1);w[0]=0;for(var q=1,z=0;q<=$;q++){for(var P=new joo_global_object.Uint8Array(u),N=0;N>>0>=caml_ml_string_length(_)&&caml_string_bound_error(),caml_string_unsafe_get(_,u)}function caml_string_get16(_,u){u>>>0>=caml_ml_string_length(_)-1&&caml_string_bound_error();var d=caml_string_unsafe_get(_,u),$=caml_string_unsafe_get(_,u+1);return $<<8|d}function caml_string_get32(_,u){u>>>0>=caml_ml_string_length(_)-3&&caml_string_bound_error();var d=caml_string_unsafe_get(_,u),$=caml_string_unsafe_get(_,u+1),w=caml_string_unsafe_get(_,u+2),q=caml_string_unsafe_get(_,u+3);return q<<24|w<<16|$<<8|d}function caml_string_get64(_,u){u>>>0>=caml_ml_string_length(_)-7&&caml_string_bound_error();for(var d=new Array(8),$=0;$<8;$++)d[7-$]=caml_string_unsafe_get(_,u+$);return caml_int64_of_bytes(d)}function caml_string_lessequal(_,u){return caml_bytes_lessequal(_,u)}function caml_string_greaterequal(_,u){return caml_string_lessequal(u,_)}function caml_string_lessthan(_,u){return caml_bytes_lessthan(_,u)}function caml_string_greaterthan(_,u){return caml_string_lessthan(u,_)}function caml_string_notequal(_,u){return 1-caml_string_equal(_,u)}var caml_argv=function(){var _=globalThis,u="a.out",d=[];if(_.process&&_.process.argv&&_.process.argv.length>1){var $=_.process.argv;u=$[1],d=$.slice(2)}for(var w=caml_string_of_jsstring(u),q=[0,w],z=0;z=0;$--)if(_.data[u+$]!=0)return $+1;return 1}function compare_nat(_,u,d,$,w,q){var z=num_digits_nat(_,u,d),P=num_digits_nat($,w,q);if(z>P)return 1;if(z=0;N--){if(_.data[u+N]>>>0>$.data[w+N]>>>0)return 1;if(_.data[u+N]>>>0<$.data[w+N]>>>0)return-1}return 0}var core_array_unsafe_float_blit=caml_array_blit,core_array_unsafe_int_blit=caml_array_blit;function core_kernel_gc_minor_words(){return 0}function core_kernel_time_ns_format(_,u){var d=new Date(_*1e3),$=caml_jsbytes_of_string(u),w=joo_global_object.strftime($,d);return caml_string_of_jsbytes(w)}function caml_md5_chan(_,u){var d=caml_ml_channels[_],$=d.file.length();u<0&&(u=$-d.offset),d.offset+u>$&&caml_raise_end_of_file();var w=caml_create_bytes(u);return d.file.read(d.offset,w,0,u),caml_md5_string(w,0,u)}function core_md5_fd(_){var u=caml_ml_open_descriptor_in(_);try{return caml_md5_chan(u,-1)}finally{caml_ml_close_channel(u)}}function MlNat(_){this.data=new globalThis.Int32Array(_),this.length=this.data.length+2}MlNat.prototype.caml_custom="_nat";function create_nat(_){for(var u=new MlNat(_),d=0;d<_;d++)u.data[d]=-1;return u}function custom_reraise_exn(_,u){var d=_[2];throw d instanceof globalThis.Error?d:Error(u)}function decr_nat(_,u,d,$){for(var w=$==1?0:1,q=0;q>>0)-w;if(_.data[u+q]=z,z>=0){w=0;break}else w=1}return w==1?0:1}function deferred_bind(_,u){var d={promise:_.promise.then(u).then(function($){return $.promise}).then(function($){return d.value=$,d.isDetermined=!0,$}).catch(function($){throw d.error=$,d.isError=!0,d.isDetermined=!0,$}),isError:!1,isDetermined:!1};return d}function deferred_map(_,u){var d={promise:_.promise.then(u).then(function($){return d.value=$,d.isDetermined=!0,$}).catch(function($){throw d.error=$,d.isError=!0,d.isDetermined=!0,$}),isError:!1,isDetermined:!1};return d}function deferred_return(_){return{promise:Promise.resolve(_),value:_,isError:!1,isDetermined:!0}}function deferred_run(_){var u={promise:Promise.resolve().then(_).then(function(d){return u.value=d,u.isDetermined=!0,d}).catch(function(d){throw u.error=d,u.isError=!0,u.isDetermined=!0,d}),isError:!1,isDetermined:!1};return u}function deferred_to_promise(_){return _.promise}function deferred_upon_exn(_,u){_.promise.then(function(){u(_.value)})}function div_helper(_,u,d){var $=_*65536+(u>>>16),w=Math.floor($/d)*65536,q=$%d*65536,z=q+(u&65535);return[w+Math.floor(z/d),z%d]}function div_digit_nat(_,u,d,$,w,q,z,P,N){for(var V=w.data[q+z-1]>>>0,L=z-2;L>=0;L--){var U=div_helper(V,w.data[q+L]>>>0,P.data[N]>>>0);_.data[u+L]=U[0],V=U[1]}return d.data[$]=V,0}function num_leading_zero_bits_in_digit(_,u){var d=_.data[u],$=0;return d&4294901760&&($+=16,d>>>=16),d&65280&&($+=8,d>>>=8),d&240&&($+=4,d>>>=4),d&12&&($+=2,d>>>=2),d&2&&($+=1,d>>>=1),d&1&&($+=1),32-$}function shift_left_nat(_,u,d,$,w,q){if(q==0)return $.data[w]=0,0;for(var z=0,P=0;P>>0;_.data[u+P]=N<>>32-q}return $.data[w]=z,0}function shift_right_nat(_,u,d,$,w,q){if(q==0)return $.data[w]=0,0;for(var z=0,P=d-1;P>=0;P--){var N=_.data[u+P]>>>0;_.data[u+P]=N>>>q|z,z=N<<32-q}return $.data[w]=z,0}function set_to_zero_nat(_,u,d){for(var $=0;$>>0,L=0;L>>0)+($.data[w+L]>>>0)*(V&65535)+N,Y=($.data[w+L]>>>0)*(V>>>16);N=Math.floor(Y/65536);var R=U+Y%65536*65536;_.data[u+L]=R,N+=Math.floor(R/4294967296)}return q>>0)-($.data[w+N]>>>0)-P;_.data[u+N]=V,V>=0?P=0:P=1}return decr_nat(_,u+q,d-q,P==1?0:1)}function div_nat(_,u,d,$,w,q){if(q==1)return div_digit_nat(_,u+1,_,u,_,u,d,$,w),0;var z=num_leading_zero_bits_in_digit($,w+q-1);shift_left_nat($,w,q,nat_of_array([0]),0,z),shift_left_nat(_,u,d,nat_of_array([0]),0,z);for(var P=($.data[w+q-1]>>>0)+1,N=create_nat(q+1),V=d-1;V>=q;V--){var L=P==4294967296?_.data[u+V]>>>0:div_helper(_.data[u+V]>>>0,_.data[u+V-1]>>>0,P)[0];for(set_to_zero_nat(N,0,q+1),mult_digit_nat(N,0,q+1,$,w,q,nat_of_array([L]),0),sub_nat(_,u+V-q,q+1,N,0,q+1,1);_.data[u+V]!=0||compare_nat(_,u+V-q,q,$,w,q)>=0;)L=L+1,sub_nat(_,u+V-q,q+1,$,w,q,1);_.data[u+V]=L}return shift_right_nat(_,u,q,nat_of_array([0]),0,z),shift_right_nat($,w,q,nat_of_array([0]),0,z),0}var expect_test_collector_saved_stderr,expect_test_collector_saved_stdout;function expect_test_collector_after_test(_,u){return caml_ml_channels[_]=expect_test_collector_saved_stdout,caml_ml_channels[u]=expect_test_collector_saved_stderr,0}function expect_test_collector_before_test(_,u,d){expect_test_collector_saved_stderr=caml_ml_channels[d],expect_test_collector_saved_stdout=caml_ml_channels[u];var $=caml_ml_channels[_];return caml_ml_channels[u]=$,caml_ml_channels[d]=$,0}function caml_random_oracles_of_rust(_){var u=_.joint_combiner_chal,d=_.joint_combiner,$=void 0;return u!==void 0&&d!==void 0&&($=[0,[0,u],d]),[0,caml_option_of_maybe_undefined($),_.beta,_.gamma,[0,_.alpha_chal],_.alpha,_.zeta,_.v,_.u,[0,_.zeta_chal],[0,_.v_chal],[0,_.u_chal]]}function caml_oracles_of_rust(_){return[0,caml_random_oracles_of_rust(_.o),[0,_.p_eval0,_.p_eval1],caml_u8array_vector_of_rust_flat_vector(_.opening_prechallenges,32),_.digest_before_evaluations]}function fp_oracles_create(_,u,d){return caml_oracles_of_rust(plonk_wasm.fp_oracles_create(caml_array_to_rust_vector(_,caml_vesta_poly_comm_to_rust),caml_pasta_fp_plonk_verifier_index_to_rust(u),caml_pasta_fp_proof_to_rust(d)))}function fq_oracles_create(_,u,d){return caml_oracles_of_rust(plonk_wasm.fq_oracles_create(caml_array_to_rust_vector(_,caml_pallas_poly_comm_to_rust),caml_pasta_fq_plonk_verifier_index_to_rust(u),caml_pasta_fq_proof_to_rust(d)))}function serialize_nat(_,u,d){var $=u.data.length;_.write(32,$);for(var w=0;w<$;w++)_.write(32,u.data[w]);d[0]=$*4,d[1]=$*8}function deserialize_nat(_,u){for(var d=_.read32s(),$=new MlNat(d),w=0;w=$&&caml_failwith("int_of_string");var q=caml_string_unsafe_get(_,d);q===45?(d++,w=!0):q===43&&d++;var z=!0;u.hi=u.hi>>>0;for(var P=caml_int64_of_int32(10),N=u.udivmod(P).quotient,V=caml_int64_of_int32(0);d<$;d++){var q=caml_string_unsafe_get(_,d),L=caml_parse_digit(q);if(L<0||L>=10)break;if(z=!1,caml_int64_ult(N,V)||(L=caml_int64_of_int32(L),V=caml_int64_add(caml_int64_mul(P,V),L),caml_int64_ult(V,L)))return u}return z&&caml_failwith("int_of_string"),w&&(V=caml_int64_neg(V)),V.hi=V.hi>>>0,V}var UInt32=function(){function _(u){this.value=u>>>0}return _.prototype.caml_custom="integers:uint32",_}();function integers_uint32_of_int64(_){return new UInt32(caml_int64_to_int32(_))}function integers_uint32_of_string(_){var u=caml_int64_create_lo_mi_hi(16777215,16777215,65535);return integers_uint32_of_int64(integers_uint_of_string(_,u))}function integers_uint16_of_string(_){var u=integers_uint32_of_string(_);return u.value&65535}function integers_uint32_add(_,u){return new UInt32(_.value+u.value)}function integers_uint32_div(_,u){return new UInt32(_.value/u.value)}function integers_uint32_logand(_,u){return new UInt32(_.value&u.value)}function integers_uint32_logor(_,u){return new UInt32(_.value|u.value)}function integers_uint32_logxor(_,u){return new UInt32(_.value^u.value)}function integers_uint32_max(_){return new UInt32(4294967295)}function integers_uint32_to_int64(_){return caml_int64_create_lo_mi_hi(_.value&16777215,_.value>>>24&16777215,0)}function integers_uint32_mul(_,u){var d=integers_uint32_to_int64(_),$=integers_uint32_to_int64(u);return new UInt32(caml_int64_to_int32(caml_int64_mul(d,$)))}function integers_uint32_of_int(_){return new UInt32(_)}function integers_uint32_of_int32(_){return new UInt32(_)}function integers_uint32_rem(_,u){return u.value==0&&caml_raise_zero_divide(),new UInt32(_.value%u.value)}function integers_uint32_shift_left(_,u){return new UInt32(_.value<>>u)}function integers_uint32_sub(_,u){return new UInt32(_.value-u.value)}function integers_uint32_to_int(_){return _.value|0}function caml_new_string(_){return caml_string_of_jsbytes(_)}function integers_uint32_to_string(_){return caml_new_string(_.value.toString())}var UInt64=function(){function _(u){this.value=u}return _.prototype.caml_custom="integers:uint64",_}();function integers_uint64_add(_,u){return new UInt64(caml_int64_add(_.value,u.value))}function integers_uint64_div(_,u){return u.value.isZero()&&caml_raise_zero_divide(),_.value.hi=_.value.hi>>>0,u.value.hi=u.value.hi>>>0,new UInt64(_.value.udivmod(u.value).quotient)}function integers_uint64_logand(_,u){return new UInt64(caml_int64_and(_.value,u.value))}function integers_uint64_logor(_,u){return new UInt64(caml_int64_or(_.value,u.value))}function integers_uint64_logxor(_,u){return new UInt64(caml_int64_xor(_.value,u.value))}function integers_uint64_max(_){var u=caml_int64_create_lo_mi_hi(16777215,16777215,65535);return u.hi=u.hi>>>0,new UInt64(u)}function integers_uint64_mul(_,u){return new UInt64(caml_int64_mul(_.value,u.value))}function integers_uint64_of_int(_){return new UInt64(caml_int64_of_int32(_))}function integers_uint64_of_int64(_){return new UInt64(caml_int64_create_lo_mi_hi(_.lo,_.mi,_.hi>>>0))}function integers_uint64_of_string(_){var u=caml_int64_create_lo_mi_hi(16777215,16777215,65535);return new UInt64(integers_uint_of_string(_,u))}function integers_uint64_of_uint32(_){return new UInt64(caml_int64_of_int32(_))}function integers_uint64_rem(_,u){return u.value.isZero()&&caml_raise_zero_divide(),_.value.hi=_.value.hi>>>0,u.value.hi=u.value.hi>>>0,new UInt64(_.value.udivmod(u.value).modulus)}function integers_uint64_shift_left(_,u){return new UInt64(caml_int64_shift_left(_.value,u))}function integers_uint64_shift_right(_,u){return new UInt64(caml_int64_shift_right_unsigned(_.value,u))}function integers_uint64_sub(_,u){return new UInt64(caml_int64_sub(_.value,u.value))}function integers_uint64_to_int(_){return caml_int64_to_int32(_.value)}function integers_uint64_to_int64(_){return _=_.value,caml_int64_create_lo_mi_hi(_.lo,_.mi,_.hi|0)}function integers_uint64_to_string(_){return caml_int64_format(caml_new_string("%u"),_.value)}function integers_uint8_of_string(_){var u=integers_uint32_of_string(_);return _.value&255}function integers_uint_size(_){return 4}function integers_ulong_size(_){return 4}function integers_ulonglong_size(_){return 8}function integers_uint8_deserialize(_,u){return u[0]=1,_.read8u()}function integers_uint16_deserialize(_,u){return u[0]=2,_.read16u()}function integers_uint32_serialize(_,u,d){_.write(32,u.value),d[0]=4,d[1]=4}function integers_uint32_deserialize(_,u){return u[0]=4,new UInt32(_.read32u())}function integers_uint32_hash(_){return _.value}function integers_uint32_compare(_,u){return _.value>u.value?1:_.value>>0,u.value.hi=u.value.hi>>>0,_.value.ucompare(u.value)}function integers_uint64_hash(_){return caml_int64_hash(_.value)}function integers_uint64_marshal(_,u,d){caml_int64_marshal(_,u.value,d)}function integers_uint64_unmarshal(_,u){return new UInt64(caml_int64_unmarshal(_,u))}function integers_unsigned_init(_){return caml_custom_ops["integers:uint8"]={deserialize:integers_uint8_deserialize,fixed_length:1},caml_custom_ops["integers:uint16"]={deserialize:integers_uint16_deserialize,fixed_length:2},caml_custom_ops["integers:uint32"]={serialize:integers_uint32_serialize,deserialize:integers_uint32_deserialize,fixed_length:4,hash:integers_uint32_hash,compare:integers_uint32_compare},caml_custom_ops["integers:uint64"]={serialize:integers_uint64_marshal,deserialize:integers_uint64_unmarshal,hash:integers_uint64_hash,compare:integers_uint64_compare},_}function integers_ushort_size(_){return 4}function is_digit_int(_,u){return _.data[u]>=0?1:0}function is_digit_zero(_,u){return _.data[u]==0?1:0}function land_digit_nat(_,u,d,$){return _.data[u]&=d.data[$],0}function lor_digit_nat(_,u,d,$){return _.data[u]|=d.data[$],0}var bigInt=function(_){"use strict";var u=1e7,d=7,$=9007199254740992,w=R($),q="0123456789abcdefghijklmnopqrstuvwxyz",z=joo_global_object.BigInt,P=typeof z=="function";function N(k_,M_,h_,G_){return typeof k_>"u"?N[0]:typeof M_<"u"?+M_==10&&!h_?U_(k_):W_(k_,M_,h_,G_):U_(k_)}function V(k_,M_){this.value=k_,this.sign=M_,this.isSmall=!1,this.caml_custom="_z"}V.prototype=Object.create(N.prototype);function L(k_){this.value=k_,this.sign=k_<0,this.isSmall=!0,this.caml_custom="_z"}L.prototype=Object.create(N.prototype);function U(k_){this.value=k_,this.caml_custom="_z"}U.prototype=Object.create(N.prototype);function Y(k_){return-$0?Math.floor(k_):Math.ceil(k_)}function J(k_,M_){var h_=k_.length,G_=M_.length,D_=new Array(h_),H_=0,J_=u,R_,I_;for(I_=0;I_=J_?1:0,D_[I_]=R_-H_*J_;for(;I_0&&D_.push(H_),D_}function I(k_,M_){return k_.length>=M_.length?J(k_,M_):J(M_,k_)}function Q(k_,M_){var h_=k_.length,G_=new Array(h_),D_=u,H_,J_;for(J_=0;J_0;)G_[J_++]=M_%D_,M_=Math.floor(M_/D_);return G_}V.prototype.add=function(k_){var M_=U_(k_);if(this.sign!==M_.sign)return this.subtract(M_.negate());var h_=this.value,G_=M_.value;return M_.isSmall?new V(Q(h_,Math.abs(G_)),this.sign):new V(I(h_,G_),this.sign)},V.prototype.plus=V.prototype.add,L.prototype.add=function(k_){var M_=U_(k_),h_=this.value;if(h_<0!==M_.sign)return this.subtract(M_.negate());var G_=M_.value;if(M_.isSmall){if(Y(h_+G_))return new L(h_+G_);G_=R(Math.abs(G_))}return new V(Q(G_,Math.abs(h_)),h_<0)},L.prototype.plus=L.prototype.add,U.prototype.add=function(k_){return new U(this.value+U_(k_).value)},U.prototype.plus=U.prototype.add;function __(k_,M_){var h_=k_.length,G_=M_.length,D_=new Array(h_),H_=0,J_=u,R_,I_;for(R_=0;R_=0?G_=__(k_,M_):(G_=__(M_,k_),h_=!h_),G_=W(G_),typeof G_=="number"?(h_&&(G_=-G_),new L(G_)):new V(G_,h_)}function e_(k_,M_,h_){var G_=k_.length,D_=new Array(G_),H_=-M_,J_=u,R_,I_;for(R_=0;R_=0)},L.prototype.minus=L.prototype.subtract,U.prototype.subtract=function(k_){return new U(this.value-U_(k_).value)},U.prototype.minus=U.prototype.subtract,V.prototype.negate=function(){return new V(this.value,!this.sign)},L.prototype.negate=function(){var k_=this.sign,M_=new L(-this.value);return M_.sign=!k_,M_},U.prototype.negate=function(){return new U(-this.value)},V.prototype.abs=function(){return new V(this.value,!1)},L.prototype.abs=function(){return new L(Math.abs(this.value))},U.prototype.abs=function(){return new U(this.value>=0?this.value:-this.value)};function r_(k_,M_){var h_=k_.length,G_=M_.length,D_=h_+G_,H_=G(D_),J_=u,R_,I_,e0,a0,_0;for(e0=0;e00;)G_[R_++]=H_%D_,H_=Math.floor(H_/D_);return G_}function a_(k_,M_){for(var h_=[];M_-- >0;)h_.push(0);return h_.concat(k_)}function c_(k_,M_){var h_=Math.max(k_.length,M_.length);if(h_<=30)return r_(k_,M_);h_=Math.ceil(h_/2);var G_=k_.slice(h_),D_=k_.slice(0,h_),H_=M_.slice(h_),J_=M_.slice(0,h_),R_=c_(D_,J_),I_=c_(G_,H_),e0=c_(I(D_,G_),I(J_,H_)),a0=I(I(R_,a_(__(__(e0,R_),I_),h_)),a_(I_,2*h_));return K(a0),a0}function l_(k_,M_){return-(.012*k_)-.012*M_+15e-6*k_*M_>0}V.prototype.multiply=function(k_){var M_=U_(k_),h_=this.value,G_=M_.value,D_=this.sign!==M_.sign,H_;if(M_.isSmall){if(G_===0)return N[0];if(G_===1)return this;if(G_===-1)return this.negate();if(H_=Math.abs(G_),H_=0;_0--){for(a0=D_-1,I_[_0+G_]!==J_&&(a0=Math.floor((I_[_0+G_]*D_+I_[_0+G_-1])/J_)),Q_=0,r0=0,y0=e0.length,n0=0;n0G_&&(e0=(e0+1)*J_),R_=Math.ceil(e0/a0);do{if(_0=n_(M_,R_),p_(_0,H_)<=0)break;R_--}while(R_);D_.push(R_),H_=__(H_,_0)}return D_.reverse(),[W(D_),W(H_)]}function m_(k_,M_){var h_=k_.length,G_=G(h_),D_=u,H_,J_,R_,I_;for(R_=0,H_=h_-1;H_>=0;--H_)I_=R_*D_+k_[H_],J_=X(I_/M_),R_=I_-J_*M_,G_[H_]=J_|0;return[G_,R_|0]}function b_(k_,M_){var h_,G_=U_(M_);if(P)return[new U(k_.value/G_.value),new U(k_.value%G_.value)];var D_=k_.value,H_=G_.value,J_;if(H_===0)throw new Error("Cannot divide by zero");if(k_.isSmall)return G_.isSmall?[new L(X(D_/H_)),new L(D_%H_)]:[N[0],k_];if(G_.isSmall){if(H_===1)return[k_,N[0]];if(H_==-1)return[k_.negate(),N[0]];var R_=Math.abs(H_);if(R_M_.length?1:-1;for(var h_=k_.length-1;h_>=0;h_--)if(k_[h_]!==M_[h_])return k_[h_]>M_[h_]?1:-1;return 0}V.prototype.compareAbs=function(k_){var M_=U_(k_),h_=this.value,G_=M_.value;return M_.isSmall?1:p_(h_,G_)},L.prototype.compareAbs=function(k_){var M_=U_(k_),h_=Math.abs(this.value),G_=M_.value;return M_.isSmall?(G_=Math.abs(G_),h_===G_?0:h_>G_?1:-1):-1},U.prototype.compareAbs=function(k_){var M_=this.value,h_=U_(k_).value;return M_=M_>=0?M_:-M_,h_=h_>=0?h_:-h_,M_===h_?0:M_>h_?1:-1},V.prototype.compare=function(k_){if(k_===1/0)return-1;if(k_===-1/0)return 1;var M_=U_(k_),h_=this.value,G_=M_.value;return this.sign!==M_.sign?M_.sign?1:-1:M_.isSmall?this.sign?-1:1:p_(h_,G_)*(this.sign?-1:1)},V.prototype.compareTo=V.prototype.compare,L.prototype.compare=function(k_){if(k_===1/0)return-1;if(k_===-1/0)return 1;var M_=U_(k_),h_=this.value,G_=M_.value;return M_.isSmall?h_==G_?0:h_>G_?1:-1:h_<0!==M_.sign?h_<0?-1:1:h_<0?1:-1},L.prototype.compareTo=L.prototype.compare,U.prototype.compare=function(k_){if(k_===1/0)return-1;if(k_===-1/0)return 1;var M_=this.value,h_=U_(k_).value;return M_===h_?0:M_>h_?1:-1},U.prototype.compareTo=U.prototype.compare,V.prototype.equals=function(k_){return this.compare(k_)===0},U.prototype.eq=U.prototype.equals=L.prototype.eq=L.prototype.equals=V.prototype.eq=V.prototype.equals,V.prototype.notEquals=function(k_){return this.compare(k_)!==0},U.prototype.neq=U.prototype.notEquals=L.prototype.neq=L.prototype.notEquals=V.prototype.neq=V.prototype.notEquals,V.prototype.greater=function(k_){return this.compare(k_)>0},U.prototype.gt=U.prototype.greater=L.prototype.gt=L.prototype.greater=V.prototype.gt=V.prototype.greater,V.prototype.lesser=function(k_){return this.compare(k_)<0},U.prototype.lt=U.prototype.lesser=L.prototype.lt=L.prototype.lesser=V.prototype.lt=V.prototype.lesser,V.prototype.greaterOrEquals=function(k_){return this.compare(k_)>=0},U.prototype.geq=U.prototype.greaterOrEquals=L.prototype.geq=L.prototype.greaterOrEquals=V.prototype.geq=V.prototype.greaterOrEquals,V.prototype.lesserOrEquals=function(k_){return this.compare(k_)<=0},U.prototype.leq=U.prototype.lesserOrEquals=L.prototype.leq=L.prototype.lesserOrEquals=V.prototype.leq=V.prototype.lesserOrEquals,V.prototype.isEven=function(){return(this.value[0]&1)===0},L.prototype.isEven=function(){return(this.value&1)===0},U.prototype.isEven=function(){return(this.value&z(1))===z(0)},V.prototype.isOdd=function(){return(this.value[0]&1)===1},L.prototype.isOdd=function(){return(this.value&1)===1},U.prototype.isOdd=function(){return(this.value&z(1))===z(1)},V.prototype.isPositive=function(){return!this.sign},L.prototype.isPositive=function(){return this.value>0},U.prototype.isPositive=L.prototype.isPositive,V.prototype.isNegative=function(){return this.sign},L.prototype.isNegative=function(){return this.value<0},U.prototype.isNegative=L.prototype.isNegative,V.prototype.isUnit=function(){return!1},L.prototype.isUnit=function(){return Math.abs(this.value)===1},U.prototype.isUnit=function(){return this.abs().value===z(1)},V.prototype.isZero=function(){return!1},L.prototype.isZero=function(){return this.value===0},U.prototype.isZero=function(){return this.value===z(0)},V.prototype.isDivisibleBy=function(k_){var M_=U_(k_);return M_.isZero()?!1:M_.isUnit()?!0:M_.compareAbs(2)===0?this.isEven():this.mod(M_).isZero()},U.prototype.isDivisibleBy=L.prototype.isDivisibleBy=V.prototype.isDivisibleBy;function d_(k_){var M_=k_.abs();if(M_.isUnit())return!1;if(M_.equals(2)||M_.equals(3)||M_.equals(5))return!0;if(M_.isEven()||M_.isDivisibleBy(3)||M_.isDivisibleBy(5))return!1;if(M_.lesser(49))return!0}function g_(k_,M_){for(var h_=k_.prev(),G_=h_,D_=0,H_,J_,R_,I_;G_.isEven();)G_=G_.divide(2),D_++;_:for(R_=0;R_-$?new L(k_-1):new V(w,!0)},U.prototype.prev=function(){return new U(this.value-z(1))};for(var y_=[1];2*y_[y_.length-1]<=u;)y_.push(2*y_[y_.length-1]);var v_=y_.length,w_=y_[v_-1];function j_(k_){return Math.abs(k_)<=u}V.prototype.shiftLeft=function(k_){var M_=U_(k_).toJSNumber();if(!j_(M_))throw new Error(String(M_)+" is too large for shifting.");if(M_<0)return this.shiftRight(-M_);var h_=this;if(h_.isZero())return h_;for(;M_>=v_;)h_=h_.multiply(w_),M_-=v_-1;return h_.multiply(y_[M_])},U.prototype.shiftLeft=L.prototype.shiftLeft=V.prototype.shiftLeft,V.prototype.shiftRight=function(k_){var M_,h_=U_(k_).toJSNumber();if(!j_(h_))throw new Error(String(h_)+" is too large for shifting.");if(h_<0)return this.shiftLeft(-h_);for(var G_=this;h_>=v_;){if(G_.isZero()||G_.isNegative()&&G_.isUnit())return G_;M_=b_(G_,w_),G_=M_[1].isNegative()?M_[0].prev():M_[0],h_-=v_-1}return M_=b_(G_,y_[h_]),M_[1].isNegative()?M_[0].prev():M_[0]},U.prototype.shiftRight=L.prototype.shiftRight=V.prototype.shiftRight;function E_(k_,M_,h_){M_=U_(M_);for(var G_=k_.isNegative(),D_=M_.isNegative(),H_=G_?k_.not():k_,J_=D_?M_.not():M_,R_=0,I_=0,e0=null,a0=null,_0=[];!H_.isZero()||!J_.isZero();)e0=b_(H_,w_),R_=e0[1].toJSNumber(),G_&&(R_=w_-1-R_),a0=b_(J_,w_),I_=a0[1].toJSNumber(),D_&&(I_=w_-1-I_),H_=e0[0],J_=a0[0],_0.push(h_(R_,I_));for(var Q_=h_(G_?1:0,D_?1:0)!==0?bigInt(-1):bigInt(0),r0=_0.length-1;r0>=0;r0-=1)Q_=Q_.multiply(w_).add(bigInt(_0[r0]));return Q_}V.prototype.not=function(){return this.negate().prev()},U.prototype.not=L.prototype.not=V.prototype.not,V.prototype.and=function(k_){return E_(this,k_,function(M_,h_){return M_&h_})},U.prototype.and=L.prototype.and=V.prototype.and,V.prototype.or=function(k_){return E_(this,k_,function(M_,h_){return M_|h_})},U.prototype.or=L.prototype.or=V.prototype.or,V.prototype.xor=function(k_){return E_(this,k_,function(M_,h_){return M_^h_})},U.prototype.xor=L.prototype.xor=V.prototype.xor;var L_=1<<30,z_=(u&-u)*(u&-u)|L_;function Y_(k_){var M_=k_.value,h_=typeof M_=="number"?M_|L_:typeof M_=="bigint"?M_|z(L_):M_[0]+M_[1]*u|z_;return h_&-h_}function O_(k_,M_){if(M_.compareTo(k_)<=0){var h_=O_(k_,M_.square(M_)),G_=h_.p,D_=h_.e,H_=G_.multiply(M_);return H_.compareTo(k_)<=0?{p:H_,e:D_*2+1}:{p:G_,e:D_*2}}return{p:bigInt(1),e:0}}V.prototype.bitLength=function(){var k_=this;return k_.compareTo(bigInt(0))<0&&(k_=k_.negate().subtract(bigInt(1))),k_.compareTo(bigInt(0))===0?bigInt(0):bigInt(O_(k_,bigInt(2)).e).add(bigInt(1))},U.prototype.bitLength=L.prototype.bitLength=V.prototype.bitLength;function N_(k_,M_){return k_=U_(k_),M_=U_(M_),k_.greater(M_)?k_:M_}function F_(k_,M_){return k_=U_(k_),M_=U_(M_),k_.lesser(M_)?k_:M_}function T_(k_,M_){if(k_=U_(k_).abs(),M_=U_(M_).abs(),k_.equals(M_))return k_;if(k_.isZero())return M_;if(M_.isZero())return k_;for(var h_=N[1],G_,D_;k_.isEven()&&M_.isEven();)G_=F_(Y_(k_),Y_(M_)),k_=k_.divide(G_),M_=M_.divide(G_),h_=h_.multiply(G_);for(;k_.isEven();)k_=k_.divide(Y_(k_));do{for(;M_.isEven();)M_=M_.divide(Y_(M_));k_.greater(M_)&&(D_=M_,M_=k_,k_=D_),M_=M_.subtract(k_)}while(!M_.isZero());return h_.isUnit()?k_:k_.multiply(h_)}function Z_(k_,M_){return k_=U_(k_).abs(),M_=U_(M_).abs(),k_.divide(T_(k_,M_)).multiply(M_)}function B_(k_,M_){k_=U_(k_),M_=U_(M_);var h_=F_(k_,M_),G_=N_(k_,M_),D_=G_.subtract(h_).add(1);if(D_.isSmall)return h_.add(Math.floor(Math.random()*D_));for(var H_=P_(D_,u).value,J_=[],R_=!0,I_=0;I_=J_){if(I_==="1"&&J_===1)continue;throw new Error(I_+" is not a valid digit in base "+M_+".")}}M_=U_(M_);var e0=[],a0=k_[0]==="-";for(H_=a0?1:0;H_"&&H_=0;H_--)G_=G_.add(k_[H_].times(D_)),D_=D_.times(M_);return h_?G_.negate():G_}function A_(k_,M_){return M_=M_||q,k_"}function P_(k_,M_){if(M_=bigInt(M_),M_.isZero()){if(k_.isZero())return{value:[0],isNegative:!1};throw new Error("Cannot convert nonzero numbers to base 0.")}if(M_.equals(-1)){if(k_.isZero())return{value:[0],isNegative:!1};if(k_.isNegative())return{value:[].concat.apply([],Array.apply(null,Array(-k_.toJSNumber())).map(Array.prototype.valueOf,[1,0])),isNegative:!1};var h_=Array.apply(null,Array(k_.toJSNumber()-1)).map(Array.prototype.valueOf,[0,1]);return h_.unshift([1]),{value:[].concat.apply([],h_),isNegative:!1}}var G_=!1;if(k_.isNegative()&&M_.isPositive()&&(G_=!0,k_=k_.abs()),M_.isUnit())return k_.isZero()?{value:[0],isNegative:!1}:{value:Array.apply(null,Array(k_.toJSNumber())).map(Number.prototype.valueOf,1),isNegative:G_};for(var D_=[],H_=k_,J_;H_.isNegative()||H_.compareAbs(M_)>=0;){J_=H_.divmod(M_),H_=J_.quotient;var R_=J_.remainder;R_.isNegative()&&(R_=M_.minus(R_).abs(),H_=H_.next()),D_.push(R_.toJSNumber())}return D_.push(H_.toJSNumber()),{value:D_.reverse(),isNegative:G_}}function $_(k_,M_,h_){var G_=P_(k_,M_);return(G_.isNegative?"-":"")+G_.value.map(function(D_){return A_(D_,h_)}).join("")}V.prototype.toArray=function(k_){return P_(this,k_)},L.prototype.toArray=function(k_){return P_(this,k_)},U.prototype.toArray=function(k_){return P_(this,k_)},V.prototype.toString=function(k_,M_){if(k_===_&&(k_=10),k_!==10)return $_(this,k_,M_);for(var h_=this.value,G_=h_.length,D_=String(h_[--G_]),H_="0000000",J_;--G_>=0;)J_=String(h_[G_]),D_+=H_.slice(J_.length)+J_;var R_=this.sign?"-":"";return R_+D_},L.prototype.toString=function(k_,M_){return k_===_&&(k_=10),k_!=10?$_(this,k_,M_):String(this.value)},U.prototype.toString=L.prototype.toString,U.prototype.toJSON=V.prototype.toJSON=L.prototype.toJSON=function(){return this.toString()},V.prototype.valueOf=function(){return parseInt(this.toString(),10)},V.prototype.toJSNumber=V.prototype.valueOf,L.prototype.valueOf=function(){return this.value},L.prototype.toJSNumber=L.prototype.valueOf,U.prototype.valueOf=U.prototype.toJSNumber=function(){return parseInt(this.toString(),10)};function C_(k_){if(Y(+k_)){var M_=+k_;if(M_===X(M_))return P?new U(z(M_)):new L(M_);throw new Error("Invalid integer: "+k_)}var h_=k_[0]==="-";h_&&(k_=k_.slice(1));var G_=k_.split(/e/i);if(G_.length>2)throw new Error("Invalid integer: "+G_.join("e"));if(G_.length===2){var D_=G_[1];if(D_[0]==="+"&&(D_=D_.slice(1)),D_=+D_,D_!==X(D_)||!Y(D_))throw new Error("Invalid integer: "+D_+" is not a valid exponent.");var H_=G_[0],J_=H_.indexOf(".");if(J_>=0&&(D_-=H_.length-J_-1,H_=H_.slice(0,J_)+H_.slice(J_+1)),D_<0)throw new Error("Cannot include negative exponent part for integers");H_+=new Array(D_+1).join("0"),k_=H_}var R_=/^([0-9][0-9]*)$/.test(k_);if(!R_)throw new Error("Invalid integer: "+k_);if(P)return new U(z(h_?"-"+k_:k_));for(var I_=[],e0=k_.length,a0=d,_0=e0-a0;e0>0;)I_.push(+k_.slice(_0,e0)),_0-=a0,_0<0&&(_0=0),e0-=a0;return K(I_),new V(I_,h_)}function S_(k_){if(P)return new U(z(k_));if(Y(k_)){if(k_!==X(k_))throw new Error(k_+" is not an integer.");return new L(k_)}return C_(k_.toString())}function U_(k_){return typeof k_=="number"?S_(k_):typeof k_=="string"?C_(k_):typeof k_=="bigint"?new U(k_):k_}for(var K_=0;K_<1e3;K_++)N[K_]=U_(K_),K_>0&&(N[-K_]=U_(-K_));return N.one=N[1],N.zero=N[0],N.minusOne=N[-1],N.max=N_,N.min=F_,N.gcd=T_,N.lcm=Z_,N.isInstance=function(k_){return k_ instanceof V||k_ instanceof L||k_ instanceof U},N.randBetween=B_,N.fromArray=function(k_,M_,h_){return q_(k_.map(U_),U_(M_||10),h_)},N}();function ml_z_normalize(_){var u=_.toJSNumber()|0;return _.equals(bigInt(u))?u:_}function ml_z_abs(_){return ml_z_normalize(bigInt(_).abs())}function ml_z_add(_,u){return ml_z_normalize(bigInt(_).add(bigInt(u)))}function ml_z_compare(_,u){return bigInt(_).compare(bigInt(u))}function ml_z_div(_,u){return u=bigInt(u),u.equals(bigInt(0))&&caml_raise_zero_divide(),ml_z_normalize(bigInt(_).divide(bigInt(u)))}function ml_z_divexact(_,u){return ml_z_div(_,u)}function ml_z_equal(_,u){return bigInt(_).equals(bigInt(u))}function ml_z_fits_int(_){return _==(_|0)?1:0}function ml_z_fits_int32(_){return ml_z_fits_int(_)}function ml_z_format(d,u){u=bigInt(u);for(var d=caml_jsbytes_of_string(d),$=10,w=0,q=0,z=0,P=0,N="",V=" ",L=0,U="";d[L]=="%";)L++;for(;;L++)if(d[L]=="#")z=1;else if(d[L]=="0")V="0";else if(d[L]=="-")P=1;else if(d[L]==" "||d[L]=="+")N=d[L];else break;for(u.lt(bigInt(0))&&(N="-",u=u.negate());d[L]>="0"&&d[L]<="9";L++)q=10*q+ +d[L];switch(d[L]){case"i":case"d":case"u":break;case"b":$=2,z&&(U="0b");break;case"o":$=8,z&&(U="0o");break;case"x":$=16,z&&(U="0x");break;case"X":$=16,z&&(U="0X"),w=1;break;default:caml_failwith("Unsupported format '"+d+"'")}P&&(V=" ");var Y=u.toString($);w===1&&(Y=Y.toUpperCase());var R=Y.length;if(V==" ")if(P)for(Y=N+U+Y;Y.length=0;z--)_.write(8,$.value[z]>>>0&255),_.write(8,$.value[z]>>>8&255),_.write(8,$.value[z]>>>16&255),_.write(8,$.value[z]>>>24&255);d[0]=4*(1+((q+3)/4|0)),d[1]=8*(1+((q+7)/8|0))}function caml_zarith_unmarshal(_,u){var d;switch(_.read8u()){case 1:d=!0;break;case 0:d=!1;break;default:caml_failwith("input_value: z (malformed input)")}for(var $=_.read32u(),w=bigInt(0),q=0;q<$/4;q++){var z=bigInt(_.read8u());z=z.add(_.read8u()<<8),z=z.add(_.read8u()<<16),z=z.add(_.read8u()<<24>>>0),w=z.shiftLeft(q*32).add(w)}return d&&(w=w.negate()),u[0]=$+4,ml_z_normalize(w)}function ml_z_init(_){return caml_custom_ops._z={serialize:caml_zarith_marshal,deserialize:caml_zarith_unmarshal,hash:ml_z_hash,compare:ml_z_compare},0}function ml_z_logand(_,u){return ml_z_normalize(bigInt(_).and(bigInt(u)))}function ml_z_lognot(_){return ml_z_normalize(bigInt(_).not())}function ml_z_logor(_,u){return ml_z_normalize(bigInt(_).or(bigInt(u)))}function ml_z_logxor(_,u){return ml_z_normalize(bigInt(_).xor(bigInt(u)))}function ml_z_mul(_,u){return ml_z_normalize(bigInt(_).multiply(bigInt(u)))}function ml_z_neg(_){return ml_z_normalize(bigInt(_).negate())}function ml_z_numbits(_){_=bigInt(_).abs();for(var u=0,d=bigInt.one;d.leq(_);)u+=1,d=d.multiply(2);return u}function ml_z_of_bits(_){for(var u=bigInt.zero,d=bigInt(256),$=bigInt.one,w=0;w>>0,$=caml_int64_hi32(_)>>>0,w=bigInt(d).add(bigInt($).shiftLeft(32));return u&&(w=w.negate()),ml_z_normalize(w)}function ml_z_of_nativeint(_){return ml_z_of_int(_)}function jsoo_z_of_js_string_base(_,u){if(_==0){_=10;var d=0,$=1;if(u[d]=="-"?($=-1,d++):u[d]=="+"&&d++,u[d]=="0"){if(d++,u.length==d)return 0;var w=u[d];w=="o"||w=="O"?_=8:w=="x"||w=="X"?_=16:(w=="b"||w=="B")&&(_=2),_!=10&&(u=u.substring(d+1),$==-1&&(u="-"+u))}}u[0]=="+"&&(u=u.substring(1)),u=u.replace(/^0+/,""),(u=="-"||u=="")&&(u="0");function q(N){if(N>=48&&N<=57)return N-48;if(N>=97&&N<=102)return N-97+10;if(N>=65&&N<=70)return N-65+10}var z=0;for(u[z]=="-"&&z++;z=_)&&caml_invalid_argument("Z.of_substring_base: invalid digit")}return ml_z_normalize(bigInt(u,_))}function ml_z_of_substring_base(_,u,d,$){return u=caml_jsbytes_of_string(u),(d!=0||$!=u.length)&&(u.length-d<$&&caml_invalid_argument("Z.of_substring_base: invalid offset or length"),u=u.slice(d,d+$)),jsoo_z_of_js_string_base(_,u)}function ml_z_popcount(_){_=bigInt(_);var u=bigInt(0),d=bigInt(1);_.lt(u)&&caml_raise_constant(caml_named_value("ml_z_overflow"));var $;for($=0;!_.equals(u);$++)_=_.and(_.prev());return $!=($|0)&&caml_raise_constant(caml_named_value("ml_z_overflow")),$|0}function ml_z_pow(_,u){return u=bigInt(u),u.lt(bigInt(0))&&caml_invalid_argument("Z.pow: exponent must be nonnegative"),ml_z_normalize(bigInt(_).pow(u))}function ml_z_pred(_){return ml_z_normalize(bigInt(_).prev())}function ml_z_rem(_,u){return u=bigInt(u),u.equals(bigInt(0))&&caml_raise_zero_divide(),ml_z_normalize(bigInt(_).mod(u))}function ml_z_shift_left(_,u){return ml_z_normalize(bigInt(_).shiftLeft(u))}function ml_z_shift_right(_,u){return ml_z_normalize(bigInt(_).shiftRight(u))}function ml_z_sign(_){return bigInt(_).compare(bigInt.zero)}function ml_z_sub(_,u){return ml_z_normalize(bigInt(_).subtract(bigInt(u)))}function ml_z_succ(_){return ml_z_normalize(bigInt(_).next())}function ml_z_testbit(_,u){return _=bigInt(_),_.shiftRight(u).and(bigInt(1)).toJSNumber()|0}function ml_z_to_bits(_){_=bigInt(_).abs();for(var u="";!_.equals(bigInt(0));)u+=String.fromCharCode(_.mod(bigInt(256))),_=_.divide(bigInt(256));for(;u.length%4!=0;)u+=String.fromCharCode(0);return caml_string_of_jsbytes(u)}function ml_z_to_int(_){if(_==(_|0))return _|0;caml_raise_constant(caml_named_value("ml_z_overflow"))}function ml_z_to_int32(_){return ml_z_to_int(_)}function ml_z_fits_int64(_){return _=bigInt(_),_.compare(bigInt("9223372036854775807"))<=0&&_.compare(bigInt("-9223372036854775808"))>=0?1:0}function ml_z_to_int64(_){_=bigInt(_),ml_z_fits_int64(_)||caml_raise_constant(caml_named_value("ml_z_overflow"));var u=bigInt(4294967295),d=_.and(u).toJSNumber(),$=_.shiftRight(32).and(u).toJSNumber(),w=caml_int64_create_lo_hi(d,$);return w}function ml_z_to_nativeint(_){return ml_z_to_int(_)}function mult_nat(_,u,d,$,w,q,z,P,N){for(var V=0,L=0;L"),null$3=caml_string_of_jsbytes(""),tp_loc$0=caml_string_of_jsbytes("shape/src/bin_shape.ml.Sorted_table.t"),tp_loc$1=caml_string_of_jsbytes("shape/src/bin_shape.ml.Canonical_exp_constructor.t"),tp_loc$2=caml_string_of_jsbytes("shape/src/bin_shape.ml.Canonical_full.Exp1.t0"),loc$0=caml_string_of_jsbytes("blit_buf_string"),loc=caml_string_of_jsbytes("blit_string_buf"),enable_everything=[0,0,0],am_running_inline_test_env_var=caml_string_of_jsbytes("TESTING_FRAMEWORK"),flags=[0,0,0],flags$0=[0,1,[0,3,0]],am_recording_environment_varia=caml_string_of_jsbytes("PPX_MODULE_TIMER"),name$2=caml_string_of_jsbytes("int"),name$3=caml_string_of_jsbytes("int32"),name$4=caml_string_of_jsbytes("int64"),name$5=caml_string_of_jsbytes("nativeint"),name$6=caml_string_of_jsbytes("char"),name$7=caml_string_of_jsbytes("float"),name$8=caml_string_of_jsbytes("string"),name$9=caml_string_of_jsbytes("bytes"),name$10=caml_string_of_jsbytes("bool"),name$11=caml_string_of_jsbytes("unit"),name$12=caml_string_of_jsbytes("option"),name$13=caml_string_of_jsbytes("list"),name$14=caml_string_of_jsbytes("array"),name$15=caml_string_of_jsbytes("lazy_t"),name$16=caml_string_of_jsbytes("ref"),name$17=caml_string_of_jsbytes("function"),name$18=caml_string_of_jsbytes("tuple0"),name$19=caml_string_of_jsbytes("tuple2"),name$20=caml_string_of_jsbytes("tuple3"),name$21=caml_string_of_jsbytes("tuple4"),name$22=caml_string_of_jsbytes("tuple5"),ocaml_lex_tables$0=[0,caml_string_of_jsbytes(`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\0\0\f\0\0\0\0\0\0\0\0\x1B\0\0\0\0\0U\0\xFD\xFF\xFE\xFF\0.\0/\0(\0\0.\x000\0\x07\0O\0\0>\0\b\0\xFF\xFF \0C\0C\0g\0d\0i\0_\0k\0_\0q\0 \0h\0h\0t\0h\0z\0h\0t\0o\0q\0\v\0t\0u\0}\0\x7F\0\f\0~\0s\0w\0z\0\r\0`),caml_string_of_jsbytes("\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"),caml_string_of_jsbytes("\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF/\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"),caml_string_of_jsbytes(`\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\b\0\f\0\0\0\f\0'\0\f\x007\0;\0=\0G\0;\0V\0;\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x001\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"\0\0\0\x07\0\0 \0 \0\0\0\0\0\0\0\x1B\0\0\0\0\0\0\v\0\0\0\0\0\r\0\0 \0!\0#\0$\0%\0&\0(\0)\0*\0+\0.\0.\0.\0.\0.\0.\0.\0.\0.\0.\0Q\x002\x003\x004\x005\x006\0<\0.\0.\0.\0.\0.\0.\0.\0.\0.\0.\0.\0.\0.\0.\0.\0.\0.\0.\0.\0.\0.\0.\0.\0.\0.\0.\x009\x008\0:\0>\0.\0?\0.\0.\0.\0.\0.\0.\0.\0.\0.\0.\0.\0.\0.\0.\0.\0.\0.\0.\0.\0.\0.\0.\0.\0.\0.\0.\0@\0A\0B\0C\0D\0E\0F\0H\0I\0J\0K\0L\0M\0N\0O\0P\0R\0S\0T\0U\0W\0X\0Y\0Z\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0-\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`),caml_string_of_jsbytes(`\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x07\0\v\0\r\0\0!\0&\0+\x006\0:\0<\0F\0P\0U\0Z\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0/\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0/\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\b\0\b\0\0\0\0\0\0\0\0\0\0\0\0\0 \0\0\0\x1B\0\0 \0\0\0 \0"\0#\0$\0%\0'\0(\0)\0*\0,\0,\0,\0,\0,\0,\0,\0,\0,\0,\x000\x001\x002\x003\x004\x005\x008\0,\0,\0,\0,\0,\0,\0,\0,\0,\0,\0,\0,\0,\0,\0,\0,\0,\0,\0,\0,\0,\0,\0,\0,\0,\0,\x007\x007\x009\0=\0,\0>\0,\0,\0,\0,\0,\0,\0,\0,\0,\0,\0,\0,\0,\0,\0,\0,\0,\0,\0,\0,\0,\0,\0,\0,\0,\0,\0?\0@\0A\0B\0C\0D\0E\0G\0H\0I\0J\0K\0L\0M\0N\0O\0Q\0R\0S\0T\0V\0W\0X\0Y\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF,\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`),caml_string_of_jsbytes(""),caml_string_of_jsbytes(""),caml_string_of_jsbytes(""),caml_string_of_jsbytes(""),caml_string_of_jsbytes(""),caml_string_of_jsbytes("")],int64$1=caml_int64_create_lo_mi_hi(1,0,0),golden_gamma=caml_int64_create_lo_mi_hi(4881429,7977343,40503),beginning_of_file=[0,1,0,0],ws_buf=caml_string_of_jsbytes(" "),loc$1=caml_string_of_jsbytes("of_string"),name$24=caml_string_of_jsbytes("src/import.ml.sexp_opaque"),err$2=[2,caml_string_of_jsbytes("src/perms.ml.Types.Read_write.t")],err$1=[2,caml_string_of_jsbytes("src/perms.ml.Types.Immutable.t")],err$0=[2,caml_string_of_jsbytes("src/perms.ml.Types.Write.t")],err=[2,caml_string_of_jsbytes("src/perms.ml.Types.Read.t")],tp_loc$3=caml_string_of_jsbytes("src/perms.ml.Types.Nobody.t"),name$25=caml_string_of_jsbytes("Nobody"),tp_loc$4=caml_string_of_jsbytes("src/perms.ml.Types.Me.t"),name$26=caml_string_of_jsbytes("Me"),loc$2=caml_string_of_jsbytes("src/perms.ml.Types.Read.t"),tp_loc$5=caml_string_of_jsbytes("src/perms.ml.Types.Read.t"),name$27=caml_string_of_jsbytes("Read"),tp_loc$6=caml_string_of_jsbytes("src/perms.ml.Types.Write.t"),tp_loc$7=caml_string_of_jsbytes("src/perms.ml.Types.Write.t"),name$28=caml_string_of_jsbytes("Write"),tp_loc$8=caml_string_of_jsbytes("src/perms.ml.Types.Immutable.t"),tp_loc$9=caml_string_of_jsbytes("src/perms.ml.Types.Immutable.t"),name$29=caml_string_of_jsbytes("Immutable"),tp_loc$10=caml_string_of_jsbytes("src/perms.ml.Types.Read_write.t"),name$30=caml_string_of_jsbytes("Read_write"),name$31=caml_string_of_jsbytes("Upper_bound"),name$32=caml_string_of_jsbytes("src/array.ml.t"),name$33=caml_string_of_jsbytes("src/array.ml.Permissioned.t"),tp_loc$11=caml_string_of_jsbytes("src/source_code_position0.ml.Stable.V1.t"),name$34=caml_string_of_jsbytes("src/list0.ml.t"),caller_identity$0=caml_string_of_jsbytes("8fabab0a-4992-11e6-8cca-9ba2c4686d9e"),module_name$20=[0,caml_string_of_jsbytes("Core_kernel.Hashtbl")],caller_identity=caml_string_of_jsbytes("8f3e445c-4992-11e6-a279-3703be311e7b"),module_name$19=[0,caml_string_of_jsbytes("Core_kernel.Hashtbl")],caller_identity$1=caml_string_of_jsbytes("ad381672-4992-11e6-9e36-b76dc8cd466f"),module_name$21=[0,caml_string_of_jsbytes("Core_kernel.Hash_set")],default_seed=[0,-825553486,caml_string_of_jsbytes("an arbitrary but deterministic string")],default_shrink_attempts=[0,137269019,1e3],caller_identity$2=caml_string_of_jsbytes("dfb300f8-4992-11e6-9c15-73a2ac6b815c"),module_name$22=[0,caml_string_of_jsbytes("Core_kernel.Map")],caller_identity$3=caml_string_of_jsbytes("8989278e-4992-11e6-8f4a-6b89776b1e53"),module_name$23=[0,caml_string_of_jsbytes("Core_kernel.Set")],name$35=caml_string_of_jsbytes("src/option.ml.t"),name$36=caml_string_of_jsbytes("src/bool.ml.t"),name$37=caml_string_of_jsbytes("src/string.ml.t"),name$38=caml_string_of_jsbytes("src/bytes.ml.Stable.V1.t"),name$39=caml_string_of_jsbytes("src/char.ml.t"),name$40=caml_string_of_jsbytes("src/sign.ml.Stable.V1.t"),name$41=caml_string_of_jsbytes("src/float.ml.T.t"),name$42=caml_string_of_jsbytes("src/int.ml.t"),name$43=caml_string_of_jsbytes("src/int.ml.Hex.t"),name$44=caml_string_of_jsbytes("src/int32.ml.t"),name$45=caml_string_of_jsbytes("src/int32.ml.Hex.t"),name$46=caml_string_of_jsbytes("src/int64.ml.t"),name$47=caml_string_of_jsbytes("src/int64.ml.Hex.t"),name$48=caml_string_of_jsbytes("src/int63.ml.Hex.t"),name$49=caml_string_of_jsbytes("src/unit.ml.t"),name$50=caml_string_of_jsbytes("src/lazy.ml.Stable.V1.t"),name$51=caml_string_of_jsbytes("src/nativeint.ml.t"),name$52=caml_string_of_jsbytes("src/nativeint.ml.Hex.t"),name$53=caml_string_of_jsbytes("src/ref.ml.T.t"),name$54=caml_string_of_jsbytes("src/std_internal.ml.array"),name$55=caml_string_of_jsbytes("src/std_internal.ml.bool"),name$56=caml_string_of_jsbytes("src/std_internal.ml.char"),name$57=caml_string_of_jsbytes("src/std_internal.ml.float"),name$58=caml_string_of_jsbytes("src/std_internal.ml.int"),name$59=caml_string_of_jsbytes("src/std_internal.ml.int32"),name$60=caml_string_of_jsbytes("src/std_internal.ml.int64"),name$61=caml_string_of_jsbytes("src/std_internal.ml.lazy_t"),name$62=caml_string_of_jsbytes("src/std_internal.ml.list"),name$63=caml_string_of_jsbytes("src/std_internal.ml.nativeint"),name$64=caml_string_of_jsbytes("src/std_internal.ml.option"),name$65=caml_string_of_jsbytes("src/std_internal.ml.string"),name$66=caml_string_of_jsbytes("src/std_internal.ml.bytes"),name$67=caml_string_of_jsbytes("src/std_internal.ml.ref"),name$68=caml_string_of_jsbytes("src/std_internal.ml.unit"),name$69=caml_string_of_jsbytes("src/std_internal.ml.float_array"),name$70=caml_string_of_jsbytes("src/std_internal.ml.sexp_array"),name$71=caml_string_of_jsbytes("src/std_internal.ml.sexp_bool"),name$72=caml_string_of_jsbytes("src/std_internal.ml.sexp_list"),name$73=caml_string_of_jsbytes("src/std_internal.ml.sexp_option"),name$74=caml_string_of_jsbytes("src/std_internal.ml.sexp_opaque"),unit_of_time_list=[0,0,[0,1,[0,2,[0,3,[0,4,[0,5,[0,6,0]]]]]]],name$76=caml_string_of_jsbytes("src/tuple.ml.T2.t"),name$77=caml_string_of_jsbytes("src/tuple.ml.T3.t"),name$80=caml_string_of_jsbytes("read_int63_decimal"),name$79=caml_string_of_jsbytes("write_int63"),name$78=caml_string_of_jsbytes("read_int63_decimal"),module_name$24=caml_string_of_jsbytes("Digit_string_helpers"),tp_loc$13=caml_string_of_jsbytes("src/month.ml.Stable.V1.t"),all$2=caml_list_of_js_array([0,1,2,3,4,5,6,7,8,9,10,11]),name$81=caml_string_of_jsbytes("src/date0.ml.Stable.V1.Without_comparable.T.t"),tp_loc$14=caml_string_of_jsbytes("src/date0.ml.Stable.V1.Without_comparable.Sexpable.Old_date.t"),name$82=caml_string_of_jsbytes("src/date0.ml.Stable.Option.V1.t"),module_name$25=caml_string_of_jsbytes("Core_kernel.Date"),name$83=caml_string_of_jsbytes("src/percent.ml.Stable.V1.t"),name$84=caml_string_of_jsbytes("src/percent.ml.Stable.Option.V1.t"),suffix$0=caml_string_of_jsbytes("ns"),suffix$1=caml_string_of_jsbytes("us"),suffix$2=caml_string_of_jsbytes("ms"),suffix$3=caml_string_of_jsbytes("s"),suffix$4=caml_string_of_jsbytes("m"),suffix$5=caml_string_of_jsbytes("h"),suffix$6=caml_string_of_jsbytes("d"),suffix=caml_string_of_jsbytes("."),tp_loc$15=caml_string_of_jsbytes("src/span_float.ml.Stable.V1.Parts.t"),module_name$26=caml_string_of_jsbytes("Core_kernel.Time.Span"),module_name$27=caml_string_of_jsbytes("Core_kernel.Time.Ofday"),utc_offset=[0,0],suffix$7=caml_string_of_jsbytes("ns"),suffix$8=caml_string_of_jsbytes("us"),suffix$9=caml_string_of_jsbytes("ms"),suffix$10=caml_string_of_jsbytes("s"),suffix$11=caml_string_of_jsbytes("m"),suffix$12=caml_string_of_jsbytes("h"),suffix$13=caml_string_of_jsbytes("d"),module_name$28=caml_string_of_jsbytes("Core_kernel.Time_ns.Span"),name$85=caml_string_of_jsbytes("src/span_ns.ml.T.t"),name$86=caml_string_of_jsbytes("src/ofday_ns.ml.t"),module_name$29=caml_string_of_jsbytes("Core.Time_ns.Ofday"),name$87=caml_string_of_jsbytes("src/time_ns.ml.t"),tp_loc$16=caml_string_of_jsbytes("src/gc.ml.Stat.T.t"),tp_loc$17=caml_string_of_jsbytes("src/gc.ml.Control.T.t"),atom=[0,0],record$1=[0,1,1,0,1,1,1,1,-921200851,2,0,0,0,0,0],label=[0,726666127,1,2,0],ocaml_lex_tables$1=[0,caml_string_of_jsbytes(`\0\0\xEC\xFF\xED\xFF\0\xEF\xFF\0\xF2\xFF\xF3\xFF\xF4\xFF\xF5\xFF\0\0\0\xF9\xFFU\0\0\0\0\0\0\0\0\0\0\0\xFF\xFF\0\0\0\0\0\xFE\xFF\0\0\xFD\xFF\v\0\xFC\xFF\0\0\0\0\0\0\0\xFB\xFF\0a\0